]> SALOME platform Git repositories - modules/hydro.git/blob - src/HYDROData/HYDROData_Document.cxx
Salome HOME
Python module name corrected.
[modules/hydro.git] / src / HYDROData / HYDROData_Document.cxx
1
2 #include <HYDROData_Document.h>
3 #include <HYDROData_Application.h>
4 #include <HYDROData_Iterator.h>
5 #include <HYDROData_Tool.h>
6
7 #include <TDataStd_Integer.hxx>
8
9 #include <TDF_Delta.hxx>
10
11 #include <QFile>
12 #include <QStringList>
13 #include <QTextStream>
14
15 IMPLEMENT_STANDARD_HANDLE(HYDROData_Document,MMgt_TShared)
16 IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Document,MMgt_TShared)
17
18 #define PYTHON_DOC_NAME "doc"
19
20 static const int UNDO_LIMIT = 10; // number of possible undo operations in the module
21
22 static const int TAG_PROPS = 1; // general properties tag
23 static const int TAG_PROPS_NEW_ID = 1; // general properties: tag for storage of the new object ID
24 static const int TAG_OBJECTS = 2; // tag of the objects sub-tree
25 static const int TAG_HISTORY = 3; // tag of the history sub-tree (Root for History)
26
27 using namespace std;
28
29 Handle(HYDROData_Document) HYDROData_Document::Document(const int theStudyID)
30 {
31   Handle(HYDROData_Document) aResult = 
32     HYDROData_Application::GetApplication()->GetDocument(theStudyID);
33   if (aResult.IsNull()) {
34     aResult = new HYDROData_Document();
35     HYDROData_Application::GetApplication()->AddDocument(theStudyID, aResult);
36   }
37   return aResult;
38 }
39
40 Handle(HYDROData_Document) HYDROData_Document::Document(
41   const TDF_Label& theObjectLabel )
42 {
43   Handle(HYDROData_Document) aResDoc;
44   if ( theObjectLabel.IsNull() )
45     return aResDoc;
46
47   Handle(TDocStd_Document) anObjDoc;
48   try
49   {
50     anObjDoc = TDocStd_Document::Get( theObjectLabel );
51   }
52   catch( ... )
53   {
54   }
55
56   if ( anObjDoc.IsNull() )
57     return aResDoc;
58
59   HYDROData_Application* anApp = HYDROData_Application::GetApplication();
60
61   DataMapOfStudyIDDocument::Iterator aMapIt( anApp->myDocuments );
62   for ( ; aMapIt.More(); aMapIt.Next() )
63   {
64     Handle(HYDROData_Document) anAppDoc = aMapIt.Value();
65     if ( anAppDoc.IsNull() || anAppDoc->myDoc != anObjDoc )
66       continue;
67
68     aResDoc = anAppDoc;
69     break;
70   }
71
72   return aResDoc;
73 }
74
75 bool HYDROData_Document::HasDocument(const int theStudyID)
76 {
77   Handle(HYDROData_Document) aResult = 
78     HYDROData_Application::GetApplication()->GetDocument(theStudyID);
79   return !aResult.IsNull();
80 }
81
82 bool HYDROData_Document::DocumentId(const Handle(HYDROData_Document)& theDocument,
83                                     int&                              theDocId )
84 {
85   return HYDROData_Application::GetApplication()->GetDocumentId(theDocument, theDocId);
86 }
87
88 Data_DocError HYDROData_Document::Load(const char* theFileName, const int theStudyID)
89 {
90   Handle(TDocStd_Document) aResult;
91   TCollection_ExtendedString aPath ((const Standard_CString)theFileName);
92   PCDM_ReaderStatus aStatus = (PCDM_ReaderStatus) -1;
93   try
94   {
95     aStatus = HYDROData_Application::GetApplication()->Open (aPath, aResult);
96   }
97   catch (Standard_Failure)
98   {}
99   if (!aResult.IsNull()) {
100     aResult->SetUndoLimit(UNDO_LIMIT);
101     HYDROData_Application::GetApplication()->AddDocument(theStudyID, new HYDROData_Document(aResult));
102   }
103   // recognize error
104   Data_DocError anError;
105   switch(aStatus) {
106   case PCDM_RS_OK:
107     anError = DocError_OK;
108     break;
109   case PCDM_RS_NoDriver:
110   case PCDM_RS_UnknownFileDriver:
111   case PCDM_RS_NoSchema:
112   case PCDM_RS_DriverFailure:
113   case PCDM_RS_WrongResource:
114     anError = DocError_ResourcesProblem;
115     break;
116   case PCDM_RS_OpenError:
117   case PCDM_RS_NoDocument:
118   case PCDM_RS_WrongStreamMode:
119   case PCDM_RS_PermissionDenied:
120     anError = DocError_CanNotOpen;
121     break;
122   case PCDM_RS_NoVersion:
123     anError = DocError_InvalidVersion;
124     break;
125   case PCDM_RS_ExtensionFailure:
126   case PCDM_RS_FormatFailure:
127   case PCDM_RS_TypeFailure:
128   case PCDM_RS_TypeNotFoundInSchema:
129   case PCDM_RS_UnrecognizedFileFormat:
130     anError = DocError_InvalidFormat;
131     break;
132   case PCDM_RS_MakeFailure:
133   default:
134     anError = DocError_UnknownProblem;
135     break;
136   }
137   return anError;
138 }
139
140 Data_DocError HYDROData_Document::Save(const char* theFileName)
141 {
142   TCollection_ExtendedString aPath ((const Standard_CString)theFileName);
143   PCDM_StoreStatus aStatus;
144   try {
145     aStatus = HYDROData_Application::GetApplication()->SaveAs (myDoc, aPath);
146   }
147   catch (Standard_Failure) {}
148   myTransactionsAfterSave = 0;
149   Standard::Purge(); // Release free memory
150
151   // recognize error
152   Data_DocError anError;
153   switch(aStatus) {
154   case PCDM_SS_OK:
155     anError = DocError_OK;
156     break;
157   case PCDM_SS_DriverFailure:
158     anError = DocError_ResourcesProblem;
159     break;
160   case PCDM_SS_WriteFailure:
161   //case PCDM_SS_DiskWritingFailure:
162   //case PCDM_SS_UserRightsFailure:
163     anError = DocError_CanNotOpen;
164     break;
165   default:
166     anError = DocError_UnknownProblem;
167     break;
168   }
169   return anError;
170 }
171
172 void HYDROData_Document::Close()
173 {
174   myDoc->Close();
175   HYDROData_Application::GetApplication()->RemoveDocument(this);
176 }
177
178 bool HYDROData_Document::DumpToPython( const QString& theFileName ) const
179 {
180   // Try to open the file
181   QFile aFile( theFileName );
182   if ( !aFile.open( QIODevice::WriteOnly ) )
183     return false;
184
185   MapOfTreatedObjects aTreatedObjects;
186
187   // Dump header for python script
188   QStringList aHeaderDump = DumpToPython( aTreatedObjects );
189   if ( aHeaderDump.isEmpty() )
190     return false;
191
192   HYDROData_Tool::WriteStringsToFile( aFile, aHeaderDump );
193
194   bool aRes = true;
195
196   // Dump all model objects to Python script
197   aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_IMAGE );
198   aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_BATHYMETRY );
199   aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_ARTIFICIAL_OBJECT );
200   aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_NATURAL_OBJECT );
201   aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_OBSTACLE );
202   aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_CALCULATION );
203   aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_POLYLINE );
204   aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_PROFILE );
205   aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_ALTITUDE );
206   return aRes;
207 }
208
209 QString HYDROData_Document::GetDocPyName() const
210 {
211   QString aDocName = PYTHON_DOC_NAME;
212   
213   int aDocId = 1;
214   if ( DocumentId( this, aDocId ) )
215     aDocName += "_" + QString::number( aDocId );
216   
217   return aDocName;
218 }
219
220 QStringList HYDROData_Document::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const
221 {
222   QString aDocName = GetDocPyName();
223
224   // Append document in to the map of treated objects to prevent names overlaping
225   theTreatedObjects.insert( aDocName, this );
226
227   int aDocId = 1;
228   if ( !DocumentId( this, aDocId ) )
229     aDocId = 1;
230
231   QStringList aResScript;
232
233   aResScript << QString( "from HYDROpy import *" );
234   aResScript << QString( "from PyQt4.QtCore import *" );
235   aResScript << QString( "from PyQt4.QtGui import *" );
236   aResScript << QString( "" );
237   aResScript << QString( "%1 = HYDROData_Document.Document( %2 );" ).arg( aDocName ).arg( aDocId );
238
239   return aResScript;
240 }
241
242 bool HYDROData_Document::dumpPartitionToPython( QFile&               theFile,
243                                                 MapOfTreatedObjects& theTreatedObjects,
244                                                 const ObjectKind&    theObjectKind ) const
245 {
246   if ( !theFile.isOpen() )
247     return false;
248
249   QTextStream anOutStream( &theFile );
250
251   bool aRes = true;
252
253   HYDROData_Iterator anIterator( this, theObjectKind );
254   for( ; anIterator.More(); anIterator.Next() )
255   {
256     Handle(HYDROData_Entity) anObject = anIterator.Current();
257     if ( anObject.IsNull() )
258       continue;
259
260     QString anObjName = anObject->GetName();
261     if ( theTreatedObjects.contains( anObjName ) )
262       continue;
263
264     theTreatedObjects.insert( anObjName, anObject );
265
266     QStringList anObjDump = anObject->DumpToPython( theTreatedObjects );
267     
268     HYDROData_Tool::WriteStringsToFile( theFile, anObjDump );
269   }
270   
271   return aRes;
272 }
273
274 void HYDROData_Document::StartOperation()
275 {
276   myDoc->NewCommand();
277 }
278
279 void HYDROData_Document::CommitOperation(const TCollection_ExtendedString& theName)
280 {
281   if( !myDoc->CommitCommand() ) // it means that there were no modifications done
282   {
283     myDoc->NewCommand();
284     NewID(); // workaround: do something just to modify the document
285     myDoc->CommitCommand();
286   }
287   myTransactionsAfterSave++;
288
289   if( theName.Length() != 0 )
290   {
291     const TDF_DeltaList& aList = GetUndos();
292     if( !aList.IsEmpty() )
293     {
294       Handle(TDF_Delta) aDelta = aList.Last();
295       if( !aDelta.IsNull() )
296         aDelta->SetName( theName );
297     }
298   }
299 }
300
301 void HYDROData_Document::AbortOperation()
302 {
303   myDoc->AbortCommand();
304 }
305
306 bool HYDROData_Document::IsOperation()
307 {
308   return myDoc->HasOpenCommand() != 0;
309 }
310
311 bool HYDROData_Document::IsModified()
312 {
313   return myTransactionsAfterSave != 0;
314 }
315
316 bool HYDROData_Document::CanUndo()
317 {
318   return myDoc->GetAvailableUndos() > 0;
319 }
320
321 const TDF_DeltaList& HYDROData_Document::GetUndos()
322 {
323   return myDoc->GetUndos();
324 }
325
326 void HYDROData_Document::ClearUndos()
327 {
328   return myDoc->ClearUndos();
329 }
330
331 void HYDROData_Document::Undo()
332 {
333   myDoc->Undo();
334   myTransactionsAfterSave--;
335 }
336
337 bool HYDROData_Document::CanRedo()
338 {
339   return myDoc->GetAvailableRedos() > 0;
340 }
341
342 const TDF_DeltaList& HYDROData_Document::GetRedos()
343 {
344   return myDoc->GetRedos();
345 }
346
347 void HYDROData_Document::ClearRedos()
348 {
349   return myDoc->ClearRedos();
350 }
351
352 void HYDROData_Document::Redo()
353 {
354   myDoc->Redo();
355   myTransactionsAfterSave++;
356 }
357
358 Handle(HYDROData_Entity) HYDROData_Document::CreateObject(const ObjectKind theKind)
359 {
360   return HYDROData_Iterator::CreateObject(this, theKind);
361 }
362
363 HYDROData_Document::HYDROData_Document()
364 {
365   HYDROData_Application::GetApplication()->NewDocument("BinOcaf", myDoc);
366   myDoc->SetUndoLimit(UNDO_LIMIT);
367   NewID(); // needed to have at least one attribute in initial document to avoid errors
368   myTransactionsAfterSave = 0;
369 }
370
371 HYDROData_Document::HYDROData_Document(const Handle(TDocStd_Document)& theDoc)
372 {
373   myDoc = theDoc;
374   myTransactionsAfterSave = 0;
375 }
376
377 HYDROData_Document::~HYDROData_Document()
378 {
379 }
380
381 int HYDROData_Document::NewID()
382 {
383   TDF_Label anIDLab = myDoc->Main().FindChild(TAG_PROPS).
384     FindChild(TAG_PROPS_NEW_ID);
385   Handle(TDataStd_Integer) anInt;
386   if (!anIDLab.FindAttribute(TDataStd_Integer::GetID(), anInt)) {
387     anInt = TDataStd_Integer::Set(anIDLab, 0);
388   }
389   // just increment value and return
390   anInt->Set(anInt->Get() + 1);
391   return anInt->Get();
392 }
393
394 TDF_Label HYDROData_Document::LabelOfObjects()
395 {
396   return myDoc->Main().FindChild(TAG_OBJECTS);
397 }