]> SALOME platform Git repositories - modules/hydro.git/blob - src/HYDROGUI/HYDROGUI_DataModel.cxx
Salome HOME
Merge branch 'BR_H2018_2' of https://codev-tuleap.cea.fr/plugins/git/salome/hydro...
[modules/hydro.git] / src / HYDROGUI / HYDROGUI_DataModel.cxx
1 // Copyright (C) 2014-2015  EDF-R&D
2 // This library is free software; you can redistribute it and/or
3 // modify it under the terms of the GNU Lesser General Public
4 // License as published by the Free Software Foundation; either
5 // version 2.1 of the License, or (at your option) any later version.
6 //
7 // This library is distributed in the hope that it will be useful,
8 // but WITHOUT ANY WARRANTY; without even the implied warranty of
9 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
10 // Lesser General Public License for more details.
11 //
12 // You should have received a copy of the GNU Lesser General Public
13 // License along with this library; if not, write to the Free Software
14 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
15 //
16 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
17 //
18
19 #include "HYDROGUI_DataModel.h"
20
21 #include "HYDROGUI_DataObject.h"
22 #include "HYDROGUI_Module.h"
23 #include "HYDROGUI_Tool.h"
24 #include "HYDROGUI_Tool2.h"
25 #include "HYDROGUI_Zone.h"
26 #include "HYDROGUI_Region.h"
27
28 #include <HYDROData_Bathymetry.h>
29 #include <HYDROData_CalculationCase.h>
30 #include <HYDROGUI_DataModelSync.h>
31 #include <HYDROData_Document.h>
32 #include <HYDROData_DummyObject3D.h>
33 #include <HYDROData_Image.h>
34 #include <HYDROData_ImmersibleZone.h>
35 #include <HYDROData_Iterator.h>
36 #include <HYDROData_Polyline3D.h>
37 #include <HYDROData_PolylineXY.h>
38 #include <HYDROData_Profile.h>
39 #include <HYDROData_VisualState.h>
40 #include <HYDROData_Region.h>
41 #include <HYDROData_Zone.h>
42 #include <HYDROData_Obstacle.h>
43 #include <HYDROData_Channel.h>
44 #include <HYDROData_Digue.h>
45 #include <HYDROData_River.h>
46 #include <HYDROData_Stream.h>
47 #include <HYDROData_StricklerTable.h>
48 #include <HYDROData_LandCoverMap.h>
49 #include <HYDROData_BCPolygon.h>
50
51 #include <CAM_Module.h>
52 #include <CAM_Study.h>
53
54 #include <LightApp_Application.h>
55 #include <LightApp_DataObject.h>
56 #include <LightApp_Study.h>
57
58 #include <SUIT_DataBrowser.h>
59 #include <SUIT_ResourceMgr.h>
60 #include <SUIT_Study.h>
61 #include <SUIT_Tools.h>
62 #include <SUIT_TreeSync.h>
63 #include <SUIT_DataObjectIterator.h>
64
65 #include <HYDROData_Document.h>
66
67 #include <TDF_Delta.hxx>
68 #include <TDF_ListIteratorOfDeltaList.hxx>
69
70 #include <QApplication>
71 #include <QDir>
72
73 // #define DEB_GROUPS 1
74 #ifdef DEB_GROUPS
75 #include <HYDROData_ShapesGroup.h>
76 #endif
77
78 static HYDROData_SequenceOfObjects myCopyingObjects;
79
80 const int ENTRY_COLUMN = 2;
81
82
83 HYDROGUI_DataModel::HYDROGUI_DataModel( CAM_Module* theModule )
84 : LightApp_DataModel( theModule )
85 {
86   update( module()->application()->activeStudy()->id() );
87 }
88
89 HYDROGUI_DataModel::~HYDROGUI_DataModel()
90 {
91 }
92
93 bool HYDROGUI_DataModel::create( CAM_Study* theStudy )
94 {
95     bool status = LightApp_DataModel::create( theStudy );
96     if ( status )
97         updateDocument();
98     return status;
99 }
100
101 bool HYDROGUI_DataModel::open( const QString& theURL,
102                                CAM_Study* theStudy,
103                                QStringList theFileList )
104 {
105   LightApp_DataModel::open( theURL, theStudy, theFileList );
106   const int aStudyId = theStudy->id();
107
108   Data_DocError res = DocError_UnknownProblem;
109   if( theFileList.count() >= 2 )
110   {
111     QString aTmpDir = theFileList[0];
112     QString aDataFileName = theFileList[1];
113     QString aStatesFileName = theFileList.count() == 3 ? theFileList[2] : "";
114
115     myStudyURL = theURL;
116     QString aDataFullPath = SUIT_Tools::addSlash( aTmpDir ) + aDataFileName;
117     QString aStatesFullPath = aStatesFileName.isEmpty() ? "" : SUIT_Tools::addSlash( aTmpDir ) + aStatesFileName;
118
119     try
120     {
121       res = HYDROData_Document::Load( (char*)aDataFullPath.toLatin1().constData(), aStudyId );
122     }
123     catch(...)
124     {
125       res = DocError_UnknownProblem;
126     }
127     
128     if ( res != DocError_OK )
129     {
130       module()->application()->putInfo( tr( "LOAD_ERROR" ) );
131       return false;
132     }
133
134     if ( !aStatesFullPath.isEmpty() )
135     {
136       QFile aFile( aStatesFullPath );
137       if( aFile.open( QFile::ReadOnly ) )
138       {
139         myStates = aFile.readAll();
140         aFile.close();
141       }
142     }
143
144     updateDocument();
145   }
146
147   // if the document open was successful, the data model update happens
148   // in the set mode of the module
149   if ( res == DocError_OK )
150     update( aStudyId );
151
152   return true;
153 }
154
155 bool HYDROGUI_DataModel::save( QStringList& theFileList )
156 {
157   if( !module()->application()->activeStudy() )
158     return false;
159   
160   LightApp_DataModel::save( theFileList );
161
162   QString aTmpDir;
163   SUIT_ResourceMgr* resMgr = module()->application()->resourceMgr();
164   bool isMultiFile = false;
165   if ( resMgr )
166     isMultiFile = resMgr->booleanValue( "Study", "multi_file", false );
167
168   // save module data to temporary files
169   LightApp_Study* aStudy = dynamic_cast<LightApp_Study*>( module()->application()->activeStudy() );
170   aTmpDir = aStudy->GetTmpDir( myStudyURL.toLatin1().constData(), isMultiFile ).c_str();
171   
172   // save OCAF data to a temporary file
173   QString aDataFileName = SUIT_Tools::file( myStudyURL, false ) + "_HYDRO.cbf";
174   QString aDataFullPath = aTmpDir + aDataFileName;
175   Data_DocError res = getDocument()->Save( (char*)aDataFullPath.toLatin1().constData() );
176   if( res != DocError_OK )
177   {
178     module()->application()->putInfo( tr( "SAVE_ERROR" ) );
179     return false;
180   }
181
182   // save tree state data to a temporary file
183   LightApp_Application* anApp = dynamic_cast<LightApp_Application*>( module()->application() );
184   QByteArray aStatesData = anApp->objectBrowser()->getOpenStates( ENTRY_COLUMN );
185   QString aStatesFileName = SUIT_Tools::file( myStudyURL, false ) + "_HYDRO_tree_states.txt";
186   QString aStatesFullPath = aTmpDir + aStatesFileName;
187   QFile aFile( aStatesFullPath );
188   if( aFile.open( QFile::WriteOnly ) )
189   {
190     aFile.write( aStatesData );
191     aFile.close();
192   }
193
194   // add temporary files to the list
195   theFileList.append( aTmpDir );
196   theFileList.append( aDataFileName );
197   theFileList.append( aStatesFileName );
198
199   return true;
200 }
201
202 bool HYDROGUI_DataModel::saveAs( const QString& theURL,
203                                  CAM_Study*,
204                                  QStringList& theFileList )
205 {
206   myStudyURL = theURL;
207   return save( theFileList );
208 }
209
210 bool HYDROGUI_DataModel::close()
211 {
212   HYDROGUI_Module* aModule = dynamic_cast<HYDROGUI_Module*>( module() );
213   if ( aModule )
214       aModule->clearCache();
215   return true;
216 }
217
218 bool HYDROGUI_DataModel::dumpPython( const QString& theURL,
219                                      CAM_Study*     theStudy,
220                                      bool           isMultiFile,
221                                      QStringList&   theListOfFiles )
222 {
223   LightApp_DataModel::dumpPython( theURL, theStudy, isMultiFile, theListOfFiles );
224
225   int aStudyId = theStudy->id();
226
227   LightApp_Study* aStudy = ::qobject_cast<LightApp_Study*>( theStudy );
228   Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( aStudyId );
229   if ( aDocument.IsNull() || !aStudy )
230     return false;
231
232   QString aDir = aStudy->GetTmpDir( theURL.toLatin1().constData(), isMultiFile ).c_str();
233   QString aFileToExport = aDir + QString( QDir::separator() ) + "HYDRO.py";
234
235   bool aRes = aDocument->DumpToPython( aFileToExport, isMultiFile );
236   if ( aRes )
237   {
238     theListOfFiles.append( aDir );
239     theListOfFiles.append( aFileToExport );
240   }
241
242   return aRes;
243 }
244
245 bool HYDROGUI_DataModel::isModified() const
246 {
247   return getDocument()->IsModified();
248 }
249
250 bool HYDROGUI_DataModel::isSaved() const
251 {
252   return true;
253 }
254
255 void HYDROGUI_DataModel::update( const int theStudyId )
256 {
257   LightApp_Application* anApp = dynamic_cast<LightApp_Application*>( module()->application() );
258   if( !anApp )
259     return;
260
261   SUIT_DataObject* aStudyRoot = anApp->activeStudy()->root();
262   if( !aStudyRoot )
263     return;
264
265   // create a new root object
266   CAM_DataObject* aNewRootObj = new CAM_DataObject();
267
268   Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( theStudyId );
269   if( aDocument.IsNull() )
270     return;
271
272   // Create root objects:
273
274   // IMAGES
275   LightApp_DataObject* anImageRootObj = createObject( aNewRootObj, tr( partitionName( KIND_IMAGE ).toLatin1() ) );
276
277   // BATHYMETRY
278   LightApp_DataObject* aBathymetryRootObj = createObject( aNewRootObj, tr( partitionName( KIND_BATHYMETRY ).toLatin1() ) );
279
280   // POLYLINES
281   LightApp_DataObject* aPolylineRootObj = createObject( aNewRootObj, tr( partitionName( KIND_POLYLINEXY ).toLatin1() ) );
282
283   // PROFILES
284   LightApp_DataObject* aProfileRootObj = createObject( aNewRootObj, tr( partitionName( KIND_PROFILE ).toLatin1() ) );
285
286   // POLYLINES 3D
287   LightApp_DataObject* aPolyline3DRootObj = createObject( aNewRootObj, tr( partitionName( KIND_POLYLINE ).toLatin1() ) );
288
289   // NATURAL OBJECTS
290   LightApp_DataObject* aNaturalObjectsRootObj = createObject( aNewRootObj, tr( partitionName( KIND_NATURAL_OBJECT ).toLatin1() ) );
291
292   // ARTIFICIAL OBJECTS
293   LightApp_DataObject* anArtificialObjectsRootObj = createObject( aNewRootObj, tr( partitionName( KIND_ARTIFICIAL_OBJECT ).toLatin1() ) );
294
295   // OBSTACLES
296   LightApp_DataObject* anObstaclesRootObj = createObject( aNewRootObj, tr( partitionName( KIND_OBSTACLE ).toLatin1() ) );
297
298   //BC Polygons
299   LightApp_DataObject* aBCPolygonRootObj = createObject( aNewRootObj, tr( partitionName( KIND_BC_POLYGON ).toLatin1() ) );
300
301   // STRICKLER TABLES
302   LightApp_DataObject* aStricklerTablesRootObj = createObject( aNewRootObj, tr( partitionName( KIND_STRICKLER_TABLE ).toLatin1() ) );
303
304   // LAND COVER MAPS
305   LightApp_DataObject* aLandCoversRootObj = createObject( aNewRootObj, tr( partitionName( KIND_LAND_COVER_MAP ).toLatin1() ) );
306
307   // CALCULATION CASES
308   LightApp_DataObject* aCalculRootObj = createObject( aNewRootObj, tr( partitionName( KIND_CALCULATION ).toLatin1() ) );
309
310   // VISUAL STATES
311   LightApp_DataObject* aVisualStateRootObj = createObject( aNewRootObj, tr( partitionName( KIND_VISUAL_STATE ).toLatin1() ) );
312
313
314   int aNoStricklerTableObj = 0;
315
316   HYDROData_Iterator anIterator( aDocument, KIND_UNKNOWN );
317   std::vector<Handle(HYDROData_Entity)> ents;
318
319   for( ; anIterator.More(); anIterator.Next() )
320     ents.push_back(anIterator.Current());
321
322   for (int i = 0; i< ents.size();i++)
323   {
324     LightApp_DataObject* obj = 0;
325     Handle(HYDROData_Entity) anObj = ents[i];
326
327     if ( !anObj.IsNull() )
328     {
329       switch ( anObj->GetKind() ) {
330         case KIND_IMAGE:
331         {
332           Handle(HYDROData_Image) anImageObj =
333             Handle(HYDROData_Image)::DownCast( anObj );
334           if( !anImageObj.IsNull() ) {
335             obj = createObject( anImageRootObj, anImageObj );
336           }
337
338           break;
339         }
340         case KIND_BATHYMETRY:
341         {
342           Handle(HYDROData_Bathymetry) aBathymetryObj =
343             Handle(HYDROData_Bathymetry)::DownCast( anObj );
344           if( !aBathymetryObj.IsNull() ) {
345             obj = createObject( aBathymetryRootObj, aBathymetryObj );
346           }
347
348           break;
349         }
350         case KIND_CHANNEL:
351         {
352           Handle(HYDROData_Channel) aChannelObj =
353             Handle(HYDROData_Channel)::DownCast( anObj );
354           if( !aChannelObj.IsNull() ) {
355             obj = createObject( anArtificialObjectsRootObj, aChannelObj );
356           }
357
358           break;
359         }
360         case KIND_DIGUE:
361         {
362           Handle(HYDROData_Digue) aDigueObj =
363             Handle(HYDROData_Digue)::DownCast( anObj );
364           if( !aDigueObj.IsNull() ) {
365             obj = createObject( anArtificialObjectsRootObj, aDigueObj );
366           }
367
368           break;
369         }
370         case KIND_IMMERSIBLE_ZONE:
371         {
372           Handle(HYDROData_ImmersibleZone) anImmersibleZoneObj =
373             Handle(HYDROData_ImmersibleZone)::DownCast( anObj );
374           if( !anImmersibleZoneObj.IsNull() ) {
375             obj = createObject( aNaturalObjectsRootObj, anImmersibleZoneObj );
376           }
377
378           break;
379         }
380         case KIND_RIVER:
381         {
382           Handle(HYDROData_River) aRiverObj =
383             Handle(HYDROData_River)::DownCast( anObj );
384           if( !aRiverObj.IsNull() ) {
385             obj = createObject( aNaturalObjectsRootObj, aRiverObj );
386           }
387
388           break;
389         }
390         case KIND_STREAM:
391         {
392           Handle(HYDROData_Stream) aStreamObj =
393             Handle(HYDROData_Stream)::DownCast( anObj );
394           if( !aStreamObj.IsNull() ) {
395             obj = createObject( aNaturalObjectsRootObj, aStreamObj );
396           }
397
398           break;
399         }
400         case KIND_OBSTACLE:
401         {
402           Handle(HYDROData_Obstacle) anObstacleObj =
403             Handle(HYDROData_Obstacle)::DownCast( anObj );
404           if( !anObstacleObj.IsNull() ) {
405             obj = createObject( anObstaclesRootObj, anObstacleObj );
406           }
407
408           break;
409         }
410                 case KIND_STRICKLER_TABLE:
411         {
412           Handle(HYDROData_StricklerTable) aStricklerTableObj =
413             Handle(HYDROData_StricklerTable)::DownCast( anObj );
414           if( !aStricklerTableObj.IsNull() ) {
415             obj = createObject( aStricklerTablesRootObj, aStricklerTableObj );
416           }
417                   aNoStricklerTableObj++;
418
419           break;
420         }
421         case KIND_LAND_COVER_MAP:
422         {
423           Handle(HYDROData_LandCoverMap) aLandCoverMapObj =
424             Handle(HYDROData_LandCoverMap)::DownCast( anObj );
425           if( !aLandCoverMapObj.IsNull() ) {
426             obj = createObject( aLandCoversRootObj, aLandCoverMapObj );
427           }
428
429           break;
430         }
431         case KIND_CALCULATION:
432         {
433           Handle(HYDROData_CalculationCase) aCalculObj =
434             Handle(HYDROData_CalculationCase)::DownCast( anObj );
435           if( !aCalculObj.IsNull() ) {
436             obj = createObject( aCalculRootObj, aCalculObj );
437           }
438
439           break;
440         }
441         case KIND_POLYLINEXY:
442         {
443           Handle(HYDROData_PolylineXY) aPolylineObj =
444             Handle(HYDROData_PolylineXY)::DownCast( anObj );
445           if( !aPolylineObj.IsNull() ) {
446             obj = createObject( aPolylineRootObj, aPolylineObj );
447           }
448
449           break;
450         }
451         case KIND_POLYLINE:
452         {
453           Handle(HYDROData_Polyline3D) aPolylineObj =
454             Handle(HYDROData_Polyline3D)::DownCast( anObj );
455           if( !aPolylineObj.IsNull() ) {
456             obj = createObject( aPolyline3DRootObj, aPolylineObj );
457           }
458
459           break;
460         }
461         case KIND_PROFILE:
462         {
463           Handle(HYDROData_Profile) aProfileObj =
464             Handle(HYDROData_Profile)::DownCast( anObj );
465           if( !aProfileObj.IsNull() ) {
466             obj = createObject( aProfileRootObj, aProfileObj );
467           }
468
469           break;
470         }
471         case KIND_VISUAL_STATE:
472         {
473           Handle(HYDROData_VisualState) aVisualStateObj =
474             Handle(HYDROData_VisualState)::DownCast( anObj );
475           if( !aVisualStateObj.IsNull() ) {
476             obj = createObject( aVisualStateRootObj, aVisualStateObj );
477           }
478
479           break;
480         }
481         case KIND_BC_POLYGON:
482         {
483           Handle(HYDROData_BCPolygon) aBCPolygonObj =
484             Handle(HYDROData_BCPolygon)::DownCast( anObj );
485           if( !aBCPolygonObj.IsNull() ) {
486             obj = createObject( aBCPolygonRootObj, aBCPolygonObj );
487           }
488
489           break;
490         }
491       }
492     }
493   }
494
495   // Create default Strickler table object
496   if ( aNoStricklerTableObj == 0 )
497     createDefaultStricklerTable( aDocument, aStricklerTablesRootObj );
498
499   //if( SUIT_DataBrowser* anObjectBrowser = anApp->objectBrowser() )
500   //{
501   //  anObjectBrowser->setAutoOpenLevel( 3 );
502   //  anObjectBrowser->openLevels();
503   //}
504
505   SUIT_DataObject* aRoot = root();
506
507   if (aRoot)
508   {
509     std::map<std::string, SUIT_DataObject*> entry2ObjNewRoot;
510     SUIT_DataObjectIterator::DetourType dt = SUIT_DataObjectIterator::DepthLeft;
511     for ( SUIT_DataObjectIterator it( aNewRootObj, dt ); it.current(); ++it )
512     {
513       LightApp_DataObject* aCurObjN = dynamic_cast<LightApp_DataObject*>(it.current());
514       if (aCurObjN)
515         entry2ObjNewRoot[aCurObjN->entry().toStdString()] = it.current();
516     }
517
518     for ( SUIT_DataObjectIterator it( aRoot, dt ); it.current(); ++it )
519     {
520       LightApp_DataObject* aCurObjO = dynamic_cast<LightApp_DataObject*>(it.current());
521       if (aCurObjO && aCurObjO->childCount() > 0)
522       {
523         std::string entry = aCurObjO->entry().toStdString();
524         SUIT_DataObject* newNode = entry2ObjNewRoot[entry];
525         if (newNode && aCurObjO->childCount() > 0)
526         {
527           DataObjectList newchildren;
528           newNode->children(newchildren);
529           //new root - remove children 
530           std::map<std::string, SUIT_DataObject*> newNode2Entries;
531           for ( DataObjectList::const_iterator it = newchildren.begin(); it != newchildren.end(); ++it )
532           {
533             SUIT_DataObject* cc = *it;
534             LightApp_DataObject* obj = dynamic_cast<LightApp_DataObject*>(cc);
535             newNode2Entries[obj->entry().toStdString()] = cc;
536             newNode->removeChild(cc);
537           }
538           //
539           std::set<SUIT_DataObject*> objtemp;
540
541           DataObjectList oldchildren;
542           aCurObjO->children(oldchildren);  
543           for ( DataObjectList::const_iterator it = oldchildren.begin(); it != oldchildren.end(); ++it )
544           {
545             SUIT_DataObject* old_ch = *it;
546             std::string entr = dynamic_cast<LightApp_DataObject*>(old_ch)->entry().toStdString();
547             if (newNode2Entries.count(entr) > 0)
548             {
549               SUIT_DataObject* obj = newNode2Entries[entr]; 
550               newNode->appendChild(obj);
551               objtemp.insert(obj);
552             }
553           }
554           //
555           for ( DataObjectList::const_iterator it = newchildren.begin(); it != newchildren.end(); ++it )
556           {
557             SUIT_DataObject* ch = *it;
558             if (objtemp.count(ch) == 0)
559               newNode->appendChild(ch);
560           }
561           { //IF DEBUG
562             //add. check
563             DataObjectList newchildren2;
564             newNode->children(newchildren2);
565             std::set<std::string> entries2, entries1;
566             for ( DataObjectList::const_iterator it = newchildren2.begin(); it != newchildren2.end(); ++it )
567               entries2.insert((dynamic_cast<LightApp_DataObject*>(*it))->entry().toStdString());
568             for ( DataObjectList::const_iterator it = newchildren.begin(); it != newchildren.end(); ++it )
569               entries1.insert((dynamic_cast<LightApp_DataObject*>(*it))->entry().toStdString());
570             assert(entries1 == entries2);
571           }
572         }
573       }
574     }
575   }
576
577   HYDROGUI_DataModelSync aSync( aNewRootObj );
578   bool isNewDoc = aRoot==0;
579   if( isNewDoc )
580     aRoot = createRootModuleObject( aStudyRoot );
581   ::synchronize < suitPtr, suitPtr, HYDROGUI_DataModelSync >
582     ( aNewRootObj, aRoot, aSync );
583
584   SUIT_DataBrowser* ob = anApp->objectBrowser();
585
586   if ( !myStates.isEmpty() )
587   {
588     ob->updateTree();
589     ob->setAutoOpenLevel( 1 );
590     //ob->setOpenStates( myStates, ENTRY_COLUMN );
591     myStates.clear();
592   }
593 }
594
595 HYDROGUI_DataObject* HYDROGUI_DataModel::getDataObject( const Handle(HYDROData_Entity)& theModelObject )
596 {
597   HYDROGUI_DataObject* aGuiObj = dynamic_cast<HYDROGUI_DataObject*>(
598     findObject( HYDROGUI_DataObject::dataObjectEntry( theModelObject ) ) );
599   return aGuiObj;
600 }
601
602 HYDROGUI_DataObject* HYDROGUI_DataModel::getReferencedDataObject( HYDROGUI_DataObject* theObject )
603 {
604   return NULL; // to do if necessary
605 }
606
607 SUIT_DataObject* HYDROGUI_DataModel::findObject( const QString& theEntry ) const
608 {
609   LightApp_Application* anApp = dynamic_cast<LightApp_Application*>( module()->application() );
610   return anApp ? anApp->findObject( theEntry ) : 0;
611 }
612
613 void HYDROGUI_DataModel::update( LightApp_DataObject* theObject,
614                                  LightApp_Study* theStudy )
615 {
616   if( !theStudy )
617     theStudy = dynamic_cast<LightApp_Study*>( module()->application()->activeStudy()) ;
618   if( theStudy )
619     update( theStudy->id() );
620 }
621
622 CAM_DataObject* HYDROGUI_DataModel::createRootModuleObject( SUIT_DataObject* theParent )
623 {
624   CAM_ModuleObject* aRootObj = createModuleObject( theParent );
625   aRootObj->setDataModel( this );
626   setRoot( aRootObj );
627   return aRootObj;
628 }
629
630 void HYDROGUI_DataModel::updateModel()
631 {
632   HYDROGUI_Module* aModule = dynamic_cast<HYDROGUI_Module*>( module() );
633   if( aModule )
634     update( aModule->getStudyId() );
635 }
636
637 Handle(HYDROData_Entity) HYDROGUI_DataModel::objectByEntry( const QString& theEntry,
638                                                             const ObjectKind theObjectKind )
639 {
640   QString anEntry = theEntry;
641   if( anEntry.indexOf( "_" ) != -1 ) // reference object
642     anEntry = anEntry.section( "_", -1 );
643
644   Handle(HYDROData_Document) aDocument = getDocument();
645   if( !aDocument.IsNull() )
646   {
647     HYDROData_Iterator anIterator( aDocument, theObjectKind );
648     for( ; anIterator.More(); anIterator.Next() )
649     {
650       Handle(HYDROData_Entity) anObject = anIterator.Current();
651       if( !anObject.IsNull() )
652       {
653         QString anEntryRef = HYDROGUI_DataObject::dataObjectEntry( anObject );
654         if( anEntryRef == anEntry )
655           return anObject;
656       }
657     }
658   }
659   return NULL;
660 }
661
662 bool HYDROGUI_DataModel::canUndo() const
663 {
664   return getDocument()->CanUndo();
665 }
666
667 bool HYDROGUI_DataModel::canRedo() const
668 {
669   return getDocument()->CanRedo();
670 }
671
672 QStringList HYDROGUI_DataModel::undoNames() const
673 {
674   QStringList aNames;
675   for( TDF_ListIteratorOfDeltaList anIter( getDocument()->GetUndos() ); anIter.More(); anIter.Next() )
676     aNames.prepend( HYDROGUI_Tool::ToQString( anIter.Value()->Name() ) );
677   return aNames;
678 }
679
680 QStringList HYDROGUI_DataModel::redoNames() const
681 {
682   QStringList aNames;
683   for( TDF_ListIteratorOfDeltaList anIter( getDocument()->GetRedos() ); anIter.More(); anIter.Next() )
684     aNames.append( HYDROGUI_Tool::ToQString( anIter.Value()->Name() ) );
685   return aNames;
686 }
687
688 void HYDROGUI_DataModel::clearUndos()
689 {
690   getDocument()->ClearUndos();
691 }
692
693 void HYDROGUI_DataModel::clearRedos()
694 {
695   getDocument()->ClearRedos();
696 }
697
698 bool HYDROGUI_DataModel::undo()
699 {
700   try 
701   {
702     getDocument()->Undo();
703   }
704   catch ( Standard_Failure )
705   {
706     return false;
707   }
708   return true;
709 }
710
711 bool HYDROGUI_DataModel::redo()
712 {
713   try 
714   {
715     getDocument()->Redo();
716   }
717   catch ( Standard_Failure )
718   {
719     return false;
720   }
721   return true;
722 }
723
724 bool HYDROGUI_DataModel::canCopy()
725 {
726   HYDROData_SequenceOfObjects aSeq = HYDROGUI_Tool::GetSelectedObjects( (HYDROGUI_Module*)module() );
727   bool isCanCopy = !aSeq.IsEmpty();
728
729   for ( Standard_Integer anIndex = 1, aLength = aSeq.Length(); anIndex <= aLength; anIndex++ ) {
730     Handle(HYDROData_Entity) anObject = aSeq.Value( anIndex );
731     if( !anObject.IsNull() ) {
732       ObjectKind aKind = anObject->GetKind();
733       bool isUnrecognized = aKind <= KIND_UNKNOWN || aKind > KIND_LAST;
734       bool isChildObject = aKind == KIND_DUMMY_3D || 
735                            aKind == KIND_ZONE ||
736                            aKind == KIND_SHAPES_GROUP || 
737                            aKind == KIND_SPLIT_GROUP;
738       if ( isUnrecognized || isChildObject ) {
739         isCanCopy = false;
740         break;
741       }
742     }
743   }
744   
745   return isCanCopy;
746 }
747
748 bool HYDROGUI_DataModel::canPaste()
749 {
750   for( int anIndex = 1, aLength = myCopyingObjects.Length(); anIndex <= aLength; anIndex++ )
751   {
752     Handle(HYDROData_Entity) anObject = myCopyingObjects.Value( anIndex );
753     if( !anObject.IsNull() && !anObject->IsRemoved() )
754       return true;
755   }
756   return false;
757 }
758
759 bool HYDROGUI_DataModel::copy()
760 {
761   HYDROData_SequenceOfObjects aSeq = HYDROGUI_Tool::GetSelectedObjects( (HYDROGUI_Module*)module() );
762   changeCopyingObjects( aSeq );
763   return true;
764 }
765
766 bool HYDROGUI_DataModel::paste()
767 {
768   bool anIsChanged = false;
769   for( int anIndex = 1, aLength = myCopyingObjects.Length(); anIndex <= aLength; anIndex++ )
770   {
771     Handle(HYDROData_Entity) anObject = myCopyingObjects.Value( anIndex );
772     if( !anObject.IsNull() && !anObject->IsRemoved() )
773     {
774       ObjectKind aKind = anObject->GetKind();
775       Handle(HYDROData_Entity) aClone = getDocument()->CreateObject( aKind );
776       if( !aClone.IsNull() )
777       {
778         anObject->CopyTo( aClone, true );
779         anIsChanged = true;
780
781         // remove Z layer
782         aClone->RemoveZLevel();
783       }
784     }
785   }
786   return anIsChanged;
787 }
788
789 void HYDROGUI_DataModel::changeCopyingObjects( const HYDROData_SequenceOfObjects& theSeq )
790 {
791   myCopyingObjects.Assign( theSeq );
792 }
793
794 QString HYDROGUI_DataModel::partitionName( const ObjectKind theObjectKind )
795 {
796   switch( theObjectKind )
797   {
798     case KIND_IMAGE:             return "IMAGES";
799     case KIND_POLYLINE:          return "POLYLINES_3D";
800     case KIND_POLYLINEXY:        return "POLYLINES";
801     case KIND_PROFILE:           return "PROFILES";
802     case KIND_VISUAL_STATE:      return "VISUAL_STATES";
803     case KIND_BATHYMETRY:        return "BATHYMETRIES";
804     case KIND_CALCULATION:       return "CALCULATION_CASES";
805     case KIND_OBSTACLE:          return "OBSTACLES";
806     case KIND_ARTIFICIAL_OBJECT: return "ARTIFICIAL_OBJECTS";
807     case KIND_NATURAL_OBJECT:    return "NATURAL_OBJECTS";
808     case KIND_STRICKLER_TABLE:   return "STRICKLER_TABLES";
809     case KIND_LAND_COVER_MAP:    return "LAND_COVER_MAPS";
810     case KIND_REGION:            return "REGIONS";
811     case KIND_BC_POLYGON:        return "BOUNDARY_POLYGONS";
812     default: break;
813   }
814   return QString();
815 }
816
817 Handle(HYDROData_Document) HYDROGUI_DataModel::getDocument() const
818 {
819   int aStudyId = module()->application()->activeStudy()->id();
820   return HYDROData_Document::Document( aStudyId );
821 }
822
823 LightApp_DataObject* HYDROGUI_DataModel::createObject( SUIT_DataObject*         theParent,
824                                                        Handle(HYDROData_Entity) theModelObject,
825                                                        const QString&           theParentEntry,
826                                                        const bool               theIsBuildTree )
827 {
828   HYDROGUI_DataObject* aResObj = new HYDROGUI_DataObject( theParent, theModelObject, theParentEntry );
829
830   const ObjectKind aKind = theModelObject->GetKind();
831   bool visibility = aKind == KIND_IMAGE || aKind == KIND_POLYLINEXY || aKind == KIND_POLYLINE ||
832                     aKind == KIND_SHAPES_GROUP || aKind == KIND_SPLIT_GROUP || aKind == KIND_ZONE ||
833                     aKind == KIND_IMMERSIBLE_ZONE || aKind == KIND_REGION || aKind == KIND_BATHYMETRY ||
834                     aKind == KIND_OBSTACLE || aKind == KIND_STREAM || aKind == KIND_CHANNEL ||
835                     aKind == KIND_DIGUE || aKind == KIND_DUMMY_3D || aKind == KIND_LAND_COVER_MAP ||
836                     aKind == KIND_BC_POLYGON;
837   if ( !visibility )
838   {
839     Handle(HYDROData_Profile) aProfObj = Handle(HYDROData_Profile)::DownCast( theModelObject );
840     visibility = !aProfObj.IsNull() && aProfObj->IsValid();
841   }
842
843   if ( aKind == KIND_REGION )
844   {
845       QString an = aResObj->name();
846       int a = 0;
847   }
848
849   if ( visibility )
850   {
851     setObjectVisibilityState( theModelObject, aResObj );
852   }
853
854   if ( theIsBuildTree )
855   {
856     buildObjectTree( theParent, aResObj, theParentEntry );
857   }
858
859   return aResObj;
860 }
861
862 LightApp_DataObject* HYDROGUI_DataModel::buildObject( SUIT_DataObject*     theParent,
863                                                       HYDROGUI_DataObject* theObject,
864                                                       const QString&       theParentEntry,
865                                                       const bool           theIsBuildTree,
866                                                       const bool           theIsInOperation )
867 {
868   if ( theIsBuildTree )
869   {
870     buildObjectTree( theParent, theObject, theParentEntry, theIsInOperation );
871   }
872   return theObject;
873 }
874
875 LightApp_DataObject* HYDROGUI_DataModel::createZone( SUIT_DataObject*       theParent,
876                                                      Handle(HYDROData_Zone) theModelObject,
877                                                      const QString&         theParentEntry,
878                                                      const bool             theIsBuildTree,
879                                                      const bool             theIsInOperation )
880 {
881   HYDROGUI_Zone* aZone = new HYDROGUI_Zone( theParent, theModelObject, theParentEntry, theIsInOperation );
882   LightApp_DataObject* aDataObj = buildObject( theParent, aZone, theParentEntry, theIsBuildTree, theIsInOperation );
883
884   setObjectVisibilityState( theModelObject, aZone );
885
886   return aDataObj;
887 }
888
889 LightApp_DataObject* HYDROGUI_DataModel::createRegion( SUIT_DataObject*         theParent,
890                                                        Handle(HYDROData_Region) theModelObject,
891                                                        const QString&           theParentEntry,
892                                                        const bool               theIsBuildTree,
893                                                        const bool               theIsInOperation )
894 {
895   return buildObject( theParent, new HYDROGUI_Region( theParent, theModelObject, theParentEntry, theIsInOperation ), 
896     theParentEntry, theIsBuildTree, theIsInOperation );
897 }
898
899 void HYDROGUI_DataModel::createDefaultStricklerTable( const Handle(HYDROData_Document)& theDocument,
900                                                       LightApp_DataObject*              theParent )
901 {
902   // Create default Strickler table object
903   Handle(HYDROData_StricklerTable) aStricklerTableObj =
904     Handle(HYDROData_StricklerTable)::DownCast( theDocument->CreateObject(KIND_STRICKLER_TABLE) );      
905   if ( !aStricklerTableObj.IsNull() )
906   {
907     SUIT_ResourceMgr* resMgr = module()->application()->resourceMgr();
908     QString defTablePath = resMgr->path( "resources", module()->name(), tr( "DEFAULT_STRICKLER_TABLE_FILE" ) );
909     aStricklerTableObj->Import( defTablePath );
910         // Set name
911     QString aStricklerTableName;
912     if ( aStricklerTableObj->GetName().isEmpty() )
913     {
914       HYDROGUI_Module* aModule = dynamic_cast<HYDROGUI_Module*>( module() );
915       if ( aModule )
916         aStricklerTableName = HYDROGUI_Tool::GenerateObjectName( aModule, tr( "DEFAULT_STRICKLER_TABLE_NAME" ) );
917     }
918     if ( aStricklerTableObj->GetName() != aStricklerTableName )
919       aStricklerTableObj->SetName( aStricklerTableName );
920
921     aStricklerTableObj->Update();
922
923     LightApp_DataObject* obj = createObject( theParent, aStricklerTableObj );
924   }
925 }
926
927 LightApp_DataObject* HYDROGUI_DataModel::createObject( SUIT_DataObject* theParent,
928                                                        const QString&   theName,
929                                                        const QString&   theParentEntry )
930 {
931   return new HYDROGUI_NamedObject( theParent, theName, theParentEntry );
932 }
933
934 void HYDROGUI_DataModel::buildObjectPartition( SUIT_DataObject*                   theObject,
935                                                const HYDROData_SequenceOfObjects& theObjects,
936                                                const QString&                     thePartName,
937                                                const bool                         theIsCreateEmpty )
938 {
939   if ( theObjects.IsEmpty() && !theIsCreateEmpty )
940     return;
941
942   HYDROGUI_DataObject* aGuiObj = dynamic_cast<HYDROGUI_DataObject*>( theObject );
943   if ( !aGuiObj )
944     return;
945
946   LightApp_DataObject* aPartSect = 
947     createObject( aGuiObj, thePartName, aGuiObj->entry() );
948
949   HYDROData_SequenceOfObjects::Iterator anIter( theObjects );
950   for ( ; anIter.More(); anIter.Next() )
951   {
952     Handle(HYDROData_Entity) anObj = anIter.Value();
953     if( !anObj.IsNull() && !anObj->IsRemoved() )
954       createObject( aPartSect, anObj, aGuiObj->entry(), false );
955   }
956 }
957
958 void HYDROGUI_DataModel::buildObjectTree( SUIT_DataObject* theParent,
959                                           SUIT_DataObject* theObject,
960                                           const QString&   theParentEntry,
961                                           const bool       theIsInOperation )
962 {
963   HYDROGUI_DataObject* aGuiObj = dynamic_cast<HYDROGUI_DataObject*>( theObject );
964   if ( !aGuiObj )
965     return;
966
967   Handle(HYDROData_Entity) aDataObj = aGuiObj->modelObject();
968   if ( aDataObj.IsNull() )
969     return;
970
971   if ( aDataObj->IsKind( STANDARD_TYPE(HYDROData_Object) ) )
972   {
973     Handle(HYDROData_Object) aGeomObj =
974       Handle(HYDROData_Object)::DownCast( aDataObj );
975
976     Handle(HYDROData_DummyObject3D) anObject3D = aGeomObj->GetObject3D();
977     if ( !anObject3D.IsNull() )
978       createObject( aGuiObj, anObject3D, "", false );
979
980 #ifdef DEB_GROUPS
981     HYDROData_SequenceOfObjects anObjGroups = aGeomObj->GetGroups();
982     buildObjectPartition( aGuiObj, anObjGroups, tr( "OBJECT_GROUPS" ), false );
983 #endif
984   }
985
986   ObjectKind anObjectKind = aDataObj->GetKind();
987
988   if ( anObjectKind == KIND_IMAGE )
989   {
990     Handle(HYDROData_Image) anImageObj =
991       Handle(HYDROData_Image)::DownCast( aDataObj );
992     for ( int anIndex = 0, aNbRef = anImageObj->NbReferences(); anIndex < aNbRef; anIndex++ )
993     {
994       Handle(HYDROData_Entity) aRefObj = anImageObj->Reference( anIndex );
995       if ( !aRefObj.IsNull() && !aRefObj->IsRemoved() )
996         createObject( aGuiObj, aRefObj, aGuiObj->entry(), false );
997     }
998   }
999   else if ( anObjectKind == KIND_IMMERSIBLE_ZONE )
1000   {
1001     Handle(HYDROData_ImmersibleZone) aZoneObj =
1002       Handle(HYDROData_ImmersibleZone)::DownCast( aDataObj );
1003
1004     LightApp_DataObject* aPolylineSect = 
1005       createObject( aGuiObj, tr( "ZONE_POLYLINE" ), aGuiObj->entry() );
1006
1007     Handle(HYDROData_PolylineXY) aPolyline = aZoneObj->GetPolyline();
1008     if ( !aPolyline.IsNull() && !aPolyline->IsRemoved() )
1009       createObject( aPolylineSect, aPolyline, aGuiObj->entry(), false );
1010
1011     LightApp_DataObject* aBathSect = 
1012       createObject( aGuiObj, tr( "ZONE_BATHYMETRY" ), aGuiObj->entry() );
1013
1014     Handle(HYDROData_IAltitudeObject) anAltitudeObj = aZoneObj->GetAltitudeObject();
1015     if ( !anAltitudeObj.IsNull() && !anAltitudeObj->IsRemoved() )
1016       createObject( aBathSect, anAltitudeObj, aGuiObj->entry(), false );
1017   }
1018   else if ( anObjectKind == KIND_POLYLINE )
1019   {
1020     Handle(HYDROData_Polyline3D) aPolyline3D =
1021       Handle(HYDROData_Polyline3D)::DownCast( aDataObj );
1022
1023     LightApp_DataObject* aPolylineSect = 
1024       createObject( aGuiObj, tr( "POLYLINE3D_POLYLINE" ), aGuiObj->entry() );
1025
1026     Handle(HYDROData_PolylineXY) aPolylineXY = aPolyline3D->GetPolylineXY();
1027     if ( !aPolylineXY.IsNull() && !aPolylineXY->IsRemoved() )
1028       createObject( aPolylineSect, aPolylineXY, aGuiObj->entry(), false );
1029
1030     LightApp_DataObject* aProfileSect = 
1031       createObject( aGuiObj, tr( "POLYLINE3D_PROFILE" ), aGuiObj->entry() );
1032
1033     Handle(HYDROData_ProfileUZ) aProfileUZ = aPolyline3D->GetProfileUZ();
1034     if ( aProfileUZ.IsNull() || aProfileUZ->IsRemoved() )
1035       aProfileUZ = aPolyline3D->GetChildProfileUZ( false );
1036
1037     if ( !aProfileUZ.IsNull() && !aProfileUZ->IsRemoved() )
1038     {
1039       Handle(HYDROData_Profile) aProfile = 
1040         Handle(HYDROData_Profile)::DownCast( aProfileUZ->GetFatherObject() );
1041       if ( !aProfile.IsNull() && !aProfile->IsRemoved() )
1042         createObject( aProfileSect, aProfile, aGuiObj->entry(), false );
1043     }
1044
1045     LightApp_DataObject* aBathSect = 
1046       createObject( aGuiObj, tr( "POLYLINE3D_BATHYMETRY" ), aGuiObj->entry() );
1047
1048     Handle(HYDROData_IAltitudeObject) anAltitudeObj = aPolyline3D->GetAltitudeObject();
1049     if ( !anAltitudeObj.IsNull() && !anAltitudeObj->IsRemoved() )
1050       createObject( aBathSect, anAltitudeObj, aGuiObj->entry(), false );
1051   }
1052   else if ( anObjectKind == KIND_CALCULATION )
1053   {
1054     Handle(HYDROData_CalculationCase) aCaseObj =
1055       Handle(HYDROData_CalculationCase)::DownCast( aDataObj );
1056
1057     LightApp_DataObject* aPolylineSect = 
1058       createObject( aGuiObj, tr( "CASE_BOUNDARY" ), aGuiObj->entry() );
1059
1060     Handle(HYDROData_PolylineXY) aPolyline = aCaseObj->GetBoundaryPolyline();
1061     if ( !aPolyline.IsNull() && !aPolyline->IsRemoved() )
1062       createObject( aPolylineSect, aPolyline, aGuiObj->entry(), false );
1063
1064     LightApp_DataObject* aCaseAOSect = 
1065       createObject( aGuiObj, tr( partitionName( KIND_ARTIFICIAL_OBJECT ).toLatin1() ),
1066                     aGuiObj->entry() );
1067     LightApp_DataObject* aCaseNOSect = 
1068       createObject( aGuiObj, tr( partitionName( KIND_NATURAL_OBJECT ).toLatin1() ),
1069                     aGuiObj->entry() );
1070
1071     HYDROData_SequenceOfObjects aSeq = aCaseObj->GetGeometryObjects();
1072     HYDROData_SequenceOfObjects::Iterator aGOIter( aSeq );
1073     Handle(HYDROData_Entity) anEntity;
1074     Handle(HYDROData_ArtificialObject) anAObject;
1075     Handle(HYDROData_NaturalObject) aNObject;
1076     for ( ; aGOIter.More(); aGOIter.Next() )
1077     {
1078       anEntity = aGOIter.Value();
1079       if ( anEntity.IsNull() )
1080         continue;
1081       anAObject = Handle(HYDROData_ArtificialObject)::DownCast( anEntity );
1082       if ( !anAObject.IsNull() )
1083         createObject( aCaseAOSect, anAObject, aGuiObj->entry(), false );
1084       else
1085       {
1086         aNObject = Handle(HYDROData_NaturalObject)::DownCast( anEntity );
1087         if ( !aNObject.IsNull() )
1088           createObject( aCaseNOSect, aNObject, aGuiObj->entry(), false );
1089       }    
1090     }
1091
1092     LightApp_DataObject* aBoundaryPolygonSect = 
1093       createObject( aGuiObj, tr( "CASE_BOUNDARY_POLYGONS" ), aGuiObj->entry() );
1094     HYDROData_SequenceOfObjects aBCPolygons = aCaseObj->GetBoundaryPolygons();
1095     for (int i = 1; i <= aBCPolygons.Size(); i++ )
1096       createObject( aBoundaryPolygonSect, aBCPolygons(i), aGuiObj->entry(), false );
1097
1098     LightApp_DataObject* aLandCoverMapSect = 
1099       createObject( aGuiObj, tr( "CASE_LAND_COVER_MAP" ), aGuiObj->entry() );
1100
1101     Handle(HYDROData_LandCoverMap) aLandCoverMap = aCaseObj->GetLandCoverMap();
1102     if ( !aLandCoverMap.IsNull() && !aLandCoverMap->IsRemoved() )
1103       createObject( aLandCoverMapSect, aLandCoverMap, aGuiObj->entry(), false );
1104
1105     LightApp_DataObject* aCaseRegionsSect = 
1106       createObject( aGuiObj, tr( "CASE_REGIONS" ), aGuiObj->entry() );
1107
1108     HYDROData_SequenceOfObjects aCaseRegions = aCaseObj->GetRegions();
1109     HYDROData_SequenceOfObjects::Iterator anIter( aCaseRegions );
1110     for ( ; anIter.More(); anIter.Next() )
1111     {
1112       Handle(HYDROData_Region) aCaseRegion =
1113         Handle(HYDROData_Region)::DownCast( anIter.Value() );
1114       if( !aCaseRegion.IsNull() && !aCaseRegion->IsRemoved() )
1115         createRegion( aCaseRegionsSect, aCaseRegion, "", true, theIsInOperation );
1116     }
1117    
1118 #ifdef DEB_GROUPS
1119     HYDROData_SequenceOfObjects aCalcGroups = aCaseObj->GetGeometryGroups();
1120     buildObjectPartition( aGuiObj, aCalcGroups, tr( "OBJECT_GROUPS" ), false );
1121
1122     HYDROData_SequenceOfObjects aCalcSplitGroups = aCaseObj->GetSplitGroups();
1123     buildObjectPartition( aGuiObj, aCalcSplitGroups, tr( "CASE_SPLIT_GROUPS" ), false );
1124 #endif
1125
1126   }
1127   else if ( anObjectKind == KIND_REGION )
1128   {
1129     Handle(HYDROData_Region) aRegionObj =
1130       Handle(HYDROData_Region)::DownCast( aDataObj );
1131
1132     HYDROData_SequenceOfObjects aRegionZones = aRegionObj->GetZones();
1133     HYDROData_SequenceOfObjects::Iterator anIter( aRegionZones );
1134     for ( ; anIter.More(); anIter.Next() )
1135     {
1136       Handle(HYDROData_Zone) aRegionZone =
1137         Handle(HYDROData_Zone)::DownCast( anIter.Value() );
1138       if( !aRegionZone.IsNull() && !aRegionZone->IsRemoved() )
1139         createZone( aGuiObj, aRegionZone, "", true, theIsInOperation );
1140     }
1141   }
1142   else if ( anObjectKind == KIND_PROFILE )
1143   {
1144     Handle(HYDROData_Profile) aProfileObj =
1145       Handle(HYDROData_Profile)::DownCast( aDataObj );
1146
1147     aGuiObj->setIsValid( aProfileObj->IsValid() );
1148   }
1149   else if ( anObjectKind == KIND_CHANNEL || anObjectKind == KIND_DIGUE )
1150   {
1151     Handle(HYDROData_Channel) aChannelObj =
1152       Handle(HYDROData_Channel)::DownCast( aDataObj );
1153
1154     LightApp_DataObject* aGuideLineSect = 
1155       createObject( aGuiObj, tr( "CHANNEL_GUIDE_LINE" ), aGuiObj->entry() );
1156     Handle(HYDROData_Polyline3D) aGuideLine = aChannelObj->GetGuideLine();
1157     if ( !aGuideLine.IsNull() && !aGuideLine->IsRemoved() ) {
1158       createObject( aGuideLineSect, aGuideLine, aGuiObj->entry(), false );
1159     }
1160
1161     LightApp_DataObject* aProfileSect = 
1162       createObject( aGuiObj, tr( "CHANNEL_PROFILE" ), aGuiObj->entry() );
1163     Handle(HYDROData_Profile) aProfile = aChannelObj->GetProfile();
1164     if ( !aProfile.IsNull() && !aProfile->IsRemoved() ) {
1165       createObject( aProfileSect, aProfile, aGuiObj->entry(), false );
1166     }
1167   }
1168   else if ( anObjectKind == KIND_STREAM )
1169   {
1170     Handle(HYDROData_Stream) aStreamObj =
1171       Handle(HYDROData_Stream)::DownCast( aDataObj );
1172
1173     LightApp_DataObject* aHydraulicAxisSect = 
1174       createObject( aGuiObj, tr( "STREAM_HYDRAULIC_AXIS" ), aGuiObj->entry() );
1175     Handle(HYDROData_PolylineXY) aHydraulicAxis = aStreamObj->GetHydraulicAxis();
1176     if ( !aHydraulicAxis.IsNull() && !aHydraulicAxis->IsRemoved() ) {
1177       createObject( aHydraulicAxisSect, aHydraulicAxis, aGuiObj->entry(), false );
1178     }
1179
1180     HYDROData_SequenceOfObjects aProfiles = aStreamObj->GetProfiles();
1181     buildObjectPartition( aGuiObj, aProfiles, tr( "STREAM_PROFILES" ), true );
1182
1183     Handle(HYDROData_Polyline3D) aBottomPolyline = aStreamObj->GetBottomPolyline();
1184     if ( !aBottomPolyline.IsNull() && !aBottomPolyline->IsRemoved() ) {
1185       createObject( aGuiObj, aBottomPolyline, aGuiObj->entry(), false );
1186     }
1187   }
1188   else if ( anObjectKind == KIND_LAND_COVER_MAP )
1189   {
1190     Handle(HYDROData_LandCoverMap) aLandCoverMapObj =
1191       Handle(HYDROData_LandCoverMap)::DownCast( aDataObj );
1192
1193     /*TODO: reference objects of the land cover map 
1194     HYDROData_SequenceOfObjects aPolylines = aLandCoverMapObj->GetPolylines();
1195     buildObjectPartition( aGuiObj, aPolylines, tr( "LAND_COVER_POLYLINES" ), true );*/
1196   }
1197   else if ( anObjectKind == KIND_BC_POLYGON )
1198   {
1199     Handle(HYDROData_BCPolygon) aBCObj =
1200       Handle(HYDROData_BCPolygon)::DownCast( aDataObj );
1201
1202     LightApp_DataObject* aPolylineSect = 
1203       createObject( aGuiObj, tr( "BC_POLYGON_POLYLINE" ), aGuiObj->entry() );
1204
1205     Handle(HYDROData_PolylineXY) aPolyline = aBCObj->GetPolyline();
1206     if ( !aPolyline.IsNull() && !aPolyline->IsRemoved() )
1207       createObject( aPolylineSect, aPolyline, aGuiObj->entry(), false );
1208   }
1209   HYDROGUI_Module* aModule = dynamic_cast<HYDROGUI_Module*>( module() );
1210   if( aModule )
1211     aModule->enableLCMActions();
1212   
1213 }
1214
1215 void HYDROGUI_DataModel::buildCaseTree( SUIT_DataObject* theParent, Handle(HYDROData_CalculationCase) theCase )
1216 {
1217   if ( !theCase.IsNull() )
1218   {
1219     if ( theParent )
1220     {
1221       // Remove previous objects tree
1222         DataObjectList aList;
1223         theParent->children( aList );
1224         QListIterator<SUIT_DataObject*> anIter( aList );
1225         while( anIter.hasNext() )
1226           removeChild( theParent, anIter.next() );
1227     }
1228
1229     new HYDROGUI_DropTargetObject( theParent, tr( "NEW_REGION" ), "", true );
1230
1231     HYDROData_SequenceOfObjects aCaseRegions = theCase->GetRegions();
1232     HYDROData_SequenceOfObjects::Iterator anIter( aCaseRegions );
1233     for ( ; anIter.More(); anIter.Next() )
1234     {
1235       Handle(HYDROData_Region) aCaseRegion =
1236         Handle(HYDROData_Region)::DownCast( anIter.Value() );
1237       if( !aCaseRegion.IsNull() && !aCaseRegion->IsRemoved() )
1238         createRegion( theParent, aCaseRegion, "", true, true );
1239     }
1240   }
1241 }
1242
1243 void HYDROGUI_DataModel::updateObjectTree( Handle(HYDROData_Entity)& theObj )
1244 {
1245   if ( !theObj.IsNull() )
1246   {
1247     HYDROGUI_DataObject* aGuiObj = dynamic_cast<HYDROGUI_DataObject*>(
1248       findObject( HYDROGUI_DataObject::dataObjectEntry( theObj ) ) );
1249     if ( aGuiObj )
1250     {
1251       // Remove previous objects tree
1252       DataObjectList aList;
1253       aGuiObj->children( aList );
1254       QListIterator<SUIT_DataObject*> anIter( aList );
1255       while( anIter.hasNext() )
1256         removeChild( aGuiObj, anIter.next() );
1257
1258       // Rebuild the subtree
1259       QString aParentEntry;
1260       HYDROGUI_DataObject* aParent = dynamic_cast<HYDROGUI_DataObject*>( aGuiObj->parent() );
1261       if ( aParent )
1262       {
1263         aParentEntry = aParent->entry();
1264       }
1265       buildObjectTree( aParent, aGuiObj, aParentEntry, aGuiObj->isInOperation() );
1266     } 
1267     else
1268     {
1269       // workaround for the bug in SalomeApp_Study::findObjectByEntry - it can't find LightApp_DataObjects
1270       HYDROGUI_Module* aModule = dynamic_cast<HYDROGUI_Module*>( module() );
1271       if( aModule )
1272       {
1273         aModule->getApp()->updateObjectBrowser();
1274       }
1275     }
1276   }
1277 }
1278
1279 void HYDROGUI_DataModel::removeChild( SUIT_DataObject* theParent,
1280                                       SUIT_DataObject* theChild )
1281 {
1282   SUIT_DataObject* aSubChild = theChild->firstChild();
1283   for( ; aSubChild; aSubChild = aSubChild->nextBrother() )
1284     removeChild( theChild, aSubChild );
1285   theParent->removeChild( theChild );
1286 }
1287
1288 SUIT_DataObject* HYDROGUI_DataModel::findChildByName( const SUIT_DataObject* theFather,
1289                                                       const QString& theName )
1290 {
1291   SUIT_DataObject* aChild = theFather->firstChild();
1292   while( aChild )
1293   {
1294     if( aChild->name() == theName )
1295       return aChild; // found
1296     aChild = aChild->nextBrother();
1297   }
1298   return NULL; // not found
1299 }
1300
1301 bool HYDROGUI_DataModel::createNewRegion( Handle(HYDROData_CalculationCase) theCase, 
1302                                          const QList<HYDROGUI_Zone*>& theZonesList )
1303 {
1304   bool isOk = !theCase.IsNull();
1305   if ( isOk )
1306   {
1307     Handle(HYDROData_Region) aRegion;
1308     Handle(HYDROData_Zone) aZone;
1309     for (int i = 0; i < theZonesList.length(); i++ )
1310     {
1311       aZone = Handle(HYDROData_Zone)::DownCast( theZonesList.at(i)->modelObject() );
1312       if ( !aZone.IsNull() )
1313       {
1314         if ( aRegion.IsNull() )
1315         {
1316           aRegion = theCase->AddNewRegion( aZone );
1317           isOk = !aRegion.IsNull();
1318         }
1319         else
1320         {
1321           if ( !( aRegion->AddZone( aZone ) ) )
1322           {
1323             isOk = false;
1324           }
1325         }
1326       }
1327     }
1328   }
1329   return isOk;
1330 }
1331
1332 bool HYDROGUI_DataModel::rename( Handle(HYDROData_Entity) theEntity, const QString& theName )
1333 {
1334   if ( theName.isEmpty() )
1335     return false;
1336
1337   try 
1338   {
1339     getDocument()->StartOperation();
1340     theEntity->SetName( theName );
1341     getDocument()->CommitOperation( HYDROGUI_Tool::ToExtString( tr("RENAME_TO").arg( theName ) ) );
1342     module()->application()->activeStudy()->Modified();
1343   }
1344   catch ( Standard_Failure )
1345   {
1346     getDocument()->AbortOperation();
1347     return false;
1348   }
1349   return true;
1350 }
1351
1352 void HYDROGUI_DataModel::updateDocument()
1353 {
1354     // Sets the default strickler coefficient from preferences to document.
1355     Handle(HYDROData_Document) aDoc = getDocument();
1356     SUIT_ResourceMgr* resMgr = module()->application()->resourceMgr();
1357     if ( resMgr && !aDoc.IsNull() )
1358       aDoc->SetDefaultStricklerCoefficient( resMgr->doubleValue( "preferences", "default_strickler_coefficient", 0 ) );
1359 }
1360
1361 void HYDROGUI_DataModel::setObjectVisibilityState( Handle(HYDROData_Entity) theModelObject,
1362                                                    HYDROGUI_DataObject* theObject )
1363 {
1364   SUIT_AbstractModel* treeModel = 0;
1365   LightApp_Application* app = dynamic_cast<LightApp_Application*>( module()->application() );
1366   if ( app )
1367     treeModel = dynamic_cast<SUIT_AbstractModel*>( app->objectBrowser()->model() );
1368
1369   if ( treeModel )
1370   {
1371     HYDROGUI_Module* aModule = dynamic_cast<HYDROGUI_Module*>( module() );
1372     bool isVisible = aModule->isObjectVisible( -1, theModelObject );
1373     Qtx::VisibilityState aVisState = isVisible ? Qtx::ShownState : Qtx::HiddenState;
1374     treeModel->setVisibilityState( theObject->text( theObject->customData( Qtx::IdType ).toInt() ), aVisState, false );
1375   }
1376 }