src/LightApp/LightApp_Application.cxx

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