X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROGUI%2FHYDROGUI_Module.cxx;h=8c8396d6624b33cc60e44e61f42c8f56f2aaec70;hb=06a6e19d03f1d202e3a58042fdf1abc1000b7c2c;hp=4dd19fe07a0b966ee57c0da1f70d8b4c73f3c29d;hpb=061386caa71490489a0475540932d9f2e48d77dc;p=modules%2Fhydro.git diff --git a/src/HYDROGUI/HYDROGUI_Module.cxx b/src/HYDROGUI/HYDROGUI_Module.cxx index 4dd19fe0..8c8396d6 100644 --- a/src/HYDROGUI/HYDROGUI_Module.cxx +++ b/src/HYDROGUI/HYDROGUI_Module.cxx @@ -28,30 +28,65 @@ #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 + #include #include #include #include +#include +#include static int ViewManagerId = 0; @@ -60,9 +95,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 +132,49 @@ 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& ) ) ); + + HYDROGUI_Tool::setOCCActionShown( this, OCCViewer_ViewWindow::MaximizedId, false ); + + ViewManagerList anOCCViewManagers; + anApp->viewManagers( OCCViewer_Viewer::Type(), anOCCViewManagers ); + foreach ( const SUIT_ViewManager* aViewManager, anOCCViewManagers ) { + connect( aViewManager, SIGNAL( mouseMove( SUIT_ViewWindow*, QMouseEvent* ) ), + this, SLOT( onMouseMove( SUIT_ViewWindow*, QMouseEvent* ) ) ); + foreach( SUIT_ViewWindow* aViewWindow, aViewManager->getViews() ) { + OCCViewer_ViewFrame* aViewFrame = dynamic_cast( aViewWindow ); + if ( aViewFrame && aViewFrame->getViewPort() ) { + aViewFrame->getViewPort()->installEventFilter( this ); + } + } + } + return aRes; } @@ -115,9 +186,30 @@ bool HYDROGUI_Module::deactivateModule( SUIT_Study* theStudy ) getApp()->removeViewManager( aViewManager ); myViewManagerMap.clear(); + ViewManagerList anOCCViewManagers; + getApp()->viewManagers( OCCViewer_Viewer::Type(), anOCCViewManagers ); + foreach ( const SUIT_ViewManager* aViewManager, anOCCViewManagers ) { + disconnect( aViewManager, SIGNAL( mouseMove( SUIT_ViewWindow*, QMouseEvent* ) ), + this, SLOT( onMouseMove( SUIT_ViewWindow*, QMouseEvent* ) ) ); + } + + myObjectStateMap.clear(); + myShapesMap.clear(); + myVTKPrsMap.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& ) ) ); + + HYDROGUI_Tool::setOCCActionShown( this, OCCViewer_ViewWindow::MaximizedId, true ); + return LightApp_Module::deactivateModule( theStudy ); } @@ -125,12 +217,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,83 +234,305 @@ void HYDROGUI_Module::contextMenuPopup( const QString& theClient, { HYDROGUI_DataModel* aModel = getDataModel(); - int aViewId = HYDROGUI_Tool::GetActiveGraphicsViewId( this ); + 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; - bool anIsSelection = false; + 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 anIsPolyline3D = false; + bool anIsProfile = false; + bool anIsValidProfile = false; + bool anAllAreProfiles = false; + bool anIsBathymetry = false; + bool anIsCalculation = false; + bool anIsImmersibleZone = false; bool anIsVisualState = false; + bool anIsRegion = false; + bool anIsZone = false; + bool anIsObstacle = false; + bool anIsStream = false; + bool anIsChannel = 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 ); + int aNbOfSelectedProfiles = 0; 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->IsVisible( aViewId ); + bool aVisibility = isObjectVisible( anActiveViewId, anObject ); anIsVisibleInSelection |= aVisibility; anIsHiddenInSelection |= !aVisibility; - if( anObject->GetKind() == KIND_IMAGE ) + ObjectKind anObjectKind = anObject->GetKind(); + if( anObjectKind == KIND_IMAGE ) + { anIsImage = true; - else if( anObject->GetKind() == KIND_POLYLINE ) + Handle(HYDROData_Image) anImage = Handle(HYDROData_Image)::DownCast( anObject ); + if( !anImage.IsNull() ) + { + anIsImportedImage = anImage->HasLocalPoints(); + 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( anObjectKind == KIND_POLYLINEXY ) anIsPolyline = true; - else if( anObject->GetKind() == KIND_VISUAL_STATE ) + else if( anObjectKind == KIND_POLYLINE ) + anIsPolyline3D = true; + else if( anObjectKind == KIND_PROFILE ) + { + anIsProfile = true; + aNbOfSelectedProfiles++; + + Handle(HYDROData_Profile) aProfile = + Handle(HYDROData_Profile)::DownCast( anObject ); + if( !aProfile.IsNull() && aProfile->IsValid() ) { + anIsValidProfile = true; + } + } + else if( anObjectKind == KIND_CALCULATION ) + anIsCalculation = true; + else if( anObjectKind == KIND_IMMERSIBLE_ZONE ) + anIsImmersibleZone = true; + else if( anObjectKind == KIND_VISUAL_STATE ) anIsVisualState = true; + else if( anObjectKind == KIND_REGION ) + anIsRegion = true; + else if( anObjectKind == KIND_ZONE ) + anIsZone = true; + else if( anObjectKind == KIND_BATHYMETRY ) + anIsBathymetry = true; + else if( anObjectKind == KIND_OBSTACLE ) + anIsObstacle = true; + else if( anObjectKind == KIND_STREAM ) + anIsStream = true; + else if( anObjectKind == KIND_CHANNEL ) + anIsChannel = true; } + + anIsGeomObject = HYDROData_Tool::IsGeometryObject( anObject ); } - if( aSeq.IsEmpty() ) + // Check if all selected objects are profiles + anAllAreProfiles = ( aNbOfSelectedProfiles > 0 ) && + ( aNbOfSelectedProfiles == aSeq.Length() ); + + // check the selected partitions + if( !anIsSelectedDataObjects && anIsObjectBrowser ) { - theMenu->addAction( action( SaveVisualStateId ) ); - theMenu->addSeparator(); + ObjectKind aSelectedPartition = HYDROGUI_Tool::GetSelectedPartition( this ); + if( aSelectedPartition != KIND_UNKNOWN ) + { + switch( aSelectedPartition ) + { + case KIND_IMAGE: + theMenu->addAction( action( ImportImageId ) ); + break; + case KIND_BATHYMETRY: + theMenu->addAction( action( ImportBathymetryId ) ); + break; + case KIND_ARTIFICIAL_OBJECT: + theMenu->addAction( action( CreateChannelId ) ); + break; + case KIND_NATURAL_OBJECT: + theMenu->addAction( action( CreateImmersibleZoneId ) ); + theMenu->addAction( action( CreateStreamId ) ); + break; + case KIND_OBSTACLE: + theMenu->addAction( action( ImportObstacleFromFileId ) ); + theMenu->addAction( action( CreateBoxId ) ); + theMenu->addAction( action( CreateCylinderId ) ); + break; + case KIND_CALCULATION: + theMenu->addAction( action( CreateCalculationId ) ); + break; + case KIND_POLYLINEXY: + theMenu->addAction( action( CreatePolylineId ) ); + break; + case KIND_POLYLINE: + theMenu->addAction( action( CreatePolyline3DId ) ); + break; + case KIND_PROFILE: + theMenu->addAction( action( CreateProfileId ) ); + theMenu->addAction( action( ImportProfilesId ) ); + theMenu->addAction( action( AllGeoreferencementId ) ); + break; + case KIND_VISUAL_STATE: + theMenu->addAction( action( SaveVisualStateId ) ); + break; + } + theMenu->addSeparator(); + } } - else if( anIsSelection && aSeq.Length() == 1 ) + + if( anIsSelectedDataObjects ) { - if( anIsImage ) + if ( anIsMustBeUpdatedImage ) { - theMenu->addAction( action( EditImageId ) ); - theMenu->addAction( action( ObserveImageId ) ); - theMenu->addAction( action( ExportImageId ) ); + theMenu->addAction( action( UpdateImageId ) ); theMenu->addSeparator(); } - else if( anIsPolyline ) + + if( aSeq.Length() == 1 ) { - theMenu->addAction( action( EditPolylineId ) ); + 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( anIsPolyline3D ) + { + theMenu->addAction( action( EditPolyline3DId ) ); + theMenu->addSeparator(); + } + else if( anIsProfile ) + { + theMenu->addAction( action( EditProfileId ) ); + theMenu->addAction( action( SelectedGeoreferencementId ) ); + 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( anIsStream ) + { + theMenu->addAction( action( EditStreamId ) ); + theMenu->addSeparator(); + } + else if( anIsChannel ) + { + theMenu->addAction( action( EditChannelId ) ); + 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(); + } + } else if ( anAllAreProfiles ) { + theMenu->addAction( action( SelectedGeoreferencementId ) ); theMenu->addSeparator(); } - else if( anIsVisualState ) + + theMenu->addAction( action( DeleteId ) ); + theMenu->addSeparator(); + + if( anIsImage || anIsPolyline || anIsPolyline3D || + anIsImmersibleZone || anIsZone || anIsRegion || + anIsBathymetry || anIsObstacle || anIsStream || + anIsChannel || anIsValidProfile ) { - theMenu->addAction( action( SaveVisualStateId ) ); - theMenu->addAction( action( LoadVisualStateId ) ); + if( anIsHiddenInSelection ) + theMenu->addAction( action( ShowId ) ); + theMenu->addAction( action( ShowOnlyId ) ); + if( anIsVisibleInSelection ) + theMenu->addAction( action( HideId ) ); theMenu->addSeparator(); } } - if( anIsSelection ) + if ( anIsOCCView ) { - theMenu->addAction( action( DeleteId ) ); - theMenu->addSeparator(); + SUIT_Operation* anOp = application()->activeStudy()->activeOperation(); + HYDROGUI_PolylineOp* aPolylineOp = dynamic_cast( anOp ); + if ( aPolylineOp && aPolylineOp->deleteEnabled() ) + theMenu->addAction( action( DeleteId ) ); } - if( anIsSelection && ( anIsImage || anIsPolyline ) ) + if( anIsObjectBrowser || anIsGraphicsView || anIsOCCView || anIsVTKView ) { - if( anIsHiddenInSelection ) - theMenu->addAction( action( ShowId ) ); - theMenu->addAction( action( ShowOnlyId ) ); - if( anIsVisibleInSelection ) - theMenu->addAction( action( HideId ) ); + 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 ) @@ -229,19 +546,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(); @@ -253,8 +592,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 @@ -267,6 +612,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 ) ) @@ -280,6 +644,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 ); @@ -315,6 +705,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 ); @@ -332,20 +948,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 ); } } } @@ -364,6 +984,17 @@ bool HYDROGUI_Module::eventFilter( QObject* theObj, QEvent* theEvent ) theObj->removeEventFilter( this ); } } + else if ( theObj->inherits( "OCCViewer_ViewPort" ) ) + { + if( aType == QEvent::Leave ) + { + SUIT_Desktop* aDesktop = getApp()->desktop(); + if ( aDesktop && aDesktop->statusBar() ) { + aDesktop->statusBar()->clearMessage(); + } + } + } + return LightApp_Module::eventFilter( theObj, theEvent ); } @@ -373,11 +1004,18 @@ 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* ) ) ); + connect( theViewManager, SIGNAL( mouseMove( SUIT_ViewWindow*, QMouseEvent* ) ), + this, SLOT( onMouseMove( SUIT_ViewWindow*, QMouseEvent* ) ) ); + } + + createSelector( theViewManager ); // replace the default selector ViewManagerInfo anInfo( theViewManager, VMR_General ); myViewManagerMap.insert( ViewManagerId++, anInfo ); @@ -391,7 +1029,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 ) @@ -406,13 +1065,27 @@ 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(); + + HYDROGUI_Tool::setOCCActionShown( aViewFrame, OCCViewer_ViewWindow::MaximizedId, false ); + + OCCViewer_ViewPort3d* aViewPort = aViewFrame->getViewPort(); + if ( aViewPort ) { + aViewPort->installEventFilter( this ); + } } } } void HYDROGUI_Module::onViewPortMouseEvent( QGraphicsSceneMouseEvent* theEvent ) { + /* ouv: currently unused if( GraphicsView_ViewPort* aViewPort = qobject_cast( sender() ) ) { SUIT_ViewManager* aViewManager = 0; @@ -442,8 +1115,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 ); @@ -454,27 +1127,34 @@ void HYDROGUI_Module::onViewPortMouseEvent( QGraphicsSceneMouseEvent* theEvent ) 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 ) @@ -487,12 +1167,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; @@ -503,11 +1179,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 ) @@ -521,3 +1212,60 @@ 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 ); + } +} + +void HYDROGUI_Module::onMouseMove( SUIT_ViewWindow* theViewWindow, QMouseEvent* theEvent ) +{ + OCCViewer_ViewWindow* anOCCViewWindow = + dynamic_cast(theViewWindow); + if ( !anOCCViewWindow ) { + return; + } + + // Get the selected point coordinates + OCCViewer_ViewPort3d* aViewPort = anOCCViewWindow->getViewPort(); + if ( !aViewPort ) { + return; + } + + gp_Pnt aPnt = GEOMUtils::ConvertClickToPoint( theEvent->x(), theEvent->y(), + aViewPort->getView() ); + + // Show the coordinates in the status bar + SUIT_Desktop* aDesktop = getApp()->desktop(); + if ( aDesktop && aDesktop->statusBar() ) { + QString aX = HYDROGUI_Tool::GetCoordinateString( aPnt.X() ); + QString anY = HYDROGUI_Tool::GetCoordinateString( aPnt.Y() ); + aDesktop->statusBar()->showMessage( tr("COORDINATES_INFO").arg( aX ).arg( anY ) ); + } +} \ No newline at end of file