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