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