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 };