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