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   bool anIsImage = false;
 145
 146   foreach( SUIT_DataOwner* aSUITOwner, anOwners )
 147   {
 148     if( LightApp_DataOwner* anOwner = dynamic_cast<LightApp_DataOwner*>( aSUITOwner ) )
 149     {
 150       Handle(HYDROData_Object) anObject = aModel->objectByEntry( anOwner->entry() );
 151       if( !anObject.IsNull() )
 152       {
 153         anIsSelection = true;
 154
 155         bool aVisibility = anObject->GetVisibility();
 156         anIsVisibleInSelection |= aVisibility;
 157         anIsHiddenInSelection |= !aVisibility;
 158
 159         if( anObject->GetKind() == KIND_IMAGE )
 160           anIsImage = true;
 161       }
 162     }
 163   }
 164
 165   if( anOwners.count() == 1 && anIsImage )
 166   {
 167     theMenu->addAction( action( EditImageId ) );
 168     theMenu->addSeparator();
 169   }
 170
 171   if( anIsSelection )
 172   {
 173     theMenu->addAction( action( DeleteId ) );
 174     theMenu->addSeparator();
 175   }
 176
 177   if( anIsSelection )
 178   {
 179     if( anIsHiddenInSelection )
 180       theMenu->addAction( action( ShowId ) );
 181     theMenu->addAction( action( ShowOnlyId ) );
 182     if( anIsVisibleInSelection )
 183       theMenu->addAction( action( HideId ) );
 184     theMenu->addSeparator();
 185   }
 186   theMenu->addAction( action( ShowAllId ) );
 187   theMenu->addAction( action( HideAllId ) );
 188   theMenu->addSeparator();
 189 }
 190
 191 void HYDROGUI_Module::update( const int flags )
 192 {
 193   if( !isUpdateEnabled() )
 194     return;
 195
 196   QApplication::setOverrideCursor( Qt::WaitCursor );
 197
 198   // To prevent calling this method recursively
 199   // from one of the methods called below
 200   setUpdateEnabled( false );
 201
 202   if( ( flags & UF_Model ) && getDataModel() )
 203   {
 204     getDataModel()->update( getStudyId() );
 205   }
 206   else
 207   {
 208     /* to do
 209     if( ( flags & UF_ObjBrowser ) && getObjectBrowser() )
 210       updateObjectBrowser();
 211     */
 212   }
 213
 214   if( ( flags & UF_Viewer ) )
 215     updateGV( flags & UF_GV_Init,
 216               flags & UF_GV_Forced );
 217
 218   if( ( flags & UF_Controls ) && getApp() )
 219     getApp()->updateActions();
 220
 221   setUpdateEnabled( true );
 222
 223   QApplication::restoreOverrideCursor();
 224 }
 225
 226 void HYDROGUI_Module::updateCommandsStatus()
 227 {
 228   LightApp_Module::updateCommandsStatus();
 229
 230   updateUndoRedoControls();
 231
 232   // to do
 233   //action( ... )->setEnabled( ... );
 234 }
 235
 236 HYDROGUI_DataModel* HYDROGUI_Module::getDataModel() const
 237 {
 238   return (HYDROGUI_DataModel*)dataModel();
 239 }
 240
 241 HYDROGUI_Displayer* HYDROGUI_Module::getDisplayer() const
 242 {
 243   return myDisplayer;
 244 }
 245
 246 GraphicsView_Viewer* HYDROGUI_Module::getViewer( const int theViewerId ) const
 247 {
 248   ViewManagerList aViewManagerList;
 249   getApp()->viewManagers( GraphicsView_Viewer::Type(), aViewManagerList );
 250
 251   ViewManagerList::iterator anIter, anIterEnd = aViewManagerList.end();
 252   for( anIter = aViewManagerList.begin(); anIter != anIterEnd; anIter++ )
 253   {
 254     GraphicsView_ViewManager* aViewManager =
 255       dynamic_cast<GraphicsView_ViewManager*>( *anIter );
 256     if( aViewManager && aViewManager->getId() == theViewerId )
 257       return aViewManager->getViewer();
 258   }
 259   return NULL;
 260 }
 261
 262 CAM_DataModel* HYDROGUI_Module::createDataModel()
 263 {
 264   return new HYDROGUI_DataModel( this );
 265 }
 266
 267 void HYDROGUI_Module::customEvent( QEvent* e )
 268 {
 269   int aType = e->type();
 270   if ( aType == NewViewEvent )
 271   {
 272     SALOME_CustomEvent* ce = ( SALOME_CustomEvent* )e;
 273     if( GraphicsView_ViewFrame* aViewFrame = ( GraphicsView_ViewFrame* )ce->data() )
 274     {
 275       if( GraphicsView_Viewer* aViewer = dynamic_cast<GraphicsView_Viewer*>( aViewFrame->getViewer() ) )
 276       {
 277         //update( UF_Viewer | UF_GV_Forced ); // ouv: to do
 278         aViewer->activateTransform( GraphicsView_Viewer::FitAll );
 279
 280         if( GraphicsView_ViewPort* aViewPort = aViewer->getActiveViewPort() )
 281         {
 282           aViewPort->setInteractionFlag( GraphicsView_ViewPort::TraceBoundingRect );
 283           aViewPort->setInteractionFlag( GraphicsView_ViewPort::ImmediateContextMenu );
 284           aViewPort->setInteractionFlag( GraphicsView_ViewPort::ImmediateSelection );
 285
 286           // ouv: tmp
 287           aViewPort->setMousePositionEnabled( true );
 288         }
 289       }
 290     }
 291   }
 292 }
 293
 294 bool HYDROGUI_Module::eventFilter( QObject* theObj, QEvent* theEvent )
 295 {
 296   QEvent::Type aType = theEvent->type();
 297   if( theObj->inherits( "GraphicsView_ViewFrame" ) )
 298   {
 299     if( aType == QEvent::Show )
 300     {
 301       SALOME_CustomEvent* e = new SALOME_CustomEvent( NewViewEvent );
 302       e->setData( theObj );
 303       QApplication::postEvent( this, e );
 304       theObj->removeEventFilter( this );
 305     }
 306   }
 307   return LightApp_Module::eventFilter( theObj, theEvent );
 308 }
 309
 310 void HYDROGUI_Module::onViewManagerAdded( SUIT_ViewManager* theViewManager )
 311 {
 312   LightApp_Module::onViewManagerAdded( theViewManager );
 313
 314   if( theViewManager->getType() == GraphicsView_Viewer::Type() )
 315   {
 316     createSelector( theViewManager ); // replace the default selector
 317
 318     connect( theViewManager, SIGNAL( viewCreated( SUIT_ViewWindow* ) ),
 319              this, SLOT( onViewCreated( SUIT_ViewWindow* ) ) );
 320   }
 321 }
 322
 323 void HYDROGUI_Module::onViewManagerRemoved( SUIT_ViewManager* theViewManager )
 324 {
 325   LightApp_Module::onViewManagerRemoved( theViewManager );
 326
 327   createSelector( theViewManager ); // replace the default selector
 328 }
 329
 330 void HYDROGUI_Module::onViewCreated( SUIT_ViewWindow* theViewWindow )
 331 {
 332   if( theViewWindow && theViewWindow->inherits( "GraphicsView_ViewFrame" ) )
 333   {
 334     if( GraphicsView_ViewFrame* aViewFrame = dynamic_cast<GraphicsView_ViewFrame*>( theViewWindow ) )
 335     {
 336       aViewFrame->installEventFilter( this );
 337     }
 338   }
 339 }
 340
 341 void HYDROGUI_Module::updateGV( const bool theIsInit,
 342                                 const bool theIsForced )
 343 {
 344   if( !getDisplayer() )
 345     return;
 346
 347   ViewManagerList aViewManagerList;
 348   getApp()->viewManagers( GraphicsView_Viewer::Type(), aViewManagerList );
 349
 350   ViewManagerList::iterator anIter, anIterEnd = aViewManagerList.end();
 351   for( anIter = aViewManagerList.begin(); anIter != anIterEnd; anIter++ )
 352   {
 353     GraphicsView_ViewManager* aViewManager =
 354       dynamic_cast<GraphicsView_ViewManager*>( *anIter );
 355     if( aViewManager )
 356       getDisplayer()->UpdateAll( aViewManager->getId(), theIsInit, theIsForced );
 357   }
 358 }
 359
 360 void HYDROGUI_Module::createSelector( SUIT_ViewManager* theViewManager )
 361 {
 362   if( !theViewManager )
 363     return;
 364
 365   LightApp_SelectionMgr* aSelectionMgr = getApp()->selectionMgr();
 366   if( !aSelectionMgr )
 367     return;
 368
 369   QString aViewType = theViewManager->getType();
 370   if( aViewType != GraphicsView_Viewer::Type() )
 371     return;
 372
 373   GraphicsView_ViewManager* aViewManager =
 374     dynamic_cast<GraphicsView_ViewManager*>( theViewManager );
 375   if( !aViewManager )
 376     return;
 377
 378   QList<SUIT_Selector*> aSelectorList;
 379   aSelectionMgr->selectors( aViewType, aSelectorList );
 380
 381   // disable all alien selectors
 382   QList<SUIT_Selector*>::iterator anIter, anIterEnd = aSelectorList.end();
 383   for( anIter = aSelectorList.begin(); anIter != anIterEnd; anIter++ )
 384   {
 385     SUIT_Selector* aSelector = *anIter;
 386     if( aSelector && !dynamic_cast<HYDROGUI_GVSelector*>( aSelector ) )
 387       aSelector->setEnabled( false );
 388   }
 389
 390   new HYDROGUI_GVSelector( this, aViewManager->getViewer(), aSelectionMgr );
 391 }
 392
 393 bool HYDROGUI_Module::setUpdateEnabled( const bool theState )
 394 {
 395   bool aPrevState = myIsUpdateEnabled;
 396   myIsUpdateEnabled = theState;
 397   return aPrevState;
 398 }
 399
 400 bool HYDROGUI_Module::isUpdateEnabled() const
 401 {
 402   return myIsUpdateEnabled;
 403 }