X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROData%2FHYDROData_Document.cxx;h=7d1a12552c9a37fe957777ba17e695a4e2625949;hb=deed826b2d6c39ba2ed410108cdf54d64cded321;hp=3960c4a4f3d545dceaf7e599220713ae636bc56f;hpb=2728f2367cc657e6a4c900ca221263ee9add26fd;p=modules%2Fhydro.git

diff --git a/src/HYDROData/HYDROData_Document.cxx b/src/HYDROData/HYDROData_Document.cxx
index 3960c4a4..7d1a1255 100644
--- a/src/HYDROData/HYDROData_Document.cxx
+++ b/src/HYDROData/HYDROData_Document.cxx
@@ -1,12 +1,22 @@
+
 #include <HYDROData_Document.h>
 #include <HYDROData_Application.h>
 #include <HYDROData_Iterator.h>
+#include <HYDROData_Tool.h>
 
 #include <TDataStd_Integer.hxx>
 
+#include <TDF_Delta.hxx>
+
+#include <QFile>
+#include <QStringList>
+#include <QTextStream>
+
 IMPLEMENT_STANDARD_HANDLE(HYDROData_Document,MMgt_TShared)
 IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Document,MMgt_TShared)
 
+#define PYTHON_DOC_NAME "doc"
+
 static const int UNDO_LIMIT = 10; // number of possible undo operations in the module
 
 static const int TAG_PROPS = 1; // general properties tag
@@ -27,6 +37,41 @@ Handle(HYDROData_Document) HYDROData_Document::Document(const int theStudyID)
   return aResult;
 }
 
+Handle(HYDROData_Document) HYDROData_Document::Document(
+  const TDF_Label& theObjectLabel )
+{
+  Handle(HYDROData_Document) aResDoc;
+  if ( theObjectLabel.IsNull() )
+    return aResDoc;
+
+  Handle(TDocStd_Document) anObjDoc;
+  try
+  {
+    anObjDoc = TDocStd_Document::Get( theObjectLabel );
+  }
+  catch( ... )
+  {
+  }
+
+  if ( anObjDoc.IsNull() )
+    return aResDoc;
+
+  HYDROData_Application* anApp = HYDROData_Application::GetApplication();
+
+  DataMapOfStudyIDDocument::Iterator aMapIt( anApp->myDocuments );
+  for ( ; aMapIt.More(); aMapIt.Next() )
+  {
+    Handle(HYDROData_Document) anAppDoc = aMapIt.Value();
+    if ( anAppDoc.IsNull() || anAppDoc->myDoc != anObjDoc )
+      continue;
+
+    aResDoc = anAppDoc;
+    break;
+  }
+
+  return aResDoc;
+}
+
 bool HYDROData_Document::HasDocument(const int theStudyID)
 {
   Handle(HYDROData_Document) aResult = 
@@ -34,6 +79,12 @@ bool HYDROData_Document::HasDocument(const int theStudyID)
   return !aResult.IsNull();
 }
 
+bool HYDROData_Document::DocumentId(const Handle(HYDROData_Document)& theDocument,
+                                    int&                              theDocId )
+{
+  return HYDROData_Application::GetApplication()->GetDocumentId(theDocument, theDocId);
+}
+
 Data_DocError HYDROData_Document::Load(const char* theFileName, const int theStudyID)
 {
   Handle(TDocStd_Document) aResult;
@@ -124,15 +175,125 @@ void HYDROData_Document::Close()
   HYDROData_Application::GetApplication()->RemoveDocument(this);
 }
 
