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