src/LightApp/LightApp_Application.cxx

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