X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROGUI%2FHYDROGUI_DataModel.cxx;h=f4cb0c9a780bdb520e01518b3516f1db26470cac;hb=fc42f9cabfa130d72aea8c10f003d6bec315b6c6;hp=6ea2d54aeab8160a183de0f6eccdffaf4a790359;hpb=6d6c4ec18ead5730c1d14090e33dc9667c5a5841;p=modules%2Fhydro.git

diff --git a/src/HYDROGUI/HYDROGUI_DataModel.cxx b/src/HYDROGUI/HYDROGUI_DataModel.cxx
index 6ea2d54a..f4cb0c9a 100644
--- a/src/HYDROGUI/HYDROGUI_DataModel.cxx
+++ b/src/HYDROGUI/HYDROGUI_DataModel.cxx
@@ -26,17 +26,26 @@
 #include "HYDROGUI_Module.h"
 #include "HYDROGUI_Tool.h"
 #include "HYDROGUI_Zone.h"
+#include "HYDROGUI_Region.h"
 
 #include <HYDROData_Bathymetry.h>
 #include <HYDROData_CalculationCase.h>
 #include <HYDROData_Document.h>
+#include <HYDROData_DummyObject3D.h>
 #include <HYDROData_Image.h>
 #include <HYDROData_ImmersibleZone.h>
 #include <HYDROData_Iterator.h>
-#include <HYDROData_Polyline.h>
+#include <HYDROData_Polyline3D.h>
+#include <HYDROData_PolylineXY.h>
+#include <HYDROData_Profile.h>
 #include <HYDROData_VisualState.h>
 #include <HYDROData_Region.h>
 #include <HYDROData_Zone.h>
+#include <HYDROData_Obstacle.h>
+#include <HYDROData_Channel.h>
+#include <HYDROData_Digue.h>
+#include <HYDROData_River.h>
+#include <HYDROData_Stream.h>
 
 #include <CAM_Application.h>
 #include <CAM_DataObject.h>
@@ -61,6 +70,11 @@
 #include <QApplication>
 #include <QDir>
 
+// #define DEB_GROUPS 1
+#ifdef DEB_GROUPS
+#include <HYDROData_ShapesGroup.h>
+#endif
+
 static HYDROData_SequenceOfObjects myCopyingObjects;
 
 HYDROGUI_DataModel::HYDROGUI_DataModel( CAM_Module* theModule )
@@ -223,70 +237,177 @@ void HYDROGUI_DataModel::update( const int theStudyId )
   if( aDocument.IsNull() )
     return;
 
-  LightApp_DataObject* anImageRootObj = createObject( aRootObj, partitionName( KIND_IMAGE ) );
+  // Create root objects:
 
-  HYDROData_Iterator anIterator( aDocument, KIND_IMAGE );
-  for( ; anIterator.More(); anIterator.Next() )
-  {
-    Handle(HYDROData_Image) anImageObj =
-      Handle(HYDROData_Image)::DownCast( anIterator.Current() );
-    if( !anImageObj.IsNull() )
-      createObject( anImageRootObj, anImageObj );
-  }
+  // IMAGES
+  LightApp_DataObject* anImageRootObj = createObject( aRootObj, tr( partitionName( KIND_IMAGE ).toAscii() ) );
 
-  LightApp_DataObject* aBathymetryRootObj = createObject( aRootObj, partitionName( KIND_BATHYMETRY ) );
+  // BATHYMETRY
+  LightApp_DataObject* aBathymetryRootObj = createObject( aRootObj, tr( partitionName( KIND_BATHYMETRY ).toAscii() ) );
 
-  anIterator = HYDROData_Iterator( aDocument, KIND_BATHYMETRY );
-  for( ; anIterator.More(); anIterator.Next() )
-  {
-    Handle(HYDROData_Bathymetry) aBathymetryObj =
-      Handle(HYDROData_Bathymetry)::DownCast( anIterator.Current() );
-    if( !aBathymetryObj.IsNull() )
-      createObject( aBathymetryRootObj, aBathymetryObj );
-  }
+  // ARTIFICIAL OBJECTS
+  LightApp_DataObject* anArtificialObjectsRootObj = createObject( aRootObj, tr( partitionName( KIND_ARTIFICIAL_OBJECT ).toAscii() ) );
 
-  LightApp_DataObject* aPolylineRootObj = createObject( aRootObj, partitionName( KIND_POLYLINE ) );
+  // NATURAL OBJECTS
+  LightApp_DataObject* aNaturalObjectsRootObj = createObject( aRootObj, tr( partitionName( KIND_NATURAL_OBJECT ).toAscii() ) );
 
