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       treeModel->setVisibilityState( aResObj->text( aResObj->customData( Qtx::IdType ).toInt() ), Qtx::HiddenState, false );
 709   }
 710
 711   if ( theIsBuildTree )
 712   {
 713     buildObjectTree( theParent, aResObj, theParentEntry );
 714   }
 715
 716   return aResObj;
 717 }
 718
 719 LightApp_DataObject* HYDROGUI_DataModel::buildObject( SUIT_DataObject*     theParent,
 720                                                       HYDROGUI_DataObject* theObject,
 721                                                       const QString&       theParentEntry,
 722                                                       const bool           theIsBuildTree,
 723                                                       const bool           theIsInOperation )
 724 {
 725   if ( theIsBuildTree )
 726   {
 727     buildObjectTree( theParent, theObject, theParentEntry, theIsInOperation );
 728   }
 729   return theObject;
 730 }
 731
 732 LightApp_DataObject* HYDROGUI_DataModel::createZone( SUIT_DataObject*       theParent,
 733                                                      Handle(HYDROData_Zone) theModelObject,
 734                                                      const QString&         theParentEntry,
 735                                                      const bool             theIsBuildTree,
 736                                                      const bool             theIsInOperation )
 737 {
 738   return buildObject( theParent, new HYDROGUI_Zone( theParent, theModelObject, theParentEntry, theIsInOperation ),
 739     theParentEntry, theIsBuildTree, theIsInOperation );
 740 }
 741
 742 LightApp_DataObject* HYDROGUI_DataModel::createRegion( SUIT_DataObject*         theParent,
 743                                                        Handle(HYDROData_Region) theModelObject,
 744                                                        const QString&           theParentEntry,
 745                                                        const bool               theIsBuildTree,
 746                                                        const bool               theIsInOperation )
 747 {
 748   return buildObject( theParent, new HYDROGUI_Region( theParent, theModelObject, theParentEntry, theIsInOperation ),
 749     theParentEntry, theIsBuildTree, theIsInOperation );
 750 }
 751
 752 LightApp_DataObject* HYDROGUI_DataModel::createObject( SUIT_DataObject* theParent,
 753                                                        const QString&   theName,
 754                                                        const QString&   theParentEntry )
 755 {
 756   return new HYDROGUI_NamedObject( theParent, theName, theParentEntry );
 757 }
 758
 759 void HYDROGUI_DataModel::buildObjectPartition( SUIT_DataObject*                   theObject,
 760                                                const HYDROData_SequenceOfObjects& theObjects,
 761                                                const QString&                     thePartName,
 762                                                const bool                         theIsCreateEmpty )
 763 {
 764   if ( theObjects.IsEmpty() && !theIsCreateEmpty )
 765     return;
 766
 767   HYDROGUI_DataObject* aGuiObj = dynamic_cast<HYDROGUI_DataObject*>( theObject );
 768   if ( !aGuiObj )
 769     return;
 770
 771   LightApp_DataObject* aPartSect =
 772     createObject( aGuiObj, thePartName, aGuiObj->entry() );
 773
 774   HYDROData_SequenceOfObjects::Iterator anIter( theObjects );
 775   for ( ; anIter.More(); anIter.Next() )
 776   {
 777     Handle(HYDROData_Entity) anObj = anIter.Value();
 778     if( !anObj.IsNull() && !anObj->IsRemoved() )
 779       createObject( aPartSect, anObj, aGuiObj->entry(), false );
 780   }
 781 }
 782
 783 void HYDROGUI_DataModel::buildObjectTree( SUIT_DataObject* theParent,
 784                                           SUIT_DataObject* theObject,
 785                                           const QString&   theParentEntry,
 786                                           const bool       theIsInOperation )
 787 {
 788   HYDROGUI_DataObject* aGuiObj = dynamic_cast<HYDROGUI_DataObject*>( theObject );
 789   if ( !aGuiObj )
 790     return;
 791
 792   Handle(HYDROData_Entity) aDataObj = aGuiObj->modelObject();
 793   if ( aDataObj.IsNull() )
 794     return;
 795
 796   if ( aDataObj->IsKind( STANDARD_TYPE(HYDROData_Object) ) )
 797   {
 798     Handle(HYDROData_Object) aGeomObj =
 799       Handle(HYDROData_Object)::DownCast( aDataObj );
 800
 801     Handle(HYDROData_DummyObject3D) anObject3D = aGeomObj->GetObject3D();
 802     if ( !anObject3D.IsNull() )
 803       createObject( aGuiObj, anObject3D, "", false );
 804
 805 #ifdef DEB_GROUPS
 806     HYDROData_SequenceOfObjects anObjGroups = aGeomObj->GetGroups();
 807     buildObjectPartition( aGuiObj, anObjGroups, tr( "OBJECT_GROUPS" ), false );
 808 #endif
 809   }
 810
 811   ObjectKind anObjectKind = aDataObj->GetKind();
 812
 813   if ( anObjectKind == KIND_IMAGE )
 814   {
 815     Handle(HYDROData_Image) anImageObj =
 816       Handle(HYDROData_Image)::DownCast( aDataObj );
 817     for ( int anIndex = 0, aNbRef = anImageObj->NbReferences(); anIndex < aNbRef; anIndex++ )
 818     {
 819       Handle(HYDROData_Entity) aRefObj = anImageObj->Reference( anIndex );
 820       if ( !aRefObj.IsNull() && !aRefObj->IsRemoved() )
 821         createObject( aGuiObj, aRefObj, aGuiObj->entry(), false );
 822     }
 823   }
 824   else if ( anObjectKind == KIND_IMMERSIBLE_ZONE )
 825   {
 826     Handle(HYDROData_ImmersibleZone) aZoneObj =
 827       Handle(HYDROData_ImmersibleZone)::DownCast( aDataObj );
 828
 829     LightApp_DataObject* aPolylineSect =
 830       createObject( aGuiObj, tr( "ZONE_POLYLINE" ), aGuiObj->entry() );
 831
 832     Handle(HYDROData_PolylineXY) aPolyline = aZoneObj->GetPolyline();
 833     if ( !aPolyline.IsNull() && !aPolyline->IsRemoved() )
 834       createObject( aPolylineSect, aPolyline, aGuiObj->entry(), false );
 835
 836     LightApp_DataObject* aBathSect =
 837       createObject( aGuiObj, tr( "ZONE_BATHYMETRY" ), aGuiObj->entry() );
 838
 839     Handle(HYDROData_IAltitudeObject) anAltitudeObj = aZoneObj->GetAltitudeObject();
 840     if ( !anAltitudeObj.IsNull() && !anAltitudeObj->IsRemoved() )
 841       createObject( aBathSect, anAltitudeObj, aGuiObj->entry(), false );
 842   }
 843   else if ( anObjectKind == KIND_POLYLINE )
 844   {
 845     Handle(HYDROData_Polyline3D) aPolyline3D =
 846       Handle(HYDROData_Polyline3D)::DownCast( aDataObj );
 847
 848     LightApp_DataObject* aPolylineSect =
 849       createObject( aGuiObj, tr( "POLYLINE3D_POLYLINE" ), aGuiObj->entry() );
 850
 851     Handle(HYDROData_PolylineXY) aPolylineXY = aPolyline3D->GetPolylineXY();
 852     if ( !aPolylineXY.IsNull() && !aPolylineXY->IsRemoved() )
 853       createObject( aPolylineSect, aPolylineXY, aGuiObj->entry(), false );
 854
 855     LightApp_DataObject* aProfileSect =
 856       createObject( aGuiObj, tr( "POLYLINE3D_PROFILE" ), aGuiObj->entry() );
 857
 858     Handle(HYDROData_ProfileUZ) aProfileUZ = aPolyline3D->GetProfileUZ();
 859     if ( aProfileUZ.IsNull() || aProfileUZ->IsRemoved() )
 860       aProfileUZ = aPolyline3D->GetChildProfileUZ( false );
 861
 862     if ( !aProfileUZ.IsNull() && !aProfileUZ->IsRemoved() )
 863     {
 864       Handle(HYDROData_Profile) aProfile =
 865         Handle(HYDROData_Profile)::DownCast( aProfileUZ->GetFatherObject() );
 866       if ( !aProfile.IsNull() && !aProfile->IsRemoved() )
 867         createObject( aProfileSect, aProfile, aGuiObj->entry(), false );
 868     }
 869
 870     LightApp_DataObject* aBathSect =
 871       createObject( aGuiObj, tr( "POLYLINE3D_BATHYMETRY" ), aGuiObj->entry() );
 872
 873     Handle(HYDROData_IAltitudeObject) anAltitudeObj = aPolyline3D->GetAltitudeObject();
 874     if ( !anAltitudeObj.IsNull() && !anAltitudeObj->IsRemoved() )
 875       createObject( aBathSect, anAltitudeObj, aGuiObj->entry(), false );
 876   }
 877   else if ( anObjectKind == KIND_CALCULATION )
 878   {
 879     Handle(HYDROData_CalculationCase) aCaseObj =
 880       Handle(HYDROData_CalculationCase)::DownCast( aDataObj );
 881
 882     LightApp_DataObject* aPolylineSect =
 883       createObject( aGuiObj, tr( "CASE_BOUNDARY" ), aGuiObj->entry() );
 884
 885     Handle(HYDROData_PolylineXY) aPolyline = aCaseObj->GetBoundaryPolyline();
 886     if ( !aPolyline.IsNull() && !aPolyline->IsRemoved() )
 887       createObject( aPolylineSect, aPolyline, aGuiObj->entry(), false );
 888
 889     LightApp_DataObject* aCaseAOSect =
 890       createObject( aGuiObj, tr( partitionName( KIND_ARTIFICIAL_OBJECT ).toAscii() ),
 891                     aGuiObj->entry() );
 892     LightApp_DataObject* aCaseNOSect =
 893       createObject( aGuiObj, tr( partitionName( KIND_NATURAL_OBJECT ).toAscii() ),
 894                     aGuiObj->entry() );
 895
 896     HYDROData_SequenceOfObjects aSeq = aCaseObj->GetGeometryObjects();
 897     HYDROData_SequenceOfObjects::Iterator aGOIter( aSeq );
 898     Handle(HYDROData_Entity) anEntity;
 899     Handle(HYDROData_ArtificialObject) anAObject;
 900     Handle(HYDROData_NaturalObject) aNObject;
 901     for ( ; aGOIter.More(); aGOIter.Next() )
 902     {
 903       anEntity = aGOIter.Value();
 904       if ( anEntity.IsNull() )
 905         continue;
 906       anAObject = Handle(HYDROData_ArtificialObject)::DownCast( anEntity );
 907       if ( !anAObject.IsNull() )
 908         createObject( aCaseAOSect, anAObject, aGuiObj->entry(), false );
 909       else
 910       {
 911         aNObject = Handle(HYDROData_NaturalObject)::DownCast( anEntity );
 912         if ( !aNObject.IsNull() )
 913           createObject( aCaseNOSect, aNObject, aGuiObj->entry(), false );
 914       }
 915     }
 916     LightApp_DataObject* aCaseRegionsSect =
 917       createObject( aGuiObj, tr( "CASE_REGIONS" ), aGuiObj->entry() );
 918
 919     HYDROData_SequenceOfObjects aCaseRegions = aCaseObj->GetRegions();
 920     HYDROData_SequenceOfObjects::Iterator anIter( aCaseRegions );
 921     for ( ; anIter.More(); anIter.Next() )
 922     {
 923       Handle(HYDROData_Region) aCaseRegion =
 924         Handle(HYDROData_Region)::DownCast( anIter.Value() );
 925       if( !aCaseRegion.IsNull() && !aCaseRegion->IsRemoved() )
 926         createRegion( aCaseRegionsSect, aCaseRegion, "", true, theIsInOperation );
 927     }
 928
 929 #ifdef DEB_GROUPS
 930     HYDROData_SequenceOfObjects aCalcGroups = aCaseObj->GetGeometryGroups();
 931     buildObjectPartition( aGuiObj, aCalcGroups, tr( "OBJECT_GROUPS" ), false );
 932
 933     HYDROData_SequenceOfObjects aCalcSplitGroups = aCaseObj->GetSplittedGroups();
 934     buildObjectPartition( aGuiObj, aCalcSplitGroups, tr( "CASE_SPLITTED_GROUPS" ), false );
 935 #endif
 936
 937   }
 938   else if ( anObjectKind == KIND_REGION )
 939   {
 940     Handle(HYDROData_Region) aRegionObj =
 941       Handle(HYDROData_Region)::DownCast( aDataObj );
 942
 943     HYDROData_SequenceOfObjects aRegionZones = aRegionObj->GetZones();
 944     HYDROData_SequenceOfObjects::Iterator anIter( aRegionZones );
 945     for ( ; anIter.More(); anIter.Next() )
 946     {
 947       Handle(HYDROData_Zone) aRegionZone =
 948         Handle(HYDROData_Zone)::DownCast( anIter.Value() );
 949       if( !aRegionZone.IsNull() && !aRegionZone->IsRemoved() )
 950         createZone( aGuiObj, aRegionZone, "", true, theIsInOperation );
 951     }
 952   }
 953   else if ( anObjectKind == KIND_PROFILE )
 954   {
 955     Handle(HYDROData_Profile) aProfileObj =
 956       Handle(HYDROData_Profile)::DownCast( aDataObj );
 957
 958     aGuiObj->setIsValid( aProfileObj->IsValid() );
 959   }
 960   else if ( anObjectKind == KIND_CHANNEL || anObjectKind == KIND_DIGUE )
 961   {
 962     Handle(HYDROData_Channel) aChannelObj =
 963       Handle(HYDROData_Channel)::DownCast( aDataObj );
 964
 965     LightApp_DataObject* aGuideLineSect =
 966       createObject( aGuiObj, tr( "CHANNEL_GUIDE_LINE" ), aGuiObj->entry() );
 967     Handle(HYDROData_Polyline3D) aGuideLine = aChannelObj->GetGuideLine();
 968     if ( !aGuideLine.IsNull() && !aGuideLine->IsRemoved() ) {
 969       createObject( aGuideLineSect, aGuideLine, aGuiObj->entry(), false );
 970     }
 971
 972     LightApp_DataObject* aProfileSect =
 973       createObject( aGuiObj, tr( "CHANNEL_PROFILE" ), aGuiObj->entry() );
 974     Handle(HYDROData_Profile) aProfile = aChannelObj->GetProfile();
 975     if ( !aProfile.IsNull() && !aProfile->IsRemoved() ) {
 976       createObject( aProfileSect, aProfile, aGuiObj->entry(), false );
 977     }
 978   }
 979   else if ( anObjectKind == KIND_STREAM )
 980   {
 981     Handle(HYDROData_Stream) aStreamObj =
 982       Handle(HYDROData_Stream)::DownCast( aDataObj );
 983
 984     LightApp_DataObject* aHydraulicAxisSect =
 985       createObject( aGuiObj, tr( "STREAM_HYDRAULIC_AXIS" ), aGuiObj->entry() );
 986     Handle(HYDROData_PolylineXY) aHydraulicAxis = aStreamObj->GetHydraulicAxis();
 987     if ( !aHydraulicAxis.IsNull() && !aHydraulicAxis->IsRemoved() ) {
 988       createObject( aHydraulicAxisSect, aHydraulicAxis, aGuiObj->entry(), false );
 989     }
 990
 991     HYDROData_SequenceOfObjects aProfiles = aStreamObj->GetProfiles();
 992     buildObjectPartition( aGuiObj, aProfiles, tr( "STREAM_PROFILES" ), true );
 993
 994     Handle(HYDROData_Polyline3D) aBottomPolyline = aStreamObj->GetBottomPolyline();
 995     if ( !aBottomPolyline.IsNull() && !aBottomPolyline->IsRemoved() ) {
 996       createObject( aGuiObj, aBottomPolyline, aGuiObj->entry(), false );
 997     }
 998   }
 999 }
