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_RIVER:
  88       {
  89         aRes = new HYDROData_River( *dynamic_cast<HYDROData_River*>( theObject ) );
  90         break;
  91       }
  92       case KIND_STREAM:
  93       {
  94         aRes = new HYDROData_Stream( *dynamic_cast<HYDROData_Stream*>( theObject ) );
  95         break;
  96       }
  97       case KIND_CONFLUENCE:
  98       {
  99         aRes = new HYDROData_Confluence( *dynamic_cast<HYDROData_Confluence*>( theObject ) );
 100         break;
 101       }
 102       case KIND_CHANNEL:
 103       {
 104         aRes = new HYDROData_Channel( *dynamic_cast<HYDROData_Channel*>( theObject ) );
 105         break;
 106       }
 107       case KIND_OBSTACLE:
 108       {
 109         aRes = new HYDROData_Obstacle( *dynamic_cast<HYDROData_Obstacle*>( theObject ) );
 110         break;
 111       }
 112       case KIND_DIGUE:
 113       {
 114         aRes = new HYDROData_Digue( *dynamic_cast<HYDROData_Digue*>( theObject ) );
 115         break;
 116       }
 117       case KIND_PROFILE:
 118       {
 119         aRes = new HYDROData_Profile( *dynamic_cast<HYDROData_Profile*>( theObject ) );
 120         break;
 121       }
 122       case KIND_PROFILEUZ:
 123       {
 124         aRes = new HYDROData_ProfileUZ( *dynamic_cast<HYDROData_ProfileUZ*>( theObject ) );
 125         break;
 126       }
 127       case KIND_POLYLINEXY:
 128       {
 129         aRes = new HYDROData_PolylineXY( *dynamic_cast<HYDROData_PolylineXY*>( theObject ) );
 130         break;
 131       }
 132       case KIND_CALCULATION:
 133       {
 134         aRes = new HYDROData_CalculationCase( *dynamic_cast<HYDROData_CalculationCase*>( theObject ) );
 135         break;
 136       }
 137       case KIND_REGION:
 138       {
 139         aRes = new HYDROData_Region( *dynamic_cast<HYDROData_Region*>( theObject ) );
 140         break;
 141       }
 142       case KIND_ZONE:
 143       {
 144         aRes = new HYDROData_Zone( *dynamic_cast<HYDROData_Zone*>( theObject ) );
 145         break;
 146       }
 147       case KIND_SHAPES_GROUP:
 148       {
 149         aRes = new HYDROData_ShapesGroup( *dynamic_cast<HYDROData_ShapesGroup*>( theObject ) );
 150         break;
 151       }
 152       case KIND_SPLIT_GROUP:
 153       {
 154         aRes = new HYDROData_SplitShapesGroup( *dynamic_cast<HYDROData_SplitShapesGroup*>( theObject ) );
 155         break;
 156       }
 157       case KIND_OBSTACLE_ALTITUDE:
 158       {
 159         aRes = new HYDROData_ObstacleAltitude( *dynamic_cast<HYDROData_ObstacleAltitude*>( theObject ) );
 160         break;
 161       }
 162       case KIND_STREAM_ALTITUDE:
 163       {
 164         aRes = new HYDROData_StreamAltitude( *dynamic_cast<HYDROData_StreamAltitude*>( theObject ) );
 165         break;
 166       }
 167       case KIND_STRICKLER_TABLE:
 168       {
 169         aRes = new HYDROData_StricklerTable( *dynamic_cast<HYDROData_StricklerTable*>( theObject ) );
 170         break;
 171       }
 172       case KIND_LAND_COVER_MAP:
 173       {
 174         aRes = new HYDROData_LandCoverMap( *dynamic_cast<HYDROData_LandCoverMap*>( theObject ) );
 175         break;
 176       }
 177     }
 178
 179     return aRes;
 180   }
 181
 182   Handle(HYDROData_Entity) createHandle( HYDROData_Entity* theObject )
 183   {
 184     Handle(HYDROData_Entity) aRes = copyObject( theObject );
 185     return aRes;
 186   }
 187
 188   HYDROData_Entity* createPointer( const Handle(HYDROData_Entity)& theObject )
 189   {
 190     HYDROData_Entity* aRes = NULL;
 191
 192     if ( !theObject.IsNull() )
 193       aRes = copyObject( theObject.operator->() );
 194
 195     return aRes;
 196   }
 197
 198 %End
 199
 200 public:
 201
 202   //! Returns the existing document or creates new if it is not exist
 203   static HYDROData_Document Document( const int theStudyID ) [opencascade::handle<HYDROData_Document> (const int)] ;
 204   %MethodCode
 205
 206     Handle(HYDROData_Document) aDocument;
 207
 208     Py_BEGIN_ALLOW_THREADS
 209     aDocument = HYDROData_Document::Document( a0 );
 210     Py_END_ALLOW_THREADS
 211
 212     if ( !aDocument.IsNull() )
 213       sipRes = aDocument.operator->();
 214
 215   %End
 216
 217   //! Returns true if data model contains document for this study
 218   static bool HasDocument( const int theStudyID );
 219
 220   //! Loads the OCAF document from the file.
 221   //! \param theFileName full name of the file to load
 222   //! \param theStudyID identifier of the SALOME study to associate with loaded file
 223   //! \returns error status (OK in case of success)
 224   static Data_DocError Load( const char* theFileName, const int theStudyID );
 225
 226   //! Saves the OCAF document to the file.
 227   //! \param theFileName full name of the file to store
 228   //! \returns error status (OK in case of success)
 229   Data_DocError Save( const char* theFileName );
 230
 231   //! Removes document data
 232   void Close();
 233
 234   //! Starts a new operation (opens a tansaction)
 235   void StartOperation();
 236
 237   //! Finishes the previously started operation (closes the transaction)
 238   //void CommitOperation(
 239   //  const TCollection_ExtendedString& theName = TCollection_ExtendedString() );
 240
 241   //! Aborts the operation
 242   void AbortOperation();
 243
 244   //! Returns true if operation has been started, but not yet finished or aborted
 245   bool IsOperation();
 246
 247   //! Returns true if document was modified (since creation/opening)
 248   bool IsModified();
 249
 250   //! Returns True if there are available Undos
 251   bool CanUndo();
 252
 253   //! Returns a list of stored undo actions
 254   //const TDF_DeltaList& GetUndos();
 255
 256   //! Clears a list of stored undo actions
 257   void ClearUndos();
 258
 259   //! Undoes last operation
 260   void Undo();
 261
 262   //! Returns True if there are available Redos
 263   bool CanRedo();
 264
 265   //! Returns a list of stored undo actions
 266   //const TDF_DeltaList& GetRedos();
 267
 268   //! Clears a list of stored undo actions
 269   void ClearRedos();
 270
 271   //! Redoes last operation
 272   void Redo();
 273
 274   //! Creates and locates in the document a new object
 275   //! \param theKind kind of the created object, can not be UNKNOWN
 276   //! \returns the created object
 277   HYDROData_Entity CreateObject( const ObjectKind theKind ) [opencascade::handle<HYDROData_Entity> (const ObjectKind)] ;
 278   %MethodCode
 279
 280     Handle(HYDROData_Entity) anObject;
 281     Py_BEGIN_ALLOW_THREADS
 282     anObject =  sipSelfWasArg ? sipCpp->HYDROData_Document::CreateObject( a0 ) :
 283                                 sipCpp->CreateObject( a0 );
 284     Py_END_ALLOW_THREADS
 285
 286     sipRes = createPointer( anObject );
 287
 288   %End
 289
 290   HYDROData_Entity FindObjectByName( const QString&   theName,
 291                                      const ObjectKind theKind = KIND_UNKNOWN )
 292   [opencascade::handle<HYDROData_Entity> (const QString&, const ObjectKind)] ;
 293   %MethodCode
 294
 295     Handle(HYDROData_Entity) anObject;
 296     Py_BEGIN_ALLOW_THREADS
 297     anObject =  sipSelfWasArg ? sipCpp->HYDROData_Document::FindObjectByName( *a0, a1 ) :
 298                                 sipCpp->FindObjectByName( *a0, a1 );
 299     Py_END_ALLOW_THREADS
 300
 301     sipRes = createPointer( anObject );
 302
 303   %End
 304
 305   HYDROData_SequenceOfObjects FindObjectsByNames( const QStringList& theNames,
 306                                                   const ObjectKind   theKind = KIND_UNKNOWN );
 307
 308   void SetLocalCS( double, double );
 309
 310   //! Get the appropriate interpolator by the name.
 311   HYDROData_IProfilesInterpolator* GetInterpolator( const TCollection_AsciiString& theName ) const;
 312
 313   //! Get list of registered interpolator names.
 314   NCollection_Sequence<TCollection_AsciiString> GetInterpolatorNames() const;
 315
 316 protected:
 317
 318   //! Creates new document: private because "Document" method must be used instead of direct creation.
 319   HYDROData_Document();
 320
 321   //! Deletes all high-level data, managed this document
 322   ~HYDROData_Document();
 323
 324 };