X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROGUI%2FHYDROGUI_Module.cxx;h=2e32038f9b523cd00cde71c8f52e68f213105d05;hb=a558c58ccc19713db2b13ada4d0f32dff61d0deb;hp=567dab1ff2faa7035bdf8c1d5b144dfe538bb209;hpb=fe02bb085711fbb88046f31bd30a4590d7263c7a;p=modules%2Fhydro.git diff --git a/src/HYDROGUI/HYDROGUI_Module.cxx b/src/HYDROGUI/HYDROGUI_Module.cxx index 567dab1f..2e32038f 100644 --- a/src/HYDROGUI/HYDROGUI_Module.cxx +++ b/src/HYDROGUI/HYDROGUI_Module.cxx @@ -28,26 +28,54 @@ #include "HYDROGUI_GVSelector.h" #include "HYDROGUI_InputPanel.h" #include "HYDROGUI_ObjSelector.h" +#include "HYDROGUI_OCCDisplayer.h" +#include "HYDROGUI_OCCSelector.h" #include "HYDROGUI_Operations.h" #include "HYDROGUI_PrsImage.h" #include "HYDROGUI_Tool.h" #include "HYDROGUI_UpdateFlags.h" +#include "HYDROGUI_Shape.h" +#include "HYDROGUI_VTKPrs.h" +#include "HYDROGUI_VTKPrsDisplayer.h" +#include "HYDROGUI_AbstractDisplayer.h" +#include "HYDROGUI_PolylineOp.h" + +#include +#include +#include + +#include #include #include #include #include +#include +#include +#include + #include +#include #include #include #include +#include +#include +#include + #include +#include +#include #include #include +#include +#include +#include + #include #include #include @@ -60,9 +88,15 @@ extern "C" HYDRO_EXPORT CAM_Module* createModule() return new HYDROGUI_Module(); } +extern "C" HYDRO_EXPORT char* getModuleVersion() +{ + return (char*)HYDRO_VERSION; +} + HYDROGUI_Module::HYDROGUI_Module() : LightApp_Module( "HYDRO" ), myDisplayer( 0 ), + myOCCDisplayer( 0 ), myIsUpdateEnabled( true ) { } @@ -91,19 +125,34 @@ void HYDROGUI_Module::initialize( CAM_Application* theApp ) setToolShown( false ); myDisplayer = new HYDROGUI_Displayer( this ); + myOCCDisplayer = new HYDROGUI_OCCDisplayer( this ); + myVTKDisplayer = new HYDROGUI_VTKPrsDisplayer( this ); } bool HYDROGUI_Module::activateModule( SUIT_Study* theStudy ) { bool aRes = LightApp_Module::activateModule( theStudy ); + LightApp_Application* anApp = getApp(); + SUIT_Desktop* aDesktop = anApp->desktop(); + + getApp()->setEditEnabled( false ); // hide SalomeApp copy/paste actions + setMenuShown( true ); setToolShown( true ); +#ifndef DISABLE_PYCONSOLE + aDesktop->tabifyDockWidget( HYDROGUI_Tool::WindowDock( anApp->getWindow( LightApp_Application::WT_PyConsole ) ), + HYDROGUI_Tool::WindowDock( anApp->getWindow( LightApp_Application::WT_LogWindow ) ) ); +#endif + update( UF_All ); updateCommandsStatus(); + connect( anApp, SIGNAL( operationFinished( const QString&, const QString&, const QStringList& ) ), + this, SLOT( onExternalOperationFinished( const QString&, const QString&, const QStringList& ) ) ); + return aRes; } @@ -115,9 +164,20 @@ bool HYDROGUI_Module::deactivateModule( SUIT_Study* theStudy ) getApp()->removeViewManager( aViewManager ); myViewManagerMap.clear(); + myObjectStateMap.clear(); + myShapesMap.clear(); + + // clear the data model's list of copying objects + HYDROGUI_DataModel::changeCopyingObjects( HYDROData_SequenceOfObjects() ); + setMenuShown( false ); setToolShown( false ); + getApp()->setEditEnabled( true ); // show SalomeApp copy/paste actions + + disconnect( getApp(), SIGNAL( operationFinished( const QString&, const QString&, const QStringList& ) ), + this, SLOT( onExternalOperationFinished( const QString&, const QString&, const QStringList& ) ) ); + return LightApp_Module::deactivateModule( theStudy ); } @@ -125,12 +185,15 @@ void HYDROGUI_Module::windows( QMap& theMap ) const { theMap.clear(); theMap.insert( LightApp_Application::WT_LogWindow, Qt::BottomDockWidgetArea ); +#ifndef DISABLE_PYCONSOLE + theMap.insert( LightApp_Application::WT_PyConsole, Qt::BottomDockWidgetArea ); +#endif theMap.insert( LightApp_Application::WT_ObjectBrowser, Qt::LeftDockWidgetArea ); } void HYDROGUI_Module::viewManagers( QStringList& theTypesList ) const { - theTypesList << GraphicsView_Viewer::Type(); + theTypesList << OCCViewer_Viewer::Type() << GraphicsView_Viewer::Type(); } void HYDROGUI_Module::contextMenuPopup( const QString& theClient, @@ -139,66 +202,237 @@ void HYDROGUI_Module::contextMenuPopup( const QString& theClient, { HYDROGUI_DataModel* aModel = getDataModel(); - bool anIsSelection = false; + bool anIsObjectBrowser = theClient == getApp()->objectBrowser()->popupClientType(); + bool anIsGraphicsView = theClient == GraphicsView_Viewer::Type(); + bool anIsOCCView = theClient == OCCViewer_Viewer::Type(); + bool anIsVTKView = theClient == SVTK_Viewer::Type(); + if( !anIsObjectBrowser && !anIsGraphicsView && !anIsOCCView && !anIsVTKView ) + return; + + size_t anActiveViewId = HYDROGUI_Tool::GetActiveViewId( this ); + + bool anIsSelectedDataObjects = false; bool anIsVisibleInSelection = false; bool anIsHiddenInSelection = false; bool anIsImage = false; + bool anIsImportedImage = false; + bool anIsImageHasRefs = false; + bool anIsFusedImage = false; + bool anIsCutImage = false; + bool anIsSplittedImage = false; + bool anIsMustBeUpdatedImage = false; bool anIsPolyline = false; + bool anIsBathymetry = false; + bool anIsCalculation = false; + bool anIsImmersibleZone = false; + bool anIsVisualState = false; + bool anIsRegion = false; + bool anIsZone = false; + bool anIsObstacle = false; + bool anIsGeomObject = false; + + // check the selected GEOM objects + if ( !HYDROGUI_Tool::GetSelectedGeomObjects( this ).isEmpty() ) { + theMenu->addAction( action( ImportGeomObjectId ) ); + theMenu->addSeparator(); + } + // check the selected data model objects HYDROData_SequenceOfObjects aSeq = HYDROGUI_Tool::GetSelectedObjects( this ); for( Standard_Integer anIndex = 1, aLength = aSeq.Length(); anIndex <= aLength; anIndex++ ) { - Handle(HYDROData_Object) anObject = aSeq.Value( anIndex ); + Handle(HYDROData_Entity) anObject = aSeq.Value( anIndex ); if( !anObject.IsNull() ) { - anIsSelection = true; + anIsSelectedDataObjects = true; - bool aVisibility = anObject->GetVisibility(); + bool aVisibility = isObjectVisible( anActiveViewId, anObject ); anIsVisibleInSelection |= aVisibility; anIsHiddenInSelection |= !aVisibility; if( anObject->GetKind() == KIND_IMAGE ) + { anIsImage = true; - - if( anObject->GetKind() == KIND_POLYLINE ) + Handle(HYDROData_Image) anImage = Handle(HYDROData_Image)::DownCast( anObject ); + if( !anImage.IsNull() ) + { + anIsImportedImage = anImage->HasLocalPoints() && !anImage->IsSelfSplitted(); + anIsImageHasRefs = anImage->HasReferences(); + if( HYDROData_OperationsFactory* aFactory = HYDROData_OperationsFactory::Factory() ) + { + if( ImageComposer_Operator* anOperator = aFactory->Operator( anImage ) ) + { + QString anOperatorName = anOperator->name(); + if( anOperatorName == ImageComposer_FuseOperator::Type() ) + anIsFusedImage = true; + else if( anOperatorName == ImageComposer_CutOperator::Type() ) + anIsCutImage = true; + else if( anOperatorName == ImageComposer_CropOperator::Type() ) + anIsSplittedImage = true; + } + } + if ( anImage->IsMustBeUpdated() ) + { + anIsMustBeUpdatedImage = true; + } + } + } + else if( anObject->GetKind() == KIND_POLYLINE ) anIsPolyline = true; + else if( anObject->GetKind() == KIND_CALCULATION ) + anIsCalculation = true; + else if( anObject->GetKind() == KIND_IMMERSIBLE_ZONE ) + anIsImmersibleZone = true; + else if( anObject->GetKind() == KIND_VISUAL_STATE ) + anIsVisualState = true; + else if( anObject->GetKind() == KIND_REGION ) + anIsRegion = true; + else if( anObject->GetKind() == KIND_ZONE ) + anIsZone = true; + else if( anObject->GetKind() == KIND_BATHYMETRY ) + anIsBathymetry = true; + else if( anObject->GetKind() == KIND_OBSTACLE ) + anIsObstacle = true; } + + anIsGeomObject = HYDROData_Tool::IsGeometryObject( anObject ); } - if( aSeq.Length() == 1 ) + // check the selected partitions + if( !anIsSelectedDataObjects && anIsObjectBrowser ) { - if( anIsImage ) + ObjectKind aSelectedPartition = HYDROGUI_Tool::GetSelectedPartition( this ); + if( aSelectedPartition != KIND_UNKNOWN ) { - theMenu->addAction( action( EditImageId ) ); - theMenu->addAction( action( ExportImageId ) ); + switch( aSelectedPartition ) + { + case KIND_IMAGE: + theMenu->addAction( action( ImportImageId ) ); + break; + case KIND_POLYLINE: + theMenu->addAction( action( CreatePolylineId ) ); + break; + case KIND_VISUAL_STATE: + theMenu->addAction( action( SaveVisualStateId ) ); + break; + case KIND_BATHYMETRY: + theMenu->addAction( action( ImportBathymetryId ) ); + break; + case KIND_CALCULATION: + theMenu->addAction( action( CreateCalculationId ) ); + break; + case KIND_IMMERSIBLE_ZONE: + theMenu->addAction( action( CreateImmersibleZoneId ) ); + break; + case KIND_OBSTACLE: + theMenu->addAction( action( ImportObstacleFromFileId ) ); + theMenu->addAction( action( CreateBoxId ) ); + theMenu->addAction( action( CreateCylinderId ) ); + break; + } theMenu->addSeparator(); } - else if( anIsPolyline ) + } + + if( anIsSelectedDataObjects ) + { + if ( anIsMustBeUpdatedImage ) { - theMenu->addAction( action( EditPolylineId ) ); + theMenu->addAction( action( UpdateImageId ) ); theMenu->addSeparator(); } - } - if( anIsSelection ) - { + if( aSeq.Length() == 1 ) + { + if( anIsImage ) + { + if( anIsImportedImage ) + theMenu->addAction( action( EditImportedImageId ) ); + else if( anIsImageHasRefs ) + { + if( anIsFusedImage ) + theMenu->addAction( action( EditFusedImageId ) ); + else if( anIsCutImage ) + theMenu->addAction( action( EditCutImageId ) ); + else if( anIsSplittedImage ) + theMenu->addAction( action( EditSplittedImageId ) ); + } + + theMenu->addAction( action( ObserveImageId ) ); + theMenu->addAction( action( ExportImageId ) ); + theMenu->addSeparator(); + + if( anIsImageHasRefs ) + { + theMenu->addAction( action( RemoveImageRefsId ) ); + theMenu->addSeparator(); + } + + theMenu->addAction( action( FuseImagesId ) ); + theMenu->addAction( action( CutImagesId ) ); + theMenu->addAction( action( SplitImageId ) ); + theMenu->addSeparator(); + } + else if( anIsPolyline ) + { + theMenu->addAction( action( EditPolylineId ) ); + theMenu->addSeparator(); + } + else if( anIsCalculation ) + { + theMenu->addAction( action( EditCalculationId ) ); + theMenu->addAction( action( ExportCalculationId ) ); + theMenu->addSeparator(); + } + else if( anIsImmersibleZone ) + { + theMenu->addAction( action( EditImmersibleZoneId ) ); + theMenu->addSeparator(); + } + else if( anIsVisualState && anIsObjectBrowser ) + { + theMenu->addAction( action( SaveVisualStateId ) ); + theMenu->addAction( action( LoadVisualStateId ) ); + theMenu->addSeparator(); + } + + // Add set color action for geometrical objects + if ( anIsGeomObject ) + { + theMenu->addAction( action( SetColorId ) ); + theMenu->addSeparator(); + } + } + theMenu->addAction( action( DeleteId ) ); theMenu->addSeparator(); + + if( anIsImage || anIsPolyline || anIsImmersibleZone || anIsZone || anIsRegion || anIsBathymetry || anIsObstacle ) + { + if( anIsHiddenInSelection ) + theMenu->addAction( action( ShowId ) ); + theMenu->addAction( action( ShowOnlyId ) ); + if( anIsVisibleInSelection ) + theMenu->addAction( action( HideId ) ); + theMenu->addSeparator(); + } } - if( anIsSelection ) + if ( anIsOCCView ) { - if( anIsHiddenInSelection ) - theMenu->addAction( action( ShowId ) ); - theMenu->addAction( action( ShowOnlyId ) ); - if( anIsVisibleInSelection ) - theMenu->addAction( action( HideId ) ); + SUIT_Operation* anOp = application()->activeStudy()->activeOperation(); + HYDROGUI_PolylineOp* aPolylineOp = dynamic_cast( anOp ); + if ( aPolylineOp && aPolylineOp->deleteEnabled() ) + theMenu->addAction( action( DeleteId ) ); + } + + if( anIsObjectBrowser || anIsGraphicsView || anIsOCCView || anIsVTKView ) + { + theMenu->addAction( action( ShowAllId ) ); + theMenu->addAction( action( HideAllId ) ); theMenu->addSeparator(); } - theMenu->addAction( action( ShowAllId ) ); - theMenu->addAction( action( HideAllId ) ); - theMenu->addSeparator(); } void HYDROGUI_Module::update( const int flags ) @@ -212,19 +446,41 @@ void HYDROGUI_Module::update( const int flags ) // from one of the methods called below setUpdateEnabled( false ); - if( ( flags & UF_Model ) && getDataModel() ) + // store selected objects + QStringList aSelectedEntries = storeSelection(); + + bool aDoFitAll = flags & UF_FitAll; + if( ( flags & UF_Viewer ) ) + updateViewer( getDisplayer(), flags & UF_GV_Init, flags & UF_GV_Forced, aDoFitAll ); + + if( ( flags & UF_OCCViewer ) ) + updateViewer( getOCCDisplayer(), flags & UF_OCC_Init, flags & UF_OCC_Forced, aDoFitAll ); + + if( ( flags & UF_VTKViewer ) ) + updateViewer( getVTKDisplayer(), flags & UF_VTK_Init, flags & UF_VTK_Forced, aDoFitAll ); + + if( ( flags & UF_Model ) && getDataModel() && getApp() ) + { getDataModel()->update( getStudyId() ); - if( ( flags & UF_ObjBrowser ) && getApp() ) + // Temporary workaround to prevent breaking + // the selection in the object browser. + // Note: processEvents() should be called after updateGV(), + // otherwise the application crashes from time to time. + //RKV: qApp->processEvents(); getApp()->updateObjectBrowser( true ); + } - if( ( flags & UF_Viewer ) ) - updateGV( flags & UF_GV_Init, - flags & UF_GV_Forced ); + // Object browser is currently updated by using UF_Model flag + if( ( flags & UF_ObjBrowser ) && ((flags & UF_Model) == 0) && getApp() ) + getApp()->updateObjectBrowser( true ); if( ( flags & UF_Controls ) && getApp() ) getApp()->updateActions(); + // restore selected objects + restoreSelection( aSelectedEntries ); + setUpdateEnabled( true ); QApplication::restoreOverrideCursor(); @@ -236,8 +492,14 @@ void HYDROGUI_Module::updateCommandsStatus() updateUndoRedoControls(); - // to do - //action( ... )->setEnabled( ... ); + action( CopyId )->setEnabled( getDataModel()->canCopy() ); + action( PasteId )->setEnabled( getDataModel()->canPaste() ); +} + +void HYDROGUI_Module::selectionChanged() +{ + LightApp_Module::selectionChanged(); + updateCommandsStatus(); } HYDROGUI_DataModel* HYDROGUI_Module::getDataModel() const @@ -250,6 +512,25 @@ HYDROGUI_Displayer* HYDROGUI_Module::getDisplayer() const return myDisplayer; } +HYDROGUI_OCCDisplayer* HYDROGUI_Module::getOCCDisplayer() const +{ + return myOCCDisplayer; +} + +HYDROGUI_VTKPrsDisplayer* HYDROGUI_Module::getVTKDisplayer() const +{ + return myVTKDisplayer; +} + +SUIT_ViewManager* HYDROGUI_Module::getViewManager( const int theId ) const +{ + if( myViewManagerMap.contains( theId ) ) + { + return myViewManagerMap[ theId ].first; + } + return NULL; +} + GraphicsView_Viewer* HYDROGUI_Module::getViewer( const int theId ) const { if( myViewManagerMap.contains( theId ) ) @@ -263,6 +544,32 @@ GraphicsView_Viewer* HYDROGUI_Module::getViewer( const int theId ) const return NULL; } +OCCViewer_Viewer* HYDROGUI_Module::getOCCViewer( const int theId ) const +{ + if( myViewManagerMap.contains( theId ) ) + { + ViewManagerInfo anInfo = myViewManagerMap[ theId ]; + OCCViewer_ViewManager* aViewManager = + ::qobject_cast( anInfo.first ); + if( aViewManager ) + return aViewManager->getOCCViewer(); + } + return NULL; +} + +SVTK_Viewer* HYDROGUI_Module::getVTKViewer( const int theId ) const +{ + if( myViewManagerMap.contains( theId ) ) + { + ViewManagerInfo anInfo = myViewManagerMap[ theId ]; + SVTK_ViewManager* aViewManager = + ::qobject_cast( anInfo.first ); + if( aViewManager ) + return dynamic_cast( aViewManager->getViewModel() ); + } + return NULL; +} + int HYDROGUI_Module::getViewManagerId( SUIT_ViewManager* theViewManager ) { ViewManagerMapIterator anIter( myViewManagerMap ); @@ -298,6 +605,232 @@ void HYDROGUI_Module::setViewManagerRole( SUIT_ViewManager* theViewManager, } } +bool HYDROGUI_Module::isObjectVisible( const int theViewId, + const Handle(HYDROData_Entity)& theObject ) const +{ + if( theObject.IsNull() ) + return false; + + ViewId2Name2ObjectStateMap::const_iterator anIter1 = myObjectStateMap.find( theViewId ); + if( anIter1 != myObjectStateMap.end() ) + { + const Name2ObjectStateMap& aName2ObjectStateMap = anIter1.value(); + Name2ObjectStateMap::const_iterator anIter2 = aName2ObjectStateMap.find( theObject->GetName()); + if( anIter2 != aName2ObjectStateMap.end() ) + { + const ObjectState& anObjectState = anIter2.value(); + return anObjectState.Visibility; + } + } + return false; +} + +void HYDROGUI_Module::setObjectVisible( const int theViewId, + const Handle(HYDROData_Entity)& theObject, + const bool theState ) +{ + if( !theObject.IsNull() ) + { + Name2ObjectStateMap& aName2ObjectStateMap = myObjectStateMap[ theViewId ]; + ObjectState& anObjectState = aName2ObjectStateMap[ theObject->GetName() ]; + anObjectState.Visibility = theState; + } +} + +/////////////////// OCC SHAPES PROCESSING +HYDROGUI_Shape* HYDROGUI_Module::getObjectShape( const int theViewId, + const Handle(HYDROData_Entity)& theObject ) const +{ + HYDROGUI_Shape* aResShape = NULL; + if( theObject.IsNull() ) + return aResShape; + + if ( myShapesMap.contains( theViewId ) ) + { + const ListOfShapes& aViewShapes = myShapesMap.value( theViewId ); + foreach ( HYDROGUI_Shape* aShape, aViewShapes ) + { + if ( !aShape || !IsEqual( aShape->getObject(), theObject ) ) + continue; + + aResShape = aShape; + break; + } + } + + return aResShape; +} + +void HYDROGUI_Module::setObjectShape( const int theViewId, + const Handle(HYDROData_Entity)& theObject, + HYDROGUI_Shape* theShape ) +{ + if( theObject.IsNull() ) + return; + + ListOfShapes& aViewShapes = myShapesMap[ theViewId ]; + aViewShapes.append( theShape ); +} + +void HYDROGUI_Module::removeObjectShape( const int theViewId, + const Handle(HYDROData_Entity)& theObject ) +{ + if ( !myShapesMap.contains( theViewId ) ) + return; + + ListOfShapes& aViewShapes = myShapesMap[ theViewId ]; + Handle(HYDROData_Entity) anObject; + for ( int i = 0; i < aViewShapes.length(); ) + { + HYDROGUI_Shape* aShape = aViewShapes.at( i ); + anObject = aShape->getObject(); + if ( aShape && (!anObject.IsNull()) && IsEqual( anObject, theObject ) ) + { + delete aShape; + aViewShapes.removeAt( i ); + continue; + } + + ++i; + } +} + +void HYDROGUI_Module::removeViewShapes( const int theViewId ) +{ + if ( !myShapesMap.contains( theViewId ) ) + return; + + const ListOfShapes& aViewShapes = myShapesMap.value( theViewId ); + for ( int i = 0, n = aViewShapes.length(); i < n; ++i ) + { + HYDROGUI_Shape* aShape = aViewShapes.at( i ); + if ( aShape ) + delete aShape; + } + + myShapesMap.remove( theViewId ); +} +/////////////////// END OF OCC SHAPES PROCESSING + +/////////////////// VTKPrs PROCESSING +HYDROGUI_VTKPrs* HYDROGUI_Module::getObjectVTKPrs( const int theViewId, + const Handle(HYDROData_Entity)& theObject ) const +{ + HYDROGUI_VTKPrs* aResShape = NULL; + if( theObject.IsNull() ) + return aResShape; + + if ( myVTKPrsMap.contains( theViewId ) ) + { + const ListOfVTKPrs& aViewShapes = myVTKPrsMap.value( theViewId ); + foreach ( HYDROGUI_VTKPrs* aShape, aViewShapes ) + { + if ( !aShape || !IsEqual( aShape->getObject(), theObject ) ) + continue; + + aResShape = aShape; + break; + } + } + + return aResShape; +} + +void HYDROGUI_Module::setObjectVTKPrs( const int theViewId, + const Handle(HYDROData_Entity)& theObject, + HYDROGUI_VTKPrs* theShape ) +{ + if( theObject.IsNull() ) + return; + + // Compute the new global Z range from the added presentation and the old global Z range. + double* aGlobalRange = getVTKDisplayer()->GetZRange( theViewId ); + double* aRange = theShape->getInternalZRange(); + bool anIsUpdate = false; + if ( aRange[0] < aGlobalRange[0] ) + { + aGlobalRange[0] = aRange[0]; + anIsUpdate = true; + } + if ( aRange[1] > aGlobalRange[1] ) + { + aGlobalRange[1] = aRange[1]; + anIsUpdate = true; + } + + //if ( anIsUpdate ) + //{ + updateVTKZRange( theViewId, aGlobalRange ); + //} + + ListOfVTKPrs& aViewShapes = myVTKPrsMap[ theViewId ]; + aViewShapes.append( theShape ); +} + +void HYDROGUI_Module::removeObjectVTKPrs( const int theViewId, + const Handle(HYDROData_Entity)& theObject ) +{ + if ( !myVTKPrsMap.contains( theViewId ) ) + return; + + ListOfVTKPrs& aViewShapes = myVTKPrsMap[ theViewId ]; + Handle(HYDROData_Entity) anObject; + for ( int i = 0; i < aViewShapes.length(); ) + { + HYDROGUI_VTKPrs* aShape = aViewShapes.at( i ); + anObject = aShape->getObject(); + if ( aShape && (!anObject.IsNull()) && IsEqual( anObject, theObject ) ) + { + delete aShape; + aViewShapes.removeAt( i ); + continue; + } + + ++i; + } + + // Invalidate global Z range + double anInvalidRange[2] = { HYDROGUI_VTKPrs::InvalidZValue(), HYDROGUI_VTKPrs::InvalidZValue() }; + getVTKDisplayer()->SetZRange( theViewId, anInvalidRange ); +} + +void HYDROGUI_Module::removeViewVTKPrs( const int theViewId ) +{ + if ( !myVTKPrsMap.contains( theViewId ) ) + return; + + const ListOfVTKPrs& aViewShapes = myVTKPrsMap.value( theViewId ); + for ( int i = 0, n = aViewShapes.length(); i < n; ++i ) + { + HYDROGUI_VTKPrs* aShape = aViewShapes.at( i ); + if ( aShape ) + delete aShape; + } + + myVTKPrsMap.remove( theViewId ); +} + +void HYDROGUI_Module::updateVTKZRange( const int theViewId, double theRange[] ) +{ + if ( myVTKPrsMap.contains( theViewId ) ) + { + // For the given viewer id update all VTK presentations ... + const ListOfVTKPrs& aViewShapes = myVTKPrsMap.value( theViewId ); + HYDROGUI_VTKPrs* aShape; + for ( int i = 0, n = aViewShapes.length(); i < n; ++i ) + { + aShape = aViewShapes.at( i ); + if ( aShape ) + { + aShape->setZRange( theRange ); + } + } + } + // ... and update the global color legend scalar bar. + getVTKDisplayer()->SetZRange( theViewId, theRange ); +} +/////////////////// END OF VTKPrs PROCESSING + CAM_DataModel* HYDROGUI_Module::createDataModel() { return new HYDROGUI_DataModel( this ); @@ -315,20 +848,24 @@ void HYDROGUI_Module::customEvent( QEvent* e ) { SUIT_ViewManager* aViewManager = aViewer->getViewManager(); ViewManagerRole aRole = getViewManagerRole( aViewManager ); - if( aRole == VMR_General ) - update( UF_Viewer ); - - aViewer->activateTransform( GraphicsView_Viewer::FitAll ); if( GraphicsView_ViewPort* aViewPort = aViewer->getActiveViewPort() ) { + if( aRole != VMR_TransformImage && aRole != VMR_ReferenceImage ) + aViewPort->scale( 1, -1 ); // invert the Y axis direction from down to up + aViewPort->setInteractionFlag( GraphicsView_ViewPort::TraceBoundingRect ); aViewPort->setInteractionFlag( GraphicsView_ViewPort::ImmediateContextMenu ); aViewPort->setInteractionFlag( GraphicsView_ViewPort::ImmediateSelection ); - // ouv: tmp + //ouv: temporarily commented //aViewPort->setViewLabelPosition( GraphicsView_ViewPort::VLP_BottomLeft, true ); } + + if( aRole != VMR_TransformImage && aRole != VMR_ReferenceImage ) + update( UF_Viewer ); + + aViewer->activateTransform( GraphicsView_Viewer::FitAll ); } } } @@ -356,12 +893,17 @@ void HYDROGUI_Module::onViewManagerAdded( SUIT_ViewManager* theViewManager ) if( theViewManager->getType() == GraphicsView_Viewer::Type() ) { - createSelector( theViewManager ); // replace the default selector - + connect( theViewManager, SIGNAL( viewCreated( SUIT_ViewWindow* ) ), + this, SLOT( onViewCreated( SUIT_ViewWindow* ) ) ); + } + else if( theViewManager->getType() == OCCViewer_Viewer::Type() ) + { connect( theViewManager, SIGNAL( viewCreated( SUIT_ViewWindow* ) ), this, SLOT( onViewCreated( SUIT_ViewWindow* ) ) ); } + createSelector( theViewManager ); // replace the default selector + ViewManagerInfo anInfo( theViewManager, VMR_General ); myViewManagerMap.insert( ViewManagerId++, anInfo ); } @@ -374,7 +916,28 @@ void HYDROGUI_Module::onViewManagerRemoved( SUIT_ViewManager* theViewManager ) int anId = getViewManagerId( theViewManager ); if( anId != -1 ) + { + OCCViewer_ViewManager* anOCCViewManager = + ::qobject_cast( myViewManagerMap[ anId ].first ); + if ( anOCCViewManager ) + { + OCCViewer_Viewer* anOCCViewer = anOCCViewManager->getOCCViewer(); + if ( anOCCViewer ) + removeViewShapes( (size_t)anOCCViewer ); + } + + if ( getVTKDisplayer()->IsApplicable( theViewManager ) ) + { + SVTK_Viewer* aVTKViewer = getVTKViewer( anId ); + if ( aVTKViewer ) + { + getVTKDisplayer()->DeleteScalarBar( anId ); + removeViewShapes( (size_t)aVTKViewer ); + } + } + myViewManagerMap.remove( anId ); + } } void HYDROGUI_Module::onViewCreated( SUIT_ViewWindow* theViewWindow ) @@ -389,13 +952,20 @@ void HYDROGUI_Module::onViewCreated( SUIT_ViewWindow* theViewWindow ) connect( aViewPort, SIGNAL( vpMouseEvent( QGraphicsSceneMouseEvent* ) ), this, SLOT( onViewPortMouseEvent( QGraphicsSceneMouseEvent* ) ) ); - return; + } + } + else if( theViewWindow && theViewWindow->inherits( "OCCViewer_ViewFrame" ) ) + { + if( OCCViewer_ViewFrame* aViewFrame = dynamic_cast( theViewWindow ) ) + { + aViewFrame->onTopView(); } } } void HYDROGUI_Module::onViewPortMouseEvent( QGraphicsSceneMouseEvent* theEvent ) { + /* ouv: currently unused if( GraphicsView_ViewPort* aViewPort = qobject_cast( sender() ) ) { SUIT_ViewManager* aViewManager = 0; @@ -425,8 +995,8 @@ void HYDROGUI_Module::onViewPortMouseEvent( QGraphicsSceneMouseEvent* theEvent ) int aXDeg = 0, aYDeg = 0; int aXMin = 0, aYMin = 0; double aXSec = 0, aYSec = 0; - HYDROGUI_Tool::DoubleToLambert( aMouseX, aXDeg, aXMin, aXSec ); - HYDROGUI_Tool::DoubleToLambert( aMouseY, aYDeg, aYMin, aYSec ); + HYDROData_Lambert93::secToDMS( aMouseX, aXDeg, aXMin, aXSec ); + HYDROData_Lambert93::secToDMS( aMouseY, aYDeg, aYMin, aYSec ); QString aDegSymbol( QChar( 0x00B0 ) ); QString aXStr = QString( "%1%2 %3' %4\"" ).arg( aXDeg ).arg( aDegSymbol ).arg( aXMin ).arg( aXSec ); @@ -434,30 +1004,37 @@ void HYDROGUI_Module::onViewPortMouseEvent( QGraphicsSceneMouseEvent* theEvent ) aViewPort->setViewLabelText( QString( "X: %1\nY: %2" ).arg( aXStr ).arg( aYStr ) ); } - else if( aRole == VMR_Mapping ) + else if( aRole == VMR_TransformImage ) aViewPort->setViewLabelText( QString( "X: %1\nY: %2" ).arg( (int)aMouseX ).arg( (int)aMouseY ) ); } + */ } -void HYDROGUI_Module::updateGV( const bool theIsInit, - const bool theIsForced ) +void HYDROGUI_Module::updateViewer( HYDROGUI_AbstractDisplayer* theDisplayer, + const bool theIsInit, + const bool theIsForced, + const bool theDoFitAll ) { - if( !getDisplayer() ) - return; - QList aViewManagerIdList; // currently, all views are updated ViewManagerMapIterator anIter( myViewManagerMap ); while( anIter.hasNext() ) - { - int anId = anIter.next().key(); - aViewManagerIdList.append( anId ); + { + SUIT_ViewManager* aViewManager = anIter.next().value().first; + + if ( theDisplayer->IsApplicable( aViewManager ) ) + { + int anId = anIter.key(); + aViewManagerIdList.append( anId ); + } } QListIterator anIdIter( aViewManagerIdList ); while( anIdIter.hasNext() ) - getDisplayer()->UpdateAll( anIdIter.next(), theIsInit, theIsForced ); + { + theDisplayer->UpdateAll( anIdIter.next(), theIsInit, theIsForced, theDoFitAll ); + } } void HYDROGUI_Module::createSelector( SUIT_ViewManager* theViewManager ) @@ -470,12 +1047,8 @@ void HYDROGUI_Module::createSelector( SUIT_ViewManager* theViewManager ) return; QString aViewType = theViewManager->getType(); - if( aViewType != GraphicsView_Viewer::Type() ) - return; - - GraphicsView_ViewManager* aViewManager = - dynamic_cast( theViewManager ); - if( !aViewManager ) + if( aViewType != GraphicsView_Viewer::Type() && + aViewType != OCCViewer_Viewer::Type()) return; QList aSelectorList; @@ -486,11 +1059,26 @@ void HYDROGUI_Module::createSelector( SUIT_ViewManager* theViewManager ) for( anIter = aSelectorList.begin(); anIter != anIterEnd; anIter++ ) { SUIT_Selector* aSelector = *anIter; - if( aSelector && !dynamic_cast( aSelector ) ) + if( aSelector && ( !dynamic_cast( aSelector ) && + !dynamic_cast( aSelector ) && + !dynamic_cast( aSelector ) ) ) aSelector->setEnabled( false ); } - new HYDROGUI_GVSelector( this, aViewManager->getViewer(), aSelectionMgr ); + if ( aViewType == GraphicsView_Viewer::Type() ) + { + GraphicsView_ViewManager* aViewManager = + ::qobject_cast( theViewManager ); + if( aViewManager ) + new HYDROGUI_GVSelector( this, aViewManager->getViewer(), aSelectionMgr ); + } + else if ( aViewType == OCCViewer_Viewer::Type() ) + { + OCCViewer_ViewManager* aViewManager = + ::qobject_cast( theViewManager ); + if( aViewManager ) + new HYDROGUI_OCCSelector( this, aViewManager->getOCCViewer(), aSelectionMgr ); + } } bool HYDROGUI_Module::setUpdateEnabled( const bool theState ) @@ -504,3 +1092,34 @@ bool HYDROGUI_Module::isUpdateEnabled() const { return myIsUpdateEnabled; } + +QStringList HYDROGUI_Module::storeSelection() const +{ + QStringList anEntryList; + if( LightApp_SelectionMgr* aSelectionMgr = getApp()->selectionMgr() ) + { + SUIT_DataOwnerPtrList aList( true ); + aSelectionMgr->selected( aList ); + + SUIT_DataOwnerPtrList::iterator anIter; + for( anIter = aList.begin(); anIter != aList.end(); anIter++ ) + { + const LightApp_DataOwner* anOwner = + dynamic_cast( (*anIter).operator->() ); + if( anOwner ) + anEntryList.append( anOwner->entry() ); + } + } + return anEntryList; +} + +void HYDROGUI_Module::restoreSelection( const QStringList& theEntryList ) +{ + if( LightApp_SelectionMgr* aSelectionMgr = getApp()->selectionMgr() ) + { + SUIT_DataOwnerPtrList aList( true ); + for( int anIndex = 0, aSize = theEntryList.size(); anIndex < aSize; anIndex++ ) + aList.append( SUIT_DataOwnerPtr( new LightApp_DataOwner( theEntryList[ anIndex ] ) ) ); + aSelectionMgr->setSelected( aList ); + } +}