1000
1001 void HYDROGUI_DataModel::buildCaseTree( SUIT_DataObject* theParent, Handle(HYDROData_CalculationCase) theCase )
1002 {
1003   if ( !theCase.IsNull() )
1004   {
1005     if ( theParent )
1006     {
1007       // Remove previous objects tree
1008         DataObjectList aList;
1009         theParent->children( aList );
1010         QListIterator<SUIT_DataObject*> anIter( aList );
1011         while( anIter.hasNext() )
1012           removeChild( theParent, anIter.next() );
1013     }
1014
1015     new HYDROGUI_DropTargetObject( theParent, tr( "NEW_REGION" ), "", true );
1016
1017     HYDROData_SequenceOfObjects aCaseRegions = theCase->GetRegions();
1018     HYDROData_SequenceOfObjects::Iterator anIter( aCaseRegions );
1019     for ( ; anIter.More(); anIter.Next() )
1020     {
1021       Handle(HYDROData_Region) aCaseRegion =
1022         Handle(HYDROData_Region)::DownCast( anIter.Value() );
1023       if( !aCaseRegion.IsNull() && !aCaseRegion->IsRemoved() )
1024         createRegion( theParent, aCaseRegion, "", true, true );
1025     }
1026   }
1027 }
1028
1029 void HYDROGUI_DataModel::updateObjectTree( Handle(HYDROData_Entity)& theObj )
1030 {
1031   if ( !theObj.IsNull() )
1032   {
1033     HYDROGUI_DataObject* aGuiObj = dynamic_cast<HYDROGUI_DataObject*>(
1034       findObject( HYDROGUI_DataObject::dataObjectEntry( theObj ) ) );
1035     if ( aGuiObj )
1036     {
1037       // Remove previous objects tree
1038       DataObjectList aList;
1039       aGuiObj->children( aList );
1040       QListIterator<SUIT_DataObject*> anIter( aList );
1041       while( anIter.hasNext() )
1042         removeChild( aGuiObj, anIter.next() );
1043
1044       // Rebuild the subtree
1045       QString aParentEntry;
1046       HYDROGUI_DataObject* aParent = dynamic_cast<HYDROGUI_DataObject*>( aGuiObj->parent() );
1047       if ( aParent )
1048       {
1049         aParentEntry = aParent->entry();
1050       }
1051       buildObjectTree( aParent, aGuiObj, aParentEntry, aGuiObj->isInOperation() );
1052     }
1053     else
1054     {
1055       // workaround for the bug in SalomeApp_Study::findObjectByEntry - it can't find LightApp_DataObjects
1056       HYDROGUI_Module* aModule = dynamic_cast<HYDROGUI_Module*>( module() );
1057       if( aModule )
1058       {
1059         aModule->getApp()->updateObjectBrowser();
1060       }
1061     }
1062   }
1063 }
1064
1065 void HYDROGUI_DataModel::removeChild( SUIT_DataObject* theParent,
1066                                       SUIT_DataObject* theChild )
1067 {
1068   SUIT_DataObject* aSubChild = theChild->firstChild();
1069   for( ; aSubChild; aSubChild = aSubChild->nextBrother() )
1070     removeChild( theChild, aSubChild );
1071   theParent->removeChild( theChild );
1072 }
1073
1074 SUIT_DataObject* HYDROGUI_DataModel::findChildByName( const SUIT_DataObject* theFather,
1075                                                       const QString& theName )
1076 {
1077   SUIT_DataObject* aChild = theFather->firstChild();
1078   while( aChild )
1079   {
1080     if( aChild->name() == theName )
1081       return aChild; // found
1082     aChild = aChild->nextBrother();
1083   }
1084   return NULL; // not found
1085 }
1086
1087 bool HYDROGUI_DataModel::createNewRegion( Handle(HYDROData_CalculationCase) theCase,
1088                                          const QList<HYDROGUI_Zone*>& theZonesList )
1089 {
1090   bool isOk = !theCase.IsNull();
1091   if ( isOk )
1092   {
1093     Handle(HYDROData_Region) aRegion;
1094     Handle(HYDROData_Zone) aZone;
1095     for (int i = 0; i < theZonesList.length(); i++ )
1096     {
1097       aZone = Handle(HYDROData_Zone)::DownCast( theZonesList.at(i)->modelObject() );
1098       if ( !aZone.IsNull() )
1099       {
1100         if ( aRegion.IsNull() )
1101         {
1102           aRegion = theCase->AddNewRegion( aZone );
1103           isOk = !aRegion.IsNull();
1104         }
1105         else
1106         {
1107           if ( !( aRegion->AddZone( aZone ) ) )
1108           {
1109             isOk = false;
1110           }
1111         }
1112       }
1113     }
1114   }
1115   return isOk;
1116 }
1117
1118 bool HYDROGUI_DataModel::rename( Handle(HYDROData_Entity) theEntity, const QString& theName )
1119 {
1120   if ( theName.isEmpty() )
1121     return false;
1122
1123   try
1124   {
1125     getDocument()->StartOperation();
1126     theEntity->SetName( theName );
1127     getDocument()->CommitOperation( HYDROGUI_Tool::ToExtString( tr("RENAME_TO").arg( theName ) ) );
1128     module()->application()->activeStudy()->Modified();
1129   }
1130   catch ( Standard_Failure )
1131   {
1132     getDocument()->AbortOperation();
1133     return false;
1134   }
1135   return true;
1136 }