-  anIterator = HYDROData_Iterator( aDocument, KIND_POLYLINE );
-  for( ; anIterator.More(); anIterator.Next() )
-  {
-    Handle(HYDROData_Polyline) aPolylineObj =
-      Handle(HYDROData_Polyline)::DownCast( anIterator.Current() );
-    if( !aPolylineObj.IsNull() )
-      createObject( aPolylineRootObj, aPolylineObj );
-  }
+  // OBSTACLES
+  LightApp_DataObject* anObstaclesRootObj = createObject( aRootObj, tr( partitionName( KIND_OBSTACLE ).toAscii() ) );
 
-  LightApp_DataObject* aZonesRootObj = createObject( aRootObj, partitionName( KIND_IMMERSIBLE_ZONE ) );
+  // CALCULATION CASES
+  LightApp_DataObject* aCalculRootObj = createObject( aRootObj, tr( partitionName( KIND_CALCULATION ).toAscii() ) );
 
-  anIterator = HYDROData_Iterator( aDocument, KIND_IMMERSIBLE_ZONE );
-  for( ; anIterator.More(); anIterator.Next() )
-  {
-    Handle(HYDROData_ImmersibleZone) aZoneObj =
-      Handle(HYDROData_ImmersibleZone)::DownCast( anIterator.Current() );
-    if( !aZoneObj.IsNull() )
-      createObject( aZonesRootObj, aZoneObj );
-  }
+  // POLYLINES
+  LightApp_DataObject* aPolylineRootObj = createObject( aRootObj, tr( partitionName( KIND_POLYLINEXY ).toAscii() ) );
 
-  LightApp_DataObject* aCalculRootObj = createObject( aRootObj, partitionName( KIND_CALCULATION ) );
+  // POLYLINES
+  LightApp_DataObject* aPolyline3DRootObj = createObject( aRootObj, tr( partitionName( KIND_POLYLINE ).toAscii() ) );
 
-  anIterator = HYDROData_Iterator( aDocument, KIND_CALCULATION );
-  for( ; anIterator.More(); anIterator.Next() )
-  {
-    Handle(HYDROData_CalculationCase) aCalculObj =
-      Handle(HYDROData_CalculationCase)::DownCast( anIterator.Current() );
-    if( !aCalculObj.IsNull() )
-      createObject( aCalculRootObj, aCalculObj );
-  }
+  // PROFILES
+  LightApp_DataObject* aProfileRootObj = createObject( aRootObj, tr( partitionName( KIND_PROFILE ).toAscii() ) );
 
-  LightApp_DataObject* aVisualStateRootObj = createObject( aRootObj, partitionName( KIND_VISUAL_STATE ) );
+  // VISUAL STATES
+  LightApp_DataObject* aVisualStateRootObj = createObject( aRootObj, tr( partitionName( KIND_VISUAL_STATE ).toAscii() ) );
 
