X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROGUI%2FHYDROGUI_CalculationDlg.cxx;h=c727437116b6f305cd9fafe62842a94a5fec6ce5;hb=3a1dd3f29ff9b985b0aa2366a2afd5724286cb6e;hp=c06ab638b0f0e2d3ff6480d2c4a556c44be64ae7;hpb=bfe9d3ccf8d5347b917d4c9e5e89413cebe51cc6;p=modules%2Fhydro.git

diff --git a/src/HYDROGUI/HYDROGUI_CalculationDlg.cxx b/src/HYDROGUI/HYDROGUI_CalculationDlg.cxx
index c06ab638..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
@@ -26,11 +22,15 @@
 #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 <HYDROData_Document.h>
 #include <HYDROData_Entity.h>
@@ -45,9 +45,12 @@
 #include <SUIT_Study.h>
 
 #include <LightApp_Application.h>
+#include <LightApp_SelectionMgr.h>
 #include <SUIT_Desktop.h>
 #include <SUIT_MessageBox.h>
 
+#include <QButtonGroup>
+#include <QComboBox>
 #include <QGroupBox>
 #include <QLabel>
 #include <QLayout>
@@ -55,18 +58,22 @@
 #include <QListWidget>
 #include <QPicture>
 #include <QPushButton>
+#include <QRadioButton>
+#include <QSplitter>
+#include <QTableWidget>
 #include <QToolButton>
+#include <QTreeView>
 #include <QWizardPage>
-#include <QComboBox>
+
 
 HYDROGUI_CalculationDlg::HYDROGUI_CalculationDlg( HYDROGUI_Module* theModule, const QString& theTitle )
 : HYDROGUI_Wizard( theModule, theTitle )
 {
-  QWizard* aWizard = wizard();
-  aWizard->addPage( createObjectsPage() );
-  aWizard->addPage( createZonesPage() );
-  connect( aWizard->button( QWizard::NextButton ), SIGNAL( clicked() ), SIGNAL( splitZones() ) );
-  aWizard->show();
+  addPage( createObjectsPage() );
+  addPage( createGroupsPage() );
+  addPage( createLandCoversPage() );
+  addPage( createZonesPage() );
+  addPage( createLandCoverZonesPage() );
 }
 
 HYDROGUI_CalculationDlg::~HYDROGUI_CalculationDlg()
@@ -76,106 +83,480 @@ HYDROGUI_CalculationDlg::~HYDROGUI_CalculationDlg()
 void HYDROGUI_CalculationDlg::reset()
 {
   myObjectName->clear();
-  myGeomObjects->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<Handle(HYDROData_Entity)> anObjects;
+  myPriorityWidget->setObjects( anObjects );
+  myLandCoverPriorityWidget->setObjects( anObjects );
 }
 
 QWizardPage* HYDROGUI_CalculationDlg::createObjectsPage() {
-  QWizardPage* aPage = new QWizardPage( wizard() );
+  QWizardPage* aPage = new QWizardPage( mainFrame() );
   QFrame* aFrame = new QFrame( aPage );
 
-  // Calculation name
+  // 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() ), this, SLOT( onEmptyName() ) );
-  connect( myValidator, SIGNAL( alreadyExists( QString ) ), this, SLOT( onAlreadyExists( QString ) ) );
+  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 );
+  
+  QBoxLayout* aModeSelectorLayout = new QHBoxLayout;
+  aModeSelectorLayout->setMargin( 5 );
+  aModeSelectorLayout->setSpacing( 5 );
+  aModeSelectorLayout->addWidget( anAutoRB );
+  aModeSelectorLayout->addWidget( aManualRB );
+  aModeGroup->setLayout( aModeSelectorLayout );
 
-  myGeomObjects = new QListWidget( aPage );
-  myGeomObjects->setSelectionMode( QListWidget::SingleSelection );
-  myGeomObjects->setEditTriggers( QListWidget::NoEditTriggers );
-  myGeomObjects->setViewMode( QListWidget::ListMode );
-  myGeomObjects->setSortingEnabled( true );
+  // 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 );
 
-  QFrame* aBtnsFrame = new QFrame( aPage );
+  // buttons
+  QFrame* aBtnsFrame = new QFrame;
   QVBoxLayout* aBtnsLayout = new QVBoxLayout( aBtnsFrame );
   aBtnsLayout->setMargin( 5 );
   aBtnsLayout->setSpacing( 5 );
   aBtnsFrame->setLayout( aBtnsLayout );
-  QPushButton* anAddBtn = new QPushButton( tr("ADD"), aBtnsFrame );
-  QPushButton* aRemoveBtn = new QPushButton( tr("REMOVE"), aBtnsFrame );
+  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 );
 
