src/SALOME_PYQT/SALOME_PYQT_GUI/SALOME_PYQT_Module.cxx

   1 //=============================================================================
   2 // File      : SALOME_PYQT_Module.cxx
   3 // Created   : 25/04/05
   4 // Author    : Vadim SANDLER
   5 // Project   : SALOME
   6 // Copyright : 2003-2005 CEA/DEN, EDF R&D
   7 // $Header   : $
   8 //=============================================================================
   9
  10 #include "SALOME_PYQT_Module.h"
  11
  12 #include "PyInterp_Dispatcher.h"
  13 #include "SUIT_ResourceMgr.h"
  14 #include "STD_MDIDesktop.h"
  15 #include "STD_TabDesktop.h"
  16 #include "SalomeApp_Application.h"
  17 #include "SalomeApp_Study.h"
  18
  19 #include "QtxWorkstack.h"
  20 #include <SALOME_LifeCycleCORBA.hxx>
  21 #include <Container_init_python.hxx>
  22
  23 #include <qfile.h>
  24 #include <qdom.h>
  25 #include <qworkspace.h>
  26 #include <qpopupmenu.h>
  27
  28 #include "SALOME_PYQT_SipDefs.h"
  29 #if defined(SIP_VERS_v4_old) || defined(SIP_VERS_v4_new)
  30 #include "sipAPISalomePyQtGUI.h"
  31 #else
  32 #include "sipSalomePyQtGUIDeclSalomePyQtGUI.h"
  33 #endif
  34
  35 #include <sipqtQWidget.h>
  36 #include <sipqtQPopupMenu.h>
  37
  38 #include <CORBA.h>
  39
  40 using namespace std;
  41
  42 ///////////////////////////////////////////////////////////////////////////////
  43 // Default name of the module, replaced at the moment of module creation
  44 #define __DEFAULT_NAME__ "SALOME_PYQT_Module"
  45
  46 ///////////////////////////////////////////////////////////////////////////////
  47 // If __CALL_OLD_METHODS__ macro is not defined the invoking of obsolete Python
  48 // module's methods like setSetting(), definePopup(), etc. is blocked.
  49 // This macro is defined by default (in Makefile)
  50 #ifdef __CALL_OLD_METHODS__
  51 const bool IsCallOldMethods = true;
  52 #else
  53 const bool IsCallOldMethods = false;
  54 #endif
  55
  56 ///////////////////////////////////////////////////////////////////////////////
  57 // NB: Python requests.
  58 // General rule for Python requests created by SALOME_PYQT_Module:
  59 // all requests should be executed SYNCHRONOUSLY within the main GUI thread.
  60 // However, it is obligatory that ANY Python call is wrapped with a request object,
  61 // so that ALL Python API calls are serialized with PyInterp_Dispatcher.
  62 ///////////////////////////////////////////////////////////////////////////////
  63
  64 //=============================================================================
  65 // The class for parsing of the XML resource files.
  66 // Used for backward compatibility with existing Python modules.
  67 //=============================================================================
  68 class SALOME_PYQT_XmlHandler
  69 {
  70 public:
  71   SALOME_PYQT_XmlHandler( SALOME_PYQT_Module* module, const QString& fileName );
  72   void createActions();
  73   void createPopup  ( QPopupMenu*    menu,
  74                       const QString& context,
  75                       const QString& parent,
  76                       const QString& object );
  77
  78 protected:
  79   void createToolBar   ( QDomNode& parentNode );
  80   void createMenu      ( QDomNode& parentNode,
  81                          const int parentMenuId = -1 );
  82
  83   void insertPopupItems( QDomNode&   parentNode,
  84                          QPopupMenu* menu );
  85
  86 private:
  87   SALOME_PYQT_Module* myModule;
  88   QDomDocument        myDoc;
  89 };
  90
  91 //=============================================================================
  92 // SALOME_PYQT_Module class implementation (implements CAM_Module API for
  93 // all Python-based SALOME module
  94 //=============================================================================
  95
  96 // While the SalomePyQtGUI library is not imported in Python it's initialization function
  97 // should be called manually (and only once) in order to initialize global sip data
  98 // and to get C API from sip : sipBuildResult for example
  99 #if defined(SIP_STATIC_MODULE)
 100 extern "C" void initSalomePyQtGUI();
 101 #else
 102 PyMODINIT_FUNC initSalomePyQtGUI();
 103 #endif
 104
 105 /*!
 106  * This function creates an instance of SALOME_PYQT_Module object by request
 107  * of and application object when the module is loaded.
 108  */
 109 extern "C" {
 110   SALOME_PYQT_EXPORT CAM_Module* createModule() {
 111     static bool alreadyInitialized = false;
 112     if ( !alreadyInitialized ) {
 113       // call only once (see above) !
 114       PyEval_RestoreThread( KERNEL_PYTHON::_gtstate );
 115       initSalomePyQtGUI();
 116       PyEval_ReleaseThread( KERNEL_PYTHON::_gtstate );
 117       alreadyInitialized = !alreadyInitialized;
 118     }
 119     return new SALOME_PYQT_Module();
 120   }
 121 }
 122
 123 /*!
 124  * Static variables definition
 125  */
 126 SALOME_PYQT_Module::InterpMap SALOME_PYQT_Module::myInterpMap;
 127 SALOME_PYQT_Module* SALOME_PYQT_Module::myInitModule = 0;
 128
 129 /*!
 130  * Little trick : provide an access to being activated Python module from outside;
 131  * needed by the SalomePyQt library :(
 132 */
 133 SALOME_PYQT_Module* SALOME_PYQT_Module::getInitModule()
 134 {
 135   return myInitModule;
 136 }
 137
 138 /*!
 139  * Constructor
 140  */
 141 SALOME_PYQT_Module::SALOME_PYQT_Module() :
 142        SalomeApp_Module( __DEFAULT_NAME__ ), myModule( 0 ), myXmlHandler ( 0 )
 143 {
 144   myMenuActionList.setAutoDelete( false );
 145   myPopupActionList.setAutoDelete( false );
 146   myToolbarActionList.setAutoDelete( false );
 147 }
 148
 149 /*!
 150  * Destructor
 151  */
 152 SALOME_PYQT_Module::~SALOME_PYQT_Module()
 153 {
 154   myMenuActionList.clear();
 155   myPopupActionList.clear();
 156   myToolbarActionList.clear();
 157   if ( myXmlHandler )
 158     delete myXmlHandler;
 159 }
 160
 161 /*!
 162  * Initialization of the module.
 163  * Inherited from CAM_Module.
 164  *
 165  * This method is used for creation of the menus, toolbars and other staff.
 166  * There are two ways:
 167  * - for obsolete modules this method first tries to read <module>_<language>.xml
 168  *   resource file which contains a menu, toolbars and popup menus description.
 169  * - new modules can create menus by by calling the corresponding methods of SalomePyQt
 170  *   Python API in the Python module's initialize() method which is called from here.
 171  * NOTE: if postponed modules loading is not used, the active study might be not defined
 172  * yet at this stage, so initialize() method should not perform any study-based initialization.
 173  */
 174 void SALOME_PYQT_Module::initialize( CAM_Application* app )
 175 {
 176   SalomeApp_Module::initialize( app );
 177
 178   // Try to get XML resource file name
 179   SUIT_ResourceMgr* aResMgr = getApp()->resourceMgr();
 180   QString aLang = aResMgr->stringValue( "language", "language", QString::null );
 181   if ( aLang.isEmpty() ) aLang = QString( "en" );
 182   QString aName = name( "" );
 183   QString aFileName = aName + "_" + aLang + ".xml";
 184   aFileName = aResMgr->path( "resources", aName, aFileName );
 185
 186   // parse XML file if it is found and create actions
 187   if ( !myXmlHandler && !aFileName.isEmpty() ) {
 188     myXmlHandler = new SALOME_PYQT_XmlHandler( this, aFileName );
 189     myXmlHandler->createActions();
 190   }
 191
 192   // perform internal initialization and call module's initialize() method
 193   // InitializeReq: request class for internal init() operation
 194   class InitializeReq : public PyInterp_Request
 195   {
 196   public:
 197     InitializeReq( CAM_Application*    _app,
 198                    SALOME_PYQT_Module* _obj )
 199       : PyInterp_Request( 0, true ), // this request should be processed synchronously (sync == true)
 200         myApp( _app ),
 201         myObj( _obj ) {}
 202
 203   protected:
 204     virtual void execute()
 205     {
 206       myObj->init( myApp );
 207     }
 208
 209   private:
 210     CAM_Application*    myApp;
 211     SALOME_PYQT_Module* myObj;
 212   };
 213
 214   // Posting the request
 215   PyInterp_Dispatcher::Get()->Exec( new InitializeReq( app, this ) );
 216 }
 217
 218 /*!
 219  * Activation of the module.
 220  * Inherited from CAM_Module.
 221  */
 222 bool SALOME_PYQT_Module::activateModule( SUIT_Study* theStudy )
 223 {
 224   MESSAGE( "SALOME_PYQT_Module::activateModule" );
 225
 226   bool res = SalomeApp_Module::activateModule( theStudy );
 227
 228   if ( !res )
 229     return res;
 230
 231   // ActivateReq: request class for internal activate() operation
 232   class ActivateReq : public PyInterp_Request
 233   {
 234   public:
 235     ActivateReq( SUIT_Study*         _study,
 236                  SALOME_PYQT_Module* _obj )
 237       : PyInterp_Request( 0, true ), // this request should be processed synchronously (sync == true)
 238         myStudy ( _study ),
 239         myObj   ( _obj   ) {}
 240
 241   protected:
 242     virtual void execute()
 243     {
 244       myObj->activate( myStudy );
 245     }
 246
 247   private:
 248     SUIT_Study*         myStudy;
 249     SALOME_PYQT_Module* myObj;
 250   };
 251
 252   // Posting the request
 253   PyInterp_Dispatcher::Get()->Exec( new ActivateReq( theStudy, this ) );
 254
 255   // activate menus, toolbars, etc
 256   setMenuShown( true );
 257   setToolShown( true );
 258
 259   return true;
 260 }
 261
 262 /*!
 263  * Deactivation of the module.
 264  * Inherited from CAM_Module.
 265  */
 266 bool SALOME_PYQT_Module::deactivateModule( SUIT_Study* theStudy )
 267 {
 268   MESSAGE( "SALOME_PYQT_Module::deactivateModule" );
 269
 270   bool res = SalomeApp_Module::deactivateModule( theStudy );
 271
 272   // deactivate menus, toolbars, etc
 273   setMenuShown( false );
 274   setToolShown( false );
 275
 276   // DeactivateReq: request class for internal deactivate() operation
 277   class DeactivateReq : public PyInterp_LockRequest
 278   {
 279   public:
 280     DeactivateReq( PyInterp_base*      _py_interp,
 281                    SUIT_Study*         _study,
 282                    SALOME_PYQT_Module* _obj )
 283       : PyInterp_LockRequest( _py_interp, 0, true ), // this request should be processed synchronously (sync == true)
 284         myStudy ( _study ),
 285         myObj   ( _obj   ) {}
 286
 287   protected:
 288     virtual void execute()
 289     {
 290       myObj->deactivate( myStudy );
 291     }
 292
 293   private:
 294     SUIT_Study*         myStudy;
 295     SALOME_PYQT_Module* myObj;
 296   };
 297
 298   // Posting the request
 299   PyInterp_Dispatcher::Get()->Exec( new DeactivateReq( myInterp, theStudy, this ) );
 300
 301   return res;
 302 }
 303
 304 /*!
 305  * Processes GUI action (from main menu, toolbar or context popup menu)
 306  */
 307 void SALOME_PYQT_Module::onGUIEvent()
 308 {
 309   // get sender action
 310   const QObject* obj = sender();
 311   if ( !obj || !obj->inherits( "QAction" ) )
 312     return;
 313   QAction* action = (QAction*)obj;
 314
 315   // get action ID
 316   int id = actionId( action );
 317   MESSAGE( "SALOME_PYQT_Module::onGUIEvent: id = " << id );
 318
 319   // perform synchronous request to Python event dispatcher
 320   class GUIEvent : public PyInterp_LockRequest
 321   {
 322   public:
 323     GUIEvent( PyInterp_base*      _py_interp,
 324               SALOME_PYQT_Module* _obj,
 325               int                 _id )
 326       : PyInterp_LockRequest( _py_interp, 0, true ), // this request should be processed synchronously (sync == true)
 327         myId    ( _id  ),
 328         myObj   ( _obj ) {}
 329
 330   protected:
 331     virtual void execute()
 332     {
 333       myObj->guiEvent( myId );
 334     }
 335
 336   private:
 337     int                 myId;
 338     SALOME_PYQT_Module* myObj;
 339   };
 340
 341   // Posting the request
 342   PyInterp_Dispatcher::Get()->Exec( new GUIEvent( myInterp, this, id ) );
 343 }
 344
 345 /*!
 346  * Processes GUI action (from context popup menu, only for XML-based actions!)
 347  */
 348 void SALOME_PYQT_Module::onGUIEvent( int id )
 349 {
 350   // perform synchronous request to Python event dispatcher
 351   class GUIEvent : public PyInterp_LockRequest
 352   {
 353   public:
 354     GUIEvent( PyInterp_base*      _py_interp,
 355               SALOME_PYQT_Module* _obj,
 356               int                 _id )
 357       : PyInterp_LockRequest( _py_interp, 0, true ), // this request should be processed synchronously (sync == true)
 358         myId    ( _id  ),
 359         myObj   ( _obj ) {}
 360
 361   protected:
 362     virtual void execute()
 363     {
 364       myObj->guiEvent( myId );
 365     }
 366
 367   private:
 368     int                 myId;
 369     SALOME_PYQT_Module* myObj;
 370   };
 371
 372   // Posting the request
 373   PyInterp_Dispatcher::Get()->Exec( new GUIEvent( myInterp, this, id ) );
 374 }
 375
 376 /*!
 377   Context popup menu request.
 378   Called when user activates popup menu in some window (view, object browser, etc).
 379   */
 380 void SALOME_PYQT_Module::contextMenuPopup( const QString& theContext, QPopupMenu* thePopupMenu, QString& /*title*/ )
 381 {
 382   MESSAGE( "SALOME_PYQT_Module::contextMenuPopup : " << theContext.latin1() );
 383   // perform synchronous request to Python event dispatcher
 384   class PopupMenuEvent : public PyInterp_LockRequest
 385   {
 386   public:
 387     PopupMenuEvent( PyInterp_base*     _py_interp,
 388                     SALOME_PYQT_Module* _obj,
 389                     const QString&      _context,
 390                     QPopupMenu*        _popup )
 391       : PyInterp_LockRequest( _py_interp, 0, true ), // this request should be processed synchronously (sync == true)
 392         myContext( _context ),
 393         myPopup  ( _popup  ),
 394         myObj    ( _obj )   {}
 395
 396   protected:
 397     virtual void execute()
 398     {
 399       myObj->contextMenu( myContext, myPopup );
 400     }
 401
 402   private:
 403     SALOME_PYQT_Module* myObj;
 404     QString             myContext;
 405     QPopupMenu*         myPopup;
 406   };
 407
 408   // Posting the request only if dispatcher is not busy!
 409   // Executing the request synchronously
 410   if ( !PyInterp_Dispatcher::Get()->IsBusy() )
 411     PyInterp_Dispatcher::Get()->Exec( new PopupMenuEvent( myInterp, this, theContext, thePopupMenu ) );
 412 }
 413
 414 /*!
 415  * Defines the dockable window associated with the module.
 416  * To fill the list of windows the correspondind Python module's windows()
 417  * method is called from SALOME_PYQT_Module::init() method.
 418  * By default, ObjectBrowser, PythonConsole and LogWindow are provided.
 419  */
 420 void SALOME_PYQT_Module::windows( QMap<int, int>& mappa ) const
 421 {
 422   // First clear the output parameters
 423   QMap<int, int>::ConstIterator it;
 424   for ( it = myWindowsMap.begin(); it != myWindowsMap.end(); ++it ) {
 425     mappa[ it.key() ] = it.data();
 426   }
 427 }
 428
 429 /*!
 430  * Defines the compatible views which should be opened on module activation.
 431  * To fill the list of views the correspondind Python module's views()
 432  * method is called from SALOME_PYQT_Module::init() method.
 433  * By default, the list is empty.
 434  */
 435 void SALOME_PYQT_Module::viewManagers( QStringList& listik ) const
 436 {
 437   for ( QStringList::ConstIterator it = myViewMgrList.begin(); it != myViewMgrList.end(); ++it ) {
 438     listik.append( *it );
 439   }
 440 }
 441
 442 /*!
 443  * Performs internal initialization
 444  * - initializes/gets the Python interpreter (one per study)
 445  * - imports the Python module
 446  * - passes the workspace widget to the Python module
 447  * - calls Python module's initialize() method
 448  * - calls Python module's windows() method
 449  * - calls Python module's views() method
 450  */
 451 void SALOME_PYQT_Module::init( CAM_Application* app )
 452 {
 453   // reset interpreter to NULL
 454   myInterp = NULL;
 455
 456   // get study Id
 457   SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( app );
 458   if ( !anApp )
 459     return;
 460
 461   SalomeApp_Study* aStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() );
 462   if ( !aStudy )
 463     return;
 464   int aStudyId = aStudy ? aStudy->studyDS()->StudyId() : 0;
 465
 466   // initialize Python subinterpreter (on per study) and put it in <myInterp> variable
 467   initInterp( aStudyId );
 468   if ( !myInterp )
 469     return; // Error
 470
 471   // import Python GUI module
 472   importModule();
 473   if ( !myModule )
 474     return; // Error
 475
 476   myInitModule = this;
 477
 478   if ( IsCallOldMethods ) { // __CALL_OLD_METHODS__
 479     // call Python module's setWorkspace() method
 480     setWorkSpace();
 481   }                         //__CALL_OLD_METHODS__
 482
 483   // then call Python module's initialize() method
 484   // ... first get python lock
 485   PyLockWrapper aLock = myInterp->GetLockWrapper();
 486   // ... (the Python module is already imported)
 487   // ... finally call Python module's initialize() method
 488   PyObjWrapper res( PyObject_CallMethod( myModule, "initialize", "" ) );
 489   if( !res ) {
 490     // VSR: this method may not be implemented in Python module
 491     // PyErr_Print();
 492   }
 493
 494   // get the windows list from the Python module by calling windows() method
 495   // ... first put default values
 496   myWindowsMap.insert( SalomeApp_Application::WT_ObjectBrowser, Qt::DockLeft );
 497   myWindowsMap.insert( SalomeApp_Application::WT_PyConsole,     Qt::DockBottom );
 498   // VSR: LogWindow is not yet implemented
 499   // myWindowsMap.insert( SalomeApp_Application::WT_LogWindow,     Qt::DockBottom );
 500
 501   PyObjWrapper res1( PyObject_CallMethod( myModule, "windows", "" ) );
 502   if( !res1 ) {
 503     // VSR: this method may not be implemented in Python module
 504     // PyErr_Print();
 505   }
 506   else {
 507     myWindowsMap.clear();
 508     if ( PyDict_Check( res1 ) ) {
 509       PyObject* key;
 510       PyObject* value;
 511       int pos = 0;
 512       while ( PyDict_Next( res1, &pos, &key, &value ) ) {
 513         // parse the return value
 514         // it should be a map: {integer:integer}
 515         int aKey, aValue;
 516         if( key && PyInt_Check( key ) && value && PyInt_Check( value ) ) {
 517           aKey   = PyInt_AsLong( key );
 518           aValue = PyInt_AsLong( value );
 519           myWindowsMap[ aKey ] = aValue;
 520         }
 521       }
 522     }
 523   }
 524   // get the windows list from the Python module by calling views() method
 525   PyObjWrapper res2( PyObject_CallMethod( myModule, "views", "" ) );
 526   if( !res2 ) {
 527     // VSR: this method may not be implemented in Python module
 528     // PyErr_Print();
 529   }
 530   else {
 531     // parse the return value
 532     // result can be one string...
 533     if ( PyString_Check( res2 ) ) {
 534       myViewMgrList.append( PyString_AsString( res2 ) );
 535     }
 536     // ... or list of strings
 537     else if ( PyList_Check( res2 ) ) {
 538       int size = PyList_Size( res2 );
 539       for ( int i = 0; i < size; i++ ) {
 540         PyObject* value = PyList_GetItem( res2, i );
 541         if( value && PyString_Check( value ) ) {
 542           myViewMgrList.append( PyString_AsString( value ) );
 543         }
 544       }
 545     }
 546   }
 547   myInitModule = 0;
 548 }
 549
 550 /*!
 551  * Performs internal activation:
 552  * - initializes/gets the Python interpreter (one per study)
 553  * - imports the Python GUI module
 554  * - calls Python module's setSettings() method (obsolete function, used for compatibility with old code)
 555  *   or activate() method (for new modules)
 556  */
 557 void SALOME_PYQT_Module::activate( SUIT_Study* theStudy )
 558 {
 559   // get study Id
 560   SalomeApp_Study* aStudy = dynamic_cast<SalomeApp_Study*>( theStudy );
 561   int aStudyId = aStudy ? aStudy->studyDS()->StudyId() : 0;
 562
 563   // initialize Python subinterpreter (on per study) and put it in <myInterp> variable
 564   initInterp( aStudyId );
 565   if ( !myInterp )
 566     return; // Error
 567
 568   // import Python GUI module
 569   importModule();
 570   if ( !myModule )
 571     return; // Error
 572
 573   // get python lock
 574   PyLockWrapper aLock = myInterp->GetLockWrapper();
 575
 576   if ( IsCallOldMethods ) { //__CALL_OLD_METHODS__
 577     // call Python module's setSettings() method (obsolete)
 578     PyObjWrapper res( PyObject_CallMethod( myModule, "setSettings", "" ) );
 579     if( !res ) {
 580       // VSR: this method may not be implemented in Python module
 581       // PyErr_Print();
 582     }
 583   }                         //__CALL_OLD_METHODS__
 584
 585   // call Python module's activate() method (for the new modules)
 586   PyObjWrapper res1( PyObject_CallMethod( myModule, "activate", "" ) );
 587   if( !res1 ) {
 588     // VSR: this method may not be implemented in Python module
 589     // PyErr_Print();
 590   }
 591 }
 592
 593 /*!
 594  * Performs internal deactivation:
 595  * - calls Python module's deactivate() method
 596  */
 597 void SALOME_PYQT_Module::deactivate( SUIT_Study* theStudy )
 598 {
 599   // check if the subinterpreter is initialized and Python module is imported
 600   if ( !myInterp || !myModule ) {
 601     // Error! Python subinterpreter should be initialized and module should be imported first!
 602     return;
 603   }
 604   // then call Python module's deactivate() method
 605   PyObjWrapper res( PyObject_CallMethod( myModule, "deactivate", "" ) );
 606   if( !res ) {
 607     // VSR: this method may not be implemented in Python module
 608     // PyErr_Print();
 609   }
 610 }
 611
 612 /*!
 613  * Called when active the study is actived (user brings its desktop to top)
 614  * - initializes/gets the Python interpreter (one per study)
 615  * - imports the Python GUI module
 616  * - calls Python module's activeStudyChanged() method
 617  */
 618 void SALOME_PYQT_Module::studyChanged( SUIT_Study* theStudy )
 619 {
 620   // get study Id
 621   SalomeApp_Study* aStudy = dynamic_cast<SalomeApp_Study*>( theStudy );
 622   int aStudyId = aStudy ? aStudy->studyDS()->StudyId() : 0;
 623
 624   // initialize Python subinterpreter (on per study) and put it in <myInterp> variable
 625   initInterp( aStudyId );
 626   if ( !myInterp )
 627     return; // Error
 628
 629   // import Python GUI module
 630   importModule();
 631   if ( !myModule )
 632     return; // Error
 633
 634   // get python lock
 635   PyLockWrapper aLock = myInterp->GetLockWrapper();
 636
 637   // call Python module's activeStudyChanged() method
 638   PyObjWrapper res( PyObject_CallMethod( myModule, "activeStudyChanged", "i", aStudyId ) );
 639   if( !res ) {
 640     // VSR: this method may not be implemented in Python module
 641     // PyErr_Print();
 642   }
 643 }
 644
 645 /*!
 646  * Get module engine, returns nil var if engine is not found in LifeCycleCORBA
 647  */
 648 Engines::Component_var SALOME_PYQT_Module::getEngine() const
 649 {
 650   Engines::Component_var comp;
 651   // temporary solution
 652   try {
 653     comp = getApp()->lcc()->FindOrLoad_Component( "FactoryServerPy", name( "" ) );
 654   }
 655   catch (CORBA::Exception&) {
 656   }
 657   return comp;
 658 }
 659
 660 /*!
 661  * Get module engine IOR, returns empty string if engine is not found in LifeCycleCORBA
 662  */
 663 QString SALOME_PYQT_Module::engineIOR() const
 664 {
 665   if ( !CORBA::is_nil( getEngine() ) )
 666     return QString( getApp()->orb()->object_to_string( getEngine() ) );
 667   return QString( "" );
 668 }
 669
 670 /*!
 671  * Called when study desktop is activated.
 672  * Used for notifying about changing of the active study.
 673  */
 674 void SALOME_PYQT_Module::studyActivated()
 675 {
 676   // StudyChangedReq: request class for internal studyChanged() operation
 677   class StudyChangedReq : public PyInterp_Request
 678   {
 679   public:
 680     StudyChangedReq( SUIT_Study*         _study,
 681                      SALOME_PYQT_Module* _obj )
 682       : PyInterp_Request( 0, true ), // this request should be processed synchronously (sync == true)
 683         myStudy ( _study ),
 684         myObj   ( _obj   ) {}
 685
 686   protected:
 687     virtual void execute()
 688     {
 689       myObj->studyChanged( myStudy );
 690     }
 691
 692   private:
 693     SUIT_Study*         myStudy;
 694     SALOME_PYQT_Module* myObj;
 695   };
 696
 697   // Posting the request
 698   PyInterp_Dispatcher::Get()->Exec( new StudyChangedReq( application()->activeStudy(), this ) );
 699 }
 700
 701 /*!
 702  * Processes context popup menu request
 703  * - calls Python module's definePopup(...) method (obsolete function, used for compatibility with old code)
 704  *   to define the popup menu context
 705  * - parses XML resourses file (if exists) and fills the popup menu with the items)
 706  * - calls Python module's customPopup(...) method (obsolete function, used for compatibility with old code)
 707  *   to allow module to customize the popup menu
 708  * - for new modules calls createPopupMenu() function to allow the modules to build the popup menu
 709  *   by using insertItem(...) Qt functions.
 710  */
 711 void SALOME_PYQT_Module::contextMenu( const QString& theContext, QPopupMenu* thePopupMenu )
 712 {
 713   // Python interpreter should be initialized and Python module should be
 714   // import first
 715   if ( !myInterp || !myModule )
 716     return;
 717
 718   QString aContext( theContext ), aObject( "" ), aParent( "" );
 719
 720   if ( IsCallOldMethods ) { //__CALL_OLD_METHODS__
 721     // call definePopup() Python module's function
 722     // this is obsolete function, used only for compatibility reasons
 723     PyObjWrapper res(PyObject_CallMethod( myModule,
 724                                           "definePopup",
 725                                           "sss",
 726                                           aContext.latin1(),
 727                                           aObject.latin1(),
 728                                           aParent.latin1() ) );
 729     if( !res ) {
 730       // VSR: this method may not be implemented in Python module
 731       // PyErr_Print();
 732     }
 733     else {
 734       // parse return value
 735       char *co, *ob, *pa;
 736       if( PyArg_ParseTuple( res, "sss", &co, &ob, &pa ) ) {
 737         aContext = co;
 738         aObject  = ob;
 739         aParent  = pa;
 740       }
 741     }
 742   }                        //__CALL_OLD_METHODS__
 743
 744   // first try to create menu via XML parser:
 745   // we create popup menus without help of QtxPopupMgr
 746   if ( myXmlHandler )
 747     myXmlHandler->createPopup( thePopupMenu, aContext, aParent, aObject );
 748
 749   PyObjWrapper sipPopup( sipBuildResult( 0, "M", thePopupMenu, sipClass_QPopupMenu ) );
 750
 751   // then call Python module's createPopupMenu() method (for new modules)
 752   PyObjWrapper res1( PyObject_CallMethod( myModule,
 753                                           "createPopupMenu",
 754                                           "Os",
 755                                           sipPopup.get(),
 756                                           aContext.latin1() ) );
 757   if( !res1 ) {
 758     // VSR: this method may not be implemented in Python module
 759     // PyErr_Print();
 760   }
 761
 762   if ( IsCallOldMethods ) { //__CALL_OLD_METHODS__
 763     // call customPopup() Python module's function
 764     // this is obsolete function, used only for compatibility reasons
 765     PyObjWrapper res2( PyObject_CallMethod( myModule,
 766                                             "customPopup",
 767                                             "Osss",
 768                                             sipPopup.get(),
 769                                             aContext.latin1(),
 770                                             aObject.latin1(),
 771                                             aParent.latin1() ) );
 772     if( !res2 ) {
 773       // VSR: this method may not be implemented in Python module
 774       // PyErr_Print();
 775     }
 776   }                        //__CALL_OLD_METHODS__
 777 }
 778
 779 /*!
 780  * Processes GUI event
 781  * - calls Python module's OnGUIEvent() method
 782  */
 783 void SALOME_PYQT_Module::guiEvent( const int theId )
 784 {
 785   // Python interpreter should be initialized and Python module should be
 786   // import first
 787   if ( !myInterp || !myModule )
 788     return;
 789
 790   PyObjWrapper res( PyObject_CallMethod( myModule, "OnGUIEvent", "i", theId ) );
 791   if( !res ) {
 792     // Error!
 793     PyErr_Print();
 794   }
 795 }
 796
 797 /*!
 798  *  Initialises python subinterpreter (one per study)
 799  */
 800 void SALOME_PYQT_Module::initInterp( int theStudyId )
 801 {
 802   // check study Id
 803   if ( !theStudyId ) {
 804     // Error! Study Id must not be 0!
 805     myInterp = NULL;
 806     return;
 807   }
 808   // try to find the subinterpreter
 809   if( myInterpMap.find( theStudyId ) != myInterpMap.end() ) {
 810     // found!
 811     myInterp = myInterpMap[ theStudyId ];
 812     return;
 813   }
 814   // not found - create a new one!
 815   ///////////////////////////////////////////////////////////////////
 816   // Attention: the creation of Python interpretor must be protected
 817   // by a C++ Lock because of C threads
 818   ///////////////////////////////////////////////////////////////////
 819   myInterp = new SALOME_PYQT_PyInterp();
 820   myInterp->initialize();
 821   myInterpMap[ theStudyId ] = myInterp;
 822
 823   // import 'salome' module and call 'salome_init' method;
 824   // do it only once on interpreter creation
 825   // ... first get python lock
 826   PyLockWrapper aLock = myInterp->GetLockWrapper();
 827   // ... then import a module
 828   PyObjWrapper aMod = PyImport_ImportModule( "salome" );
 829   if( !aMod ) {
 830     // Error!
 831     PyErr_Print();
 832     return;
 833   }
 834   // ... then call a method
 835   PyObjWrapper aRes( PyObject_CallMethod( aMod, "salome_init", "" ) );
 836   if( !aRes ) {
 837     // Error!
 838     PyErr_Print();
 839     return;
 840   }
 841 }
 842
 843 /*!
 844  *  Imports Python GUI module and remember the reference to the module
 845  *  !!! initInterp() should be called first!!!
 846  */
 847 void SALOME_PYQT_Module::importModule()
 848 {
 849   // check if the subinterpreter is initialized
 850   if ( !myInterp ) {
 851     // Error! Python subinterpreter should be initialized first!
 852     myModule = 0;
 853     return;
 854   }
 855   // import Python GUI module and puts it in <myModule> attribute
 856   // ... first get python lock
 857   PyLockWrapper aLock = myInterp->GetLockWrapper();
 858   // ... then import a module
 859   QString aMod = QString( name("") ) + "GUI";
 860   myModule = PyImport_ImportModule( (char*)( aMod.latin1() ) );
 861   if( !myModule ) {
 862     // Error!
 863     PyErr_Print();
 864     return;
 865   }
 866 }
 867
 868 /*!
 869  *  Calls <module>.setWorkSpace() method with PyQt QWidget object to use with
 870  *  interpreter.
 871  *  !!! initInterp() and importModule() should be called first!!!
 872  */
 873 void SALOME_PYQT_Module::setWorkSpace()
 874 {
 875   // check if the subinterpreter is initialized and Python module is imported
 876   if ( !myInterp || !myModule ) {
 877     // Error! Python subinterpreter should be initialized and module should be imported first!
 878     return;
 879   }
 880
 881   // call setWorkspace() method
 882   // ... first get python lock
 883   PyLockWrapper aLock = myInterp->GetLockWrapper();
 884
 885   // ... then try to import SalomePyQt module. If it's not possible don't go on.
 886   PyObjWrapper aQtModule( PyImport_ImportModule( "SalomePyQt" ) );
 887   if( !aQtModule ) {
 888     // Error!
 889     PyErr_Print();
 890     return;
 891   }
 892
 893   if ( IsCallOldMethods ) { //__CALL_OLD_METHODS__
 894     // ... then get workspace object
 895     QWidget* aWorkspace = 0;
 896     if ( getApp()->desktop()->inherits( "STD_MDIDesktop" ) ) {
 897       STD_MDIDesktop* aDesktop = dynamic_cast<STD_MDIDesktop*>( getApp()->desktop() );
 898       if ( aDesktop )
 899         aWorkspace = aDesktop->workspace();
 900     }
 901     else if ( getApp()->desktop()->inherits( "STD_TabDesktop" ) ) {
 902       STD_TabDesktop* aDesktop = dynamic_cast<STD_TabDesktop*>( getApp()->desktop() );
 903       if ( aDesktop )
 904         aWorkspace = aDesktop->workstack();
 905     }
 906     PyObjWrapper pyws( sipBuildResult( 0, "M", aWorkspace, sipClass_QWidget ) );
 907     // ... and finally call Python module's setWorkspace() method (obsolete)
 908     PyObjWrapper res( PyObject_CallMethod( myModule, "setWorkSpace", "O", pyws.get() ) );
 909     if( !res ) {
 910       // VSR: this method may not be implemented in Python module
 911       // PyErr_Print();
 912       return;
 913     }
 914   }                         //__CALL_OLD_METHODS__
 915 }
 916
 917 /*!
 918  * Adds an action into private action list [internal usage]
 919  */
 920 void SALOME_PYQT_Module::addAction( const PyQtGUIAction type, QAction* action )
 921 {
 922   switch ( type ) {
 923   case PYQT_ACTION_MENU:
 924     myMenuActionList.append( action );
 925     break;
 926   case PYQT_ACTION_TOOLBAL:
 927     myToolbarActionList.append( action );
 928     break;
 929   case PYQT_ACTION_POPUP:
 930     myPopupActionList.append( action );
 931     break;
 932   }
 933 }
 934
 935
 936 /*!
 937  * The next methods just call the parent implementation.
 938  * This is done to open protected methods from CAM_Module class.
 939 */
 940 int SALOME_PYQT_Module::createTool( const QString& name )
 941 {
 942   return SalomeApp_Module::createTool( name );
 943 }
 944 int SALOME_PYQT_Module::createTool( const int id, const int tBar, const int idx )
 945 {
 946   return SalomeApp_Module::createTool( id, tBar, idx );
 947 }
 948 int SALOME_PYQT_Module::createTool( const int id, const QString& tBar, const int idx )
 949 {
 950   return SalomeApp_Module::createTool( id, tBar, idx );
 951 }
 952 int SALOME_PYQT_Module::createTool( QAction* a, const int tBar, const int id, const int idx )
 953 {
 954   return SalomeApp_Module::createTool( a, tBar, id, idx );
 955 }
 956 int SALOME_PYQT_Module::createTool( QAction* a, const QString& tBar, const int id, const int idx )
 957 {
 958   return SalomeApp_Module::createTool( a, tBar, id, idx );
 959 }
 960 int SALOME_PYQT_Module::createMenu( const QString& subMenu, const int menu, const int id, const int group, const int idx )
 961 {
 962   return SalomeApp_Module::createMenu( subMenu, menu, id, group, idx );
 963 }
 964 int SALOME_PYQT_Module::createMenu( const QString& subMenu, const QString& menu, const int id, const int group, const int idx )
 965 {
 966   return SalomeApp_Module::createMenu( subMenu, menu, id, group, idx );
 967 }
 968 int SALOME_PYQT_Module::createMenu( const int id, const int menu, const int group, const int idx )
 969 {
 970   return SalomeApp_Module::createMenu( id, menu, group, idx );
 971 }
 972 int SALOME_PYQT_Module::createMenu( const int id, const QString& menu, const int group, const int idx )
 973 {
 974   return SalomeApp_Module::createMenu( id, menu, group, idx );
 975 }
 976 int SALOME_PYQT_Module::createMenu( QAction* a, const int menu, const int id, const int group, const int idx )
 977 {
 978   return SalomeApp_Module::createMenu( a, menu, id, group, idx );
 979 }
 980 int SALOME_PYQT_Module::createMenu( QAction* a, const QString& menu, const int id, const int group, const int idx )
 981 {
 982   return SalomeApp_Module::createMenu( a, menu, id, group, idx );
 983 }
 984 QAction* SALOME_PYQT_Module::createSeparator()
 985 {
 986   return SalomeApp_Module::separator();
 987 }
 988 QAction* SALOME_PYQT_Module::action( const int id ) const
 989 {
 990   QAction* a = SalomeApp_Module::action( id );
 991   if ( !a ) // try own action map for menu items
 992     a = SalomeApp_Module::action( id + PYQT_ACTION_MENU );
 993   if ( !a ) // try own action map for toolbar items
 994     a = SalomeApp_Module::action( id + PYQT_ACTION_TOOLBAL );
 995   if ( !a ) // try own action map for popup items
 996     a = SalomeApp_Module::action( id + PYQT_ACTION_POPUP );
 997   return a;
 998 }
 999 int SALOME_PYQT_Module::actionId( const QAction* a ) const
