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