-  QLabel* aNameLabel = new QLabel( tr( "NAME" ), aPage );
-  QLabel* anObjectsLabel = new QLabel( tr( "CALCULATION_REFERENCE_OBJECTS" ), aPage );
+  aTopContainer->setLayout( aTopLayout );
+
+  // add the top of the page to the splitter
+  mySplitter->insertWidget(0, aTopContainer);
+  mySplitter->setStretchFactor(0, 2);
+
+  // Bottom of the page
+  myPriorityWidget = new HYDROGUI_PriorityWidget( mainFrame() );
+
+  QGroupBox* aPriorityGroup = new QGroupBox( tr( "PRIORITY" ) );
+  QBoxLayout* aPriorityLayout = new QHBoxLayout;
+  aPriorityLayout->setMargin( 5 );
+  aPriorityLayout->setSpacing( 5 );
+  aPriorityLayout->addWidget( myPriorityWidget );
+  aPriorityGroup->setLayout( aPriorityLayout );
+
+  // add the bottom of the page to the splitter
+  mySplitter->insertWidget(1, aPriorityGroup);
+  mySplitter->setStretchFactor(1, 1);
 
-  QGridLayout* aZonesLayout = new QGridLayout( aPage );
-  aZonesLayout->setMargin( 5 );
-  aZonesLayout->setSpacing( 5 );
-  aZonesLayout->setVerticalSpacing( 10 );
-  aZonesLayout->addWidget( aNameLabel,     0, 0, Qt::AlignHCenter );
-  aZonesLayout->addWidget( myObjectName,   0, 1 );
-  aZonesLayout->addWidget( anObjectsLabel, 1, 0, Qt::AlignHCenter );
-  aZonesLayout->addWidget( myGeomObjects,  1, 1, 2, 1 );
-  aZonesLayout->addWidget( aBtnsFrame,     2, 0, Qt::AlignHCenter );
+  // Page layout
+  QVBoxLayout* aPageLayout = new QVBoxLayout;
+  aPageLayout->setMargin( 5 );
+  aPageLayout->setSpacing( 5 );
+  aPageLayout->addWidget( mySplitter );
 
-  aPage->setLayout( aZonesLayout );
+  aPage->setLayout( aPageLayout );
 
-  connect( anAddBtn, SIGNAL( clicked() ), this, SIGNAL( addObjects() ) );
-  connect( aRemoveBtn, SIGNAL( clicked() ), this, SIGNAL( removeObjects() ) );
+  // Create selector
+  if ( module() ) {
+    HYDROGUI_ListSelector* aListSelector = 
+      new HYDROGUI_ListSelector( myGeomObjects, module()->getApp()->selectionMgr() );
+    aListSelector->setAutoBlock( true );
+  }
+
+  // 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() ) );
 
   return aPage;
 }
 
-void HYDROGUI_CalculationDlg::onEmptyName()
-{
-  QString aTitle = QObject::tr( "INSUFFICIENT_INPUT_DATA" );
-  QString aMessage = QObject::tr( "INCORRECT_OBJECT_NAME" );
-  SUIT_MessageBox::critical( module()->getApp()->desktop(), aTitle, aMessage );
+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;
 }
 
-void HYDROGUI_CalculationDlg::onAlreadyExists( QString theName )
-{
-  QString aTitle = QObject::tr( "INSUFFICIENT_INPUT_DATA" );
-  QString aMessage = QObject::tr( "OBJECT_EXISTS_IN_DOCUMENT" ).arg( theName );
-  SUIT_MessageBox::critical( module()->getApp()->desktop(), aTitle, aMessage );
+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<HYDROGUI_PriorityTableModel*>( 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( wizard() );
+  QWizardPage* aPage = new QWizardPage( mainFrame() );
   QFrame* aFrame = new QFrame( aPage );
 
   QGridLayout* aLayout = new QGridLayout( aPage );
   
-  myBrowser = new HYDROGUI_DataBrowser( module(), 0, aPage );
+  myBrowser = new HYDROGUI_DataBrowser( module(), NULL, aPage );
   myBrowser->setAutoOpenLevel( 3 );
   aLayout->setMargin( 5 );
   aLayout->setSpacing( 5 );
 
   aLayout->addWidget( myBrowser, 0, 0, 1, 2 );
 
-  myBatimetryLabel = new QLabel( tr( "BATHYMETRY" ), aFrame );
+  myBathymetryLabel = new QLabel( tr( "BATHYMETRY" ), aFrame );
   myBathymetryChoice = new QComboBox( aFrame );
 
   myBathymetryChoice->setVisible( false );
-  myBatimetryLabel->setVisible( false );
+  myBathymetryLabel->setVisible( false );
 
-  aLayout->addWidget( myBatimetryLabel, 1, 0 );
+  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*>&, SUIT_DataObject*, int, Qt::DropAction ) ),
       SLOT( onZonesDropped( const QList<SUIT_DataObject*>&, 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*>&, SUIT_DataObject*, int, Qt::DropAction ) ),
