]> SALOME platform Git repositories - modules/hydro.git/blob - src/HYDROData/HYDROData_Document.cxx
Salome HOME
The data model has been redesigned to new format.
[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 Handle(HYDROData_Entity)& theObject )
42 {
43   Handle(HYDROData_Document) aResDoc;
44   if ( theObject.IsNull() )
45     return aResDoc;
46
47   Handle(TDocStd_Document) anObjDoc;
48   try
49   {
50     anObjDoc = TDocStd_Document::Get( theObject->Label() );
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_POLYLINE   );
199   aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_BATHYMETRY );
200   aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_IMMERSIBLE_ZONE );
201   aRes = aRes && dumpPartitionToPython( aFile, aTreatedObjects, KIND_CALCULATION );
202
203   return aRes;
204 }
205
206 QString HYDROData_Document::GetDocPyName() const
207 {
208   QString aDocName = PYTHON_DOC_NAME;
209   
210   int aDocId = 1;
211   if ( DocumentId( this, aDocId ) )
212     aDocName += "_" + QString::number( aDocId );
213   
214   return aDocName;
215 }
216
217 QStringList HYDROData_Document::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const
218 {
219   QString aDocName = GetDocPyName();
220
221   // Append document in to the map of treated objects to prevent names overlaping
222   theTreatedObjects.insert( aDocName, this );
223
224   int aDocId = 1;
225   if ( !DocumentId( this, aDocId ) )
226     aDocId = 1;
227
228   QStringList aResScript;
229
230   aResScript << QString( "from HYDROData import *" );
231   aResScript << QString( "from PyQt4.QtCore import *" );
232   aResScript << QString( "from PyQt4.QtGui import *" );
233   aResScript << QString( "" );
234   aResScript << QString( "%1 = HYDROData_Document.Document( %2 );" ).arg( aDocName ).arg( aDocId );
235
236   return aResScript;
237 }
238
239 bool HYDROData_Document::dumpPartitionToPython( QFile&               theFile,
240                                                 MapOfTreatedObjects& theTreatedObjects,
241                                                 const ObjectKind&    theObjectKind ) const
242 {
243   if ( !theFile.isOpen() )
244     return false;
245
246   QTextStream anOutStream( &theFile );
247
248   bool aRes = true;
249
250   HYDROData_Iterator anIterator( this, theObjectKind );
251   for( ; anIterator.More(); anIterator.Next() )
252   {
253     Handle(HYDROData_Entity) anObject = anIterator.Current();
254     if ( anObject.IsNull() )
255       continue;
256
257     QString anObjName = anObject->GetName();
258     if ( theTreatedObjects.contains( anObjName ) )
259       continue;
260
261     theTreatedObjects.insert( anObjName, anObject );
262
263     QStringList anObjDump = anObject->DumpToPython( theTreatedObjects );
264     
265     HYDROData_Tool::WriteStringsToFile( theFile, anObjDump );
266   }
267   
268   return aRes;
269 }
270
271 void HYDROData_Document::StartOperation()
272 {
273   myDoc->NewCommand();
274 }
275
276 void HYDROData_Document::CommitOperation(const TCollection_ExtendedString& theName)
277 {
278   if( !myDoc->CommitCommand() ) // it means that there were no modifications done
279   {
280     myDoc->NewCommand();
281     NewID(); // workaround: do something just to modify the document
282     myDoc->CommitCommand();
283   }
284   myTransactionsAfterSave++;
285
286   if( theName.Length() != 0 )
287   {
288     const TDF_DeltaList& aList = GetUndos();
289     if( !aList.IsEmpty() )
290     {
291       Handle(TDF_Delta) aDelta = aList.Last();
292       if( !aDelta.IsNull() )
293         aDelta->SetName( theName );
294     }
295   }
296 }
297
298 void HYDROData_Document::AbortOperation()
299 {
300   myDoc->AbortCommand();
301 }
302
303 bool HYDROData_Document::IsOperation()
304 {
305   return myDoc->HasOpenCommand() != 0;
306 }
307
308 bool HYDROData_Document::IsModified()
309 {
310   return myTransactionsAfterSave != 0;
311 }
312
313 bool HYDROData_Document::CanUndo()
314 {
315   return myDoc->GetAvailableUndos() > 0;
316 }
317
318 const TDF_DeltaList& HYDROData_Document::GetUndos()
319 {
320   return myDoc->GetUndos();
321 }
322
323 void HYDROData_Document::ClearUndos()
324 {
325   return myDoc->ClearUndos();
326 }
327
328 void HYDROData_Document::Undo()
329 {
330   myDoc->Undo();
331   myTransactionsAfterSave--;
332 }
333
334 bool HYDROData_Document::CanRedo()
335 {
336   return myDoc->GetAvailableRedos() > 0;
337 }
338
339 const TDF_DeltaList& HYDROData_Document::GetRedos()
340 {
341   return myDoc->GetRedos();
342 }
343
344 void HYDROData_Document::ClearRedos()
345 {
346   return myDoc->ClearRedos();
347 }
348
349 void HYDROData_Document::Redo()
350 {
351   myDoc->Redo();
352   myTransactionsAfterSave++;
353 }
354
355 Handle(HYDROData_Entity) HYDROData_Document::CreateObject(const ObjectKind theKind)
356 {
357   return HYDROData_Iterator::CreateObject(this, theKind);
358 }
359
360 HYDROData_Document::HYDROData_Document()
361 {
362   HYDROData_Application::GetApplication()->NewDocument("BinOcaf", myDoc);
363   myDoc->SetUndoLimit(UNDO_LIMIT);
364   NewID(); // needed to have at least one attribute in initial document to avoid errors
365   myTransactionsAfterSave = 0;
366 }
367
368 HYDROData_Document::HYDROData_Document(const Handle(TDocStd_Document)& theDoc)
369 {
370   myDoc = theDoc;
371   myTransactionsAfterSave = 0;
372 }
373
374 HYDROData_Document::~HYDROData_Document()
375 {
376 }
377
378 int HYDROData_Document::NewID()
379 {
380   TDF_Label anIDLab = myDoc->Main().FindChild(TAG_PROPS).
381     FindChild(TAG_PROPS_NEW_ID);
382   Handle(TDataStd_Integer) anInt;
383   if (!anIDLab.FindAttribute(TDataStd_Integer::GetID(), anInt)) {
384     anInt = TDataStd_Integer::Set(anIDLab, 0);
385   }
386   // just increment value and return
387   anInt->Set(anInt->Get() + 1);
388   return anInt->Get();
389 }
390
391 TDF_Label HYDROData_Document::LabelOfObjects()
392 {
393   return myDoc->Main().FindChild(TAG_OBJECTS);
394 }