src/SALOME_PYQT/SalomePyQt/SalomePyQt.cxx

   1 // Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 // File   : SalomePyQt.cxx
  24 // Author : Vadim SANDLER, Open CASCADE S.A.S. (vadim.sandler@opencascade.com)
  25
  26 #ifdef WIN32
  27 // E.A. : On windows with python 2.6, there is a conflict
  28 // E.A. : between pymath.h and Standard_math.h which define
  29 // E.A. : some same symbols : acosh, asinh, ...
  30 #include <Standard_math.hxx>
  31 #include <pymath.h>
  32 #endif
  33
  34 #include "SALOME_PYQT_ModuleLight.h" // this include must be first!!!
  35 #include "SALOME_PYQT_DataModelLight.h"
  36 #include "SALOME_PYQT_PyModule.h"
  37 #include "SalomePyQt.h"
  38
  39 #include "LightApp_SelectionMgr.h"
  40 #include "LogWindow.h"
  41 #ifndef DISABLE_OCCVIEWER
  42 #include "OCCViewer_ViewWindow.h"
  43 #include "OCCViewer_ViewFrame.h"
  44 #endif // DISABLE_OCCVIEWER
  45 #ifndef DISABLE_PLOT2DVIEWER
  46 #include "Plot2d_ViewManager.h"
  47 #include "Plot2d_ViewWindow.h"
  48 #endif // DISABLE_PLOT2DVIEWER
  49 #ifndef DISABLE_PVVIEWER
  50 #include "PVViewer_ViewManager.h"
  51 #include "PVViewer_ViewModel.h"
  52 #endif // DISABLE_PVVIEWER
  53 #include "QtxActionMenuMgr.h"
  54 #include "QtxWorkstack.h"
  55 #include "QtxTreeView.h"
  56 #include "SALOME_Event.h"
  57 #include "STD_TabDesktop.h"
  58 #include "SUIT_DataBrowser.h"
  59 #include "SUIT_ResourceMgr.h"
  60 #include "SUIT_Session.h"
  61 #include "SUIT_Tools.h"
  62 #include "SUIT_ViewManager.h"
  63 #include "SUIT_ViewWindow.h"
  64 #include "PyConsole_Console.h"
  65
  66 #include <QAction>
  67 #include <QApplication>
  68 #include <QPaintEvent>
  69 #include <QCoreApplication>
  70
  71 namespace
  72 {
  73   /*!
  74     \brief Get the currently active application.
  75     \internal
  76     \return active application object or 0 if there is no any
  77   */
  78   LightApp_Application* getApplication()
  79   {
  80     if ( SUIT_Session::session() )
  81       return dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() );
  82     return 0;
  83   }
  84
  85   /*!
  86     \brief Get the currently active study.
  87     \internal
  88     \return active study or 0 if there is no study opened
  89   */
  90   LightApp_Study* getActiveStudy()
  91   {
  92     if ( getApplication() )
  93       return dynamic_cast<LightApp_Study*>( getApplication()->activeStudy() );
  94     return 0;
  95   }
  96
  97   /*!
  98     \brief Get the currently active module.
  99     \internal
 100     This function returns correct result only if Python-based
 101     module is currently active. Otherwize, 0 is returned.
 102   */
 103   LightApp_Module* getActiveModule()
 104   {
 105     LightApp_Module* module = 0;
 106     if ( LightApp_Application* anApp = getApplication() ) {
 107       module = PyModuleHelper::getInitModule();
 108       if ( !module )
 109         module = dynamic_cast<LightApp_Module*>( anApp->activeModule() );
 110     }
 111     return module;
 112   }
 113
 114   /*!
 115     \brief Get the currently active Python module's helper.
 116     \internal
 117     This function returns correct result only if Python-based
 118     module is currently active. Otherwize, 0 is returned.
 119   */
 120   PyModuleHelper* getPythonHelper()
 121   {
 122     LightApp_Module* module = getActiveModule();
 123     PyModuleHelper* helper = module ? module->findChild<PyModuleHelper*>( "python_module_helper" ) : 0;
 124     return helper;
 125   }
 126
 127   /*!
 128     \brief Get SALOME verbose level
 129     \internal
 130     \return \c true if SALOME debug output is allowed or \c false otherwise
 131   */
 132   bool verbose()
 133   {
 134     bool isVerbose = false;
 135     if ( getenv( "SALOME_VERBOSE" ) ) {
 136       QString envVar = getenv( "SALOME_VERBOSE" );
 137       bool ok;
 138       int value = envVar.toInt( &ok );
 139       isVerbose = ok && value != 0;
 140     }
 141     return isVerbose;
 142   }
 143
 144   /*!
 145     \brief Get menu item title
 146     \internal
 147     \param menuId menu identifier
 148     \return menu title (localized)
 149   */
 150   QString getMenuName( const QString& menuId )
 151   {
 152     QStringList contexts;
 153     contexts << "SalomeApp_Application" << "LightApp_Application" << "STD_TabDesktop" <<
 154       "STD_MDIDesktop" << "STD_Application" << "SUIT_Application" << "";
 155     QString menuName = menuId;
 156     for ( int i = 0; i < contexts.count() && menuName == menuId; i++ )
 157       menuName = QApplication::translate( contexts[i].toLatin1().data(), menuId.toLatin1().data() );
 158     return menuName;
 159   }
 160
 161   /*!
 162     \brief Load module icon
 163     \internal
 164     \param module module name
 165     \param fileName path to the icon file
 166     \return icon
 167   */
 168   QIcon loadIconInternal( const QString& module, const QString& fileName )
 169   {
 170     QIcon icon;
 171
 172     LightApp_Application* app = getApplication();
 173
 174     if ( app && !fileName.isEmpty() ) {
 175       QPixmap pixmap = app->resourceMgr()->loadPixmap( module,
 176                                                        QApplication::translate( module.toLatin1().data(),
 177                                                                                 fileName.toLatin1().data() ) );
 178       if ( !pixmap.isNull() )
 179         icon = QIcon( pixmap );
 180     }
 181     return icon;
 182   }
 183
 184   /*!
 185     \brief Gets window with specified identifier
 186     \internal
 187     \param id window identifier
 188     \return pointer on the window
 189   */
 190   SUIT_ViewWindow* getWnd( const int id )
 191   {
 192     SUIT_ViewWindow* resWnd = 0;
 193
 194     LightApp_Application* app = getApplication();
 195     if ( app ) {
 196       ViewManagerList vmlist = app->viewManagers();
 197       foreach( SUIT_ViewManager* vm, vmlist ) {
 198         QVector<SUIT_ViewWindow*> vwlist = vm->getViews();
 199         foreach ( SUIT_ViewWindow* vw, vwlist ) {
 200           if ( id == vw->getId() ) {
 201             resWnd = vw;
 202             break;
 203           }
 204         }
 205       }
 206     }
 207     return resWnd;
 208   }
 209
 210   /*!
 211     \brief Map of created selection objects.
 212     \internal
 213   */
 214   QMap<LightApp_Application*, SALOME_Selection*> SelMap;
 215
 216   /*!
 217     \brief Default resource file section name.
 218     \internal
 219   */
 220   const char* DEFAULT_SECTION = "SalomePyQt";
 221 }
 222
 223 /*!
 224   \class SALOME_Selection
 225   \brief The class represents selection which can be used in Python.
 226 */
 227
 228 /*!
 229   \brief Get the selection object for the specified application.
 230
 231   Finds or creates the selection object (one per study).
 232
 233   \param app application object
 234   \return selection object or 0 if \a app is invalid
 235 */
 236 SALOME_Selection* SALOME_Selection::GetSelection( LightApp_Application* app )
 237 {
 238   SALOME_Selection* sel = 0;
 239   if ( app && SelMap.find( app ) != SelMap.end() )
 240     sel = SelMap[ app ];
 241   else
 242     sel = SelMap[ app ] = new SALOME_Selection( app );
 243   return sel;
 244 }
 245
 246 /*!
 247   \brief Constructor.
 248   \param p parent object
 249 */
 250 SALOME_Selection::SALOME_Selection( QObject* p ) : QObject( 0 ), mySelMgr( 0 )
 251 {
 252   LightApp_Application* app = dynamic_cast<LightApp_Application*>( p );
 253   if ( app ) {
 254     mySelMgr = app->selectionMgr();
 255     connect( mySelMgr, SIGNAL( selectionChanged() ), this, SIGNAL( currentSelectionChanged() ) );
 256     connect( mySelMgr, SIGNAL( destroyed() ),        this, SLOT  ( onSelMgrDestroyed() ) );
 257   }
 258 }
 259
 260 /*!
 261   \brief Destructor.
 262 */
 263 SALOME_Selection::~SALOME_Selection()
 264 {
 265   LightApp_Application* app = 0;
 266   QMap<LightApp_Application*, SALOME_Selection*>::Iterator it;
 267   for ( it = SelMap.begin(); it != SelMap.end() && !app; ++it ) {
 268     if ( it.value() == this ) app = it.key();
 269   }
 270   if ( app ) SelMap.remove( app );
 271 }
 272
 273 /*!
 274   \brief Called when selection manager is destroyed (usually
 275   when the study is closed).
 276 */
 277 void SALOME_Selection::onSelMgrDestroyed()
 278 {
 279   mySelMgr = 0;
 280 }
 281
 282 /*!
 283   \brief Clear the selection.
 284 */
 285 void SALOME_Selection::Clear()
 286 {
 287   class TEvent: public SALOME_Event
 288   {
 289     LightApp_SelectionMgr* mySelMgr;
 290   public:
 291     TEvent( LightApp_SelectionMgr* selMgr )
 292       : mySelMgr( selMgr ) {}
 293     virtual void Execute()
 294     {
 295       if ( mySelMgr )
 296         mySelMgr->clearSelected();
 297     }
 298   };
 299   ProcessVoidEvent( new TEvent( mySelMgr ) );
 300 }
 301
 302 /*!
 303   \brief Clear the selection.
 304 */
 305 void SALOME_Selection::ClearIObjects()
 306 {
 307   Clear();
 308 }
 309
 310 /*!
 311   Removes all selection filters.
 312 */
 313 void SALOME_Selection::ClearFilters()
 314 {
 315   class TEvent: public SALOME_Event
 316   {
 317     LightApp_SelectionMgr* mySelMgr;
 318   public:
 319     TEvent( LightApp_SelectionMgr* selMgr )
 320       : mySelMgr( selMgr ) {}
 321     virtual void Execute()
 322     {
 323       if ( mySelMgr )
 324         mySelMgr->clearFilters();
 325     }
 326   };
 327   ProcessVoidEvent( new TEvent( mySelMgr ) );
 328 }
 329
 330 /*!
 331   \class SalomePyQt
 332   \brief The class provides utility functions which can be used in the Python
 333   to operate with the SALOME GUI.
 334
 335   All the functionality of this class is implemented as static methods, so they
 336   can be called with the class name prefixed or via creation of the class instance.
 337   For example, next both ways of SalomePyQt class usage are legal:
 338   \code
 339   from SalomePyQt import *
 340   sg = SalomePyQt()
 341   # using SalomePyQt class instance
 342   desktop = sg.getDesktop()
 343   # using SalomePyQt class directly
 344   menubar = SalomePyQt.getMainMenuBar()
 345   \endcode
 346 */
 347
 348 /*!
 349   \fn QWidget* SalomePyQt::getDesktop();
 350   \brief Get the active application's desktop window.
 351   \return desktop window or 0 if there is no any
 352 */
 353
 354 class TGetDesktopEvent: public SALOME_Event
 355 {
 356 public:
 357   typedef QWidget* TResult;
 358   TResult myResult;
 359   TGetDesktopEvent() : myResult( 0 ) {}
 360   virtual void Execute()
 361   {
 362     if ( getApplication() )
 363       myResult = (QWidget*)( getApplication()->desktop() );
 364   }
 365 };
 366 QWidget* SalomePyQt::getDesktop()
 367 {
 368   return ProcessEvent( new TGetDesktopEvent() );
 369 }
 370
 371 /*!
 372   \fn QWidget* SalomePyQt::getMainFrame();
 373   \brief Get current application's main frame widget [obsolete].
 374
 375   Main frame widget is an internal widget of the application
 376   desktop window (workspace).
 377
 378   \return workspace widget (0 on any error)
 379 */
 380
 381 class TGetMainFrameEvent: public SALOME_Event
 382 {
 383 public:
 384   typedef QWidget* TResult;
 385   TResult myResult;
 386   TGetMainFrameEvent() : myResult( 0 ) {}
 387   virtual void Execute()
 388   {
 389     if ( getApplication() ) {
 390       SUIT_Desktop* aDesktop = getApplication()->desktop();
 391       myResult = (QWidget*)( aDesktop->centralWidget() );
 392     }
 393   }
 394 };
 395 QWidget* SalomePyQt::getMainFrame()
 396 {
 397   return ProcessEvent( new TGetMainFrameEvent() );
 398 }
 399
 400 /*!
 401   \fn QMenuBar* SalomePyQt::getMainMenuBar();
 402   \brief Get current application desktop's main menu.
 403   \return main menu object (0 on any error)
 404 */
 405
 406 class TGetMainMenuBarEvent: public SALOME_Event
 407 {
 408 public:
 409   typedef QMenuBar* TResult;
 410   TResult myResult;
 411   TGetMainMenuBarEvent() : myResult( 0 ) {}
 412   virtual void Execute()
 413   {
 414     if ( LightApp_Application* anApp = getApplication() ) {
 415       myResult = anApp->desktop()->menuBar();
 416     }
 417   }
 418 };
 419 QMenuBar* SalomePyQt::getMainMenuBar()
 420 {
 421   return ProcessEvent( new TGetMainMenuBarEvent() );
 422 }
 423
 424 /*!
 425   \fn QMenu* SalomePyQt::getPopupMenu( const MenuName menu );
 426   \brief Get main menu's child popup submenu by its identifier.
 427
 428   This function is obsolete.
 429   Use QMenu* SalomePyQt::getPopupMenu( const QString& menu ) instead.
 430
 431   \param menu menu identifier
 432   \return popup submenu object or 0 if it does not exist
 433 */
 434
 435 /*!
 436   \fn QMenu* SalomePyQt::getPopupMenu( const QString& menu );
 437   \brief Get main menu's child popup submenu by its name.
 438
 439   The function creates menu if it does not exist.
 440
 441   \param menu menu name
 442   \return popup submenu object (0 on any error)
 443 */
 444
 445 class TGetPopupMenuEvent: public SALOME_Event
 446 {
 447 public:
 448   typedef QMenu* TResult;
 449   TResult myResult;
 450   QString myMenuName;
 451   TGetPopupMenuEvent( const QString& menu ) : myResult( 0 ), myMenuName( menu ) {}
 452   virtual void Execute()
 453   {
 454     LightApp_Application* anApp = getApplication();
 455     if ( anApp && !myMenuName.isEmpty() ) {
 456       QtxActionMenuMgr* mgr = anApp->desktop()->menuMgr();
 457       myResult = mgr->findMenu( myMenuName, -1, false ); // search only top menu
 458     }
 459   }
 460 };
 461
 462 QMenu* SalomePyQt::getPopupMenu( const MenuName menu )
 463 {
 464   QString menuName;
 465   switch( menu ) {
 466   case File:
 467     menuName = getMenuName( "MEN_DESK_FILE" );        break;
 468   case View:
 469     menuName = getMenuName( "MEN_DESK_VIEW" );        break;
 470   case Edit:
 471     menuName = getMenuName( "MEN_DESK_EDIT" );        break;
 472   case Preferences:
 473     menuName = getMenuName( "MEN_DESK_PREFERENCES" ); break;
 474   case Tools:
 475     menuName = getMenuName( "MEN_DESK_TOOLS" );       break;
 476   case Window:
 477     menuName = getMenuName( "MEN_DESK_WINDOW" );      break;
 478   case Help:
 479     menuName = getMenuName( "MEN_DESK_HELP" );        break;
 480   }
 481   return ProcessEvent( new TGetPopupMenuEvent( menuName ) );
 482 }
 483 QMenu* SalomePyQt::getPopupMenu( const QString& menu )
 484 {
 485   return ProcessEvent( new TGetPopupMenuEvent( menu ) );
 486 }
 487
 488 /*!
 489   \fn QTreeView* SalomePyQt::getObjectBrowser();
 490   \brief Get object browser
 491   \return object browser for the active study or 0 in case of error
 492 */
 493
 494 class TGetObjectBrowserEvent: public SALOME_Event
 495 {
 496 public:
 497   typedef QTreeView* TResult;
 498   TResult myResult;
 499   TGetObjectBrowserEvent() : myResult( 0 ) {}
 500   virtual void Execute()
 501   {
 502     LightApp_Application* anApp = getApplication();
 503     if ( anApp && anApp->objectBrowser() ) {
 504       myResult = anApp->objectBrowser()->treeView();
 505     }
 506   }
 507 };
 508 QTreeView* SalomePyQt::getObjectBrowser()
 509 {
 510   return ProcessEvent( new TGetObjectBrowserEvent() );
 511 }
 512
 513 /*!
 514   \fn int SalomePyQt::getStudyId();
 515   \brief Get active study's identifier.
 516   \return active study ID or 0 if there is no active study
 517 */
 518
 519 class TGetStudyIdEvent: public SALOME_Event
 520 {
 521 public:
 522   typedef int TResult;
 523   TResult myResult;
 524   TGetStudyIdEvent() : myResult( 0 ) {}
 525   virtual void Execute()
 526   {
 527     if ( LightApp_Study* aStudy = getActiveStudy() ) {
 528       myResult = aStudy->id();
 529     }
 530   }
 531 };
 532 int SalomePyQt::getStudyId()
 533 {
 534   return ProcessEvent( new TGetStudyIdEvent() );
 535 }
 536
 537 /*!
 538   \fn SALOME_Selection* SalomePyQt::getSelection();
 539   \brief Get the selection object for the current study.
 540
 541   Creates a Selection object if it has not been created yet.
 542
 543   \return selection object (0 on error)
 544 */
 545
 546 class TGetSelectionEvent: public SALOME_Event
 547 {
 548 public:
 549   typedef SALOME_Selection* TResult;
 550   TResult myResult;
 551   TGetSelectionEvent() : myResult( 0 ) {}
 552   virtual void Execute()
 553   {
 554     myResult = SALOME_Selection::GetSelection( getApplication() );
 555   }
 556 };
 557 SALOME_Selection* SalomePyQt::getSelection()
 558 {
 559   return ProcessEvent( new TGetSelectionEvent() );
 560 }
 561
 562 /*!
 563   \fn void SalomePyQt::putInfo( const QString& msg, const int sec );
 564   \brief Put an information message to the current application's
 565   desktop status bar.
 566
 567   Optional second delay parameter (\a sec) can be used to specify
 568   time of the message diplaying in seconds. If this parameter is less
 569   or equal to zero, the constant message will be put.
 570
 571   \param msg message text
 572   \param sec message displaying time in seconds
 573 */
 574
 575 class TPutInfoEvent: public SALOME_Event
 576 {
 577   QString myMsg;
 578   int     mySecs;
 579 public:
 580   TPutInfoEvent( const QString& msg, const int sec = 0 ) : myMsg( msg ), mySecs( sec ) {}
 581   virtual void Execute()
 582   {
 583     if ( LightApp_Application* anApp = getApplication() ) {
 584       anApp->putInfo( myMsg, mySecs * 1000 );
 585     }
 586   }
 587 };
 588 void SalomePyQt::putInfo( const QString& msg, const int sec )
 589 {
 590   ProcessVoidEvent( new TPutInfoEvent( msg, sec ) );
 591 }
 592
 593 /*!
 594   \fn const QString SalomePyQt::getActiveComponent();
 595   \brief Get the currently active module name (for the current study).
 596   \return active module name or empty string if there is no active module
 597 */
 598
 599 class TGetActiveComponentEvent: public SALOME_Event
 600 {
 601 public:
 602   typedef QString TResult;
 603   TResult myResult;
 604   TGetActiveComponentEvent() {}
 605   virtual void Execute()
 606   {
 607     if ( LightApp_Application* anApp = getApplication() ) {
 608       if ( CAM_Module* mod = anApp->activeModule() ) {
 609         myResult = mod->name();
 610       }
 611     }
 612   }
 613 };
 614 const QString SalomePyQt::getActiveComponent()
 615 {
 616   return ProcessEvent( new TGetActiveComponentEvent() );
 617 }
 618
 619 /*!
 620   \fn PyObject* SalomePyQt::getActivePythonModule();
 621   \brief Access to Python module object currently loaded into SALOME_PYQT_ModuleLight container.
 622   \return Python module object currently loaded into SALOME_PYQT_ModuleLight container
 623 */
 624
 625 class TGetActivePyModuleEvent: public SALOME_Event
 626 {
 627 public:
 628   typedef PyObject* TResult;
 629   TResult myResult;
 630   TGetActivePyModuleEvent() : myResult( Py_None ) {}
 631   virtual void Execute()
 632   {
 633     PyModuleHelper* helper = getPythonHelper();
 634     if ( helper )
 635       myResult = (PyObject*)helper->pythonModule();
 636   }
 637 };
 638 PyObject* SalomePyQt::getActivePythonModule()
 639 {
 640   return ProcessEvent( new TGetActivePyModuleEvent() );
 641 }
 642
 643 /*!
 644   \fn bool SalomePyQt::activateModule( const QString& modName );
 645   \brief Activates SALOME module with the given name
 646   \return True if the module has been activated and False otherwise.
 647 */
 648
 649 class TActivateModuleEvent: public SALOME_Event
 650 {
 651 public:
 652   typedef bool TResult;
 653   TResult myResult;
 654   QString myModuleName;
 655   TActivateModuleEvent( const QString& modName )
 656   : myResult( false ), myModuleName( modName ) {}
 657   virtual void Execute()
 658   {
 659     if ( LightApp_Application* anApp = getApplication() ) {
 660       myResult = anApp->activateModule( myModuleName );
 661     }
 662   }
 663 };
 664 bool SalomePyQt::activateModule( const QString& modName )
 665 {
 666   return ProcessEvent( new TActivateModuleEvent( modName ) );
 667 }
 668
 669 /*!
 670   \brief Update an Object Browser of the specified (by identifier) study.
 671
 672   If \a studyId <= 0 the active study's object browser is updated.
 673   The \a updateSelection parameter is obsolete and currently is not used.
 674   This parameter will be removed in future, so try to avoid its usage in
 675   your code.
 676
 677   \brief studyId study identifier
 678   \brief updateSelection update selection flag (not used)
 679   \sa getActiveStudy()
 680 */
 681 void SalomePyQt::updateObjBrowser( const int studyId, bool updateSelection )
 682 {
 683   class TEvent: public SALOME_Event
 684   {
 685     int  myStudyId;
 686     bool myUpdateSelection;
 687   public:
 688     TEvent( const int studyId, bool updateSelection )
 689       : myStudyId( studyId ), myUpdateSelection( updateSelection ) {}
 690     virtual void Execute()
 691     {
 692       if ( SUIT_Session::session() ) {
 693         if ( getActiveStudy() && myStudyId <= 0 )
 694           myStudyId = getActiveStudy()->id();
 695         if ( myStudyId > 0 ) {
 696           QList<SUIT_Application*> apps = SUIT_Session::session()->applications();
 697           QList<SUIT_Application*>::Iterator it;
 698           for( it = apps.begin(); it != apps.end(); ++it ) {
 699             LightApp_Application* anApp = dynamic_cast<LightApp_Application*>( *it );
 700             if ( anApp && anApp->activeStudy() && anApp->activeStudy()->id() == myStudyId ) {
 701               anApp->updateObjectBrowser();
 702               return;
 703             }
 704           }
 705         }
 706       }
 707     }
 708   };
 709   ProcessVoidEvent( new TEvent( studyId, updateSelection ) );
 710 }
 711
 712
 713 /*!
 714   SalomePyQt::isModified()
 715   \return The modification status of the data model
 716   for the currently active Python module
 717   \note This function is supported for "light" Python-based SALOME modules only.
 718   \sa setModified()
 719 */
 720 class TIsModifiedEvent: public SALOME_Event
 721 {
 722 public:
 723   typedef bool TResult;
 724   TResult myResult;
 725   TIsModifiedEvent() : myResult( false ) {}
 726   virtual void Execute()
 727   {
 728     LightApp_Module* module = getActiveModule();
 729     if ( !module )
 730       return;
 731
 732     SALOME_PYQT_DataModelLight* aModel =
 733       dynamic_cast<SALOME_PYQT_DataModelLight*>( module->dataModel() );
 734     if ( aModel ) {
 735       myResult = aModel->isModified();
 736     }
 737     else {
 738       if ( verbose() ) printf( "SalomePyQt.isModified() function is not supported for the current module.\n" );
 739     }
 740   }
 741 };
 742 bool SalomePyQt::isModified()
 743 {
 744   return ProcessEvent(new TIsModifiedEvent());
 745 }
 746
 747 /*!
 748   SalomePyQt::setModified()
 749
 750   Sets the modification status of the data model for
 751   the currently active Python module. This method should be used
 752   by the Python code in order to enable/disable "Save" operation
 753   depending on the module's data state.
 754
 755   \note This function is supported for "light" Python-based SALOME modules only.
 756
 757   \param New modification status of the data model
 758
 759   \sa isModified()
 760 */
 761 void SalomePyQt::setModified( bool flag )
 762 {
 763   class TEvent: public SALOME_Event
 764   {
 765     bool myFlag;
 766   public:
 767     TEvent( bool flag )
 768       : myFlag( flag ) {}
 769     virtual void Execute()
 770     {
 771       LightApp_Module* module = getActiveModule();
 772       if ( !module )
 773         return;
 774
 775       SALOME_PYQT_DataModelLight* model =
 776         dynamic_cast<SALOME_PYQT_DataModelLight*>( module->dataModel() );
 777
 778       LightApp_Application* app = module->getApp();
 779
 780       if ( model && app ) {
 781         model->setModified( myFlag );
 782         app->updateActions();
 783       }
 784       else {
 785         if ( verbose() ) printf( "SalomePyQt.setModified() function is not supported for the current module.\n" );
 786       }
 787     }
 788   };
 789   ProcessVoidEvent( new TEvent( flag ) );
 790 }
 791
 792 /*!
 793   \brief Add string setting to the application preferences.
 794
 795   The parameter \a autoValue is obsolete parameter and currently is not used.
 796   This parameter will be removed in future, so try to avoid its usage in
 797   your code.
 798
 799   This function is obsolete. Use one of addSetting() instead.
 800
 801   \param name setting name (it should be of kind <section:setting> where
 802   \c section is resources section name and \c setting is setting name)
 803   \param value new setting value
 804   \param autoValue (not used)
 805 */
 806 void SalomePyQt::addStringSetting( const QString& name, const QString& value, bool autoValue )
 807 {
 808   class TEvent: public SALOME_Event
 809   {
 810     QString myName;
 811     QString myValue;
 812     bool    myAutoValue;
 813   public:
 814     TEvent( const QString& name, const QString& value, bool autoValue )
 815       : myName( name ), myValue( value ), myAutoValue( autoValue ) {}
 816     virtual void Execute()
 817     {
 818       if ( SUIT_Session::session() ) {
 819         SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
 820         QStringList sl = myName.split( ":", QString::SkipEmptyParts );
 821         QString _sec = sl.count() > 1 ? sl[ 0 ].trimmed() : QString( DEFAULT_SECTION );
 822         QString _nam = sl.count() > 1 ? sl[ 1 ].trimmed() : sl.count() > 0 ? sl[ 0 ].trimmed() : QString( "" );
 823         if ( !_sec.isEmpty() && !_nam.isEmpty() )
 824           resMgr->setValue( _sec, _nam, myValue );
 825       }
 826     }
 827   };
 828   ProcessVoidEvent( new TEvent( name, value, autoValue ) );
 829 }
 830
 831 /*!
 832   \brief Add integer setting to the application preferences.
 833
 834   The parameter \a autoValue is obsolete parameter and currently is not used.
 835   This parameter will be removed in future, so try to avoid its usage in
 836   your code.
 837
 838   This function is obsolete. Use one of addSetting() instead.
 839
 840   \param name setting name (it should be of kind <section:setting> where
 841   \c section is resources section name and \c setting is setting name)
 842   \param value new setting value
 843   \param autoValue (not used)
 844 */
 845 void SalomePyQt::addIntSetting( const QString& name, const int value, bool autoValue)
 846 {
 847   class TEvent: public SALOME_Event
 848   {
 849     QString myName;
 850     int     myValue;
 851     bool    myAutoValue;
 852   public:
 853     TEvent( const QString& name, const int value, bool autoValue )
 854       : myName( name ), myValue( value ), myAutoValue( autoValue ) {}
 855     virtual void Execute()
 856     {
 857       if ( SUIT_Session::session() ) {
 858         SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
 859         QStringList sl = myName.split( ":", QString::SkipEmptyParts );
 860         QString _sec = sl.count() > 1 ? sl[ 0 ].trimmed() : QString( DEFAULT_SECTION );
 861         QString _nam = sl.count() > 1 ? sl[ 1 ].trimmed() : sl.count() > 0 ? sl[ 0 ].trimmed() : QString( "" );
 862         if ( !_sec.isEmpty() && !_nam.isEmpty() )
 863           resMgr->setValue( _sec, _nam, myValue );
 864       }
 865     }
 866   };
 867   ProcessVoidEvent( new TEvent( name, value, autoValue ) );
 868 }
 869
 870 /*!
 871   \brief Add double setting to the application preferences.
 872
 873   The parameter \a autoValue is obsolete parameter and currently is not used.
 874   This parameter will be removed in future, so try to avoid its usage in
 875   your code.
 876
 877   This function is obsolete. Use one of addSetting() instead.
 878
 879   \param name setting name (it should be of kind <section:setting> where
 880   \c section is resources section name and \c setting is setting name)
 881   \param value new setting value
 882   \param autoValue (not used)
 883 */
 884 void SalomePyQt::addDoubleSetting( const QString& name, const double value, bool autoValue )
 885 {
 886   class TEvent: public SALOME_Event
 887   {
 888     QString myName;
 889     double  myValue;
 890     bool    myAutoValue;
 891   public:
 892     TEvent( const QString& name, const double value, bool autoValue )
 893       : myName( name ), myValue( value ), myAutoValue( autoValue ) {}
 894     virtual void Execute()
 895     {
 896       if ( SUIT_Session::session() ) {
 897         SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
 898         QStringList sl = myName.split( ":", QString::SkipEmptyParts );
 899         QString _sec = sl.count() > 1 ? sl[ 0 ].trimmed() : QString( DEFAULT_SECTION );
 900         QString _nam = sl.count() > 1 ? sl[ 1 ].trimmed() : sl.count() > 0 ? sl[ 0 ].trimmed() : QString( "" );
 901         if ( !_sec.isEmpty() && !_nam.isEmpty() )
 902           resMgr->setValue( _sec, _nam, myValue );
 903       }
 904     }
 905   };
 906   ProcessVoidEvent( new TEvent( name, value, autoValue ) );
 907 }
 908
 909 /*!
 910   \brief Add boolean setting to the application preferences.
 911
 912   The parameter \a autoValue is obsolete parameter and currently is not used.
 913   This parameter will be removed in future, so try to avoid its usage in
 914   your code.
 915
 916   This function is obsolete. Use one of addSetting() instead.
 917
 918   \param name setting name (it should be of kind <section:setting> where
 919   \c section is resources section name and \c setting is setting name)
 920   \param value new setting value
 921   \param autoValue (not used)
 922 */
 923 void SalomePyQt::addBoolSetting( const QString& name, const bool value, bool autoValue )
 924 {
 925   class TEvent: public SALOME_Event
 926   {
 927     QString myName;
 928     bool    myValue;
 929     bool    myAutoValue;
 930   public:
 931     TEvent( const QString& name, const bool value, bool autoValue )
 932       : myName( name ), myValue( value ), myAutoValue( autoValue ) {}
 933     virtual void Execute()
 934     {
 935       if ( SUIT_Session::session() ) {
 936         SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
 937         QStringList sl = myName.split( ":", QString::SkipEmptyParts );
 938         QString _sec = sl.count() > 1 ? sl[ 0 ].trimmed() : QString( DEFAULT_SECTION );
 939         QString _nam = sl.count() > 1 ? sl[ 1 ].trimmed() : sl.count() > 0 ? sl[ 0 ].trimmed() : QString( "" );
 940         if ( !_sec.isEmpty() && !_nam.isEmpty() )
 941           resMgr->setValue( _sec, _nam, myValue );
 942       }
 943     }
 944   };
 945   ProcessVoidEvent( new TEvent( name, value, autoValue ) );
 946 }
 947
 948 /*!
 949   \brief Remove setting from the application preferences.
 950
 951   This function is obsolete. Use removeSetting() instead.
 952
 953   \param name setting name (it should be of kind <section:setting> where
 954   \c section is resources section name and \c setting is setting name)
 955 */
 956 void SalomePyQt::removeSettings( const QString& name )
 957 {
 958   class TEvent: public SALOME_Event
 959   {
 960     QString myName;
 961   public:
 962     TEvent( const QString& name ) : myName( name ) {}
 963     virtual void Execute()
 964     {
 965       if ( SUIT_Session::session() ) {
 966         SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
 967         QStringList sl = myName.split( ":", QString::SkipEmptyParts );
 968         QString _sec = sl.count() > 1 ? sl[ 0 ].trimmed() : QString( DEFAULT_SECTION );
 969         QString _nam = sl.count() > 1 ? sl[ 1 ].trimmed() : sl.count() > 0 ? sl[ 0 ].trimmed() : QString( "" );
 970         if ( !_sec.isEmpty() && !_nam.isEmpty() )
 971           resMgr->remove( _sec, _nam );
 972       }
 973     }
 974   };
 975   ProcessVoidEvent( new TEvent( name ) );
 976 }
 977
 978 /*!
 979   \fn QString SalomePyQt::getSetting( const QString& name );
 980   \brief Get application setting value (as string represenation).
 981
 982   This function is obsolete. Use stringSetting(), integerSetting(),
 983   boolSetting(), stringSetting() or colorSetting() instead.
 984
 985   \param name setting name (it should be of kind <section:setting> where
 986   \c section is resources section name and \c setting is setting name)
 987   \return setting name (empty string if setting name is invalid)
 988 */
 989
 990 class TGetSettingEvent: public SALOME_Event
 991 {
 992 public:
 993   typedef QString TResult;
 994   TResult myResult;
 995   QString myName;
 996   TGetSettingEvent( const QString& name ) : myName( name ) {}
 997   virtual void Execute()
 998   {
 999     if ( SUIT_Session::session() ) {
1000       SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1001       QStringList sl = myName.split( ":", QString::SkipEmptyParts );
1002       QString _sec = sl.count() > 1 ? sl[ 0 ].trimmed() : QString( DEFAULT_SECTION );
1003       QString _nam = sl.count() > 1 ? sl[ 1 ].trimmed() : sl.count() > 0 ? sl[ 0 ].trimmed() : QString( "" );
1004       myResult = ( !_sec.isEmpty() && !_nam.isEmpty() ) ? resMgr->stringValue( _sec, _nam, "" ) : QString( "" );
1005     }
1006   }
1007 };
1008 QString SalomePyQt::getSetting( const QString& name )
1009 {
1010   return ProcessEvent( new TGetSettingEvent( name ) );
1011 }
1012
1013 /*!
1014   \fn QString SalomePyQt::constant( const QString& name );
1015   \brief Get constant's value from application's resource manager.
1016
1017   \param name name of the constant
1018   \return value of the constant
1019
1020   \sa setConstant()
1021 */
1022
1023 class TGetConstantEvent: public SALOME_Event
1024 {
1025 public:
1026   typedef QString TResult;
1027   TResult myResult;
1028   QString myName;
1029   TGetConstantEvent( const QString& name ) : myName( name ) {}
1030   virtual void Execute()
1031   {
1032     if ( SUIT_Session::session() )
1033       myResult = SUIT_Session::session()->resourceMgr()->constant( myName );
1034   }
1035 };
1036 QString SalomePyQt::constant( const QString& name )
1037 {
1038   return ProcessEvent( new TGetConstantEvent( name ) );
1039 }
1040
1041 /*!
1042   \brief Add constant to the application's resource manager.
1043
1044   This function is useful to specify programmatically specific
1045   variables that are referenced in the resource setting.
1046
1047   For example, some resource value can be set as "$(myroot)/data/files".
1048   Then, "mypath" constant can be set programmatically by the application
1049   depending on run-time requirements.
1050
1051   \param section resources file section name
1052   \param name name of the constant
1053   \param value value of the constant
1054
1055   \sa constant()
1056 */
1057 void SalomePyQt::setConstant( const QString& name, const QString& value )
1058 {
1059   class TEvent: public SALOME_Event
1060   {
1061     QString myName, myValue;
1062   public:
1063     TEvent( const QString& name, const QString& value )
1064       : myName( name ), myValue( value ) {}
1065     virtual void Execute()
1066     {
1067       if ( SUIT_Session::session() )
1068         SUIT_Session::session()->resourceMgr()->setConstant( myName, myValue );
1069     }
1070   };
1071   ProcessVoidEvent( new TEvent( name, value ) );
1072 }
1073
1074 /*!
1075   \brief Add double setting to the application preferences.
1076   \param section resources file section name
1077   \param name setting name
1078   \param value new setting value
1079 */
1080 void SalomePyQt::addSetting( const QString& section, const QString& name, const double value )
1081 {
1082   class TEvent: public SALOME_Event
1083   {
1084     QString mySection;
1085     QString myName;
1086     double  myValue;
1087   public:
1088     TEvent( const QString& section, const QString& name, double value )
1089       : mySection( section ), myName( name ), myValue( value ) {}
1090     virtual void Execute()
1091     {
1092       if ( SUIT_Session::session() ) {
1093         SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1094         if ( !mySection.isEmpty() && !myName.isEmpty() )
1095           resMgr->setValue( mySection, myName, myValue );
1096       }
1097     }
1098   };
1099   ProcessVoidEvent( new TEvent( section, name, value ) );
1100 }
1101
1102 /*!
1103   \brief Add integer setting to the application preferences.
1104   \param section resources file section name
1105   \param name setting name
1106   \param value new setting value
1107 */
1108 void SalomePyQt::addSetting( const QString& section, const QString& name, const int value )
1109 {
1110   class TEvent: public SALOME_Event
1111   {
1112     QString mySection;
1113     QString myName;
1114     int     myValue;
1115   public:
1116     TEvent( const QString& section, const QString& name, int value )
1117       : mySection( section ), myName( name ), myValue( value ) {}
1118     virtual void Execute()
1119     {
1120       if ( SUIT_Session::session() ) {
1121         SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1122         if ( !mySection.isEmpty() && !myName.isEmpty() )
1123           resMgr->setValue( mySection, myName, myValue );
1124       }
1125     }
1126   };
1127   ProcessVoidEvent( new TEvent( section, name, value ) );
1128 }
1129
1130 /*!
1131   \brief Add boolean setting to the application preferences.
1132   \param section resources file section name
1133   \param name setting name
1134   \param value new setting value
1135   \param dumb this parameter is used in order to avoid sip compilation error
1136   because of conflicting int and bool types
1137 */
1138 void SalomePyQt::addSetting( const QString& section, const QString& name, const bool value, const int /*dumb*/ )
1139 {
1140   class TEvent: public SALOME_Event
1141   {
1142     QString mySection;
1143     QString myName;
1144     bool    myValue;
1145   public:
1146     TEvent( const QString& section, const QString& name, bool value )
1147       : mySection( section ), myName( name ), myValue( value ) {}
1148     virtual void Execute()
1149     {
1150       if ( SUIT_Session::session() ) {
1151         SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1152         if ( !mySection.isEmpty() && !myName.isEmpty() )
1153           resMgr->setValue( mySection, myName, myValue );
1154       }
1155     }
1156   };
1157   ProcessVoidEvent( new TEvent( section, name, value ) );
1158 }
1159
1160 /*!
1161   \brief Add string setting to the application preferences.
1162   \param section resources file section name
1163   \param name setting name
1164   \param value new setting value
1165 */
1166 void SalomePyQt::addSetting( const QString& section, const QString& name, const QString& value )
1167 {
1168   class TEvent: public SALOME_Event
1169   {
1170     QString mySection;
1171     QString myName;
1172     QString myValue;
1173   public:
1174     TEvent( const QString& section, const QString& name, const QString& value )
1175       : mySection( section ), myName( name ), myValue( value ) {}
1176     virtual void Execute()
1177     {
1178       if ( SUIT_Session::session() ) {
1179         SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1180         if ( !mySection.isEmpty() && !myName.isEmpty() )
1181           resMgr->setValue( mySection, myName, myValue );
1182       }
1183     }
1184   };
1185   ProcessVoidEvent( new TEvent( section, name, value ) );
1186 }
1187
1188 /*!
1189   \brief Add color setting to the application preferences.
1190   \param section resources file section name
1191   \param name setting name
1192   \param value new setting value
1193 */
1194 void SalomePyQt::addSetting( const QString& section, const QString& name, const QColor& value )
1195 {
1196   class TEvent: public SALOME_Event
1197   {
1198     QString mySection;
1199     QString myName;
1200     QColor  myValue;
1201   public:
1202     TEvent( const QString& section, const QString& name, const QColor& value )
1203       : mySection( section ), myName( name ), myValue( value ) {}
1204     virtual void Execute()
1205     {
1206       if ( SUIT_Session::session() ) {
1207         SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1208         if ( !mySection.isEmpty() && !myName.isEmpty() )
1209           resMgr->setValue( mySection, myName, myValue );
1210       }
1211     }
1212   };
1213   ProcessVoidEvent( new TEvent( section, name, value ) );
1214 }
1215
1216 /*!
1217   \brief Add byte array setting to the application preferences.
1218   \param section resources file section name
1219   \param name setting name
1220   \param value new setting value
1221 */
1222 void SalomePyQt::addSetting( const QString& section, const QString& name, const QByteArray& value )
1223 {
1224   class TEvent: public SALOME_Event
1225   {
1226     QString    mySection;
1227     QString    myName;
1228     QByteArray myValue;
1229   public:
1230     TEvent( const QString& section, const QString& name, const QByteArray& value )
1231       : mySection( section ), myName( name ), myValue( value ) {}
1232     virtual void Execute()
1233     {
1234       if ( SUIT_Session::session() ) {
1235         SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1236         if ( !mySection.isEmpty() && !myName.isEmpty() )
1237           resMgr->setValue( mySection, myName, myValue );
1238       }
1239     }
1240   };
1241   ProcessVoidEvent( new TEvent( section, name, value ) );
1242 }
1243
1244 /*!
1245   \fn int SalomePyQt::integerSetting( const QString& section,
1246                                       const QString& name,
1247                                       const int def );
1248   \brief Get integer setting from the application preferences.
1249   \param section resources file section name
1250   \param name setting name
1251   \param def default value which is returned if the setting is not found
1252   \return setting value
1253 */
1254
1255 class TGetIntSettingEvent: public SALOME_Event
1256 {
1257 public:
1258   typedef int TResult;
1259   TResult myResult;
1260   QString mySection;
1261   QString myName;
1262   TResult myDefault;
1263   TGetIntSettingEvent( const QString& section, const QString& name, const int def )
1264     : mySection( section ), myName( name ), myDefault( def ) {}
1265   virtual void Execute()
1266   {
1267     if ( SUIT_Session::session() ) {
1268       SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1269       myResult = ( !mySection.isEmpty() && !myName.isEmpty() ) ? resMgr->integerValue( mySection, myName, myDefault ) : myDefault;
1270     }
1271   }
1272 };
1273 int SalomePyQt::integerSetting( const QString& section, const QString& name, const int def )
1274 {
1275   return ProcessEvent( new TGetIntSettingEvent( section, name, def ) );
1276 }
1277
1278 /*!
1279   \fn double SalomePyQt::doubleSetting( const QString& section,
1280                                         const QString& name,
1281                                         const double def );
1282   \brief Get double setting from the application preferences.
1283   \param section resources file section name
1284   \param name setting name
1285   \param def default value which is returned if the setting is not found
1286   \return setting value
1287 */
1288
1289 class TGetDblSettingEvent: public SALOME_Event
1290 {
1291 public:
1292   typedef double TResult;
1293   TResult myResult;
1294   QString mySection;
1295   QString myName;
1296   TResult myDefault;
1297   TGetDblSettingEvent( const QString& section, const QString& name, const double def )
1298     : mySection( section ), myName( name ), myDefault( def ) {}
1299   virtual void Execute()
1300   {
1301     if ( SUIT_Session::session() ) {
1302       SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1303       myResult = ( !mySection.isEmpty() && !myName.isEmpty() ) ? resMgr->doubleValue( mySection, myName, myDefault ) : myDefault;
1304     }
1305   }
1306 };
1307 double SalomePyQt::doubleSetting( const QString& section, const QString& name, const double def )
1308 {
1309   return ProcessEvent( new TGetDblSettingEvent( section, name, def ) );
1310 }
1311
1312 /*!
1313   \fn bool SalomePyQt::boolSetting( const QString& section,
1314                                     const QString& name,
1315                                     const bool def );
1316   \brief Get boolean setting from the application preferences.
1317   \param section resources file section name
1318   \param name setting name
1319   \param def default value which is returned if the setting is not found
1320   \return setting value
1321 */
1322
1323 class TGetBoolSettingEvent: public SALOME_Event
1324 {
1325 public:
1326   typedef bool TResult;
1327   TResult myResult;
1328   QString mySection;
1329   QString myName;
1330   TResult myDefault;
1331   TGetBoolSettingEvent( const QString& section, const QString& name, const bool def )
1332     : mySection( section ), myName( name ), myDefault( def ) {}
1333   virtual void Execute()
1334   {
1335     if ( SUIT_Session::session() ) {
1336       SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1337       myResult = ( !mySection.isEmpty() && !myName.isEmpty() ) ? resMgr->booleanValue( mySection, myName, myDefault ) : myDefault;
1338     }
1339   }
1340 };
1341 bool SalomePyQt::boolSetting( const QString& section, const QString& name, const bool def )
1342 {
1343   return ProcessEvent( new TGetBoolSettingEvent( section, name, def ) );
1344 }
1345
1346 /*!
1347   \fn QString SalomePyQt::stringSetting( const QString& section,
1348                                          const QString& name,
1349                                          const QString& def,
1350                                          const bool subst );
1351   \brief Get string setting from the application preferences.
1352   \param section resources file section name
1353   \param name setting name
1354   \param def default value which is returned if the setting is not found
1355   \param subst \c true to make substitution, \c false to get "raw" value
1356   \return setting value
1357 */
1358
1359 class TGetStrSettingEvent: public SALOME_Event
1360 {
1361 public:
1362   typedef QString TResult;
1363   TResult myResult;
1364   QString mySection;
1365   QString myName;
1366   bool mySubst;
1367   TResult myDefault;
1368   TGetStrSettingEvent( const QString& section, const QString& name, const QString& def, const bool subst )
1369     : mySection( section ), myName( name ), myDefault( def ), mySubst( subst ) {}
1370   virtual void Execute()
1371   {
1372     if ( SUIT_Session::session() ) {
1373       SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1374       myResult = ( !mySection.isEmpty() && !myName.isEmpty() ) ? resMgr->stringValue( mySection, myName, myDefault, mySubst ) : myDefault;
1375     }
1376   }
1377 };
1378 QString SalomePyQt::stringSetting( const QString& section, const QString& name, const QString& def, const bool subst )
1379 {
1380   return ProcessEvent( new TGetStrSettingEvent( section, name, def, subst ) );
1381 }
1382
1383 /*!
1384   \fn QColor SalomePyQt::colorSetting( const QString& section,
1385                                        const QString& name,
1386                                        const QColor def );
1387   \brief Get color setting from the application preferences.
1388   \param section resources file section name
1389   \param name setting name
1390   \param def default value which is returned if the setting is not found
1391   \return setting value
1392 */
1393
1394 class TGetColorSettingEvent: public SALOME_Event
1395 {
1396 public:
1397   typedef QColor TResult;
1398   TResult myResult;
1399   QString mySection;
1400   QString myName;
1401   TResult myDefault;
1402   TGetColorSettingEvent( const QString& section, const QString& name, const QColor& def )
1403     : mySection( section ), myName( name ), myDefault( def ) {}
1404   virtual void Execute()
1405   {
1406     if ( SUIT_Session::session() ) {
1407       SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1408       myResult = ( !mySection.isEmpty() && !myName.isEmpty() ) ? resMgr->colorValue( mySection, myName, myDefault ) : myDefault;
1409     }
1410   }
1411 };
1412 QColor SalomePyQt::colorSetting ( const QString& section, const QString& name, const QColor& def )
1413 {
1414   return ProcessEvent( new TGetColorSettingEvent( section, name, def ) );
1415 }
1416
1417 /*!
1418   \fn QByteArray SalomePyQt::byteArraySetting( const QString& section,
1419                                                const QString& name,
1420                                                const QByteArray def );
1421   \brief Get byte array setting from the application preferences.
1422   \param section resources file section name
1423   \param name setting name
1424   \param def default value which is returned if the setting is not found
1425   \return setting value
1426 */
1427
1428 class TGetByteArraySettingEvent: public SALOME_Event
1429 {
1430 public:
1431   typedef QByteArray TResult;
1432   TResult myResult;
1433   QString mySection;
1434   QString myName;
1435   TResult myDefault;
1436   TGetByteArraySettingEvent( const QString& section, const QString& name, const QByteArray& def )
1437     : mySection( section ), myName( name ), myDefault( def ) {}
1438   virtual void Execute()
1439   {
1440     if ( SUIT_Session::session() ) {
1441       SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1442       myResult = ( !mySection.isEmpty() && !myName.isEmpty() ) ? resMgr->byteArrayValue( mySection, myName, myDefault ) : myDefault;
1443     }
1444   }
1445 };
1446 QByteArray SalomePyQt::byteArraySetting ( const QString& section, const QString& name, const QByteArray& def )
1447 {
1448   return ProcessEvent( new TGetByteArraySettingEvent( section, name, def ) );
1449 }
1450
1451 /*!
1452   \brief Remove setting from the application preferences.
1453   \param section resources file section name
1454   \param name setting name
1455 */
1456 void SalomePyQt::removeSetting( const QString& section, const QString& name )
1457 {
1458   class TEvent: public SALOME_Event
1459   {
1460     QString mySection;
1461     QString myName;
1462   public:
1463     TEvent( const QString& section, const QString& name ) : mySection( section ), myName( name ) {}
1464     virtual void Execute()
1465     {
1466       if ( SUIT_Session::session() ) {
1467         SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1468         if ( !mySection.isEmpty() && !myName.isEmpty() )
1469           resMgr->remove( mySection, myName );
1470       }
1471     }
1472   };
1473   ProcessVoidEvent( new TEvent( section, name ) );
1474 }
1475
1476 /*!
1477   \fn bool SalomePyQt::hasSetting( const QString& section, const QString& name );
1478   \brief Check setting existence in the application preferences.
1479   \param section resources file section name
1480   \param name setting name
1481   \return \c true if setting exists
1482 */
1483
1484 class THasSettingEvent: public SALOME_Event
1485 {
1486 public:
1487   typedef bool TResult;
1488   TResult myResult;
1489   QString mySection;
1490   QString myName;
1491   THasSettingEvent( const QString& section, const QString& name )
1492     : mySection( section ), myName( name ) {}
1493   virtual void Execute()
1494   {
1495     if ( SUIT_Session::session() ) {
1496       SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1497       myResult = resMgr->hasValue( mySection, myName );
1498     }
1499   }
1500 };
1501 bool SalomePyQt::hasSetting( const QString& section, const QString& name )
1502 {
1503   return ProcessEvent( new THasSettingEvent( section, name ) );
1504 }
1505
1506 /*!
1507   \fn QStringList SalomePyQt::parameters( const QString& section );
1508   \brief Get names of preference items stored within the given section.
1509   \param section resources file section's name
1510   \return \c list of preferences items
1511 */
1512
1513 /*!
1514   \fn QStringList SalomePyQt::parameters( const QStringList& section );
1515   \brief Get names of preference items stored within the given section.
1516   \param section resources file section's name
1517   \return \c list of preferences items
1518 */
1519
1520 class TParametersEvent: public SALOME_Event
1521 {
1522 public:
1523   typedef QStringList TResult;
1524   TResult myResult;
1525   QStringList mySection;
1526   TParametersEvent( const QString& section )
1527   {
1528     mySection << section;
1529   }
1530   TParametersEvent( const QStringList& section )
1531     : mySection( section )
1532   {}
1533   virtual void Execute()
1534   {
1535     if ( SUIT_Session::session() ) {
1536       SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
1537       myResult = resMgr->parameters( mySection );
1538     }
1539   }
1540 };
1541 QStringList SalomePyQt::parameters( const QString& section )
1542 {
1543   return ProcessEvent( new TParametersEvent( section ) );
1544 }
1545 QStringList SalomePyQt::parameters( const QStringList& section )
1546 {
1547   return ProcessEvent( new TParametersEvent( section ) );
1548 }
1549
1550 /*!
1551   \fn QString SalomePyQt::getFileName( QWidget*           parent,
1552                                        const QString&     initial,
1553                                        const QStringList& filters,
1554                                        const QString&     caption,
1555                                        bool               open );
1556   \brief Show 'Open/Save file' dialog box for file selection
1557          and return a user's choice (selected file name).
1558   \param parent parent widget
1559   \param initial initial directory the dialog box to be opened in
1560   \param filters list of files filters (wildcards)
1561   \param caption dialog box title
1562   \param open if \c true, "Open File" dialog box is shown;
1563          otherwise "Save File" dialog box is shown
1564   \return selected file name (null string if user cancels operation)
1565 */
1566
1567 class TGetFileNameEvent: public SALOME_Event
1568 {
1569 public:
1570   typedef QString TResult;
1571   TResult     myResult;
1572   QWidget*    myParent;
1573   QString     myInitial;
1574   QStringList myFilters;
1575   QString     myCaption;
1576   bool        myOpen;
1577   TGetFileNameEvent( QWidget*           parent,
1578                      const QString&     initial,
1579                      const QStringList& filters,
1580                      const QString&     caption,
1581                      bool               open )
1582     : myParent ( parent ),
1583       myInitial( initial ),
1584       myFilters( filters ),
1585       myCaption( caption ),
1586       myOpen ( open ) {}
1587   virtual void Execute()
1588   {
1589     if ( LightApp_Application* anApp = getApplication() ) {
1590       myResult = anApp->getFileName( myOpen, myInitial, myFilters.join(";;"),
1591                                      myCaption, myParent );
1592     }
1593   }
1594 };
1595 QString SalomePyQt::getFileName( QWidget*           parent,
1596                                  const QString&     initial,
1597                                  const QStringList& filters,
1598                                  const QString&     caption,
1599                                  bool               open )
1600 {
1601   return ProcessEvent( new TGetFileNameEvent( parent, initial, filters, caption, open ) );
1602 }
1603
1604 /*!
1605   \fn QStringList SalomePyQt::getOpenFileNames( QWidget*           parent,
1606                                                 const QString&     initial,
1607                                                 const QStringList& filters,
1608                                                 const QString&     caption );
1609   \brief Show 'Open files' dialog box for multiple files selection
1610          and return a user's choice (selected file names list).
1611   \param parent parent widget
1612   \param initial initial directory the dialog box to be opened in
1613   \param filters list of files filters (wildcards)
1614   \param caption dialog box title
1615   \return selected file names list (empty list if user cancels operation)
1616 */
1617
1618 class TGetOpenFileNamesEvent: public SALOME_Event
1619 {
1620 public:
1621   typedef QStringList TResult;
1622   TResult     myResult;
1623   QWidget*    myParent;
1624   QString     myInitial;
1625   QStringList myFilters;
1626   QString     myCaption;
1627   TGetOpenFileNamesEvent( QWidget*           parent,
1628                           const QString&     initial,
1629                           const QStringList& filters,
1630                           const QString&     caption )
1631     : myParent ( parent ),
1632       myInitial( initial ),
1633       myFilters( filters ),
1634       myCaption( caption ) {}
1635   virtual void Execute()
1636   {
1637     if ( LightApp_Application* anApp = getApplication() ) {
1638       myResult = anApp->getOpenFileNames( myInitial, myFilters.join(";;"), myCaption, myParent );
1639     }
1640   }
1641 };
1642 QStringList SalomePyQt::getOpenFileNames( QWidget*           parent,
1643                                           const QString&     initial,
1644                                           const QStringList& filters,
1645                                           const QString&     caption )
1646 {
1647   return ProcessEvent( new TGetOpenFileNamesEvent( parent, initial, filters, caption ) );
1648 }
1649
1650 /*!
1651   \fn QString SalomePyQt::getExistingDirectory( QWidget*       parent,
1652                                                 const QString& initial,
1653                                                 const QString& caption );
1654   \brief Show 'Get Directory' dialog box for the directory selection
1655          and return a user's choice (selected directory name).
1656   \param parent parent widget
1657   \param initial initial directory the dialog box to be opened in
1658   \param caption dialog box title
1659   \return selected directory name (null string if user cancels operation)
1660 */
1661
1662 class TGetExistingDirectoryEvent: public SALOME_Event
1663 {
1664 public:
1665   typedef QString TResult;
1666   TResult     myResult;
1667   QWidget*    myParent;
1668   QString     myInitial;
1669   QString     myCaption;
1670   TGetExistingDirectoryEvent( QWidget*           parent,
1671                               const QString&     initial,
1672                               const QString&     caption )
1673     : myParent ( parent ),
1674       myInitial( initial ),
1675       myCaption( caption ) {}
1676   virtual void Execute()
1677   {
1678     if ( LightApp_Application* anApp = getApplication() ) {
1679       myResult = anApp->getDirectory( myInitial, myCaption, myParent );
1680     }
1681   }
1682 };
1683 QString SalomePyQt::getExistingDirectory( QWidget*       parent,
1684                                           const QString& initial,
1685                                           const QString& caption )
1686 {
1687   return ProcessEvent( new TGetExistingDirectoryEvent( parent, initial, caption ) );
1688 }
1689
1690 /*!
1691   \fn QString SalomePyQt::loadIcon( const QString& filename );
1692   \brief Load an icon from the module resources by the specified file name.
1693   \param fileName icon file name
1694   \return icon object
1695 */
1696
1697 class TLoadIconEvent: public SALOME_Event
1698 {
1699 public:
1700   typedef QIcon TResult;
1701   TResult     myResult;
1702   QString     myModule;
1703   QString     myFileName;
1704   TLoadIconEvent( const QString& module, const QString& filename )
1705     : myModule( module ),
1706       myFileName ( filename ) {}
1707   virtual void Execute()
1708   {
1709     myResult = loadIconInternal( myModule, myFileName );
1710   }
1711 };
1712 QIcon SalomePyQt::loadIcon( const QString& module, const QString& filename )
1713 {
1714   return ProcessEvent( new TLoadIconEvent( module, filename ) );
1715 }
1716
1717 /*!
1718   \brief Open external browser to display context help information.
1719   \todo
1720
1721   Current implementation does nothing.
1722
1723   \param source documentation (HTML) file name
1724   \param context context (for example, HTML ancor name)
1725 */
1726 void SalomePyQt::helpContext( const QString& source, const QString& context )
1727 {
1728   class TEvent: public SALOME_Event
1729   {
1730     QString mySource;
1731     QString myContext;
1732   public:
1733     TEvent( const QString& source, const QString& context )
1734       : mySource( source ), myContext( context ) {}
1735     virtual void Execute()
1736     {
1737       if ( LightApp_Application* anApp = getApplication() ) {
1738         anApp->onHelpContextModule( "", mySource, myContext );
1739       }
1740     }
1741   };
1742   ProcessVoidEvent( new TEvent( source, context ) );
1743 }
1744
1745 /*!
1746   \fn int SalomePyQt::defaultMenuGroup();
1747   \brief Get detault menu group identifier which can be used when
1748   creating menus (insert custom menu commands).
1749   \return default menu group ID
1750 */
1751
1752 class TDefMenuGroupEvent: public SALOME_Event
1753 {
1754 public:
1755   typedef int TResult;
1756   TResult myResult;
1757   TDefMenuGroupEvent() : myResult( -1 ) {}
1758   virtual void Execute()
1759   {
1760     myResult = PyModuleHelper::defaultMenuGroup();
1761   }
1762 };
1763 int SalomePyQt::defaultMenuGroup()
1764 {
1765   return ProcessEvent( new TDefMenuGroupEvent() );
1766 }
1767
1768 class CrTool
1769 {
1770 public:
1771   CrTool( const QString& tBar, const QString& nBar )
1772     : myCase( 0 ), myTbTitle( tBar ), myTbName( nBar)  {}
1773   CrTool( const int id, const int tBar, const int idx )
1774     : myCase( 1 ), myId( id ), myTbId( tBar ), myIndex( idx ) {}
1775   CrTool( const int id, const QString& tBar, const int idx )
1776     : myCase( 2 ), myId( id ), myTbTitle( tBar ), myIndex( idx ) {}
1777   CrTool( QAction* action, const int tbId, const int id, const int idx )
1778     : myCase( 3 ), myAction( action ), myTbId( tbId ), myId( id ), myIndex( idx ) {}
1779   CrTool( QAction* action, const QString& tBar, const int id, const int idx )
1780     : myCase( 4 ), myAction( action ), myTbTitle( tBar ), myId( id ), myIndex( idx ) {}
1781
1782   int execute( LightApp_Module* module ) const
1783   {
1784     if ( module ) {
1785       switch ( myCase ) {
1786       case 0:
1787         return module->createTool( myTbTitle, myTbName );
1788       case 1:
1789         return module->createTool( myId, myTbId, myIndex );
1790       case 2:
1791         return module->createTool( myId, myTbTitle, myIndex );
1792       case 3:
1793         return module->createTool( myAction, myTbId, myId, myIndex );
1794       case 4:
1795         return module->createTool( myAction, myTbTitle, myId, myIndex );
1796       }
1797     }
1798     return -1;
1799   }
1800 private:
1801    int        myCase;
1802    QString    myTbTitle;
1803    QString    myTbName;
1804    int        myTbId;
1805    QAction*   myAction;
1806    int        myId;
1807    int        myIndex;
1808 };
1809
1810 class TCreateToolEvent: public SALOME_Event
1811 {
1812 public:
1813   typedef int TResult;
1814   TResult myResult;
1815   const CrTool& myCrTool;
1816   TCreateToolEvent( const CrTool& crTool )
1817     : myResult( -1 ), myCrTool( crTool ) {}
1818   virtual void Execute()
1819   {
1820     LightApp_Module* module = getActiveModule();
1821     if ( module )
1822       myResult = myCrTool.execute( module );
1823   }
1824 };
1825
1826 /*!
1827   \brief Create toolbar with specified name.
1828   \param tBar toolbar title (language-dependent)
1829   \param nBar toolbar name (language-independent) [optional]
1830   \return toolbar ID or -1 if toolbar creation is failed
1831 */
1832 int SalomePyQt::createTool( const QString& tBar, const QString& nBar )
1833 {
1834   return ProcessEvent( new TCreateToolEvent( CrTool( tBar, nBar ) ) );
1835 }
1836
1837 /*!
1838   \brief Insert action with specified \a id to the toolbar.
1839   \param id action ID
1840   \param tBar toolbar ID
1841   \param idx required index in the toolbar
1842   \return action ID or -1 if action could not be added
1843 */
1844 int SalomePyQt::createTool( const int id, const int tBar, const int idx )
1845 {
1846   return ProcessEvent( new TCreateToolEvent( CrTool( id, tBar, idx ) ) );
1847 }
1848
1849 /*!
1850   \brief Insert action with specified \a id to the toolbar.
1851   \param id action ID
1852   \param tBar toolbar name
1853   \param idx required index in the toolbar
1854   \return action ID or -1 if action could not be added
1855 */
1856 int SalomePyQt::createTool( const int id, const QString& tBar, const int idx )
1857 {
1858   return ProcessEvent( new TCreateToolEvent( CrTool( id, tBar, idx ) ) );
1859 }
1860
1861 /*!
1862   \brief Insert action to the toolbar.
1863   \param a action
1864   \param tBar toolbar ID
1865   \param id required action ID
1866   \param idx required index in the toolbar
1867   \return action ID or -1 if action could not be added
1868 */
1869 int SalomePyQt::createTool( QAction* a, const int tBar, const int id, const int idx )
1870 {
1871   return ProcessEvent( new TCreateToolEvent( CrTool( a, tBar, id, idx ) ) );
1872 }
1873
1874 /*!
1875   \brief Insert action to the toolbar.
1876   \param a action
1877   \param tBar toolbar name
1878   \param id required action ID
1879   \param idx required index in the toolbar
1880   \return action ID or -1 if action could not be added
1881 */
1882 int SalomePyQt::createTool( QAction* a, const QString& tBar, const int id, const int idx )
1883 {
1884   return ProcessEvent( new TCreateToolEvent( CrTool( a, tBar, id, idx ) ) );
1885 }
1886
1887 class CrMenu
1888 {
1889 public:
1890   CrMenu( const QString& subMenu, const int menu, const int id, const int group, const int idx )
1891     : myCase( 0 ), mySubMenuName( subMenu ), myMenuId( menu ), myId( id ), myGroup( group ), myIndex( idx ) {}
1892   CrMenu( const QString& subMenu, const QString& menu, const int id, const int group, const int idx )
1893     : myCase( 1 ), mySubMenuName( subMenu ), myMenuName( menu ), myId( id ), myGroup( group ), myIndex( idx ) {}
1894   CrMenu( const int id, const int menu, const int group, const int idx )
1895     : myCase( 2 ), myId( id ), myMenuId( menu ), myGroup( group ), myIndex( idx ) {}
1896   CrMenu( const int id, const QString& menu, const int group, const int idx )
1897     : myCase( 3 ), myId( id ), myMenuName( menu ), myGroup( group ), myIndex( idx ) {}
1898   CrMenu( QAction* action, const int menu, const int id, const int group, const int idx )
1899     : myCase( 4 ), myAction( action ), myMenuId( menu ), myId( id ), myGroup( group ), myIndex( idx ) {}
1900   CrMenu( QAction* action, const QString& menu, const int id, const int group, const int idx )
1901     : myCase( 5 ), myAction( action ), myMenuName( menu ), myId( id ), myGroup( group ), myIndex( idx ) {}
1902
1903   int execute( LightApp_Module* module ) const
1904   {
1905     if ( module ) {
1906       switch ( myCase ) {
1907       case 0:
1908         return module->createMenu( mySubMenuName, myMenuId, myId, myGroup, myIndex );
1909       case 1:
1910         return module->createMenu( mySubMenuName, myMenuName, myId, myGroup, myIndex );
1911       case 2:
1912         return module->createMenu( myId, myMenuId, myGroup, myIndex );
1913       case 3:
1914         return module->createMenu( myId, myMenuName, myGroup, myIndex );
1915       case 4:
1916         return module->createMenu( myAction, myMenuId, myId, myGroup, myIndex );
1917       case 5:
1918         return module->createMenu( myAction, myMenuName, myId, myGroup, myIndex );
1919       }
1920     }
1921     return -1;
1922   }
1923 private:
1924    int        myCase;
1925    QString    myMenuName;
1926    int        myMenuId;
1927    QString    mySubMenuName;
1928    int        myGroup;
1929    QAction*   myAction;
1930    int        myId;
1931    int        myIndex;
1932 };
1933
1934 class TCreateMenuEvent: public SALOME_Event
1935 {
1936 public:
1937   typedef int TResult;
1938   TResult myResult;
1939   const CrMenu& myCrMenu;
1940   TCreateMenuEvent( const CrMenu& crMenu )
1941     : myResult( -1 ), myCrMenu( crMenu ) {}
1942   virtual void Execute()
1943   {
1944     LightApp_Module* module = getActiveModule();
1945     if ( module )
1946       myResult = myCrMenu.execute( module );
1947   }
1948 };
1949
1950 /*!
1951   \brief Create main menu.
1952   \param subMenu menu name
1953   \param menu parent menu ID
1954   \param id required menu ID
1955   \param group menu group ID
1956   \param idx required index in the menu
1957   \return menu ID or -1 if menu could not be added
1958 */
1959 int SalomePyQt::createMenu( const QString& subMenu, const int menu, const int id, const int group, const int idx )
1960 {
1961   return ProcessEvent( new TCreateMenuEvent( CrMenu( subMenu, menu, id, group, idx ) ) );
1962 }
1963
1964 /*!
1965   \brief Create main menu.
1966   \param subMenu menu name
1967   \param menu parent menu name (list of menu names separated by "|")
1968   \param id required menu ID
1969   \param group menu group ID
1970   \param idx required index in the menu
1971   \return menu ID or -1 if menu could not be added
1972 */
1973 int SalomePyQt::createMenu( const QString& subMenu, const QString& menu, const int id, const int group, const int idx )
1974 {
1975   return ProcessEvent( new TCreateMenuEvent( CrMenu( subMenu, menu, id, group, idx ) ) );
1976 }
1977
1978 /*!
1979   \brief Insert action to the main menu.
1980   \param id action ID
1981   \param menu parent menu ID
1982   \param group menu group ID
1983   \param idx required index in the menu
1984   \return action ID or -1 if action could not be added
1985 */
1986 int SalomePyQt::createMenu( const int id, const int menu, const int group, const int idx )
1987 {
1988   return ProcessEvent( new TCreateMenuEvent( CrMenu( id, menu, group, idx ) ) );
1989 }
1990
1991 /*!
1992   \brief Insert action to the main menu.
1993   \param id action ID
1994   \param menu parent menu name (list of menu names separated by "|")
1995   \param group menu group ID
1996   \param idx required index in the menu
1997   \return action ID or -1 if action could not be added
1998 */
1999 int SalomePyQt::createMenu( const int id, const QString& menu, const int group, const int idx )
2000 {
2001   return ProcessEvent( new TCreateMenuEvent( CrMenu( id, menu, group, idx ) ) );
2002 }
2003
2004 /*!
2005   \brief Insert action to the main menu.
2006   \param a action
2007   \param menu parent menu ID
2008   \param group menu group ID
2009   \param idx required index in the menu
2010   \return action ID or -1 if action could not be added
2011 */
2012 int SalomePyQt::createMenu( QAction* a, const int menu, const int id, const int group, const int idx )
2013 {
2014   return ProcessEvent( new TCreateMenuEvent( CrMenu( a, menu, id, group, idx ) ) );
2015 }
2016
2017 /*!
2018   \brief Insert action to the main menu.
2019   \param a action
2020   \param menu parent menu name (list of menu names separated by "|")
2021   \param group menu group ID
2022   \param idx required index in the menu
2023   \return action ID or -1 if action could not be added
2024 */
2025 int SalomePyQt::createMenu( QAction* a, const QString& menu, const int id, const int group, const int idx )
2026 {
2027   return ProcessEvent( new TCreateMenuEvent( CrMenu( a, menu, id, group, idx ) ) );
2028 }
2029
2030 /*!
2031   \fn QAction* SalomePyQt::createSeparator();
2032   \brief Create separator action which can be used in the menu or toolbar.
2033   \return new separator action
2034 */
2035
2036 class TCreateSepEvent: public SALOME_Event
2037 {
2038 public:
2039   typedef QAction* TResult;
2040   TResult myResult;
2041   TCreateSepEvent()
2042     : myResult( 0 ) {}
2043   virtual void Execute()
2044   {
2045     LightApp_Module* module = getActiveModule();
2046     if ( module )
2047       myResult = (QAction*)module->separator();
2048   }
2049 };
2050 QAction* SalomePyQt::createSeparator()
2051 {
2052   return ProcessEvent( new TCreateSepEvent() );
2053 }
2054
2055 /*!
2056   \fn QAction* SalomePyQt::createAction( const int      id,
2057                                          const QString& menuText,
2058                                          const QString& tipText,
2059                                          const QString& statusText,
2060                                          const QString& icon,
2061                                          const int      key,
2062                                          const bool     toggle );
2063   \brief Create an action which can be then used in the menu or toolbar.
2064   \param id the unique id action to be registered to
2065   \param menuText action text which should appear in menu
2066   \param tipText text which should appear in the tooltip
2067   \param statusText text which should appear in the status bar when action is activated
2068   \param icon the name of the icon file (the actual icon file name can be coded in the translation files)
2069   \param key the key accelrator for the action
2070   \param toggle if \c true the action is checkable
2071 */
2072
2073 class TCreateActionEvent: public SALOME_Event
2074 {
2075 public:
2076   typedef QAction* TResult;
2077   TResult myResult;
2078   int     myId;
2079   QString myMenuText;
2080   QString myTipText;
2081   QString myStatusText;
2082   QString myIcon;
2083   int     myKey;
2084   bool    myToggle;
2085   TCreateActionEvent( const int id, const QString& menuText, const QString& tipText,
2086                       const QString& statusText, const QString& icon, const int key, const bool toggle )
2087     : myResult( 0 ), myId( id ), myMenuText( menuText ), myTipText( tipText ),
2088       myStatusText( statusText ), myIcon( icon ), myKey( key ), myToggle( toggle ) {}
2089   virtual void Execute()
2090   {
2091     LightApp_Module* module = getActiveModule();
2092     if ( module ) {
2093       QIcon icon = loadIconInternal( module->name(), myIcon );
2094       myResult = (QAction*)module->action( myId );
2095       if ( myResult ) {
2096         if ( myResult->toolTip().isEmpty() && !myTipText.isEmpty() )
2097           myResult->setToolTip( myTipText );
2098         if ( myResult->text().isEmpty() && !myMenuText.isEmpty() )
2099           myResult->setText( myMenuText );
2100         if ( myResult->icon().isNull() && !icon.isNull() )
2101           myResult->setIcon( icon );
2102         if ( myResult->statusTip().isEmpty() && !myStatusText.isEmpty() )
2103           myResult->setStatusTip( myStatusText );
2104         if ( myResult->shortcut().isEmpty() && myKey )
2105           myResult->setShortcut( myKey );
2106         if ( myResult->isCheckable() != myToggle )
2107           myResult->setCheckable( myToggle );
2108       }
2109       else {
2110         myResult = (QAction*)module->createAction( myId, myTipText, icon, myMenuText, myStatusText, myKey, module, myToggle );
2111       }
2112       // for Python module, automatically connect action to callback slot
2113       PyModuleHelper* helper = module->findChild<PyModuleHelper*>( "python_module_helper" );
2114       if ( helper ) helper->connectAction( myResult );
2115     }
2116   }
2117 };
2118 QAction* SalomePyQt::createAction( const int id,           const QString& menuText,
2119                                    const QString& tipText, const QString& statusText,
2120                                    const QString& icon,    const int key, const bool toggle )
2121 {
2122   return ProcessEvent( new TCreateActionEvent( id, menuText, tipText, statusText, icon, key, toggle ) );
2123 }
2124
2125 /*!
2126   \fn QtxActionGroup* SalomePyQt::createActionGroup( const int id, const bool exclusive );
2127   \brief Create an action group which can be then used in the menu or toolbar
2128   \param id         : the unique id action group to be registered to
2129   \param exclusive  : if \c true the action group does exclusive toggling
2130 */
2131
2132 struct TCreateActionGroupEvent: public SALOME_Event
2133 {
2134   typedef QtxActionGroup* TResult;
2135   TResult myResult;
2136   int     myId;
2137   bool    myExclusive;
2138   TCreateActionGroupEvent( const int id, const bool exclusive )
2139     : myId( id ), myExclusive( exclusive ) {}
2140   virtual void Execute()
2141   {
2142     LightApp_Module* module = getActiveModule();
2143     if ( module )
2144       myResult = module->createActionGroup( myId, myExclusive );
2145   }
2146 };
2147 QtxActionGroup* SalomePyQt::createActionGroup( const int id, const bool exclusive )
2148 {
2149   return ProcessEvent( new TCreateActionGroupEvent( id, exclusive ) );
2150 }
2151
2152 /*!
2153   \fn QAction* SalomePyQt::action( const int id );
2154   \brief Get action by specified identifier.
2155   \return action or 0 if action is not registered
2156 */
2157
2158 class TActionEvent: public SALOME_Event
2159 {
2160 public:
2161   typedef QAction* TResult;
2162   TResult myResult;
2163   int     myId;
2164   TActionEvent( const int id )
2165     : myResult( 0 ), myId( id ) {}
2166   virtual void Execute()
2167   {
2168     LightApp_Module* module = getActiveModule();
2169     if ( module )
2170       myResult = (QAction*)module->action( myId );
2171   }
2172 };
2173 QAction* SalomePyQt::action( const int id )
2174 {
2175   return ProcessEvent( new TActionEvent( id ) );
2176 }
2177
2178 /*!
2179   \fn int SalomePyQt::actionId( const QAction* a );
2180   \brief Get an action identifier.
2181   \return action ID or -1 if action is not registered
2182 */
2183
2184 class TActionIdEvent: public SALOME_Event
2185 {
2186 public:
2187   typedef  int TResult;
2188   TResult  myResult;
2189   const QAction* myAction;
2190   TActionIdEvent( const QAction* action )
2191     : myResult( -1 ), myAction( action ) {}
2192   virtual void Execute()
2193   {
2194     LightApp_Module* module = getActiveModule();
2195     if ( module )
2196       myResult = module->actionId( myAction );
2197   }
2198 };
2199 int SalomePyQt::actionId( const QAction* a )
2200 {
2201   return ProcessEvent( new TActionIdEvent( a ) );
2202 }
2203
2204 /*!
2205   \fn int SalomePyQt::addGlobalPreference( const QString& label );
2206   \brief Add global (not module-related) preferences group.
2207   \param label global preferences group name
2208   \return preferences group identifier
2209 */
2210
2211 class TAddGlobalPrefEvent: public SALOME_Event
2212 {
2213 public:
2214   typedef int TResult;
2215   TResult myResult;
2216   QString myLabel;
2217   TAddGlobalPrefEvent( const QString& label )
2218     : myResult( -1 ), myLabel( label ) {}
2219   virtual void Execute()
2220   {
2221     LightApp_Module* module = getActiveModule();
2222     if ( module ) {
2223       LightApp_Preferences* pref = module->getApp()->preferences();
2224       if ( pref )
2225         myResult = pref->addPreference( myLabel, -1 );
2226     }
2227   }
2228 };
2229 int SalomePyQt::addGlobalPreference( const QString& label )
2230 {
2231   return ProcessEvent( new TAddGlobalPrefEvent( label ) );
2232 }
2233
2234 /*!
2235   \fn int SalomePyQt::addPreference( const QString& label );
2236   \brief Add module-related preferences group.
2237   \param label preferences group name
2238   \return preferences group identifier
2239 */
2240
2241 class TAddPrefEvent: public SALOME_Event
2242 {
2243 public:
2244   typedef int TResult;
2245   TResult myResult;
2246   QString myLabel;
2247   TAddPrefEvent( const QString& label )
2248     : myResult( -1 ), myLabel( label ) {}
2249   virtual void Execute()
2250   {
2251     LightApp_Module* module = getActiveModule();
2252     if ( module ) {
2253       LightApp_Preferences* pref = module->getApp()->preferences();
2254       if ( pref ) {
2255         int cId = pref->addPreference( module->moduleName(), -1 );
2256         if ( cId != -1 )
2257           myResult = pref->addPreference( myLabel, cId );
2258       }
2259     }
2260   }
2261 };
2262 int SalomePyQt::addPreference( const QString& label )
2263 {
2264   return ProcessEvent( new TAddPrefEvent( label ) );
2265 }
2266
2267 /*!
2268   \fn int SalomePyQt::addPreference( const QString& label, const int pId, const int type,
2269                                      const QString& section, const QString& param );
2270   \brief Add module-related preferences.
2271   \param label preferences group name
2272   \param pId parent preferences group id
2273   \param type preferences type
2274   \param section resources file section name
2275   \param param resources file setting name
2276   \return preferences identifier
2277 */
2278
2279 class TAddPrefParamEvent: public SALOME_Event
2280 {
2281 public:
2282   typedef int TResult;
2283   TResult myResult;
2284   QString myLabel;
2285   int     myPId;
2286   int     myType;
2287   QString mySection;
2288   QString myParam;
2289   TAddPrefParamEvent( const QString& label,
2290                       const int pId, const int type,
2291                       const QString& section,
2292                       const QString& param )
2293     : myResult( -1 ),
2294       myLabel( label ), myPId( pId ), myType( type ),
2295       mySection( section ), myParam ( param ) {}
2296   virtual void Execute()
2297   {
2298     LightApp_Module* module = getActiveModule();
2299     if ( module ) {
2300       LightApp_Preferences* pref = module->getApp()->preferences();
2301       if ( pref )
2302         myResult = pref->addPreference( module->moduleName(), myLabel, myPId, myType, mySection, myParam );
2303     }
2304   }
2305 };
2306 int SalomePyQt::addPreference( const QString& label, const int pId, const int type,
2307                                const QString& section, const QString& param )
2308 {
2309   return ProcessEvent( new TAddPrefParamEvent( label, pId, type, section, param ) );
2310 }
2311
2312 /*!
2313   \fn QVariant SalomePyQt::preferenceProperty( const int id, const QString& prop );
2314   \brief Get the preferences property.
2315   \param id preferences identifier
2316   \param prop preferences property name
2317   \return preferences property value or null QVariant if property is not set
2318 */
2319
2320 class TPrefPropEvent: public SALOME_Event
2321 {
2322 public:
2323   typedef QVariant TResult;
2324   TResult myResult;
2325   int     myId;
2326   QString myProp;
2327   TPrefPropEvent( const int id, const QString& prop )
2328     : myId( id ), myProp( prop ) {}
2329   virtual void Execute()
2330   {
2331     LightApp_Module* module = getActiveModule();
2332     if ( module ) {
2333       LightApp_Preferences* pref = module->getApp()->preferences();
2334       if ( pref )
2335         myResult = pref->itemProperty( myProp, myId );
2336     }
2337   }
2338 };
2339 QVariant SalomePyQt::preferenceProperty( const int id, const QString& prop )
2340 {
2341   return ProcessEvent( new TPrefPropEvent( id, prop ) );
2342 }
2343
2344 /*!
2345   \brief Set the preferences property.
2346   \param id preferences identifier
2347   \param prop preferences property name
2348   \param var preferences property value
2349 */
2350 void SalomePyQt::setPreferenceProperty( const int id,
2351                                         const QString& prop,
2352                                         const QVariant& var )
2353 {
2354   class TEvent: public SALOME_Event
2355   {
2356     int      myId;
2357     QString  myProp;
2358     QVariant myVar;
2359   public:
2360     TEvent( const int id, const QString& prop, const QVariant& var )
2361       : myId( id ), myProp( prop ), myVar( var ) {}
2362     virtual void Execute()
2363     {
2364       LightApp_Module* module = getActiveModule();
2365       if ( module ) {
2366         LightApp_Preferences* pref = module->getApp()->preferences();
2367         if ( pref )
2368           pref->setItemProperty( myProp, myVar, myId );
2369       }
2370     }
2371   };
2372   ProcessVoidEvent( new TEvent( id, prop, var) );
2373 }
2374
2375 /*!
2376   \brief Add the property value to the list of values.
2377
2378   This method allows creating properties which are QList<QVariant>
2379   - there is no way to pass such values directly to QVariant parameter with PyQt.
2380
2381   \param id preferences identifier
2382   \param prop preferences property name
2383   \param idx preferences property index
2384   \param var preferences property value for the index \a idx
2385 */
2386 void SalomePyQt::addPreferenceProperty( const int id,
2387                                         const QString& prop,
2388                                         const int idx,
2389                                         const QVariant& var )
2390 {
2391   class TEvent: public SALOME_Event
2392   {
2393     int      myId;
2394     QString  myProp;
2395     int      myIdx;
2396     QVariant myVar;
2397   public:
2398     TEvent( const int id, const QString& prop, const int idx, const QVariant& var )
2399       : myId( id ), myProp( prop ), myIdx( idx), myVar( var ) {}
2400     virtual void Execute()
2401     {
2402       LightApp_Module* module = getActiveModule();
2403       if ( module ) {
2404         LightApp_Preferences* pref = module->getApp()->preferences();
2405         if ( pref ) {
2406           QVariant var =  pref->itemProperty( myProp, myId );
2407           if ( var.isValid() ) {
2408             if ( var.type() == QVariant::StringList ) {
2409               QStringList sl = var.toStringList();
2410               if ( myIdx >= 0 && myIdx < sl.count() )
2411                 sl[myIdx] = myVar.toString();
2412               else
2413                 sl.append( myVar.toString() );
2414               pref->setItemProperty( myProp, sl, myId );
2415             }
2416             else if ( var.type() == QVariant::List ) {
2417               QList<QVariant> vl = var.toList();
2418               if ( myIdx >= 0 && myIdx < vl.count() )
2419                 vl[myIdx] = myVar;
2420               else
2421                 vl.append( myVar );
2422               pref->setItemProperty( myProp, vl, myId );
2423             }
2424           }
2425           else {
2426             QList<QVariant> vl;
2427             vl.append( myVar );
2428             pref->setItemProperty( myProp, vl, myId );
2429           }
2430         }
2431       }
2432     }
2433   };
2434   ProcessVoidEvent( new TEvent( id, prop, idx, var) );
2435 }
2436
2437 /*!
2438   \brief Put the message to the Log messages output window
2439   \param msg message text (it can be of simple rich text format)
2440   \param addSeparator boolean flag which specifies if it is necessary
2441          to separate the message with predefined separator
2442 */
2443 void SalomePyQt::message( const QString& msg, bool addSeparator )
2444 {
2445   class TEvent: public SALOME_Event
2446   {
2447     QString  myMsg;
2448     bool     myAddSep;
2449   public:
2450     TEvent( const QString& msg, bool addSeparator )
2451       : myMsg( msg ), myAddSep( addSeparator ) {}
2452     virtual void Execute()
2453     {
2454       if ( LightApp_Application* anApp = getApplication() ) {
2455         LogWindow* lw = anApp->logWindow();
2456         if ( lw )
2457           lw->putMessage( myMsg, myAddSep );
2458       }
2459     }
2460   };
2461   ProcessVoidEvent( new TEvent( msg, addSeparator ) );
2462 }
2463
2464 /*!
2465   \brief Remove all the messages from the Log messages output window.
2466 */
2467 void SalomePyQt::clearMessages()
2468 {
2469   class TEvent: public SALOME_Event
2470   {
2471   public:
2472     TEvent() {}
2473     virtual void Execute()
2474     {
2475       if ( LightApp_Application* anApp = getApplication() ) {
2476         LogWindow* lw = anApp->logWindow();
2477         if ( lw )
2478           lw->clear();
2479       }
2480     }
2481   };
2482   ProcessVoidEvent( new TEvent() );
2483 }
2484
2485 /*!
2486   \fn bool SalomePyQt::dumpView( const QString& filename, const int id = 0 );
2487   \brief Dump the contents of the id view window. If id is 0 then current active view is processed.
2488   to the image file in the specified format.
2489
2490   For the current moment JPEG, PNG and BMP images formats are supported.
2491   The image format is defined automatically by the file name extension.
2492   By default, BMP format is used.
2493
2494   \param filename image file name
2495   \return operation status (\c true on success)
2496 */
2497
2498 class TDumpViewEvent: public SALOME_Event
2499 {
2500 public:
2501   typedef bool TResult;
2502   TResult myResult;
2503   QString myFileName;
2504   int myWndId;
2505   TDumpViewEvent( const QString& filename, const int id )
2506     : myResult ( false ), myFileName( filename ), myWndId( id ) {}
2507   virtual void Execute()
2508   {
2509     SUIT_ViewWindow* wnd = 0;
2510     if ( !myWndId ) {
2511       if ( LightApp_Application* anApp = getApplication() ) {
2512         SUIT_ViewManager* vm = anApp->activeViewManager();
2513         if ( vm )
2514           wnd = vm->getActiveView();
2515       }
2516       myWndId = wnd->getId();
2517     }
2518     else {
2519       wnd = dynamic_cast<SUIT_ViewWindow*>( getWnd( myWndId ) );
2520     }
2521     if ( wnd ) {
2522       QString fmt = SUIT_Tools::extension( myFileName ).toUpper();
2523 #ifndef DISABLE_PLOT2DVIEWER
2524       Plot2d_ViewWindow* wnd2D = dynamic_cast<Plot2d_ViewWindow*>( wnd );
2525       if ( wnd2D ) {
2526         qApp->postEvent( wnd2D->getViewFrame(), new QPaintEvent( QRect( 0, 0, wnd2D->getViewFrame()->width(), wnd2D->getViewFrame()->height() ) ) );
2527         qApp->postEvent( wnd2D, new QPaintEvent( QRect( 0, 0, wnd2D->width(), wnd2D->height() ) ) );
2528         qApp->processEvents();
2529         if ( fmt == "PS" || fmt == "EPS" || fmt == "PDF" ) {
2530           myResult = wnd2D->getViewFrame()->print( myFileName, fmt );
2531           return;
2532         }
2533       }
2534 #endif // DISABLE_PLOT2DVIEWER
2535       QImage im = wnd->dumpView();
2536       if ( !im.isNull() && !myFileName.isEmpty() ) {
2537         if ( fmt.isEmpty() ) fmt = QString( "BMP" ); // default format
2538         if ( fmt == "JPG" )  fmt = "JPEG";
2539         myResult = im.save( myFileName, fmt.toLatin1() );
2540       }
2541     }
2542   }
2543 };
2544 bool SalomePyQt::dumpView( const QString& filename, const int id )
2545 {
2546   return ProcessEvent( new TDumpViewEvent( filename, id ) );
2547 }
2548
2549 /*!
2550   \fn QList<int> SalomePyQt::getViews();
2551   \brief Get list of integer identifiers of all the currently opened views
2552   \return list of integer identifiers of all the currently opened views
2553 */
2554
2555 class TGetViews: public SALOME_Event
2556 {
2557 public:
2558   typedef QList<int> TResult;
2559   TResult myResult;
2560   TGetViews() {}
2561   virtual void Execute()
2562   {
2563     myResult.clear();
2564     LightApp_Application* app  = getApplication();
2565     if ( app ) {
2566       STD_TabDesktop* tabDesk = dynamic_cast<STD_TabDesktop*>( app->desktop() );
2567       if ( tabDesk ) {
2568         QList<SUIT_ViewWindow*> wndlist = tabDesk->windows();
2569         SUIT_ViewWindow* wnd;
2570         foreach ( wnd, wndlist )
2571           myResult.append( wnd->getId() );
2572       }
2573     }
2574   }
2575 };
2576 QList<int> SalomePyQt::getViews()
2577 {
2578   return ProcessEvent( new TGetViews() );
2579 }
2580
2581 /*!
2582   \fn int SalomePyQt::getActiveView();
2583   \brief Get integer identifier of the currently active view
2584   \return integer identifier of the currently active view
2585 */
2586
2587 class TGetActiveView: public SALOME_Event
2588 {
2589 public:
2590   typedef int TResult;
2591   TResult myResult;
2592   TGetActiveView()
2593     : myResult( -1 ) {}
2594   virtual void Execute()
2595   {
2596     LightApp_Application* app = getApplication();
2597     if ( app ) {
2598       SUIT_ViewManager* viewMgr = app->activeViewManager();
2599       if ( viewMgr ) {
2600         SUIT_ViewWindow* wnd = viewMgr->getActiveView();
2601         if ( wnd )
2602           myResult = wnd->getId();
2603       }
2604     }
2605   }
2606 };
2607 int SalomePyQt::getActiveView()
2608 {
2609   return ProcessEvent( new TGetActiveView() );
2610 }
2611
2612 /*!
2613   \fn QString SalomePyQt::getViewType( const int id );
2614   \brief Get type of the specified view, e.g. "OCCViewer"
2615   \param id window identifier
2616   \return view type
2617 */
2618
2619 class TGetViewType: public SALOME_Event
2620 {
2621 public:
2622   typedef QString TResult;
2623   TResult myResult;
2624   int myWndId;
2625   TGetViewType( const int id )
2626     : myWndId( id ) {}
2627   virtual void Execute()
2628   {
2629     SUIT_ViewWindow* wnd = getWnd( myWndId );
2630     if ( wnd ) {
2631       SUIT_ViewManager* viewMgr = wnd->getViewManager();
2632       if ( viewMgr )
2633         myResult = viewMgr->getType();
2634     }
2635   }
2636 };
2637 QString SalomePyQt::getViewType( const int id )
2638 {
2639   return ProcessEvent( new TGetViewType( id ) );
2640 }
2641
2642 /*!
2643   \fn bool SalomePyQt::setViewTitle( const int id, const QString& title );
2644   \brief Change view caption
2645   \param id window identifier
2646   \param title new window title
2647   \return \c true if operation is completed successfully and \c false otherwise
2648 */
2649
2650 class TSetViewTitle: public SALOME_Event
2651 {
2652 public:
2653   typedef bool TResult;
2654   TResult myResult;
2655   int myWndId;
2656   QString myTitle;
2657   TSetViewTitle( const int id, const QString& title )
2658     : myResult( false ),
2659       myWndId( id ),
2660       myTitle( title ) {}
2661   virtual void Execute()
2662   {
2663     SUIT_ViewWindow* wnd = getWnd( myWndId );
2664     if ( wnd ) {
2665       wnd->setWindowTitle( myTitle );
2666       myResult = true;
2667     }
2668   }
2669 };
2670 bool SalomePyQt::setViewTitle( const int id, const QString& title )
2671 {
2672   return ProcessEvent( new TSetViewTitle( id, title ) );
2673 }
2674
2675 /*!
2676   \fn bool SalomePyQt::setViewSize( const int w, const int h, const int id );
2677   \brief Set view size
2678   \param w window width
2679   \param h window height
2680   \param id window identifier
2681   \return \c true if operation is completed successfully and \c false otherwise
2682 */
2683
2684 class TSetViewSize: public SALOME_Event
2685 {
2686 public:
2687   typedef bool TResult;
2688   TResult myResult;
2689   int myWndWidth;
2690   int myWndHeight;
2691   int myWndId;
2692   TSetViewSize( const int w, const int h, const int id )
2693     : myResult( false ),
2694       myWndWidth( w ),
2695       myWndHeight( h ),
2696       myWndId( id ) {}
2697   virtual void Execute()
2698   {
2699     SUIT_ViewWindow* wnd = 0;
2700     if ( !myWndId ) {
2701       if ( LightApp_Application* anApp = getApplication() ) {
2702         SUIT_ViewManager* vm = anApp->activeViewManager();
2703         if ( vm )
2704           wnd = vm->getActiveView();
2705       }
2706     }
2707     else {
2708       wnd = dynamic_cast<SUIT_ViewWindow*>( getWnd( myWndId ) );
2709     }
2710     if ( wnd ) {
2711       SUIT_ViewManager* viewMgr = wnd->getViewManager();
2712       if ( viewMgr ) {
2713         QString type = viewMgr->getType();
2714         if ( type == "OCCViewer") {
2715 #ifndef DISABLE_OCCVIEWER
2716           // specific processing for OCC viewer:
2717           // OCC view can embed up to 4 sub-views, split according to the specified layout;
2718           // - if there is only one sub-view active; it will be resized;
2719           // - if there are several sub-views, each of them will be resized.
2720           OCCViewer_ViewWindow* occView = qobject_cast<OCCViewer_ViewWindow*>( wnd );
2721           for ( int i = OCCViewer_ViewFrame::BOTTOM_RIGHT; i <= OCCViewer_ViewFrame::TOP_RIGHT; i++ ) {
2722             if ( occView && occView->getView( i ) ) {
2723               occView->getView( i )->centralWidget()->resize( myWndWidth, myWndHeight );
2724               myResult = true;
2725             }
2726           }
2727 #endif // DISABLE_OCCVIEWER
2728         }
2729         else if ( type == "ParaView") {
2730 #ifndef DISABLE_PVVIEWER
2731           // specific processing for ParaView viewer:
2732           // hierarchy of ParaView viewer is much complex than for usual view;
2733           // we look for sub-widget named "Viewport"
2734           QList<QWidget*> lst = wnd->findChildren<QWidget*>( "Viewport" );
2735           if ( !lst.isEmpty() ) {
2736             lst[0]->resize( myWndWidth, myWndHeight );
2737             myResult = true;
2738           }
2739 #endif // DISABLE_PVVIEWER
2740         }
2741         else {
2742           if ( wnd->centralWidget() ) {
2743             wnd->centralWidget()->resize( myWndWidth, myWndHeight );
2744             myResult = true;
2745           }
2746         }
2747       }
2748     }
2749   }
2750 };
2751 bool SalomePyQt::setViewSize( const int w, const int h, const int id )
2752 {
2753   return ProcessEvent( new TSetViewSize( w, h, id ) );
2754 }
2755
2756 /*!
2757   \fn QString SalomePyQt::getViewTitle( const int id );
2758   \brief Get view caption
2759   \param id window identifier
2760   \return view caption
2761 */
2762
2763 class TGetViewTitle: public SALOME_Event
2764 {
2765 public:
2766   typedef QString TResult;
2767   TResult myResult;
2768   int myWndId;
2769   TGetViewTitle( const int id )
2770     : myWndId( id ) {}
2771   virtual void Execute()
2772   {
2773     SUIT_ViewWindow* wnd = getWnd( myWndId );
2774     if ( wnd )
2775       myResult = wnd->windowTitle();
2776   }
2777 };
2778 QString SalomePyQt::getViewTitle( const int id )
2779 {
2780   return ProcessEvent( new TGetViewTitle( id ) );
2781 }
2782
2783 /*!
2784   \fn QList<int> SalomePyQt::findViews( const QString& type );
2785   \brief Get list of integer identifiers of all the
2786          currently opened views of the specified type
2787   \param type viewer type
2788   \return list of integer identifiers
2789 */
2790
2791 class TFindViews: public SALOME_Event
2792 {
2793 public:
2794   typedef QList<int> TResult;
2795   TResult myResult;
2796   QString myType;
2797   TFindViews( const QString& type )
2798     : myType( type ) {}
2799   virtual void Execute()
2800   {
2801     myResult.clear();
2802     LightApp_Application* app  = getApplication();
2803     if ( app ) {
2804       ViewManagerList vmList;
2805       app->viewManagers( myType, vmList );
2806       SUIT_ViewManager* viewMgr;
2807       foreach ( viewMgr, vmList ) {
2808         QVector<SUIT_ViewWindow*> vec = viewMgr->getViews();
2809         for ( int i = 0, n = vec.size(); i < n; i++ ) {
2810           SUIT_ViewWindow* wnd = vec[ i ];
2811           if ( wnd )
2812             myResult.append( wnd->getId() );
2813         }
2814       }
2815     }
2816   }
2817 };
2818 QList<int> SalomePyQt::findViews( const QString& type )
2819 {
2820   return ProcessEvent( new TFindViews( type ) );
2821 }
2822
2823 /*!
2824   \fn bool SalomePyQt::activateView( const int id );
2825   \brief Activate view
2826   \param id window identifier
2827   \return \c true if operation is completed successfully and \c false otherwise
2828 */
2829
2830 class TActivateView: public SALOME_Event
2831 {
2832 public:
2833   typedef bool TResult;
2834   TResult myResult;
2835   int myWndId;
2836   TActivateView( const int id )
2837     : myResult( false ),
2838       myWndId( id ) {}
2839   virtual void Execute()
2840   {
2841     SUIT_ViewWindow* wnd = getWnd( myWndId );
2842     if ( wnd ) {
2843       wnd->setFocus();
2844       myResult = true;
2845     }
2846   }
2847 };
2848 bool SalomePyQt::activateView( const int id )
2849 {
2850   return ProcessEvent( new TActivateView( id ) );
2851 }
2852
2853 /*!
2854   \fn int SalomePyQt::createView( const QString& type, bool visible = true, const int width = 0, const int height = 0 );
2855   \brief Create new view and activate it
2856   \param type viewer type
2857   \param visible
2858   \param width
2859   \param height
2860   \return integer identifier of created view (or -1 if view could not be created)
2861 */
2862
2863 class TCreateView: public SALOME_Event
2864 {
2865 public:
2866   typedef int TResult;
2867   TResult myResult;
2868   QString myType;
2869   bool myVisible;
2870   int myWidth;
2871   int myHeight;
2872   TCreateView( const QString& theType, bool visible, const int width, const int height )
2873     : myResult( -1 ),
2874       myType( theType ),
2875       myVisible(visible),
2876       myWidth(width),
2877       myHeight(height) {}
2878   virtual void Execute()
2879   {
2880     LightApp_Application* app  = getApplication();
2881     if ( app ) {
2882       SUIT_ViewManager* viewMgr = app->createViewManager( myType );
2883       if ( viewMgr ) {
2884         QWidget* wnd = viewMgr->getActiveView();
2885         myResult = viewMgr->getActiveView()->getId();
2886         if ( wnd ) {
2887           if ( !myVisible )
2888             wnd->setVisible(false);
2889           if ( !myVisible && myWidth == 0 && myHeight == 0 ) {
2890             myWidth = 1024;
2891             myHeight = 768;
2892           }
2893           if (myWidth > 0 && myHeight > 0) {
2894 #ifndef DISABLE_PLOT2DVIEWER
2895             Plot2d_ViewWindow* wnd2D = dynamic_cast<Plot2d_ViewWindow*>( wnd );
2896             if ( wnd2D ) wnd = wnd2D->getViewFrame();
2897 #endif // DISABLE_PLOT2DVIEWER
2898             wnd->setGeometry( 0, 0, myWidth, myHeight );
2899           }
2900         }
2901       }
2902     }
2903   }
2904 };
2905 int SalomePyQt::createView( const QString& type, bool visible, const int width, const int height )
2906 {
2907   int ret = ProcessEvent( new TCreateView( type, visible, width, height ) );
2908   QCoreApplication::processEvents();
2909   return ret;
2910 }
2911
2912 /*!
2913   \fn int SalomePyQt::createView( const QString& type, QWidget* w );
2914   \brief Create new view with custom widget embedded and activate it
2915   \param type viewer type
2916   \param w custom widget
2917   \return integer identifier of created view (or -1 if view could not be created)
2918 */
2919
2920 class TCreateViewWg: public SALOME_Event
2921 {
2922 public:
2923   typedef int TResult;
2924   TResult myResult;
2925   QString myType;
2926   QWidget* myWidget;
2927   TCreateViewWg( const QString& theType, QWidget* w )
2928     : myResult( -1 ),
2929       myType( theType ),
2930       myWidget( w ) {}
2931   virtual void Execute()
2932   {
2933     LightApp_Application* app  = getApplication();
2934     if ( app ) {
2935       SUIT_ViewManager* viewMgr = app->createViewManager( myType, myWidget );
2936       if ( viewMgr ) {
2937         SUIT_ViewWindow* wnd = viewMgr->getActiveView();
2938         if ( wnd )
2939           myResult = wnd->getId();
2940       }
2941     }
2942   }
2943 };
2944 int SalomePyQt::createView( const QString& type, QWidget* w )
2945 {
2946   int ret = ProcessEvent( new TCreateViewWg( type, w ) );
2947   QCoreApplication::processEvents();
2948   return ret;
2949 }
2950
2951 /*!
2952   \fn bool SalomePyQt::closeView( const int id );
2953   \brief Close view
2954   \param id window identifier
2955   \return \c true if operation is completed successfully and \c false otherwise
2956 */
2957
2958 class TCloseView: public SALOME_Event
2959 {
2960 public:
2961   typedef bool TResult;
2962   TResult myResult;
2963   int myWndId;
2964   TCloseView( const int id )
2965     : myResult( false ),
2966       myWndId( id ) {}
2967   virtual void Execute()
2968   {
2969     SUIT_ViewWindow* wnd = getWnd( myWndId );
2970     if ( wnd ) {
2971       SUIT_ViewManager* viewMgr = wnd->getViewManager();
2972       if ( viewMgr ) {
2973         wnd->close();
2974         myResult = true;
2975       }
2976     }
2977   }
2978 };
2979 bool SalomePyQt::closeView( const int id )
2980 {
2981   return ProcessEvent( new TCloseView( id ) );
2982 }
2983
2984 /*!
2985   \fn int SalomePyQt::cloneView( const int id );
2986   \brief Clone view (if this operation is supported for specified view type)
2987   \param id window identifier
2988   \return integer identifier of the cloned view or -1 or operation could not be performed
2989 */
2990
2991 class TCloneView: public SALOME_Event
2992 {
2993 public:
2994   typedef int TResult;
2995   TResult myResult;
2996   int myWndId;
2997   TCloneView( const int id )
2998     : myResult( -1 ),
2999       myWndId( id ) {}
3000   virtual void Execute()
3001   {
3002     SUIT_ViewWindow* wnd = getWnd( myWndId );
3003     if ( wnd ) {
3004       SUIT_ViewManager* viewMgr = wnd->getViewManager();
3005       if ( viewMgr ) {
3006 #ifndef DISABLE_OCCVIEWER
3007         if ( wnd->inherits( "OCCViewer_ViewWindow" ) ) {
3008           OCCViewer_ViewWindow* occView = (OCCViewer_ViewWindow*)( wnd );
3009           occView->onCloneView();
3010           wnd = viewMgr->getActiveView();
3011           if ( wnd )
3012             myResult = wnd->getId();
3013         }
3014 #endif // DISABLE_OCCVIEWER
3015 #ifndef DISABLE_PLOT2DVIEWER
3016         if ( wnd->inherits( "Plot2d_ViewWindow" ) ) {
3017           Plot2d_ViewManager* viewMgr2d = dynamic_cast<Plot2d_ViewManager*>( viewMgr );
3018           Plot2d_ViewWindow* srcWnd2d = dynamic_cast<Plot2d_ViewWindow*>( wnd );
3019           if ( viewMgr2d && srcWnd2d ) {
3020             Plot2d_ViewWindow* resWnd = viewMgr2d->cloneView( srcWnd2d );
3021             myResult = resWnd->getId();
3022           }
3023         }
3024 #endif // DISABLE_OCCVIEWER
3025       }
3026     }
3027   }
3028 };
3029 int SalomePyQt::cloneView( const int id )
3030 {
3031   return ProcessEvent( new TCloneView( id ) );
3032 }
3033
3034 /*!
3035   \fn bool SalomePyQt::setViewVisible( const int id, const bool visible )
3036   \brief Set view visibility.
3037   \param id window identifier
3038   \param visible new visiblity
3039 */
3040
3041 void SalomePyQt::setViewVisible( const int id, const bool visible )
3042 {
3043   class TEvent: public SALOME_Event
3044   {
3045     int myWndId;
3046     bool myVisible;
3047   public:
3048     TEvent( const int id, const bool visible )
3049       : myWndId( id ), myVisible( visible ) {}
3050     virtual void Execute()
3051     {
3052       SUIT_ViewWindow* wnd = getWnd( myWndId );
3053       if ( wnd ) wnd->setVisible( myVisible );
3054     }
3055   };
3056   ProcessVoidEvent( new TEvent( id, visible ) );
3057 }
3058
3059 /*!
3060   \fn bool SalomePyQt::isViewVisible( const int id );
3061   \brief Check whether view is visible ( i.e. it is on the top of the views stack)
3062   \param id window identifier
3063   \return \c true if view is visible and \c false otherwise
3064 */
3065
3066 class TIsViewVisible: public SALOME_Event
3067 {
3068 public:
3069   typedef bool TResult;
3070   TResult myResult;
3071   int myWndId;
3072   TIsViewVisible( const int id )
3073     : myResult( false ),
3074       myWndId( id ) {}
3075   virtual void Execute()
3076   {
3077     SUIT_ViewWindow* wnd = getWnd( myWndId );
3078     if ( wnd )
3079     {
3080       QWidget* p = wnd->parentWidget();
3081       myResult = ( p && p->isVisibleTo( p->parentWidget() ) );
3082     }
3083   }
3084 };
3085 bool SalomePyQt::isViewVisible( const int id )
3086 {
3087   return ProcessEvent( new TIsViewVisible( id ) );
3088 }
3089
3090 /*!
3091   \fn bool SalomePyQt::setViewClosable( const int id, const bool on );
3092   \brief Set / clear view's "closable" option. By default any view is closable
3093         (i.e. can be closed by the user).
3094   \param id window identifier
3095   \param on new "closable" option's value
3096 */
3097
3098 void SalomePyQt::setViewClosable( const int id, const bool on )
3099 {
3100   class TEvent: public SALOME_Event
3101   {
3102     int myWndId;
3103     bool myOn;
3104   public:
3105     TEvent( const int id, const bool on )
3106       : myWndId( id ), myOn( on ) {}
3107     virtual void Execute()
3108     {
3109       SUIT_ViewWindow* wnd = getWnd( myWndId );
3110       if ( wnd ) wnd->setClosable( myOn );
3111     }
3112   };
3113   ProcessVoidEvent( new TEvent( id, on ) );
3114 }
3115
3116 /*!
3117   \fn bool SalomePyQt::isViewClosable( const int id );
3118   \brief Check whether view is closable (i.e. can be closed by the user)
3119   \param id window identifier
3120   \return \c true if view is closable or \c false otherwise
3121 */
3122
3123 class TIsViewClosable: public SALOME_Event
3124 {
3125 public:
3126   typedef bool TResult;
3127   TResult myResult;
3128   int myWndId;
3129   TIsViewClosable( const int id )
3130     : myResult( true ),
3131       myWndId( id ) {}
3132   virtual void Execute()
3133   {
3134     SUIT_ViewWindow* wnd = getWnd( myWndId );
3135     if ( wnd )
3136       myResult = wnd->closable();
3137   }
3138 };
3139
3140 bool SalomePyQt::isViewClosable( const int id )
3141 {
3142   return ProcessEvent( new TIsViewClosable( id ) );
3143 }
3144
3145 /*!
3146   \fn bool SalomePyQt::groupAllViews();
3147   \brief Group all views to the single tab area
3148   \return \c true if operation is completed successfully and \c false otherwise
3149 */
3150
3151 class TGroupAllViews: public SALOME_Event
3152 {
3153 public:
3154   typedef bool TResult;
3155   TResult myResult;
3156   TGroupAllViews()
3157     : myResult( false ) {}
3158   virtual void Execute()
3159   {
3160     LightApp_Application* app  = getApplication();
3161     if ( app ) {
3162       STD_TabDesktop* tabDesk = dynamic_cast<STD_TabDesktop*>( app->desktop() );
3163       if ( tabDesk ) {
3164         QtxWorkstack* wStack = tabDesk->workstack();
3165         if ( wStack ) {
3166           wStack->stack();
3167           myResult = true;
3168         }
3169       }
3170     }
3171   }
3172 };
3173 bool SalomePyQt::groupAllViews()
3174 {
3175   return ProcessEvent( new TGroupAllViews() );
3176 }
3177
3178 /*!
3179   \fn bool SalomePyQt::splitView( const int id, const Orientation ori, const Action action );
3180   \brief Split tab area to which view with identifier belongs to
3181   \param id window identifier
3182   \param ori orientation of split operation
3183   \param action action to be performed
3184   \return \c true if operation is completed successfully \c false otherwise
3185 */
3186
3187 class TSplitView: public SALOME_Event
3188 {
3189 public:
3190   typedef bool TResult;
3191   TResult myResult;
3192   int myWndId;
3193   Orientation myOri;
3194   Action myAction;
3195   TSplitView( const int id,
3196               const Orientation ori,
3197               const Action action )
3198     : myResult( false ),
3199       myWndId( id ),
3200       myOri( ori ),
3201       myAction( action ) {}
3202   virtual void Execute()
3203   {
3204     SUIT_ViewWindow* wnd = getWnd( myWndId );
3205     if ( wnd ) {
3206       // activate view
3207       // wnd->setFocus(); ???
3208
3209       // split workstack
3210       if ( getApplication() ) {
3211         STD_TabDesktop* desk =
3212           dynamic_cast<STD_TabDesktop*>( getApplication()->desktop() );
3213         if ( desk ) {
3214           QtxWorkstack* wStack = desk->workstack();
3215           if ( wStack ) {
3216             Qt::Orientation qtOri =
3217               ( myOri == Horizontal ) ? Qt::Horizontal : Qt::Vertical;
3218
3219             QtxWorkstack::SplitType sType;
3220             if ( myAction == MoveWidget )
3221               sType = QtxWorkstack::SplitMove;
3222             else if ( myAction == LeaveWidget )
3223               sType = QtxWorkstack::SplitStay;
3224             else
3225               sType = QtxWorkstack::SplitAt;
3226
3227             wStack->Split( wnd, qtOri, sType );
3228             myResult = true;
3229           }
3230         }
3231       }
3232     }
3233   }
3234 };
3235 bool SalomePyQt::splitView( const int id, const Orientation ori, const Action action )
3236 {
3237   return ProcessEvent( new TSplitView( id, ori, action ) );
3238 }
3239
3240 /*!
3241   \fn bool SalomePyQt::moveView( const int id, const int id_to, const bool before );
3242   \brief Move view with the first identifier to the same area which
3243          another view with the second identifier belongs to
3244   \param id source window identifier
3245   \param id_to destination window identifier
3246   param before specifies whether the first viewt has to be moved before or after
3247         the second view
3248   \return \c true if operation is completed successfully and \c false otherwise
3249 */
3250
3251 class TMoveView: public SALOME_Event
3252 {
3253 public:
3254   typedef bool TResult;
3255   TResult myResult;
3256   int myWndId;
3257   int myWndToId;
3258   bool myIsBefore;
3259   TMoveView( const int id, const int id_to, const bool before )
3260     : myResult( false ),
3261     myWndId( id ),
3262     myWndToId( id_to ),
3263     myIsBefore( before ) {}
3264   virtual void Execute()
3265   {
3266     SUIT_ViewWindow* wnd = getWnd( myWndId );
3267     SUIT_ViewWindow* wnd_to = getWnd( myWndToId );
3268     if ( wnd && wnd_to ) {
3269       QtxWorkstack* wStack = dynamic_cast<STD_TabDesktop*>(
3270         getApplication()->desktop() )->workstack();
3271       if ( wStack )
3272         myResult = wStack->move( wnd, wnd_to, myIsBefore );
3273     }
3274   }
3275 };
3276 bool SalomePyQt::moveView( const int id, const int id_to, const bool before )
3277 {
3278   return ProcessEvent( new TMoveView( id, id_to, before ) );
3279 }
3280
3281 /*!
3282   \fn QList<int> SalomePyQt::neighbourViews( const int id );
3283   \brief Get list of views identifiers that belongs to the same area as
3284          specified view (excluding it)
3285   \param id window identifier
3286   \return list of views identifiers
3287 */
3288
3289 class TNeighbourViews: public SALOME_Event
3290 {
3291 public:
3292   typedef QList<int> TResult;
3293   TResult myResult;
3294   int myWndId;
3295   TNeighbourViews( const int id )
3296     : myWndId( id ) {}
3297   virtual void Execute()
3298   {
3299     myResult.clear();
3300     SUIT_ViewWindow* wnd = getWnd( myWndId );
3301     if ( wnd ) {
3302       QtxWorkstack* wStack = dynamic_cast<STD_TabDesktop*>(
3303         getApplication()->desktop() )->workstack();
3304       if ( wStack ) {
3305         QWidgetList wgList = wStack->windowList( wnd );
3306         QWidget* wg;
3307         foreach ( wg, wgList ) {
3308           SUIT_ViewWindow* tmpWnd = dynamic_cast<SUIT_ViewWindow*>( wg );
3309           if ( tmpWnd && tmpWnd != wnd )
3310             myResult.append( tmpWnd->getId() );
3311         }
3312       }
3313     }
3314   }
3315 };
3316 QList<int> SalomePyQt::neighbourViews( const int id )
3317 {
3318   return ProcessEvent( new TNeighbourViews( id ) );
3319 }
3320
3321
3322 /*!
3323   \fn void SalomePyQt::createRoot();
3324   \brief Initialize root data object.
3325
3326   Does nothing if root is already initialized.
3327 */
3328
3329 void SalomePyQt::createRoot()
3330 {
3331   class TEvent: public SALOME_Event
3332   {
3333   public:
3334     TEvent() {}
3335     virtual void Execute()
3336     {
3337       SALOME_PYQT_ModuleLight* module = dynamic_cast<SALOME_PYQT_ModuleLight*>( getActiveModule() );
3338       if ( module ) {
3339         SALOME_PYQT_DataModelLight* dm =
3340           dynamic_cast<SALOME_PYQT_DataModelLight*>( module->dataModel() );
3341         if ( dm )
3342           dm->getRoot();
3343       }
3344       else {
3345         if ( verbose() ) printf( "SalomePyQt.createRoot() function is not supported for the current module.\n" );
3346       }
3347     }
3348   };
3349   ProcessVoidEvent( new TEvent() );
3350 }
3351
3352 /*!
3353   \fn QString SalomePyQt::createObject( const QString& parent );
3354   \brief Create empty data object
3355   \param parent entry of parent data object
3356   \return entry of created data object
3357 */
3358
3359 class TCreateEmptyObjectEvent: public SALOME_Event
3360 {
3361 public:
3362   typedef QString TResult;
3363   TResult  myResult;
3364   QString  myParent;
3365   TCreateEmptyObjectEvent( const QString& parent )
3366     : myParent( parent ) {}
3367   virtual void Execute()
3368   {
3369     SALOME_PYQT_ModuleLight* module = dynamic_cast<SALOME_PYQT_ModuleLight*>( getActiveModule() );
3370     if ( module ) {
3371        myResult = module->createObject( myParent );
3372     }
3373     else {
3374       if ( verbose() ) printf( "SalomePyQt.createObject() function is not supported for the current module.\n" );
3375     }
3376   }
3377 };
3378 QString SalomePyQt::createObject( const QString& parent )
3379 {
3380   return ProcessEvent( new TCreateEmptyObjectEvent( parent ) );
3381 }
3382
3383 /*!
3384   \fn QString SalomePyQt::createObject( const QString& name, const QString& icon,
3385                                         const QString& tooltip,const QString& parent );
3386   \brief Create new data object with specified name, icon and tooltip
3387   \param name data object name
3388   \param icon data object icon
3389   \param toolTip data object tooltip
3390   \param parent entry of parent data object
3391   \return entry of created data object
3392 */
3393
3394 class TCreateObjectEvent: public SALOME_Event
3395 {
3396 public:
3397   typedef QString TResult;
3398   TResult myResult;
3399   QString myParent;
3400   QString myName;
3401   QString myIcon;
3402   QString myToolTip;
3403   TCreateObjectEvent( const QString& name,
3404                       const QString& icon,
3405                       const QString& tooltip,
3406                       const QString& parent )
3407     : myName( name ),
3408       myIcon( icon ),
3409       myToolTip( tooltip ),
3410       myParent( parent ) {}
3411   virtual void Execute()
3412   {
3413     SALOME_PYQT_ModuleLight* module = dynamic_cast<SALOME_PYQT_ModuleLight*>( getActiveModule() );
3414     if ( module ) {
3415       myResult = module->createObject( myName, myIcon, myToolTip, myParent );
3416     }
3417     else {
3418       if ( verbose() ) printf( "SalomePyQt.createObject() function is not supported for the current module.\n" );
3419     }
3420   }
3421 };
3422 QString SalomePyQt::createObject( const QString& name,
3423                                   const QString& icon,
3424                                   const QString& toolTip,
3425                                   const QString& parent )
3426 {
3427   return ProcessEvent( new TCreateObjectEvent( name, icon, toolTip, parent ) );
3428 }
3429
3430
3431 /*!
3432   \fn void SalomePyQt::setName( const QString& entry, const QString& name );
3433   \brief Set data object name
3434   \param entry data object entry
3435   \param name data object name
3436 */
3437 class TSetNameEvent: public SALOME_Event
3438 {
3439 public:
3440   QString myEntry;
3441   QString myName;
3442   TSetNameEvent( const QString& entry,
3443                  const QString& name )
3444   : myEntry( entry ),
3445     myName( name ) {}
3446   virtual void Execute()
3447   {
3448     SALOME_PYQT_ModuleLight* module = dynamic_cast<SALOME_PYQT_ModuleLight*>( getActiveModule() );
3449     if ( module ) {
3450       module->setName( myEntry, myName );
3451     }
3452     else {
3453       if ( verbose() ) printf( "SalomePyQt.setName() function is not supported for the current module.\n" );
3454     }
3455   }
3456 };
3457 void SalomePyQt::setName( const QString& entry, const QString& name )
3458 {
3459   ProcessVoidEvent( new TSetNameEvent( entry, name ) );
3460 }
3461
3462 /*!
3463   \fn void SalomePyQt::setIcon( const QString& entry, const QString& icon );
3464   \brief Set data object icon
3465   \param entry data object entry
3466   \param icon data object icon file name (icon is loaded from module resources)
3467 */
3468
3469 class TSetIconEvent: public SALOME_Event
3470 {
3471 public:
3472   QString myEntry;
3473   QString myIcon;
3474   TSetIconEvent( const QString& entry,
3475                  const QString& icon )
3476   : myEntry( entry ),
3477     myIcon( icon ) {}
3478   virtual void Execute()
3479   {
3480     SALOME_PYQT_ModuleLight* module = dynamic_cast<SALOME_PYQT_ModuleLight*>( getActiveModule() );
3481     if ( module ) {
3482       module->setIcon( myEntry, myIcon );
3483     }
3484     else {
3485       if ( verbose() ) printf( "SalomePyQt.setIcon() function is not supported for the current module.\n" );
3486     }
3487   }
3488 };
3489
3490 void SalomePyQt::setIcon( const QString& entry, const QString& icon )
3491 {
3492   ProcessVoidEvent( new TSetIconEvent( entry, icon ) );
3493 }
3494
3495 /*!
3496   \fn void SalomePyQt::setToolTip( const QString& entry, const QString& toolTip );
3497   \brief Set data object tooltip
3498   \param entry data object entry
3499   \param toolTip data object tooltip
3500 */
3501
3502 class TSetToolTipEvent: public SALOME_Event
3503 {
3504 public:
3505   QString myEntry;
3506   QString myToolTip;
3507   TSetToolTipEvent( const QString& entry,
3508                     const QString& toolTip )
3509     : myEntry( entry ),
3510       myToolTip( toolTip ) {}
3511   virtual void Execute()
3512   {
3513     SALOME_PYQT_ModuleLight* module = dynamic_cast<SALOME_PYQT_ModuleLight*>( getActiveModule() );
3514     if ( module ) {
3515       module->setToolTip( myEntry, myToolTip );
3516     }
3517     else {
3518       if ( verbose() ) printf( "SalomePyQt.setToolTip() function is not supported for the current module.\n" );
3519     }
3520   }
3521 };
3522 void SalomePyQt::setToolTip( const QString& entry, const QString& toolTip )
3523 {
3524   ProcessVoidEvent( new TSetToolTipEvent( entry, toolTip ) );
3525 }
3526
3527 /*!
3528   \fn void SalomePyQt::setReference( const QString& entry, const QString& refEntry );
3529   \brief Set reference to another data object
3530   \param entry data object entry
3531   \param refEntry referenced data object entry
3532 */
3533
3534 class TSetRefEvent: public SALOME_Event
3535 {
3536 public:
3537   QString myEntry;
3538   QString myRefEntry;
3539   TSetRefEvent( const QString& entry,
3540                 const QString& refEntry )
3541     : myEntry( entry ),
3542       myRefEntry( refEntry ) {}
3543   virtual void Execute()
3544   {
3545     SALOME_PYQT_ModuleLight* module = dynamic_cast<SALOME_PYQT_ModuleLight*>( getActiveModule() );
3546     if ( module ) {
3547       module->setReference( myEntry, myRefEntry );
3548     }
3549     else {
3550       if ( verbose() ) printf( "SalomePyQt.setReference() function is not supported for the current module.\n" );
3551     }
3552   }
3553 };
3554 void SalomePyQt::setReference( const QString& entry, const QString& refEntry )
3555 {
3556   ProcessVoidEvent( new TSetRefEvent( entry, refEntry ) );
3557 }
3558
3559 /*!
3560   \fn void SalomePyQt::setColor( const QString& entry, const QColor& color );
3561   \brief Set data object color
3562   \param entry data object entry
3563   \param color data object color
3564  */
3565
3566 class TSetColorEvent: public SALOME_Event
3567 {
3568 public:
3569   QString myEntry;
3570   QColor  myColor;
3571   TSetColorEvent( const QString& entry,
3572                   const QColor& color )
3573     : myEntry( entry ),
3574       myColor( color ) {}
3575   virtual void Execute()
3576   {
3577     SALOME_PYQT_ModuleLight* module = dynamic_cast<SALOME_PYQT_ModuleLight*>( getActiveModule() );
3578     if ( module ) {
3579       module->setColor( myEntry, myColor );
3580     }
3581     else {
3582       if ( verbose() ) printf( "SalomePyQt.setColor() function is not supported for the current module.\n" );
3583     }
3584   }
3585 };
3586 void SalomePyQt::setColor( const QString& entry, const QColor& color )
3587 {
3588   ProcessVoidEvent( new TSetColorEvent( entry, color ) );
3589 }
3590
3591 /*!
3592   \fn QString SalomePyQt::getName( const QString& entry );
3593   \brief Get data object name
3594   \param entry data object entry
3595   \return data object name
3596 */
3597
3598 class TGetNameEvent: public SALOME_Event
3599 {
3600 public:
3601   typedef QString TResult;
3602   TResult myResult;
3603   QString myEntry;
3604   TGetNameEvent( const QString& entry )
3605     : myEntry( entry ) {}
3606   virtual void Execute()
3607   {
3608     SALOME_PYQT_ModuleLight* module = dynamic_cast<SALOME_PYQT_ModuleLight*>( getActiveModule() );
3609     if ( module ) {
3610       myResult = module->getName( myEntry );
3611     }
3612     else {
3613       if ( verbose() ) printf( "SalomePyQt.getName() function is not supported for the current module.\n" );
3614     }
3615   }
3616 };
3617 QString SalomePyQt::getName( const QString& entry )
3618 {
3619   return ProcessEvent( new TGetNameEvent( entry ) );
3620 }
3621
3622 /*!
3623   \fn QString SalomePyQt::getToolTip( const QString& entry );
3624   \brief Get data object tooltip
3625   \param entry data object entry
3626   \return data object tooltip
3627 */
3628
3629 class TGetToolTipEvent: public SALOME_Event
3630 {
3631 public:
3632   typedef QString TResult;
3633   TResult myResult;
3634   QString myEntry;
3635   TGetToolTipEvent( const QString& entry )
3636   : myEntry( entry ) {}
3637   virtual void Execute()
3638   {
3639     SALOME_PYQT_ModuleLight* module = dynamic_cast<SALOME_PYQT_ModuleLight*>( getActiveModule() );
3640     if ( module ) {
3641       myResult = module->getToolTip( myEntry );
3642     }
3643     else {
3644       if ( verbose() ) printf( "SalomePyQt.getToolTip() function is not supported for the current module.\n" );
3645     }
3646   }
3647 };
3648 QString SalomePyQt::getToolTip( const QString& entry )
3649 {
3650   return ProcessEvent( new TGetToolTipEvent( entry ) );
3651 }
3652
3653 /*
3654   \fn QString SalomePyQt::getReference( const QString& entry );
3655   \brief Get entry of the referenced object (if there's any)
3656   \param entry data object entry
3657   \return referenced data object entry
3658 */
3659
3660 class TGetRefEvent: public SALOME_Event
3661 {
3662 public:
3663   typedef QString TResult;
3664   TResult myResult;
3665   QString myEntry;
3666   TGetRefEvent( const QString& entry )
3667   : myEntry( entry ) {}
3668   virtual void Execute()
3669   {
3670     SALOME_PYQT_ModuleLight* module = dynamic_cast<SALOME_PYQT_ModuleLight*>( getActiveModule() );
3671     if ( module ) {
3672       myResult = module->getReference( myEntry );
3673     }
3674     else {
3675       if ( verbose() ) printf( "SalomePyQt.getReference() function is not supported for the current module.\n" );
3676     }
3677   }
3678 };
3679 QString SalomePyQt::getReference( const QString& entry )
3680 {
3681   return ProcessEvent( new TGetRefEvent( entry ) );
3682 }
3683
3684 /*!
3685   \fn QColor SalomePyQt::getColor( const QString& entry );
3686   \brief Get data object color
3687   \param entry data object entry
3688   \return data object color
3689 */
3690
3691 class TGetColorEvent: public SALOME_Event
3692 {
3693 public:
3694   typedef QColor TResult;
3695   TResult myResult;
3696   QString myEntry;
3697   TGetColorEvent( const QString& entry )
3698   : myEntry( entry ) {}
3699   virtual void Execute()
3700   {
3701     SALOME_PYQT_ModuleLight* module = dynamic_cast<SALOME_PYQT_ModuleLight*>( getActiveModule() );
3702     if ( module ) {
3703       myResult = module->getColor( myEntry );
3704     }
3705     else {
3706       if ( verbose() ) printf( "SalomePyQt.getColor() function is not supported for the current module.\n" );
3707     }
3708   }
3709 };
3710 QColor SalomePyQt::getColor( const QString& entry )
3711 {
3712   return ProcessEvent( new TGetColorEvent( entry ) );
3713 }
3714
3715 /*!
3716   \fn void SalomePyQt::removeChildren( const QString& entry );
3717   \brief Remove all child data objects from specified data object
3718   \param entry data object entry
3719 */
3720
3721 class TRemoveChildEvent: public SALOME_Event
3722 {
3723 public:
3724   QString myEntry;
3725   TRemoveChildEvent( const QString& entry )
3726   : myEntry( entry ) {}
3727   virtual void Execute()
3728   {
3729     SALOME_PYQT_ModuleLight* module = dynamic_cast<SALOME_PYQT_ModuleLight*>( getActiveModule() );
3730     if ( module ) {
3731       module->removeChildren( myEntry );
3732     }
3733     else {
3734       if ( verbose() ) printf( "SalomePyQt.removeChildren() function is not supported for the current module.\n" );
3735     }
3736   }
3737 };
3738 void SalomePyQt::removeChildren( const QString& entry )
3739 {
3740   ProcessVoidEvent( new TRemoveChildEvent( entry ) );
3741 }
3742 void SalomePyQt::removeChild( const QString& entry )
3743 {
3744   if ( verbose() ) printf( "SalomePyQt.removeChild() function is obsolete. Use SalomePyQt.removeChildren() instead." );
3745   removeChildren( entry );
3746 }
3747
3748 /*!
3749   \fn void SalomePyQt::removeObject( const QString& entry );
3750   \brief Remove object by entry
3751   \param entry data object entry
3752 */
3753
3754 class TRemoveObjectEvent: public SALOME_Event
3755 {
3756 public:
3757   QString myEntry;
3758
3759   TRemoveObjectEvent( const QString& entry )
3760   : myEntry( entry ) {}
3761   virtual void Execute()
3762   {
3763     SALOME_PYQT_ModuleLight* module = dynamic_cast<SALOME_PYQT_ModuleLight*>( getActiveModule() );
3764     if ( module ) {
3765       module->removeObject( myEntry );
3766     }
3767     else {
3768       if ( verbose() ) printf( "SalomePyQt.removeObject() function is not supported for the current module.\n" );
3769     }
3770   }
3771 };
3772 void SalomePyQt::removeObject( const QString& entry )
3773 {
3774   ProcessVoidEvent( new TRemoveObjectEvent( entry ) );
3775 }
3776
3777 /*!
3778   \fn QStringList SalomePyQt::getChildren( const QString& entry, const bool recursive );
3779   \brief Get entries of all child data objects of specified data object
3780   \param entry data object entry
3781   \param recursive \c true for recursive processing
3782 */
3783
3784 class TGetChildrenEvent: public SALOME_Event
3785 {
3786 public:
3787   typedef QStringList TResult;
3788   TResult myResult;
3789   QString myEntry;
3790   bool    myRecursive;
3791   TGetChildrenEvent( const QString& entry, const bool recursive )
3792     : myEntry( entry ),
3793       myRecursive( recursive ) {}
3794   virtual void Execute()
3795   {
3796     SALOME_PYQT_ModuleLight* module = dynamic_cast<SALOME_PYQT_ModuleLight*>( getActiveModule() );
3797     if ( module ) {
3798       myResult = module->getChildren( myEntry, myRecursive );
3799     }
3800     else {
3801       if ( verbose() ) printf( "SalomePyQt.getChildren() function is not supported for the current module.\n" );
3802     }
3803   }
3804 };
3805 QStringList SalomePyQt::getChildren( const QString& entry, const bool recursive )
3806 {
3807   return ProcessEvent( new TGetChildrenEvent( entry, recursive ) );
3808 }
3809
3810 #ifndef DISABLE_PLOT2DVIEWER
3811 // Next set of methods relates to the Plot2d viewer functionality
3812
3813 /*!
3814   \fn void SalomePyQt::displayCurve( const int id, Plot2d_Curve* theCurve )
3815   \brief Display theCurve in view
3816   \param id window identifier
3817   \param theCurve curve to display
3818 */
3819
3820 class TDisplayCurve: public SALOME_Event
3821 {
3822 public:
3823   int myWndId;
3824   Plot2d_Curve* myCurve;
3825   TDisplayCurve( const int id, Plot2d_Curve* theCurve ) : myWndId( id ), myCurve( theCurve ) {}
3826   virtual void Execute() {
3827     Plot2d_ViewWindow* wnd = dynamic_cast<Plot2d_ViewWindow*>( getWnd( myWndId ) );
3828     if ( wnd )
3829       wnd->getViewFrame()->displayCurve( myCurve );
3830   }
3831 };
3832 void SalomePyQt::displayCurve( const int id, Plot2d_Curve* theCurve )
3833 {
3834   ProcessVoidEvent( new TDisplayCurve( id, theCurve ) );
3835 }
3836
3837 /*!
3838   \fn void SalomePyQt::eraseCurve( const int id, Plot2d_Curve* theCurve )
3839   \brief Erase theCurve in view
3840   \param id window identifier
3841   \param theCurve curve to erase
3842 */
3843
3844 class TEraseCurve: public SALOME_Event
3845 {
3846 public:
3847   int myWndId;
3848   Plot2d_Curve* myCurve;
3849   TEraseCurve( const int id, Plot2d_Curve* theCurve ) : myWndId( id ), myCurve( theCurve ) {}
3850   virtual void Execute() {
3851     Plot2d_ViewWindow* wnd = dynamic_cast<Plot2d_ViewWindow*>( getWnd( myWndId ) );
3852     wnd->getViewFrame()->eraseCurve( myCurve );
3853   }
3854 };
3855 void SalomePyQt::eraseCurve( const int id, Plot2d_Curve* theCurve )
3856 {
3857   ProcessVoidEvent( new TEraseCurve( id, theCurve ) );
3858 }
3859
3860 /*!
3861   \fn void SalomePyQt::deleteCurve( Plot2d_Curve* theCurve )
3862   \brief Delete theCurve from all views
3863   \param theCurve curve to delete
3864 */
3865
3866 class TDeleteCurve: public SALOME_Event
3867 {
3868 public:
3869   Plot2d_Curve* myCurve;
3870   TDeleteCurve( Plot2d_Curve* theCurve ) : myCurve( theCurve ) {}
3871   virtual void Execute() {
3872     LightApp_Application* app  = getApplication();
3873     if ( app ) {
3874       STD_TabDesktop* tabDesk = dynamic_cast<STD_TabDesktop*>( app->desktop() );
3875       if ( tabDesk ) {
3876         QList<SUIT_ViewWindow*> wndlist = tabDesk->windows();
3877         SUIT_ViewWindow* wnd;
3878         foreach ( wnd, wndlist ) {
3879           Plot2d_ViewWindow* aP2d = dynamic_cast<Plot2d_ViewWindow*>( wnd );
3880           if ( aP2d )
3881             aP2d->getViewFrame()->eraseObject( myCurve );
3882         }
3883       }
3884     }
3885   }
3886 };
3887 void SalomePyQt::eraseCurve( Plot2d_Curve* theCurve )
3888 {
3889   ProcessVoidEvent( new TDeleteCurve( theCurve ) );
3890 }
3891
3892 /*!
3893   \brief updateCurves (repaint) curves in view window.
3894 */
3895 void SalomePyQt::updateCurves( const int id )
3896 {
3897   class TEvent: public SALOME_Event
3898   {
3899   public:
3900     int myWndId;
3901     TEvent( const int id ) : myWndId( id ) {}
3902     virtual void Execute()
3903     {
3904       Plot2d_ViewWindow* wnd = dynamic_cast<Plot2d_ViewWindow*>( getWnd( myWndId ) );
3905       if ( wnd )
3906         wnd->getViewFrame()->DisplayAll();
3907     }
3908   };
3909   ProcessVoidEvent( new TEvent( id ) );
3910 }
3911
3912 /*!
3913   \fn QString SalomePyQt::getPlot2dTitle( const int id, ObjectType type = MainTitle )
3914   \brief Get title of corresponding type
3915   \param id window identifier
3916   \param type is type of title
3917   \return title of corresponding type
3918 */
3919
3920 class TGetPlot2dTitle: public SALOME_Event
3921 {
3922 public:
3923   typedef QString TResult;
3924   TResult myResult;
3925   int myWndId;
3926   ObjectType myType;
3927   TGetPlot2dTitle(const int id, ObjectType type) :
3928     myWndId( id ),
3929     myType( type ) {}
3930   virtual void Execute() {
3931     Plot2d_ViewWindow* wnd = dynamic_cast<Plot2d_ViewWindow*>( getWnd( myWndId ) );
3932     if ( wnd )
3933       myResult = wnd->getViewFrame()->getTitle( (Plot2d_ViewFrame::ObjectType)myType );
3934   }
3935 };
3936 QString SalomePyQt::getPlot2dTitle( const int id, ObjectType type )
3937 {
3938   return ProcessEvent( new TGetPlot2dTitle( id, type ) );
3939 }
3940
3941
3942 /*!
3943   \fn void SalomePyQt::setPlot2dTitle( const int id, const QString& title, ObjectType type = MainTitle, bool show = true )
3944   \brief Set title of corresponding type
3945   \param id window identifier
3946   \param title
3947   \param type is type of title
3948   \param show
3949 */
3950
3951 class TSetPlot2dTitle: public SALOME_Event
3952 {
3953 public:
3954   int myWndId;
3955   Plot2d_Curve* myCurve;
3956   QString myTitle;
3957   ObjectType myType;
3958   bool myShow;
3959   TSetPlot2dTitle( const int id, const QString& title, ObjectType type, bool show ) :
3960     myWndId( id ),
3961     myTitle( title ),
3962     myType( type ),
3963     myShow( show ) {}
3964   virtual void Execute() {
3965     Plot2d_ViewWindow* wnd = dynamic_cast<Plot2d_ViewWindow*>( getWnd( myWndId ) );
3966     wnd->getViewFrame()->setTitle( myShow, myTitle, (Plot2d_ViewFrame::ObjectType)myType, false );
3967   }
3968 };
3969 void SalomePyQt::setPlot2dTitle( const int id, const QString& title, ObjectType type, bool show )
3970 {
3971   ProcessVoidEvent( new TSetPlot2dTitle( id, title, type, show ) );
3972 }
3973
3974 /*!
3975   \fn QList<int> SalomePyQt::getPlot2dFitRangeByCurves( const int id )
3976   \brief Get list of Plot2d view ranges
3977   \param id window identifier
3978   \return list of view ranges (XMin, XMax, YMin, YMax)
3979 */
3980
3981 class TFitRangeByCurves: public SALOME_Event
3982 {
3983 public:
3984   typedef QList<double> TResult;
3985   TResult myResult;
3986   int myWndId;
3987   TFitRangeByCurves( const int id )
3988     : myWndId( id ) {}
3989   virtual void Execute()
3990   {
3991     myResult.clear();
3992     Plot2d_ViewWindow* wnd = dynamic_cast<Plot2d_ViewWindow*>( getWnd( myWndId ) );
3993     if ( wnd ) {
3994       double XMin, XMax, YMin, YMax, Y2Min, Y2Max;
3995       wnd->getViewFrame()->getFitRangeByCurves( XMin, XMax, YMin, YMax, Y2Min, Y2Max );
3996       myResult.append( XMin );
3997       myResult.append( XMax );
3998       myResult.append( YMin );
3999       myResult.append( YMax );
4000     }
4001   }
4002 };
4003 QList<double> SalomePyQt::getPlot2dFitRangeByCurves( const int id )
4004 {
4005   return ProcessEvent( new TFitRangeByCurves( id ) );
4006 }
4007
4008 /*!
4009   \fn QList<int> SalomePyQt::getPlot2dFitRangeCurrent( const int id )
4010   \brief Get list of current Plot2d view ranges
4011   \param id window identifier
4012   \return list of view ranges (XMin, XMax, YMin, YMax)
4013 */
4014
4015 class TFitRangeCurrent: public SALOME_Event
4016 {
4017 public:
4018   typedef QList<double> TResult;
4019   TResult myResult;
4020   int myWndId;
4021   TFitRangeCurrent( const int id )
4022     : myWndId( id ) {}
4023   virtual void Execute()
4024   {
4025     myResult.clear();
4026     Plot2d_ViewWindow* wnd = dynamic_cast<Plot2d_ViewWindow*>( getWnd( myWndId ) );
4027     if ( wnd ) {
4028       double XMin, XMax, YMin, YMax, Y2Min, Y2Max;
4029       wnd->getViewFrame()->getFitRanges( XMin, XMax, YMin, YMax, Y2Min, Y2Max );
4030       myResult.append( XMin );
4031       myResult.append( XMax );
4032       myResult.append( YMin );
4033       myResult.append( YMax );
4034     }
4035   }
4036 };
4037 QList<double> SalomePyQt::getPlot2dFitRangeCurrent( const int id )
4038 {
4039   return ProcessEvent( new TFitRangeCurrent( id ) );
4040 }
4041
4042 /*!
4043   \fn void SalomePyQt::setPlot2dFitRange( const int id, const double XMin, const double XMax, const double YMin, const double YMax )
4044   \brief Set range of Plot2d view
4045   \param id window identifier
4046   \param XMin
4047   \param XMax
4048   \param YMin
4049   \param YMax
4050 */
4051
4052 class TPlot2dFitRange: public SALOME_Event
4053 {
4054 public:
4055   int myWndId;
4056   double myXMin;
4057   double myXMax;
4058   double myYMin;
4059   double myYMax;
4060   TPlot2dFitRange( const int id, const double XMin, const double XMax, const double YMin, const double YMax ) :
4061     myWndId( id ),
4062     myXMin( XMin ),
4063     myXMax( XMax ),
4064     myYMin( YMin ),
4065     myYMax( YMax ) {}
4066   virtual void Execute() {
4067     Plot2d_ViewWindow* wnd = dynamic_cast<Plot2d_ViewWindow*>( getWnd( myWndId ) );
4068     if ( wnd )
4069       wnd->getViewFrame()->fitData( 0, myXMin, myXMax, myYMin, myYMax );
4070   }
4071 };
4072 void SalomePyQt::setPlot2dFitRange( const int id, const double XMin, const double XMax, const double YMin, const double YMax )
4073 {
4074   ProcessVoidEvent( new TPlot2dFitRange( id, XMin, XMax, YMin, YMax ) );
4075 }
4076
4077 // End of methods related to the Plot2d viewer functionality
4078 #endif // DISABLE_PLOT2DVIEWER
4079
4080 /*!
4081   \brief Process Qt event loop
4082 */
4083 void SalomePyQt::processEvents()
4084 {
4085   QCoreApplication::processEvents();
4086 }
4087
4088 /*!
4089   \brief Set visibility state for given object
4090   \param theEntry study ID of the object
4091   \param theState visibility state
4092 */
4093 void SalomePyQt::setVisibilityState( const QString& theEntry, VisibilityState theState )
4094 {
4095   class TEvent: public SALOME_Event
4096   {
4097     QString myEntry;
4098     int myState;
4099   public:
4100     TEvent( const QString& theEntry, int theState ):
4101       myEntry( theEntry ), myState( theState ) {}
4102     virtual void Execute()
4103     {
4104       LightApp_Study* aStudy = getActiveStudy();
4105       if ( !aStudy )
4106         return;
4107       aStudy->setVisibilityState( myEntry, (Qtx::VisibilityState)myState );
4108     }
4109   };
4110   ProcessVoidEvent( new TEvent( theEntry, theState ) );
4111 }
4112
4113 /*!
4114   \fn VisibilityState SalomePyQt::getVisibilityState( const QString& theEntry )
4115   \brief Get visibility state for given object
4116   \param theEntry study ID of the object
4117   \return visibility state
4118 */
4119
4120 class TGetVisibilityStateEvent: public SALOME_Event
4121 {
4122 public:
4123   typedef int TResult;
4124   TResult myResult;
4125   QString myEntry;
4126   TGetVisibilityStateEvent( const QString& theEntry ) : myResult( 0 ), myEntry( theEntry ) {}
4127   virtual void Execute()
4128   {
4129     LightApp_Study* aStudy = getActiveStudy();
4130     if ( aStudy )
4131       myResult = aStudy->visibilityState( myEntry );
4132   }
4133 };
4134 VisibilityState SalomePyQt::getVisibilityState( const QString& theEntry )
4135 {
4136   return (VisibilityState) ProcessEvent( new TGetVisibilityStateEvent( theEntry ) );
4137 }
4138
4139 /*!
4140   \brief Set position of given object in the tree
4141   \param theEntry study ID of the object
4142   \param thePos position
4143 */
4144 void SalomePyQt::setObjectPosition( const QString& theEntry, int thePos )
4145 {
4146   class TEvent: public SALOME_Event
4147   {
4148     QString myEntry;
4149     int myPos;
4150   public:
4151     TEvent( const QString& theEntry, int thePos ):
4152       myEntry( theEntry ), myPos( thePos ) {}
4153     virtual void Execute()
4154     {
4155       SALOME_PYQT_ModuleLight* module = dynamic_cast<SALOME_PYQT_ModuleLight*>( getActiveModule() );
4156       if ( module )
4157         module->setObjectPosition( myEntry, myPos );
4158     }
4159   };
4160   ProcessVoidEvent( new TEvent( theEntry, thePos ) );
4161 }
4162
4163 /*!
4164   \fn int SalomePyQt::getObjectPosition( const QString& theEntry )
4165   \brief Get position of given object in the tree
4166   \param theEntry study ID of the object
4167   \return position
4168 */
4169
4170 class TGetObjectPositionEvent: public SALOME_Event
4171 {
4172 public:
4173   typedef int TResult;
4174   TResult myResult;
4175   QString myEntry;
4176   TGetObjectPositionEvent( const QString& theEntry ) : myResult( 0 ), myEntry( theEntry ) {}
4177   virtual void Execute()
4178   {
4179     SALOME_PYQT_ModuleLight* module = dynamic_cast<SALOME_PYQT_ModuleLight*>( getActiveModule() );
4180     if ( module )
4181       myResult = module->getObjectPosition( myEntry );
4182   }
4183 };
4184 int SalomePyQt::getObjectPosition( const QString& theEntry )
4185 {
4186   return ProcessEvent( new TGetObjectPositionEvent( theEntry ) );
4187 }
4188
4189 /*!
4190   \brief Start recordind a log of Python commands from embedded console
4191   \param theFileName output lof file name
4192 */
4193 void SalomePyQt::startPyLog( const QString& theFileName )
4194 {
4195   class TEvent: public SALOME_Event
4196   {
4197     QString myFileName;
4198   public:
4199     TEvent( const QString& theFileName ):
4200       myFileName( theFileName ) {}
4201     virtual void Execute()
4202     {
4203       if ( getApplication() ) {
4204         PyConsole_Console* pyConsole = getApplication()->pythonConsole( false );
4205         if ( pyConsole ) pyConsole->startLog( myFileName );
4206       }
4207     }
4208   };
4209   ProcessVoidEvent( new TEvent( theFileName ) );
4210 }
4211
4212 /*!
4213   \brief Stop recordind a log of Python commands from embedded console
4214 */
4215 void SalomePyQt::stopPyLog()
4216 {
4217   class TEvent: public SALOME_Event
4218   {
4219   public:
4220     TEvent() {}
4221     virtual void Execute()
4222     {
4223       if ( getApplication() ) {
4224         PyConsole_Console* pyConsole = getApplication()->pythonConsole( false );
4225         if ( pyConsole ) pyConsole->stopLog();
4226       }
4227     }
4228   };
4229   ProcessVoidEvent( new TEvent() );
4230 }