X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROGUI%2FHYDROGUI_CalculationOp.cxx;h=f8311d5a4f90c45bb0ef1dfa8626dd9995559e35;hb=d6e19029f8b41f295db878e9aecf451c2edda4af;hp=9d78d3cc4db6990fc98bbaa1c79e360aca362d4c;hpb=f499e28961344db8429c02de5ae962a1bb40b323;p=modules%2Fhydro.git diff --git a/src/HYDROGUI/HYDROGUI_CalculationOp.cxx b/src/HYDROGUI/HYDROGUI_CalculationOp.cxx index 9d78d3cc..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 @@ -151,22 +149,7 @@ void HYDROGUI_CalculationOp::startOperation() aPanel->includeGeomObjects( aList ); // set rules - HYDROData_ListOfRules aRules; - Handle(HYDROData_Object) anObject1, anObject2; - HYDROData_PriorityType aPriority; - HYDROData_Zone::MergeAltitudesType aMergeType; - for ( int anIndex = 0; anIndex < myEditedObject->GetRulesCount(); anIndex++ ) { - if ( myEditedObject->GetRule( anIndex, anObject1, aPriority, anObject2, aMergeType ) ) { - HYDROData_CustomRule aRule; - aRule.Object1 = anObject1; - aRule.Object2 = anObject2; - aRule.Priority = aPriority; - aRule.MergeType = aMergeType; - - aRules << aRule; - } - } - aPanel->setRules( aRules ); + setRules( HYDROData_CalculationCase::DataTag_CustomRules ); } } else @@ -223,11 +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( 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* ) ) ); @@ -240,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; } @@ -285,6 +280,69 @@ void HYDROGUI_CalculationOp::onBoundarySelected ( const QString & theObjName ) } } +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 ); + } + } +} + void HYDROGUI_CalculationOp::onObjectsSelected() { HYDROGUI_CalculationDlg* aPanel = @@ -326,6 +384,47 @@ void HYDROGUI_CalculationOp::onObjectsSelected() 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 ) { HYDROGUI_Region* aRegionItem = dynamic_cast(theItem); @@ -518,6 +617,31 @@ 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 @@ -572,6 +696,58 @@ bool HYDROGUI_CalculationOp::confirmContinueWithWarning( const HYDROData_Warning 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, QStringList& theBrowseObjectsEntries ) @@ -587,6 +763,14 @@ bool HYDROGUI_CalculationOp::processApply( int& theUpdateFlags, 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; @@ -658,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() ); @@ -675,31 +934,36 @@ void HYDROGUI_CalculationOp::onNext( const int theIndex ) // At first we must to update the case name because of // automatic names generation for regions and zones myEditedObject->SetName( aNewCaseName ); - - // Clear rules - if ( myEditedObject->GetRulesCount() > 0 ) { - myEditedObject->ClearRules(); - } - + // Set parameters for automatic mode int aMode = aPanel->getMode(); - if ( aMode == HYDROData_CalculationCase::AUTOMATIC ) { + if ( aMode == HYDROData_CalculationCase::AUTOMATIC ) + { // Set objects in the specified order - 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; + 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 ); } - myEditedObject->AddGeometryObject( anObject ); - } - - // Set priority rules - foreach ( const HYDROData_CustomRule& aRule, aPanel->getRules() ) { - myEditedObject->AddRule( aRule.Object1, aRule.Priority, - aRule.Object2, aRule.MergeType ); + // 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 ); @@ -709,6 +973,8 @@ void HYDROGUI_CalculationOp::onNext( const int theIndex ) myShowZones = true; myEditedObject->Update(); + AssignDefaultZonesColors(); + //aPanel->setEditedObject( myEditedObject ); aPanel->refreshZonesBrowser(); @@ -716,6 +982,8 @@ void HYDROGUI_CalculationOp::onNext( const int theIndex ) createPreview(); anIsToUpdateOb = true; + + myEditedObject->SetToUpdate( true ); } else { @@ -726,6 +994,7 @@ void HYDROGUI_CalculationOp::onNext( const int theIndex ) } } + // Move this code to processing od the last panel (see below) if ( anIsToUpdateOb ) { SUIT_DataBrowser* anObjBrowser = ((LightApp_Application*)module()->application())->objectBrowser(); if ( anObjBrowser ) { @@ -733,6 +1002,49 @@ void HYDROGUI_CalculationOp::onNext( const int theIndex ) } } + 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(); } } @@ -776,6 +1088,110 @@ void HYDROGUI_CalculationOp::setZonesVisible( bool theIsVisible ) } } +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() ) + { + 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; + } + + 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() { LightApp_Application* anApp = module()->getApp(); @@ -1010,6 +1426,81 @@ 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 = @@ -1025,3 +1516,27 @@ void HYDROGUI_CalculationOp::onChangeMode( int theMode ) 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 ); +}