1 // PARAVIS : ParaView wrapper SALOME module
3 // Copyright (C) 2010-2013 CEA/DEN, EDF R&D
5 // This library is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU Lesser General Public
7 // License as published by the Free Software Foundation; either
8 // version 2.1 of the License.
10 // This library is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 // Lesser General Public License for more details.
15 // You should have received a copy of the GNU Lesser General Public
16 // License along with this library; if not, write to the Free Software
17 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 // File : PVGUI_Module.cxx
22 // Author : Julia DOROVSKIKH
24 #include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
26 #undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
28 #include <vtkPython.h> // Python first
29 #include "PVGUI_Module.h"
31 #include "SALOMEconfig.h"
33 #include CORBA_CLIENT_HEADER(VISU_Gen)
35 #include CORBA_SERVER_HEADER(SALOMEDS)
38 #include "PARAVIS_Gen_i.hh"
42 #include "PVGUI_ViewModel.h"
43 #include "PVGUI_ViewManager.h"
44 #include "PVGUI_ViewWindow.h"
45 #include "PVGUI_Tools.h"
46 #include "PVGUI_ParaViewSettingsPane.h"
47 #include "PVGUI_OutputWindowAdapter.h"
49 #include <SUIT_DataBrowser.h>
50 #include <SUIT_Desktop.h>
51 #include <SUIT_MessageBox.h>
52 #include <SUIT_ResourceMgr.h>
53 #include <SUIT_Session.h>
54 #include <SUIT_OverrideCursor.h>
55 #include <SUIT_ExceptionHandler.h>
58 #include "SALOME_LifeCycleCORBA.hxx"
59 #include "SALOMEDS_SObject.hxx"
61 #include "LightApp_SelectionMgr.h"
62 #include "LightApp_NameDlg.h"
64 #include <SalomeApp_Application.h>
65 #include <SalomeApp_Study.h>
66 #include <SALOME_ListIO.hxx>
67 #include <SALOMEDS_Tool.hxx>
68 #include <PyInterp_Dispatcher.h>
70 #include <QtxActionMenuMgr.h>
71 #include <QtxActionToolMgr.h>
74 #include <QApplication>
80 #include <QInputDialog>
84 #include <QStringList>
87 #include <QTextStream>
89 #include <QDockWidget>
90 #include <QHelpEngine>
92 #include <pqApplicationCore.h>
93 #include <pqPVApplicationCore.h>
94 #include <pqActiveView.h>
95 #include <pqObjectBuilder.h>
96 #include <pqOptions.h>
97 #include <pqRenderView.h>
99 #include <pqUndoStack.h>
100 #include <pqVCRController.h>
101 #include <pqTabbedMultiViewWidget.h>
102 #include <pqPipelineSource.h>
103 #include <pqActiveObjects.h>
104 #include <vtkProcessModule.h>
105 #include <vtkSMSession.h>
106 #include <vtkPVSession.h>
107 #include <vtkPVProgressHandler.h>
108 #include <pqParaViewBehaviors.h>
109 #include <pqHelpReaction.h>
110 #include <vtkOutputWindow.h>
111 #include <pqPluginManager.h>
112 //#include <vtkPVPluginInformation.h>
113 #include "pqInterfaceTracker.h"
114 #include <pqSettings.h>
115 #include <pqPythonDialog.h>
116 #include <pqPythonManager.h>
117 #include <pqPythonShell.h>
118 //#include <pqBrandPluginsLoader.h>
119 #include <pqLoadDataReaction.h>
120 #include <vtkEventQtSlotConnect.h>
121 #include <pqPythonScriptEditor.h>
122 #include <pqStandardSummaryPanelImplementation.h>
123 #include <pqCollaborationBehavior.h>
124 #include <pqDataRepresentation.h>
125 #include <pqPipelineRepresentation.h>
126 #include <pqLookupTableManager.h>
127 #include <pqDisplayColorWidget.h>
128 #include <pqColorToolbar.h>
129 #include <pqScalarBarVisibilityReaction.h>
130 #include <pqStandardPropertyWidgetInterface.h>
131 #include <pqMultiServerBehavior.h>
132 #include <pqViewStreamingBehavior.h>
134 #include <PARAVIS_version.h>
136 #include <vtkPVConfig.h>
138 #include <PVGUI_MatplotlibMathTextUtilities.h>
140 #include CORBA_SERVER_HEADER(SALOME_ModuleCatalog)
143 * Make sure all the kits register their classes with vtkInstantiator.
144 * Since ParaView uses Tcl wrapping, all of VTK is already compiled in
145 * anyway. The instantiators will add no more code for the linker to
149 //#include <vtkCommonInstantiator.h>
150 //#include <vtkFilteringInstantiator.h>
151 //#include <vtkGenericFilteringInstantiator.h>
152 //#include <vtkIOInstantiator.h>
153 //#include <vtkImagingInstantiator.h>
154 //#include <vtkInfovisInstantiator.h>
155 //#include <vtkGraphicsInstantiator.h>
157 //#include <vtkRenderingInstantiator.h>
158 //#include <vtkVolumeRenderingInstantiator.h>
159 //#include <vtkHybridInstantiator.h>
160 //#include <vtkParallelInstantiator.h>
162 #include <pqAlwaysConnectedBehavior.h>
163 #include <pqApplicationCore.h>
164 #include <pqAutoLoadPluginXMLBehavior.h>
165 #include <pqCommandLineOptionsBehavior.h>
166 #include <pqCrashRecoveryBehavior.h>
167 #include <pqDataTimeStepBehavior.h>
168 #include <pqDefaultViewBehavior.h>
169 #include <pqDeleteBehavior.h>
170 #include <pqObjectPickingBehavior.h>
171 #include <pqPersistentMainWindowStateBehavior.h>
172 #include <pqPipelineContextMenuBehavior.h>
173 #include <pqPluginActionGroupBehavior.h>
174 #include <pqPluginDockWidgetsBehavior.h>
175 #include <pqPluginManager.h>
176 #include <pqPVNewSourceBehavior.h>
177 #include <pqSpreadSheetVisibilityBehavior.h>
178 #include <pqStandardViewModules.h>
179 #include <pqUndoRedoBehavior.h>
180 #include <pqViewFrameActionsBehavior.h>
181 #include <pqServerManagerObserver.h>
183 #include <vtkClientServerInterpreterInitializer.h>
186 //----------------------------------------------------------------------------
187 pqPVApplicationCore* PVGUI_Module::MyCoreApp = 0;
188 //PVGUI_OutputWindowAdapter* PVGUI_Module::pqImplementation::OutputWindowAdapter = 0;
189 //QPointer<pqHelpWindow> PVGUI_Module::pqImplementation::helpWindow = 0;
191 PVGUI_Module* ParavisModule = 0;
196 <h2>Building and installing PARAVIS</h2>
197 As any other SALOME module, PARAVIS requires PARAVIS_ROOT_DIR environment variable to be set to PARAVIS
198 installation directory.
199 Other variables needed for correct detection of ParaView location:
200 \li PVHOME - points at the ParaView installation directory tree
201 \li PVVERSION - number of ParaView version
203 It also requires common SALOME environment including GUI_ROOT_DIR and other prerequsites.
206 PARAVIS module can be launched using the following commands:
207 \li Full SALOME configuration
209 runSalome --modules="PARAVIS"
212 <h2>ParaView GUI integration</h2>
213 <h3>ParaView GUI integration overview</h3>
215 The main idea is to reuse ParaView GUI internal logic as much as possible, providing a layer
216 between it and SALOME GUI that hides the following SALOME GUI implementation details from ParaView:
218 \li SALOME GUI executable and Qt event loop
219 \li SALOME GUI desktop
220 \li Dock windows areas
221 \li SALOME menu and toolbar managers
223 Major part of the integration is implemented in PVGUI_Module class.
225 <h3>ParaView client initalization</h3>
227 ParaView client initalization is performed when an instance of PVGUI_Module class has been created
228 and \link PVGUI_Module::initialize() PVGUI_Module::initialize()\endlink method is called by SALOME GUI.
229 The actual client start-up is done in \link PVGUI_Module::pvInit() PVGUI_Module::pvInit()\endlink method.
232 <h3>Multi-view manager</h3>
234 SALOME GUI requires that each kind of view be implemnted with help of (at least) three classes. For ParaView multi-view manager
237 \li PVGUI_ViewManager - view manager class
238 \li PVGUI_Viewer - view model class
239 \li PVGUI_ViewWindow - view window class that acts as a parent for %pqViewManager
241 Single instances of PVGUI_ViewManager and PVGUI_ViewWindow classes are created by \link PVGUI_Module::showView()
242 PVGUI_Module::showView()\endlink method upon the first PARAVIS module activation. The same method hides the multi-view manager
243 when the module is deactivated (the user switches to another module or a study is closed).
244 A special trick is used to make PVGUI_ViewWindow the parent of %pqViewManager widget. It is created initally by %pqMainWindowCore
245 with the desktop as a parent, so when it is shown PVGUI_ViewWindow instance is passed to its setParent() method. In
246 \link PVGUI_ViewWindow::~PVGUI_ViewWindow() PVGUI_ViewWindow::~PVGUI_ViewWindow()\endlink the parent is nullified to avoid deletion
247 of %pqViewManager widget that would break %pqMainWindowCore class.
249 <h3>ParaView plugins</h3>
250 ParaView server and client plugins are managed by %pqMainWindowCore slots that has full access to PARAVIS menus and toolbars.
251 As a result they appears automatically in PARAVIS menus and toolbars if loaded successfully.
256 \brief Implementation
257 SALOME module wrapping ParaView GUI.
262 Fix for the issue 21730: [CEA 596] Slice of polyhedron in PARAVIS returns no cell.
263 Wrap vtkEDFCutter filter.
266 extern "C" void vtkEDFCutterCS_Initialize(vtkClientServerInterpreter*);
267 static void vtkEDFHelperInit();
269 void vtkEDFHelperInit(vtkClientServerInterpreter* interp){
270 vtkEDFCutterCS_Initialize(interp);
273 void vtkEDFHelperInit() {
274 vtkClientServerInterpreterInitializer::GetInitializer()->
275 RegisterCallback(&vtkEDFHelperInit);
280 ClientFindOrCreateParavisComponent(_PTR(Study) theStudyDocument)
282 _PTR(SComponent) aSComponent = theStudyDocument->FindComponent("PARAVIS");
284 _PTR(StudyBuilder) aStudyBuilder = theStudyDocument->NewBuilder();
285 aStudyBuilder->NewCommand();
286 int aLocked = theStudyDocument->GetProperties()->IsLocked();
287 if (aLocked) theStudyDocument->GetProperties()->SetLocked(false);
288 aSComponent = aStudyBuilder->NewComponent("PARAVIS");
289 _PTR(GenericAttribute) anAttr =
290 aStudyBuilder->FindOrCreateAttribute(aSComponent, "AttributeName");
291 _PTR(AttributeName) aName (anAttr);
293 CORBA::ORB_var anORB = PARAVIS::PARAVIS_Gen_i::GetORB();
294 SALOME_NamingService *NamingService = new SALOME_NamingService( anORB );
295 CORBA::Object_var objVarN = NamingService->Resolve("/Kernel/ModulCatalog");
296 SALOME_ModuleCatalog::ModuleCatalog_var Catalogue =
297 SALOME_ModuleCatalog::ModuleCatalog::_narrow(objVarN);
298 SALOME_ModuleCatalog::Acomponent_var Comp = Catalogue->GetComponent( "PARAVIS" );
299 if (!Comp->_is_nil()) {
300 aName->SetValue(Comp->componentusername());
303 anAttr = aStudyBuilder->FindOrCreateAttribute(aSComponent, "AttributePixMap");
304 _PTR(AttributePixMap) aPixmap (anAttr);
305 aPixmap->SetPixMap( "pqAppIcon16.png" );
307 // Create Attribute parameters for future using
308 anAttr = aStudyBuilder->FindOrCreateAttribute(aSComponent, "AttributeParameter");
311 PARAVIS::PARAVIS_Gen_var aPARAVIS = PARAVIS::PARAVIS_Gen_i::GetParavisGenImpl()->_this();
313 aStudyBuilder->DefineComponentInstance(aSComponent, aPARAVIS->GetIOR());
314 if (aLocked) theStudyDocument->GetProperties()->SetLocked(true);
315 aStudyBuilder->CommitCommand();
321 Clean up function; used to stop ParaView progress events when
322 exception is caught by global exception handler.
324 void paravisCleanUp()
326 if ( pqApplicationCore::instance() ) {
327 pqServer* s = pqApplicationCore::instance()->getActiveServer();
328 if ( s ) s->session()->GetProgressHandler()->CleanupPendingProgress();
333 \brief Constructor. Sets the default name for the module.
335 PVGUI_Module::PVGUI_Module()
336 : SalomeApp_Module( "PARAVIS" ),
337 // Implementation( 0 ),
338 mySelectionControlsTb( -1 ),
339 mySourcesMenuId( -1 ),
340 myFiltersMenuId( -1 ),
342 myToolbarsMenuId(-1),
349 Q_INIT_RESOURCE( PVGUI );
351 ParavisModule = this;
354 QString aDestPath = QString( "%1/.config/%2/Macros" ).arg( QDir::homePath() ).arg( QApplication::applicationName() );
358 QDir aDestDir(aDestPath);
359 QStringList aDestFiles = aDestDir.entryList(aFilter, QDir::Files);
360 foreach (QString aStr, aDestFiles) {
361 aDestDir.remove(aStr);
368 PVGUI_Module::~PVGUI_Module()
375 \brief Initialize module. Creates menus, prepares context menu, etc.
376 \param app SALOME GUI application instance
378 void PVGUI_Module::initialize( CAM_Application* app )
380 //VTN: Disable conflict with python initialization for MatPlot.
381 PVGUI_MatplotlibMathTextUtilities::Disable();
383 SalomeApp_Module::initialize( app );
385 // Create ParaViS actions
387 // Create ParaViS menus
390 // Uncomment to debug ParaView initialization
391 // "aa" used instead of "i" as GDB doesn't like "i" variables :)
399 // Initialize ParaView client
402 // Create GUI elements (menus, toolbars, dock widgets)
403 //if ( !Implementation ){
404 SalomeApp_Application* anApp = getApp();
405 SUIT_Desktop* aDesktop = anApp->desktop();
407 // connect(aDesktop, SIGNAL()
409 // Remember current state of desktop toolbars
410 QList<QToolBar*> foreignToolbars = aDesktop->findChildren<QToolBar*>();
412 // Simulate ParaView client main window
413 //Implementation = new pqImplementation( aDesktop );
421 QList<QDockWidget*> activeDocks = aDesktop->findChildren<QDockWidget*>();
422 QList<QMenu*> activeMenus = aDesktop->findChildren<QMenu*>();
424 // new pqParaViewBehaviors(anApp->desktop(), this);
425 // Has to be replaced in order to exclude using of pqQtMessageHandlerBehaviour
426 // Start pqParaViewBehaviors
427 // Register ParaView interfaces.
428 //pqPluginManager* pgm = pqApplicationCore::instance()->getPluginManager();
429 pqInterfaceTracker* pgm = pqApplicationCore::instance()->interfaceTracker();
431 // * adds support for standard paraview views.
432 pgm->addInterface(new pqStandardViewModules(pgm));
433 pgm->addInterface(new pqStandardSummaryPanelImplementation(pgm));
434 pgm->addInterface(new pqStandardPropertyWidgetInterface(pgm));
436 // Load plugins distributed with application.
437 pqApplicationCore::instance()->loadDistributedPlugins();
439 // Define application behaviors.
440 //new pqQtMessageHandlerBehavior(this);
441 new pqDataTimeStepBehavior(this);
442 new pqViewFrameActionsBehavior(this);
443 new pqSpreadSheetVisibilityBehavior(this);
444 new pqPipelineContextMenuBehavior(this);
445 new pqDefaultViewBehavior(this);
446 new pqAlwaysConnectedBehavior(this);
447 new pqPVNewSourceBehavior(this);
448 new pqDeleteBehavior(this);
449 new pqUndoRedoBehavior(this);
450 new pqCrashRecoveryBehavior(this);
451 new pqAutoLoadPluginXMLBehavior(this);
452 new pqPluginDockWidgetsBehavior(aDesktop);
453 //new pqVerifyRequiredPluginBehavior(this);
454 new pqPluginActionGroupBehavior(aDesktop);
455 //new pqFixPathsInStateFilesBehavior(this);
456 new pqCommandLineOptionsBehavior(this);
457 new pqPersistentMainWindowStateBehavior(aDesktop);
458 new pqObjectPickingBehavior(aDesktop);
459 new pqCollaborationBehavior(this);
460 new pqMultiServerBehavior(this);
461 new pqViewStreamingBehavior(this);
463 // Setup quick-launch shortcuts.
464 QShortcut *ctrlSpace = new QShortcut(Qt::CTRL + Qt::Key_Space, aDesktop);
465 QObject::connect(ctrlSpace, SIGNAL(activated()),
466 pqApplicationCore::instance(), SLOT(quickLaunch()));
467 QShortcut *altSpace = new QShortcut(Qt::ALT + Qt::Key_Space, aDesktop);
468 QObject::connect(altSpace, SIGNAL(activated()),
469 pqApplicationCore::instance(), SLOT(quickLaunch()));
470 // End pqParaViewBehaviors
472 // Find Plugin Dock Widgets
473 QList<QDockWidget*> currentDocks = aDesktop->findChildren<QDockWidget*>();
474 QList<QDockWidget*>::iterator i;
475 for (i = currentDocks.begin(); i != currentDocks.end(); ++i) {
476 if(!activeDocks.contains(*i)) {
477 myDockWidgets[*i] = false; // hidden by default
483 QList<QMenu*> currentMenus = aDesktop->findChildren<QMenu*>();
484 QList<QMenu*>::iterator im;
485 for (im = currentMenus.begin(); im != currentMenus.end(); ++im) {
486 if(!activeMenus.contains(*im)) {
491 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
492 QString aPath = resMgr->stringValue("resources", "PARAVIS", QString());
493 if (!aPath.isNull()) {
494 MyCoreApp->loadConfiguration(aPath + QDir::separator() + "ParaViewFilters.xml");
495 MyCoreApp->loadConfiguration(aPath + QDir::separator() + "ParaViewReaders.xml");
496 MyCoreApp->loadConfiguration(aPath + QDir::separator() + "ParaViewSources.xml");
497 MyCoreApp->loadConfiguration(aPath + QDir::separator() + "ParaViewWriters.xml");
500 // Force creation of engine
501 PARAVIS::GetParavisGen(this);
504 // Find created toolbars
505 QCoreApplication::processEvents();
507 QList<QToolBar*> allToolbars = aDesktop->findChildren<QToolBar*>();
508 foreach(QToolBar* aBar, allToolbars) {
509 if (!foreignToolbars.contains(aBar)) {
510 myToolbars[aBar] = true;
511 myToolbarBreaks[aBar] = false;
512 aBar->setVisible(false);
513 aBar->toggleViewAction()->setVisible(false);
520 // we need to start trace after connection is done
521 connect(pqApplicationCore::instance()->getObjectBuilder(), SIGNAL(finishedAddingServer(pqServer*)),
522 this, SLOT(onFinishedAddingServer(pqServer*)));
524 connect(pqApplicationCore::instance()->getObjectBuilder(), SIGNAL(dataRepresentationCreated(pqDataRepresentation*)),
525 this, SLOT(onDataRepresentationCreated(pqDataRepresentation*)));
528 SUIT_ResourceMgr* aResourceMgr = SUIT_Session::session()->resourceMgr();
529 bool isStop = aResourceMgr->booleanValue( "PARAVIS", "stop_trace", false );
530 // start timer to activate trace in a proper moment
534 this->VTKConnect = vtkEventQtSlotConnect::New();
536 vtkProcessModule* pm = vtkProcessModule::GetProcessModule();
538 vtkPVSession* pvs = dynamic_cast<vtkPVSession*>(pm->GetSession());
540 vtkPVProgressHandler* ph = pvs->GetProgressHandler();
542 this->VTKConnect->Connect(ph, vtkCommand::StartEvent,
543 this, SLOT(onStartProgress()));
544 this->VTKConnect->Connect(ph, vtkCommand::EndEvent,
545 this, SLOT(onEndProgress()));
550 connect(&pqActiveObjects::instance(),
551 SIGNAL(representationChanged(pqRepresentation*)),
552 this, SLOT(onRepresentationChanged(pqRepresentation*)));
555 void PVGUI_Module::onStartProgress()
557 QApplication::setOverrideCursor(Qt::WaitCursor);
560 void PVGUI_Module::onEndProgress()
562 QApplication::restoreOverrideCursor();
565 void PVGUI_Module::onFinishedAddingServer(pqServer* /*server*/)
567 SUIT_ResourceMgr* aResourceMgr = SUIT_Session::session()->resourceMgr();
568 bool isStop = aResourceMgr->booleanValue( "PARAVIS", "stop_trace", false );
573 void PVGUI_Module::onDataRepresentationCreated(pqDataRepresentation* data) {
577 if(!data->getLookupTable())
580 SUIT_ResourceMgr* aResourceMgr = SUIT_Session::session()->resourceMgr();
584 bool visible = aResourceMgr->booleanValue( "PARAVIS", "show_color_legend", false );
585 pqLookupTableManager* lut_mgr = pqApplicationCore::instance()->getLookupTableManager();
588 lut_mgr->setScalarBarVisibility(data,visible);
591 connect(data, SIGNAL(dataUpdated()), this, SLOT(onDataRepresentationUpdated()));
594 void PVGUI_Module::onDataRepresentationUpdated() {
595 SalomeApp_Study* activeStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
596 if(!activeStudy) return;
598 activeStudy->Modified();
601 void PVGUI_Module::onVariableChanged(pqVariableType t, const QString) {
603 pqDisplayColorWidget* colorWidget = qobject_cast<pqDisplayColorWidget*>(sender());
607 if( t == VARIABLE_TYPE_NONE )
610 SUIT_ResourceMgr* aResourceMgr = SUIT_Session::session()->resourceMgr();
615 bool visible = aResourceMgr->booleanValue( "PARAVIS", "show_color_legend", false );
620 /*//VTN: getRepresentation is protected
621 pqDataRepresentation* data = colorWidget->getRepresentation();
623 if( !data->getLookupTable() )
626 pqLookupTableManager* lut_mgr = pqApplicationCore::instance()->getLookupTableManager();
629 lut_mgr->setScalarBarVisibility(data,visible);
632 pqColorToolbar* colorTooBar = qobject_cast<pqColorToolbar*>(colorWidget->parent());
636 pqScalarBarVisibilityReaction* scalarBarVisibility = colorTooBar->findChild<pqScalarBarVisibilityReaction *>();
637 if(scalarBarVisibility) {
638 scalarBarVisibility->setScalarBarVisibility(visible);
644 \brief Launches a tracing of current server
646 void PVGUI_Module::timerEvent(QTimerEvent* te )
649 PyInterp_Dispatcher* aDispatcher = PyInterp_Dispatcher::Get();
650 if ( !aDispatcher->IsBusy() ) {
651 pqPythonManager* manager = qobject_cast<pqPythonManager*>
652 ( pqApplicationCore::instance()->manager( "PYTHON_MANAGER" ) );
654 pqPythonDialog* pyDiag = manager->pythonShellDialog();
656 pqPythonShell* shell = pyDiag->shell();
658 QString script = "from paraview import smtrace\nsmtrace.start_trace()\n";
659 shell->executeScript(script);
660 killTimer( te->timerId() );
668 void PVGUI_Module::updateMacros()
670 pqPythonManager* aPythonManager = pqPVApplicationCore::instance()->pythonManager();
671 if(!aPythonManager) {
675 QString aRootDir = getenv("PARAVIS_ROOT_DIR");
677 QString aSourcePath = aRootDir + "/bin/salome/Macro";
682 QDir aSourceDir(aSourcePath);
683 QStringList aSourceFiles = aSourceDir.entryList(aFilter, QDir::Files);
684 foreach (QString aStr, aSourceFiles) {
685 aPythonManager->addMacro(aSourcePath + "/" + aStr);
691 \brief Get list of compliant dockable GUI elements
692 \param m map to be filled in ("type":"default_position")
694 void PVGUI_Module::windows( QMap<int, int>& m ) const
696 m.insert( LightApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
697 m.insert( LightApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
698 // ParaView diagnostic output redirected here
699 m.insert( LightApp_Application::WT_LogWindow, Qt::BottomDockWidgetArea );
703 \brief Static method, performs initialization of ParaView session.
704 \return \c true if ParaView has been initialized successfully, otherwise false
706 bool PVGUI_Module::pvInit()
708 // if ( !pqImplementation::Core ){
710 // Obtain command-line arguments
713 QString aOptions = getenv("PARAVIS_OPTIONS");
714 QStringList aOptList = aOptions.split(":", QString::SkipEmptyParts);
715 argv = new char*[aOptList.size() + 1];
716 QStringList args = QApplication::arguments();
717 argv[0] = (args.size() > 0)? strdup(args[0].toLatin1().constData()) : strdup("paravis");
720 foreach (QString aStr, aOptList) {
721 argv[argc] = strdup( aStr.toLatin1().constData() );
724 MyCoreApp = new pqPVApplicationCore (argc, argv);
725 if (MyCoreApp->getOptions()->GetHelpSelected() ||
726 MyCoreApp->getOptions()->GetUnknownArgument() ||
727 MyCoreApp->getOptions()->GetErrorMessage() ||
728 MyCoreApp->getOptions()->GetTellVersion()) {
732 /* VTN: Looks like trash. For porting see branded_paraview_initializer.cxx.in
733 // Not sure why this is needed. Andy added this ages ago with comment saying
734 // needed for Mac apps. Need to check that it's indeed still required.
735 QDir dir(QApplication::applicationDirPath());
738 QApplication::addLibraryPath(dir.absolutePath());
739 // Load required application plugins.
740 QString plugin_string = "";
741 QStringList plugin_list = plugin_string.split(';',QString::SkipEmptyParts);
742 pqBrandPluginsLoader loader;
743 if (loader.loadPlugins(plugin_list) == false) {
744 printf("Failed to load required plugins for this application\n");
748 // Load optional plugins.
750 plugin_list = plugin_string.split(';',QString::SkipEmptyParts);
751 loader.loadPlugins(plugin_list, true); //quietly skip not-found plugins.
753 // End of Initializer code
755 vtkOutputWindow::SetInstance(PVGUI_OutputWindowAdapter::New());
757 new pqTabbedMultiViewWidget(); // it registers as "MULTIVIEW_WIDGET on creation
759 for (int i = 0; i < argc; i++)
768 \brief Shows (toShow = true) or hides ParaView view window
770 void PVGUI_Module::showView( bool toShow )
772 SalomeApp_Application* anApp = getApp();
773 PVGUI_ViewManager* viewMgr =
774 dynamic_cast<PVGUI_ViewManager*>( anApp->getViewManager( PVGUI_Viewer::Type(), false ) );
776 viewMgr = new PVGUI_ViewManager( anApp->activeStudy(), anApp->desktop() );
777 anApp->addViewManager( viewMgr );
778 connect( viewMgr, SIGNAL( lastViewClosed( SUIT_ViewManager* ) ),
779 anApp, SLOT( onCloseView( SUIT_ViewManager* ) ) );
782 PVGUI_ViewWindow* pvWnd = dynamic_cast<PVGUI_ViewWindow*>( viewMgr->getActiveView() );
784 pvWnd = dynamic_cast<PVGUI_ViewWindow*>( viewMgr->createViewWindow() );
787 pvWnd->setShown( toShow );
788 if ( toShow ) pvWnd->setFocus();
792 \brief Slot to show help for proxy.
794 void PVGUI_Module::showHelpForProxy( const QString& groupname, const QString& proxyname )
796 pqHelpReaction::showProxyHelp(groupname, proxyname);
801 \brief Slot to show the waiting state.
803 void PVGUI_Module::onPreAccept()
805 getApp()->desktop()->statusBar()->showMessage(tr("STB_PREACCEPT"));
806 QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
810 \brief Slot to show the ready state.
812 void PVGUI_Module::onPostAccept()
814 getApp()->desktop()->statusBar()->showMessage(tr("STB_POSTACCEPT"), 2000);
815 QTimer::singleShot(0, this, SLOT(endWaitCursor()));
819 \brief Slot to switch off wait cursor.
821 void PVGUI_Module::endWaitCursor()
823 QApplication::restoreOverrideCursor();
827 \brief Returns the ParaView multi-view manager.
829 pqTabbedMultiViewWidget* PVGUI_Module::getMultiViewManager() const
831 return qobject_cast<pqTabbedMultiViewWidget*>(pqApplicationCore::instance()->manager("MULTIVIEW_WIDGET"));
835 static void ParavisMessageOutput(QtMsgType type, const char *msg)
840 vtkOutputWindow::GetInstance()->DisplayText(msg);
843 vtkOutputWindow::GetInstance()->DisplayErrorText(msg);
846 vtkOutputWindow::GetInstance()->DisplayErrorText(msg);
849 vtkOutputWindow::GetInstance()->DisplayErrorText(msg);
857 \brief Activate module.
858 \param study current study
859 \return \c true if activaion is done successfully or 0 to prevent
862 bool PVGUI_Module::activateModule( SUIT_Study* study )
864 myOldMsgHandler = qInstallMsgHandler(ParavisMessageOutput);
866 SUIT_ExceptionHandler::addCleanUpRoutine( paravisCleanUp );
868 bool isDone = SalomeApp_Module::activateModule( study );
869 if ( !isDone ) return false;
872 if ( mySourcesMenuId != -1 ) menuMgr()->show(mySourcesMenuId);
873 if ( myFiltersMenuId != -1 ) menuMgr()->show(myFiltersMenuId);
874 if ( myFiltersMenuId != -1 ) menuMgr()->show(myMacrosMenuId);
875 if ( myFiltersMenuId != -1 ) menuMgr()->show(myToolbarsMenuId);
876 setMenuShown( true );
877 setToolShown( true );
879 restoreDockWidgetsState();
881 QMenu* aMenu = menuMgr()->findMenu( myRecentMenuId );
883 QList<QAction*> anActns = aMenu->actions();
884 for (int i = 0; i < anActns.size(); ++i) {
885 QAction* a = anActns.at(i);
891 QList<QMenu*>::iterator it;
892 for (it = myMenus.begin(); it != myMenus.end(); ++it) {
893 QAction* a = (*it)->menuAction();
898 if ( myRecentMenuId != -1 ) menuMgr()->show(myRecentMenuId);
900 ClientFindOrCreateParavisComponent(PARAVIS::GetCStudy(this));
907 \brief Deactivate module.
908 \param study current study
909 \return \c true if deactivaion is done successfully or 0 to prevent
910 deactivation on error
912 bool PVGUI_Module::deactivateModule( SUIT_Study* study )
914 QMenu* aMenu = menuMgr()->findMenu( myRecentMenuId );
916 QList<QAction*> anActns = aMenu->actions();
917 for (int i = 0; i < anActns.size(); ++i) {
918 QAction* a = anActns.at(i);
920 a->setVisible(false);
924 QList<QMenu*>::iterator it;
925 for (it = myMenus.begin(); it != myMenus.end(); ++it) {
926 QAction* a = (*it)->menuAction();
928 a->setVisible(false);
931 QList<QDockWidget*> aStreamingViews = application()->desktop()->findChildren<QDockWidget*>("pqStreamingControls");
932 foreach(QDockWidget* aView, aStreamingViews) {
933 if (!myDockWidgets.contains(aView))
934 myDockWidgets[aView] = aView->isVisible();
937 /*if (pqImplementation::helpWindow) {
938 pqImplementation::helpWindow->hide();
942 menuMgr()->hide(myRecentMenuId);
943 menuMgr()->hide(mySourcesMenuId);
944 menuMgr()->hide(myFiltersMenuId);
945 menuMgr()->hide(myMacrosMenuId);
946 menuMgr()->hide(myToolbarsMenuId);
947 setMenuShown( false );
948 setToolShown( false );
951 saveDockWidgetsState();
953 SUIT_ExceptionHandler::removeCleanUpRoutine( paravisCleanUp );
956 qInstallMsgHandler(myOldMsgHandler);
958 return SalomeApp_Module::deactivateModule( study );
963 \brief Called when application is closed.
965 Process finalize application functionality from ParaView in order to save server settings
966 and nullify application pointer if the application is being closed.
968 \param theApp application
970 void PVGUI_Module::onApplicationClosed( SUIT_Application* theApp )
972 pqApplicationCore::instance()->settings()->sync();
973 int aAppsNb = SUIT_Session::session()->applications().size();
975 deleteTemporaryFiles();
976 MyCoreApp->deleteLater();
978 CAM_Module::onApplicationClosed(theApp);
983 \brief Called when study is closed.
985 Removes data model from the \a study.
987 \param study study being closed
989 void PVGUI_Module::studyClosed(SUIT_Study* study)
991 clearParaviewState();
993 SalomeApp_Module::studyClosed(study);
997 \brief Called when study is opened.
999 void PVGUI_Module::onModelOpened()
1001 _PTR(Study) studyDS = PARAVIS::GetCStudy(this);
1006 _PTR(SComponent) paravisComp =
1007 studyDS->FindComponent(PARAVIS::GetParavisGen(this)->ComponentDataType());
1012 _PTR(ChildIterator) anIter(studyDS->NewChildIterator(paravisComp));
1013 for (; anIter->More(); anIter->Next()) {
1014 _PTR(SObject) aSObj = anIter->Value();
1015 _PTR(GenericAttribute) anAttr;
1016 if (!aSObj->FindAttribute(anAttr, "AttributeLocalID")) {
1019 _PTR(AttributeLocalID) anID(anAttr);
1020 if (anID->Value() == PVSTATEID) {
1027 \brief Returns IOR of current engine
1029 QString PVGUI_Module::engineIOR() const
1031 CORBA::String_var anIOR = PARAVIS::GetParavisGen(this)->GetIOR();
1032 return QString(anIOR.in());
1037 \brief Open file of format supported by ParaView
1039 void PVGUI_Module::openFile(const char* theName)
1043 pqLoadDataReaction::loadData(aFiles);
1046 void PVGUI_Module::executeScript(const char *script)
1049 pqPythonManager* manager = qobject_cast<pqPythonManager*>(
1050 pqApplicationCore::instance()->manager("PYTHON_MANAGER"));
1052 pqPythonDialog* pyDiag = manager->pythonShellDialog();
1054 pyDiag->runString(script);
1061 \brief Returns trace string
1063 static const QString MYReplaceStr("paraview.simple");
1064 static const QString MYReplaceImportStr("except: from pvsimple import *");
1065 QString PVGUI_Module::getTraceString()
1067 QString traceString;
1069 pqPythonManager* manager = qobject_cast<pqPythonManager*>(
1070 pqApplicationCore::instance()->manager("PYTHON_MANAGER"));
1072 pqPythonDialog* pyDiag = manager->pythonShellDialog();
1074 pyDiag->runString("from paraview import smtrace\n"
1075 "__smtraceString = smtrace.get_trace_string()\n");
1076 pyDiag->shell()->makeCurrent();
1077 PyObject* main_module = PyImport_AddModule((char*)"__main__");
1078 PyObject* global_dict = PyModule_GetDict(main_module);
1079 PyObject* string_object = PyDict_GetItemString(global_dict, "__smtraceString");
1080 char* string_ptr = string_object ? PyString_AsString(string_object) : 0;
1082 traceString = string_ptr;
1084 pyDiag->shell()->releaseControl();
1087 if ((!traceString.isNull()) && traceString.length() != 0) {
1088 int aPos = traceString.indexOf(MYReplaceStr);
1089 while (aPos != -1) {
1090 traceString = traceString.replace(aPos, MYReplaceStr.length(), "pvsimple");
1091 aPos = traceString.indexOf(MYReplaceStr, aPos);
1093 int aImportPos = traceString.indexOf(MYReplaceImportStr);
1094 if(aImportPos != -1)
1096 traceString = traceString.replace(aImportPos, MYReplaceImportStr.length(), "except:\n import pvsimple\n from pvsimple import *");
1104 \brief Saves trace string to disk file
1106 void PVGUI_Module::saveTrace(const char* theName)
1108 QFile file(theName);
1109 if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
1110 MESSAGE( "Could not open file:" << theName );
1113 QTextStream out(&file);
1114 out << getTraceString();
1119 \brief Saves ParaView state to a disk file
1121 void PVGUI_Module::saveParaviewState(const char* theFileName)
1123 pqApplicationCore::instance()->saveState(theFileName);
1127 \brief Delete all objects for Paraview Pipeline Browser
1129 void PVGUI_Module::clearParaviewState()
1131 QAction* deleteAllAction = action(DeleteAllId);
1132 if (deleteAllAction) {
1133 deleteAllAction->activate(QAction::Trigger);
1138 \brief Restores ParaView state from a disk file
1140 If toClear == true, the current ojects will be deleted
1142 void PVGUI_Module::loadParaviewState(const char* theFileName)
1144 pqApplicationCore::instance()->loadState(theFileName, getActiveServer());
1148 \brief Imports MED data from VISU module by data entry
1150 void PVGUI_Module::onImportFromVisu(QString theEntry)
1153 SUIT_OverrideCursor aWaitCursor;
1156 SalomeApp_Study* activeStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
1157 if(!activeStudy) return;
1159 // get SALOMEDS client study
1160 _PTR(Study) aStudy = activeStudy->studyDS();
1163 // find VISU component in a study
1164 _PTR(SComponent) aVisuComp = aStudy->FindComponent( "VISU" );
1165 if(!aVisuComp) return;
1167 // get SObject client by entry
1168 _PTR(SObject) aSObj = aStudy->FindObjectID(qPrintable(theEntry));
1171 // get CORBA SObject
1172 SALOMEDS_SObject* aSObject = _CAST(SObject, aSObj);
1173 if ( !aSObject ) return;
1176 SALOME_NamingService* aNamingService = SalomeApp_Application::namingService();
1177 SALOME_LifeCycleCORBA aLCC(aNamingService);
1179 Engines::EngineComponent_var aComponent = aLCC.FindOrLoad_Component("FactoryServer","VISU");
1180 VISU::VISU_Gen_var aVISU = VISU::VISU_Gen::_narrow(aComponent);
1181 if(CORBA::is_nil(aVISU)) return;
1183 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1184 aStudyBuilder->LoadWith( aVisuComp, SalomeApp_Application::orb()->object_to_string(aVISU) );
1186 // get VISU result object
1187 CORBA::Object_var aResultObject = aSObject->GetObject();
1188 if (CORBA::is_nil(aResultObject)) return;
1189 VISU::Result_var aResult = VISU::Result::_narrow( aResultObject );
1190 if (CORBA::is_nil(aResult)) return;
1192 // export VISU result to the MED file
1193 std::string aTmpDir = SALOMEDS_Tool::GetTmpDir();
1194 std::string aFileName = aSObject->GetName();
1195 std::string aFilePath = aTmpDir + aFileName;
1197 if (aResult->ExportMED(aFilePath.c_str())) {
1198 openFile(aFilePath.c_str());
1199 myTemporaryFiles.append(QString(aFilePath.c_str()));
1202 MESSAGE("Visu module is not found.");
1207 \brief Deletes temporary files created during import operation from VISU
1209 void PVGUI_Module::deleteTemporaryFiles()
1211 foreach(QString aFile, myTemporaryFiles) {
1212 if (QFile::exists(aFile)) {
1213 QFile::remove(aFile);
1220 \brief Returns current active ParaView server
1222 pqServer* PVGUI_Module::getActiveServer()
1224 return pqApplicationCore::instance()->getActiveServer();
1229 \brief Creates PARAVIS preference pane
1231 void PVGUI_Module::createPreferences()
1233 // Paraview settings tab
1234 int aParaViewSettingsTab = addPreference( tr( "TIT_PVIEWSETTINGS" ) );
1235 int aPanel = addPreference(QString(), aParaViewSettingsTab, LightApp_Preferences::UserDefined, "PARAVIS", "");
1236 setPreferenceProperty(aPanel, "content", (qint64)(new PVGUI_ParaViewSettingsPane()));
1238 // Paravis settings tab
1239 int aParaVisSettingsTab = addPreference( tr( "TIT_PVISSETTINGS" ) );
1240 addPreference( tr( "PREF_STOP_TRACE" ), aParaVisSettingsTab, LightApp_Preferences::Bool, "PARAVIS", "stop_trace");
1242 int aSaveType = addPreference(tr( "PREF_SAVE_TYPE_LBL" ), aParaVisSettingsTab,
1243 LightApp_Preferences::Selector,
1244 "PARAVIS", "savestate_type");
1245 QList<QVariant> aIndices;
1246 QStringList aStrings;
1248 aStrings<<tr("PREF_SAVE_TYPE_0");
1249 aStrings<<tr("PREF_SAVE_TYPE_1");
1250 aStrings<<tr("PREF_SAVE_TYPE_2");
1251 setPreferenceProperty(aSaveType, "strings", aStrings);
1252 setPreferenceProperty(aSaveType, "indexes", aIndices);
1254 //rnv: imp 21712: [CEA 581] Preference to display legend by default
1255 int aDispColoreLegend = addPreference( tr( "PREF_SHOW_COLOR_LEGEND" ), aParaVisSettingsTab,
1256 LightApp_Preferences::Bool, "PARAVIS", "show_color_legend");
1260 \brief Creates ParaViS context menu popup
1262 void PVGUI_Module::contextMenuPopup(const QString& theClient, QMenu* theMenu, QString& theTitle)
1264 SalomeApp_Module::contextMenuPopup(theClient, theMenu, theTitle);
1266 // Check if we are in Object Browser
1267 SUIT_DataBrowser* ob = getApp()->objectBrowser();
1268 bool isOBClient = (ob && theClient == ob->popupClientType());
1273 // Get list of selected objects
1274 LightApp_SelectionMgr* aSelectionMgr = getApp()->selectionMgr();
1275 SALOME_ListIO aListIO;
1276 aSelectionMgr->selectedObjects(aListIO);
1277 if (aListIO.Extent() == 1 && aListIO.First()->hasEntry()) {
1278 QString entry = QString(aListIO.First()->getEntry());
1281 SalomeApp_Study* activeStudy =
1282 dynamic_cast<SalomeApp_Study*>(getApp()->activeStudy());
1287 // Get SALOMEDS client study
1288 _PTR(Study) studyDS = activeStudy->studyDS();
1293 QString paravisDataType(PARAVIS::GetParavisGen(this)->ComponentDataType());
1294 if(activeStudy && activeStudy->isComponent(entry) &&
1295 activeStudy->componentDataType(entry) == paravisDataType) {
1296 // ParaViS module object
1297 theMenu->addSeparator();
1298 theMenu->addAction(action(SaveStatePopupId));
1301 // Try to get state object
1302 _PTR(SObject) stateSObj =
1303 studyDS->FindObjectID(entry.toLatin1().constData());
1309 _PTR(GenericAttribute) anAttr;
1310 if (!stateSObj->FindAttribute(anAttr, "AttributeLocalID")) {
1314 _PTR(AttributeLocalID) anID(anAttr);
1316 if (anID->Value() == PVSTATEID) {
1317 // Paraview state object
1318 theMenu->addSeparator();
1319 theMenu->addAction(action(AddStatePopupId));
1320 theMenu->addAction(action(CleanAndAddStatePopupId));
1321 theMenu->addSeparator();
1322 theMenu->addAction(action(ParaVisRenameId));
1323 theMenu->addAction(action(ParaVisDeleteId));
1329 void PVGUI_Module::onShowTrace()
1331 if (!myTraceWindow) {
1332 myTraceWindow = new pqPythonScriptEditor(getApp()->desktop());
1334 myTraceWindow->setText(getTraceString());
1335 myTraceWindow->show();
1336 myTraceWindow->raise();
1337 myTraceWindow->activateWindow();
1341 \brief Show ParaView view.
1343 void PVGUI_Module::onNewParaViewWindow()
1349 \brief Save state under the module root object.
1351 void PVGUI_Module::onSaveMultiState()
1353 // Create state study object
1355 // Get SALOMEDS client study
1356 _PTR(Study) studyDS = PARAVIS::GetCStudy(this);
1361 _PTR(SComponent) paravisComp =
1362 studyDS->FindComponent(PARAVIS::GetParavisGen(this)->ComponentDataType());
1367 // Unlock the study if it is locked
1368 bool isLocked = studyDS->GetProperties()->IsLocked();
1370 studyDS->GetProperties()->SetLocked(false);
1373 QString stateName = tr("SAVED_PARAVIEW_STATE_NAME") +
1374 QString::number(myStateCounter + 1);
1376 _PTR(StudyBuilder) studyBuilder = studyDS->NewBuilder();
1377 _PTR(SObject) newSObj = studyBuilder->NewObject(paravisComp);
1380 _PTR(GenericAttribute) anAttr;
1381 anAttr = studyBuilder->FindOrCreateAttribute(newSObj, "AttributeName");
1382 _PTR(AttributeName) nameAttr(anAttr);
1384 nameAttr->SetValue(stateName.toLatin1().constData());
1387 anAttr = studyBuilder->FindOrCreateAttribute(newSObj, "AttributeLocalID");
1388 _PTR(AttributeLocalID) localIdAttr(anAttr);
1390 localIdAttr->SetValue(PVSTATEID);
1393 QString stateEntry = QString::fromStdString(newSObj->GetID());
1395 // File name for state saving
1396 QString tmpDir = QString::fromStdString(SALOMEDS_Tool::GetTmpDir());
1397 QString fileName = QString("%1_paravisstate:%2").arg(tmpDir,
1400 anAttr = studyBuilder->FindOrCreateAttribute(newSObj, "AttributeString");
1401 _PTR(AttributeString) stringAttr(anAttr);
1403 stringAttr->SetValue(fileName.toLatin1().constData());
1405 // Lock the study back if necessary
1407 studyDS->GetProperties()->SetLocked(true);
1411 saveParaviewState(fileName.toLatin1().constData());
1412 myTemporaryFiles.append(fileName);
1414 // Increment the counter
1421 \brief Restore the selected state by merging with the current one.
1423 void PVGUI_Module::onAddState()
1425 loadSelectedState(false);
1429 \brief Clean the current state and restore the selected one.
1431 void PVGUI_Module::onCleanAddState()
1433 loadSelectedState(true);
1437 \brief Rename the selected object.
1439 void PVGUI_Module::onRename()
1441 LightApp_SelectionMgr* aSelectionMgr = getApp()->selectionMgr();
1442 SALOME_ListIO aListIO;
1443 aSelectionMgr->selectedObjects(aListIO);
1445 if (aListIO.Extent() == 1 && aListIO.First()->hasEntry()) {
1446 std::string entry = aListIO.First()->getEntry();
1448 // Get SALOMEDS client study
1449 _PTR(Study) studyDS = PARAVIS::GetCStudy(this);
1454 // Unlock the study if it is locked
1455 bool isLocked = studyDS->GetProperties()->IsLocked();
1457 studyDS->GetProperties()->SetLocked(false);
1460 // Rename the selected state object
1461 _PTR(SObject) stateSObj = studyDS->FindObjectID(entry);
1466 _PTR(GenericAttribute) anAttr;
1467 if (stateSObj->FindAttribute(anAttr, "AttributeName")) {
1468 _PTR(AttributeName) nameAttr (anAttr);
1470 LightApp_NameDlg::getName(getApp()->desktop(), nameAttr->Value().c_str());
1471 if (!newName.isEmpty()) {
1472 nameAttr->SetValue(newName.toLatin1().constData());
1473 aListIO.First()->setName(newName.toLatin1().constData());
1477 // Lock the study back if necessary
1479 studyDS->GetProperties()->SetLocked(true);
1482 // Update object browser
1489 \brief Delete the selected objects.
1491 void PVGUI_Module::onDelete()
1493 LightApp_SelectionMgr* aSelectionMgr = getApp()->selectionMgr();
1494 SALOME_ListIO aListIO;
1495 aSelectionMgr->selectedObjects(aListIO);
1497 if (aListIO.Extent() == 1 && aListIO.First()->hasEntry()) {
1498 std::string entry = aListIO.First()->getEntry();
1500 // Get SALOMEDS client study
1501 _PTR(Study) studyDS = PARAVIS::GetCStudy(this);
1506 // Unlock the study if it is locked
1507 bool isLocked = studyDS->GetProperties()->IsLocked();
1509 studyDS->GetProperties()->SetLocked(false);
1512 // Remove the selected state from the study
1513 _PTR(StudyBuilder) studyBuilder = studyDS->NewBuilder();
1514 _PTR(SObject) stateSObj = studyDS->FindObjectID(entry);
1515 studyBuilder->RemoveObject(stateSObj);
1517 // Lock the study back if necessary
1519 studyDS->GetProperties()->SetLocked(true);
1522 // Update object browser
1528 \brief Discover help project files from the resources.
1529 \return name of the help file.
1531 QString PVGUI_Module::getHelpFileName() {
1532 QString aPVHome(getenv("PVHOME"));
1533 if (aPVHome.isNull()) {
1534 qWarning("Wariable PVHOME is not defined");
1537 QChar aSep = QDir::separator();
1538 //PARAVIEW_VERSION from the vtkPVConfig.h file
1539 QString aFileName = aPVHome + aSep + "share" + aSep + "doc" + aSep + "paraview-"+ PARAVIEW_VERSION + aSep + "paraview.qch";
1545 \brief Load selected paraview state
1547 If toClear == true, the current state will be cleared
1549 void PVGUI_Module::loadSelectedState(bool toClear)
1553 LightApp_SelectionMgr* aSelectionMgr = getApp()->selectionMgr();
1554 SALOME_ListIO aListIO;
1555 aSelectionMgr->selectedObjects(aListIO);
1557 if (aListIO.Extent() == 1 && aListIO.First()->hasEntry()) {
1558 std::string entry = aListIO.First()->getEntry();
1560 // Get SALOMEDS client study
1561 _PTR(Study) studyDS = PARAVIS::GetCStudy(this);
1567 _PTR(SObject) stateSObj = studyDS->FindObjectID(entry);
1568 _PTR(GenericAttribute) anAttr;
1569 if (!stateSObj->FindAttribute(anAttr, "AttributeLocalID")) {
1572 _PTR(AttributeLocalID) anID(anAttr);
1573 if (!anID->Value() == PVSTATEID) {
1577 // Get state file name
1578 if (stateSObj->FindAttribute(anAttr, "AttributeString")) {
1579 _PTR(AttributeString) aStringAttr(anAttr);
1580 QString stringValue(aStringAttr->Value().c_str());
1582 if (QFile::exists(stringValue)) {
1583 fileName = stringValue;
1588 if (!fileName.isEmpty()) {
1590 clearParaviewState();
1593 loadParaviewState(fileName.toLatin1().constData());
1596 SUIT_MessageBox::critical(getApp()->desktop(),
1598 tr("ERR_STATE_CANNOT_BE_RESTORED"));
1602 void PVGUI_Module::onRepresentationChanged(pqRepresentation*) {
1605 //rnv: to fix the issue "21712: [CEA 581] Preference to display legend by default"
1606 // find the pqDisplayColorWidget instances and connect the variableChanged SIGNAL on the
1607 // onVariableChanged slot of this class. This connection needs to change visibility
1608 // of the "Colored Legend" after change the "Color By" array.
1609 QList<pqDisplayColorWidget*> aWidget = getApp()->desktop()->findChildren<pqDisplayColorWidget*>();
1611 for (int i = 0; i < aWidget.size() ; i++ ) {
1613 connect( aWidget[i], SIGNAL ( variableChanged ( pqVariableType, const QString ) ),
1614 this, SLOT(onVariableChanged( pqVariableType, const QString) ), Qt::UniqueConnection );
1621 \fn CAM_Module* createModule();
1622 \brief Export module instance (factory function).
1623 \return new created instance of the module
1627 #define PVGUI_EXPORT __declspec(dllexport)
1629 #define PVGUI_EXPORT
1635 PVGUI_EXPORT CAM_Module* createModule() {
1640 return new PVGUI_Module();
1643 PVGUI_EXPORT char* getModuleVersion() {
1644 return (char*)PARAVIS_VERSION_STR;