+      SLOT( onLandCoverZonesDropped( const QList<SUIT_DataObject*>&, 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::onEmptyName()
+{
+  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<SUIT_DataObject*>& theList, 
     SUIT_DataObject* theTargetParent, int theTargetRow, Qt::DropAction theDropAction )
 {
@@ -197,18 +578,29 @@ void HYDROGUI_CalculationDlg::onZonesDropped( const QList<SUIT_DataObject*>& the
     if ( aRegionsRoot )
     {
       // Create a new region
+      emit createRegion( aZonesList );
     }
     else
     {
       HYDROGUI_Region* aRegion = dynamic_cast<HYDROGUI_Region*>(theTargetParent);
       if ( aRegion )
       {
-        aRegion->addZones( );
+        emit moveZones( theTargetParent, aZonesList );
       }
     }
   }
 }
 
+void HYDROGUI_CalculationDlg::OnNewRegion()
+{
+  emit createRegion( myBrowser->getSelected() );
+}
+
+void HYDROGUI_CalculationDlg::OnNewLandCoverRegion()
+{
+  emit createLandCoverRegion( myLandCoverBrowser->getSelected() );
+}
+
 void HYDROGUI_CalculationDlg::onMergeTypeSelected( int theIndex )
 {
   int aType = myBathymetryChoice->itemData( theIndex ).toInt();
@@ -234,7 +626,7 @@ void HYDROGUI_CalculationDlg::onSelected( SUIT_DataObject* theObject )
     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->getBathymetries();
+    QStringList aList = aZone->getAltitudes();
     for ( int i = 0; i < aList.length(); i++ )
     {
       myBathymetryChoice->addItem( aList.at( i ), HYDROData_Zone::Merge_Object );
@@ -250,7 +642,7 @@ void HYDROGUI_CalculationDlg::onSelected( SUIT_DataObject* theObject )
         aCurIndex = 2;
         break;
       case HYDROData_Zone::Merge_Object:
-        aCurIndex = 3 + aList.indexOf( aZone->text( HYDROGUI_DataObject::BathymetryId ) );
+        aCurIndex = 3 + aList.indexOf( aZone->text( HYDROGUI_DataObject::AltitudeObjId ) );
         break;
       default:
         aCurIndex = 0; // Select unknown by default
@@ -260,7 +652,24 @@ void HYDROGUI_CalculationDlg::onSelected( SUIT_DataObject* theObject )
   }
 
   myBathymetryChoice->setVisible( doShow );
-  myBatimetryLabel->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<SUIT_DataObject*>& theList, 
+    SUIT_DataObject* theTargetParent, int theTargetRow, Qt::DropAction theDropAction )
+{
+  // TODO: implement this function
 }
 
 void HYDROGUI_CalculationDlg::setObjectName( const QString& theName )
@@ -273,27 +682,123 @@ QString HYDROGUI_CalculationDlg::getObjectName() const
   return myObjectName->text();
 }
 
-void HYDROGUI_CalculationDlg::setGeomObjects( const QStringList& theObjects )
+void moveItems( QListWidget* theSource, QListWidget* theDest, const QStringList& theObjects )
 {
+  QList<QListWidgetItem*> 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::setSelectedGeomObjects( const QStringList& theObjects )
+void HYDROGUI_CalculationDlg::includeGeomObjects( const QStringList& theObjects )
 {
-  myGeomObjects->clear();
+  QList<QListWidgetItem*> 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 )
+{
+  QList<QListWidgetItem*> 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() );
+}
+
+void HYDROGUI_CalculationDlg::setBoundary( const QString& theObjName )
+{
+  bool isBlocked = myPolylineName->blockSignals( true );
+  myPolylineName->setCurrentIndex( myPolylineName->findText( theObjName ) );
+  myPolylineName->blockSignals( isBlocked );
+}
+
+void HYDROGUI_CalculationDlg::setPolylineNames( const QStringList& theObjects, const QStringList& theObjectsEntries )
+{
+  myPolylineName->clear();
+  myPolylineName->addItem( "", "" ); // No boundary item
+
+  for ( int i = 0, n = theObjects.length(); i < n; ++i )
+  {
+    myPolylineName->addItem( theObjects.at( i ), theObjectsEntries.at( i ) );
+  }
+}
+
+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::setAllGeomObjects( const QStringList& theObjects, const QStringList& theObjectsEntries )
+{
+  myAvailableGeomObjects->clear();
 
   for ( int i = 0, n = theObjects.length(); i < n; ++i )
   {
     QString anObjName = theObjects.at( i );
 
-    QListWidgetItem* aListItem = new QListWidgetItem( anObjName, myGeomObjects );
+    QListWidgetItem* aListItem = new QListWidgetItem( anObjName, myAvailableGeomObjects );
     aListItem->setFlags( Qt::ItemIsEnabled | Qt::ItemIsSelectable );
+    aListItem->setData( Qt::UserRole, theObjectsEntries.at( i ) );
   }
 }
 
-QStringList HYDROGUI_CalculationDlg::getSelectedGeomObjects() const
+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 );
+
+    QListWidgetItem* aListItem = new QListWidgetItem( anObjName, myAvailableLandCovers );
+    aListItem->setFlags( Qt::ItemIsEnabled | Qt::ItemIsSelectable );
+    aListItem->setData( Qt::UserRole, theObjectsEntries.at( i ) );
+  }
+}
+
+QStringList getSelected( QListWidget* theWidget )
 {
   QStringList aResList;
-  QList<QListWidgetItem*> aList = myGeomObjects->selectedItems();
+  QList<QListWidgetItem*> aList = theWidget->selectedItems();
   for ( int i = 0, n = aList.length(); i < n; ++i )
   {
     aResList.append( aList.at( i )->text() );
@@ -301,19 +806,49 @@ QStringList HYDROGUI_CalculationDlg::getSelectedGeomObjects() const
   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 );
 
-  HYDROGUI_DataObject* anobj = new HYDROGUI_DataObject( 0, NULL, "" );
-  myBrowser->setRoot(anobj);
+  // Build the calculation case subtree
+  module()->getDataModel()->buildCaseTree( myBrowser->root(), myEditedObject );
 
-  LightApp_DataObject* aCaseItem = module()->getDataModel()->createObject( anobj,
-                                     myEditedObject, "", true );
   myBrowser->updateTree();
   myBrowser->openLevels();
   myBrowser->adjustColumnsWidth();
+  myBrowser->setAutoUpdate( true );
+  myBrowser->setUpdateModified( true );
 }
 
 HYDROGUI_Zone* HYDROGUI_CalculationDlg::getCurrentZone() const
