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