src/PVGUI/PVGUI_Module.cxx

   1 // PARAVIS : ParaView wrapper SALOME module
   2 //
   3 // Copyright (C) 2010-2012  CEA/DEN, EDF R&D
   4 //
   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.
   9 //
  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.
  14 //
  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
  18 //
  19 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  20 //
  21 // File   : PVGUI_Module.cxx
  22 // Author : Julia DOROVSKIKH
  23
  24 #include <Standard_math.hxx>  // E.A. must be included before Python.h to fix compilation on windows
  25 #ifdef HAVE_FINITE
  26 #undef HAVE_FINITE            // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
  27 #endif
  28 #include <vtkPython.h> // Python first
  29 #include "PVGUI_Module.h"
  30
  31 #include "SALOMEconfig.h"
  32 #ifdef WITH_VISU
  33 #include CORBA_CLIENT_HEADER(VISU_Gen)
  34 #endif
  35 #include CORBA_SERVER_HEADER(SALOMEDS)
  36
  37
  38 #include "PARAVIS_Gen_i.hh"
  39
  40 #include "PV_Tools.h"
  41
  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"
  48
  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>
  56
  57 // SALOME Includes
  58 #include "SALOME_LifeCycleCORBA.hxx"
  59 #include "SALOMEDS_SObject.hxx"
  60
  61 #include "LightApp_SelectionMgr.h"
  62 #include "LightApp_NameDlg.h"
  63
  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>
  69
  70 #include <QtxActionMenuMgr.h>
  71 #include <QtxActionToolMgr.h>
  72
  73 #include <QAction>
  74 #include <QApplication>
  75 #include <QCursor>
  76 #include <QDir>
  77 #include <QFile>
  78 #include <QFileInfo>
  79 #include <QIcon>
  80 #include <QInputDialog>
  81 #include <QMenu>
  82 #include <QStatusBar>
  83 #include <QString>
  84 #include <QStringList>
  85 #include <QTimer>
  86 #include <QToolBar>
  87 #include <QTextStream>
  88 #include <QShortcut>
  89 #include <QDockWidget>
  90 #include <QHelpEngine>
  91
  92 #include <pqApplicationCore.h>
  93 #include <pqPVApplicationCore.h>
  94 #include <pqActiveView.h>
  95 #include <pqObjectBuilder.h>
  96 #include <pqOptions.h>
  97 #include <pqRenderView.h>
  98 #include <pqServer.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>
 127 #include <pqColorToolbar.h>
 128 #include <pqScalarBarVisibilityReaction.h>
 129 #include <pqStandardPropertyWidgetInterface.h>
 130 #include <pqMultiServerBehavior.h>
 131 #include <pqViewStreamingBehavior.h>
 132
 133 #include <PARAVIS_version.h>
 134
 135 #include <vtkPVConfig.h>
 136
 137 #include <PVGUI_MatplotlibMathTextUtilities.h>
 138
 139 #include CORBA_SERVER_HEADER(SALOME_ModuleCatalog)
 140
 141 /*
 142  * Make sure all the kits register their classes with vtkInstantiator.
 143  * Since ParaView uses Tcl wrapping, all of VTK is already compiled in
 144  * anyway.  The instantiators will add no more code for the linker to
 145  * collect.
 146  */
 147
 148 //#include <vtkCommonInstantiator.h>
 149 //#include <vtkFilteringInstantiator.h>
 150 //#include <vtkGenericFilteringInstantiator.h>
 151 //#include <vtkIOInstantiator.h>
 152 //#include <vtkImagingInstantiator.h>
 153 //#include <vtkInfovisInstantiator.h>
 154 //#include <vtkGraphicsInstantiator.h>
 155
 156 //#include <vtkRenderingInstantiator.h>
 157 //#include <vtkVolumeRenderingInstantiator.h>
 158 //#include <vtkHybridInstantiator.h>
 159 //#include <vtkParallelInstantiator.h>
 160
 161 #include <pqAlwaysConnectedBehavior.h>
 162 #include <pqApplicationCore.h>
 163 #include <pqAutoLoadPluginXMLBehavior.h>
 164 #include <pqCommandLineOptionsBehavior.h>
 165 #include <pqCrashRecoveryBehavior.h>
 166 #include <pqDataTimeStepBehavior.h>
 167 #include <pqDefaultViewBehavior.h>
 168 #include <pqDeleteBehavior.h>
 169 #include <pqObjectPickingBehavior.h>
 170 #include <pqPersistentMainWindowStateBehavior.h>
 171 #include <pqPipelineContextMenuBehavior.h>
 172 #include <pqPluginActionGroupBehavior.h>
 173 #include <pqPluginDockWidgetsBehavior.h>
 174 #include <pqPluginManager.h>
 175 #include <pqPVNewSourceBehavior.h>
 176 #include <pqSpreadSheetVisibilityBehavior.h>
 177 #include <pqStandardViewModules.h>
 178 #include <pqUndoRedoBehavior.h>
 179 #include <pqViewFrameActionsBehavior.h>
 180 #include <pqServerManagerObserver.h>
 181
 182 #include <vtkClientServerInterpreterInitializer.h>
 183
 184
 185 //----------------------------------------------------------------------------
 186 pqPVApplicationCore* PVGUI_Module::MyCoreApp = 0;
 187 //PVGUI_OutputWindowAdapter* PVGUI_Module::pqImplementation::OutputWindowAdapter = 0;
 188 //QPointer<pqHelpWindow> PVGUI_Module::pqImplementation::helpWindow = 0;
 189
 190 PVGUI_Module* ParavisModule = 0;
 191
 192 /*!
 193   \mainpage
 194
 195   <h2>Building and installing PARAVIS</h2>
 196   As any other SALOME module, PARAVIS requires PARAVIS_ROOT_DIR environment variable to be set to PARAVIS
 197   installation directory.
 198   Other variables needed for correct detection of ParaView location:
 199   \li PVHOME - points at the ParaView installation directory tree
 200   \li PVVERSION - number of ParaView version
 201
 202   It also requires common SALOME environment including GUI_ROOT_DIR and other prerequsites.
 203
 204
 205   PARAVIS module can be launched using the following commands:
 206   \li Full SALOME configuration
 207   \code
 208   runSalome --modules="PARAVIS"
 209   \endcode
 210
 211   <h2>ParaView GUI integration</h2>
 212   <h3>ParaView GUI integration overview</h3>
 213
 214   The main idea is to reuse ParaView GUI internal logic as much as possible, providing a layer
 215   between it and SALOME GUI that hides the following SALOME GUI implementation details from ParaView:
 216
 217   \li SALOME GUI executable and Qt event loop
 218   \li SALOME GUI desktop
 219   \li Dock windows areas
 220   \li SALOME menu and toolbar managers
 221
 222   Major part of the integration is implemented in PVGUI_Module class.
 223
 224   <h3>ParaView client initalization</h3>
 225
 226   ParaView client initalization is performed when an instance of PVGUI_Module class has been created
 227   and \link PVGUI_Module::initialize() PVGUI_Module::initialize()\endlink method is called by SALOME GUI.
 228   The actual client start-up is done in \link PVGUI_Module::pvInit() PVGUI_Module::pvInit()\endlink method.
 229
 230
 231   <h3>Multi-view manager</h3>
 232
 233   SALOME GUI requires that each kind of view be implemnted with help of (at least) three classes. For ParaView multi-view manager
 234   these are:
 235
 236   \li PVGUI_ViewManager - view manager class
 237   \li PVGUI_Viewer      - view model class
 238   \li PVGUI_ViewWindow  - view window class that acts as a parent for %pqViewManager
 239
 240   Single instances of PVGUI_ViewManager and PVGUI_ViewWindow classes are created by \link PVGUI_Module::showView()
 241   PVGUI_Module::showView()\endlink method upon the first PARAVIS module activation. The same method hides the multi-view manager
 242   when the module is deactivated (the user switches to another module or a study is closed).
 243   A special trick is used to make PVGUI_ViewWindow the parent of %pqViewManager widget. It is created initally by %pqMainWindowCore
 244   with the desktop as a parent, so when it is shown PVGUI_ViewWindow instance is passed to its setParent() method. In
 245   \link PVGUI_ViewWindow::~PVGUI_ViewWindow() PVGUI_ViewWindow::~PVGUI_ViewWindow()\endlink the parent is nullified to avoid deletion
 246   of %pqViewManager widget that would break %pqMainWindowCore class.
 247
 248   <h3>ParaView plugins</h3>
 249   ParaView server and client plugins are managed by %pqMainWindowCore slots that has full access to PARAVIS menus and toolbars.
 250   As a result they appears automatically in PARAVIS menus and toolbars if loaded successfully.
 251 */
 252
 253 /*!
 254   \class PVGUI_Module
 255   \brief Implementation
 256          SALOME module wrapping ParaView GUI.
 257 */
 258
 259
 260 /*
 261   Fix for the issue 21730: [CEA 596] Slice of polyhedron in PARAVIS returns no cell.
 262   Wrap vtkEDFCutter filter.
 263 */
 264
 265 extern "C" void vtkEDFCutterCS_Initialize(vtkClientServerInterpreter*);
 266 static void vtkEDFHelperInit();
 267
 268 void vtkEDFHelperInit(vtkClientServerInterpreter* interp){
 269     vtkEDFCutterCS_Initialize(interp);
 270 }
 271
 272 void vtkEDFHelperInit() {
 273     vtkClientServerInterpreterInitializer::GetInitializer()->
 274         RegisterCallback(&vtkEDFHelperInit);
 275 }
 276
 277
 278   _PTR(SComponent)
 279   ClientFindOrCreateParavisComponent(_PTR(Study) theStudyDocument)
 280   {
 281     _PTR(SComponent) aSComponent = theStudyDocument->FindComponent("PARAVIS");
 282     if (!aSComponent) {
 283       _PTR(StudyBuilder) aStudyBuilder = theStudyDocument->NewBuilder();
 284       aStudyBuilder->NewCommand();
 285       int aLocked = theStudyDocument->GetProperties()->IsLocked();
 286       if (aLocked) theStudyDocument->GetProperties()->SetLocked(false);
 287       aSComponent = aStudyBuilder->NewComponent("PARAVIS");
 288       _PTR(GenericAttribute) anAttr =
 289         aStudyBuilder->FindOrCreateAttribute(aSComponent, "AttributeName");
 290       _PTR(AttributeName) aName (anAttr);
 291
 292       CORBA::ORB_var anORB = PARAVIS::PARAVIS_Gen_i::GetORB();
 293       SALOME_NamingService *NamingService = new SALOME_NamingService( anORB );
 294       CORBA::Object_var objVarN = NamingService->Resolve("/Kernel/ModulCatalog");
 295       SALOME_ModuleCatalog::ModuleCatalog_var Catalogue =
 296         SALOME_ModuleCatalog::ModuleCatalog::_narrow(objVarN);
 297       SALOME_ModuleCatalog::Acomponent_var Comp = Catalogue->GetComponent( "PARAVIS" );
 298       if (!Comp->_is_nil()) {
 299         aName->SetValue(Comp->componentusername());
 300       }
 301
 302       anAttr = aStudyBuilder->FindOrCreateAttribute(aSComponent, "AttributePixMap");
 303       _PTR(AttributePixMap) aPixmap (anAttr);
 304       aPixmap->SetPixMap( "pqAppIcon16.png" );
 305
 306       // Create Attribute parameters for future using
 307       anAttr = aStudyBuilder->FindOrCreateAttribute(aSComponent, "AttributeParameter");
 308
 309
 310       PARAVIS::PARAVIS_Gen_var aPARAVIS = PARAVIS::PARAVIS_Gen_i::GetParavisGenImpl()->_this();
 311
 312       aStudyBuilder->DefineComponentInstance(aSComponent, aPARAVIS->GetIOR());
 313       if (aLocked) theStudyDocument->GetProperties()->SetLocked(true);
 314       aStudyBuilder->CommitCommand();
 315     }
 316     return aSComponent;
 317   }
 318
 319 /*!
 320   Clean up function; used to stop ParaView progress events when
 321   exception is caught by global exception handler.
 322 */
 323 void paravisCleanUp()
 324 {
 325   if ( pqApplicationCore::instance() ) {
 326     pqServer* s = pqApplicationCore::instance()->getActiveServer();
 327     if ( s ) s->session()->GetProgressHandler()->CleanupPendingProgress();
 328   }
 329 }
 330
 331 /*!
 332   \brief Constructor. Sets the default name for the module.
 333 */
 334 PVGUI_Module::PVGUI_Module()
 335   : SalomeApp_Module( "PARAVIS" ),
 336     //    Implementation( 0 ),
 337     mySelectionControlsTb( -1 ),
 338     mySourcesMenuId( -1 ),
 339     myFiltersMenuId( -1 ),
 340     myMacrosMenuId(-1),
 341     myToolbarsMenuId(-1),
 342     myRecentMenuId(-1),
 343     myOldMsgHandler(0),
 344     myTraceWindow(0),
 345     myStateCounter(0)
 346 {
 347 #ifdef HAS_PV_DOC
 348   Q_INIT_RESOURCE( PVGUI );
 349 #endif
 350   ParavisModule = this;
 351
 352   // Clear old macros
 353   QString aDestPath = QString( "%1/.config/%2/Macros" ).arg( QDir::homePath() ).arg( QApplication::applicationName() );
 354   QStringList aFilter;
 355   aFilter << "*.py";
 356
 357   QDir aDestDir(aDestPath);
 358   QStringList aDestFiles = aDestDir.entryList(aFilter, QDir::Files);
 359   foreach (QString aStr, aDestFiles) {
 360     aDestDir.remove(aStr);
 361   }
 362 }
 363
 364 /*!
 365   \brief Destructor.
 366 */
 367 PVGUI_Module::~PVGUI_Module()
 368 {
 369 }
 370
 371
 372
 373 /*!
 374   \brief Initialize module. Creates menus, prepares context menu, etc.
 375   \param app SALOME GUI application instance
 376 */
 377 void PVGUI_Module::initialize( CAM_Application* app )
 378 {
 379   //VTN: Disable conflict with python initialization for MatPlot.
 380   PVGUI_MatplotlibMathTextUtilities::Disable();
 381
 382   SalomeApp_Module::initialize( app );
 383
 384   // Create ParaViS actions
 385   createActions();
 386   // Create ParaViS menus
 387   createMenus();
 388
 389   // Uncomment to debug ParaView initialization
 390   // "aa" used instead of "i" as GDB doesn't like "i" variables :)
 391   /*
 392   int aa = 1;
 393   while( aa ){
 394     aa = aa;
 395   }
 396   */
 397
 398   // Initialize ParaView client
 399   pvInit();
 400
 401   // Create GUI elements (menus, toolbars, dock widgets)
 402   //if ( !Implementation ){
 403     SalomeApp_Application* anApp = getApp();
 404     SUIT_Desktop* aDesktop = anApp->desktop();
 405
 406     // connect(aDesktop, SIGNAL()
 407
 408     // Remember current state of desktop toolbars
 409     QList<QToolBar*> foreignToolbars = aDesktop->findChildren<QToolBar*>();
 410
 411     // Simulate ParaView client main window
 412     //Implementation = new pqImplementation( aDesktop );
 413
 414     setupDockWidgets();
 415
 416     pvCreateActions();
 417     pvCreateToolBars();
 418     pvCreateMenus();
 419
 420     // new pqParaViewBehaviors(anApp->desktop(), this);
 421     // Has to be replaced in order to exclude using of pqQtMessageHandlerBehaviour
 422     //  Start pqParaViewBehaviors
 423     // Register ParaView interfaces.
 424     //pqPluginManager* pgm = pqApplicationCore::instance()->getPluginManager();
 425     pqInterfaceTracker* pgm = pqApplicationCore::instance()->interfaceTracker();
 426
 427     // * adds support for standard paraview views.
 428     pgm->addInterface(new pqStandardViewModules(pgm));
 429     pgm->addInterface(new pqStandardSummaryPanelImplementation(pgm));
 430     pgm->addInterface(new pqStandardPropertyWidgetInterface(pgm));
 431
 432     // Load plugins distributed with application.
 433     pqApplicationCore::instance()->loadDistributedPlugins();
 434
 435     // Define application behaviors.
 436     //new pqQtMessageHandlerBehavior(this);
 437     new pqDataTimeStepBehavior(this);
 438     new pqViewFrameActionsBehavior(this);
 439     new pqSpreadSheetVisibilityBehavior(this);
 440     new pqPipelineContextMenuBehavior(this);
 441     new pqDefaultViewBehavior(this);
 442     new pqAlwaysConnectedBehavior(this);
 443     new pqPVNewSourceBehavior(this);
 444     new pqDeleteBehavior(this);
 445     new pqUndoRedoBehavior(this);
 446     new pqCrashRecoveryBehavior(this);
 447     new pqAutoLoadPluginXMLBehavior(this);
 448     new pqPluginDockWidgetsBehavior(aDesktop);
 449     //new pqVerifyRequiredPluginBehavior(this);
 450     new pqPluginActionGroupBehavior(aDesktop);
 451     //new pqFixPathsInStateFilesBehavior(this);
 452     new pqCommandLineOptionsBehavior(this);
 453     new pqPersistentMainWindowStateBehavior(aDesktop);
 454     new pqObjectPickingBehavior(aDesktop);
 455     new pqCollaborationBehavior(this);
 456     new pqMultiServerBehavior(this);
 457     new pqViewStreamingBehavior(this);
 458
 459     // Setup quick-launch shortcuts.
 460     QShortcut *ctrlSpace = new QShortcut(Qt::CTRL + Qt::Key_Space, aDesktop);
 461     QObject::connect(ctrlSpace, SIGNAL(activated()),
 462       pqApplicationCore::instance(), SLOT(quickLaunch()));
 463     QShortcut *altSpace = new QShortcut(Qt::ALT + Qt::Key_Space, aDesktop);
 464     QObject::connect(altSpace, SIGNAL(activated()),
 465       pqApplicationCore::instance(), SLOT(quickLaunch()));
 466     //  End pqParaViewBehaviors
 467
 468
 469     SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
 470     QString aPath = resMgr->stringValue("resources", "PARAVIS", QString());
 471     if (!aPath.isNull()) {
 472       MyCoreApp->loadConfiguration(aPath + QDir::separator() + "ParaViewFilters.xml");
 473       MyCoreApp->loadConfiguration(aPath + QDir::separator() + "ParaViewReaders.xml");
 474       MyCoreApp->loadConfiguration(aPath + QDir::separator() + "ParaViewSources.xml");
 475       MyCoreApp->loadConfiguration(aPath + QDir::separator() + "ParaViewWriters.xml");
 476     }
 477
 478     // Force creation of engine
 479     PARAVIS::GetParavisGen(this);
 480     updateObjBrowser();
 481
 482     // Find created toolbars
 483     QCoreApplication::processEvents();
 484
 485     QList<QToolBar*> allToolbars = aDesktop->findChildren<QToolBar*>();
 486     foreach(QToolBar* aBar, allToolbars) {
 487       if (!foreignToolbars.contains(aBar)) {
 488         myToolbars[aBar] = true;
 489         myToolbarBreaks[aBar] = false;
 490         aBar->setVisible(false);
 491         aBar->toggleViewAction()->setVisible(false);
 492       }
 493     }
 494     //}
 495
 496   updateMacros();
 497
 498   // we need to start trace after connection is done
 499   connect(pqApplicationCore::instance()->getObjectBuilder(), SIGNAL(finishedAddingServer(pqServer*)),
 500           this, SLOT(onFinishedAddingServer(pqServer*)));
 501
 502   connect(pqApplicationCore::instance()->getObjectBuilder(), SIGNAL(dataRepresentationCreated(pqDataRepresentation*)),
 503           this, SLOT(onDataRepresentationCreated(pqDataRepresentation*)));
 504
 505
 506   SUIT_ResourceMgr* aResourceMgr = SUIT_Session::session()->resourceMgr();
 507   bool isStop = aResourceMgr->booleanValue( "PARAVIS", "stop_trace", false );
 508   // start timer to activate trace in a proper moment
 509   if(!isStop)
 510     startTimer( 50 );
 511
 512   this->VTKConnect = vtkEventQtSlotConnect::New();
 513   vtkProcessModule* pm = vtkProcessModule::GetProcessModule();
 514
 515   this->VTKConnect->Connect(pm, vtkCommand::StartEvent,
 516     this, SLOT(onStartProgress()));
 517   this->VTKConnect->Connect(pm, vtkCommand::EndEvent,
 518     this, SLOT(onEndProgress()));
 519
 520   connect(&pqActiveObjects::instance(),
 521           SIGNAL(representationChanged(pqRepresentation*)),
 522           this, SLOT(onRepresentationChanged(pqRepresentation*)));
 523 }
 524
 525 void PVGUI_Module::onStartProgress()
 526 {
 527   QApplication::setOverrideCursor(Qt::WaitCursor);
 528 }
 529
 530 void PVGUI_Module::onEndProgress()
 531 {
 532   QApplication::restoreOverrideCursor();
 533 }
 534
 535 void PVGUI_Module::onFinishedAddingServer(pqServer* /*server*/)
 536 {
 537   SUIT_ResourceMgr* aResourceMgr = SUIT_Session::session()->resourceMgr();
 538   bool isStop = aResourceMgr->booleanValue( "PARAVIS", "stop_trace", false );
 539   if(!isStop)
 540     startTimer( 50 );
 541 }
 542
 543 void PVGUI_Module::onDataRepresentationCreated(pqDataRepresentation* data) {
 544   if(!data)
 545     return;
 546
 547   if(!data->getLookupTable())
 548     return;
 549
 550   SUIT_ResourceMgr* aResourceMgr = SUIT_Session::session()->resourceMgr();
 551   if(!aResourceMgr)
 552     return;
 553
 554   bool visible = aResourceMgr->booleanValue( "PARAVIS", "show_color_legend", false );
 555   pqLookupTableManager* lut_mgr = pqApplicationCore::instance()->getLookupTableManager();
 556
 557   if(lut_mgr) {
 558     lut_mgr->setScalarBarVisibility(data,visible);
 559   }
 560
 561   connect(data, SIGNAL(dataUpdated()), this, SLOT(onDataRepresentationUpdated()));
 562 }
 563
 564 void PVGUI_Module::onDataRepresentationUpdated() {
 565   SalomeApp_Study* activeStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
 566   if(!activeStudy) return;
 567
 568   activeStudy->Modified();
 569 }
 570
 571 void PVGUI_Module::onVariableChanged(pqVariableType t, const QString) {
 572
 573   pqDisplayColorWidget* colorWidget = qobject_cast<pqDisplayColorWidget*>(sender());
 574   if( !colorWidget )
 575     return;
 576
 577   if( t == VARIABLE_TYPE_NONE )
 578     return;
 579
 580   SUIT_ResourceMgr* aResourceMgr = SUIT_Session::session()->resourceMgr();
 581
 582   if(!aResourceMgr)
 583     return;
 584
 585   bool visible = aResourceMgr->booleanValue( "PARAVIS", "show_color_legend", false );
 586
 587   if(!visible)
 588     return;
 589
 590   /*//VTN: getRepresentation is protected
 591   pqDataRepresentation* data  = colorWidget->getRepresentation();
 592
 593   if( !data->getLookupTable() )
 594     return;
 595
 596   pqLookupTableManager* lut_mgr = pqApplicationCore::instance()->getLookupTableManager();
 597
 598   if(lut_mgr) {
 599     lut_mgr->setScalarBarVisibility(data,visible);
 600   }
 601   */
 602   pqColorToolbar* colorTooBar = qobject_cast<pqColorToolbar*>(colorWidget->parent());
 603   if( !colorTooBar )
 604     return;
 605
 606   pqScalarBarVisibilityReaction* scalarBarVisibility = colorTooBar->findChild<pqScalarBarVisibilityReaction *>();
 607   if(scalarBarVisibility) {
 608     scalarBarVisibility->setScalarBarVisibility(visible);
 609   }
 610 }
 611
 612
 613 /*!
 614   \brief Launches a tracing of current server
 615 */
 616 void PVGUI_Module::timerEvent(QTimerEvent* te )
 617 {
 618 #ifndef WNT
 619   PyInterp_Dispatcher* aDispatcher = PyInterp_Dispatcher::Get();
 620   if ( !aDispatcher->IsBusy() ) {
 621     pqPythonManager* manager = qobject_cast<pqPythonManager*>
 622       ( pqApplicationCore::instance()->manager( "PYTHON_MANAGER" ) );
 623     if ( manager )  {
 624       pqPythonDialog* pyDiag = manager->pythonShellDialog();
 625       if ( pyDiag ) {
 626         pqPythonShell* shell = pyDiag->shell();
 627         if ( shell ) {
 628           QString script = "from paraview import smtrace\nsmtrace.start_trace()\n";
 629           shell->executeScript(script);
 630           killTimer( te->timerId() );
 631         }
 632       }
 633     }
 634   }
 635 #endif
 636 }
 637
 638 void PVGUI_Module::updateMacros()
 639 {
 640   pqPythonManager* aPythonManager = pqPVApplicationCore::instance()->pythonManager();
 641   if(!aPythonManager)  {
 642     return;
 643   }
 644
 645   QString aRootDir = getenv("PARAVIS_ROOT_DIR");
 646
 647   QString aSourcePath = aRootDir + "/bin/salome/Macro";
 648
 649   QStringList aFilter;
 650   aFilter << "*.py";
 651
 652   QDir aSourceDir(aSourcePath);
 653   QStringList aSourceFiles = aSourceDir.entryList(aFilter, QDir::Files);
 654   foreach (QString aStr, aSourceFiles) {
 655     aPythonManager->addMacro(aSourcePath + "/" + aStr);
 656   }
 657 }
 658
 659
 660 /*!
 661   \brief Get list of compliant dockable GUI elements
 662   \param m map to be filled in ("type":"default_position")
 663 */
 664 void PVGUI_Module::windows( QMap<int, int>& m ) const
 665 {
 666   m.insert( LightApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea );
 667   m.insert( LightApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea );
 668   // ParaView diagnostic output redirected here
 669   m.insert( LightApp_Application::WT_LogWindow, Qt::BottomDockWidgetArea );
 670 }
 671
 672 /*!
 673   \brief Static method, performs initialization of ParaView session.
 674   \return \c true if ParaView has been initialized successfully, otherwise false
 675 */
 676 bool PVGUI_Module::pvInit()
 677 {
 678   //  if ( !pqImplementation::Core ){
 679   if ( ! MyCoreApp) {
 680     // Obtain command-line arguments
 681     int argc = 0;
 682     char** argv = 0;
 683     QString aOptions = getenv("PARAVIS_OPTIONS");
 684     QStringList aOptList = aOptions.split(":", QString::SkipEmptyParts);
 685     argv = new char*[aOptList.size() + 1];
 686     QStringList args = QApplication::arguments();
 687     argv[0] = (args.size() > 0)? strdup(args[0].toLatin1().constData()) : strdup("paravis");
 688     argc++;
 689
 690     foreach (QString aStr, aOptList) {
 691       argv[argc] = strdup( aStr.toLatin1().constData() );
 692       argc++;
 693     }
 694     MyCoreApp = new pqPVApplicationCore (argc, argv);
 695     if (MyCoreApp->getOptions()->GetHelpSelected() ||
 696         MyCoreApp->getOptions()->GetUnknownArgument() ||
 697         MyCoreApp->getOptions()->GetErrorMessage() ||
 698         MyCoreApp->getOptions()->GetTellVersion()) {
 699       return false;
 700       }
 701
 702     /* VTN: Looks like trash. For porting see branded_paraview_initializer.cxx.in
 703     // Not sure why this is needed. Andy added this ages ago with comment saying
 704     // needed for Mac apps. Need to check that it's indeed still required.
 705     QDir dir(QApplication::applicationDirPath());
 706     dir.cdUp();
 707     dir.cd("Plugins");
 708     QApplication::addLibraryPath(dir.absolutePath());
 709     // Load required application plugins.
 710     QString plugin_string = "";
 711     QStringList plugin_list = plugin_string.split(';',QString::SkipEmptyParts);
 712     pqBrandPluginsLoader loader;
 713     if (loader.loadPlugins(plugin_list) == false) {
 714       printf("Failed to load required plugins for this application\n");
 715       return false;
 716     }
 717
 718     // Load optional plugins.
 719     plugin_string = "";
 720     plugin_list = plugin_string.split(';',QString::SkipEmptyParts);
 721     loader.loadPlugins(plugin_list, true); //quietly skip not-found plugins.
 722     */
 723     // End of Initializer code
 724
 725     vtkOutputWindow::SetInstance(PVGUI_OutputWindowAdapter::New());
 726
 727     new pqTabbedMultiViewWidget(); // it registers as "MULTIVIEW_WIDGET on creation
 728
 729     for (int i = 0; i < argc; i++)
 730       free(argv[i]);
 731     delete[] argv;
 732   }
 733
 734   return true;
 735 }
 736
 737 /*!
 738   \brief Shows (toShow = true) or hides ParaView view window
 739 */
 740 void PVGUI_Module::showView( bool toShow )
 741 {
 742   SalomeApp_Application* anApp = getApp();
 743   PVGUI_ViewManager* viewMgr =
 744     dynamic_cast<PVGUI_ViewManager*>( anApp->getViewManager( PVGUI_Viewer::Type(), false ) );
 745   if ( !viewMgr ) {
 746     viewMgr = new PVGUI_ViewManager( anApp->activeStudy(), anApp->desktop() );
 747     anApp->addViewManager( viewMgr );
 748     connect( viewMgr, SIGNAL( lastViewClosed( SUIT_ViewManager* ) ),
 749              anApp, SLOT( onCloseView( SUIT_ViewManager* ) ) );
 750   }
 751
 752   PVGUI_ViewWindow* pvWnd = dynamic_cast<PVGUI_ViewWindow*>( viewMgr->getActiveView() );
 753   if ( !pvWnd ) {
 754     pvWnd = dynamic_cast<PVGUI_ViewWindow*>( viewMgr->createViewWindow() );
 755   }
 756
 757   pvWnd->setShown( toShow );
 758   if ( toShow ) pvWnd->setFocus();
 759 }
 760
 761 /*!
 762   \brief Slot to show help for proxy.
 763 */
 764 void PVGUI_Module::showHelpForProxy( const QString& groupname, const QString& proxyname )
 765 {
 766   pqHelpReaction::showProxyHelp(groupname, proxyname);
 767 }
 768
 769
 770 /*!
 771   \brief Slot to show the waiting state.
 772 */
 773 void PVGUI_Module::onPreAccept()
 774 {
 775   getApp()->desktop()->statusBar()->showMessage(tr("STB_PREACCEPT"));
 776   QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 777 }
 778
 779 /*!
 780   \brief Slot to show the ready state.
 781 */
 782 void PVGUI_Module::onPostAccept()
 783 {
 784   getApp()->desktop()->statusBar()->showMessage(tr("STB_POSTACCEPT"), 2000);
 785   QTimer::singleShot(0, this, SLOT(endWaitCursor()));
 786 }
 787
 788 /*!
 789   \brief Slot to switch off wait cursor.
 790 */
 791 void PVGUI_Module::endWaitCursor()
 792 {
 793   QApplication::restoreOverrideCursor();
 794 }
 795
 796 /*!
 797   \brief Returns the ParaView multi-view manager.
 798 */
 799 pqTabbedMultiViewWidget* PVGUI_Module::getMultiViewManager() const
 800 {
 801   return qobject_cast<pqTabbedMultiViewWidget*>(pqApplicationCore::instance()->manager("MULTIVIEW_WIDGET"));
 802 }
 803
 804
 805 static void ParavisMessageOutput(QtMsgType type, const char *msg)
 806 {
 807   switch(type)
 808     {
 809   case QtDebugMsg:
 810     vtkOutputWindow::GetInstance()->DisplayText(msg);
 811     break;
 812   case QtWarningMsg:
 813     vtkOutputWindow::GetInstance()->DisplayErrorText(msg);
 814     break;
 815   case QtCriticalMsg:
 816     vtkOutputWindow::GetInstance()->DisplayErrorText(msg);
 817     break;
 818   case QtFatalMsg:
 819     vtkOutputWindow::GetInstance()->DisplayErrorText(msg);
 820     break;
 821     }
 822 }
 823
 824
 825
 826 /*!
 827   \brief Activate module.
 828   \param study current study
 829   \return \c true if activaion is done successfully or 0 to prevent
 830   activation on error
 831 */
 832 bool PVGUI_Module::activateModule( SUIT_Study* study )
 833 {
 834   myOldMsgHandler = qInstallMsgHandler(ParavisMessageOutput);
 835
 836   SUIT_ExceptionHandler::addCleanUpRoutine( paravisCleanUp );
 837
 838   bool isDone = SalomeApp_Module::activateModule( study );
 839   if ( !isDone ) return false;
 840
 841   showView( true );
 842   if ( mySourcesMenuId != -1 ) menuMgr()->show(mySourcesMenuId);
 843   if ( myFiltersMenuId != -1 ) menuMgr()->show(myFiltersMenuId);
 844   if ( myFiltersMenuId != -1 ) menuMgr()->show(myMacrosMenuId);
 845   if ( myFiltersMenuId != -1 ) menuMgr()->show(myToolbarsMenuId);
 846   setMenuShown( true );
 847   setToolShown( true );
 848
 849   restoreDockWidgetsState();
 850
 851    QMenu* aMenu = menuMgr()->findMenu( myRecentMenuId );
 852    if(aMenu) {
 853       QList<QAction*> anActns = aMenu->actions();
 854       for (int i = 0; i < anActns.size(); ++i) {
 855               QAction* a = anActns.at(i);
 856         if(a)
 857            a->setVisible(true);
 858       }
 859     }
 860
 861   if ( myRecentMenuId != -1 ) menuMgr()->show(myRecentMenuId);
 862
 863   ClientFindOrCreateParavisComponent(PARAVIS::GetCStudy(this));
 864
 865   return isDone;
 866 }
 867
 868
 869 /*!
 870   \brief Deactivate module.
 871   \param study current study
 872   \return \c true if deactivaion is done successfully or 0 to prevent
 873   deactivation on error
 874 */
 875 bool PVGUI_Module::deactivateModule( SUIT_Study* study )
 876 {
 877    QMenu* aMenu = menuMgr()->findMenu( myRecentMenuId );
 878    if(aMenu) {
 879       QList<QAction*> anActns = aMenu->actions();
 880       for (int i = 0; i < anActns.size(); ++i) {
 881               QAction* a = anActns.at(i);
 882         if(a)
 883           a->setVisible(false);
 884       }
 885     }
 886
 887   QList<QDockWidget*> aStreamingViews = application()->desktop()->findChildren<QDockWidget*>("pqStreamingControls");
 888   foreach(QDockWidget* aView, aStreamingViews) {
 889     if (!myDockWidgets.contains(aView))
 890       myDockWidgets[aView] = aView->isVisible();
 891   }
 892
 893   /*if (pqImplementation::helpWindow) {
 894     pqImplementation::helpWindow->hide();
 895     }*/
 896   showView( false );
 897   // hide menus
 898   menuMgr()->hide(myRecentMenuId);
 899   menuMgr()->hide(mySourcesMenuId);
 900   menuMgr()->hide(myFiltersMenuId);
 901   menuMgr()->hide(myMacrosMenuId);
 902   menuMgr()->hide(myToolbarsMenuId);
 903   setMenuShown( false );
 904   setToolShown( false );
 905
 906
 907   saveDockWidgetsState();
 908
 909   SUIT_ExceptionHandler::removeCleanUpRoutine( paravisCleanUp );
 910
 911   if (myOldMsgHandler)
 912     qInstallMsgHandler(myOldMsgHandler);
 913
 914   return SalomeApp_Module::deactivateModule( study );
 915 }
 916
 917
 918 /*!
 919   \brief Called when application is closed.
 920
 921   Process finalize application functionality from ParaView in order to save server settings
 922   and nullify application pointer if the application is being closed.
 923
 924   \param theApp application
 925 */
 926 void PVGUI_Module::onApplicationClosed( SUIT_Application* theApp )
 927 {
 928   pqApplicationCore::instance()->settings()->sync();
 929   int aAppsNb = SUIT_Session::session()->applications().size();
 930   if (aAppsNb == 1) {
 931     deleteTemporaryFiles();
 932     MyCoreApp->deleteLater();
 933   }
 934   CAM_Module::onApplicationClosed(theApp);
 935 }
 936
 937
 938 /*!
 939   \brief Called when study is closed.
 940
 941   Removes data model from the \a study.
 942
 943   \param study study being closed
 944 */
 945 void PVGUI_Module::studyClosed(SUIT_Study* study)
 946 {
 947   clearParaviewState();
 948
 949   SalomeApp_Module::studyClosed(study);
 950 }
 951
 952 /*!
 953   \brief Called when study is opened.
 954 */
 955 void PVGUI_Module::onModelOpened()
 956 {
 957   _PTR(Study) studyDS = PARAVIS::GetCStudy(this);
 958   if(!studyDS) {
 959     return;
 960   }
 961
 962   _PTR(SComponent) paravisComp =
 963     studyDS->FindComponent(PARAVIS::GetParavisGen(this)->ComponentDataType());
 964   if(!paravisComp) {
 965     return;
 966   }
 967
 968   _PTR(ChildIterator) anIter(studyDS->NewChildIterator(paravisComp));
 969   for (; anIter->More(); anIter->Next()) {
 970     _PTR(SObject) aSObj = anIter->Value();
 971     _PTR(GenericAttribute) anAttr;
 972     if (!aSObj->FindAttribute(anAttr, "AttributeLocalID")) {
 973       continue;
 974     }
 975     _PTR(AttributeLocalID) anID(anAttr);
 976     if (anID->Value() == PVSTATEID) {
 977       myStateCounter++;
 978     }
 979   }
 980 }
 981
 982 /*!
 983   \brief Returns IOR of current engine
 984 */
 985 QString PVGUI_Module::engineIOR() const
 986 {
 987   CORBA::String_var anIOR = PARAVIS::GetParavisGen(this)->GetIOR();
 988   return QString(anIOR.in());
 989 }
 990
 991
 992 /*!
 993   \brief Open file of format supported by ParaView
 994 */
 995 void PVGUI_Module::openFile(const char* theName)
 996 {
 997   QStringList aFiles;
 998   aFiles<<theName;
 999   pqLoadDataReaction::loadData(aFiles);
1000 }
1001
1002 void PVGUI_Module::executeScript(const char *script)
1003 {
1004 #ifndef WNT
1005   pqPythonManager* manager = qobject_cast<pqPythonManager*>(
1006                              pqApplicationCore::instance()->manager("PYTHON_MANAGER"));
1007   if (manager)  {
1008     pqPythonDialog* pyDiag = manager->pythonShellDialog();
1009     if (pyDiag) {
1010       pyDiag->runString(script);
1011       }
1012     }
1013 #endif
1014 }
1015
1016 /*!
1017   \brief Returns trace string
1018 */
1019 static const QString MYReplaceStr("paraview.simple");
1020 static const QString MYReplaceImportStr("except: from pvsimple import *");
1021 QString PVGUI_Module::getTraceString()
1022 {
1023   QString traceString;
1024 #ifndef WNT
1025   pqPythonManager* manager = qobject_cast<pqPythonManager*>(
1026                              pqApplicationCore::instance()->manager("PYTHON_MANAGER"));
1027   if (manager)  {
1028     pqPythonDialog* pyDiag = manager->pythonShellDialog();
1029     if (pyDiag) {
1030       pyDiag->runString("from paraview import smtrace\n"
1031                         "__smtraceString = smtrace.get_trace_string()\n");
1032       pyDiag->shell()->makeCurrent();
1033       PyObject* main_module = PyImport_AddModule((char*)"__main__");
1034       PyObject* global_dict = PyModule_GetDict(main_module);
1035       PyObject* string_object = PyDict_GetItemString(global_dict, "__smtraceString");
1036       char* string_ptr = string_object ? PyString_AsString(string_object) : 0;
1037       if (string_ptr)  {
1038         traceString = string_ptr;
1039       }
1040       pyDiag->shell()->releaseControl();
1041     }
1042   }
1043   if ((!traceString.isNull()) && traceString.length() != 0) {
1044     int aPos = traceString.indexOf(MYReplaceStr);
1045     while (aPos != -1) {
1046       traceString = traceString.replace(aPos, MYReplaceStr.length(), "pvsimple");
1047       aPos = traceString.indexOf(MYReplaceStr, aPos);
1048     }
1049     int aImportPos = traceString.indexOf(MYReplaceImportStr);
1050     if(aImportPos != -1)
1051       {
1052       traceString = traceString.replace(aImportPos, MYReplaceImportStr.length(), "except:\n  import pvsimple\n  from pvsimple import *");
1053       }
1054   }
1055 #endif
1056   return traceString;
1057 }
1058
1059 /*!
1060   \brief Saves trace string to disk file
1061 */
1062 void PVGUI_Module::saveTrace(const char* theName)
1063 {
1064   QFile file(theName);
1065   if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
1066     MESSAGE( "Could not open file:" << theName );
1067     return;
1068   }
1069   QTextStream out(&file);
1070   out << getTraceString();
1071   file.close();
1072 }
1073
1074 /*!
1075   \brief Saves ParaView state to a disk file
1076 */
1077 void PVGUI_Module::saveParaviewState(const char* theFileName)
1078 {
1079   pqApplicationCore::instance()->saveState(theFileName);
1080 }
1081
1082 /*!
1083   \brief Delete all objects for Paraview Pipeline Browser
1084 */
1085 void PVGUI_Module::clearParaviewState()
1086 {
1087   QAction* deleteAllAction = action(DeleteAllId);
1088   if (deleteAllAction) {
1089     deleteAllAction->activate(QAction::Trigger);
1090   }
1091 }
1092
1093 /*!
1094   \brief Restores ParaView state from a disk file
1095
1096   If toClear == true, the current ojects will be deleted
1097 */
1098 void PVGUI_Module::loadParaviewState(const char* theFileName)
1099 {
1100   pqApplicationCore::instance()->loadState(theFileName, getActiveServer());
1101 }
1102
1103 /*!
1104   \brief Imports MED data from VISU module by data entry
1105 */
1106 void PVGUI_Module::onImportFromVisu(QString theEntry)
1107 {
1108 #ifdef WITH_VISU
1109   SUIT_OverrideCursor aWaitCursor;
1110
1111   // get active study
1112   SalomeApp_Study* activeStudy = dynamic_cast<SalomeApp_Study*>(application()->activeStudy());
1113   if(!activeStudy) return;
1114
1115   // get SALOMEDS client study
1116   _PTR(Study) aStudy = activeStudy->studyDS();
1117   if(!aStudy) return;
1118
1119   // find VISU component in a study
1120   _PTR(SComponent) aVisuComp = aStudy->FindComponent( "VISU" );
1121   if(!aVisuComp) return;
1122
1123   // get SObject client by entry
1124   _PTR(SObject) aSObj = aStudy->FindObjectID(qPrintable(theEntry));
1125   if (!aSObj) return;
1126
1127   // get CORBA SObject
1128   SALOMEDS_SObject* aSObject = _CAST(SObject, aSObj);
1129   if ( !aSObject ) return;
1130
1131   // load VISU engine
1132   SALOME_NamingService* aNamingService = SalomeApp_Application::namingService();
1133   SALOME_LifeCycleCORBA aLCC(aNamingService);
1134
1135   Engines::EngineComponent_var aComponent = aLCC.FindOrLoad_Component("FactoryServer","VISU");
1136   VISU::VISU_Gen_var aVISU = VISU::VISU_Gen::_narrow(aComponent);
1137   if(CORBA::is_nil(aVISU)) return;
1138
1139   _PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
1140   aStudyBuilder->LoadWith( aVisuComp, SalomeApp_Application::orb()->object_to_string(aVISU) );
1141
1142   // get VISU result object
1143   CORBA::Object_var aResultObject = aSObject->GetObject();
1144   if (CORBA::is_nil(aResultObject)) return;
1145   VISU::Result_var aResult = VISU::Result::_narrow( aResultObject );
1146   if (CORBA::is_nil(aResult)) return;
1147
1148   // export VISU result to the MED file
1149   std::string aTmpDir = SALOMEDS_Tool::GetTmpDir();
1150   std::string aFileName = aSObject->GetName();
1151   std::string aFilePath = aTmpDir + aFileName;
1152
1153   if (aResult->ExportMED(aFilePath.c_str())) {
1154     openFile(aFilePath.c_str());
1155     myTemporaryFiles.append(QString(aFilePath.c_str()));
1156   }
1157 #else
1158   MESSAGE("Visu module is not found.");
1159 #endif
1160 }
1161
1162 /*!
1163   \brief Deletes temporary files created during import operation from VISU
1164 */
1165 void PVGUI_Module::deleteTemporaryFiles()
1166 {
1167   foreach(QString aFile, myTemporaryFiles) {
1168     if (QFile::exists(aFile)) {
1169       QFile::remove(aFile);
1170     }
1171   }
1172 }
1173
1174
1175 /*!
1176   \brief Returns current active ParaView server
1177 */
1178 pqServer* PVGUI_Module::getActiveServer()
1179 {
1180   return pqApplicationCore::instance()->getActiveServer();
1181 }
1182
1183
1184 /*!
1185   \brief Creates PARAVIS preference pane
1186 */
1187 void PVGUI_Module::createPreferences()
1188 {
1189   // Paraview settings tab
1190   int aParaViewSettingsTab = addPreference( tr( "TIT_PVIEWSETTINGS" ) );
1191   int aPanel = addPreference(QString(), aParaViewSettingsTab, LightApp_Preferences::UserDefined, "PARAVIS", "");
1192   setPreferenceProperty(aPanel, "content", (qint64)(new PVGUI_ParaViewSettingsPane()));
1193
1194   // Paravis settings tab
1195   int aParaVisSettingsTab = addPreference( tr( "TIT_PVISSETTINGS" ) );
1196   addPreference( tr( "PREF_STOP_TRACE" ), aParaVisSettingsTab, LightApp_Preferences::Bool, "PARAVIS", "stop_trace");
1197
1198   int aSaveType = addPreference(tr( "PREF_SAVE_TYPE_LBL" ), aParaVisSettingsTab,
1199                                 LightApp_Preferences::Selector,
1200                                 "PARAVIS", "savestate_type");
1201   QList<QVariant> aIndices;
1202   QStringList aStrings;
1203   aIndices<<0<<1<<2;
1204   aStrings<<tr("PREF_SAVE_TYPE_0");
1205   aStrings<<tr("PREF_SAVE_TYPE_1");
1206   aStrings<<tr("PREF_SAVE_TYPE_2");
1207   setPreferenceProperty(aSaveType, "strings", aStrings);
1208   setPreferenceProperty(aSaveType, "indexes", aIndices);
1209
1210   //rnv: imp 21712: [CEA 581] Preference to display legend by default
1211   int aDispColoreLegend = addPreference( tr( "PREF_SHOW_COLOR_LEGEND" ), aParaVisSettingsTab,
1212                                          LightApp_Preferences::Bool, "PARAVIS", "show_color_legend");
1213 }
1214
1215 /*!
1216   \brief Creates ParaViS context menu popup
1217 */
1218 void PVGUI_Module::contextMenuPopup(const QString& theClient, QMenu* theMenu, QString& theTitle)
1219 {
1220   SalomeApp_Module::contextMenuPopup(theClient, theMenu, theTitle);
1221
1222   // Check if we are in Object Browser
1223   SUIT_DataBrowser* ob = getApp()->objectBrowser();
1224   bool isOBClient = (ob && theClient == ob->popupClientType());
1225   if (!isOBClient) {
1226     return;
1227   }
1228
1229   // Get list of selected objects
1230   LightApp_SelectionMgr* aSelectionMgr = getApp()->selectionMgr();
1231   SALOME_ListIO aListIO;
1232   aSelectionMgr->selectedObjects(aListIO);
1233   if (aListIO.Extent() == 1 && aListIO.First()->hasEntry()) {
1234     QString entry = QString(aListIO.First()->getEntry());
1235
1236     // Get active study
1237     SalomeApp_Study* activeStudy =
1238       dynamic_cast<SalomeApp_Study*>(getApp()->activeStudy());
1239     if(!activeStudy) {
1240       return;
1241     }
1242
1243     // Get SALOMEDS client study
1244     _PTR(Study) studyDS = activeStudy->studyDS();
1245     if(!studyDS) {
1246       return;
1247     }
1248
1249     QString paravisDataType(PARAVIS::GetParavisGen(this)->ComponentDataType());
1250     if(activeStudy && activeStudy->isComponent(entry) &&
1251        activeStudy->componentDataType(entry) == paravisDataType) {
1252       // ParaViS module object
1253       theMenu->addSeparator();
1254       theMenu->addAction(action(SaveStatePopupId));
1255     }
1256     else {
1257       // Try to get state object
1258       _PTR(SObject) stateSObj =
1259         studyDS->FindObjectID(entry.toLatin1().constData());
1260       if (!stateSObj) {
1261         return;
1262       }
1263
1264       // Check local id
1265       _PTR(GenericAttribute) anAttr;
1266       if (!stateSObj->FindAttribute(anAttr, "AttributeLocalID")) {
1267         return;
1268       }
1269
1270       _PTR(AttributeLocalID) anID(anAttr);
1271
1272       if (anID->Value() == PVSTATEID) {
1273         // Paraview state object
1274         theMenu->addSeparator();
1275         theMenu->addAction(action(AddStatePopupId));
1276         theMenu->addAction(action(CleanAndAddStatePopupId));
1277         theMenu->addSeparator();
1278         theMenu->addAction(action(ParaVisRenameId));
1279         theMenu->addAction(action(ParaVisDeleteId));
1280       }
1281     }
1282   }
1283 }
1284
1285 void PVGUI_Module::onShowTrace()
1286 {
1287   if (!myTraceWindow) {
1288     myTraceWindow = new pqPythonScriptEditor(getApp()->desktop());
1289   }
1290   myTraceWindow->setText(getTraceString());
1291   myTraceWindow->show();
1292   myTraceWindow->raise();
1293   myTraceWindow->activateWindow();
1294 }
1295
1296 /*!
1297   \brief Show ParaView view.
1298 */
1299 void PVGUI_Module::onNewParaViewWindow()
1300 {
1301   showView(true);
1302 }
1303
1304 /*!
1305   \brief Save state under the module root object.
1306 */
1307 void PVGUI_Module::onSaveMultiState()
1308 {
1309   // Create state study object
1310
1311   // Get SALOMEDS client study
1312   _PTR(Study) studyDS = PARAVIS::GetCStudy(this);
1313   if(!studyDS) {
1314     return;
1315   }
1316
1317   _PTR(SComponent) paravisComp =
1318     studyDS->FindComponent(PARAVIS::GetParavisGen(this)->ComponentDataType());
1319   if(!paravisComp) {
1320     return;
1321   }
1322
1323   // Unlock the study if it is locked
1324   bool isLocked = studyDS->GetProperties()->IsLocked();
1325   if (isLocked) {
1326     studyDS->GetProperties()->SetLocked(false);
1327   }
1328
1329   QString stateName = tr("SAVED_PARAVIEW_STATE_NAME") +
1330     QString::number(myStateCounter + 1);
1331
1332   _PTR(StudyBuilder) studyBuilder = studyDS->NewBuilder();
1333   _PTR(SObject) newSObj = studyBuilder->NewObject(paravisComp);
1334
1335   // Set name
1336   _PTR(GenericAttribute) anAttr;
1337   anAttr = studyBuilder->FindOrCreateAttribute(newSObj, "AttributeName");
1338   _PTR(AttributeName) nameAttr(anAttr);
1339
1340   nameAttr->SetValue(stateName.toLatin1().constData());
1341
1342   // Set local id
1343   anAttr = studyBuilder->FindOrCreateAttribute(newSObj, "AttributeLocalID");
1344   _PTR(AttributeLocalID) localIdAttr(anAttr);
1345
1346   localIdAttr->SetValue(PVSTATEID);
1347
1348   // Set file name
1349   QString stateEntry = QString::fromStdString(newSObj->GetID());
1350
1351   // File name for state saving
1352   QString tmpDir = QString::fromStdString(SALOMEDS_Tool::GetTmpDir());
1353   QString fileName = QString("%1_paravisstate:%2").arg(tmpDir,
1354                                                        stateEntry);
1355
1356   anAttr = studyBuilder->FindOrCreateAttribute(newSObj, "AttributeString");
1357   _PTR(AttributeString) stringAttr(anAttr);
1358
1359   stringAttr->SetValue(fileName.toLatin1().constData());
1360
1361   // Lock the study back if necessary
1362   if (isLocked) {
1363     studyDS->GetProperties()->SetLocked(true);
1364   }
1365
1366   // Save state
1367   saveParaviewState(fileName.toLatin1().constData());
1368   myTemporaryFiles.append(fileName);
1369
1370   // Increment the counter
1371   myStateCounter++;
1372
1373   updateObjBrowser();
1374 }
1375
1376 /*!
1377   \brief Restore the selected state by merging with the current one.
1378 */
1379 void PVGUI_Module::onAddState()
1380 {
1381   loadSelectedState(false);
1382 }
1383
1384 /*!
1385   \brief Clean the current state and restore the selected one.
1386 */
1387 void PVGUI_Module::onCleanAddState()
1388 {
1389   loadSelectedState(true);
1390 }
1391
1392 /*!
1393   \brief Rename the selected object.
1394 */
1395 void PVGUI_Module::onRename()
1396 {
1397   LightApp_SelectionMgr* aSelectionMgr = getApp()->selectionMgr();
1398   SALOME_ListIO aListIO;
1399   aSelectionMgr->selectedObjects(aListIO);
1400
1401   if (aListIO.Extent() == 1 && aListIO.First()->hasEntry()) {
1402     std::string entry = aListIO.First()->getEntry();
1403
1404     // Get SALOMEDS client study
1405     _PTR(Study) studyDS = PARAVIS::GetCStudy(this);
1406     if(!studyDS) {
1407       return;
1408     }
1409
1410     // Unlock the study if it is locked
1411     bool isLocked = studyDS->GetProperties()->IsLocked();
1412     if (isLocked) {
1413       studyDS->GetProperties()->SetLocked(false);
1414     }
1415
1416     // Rename the selected state object
1417     _PTR(SObject) stateSObj = studyDS->FindObjectID(entry);
1418     if (!stateSObj) {
1419       return;
1420     }
1421
1422     _PTR(GenericAttribute) anAttr;
1423     if (stateSObj->FindAttribute(anAttr, "AttributeName")) {
1424       _PTR(AttributeName) nameAttr (anAttr);
1425       QString newName =
1426         LightApp_NameDlg::getName(getApp()->desktop(), nameAttr->Value().c_str());
1427       if (!newName.isEmpty()) {
1428         nameAttr->SetValue(newName.toLatin1().constData());
1429         aListIO.First()->setName(newName.toLatin1().constData());
1430       }
1431     }
1432
1433     // Lock the study back if necessary
1434     if (isLocked) {
1435       studyDS->GetProperties()->SetLocked(true);
1436     }
1437
1438     // Update object browser
1439     updateObjBrowser();
1440
1441   }
1442 }
1443
1444 /*!
1445   \brief Delete the selected objects.
1446 */
1447 void PVGUI_Module::onDelete()
1448 {
1449   LightApp_SelectionMgr* aSelectionMgr = getApp()->selectionMgr();
1450   SALOME_ListIO aListIO;
1451   aSelectionMgr->selectedObjects(aListIO);
1452
1453   if (aListIO.Extent() == 1 && aListIO.First()->hasEntry()) {
1454     std::string entry = aListIO.First()->getEntry();
1455
1456     // Get SALOMEDS client study
1457     _PTR(Study) studyDS = PARAVIS::GetCStudy(this);
1458     if(!studyDS) {
1459       return;
1460     }
1461
1462     // Unlock the study if it is locked
1463     bool isLocked = studyDS->GetProperties()->IsLocked();
1464     if (isLocked) {
1465       studyDS->GetProperties()->SetLocked(false);
1466     }
1467
1468     // Remove the selected state from the study
1469     _PTR(StudyBuilder) studyBuilder = studyDS->NewBuilder();
1470     _PTR(SObject) stateSObj = studyDS->FindObjectID(entry);
1471     studyBuilder->RemoveObject(stateSObj);
1472
1473     // Lock the study back if necessary
1474     if (isLocked) {
1475       studyDS->GetProperties()->SetLocked(true);
1476     }
1477
1478     // Update object browser
1479     updateObjBrowser();
1480   }
1481 }
1482
1483 /*!
1484   \brief Discover help project files from the resources.
1485   \return name of the help file.
1486 */
1487 QString PVGUI_Module::getHelpFileName() {
1488   QString aPVHome(getenv("PVHOME"));
1489   if (aPVHome.isNull()) {
1490     qWarning("Wariable PVHOME is not defined");
1491     return QString();
1492   }
1493   QChar aSep = QDir::separator();
1494   //PARAVIEW_VERSION from the vtkPVConfig.h file
1495   QString aFileName =  aPVHome + aSep + "share" + aSep + "doc" + aSep + "paraview-"+ PARAVIEW_VERSION + aSep + "paraview.qch";
1496   return aFileName;
1497 }
1498
1499
1500 /*!
1501   \brief Load selected paraview state
1502
1503   If toClear == true, the current state will be cleared
1504 */
1505 void PVGUI_Module::loadSelectedState(bool toClear)
1506 {
1507   QString fileName;
1508
1509   LightApp_SelectionMgr* aSelectionMgr = getApp()->selectionMgr();
1510   SALOME_ListIO aListIO;
1511   aSelectionMgr->selectedObjects(aListIO);
1512
1513   if (aListIO.Extent() == 1 && aListIO.First()->hasEntry()) {
1514     std::string entry = aListIO.First()->getEntry();
1515
1516     // Get SALOMEDS client study
1517     _PTR(Study) studyDS = PARAVIS::GetCStudy(this);
1518     if(!studyDS) {
1519       return;
1520     }
1521
1522     // Check local id
1523     _PTR(SObject) stateSObj = studyDS->FindObjectID(entry);
1524     _PTR(GenericAttribute) anAttr;
1525     if (!stateSObj->FindAttribute(anAttr, "AttributeLocalID")) {
1526       return;
1527     }
1528     _PTR(AttributeLocalID) anID(anAttr);
1529     if (!anID->Value() == PVSTATEID) {
1530       return;
1531     }
1532
1533     // Get state file name
1534     if (stateSObj->FindAttribute(anAttr, "AttributeString")) {
1535       _PTR(AttributeString) aStringAttr(anAttr);
1536       QString stringValue(aStringAttr->Value().c_str());
1537
1538       if (QFile::exists(stringValue)) {
1539         fileName = stringValue;
1540       }
1541     }
1542   }
1543
1544   if (!fileName.isEmpty()) {
1545     if (toClear) {
1546       clearParaviewState();
1547     }
1548
1549     loadParaviewState(fileName.toLatin1().constData());
1550   }
1551   else {
1552     SUIT_MessageBox::critical(getApp()->desktop(),
1553                               tr("ERR_ERROR"),
1554                               tr("ERR_STATE_CANNOT_BE_RESTORED"));
1555   }
1556 }
1557
1558 void PVGUI_Module::onRepresentationChanged(pqRepresentation*) {
1559
1560
1561   //rnv: to fix the issue "21712: [CEA 581] Preference to display legend by default"
1562   //     find the pqDisplayColorWidget instances and connect the variableChanged SIGNAL on the
1563   //     onVariableChanged slot of this class. This connection needs to change visibility
1564   //     of the "Colored Legend" after change the "Color By" array.
1565   QList<pqDisplayColorWidget*> aWidget = getApp()->desktop()->findChildren<pqDisplayColorWidget*>();
1566
1567   for (int i = 0; i < aWidget.size() ; i++ ) {
1568     if( aWidget[i] ) {
1569       connect( aWidget[i], SIGNAL ( variableChanged ( pqVariableType, const QString ) ),
1570                this, SLOT(onVariableChanged( pqVariableType, const QString) ), Qt::UniqueConnection );
1571     }
1572   }
1573 }
1574
1575
1576 /*!
1577   \fn CAM_Module* createModule();
1578   \brief Export module instance (factory function).
1579   \return new created instance of the module
1580 */
1581
1582 #ifdef WNT
1583 #define PVGUI_EXPORT __declspec(dllexport)
1584 #else   // WNT
1585 #define PVGUI_EXPORT
1586 #endif  // WNT
1587
1588 extern "C" {
1589
1590   bool flag = false;
1591   PVGUI_EXPORT CAM_Module* createModule() {
1592     if(!flag) {
1593         vtkEDFHelperInit();
1594         flag = true;
1595     }
1596     return new PVGUI_Module();
1597   }
1598
1599   PVGUI_EXPORT char* getModuleVersion() {
1600     return (char*)PARAVIS_VERSION_STR;
1601   }
1602
1603 }