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