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