src/LightApp/LightApp_Application.cxx

   1 // Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 // File:      LightApp_Application.cxx
  24 // Created:   6/20/2005 18:39:45 PM
  25 // Author:    Natalia Donis
  26
  27 #ifdef WIN32
  28 // E.A. : On windows with python 2.6, there is a conflict
  29 // E.A. : between pymath.h and Standard_math.h which define
  30 // E.A. : some same symbols : acosh, asinh, ...
  31   #include <Standard_math.hxx>
  32   #ifndef DISABLE_PYCONSOLE
  33     #include <pymath.h>
  34   #endif
  35 #endif
  36
  37 #ifndef DISABLE_PYCONSOLE
  38   #include "LightApp_PyEditor.h"
  39   #include "PyConsole_Interp.h"
  40   #include "PyConsole_Console.h"
  41 #endif
  42
  43 #include "LightApp_Application.h"
  44 #include "LightApp_Module.h"
  45 #include "LightApp_DataModel.h"
  46 #include "LightApp_DataOwner.h"
  47 #include "LightApp_Displayer.h"
  48 #include "LightApp_Study.h"
  49 #include "LightApp_Preferences.h"
  50 #include "LightApp_PreferencesDlg.h"
  51 #include "LightApp_ModuleDlg.h"
  52 #include "LightApp_AboutDlg.h"
  53 #include "LightApp_ModuleAction.h"
  54 // temporary commented
  55 #include "LightApp_EventFilter.h"
  56 #include "LightApp_OBSelector.h"
  57 #include "LightApp_SelectionMgr.h"
  58 #include "LightApp_DataObject.h"
  59 #include "LightApp_WgViewModel.h"
  60 #include "LightApp_FullScreenHelper.h"
  61
  62 #include <GUI_version.h>
  63
  64 #include <SALOME_Event.h>
  65
  66 #ifdef USE_SALOME_STYLE
  67 #include <Style_Salome.h>
  68 #include <Style_PrefDlg.h>
  69 #endif // USE_SALOME_STYLE
  70
  71 #include <CAM_Module.h>
  72 #include <CAM_DataModel.h>
  73 #include <CAM_Study.h>
  74 #include <STD_TabDesktop.h>
  75
  76 #include <SUIT_DataBrowser.h>
  77 #include <SUIT_Session.h>
  78 #include <SUIT_Study.h>
  79 #include <SUIT_FileDlg.h>
  80 #include <SUIT_ResourceMgr.h>
  81 #include <SUIT_ShortcutMgr.h>
  82 #include <SUIT_Tools.h>
  83 #include <SUIT_Accel.h>
  84 #include <SUIT_MessageBox.h>
  85 #include <SUIT_ViewWindow.h>
  86
  87 #include <Qtx.h>
  88 #include <QtxFontEdit.h>
  89 #include <QtxToolBar.h>
  90 #include <QtxTreeView.h>
  91 #include <QtxMRUAction.h>
  92 #include <QtxDockAction.h>
  93 #include <QtxDockWidget.h>
  94 #include <QtxActionToolMgr.h>
  95 #include <QtxSearchTool.h>
  96 #include <QtxWorkstack.h>
  97 #include <QtxMap.h>
  98
  99 #include <LogWindow.h>
 100
 101 #ifndef DISABLE_GLVIEWER
 102   #include <GLViewer_Viewer.h>
 103   #include <GLViewer_ViewManager.h>
 104   #include "LightApp_GLSelector.h"
 105 #endif
 106
 107 #ifndef DISABLE_PLOT2DVIEWER
 108   #include <Plot2d_ViewManager.h>
 109   #include <Plot2d_ViewModel.h>
 110   #include <Plot2d_ViewWindow.h>
 111   #include <Plot2d_ViewFrame.h>
 112   #include "LightApp_Plot2dSelector.h"
 113 #ifndef DISABLE_SALOMEOBJECT
 114   #include <SPlot2d_ViewModel.h>
 115 #else
 116   #include <Plot2d_ViewModel.h>
 117 #endif
 118 #endif
 119
 120 #ifndef DISABLE_OCCVIEWER
 121   #include <OCCViewer_ViewManager.h>
 122   #include <OCCViewer_ViewFrame.h>
 123   #include <OCCViewer_ViewPort3d.h>
 124 #ifndef DISABLE_SALOMEOBJECT
 125   #include <SOCC_ViewModel.h>
 126 #else
 127   #include <OCCViewer_ViewModel.h>
 128 #endif
 129   #include "LightApp_OCCSelector.h"
 130 #endif
 131
 132 #ifndef DISABLE_VTKVIEWER
 133 #ifndef DISABLE_SALOMEOBJECT
 134   #include <SVTK_ViewModel.h>
 135   #include <SVTK_ViewManager.h>
 136   #include "LightApp_VTKSelector.h"
 137 #else
 138   #include <VTKViewer_ViewModel.h>
 139   #include <VTKViewer_ViewManager.h>
 140 #endif
 141   #include <VTKViewer_ViewModel.h>
 142 #endif
 143
 144 #ifndef DISABLE_QXGRAPHVIEWER
 145   #include <QxScene_ViewManager.h>
 146   #include <QxScene_ViewModel.h>
 147   #include <QxScene_ViewWindow.h>
 148 #endif
 149
 150 #ifndef DISABLE_GRAPHICSVIEW
 151   #include "GraphicsView_Viewer.h"
 152   #include "GraphicsView_ViewManager.h"
 153   #include "LightApp_GVSelector.h"
 154 #endif
 155
 156 #ifndef DISABLE_PVVIEWER
 157   #include "PVViewer_ViewManager.h"
 158   #include "PVViewer_ViewWindow.h"
 159   #include "PVViewer_ViewModel.h"
 160 #endif
 161
 162 #ifndef DISABLE_PYVIEWER
 163   #include <PyViewer_ViewManager.h>
 164   #include <PyViewer_ViewModel.h>
 165   #include <PyViewer_ViewWindow.h>
 166 #endif
 167
 168
 169 #define VISIBILITY_COLUMN_WIDTH 25
 170
 171 #include <QDir>
 172 #include <QImage>
 173 #include <QString>
 174 #include <QWidget>
 175 #include <QStringList>
 176 #include <QFile>
 177 #include <QApplication>
 178 #include <QMap>
 179 #include <QStatusBar>
 180 #include <QThread>
 181 #include <QObjectList>
 182 #include <QComboBox>
 183 #include <QInputDialog>
 184 #include <QFontDatabase>
 185 #include <QIcon>
 186 #include <QByteArray>
 187 #include <QMenu>
 188 #include <QProcess>
 189 #include <QTimer>
 190 #include <QHeaderView>
 191 #include <QTreeView>
 192 #include <QMimeData>
 193 #include <QShortcut>
 194 #include <QRegExp>
 195
 196 #include <utilities.h>
 197
 198 #define FIRST_HELP_ID 1000000
 199
 200 #ifndef DISABLE_SALOMEOBJECT
 201   #include <SALOME_InteractiveObject.hxx>
 202   #include <SALOME_ListIO.hxx>
 203 #endif
 204
 205 #include <Standard_Version.hxx>
 206
 207 #define ToolBarMarker    0
 208 #define DockWidgetMarker 1
 209
 210 static const char* imageEmptyIcon[] = {
 211 "20 20 1 1",
 212 ".      c None",
 213 "....................",
 214 "....................",
 215 "....................",
 216 "....................",
 217 "....................",
 218 "....................",
 219 "....................",
 220 "....................",
 221 "....................",
 222 "....................",
 223 "....................",
 224 "....................",
 225 "....................",
 226 "....................",
 227 "....................",
 228 "....................",
 229 "....................",
 230 "....................",
 231 "....................",
 232 "...................."};
 233
 234 int LightApp_Application::lastStudyId = 0;
 235
 236 // Markers used to parse array with dockable windows and toolbars state.
 237 // For more details please see the qdockarealayout.cpp && qtoolbararealayout.cpp
 238 // in the Qt source code.
 239
 240 #define QDockWidgetMarker 0xfd // = DockWidgetStateMarker
 241 #define QToolBarMarker 0xfc    // = ToolBarStateMarkerEx
 242
 243 // Format of the Byte array with the windows and toolbar state is:
 244 // VersionMarker|version|DockWidgetStateMarker|nbDockWidgetLines|...DocWidgetData...|ToolBarStateMarkerEx|nbToolBarLines|...ToolBarData...
 245
 246 //Find toolbar marker position in the array in the following way:
 247 //since the 'toolbar marker' is not unique, find index of first occurrence of the
 248 //'toolbar marker' in the array and check that next string is name of the toolbar
 249
 250 void LightAppCleanUpAppResources()
 251 {
 252   if ( LightApp_Application::_prefs_ ) {
 253     delete LightApp_Application::_prefs_;
 254     LightApp_Application::_prefs_ = 0;
 255   }
 256 }
 257
 258 namespace
 259 {
 260   int getToolbarMarkerIndex( QByteArray input, const QStringList& aFlags ) {
 261     int aResult = -1,tmp = 0;
 262     int inputLen = input.length();
 263     QDataStream anInputData( &input, QIODevice::ReadOnly );
 264     while ( tmp < inputLen ) {
 265       tmp = input.indexOf( QToolBarMarker, tmp + 1 );
 266       if ( tmp < 0 )
 267         break;
 268       anInputData.device()->seek( tmp );
 269       uchar mark;
 270       anInputData >> mark;
 271       int lines;
 272       anInputData >> lines;
 273
 274       if ( lines == 0 && anInputData.atEnd() ) {
 275         //Case then array doesn't contain information about toolbars,
 276         aResult = tmp;
 277         break;
 278       }
 279
 280       int pos;
 281       anInputData >> pos;
 282       int cnt;
 283       anInputData >> cnt;
 284       QString str;
 285       anInputData >> str;
 286       if ( aFlags.contains( str ) ) {
 287         aResult = tmp;
 288         break;
 289       }
 290     }
 291     return aResult;
 292   }
 293
 294   QString langToName( const QString& lang )
 295   {
 296     // special processing for English language to avoid such result as "American English"
 297     // as Qt cannot just say "English"
 298     QString result;
 299     if ( lang == "en" )
 300       result = "English";
 301     else
 302       result = QLocale( lang ).nativeLanguageName();
 303     return result;
 304   }
 305 }
 306
 307 /*!
 308   \return last global id of study
 309 */
 310 int LightApp_Application::studyId()
 311 {
 312   return LightApp_Application::lastStudyId;
 313 }
 314
 315 /*!Create new instance of LightApp_Application.*/
 316 extern "C" LIGHTAPP_EXPORT SUIT_Application* createApplication()
 317 {
 318   return new LightApp_Application();
 319 }
 320
 321 /*! \var global preferences of LightApp */
 322 LightApp_Preferences* LightApp_Application::_prefs_ = 0;
 323
 324
 325 /*!
 326   \class LightApp_Application
 327   Application containing LightApp module
 328 */
 329
 330 /*!Constructor.*/
 331 LightApp_Application::LightApp_Application()
 332 : CAM_Application( false ),
 333   myPrefs( 0 ),
 334   myScreenHelper(new LightApp_FullScreenHelper())
 335 {
 336   Q_INIT_RESOURCE( LightApp );
 337
 338   STD_TabDesktop* desk = new STD_TabDesktop();
 339   desk->setFullScreenAllowed(false);
 340   desk->setMinimizeAllowed(false);
 341
 342   setDesktop( desk );
 343
 344   // initialize auto save timer
 345   myAutoSaveTimer = new QTimer( this );
 346   myAutoSaveTimer->setSingleShot( true );
 347   connect( myAutoSaveTimer, SIGNAL( timeout() ), this, SLOT( onSaveDoc() ) );
 348
 349   //connect( this, SIGNAL( moving() ), this, SLOT( onMoved() ) );
 350
 351   SUIT_ResourceMgr* aResMgr = SUIT_Session::session()->resourceMgr();
 352   QPixmap aLogo = aResMgr->loadPixmap( "LightApp", tr( "APP_DEFAULT_ICO" ), false );
 353
 354   desktop()->setWindowIcon( aLogo );
 355   desktop()->setDockableMenuBar( false );
 356   desktop()->setDockableStatusBar( false );
 357
 358   // base logo (salome itself)
 359   desktop()->logoInsert( "_app_base",  aResMgr->loadPixmap( "LightApp", tr( "APP_BASE_LOGO" ), false ) );
 360   // extra logo (salome-based application)
 361   desktop()->logoInsert( "_app_extra", aResMgr->loadPixmap( "LightApp", tr( "APP_EXTRA_LOGO" ), false ) );
 362
 363   clearViewManagers();
 364
 365   mySelMgr = new LightApp_SelectionMgr( this );
 366
 367   myAccel = SUIT_Accel::getAccel();
 368
 369 #ifndef DISABLE_OCCVIEWER
 370   myAccel->setActionKey( SUIT_Accel::PanLeft,     Qt::CTRL+Qt::Key_Left,     OCCViewer_Viewer::Type() );
 371   myAccel->setActionKey( SUIT_Accel::PanRight,    Qt::CTRL+Qt::Key_Right,    OCCViewer_Viewer::Type() );
 372   myAccel->setActionKey( SUIT_Accel::PanUp,       Qt::CTRL+Qt::Key_Up,       OCCViewer_Viewer::Type() );
 373   myAccel->setActionKey( SUIT_Accel::PanDown,     Qt::CTRL+Qt::Key_Down,     OCCViewer_Viewer::Type() );
 374   myAccel->setActionKey( SUIT_Accel::ZoomIn,      Qt::CTRL+Qt::Key_Plus,     OCCViewer_Viewer::Type() );
 375   myAccel->setActionKey( SUIT_Accel::ZoomOut,     Qt::CTRL+Qt::Key_Minus,    OCCViewer_Viewer::Type() );
 376   myAccel->setActionKey( SUIT_Accel::ZoomFit,     Qt::CTRL+Qt::Key_Asterisk, OCCViewer_Viewer::Type() );
 377   myAccel->setActionKey( SUIT_Accel::ZoomFit,     Qt::Key_Space,             OCCViewer_Viewer::Type() );
 378   myAccel->setActionKey( SUIT_Accel::RotateLeft,  Qt::ALT+Qt::Key_Left,      OCCViewer_Viewer::Type() );
 379   myAccel->setActionKey( SUIT_Accel::RotateRight, Qt::ALT+Qt::Key_Right,     OCCViewer_Viewer::Type() );
 380   myAccel->setActionKey( SUIT_Accel::RotateUp,    Qt::ALT+Qt::Key_Up,        OCCViewer_Viewer::Type() );
 381   myAccel->setActionKey( SUIT_Accel::RotateDown,  Qt::ALT+Qt::Key_Down,      OCCViewer_Viewer::Type() );
 382 #endif
 383 #ifndef DISABLE_VTKVIEWER
 384   myAccel->setActionKey( SUIT_Accel::PanLeft,     Qt::CTRL+Qt::Key_Left,     VTKViewer_Viewer::Type() );
 385   myAccel->setActionKey( SUIT_Accel::PanRight,    Qt::CTRL+Qt::Key_Right,    VTKViewer_Viewer::Type() );
 386   myAccel->setActionKey( SUIT_Accel::PanUp,       Qt::CTRL+Qt::Key_Up,       VTKViewer_Viewer::Type() );
 387   myAccel->setActionKey( SUIT_Accel::PanDown,     Qt::CTRL+Qt::Key_Down,     VTKViewer_Viewer::Type() );
 388   myAccel->setActionKey( SUIT_Accel::ZoomIn,      Qt::CTRL+Qt::Key_Plus,     VTKViewer_Viewer::Type() );
 389   myAccel->setActionKey( SUIT_Accel::ZoomOut,     Qt::CTRL+Qt::Key_Minus,    VTKViewer_Viewer::Type() );
 390   myAccel->setActionKey( SUIT_Accel::ZoomFit,     Qt::CTRL+Qt::Key_Asterisk, VTKViewer_Viewer::Type() );
 391   myAccel->setActionKey( SUIT_Accel::ZoomFit,     Qt::Key_Space,             VTKViewer_Viewer::Type() );
 392   myAccel->setActionKey( SUIT_Accel::RotateLeft,  Qt::ALT+Qt::Key_Left,      VTKViewer_Viewer::Type() );
 393   myAccel->setActionKey( SUIT_Accel::RotateRight, Qt::ALT+Qt::Key_Right,     VTKViewer_Viewer::Type() );
 394   myAccel->setActionKey( SUIT_Accel::RotateUp,    Qt::ALT+Qt::Key_Up,        VTKViewer_Viewer::Type() );
 395   myAccel->setActionKey( SUIT_Accel::RotateDown,  Qt::ALT+Qt::Key_Down,      VTKViewer_Viewer::Type() );
 396 #endif
 397 #ifndef DISABLE_PLOT2DVIEWER
 398   myAccel->setActionKey( SUIT_Accel::PanLeft,     Qt::CTRL+Qt::Key_Left,     Plot2d_Viewer::Type() );
 399   myAccel->setActionKey( SUIT_Accel::PanRight,    Qt::CTRL+Qt::Key_Right,    Plot2d_Viewer::Type() );
 400   myAccel->setActionKey( SUIT_Accel::PanUp,       Qt::CTRL+Qt::Key_Up,       Plot2d_Viewer::Type() );
 401   myAccel->setActionKey( SUIT_Accel::PanDown,     Qt::CTRL+Qt::Key_Down,     Plot2d_Viewer::Type() );
 402   myAccel->setActionKey( SUIT_Accel::ZoomIn,      Qt::CTRL+Qt::Key_Plus,     Plot2d_Viewer::Type() );
 403   myAccel->setActionKey( SUIT_Accel::ZoomOut,     Qt::CTRL+Qt::Key_Minus,    Plot2d_Viewer::Type() );
 404   myAccel->setActionKey( SUIT_Accel::ZoomFit,     Qt::CTRL+Qt::Key_Asterisk, Plot2d_Viewer::Type() );
 405   myAccel->setActionKey( SUIT_Accel::ZoomFit,     Qt::Key_Space,             Plot2d_Viewer::Type() );
 406 #endif
 407
 408   connect( mySelMgr, SIGNAL( selectionChanged() ), this, SLOT( onSelection() ) );
 409   connect( desktop(), SIGNAL( windowActivated( SUIT_ViewWindow* ) ),
 410            this,      SLOT( onWindowActivated( SUIT_ViewWindow* ) ), Qt::UniqueConnection );
 411   connect( this, SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
 412            this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ), Qt::UniqueConnection );
 413
 414
 415   // Set existing font for the python console in resources
 416   if( !aResMgr->hasValue( "PyConsole", "font" ) )
 417     return;
 418
 419   QFont f = aResMgr->fontValue( "PyConsole", "font" );
 420   QFontDatabase fdb;
 421   QStringList famdb = fdb.families();
 422
 423   if ( famdb.contains(f.family()) || !aResMgr->hasValue( "PyConsole", "additional_families" ) )
 424     return;
 425
 426   QStringList anAddFamilies = aResMgr->stringValue( "PyConsole", "additional_families" ).split( ";", QString::SkipEmptyParts );
 427   QString aFamily;
 428   for ( QStringList::Iterator it = anAddFamilies.begin(); it != anAddFamilies.end(); ++it )
 429   {
 430     aFamily = *it;
 431     if ( famdb.contains(aFamily) )
 432     {
 433       f.setFamily( aFamily );
 434       aResMgr->setValue( "PyConsole", "font", f );
 435       break;
 436     }
 437   }
 438 }
 439
 440 /*!Destructor.
 441  *\li Save window geometry.
 442  *\li Save desktop geometry.
 443  *\li Save resource maneger.
 444  *\li Delete selection manager.
 445  */
 446 LightApp_Application::~LightApp_Application()
 447 {
 448   savePreferences();
 449   delete mySelMgr;
 450   delete myScreenHelper;
 451   myPrefs = 0;
 452 }
 453
 454 /*!Start application.*/
 455 void LightApp_Application::start()
 456 {
 457   CAM_Application::start();
 458
 459   updateWindows();
 460   updateViewManagers();
 461   updateCommandsStatus();
 462
 463   putInfo( "" );
 464   desktop()->statusBar()->showMessage( "" );
 465
 466   LightApp_EventFilter::Init();
 467 }
 468
 469 /*!Closeapplication.*/
 470 void LightApp_Application::closeApplication()
 471 {
 472 #ifndef DISABLE_QTXWEBBROWSER
 473   QProcess::startDetached( "HelpBrowser",
 474                            QStringList() << QString( "--remove=%1" ).arg( QApplication::instance()->applicationPid() ) );
 475 #endif
 476   CAM_Application::closeApplication();
 477 }
 478
 479 /*!Gets application name.*/
 480 QString LightApp_Application::applicationName() const
 481 {
 482   static QString _app_name;
 483   if ( _app_name.isEmpty() )
 484     _app_name = tr( "APP_NAME" );
 485   return _app_name;
 486 }
 487
 488 /*!Gets application version.*/
 489 QString LightApp_Application::applicationVersion() const
 490 {
 491   static QString _app_version;
 492
 493   if ( _app_version.isEmpty() )
 494   {
 495     QString resVersion = tr( "APP_VERSION" );
 496     if ( resVersion != "APP_VERSION" )
 497     {
 498       _app_version = resVersion;
 499     }
 500     else
 501     {
 502       _app_version = GUI_VERSION_STR;
 503     }
 504   }
 505   return _app_version;
 506 }
 507
 508 /*!Load module by \a name.*/
 509 CAM_Module* LightApp_Application::loadModule( const QString& name, const bool showMsg )
 510 {
 511   CAM_Module* mod = CAM_Application::loadModule( name, showMsg );
 512   if ( mod )
 513   {
 514     connect( this, SIGNAL( studyOpened() ), mod, SLOT( onModelOpened() ) );
 515     connect( this, SIGNAL( studySaved() ),  mod, SLOT( onModelSaved() ) );
 516     connect( this, SIGNAL( studyClosed() ), mod, SLOT( onModelClosed() ) );
 517   }
 518   return mod;
 519 }
 520
 521 /*!Activate module by \a modName*/
 522 bool LightApp_Application::activateModule( const QString& modName )
 523 {
 524   QString actName;
 525   CAM_Module* prevMod = activeModule();
 526
 527   if ( prevMod )
 528     actName = prevMod->moduleName();
 529
 530   if ( actName == modName )
 531     return true;
 532
 533   putInfo( tr( "ACTIVATING_MODULE" ).arg( modName ) );
 534
 535   saveDockWindowsState();
 536
 537   bool status = CAM_Application::activateModule( modName );
 538
 539   updateModuleActions();
 540
 541   putInfo( "" );
 542
 543   if ( !status )
 544     return false;
 545
 546   updateWindows();
 547   updateViewManagers();
 548
 549   if ( activeStudy() && activeStudy()->root() && objectBrowser() ) {
 550     if ( objectBrowser()->root() != activeStudy()->root() )
 551       objectBrowser()->setRoot( activeStudy()->root() );
 552     updateObjectBrowser( true );
 553   }
 554
 555   if ( activeModule() ) activeModule()->updateModuleVisibilityState();
 556
 557   return true;
 558 }
 559
 560 /*!Gets selection manager.*/
 561 LightApp_SelectionMgr* LightApp_Application::selectionMgr() const
 562 {
 563   return mySelMgr;
 564 }
 565
 566 /*!Creat action "New window" for certain type of viewer:*/
 567 void LightApp_Application::createActionForViewer( const int id,
 568                                                   const int parentId,
 569                                                   const QString& suffix,
 570                                                   const int accel )
 571 {
 572   QString vtlt = tr( QString( "NEW_WINDOW_%1" ).arg( suffix ).toLatin1().constData() );
 573   QString tip = tr( "CREATING_NEW_WINDOW" ).arg( vtlt.remove( "&" ) );
 574   QAction* a = createAction( id,                      // menu action id
 575                              tip,                     // status tip
 576                              QIcon(),                 // icon
 577                              vtlt,                    // menu text
 578                              tip,                     // tooltip
 579                              accel,                   // shortcut
 580                              desktop(),               // parent
 581                              false,                   // toggle flag
 582                              this,                    // receiver
 583                              SLOT( onNewWindow() ) ); // slot
 584   createMenu( a, parentId, -1 );
 585 }
 586
 587 /*!Create actions:*/
 588
 589 void LightApp_Application::createActions()
 590 {
 591   CAM_Application::createActions();
 592
 593   SUIT_Desktop* desk = desktop();
 594   SUIT_ResourceMgr* resMgr = resourceMgr();
 595
 596   // Preferences
 597   createAction( PreferencesId, tr( "TOT_DESK_PREFERENCES" ), QIcon(),
 598                 tr( "MEN_DESK_PREFERENCES" ), tr( "PRP_DESK_PREFERENCES" ),
 599                 Qt::CTRL+Qt::Key_P, desk, false, this, SLOT( onPreferences() ) );
 600
 601   // Help menu
 602
 603   int helpMenu = createMenu( tr( "MEN_DESK_HELP" ), -1, -1, 1000 );
 604
 605   int id = LightApp_Application::UserID + FIRST_HELP_ID;
 606
 607   // a) Link to web site
 608   QString url = resMgr->stringValue("GUI", "site_url");
 609   if ( !url.isEmpty() ) {
 610     QString title = tr ( "SALOME_SITE" );
 611     QAction* as = createAction( id, title,
 612                                 resMgr->loadPixmap( "LightApp", tr( "ICON_WWW" ), false ),
 613                                 title, title,
 614                                 0, desk, false, this, SLOT( onHelpOnline() ) );
 615     as->setData( url );
 616     createMenu( as, helpMenu, -1, 0 );
 617     id++;
 618   }
 619
 620   // b) Link to Forum
 621   url = resMgr->stringValue("GUI", "forum_url");
 622   if ( !url.isEmpty() ) {
 623     QString title = tr ( "SALOME_FORUM" );
 624     QAction* af = createAction( helpMenu, title,
 625                                 resMgr->loadPixmap( "LightApp", tr( "ICON_WWW" ), false ),
 626                                 title, title,
 627                                 0, desk, false, this, SLOT( onHelpOnline() ) );
 628     af->setData( url );
 629     createMenu( af, helpMenu, -1, 0 );
 630     id++;
 631   }
 632
 633   // c) Link to YouTube channel
 634   url = resMgr->stringValue("GUI", "channel_url");
 635   if ( !url.isEmpty() ) {
 636     createMenu( separator(), helpMenu, -1, 0 );
 637     QString title = tr ( "SALOME_VIDEO_TUTORIALS" );
 638     QAction* av = createAction( helpMenu, title,
 639                                 resMgr->loadPixmap( "LightApp", tr( "ICON_LIFE_RIGN" ), false ),
 640                                 title, title,
 641                                 0, desk, false, this, SLOT( onHelpOnline() ) );
 642     av->setData( url );
 643     createMenu( av, helpMenu, -1, 0 );
 644     id++;
 645   }
 646
 647   // d) Help for modules
 648
 649   // - First create top-level menus to preserve correct order
 650   QString userGuide = "User's Guide";
 651   QString devGuide = "Developer's Guide";
 652   createMenu( userGuide, helpMenu, -1, 5 );
 653   createMenu( devGuide, helpMenu, -1, 5 );
 654
 655   QStringList aModuleList;
 656   modules( aModuleList, false );
 657   aModuleList.prepend( "GUI" );
 658   aModuleList.prepend( "KERNEL" );
 659
 660   QString aModule;
 661   foreach( aModule, aModuleList ) {
 662     if ( aModule.isEmpty() )                                         // module title (user name)
 663       continue;
 664     IMap <QString, QString> helpData;                                // list of help files for the module
 665     QString helpSubMenu;                                             // help submenu name (empty if not needed)
 666     QString modName = moduleName( aModule );                         // module name
 667     if ( modName.isEmpty() ) modName = aModule;                      // for KERNEL and GUI
 668     QString rootDir = QString( "%1_ROOT_DIR" ).arg( modName );       // module root dir env variable
 669     QString modDir  = getenv( rootDir.toLatin1().constData() );      // module root dir path
 670     QString docSection;
 671     if (resMgr->hasValue( modName, "documentation" ) )
 672       docSection = resMgr->stringValue(modName, "documentation");
 673     else if ( resMgr->hasSection( modName + "_documentation" ) )
 674       docSection = modName + "_documentation";
 675     if ( !docSection.isEmpty() ) {
 676       helpSubMenu = resMgr->stringValue( docSection, "sub_menu", "" ).arg( aModule );
 677       QStringList listOfParam = resMgr->parameters( docSection );
 678       foreach( QString paramName, listOfParam ) {
 679         QString valueStr = resMgr->stringValue( docSection, paramName );
 680         if ( !valueStr.isEmpty() ) {
 681           QFileInfo fi( valueStr );
 682           if ( fi.isRelative() && !modDir.isEmpty() )
 683             valueStr = Qtx::addSlash( modDir ) + valueStr;
 684           if ( QFile::exists( valueStr ) )
 685             helpData.insert( paramName.arg( aModule ), valueStr );
 686         }
 687       }
 688     }
 689
 690     if ( helpData.isEmpty() && !modDir.isEmpty() ) {
 691       QStringList idxLst = QStringList() << modDir << "share" << "doc" << "salome" << "gui" << modName << "index.html";
 692       QString indexFile = idxLst.join( QDir::separator() );          // index file
 693       if ( QFile::exists( indexFile ) )
 694         helpData.insert( tr( "%1 module Users's Guide" ).arg( aModule ), indexFile );
 695     }
 696
 697     IMapConstIterator<QString, QString > fileIt;
 698     for ( fileIt = helpData.begin(); fileIt != helpData.end(); fileIt++ ) {
 699       QString helpFileName = fileIt.key();
 700       // remove all '//' occurances
 701       while ( helpFileName.contains( "//" ) )
 702         helpFileName.replace( "//", "" );
 703       // obtain submenus hierarchy if given
 704       QStringList smenus = helpFileName.split( "/" );
 705       helpFileName = smenus.takeLast();
 706       // workaround for User's Guide and Developer's Guide to avoid having single item in module's submenu.
 707       if ( helpFileName == userGuide || helpFileName == devGuide ) {
 708         QString menuPath = smenus.join( "/" );
 709         QStringList allKeys = helpData.keys();
 710         QStringList total = allKeys.filter( QRegExp( QString( "^%1" ).arg( menuPath ) ) );
 711         if ( total.count() == 1 && smenus.count() > 0 )
 712           helpFileName = smenus.takeLast();
 713       }
 714       QAction* a = createAction( id, helpFileName,
 715                                  resMgr->loadPixmap( "STD", tr( "ICON_HELP" ), false ),
 716                                  helpFileName, helpFileName,
 717                                  0, desk, false, this, SLOT( onHelpContentsModule() ) );
 718       a->setData( fileIt.value() );
 719       if ( !helpSubMenu.isEmpty() ) {
 720         smenus.prepend( helpSubMenu );
 721       }
 722       // create sub-menus hierarchy
 723       int menuId = helpMenu;
 724       foreach ( QString subMenu, smenus )
 725         menuId = createMenu( subMenu, menuId, -1, 5 );
 726       createMenu( a, menuId, -1, ( menuId != helpMenu && (helpFileName == userGuide || helpFileName == devGuide) ) ? 0 : 5 );
 727       id++;
 728     }
 729   }
 730
 731   // - Additional help items
 732
 733   createMenu( separator(), helpMenu, -1, 10 );
 734
 735   QStringList addHelpItems = resMgr->parameters( "add_help" );
 736   foreach ( QString addHelpItem, addHelpItems ) {
 737     QString valueStr = resMgr->stringValue( "add_help", addHelpItem );
 738     if ( !valueStr.isEmpty() && QFile::exists( valueStr ) ) {
 739       QAction* a = createAction( id, addHelpItem,
 740                                  resMgr->loadPixmap( "STD", tr( "ICON_HELP" ), false ),
 741                                  addHelpItem, addHelpItem,
 742                                  0, desk, false, this, SLOT( onHelpContentsModule() ) );
 743       a->setData( valueStr );
 744       createMenu( a, helpMenu, -1, 10 );
 745       id++;
 746     }
 747   }
 748
 749   //! MRU
 750   static QtxMRUAction* mru = new QtxMRUAction( tr( "TOT_DESK_MRU" ), tr( "MEN_DESK_MRU" ), 0 );
 751   connect( mru, SIGNAL( activated( const QString& ) ), this, SLOT( onMRUActivated( const QString& ) ) );
 752   registerAction( MRUId, mru );
 753
 754   // default icon for neutral point ('SALOME' module)
 755   QPixmap defIcon = resMgr->loadPixmap( "LightApp", tr( "APP_DEFAULT_ICO" ), false );
 756   if ( defIcon.isNull() )
 757     defIcon = QPixmap( imageEmptyIcon );
 758
 759   //! default icon for any module
 760   QPixmap modIcon = resMgr->loadPixmap( "LightApp", tr( "APP_MODULE_ICO" ), false );
 761   if ( modIcon.isNull() )
 762     modIcon = QPixmap( imageEmptyIcon );
 763
 764   QStringList modList;
 765   modules( modList, false );
 766
 767   if ( modList.count() > 1 )
 768   {
 769     LightApp_ModuleAction* moduleAction =
 770       new LightApp_ModuleAction( tr( "APP_NAME" ), defIcon, desk );
 771
 772     QMap<QString, QString> iconMap;
 773     moduleIconNames( iconMap );
 774
 775     const int iconSize = 20;
 776
 777     QStringList::Iterator it;
 778     for ( it = modList.begin(); it != modList.end(); ++it )
 779     {
 780       if ( !isModuleAccessible( *it ) )
 781         continue;
 782
 783       QString modName = moduleName( *it );
 784
 785       QString iconName;
 786       if ( iconMap.contains( *it ) )
 787         iconName = iconMap[*it];
 788
 789       QPixmap icon = resMgr->loadPixmap( modName, iconName, false );
 790       if ( icon.isNull() )
 791       {
 792         icon = modIcon;
 793         INFOS( std::endl <<
 794                "****************************************************************" << std::endl <<
 795                "     Warning: icon for " << qPrintable(*it) << " is not found!" << std::endl <<
 796                "     Using the default icon." << std::endl <<
 797                "****************************************************************" << std::endl);
 798       }
 799       icon = Qtx::scaleIcon( icon, iconSize );
 800
 801       moduleAction->insertModule( *it, icon );
 802     }
 803
 804     connect( moduleAction, SIGNAL( moduleActivated( const QString& ) ),
 805              this, SLOT( onModuleActivation( const QString& ) ) );
 806     registerAction( ModulesListId, moduleAction );
 807   }
 808
 809   // New window
 810   int windowMenu = createMenu( tr( "MEN_DESK_WINDOW" ), -1, MenuWindowId, 100 );
 811   int newWinMenu = createMenu( tr( "MEN_DESK_NEWWINDOW" ), windowMenu, -1, 0 );
 812
 813   createAction( CloseId, tr( "TOT_CLOSE" ), QIcon(), tr( "MEN_DESK_CLOSE" ), tr( "PRP_CLOSE" ),
 814                 Qt::CTRL+Qt::Key_F4, desk, false, this, SLOT( onCloseWindow() ) );
 815   createAction( CloseAllId, tr( "TOT_CLOSE_ALL" ), QIcon(), tr( "MEN_DESK_CLOSE_ALL" ), tr( "PRP_CLOSE_ALL" ),
 816                 0, desk, false, this, SLOT( onCloseAllWindow() ) );
 817   createAction( GroupAllId, tr( "TOT_GROUP_ALL" ), QIcon(), tr( "MEN_DESK_GROUP_ALL" ), tr( "PRP_GROUP_ALL" ),
 818                 0, desk, false, this, SLOT( onGroupAllWindow() ) );
 819
 820   createMenu( CloseId,     windowMenu, 0, -1 );
 821   createMenu( CloseAllId,  windowMenu, 0, -1 );
 822   createMenu( GroupAllId,  windowMenu, 0, -1 );
 823   createMenu( separator(), windowMenu, -1, 0 );
 824
 825 #ifndef DISABLE_GLVIEWER
 826   createActionForViewer( NewGLViewId, newWinMenu, QString::number( 0 ), Qt::ALT+Qt::Key_G );
 827 #endif
 828 #ifndef DISABLE_PLOT2DVIEWER
 829   createActionForViewer( NewPlot2dId, newWinMenu, QString::number( 1 ), Qt::ALT+Qt::Key_P );
 830 #endif
 831 #ifndef DISABLE_OCCVIEWER
 832   createActionForViewer( NewOCCViewId, newWinMenu, QString::number( 2 ), Qt::ALT+Qt::Key_O );
 833 #endif
 834 #ifndef DISABLE_VTKVIEWER
 835   createActionForViewer( NewVTKViewId, newWinMenu, QString::number( 3 ), Qt::ALT+Qt::Key_K );
 836 #endif
 837 #ifndef DISABLE_QXGRAPHVIEWER
 838   createActionForViewer( NewQxSceneViewId, newWinMenu, QString::number( 4 ), Qt::ALT+Qt::Key_S );
 839 #endif
 840 #ifndef DISABLE_GRAPHICSVIEW
 841   createActionForViewer( NewGraphicsViewId, newWinMenu, QString::number( 5 ), Qt::ALT+Qt::Key_C );
 842 #endif
 843 #ifndef DISABLE_PVVIEWER
 844   createActionForViewer( NewPVViewId, newWinMenu, QString::number( 6 ), Qt::ALT+Qt::Key_A );
 845 #endif
 846 #ifndef DISABLE_PYVIEWER
 847   createActionForViewer( NewPyViewerId, newWinMenu, QString::number( 7 ), Qt::ALT+Qt::Key_Y );
 848 #endif
 849
 850   createAction( RenameId, tr( "TOT_RENAME" ), QIcon(), tr( "MEN_DESK_RENAME" ), tr( "PRP_RENAME" ),
 851                 Qt::ALT+Qt::SHIFT+Qt::Key_R, desk, false, this, SLOT( onRenameWindow() ) );
 852   createMenu( RenameId, windowMenu, -1 );
 853
 854   int fileMenu = createMenu( tr( "MEN_DESK_FILE" ), -1 );
 855   createMenu( PreferencesId, fileMenu, 50, -1 );
 856   createMenu( separator(), fileMenu, -1, 50, -1 );
 857
 858   createMenu( separator(), fileMenu, -1, 100, -1 );
 859   createMenu( MRUId, fileMenu, 100, -1 );
 860   createMenu( separator(), fileMenu, -1, 100, -1 );
 861
 862 #ifdef USE_SALOME_STYLE
 863   createAction( StyleId, tr( "TOT_THEME" ), QIcon(), tr( "MEN_DESK_THEME" ), tr( "PRP_THEME" ),
 864                 0, desk, false, this, SLOT( onStylePreferences() ) );
 865 #endif // USE_SALOME_STYLE
 866
 867   createAction( FullScreenId, tr( "TOT_FULLSCREEN" ), QIcon(), tr( "MEN_DESK_FULLSCREEN" ), tr( "PRP_FULLSCREEN" ),
 868                 Qt::Key_F11, desk, false, this, SLOT( onFullScreen() ) );
 869
 870
 871   int viewMenu = createMenu( tr( "MEN_DESK_VIEW" ), -1 );
 872   createMenu( separator(), viewMenu, -1, 20, -1 );
 873 #ifdef USE_SALOME_STYLE
 874   createMenu( StyleId, viewMenu, 20, -1 );
 875 #endif // USE_SALOME_STYLE
 876   createMenu( FullScreenId, viewMenu, 20, -1 );
 877
 878   int modTBar = createTool( tr( "INF_TOOLBAR_MODULES" ),    // title (language-dependant)
 879                             QString( "SalomeModules" ) );   // name (language-independant)
 880   createTool( ModulesListId, modTBar );
 881 }
 882
 883 /*!On module activation action.*/
 884 void LightApp_Application::onModuleActivation( const QString& modName )
 885 {
 886   // Force user to create/open a study before module activation
 887   QMap<QString, QString> iconMap;
 888   moduleIconNames( iconMap );
 889   QPixmap icon = resourceMgr()->loadPixmap( moduleName( modName ), iconMap[ modName ], false );
 890   if ( icon.isNull() )
 891     icon = resourceMgr()->loadPixmap( "LightApp", tr( "APP_MODULE_BIG_ICO" ), false ); // default icon for any module
 892
 893   bool cancelled = false;
 894
 895   while ( !modName.isEmpty() && !activeStudy() && !cancelled ){
 896     LightApp_ModuleDlg aDlg( desktop(), modName, icon );
 897     QMap<int, QString> opmap = activateModuleActions();
 898     for ( QMap<int, QString>::ConstIterator it = opmap.begin(); it != opmap.end(); ++it )
 899       aDlg.addButton( it.value(), it.key() );
 900
 901     int res = aDlg.exec();
 902     if ( res ) {
 903       // some operation is selected
 904       moduleActionSelected( res );
 905     }
 906     else {
 907       // cancelled
 908       putInfo( tr("INF_CANCELLED") );
 909
 910       LightApp_ModuleAction* moduleAction =
 911         qobject_cast<LightApp_ModuleAction*>( action( ModulesListId ) );
 912       if ( moduleAction )
 913         moduleAction->setActiveModule( QString() );
 914       cancelled = true;
 915     }
 916   }
 917
 918   if ( !cancelled )
 919     activateModule( modName );
 920 }
 921
 922 /*!Default module activation.*/
 923 QString LightApp_Application::defaultModule() const
 924 {
 925   QStringList aModuleNames;
 926   modules( aModuleNames, false ); // obtain a complete list of module names for the current configuration
 927   //! If there's the one and only module --> activate it automatically
 928   //! TODO: Possible improvement - default module can be taken from preferences
 929   return aModuleNames.count() > 1 ? "" : ( aModuleNames.count() ? aModuleNames.first() : "" );
 930 }
 931
 932 /*!On new window slot.*/
 933 void LightApp_Application::onNewWindow()
 934 {
 935   const QObject* obj = sender();
 936   if ( !obj || !obj->inherits( "QAction" ) )
 937     return;
 938
 939   QString type;
 940   int id = actionId( (QAction*)obj );
 941   switch ( id )
 942   {
 943 #ifndef DISABLE_GLVIEWER
 944   case NewGLViewId:
 945     type = GLViewer_Viewer::Type();
 946     break;
 947 #endif
 948 #ifndef DISABLE_PLOT2DVIEWER
 949   case NewPlot2dId:
 950     type = Plot2d_Viewer::Type();
 951     break;
 952 #endif
 953 #ifndef DISABLE_OCCVIEWER
 954   case NewOCCViewId:
 955     type = OCCViewer_Viewer::Type();
 956     break;
 957 #endif
 958 #ifndef DISABLE_VTKVIEWER
 959   case NewVTKViewId:
 960     type = VTKViewer_Viewer::Type();
 961     break;
 962 #endif
 963 #ifndef DISABLE_QXGRAPHVIEWER
 964   case NewQxSceneViewId:
 965     type = QxScene_Viewer::Type();
 966     break;
 967 #endif
 968 #ifndef DISABLE_GRAPHICSVIEW
 969   case NewGraphicsViewId:
 970     type = GraphicsView_Viewer::Type();
 971     break;
 972 #endif
 973 #ifndef DISABLE_PVVIEWER
 974   case NewPVViewId:
 975     type = PVViewer_Viewer::Type();
 976     break;
 977 #endif
 978 #ifndef DISABLE_PYVIEWER
 979   case NewPyViewerId:
 980     type = PyViewer_Viewer::Type();
 981     break;
 982 #endif
 983   }
 984
 985   if ( !type.isEmpty() )
 986     createViewManager( type );
 987 }
 988
 989 /*!
 990   SLOT: Creates new document
 991 */
 992 void LightApp_Application::onNewDoc()
 993 {
 994 #ifdef SINGLE_DESKTOP
 995   if ( !checkExistingDoc() )
 996     return;
 997 #endif
 998
 999   //asl: fix for 0020515
1000   saveDockWindowsState();
1001
1002   CAM_Application::onNewDoc();
1003 }
1004
1005 /*!
1006   SLOT: Opens new document
1007 */
1008 void LightApp_Application::onOpenDoc()
1009 {
1010   SUIT_Study* study = activeStudy();
1011
1012 #ifdef SINGLE_DESKTOP
1013   if ( !checkExistingDoc() )
1014     return;
1015 #endif
1016
1017   CAM_Application::onOpenDoc();
1018
1019   if ( !study ) // new study will be create in THIS application
1020   {
1021     updateWindows();
1022     updateViewManagers();
1023   }
1024 }
1025
1026 /*!
1027   SLOT: Opens new document.
1028   \param aName - name of file
1029 */
1030 bool LightApp_Application::onOpenDoc( const QString& aName )
1031 {
1032 #ifdef SINGLE_DESKTOP
1033   if ( !checkExistingDoc() )
1034     return false;
1035 #endif
1036
1037   saveDockWindowsState();
1038
1039   // We should take mru action first because this application instance can be deleted later.
1040   QtxMRUAction* mru = ::qobject_cast<QtxMRUAction*>( action( MRUId ) );
1041
1042   bool res = CAM_Application::onOpenDoc( aName );
1043
1044   if ( mru )
1045   {
1046     if ( res )
1047       mru->insert( aName );
1048     else
1049       mru->remove( aName );
1050   }
1051   return res;
1052 }
1053
1054 /*!
1055   SLOT: Displays "About" message box
1056 */
1057 void LightApp_Application::onHelpAbout()
1058 {
1059   LightApp_AboutDlg dlg( applicationName(), applicationVersion(), desktop() );
1060   dlg.exec();
1061 }
1062
1063 /*!
1064   Private SLOT: Called on selection is changed
1065   Dispatchs active module that selection is changed
1066 */
1067 void LightApp_Application::onSelection()
1068 {
1069   //MESSAGE("onSelection")
1070   onSelectionChanged();
1071
1072   if ( activeModule() && activeModule()->inherits( "LightApp_Module" ) )
1073     ((LightApp_Module*)activeModule())->selectionChanged();
1074 }
1075
1076 /*!
1077   Sets active study.
1078  \param study - SUIT_Study.
1079 */
1080 void LightApp_Application::setActiveStudy( SUIT_Study* study )
1081 {
1082   CAM_Application::setActiveStudy( study );
1083 }
1084
1085 /*!
1086   Enables/Disables menu items and toolbar buttons. Rebuild menu
1087 */
1088 void LightApp_Application::updateCommandsStatus()
1089 {
1090   CAM_Application::updateCommandsStatus();
1091   QAction* a = 0;
1092
1093 #ifndef DISABLE_GLVIEWER
1094   a = action( NewGLViewId );
1095   if( a )
1096     a->setEnabled( activeStudy() );
1097 #endif
1098
1099 #ifndef DISABLE_PLOT2DVIEWER
1100   a = action( NewPlot2dId );
1101   if( a )
1102     a->setEnabled( activeStudy() );
1103 #endif
1104
1105 #ifndef DISABLE_OCCVIEWER
1106   a = action( NewOCCViewId );
1107   if( a )
1108     a->setEnabled( activeStudy() );
1109 #endif
1110
1111 #ifndef DISABLE_VTKVIEWER
1112   a = action( NewVTKViewId );
1113   if( a )
1114     a->setEnabled( activeStudy() );
1115 #endif
1116
1117 #ifndef DISABLE_QXGRAPHVIEWER
1118   a = action( NewQxSceneViewId );
1119   if( a )
1120     a->setEnabled( activeStudy() );
1121 #endif
1122
1123 #ifndef DISABLE_GRAPHICSVIEW
1124   a = action( NewGraphicsViewId );
1125   if( a )
1126     a->setEnabled( activeStudy() );
1127 #endif
1128
1129 #ifndef DISABLE_PVVIEWER
1130   a = action( NewPVViewId );
1131   if( a )
1132     a->setEnabled( activeStudy() );
1133 #endif
1134
1135 #ifndef DISABLE_PYVIEWER
1136   a = action( NewPyViewerId );
1137   if( a )
1138     a->setEnabled( activeStudy() );
1139 #endif
1140 }
1141
1142 /*!
1143   \class RunBrowser
1144   Runs system command in separate thread
1145 */
1146 class RunBrowser: public QThread
1147 {
1148 public:
1149   RunBrowser( LightApp_Application* app,
1150               const QString&        theApp,
1151               const QString&        theParams,
1152               const QString&        theHelpFile,
1153               const QString&        theContext = QString(),
1154               //For the external browser always specify 'file://' protocol,
1155               //because some WEB browsers (for example Mozilla Firefox) can't open local file without protocol.
1156               const QString&        theProtocol = QString("file://"),
1157               const bool            isFile = true)
1158     : myApp( theApp ),
1159       myParams( theParams ),
1160       myContext( theContext ),
1161       myStatus(0),
1162       myLApp( app )
1163   {
1164     QString path_begin = theProtocol+"%1";
1165     QString path_end = theHelpFile;
1166     if( isFile ) {
1167       path_end = QFileInfo( theHelpFile ).canonicalFilePath();
1168     }
1169     myHelpFile = path_begin.arg( path_end );
1170   }
1171
1172   virtual void run()
1173   {
1174     if ( !myApp.isEmpty() && !myHelpFile.isEmpty()) {
1175       QString aCommand = QString( "%1 %2 \"%3%4\"" ).arg( myApp, myParams, myHelpFile, myContext.isEmpty() ? QString("") : QString( "#%1" ).arg( myContext ) );
1176
1177       QProcess* proc = new QProcess();
1178
1179       proc->start( aCommand );
1180       if ( !proc->waitForStarted() ) {
1181         SALOME_CustomEvent* ce2000 = new SALOME_CustomEvent( 2000 );
1182         QString* msg = new QString( QObject::tr( "EXTERNAL_BROWSER_CANNOT_SHOW_PAGE" ).arg( myApp, myHelpFile ) );
1183         ce2000->setData( msg );
1184         QApplication::postEvent( myLApp, ce2000 );
1185       }
1186     }
1187   }
1188
1189 private:
1190   QString               myApp;
1191   QString               myParams;
1192   QString               myHelpFile;
1193   QString               myContext;
1194   int                   myStatus;
1195   LightApp_Application* myLApp;
1196 };
1197
1198 /*!
1199   SLOT: Displays help contents for choosen module
1200 */
1201 void LightApp_Application::onHelpContentsModule()
1202 {
1203   const QAction* a = (QAction*) sender();
1204   QString helpFile = a->data().toString();
1205   if ( helpFile.isEmpty() ) return;
1206
1207   SUIT_ResourceMgr* resMgr = resourceMgr();
1208   QString platform;
1209 #ifdef WIN32
1210   platform = "winapplication";
1211 #else
1212   platform = "application";
1213 #endif
1214   QString anApp = resMgr->stringValue("ExternalBrowser", platform);
1215 #ifdef WIN32
1216   QString quote("\"");
1217   anApp.prepend( quote );
1218   anApp.append( quote );
1219 #endif
1220   QString aParams = resMgr->stringValue("ExternalBrowser", "parameters");
1221 #if DISABLE_QTXWEBBROWSER
1222   bool useExtBrowser = true;
1223 #else
1224   bool useExtBrowser = resMgr->booleanValue("ExternalBrowser", "use_external_browser", false );
1225 #endif
1226
1227   if( useExtBrowser ) {
1228     if ( !anApp.isEmpty() ) {
1229       RunBrowser* rs = new RunBrowser( this, anApp, aParams, helpFile );
1230       rs->start();
1231     }
1232     else {
1233       if ( SUIT_MessageBox::question( desktop(), tr( "WRN_WARNING" ), tr( "DEFINE_EXTERNAL_BROWSER" ),
1234                                       SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1235                                       SUIT_MessageBox::Yes ) == SUIT_MessageBox::Yes )
1236
1237         showPreferences( tr( "PREF_APP" ) );
1238     }
1239   }
1240   else {
1241     QStringList parameters;
1242     parameters << QString( "--language=%1" ).arg( resMgr->stringValue( "language", "language" ) );
1243     parameters << QString( "--add=%1" ).arg( QApplication::instance()->applicationPid() );
1244     parameters << helpFile;
1245     QProcess::startDetached( "HelpBrowser", parameters );
1246   }
1247 }
1248
1249 /*!
1250   SLOT: Displays help contents for choosen dialog
1251 */
1252 void LightApp_Application::onHelpContextModule( const QString& theComponentName,
1253                                                 const QString& theFileName,
1254                                                 const QString& theContext )
1255 {
1256   QString fileName = theFileName;
1257   QString context  = theContext;
1258   if ( !QFile::exists( fileName ) && theContext.isEmpty() ) {
1259     // context might be passed within theFileName argument
1260     QStringList comps = fileName.split("#");
1261     if ( comps.count() > 1 ) {
1262       context = comps.last();
1263       comps.removeLast();
1264       fileName = comps.join("#");
1265     }
1266   }
1267
1268   QString homeDir = "";
1269   if ( !theComponentName.isEmpty() ) {
1270     QString dir = getenv( ( theComponentName + "_ROOT_DIR" ).toLatin1().constData() );
1271     if ( !dir.isEmpty() )
1272       homeDir = Qtx::addSlash( Qtx::addSlash( dir )      +
1273                                Qtx::addSlash( "share" )  +
1274                                Qtx::addSlash( "doc" )    +
1275                                Qtx::addSlash( "salome" ) +
1276                                Qtx::addSlash( "gui" )    +
1277                                Qtx::addSlash( theComponentName ) );
1278   }
1279
1280   QString helpFile = QFileInfo( homeDir + fileName ).absoluteFilePath();
1281   SUIT_ResourceMgr* resMgr = resourceMgr();
1282         QString platform;
1283 #ifdef WIN32
1284         platform = "winapplication";
1285 #else
1286         platform = "application";
1287 #endif
1288         QString anApp = resMgr->stringValue("ExternalBrowser", platform);
1289 #ifdef WIN32
1290         QString quote("\"");
1291         anApp.prepend( quote );
1292         anApp.append( quote );
1293 #endif
1294
1295 #if DISABLE_QTXWEBBROWSER
1296   bool useExtBrowser = true;
1297 #else
1298   bool useExtBrowser = resMgr->booleanValue("ExternalBrowser", "use_external_browser", false );
1299 #endif
1300
1301   if(useExtBrowser) {
1302     QString aParams = resMgr->stringValue("ExternalBrowser", "parameters");
1303
1304     if ( !anApp.isEmpty() ) {
1305       RunBrowser* rs = new RunBrowser( this, anApp, aParams, helpFile, context );
1306       rs->start();
1307     }
1308     else {
1309       if ( SUIT_MessageBox::question( desktop(), tr( "WRN_WARNING" ), tr( "DEFINE_EXTERNAL_BROWSER" ),
1310                                       SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1311                                       SUIT_MessageBox::Yes ) == SUIT_MessageBox::Yes )
1312         showPreferences( tr( "PREF_APP" ) );
1313     }
1314   }
1315   else {
1316     QStringList parameters;
1317     parameters << QString( "--language=%1" ).arg( resMgr->stringValue( "language", "language" ) );
1318     parameters << QString( "--add=%1" ).arg( QApplication::instance()->applicationPid() );
1319     parameters << QString( "%1#%2" ).arg( helpFile ).arg( context );
1320     QProcess::startDetached( "HelpBrowser", parameters );
1321   }
1322 }
1323
1324 /*!
1325   SLOT: Displays help contents for choosen module
1326 */
1327 void LightApp_Application::onHelpOnline()
1328 {
1329   const QAction* a = (QAction*) sender();
1330   QString url = a->data().toString();
1331   if ( url.isEmpty() ) return;
1332
1333   SUIT_ResourceMgr* resMgr = resourceMgr();
1334   QString platform;
1335 #ifdef WIN32
1336   platform = "winapplication";
1337 #else
1338   platform = "application";
1339 #endif
1340   QString anApp = resMgr->stringValue("ExternalBrowser", platform);
1341 #ifdef WIN32
1342   QString quote("\"");
1343   anApp.prepend( quote );
1344   anApp.append( quote );
1345 #endif
1346   QString aParams = resMgr->stringValue("ExternalBrowser", "parameters");
1347 #if DISABLE_QTXWEBBROWSER
1348   bool useExtBrowser = true;
1349 #else
1350   bool useExtBrowser = resMgr->booleanValue("ExternalBrowser", "use_external_browser", false );
1351 #endif
1352
1353   if( useExtBrowser ) {
1354     if ( !anApp.isEmpty() ) {
1355       RunBrowser* rs = new RunBrowser( this, anApp, aParams, url, "", "http://", false );
1356       rs->start();
1357     }
1358     else {
1359       if ( SUIT_MessageBox::question( desktop(), tr( "WRN_WARNING" ), tr( "DEFINE_EXTERNAL_BROWSER" ),
1360                                       SUIT_MessageBox::Yes | SUIT_MessageBox::No,
1361                                       SUIT_MessageBox::Yes ) == SUIT_MessageBox::Yes )
1362
1363         showPreferences( tr( "PREF_APP" ) );
1364     }
1365   }
1366   else {
1367     QStringList parameters;
1368     parameters << QString( "--language=%1" ).arg( resMgr->stringValue( "language", "language" ) );
1369     parameters << QString( "--add=%1" ).arg( QApplication::instance()->applicationPid() );
1370     parameters << "http://" + url;
1371     QProcess::startDetached( "HelpBrowser", parameters );
1372   }
1373 }
1374
1375 /*!
1376   Sets enable or disable some actions on selection changed.
1377 */
1378 void LightApp_Application::onSelectionChanged()
1379 {
1380   LightApp_Module* m = dynamic_cast<LightApp_Module*>( activeModule() );
1381   bool canCopy  = m ? m->canCopy() : false;
1382   bool canPaste = m ? m->canPaste() : false;
1383
1384   action( EditCopyId )->setEnabled(canCopy);
1385   action( EditPasteId )->setEnabled(canPaste);
1386 }
1387
1388 /*!
1389   SLOT: Performs some actions when dockable windows are triggered
1390 */
1391 void LightApp_Application::onDockWindowVisibilityChanged( bool )
1392 {
1393 }
1394
1395 QWidget* LightApp_Application::dockWindow( const int id ) const
1396 {
1397   QWidget* wid = 0;
1398   if ( myWin.contains( id ) )
1399     wid = myWin[id];
1400   return wid;
1401 }
1402
1403 QDockWidget* LightApp_Application::windowDock( QWidget* wid ) const
1404 {
1405   if ( !wid )
1406     return 0;
1407
1408   QDockWidget* dock = 0;
1409   QWidget* w = wid->parentWidget();
1410   while ( w && !dock )
1411   {
1412     dock = ::qobject_cast<QDockWidget*>( w );
1413     w = w->parentWidget();
1414   }
1415   return dock;
1416 }
1417
1418 void LightApp_Application::insertDockWindow( const int id, QWidget* wid )
1419 {
1420   if ( !wid )
1421     return;
1422
1423   if ( wid != dockWindow( id ) )
1424     removeDockWindow( id );
1425
1426   myWin.insert( id, wid );
1427
1428   QtxDockWidget* dock = new QtxDockWidget( true, desktop() );
1429   connect( dock, SIGNAL(  destroyed( QObject* ) ), this, SLOT( onWCDestroyed( QObject* ) ) );
1430
1431   dock->setFeatures( QDockWidget::AllDockWidgetFeatures );
1432   dock->setObjectName( wid->objectName().isEmpty() ? QString( "window_%1" ).arg( id ) :
1433                        QString( "%1Dock" ).arg( wid->objectName() ) );
1434   dock->setWidget( wid );
1435   dock->toggleViewAction()->setData( QVariant( wid->objectName() ) );
1436   connect( dock->toggleViewAction(), SIGNAL( triggered( bool ) ),
1437            this, SLOT( onDockWindowVisibilityChanged( bool ) ) );
1438
1439   QKeySequence accel = wid->property( "shortcut" ).value<QKeySequence>();
1440   if ( !accel.isEmpty() )
1441     dock->toggleViewAction()->setShortcut( accel );
1442
1443   dock->show();
1444 }
1445
1446 void LightApp_Application::removeDockWindow( const int id )
1447 {
1448   QWidget* wid = dockWindow( id );
1449   if ( !wid )
1450     return;
1451
1452   myWin.remove( id );
1453
1454   QDockWidget* dock = windowDock( wid );
1455   if ( !dock )
1456     return;
1457
1458   dock->setWidget( 0 );
1459   wid->setParent( 0 );
1460   wid->setVisible( false );
1461   delete dock;
1462 }
1463
1464 void LightApp_Application::placeDockWindow( const int id, Qt::DockWidgetArea place )
1465 {
1466   QDockWidget* dock = windowDock( dockWindow( id ) );
1467   if ( dock && desktop() ) {
1468     desktop()->addDockWidget( place, dock );
1469     QtxDockAction* a = qobject_cast<QtxDockAction*>( action( ViewWindowsId ) );
1470     if ( a ) a->update();
1471   }
1472 }
1473
1474 /*!
1475   Gets window.
1476   \param flag - key for window
1477   \param studyId - study id
1478   Flag used how identificator of window in windows list.
1479 */
1480 QWidget* LightApp_Application::getWindow( const int flag, const int )
1481 {
1482   QWidget* wid = dockWindow( flag );
1483   if ( !wid )
1484     insertDockWindow( flag, wid = createWindow( flag ) );
1485
1486   QMap<int, int> winMap;
1487   currentWindows( winMap );
1488   if ( winMap.contains( flag ) )
1489     placeDockWindow( flag, (Qt::DockWidgetArea)winMap[flag] );
1490
1491   return wid;
1492 }
1493
1494 /*!
1495   \return Object Browser
1496 */
1497 SUIT_DataBrowser* LightApp_Application::objectBrowser()
1498 {
1499   return qobject_cast<SUIT_DataBrowser*>( dockWindow( WT_ObjectBrowser ) );
1500 }
1501
1502 /*!
1503   \return Log Window
1504 */
1505 LogWindow* LightApp_Application::logWindow()
1506 {
1507   return qobject_cast<LogWindow*>( dockWindow( WT_LogWindow ) );
1508 }
1509
1510 #ifndef DISABLE_PYCONSOLE
1511 /*!
1512   This returns the python console integrated to the GUI. Depending
1513   when you request the python console, this function could return
1514   null. Then the optional parameter force (default to false) can be
1515   set to force the creation of the python console if it is not done
1516   already.
1517   \param force - if true, the pythonConsole is created if it does not exist yet
1518   \return Python Console
1519 */
1520 PyConsole_Console* LightApp_Application::pythonConsole(const bool force)
1521 {
1522   QWidget* wid = dockWindow( WT_PyConsole );
1523   if ( !wid && force==true) {
1524     wid = getWindow(WT_PyConsole);
1525   }
1526   return qobject_cast<PyConsole_Console*>( wid );
1527 }
1528 #endif
1529
1530 /*!
1531   Updates object browser and maybe data models
1532   \param updateModels - if it is true, then data models are updated
1533 */
1534 void LightApp_Application::updateObjectBrowser( const bool updateModels )
1535 {
1536   // update existing data models
1537   if ( updateModels )
1538   {
1539     const bool isAutoUpdate = objectBrowser() ? objectBrowser()->autoUpdate() : true;
1540     if ( objectBrowser() )
1541       objectBrowser()->setAutoUpdate( false );
1542
1543     LightApp_Study* study = dynamic_cast<LightApp_Study*>(activeStudy());
1544     if ( study ) {
1545       CAM_Study::ModelList dm_list;
1546       study->dataModels( dm_list );
1547       QListIterator<CAM_DataModel*> it( dm_list );
1548       while ( it.hasNext() ) {
1549         CAM_DataModel* camDM = it.next();
1550         if ( camDM && camDM->inherits( "LightApp_DataModel" ) )
1551           ((LightApp_DataModel*)camDM)->update();
1552       }
1553     }
1554
1555     if( objectBrowser() )
1556       objectBrowser()->setAutoUpdate( isAutoUpdate );
1557   }
1558
1559   if ( objectBrowser() ) {
1560     objectBrowser()->updateGeometry();
1561     objectBrowser()->updateTree( 0, false );
1562   }
1563 }
1564
1565 /*!
1566   \return preferences
1567 */
1568 LightApp_Preferences* LightApp_Application::preferences() const
1569 {
1570   return preferences( false );
1571 }
1572
1573 /*!
1574   \return first view manager of some type
1575   \param vmType - type of view manager
1576   \param create - is it necessary to create view manager in case, when there is no manager of such type
1577 */
1578 SUIT_ViewManager* LightApp_Application::getViewManager( const QString& vmType, const bool create )
1579 {
1580   SUIT_ViewManager* aVM = viewManager( vmType );
1581   SUIT_ViewManager* anActiveVM = CAM_Application::activeViewManager();
1582   MESSAGE("vmType: " << vmType.toStdString() << " aVM: " << aVM << " anActiveVM: " << anActiveVM );
1583   if ( anActiveVM && anActiveVM->getType() == vmType )
1584     {
1585       MESSAGE("aVM = anActiveVM");
1586       aVM = anActiveVM;
1587     }
1588
1589   if ( aVM && !aVM->getDetached() && create )
1590   {
1591     if ( !aVM->getActiveView() )
1592       {
1593         MESSAGE("aVM->createView()");
1594         aVM->createView();
1595       }
1596     else
1597       {
1598         MESSAGE("desktop()->setActiveWindow: " << aVM->getActiveView());
1599         desktop()->setActiveWindow( aVM->getActiveView() );
1600       }
1601   }
1602   else if ( create )
1603     {
1604       MESSAGE("aVM = createViewManager( vmType )");
1605       aVM = createViewManager( vmType );
1606     }
1607
1608   return aVM;
1609 }
1610
1611 /*!
1612   Creates view manager of some type
1613   \param vmType - type of view manager
1614 */
1615 SUIT_ViewManager* LightApp_Application::createViewManager( const QString& vmType, bool detached )
1616 {
1617   SUIT_ResourceMgr* resMgr = resourceMgr();
1618
1619   SUIT_ViewManager* viewMgr = 0;
1620 #ifndef DISABLE_GLVIEWER
1621   if( vmType == GLViewer_Viewer::Type() )
1622   {
1623     viewMgr = new GLViewer_ViewManager( activeStudy(), desktop() );
1624     new LightApp_GLSelector( (GLViewer_Viewer2d*)viewMgr->getViewModel(), mySelMgr );
1625   }
1626 #endif
1627 #ifndef DISABLE_PLOT2DVIEWER
1628   if( vmType == Plot2d_Viewer::Type() )
1629   {
1630     viewMgr = new Plot2d_ViewManager( activeStudy(), desktop() );
1631     Plot2d_Viewer* vm;
1632 #ifndef DISABLE_SALOMEOBJECT
1633     SPlot2d_Viewer* v = new SPlot2d_Viewer();
1634     vm = v;
1635     new LightApp_Plot2dSelector( v, mySelMgr );
1636 #else
1637     vm = new Plot2d_Viewer();
1638 #endif
1639     viewMgr->setViewModel( vm  );// custom view model, which extends SALOME_View interface
1640     Plot2d_ViewWindow* wnd = dynamic_cast<Plot2d_ViewWindow*>( viewMgr->getActiveView() );
1641     if( wnd )
1642     {
1643       Plot2d_ViewFrame* frame = wnd->getViewFrame();
1644       frame->setBackgroundColor( resMgr->colorValue( "Plot2d", "Background", frame->backgroundColor() ) );
1645     }
1646   }
1647 #endif
1648 #ifndef DISABLE_QXGRAPHVIEWER
1649   if( vmType == QxScene_Viewer::Type() )
1650   {
1651     viewMgr = new QxScene_ViewManager( activeStudy(), desktop() );
1652     QxScene_Viewer* vm = new QxScene_Viewer();
1653     viewMgr->setViewModel( vm  );
1654     //QxScene_ViewWindow* wnd = dynamic_cast<QxScene_ViewWindow*>( viewMgr->getActiveView() );
1655   }
1656 #endif
1657 #ifndef DISABLE_GRAPHICSVIEW
1658   if( vmType == GraphicsView_Viewer::Type() )
1659   {
1660     viewMgr = new GraphicsView_ViewManager( activeStudy(), desktop() );
1661     new LightApp_GVSelector( (GraphicsView_Viewer*)viewMgr->getViewModel(), mySelMgr );
1662   }
1663 #endif
1664 #ifndef DISABLE_PVVIEWER
1665   if( vmType == PVViewer_Viewer::Type() )
1666   {
1667     if (( viewMgr = dynamic_cast<PVViewer_ViewManager*>( getViewManager( vmType, false )))) {
1668       viewMgr->getActiveView()->setFocus();
1669       return 0;
1670     } else {
1671       viewMgr = new PVViewer_ViewManager( activeStudy(), desktop(), logWindow() );
1672     }
1673   }
1674 #endif
1675 #ifndef DISABLE_PYVIEWER
1676   if( vmType == PyViewer_Viewer::Type() )
1677   {
1678     viewMgr = new PyViewer_ViewManager( activeStudy(), desktop() );
1679   }
1680 #endif
1681 #ifndef DISABLE_OCCVIEWER
1682   if( vmType == OCCViewer_Viewer::Type() )
1683   {
1684     viewMgr = new OCCViewer_ViewManager( activeStudy(), desktop() );
1685     OCCViewer_Viewer* vm;
1686 #ifndef DISABLE_SALOMEOBJECT
1687     vm = new SOCC_Viewer();
1688 #else
1689     vm = new OCCViewer_Viewer( true );
1690 #endif
1691     vm->setBackground( OCCViewer_ViewFrame::TOP_LEFT,
1692                        resMgr->backgroundValue( "OCCViewer", "xz_background", vm->background(OCCViewer_ViewFrame::TOP_LEFT) ) );
1693     vm->setBackground( OCCViewer_ViewFrame::TOP_RIGHT,
1694                        resMgr->backgroundValue( "OCCViewer", "yz_background", vm->background(OCCViewer_ViewFrame::TOP_RIGHT) ) );
1695     vm->setBackground( OCCViewer_ViewFrame::BOTTOM_LEFT,
1696                        resMgr->backgroundValue( "OCCViewer", "xy_background", vm->background(OCCViewer_ViewFrame::BOTTOM_LEFT) ) );
1697     vm->setBackground( OCCViewer_ViewFrame::BOTTOM_RIGHT,
1698                        resMgr->backgroundValue( "OCCViewer", "background", vm->background(OCCViewer_ViewFrame::MAIN_VIEW) ) );
1699
1700     vm->setTrihedronSize(  resMgr->doubleValue( "3DViewer", "trihedron_size", vm->trihedronSize() ),
1701                            resMgr->booleanValue( "3DViewer", "relative_size", vm->trihedronRelative() ));
1702     vm->setInteractionStyle( resMgr->integerValue( "3DViewer", "navigation_mode", vm->interactionStyle() ) );
1703     vm->setProjectionType( resMgr->integerValue( "OCCViewer", "projection_mode", vm->projectionType() ) );
1704     vm->setStereoType( resMgr->integerValue( "OCCViewer", "stereo_type", vm->stereoType() ) );
1705     vm->setAnaglyphFilter( resMgr->integerValue( "OCCViewer", "anaglyph_filter", vm->anaglyphFilter() ) );
1706     vm->setStereographicFocus( resMgr->integerValue( "OCCViewer", "focus_type", vm->stereographicFocusType() ),
1707                                resMgr->doubleValue( "OCCViewer", "focus_value", vm->stereographicFocusValue() ));
1708     vm->setInterocularDistance( resMgr->integerValue( "OCCViewer", "iod_type", vm->interocularDistanceType() ),
1709                                 resMgr->doubleValue( "OCCViewer", "iod_value", vm->interocularDistanceValue() ));
1710
1711     vm->setReverseStereo( resMgr->booleanValue( "OCCViewer", "reverse_stereo", vm->isReverseStereo() ) );
1712     vm->setVSync( resMgr->booleanValue( "OCCViewer", "enable_vsync", vm->isVSync() ) );
1713     vm->setQuadBufferSupport( resMgr->booleanValue( "OCCViewer", "enable_quad_buffer_support", vm->isQuadBufferSupport() ) );
1714     vm->setZoomingStyle( resMgr->integerValue( "3DViewer", "zooming_mode", vm->zoomingStyle() ) );
1715     vm->enablePreselection( resMgr->booleanValue( "OCCViewer", "enable_preselection", vm->isPreselectionEnabled() ) );
1716     vm->enableSelection(    resMgr->booleanValue( "OCCViewer", "enable_selection",    vm->isSelectionEnabled() ) );
1717     vm->setClippingColor( resMgr->colorValue( "OCCViewer", "clipping_color", vm->clippingColor() ) );
1718     vm->setClippingTextureParams( resMgr->booleanValue( "OCCViewer", "clipping_use_default_texture", vm->isDefaultTextureUsed() ),
1719                                   resMgr->stringValue( "OCCViewer", "clipping_texture", vm->clippingTexture() ),
1720                                   resMgr->booleanValue( "OCCViewer", "clipping_modulate", vm->isTextureModulated() ),
1721                                   resMgr->doubleValue( "OCCViewer", "clipping_scale", vm->clippingTextureScale() ) );
1722
1723
1724     viewMgr->setViewModel( vm );// custom view model, which extends SALOME_View interface
1725     new LightApp_OCCSelector( (OCCViewer_Viewer*)viewMgr->getViewModel(), mySelMgr );
1726   }
1727 #endif
1728 #ifndef DISABLE_VTKVIEWER
1729 #ifndef DISABLE_SALOMEOBJECT
1730   if ( vmType == SVTK_Viewer::Type() )
1731 #else
1732   if ( vmType == VTKViewer_Viewer::Type() )
1733 #endif
1734   {
1735 #ifndef DISABLE_SALOMEOBJECT
1736     viewMgr = new SVTK_ViewManager( activeStudy(), desktop() );
1737     SVTK_Viewer* vm = dynamic_cast<SVTK_Viewer*>( viewMgr->getViewModel() );
1738     if( vm )
1739     {
1740       vm->setProjectionMode( resMgr->integerValue( "VTKViewer", "projection_mode", vm->projectionMode() ) );
1741       vm->setStereoType( resMgr->integerValue( "VTKViewer", "stereo_type", vm->stereoType() ) );
1742       vm->setAnaglyphFilter( resMgr->integerValue( "VTKViewer", "anaglyph_filter", vm->anaglyphFilter() ) );
1743       vm->setQuadBufferSupport( resMgr->booleanValue( "VTKViewer", "enable_quad_buffer_support", vm->isQuadBufferSupport() ) );
1744       vm->setBackground( resMgr->backgroundValue( "VTKViewer", "background", vm->background() ) );
1745       vm->setTrihedronSize( resMgr->doubleValue( "3DViewer", "trihedron_size", vm->trihedronSize() ),
1746                             resMgr->booleanValue( "3DViewer", "relative_size", vm->trihedronRelative() ) );
1747       vm->setStaticTrihedronVisible( resMgr->booleanValue( "3DViewer", "show_static_trihedron", vm->isStaticTrihedronVisible() ) );
1748       vm->setInteractionStyle( resMgr->integerValue( "3DViewer", "navigation_mode", vm->interactionStyle() ) );
1749       vm->setZoomingStyle( resMgr->integerValue( "3DViewer", "zooming_mode", vm->zoomingStyle() ) );
1750       vm->setPreSelectionMode(resMgr->integerValue( "VTKViewer", "preselection", vm->preSelectionMode() ) );
1751       vm->enableSelection( resMgr->booleanValue( "VTKViewer", "enable_selection", vm->isSelectionEnabled() ) );
1752       vm->setIncrementalSpeed( resMgr->integerValue( "VTKViewer", "speed_value", vm->incrementalSpeed() ),
1753                                resMgr->integerValue( "VTKViewer", "speed_mode", vm->incrementalSpeedMode() ) );
1754       vm->setSpacemouseButtons( resMgr->integerValue( "VTKViewer", "spacemouse_func1_btn", vm->spacemouseBtn(1) ),
1755                                 resMgr->integerValue( "VTKViewer", "spacemouse_func2_btn", vm->spacemouseBtn(2) ),
1756                                 resMgr->integerValue( "VTKViewer", "spacemouse_func5_btn", vm->spacemouseBtn(3) ) );
1757       new LightApp_VTKSelector( vm, mySelMgr );
1758     }
1759 #else
1760     viewMgr = new VTKViewer_ViewManager( activeStudy(), desktop() );
1761     VTKViewer_Viewer* vm = dynamic_cast<VTKViewer_Viewer*>( viewMgr->getViewModel() );
1762     if ( vm )
1763       vm->setBackground( resMgr->backgroundValue( "VTKViewer", "background", vm->background() ) );
1764 #endif
1765   }
1766 #endif
1767
1768   if ( !viewMgr )
1769     return 0;
1770
1771   viewMgr->setDetached(detached);
1772   addViewManager( viewMgr );
1773   SUIT_ViewWindow* viewWin = viewMgr->createViewWindow();
1774
1775   if ( viewWin && desktop() ) {
1776     viewWin->resize( (int)( desktop()->width() * 0.6 ), (int)( desktop()->height() * 0.6 ) );
1777     viewWin->setDropDownButtons( resMgr->booleanValue( "viewers", "drop_down_buttons", true ) );
1778   }
1779
1780   return viewMgr;
1781 }
1782
1783 SUIT_ViewManager* LightApp_Application::createViewManager( const QString& vmType, QWidget* w )
1784 {
1785   SUIT_ResourceMgr* resMgr = resourceMgr();
1786
1787   SUIT_ViewManager* vm = new SUIT_ViewManager( activeStudy(),
1788                                                desktop(),
1789                                                new LightApp_WgViewModel( vmType, w ) );
1790   vm->setTitle( QString( "%1: %M - viewer %V" ).arg( vmType ) );
1791
1792   addViewManager( vm );
1793   SUIT_ViewWindow* vw = vm->createViewWindow();
1794   if ( vw && desktop() ) {
1795     vw->resize( (int)( desktop()->width() * 0.6 ), (int)( desktop()->height() * 0.6 ) );
1796     vw->setDropDownButtons( resMgr->booleanValue( "viewers", "drop_down_buttons", true ) );
1797   }
1798
1799   if ( !vmType.isEmpty() && !myUserWmTypes.contains( vmType ) )
1800     myUserWmTypes << vmType;
1801
1802   return vm;
1803 }
1804
1805 SUIT_ViewManager* LightApp_Application::createViewManager( SUIT_ViewModel* theModel )
1806 {
1807   SUIT_ResourceMgr* resMgr = resourceMgr();
1808
1809   SUIT_ViewManager* vm = new SUIT_ViewManager( activeStudy(),
1810                                                desktop(),
1811                                                theModel );
1812
1813   QString vmType = vm->getType();
1814
1815   vm->setTitle( QString( "%1: %M - viewer %V" ).arg( vmType ) );
1816
1817   addViewManager( vm );
1818   SUIT_ViewWindow* vw = vm->createViewWindow();
1819   if ( vw && desktop() ) {
1820     vw->resize( (int)( desktop()->width() * 0.6 ), (int)( desktop()->height() * 0.6 ) );
1821     vw->setDropDownButtons( resMgr->booleanValue( "viewers", "drop_down_buttons", true ) );
1822   }
1823
1824   if ( !vmType.isEmpty() && !myUserWmTypes.contains( vmType ) )
1825     myUserWmTypes << vmType;
1826
1827   return vm;
1828 }
1829
1830 /*!
1831   SLOT: Removes view manager from application
1832 */
1833 void LightApp_Application::onCloseView( SUIT_ViewManager* theVM )
1834 {
1835   removeViewManager( theVM );
1836 }
1837
1838 /*!
1839   Protected SLOT: On study created.
1840   \param theStudy - just created study
1841 */
1842 void LightApp_Application::onStudyCreated( SUIT_Study* theStudy )
1843 {
1844   SUIT_DataObject* aRoot = 0;
1845   if ( theStudy && theStudy->root() )
1846   {
1847     aRoot = theStudy->root();
1848     //aRoot->setName( tr( "DATA_MODELS" ) );
1849   }
1850
1851   getWindow( WT_ObjectBrowser );
1852
1853   loadDockWindowsState();
1854
1855   if ( objectBrowser() )
1856     objectBrowser()->setRoot( aRoot );
1857
1858   activateModule( defaultModule() );
1859
1860   if ( objectBrowser() )
1861     objectBrowser()->openLevels();
1862
1863 #ifndef DISABLE_PYCONSOLE
1864   if( pythonConsole() )
1865     getPyInterp()->initStudy();
1866 #endif
1867 }
1868
1869 /*!
1870   Protected SLOT: On study opened.
1871   \param theStudy - just opened  study
1872 */
1873 void LightApp_Application::onStudyOpened( SUIT_Study* theStudy )
1874 {
1875   SUIT_DataObject* aRoot = 0;
1876   if ( theStudy && theStudy->root() )
1877   {
1878     aRoot = theStudy->root();
1879     //aRoot->dump();
1880   }
1881
1882   getWindow( WT_ObjectBrowser );
1883
1884   loadDockWindowsState();
1885
1886   if ( objectBrowser() )
1887     objectBrowser()->setRoot( aRoot );
1888
1889   activateModule( defaultModule() );
1890
1891   if ( objectBrowser() )
1892     objectBrowser()->openLevels();
1893
1894 #ifndef DISABLE_PYCONSOLE
1895   if( pythonConsole() )
1896     getPyInterp()->initStudy();
1897 #endif
1898
1899   emit studyOpened();
1900 }
1901
1902 /*!Protected SLOT. On study saved.*/
1903 void LightApp_Application::onStudySaved( SUIT_Study* s )
1904 {
1905   QtxMRUAction* mru = ::qobject_cast<QtxMRUAction*>( action( MRUId ) );
1906   if ( mru && s )
1907     mru->insert( s->studyName() );
1908
1909   emit studySaved();
1910 }
1911
1912 /*!Protected SLOT. On study closed.*/
1913 void LightApp_Application::onStudyClosed( SUIT_Study* s )
1914 {
1915   /*
1916   disconnect( this, SIGNAL( viewManagerRemoved( SUIT_ViewManager* ) ),
1917               this, SLOT( onViewManagerRemoved( SUIT_ViewManager* ) ) );
1918   */
1919
1920   // stop auto-save timer
1921   myAutoSaveTimer->stop();
1922
1923   // Bug 10396: clear selection
1924   mySelMgr->clearSelected();
1925
1926   // Bug 12944: emit signal only after clear selection
1927   emit studyClosed();
1928
1929   activateModule( "" );
1930 }
1931
1932 /*!Protected SLOT.On desktop activated.*/
1933 void LightApp_Application::onDesktopActivated()
1934 {
1935   CAM_Application::onDesktopActivated();
1936   LightApp_Module* aModule = dynamic_cast<LightApp_Module*>(activeModule());
1937   if(aModule)
1938     aModule->studyActivated();
1939 }
1940
1941 void LightApp_Application::studyOpened( SUIT_Study* s )
1942 {
1943   CAM_Application::studyOpened( s );
1944
1945   updateWindows();
1946   updateViewManagers();
1947 }
1948
1949 void LightApp_Application::studySaved( SUIT_Study* s )
1950 {
1951   CAM_Application::studyOpened( s );
1952   SUIT_ResourceMgr* aResMgr = SUIT_Session::session()->resourceMgr();
1953   if ( aResMgr && activeStudy() ) {
1954     int autoSaveInterval = aResMgr->integerValue( "Study", "auto_save_interval", 0 );
1955     if ( autoSaveInterval > 0 ) myAutoSaveTimer->start( autoSaveInterval*60000 );
1956   }
1957 }
1958
1959 void LightApp_Application::studyCreated( SUIT_Study* s )
1960 {
1961   CAM_Application::studyCreated( s );
1962
1963   updateWindows();
1964   updateViewManagers();
1965 }
1966
1967 /*!Gets file filter.
1968  *\retval QString "(*.hdf)"
1969  */
1970 QString LightApp_Application::getFileFilter( bool /*open*/) const
1971 {
1972   return "(*.hdf)";
1973 }
1974
1975 /*!
1976   Shows file dialog and return user selected file name
1977 */
1978 QString LightApp_Application::getFileName( bool open, const QString& initial, const QString& filters,
1979                                            const QString& caption, QWidget* parent )
1980 {
1981   if ( !parent )
1982     parent = desktop();
1983   QStringList fls = filters.split( ";;", QString::SkipEmptyParts );
1984   return SUIT_FileDlg::getFileName( parent, initial, fls, caption, open, true );
1985 }
1986
1987 /*! Gets directory*/
1988 QString LightApp_Application::getDirectory( const QString& initial, const QString& caption, QWidget* parent )
1989 {
1990   if ( !parent )
1991     parent = desktop();
1992   return SUIT_FileDlg::getExistingDirectory( parent, initial, caption, true );
1993 }
1994
1995 /*! Get open file names*/
1996 QStringList LightApp_Application::getOpenFileNames( const QString& initial, const QString& filters,
1997                                                     const QString& caption, QWidget* parent )
1998 {
1999   if ( !parent )
2000     parent = desktop();
2001   QStringList fls = filters.split( ";;", QString::SkipEmptyParts );
2002   return SUIT_FileDlg::getOpenFileNames( parent, initial, fls, caption, true );
2003 }
2004
2005 /*!Private SLOT. Update object browser.*/
2006 void LightApp_Application::onRefresh()
2007 {
2008   updateObjectBrowser( true );
2009 }
2010
2011 /*!Private SLOT. Update actions after rename object.*/
2012 void LightApp_Application::onRenamed()
2013 {
2014   activeStudy()->Modified();
2015   updateActions();
2016 }
2017
2018 // IMN 08.07.2015 : issue 002556: Some stereo outputs are affected by window position.
2019 // To prevent reversion the window should be either aligned during movement and resize.
2020 /*!Private SLOT. Update actions after rename object.*/
2021 /*void LightApp_Application::onMoved()
2022 {
2023   OCCViewer_ViewManager* viewMgr = 0;
2024   viewMgr = dynamic_cast<OCCViewer_ViewManager*>( getViewManager( OCCViewer_Viewer::Type(), false ) );
2025   if (viewMgr) {
2026     OCCViewer_ViewWindow* view = 0;
2027     view = dynamic_cast<OCCViewer_ViewWindow*>( viewMgr->getActiveView() );
2028     if (view) {
2029       view->getViewPort()->repaintViewAfterMove();
2030     }
2031   }
2032 }
2033 */
2034 /*!Private SLOT. Support drag-and-drop operation.*/
2035 void LightApp_Application::onDropped( const QList<SUIT_DataObject*>& objects, SUIT_DataObject* parent, int row, Qt::DropAction action )
2036 {
2037   LightApp_DataObject* parentObj = dynamic_cast<LightApp_DataObject*>( parent );
2038   if ( !parentObj )
2039     return;
2040
2041   LightApp_Module* aModule = dynamic_cast<LightApp_Module*>( parentObj->module() );
2042   if ( aModule )
2043     aModule->dropObjects( objects, parentObj, row, action );
2044 }
2045
2046 /*!Private SLOT. On preferences.*/
2047 void LightApp_Application::onPreferences()
2048 {
2049   showPreferences( activeModule() ? activeModule()->moduleName() : tr( "PREF_CATEGORY_SALOME" ) );
2050 }
2051
2052 /*!Private SLOT. On preferences.*/
2053 void LightApp_Application::showPreferences( const QString& itemText )
2054 {
2055   QApplication::setOverrideCursor( Qt::WaitCursor );
2056
2057   LightApp_PreferencesDlg* prefDlg = new LightApp_PreferencesDlg( preferences( true ), desktop());
2058
2059   QApplication::restoreOverrideCursor();
2060
2061   if ( !prefDlg )
2062     return;
2063
2064   preferences()->activateItem( itemText );
2065
2066   if ( ( prefDlg->exec() == QDialog::Accepted || prefDlg->isSaved() ) &&  resourceMgr() )
2067   {
2068     if ( desktop() )
2069       resourceMgr()->setValue( "desktop", "geometry", desktop()->storeGeometry() );
2070     resourceMgr()->save();
2071
2072     // Update shortcuts
2073     shortcutMgr()->updateShortcuts();
2074   }
2075
2076   delete prefDlg;
2077 }
2078
2079 /*!Protected SLOT. On preferences changed.*/
2080 void LightApp_Application::onPreferenceChanged( QString& modName, QString& section, QString& param )
2081 {
2082   LightApp_Module* sMod = 0;
2083   CAM_Module* mod = module( modName );
2084   if ( mod && mod->inherits( "LightApp_Module" ) )
2085     sMod = (LightApp_Module*)mod;
2086
2087   if ( sMod )
2088     sMod->preferencesChanged( section, param );
2089   else
2090     preferencesChanged( section, param );
2091   // emit signal to allow additional preferences changing processing
2092   emit preferenceChanged( modName, section, param );
2093 }
2094
2095 /*!Remove all windows from study.*/
2096 void LightApp_Application::beforeCloseDoc( SUIT_Study* s )
2097 {
2098   saveDockWindowsState();
2099
2100   if ( SUIT_DataBrowser* ob = objectBrowser() )
2101     ob->setModel(0);
2102
2103   CAM_Application::beforeCloseDoc( s );
2104 }
2105
2106 /*!Update actions.*/
2107 void LightApp_Application::updateActions()
2108 {
2109   updateCommandsStatus();
2110 }
2111
2112 /*!
2113   Creates new study
2114 */
2115 SUIT_Study* LightApp_Application::createNewStudy()
2116 {
2117   LightApp_Application::lastStudyId++;
2118
2119   LightApp_Study* aStudy = new LightApp_Study( this );
2120
2121   // Set up processing of major study-related events
2122   connect( aStudy, SIGNAL( created( SUIT_Study* ) ), this, SLOT( onStudyCreated( SUIT_Study* ) ) );
2123   connect( aStudy, SIGNAL( opened ( SUIT_Study* ) ), this, SLOT( onStudyOpened ( SUIT_Study* ) ) );
2124   connect( aStudy, SIGNAL( saved  ( SUIT_Study* ) ), this, SLOT( onStudySaved  ( SUIT_Study* ) ) );
2125   connect( aStudy, SIGNAL( closed ( SUIT_Study* ) ), this, SLOT( onStudyClosed ( SUIT_Study* ) ) );
2126
2127   return aStudy;
2128 }
2129
2130 /*!
2131   Creates window by flag.
2132   \param flag - identificator of window type
2133 */
2134 QWidget* LightApp_Application::createWindow( const int flag )
2135 {
2136   QWidget* wid = 0;
2137
2138   SUIT_ResourceMgr* resMgr = resourceMgr();
2139
2140   if ( flag == WT_ObjectBrowser )
2141   {
2142     SUIT_DataBrowser* ob = new SUIT_DataBrowser( new LightApp_DataObject(), desktop() );
2143     ob->setObjectName( "objectBrowser" );
2144     ob->setSortMenuEnabled( true );
2145     ob->setAutoUpdate( true );
2146     if ( resMgr->hasValue( "ObjectBrowser", "auto_hide_search_tool" ) )
2147       ob->searchTool()->enableAutoHide( resMgr->booleanValue( "ObjectBrowser", "auto_hide_search_tool" ) );
2148
2149     //ob->setAutoOpenLevel( 1 ); // commented by ASV as a fix to bug IPAL10107
2150     ob->setWindowTitle( tr( "OBJECT_BROWSER" ) );
2151     connect( ob, SIGNAL( requestUpdate() ), this, SLOT( onRefresh() ) );
2152
2153     QString EntryCol = QObject::tr( "ENTRY_COLUMN" );
2154     SUIT_AbstractModel* treeModel = dynamic_cast<SUIT_AbstractModel*>( ob->model() );
2155     treeModel->setSearcher( this );
2156     treeModel->registerColumn( 0, EntryCol, LightApp_DataObject::EntryId );
2157     treeModel->setAppropriate( EntryCol, Qtx::Toggled );
2158
2159     // Mantis issue 0020136: Drag&Drop in OB
2160     SUIT_ProxyModel* proxyModel = dynamic_cast<SUIT_ProxyModel*>(treeModel);
2161     if ( proxyModel ) {
2162       connect( proxyModel, SIGNAL( dropped( const QList<SUIT_DataObject*>&, SUIT_DataObject*, int, Qt::DropAction ) ),
2163                this,       SLOT( onDropped( const QList<SUIT_DataObject*>&, SUIT_DataObject*, int, Qt::DropAction ) ) );
2164       connect( proxyModel, SIGNAL( renamed( SUIT_DataObject* ) ),
2165                this,       SLOT( onRenamed( ) ) );
2166
2167     }
2168
2169     // temporary commented
2170     /*
2171     OB_ListView* ob_list = dynamic_cast<OB_ListView*>( const_cast<QListView*>( ob->listView() ) );
2172     if( ob_list )
2173       ob_list->setColumnMaxWidth( 0, desktop()->width()/4 );
2174     */
2175
2176     // Create OBSelector
2177     new LightApp_OBSelector( ob, mySelMgr );
2178 #if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
2179     ob->treeView()->header()->setResizeMode(SUIT_DataObject::VisibilityId, QHeaderView::Fixed);
2180 #else
2181     ob->treeView()->header()->setSectionResizeMode(SUIT_DataObject::VisibilityId, QHeaderView::Fixed);
2182 #endif
2183     ob->treeView()->header()->moveSection(SUIT_DataObject::NameId,SUIT_DataObject::VisibilityId);
2184     ob->treeView()->setColumnWidth(SUIT_DataObject::VisibilityId, VISIBILITY_COLUMN_WIDTH);
2185     ob->setProperty( "shortcut", QKeySequence( "Alt+Shift+O" ) );
2186     wid = ob;
2187     ob->connectPopupRequest( this, SLOT( onConnectPopupRequest( SUIT_PopupClient*, QContextMenuEvent* ) ) );
2188   }
2189 #ifndef DISABLE_PYCONSOLE
2190   else  if ( flag == WT_PyConsole )
2191   {
2192     PyConsole_Console* pyCons = new PyConsole_Console( desktop(), new LightApp_PyEditor( getPyInterp() ) );
2193     pyCons->setObjectName( "pythonConsole" );
2194     pyCons->setWindowTitle( tr( "PYTHON_CONSOLE" ) );
2195     pyCons->setFont( resMgr->fontValue( "PyConsole", "font" ) );
2196     pyCons->setIsShowBanner( resMgr->booleanValue( "PyConsole", "show_banner", true ) );
2197     pyCons->setAutoCompletion( resMgr->booleanValue( "PyConsole", "auto_completion", true ) );
2198     pyCons->setProperty( "shortcut", QKeySequence( "Alt+Shift+P" ) );
2199     wid = pyCons;
2200   }
2201 #endif
2202   else if ( flag == WT_LogWindow )
2203   {
2204     LogWindow* logWin = new LogWindow( desktop() );
2205     logWin->setObjectName( "logWindow" );
2206     logWin->setWindowTitle( tr( "LOG_WINDOW" ) );
2207     logWin->setProperty( "shortcut", QKeySequence( "Alt+Shift+L" ) );
2208     wid = logWin;
2209     logWin->connectPopupRequest( this, SLOT( onConnectPopupRequest( SUIT_PopupClient*, QContextMenuEvent* ) ) );
2210   }
2211   return wid;
2212 }
2213
2214 /*!
2215   \return default windows( Object Browser, Python Console )
2216   Adds to map \a aMap.
2217  */
2218 void LightApp_Application::defaultWindows( QMap<int, int>& aMap ) const
2219 {
2220 #ifndef DISABLE_PYCONSOLE
2221   aMap.insert( WT_PyConsole, Qt::BottomDockWidgetArea );
2222 #endif
2223   if ( activeStudy() ) {
2224     aMap.insert( WT_ObjectBrowser, Qt::LeftDockWidgetArea );
2225     //  aMap.insert( WT_LogWindow, Qt::DockBottom );
2226   }
2227 }
2228
2229 /*!Default view managers*/
2230 void LightApp_Application::defaultViewManagers( QStringList& ) const
2231 {
2232   /*!Do nothing.*/
2233 }
2234
2235 /*!
2236   \return preferences.
2237   Create preferences, if \a crt = true.
2238 */
2239 LightApp_Preferences* LightApp_Application::preferences( const bool crt ) const
2240 {
2241   if ( myPrefs )
2242     return myPrefs;
2243
2244   LightApp_Application* that = (LightApp_Application*)this;
2245
2246   bool toCreate = !_prefs_ && crt;
2247   if ( toCreate )
2248   {
2249     _prefs_ = new LightApp_Preferences( resourceMgr() );
2250     that->createPreferences( _prefs_ );
2251     qAddPostRoutine( LightAppCleanUpAppResources );
2252   }
2253
2254   that->myPrefs = _prefs_;
2255
2256   connect( myPrefs, SIGNAL( preferenceChanged( QString&, QString&, QString& ) ),
2257            this, SLOT( onPreferenceChanged( QString&, QString&, QString& ) ), Qt::UniqueConnection );
2258   connect( myPrefs, SIGNAL( resetToDefaults() ),
2259            this, SIGNAL( preferenceResetToDefaults() ), Qt::UniqueConnection );
2260
2261   if ( !crt )
2262     return myPrefs;
2263
2264   SUIT_ResourceMgr* resMgr = resourceMgr();
2265
2266   QList<SUIT_Application*> appList = SUIT_Session::session()->applications();
2267   for ( QList<SUIT_Application*>::iterator appIt = appList.begin(); appIt != appList.end(); ++appIt )
2268   {
2269     LightApp_Application* app = ::qobject_cast<LightApp_Application*>( *appIt );
2270     if ( !app )
2271       continue;
2272
2273     QStringList modNameList;
2274     app->modules( modNameList, false );
2275
2276     QMap<QString, QString> iconMap;
2277     app->moduleIconNames( iconMap );
2278
2279     for ( QStringList::const_iterator it = modNameList.begin(); it != modNameList.end(); ++it )
2280     {
2281       if ( !app->isModuleAccessible( *it ) || _prefs_->hasModule( *it ) )
2282         continue;
2283
2284       int modId = _prefs_->addPreference( *it );
2285       if ( iconMap.contains( *it ) )
2286         _prefs_->setItemIcon( modId, Qtx::scaleIcon( resMgr->loadPixmap( moduleName( *it ), iconMap[*it], false ), 20 ) );
2287     }
2288
2289     ModuleList modList;
2290     app->modules( modList );
2291     QListIterator<CAM_Module*> itr( modList );
2292     while ( itr.hasNext() )
2293     {
2294       LightApp_Module* mod = 0;
2295
2296       CAM_Module* anItem = itr.next();
2297       if ( anItem->inherits( "LightApp_Module" ) )
2298         mod = (LightApp_Module*)anItem;
2299
2300       if ( mod && !_prefs_->hasModule( mod->moduleName() ) )
2301       {
2302         _prefs_->addPreference( mod->moduleName() );
2303         mod->createPreferences();
2304         that->emptyPreferences( mod->moduleName() );
2305       }
2306     }
2307   }
2308   _prefs_->setItemProperty( "info", tr( "PREFERENCES_NOT_LOADED" ) );
2309
2310   return myPrefs;
2311 }
2312
2313 /*!
2314   Adds new module to application
2315 */
2316 void LightApp_Application::moduleAdded( CAM_Module* mod )
2317 {
2318   CAM_Application::moduleAdded( mod );
2319
2320   LightApp_Module* lightMod = 0;
2321   if ( mod && mod->inherits( "LightApp_Module" ) )
2322     lightMod = (LightApp_Module*)mod;
2323
2324   if ( myPrefs && lightMod && !myPrefs->hasModule( lightMod->moduleName() ))
2325   {
2326     myPrefs->addPreference( mod->moduleName() );
2327     lightMod->createPreferences();
2328     emptyPreferences( mod->moduleName() );
2329   }
2330 }
2331
2332 void LightApp_Application::emptyPreferences( const QString& modName )
2333 {
2334   QtxPreferenceItem* item = myPrefs->findItem( modName, true );
2335   if ( !item || !item->isEmpty() )
2336     return;
2337
2338   //  printf( "---------------------> Modify for empty module.\n" );
2339
2340   QtxPagePrefFrameItem* frm = new QtxPagePrefFrameItem( item->title(), item->parentItem() );
2341   frm->setIcon( item->icon() );
2342   frm->setStretch( false );
2343   item->parentItem()->insertItem( frm, item );
2344   new QtxPagePrefLabelItem( Qt::AlignCenter, tr( "PREFERENCES_NOT_SUPPORTED" ).arg( modName ), frm );
2345   delete item;
2346 }
2347
2348 /*!
2349   Create preferences
2350 */
2351 void LightApp_Application::createPreferences( LightApp_Preferences* pref )
2352 {
2353   if ( !pref )
2354     return;
2355
2356   QStringList     aValuesList;
2357   QList<QVariant> anIndicesList;
2358   QIntList        idList;
2359   QIntList        txtList;
2360
2361   // . Top-level "SALOME" preferences group <<start>>
2362   int salomeCat = pref->addPreference( tr( "PREF_CATEGORY_SALOME" ) );
2363   pref->setItemIcon( salomeCat, Qtx::scaleIcon( resourceMgr()->loadPixmap( "LightApp", tr( "APP_DEFAULT_ICO" ), false ), 20 ) );
2364
2365   // .. "General" preferences tab <<start>>
2366   int genTab = pref->addPreference( tr( "PREF_TAB_GENERAL" ), salomeCat );
2367
2368   // ... "Language" group <<start>>
2369   int langGroup = pref->addPreference( tr( "PREF_GROUP_LANGUAGE" ), genTab );
2370   pref->setItemProperty( "columns", 2, langGroup );
2371   // .... -> application language
2372   int curLang = pref->addPreference( tr( "PREF_CURRENT_LANGUAGE" ), langGroup,
2373                                           LightApp_Preferences::Selector, "language", "language" );
2374   QStringList aLangs = SUIT_Session::session()->resourceMgr()->stringValue( "language", "languages", "en" ).split( "," );
2375   QList<QVariant> aIcons;
2376   QList<QVariant> aNumbers;
2377   QStringList aTitles;
2378   foreach ( QString aLang, aLangs ) {
2379     aIcons << QPixmap( QString( ":/images/%1" ).arg( aLang ) );
2380     aNumbers << aLang;
2381     aTitles << langToName( aLang );
2382   }
2383   pref->setItemProperty( "strings", aTitles, curLang );
2384   pref->setItemProperty( "ids",     aNumbers, curLang );
2385   pref->setItemProperty( "icons",   aIcons, curLang );
2386   pref->setItemProperty( "restart",  true, curLang );
2387
2388   int curLocale = pref->addPreference( tr( "PREF_CURRENT_LOCALE" ), langGroup,
2389                                           LightApp_Preferences::Bool, "language", "locale" );
2390   pref->setItemProperty( "restart",  true, curLocale );
2391   // ... "Language" group <<end>>
2392
2393   // ... "Look and feel" group <<start>>
2394   int lookGroup = pref->addPreference( tr( "PREF_GROUP_LOOK_AND_FEEL" ), genTab );
2395   pref->setItemProperty( "columns", 2, lookGroup );
2396   // .... -> show splash-screen
2397   pref->addPreference( tr( "PREF_SHOW_SPLASH" ), lookGroup, LightApp_Preferences::Bool, "launch", "splash" );
2398   // .... -> opaque resize
2399   pref->addPreference( tr( "PREF_OPAQUE_RESIZE" ), lookGroup, LightApp_Preferences::Bool, "desktop", "opaque_resize" );
2400   // .... -> drop-down buttons
2401   pref->addPreference( tr( "PREF_DROP_DOWN_BUTTONS" ), lookGroup, LightApp_Preferences::Bool, "viewers", "drop_down_buttons" );
2402   // ... "Look and feel" group <<end>>
2403
2404   // ... "Study properties" group <<start>>
2405   int studyGroup = pref->addPreference( tr( "PREF_GROUP_STUDY" ), genTab );
2406   pref->setItemProperty( "columns", 2, studyGroup );
2407   // .... -> multi-file save
2408   pref->addPreference( tr( "PREF_MULTI_FILE" ), studyGroup, LightApp_Preferences::Bool, "Study", "multi_file" );
2409   // .... -> ascii save mode
2410   pref->addPreference( tr( "PREF_ASCII_FILE" ), studyGroup, LightApp_Preferences::Bool, "Study", "ascii_file" );
2411   // .... -> store windows geometry
2412   pref->addPreference( tr( "PREF_LOAD_LIGHT" ), studyGroup, LightApp_Preferences::Bool, "Study", "autoload_light_modules" );
2413   pref->addPreference( tr( "PREF_STORE_POS" ),  studyGroup, LightApp_Preferences::Bool, "Study", "store_positions" );
2414   pref->addPreference( "", studyGroup, LightApp_Preferences::Space );
2415   pref->addPreference( tr( "PREF_STORE_TOOL_POS" ),  studyGroup, LightApp_Preferences::Bool, "Study", "store_tool_positions" );
2416   // .... -> auto-save
2417   int autoSaveInterval = pref->addPreference( tr( "PREF_AUTO_SAVE" ),  studyGroup,
2418                                               LightApp_Preferences::IntSpin, "Study", "auto_save_interval" );
2419   pref->setItemProperty( "min",        0, autoSaveInterval );
2420   pref->setItemProperty( "max",     1440, autoSaveInterval );
2421   pref->setItemProperty( "special", tr( "PREF_AUTO_SAVE_DISABLED" ), autoSaveInterval );
2422   // ... "Study properties" group <<end>>
2423
2424   // ... "Help browser" group <<start>>
2425 #ifndef DISABLE_QTXWEBBROWSER
2426   int extgroup = pref->addPreference( tr( "PREF_GROUP_EXT_BROWSER" ), genTab, LightApp_Preferences::Auto, "ExternalBrowser", "use_external_browser");
2427 #else
2428   int extgroup = pref->addPreference( tr( "PREF_GROUP_EXT_BROWSER" ), genTab );
2429 #endif
2430
2431 #ifdef WIN32
2432   QString platform = "winapplication";
2433 #else
2434   QString platform = "application";
2435 #endif
2436   // .... -> browser application
2437   int apppref = pref->addPreference( tr( "PREF_APP" ), extgroup, LightApp_Preferences::File, "ExternalBrowser", platform );
2438   pref->setItemProperty( "mode", Qtx::PT_OpenFile, apppref );
2439   // .... -> browser parameters
2440   pref->addPreference( tr( "PREF_PARAM" ), extgroup, LightApp_Preferences::String, "ExternalBrowser", "parameters" );
2441   // ... "Help browser" group <<end>>
2442
2443   // ... "Python console properties" group <<start>>
2444   int pythonConsoleGroup = pref->addPreference( tr( "PREF_GROUP_PY_CONSOLE" ), genTab );
2445   pref->setItemProperty( "columns", 2, pythonConsoleGroup );
2446   // .... -> font
2447   pref->addPreference( tr( "PREF_FONT" ), pythonConsoleGroup, LightApp_Preferences::Font, "PyConsole", "font" );
2448   // .... -> show banner
2449   pref->addPreference( tr( "PREF_SHOW_BANNER" ), pythonConsoleGroup, LightApp_Preferences::Bool, "PyConsole", "show_banner" );
2450   // .... -> auto-completion
2451   pref->addPreference( tr( "PREF_AUTO_COMPLETION" ), pythonConsoleGroup, LightApp_Preferences::Bool, "PyConsole", "auto_completion" );
2452   // ... "Python console properties" group <<end>>
2453
2454   // ... "MRU" preferences group <<start>>
2455   int mruGroup = pref->addPreference( tr( "PREF_GROUP_MRU" ), genTab, LightApp_Preferences::Auto, "MRU", "show_mru" );
2456   pref->setItemProperty( "columns", 4, mruGroup );
2457   // number of MRU items
2458   int mruVisCount = pref->addPreference( tr( "PREF_MRU_VISIBLE_COUNT" ), mruGroup, LightApp_Preferences::IntSpin,
2459                                          "MRU", "visible_count" );
2460   pref->setItemProperty( "min", 0,   mruVisCount );
2461   pref->setItemProperty( "max", 100, mruVisCount );
2462   // MRU links type
2463   int mruLinkType = pref->addPreference( tr( "PREF_MRU_LINK_TYPE" ), mruGroup, LightApp_Preferences::Selector,
2464                                          "MRU", "link_type" );
2465   aValuesList.clear();
2466   anIndicesList.clear();
2467   aValuesList   << tr("PREF_MRU_LINK_AUTO") << tr("PREF_MRU_LINK_SHORT") << tr("PREF_MRU_LINK_FULL");
2468   anIndicesList << 0                        << 1                         << 2                       ;
2469   pref->setItemProperty( "strings", aValuesList,   mruLinkType );
2470   pref->setItemProperty( "indexes", anIndicesList, mruLinkType );
2471   // ... "MRU" preferences group <<end>>
2472
2473   // ... "Full-screen" group <<start>>
2474   int fullScreenGroup = pref->addPreference( tr( "PREF_GROUP_FULL_SCREEN" ), genTab );
2475   pref->setItemProperty( "columns", 2, fullScreenGroup );
2476   // .... -> automatic hiding toolbars
2477   pref->addPreference( tr( "PREF_FULL_SCREEN_AUTO" ), fullScreenGroup,
2478                        LightApp_Preferences::Bool, "OCCViewer", "automatic_hiding" );
2479   // ... "Full-screen" group <<end>>
2480
2481   // .. "General" preferences tab <<end>>
2482
2483   // .. "3D viewer" group <<start>>
2484   int Viewer3DGroup = pref->addPreference( tr( "PREF_GROUP_3DVIEWER" ), salomeCat );
2485   // ... -> navigation mode
2486   int vtkStyleMode = pref->addPreference( tr( "PREF_NAVIGATION" ), Viewer3DGroup,
2487                                           LightApp_Preferences::Selector, "3DViewer", "navigation_mode" );
2488   aValuesList.clear();
2489   anIndicesList.clear();
2490   aValuesList   << tr("PREF_STANDARD_STYLE") << tr("PREF_KEYFREE_STYLE");
2491   anIndicesList << 0                         << 1;
2492   pref->setItemProperty( "strings", aValuesList,   vtkStyleMode );
2493   pref->setItemProperty( "indexes", anIndicesList, vtkStyleMode );
2494   // ... -> zooming mode
2495   int occZoomingStyleMode = pref->addPreference( tr( "PREF_ZOOMING" ), Viewer3DGroup,
2496                                                  LightApp_Preferences::Selector, "3DViewer", "zooming_mode" );
2497   aValuesList.clear();
2498   anIndicesList.clear();
2499   aValuesList   << tr("PREF_ZOOMING_AT_CENTER") << tr("PREF_ZOOMING_AT_CURSOR");
2500   anIndicesList << 0                            << 1;
2501   pref->setItemProperty( "strings", aValuesList,   occZoomingStyleMode );
2502   pref->setItemProperty( "indexes", anIndicesList, occZoomingStyleMode );
2503   // ... "Trihedron" group <<start>>
2504   int occTriGroup = pref->addPreference( tr( "PREF_TRIHEDRON" ), Viewer3DGroup );
2505   pref->setItemProperty( "columns", 2, occTriGroup );
2506   // .... -> trihedron size
2507   int occTS = pref->addPreference( tr( "PREF_TRIHEDRON_SIZE" ), occTriGroup,
2508                                    LightApp_Preferences::DblSpin, "3DViewer", "trihedron_size" );
2509   pref->setItemProperty( "min", 1.0E-06, occTS );
2510   pref->setItemProperty( "max", 1000, occTS );
2511   // .... -> relative size of trihedron
2512   pref->addPreference( tr( "PREF_RELATIVE_SIZE" ), occTriGroup, LightApp_Preferences::Bool, "3DViewer", "relative_size" );
2513   // .... -> show static trihedron
2514   pref->addPreference( tr( "PREF_SHOW_STATIC_TRIHEDRON" ), occTriGroup, LightApp_Preferences::Bool, "3DViewer", "show_static_trihedron" );
2515   // ... "Trihedron" group <<end>>
2516   // .. "3D viewer" group <<end>>
2517
2518   QString formats;
2519   int bgId;
2520 #ifndef DISABLE_OCCVIEWER
2521   // .. "OCC viewer" group <<start>>
2522   int occGroup = pref->addPreference( tr( "PREF_GROUP_OCCVIEWER" ), salomeCat );
2523
2524   // .... -> Projection mode
2525   int occProjMode = pref->addPreference( tr( "PREF_PROJECTION_MODE" ), occGroup,
2526                                          LightApp_Preferences::Selector, "OCCViewer", "projection_mode" );
2527   aValuesList.clear();
2528   anIndicesList.clear();
2529   aValuesList   << tr("PREF_ORTHOGRAPHIC") << tr("PREF_PERSPECTIVE");
2530   anIndicesList << 0                       << 1;
2531   pref->setItemProperty( "strings", aValuesList,   occProjMode );
2532   pref->setItemProperty( "indexes", anIndicesList, occProjMode );
2533
2534   // .... -> Stereo group
2535   int stereoGroup = pref->addPreference( tr( "PREF_GROUP_STEREO" ), occGroup);
2536   pref->setItemProperty( "columns", 2, stereoGroup );
2537   // .... -> Stereo type
2538   int stereoType = pref->addPreference( tr( "PREF_STEREO_TYPE" ), stereoGroup,
2539                                             LightApp_Preferences::Selector, "OCCViewer", "stereo_type" );
2540   aValuesList.clear();
2541   anIndicesList.clear();
2542   idList.clear();
2543   OCCViewer_Viewer::stereoData( aValuesList, idList);
2544   foreach( int gid, idList ) anIndicesList << gid;
2545   pref->setItemProperty( "strings", aValuesList,   stereoType );
2546   pref->setItemProperty( "indexes", anIndicesList, stereoType );
2547
2548   // .... -> Anaglyph filter
2549   int anaglyphFilter = pref->addPreference( tr( "PREF_ANAGLYPH_FILTER" ), stereoGroup,
2550                                             LightApp_Preferences::Selector, "OCCViewer", "anaglyph_filter" );
2551   aValuesList.clear();
2552   anIndicesList.clear();
2553   aValuesList   << tr("PREF_ANAGLYPH_RED_CYAN") << tr("PREF_ANAGLYPH_YELLOW_BLUE") << tr("PREF_ANAGLYPH_GREEN_MAGENTA");
2554   anIndicesList << 0                            << 1                               << 2;
2555
2556   pref->setItemProperty( "strings", aValuesList,   anaglyphFilter );
2557   pref->setItemProperty( "indexes", anIndicesList, anaglyphFilter );
2558
2559   // .... -> Convergence distance type
2560   int occFocusType = pref->addPreference( tr( "PREF_FOCUS_TYPE" ), stereoGroup,
2561                                            LightApp_Preferences::Selector, "OCCViewer", "focus_type" );
2562   aValuesList.clear();
2563   anIndicesList.clear();
2564   aValuesList   << tr("PREF_ABSOLUTE") << tr("PREF_RELATIVE");
2565   anIndicesList << 0                   << 1;
2566   pref->setItemProperty( "strings", aValuesList,   occFocusType );
2567   pref->setItemProperty( "indexes", anIndicesList, occFocusType );
2568
2569   // .... -> Stereographic focus value
2570   int focusValue = pref->addPreference( tr( "PREF_FOCUS_VALUE" ), stereoGroup,
2571                LightApp_Preferences::DblSpin, "OCCViewer", "focus_value" );
2572   pref->setItemProperty( "precision", 3, focusValue );
2573   pref->setItemProperty( "min", 1.0E-03, focusValue );
2574   pref->setItemProperty( "max", 1.0E03, focusValue );
2575   pref->setItemProperty( "step", 0.05, focusValue );
2576
2577   // .... -> IOD type
2578   int occIODType = pref->addPreference( tr( "PREF_IOD_TYPE" ), stereoGroup,
2579                                            LightApp_Preferences::Selector, "OCCViewer", "iod_type" );
2580   aValuesList.clear();
2581   anIndicesList.clear();
2582   aValuesList   << tr("PREF_ABSOLUTE") << tr("PREF_RELATIVE");
2583   anIndicesList << 0                   << 1;
2584   pref->setItemProperty( "strings", aValuesList,   occIODType );
2585   pref->setItemProperty( "indexes", anIndicesList, occIODType );
2586
2587   // .... -> Interocular distance (IOD) value
2588   int IODValue = pref->addPreference( tr( "PREF_IOD_VALUE" ), stereoGroup,
2589                                       LightApp_Preferences::DblSpin, "OCCViewer", "iod_value" );
2590   pref->setItemProperty( "precision", 3, IODValue );
2591   pref->setItemProperty( "min", 1.0E-03, IODValue );
2592   pref->setItemProperty( "max", 1.0E03, IODValue );
2593   pref->setItemProperty( "step", 0.05, IODValue );
2594
2595   // .... -> Reverse stereo
2596   pref->addPreference( tr( "PREF_REVERSE_STEREO" ), stereoGroup,
2597                        LightApp_Preferences::Bool, "OCCViewer", "reverse_stereo" );
2598   // .... -> Enable V-Sync
2599   pref->addPreference( tr( "PREF_ENABLE_VSYNC" ), stereoGroup,
2600                        LightApp_Preferences::Bool, "OCCViewer", "enable_vsync" );
2601   // .... -> Enable quad-buffer support
2602   pref->addPreference( tr( "PREF_ENABLE_QUAD_BUFFER_SUPPORT" ), stereoGroup,
2603                        LightApp_Preferences::Bool, "OCCViewer", "enable_quad_buffer_support" );
2604
2605   // ... "Background" group <<start>>
2606   int bgGroup = pref->addPreference( tr( "PREF_VIEWER_BACKGROUND" ), occGroup );
2607   //  pref->setItemProperty( "columns", 2, bgGroup );
2608   aValuesList.clear();
2609   anIndicesList.clear();
2610   txtList.clear();
2611   idList.clear();
2612   formats = OCCViewer_Viewer::backgroundData( aValuesList, idList, txtList );
2613   foreach( int gid, idList ) anIndicesList << gid;
2614   // .... -> 3D viewer background
2615   bgId = pref->addPreference( tr( "PREF_3DVIEWER_BACKGROUND" ), bgGroup,
2616                                   LightApp_Preferences::Background, "OCCViewer", "background" );
2617   pref->setItemProperty( "gradient_names", aValuesList, bgId );
2618   pref->setItemProperty( "gradient_ids", anIndicesList, bgId );
2619   pref->setItemProperty( "texture_enabled", !txtList.isEmpty(), bgId );
2620   pref->setItemProperty( "texture_center_enabled", (bool)txtList.contains( Qtx::CenterTexture ), bgId );
2621   pref->setItemProperty( "texture_tile_enabled", (bool)txtList.contains( Qtx::TileTexture ), bgId );
2622   pref->setItemProperty( "texture_stretch_enabled", (bool)txtList.contains( Qtx::StretchTexture ), bgId );
2623   pref->setItemProperty( "custom_enabled", false, bgId );
2624   pref->setItemProperty( "image_formats", formats, bgId );
2625   // .... -> XZ viewer background
2626   bgId = pref->addPreference( tr( "PREF_XZVIEWER_BACKGROUND" ), bgGroup,
2627                               LightApp_Preferences::Background, "OCCViewer", "xz_background" );
2628   pref->setItemProperty( "gradient_names", aValuesList, bgId );
2629   pref->setItemProperty( "gradient_ids", anIndicesList, bgId );
2630   pref->setItemProperty( "texture_enabled", !txtList.isEmpty(), bgId );
2631   pref->setItemProperty( "texture_center_enabled", (bool)txtList.contains( Qtx::CenterTexture ), bgId );
2632   pref->setItemProperty( "texture_tile_enabled", (bool)txtList.contains( Qtx::TileTexture ), bgId );
2633   pref->setItemProperty( "texture_stretch_enabled", (bool)txtList.contains( Qtx::StretchTexture ), bgId );
2634   pref->setItemProperty( "custom_enabled", false, bgId );
2635   pref->setItemProperty( "image_formats", formats, bgId );
2636   // .... -> YZ viewer background
2637   bgId = pref->addPreference( tr( "PREF_YZVIEWER_BACKGROUND" ), bgGroup,
2638                               LightApp_Preferences::Background, "OCCViewer", "yz_background" );
2639   pref->setItemProperty( "gradient_names", aValuesList, bgId );
2640   pref->setItemProperty( "gradient_ids", anIndicesList, bgId );
2641   pref->setItemProperty( "texture_enabled", !txtList.isEmpty(), bgId );
2642   pref->setItemProperty( "texture_center_enabled", (bool)txtList.contains( Qtx::CenterTexture ), bgId );
2643   pref->setItemProperty( "texture_tile_enabled", (bool)txtList.contains( Qtx::TileTexture ), bgId );
2644   pref->setItemProperty( "texture_stretch_enabled", (bool)txtList.contains( Qtx::StretchTexture ), bgId );
2645   pref->setItemProperty( "custom_enabled", false, bgId );
2646   pref->setItemProperty( "image_formats", formats, bgId );
2647   // .... -> XY viewer background
2648   bgId = pref->addPreference( tr( "PREF_XYVIEWER_BACKGROUND" ), bgGroup,
2649                               LightApp_Preferences::Background, "OCCViewer", "xy_background" );
2650   pref->setItemProperty( "gradient_names", aValuesList, bgId );
2651   pref->setItemProperty( "gradient_ids", anIndicesList, bgId );
2652   pref->setItemProperty( "texture_enabled", !txtList.isEmpty(), bgId );
2653   pref->setItemProperty( "texture_center_enabled", (bool)txtList.contains( Qtx::CenterTexture ), bgId );
2654   pref->setItemProperty( "texture_tile_enabled", (bool)txtList.contains( Qtx::TileTexture ), bgId );
2655   pref->setItemProperty( "texture_stretch_enabled", (bool)txtList.contains( Qtx::StretchTexture ), bgId );
2656   pref->setItemProperty( "custom_enabled", false, bgId );
2657   pref->setItemProperty( "image_formats", formats, bgId );
2658   // ... "Background" group <<end>>
2659
2660
2661   // ... "Selection" group <<start>>
2662   int occSelectionGroup = pref->addPreference( tr( "PREF_GROUP_SELECTION" ), occGroup );
2663   pref->setItemProperty( "columns", 2, occSelectionGroup );
2664   // .... -> enable preselection
2665   pref->addPreference( tr( "PREF_ENABLE_PRESELECTION" ), occSelectionGroup,
2666                        LightApp_Preferences::Bool, "OCCViewer", "enable_preselection" );
2667   // .... -> enable selection
2668   pref->addPreference( tr( "PREF_ENABLE_SELECTION" ), occSelectionGroup,
2669                        LightApp_Preferences::Bool, "OCCViewer", "enable_selection" );
2670   // ... "Selection" group <<end>>
2671
2672   // ... "Clipping" group <<start>>
2673   int occClippingGroup = pref->addPreference( tr( "PREF_GROUP_CLIPPING" ), occGroup );
2674   // .... -> clipping color
2675   pref->addPreference( tr( "PREF_CLIPPING_COLOR" ), occClippingGroup,
2676                        LightApp_Preferences::Color, "OCCViewer", "clipping_color" );
2677   int texturePref = pref->addPreference( "", occClippingGroup, LightApp_Preferences::Frame );
2678   pref->setItemProperty( "columns", 2, texturePref );
2679   // .... -> use default texture
2680   pref->addPreference( tr( "PREF_CLIPPING_DEFAULT_TEXTURE" ), texturePref,
2681                LightApp_Preferences::Bool, "OCCViewer", "clipping_use_default_texture" );
2682   // .... -> clipping texture
2683   int filePref = pref->addPreference( tr( "PREF_CLIPPING_TEXTURE" ), texturePref,
2684                LightApp_Preferences::File, "OCCViewer", "clipping_texture" );
2685   pref->setItemProperty( "path_filter", tr( "OCC_TEXTURE_FILES" ), filePref );
2686   // .... -> modulate
2687   pref->addPreference( tr( "PREF_CLIPPING_MODULATE" ), texturePref,
2688                LightApp_Preferences::Bool, "OCCViewer", "clipping_modulate" );
2689   // .... -> scale factor
2690   int scaleFactor = pref->addPreference( tr( "PREF_CLIPPING_SCALE" ), texturePref,
2691                LightApp_Preferences::DblSpin, "OCCViewer", "clipping_scale" );
2692   pref->setItemProperty( "precision", 3, scaleFactor );
2693   pref->setItemProperty( "min", 1.0E-03, scaleFactor );
2694   pref->setItemProperty( "max", 1.0E03, scaleFactor );
2695   pref->setItemProperty( "step", 0.1, scaleFactor );
2696   // ... "Clipping" group <<end>>
2697
2698   // ... "Ray tracing" group <<start>>
2699   int occRayTracingGroup = pref->addPreference( tr( "PREF_GROUP_RAY_TRACING" ), occGroup );
2700   int rtPref = pref->addPreference( "", occRayTracingGroup, LightApp_Preferences::Frame );
2701   pref->setItemProperty( "columns", 2, rtPref );
2702   // .... -> depth
2703   int rt_depth = pref->addPreference( tr( "PREF_RAY_TRACING_DEPTH" ), rtPref,
2704                LightApp_Preferences::IntSpin, "OCCViewer", "rt_depth" );
2705   pref->setItemProperty( "min", 1, rt_depth );
2706   pref->setItemProperty( "max", 10, rt_depth );
2707   pref->setItemProperty( "step", 1, rt_depth );
2708   pref->addPreference( "", rtPref, LightApp_Preferences::Frame );
2709   // .... -> specular reflections
2710   pref->addPreference( tr( "PREF_RAY_TRACING_REFLECTION" ), rtPref,
2711                LightApp_Preferences::Bool, "OCCViewer", "rt_reflection" );
2712   // .... -> adaptive anti-aliasing
2713   pref->addPreference( tr( "PREF_RAY_TRACING_ANTIALIASING" ), rtPref,
2714                LightApp_Preferences::Bool, "OCCViewer", "rt_antialiasing" );
2715   // .... -> shadows rendering
2716   pref->addPreference( tr( "PREF_RAY_TRACING_SHADOW" ), rtPref,
2717                LightApp_Preferences::Bool, "OCCViewer", "rt_shadow" );
2718   // .... -> transparent shadow
2719   pref->addPreference( tr( "PREF_RAY_TRACING_TRANS_SHADOW" ), rtPref,
2720                LightApp_Preferences::Bool, "OCCViewer", "rt_trans_shadow" );
2721   // ... "Ray tracing" group <<end>>
2722
2723   // ... "Light source" group <<start>>
2724   int occLightGroup = pref->addPreference( tr( "PREF_GROUP_LIGHT" ), occGroup );
2725   // .... -> light color
2726   pref->addPreference( tr( "PREF_LIGHT_COLOR" ), occLightGroup,
2727                LightApp_Preferences::Color, "OCCViewer", "light_color" );
2728   int directionPref = pref->addPreference( "", occLightGroup, LightApp_Preferences::Frame );
2729   pref->setItemProperty( "columns", 3, directionPref );
2730   // .... -> light direction (dx component)
2731   int light_dx = pref->addPreference( tr( "Dx" ), directionPref,
2732                LightApp_Preferences::DblSpin, "OCCViewer", "light_dx" );
2733   pref->setItemProperty( "precision", 2, light_dx );
2734   pref->setItemProperty( "min", -1.0E03, light_dx );
2735   pref->setItemProperty( "max", 1.0E03, light_dx );
2736   pref->setItemProperty( "step", 0.1, light_dx );
2737   // .... -> light direction (dy component)
2738   int light_dy = pref->addPreference( tr( "Dy" ), directionPref,
2739                LightApp_Preferences::DblSpin, "OCCViewer", "light_dy" );
2740   pref->setItemProperty( "precision", 2, light_dy );
2741   pref->setItemProperty( "min", -1.0E03, light_dy );
2742   pref->setItemProperty( "max", 1.0E03, light_dy );
2743   pref->setItemProperty( "step", 0.1, light_dy );
2744   // .... -> light direction (dz component)
2745   int light_dz = pref->addPreference( tr( "Dz" ), directionPref,
2746                LightApp_Preferences::DblSpin, "OCCViewer", "light_dz" );
2747   pref->setItemProperty( "precision", 2, light_dz );
2748   pref->setItemProperty( "min", -1.0E03, light_dz );
2749   pref->setItemProperty( "max", 1.0E03, light_dz );
2750   pref->setItemProperty( "step", 0.1, light_dz );
2751   // ... "Light source" group <<end>>
2752
2753   // ... -> empty frame (for layout) <<start>>
2754   int occGen = pref->addPreference( "", occGroup, LightApp_Preferences::Frame );
2755   pref->setItemProperty( "margin",  0, occGen );
2756   pref->setItemProperty( "columns", 2, occGen );
2757   // ... -> empty frame (for layout) <<end>>
2758
2759   // .. "OCC viewer" group <<end>>
2760 #endif
2761
2762 #ifndef DISABLE_VTKVIEWER
2763   // .. "VTK viewer" group <<start>>
2764   int vtkGroup = pref->addPreference( tr( "PREF_GROUP_VTKVIEWER" ), salomeCat ); //viewTab
2765
2766   // ... -> empty frame (for layout) <<start>>
2767   int vtkGen = pref->addPreference( "", vtkGroup, LightApp_Preferences::Frame );
2768   //pref->setItemProperty( "columns", 2, vtkGen );
2769   // .... -> projection mode
2770   int vtkProjMode = pref->addPreference( tr( "PREF_PROJECTION_MODE" ), vtkGen,
2771                                          LightApp_Preferences::Selector, "VTKViewer", "projection_mode" );
2772   aValuesList.clear();
2773   anIndicesList.clear();
2774   aValuesList   << tr("PREF_ORTHOGRAPHIC") << tr("PREF_PERSPECTIVE");
2775   anIndicesList << 0                       << 1;
2776   pref->setItemProperty( "strings", aValuesList,   vtkProjMode );
2777   pref->setItemProperty( "indexes", anIndicesList, vtkProjMode );
2778
2779   // .... -> Stereo group
2780   int vtkStereoGroup = pref->addPreference( tr( "PREF_GROUP_STEREO" ), vtkGroup);
2781   pref->setItemProperty( "columns", 2, vtkStereoGroup );
2782   // .... -> Stereo type
2783   int vtkStereoType = pref->addPreference( tr( "PREF_STEREO_TYPE" ), vtkStereoGroup,
2784                                            LightApp_Preferences::Selector, "VTKViewer", "stereo_type" );
2785   aValuesList.clear();
2786   anIndicesList.clear();
2787   idList.clear();
2788   SVTK_Viewer::stereoData( aValuesList, idList);
2789   foreach( int gid, idList ) anIndicesList << gid;
2790   pref->setItemProperty( "strings", aValuesList,   vtkStereoType );
2791   pref->setItemProperty( "indexes", anIndicesList, vtkStereoType );
2792   // .... -> Anaglyph filter
2793   int vtkAnaglyphFilter = pref->addPreference( tr( "PREF_ANAGLYPH_FILTER" ), vtkStereoGroup,
2794                                                LightApp_Preferences::Selector, "VTKViewer", "anaglyph_filter" );
2795   aValuesList.clear();
2796   anIndicesList.clear();
2797   aValuesList   << tr("PREF_ANAGLYPH_RED_CYAN") << tr("PREF_ANAGLYPH_YELLOW_BLUE") << tr("PREF_ANAGLYPH_GREEN_MAGENTA");
2798   anIndicesList << 0                            << 1                               << 2;
2799
2800   pref->setItemProperty( "strings", aValuesList,   vtkAnaglyphFilter );
2801   pref->setItemProperty( "indexes", anIndicesList, vtkAnaglyphFilter );
2802
2803   // .... -> Enable quad-buffer support
2804   pref->addPreference( tr( "PREF_ENABLE_QUAD_BUFFER_SUPPORT" ), vtkStereoGroup,
2805                        LightApp_Preferences::Bool, "VTKViewer", "enable_quad_buffer_support" );
2806
2807   // .... -> background
2808   aValuesList.clear();
2809   anIndicesList.clear();
2810   txtList.clear();
2811   idList.clear();
2812 #ifndef DISABLE_SALOMEOBJECT
2813   formats = SVTK_Viewer::backgroundData( aValuesList, idList, txtList );
2814 #endif
2815   foreach( int gid, idList ) anIndicesList << gid;
2816   bgId = pref->addPreference( tr( "PREF_VIEWER_BACKGROUND" ), vtkGen,
2817                               LightApp_Preferences::Background, "VTKViewer", "background" );
2818   pref->setItemProperty( "gradient_names", aValuesList, bgId );
2819   pref->setItemProperty( "gradient_ids", anIndicesList, bgId );
2820   pref->setItemProperty( "texture_enabled", !txtList.isEmpty(), bgId );
2821   pref->setItemProperty( "texture_center_enabled", (bool)txtList.contains( Qtx::CenterTexture ), bgId );
2822   pref->setItemProperty( "texture_tile_enabled", (bool)txtList.contains( Qtx::TileTexture ), bgId );
2823   pref->setItemProperty( "texture_stretch_enabled", (bool)txtList.contains( Qtx::StretchTexture ), bgId );
2824   pref->setItemProperty( "custom_enabled", false, bgId );
2825 #ifndef DISABLE_SALOMEOBJECT
2826   pref->setItemProperty( "image_formats", formats, bgId );
2827 #endif
2828   // .... -> speed increment
2829   int vtkSpeed = pref->addPreference( tr( "PREF_INCREMENTAL_SPEED" ), vtkGen,
2830                                       LightApp_Preferences::IntSpin, "VTKViewer", "speed_value" );
2831   pref->setItemProperty( "min", 1, vtkSpeed );
2832   pref->setItemProperty( "max", 1000, vtkSpeed );
2833   // .... -> speed mode
2834   int vtkSpeedMode = pref->addPreference( tr( "PREF_INCREMENTAL_SPEED_MODE" ), vtkGen,
2835                                           LightApp_Preferences::Selector, "VTKViewer", "speed_mode" );
2836   aValuesList.clear();
2837   anIndicesList.clear();
2838   aValuesList   << tr("PREF_ARITHMETIC") << tr("PREF_GEOMETRICAL");
2839   anIndicesList << 0                     << 1;
2840   pref->setItemProperty( "strings", aValuesList,   vtkSpeedMode );
2841   pref->setItemProperty( "indexes", anIndicesList, vtkSpeedMode );
2842
2843   // ... "Selection" group <<start>>
2844   int vtkSelectionGroup = pref->addPreference( tr( "PREF_GROUP_SELECTION" ), vtkGroup );
2845   pref->setItemProperty( "columns", 2, vtkSelectionGroup );
2846   // .... -> preselection
2847   int vtkPreselection = pref->addPreference( tr( "PREF_PRESELECTION" ),  vtkSelectionGroup,
2848                                              LightApp_Preferences::Selector, "VTKViewer", "preselection" );
2849   aValuesList.clear();
2850   anIndicesList.clear();
2851   aValuesList   << tr("PREF_PRESELECTION_STANDARD") << tr("PREF_PRESELECTION_DYNAMIC") << tr("PREF_PRESELECTION_DISABLED");
2852   anIndicesList << 0 << 1 << 2;
2853   pref->setItemProperty( "strings", aValuesList,   vtkPreselection );
2854   pref->setItemProperty( "indexes", anIndicesList, vtkPreselection );
2855   // .... -> enable selection
2856   pref->addPreference( tr( "PREF_ENABLE_SELECTION" ), vtkSelectionGroup, LightApp_Preferences::Bool, "VTKViewer", "enable_selection" );
2857   // ... "Selection" group <<end>>
2858
2859   // ... -> empty frame (for layout) <<end>>
2860
2861   // ... space mouse sub-group <<start>>
2862   int vtkSM = pref->addPreference( tr( "PREF_FRAME_SPACEMOUSE" ), vtkGroup, LightApp_Preferences::GroupBox );
2863   //pref->setItemProperty( "columns", 2, vtkSM );
2864   // .... -> decrease speed increment
2865   int spacemousePref1 = pref->addPreference( tr( "PREF_SPACEMOUSE_FUNC_1" ), vtkSM,
2866                                              LightApp_Preferences::Selector, "VTKViewer",
2867                                              "spacemouse_func1_btn" );
2868   // .... -> increase speed increment
2869   int spacemousePref2 = pref->addPreference( tr( "PREF_SPACEMOUSE_FUNC_2" ), vtkSM,
2870                                              LightApp_Preferences::Selector, "VTKViewer",
2871                                              "spacemouse_func2_btn" );
2872   // .... -> dominant / combined switch
2873   int spacemousePref3 = pref->addPreference( tr( "PREF_SPACEMOUSE_FUNC_3" ), vtkSM,
2874                                              LightApp_Preferences::Selector, "VTKViewer",
2875                                              "spacemouse_func5_btn" ); //
2876   aValuesList.clear();
2877   anIndicesList.clear();
2878   aValuesList << tr( "PREF_SPACEMOUSE_BTN_1" )  << tr( "PREF_SPACEMOUSE_BTN_2" ) << tr( "PREF_SPACEMOUSE_BTN_3" );
2879   aValuesList << tr( "PREF_SPACEMOUSE_BTN_4" )  << tr( "PREF_SPACEMOUSE_BTN_5" ) << tr( "PREF_SPACEMOUSE_BTN_6" );
2880   aValuesList << tr( "PREF_SPACEMOUSE_BTN_7" )  << tr( "PREF_SPACEMOUSE_BTN_8" ) << tr( "PREF_SPACEMOUSE_BTN_*" );
2881   aValuesList << tr( "PREF_SPACEMOUSE_BTN_10" ) << tr( "PREF_SPACEMOUSE_BTN_11" );
2882   anIndicesList << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11;
2883   pref->setItemProperty( "strings", aValuesList,   spacemousePref1 );
2884   pref->setItemProperty( "indexes", anIndicesList, spacemousePref1 );
2885   pref->setItemProperty( "strings", aValuesList,   spacemousePref2 );
2886   pref->setItemProperty( "indexes", anIndicesList, spacemousePref2 );
2887   pref->setItemProperty( "strings", aValuesList,   spacemousePref3 );
2888   pref->setItemProperty( "indexes", anIndicesList, spacemousePref3 );
2889   // ... space mouse sub-group <<end>>
2890
2891   // ... avi recording sub-group <<start>>
2892   int vtkRec = pref->addPreference( tr( "PREF_FRAME_RECORDING" ), vtkGroup, LightApp_Preferences::GroupBox );
2893   pref->setItemProperty( "columns", 2, vtkRec );
2894   // .... -> recording mode
2895   int modePref = pref->addPreference( tr( "PREF_RECORDING_MODE" ), vtkRec,
2896                                       LightApp_Preferences::Selector, "VTKViewer", "recorder_mode" );
2897   aValuesList.clear();
2898   anIndicesList.clear();
2899   aValuesList   << tr( "PREF_SKIPPED_FRAMES" ) << tr( "PREF_ALL_DISLPAYED_FRAMES" );
2900   anIndicesList << 0                           << 1;
2901   pref->setItemProperty( "strings", aValuesList,   modePref );
2902   pref->setItemProperty( "indexes", anIndicesList, modePref );
2903   // .... -> fps
2904   int fpsPref = pref->addPreference( tr( "PREF_FPS" ), vtkRec,
2905                                      LightApp_Preferences::DblSpin, "VTKViewer", "recorder_fps" );
2906   pref->setItemProperty( "min", 0.1, fpsPref );
2907   pref->setItemProperty( "max", 100, fpsPref );
2908   // .... -> quality
2909   int qualityPref = pref->addPreference( tr( "PREF_QUALITY" ), vtkRec,
2910                                          LightApp_Preferences::IntSpin, "VTKViewer", "recorder_quality" );
2911   pref->setItemProperty( "min", 1, qualityPref );
2912   pref->setItemProperty( "max", 100, qualityPref );
2913   // .... -> progressive mode
2914   pref->addPreference( tr( "PREF_PROGRESSIVE" ), vtkRec,
2915                        LightApp_Preferences::Bool, "VTKViewer", "recorder_progressive" );
2916   // ... avi recording sub-group <<end>>
2917
2918   // ... group names sub-group <<start>>
2919   int vtkGN = pref->addPreference( tr( "PREF_FRAME_GROUP_NAMES" ), vtkGroup,
2920                                    LightApp_Preferences::GroupBox, "VTKViewer", "show_group_names" );
2921   pref->setItemProperty( "columns", 2, vtkGN );
2922   // .... -> text color
2923   pref->addPreference( tr(  "PREF_GROUP_NAMES_TEXT_COLOR" ), vtkGN,
2924                        LightApp_Preferences::Color, "VTKViewer", "group_names_text_color" );
2925   // .... -> transparency
2926   int transPref = pref->addPreference( tr( "PREF_GROUP_NAMES_TRANSPARENCY" ), vtkGN,
2927                                        LightApp_Preferences::DblSpin, "VTKViewer", "group_names_transparency" );
2928   pref->setItemProperty( "min", 0.0, transPref );
2929   pref->setItemProperty( "max", 1.0, transPref );
2930   pref->setItemProperty( "step", 0.1, transPref );
2931   // ... -> group names sub-group <<end>>
2932   // .. "VTK viewer" group <<end>>
2933 #endif
2934
2935   // .. "Plot2d viewer" group <<start>>
2936   int plot2dGroup = pref->addPreference( tr( "PREF_GROUP_PLOT2DVIEWER" ), salomeCat ); //viewTab
2937   //pref->setItemProperty( "columns", 2, plot2dGroup );
2938
2939   // ... -> background
2940   pref->addPreference( tr( "PREF_VIEWER_BACKGROUND_COLOR" ), plot2dGroup,
2941                        LightApp_Preferences::Color, "Plot2d", "Background" );
2942   // ... -> selection color
2943   pref->addPreference( tr( "PREF_VIEWER_SELECTION" ), plot2dGroup,
2944                        LightApp_Preferences::Color, "Plot2d", "SelectionColor" );
2945
2946   // ... "Viewer" group <<start>>
2947   int plot2dViewerGroup = pref->addPreference( tr( "PREF_GROUP_VIEWER" ), plot2dGroup );
2948
2949   // .... -> curve type
2950   int curveType = pref->addPreference( tr( "PREF_CURVE_TYPE" ), plot2dViewerGroup,
2951                                        LightApp_Preferences::Selector, "Plot2d", "CurveType" );
2952   aValuesList.clear();
2953   anIndicesList.clear();
2954   aValuesList   << tr("PREF_POINTS") << tr("PREF_LINES") << tr("PREF_SPLINE");
2955   anIndicesList << 0                 << 1                << 2                ;
2956   pref->setItemProperty( "strings", aValuesList,   curveType );
2957   pref->setItemProperty( "indexes", anIndicesList, curveType );
2958   // .... -> marker size
2959   int markerSize = pref->addPreference( tr( "PREF_MARKER_SIZE" ), plot2dViewerGroup,
2960                                         LightApp_Preferences::IntSpin, "Plot2d", "MarkerSize" );
2961   pref->setItemProperty( "min", 0, markerSize );
2962   pref->setItemProperty( "max", 100, markerSize );
2963   // .... -> horizontal scaling mode
2964   int horScale = pref->addPreference( tr( "PREF_HOR_AXIS_SCALE" ), plot2dViewerGroup,
2965                                       LightApp_Preferences::Selector, "Plot2d", "HorScaleMode" );
2966   aValuesList.clear();
2967   anIndicesList.clear();
2968   aValuesList   << tr("PREF_LINEAR") << tr("PREF_LOGARITHMIC");
2969   anIndicesList << 0                 << 1                     ;
2970   pref->setItemProperty( "strings", aValuesList,   horScale );
2971   pref->setItemProperty( "indexes", anIndicesList, horScale );
2972   // .... -> vertical scaling mode
2973   int verScale = pref->addPreference( tr( "PREF_VERT_AXIS_SCALE" ), plot2dViewerGroup,
2974                                       LightApp_Preferences::Selector, "Plot2d", "VerScaleMode" );
2975   pref->setItemProperty( "strings", aValuesList,   verScale );
2976   pref->setItemProperty( "indexes", anIndicesList, verScale );
2977
2978   // .... -> errors/deviation colot
2979   pref->addPreference( tr( "PREF_DEVIATION_COLOR" ), plot2dViewerGroup,
2980                        LightApp_Preferences::Color, "Plot2d", "DeviationMarkerColor" );
2981   // .... -> deviation markers line size
2982   int deviationMarkerLw = pref->addPreference( tr( "PREF_DEVIATION_MARKER_LW" ), plot2dViewerGroup,
2983                                         LightApp_Preferences::IntSpin, "Plot2d", "DeviationMarkerLineWidth" );
2984   pref->setItemProperty( "min", 1, deviationMarkerLw );
2985   pref->setItemProperty( "max", 5, deviationMarkerLw );
2986   // .... -> deviation markers tick mark size
2987   int deviationMarkerTs = pref->addPreference( tr( "PREF_DEVIATION_MARKER_TS" ), plot2dViewerGroup,
2988                                         LightApp_Preferences::IntSpin, "Plot2d", "DeviationMarkerTickSize" );
2989   pref->setItemProperty( "min", 1, deviationMarkerTs );
2990   pref->setItemProperty( "max", 5, deviationMarkerTs );
2991   // .... "Viewer" group <<end>>
2992
2993   // ... "Legend" group <<start>>
2994   int plot2dLegendGroup = pref->addPreference( tr( "PREF_GROUP_LEGEND" ), plot2dGroup );
2995
2996   // .... -> show legend
2997   pref->addPreference( tr( "PREF_SHOW_LEGEND" ), plot2dLegendGroup,
2998                        LightApp_Preferences::Bool, "Plot2d", "ShowLegend" );
2999   // .... -> legend position
3000   int legendPosition = pref->addPreference( tr( "PREF_LEGEND_POSITION" ), plot2dLegendGroup,
3001                                             LightApp_Preferences::Selector, "Plot2d", "LegendPos" );
3002   aValuesList.clear();
3003   anIndicesList.clear();
3004   aValuesList   << tr("PREF_LEFT") << tr("PREF_RIGHT") << tr("PREF_TOP") << tr("PREF_BOTTOM");
3005   anIndicesList << 0               << 1                << 2              << 3                ;
3006   pref->setItemProperty( "strings", aValuesList,   legendPosition );
3007   pref->setItemProperty( "indexes", anIndicesList, legendPosition );
3008   // .... -> Symbol type
3009   int legendSymbolType = pref->addPreference( tr( "PREF_LEGEND_SYMBOL_TYPE" ), plot2dLegendGroup,
3010                                             LightApp_Preferences::Selector, "Plot2d", "LegendSymbolType" );
3011   aValuesList.clear();
3012   anIndicesList.clear();
3013   aValuesList   << tr("PREF_MARKER_ON_LINE") << tr("PREF_MARKER_ABOVE_LINE");
3014   anIndicesList << 0                            << 1                        ;
3015   pref->setItemProperty( "strings", aValuesList,   legendSymbolType );
3016   pref->setItemProperty( "indexes", anIndicesList, legendSymbolType );
3017   // .... -> legend font
3018   pref->addPreference( tr( "PREF_LEGEND_FONT" ), plot2dLegendGroup, LightApp_Preferences::Font, "Plot2d", "LegendFont" );
3019   // ... -> font color
3020   pref->addPreference( tr( "PREF_FONT_COLOR" ), plot2dLegendGroup, LightApp_Preferences::Color, "Plot2d", "LegendFontColor" );
3021   // ... -> selection font color
3022   pref->addPreference( tr( "PREF_SELECTED_FONT_COLOR" ), plot2dLegendGroup, LightApp_Preferences::Color, "Plot2d", "SelectedLegendFontColor" );
3023   // ... "Legend" group <<end>>
3024
3025   // .. "Plot2d viewer" group <<end>>
3026
3027   // .. "PyViewer" preferences tab <<start>>
3028   int pyeditTab = pref->addPreference( tr( "PREF_TAB_PYEDITOR" ), salomeCat );
3029   // ... "Font settings" group <<start>>
3030   int pyFontGroup = pref->addPreference( tr( "PREF_GROUP_PY_FONT" ), pyeditTab );
3031   int pyFont = pref->addPreference( tr( "PREF_PY_FONT" ), pyFontGroup,
3032                                     LightApp_Preferences::Font, "PyEditor", "Font" );
3033   pref->setItemProperty( "features", QtxFontEdit::Family | QtxFontEdit::Size | QtxFontEdit::UserSize, pyFont );
3034   // ... "Font settings" group <<end>>
3035   // ... "Display settings" group <<start>>
3036   int pyDispGroup = pref->addPreference( tr( "PREF_GROUP_PY_DISPLAY" ), pyeditTab );
3037   pref->setItemProperty( "columns", 2, pyDispGroup );
3038   // ... -> current line highlight
3039   pref->addPreference( tr( "PREF_PY_CURRLINE_HIGHLIGHT" ), pyDispGroup,
3040     LightApp_Preferences::Bool, "PyEditor", "HighlightCurrentLine" );
3041   // ... -> text wrapping
3042   pref->addPreference( tr( "PREF_PY_TEXT_WRAP" ), pyDispGroup,
3043     LightApp_Preferences::Bool, "PyEditor", "TextWrapping" );
3044   // ... -> center cursor on scroll
3045   pref->addPreference( tr( "PREF_PY_CURSON_ON_SCROLL" ), pyDispGroup,
3046     LightApp_Preferences::Bool, "PyEditor", "CenterCursorOnScroll" );
3047   // ... -> line numbers area
3048   pref->addPreference( tr( "PREF_PY_LINE_NUMBS_AREA" ), pyDispGroup,
3049     LightApp_Preferences::Bool, "PyEditor", "LineNumberArea" );
3050   // ... "Display settings" group <<end>>
3051
3052   // ... "Editor settings" group <<start>>
3053   int pyEditGroup = pref->addPreference( tr( "PREF_GROUP_PY_EDITOR" ), pyeditTab );
3054   // ... -> navigation mode
3055   int pyCompletion = pref->addPreference( tr( "PREF_PY_COMPLETION_MODE" ), pyEditGroup,
3056                                           LightApp_Preferences::Selector, "PyEditor", "CompletionPolicy" );
3057   aValuesList.clear();
3058   anIndicesList.clear();
3059   aValuesList   << tr("PREF_PY_NONE") << tr("PREF_PY_AUTO") << tr("PREF_PY_MANUAL") << tr("PREF_PY_ALWAYS");
3060   anIndicesList << 0                  << 1                  << 2                    << 3                   ;
3061   pref->setItemProperty( "strings", aValuesList, pyCompletion );
3062   pref->setItemProperty( "indexes", anIndicesList, pyCompletion );
3063   // ... "Editor settings" group <<end>>
3064
3065   // ... "Tab settings" group <<start>>
3066   int pyTabGroup = pref->addPreference( tr( "PREF_GROUP_PY_TAB" ), pyeditTab );
3067   pref->setItemProperty( "columns", 2, pyTabGroup );
3068   // ... -> tab whitespaces
3069   pref->addPreference( tr( "PREF_PY_TAB_WHITESPACES" ), pyTabGroup,
3070     LightApp_Preferences::Bool, "PyEditor", "TabSpaceVisible" );
3071   // ... -> tab size
3072   pref->addPreference( tr( "PREF_PY_TAB_SIZE" ), pyTabGroup,
3073     LightApp_Preferences::IntSpin, "PyEditor", "TabSize" );
3074   // ... "Tab settings" group <<end>>
3075   // ... "Vertical edge settings" group <<start>>
3076   int pyVertEdgeGroup = pref->addPreference( tr( "PREF_GROUP_VERT_EDGE" ), pyeditTab );
3077   pref->setItemProperty( "columns", 2, pyVertEdgeGroup );
3078   // ... -> vertical edge
3079   pref->addPreference( tr( "PREF_PY_VERT_EDGE" ), pyVertEdgeGroup,
3080     LightApp_Preferences::Bool, "PyEditor", "VerticalEdge" );
3081   // ... -> number of columns
3082   pref->addPreference( tr( "PREF_PY_NUM_COLUMNS" ), pyVertEdgeGroup,
3083     LightApp_Preferences::IntSpin, "PyEditor", "NumberColumns" );
3084   // ... "Vertical edge settings" group <<end>>
3085   // .. "PyEditor" preferences tab <<end>>
3086
3087   // .. "Directories" preferences tab <<start>>
3088   int dirTab = pref->addPreference( tr( "PREF_TAB_DIRECTORIES" ), salomeCat );
3089   // ... --> quick directories list
3090   int dirGroup = pref->addPreference( tr( "PREF_GROUP_DIRECTORIES" ), dirTab );
3091   pref->addPreference( tr( "" ), dirGroup,
3092                        LightApp_Preferences::DirList, "FileDlg", "QuickDirList" );
3093   // .. "Directories" preferences tab <<end>>
3094
3095   // .. "Object browser" preferences tab <<start>>
3096   int obTab = pref->addPreference( tr( "PREF_TAB_OBJBROWSER" ), salomeCat );
3097
3098   // ... "Search tool" group <<start>>
3099   int stGroup = pref->addPreference( tr( "PREF_OBJ_BROWSER_SEARCH_TOOL" ), obTab );
3100   // .... --> auto-hide
3101   pref->addPreference( tr( "PREF_AUTO_HIDE_SEARCH_TOOL" ), stGroup, LightApp_Preferences::Bool,
3102                        "ObjectBrowser", "auto_hide_search_tool" );
3103   // ... "Search tool" group <<end>>
3104
3105   // ... "Object browser settings" group <<start>>
3106   int objSetGroup = pref->addPreference( tr( "PREF_GROUP_LOOK_AND_FEEL" ), obTab );
3107   pref->setItemProperty( "columns", 2, objSetGroup );
3108   // .... -> auto size first column
3109   pref->addPreference( tr( "PREF_AUTO_SIZE_FIRST" ), objSetGroup, LightApp_Preferences::Bool,
3110                        "ObjectBrowser", "auto_size_first" );
3111   // .... -> auto size other columns
3112   pref->addPreference( tr( "PREF_AUTO_SIZE" ), objSetGroup, LightApp_Preferences::Bool,
3113                        "ObjectBrowser", "auto_size" );
3114   // .... -> resize columns on expand item
3115   pref->addPreference( tr( "PREF_RESIZE_ON_EXPAND_ITEM" ), objSetGroup, LightApp_Preferences::Bool,
3116                        "ObjectBrowser", "resize_on_expand_item" );
3117   // .... -> browse to published object
3118   int browsePublished = pref->addPreference( tr( "PREF_BROWSE_TO_THE_PUBLISHED_OBJECT" ), objSetGroup, LightApp_Preferences::Selector,
3119                                              "ObjectBrowser", "browse_published_object" );
3120   aValuesList.clear();
3121   anIndicesList.clear();
3122   aValuesList << tr( "PREF_BROWSE_NEVER" ) << tr( "PREF_BROWSE_AFTER_APPLY_AND_CLOSE_ONLY" ) << tr( "PREF_BROWSE_ALWAYS" );
3123   anIndicesList << BP_Never << BP_ApplyAndClose << BP_Always;
3124   pref->setItemProperty( "strings", aValuesList,   browsePublished );
3125   pref->setItemProperty( "indexes", anIndicesList, browsePublished );
3126   // ... "Object browser settings" group <<end>>
3127   // .. "Object browser" preferences tab <<end>>
3128
3129   // .. "Shortcuts" preferences tab <<start>>
3130   int shortcutTab = pref->addPreference( tr( "PREF_TAB_SHORTCUTS" ), salomeCat );
3131   // ... "Shortcuts settings" group <<start>>
3132   int shortcutGroup = pref->addPreference( tr( "PREF_GROUP_SHORTCUTS" ), shortcutTab );
3133   pref->addPreference( tr( "" ), shortcutGroup,
3134                        LightApp_Preferences::ShortcutTree, "shortcuts" );
3135   // ... "Shortcuts settings" group <<end>>
3136   // .. "Shortcuts" preferences tab <<end>>
3137   // . Top-level "SALOME" preferences group <<end>>
3138
3139   pref->retrieve();
3140 }
3141
3142 /*!
3143   Changes appearance of application according to changed preferences
3144   \param sec - section
3145   \param param - name of changed parameter
3146 */
3147 void LightApp_Application::preferencesChanged( const QString& sec, const QString& param )
3148 {
3149   SUIT_ResourceMgr* resMgr = resourceMgr();
3150   if ( !resMgr )
3151     return;
3152
3153   if ( sec == "viewers" && param == "drop_down_buttons" )
3154   {
3155     ViewManagerList vmlist = viewManagers();
3156     foreach( SUIT_ViewManager* vm, vmlist )
3157     {
3158       QVector<SUIT_ViewWindow*> vwlist = vm->getViews();
3159       foreach( SUIT_ViewWindow* vw, vwlist )
3160         if ( vw ) vw->setDropDownButtons( resMgr->booleanValue( "viewers", "drop_down_buttons", true ) );
3161     }
3162   }
3163
3164   if ( sec == QString( "3DViewer" ) && (param == QString( "trihedron_size" ) || param == QString( "relative_size" )))
3165   {
3166     double sz = resMgr->doubleValue( sec, "trihedron_size", -1 );
3167     bool relative = resMgr->booleanValue( sec, "relative_size", true );
3168     QList<SUIT_ViewManager*> lst;
3169 #ifndef DISABLE_OCCVIEWER
3170     viewManagers( OCCViewer_Viewer::Type(), lst );
3171     QListIterator<SUIT_ViewManager*> itOCC( lst );
3172     while ( itOCC.hasNext() && sz >= 0 )
3173     {
3174       SUIT_ViewModel* vm = itOCC.next()->getViewModel();
3175       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3176         continue;
3177
3178       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3179       occVM->setTrihedronSize( sz, relative );
3180       occVM->getAISContext()->UpdateCurrentViewer();
3181     }
3182 #endif
3183 #ifndef DISABLE_VTKVIEWER
3184 #ifndef DISABLE_SALOMEOBJECT
3185     viewManagers( SVTK_Viewer::Type(), lst );
3186     QListIterator<SUIT_ViewManager*> itVTK( lst );
3187     while ( itVTK.hasNext() && sz >= 0 )
3188     {
3189       SUIT_ViewModel* vm = itVTK.next()->getViewModel();
3190       if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
3191         continue;
3192
3193       SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
3194       if( vtkVM )
3195       {
3196         vtkVM->setTrihedronSize( sz, relative );
3197         vtkVM->Repaint();
3198       }
3199     }
3200 #endif
3201 #endif
3202   }
3203
3204   if ( sec == QString( "3DViewer" ) && param == QString( "show_static_trihedron" ) )
3205   {
3206     bool isVisible = resMgr->booleanValue( "3DViewer", "show_static_trihedron", true );
3207     QList<SUIT_ViewManager*> lst;
3208 #ifndef DISABLE_OCCVIEWER
3209     viewManagers( OCCViewer_Viewer::Type(), lst );
3210     QListIterator<SUIT_ViewManager*> itOCC( lst );
3211     while ( itOCC.hasNext() )
3212     {
3213       SUIT_ViewModel* vm = itOCC.next()->getViewModel();
3214       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3215         continue;
3216
3217       OCCViewer_Viewer* occVM = dynamic_cast<OCCViewer_Viewer*>( vm );
3218       if( occVM )
3219       {
3220         occVM->setStaticTrihedronDisplayed( isVisible );
3221       }
3222     }
3223 #endif
3224 #ifndef DISABLE_VTKVIEWER
3225 #ifndef DISABLE_SALOMEOBJECT
3226     viewManagers( SVTK_Viewer::Type(), lst );
3227     QListIterator<SUIT_ViewManager*> itVTK( lst );
3228     while ( itVTK.hasNext() )
3229     {
3230       SUIT_ViewModel* vm = itVTK.next()->getViewModel();
3231       if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
3232         continue;
3233
3234       SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
3235       if( vtkVM )
3236       {
3237         vtkVM->setStaticTrihedronVisible( isVisible );
3238         vtkVM->Repaint();
3239       }
3240     }
3241 #endif
3242 #endif
3243   }
3244
3245   if ( sec == QString( "3DViewer" ) && param == QString( "navigation_mode" ) )
3246   {
3247     int mode = resMgr->integerValue( "3DViewer", "navigation_mode", 0 );
3248     QList<SUIT_ViewManager*> lst;
3249 #ifndef DISABLE_OCCVIEWER
3250     viewManagers( OCCViewer_Viewer::Type(), lst );
3251     QListIterator<SUIT_ViewManager*> itOCC( lst );
3252     while ( itOCC.hasNext() )
3253     {
3254       SUIT_ViewModel* vm = itOCC.next()->getViewModel();
3255       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3256         continue;
3257
3258       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3259       occVM->setInteractionStyle( mode );
3260     }
3261 #endif
3262 #ifndef DISABLE_VTKVIEWER
3263 #ifndef DISABLE_SALOMEOBJECT
3264     viewManagers( SVTK_Viewer::Type(), lst );
3265     QListIterator<SUIT_ViewManager*> itVTK( lst );
3266     while ( itVTK.hasNext() )
3267     {
3268       SUIT_ViewModel* vm = itVTK.next()->getViewModel();
3269       if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
3270         continue;
3271
3272       SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
3273       if( vtkVM ) vtkVM->setInteractionStyle( mode );
3274     }
3275 #endif
3276 #endif
3277   }
3278
3279 #ifndef DISABLE_OCCVIEWER
3280   if ( sec == QString( "OCCViewer" ) && param == QString( "enable_preselection" ) )
3281   {
3282     bool isToEnablePreselection = resMgr->booleanValue( "OCCViewer", "enable_preselection", true );
3283     QList<SUIT_ViewManager*> lst;
3284     viewManagers( OCCViewer_Viewer::Type(), lst );
3285     QListIterator<SUIT_ViewManager*> it( lst );
3286     while ( it.hasNext() )
3287     {
3288       SUIT_ViewModel* vm = it.next()->getViewModel();
3289       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3290         continue;
3291
3292       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3293       occVM->enablePreselection( isToEnablePreselection );
3294     }
3295   }
3296 #endif
3297
3298 #ifndef DISABLE_OCCVIEWER
3299   if ( sec == QString( "OCCViewer" ) && param == QString( "enable_selection" ) )
3300   {
3301     bool isToEnableSelection = resMgr->booleanValue( "OCCViewer", "enable_selection", true );
3302     QList<SUIT_ViewManager*> lst;
3303     viewManagers( OCCViewer_Viewer::Type(), lst );
3304     QListIterator<SUIT_ViewManager*> it( lst );
3305     while ( it.hasNext() )
3306     {
3307       SUIT_ViewModel* vm = it.next()->getViewModel();
3308       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3309         continue;
3310
3311       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3312       occVM->enableSelection( isToEnableSelection );
3313     }
3314   }
3315 #endif
3316
3317 #ifndef DISABLE_OCCVIEWER
3318   if ( sec == QString( "OCCViewer" ) && param == QString( "clipping_color" ) )
3319   {
3320     QColor aColor = resMgr->colorValue( "OCCViewer", "clipping_color", QColor( 50, 50, 50 ) );
3321     QList<SUIT_ViewManager*> lst;
3322     viewManagers( OCCViewer_Viewer::Type(), lst );
3323     QListIterator<SUIT_ViewManager*> it( lst );
3324     while ( it.hasNext() )
3325     {
3326       SUIT_ViewModel* vm = it.next()->getViewModel();
3327       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3328         continue;
3329
3330       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3331       occVM->setClippingColor( aColor );
3332     }
3333   }
3334 #endif
3335
3336 #ifndef DISABLE_OCCVIEWER
3337   if ( sec == QString( "OCCViewer" ) && ( param == QString( "clipping_use_default_texture" ) ||
3338                                           param == QString( "clipping_texture" ) ||
3339                                           param == QString( "clipping_modulate" ) ||
3340                                           param == QString( "clipping_scale" ) ) )
3341   {
3342     bool isDefaultTextureUsed = resMgr->booleanValue( "OCCViewer", "clipping_use_default_texture" );
3343     QString aTexture = resMgr->stringValue( "OCCViewer", "clipping_texture" );
3344     bool isModulated = resMgr->booleanValue( "OCCViewer", "clipping_modulate" );
3345     double aScale = resMgr->doubleValue( "OCCViewer", "clipping_scale" );
3346     QList<SUIT_ViewManager*> lst;
3347     viewManagers( OCCViewer_Viewer::Type(), lst );
3348     QListIterator<SUIT_ViewManager*> it( lst );
3349     while ( it.hasNext() )
3350     {
3351       SUIT_ViewModel* vm = it.next()->getViewModel();
3352       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3353         continue;
3354
3355       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3356       occVM->setClippingTextureParams( isDefaultTextureUsed, aTexture, isModulated, aScale );
3357     }
3358   }
3359 #endif
3360
3361 #ifndef DISABLE_OCCVIEWER
3362   if ( sec == QString( "OCCViewer" ) && param == QString( "projection_mode" ) )
3363   {
3364     int mode = resMgr->integerValue( "OCCViewer", "projection_mode", 0 );
3365     QList<SUIT_ViewManager*> lst;
3366     viewManagers( OCCViewer_Viewer::Type(), lst );
3367     QListIterator<SUIT_ViewManager*> it( lst );
3368     while ( it.hasNext() )
3369     {
3370       SUIT_ViewModel* vm = it.next()->getViewModel();
3371       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3372         continue;
3373
3374       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3375       occVM->setProjectionType( mode );
3376     }
3377   }
3378 #endif
3379
3380 #ifndef DISABLE_OCCVIEWER
3381   if ( sec == QString( "OCCViewer" ) && param == QString( "stereo_type" ) )
3382   {
3383     int mode = resMgr->integerValue( "OCCViewer", "stereo_type", 0 );
3384     QList<SUIT_ViewManager*> lst;
3385     viewManagers( OCCViewer_Viewer::Type(), lst );
3386     QListIterator<SUIT_ViewManager*> it( lst );
3387     while ( it.hasNext() )
3388     {
3389       SUIT_ViewModel* vm = it.next()->getViewModel();
3390       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3391         continue;
3392
3393       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3394       occVM->setStereoType( mode );
3395     }
3396   }
3397 #endif
3398
3399 #ifndef DISABLE_OCCVIEWER
3400   if ( sec == QString( "OCCViewer" ) && param == QString( "anaglyph_filter" ) )
3401   {
3402     int mode = resMgr->integerValue( "OCCViewer", "anaglyph_filter", 0 );
3403     QList<SUIT_ViewManager*> lst;
3404     viewManagers( OCCViewer_Viewer::Type(), lst );
3405     QListIterator<SUIT_ViewManager*> it( lst );
3406     while ( it.hasNext() )
3407     {
3408       SUIT_ViewModel* vm = it.next()->getViewModel();
3409       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3410         continue;
3411
3412       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3413       occVM->setAnaglyphFilter( mode );
3414     }
3415   }
3416 #endif
3417
3418 #ifndef DISABLE_OCCVIEWER
3419   if ( sec == QString( "OCCViewer" ) && ( param == QString( "focus_type" ) ||
3420                                           param == QString( "focus_value" ) ) )
3421   {
3422     int aType = resMgr->integerValue( "OCCViewer", "focus_type" );
3423     double aValue = resMgr->doubleValue( "OCCViewer", "focus_value" );
3424     QList<SUIT_ViewManager*> lst;
3425     viewManagers( OCCViewer_Viewer::Type(), lst );
3426     QListIterator<SUIT_ViewManager*> it( lst );
3427     while ( it.hasNext() )
3428     {
3429       SUIT_ViewModel* vm = it.next()->getViewModel();
3430       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3431         continue;
3432
3433       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3434       occVM->setStereographicFocus( aType, aValue );
3435     }
3436   }
3437 #endif
3438
3439 #ifndef DISABLE_OCCVIEWER
3440   if ( sec == QString( "OCCViewer" ) && ( param == QString( "iod_type" ) ||
3441                                           param == QString( "iod_value" ) ) )
3442   {
3443     int aType = resMgr->integerValue( "OCCViewer", "iod_type" );
3444     double aValue = resMgr->doubleValue( "OCCViewer", "iod_value" );
3445     QList<SUIT_ViewManager*> lst;
3446     viewManagers( OCCViewer_Viewer::Type(), lst );
3447     QListIterator<SUIT_ViewManager*> it( lst );
3448     while ( it.hasNext() )
3449     {
3450       SUIT_ViewModel* vm = it.next()->getViewModel();
3451       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3452         continue;
3453
3454       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3455       occVM->setInterocularDistance( aType, aValue );
3456     }
3457   }
3458 #endif
3459
3460 #ifndef DISABLE_OCCVIEWER
3461   if ( sec == QString( "OCCViewer" ) && param == QString( "reverse_stereo" ) )
3462   {
3463     bool reverse = resMgr->booleanValue( "OCCViewer", "reverse_stereo", false );
3464     QList<SUIT_ViewManager*> lst;
3465     viewManagers( OCCViewer_Viewer::Type(), lst );
3466     QListIterator<SUIT_ViewManager*> it( lst );
3467     while ( it.hasNext() )
3468     {
3469       SUIT_ViewModel* vm = it.next()->getViewModel();
3470       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3471         continue;
3472
3473       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3474       occVM->setReverseStereo( reverse );
3475     }
3476   }
3477 #endif
3478
3479 #ifndef DISABLE_OCCVIEWER
3480   if ( sec == QString( "OCCViewer" ) && param == QString( "enable_vsync" ) )
3481   {
3482     bool enable = resMgr->booleanValue( "OCCViewer", "enable_vsync", true );
3483     QList<SUIT_ViewManager*> lst;
3484     viewManagers( OCCViewer_Viewer::Type(), lst );
3485     QListIterator<SUIT_ViewManager*> it( lst );
3486     while ( it.hasNext() )
3487     {
3488       SUIT_ViewModel* vm = it.next()->getViewModel();
3489       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3490         continue;
3491
3492       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3493       occVM->setVSync( enable );
3494     }
3495   }
3496 #endif
3497
3498 #ifndef DISABLE_OCCVIEWER
3499   if ( sec == QString( "OCCViewer" ) && param == QString( "enable_quad_buffer_support" ) )
3500   {
3501     bool enable = resMgr->booleanValue( "OCCViewer", "enable_quad_buffer_support", false );
3502     QList<SUIT_ViewManager*> lst;
3503     viewManagers( OCCViewer_Viewer::Type(), lst );
3504     QListIterator<SUIT_ViewManager*> it( lst );
3505     while ( it.hasNext() )
3506     {
3507       SUIT_ViewModel* vm = it.next()->getViewModel();
3508       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3509         continue;
3510
3511       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3512       occVM->setQuadBufferSupport( enable );
3513     }
3514   }
3515 #endif
3516
3517   if ( sec == QString( "3DViewer" ) && param == QString( "zooming_mode" ) )
3518   {
3519     int mode = resMgr->integerValue( "3DViewer", "zooming_mode", 0 );
3520     QList<SUIT_ViewManager*> lst;
3521 #ifndef DISABLE_OCCVIEWER
3522     viewManagers( OCCViewer_Viewer::Type(), lst );
3523     QListIterator<SUIT_ViewManager*> itOCC( lst );
3524     while ( itOCC.hasNext() )
3525     {
3526       SUIT_ViewModel* vm = itOCC.next()->getViewModel();
3527       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3528         continue;
3529
3530       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3531       occVM->setZoomingStyle( mode );
3532     }
3533 #endif
3534 #ifndef DISABLE_VTKVIEWER
3535 #ifndef DISABLE_SALOMEOBJECT
3536     viewManagers( SVTK_Viewer::Type(), lst );
3537     QListIterator<SUIT_ViewManager*> itVTK( lst );
3538     while ( itVTK.hasNext() )
3539     {
3540       SUIT_ViewModel* vm = itVTK.next()->getViewModel();
3541       if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
3542         continue;
3543
3544       SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
3545       if( vtkVM ) vtkVM->setZoomingStyle( mode );
3546     }
3547 #endif
3548 #endif
3549   }
3550
3551 #ifndef DISABLE_VTKVIEWER
3552   if ( sec == QString( "VTKViewer" ) && (param == QString( "speed_value" ) || param == QString( "speed_mode" )) )
3553   {
3554     int speed = resMgr->integerValue( "VTKViewer", "speed_value", 10 );
3555     int mode = resMgr->integerValue( "VTKViewer", "speed_mode", 0 );
3556     QList<SUIT_ViewManager*> lst;
3557 #ifndef DISABLE_SALOMEOBJECT
3558     viewManagers( SVTK_Viewer::Type(), lst );
3559     QListIterator<SUIT_ViewManager*> it( lst );
3560     while ( it.hasNext() )
3561     {
3562       SUIT_ViewModel* vm = it.next()->getViewModel();
3563       if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
3564         continue;
3565
3566       SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
3567       if( vtkVM ) vtkVM->setIncrementalSpeed( speed, mode );
3568     }
3569 #endif
3570   }
3571 #endif
3572
3573 #ifndef DISABLE_VTKVIEWER
3574   if ( sec == QString( "VTKViewer" ) && param == QString( "projection_mode" ) )
3575   {
3576     int mode = resMgr->integerValue( "VTKViewer", "projection_mode", 0 );
3577     QList<SUIT_ViewManager*> lst;
3578 #ifndef DISABLE_SALOMEOBJECT
3579     viewManagers( SVTK_Viewer::Type(), lst );
3580     QListIterator<SUIT_ViewManager*> it( lst );
3581     while ( it.hasNext() )
3582     {
3583       SUIT_ViewModel* vm = it.next()->getViewModel();
3584       if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
3585         continue;
3586
3587       SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
3588       if( vtkVM ) vtkVM->setProjectionMode( mode );
3589     }
3590 #endif
3591   }
3592 #endif
3593
3594 #ifndef DISABLE_VTKVIEWER
3595   if ( sec == QString( "VTKViewer" ) && param == QString( "stereo_type" ) )
3596   {
3597     int mode = resMgr->integerValue( "VTKViewer", "stereo_type", 0 );
3598     QList<SUIT_ViewManager*> lst;
3599 #ifndef DISABLE_SALOMEOBJECT
3600     viewManagers( SVTK_Viewer::Type(), lst );
3601     QListIterator<SUIT_ViewManager*> it( lst );
3602     while ( it.hasNext() )
3603     {
3604       SUIT_ViewModel* vm = it.next()->getViewModel();
3605       if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
3606         continue;
3607
3608       SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
3609       if( vtkVM ) vtkVM->setStereoType( mode );
3610     }
3611 #endif
3612   }
3613 #endif
3614
3615 #ifndef DISABLE_VTKVIEWER
3616   if ( sec == QString( "VTKViewer" ) && param == QString( "anaglyph_filter" ) )
3617   {
3618     int mode = resMgr->integerValue( "VTKViewer", "anaglyph_filter", 0 );
3619     QList<SUIT_ViewManager*> lst;
3620 #ifndef DISABLE_SALOMEOBJECT
3621     viewManagers( SVTK_Viewer::Type(), lst );
3622     QListIterator<SUIT_ViewManager*> it( lst );
3623     while ( it.hasNext() )
3624     {
3625       SUIT_ViewModel* vm = it.next()->getViewModel();
3626       if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
3627         continue;
3628
3629       SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
3630       if( vtkVM ) vtkVM->setAnaglyphFilter( mode );
3631     }
3632 #endif
3633   }
3634 #endif
3635
3636 #ifndef DISABLE_VTKVIEWER
3637   if ( sec == QString( "VTKViewer" ) && param == QString( "enable_quad_buffer_support" ) )
3638   {
3639     int enable = resMgr->booleanValue( "VTKViewer", "enable_quad_buffer_support", false );
3640     QList<SUIT_ViewManager*> lst;
3641 #ifndef DISABLE_SALOMEOBJECT
3642     viewManagers( SVTK_Viewer::Type(), lst );
3643     QListIterator<SUIT_ViewManager*> it( lst );
3644     while ( it.hasNext() )
3645     {
3646       SUIT_ViewModel* vm = it.next()->getViewModel();
3647       if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
3648         continue;
3649
3650       SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
3651       if( vtkVM ) vtkVM->setQuadBufferSupport( enable );
3652     }
3653 #endif
3654   }
3655 #endif
3656
3657 #ifndef DISABLE_VTKVIEWER
3658   if ( sec == QString( "VTKViewer" ) && param == QString( "preselection" ) )
3659   {
3660     int mode = resMgr->integerValue( "VTKViewer", "preselection", 0 );
3661     QList<SUIT_ViewManager*> lst;
3662 #ifndef DISABLE_SALOMEOBJECT
3663     viewManagers( SVTK_Viewer::Type(), lst );
3664     QListIterator<SUIT_ViewManager*> it( lst );
3665     while ( it.hasNext() )
3666     {
3667       SUIT_ViewModel* vm = it.next()->getViewModel();
3668       if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
3669         continue;
3670
3671       SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
3672       if( vtkVM ) vtkVM->setPreSelectionMode( mode );
3673     }
3674 #endif
3675   }
3676 #endif
3677
3678 #ifndef DISABLE_VTKVIEWER
3679   if ( sec == QString( "VTKViewer" ) && param == QString( "enable_selection" ) )
3680   {
3681     bool isToEnableSelection = resMgr->booleanValue( "VTKViewer", "enable_selection", true );
3682     QList<SUIT_ViewManager*> lst;
3683 #ifndef DISABLE_SALOMEOBJECT
3684     viewManagers( SVTK_Viewer::Type(), lst );
3685     QListIterator<SUIT_ViewManager*> it( lst );
3686     while ( it.hasNext() )
3687     {
3688       SUIT_ViewModel* vm = it.next()->getViewModel();
3689       if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
3690         continue;
3691
3692       SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
3693       if( vtkVM ) vtkVM->enableSelection( isToEnableSelection );
3694     }
3695 #endif
3696   }
3697 #endif
3698
3699 #ifndef DISABLE_VTKVIEWER
3700   if ( sec == QString( "VTKViewer" ) && (param == QString( "spacemouse_func1_btn" ) ||
3701                                          param == QString( "spacemouse_func2_btn" ) ||
3702                                          param == QString( "spacemouse_func5_btn" ) ) )
3703   {
3704     int btn1 = resMgr->integerValue( "VTKViewer", "spacemouse_func1_btn", 1 );
3705     int btn2 = resMgr->integerValue( "VTKViewer", "spacemouse_func2_btn", 2 );
3706     int btn3 = resMgr->integerValue( "VTKViewer", "spacemouse_func5_btn", 9 );
3707     QList<SUIT_ViewManager*> lst;
3708 #ifndef DISABLE_SALOMEOBJECT
3709     viewManagers( SVTK_Viewer::Type(), lst );
3710     QListIterator<SUIT_ViewManager*> it( lst );
3711     while ( it.hasNext() )
3712     {
3713       SUIT_ViewModel* vm = it.next()->getViewModel();
3714       if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
3715         continue;
3716
3717       SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
3718       if( vtkVM ) vtkVM->setSpacemouseButtons( btn1, btn2, btn3 );
3719     }
3720 #endif
3721   }
3722 #endif
3723   if( sec=="ObjectBrowser" )
3724   {
3725     SUIT_DataBrowser* ob = objectBrowser();
3726     if ( !ob )
3727       return;
3728
3729     if ( param=="auto_size_first" )
3730     {
3731       bool autoSizeFirst = resMgr->booleanValue( "ObjectBrowser", "auto_size_first", true );
3732       ob->setAutoSizeFirstColumn( autoSizeFirst );
3733       if ( autoSizeFirst )
3734         ob->adjustFirstColumnWidth();
3735     }
3736     else if ( param=="auto_size" ) {
3737       bool autoSize = resMgr->booleanValue( "ObjectBrowser", "auto_size", false );
3738       ob->setAutoSizeColumns(autoSize);
3739       if ( autoSize )
3740         ob->adjustColumnsWidth();
3741     }
3742     else if ( param=="resize_on_expand_item" ) {
3743       bool resizeOnExpandItem = resMgr->booleanValue( "ObjectBrowser", "resize_on_expand_item", false );
3744       ob->setResizeOnExpandItem(resizeOnExpandItem);
3745     }
3746     else if ( param == "auto_hide_search_tool" ) {
3747       ob->searchTool()->enableAutoHide( resMgr->booleanValue( "ObjectBrowser", "auto_hide_search_tool" ) );
3748     }
3749   }
3750
3751   if( sec=="Study" )
3752   {
3753     if( param=="auto_save_interval" ) {
3754       myAutoSaveTimer->stop();
3755       int autoSaveInterval = resMgr->integerValue( "Study", "auto_save_interval", 0 );
3756       if ( activeStudy() && autoSaveInterval > 0 ) myAutoSaveTimer->start( autoSaveInterval*60000 );
3757     }
3758   }
3759
3760 #ifndef DISABLE_PYCONSOLE
3761   if( sec=="PyConsole" && pythonConsole() )
3762   {
3763     if ( param=="font" ) {
3764       pythonConsole()->setFont( resMgr->fontValue( "PyConsole", "font" ) );
3765     }
3766     else if ( param=="show_banner" ) {
3767       pythonConsole()->setIsShowBanner( resMgr->booleanValue( "PyConsole", "show_banner", true ) );
3768     }
3769     else if ( param=="auto_completion" ) {
3770       pythonConsole()->setAutoCompletion( resMgr->booleanValue( "PyConsole", "auto_completion", true ) );
3771     }
3772   }
3773 #endif
3774
3775   if( sec=="MRU" )
3776   {
3777     QtxMRUAction* mru = ::qobject_cast<QtxMRUAction*>( action( MRUId ) );
3778     if ( mru ) {
3779       if ( param == "visible_count" )
3780         mru->setVisibleCount( resMgr->integerValue( "MRU", "visible_count", 5 ) );    // 5 MRU items by default
3781       else if ( param == "max_count" )
3782         mru->setHistoryCount( resMgr->integerValue( "MRU", "max_count", -1 ) );       // unlimited history by default
3783       else if ( param == "insert_mode" )
3784         mru->setInsertMode( resMgr->integerValue( "MRU", "insert_mode", 0 ) );        // QtxMRUAction::MoveFirst by default
3785       else if ( param == "link_type" )
3786         mru->setLinkType( resMgr->integerValue( "MRU", "link_type", 0 ) );            // QtxMRUAction::LinkAuto by default
3787       else if ( param == "show_clear" )
3788         mru->setClearPossible( resMgr->booleanValue( "MRU", "show_clear", false ) );  // do not show "Clear" item by default
3789       else if ( param == "show_mru" )
3790         mru->setVisible( resMgr->booleanValue( "MRU", "show_mru", false ) );          // do not show MRU menu item by default
3791     }
3792   }
3793   if ( sec == "language" && param == "language" )
3794   {
3795     // VSR 18.06.2015 : commented out : single warning dialog box is now shown by the LightApp_PreferencesDlg
3796     //SUIT_MessageBox::information( desktop(), tr( "WRN_WARNING" ), tr( "LANG_CHANGED" ) );
3797   }
3798   if ( sec == "language" && param == "locale")
3799   {
3800     // VSR 18.06.2015: commented out : single warning dialog box is now shown by the LightApp_PreferencesDlg
3801     //SUIT_MessageBox::information( desktop(), tr( "WRN_WARNING" ), tr( "LOCALE_CHANGED" ) );
3802   }
3803   if ( sec == "desktop" && param == "opaque_resize" ) {
3804     bool opaqueResize = resMgr->booleanValue( "desktop", "opaque_resize", false );
3805     // RNV: This code has been commented, because clearing of the QMainWindow::AnimatedDocks option
3806     //      leads to strange behaviour of the dockable windows (at least at qt-5.6.1):
3807     //      any dockable window can't be docked to the another area, except initial area.
3808     //      It is possible to move window to another area, but it always returns to the initial area.
3809     //
3810     //    QMainWindow::DockOptions dopts = desktop()->dockOptions();
3811     //    if ( opaqueResize ) dopts |= QMainWindow::AnimatedDocks;
3812     //     else                dopts &= ~QMainWindow::AnimatedDocks;
3813     //    desktop()->setDockOptions( dopts );
3814     desktop()->setOpaqueResize( opaqueResize );
3815     if ( dynamic_cast<STD_TabDesktop*>( desktop() ) )
3816       dynamic_cast<STD_TabDesktop*>( desktop() )->workstack()->setOpaqueResize( opaqueResize );
3817   }
3818
3819 #ifndef DISABLE_PLOT2DVIEWER
3820   QList<SUIT_ViewManager*> lst;
3821   viewManagers( Plot2d_Viewer::Type(), lst );
3822   QListIterator<SUIT_ViewManager*> itPlot2d( lst );
3823   while ( itPlot2d.hasNext() ) {
3824     SUIT_ViewManager* viewMgr = itPlot2d.next();
3825     SUIT_ViewModel* vm = viewMgr->getViewModel();
3826     if ( !vm || !vm->inherits( "Plot2d_Viewer" ) )
3827       continue;
3828
3829     //Plot2d_Viewer* Plot2dVM = dynamic_cast<Plot2d_Viewer*>( vm );
3830
3831     viewMgr->setViewModel( vm  );
3832     Plot2d_ViewWindow* wnd = dynamic_cast<Plot2d_ViewWindow*>( viewMgr->getActiveView() );
3833     if( wnd ) {
3834       Plot2d_ViewFrame* frame = wnd->getViewFrame();
3835       frame->SetPreference();
3836     }
3837   }
3838 #endif
3839 }
3840
3841 /*!
3842   Loads preferences
3843 */
3844 void LightApp_Application::loadPreferences()
3845 {
3846   CAM_Application::loadPreferences();
3847
3848   SUIT_ResourceMgr* aResMgr = resourceMgr();
3849
3850   if ( !aResMgr )
3851     return;
3852
3853   static bool mru_load = true;
3854   if ( mru_load )
3855   {
3856     QtxMRUAction* mru = ::qobject_cast<QtxMRUAction*>( action( MRUId ) );
3857     if ( mru ) {
3858       mru->setVisible( aResMgr->booleanValue( "MRU", "show_mru", false ) );         // do not show MRU menu item by default
3859       mru->setVisibleCount( aResMgr->integerValue( "MRU", "visible_count", 5 ) );   // 5 MRU items by default
3860       mru->setHistoryCount( aResMgr->integerValue( "MRU", "max_count", -1 ) );      // unlimited history by default
3861       mru->setInsertMode( aResMgr->integerValue( "MRU", "insert_mode", 0 ) );       // QtxMRUAction::MoveFirst by default
3862       mru->setLinkType( aResMgr->integerValue( "MRU", "link_type", 0 ) );           // QtxMRUAction::LinkAuto by default
3863       mru->setClearPossible( aResMgr->booleanValue( "MRU", "show_clear", false ) ); // do not show "Clear" item by default
3864       mru->loadLinks( aResMgr, "MRU" );
3865     }
3866     mru_load = false;
3867   }
3868
3869   myWinVis.clear();
3870   QStringList mods = aResMgr->parameters( "windows_visibility" );
3871   for ( QStringList::const_iterator itr = mods.begin(); itr != mods.end(); ++itr )
3872   {
3873     QByteArray arr;
3874     if ( aResMgr->value( "windows_visibility", *itr, arr ) )
3875       myWinVis.insert( *itr, arr );
3876   }
3877
3878   if ( desktop() ) {
3879     desktop()->retrieveGeometry( aResMgr->stringValue( "desktop", "geometry" ) );
3880     bool opaqueResize = aResMgr->booleanValue( "desktop", "opaque_resize", false );
3881     //    QMainWindow::DockOptions dopts = desktop()->dockOptions();
3882     //    if ( opaqueResize ) dopts |= QMainWindow::AnimatedDocks;
3883     //    else                dopts &= ~QMainWindow::AnimatedDocks;
3884     //    desktop()->setDockOptions( dopts );
3885     desktop()->setOpaqueResize( opaqueResize );
3886     if ( dynamic_cast<STD_TabDesktop*>( desktop() ) )
3887       dynamic_cast<STD_TabDesktop*>( desktop() )->workstack()->setOpaqueResize( opaqueResize );
3888   }
3889 }
3890
3891 /*!
3892   Saves preferences
3893 */
3894 void LightApp_Application::savePreferences()
3895 {
3896   CAM_Application::savePreferences();
3897
3898   saveDockWindowsState();
3899
3900   SUIT_ResourceMgr* aResMgr = resourceMgr();
3901
3902   if ( !aResMgr )
3903     return;
3904
3905   QtxMRUAction* mru = ::qobject_cast<QtxMRUAction*>( action( MRUId ) );
3906   if ( mru )
3907     mru->saveLinks( aResMgr, "MRU" );
3908
3909   for ( WinVis::const_iterator itr = myWinVis.begin(); itr != myWinVis.end(); ++itr )
3910     aResMgr->setValue( "windows_visibility", itr.key(), itr.value() );
3911
3912   if ( desktop() )
3913     aResMgr->setValue( "desktop", "geometry", desktop()->storeGeometry() );
3914
3915 #if GUI_DEVELOPMENT > 0
3916   aResMgr->setValue( "salome", "version", QString(GUI_VERSION_STR)+"dev" );
3917 #else
3918   aResMgr->setValue( "salome", "version", QString(GUI_VERSION_STR) );
3919 #endif
3920
3921   aResMgr->save();
3922 }
3923
3924 /*!
3925   Updates desktop title
3926 */
3927 void LightApp_Application::updateDesktopTitle()
3928 {
3929   QString aTitle = applicationName();
3930   QString aVer = applicationVersion();
3931   if ( !aVer.isEmpty() )
3932     aTitle += QString( " " ) + aVer;
3933
3934   if ( activeStudy() ) {
3935     QString sName = SUIT_Tools::file( activeStudy()->studyName().trimmed(), false );
3936     aTitle += QString( " - [%1]" ).arg( sName );
3937   }
3938
3939   desktop()->setWindowTitle( aTitle );
3940 }
3941
3942 /*!
3943   \brief Get map of the operations which can be performed
3944   on the module activation.
3945
3946   The method should return the map of the kind \c {<id>:<name>}
3947   where \c <id> is an integer identifier of the operation and
3948   \c <name> is a title for the button to be added to the
3949   dialog box. After user selects the required operation by the
3950   clicking the corresponding button in the dialog box, its identifier
3951   is passed to the moduleActionSelected() method to process
3952   the made choice.
3953
3954   \return map of the operations
3955   \sa moduleActionSelected()
3956 */
3957 QMap<int, QString> LightApp_Application::activateModuleActions() const
3958 {
3959   QMap<int, QString> opmap;
3960   opmap.insert( NewStudyId,  tr( "ACTIVATE_MODULE_OP_NEW" ) );
3961   opmap.insert( OpenStudyId, tr( "ACTIVATE_MODULE_OP_OPEN" ) );
3962   return opmap;
3963 }
3964
3965 /*!
3966   \brief Called when the used selectes required operation chosen
3967   from "Activate module" dialog box.
3968
3969   Performs the required operation according to the user choice.
3970
3971   \param id operation identifier
3972   \sa activateModuleActions()
3973 */
3974 void LightApp_Application::moduleActionSelected( const int id )
3975 {
3976   switch ( id ) {
3977   case NewStudyId:
3978     onNewDoc();
3979     break;
3980   case OpenStudyId:
3981     onOpenDoc();
3982     break;
3983   default:
3984     break;
3985   }
3986 }
3987
3988 /*!
3989   Updates windows after close document
3990 */
3991 void LightApp_Application::afterCloseDoc()
3992 {
3993   updateWindows();
3994
3995   CAM_Application::afterCloseDoc();
3996 }
3997
3998 /*!
3999   Updates actions of active module
4000 */
4001 void LightApp_Application::updateModuleActions()
4002 {
4003   QString modName;
4004   if ( activeModule() ) {
4005     modName = activeModule()->moduleName();
4006     if ( !isModuleAccessible( modName ) ) {
4007       QList<SUIT_Application*> apps = SUIT_Session::session()->applications();
4008       foreach( SUIT_Application* app, apps ) {
4009         LightApp_Application* lapp = dynamic_cast<LightApp_Application*>( app );
4010         if ( lapp && lapp != this )
4011           lapp->removeModuleAction( modName );
4012       }
4013     }
4014   }
4015
4016   LightApp_ModuleAction* moduleAction =
4017     qobject_cast<LightApp_ModuleAction*>( action( ModulesListId ) );
4018   if ( moduleAction )
4019     moduleAction->setActiveModule( modName );
4020 }
4021
4022 void LightApp_Application::removeModuleAction( const QString& modName )
4023 {
4024   LightApp_ModuleAction* moduleAction =
4025     qobject_cast<LightApp_ModuleAction*>( action( ModulesListId ) );
4026   if ( moduleAction )
4027     moduleAction->removeModule( modName );
4028 }
4029
4030 bool LightApp_Application::checkModule( const QString& title )
4031 {
4032   if ( title.isEmpty() )
4033     return false;
4034
4035   QString library = moduleLibrary( title, true );
4036   if ( library.isEmpty() )
4037     return false;
4038
4039   QString name = moduleName( title );
4040
4041   bool isPyModule = library.contains( "SalomePyQtGUI" ) || library.contains( "SalomePyQtGUILight" );
4042
4043   QStringList paths;
4044 #if defined(WIN32)
4045   paths = QString( ::getenv( "PATH" ) ).split( ";", QString::SkipEmptyParts );
4046 #elif defined(__APPLE__)
4047   paths = QString( ::getenv( "DYLD_LIBRARY_PATH" ) ).split( ":", QString::SkipEmptyParts );
4048 #else
4049   paths = QString( ::getenv( "LD_LIBRARY_PATH" ) ).split( ":", QString::SkipEmptyParts );
4050 #endif
4051
4052   bool isFound = false;
4053   QStringList::const_iterator it;
4054   for ( it = paths.begin(); it != paths.end() && !isFound; ++it )
4055   {
4056     isFound = QFileInfo( Qtx::addSlash( *it ) + library ).exists();
4057   }
4058
4059   if ( !isFound )
4060   {
4061     INFOS( std::endl <<
4062            "****************************************************************" << std::endl <<
4063            "     Warning: library " << qPrintable( library ) << " is not found!" << std::endl <<
4064            "     Module " << qPrintable( title ) << " will not be available in GUI mode!" << std::endl <<
4065            "****************************************************************" << std::endl);
4066     return false;
4067   }
4068
4069   if ( isPyModule )
4070   {
4071     QString pyModule = QString( "%1GUI.py" ).arg( name );
4072     paths = QString( ::getenv( "PYTHONPATH" ) ).split( ":", QString::SkipEmptyParts );
4073
4074     isFound = false;
4075     for ( it = paths.begin(); it != paths.end() && !isFound; ++it )
4076     {
4077       isFound = QFileInfo( Qtx::addSlash( *it ) + pyModule ).exists();
4078     }
4079
4080     if ( !isFound )
4081     {
4082       INFOS( std::endl <<
4083              "****************************************************************" << std::endl <<
4084              "     Warning: Python module " << qPrintable( pyModule ) << " is not found!" << std::endl <<
4085              "     Module " << qPrintable( title ) << " will not be available in GUI mode!" << std::endl <<
4086              "****************************************************************" << std::endl);
4087       return false;
4088     }
4089   }
4090
4091   return true;
4092 }
4093
4094 /*!
4095   Gets current windows.
4096   \param winMap - output current windows map.
4097 */
4098 void LightApp_Application::currentWindows( QMap<int, int>& winMap ) const
4099 {
4100   winMap.clear();
4101   if ( activeModule() && activeModule()->inherits( "LightApp_Module" ) )
4102     ((LightApp_Module*)activeModule())->windows( winMap );
4103   else
4104     defaultWindows( winMap );
4105 }
4106
4107 /*!
4108   Gets current view managers.
4109   \param lst - output current view managers list.
4110 */
4111 void LightApp_Application::currentViewManagers( QStringList& lst ) const
4112 {
4113   lst.clear();
4114   if ( !activeStudy() )
4115     return;
4116
4117   if ( activeModule() && activeModule()->inherits( "LightApp_Module" ) )
4118     ((LightApp_Module*)activeModule())->viewManagers( lst );
4119   else
4120     defaultViewManagers( lst );
4121 }
4122
4123 /*!
4124   Updates windows
4125 */
4126 void LightApp_Application::updateWindows()
4127 {
4128   QMap<int, int> winMap;
4129   currentWindows( winMap );
4130
4131   for ( QMap<int, int>::ConstIterator it = winMap.begin(); it != winMap.end(); ++it )
4132   {
4133     if ( !dockWindow( it.key() ) )
4134       getWindow( it.key() );
4135   }
4136
4137   for ( WinMap::ConstIterator it = myWin.begin(); it != myWin.end(); ++it )
4138   {
4139     QWidget* wid = it.value();
4140     if ( winMap.contains( it.key() ) )
4141       wid->setVisible( true );
4142     else
4143       delete wid;
4144   }
4145
4146   loadDockWindowsState();
4147 }
4148
4149 /*!
4150   Updates view managers
4151 */
4152 void LightApp_Application::updateViewManagers()
4153 {
4154   QStringList lst;
4155   currentViewManagers( lst );
4156
4157   for ( QStringList::const_iterator it = lst.begin(); it != lst.end(); ++it )
4158     getViewManager( *it, true );
4159 }
4160
4161 /*!
4162   Loads windows geometry
4163 */
4164 void LightApp_Application::loadDockWindowsState()
4165 {
4166   if ( !desktop() )
4167     return;
4168   SUIT_ResourceMgr* aResMgr = SUIT_Session::session()->resourceMgr();
4169   bool storeWin = aResMgr->booleanValue( "Study", "store_positions", true );
4170   bool storeTb = aResMgr->booleanValue( "Study", "store_tool_positions", true );
4171
4172   QString modName;
4173   if ( activeModule() )
4174     modName = activeModule()->name();
4175   else if ( activeStudy() )
4176     modName = "nomodule";
4177
4178   QtxResourceMgr::WorkingMode prevMode = aResMgr->setWorkingMode( QtxResourceMgr::IgnoreUserValues );
4179   QByteArray aDefaultState;
4180   aResMgr->value( "windows_geometry", modName, aDefaultState );
4181   QByteArray aDefaultVisibility;
4182   aResMgr->value( "windows_visibility", modName, aDefaultVisibility );
4183   bool hasDefaultVisibility = !aDefaultVisibility.isEmpty();
4184   aResMgr->setWorkingMode( prevMode );
4185
4186   if( !storeWin && !storeTb && aDefaultState.isEmpty() && !hasDefaultVisibility)
4187     return;
4188
4189   if ( aResMgr->hasValue("windows_geometry" ,modName ) ) {
4190     long version = Qtx::versionToId( aResMgr->stringValue( "windows_geometry_version", modName, "" ) );
4191     QByteArray arr;
4192     if ( version > Qtx::versionToId( "7.4.1" ) )
4193       aResMgr->value( "windows_geometry", modName , arr );
4194     else
4195       arr = aDefaultState;
4196     QByteArray aTargetArray = processState(arr, storeWin, storeTb, true, aDefaultState);
4197     desktop()->restoreState( aTargetArray );
4198   }
4199
4200   QStringList mainToolbarsNames;
4201   mainToolbarsNames << "SalomeStandard" << "SalomeModules";
4202   QList<QToolBar*> mainToolbars = findToolBars( mainToolbarsNames );
4203   foreach( QToolBar* tb, mainToolbars ) tb->setVisible( true );
4204   /*
4205   if ( !myWinVis.contains( modName ) && aDefaultVisibility.isEmpty())
4206     return;
4207
4208   QMap<QString, bool> *tbMap = 0;
4209   QMap<QString, bool> *dwMap = 0;
4210
4211   QMap<QString, bool> userTbMap, userDwMap;
4212   dockWindowsState( myWinVis[modName], userTbMap, userDwMap );
4213
4214   QMap<QString, bool> defaultTbMap, defaultDwMap;
4215   if(hasDefaultVisibility) {
4216     dockWindowsState( aDefaultVisibility, defaultTbMap, defaultDwMap);
4217   }
4218
4219   if(storeTb) {
4220     tbMap =  &userTbMap;
4221   } else {
4222     if(hasDefaultVisibility){
4223       tbMap =  &defaultTbMap;
4224     }
4225   }
4226
4227   if(storeWin) {
4228     dwMap =  &userDwMap;
4229   } else {
4230     if(hasDefaultVisibility){
4231       dwMap =  &defaultDwMap;
4232     }
4233   }
4234
4235   if(tbMap) {
4236     QList<QToolBar*> tbList = findToolBars();
4237     for ( QList<QToolBar*>::iterator tit = tbList.begin(); tit != tbList.end(); ++tit )
4238       {
4239         QToolBar* tb = *tit;
4240         if ( tbMap->contains( tb->objectName() ) ) {
4241           tb->setVisible( (*tbMap)[tb->objectName()] );
4242         }
4243       }
4244   }
4245
4246   if(dwMap) {
4247     QList<QDockWidget*> dwList = desktop()->findChildren<QDockWidget*>();
4248     for ( QList<QDockWidget*>::iterator dit = dwList.begin(); dit != dwList.end(); ++dit )
4249       {
4250         QDockWidget* dw = *dit;
4251
4252         QObject* po = Qtx::findParent( dw, "QMainWindow" );
4253         if ( po != desktop() )
4254           continue;
4255
4256         if ( dwMap->contains( dw->objectName() ) )
4257           dw->setVisible( (*dwMap)[dw->objectName()] );
4258       }
4259   }
4260   */
4261 }
4262
4263
4264 /*!
4265   Saves windows geometry
4266 */
4267 void LightApp_Application::saveDockWindowsState()
4268 {
4269   if ( !desktop() )
4270     return;
4271
4272   bool storeWin = resourceMgr()->booleanValue( "Study", "store_positions", true );
4273   bool storeTb = resourceMgr()->booleanValue( "Study", "store_tool_positions", true );
4274
4275   if( !storeWin && !storeTb )
4276     return;
4277
4278   QString modName;
4279   if ( activeModule() )
4280     modName = activeModule()->name();
4281   else if ( activeStudy() )
4282     modName = "nomodule";
4283
4284   QString versionId = GUI_VERSION_STR;
4285 #if GUI_DEVELOPMENT > 0
4286   versionId += "dev";
4287 #endif
4288
4289   QByteArray arr = desktop()->saveState();
4290   resourceMgr()->setValue( "windows_geometry", modName, processState(arr, storeWin, storeTb, false) );
4291   resourceMgr()->setValue( "windows_geometry_version", modName, versionId );
4292
4293   QByteArray visArr;
4294   if ( myWinVis.contains( modName ) )
4295     visArr = myWinVis[modName];
4296
4297   QMap<QString, bool> tbMap, dwMap;
4298   dockWindowsState( visArr, tbMap, dwMap );
4299
4300   QList<QToolBar*> tbList = desktop()->findChildren<QToolBar*>();
4301   for ( QList<QToolBar*>::iterator it = tbList.begin(); it != tbList.end(); ++it )
4302   {
4303     QToolBar* tb = *it;
4304     tbMap.insert( tb->objectName(), tb->toggleViewAction()->isChecked() );
4305   }
4306
4307   QList<QDockWidget*> dwList = desktop()->findChildren<QDockWidget*>();
4308   for ( QList<QDockWidget*>::iterator it = dwList.begin(); it != dwList.end(); ++it )
4309   {
4310     QDockWidget* wid = *it;
4311     dwMap.insert( wid->objectName(), wid->toggleViewAction()->isChecked() );
4312   }
4313
4314   visArr = dockWindowsState( tbMap, dwMap );
4315
4316   myWinVis.insert( modName, visArr );
4317 }
4318
4319 QByteArray LightApp_Application::dockWindowsState( const QMap<QString, bool>& tb, const QMap<QString, bool>& dw ) const
4320 {
4321   QByteArray visArr;
4322   QDataStream stream( &visArr, QIODevice::WriteOnly );
4323
4324   stream << (uchar)ToolBarMarker;
4325   stream << tb.size();
4326   for ( QMap<QString, bool>::const_iterator tit = tb.begin(); tit != tb.end(); ++tit )
4327   {
4328     stream << tit.key();
4329     stream << (uchar)( tit.value() ? 1 : 0 );
4330   }
4331
4332   stream << (uchar)DockWidgetMarker;
4333   stream << dw.size();
4334   for ( QMap<QString, bool>::const_iterator wit = dw.begin(); wit != dw.end(); ++wit )
4335   {
4336     stream << wit.key();
4337     stream << (uchar)( wit.value() ? 1 : 0 );
4338   }
4339
4340   return visArr;
4341 }
4342
4343 void LightApp_Application::dockWindowsState( const QByteArray& arr, QMap<QString, bool>& tb, QMap<QString, bool>& dw ) const
4344 {
4345   tb.clear();
4346   dw.clear();
4347
4348   QByteArray visArr = arr;
4349   QDataStream stream( &visArr, QIODevice::ReadOnly );
4350
4351   uchar marker;
4352   stream >> marker;
4353   if ( marker != ToolBarMarker )
4354     return;
4355
4356   int lines;
4357   stream >> lines;
4358   for ( int i = 0; i < lines; ++i )
4359   {
4360     QString objectName;
4361     stream >> objectName;
4362     uchar shown;
4363     stream >> shown;
4364     tb.insert( objectName, shown );
4365   }
4366
4367   stream >> marker;
4368   if ( marker != DockWidgetMarker )
4369     return;
4370
4371   stream >> lines;
4372   for ( int j = 0; j < lines; ++j )
4373   {
4374     QString objectName;
4375     stream >> objectName;
4376     uchar shown;
4377     stream >> shown;
4378     dw.insert( objectName, shown );
4379   }
4380 }
4381
4382 /*!
4383   Adds icon names for modules
4384 */
4385 void LightApp_Application::moduleIconNames( QMap<QString, QString>& iconMap ) const
4386 {
4387   iconMap.clear();
4388
4389   SUIT_ResourceMgr* resMgr = resourceMgr();
4390   if ( !resMgr )
4391     return;
4392
4393   QStringList modList;
4394   modules( modList, false );
4395
4396   for ( QStringList::const_iterator it = modList.begin(); it != modList.end(); ++it )
4397   {
4398     QString modName = *it;
4399     QString modIntr = moduleName( modName );
4400     QString modIcon = resMgr->stringValue( modIntr, "icon", QString() );
4401
4402     if ( modIcon.isEmpty() )
4403       continue;
4404
4405     if ( SUIT_Tools::extension( modIcon ).isEmpty() )
4406       modIcon += QString( ".png" );
4407
4408     iconMap.insert( modName, modIcon );
4409   }
4410 }
4411
4412 /*!
4413   Inserts items in popup, which necessary for current application
4414 */
4415 void LightApp_Application::contextMenuPopup( const QString& type, QMenu* thePopup, QString& title )
4416 {
4417   //Add "Rename" item
4418   LightApp_SelectionMgr* selMgr = LightApp_Application::selectionMgr();
4419   bool cacheIsOn = selMgr->isSelectionCacheEnabled();
4420   selMgr->setSelectionCacheEnabled( true );
4421
4422   SUIT_DataBrowser* ob = objectBrowser();
4423
4424   CAM_Application::contextMenuPopup( type, thePopup, title );
4425
4426   if ( ob && type == ob->popupClientType() ) {
4427     thePopup->addSeparator();
4428     QAction* a = thePopup->addAction( tr( "MEN_REFRESH" ), this, SLOT( onRefresh() ) );
4429     if ( ob->shortcutKey(SUIT_DataBrowser::UpdateShortcut) )
4430       a->setShortcut( ob->shortcutKey(SUIT_DataBrowser::UpdateShortcut) );
4431   }
4432
4433 #ifndef DISABLE_SALOMEOBJECT
4434   if ( selMgr && ob ) {
4435     SALOME_ListIO selected;
4436     selMgr->selectedObjects( selected );
4437     if(selected.Extent() == 1){
4438       Handle(SALOME_InteractiveObject) anIObject = selected.First();
4439       SUIT_DataObject* obj = findObject(anIObject->getEntry());
4440       if(obj && obj->renameAllowed()) {
4441         QAction* a = new QAction(tr("MEN_RENAME_OBJ"), thePopup);
4442         connect( a, SIGNAL( triggered(bool) ), ob, SLOT( onStartEditing() ) );
4443         if ( ob->shortcutKey(SUIT_DataBrowser::RenameShortcut) )
4444           a->setShortcut( ob->shortcutKey(SUIT_DataBrowser::RenameShortcut) );
4445
4446         QList<QAction*> acts = thePopup->actions();
4447         QAction* firstAction = acts.count() > 0 ? acts.first() : 0;
4448         thePopup->insertAction(firstAction,a);
4449       }
4450     }
4451   }
4452 #endif
4453
4454   selMgr->setSelectionCacheEnabled( cacheIsOn );
4455 }
4456
4457 /*!
4458   Create empty study
4459 */
4460 void LightApp_Application::createEmptyStudy()
4461 {
4462   CAM_Application::createEmptyStudy();
4463
4464   if ( objectBrowser() )
4465     objectBrowser()->updateTree();
4466
4467   SUIT_ResourceMgr* aResMgr = SUIT_Session::session()->resourceMgr();
4468   if ( aResMgr && activeStudy() ) {
4469     int autoSaveInterval = aResMgr->integerValue( "Study", "auto_save_interval", 0 );
4470     if ( autoSaveInterval > 0 ) myAutoSaveTimer->start( autoSaveInterval*60000 );
4471   }
4472 }
4473
4474 /*!Set desktop:*/
4475 void LightApp_Application::setDesktop( SUIT_Desktop* desk )
4476 {
4477   CAM_Application::setDesktop( desk );
4478
4479   if ( desk ) {
4480     connect( desk, SIGNAL( message( const QString& ) ),
4481              this, SLOT( onDesktopMessage( const QString& ) ), Qt::UniqueConnection );
4482     connect( desk, SIGNAL( windowActivated( SUIT_ViewWindow* ) ),
4483              this, SLOT( onWindowActivated( SUIT_ViewWindow* ) ), Qt::UniqueConnection );
4484     /* connect( desk, SIGNAL( windowMoved( SUIT_ViewWindow* ) ),
4485              this, SLOT( onWindowMoved( SUIT_ViewWindow* ) ), Qt::UniqueConnection ); */
4486   }
4487 }
4488
4489 /*!
4490   Activates module
4491   \param mod - module to be activated
4492 */
4493 bool LightApp_Application::activateModule( CAM_Module* mod )
4494 {
4495   bool res = CAM_Application::activateModule( mod );
4496
4497   if ( objectBrowser() )
4498     objectBrowser()->updateTree();
4499
4500   return res;
4501 }
4502
4503 /*!
4504   \return keyborad accelerators manager object
4505 */
4506 SUIT_Accel* LightApp_Application::accel() const
4507 {
4508   return myAccel;
4509 }
4510
4511 /*!
4512   Removes dead widget container from map
4513 */
4514 void LightApp_Application::onWCDestroyed( QObject* ob )
4515 {
4516   // remove destroyed widget container from windows map
4517   for ( WinMap::ConstIterator itr = myWin.begin(); itr != myWin.end(); ++itr )
4518   {
4519     if ( itr.value() != ob )
4520       continue;
4521
4522     int key = itr.key();
4523     myWin.remove( key );
4524     break;
4525   }
4526 }
4527
4528 void LightApp_Application::onMRUActivated( const QString& name )
4529 {
4530   SUIT_Session* s = SUIT_Session::session();
4531   if ( s && s->activeApplication() == this )
4532     onOpenDoc( name );
4533 }
4534
4535 void LightApp_Application::onStylePreferences()
4536 {
4537 #ifdef USE_SALOME_STYLE
4538   Style_PrefDlg dlg( desktop() );
4539   dlg.exec();
4540
4541   resourceMgr()->setValue( "Style", "use_salome_style", Style_Salome::isActive() );
4542 #endif // USE_SALOME_STYLE
4543 }
4544
4545 void LightApp_Application::onFullScreen(){
4546   if(myScreenHelper) {
4547     if(desktop()->isFullScreen())
4548       myScreenHelper->switchToNormalScreen();
4549     else
4550       myScreenHelper->switchToFullScreen();
4551   }
4552 }
4553
4554 /*!
4555   Connects just added view manager
4556 */
4557 void LightApp_Application::addViewManager( SUIT_ViewManager* vm )
4558 {
4559   connect( vm, SIGNAL( lastViewClosed( SUIT_ViewManager* ) ),
4560            this, SLOT( onCloseView( SUIT_ViewManager* ) ) );
4561   CAM_Application::addViewManager( vm );
4562 }
4563
4564 /*!
4565   Remove view manager from memory
4566 */
4567 void LightApp_Application::removeViewManager( SUIT_ViewManager* vm )
4568 {
4569   disconnect( vm, SIGNAL( lastViewClosed( SUIT_ViewManager* ) ),
4570            this, SLOT( onCloseView( SUIT_ViewManager* ) ) );
4571   LightApp_Study* aStudy = dynamic_cast<LightApp_Study*>(activeStudy());
4572   if (aStudy )
4573     aStudy->removeObjectProperties( vm->getGlobalId() );
4574
4575   CAM_Application::removeViewManager( vm );
4576
4577   LightApp_SelectionMgr* selMgr = selectionMgr();
4578   QList<SUIT_Selector*> selectors;
4579   selMgr->selectors( selectors );
4580   foreach( SUIT_Selector* selector, selectors ) {
4581     if ( selector->owner() == vm->getViewModel() ) {
4582       delete selector;
4583     }
4584   }
4585
4586   // IPAL22894: Crash on closing OCC view
4587   //delete vm;
4588   vm->deleteLater();
4589 }
4590
4591 /*!
4592   Renames active window of desktop
4593 */
4594 void LightApp_Application::onRenameWindow()
4595 {
4596   if( !desktop() )
4597     return;
4598
4599   QWidget* w = desktop()->activeWindow();
4600   if( !w )
4601     return;
4602
4603   bool ok;
4604   QString name = QInputDialog::getText( w, tr( "TOT_RENAME" ), tr( "PRP_RENAME" ), QLineEdit::Normal, w->windowTitle(), &ok );
4605   if( ok && !name.isEmpty() )
4606     w->setWindowTitle( name );
4607 }
4608
4609 /*!
4610   Closes active window of desktop
4611 */
4612 void LightApp_Application::onCloseWindow()
4613 {
4614   if( !desktop() )
4615     return;
4616
4617   QWidget* w = desktop()->activeWindow();
4618   if( !w )
4619     return;
4620
4621   w->close();
4622 }
4623
4624 /*!
4625   Closes all windows of desktop
4626 */
4627 void LightApp_Application::onCloseAllWindow()
4628 {
4629   STD_TabDesktop* desk = dynamic_cast<STD_TabDesktop*>( desktop() );
4630   if( !desk )
4631     return;
4632
4633   QList<SUIT_ViewWindow*> wndList = desk->windows();
4634   SUIT_ViewWindow* wnd;
4635   foreach( wnd, wndList )
4636   {
4637     if ( wnd )
4638       wnd->close();
4639   }
4640 }
4641
4642 /*!
4643   Groups all windows of desktop
4644 */
4645 void LightApp_Application::onGroupAllWindow()
4646 {
4647   STD_TabDesktop* desk = dynamic_cast<STD_TabDesktop*>( desktop() );
4648   if( !desk )
4649     return;
4650
4651   QtxWorkstack* wgStack = desk->workstack();
4652   if ( wgStack )
4653     wgStack->stack();
4654 }
4655
4656 /*!
4657   \return default name for an active study
4658 */
4659 void LightApp_Application::setDefaultStudyName( const QString& theName )
4660 {
4661   QStringList anInfoList;
4662   modules( anInfoList, false );
4663
4664   LightApp_Study* aStudy = (LightApp_Study*)activeStudy();
4665   if( anInfoList.count() == 1 && // to avoid a conflict between different modules
4666       !aStudy->isSaved() )
4667   {
4668     aStudy->setStudyName( theName );
4669     updateDesktopTitle();
4670   }
4671 }
4672
4673 /*!
4674   Custom event handler
4675 */
4676 bool LightApp_Application::event( QEvent* e )
4677 {
4678   if( e && e->type()==2000 )
4679   {
4680     SALOME_CustomEvent* ce = ( SALOME_CustomEvent* )e;
4681     QString* d = ( QString* )ce->data();
4682     if( SUIT_MessageBox::question(0, tr("WRN_WARNING"),
4683                                   d ? *d : "",
4684                                   SUIT_MessageBox::Yes | SUIT_MessageBox::No,
4685                                   SUIT_MessageBox::Yes ) == SUIT_MessageBox::Yes )
4686       showPreferences( tr( "PREF_APP" ) );
4687     if( d )
4688       delete d;
4689     return true;
4690   }
4691   return CAM_Application::event( e );
4692 }
4693
4694 /*! Check data object */
4695 bool LightApp_Application::checkDataObject(LightApp_DataObject* theObj)
4696 {
4697   if (theObj)
4698     {
4699       bool isSuitable = !theObj->entry().isEmpty() &&
4700                         !theObj->componentDataType().isEmpty() &&
4701                         !theObj->name().isEmpty();
4702       return isSuitable;
4703     }
4704
4705   return false;
4706 }
4707
4708 int LightApp_Application::openChoice( const QString& aName )
4709 {
4710   int choice = CAM_Application::openChoice( aName );
4711
4712   if ( choice == OpenExist ) // The document is already open.
4713   {
4714     // Do you want to reload it?
4715     if ( SUIT_MessageBox::question( desktop(), tr( "WRN_WARNING" ), tr( "QUE_DOC_ALREADYOPEN" ).arg( aName ),
4716                                     SUIT_MessageBox::Yes | SUIT_MessageBox::No, SUIT_MessageBox::No ) == SUIT_MessageBox::Yes )
4717       choice = OpenReload;
4718   }
4719
4720   return choice;
4721 }
4722
4723 bool LightApp_Application::openAction( const int choice, const QString& aName )
4724 {
4725   bool res = false;
4726   switch ( choice )
4727   {
4728   case OpenReload:
4729     {
4730       STD_Application* app = 0;
4731       SUIT_Session* session = SUIT_Session::session();
4732       QList<SUIT_Application*> appList = session->applications();
4733       for ( QList<SUIT_Application*>::iterator it = appList.begin(); it != appList.end() && !app; ++it )
4734       {
4735         if ( (*it)->activeStudy() && (*it)->activeStudy()->studyName() == aName )
4736           app = ::qobject_cast<STD_Application*>( *it );
4737       }
4738
4739       if ( app )
4740       {
4741         app->onCloseDoc( false );
4742         appList = session->applications();
4743         STD_Application* other = 0;
4744         for ( QList<SUIT_Application*>::iterator it = appList.begin(); it != appList.end() && !other; ++it )
4745           other = ::qobject_cast<STD_Application*>( *it );
4746
4747         if ( other )
4748           res = other->onOpenDoc( aName );
4749       }
4750     }
4751     break;
4752   default:
4753     res = CAM_Application::openAction( choice, aName );
4754     break;
4755   }
4756
4757   return res;
4758 }
4759
4760 QStringList LightApp_Application::viewManagersTypes() const
4761 {
4762   QStringList aTypesList;
4763   aTypesList += myUserWmTypes;
4764 #ifndef DISABLE_GLVIEWER
4765   aTypesList<<GLViewer_Viewer::Type();
4766 #endif
4767 #ifndef DISABLE_PLOT2DVIEWER
4768   aTypesList<<Plot2d_Viewer::Type();
4769 #endif
4770 #ifndef DISABLE_QXGRAPHVIEWER
4771   aTypesList<<QxScene_Viewer::Type();
4772 #endif
4773 #ifndef DISABLE_PVVIEWER
4774   aTypesList<<PVViewer_Viewer::Type();
4775 #endif
4776 #ifndef DISABLE_PYVIEWER
4777   aTypesList<<PyViewer_Viewer::Type();
4778 #endif
4779 #ifndef DISABLE_OCCVIEWER
4780   aTypesList<<OCCViewer_Viewer::Type();
4781 #endif
4782 #ifndef DISABLE_VTKVIEWER
4783  #ifndef DISABLE_SALOMEOBJECT
4784   aTypesList<<SVTK_Viewer::Type();
4785  #else
4786   aTypesList<<VTKViewer_Viewer::Type();
4787  #endif
4788 #endif
4789   return aTypesList;
4790 }
4791 /*!
4792  * Removes all view managers of known types
4793  * Other view managers are ignored
4794  */
4795 void LightApp_Application::clearKnownViewManagers()
4796 {
4797   QStringList aTypesList = viewManagersTypes();
4798   QList<SUIT_ViewManager*> aMgrList;
4799   viewManagers( aMgrList );
4800   foreach (SUIT_ViewManager* aMgr, aMgrList) {
4801     if (aTypesList.contains(aMgr->getType()))
4802       removeViewManager(aMgr);
4803   }
4804 }
4805
4806 /*!
4807   Copy of current selection
4808  */
4809 void LightApp_Application::onCopy()
4810 {
4811   LightApp_Module* m = dynamic_cast<LightApp_Module*>( activeModule() );
4812   if( m )
4813     m->copy();
4814 }
4815
4816 /*!
4817   Paste of current data in clipboard
4818  */
4819 void LightApp_Application::onPaste()
4820 {
4821   LightApp_Module* m = dynamic_cast<LightApp_Module*>( activeModule() );
4822   if( m )
4823     m->paste();
4824 }
4825
4826 /*!
4827   Browse (i.e. set focus on) the published objects
4828   \param theIsApplyAndClose - flag indicating that the dialog for creating objects
4829                               has been accepted by Ok (or Apply & Close) button
4830   \param theIsOptimizedBrowsing - flag switching to optimized browsing mode
4831                                   (to select the first published object only)
4832   \return entry of the selected object
4833  */
4834 QString LightApp_Application::browseObjects( const QStringList& theEntryList,
4835                                              const bool theIsApplyAndClose,
4836                                              const bool theIsOptimizedBrowsing )
4837 {
4838   QString aResult;
4839   if( SUIT_ResourceMgr* aResourceMgr = resourceMgr() )
4840   {
4841     int aBrowsePolicy = aResourceMgr->integerValue( "ObjectBrowser", "browse_published_object", (int)BP_Never );
4842     switch( aBrowsePolicy )
4843     {
4844       case BP_Never:
4845         return aResult;
4846       case BP_ApplyAndClose:
4847         if( !theIsApplyAndClose )
4848           return aResult;
4849       case BP_Always:
4850       default:
4851         break;
4852     }
4853   }
4854
4855   LightApp_Study* aStudy = dynamic_cast<LightApp_Study*>( activeStudy() );
4856   if( !aStudy )
4857     return aResult;
4858
4859   SUIT_DataBrowser* anOB = objectBrowser();
4860   if( !anOB )
4861     return aResult;
4862
4863   SUIT_AbstractModel* aModel = dynamic_cast<SUIT_AbstractModel*>( anOB->model() );
4864   if( !aModel )
4865     return aResult;
4866
4867   QStringListIterator anIter( theEntryList );
4868   if( theIsOptimizedBrowsing )
4869   {
4870     // go to the last entry
4871     anIter.toBack();
4872     if( anIter.hasPrevious() )
4873       anIter.previous();
4874   }
4875
4876   // scroll to each entry in the list
4877   // (in optimized mode - to the last entry only)
4878   QString anEntry;
4879   LightApp_DataObject* anObject = 0;
4880   while( anIter.hasNext() )
4881   {
4882     anEntry = anIter.next();
4883     if( !anEntry.isEmpty() )
4884     {
4885       anObject = aStudy->findObjectByEntry( anEntry );
4886       if( anObject )
4887       {
4888         QModelIndex anIndex = aModel->index( anObject );
4889         anOB->treeView()->scrollTo( anIndex );
4890       }
4891     }
4892   }
4893
4894   // always select the last object
4895   if( anObject && !anEntry.isEmpty() )
4896   {
4897     QList<SUIT_Selector*> aSelectorList;
4898     selectionMgr()->selectors( "ObjectBrowser", aSelectorList );
4899     if( !aSelectorList.isEmpty() )
4900     {
4901       if( LightApp_OBSelector* aSelector = dynamic_cast<LightApp_OBSelector*>( aSelectorList.first() ) )
4902       {
4903         bool anIsAutoBlock = aSelector->autoBlock();
4904
4905         // temporarily disable auto block, to emit LightApp_SelectionMgr::currentSelectionChanged() signal
4906         aSelector->setAutoBlock( false );
4907
4908         SUIT_DataOwnerPtrList aList;
4909 #ifndef DISABLE_SALOMEOBJECT
4910         Handle(SALOME_InteractiveObject) aSObj = new SALOME_InteractiveObject
4911           ( anObject->entry().toLatin1().constData(),
4912             anObject->componentDataType().toLatin1().constData(),
4913             anObject->name().toLatin1().constData() );
4914         LightApp_DataOwner* owner = new LightApp_DataOwner( aSObj  );
4915 #else
4916         LightApp_DataOwner* owner = new LightApp_DataOwner( anEntry );
4917 #endif
4918
4919         aList.append( owner );
4920         selectionMgr()->setSelected( aList );
4921         aResult = anEntry;
4922
4923         // restore auto block flag
4924         aSelector->setAutoBlock( anIsAutoBlock );
4925       }
4926     }
4927   }
4928
4929   return aResult;
4930 }
4931
4932 SUIT_DataObject* LightApp_Application::findObject( const QString& id ) const
4933 {
4934   LightApp_Study* study = dynamic_cast<LightApp_Study*>( activeStudy() );
4935   return study ? study->findObjectByEntry( id ) : 0;
4936 }
4937
4938 /*!
4939   Checks that an object can be renamed.
4940   \param entry entry of the object
4941   \brief Return \c true if object can be renamed
4942 */
4943 bool LightApp_Application::renameAllowed( const QString& /*entry*/) const {
4944   return false;
4945 }
4946
4947 /*!
4948   Rename object by entry.
4949   \param entry entry of the object
4950   \param name new name of the object
4951   \brief Return \c true if rename operation finished successfully, \c false otherwise.
4952 */
4953 bool LightApp_Application::renameObject( const QString& entry, const QString& ) {
4954   return false;
4955 }
4956
4957 /*! Process standard messages from desktop */
4958 void LightApp_Application::onDesktopMessage( const QString& message )
4959 {
4960   const QString sectionSeparator = "/";
4961
4962   if ( message.toLower() == "updateobjectbrowser" ||
4963        message.toLower() == "updateobjbrowser" ) {
4964     // update object browser
4965     updateObjectBrowser();
4966   }
4967   else if ( message.toLower().startsWith( "activate_viewer" ) ) {
4968     QString vtype = message.split( sectionSeparator ).last();
4969     if ( !vtype.isEmpty() )
4970       getViewManager( vtype, true );
4971   }
4972   else {
4973     QStringList data = message.split( sectionSeparator );
4974     if ( data.count() > 1 ) {
4975       QString msgType = data[0].trimmed();
4976       LightApp_Module* sMod = 0;
4977       CAM_Module* mod = module( msgType );
4978       if ( !mod )
4979         mod = module( moduleTitle( msgType ) );
4980       if ( mod && mod->inherits( "LightApp_Module" ) )
4981         sMod = (LightApp_Module*)mod;
4982
4983       if ( msgType.toLower() == "preferences" ) {
4984         // requested preferences change: should be given as "preferences/<section>/<name>/<value>"
4985         // for example "preferences/Study/multi_file_dump/true"
4986         if ( data.count() > 3 ) {
4987           QString section = data[1].trimmed();
4988           QString param   = data[2].trimmed();
4989           QString value   = QStringList( data.mid(3) ).join( sectionSeparator );
4990           resourceMgr()->setValue( section, param, value );
4991         }
4992       }
4993       else if ( sMod ) {
4994         // received message for the module
4995         QString msg = QStringList( data.mid(1) ).join( sectionSeparator );
4996         sMod->message( msg );
4997       }
4998     }
4999   }
5000 }
5001
5002 /*!
5003   Internal method.
5004   Returns all top level toolbars.
5005   Note : Result list contains only main window toolbars, not including toolbars from viewers.
5006 */
5007 QList<QToolBar*> LightApp_Application::findToolBars( const QStringList& names )
5008 {
5009   QList<QToolBar*> aResult;
5010   QList<QToolBar*> tbList = desktop()->findChildren<QToolBar*>();
5011   for ( QList<QToolBar*>::iterator tit = tbList.begin(); tit != tbList.end(); ++tit ) {
5012     QToolBar* tb = *tit;
5013     QObject* po = Qtx::findParent( tb, "QMainWindow" );
5014     if ( po != desktop() )
5015       continue;
5016     if ( names.isEmpty() || names.contains( tb->objectName() ) )
5017       aResult.append(tb);
5018   }
5019   return aResult;
5020 }
5021
5022 /*!
5023   Internal method to parse toolbars and dockable windows state.
5024 */
5025 QByteArray LightApp_Application::processState(QByteArray& input,
5026                                               const bool processWin,
5027                                               const bool processTb,
5028                                               const bool isRestoring,
5029                                               QByteArray defaultState) {
5030
5031   QByteArray aRes;
5032   bool hasDefaultState  = !defaultState.isEmpty();
5033   bool isDockWinWriten = false;
5034   int nbDocWin = -1;
5035   //Write date from users settings
5036   if(isRestoring){
5037     QDataStream tmpInputData(&input, QIODevice::ReadOnly);
5038     int marker, version;
5039     uchar dockmarker;
5040     tmpInputData >> marker;
5041     tmpInputData >> version;
5042     tmpInputData >> dockmarker;
5043     tmpInputData >> nbDocWin;
5044   }
5045   if(processWin && processTb && !isRestoring) {
5046     aRes = input;
5047   } else if(!processWin && !processTb ) {
5048     if(hasDefaultState)
5049       aRes = defaultState;
5050   } else {
5051     QDataStream aData(&aRes, QIODevice::WriteOnly);
5052     QList<QToolBar*> aToolBars = findToolBars();
5053
5054     QStringList aNames;
5055     for ( QList<QToolBar*>::iterator tit = aToolBars.begin(); tit != aToolBars.end(); ++tit ) {
5056       QToolBar* tb = *tit;
5057       aNames.append(tb->objectName());
5058     }
5059
5060     int toolBarMarkerIndex = getToolbarMarkerIndex(input,aNames);
5061     if(toolBarMarkerIndex < 0)
5062       return aRes;
5063     QDataStream anInputData(&input, QIODevice::ReadOnly);
5064
5065     int toolBarMarkerIndexDef;
5066     if(hasDefaultState) {
5067       toolBarMarkerIndexDef = getToolbarMarkerIndex(defaultState, aNames);
5068       if(toolBarMarkerIndexDef < 0)
5069         return aRes;
5070     }
5071     QDataStream anInputDataDef(&defaultState, QIODevice::ReadOnly);
5072
5073     QDataStream* aTargetData = 0;
5074     int          aTargetIndex = -1;
5075
5076     QByteArray currentArr = desktop()->saveState();
5077     QDataStream anInputDataCur(&currentArr, QIODevice::ReadOnly);
5078     bool useInputData = !isRestoring || (isRestoring && nbDocWin > 0);
5079     if(processWin && useInputData) {
5080       aTargetData = &anInputData;
5081       aTargetIndex = toolBarMarkerIndex;
5082     } else {
5083       //Write date from default settings
5084       if(hasDefaultState) {
5085         aTargetData = &anInputDataDef;
5086         aTargetIndex = toolBarMarkerIndexDef;
5087       } else {
5088         //If no default state, write current snapshot of the dockable windows
5089         if(isRestoring) {
5090           aTargetData = &anInputDataCur;
5091           int toolBarMarkerIndexCur = getToolbarMarkerIndex(currentArr, aNames);
5092           aTargetIndex = toolBarMarkerIndexCur;
5093         }
5094       }
5095     }
5096
5097     if(aTargetData && aTargetIndex >= 0 ) {
5098       aTargetData->device()->seek(0);
5099       while( aTargetData->device()->pos() < aTargetIndex ) {
5100         uchar ch;
5101         *aTargetData >> ch;
5102         aData<<ch;
5103       }
5104       isDockWinWriten = true;
5105     }
5106
5107     aTargetData = 0;
5108     aTargetIndex = -1;
5109
5110     if(processTb) {
5111       aTargetData = &anInputData;
5112       aTargetIndex = toolBarMarkerIndex;
5113     } else {
5114       if(hasDefaultState) {
5115         aTargetData = &anInputDataDef;
5116         aTargetIndex = toolBarMarkerIndexDef;
5117       }
5118     }
5119
5120     if(aTargetData && aTargetIndex >= 0) {
5121       int index;
5122       if(!isDockWinWriten ) {
5123         //Write version marker
5124         int marker, version;
5125         aTargetData->device()->seek(0);
5126         *aTargetData >> marker;
5127         *aTargetData >> version;
5128         aData << marker;
5129         aData << version;
5130         aData << (uchar) QDockWidgetMarker;
5131         aData << (int) 0;
5132         int shift = 4*sizeof(int) + sizeof(QSize);
5133         index = aTargetIndex - shift;
5134       } else {
5135         index = aTargetIndex;
5136       }
5137
5138       aTargetData->device()->seek(index);
5139       while(!aTargetData->atEnd()) {
5140         uchar ch;
5141         *aTargetData >> ch;
5142         aData << ch;
5143       }
5144     } else { // Not treat toolbars
5145       aData << (uchar) QToolBarMarker;
5146       aData << (int) 0; //Nb toolbars = 0
5147     }
5148   }
5149   return aRes;
5150 }
5151
5152 /*!
5153   \brief Emits operationFinished signal.
5154   \param theModuleName the name of the module which perfomed the operation
5155   \param theOperationName the operation name
5156   \param theEntryList the list of the created objects entries
5157 */
5158 void LightApp_Application::emitOperationFinished( const QString& theModuleName,
5159                                                   const QString& theOperationName,
5160                                                   const QStringList& theEntryList )
5161 {
5162   emit operationFinished( theModuleName, theOperationName, theEntryList );
5163 }
5164
5165 /*!
5166   Update visibility state of given objects
5167 */
5168 void LightApp_Application::updateVisibilityState( DataObjectList& theList,
5169                                                   SUIT_ViewModel*  theViewModel )
5170 {
5171   if ( !theViewModel || theList.isEmpty() ) return;
5172
5173   LightApp_Study* aStudy = dynamic_cast<LightApp_Study*>(activeStudy());
5174   if ( !aStudy ) return;
5175
5176   SALOME_View* aView = dynamic_cast<SALOME_View*>( theViewModel );
5177
5178   for ( DataObjectList::iterator itr = theList.begin(); itr != theList.end(); ++itr ) {
5179     LightApp_DataObject* obj = dynamic_cast<LightApp_DataObject*>(*itr);
5180
5181     if ( !obj || aStudy->isComponent( obj->entry() ) )
5182       continue;
5183
5184     LightApp_Module* anObjModule = dynamic_cast<LightApp_Module*>(obj->module());
5185     if ( anObjModule ) {
5186       LightApp_Displayer* aDisplayer = anObjModule->displayer();
5187       if ( aDisplayer ) {
5188         Qtx::VisibilityState anObjState = Qtx::UnpresentableState;
5189         if ( aDisplayer->canBeDisplayed( obj->entry(), theViewModel->getType() ) ) {
5190           if ( aView && aDisplayer->IsDisplayed( obj->entry(), aView ) )
5191             anObjState = Qtx::ShownState;
5192           else
5193             anObjState = Qtx::HiddenState;
5194         }
5195         aStudy->setVisibilityState( obj->entry(), anObjState );
5196       }
5197     }
5198   }
5199 }
5200
5201 /*!
5202  * Called when window activated
5203  */
5204 void LightApp_Application::onWindowActivated( SUIT_ViewWindow* theViewWindow )
5205 {
5206   SUIT_DataBrowser* anOB = objectBrowser();
5207   if ( !anOB )
5208     return;
5209   SUIT_DataObject* rootObj = anOB->root();
5210   if ( !rootObj )
5211     return;
5212
5213   DataObjectList listObj = rootObj->children( true );
5214
5215   SUIT_ViewModel* vmod = 0;
5216   if ( SUIT_ViewManager* vman = theViewWindow->getViewManager() )
5217     vmod = vman->getViewModel();
5218   updateVisibilityState( listObj, vmod );
5219 }
5220
5221 /*!
5222   Called then view manager removed
5223 */
5224 void LightApp_Application::onViewManagerRemoved( SUIT_ViewManager* )
5225 {
5226   ViewManagerList lst;
5227   viewManagers( lst );
5228   if ( lst.count() == 1) { // in case if closed last view window
5229     LightApp_Study* aStudy = dynamic_cast<LightApp_Study*>( activeStudy() );
5230     if ( aStudy )
5231       aStudy->setVisibilityStateForAll( Qtx::UnpresentableState );
5232   }
5233 }
5234
5235 /*!
5236   Check existing document.
5237 */
5238 bool LightApp_Application::checkExistingDoc()
5239 {
5240   bool result = true;
5241   if( activeStudy() ) {
5242     int answer = SUIT_MessageBox::question( desktop(),
5243                                             tr( "APPCLOSE_CAPTION" ),
5244                                             tr( "STUDYCLOSE_DESCRIPTION" ),
5245                                             tr( "APPCLOSE_SAVE" ),
5246                                             tr( "APPCLOSE_CLOSE" ),
5247                                             tr( "APPCLOSE_CANCEL" ), 0 );
5248     if(answer == 0) {
5249       if ( activeStudy()->isSaved() ) {
5250         onSaveDoc();
5251         closeDoc( false );
5252       } else if ( onSaveAsDoc() ) {
5253         if( !closeDoc( false ) ) {
5254           result = false;
5255         }
5256       } else {
5257         result = false;
5258       }
5259     }
5260     else if( answer == 1 ) {
5261       closeDoc( false );
5262     } else if( answer == 2 ) {
5263       result = false;
5264     }
5265   }
5266   return result;
5267 }
5268
5269 #ifndef DISABLE_PYCONSOLE
5270
5271 PyConsole_Interp* LightApp_Application::getPyInterp()
5272 {
5273   static PyConsole_Interp* myInterp = 0;
5274   if ( !myInterp ) {
5275     myInterp = createPyInterp();
5276     myInterp->initialize();
5277   }
5278   return myInterp;
5279 }
5280
5281 PyConsole_Interp* LightApp_Application::createPyInterp()
5282 {
5283   return new PyConsole_Interp();
5284 }
5285
5286 #endif // DISABLE_PYCONSOLE