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