src/SUIT/SUIT_Application.cxx

   1 // Copyright (C) 2007-2014  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 "SUIT_Application.h"
  24
  25 #include "SUIT_Study.h"
  26 #include "SUIT_Session.h"
  27 #include "SUIT_Desktop.h"
  28 #include "SUIT_ResourceMgr.h"
  29 #include "SUIT_ShortcutMgr.h"
  30
  31 #include <QTimer>
  32 #include <QLabel>
  33 #include <QStatusBar>
  34 #include <QApplication>
  35 #include <QSize>
  36
  37 #include <QtxAction.h>
  38 #include <QtxActionMenuMgr.h>
  39 #include <QtxActionToolMgr.h>
  40
  41
  42 /*!
  43   \class StatusLabel
  44   \brief Status bar customization label. Used to workaroubd desktop resizing bug.
  45   \internal
  46 */
  47 class StatusLabel : public QLabel
  48 {
  49 public:
  50   StatusLabel( QWidget* parent ) : QLabel( parent ) {}
  51   QSize minimumSizeHint () const { return QSize( 0, QLabel::minimumSizeHint().height() ); }
  52 };
  53
  54 /*!
  55   Default constructor
  56 */
  57 SUIT_Application::SUIT_Application()
  58 : QObject( 0 ),
  59   myStudy( 0 ),
  60   myDesktop( 0 ),
  61   myStatusLabel( 0 )
  62 {
  63   if ( SUIT_Session::session() )
  64     SUIT_Session::session()->insertApplication( this );
  65 }
  66
  67 /*!
  68   Destructor
  69 */
  70 SUIT_Application::~SUIT_Application()
  71 {
  72   SUIT_Study* s = myStudy;
  73   setActiveStudy( 0 );
  74   delete s;
  75
  76   setDesktop( 0 );
  77 }
  78
  79 /*!
  80   \return main window of application (desktop)
  81 */
  82 SUIT_Desktop* SUIT_Application::desktop()
  83 {
  84   return myDesktop;
  85 }
  86
  87 /*!
  88    \return FALSE if application can not be closed (because of non saved data for example).
  89    This method called by SUIT_Session whin closing of application was requested.
  90 */
  91 bool SUIT_Application::isPossibleToClose( bool& )
  92 {
  93   return true;
  94 }
  95
  96 /*!
  97   Performs some finalization of life cycle of this application.
  98   For instance, the application can force its documents(s) to close.
  99 */
 100 void SUIT_Application::closeApplication()
 101 {
 102   emit applicationClosed( this );
 103 }
 104
 105 /*!
 106   \return active Study. If Application supports wirking with several studies this method should be redefined
 107 */
 108 SUIT_Study* SUIT_Application::activeStudy() const
 109 {
 110   return myStudy;
 111 }
 112
 113 /*!
 114   \return version of application
 115 */
 116 QString SUIT_Application::applicationVersion() const
 117 {
 118   return QString();
 119 }
 120
 121 /*!
 122   Shows the application's main widget. For non GUI application must be redefined.
 123 */
 124 void SUIT_Application::start()
 125 {
 126   if ( desktop() )
 127     desktop()->show();
 128
 129   // Initialize shortcut manager
 130   SUIT_ShortcutMgr::Init();
 131 }
 132
 133 /*!
 134   Opens document into active Study. If Study is empty - creates it.
 135   \param theFileName - name of document file
 136 */
 137 bool SUIT_Application::useFile( const QString& theFileName )
 138 {
 139   createEmptyStudy();
 140   SUIT_Study* study = activeStudy();
 141
 142   bool status = study ? study->openDocument( theFileName ) : false;
 143
 144   if ( !status )
 145   {
 146     setActiveStudy( 0 );
 147     delete study;
 148   }
 149
 150   return status;
 151 }
 152
 153 /*!
 154   Creates new empty Study if active Study = 0
 155 */
 156 void SUIT_Application::createEmptyStudy()
 157 {
 158   if ( !activeStudy() )
 159     setActiveStudy( createNewStudy() );
 160 }
 161
 162 /*!
 163   \return number of Studies.
 164   Must be redefined in Applications which support several studies for one Application instance.
 165 */
 166 int SUIT_Application::getNbStudies() const
 167 {
 168   return activeStudy() ? 1 : 0;
 169 }
 170
 171 /*!
 172   \return global resource manager
 173 */
 174 SUIT_ResourceMgr* SUIT_Application::resourceMgr() const
 175 {
 176   if ( !SUIT_Session::session() )
 177     return 0;
 178
 179   return SUIT_Session::session()->resourceMgr();
 180 }
 181
 182 /*!
 183   \brief Get access to shortcut manager.
 184   \return global shortcut manager
 185 */
 186 SUIT_ShortcutMgr* SUIT_Application::shortcutMgr() const
 187 {
 188   return SUIT_ShortcutMgr::getShortcutMgr();
 189 }
 190
 191 #define DEFAULT_MESSAGE_DELAY 3000
 192
 193 /*!
 194   Puts the message to the status bar
 195   \param msg - text of message
 196   \param msec - time in milliseconds, after that the status label will be cleared
 197 */
 198 void SUIT_Application::putInfo( const QString& msg, const int msec )
 199 {
 200   if ( !desktop() )
 201     return;
 202
 203   if ( !myStatusLabel )
 204   {
 205     myStatusLabel = new StatusLabel( desktop()->statusBar() );
 206     desktop()->statusBar()->addWidget( myStatusLabel, 1 );
 207     myStatusLabel->show();
 208   }
 209
 210   QString prev = myStatusLabel->text();
 211
 212   myStatusLabel->setText( msg );
 213   if ( msec != -1 )
 214     QTimer::singleShot( msec <= 0 ? DEFAULT_MESSAGE_DELAY : msec, this, SLOT( onInfoClear() ) );
 215
 216   if ( prev != msg )
 217     emit infoChanged( msg );
 218 }
 219
 220 /*!
 221   Clear the information label in status bar after delay.
 222 */
 223 void SUIT_Application::onInfoClear()
 224 {
 225   if ( !myStatusLabel )
 226     return;
 227
 228   bool changed = !myStatusLabel->text().isEmpty();
 229   myStatusLabel->clear();
 230   if ( changed )
 231     emit infoChanged( QString() );
 232 }
 233
 234 /*!
 235   Update status of the registerd actions
 236 */
 237 void SUIT_Application::updateCommandsStatus()
 238 {
 239 }
 240
 241 /*!
 242   Initialize with application arguments
 243   \param argc - number of application arguments
 244   \param argv - array of application arguments
 245 */
 246 SUIT_Application* SUIT_Application::startApplication( int argc, char** argv ) const
 247 {
 248   return startApplication( objectName(), argc, argv );
 249 }
 250
 251 /*!
 252   Initialize with application name and arguments
 253   \param name - name of application
 254   \param argc - number of application arguments
 255   \param argv - array of application arguments
 256 */
 257 SUIT_Application* SUIT_Application::startApplication( const QString& name, int argc, char** argv ) const
 258 {
 259   SUIT_Session* session = SUIT_Session::session();
 260   if ( !session )
 261     return 0;
 262
 263   return session->startApplication( name, argc, argv );
 264 }
 265
 266 /*!
 267   Sets the main window of application
 268   \param desk - new main window (desktop)
 269 */
 270 void SUIT_Application::setDesktop( SUIT_Desktop* desk )
 271 {
 272   if ( myDesktop == desk )
 273     return;
 274
 275   // >> VSR 09/06/2009: workaround about the Qt 4.5.0 bug: SIGSEGV on desktop delete
 276   myDesktop->deleteLater(); // delete myDesktop;
 277   // << VSR 09/06/2009
 278   myDesktop = desk;
 279   if ( myDesktop ) {
 280     connect( myDesktop, SIGNAL( activated() ), this, SLOT( onDesktopActivated() ) );
 281     // Force desktop activation (NPAL16628)
 282     QApplication::postEvent(myDesktop, new QEvent(QEvent::WindowActivate));
 283   }
 284 }
 285
 286 /*!
 287   Creates new instance of study.
 288   By default, it is called from createEmptyStudy()
 289   \sa createEmptyStudy()
 290 */
 291 SUIT_Study* SUIT_Application::createNewStudy()
 292 {
 293   return new SUIT_Study( this );
 294 }
 295
 296 /*!
 297   Sets study as active
 298   \param study - instance of study to be set as active
 299 */
 300 void SUIT_Application::setActiveStudy( SUIT_Study* study )
 301 {
 302   if ( myStudy == study )
 303     return;
 304
 305   if ( myStudy )
 306     disconnect( myStudy, SIGNAL( studyModified( SUIT_Study* ) ),
 307                 this, SLOT( updateCommandsStatus() ) );
 308   if ( study )
 309     connect( study, SIGNAL( studyModified( SUIT_Study* ) ),
 310              this, SLOT( updateCommandsStatus() ) );
 311
 312   myStudy = study;
 313 }
 314
 315 /*!
 316   Creates new toolbar
 317   \return identificator of new toolbar in tool manager
 318   \param name - name of new toolbar
 319 */
 320 int SUIT_Application::createTool( const QString& name )
 321 {
 322   if ( !desktop() || !desktop()->toolMgr() )
 323     return -1;
 324
 325   return desktop()->toolMgr()->createToolBar( name );
 326 }
 327
 328 /*!
 329   Creates new toolbutton
 330   \return SUIT identificator of new action
 331   \param a - action
 332   \param tBar - identificator of toolbar
 333   \param id - proposed SUIT identificator of action (if it is -1, then must be use any free)
 334   \param idx - index in toolbar
 335 */
 336 int SUIT_Application::createTool( QAction* a, const int tBar, const int id, const int idx )
 337 {
 338   if ( !desktop() || !desktop()->toolMgr() )
 339     return -1;
 340
 341   int regId = registerAction( id, a );
 342   int intId = desktop()->toolMgr()->insert( a, tBar, idx );
 343   return intId != -1 ? regId : -1;
 344 }
 345
 346 /*!
 347   Creates new toolbutton
 348   \return SUIT identificator of new action
 349   \param a - action
 350   \param tBar - name of toolbar
 351   \param id - proposed SUIT identificator of action (if it is -1, then must be use any free)
 352   \param idx - index in toolbar
 353 */
 354 int SUIT_Application::createTool( QAction* a, const QString& tBar, const int id, const int idx )
 355 {
 356   if ( !desktop() || !desktop()->toolMgr() )
 357     return -1;
 358
 359   int regId = registerAction( id, a );
 360   int intId = desktop()->toolMgr()->insert( a, tBar, idx );
 361   return intId != -1 ? regId : -1;
 362 }
 363
 364 /*!
 365   Creates new toolbutton
 366   \return "id" if all right or -1 otherwise
 367   \param id - SUIT identificator of action
 368   \param tBar - identificator of toolbar
 369   \param idx - index in toolbar
 370 */
 371 int SUIT_Application::createTool( const int id, const int tBar, const int idx )
 372 {
 373   if ( !desktop() || !desktop()->toolMgr() )
 374     return -1;
 375
 376   int intId = desktop()->toolMgr()->insert( action( id ), tBar, idx );
 377   return intId != -1 ? id : -1;
 378 }
 379
 380 /*!
 381   Creates new toolbutton
 382   \return "id" if all right or -1 otherwise
 383   \param id - SUIT identificator of action
 384   \param tBar - name of toolbar
 385   \param idx - index in toolbar
 386 */
 387 int SUIT_Application::createTool( const int id, const QString& tBar, const int idx )
 388 {
 389   if ( !desktop() || !desktop()->toolMgr() )
 390     return -1;
 391
 392   int intId = desktop()->toolMgr()->insert( action( id ), tBar, idx );
 393   return intId != -1 ? id : -1;
 394 }
 395
 396 /*!
 397   Creates new menu item
 398   \return identificator of new action in menu manager
 399   \param subMenu - menu text of new item
 400   \param menu - identificator of parent menu item
 401   \param id - proposed identificator of action
 402   \param group - group in menu manager
 403   \param index - index in menu
 404 */
 405 int SUIT_Application::createMenu( const QString& subMenu, const int menu,
 406                                   const int id, const int group, const int index )
 407 {
 408   if ( !desktop() || !desktop()->menuMgr() )
 409     return -1;
 410
 411   return desktop()->menuMgr()->insert( subMenu, menu, group, id, index );
 412 }
 413
 414 /*!
 415   Creates new menu item
 416   \return identificator of new action in menu manager
 417   \param subMenu - menu text of new item
 418   \param menu - menu text of parent menu item
 419   \param id - proposed identificator of action
 420   \param group - group in menu manager
 421   \param index - index in menu
 422 */
 423 int SUIT_Application::createMenu( const QString& subMenu, const QString& menu,
 424                                   const int id, const int group, const int index )
 425 {
 426   if ( !desktop() || !desktop()->menuMgr() )
 427     return -1;
 428
 429   return desktop()->menuMgr()->insert( subMenu, menu, group, id, index );
 430 }
 431
 432 /*!
 433   Creates new menu item
 434   \return SUIT identificator of new action
 435   \param a - action
 436   \param menu - identificator of parent menu item
 437   \param id - proposed SUIT identificator of action
 438   \param group - group in menu manager
 439   \param index - index in menu
 440 */
 441 int SUIT_Application::createMenu( QAction* a, const int menu, const int id, const int group, const int index )
 442 {
 443   if ( !a || !desktop() || !desktop()->menuMgr() )
 444     return -1;
 445
 446   int regId = registerAction( id, a );
 447   int intId = desktop()->menuMgr()->insert( a, menu, group, index );
 448   return intId != -1 ? regId : -1;
 449 }
 450
 451 /*!
 452   Creates new menu item
 453   \return SUIT identificator of new action
 454   \param a - action
 455   \param menu - menu text of parent menu item
 456   \param id - proposed SUIT identificator of action
 457   \param group - group in menu manager
 458   \param index - index in menu
 459 */
 460 int SUIT_Application::createMenu( QAction* a, const QString& menu, const int id, const int group, const int index )
 461 {
 462   if ( !a || !desktop() || !desktop()->menuMgr() )
 463     return -1;
 464
 465   int regId = registerAction( id, a );
 466   int intId = desktop()->menuMgr()->insert( a, menu, group, index );
 467   return intId != -1 ? regId : -1;
 468 }
 469
 470 /*!
 471   Creates new menu item
 472   \return identificator of new action in menu manager
 473   \param id - SUIT identificator of action
 474   \param menu - menu text of parent menu item
 475   \param group - group in menu manager
 476   \param index - index in menu
 477 */
 478 int SUIT_Application::createMenu( const int id, const int menu, const int group, const int index )
 479 {
 480   if ( !desktop() || !desktop()->menuMgr() )
 481     return -1;
 482
 483   int intId = desktop()->menuMgr()->insert( action( id ), menu, group, index );
 484   return intId != -1 ? id : -1;
 485 }
 486
 487 /*!
 488   Creates new menu item
 489   \return identificator of new action in menu manager
 490   \param id - SUIT identificator of action
 491   \param menu - menu text of parent menu item
 492   \param group - group in menu manager
 493   \param index - index in menu
 494 */
 495 int SUIT_Application::createMenu( const int id, const QString& menu, const int group, const int index )
 496 {
 497   if ( !desktop() || !desktop()->menuMgr() )
 498     return -1;
 499
 500   int intId = desktop()->menuMgr()->insert( action( id ), menu, group, index );
 501   return intId != -1 ? id : -1;
 502 }
 503
 504 /*!
 505   Show/hide menu item corresponding to action
 506   \param a - action
 507   \param on - if it is true, the item will be shown, otherwise it will be hidden
 508 */
 509 void SUIT_Application::setMenuShown( QAction* a, const bool on )
 510 {
 511   if ( !a || !desktop() )
 512     return;
 513
 514   QtxActionMenuMgr* mMgr = desktop()->menuMgr();
 515   if ( mMgr )
 516     mMgr->setShown( mMgr->actionId( a ), on );
 517 }
 518
 519 /*!
 520   Show/hide menu item corresponding to action
 521   \param id - identificator of action in menu manager
 522   \param on - if it is true, the item will be shown, otherwise it will be hidden
 523 */
 524 void SUIT_Application::setMenuShown( const int id, const bool on )
 525 {
 526   setMenuShown( action( id ), on );
 527 }
 528
 529 /*!
 530   Show/hide tool button corresponding to action
 531   \param a - action
 532   \param on - if it is true, the button will be shown, otherwise it will be hidden
 533 */
 534 void SUIT_Application::setToolShown( QAction* a, const bool on )
 535 {
 536   if ( !a || !desktop() )
 537     return;
 538
 539   QtxActionToolMgr* tMgr = desktop()->toolMgr();
 540   if ( tMgr )
 541     tMgr->setShown( tMgr->actionId( a ), on );
 542 }
 543
 544 /*!
 545   Show/hide menu item corresponding to action
 546   \param id - identificator of action in tool manager
 547   \param on - if it is true, the button will be shown, otherwise it will be hidden
 548 */
 549 void SUIT_Application::setToolShown( const int id, const bool on )
 550 {
 551   setToolShown( action( id ), on );
 552 }
 553
 554 /*!
 555   Show/hide both menu item and tool button corresponding to action
 556   \param a - action
 557   \param on - if it is true, the item will be shown, otherwise it will be hidden
 558 */
 559 void SUIT_Application::setActionShown( QAction* a, const bool on )
 560 {
 561   setMenuShown( a, on );
 562   setToolShown( a, on );
 563 }
 564
 565 /*!
 566   Show/hide both menu item and tool button corresponding to action
 567   \param id - identificator in both menu manager and tool manager
 568   \param on - if it is true, the item will be shown, otherwise it will be hidden
 569 */
 570 void SUIT_Application::setActionShown( const int id, const bool on )
 571 {
 572   setMenuShown( id, on );
 573   setToolShown( id, on );
 574 }
 575
 576 /*!
 577   \return action by it's SUIT identificator
 578   \param id - SUIT identificator
 579 */
 580 QAction* SUIT_Application::action( const int id ) const
 581 {
 582   QAction* a = 0;
 583   if ( myActionMap.contains( id ) )
 584     a = myActionMap[id];
 585   return a;
 586 }
 587
 588 /*!
 589   \return SUIT identificator of action
 590   \param a - action
 591 */
 592 int SUIT_Application::actionId( const QAction* a ) const
 593 {
 594   int id = -1;
 595   for ( QMap<int, QAction*>::ConstIterator it = myActionMap.begin(); it != myActionMap.end() && id == -1; ++it )
 596   {
 597     if ( it.value() == a )
 598       id = it.key();
 599   }
 600   return id;
 601 }
 602
 603 QList<QAction*> SUIT_Application::actions() const
 604 {
 605   return myActionMap.values();
 606 }
 607
 608 QList<int> SUIT_Application::actionIds() const
 609 {
 610   return myActionMap.keys();
 611 }
 612
 613 /*!
 614   Creates action and registers it both in menu manager and tool manager
 615   \return new instance of action
 616   \param id - proposed SUIT identificator
 617   \param text - description
 618   \param icon - icon for toolbar
 619   \param menu - menu text
 620   \param tip - tool tip
 621   \param key - shortcut
 622   \param parent - parent object
 623   \param toggle - if it is TRUE the action will be a toggle action, otherwise it will be a command action
 624   \param reciever - object that contains slot
 625   \param member - slot to be called when action is activated
 626 */
 627 QAction* SUIT_Application::createAction( const int id, const QString& text, const QIcon& icon,
 628                                          const QString& menu, const QString& tip, const int key,
 629                                          QObject* parent, const bool toggle, QObject* reciever,
 630                                          const char* member, const QString& shortcutAction )
 631 {
 632   QtxAction* a = new QtxAction( text, icon, menu, key, parent, toggle, shortcutAction );
 633   a->setStatusTip( tip );
 634
 635   if ( reciever && member )
 636     connect( a, SIGNAL( triggered( bool ) ), reciever, member );
 637
 638   registerAction( id, a );
 639
 640   return a;
 641 }
 642
 643 /*!
 644   Registers action both in menu manager and tool manager
 645   \param id - proposed SUIT identificator (if it is -1, auto generated one is used)
 646   \param a - action
 647 */
 648 int SUIT_Application::registerAction( const int id, QAction* a )
 649 {
 650   int ident = actionId( a );
 651   if ( ident != -1 )
 652     return ident;
 653
 654   static int generatedId = -1;
 655   ident = id == -1 ? --generatedId : id;
 656
 657   if ( action( ident ) )
 658     qWarning( "Action registration id is already in use: %d", ident );
 659
 660   myActionMap.insert( ident, a );
 661
 662   if ( desktop() && desktop()->menuMgr() )
 663     desktop()->menuMgr()->registerAction( a );
 664
 665   if ( desktop() && desktop()->toolMgr() )
 666     desktop()->toolMgr()->registerAction( a );
 667
 668   if ( desktop() )
 669     desktop()->addAction( a );
 670
 671   return ident;
 672 }
 673
 674 /*!
 675   \return global action used as separator
 676 */
 677 QAction* SUIT_Application::separator()
 678 {
 679   return QtxActionMgr::separator();
 680 }
 681
 682 /*!
 683   SLOT: it is called when desktop is activated
 684 */
 685
 686 void SUIT_Application::onDesktopActivated()
 687 {
 688   emit activated( this );
 689 }
 690
 691 /*!
 692   SLOT: is used for Help browsing
 693 */
 694 void SUIT_Application::onHelpContextModule( const QString& /*theComponentName*/,
 695                                             const QString& /*theFileName*/,
 696                                             const QString& /*theContext*/ )
 697 {
 698 }