src/LightApp/LightApp_Application.cxx

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