src/CAM/CAM_Module.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 #include "CAM_Module.h"
  24
  25 #include "CAM_DataModel.h"
  26 #include "CAM_Application.h"
  27 #include "CAM_Study.h"
  28
  29 #include <QtxAction.h>
  30 #include <QtxActionGroup.h>
  31 #include <QtxActionMenuMgr.h>
  32 #include <QtxActionToolMgr.h>
  33
  34 #include <SUIT_Desktop.h>
  35 #include <SUIT_Session.h>
  36 #include <SUIT_ResourceMgr.h>
  37
  38 #include <QMenu>
  39
  40 /*!
  41   \class CAM_Module
  42   \brief Base implementation of the module in the CAM application architecture.
  43
  44   Provides support of menu/toolbars management.
  45 */
  46
  47 class ActionMgrLocker
  48 {
  49 public:
  50   ActionMgrLocker( QtxActionMgr* m, bool use ) : myMgr( m ), myUseLock( use )
  51   {
  52     if ( myUseLock ) {
  53       myUpdEnabled = myMgr->isUpdatesEnabled();
  54       myMgr->setUpdatesEnabled( false );
  55     }
  56   }
  57   ~ActionMgrLocker()
  58   {
  59     if ( myUseLock ) {
  60       myMgr->setUpdatesEnabled( myUpdEnabled );
  61       //myMgr->update();
  62     }
  63   }
  64
  65   QtxActionMgr* myMgr;
  66   bool          myUseLock;
  67   bool          myUpdEnabled;
  68 };
  69
  70 /*!
  71   \brief Default constructor.
  72
  73   Creates unnamed module.
  74 */
  75 CAM_Module::CAM_Module()
  76 : QObject(),
  77   myApp( 0 ),
  78   myDataModel( 0 )
  79 {
  80 }
  81
  82 /*!
  83   \brief Constructor.
  84
  85   Creates module with the specified \a name.
  86
  87   \param name module name
  88 */
  89 CAM_Module::CAM_Module( const QString& name )
  90 : QObject(),
  91   myApp( 0 ),
  92   myName( name ),
  93   myDataModel( 0 ),
  94   myMenuShown( false ),
  95   myToolShown( false )
  96 {
  97 }
  98
  99 /*!
 100   \brief Destructor.
 101
 102   Destroy data model.
 103 */
 104 CAM_Module::~CAM_Module()
 105 {
 106   delete myDataModel;
 107   myDataModel = 0;
 108 }
 109
 110 /*!
 111   \brief Initialize module.
 112
 113   This method is usually called when the module is created (for example,
 114   on the module library loading).
 115   Successor classes can use this method to create menu/toolbar actions
 116   and perform other module initialization.
 117
 118   \param app parent application object
 119   \sa activateModule(), deactivateModule()
 120 */
 121 void CAM_Module::initialize( CAM_Application* app )
 122 {
 123   myApp = app;
 124   if ( myApp )
 125   {
 126     SUIT_Session* aSession = SUIT_Session::session();
 127     connect( aSession, SIGNAL( applicationClosed( SUIT_Application* ) ),
 128              this, SLOT( onApplicationClosed( SUIT_Application* ) ) );
 129
 130     connect( myApp, SIGNAL( infoChanged( QString ) ), this, SLOT( onInfoChanged( QString ) ) );
 131   }
 132 }
 133
 134 /*!
 135   \brief Get module icon.
 136   \return module icon pixmap
 137   \sa iconName()
 138 */
 139 QPixmap CAM_Module::moduleIcon() const
 140 {
 141   if ( myIcon.isNull() ) {
 142     QString iname = iconName();
 143     if ( !iname.isEmpty() ) {
 144       CAM_Module* that = (CAM_Module*)this;
 145       that->myIcon = application()->resourceMgr()->loadPixmap( name(), iname, false );
 146     }
 147   }
 148   return myIcon;
 149 }
 150
 151 /*!
 152   \brief Get module icon's name.
 153
 154   This function is used to get module icon's file name.
 155   Default implementation returns empty string.
 156
 157   \return module icon's name.
 158   \sa moduleIcon()
 159 */
 160 QString CAM_Module::iconName() const
 161 {
 162   return application()->moduleIcon( name() );
 163 }
 164
 165 /*!
 166   \brief Get module (internal) name
 167   \return module name
 168   \sa setName(), moduleName(), setModuleName()
 169 */
 170 QString CAM_Module::name() const
 171 {
 172   return objectName();
 173 }
 174
 175 /*!
 176   \brief Get module title (user name)
 177   \return module title
 178   \sa setModuleName(), name(), setName()
 179 */
 180 QString CAM_Module::moduleName() const
 181 {
 182   return myName;
 183 }
 184
 185 /*!
 186   \brief Get data model.
 187
 188   Creates data model, if it is not yet created.
 189
 190   \return data model pointer
 191   \sa createDataModel()
 192 */
 193 CAM_DataModel* CAM_Module::dataModel() const
 194 {
 195   if ( !myDataModel )
 196   {
 197     CAM_Module* that = (CAM_Module*)this;
 198     that->myDataModel = that->createDataModel();
 199     that->myDataModel->initialize();
 200   }
 201   return myDataModel;
 202 }
 203
 204 /*!
 205   \brief Get application.
 206   \return application pointer
 207 */
 208 CAM_Application* CAM_Module::application() const
 209 {
 210   return myApp;
 211 }
 212
 213 /*!
 214   \brief If return false, selection will be cleared at module activation
 215 */
 216 bool CAM_Module::isSelectionCompatible()
 217 {
 218   return false;
 219 }
 220
 221 /*!
 222   \brief Activate module.
 223
 224   This method is called when the user activates module.
 225   Successor classes can use this method to customize module activation process,
 226   for example, to show own menus, toolbars, etc.
 227
 228   Default implementation always returns \c true.
 229
 230   \return \c true if module is activated successfully.
 231   \sa initialize(), deactivateModule()
 232  */
 233 bool CAM_Module::activateModule( SUIT_Study* /*study*/ )
 234 {
 235   // IMN 05/03/2015: we copied myActionMap for reset/unset actions accelerator keys
 236   // after activate/deactivate modules
 237   for ( QMap<QAction*, QKeySequence>::Iterator it = myActionShortcutMap.begin(); it != myActionShortcutMap.end(); ++it )
 238   {
 239     // Reset actions accelerator keys
 240     it.key()->setShortcut( it.value() );
 241   }
 242   myActionShortcutMap.clear();
 243   return true;
 244 }
 245
 246 /*!
 247   \brief Deactivate module.
 248
 249   This method is called when the user deactivates module.
 250   Successor classes can use this method to customize module deactivation process,
 251   for example, to hide own menus, toolbars, etc.
 252
 253   Default implementation always returns \c true.
 254
 255   \return \c true if module is deactivated successfully.
 256   \sa initialize(), activateModule()
 257  */
 258 bool CAM_Module::deactivateModule( SUIT_Study* )
 259 {
 260   // IMN 05/03/2015: we copied myActionMap for reset/unset actions accelerator keys
 261   // after activate/deactivate modules
 262   myActionShortcutMap.clear();
 263   for ( QMap<int, QAction*>::Iterator it = myActionMap.begin(); it != myActionMap.end(); ++it )
 264   {
 265     myActionShortcutMap.insert( it.value(), it.value()->shortcut() );
 266     it.value()->setShortcut( QKeySequence() );
 267   }
 268   return true;
 269 }
 270
 271 /*!
 272   \brief Called when study is closed.
 273
 274   Removes data model from the \a study.
 275
 276   \param study study being closed
 277 */
 278 void CAM_Module::studyClosed( SUIT_Study* study )
 279 {
 280   CAM_Study* camDoc = dynamic_cast<CAM_Study*>( study );
 281   if ( !camDoc )
 282     return;
 283
 284   CAM_DataModel* dm = dataModel();
 285   if ( dm && camDoc->containsDataModel( dm ) ) {
 286     dm->close();
 287     camDoc->removeDataModel( dm );
 288   }
 289 }
 290
 291 /*!
 292   \brief Called when study is changed (obsolete).
 293
 294   Default implementation does nothing.
 295
 296   \param oldStudy old study
 297   \param newStudy new study
 298 */
 299 void CAM_Module::studyChanged( SUIT_Study* /*oldStudy*/, SUIT_Study* /*newStudy*/ )
 300 {
 301 }
 302
 303 /*!
 304   \brief Check if the module is active.
 305   \return \c true if module is active.
 306 */
 307 bool CAM_Module::isActiveModule() const
 308 {
 309   return application() ? application()->activeModule() == this : false;
 310 }
 311
 312 /*!
 313   \brief Put the text message into the status bar of the application main window.
 314
 315   If \a msec > 0, the message will be shown \a msec milliseconds.
 316   If \a msec < 0, the message will be constantly displayed until module is active.
 317
 318   \param msg text message
 319   \param msec message displaying duration in milliseconds
 320 */
 321 void CAM_Module::putInfo( const QString& msg, const int msec )
 322 {
 323   if ( application() )
 324     application()->putInfo( msg, msec );
 325
 326   if ( msec < 0 )
 327     myInfo = msg;
 328 }
 329
 330 /*!
 331     \brief Shows the notifications with spectified text, title and automatic close timeout.
 332     Notification will be automatically closed after specified timeout in msec. If
 333     timeout is zero then automatic closing doesn't performed.
 334     \param text - Notification text
 335     \param title - Notification title
 336     \param timeout - Notification close timeout in msec
 337     \return notification identifier
 338 */
 339 int CAM_Module::showNotification( const QString& message, const QString& title, int timeout )
 340 {
 341   int res = -1;
 342   if ( application() )
 343     res = application()->showNotification( message, title, timeout );
 344   return res;
 345 }
 346
 347 /*!
 348     \brief Closes the notifications with spectified text.
 349     \param text - Notification text
 350 */
 351 void CAM_Module::hideNotification( const QString& message )
 352 {
 353   if ( application() )
 354     application()->hideNotification( message );
 355 }
 356
 357 /*!
 358     \brief Closes the notifications with spectified identifier.
 359     \param text - Notification text
 360 */
 361 void CAM_Module::hideNotification( int id )
 362 {
 363   if ( application() )
 364     application()->hideNotification( id );
 365 }
 366
 367 /*!
 368   \brief Restore message info.
 369
 370   Restores constant text message when previous information status message is removed.
 371
 372   \param txt previous message (being removed)
 373   \sa putInfo()
 374 */
 375 void CAM_Module::onInfoChanged( QString txt )
 376 {
 377   if ( txt.isEmpty() && isActiveModule() && !myInfo.isEmpty() && application() )
 378     application()->putInfo( myInfo );
 379 }
 380
 381 /*!
 382   \brief Called when application is closed.
 383
 384   Nullify application pointer if the application is being closed.
 385
 386   \param theApp application
 387 */
 388 void CAM_Module::onApplicationClosed( SUIT_Application* theApp )
 389 {
 390   if (myApp == theApp)
 391     myApp = NULL;
 392 }
 393
 394 /*!
 395   \brief Create data model.
 396   \return created data model object or 0 if it could not be created
 397 */
 398 CAM_DataModel* CAM_Module::createDataModel()
 399 {
 400   return new CAM_DataModel( this );
 401 }
 402
 403 /*!
 404   \brief Set module (internal) name
 405   \param name new module name
 406   \sa name(), moduleName(), setModuleName()
 407  */
 408 void CAM_Module::setName( const QString& name )
 409 {
 410   setObjectName( name );
 411 }
 412
 413 /*!
 414   \brief Set module title (user name)
 415   \param name new module title
 416   \sa moduleName(), name(), setName()
 417  */
 418 void CAM_Module::setModuleName( const QString& name )
 419 {
 420   myName = name;
 421 }
 422
 423 /*!
 424   \brief Get menu manager.
 425   \return menu manager pointer
 426 */
 427 QtxActionMenuMgr* CAM_Module::menuMgr() const
 428 {
 429   QtxActionMenuMgr* mgr = 0;
 430   if ( application() && application()->desktop() )
 431     mgr = application()->desktop()->menuMgr();
 432   return mgr;
 433 }
 434
 435 /*!
 436   \brief Get toolbar manager.
 437   \return toolbar manager pointer
 438 */
 439 QtxActionToolMgr* CAM_Module::toolMgr() const
 440 {
 441   QtxActionToolMgr* mgr = 0;
 442   if ( application() && application()->desktop() )
 443     mgr = application()->desktop()->toolMgr();
 444   return mgr;
 445 }
 446
 447 /*!
 448   \brief Create toolbar with speicifed \a name.
 449
 450   If the toolbar has been already created, its ID is just returned.
 451
 452   \param title toolbar title
 453   \param name toolbar name (identifier)
 454   \return toolbar ID or -1 if toolbar could not be created
 455 */
 456 int CAM_Module::createTool( const QString& title, const QString& name )
 457 {
 458   if ( !toolMgr() )
 459     return -1;
 460
 461   ActionMgrLocker lock( toolMgr(), !myToolShown );
 462
 463   return toolMgr()->createToolBar( title, name );
 464 }
 465
 466 /*!
 467   \brief Add toolbar item.
 468
 469   Insert action \a to the toolbar manager and register it with specified \a id.
 470   Resulting action ID may differ from the requested one. This can happen if
 471   requested ID is already in use.
 472
 473   If action has been already added previously, its ID is just returned.
 474
 475   If \a id < 0, the action ID is generated automatically.
 476
 477   If \a idx < 0, the action is added to the end of the toolbar.
 478
 479   \param a action
 480   \param tBar toolbar ID
 481   \param id requested action ID
 482   \param idx action index (desired position in the toolbar)
 483   \return action ID or -1 if toolbar item could not be added
 484 */
 485 int CAM_Module::createTool( QAction* a, const int tBar, const int id, const int idx )
 486 {
 487   if ( !toolMgr() )
 488     return -1;
 489
 490   ActionMgrLocker lock( toolMgr(), !myToolShown );
 491
 492   int regId = registerAction( id, a );
 493   int intId = toolMgr()->insert( a, tBar, idx );
 494
 495   if ( !myToolShown )
 496     setToolShown( a, false );
 497
 498   return intId != -1 ? regId : -1;
 499 }
 500
 501 /*!
 502   \brief Add toolbar item.
 503
 504   Insert action \a to the toolbar manager and register it with specified \a id.
 505   Resulting action ID may differ from the requested one. This can happen if
 506   requested ID is already in use.
 507
 508   If action has been already added previously, its ID is just returned.
 509
 510   If \a id < 0, the action ID is generated automatically.
 511
 512   If \a idx < 0, the action is added to the end of the toolbar.
 513
 514   \param a action
 515   \param tBar toolbar name
 516   \param id requested action ID
 517   \param idx action index (desired position in the toolbar)
 518   \return action ID or -1 if toolbar item could not be added
 519 */
 520 int CAM_Module::createTool( QAction* a, const QString& tBar, const int id, const int idx )
 521 {
 522   if ( !toolMgr() )
 523     return -1;
 524
 525   ActionMgrLocker lock( toolMgr(), !myToolShown );
 526
 527   int regId = registerAction( id, a );
 528   int intId = toolMgr()->insert( a, tBar, idx );
 529
 530   if ( !myToolShown )
 531     setToolShown( a, false );
 532
 533   return intId != -1 ? regId : -1;
 534 }
 535
 536 /*!
 537   \brief Add toolbar item.
 538
 539   Insert action with \a id identifier to the toolbar manager.
 540   It is assumed that action has been already registered.
 541
 542   Resulting action ID may differ from the requested one. This can happen if
 543   requested ID is already in use.
 544
 545   If action has been already added previously, its ID is just returned.
 546
 547   If \a idx < 0, the action is added to the end of the toolbar.
 548
 549   \param id action ID
 550   \param tBar toolbar ID
 551   \param idx action index (desired position in the toolbar)
 552   \return action ID or -1 if toolbar item could not be added
 553 */
 554 int CAM_Module::createTool( const int id, const int tBar, const int idx )
 555 {
 556   if ( !toolMgr() )
 557     return -1;
 558
 559   ActionMgrLocker lock( toolMgr(), !myToolShown );
 560
 561   int intId = toolMgr()->insert( action( id ), tBar, idx );
 562
 563   if ( !myToolShown )
 564     setToolShown( action( id ), false );
 565
 566   return intId != -1 ? id : -1;
 567 }
 568
 569 /*!
 570   \brief Add toolbar item.
 571
 572   Insert action with \a id identifier to the toolbar manager.
 573   It is assumed that action has been already registered.
 574
 575   Resulting action ID may differ from the requested one. This can happen if
 576   requested ID is already in use.
 577
 578   If action has been already added previously, its ID is just returned.
 579
 580   If \a idx < 0, the action is added to the end of the toolbar.
 581
 582   \param id action ID
 583   \param tBar toolbar name
 584   \param idx action index (desired position in the toolbar)
 585   \return action ID or -1 if toolbar item could not be added
 586 */
 587 int CAM_Module::createTool( const int id, const QString& tBar, const int idx )
 588 {
 589   if ( !toolMgr() )
 590     return -1;
 591
 592   ActionMgrLocker lock( toolMgr(), !myToolShown );
 593
 594   int intId = toolMgr()->insert( action( id ), tBar, idx );
 595
 596   if ( !myToolShown )
 597     setToolShown( action( id ), false );
 598
 599   return intId != -1 ? id : -1;
 600 }
 601
 602 /*!
 603   \brief Create menu or submenu.
 604
 605   Create main menu or popup submenu and register it with specified \a id.
 606   Resulting action ID may differ from the requested one. This can happen if
 607   requested ID is already in use.
 608
 609   If \a id < 0, the menu ID is generated automatically.
 610   If menu has been already created previously, its ID is just returned.
 611
 612   The \a menu parameter represents the menu name - it could be a sequence
 613   of strings, separated by '|' symbol. For example, "File|Edit" means
 614   File->Edit submenu. If menu doesn't exist, it is created automatically.
 615
 616   Parameter \a idx defines the index of the menu item in the menu group which
 617   is defined by the \a group. If \a idx < 0, the menu/submenu is added to the
 618   end of the menu group.
 619
 620   \param subMenu subMenu name
 621   \param menu parent menu ID
 622   \param id requested menu ID
 623   \param group menu group ID
 624   \param idx menu item index (desired position in the menu group)
 625   \return menu item ID or -1 if menu item could not be added
 626 */
 627 int CAM_Module::createMenu( const QString& subMenu, const int menu,
 628                             const int id, const int group, const int idx, QMenu * menuObj )
 629 {
 630   if ( !menuMgr() )
 631     return -1;
 632
 633   return menuMgr()->insert( subMenu, menu, group, id, idx, menuObj );
 634 }
 635
 636 /*!
 637   \brief Create menu or submenu.
 638
 639   Create main menu or popup submenu and register it with specified \a id.
 640   Resulting action ID may differ from the requested one. This can happen if
 641   requested ID is already in use.
 642
 643   If \a id < 0, the menu ID is generated automatically.
 644   If menu has been already created previously, its ID is just returned.
 645
 646   The \a menu parameter represents the menu name - it could be a sequence
 647   of strings, separated by '|' symbol. For example, "File|Edit" means
 648   File->Edit submenu. If menu doesn't exist, it is created automatically.
 649
 650   Parameter \a idx defines the index of the menu item in the menu group which
 651   is defined by the \a group. If \a idx < 0, the menu/submenu is added to the
 652   end of the menu group.
 653
 654   \param subMenu subMenu name
 655   \param menu parent menu name(s)
 656   \param id requested menu ID
 657   \param group menu group ID
 658   \param idx menu item index (desired position in the menu group)
 659   \return menu item ID or -1 if menu item could not be added
 660 */
 661 int CAM_Module::createMenu( const QString& subMenu, const QString& menu,
 662                             const int id, const int group, const int idx )
 663 {
 664   if ( !menuMgr() )
 665     return -1;
 666
 667   return menuMgr()->insert( subMenu, menu, group, id, idx );
 668 }
 669
 670 /*!
 671   \brief Add menu item.
 672
 673   Insert action \a to the menu manager and register it with specified \a id.
 674   Resulting action ID may differ from the requested one. This can happen if
 675   requested ID is already in use.
 676
 677   If \a id < 0, the action ID is generated automatically.
 678
 679   If action has been already added previously, its ID is just returned.
 680
 681   Parameter \a idx defines the index of the menu item in the menu group which
 682   is defined by the \a group. If \a idx < 0, the action is added to the
 683   end of the menu group.
 684
 685   \param a action
 686   \param menu menu ID
 687   \param id requested action ID
 688   \param group menu group ID
 689   \param idx action index (desired position in the menu group)
 690   \return action ID or -1 if menu item could not be added
 691 */
 692 int CAM_Module::createMenu( QAction* a, const int menu, const int id, const int group, const int idx )
 693 {
 694   if ( !a || !menuMgr() )
 695     return -1;
 696
 697   ActionMgrLocker lock( menuMgr(), !myMenuShown );
 698
 699   int regId = registerAction( id, a );
 700   int intId = menuMgr()->insert( a, menu, group, idx );
 701
 702   if ( !myMenuShown )
 703     setMenuShown( a, false );
 704
 705   return intId != -1 ? regId : -1;
 706 }
 707
 708 /*!
 709   \brief Add menu item.
 710
 711   Insert action \a to the menu manager and register it with specified \a id.
 712   Resulting action ID may differ from the requested one. This can happen if
 713   requested ID is already in use.
 714
 715   If \a id < 0, the action ID is generated automatically.
 716
 717   If action has been already added previously, its ID is just returned.
 718
 719   The \a menu parameter represents the menu name - it could be a sequence
 720   of strings, separated by '|' symbol. For example, "File|Edit" means
 721   File->Edit submenu. If menu doesn't exist, it is created automatically.
 722
 723   Parameter \a idx defines the index of the menu item in the menu group which
 724   is defined by the \a group. If \a idx < 0, the action is added to the
 725   end of the menu group.
 726
 727   \param a action
 728   \param menu menu name(s)
 729   \param id requested action ID
 730   \param group menu group ID
 731   \param idx action index (desired position in the menu group)
 732   \return action ID or -1 if menu item could not be added
 733 */
 734 int CAM_Module::createMenu( QAction* a, const QString& menu, const int id, const int group, const int idx )
 735 {
 736   if ( !a || !menuMgr() )
 737     return -1;
 738
 739   ActionMgrLocker lock( menuMgr(), !myMenuShown );
 740
 741   int regId = registerAction( id, a );
 742   int intId = menuMgr()->insert( a, menu, group, idx );
 743
 744   if ( !myMenuShown )
 745     setMenuShown( a, false );
 746
 747   return intId != -1 ? regId : -1;
 748 }
 749
 750 /*!
 751   \brief Add menu item.
 752
 753   Insert action with \a id identifier to the menu manager.
 754   It is assumed that action has been already registered.
 755
 756   Resulting action ID may differ from the requested one. This can happen if
 757   requested ID is already in use.
 758
 759   If action has been already added previously, its ID is just returned.
 760
 761   Parameter \a idx defines the index of the menu item in the menu group which
 762   is defined by the \a group. If \a idx < 0, the action is added to the
 763   end of the menu group.
 764
 765   \param id action ID
 766   \param menu menu ID
 767   \param group menu group ID
 768   \param idx action index (desired position in the menu group)
 769   \return action ID or -1 if menu item could not be added
 770 */
 771 int CAM_Module::createMenu( const int id, const int menu, const int group, const int idx )
 772 {
 773   if ( !menuMgr() )
 774     return -1;
 775
 776   ActionMgrLocker lock( menuMgr(), !myMenuShown );
 777
 778   int intId = menuMgr()->insert( action( id ), menu, group, idx );
 779
 780   if ( !myMenuShown )
 781     setMenuShown( action( id ), false );
 782
 783   return intId != -1 ? id : -1;
 784 }
 785
 786 /*!
 787   \brief Add menu item.
 788
 789   Insert action with \a id identifier to the menu manager.
 790   It is assumed that action has been already registered.
 791
 792   Resulting action ID may differ from the requested one. This can happen if
 793   requested ID is already in use.
 794
 795   If action has been already added previously, its ID is just returned.
 796
 797   The \a menu parameter represents the menu name - it could be a sequence
 798   of strings, separated by '|' symbol. For example, "File|Edit" means
 799   File->Edit submenu. If menu doesn't exist, it is created automatically.
 800
 801   Parameter \a idx defines the index of the menu item in the menu group which
 802   is defined by the \a group. If \a idx < 0, the action is added to the
 803   end of the menu group.
 804
 805   \param id action ID
 806   \param menu menu name(s)
 807   \param group menu group ID
 808   \param idx action index (desired position in the menu group)
 809   \return action ID or -1 if menu item could not be added
 810 */
 811 int CAM_Module::createMenu( const int id, const QString& menu, const int group, const int idx )
 812 {
 813   if ( !menuMgr() )
 814     return -1;
 815
 816   ActionMgrLocker lock( menuMgr(), !myMenuShown );
 817
 818   int intId = menuMgr()->insert( action( id ), menu, group, idx );
 819
 820   if ( !myMenuShown )
 821     setMenuShown( action( id ), false );
 822
 823   return intId != -1 ? id : -1;
 824 }
 825
 826 /*!
 827   \brief Show/hide all module's menus.
 828   \param on if \c true, show menus, otherwise, hide all menus
 829   \sa setToolShown()
 830 */
 831 void CAM_Module::setMenuShown( const bool on )
 832 {
 833   myMenuShown = on;
 834
 835   QtxActionMenuMgr* mMgr = menuMgr();
 836   if ( !mMgr )
 837     return;
 838
 839   bool upd = mMgr->isUpdatesEnabled();
 840   mMgr->setUpdatesEnabled( false );
 841
 842   QAction* sep = separator();
 843   for ( QMap<int, QAction*>::Iterator it = myActionMap.begin(); it != myActionMap.end(); ++it )
 844   {
 845     if ( it.value() != sep )
 846       mMgr->setShown( mMgr->actionId( it.value() ), on );
 847   }
 848
 849   mMgr->setUpdatesEnabled( upd );
 850   if ( upd )
 851     mMgr->update();
 852 }
 853
 854 /*!
 855   \brief Show/hide specified menu item.
 856   \param a action
 857   \param on if \c true, show menu item, otherwise, hide it
 858 */
 859 void CAM_Module::setMenuShown( QAction* a, const bool on )
 860 {
 861   if ( menuMgr() )
 862     menuMgr()->setShown( menuMgr()->actionId( a ), on );
 863 }
 864
 865 /*!
 866   \brief Show/hide specified menu item.
 867   \param id menu item ID
 868   \param on if \c true, show menu item, otherwise, hide it
 869 */
 870 void CAM_Module::setMenuShown( const int id, const bool on )
 871 {
 872   setMenuShown( action( id ), on );
 873 }
 874
 875 /*!
 876   \brief Show/hide all module's toolbars.
 877   \param on if \c true, show toolbars, otherwise, hide all toolbars
 878   \sa setMenuShown()
 879 */
 880 void CAM_Module::setToolShown( const bool on )
 881 {
 882   myToolShown = on;
 883
 884   QtxActionToolMgr* tMgr = toolMgr();
 885   if ( !tMgr )
 886     return;
 887
 888   bool upd = tMgr->isUpdatesEnabled();
 889   tMgr->setUpdatesEnabled( false );
 890
 891   QAction* sep = separator();
 892   for ( QMap<int, QAction*>::Iterator it = myActionMap.begin(); it != myActionMap.end(); ++it )
 893   {
 894     if ( it.value() != sep )
 895       tMgr->setShown( tMgr->actionId( it.value() ), on );
 896   }
 897
 898   tMgr->setUpdatesEnabled( upd );
 899   if ( upd )
 900     tMgr->update();
 901 }
 902
 903 /*!
 904   \brief Show/hide specified toolbar item.
 905   \param a action
 906   \param on if \c true, show toolbar item, otherwise, hide it
 907 */
 908 void CAM_Module::setToolShown( QAction* a, const bool on )
 909 {
 910   if ( toolMgr() )
 911     toolMgr()->setShown( toolMgr()->actionId( a ), on );
 912 }
 913
 914 /*!
 915   \brief Show/hide specified toolbar item.
 916   \param id toolbar item ID
 917   \param on if \c true, show toolbar item, otherwise, hide it
 918 */
 919 void CAM_Module::setToolShown( const int id, const bool on )
 920 {
 921   setToolShown( action( id ), on );
 922 }
 923
 924 /*!
 925   \brief Get action by specified \a id.
 926   \param id action ID
 927   \return action or 0 if not found
 928 */
 929 QAction* CAM_Module::action( const int id ) const
 930 {
 931   QAction* a = 0;
 932   if ( myActionMap.contains( id ) )
 933     a = myActionMap[id];
 934   else if ( menuMgr() ) {
 935     QMenu* m = menuMgr()->findMenu( id );
 936     if ( m ) a = m->menuAction();
 937   }
 938   return a;
 939 }
 940
 941 /*!
 942   \brief Get action ID.
 943   \param a action
 944   \return action ID or -1 if not found
 945 */
 946 int CAM_Module::actionId( const QAction* a ) const
 947 {
 948   int id = -1;
 949   for ( QMap<int, QAction*>::ConstIterator it = myActionMap.begin(); it != myActionMap.end() && id == -1; ++it )
 950   {
 951     if ( it.value() == a )
 952       id = it.key();
 953   }
 954   return id;
 955 }
 956
 957 /*!
 958   \brief Create new instance of QtxAction and register action with specified \a id.
 959
 960   Resulting action ID may differ from the requested one. This can happen if
 961   requested ID is already in use.
 962
 963   If \a id < 0, the action ID is generated automatically.
 964
 965   \param id required action ID
 966   \param text tooltip text
 967   \param icon action icon
 968   \param menu menu text
 969   \param tip status bar tip
 970   \param key keyboard accelerator
 971   \param parent parent object
 972   \param toggle if \c true, the action will be toggled
 973   \param reciever action activation signal receiver object
 974   \param member action activation signal receiver slot
 975 */
 976 QAction* CAM_Module::createAction( const int id, const QString& text, const QIcon& icon,
 977                                    const QString& menu, const QString& tip, const int key,
 978                                    QObject* parent, const bool toggle, QObject* reciever,
 979                                    const char* member, const QString& shortcutAction )
 980 {
 981   return createAction( id, text, icon, menu, tip, QKeySequence(key), parent, toggle, reciever, member, shortcutAction );
 982 }
 983
 984 /*!
 985   \brief Create new instance of QtxAction and register action with specified \a id.
 986
 987   Resulting action ID may differ from the requested one. This can happen if
 988   requested ID is already in use.
 989
 990   If \a id < 0, the action ID is generated automatically.
 991
 992   \param id required action ID
 993   \param text tooltip text
 994   \param icon action icon
 995   \param menu menu text
 996   \param tip status bar tip
 997   \param key keyboard accelerator
 998   \param parent parent object
 999   \param toggle if \c true, the action will be toggled
1000   \param reciever action activation signal receiver object
1001   \param member action activation signal receiver slot
1002 */
1003 QAction* CAM_Module::createAction( const int id, const QString& text, const QIcon& icon,
1004                                    const QString& menu, const QString& tip, const QKeySequence& key,
1005                                    QObject* parent, const bool toggle, QObject* reciever,
1006                                    const char* member, const QString& shortcutAction )
1007 {
1008   QtxAction* a = new QtxAction( text, icon, menu, key, parent, toggle, shortcutAction );
1009   a->setStatusTip( tip );
1010
1011   if ( reciever && member )
1012     connect( a, SIGNAL( triggered( bool ) ), reciever, member );
1013
1014   registerAction( id, a );
1015
1016   return a;
1017 }
1018
1019 /*!
1020   \brief Create new action group.
1021   \param id action group ID
1022   \param exclusive \c true for exclusive action group
1023   \return created action group
1024 */
1025 QtxActionGroup* CAM_Module::createActionGroup( const int id, const bool exclusive )
1026 {
1027   QtxActionGroup* a = qobject_cast<QtxActionGroup*>( action( id ) );
1028   if ( !a ) {
1029     a = new QtxActionGroup( this );
1030     registerAction( id, a );
1031   }
1032   a->setExclusive( exclusive );
1033   return a;
1034 }
1035
1036 /*!
1037   \brief Register action in the internal action map.
1038
1039   If action has been already added previously, its ID is just returned.
1040   If \a id < 0, the action ID is generated automatically.
1041
1042   \param id action required ID
1043   \param a action
1044   \return action ID
1045 */
1046 int CAM_Module::registerAction( const int id, QAction* a )
1047 {
1048   int ident = -1;
1049   for ( QMap<int, QAction*>::ConstIterator it = myActionMap.begin(); it != myActionMap.end() && ident == -1; ++it )
1050     if ( it.value() == a )
1051       ident = it.key();
1052
1053   if ( ident != -1 )
1054     return ident;
1055
1056   static int generatedId = -1;
1057   ident = id < 0 ? --generatedId : id;
1058
1059   myActionMap.insert( ident, a );
1060
1061   if ( menuMgr() )
1062     menuMgr()->registerAction( a );
1063
1064   if ( toolMgr() )
1065     toolMgr()->registerAction( a );
1066
1067   if ( application() && application()->desktop() &&
1068        a->shortcutContext() != Qt::WidgetShortcut &&
1069        a->shortcutContext() != Qt::WidgetWithChildrenShortcut )
1070     application()->desktop()->addAction( a );
1071
1072   return ident;
1073 }
1074
1075 /*!
1076   \brief Unregister action from the internal action map.
1077
1078   \param id action ID
1079   \return \c true on success or \c false if action is in use
1080 */
1081 bool CAM_Module::unregisterAction( const int id )
1082 {
1083   return unregisterAction( action( id ) );
1084 }
1085
1086 /*!
1087   \brief Unregister action from the internal action map.
1088
1089   \param a action
1090   \return \c true on success or \c false if action is in use
1091 */
1092 bool CAM_Module::unregisterAction( QAction* a )
1093 {
1094   if ( !a )
1095     return false;
1096   if ( menuMgr() ) {
1097     int id = menuMgr()->actionId( a );
1098     if ( id != -1 && menuMgr()->containsMenu( id, -1 ) )
1099       return false;
1100   }
1101   if ( toolMgr() ) {
1102     int id = toolMgr()->actionId( a );
1103     if ( id != -1 && toolMgr()->containsAction( id ) )
1104       return false;
1105   }
1106   if ( menuMgr() )
1107     menuMgr()->unRegisterAction( menuMgr()->actionId( a ) );
1108   if ( toolMgr() )
1109     toolMgr()->unRegisterAction( toolMgr()->actionId( a ) );
1110   return true;
1111 }
1112
1113 /*!
1114   \brief Create separator action.
1115
1116   Separator action can be used in menus or toolbars.
1117
1118   \return new separator action
1119 */
1120 QAction* CAM_Module::separator()
1121 {
1122   return QtxActionMgr::separator();
1123 }
1124
1125 /*!
1126   \brief Update visibility state of the module objects.
1127 */
1128 void CAM_Module::updateModuleVisibilityState() {
1129
1130 }
1131
1132 /*!
1133   \brief Activate GUI operation of module by its ID.
1134   This method is called from CAM_Application::startOperation().
1135   \param actionId is a numerical unique operation id.
1136 */
1137 bool CAM_Module::activateOperation( int actionId )
1138 {
1139   return false;
1140 }
1141
1142 /*!
1143   \brief Activate GUI operation of module by its ID.
1144   This method is called from CAM_Application::startOperation().
1145   \param actionId is a string unique operation id.
1146 */
1147 bool CAM_Module::activateOperation( const QString& actionId )
1148 {
1149   return false;
1150 }
1151
1152 /*!
1153   \brief Activate GUI operation of module by its ID and \a pluginName.
1154   This method is called from CAM_Application::startOperation().
1155   \param actionId is a string unique operation id.
1156   \param pluginName is a name of a plugin where the operation is implemented.
1157 */
1158 bool CAM_Module::activateOperation( const QString& actionId, const QString& pluginName )
1159 {
1160   return false;
1161 }
1162
1163
1164 /*!
1165   \brief Connect data model of the module to the active study
1166   \param camStudy CAM study object
1167 */
1168 void CAM_Module::connectToStudy( CAM_Study* camStudy )
1169 {
1170   CAM_Application* app = camStudy ? dynamic_cast<CAM_Application*>( camStudy->application() ) : 0;
1171   if( !app )
1172     return;
1173
1174   CAM_DataModel* prev = 0;
1175   CAM_Application::ModuleList mods = app->modules();
1176   for( QList<CAM_Module*>::const_iterator it = mods.begin(); it != mods.end(); ++it )
1177   {
1178     CAM_DataModel* dm = (*it)->dataModel();
1179     if( (*it) == this && !camStudy->containsDataModel( dm ) )
1180     {
1181       if ( prev )
1182         camStudy->insertDataModel( (*it)->dataModel(), prev );
1183       else
1184         camStudy->insertDataModel( (*it)->dataModel(), 0 );
1185     }
1186     prev = dm;
1187   }
1188 }
1189
1190 /*!
1191   \fn void CAM_Module::contextMenuPopup( const QString& type, QMenu* menu, QString& title );
1192   \brief Create context popup menu.
1193   \param type popup menu context
1194   \param menu popup menu
1195   \param title popup menu title, which can be set by the module if required
1196 */
1197
1198 /*!
1199   \fn void CAM_Module::updateCommandsStatus();
1200   \brief Update menu/toolbar actions.
1201 */
1202
1203
1204 bool CAM_Module::abortAllOperations()
1205 {
1206   return true;
1207 }