]> SALOME platform Git repositories - modules/hydro.git/blob - src/HYDROPy/HYDROData_Document.sip
Salome HOME
refs# 1917 + protection against null shapes wires in GetMiddlePoint()
[modules/hydro.git] / src / HYDROPy / HYDROData_Document.sip
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 %ExportedHeaderCode
20 #include <HYDROData_Document.h>
21 %End
22
23 %ModuleHeaderCode
24 HYDROData_Entity* copyObject( HYDROData_Entity* theObject );
25 Handle(HYDROData_Entity) createHandle( HYDROData_Entity* theObject );
26 HYDROData_Entity* createPointer( const Handle(HYDROData_Entity)& theObject );
27 %End
28
29 enum Data_DocError {
30   DocError_OK = 0, ///< success
31   DocError_ResourcesProblem, ///< resources files are invalid or not found
32   DocError_CanNotOpen, ///< can not open file for reading or writing
33   DocError_InvalidVersion, ///< version of document is different than expected
34   DocError_InvalidFormat, ///< format of the document is bad
35   DocError_UnknownProblem ///< problem has unknown nature
36 };
37
38 class HYDROData_Document 
39 {
40 %TypeHeaderCode
41 #include <HYDROData_Document.h>
42 %End
43
44 %ConvertToSubClassCode
45     HYDROData_Document* aDoc = dynamic_cast< HYDROData_Document*>( sipCpp );
46     if ( aDoc )
47       sipClass = sipClass_HYDROData_Document;
48     else
49       sipClass = NULL;
50 %End
51
52 %TypeCode
53
54   HYDROData_Entity* copyObject( HYDROData_Entity* theObject )
55   {
56     HYDROData_Entity* aRes = NULL;
57     if ( theObject == NULL )
58       return aRes;
59
60     switch( theObject->GetKind() )
61     {
62       case KIND_IMAGE:
63       {
64         aRes = new HYDROData_Image( *dynamic_cast<HYDROData_Image*>( theObject ) );
65         break;
66       }
67       case KIND_POLYLINE:
68       {
69         aRes = new HYDROData_Polyline3D( *dynamic_cast<HYDROData_Polyline3D*>( theObject ) );
70         break;
71       }
72       case KIND_BATHYMETRY:
73       {
74         aRes = new HYDROData_Bathymetry( *dynamic_cast<HYDROData_Bathymetry*>( theObject ) );
75         break;
76       }
77       case KIND_ALTITUDE:
78       {
79         aRes = new HYDROData_AltitudeObject( *dynamic_cast<HYDROData_AltitudeObject*>( theObject ) );
80         break;
81       }
82       case KIND_IMMERSIBLE_ZONE:
83       {
84         aRes = new HYDROData_ImmersibleZone( *dynamic_cast<HYDROData_ImmersibleZone*>( theObject ) );
85         break;
86       }
87       case KIND_BC_POLYGON:
88       {
89         aRes = new HYDROData_BCPolygon( *dynamic_cast<HYDROData_BCPolygon*>( theObject ) );
90         break;
91       }
92       case KIND_RIVER:
93       {
94         aRes = new HYDROData_River( *dynamic_cast<HYDROData_River*>( theObject ) );
95         break;
96       }
97       case KIND_STREAM:
98       {
99         aRes = new HYDROData_Stream( *dynamic_cast<HYDROData_Stream*>( theObject ) );
100         break;
101       }
102       case KIND_CONFLUENCE:
103       {
104         aRes = new HYDROData_Confluence( *dynamic_cast<HYDROData_Confluence*>( theObject ) );
105         break;
106       }
107       case KIND_CHANNEL:
108       {
109         aRes = new HYDROData_Channel( *dynamic_cast<HYDROData_Channel*>( theObject ) );
110         break;
111       }
112       case KIND_OBSTACLE:
113       {
114         aRes = new HYDROData_Obstacle( *dynamic_cast<HYDROData_Obstacle*>( theObject ) );
115         break;
116       }
117       case KIND_DIGUE:
118       {
119         aRes = new HYDROData_Digue( *dynamic_cast<HYDROData_Digue*>( theObject ) );
120         break;
121       }
122       case KIND_PROFILE:
123       {
124         aRes = new HYDROData_Profile( *dynamic_cast<HYDROData_Profile*>( theObject ) );
125         break;
126       }
127       case KIND_PROFILEUZ:
128       {
129         aRes = new HYDROData_ProfileUZ( *dynamic_cast<HYDROData_ProfileUZ*>( theObject ) );
130         break;
131       }
132       case KIND_POLYLINEXY:
133       {
134         aRes = new HYDROData_PolylineXY( *dynamic_cast<HYDROData_PolylineXY*>( theObject ) );
135         break;
136       }
137       case KIND_CALCULATION:
138       {
139         aRes = new HYDROData_CalculationCase( *dynamic_cast<HYDROData_CalculationCase*>( theObject ) );
140         break;
141       }
142       case KIND_REGION:
143       {
144         aRes = new HYDROData_Region( *dynamic_cast<HYDROData_Region*>( theObject ) );
145         break;
146       }
147       case KIND_ZONE:
148       {
149         aRes = new HYDROData_Zone( *dynamic_cast<HYDROData_Zone*>( theObject ) );
150         break;
151       }
152       case KIND_SHAPES_GROUP:
153       {
154         aRes = new HYDROData_ShapesGroup( *dynamic_cast<HYDROData_ShapesGroup*>( theObject ) );
155         break;
156       }
157       case KIND_SPLIT_GROUP:
158       {
159         aRes = new HYDROData_SplitShapesGroup( *dynamic_cast<HYDROData_SplitShapesGroup*>( theObject ) );
160         break;
161       }
162       case KIND_OBSTACLE_ALTITUDE:
163       {
164         aRes = new HYDROData_ObstacleAltitude( *dynamic_cast<HYDROData_ObstacleAltitude*>( theObject ) );
165         break;
166       }
167       case KIND_STREAM_ALTITUDE:
168       {
169         aRes = new HYDROData_StreamAltitude( *dynamic_cast<HYDROData_StreamAltitude*>( theObject ) );
170         break;
171       }
172       case KIND_STRICKLER_TABLE:
173       {
174         aRes = new HYDROData_StricklerTable( *dynamic_cast<HYDROData_StricklerTable*>( theObject ) );
175         break;
176       }
177       case KIND_LAND_COVER_MAP:
178       {
179         aRes = new HYDROData_LandCoverMap( *dynamic_cast<HYDROData_LandCoverMap*>( theObject ) );
180         break;
181       }
182     }
183     
184     return aRes;
185   }
186   
187   Handle(HYDROData_Entity) createHandle( HYDROData_Entity* theObject )
188   {
189     Handle(HYDROData_Entity) aRes = copyObject( theObject );
190     return aRes;
191   }
192   
193   HYDROData_Entity* createPointer( const Handle(HYDROData_Entity)& theObject )
194   {
195     HYDROData_Entity* aRes = NULL;
196     
197     if ( !theObject.IsNull() )
198       aRes = copyObject( theObject.operator->() );
199     
200     return aRes;
201   }
202
203 %End
204
205 public:
206
207   //! Returns the existing document or creates new if it is not exist
208   static HYDROData_Document Document( const int theStudyID ) [opencascade::handle<HYDROData_Document> (const int)] ;
209   %MethodCode
210
211     Handle(HYDROData_Document) aDocument;
212
213     Py_BEGIN_ALLOW_THREADS
214     aDocument = HYDROData_Document::Document( a0 );
215     Py_END_ALLOW_THREADS
216
217     if ( !aDocument.IsNull() )
218       sipRes = aDocument.operator->();
219
220   %End
221
222   //! Returns true if data model contains document for this study
223   static bool HasDocument( const int theStudyID );
224
225   //! Loads the OCAF document from the file.
226   //! \param theFileName full name of the file to load
227   //! \param theStudyID identifier of the SALOME study to associate with loaded file
228   //! \returns error status (OK in case of success)
229   static Data_DocError Load( const char* theFileName, const int theStudyID );
230
231   //! Saves the OCAF document to the file.
232   //! \param theFileName full name of the file to store
233   //! \returns error status (OK in case of success)
234   Data_DocError Save( const char* theFileName );
235
236   //! Removes document data
237   void Close();
238
239   //! Starts a new operation (opens a tansaction)
240   void StartOperation();
241   
242   //! Finishes the previously started operation (closes the transaction)
243   //void CommitOperation(
244   //  const TCollection_ExtendedString& theName = TCollection_ExtendedString() );
245     
246   //! Aborts the operation 
247   void AbortOperation();
248   
249   //! Returns true if operation has been started, but not yet finished or aborted
250   bool IsOperation();
251   
252   //! Returns true if document was modified (since creation/opening)
253   bool IsModified();
254
255   //! Returns True if there are available Undos
256   bool CanUndo();
257   
258   //! Returns a list of stored undo actions
259   //const TDF_DeltaList& GetUndos();
260   
261   //! Clears a list of stored undo actions
262   void ClearUndos();
263   
264   //! Undoes last operation
265   void Undo();
266
267   //! Returns True if there are available Redos
268   bool CanRedo();
269   
270   //! Returns a list of stored undo actions
271   //const TDF_DeltaList& GetRedos();
272   
273   //! Clears a list of stored undo actions
274   void ClearRedos();
275   
276   //! Redoes last operation
277   void Redo();
278
279   //! Creates and locates in the document a new object
280   //! \param theKind kind of the created object, can not be UNKNOWN
281   //! \returns the created object
282   HYDROData_Entity CreateObject( const ObjectKind theKind ) [opencascade::handle<HYDROData_Entity> (const ObjectKind)] ;
283   %MethodCode
284
285     Handle(HYDROData_Entity) anObject;
286     Py_BEGIN_ALLOW_THREADS
287     anObject =  sipSelfWasArg ? sipCpp->HYDROData_Document::CreateObject( a0 ) :
288                                 sipCpp->CreateObject( a0 );
289     Py_END_ALLOW_THREADS
290
291     sipRes = createPointer( anObject );
292     
293   %End
294
295   HYDROData_Entity FindObjectByName( const QString&   theName,
296                                      const ObjectKind theKind = KIND_UNKNOWN ) 
297   [opencascade::handle<HYDROData_Entity> (const QString&, const ObjectKind)] ;
298   %MethodCode
299
300     Handle(HYDROData_Entity) anObject;
301     Py_BEGIN_ALLOW_THREADS
302     anObject =  sipSelfWasArg ? sipCpp->HYDROData_Document::FindObjectByName( *a0, a1 ) :
303                                 sipCpp->FindObjectByName( *a0, a1 );
304     Py_END_ALLOW_THREADS
305
306     sipRes = createPointer( anObject );
307     
308   %End
309
310   HYDROData_SequenceOfObjects FindObjectsByNames( const QStringList& theNames,
311                                                   const ObjectKind   theKind = KIND_UNKNOWN );
312
313   void SetLocalCS( double, double );
314
315   //! Get the appropriate interpolator by the name.
316   HYDROData_IProfilesInterpolator* GetInterpolator( const TCollection_AsciiString& theName ) const;
317
318   //! Get list of registered interpolator names.
319   NCollection_Sequence<TCollection_AsciiString> GetInterpolatorNames() const;
320
321 protected:
322
323   //! Creates new document: private because "Document" method must be used instead of direct creation.
324   HYDROData_Document();
325   
326   //! Deletes all high-level data, managed this document
327   ~HYDROData_Document();
328
329 };