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