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     ob->treeView()->header()->setSectionResizeMode(SUIT_DataObject::VisibilityId, QHeaderView::Fixed);
2108     ob->treeView()->header()->moveSection(SUIT_DataObject::NameId,SUIT_DataObject::VisibilityId);
2109     ob->treeView()->setColumnWidth(SUIT_DataObject::VisibilityId, VISIBILITY_COLUMN_WIDTH);
2110     ob->setProperty( "shortcut", QKeySequence( "Alt+Shift+O" ) );
2111     wid = ob;
2112     ob->connectPopupRequest( this, SLOT( onConnectPopupRequest( SUIT_PopupClient*, QContextMenuEvent* ) ) );
2113   }
2114 #ifndef DISABLE_PYCONSOLE
2115   else  if ( flag == WT_PyConsole )
2116   {
2117     PyConsole_Console* pyCons = new PyConsole_Console( desktop(), new LightApp_PyEditor( getPyInterp() ) );
2118     pyCons->setObjectName( "pythonConsole" );
2119     pyCons->setWindowTitle( tr( "PYTHON_CONSOLE" ) );
2120     pyCons->setFont( resMgr->fontValue( "PyConsole", "font" ) );
2121     pyCons->setIsShowBanner( resMgr->booleanValue( "PyConsole", "show_banner", true ) );
2122     pyCons->setAutoCompletion( resMgr->booleanValue( "PyConsole", "auto_completion", true ) );
2123     pyCons->setProperty( "shortcut", QKeySequence( "Alt+Shift+P" ) );
2124     wid = pyCons;
2125   }
2126 #endif
2127   else if ( flag == WT_LogWindow )
2128   {
2129     LogWindow* logWin = new LogWindow( desktop() );
2130     logWin->handleQtMessages( true );
2131     logWin->setObjectName( "logWindow" );
2132     logWin->setWindowTitle( tr( "LOG_WINDOW" ) );
2133     logWin->setProperty( "shortcut", QKeySequence( "Alt+Shift+L" ) );
2134     wid = logWin;
2135     logWin->connectPopupRequest( this, SLOT( onConnectPopupRequest( SUIT_PopupClient*, QContextMenuEvent* ) ) );
2136   }
2137   return wid;
2138 }
2139
2140 /*!
2141   \return default windows( Object Browser, Python Console )
2142   Adds to map \a aMap.
2143  */
2144 void LightApp_Application::defaultWindows( QMap<int, int>& aMap ) const
2145 {
2146 #ifndef DISABLE_PYCONSOLE
2147   aMap.insert( WT_PyConsole, Qt::BottomDockWidgetArea );
2148 #endif
2149   if ( activeStudy() ) {
2150     aMap.insert( WT_ObjectBrowser, Qt::LeftDockWidgetArea );
2151     //  aMap.insert( WT_LogWindow, Qt::DockBottom );
2152   }
2153 }
2154
2155 /*!Default view managers*/
2156 void LightApp_Application::defaultViewManagers( QStringList& ) const
2157 {
2158   /*!Do nothing.*/
2159 }
2160
2161 /*!
2162   \return preferences.
2163   Create preferences, if \a crt = true.
2164 */
2165 LightApp_Preferences* LightApp_Application::preferences( const bool crt ) const
2166 {
2167   if ( myPrefs )
2168     return myPrefs;
2169
2170   LightApp_Application* that = (LightApp_Application*)this;
2171
2172   bool toCreate = !_prefs_ && crt;
2173   if ( toCreate )
2174   {
2175     _prefs_ = new LightApp_Preferences( resourceMgr() );
2176     that->createPreferences( _prefs_ );
2177     qAddPostRoutine( LightAppCleanUpAppResources );
2178   }
2179
2180   that->myPrefs = _prefs_;
2181
2182   connect( myPrefs, SIGNAL( preferenceChanged( QString&, QString&, QString& ) ),
2183            this, SLOT( onPreferenceChanged( QString&, QString&, QString& ) ), Qt::UniqueConnection );
2184   connect( myPrefs, SIGNAL( resetToDefaults() ),
2185            this, SIGNAL( preferenceResetToDefaults() ), Qt::UniqueConnection );
2186
2187   if ( !crt )
2188     return myPrefs;
2189
2190   SUIT_ResourceMgr* resMgr = resourceMgr();
2191
2192   QList<SUIT_Application*> appList = SUIT_Session::session()->applications();
2193   for ( QList<SUIT_Application*>::iterator appIt = appList.begin(); appIt != appList.end(); ++appIt )
2194   {
2195     LightApp_Application* app = ::qobject_cast<LightApp_Application*>( *appIt );
2196     if ( !app )
2197       continue;
2198
2199     // all modules available in current session
2200     QStringList names;
2201     app->modules( names, false );
2202
2203     // icons of modules
2204     QMap<QString, QString> icons;
2205     app->moduleIconNames( icons );
2206
2207     // step 1: iterate through list of all available modules
2208     // and add empty preferences page
2209     for ( QStringList::const_iterator it = names.begin(); it != names.end(); ++it )
2210     {
2211       if ( !_prefs_->hasModule( *it ) ) // prevent possible duplications
2212       {
2213         int modId = _prefs_->addPreference( *it ); // add empty page
2214         if ( icons.contains( *it ) )               // set icon
2215           _prefs_->setItemIcon( modId, Qtx::scaleIcon( resMgr->loadPixmap( moduleName( *it ),
2216                                                                            icons[*it], false ), 20 ) );
2217       }
2218     }
2219
2220     // step 2: iterate through list of all loaded modules
2221     // and initialize their preferences
2222     ModuleList loadedModules;
2223     app->modules( loadedModules );
2224     QListIterator<CAM_Module*> itr( loadedModules );
2225     while ( itr.hasNext() )
2226     {
2227       LightApp_Module* module = 0;
2228       CAM_Module* m = itr.next();
2229       if ( m->inherits( "LightApp_Module" ) )
2230         module = (LightApp_Module*)m;
2231
2232       if ( module && !_prefs_->hasModule( module->moduleName() ) )
2233       {
2234         _prefs_->addPreference( module->moduleName() ); // add page (for sure, had to be done at step 1)
2235         module->createPreferences();                    // initialize preferences
2236         that->emptyPreferences( module->moduleName() ); // show dummy page if module does not export any preferences
2237       }
2238     }
2239   }
2240   _prefs_->setItemProperty( "info", tr( "PREFERENCES_NOT_LOADED" ) ); // dummy page for modules which are not loaded yet
2241
2242   return myPrefs;
2243 }
2244
2245 /*!
2246   Adds new module to application
2247 */
2248 void LightApp_Application::moduleAdded( CAM_Module* mod )
2249 {
2250   CAM_Application::moduleAdded( mod );
2251
2252   LightApp_Module* lightMod = 0;
2253   if ( mod && mod->inherits( "LightApp_Module" ) )
2254     lightMod = (LightApp_Module*)mod;
2255
2256   if ( myPrefs && lightMod && !myPrefs->hasModule( lightMod->moduleName() ))
2257   {
2258     myPrefs->addPreference( mod->moduleName() );
2259     lightMod->createPreferences();
2260     emptyPreferences( mod->moduleName() );
2261   }
2262 }
2263
2264 void LightApp_Application::emptyPreferences( const QString& modName )
2265 {
2266   QtxPreferenceItem* item = myPrefs->findItem( modName, true );
2267   if ( !item || !item->isEmpty() )
2268     return;
2269
2270   QtxPagePrefFrameItem* frm = new QtxPagePrefFrameItem( item->title(), item->parentItem() );
2271   frm->setIcon( item->icon() );
2272   frm->setStretch( false );
2273   item->parentItem()->insertItem( frm, item );
2274   new QtxPagePrefLabelItem( Qt::AlignCenter, tr( "PREFERENCES_NOT_SUPPORTED" ).arg( modName ), frm );
2275   delete item;
2276 }
2277
2278 /*!
2279   Create preferences
2280 */
2281 void LightApp_Application::createPreferences( LightApp_Preferences* pref )
2282 {
2283   if ( !pref )
2284     return;
2285
2286   QStringList     aValuesList;
2287   QList<QVariant> anIndicesList;
2288   QIntList        idList;
2289   QIntList        txtList;
2290
2291   // . Top-level "SALOME" preferences group <<start>>
2292   int salomeCat = pref->addPreference( tr( "PREF_CATEGORY_SALOME" ) );
2293   pref->setItemIcon( salomeCat, Qtx::scaleIcon( resourceMgr()->loadPixmap( "LightApp", tr( "APP_DEFAULT_ICO" ), false ), 20 ) );
2294
2295   // .. "General" preferences tab <<start>>
2296   int genTab = pref->addPreference( tr( "PREF_TAB_GENERAL" ), salomeCat );
2297
2298   // ... "Language" group <<start>>
2299   int langGroup = pref->addPreference( tr( "PREF_GROUP_LANGUAGE" ), genTab );
2300   pref->setItemProperty( "columns", 2, langGroup );
2301   // .... -> application language
2302   int curLang = pref->addPreference( tr( "PREF_CURRENT_LANGUAGE" ), langGroup,
2303                                           LightApp_Preferences::Selector, "language", "language" );
2304   QStringList aLangs = SUIT_Session::session()->resourceMgr()->stringValue( "language", "languages", "en" ).split( "," );
2305   QList<QVariant> aIcons;
2306   QList<QVariant> aNumbers;
2307   QStringList aTitles;
2308   foreach ( QString aLang, aLangs ) {
2309     aIcons << QPixmap( QString( ":/images/%1" ).arg( aLang ) );
2310     aNumbers << aLang;
2311     aTitles << langToName( aLang );
2312   }
2313   pref->setItemProperty( "strings", aTitles, curLang );
2314   pref->setItemProperty( "ids",     aNumbers, curLang );
2315   pref->setItemProperty( "icons",   aIcons, curLang );
2316   pref->setItemProperty( "restart",  true, curLang );
2317
2318   int curLocale = pref->addPreference( tr( "PREF_CURRENT_LOCALE" ), langGroup,
2319                                           LightApp_Preferences::Bool, "language", "locale" );
2320   pref->setItemProperty( "restart",  true, curLocale );
2321   // ... "Language" group <<end>>
2322
2323   // ... "Look and feel" group <<start>>
2324   int lookGroup = pref->addPreference( tr( "PREF_GROUP_LOOK_AND_FEEL" ), genTab );
2325   pref->setItemProperty( "columns", 2, lookGroup );
2326   // .... -> show splash-screen
2327   pref->addPreference( tr( "PREF_SHOW_SPLASH" ), lookGroup, LightApp_Preferences::Bool, "launch", "splash" );
2328   // .... -> opaque resize
2329   pref->addPreference( tr( "PREF_OPAQUE_RESIZE" ), lookGroup, LightApp_Preferences::Bool, "desktop", "opaque_resize" );
2330   // .... -> drop-down buttons
2331   pref->addPreference( tr( "PREF_DROP_DOWN_BUTTONS" ), lookGroup, LightApp_Preferences::Bool, "viewers", "drop_down_buttons" );
2332   // .... -> Notification timeout
2333   int delay = pref->addPreference( tr( "PREF_NOTIFY_TIMEOUT" ), lookGroup, LightApp_Preferences::IntSpin, "notification", "timeout" );
2334   pref->setItemProperty( "special", tr("PREF_NOTIFY_TIMEOUT_NONE"), delay );
2335   pref->setItemProperty( "min", 0, delay );
2336   pref->setItemProperty( "max", 100, delay );
2337   pref->setItemProperty( "suffix", " sec", delay );
2338   // ... "Look and feel" group <<end>>
2339
2340   // ... "Study properties" group <<start>>
2341   int studyGroup = pref->addPreference( tr( "PREF_GROUP_STUDY" ), genTab );
2342   pref->setItemProperty( "columns", 2, studyGroup );
2343   // .... -> multi-file save
2344   pref->addPreference( tr( "PREF_MULTI_FILE" ), studyGroup, LightApp_Preferences::Bool, "Study", "multi_file" );
2345   // .... -> ascii save mode
2346   pref->addPreference( tr( "PREF_ASCII_FILE" ), studyGroup, LightApp_Preferences::Bool, "Study", "ascii_file" );
2347   // .... -> store windows geometry
2348   pref->addPreference( tr( "PREF_LOAD_LIGHT" ), studyGroup, LightApp_Preferences::Bool, "Study", "autoload_light_modules" );
2349   pref->addPreference( tr( "PREF_STORE_POS" ),  studyGroup, LightApp_Preferences::Bool, "Study", "store_positions" );
2350   pref->addPreference( "", studyGroup, LightApp_Preferences::Space );
2351   pref->addPreference( tr( "PREF_STORE_TOOL_POS" ),  studyGroup, LightApp_Preferences::Bool, "Study", "store_tool_positions" );
2352   // .... -> auto-save
2353   int autoSaveInterval = pref->addPreference( tr( "PREF_AUTO_SAVE" ),  studyGroup,
2354                                               LightApp_Preferences::IntSpin, "Study", "auto_save_interval" );
2355   pref->setItemProperty( "min",        0, autoSaveInterval );
2356   pref->setItemProperty( "max",     1440, autoSaveInterval );
2357   pref->setItemProperty( "special", tr( "PREF_AUTO_SAVE_DISABLED" ), autoSaveInterval );
2358   // ... "Study properties" group <<end>>
2359
2360   // ... "Help browser" group <<start>>
2361 #ifndef DISABLE_QTXWEBBROWSER
2362   int extgroup = pref->addPreference( tr( "PREF_GROUP_EXT_BROWSER" ), genTab, LightApp_Preferences::Auto, "ExternalBrowser", "use_external_browser");
2363 #else
2364   int extgroup = pref->addPreference( tr( "PREF_GROUP_EXT_BROWSER" ), genTab );
2365 #endif
2366
2367 #ifdef WIN32
2368   QString platform = "winapplication";
2369 #else
2370   QString platform = "application";
2371 #endif
2372   // .... -> browser application
2373   int apppref = pref->addPreference( tr( "PREF_APP" ), extgroup, LightApp_Preferences::File, "ExternalBrowser", platform );
2374   pref->setItemProperty( "mode", Qtx::PT_OpenFile, apppref );
2375   // .... -> browser parameters
2376   pref->addPreference( tr( "PREF_PARAM" ), extgroup, LightApp_Preferences::String, "ExternalBrowser", "parameters" );
2377   // ... "Help browser" group <<end>>
2378
2379   // ... "Python console properties" group <<start>>
2380   int pythonConsoleGroup = pref->addPreference( tr( "PREF_GROUP_PY_CONSOLE" ), genTab );
2381   pref->setItemProperty( "columns", 2, pythonConsoleGroup );
2382   // .... -> font
2383   pref->addPreference( tr( "PREF_FONT" ), pythonConsoleGroup, LightApp_Preferences::Font, "PyConsole", "font" );
2384   // .... -> show banner
2385   pref->addPreference( tr( "PREF_SHOW_BANNER" ), pythonConsoleGroup, LightApp_Preferences::Bool, "PyConsole", "show_banner" );
2386   // .... -> auto-completion
2387   pref->addPreference( tr( "PREF_AUTO_COMPLETION" ), pythonConsoleGroup, LightApp_Preferences::Bool, "PyConsole", "auto_completion" );
2388   // ... "Python console properties" group <<end>>
2389
2390   // ... "MRU" preferences group <<start>>
2391   int mruGroup = pref->addPreference( tr( "PREF_GROUP_MRU" ), genTab, LightApp_Preferences::Auto, "MRU", "show_mru" );
2392   pref->setItemProperty( "columns", 4, mruGroup );
2393   // number of MRU items
2394   int mruVisCount = pref->addPreference( tr( "PREF_MRU_VISIBLE_COUNT" ), mruGroup, LightApp_Preferences::IntSpin,
2395                                          "MRU", "visible_count" );
2396   pref->setItemProperty( "min", 0,   mruVisCount );
2397   pref->setItemProperty( "max", 100, mruVisCount );
2398   // MRU links type
2399   int mruLinkType = pref->addPreference( tr( "PREF_MRU_LINK_TYPE" ), mruGroup, LightApp_Preferences::Selector,
2400                                          "MRU", "link_type" );
2401   aValuesList.clear();
2402   anIndicesList.clear();
2403   aValuesList   << tr("PREF_MRU_LINK_AUTO") << tr("PREF_MRU_LINK_SHORT") << tr("PREF_MRU_LINK_FULL");
2404   anIndicesList << 0                        << 1                         << 2                       ;
2405   pref->setItemProperty( "strings", aValuesList,   mruLinkType );
2406   pref->setItemProperty( "indexes", anIndicesList, mruLinkType );
2407   // ... "MRU" preferences group <<end>>
2408
2409   // ... "Full-screen" group <<start>>
2410   int fullScreenGroup = pref->addPreference( tr( "PREF_GROUP_FULL_SCREEN" ), genTab );
2411   pref->setItemProperty( "columns", 2, fullScreenGroup );
2412   // .... -> automatic hiding toolbars
2413   pref->addPreference( tr( "PREF_FULL_SCREEN_AUTO" ), fullScreenGroup,
2414                        LightApp_Preferences::Bool, "OCCViewer", "automatic_hiding" );
2415   // ... "Full-screen" group <<end>>
2416
2417   // .. "General" preferences tab <<end>>
2418
2419   // .. "3D viewer" group <<start>>
2420   int Viewer3DGroup = pref->addPreference( tr( "PREF_GROUP_3DVIEWER" ), salomeCat );
2421   // ... -> navigation mode
2422   int vtkStyleMode = pref->addPreference( tr( "PREF_NAVIGATION" ), Viewer3DGroup,
2423                                           LightApp_Preferences::Selector, "3DViewer", "navigation_mode" );
2424   aValuesList.clear();
2425   anIndicesList.clear();
2426   aValuesList   << tr("PREF_STANDARD_STYLE") << tr("PREF_KEYFREE_STYLE");
2427   anIndicesList << 0                         << 1;
2428   pref->setItemProperty( "strings", aValuesList,   vtkStyleMode );
2429   pref->setItemProperty( "indexes", anIndicesList, vtkStyleMode );
2430   // ... -> zooming mode
2431   int occZoomingStyleMode = pref->addPreference( tr( "PREF_ZOOMING" ), Viewer3DGroup,
2432                                                  LightApp_Preferences::Selector, "3DViewer", "zooming_mode" );
2433   aValuesList.clear();
2434   anIndicesList.clear();
2435   aValuesList   << tr("PREF_ZOOMING_AT_CENTER") << tr("PREF_ZOOMING_AT_CURSOR");
2436   anIndicesList << 0                            << 1;
2437   pref->setItemProperty( "strings", aValuesList,   occZoomingStyleMode );
2438   pref->setItemProperty( "indexes", anIndicesList, occZoomingStyleMode );
2439   // ... "Trihedron" group <<start>>
2440   int occTriGroup = pref->addPreference( tr( "PREF_TRIHEDRON" ), Viewer3DGroup );
2441   pref->setItemProperty( "columns", 2, occTriGroup );
2442   // .... -> trihedron size
2443   int occTS = pref->addPreference( tr( "PREF_TRIHEDRON_SIZE" ), occTriGroup,
2444                                    LightApp_Preferences::DblSpin, "3DViewer", "trihedron_size" );
2445   pref->setItemProperty( "min", 1.0E-06, occTS );
2446   pref->setItemProperty( "max", 1000, occTS );
2447   // .... -> relative size of trihedron
2448   pref->addPreference( tr( "PREF_RELATIVE_SIZE" ), occTriGroup, LightApp_Preferences::Bool, "3DViewer", "relative_size" );
2449   // .... -> show static trihedron
2450   pref->addPreference( tr( "PREF_SHOW_STATIC_TRIHEDRON" ), occTriGroup, LightApp_Preferences::Bool, "3DViewer", "show_static_trihedron" );
2451   // ... "Trihedron" group <<end>>
2452   // .. "3D viewer" group <<end>>
2453
2454   QString formats;
2455   int bgId;
2456 #ifndef DISABLE_OCCVIEWER
2457   // .. "OCC viewer" group <<start>>
2458   int occGroup = pref->addPreference( tr( "PREF_GROUP_OCCVIEWER" ), salomeCat );
2459
2460   // .... -> Projection mode
2461   int occProjMode = pref->addPreference( tr( "PREF_PROJECTION_MODE" ), occGroup,
2462                                          LightApp_Preferences::Selector, "OCCViewer", "projection_mode" );
2463   aValuesList.clear();
2464   anIndicesList.clear();
2465   aValuesList   << tr("PREF_ORTHOGRAPHIC") << tr("PREF_PERSPECTIVE");
2466   anIndicesList << 0                       << 1;
2467   pref->setItemProperty( "strings", aValuesList,   occProjMode );
2468   pref->setItemProperty( "indexes", anIndicesList, occProjMode );
2469
2470   // .... -> Stereo group
2471   int stereoGroup = pref->addPreference( tr( "PREF_GROUP_STEREO" ), occGroup);
2472   pref->setItemProperty( "columns", 2, stereoGroup );
2473   // .... -> Stereo type
2474   int stereoType = pref->addPreference( tr( "PREF_STEREO_TYPE" ), stereoGroup,
2475                                             LightApp_Preferences::Selector, "OCCViewer", "stereo_type" );
2476   aValuesList.clear();
2477   anIndicesList.clear();
2478   idList.clear();
2479   OCCViewer_Viewer::stereoData( aValuesList, idList);
2480   foreach( int gid, idList ) anIndicesList << gid;
2481   pref->setItemProperty( "strings", aValuesList,   stereoType );
2482   pref->setItemProperty( "indexes", anIndicesList, stereoType );
2483
2484   // .... -> Anaglyph filter
2485   int anaglyphFilter = pref->addPreference( tr( "PREF_ANAGLYPH_FILTER" ), stereoGroup,
2486                                             LightApp_Preferences::Selector, "OCCViewer", "anaglyph_filter" );
2487   aValuesList.clear();
2488   anIndicesList.clear();
2489   aValuesList   << tr("PREF_ANAGLYPH_RED_CYAN") << tr("PREF_ANAGLYPH_YELLOW_BLUE") << tr("PREF_ANAGLYPH_GREEN_MAGENTA");
2490   anIndicesList << 0                            << 1                               << 2;
2491
2492   pref->setItemProperty( "strings", aValuesList,   anaglyphFilter );
2493   pref->setItemProperty( "indexes", anIndicesList, anaglyphFilter );
2494
2495   // .... -> Convergence distance type
2496   int occFocusType = pref->addPreference( tr( "PREF_FOCUS_TYPE" ), stereoGroup,
2497                                            LightApp_Preferences::Selector, "OCCViewer", "focus_type" );
2498   aValuesList.clear();
2499   anIndicesList.clear();
2500   aValuesList   << tr("PREF_ABSOLUTE") << tr("PREF_RELATIVE");
2501   anIndicesList << 0                   << 1;
2502   pref->setItemProperty( "strings", aValuesList,   occFocusType );
2503   pref->setItemProperty( "indexes", anIndicesList, occFocusType );
2504
2505   // .... -> Stereographic focus value
2506   int focusValue = pref->addPreference( tr( "PREF_FOCUS_VALUE" ), stereoGroup,
2507                LightApp_Preferences::DblSpin, "OCCViewer", "focus_value" );
2508   pref->setItemProperty( "precision", 3, focusValue );
2509   pref->setItemProperty( "min", 1.0E-03, focusValue );
2510   pref->setItemProperty( "max", 1.0E03, focusValue );
2511   pref->setItemProperty( "step", 0.05, focusValue );
2512
2513   // .... -> IOD type
2514   int occIODType = pref->addPreference( tr( "PREF_IOD_TYPE" ), stereoGroup,
2515                                            LightApp_Preferences::Selector, "OCCViewer", "iod_type" );
2516   aValuesList.clear();
2517   anIndicesList.clear();
2518   aValuesList   << tr("PREF_ABSOLUTE") << tr("PREF_RELATIVE");
2519   anIndicesList << 0                   << 1;
2520   pref->setItemProperty( "strings", aValuesList,   occIODType );
2521   pref->setItemProperty( "indexes", anIndicesList, occIODType );
2522
2523   // .... -> Interocular distance (IOD) value
2524   int IODValue = pref->addPreference( tr( "PREF_IOD_VALUE" ), stereoGroup,
2525                                       LightApp_Preferences::DblSpin, "OCCViewer", "iod_value" );
2526   pref->setItemProperty( "precision", 3, IODValue );
2527   pref->setItemProperty( "min", 1.0E-03, IODValue );
2528   pref->setItemProperty( "max", 1.0E03, IODValue );
2529   pref->setItemProperty( "step", 0.05, IODValue );
2530
2531   // .... -> Reverse stereo
2532   pref->addPreference( tr( "PREF_REVERSE_STEREO" ), stereoGroup,
2533                        LightApp_Preferences::Bool, "OCCViewer", "reverse_stereo" );
2534   // .... -> Enable V-Sync
2535   pref->addPreference( tr( "PREF_ENABLE_VSYNC" ), stereoGroup,
2536                        LightApp_Preferences::Bool, "OCCViewer", "enable_vsync" );
2537   // .... -> Enable quad-buffer support
2538   pref->addPreference( tr( "PREF_ENABLE_QUAD_BUFFER_SUPPORT" ), stereoGroup,
2539                        LightApp_Preferences::Bool, "OCCViewer", "enable_quad_buffer_support" );
2540
2541   // ... "Background" group <<start>>
2542   int bgGroup = pref->addPreference( tr( "PREF_VIEWER_BACKGROUND" ), occGroup );
2543   //  pref->setItemProperty( "columns", 2, bgGroup );
2544   aValuesList.clear();
2545   anIndicesList.clear();
2546   txtList.clear();
2547   idList.clear();
2548   formats = OCCViewer_Viewer::backgroundData( aValuesList, idList, txtList );
2549   foreach( int gid, idList ) anIndicesList << gid;
2550   // .... -> 3D viewer background
2551   bgId = pref->addPreference( tr( "PREF_3DVIEWER_BACKGROUND" ), bgGroup,
2552                                   LightApp_Preferences::Background, "OCCViewer", "background" );
2553   pref->setItemProperty( "gradient_names", aValuesList, bgId );
2554   pref->setItemProperty( "gradient_ids", anIndicesList, bgId );
2555   pref->setItemProperty( "texture_enabled", !txtList.isEmpty(), bgId );
2556   pref->setItemProperty( "texture_center_enabled", (bool)txtList.contains( Qtx::CenterTexture ), bgId );
2557   pref->setItemProperty( "texture_tile_enabled", (bool)txtList.contains( Qtx::TileTexture ), bgId );
2558   pref->setItemProperty( "texture_stretch_enabled", (bool)txtList.contains( Qtx::StretchTexture ), bgId );
2559   pref->setItemProperty( "custom_enabled", false, bgId );
2560   pref->setItemProperty( "image_formats", formats, bgId );
2561   // .... -> XZ viewer background
2562   bgId = pref->addPreference( tr( "PREF_XZVIEWER_BACKGROUND" ), bgGroup,
2563                               LightApp_Preferences::Background, "OCCViewer", "xz_background" );
2564   pref->setItemProperty( "gradient_names", aValuesList, bgId );
2565   pref->setItemProperty( "gradient_ids", anIndicesList, bgId );
2566   pref->setItemProperty( "texture_enabled", !txtList.isEmpty(), bgId );
2567   pref->setItemProperty( "texture_center_enabled", (bool)txtList.contains( Qtx::CenterTexture ), bgId );
2568   pref->setItemProperty( "texture_tile_enabled", (bool)txtList.contains( Qtx::TileTexture ), bgId );
2569   pref->setItemProperty( "texture_stretch_enabled", (bool)txtList.contains( Qtx::StretchTexture ), bgId );
2570   pref->setItemProperty( "custom_enabled", false, bgId );
2571   pref->setItemProperty( "image_formats", formats, bgId );
2572   // .... -> YZ viewer background
2573   bgId = pref->addPreference( tr( "PREF_YZVIEWER_BACKGROUND" ), bgGroup,
2574                               LightApp_Preferences::Background, "OCCViewer", "yz_background" );
2575   pref->setItemProperty( "gradient_names", aValuesList, bgId );
2576   pref->setItemProperty( "gradient_ids", anIndicesList, bgId );
2577   pref->setItemProperty( "texture_enabled", !txtList.isEmpty(), bgId );
2578   pref->setItemProperty( "texture_center_enabled", (bool)txtList.contains( Qtx::CenterTexture ), bgId );
2579   pref->setItemProperty( "texture_tile_enabled", (bool)txtList.contains( Qtx::TileTexture ), bgId );
2580   pref->setItemProperty( "texture_stretch_enabled", (bool)txtList.contains( Qtx::StretchTexture ), bgId );
2581   pref->setItemProperty( "custom_enabled", false, bgId );
2582   pref->setItemProperty( "image_formats", formats, bgId );
2583   // .... -> XY viewer background
2584   bgId = pref->addPreference( tr( "PREF_XYVIEWER_BACKGROUND" ), bgGroup,
2585                               LightApp_Preferences::Background, "OCCViewer", "xy_background" );
2586   pref->setItemProperty( "gradient_names", aValuesList, bgId );
2587   pref->setItemProperty( "gradient_ids", anIndicesList, bgId );
2588   pref->setItemProperty( "texture_enabled", !txtList.isEmpty(), bgId );
2589   pref->setItemProperty( "texture_center_enabled", (bool)txtList.contains( Qtx::CenterTexture ), bgId );
2590   pref->setItemProperty( "texture_tile_enabled", (bool)txtList.contains( Qtx::TileTexture ), bgId );
2591   pref->setItemProperty( "texture_stretch_enabled", (bool)txtList.contains( Qtx::StretchTexture ), bgId );
2592   pref->setItemProperty( "custom_enabled", false, bgId );
2593   pref->setItemProperty( "image_formats", formats, bgId );
2594   // ... "Background" group <<end>>
2595
2596
2597   // ... "Selection" group <<start>>
2598   int occSelectionGroup = pref->addPreference( tr( "PREF_GROUP_SELECTION" ), occGroup );
2599   pref->setItemProperty( "columns", 2, occSelectionGroup );
2600   // .... -> enable preselection
2601   pref->addPreference( tr( "PREF_ENABLE_PRESELECTION" ), occSelectionGroup,
2602                        LightApp_Preferences::Bool, "OCCViewer", "enable_preselection" );
2603   // .... -> enable selection
2604   pref->addPreference( tr( "PREF_ENABLE_SELECTION" ), occSelectionGroup,
2605                        LightApp_Preferences::Bool, "OCCViewer", "enable_selection" );
2606   // ... "Selection" group <<end>>
2607
2608   // ... "Clipping" group <<start>>
2609   int occClippingGroup = pref->addPreference( tr( "PREF_GROUP_CLIPPING" ), occGroup );
2610   // .... -> clipping color
2611   pref->addPreference( tr( "PREF_CLIPPING_COLOR" ), occClippingGroup,
2612                        LightApp_Preferences::Color, "OCCViewer", "clipping_color" );
2613   int texturePref = pref->addPreference( "", occClippingGroup, LightApp_Preferences::Frame );
2614   pref->setItemProperty( "columns", 2, texturePref );
2615   // .... -> use default texture
2616   pref->addPreference( tr( "PREF_CLIPPING_DEFAULT_TEXTURE" ), texturePref,
2617                LightApp_Preferences::Bool, "OCCViewer", "clipping_use_default_texture" );
2618   // .... -> clipping texture
2619   int filePref = pref->addPreference( tr( "PREF_CLIPPING_TEXTURE" ), texturePref,
2620                LightApp_Preferences::File, "OCCViewer", "clipping_texture" );
2621   pref->setItemProperty( "path_filter", tr( "OCC_TEXTURE_FILES" ), filePref );
2622   // .... -> modulate
2623   pref->addPreference( tr( "PREF_CLIPPING_MODULATE" ), texturePref,
2624                LightApp_Preferences::Bool, "OCCViewer", "clipping_modulate" );
2625   // .... -> scale factor
2626   int scaleFactor = pref->addPreference( tr( "PREF_CLIPPING_SCALE" ), texturePref,
2627                LightApp_Preferences::DblSpin, "OCCViewer", "clipping_scale" );
2628   pref->setItemProperty( "precision", 3, scaleFactor );
2629   pref->setItemProperty( "min", 1.0E-03, scaleFactor );
2630   pref->setItemProperty( "max", 1.0E03, scaleFactor );
2631   pref->setItemProperty( "step", 0.1, scaleFactor );
2632   // ... "Clipping" group <<end>>
2633
2634   // ... "Ray tracing" group <<start>>
2635   int occRayTracingGroup = pref->addPreference( tr( "PREF_GROUP_RAY_TRACING" ), occGroup );
2636   int rtPref = pref->addPreference( "", occRayTracingGroup, LightApp_Preferences::Frame );
2637   pref->setItemProperty( "columns", 2, rtPref );
2638   // .... -> depth
2639   int rt_depth = pref->addPreference( tr( "PREF_RAY_TRACING_DEPTH" ), rtPref,
2640                LightApp_Preferences::IntSpin, "OCCViewer", "rt_depth" );
2641   pref->setItemProperty( "min", 1, rt_depth );
2642   pref->setItemProperty( "max", 10, rt_depth );
2643   pref->setItemProperty( "step", 1, rt_depth );
2644   pref->addPreference( "", rtPref, LightApp_Preferences::Frame );
2645   // .... -> specular reflections
2646   pref->addPreference( tr( "PREF_RAY_TRACING_REFLECTION" ), rtPref,
2647                LightApp_Preferences::Bool, "OCCViewer", "rt_reflection" );
2648   // .... -> adaptive anti-aliasing
2649   pref->addPreference( tr( "PREF_RAY_TRACING_ANTIALIASING" ), rtPref,
2650                LightApp_Preferences::Bool, "OCCViewer", "rt_antialiasing" );
2651   // .... -> shadows rendering
2652   pref->addPreference( tr( "PREF_RAY_TRACING_SHADOW" ), rtPref,
2653                LightApp_Preferences::Bool, "OCCViewer", "rt_shadow" );
2654   // .... -> transparent shadow
2655   pref->addPreference( tr( "PREF_RAY_TRACING_TRANS_SHADOW" ), rtPref,
2656                LightApp_Preferences::Bool, "OCCViewer", "rt_trans_shadow" );
2657   // ... "Ray tracing" group <<end>>
2658
2659   // ... "Light source" group <<start>>
2660   int occLightGroup = pref->addPreference( tr( "PREF_GROUP_LIGHT" ), occGroup );
2661   // .... -> light color
2662   pref->addPreference( tr( "PREF_LIGHT_COLOR" ), occLightGroup,
2663                LightApp_Preferences::Color, "OCCViewer", "light_color" );
2664   int directionPref = pref->addPreference( "", occLightGroup, LightApp_Preferences::Frame );
2665   pref->setItemProperty( "columns", 3, directionPref );
2666   // .... -> light direction (dx component)
2667   int light_dx = pref->addPreference( tr( "Dx" ), directionPref,
2668                LightApp_Preferences::DblSpin, "OCCViewer", "light_dx" );
2669   pref->setItemProperty( "precision", 2, light_dx );
2670   pref->setItemProperty( "min", -1.0E03, light_dx );
2671   pref->setItemProperty( "max", 1.0E03, light_dx );
2672   pref->setItemProperty( "step", 0.1, light_dx );
2673   // .... -> light direction (dy component)
2674   int light_dy = pref->addPreference( tr( "Dy" ), directionPref,
2675                LightApp_Preferences::DblSpin, "OCCViewer", "light_dy" );
2676   pref->setItemProperty( "precision", 2, light_dy );
2677   pref->setItemProperty( "min", -1.0E03, light_dy );
2678   pref->setItemProperty( "max", 1.0E03, light_dy );
2679   pref->setItemProperty( "step", 0.1, light_dy );
2680   // .... -> light direction (dz component)
2681   int light_dz = pref->addPreference( tr( "Dz" ), directionPref,
2682                LightApp_Preferences::DblSpin, "OCCViewer", "light_dz" );
2683   pref->setItemProperty( "precision", 2, light_dz );
2684   pref->setItemProperty( "min", -1.0E03, light_dz );
2685   pref->setItemProperty( "max", 1.0E03, light_dz );
2686   pref->setItemProperty( "step", 0.1, light_dz );
2687   // ... "Light source" group <<end>>
2688
2689   // ... -> empty frame (for layout) <<start>>
2690   int occGen = pref->addPreference( "", occGroup, LightApp_Preferences::Frame );
2691   pref->setItemProperty( "margin",  0, occGen );
2692   pref->setItemProperty( "columns", 2, occGen );
2693   // ... -> empty frame (for layout) <<end>>
2694
2695   // .. "OCC viewer" group <<end>>
2696 #endif
2697
2698 #ifndef DISABLE_VTKVIEWER
2699   // .. "VTK viewer" group <<start>>
2700   int vtkGroup = pref->addPreference( tr( "PREF_GROUP_VTKVIEWER" ), salomeCat ); //viewTab
2701
2702   // ... -> empty frame (for layout) <<start>>
2703   int vtkGen = pref->addPreference( "", vtkGroup, LightApp_Preferences::Frame );
2704   //pref->setItemProperty( "columns", 2, vtkGen );
2705   // .... -> projection mode
2706   int vtkProjMode = pref->addPreference( tr( "PREF_PROJECTION_MODE" ), vtkGen,
2707                                          LightApp_Preferences::Selector, "VTKViewer", "projection_mode" );
2708   aValuesList.clear();
2709   anIndicesList.clear();
2710   aValuesList   << tr("PREF_ORTHOGRAPHIC") << tr("PREF_PERSPECTIVE");
2711   anIndicesList << 0                       << 1;
2712   pref->setItemProperty( "strings", aValuesList,   vtkProjMode );
2713   pref->setItemProperty( "indexes", anIndicesList, vtkProjMode );
2714
2715   // .... -> Stereo group
2716   int vtkStereoGroup = pref->addPreference( tr( "PREF_GROUP_STEREO" ), vtkGroup);
2717   pref->setItemProperty( "columns", 2, vtkStereoGroup );
2718   // .... -> Stereo type
2719   int vtkStereoType = pref->addPreference( tr( "PREF_STEREO_TYPE" ), vtkStereoGroup,
2720                                            LightApp_Preferences::Selector, "VTKViewer", "stereo_type" );
2721   aValuesList.clear();
2722   anIndicesList.clear();
2723   idList.clear();
2724   SVTK_Viewer::stereoData( aValuesList, idList);
2725   foreach( int gid, idList ) anIndicesList << gid;
2726   pref->setItemProperty( "strings", aValuesList,   vtkStereoType );
2727   pref->setItemProperty( "indexes", anIndicesList, vtkStereoType );
2728   // .... -> Anaglyph filter
2729   int vtkAnaglyphFilter = pref->addPreference( tr( "PREF_ANAGLYPH_FILTER" ), vtkStereoGroup,
2730                                                LightApp_Preferences::Selector, "VTKViewer", "anaglyph_filter" );
2731   aValuesList.clear();
2732   anIndicesList.clear();
2733   aValuesList   << tr("PREF_ANAGLYPH_RED_CYAN") << tr("PREF_ANAGLYPH_YELLOW_BLUE") << tr("PREF_ANAGLYPH_GREEN_MAGENTA");
2734   anIndicesList << 0                            << 1                               << 2;
2735
2736   pref->setItemProperty( "strings", aValuesList,   vtkAnaglyphFilter );
2737   pref->setItemProperty( "indexes", anIndicesList, vtkAnaglyphFilter );
2738
2739   // .... -> Enable quad-buffer support
2740   pref->addPreference( tr( "PREF_ENABLE_QUAD_BUFFER_SUPPORT" ), vtkStereoGroup,
2741                        LightApp_Preferences::Bool, "VTKViewer", "enable_quad_buffer_support" );
2742
2743   // .... -> background
2744   aValuesList.clear();
2745   anIndicesList.clear();
2746   txtList.clear();
2747   idList.clear();
2748 #ifndef DISABLE_SALOMEOBJECT
2749   formats = SVTK_Viewer::backgroundData( aValuesList, idList, txtList );
2750 #endif
2751   foreach( int gid, idList ) anIndicesList << gid;
2752   bgId = pref->addPreference( tr( "PREF_VIEWER_BACKGROUND" ), vtkGen,
2753                               LightApp_Preferences::Background, "VTKViewer", "background" );
2754   pref->setItemProperty( "gradient_names", aValuesList, bgId );
2755   pref->setItemProperty( "gradient_ids", anIndicesList, bgId );
2756   pref->setItemProperty( "texture_enabled", !txtList.isEmpty(), bgId );
2757   pref->setItemProperty( "texture_center_enabled", (bool)txtList.contains( Qtx::CenterTexture ), bgId );
2758   pref->setItemProperty( "texture_tile_enabled", (bool)txtList.contains( Qtx::TileTexture ), bgId );
2759   pref->setItemProperty( "texture_stretch_enabled", (bool)txtList.contains( Qtx::StretchTexture ), bgId );
2760   pref->setItemProperty( "custom_enabled", false, bgId );
2761 #ifndef DISABLE_SALOMEOBJECT
2762   pref->setItemProperty( "image_formats", formats, bgId );
2763 #endif
2764   // .... -> speed increment
2765   int vtkSpeed = pref->addPreference( tr( "PREF_INCREMENTAL_SPEED" ), vtkGen,
2766                                       LightApp_Preferences::IntSpin, "VTKViewer", "speed_value" );
2767   pref->setItemProperty( "min", 1, vtkSpeed );
2768   pref->setItemProperty( "max", 1000, vtkSpeed );
2769   // .... -> speed mode
2770   int vtkSpeedMode = pref->addPreference( tr( "PREF_INCREMENTAL_SPEED_MODE" ), vtkGen,
2771                                           LightApp_Preferences::Selector, "VTKViewer", "speed_mode" );
2772   aValuesList.clear();
2773   anIndicesList.clear();
2774   aValuesList   << tr("PREF_ARITHMETIC") << tr("PREF_GEOMETRICAL");
2775   anIndicesList << 0                     << 1;
2776   pref->setItemProperty( "strings", aValuesList,   vtkSpeedMode );
2777   pref->setItemProperty( "indexes", anIndicesList, vtkSpeedMode );
2778
2779   // ... "Selection" group <<start>>
2780   int vtkSelectionGroup = pref->addPreference( tr( "PREF_GROUP_SELECTION" ), vtkGroup );
2781   pref->setItemProperty( "columns", 2, vtkSelectionGroup );
2782   // .... -> preselection
2783   int vtkPreselection = pref->addPreference( tr( "PREF_PRESELECTION" ),  vtkSelectionGroup,
2784                                              LightApp_Preferences::Selector, "VTKViewer", "preselection" );
2785   aValuesList.clear();
2786   anIndicesList.clear();
2787   aValuesList   << tr("PREF_PRESELECTION_STANDARD") << tr("PREF_PRESELECTION_DYNAMIC") << tr("PREF_PRESELECTION_DISABLED");
2788   anIndicesList << 0 << 1 << 2;
2789   pref->setItemProperty( "strings", aValuesList,   vtkPreselection );
2790   pref->setItemProperty( "indexes", anIndicesList, vtkPreselection );
2791   // .... -> enable selection
2792   pref->addPreference( tr( "PREF_ENABLE_SELECTION" ), vtkSelectionGroup, LightApp_Preferences::Bool, "VTKViewer", "enable_selection" );
2793   // ... "Selection" group <<end>>
2794
2795   // ... -> empty frame (for layout) <<end>>
2796
2797   // ... space mouse sub-group <<start>>
2798   int vtkSM = pref->addPreference( tr( "PREF_FRAME_SPACEMOUSE" ), vtkGroup, LightApp_Preferences::GroupBox );
2799   //pref->setItemProperty( "columns", 2, vtkSM );
2800   // .... -> decrease speed increment
2801   int spacemousePref1 = pref->addPreference( tr( "PREF_SPACEMOUSE_FUNC_1" ), vtkSM,
2802                                              LightApp_Preferences::Selector, "VTKViewer",
2803                                              "spacemouse_func1_btn" );
2804   // .... -> increase speed increment
2805   int spacemousePref2 = pref->addPreference( tr( "PREF_SPACEMOUSE_FUNC_2" ), vtkSM,
2806                                              LightApp_Preferences::Selector, "VTKViewer",
2807                                              "spacemouse_func2_btn" );
2808   // .... -> dominant / combined switch
2809   int spacemousePref3 = pref->addPreference( tr( "PREF_SPACEMOUSE_FUNC_3" ), vtkSM,
2810                                              LightApp_Preferences::Selector, "VTKViewer",
2811                                              "spacemouse_func5_btn" ); //
2812   aValuesList.clear();
2813   anIndicesList.clear();
2814   aValuesList << tr( "PREF_SPACEMOUSE_BTN_1" )  << tr( "PREF_SPACEMOUSE_BTN_2" ) << tr( "PREF_SPACEMOUSE_BTN_3" );
2815   aValuesList << tr( "PREF_SPACEMOUSE_BTN_4" )  << tr( "PREF_SPACEMOUSE_BTN_5" ) << tr( "PREF_SPACEMOUSE_BTN_6" );
2816   aValuesList << tr( "PREF_SPACEMOUSE_BTN_7" )  << tr( "PREF_SPACEMOUSE_BTN_8" ) << tr( "PREF_SPACEMOUSE_BTN_*" );
2817   aValuesList << tr( "PREF_SPACEMOUSE_BTN_10" ) << tr( "PREF_SPACEMOUSE_BTN_11" );
2818   anIndicesList << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11;
2819   pref->setItemProperty( "strings", aValuesList,   spacemousePref1 );
2820   pref->setItemProperty( "indexes", anIndicesList, spacemousePref1 );
2821   pref->setItemProperty( "strings", aValuesList,   spacemousePref2 );
2822   pref->setItemProperty( "indexes", anIndicesList, spacemousePref2 );
2823   pref->setItemProperty( "strings", aValuesList,   spacemousePref3 );
2824   pref->setItemProperty( "indexes", anIndicesList, spacemousePref3 );
2825   // ... space mouse sub-group <<end>>
2826
2827   // ... avi recording sub-group <<start>>
2828   int vtkRec = pref->addPreference( tr( "PREF_FRAME_RECORDING" ), vtkGroup, LightApp_Preferences::GroupBox );
2829   pref->setItemProperty( "columns", 2, vtkRec );
2830   // .... -> recording mode
2831   int modePref = pref->addPreference( tr( "PREF_RECORDING_MODE" ), vtkRec,
2832                                       LightApp_Preferences::Selector, "VTKViewer", "recorder_mode" );
2833   aValuesList.clear();
2834   anIndicesList.clear();
2835   aValuesList   << tr( "PREF_SKIPPED_FRAMES" ) << tr( "PREF_ALL_DISLPAYED_FRAMES" );
2836   anIndicesList << 0                           << 1;
2837   pref->setItemProperty( "strings", aValuesList,   modePref );
2838   pref->setItemProperty( "indexes", anIndicesList, modePref );
2839   // .... -> fps
2840   int fpsPref = pref->addPreference( tr( "PREF_FPS" ), vtkRec,
2841                                      LightApp_Preferences::DblSpin, "VTKViewer", "recorder_fps" );
2842   pref->setItemProperty( "min", 0.1, fpsPref );
2843   pref->setItemProperty( "max", 100, fpsPref );
2844   // .... -> quality
2845   int qualityPref = pref->addPreference( tr( "PREF_QUALITY" ), vtkRec,
2846                                          LightApp_Preferences::IntSpin, "VTKViewer", "recorder_quality" );
2847   pref->setItemProperty( "min", 1, qualityPref );
2848   pref->setItemProperty( "max", 100, qualityPref );
2849   // .... -> progressive mode
2850   pref->addPreference( tr( "PREF_PROGRESSIVE" ), vtkRec,
2851                        LightApp_Preferences::Bool, "VTKViewer", "recorder_progressive" );
2852   // ... avi recording sub-group <<end>>
2853
2854   // ... group names sub-group <<start>>
2855   int vtkGN = pref->addPreference( tr( "PREF_FRAME_GROUP_NAMES" ), vtkGroup,
2856                                    LightApp_Preferences::GroupBox, "VTKViewer", "show_group_names" );
2857   pref->setItemProperty( "columns", 2, vtkGN );
2858   // .... -> text color
2859   pref->addPreference( tr(  "PREF_GROUP_NAMES_TEXT_COLOR" ), vtkGN,
2860                        LightApp_Preferences::Color, "VTKViewer", "group_names_text_color" );
2861   // .... -> transparency
2862   int transPref = pref->addPreference( tr( "PREF_GROUP_NAMES_TRANSPARENCY" ), vtkGN,
2863                                        LightApp_Preferences::DblSpin, "VTKViewer", "group_names_transparency" );
2864   pref->setItemProperty( "min", 0.0, transPref );
2865   pref->setItemProperty( "max", 1.0, transPref );
2866   pref->setItemProperty( "step", 0.1, transPref );
2867   // ... -> group names sub-group <<end>>
2868   // .. "VTK viewer" group <<end>>
2869 #endif
2870
2871   // .. "Plot2d viewer" group <<start>>
2872   int plot2dGroup = pref->addPreference( tr( "PREF_GROUP_PLOT2DVIEWER" ), salomeCat ); //viewTab
2873   //pref->setItemProperty( "columns", 2, plot2dGroup );
2874
2875   // ... -> background
2876   pref->addPreference( tr( "PREF_VIEWER_BACKGROUND_COLOR" ), plot2dGroup,
2877                        LightApp_Preferences::Color, "Plot2d", "Background" );
2878   // ... -> selection color
2879   pref->addPreference( tr( "PREF_VIEWER_SELECTION" ), plot2dGroup,
2880                        LightApp_Preferences::Color, "Plot2d", "SelectionColor" );
2881
2882   // ... "Viewer" group <<start>>
2883   int plot2dViewerGroup = pref->addPreference( tr( "PREF_GROUP_VIEWER" ), plot2dGroup );
2884
2885   // .... -> curve type
2886   int curveType = pref->addPreference( tr( "PREF_CURVE_TYPE" ), plot2dViewerGroup,
2887                                        LightApp_Preferences::Selector, "Plot2d", "CurveType" );
2888   aValuesList.clear();
2889   anIndicesList.clear();
2890   aValuesList   << tr("PREF_POINTS") << tr("PREF_LINES") << tr("PREF_SPLINE");
2891   anIndicesList << 0                 << 1                << 2                ;
2892   pref->setItemProperty( "strings", aValuesList,   curveType );
2893   pref->setItemProperty( "indexes", anIndicesList, curveType );
2894   // .... -> marker size
2895   int markerSize = pref->addPreference( tr( "PREF_MARKER_SIZE" ), plot2dViewerGroup,
2896                                         LightApp_Preferences::IntSpin, "Plot2d", "MarkerSize" );
2897   pref->setItemProperty( "min", 0, markerSize );
2898   pref->setItemProperty( "max", 100, markerSize );
2899   // .... -> horizontal scaling mode
2900   int horScale = pref->addPreference( tr( "PREF_HOR_AXIS_SCALE" ), plot2dViewerGroup,
2901                                       LightApp_Preferences::Selector, "Plot2d", "HorScaleMode" );
2902   aValuesList.clear();
2903   anIndicesList.clear();
2904   aValuesList   << tr("PREF_LINEAR") << tr("PREF_LOGARITHMIC");
2905   anIndicesList << 0                 << 1                     ;
2906   pref->setItemProperty( "strings", aValuesList,   horScale );
2907   pref->setItemProperty( "indexes", anIndicesList, horScale );
2908   // .... -> vertical scaling mode
2909   int verScale = pref->addPreference( tr( "PREF_VERT_AXIS_SCALE" ), plot2dViewerGroup,
2910                                       LightApp_Preferences::Selector, "Plot2d", "VerScaleMode" );
2911   pref->setItemProperty( "strings", aValuesList,   verScale );
2912   pref->setItemProperty( "indexes", anIndicesList, verScale );
2913
2914   // .... -> errors/deviation colot
2915   pref->addPreference( tr( "PREF_DEVIATION_COLOR" ), plot2dViewerGroup,
2916                        LightApp_Preferences::Color, "Plot2d", "DeviationMarkerColor" );
2917   // .... -> deviation markers line size
2918   int deviationMarkerLw = pref->addPreference( tr( "PREF_DEVIATION_MARKER_LW" ), plot2dViewerGroup,
2919                                         LightApp_Preferences::IntSpin, "Plot2d", "DeviationMarkerLineWidth" );
2920   pref->setItemProperty( "min", 1, deviationMarkerLw );
2921   pref->setItemProperty( "max", 5, deviationMarkerLw );
2922   // .... -> deviation markers tick mark size
2923   int deviationMarkerTs = pref->addPreference( tr( "PREF_DEVIATION_MARKER_TS" ), plot2dViewerGroup,
2924                                         LightApp_Preferences::IntSpin, "Plot2d", "DeviationMarkerTickSize" );
2925   pref->setItemProperty( "min", 1, deviationMarkerTs );
2926   pref->setItemProperty( "max", 5, deviationMarkerTs );
2927   // .... "Viewer" group <<end>>
2928
2929   // ... "Legend" group <<start>>
2930   int plot2dLegendGroup = pref->addPreference( tr( "PREF_GROUP_LEGEND" ), plot2dGroup );
2931
2932   // .... -> show legend
2933   pref->addPreference( tr( "PREF_SHOW_LEGEND" ), plot2dLegendGroup,
2934                        LightApp_Preferences::Bool, "Plot2d", "ShowLegend" );
2935   // .... -> legend position
2936   int legendPosition = pref->addPreference( tr( "PREF_LEGEND_POSITION" ), plot2dLegendGroup,
2937                                             LightApp_Preferences::Selector, "Plot2d", "LegendPos" );
2938   aValuesList.clear();
2939   anIndicesList.clear();
2940   aValuesList   << tr("PREF_LEFT") << tr("PREF_RIGHT") << tr("PREF_TOP") << tr("PREF_BOTTOM");
2941   anIndicesList << 0               << 1                << 2              << 3                ;
2942   pref->setItemProperty( "strings", aValuesList,   legendPosition );
2943   pref->setItemProperty( "indexes", anIndicesList, legendPosition );
2944   // .... -> Symbol type
2945   int legendSymbolType = pref->addPreference( tr( "PREF_LEGEND_SYMBOL_TYPE" ), plot2dLegendGroup,
2946                                             LightApp_Preferences::Selector, "Plot2d", "LegendSymbolType" );
2947   aValuesList.clear();
2948   anIndicesList.clear();
2949   aValuesList   << tr("PREF_MARKER_ON_LINE") << tr("PREF_MARKER_ABOVE_LINE");
2950   anIndicesList << 0                            << 1                        ;
2951   pref->setItemProperty( "strings", aValuesList,   legendSymbolType );
2952   pref->setItemProperty( "indexes", anIndicesList, legendSymbolType );
2953   // .... -> legend font
2954   pref->addPreference( tr( "PREF_LEGEND_FONT" ), plot2dLegendGroup, LightApp_Preferences::Font, "Plot2d", "LegendFont" );
2955   // ... -> font color
2956   pref->addPreference( tr( "PREF_FONT_COLOR" ), plot2dLegendGroup, LightApp_Preferences::Color, "Plot2d", "LegendFontColor" );
2957   // ... -> selection font color
2958   pref->addPreference( tr( "PREF_SELECTED_FONT_COLOR" ), plot2dLegendGroup, LightApp_Preferences::Color, "Plot2d", "SelectedLegendFontColor" );
2959   // ... "Legend" group <<end>>
2960
2961   // .. "Plot2d viewer" group <<end>>
2962
2963   // .. "PyViewer" preferences tab <<start>>
2964   int pyeditTab = pref->addPreference( tr( "PREF_TAB_PYEDITOR" ), salomeCat );
2965   // ... "Font settings" group <<start>>
2966   int pyFontGroup = pref->addPreference( tr( "PREF_GROUP_PY_FONT" ), pyeditTab );
2967   int pyFont = pref->addPreference( tr( "PREF_PY_FONT" ), pyFontGroup,
2968                                     LightApp_Preferences::Font, "PyEditor", "Font" );
2969   pref->setItemProperty( "features", QtxFontEdit::Family | QtxFontEdit::Size | QtxFontEdit::UserSize, pyFont );
2970   // ... "Font settings" group <<end>>
2971   // ... "Display settings" group <<start>>
2972   int pyDispGroup = pref->addPreference( tr( "PREF_GROUP_PY_DISPLAY" ), pyeditTab );
2973   pref->setItemProperty( "columns", 2, pyDispGroup );
2974   // ... -> current line highlight
2975   pref->addPreference( tr( "PREF_PY_CURRLINE_HIGHLIGHT" ), pyDispGroup,
2976     LightApp_Preferences::Bool, "PyEditor", "HighlightCurrentLine" );
2977   // ... -> text wrapping
2978   pref->addPreference( tr( "PREF_PY_TEXT_WRAP" ), pyDispGroup,
2979     LightApp_Preferences::Bool, "PyEditor", "TextWrapping" );
2980   // ... -> center cursor on scroll
2981   pref->addPreference( tr( "PREF_PY_CURSON_ON_SCROLL" ), pyDispGroup,
2982     LightApp_Preferences::Bool, "PyEditor", "CenterCursorOnScroll" );
2983   // ... -> line numbers area
2984   pref->addPreference( tr( "PREF_PY_LINE_NUMBS_AREA" ), pyDispGroup,
2985     LightApp_Preferences::Bool, "PyEditor", "LineNumberArea" );
2986   // ... "Display settings" group <<end>>
2987
2988   // ... "Editor settings" group <<start>>
2989   int pyEditGroup = pref->addPreference( tr( "PREF_GROUP_PY_EDITOR" ), pyeditTab );
2990   // ... -> navigation mode
2991   int pyCompletion = pref->addPreference( tr( "PREF_PY_COMPLETION_MODE" ), pyEditGroup,
2992                                           LightApp_Preferences::Selector, "PyEditor", "CompletionPolicy" );
2993   aValuesList.clear();
2994   anIndicesList.clear();
2995   aValuesList   << tr("PREF_PY_NONE") << tr("PREF_PY_AUTO") << tr("PREF_PY_MANUAL") << tr("PREF_PY_ALWAYS");
2996   anIndicesList << 0                  << 1                  << 2                    << 3                   ;
2997   pref->setItemProperty( "strings", aValuesList, pyCompletion );
2998   pref->setItemProperty( "indexes", anIndicesList, pyCompletion );
2999   // ... "Editor settings" group <<end>>
3000
3001   // ... "Tab settings" group <<start>>
3002   int pyTabGroup = pref->addPreference( tr( "PREF_GROUP_PY_TAB" ), pyeditTab );
3003   pref->setItemProperty( "columns", 2, pyTabGroup );
3004   // ... -> tab whitespaces
3005   pref->addPreference( tr( "PREF_PY_TAB_WHITESPACES" ), pyTabGroup,
3006     LightApp_Preferences::Bool, "PyEditor", "TabSpaceVisible" );
3007   // ... -> tab size
3008   pref->addPreference( tr( "PREF_PY_TAB_SIZE" ), pyTabGroup,
3009     LightApp_Preferences::IntSpin, "PyEditor", "TabSize" );
3010   // ... "Tab settings" group <<end>>
3011   // ... "Vertical edge settings" group <<start>>
3012   int pyVertEdgeGroup = pref->addPreference( tr( "PREF_GROUP_VERT_EDGE" ), pyeditTab );
3013   pref->setItemProperty( "columns", 2, pyVertEdgeGroup );
3014   // ... -> vertical edge
3015   pref->addPreference( tr( "PREF_PY_VERT_EDGE" ), pyVertEdgeGroup,
3016     LightApp_Preferences::Bool, "PyEditor", "VerticalEdge" );
3017   // ... -> number of columns
3018   pref->addPreference( tr( "PREF_PY_NUM_COLUMNS" ), pyVertEdgeGroup,
3019     LightApp_Preferences::IntSpin, "PyEditor", "NumberColumns" );
3020   // ... "Vertical edge settings" group <<end>>
3021   // .. "PyEditor" preferences tab <<end>>
3022
3023   // .. "Directories" preferences tab <<start>>
3024   int dirTab = pref->addPreference( tr( "PREF_TAB_DIRECTORIES" ), salomeCat );
3025   // ... --> quick directories list
3026   int dirGroup = pref->addPreference( tr( "PREF_GROUP_DIRECTORIES" ), dirTab );
3027   pref->addPreference( tr( "" ), dirGroup,
3028                        LightApp_Preferences::DirList, "FileDlg", "QuickDirList" );
3029   // .. "Directories" preferences tab <<end>>
3030
3031   // .. "Object browser" preferences tab <<start>>
3032   int obTab = pref->addPreference( tr( "PREF_TAB_OBJBROWSER" ), salomeCat );
3033
3034   // ... "Search tool" group <<start>>
3035   int stGroup = pref->addPreference( tr( "PREF_OBJ_BROWSER_SEARCH_TOOL" ), obTab );
3036   // .... --> auto-hide
3037   pref->addPreference( tr( "PREF_AUTO_HIDE_SEARCH_TOOL" ), stGroup, LightApp_Preferences::Bool,
3038                        "ObjectBrowser", "auto_hide_search_tool" );
3039   // ... "Search tool" group <<end>>
3040
3041   // ... "Object browser settings" group <<start>>
3042   int objSetGroup = pref->addPreference( tr( "PREF_GROUP_LOOK_AND_FEEL" ), obTab );
3043   pref->setItemProperty( "columns", 2, objSetGroup );
3044   // .... -> auto size first column
3045   pref->addPreference( tr( "PREF_AUTO_SIZE_FIRST" ), objSetGroup, LightApp_Preferences::Bool,
3046                        "ObjectBrowser", "auto_size_first" );
3047   // .... -> auto size other columns
3048   pref->addPreference( tr( "PREF_AUTO_SIZE" ), objSetGroup, LightApp_Preferences::Bool,
3049                        "ObjectBrowser", "auto_size" );
3050   // .... -> resize columns on expand item
3051   pref->addPreference( tr( "PREF_RESIZE_ON_EXPAND_ITEM" ), objSetGroup, LightApp_Preferences::Bool,
3052                        "ObjectBrowser", "resize_on_expand_item" );
3053   // .... -> browse to published object
3054   int browsePublished = pref->addPreference( tr( "PREF_BROWSE_TO_THE_PUBLISHED_OBJECT" ), objSetGroup, LightApp_Preferences::Selector,
3055                                              "ObjectBrowser", "browse_published_object" );
3056   aValuesList.clear();
3057   anIndicesList.clear();
3058   aValuesList << tr( "PREF_BROWSE_NEVER" ) << tr( "PREF_BROWSE_AFTER_APPLY_AND_CLOSE_ONLY" ) << tr( "PREF_BROWSE_ALWAYS" );
3059   anIndicesList << BP_Never << BP_ApplyAndClose << BP_Always;
3060   pref->setItemProperty( "strings", aValuesList,   browsePublished );
3061   pref->setItemProperty( "indexes", anIndicesList, browsePublished );
3062   // ... "Object browser settings" group <<end>>
3063   // .. "Object browser" preferences tab <<end>>
3064
3065   // .. "Shortcuts" preferences tab <<start>>
3066   int shortcutTab = pref->addPreference( tr( "PREF_TAB_SHORTCUTS" ), salomeCat );
3067   // ... "Shortcuts settings" group <<start>>
3068   int shortcutGroup = pref->addPreference( tr( "PREF_GROUP_SHORTCUTS" ), shortcutTab );
3069   pref->addPreference( tr( "" ), shortcutGroup,
3070                        LightApp_Preferences::ShortcutTree, "shortcuts" );
3071   // ... "Shortcuts settings" group <<end>>
3072   // .. "Shortcuts" preferences tab <<end>>
3073   // . Top-level "SALOME" preferences group <<end>>
3074
3075   pref->retrieve();
3076 }
3077
3078 /*!
3079   Changes appearance of application according to changed preferences
3080   \param sec - section
3081   \param param - name of changed parameter
3082 */
3083 void LightApp_Application::preferencesChanged( const QString& sec, const QString& param )
3084 {
3085   SUIT_ResourceMgr* resMgr = resourceMgr();
3086   if ( !resMgr )
3087     return;
3088
3089   if ( sec == "viewers" && param == "drop_down_buttons" )
3090   {
3091     ViewManagerList vmlist = viewManagers();
3092     foreach( SUIT_ViewManager* vm, vmlist )
3093     {
3094       QVector<SUIT_ViewWindow*> vwlist = vm->getViews();
3095       foreach( SUIT_ViewWindow* vw, vwlist )
3096         if ( vw ) vw->setDropDownButtons( resMgr->booleanValue( "viewers", "drop_down_buttons", true ) );
3097     }
3098   }
3099
3100   if ( sec == QString( "3DViewer" ) && (param == QString( "trihedron_size" ) || param == QString( "relative_size" )))
3101   {
3102     double sz = resMgr->doubleValue( sec, "trihedron_size", -1 );
3103     bool relative = resMgr->booleanValue( sec, "relative_size", true );
3104     QList<SUIT_ViewManager*> lst;
3105 #ifndef DISABLE_OCCVIEWER
3106     viewManagers( OCCViewer_Viewer::Type(), lst );
3107     QListIterator<SUIT_ViewManager*> itOCC( lst );
3108     while ( itOCC.hasNext() && sz >= 0 )
3109     {
3110       SUIT_ViewModel* vm = itOCC.next()->getViewModel();
3111       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3112         continue;
3113
3114       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3115       occVM->setTrihedronSize( sz, relative );
3116       occVM->getAISContext()->UpdateCurrentViewer();
3117     }
3118 #endif
3119 #ifndef DISABLE_VTKVIEWER
3120 #ifndef DISABLE_SALOMEOBJECT
3121     viewManagers( SVTK_Viewer::Type(), lst );
3122     QListIterator<SUIT_ViewManager*> itVTK( lst );
3123     while ( itVTK.hasNext() && sz >= 0 )
3124     {
3125       SUIT_ViewModel* vm = itVTK.next()->getViewModel();
3126       if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
3127         continue;
3128
3129       SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
3130       if( vtkVM )
3131       {
3132         vtkVM->setTrihedronSize( sz, relative );
3133         vtkVM->Repaint();
3134       }
3135     }
3136 #endif
3137 #endif
3138   }
3139
3140   if ( sec == QString( "3DViewer" ) && param == QString( "show_static_trihedron" ) )
3141   {
3142     bool isVisible = resMgr->booleanValue( "3DViewer", "show_static_trihedron", true );
3143     QList<SUIT_ViewManager*> lst;
3144 #ifndef DISABLE_OCCVIEWER
3145     viewManagers( OCCViewer_Viewer::Type(), lst );
3146     QListIterator<SUIT_ViewManager*> itOCC( lst );
3147     while ( itOCC.hasNext() )
3148     {
3149       SUIT_ViewModel* vm = itOCC.next()->getViewModel();
3150       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3151         continue;
3152
3153       OCCViewer_Viewer* occVM = dynamic_cast<OCCViewer_Viewer*>( vm );
3154       if( occVM )
3155       {
3156         occVM->setStaticTrihedronDisplayed( isVisible );
3157       }
3158     }
3159 #endif
3160 #ifndef DISABLE_VTKVIEWER
3161 #ifndef DISABLE_SALOMEOBJECT
3162     viewManagers( SVTK_Viewer::Type(), lst );
3163     QListIterator<SUIT_ViewManager*> itVTK( lst );
3164     while ( itVTK.hasNext() )
3165     {
3166       SUIT_ViewModel* vm = itVTK.next()->getViewModel();
3167       if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
3168         continue;
3169
3170       SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
3171       if( vtkVM )
3172       {
3173         vtkVM->setStaticTrihedronVisible( isVisible );
3174         vtkVM->Repaint();
3175       }
3176     }
3177 #endif
3178 #endif
3179   }
3180
3181   if ( sec == QString( "3DViewer" ) && param == QString( "navigation_mode" ) )
3182   {
3183     int mode = resMgr->integerValue( "3DViewer", "navigation_mode", 0 );
3184     QList<SUIT_ViewManager*> lst;
3185 #ifndef DISABLE_OCCVIEWER
3186     viewManagers( OCCViewer_Viewer::Type(), lst );
3187     QListIterator<SUIT_ViewManager*> itOCC( lst );
3188     while ( itOCC.hasNext() )
3189     {
3190       SUIT_ViewModel* vm = itOCC.next()->getViewModel();
3191       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3192         continue;
3193
3194       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3195       occVM->setInteractionStyle( mode );
3196     }
3197 #endif
3198 #ifndef DISABLE_VTKVIEWER
3199 #ifndef DISABLE_SALOMEOBJECT
3200     viewManagers( SVTK_Viewer::Type(), lst );
3201     QListIterator<SUIT_ViewManager*> itVTK( lst );
3202     while ( itVTK.hasNext() )
3203     {
3204       SUIT_ViewModel* vm = itVTK.next()->getViewModel();
3205       if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
3206         continue;
3207
3208       SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
3209       if( vtkVM ) vtkVM->setInteractionStyle( mode );
3210     }
3211 #endif
3212 #endif
3213   }
3214
3215 #ifndef DISABLE_OCCVIEWER
3216   if ( sec == QString( "OCCViewer" ) && param == QString( "enable_preselection" ) )
3217   {
3218     bool isToEnablePreselection = resMgr->booleanValue( "OCCViewer", "enable_preselection", true );
3219     QList<SUIT_ViewManager*> lst;
3220     viewManagers( OCCViewer_Viewer::Type(), lst );
3221     QListIterator<SUIT_ViewManager*> it( lst );
3222     while ( it.hasNext() )
3223     {
3224       SUIT_ViewModel* vm = it.next()->getViewModel();
3225       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3226         continue;
3227
3228       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3229       occVM->enablePreselection( isToEnablePreselection );
3230     }
3231   }
3232 #endif
3233
3234 #ifndef DISABLE_OCCVIEWER
3235   if ( sec == QString( "OCCViewer" ) && param == QString( "enable_selection" ) )
3236   {
3237     bool isToEnableSelection = resMgr->booleanValue( "OCCViewer", "enable_selection", true );
3238     QList<SUIT_ViewManager*> lst;
3239     viewManagers( OCCViewer_Viewer::Type(), lst );
3240     QListIterator<SUIT_ViewManager*> it( lst );
3241     while ( it.hasNext() )
3242     {
3243       SUIT_ViewModel* vm = it.next()->getViewModel();
3244       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3245         continue;
3246
3247       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3248       occVM->enableSelection( isToEnableSelection );
3249     }
3250   }
3251 #endif
3252
3253 #ifndef DISABLE_OCCVIEWER
3254   if ( sec == QString( "OCCViewer" ) && param == QString( "clipping_color" ) )
3255   {
3256     QColor aColor = resMgr->colorValue( "OCCViewer", "clipping_color", QColor( 50, 50, 50 ) );
3257     QList<SUIT_ViewManager*> lst;
3258     viewManagers( OCCViewer_Viewer::Type(), lst );
3259     QListIterator<SUIT_ViewManager*> it( lst );
3260     while ( it.hasNext() )
3261     {
3262       SUIT_ViewModel* vm = it.next()->getViewModel();
3263       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3264         continue;
3265
3266       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3267       occVM->setClippingColor( aColor );
3268     }
3269   }
3270 #endif
3271
3272 #ifndef DISABLE_OCCVIEWER
3273   if ( sec == QString( "OCCViewer" ) && ( param == QString( "clipping_use_default_texture" ) ||
3274                                           param == QString( "clipping_texture" ) ||
3275                                           param == QString( "clipping_modulate" ) ||
3276                                           param == QString( "clipping_scale" ) ) )
3277   {
3278     bool isDefaultTextureUsed = resMgr->booleanValue( "OCCViewer", "clipping_use_default_texture" );
3279     QString aTexture = resMgr->stringValue( "OCCViewer", "clipping_texture" );
3280     bool isModulated = resMgr->booleanValue( "OCCViewer", "clipping_modulate" );
3281     double aScale = resMgr->doubleValue( "OCCViewer", "clipping_scale" );
3282     QList<SUIT_ViewManager*> lst;
3283     viewManagers( OCCViewer_Viewer::Type(), lst );
3284     QListIterator<SUIT_ViewManager*> it( lst );
3285     while ( it.hasNext() )
3286     {
3287       SUIT_ViewModel* vm = it.next()->getViewModel();
3288       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3289         continue;
3290
3291       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3292       occVM->setClippingTextureParams( isDefaultTextureUsed, aTexture, isModulated, aScale );
3293     }
3294   }
3295 #endif
3296
3297 #ifndef DISABLE_OCCVIEWER
3298   if ( sec == QString( "OCCViewer" ) && param == QString( "projection_mode" ) )
3299   {
3300     int mode = resMgr->integerValue( "OCCViewer", "projection_mode", 0 );
3301     QList<SUIT_ViewManager*> lst;
3302     viewManagers( OCCViewer_Viewer::Type(), lst );
3303     QListIterator<SUIT_ViewManager*> it( lst );
3304     while ( it.hasNext() )
3305     {
3306       SUIT_ViewModel* vm = it.next()->getViewModel();
3307       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3308         continue;
3309
3310       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3311       occVM->setProjectionType( mode );
3312     }
3313   }
3314 #endif
3315
3316 #ifndef DISABLE_OCCVIEWER
3317   if ( sec == QString( "OCCViewer" ) && param == QString( "stereo_type" ) )
3318   {
3319     int mode = resMgr->integerValue( "OCCViewer", "stereo_type", 0 );
3320     QList<SUIT_ViewManager*> lst;
3321     viewManagers( OCCViewer_Viewer::Type(), lst );
3322     QListIterator<SUIT_ViewManager*> it( lst );
3323     while ( it.hasNext() )
3324     {
3325       SUIT_ViewModel* vm = it.next()->getViewModel();
3326       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3327         continue;
3328
3329       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3330       occVM->setStereoType( mode );
3331     }
3332   }
3333 #endif
3334
3335 #ifndef DISABLE_OCCVIEWER
3336   if ( sec == QString( "OCCViewer" ) && param == QString( "anaglyph_filter" ) )
3337   {
3338     int mode = resMgr->integerValue( "OCCViewer", "anaglyph_filter", 0 );
3339     QList<SUIT_ViewManager*> lst;
3340     viewManagers( OCCViewer_Viewer::Type(), lst );
3341     QListIterator<SUIT_ViewManager*> it( lst );
3342     while ( it.hasNext() )
3343     {
3344       SUIT_ViewModel* vm = it.next()->getViewModel();
3345       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3346         continue;
3347
3348       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3349       occVM->setAnaglyphFilter( mode );
3350     }
3351   }
3352 #endif
3353
3354 #ifndef DISABLE_OCCVIEWER
3355   if ( sec == QString( "OCCViewer" ) && ( param == QString( "focus_type" ) ||
3356                                           param == QString( "focus_value" ) ) )
3357   {
3358     int aType = resMgr->integerValue( "OCCViewer", "focus_type" );
3359     double aValue = resMgr->doubleValue( "OCCViewer", "focus_value" );
3360     QList<SUIT_ViewManager*> lst;
3361     viewManagers( OCCViewer_Viewer::Type(), lst );
3362     QListIterator<SUIT_ViewManager*> it( lst );
3363     while ( it.hasNext() )
3364     {
3365       SUIT_ViewModel* vm = it.next()->getViewModel();
3366       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3367         continue;
3368
3369       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3370       occVM->setStereographicFocus( aType, aValue );
3371     }
3372   }
3373 #endif
3374
3375 #ifndef DISABLE_OCCVIEWER
3376   if ( sec == QString( "OCCViewer" ) && ( param == QString( "iod_type" ) ||
3377                                           param == QString( "iod_value" ) ) )
3378   {
3379     int aType = resMgr->integerValue( "OCCViewer", "iod_type" );
3380     double aValue = resMgr->doubleValue( "OCCViewer", "iod_value" );
3381     QList<SUIT_ViewManager*> lst;
3382     viewManagers( OCCViewer_Viewer::Type(), lst );
3383     QListIterator<SUIT_ViewManager*> it( lst );
3384     while ( it.hasNext() )
3385     {
3386       SUIT_ViewModel* vm = it.next()->getViewModel();
3387       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3388         continue;
3389
3390       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3391       occVM->setInterocularDistance( aType, aValue );
3392     }
3393   }
3394 #endif
3395
3396 #ifndef DISABLE_OCCVIEWER
3397   if ( sec == QString( "OCCViewer" ) && param == QString( "reverse_stereo" ) )
3398   {
3399     bool reverse = resMgr->booleanValue( "OCCViewer", "reverse_stereo", false );
3400     QList<SUIT_ViewManager*> lst;
3401     viewManagers( OCCViewer_Viewer::Type(), lst );
3402     QListIterator<SUIT_ViewManager*> it( lst );
3403     while ( it.hasNext() )
3404     {
3405       SUIT_ViewModel* vm = it.next()->getViewModel();
3406       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3407         continue;
3408
3409       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3410       occVM->setReverseStereo( reverse );
3411     }
3412   }
3413 #endif
3414
3415 #ifndef DISABLE_OCCVIEWER
3416   if ( sec == QString( "OCCViewer" ) && param == QString( "enable_vsync" ) )
3417   {
3418     bool enable = resMgr->booleanValue( "OCCViewer", "enable_vsync", true );
3419     QList<SUIT_ViewManager*> lst;
3420     viewManagers( OCCViewer_Viewer::Type(), lst );
3421     QListIterator<SUIT_ViewManager*> it( lst );
3422     while ( it.hasNext() )
3423     {
3424       SUIT_ViewModel* vm = it.next()->getViewModel();
3425       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3426         continue;
3427
3428       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3429       occVM->setVSync( enable );
3430     }
3431   }
3432 #endif
3433
3434 #ifndef DISABLE_OCCVIEWER
3435   if ( sec == QString( "OCCViewer" ) && param == QString( "enable_quad_buffer_support" ) )
3436   {
3437     bool enable = resMgr->booleanValue( "OCCViewer", "enable_quad_buffer_support", false );
3438     QList<SUIT_ViewManager*> lst;
3439     viewManagers( OCCViewer_Viewer::Type(), lst );
3440     QListIterator<SUIT_ViewManager*> it( lst );
3441     while ( it.hasNext() )
3442     {
3443       SUIT_ViewModel* vm = it.next()->getViewModel();
3444       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3445         continue;
3446
3447       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3448       occVM->setQuadBufferSupport( enable );
3449     }
3450   }
3451 #endif
3452
3453   if ( sec == QString( "3DViewer" ) && param == QString( "zooming_mode" ) )
3454   {
3455     int mode = resMgr->integerValue( "3DViewer", "zooming_mode", 0 );
3456     QList<SUIT_ViewManager*> lst;
3457 #ifndef DISABLE_OCCVIEWER
3458     viewManagers( OCCViewer_Viewer::Type(), lst );
3459     QListIterator<SUIT_ViewManager*> itOCC( lst );
3460     while ( itOCC.hasNext() )
3461     {
3462       SUIT_ViewModel* vm = itOCC.next()->getViewModel();
3463       if ( !vm || !vm->inherits( "OCCViewer_Viewer" ) )
3464         continue;
3465
3466       OCCViewer_Viewer* occVM = (OCCViewer_Viewer*)vm;
3467       occVM->setZoomingStyle( mode );
3468     }
3469 #endif
3470 #ifndef DISABLE_VTKVIEWER
3471 #ifndef DISABLE_SALOMEOBJECT
3472     viewManagers( SVTK_Viewer::Type(), lst );
3473     QListIterator<SUIT_ViewManager*> itVTK( lst );
3474     while ( itVTK.hasNext() )
3475     {
3476       SUIT_ViewModel* vm = itVTK.next()->getViewModel();
3477       if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
3478         continue;
3479
3480       SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
3481       if( vtkVM ) vtkVM->setZoomingStyle( mode );
3482     }
3483 #endif
3484 #endif
3485   }
3486
3487 #ifndef DISABLE_VTKVIEWER
3488   if ( sec == QString( "VTKViewer" ) && (param == QString( "speed_value" ) || param == QString( "speed_mode" )) )
3489   {
3490     int speed = resMgr->integerValue( "VTKViewer", "speed_value", 10 );
3491     int mode = resMgr->integerValue( "VTKViewer", "speed_mode", 0 );
3492     QList<SUIT_ViewManager*> lst;
3493 #ifndef DISABLE_SALOMEOBJECT
3494     viewManagers( SVTK_Viewer::Type(), lst );
3495     QListIterator<SUIT_ViewManager*> it( lst );
3496     while ( it.hasNext() )
3497     {
3498       SUIT_ViewModel* vm = it.next()->getViewModel();
3499       if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
3500         continue;
3501
3502       SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
3503       if( vtkVM ) vtkVM->setIncrementalSpeed( speed, mode );
3504     }
3505 #endif
3506   }
3507 #endif
3508
3509 #ifndef DISABLE_VTKVIEWER
3510   if ( sec == QString( "VTKViewer" ) && param == QString( "projection_mode" ) )
3511   {
3512     int mode = resMgr->integerValue( "VTKViewer", "projection_mode", 0 );
3513     QList<SUIT_ViewManager*> lst;
3514 #ifndef DISABLE_SALOMEOBJECT
3515     viewManagers( SVTK_Viewer::Type(), lst );
3516     QListIterator<SUIT_ViewManager*> it( lst );
3517     while ( it.hasNext() )
3518     {
3519       SUIT_ViewModel* vm = it.next()->getViewModel();
3520       if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
3521         continue;
3522
3523       SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
3524       if( vtkVM ) vtkVM->setProjectionMode( mode );
3525     }
3526 #endif
3527   }
3528 #endif
3529
3530 #ifndef DISABLE_VTKVIEWER
3531   if ( sec == QString( "VTKViewer" ) && param == QString( "stereo_type" ) )
3532   {
3533     int mode = resMgr->integerValue( "VTKViewer", "stereo_type", 0 );
3534     QList<SUIT_ViewManager*> lst;
3535 #ifndef DISABLE_SALOMEOBJECT
3536     viewManagers( SVTK_Viewer::Type(), lst );
3537     QListIterator<SUIT_ViewManager*> it( lst );
3538     while ( it.hasNext() )
3539     {
3540       SUIT_ViewModel* vm = it.next()->getViewModel();
3541       if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
3542         continue;
3543
3544       SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
3545       if( vtkVM ) vtkVM->setStereoType( mode );
3546     }
3547 #endif
3548   }
3549 #endif
3550
3551 #ifndef DISABLE_VTKVIEWER
3552   if ( sec == QString( "VTKViewer" ) && param == QString( "anaglyph_filter" ) )
3553   {
3554     int mode = resMgr->integerValue( "VTKViewer", "anaglyph_filter", 0 );
3555     QList<SUIT_ViewManager*> lst;
3556 #ifndef DISABLE_SALOMEOBJECT
3557     viewManagers( SVTK_Viewer::Type(), lst );
3558     QListIterator<SUIT_ViewManager*> it( lst );
3559     while ( it.hasNext() )
3560     {
3561       SUIT_ViewModel* vm = it.next()->getViewModel();
3562       if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
3563         continue;
3564
3565       SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
3566       if( vtkVM ) vtkVM->setAnaglyphFilter( mode );
3567     }
3568 #endif
3569   }
3570 #endif
3571
3572 #ifndef DISABLE_VTKVIEWER
3573   if ( sec == QString( "VTKViewer" ) && param == QString( "enable_quad_buffer_support" ) )
3574   {
3575     int enable = resMgr->booleanValue( "VTKViewer", "enable_quad_buffer_support", false );
3576     QList<SUIT_ViewManager*> lst;
3577 #ifndef DISABLE_SALOMEOBJECT
3578     viewManagers( SVTK_Viewer::Type(), lst );
3579     QListIterator<SUIT_ViewManager*> it( lst );
3580     while ( it.hasNext() )
3581     {
3582       SUIT_ViewModel* vm = it.next()->getViewModel();
3583       if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
3584         continue;
3585
3586       SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
3587       if( vtkVM ) vtkVM->setQuadBufferSupport( enable );
3588     }
3589 #endif
3590   }
3591 #endif
3592
3593 #ifndef DISABLE_VTKVIEWER
3594   if ( sec == QString( "VTKViewer" ) && param == QString( "preselection" ) )
3595   {
3596     int mode = resMgr->integerValue( "VTKViewer", "preselection", 0 );
3597     QList<SUIT_ViewManager*> lst;
3598 #ifndef DISABLE_SALOMEOBJECT
3599     viewManagers( SVTK_Viewer::Type(), lst );
3600     QListIterator<SUIT_ViewManager*> it( lst );
3601     while ( it.hasNext() )
3602     {
3603       SUIT_ViewModel* vm = it.next()->getViewModel();
3604       if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
3605         continue;
3606
3607       SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
3608       if( vtkVM ) vtkVM->setPreSelectionMode( mode );
3609     }
3610 #endif
3611   }
3612 #endif
3613
3614 #ifndef DISABLE_VTKVIEWER
3615   if ( sec == QString( "VTKViewer" ) && param == QString( "enable_selection" ) )
3616   {
3617     bool isToEnableSelection = resMgr->booleanValue( "VTKViewer", "enable_selection", true );
3618     QList<SUIT_ViewManager*> lst;
3619 #ifndef DISABLE_SALOMEOBJECT
3620     viewManagers( SVTK_Viewer::Type(), lst );
3621     QListIterator<SUIT_ViewManager*> it( lst );
3622     while ( it.hasNext() )
3623     {
3624       SUIT_ViewModel* vm = it.next()->getViewModel();
3625       if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
3626         continue;
3627
3628       SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
3629       if( vtkVM ) vtkVM->enableSelection( isToEnableSelection );
3630     }
3631 #endif
3632   }
3633 #endif
3634
3635 #ifndef DISABLE_VTKVIEWER
3636   if ( sec == QString( "VTKViewer" ) && (param == QString( "spacemouse_func1_btn" ) ||
3637                                          param == QString( "spacemouse_func2_btn" ) ||
3638                                          param == QString( "spacemouse_func5_btn" ) ) )
3639   {
3640     int btn1 = resMgr->integerValue( "VTKViewer", "spacemouse_func1_btn", 1 );
3641     int btn2 = resMgr->integerValue( "VTKViewer", "spacemouse_func2_btn", 2 );
3642     int btn3 = resMgr->integerValue( "VTKViewer", "spacemouse_func5_btn", 9 );
3643     QList<SUIT_ViewManager*> lst;
3644 #ifndef DISABLE_SALOMEOBJECT
3645     viewManagers( SVTK_Viewer::Type(), lst );
3646     QListIterator<SUIT_ViewManager*> it( lst );
3647     while ( it.hasNext() )
3648     {
3649       SUIT_ViewModel* vm = it.next()->getViewModel();
3650       if ( !vm || !vm->inherits( "SVTK_Viewer" ) )
3651         continue;
3652
3653       SVTK_Viewer* vtkVM = dynamic_cast<SVTK_Viewer*>( vm );
3654       if( vtkVM ) vtkVM->setSpacemouseButtons( btn1, btn2, btn3 );
3655     }
3656 #endif
3657   }
3658 #endif
3659   if( sec=="ObjectBrowser" )
3660   {
3661     SUIT_DataBrowser* ob = objectBrowser();
3662     if ( !ob )
3663       return;
3664
3665     if ( param=="auto_size_first" )
3666     {
3667       bool autoSizeFirst = resMgr->booleanValue( "ObjectBrowser", "auto_size_first", true );
3668       ob->setAutoSizeFirstColumn( autoSizeFirst );
3669       if ( autoSizeFirst )
3670         ob->adjustFirstColumnWidth();
3671     }
3672     else if ( param=="auto_size" ) {
3673       bool autoSize = resMgr->booleanValue( "ObjectBrowser", "auto_size", false );
3674       ob->setAutoSizeColumns(autoSize);
3675       if ( autoSize )
3676         ob->adjustColumnsWidth();
3677     }
3678     else if ( param=="resize_on_expand_item" ) {
3679       bool resizeOnExpandItem = resMgr->booleanValue( "ObjectBrowser", "resize_on_expand_item", false );
3680       ob->setResizeOnExpandItem(resizeOnExpandItem);
3681     }
3682     else if ( param == "auto_hide_search_tool" ) {
3683       ob->searchTool()->enableAutoHide( resMgr->booleanValue( "ObjectBrowser", "auto_hide_search_tool" ) );
3684     }
3685   }
3686
3687   if( sec=="Study" )
3688   {
3689     if( param=="auto_save_interval" ) {
3690       myAutoSaveTimer->stop();
3691       int autoSaveInterval = resMgr->integerValue( "Study", "auto_save_interval", 0 );
3692       if ( activeStudy() && autoSaveInterval > 0 ) myAutoSaveTimer->start( autoSaveInterval*60000 );
3693     }
3694   }
3695
3696 #ifndef DISABLE_PYCONSOLE
3697   if( sec=="PyConsole" && pythonConsole() )
3698   {
3699     if ( param=="font" ) {
3700       pythonConsole()->setFont( resMgr->fontValue( "PyConsole", "font" ) );
3701     }
3702     else if ( param=="show_banner" ) {
3703       pythonConsole()->setIsShowBanner( resMgr->booleanValue( "PyConsole", "show_banner", true ) );
3704     }
3705     else if ( param=="auto_completion" ) {
3706       pythonConsole()->setAutoCompletion( resMgr->booleanValue( "PyConsole", "auto_completion", true ) );
3707     }
3708   }
3709 #endif
3710
3711   if( sec=="MRU" )
3712   {
3713     QtxMRUAction* mru = ::qobject_cast<QtxMRUAction*>( action( MRUId ) );
3714     if ( mru ) {
3715       if ( param == "visible_count" )
3716         mru->setVisibleCount( resMgr->integerValue( "MRU", "visible_count", 5 ) );    // 5 MRU items by default
3717       else if ( param == "max_count" )
3718         mru->setHistoryCount( resMgr->integerValue( "MRU", "max_count", -1 ) );       // unlimited history by default
3719       else if ( param == "insert_mode" )
3720         mru->setInsertMode( resMgr->integerValue( "MRU", "insert_mode", 0 ) );        // QtxMRUAction::MoveFirst by default
3721       else if ( param == "link_type" )
3722         mru->setLinkType( resMgr->integerValue( "MRU", "link_type", 0 ) );            // QtxMRUAction::LinkAuto by default
3723       else if ( param == "show_clear" )
3724         mru->setClearPossible( resMgr->booleanValue( "MRU", "show_clear", false ) );  // do not show "Clear" item by default
3725       else if ( param == "show_mru" )
3726         mru->setVisible( resMgr->booleanValue( "MRU", "show_mru", false ) );          // do not show MRU menu item by default
3727     }
3728   }
3729   if ( sec == "language" && param == "language" )
3730   {
3731     // VSR 18.06.2015 : commented out : single warning dialog box is now shown by the LightApp_PreferencesDlg
3732     //SUIT_MessageBox::information( desktop(), tr( "WRN_WARNING" ), tr( "LANG_CHANGED" ) );
3733   }
3734   if ( sec == "language" && param == "locale")
3735   {
3736     // VSR 18.06.2015: commented out : single warning dialog box is now shown by the LightApp_PreferencesDlg
3737     //SUIT_MessageBox::information( desktop(), tr( "WRN_WARNING" ), tr( "LOCALE_CHANGED" ) );
3738   }
3739   if ( sec == "desktop" && param == "opaque_resize" ) {
3740     bool opaqueResize = resMgr->booleanValue( "desktop", "opaque_resize", false );
3741     // RNV: This code has been commented, because clearing of the QMainWindow::AnimatedDocks option
3742     //      leads to strange behaviour of the dockable windows (at least at qt-5.6.1):
3743     //      any dockable window can't be docked to the another area, except initial area.
3744     //      It is possible to move window to another area, but it always returns to the initial area.
3745     //
3746     //    QMainWindow::DockOptions dopts = desktop()->dockOptions();
3747     //    if ( opaqueResize ) dopts |= QMainWindow::AnimatedDocks;
3748     //     else                dopts &= ~QMainWindow::AnimatedDocks;
3749     //    desktop()->setDockOptions( dopts );
3750     desktop()->setOpaqueResize( opaqueResize );
3751     if ( dynamic_cast<STD_TabDesktop*>( desktop() ) )
3752       dynamic_cast<STD_TabDesktop*>( desktop() )->workstack()->setOpaqueResize( opaqueResize );
3753   }
3754
3755 #ifndef DISABLE_PLOT2DVIEWER
3756   QList<SUIT_ViewManager*> lst;
3757   viewManagers( Plot2d_Viewer::Type(), lst );
3758   QListIterator<SUIT_ViewManager*> itPlot2d( lst );
3759   while ( itPlot2d.hasNext() ) {
3760     SUIT_ViewManager* viewMgr = itPlot2d.next();
3761     SUIT_ViewModel* vm = viewMgr->getViewModel();
3762     if ( !vm || !vm->inherits( "Plot2d_Viewer" ) )
3763       continue;
3764
3765     //Plot2d_Viewer* Plot2dVM = dynamic_cast<Plot2d_Viewer*>( vm );
3766
3767     viewMgr->setViewModel( vm  );
3768     Plot2d_ViewWindow* wnd = dynamic_cast<Plot2d_ViewWindow*>( viewMgr->getActiveView() );
3769     if( wnd ) {
3770       Plot2d_ViewFrame* frame = wnd->getViewFrame();
3771       frame->SetPreference();
3772     }
3773   }
3774 #endif
3775 }
3776
3777 /*!
3778   Loads preferences
3779 */
3780 void LightApp_Application::loadPreferences()
3781 {
3782   CAM_Application::loadPreferences();
3783
3784   SUIT_ResourceMgr* aResMgr = resourceMgr();
3785
3786   if ( !aResMgr )
3787     return;
3788
3789   static bool mru_load = true;
3790   if ( mru_load )
3791   {
3792     QtxMRUAction* mru = ::qobject_cast<QtxMRUAction*>( action( MRUId ) );
3793     if ( mru ) {
3794       mru->setVisible( aResMgr->booleanValue( "MRU", "show_mru", false ) );         // do not show MRU menu item by default
3795       mru->setVisibleCount( aResMgr->integerValue( "MRU", "visible_count", 5 ) );   // 5 MRU items by default
3796       mru->setHistoryCount( aResMgr->integerValue( "MRU", "max_count", -1 ) );      // unlimited history by default
3797       mru->setInsertMode( aResMgr->integerValue( "MRU", "insert_mode", 0 ) );       // QtxMRUAction::MoveFirst by default
3798       mru->setLinkType( aResMgr->integerValue( "MRU", "link_type", 0 ) );           // QtxMRUAction::LinkAuto by default
3799       mru->setClearPossible( aResMgr->booleanValue( "MRU", "show_clear", false ) ); // do not show "Clear" item by default
3800       mru->loadLinks( aResMgr, "MRU" );
3801     }
3802     mru_load = false;
3803   }
3804
3805   myWinVis.clear();
3806   QStringList mods = aResMgr->parameters( "windows_visibility" );
3807   for ( QStringList::const_iterator itr = mods.begin(); itr != mods.end(); ++itr )
3808   {
3809     QByteArray arr;
3810     if ( aResMgr->value( "windows_visibility", *itr, arr ) )
3811       myWinVis.insert( *itr, arr );
3812   }
3813
3814   if ( desktop() ) {
3815     desktop()->retrieveGeometry( aResMgr->stringValue( "desktop", "geometry" ) );
3816     bool opaqueResize = aResMgr->booleanValue( "desktop", "opaque_resize", false );
3817     //    QMainWindow::DockOptions dopts = desktop()->dockOptions();
3818     //    if ( opaqueResize ) dopts |= QMainWindow::AnimatedDocks;
3819     //    else                dopts &= ~QMainWindow::AnimatedDocks;
3820     //    desktop()->setDockOptions( dopts );
3821     desktop()->setOpaqueResize( opaqueResize );
3822     if ( dynamic_cast<STD_TabDesktop*>( desktop() ) )
3823       dynamic_cast<STD_TabDesktop*>( desktop() )->workstack()->setOpaqueResize( opaqueResize );
3824   }
3825 }
3826
3827 /*!
3828   Saves preferences
3829 */
3830 void LightApp_Application::savePreferences()
3831 {
3832   CAM_Application::savePreferences();
3833
3834   saveDockWindowsState();
3835
3836   SUIT_ResourceMgr* aResMgr = resourceMgr();
3837
3838   if ( !aResMgr )
3839     return;
3840
3841   QtxMRUAction* mru = ::qobject_cast<QtxMRUAction*>( action( MRUId ) );
3842   if ( mru )
3843     mru->saveLinks( aResMgr, "MRU" );
3844
3845   for ( WinVis::const_iterator itr = myWinVis.begin(); itr != myWinVis.end(); ++itr )
3846     aResMgr->setValue( "windows_visibility", itr.key(), itr.value() );
3847
3848   if ( desktop() )
3849     aResMgr->setValue( "desktop", "geometry", desktop()->storeGeometry() );
3850
3851 #if GUI_DEVELOPMENT > 0
3852   aResMgr->setValue( "salome", "version", QString(GUI_VERSION_STR)+"dev" );
3853 #else
3854   aResMgr->setValue( "salome", "version", QString(GUI_VERSION_STR) );
3855 #endif
3856
3857   aResMgr->save();
3858 }
3859
3860 /*!
3861   Updates desktop title
3862 */
3863 void LightApp_Application::updateDesktopTitle()
3864 {
3865   QString aTitle = applicationName();
3866   QString aVer = applicationVersion();
3867   if ( !aVer.isEmpty() )
3868     aTitle += QString( " " ) + aVer;
3869
3870   if ( activeStudy() ) {
3871     QString sName = SUIT_Tools::file( activeStudy()->studyName().trimmed(), false );
3872     aTitle += QString( " - [%1]" ).arg( sName );
3873   }
3874
3875   desktop()->setWindowTitle( aTitle );
3876 }
3877
3878 /*!
3879   \brief Get map of the operations which can be performed
3880   on the module activation.
3881
3882   The method should return the map of the kind \c {<id>:<name>}
3883   where \c <id> is an integer identifier of the operation and
3884   \c <name> is a title for the button to be added to the
3885   dialog box. After user selects the required operation by the
3886   clicking the corresponding button in the dialog box, its identifier
3887   is passed to the moduleActionSelected() method to process
3888   the made choice.
3889
3890   \return map of the operations
3891   \sa moduleActionSelected()
3892 */
3893 QMap<int, QString> LightApp_Application::activateModuleActions() const
3894 {
3895   QMap<int, QString> opmap;
3896   opmap.insert( NewStudyId,  tr( "ACTIVATE_MODULE_OP_NEW" ) );
3897   opmap.insert( OpenStudyId, tr( "ACTIVATE_MODULE_OP_OPEN" ) );
3898   return opmap;
3899 }
3900
3901 /*!
3902   \brief Called when the used selectes required operation chosen
3903   from "Activate module" dialog box.
3904
3905   Performs the required operation according to the user choice.
3906
3907   \param id operation identifier
3908   \sa activateModuleActions()
3909 */
3910 void LightApp_Application::moduleActionSelected( const int id )
3911 {
3912   switch ( id ) {
3913   case NewStudyId:
3914     onNewDoc();
3915     break;
3916   case OpenStudyId:
3917     onOpenDoc();
3918     break;
3919   default:
3920     break;
3921   }
3922 }
3923
3924 /*!
3925   Updates windows after close document
3926 */
3927 void LightApp_Application::afterCloseDoc()
3928 {
3929   updateWindows();
3930
3931   CAM_Application::afterCloseDoc();
3932 }
3933
3934 /*!
3935   Updates actions of active module
3936 */
3937 void LightApp_Application::updateModuleActions()
3938 {
3939   QString modName;
3940   if ( activeModule() )
3941     modName = activeModule()->moduleName();
3942
3943   LightApp_ModuleAction* moduleAction =
3944     qobject_cast<LightApp_ModuleAction*>( action( ModulesListId ) );
3945   if ( moduleAction )
3946     moduleAction->setActiveModule( modName );
3947 }
3948
3949 void LightApp_Application::removeModuleAction( const QString& modName )
3950 {
3951   LightApp_ModuleAction* moduleAction =
3952     qobject_cast<LightApp_ModuleAction*>( action( ModulesListId ) );
3953   if ( moduleAction )
3954     moduleAction->removeModule( modName );
3955 }
3956
3957 bool LightApp_Application::checkModule( const QString& title )
3958 {
3959   if ( title.isEmpty() )
3960     return false;
3961
3962   QString library = moduleLibrary( title, true );
3963   if ( library.isEmpty() )
3964     return false;
3965
3966   QString name = moduleName( title );
3967
3968   bool isPyModule = library.contains( "SalomePyQtGUI" ) || library.contains( "SalomePyQtGUILight" );
3969
3970   QStringList paths;
3971 #if defined(WIN32)
3972   paths = QString( Qtx::getenv( "PATH" ) ).split( ";", QString::SkipEmptyParts );
3973 #elif defined(__APPLE__)
3974   paths = QString( Qtx::getenv( "DYLD_LIBRARY_PATH" ) ).split( ":", QString::SkipEmptyParts );
3975 #else
3976   paths = QString( Qtx::getenv( "LD_LIBRARY_PATH" ) ).split( ":", QString::SkipEmptyParts );
3977 #endif
3978
3979   bool isFound = false;
3980   QStringList::const_iterator it;
3981   for ( it = paths.begin(); it != paths.end() && !isFound; ++it )
3982   {
3983     isFound = QFileInfo( Qtx::addSlash( *it ) + library ).exists();
3984   }
3985
3986   if ( !isFound )
3987   {
3988     INFOS( std::endl <<
3989            "****************************************************************" << std::endl <<
3990            "     Warning: library " << qPrintable( library ) << " is not found!" << std::endl <<
3991            "     Module " << qPrintable( title ) << " will not be available in GUI mode!" << std::endl <<
3992            "****************************************************************" << std::endl);
3993     return false;
3994   }
3995
3996   if ( isPyModule )
3997   {
3998     QString pyModule = QString( "%1GUI.py" ).arg( name );
3999 #if defined(WIN32)
4000     paths = QString( Qtx::getenv( "PYTHONPATH" ) ).split( ";", QString::SkipEmptyParts );
4001 #else
4002     paths = QString( Qtx::getenv( "PYTHONPATH" ) ).split( ":", QString::SkipEmptyParts );
4003 #endif
4004     isFound = false;
4005     for ( it = paths.begin(); it != paths.end() && !isFound; ++it )
4006     {
4007       isFound = QFileInfo( Qtx::addSlash( *it ) + pyModule ).exists();
4008     }
4009
4010     if ( !isFound )
4011     {
4012       INFOS( std::endl <<
4013              "****************************************************************" << std::endl <<
4014              "     Warning: Python module " << qPrintable( pyModule ) << " is not found!" << std::endl <<
4015              "     Module " << qPrintable( title ) << " will not be available in GUI mode!" << std::endl <<
4016              "****************************************************************" << std::endl);
4017       return false;
4018     }
4019   }
4020
4021   return true;
4022 }
4023
4024 /*!
4025   Gets current windows.
4026   \param winMap - output current windows map.
4027 */
4028 void LightApp_Application::currentWindows( QMap<int, int>& winMap ) const
4029 {
4030   winMap.clear();
4031   if ( activeModule() && activeModule()->inherits( "LightApp_Module" ) )
4032     ((LightApp_Module*)activeModule())->windows( winMap );
4033   else
4034     defaultWindows( winMap );
4035 }
4036
4037 /*!
4038   Gets current view managers.
4039   \param lst - output current view managers list.
4040 */
4041 void LightApp_Application::currentViewManagers( QStringList& lst ) const
4042 {
4043   lst.clear();
4044   if ( !activeStudy() )
4045     return;
4046
4047   if ( activeModule() && activeModule()->inherits( "LightApp_Module" ) )
4048     ((LightApp_Module*)activeModule())->viewManagers( lst );
4049   else
4050     defaultViewManagers( lst );
4051 }
4052
4053 /*!
4054   Updates windows
4055 */
4056 void LightApp_Application::updateWindows()
4057 {
4058   QMap<int, int> winMap;
4059   currentWindows( winMap );
4060
4061   for ( QMap<int, int>::ConstIterator it = winMap.begin(); it != winMap.end(); ++it )
4062   {
4063     if ( !dockWindow( it.key() ) )
4064       getWindow( it.key() );
4065   }
4066
4067   for ( WinMap::ConstIterator it = myWin.begin(); it != myWin.end(); ++it )
4068   {
4069     QWidget* wid = it.value();
4070     if ( winMap.contains( it.key() ) )
4071       wid->setVisible( true );
4072     else
4073       delete wid;
4074   }
4075
4076   loadDockWindowsState();
4077 }
4078
4079 /*!
4080   Updates view managers
4081 */
4082 void LightApp_Application::updateViewManagers()
4083 {
4084   QStringList lst;
4085   currentViewManagers( lst );
4086
4087   for ( QStringList::const_iterator it = lst.begin(); it != lst.end(); ++it )
4088     getViewManager( *it, true );
4089 }
4090
4091 /*!
4092   Loads windows geometry
4093 */
4094 void LightApp_Application::loadDockWindowsState()
4095 {
4096   if ( !desktop() )
4097     return;
4098   SUIT_ResourceMgr* aResMgr = SUIT_Session::session()->resourceMgr();
4099   bool storeWin = aResMgr->booleanValue( "Study", "store_positions", true );
4100   bool storeTb = aResMgr->booleanValue( "Study", "store_tool_positions", true );
4101
4102   QString modName;
4103   if ( activeModule() )
4104     modName = activeModule()->name();
4105   else if ( activeStudy() )
4106     modName = "nomodule";
4107
4108   QtxResourceMgr::WorkingMode prevMode = aResMgr->setWorkingMode( QtxResourceMgr::IgnoreUserValues );
4109   QByteArray aDefaultState;
4110   aResMgr->value( "windows_geometry", modName, aDefaultState );
4111   QByteArray aDefaultVisibility;
4112   aResMgr->value( "windows_visibility", modName, aDefaultVisibility );
4113   bool hasDefaultVisibility = !aDefaultVisibility.isEmpty();
4114   aResMgr->setWorkingMode( prevMode );
4115
4116   if( !storeWin && !storeTb && aDefaultState.isEmpty() && !hasDefaultVisibility)
4117     return;
4118
4119   if ( aResMgr->hasValue("windows_geometry" ,modName ) ) {
4120     long version = Qtx::versionToId( aResMgr->stringValue( "windows_geometry_version", modName, "" ) );
4121     QByteArray arr;
4122     if ( version > Qtx::versionToId( "7.4.1" ) )
4123       aResMgr->value( "windows_geometry", modName , arr );
4124     else
4125       arr = aDefaultState;
4126     QByteArray aTargetArray = processState(arr, storeWin, storeTb, true, aDefaultState);
4127     desktop()->restoreState( aTargetArray );
4128   }
4129
4130   QStringList mainToolbarsNames;
4131   mainToolbarsNames << "SalomeStandard" << "SalomeModules";
4132   QList<QToolBar*> mainToolbars = findToolBars( mainToolbarsNames );
4133   foreach( QToolBar* tb, mainToolbars ) tb->setVisible( true );
4134   /*
4135   if ( !myWinVis.contains( modName ) && aDefaultVisibility.isEmpty())
4136     return;
4137
4138   QMap<QString, bool> *tbMap = 0;
4139   QMap<QString, bool> *dwMap = 0;
4140
4141   QMap<QString, bool> userTbMap, userDwMap;
4142   dockWindowsState( myWinVis[modName], userTbMap, userDwMap );
4143
4144   QMap<QString, bool> defaultTbMap, defaultDwMap;
4145   if(hasDefaultVisibility) {
4146     dockWindowsState( aDefaultVisibility, defaultTbMap, defaultDwMap);
4147   }
4148
4149   if(storeTb) {
4150     tbMap =  &userTbMap;
4151   } else {
4152     if(hasDefaultVisibility){
4153       tbMap =  &defaultTbMap;
4154     }
4155   }
4156
4157   if(storeWin) {
4158     dwMap =  &userDwMap;
4159   } else {
4160     if(hasDefaultVisibility){
4161       dwMap =  &defaultDwMap;
4162     }
4163   }
4164
4165   if(tbMap) {
4166     QList<QToolBar*> tbList = findToolBars();
4167     for ( QList<QToolBar*>::iterator tit = tbList.begin(); tit != tbList.end(); ++tit )
4168       {
4169         QToolBar* tb = *tit;
4170         if ( tbMap->contains( tb->objectName() ) ) {
4171           tb->setVisible( (*tbMap)[tb->objectName()] );
4172         }
4173       }
4174   }
4175
4176   if(dwMap) {
4177     QList<QDockWidget*> dwList = desktop()->findChildren<QDockWidget*>();
4178     for ( QList<QDockWidget*>::iterator dit = dwList.begin(); dit != dwList.end(); ++dit )
4179       {
4180         QDockWidget* dw = *dit;
4181
4182         QObject* po = Qtx::findParent( dw, "QMainWindow" );
4183         if ( po != desktop() )
4184           continue;
4185
4186         if ( dwMap->contains( dw->objectName() ) )
4187           dw->setVisible( (*dwMap)[dw->objectName()] );
4188       }
4189   }
4190   */
4191 }
4192
4193
4194 /*!
4195   Saves windows geometry
4196 */
4197 void LightApp_Application::saveDockWindowsState()
4198 {
4199   if ( !desktop() )
4200     return;
4201
4202   bool storeWin = resourceMgr()->booleanValue( "Study", "store_positions", true );
4203   bool storeTb = resourceMgr()->booleanValue( "Study", "store_tool_positions", true );
4204
4205   if( !storeWin && !storeTb )
4206     return;
4207
4208   QString modName;
4209   if ( activeModule() )
4210     modName = activeModule()->name();
4211   else if ( activeStudy() )
4212     modName = "nomodule";
4213
4214   QString versionId = GUI_VERSION_STR;
4215 #if GUI_DEVELOPMENT > 0
4216   versionId += "dev";
4217 #endif
4218
4219   QByteArray arr = desktop()->saveState();
4220   resourceMgr()->setValue( "windows_geometry", modName, processState(arr, storeWin, storeTb, false) );
4221   resourceMgr()->setValue( "windows_geometry_version", modName, versionId );
4222
4223   QByteArray visArr;
4224   if ( myWinVis.contains( modName ) )
4225     visArr = myWinVis[modName];
4226
4227   QMap<QString, bool> tbMap, dwMap;
4228   dockWindowsState( visArr, tbMap, dwMap );
4229
4230   QList<QToolBar*> tbList = desktop()->findChildren<QToolBar*>();
4231   for ( QList<QToolBar*>::iterator it = tbList.begin(); it != tbList.end(); ++it )
4232   {
4233     QToolBar* tb = *it;
4234     tbMap.insert( tb->objectName(), tb->toggleViewAction()->isChecked() );
4235   }
4236
4237   QList<QDockWidget*> dwList = desktop()->findChildren<QDockWidget*>();
4238   for ( QList<QDockWidget*>::iterator it = dwList.begin(); it != dwList.end(); ++it )
4239   {
4240     QDockWidget* wid = *it;
4241     dwMap.insert( wid->objectName(), wid->toggleViewAction()->isChecked() );
4242   }
4243
4244   visArr = dockWindowsState( tbMap, dwMap );
4245
4246   myWinVis.insert( modName, visArr );
4247 }
4248
4249 QByteArray LightApp_Application::dockWindowsState( const QMap<QString, bool>& tb, const QMap<QString, bool>& dw ) const
4250 {
4251   QByteArray visArr;
4252   QDataStream stream( &visArr, QIODevice::WriteOnly );
4253
4254   stream << (uchar)ToolBarMarker;
4255   stream << tb.size();
4256   for ( QMap<QString, bool>::const_iterator tit = tb.begin(); tit != tb.end(); ++tit )
4257   {
4258     stream << tit.key();
4259     stream << (uchar)( tit.value() ? 1 : 0 );
4260   }
4261
4262   stream << (uchar)DockWidgetMarker;
4263   stream << dw.size();
4264   for ( QMap<QString, bool>::const_iterator wit = dw.begin(); wit != dw.end(); ++wit )
4265   {
4266     stream << wit.key();
4267     stream << (uchar)( wit.value() ? 1 : 0 );
4268   }
4269
4270   return visArr;
4271 }
4272
4273 void LightApp_Application::dockWindowsState( const QByteArray& arr, QMap<QString, bool>& tb, QMap<QString, bool>& dw ) const
4274 {
4275   tb.clear();
4276   dw.clear();
4277
4278   QByteArray visArr = arr;
4279   QDataStream stream( &visArr, QIODevice::ReadOnly );
4280
4281   uchar marker;
4282   stream >> marker;
4283   if ( marker != ToolBarMarker )
4284     return;
4285
4286   int lines;
4287   stream >> lines;
4288   for ( int i = 0; i < lines; ++i )
4289   {
4290     QString objectName;
4291     stream >> objectName;
4292     uchar shown;
4293     stream >> shown;
4294     tb.insert( objectName, shown );
4295   }
4296
4297   stream >> marker;
4298   if ( marker != DockWidgetMarker )
4299     return;
4300
4301   stream >> lines;
4302   for ( int j = 0; j < lines; ++j )
4303   {
4304     QString objectName;
4305     stream >> objectName;
4306     uchar shown;
4307     stream >> shown;
4308     dw.insert( objectName, shown );
4309   }
4310 }
4311
4312 /*!
4313   Adds icon names for modules
4314 */
4315 void LightApp_Application::moduleIconNames( QMap<QString, QString>& iconMap ) const
4316 {
4317   iconMap.clear();
4318
4319   SUIT_ResourceMgr* resMgr = resourceMgr();
4320   if ( !resMgr )
4321     return;
4322
4323   QStringList modList;
4324   modules( modList, false );
4325
4326   for ( QStringList::const_iterator it = modList.begin(); it != modList.end(); ++it )
4327   {
4328     QString modName = *it;
4329     QString modIntr = moduleName( modName );
4330     QString modIcon = resMgr->stringValue( modIntr, "icon", QString() );
4331
4332     if ( modIcon.isEmpty() )
4333       continue;
4334
4335     if ( SUIT_Tools::extension( modIcon ).isEmpty() )
4336       modIcon += QString( ".png" );
4337
4338     iconMap.insert( modName, modIcon );
4339   }
4340 }
4341
4342 /*!
4343   Inserts items in popup, which necessary for current application
4344 */
4345 void LightApp_Application::contextMenuPopup( const QString& type, QMenu* thePopup, QString& title )
4346 {
4347   //Add "Rename" item
4348   LightApp_SelectionMgr* selMgr = LightApp_Application::selectionMgr();
4349   bool cacheIsOn = selMgr->isSelectionCacheEnabled();
4350   selMgr->setSelectionCacheEnabled( true );
4351
4352   SUIT_DataBrowser* ob = objectBrowser();
4353
4354   CAM_Application::contextMenuPopup( type, thePopup, title );
4355
4356   if ( ob && type == ob->popupClientType() ) {
4357     thePopup->addSeparator();
4358     QAction* a = thePopup->addAction( tr( "MEN_REFRESH" ), this, SLOT( onRefresh() ) );
4359     if ( ob->shortcutKey(SUIT_DataBrowser::UpdateShortcut) )
4360       a->setShortcut( ob->shortcutKey(SUIT_DataBrowser::UpdateShortcut) );
4361   }
4362
4363 #ifndef DISABLE_SALOMEOBJECT
4364   if ( selMgr && ob ) {
4365     SALOME_ListIO selected;
4366     selMgr->selectedObjects( selected );
4367     if(selected.Extent() == 1){
4368       Handle(SALOME_InteractiveObject) anIObject = selected.First();
4369       SUIT_DataObject* obj = findObject(anIObject->getEntry());
4370       if(obj && obj->renameAllowed()) {
4371         QAction* a = new QAction(tr("MEN_RENAME_OBJ"), thePopup);
4372         connect( a, SIGNAL( triggered(bool) ), ob, SLOT( onStartEditing() ) );
4373         if ( ob->shortcutKey(SUIT_DataBrowser::RenameShortcut) )
4374           a->setShortcut( ob->shortcutKey(SUIT_DataBrowser::RenameShortcut) );
4375
4376         QList<QAction*> acts = thePopup->actions();
4377         QAction* firstAction = acts.count() > 0 ? acts.first() : 0;
4378         thePopup->insertAction(firstAction,a);
4379       }
4380     }
4381   }
4382 #endif
4383
4384   selMgr->setSelectionCacheEnabled( cacheIsOn );
4385 }
4386
4387 /*!
4388   Create empty study
4389 */
4390 void LightApp_Application::createEmptyStudy()
4391 {
4392   CAM_Application::createEmptyStudy();
4393
4394   if ( objectBrowser() )
4395     objectBrowser()->updateTree();
4396
4397   SUIT_ResourceMgr* aResMgr = SUIT_Session::session()->resourceMgr();
4398   if ( aResMgr && activeStudy() ) {
4399     int autoSaveInterval = aResMgr->integerValue( "Study", "auto_save_interval", 0 );
4400     if ( autoSaveInterval > 0 ) myAutoSaveTimer->start( autoSaveInterval*60000 );
4401   }
4402 }
4403
4404 /*!Set desktop:*/
4405 void LightApp_Application::setDesktop( SUIT_Desktop* desk )
4406 {
4407   CAM_Application::setDesktop( desk );
4408
4409   if ( desk ) {
4410     connect( desk, SIGNAL( message( const QString& ) ),
4411              this, SLOT( onDesktopMessage( const QString& ) ), Qt::UniqueConnection );
4412     connect( desk, SIGNAL( windowActivated( SUIT_ViewWindow* ) ),
4413              this, SLOT( onWindowActivated( SUIT_ViewWindow* ) ), Qt::UniqueConnection );
4414     /* connect( desk, SIGNAL( windowMoved( SUIT_ViewWindow* ) ),
4415              this, SLOT( onWindowMoved( SUIT_ViewWindow* ) ), Qt::UniqueConnection ); */
4416   }
4417 }
4418
4419 /*!
4420   Activates module
4421   \param mod - module to be activated
4422 */
4423 bool LightApp_Application::activateModule( CAM_Module* mod )
4424 {
4425   bool res = CAM_Application::activateModule( mod );
4426
4427   if ( objectBrowser() )
4428     objectBrowser()->updateTree();
4429
4430   return res;
4431 }
4432
4433 /*!
4434   \return keyborad accelerators manager object
4435 */
4436 SUIT_Accel* LightApp_Application::accel() const
4437 {
4438   return myAccel;
4439 }
4440
4441 /*!
4442   Removes dead widget container from map
4443 */
4444 void LightApp_Application::onWCDestroyed( QObject* ob )
4445 {
4446   // remove destroyed widget container from windows map
4447   for ( WinMap::ConstIterator itr = myWin.begin(); itr != myWin.end(); ++itr )
4448   {
4449     if ( itr.value() != ob )
4450       continue;
4451
4452     int key = itr.key();
4453     myWin.remove( key );
4454     break;
4455   }
4456 }
4457
4458 void LightApp_Application::onMRUActivated( const QString& name )
4459 {
4460   SUIT_Session* s = SUIT_Session::session();
4461   if ( s && s->activeApplication() == this )
4462     onOpenDoc( name );
4463 }
4464
4465 void LightApp_Application::onStylePreferences()
4466 {
4467 #ifdef USE_SALOME_STYLE
4468   Style_PrefDlg dlg( desktop() );
4469   dlg.exec();
4470
4471   resourceMgr()->setValue( "Style", "use_salome_style", Style_Salome::isActive() );
4472 #endif // USE_SALOME_STYLE
4473 }
4474
4475 void LightApp_Application::onFullScreen(){
4476   if(myScreenHelper) {
4477     if(desktop()->isFullScreen())
4478       myScreenHelper->switchToNormalScreen();
4479     else
4480       myScreenHelper->switchToFullScreen();
4481   }
4482 }
4483
4484 /*!
4485   Connects just added view manager
4486 */
4487 void LightApp_Application::addViewManager( SUIT_ViewManager* vm )
4488 {
4489   connect( vm, SIGNAL( lastViewClosed( SUIT_ViewManager* ) ),
4490            this, SLOT( onCloseView( SUIT_ViewManager* ) ) );
4491   CAM_Application::addViewManager( vm );
4492 }
4493
4494 /*!
4495   Remove view manager from memory
4496 */
4497 void LightApp_Application::removeViewManager( SUIT_ViewManager* vm )
4498 {
4499   disconnect( vm, SIGNAL( lastViewClosed( SUIT_ViewManager* ) ),
4500            this, SLOT( onCloseView( SUIT_ViewManager* ) ) );
4501   LightApp_Study* aStudy = dynamic_cast<LightApp_Study*>(activeStudy());
4502   if (aStudy )
4503     aStudy->removeObjectProperties( vm->getGlobalId() );
4504
4505   CAM_Application::removeViewManager( vm );
4506
4507   LightApp_SelectionMgr* selMgr = selectionMgr();
4508   QList<SUIT_Selector*> selectors;
4509   selMgr->selectors( selectors );
4510   foreach( SUIT_Selector* selector, selectors ) {
4511     if ( selector->owner() == vm->getViewModel() ) {
4512       delete selector;
4513     }
4514   }
4515
4516   // IPAL22894: Crash on closing OCC view
4517   //delete vm;
4518   vm->deleteLater();
4519 }
4520
4521 /*!
4522   Renames active window of desktop
4523 */
4524 void LightApp_Application::onRenameWindow()
4525 {
4526   if( !desktop() )
4527     return;
4528
4529   QWidget* w = desktop()->activeWindow();
4530   if( !w )
4531     return;
4532
4533   bool ok;
4534   QString name = QInputDialog::getText( w, tr( "TOT_RENAME" ), tr( "PRP_RENAME" ), QLineEdit::Normal, w->windowTitle(), &ok );
4535   if( ok && !name.isEmpty() )
4536     w->setWindowTitle( name );
4537 }
4538
4539 /*!
4540   Closes active window of desktop
4541 */
4542 void LightApp_Application::onCloseWindow()
4543 {
4544   if( !desktop() )
4545     return;
4546
4547   QWidget* w = desktop()->activeWindow();
4548   if( !w )
4549     return;
4550
4551   w->close();
4552 }
4553
4554 /*!
4555   Closes all windows of desktop
4556 */
4557 void LightApp_Application::onCloseAllWindow()
4558 {
4559   STD_TabDesktop* desk = dynamic_cast<STD_TabDesktop*>( desktop() );
4560   if( !desk )
4561     return;
4562
4563   QList<SUIT_ViewWindow*> wndList = desk->windows();
4564   SUIT_ViewWindow* wnd;
4565   foreach( wnd, wndList )
4566   {
4567     if ( wnd )
4568       wnd->close();
4569   }
4570 }
4571
4572 /*!
4573   Groups all windows of desktop
4574 */
4575 void LightApp_Application::onGroupAllWindow()
4576 {
4577   STD_TabDesktop* desk = dynamic_cast<STD_TabDesktop*>( desktop() );
4578   if( !desk )
4579     return;
4580
4581   QtxWorkstack* wgStack = desk->workstack();
4582   if ( wgStack )
4583     wgStack->stack();
4584 }
4585
4586 /*!
4587   \return default name for an active study
4588 */
4589 void LightApp_Application::setDefaultStudyName( const QString& theName )
4590 {
4591   QStringList anInfoList;
4592   modules( anInfoList, false );
4593
4594   LightApp_Study* aStudy = (LightApp_Study*)activeStudy();
4595   if( anInfoList.count() == 1 && // to avoid a conflict between different modules
4596       !aStudy->isSaved() )
4597   {
4598     aStudy->setStudyName( theName );
4599     updateDesktopTitle();
4600   }
4601 }
4602
4603 /*!
4604   Custom event handler
4605 */
4606 bool LightApp_Application::event( QEvent* e )
4607 {
4608   if( e && e->type()==2000 )
4609   {
4610     SALOME_CustomEvent* ce = ( SALOME_CustomEvent* )e;
4611     QString* d = ( QString* )ce->data();
4612     if( SUIT_MessageBox::question(0, tr("WRN_WARNING"),
4613                                   d ? *d : "",
4614                                   SUIT_MessageBox::Yes | SUIT_MessageBox::No,
4615                                   SUIT_MessageBox::Yes ) == SUIT_MessageBox::Yes )
4616     {
4617       QStringList path;
4618       path << tr( "PREF_CATEGORY_SALOME" ) << tr( "PREF_TAB_GENERAL" )
4619            << tr( "PREF_GROUP_EXT_BROWSER" ) << tr( "PREF_APP" );
4620       showPreferences( path );
4621     }
4622     if( d )
4623       delete d;
4624     return true;
4625   }
4626   return CAM_Application::event( e );
4627 }
4628
4629 /*! Check data object */
4630 bool LightApp_Application::checkDataObject(LightApp_DataObject* theObj)
4631 {
4632   if (theObj)
4633     {
4634       bool isSuitable = !theObj->entry().isEmpty() &&
4635                         !theObj->componentDataType().isEmpty() &&
4636                         !theObj->name().isEmpty();
4637       return isSuitable;
4638     }
4639
4640   return false;
4641 }
4642
4643 int LightApp_Application::openChoice( const QString& aName )
4644 {
4645   int choice = CAM_Application::openChoice( aName );
4646
4647   if ( choice == OpenExist ) // The document is already open.
4648   {
4649     // Do you want to reload it?
4650     if ( SUIT_MessageBox::question( desktop(), tr( "WRN_WARNING" ), tr( "QUE_DOC_ALREADYOPEN" ).arg( aName ),
4651                                     SUIT_MessageBox::Yes | SUIT_MessageBox::No, SUIT_MessageBox::No ) == SUIT_MessageBox::Yes )
4652       choice = OpenReload;
4653   }
4654
4655   return choice;
4656 }
4657
4658 bool LightApp_Application::openAction( const int choice, const QString& aName )
4659 {
4660   bool res = false;
4661   switch ( choice )
4662   {
4663   case OpenReload:
4664     {
4665       STD_Application* app = 0;
4666       SUIT_Session* session = SUIT_Session::session();
4667       QList<SUIT_Application*> appList = session->applications();
4668       for ( QList<SUIT_Application*>::iterator it = appList.begin(); it != appList.end() && !app; ++it )
4669       {
4670         if ( (*it)->activeStudy() && (*it)->activeStudy()->studyName() == aName )
4671           app = ::qobject_cast<STD_Application*>( *it );
4672       }
4673
4674       if ( app )
4675       {
4676         app->onCloseDoc( false );
4677         appList = session->applications();
4678         STD_Application* other = 0;
4679         for ( QList<SUIT_Application*>::iterator it = appList.begin(); it != appList.end() && !other; ++it )
4680           other = ::qobject_cast<STD_Application*>( *it );
4681
4682         if ( other )
4683           res = other->onOpenDoc( aName );
4684       }
4685     }
4686     break;
4687   default:
4688     res = CAM_Application::openAction( choice, aName );
4689     break;
4690   }
4691
4692   return res;
4693 }
4694
4695 QStringList LightApp_Application::viewManagersTypes() const
4696 {
4697   QStringList aTypesList;
4698   aTypesList += myUserWmTypes;
4699 #ifndef DISABLE_GLVIEWER
4700   aTypesList<<GLViewer_Viewer::Type();
4701 #endif
4702 #ifndef DISABLE_PLOT2DVIEWER
4703   aTypesList<<Plot2d_Viewer::Type();
4704 #endif
4705 #ifndef DISABLE_QXGRAPHVIEWER
4706   aTypesList<<QxScene_Viewer::Type();
4707 #endif
4708 #ifndef DISABLE_PVVIEWER
4709   aTypesList<<PVViewer_Viewer::Type();
4710 #endif
4711 #ifndef DISABLE_PYVIEWER
4712   aTypesList<<PyViewer_Viewer::Type();
4713 #endif
4714 #ifndef DISABLE_OCCVIEWER
4715   aTypesList<<OCCViewer_Viewer::Type();
4716 #endif
4717 #ifndef DISABLE_VTKVIEWER
4718  #ifndef DISABLE_SALOMEOBJECT
4719   aTypesList<<SVTK_Viewer::Type();
4720  #else
4721   aTypesList<<VTKViewer_Viewer::Type();
4722  #endif
4723 #endif
4724   return aTypesList;
4725 }
4726 /*!
4727  * Removes all view managers of known types
4728  * Other view managers are ignored
4729  */
4730 void LightApp_Application::clearKnownViewManagers()
4731 {
4732   QStringList aTypesList = viewManagersTypes();
4733   QList<SUIT_ViewManager*> aMgrList;
4734   viewManagers( aMgrList );
4735   foreach (SUIT_ViewManager* aMgr, aMgrList) {
4736     if (aTypesList.contains(aMgr->getType()))
4737       removeViewManager(aMgr);
4738   }
4739 }
4740
4741 /*!
4742   Copy of current selection
4743  */
4744 void LightApp_Application::onCopy()
4745 {
4746   LightApp_Module* m = dynamic_cast<LightApp_Module*>( activeModule() );
4747   if( m )
4748     m->copy();
4749 }
4750
4751 /*!
4752   Paste of current data in clipboard
4753  */
4754 void LightApp_Application::onPaste()
4755 {
4756   LightApp_Module* m = dynamic_cast<LightApp_Module*>( activeModule() );
4757   if( m )
4758     m->paste();
4759 }
4760
4761 /*!
4762   Browse (i.e. set focus on) the published objects
4763   \param theIsApplyAndClose - flag indicating that the dialog for creating objects
4764                               has been accepted by Ok (or Apply & Close) button
4765   \param theIsOptimizedBrowsing - flag switching to optimized browsing mode
4766                                   (to select the first published object only)
4767   \return entry of the selected object
4768  */
4769 QString LightApp_Application::browseObjects( const QStringList& theEntryList,
4770                                              const bool theIsApplyAndClose,
4771                                              const bool theIsOptimizedBrowsing )
4772 {
4773   QString aResult;
4774   if( SUIT_ResourceMgr* aResourceMgr = resourceMgr() )
4775   {
4776     int aBrowsePolicy = aResourceMgr->integerValue( "ObjectBrowser", "browse_published_object", (int)BP_Never );
4777     switch( aBrowsePolicy )
4778     {
4779       case BP_Never:
4780         return aResult;
4781       case BP_ApplyAndClose:
4782         if( !theIsApplyAndClose )
4783           return aResult;
4784       case BP_Always:
4785       default:
4786         break;
4787     }
4788   }
4789
4790   LightApp_Study* aStudy = dynamic_cast<LightApp_Study*>( activeStudy() );
4791   if( !aStudy )
4792     return aResult;
4793
4794   SUIT_DataBrowser* anOB = objectBrowser();
4795   if( !anOB )
4796     return aResult;
4797
4798   SUIT_AbstractModel* aModel = dynamic_cast<SUIT_AbstractModel*>( anOB->model() );
4799   if( !aModel )
4800     return aResult;
4801
4802   QStringListIterator anIter( theEntryList );
4803   if( theIsOptimizedBrowsing )
4804   {
4805     // go to the last entry
4806     anIter.toBack();
4807     if( anIter.hasPrevious() )
4808       anIter.previous();
4809   }
4810
4811   // scroll to each entry in the list
4812   // (in optimized mode - to the last entry only)
4813   QString anEntry;
4814   LightApp_DataObject* anObject = 0;
4815   while( anIter.hasNext() )
4816   {
4817     anEntry = anIter.next();
4818     if( !anEntry.isEmpty() )
4819     {
4820       anObject = aStudy->findObjectByEntry( anEntry );
4821       if( anObject )
4822       {
4823         QModelIndex anIndex = aModel->index( anObject );
4824         anOB->treeView()->scrollTo( anIndex );
4825       }
4826     }
4827   }
4828
4829   // always select the last object
4830   if( anObject && !anEntry.isEmpty() )
4831   {
4832     QList<SUIT_Selector*> aSelectorList;
4833     selectionMgr()->selectors( "ObjectBrowser", aSelectorList );
4834     if( !aSelectorList.isEmpty() )
4835     {
4836       if( LightApp_OBSelector* aSelector = dynamic_cast<LightApp_OBSelector*>( aSelectorList.first() ) )
4837       {
4838         bool anIsAutoBlock = aSelector->autoBlock();
4839
4840         // temporarily disable auto block, to emit LightApp_SelectionMgr::currentSelectionChanged() signal
4841         aSelector->setAutoBlock( false );
4842
4843         SUIT_DataOwnerPtrList aList;
4844 #ifndef DISABLE_SALOMEOBJECT
4845         Handle(SALOME_InteractiveObject) aSObj = new SALOME_InteractiveObject
4846           ( anObject->entry().toUtf8().constData(),
4847             anObject->componentDataType().toLatin1().constData(),
4848             anObject->name().toUtf8().constData() );
4849         LightApp_DataOwner* owner = new LightApp_DataOwner( aSObj  );
4850 #else
4851         LightApp_DataOwner* owner = new LightApp_DataOwner( anEntry );
4852 #endif
4853
4854         aList.append( owner );
4855         selectionMgr()->setSelected( aList );
4856         aResult = anEntry;
4857
4858         // restore auto block flag
4859         aSelector->setAutoBlock( anIsAutoBlock );
4860       }
4861     }
4862   }
4863
4864   return aResult;
4865 }
4866
4867 SUIT_DataObject* LightApp_Application::findObject( const QString& id ) const
4868 {
4869   LightApp_Study* study = dynamic_cast<LightApp_Study*>( activeStudy() );
4870   return study ? study->findObjectByEntry( id ) : 0;
4871 }
4872
4873 /*!
4874   Checks that an object can be renamed.
4875   \param entry entry of the object
4876   \brief Return \c true if object can be renamed
4877 */
4878 bool LightApp_Application::renameAllowed( const QString& /*entry*/) const {
4879   return false;
4880 }
4881
4882 /*!
4883   Rename object by entry.
4884   \param entry entry of the object
4885   \param name new name of the object
4886   \brief Return \c true if rename operation finished successfully, \c false otherwise.
4887 */
4888 bool LightApp_Application::renameObject( const QString& entry, const QString& ) {
4889   return false;
4890 }
4891
4892 /*! Process standard messages from desktop */
4893 void LightApp_Application::onDesktopMessage( const QString& message )
4894 {
4895   const QString sectionSeparator = "/";
4896
4897   if ( message.toLower() == "updateobjectbrowser" ||
4898        message.toLower() == "updateobjbrowser" ) {
4899     // update object browser
4900     updateObjectBrowser();
4901   }
4902   else if ( message.toLower().startsWith( "activate_viewer" ) ) {
4903     QString vtype = message.split( sectionSeparator ).last();
4904     if ( !vtype.isEmpty() )
4905       getViewManager( vtype, true );
4906   }
4907   else {
4908     QStringList data = message.split( sectionSeparator );
4909     if ( data.count() > 1 ) {
4910       QString msgType = data[0].trimmed();
4911       LightApp_Module* sMod = 0;
4912       CAM_Module* mod = module( msgType );
4913       if ( !mod )
4914         mod = module( moduleTitle( msgType ) );
4915       if ( mod && mod->inherits( "LightApp_Module" ) )
4916         sMod = (LightApp_Module*)mod;
4917
4918       if ( msgType.toLower() == "preferences" ) {
4919         // requested preferences change: should be given as "preferences/<section>/<name>/<value>"
4920         // for example "preferences/Study/multi_file_dump/true"
4921         if ( data.count() > 3 ) {
4922           QString section = data[1].trimmed();
4923           QString param   = data[2].trimmed();
4924           QString value   = QStringList( data.mid(3) ).join( sectionSeparator );
4925           resourceMgr()->setValue( section, param, value );
4926         }
4927       }
4928       else if ( sMod ) {
4929         // received message for the module
4930         QString msg = QStringList( data.mid(1) ).join( sectionSeparator );
4931         sMod->message( msg );
4932       }
4933     }
4934   }
4935 }
4936
4937 /*!
4938   Internal method.
4939   Returns all top level toolbars.
4940   Note : Result list contains only main window toolbars, not including toolbars from viewers.
4941 */
4942 QList<QToolBar*> LightApp_Application::findToolBars( const QStringList& names )
4943 {
4944   QList<QToolBar*> aResult;
4945   QList<QToolBar*> tbList = desktop()->findChildren<QToolBar*>();
4946   for ( QList<QToolBar*>::iterator tit = tbList.begin(); tit != tbList.end(); ++tit ) {
4947     QToolBar* tb = *tit;
4948     QObject* po = Qtx::findParent( tb, "QMainWindow" );
4949     if ( po != desktop() )
4950       continue;
4951     if ( names.isEmpty() || names.contains( tb->objectName() ) )
4952       aResult.append(tb);
4953   }
4954   return aResult;
4955 }
4956
4957 /*!
4958   Internal method to parse toolbars and dockable windows state.
4959 */
4960 QByteArray LightApp_Application::processState(QByteArray& input,
4961                                               const bool processWin,
4962                                               const bool processTb,
4963                                               const bool isRestoring,
4964                                               QByteArray defaultState) {
4965
4966   QByteArray aRes;
4967   bool hasDefaultState  = !defaultState.isEmpty();
4968   bool isDockWinWriten = false;
4969   int nbDocWin = -1;
4970   //Write date from users settings
4971   if(isRestoring){
4972     QDataStream tmpInputData(&input, QIODevice::ReadOnly);
4973     int marker, version;
4974     uchar dockmarker;
4975     tmpInputData >> marker;
4976     tmpInputData >> version;
4977     tmpInputData >> dockmarker;
4978     tmpInputData >> nbDocWin;
4979   }
4980   if(processWin && processTb && !isRestoring) {
4981     aRes = input;
4982   } else if(!processWin && !processTb ) {
4983     if(hasDefaultState)
4984       aRes = defaultState;
4985   } else {
4986     QDataStream aData(&aRes, QIODevice::WriteOnly);
4987     QList<QToolBar*> aToolBars = findToolBars();
4988
4989     QStringList aNames;
4990     for ( QList<QToolBar*>::iterator tit = aToolBars.begin(); tit != aToolBars.end(); ++tit ) {
4991       QToolBar* tb = *tit;
4992       aNames.append(tb->objectName());
4993     }
4994
4995     int toolBarMarkerIndex = getToolbarMarkerIndex(input,aNames);
4996     if(toolBarMarkerIndex < 0)
4997       return aRes;
4998     QDataStream anInputData(&input, QIODevice::ReadOnly);
4999
5000     int toolBarMarkerIndexDef;
5001     if(hasDefaultState) {
5002       toolBarMarkerIndexDef = getToolbarMarkerIndex(defaultState, aNames);
5003       if(toolBarMarkerIndexDef < 0)
5004         return aRes;
5005     }
5006     QDataStream anInputDataDef(&defaultState, QIODevice::ReadOnly);
5007
5008     QDataStream* aTargetData = 0;
5009     int          aTargetIndex = -1;
5010
5011     QByteArray currentArr = desktop()->saveState();
5012     QDataStream anInputDataCur(&currentArr, QIODevice::ReadOnly);
5013     bool useInputData = !isRestoring || (isRestoring && nbDocWin > 0);
5014     if(processWin && useInputData) {
5015       aTargetData = &anInputData;
5016       aTargetIndex = toolBarMarkerIndex;
5017     } else {
5018       //Write date from default settings
5019       if(hasDefaultState) {
5020         aTargetData = &anInputDataDef;
5021         aTargetIndex = toolBarMarkerIndexDef;
5022       } else {
5023         //If no default state, write current snapshot of the dockable windows
5024         if(isRestoring) {
5025           aTargetData = &anInputDataCur;
5026           int toolBarMarkerIndexCur = getToolbarMarkerIndex(currentArr, aNames);
5027           aTargetIndex = toolBarMarkerIndexCur;
5028         }
5029       }
5030     }
5031
5032     if(aTargetData && aTargetIndex >= 0 ) {
5033       aTargetData->device()->seek(0);
5034       while( aTargetData->device()->pos() < aTargetIndex ) {
5035         uchar ch;
5036         *aTargetData >> ch;
5037         aData<<ch;
5038       }
5039       isDockWinWriten = true;
5040     }
5041
5042     aTargetData = 0;
5043     aTargetIndex = -1;
5044
5045     if(processTb) {
5046       aTargetData = &anInputData;
5047       aTargetIndex = toolBarMarkerIndex;
5048     } else {
5049       if(hasDefaultState) {
5050         aTargetData = &anInputDataDef;
5051         aTargetIndex = toolBarMarkerIndexDef;
5052       }
5053     }
5054
5055     if(aTargetData && aTargetIndex >= 0) {
5056       int index;
5057       if(!isDockWinWriten ) {
5058         //Write version marker
5059         int marker, version;
5060         aTargetData->device()->seek(0);
5061         *aTargetData >> marker;
5062         *aTargetData >> version;
5063         aData << marker;
5064         aData << version;
5065         aData << (uchar) QDockWidgetMarker;
5066         aData << (int) 0;
5067         int shift = 4*sizeof(int) + sizeof(QSize);
5068         index = aTargetIndex - shift;
5069       } else {
5070         index = aTargetIndex;
5071       }
5072
5073       aTargetData->device()->seek(index);
5074       while(!aTargetData->atEnd()) {
5075         uchar ch;
5076         *aTargetData >> ch;
5077         aData << ch;
5078       }
5079     } else { // Not treat toolbars
5080       aData << (uchar) QToolBarMarker;
5081       aData << (int) 0; //Nb toolbars = 0
5082     }
5083   }
5084   return aRes;
5085 }
5086
5087 /*!
5088   \brief Emits operationFinished signal.
5089   \param theModuleName the name of the module which perfomed the operation
5090   \param theOperationName the operation name
5091   \param theEntryList the list of the created objects entries
5092 */
5093 void LightApp_Application::emitOperationFinished( const QString& theModuleName,
5094                                                   const QString& theOperationName,
5095                                                   const QStringList& theEntryList )
5096 {
5097   emit operationFinished( theModuleName, theOperationName, theEntryList );
5098 }
5099
5100 /*!
5101   Update visibility state of given objects
5102 */
5103 void LightApp_Application::updateVisibilityState( DataObjectList& theList,
5104                                                   SUIT_ViewModel*  theViewModel )
5105 {
5106   if ( !theViewModel || theList.isEmpty() ) return;
5107
5108   LightApp_Study* aStudy = dynamic_cast<LightApp_Study*>(activeStudy());
5109   if ( !aStudy ) return;
5110
5111   SALOME_View* aView = dynamic_cast<SALOME_View*>( theViewModel );
5112
5113   for ( DataObjectList::iterator itr = theList.begin(); itr != theList.end(); ++itr ) {
5114     LightApp_DataObject* obj = dynamic_cast<LightApp_DataObject*>(*itr);
5115
5116     if ( !obj || aStudy->isComponent( obj->entry() ) )
5117       continue;
5118
5119     LightApp_Module* anObjModule = dynamic_cast<LightApp_Module*>(obj->module());
5120     if ( anObjModule ) {
5121       LightApp_Displayer* aDisplayer = anObjModule->displayer();
5122       if ( aDisplayer ) {
5123         Qtx::VisibilityState anObjState = Qtx::UnpresentableState;
5124         if ( aDisplayer->canBeDisplayed( obj->entry(), theViewModel->getType() ) ) {
5125           if ( aView && aDisplayer->IsDisplayed( obj->entry(), aView ) )
5126             anObjState = Qtx::ShownState;
5127           else
5128             anObjState = Qtx::HiddenState;
5129         }
5130         aStudy->setVisibilityState( obj->entry(), anObjState );
5131       }
5132     }
5133   }
5134 }
5135
5136 /*!
5137  * Called when window activated
5138  */
5139 void LightApp_Application::onWindowActivated( SUIT_ViewWindow* theViewWindow )
5140 {
5141   SUIT_DataBrowser* anOB = objectBrowser();
5142   if ( !anOB )
5143     return;
5144   SUIT_DataObject* rootObj = anOB->root();
5145   if ( !rootObj )
5146     return;
5147
5148   DataObjectList listObj = rootObj->children( true );
5149
5150   SUIT_ViewModel* vmod = 0;
5151   if ( SUIT_ViewManager* vman = theViewWindow->getViewManager() )
5152     vmod = vman->getViewModel();
5153   updateVisibilityState( listObj, vmod );
5154 }
5155
5156 /*!
5157   Called then view manager removed
5158 */
5159 void LightApp_Application::onViewManagerRemoved( SUIT_ViewManager* )
5160 {
5161   ViewManagerList lst;
5162   viewManagers( lst );
5163   if ( lst.count() == 1) { // in case if closed last view window
5164     LightApp_Study* aStudy = dynamic_cast<LightApp_Study*>( activeStudy() );
5165     if ( aStudy )
5166       aStudy->setVisibilityStateForAll( Qtx::UnpresentableState );
5167   }
5168 }
5169
5170 /*!
5171   Check existing document.
5172 */
5173 bool LightApp_Application::checkExistingDoc( bool closeExistingDoc )
5174 {
5175   bool result = true;
5176   if( activeStudy() ) {
5177     int answer = !activeStudy()->isModified() ? 1 :
5178                  SUIT_MessageBox::question( desktop(),
5179                                             tr( "APPCLOSE_CAPTION" ),
5180                                             tr( "STUDYCLOSE_DESCRIPTION" ),
5181                                             tr( "APPCLOSE_SAVE" ),
5182                                             tr( "APPCLOSE_CLOSE" ),
5183                                             tr( "APPCLOSE_CANCEL" ), 0 );
5184     if(answer == 0) {
5185       if ( activeStudy()->isSaved() ) {
5186         onSaveDoc();
5187                 if (closeExistingDoc) {
5188                         closeDoc(false);
5189                 }
5190       } else if ( onSaveAsDoc() ) {
5191          if (closeExistingDoc) {
5192            if( !closeDoc( false ) ) {
5193              result = false;
5194            }
5195         }
5196       } else {
5197         result = false;
5198       }
5199     }
5200     else if( answer == 1 ) {
5201       if (closeExistingDoc) {
5202         closeDoc( false );
5203       }
5204     } else if( answer == 2 ) {
5205       result = false;
5206     }
5207   }
5208   return result;
5209 }
5210
5211 #ifndef DISABLE_PYCONSOLE
5212
5213 PyConsole_Interp* LightApp_Application::getPyInterp()
5214 {
5215   static PyConsole_Interp* myInterp = 0;
5216   if ( !myInterp ) {
5217     myInterp = createPyInterp();
5218     myInterp->initialize();
5219   }
5220   return myInterp;
5221 }
5222
5223 PyConsole_Interp* LightApp_Application::createPyInterp()
5224 {
5225   return new PyConsole_Interp();
5226 }
5227
5228 #endif // DISABLE_PYCONSOLE