src/LightApp/LightApp_Application.cxx

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