src/LightApp/LightApp_Application.cxx

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