src/LightApp/LightApp_Application.cxx

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