X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROGUI%2FHYDROGUI_CalculationDlg.cxx;h=c727437116b6f305cd9fafe62842a94a5fec6ce5;hb=3a1dd3f29ff9b985b0aa2366a2afd5724286cb6e;hp=57e38659b0d6bb21e68438a5ffb6f8f03ba17e4e;hpb=11ec2af6a8049f50cdd7b8f53da49f813b5d2c8f;p=modules%2Fhydro.git diff --git a/src/HYDROGUI/HYDROGUI_CalculationDlg.cxx b/src/HYDROGUI/HYDROGUI_CalculationDlg.cxx index 57e38659..c7274371 100644 --- a/src/HYDROGUI/HYDROGUI_CalculationDlg.cxx +++ b/src/HYDROGUI/HYDROGUI_CalculationDlg.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,11 +20,37 @@ #include "HYDROGUI_ObjSelector.h" #include "HYDROGUI_Tool.h" +#include "HYDROGUI_DataBrowser.h" +#include "HYDROGUI_DataModel.h" +#include "HYDROGUI_ListSelector.h" +#include "HYDROGUI_Module.h" +#include "HYDROGUI_DataObject.h" +#include "HYDROGUI_NameValidator.h" +#include "HYDROGUI_Region.h" +#include "HYDROGUI_Zone.h" +#include "HYDROGUI_OrderedListWidget.h" +#include "HYDROGUI_PriorityWidget.h" +#include "HYDROGUI_PriorityTableModel.h" + +#include +#include +#include +#include + +#include #include #include #include +#include + +#include +#include +#include +#include +#include +#include #include #include #include @@ -36,88 +58,618 @@ #include #include #include +#include +#include +#include #include +#include +#include + HYDROGUI_CalculationDlg::HYDROGUI_CalculationDlg( HYDROGUI_Module* theModule, const QString& theTitle ) -: HYDROGUI_InputPanel( theModule, theTitle ) +: HYDROGUI_Wizard( theModule, theTitle ) +{ + addPage( createObjectsPage() ); + addPage( createGroupsPage() ); + addPage( createLandCoversPage() ); + addPage( createZonesPage() ); + addPage( createLandCoverZonesPage() ); +} + +HYDROGUI_CalculationDlg::~HYDROGUI_CalculationDlg() +{ +} + +void HYDROGUI_CalculationDlg::reset() { - // Calculation name - myObjectNameGroup = new QGroupBox( tr( "CALCULATION_NAME" ), mainFrame() ); + myObjectName->clear(); + HYDROGUI_ListModel::Object2VisibleList anObject2VisibleList; + myGeomObjects->setObjects(anObject2VisibleList); + myLandCovers->setObjects(anObject2VisibleList); + myPolylineName->clear(); + myStricklerTableName->clear(); + myAvailableGeomObjects->clear(); + myAvailableLandCovers->clear(); + + // Activate the automatic mode + setMode( HYDROData_CalculationCase::AUTOMATIC ); + setLandCoverMode( HYDROData_CalculationCase::AUTOMATIC ); + + // Reset the priority widget state + QList anObjects; + myPriorityWidget->setObjects( anObjects ); + myLandCoverPriorityWidget->setObjects( anObjects ); +} - myObjectName = new QLineEdit( myObjectNameGroup ); +QWizardPage* HYDROGUI_CalculationDlg::createObjectsPage() { + QWizardPage* aPage = new QWizardPage( mainFrame() ); + QFrame* aFrame = new QFrame( aPage ); - QBoxLayout* aNameLayout = new QHBoxLayout( myObjectNameGroup ); - aNameLayout->setMargin( 5 ); - aNameLayout->setSpacing( 5 ); - aNameLayout->addWidget( new QLabel( tr( "NAME" ), myObjectNameGroup ) ); - aNameLayout->addWidget( myObjectName ); + // Splitter + mySplitter = new QSplitter(Qt::Vertical); + // Top of the page + QWidget* aTopContainer = new QWidget; + + // calculation name + myObjectName = new QLineEdit( aPage ); + myValidator = new HYDROGUI_NameValidator(module(), myObjectName); + myObjectName->setValidator( myValidator ); + + connect( myValidator, SIGNAL( emptyName() ), SLOT( onEmptyName() ) ); + connect( myValidator, SIGNAL( alreadyExists( QString ) ), SLOT( onAlreadyExists( QString ) ) ); + + // polyline name + myPolylineName = new QComboBox( aPage ); + connect( myPolylineName, SIGNAL( activated( const QString & ) ), + SIGNAL( boundarySelected( const QString & ) ) ); + + // names labels + QLabel* aNameLabel = new QLabel( tr( "NAME" ), aPage ); + QLabel* aLimitsLabel = new QLabel( tr( "LIMITS" ), aPage ); + + // mode selector (auto/manual) + QGroupBox* aModeGroup = new QGroupBox( tr( "MODE" ) ); + + QRadioButton* aManualRB = new QRadioButton( tr( "MANUAL" ), mainFrame() ); + QRadioButton* anAutoRB = new QRadioButton( tr( "AUTO" ), mainFrame() ); + + myModeButtons = new QButtonGroup( mainFrame() ); + myModeButtons->addButton( anAutoRB, HYDROData_CalculationCase::AUTOMATIC ); + myModeButtons->addButton( aManualRB, HYDROData_CalculationCase::MANUAL ); - // Calculation boundary line - QGroupBox* aBndGroup = new QGroupBox( tr( "CALCULATION_BOUNDARY" ), mainFrame() ); + QBoxLayout* aModeSelectorLayout = new QHBoxLayout; + aModeSelectorLayout->setMargin( 5 ); + aModeSelectorLayout->setSpacing( 5 ); + aModeSelectorLayout->addWidget( anAutoRB ); + aModeSelectorLayout->addWidget( aManualRB ); + aModeGroup->setLayout( aModeSelectorLayout ); + + // geometry objects + QLabel* anObjectsLabel = new QLabel( tr( "CALCULATION_REFERENCE_OBJECTS" ) ); + myGeomObjects = new HYDROGUI_OrderedListWidget( aPage, 16 ); + myGeomObjects->setHiddenObjectsShown(true); + myGeomObjects->setVisibilityIconShown(false); + myGeomObjects->setContentsMargins(QMargins()); + + // included geometry objects + QLabel* anIncludedLabel = new QLabel( tr( "INCLUDED_OBJECTS" ) ); + myAvailableGeomObjects = new QListWidget( aPage ); + myAvailableGeomObjects->setSelectionMode( QListWidget::ExtendedSelection ); + myAvailableGeomObjects->setEditTriggers( QListWidget::NoEditTriggers ); + myAvailableGeomObjects->setViewMode( QListWidget::ListMode ); + myAvailableGeomObjects->setSortingEnabled( true ); - myBndPolyline = new HYDROGUI_ObjSelector( theModule, KIND_POLYLINE, aBndGroup ); + // buttons + QFrame* aBtnsFrame = new QFrame; + QVBoxLayout* aBtnsLayout = new QVBoxLayout( aBtnsFrame ); + aBtnsLayout->setMargin( 5 ); + aBtnsLayout->setSpacing( 5 ); + aBtnsFrame->setLayout( aBtnsLayout ); + QPushButton* anAddBtn = new QPushButton( tr("INCLUDE"), aBtnsFrame ); + QPushButton* aRemoveBtn = new QPushButton( tr("EXCLUDE"), aBtnsFrame ); + + // fill the butons frame with two buttons + aBtnsLayout->addWidget( anAddBtn ); + aBtnsLayout->addWidget( aRemoveBtn ); + aBtnsLayout->addStretch( 1 ); + + // top of the page layout + + // objects frame + QFrame* anObjectsFrame = new QFrame( aPage ); + anObjectsFrame->setFrameStyle( QFrame::Panel | QFrame::Raised ); + QGridLayout* anObjsLayout = new QGridLayout( anObjectsFrame ); + anObjsLayout->setMargin( 5 ); + anObjsLayout->setSpacing( 5 ); + anObjectsFrame->setLayout( anObjsLayout ); + + // fill the objects frame with two lists, two labels and with buttons frame + anObjsLayout->addWidget( anObjectsLabel, 0, 0, Qt::AlignHCenter ); + anObjsLayout->addWidget( anIncludedLabel, 0, 2, Qt::AlignHCenter ); + anObjsLayout->addWidget( myAvailableGeomObjects, 1, 0 ); + anObjsLayout->addWidget( aBtnsFrame, 1, 1, Qt::AlignHCenter ); + anObjsLayout->addWidget( myGeomObjects, 1, 2 ); + + // fill the top of the page + QGridLayout* aTopLayout = new QGridLayout; + aTopLayout->setMargin( 5 ); + aTopLayout->setSpacing( 5 ); + aTopLayout->setVerticalSpacing( 10 ); + aTopLayout->addWidget( aNameLabel, 0, 0, Qt::AlignHCenter ); + aTopLayout->addWidget( myObjectName, 0, 1 ); + aTopLayout->addWidget( aLimitsLabel, 1, 0, Qt::AlignHCenter ); + aTopLayout->addWidget( myPolylineName, 1, 1 ); + aTopLayout->addWidget( aModeGroup, 2, 0, 1, 2 ); + aTopLayout->addWidget( anObjectsFrame, 3, 0, 1, 2 ); - QBoxLayout* aBndLayout = new QHBoxLayout( aBndGroup ); - aBndLayout->setMargin( 5 ); - aBndLayout->setSpacing( 5 ); - aBndLayout->addWidget( new QLabel( tr( "BOUNDARY_POLYLINE" ), aBndGroup ) ); - aBndLayout->addWidget( myBndPolyline ); + aTopContainer->setLayout( aTopLayout ); + // add the top of the page to the splitter + mySplitter->insertWidget(0, aTopContainer); + mySplitter->setStretchFactor(0, 2); - // Calculation zones - QGroupBox* aZonesGroup = new QGroupBox( tr( "CALCULATION_ZONES" ), mainFrame() ); + // Bottom of the page + myPriorityWidget = new HYDROGUI_PriorityWidget( mainFrame() ); - myZones = new QListWidget( aZonesGroup ); - myZones->setSelectionMode( QListWidget::SingleSelection ); - myZones->setEditTriggers( QListWidget::NoEditTriggers ); - myZones->setViewMode( QListWidget::ListMode ); + QGroupBox* aPriorityGroup = new QGroupBox( tr( "PRIORITY" ) ); + QBoxLayout* aPriorityLayout = new QHBoxLayout; + aPriorityLayout->setMargin( 5 ); + aPriorityLayout->setSpacing( 5 ); + aPriorityLayout->addWidget( myPriorityWidget ); + aPriorityGroup->setLayout( aPriorityLayout ); - myRegions = new QListWidget( aZonesGroup ); - myRegions->setSelectionMode( QListWidget::SingleSelection ); - myRegions->setEditTriggers( QListWidget::NoEditTriggers ); - myRegions->setViewMode( QListWidget::ListMode ); + // add the bottom of the page to the splitter + mySplitter->insertWidget(1, aPriorityGroup); + mySplitter->setStretchFactor(1, 1); - mySplittedZonesPrefix = new QLineEdit( aZonesGroup ); + // Page layout + QVBoxLayout* aPageLayout = new QVBoxLayout; + aPageLayout->setMargin( 5 ); + aPageLayout->setSpacing( 5 ); + aPageLayout->addWidget( mySplitter ); - QPushButton* aSplitBtn = new QPushButton( tr( "SPLIT_REFERENCE_ZONES" ), aZonesGroup ); + aPage->setLayout( aPageLayout ); - QGridLayout* aZonesLayout = new QGridLayout( aZonesGroup ); - aZonesLayout->setMargin( 5 ); - aZonesLayout->setSpacing( 5 ); - aZonesLayout->addWidget( new QLabel( tr( "CALCULATION_REFERENCE_ZONES" ), aZonesGroup ), 0, 0, 1, 2 ); - aZonesLayout->addWidget( myZones, 1, 0, 1, 2 ); - aZonesLayout->addWidget( new QLabel( tr( "CALCULATION_REGIONS" ), aZonesGroup ), 2, 0, 1, 2 ); - aZonesLayout->addWidget( myRegions, 3, 0, 1, 2 ); - aZonesLayout->addWidget( new QLabel( tr( "PREFIX_REGIONS" ), aZonesGroup ), 4, 0 ); - aZonesLayout->addWidget( mySplittedZonesPrefix, 4, 1 ); - aZonesLayout->addWidget( aSplitBtn, 5, 0, 1, 2 ); + // Create selector + if ( module() ) { + HYDROGUI_ListSelector* aListSelector = + new HYDROGUI_ListSelector( myGeomObjects, module()->getApp()->selectionMgr() ); + aListSelector->setAutoBlock( true ); + } - // Common - addWidget( myObjectNameGroup ); - addWidget( aBndGroup ); - addWidget( aZonesGroup ); - addStretch(); + // Connections + connect( myModeButtons, SIGNAL( buttonClicked( int ) ), SIGNAL( changeMode( int ) ) ); + connect( anAddBtn, SIGNAL( clicked() ), SIGNAL( addObjects() ) ); + connect( aRemoveBtn, SIGNAL( clicked() ), SIGNAL( removeObjects() ) ); + connect( myGeomObjects, SIGNAL( orderChanged() ), SLOT( onOrderChanged() ) ); - // Connect signals and slots - connect( aSplitBtn, SIGNAL( clicked( bool ) ), this, SIGNAL( SplitZones() ) ); + return aPage; } -HYDROGUI_CalculationDlg::~HYDROGUI_CalculationDlg() +QWizardPage* HYDROGUI_CalculationDlg::createGroupsPage() { + QWizardPage* aPage = new QWizardPage( mainFrame() ); + QFrame* aFrame = new QFrame( aPage ); + + myGroups = new QListWidget( aPage ); + myGroups->setSelectionMode( QListWidget::ExtendedSelection ); + myGroups->setEditTriggers( QListWidget::NoEditTriggers ); + myGroups->setViewMode( QListWidget::ListMode ); + myGroups->setSortingEnabled( true ); + + myAvailableGroups = new QListWidget( aPage ); + myAvailableGroups->setSelectionMode( QListWidget::ExtendedSelection ); + myAvailableGroups->setEditTriggers( QListWidget::NoEditTriggers ); + myAvailableGroups->setViewMode( QListWidget::ListMode ); + myAvailableGroups->setSortingEnabled( true ); + + connect( myGroups, SIGNAL( itemSelectionChanged() ), + SIGNAL( groupsSelected() ) ); + + QFrame* aGroupsFrame = new QFrame( aPage ); + QGridLayout* aGroupsLayout = new QGridLayout( aGroupsFrame ); + aGroupsLayout->setMargin( 5 ); + aGroupsLayout->setSpacing( 5 ); + aGroupsFrame->setLayout( aGroupsLayout ); + + QFrame* aBtnsFrame = new QFrame( aGroupsFrame ); + QVBoxLayout* aBtnsLayout = new QVBoxLayout( aBtnsFrame ); + aBtnsLayout->setMargin( 5 ); + aBtnsLayout->setSpacing( 5 ); + aBtnsFrame->setLayout( aBtnsLayout ); + QPushButton* anAddBtn = new QPushButton( tr("INCLUDE"), aBtnsFrame ); + QPushButton* aRemoveBtn = new QPushButton( tr("EXCLUDE"), aBtnsFrame ); + + // Fill the butons frame with two buttons + aBtnsLayout->addWidget( anAddBtn ); + aBtnsLayout->addWidget( aRemoveBtn ); + aBtnsLayout->addStretch( 1 ); + + QLabel* anIncludedLabel = new QLabel( tr( "INCLUDED_GROUPS" ), aGroupsFrame ); + QLabel* anAvailableLabel = new QLabel( tr( "AVAILABLE_GROUPS" ), aGroupsFrame ); + + // Fill the objects frame with two lists, two labels and with buttons frame + aGroupsLayout->addWidget( anAvailableLabel, 0, 0, Qt::AlignHCenter ); + aGroupsLayout->addWidget( anIncludedLabel, 0, 2, Qt::AlignHCenter ); + aGroupsLayout->addWidget( myAvailableGroups, 1, 0 ); + aGroupsLayout->addWidget( aBtnsFrame, 1, 1, Qt::AlignHCenter ); + aGroupsLayout->addWidget( myGroups, 1, 2 ); + + // Fill the page + QGridLayout* aPageLayout = new QGridLayout( aPage ); + aPageLayout->setMargin( 5 ); + aPageLayout->setSpacing( 5 ); + aPageLayout->setVerticalSpacing( 10 ); + aPageLayout->addWidget( aGroupsFrame, 0, 0 ); + + aPage->setLayout( aPageLayout ); + + connect( anAddBtn, SIGNAL( clicked() ), SIGNAL( addGroups() ) ); + connect( aRemoveBtn, SIGNAL( clicked() ), SIGNAL( removeGroups() ) ); + + return aPage; +} + +QWizardPage* HYDROGUI_CalculationDlg::createLandCoversPage() { + QWizardPage* aPage = new QWizardPage( mainFrame() ); + QFrame* aFrame = new QFrame( aPage ); + + // Splitter + myLandCoverSplitter = new QSplitter(Qt::Vertical); + + // Top of the page + QWidget* aTopContainer = new QWidget; + + // Combo-box to choose Strickler table name + QLabel* aStricklerTableLabel = new QLabel( tr( "STRICKLER_TABLE" ), aPage ); + myStricklerTableName = new QComboBox( aPage ); + myStricklerTableName->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed ) ); + connect( myStricklerTableName, SIGNAL( activated( const QString & ) ), + SIGNAL( StricklerTableSelected( const QString & ) ) ); + + // Mode selector (auto/manual) + QGroupBox* aModeGroup = new QGroupBox( tr( "MODE" ) ); + + QRadioButton* aManualRB = new QRadioButton( tr( "MANUAL" ), mainFrame() ); + QRadioButton* anAutoRB = new QRadioButton( tr( "AUTO" ), mainFrame() ); + + myLandCoverModeButtons = new QButtonGroup( mainFrame() ); + myLandCoverModeButtons->addButton( anAutoRB, HYDROData_CalculationCase::AUTOMATIC ); + myLandCoverModeButtons->addButton( aManualRB, HYDROData_CalculationCase::MANUAL ); + + QBoxLayout* aModeSelectorLayout = new QHBoxLayout; + aModeSelectorLayout->setMargin( 5 ); + aModeSelectorLayout->setSpacing( 5 ); + aModeSelectorLayout->addWidget( anAutoRB ); + aModeSelectorLayout->addWidget( aManualRB ); + aModeGroup->setLayout( aModeSelectorLayout ); + + // Available land covers + QLabel* aLandCoversLabel = new QLabel( tr( "CALCULATION_REFERENCE_LAND_COVERS" ) ); + myAvailableLandCovers = new QListWidget( aPage ); + myAvailableLandCovers->setSelectionMode( QListWidget::ExtendedSelection ); + myAvailableLandCovers->setEditTriggers( QListWidget::NoEditTriggers ); + myAvailableLandCovers->setViewMode( QListWidget::ListMode ); + myAvailableLandCovers->setSortingEnabled( true ); + + // Included land covers + QLabel* anIncludedLabel = new QLabel( tr( "INCLUDED_LAND_COVERS" ) ); + myLandCovers = new HYDROGUI_OrderedListWidget( aPage, 16 ); + myLandCovers->setHiddenObjectsShown(true); + myLandCovers->setVisibilityIconShown(false); + myLandCovers->setContentsMargins(QMargins()); + + // Include/Exclude buttons + QFrame* aBtnsFrame = new QFrame; + QVBoxLayout* aBtnsLayout = new QVBoxLayout( aBtnsFrame ); + aBtnsLayout->setMargin( 5 ); + aBtnsLayout->setSpacing( 5 ); + aBtnsFrame->setLayout( aBtnsLayout ); + QPushButton* anAddBtn = new QPushButton( tr("INCLUDE"), aBtnsFrame ); + QPushButton* aRemoveBtn = new QPushButton( tr("EXCLUDE"), aBtnsFrame ); + + // Fill the butons frame with two buttons + aBtnsLayout->addWidget( anAddBtn ); + aBtnsLayout->addWidget( aRemoveBtn ); + aBtnsLayout->addStretch( 1 ); + + // Land covers frame + QFrame* aLandCoversFrame = new QFrame( aPage ); + aLandCoversFrame->setFrameStyle( QFrame::Panel | QFrame::Raised ); + QGridLayout* aLandCoversLayout = new QGridLayout( aLandCoversFrame ); + aLandCoversLayout->setMargin( 5 ); + aLandCoversLayout->setSpacing( 5 ); + aLandCoversFrame->setLayout( aLandCoversLayout ); + + // Fill the land covers frame with two lists, two labels and with buttons frame + aLandCoversLayout->addWidget( aLandCoversLabel, 0, 0, Qt::AlignHCenter ); + aLandCoversLayout->addWidget( anIncludedLabel, 0, 2, Qt::AlignHCenter ); + aLandCoversLayout->addWidget( myAvailableLandCovers, 1, 0 ); + aLandCoversLayout->addWidget( aBtnsFrame, 1, 1, Qt::AlignHCenter ); + aLandCoversLayout->addWidget( myLandCovers, 1, 2 ); + + // Fill the top layout of the page + QGridLayout* aTopLayout = new QGridLayout; + aTopLayout->setMargin( 5 ); + aTopLayout->setSpacing( 5 ); + aTopLayout->setVerticalSpacing( 10 ); + aTopLayout->addWidget( aStricklerTableLabel, 0, 0, Qt::AlignHCenter ); + aTopLayout->addWidget( myStricklerTableName, 0, 1 ); + aTopLayout->addWidget( aModeGroup, 1, 0, 1, 2 ); + aTopLayout->addWidget( aLandCoversFrame, 2, 0, 1, 2 ); + + aTopContainer->setLayout( aTopLayout ); + + // Add the top of the page to the splitter + myLandCoverSplitter->insertWidget(0, aTopContainer); + myLandCoverSplitter->setStretchFactor(0, 2); + + // Bottom of the page + myLandCoverPriorityWidget = new HYDROGUI_PriorityWidget( mainFrame() ); + HYDROGUI_PriorityTableModel* aModel = + dynamic_cast( myLandCoverPriorityWidget->getTable()->model() ); + if ( aModel ) + aModel->setColumnCount( 3 ); + + QGroupBox* aPriorityGroup = new QGroupBox( tr( "PRIORITY" ) ); + QBoxLayout* aPriorityLayout = new QHBoxLayout; + aPriorityLayout->setMargin( 5 ); + aPriorityLayout->setSpacing( 5 ); + aPriorityLayout->addWidget( myLandCoverPriorityWidget ); + aPriorityGroup->setLayout( aPriorityLayout ); + + // Add the bottom of the page to the splitter + myLandCoverSplitter->insertWidget(1, aPriorityGroup); + myLandCoverSplitter->setStretchFactor(1, 1); + + // Page layout + QVBoxLayout* aPageLayout = new QVBoxLayout; + aPageLayout->setMargin( 5 ); + aPageLayout->setSpacing( 5 ); + aPageLayout->addWidget( myLandCoverSplitter ); + + aPage->setLayout( aPageLayout ); + + // Create selector + if ( module() ) { + HYDROGUI_ListSelector* aListSelector = + new HYDROGUI_ListSelector( myLandCovers, module()->getApp()->selectionMgr() ); + aListSelector->setAutoBlock( true ); + } + + // Connections + connect( myLandCoverModeButtons, SIGNAL( buttonClicked( int ) ), SIGNAL( changeLandCoverMode( int ) ) ); + connect( anAddBtn, SIGNAL( clicked() ), SIGNAL( addLandCovers() ) ); + connect( aRemoveBtn, SIGNAL( clicked() ), SIGNAL( removeLandCovers() ) ); + + connect( myLandCovers, SIGNAL( orderLandCoverChanged() ), SLOT( onOrderLandCoverChanged() ) ); + + return aPage; +} + +QWizardPage* HYDROGUI_CalculationDlg::createZonesPage() { + QWizardPage* aPage = new QWizardPage( mainFrame() ); + QFrame* aFrame = new QFrame( aPage ); + + QGridLayout* aLayout = new QGridLayout( aPage ); + + myBrowser = new HYDROGUI_DataBrowser( module(), NULL, aPage ); + myBrowser->setAutoOpenLevel( 3 ); + aLayout->setMargin( 5 ); + aLayout->setSpacing( 5 ); + + aLayout->addWidget( myBrowser, 0, 0, 1, 2 ); + + myBathymetryLabel = new QLabel( tr( "BATHYMETRY" ), aFrame ); + myBathymetryChoice = new QComboBox( aFrame ); + + myBathymetryChoice->setVisible( false ); + myBathymetryLabel->setVisible( false ); + + aLayout->addWidget( myBathymetryLabel, 1, 0 ); + aLayout->addWidget( myBathymetryChoice, 1, 1 ); + + aPage->setLayout( aLayout ); + + connect( myBrowser, SIGNAL( dataChanged() ), SLOT( onDataChanged() ) ); + connect( myBrowser, SIGNAL( clicked( SUIT_DataObject* ) ), SIGNAL( clickedInZonesBrowser( SUIT_DataObject* ) ) ); + connect( myBrowser, SIGNAL( clicked( SUIT_DataObject* ) ), SLOT( onSelected( SUIT_DataObject* ) ) ); + connect( myBathymetryChoice, SIGNAL( activated( int ) ), SLOT( onMergeTypeSelected( int ) ) ); + connect( myBrowser, + SIGNAL( dropped( const QList&, SUIT_DataObject*, int, Qt::DropAction ) ), + SLOT( onZonesDropped( const QList&, SUIT_DataObject*, int, Qt::DropAction ) ) ); + connect( myBrowser, SIGNAL( newRegion() ), this, SLOT( OnNewRegion() ) ); + + return aPage; +} + +QWizardPage* HYDROGUI_CalculationDlg::createLandCoverZonesPage() { + QWizardPage* aPage = new QWizardPage( mainFrame() ); + QFrame* aFrame = new QFrame( aPage ); + + QGridLayout* aLayout = new QGridLayout( aPage ); + + myLandCoverBrowser = new HYDROGUI_DataBrowser( module(), NULL, aPage ); + myLandCoverBrowser->setAutoOpenLevel( 3 ); + aLayout->setMargin( 5 ); + aLayout->setSpacing( 5 ); + + aLayout->addWidget( myLandCoverBrowser, 0, 0, 1, 2 ); + + myStricklerTypeLabel = new QLabel( tr( "STRICKLER_TYPE" ), aFrame ); + myStricklerTypeChoice = new QComboBox( aFrame ); + + myStricklerTypeLabel->setVisible( false ); + myStricklerTypeChoice->setVisible( false ); + + aLayout->addWidget( myBathymetryLabel, 1, 0 ); + aLayout->addWidget( myBathymetryChoice, 1, 1 ); + + aPage->setLayout( aLayout ); + + // Connections + connect( myLandCoverBrowser, SIGNAL( dataChanged() ), SLOT( onDataLandCoverChanged() ) ); + connect( myLandCoverBrowser, SIGNAL( clicked( SUIT_DataObject* ) ), SIGNAL( clickedInZonesBrowser( SUIT_DataObject* ) ) ); + connect( myLandCoverBrowser, SIGNAL( clicked( SUIT_DataObject* ) ), SLOT( onLandCoverZoneSelected( SUIT_DataObject* ) ) ); + connect( myStricklerTypeChoice, SIGNAL( activated( int ) ), SLOT( onMergeStricklerTypeSelected( int ) ) ); + connect( myLandCoverBrowser, + SIGNAL( dropped( const QList&, SUIT_DataObject*, int, Qt::DropAction ) ), + SLOT( onLandCoverZonesDropped( const QList&, SUIT_DataObject*, int, Qt::DropAction ) ) ); + connect( myLandCoverBrowser, SIGNAL( newRegion() ), this, SLOT( OnNewLandCoverRegion() ) ); + + return aPage; +} + + +bool HYDROGUI_CalculationDlg::acceptCurrent() const { + QString anErrorMsg; + + if ( false /*myGeomObjects->count() == 0*/ ) + { + anErrorMsg = tr( "EMPTY_GEOMETRY_OBJECTS" ); + } + + if ( !anErrorMsg.isEmpty() ) + { + anErrorMsg += "\n" + tr( "INPUT_VALID_DATA" ); + + QString aTitle = tr( "INSUFFICIENT_INPUT_DATA" ); + SUIT_MessageBox::critical( module()->getApp()->desktop(), aTitle, anErrorMsg ); + } + + return anErrorMsg.isEmpty(); } -void HYDROGUI_CalculationDlg::reset() +void HYDROGUI_CalculationDlg::onEmptyName() { - myObjectName->clear(); + QString aTitle = tr( "INSUFFICIENT_INPUT_DATA" ); + QString aMessage = tr( "INCORRECT_OBJECT_NAME" ) + "\n" + tr( "INPUT_VALID_DATA" ); + SUIT_MessageBox::critical( module()->getApp()->desktop(), aTitle, aMessage ); +} + +void HYDROGUI_CalculationDlg::onAlreadyExists( QString theName ) +{ + QString aTitle = tr( "INSUFFICIENT_INPUT_DATA" ); + QString aMessage = QObject::tr( "OBJECT_EXISTS_IN_DOCUMENT" ).arg( theName ) + + "\n" + tr( "INPUT_VALID_DATA" ); + SUIT_MessageBox::critical( module()->getApp()->desktop(), aTitle, aMessage ); +} + +void HYDROGUI_CalculationDlg::onZonesDropped( const QList& theList, + SUIT_DataObject* theTargetParent, int theTargetRow, Qt::DropAction theDropAction ) +{ + QList aZonesList; + HYDROGUI_Zone* aZone; + // Get a list of dropped zones + for ( int i = 0; i < theList.length(); i++ ) + { + aZone = dynamic_cast( theList.at( i ) ); + if ( aZone ) + { + aZonesList.append( aZone ); + } + } + if ( aZonesList.length() > 0 ) + { + // Get the target region + HYDROGUI_NamedObject* aRegionsRoot = dynamic_cast(theTargetParent); + if ( aRegionsRoot ) + { + // Create a new region + emit createRegion( aZonesList ); + } + else + { + HYDROGUI_Region* aRegion = dynamic_cast(theTargetParent); + if ( aRegion ) + { + emit moveZones( theTargetParent, aZonesList ); + } + } + } +} - myBndPolyline->Clear(); +void HYDROGUI_CalculationDlg::OnNewRegion() +{ + emit createRegion( myBrowser->getSelected() ); +} - myZones->clear(); - myRegions->clear(); +void HYDROGUI_CalculationDlg::OnNewLandCoverRegion() +{ + emit createLandCoverRegion( myLandCoverBrowser->getSelected() ); +} - setSplitZonesPrefix( tr( "DEFAULT_PREFIX_REGIONS" ) ); +void HYDROGUI_CalculationDlg::onMergeTypeSelected( int theIndex ) +{ + int aType = myBathymetryChoice->itemData( theIndex ).toInt(); + QString aText = myBathymetryChoice->itemText( theIndex ); + emit setMergeType( aType, aText ); +} + +void HYDROGUI_CalculationDlg::onSelected( SUIT_DataObject* theObject ) +{ + bool doShow = false; + HYDROGUI_Zone* aZone = dynamic_cast( theObject ); + if ( aZone ) + { + doShow = aZone->isMergingNeed(); + } + + if ( doShow ) + { + // Fill the merge type combo box + bool prevBlock = myBathymetryChoice->blockSignals( true ); + myCurrentZone = aZone; + myBathymetryChoice->clear(); + myBathymetryChoice->addItem( tr("MERGE_UNKNOWN"), HYDROData_Zone::Merge_UNKNOWN ); + myBathymetryChoice->addItem( tr("MERGE_ZMIN"), HYDROData_Zone::Merge_ZMIN ); + myBathymetryChoice->addItem( tr("MERGE_ZMAX"), HYDROData_Zone::Merge_ZMAX ); + QStringList aList = aZone->getAltitudes(); + for ( int i = 0; i < aList.length(); i++ ) + { + myBathymetryChoice->addItem( aList.at( i ), HYDROData_Zone::Merge_Object ); + } + // Select the current choice if any + int aCurIndex = 0; + switch ( aZone->getMergeType() ) + { + case HYDROData_Zone::Merge_ZMIN: + aCurIndex = 1; + break; + case HYDROData_Zone::Merge_ZMAX: + aCurIndex = 2; + break; + case HYDROData_Zone::Merge_Object: + aCurIndex = 3 + aList.indexOf( aZone->text( HYDROGUI_DataObject::AltitudeObjId ) ); + break; + default: + aCurIndex = 0; // Select unknown by default + } + myBathymetryChoice->setCurrentIndex( aCurIndex ); + myBathymetryChoice->blockSignals( prevBlock ); + } + + myBathymetryChoice->setVisible( doShow ); + myBathymetryChoice->setEnabled( getMode() == HYDROData_CalculationCase::MANUAL ); + myBathymetryLabel->setVisible( doShow ); +} + +void HYDROGUI_CalculationDlg::onLandCoverZoneSelected( SUIT_DataObject* theObject ) +{ + // TODO: implement this function +} + +void HYDROGUI_CalculationDlg::onMergeStricklerTypeSelected( int theIndex ) +{ + // TODO: implement this function +} + +void HYDROGUI_CalculationDlg::onLandCoverZonesDropped( const QList& theList, + SUIT_DataObject* theTargetParent, int theTargetRow, Qt::DropAction theDropAction ) +{ + // TODO: implement this function } void HYDROGUI_CalculationDlg::setObjectName( const QString& theName ) @@ -130,106 +682,471 @@ QString HYDROGUI_CalculationDlg::getObjectName() const return myObjectName->text(); } -void HYDROGUI_CalculationDlg::setPolylineName( const QString& theName ) +void moveItems( QListWidget* theSource, QListWidget* theDest, const QStringList& theObjects ) +{ + QList aFoundItems; + int anIdx; + QListWidgetItem* anItem; + + for ( int i = 0, n = theObjects.length(); i < n; ++i ) + { + QString anObjName = theObjects.at( i ); + aFoundItems = theSource->findItems( anObjName, Qt::MatchExactly ); + for ( anIdx = 0; anIdx < aFoundItems.length(); anIdx++ ) + { + anItem = aFoundItems.at( anIdx ); + // Remove this object from available objects list + anItem = theSource->takeItem( theSource->row( anItem ) ); + // Add the item to the included objects list + theDest->addItem( anItem ); + } + } +} + +void HYDROGUI_CalculationDlg::includeGeomObjects( const QStringList& theObjects ) +{ + QList aFoundItems; + foreach ( const QString& anObjName, theObjects ) { + // Hide the object in the available objects list + aFoundItems = myAvailableGeomObjects->findItems( anObjName, Qt::MatchExactly ); + foreach ( QListWidgetItem* anItem, aFoundItems ) { + anItem->setHidden( true ); + } + + // Add the object to the list of included objects + Handle(HYDROData_Entity) anObject = + HYDROGUI_Tool::FindObjectByName( module(), anObjName ); + myGeomObjects->addObject( HYDROGUI_ListModel::Object2Visible( anObject, true ) ); + } + + myPriorityWidget->setObjects( getGeometryObjects() ); +} + +void HYDROGUI_CalculationDlg::excludeGeomObjects( const QStringList& theObjects ) { - myBndPolyline->SetName( theName ); + QList aFoundItems; + foreach ( const QString& anObjName, theObjects ) { + // Set visible the object in the available objects list + aFoundItems = myAvailableGeomObjects->findItems( anObjName, Qt::MatchExactly ); + foreach ( QListWidgetItem* anItem, aFoundItems ) { + anItem->setHidden( false ); + } + + // Remove the object from the list of included objects + myGeomObjects->removeObjectByName( anObjName ); + } + + myPriorityWidget->setObjects( getGeometryObjects() ); } -QString HYDROGUI_CalculationDlg::getPolylineName() const +void HYDROGUI_CalculationDlg::setBoundary( const QString& theObjName ) { - return myBndPolyline->GetName(); + bool isBlocked = myPolylineName->blockSignals( true ); + myPolylineName->setCurrentIndex( myPolylineName->findText( theObjName ) ); + myPolylineName->blockSignals( isBlocked ); } -void HYDROGUI_CalculationDlg::setZones( const QStringList& theZones ) +void HYDROGUI_CalculationDlg::setPolylineNames( const QStringList& theObjects, const QStringList& theObjectsEntries ) { - myZones->clear(); + myPolylineName->clear(); + myPolylineName->addItem( "", "" ); // No boundary item - for ( int i = 0, n = theZones.length(); i < n; ++i ) + for ( int i = 0, n = theObjects.length(); i < n; ++i ) { - QString aZoneName = theZones.at( i ); + myPolylineName->addItem( theObjects.at( i ), theObjectsEntries.at( i ) ); + } +} - QListWidgetItem* aListItem = new QListWidgetItem( aZoneName, myZones ); - aListItem->setFlags( Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsUserCheckable ); - aListItem->setCheckState( Qt::Unchecked ); +void HYDROGUI_CalculationDlg::setStricklerTableNames( const QStringList& theObjects, const QStringList& theObjectsEntries ) +{ + myStricklerTableName->clear(); + + for ( int i = 0, n = theObjects.length(); i < n; ++i ) + { + myStricklerTableName->addItem( theObjects.at( i ), theObjectsEntries.at( i ) ); } } -void HYDROGUI_CalculationDlg::setSelectedZones( const QStringList& theZones ) +void HYDROGUI_CalculationDlg::setAllGeomObjects( const QStringList& theObjects, const QStringList& theObjectsEntries ) { - for ( int i = 0, n = theZones.length(); i < n; ++i ) + myAvailableGeomObjects->clear(); + + for ( int i = 0, n = theObjects.length(); i < n; ++i ) { - QString aZoneName = theZones.at( i ); + QString anObjName = theObjects.at( i ); - QList anItems = - myZones->findItems( aZoneName, Qt::MatchFixedString | Qt::MatchCaseSensitive ); - if ( anItems.isEmpty() ) - continue; + QListWidgetItem* aListItem = new QListWidgetItem( anObjName, myAvailableGeomObjects ); + aListItem->setFlags( Qt::ItemIsEnabled | Qt::ItemIsSelectable ); + aListItem->setData( Qt::UserRole, theObjectsEntries.at( i ) ); + } +} - QListWidgetItem* aListItem = anItems.first(); - if ( !aListItem ) - continue; +void HYDROGUI_CalculationDlg::setAllLandCovers( const QStringList& theObjects, const QStringList& theObjectsEntries ) +{ + myAvailableLandCovers->clear(); + + for ( int i = 0, n = theObjects.length(); i < n; ++i ) + { + QString anObjName = theObjects.at( i ); - aListItem->setCheckState( Qt::Checked ); + QListWidgetItem* aListItem = new QListWidgetItem( anObjName, myAvailableLandCovers ); + aListItem->setFlags( Qt::ItemIsEnabled | Qt::ItemIsSelectable ); + aListItem->setData( Qt::UserRole, theObjectsEntries.at( i ) ); } } -QStringList HYDROGUI_CalculationDlg::getSelectedZones() const +QStringList getSelected( QListWidget* theWidget ) { QStringList aResList; - - for ( int i = 0, n = myZones->count(); i < n; ++i ) + QList aList = theWidget->selectedItems(); + for ( int i = 0, n = aList.length(); i < n; ++i ) { - QListWidgetItem* aListItem = myZones->item( i ); - if ( !aListItem || aListItem->checkState() != Qt::Checked ) + aResList.append( aList.at( i )->text() ); + } + return aResList; +} + +QStringList HYDROGUI_CalculationDlg::getSelectedGeomObjects() const +{ + return myGeomObjects->getSelectedNames(); +} + +QStringList HYDROGUI_CalculationDlg::getSelectedLandCovers() const +{ + return myLandCovers->getSelectedNames(); +} + +QStringList HYDROGUI_CalculationDlg::getAllGeomObjects() const +{ + return myGeomObjects->getAllNames(); +} + +QStringList HYDROGUI_CalculationDlg::getAllLandCovers() const +{ + return myLandCovers->getAllNames(); +} + +QStringList HYDROGUI_CalculationDlg::getSelectedAvailableGeomObjects() const +{ + return getSelected( myAvailableGeomObjects ); +} + +QStringList HYDROGUI_CalculationDlg::getSelectedAvailableLandCovers() const +{ + return getSelected( myAvailableLandCovers ); +} + +void HYDROGUI_CalculationDlg::setEditedObject( const Handle(HYDROData_CalculationCase) theCase ) +{ + myEditedObject = theCase; + myValidator->setEditedObject( theCase ); + + // Build the calculation case subtree + module()->getDataModel()->buildCaseTree( myBrowser->root(), myEditedObject ); + + myBrowser->updateTree(); + myBrowser->openLevels(); + myBrowser->adjustColumnsWidth(); + myBrowser->setAutoUpdate( true ); + myBrowser->setUpdateModified( true ); +} + +HYDROGUI_Zone* HYDROGUI_CalculationDlg::getCurrentZone() const +{ + return myCurrentZone; +} + +void HYDROGUI_CalculationDlg::refreshZonesBrowser() +{ + SUIT_DataObject* aRoot = myBrowser->root(); + module()->getDataModel()->updateObjectTree( myEditedObject ); + module()->getDataModel()->buildCaseTree( aRoot, myEditedObject ); + myBrowser->updateTree( aRoot ); +} + +void HYDROGUI_CalculationDlg::onDataChanged() +{ + SUIT_DataObject* aRoot = myBrowser->root(); + module()->getDataModel()->buildCaseTree( aRoot, myEditedObject ); + myBrowser->updateTree( aRoot ); +} + +void HYDROGUI_CalculationDlg::setAvailableGroups( const QStringList& theGroups ) +{ + myAvailableGroups->clear(); + myGroups->clear(); + foreach( QString aGroup, theGroups ) + myAvailableGroups->addItem( aGroup ); +} + +QStringList HYDROGUI_CalculationDlg::getSelectedGroups() const +{ + return getSelected( myGroups ); +} + +QStringList HYDROGUI_CalculationDlg::getSelectedAvailableGroups() const +{ + return getSelected( myAvailableGroups ); +} + +void HYDROGUI_CalculationDlg::includeGroups( const QStringList& theObjects ) +{ + moveItems( myAvailableGroups, myGroups, theObjects ); +} + +void HYDROGUI_CalculationDlg::excludeGroups( const QStringList& theObjects ) +{ + moveItems( myGroups, myAvailableGroups, theObjects ); +} + +/** + Get creation mode. + @param theMode the mode +*/ +int HYDROGUI_CalculationDlg::getMode() const +{ + return myModeButtons->checkedId(); +} + +/** + Set creation mode. + @param theMode the mode +*/ +void HYDROGUI_CalculationDlg::setMode( int theMode ) +{ + bool isBlocked = myModeButtons->blockSignals( true ); + myModeButtons->button( theMode )->setChecked( true ); + myModeButtons->blockSignals( isBlocked ); + + bool isAuto = ( theMode == HYDROData_CalculationCase::AUTOMATIC ); + + myGeomObjects->setOrderingEnabled( isAuto ); + QWidget* aWidget = mySplitter->widget( 1 ); + if ( aWidget ) { + aWidget->setVisible( isAuto ); + } +} + +/** + Get creation mode for land covers panel. + @param theMode the mode +*/ +int HYDROGUI_CalculationDlg::getLandCoverMode() const +{ + return myLandCoverModeButtons->checkedId(); +} + +/** + Set creation mode for land cover panel. + @param theMode the mode +*/ +void HYDROGUI_CalculationDlg::setLandCoverMode( int theMode ) +{ + bool isBlocked = myLandCoverModeButtons->blockSignals( true ); + myLandCoverModeButtons->button( theMode )->setChecked( true ); + myLandCoverModeButtons->blockSignals( isBlocked ); + + bool isAuto = ( theMode == HYDROData_CalculationCase::AUTOMATIC ); + + myLandCovers->setOrderingEnabled( isAuto ); + QWidget* aWidget = myLandCoverSplitter->widget( 1 ); + if ( aWidget ) { + aWidget->setVisible( isAuto ); + } +} + +/** + Enable/disable zones drag'n'drop and renaming. + @param theIsEnabled if true - zones drag'n'drop and renaming will be enabled +*/ +void HYDROGUI_CalculationDlg::setEditZonesEnabled( const bool theIsEnabled ) +{ + myBrowser->setReadOnly( !theIsEnabled ); +} + +/** + Enable/disable land covers drag'n'drop and renaming. + @param theIsEnabled if true - land covers drag'n'drop and renaming will be enabled +*/ +void HYDROGUI_CalculationDlg::setEditLandCoversEnabled( const bool theIsEnabled ) +{ + myLandCoverBrowser->setReadOnly( !theIsEnabled ); +} + +/** + Get included geometry objects. + @return the list of geometry objects + */ +QList HYDROGUI_CalculationDlg::getGeometryObjects() +{ + QList anEntities = myGeomObjects->getObjects(); + QList anObjects; + + foreach ( Handle(HYDROData_Entity) anEntity, anEntities ) { + Handle(HYDROData_Object) anObj = Handle(HYDROData_Object)::DownCast( anEntity ); + if ( anObj.IsNull() ) { continue; + } - QString aSelZoneName = aListItem->text(); - aResList.append( aSelZoneName ); + anObjects << anObj; } - return aResList; + return anObjects; } -void HYDROGUI_CalculationDlg::setRegions( const QStringList& theRegions ) +/** + Get included land covers. + @return the list of land covers + */ +QList HYDROGUI_CalculationDlg::getLandCovers() { - myRegions->clear(); + QList anEntities = myLandCovers->getObjects(); + QList aLandCovers; - for ( int i = 0, n = theRegions.length(); i < n; ++i ) - { - QString aRegionName = theRegions.at( i ); + foreach ( Handle(HYDROData_Entity) anEntity, anEntities ) { + Handle(HYDROData_LandCover) aLandCover = Handle(HYDROData_LandCover)::DownCast( anEntity ); + if ( aLandCover.IsNull() ) { + continue; + } - QListWidgetItem* aListItem = new QListWidgetItem( aRegionName, myRegions ); - aListItem->setFlags( Qt::ItemIsEnabled | Qt::ItemIsSelectable ); + aLandCovers << aLandCover; } + + return aLandCovers; } -QStringList HYDROGUI_CalculationDlg::getRegions() const +/** + Get rules. + @return the list of rules + */ +HYDROData_ListOfRules HYDROGUI_CalculationDlg::getRules() const { - QStringList aResList; + return myPriorityWidget->getRules(); +} + +/** + Set rules. + @param theRules the list of rules + */ +void HYDROGUI_CalculationDlg::setRules( const HYDROData_ListOfRules& theRules ) const +{ + myPriorityWidget->setRules( theRules ); +} + +/** + Get rules defined for land covers. + @return the list of rules + */ +HYDROData_ListOfRules HYDROGUI_CalculationDlg::getLandCoverRules() const +{ + return myLandCoverPriorityWidget->getRules(); +} + +/** + Set rules for land covers. + @param theRules the list of rules + */ +void HYDROGUI_CalculationDlg::setLandCoverRules( const HYDROData_ListOfRules& theRules ) const +{ + myLandCoverPriorityWidget->setRules( theRules ); +} + +/** + Slot called when objects order is changed. + */ +void HYDROGUI_CalculationDlg::onOrderChanged() +{ + bool isConfirmed = true; + emit orderChanged( isConfirmed ); + if( isConfirmed ) + myPriorityWidget->setObjects( getGeometryObjects() ); + else + myGeomObjects->undoLastMove(); +} - for ( int i = 0, n = myRegions->count(); i < n; ++i ) +void HYDROGUI_CalculationDlg::setStricklerTable( const QString& theStricklerTableName, bool theBlockSignals ) +{ + bool isBlocked; + if ( theBlockSignals ) + isBlocked = myStricklerTableName->blockSignals( true ); + + myStricklerTableName->setCurrentIndex( myStricklerTableName->findText( theStricklerTableName ) ); + + if ( theBlockSignals ) + myStricklerTableName->blockSignals( isBlocked ); + else + emit StricklerTableSelected( theStricklerTableName ); +} + +void HYDROGUI_CalculationDlg::includeLandCovers( const QStringList& theLandCovers, bool theReset ) +{ + if ( theReset ) { - QListWidgetItem* aListItem = myRegions->item( i ); - if ( !aListItem ) - continue; + HYDROGUI_ListModel::Object2VisibleList anObject2VisibleList; + myLandCovers->setObjects(anObject2VisibleList); + } + + QList aFoundItems; + foreach ( const QString& anObjName, theLandCovers ) { + // Hide the land cover in the available land covers list + aFoundItems = myAvailableLandCovers->findItems( anObjName, Qt::MatchExactly ); + foreach ( QListWidgetItem* anItem, aFoundItems ) { + anItem->setHidden( true ); + } - QString aRegionName = aListItem->text(); - aResList.append( aRegionName ); + // Add the land cover to the list of included objects + Handle(HYDROData_Entity) anObject = + HYDROGUI_Tool::FindObjectByName( module(), anObjName ); + myLandCovers->addObject( HYDROGUI_ListModel::Object2Visible( anObject, true ) ); } - return aResList; + myLandCoverPriorityWidget->setObjects( getLandCovers() ); } -void HYDROGUI_CalculationDlg::setSplitZonesPrefix( const QString& theName ) +void HYDROGUI_CalculationDlg::excludeLandCovers( const QStringList& theLandCovers ) { - mySplittedZonesPrefix->setText( theName ); + QList aFoundItems; + foreach ( const QString& anObjName, theLandCovers ) { + // Set visible the land cover in the available objects list + aFoundItems = myAvailableLandCovers->findItems( anObjName, Qt::MatchExactly ); + foreach ( QListWidgetItem* anItem, aFoundItems ) { + anItem->setHidden( false ); + } + + // Remove the land cover from the list of included objects + myLandCovers->removeObjectByName( anObjName ); + } + + myLandCoverPriorityWidget->setObjects( getLandCovers() ); +} + +void HYDROGUI_CalculationDlg::refreshLandCoverZonesBrowser() +{ + SUIT_DataObject* aRoot = myLandCoverBrowser->root(); + module()->getDataModel()->updateObjectTree( myEditedObject ); + module()->getDataModel()->buildCaseTree( aRoot, myEditedObject ); + myLandCoverBrowser->updateTree( aRoot ); } -QString HYDROGUI_CalculationDlg::getSplitZonesPrefix() const +/** + Slot called when zones created on land covers are changed. + */ +void HYDROGUI_CalculationDlg::onDataLandCoverChanged() { - QString aPrefix = mySplittedZonesPrefix->text(); - if ( aPrefix.isEmpty() ) - aPrefix = tr( "DEFAULT_PREFIX_REGIONS" ); - return aPrefix; + SUIT_DataObject* aRoot = myLandCoverBrowser->root(); + module()->getDataModel()->buildCaseTree( aRoot, myEditedObject ); + myLandCoverBrowser->updateTree( aRoot ); } +/** + Slot called when land covers order is changed. + */ +void HYDROGUI_CalculationDlg::onOrderLandCoverChanged() +{ + bool isConfirmed = true; + emit orderLandCoverChanged( isConfirmed ); + if( isConfirmed ) + myLandCoverPriorityWidget->setObjects( getLandCovers() ); + else + myLandCovers->undoLastMove(); +}