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