src/HYDROGUI/HYDROGUI_DataModel.cxx

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