-  anIterator = HYDROData_Iterator( aDocument, KIND_VISUAL_STATE );
-  for( ; anIterator.More(); anIterator.Next() )
-  {
-    Handle(HYDROData_VisualState) aVisualStateObj =
-      Handle(HYDROData_VisualState)::DownCast( anIterator.Current() );
-    if( !aVisualStateObj.IsNull() )
-      createObject( aVisualStateRootObj, aVisualStateObj );
+  HYDROData_Iterator anIterator( aDocument, KIND_UNKNOWN );
+  for( ; anIterator.More(); anIterator.Next() ) {
+    Handle(HYDROData_Entity) anObj = anIterator.Current();
+
+    if ( !anObj.IsNull() )
+    {
+      switch ( anObj->GetKind() ) {
+        case KIND_IMAGE:
+        {
+          Handle(HYDROData_Image) anImageObj =
+            Handle(HYDROData_Image)::DownCast( anObj );
+          if( !anImageObj.IsNull() ) {
+            createObject( anImageRootObj, anImageObj );
+          }
+
+          break;
+        }
+        case KIND_BATHYMETRY:
+        {
+          Handle(HYDROData_Bathymetry) aBathymetryObj =
+            Handle(HYDROData_Bathymetry)::DownCast( anObj );
+          if( !aBathymetryObj.IsNull() ) {
+            createObject( aBathymetryRootObj, aBathymetryObj );
+          }
+
+          break;
+        }
+        case KIND_CHANNEL:
+        {
+          Handle(HYDROData_Channel) aChannelObj =
+            Handle(HYDROData_Channel)::DownCast( anObj );
+          if( !aChannelObj.IsNull() ) {
+            createObject( anArtificialObjectsRootObj, aChannelObj );
+          }
+
+          break;
+        }
+        case KIND_DIGUE:
+        {
+          Handle(HYDROData_Digue) aDigueObj =
+            Handle(HYDROData_Digue)::DownCast( anObj );
+          if( !aDigueObj.IsNull() ) {
+            createObject( anArtificialObjectsRootObj, aDigueObj );
+          }
+
+          break;
+        }
+        case KIND_IMMERSIBLE_ZONE:
+        {
+          Handle(HYDROData_ImmersibleZone) anImmersibleZoneObj =
+            Handle(HYDROData_ImmersibleZone)::DownCast( anObj );
+          if( !anImmersibleZoneObj.IsNull() ) {
+            createObject( aNaturalObjectsRootObj, anImmersibleZoneObj );
+          }
+
+          break;
+        }
+        case KIND_RIVER:
+        {
+          Handle(HYDROData_River) aRiverObj =
+            Handle(HYDROData_River)::DownCast( anObj );
+          if( !aRiverObj.IsNull() ) {
+            createObject( aNaturalObjectsRootObj, aRiverObj );
+          }
+
+          break;
+        }
+        case KIND_STREAM:
+        {
+          Handle(HYDROData_Stream) aStreamObj =
+            Handle(HYDROData_Stream)::DownCast( anObj );
+          if( !aStreamObj.IsNull() ) {
+            createObject( aNaturalObjectsRootObj, aStreamObj );
+          }
+
+          break;
+        }
+        case KIND_OBSTACLE:
+        {
+          Handle(HYDROData_Obstacle) anObstacleObj =
+            Handle(HYDROData_Obstacle)::DownCast( anObj );
+          if( !anObstacleObj.IsNull() ) {
+            createObject( anObstaclesRootObj, anObstacleObj );
+          }
+
+          break;
+        }
+        case KIND_CALCULATION:
+        {
+          Handle(HYDROData_CalculationCase) aCalculObj =
+            Handle(HYDROData_CalculationCase)::DownCast( anObj );
+          if( !aCalculObj.IsNull() ) {
+            createObject( aCalculRootObj, aCalculObj );
+          }
+
+          break;
+        }
+        case KIND_POLYLINEXY:
+        {
+          Handle(HYDROData_PolylineXY) aPolylineObj =
+            Handle(HYDROData_PolylineXY)::DownCast( anObj );
+          if( !aPolylineObj.IsNull() ) {
+            createObject( aPolylineRootObj, aPolylineObj );
+          }
+
+          break;
+        }
+        case KIND_POLYLINE:
+        {
+          Handle(HYDROData_Polyline3D) aPolylineObj =
+            Handle(HYDROData_Polyline3D)::DownCast( anObj );
+          if( !aPolylineObj.IsNull() ) {
+            createObject( aPolyline3DRootObj, aPolylineObj );
+          }
+
+          break;
+        }
+        case KIND_PROFILE:
+        {
+          Handle(HYDROData_Profile) aProfileObj =
+            Handle(HYDROData_Profile)::DownCast( anObj );
+          if( !aProfileObj.IsNull() ) {
+            createObject( aProfileRootObj, aProfileObj );
+          }
+
+          break;
+        }
+        case KIND_VISUAL_STATE:
+        {
+          Handle(HYDROData_VisualState) aVisualStateObj =
+            Handle(HYDROData_VisualState)::DownCast( anObj );
+          if( !aVisualStateObj.IsNull() ) {
+            createObject( aVisualStateRootObj, aVisualStateObj );
+          }
+
+          break;
+        }
+      }
+    }
   }
 
   if( SUIT_DataBrowser* anObjectBrowser = anApp->objectBrowser() )
@@ -323,7 +444,8 @@ void HYDROGUI_DataModel::update( LightApp_DataObject* theObject,
 
 CAM_DataObject* HYDROGUI_DataModel::createRootModuleObject( SUIT_DataObject* theParent )
 {
-  CAM_DataObject* aRootObj = createModuleObject( theParent );
+  CAM_ModuleObject* aRootObj = createModuleObject( theParent );
+  aRootObj->setDataModel( this );
   setRoot( aRootObj );
   return aRootObj;
 }
@@ -425,20 +547,25 @@ bool HYDROGUI_DataModel::redo()
 bool HYDROGUI_DataModel::canCopy()
 {
   HYDROData_SequenceOfObjects aSeq = HYDROGUI_Tool::GetSelectedObjects( (HYDROGUI_Module*)module() );
-  if( aSeq.Length() != 1 )
-    return false;
-
-  Handle(HYDROData_Entity) anObject = aSeq.First();
-  if( anObject.IsNull() )
-    return false;
-
-  ObjectKind aKind = anObject->GetKind();
-  if( aKind == KIND_IMAGE ||
-      aKind == KIND_POLYLINE ||
-      aKind == KIND_CALCULATION )
-    return true;
+  bool isCanCopy = !aSeq.IsEmpty();
 
-  return false;
+  for ( Standard_Integer anIndex = 1, aLength = aSeq.Length(); anIndex <= aLength; anIndex++ ) {
+    Handle(HYDROData_Entity) anObject = aSeq.Value( anIndex );
+    if( !anObject.IsNull() ) {
+      ObjectKind aKind = anObject->GetKind();
+      bool isUnrecognized = aKind <= KIND_UNKNOWN || aKind > KIND_LAST;
+      bool isChildObject = aKind == KIND_DUMMY_3D || 
+                           aKind == KIND_ZONE ||
+                           aKind == KIND_SHAPES_GROUP || 
+                           aKind == KIND_SPLITTED_GROUP;
+      if ( isUnrecognized || isChildObject ) {
+        isCanCopy = false;
+        break;
+      }
+    }
+  }
+  
+  return isCanCopy;
 }
 
 bool HYDROGUI_DataModel::canPaste()
@@ -506,12 +633,16 @@ QString HYDROGUI_DataModel::partitionName( const ObjectKind theObjectKind )
 {
   switch( theObjectKind )
   {
-    case KIND_IMAGE:           return "IMAGES";
-    case KIND_POLYLINE:        return "POLYLINES";
-    case KIND_VISUAL_STATE:    return "VISUAL_STATES";
-    case KIND_BATHYMETRY:      return "BATHYMETRIES";
-    case KIND_CALCULATION:     return "CALCULATION_CASES";
-    case KIND_IMMERSIBLE_ZONE: return "IMMERSIBLE_ZONES";
+    case KIND_IMAGE:             return "IMAGES";
+    case KIND_POLYLINE:          return "POLYLINES_3D";
+    case KIND_POLYLINEXY:        return "POLYLINES";
+    case KIND_PROFILE:           return "PROFILES";
+    case KIND_VISUAL_STATE:      return "VISUAL_STATES";
+    case KIND_BATHYMETRY:        return "BATHYMETRIES";
+    case KIND_CALCULATION:       return "CALCULATION_CASES";
+    case KIND_OBSTACLE:          return "OBSTACLES";
+    case KIND_ARTIFICIAL_OBJECT: return "ARTIFICIAL_OBJECTS";
+    case KIND_NATURAL_OBJECT:    return "NATURAL_OBJECTS";
     default: break;
   }
   return QString();
@@ -528,17 +659,7 @@ LightApp_DataObject* HYDROGUI_DataModel::createObject( SUIT_DataObject*
                                                        const QString&           theParentEntry,
                                                        const bool               theIsBuildTree )
 {
-  HYDROGUI_DataObject* aResObj;
-  Handle(HYDROData_Zone) aRegionZone =
-    Handle(HYDROData_Zone)::DownCast( theModelObject );
-  if( !aRegionZone.IsNull() )
-  {
-    aResObj = new HYDROGUI_Zone( theParent, aRegionZone, theParentEntry );
-  }
-  else
-  {
-    aResObj = new HYDROGUI_DataObject( theParent, theModelObject, theParentEntry );
-  }
+  HYDROGUI_DataObject* aResObj = new HYDROGUI_DataObject( theParent, theModelObject, theParentEntry );
   
   if ( theIsBuildTree )
   {
@@ -548,6 +669,39 @@ LightApp_DataObject* HYDROGUI_DataModel::createObject( SUIT_DataObject*
   return aResObj;
 }
 
+LightApp_DataObject* HYDROGUI_DataModel::buildObject( SUIT_DataObject*     theParent,
+                                                      HYDROGUI_DataObject* theObject,
+                                                      const QString&       theParentEntry,
+                                                      const bool           theIsBuildTree,
+                                                      const bool           theIsInOperation )
+{
+  if ( theIsBuildTree )
+  {
+    buildObjectTree( theParent, theObject, theParentEntry, theIsInOperation );
+  }
+  return theObject;
+}
+
+LightApp_DataObject* HYDROGUI_DataModel::createZone( SUIT_DataObject*       theParent,
+                                                     Handle(HYDROData_Zone) theModelObject,
+                                                     const QString&         theParentEntry,
+                                                     const bool             theIsBuildTree,
+                                                     const bool             theIsInOperation )
+{
+  return buildObject( theParent, new HYDROGUI_Zone( theParent, theModelObject, theParentEntry, theIsInOperation ), 
+    theParentEntry, theIsBuildTree, theIsInOperation );
+}
+
+LightApp_DataObject* HYDROGUI_DataModel::createRegion( SUIT_DataObject*         theParent,
+                                                       Handle(HYDROData_Region) theModelObject,
+                                                       const QString&           theParentEntry,
+                                                       const bool               theIsBuildTree,
+                                                       const bool               theIsInOperation )
+{
+  return buildObject( theParent, new HYDROGUI_Region( theParent, theModelObject, theParentEntry, theIsInOperation ), 
+    theParentEntry, theIsBuildTree, theIsInOperation );
+}
+
 LightApp_DataObject* HYDROGUI_DataModel::createObject( SUIT_DataObject* theParent,
                                                        const QString&   theName,
                                                        const QString&   theParentEntry )
@@ -555,9 +709,34 @@ LightApp_DataObject* HYDROGUI_DataModel::createObject( SUIT_DataObject* theParen
   return new HYDROGUI_NamedObject( theParent, theName, theParentEntry );
 }
 
+void HYDROGUI_DataModel::buildObjectPartition( SUIT_DataObject*                   theObject,
+                                               const HYDROData_SequenceOfObjects& theObjects,
+                                               const QString&                     thePartName,
+                                               const bool                         theIsCreateEmpty )
+{
+  if ( theObjects.IsEmpty() && !theIsCreateEmpty )
+    return;
+
+  HYDROGUI_DataObject* aGuiObj = dynamic_cast<HYDROGUI_DataObject*>( theObject );
+  if ( !aGuiObj )
+    return;
+
+  LightApp_DataObject* aPartSect = 
+    createObject( aGuiObj, thePartName, aGuiObj->entry() );
+
+  HYDROData_SequenceOfObjects::Iterator anIter( theObjects );
+  for ( ; anIter.More(); anIter.Next() )
+  {
+    Handle(HYDROData_Entity) anObj = anIter.Value();
+    if( !anObj.IsNull() && !anObj->IsRemoved() )
+      createObject( aPartSect, anObj, aGuiObj->entry(), false );
+  }
+}
+
 void HYDROGUI_DataModel::buildObjectTree( SUIT_DataObject* theParent,
                                           SUIT_DataObject* theObject,
-                                          const QString&   theParentEntry )
+                                          const QString&   theParentEntry,
+                                          const bool       theIsInOperation )
 {
   HYDROGUI_DataObject* aGuiObj = dynamic_cast<HYDROGUI_DataObject*>( theObject );
   if ( !aGuiObj )
@@ -567,6 +746,21 @@ void HYDROGUI_DataModel::buildObjectTree( SUIT_DataObject* theParent,
   if ( aDataObj.IsNull() )
     return;
 
+  if ( aDataObj->IsKind( STANDARD_TYPE(HYDROData_Object) ) )
+  {
+    Handle(HYDROData_Object) aGeomObj =
+      Handle(HYDROData_Object)::DownCast( aDataObj );
+
+    Handle(HYDROData_DummyObject3D) anObject3D = aGeomObj->GetObject3D();
+    if ( !anObject3D.IsNull() )
+      createObject( aGuiObj, anObject3D, "", false );
+
+#ifdef DEB_GROUPS
+    HYDROData_SequenceOfObjects anObjGroups = aGeomObj->GetGroups();
+    buildObjectPartition( aGuiObj, anObjGroups, tr( "OBJECT_GROUPS" ), false );
+#endif
+  }
+
   ObjectKind anObjectKind = aDataObj->GetKind();
 
   if ( anObjectKind == KIND_IMAGE )
@@ -588,22 +782,90 @@ void HYDROGUI_DataModel::buildObjectTree( SUIT_DataObject* theParent,
     LightApp_DataObject* aPolylineSect = 
       createObject( aGuiObj, tr( "ZONE_POLYLINE" ), aGuiObj->entry() );
 
-    Handle(HYDROData_Polyline) aPolyline = aZoneObj->GetPolyline();
+    Handle(HYDROData_PolylineXY) aPolyline = aZoneObj->GetPolyline();
     if ( !aPolyline.IsNull() && !aPolyline->IsRemoved() )
       createObject( aPolylineSect, aPolyline, aGuiObj->entry(), false );
 
     LightApp_DataObject* aBathSect = 
       createObject( aGuiObj, tr( "ZONE_BATHYMETRY" ), aGuiObj->entry() );
 
-    Handle(HYDROData_Bathymetry) aBathymetry = aZoneObj->GetBathymetry();
-    if ( !aBathymetry.IsNull() && !aBathymetry->IsRemoved() )
-      createObject( aBathSect, aBathymetry, aGuiObj->entry(), false );
+    Handle(HYDROData_IAltitudeObject) anAltitudeObj = aZoneObj->GetAltitudeObject();
+    if ( !anAltitudeObj.IsNull() && !anAltitudeObj->IsRemoved() )
+      createObject( aBathSect, anAltitudeObj, aGuiObj->entry(), false );
+  }
+  else if ( anObjectKind == KIND_POLYLINE )
+  {
+    Handle(HYDROData_Polyline3D) aPolyline3D =
+      Handle(HYDROData_Polyline3D)::DownCast( aDataObj );
+
+    LightApp_DataObject* aPolylineSect = 
+      createObject( aGuiObj, tr( "POLYLINE3D_POLYLINE" ), aGuiObj->entry() );
+
+    Handle(HYDROData_PolylineXY) aPolylineXY = aPolyline3D->GetPolylineXY();
+    if ( !aPolylineXY.IsNull() && !aPolylineXY->IsRemoved() )
+      createObject( aPolylineSect, aPolylineXY, aGuiObj->entry(), false );
+
+    LightApp_DataObject* aProfileSect = 
+      createObject( aGuiObj, tr( "POLYLINE3D_PROFILE" ), aGuiObj->entry() );
+
+    Handle(HYDROData_ProfileUZ) aProfileUZ = aPolyline3D->GetProfileUZ();
+    if ( aProfileUZ.IsNull() || aProfileUZ->IsRemoved() )
+      aProfileUZ = aPolyline3D->GetChildProfileUZ( false );
+
+    if ( !aProfileUZ.IsNull() && !aProfileUZ->IsRemoved() )
+    {
+      Handle(HYDROData_Profile) aProfile = 
+        Handle(HYDROData_Profile)::DownCast( aProfileUZ->GetFatherObject() );
+      if ( !aProfile.IsNull() && !aProfile->IsRemoved() )
+        createObject( aProfileSect, aProfile, aGuiObj->entry(), false );
+    }
+
+    LightApp_DataObject* aBathSect = 
+      createObject( aGuiObj, tr( "POLYLINE3D_BATHYMETRY" ), aGuiObj->entry() );
+
+    Handle(HYDROData_IAltitudeObject) anAltitudeObj = aPolyline3D->GetAltitudeObject();
+    if ( !anAltitudeObj.IsNull() && !anAltitudeObj->IsRemoved() )
+      createObject( aBathSect, anAltitudeObj, aGuiObj->entry(), false );
   }
   else if ( anObjectKind == KIND_CALCULATION )
   {
     Handle(HYDROData_CalculationCase) aCaseObj =
       Handle(HYDROData_CalculationCase)::DownCast( aDataObj );
 
+    LightApp_DataObject* aPolylineSect = 
+      createObject( aGuiObj, tr( "CASE_BOUNDARY" ), aGuiObj->entry() );
+
+    Handle(HYDROData_PolylineXY) aPolyline = aCaseObj->GetBoundaryPolyline();
+    if ( !aPolyline.IsNull() && !aPolyline->IsRemoved() )
+      createObject( aPolylineSect, aPolyline, aGuiObj->entry(), false );
+
+    LightApp_DataObject* aCaseAOSect = 
+      createObject( aGuiObj, tr( partitionName( KIND_ARTIFICIAL_OBJECT ).toAscii() ),
+                    aGuiObj->entry() );
+    LightApp_DataObject* aCaseNOSect = 
+      createObject( aGuiObj, tr( partitionName( KIND_NATURAL_OBJECT ).toAscii() ),
+                    aGuiObj->entry() );
+
+    HYDROData_SequenceOfObjects aSeq = aCaseObj->GetGeometryObjects();
+    HYDROData_SequenceOfObjects::Iterator aGOIter( aSeq );
+    Handle(HYDROData_Entity) anEntity;
+    Handle(HYDROData_ArtificialObject) anAObject;
+    Handle(HYDROData_NaturalObject) aNObject;
+    for ( ; aGOIter.More(); aGOIter.Next() )
+    {
+      anEntity = aGOIter.Value();
+      if ( anEntity.IsNull() )
+        continue;
+      anAObject = Handle(HYDROData_ArtificialObject)::DownCast( anEntity );
+      if ( !anAObject.IsNull() )
+        createObject( aCaseAOSect, anAObject, aGuiObj->entry(), false );
+      else
+      {
+        aNObject = Handle(HYDROData_NaturalObject)::DownCast( anEntity );
+        if ( !aNObject.IsNull() )
+          createObject( aCaseNOSect, aNObject, aGuiObj->entry(), false );
+      }
+    }
     LightApp_DataObject* aCaseRegionsSect = 
       createObject( aGuiObj, tr( "CASE_REGIONS" ), aGuiObj->entry() );
 
@@ -614,8 +876,17 @@ void HYDROGUI_DataModel::buildObjectTree( SUIT_DataObject* theParent,
       Handle(HYDROData_Region) aCaseRegion =
         Handle(HYDROData_Region)::DownCast( anIter.Value() );
       if( !aCaseRegion.IsNull() && !aCaseRegion->IsRemoved() )
-        createObject( aCaseRegionsSect, aCaseRegion, "", true );
+        createRegion( aCaseRegionsSect, aCaseRegion, "", true, theIsInOperation );
     }
+
+#ifdef DEB_GROUPS
+    HYDROData_SequenceOfObjects aCalcGroups = aCaseObj->GetSplittedGroups();
+    buildObjectPartition( aGuiObj, aCalcGroups, tr( "OBJECT_GROUPS" ), false );
+
+    HYDROData_SequenceOfObjects aCalcSplitGroups = aCaseObj->GetSplittedGroups();
+    buildObjectPartition( aGuiObj, aCalcSplitGroups, tr( "CASE_SPLITTED_GROUPS" ), false );
+#endif
+
   }
   else if ( anObjectKind == KIND_REGION )
   {
@@ -629,7 +900,112 @@ void HYDROGUI_DataModel::buildObjectTree( SUIT_DataObject* theParent,
       Handle(HYDROData_Zone) aRegionZone =
         Handle(HYDROData_Zone)::DownCast( anIter.Value() );
       if( !aRegionZone.IsNull() && !aRegionZone->IsRemoved() )
-        createObject( aGuiObj, aRegionZone, "", true );
+        createZone( aGuiObj, aRegionZone, "", true, theIsInOperation );
+    }
+  }
+  else if ( anObjectKind == KIND_PROFILE )
+  {
+    Handle(HYDROData_Profile) aProfileObj =
+      Handle(HYDROData_Profile)::DownCast( aDataObj );
+
+    aGuiObj->setIsValid( aProfileObj->IsValid() );
+  }
+  else if ( anObjectKind == KIND_CHANNEL || anObjectKind == KIND_DIGUE )
+  {
+    Handle(HYDROData_Channel) aChannelObj =
+      Handle(HYDROData_Channel)::DownCast( aDataObj );
+
+    LightApp_DataObject* aGuideLineSect = 
+      createObject( aGuiObj, tr( "CHANNEL_GUIDE_LINE" ), aGuiObj->entry() );
+    Handle(HYDROData_Polyline3D) aGuideLine = aChannelObj->GetGuideLine();
+    if ( !aGuideLine.IsNull() && !aGuideLine->IsRemoved() ) {
+      createObject( aGuideLineSect, aGuideLine, aGuiObj->entry(), false );
+    }
+
+    LightApp_DataObject* aProfileSect = 
+      createObject( aGuiObj, tr( "CHANNEL_PROFILE" ), aGuiObj->entry() );
+    Handle(HYDROData_Profile) aProfile = aChannelObj->GetProfile();
+    if ( !aProfile.IsNull() && !aProfile->IsRemoved() ) {
+      createObject( aProfileSect, aProfile, aGuiObj->entry(), false );
+    }
+  }
+  else if ( anObjectKind == KIND_STREAM )
+  {
+    Handle(HYDROData_Stream) aStreamObj =
+      Handle(HYDROData_Stream)::DownCast( aDataObj );
+
+    LightApp_DataObject* aHydraulicAxisSect = 
+      createObject( aGuiObj, tr( "STREAM_HYDRAULIC_AXIS" ), aGuiObj->entry() );
+    Handle(HYDROData_PolylineXY) aHydraulicAxis = aStreamObj->GetHydraulicAxis();
+    if ( !aHydraulicAxis.IsNull() && !aHydraulicAxis->IsRemoved() ) {
+      createObject( aHydraulicAxisSect, aHydraulicAxis, aGuiObj->entry(), false );
+    }
+
+    HYDROData_SequenceOfObjects aProfiles = aStreamObj->GetProfiles();
+    buildObjectPartition( aGuiObj, aProfiles, tr( "STREAM_PROFILES" ), true );
+  }
+}
+
+void HYDROGUI_DataModel::buildCaseTree( SUIT_DataObject* theParent, Handle(HYDROData_CalculationCase) theCase )
+{
+  if ( !theCase.IsNull() )
+  {
+    if ( theParent )
+    {
+      // Remove previous objects tree
+        DataObjectList aList;
+        theParent->children( aList );
+        QListIterator<SUIT_DataObject*> anIter( aList );
+        while( anIter.hasNext() )
+          removeChild( theParent, anIter.next() );
+    }
+
+    new HYDROGUI_DropTargetObject( theParent, tr( "NEW_REGION" ), "", true );
+
+    HYDROData_SequenceOfObjects aCaseRegions = theCase->GetRegions();
+    HYDROData_SequenceOfObjects::Iterator anIter( aCaseRegions );
+    for ( ; anIter.More(); anIter.Next() )
+    {
+      Handle(HYDROData_Region) aCaseRegion =
+        Handle(HYDROData_Region)::DownCast( anIter.Value() );
+      if( !aCaseRegion.IsNull() && !aCaseRegion->IsRemoved() )
+        createRegion( theParent, aCaseRegion, "", true, true );
+    }
+  }
+}
+
+void HYDROGUI_DataModel::updateObjectTree( Handle(HYDROData_Entity)& theObj )
+{
+  if ( !theObj.IsNull() )
+  {
+    HYDROGUI_DataObject* aGuiObj = dynamic_cast<HYDROGUI_DataObject*>(
+      findObject( HYDROGUI_DataObject::dataObjectEntry( theObj ) ) );
+    if ( aGuiObj )
+    {
+      // Remove previous objects tree
+      DataObjectList aList;
+      aGuiObj->children( aList );
+      QListIterator<SUIT_DataObject*> anIter( aList );
+      while( anIter.hasNext() )
+        removeChild( aGuiObj, anIter.next() );
+
+      // Rebuild the subtree
+      QString aParentEntry;
+      HYDROGUI_DataObject* aParent = dynamic_cast<HYDROGUI_DataObject*>( aGuiObj->parent() );
+      if ( aParent )
+      {
+        aParentEntry = aParent->entry();
+      }
+      buildObjectTree( aParent, aGuiObj, aParentEntry, aGuiObj->isInOperation() );
+    } 
+    else
+    {
+      // workaround for the bug in SalomeApp_Study::findObjectByEntry - it can't find LightApp_DataObjects
+      HYDROGUI_Module* aModule = dynamic_cast<HYDROGUI_Module*>( module() );
+      if( aModule )
+      {
+        aModule->getApp()->updateObjectBrowser();
+      }
     }
   }
 }
@@ -655,3 +1031,55 @@ SUIT_DataObject* HYDROGUI_DataModel::findChildByName( const SUIT_DataObject* the
   }
   return NULL; // not found
 }
+
+bool HYDROGUI_DataModel::createNewRegion( Handle(HYDROData_CalculationCase) theCase, 
+                                         const QList<HYDROGUI_Zone*>& theZonesList )
+{
+  bool isOk = !theCase.IsNull();
+  if ( isOk )
+  {
+    Handle(HYDROData_Region) aRegion;
+    Handle(HYDROData_Zone) aZone;
+    for (int i = 0; i < theZonesList.length(); i++ )
+    {
+      aZone = Handle(HYDROData_Zone)::DownCast( theZonesList.at(i)->modelObject() );
+      if ( !aZone.IsNull() )
+      {
+        if ( aRegion.IsNull() )
+        {
+          aRegion = theCase->AddNewRegion( aZone );
+          isOk = !aRegion.IsNull();
+        }
+        else
+        {
+          if ( !( aRegion->AddZone( aZone ) ) )
+          {
+            isOk = false;
+          }
+        }
+      }
+    }
+  }
+  return isOk;
+}
+
+bool HYDROGUI_DataModel::rename( Handle(HYDROData_Entity) theEntity, const QString& theName )
+{
+  if ( theName.isEmpty() )
+    return false;
+
+  try 
+  {
+    getDocument()->StartOperation();
+    theEntity->SetName( theName );
+    getDocument()->CommitOperation( HYDROGUI_Tool::ToExtString( tr("RENAME_TO").arg( theName ) ) );
+    module()->application()->activeStudy()->Modified();
+  }
+  catch ( Standard_Failure )
+  {
+    getDocument()->AbortOperation();
+    return false;
+  }
+  return true;
+}
+