src/LightApp/LightApp_Application.cxx

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