src/HYDROGUI/HYDROGUI_Module.cxx

   1 // Copyright (C) 2007-2013  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.
  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 "HYDROGUI_Module.h"
  24
  25 #include "HYDROGUI.h"
  26 #include "HYDROGUI_DataModel.h"
  27 #include "HYDROGUI_Displayer.h"
  28 #include "HYDROGUI_GVSelector.h"
  29 #include "HYDROGUI_InputPanel.h"
  30 #include "HYDROGUI_ObjSelector.h"
  31 #include "HYDROGUI_Operations.h"
  32 #include "HYDROGUI_PrsImage.h"
  33 #include "HYDROGUI_UpdateFlags.h"
  34
  35 #include <GraphicsView_ViewFrame.h>
  36 #include <GraphicsView_ViewManager.h>
  37 #include <GraphicsView_ViewPort.h>
  38 #include <GraphicsView_Viewer.h>
  39
  40 #include <LightApp_Application.h>
  41 #include <LightApp_DataOwner.h>
  42 #include <LightApp_GVSelector.h>
  43 #include <LightApp_SelectionMgr.h>
  44 #include <LightApp_UpdateFlags.h>
  45
  46 #include <SALOME_Event.h>
  47
  48 #include <SUIT_Study.h>
  49 #include <SUIT_ViewManager.h>
  50
  51 #include <QAction>
  52 #include <QApplication>
  53 #include <QMenu>
  54
  55 extern "C" HYDRO_EXPORT CAM_Module* createModule()
  56 {
  57   return new HYDROGUI_Module();
  58 }
  59
  60 HYDROGUI_Module::HYDROGUI_Module()
  61 : LightApp_Module( "HYDRO" ),
  62   myDisplayer( 0 ),
  63   myIsUpdateEnabled( true )
  64 {
  65 }
  66
  67 HYDROGUI_Module::~HYDROGUI_Module()
  68 {
  69 }
  70
  71 int HYDROGUI_Module::getStudyId() const
  72 {
  73   LightApp_Application* anApp = getApp();
  74   return anApp ? anApp->activeStudy()->id() : 0;
  75 }
  76
  77 void HYDROGUI_Module::initialize( CAM_Application* theApp )
  78 {
  79   LightApp_Module::initialize( theApp );
  80
  81   createActions();
  82   createUndoRedoActions();
  83   createMenus();
  84   createPopups();
  85   createToolbars();
  86
  87   setMenuShown( false );
  88   setToolShown( false );
  89
  90   myDisplayer = new HYDROGUI_Displayer( this );
  91 }
  92
  93 bool HYDROGUI_Module::activateModule( SUIT_Study* theStudy )
  94 {
  95   bool aRes = LightApp_Module::activateModule( theStudy );
  96
  97   setMenuShown( true );
  98   setToolShown( true );
  99
 100   update( UF_All );
 101
 102   updateCommandsStatus();
 103
 104   return aRes;
 105 }
 106
 107 bool HYDROGUI_Module::deactivateModule( SUIT_Study* theStudy )
 108 {
 109   setMenuShown( false );
 110   setToolShown( false );
 111
 112   return LightApp_Module::deactivateModule( theStudy );
 113 }
 114
 115 void HYDROGUI_Module::windows( QMap<int, int>& theMap ) const
 116 {
 117   theMap.clear();
 118   theMap.insert( LightApp_Application::WT_LogWindow,     Qt::BottomDockWidgetArea );
 119   theMap.insert( LightApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea   );
 120 }
 121
 122 void HYDROGUI_Module::viewManagers( QStringList& theTypesList ) const
 123 {
 124   theTypesList << GraphicsView_Viewer::Type();
 125 }
 126
 127 void HYDROGUI_Module::contextMenuPopup( const QString& theClient,
 128                                         QMenu* theMenu,
 129                                         QString& theTitle )
 130 {
 131   HYDROGUI_DataModel* aModel = getDataModel();
 132
 133   LightApp_SelectionMgr* aSelectionMgr = getApp()->selectionMgr();
 134   if( !aSelectionMgr )
 135     return;
 136
 137   SUIT_DataOwnerPtrList anOwners;
 138   aSelectionMgr->selected( anOwners );
 139
 140   bool anIsSelection = false;
 141   bool anIsVisibleInSelection = false;
 142   bool anIsHiddenInSelection = false;
 143
 144   foreach( SUIT_DataOwner* aSUITOwner, anOwners )
 145   {
 146     if( LightApp_DataOwner* anOwner = dynamic_cast<LightApp_DataOwner*>( aSUITOwner ) )
 147     {
 148       Handle(HYDROData_Object) anObject = aModel->objectByEntry( anOwner->entry() );
 149       if( !anObject.IsNull() )
 150       {
 151         bool aVisibility = anObject->GetVisibility();
 152         anIsVisibleInSelection |= aVisibility;
 153         anIsHiddenInSelection |= !aVisibility;
 154         anIsSelection = true;
 155       }
 156     }
 157   }
 158
 159   if( anIsSelection )
 160   {
 161     theMenu->addAction( action( DeleteId ) );
 162     theMenu->addSeparator();
 163   }
 164
 165   if( anIsSelection )
 166   {
 167     if( anIsHiddenInSelection )
 168       theMenu->addAction( action( ShowId ) );
 169     theMenu->addAction( action( ShowOnlyId ) );
 170     if( anIsVisibleInSelection )
 171       theMenu->addAction( action( HideId ) );
 172     theMenu->addSeparator();
 173   }
 174   theMenu->addAction( action( ShowAllId ) );
 175   theMenu->addAction( action( HideAllId ) );
 176   theMenu->addSeparator();
 177 }
 178
 179 void HYDROGUI_Module::update( const int flags )
 180 {
 181   if( !isUpdateEnabled() )
 182     return;
 183
 184   QApplication::setOverrideCursor( Qt::WaitCursor );
 185
 186   // To prevent calling this method recursively
 187   // from one of the methods called below
 188   setUpdateEnabled( false );
 189
 190   if( ( flags & UF_Model ) && getDataModel() )
 191   {
 192     getDataModel()->update( getStudyId() );
 193   }
 194   else
 195   {
 196     /* to do
 197     if( ( flags & UF_ObjBrowser ) && getObjectBrowser() )
 198       updateObjectBrowser();
 199     */
 200   }
 201
 202   if( ( flags & UF_Viewer ) )
 203     updateGV( flags & UF_GV_Init,
 204               flags & UF_GV_Forced );
 205
 206   if( ( flags & UF_Controls ) && getApp() )
 207     getApp()->updateActions();
 208
 209   setUpdateEnabled( true );
 210
 211   QApplication::restoreOverrideCursor();
 212 }
 213
 214 void HYDROGUI_Module::updateCommandsStatus()
 215 {
 216   LightApp_Module::updateCommandsStatus();
 217
 218   updateUndoRedoControls();
 219
 220   // to do
 221   //action( ... )->setEnabled( ... );
 222 }
 223
 224 HYDROGUI_DataModel* HYDROGUI_Module::getDataModel() const
 225 {
 226   return (HYDROGUI_DataModel*)dataModel();
 227 }
 228
 229 HYDROGUI_Displayer* HYDROGUI_Module::getDisplayer() const
 230 {
 231   return myDisplayer;
 232 }
 233
 234 GraphicsView_Viewer* HYDROGUI_Module::getViewer( const int theViewerId ) const
 235 {
 236   ViewManagerList aViewManagerList;
 237   getApp()->viewManagers( GraphicsView_Viewer::Type(), aViewManagerList );
 238
 239   ViewManagerList::iterator anIter, anIterEnd = aViewManagerList.end();
 240   for( anIter = aViewManagerList.begin(); anIter != anIterEnd; anIter++ )
 241   {
 242     GraphicsView_ViewManager* aViewManager =
 243       dynamic_cast<GraphicsView_ViewManager*>( *anIter );
 244     if( aViewManager && aViewManager->getId() == theViewerId )
 245       return aViewManager->getViewer();
 246   }
 247   return NULL;
 248 }
 249
 250 CAM_DataModel* HYDROGUI_Module::createDataModel()
 251 {
 252   return new HYDROGUI_DataModel( this );
 253 }
 254
 255 void HYDROGUI_Module::customEvent( QEvent* e )
 256 {
 257   int aType = e->type();
 258   if ( aType == NewViewEvent )
 259   {
 260     SALOME_CustomEvent* ce = ( SALOME_CustomEvent* )e;
 261     if( GraphicsView_ViewFrame* aViewFrame = ( GraphicsView_ViewFrame* )ce->data() )
 262     {
 263       if( GraphicsView_Viewer* aViewer = dynamic_cast<GraphicsView_Viewer*>( aViewFrame->getViewer() ) )
 264       {
 265         update( UF_Viewer | UF_GV_Forced );
 266         aViewer->activateTransform( GraphicsView_Viewer::FitAll );
 267
 268         if( GraphicsView_ViewPort* aViewPort = aViewer->getActiveViewPort() )
 269         {
 270           aViewPort->setInteractionFlag( GraphicsView_ViewPort::TraceBoundingRect );
 271           aViewPort->setInteractionFlag( GraphicsView_ViewPort::ImmediateContextMenu );
 272           aViewPort->setInteractionFlag( GraphicsView_ViewPort::ImmediateSelection );
 273         }
 274       }
 275     }
 276   }
 277 }
 278
 279 bool HYDROGUI_Module::eventFilter( QObject* theObj, QEvent* theEvent )
 280 {
 281   QEvent::Type aType = theEvent->type();
 282   if( theObj->inherits( "GraphicsView_ViewFrame" ) )
 283   {
 284     if( aType == QEvent::Show )
 285     {
 286       SALOME_CustomEvent* e = new SALOME_CustomEvent( NewViewEvent );
 287       e->setData( theObj );
 288       QApplication::postEvent( this, e );
 289       theObj->removeEventFilter( this );
 290     }
 291   }
 292   return LightApp_Module::eventFilter( theObj, theEvent );
 293 }
 294
 295 void HYDROGUI_Module::onViewManagerAdded( SUIT_ViewManager* theViewManager )
 296 {
 297   LightApp_Module::onViewManagerAdded( theViewManager );
 298
 299   if( theViewManager->getType() == GraphicsView_Viewer::Type() )
 300   {
 301     createSelector( theViewManager ); // replace the default selector
 302
 303     connect( theViewManager, SIGNAL( viewCreated( SUIT_ViewWindow* ) ),
 304              this, SLOT( onViewCreated( SUIT_ViewWindow* ) ) );
 305   }
 306 }
 307
 308 void HYDROGUI_Module::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
 309 {
 310   LightApp_Module::onViewManagerRemoved( theViewManager );
 311
 312   createSelector( theViewManager ); // replace the default selector
 313 }
 314
 315 void HYDROGUI_Module::onViewCreated( SUIT_ViewWindow* theViewWindow )
 316 {
 317   if( theViewWindow && theViewWindow->inherits( "GraphicsView_ViewFrame" ) )
 318   {
 319     if( GraphicsView_ViewFrame* aViewFrame = dynamic_cast<GraphicsView_ViewFrame*>( theViewWindow ) )
 320     {
 321       aViewFrame->installEventFilter( this );
 322     }
 323   }
 324 }
 325
 326 void HYDROGUI_Module::updateGV( const bool theIsInit,
 327                                 const bool theIsForced )
 328 {
 329   if( !getDisplayer() )
 330     return;
 331
 332   ViewManagerList aViewManagerList;
 333   getApp()->viewManagers( GraphicsView_Viewer::Type(), aViewManagerList );
 334
 335   ViewManagerList::iterator anIter, anIterEnd = aViewManagerList.end();
 336   for( anIter = aViewManagerList.begin(); anIter != anIterEnd; anIter++ )
 337   {
 338     GraphicsView_ViewManager* aViewManager =
 339       dynamic_cast<GraphicsView_ViewManager*>( *anIter );
 340     if( aViewManager )
 341       getDisplayer()->UpdateAll( aViewManager->getId(), theIsInit, theIsForced );
 342   }
 343 }
 344
 345 void HYDROGUI_Module::createSelector( SUIT_ViewManager* theViewManager )
 346 {
 347   if( !theViewManager )
 348     return;
 349
 350   LightApp_SelectionMgr* aSelectionMgr = getApp()->selectionMgr();
 351   if( !aSelectionMgr )
 352     return;
 353
 354   QString aViewType = theViewManager->getType();
 355   if( aViewType != GraphicsView_Viewer::Type() )
 356     return;
 357
 358   GraphicsView_ViewManager* aViewManager =
 359     dynamic_cast<GraphicsView_ViewManager*>( theViewManager );
 360   if( !aViewManager )
 361     return;
 362
 363   QList<SUIT_Selector*> aSelectorList;
 364   aSelectionMgr->selectors( aViewType, aSelectorList );
 365
 366   // disable all alien selectors
 367   QList<SUIT_Selector*>::iterator anIter, anIterEnd = aSelectorList.end();
 368   for( anIter = aSelectorList.begin(); anIter != anIterEnd; anIter++ )
 369   {
 370     SUIT_Selector* aSelector = *anIter;
 371     if( aSelector && !dynamic_cast<HYDROGUI_GVSelector*>( aSelector ) )
 372       aSelector->setEnabled( false );
 373   }
 374
 375   new HYDROGUI_GVSelector( this, aViewManager->getViewer(), aSelectionMgr );
 376 }
 377
 378 bool HYDROGUI_Module::setUpdateEnabled( const bool theState )
 379 {
 380   bool aPrevState = myIsUpdateEnabled;
 381   myIsUpdateEnabled = theState;
 382   return aPrevState;
 383 }
 384
 385 bool HYDROGUI_Module::isUpdateEnabled() const
 386 {
 387   return myIsUpdateEnabled;
 388 }