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