1 // PARAVIS : ParaView wrapper SALOME module
3 // Copyright (C) 2010-2012 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 <vtkPVProgressHandler.h>
107 #include <pqParaViewBehaviors.h>
108 #include <pqHelpReaction.h>
109 #include <vtkOutputWindow.h>
110 #include <pqPluginManager.h>
111 //#include <vtkPVPluginInformation.h>
112 #include "pqInterfaceTracker.h"
113 #include <pqSettings.h>
114 #include <pqPythonDialog.h>
115 #include <pqPythonManager.h>
116 #include <pqPythonShell.h>
117 #include <pqBrandPluginsLoader.h>
118 #include <pqLoadDataReaction.h>
119 #include <vtkEventQtSlotConnect.h>
120 #include <pqPythonScriptEditor.h>
121 #include <pqStandardSummaryPanelImplementation.h>
122 #include <pqCollaborationBehavior.h>
123 #include <pqDataRepresentation.h>
124 #include <pqPipelineRepresentation.h>
125 #include <pqLookupTableManager.h>
126 #include <pqDisplayColorWidget.h>
128 #include <PARAVIS_version.h>
130 #include <vtkPVConfig.h>
132 #include CORBA_SERVER_HEADER(SALOME_ModuleCatalog)
135 * Make sure all the kits register their classes with vtkInstantiator.
136 * Since ParaView uses Tcl wrapping, all of VTK is already compiled in
137 * anyway. The instantiators will add no more code for the linker to
141 #include <vtkCommonInstantiator.h>
142 #include <vtkFilteringInstantiator.h>
143 #include <vtkGenericFilteringInstantiator.h>
144 #include <vtkIOInstantiator.h>
145 #include <vtkImagingInstantiator.h>
146 #include <vtkInfovisInstantiator.h>
147 #include <vtkGraphicsInstantiator.h>
149 #include <vtkRenderingInstantiator.h>
150 #include <vtkVolumeRenderingInstantiator.h>
151 #include <vtkHybridInstantiator.h>
152 #include <vtkParallelInstantiator.h>
154 #include <pqAlwaysConnectedBehavior.h>
155 #include <pqApplicationCore.h>
156 #include <pqAutoLoadPluginXMLBehavior.h>
157 #include <pqCommandLineOptionsBehavior.h>
158 #include <pqCrashRecoveryBehavior.h>
159 #include <pqDataTimeStepBehavior.h>
160 #include <pqDefaultViewBehavior.h>
161 #include <pqDeleteBehavior.h>
162 #include <pqObjectPickingBehavior.h>
163 #include <pqPersistentMainWindowStateBehavior.h>
164 #include <pqPipelineContextMenuBehavior.h>
165 #include <pqPluginActionGroupBehavior.h>
166 #include <pqPluginDockWidgetsBehavior.h>
167 #include <pqPluginManager.h>
168 #include <pqPVNewSourceBehavior.h>
169 #include <pqSpreadSheetVisibilityBehavior.h>
170 #include <pqStandardViewModules.h>
171 #include <pqUndoRedoBehavior.h>
172 #include <pqViewFrameActionsBehavior.h>
173 #include <pqServerManagerObserver.h>
175 #include <vtkClientServerInterpreterInitializer.h>
178 //----------------------------------------------------------------------------
179 pqPVApplicationCore* PVGUI_Module::MyCoreApp = 0;
180 //PVGUI_OutputWindowAdapter* PVGUI_Module::pqImplementation::OutputWindowAdapter = 0;
181 //QPointer<pqHelpWindow> PVGUI_Module::pqImplementation::helpWindow = 0;
183 PVGUI_Module* ParavisModule = 0;
188 <h2>Building and installing PARAVIS</h2>
189 As any other SALOME module, PARAVIS requires PARAVIS_ROOT_DIR environment variable to be set to PARAVIS
190 installation directory.
191 Other variables needed for correct detection of ParaView location:
192 \li PVHOME - points at the ParaView installation directory tree
193 \li PVVERSION - number of ParaView version
195 It also requires common SALOME environment including GUI_ROOT_DIR and other prerequsites.
198 PARAVIS module can be launched using the following commands:
199 \li Full SALOME configuration
201 runSalome --modules="PARAVIS"
204 <h2>ParaView GUI integration</h2>
205 <h3>ParaView GUI integration overview</h3>
207 The main idea is to reuse ParaView GUI internal logic as much as possible, providing a layer
208 between it and SALOME GUI that hides the following SALOME GUI implementation details from ParaView:
210 \li SALOME GUI executable and Qt event loop
211 \li SALOME GUI desktop
212 \li Dock windows areas
213 \li SALOME menu and toolbar managers
215 Major part of the integration is implemented in PVGUI_Module class.
217 <h3>ParaView client initalization</h3>
219 ParaView client initalization is performed when an instance of PVGUI_Module class has been created
220 and \link PVGUI_Module::initialize() PVGUI_Module::initialize()\endlink method is called by SALOME GUI.
221 The actual client start-up is done in \link PVGUI_Module::pvInit() PVGUI_Module::pvInit()\endlink method.
224 <h3>Multi-view manager</h3>
226 SALOME GUI requires that each kind of view be implemnted with help of (at least) three classes. For ParaView multi-view manager
229 \li PVGUI_ViewManager - view manager class
230 \li PVGUI_Viewer - view model class
231 \li PVGUI_ViewWindow - view window class that acts as a parent for %pqViewManager
233 Single instances of PVGUI_ViewManager and PVGUI_ViewWindow classes are created by \link PVGUI_Module::showView()
234 PVGUI_Module::showView()\endlink method upon the first PARAVIS module activation. The same method hides the multi-view manager
235 when the module is deactivated (the user switches to another module or a study is closed).
236 A special trick is used to make PVGUI_ViewWindow the parent of %pqViewManager widget. It is created initally by %pqMainWindowCore
237 with the desktop as a parent, so when it is shown PVGUI_ViewWindow instance is passed to its setParent() method. In
238 \link PVGUI_ViewWindow::~PVGUI_ViewWindow() PVGUI_ViewWindow::~PVGUI_ViewWindow()\endlink the parent is nullified to avoid deletion
239 of %pqViewManager widget that would break %pqMainWindowCore class.
241 <h3>ParaView plugins</h3>
242 ParaView server and client plugins are managed by %pqMainWindowCore slots that has full access to PARAVIS menus and toolbars.
243 As a result they appears automatically in PARAVIS menus and toolbars if loaded successfully.
248 \brief Implementation
249 SALOME module wrapping ParaView GUI.
254 Fix for the issue 21730: [CEA 596] Slice of polyhedron in PARAVIS returns no cell.
255 Wrap vtkEDFCutter filter.
258 extern "C" void vtkEDFCutterCS_Initialize(vtkClientServerInterpreter*);
259 static void vtkEDFHelperInit();
261 void vtkEDFHelperInit(vtkClientServerInterpreter* interp){
262 vtkEDFCutterCS_Initialize(interp);
265 void vtkEDFHelperInit() {
266 vtkClientServerInterpreterInitializer::GetInitializer()->
267 RegisterCallback(&vtkEDFHelperInit);
272 ClientFindOrCreateParavisComponent(_PTR(Study) theStudyDocument)
274 _PTR(SComponent) aSComponent = theStudyDocument->FindComponent("PARAVIS");
276 _PTR(StudyBuilder) aStudyBuilder = theStudyDocument->NewBuilder();
277 aStudyBuilder->NewCommand();
278 int aLocked = theStudyDocument->GetProperties()->IsLocked();
279 if (aLocked) theStudyDocument->GetProperties()->SetLocked(false);
280 aSComponent = aStudyBuilder->NewComponent("PARAVIS");
281 _PTR(GenericAttribute) anAttr =
282 aStudyBuilder->FindOrCreateAttribute(aSComponent, "AttributeName");
283 _PTR(AttributeName) aName (anAttr);
285 CORBA::ORB_var anORB = PARAVIS::PARAVIS_Gen_i::GetORB();
286 SALOME_NamingService *NamingService = new SALOME_NamingService( anORB );
287 CORBA::Object_var objVarN = NamingService->Resolve("/Kernel/ModulCatalog");
288 SALOME_ModuleCatalog::ModuleCatalog_var Catalogue =
289 SALOME_ModuleCatalog::ModuleCatalog::_narrow(objVarN);
290 SALOME_ModuleCatalog::Acomponent_var Comp = Catalogue->GetComponent( "PARAVIS" );
291 if (!Comp->_is_nil()) {
292 aName->SetValue(Comp->componentusername());
295 anAttr = aStudyBuilder->FindOrCreateAttribute(aSComponent, "AttributePixMap");
296 _PTR(AttributePixMap) aPixmap (anAttr);
297 aPixmap->SetPixMap( "pqAppIcon16.png" );
299 // Create Attribute parameters for future using
300 anAttr = aStudyBuilder->FindOrCreateAttribute(aSComponent, "AttributeParameter");
303 PARAVIS::PARAVIS_Gen_var aPARAVIS = PARAVIS::PARAVIS_Gen_i::GetParavisGenImpl()->_this();
305 aStudyBuilder->DefineComponentInstance(aSComponent, aPARAVIS->GetIOR());
306 if (aLocked) theStudyDocument->GetProperties()->SetLocked(true);
307 aStudyBuilder->CommitCommand();
313 Clean up function; used to stop ParaView progress events when
314 exception is caught by global exception handler.
316 void paravisCleanUp()
318 if ( pqApplicationCore::instance() ) {
319 pqServer* s = pqApplicationCore::instance()->getActiveServer();
320 if ( s ) s->session()->GetProgressHandler()->CleanupPendingProgress();
325 \brief Constructor. Sets the default name for the module.
327 PVGUI_Module::PVGUI_Module()
328 : SalomeApp_Module( "PARAVIS" ),
329 // Implementation( 0 ),
330 mySelectionControlsTb( -1 ),
331 mySourcesMenuId( -1 ),
332 myFiltersMenuId( -1 ),
334 myToolbarsMenuId(-1),
341 Q_INIT_RESOURCE( PVGUI );
343 ParavisModule = this;
346 QString aDestPath = QString( "%1/.config/%2/Macros" ).arg( QDir::homePath() ).arg( QApplication::applicationName() );
350 QDir aDestDir(aDestPath);
351 QStringList aDestFiles = aDestDir.entryList(aFilter, QDir::Files);
352 foreach (QString aStr, aDestFiles) {
353 aDestDir.remove(aStr);
360 PVGUI_Module::~PVGUI_Module()
367 \brief Initialize module. Creates menus, prepares context menu, etc.
368 \param app SALOME GUI application instance
370 void PVGUI_Module::initialize( CAM_Application* app )
372 SalomeApp_Module::initialize( app );
374 // Create ParaViS actions
376 // Create ParaViS menus
379 // Uncomment to debug ParaView initialization
380 // "aa" used instead of "i" as GDB doesn't like "i" variables :)
388 // Initialize ParaView client
391 // Create GUI elements (menus, toolbars, dock widgets)
392 //if ( !Implementation ){
393 SalomeApp_Application* anApp = getApp();
394 SUIT_Desktop* aDesktop = anApp->desktop();
396 // connect(aDesktop, SIGNAL()
398 // Remember current state of desktop toolbars
399 QList<QToolBar*> foreignToolbars = aDesktop->findChildren<QToolBar*>();
401 // Simulate ParaView client main window
402 //Implementation = new pqImplementation( aDesktop );
410 // new pqParaViewBehaviors(anApp->desktop(), this);
411 // Has to be replaced in order to exclude using of pqQtMessageHandlerBehaviour
412 // Start pqParaViewBehaviors
413 // Register ParaView interfaces.
414 //pqPluginManager* pgm = pqApplicationCore::instance()->getPluginManager();
415 pqInterfaceTracker* pgm = pqApplicationCore::instance()->interfaceTracker();
417 // * adds support for standard paraview views.
418 pgm->addInterface(new pqStandardViewModules(pgm));
419 pgm->addInterface(new pqStandardSummaryPanelImplementation(pgm));
421 // Load plugins distributed with application.
422 pqApplicationCore::instance()->loadDistributedPlugins();
424 // Define application behaviors.
425 //new pqQtMessageHandlerBehavior(this);
426 new pqDataTimeStepBehavior(this);
427 new pqViewFrameActionsBehavior(this);
428 new pqSpreadSheetVisibilityBehavior(this);
429 new pqPipelineContextMenuBehavior(this);
430 new pqDefaultViewBehavior(this);
431 new pqAlwaysConnectedBehavior(this);
432 new pqPVNewSourceBehavior(this);
433 new pqDeleteBehavior(this);
434 new pqUndoRedoBehavior(this);
435 new pqCrashRecoveryBehavior(this);
436 new pqAutoLoadPluginXMLBehavior(this);
437 new pqPluginDockWidgetsBehavior(aDesktop);
438 //new pqVerifyRequiredPluginBehavior(this);
439 new pqPluginActionGroupBehavior(aDesktop);
440 //new pqFixPathsInStateFilesBehavior(this);
441 new pqCommandLineOptionsBehavior(this);
442 new pqPersistentMainWindowStateBehavior(aDesktop);
443 new pqObjectPickingBehavior(aDesktop);
444 new pqCollaborationBehavior(this);
446 // Setup quick-launch shortcuts.
447 QShortcut *ctrlSpace = new QShortcut(Qt::CTRL + Qt::Key_Space, aDesktop);
448 QObject::connect(ctrlSpace, SIGNAL(activated()),
449 pqApplicationCore::instance(), SLOT(quickLaunch()));
450 QShortcut *altSpace = new QShortcut(Qt::ALT + Qt::Key_Space, aDesktop);
451 QObject::connect(altSpace, SIGNAL(activated()),
452 pqApplicationCore::instance(), SLOT(quickLaunch()));
453 // End pqParaViewBehaviors
456 SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
457 QString aPath = resMgr->stringValue("resources", "PARAVIS", QString());
458 if (!aPath.isNull()) {
459 MyCoreApp->loadConfiguration(aPath + QDir::separator() + "ParaViewFilters.xml");
460 MyCoreApp->loadConfiguration(aPath + QDir::separator() + "ParaViewReaders.xml");
461 MyCoreApp->loadConfiguration(aPath + QDir::separator() + "ParaViewSources.xml");
462 MyCoreApp->loadConfiguration(aPath + QDir::separator() + "ParaViewWriters.xml");
465 // Force creation of engine
466 PARAVIS::GetParavisGen(this);
469 // Find created toolbars
470 QCoreApplication::processEvents();
472 QList<QToolBar*> allToolbars = aDesktop->findChildren<QToolBar*>();
473 foreach(QToolBar* aBar, allToolbars) {
474 if (!foreignToolbars.contains(aBar)) {
475 myToolbars[aBar] = true;
476 myToolbarBreaks[aBar] = false;
477 aBar->setVisible(false);
478 aBar->toggleViewAction()->setVisible(false);
485 // we need to start trace after connection is done
486 connect(pqApplicationCore::instance()->getObjectBuilder(), SIGNAL(finishedAddingServer(pqServer*)),
487 this, SLOT(onFinishedAddingServer(pqServer*)));
489 connect(pqApplicationCore::instance()->getObjectBuilder(), SIGNAL(dataRepresentationCreated(pqDataRepresentation*)),
490 this, SLOT(onDataRepresentationCreated(pqDataRepresentation*)));
493 SUIT_ResourceMgr* aResourceMgr = SUIT_Session::session()->resourceMgr();
494 bool isStop = aResourceMgr->booleanValue( "PARAVIS", "stop_trace", false );
495 // start timer to activate trace in a proper moment
499 this->VTKConnect = vtkEventQtSlotConnect::New();
500 vtkProcessModule* pm = vtkProcessModule::GetProcessModule();
502 this->VTKConnect->Connect(pm, vtkCommand::StartEvent,
503 this, SLOT(onStartProgress()));
504 this->VTKConnect->Connect(pm, vtkCommand::EndEvent,
505 this, SLOT(onEndProgress()));
507 connect(&pqActiveObjects::instance(),
508 SIGNAL(representationChanged(pqRepresentation*)),
509 this, SLOT(onRepresentationChanged(pqRepresentation*)));
512 void PVGUI_Module::onStartProgress()
514 QApplication::setOverrideCursor(Qt::WaitCursor);
517 void PVGUI_Module::onEndProgress()
519 QApplication::restoreOverrideCursor();
522 void PVGUI_Module::onFinishedAddingServer(pqServer* /*server*/)
524 SUIT_ResourceMgr* aResourceMgr = SUIT_Session::session()->resourceMgr();
525 bool isStop = aResourceMgr->booleanValue( "PARAVIS", "stop_trace", false );
530 void PVGUI_Module::onDataRepresentationCreated(pqDataRepresentation* data) {
534 if(!data->getLookupTable())
537 SUIT_ResourceMgr* aResourceMgr = SUIT_Session::session()->resourceMgr();
541 bool visible = aResourceMgr->booleanValue( "PARAVIS", "show_color_legend", false );
542 pqLookupTableManager* lut_mgr = pqApplicationCore::instance()->getLookupTableManager();
545 lut_mgr->setScalarBarVisibility(data,visible);
548 connect(data, SIGNAL(dataUpdated()), this, SLOT(onDataRepresentationUpdated()));
551 void PVGUI_Module::onDataRepresentationUpdated() {
552 SalomeApp_Study* activeStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
553 if(!activeStudy) return;
555 activeStudy->Modified();
558 void PVGUI_Module::onVariableChanged(pqVariableType t, const QString) {
560 pqDisplayColorWidget* colorWidget = qobject_cast<pqDisplayColorWidget*>(sender());
564 if( t == VARIABLE_TYPE_NONE )
567 pqDataRepresentation* data = colorWidget->getRepresentation();
569 if( !data->getLookupTable() )
572 SUIT_ResourceMgr* aResourceMgr = SUIT_Session::session()->resourceMgr();
577 bool visible = aResourceMgr->booleanValue( "PARAVIS", "show_color_legend", false );
582 pqLookupTableManager* lut_mgr = pqApplicationCore::instance()->getLookupTableManager();
585 lut_mgr->setScalarBarVisibility(data,visible);
592 \brief Launches a tracing of current server
594 void PVGUI_Module::timerEvent(QTimerEvent* te )
597 PyInterp_Dispatcher* aDispatcher = PyInterp_Dispatcher::Get();
598 if ( !aDispatcher->IsBusy() ) {
599 pqPythonManager* manager = qobject_cast<pqPythonManager*>
600 ( pqApplicationCore::instance()->manager( "PYTHON_MANAGER" ) );
602 pqPythonDialog* pyDiag = manager->pythonShellDialog();
604 pqPythonShell* shell = pyDiag->shell();
606 QString script = "from paraview import smtrace\nsmtrace.start_trace()\n";
607 shell->executeScript(script);
608 killTimer( te->timerId() );
616 void PVGUI_Module::updateMacros()
618 pqPythonManager* aPythonManager = pqPVApplicationCore::instance()->pythonManager();
619 if(!aPythonManager) {
623 QString aRootDir = getenv("PARAVIS_ROOT_DIR");
625 QString aSourcePath = aRootDir + "/bin/salome/Macro";
630 QDir aSourceDir(aSourcePath);
631 QStringList aSourceFiles = aSourceDir.entryList(aFilter, QDir::Files);
632 foreach (QString aStr, aSourceFiles) {
633 aPythonManager->addMacro(aSourcePath + "/" + aStr);
639 \brief Get list of compliant dockable GUI elements
640 \param m map to be filled in ("type":"default_position")
642 void PVGUI_Module::windows( QMap<int, int>& m ) const
644 m.insert( LightApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
645 m.insert( LightApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
646 // ParaView diagnostic output redirected here
647 m.insert( LightApp_Application::WT_LogWindow, Qt::BottomDockWidgetArea );
651 \brief Static method, performs initialization of ParaView session.
652 \return \c true if ParaView has been initialized successfully, otherwise false
654 bool PVGUI_Module::pvInit()
656 // if ( !pqImplementation::Core ){
658 // Obtain command-line arguments
661 QString aOptions = getenv("PARAVIS_OPTIONS");
662 QStringList aOptList = aOptions.split(":", QString::SkipEmptyParts);
663 argv = new char*[aOptList.size() + 1];
664 QStringList args = QApplication::arguments();
665 argv[0] = (args.size() > 0)? strdup(args[0].toLatin1().constData()) : strdup("paravis");
668 foreach (QString aStr, aOptList) {
669 argv[argc] = strdup( aStr.toLatin1().constData() );
672 MyCoreApp = new pqPVApplicationCore (argc, argv);
673 if (MyCoreApp->getOptions()->GetHelpSelected() ||
674 MyCoreApp->getOptions()->GetUnknownArgument() ||
675 MyCoreApp->getOptions()->GetErrorMessage() ||
676 MyCoreApp->getOptions()->GetTellVersion()) {
680 // Not sure why this is needed. Andy added this ages ago with comment saying
681 // needed for Mac apps. Need to check that it's indeed still required.
682 QDir dir(QApplication::applicationDirPath());
685 QApplication::addLibraryPath(dir.absolutePath());
686 // Load required application plugins.
687 QString plugin_string = "";
688 QStringList plugin_list = plugin_string.split(';',QString::SkipEmptyParts);
689 pqBrandPluginsLoader loader;
690 if (loader.loadPlugins(plugin_list) == false) {
691 printf("Failed to load required plugins for this application\n");
695 // Load optional plugins.
697 plugin_list = plugin_string.split(';',QString::SkipEmptyParts);
698 loader.loadPlugins(plugin_list, true); //quietly skip not-found plugins.
700 // End of Initializer code
702 vtkOutputWindow::SetInstance(PVGUI_OutputWindowAdapter::New());
704 new pqTabbedMultiViewWidget(); // it registers as "MULTIVIEW_WIDGET on creation
706 for (int i = 0; i < argc; i++)
715 \brief Shows (toShow = true) or hides ParaView view window
717 void PVGUI_Module::showView( bool toShow )
719 SalomeApp_Application* anApp = getApp();
720 PVGUI_ViewManager* viewMgr =
721 dynamic_cast<PVGUI_ViewManager*>( anApp->getViewManager( PVGUI_Viewer::Type(), false ) );
723 viewMgr = new PVGUI_ViewManager( anApp->activeStudy(), anApp->desktop() );
724 anApp->addViewManager( viewMgr );
725 connect( viewMgr, SIGNAL( lastViewClosed( SUIT_ViewManager* ) ),
726 anApp, SLOT( onCloseView( SUIT_ViewManager* ) ) );
729 PVGUI_ViewWindow* pvWnd = dynamic_cast<PVGUI_ViewWindow*>( viewMgr->getActiveView() );
731 pvWnd = dynamic_cast<PVGUI_ViewWindow*>( viewMgr->createViewWindow() );
734 pvWnd->setShown( toShow );
735 if ( toShow ) pvWnd->setFocus();
739 \brief Slot to show help for proxy.
741 void PVGUI_Module::showHelpForProxy( const QString& groupname, const QString& proxyname )
743 pqHelpReaction::showProxyHelp(groupname, proxyname);
748 \brief Slot to show the waiting state.
750 void PVGUI_Module::onPreAccept()
752 getApp()->desktop()->statusBar()->showMessage(tr("STB_PREACCEPT"));
753 QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
757 \brief Slot to show the ready state.
759 void PVGUI_Module::onPostAccept()
761 getApp()->desktop()->statusBar()->showMessage(tr("STB_POSTACCEPT"), 2000);
762 QTimer::singleShot(0, this, SLOT(endWaitCursor()));
766 \brief Slot to switch off wait cursor.
768 void PVGUI_Module::endWaitCursor()
770 QApplication::restoreOverrideCursor();
774 \brief Returns the ParaView multi-view manager.
776 pqTabbedMultiViewWidget* PVGUI_Module::getMultiViewManager() const
778 return qobject_cast<pqTabbedMultiViewWidget*>(pqApplicationCore::instance()->manager("MULTIVIEW_WIDGET"));
782 static void ParavisMessageOutput(QtMsgType type, const char *msg)
787 vtkOutputWindow::GetInstance()->DisplayText(msg);
790 vtkOutputWindow::GetInstance()->DisplayErrorText(msg);
793 vtkOutputWindow::GetInstance()->DisplayErrorText(msg);
796 vtkOutputWindow::GetInstance()->DisplayErrorText(msg);
804 \brief Activate module.
805 \param study current study
806 \return \c true if activaion is done successfully or 0 to prevent
809 bool PVGUI_Module::activateModule( SUIT_Study* study )
811 myOldMsgHandler = qInstallMsgHandler(ParavisMessageOutput);
813 SUIT_ExceptionHandler::addCleanUpRoutine( paravisCleanUp );
815 bool isDone = SalomeApp_Module::activateModule( study );
816 if ( !isDone ) return false;
819 if ( mySourcesMenuId != -1 ) menuMgr()->show(mySourcesMenuId);
820 if ( myFiltersMenuId != -1 ) menuMgr()->show(myFiltersMenuId);
821 if ( myFiltersMenuId != -1 ) menuMgr()->show(myMacrosMenuId);
822 if ( myFiltersMenuId != -1 ) menuMgr()->show(myToolbarsMenuId);
823 setMenuShown( true );
824 setToolShown( true );
826 restoreDockWidgetsState();
828 QMenu* aMenu = menuMgr()->findMenu( myRecentMenuId );
830 QList<QAction*> anActns = aMenu->actions();
831 for (int i = 0; i < anActns.size(); ++i) {
832 QAction* a = anActns.at(i);
838 if ( myRecentMenuId != -1 ) menuMgr()->show(myRecentMenuId);
840 ClientFindOrCreateParavisComponent(PARAVIS::GetCStudy(this));
847 \brief Deactivate module.
848 \param study current study
849 \return \c true if deactivaion is done successfully or 0 to prevent
850 deactivation on error
852 bool PVGUI_Module::deactivateModule( SUIT_Study* study )
854 QMenu* aMenu = menuMgr()->findMenu( myRecentMenuId );
856 QList<QAction*> anActns = aMenu->actions();
857 for (int i = 0; i < anActns.size(); ++i) {
858 QAction* a = anActns.at(i);
860 a->setVisible(false);
864 QList<QDockWidget*> aStreamingViews = application()->desktop()->findChildren<QDockWidget*>("pqStreamingControls");
865 foreach(QDockWidget* aView, aStreamingViews) {
866 if (!myDockWidgets.contains(aView))
867 myDockWidgets[aView] = aView->isVisible();
870 /*if (pqImplementation::helpWindow) {
871 pqImplementation::helpWindow->hide();
875 menuMgr()->hide(myRecentMenuId);
876 menuMgr()->hide(mySourcesMenuId);
877 menuMgr()->hide(myFiltersMenuId);
878 menuMgr()->hide(myMacrosMenuId);
879 menuMgr()->hide(myToolbarsMenuId);
880 setMenuShown( false );
881 setToolShown( false );
884 saveDockWidgetsState();
886 SUIT_ExceptionHandler::removeCleanUpRoutine( paravisCleanUp );
889 qInstallMsgHandler(myOldMsgHandler);
891 return SalomeApp_Module::deactivateModule( study );
896 \brief Called when application is closed.
898 Process finalize application functionality from ParaView in order to save server settings
899 and nullify application pointer if the application is being closed.
901 \param theApp application
903 void PVGUI_Module::onApplicationClosed( SUIT_Application* theApp )
905 pqApplicationCore::instance()->settings()->sync();
906 int aAppsNb = SUIT_Session::session()->applications().size();
908 deleteTemporaryFiles();
909 MyCoreApp->deleteLater();
911 CAM_Module::onApplicationClosed(theApp);
916 \brief Called when study is closed.
918 Removes data model from the \a study.
920 \param study study being closed
922 void PVGUI_Module::studyClosed(SUIT_Study* study)
924 clearParaviewState();
926 SalomeApp_Module::studyClosed(study);
930 \brief Called when study is opened.
932 void PVGUI_Module::onModelOpened()
934 _PTR(Study) studyDS = PARAVIS::GetCStudy(this);
939 _PTR(SComponent) paravisComp =
940 studyDS->FindComponent(PARAVIS::GetParavisGen(this)->ComponentDataType());
945 _PTR(ChildIterator) anIter(studyDS->NewChildIterator(paravisComp));
946 for (; anIter->More(); anIter->Next()) {
947 _PTR(SObject) aSObj = anIter->Value();
948 _PTR(GenericAttribute) anAttr;
949 if (!aSObj->FindAttribute(anAttr, "AttributeLocalID")) {
952 _PTR(AttributeLocalID) anID(anAttr);
953 if (anID->Value() == PVSTATEID) {
960 \brief Returns IOR of current engine
962 QString PVGUI_Module::engineIOR() const
964 CORBA::String_var anIOR = PARAVIS::GetParavisGen(this)->GetIOR();
965 return QString(anIOR.in());
970 \brief Open file of format supported by ParaView
972 void PVGUI_Module::openFile(const char* theName)
976 pqLoadDataReaction::loadData(aFiles);
979 void PVGUI_Module::executeScript(const char *script)
982 pqPythonManager* manager = qobject_cast<pqPythonManager*>(
983 pqApplicationCore::instance()->manager("PYTHON_MANAGER"));
985 pqPythonDialog* pyDiag = manager->pythonShellDialog();
987 pyDiag->runString(script);
994 \brief Returns trace string
996 static const QString MYReplaceStr("paraview.simple");
997 static const QString MYReplaceImportStr("except: from pvsimple import *");
998 QString PVGUI_Module::getTraceString()
1000 QString traceString;
1002 pqPythonManager* manager = qobject_cast<pqPythonManager*>(
1003 pqApplicationCore::instance()->manager("PYTHON_MANAGER"));
1005 pqPythonDialog* pyDiag = manager->pythonShellDialog();
1007 pyDiag->runString("from paraview import smtrace\n"
1008 "__smtraceString = smtrace.get_trace_string()\n");
1009 pyDiag->shell()->makeCurrent();
1010 PyObject* main_module = PyImport_AddModule((char*)"__main__");
1011 PyObject* global_dict = PyModule_GetDict(main_module);
1012 PyObject* string_object = PyDict_GetItemString(global_dict, "__smtraceString");
1013 char* string_ptr = string_object ? PyString_AsString(string_object) : 0;
1015 traceString = string_ptr;
1017 pyDiag->shell()->releaseControl();
1020 if ((!traceString.isNull()) && traceString.length() != 0) {
1021 int aPos = traceString.indexOf(MYReplaceStr);
1022 while (aPos != -1) {
1023 traceString = traceString.replace(aPos, MYReplaceStr.length(), "pvsimple");
1024 aPos = traceString.indexOf(MYReplaceStr, aPos);
1026 int aImportPos = traceString.indexOf(MYReplaceImportStr);
1027 if(aImportPos != -1)
1029 traceString = traceString.replace(aImportPos, MYReplaceImportStr.length(), "except:\n import pvsimple\n from pvsimple import *");
1037 \brief Saves trace string to disk file
1039 void PVGUI_Module::saveTrace(const char* theName)
1041 QFile file(theName);
1042 if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
1043 MESSAGE( "Could not open file:" << theName );
1046 QTextStream out(&file);
1047 out << getTraceString();
1052 \brief Saves ParaView state to a disk file
1054 void PVGUI_Module::saveParaviewState(const char* theFileName)
1056 pqApplicationCore::instance()->saveState(theFileName);
1060 \brief Delete all objects for Paraview Pipeline Browser
1062 void PVGUI_Module::clearParaviewState()
1064 QAction* deleteAllAction = action(DeleteAllId);
1065 if (deleteAllAction) {
1066 deleteAllAction->activate(QAction::Trigger);
1071 \brief Restores ParaView state from a disk file
1073 If toClear == true, the current ojects will be deleted
1075 void PVGUI_Module::loadParaviewState(const char* theFileName)
1077 pqApplicationCore::instance()->loadState(theFileName, getActiveServer());
1081 \brief Imports MED data from VISU module by data entry
1083 void PVGUI_Module::onImportFromVisu(QString theEntry)
1086 SUIT_OverrideCursor aWaitCursor;
1089 SalomeApp_Study* activeStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
1090 if(!activeStudy) return;
1092 // get SALOMEDS client study
1093 _PTR(Study) aStudy = activeStudy->studyDS();
1096 // find VISU component in a study
1097 _PTR(SComponent) aVisuComp = aStudy->FindComponent( "VISU" );
1098 if(!aVisuComp) return;
1100 // get SObject client by entry
1101 _PTR(SObject) aSObj = aStudy->FindObjectID(qPrintable(theEntry));
1104 // get CORBA SObject
1105 SALOMEDS_SObject* aSObject = _CAST(SObject, aSObj);
1106 if ( !aSObject ) return;
1109 SALOME_NamingService* aNamingService = SalomeApp_Application::namingService();
1110 SALOME_LifeCycleCORBA aLCC(aNamingService);
1112 Engines::EngineComponent_var aComponent = aLCC.FindOrLoad_Component("FactoryServer","VISU");
1113 VISU::VISU_Gen_var aVISU = VISU::VISU_Gen::_narrow(aComponent);
1114 if(CORBA::is_nil(aVISU)) return;
1116 _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1117 aStudyBuilder->LoadWith( aVisuComp, SalomeApp_Application::orb()->object_to_string(aVISU) );
1119 // get VISU result object
1120 CORBA::Object_var aResultObject = aSObject->GetObject();
1121 if (CORBA::is_nil(aResultObject)) return;
1122 VISU::Result_var aResult = VISU::Result::_narrow( aResultObject );
1123 if (CORBA::is_nil(aResult)) return;
1125 // export VISU result to the MED file
1126 std::string aTmpDir = SALOMEDS_Tool::GetTmpDir();
1127 std::string aFileName = aSObject->GetName();
1128 std::string aFilePath = aTmpDir + aFileName;
1130 if (aResult->ExportMED(aFilePath.c_str())) {
1131 openFile(aFilePath.c_str());
1132 myTemporaryFiles.append(QString(aFilePath.c_str()));
1135 MESSAGE("Visu module is not found.");
1140 \brief Deletes temporary files created during import operation from VISU
1142 void PVGUI_Module::deleteTemporaryFiles()
1144 foreach(QString aFile, myTemporaryFiles) {
1145 if (QFile::exists(aFile)) {
1146 QFile::remove(aFile);
1153 \brief Returns current active ParaView server
1155 pqServer* PVGUI_Module::getActiveServer()
1157 return pqApplicationCore::instance()->getActiveServer();
1162 \brief Creates PARAVIS preference pane
1164 void PVGUI_Module::createPreferences()
1166 // Paraview settings tab
1167 int aParaViewSettingsTab = addPreference( tr( "TIT_PVIEWSETTINGS" ) );
1168 int aPanel = addPreference(QString(), aParaViewSettingsTab, LightApp_Preferences::UserDefined, "PARAVIS", "");
1169 setPreferenceProperty(aPanel, "content", (qint64)(new PVGUI_ParaViewSettingsPane()));
1171 // Paravis settings tab
1172 int aParaVisSettingsTab = addPreference( tr( "TIT_PVISSETTINGS" ) );
1173 addPreference( tr( "PREF_STOP_TRACE" ), aParaVisSettingsTab, LightApp_Preferences::Bool, "PARAVIS", "stop_trace");
1175 int aSaveType = addPreference(tr( "PREF_SAVE_TYPE_LBL" ), aParaVisSettingsTab,
1176 LightApp_Preferences::Selector,
1177 "PARAVIS", "savestate_type");
1178 QList<QVariant> aIndices;
1179 QStringList aStrings;
1181 aStrings<<tr("PREF_SAVE_TYPE_0");
1182 aStrings<<tr("PREF_SAVE_TYPE_1");
1183 aStrings<<tr("PREF_SAVE_TYPE_2");
1184 setPreferenceProperty(aSaveType, "strings", aStrings);
1185 setPreferenceProperty(aSaveType, "indexes", aIndices);
1187 //rnv: imp 21712: [CEA 581] Preference to display legend by default
1188 int aDispColoreLegend = addPreference( tr( "PREF_SHOW_COLOR_LEGEND" ), aParaVisSettingsTab,
1189 LightApp_Preferences::Bool, "PARAVIS", "show_color_legend");
1193 \brief Creates ParaViS context menu popup
1195 void PVGUI_Module::contextMenuPopup(const QString& theClient, QMenu* theMenu, QString& theTitle)
1197 SalomeApp_Module::contextMenuPopup(theClient, theMenu, theTitle);
1199 // Check if we are in Object Browser
1200 SUIT_DataBrowser* ob = getApp()->objectBrowser();
1201 bool isOBClient = (ob && theClient == ob->popupClientType());
1206 // Get list of selected objects
1207 LightApp_SelectionMgr* aSelectionMgr = getApp()->selectionMgr();
1208 SALOME_ListIO aListIO;
1209 aSelectionMgr->selectedObjects(aListIO);
1210 if (aListIO.Extent() == 1 && aListIO.First()->hasEntry()) {
1211 QString entry = QString(aListIO.First()->getEntry());
1214 SalomeApp_Study* activeStudy =
1215 dynamic_cast<SalomeApp_Study*>(getApp()->activeStudy());
1220 // Get SALOMEDS client study
1221 _PTR(Study) studyDS = activeStudy->studyDS();
1226 QString paravisDataType(PARAVIS::GetParavisGen(this)->ComponentDataType());
1227 if(activeStudy && activeStudy->isComponent(entry) &&
1228 activeStudy->componentDataType(entry) == paravisDataType) {
1229 // ParaViS module object
1230 theMenu->addSeparator();
1231 theMenu->addAction(action(SaveStatePopupId));
1234 // Try to get state object
1235 _PTR(SObject) stateSObj =
1236 studyDS->FindObjectID(entry.toLatin1().constData());
1242 _PTR(GenericAttribute) anAttr;
1243 if (!stateSObj->FindAttribute(anAttr, "AttributeLocalID")) {
1247 _PTR(AttributeLocalID) anID(anAttr);
1249 if (anID->Value() == PVSTATEID) {
1250 // Paraview state object
1251 theMenu->addSeparator();
1252 theMenu->addAction(action(AddStatePopupId));
1253 theMenu->addAction(action(CleanAndAddStatePopupId));
1254 theMenu->addSeparator();
1255 theMenu->addAction(action(ParaVisRenameId));
1256 theMenu->addAction(action(ParaVisDeleteId));
1262 void PVGUI_Module::onShowTrace()
1264 if (!myTraceWindow) {
1265 myTraceWindow = new pqPythonScriptEditor(getApp()->desktop());
1267 myTraceWindow->setText(getTraceString());
1268 myTraceWindow->show();
1269 myTraceWindow->raise();
1270 myTraceWindow->activateWindow();
1274 \brief Show ParaView view.
1276 void PVGUI_Module::onNewParaViewWindow()
1282 \brief Save state under the module root object.
1284 void PVGUI_Module::onSaveMultiState()
1286 // Create state study object
1288 // Get SALOMEDS client study
1289 _PTR(Study) studyDS = PARAVIS::GetCStudy(this);
1294 _PTR(SComponent) paravisComp =
1295 studyDS->FindComponent(PARAVIS::GetParavisGen(this)->ComponentDataType());
1300 // Unlock the study if it is locked
1301 bool isLocked = studyDS->GetProperties()->IsLocked();
1303 studyDS->GetProperties()->SetLocked(false);
1306 QString stateName = tr("SAVED_PARAVIEW_STATE_NAME") +
1307 QString::number(myStateCounter + 1);
1309 _PTR(StudyBuilder) studyBuilder = studyDS->NewBuilder();
1310 _PTR(SObject) newSObj = studyBuilder->NewObject(paravisComp);
1313 _PTR(GenericAttribute) anAttr;
1314 anAttr = studyBuilder->FindOrCreateAttribute(newSObj, "AttributeName");
1315 _PTR(AttributeName) nameAttr(anAttr);
1317 nameAttr->SetValue(stateName.toLatin1().constData());
1320 anAttr = studyBuilder->FindOrCreateAttribute(newSObj, "AttributeLocalID");
1321 _PTR(AttributeLocalID) localIdAttr(anAttr);
1323 localIdAttr->SetValue(PVSTATEID);
1326 QString stateEntry = QString::fromStdString(newSObj->GetID());
1328 // File name for state saving
1329 QString tmpDir = QString::fromStdString(SALOMEDS_Tool::GetTmpDir());
1330 QString fileName = QString("%1_paravisstate:%2").arg(tmpDir,
1333 anAttr = studyBuilder->FindOrCreateAttribute(newSObj, "AttributeString");
1334 _PTR(AttributeString) stringAttr(anAttr);
1336 stringAttr->SetValue(fileName.toLatin1().constData());
1338 // Lock the study back if necessary
1340 studyDS->GetProperties()->SetLocked(true);
1344 saveParaviewState(fileName.toLatin1().constData());
1345 myTemporaryFiles.append(fileName);
1347 // Increment the counter
1354 \brief Restore the selected state by merging with the current one.
1356 void PVGUI_Module::onAddState()
1358 loadSelectedState(false);
1362 \brief Clean the current state and restore the selected one.
1364 void PVGUI_Module::onCleanAddState()
1366 loadSelectedState(true);
1370 \brief Rename the selected object.
1372 void PVGUI_Module::onRename()
1374 LightApp_SelectionMgr* aSelectionMgr = getApp()->selectionMgr();
1375 SALOME_ListIO aListIO;
1376 aSelectionMgr->selectedObjects(aListIO);
1378 if (aListIO.Extent() == 1 && aListIO.First()->hasEntry()) {
1379 std::string entry = aListIO.First()->getEntry();
1381 // Get SALOMEDS client study
1382 _PTR(Study) studyDS = PARAVIS::GetCStudy(this);
1387 // Unlock the study if it is locked
1388 bool isLocked = studyDS->GetProperties()->IsLocked();
1390 studyDS->GetProperties()->SetLocked(false);
1393 // Rename the selected state object
1394 _PTR(SObject) stateSObj = studyDS->FindObjectID(entry);
1399 _PTR(GenericAttribute) anAttr;
1400 if (stateSObj->FindAttribute(anAttr, "AttributeName")) {
1401 _PTR(AttributeName) nameAttr (anAttr);
1403 LightApp_NameDlg::getName(getApp()->desktop(), nameAttr->Value().c_str());
1404 if (!newName.isEmpty()) {
1405 nameAttr->SetValue(newName.toLatin1().constData());
1406 aListIO.First()->setName(newName.toLatin1().constData());
1410 // Lock the study back if necessary
1412 studyDS->GetProperties()->SetLocked(true);
1415 // Update object browser
1422 \brief Delete the selected objects.
1424 void PVGUI_Module::onDelete()
1426 LightApp_SelectionMgr* aSelectionMgr = getApp()->selectionMgr();
1427 SALOME_ListIO aListIO;
1428 aSelectionMgr->selectedObjects(aListIO);
1430 if (aListIO.Extent() == 1 && aListIO.First()->hasEntry()) {
1431 std::string entry = aListIO.First()->getEntry();
1433 // Get SALOMEDS client study
1434 _PTR(Study) studyDS = PARAVIS::GetCStudy(this);
1439 // Unlock the study if it is locked
1440 bool isLocked = studyDS->GetProperties()->IsLocked();
1442 studyDS->GetProperties()->SetLocked(false);
1445 // Remove the selected state from the study
1446 _PTR(StudyBuilder) studyBuilder = studyDS->NewBuilder();
1447 _PTR(SObject) stateSObj = studyDS->FindObjectID(entry);
1448 studyBuilder->RemoveObject(stateSObj);
1450 // Lock the study back if necessary
1452 studyDS->GetProperties()->SetLocked(true);
1455 // Update object browser
1461 \brief Discover help project files from the resources.
1462 \return name of the help file.
1464 QString PVGUI_Module::getHelpFileName() {
1465 QString aPVHome(getenv("PVHOME"));
1466 if (aPVHome.isNull()) {
1467 qWarning("Wariable PVHOME is not defined");
1470 QChar aSep = QDir::separator();
1471 //PARAVIEW_VERSION from the vtkPVConfig.h file
1472 QString aFileName = aPVHome + aSep + "share" + aSep + "doc" + aSep + "paraview-"+ PARAVIEW_VERSION + aSep + "paraview.qch";
1478 \brief Load selected paraview state
1480 If toClear == true, the current state will be cleared
1482 void PVGUI_Module::loadSelectedState(bool toClear)
1486 LightApp_SelectionMgr* aSelectionMgr = getApp()->selectionMgr();
1487 SALOME_ListIO aListIO;
1488 aSelectionMgr->selectedObjects(aListIO);
1490 if (aListIO.Extent() == 1 && aListIO.First()->hasEntry()) {
1491 std::string entry = aListIO.First()->getEntry();
1493 // Get SALOMEDS client study
1494 _PTR(Study) studyDS = PARAVIS::GetCStudy(this);
1500 _PTR(SObject) stateSObj = studyDS->FindObjectID(entry);
1501 _PTR(GenericAttribute) anAttr;
1502 if (!stateSObj->FindAttribute(anAttr, "AttributeLocalID")) {
1505 _PTR(AttributeLocalID) anID(anAttr);
1506 if (!anID->Value() == PVSTATEID) {
1510 // Get state file name
1511 if (stateSObj->FindAttribute(anAttr, "AttributeString")) {
1512 _PTR(AttributeString) aStringAttr(anAttr);
1513 QString stringValue(aStringAttr->Value().c_str());
1515 if (QFile::exists(stringValue)) {
1516 fileName = stringValue;
1521 if (!fileName.isEmpty()) {
1523 clearParaviewState();
1526 loadParaviewState(fileName.toLatin1().constData());
1529 SUIT_MessageBox::critical(getApp()->desktop(),
1531 tr("ERR_STATE_CANNOT_BE_RESTORED"));
1535 void PVGUI_Module::onRepresentationChanged(pqRepresentation*) {
1538 //rnv: to fix the issue "21712: [CEA 581] Preference to display legend by default"
1539 // find the pqDisplayColorWidget instances and connect the variableChanged SIGNAL on the
1540 // onVariableChanged slot of this class. This connection needs to change visibility
1541 // of the "Colored Legend" after change the "Color By" array.
1542 QList<pqDisplayColorWidget*> aWidget = getApp()->desktop()->findChildren<pqDisplayColorWidget*>();
1544 for (int i = 0; i < aWidget.size() ; i++ ) {
1546 connect( aWidget[i], SIGNAL ( variableChanged ( pqVariableType, const QString ) ),
1547 this, SLOT(onVariableChanged( pqVariableType, const QString) ), Qt::UniqueConnection );
1554 \fn CAM_Module* createModule();
1555 \brief Export module instance (factory function).
1556 \return new created instance of the module
1560 #define PVGUI_EXPORT __declspec(dllexport)
1562 #define PVGUI_EXPORT
1568 PVGUI_EXPORT CAM_Module* createModule() {
1573 return new PVGUI_Module();
1576 PVGUI_EXPORT char* getModuleVersion() {
1577 return (char*)PARAVIS_VERSION_STR;