+bool HYDROData_Document::DumpToPython( const QString& theFileName ) const
+{
+  // Try to open the file
+  QFile aFile( theFileName );
+  if ( !aFile.open( QIODevice::WriteOnly ) )
+    return false;
+
+  MapOfTreatedObjects aTreatedObjects;
+
+  // Dump header for python script
+  QStringList aHeaderDump = DumpToPython( aTreatedObjects );
+  if ( aHeaderDump.isEmpty() )
+    return false;
+
+  HYDROData_Tool::WriteStringsToFile( aFile, aHeaderDump );
+
+  bool aRes = true;
+
+  // Dump all model objects to Python script
+  aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_IMAGE      );
+  aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_POLYLINE   );
+  aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_BATHYMETRY );
+  aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_ALTITUDE );
+  aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_IMMERSIBLE_ZONE );
+  aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_CALCULATION );
+
+  return aRes;
+}
+
+QString HYDROData_Document::GetDocPyName() const
+{
+  QString aDocName = PYTHON_DOC_NAME;
+  
+  int aDocId = 1;
+  if ( DocumentId( this, aDocId ) )
+    aDocName += "_" + QString::number( aDocId );
+  
+  return aDocName;
+}
+
+QStringList HYDROData_Document::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const
+{
+  QString aDocName = GetDocPyName();
+
+  // Append document in to the map of treated objects to prevent names overlaping
+  theTreatedObjects.insert( aDocName, this );
+
+  int aDocId = 1;
+  if ( !DocumentId( this, aDocId ) )
+    aDocId = 1;
+
+  QStringList aResScript;
+
+  aResScript << QString( "from HYDROData import *" );
+  aResScript << QString( "from PyQt4.QtCore import *" );
+  aResScript << QString( "from PyQt4.QtGui import *" );
+  aResScript << QString( "" );
+  aResScript << QString( "%1 = HYDROData_Document.Document( %2 );" ).arg( aDocName ).arg( aDocId );
+
+  return aResScript;
+}
+
+bool HYDROData_Document::dumpPartitionToPython( QFile&               theFile,
+                                                MapOfTreatedObjects& theTreatedObjects,
+                                                const ObjectKind&    theObjectKind ) const
+{
+  if ( !theFile.isOpen() )
+    return false;
+
+  QTextStream anOutStream( &theFile );
+
+  bool aRes = true;
+
+  HYDROData_Iterator anIterator( this, theObjectKind );
+  for( ; anIterator.More(); anIterator.Next() )
+  {
+    Handle(HYDROData_Entity) anObject = anIterator.Current();
+    if ( anObject.IsNull() )
+      continue;
+
+    QString anObjName = anObject->GetName();
+    if ( theTreatedObjects.contains( anObjName ) )
+      continue;
+
+    theTreatedObjects.insert( anObjName, anObject );
+
+    QStringList anObjDump = anObject->DumpToPython( theTreatedObjects );
+    
+    HYDROData_Tool::WriteStringsToFile( theFile, anObjDump );
+  }
+  
+  return aRes;
+}
+
 void HYDROData_Document::StartOperation()
 {
   myDoc->NewCommand();
 }
 
-void HYDROData_Document::CommitOperation()
+void HYDROData_Document::CommitOperation(const TCollection_ExtendedString& theName)
 {
-  myDoc->CommitCommand();
+  if( !myDoc->CommitCommand() ) // it means that there were no modifications done
+  {
+    myDoc->NewCommand();
+    NewID(); // workaround: do something just to modify the document
+    myDoc->CommitCommand();
+  }
   myTransactionsAfterSave++;
+
+  if( theName.Length() != 0 )
+  {
+    const TDF_DeltaList& aList = GetUndos();
+    if( !aList.IsEmpty() )
+    {
+      Handle(TDF_Delta) aDelta = aList.Last();
+      if( !aDelta.IsNull() )
+        aDelta->SetName( theName );
+    }
+  }
 }
 
 void HYDROData_Document::AbortOperation()
@@ -155,6 +316,16 @@ bool HYDROData_Document::CanUndo()
   return myDoc->GetAvailableUndos() > 0;
 }
 
+const TDF_DeltaList& HYDROData_Document::GetUndos()
+{
+  return myDoc->GetUndos();
+}
+
+void HYDROData_Document::ClearUndos()
+{
+  return myDoc->ClearUndos();
+}
+
 void HYDROData_Document::Undo()
 {
   myDoc->Undo();
@@ -166,13 +337,23 @@ bool HYDROData_Document::CanRedo()
   return myDoc->GetAvailableRedos() > 0;
 }
 
+const TDF_DeltaList& HYDROData_Document::GetRedos()
+{
+  return myDoc->GetRedos();
+}
+
+void HYDROData_Document::ClearRedos()
+{
+  return myDoc->ClearRedos();
+}
+
 void HYDROData_Document::Redo()
 {
   myDoc->Redo();
   myTransactionsAfterSave++;
 }
 
-Handle_HYDROData_Object HYDROData_Document::CreateObject(const ObjectKind theKind)
+Handle(HYDROData_Entity) HYDROData_Document::CreateObject(const ObjectKind theKind)
 {
   return HYDROData_Iterator::CreateObject(this, theKind);
 }