X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROGUI%2FHYDROGUI_CalculationOp.cxx;h=954e789f45028ac10c404ea4ff7056d38026ace0;hb=e7225e329739e01faed6682de0bc83cf84c28de6;hp=30b2c63850c61ad3bda6e4a93d91f7568d625619;hpb=0c76593b1d11353467fe978da4ad99549c59899e;p=modules%2Fhydro.git diff --git a/src/HYDROGUI/HYDROGUI_CalculationOp.cxx b/src/HYDROGUI/HYDROGUI_CalculationOp.cxx index 30b2c638..954e789f 100644 --- a/src/HYDROGUI/HYDROGUI_CalculationOp.cxx +++ b/src/HYDROGUI/HYDROGUI_CalculationOp.cxx @@ -28,11 +28,13 @@ #include "HYDROGUI_Tool.h" #include "HYDROGUI_UpdateFlags.h" #include "HYDROGUI_Zone.h" +#include "HYDROGUI_Region.h" -#include +#include +#include #include -#include #include +#include #include #include @@ -40,11 +42,16 @@ #include #include +#include +#include #include #include +#include #include +#include +#include HYDROGUI_CalculationOp::HYDROGUI_CalculationOp( HYDROGUI_Module* theModule, bool theIsEdit ) : HYDROGUI_Operation( theModule ), @@ -72,12 +79,53 @@ void HYDROGUI_CalculationOp::startOperation() if ( !aPanel ) return; - myRegionsList.clear(); - aPanel->reset(); + SUIT_DataBrowser* aOb = ((LightApp_Application*)module()->application())->objectBrowser(); + QList aShortcuts = aOb->findChildren(); + QShortcut* aShortcut; + foreach( aShortcut, aShortcuts ) + { + if ( aShortcut->key() == + QKeySequence(((LightApp_Application*)module()->application())->objectBrowser()->shortcutKey( + SUIT_DataBrowser::RenameShortcut ) ) ) + { + aShortcut->setEnabled( false ); + } + } - QString anObjectName = HYDROGUI_Tool::GenerateObjectName( module(), "Case" ); + aPanel->reset(); + QStringList aList; + QStringList anEntryList; + HYDROData_SequenceOfObjects aSeq = HYDROGUI_Tool::GetGeometryObjects( module() ); + getNamesAndEntries( aSeq, aList, anEntryList ); + aPanel->setAllGeomObjects( aList, anEntryList ); + + // Get all polylines + aList.clear(); + anEntryList.clear(); + HYDROData_Iterator anIter( doc(), KIND_POLYLINEXY ); + Handle(HYDROData_PolylineXY) aPolylineObj; + QString aPolylineName; + for ( ; anIter.More(); anIter.Next() ) + { + aPolylineObj = Handle(HYDROData_PolylineXY)::DownCast( anIter.Current() ); + + if ( !aPolylineObj.IsNull() && aPolylineObj->IsClosed() ) + { + // Check the polyline shape + TopoDS_Shape aPolylineShape = aPolylineObj->GetShape(); + if ( !aPolylineShape.IsNull() && aPolylineShape.ShapeType() == TopAbs_WIRE ) { + aPolylineName = aPolylineObj->GetName(); + if ( !aPolylineName.isEmpty() ) + { + aList.append( aPolylineName ); + anEntryList.append( HYDROGUI_DataObject::dataObjectEntry( aPolylineObj ) ); + } + } + } + } + aPanel->setPolylineNames( aList, anEntryList ); - QStringList aSelectedObjects; + QString anObjectName = HYDROGUI_Tool::GenerateObjectName( module(), tr( "DEFAULT_CALCULATION_CASE_NAME" ) ); myEditedObject.Nullify(); if ( myIsEdit ) @@ -86,7 +134,20 @@ void HYDROGUI_CalculationOp::startOperation() if ( !myEditedObject.IsNull() ) { anObjectName = myEditedObject->GetName(); - updateGeomObjectsList(aPanel); + aPolylineObj = myEditedObject->GetBoundaryPolyline(); + if ( aPolylineObj.IsNull() ) + { + aPanel->setBoundary( QString() ); + } + else + { + aPolylineName = aPolylineObj->GetName(); + aPanel->setBoundary( aPolylineName ); + } + + aSeq = myEditedObject->GetGeometryObjects(); + getNamesAndEntries( aSeq, aList, anEntryList ); + aPanel->includeGeomObjects( aList ); } } else @@ -98,32 +159,26 @@ void HYDROGUI_CalculationOp::startOperation() aPanel->setObjectName( anObjectName ); aPanel->setEditedObject( myEditedObject ); -// aPanel->setSelectedGeomObjects( aSelectedObjects ); createPreview(); } -void HYDROGUI_CalculationOp::updateGeomObjectsList( HYDROGUI_CalculationDlg* thePanel ) const +void HYDROGUI_CalculationOp::getNamesAndEntries( const HYDROData_SequenceOfObjects& theSeq, + QStringList& theNames, QStringList& theEntries ) const { - Handle(HYDROData_Object) anObject; - Handle(HYDROData_Entity) anEntity; - QStringList aList; - // Update the list in the dialog - HYDROData_SequenceOfObjects aSeq = myEditedObject->GetGeometryObjects(); - HYDROData_SequenceOfObjects::Iterator anIter( aSeq ); + + theNames.clear(); + theEntries.clear(); + HYDROData_SequenceOfObjects::Iterator anIter( theSeq ); for ( ; anIter.More(); anIter.Next() ) { - anEntity = anIter.Value(); - if ( !anEntity.IsNull() ) - { - anObject = Handle(HYDROData_Object)::DownCast( anEntity ); - if ( !anObject.IsNull() ) - { - aList.append( anObject->GetName() ); - } - } + Handle(HYDROData_Entity) anEntity = anIter.Value(); + //if ( !HYDROData_Tool::IsGeometryObject( anEntity ) ) + // continue; + + theNames.append( anEntity->GetName() ); + theEntries.append( HYDROGUI_DataObject::dataObjectEntry( anEntity ) ); } - thePanel->setSelectedGeomObjects( aList ); } void HYDROGUI_CalculationOp::abortOperation() @@ -132,6 +187,7 @@ void HYDROGUI_CalculationOp::abortOperation() // Abort transaction abortDocOperation(); HYDROGUI_Operation::abortOperation(); + module()->getApp()->updateObjectBrowser(); } void HYDROGUI_CalculationOp::commitOperation() @@ -149,123 +205,314 @@ HYDROGUI_InputPanel* HYDROGUI_CalculationOp::createInputPanel() const // Connect signals and slots connect( aPanel, SIGNAL( addObjects() ), SLOT( onAddObjects() ) ); connect( aPanel, SIGNAL( removeObjects() ), SLOT( onRemoveObjects() ) ); - connect( aPanel, SIGNAL( splitZones() ), SLOT( onSplitZones() ) ); - connect( aPanel, SIGNAL( clicked( SUIT_DataObject* ) ), SLOT( onSelected( SUIT_DataObject* ) ) ); - connect( aPanel, SIGNAL( setMergeType( int, QString ) ), SLOT( onSetMergeType( int, QString ) ) ); + connect( aPanel, SIGNAL( addGroups() ), SLOT( onAddGroups() ) ); + connect( aPanel, SIGNAL( removeGroups() ), SLOT( onRemoveGroups() ) ); + connect( aPanel, SIGNAL( Next( const int ) ), SLOT( onNext( const int ) ) ); + connect( aPanel, SIGNAL( Back( const int ) ), SLOT( onHideZones() ) ); + //connect( aPanel, SIGNAL( clicked( SUIT_DataObject* ) ), SLOT( onSelected( SUIT_DataObject* ) ) ); + connect( aPanel, SIGNAL( setMergeType( int, QString& ) ), SLOT( onSetMergeType( int, QString& ) ) ); + connect( aPanel, SIGNAL( moveZones( SUIT_DataObject*, const QList& ) ), + SLOT( onMoveZones( SUIT_DataObject*, const QList& ) ) ); + connect( aPanel, SIGNAL( createRegion( const QList& ) ), + SLOT( onCreateRegion( const QList& ) ) ); + connect( aPanel, SIGNAL( clickedInZonesBrowser( SUIT_DataObject* ) ), + SLOT( onClickedInZonesBrowser( SUIT_DataObject* ) ) ); + connect( aPanel, SIGNAL( objectsSelected() ), + SLOT( onObjectsSelected() ) ); + connect( aPanel, SIGNAL( boundarySelected( const QString & ) ), + SLOT( onBoundarySelected( const QString & ) ) ); return aPanel; } -void HYDROGUI_CalculationOp::onSetMergeType( int theMergeType, QString theBathymetryName ) +void HYDROGUI_CalculationOp::onBoundarySelected ( const QString & theObjName ) { - HYDROGUI_CalculationDlg* aPanel = - ::qobject_cast( inputPanel() ); - if ( aPanel ) + bool anIsToUpdateViewer = false; + + // Remove the old boundary from the operation viewer + Handle(HYDROData_PolylineXY) aPrevPolyline = + myEditedObject->GetBoundaryPolyline(); + if ( !aPrevPolyline.IsNull() ) { - HYDROGUI_Zone* aZone = aPanel->getCurrentZone(); - if ( aZone ) + setObjectVisibility( aPrevPolyline, false ); + anIsToUpdateViewer = true; + } + + // Set the selected boundary polyline to the calculation case + Handle(HYDROData_PolylineXY) aNewPolyline = Handle(HYDROData_PolylineXY)::DownCast( + HYDROGUI_Tool::FindObjectByName( module(), theObjName, KIND_POLYLINEXY ) ); + myEditedObject->SetBoundaryPolyline( aNewPolyline ); + + if ( myPreviewViewManager ) + { + OCCViewer_Viewer* aViewer = myPreviewViewManager->getOCCViewer(); + if ( aViewer ) { - aZone->setMergeType( theMergeType, theBathymetryName ); + if ( !aNewPolyline.IsNull() ) + { + Handle(AIS_InteractiveContext) aCtx = aViewer->getAISContext(); + if ( !aCtx.IsNull() ) + { + setObjectVisibility( aNewPolyline, true ); + anIsToUpdateViewer = true; + } + } + + if ( anIsToUpdateViewer ) + module()->update( UF_OCCViewer ); } } } -void HYDROGUI_CalculationOp::onAddObjects() +void HYDROGUI_CalculationOp::onObjectsSelected() { - // Add geometry objects selected in the module browser to the calculation case - Handle(HYDROData_Object) anObject; + HYDROGUI_CalculationDlg* aPanel = + ::qobject_cast( inputPanel() ); + + QStringList aSelectedObjs = aPanel->getSelectedGeomObjects(); + QMap aSelectedObjsMap; + foreach( QString aName, aSelectedObjs ) + aSelectedObjsMap[aName] = true; + + + // Select the appropriate geometry object shape in the viewer + selectionMgr()->clearSelected(); + + // Unhighlight all objects except selected + HYDROGUI_Shape* aShape = 0, *aLastShape = 0; Handle(HYDROData_Entity) anEntity; - QStringList aList; - HYDROData_SequenceOfObjects aSeq = HYDROGUI_Tool::GetSelectedObjects( module() ); - for( Standard_Integer anIndex = 1, aLength = aSeq.Length(); anIndex <= aLength; anIndex++ ) + HYDROData_SequenceOfObjects aSeq = myEditedObject->GetGeometryObjects(); + HYDROData_SequenceOfObjects::Iterator anIter( aSeq ); + bool isSelected; + QString aName; + for ( ; anIter.More(); anIter.Next() ) { - anEntity = aSeq.Value( anIndex ); + anEntity = anIter.Value(); if ( !anEntity.IsNull() ) { - anObject = Handle(HYDROData_Object)::DownCast( anEntity ); - if( !anObject.IsNull() ) + aShape = module()->getObjectShape( HYDROGUI_Module::VMR_PreviewCaseZones, anEntity ); + if ( aShape ) { - if (myEditedObject->AddGeometryObject( anObject )) - { - aList.append( anObject->GetName() ); - } + aName = anEntity->GetName(); + isSelected = aSelectedObjsMap.contains( aName ); + aShape->highlight( isSelected, false ); + aShape->update( false ); + aLastShape = aShape; } } } - HYDROGUI_CalculationDlg* aPanel = - ::qobject_cast( inputPanel() ); - if ( aPanel ) + if( aLastShape ) + aLastShape->update( true ); +} + +void HYDROGUI_CalculationOp::onClickedInZonesBrowser( SUIT_DataObject* theItem ) +{ + HYDROGUI_Region* aRegionItem = dynamic_cast(theItem); + HYDROGUI_Zone* aZoneItem; + selectionMgr()->clearSelected(); + if ( aRegionItem ) + { + // Select a region in preview + SUIT_DataOwnerPtrList aList( true ); + DataObjectList aZones = aRegionItem->children(); + for ( int i = 0; i < aZones.length(); i++ ) + { + aZoneItem = dynamic_cast(aZones.at(i)); + if ( aZoneItem ) + { + aList.append( SUIT_DataOwnerPtr( new LightApp_DataOwner( aZoneItem->entry() ) ) ); + } + } + selectionMgr()->setSelected( aList ); + } + else { - updateGeomObjectsList( aPanel ); + // select a single zone + aZoneItem = dynamic_cast(theItem); + if ( aZoneItem ) + { + SUIT_DataOwnerPtrList aList( true ); + aList.append( SUIT_DataOwnerPtr( new LightApp_DataOwner( aZoneItem->entry() ) ) ); + selectionMgr()->setSelected( aList ); + } } } -void HYDROGUI_CalculationOp::onRemoveObjects() +void HYDROGUI_CalculationOp::onMoveZones( SUIT_DataObject* theRegionItem, const QList& theZonesList ) +{ + HYDROGUI_Region* aRegion = dynamic_cast(theRegionItem); + if ( aRegion ) + { + QList aZonesList; + HYDROGUI_Zone* aZone; + // Get a list of dropped zones + for ( int i = 0; i < theZonesList.length(); i++ ) + { + aZone = dynamic_cast( theZonesList.at( i ) ); + if ( aZone ) + { + aZonesList.append( aZone ); + } + } + if ( aZonesList.length() > 0 ) + { + aRegion->addZones( aZonesList ); + HYDROGUI_CalculationDlg* aPanel = + ::qobject_cast( inputPanel() ); + if ( aPanel ) + { + aPanel->refreshZonesBrowser(); + } + createPreview(); + } + } +} + +void HYDROGUI_CalculationOp::onCreateRegion( const QList& theZonesList ) +{ + QList aZonesList; + HYDROGUI_Zone* aZone; + // Get a list of dropped zones + for ( int i = 0; i < theZonesList.length(); i++ ) + { + aZone = dynamic_cast( theZonesList.at( i ) ); + if ( aZone ) + { + aZonesList.append( aZone ); + } + } + if ( aZonesList.length() > 0 ) + { + module()->getDataModel()->createNewRegion( myEditedObject, aZonesList ); + HYDROGUI_CalculationDlg* aPanel = + ::qobject_cast( inputPanel() ); + if ( aPanel ) + { + aPanel->refreshZonesBrowser(); + } + createPreview(); + } +} + +void HYDROGUI_CalculationOp::onSetMergeType( int theMergeType, QString& theAltitudeName ) { - // Remove selected objects from the calculation case HYDROGUI_CalculationDlg* aPanel = ::qobject_cast( inputPanel() ); if ( aPanel ) { - QStringList aList = aPanel->getSelectedGeomObjects(); - Handle(HYDROData_Object) anObject; - Handle(HYDROData_Entity) anEntity; - for (int i = 0; i < aList.length(); i++) + HYDROGUI_Zone* aZone = aPanel->getCurrentZone(); + if ( aZone ) { - anEntity = HYDROGUI_Tool::FindObjectByName( module(), aList.at(i) ); - if ( !anEntity.IsNull() ) + aZone->setMergeType( theMergeType, theAltitudeName ); + HYDROGUI_Shape* aShape = module()->getObjectShape( HYDROGUI_Module::VMR_PreviewCaseZones, aZone->modelObject() ); + if ( aShape ) { - anObject = Handle(HYDROData_Object)::DownCast( anEntity ); - if ( !anObject.IsNull() ) - { - myEditedObject->RemoveGeometryObject( anObject ); - } + aShape->update(); } } - updateGeomObjectsList( aPanel ); + aPanel->refreshZonesBrowser(); } } -bool HYDROGUI_CalculationOp::processApply( int& theUpdateFlags, - QString& theErrorMsg ) +void HYDROGUI_CalculationOp::onAddObjects() { HYDROGUI_CalculationDlg* aPanel = ::qobject_cast( inputPanel() ); if ( !aPanel ) - return false; + return; - //QString anObjectName = aPanel->getObjectName().simplified(); - //if ( anObjectName.isEmpty() ) - //{ - // theErrorMsg = tr( "INCORRECT_OBJECT_NAME" ); - // return false; - //} + // Add geometry objects selected in the module browser to the calculation case + QStringList aSelectedList = aPanel->getSelectedAvailableGeomObjects(); + if ( aSelectedList.isEmpty() || !confirmRegionsChange() ) + return; - //// check that there are no other objects with the same name in the document - //if( !myIsEdit || ( !myEditedObject.IsNull() && myEditedObject->GetName() != anObjectName ) ) - //{ - // Handle(HYDROData_Entity) anObject = HYDROGUI_Tool::FindObjectByName( module(), anObjectName ); - // if ( !anObject.IsNull() ) - // { - // theErrorMsg = tr( "OBJECT_EXISTS_IN_DOCUMENT" ).arg( anObjectName ); - // return false; - // } - //} + QStringList anAddedList; + for (int i = 0; i < aSelectedList.length(); i++) + { + Handle(HYDROData_Object) anObject = Handle(HYDROData_Object)::DownCast( + HYDROGUI_Tool::FindObjectByName( module(), aSelectedList.at( i ) ) ); + if ( anObject.IsNull() ) + continue; - //Handle(HYDROData_Document) aDocument = doc(); + if ( myEditedObject->AddGeometryObject( anObject ) ) + anAddedList.append( anObject->GetName() ); + } - //Handle(HYDROData_CalculationCase) aCalculObj = myIsEdit ? myEditedObject : - // Handle(HYDROData_CalculationCase)::DownCast( aDocument->CreateObject( KIND_CALCULATION ) ); - //if ( aCalculObj.IsNull() ) - // return false; + if ( !anAddedList.isEmpty() ) + { + aPanel->includeGeomObjects( anAddedList ); + createPreview(); + } +} - //aCalculObj->SetName( anObjectName ); +void HYDROGUI_CalculationOp::onRemoveObjects() +{ + // Remove selected objects from the calculation case + HYDROGUI_CalculationDlg* aPanel = + ::qobject_cast( inputPanel() ); + if ( !aPanel ) + return; + + QStringList aSelectedList = aPanel->getSelectedGeomObjects(); + if ( aSelectedList.isEmpty() || !confirmRegionsChange() ) + return; + + for (int i = 0; i < aSelectedList.length(); i++) + { + Handle(HYDROData_Object) anObject = Handle(HYDROData_Object)::DownCast( + HYDROGUI_Tool::FindObjectByName( module(), aSelectedList.at(i) ) ); + if ( anObject.IsNull() ) + continue; - //QStringList aRefObjectNames = aPanel->getSelectedGeomObjects(); - //HYDROData_SequenceOfObjects aGeomObjects = - // HYDROGUI_Tool::FindObjectsByNames( module(), aRefObjectNames ); + setObjectVisibility( anObject, false ); + myEditedObject->RemoveGeometryObject( anObject ); + } - theUpdateFlags = UF_Model; + module()->update( UF_OCCViewer ); + aPanel->excludeGeomObjects( aSelectedList ); +} + +bool HYDROGUI_CalculationOp::confirmRegionsChange() const +{ + // Check if the case is already modified or not + bool isConfirmed = myEditedObject->IsMustBeUpdated(); + if ( !isConfirmed ) + { + // If not modified check if the case has already defined regions with zones + HYDROData_SequenceOfObjects aSeq = myEditedObject->GetRegions(); + if ( aSeq.Length() > 0 ) + { + // If there are already defined zones then ask a user to confirm zones recalculation + isConfirmed = ( SUIT_MessageBox::question( module()->getApp()->desktop(), + tr( "REGIONS_CHANGED" ), + tr( "CONFIRM_SPLITTING_ZONES_RECALCULATION" ), + QMessageBox::Yes | QMessageBox::No, + QMessageBox::No ) == QMessageBox::Yes ); + } + else + { + isConfirmed = true; // No regions - no zones - nothing to recalculate + } + } + return isConfirmed; +} + +bool HYDROGUI_CalculationOp::processApply( int& theUpdateFlags, + QString& theErrorMsg, + QStringList& theBrowseObjectsEntries ) +{ + HYDROGUI_CalculationDlg* aPanel = + ::qobject_cast( inputPanel() ); + if ( !aPanel ) + return false; + + if( !myIsEdit ) + { + QString anEntry = HYDROGUI_DataObject::dataObjectEntry( myEditedObject ); + theBrowseObjectsEntries.append( anEntry ); + } + + theUpdateFlags = UF_Model | UF_OCCViewer | UF_OCC_Forced | UF_VTKViewer | UF_VTK_Forced | UF_VTK_Init; return true; } @@ -276,12 +523,13 @@ void HYDROGUI_CalculationOp::onApply() int anUpdateFlags = 0; QString anErrorMsg; + QStringList aBrowseObjectsEntries; bool aResult = false; try { - aResult = processApply( anUpdateFlags, anErrorMsg ); + aResult = processApply( anUpdateFlags, anErrorMsg, aBrowseObjectsEntries ); } catch ( Standard_Failure ) { @@ -300,6 +548,7 @@ void HYDROGUI_CalculationOp::onApply() { module()->update( anUpdateFlags ); commit(); + browseObjects( aBrowseObjectsEntries ); } else { @@ -313,61 +562,127 @@ void HYDROGUI_CalculationOp::onApply() } } -void HYDROGUI_CalculationOp::onSplitZones() +void HYDROGUI_CalculationOp::onNext( const int theIndex ) { - //myRegionsList.clear(); - - HYDROGUI_CalculationDlg* aPanel = - ::qobject_cast( inputPanel() ); - if ( !aPanel ) - return; - - QApplication::setOverrideCursor( Qt::WaitCursor ); - - //QStringList aGeomObjectNames = aPanel->getSelectedGeomObjects(); - //HYDROData_SequenceOfObjects aGeomObjects = - // HYDROGUI_Tool::FindObjectsByNames( module(), aGeomObjectNames ); - - //QStringList aResSplittedZones; - - //HYDROData_SplitToZonesTool::SplitDataList aSplittedZones = - // HYDROData_SplitToZonesTool::SplitToZones( aGeomObjects ); - - //QStringList aUsedNames; + if( theIndex==1 ) + { + setAvailableGroups(); + } + else if( theIndex==2 ) + { + HYDROGUI_CalculationDlg* aPanel = + ::qobject_cast( inputPanel() ); + if ( !aPanel ) + return; - //HYDROData_SplitToZonesTool::SplitDataListIterator anIter( aSplittedZones ); - //while( anIter.hasNext() ) - //{ - // Region aRegion; - // aRegion.SplitData = anIter.next(); + QApplication::setOverrideCursor( Qt::WaitCursor ); + + QString aNewCaseName = aPanel->getObjectName(); + QString anOldCaseName = myEditedObject->GetName(); + + bool anIsToUpdateOb = myIsEdit && anOldCaseName != aNewCaseName; + + // At first we must to update the case name because of + // automatic names generation for regions and zones + myEditedObject->SetName( aNewCaseName ); + + if ( myEditedObject->IsMustBeUpdated() ) + { + myShowZones = true; + myEditedObject->Update(); - // aRegion.FillingColor = HYDROGUI_Tool::GenerateFillingColor( module(), aRegion.SplitData.ObjectNames ); - // aRegion.BorderColor = QColor( HYDROData_ImmersibleZone::DefaultBorderColor() ); + //aPanel->setEditedObject( myEditedObject ); + aPanel->refreshZonesBrowser(); - // aRegion.RegionName = HYDROGUI_Tool::GenerateObjectName( module(), "Region", aUsedNames ); + createPreview(); + } + else + { + setZonesVisible( true ); + } - // aUsedNames.append( aRegion.RegionName ); + if ( anIsToUpdateOb ) + module()->getApp()->updateObjectBrowser( false ); - // aResSplittedZones.append( aRegion.RegionName ); + QApplication::restoreOverrideCursor(); + } +} - // myRegionsList.append( aRegion ); - //} - // +void HYDROGUI_CalculationOp::onHideZones() +{ + setZonesVisible( false ); +} - myEditedObject->SplitGeometryObjects(); - aPanel->setEditedObject( myEditedObject ); - createPreview(); +void HYDROGUI_CalculationOp::setZonesVisible( bool theIsVisible ) +{ + myShowZones = theIsVisible; + HYDROData_SequenceOfObjects aRegions = myEditedObject->GetRegions(); + HYDROData_SequenceOfObjects::Iterator aRegionsIter( aRegions ); + HYDROData_SequenceOfObjects aZones; + Handle(HYDROData_Region) aRegion; + if ( myPreviewViewManager ) + { + if ( OCCViewer_Viewer* aViewer = myPreviewViewManager->getOCCViewer() ) + { + Handle(AIS_InteractiveContext) aCtx = aViewer->getAISContext(); + if ( !aCtx.IsNull() ) + { + for ( ; aRegionsIter.More(); aRegionsIter.Next() ) + { + aRegion = Handle(HYDROData_Region)::DownCast( aRegionsIter.Value() ); + if ( !aRegion.IsNull() ) + { + aZones = aRegion->GetZones(); + HYDROData_SequenceOfObjects::Iterator aZonesIter( aZones ); + for ( ; aZonesIter.More(); aZonesIter.Next() ) + { + setObjectVisibility( aZonesIter.Value(), theIsVisible ); + } + } + } + } - QApplication::restoreOverrideCursor(); + module()->update( UF_OCCViewer ); + } + } } void HYDROGUI_CalculationOp::createPreview() { LightApp_Application* anApp = module()->getApp(); + HYDROData_SequenceOfObjects aSeq = myEditedObject->GetGeometryObjects(); + Handle(HYDROData_Entity) anEntity; + + if ( myShowZones ) + { + // Gather zones for displaying + HYDROData_SequenceOfObjects aRegions = myEditedObject->GetRegions(); + HYDROData_SequenceOfObjects::Iterator aRegionsIter( aRegions ); + HYDROData_SequenceOfObjects aZones; + Handle(HYDROData_Region) aRegion; + for ( ; aRegionsIter.More(); aRegionsIter.Next() ) + { + anEntity = aRegionsIter.Value(); + if ( !anEntity.IsNull() ) + { + aRegion = Handle(HYDROData_Region)::DownCast( anEntity ); + if ( !aRegion.IsNull() ) + { + aZones = aRegion->GetZones(); + aSeq.Append( aZones ); + } + } + } + } + + // Get a boundary polyline if any + aSeq.Append( myEditedObject->GetBoundaryPolyline() ); + + module()->removeViewShapes( HYDROGUI_Module::VMR_PreviewCaseZones ); if ( !myActiveViewManager ) { - if ( myRegionsList.isEmpty() ) + if ( aSeq.IsEmpty() ) return; myActiveViewManager = anApp->activeViewManager(); @@ -395,28 +710,31 @@ void HYDROGUI_CalculationOp::createPreview() Handle(AIS_InteractiveContext) aCtx = aViewer->getAISContext(); if ( !aCtx.IsNull() ) { - RegionsList::iterator anIter = myRegionsList.begin(); - for ( ; anIter != myRegionsList.end(); ++anIter ) + HYDROData_SequenceOfObjects::Iterator anIter( aSeq ); + for ( ; anIter.More(); anIter.Next() ) { - Region& aRegion = *anIter; - if ( aRegion.Shape ) - { - aRegion.Shape->erase( false ); - delete aRegion.Shape; - } - - aRegion.Shape = new HYDROGUI_Shape( aCtx, NULL ); - - aRegion.Shape->setFillingColor( aRegion.FillingColor, false, false ); - aRegion.Shape->setBorderColor( aRegion.BorderColor, false, false ); - aRegion.Shape->setFace( aRegion.SplitData.Face(), true, false ); + setObjectVisibility( anIter.Value(), true ); } //Process the draw events for viewer - QApplication::processEvents(); + QApplication::processEvents( QEventLoop::ExcludeUserInputEvents ); if ( OCCViewer_ViewWindow* vw = (OCCViewer_ViewWindow*)myPreviewViewManager->getActiveView() ) vw->onTopView(); } + + module()->update( UF_OCCViewer | UF_FitAll ); + } +} + +void HYDROGUI_CalculationOp::setObjectVisibility( Handle(HYDROData_Entity) theEntity, const bool theIsVisible ) +{ + if ( theEntity.IsNull() || !myPreviewViewManager ) { + return; + } + + OCCViewer_Viewer* aViewer = myPreviewViewManager->getOCCViewer(); + if ( aViewer ) { + module()->setObjectVisible( (size_t)aViewer, theEntity, theIsVisible ); } } @@ -427,20 +745,35 @@ void HYDROGUI_CalculationOp::onLastViewClosed( SUIT_ViewManager* theViewManager void HYDROGUI_CalculationOp::closePreview() { - RegionsList::iterator anIter= myRegionsList.begin(); - for ( ; anIter != myRegionsList.end(); ++anIter ) + SUIT_DataBrowser* aOb = ((LightApp_Application*)module()->application())->objectBrowser(); + QList aShortcuts = aOb->findChildren(); + QShortcut* aShortcut; + foreach( aShortcut, aShortcuts ) { - Region& aRegion = *anIter; - if ( aRegion.Shape ) + if ( aShortcut->key() == + QKeySequence( ((LightApp_Application*)module()->application())->objectBrowser()->shortcutKey( + SUIT_DataBrowser::RenameShortcut ) ) ) { - aRegion.Shape->erase( false ); - delete aRegion.Shape; - aRegion.Shape = NULL; + aShortcut->setEnabled( true ); } } + if( myPreviewViewManager ) { + // Hide all the displayed objects in the preview view + OCCViewer_Viewer* aViewer = myPreviewViewManager->getOCCViewer(); + if ( aViewer ) { + size_t aViewId = (size_t)aViewer; + HYDROData_Iterator anIterator( doc() ); + for( ; anIterator.More(); anIterator.Next() ) { + Handle(HYDROData_Entity) anObject = anIterator.Current(); + if( !anObject.IsNull() ) { + module()->setObjectVisible( aViewId, anObject, false ); + } + } + } + disconnect( myPreviewViewManager, SIGNAL( lastViewClosed( SUIT_ViewManager* ) ), this, SLOT( onLastViewClosed( SUIT_ViewManager* ) ) ); @@ -455,4 +788,95 @@ void HYDROGUI_CalculationOp::closePreview() } } +void HYDROGUI_CalculationOp::setAvailableGroups() +{ + HYDROGUI_CalculationDlg* aPanel = + ::qobject_cast( inputPanel() ); + + HYDROData_SequenceOfObjects aSeq = myEditedObject->GetGeometryGroups(); + QStringList aList, anEntryList; + getNamesAndEntries( aSeq, aList, anEntryList ); + + QStringList aGroupsNames; + + HYDROData_SequenceOfObjects anObjs = myEditedObject->GetGeometryObjects(); + for( int anIndex = 1, aLength = anObjs.Length(); anIndex <= aLength; anIndex++ ) + { + Handle_HYDROData_Object anObj = Handle_HYDROData_Object::DownCast( anObjs.Value( anIndex ) ); + HYDROData_SequenceOfObjects aGroups = anObj->GetGroups(); + for( int aGIndex = 1, aGLength = aGroups.Length(); aGIndex <= aGLength; aGIndex++ ) + { + Handle_HYDROData_ShapesGroup aGroup = Handle_HYDROData_ShapesGroup::DownCast( aGroups.Value( aGIndex ) ); + aGroupsNames.append( aGroup->GetName() ); + } + } + if( myEditedObject->IsMustBeUpdated() ) { + for( int anIndex = 1, aLength = aSeq.Length(); anIndex <= aLength; anIndex++ ) { + Handle(HYDROData_ShapesGroup) aGeomGroup = + Handle(HYDROData_ShapesGroup)::DownCast( aSeq.Value( anIndex ) ); + if ( !aGeomGroup.IsNull() && !aGroupsNames.contains( aGeomGroup->GetName() ) ) { + myEditedObject->RemoveGeometryGroup( aGeomGroup ); + } + } + } + + aPanel->setAvailableGroups( aGroupsNames ); + aPanel->includeGroups( aList ); + + bool isUpdated = myEditedObject->IsMustBeUpdated(); +} + +void HYDROGUI_CalculationOp::onAddGroups() +{ + HYDROGUI_CalculationDlg* aPanel = + ::qobject_cast( inputPanel() ); + if ( !aPanel ) + return; + // Add geometry objects selected in the module browser to the calculation case + QStringList aSelectedList = aPanel->getSelectedAvailableGroups(); + if ( aSelectedList.isEmpty() || !confirmRegionsChange() ) + return; + + QStringList anAddedList; + for (int i = 0; i < aSelectedList.length(); i++) + { + Handle(HYDROData_ShapesGroup) aGroup = Handle(HYDROData_ShapesGroup)::DownCast( + HYDROGUI_Tool::FindObjectByName( module(), aSelectedList.at( i ) ) ); + if ( aGroup.IsNull() ) + continue; + + if ( myEditedObject->AddGeometryGroup( aGroup ) ) + anAddedList.append( aGroup->GetName() ); + } + + if ( !anAddedList.isEmpty() ) + { + aPanel->includeGroups( anAddedList ); + } +} + +void HYDROGUI_CalculationOp::onRemoveGroups() +{ + // Remove selected objects from the calculation case + HYDROGUI_CalculationDlg* aPanel = + ::qobject_cast( inputPanel() ); + if ( !aPanel ) + return; + + QStringList aSelectedList = aPanel->getSelectedGroups(); + if ( aSelectedList.isEmpty() || !confirmRegionsChange() ) + return; + + for (int i = 0; i < aSelectedList.length(); i++) + { + Handle(HYDROData_ShapesGroup) aGroup = Handle(HYDROData_ShapesGroup)::DownCast( + HYDROGUI_Tool::FindObjectByName( module(), aSelectedList.at(i) ) ); + if ( aGroup.IsNull() ) + continue; + + myEditedObject->RemoveGeometryGroup( aGroup ); + } + + aPanel->excludeGroups( aSelectedList ); +}