src/HYDROData/HYDROData_Document.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 <HYDROData_Document.h>
  20 #include <HYDROData_Application.h>
  21 #include <HYDROData_Iterator.h>
  22 #include <HYDROData_Tool.h>
  23 #include <HYDROData_InterpolatorsFactory.h>
  24
  25 #include <TDataStd_Real.hxx>
  26 #include <TDataStd_Integer.hxx>
  27 #include <TDataXtd_Position.hxx>
  28
  29 #include <TDF_Delta.hxx>
  30
  31 #include <gp_Pnt.hxx>
  32
  33 #include <QFile>
  34 #include <QStringList>
  35 #include <QTextStream>
  36
  37 IMPLEMENT_STANDARD_HANDLE(HYDROData_Document,MMgt_TShared)
  38 IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Document,MMgt_TShared)
  39
  40 #define PYTHON_DOC_NAME "hydro_doc"
  41
  42 static const int UNDO_LIMIT = 10; // number of possible undo operations in the module
  43
  44 static const int TAG_PROPS = 1; // general properties tag
  45 static const int TAG_PROPS_NEW_ID = 1; // general properties: tag for storage of the new object ID
  46 static const int TAG_OBJECTS = 2; // tag of the objects sub-tree
  47 static const int TAG_HISTORY = 3; // tag of the history sub-tree (Root for History)
  48 static const int TAG_LOCAL_CS = 4; // tag of local coordinate system information
  49 static const int TAG_DEF_STRICKLER_COEFF = 5; // tag of default strickler coefficient
  50 static const gp_Pnt2d DEFAULT_LOCAL_CS( 0, 0 );
  51
  52 using namespace std;
  53
  54 typedef QMap<Standard_Integer,Handle_HYDROData_Entity> MapOfOrdered;
  55 typedef QMap<QString,Handle_HYDROData_Entity> MapOfUnordered;
  56
  57 Handle(HYDROData_Document) HYDROData_Document::Document(const int theStudyID)
  58 {
  59   Handle(HYDROData_Document) aResult =
  60     HYDROData_Application::GetApplication()->GetDocument(theStudyID);
  61   if (aResult.IsNull()) {
  62     aResult = new HYDROData_Document();
  63     HYDROData_Application::GetApplication()->AddDocument(theStudyID, aResult);
  64   }
  65   return aResult;
  66 }
  67
  68 Handle(HYDROData_Document) HYDROData_Document::Document(
  69   const TDF_Label& theObjectLabel )
  70 {
  71   Handle(HYDROData_Document) aResDoc;
  72   if ( theObjectLabel.IsNull() )
  73     return aResDoc;
  74
  75   Handle(TDocStd_Document) anObjDoc;
  76   try
  77   {
  78     anObjDoc = TDocStd_Document::Get( theObjectLabel );
  79   }
  80   catch( ... )
  81   {
  82   }
  83
  84   if ( anObjDoc.IsNull() )
  85     return aResDoc;
  86
  87   HYDROData_Application* anApp = HYDROData_Application::GetApplication();
  88
  89   DataMapOfStudyIDDocument::Iterator aMapIt( anApp->myDocuments );
  90   for ( ; aMapIt.More(); aMapIt.Next() )
  91   {
  92     Handle(HYDROData_Document) anAppDoc = aMapIt.Value();
  93     if ( anAppDoc.IsNull() || anAppDoc->myDoc != anObjDoc )
  94       continue;
  95
  96     aResDoc = anAppDoc;
  97     break;
  98   }
  99
 100   return aResDoc;
 101 }
 102
 103 bool HYDROData_Document::HasDocument(const int theStudyID)
 104 {
 105   Handle(HYDROData_Document) aResult =
 106     HYDROData_Application::GetApplication()->GetDocument(theStudyID);
 107   return !aResult.IsNull();
 108 }
 109
 110 bool HYDROData_Document::DocumentId(const Handle(HYDROData_Document)& theDocument,
 111                                     int&                              theDocId )
 112 {
 113   return HYDROData_Application::GetApplication()->GetDocumentId(theDocument, theDocId);
 114 }
 115
 116 Data_DocError HYDROData_Document::Load(const char* theFileName, const int theStudyID)
 117 {
 118   Handle(TDocStd_Document) aResult;
 119   TCollection_ExtendedString aPath ((const Standard_CString)theFileName);
 120   PCDM_ReaderStatus aStatus = (PCDM_ReaderStatus) -1;
 121   try
 122   {
 123     aStatus = HYDROData_Application::GetApplication()->Open (aPath, aResult);
 124   }
 125   catch (Standard_Failure)
 126   {}
 127   if (!aResult.IsNull()) {
 128     aResult->SetUndoLimit(UNDO_LIMIT);
 129     HYDROData_Application::GetApplication()->AddDocument(theStudyID, new HYDROData_Document(aResult));
 130   }
 131   // recognize error
 132   Data_DocError anError;
 133   switch(aStatus) {
 134   case PCDM_RS_OK:
 135     anError = DocError_OK;
 136     break;
 137   case PCDM_RS_NoDriver:
 138   case PCDM_RS_UnknownFileDriver:
 139   case PCDM_RS_NoSchema:
 140   case PCDM_RS_DriverFailure:
 141   case PCDM_RS_WrongResource:
 142     anError = DocError_ResourcesProblem;
 143     break;
 144   case PCDM_RS_OpenError:
 145   case PCDM_RS_NoDocument:
 146   case PCDM_RS_WrongStreamMode:
 147   case PCDM_RS_PermissionDenied:
 148     anError = DocError_CanNotOpen;
 149     break;
 150   case PCDM_RS_NoVersion:
 151     anError = DocError_InvalidVersion;
 152     break;
 153   case PCDM_RS_ExtensionFailure:
 154   case PCDM_RS_FormatFailure:
 155   case PCDM_RS_TypeFailure:
 156   case PCDM_RS_TypeNotFoundInSchema:
 157   case PCDM_RS_UnrecognizedFileFormat:
 158     anError = DocError_InvalidFormat;
 159     break;
 160   case PCDM_RS_MakeFailure:
 161   default:
 162     anError = DocError_UnknownProblem;
 163     break;
 164   }
 165   return anError;
 166 }
 167
 168 Data_DocError HYDROData_Document::Save(const char* theFileName)
 169 {
 170   TCollection_ExtendedString aPath ((const Standard_CString)theFileName);
 171   PCDM_StoreStatus aStatus;
 172   try {
 173     aStatus = HYDROData_Application::GetApplication()->SaveAs (myDoc, aPath);
 174   }
 175   catch (Standard_Failure) {}
 176   myTransactionsAfterSave = 0;
 177   Standard::Purge(); // Release free memory
 178
 179   // recognize error
 180   Data_DocError anError;
 181   switch(aStatus) {
 182   case PCDM_SS_OK:
 183     anError = DocError_OK;
 184     break;
 185   case PCDM_SS_DriverFailure:
 186     anError = DocError_ResourcesProblem;
 187     break;
 188   case PCDM_SS_WriteFailure:
 189   //case PCDM_SS_DiskWritingFailure:
 190   //case PCDM_SS_UserRightsFailure:
 191     anError = DocError_CanNotOpen;
 192     break;
 193   default:
 194     anError = DocError_UnknownProblem;
 195     break;
 196   }
 197   return anError;
 198 }
 199
 200 void HYDROData_Document::Close()
 201 {
 202   myDoc->Close();
 203   HYDROData_Application::GetApplication()->RemoveDocument(this);
 204 }
 205
 206 double HYDROData_Document::GetDefaultStricklerCoefficient() const
 207 {
 208     double aRes = 0;
 209     TDF_Label aLabel = myDoc->Main().FindChild(TAG_DEF_STRICKLER_COEFF, Standard_False);
 210     if ( !aLabel.IsNull() )
 211     {
 212         Handle(TDataStd_Real) anAttr;
 213         if ( aLabel.FindAttribute( TDataStd_Real::GetID(), anAttr ) )
 214             aRes = anAttr->Get();
 215     }
 216
 217     return aRes;
 218 }
 219
 220 void HYDROData_Document::SetDefaultStricklerCoefficient( double theCoeff ) const
 221 {
 222     TDF_Label aLabel = myDoc->Main().FindChild(TAG_DEF_STRICKLER_COEFF);
 223     if ( !aLabel.IsNull() )
 224     {
 225         Handle(TDataStd_Real) anAttr;
 226         if ( !aLabel.FindAttribute( TDataStd_Real::GetID(), anAttr ) )
 227             aLabel.AddAttribute( anAttr = new TDataStd_Real() );
 228         anAttr->Set( theCoeff );
 229     }
 230 }
 231
 232 bool HYDROData_Document::DumpToPython( const QString& theFileName,
 233                                        const bool     theIsMultiFile ) const
 234 {
 235   // Try to open the file
 236   QFile aFile( theFileName );
 237   if ( !aFile.open( QIODevice::WriteOnly ) )
 238     return false;
 239
 240   MapOfTreatedObjects aTreatedObjects;
 241
 242   // Dump header for python script
 243   QStringList aHeaderDump = DumpToPython( aTreatedObjects, theIsMultiFile );
 244   if ( aHeaderDump.isEmpty() )
 245     return false;
 246
 247   HYDROData_Tool::WriteStringsToFile( aFile, aHeaderDump );
 248
 249   bool aRes = true;
 250
 251   // Dump the local CS data to Python
 252   UpdateLCSFields();
 253   QString aLCS = QString( "%1.SetLocalCS( %2, %3 )" ).arg( GetDocPyName() ).arg( myLX ).arg( myLY );
 254   if( theIsMultiFile )
 255     aLCS.prepend( "  " );
 256   HYDROData_Tool::WriteStringsToFile( aFile, QStringList() << aLCS );
 257
 258   // Dump all model objects to Python script
 259   aRes = aRes && dumpPartitionToPython( aFile, theIsMultiFile, aTreatedObjects, KIND_IMAGE );
 260   aRes = aRes && dumpPartitionToPython( aFile, theIsMultiFile, aTreatedObjects, KIND_STRICKLER_TABLE );
 261   aRes = aRes && dumpPartitionToPython( aFile, theIsMultiFile, aTreatedObjects, KIND_POLYLINEXY );
 262   aRes = aRes && dumpPartitionToPython( aFile, theIsMultiFile, aTreatedObjects, KIND_BATHYMETRY );
 263   aRes = aRes && dumpPartitionToPython( aFile, theIsMultiFile, aTreatedObjects, KIND_PROFILE );
 264   aRes = aRes && dumpPartitionToPython( aFile, theIsMultiFile, aTreatedObjects, KIND_POLYLINE );
 265   aRes = aRes && dumpPartitionToPython( aFile, theIsMultiFile, aTreatedObjects, KIND_IMMERSIBLE_ZONE );
 266   aRes = aRes && dumpPartitionToPython( aFile, theIsMultiFile, aTreatedObjects, KIND_STREAM );
 267   aRes = aRes && dumpPartitionToPython( aFile, theIsMultiFile, aTreatedObjects, KIND_CHANNEL );
 268   aRes = aRes && dumpPartitionToPython( aFile, theIsMultiFile, aTreatedObjects, KIND_DIGUE );
 269   aRes = aRes && dumpPartitionToPython( aFile, theIsMultiFile, aTreatedObjects, KIND_OBSTACLE );
 270   aRes = aRes && dumpPartitionToPython( aFile, theIsMultiFile, aTreatedObjects, KIND_CALCULATION );
 271
 272   // Dump code to close python fuction
 273   if ( aRes && theIsMultiFile )
 274   {
 275     QStringList aFooterScript;
 276     aFooterScript << QString( "" );
 277     aFooterScript << QString( "  pass" );
 278     HYDROData_Tool::WriteStringsToFile( aFile, aFooterScript );
 279   }
 280
 281   return aRes;
 282 }
 283
 284 QString HYDROData_Document::GetDocPyName() const
 285 {
 286   QString aDocName = PYTHON_DOC_NAME;
 287
 288   /*
 289   int aDocId = 1;
 290   if ( DocumentId( this, aDocId ) )
 291     aDocName += "_" + QString::number( aDocId );
 292   */
 293
 294   return aDocName;
 295 }
 296
 297 QStringList HYDROData_Document::DumpToPython( MapOfTreatedObjects& theTreatedObjects,
 298                                               const bool           theIsMultiFile ) const
 299 {
 300   QString aDocName = GetDocPyName();
 301
 302   // Append document in to the map of treated objects to prevent names overlaping
 303   theTreatedObjects.insert( aDocName, this );
 304
 305   int aDocId = 1;
 306   if ( !DocumentId( this, aDocId ) )
 307     aDocId = 1;
 308
 309   QStringList aResScript;
 310
 311   aResScript << QString( "from HYDROPy import *" );
 312   aResScript << QString( "from PyQt4.QtCore import *" );
 313   aResScript << QString( "from PyQt4.QtGui import *" );
 314
 315   if ( theIsMultiFile )
 316   {
 317     aResScript << QString( "import salome" );
 318     aResScript << QString( "" );
 319     aResScript << QString( "def RebuildData( theStudy ):" );
 320     aResScript << QString( "  %1 = HYDROData_Document.Document( theStudy._get_StudyId() );" ).arg( aDocName );
 321   }
 322   else
 323   {
 324     aResScript << QString( "" );
 325     aResScript << QString( "%1 = HYDROData_Document.Document( theStudy._get_StudyId() );" ).arg( aDocName );
 326   }
 327
 328   return aResScript;
 329 }
 330
 331 bool HYDROData_Document::dumpPartitionToPython( QFile&               theFile,
 332                                                 const bool           theIsMultiFile,
 333                                                 MapOfTreatedObjects& theTreatedObjects,
 334                                                 const ObjectKind&    theObjectKind ) const
 335 {
 336   if ( !theFile.isOpen() )
 337     return false;
 338
 339   QTextStream anOutStream( &theFile );
 340
 341   bool aRes = true;
 342
 343   HYDROData_Iterator anIterator( this, theObjectKind );
 344   for( ; anIterator.More(); anIterator.Next() )
 345   {
 346     Handle(HYDROData_Entity) anObject = anIterator.Current();
 347     if ( anObject.IsNull() )
 348       continue;
 349
 350     QString anObjName = anObject->GetName();
 351     if ( theTreatedObjects.contains( anObjName ) )
 352       continue;
 353
 354     theTreatedObjects.insert( anObjName, anObject );
 355
 356     QStringList anObjDump = anObject->DumpToPython( theTreatedObjects );
 357
 358     if ( theIsMultiFile )
 359     {
 360       // For multifile dump we use the function, see the document dump header
 361       QStringList::iterator anIt = anObjDump.begin();
 362       for ( ; anIt != anObjDump.end(); ++anIt )
 363         anIt->prepend( "  " );
 364     }
 365
 366     HYDROData_Tool::WriteStringsToFile( theFile, anObjDump );
 367   }
 368
 369   return aRes;
 370 }
 371
 372 bool takeLastDigits( QString& theStr, int& aRes )
 373 {
 374   aRes = -1;
 375
 376   QString anStrNum;
 377   for ( int i = theStr.length() - 1; i >= 0; --i )
 378   {
 379     const QChar& aChar = theStr.at( i );
 380     if ( !aChar.isDigit() )
 381       break;
 382
 383     anStrNum.prepend( aChar );
 384   }
 385
 386   if ( anStrNum.isEmpty() )
 387     return false;
 388
 389   theStr.remove( theStr.length() - anStrNum.length(), anStrNum.length() );
 390   aRes = anStrNum.toInt();
 391
 392   return true;
 393 }
 394
 395 bool isObjectNameLessThan( const QString& theStr1, const QString& theStr2 )
 396 {
 397   QString aStr1 = theStr1, aStr2 = theStr2;
 398
 399   int aNum1 = -1, aNum2 = -1;
 400   if ( takeLastDigits( aStr1, aNum1 ) && takeLastDigits( aStr2, aNum2 ) )
 401   {
 402     if ( aStr1 == aStr2 )
 403       return aNum1 < aNum2;
 404   }
 405
 406   return theStr1 < theStr2;
 407 }
 408
 409 HYDROData_SequenceOfObjects HYDROData_Document::GetObjectsLayerOrder(
 410   const Standard_Boolean theIsAll ) const
 411 {
 412   HYDROData_SequenceOfObjects anOrder;
 413
 414   MapOfOrdered   aMapOfOrdered;
 415   MapOfUnordered aMapOfUnordered;
 416
 417   HYDROData_Iterator anIter( this );
 418   for ( ; anIter.More(); anIter.Next() )
 419   {
 420     Handle(HYDROData_Entity) anObject = anIter.Current();
 421     if ( anObject.IsNull() || !anObject->IsHas2dPrs() )
 422       continue;
 423
 424     Standard_Integer anObjZLevel = -1;
 425     if ( anObject->GetZLevel( anObjZLevel ) )
 426     {
 427       aMapOfOrdered.insert( anObjZLevel, anObject );
 428     }
 429     else
 430     {
 431       QString anObjName = anObject->GetName();
 432       if ( anObjName.isEmpty() )
 433         continue;
 434
 435       aMapOfUnordered.insert( anObjName, anObject );
 436     }
 437   }
 438
 439   MapOfOrdered::const_iterator anOrderedMapIt = aMapOfOrdered.constBegin();
 440   for ( ; anOrderedMapIt != aMapOfOrdered.constEnd(); anOrderedMapIt++ )
 441   {
 442     const Handle(HYDROData_Entity)& anObject = anOrderedMapIt.value();
 443     anOrder.Prepend( anObject );
 444   }
 445
 446   if ( theIsAll )
 447   {
 448     QStringList aSortedNames = aMapOfUnordered.keys();
 449     qSort( aSortedNames.begin(), aSortedNames.end(), isObjectNameLessThan );
 450
 451     for ( int i = 0; i < aSortedNames.length(); ++i )
 452     {
 453       QString anObjName = aSortedNames.value( i );
 454
 455       const Handle(HYDROData_Entity)& anObject = aMapOfUnordered.value( anObjName );
 456       anOrder.Append( anObject );
 457     }
 458   }
 459
 460   return anOrder;
 461 }
 462
 463 void HYDROData_Document::SetObjectsLayerOrder( const HYDROData_SequenceOfObjects& theOrder )
 464 {
 465   // At first we remove previous model order
 466   RemoveObjectsLayerOrder();
 467
 468   // Make new objects order
 469   Standard_Integer aLevel = 0;
 470   for ( int i = theOrder.Length(), n = 1; i >= n; --i )
 471   {
 472     const Handle(HYDROData_Entity)& anObject = theOrder.Value( i );
 473     if ( anObject.IsNull() || !anObject->IsHas2dPrs() )
 474       continue;
 475
 476     anObject->SetZLevel( aLevel++ );
 477   }
 478 }
 479
 480 void HYDROData_Document::Show( const Handle_HYDROData_Entity& theObject )
 481 {
 482   HYDROData_SequenceOfObjects anOrder;
 483   anOrder.Append( theObject );
 484   Show( anOrder );
 485 }
 486
 487 void HYDROData_Document::Show( const HYDROData_SequenceOfObjects& theObjects )
 488 {
 489   MapOfUnordered aMapOfUnordered;
 490
 491   for ( int i = 1, n = theObjects.Length(); i <= n; ++i )
 492   {
 493     const Handle(HYDROData_Entity)& anObject = theObjects.Value( i );
 494     if ( anObject.IsNull() || !anObject->IsHas2dPrs() )
 495       continue;
 496
 497     Standard_Integer anObjZLevel = -1;
 498     if ( anObject->GetZLevel( anObjZLevel ) )
 499     {
 500       continue; // Skip objects that already have the z-level
 501     }
 502     else
 503     {
 504       QString anObjName = anObject->GetName();
 505       if ( anObjName.isEmpty() )
 506         continue;
 507
 508       aMapOfUnordered.insert( anObjName, anObject );
 509     }
 510   }
 511
 512   if ( aMapOfUnordered.isEmpty() )
 513     return; // Nothing to show
 514
 515   Standard_Integer aTopId = 0;
 516
 517   HYDROData_SequenceOfObjects aModelOrder = GetObjectsLayerOrder( Standard_False );
 518   if ( !aModelOrder.IsEmpty() )
 519   {
 520     const Handle(HYDROData_Entity)& anObject = aModelOrder.First();
 521     anObject->GetZLevel( aTopId );
 522     aTopId++;
 523   }
 524
 525   aTopId += aMapOfUnordered.size() - 1;
 526
 527   QStringList aSortedNames = aMapOfUnordered.keys();
 528   qSort( aSortedNames.begin(), aSortedNames.end(), isObjectNameLessThan );
 529
 530   for ( int i = 0; i < aSortedNames.length(); ++i )
 531   {
 532     QString anObjName = aSortedNames.value( i );
 533
 534     const Handle(HYDROData_Entity)& anObject = aMapOfUnordered.value( anObjName );
 535     anObject->SetZLevel( aTopId-- );
 536   }
 537 }
 538
 539 void HYDROData_Document::RemoveObjectsLayerOrder()
 540 {
 541   HYDROData_Iterator anIter( this );
 542   for ( ; anIter.More(); anIter.Next() )
 543   {
 544     Handle(HYDROData_Entity) anObject = anIter.Current();
 545     if ( anObject.IsNull() || !anObject->IsHas2dPrs() )
 546       continue;
 547
 548     anObject->RemoveZLevel();
 549   }
 550 }
 551
 552 void HYDROData_Document::StartOperation()
 553 {
 554   myDoc->NewCommand();
 555 }
 556
 557 void HYDROData_Document::CommitOperation(const TCollection_ExtendedString& theName)
 558 {
 559   if( !myDoc->CommitCommand() ) // it means that there were no modifications done
 560   {
 561     myDoc->NewCommand();
 562     NewID(); // workaround: do something just to modify the document
 563     myDoc->CommitCommand();
 564   }
 565   myTransactionsAfterSave++;
 566
 567   if( theName.Length() != 0 )
 568   {
 569     const TDF_DeltaList& aList = GetUndos();
 570     if( !aList.IsEmpty() )
 571     {
 572       Handle(TDF_Delta) aDelta = aList.Last();
 573       if( !aDelta.IsNull() )
 574         aDelta->SetName( theName );
 575     }
 576   }
 577 }
 578
 579 void HYDROData_Document::AbortOperation()
 580 {
 581   myDoc->AbortCommand();
 582 }
 583
 584 bool HYDROData_Document::IsOperation()
 585 {
 586   return myDoc->HasOpenCommand() != 0;
 587 }
 588
 589 bool HYDROData_Document::IsModified()
 590 {
 591   return myTransactionsAfterSave != 0;
 592 }
 593
 594 bool HYDROData_Document::CanUndo()
 595 {
 596   return myDoc->GetAvailableUndos() > 0;
 597 }
 598
 599 const TDF_DeltaList& HYDROData_Document::GetUndos()
 600 {
 601   return myDoc->GetUndos();
 602 }
 603
 604 void HYDROData_Document::ClearUndos()
 605 {
 606   return myDoc->ClearUndos();
 607 }
 608
 609 void HYDROData_Document::Undo()
 610 {
 611   myDoc->Undo();
 612   myTransactionsAfterSave--;
 613 }
 614
 615 bool HYDROData_Document::CanRedo()
 616 {
 617   return myDoc->GetAvailableRedos() > 0;
 618 }
 619
 620 const TDF_DeltaList& HYDROData_Document::GetRedos()
 621 {
 622   return myDoc->GetRedos();
 623 }
 624
 625 void HYDROData_Document::ClearRedos()
 626 {
 627   return myDoc->ClearRedos();
 628 }
 629
 630 void HYDROData_Document::Redo()
 631 {
 632   myDoc->Redo();
 633   myTransactionsAfterSave++;
 634 }
 635
 636 Handle(HYDROData_Entity) HYDROData_Document::CreateObject( const ObjectKind theKind )
 637 {
 638   return HYDROData_Iterator::CreateObject( this, theKind );
 639 }
 640
 641 Handle(HYDROData_Entity) HYDROData_Document::FindObjectByName(
 642   const QString&   theName,
 643   const ObjectKind theObjectKind ) const
 644 {
 645   Handle(HYDROData_Entity) anObject;
 646   if ( theName.isEmpty() )
 647     return anObject;
 648
 649   QStringList aNamesList;
 650   aNamesList << theName;
 651
 652   HYDROData_SequenceOfObjects aSeqOfObjs = FindObjectsByNames( aNamesList, theObjectKind );
 653   if( aSeqOfObjs.IsEmpty() )
 654     return anObject;
 655
 656   anObject = aSeqOfObjs.First();
 657   return anObject;
 658 }
 659
 660 HYDROData_SequenceOfObjects HYDROData_Document::FindObjectsByNames(
 661   const QStringList& theNames,
 662   const ObjectKind   theObjectKind ) const
 663 {
 664   HYDROData_SequenceOfObjects aResSeq;
 665
 666   QStringList aNamesList = theNames;
 667
 668   HYDROData_Iterator anIter( this, theObjectKind );
 669   for( ; anIter.More(); anIter.Next() )
 670   {
 671     Handle(HYDROData_Entity) anObject = anIter.Current();
 672     if( anObject.IsNull() )
 673       continue;
 674
 675     QString anObjName = anObject->GetName();
 676     if ( anObjName.isEmpty() || !aNamesList.contains( anObjName ) )
 677       continue;
 678
 679     aResSeq.Append( anObject );
 680
 681     aNamesList.removeAll( anObjName );
 682     if ( aNamesList.isEmpty() )
 683       break;
 684   }
 685
 686   return aResSeq;
 687 }
 688
 689 HYDROData_Document::HYDROData_Document()
 690 {
 691   HYDROData_Application::GetApplication()->NewDocument("BinOcaf", myDoc);
 692   myDoc->SetUndoLimit(UNDO_LIMIT);
 693   NewID(); // needed to have at least one attribute in initial document to avoid errors
 694   myTransactionsAfterSave = 0;
 695   myLX = -1;
 696   myLY = -1;
 697
 698   myInterpolatorsFactory = 0;
 699 }
 700
 701 HYDROData_Document::HYDROData_Document(const Handle(TDocStd_Document)& theDoc)
 702 {
 703   myDoc = theDoc;
 704   myTransactionsAfterSave = 0;
 705   myLX = -1;
 706   myLY = -1;
 707
 708   myInterpolatorsFactory = 0;
 709 }
 710
 711 HYDROData_Document::~HYDROData_Document()
 712 {
 713 }
 714
 715 int HYDROData_Document::NewID()
 716 {
 717   TDF_Label anIDLab = myDoc->Main().FindChild(TAG_PROPS).
 718     FindChild(TAG_PROPS_NEW_ID);
 719   Handle(TDataStd_Integer) anInt;
 720   if (!anIDLab.FindAttribute(TDataStd_Integer::GetID(), anInt)) {
 721     anInt = TDataStd_Integer::Set(anIDLab, 0);
 722   }
 723   // just increment value and return
 724   anInt->Set(anInt->Get() + 1);
 725   return anInt->Get();
 726 }
 727
 728 TDF_Label HYDROData_Document::LabelOfObjects()
 729 {
 730   return myDoc->Main().FindChild(TAG_OBJECTS);
 731 }
 732
 733 TDF_Label HYDROData_Document::LabelOfLocalCS() const
 734 {
 735   return myDoc->Main().FindChild(TAG_LOCAL_CS);
 736 }
 737
 738 void HYDROData_Document::GetLocalCS( double& theLX, double& theLY ) const
 739 {
 740   TDF_Label aLocalCSLab = LabelOfLocalCS();
 741
 742   Handle( TDataXtd_Position ) aLocalCS;
 743   if( aLocalCSLab.FindAttribute( TDataXtd_Position::GetID(), aLocalCS ) )
 744   {
 745     gp_Pnt aLocalCS3d = aLocalCS->GetPosition();
 746     theLX = aLocalCS3d.X();
 747     theLY = aLocalCS3d.Y();
 748   }
 749   else
 750   {
 751     theLX = DEFAULT_LOCAL_CS.X();
 752     theLY = DEFAULT_LOCAL_CS.Y();
 753   }
 754 }
 755
 756 void HYDROData_Document::SetLocalCS( double theLX, double theLY )
 757 {
 758   UpdateLCSFields();
 759
 760   // update the local CS data in attribute
 761   TDF_Label aLocalCSLab = LabelOfLocalCS();
 762   Handle( TDataXtd_Position ) aLocalCS;
 763   if( !aLocalCSLab.FindAttribute( TDataXtd_Position::GetID(), aLocalCS ) )
 764     aLocalCS = TDataXtd_Position::Set( aLocalCSLab );
 765
 766   gp_Pnt aLocalCS3d( theLX, theLY, 0 );
 767   aLocalCS->SetPosition( aLocalCS3d );
 768
 769   // calculate delta for coordinates
 770   double aDX = myLX - theLX;
 771   double aDY = myLY - theLY;
 772
 773   // update the local CS data in internal fields
 774   myLX = theLX;
 775   myLY = theLY;
 776
 777   //update all objects in the document
 778   HYDROData_Iterator anIterator( this, KIND_UNKNOWN );
 779   for( ; anIterator.More(); anIterator.Next() )
 780     anIterator.Current()->UpdateLocalCS( aDX, aDY );
 781 }
 782
 783 void HYDROData_Document::UpdateLCSFields() const
 784 {
 785   if( myLX >= 0 && myLY >= 0 )
 786     return;
 787
 788   double aLX, aLY;
 789   GetLocalCS( aLX, aLY );
 790   HYDROData_Document* aThat = const_cast<HYDROData_Document*>( this );
 791   aThat->myLX = aLX;
 792   aThat->myLY = aLY;
 793 }
 794
 795 void HYDROData_Document::Transform( double& X, double& Y, bool IsToLocalCS ) const
 796 {
 797   UpdateLCSFields();
 798   if( IsToLocalCS )
 799   {
 800     X -= myLX;
 801     Y -= myLY;
 802   }
 803   else
 804   {
 805     X += myLX;
 806     Y += myLY;
 807   }
 808 }
 809
 810 void HYDROData_Document::Transform( gp_Pnt& thePnt, bool IsToLocalCS ) const
 811 {
 812   double X = thePnt.X();
 813   double Y = thePnt.Y();
 814   double Z = thePnt.Z();
 815   Transform( X, Y, IsToLocalCS );
 816   thePnt = gp_Pnt( X, Y, Z );
 817 }
 818
 819 void HYDROData_Document::Transform( gp_XYZ& thePnt, bool IsToLocalCS ) const
 820 {
 821   double X = thePnt.X();
 822   double Y = thePnt.Y();
 823   double Z = thePnt.Z();
 824   Transform( X, Y, IsToLocalCS );
 825   thePnt = gp_XYZ( X, Y, Z );
 826 }
 827
 828 void HYDROData_Document::Transform( gp_XY& thePnt, bool IsToLocalCS ) const
 829 {
 830   double X = thePnt.X();
 831   double Y = thePnt.Y();
 832   Transform( X, Y, IsToLocalCS );
 833   thePnt = gp_XY( X, Y );
 834 }
 835
 836 HYDROData_InterpolatorsFactory* HYDROData_Document::GetInterpolatorsFactory()
 837 {
 838   if ( !myInterpolatorsFactory ) {
 839     myInterpolatorsFactory = new HYDROData_InterpolatorsFactory();
 840   }
 841
 842   return myInterpolatorsFactory;
 843 }
 844
 845 HYDROData_IProfilesInterpolator* HYDROData_Document::GetInterpolator( const TCollection_AsciiString& theName ) const
 846 {
 847   HYDROData_IProfilesInterpolator* anInterpolator = NULL;
 848
 849   HYDROData_Document* aThat = const_cast<HYDROData_Document*>( this );
 850   HYDROData_InterpolatorsFactory* aFactory = aThat->GetInterpolatorsFactory();
 851   if ( aFactory ) {
 852     anInterpolator = aFactory->GetInterpolator( theName );
 853   }
 854
 855   return anInterpolator;
 856 }
 857
 858 NCollection_Sequence<TCollection_AsciiString> HYDROData_Document::GetInterpolatorNames() const
 859 {
 860   NCollection_Sequence<TCollection_AsciiString> aNames;
 861
 862   HYDROData_Document* aThat = const_cast<HYDROData_Document*>( this );
 863   HYDROData_InterpolatorsFactory* aFactory = aThat->GetInterpolatorsFactory();
 864   if ( aFactory ) {
 865     aNames = aFactory->GetInterpolatorNames();
 866   }
 867
 868   return aNames;
 869 }