@@ -323,5 +858,295 @@ HYDROGUI_Zone* HYDROGUI_CalculationDlg::getCurrentZone() const
 
 void HYDROGUI_CalculationDlg::refreshZonesBrowser()
 {
-  myBrowser->updateTree();
-}
\ No newline at end of file
+  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<Handle(HYDROData_Entity)> HYDROGUI_CalculationDlg::getGeometryObjects()
+{
+  QList<Handle(HYDROData_Entity)> anEntities = myGeomObjects->getObjects();
+  QList<Handle(HYDROData_Entity)> anObjects;
+
+  foreach ( Handle(HYDROData_Entity) anEntity, anEntities ) {
+    Handle(HYDROData_Object) anObj = Handle(HYDROData_Object)::DownCast( anEntity );
+    if ( anObj.IsNull() ) {
+      continue;
+    }
+
+    anObjects << anObj;
+  }
+
+  return anObjects;
+}
+
+/**
+  Get included land covers.
+  @return the list of land covers
+ */
+QList<Handle(HYDROData_Entity)> HYDROGUI_CalculationDlg::getLandCovers()
+{
+  QList<Handle(HYDROData_Entity)> anEntities = myLandCovers->getObjects();
+  QList<Handle(HYDROData_Entity)> aLandCovers;
+
+  foreach ( Handle(HYDROData_Entity) anEntity, anEntities ) {
+    Handle(HYDROData_LandCover) aLandCover = Handle(HYDROData_LandCover)::DownCast( anEntity );
+    if ( aLandCover.IsNull() ) {
+      continue;
+    }
+
+    aLandCovers << aLandCover;
+  }
+
+  return aLandCovers;
+}
+
+/**
+  Get rules.
+  @return the list of rules
+ */
+HYDROData_ListOfRules HYDROGUI_CalculationDlg::getRules() const
+{
+  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();
+}
+
+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 )
+  {
+    HYDROGUI_ListModel::Object2VisibleList anObject2VisibleList;
+    myLandCovers->setObjects(anObject2VisibleList);
+  }
+        
+  QList<QListWidgetItem*> 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 );
+    }
+
+    // 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 ) );
+  }
+
+  myLandCoverPriorityWidget->setObjects( getLandCovers() );
+}
+
+void HYDROGUI_CalculationDlg::excludeLandCovers( const QStringList& theLandCovers )
+{
+  QList<QListWidgetItem*> 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 );
+}
+
+/**
+  Slot called when zones created on land covers are changed.
+ */
+void HYDROGUI_CalculationDlg::onDataLandCoverChanged()
+{
+  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();  
+}