src/LightApp/LightApp_Application.cxx

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