src/SalomeApp/SalomeApp_Module.cxx

   1 // File:      SalomeApp_Module.cxx
   2 // Created:   10/25/2004 11:39:56 AM
   3 // Author:    Sergey LITONIN
   4 // Copyright (C) CEA 2004
   5
   6 #include "SalomeApp_Module.h"
   7
   8 #include "SalomeApp_Study.h"
   9 #include "SalomeApp_DataModel.h"
  10 #include "SalomeApp_Application.h"
  11 #include "SalomeApp_Preferences.h"
  12 #include "SalomeApp_UpdateFlags.h"
  13 #include "SalomeApp_Operation.h"
  14 #include "SalomeApp_SwitchOp.h"
  15
  16 #include <OB_Browser.h>
  17
  18 #include <CAM_Study.h>
  19
  20 #include <SUIT_MessageBox.h>
  21 #include <SUIT_ResourceMgr.h>
  22
  23 #include <QtxPopupMgr.h>
  24
  25 #include <SVTK_ViewWindow.h>
  26 #include <OCCViewer_ViewWindow.h>
  27 #include <OCCViewer_ViewPort3d.h>
  28 #include <GLViewer_ViewFrame.h>
  29 #include <GLViewer_ViewPort.h>
  30 #include <Plot2d_ViewWindow.h>
  31
  32 /*!Constructor.*/
  33 SalomeApp_Module::SalomeApp_Module( const QString& name )
  34 : CAM_Module( name ),
  35 myPopupMgr( 0 ),
  36 mySwitchOp( 0 )
  37 {
  38 }
  39
  40 /*!Destructor.*/
  41 SalomeApp_Module::~SalomeApp_Module()
  42 {
  43   if ( mySwitchOp )
  44     delete mySwitchOp;
  45 }
  46
  47 /*!Initialize module.*/
  48 void SalomeApp_Module::initialize( CAM_Application* app )
  49 {
  50   CAM_Module::initialize( app );
  51
  52   SUIT_ResourceMgr* resMgr = app ? app->resourceMgr() : 0;
  53   if ( resMgr )
  54     resMgr->raiseTranslators( name() );
  55 }
  56
  57 /*!Activate module.*/
  58 bool SalomeApp_Module::activateModule( SUIT_Study* study )
  59 {
  60   bool res = CAM_Module::activateModule( study );
  61
  62   if ( res && application() && application()->resourceMgr() )
  63     application()->resourceMgr()->raiseTranslators( name() );
  64
  65   if ( mySwitchOp == 0 )
  66     mySwitchOp = new SalomeApp_SwitchOp( this );
  67
  68   return res;
  69 }
  70
  71 /*!Deactivate module.*/
  72 bool SalomeApp_Module::deactivateModule( SUIT_Study* )
  73 {
  74   delete mySwitchOp;
  75   mySwitchOp = 0;
  76
  77   return true;
  78 }
  79
  80 /*!NOT IMPLEMENTED*/
  81 void SalomeApp_Module::selectionChanged()
  82 {
  83 }
  84
  85 /*!NOT IMPLEMENTED*/
  86 void SalomeApp_Module::MenuItem()
  87 {
  88 }
  89
  90 /*!NOT IMPLEMENTED*/
  91 void SalomeApp_Module::windows( QMap<int, int>& ) const
  92 {
  93 }
  94
  95 /*!NOT IMPLEMENTED*/
  96 void SalomeApp_Module::viewManagers( QStringList& ) const
  97 {
  98 }
  99
 100 /*!NOT IMPLEMENTED*/
 101 void SalomeApp_Module::createPreferences()
 102 {
 103 }
 104
 105 /*!NOT IMPLEMENTED*/
 106 void SalomeApp_Module::preferencesChanged( const QString&, const QString& )
 107 {
 108 }
 109
 110 /*!Gets application.*/
 111 SalomeApp_Application* SalomeApp_Module::getApp() const
 112 {
 113   return (SalomeApp_Application*)application();
 114 }
 115
 116 /*!NOT IMPLEMENTED*/
 117 void SalomeApp_Module::onModelOpened()
 118 {
 119 }
 120
 121 /*!NOT IMPLEMENTED*/
 122 void SalomeApp_Module::onModelSaved()
 123 {
 124 }
 125
 126 /*!NOT IMPLEMENTED*/
 127 void SalomeApp_Module::onModelClosed()
 128 {
 129 }
 130
 131 /*!Gets popup manager.(create if not exist)*/
 132 QtxPopupMgr* SalomeApp_Module::popupMgr()
 133 {
 134   if ( !myPopupMgr )
 135     myPopupMgr = new QtxPopupMgr( 0, this );
 136   return myPopupMgr;
 137 }
 138
 139 /*!Gets preferences.*/
 140 SalomeApp_Preferences* SalomeApp_Module::preferences() const
 141 {
 142   SalomeApp_Preferences* pref = 0;
 143   if ( getApp() )
 144     pref = getApp()->preferences();
 145   return pref;
 146 }
 147
 148 /*!Create new instance of data model and return it.*/
 149 CAM_DataModel* SalomeApp_Module::createDataModel()
 150 {
 151   return new SalomeApp_DataModel(this);
 152 }
 153
 154 /*!Update object browser.*/
 155 void SalomeApp_Module::updateObjBrowser( bool updateDataModel, SUIT_DataObject* root )
 156 {
 157   if( updateDataModel )
 158     if( CAM_DataModel* aDataModel = dataModel() )
 159       if( SalomeApp_DataModel* aModel = dynamic_cast<SalomeApp_DataModel*>( aDataModel ) )
 160         aModel->update( 0, dynamic_cast<SalomeApp_Study*>( getApp()->activeStudy() ) );
 161   getApp()->objectBrowser()->updateTree( root );
 162 }
 163
 164 /*!Context menu popup.*/
 165 void SalomeApp_Module::contextMenuPopup( const QString& client, QPopupMenu* menu, QString& /*title*/ )
 166 {
 167   SalomeApp_Selection* sel = createSelection();
 168   sel->init( client, getApp()->selectionMgr() );
 169   popupMgr()->updatePopup( menu, sel );
 170   delete sel;
 171 }
 172
 173 /*!Create and return instance of SalomeApp_Selection.*/
 174 SalomeApp_Selection* SalomeApp_Module::createSelection() const
 175 {
 176   return new SalomeApp_Selection();
 177 }
 178
 179 /*!Add preference to preferences.*/
 180 int SalomeApp_Module::addPreference( const QString& label )
 181 {
 182   SalomeApp_Preferences* pref = preferences();
 183   if ( !pref )
 184     return -1;
 185
 186   int catId = pref->addPreference( moduleName(), -1 );
 187   if ( catId == -1 )
 188     return -1;
 189
 190   return pref->addPreference( label, catId );
 191 }
 192
 193 /*!Add preference to preferences.*/
 194 int SalomeApp_Module::addPreference( const QString& label, const int pId, const int type,
 195                                      const QString& section, const QString& param )
 196 {
 197   SalomeApp_Preferences* pref = preferences();
 198   if ( !pref )
 199     return -1;
 200
 201   return pref->addPreference( moduleName(), label, pId, type, section, param );
 202 }
 203
 204 /*!Gets property of preferences.*/
 205 QVariant SalomeApp_Module::preferenceProperty( const int id, const QString& prop ) const
 206 {
 207   QVariant var;
 208   SalomeApp_Preferences* pref = preferences();
 209   if ( pref )
 210     var = pref->itemProperty( id, prop );
 211   return var;
 212 }
 213
 214
 215 /*!Set property of preferences.*/
 216 void SalomeApp_Module::setPreferenceProperty( const int id, const QString& prop, const QVariant& var )
 217 {
 218   SalomeApp_Preferences* pref = preferences();
 219   if ( pref )
 220     pref->setItemProperty( id, prop, var );
 221 }
 222
 223 /*!
 224  * \brief Update something in accordance with update flags
 225   * \param theFlags - update flags
 226 *
 227 * Update viewer or/and object browser etc. in accordance with update flags ( see
 228 * SalomeApp_UpdateFlags enumeration ). Derived modules can redefine this method for their
 229 * own purposes
 230 */
 231 void SalomeApp_Module::update( const int theFlags )
 232 {
 233   if ( theFlags & UF_Model )
 234   {
 235     if( CAM_DataModel* aDataModel = dataModel() )
 236       if( SalomeApp_DataModel* aModel = dynamic_cast<SalomeApp_DataModel*>( aDataModel ) )
 237         aModel->update( 0, dynamic_cast<SalomeApp_Study*>( getApp()->activeStudy() ) );
 238   }
 239   if ( theFlags & UF_ObjBrowser )
 240     getApp()->objectBrowser()->updateTree( 0 );
 241   if ( theFlags & UF_Controls )
 242     updateControls();
 243   if ( theFlags & UF_Viewer )
 244   {
 245     if ( SUIT_ViewManager* viewMgr = getApp()->activeViewManager() )
 246       if ( SUIT_ViewWindow* viewWnd = viewMgr->getActiveView() )
 247       {
 248         if ( viewWnd->inherits( "SVTK_ViewWindow" ) )
 249           ( (SVTK_ViewWindow*)viewWnd )->Repaint();
 250         else if ( viewWnd->inherits( "OCCViewer_ViewWindow" ) )
 251           ( (OCCViewer_ViewWindow*)viewWnd )->getViewPort()->onUpdate();
 252         else if ( viewWnd->inherits( "Plot2d_ViewWindow" ) )
 253           ( (Plot2d_ViewWindow*)viewWnd )->getViewFrame()->Repaint();
 254         else if ( viewWnd->inherits( "GLViewer_ViewFrame" ) )
 255           ( (GLViewer_ViewFrame*)viewWnd )->getViewPort()->onUpdate();
 256       }
 257   }
 258 }
 259
 260 /*!
 261  * \brief Updates controls
 262 *
 263 * Updates (i.e. disable/enable) controls states (menus, tool bars etc.). This method is
 264 * called from update( UF_Controls ). You may redefine it in concrete module.
 265 */
 266 void SalomeApp_Module::updateControls()
 267 {
 268 }
 269
 270 /*!
 271  * \brief Starts operation with given identifier
 272   * \param id - identifier of operation to be started
 273 *
 274 * Module stores operations in map. This method starts operation by id.
 275 * If operation isn't in map, then it will be created by createOperation method
 276 * and will be inserted to map
 277 */
 278 void SalomeApp_Module::startOperation( const int id )
 279 {
 280   SalomeApp_Operation* op = 0;
 281   if( myOperations.contains( id ) )
 282     op = myOperations[ id ];
 283   else
 284   {
 285     op = createOperation( id );
 286     if( op )
 287     {
 288       myOperations.insert( id, op );
 289       op->setModule( this );
 290       connect( op, SIGNAL( stopped( SUIT_Operation* ) ), this, SLOT( onOperationStopped( SUIT_Operation* ) ) );
 291       connect( op, SIGNAL( destroyed() ), this, SLOT( onOperationDestroyed() ) );
 292     }
 293   }
 294
 295   if( op )
 296     op->start();
 297 }
 298
 299 /*!
 300  * \brief Creates operation with given identifier
 301   * \param id - identifier of operation to be started
 302   * \return Pointer on created operation or NULL if operation is not created
 303 *
 304 * Creates operation with given id. You should not call this method, it will be called
 305 * automatically from startOperation. You may redefine this method in concrete module to
 306 * create operations.
 307 */
 308 SalomeApp_Operation* SalomeApp_Module::createOperation( const int /*id*/ ) const
 309 {
 310   return 0;
 311 }
 312
 313 /*!
 314  * \brief Virtual protected slot called when operation stopped
 315   * \param theOp - stopped operation
 316 *
 317 * Virtual protected slot called when operation stopped. Redefine this slot if you want to
 318 * perform actions after stopping operation
 319 */
 320 void SalomeApp_Module::onOperationStopped( SUIT_Operation* /*theOp*/ )
 321 {
 322 }
 323
 324 /*!
 325  * \brief Virtual protected slot called when operation destroyed
 326   * \param theOp - destroyed operation
 327 *
 328 * Virtual protected slot called when operation destroyed. Redefine this slot if you want to
 329 * perform actions after destroying operation. Base implementation removes pointer on
 330 * destroyed operation from the map of operations
 331 */
 332 void SalomeApp_Module::onOperationDestroyed()
 333 {
 334   const QObject* s = sender();
 335   if( s && s->inherits( "SalomeApp_Operation" ) )
 336   {
 337     const SalomeApp_Operation* op = ( SalomeApp_Operation* )s;
 338     MapOfOperation::const_iterator anIt = myOperations.begin(),
 339                                    aLast = myOperations.end();
 340     for( ; anIt!=aLast; anIt++ )
 341       if( anIt.data()==op )
 342       {
 343         myOperations.remove( anIt.key() );
 344         break;
 345       }
 346   }
 347 }