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