1000 {
1001   int id = SalomeApp_Module::actionId( a );
1002   if ( myMenuActionList.contains( a ) )    // check own action map for menu items
1003     id -= PYQT_ACTION_MENU;
1004   if ( myToolbarActionList.contains( a ) ) // check own action map for toolbar items
1005     id -= PYQT_ACTION_TOOLBAL;
1006   if ( myPopupActionList.contains( a ) )   // check own action map for popup items
1007     id -= PYQT_ACTION_POPUP;
1008   return id;
1009 }
1010 QAction* SALOME_PYQT_Module::createAction( const int id, const QString& text, const QString& icon,
1011                                            const QString& menu, const QString& tip, const int key,
1012                                            const bool toggle )
1013 {
1014   QIconSet anIcon;
1015   if ( !icon.isEmpty() ) {
1016     QPixmap pixmap  = getApp()->resourceMgr()->loadPixmap( name(""), tr( icon ) );
1017     if ( !pixmap.isNull() )
1018       anIcon = QIconSet( pixmap );
1019   }
1020   return SalomeApp_Module::createAction( id, text, anIcon, menu, tip, key, getApp()->desktop(), toggle, this, SLOT( onGUIEvent() ) );
1021 }
1022
1023
1024 //=============================================================================
1025 // SALOME_PYQT_XmlHandler class implementation
1026 //=============================================================================
1027
1028 // gets an tag name for the dom element [ static ]
1029 // returns an empty string if the element does not have tag name
1030 static QString tagName( const QDomElement& element ) {
1031  return element.tagName().stripWhiteSpace();
1032 }
1033
1034 // gets an attribute by it's name for the dom element [ static ]
1035 // returns an empty string if the element does not have such attribute
1036 static QString attribute( const QDomElement& element, const QString& attName ) {
1037   return element.attribute( attName ).stripWhiteSpace();
1038 }
1039
1040 // checks the given value for the boolean value [ static ]
1041 // returns TRUE if string is "true", "yes" or "1"
1042 static bool checkBool( const QString& value ) {
1043   return ( value == "true" || value == "yes" || value == "1" );
1044 }
1045
1046 // checks the given value for the integer value [ static ]
1047 // returns -1 if item is empty or presents and invalid number
1048 static int checkInt( const QString& value )
1049 {
1050   return value.isEmpty() ? -1 : value.toInt();
1051 }
1052
1053 /*!
1054  * Constructor
1055  */
1056 SALOME_PYQT_XmlHandler::SALOME_PYQT_XmlHandler( SALOME_PYQT_Module* module, const QString& fileName )
1057      : myModule( module )
1058 {
1059   QFile aFile( fileName );
1060   if ( !aFile.open( IO_ReadOnly ) )
1061     return;
1062   if ( !myDoc.setContent( &aFile ) ) {
1063       aFile.close();
1064       return;
1065   }
1066   aFile.close();
1067 }
1068
1069 /*!
1070   Called by SALOME_PYQT_Module::initialize() in order to create actions
1071   (menus, toolbars, popup menus)
1072  */
1073 void SALOME_PYQT_XmlHandler::createActions()
1074 {
1075   // get document element
1076   QDomElement aDocElem = myDoc.documentElement();
1077
1078   // get main menu actions
1079   QDomNodeList aMenuList = aDocElem.elementsByTagName( "menu-item" );
1080   for ( int i = 0; i < aMenuList.count(); i++ ) {
1081     QDomNode n = aMenuList.item( i );
1082     createMenu( n );
1083   }
1084
1085   // create toolbars actions
1086   QDomNodeList aToolsList = aDocElem.elementsByTagName( "toolbar" );
1087   for ( int i = 0; i < aToolsList.count(); i++ ) {
1088     QDomNode n = aToolsList.item( i );
1089     createToolBar( n );
1090   }
1091 }
1092
1093 /*!
1094  *  Creates popup menu
1095  */
1096 void SALOME_PYQT_XmlHandler::createPopup( QPopupMenu*    menu,
1097                                           const QString& context,
1098                                           const QString& parent,
1099                                           const QString& object )
1100 {
1101   // get document element
1102   QDomElement aDocElem = myDoc.documentElement();
1103
1104   // get popup menus actions
1105   QDomNodeList aPopupList = aDocElem.elementsByTagName( "popupmenu" );
1106   for ( int i = 0; i < aPopupList.count(); i++ ) {
1107     QDomNode n = aPopupList.item( i );
1108     if ( !n.isNull() && n.isElement() ) {
1109       QDomElement e = n.toElement();
1110       QString lab = attribute( e, "label-id"   );
1111       QString ctx = attribute( e, "context-id" );
1112       QString prt = attribute( e, "parent-id"  );
1113       QString obj = attribute( e, "object-id"  );
1114       if ( ctx == context && prt == parent && obj == object )  {
1115         insertPopupItems( n, menu );
1116         break;
1117       }
1118     }
1119   }
1120 }
1121
1122 /*!
1123   Create main menu with child actions
1124  */
1125 void SALOME_PYQT_XmlHandler::createMenu( QDomNode& parentNode, const int parentMenuId )
1126 {
1127   if ( !myModule )
1128     return;
1129
1130   if ( parentNode.isNull() )
1131     return;
1132
1133   QDomElement parentElement = parentNode.toElement();
1134   if ( !parentElement.isNull() ) {
1135     QString plabel = attribute( parentElement, "label-id" );
1136     int     pid    = checkInt( attribute( parentElement, "item-id" ) );
1137     int     ppos   = checkInt( attribute( parentElement, "pos-id" ) );
1138     if ( !plabel.isEmpty() ) {
1139       // create menu
1140       int menuId = myModule->createMenu( plabel,         // label
1141                                          parentMenuId,   // parent menu ID, should be -1 for main menu
1142                                          pid,            // ID
1143                                          80,             // group ID
1144                                          ppos );         // position
1145       QDomNode node = parentNode.firstChild();
1146       while ( !node.isNull() ) {
1147         if ( node.isElement() ) {
1148           QDomElement elem = node.toElement();
1149           QString aTagName = tagName( elem );
1150           if ( aTagName == "popup-item" ) {
1151             int     id      = checkInt( attribute( elem, "item-id" ) );
1152             int     pos     = checkInt( attribute( elem, "pos-id" ) );
1153             QString label   = attribute( elem, "label-id" );
1154             QString icon    = attribute( elem, "icon-id" );
1155             QString tooltip = attribute( elem, "tooltip-id" );
1156             QString accel   = attribute( elem, "accel-id" );
1157             bool    toggle  = checkBool( attribute( elem, "toggle-id" ) );
1158             ////QString execute = attribute( elem, "execute-action" );               // not used
1159
1160             // -1 action ID is not allowed : it means that <item-id> attribute is missed in the XML file!
1161             // also check if the action with given ID is already created
1162             if ( id != -1 && !myModule->action( SALOME_PYQT_Module::PYQT_ACTION_MENU + id ) ) {
1163               // little trick to have several actions with same ID for menus and toolbars
1164               id = SALOME_PYQT_Module::PYQT_ACTION_MENU + id;
1165               // create menu action
1166               QAction* action = myModule->createAction( id,                               // ID
1167                                                         tooltip,                          // tooltip
1168                                                         icon,                             // icon
1169                                                         label,                            // menu text
1170                                                         tooltip,                          // status-bar text
1171                                                         QKeySequence( accel ),            // keyboard accelerator
1172                                                         toggle );                         // toogled action
1173               myModule->addAction( SALOME_PYQT_Module::PYQT_ACTION_MENU, action );
1174               myModule->createMenu( action, menuId, -1, 80, pos );
1175             }
1176           }
1177           else if ( aTagName == "submenu" ) {
1178             // create sub-menu
1179             createMenu( node, menuId );
1180           }
1181           else if ( aTagName == "separator" ) {
1182             // create menu separator
1183             int     pos     = checkInt( attribute( elem, "pos-id" ) );
1184             QAction* action = myModule->createSeparator();
1185             myModule->createMenu( action, menuId, -1, 80, pos );
1186           }
1187         }
1188         node = node.nextSibling();
1189       }
1190     }
1191   }
1192 }
1193
1194 /*!
1195   Create a toolbar with child actions
1196  */
1197 void SALOME_PYQT_XmlHandler::createToolBar( QDomNode& parentNode )
1198 {
1199   if ( !myModule )
1200     return;
1201
1202   if ( parentNode.isNull() )
1203     return;
1204
1205   QDomElement parentElement = parentNode.toElement();
1206   if ( !parentElement.isNull() ) {
1207     QString aLabel = attribute( parentElement, "label-id" );
1208     if ( !aLabel.isEmpty() ) {
1209       // create toolbar
1210       int tbId = myModule->createTool( aLabel );
1211       QDomNode node = parentNode.firstChild();
1212       while ( !node.isNull() ) {
1213         if ( node.isElement() ) {
1214           QDomElement elem = node.toElement();
1215           QString aTagName = tagName( elem );
1216           if ( aTagName == "toolbutton-item" ) {
1217             int     id      = checkInt( attribute( elem, "item-id" ) );
1218             int     pos     = checkInt( attribute( elem, "pos-id" ) );
1219             QString label   = attribute( elem, "label-id" );
1220             QString icon    = attribute( elem, "icon-id" );
1221             QString tooltip = attribute( elem, "tooltip-id" );
1222             QString accel   = attribute( elem, "accel-id" );
1223             bool    toggle  = checkBool( attribute( elem, "toggle-id" ) );
1224             ////QString execute = attribute( elem, "execute-action" );               // not used
1225
1226             // -1 action ID is not allowed : it means that <item-id> attribute is missed in the XML file!
1227             // also check if the action with given ID is already created
1228             if ( id != -1 && !myModule->action( SALOME_PYQT_Module::PYQT_ACTION_TOOLBAL + id ) ) {
1229               // little trick to have several actions with same ID for menus and toolbars
1230               id = SALOME_PYQT_Module::PYQT_ACTION_TOOLBAL + id;
1231               // create toolbar action
1232               QAction* action = myModule->createAction( id,                               // ID
1233                                                         tooltip,                          // tooltip
1234                                                         icon,                             // icon
1235                                                         label,                            // menu text
1236                                                         tooltip,                          // status-bar text
1237                                                         QKeySequence( accel ),            // keyboard accelerator
1238                                                         toggle );                         // toogled action
1239               myModule->addAction( SALOME_PYQT_Module::PYQT_ACTION_TOOLBAL, action );
1240               myModule->createTool( action, tbId, -1, pos );
1241             }
1242           }
1243           else if ( aTagName == "separatorTB" ) {
1244             // create toolbar separator
1245             int     pos     = checkInt( attribute( elem, "pos-id" ) );
1246             QAction* action = myModule->createSeparator();
1247             myModule->createTool( action, tbId, -1, pos );
1248           }
1249         }
1250         node = node.nextSibling();
1251       }
1252     }
1253   }
1254 }
1255
1256 void SALOME_PYQT_XmlHandler::insertPopupItems( QDomNode& parentNode, QPopupMenu* menu )
1257 {
1258   if ( !myModule )
1259     return;
1260
1261   if ( parentNode.isNull() )
1262     return;
1263
1264   // we create popup menus without help of QtxPopupMgr
1265   QDomNode node = parentNode.firstChild();
1266   while ( !node.isNull() ) {
1267     if ( node.isElement() ) {
1268       QDomElement elem = node.toElement();
1269       QString aTagName = tagName( elem );
1270       if ( aTagName == "popup-item" ) {
1271         // insert a command item
1272         int     id      = checkInt( attribute( elem, "item-id" ) );
1273         int     pos     = checkInt( attribute( elem, "pos-id" ) );
1274         QString label   = attribute( elem, "label-id" );
1275         QString icon    = attribute( elem, "icon-id" );
1276         /////QString tooltip = attribute( elem, "tooltip-id" );                   // not used
1277         QString accel   = attribute( elem, "accel-id" );
1278         /////bool    toggle  = checkBool( attribute( elem, "toggle-id" ) );       // not used
1279         /////QString execute = attribute( elem, "execute-action" );               // not used
1280
1281         QIconSet anIcon;
1282         if ( !icon.isEmpty() ) {
1283           QPixmap pixmap  = myModule->getApp()->resourceMgr()->loadPixmap( myModule->name(""), icon );
1284           if ( !pixmap.isNull() )
1285             anIcon = QIconSet( pixmap );
1286         }
1287
1288         // -1 action ID is not allowed : it means that <item-id> attribute is missed in the XML file!
1289         // also check if the action with given ID is already created
1290         if ( id != -1 ) {
1291           menu->insertItem( anIcon, label, myModule, SLOT( onGUIEvent(int) ), QKeySequence( accel ), id, pos );
1292         }
1293       }
1294       else if ( aTagName == "submenu" ) {
1295         // create sub-menu
1296         int     id    = checkInt( attribute( elem, "item-id" ) );
1297         int     pos   = checkInt( attribute( elem, "pos-id" ) );
1298         QString label = attribute( elem, "label-id" );
1299         QString icon    = attribute( elem, "icon-id" );
1300
1301         QIconSet anIcon;
1302         if ( !icon.isEmpty() ) {
1303           QPixmap pixmap  = myModule->getApp()->resourceMgr()->loadPixmap( myModule->name(""), icon );
1304           if ( !pixmap.isNull() )
1305             anIcon = QIconSet( pixmap );
1306         }
1307
1308         QPopupMenu* newPopup = new QPopupMenu( menu, label );
1309         menu->insertItem( anIcon, label, newPopup, id, pos );
1310         insertPopupItems( node, newPopup );
1311       }
1312       else if ( aTagName == "separator" ) {
1313         // create menu separator
1314         int     pos     = checkInt( attribute( elem, "pos-id" ) );
1315         menu->insertSeparator( pos );
1316       }
1317     }
1318     node = node.nextSibling();
1319   }
1320 }