X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROGUI%2FHYDROGUI_Module.cxx;h=3d5dc177b24e0ea104e9ad3e3db34593e223479e;hb=5e9382826b48843ce2b958dc4d9a5e0b99f938c7;hp=604ed597512ab270758189fc867e779fdf846210;hpb=8c70d5cb1e04edf503afb50caf735fa1c4f45b25;p=modules%2Fhydro.git diff --git a/src/HYDROGUI/HYDROGUI_Module.cxx b/src/HYDROGUI/HYDROGUI_Module.cxx index 604ed597..3d5dc177 100644 --- a/src/HYDROGUI/HYDROGUI_Module.cxx +++ b/src/HYDROGUI/HYDROGUI_Module.cxx @@ -1,12 +1,8 @@ -// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE -// -// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, -// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS -// +// Copyright (C) 2014-2015 EDF-R&D // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either -// version 2.1 of the License. +// version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -24,6 +20,7 @@ #include "HYDROGUI.h" #include "HYDROGUI_DataModel.h" +#include "HYDROGUI_DataObject.h" #include "HYDROGUI_Displayer.h" #include "HYDROGUI_GVSelector.h" #include "HYDROGUI_InputPanel.h" @@ -39,14 +36,21 @@ #include "HYDROGUI_VTKPrsDisplayer.h" #include "HYDROGUI_AbstractDisplayer.h" #include "HYDROGUI_PolylineOp.h" +#include "HYDROGUI_SetColorOp.h" +#include "HYDROGUI_ImportGeomObjectOp.h" +#include "HYDROGUI_ShowHideOp.h" +#include #include +#include #include #include -#include +#include #include +#include + #include #include #include @@ -62,6 +66,8 @@ #include #include +#include + #include #include #include @@ -69,18 +75,32 @@ #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; @@ -147,29 +167,107 @@ bool HYDROGUI_Module::activateModule( SUIT_Study* theStudy ) HYDROGUI_Tool::WindowDock( anApp->getWindow( LightApp_Application::WT_LogWindow ) ) ); #endif + // Remove defunct view managers from the map. + // It's essential to do this before "update( UF_All )" call! + QList anObsoleteIds; + ViewManagerList anAllViewManagers = anApp->viewManagers(); + ViewManagerList aHydroViewManagers; // view managers created inside the HYDRO module + ViewManagerMapIterator anIter( myViewManagerMap ); + while( anIter.hasNext() ) { + int anId = anIter.next().key(); + const ViewManagerInfo& anInfo = anIter.value(); + + aHydroViewManagers << anInfo.first; + + if ( !anAllViewManagers.contains( anInfo.first ) ) { + anObsoleteIds << anId; + } + } + foreach ( const int anId, anObsoleteIds ) { + myViewManagerMap.remove( anId ); + myObjectStateMap.remove( anId ); + myShapesMap.remove( anId ); + myVTKPrsMap.remove( anId ); + } + // Replace the default selector for all view managers. + // Add view managers created outside of HYDRO module to the map. + foreach ( SUIT_ViewManager* aViewManager, anAllViewManagers ) { + createSelector( aViewManager ); // replace the default selector + if ( !aHydroViewManagers.contains( aViewManager ) ) { + ViewManagerInfo anInfo( aViewManager, VMR_General ); + myViewManagerMap.insert( ViewManagerId++, anInfo ); + } + } + 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 ); + } + } + } + + // Load GEOM data + SalomeApp_Study* aStudy = + dynamic_cast( getApp()->activeStudy() ); + if ( aStudy ) { + SALOMEDS::Study_var aDSStudy = GeometryGUI::ClientStudyToStudy( aStudy->studyDS() ); + GEOM::GEOM_Gen_var aGeomEngine = GeometryGUI::GetGeomGen(); + if ( !aGeomEngine->_is_nil() && !aGeomEngine->_is_nil() ) { + SALOMEDS::StudyBuilder_var aStudyBuilder = aDSStudy->NewBuilder(); + SALOMEDS::SComponent_wrap GEOM_var = aDSStudy->FindComponent( "GEOM" ); + if( !GEOM_var->_is_nil() ) { + aStudyBuilder->LoadWith( GEOM_var, aGeomEngine ); + } + } + } + +// SUIT_DataBrowser* ob = getApp()->objectBrowser(); +// SUIT_AbstractModel* treeModel = dynamic_cast( ob->model() ); +// treeModel->setAppropriate( SUIT_DataObject::VisibilityId, Qtx::Toggled ); + return aRes; } bool HYDROGUI_Module::deactivateModule( SUIT_Study* theStudy ) { + /* Issues ## 68, 88. ViewManagerMapIterator anIter( myViewManagerMap ); while( anIter.hasNext() ) if( SUIT_ViewManager* aViewManager = anIter.next().value().first ) 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* ) ) ); + } + + /* Issues ## 68, 88. myObjectStateMap.clear(); myShapesMap.clear(); myVTKPrsMap.clear(); + */ + + // clear the status bar + SUIT_Desktop* aDesktop = getApp()->desktop(); + if ( aDesktop && aDesktop->statusBar() ) { + aDesktop->statusBar()->clearMessage(); + } // clear the data model's list of copying objects HYDROGUI_DataModel::changeCopyingObjects( HYDROData_SequenceOfObjects() ); @@ -179,11 +277,9 @@ bool HYDROGUI_Module::deactivateModule( SUIT_Study* theStudy ) 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 ); + myActiveOperationMap.clear(); return LightApp_Module::deactivateModule( theStudy ); } @@ -199,7 +295,7 @@ void HYDROGUI_Module::windows( QMap& theMap ) const void HYDROGUI_Module::viewManagers( QStringList& theTypesList ) const { - theTypesList << OCCViewer_Viewer::Type() << GraphicsView_Viewer::Type(); + theTypesList << GraphicsView_Viewer::Type() << OCCViewer_Viewer::Type(); } void HYDROGUI_Module::contextMenuPopup( const QString& theClient, @@ -227,7 +323,7 @@ void HYDROGUI_Module::contextMenuPopup( const QString& theClient, bool anIsFusedImage = false; bool anIsCutImage = false; bool anIsSplittedImage = false; - bool anIsMustBeUpdatedImage = false; + bool anIsMustObjectBeUpdated = false; bool anIsPolyline = false; bool anIsPolyline3D = false; bool anIsProfile = false; @@ -240,13 +336,52 @@ void HYDROGUI_Module::contextMenuPopup( const QString& theClient, bool anIsRegion = false; bool anIsZone = false; bool anIsObstacle = false; + bool anIsStricklerTable = false; + bool anIsLandCover = false; bool anIsStream = false; - bool anIsGeomObject = false; + bool anIsChannel = false; + bool anIsDigue = false; + bool anIsDummyObject3D = false; + bool anIsGroup = false; + bool anIsObjectCanBeColored = false; + bool isRoot = false; + bool isStreamHasBottom = false; + + SUIT_SelectionMgr* aSelectionMgr = getApp()->selectionMgr(); + SUIT_DataOwnerPtrList anOwners; + aSelectionMgr->selected( anOwners ); + if( anIsObjectBrowser && anOwners.size()==1 ) + { + QString anEntry = anOwners[0]->keyString(); + LightApp_Study* aStudy = dynamic_cast( getApp()->activeStudy() ); + if( aStudy ) + isRoot = aStudy->isComponent( anEntry ); + } - // check the selected GEOM objects - if ( !HYDROGUI_Tool::GetSelectedGeomObjects( this ).isEmpty() ) { - theMenu->addAction( action( ImportGeomObjectId ) ); - theMenu->addSeparator(); + // Check the selected GEOM objects (take into account the Object Browser only) + if ( anIsObjectBrowser ) { + QList anObstacleTypes = + HYDROGUI_ImportGeomObjectOp::getObstacleTypes(); + QList aPolylineTypes = + HYDROGUI_ImportGeomObjectOp::getPolylineTypes(); + + bool isCanBeImportedAsObstacle = + !HYDROGUI_Tool::GetSelectedGeomObjects( this, anObstacleTypes ).isEmpty(); + bool isCanBeImportedAsPolyline = + !HYDROGUI_Tool::GetSelectedGeomObjects( this, aPolylineTypes ).isEmpty(); + + // Add import as obstacle action + if ( isCanBeImportedAsObstacle ) { + theMenu->addAction( action( ImportGeomObjectAsObstacleId ) ); + } + // Add import as polyline action + if ( isCanBeImportedAsPolyline ) { + theMenu->addAction( action( ImportGeomObjectAsPolylineId ) ); + } + // Add separator + if ( isCanBeImportedAsObstacle || isCanBeImportedAsPolyline ) { + theMenu->addSeparator(); + } } // check the selected data model objects @@ -263,6 +398,11 @@ void HYDROGUI_Module::contextMenuPopup( const QString& theClient, anIsVisibleInSelection |= aVisibility; anIsHiddenInSelection |= !aVisibility; + if ( anObject->CanBeUpdated() && anObject->IsMustBeUpdated() ) + { + anIsMustObjectBeUpdated = true; + } + ObjectKind anObjectKind = anObject->GetKind(); if( anObjectKind == KIND_IMAGE ) { @@ -285,10 +425,6 @@ void HYDROGUI_Module::contextMenuPopup( const QString& theClient, anIsSplittedImage = true; } } - if ( anImage->IsMustBeUpdated() ) - { - anIsMustBeUpdatedImage = true; - } } } else if( anObjectKind == KIND_POLYLINEXY ) @@ -320,11 +456,30 @@ void HYDROGUI_Module::contextMenuPopup( const QString& theClient, anIsBathymetry = true; else if( anObjectKind == KIND_OBSTACLE ) anIsObstacle = true; + else if( anObjectKind == KIND_STRICKLER_TABLE ) + anIsStricklerTable = true; + else if( anObjectKind == KIND_LAND_COVER ) + anIsLandCover = true; else if( anObjectKind == KIND_STREAM ) + { anIsStream = true; + Handle(HYDROData_Stream) aStream = + Handle(HYDROData_Stream)::DownCast( anObject ); + if ( !aStream.IsNull() ) + isStreamHasBottom = !aStream->GetBottomPolyline().IsNull(); + } + else if( anObjectKind == KIND_CHANNEL ) + anIsChannel = true; + else if( anObjectKind == KIND_DIGUE ) + anIsDigue = true; + else if( anObjectKind == KIND_DUMMY_3D ) + anIsDummyObject3D = true; + else if( anObjectKind == KIND_SHAPES_GROUP || anObjectKind == KIND_SPLITTED_GROUP ) + anIsGroup = true; } - anIsGeomObject = HYDROData_Tool::IsGeometryObject( anObject ); + if ( !anIsObjectCanBeColored ) + anIsObjectCanBeColored = HYDROGUI_SetColorOp::CanObjectBeColored( anObject ); } // Check if all selected objects are profiles @@ -342,6 +497,31 @@ void HYDROGUI_Module::contextMenuPopup( const QString& theClient, case KIND_IMAGE: theMenu->addAction( action( ImportImageId ) ); break; + case KIND_BATHYMETRY: + theMenu->addAction( action( ImportBathymetryId ) ); + break; + case KIND_ARTIFICIAL_OBJECT: + theMenu->addAction( action( CreateChannelId ) ); + theMenu->addAction( action( CreateDigueId ) ); + 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_STRICKLER_TABLE: + theMenu->addAction( action( ImportStricklerTableFromFileId ) ); + break; + case KIND_LAND_COVER: + theMenu->addAction( action( CreateLandCoverId ) ); + break; + case KIND_CALCULATION: + theMenu->addAction( action( CreateCalculationId ) ); + break; case KIND_POLYLINEXY: theMenu->addAction( action( CreatePolylineId ) ); break; @@ -356,20 +536,6 @@ void HYDROGUI_Module::contextMenuPopup( const QString& theClient, 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(); } @@ -377,11 +543,17 @@ void HYDROGUI_Module::contextMenuPopup( const QString& theClient, if( anIsSelectedDataObjects ) { - if ( anIsMustBeUpdatedImage ) + if ( anIsMustObjectBeUpdated ) { - theMenu->addAction( action( UpdateImageId ) ); + theMenu->addAction( action( UpdateObjectId ) ); theMenu->addSeparator(); } + else + { + theMenu->addAction( action( ForcedUpdateObjectId ) ); + theMenu->addSeparator(); + } + if( aSeq.Length() == 1 ) { @@ -399,7 +571,7 @@ void HYDROGUI_Module::contextMenuPopup( const QString& theClient, theMenu->addAction( action( EditSplittedImageId ) ); } - theMenu->addAction( action( ObserveImageId ) ); + //RKV: BUG#98: theMenu->addAction( action( ObserveImageId ) ); theMenu->addAction( action( ExportImageId ) ); theMenu->addSeparator(); @@ -414,6 +586,12 @@ void HYDROGUI_Module::contextMenuPopup( const QString& theClient, theMenu->addAction( action( SplitImageId ) ); theMenu->addSeparator(); } + else if( anIsBathymetry ) + { + theMenu->addAction( action( EditImportedBathymetryId ) ); + theMenu->addAction( action( BathymetryBoundsId ) ); + theMenu->addSeparator(); + } else if( anIsPolyline ) { theMenu->addAction( action( EditPolylineId ) ); @@ -444,8 +622,41 @@ void HYDROGUI_Module::contextMenuPopup( const QString& theClient, else if( anIsStream ) { theMenu->addAction( action( EditStreamId ) ); + if ( action( RiverBottomContextId ) ) + { + theMenu->addAction( action( RiverBottomContextId ) ); + action( RiverBottomContextId )->setEnabled( !isStreamHasBottom ); + } + theMenu->addAction( action( ProfileInterpolateId ) ); + theMenu->addSeparator(); + } + else if( anIsChannel ) + { + theMenu->addAction( action( EditChannelId ) ); + theMenu->addSeparator(); + } + else if( anIsDigue ) + { + theMenu->addAction( action( EditDigueId ) ); + theMenu->addSeparator(); + } + else if( anIsObstacle ) + { + theMenu->addAction( action( TranslateObstacleId ) ); theMenu->addSeparator(); } + else if( anIsStricklerTable ) + { + theMenu->addAction( action( EditStricklerTableId ) ); + theMenu->addAction( action( ExportStricklerTableFromFileId ) ); + theMenu->addAction( action( DuplicateStricklerTableId ) ); + theMenu->addSeparator(); + } + else if( anIsLandCover ) + { + theMenu->addAction( action( EditLandCoverId ) ); + theMenu->addSeparator(); + } else if( anIsVisualState && anIsObjectBrowser ) { theMenu->addAction( action( SaveVisualStateId ) ); @@ -454,7 +665,7 @@ void HYDROGUI_Module::contextMenuPopup( const QString& theClient, } // Add set color action for geometrical objects - if ( anIsGeomObject ) + if ( anIsObjectCanBeColored ) { theMenu->addAction( action( SetColorId ) ); theMenu->addSeparator(); @@ -464,11 +675,24 @@ void HYDROGUI_Module::contextMenuPopup( const QString& theClient, theMenu->addSeparator(); } - theMenu->addAction( action( DeleteId ) ); + // Add copy action + QAction* aCopyAction = action( CopyId ); + if( aCopyAction && aCopyAction->isEnabled() ) { + theMenu->addAction( action( CopyId ) ); + theMenu->addSeparator(); + } + + // Add delete action + if( !anIsDummyObject3D ) + theMenu->addAction( action( DeleteId ) ); + theMenu->addSeparator(); - if( anIsImage || anIsPolyline || anIsPolyline3D || anIsImmersibleZone || anIsZone || - anIsRegion || anIsBathymetry || anIsObstacle || anIsStream || anIsValidProfile ) + if( anIsImage || anIsPolyline || anIsPolyline3D || + anIsImmersibleZone || anIsZone || anIsRegion || + anIsBathymetry || anIsObstacle || anIsStream || + anIsChannel || anIsDigue || anIsDummyObject3D || + anIsValidProfile || anIsGroup ) { if( anIsHiddenInSelection ) theMenu->addAction( action( ShowId ) ); @@ -485,6 +709,10 @@ void HYDROGUI_Module::contextMenuPopup( const QString& theClient, HYDROGUI_PolylineOp* aPolylineOp = dynamic_cast( anOp ); if ( aPolylineOp && aPolylineOp->deleteEnabled() ) theMenu->addAction( action( DeleteId ) ); + + theMenu->addSeparator(); + theMenu->addAction( action( SetZLevelId ) ); + theMenu->addSeparator(); } if( anIsObjectBrowser || anIsGraphicsView || anIsOCCView || anIsVTKView ) @@ -493,11 +721,80 @@ void HYDROGUI_Module::contextMenuPopup( const QString& theClient, theMenu->addAction( action( HideAllId ) ); theMenu->addSeparator(); } + + if ( anIsOCCView || anIsVTKView ) + { + theMenu->addSeparator(); + theMenu->addAction( action( CopyViewerPositionId ) ); + } + + if( isRoot ) + theMenu->addAction( action( EditLocalCSId ) ); + + if( anIsObjectBrowser && anOwners.size()==1 ) + { + if( aSeq.Size() > 0 ) + { + Handle( HYDROData_Object ) anObject = Handle( HYDROData_Object )::DownCast( aSeq.First() ); + if( !anObject.IsNull() ) + { + theMenu->addSeparator(); + theMenu->addAction( action( SubmersibleId ) ); + action( SubmersibleId )->setCheckable( true ); + action( SubmersibleId )->setChecked( anObject->IsSubmersible() ); + } + } + } +} + +void HYDROGUI_Module::createPreferences() +{ + int genTab = addPreference( tr( "PREF_TAB_GENERAL" ) ); + int CursorGroup = addPreference( tr( "PREF_GROUP_CURSOR" ), genTab ); + + int typeOfCursor = addPreference( tr( "PREF_TYPE_OF_CURSOR" ), CursorGroup, + LightApp_Preferences::Selector, "preferences", "type_of_cursor" ); + + // Set property cursor type + QList aCursorTypeIndicesList; + QList aCursorTypeIconsList; + + SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr(); + for ( int i = CT_ArrowCursor; i < CT_User; i++ ) { + QString icoFile = QString( "ICON_CURSOR_%1" ).arg( i+1 ); + QPixmap pixmap = resMgr->loadPixmap( "HYDRO", tr( qPrintable( icoFile ) ) ); + aCursorTypeIndicesList << i; + aCursorTypeIconsList << pixmap; + } + + setPreferenceProperty( typeOfCursor, "indexes", aCursorTypeIndicesList ); + setPreferenceProperty( typeOfCursor, "icons", aCursorTypeIconsList ); + + int viewerGroup = addPreference( tr( "PREF_GROUP_VIEWER" ), genTab ); + addPreference( tr( "PREF_VIEWER_AUTO_FITALL" ), viewerGroup, + LightApp_Preferences::Bool, "HYDRO", "auto_fit_all" ); + + int StricklerTableGroup = addPreference( tr( "PREF_GROUP_STRICKLER_TABLE" ), genTab ); + int defaultStricklerCoef = addPreference( tr( "PREF_DEFAULT_STRICKLER_COEFFICIENT" ), StricklerTableGroup, + LightApp_Preferences::DblSpin, "HYDRO", "default_strickler_coefficient" ); + setPreferenceProperty( defaultStricklerCoef, "precision", 2 ); + setPreferenceProperty( defaultStricklerCoef, "min", 0.00 ); + setPreferenceProperty( defaultStricklerCoef, "max", 1000000.00 ); + setPreferenceProperty( defaultStricklerCoef, "step", 0.01 ); +} + +QCursor HYDROGUI_Module::getPrefEditCursor() const +{ + int aCursorType = SUIT_Session::session()->resourceMgr()->integerValue("preferences", "type_of_cursor", (int)CT_CrossCursor ); + if ( aCursorType >= Qt::BlankCursor) + aCursorType++; + QCursor aCursor = QCursor( Qt::CursorShape(aCursorType) ); + return aCursor; } void HYDROGUI_Module::update( const int flags ) { - if( !isUpdateEnabled() ) + if ( !isUpdateEnabled() ) return; QApplication::setOverrideCursor( Qt::WaitCursor ); @@ -510,6 +807,12 @@ void HYDROGUI_Module::update( const int flags ) QStringList aSelectedEntries = storeSelection(); bool aDoFitAll = flags & UF_FitAll; + if ( aDoFitAll ) + { + SUIT_ResourceMgr* aResMgr = getApp()->resourceMgr(); + aDoFitAll = aResMgr->booleanValue( "HYDRO", "auto_fit_all", false ); + } + if( ( flags & UF_Viewer ) ) updateViewer( getDisplayer(), flags & UF_GV_Init, flags & UF_GV_Forced, aDoFitAll ); @@ -527,8 +830,17 @@ void HYDROGUI_Module::update( const int flags ) // the selection in the object browser. // Note: processEvents() should be called after updateGV(), // otherwise the application crashes from time to time. - //RKV: qApp->processEvents(); + //RKV: qApp->processEvents(); + SUIT_ResourceMgr* aResMgr = getApp()->resourceMgr(); + bool isResizeOnExpandItem = aResMgr->booleanValue( "ObjectBrowser", "resize_on_expand_item", false ); + SUIT_DataBrowser* anObjectBrowser = getApp()->objectBrowser(); + if ( isResizeOnExpandItem && anObjectBrowser ) { + anObjectBrowser->setResizeOnExpandItem( false ); // MZN: ISSUE #280 + } getApp()->updateObjectBrowser( true ); + if ( isResizeOnExpandItem && anObjectBrowser ) { + anObjectBrowser->setResizeOnExpandItem( true ); // MZN: ISSUE #280 + } } // Object browser is currently updated by using UF_Model flag @@ -671,12 +983,25 @@ bool HYDROGUI_Module::isObjectVisible( const int theViewId, if( theObject.IsNull() ) return false; - ViewId2Name2ObjectStateMap::const_iterator anIter1 = myObjectStateMap.find( theViewId ); + if( theViewId < 0 ) + { + //search in all + foreach( int aViewId, myObjectStateMap.keys() ) + { + if( isObjectVisible( aViewId, theObject ) ) + return true; + } + return false; + } + + ViewId2Entry2ObjectStateMap::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 Entry2ObjectStateMap& aEntry2ObjectStateMap = anIter1.value(); + QString anEntry = HYDROGUI_DataObject::dataObjectEntry( theObject ); + + Entry2ObjectStateMap::const_iterator anIter2 = aEntry2ObjectStateMap.find( anEntry ); + if( anIter2 != aEntry2ObjectStateMap.end() ) { const ObjectState& anObjectState = anIter2.value(); return anObjectState.Visibility; @@ -691,13 +1016,78 @@ void HYDROGUI_Module::setObjectVisible( const int theViewId, { if( !theObject.IsNull() ) { - Name2ObjectStateMap& aName2ObjectStateMap = myObjectStateMap[ theViewId ]; - ObjectState& anObjectState = aName2ObjectStateMap[ theObject->GetName() ]; + Entry2ObjectStateMap& aEntry2ObjectStateMap = myObjectStateMap[ theViewId ]; + QString anEntry = HYDROGUI_DataObject::dataObjectEntry( theObject ); + + ObjectState& anObjectState = aEntry2ObjectStateMap[ anEntry ]; anObjectState.Visibility = theState; + + HYDROGUI_DataObject* hydroObject = getDataModel()->getDataObject( theObject ); + if ( hydroObject ) + { + SUIT_AbstractModel* treeModel = dynamic_cast( getApp()->objectBrowser()->model() ); + QString id = hydroObject->text( hydroObject->customData( Qtx::IdType ).toInt() ); + Qtx::VisibilityState visState = treeModel->visibilityState( id ); + if ( visState != Qtx::UnpresentableState ) + treeModel->setVisibilityState( id, theState ? Qtx::ShownState : Qtx::HiddenState ); + } + } +} + +void HYDROGUI_Module::setIsToUpdate( const Handle(HYDROData_Entity)& theObject, + const bool theState ) +{ + if( !theObject.IsNull() ) + { + // Process OCC shapes + ViewId2ListOfShapes::const_iterator aShapesMapIter( myShapesMap.begin() ); + while( aShapesMapIter != myShapesMap.end() ) + { + const ListOfShapes& aShapesList = aShapesMapIter.value(); + foreach ( HYDROGUI_Shape* aShape, aShapesList ) + { + if ( aShape && IsEqual( aShape->getObject(), theObject ) ) + { + aShape->setIsToUpdate( theState ); + } + } + aShapesMapIter++; + } + // Process VTK shapes + ViewId2ListOfVTKPrs::const_iterator aVTKPrsMapIter( myVTKPrsMap.begin() ); + while( aVTKPrsMapIter != myVTKPrsMap.end() ) + { + const ListOfVTKPrs& aShapesList = aVTKPrsMapIter.value(); + foreach ( HYDROGUI_VTKPrs* aShape, aShapesList ) + { + if ( aShape && IsEqual( aShape->getObject(), theObject ) ) + { + aShape->setIsToUpdate( theState ); + } + } + aVTKPrsMapIter++; + } } } /////////////////// OCC SHAPES PROCESSING +QList HYDROGUI_Module::getObjectShapes( const int theViewId, + ObjectKind theKind ) const +{ + QList aResult; + + if ( myShapesMap.contains( theViewId ) ) + { + const ListOfShapes& aViewShapes = myShapesMap.value( theViewId ); + foreach ( HYDROGUI_Shape* aShape, aViewShapes ) + { + if( aShape && aShape->getObject()->GetKind()==theKind ) + aResult.append( aShape ); + } + } + return aResult; +} + HYDROGUI_Shape* HYDROGUI_Module::getObjectShape( const int theViewId, const Handle(HYDROData_Entity)& theObject ) const { @@ -803,30 +1193,62 @@ void HYDROGUI_Module::setObjectVTKPrs( const int theViewId 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] ) + if( theShape && theShape->needScalarBar() ) { - aGlobalRange[0] = aRange[0]; - anIsUpdate = true; - } - if ( aRange[1] > aGlobalRange[1] ) - { - aGlobalRange[1] = aRange[1]; - anIsUpdate = true; - } + // 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 ); - //} + //if ( anIsUpdate ) + //{ + updateVTKZRange( theViewId, aGlobalRange ); + //} + } ListOfVTKPrs& aViewShapes = myVTKPrsMap[ theViewId ]; aViewShapes.append( theShape ); } +void HYDROGUI_Module::removeObjectVTKPrs( const int theViewId, + const QString& theEntry ) +{ + if ( !myVTKPrsMap.contains( theViewId ) ) + return; + + ListOfVTKPrs& aViewShapes = myVTKPrsMap[ theViewId ]; + Handle(HYDROData_Entity) anObject; + QString anEntryRef; + for ( int i = 0; i < aViewShapes.length(); ) + { + HYDROGUI_VTKPrs* aShape = aViewShapes.at( i ); + anObject = aShape->getObject(); + anEntryRef = HYDROGUI_DataObject::dataObjectEntry( anObject ); + if ( aShape && (!anObject.IsNull()) && ( anEntryRef == theEntry ) ) + { + 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::removeObjectVTKPrs( const int theViewId, const Handle(HYDROData_Entity)& theObject ) { @@ -880,7 +1302,7 @@ void HYDROGUI_Module::updateVTKZRange( const int theViewId, double theRange[] ) for ( int i = 0, n = aViewShapes.length(); i < n; ++i ) { aShape = aViewShapes.at( i ); - if ( aShape ) + if ( aShape && aShape->needScalarBar() ) { aShape->setZRange( theRange ); } @@ -944,6 +1366,27 @@ 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(); + } + } + } + else if ( theObj->inherits( "SVTK_ViewWindow" ) ) + { + if( aType == QEvent::Leave ) + { + SUIT_Desktop* aDesktop = getApp()->desktop(); + if ( aDesktop && aDesktop->statusBar() ) { + aDesktop->statusBar()->clearMessage(); + } + } + } + return LightApp_Module::eventFilter( theObj, theEvent ); } @@ -960,6 +1403,15 @@ void HYDROGUI_Module::onViewManagerAdded( SUIT_ViewManager* theViewManager ) { connect( theViewManager, SIGNAL( viewCreated( SUIT_ViewWindow* ) ), this, SLOT( onViewCreated( SUIT_ViewWindow* ) ) ); + connect( theViewManager, SIGNAL( mouseMove( SUIT_ViewWindow*, QMouseEvent* ) ), + this, SLOT( onMouseMove( SUIT_ViewWindow*, QMouseEvent* ) ) ); + } + else if( theViewManager->getType() == SVTK_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 @@ -991,7 +1443,7 @@ void HYDROGUI_Module::onViewManagerRemoved( SUIT_ViewManager* theViewManager ) SVTK_Viewer* aVTKViewer = getVTKViewer( anId ); if ( aVTKViewer ) { - getVTKDisplayer()->DeleteScalarBar( anId ); + getVTKDisplayer()->EraseScalarBar( anId, true ); removeViewShapes( (size_t)aVTKViewer ); } } @@ -1021,6 +1473,18 @@ void HYDROGUI_Module::onViewCreated( SUIT_ViewWindow* theViewWindow ) aViewFrame->onTopView(); HYDROGUI_Tool::setOCCActionShown( aViewFrame, OCCViewer_ViewWindow::MaximizedId, false ); + + OCCViewer_ViewPort3d* aViewPort = aViewFrame->getViewPort(); + if ( aViewPort ) { + aViewPort->installEventFilter( this ); + } + } + } + else if( theViewWindow && theViewWindow->inherits( "SVTK_ViewWindow" ) ) + { + if( SVTK_ViewWindow* aViewFrame = dynamic_cast( theViewWindow ) ) + { + aViewFrame->installEventFilter( this ); } } } @@ -1185,3 +1649,97 @@ void HYDROGUI_Module::restoreSelection( const QStringList& theEntryList ) aSelectionMgr->setSelected( aList ); } } + +void HYDROGUI_Module::onMouseMove( SUIT_ViewWindow* theViewWindow, QMouseEvent* ) +{ + double X, Y, Z; + bool doShow = false; + HYDROGUI_Displayer* aDisplayer = getDisplayer(); + if ( aDisplayer ) + aDisplayer->SaveCursorViewPosition( theViewWindow ); + doShow = aDisplayer->GetCursorViewCoordinates( theViewWindow, X, Y, Z ); + + if ( doShow ) + { + // Show the coordinates in the status bar + SUIT_Desktop* aDesktop = getApp()->desktop(); + if ( aDesktop && aDesktop->statusBar() ) + { + gp_Pnt aWPnt( X, Y, Z ); + int aStudyId = application()->activeStudy()->id(); + HYDROData_Document::Document( aStudyId )->Transform( aWPnt, false ); + double WX = aWPnt.X(), WY = aWPnt.Y(); + + QString aXStr = HYDROGUI_Tool::GetCoordinateString( X, true ); + QString anYStr = HYDROGUI_Tool::GetCoordinateString( Y, true ); + QString aWXStr = HYDROGUI_Tool::GetCoordinateString( WX, true ); + QString aWYStr = HYDROGUI_Tool::GetCoordinateString( WY, true ); + QString aMsg = tr( "COORDINATES_INFO" ); + aMsg = aMsg.arg( aXStr ).arg( anYStr ).arg( aWXStr ).arg( aWYStr ); + aDesktop->statusBar()->showMessage( aMsg ); + } + } +} + +/** + * Returns stack of active operations; + */ +QStack& HYDROGUI_Module::getActiveOperations() +{ + return myActiveOperationMap; +} + +/** + * Returns the module active operation. If the active operation is show/hide, + * the method returns the previous operation if it is. + */ +HYDROGUI_Operation* HYDROGUI_Module::activeOperation() +{ + HYDROGUI_Operation* anOp = !myActiveOperationMap.empty() ? myActiveOperationMap.top() : 0; + + if ( dynamic_cast( anOp ) ) + { + QVectorIterator aVIt( myActiveOperationMap ); + aVIt.toBack(); + aVIt.previous(); // skip the top show/hide operation + anOp = aVIt.hasPrevious() ? aVIt.previous() : 0; + } + + return anOp; +} + +/*! + * \brief Virtual public slot + * + * This method is called after the object inserted into data view to update their visibility state + * This is default implementation + */ +void HYDROGUI_Module::onObjectClicked( SUIT_DataObject* theObject, int theColumn ) +{ + if ( !isActiveModule() ) + return; + + HYDROGUI_DataObject* hydroObject = dynamic_cast( theObject ); + + // change visibility of object + if ( !hydroObject || theColumn != SUIT_DataObject::VisibilityId ) + return; + + SUIT_AbstractModel* treeModel = dynamic_cast( getApp()->objectBrowser()->model() ); + + QString id = theObject->text( theObject->customData( Qtx::IdType ).toInt() ); + Qtx::VisibilityState visState = treeModel->visibilityState( id ); + if ( visState == Qtx::UnpresentableState ) + return; + + visState = visState == Qtx::ShownState ? Qtx::HiddenState : Qtx::ShownState; + treeModel->setVisibilityState( id, visState ); + + bool vis = visState == Qtx::ShownState; + if ( vis == isObjectVisible( HYDROGUI_Tool::GetActiveViewId( this ), hydroObject->modelObject() ) ) + return; + + setObjectVisible( HYDROGUI_Tool::GetActiveViewId( this ), hydroObject->modelObject(), vis ); + + update( UF_OCCViewer | ( visState == Qtx::ShownState ? UF_FitAll : 0 ) ); +}