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 title - title of new toolbar
 319   \param name - name (identifier) of new toolbar
 320 */
 321 int SUIT_Application::createTool( const QString& title, const QString& name )
 322 {
 323   if ( !desktop() || !desktop()->toolMgr() )
 324     return -1;
 325
 326   return desktop()->toolMgr()->createToolBar( title, name );
 327 }
 328
 329 /*!
 330   Creates new toolbutton
 331   \return SUIT identificator of new action
 332   \param a - action
 333   \param tBar - identificator of toolbar
 334   \param id - proposed SUIT identificator of action (if it is -1, then must be use any free)
 335   \param idx - index in toolbar
 336 */
 337 int SUIT_Application::createTool( QAction* a, const int tBar, const int id, const int idx )
 338 {
 339   if ( !desktop() || !desktop()->toolMgr() )
 340     return -1;
 341
 342   int regId = registerAction( id, a );
 343   int intId = desktop()->toolMgr()->insert( a, tBar, idx );
 344   return intId != -1 ? regId : -1;
 345 }
 346
 347 /*!
 348   Creates new toolbutton
 349   \return SUIT identificator of new action
 350   \param a - action
 351   \param tBar - name of toolbar
 352   \param id - proposed SUIT identificator of action (if it is -1, then must be use any free)
 353   \param idx - index in toolbar
 354 */
 355 int SUIT_Application::createTool( QAction* a, const QString& tBar, const int id, const int idx )
 356 {
 357   if ( !desktop() || !desktop()->toolMgr() )
 358     return -1;
 359
 360   int regId = registerAction( id, a );
 361   int intId = desktop()->toolMgr()->insert( a, tBar, idx );
 362   return intId != -1 ? regId : -1;
 363 }
 364
 365 /*!
 366   Creates new toolbutton
 367   \return "id" if all right or -1 otherwise
 368   \param id - SUIT identificator of action
 369   \param tBar - identificator of toolbar
 370   \param idx - index in toolbar
 371 */
 372 int SUIT_Application::createTool( const int id, const int tBar, const int idx )
 373 {
 374   if ( !desktop() || !desktop()->toolMgr() )
 375     return -1;
 376
 377   int intId = desktop()->toolMgr()->insert( action( id ), tBar, idx );
 378   return intId != -1 ? id : -1;
 379 }
 380
 381 /*!
 382   Creates new toolbutton
 383   \return "id" if all right or -1 otherwise
 384   \param id - SUIT identificator of action
 385   \param tBar - name of toolbar
 386   \param idx - index in toolbar
 387 */
 388 int SUIT_Application::createTool( const int id, const QString& tBar, const int idx )
 389 {
 390   if ( !desktop() || !desktop()->toolMgr() )
 391     return -1;
 392
 393   int intId = desktop()->toolMgr()->insert( action( id ), tBar, idx );
 394   return intId != -1 ? id : -1;
 395 }
 396
 397 /*!
 398   Creates new menu item
 399   \return identificator of new action in menu manager
 400   \param subMenu - menu text of new item
 401   \param menu - identificator of parent menu item
 402   \param id - proposed identificator of action
 403   \param group - group in menu manager
 404   \param index - index in menu
 405 */
 406 int SUIT_Application::createMenu( const QString& subMenu, const int menu,
 407                                   const int id, const int group, const int index )
 408 {
 409   if ( !desktop() || !desktop()->menuMgr() )
 410     return -1;
 411
 412   return desktop()->menuMgr()->insert( subMenu, menu, group, id, index );
 413 }
 414
 415 /*!
 416   Creates new menu item
 417   \return identificator of new action in menu manager
 418   \param subMenu - menu text of new item
 419   \param menu - menu text of parent menu item
 420   \param id - proposed identificator of action
 421   \param group - group in menu manager
 422   \param index - index in menu
 423 */
 424 int SUIT_Application::createMenu( const QString& subMenu, const QString& menu,
 425                                   const int id, const int group, const int index )
 426 {
 427   if ( !desktop() || !desktop()->menuMgr() )
 428     return -1;
 429
 430   return desktop()->menuMgr()->insert( subMenu, menu, group, id, index );
 431 }
 432
 433 /*!
 434   Creates new menu item
 435   \return SUIT identificator of new action
 436   \param a - action
 437   \param menu - identificator of parent menu item
 438   \param id - proposed SUIT identificator of action
 439   \param group - group in menu manager
 440   \param index - index in menu
 441 */
 442 int SUIT_Application::createMenu( QAction* a, const int menu, const int id, const int group, const int index )
 443 {
 444   if ( !a || !desktop() || !desktop()->menuMgr() )
 445     return -1;
 446
 447   int regId = registerAction( id, a );
 448   int intId = desktop()->menuMgr()->insert( a, menu, group, index );
 449   return intId != -1 ? regId : -1;
 450 }
 451
 452 /*!
 453   Creates new menu item
 454   \return SUIT identificator of new action
 455   \param a - action
 456   \param menu - menu text of parent menu item
 457   \param id - proposed SUIT identificator of action
 458   \param group - group in menu manager
 459   \param index - index in menu
 460 */
 461 int SUIT_Application::createMenu( QAction* a, const QString& menu, const int id, const int group, const int index )
 462 {
 463   if ( !a || !desktop() || !desktop()->menuMgr() )
 464     return -1;
 465
 466   int regId = registerAction( id, a );
 467   int intId = desktop()->menuMgr()->insert( a, menu, group, index );
 468   return intId != -1 ? regId : -1;
 469 }
 470
 471 /*!
 472   Creates new menu item
 473   \return identificator of new action in menu manager
 474   \param id - SUIT identificator of action
 475   \param menu - menu text of parent menu item
 476   \param group - group in menu manager
 477   \param index - index in menu
 478 */
 479 int SUIT_Application::createMenu( const int id, const int menu, const int group, const int index )
 480 {
 481   if ( !desktop() || !desktop()->menuMgr() )
 482     return -1;
 483
 484   int intId = desktop()->menuMgr()->insert( action( id ), menu, group, index );
 485   return intId != -1 ? id : -1;
 486 }
 487
 488 /*!
 489   Creates new menu item
 490   \return identificator of new action in menu manager
 491   \param id - SUIT identificator of action
 492   \param menu - menu text of parent menu item
 493   \param group - group in menu manager
 494   \param index - index in menu
 495 */
 496 int SUIT_Application::createMenu( const int id, const QString& menu, const int group, const int index )
 497 {
 498   if ( !desktop() || !desktop()->menuMgr() )
 499     return -1;
 500
 501   int intId = desktop()->menuMgr()->insert( action( id ), menu, group, index );
 502   return intId != -1 ? id : -1;
 503 }
 504
 505 /*!
 506   Show/hide menu item corresponding to action
 507   \param a - action
 508   \param on - if it is true, the item will be shown, otherwise it will be hidden
 509 */
 510 void SUIT_Application::setMenuShown( QAction* a, const bool on )
 511 {
 512   if ( !a || !desktop() )
 513     return;
 514
 515   QtxActionMenuMgr* mMgr = desktop()->menuMgr();
 516   if ( mMgr )
 517     mMgr->setShown( mMgr->actionId( a ), on );
 518 }
 519
 520 /*!
 521   Show/hide menu item corresponding to action
 522   \param id - identificator of action in menu manager
 523   \param on - if it is true, the item will be shown, otherwise it will be hidden
 524 */
 525 void SUIT_Application::setMenuShown( const int id, const bool on )
 526 {
 527   setMenuShown( action( id ), on );
 528 }
 529
 530 /*!
 531   Show/hide tool button corresponding to action
 532   \param a - action
 533   \param on - if it is true, the button will be shown, otherwise it will be hidden
 534 */
 535 void SUIT_Application::setToolShown( QAction* a, const bool on )
 536 {
 537   if ( !a || !desktop() )
 538     return;
 539
 540   QtxActionToolMgr* tMgr = desktop()->toolMgr();
 541   if ( tMgr )
 542     tMgr->setShown( tMgr->actionId( a ), on );
 543 }
 544
 545 /*!
 546   Show/hide menu item corresponding to action
 547   \param id - identificator of action in tool manager
 548   \param on - if it is true, the button will be shown, otherwise it will be hidden
 549 */
 550 void SUIT_Application::setToolShown( const int id, const bool on )
 551 {
 552   setToolShown( action( id ), on );
 553 }
 554
 555 /*!
 556   Show/hide both menu item and tool button corresponding to action
 557   \param a - action
 558   \param on - if it is true, the item will be shown, otherwise it will be hidden
 559 */
 560 void SUIT_Application::setActionShown( QAction* a, const bool on )
 561 {
 562   setMenuShown( a, on );
 563   setToolShown( a, on );
 564 }
 565
 566 /*!
 567   Show/hide both menu item and tool button corresponding to action
 568   \param id - identificator in both menu manager and tool manager
 569   \param on - if it is true, the item will be shown, otherwise it will be hidden
 570 */
 571 void SUIT_Application::setActionShown( const int id, const bool on )
 572 {
 573   setMenuShown( id, on );
 574   setToolShown( id, on );
 575 }
 576
 577 /*!
 578   \return action by it's SUIT identificator
 579   \param id - SUIT identificator
 580 */
 581 QAction* SUIT_Application::action( const int id ) const
 582 {
 583   QAction* a = 0;
 584   if ( myActionMap.contains( id ) )
 585     a = myActionMap[id];
 586   return a;
 587 }
 588
 589 /*!
 590   \return SUIT identificator of action
 591   \param a - action
 592 */
 593 int SUIT_Application::actionId( const QAction* a ) const
 594 {
 595   int id = -1;
 596   for ( QMap<int, QAction*>::ConstIterator it = myActionMap.begin(); it != myActionMap.end() && id == -1; ++it )
 597   {
 598     if ( it.value() == a )
 599       id = it.key();
 600   }
 601   return id;
 602 }
 603
 604 QList<QAction*> SUIT_Application::actions() const
 605 {
 606   return myActionMap.values();
 607 }
 608
 609 QList<int> SUIT_Application::actionIds() const
 610 {
 611   return myActionMap.keys();
 612 }
 613
 614 /*!
 615   Creates action and registers it both in menu manager and tool manager
 616   \return new instance of action
 617   \param id - proposed SUIT identificator
 618   \param text - description
 619   \param icon - icon for toolbar
 620   \param menu - menu text
 621   \param tip - tool tip
 622   \param key - shortcut
 623   \param parent - parent object
 624   \param toggle - if it is TRUE the action will be a toggle action, otherwise it will be a command action
 625   \param reciever - object that contains slot
 626   \param member - slot to be called when action is activated
 627 */
 628 QAction* SUIT_Application::createAction( const int id, const QString& text, const QIcon& icon,
 629                                          const QString& menu, const QString& tip, const int key,
 630                                          QObject* parent, const bool toggle, QObject* reciever,
 631                                          const char* member, const QString& shortcutAction )
 632 {
 633   QtxAction* a = new QtxAction( text, icon, menu, key, parent, toggle, shortcutAction );
 634   a->setStatusTip( tip );
 635
 636   if ( reciever && member )
 637     connect( a, SIGNAL( triggered( bool ) ), reciever, member );
 638
 639   registerAction( id, a );
 640
 641   return a;
 642 }
 643
 644 /*!
 645   Registers action both in menu manager and tool manager
 646   \param id - proposed SUIT identificator (if it is -1, auto generated one is used)
 647   \param a - action
 648 */
 649 int SUIT_Application::registerAction( const int id, QAction* a )
 650 {
 651   int ident = actionId( a );
 652   if ( ident != -1 )
 653     return ident;
 654
 655   static int generatedId = -1;
 656   ident = id == -1 ? --generatedId : id;
 657
 658   if ( action( ident ) )
 659     qWarning( "Action registration id is already in use: %d", ident );
 660
 661   myActionMap.insert( ident, a );
 662
 663   if ( desktop() && desktop()->menuMgr() )
 664     desktop()->menuMgr()->registerAction( a );
 665
 666   if ( desktop() && desktop()->toolMgr() )
 667     desktop()->toolMgr()->registerAction( a );
 668
 669   if ( desktop() )
 670     desktop()->addAction( a );
 671
 672   return ident;
 673 }
 674
 675 /*!
 676   \return global action used as separator
 677 */
 678 QAction* SUIT_Application::separator()
 679 {
 680   return QtxActionMgr::separator();
 681 }
 682
 683 /*!
 684   SLOT: it is called when desktop is activated
 685 */
 686
 687 void SUIT_Application::onDesktopActivated()
 688 {
 689   emit activated( this );
 690 }
 691
 692 /*!
 693   SLOT: is used for Help browsing
 694 */
 695 void SUIT_Application::onHelpContextModule( const QString& /*theComponentName*/,
 696                                             const QString& /*theFileName*/,
 697                                             const QString& /*theContext*/ )
 698 {
 699 }