src/LightApp/LightApp_Application.cxx

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