src/LightApp/LightApp_Application.cxx

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