X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROGUI%2FHYDROGUI_CalculationOp.cxx;h=f8311d5a4f90c45bb0ef1dfa8626dd9995559e35;hb=d6e19029f8b41f295db878e9aecf451c2edda4af;hp=f8143232e57c86e73abc26941d06c32a4c3153bf;hpb=8543e637cbb4ae48998c596241fce567a729eb67;p=modules%2Fhydro.git diff --git a/src/HYDROGUI/HYDROGUI_CalculationOp.cxx b/src/HYDROGUI/HYDROGUI_CalculationOp.cxx index f8143232..f8311d5a 100644 --- a/src/HYDROGUI/HYDROGUI_CalculationOp.cxx +++ b/src/HYDROGUI/HYDROGUI_CalculationOp.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 @@ -33,8 +29,10 @@ #include #include #include +#include #include #include +#include #include #include @@ -92,7 +90,6 @@ void HYDROGUI_CalculationOp::startOperation() } } - aPanel->reset(); QStringList aList; QStringList anEntryList; @@ -134,6 +131,7 @@ void HYDROGUI_CalculationOp::startOperation() myEditedObject = Handle(HYDROData_CalculationCase)::DownCast( HYDROGUI_Tool::GetSelectedObject( module() ) ); if ( !myEditedObject.IsNull() ) { + aPanel->setMode( myEditedObject->GetAssignmentMode() ); anObjectName = myEditedObject->GetName(); aPolylineObj = myEditedObject->GetBoundaryPolyline(); if ( aPolylineObj.IsNull() ) @@ -145,16 +143,21 @@ void HYDROGUI_CalculationOp::startOperation() aPolylineName = aPolylineObj->GetName(); aPanel->setBoundary( aPolylineName ); } + aSeq = myEditedObject->GetGeometryObjects(); getNamesAndEntries( aSeq, aList, anEntryList ); aPanel->includeGeomObjects( aList ); + + // set rules + setRules( HYDROData_CalculationCase::DataTag_CustomRules ); } } else { myEditedObject = Handle(HYDROData_CalculationCase)::DownCast( doc()->CreateObject( KIND_CALCULATION ) ); - myEditedObject->SetName(anObjectName); + myEditedObject->SetName( anObjectName ); + myEditedObject->SetAssignmentMode( (HYDROData_CalculationCase::AssignmentMode)aPanel->getMode() ); } aPanel->setObjectName( anObjectName ); @@ -173,8 +176,8 @@ void HYDROGUI_CalculationOp::getNamesAndEntries( const HYDROData_SequenceOfObjec for ( ; anIter.More(); anIter.Next() ) { Handle(HYDROData_Entity) anEntity = anIter.Value(); - if ( !HYDROData_Tool::IsGeometryObject( anEntity ) ) - continue; + //if ( !HYDROData_Tool::IsGeometryObject( anEntity ) ) + // continue; theNames.append( anEntity->GetName() ); theEntries.append( HYDROGUI_DataObject::dataObjectEntry( anEntity ) ); @@ -203,10 +206,19 @@ HYDROGUI_InputPanel* HYDROGUI_CalculationOp::createInputPanel() const HYDROGUI_CalculationDlg* aPanel = new HYDROGUI_CalculationDlg( module(), getName() ); // Connect signals and slots + connect( aPanel, SIGNAL( changeMode( int ) ), SLOT( onChangeMode( int ) ) ); connect( aPanel, SIGNAL( addObjects() ), SLOT( onAddObjects() ) ); connect( aPanel, SIGNAL( removeObjects() ), SLOT( onRemoveObjects() ) ); connect( aPanel, SIGNAL( addGroups() ), SLOT( onAddGroups() ) ); connect( aPanel, SIGNAL( removeGroups() ), SLOT( onRemoveGroups() ) ); + + connect( aPanel, SIGNAL( changeLandCoverMode( int ) ), SLOT( onChangeLandCoverMode( int ) ) ); + connect( aPanel, SIGNAL( addLandCovers() ), SLOT( onAddLandCovers() ) ); + connect( aPanel, SIGNAL( removeLandCovers() ), SLOT( onRemoveLandCovers() ) ); + + connect( aPanel, SIGNAL( orderChanged( bool& ) ), SLOT( onOrderChanged( bool& ) ) ); + connect( aPanel, SIGNAL( orderLandCoverChanged( bool& ) ), SLOT( onOrderLandCoverChanged( bool& ) ) ); + 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* ) ) ); @@ -219,8 +231,12 @@ HYDROGUI_InputPanel* HYDROGUI_CalculationOp::createInputPanel() const SLOT( onClickedInZonesBrowser( SUIT_DataObject* ) ) ); connect( aPanel, SIGNAL( objectsSelected() ), SLOT( onObjectsSelected() ) ); + connect( aPanel, SIGNAL( landCoversSelected() ), + SLOT( onLandCoversSelected() ) ); connect( aPanel, SIGNAL( boundarySelected( const QString & ) ), SLOT( onBoundarySelected( const QString & ) ) ); + connect( aPanel, SIGNAL( StricklerTableSelected( const QString & ) ), + SLOT( onStricklerTableSelected( const QString & ) ) ); return aPanel; } @@ -234,7 +250,7 @@ void HYDROGUI_CalculationOp::onBoundarySelected ( const QString & theObjName ) myEditedObject->GetBoundaryPolyline(); if ( !aPrevPolyline.IsNull() ) { - module()->removeObjectShape( HYDROGUI_Module::VMR_PreviewCaseZones, aPrevPolyline ); + setObjectVisibility( aPrevPolyline, false ); anIsToUpdateViewer = true; } @@ -253,13 +269,76 @@ void HYDROGUI_CalculationOp::onBoundarySelected ( const QString & theObjName ) Handle(AIS_InteractiveContext) aCtx = aViewer->getAISContext(); if ( !aCtx.IsNull() ) { - showObject( aNewPolyline, aCtx ); + setObjectVisibility( aNewPolyline, true ); anIsToUpdateViewer = true; } } if ( anIsToUpdateViewer ) - aViewer->update(); + module()->update( UF_OCCViewer ); + } + } +} + +void HYDROGUI_CalculationOp::onStricklerTableSelected ( const QString & theObjName ) +{ + bool anIsToUpdateViewer = false; + + // Remove old presentations of land covers from the operation viewer + Handle(HYDROData_Entity) anEntity; + Handle(HYDROData_LandCover) aLandCover; + HYDROData_SequenceOfObjects aLandCovers; + HYDROData_SequenceOfObjects aSeq = myEditedObject->GetLandCovers(); + HYDROData_SequenceOfObjects::Iterator anIter( aSeq ); + for ( ; anIter.More(); anIter.Next() ) + { + anEntity = anIter.Value(); + if ( !anEntity.IsNull() ) + { + aLandCover = Handle(HYDROData_LandCover)::DownCast( anEntity ); + if ( !aLandCover.IsNull() ) + { + aLandCovers.Append( aLandCover ); + setObjectVisibility( aLandCover, false ); + anIsToUpdateViewer = true; + } + } + } + + // Set the selected Strickler table to the calculation case + Handle(HYDROData_StricklerTable) aNewStricklerTable = Handle(HYDROData_StricklerTable)::DownCast( + HYDROGUI_Tool::FindObjectByName( module(), theObjName, KIND_STRICKLER_TABLE ) ); + myEditedObject->SetStricklerTable( aNewStricklerTable ); + + if ( myPreviewViewManager ) + { + OCCViewer_Viewer* aViewer = myPreviewViewManager->getOCCViewer(); + if ( aViewer ) + { + if ( !aNewStricklerTable.IsNull() ) + { + Handle(AIS_InteractiveContext) aCtx = aViewer->getAISContext(); + if ( !aCtx.IsNull() ) + { + HYDROData_SequenceOfObjects::Iterator anIter( aLandCovers ); + for ( ; anIter.More(); anIter.Next() ) + { + anEntity = anIter.Value(); + if ( !anEntity.IsNull() ) + { + aLandCover = Handle(HYDROData_LandCover)::DownCast( anEntity ); + if ( !aLandCover.IsNull() ) + { + setObjectVisibility( aLandCover, true ); + anIsToUpdateViewer = true; + } + } + } + } + } + + if ( anIsToUpdateViewer ) + module()->update( UF_OCCViewer ); } } } @@ -296,13 +375,54 @@ void HYDROGUI_CalculationOp::onObjectsSelected() aName = anEntity->GetName(); isSelected = aSelectedObjsMap.contains( aName ); aShape->highlight( isSelected, false ); - aShape->update( false ); + aShape->update( false, false ); aLastShape = aShape; } } } if( aLastShape ) - aLastShape->update( true ); + aLastShape->update( true, false ); +} + +void HYDROGUI_CalculationOp::onLandCoversSelected() +{ + HYDROGUI_CalculationDlg* aPanel = + ::qobject_cast( inputPanel() ); + + QStringList aSelectedObjs = aPanel->getSelectedLandCovers(); + QMap aSelectedObjsMap; + foreach( QString aName, aSelectedObjs ) + aSelectedObjsMap[aName] = true; + + + // Select the appropriate land cover shape in the viewer + selectionMgr()->clearSelected(); + + // Unhighlight all land covers except selected + HYDROGUI_Shape* aShape = 0, *aLastShape = 0; + Handle(HYDROData_Entity) anEntity; + HYDROData_SequenceOfObjects aSeq = myEditedObject->GetLandCovers(); + HYDROData_SequenceOfObjects::Iterator anIter( aSeq ); + bool isSelected; + QString aName; + for ( ; anIter.More(); anIter.Next() ) + { + anEntity = anIter.Value(); + if ( !anEntity.IsNull() ) + { + aShape = module()->getObjectShape( HYDROGUI_Module::VMR_PreviewCaseZones, anEntity ); + if ( aShape ) + { + aName = anEntity->GetName(); + isSelected = aSelectedObjsMap.contains( aName ); + aShape->highlight( isSelected, false ); + aShape->update( false, false ); + aLastShape = aShape; + } + } + } + if( aLastShape ) + aLastShape->update( true, false ); } void HYDROGUI_CalculationOp::onClickedInZonesBrowser( SUIT_DataObject* theItem ) @@ -407,7 +527,7 @@ void HYDROGUI_CalculationOp::onSetMergeType( int theMergeType, QString& theAltit HYDROGUI_Shape* aShape = module()->getObjectShape( HYDROGUI_Module::VMR_PreviewCaseZones, aZone->modelObject() ); if ( aShape ) { - aShape->update(); + aShape->update( true, false ); } } aPanel->refreshZonesBrowser(); @@ -464,10 +584,11 @@ void HYDROGUI_CalculationOp::onRemoveObjects() if ( anObject.IsNull() ) continue; - module()->removeObjectShape( HYDROGUI_Module::VMR_PreviewCaseZones, anObject ); + setObjectVisibility( anObject, false ); myEditedObject->RemoveGeometryObject( anObject ); } + module()->update( UF_OCCViewer ); aPanel->excludeGeomObjects( aSelectedList ); } @@ -484,7 +605,7 @@ bool HYDROGUI_CalculationOp::confirmRegionsChange() const // 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" ), + tr( "CONFIRM_SPLITTING_ZONES_RECALCULATION_REGIONS" ), QMessageBox::Yes | QMessageBox::No, QMessageBox::No ) == QMessageBox::Yes ); } @@ -496,31 +617,192 @@ bool HYDROGUI_CalculationOp::confirmRegionsChange() const return isConfirmed; } +bool HYDROGUI_CalculationOp::confirmOrderChange() 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( "ORDER_CHANGED" ), + tr( "CONFIRM_SPLITTING_ZONES_RECALCULATION_REGIONS" ), + QMessageBox::Yes | QMessageBox::No, + QMessageBox::No ) == QMessageBox::Yes ); + } + else + { + isConfirmed = true; // No regions - no zones - nothing to recalculate + } + } + return isConfirmed; +} + +bool HYDROGUI_CalculationOp::confirmModeChange() 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( "MODE_CHANGED" ), + tr( "CONFIRM_SPLITTING_ZONES_RECALCULATION_MODE" ), + QMessageBox::Yes | QMessageBox::No, + QMessageBox::No ) == QMessageBox::Yes ); + } + else + { + isConfirmed = true; // No regions - no zones - nothing to recalculate + } + } + return isConfirmed; +} + +bool HYDROGUI_CalculationOp::confirmContinueWithWarning( const HYDROData_Warning& theWarning ) const +{ + HYDROData_WarningType aType = theWarning.Type; + if ( aType == WARN_OK ) { + return true; + } + + QString aTitle; + QString aMsg; + switch ( aType ) + { + case WARN_EMPTY_REGIONS: + aTitle = tr( "EMPTY_REGIONS" ); + aMsg = tr( "CONFIRM_CONTINUE_WITH_OBJECTS_NOT_INCLUDED_TO_REGION" ).arg( theWarning.Data ); + break; + default: + aTitle = tr( "WARNING" ); + aMsg = theWarning.Data; + } + + + int anAnswer = SUIT_MessageBox::warning( module()->getApp()->desktop(), + aTitle, aMsg, + QMessageBox::Yes | QMessageBox::No, + QMessageBox::No ); + + return ( anAnswer == QMessageBox::Yes ); +} + +bool HYDROGUI_CalculationOp::confirmLandCoverModeChange() 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 + // TODO: adapt HYDROData_CalculationCase class to process regions constructed for land covers + /*HYDROData_SequenceOfObjects aSeq = myEditedObject->GetLandCoverRegions(); + 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( "MODE_CHANGED" ), + tr( "CONFIRM_LAND_COVER_PARTITION_RECALCULATION_MODE" ), + QMessageBox::Yes | QMessageBox::No, + QMessageBox::No ) == QMessageBox::Yes ); + /*} + else + { + isConfirmed = true; // No regions - no zones - nothing to recalculate + }*/ + } + return isConfirmed; +} + +bool HYDROGUI_CalculationOp::confirmLandCoverOrderChange() 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 + // TODO: adapt HYDROData_CalculationCase class to process regions constructed for land covers + /*HYDROData_SequenceOfObjects aSeq = myEditedObject->GetLandCoverRegions(); + 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( "ORDER_CHANGED" ), + tr( "CONFIRM_LAND_COVER_PARTITION_RECALCULATION_REGIONS" ), + 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 ) + QString& theErrorMsg, + QStringList& theBrowseObjectsEntries ) { HYDROGUI_CalculationDlg* aPanel = ::qobject_cast( inputPanel() ); if ( !aPanel ) return false; - theUpdateFlags = UF_Model | UF_OCCViewer | UF_OCC_Forced; + if( !myIsEdit ) + { + QString anEntry = HYDROGUI_DataObject::dataObjectEntry( myEditedObject ); + theBrowseObjectsEntries.append( anEntry ); + } + + // For manual mode priority rules are redundant + if ( aPanel->getMode() == HYDROData_CalculationCase::MANUAL ) { + myEditedObject->ClearRules( HYDROData_CalculationCase::DataTag_CustomRules, false ); + } + if ( aPanel->getLandCoverMode() == HYDROData_CalculationCase::MANUAL ) { + myEditedObject->ClearRules( HYDROData_CalculationCase::DataTag_CustomLandCoverRules, false ); + } + + theUpdateFlags = UF_Model | UF_OCCViewer | UF_OCC_Forced | UF_VTKViewer | UF_VTK_Forced | UF_VTK_Init; return true; } void HYDROGUI_CalculationOp::onApply() { + // Check warnings + HYDROData_Warning aWarning = myEditedObject->GetLastWarning(); + if ( aWarning.Type != WARN_OK ) { + if ( !confirmContinueWithWarning( aWarning ) ) { + // Go back to the first page + HYDROGUI_CalculationDlg* aPanel = + ::qobject_cast( inputPanel() ); + if ( aPanel ) { + aPanel->onFirstPage(); + } + return; + } + } + QApplication::setOverrideCursor( Qt::WaitCursor ); int anUpdateFlags = 0; QString anErrorMsg; + QStringList aBrowseObjectsEntries; bool aResult = false; try { - aResult = processApply( anUpdateFlags, anErrorMsg ); + aResult = processApply( anUpdateFlags, anErrorMsg, aBrowseObjectsEntries ); } catch ( Standard_Failure ) { @@ -539,6 +821,7 @@ void HYDROGUI_CalculationOp::onApply() { module()->update( anUpdateFlags ); commit(); + browseObjects( aBrowseObjectsEntries ); } else { @@ -559,6 +842,81 @@ void HYDROGUI_CalculationOp::onNext( const int theIndex ) setAvailableGroups(); } else if( theIndex==2 ) + { + // Land covers panel + HYDROGUI_CalculationDlg* aPanel = + ::qobject_cast( inputPanel() ); + if ( !aPanel ) + return; + + QStringList aList; + QStringList anEntryList; + HYDROData_SequenceOfObjects aSeq; + + Handle(HYDROData_StricklerTable) aStricklerTableObj; + QString aStricklerTableName; + + // Get all Strickler table objects to fill in combo-box + aList.clear(); + anEntryList.clear(); + HYDROData_Iterator anIter( doc(), KIND_STRICKLER_TABLE ); + for ( ; anIter.More(); anIter.Next() ) + { + aStricklerTableObj = Handle(HYDROData_StricklerTable)::DownCast( anIter.Current() ); + + if ( !aStricklerTableObj.IsNull() ) + { + aStricklerTableName = aStricklerTableObj->GetName(); + if ( !aStricklerTableName.isEmpty() ) + { + aList.append( aStricklerTableName ); + anEntryList.append( HYDROGUI_DataObject::dataObjectEntry( aStricklerTableObj ) ); + } + } + } + aPanel->setStricklerTableNames( aList, anEntryList ); + if ( !aList.isEmpty() ) + aPanel->setStricklerTable( aList.at( 0 ), false ); + + // Fill in list widget with all available land covers + aSeq = HYDROGUI_Tool::GetLandCovers( module() ); + getNamesAndEntries( aSeq, aList, anEntryList ); + aPanel->setAllLandCovers( aList, anEntryList ); + + // Set list of included land covers + aSeq = myEditedObject->GetLandCovers(); + getNamesAndEntries( aSeq, aList, anEntryList ); + aPanel->includeLandCovers( aList, true ); + + if ( !myEditedObject.IsNull() ) + { + if ( myIsEdit ) + { + // Select the certain Strickler table object in combo-box + aStricklerTableObj = myEditedObject->GetStricklerTable(); + if ( aStricklerTableObj.IsNull() ) + { + aPanel->setStricklerTable( QString() ); + } + else + { + aStricklerTableName = aStricklerTableObj->GetName(); + aPanel->setStricklerTable( aStricklerTableName ); + } + + // Set mode (Auto or Manual) to defined priority of land covers + aPanel->setLandCoverMode( myEditedObject->GetAssignmentLandCoverMode() ); + + // Set rules defined on land covers + setRules( HYDROData_CalculationCase::DataTag_CustomLandCoverRules ); + } + else + { + myEditedObject->SetAssignmentLandCoverMode( (HYDROData_CalculationCase::AssignmentMode)aPanel->getLandCoverMode() ); + } + } + } + else if( theIndex==3 ) { HYDROGUI_CalculationDlg* aPanel = ::qobject_cast( inputPanel() ); @@ -569,30 +927,123 @@ void HYDROGUI_CalculationOp::onNext( const int theIndex ) QString aNewCaseName = aPanel->getObjectName(); QString anOldCaseName = myEditedObject->GetName(); + bool isNameChanged = anOldCaseName != aNewCaseName; - bool anIsToUpdateOb = myIsEdit && anOldCaseName != aNewCaseName; - + bool anIsToUpdateOb = isNameChanged; + // At first we must to update the case name because of // automatic names generation for regions and zones myEditedObject->SetName( aNewCaseName ); - + + // Set parameters for automatic mode + int aMode = aPanel->getMode(); + if ( aMode == HYDROData_CalculationCase::AUTOMATIC ) + { + // Set objects in the specified order + if( myEditedObject->IsMustBeUpdated() ) + { + myEditedObject->RemoveGeometryObjects(); + foreach ( const QString& aName, aPanel->getAllGeomObjects() ) + { + Handle(HYDROData_Object) anObject = Handle(HYDROData_Object)::DownCast( + HYDROGUI_Tool::FindObjectByName( module(), aName ) ); + if ( anObject.IsNull() ) + { + continue; + } + myEditedObject->AddGeometryObject( anObject ); + } + + // Clear priority rules + //@ASL if ( myEditedObject->GetRulesCount() > 0 ) { + myEditedObject->ClearRules( HYDROData_CalculationCase::DataTag_CustomRules, true ); + //@ASL } + // Set priority rules + foreach ( const HYDROData_CustomRule& aRule, aPanel->getRules() ) { + myEditedObject->AddRule( aRule.Object1, aRule.Priority, + aRule.Object2, aRule.MergeType, + HYDROData_CalculationCase::DataTag_CustomRules ); + } + } + } + aPanel->setEditZonesEnabled( aMode == HYDROData_CalculationCase::MANUAL ); + if ( myEditedObject->IsMustBeUpdated() ) { myShowZones = true; myEditedObject->Update(); + + AssignDefaultZonesColors(); //aPanel->setEditedObject( myEditedObject ); aPanel->refreshZonesBrowser(); - + + closePreview(); createPreview(); + + anIsToUpdateOb = true; + + myEditedObject->SetToUpdate( true ); } else { setZonesVisible( true ); + + if ( isNameChanged ) { + module()->getDataModel()->updateObjectTree( myEditedObject ); + } } - if ( anIsToUpdateOb ) - module()->getApp()->updateObjectBrowser( false ); + // Move this code to processing od the last panel (see below) + if ( anIsToUpdateOb ) { + SUIT_DataBrowser* anObjBrowser = ((LightApp_Application*)module()->application())->objectBrowser(); + if ( anObjBrowser ) { + anObjBrowser->updateTree( module()->getDataModel()->getDataObject( myEditedObject ), false ); + } + } + + QApplication::restoreOverrideCursor(); + } + else if( theIndex==4 ) + { + // Partition of Land covers panel + HYDROGUI_CalculationDlg* aPanel = + ::qobject_cast( inputPanel() ); + if ( !aPanel ) + return; + + QApplication::setOverrideCursor( Qt::WaitCursor ); + + // Set parameters for automatic mode + int aMode = aPanel->getLandCoverMode(); + if ( aMode == HYDROData_CalculationCase::AUTOMATIC ) + { + // Set objects in the specified order + if( myEditedObject->IsMustBeUpdated() ) + { + myEditedObject->RemoveLandCovers(); + foreach ( const QString& aName, aPanel->getAllLandCovers() ) + { + Handle(HYDROData_LandCover) aLandCover = Handle(HYDROData_LandCover)::DownCast( + HYDROGUI_Tool::FindObjectByName( module(), aName ) ); + if ( aLandCover.IsNull() ) + { + continue; + } + myEditedObject->AddLandCover( aLandCover ); + } + + // Clear priority rules + myEditedObject->ClearRules( HYDROData_CalculationCase::DataTag_CustomLandCoverRules, true ); + // Set priority rules + foreach ( const HYDROData_CustomRule& aRule, aPanel->getLandCoverRules() ) { + myEditedObject->AddRule( aRule.Object1, aRule.Priority, + aRule.Object2, HYDROData_Zone::Merge_Object, + HYDROData_CalculationCase::DataTag_CustomLandCoverRules ); + } + } + } + aPanel->setEditLandCoversEnabled( aMode == HYDROData_CalculationCase::MANUAL ); QApplication::restoreOverrideCursor(); } @@ -626,22 +1077,119 @@ void HYDROGUI_CalculationOp::setZonesVisible( bool theIsVisible ) HYDROData_SequenceOfObjects::Iterator aZonesIter( aZones ); for ( ; aZonesIter.More(); aZonesIter.Next() ) { - if ( theIsVisible ) - { - showObject( aZonesIter.Value(), aCtx ); - } - else + setObjectVisibility( aZonesIter.Value(), theIsVisible ); + } + } + } + } + + module()->update( UF_OCCViewer ); + } + } +} + +void HYDROGUI_CalculationOp::AssignDefaultZonesColors() +{ + 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() ) + { + int aCounter = 0; + 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() ) + { + // Zone + Handle(HYDROData_Zone) aZone = Handle(HYDROData_Zone)::DownCast( aZonesIter.Value() ); + if ( !aZone.IsNull() ) { - module()->removeObjectShape( HYDROGUI_Module::VMR_PreviewCaseZones, aZonesIter.Value() ); + QColor aFillingColor = GenerateDefaultZonesColor(++aCounter); + while (aFillingColor == Qt::red) + aFillingColor = GenerateDefaultZonesColor(++aCounter); + + aZone->SetColor(aFillingColor); } } } } } + } + } +} + +QColor HYDROGUI_CalculationOp::GenerateDefaultZonesColor( int theIndex, + float theSaturation/* = 0.5*/, + float theValue/* = 0.95*/ ) const +{ + float aGoldenRatioConjugate = (float)(360./582.); + float aHue = (float)rand(); + aHue += aGoldenRatioConjugate*theIndex; + aHue -= floor(aHue); + + float aR = 0., aG = 0., aB = 0.; + int aHueInt = (int)(aHue*6.); + float aF = aHue*6. - aHueInt; + float aP = theValue * (1. - theSaturation); + float aQ = theValue * (1. - aF*theSaturation); + float aT = theValue * (1. - (1. - aF) * theSaturation); + switch (aHueInt) + { + case 0: { aR = theValue; aG = aT; aB = aP; break; } + case 1: { aR = aQ; aG = theValue; aB = aP; break; } + case 2: { aR = aP; aG = theValue; aB = aT; break; } + case 3: { aR = aP; aG = aQ; aB = theValue; break; } + case 4: { aR = aT; aG = aP; aB = theValue; break; } + case 5: { aR = theValue; aG = aP; aB = aQ; break; } + default: break; + } - aViewer->update(); + QColor aColor = QColor( (int)(aR*256.), (int)(aG*256.), (int)(aB*256.) ); + return ( aColor.isValid() ? aColor : HYDROData_ImmersibleZone::DefaultFillingColor() ); +} + +void HYDROGUI_CalculationOp::setRules( HYDROData_CalculationCase::DataTag theDataTag ) +{ + HYDROGUI_CalculationDlg* aPanel = + ::qobject_cast( inputPanel() ); + if ( !aPanel ) + return; + + HYDROData_ListOfRules aRules; + Handle(HYDROData_Entity) anObject1, anObject2; + HYDROData_PriorityType aPriority; + HYDROData_Zone::MergeAltitudesType aMergeType; + HYDROData_CalculationCase::DataTag aDataTag = HYDROData_CalculationCase::DataTag_CustomRules; + for ( int anIndex = 0; ; anIndex++ ) + { + if ( myEditedObject->GetRule( anIndex, anObject1, aPriority, anObject2, aMergeType, theDataTag ) ) { + HYDROData_CustomRule aRule; + aRule.Object1 = anObject1; + aRule.Object2 = anObject2; + aRule.Priority = aPriority; + aRule.MergeType = aMergeType; + + aRules << aRule; } + else + break; } + + if ( theDataTag == HYDROData_CalculationCase::DataTag_CustomRules ) + aPanel->setRules( aRules ); + else if ( theDataTag == HYDROData_CalculationCase::DataTag_CustomLandCoverRules ) + aPanel->setLandCoverRules( aRules ); } void HYDROGUI_CalculationOp::createPreview() @@ -710,30 +1258,28 @@ void HYDROGUI_CalculationOp::createPreview() HYDROData_SequenceOfObjects::Iterator anIter( aSeq ); for ( ; anIter.More(); anIter.Next() ) { - showObject( anIter.Value(), aCtx ); + 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(); } - aViewer->update(); + module()->update( UF_OCCViewer | UF_FitAll ); } } -void HYDROGUI_CalculationOp::showObject( Handle(HYDROData_Entity) theEntity, Handle(AIS_InteractiveContext) theCtx ) +void HYDROGUI_CalculationOp::setObjectVisibility( Handle(HYDROData_Entity) theEntity, const bool theIsVisible ) { - if ( !theEntity.IsNull() ) - { - HYDROGUI_Shape* aShape = module()->getObjectShape( HYDROGUI_Module::VMR_PreviewCaseZones, theEntity ); - if ( !aShape ) - { - aShape = new HYDROGUI_Shape( theCtx, theEntity ); - module()->setObjectShape( HYDROGUI_Module::VMR_PreviewCaseZones, theEntity, aShape ); - } - aShape->update( false ); + if ( theEntity.IsNull() || !myPreviewViewManager ) { + return; + } + + OCCViewer_Viewer* aViewer = myPreviewViewManager->getOCCViewer(); + if ( aViewer ) { + module()->setObjectVisible( (size_t)aViewer, theEntity, theIsVisible ); } } @@ -760,6 +1306,19 @@ void HYDROGUI_CalculationOp::closePreview() 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* ) ) ); @@ -777,7 +1336,11 @@ void HYDROGUI_CalculationOp::closePreview() void HYDROGUI_CalculationOp::setAvailableGroups() { HYDROGUI_CalculationDlg* aPanel = - ::qobject_cast( inputPanel() ); + ::qobject_cast( inputPanel() ); + + HYDROData_SequenceOfObjects aSeq = myEditedObject->GetGeometryGroups(); + QStringList aList, anEntryList; + getNamesAndEntries( aSeq, aList, anEntryList ); QStringList aGroupsNames; @@ -792,8 +1355,20 @@ void HYDROGUI_CalculationOp::setAvailableGroups() aGroupsNames.append( aGroup->GetName() ); } } - myEditedObject->RemoveGeometryGroups(); + 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() @@ -850,3 +1425,118 @@ void HYDROGUI_CalculationOp::onRemoveGroups() aPanel->excludeGroups( aSelectedList ); } + +void HYDROGUI_CalculationOp::onChangeLandCoverMode( int theMode ) +{ + HYDROGUI_CalculationDlg* aPanel = + ::qobject_cast( inputPanel() ); + if ( !aPanel ) + return; + + if ( !confirmLandCoverModeChange() ) { + aPanel->setLandCoverMode( myEditedObject->GetAssignmentLandCoverMode() ); + return; + } + + myEditedObject->SetAssignmentLandCoverMode( (HYDROData_CalculationCase::AssignmentMode)theMode ); + aPanel->setLandCoverMode( theMode ); +} + +void HYDROGUI_CalculationOp::onAddLandCovers() +{ + HYDROGUI_CalculationDlg* aPanel = + ::qobject_cast( inputPanel() ); + if ( !aPanel ) + return; + + // Add land covers selected in the module browser to the calculation case + QStringList aSelectedList = aPanel->getSelectedAvailableLandCovers(); + if ( aSelectedList.isEmpty() || !confirmRegionsChange() ) + return; + + QStringList anAddedList; + for (int i = 0; i < aSelectedList.length(); i++) + { + Handle(HYDROData_LandCover) anObject = Handle(HYDROData_LandCover)::DownCast( + HYDROGUI_Tool::FindObjectByName( module(), aSelectedList.at( i ) ) ); + if ( anObject.IsNull() ) + continue; + + if ( myEditedObject->AddLandCover( anObject ) ) + anAddedList.append( anObject->GetName() ); + } + + if ( !anAddedList.isEmpty() ) + { + aPanel->includeLandCovers( anAddedList, false ); + // TODO: create preview of included land covers + //createPreview(); + } +} + +void HYDROGUI_CalculationOp::onRemoveLandCovers() +{ + // Remove selected objects from the calculation case + HYDROGUI_CalculationDlg* aPanel = + ::qobject_cast( inputPanel() ); + if ( !aPanel ) + return; + + QStringList aSelectedList = aPanel->getSelectedLandCovers(); + if ( aSelectedList.isEmpty() || !confirmRegionsChange() ) + return; + + for (int i = 0; i < aSelectedList.length(); i++) + { + Handle(HYDROData_LandCover) anObject = Handle(HYDROData_LandCover)::DownCast( + HYDROGUI_Tool::FindObjectByName( module(), aSelectedList.at(i) ) ); + if ( anObject.IsNull() ) + continue; + + setObjectVisibility( anObject, false ); + myEditedObject->RemoveLandCover( anObject ); + } + + module()->update( UF_OCCViewer ); + aPanel->excludeLandCovers( aSelectedList ); +} + +void HYDROGUI_CalculationOp::onChangeMode( int theMode ) +{ + HYDROGUI_CalculationDlg* aPanel = + ::qobject_cast( inputPanel() ); + if ( !aPanel ) + return; + + if ( !confirmModeChange() ) { + aPanel->setMode( myEditedObject->GetAssignmentMode() ); + return; + } + + myEditedObject->SetAssignmentMode( (HYDROData_CalculationCase::AssignmentMode)theMode ); + aPanel->setMode( theMode ); +} + +void HYDROGUI_CalculationOp::onOrderChanged( bool& isConfirmed ) +{ + HYDROGUI_CalculationDlg* aPanel = + ::qobject_cast( inputPanel() ); + if ( !aPanel ) + return; + + isConfirmed = confirmOrderChange(); + if( isConfirmed ) + myEditedObject->SetToUpdate( true ); +} + +void HYDROGUI_CalculationOp::onOrderLandCoverChanged( bool& isConfirmed ) +{ + HYDROGUI_CalculationDlg* aPanel = + ::qobject_cast( inputPanel() ); + if ( !aPanel ) + return; + + isConfirmed = confirmLandCoverOrderChange(); + if( isConfirmed ) + myEditedObject->SetToUpdate( true ); +}