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