ADD_DEFINITIONS(-DWNT)
ENDIF(WIN32)
+
+# Common CMake macros
+# ===================
+SET(CONFIGURATION_ROOT_DIR $ENV{CONFIGURATION_ROOT_DIR} CACHE PATH "Path to the Salome CMake configuration files")
+IF(EXISTS ${CONFIGURATION_ROOT_DIR})
+ LIST(APPEND CMAKE_MODULE_PATH "${CONFIGURATION_ROOT_DIR}/cmake")
+ INCLUDE(SalomeMacros)
+ELSE()
+ MESSAGE(FATAL_ERROR "We absolutely need the Salome CMake configuration files, please define CONFIGURATION_ROOT_DIR !")
+ENDIF()
+
# Find KERNEL
# ==============
SET(KERNEL_ROOT_DIR $ENV{KERNEL_ROOT_DIR} CACHE PATH "Path to the Salome KERNEL")
#define _DEVDEBUG_
#include "HYDRO_trace.hxx"
-IMPLEMENT_STANDARD_HANDLE(HYDROData_AltitudeObject, HYDROData_IAltitudeObject)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_AltitudeObject, HYDROData_IAltitudeObject)
HYDROData_AltitudeObject::HYDROData_AltitudeObject()
#include "HYDROData_IAltitudeObject.h"
-DEFINE_STANDARD_HANDLE(HYDROData_AltitudeObject, HYDROData_IAltitudeObject)
-
/**\class HYDROData_AltitudeObject
* \brief Class that stores/retreives information about the Altitude.
class HYDROData_AltitudeObject : public HYDROData_IAltitudeObject
{
protected:
-
/**
* Enumeration of tags corresponding to the persistent object parameters.
*/
};
public:
-
- DEFINE_STANDARD_RTTI(HYDROData_AltitudeObject);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_AltitudeObject, HYDROData_IAltitudeObject);
/**
* Returns the kind of this object.
#include <TColStd_SequenceOfExtendedString.hxx>
-IMPLEMENT_STANDARD_HANDLE(HYDROData_Application,TDocStd_Application)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Application,TDocStd_Application)
static HYDROData_Application* TheApplication = new HYDROData_Application;
HYDRODATA_EXPORT HYDROData_Application();
// CASCADE RTTI
- DEFINE_STANDARD_RTTI(HYDROData_Application)
+ DEFINE_STANDARD_RTTIEXT(HYDROData_Application, TDocStd_Application)
private:
//! Returns document by its study ID, if document doesn't exists return null
friend class HYDROData_Document; // to manipulate documents of application
};
-// Define handle class
-DEFINE_STANDARD_HANDLE(HYDROData_Application,TDocStd_Application)
-
#endif
#include "HYDROData_ArtificialObject.h"
-IMPLEMENT_STANDARD_HANDLE(HYDROData_ArtificialObject,HYDROData_Object)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_ArtificialObject,HYDROData_Object)
HYDROData_ArtificialObject::HYDROData_ArtificialObject( Geometry theGeometry )
#include <HYDROData_Object.h>
-DEFINE_STANDARD_HANDLE(HYDROData_ArtificialObject, HYDROData_Object)
-
-
/**\class HYDROData_ArtificialObject
* \brief The artificial objects are objects created or planned for creation by human.
*
};
public:
- DEFINE_STANDARD_RTTI(HYDROData_ArtificialObject);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_ArtificialObject, HYDROData_Object);
protected:
#define _DEVDEBUG_
#include "HYDRO_trace.hxx"
-IMPLEMENT_STANDARD_HANDLE(HYDROData_Bathymetry, HYDROData_IAltitudeObject)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Bathymetry, HYDROData_IAltitudeObject)
//HYDROData_QuadtreeNode* HYDROData_Bathymetry::myQuadtree = 0;
// Convert from global to local CS
- Handle_HYDROData_Document aDoc = HYDROData_Document::Document( myLab );
+ Handle(HYDROData_Document) aDoc = HYDROData_Document::Document( myLab );
AltitudePoints::Iterator anIter( aPoints );
for ( ; anIter.More(); anIter.Next() )
{
}
-Handle_HYDROData_PolylineXY HYDROData_Bathymetry::CreateBoundaryPolyline() const
+Handle(HYDROData_PolylineXY) HYDROData_Bathymetry::CreateBoundaryPolyline() const
{
Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab );
- Handle_HYDROData_PolylineXY aResult =
- Handle_HYDROData_PolylineXY::DownCast( aDocument->CreateObject( KIND_POLYLINEXY ) );
+ Handle(HYDROData_PolylineXY) aResult =
+ Handle(HYDROData_PolylineXY)::DownCast( aDocument->CreateObject( KIND_POLYLINEXY ) );
if( aResult.IsNull() )
return aResult;
class QFile;
class gp_XYZ;
class gp_XY;
-class Handle_HYDROData_PolylineXY;
+class HYDROData_PolylineXY;
-DEFINE_STANDARD_HANDLE(HYDROData_Bathymetry, HYDROData_IAltitudeObject)
-
/**\class HYDROData_Bathymetry
* \brief Class that stores/retreives information about the Bathymetry.
};
public:
-
- DEFINE_STANDARD_RTTI(HYDROData_Bathymetry);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_Bathymetry, HYDROData_IAltitudeObject);
/**
* Returns the kind of this object. Must be redefined in all objects of known type.
*/
HYDRODATA_EXPORT virtual bool ImportFromFile( const TCollection_AsciiString& theFileName );
- HYDRODATA_EXPORT Handle_HYDROData_PolylineXY CreateBoundaryPolyline() const;
+ HYDRODATA_EXPORT Handle(HYDROData_PolylineXY) CreateBoundaryPolyline() const;
HYDRODATA_EXPORT virtual void UpdateLocalCS( double theDx, double theDy );
#define _DEVDEBUG_
#include "HYDRO_trace.hxx"
-IMPLEMENT_STANDARD_HANDLE(HYDROData_CalculationCase, HYDROData_Entity)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_CalculationCase, HYDROData_Entity)
HYDROData_CalculationCase::HYDROData_CalculationCase()
class TopoDS_Shape;
class TopoDS_Shell;
-class TopTools_ListOfShape;
-
-class Handle(HYDROData_Object);
-class Handle(HYDROData_Region);
-class Handle(HYDROData_Zone);
-class Handle(HYDROData_PolylineXY);
-class Handle(HYDROData_ShapesGroup);
-class Handle(HYDROData_SplitShapesGroup);
-class Handle(HYDROData_Document);
-class Handle(HYDROData_StricklerTable);
-class Handle(HYDROData_LandCoverMap);
-
-DEFINE_STANDARD_HANDLE(HYDROData_CalculationCase, HYDROData_Entity)
+class HYDROData_Object;
+class HYDROData_Region;
+class HYDROData_Zone;
+class HYDROData_PolylineXY;
+class HYDROData_ShapesGroup;
+class HYDROData_SplitShapesGroup;
+class HYDROData_Document;
+class HYDROData_StricklerTable;
+class HYDROData_LandCoverMap;
/**\class HYDROData_CalculationCase
* \brief Calculation case is defined by selection of Geometry objects with or without �Zone of water�.
};
public:
-
- DEFINE_STANDARD_RTTI(HYDROData_CalculationCase);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_CalculationCase, HYDROData_Entity);
/**
* Returns the kind of this object. Must be redefined in all objects of known type.
#include <TColStd_Array1OfReal.hxx>
#include <TopTools_HArray1OfShape.hxx>
+#include <TopTools_SequenceOfShape.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Wire.hxx>
#define _DEVDEBUG_
#include "HYDRO_trace.hxx"
-IMPLEMENT_STANDARD_HANDLE(HYDROData_Channel,HYDROData_ArtificialObject)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Channel,HYDROData_ArtificialObject)
#include <TopoDS_Face.hxx>
#include <TopoDS_Wire.hxx>
-class Handle(HYDROData_Polyline3D);
-class Handle(HYDROData_Profile);
-class TopTools_SequenceOfShape;
-class TopTools_ListOfShape;
-
-DEFINE_STANDARD_HANDLE(HYDROData_Channel, HYDROData_ArtificialObject)
+class HYDROData_Polyline3D;
+class HYDROData_Profile;
/**\class HYDROData_Channel
* \brief
};
public:
-
- DEFINE_STANDARD_RTTI(HYDROData_Channel);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_Channel, HYDROData_ArtificialObject);
public:
#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
-IMPLEMENT_STANDARD_HANDLE(HYDROData_ChannelAltitude, HYDROData_IAltitudeObject)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_ChannelAltitude, HYDROData_IAltitudeObject)
HYDROData_ChannelAltitude::HYDROData_ChannelAltitude()
#include "HYDROData_IAltitudeObject.h"
-DEFINE_STANDARD_HANDLE(HYDROData_ChannelAltitude, HYDROData_IAltitudeObject)
-
/**\class HYDROData_ChannelAltitude
* \brief Class that stores/retrieves information about the Channel altitude.
public:
- DEFINE_STANDARD_RTTI(HYDROData_ChannelAltitude);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_ChannelAltitude, HYDROData_IAltitudeObject);
/**
* Returns the kind of this object.
#include <QStringList>
-IMPLEMENT_STANDARD_HANDLE(HYDROData_Confluence,HYDROData_NaturalObject)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Confluence,HYDROData_NaturalObject)
#include "HYDROData_NaturalObject.h"
-DEFINE_STANDARD_HANDLE(HYDROData_Confluence, HYDROData_NaturalObject)
-
/**\class HYDROData_Confluence
* \brief
*
};
public:
- DEFINE_STANDARD_RTTI(HYDROData_Confluence);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_Confluence, HYDROData_NaturalObject);
/**
* Returns the kind of this object. Must be redefined in all objects of known type.
#include <QColor>
#include <QStringList>
-IMPLEMENT_STANDARD_HANDLE(HYDROData_Digue,HYDROData_Channel)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Digue,HYDROData_Channel)
#include "HYDROData_Channel.h"
-DEFINE_STANDARD_HANDLE(HYDROData_Digue, HYDROData_Channel)
-
/**\class HYDROData_Digue
* \brief
*
};
public:
- DEFINE_STANDARD_RTTI(HYDROData_Digue);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_Digue, HYDROData_Channel);
/**
* Returns the kind of this object. Must be redefined in all objects of known type.
#include <QTextStream>
#include <QColor>
-IMPLEMENT_STANDARD_HANDLE(HYDROData_Document,MMgt_TShared)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Document,MMgt_TShared)
#define PYTHON_DOC_NAME "hydro_doc"
using namespace std;
-typedef QMap<Standard_Integer,Handle_HYDROData_Entity> MapOfOrdered;
-typedef QMap<QString,Handle_HYDROData_Entity> MapOfUnordered;
+typedef QMap<Standard_Integer, Handle(HYDROData_Entity)> MapOfOrdered;
+typedef QMap<QString, Handle(HYDROData_Entity)> MapOfUnordered;
Handle(HYDROData_Document) HYDROData_Document::Document(const int theStudyID)
{
}
}
-void HYDROData_Document::Show( const Handle_HYDROData_Entity& theObject )
+void HYDROData_Document::Show( const Handle(HYDROData_Entity)& theObject )
{
HYDROData_SequenceOfObjects anOrder;
anOrder.Append( theObject );
class HYDROData_InterpolatorsFactory;
class HYDROData_IProfilesInterpolator;
-class Handle(HYDROData_StricklerTable);
-class Handle(HYDROData_LandCoverMap);
+class HYDROData_StricklerTable;
+class HYDROData_LandCoverMap;
class QFile;
class gp_Pnt2d;
DocError_UnknownProblem ///< problem has unknown nature
};
-DEFINE_STANDARD_HANDLE(HYDROData_Document, MMgt_TShared)
-
/**\class HYDROData_Document
*
* \brief Document for internal data structure of any object storage. Corresponds to the SALOME study.
class HYDROData_Document : public MMgt_TShared
{
public:
-
- DEFINE_STANDARD_RTTI(HYDROData_Document);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_Document, MMgt_TShared);
//! Returns the existing document or creates new if it is not exist
HYDRODATA_EXPORT static Handle(HYDROData_Document) Document(const int theStudyID);
//! Show object at the top of other model objects. If the object
//! already has the z-level parameter then nothing will be done.
- HYDRODATA_EXPORT void Show( const Handle_HYDROData_Entity& theObject );
+ HYDRODATA_EXPORT void Show( const Handle(HYDROData_Entity)& theObject );
//! Show sequence of objects at the top of other model objects.
//! The objects from the sequence will be sorted alphabetically at first.
#include <QString>
#include <QColor>
-IMPLEMENT_STANDARD_HANDLE(HYDROData_DummyObject3D,HYDROData_Entity)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_DummyObject3D,HYDROData_Entity)
HYDROData_DummyObject3D::HYDROData_DummyObject3D()
#include <HYDROData_Entity.h>
-DEFINE_STANDARD_HANDLE(HYDROData_DummyObject3D, HYDROData_Entity)
-
-class Handle(HYDROData_Object);
+class HYDROData_Object;
class TopoDS_Shape;
/**\class HYDROData_DummyObject3D
};
public:
- DEFINE_STANDARD_RTTI(HYDROData_DummyObject3D);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_DummyObject3D, HYDROData_Entity);
public:
#include "HYDRO_trace.hxx"
HYDROData_SequenceOfObjects::HYDROData_SequenceOfObjects()
- : NCollection_Sequence<Handle_HYDROData_Entity>()
+ : NCollection_Sequence<Handle(HYDROData_Entity)>()
{
}
HYDROData_SequenceOfObjects::HYDROData_SequenceOfObjects( const HYDROData_SequenceOfObjects& theSequence )
- : NCollection_Sequence<Handle_HYDROData_Entity>( theSequence )
+ : NCollection_Sequence<Handle(HYDROData_Entity)>( theSequence )
{
}
-HYDROData_SequenceOfObjects::HYDROData_SequenceOfObjects( const NCollection_Sequence<Handle_HYDROData_Entity>& theSequence )
- : NCollection_Sequence<Handle_HYDROData_Entity>( theSequence )
+HYDROData_SequenceOfObjects::HYDROData_SequenceOfObjects( const NCollection_Sequence<Handle(HYDROData_Entity)>& theSequence )
+ : NCollection_Sequence<Handle(HYDROData_Entity)>( theSequence )
{
}
-IMPLEMENT_STANDARD_HANDLE(HYDROData_Entity,MMgt_TShared)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Entity,MMgt_TShared)
// is equal function for unique object mapping
-bool IsEqual(const Handle_HYDROData_Entity& theObj1, const Handle_HYDROData_Entity& theObj2)
+bool IsEqual(const Handle(HYDROData_Entity)& theObj1, const Handle(HYDROData_Entity)& theObj2)
{
if ( !theObj1.IsNull() && !theObj2.IsNull() )
return theObj1->Label() == theObj2->Label();
return aRefs.IsNull() ? 0 : aRefs->Extent();
}
-bool HYDROData_Entity::HasReference( const Handle_HYDROData_Entity& theObj,
+bool HYDROData_Entity::HasReference( const Handle(HYDROData_Entity)& theObj,
const int theTag ) const
{
if ( theObj.IsNull() )
return false;
}
-void HYDROData_Entity::AddReferenceObject( const Handle_HYDROData_Entity& theObj,
+void HYDROData_Entity::AddReferenceObject( const Handle(HYDROData_Entity)& theObj,
const int theTag )
{
if ( theObj.IsNull() )
aRefs->Append( theObj->Label() );
}
-void HYDROData_Entity::SetReferenceObject( const Handle_HYDROData_Entity& theObj,
+void HYDROData_Entity::SetReferenceObject( const Handle(HYDROData_Entity)& theObj,
const int theTag,
const int theIndex )
{
}
}
-void HYDROData_Entity::InsertReferenceObject( const Handle_HYDROData_Entity& theObj,
+void HYDROData_Entity::InsertReferenceObject( const Handle(HYDROData_Entity)& theObj,
const int theTag,
const int theBeforeIndex )
{
#include <TDF_Label.hxx>
#include <QMap>
#include <QString>
+#include <Standard_Type.hxx>
class QColor;
class QVariant;
class QStringList;
-class Handle(TDataStd_ReferenceList);
-class Handle_HYDROData_Entity;
+class TDataStd_ReferenceList;
+class HYDROData_Entity;
class TopoDS_Shape;
///! Kind of an object in a document
const ObjectKind KIND_LAND_COVER_MAP = 29;
const ObjectKind KIND_LAST = KIND_LAND_COVER_MAP;
-DEFINE_STANDARD_HANDLE(HYDROData_Entity, MMgt_TShared)
-
class MapOfTreatedObjects : public QMap<QString,Handle(Standard_Transient)>
{
};
-class HYDRODATA_EXPORT HYDROData_SequenceOfObjects : public NCollection_Sequence<Handle_HYDROData_Entity>
+class HYDRODATA_EXPORT HYDROData_SequenceOfObjects : public NCollection_Sequence<Handle(HYDROData_Entity)>
{
public:
HYDROData_SequenceOfObjects();
HYDROData_SequenceOfObjects( const HYDROData_SequenceOfObjects& );
- HYDROData_SequenceOfObjects( const NCollection_Sequence<Handle_HYDROData_Entity>& );
+ HYDROData_SequenceOfObjects( const NCollection_Sequence<Handle(HYDROData_Entity)>& );
};
///! Is Equal for HYDROData_Entity mapping
-HYDRODATA_EXPORT bool IsEqual(const Handle_HYDROData_Entity& theObj1, const Handle_HYDROData_Entity& theObj2);
+HYDRODATA_EXPORT bool IsEqual(const Handle(HYDROData_Entity)& theObj1, const Handle(HYDROData_Entity)& theObj2);
/**\class HYDROData_Entity
* \brief Generic class of any object in the data model.
};
public:
- DEFINE_STANDARD_RTTI(HYDROData_Entity);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_Entity, MMgt_TShared);
/**
* Returns the kind of this object. Must be redefined in all objects of known type.
* \param theObj pointer to reference object
* \param theTag tag of a label to store attribute (for 0 this is myLab)
*/
- bool HasReference( const Handle_HYDROData_Entity& theObj,
+ bool HasReference( const Handle(HYDROData_Entity)& theObj,
const int theTag = 0 ) const;
/**
* \param theObj pointer to reference object
* \param theTag tag of a label to store attribute (for 0 this is myLab)
*/
- void AddReferenceObject( const Handle_HYDROData_Entity& theObj,
+ void AddReferenceObject( const Handle(HYDROData_Entity)& theObj,
const int theTag = 0 );
/**
- if less than zero then prepend to the list
- indexing starts from 0
*/
- void SetReferenceObject( const Handle_HYDROData_Entity& theObj,
+ void SetReferenceObject( const Handle(HYDROData_Entity)& theObj,
const int theTag = 0,
const int theIndex = 0 );
- if less than zero then prepend to the list
- indexing starts from 0
*/
- void InsertReferenceObject( const Handle_HYDROData_Entity& theObj,
+ void InsertReferenceObject( const Handle(HYDROData_Entity)& theObj,
const int theTag = 0,
const int theBeforeIndex = 0 );
* - indexing starts from 0
* \returns pointer to reference object or NULL if label is not set
*/
- Handle_HYDROData_Entity GetReferenceObject( const int theTag = 0,
+ Handle(HYDROData_Entity) GetReferenceObject( const int theTag = 0,
const int theIndex = 0 ) const;
HYDROData_SequenceOfObjects GetReferenceObjects( const int theTag = 0 ) const;
#define INVALID_ALTITUDE_VALUE -9999.0
-IMPLEMENT_STANDARD_HANDLE(HYDROData_IAltitudeObject, HYDROData_Entity)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_IAltitudeObject, HYDROData_Entity)
HYDROData_IAltitudeObject::HYDROData_IAltitudeObject()
class gp_XY;
-DEFINE_STANDARD_HANDLE(HYDROData_IAltitudeObject, HYDROData_Entity)
-
/**\class HYDROData_IAltitudeObject
* \briefThe base class for all altitude objects in the HYDRO module.
};
public:
-
- DEFINE_STANDARD_RTTI(HYDROData_IAltitudeObject);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_IAltitudeObject, HYDROData_Entity);
/**
* Returns the kind of this object. Must be redefined in all objects of known type.
*/
HYDRODATA_EXPORT virtual const ObjectKind GetKind() const = 0;
-public:
+public:
// Public methods to work with altitudes.
/**
#include <TopoDS_Shape.hxx>
#include <QColor>
-IMPLEMENT_STANDARD_HANDLE(HYDROData_IPolyline, HYDROData_Entity)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_IPolyline, HYDROData_Entity)
HYDROData_IPolyline::HYDROData_IPolyline()
#include "HYDROData_Entity.h"
-
-DEFINE_STANDARD_HANDLE(HYDROData_IPolyline, HYDROData_Entity)
-
class gp_XY;
class TopoDS_Shape;
-class Handle(TDataStd_RealList);
-class Handle(TDataStd_ExtStringList);
-class Handle(TDataStd_BooleanList);
-class Handle(TDataStd_IntegerList);
+class TDataStd_RealList;
+class TDataStd_ExtStringList;
+class TDataStd_BooleanList;
+class TDataStd_IntegerList;
/**\class HYDROData_IPolyline
class HYDROData_IPolyline : public HYDROData_Entity
{
public:
-
enum SectionType{ SECTION_POLYLINE = 0, SECTION_SPLINE = 1 };
typedef gp_XY Point;
};
public:
- DEFINE_STANDARD_RTTI(HYDROData_IPolyline);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_IPolyline, HYDROData_Entity);
public:
static const Standard_GUID GUID_HAS_LOCAL_POINTS("FD8841AA-FC44-42fa-B6A7-0F682CCC6F27");
static const Standard_GUID GUID_HAS_GLOBAL_POINTS("330D0E81-742D-4ea3-92D4-484877CFA7C1");
-IMPLEMENT_STANDARD_HANDLE(HYDROData_Image, HYDROData_Entity)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Image, HYDROData_Entity)
HYDROData_Image::HYDROData_Image()
#pragma warning ( default: 4251 )
#endif
-DEFINE_STANDARD_HANDLE(HYDROData_Image, HYDROData_Entity)
-
/**\class HYDROData_Image
* \brief Class that stores/retreives information about the image.
*
};
public:
- DEFINE_STANDARD_RTTI(HYDROData_Image);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_Image, HYDROData_Entity);
/**
* Returns the kind of this object. Must be redefined in all objects of known type.
//#define HYDRODATA_IMZONE_DEB 1
-IMPLEMENT_STANDARD_HANDLE(HYDROData_ImmersibleZone,HYDROData_NaturalObject)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_ImmersibleZone,HYDROData_NaturalObject)
#include <HYDROData_NaturalObject.h>
-DEFINE_STANDARD_HANDLE(HYDROData_ImmersibleZone, HYDROData_NaturalObject)
-
-class Handle(HYDROData_PolylineXY);
+class HYDROData_PolylineXY;
/**\class HYDROData_ImmersibleZone
* \brief
};
public:
- DEFINE_STANDARD_RTTI(HYDROData_ImmersibleZone);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_ImmersibleZone, HYDROData_NaturalObject);
/**
* Returns the kind of this object. Must be redefined in all objects of known type.
#include <QColor>
#include <QStringList>
-IMPLEMENT_STANDARD_HANDLE( HYDROData_LandCover, HYDROData_Entity )
IMPLEMENT_STANDARD_RTTIEXT( HYDROData_LandCover, HYDROData_Entity )
HYDROData_LandCover::HYDROData_LandCover()
#include <BRepCheck_Shell.hxx>
#include <BRepCheck_ListOfStatus.hxx>
#include <TopTools_SequenceOfShape.hxx>
-#include <Handle_Geom_Curve.hxx>
-#include <Handle_Geom_Line.hxx>
-#include <Handle_Geom_TrimmedCurve.hxx>
+#include <Geom_Curve.hxx>
+#include <Geom_Line.hxx>
+#include <Geom_TrimmedCurve.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <TopTools_DataMapOfShapeListOfShape.hxx>
#include <NCollection_DoubleMap.hxx>
const int TELEMAC_PRECISION = 3;
-IMPLEMENT_STANDARD_HANDLE(HYDROData_LandCoverMap, HYDROData_Entity)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_LandCoverMap, HYDROData_Entity)
/**
//
if (!anEdgesToRemove.IsEmpty())
{
- Handle_ShapeBuild_ReShape aReshape = new ShapeBuild_ReShape();
+ Handle(ShapeBuild_ReShape) aReshape = new ShapeBuild_ReShape();
TopoDS_Shape OutF = aReshape->Apply(CurFace);
TopTools_ListIteratorOfListOfShape aIt(anEdgesToRemove);
for (; aIt.More(); aIt.Next())
}
}
//
- Handle_ShapeBuild_ReShape anExtReshape = new ShapeBuild_ReShape();
+ Handle(ShapeBuild_ReShape) anExtReshape = new ShapeBuild_ReShape();
for (int i = 1; i <= aF2FReplace->Extent(); i++)
{
TopoDS_Face aFK = aF2FReplace->FindKey(i);
{
TopoDS_Edge E = TopoDS::Edge(anEdgeEx.Current());
double aFP, aLP;
- Handle_Geom_Curve aCur = BRep_Tool::Curve(E, aFP, aLP);
+ Handle(Geom_Curve) aCur = BRep_Tool::Curve(E, aFP, aLP);
Handle(Geom_Line) aLine = Handle(Geom_Line)::DownCast(aCur);
if (aLine.IsNull())
{
#include <TopoDS_Face.hxx>
#include <TopExp_Explorer.hxx>
-class Handle_HYDROData_StricklerTable;
+class HYDROData_StricklerTable;
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
typedef NCollection_IndexedDataMap<TopoDS_Face, QString> HYDROData_MapOfFaceToStricklerType;
-DEFINE_STANDARD_HANDLE( HYDROData_LandCoverMap, HYDROData_Entity )
-
class TopoDS_Shape;
class TopoDS_Wire;
class TopoDS_Iterator;
-class TopTools_ListOfShape;
-class Handle( HYDROData_PolylineXY );
-class Handle( HYDROData_Object );
+class HYDROData_PolylineXY;
+class HYDROData_Object;
class gp_Pnt2d;
class HYDROData_LandCoverMap : public HYDROData_Entity
HYDRODATA_EXPORT bool ExportTelemac( const QString& theFileName,
double theDeflection,
- const Handle_HYDROData_StricklerTable& theTable ) const;
+ const Handle(HYDROData_StricklerTable)& theTable ) const;
HYDRODATA_EXPORT bool Add( const Handle( HYDROData_Object )&, const QString& theType );
HYDRODATA_EXPORT bool Add( const Handle( HYDROData_PolylineXY )&, const QString& theType );
double theTolerance = 1E-5 );
public:
- DEFINE_STANDARD_RTTI( HYDROData_LandCoverMap );
+ DEFINE_STANDARD_RTTIEXT( HYDROData_LandCoverMap, HYDROData_Entity );
private:
friend class Explorer;
#include "HYDROData_NaturalObject.h"
-IMPLEMENT_STANDARD_HANDLE(HYDROData_NaturalObject,HYDROData_Object)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_NaturalObject,HYDROData_Object)
HYDROData_NaturalObject::HYDROData_NaturalObject( Geometry theGeometry )
#include <HYDROData_Object.h>
-DEFINE_STANDARD_HANDLE(HYDROData_NaturalObject, HYDROData_Object)
-
-
/**\class HYDROData_NaturalObject
* \brief The natural objects are objects of environment not created by human.
*
};
public:
- DEFINE_STANDARD_RTTI(HYDROData_NaturalObject);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_NaturalObject, HYDROData_Object);
protected:
#define _DEVDEBUG_
#include "HYDRO_trace.hxx"
-IMPLEMENT_STANDARD_HANDLE(HYDROData_Object,HYDROData_Entity)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Object,HYDROData_Entity)
HYDROData_Object::HYDROData_Object( Geometry theGeometry )
#include <HYDROData_Entity.h>
-DEFINE_STANDARD_HANDLE(HYDROData_Object, HYDROData_Entity)
-
class TopoDS_Shape;
-class Handle(HYDROData_IAltitudeObject);
-class Handle(HYDROData_DummyObject3D);
-class Handle(HYDROData_ShapesGroup);
+class HYDROData_IAltitudeObject;
+class HYDROData_DummyObject3D;
+class HYDROData_ShapesGroup;
/**\class HYDROData_Object
* \brief The base class for all geometrical objects in the HYDRO module.
};
public:
- DEFINE_STANDARD_RTTI(HYDROData_Object);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_Object, HYDROData_Entity);
/**
* Updates the name of this object.
#define _DEVDEBUG_
#include "HYDRO_trace.hxx"
-IMPLEMENT_STANDARD_HANDLE(HYDROData_Obstacle,HYDROData_ArtificialObject)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Obstacle,HYDROData_ArtificialObject)
#include "HYDROData_ArtificialObject.h"
-DEFINE_STANDARD_HANDLE(HYDROData_Obstacle, HYDROData_ArtificialObject)
-
/**\class HYDROData_Obstacle
* \brief
*
};
public:
- DEFINE_STANDARD_RTTI(HYDROData_Obstacle);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_Obstacle, HYDROData_ArtificialObject);
/**
* Returns the kind of this object. Must be redefined in all objects of known type.
#include <TopoDS_Shape.hxx>
#include <BRepTools.hxx>
-IMPLEMENT_STANDARD_HANDLE(HYDROData_ObstacleAltitude, HYDROData_IAltitudeObject)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_ObstacleAltitude, HYDROData_IAltitudeObject)
HYDROData_ObstacleAltitude::HYDROData_ObstacleAltitude()
#include "HYDROData_IAltitudeObject.h"
-DEFINE_STANDARD_HANDLE(HYDROData_ObstacleAltitude, HYDROData_IAltitudeObject)
-
/**\class HYDROData_ObstacleAltitude
* \brief Class that stores/retreives information about the obstacle altitude.
public:
- DEFINE_STANDARD_RTTI(HYDROData_ObstacleAltitude);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_ObstacleAltitude, HYDROData_IAltitudeObject);
/**
* Returns the kind of this object.
#include <QMap>
class ImageComposer_Operator;
-class Handle_HYDROData_Document;
+class HYDROData_Document;
/**\class HYDROData_OperationsFactory
*
* \returns created object related to the data structure
*/
HYDRODATA_EXPORT Handle(HYDROData_Image) CreateImage(
- Handle_HYDROData_Document theDoc, const ImageComposer_Operator* theOperator);
+ Handle(HYDROData_Document) theDoc, const ImageComposer_Operator* theOperator);
/**
* Returns the operator, initialized by the properties of theImage
#include <QColor>
#include <QStringList>
-IMPLEMENT_STANDARD_HANDLE(HYDROData_Polyline3D,HYDROData_Object)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Polyline3D,HYDROData_Object)
#include "HYDROData_Object.h"
-DEFINE_STANDARD_HANDLE(HYDROData_Polyline3D, HYDROData_Object)
-
-class Handle(HYDROData_PolylineXY);
-class Handle(HYDROData_ProfileUZ);
+class HYDROData_PolylineXY;
+class HYDROData_ProfileUZ;
class gp_XYZ;
/**\class HYDROData_Polyline3D
};
public:
- DEFINE_STANDARD_RTTI(HYDROData_Polyline3D);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_Polyline3D, HYDROData_Object);
/**
* Returns the kind of this object. Must be redefined in all objects of known type.
#include <gp_Pnt2d.hxx>
#include <vector>
-class Handle( HYDROData_Document );
+class HYDROData_Document;
class HYDROData_TopoCurve;
-class Handle(HYDROData_Object);
+class HYDROData_Object;
class HYDRODATA_EXPORT HYDROData_PolylineOperator
{
return getUniqueSectionName( aNamesSeq );
}
-IMPLEMENT_STANDARD_HANDLE(HYDROData_PolylineXY, HYDROData_IPolyline)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_PolylineXY, HYDROData_IPolyline)
HYDROData_PolylineXY::HYDROData_PolylineXY()
#include "HYDROData_IPolyline.h"
#include <TopTools_HSequenceOfShape.hxx>
-DEFINE_STANDARD_HANDLE(HYDROData_PolylineXY, HYDROData_IPolyline)
-
class QPainterPath;
class QTransform;
class TopoDS_Wire;
};
public:
- DEFINE_STANDARD_RTTI(HYDROData_PolylineXY);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_PolylineXY, HYDROData_IPolyline);
/**
Standard_Integer aTag );
~HYDROData_PriorityQueue();
- Handle_HYDROData_Entity GetMostPriorityObject( const QStringList& theZoneObjects,
+ Handle(HYDROData_Entity) GetMostPriorityObject( const QStringList& theZoneObjects,
HYDROData_Zone::MergeType& theMergeType ) const;
bool IsMorePriority( const Handle(HYDROData_Entity)& theObj1,
#include <QColor>
#include <QStringList>
-IMPLEMENT_STANDARD_HANDLE(HYDROData_Profile, HYDROData_Object)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Profile, HYDROData_Object)
HYDROData_Profile::HYDROData_Profile()
#include "HYDROData_ProfileUZ.h"
-DEFINE_STANDARD_HANDLE(HYDROData_Profile, HYDROData_Object)
-
class gp_XYZ;
class OSD_File;
-class Handle(HYDROData_Document);
+class HYDROData_Document;
/**\class HYDROData_Profile
* \brief Class that stores/retreives information about the profile.
};
public:
- DEFINE_STANDARD_RTTI(HYDROData_Profile);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_Profile, HYDROData_Object);
/**
* Returns the kind of this object. Must be redefined in all objects of known type.
#include <HYDROData_PolylineXY.h>
-IMPLEMENT_STANDARD_HANDLE(HYDROData_ProfileUZ, HYDROData_IPolyline)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_ProfileUZ, HYDROData_IPolyline)
HYDROData_ProfileUZ::HYDROData_ProfileUZ()
return aResList;
}
-void HYDROData_ProfileUZ::CalculateAndAddPoints(const NCollection_Sequence<gp_XYZ>& theXYZPoints, Handle_HYDROData_PolylineXY& thePolylineXY)
+void HYDROData_ProfileUZ::CalculateAndAddPoints(const NCollection_Sequence<gp_XYZ>& theXYZPoints, Handle(HYDROData_PolylineXY)& thePolylineXY)
{
// Fill 2D polyline
for ( int i = 1; i <= theXYZPoints.Size(); i++ ) {
#include "HYDROData_IPolyline.h"
-DEFINE_STANDARD_HANDLE(HYDROData_ProfileUZ, HYDROData_IPolyline)
-
class gp_XYZ;
-class Handle_HYDROData_PolylineXY;
+class HYDROData_PolylineXY;
/**\class HYDROData_ProfileUZ
* \brief Class that stores/retreives information about the
};
public:
- DEFINE_STANDARD_RTTI(HYDROData_ProfileUZ);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_ProfileUZ, HYDROData_IPolyline);
/**
*/
HYDRODATA_EXPORT virtual PointsList GetPoints( const int theSectionIndex = -1, bool IsConvertToGlobal = false ) const;
- HYDRODATA_EXPORT virtual void CalculateAndAddPoints(const NCollection_Sequence<gp_XYZ>& theXYZPoints, Handle_HYDROData_PolylineXY& thePolylineXY);
+ HYDRODATA_EXPORT virtual void CalculateAndAddPoints(const NCollection_Sequence<gp_XYZ>& theXYZPoints,
+ Handle(HYDROData_PolylineXY)& thePolylineXY);
protected:
#include <TopExp.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
-#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_DataMapOfShapeReal.hxx>
HYDROData_Make3dMesh::HYDROData_Make3dMesh( const TopoDS_Shape& aShape,
#include <Standard_Real.hxx>
#include <IntCurvesFace_ShapeIntersector.hxx>
+#include <TopTools_ListOfShape.hxx>
+#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
class TopoDS_Shape;
class TopoDS_Edge;
class TopoDS_Face;
class TopoDS_Wire;
class TopoDS_Vertex;
-class TopTools_ListOfShape;
-class TopTools_IndexedDataMapOfShapeListOfShape;
class gp_Pnt;
class HYDROData_Make3dMesh
//#define DEB_GET_REGION_SHAPE
-IMPLEMENT_STANDARD_HANDLE(HYDROData_Region, HYDROData_Entity)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Region, HYDROData_Entity)
#include "HYDROData_ShapesGroup.h"
-DEFINE_STANDARD_HANDLE(HYDROData_Region, HYDROData_Entity)
-
-class Handle(HYDROData_Zone);
-class Handle(HYDROData_Document);
+class HYDROData_Zone;
+class HYDROData_Document;
class TopoDS_Shape;
class TopoDS_Face;
class QStringList;
*/
class HYDROData_Region : public HYDROData_Entity
{
-
protected:
-
/**
* Enumeration of tags corresponding to the persistent object parameters.
*/
};
public:
- DEFINE_STANDARD_RTTI(HYDROData_Region);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_Region, HYDROData_Entity);
/**
* Returns the kind of this object. Must be redefined in all objects of known type.
#include <QStringList>
-IMPLEMENT_STANDARD_HANDLE(HYDROData_River,HYDROData_NaturalObject)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_River,HYDROData_NaturalObject)
#include "HYDROData_NaturalObject.h"
-DEFINE_STANDARD_HANDLE(HYDROData_River, HYDROData_NaturalObject)
-
/**\class HYDROData_River
* \brief
*
};
public:
- DEFINE_STANDARD_RTTI(HYDROData_River);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_River, HYDROData_NaturalObject);
/**
* Returns the kind of this object. Must be redefined in all objects of known type.
#include <BRep_Tool.hxx>
#include <BRepTools.hxx>
#include <Precision.hxx>
-#include <Handle_Geom_Curve.hxx>
-#include <Handle_Geom_Line.hxx>
-#include <Handle_Geom_TrimmedCurve.hxx>
+#include <Geom_Curve.hxx>
+#include <Geom_Line.hxx>
+#include <Geom_TrimmedCurve.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx>
#include <BRepBuilderAPI_MakeWire.hxx>
void HYDROData_ShapeFile::Export(Handle(HYDROData_Document) theDocument,
const QString& aFileName,
- NCollection_Sequence<Handle_HYDROData_PolylineXY> aPolyXYSeq,
- NCollection_Sequence<Handle_HYDROData_Polyline3D> aPoly3DSeq,
+ NCollection_Sequence<Handle(HYDROData_PolylineXY)> aPolyXYSeq,
+ NCollection_Sequence<Handle(HYDROData_Polyline3D)> aPoly3DSeq,
QStringList& aNonExpList)
{
SHPHandle hSHPHandle;
if (!aPolyXYSeq.IsEmpty() && aPoly3DSeq.IsEmpty())
{
- hSHPHandle = SHPCreate( aFileName.toAscii().data(), SHPT_ARC );
+ hSHPHandle = SHPCreate( aFileName.toLatin1().data(), SHPT_ARC );
for (int i = 1; i <= aPolyXYSeq.Size(); i++)
if (WriteObjectPolyXY(theDocument, hSHPHandle, aPolyXYSeq(i)) != 1)
aNonExpList.append(aPolyXYSeq(i)->GetName());
}
else if (aPolyXYSeq.IsEmpty() && !aPoly3DSeq.IsEmpty())
{
- hSHPHandle = SHPCreate( aFileName.toAscii().data(), SHPT_ARCZ );
+ hSHPHandle = SHPCreate( aFileName.toLatin1().data(), SHPT_ARCZ );
for (int i = 1; i <= aPoly3DSeq.Size(); i++)
if (WriteObjectPoly3D(theDocument, hSHPHandle, aPoly3DSeq(i)) != 1)
aNonExpList.append(aPoly3DSeq(i)->GetName());
void HYDROData_ShapeFile::Export(Handle(HYDROData_Document) theDocument,
const QString& aFileName,
- const Handle_HYDROData_LandCoverMap& aLCM,
+ const Handle(HYDROData_LandCoverMap)& aLCM,
QStringList& aNonExpList,
bool bCheckLinear, bool bUseDiscr, double theDefl)
{
SHPHandle hSHPHandle = NULL;
if ( !aLCM.IsNull() && !aLCM->IsEmpty())
{
- hSHPHandle = SHPCreate( aFileName.toAscii().data(), SHPT_POLYGON );
+ hSHPHandle = SHPCreate( aFileName.toLatin1().data(), SHPT_POLYGON );
HYDROData_LandCoverMap::Explorer It( aLCM );
for( ; It.More(); It.Next())
{
int HYDROData_ShapeFile::WriteObjectPolyXY(Handle(HYDROData_Document) theDocument,
SHPHandle theShpHandle,
- Handle_HYDROData_PolylineXY thePoly )
+ Handle(HYDROData_PolylineXY) thePoly )
{
SHPObject *aSHPObj;
std::vector<double> x, y;
int HYDROData_ShapeFile::WriteObjectPoly3D(Handle(HYDROData_Document) theDocument,
SHPHandle theShpHandle,
- Handle_HYDROData_Polyline3D thePoly )
+ Handle(HYDROData_Polyline3D) thePoly )
{
SHPObject *aSHPObj;
std::vector<double> x, y, z;
return;
TopoDS_Edge E;
int nParts = anObj->nParts;
- Handle_Geom_Plane aPlaneSur = new Geom_Plane(gp_Pnt(0,0,0), gp_Dir(0,0,1));
+ Handle(Geom_Plane) aPlaneSur = new Geom_Plane(gp_Pnt(0,0,0), gp_Dir(0,0,1));
BRep_Builder BB;
BB.MakeFace(F);
gp_Pnt P2 = BRep_Tool::Pnt(VPoints(k + 1));
if (P1.Distance(P2) < Precision::Confusion())
continue;
- Handle_Geom_TrimmedCurve aTC = GC_MakeSegment(P1, P2).Value();
+ Handle(Geom_TrimmedCurve) aTC = GC_MakeSegment(P1, P2).Value();
TopoDS_Edge E;
if ( k != VPoints.Size() - 2)
E = BRepLib_MakeEdge(aTC, VPoints(k), VPoints(k + 1)).Edge();
int Stat = TryOpenShapeFile(theFileName);
if (Stat != 0)
return Stat;
- myHSHP = SHPOpen( theFileName.toAscii().data(), "rb" );
+ myHSHP = SHPOpen( theFileName.toLatin1().data(), "rb" );
if (!Parse(myHSHP, HYDROData_ShapeFile::ShapeType_Polygon, theShapeTypeOfFile))
return 0;
for (size_t i = 0; i < mySHPObjects.size(); i++)
void HYDROData_ShapeFile::ReadSHPPolyXY(Handle(HYDROData_Document) theDocument, SHPObject* anObj, QString theFileName,
- int theInd, NCollection_Sequence<Handle_HYDROData_Entity>& theEntities)
+ int theInd, NCollection_Sequence<Handle(HYDROData_Entity)>& theEntities)
{
Handle(HYDROData_PolylineXY) aPolylineXY = Handle(HYDROData_PolylineXY)::DownCast( theDocument->CreateObject( KIND_POLYLINEXY ) );
anObj->padfY[StartIndex] == anObj->padfY[EndIndex - 1] )
{
IsClosed = true;
- aPolylineXY->AddSection( TCollection_AsciiString( ("poly_section_" + QString::number(i)).data()->toAscii()), aSectType, true);
+ aPolylineXY->AddSection( TCollection_AsciiString( ("poly_section_" + QString::number(i)).data()->toLatin1()), aSectType, true);
}
else
- aPolylineXY->AddSection( TCollection_AsciiString( ("poly_section_" + QString::number(i)).data()->toAscii()), aSectType, false);
+ aPolylineXY->AddSection( TCollection_AsciiString( ("poly_section_" + QString::number(i)).data()->toLatin1()), aSectType, false);
if (IsClosed)
EndIndex--;
}
void HYDROData_ShapeFile::ReadSHPPoly3D(Handle(HYDROData_Document) theDocument, SHPObject* anObj, QString theFileName,
- int theInd, NCollection_Sequence<Handle_HYDROData_Entity>& theEntities)
+ int theInd, NCollection_Sequence<Handle(HYDROData_Entity)>& theEntities)
{
Handle(HYDROData_PolylineXY) aPolylineXY = Handle(HYDROData_PolylineXY)::DownCast( theDocument->CreateObject( KIND_POLYLINEXY ) );
anObj->padfZ[StartIndex] == anObj->padfZ[EndIndex - 1])
{
IsClosed = true;
- aPolylineXY->AddSection( TCollection_AsciiString( ("poly_section_" + QString::number(i)).data()->toAscii()), aSectType, true );
+ aPolylineXY->AddSection( TCollection_AsciiString( ("poly_section_" + QString::number(i)).data()->toLatin1()), aSectType, true );
}
else
- aPolylineXY->AddSection( TCollection_AsciiString( ("poly_section_" + QString::number(i)).data()->toAscii()), aSectType, false );
+ aPolylineXY->AddSection( TCollection_AsciiString( ("poly_section_" + QString::number(i)).data()->toLatin1()), aSectType, false );
if (IsClosed)
EndIndex--;
int HYDROData_ShapeFile::ImportPolylines(Handle(HYDROData_Document) theDocument, const QString& theFileName,
- NCollection_Sequence<Handle_HYDROData_Entity>& theEntities, int& theShapeTypeOfFile)
+ NCollection_Sequence<Handle(HYDROData_Entity)>& theEntities, int& theShapeTypeOfFile)
{
//Free();
int aStat = TryOpenShapeFile(theFileName);
anExistingNames.push_back(anIter.Current()->GetName());
SHPHandle aHSHP;
- aHSHP = SHPOpen( theFileName.toAscii().data(), "rb" );
+ aHSHP = SHPOpen( theFileName.toLatin1().data(), "rb" );
QFileInfo aFileInfo(theFileName);
QString aBaseFileName = aFileInfo.baseName();
return -3;
FILE* pFileSHP = NULL;
- pFileSHP = fopen (aSHPfile.toAscii().data(), "r");
+ pFileSHP = fopen (aSHPfile.toLatin1().data(), "r");
FILE* pFileSHX = NULL;
- pFileSHX = fopen (aSHXfile.toAscii().data(), "r");
+ pFileSHX = fopen (aSHXfile.toLatin1().data(), "r");
if (pFileSHP == NULL || pFileSHX == NULL)
{
QString aSHPfile = theSHPFilePath.simplified();
QString aDBFfile = theSHPFilePath.simplified().replace( theSHPFilePath.simplified().size() - 4, 4, ".dbf");
FILE* pFileDBF = NULL;
- pFileDBF = fopen (aDBFfile.toAscii().data(), "r");
+ pFileDBF = fopen (aDBFfile.toLatin1().data(), "r");
if (pFileDBF == NULL)
{
bool HYDROData_ShapeFile::DBF_OpenDBF(const QString& thePathToDBFFile)
{
- myHDBF = DBFOpen( thePathToDBFFile.toAscii().data(), "r" );
+ myHDBF = DBFOpen( thePathToDBFFile.toLatin1().data(), "r" );
if(myHDBF != NULL)
return true;
else
#include <NCollection_Sequence.hxx>
#include <QStringList>
#include "HYDROData.h"
+#include <TopTools_SequenceOfShape.hxx>
//extern "C" {
#include <shapefil.h>
//};
class gp_XYZ;
-class Handle_HYDROData_PolylineXY;
-class Handle_HYDROData_Polyline3D;
-class Handle(HYDROData_Document);
-class TopTools_SequenceOfShape;
+class HYDROData_PolylineXY;
+class HYDROData_Polyline3D;
+class HYDROData_Document;
class TopoDS_Face;
class TopoDS_Shape;
-class Handle_HYDROData_Entity;
-class Handle_HYDROData_LandCoverMap;
+class HYDROData_Entity;
+class HYDROData_LandCoverMap;
class HYDROData_ShapeFile
{
//Export operation
HYDRODATA_EXPORT void Export(Handle(HYDROData_Document) theDocument,
const QString& aFileName,
- NCollection_Sequence<Handle_HYDROData_PolylineXY> aPolyXYSeq,
- NCollection_Sequence<Handle_HYDROData_Polyline3D> aPoly3DSeq,
+ NCollection_Sequence<Handle(HYDROData_PolylineXY)> aPolyXYSeq,
+ NCollection_Sequence<Handle(HYDROData_Polyline3D)> aPoly3DSeq,
QStringList& aNonExpList);
HYDRODATA_EXPORT void Export(Handle(HYDROData_Document) theDocument,
const QString& aFileName,
- const Handle_HYDROData_LandCoverMap& aLCM,
+ const Handle(HYDROData_LandCoverMap)& aLCM,
QStringList& aNonExpList,
bool bCheckLinear = true,
bool bUseDiscr = false,
double theDefl = 0.1);
int WriteObjectPolyXY(Handle(HYDROData_Document) theDocument, SHPHandle theShpHandle,
- Handle_HYDROData_PolylineXY thePoly );
+ Handle(HYDROData_PolylineXY) thePoly );
int WriteObjectPoly3D(Handle(HYDROData_Document) theDocument, SHPHandle theShpHandle,
- Handle_HYDROData_Polyline3D thePoly );
+ Handle(HYDROData_Polyline3D) thePoly );
int WriteObjectPolygon(Handle(HYDROData_Document) theDocument, SHPHandle theShpHandle,
const TopoDS_Shape& theInputShape, bool bUseDiscr, double theDefl );
//Import Polyline
void ReadSHPPolyXY(Handle(HYDROData_Document) theDocument, SHPObject* anObj, QString theFileName,
- int theInd, NCollection_Sequence<Handle_HYDROData_Entity>& theEntities);
+ int theInd, NCollection_Sequence<Handle(HYDROData_Entity)>& theEntities);
void ReadSHPPoly3D(Handle(HYDROData_Document) theDocument, SHPObject* anObj, QString theFileName,
- int theInd, NCollection_Sequence<Handle_HYDROData_Entity>& theEntities);
+ int theInd, NCollection_Sequence<Handle(HYDROData_Entity)>& theEntities);
HYDRODATA_EXPORT int ImportPolylines(Handle(HYDROData_Document) theDocument, const QString& theFileName,
- NCollection_Sequence<Handle_HYDROData_Entity>& theEntities, int& theShapeTypeOfFile);
+ NCollection_Sequence<Handle(HYDROData_Entity)>& theEntities, int& theShapeTypeOfFile);
HYDRODATA_EXPORT QString GetShapeTypeName(int theType);
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <ShapeUpgrade_UnifySameDomain.hxx>
-IMPLEMENT_STANDARD_HANDLE(HYDROData_ShapesGroup,HYDROData_Entity)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_ShapesGroup,HYDROData_Entity)
void HYDROData_ShapesGroup::GroupDefinition::Update( SeqOfGroupsDefs* theGroupsDefs,
#define HYDROData_ShapesGroup_HeaderFile
#include <HYDROData_Entity.h>
-
#include <TopTools_SequenceOfShape.hxx>
-
+#include <TopTools_ListOfShape.hxx>
#include <QString>
class TopoDS_Shape;
-class TopTools_ListOfShape;
class BRepBuilderAPI_MakeShape;
class ShapeUpgrade_UnifySameDomain;
-DEFINE_STANDARD_HANDLE(HYDROData_ShapesGroup, HYDROData_Entity)
-
/**\class HYDROData_ShapesGroup
* \brief Class that stores/retreives the sequence of shapes.
*/
};
public:
- DEFINE_STANDARD_RTTI(HYDROData_ShapesGroup);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_ShapesGroup, HYDROData_Entity);
/**
* Returns the kind of this object. Must be redefined in all objects of known type.
#include "HYDROData.h"
#include <TopAbs_ShapeEnum.hxx>
+#include <TopTools_ListOfShape.hxx>
+#include <TopTools_SequenceOfShape.hxx>
class TopoDS_Shape;
class TopoDS_Vertex;
class TopoDS_Edge;
-class TopTools_SequenceOfShape;
-class TopTools_ListOfShape;
class HYDRODATA_EXPORT HYDROData_ShapesTool {
{
}
-void HYDROData_SinusX::CollectExistingNames(Handle_HYDROData_Document theDocument)
+void HYDROData_SinusX::CollectExistingNames(Handle(HYDROData_Document) theDocument)
{
HYDROData_Iterator anIter( theDocument );
int anInd = 0;
}
-bool HYDROData_SinusX::Import(const QString& theFilePath, Handle(HYDROData_Document) theDocument, NCollection_Sequence<Handle_HYDROData_Entity>& theEntities)
+bool HYDROData_SinusX::Import(const QString& theFilePath, Handle(HYDROData_Document) theDocument,
+ NCollection_Sequence<Handle(HYDROData_Entity)>& theEntities)
{
if ( theFilePath.isEmpty() )
{
}
-void HYDROData_SinusX::SXToHydro(Handle(HYDROData_Document) theDocument, NCollection_Sequence<Handle_HYDROData_Entity>& theEntities)
+void HYDROData_SinusX::SXToHydro(Handle(HYDROData_Document) theDocument, NCollection_Sequence<Handle(HYDROData_Entity)>& theEntities)
{
for ( size_t i = 0; i < myCurveBlocks.size(); i++ )
{
}
-bool HYDROData_SinusX::Export(const QString& theFilePath, const NCollection_Sequence<Handle_HYDROData_Entity>& theEntities)
+bool HYDROData_SinusX::Export(const QString& theFilePath, const NCollection_Sequence<Handle(HYDROData_Entity)>& theEntities)
{
if ( theFilePath.isEmpty() )
{
}
-void HYDROData_SinusX::HydroToSX(QFile& theFile, const NCollection_Sequence<Handle_HYDROData_Entity>& theEntities)
+void HYDROData_SinusX::HydroToSX(QFile& theFile, const NCollection_Sequence<Handle(HYDROData_Entity)>& theEntities)
{
QTextStream aTextStream(&theFile);
aTextStream << "C Generated by HYDRO Module\n";
for (int i = 1; i <= theEntities.Size(); i++)
{
- Handle_HYDROData_Entity anEnt = theEntities.Value(i);
+ Handle(HYDROData_Entity) anEnt = theEntities.Value(i);
if (anEnt->IsKind( STANDARD_TYPE(HYDROData_Bathymetry) ))
{
Handle(HYDROData_Bathymetry) aBathy = Handle(HYDROData_Bathymetry)::DownCast( anEnt );
class QFile;
class gp_XYZ;
-class Handle_HYDROData_Entity;
-class Handle_HYDROData_Document;
+class HYDROData_Entity;
+class HYDROData_Document;
struct HYDROGUI_CurveBlock
{
public:
HYDROData_SinusX( );
virtual ~HYDROData_SinusX();
- bool Import (const QString& theFilePath, Handle(HYDROData_Document) theDocument, NCollection_Sequence<Handle_HYDROData_Entity>& theEntities);
- bool Export(const QString& theFilePath, const NCollection_Sequence<Handle_HYDROData_Entity>& theEntities);
+ bool Import (const QString& theFilePath, Handle(HYDROData_Document) theDocument, NCollection_Sequence<Handle(HYDROData_Entity)>& theEntities);
+ bool Export(const QString& theFilePath, const NCollection_Sequence<Handle(HYDROData_Entity)>& theEntities);
private:
- void SXToHydro(Handle(HYDROData_Document) theDocument, NCollection_Sequence<Handle_HYDROData_Entity>& theEntities);
+ void SXToHydro(Handle(HYDROData_Document) theDocument, NCollection_Sequence<Handle(HYDROData_Entity)>& theEntities);
bool Parse( QFile& theFile );
- void CollectExistingNames(Handle_HYDROData_Document theDocument);
+ void CollectExistingNames(Handle(HYDROData_Document) theDocument);
QString GetName(const QString& theName);
- void HydroToSX( QFile& theFile, const NCollection_Sequence<Handle_HYDROData_Entity>& theEntities);
+ void HydroToSX( QFile& theFile, const NCollection_Sequence<Handle(HYDROData_Entity)>& theEntities);
private:
#include "HYDROData_SplitShapesGroup.h"
-IMPLEMENT_STANDARD_HANDLE(HYDROData_SplitShapesGroup,HYDROData_ShapesGroup)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_SplitShapesGroup,HYDROData_ShapesGroup)
HYDROData_SplitShapesGroup::HYDROData_SplitShapesGroup()
#include <HYDROData_ShapesGroup.h>
-DEFINE_STANDARD_HANDLE(HYDROData_SplitShapesGroup, HYDROData_ShapesGroup)
-
-
/**\class HYDROData_SplitShapesGroup
* \brief Class that stores/retreives the sequence of split shapes.
*/
};
public:
- DEFINE_STANDARD_RTTI(HYDROData_SplitShapesGroup);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_SplitShapesGroup, HYDROData_ShapesGroup);
/**
* Returns the kind of this object. Must be redefined in all objects of known type.
#include <TopTools_ListOfShape.hxx>
#include <QStringList>
-class Handle(HYDROData_PolylineXY);
+class HYDROData_PolylineXY;
/**
* \class HYDROData_SplitToZonesTool
#include <TColStd_Array1OfReal.hxx>
#include <TColStd_ListOfReal.hxx>
#include <TColStd_ListIteratorOfListOfReal.hxx>
-#include <TCollection_CompareOfReal.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColgp_HArray1OfPnt.hxx>
#include <TopTools_HArray1OfShape.hxx>
-#include <SortTools_QuickSortOfReal.hxx>
-
#include <QColor>
#include <QStringList>
+#include <QVector>
//#define DEB_STREAM 1
#ifdef DEB_STREAM
typedef NCollection_DataMap<Standard_Real, Handle(HYDROData_Profile)> HYDROData_DataMapOfRealOfHDProfile;
-IMPLEMENT_STANDARD_HANDLE(HYDROData_Stream,HYDROData_NaturalObject)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Stream,HYDROData_NaturalObject)
if ( aList.IsEmpty() )
return;
- TColStd_Array1OfReal anArr( 1, aList.Extent() );
+ QVector<double> anArr( aList.Extent() );
TColStd_ListIteratorOfListOfReal it( aList );
for ( int j = 1; it.More(); it.Next(), j++ )
- anArr( j ) = it.Value();
+ anArr[j-1] = it.Value();
// sorting
if ( aList.Extent() > 1 )
{
- TCollection_CompareOfReal Compar;
- SortTools_QuickSortOfReal::Sort( anArr, Compar );
+ //TCollection_CompareOfReal Compar;
+ //SortTools_QuickSortOfReal::Sort( anArr, Compar );
+ std::sort( anArr.begin(), anArr.end() );
- for (int j = 1; j <= anArr.Length(); j++) {
- const Standard_Real aKey = anArr(j);
+ for (int j = 1; j <= anArr.size(); j++) {
+ const Standard_Real aKey = anArr[j-1];
const Handle(HYDROData_Profile)& aProfile = aDM.Find(aKey);
insertProfileInToOrder( aProfile );
}
return KIND_STREAM_ALTITUDE;
}
-void HYDROData_Stream::setParametersArray( const TColStd_Array1OfReal& theArray )
+void HYDROData_Stream::setParametersArray( const QVector<double>& theArray )
{
- if ( theArray.Length() == 0 )
+ if ( theArray.size() == 0 )
{
removeParametersArray();
return;
TDF_Label aLabel = myLab.FindChild( DataTag_ParamsArray );
+ int n = theArray.size();
Handle(TDataStd_RealArray) aParamsArray =
- TDataStd_RealArray::Set( aLabel, theArray.Lower(), theArray.Upper() );
-
- for ( int i = theArray.Lower(), n = theArray.Upper(); i <= n; ++i )
+ TDataStd_RealArray::Set( aLabel, 1, n );
+ for ( int i = 0; i < n; ++i )
{
- const Standard_Real& aParam = theArray( i );
- aParamsArray->SetValue( i, aParam );
+ const Standard_Real& aParam = theArray[i];
+ aParamsArray->SetValue( i+1, aParam );
}
}
{
aResIndex = 0;
- TColStd_Array1OfReal aNewArr( anArr->Lower(), anArr->Upper() + 1 );
+ QVector<double> aNewArr( anArr->Upper() );
bool isInserted = false;
for ( int i = anArr->Lower(), j = i, n = anArr->Upper(); i <= n; ++i, ++j )
}
else
{
- aNewArr( j ) = theParam;
+ aNewArr[j-1] = theParam;
isInserted = true;
++j;
}
}
- aNewArr( j ) = aStoredParam;
+ aNewArr[j-1] = aStoredParam;
}
if ( !isInserted )
{
aResIndex = -1;
- aNewArr( aNewArr.Upper() ) = theParam;
+ aNewArr[aNewArr.size()-1] = theParam;
}
setParametersArray( aNewArr );
}
else
{
- TColStd_Array1OfReal aNewArr( 1, 1 );
- aNewArr.SetValue( 1, theParam );
+ QVector<double> aNewArr( 1 );
+ aNewArr[0] = theParam;
setParametersArray( aNewArr );
}
return;
}
- TColStd_Array1OfReal aNewArr( aParamsArray->Lower(), aParamsArray->Upper() - 1 );
+ QVector<double> aNewArr( aParamsArray->Upper() - 2 );
for ( int i = aParamsArray->Lower(), j = i, k = 0, n = aParamsArray->Upper(); i <= n; ++i, ++k )
{
if ( k == theIndex )
continue;
- aNewArr.SetValue( j, aStoredParam );
+ aNewArr[j-1] = aStoredParam;
++j;
}
#endif
return true;
-}
\ No newline at end of file
+}
#include <Geom_BSplineCurve.hxx>
-DEFINE_STANDARD_HANDLE(HYDROData_Stream, HYDROData_NaturalObject)
-
-class Handle(HYDROData_PolylineXY);
-class Handle(HYDROData_Polyline3D);
-class Handle(HYDROData_Profile);
+class HYDROData_PolylineXY;
+class HYDROData_Polyline3D;
+class HYDROData_Profile;
class HYDROData_IProfilesInterpolator;
-class TColStd_Array1OfReal;
-class Handle(TopTools_HArray1OfShape);
+class TopTools_HArray1OfShape;
/**\class HYDROData_Stream
};
public:
-
- DEFINE_STANDARD_RTTI(HYDROData_Stream);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_Stream, HYDROData_NaturalObject);
public:
private:
- void setParametersArray( const TColStd_Array1OfReal& theArray );
+ void setParametersArray( const QVector<double>& theArray );
TColStd_Array1OfReal* getParametersArray() const;
#include <BRep_Builder.hxx>
#include <BRepBuilderAPI_MakeVertex.hxx>
#endif
-IMPLEMENT_STANDARD_HANDLE(HYDROData_StreamAltitude, HYDROData_IAltitudeObject)
+
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_StreamAltitude, HYDROData_IAltitudeObject)
HYDROData_StreamAltitude::HYDROData_StreamAltitude()
#include "HYDROData_IAltitudeObject.h"
-DEFINE_STANDARD_HANDLE(HYDROData_StreamAltitude, HYDROData_IAltitudeObject)
-
class TopoDS_Wire;
/**\class HYDROData_StreamAltitude
public:
- DEFINE_STANDARD_RTTI(HYDROData_StreamAltitude);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_StreamAltitude, HYDROData_IAltitudeObject);
/**
* Returns the kind of this object.
#include <QFile>
#include <QTextStream>
-IMPLEMENT_STANDARD_HANDLE( HYDROData_StricklerTable, HYDROData_Entity )
IMPLEMENT_STANDARD_RTTIEXT( HYDROData_StricklerTable, HYDROData_Entity )
HYDROData_StricklerTable::HYDROData_StricklerTable()
#include <TColStd_SequenceOfExtendedString.hxx>
-class Handle( TDataStd_NamedData );
-
-DEFINE_STANDARD_HANDLE( HYDROData_StricklerTable, HYDROData_Entity )
+class TDataStd_NamedData;
class HYDROData_StricklerTable : public HYDROData_Entity
{
HYDRODATA_EXPORT ~HYDROData_StricklerTable();
public:
- DEFINE_STANDARD_RTTI( HYDROData_StricklerTable );
+ DEFINE_STANDARD_RTTIEXT( HYDROData_StricklerTable, HYDROData_Entity );
HYDRODATA_EXPORT virtual const ObjectKind GetKind() const;
#include <QStringList>
#include <Precision.hxx>
-class Handle_HYDROData_Document;
-class Handle_HYDROData_Entity;
+class HYDROData_Document;
+class HYDROData_Entity;
class HYDROData_SequenceOfObjects;
class MapOfTreatedObjects;
class gp_XY;
class TopoDS_Face;
class TopoDS_Shape;
class TopoDS_Wire;
-class TopTools_SequenceOfShape;
class Quantity_Color;
class HYDRODATA_EXPORT HYDROData_Tool {
* \param theIsTryToUsePurePrefix if true - the prefix will be returned if the name equal to the prefix is not busy
* \return generated name
*/
- static QString GenerateObjectName( const Handle_HYDROData_Document& theDoc,
+ static QString GenerateObjectName( const Handle(HYDROData_Document)& theDoc,
const QString& thePrefix,
const QStringList& theUsedNames = QStringList(),
const bool theIsTryToUsePurePrefix = false );
* \param theObject object to check
* \return true if object is geometry object
*/
- static bool IsGeometryObject( const Handle_HYDROData_Entity& theObject );
+ static bool IsGeometryObject( const Handle(HYDROData_Entity)& theObject );
/**
* \brief Updates the child object name.
*/
static void UpdateChildObjectName( const QString& theOldStr,
const QString& theNewStr,
- const Handle_HYDROData_Entity& theObject );
+ const Handle(HYDROData_Entity)& theObject );
/**
#define HYDRODATA_TOPOCURVE_H
#include <deque>
-#include <Handle_Geom_BSplineCurve.hxx>
+#include <Geom_BSplineCurve.hxx>
#include <HYDROData.h>
#include <list>
#include <TopExp.hxx>
#include <TDataStd_AsciiString.hxx>
-IMPLEMENT_STANDARD_HANDLE(HYDROData_VisualState, HYDROData_Entity)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_VisualState, HYDROData_Entity)
HYDROData_VisualState::HYDROData_VisualState()
#include <HYDROData_Entity.h>
-DEFINE_STANDARD_HANDLE(HYDROData_VisualState, HYDROData_Entity)
-
/**\class HYDROData_VisualState
* \brief Class that stores/retreives information about the visual state.
*
};
public:
- DEFINE_STANDARD_RTTI(HYDROData_VisualState);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_VisualState, HYDROData_Entity);
/**
* Returns the kind of this object. Must be redefined in all objects of known type.
#define _DEVDEBUG_
#include "HYDRO_trace.hxx"
-IMPLEMENT_STANDARD_HANDLE(HYDROData_Zone, HYDROData_Entity)
IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Zone, HYDROData_Entity)
#include "HYDROData_Entity.h"
#include "HYDROData_IInterpolator.h"
-class Handle(HYDROData_LandCover);
+class HYDROData_LandCover;
class TopoDS_Shape;
-DEFINE_STANDARD_HANDLE(HYDROData_Zone, HYDROData_Entity)
-
/**\class HYDROData_Zone
* \brief Class that stores/retreives information about the 2d face.
{
public:
-
// Enumeration of mergin types for conflict altitudes/types
enum MergeType
{
};
public:
- DEFINE_STANDARD_RTTI(HYDROData_Zone);
+ DEFINE_STANDARD_RTTIEXT(HYDROData_Zone, HYDROData_Entity);
/**
* Returns the kind of this object. Must be redefined in all objects of known type.
include(../../CMake/Common.cmake)
include(../../CMake/UseQT4EXT.cmake)
-
+INCLUDE(UseQtExt)
+
set(PROJECT_HEADERS
HYDROGUI.h
HYDROGUI_AbstractDisplayer.h
HYDROGUI_TransparencyDlg.h
)
-QT4_WRAP_CPP(PROJECT_HEADERS_MOC ${PROJECT_HEADERS})
+QT_WRAP_MOC(PROJECT_HEADERS_MOC ${PROJECT_HEADERS})
set(PROJECT_SOURCES
HYDROGUI_AbstractDisplayer.cxx
- HYDROGUI_AISShape.cxx
- HYDROGUI_AISTrihedron.cxx
+ #HYDROGUI_AISShape.cxx
+ #HYDROGUI_AISTrihedron.cxx
HYDROGUI_BathymetryPrs.cxx
- HYDROGUI_CalculationDlg.cxx
+ #HYDROGUI_CalculationDlg.cxx
HYDROGUI_CalculationOp.cxx
HYDROGUI_ChannelDlg.cxx
HYDROGUI_ChannelOp.cxx
HYDROGUI_CopyPasteOp.cxx
HYDROGUI_CopyPastePositionOp.cxx
HYDROGUI_CurveCreatorProfile.cxx
- HYDROGUI_DataBrowser.cxx
+ #HYDROGUI_DataBrowser.cxx
HYDROGUI_DataModel.cxx
HYDROGUI_DataModelSync.cxx
HYDROGUI_DataObject.cxx
HYDROGUI_ImportImageDlg.cxx
HYDROGUI_ImportImageOp.cxx
HYDROGUI_ImportLandCoverMapOp.cxx
- HYDROGUI_ImportLandCoverMapDlg.cxx
- HYDROGUI_ImportPolylineOp.cxx
- HYDROGUI_ImportSinusXOp.cxx
+ #HYDROGUI_ImportLandCoverMapDlg.cxx
+ #HYDROGUI_ImportPolylineOp.cxx
+ #HYDROGUI_ImportSinusXOp.cxx
HYDROGUI_ExportSinusXOp.cxx
HYDROGUI_ExportSinusXDlg.cxx
HYDROGUI_ExportLandCoverMapDlg.cxx
HYDROGUI_InputPanel.cxx
HYDROGUI_LandCoverArgsFilter.cxx
HYDROGUI_LandCoverMapDlg.cxx
- HYDROGUI_LandCoverMapOp.cxx
- HYDROGUI_LandCoverMapPrs.cxx
+ #HYDROGUI_LandCoverMapOp.cxx
+ #HYDROGUI_LandCoverMapPrs.cxx
HYDROGUI_LocalCSDlg.cxx
HYDROGUI_LocalCSOp.cxx
HYDROGUI_MergePolylinesDlg.cxx
HYDROGUI_NameValidator.cxx
HYDROGUI_ObjSelector.cxx
HYDROGUI_ObserveImageOp.cxx
- HYDROGUI_OCCDisplayer.cxx
- HYDROGUI_OCCSelector.cxx
+ #HYDROGUI_OCCDisplayer.cxx
+ #HYDROGUI_OCCSelector.cxx
HYDROGUI_Operation.cxx
HYDROGUI_Operations.cxx
HYDROGUI_Poly3DDlg.cxx
HYDROGUI_Poly3DOp.cxx
+ HYDROGUI_Polyline.cxx
HYDROGUI_PolylineDlg.cxx
HYDROGUI_PolylineOp.cxx
HYDROGUI_ProfileDlg.cxx
HYDROGUI_PrsZoneDriver.cxx
HYDROGUI_Region.cxx
HYDROGUI_RemoveImageRefsOp.cxx
- HYDROGUI_Shape.cxx
- HYDROGUI_Polyline.cxx
- HYDROGUI_ShapeBathymetry.cxx
- HYDROGUI_ShapeImage.cxx
- HYDROGUI_ShapeLandCoverMap.cxx
+ #HYDROGUI_Shape.cxx
+ #HYDROGUI_ShapeBathymetry.cxx
+ #HYDROGUI_ShapeImage.cxx
+ #HYDROGUI_ShapeLandCoverMap.cxx
HYDROGUI_ShowHideOp.cxx
HYDROGUI_StreamDlg.cxx
HYDROGUI_StreamOp.cxx
HYDROGUI_LineEditDoubleValidator.cxx
- HYDROGUI_StricklerTableDlg.cxx
+ #HYDROGUI_StricklerTableDlg.cxx
HYDROGUI_StricklerTableOp.cxx
- HYDROGUI_StricklerTypeComboBox.cxx
+ #HYDROGUI_StricklerTypeComboBox.cxx
HYDROGUI_SplitPolylinesDlg.cxx
HYDROGUI_SplitPolylinesOp.cxx
HYDROGUI_SubmersibleOp.cxx
- HYDROGUI_Tool.cxx
- HYDROGUI_Tool2.cxx
+ #HYDROGUI_Tool.cxx
+ #HYDROGUI_Tool2.cxx
HYDROGUI_TwoImagesDlg.cxx
HYDROGUI_TwoImagesOp.cxx
- HYDROGUI_UpdateObjectOp.cxx
+ #HYDROGUI_UpdateObjectOp.cxx
HYDROGUI_VisualStateOp.cxx
HYDROGUI_VTKPrs.cxx
HYDROGUI_VTKPrsBathymetry.cxx
HYDROGUI_Wizard.cxx
HYDROGUI_Zone.cxx
HYDROGUI_ImportGeomObjectOp.cxx
- HYDROGUI_ImportObstacleFromFileOp.cxx
+ #HYDROGUI_ImportObstacleFromFileOp.cxx
HYDROGUI_ExportCalculationOp.cxx
- HYDROGUI_GeomObjectDlg.cxx
+ #HYDROGUI_GeomObjectDlg.cxx
HYDROGUI_SetColorOp.cxx
HYDROGUI_ColorDlg.cxx
- HYDROGUI_ImportProfilesOp.cxx
+ #HYDROGUI_ImportProfilesOp.cxx
HYDROGUI_GeoreferencementDlg.cxx
HYDROGUI_GeoreferencementOp.cxx
HYDROGUI_Actor.cxx
- HYDROGUI_BathymetryBoundsOp.cxx
+ #HYDROGUI_BathymetryBoundsOp.cxx
HYDROGUI_TranslateObstacleDlg.cxx
HYDROGUI_TranslateObstacleOp.cxx
- HYDROGUI_ListModel.cxx
+ #HYDROGUI_ListModel.cxx
HYDROGUI_ZLevelsDlg.cxx
HYDROGUI_ZLevelsOp.cxx
HYDROGUI_OrderedListWidget.cxx
HYDROGUI_ZLayers.cxx
HYDROGUI_ZLayers2.cxx
HYDROGUI_ZLayers3.cxx
- HYDROGUI_PriorityWidget.cxx
- HYDROGUI_PriorityTableModel.cxx
+ #HYDROGUI_PriorityWidget.cxx
+ #HYDROGUI_PriorityTableModel.cxx
HYDROGUI_RiverBottomDlg.cxx
HYDROGUI_RiverBottomOp.cxx
HYDROGUI_ViewerDlg.cxx
#include <Prs3d_LineAspect.hxx>
#include <StdPrs_WFDeflectionShape.hxx>
-IMPLEMENT_STANDARD_HANDLE(HYDROGUI_AISShape, AIS_Shape)
IMPLEMENT_STANDARD_RTTIEXT(HYDROGUI_AISShape, AIS_Shape)
HYDROGUI_AISShape::HYDROGUI_AISShape( const TopoDS_Shape& theShape )
#include <AIS_Shape.hxx>
-DEFINE_STANDARD_HANDLE(HYDROGUI_AISShape, AIS_Shape)
-
class HYDROGUI_AISShape : public AIS_Shape
{
public:
- DEFINE_STANDARD_RTTI(HYDROGUI_AISShape);
+ DEFINE_STANDARD_RTTIEXT(HYDROGUI_AISShape, AIS_Shape);
HYDROGUI_AISShape( const TopoDS_Shape& );
virtual ~HYDROGUI_AISShape();
* \brief AIS trihedron is redefined in order to show U text on the OX axis
* and Z text on the OY axis.
*/
-DEFINE_STANDARD_HANDLE(HYDROGUI_AISTrihedron, AIS_Trihedron)
class HYDROGUI_AISTrihedron : public AIS_Trihedron
{
* \param theTransformation the transformation
* \param thePresentationManager the presentation
*/
- void Compute( const Handle_Prs3d_Projector& theProjector,
- const Handle_Geom_Transformation& theTransformation,
- const Handle_Prs3d_Presentation& thePresentation );
+ void Compute( const Handle(Prs3d_Projector)& theProjector,
+ const Handle(Geom_Transformation)& theTransformation,
+ const Handle(Prs3d_Presentation)& thePresentation );
/**
* AIS trihedron compute selection method. It is empty. We do not select the trihedron
HYDROData_SequenceOfObjects anObjs = myEditedObject->GetGeometryObjects();
for( int anIndex = 1, aLength = anObjs.Length(); anIndex <= aLength; anIndex++ )
{
- Handle_HYDROData_Object anObj = Handle_HYDROData_Object::DownCast( anObjs.Value( anIndex ) );
+ Handle(HYDROData_Object) anObj = Handle(HYDROData_Object)::DownCast( anObjs.Value( anIndex ) );
HYDROData_SequenceOfObjects aGroups = anObj->GetGroups();
for( int aGIndex = 1, aGLength = aGroups.Length(); aGIndex <= aGLength; aGIndex++ )
{
- Handle_HYDROData_ShapesGroup aGroup = Handle_HYDROData_ShapesGroup::DownCast( aGroups.Value( aGIndex ) );
+ Handle(HYDROData_ShapesGroup) aGroup = Handle(HYDROData_ShapesGroup)::DownCast( aGroups.Value( aGIndex ) );
aGroupsNames.append( aGroup->GetName() );
}
}
// Create root objects:
// IMAGES
- LightApp_DataObject* anImageRootObj = createObject( aNewRootObj, tr( partitionName( KIND_IMAGE ).toAscii() ) );
+ LightApp_DataObject* anImageRootObj = createObject( aNewRootObj, tr( partitionName( KIND_IMAGE ).toLatin1() ) );
// BATHYMETRY
- LightApp_DataObject* aBathymetryRootObj = createObject( aNewRootObj, tr( partitionName( KIND_BATHYMETRY ).toAscii() ) );
+ LightApp_DataObject* aBathymetryRootObj = createObject( aNewRootObj, tr( partitionName( KIND_BATHYMETRY ).toLatin1() ) );
// POLYLINES
- LightApp_DataObject* aPolylineRootObj = createObject( aNewRootObj, tr( partitionName( KIND_POLYLINEXY ).toAscii() ) );
+ LightApp_DataObject* aPolylineRootObj = createObject( aNewRootObj, tr( partitionName( KIND_POLYLINEXY ).toLatin1() ) );
// PROFILES
- LightApp_DataObject* aProfileRootObj = createObject( aNewRootObj, tr( partitionName( KIND_PROFILE ).toAscii() ) );
+ LightApp_DataObject* aProfileRootObj = createObject( aNewRootObj, tr( partitionName( KIND_PROFILE ).toLatin1() ) );
// POLYLINES 3D
- LightApp_DataObject* aPolyline3DRootObj = createObject( aNewRootObj, tr( partitionName( KIND_POLYLINE ).toAscii() ) );
+ LightApp_DataObject* aPolyline3DRootObj = createObject( aNewRootObj, tr( partitionName( KIND_POLYLINE ).toLatin1() ) );
// NATURAL OBJECTS
- LightApp_DataObject* aNaturalObjectsRootObj = createObject( aNewRootObj, tr( partitionName( KIND_NATURAL_OBJECT ).toAscii() ) );
+ LightApp_DataObject* aNaturalObjectsRootObj = createObject( aNewRootObj, tr( partitionName( KIND_NATURAL_OBJECT ).toLatin1() ) );
// ARTIFICIAL OBJECTS
- LightApp_DataObject* anArtificialObjectsRootObj = createObject( aNewRootObj, tr( partitionName( KIND_ARTIFICIAL_OBJECT ).toAscii() ) );
+ LightApp_DataObject* anArtificialObjectsRootObj = createObject( aNewRootObj, tr( partitionName( KIND_ARTIFICIAL_OBJECT ).toLatin1() ) );
// OBSTACLES
- LightApp_DataObject* anObstaclesRootObj = createObject( aNewRootObj, tr( partitionName( KIND_OBSTACLE ).toAscii() ) );
+ LightApp_DataObject* anObstaclesRootObj = createObject( aNewRootObj, tr( partitionName( KIND_OBSTACLE ).toLatin1() ) );
// STRICKLER TABLES
- LightApp_DataObject* aStricklerTablesRootObj = createObject( aNewRootObj, tr( partitionName( KIND_STRICKLER_TABLE ).toAscii() ) );
+ LightApp_DataObject* aStricklerTablesRootObj = createObject( aNewRootObj, tr( partitionName( KIND_STRICKLER_TABLE ).toLatin1() ) );
// LAND COVER MAPS
- LightApp_DataObject* aLandCoversRootObj = createObject( aNewRootObj, tr( partitionName( KIND_LAND_COVER_MAP ).toAscii() ) );
+ LightApp_DataObject* aLandCoversRootObj = createObject( aNewRootObj, tr( partitionName( KIND_LAND_COVER_MAP ).toLatin1() ) );
// CALCULATION CASES
- LightApp_DataObject* aCalculRootObj = createObject( aNewRootObj, tr( partitionName( KIND_CALCULATION ).toAscii() ) );
+ LightApp_DataObject* aCalculRootObj = createObject( aNewRootObj, tr( partitionName( KIND_CALCULATION ).toLatin1() ) );
// VISUAL STATES
- LightApp_DataObject* aVisualStateRootObj = createObject( aNewRootObj, tr( partitionName( KIND_VISUAL_STATE ).toAscii() ) );
+ LightApp_DataObject* aVisualStateRootObj = createObject( aNewRootObj, tr( partitionName( KIND_VISUAL_STATE ).toLatin1() ) );
int aNoStricklerTableObj = 0;
HYDROData_Iterator anIterator( aDocument, KIND_UNKNOWN );
createObject( aPolylineSect, aPolyline, aGuiObj->entry(), false );
LightApp_DataObject* aCaseAOSect =
- createObject( aGuiObj, tr( partitionName( KIND_ARTIFICIAL_OBJECT ).toAscii() ),
+ createObject( aGuiObj, tr( partitionName( KIND_ARTIFICIAL_OBJECT ).toLatin1() ),
aGuiObj->entry() );
LightApp_DataObject* aCaseNOSect =
- createObject( aGuiObj, tr( partitionName( KIND_NATURAL_OBJECT ).toAscii() ),
+ createObject( aGuiObj, tr( partitionName( KIND_NATURAL_OBJECT ).toLatin1() ),
aGuiObj->entry() );
HYDROData_SequenceOfObjects aSeq = aCaseObj->GetGeometryObjects();
anObjectKind = aFatherObj->GetKind();
}
- anIcon = QObject::tr( QString("HYDRO_%1TYPE%2_ICO").arg( aNeedUpdate ).arg( anObjectKind ).toAscii() );
+ anIcon = QObject::tr( QString("HYDRO_%1TYPE%2_ICO").arg( aNeedUpdate ).arg( anObjectKind ).toLatin1() );
}
return aResMgr->loadPixmap( "HYDRO", anIcon );
#include <TopoDS_Edge.hxx>
#include <BRep_Tool.hxx>
#include <Precision.hxx>
-#include <Handle_Geom_Curve.hxx>
-#include <Handle_Geom_Line.hxx>
-#include <Handle_Geom_TrimmedCurve.hxx>
+#include <Geom_Curve.hxx>
+#include <Geom_Line.hxx>
+#include <Geom_TrimmedCurve.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <HYDROData_ShapeFile.h>
#include <SUIT_Desktop.h>
Handle(HYDROData_PolylineXY) aPolyXY;
Handle(HYDROData_Polyline3D) aPoly3D;
- NCollection_Sequence<Handle_HYDROData_PolylineXY> aPolyXYSeq;
- NCollection_Sequence<Handle_HYDROData_Polyline3D> aPoly3DSeq;
+ NCollection_Sequence<Handle(HYDROData_PolylineXY)> aPolyXYSeq;
+ NCollection_Sequence<Handle(HYDROData_Polyline3D)> aPoly3DSeq;
//
HYDROData_SequenceOfObjects aSeq = HYDROGUI_Tool::GetSelectedObjects( module() );
for( int anIndex = 1, aLength = aSeq.Length(); anIndex <= aLength; anIndex++ )
{
QStringList aNonExpList;
HYDROData_ShapeFile anExporter;
- Handle_HYDROData_Document aDoc = HYDROData_Document::Document( application()->activeStudy()->id() );
+ Handle(HYDROData_Document) aDoc = HYDROData_Document::Document( application()->activeStudy()->id() );
if (!aPolyXYSeq.IsEmpty() || !aPolyXYSeq.IsEmpty())
//Export polylines
anExporter.Export(aDoc, aFileName, aPolyXYSeq, aPoly3DSeq, aNonExpList);
QStringList SortedListOfAttr = anAttrNames.toList();
SortedListOfAttr.sort();
//
- Handle_HYDROData_LandCoverMap aLCM = Handle(HYDROData_LandCoverMap)::DownCast( aSeq(1) );
+ Handle(HYDROData_LandCoverMap) aLCM = Handle(HYDROData_LandCoverMap)::DownCast( aSeq(1) );
bool IsLinear = aLCM->CheckLinear();
HYDROGUI_ExportLandCoverMapDlg aDlg( module()->getApp()->desktop(), IsLinear, SortedListOfAttr);
if ( aDlg.exec() == HYDROGUI_ExportLandCoverMapDlg::Accepted )
#include <TColgp_Array1OfPnt.hxx>
-IMPLEMENT_STANDARD_TYPE(HYDROGUI_ImagePrs)
- IMPLEMENT_STANDARD_SUPERTYPE_ARRAY()
- STANDARD_TYPE(AIS_InteractiveObject),
- STANDARD_TYPE(SelectMgr_SelectableObject),
- STANDARD_TYPE(PrsMgr_PresentableObject),
- STANDARD_TYPE(MMgt_TShared),
- STANDARD_TYPE(Standard_Transient),
- IMPLEMENT_STANDARD_SUPERTYPE_ARRAY_END()
- IMPLEMENT_STANDARD_TYPE_END(HYDROGUI_ImagePrs)
-
- IMPLEMENT_DOWNCAST(HYDROGUI_ImagePrs,Standard_Transient)
- IMPLEMENT_STANDARD_RTTI(HYDROGUI_ImagePrs)
-
- HYDROGUI_ImagePrs::HYDROGUI_ImagePrs()
- : AIS_InteractiveObject()
+IMPLEMENT_STANDARD_RTTIEXT(HYDROGUI_ImagePrs, AIS_InteractiveObject)
+
+HYDROGUI_ImagePrs::HYDROGUI_ImagePrs()
+ : AIS_InteractiveObject()
{
}
class Font_FTFont;
class HYDROGUI_ImagePrs;
-DEFINE_STANDARD_HANDLE(HYDROGUI_ImagePrs, AIS_InteractiveObject)
-
class HYDROGUI_ImagePrs : public AIS_InteractiveObject
{
public:
const Handle(Prs3d_Presentation)&, const Standard_Integer = 0 );
virtual void ComputeSelection( const Handle(SelectMgr_Selection)&, const Standard_Integer );
- DEFINE_STANDARD_RTTI(HYDROGUI_ImagePrs)
+ DEFINE_STANDARD_RTTIEXT(HYDROGUI_ImagePrs, AIS_InteractiveObject)
private:
gp_Pnt convert( const QPointF& ) const;
if ( !aPanel->getFileName().isEmpty() )
anObjName = aPanel->getObjectName();
- Handle_HYDROData_Document aDoc = HYDROData_Document::Document( application()->activeStudy()->id() );
+ Handle(HYDROData_Document) aDoc = HYDROData_Document::Document( application()->activeStudy()->id() );
//check if name of LCM is already exists
QSet<QString> aNameList;
//Collect all strickler_types
QSet<QString> aSTSet;
- Handle_HYDROData_Document aDoc = HYDROData_Document::Document( application()->activeStudy()->id() );
+ Handle(HYDROData_Document) aDoc = HYDROData_Document::Document( application()->activeStudy()->id() );
Handle(HYDROData_StricklerTable) DefStricklerTableObj;
if ( aDoc )
{
#include <NCollection_Sequence.hxx>
class SUIT_FileDlg;
-class Handle_HYDROData_Entity;
+class HYDROData_Entity;
class HYDROGUI_ImportPolylineOp : public HYDROGUI_Operation
{
protected:
virtual void startOperation();
virtual void onApply();
- void UpdateView( NCollection_Sequence<Handle_HYDROData_Entity>& anEntities);
+ void UpdateView( NCollection_Sequence<Handle(HYDROData_Entity)>& anEntities);
private:
SUIT_FileDlg* myFileDlg;
if (anExt == "sx")
{
HYDROData_SinusX aSinusXImporter;
- NCollection_Sequence<Handle_HYDROData_Entity> anEntities;
+ NCollection_Sequence<Handle(HYDROData_Entity)> anEntities;
if (aSinusXImporter.Import(aFileName, doc(), anEntities))
{
UpdateView(anEntities);
QApplication::restoreOverrideCursor();
}
-void HYDROGUI_ImportSinusXOp::UpdateView( NCollection_Sequence<Handle_HYDROData_Entity>& anEntities)
+void HYDROGUI_ImportSinusXOp::UpdateView( NCollection_Sequence<Handle(HYDROData_Entity)>& anEntities)
{
size_t anActiveViewId = HYDROGUI_Tool::GetActiveGraphicsViewId( module() );
if ( anActiveViewId == 0 )
#include <NCollection_Sequence.hxx>
class SUIT_FileDlg;
-class Handle_HYDROData_Entity;
+class HYDROData_Entity;
class HYDROGUI_ImportSinusXOp : public HYDROGUI_Operation
{
protected:
virtual void startOperation();
virtual void onApply();
- void UpdateView( NCollection_Sequence<Handle_HYDROData_Entity>& anEntities);
+ void UpdateView( NCollection_Sequence<Handle(HYDROData_Entity)>& anEntities);
private:
SUIT_FileDlg* myFileDlg;
};
#include <HYDROData_LandCoverMap.h>
#include <HYDROData_StricklerTable.h>
#include <AIS_ColoredShape.hxx>
-#include <Aspect_ColorScale.hxx>
+#include <AIS_ColorScale.hxx>
DEFINE_STANDARD_HANDLE( HYDROGUI_LandCoverMapPrs, AIS_ColoredShape )
class SUIT_ViewWindow;
class SUIT_ViewManager;
-class Handle(HYDROData_StricklerTable);
+class HYDROData_StricklerTable;
class HYDROGUI_DataModel;
class HYDROGUI_Displayer;
#include "HYDROGUI_AbstractDisplayer.h"
class HYDROGUI_Shape;
-class Handle(AIS_InteractiveContext);
+class AIS_InteractiveContext;
class OCCViewer_ViewManager;
class OCCViewer_Viewer;
class HYDROGUI_Module;
class OCCViewer_Viewer;
-class Handle_AIS_InteractiveObject;
+class AIS_InteractiveObject;
class HYDROGUI_OCCSelector : public LightApp_OCCSelector
{
virtual void getSelection( SUIT_DataOwnerPtrList& ) const;
virtual void setSelection( const SUIT_DataOwnerPtrList& );
- virtual QString entry( const Handle_AIS_InteractiveObject& ) const;
+ virtual QString entry( const Handle(AIS_InteractiveObject)& ) const;
private:
HYDROGUI_Module* myModule;
}
}
-Handle_HYDROData_Document HYDROGUI_Operation::doc() const
+Handle(HYDROData_Document) HYDROGUI_Operation::doc() const
{
return HYDROData_Document::Document( myModule->getStudyId() );
}
#define HYDROGUI_OPERATION_H
#include <LightApp_Operation.h>
-
+#include <Standard_DefineHandle.hxx>
#include <QCursor>
class HYDROGUI_Module;
class SUIT_SelectionMgr;
class OCCViewer_ViewManager;
-class Handle_HYDROData_Document;
-class Handle_HYDROData_Object;
+class HYDROData_Document;
+class HYDROData_Object;
class HYDROGUI_Operation : public LightApp_Operation
{
void abortDocOperation();
void commitDocOperation();
- Handle_HYDROData_Document doc() const;
+ Handle(HYDROData_Document) doc() const;
virtual bool isToAbortOnApply() const { return true; }
#include <BRepAdaptor_Curve.hxx>
#include <Prs3d_LineAspect.hxx>
-IMPLEMENT_STANDARD_HANDLE (HYDROGUI_Polyline, AIS_Shape)
IMPLEMENT_STANDARD_RTTIEXT(HYDROGUI_Polyline, AIS_Shape)
#include <Standard.hxx>
#include <Standard_DefineHandle.hxx>
#include <PrsMgr_PresentationManager.hxx>
-#include <Handle_Prs3d_Presentation.hxx>
+#include <Prs3d_Presentation.hxx>
#include <TCollection_AsciiString.hxx>
#include <AIS_DisplayMode.hxx>
const Standard_Integer aMode = 0);
public:
- DEFINE_STANDARD_RTTI(HYDROGUI_Polyline);
+ DEFINE_STANDARD_RTTIEXT(HYDROGUI_Polyline, AIS_Shape);
};
-DEFINE_STANDARD_HANDLE(HYDROGUI_Polyline, AIS_Shape)
-
#endif
Handle_HYDROData_Bathymetry aBath = Handle_HYDROData_Bathymetry::DownCast( getObject() );
if( !aBath.IsNull() )
{
- Handle_AIS_PointCloud aPntCloud = new HYDROGUI_BathymetryPrs();
+ Handle(AIS_PointCloud) aPntCloud = new HYDROGUI_BathymetryPrs();
aPntCloud->SetHilightMode( AIS_PointCloud::DM_BndBox );
aPntCloud->Attributes()->SetPointAspect (new Prs3d_PointAspect (Aspect_TOM_POINT, Quantity_NOC_WHITE, 2.0));
#include <TColgp_HArray1OfPnt.hxx>
#include <Quantity_HArray1OfColor.hxx>
-class Handle_HYDROData_Bathymetry;
-class Handle_Aspect_ColorScale;
+class HYDROData_Bathymetry;
+class Aspect_ColorScale;
class HYDROGUI_OCCDisplayer;
class HYDROGUI_ShapeBathymetry : public HYDROGUI_Shape
public:
HYDROGUI_ShapeBathymetry( HYDROGUI_OCCDisplayer* theDisplayer,
const Handle(AIS_InteractiveContext)& theContext,
- const Handle_HYDROData_Bathymetry& theBathymetry,
+ const Handle(HYDROData_Bathymetry)& theBathymetry,
const int theZLayer = -1 );
virtual ~HYDROGUI_ShapeBathymetry();
void GetRange( double& theMin, double& theMax ) const;
- void UpdateWithColorScale( const Handle_Aspect_ColorScale& );
+ void UpdateWithColorScale( const Handle(Aspect_ColorScale)& );
virtual void display( const bool theIsUpdateViewer = true );
virtual void erase( const bool theIsUpdateViewer = true );
virtual void setVisible( const bool theState,
const bool theIsUpdateViewer = true );
protected:
- virtual Handle_AIS_InteractiveObject createShape() const;
+ virtual Handle(AIS_InteractiveObject) createShape() const;
virtual void displayShape( const bool theIsUpdateViewer );
private:
HYDROGUI_OCCDisplayer* myDisplayer;
- Handle_TColgp_HArray1OfPnt myCoords;
- Handle_Quantity_HArray1OfColor myColors;
+ Handle(TColgp_HArray1OfPnt) myCoords;
+ Handle(Quantity_HArray1OfColor) myColors;
};
#endif
#include <gp_Pnt.hxx>
HYDROGUI_ShapeImage::HYDROGUI_ShapeImage( const Handle(AIS_InteractiveContext)& theContext,
- const Handle_HYDROData_Image& theImage,
+ const Handle(HYDROData_Image)& theImage,
const int theZLayer )
: HYDROGUI_Shape( theContext, theImage, theZLayer )
{
#include "HYDROGUI_InputPanel.h"
#include <QAbstractItemDelegate>
+#include <Standard_Type.hxx>
-class Handle_HYDROData_StricklerTable;
+class HYDROData_StricklerTable;
class QGroupBox;
class QLineEdit;
bool isTableNameReadOnly() const;
void setTableNameReadOnly( bool );
- void getGuiData( Handle_HYDROData_StricklerTable& theTable ) const;
- void setGuiData( const Handle_HYDROData_StricklerTable& theTable );
+ void getGuiData( Handle(HYDROData_StricklerTable)& theTable ) const;
+ void setGuiData( const Handle(HYDROData_StricklerTable)& theTable );
protected:
void updateControls();
#include <QString>
class TCollection_AsciiString;
-class Handle_HYDROData_Document;
-class Handle_Image_PixMap;
-class Handle_TCollection_HAsciiString;
-class Handle_TCollection_HExtendedString;
+class HYDROData_Document;
+class Image_PixMap;
+class TCollection_HAsciiString;
+class TCollection_HExtendedString;
class QDockWidget;
class QImage;
class QWidget;
{
QString ToQString( const TCollection_AsciiString& );
QString ToQString( const TCollection_ExtendedString& );
- QString ToQString( const Handle_TCollection_HAsciiString& );
- QString ToQString( const Handle_TCollection_HExtendedString& );
+ QString ToQString( const Handle(TCollection_HAsciiString)& );
+ QString ToQString( const Handle(TCollection_HExtendedString)& );
TCollection_AsciiString ToAsciiString( const QString& );
TCollection_ExtendedString ToExtString( const QString& );
Handle(TCollection_HAsciiString) ToHAsciiString( const QString& );
QDockWidget* WindowDock( QWidget* wid );
- QStringList FindExistingObjectsNames( const Handle_HYDROData_Document& theDoc,
+ QStringList FindExistingObjectsNames( const Handle(HYDROData_Document)& theDoc,
const ObjectKind theObjectKind,
bool isCheckValidProfile = false );
QString GetCoordinateString( const double theNumber, bool isInLocale );
- Handle_Image_PixMap Pixmap( const QImage& theImage );
+ Handle(Image_PixMap) Pixmap( const QImage& theImage );
void GetObjectReferences( const Handle(HYDROData_Entity)& theObj,
HYDROData_SequenceOfObjects& theRefObjects,
QStringList& theRefNames );
HYDROData_SequenceOfObjects GetObjectBackReferences( const Handle(HYDROData_Entity)& theObj );
QMap<QString,HYDROData_SequenceOfObjects> GetObjectsBackReferences
- ( const Handle_HYDROData_Document& theDocument, const QStringList& theObjectNames );
+ ( const Handle(HYDROData_Document)& theDocument, const QStringList& theObjectNames );
};
#endif
class SUIT_ViewManager;
class GraphicsView_ViewPort;
class OCCViewer_ViewFrame;
-class Handle_HYDROData_Document;
+class HYDROData_Document;
namespace HYDROGUI_Tool
{
HYDROData_SequenceOfObjects GetSelectedObjects( HYDROGUI_Module* theModule );
- bool IsObjectHasPresentation( const Handle_HYDROData_Entity& theObject,
+ bool IsObjectHasPresentation( const Handle(HYDROData_Entity)& theObject,
const QString& theViewerType = "" );
Handle(HYDROData_Entity) GetSelectedObject( HYDROGUI_Module* theModule );
QColor GenerateFillingColor( HYDROGUI_Module* theModule, const QStringList& theZoneNames );
- QColor GenerateFillingColor( const Handle_HYDROData_Document& theDoc,
+ QColor GenerateFillingColor( const Handle(HYDROData_Document)& theDoc,
const QStringList& theZoneNames );
QStringList GetSelectedGeomObjects( HYDROGUI_Module* theModule,
#include <NCollection_Map.hxx>
-class Handle_HYDROData_Entity;
+class HYDROData_Entity;
class HYDROGUI_UpdateObjectOp : public HYDROGUI_Operation
{
virtual void startOperation();
- virtual void updateObject( const Handle_HYDROData_Entity& theObject,
+ virtual void updateObject( const Handle(HYDROData_Entity)& theObject,
NCollection_Map<Handle(HYDROData_Entity)>& theMapOfTreated ) const;
private:
// Define IO for actors to be added:
QString anEntry = HYDROGUI_DataObject::dataObjectEntry( theObject );
myIO = new SALOME_InteractiveObject(
- anEntry.toAscii(), QString::number( theObject->GetKind() ).toAscii(), theObject->GetName().toAscii() );
+ anEntry.toLatin1(), QString::number( theObject->GetKind() ).toLatin1(), theObject->GetName().toLatin1() );
myZRange[0] = HYDROData_IAltitudeObject::GetInvalidAltitude();
myZRange[1] = HYDROData_IAltitudeObject::GetInvalidAltitude();
}
#include <vector>
#include <V3d_Viewer.hxx>
-class Handle_PrsMgr_PresentableObject;
-class Handle_AIS_InteractiveContext;
+class PrsMgr_PresentableObject;
+class AIS_InteractiveContext;
class HYDROGUI_ZLayersIterator
{
public:
- HYDROGUI_ZLayersIterator( const Handle_V3d_Viewer& );
+ HYDROGUI_ZLayersIterator( const Handle(V3d_Viewer)& );
~HYDROGUI_ZLayersIterator();
- void Init( const Handle_V3d_Viewer& );
+ void Init( const Handle(V3d_Viewer)& );
bool More() const;
void Next();
int LayerId() const;
std::vector<int> myZLayers;
int myIndex;
int myNewZLayer;
- Handle_V3d_Viewer myViewer;
+ Handle(V3d_Viewer) myViewer;
};
-void SetPrsZLayer( const Handle_PrsMgr_PresentableObject& thePresentableObject,
+void SetPrsZLayer( const Handle(PrsMgr_PresentableObject)& thePresentableObject,
const int theMode, const int theLayerId );
-void UpdateZLayersOfHilightPresentationsOfDisplayedObjects( const Handle_AIS_InteractiveContext&, int theLayer );
-void SetZLayerSettings( const Handle_V3d_Viewer&, int theLayerId, bool theIsOrdered );
-int CreateTopZLayer( const Handle_V3d_Viewer& );
+void UpdateZLayersOfHilightPresentationsOfDisplayedObjects( const Handle(AIS_InteractiveContext)&, int theLayer );
+void SetZLayerSettings( const Handle(V3d_Viewer)&, int theLayerId, bool theIsOrdered );
+int CreateTopZLayer( const Handle(V3d_Viewer)& );
#endif
include(../../CMake/Common.cmake)
-include(UsePyQt4)
+INCLUDE(UsePyQt)
# --- options ---
# --- sources ---
# sources / sip wrappings
-PYQT4_WRAP_SIP(_sip_SOURCES ${_sip_files} SOURCES ${_add_SOURCES})
+PYQT_WRAP_SIP(_sip_SOURCES ${_sip_files} SOURCES ${_add_SOURCES})
# sources / to compile
SET(HYDROPy_SOURCES ${_sip_SOURCES})
SET( CPPUNIT_INCLUDES $ENV{cppUNIT_ROOT}/include )
SET( CAS_INCLUDES $ENV{CASROOT}/inc )
-SET( QT_INCLUDES $ENV{QTDIR}/include $ENV{QTDIR}/include/QtCore $ENV{QTDIR}/include/QtGui $ENV{QTDIR}/include/QtTest )
+SET( QT_INCLUDES $ENV{QT5_ROOT_DIR}/include $ENV{QT5_ROOT_DIR}/include/QtCore $ENV{QT5_ROOT_DIR}/include/QtGui $ENV{QT5_ROOT_DIR}/include/QtTest )
SET( KERNEL_INCLUDES $ENV{KERNEL_ROOT_DIR}/include/salome )
SET( GUI_INCLUDES $ENV{GUI_ROOT_DIR}/include/salome )
SET( GEOM_INCLUDES $ENV{GEOM_ROOT_DIR}/include/salome )
ENDIF()
SET( CAS_LIBRARIES TKernel TKLCAF TKCAF TKCDF TKMath TKG2d TKG3d TKBRep TKGeomBase TKTopAlgo TKGeomAlgo TKBool TKShHealing TKXSBase TKOffset TKHLR TKBO TKV3d TKService TKMesh )
-link_directories( $ENV{QTDIR}/lib )
+link_directories( $ENV{QT5_ROOT_DIR}/lib )
IF( ${WIN32} )
SET( QT_LIBRARIES QtCored4 QtGuid4 QtTestd4 )
ELSE()
-find_package(Qt4 4.8.4 REQUIRED QtCore QtGui )
+find_package( Qt5Core )
+find_package( Qt5Widgets )
set( EXTERNAL_FILES
../HYDROData/HYDROData_AltitudeObject.cxx
../HYDROGUI/HYDROGUI_StricklerTableDlg.h
)
-QT4_WRAP_CPP( PROJECT_MOC_HEADERS ${MOC_HEADERS} )
+QT_WRAP_MOC( PROJECT_MOC_HEADERS ${MOC_HEADERS} )
class TopoDS_Shape;
class QString;
class QColor;
-class Handle_AIS_InteractiveContext;
-class Handle_AIS_InteractiveObject;
-class Handle_Aspect_ColorScale;
+class AIS_InteractiveContext;
+class AIS_InteractiveObject;
+class Aspect_ColorScale;
class TestViewer
{
static OCCViewer_ViewManager* viewManager();
static OCCViewer_Viewer* viewer();
static OCCViewer_ViewWindow* viewWindow();
- static Handle_AIS_InteractiveContext context();
+ static Handle(AIS_InteractiveContext) context();
static void eraseAll( bool isUpdate );
- static void show( const Handle_AIS_InteractiveObject& theObject,
+ static void show( const Handle(AIS_InteractiveObject)& theObject,
int theMode, int theSelectionMode, bool isFitAll, const char* theKey );
static void show( const TopoDS_Shape& theShape, int theMode, bool isFitAll, const QColor& theColor );
static void show( const TopoDS_Shape& theShape, int theMode, bool isFitAll, const char* theKey );
static bool AssertImages( QString& theMessage );
static QColor GetColor(int i);
- static Handle_Aspect_ColorScale colorScale();
+ static Handle(Aspect_ColorScale) colorScale();
static void showColorScale( bool );
static void select( int theViewX, int theViewY );
