-using namespace std;
-#include "GEOMImpl_ArcDriver.hxx"
-#include "GEOMImpl_IArc.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_ArcDriver.hxx>
+#include <GEOMImpl_IArc.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx>
#include <BRep_Tool.hxx>
-using namespace std;
+#include <Standard_Stream.hxx>
#include <BRepOffsetAPI_MakeFilling.hxx>
-#include "GEOMImpl_Block6Explorer.hxx"
+#include <GEOMImpl_Block6Explorer.hxx>
#include "utilities.h"
TopTools_IndexedMapOfShape aFaceEdges;
TopExp::MapShapes(myFaces(1), TopAbs_EDGE, aFaceEdges);
- for (Standard_Integer i = 1; i <= 4; i++) {
+ Standard_Integer i = 1;
+ for (; i <= 4; i++) {
// Get i-th vertex of the face 1
TopoDS_Shape Vi = myVertices(vertex_id(1, i));
if (!MB.Contains(Vi)) {
}
// 3. Store edges of the second (opposite to the first) face
- for (Standard_Integer i = 1; i <= 4; i++) {
+ for (i = 1; i <= 4; i++) {
// Get i-th and (i+1)-th vertices of the face 2
TopoDS_Shape Vi = myVertices(vertex_id(2, i));
TopoDS_Shape Vj = myVertices(vertex_id(2, mod4(i + 1)));
Standard_TypeMismatch::Raise("Block has wrong number of edges");
}
- for (Standard_Integer i = 2; i <= NBFACES; i++) {
+ for (i = 2; i <= NBFACES; i++) {
TopoDS_Shape Ei1 = myEdges(edge_id(i, 1));
TopoDS_Shape Ei2 = myEdges(edge_id(i, 2));
const TopTools_ListOfShape& aFacesOfEi1 = MBE.FindFromKey(Ei1);
Standard_Real Dist_min = RealLast();
// try all possible locations to find the best (with minimum sum distance)
- for (Standard_Integer i = 1; i <= 4; i++) {
+ Standard_Integer i = 1;
+ for (; i <= 4; i++) {
// try direct orientation
Standard_Real Dist_plus = aPnts1(1).Distance(aPnts2(i)) +
aPnts1(2).Distance(aPnts2(mod4(i + 1))) +
// 3. Put vertices and edges of the second face to they
// permanent location in <myVertices> and <myEdges>
- for (Standard_Integer i = 1; i <= 4; i++) {
+ for (i = 1; i <= 4; i++) {
Standard_Integer nb = mod4(i_min + s_min*(i - 1));
if (aPnts1(i).Distance(aPnts2(nb)) < Precision::Confusion()) {
-using namespace std;
+#include <Standard_Stream.hxx>
#include <BRepOffsetAPI_MakeFilling.hxx>
-#include "GEOMImpl_BlockDriver.hxx"
-#include "GEOMImpl_IBlocks.hxx"
-#include "GEOMImpl_IBlockTrsf.hxx"
-#include "GEOMImpl_GlueDriver.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOMImpl_ILocalOperations.hxx"
-#include "GEOMImpl_Block6Explorer.hxx"
-#include "GEOMImpl_IBlocksOperations.hxx"
+#include <GEOMImpl_BlockDriver.hxx>
+#include <GEOMImpl_IBlocks.hxx>
+#include <GEOMImpl_IBlockTrsf.hxx>
+#include <GEOMImpl_GlueDriver.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOMImpl_ILocalOperations.hxx>
+#include <GEOMImpl_Block6Explorer.hxx>
+#include <GEOMImpl_IBlocksOperations.hxx>
-#include "GEOM_Function.hxx"
+#include <GEOM_Function.hxx>
-#include "ShHealOper_Sewing.hxx"
-#include "NMTAlgo_Splitter1.hxx"
-#include "BlockFix_BlockFixAPI.hxx"
+#include <ShHealOper_Sewing.hxx>
+#include <NMTAlgo_Splitter1.hxx>
+#include <BlockFix_BlockFixAPI.hxx>
#include "utilities.h"
-using namespace std;
-#include "GEOMImpl_BooleanDriver.hxx"
-#include "GEOMImpl_IBoolean.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_BooleanDriver.hxx>
+#include <GEOMImpl_IBoolean.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRepAlgo.hxx>
#include <BRepAlgoAPI_Common.hxx>
-using namespace std;
-#include "GEOMImpl_BoxDriver.hxx"
-#include "GEOMImpl_IBox.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_BoxDriver.hxx>
+#include <GEOMImpl_IBox.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRepPrimAPI_MakeBox.hxx>
#include <BRep_Tool.hxx>
-using namespace std;
-#include "GEOMImpl_ChamferDriver.hxx"
-#include "GEOMImpl_IChamfer.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOMImpl_ILocalOperations.hxx"
-#include "GEOM_Function.hxx"
-#include "GEOMImpl_Block6Explorer.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_ChamferDriver.hxx>
+#include <GEOMImpl_IChamfer.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOMImpl_ILocalOperations.hxx>
+#include <GEOM_Function.hxx>
+#include <GEOMImpl_Block6Explorer.hxx>
#include <BRep_Tool.hxx>
#include <BRepTools.hxx>
-using namespace std;
-#include "GEOMImpl_CircleDriver.hxx"
-#include "GEOMImpl_ICircle.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_CircleDriver.hxx>
+#include <GEOMImpl_ICircle.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx>
#include <BRep_Tool.hxx>
-using namespace std;
-#include "GEOMImpl_ConeDriver.hxx"
-#include "GEOMImpl_ICone.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_ConeDriver.hxx>
+#include <GEOMImpl_ICone.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRepPrimAPI_MakeCone.hxx>
#include <BRepPrimAPI_MakeCylinder.hxx>
-using namespace std;
-#include "GEOMImpl_CopyDriver.hxx"
-#include "GEOMImpl_ICopy.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_CopyDriver.hxx>
+#include <GEOMImpl_ICopy.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRep_Tool.hxx>
#include <gp_Pnt.hxx>
-using namespace std;
-#include "GEOMImpl_CylinderDriver.hxx"
-#include "GEOMImpl_ICylinder.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_CylinderDriver.hxx>
+#include <GEOMImpl_ICylinder.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRepPrimAPI_MakeCylinder.hxx>
#include <BRep_Tool.hxx>
-using namespace std;
-#include "GEOMImpl_EllipseDriver.hxx"
-#include "GEOMImpl_IEllipse.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_EllipseDriver.hxx>
+#include <GEOMImpl_IEllipse.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx>
#include <BRep_Tool.hxx>
-using namespace std;
-#include "GEOMImpl_ExportDriver.hxx"
-#include "GEOMImpl_IImportExport.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_ExportDriver.hxx>
+#include <GEOMImpl_IImportExport.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <TopoDS_Shape.hxx>
#include <TCollection_AsciiString.hxx>
-using namespace std;
-#include "GEOMImpl_FilletDriver.hxx"
-#include "GEOMImpl_IFillet.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOMImpl_ILocalOperations.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_FilletDriver.hxx>
+#include <GEOMImpl_IFillet.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOMImpl_ILocalOperations.hxx>
+#include <GEOM_Function.hxx>
#include <BRepFilletAPI_MakeFillet.hxx>
#include <BRepCheck_Analyzer.hxx>
-using namespace std;
+#include <Standard_Stream.hxx>
-#include "GEOMImpl_FillingDriver.hxx"
-#include "GEOM_Function.hxx"
-#include "GEOMImpl_IFilling.hxx"
-#include "GEOMImpl_Types.hxx"
+#include <GEOMImpl_FillingDriver.hxx>
+#include <GEOM_Function.hxx>
+#include <GEOMImpl_IFilling.hxx>
+#include <GEOMImpl_Types.hxx>
#include <BRep_Tool.hxx>
#include <BRepAlgo.hxx>
-using namespace std;
+#ifdef WNT
+#pragma warning( disable:4786 )
+#endif
-#include "GEOMImpl_Gen.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_Gen.hxx>
#include "utilities.h"
-#include "OpUtil.hxx"
-#include "Utils_ExceptHandlers.hxx"
+#include <OpUtil.hxx>
+#include <Utils_ExceptHandlers.hxx>
#include <TFunction_Driver.hxx>
#include <TFunction_DriverTable.hxx>
-#include "GEOMImpl_PointDriver.hxx"
-#include "GEOMImpl_VectorDriver.hxx"
-#include "GEOMImpl_LineDriver.hxx"
-#include "GEOMImpl_PlaneDriver.hxx"
-#include "GEOMImpl_MarkerDriver.hxx"
-#include "GEOMImpl_ArcDriver.hxx"
-#include "GEOMImpl_CircleDriver.hxx"
-#include "GEOMImpl_EllipseDriver.hxx"
-#include "GEOMImpl_PolylineDriver.hxx"
-#include "GEOMImpl_SplineDriver.hxx"
-#include "GEOMImpl_SketcherDriver.hxx"
-#include "GEOMImpl_BoxDriver.hxx"
-#include "GEOMImpl_ConeDriver.hxx"
-#include "GEOMImpl_CylinderDriver.hxx"
-#include "GEOMImpl_PrismDriver.hxx"
-#include "GEOMImpl_PipeDriver.hxx"
-#include "GEOMImpl_RevolutionDriver.hxx"
-#include "GEOMImpl_ShapeDriver.hxx"
-#include "GEOMImpl_BlockDriver.hxx"
-#include "GEOMImpl_SphereDriver.hxx"
-#include "GEOMImpl_TorusDriver.hxx"
-#include "GEOMImpl_BooleanDriver.hxx"
-#include "GEOMImpl_ChamferDriver.hxx"
-#include "GEOMImpl_FilletDriver.hxx"
-#include "GEOMImpl_TranslateDriver.hxx"
-#include "GEOMImpl_RotateDriver.hxx"
-#include "GEOMImpl_MirrorDriver.hxx"
-#include "GEOMImpl_OffsetDriver.hxx"
-#include "GEOMImpl_ScaleDriver.hxx"
-#include "GEOMImpl_PositionDriver.hxx"
-#include "GEOMImpl_PartitionDriver.hxx"
-#include "GEOMImpl_CopyDriver.hxx"
-#include "GEOMImpl_ExportDriver.hxx"
-#include "GEOMImpl_ImportDriver.hxx"
-#include "GEOMImpl_ArchimedeDriver.hxx"
-#include "GEOMImpl_HealingDriver.hxx"
-#include "GEOMImpl_FillingDriver.hxx"
-#include "GEOMImpl_GlueDriver.hxx"
-#include "GEOMImpl_MeasureDriver.hxx"
+#include <GEOMImpl_PointDriver.hxx>
+#include <GEOMImpl_VectorDriver.hxx>
+#include <GEOMImpl_LineDriver.hxx>
+#include <GEOMImpl_PlaneDriver.hxx>
+#include <GEOMImpl_MarkerDriver.hxx>
+#include <GEOMImpl_ArcDriver.hxx>
+#include <GEOMImpl_CircleDriver.hxx>
+#include <GEOMImpl_EllipseDriver.hxx>
+#include <GEOMImpl_PolylineDriver.hxx>
+#include <GEOMImpl_SplineDriver.hxx>
+#include <GEOMImpl_SketcherDriver.hxx>
+#include <GEOMImpl_BoxDriver.hxx>
+#include <GEOMImpl_ConeDriver.hxx>
+#include <GEOMImpl_CylinderDriver.hxx>
+#include <GEOMImpl_PrismDriver.hxx>
+#include <GEOMImpl_PipeDriver.hxx>
+#include <GEOMImpl_RevolutionDriver.hxx>
+#include <GEOMImpl_ShapeDriver.hxx>
+#include <GEOMImpl_BlockDriver.hxx>
+#include <GEOMImpl_SphereDriver.hxx>
+#include <GEOMImpl_TorusDriver.hxx>
+#include <GEOMImpl_BooleanDriver.hxx>
+#include <GEOMImpl_ChamferDriver.hxx>
+#include <GEOMImpl_FilletDriver.hxx>
+#include <GEOMImpl_TranslateDriver.hxx>
+#include <GEOMImpl_RotateDriver.hxx>
+#include <GEOMImpl_MirrorDriver.hxx>
+#include <GEOMImpl_OffsetDriver.hxx>
+#include <GEOMImpl_ScaleDriver.hxx>
+#include <GEOMImpl_PositionDriver.hxx>
+#include <GEOMImpl_PartitionDriver.hxx>
+#include <GEOMImpl_CopyDriver.hxx>
+#include <GEOMImpl_ExportDriver.hxx>
+#include <GEOMImpl_ImportDriver.hxx>
+#include <GEOMImpl_ArchimedeDriver.hxx>
+#include <GEOMImpl_HealingDriver.hxx>
+#include <GEOMImpl_FillingDriver.hxx>
+#include <GEOMImpl_GlueDriver.hxx>
+#include <GEOMImpl_MeasureDriver.hxx>
//=============================================================================
/*!
#include "GEOMImpl_IGroupOperations.hxx"
#include "GEOM_Engine.hxx"
-class GEOMImpl_Gen : public GEOM_Engine
+#ifdef WNT
+#include <SALOME_WNT.hxx>
+#else
+#define SALOME_WNT_EXPORT
+#endif
+
+class SALOME_WNT_EXPORT GEOMImpl_Gen : public GEOM_Engine
{
public:
GEOMImpl_Gen();
-using namespace std;
-#include "GEOMImpl_GlueDriver.hxx"
-#include "GEOMImpl_IGlue.hxx"
-#include "GEOMImpl_Types.hxx"
+#include <Standard_Stream.hxx>
-#include "GEOM_Object.hxx"
-#include "GEOM_Function.hxx"
+#include <GEOMImpl_GlueDriver.hxx>
+#include <GEOMImpl_IGlue.hxx>
+#include <GEOMImpl_Types.hxx>
-#include "GEOMAlgo_Gluer.hxx"
+#include <GEOM_Object.hxx>
+#include <GEOM_Function.hxx>
+
+#include <GEOMAlgo_Gluer.hxx>
#include "utilities.h"
-using namespace std;
-#include "GEOMImpl_HealingDriver.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOMImpl_IHealing.hxx"
-#include "GEOM_Function.hxx"
-
-#include "ShHealOper_ShapeProcess.hxx"
-#include "ShHealOper_RemoveFace.hxx"
-#include "ShHealOper_CloseContour.hxx"
-#include "ShHealOper_RemoveInternalWires.hxx"
-#include "ShHealOper_FillHoles.hxx"
-#include "ShHealOper_Sewing.hxx"
-#include "ShHealOper_EdgeDivide.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_HealingDriver.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOMImpl_IHealing.hxx>
+#include <GEOM_Function.hxx>
+
+#include <ShHealOper_ShapeProcess.hxx>
+#include <ShHealOper_RemoveFace.hxx>
+#include <ShHealOper_CloseContour.hxx>
+#include <ShHealOper_RemoveInternalWires.hxx>
+#include <ShHealOper_FillHoles.hxx>
+#include <ShHealOper_Sewing.hxx>
+#include <ShHealOper_EdgeDivide.hxx>
#include <TopoDS.hxx>
#include <TopExp.hxx>
-using namespace std;
+#include <Standard_Stream.hxx>
-#include "GEOMImpl_I3DPrimOperations.hxx"
+#include <GEOMImpl_I3DPrimOperations.hxx>
#include "utilities.h"
-#include "OpUtil.hxx"
-#include "Utils_ExceptHandlers.hxx"
+#include <OpUtil.hxx>
+#include <Utils_ExceptHandlers.hxx>
#include <TFunction_DriverTable.hxx>
#include <TFunction_Driver.hxx>
#include <TFunction_Logbook.hxx>
#include <TDF_Tool.hxx>
-#include "GEOM_Function.hxx"
-#include "GEOM_PythonDump.hxx"
-
-#include "GEOMImpl_Types.hxx"
-
-#include "GEOMImpl_BoxDriver.hxx"
-#include "GEOMImpl_CylinderDriver.hxx"
-#include "GEOMImpl_ConeDriver.hxx"
-#include "GEOMImpl_SphereDriver.hxx"
-#include "GEOMImpl_TorusDriver.hxx"
-#include "GEOMImpl_PrismDriver.hxx"
-#include "GEOMImpl_PipeDriver.hxx"
-#include "GEOMImpl_RevolutionDriver.hxx"
-#include "GEOMImpl_ShapeDriver.hxx"
-#include "GEOMImpl_FillingDriver.hxx"
-
-#include "GEOMImpl_IBox.hxx"
-#include "GEOMImpl_ICylinder.hxx"
-#include "GEOMImpl_ICone.hxx"
-#include "GEOMImpl_ISphere.hxx"
-#include "GEOMImpl_ITorus.hxx"
-#include "GEOMImpl_IPrism.hxx"
-#include "GEOMImpl_IPipe.hxx"
-#include "GEOMImpl_IRevolution.hxx"
-#include "GEOMImpl_IShapes.hxx"
-#include "GEOMImpl_IFilling.hxx"
+#include <GEOM_Function.hxx>
+#include <GEOM_PythonDump.hxx>
+
+#include <GEOMImpl_Types.hxx>
+
+#include <GEOMImpl_BoxDriver.hxx>
+#include <GEOMImpl_CylinderDriver.hxx>
+#include <GEOMImpl_ConeDriver.hxx>
+#include <GEOMImpl_SphereDriver.hxx>
+#include <GEOMImpl_TorusDriver.hxx>
+#include <GEOMImpl_PrismDriver.hxx>
+#include <GEOMImpl_PipeDriver.hxx>
+#include <GEOMImpl_RevolutionDriver.hxx>
+#include <GEOMImpl_ShapeDriver.hxx>
+#include <GEOMImpl_FillingDriver.hxx>
+
+#include <GEOMImpl_IBox.hxx>
+#include <GEOMImpl_ICylinder.hxx>
+#include <GEOMImpl_ICone.hxx>
+#include <GEOMImpl_ISphere.hxx>
+#include <GEOMImpl_ITorus.hxx>
+#include <GEOMImpl_IPrism.hxx>
+#include <GEOMImpl_IPipe.hxx>
+#include <GEOMImpl_IRevolution.hxx>
+#include <GEOMImpl_IShapes.hxx>
+#include <GEOMImpl_IFilling.hxx>
#include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
class GEOMImpl_I3DPrimOperations : public GEOM_IOperations {
public:
- GEOMImpl_I3DPrimOperations(GEOM_Engine* theEngine, int theDocID);
- ~GEOMImpl_I3DPrimOperations();
+ Standard_EXPORT GEOMImpl_I3DPrimOperations(GEOM_Engine* theEngine, int theDocID);
+ Standard_EXPORT ~GEOMImpl_I3DPrimOperations();
- Handle(GEOM_Object) MakeBoxDXDYDZ (double theDX, double theDY, double theDZ);
- Handle(GEOM_Object) MakeBoxTwoPnt (Handle(GEOM_Object) thePnt1,
+ Standard_EXPORT Handle(GEOM_Object) MakeBoxDXDYDZ (double theDX, double theDY, double theDZ);
+ Standard_EXPORT Handle(GEOM_Object) MakeBoxTwoPnt (Handle(GEOM_Object) thePnt1,
Handle(GEOM_Object) thePnt2);
- Handle(GEOM_Object) MakeCylinderRH (double theR, double theH);
- Handle(GEOM_Object) MakeCylinderPntVecRH (Handle(GEOM_Object) thePnt,
+ Standard_EXPORT Handle(GEOM_Object) MakeCylinderRH (double theR, double theH);
+ Standard_EXPORT Handle(GEOM_Object) MakeCylinderPntVecRH (Handle(GEOM_Object) thePnt,
Handle(GEOM_Object) theVec,
double theR, double theH);
- Handle(GEOM_Object) MakeConeR1R2H (double theR1, double theR2, double theH);
- Handle(GEOM_Object) MakeConePntVecR1R2H (Handle(GEOM_Object) thePnt,
+ Standard_EXPORT Handle(GEOM_Object) MakeConeR1R2H (double theR1, double theR2, double theH);
+ Standard_EXPORT Handle(GEOM_Object) MakeConePntVecR1R2H (Handle(GEOM_Object) thePnt,
Handle(GEOM_Object) theVec,
double theR1, double theR2, double theH);
- Handle(GEOM_Object) MakeSphereR (double theR);
- Handle(GEOM_Object) MakeSpherePntR (Handle(GEOM_Object) thePnt, double theR);
+ Standard_EXPORT Handle(GEOM_Object) MakeSphereR (double theR);
+ Standard_EXPORT Handle(GEOM_Object) MakeSpherePntR (Handle(GEOM_Object) thePnt, double theR);
- Handle(GEOM_Object) MakeTorusRR (double theRMajor, double theRMinor);
+ Standard_EXPORT Handle(GEOM_Object) MakeTorusRR (double theRMajor, double theRMinor);
- Handle(GEOM_Object) MakeTorusPntVecRR (Handle(GEOM_Object) thePnt,
+ Standard_EXPORT Handle(GEOM_Object) MakeTorusPntVecRR (Handle(GEOM_Object) thePnt,
Handle(GEOM_Object) theVec,
double theRMajor, double theRMinor);
- Handle(GEOM_Object) MakePrismVecH (Handle(GEOM_Object) theBase,
+ Standard_EXPORT Handle(GEOM_Object) MakePrismVecH (Handle(GEOM_Object) theBase,
Handle(GEOM_Object) theVec, double theH);
- Handle(GEOM_Object) MakePrismTwoPnt (Handle(GEOM_Object) theBase,
+ Standard_EXPORT Handle(GEOM_Object) MakePrismTwoPnt (Handle(GEOM_Object) theBase,
Handle(GEOM_Object) thePoint1,
Handle(GEOM_Object) thePoint2);
- Handle(GEOM_Object) MakePipe (Handle(GEOM_Object) theBase,
+ Standard_EXPORT Handle(GEOM_Object) MakePipe (Handle(GEOM_Object) theBase,
Handle(GEOM_Object) thePath);
- Handle(GEOM_Object) MakeRevolutionAxisAngle (Handle(GEOM_Object) theBase,
+ Standard_EXPORT Handle(GEOM_Object) MakeRevolutionAxisAngle (Handle(GEOM_Object) theBase,
Handle(GEOM_Object) theAxis,
double theAngle);
- Handle(GEOM_Object) MakeSolidShell (Handle(GEOM_Object) theShell);
+ Standard_EXPORT Handle(GEOM_Object) MakeSolidShell (Handle(GEOM_Object) theShell);
- Handle(GEOM_Object) MakeFilling (Handle(GEOM_Object) theShape, int theMinDeg, int theMaxDeg, double theTol2D, double theTol3D, int theNbIter);
+ Standard_EXPORT Handle(GEOM_Object) MakeFilling (Handle(GEOM_Object) theShape, int theMinDeg, int theMaxDeg, double theTol2D, double theTol3D, int theNbIter);
};
-using namespace std;
+#include <Standard_Stream.hxx>
-#include "GEOMImpl_IBasicOperations.hxx"
+#include <GEOMImpl_IBasicOperations.hxx>
#include "utilities.h"
-#include "OpUtil.hxx"
-#include "Utils_ExceptHandlers.hxx"
+#include <OpUtil.hxx>
+#include <Utils_ExceptHandlers.hxx>
#include <TFunction_DriverTable.hxx>
#include <TFunction_Driver.hxx>
#include <TFunction_Logbook.hxx>
#include <TDF_Tool.hxx>
-#include "GEOM_Function.hxx"
-#include "GEOM_PythonDump.hxx"
+#include <GEOM_Function.hxx>
+#include <GEOM_PythonDump.hxx>
-#include "GEOMImpl_PointDriver.hxx"
-#include "GEOMImpl_VectorDriver.hxx"
-#include "GEOMImpl_LineDriver.hxx"
-#include "GEOMImpl_PlaneDriver.hxx"
-#include "GEOMImpl_MarkerDriver.hxx"
+#include <GEOMImpl_PointDriver.hxx>
+#include <GEOMImpl_VectorDriver.hxx>
+#include <GEOMImpl_LineDriver.hxx>
+#include <GEOMImpl_PlaneDriver.hxx>
+#include <GEOMImpl_MarkerDriver.hxx>
-#include "GEOMImpl_IPoint.hxx"
-#include "GEOMImpl_IVector.hxx"
-#include "GEOMImpl_ILine.hxx"
-#include "GEOMImpl_IPlane.hxx"
-#include "GEOMImpl_IMarker.hxx"
+#include <GEOMImpl_IPoint.hxx>
+#include <GEOMImpl_IVector.hxx>
+#include <GEOMImpl_ILine.hxx>
+#include <GEOMImpl_IPlane.hxx>
+#include <GEOMImpl_IMarker.hxx>
-#include "GEOMImpl_Types.hxx"
+#include <GEOMImpl_Types.hxx>
#include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
class GEOMImpl_IBasicOperations : public GEOM_IOperations {
public:
- GEOMImpl_IBasicOperations(GEOM_Engine* theEngine, int theDocID);
- ~GEOMImpl_IBasicOperations();
+ Standard_EXPORT GEOMImpl_IBasicOperations(GEOM_Engine* theEngine, int theDocID);
+ Standard_EXPORT ~GEOMImpl_IBasicOperations();
// Point
- Handle(GEOM_Object) MakePointXYZ (double theX, double theY, double theZ);
+ Standard_EXPORT Handle(GEOM_Object) MakePointXYZ (double theX, double theY, double theZ);
- Handle(GEOM_Object) MakePointWithReference (Handle(GEOM_Object) theReference,
+ Standard_EXPORT Handle(GEOM_Object) MakePointWithReference (Handle(GEOM_Object) theReference,
double theX, double theY, double theZ);
- Handle(GEOM_Object) MakePointOnCurve (Handle(GEOM_Object) theCurve,
+ Standard_EXPORT Handle(GEOM_Object) MakePointOnCurve (Handle(GEOM_Object) theCurve,
double theParameter);
// Vector
- Handle(GEOM_Object) MakeVectorDXDYDZ (double theDX, double theDY, double theDZ);
+ Standard_EXPORT Handle(GEOM_Object) MakeVectorDXDYDZ (double theDX, double theDY, double theDZ);
- Handle(GEOM_Object) MakeVectorTwoPnt (Handle(GEOM_Object) thePnt1,
+ Standard_EXPORT Handle(GEOM_Object) MakeVectorTwoPnt (Handle(GEOM_Object) thePnt1,
Handle(GEOM_Object) thePnt2);
// Line
- Handle(GEOM_Object) MakeLineTwoPnt (Handle(GEOM_Object) thePnt1,
+ Standard_EXPORT Handle(GEOM_Object) MakeLineTwoPnt (Handle(GEOM_Object) thePnt1,
Handle(GEOM_Object) thePnt2);
- Handle(GEOM_Object) MakeLine (Handle(GEOM_Object) thePnt,
+ Standard_EXPORT Handle(GEOM_Object) MakeLine (Handle(GEOM_Object) thePnt,
Handle(GEOM_Object) theDir);
// Plane
- Handle(GEOM_Object) MakePlaneThreePnt (Handle(GEOM_Object) thePnt1,
+ Standard_EXPORT Handle(GEOM_Object) MakePlaneThreePnt (Handle(GEOM_Object) thePnt1,
Handle(GEOM_Object) thePnt2,
Handle(GEOM_Object) thePnt3,
double theSize);
- Handle(GEOM_Object) MakePlanePntVec (Handle(GEOM_Object) thePnt,
+ Standard_EXPORT Handle(GEOM_Object) MakePlanePntVec (Handle(GEOM_Object) thePnt,
Handle(GEOM_Object) theVec,
double theSize);
- Handle(GEOM_Object) MakePlaneFace (Handle(GEOM_Object) theFace, double theSize);
+ Standard_EXPORT Handle(GEOM_Object) MakePlaneFace (Handle(GEOM_Object) theFace, double theSize);
// Marker
- Handle(GEOM_Object) MakeMarker (double theOX, double theOY, double theOZ,
+ Standard_EXPORT Handle(GEOM_Object) MakeMarker (double theOX, double theOY, double theOZ,
double theXDX, double theXDY, double theXDZ,
double theYDX, double theYDY, double theYDZ);
};
-using namespace std;
+#ifdef WNT
+#pragma warning( disable:4786 )
+#endif
-#include "GEOMImpl_IBlocksOperations.hxx"
+#include <Standard_Stream.hxx>
-#include "GEOMImpl_Types.hxx"
+#include <GEOMImpl_IBlocksOperations.hxx>
-#include "GEOMImpl_BlockDriver.hxx"
-#include "GEOMImpl_IBlocks.hxx"
-#include "GEOMImpl_IBlockTrsf.hxx"
-#include "GEOMImpl_CopyDriver.hxx"
-#include "GEOMImpl_Block6Explorer.hxx"
+#include <GEOMImpl_Types.hxx>
-#include "GEOM_Function.hxx"
-#include "GEOM_PythonDump.hxx"
+#include <GEOMImpl_BlockDriver.hxx>
+#include <GEOMImpl_IBlocks.hxx>
+#include <GEOMImpl_IBlockTrsf.hxx>
+#include <GEOMImpl_CopyDriver.hxx>
+#include <GEOMImpl_Block6Explorer.hxx>
-#include "GEOMAlgo_GlueAnalyser.hxx"
-#include "GEOMAlgo_CoupleOfShapes.hxx"
-#include "GEOMAlgo_ListOfCoupleOfShapes.hxx"
-#include "GEOMAlgo_ListIteratorOfListOfCoupleOfShapes.hxx"
-#include "BlockFix_CheckTool.hxx"
+#include <GEOM_Function.hxx>
+#include <GEOM_PythonDump.hxx>
+
+#include <GEOMAlgo_GlueAnalyser.hxx>
+#include <GEOMAlgo_CoupleOfShapes.hxx>
+#include <GEOMAlgo_ListOfCoupleOfShapes.hxx>
+#include <GEOMAlgo_ListIteratorOfListOfCoupleOfShapes.hxx>
+#include <BlockFix_CheckTool.hxx>
#include "utilities.h"
-#include "OpUtil.hxx"
-#include "Utils_ExceptHandlers.hxx"
+#include <OpUtil.hxx>
+#include <Utils_ExceptHandlers.hxx>
#include <TFunction_DriverTable.hxx>
#include <TFunction_Driver.hxx>
class GEOMImpl_IBlocksOperations : public GEOM_IOperations {
public:
- GEOMImpl_IBlocksOperations(GEOM_Engine* theEngine, int theDocID);
- ~GEOMImpl_IBlocksOperations();
+ Standard_EXPORT GEOMImpl_IBlocksOperations(GEOM_Engine* theEngine, int theDocID);
+ Standard_EXPORT ~GEOMImpl_IBlocksOperations();
// Creation of blocks and block faces
- Handle(GEOM_Object) MakeQuad (Handle(GEOM_Object) theEdge1,
+ Standard_EXPORT Handle(GEOM_Object) MakeQuad (Handle(GEOM_Object) theEdge1,
Handle(GEOM_Object) theEdge2,
Handle(GEOM_Object) theEdge3,
Handle(GEOM_Object) theEdge4);
- Handle(GEOM_Object) MakeQuad2Edges (Handle(GEOM_Object) theEdge1,
+ Standard_EXPORT Handle(GEOM_Object) MakeQuad2Edges (Handle(GEOM_Object) theEdge1,
Handle(GEOM_Object) theEdge2);
- Handle(GEOM_Object) MakeQuad4Vertices (Handle(GEOM_Object) thePoint1,
+ Standard_EXPORT Handle(GEOM_Object) MakeQuad4Vertices (Handle(GEOM_Object) thePoint1,
Handle(GEOM_Object) thePoint2,
Handle(GEOM_Object) thePoint3,
Handle(GEOM_Object) thePoint4);
- Handle(GEOM_Object) MakeHexa (Handle(GEOM_Object) theFace1,
+ Standard_EXPORT Handle(GEOM_Object) MakeHexa (Handle(GEOM_Object) theFace1,
Handle(GEOM_Object) theFace2,
Handle(GEOM_Object) theFace3,
Handle(GEOM_Object) theFace4,
Handle(GEOM_Object) theFace5,
Handle(GEOM_Object) theFace6);
- Handle(GEOM_Object) MakeHexa2Faces (Handle(GEOM_Object) theFace1,
+ Standard_EXPORT Handle(GEOM_Object) MakeHexa2Faces (Handle(GEOM_Object) theFace1,
Handle(GEOM_Object) theFace2);
- Handle(GEOM_Object) MakeBlockCompound (Handle(GEOM_Object) theCompound);
+ Standard_EXPORT Handle(GEOM_Object) MakeBlockCompound (Handle(GEOM_Object) theCompound);
// Extract elements of blocks and blocks compounds
- Handle(GEOM_Object) GetPoint (Handle(GEOM_Object) theShape,
+ Standard_EXPORT Handle(GEOM_Object) GetPoint (Handle(GEOM_Object) theShape,
const Standard_Real theX,
const Standard_Real theY,
const Standard_Real theZ,
const Standard_Real theEpsilon);
- Handle(GEOM_Object) GetEdge (Handle(GEOM_Object) theShape,
+ Standard_EXPORT Handle(GEOM_Object) GetEdge (Handle(GEOM_Object) theShape,
Handle(GEOM_Object) thePoint1,
Handle(GEOM_Object) thePoint2);
- Handle(GEOM_Object) GetEdgeNearPoint (Handle(GEOM_Object) theBlock,
+ Standard_EXPORT Handle(GEOM_Object) GetEdgeNearPoint (Handle(GEOM_Object) theBlock,
Handle(GEOM_Object) thePoint);
- Handle(GEOM_Object) GetFaceByPoints (Handle(GEOM_Object) theShape,
+ Standard_EXPORT Handle(GEOM_Object) GetFaceByPoints (Handle(GEOM_Object) theShape,
Handle(GEOM_Object) thePoint1,
Handle(GEOM_Object) thePoint2,
Handle(GEOM_Object) thePoint3,
Handle(GEOM_Object) thePoint4);
- Handle(GEOM_Object) GetFaceByEdges (Handle(GEOM_Object) theShape,
+ Standard_EXPORT Handle(GEOM_Object) GetFaceByEdges (Handle(GEOM_Object) theShape,
Handle(GEOM_Object) theEdge1,
Handle(GEOM_Object) theEdge2);
- Handle(GEOM_Object) GetOppositeFace (Handle(GEOM_Object) theBlock,
+ Standard_EXPORT Handle(GEOM_Object) GetOppositeFace (Handle(GEOM_Object) theBlock,
Handle(GEOM_Object) theFace);
- Handle(GEOM_Object) GetFaceNearPoint (Handle(GEOM_Object) theBlock,
+ Standard_EXPORT Handle(GEOM_Object) GetFaceNearPoint (Handle(GEOM_Object) theBlock,
Handle(GEOM_Object) thePoint);
- Handle(GEOM_Object) GetFaceByNormale (Handle(GEOM_Object) theBlock,
+ Standard_EXPORT Handle(GEOM_Object) GetFaceByNormale (Handle(GEOM_Object) theBlock,
Handle(GEOM_Object) theVector);
// Check blocks compounds
- Standard_Boolean IsCompoundOfBlocks (Handle(GEOM_Object) theCompound,
+ Standard_EXPORT Standard_Boolean IsCompoundOfBlocks (Handle(GEOM_Object) theCompound,
const Standard_Integer theMinNbFaces,
const Standard_Integer theMaxNbFaces,
Standard_Integer& theNbBlocks);
list<int> incriminated;
};
- Standard_Boolean CheckCompoundOfBlocksOld (Handle(GEOM_Object) theCompound,
+ Standard_EXPORT Standard_Boolean CheckCompoundOfBlocksOld (Handle(GEOM_Object) theCompound,
list<BCError>& theErrors);
- Standard_Boolean CheckCompoundOfBlocks (Handle(GEOM_Object) theCompound,
+ Standard_EXPORT Standard_Boolean CheckCompoundOfBlocks (Handle(GEOM_Object) theCompound,
list<BCError>& theErrors);
- TCollection_AsciiString PrintBCErrors (Handle(GEOM_Object) theCompound,
+ Standard_EXPORT TCollection_AsciiString PrintBCErrors (Handle(GEOM_Object) theCompound,
const list<BCError>& theErrors);
- Handle(GEOM_Object) RemoveExtraEdges (Handle(GEOM_Object) theShape);
+ Standard_EXPORT Handle(GEOM_Object) RemoveExtraEdges (Handle(GEOM_Object) theShape);
- Handle(GEOM_Object) CheckAndImprove (Handle(GEOM_Object) theCompound);
+ Standard_EXPORT Handle(GEOM_Object) CheckAndImprove (Handle(GEOM_Object) theCompound);
- static void AddBlocksFrom (const TopoDS_Shape& theShape,
+ Standard_EXPORT static void AddBlocksFrom (const TopoDS_Shape& theShape,
TopTools_ListOfShape& BLO,
TopTools_ListOfShape& NOT,
TopTools_ListOfShape& EXT);
// Extract blocks from blocks compounds
- Handle(TColStd_HSequenceOfTransient) ExplodeCompoundOfBlocks
+ Standard_EXPORT Handle(TColStd_HSequenceOfTransient) ExplodeCompoundOfBlocks
(Handle(GEOM_Object) theCompound,
const Standard_Integer theMinNbFaces,
const Standard_Integer theMaxNbFaces);
- Handle(GEOM_Object) GetBlockNearPoint (Handle(GEOM_Object) theCompound,
+ Standard_EXPORT Handle(GEOM_Object) GetBlockNearPoint (Handle(GEOM_Object) theCompound,
Handle(GEOM_Object) thePoint);
- Handle(GEOM_Object) GetBlockByParts
+ Standard_EXPORT Handle(GEOM_Object) GetBlockByParts
(Handle(GEOM_Object) theCompound,
const Handle(TColStd_HSequenceOfTransient)& theParts);
- Handle(TColStd_HSequenceOfTransient) GetBlocksByParts
+ Standard_EXPORT Handle(TColStd_HSequenceOfTransient) GetBlocksByParts
(Handle(GEOM_Object) theCompound,
const Handle(TColStd_HSequenceOfTransient)& theParts);
// Operations on blocks with gluing of result
- Handle(GEOM_Object) MakeMultiTransformation1D (Handle(GEOM_Object) theBlock,
+ Standard_EXPORT Handle(GEOM_Object) MakeMultiTransformation1D (Handle(GEOM_Object) theBlock,
const Standard_Integer theDirFace1,
const Standard_Integer theDirFace2,
const Standard_Integer theNbTimes);
- Handle(GEOM_Object) MakeMultiTransformation2D (Handle(GEOM_Object) theBlock,
+ Standard_EXPORT Handle(GEOM_Object) MakeMultiTransformation2D (Handle(GEOM_Object) theBlock,
const Standard_Integer theDirFace1U,
const Standard_Integer theDirFace2U,
const Standard_Integer theNbTimesU,
const Standard_Integer theNbTimesV);
// Build groups for Propagation of 1D hypotheses
- Handle(TColStd_HSequenceOfTransient) Propagate (Handle(GEOM_Object) theShape);
+ Standard_EXPORT Handle(TColStd_HSequenceOfTransient) Propagate (Handle(GEOM_Object) theShape);
};
#endif
-using namespace std;
+#include <Standard_Stream.hxx>
-#include "GEOMImpl_IBooleanOperations.hxx"
+#include <GEOMImpl_IBooleanOperations.hxx>
-#include "GEOM_Function.hxx"
-#include "GEOM_PythonDump.hxx"
+#include <GEOM_Function.hxx>
+#include <GEOM_PythonDump.hxx>
-#include "GEOMImpl_Types.hxx"
+#include <GEOMImpl_Types.hxx>
-#include "GEOMImpl_BooleanDriver.hxx"
-#include "GEOMImpl_IBoolean.hxx"
+#include <GEOMImpl_BooleanDriver.hxx>
+#include <GEOMImpl_IBoolean.hxx>
-#include "GEOMImpl_PartitionDriver.hxx"
-#include "GEOMImpl_IPartition.hxx"
+#include <GEOMImpl_PartitionDriver.hxx>
+#include <GEOMImpl_IPartition.hxx>
#include <TDF_Tool.hxx>
class GEOMImpl_IBooleanOperations : public GEOM_IOperations {
public:
- GEOMImpl_IBooleanOperations(GEOM_Engine* theEngine, int theDocID);
- ~GEOMImpl_IBooleanOperations();
+ Standard_EXPORT GEOMImpl_IBooleanOperations(GEOM_Engine* theEngine, int theDocID);
+ Standard_EXPORT ~GEOMImpl_IBooleanOperations();
- Handle(GEOM_Object) MakeBoolean (Handle(GEOM_Object) theShape1,
+ Standard_EXPORT Handle(GEOM_Object) MakeBoolean (Handle(GEOM_Object) theShape1,
Handle(GEOM_Object) theShape2,
Standard_Integer theOp);
- Handle(GEOM_Object) MakePartition (const Handle(TColStd_HSequenceOfTransient)& theShapes,
+ Standard_EXPORT Handle(GEOM_Object) MakePartition (const Handle(TColStd_HSequenceOfTransient)& theShapes,
const Handle(TColStd_HSequenceOfTransient)& theTools,
const Handle(TColStd_HSequenceOfTransient)& theKeepInside,
const Handle(TColStd_HSequenceOfTransient)& theRemoveInside,
const Standard_Boolean theRemoveWebs,
const Handle(TColStd_HArray1OfInteger)& theMaterials);
- Handle(GEOM_Object) MakeHalfPartition (Handle(GEOM_Object) theShape,
+ Standard_EXPORT Handle(GEOM_Object) MakeHalfPartition (Handle(GEOM_Object) theShape,
Handle(GEOM_Object) thePlane);
};
-using namespace std;
+#include <Standard_Stream.hxx>
-#include "GEOMImpl_ICurvesOperations.hxx"
+#include <GEOMImpl_ICurvesOperations.hxx>
-#include "GEOM_Function.hxx"
-#include "GEOM_PythonDump.hxx"
+#include <GEOM_Function.hxx>
+#include <GEOM_PythonDump.hxx>
-#include "GEOMImpl_Types.hxx"
+#include <GEOMImpl_Types.hxx>
-#include "GEOMImpl_PolylineDriver.hxx"
-#include "GEOMImpl_CircleDriver.hxx"
-#include "GEOMImpl_SplineDriver.hxx"
-#include "GEOMImpl_EllipseDriver.hxx"
-#include "GEOMImpl_ArcDriver.hxx"
-#include "GEOMImpl_SketcherDriver.hxx"
+#include <GEOMImpl_PolylineDriver.hxx>
+#include <GEOMImpl_CircleDriver.hxx>
+#include <GEOMImpl_SplineDriver.hxx>
+#include <GEOMImpl_EllipseDriver.hxx>
+#include <GEOMImpl_ArcDriver.hxx>
+#include <GEOMImpl_SketcherDriver.hxx>
-#include "GEOMImpl_IPolyline.hxx"
-#include "GEOMImpl_ICircle.hxx"
-#include "GEOMImpl_ISpline.hxx"
-#include "GEOMImpl_IEllipse.hxx"
-#include "GEOMImpl_IArc.hxx"
-#include "GEOMImpl_ISketcher.hxx"
+#include <GEOMImpl_IPolyline.hxx>
+#include <GEOMImpl_ICircle.hxx>
+#include <GEOMImpl_ISpline.hxx>
+#include <GEOMImpl_IEllipse.hxx>
+#include <GEOMImpl_IArc.hxx>
+#include <GEOMImpl_ISketcher.hxx>
#include "utilities.h"
class GEOMImpl_ICurvesOperations : public GEOM_IOperations {
public:
- GEOMImpl_ICurvesOperations(GEOM_Engine* theEngine, int theDocID);
- ~GEOMImpl_ICurvesOperations();
+ Standard_EXPORT GEOMImpl_ICurvesOperations(GEOM_Engine* theEngine, int theDocID);
+ Standard_EXPORT ~GEOMImpl_ICurvesOperations();
- Handle(GEOM_Object) MakePolyline (list<Handle(GEOM_Object)> thePoints);
+ Standard_EXPORT Handle(GEOM_Object) MakePolyline (list<Handle(GEOM_Object)> thePoints);
- Handle(GEOM_Object) MakeCircleThreePnt (Handle(GEOM_Object) thePnt1,
+ Standard_EXPORT Handle(GEOM_Object) MakeCircleThreePnt (Handle(GEOM_Object) thePnt1,
Handle(GEOM_Object) thePnt2,
Handle(GEOM_Object) thePnt3);
- Handle(GEOM_Object) MakeCirclePntVecR (Handle(GEOM_Object) thePnt,
+ Standard_EXPORT Handle(GEOM_Object) MakeCirclePntVecR (Handle(GEOM_Object) thePnt,
Handle(GEOM_Object) theVec, double theR);
- Handle(GEOM_Object) MakeEllipse (Handle(GEOM_Object) thePnt,
+ Standard_EXPORT Handle(GEOM_Object) MakeEllipse (Handle(GEOM_Object) thePnt,
Handle(GEOM_Object) theVec,
double theRMajor, double theRMinor);
- Handle(GEOM_Object) MakeArc (Handle(GEOM_Object) thePnt1,
+ Standard_EXPORT Handle(GEOM_Object) MakeArc (Handle(GEOM_Object) thePnt1,
Handle(GEOM_Object) thePnt2,
Handle(GEOM_Object) thePnt3);
- Handle(GEOM_Object) MakeSplineBezier (list<Handle(GEOM_Object)> thePoints);
- Handle(GEOM_Object) MakeSplineInterpolation (list<Handle(GEOM_Object)> thePoints);
+ Standard_EXPORT Handle(GEOM_Object) MakeSplineBezier (list<Handle(GEOM_Object)> thePoints);
+ Standard_EXPORT Handle(GEOM_Object) MakeSplineInterpolation (list<Handle(GEOM_Object)> thePoints);
- Handle(GEOM_Object) MakeSketcher (const char* theCommand, list<double> theWorkingPlane);
- Handle(GEOM_Object) MakeSketcherOnPlane (const char* theCommand,
+ Standard_EXPORT Handle(GEOM_Object) MakeSketcher (const char* theCommand, list<double> theWorkingPlane);
+ Standard_EXPORT Handle(GEOM_Object) MakeSketcherOnPlane (const char* theCommand,
Handle(GEOM_Object) theWorkingPlane);
};
-using namespace std;
+#include <Standard_Stream.hxx>
-#include "GEOMImpl_IGroupOperations.hxx"
+#include <GEOMImpl_IGroupOperations.hxx>
-#include "GEOMImpl_Types.hxx"
+#include <GEOMImpl_Types.hxx>
-#include "GEOM_Function.hxx"
-#include "GEOM_ISubShape.hxx"
-#include "GEOM_PythonDump.hxx"
+#include <GEOM_Function.hxx>
+#include <GEOM_ISubShape.hxx>
+#include <GEOM_PythonDump.hxx>
#include "utilities.h"
-#include "OpUtil.hxx"
-#include "Utils_ExceptHandlers.hxx"
+#include <OpUtil.hxx>
+#include <Utils_ExceptHandlers.hxx>
#include <TFunction_DriverTable.hxx>
#include <TFunction_Driver.hxx>
class GEOMImpl_IGroupOperations : public GEOM_IOperations {
public:
- GEOMImpl_IGroupOperations(GEOM_Engine* theEngine, int theDocID);
- ~GEOMImpl_IGroupOperations();
+ Standard_EXPORT GEOMImpl_IGroupOperations(GEOM_Engine* theEngine, int theDocID);
+ Standard_EXPORT ~GEOMImpl_IGroupOperations();
- Handle(GEOM_Object) CreateGroup(Handle(GEOM_Object) theMainShape, TopAbs_ShapeEnum theShapeType);
+ Standard_EXPORT Handle(GEOM_Object) CreateGroup(Handle(GEOM_Object) theMainShape, TopAbs_ShapeEnum theShapeType);
- void AddObject(Handle(GEOM_Object) theGroup, int theSubShapeID);
+ Standard_EXPORT void AddObject(Handle(GEOM_Object) theGroup, int theSubShapeID);
- void RemoveObject(Handle(GEOM_Object) theGroup, int theSubShapeID);
+ Standard_EXPORT void RemoveObject(Handle(GEOM_Object) theGroup, int theSubShapeID);
- void UnionList (Handle(GEOM_Object) theGroup,
+ Standard_EXPORT void UnionList (Handle(GEOM_Object) theGroup,
const Handle(TColStd_HSequenceOfTransient)& theSubShapes);
- void DifferenceList (Handle(GEOM_Object) theGroup,
+ Standard_EXPORT void DifferenceList (Handle(GEOM_Object) theGroup,
const Handle(TColStd_HSequenceOfTransient)& theSubShapes);
- void UnionIDs (Handle(GEOM_Object) theGroup,
+ Standard_EXPORT void UnionIDs (Handle(GEOM_Object) theGroup,
const Handle(TColStd_HSequenceOfInteger)& theSubShapes);
- void DifferenceIDs (Handle(GEOM_Object) theGroup,
+ Standard_EXPORT void DifferenceIDs (Handle(GEOM_Object) theGroup,
const Handle(TColStd_HSequenceOfInteger)& theSubShapes);
- TopAbs_ShapeEnum GetType(Handle(GEOM_Object) theGroup);
+ Standard_EXPORT TopAbs_ShapeEnum GetType(Handle(GEOM_Object) theGroup);
- Handle(GEOM_Object) GetMainShape(Handle(GEOM_Object) theGroup);
+ Standard_EXPORT Handle(GEOM_Object) GetMainShape(Handle(GEOM_Object) theGroup);
- Handle(TColStd_HArray1OfInteger) GetObjects(Handle(GEOM_Object) theGroup);
+ Standard_EXPORT Handle(TColStd_HArray1OfInteger) GetObjects(Handle(GEOM_Object) theGroup);
};
-using namespace std;
+#ifdef WNT
+#pragma warning( disable:4786 )
+#endif
-#include "GEOMImpl_IHealingOperations.hxx"
+#include <Standard_Stream.hxx>
-#include "GEOM_PythonDump.hxx"
+#include <GEOMImpl_IHealingOperations.hxx>
-#include "GEOMImpl_HealingDriver.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOMImpl_IHealing.hxx"
-#include "GEOMImpl_CopyDriver.hxx"
+#include <GEOM_PythonDump.hxx>
-#include "ShHealOper_ShapeProcess.hxx"
+#include <GEOMImpl_HealingDriver.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOMImpl_IHealing.hxx>
+#include <GEOMImpl_CopyDriver.hxx>
+
+#include <ShHealOper_ShapeProcess.hxx>
#include "utilities.h"
-#include "OpUtil.hxx"
-#include "Utils_ExceptHandlers.hxx"
+#include <OpUtil.hxx>
+#include <Utils_ExceptHandlers.hxx>
#include <ShapeAnalysis_FreeBounds.hxx>
class GEOMImpl_IHealingOperations : public GEOM_IOperations {
public:
- GEOMImpl_IHealingOperations(GEOM_Engine* theEngine, int theDocID);
- ~GEOMImpl_IHealingOperations();
+ Standard_EXPORT GEOMImpl_IHealingOperations(GEOM_Engine* theEngine, int theDocID);
+ Standard_EXPORT ~GEOMImpl_IHealingOperations();
// Apply Shape Processing to the selected Object
- Handle(GEOM_Object) ShapeProcess( Handle(GEOM_Object) theObject,
+ Standard_EXPORT Handle(GEOM_Object) ShapeProcess( Handle(GEOM_Object) theObject,
const Handle(TColStd_HArray1OfExtendedString)& theOperations,
const Handle(TColStd_HArray1OfExtendedString)& theParams,
const Handle(TColStd_HArray1OfExtendedString)& theValues );
// Retrieve default Shape Process parameters (from resource file)
- void GetShapeProcessParameters( list<string>& theOperations,
+ Standard_EXPORT void GetShapeProcessParameters( list<string>& theOperations,
list<string>& theParams,
list<string>& theValues );
// Retrieve default Shape Process parameters for given operator
- bool GetOperatorParameters( const string theOperation,
+ Standard_EXPORT bool GetOperatorParameters( const string theOperation,
list<string>& theParams,
list<string>& theValues );
// returns all parameters that are valid for the given operation (Shape Process operator)
- static bool GetParameters( const string theOperation, list<string>& theParams );
+ Standard_EXPORT static bool GetParameters( const string theOperation, list<string>& theParams );
- Handle(GEOM_Object) SuppressFaces( Handle(GEOM_Object) theObject,
+ Standard_EXPORT Handle(GEOM_Object) SuppressFaces( Handle(GEOM_Object) theObject,
const Handle(TColStd_HArray1OfInteger)& theFaces);
- Handle(GEOM_Object) CloseContour( Handle(GEOM_Object) theObject,
+ Standard_EXPORT Handle(GEOM_Object) CloseContour( Handle(GEOM_Object) theObject,
const Handle(TColStd_HArray1OfInteger)& theWires,
bool isCommonVertex );
- Handle(GEOM_Object) RemoveIntWires( Handle(GEOM_Object) theObject,
+ Standard_EXPORT Handle(GEOM_Object) RemoveIntWires( Handle(GEOM_Object) theObject,
const Handle(TColStd_HArray1OfInteger)& theWires);
- Handle(GEOM_Object) FillHoles( Handle(GEOM_Object) theObject,
+ Standard_EXPORT Handle(GEOM_Object) FillHoles( Handle(GEOM_Object) theObject,
const Handle(TColStd_HArray1OfInteger)& theWires);
- Handle(GEOM_Object) Sew( Handle(GEOM_Object) theObject,
+ Standard_EXPORT Handle(GEOM_Object) Sew( Handle(GEOM_Object) theObject,
double theTolerance );
- Handle(GEOM_Object) DivideEdge( Handle(GEOM_Object) theObject,
+ Standard_EXPORT Handle(GEOM_Object) DivideEdge( Handle(GEOM_Object) theObject,
int theIndex,
double theValue,
bool isByParameter );
// this function does not use Function-Driver mechanism, it just computes the free
// boundary edges and returns them in the sequence. It is called just for information reasons
// and it's not intended for history/undo/redo/etc..
- bool GetFreeBoundary ( Handle(GEOM_Object) theObject,
+ Standard_EXPORT bool GetFreeBoundary ( Handle(GEOM_Object) theObject,
Handle(TColStd_HSequenceOfTransient)& theOutClosedWires,
Handle(TColStd_HSequenceOfTransient)& theOutOpenWires );
};
-using namespace std;
+#include <Standard_Stream.hxx>
-#include "GEOMImpl_IInsertOperations.hxx"
+#include <GEOMImpl_IInsertOperations.hxx>
#include "utilities.h"
-#include "OpUtil.hxx"
-#include "Utils_ExceptHandlers.hxx"
+#include <OpUtil.hxx>
+#include <Utils_ExceptHandlers.hxx>
#include <TFunction_DriverTable.hxx>
#include <TFunction_Driver.hxx>
#include <TFunction_Logbook.hxx>
#include <TDF_Tool.hxx>
-#include "GEOM_Function.hxx"
-#include "GEOM_PythonDump.hxx"
+#include <GEOM_Function.hxx>
+#include <GEOM_PythonDump.hxx>
-#include "GEOMImpl_CopyDriver.hxx"
-#include "GEOMImpl_ExportDriver.hxx"
-#include "GEOMImpl_ImportDriver.hxx"
+#include <GEOMImpl_CopyDriver.hxx>
+#include <GEOMImpl_ExportDriver.hxx>
+#include <GEOMImpl_ImportDriver.hxx>
-#include "GEOMImpl_ICopy.hxx"
-#include "GEOMImpl_IImportExport.hxx"
+#include <GEOMImpl_ICopy.hxx>
+#include <GEOMImpl_IImportExport.hxx>
-#include "GEOMImpl_Types.hxx"
+#include <GEOMImpl_Types.hxx>
#include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
class GEOMImpl_IInsertOperations : public GEOM_IOperations {
public:
- GEOMImpl_IInsertOperations(GEOM_Engine* theEngine, int theDocID);
- ~GEOMImpl_IInsertOperations();
+ Standard_EXPORT GEOMImpl_IInsertOperations(GEOM_Engine* theEngine, int theDocID);
+ Standard_EXPORT ~GEOMImpl_IInsertOperations();
- Handle(GEOM_Object) MakeCopy (Handle(GEOM_Object) theOriginal);
+ Standard_EXPORT Handle(GEOM_Object) MakeCopy (Handle(GEOM_Object) theOriginal);
- Handle(GEOM_Object) Import (const char* theFileName, const char* theFormatType);
+ Standard_EXPORT Handle(GEOM_Object) Import (const char* theFileName, const char* theFormatType);
- void Export (const Handle(GEOM_Object) theOriginal,
+ Standard_EXPORT void Export (const Handle(GEOM_Object) theOriginal,
const char* theFileName,
const char* theFormatType);
- Standard_Boolean ImportTranslators (Handle(TColStd_HSequenceOfAsciiString)& theFormats,
+ Standard_EXPORT Standard_Boolean ImportTranslators (Handle(TColStd_HSequenceOfAsciiString)& theFormats,
Handle(TColStd_HSequenceOfAsciiString)& thePatterns);
- Standard_Boolean ExportTranslators (Handle(TColStd_HSequenceOfAsciiString)& theFormats,
+ Standard_EXPORT Standard_Boolean ExportTranslators (Handle(TColStd_HSequenceOfAsciiString)& theFormats,
Handle(TColStd_HSequenceOfAsciiString)& thePatterns);
- Standard_Boolean IsSupported (const Standard_Boolean isImport,
+ Standard_EXPORT Standard_Boolean IsSupported (const Standard_Boolean isImport,
const TCollection_AsciiString theFormat,
Handle(TCollection_HAsciiString)& theLibName);
-using namespace std;
+#include <Standard_Stream.hxx>
-#include "GEOMImpl_ILocalOperations.hxx"
+#include <GEOMImpl_ILocalOperations.hxx>
-#include "GEOM_Function.hxx"
-#include "GEOM_PythonDump.hxx"
+#include <GEOM_Function.hxx>
+#include <GEOM_PythonDump.hxx>
-#include "GEOMImpl_Types.hxx"
+#include <GEOMImpl_Types.hxx>
-#include "GEOMImpl_FilletDriver.hxx"
-#include "GEOMImpl_ChamferDriver.hxx"
+#include <GEOMImpl_FilletDriver.hxx>
+#include <GEOMImpl_ChamferDriver.hxx>
-#include "GEOMImpl_IFillet.hxx"
-#include "GEOMImpl_IChamfer.hxx"
+#include <GEOMImpl_IFillet.hxx>
+#include <GEOMImpl_IChamfer.hxx>
-#include "GEOMImpl_IArchimede.hxx"
-#include "GEOMImpl_ArchimedeDriver.hxx"
+#include <GEOMImpl_IArchimede.hxx>
+#include <GEOMImpl_ArchimedeDriver.hxx>
#include "utilities.h"
-#include "OpUtil.hxx"
-#include "Utils_ExceptHandlers.hxx"
+#include <OpUtil.hxx>
+#include <Utils_ExceptHandlers.hxx>
#include <TFunction_DriverTable.hxx>
#include <TFunction_Driver.hxx>
class GEOMImpl_ILocalOperations : public GEOM_IOperations {
public:
- GEOMImpl_ILocalOperations(GEOM_Engine* theEngine, int theDocID);
- ~GEOMImpl_ILocalOperations();
+ Standard_EXPORT GEOMImpl_ILocalOperations(GEOM_Engine* theEngine, int theDocID);
+ Standard_EXPORT ~GEOMImpl_ILocalOperations();
- Handle(GEOM_Object) MakeFilletAll (Handle(GEOM_Object) theShape, double theR);
- Handle(GEOM_Object) MakeFilletEdges (Handle(GEOM_Object) theShape, double theR,
+ Standard_EXPORT Handle(GEOM_Object) MakeFilletAll (Handle(GEOM_Object) theShape, double theR);
+ Standard_EXPORT Handle(GEOM_Object) MakeFilletEdges (Handle(GEOM_Object) theShape, double theR,
list<int> theEdges);
- Handle(GEOM_Object) MakeFilletFaces (Handle(GEOM_Object) theShape, double theR,
+ Standard_EXPORT Handle(GEOM_Object) MakeFilletFaces (Handle(GEOM_Object) theShape, double theR,
list<int> theFaces);
- Handle(GEOM_Object) MakeChamferAll (Handle(GEOM_Object) theShape, double theD);
- Handle(GEOM_Object) MakeChamferEdge (Handle(GEOM_Object) theShape,
+ Standard_EXPORT Handle(GEOM_Object) MakeChamferAll (Handle(GEOM_Object) theShape, double theD);
+ Standard_EXPORT Handle(GEOM_Object) MakeChamferEdge (Handle(GEOM_Object) theShape,
double theD1, double theD2,
int theFace1, int theFace2);
- Handle(GEOM_Object) MakeChamferFaces (Handle(GEOM_Object) theShape,
+ Standard_EXPORT Handle(GEOM_Object) MakeChamferFaces (Handle(GEOM_Object) theShape,
double theD1, double theD2,
list<int> theFaces);
- Handle(GEOM_Object) MakeArchimede (Handle(GEOM_Object) theShape,
+ Standard_EXPORT Handle(GEOM_Object) MakeArchimede (Handle(GEOM_Object) theShape,
double theWeight, double theWaterDensity,
double theMeshingDeflection);
- Standard_Integer GetSubShapeIndex (Handle(GEOM_Object) theShape,
+ Standard_EXPORT Standard_Integer GetSubShapeIndex (Handle(GEOM_Object) theShape,
Handle(GEOM_Object) theSubShape);
- static bool GetSubShape (const TopoDS_Shape& theShape,
+ Standard_EXPORT static bool GetSubShape (const TopoDS_Shape& theShape,
const int theIndex,
TopoDS_Shape& theSubShape);
};
-using namespace std;
+#include <Standard_Stream.hxx>
-#include "GEOMImpl_IMeasureOperations.hxx"
+#include <GEOMImpl_IMeasureOperations.hxx>
-#include "GEOMImpl_Types.hxx"
-#include "GEOMImpl_MeasureDriver.hxx"
-#include "GEOMImpl_IMeasure.hxx"
+#include <GEOMImpl_Types.hxx>
+#include <GEOMImpl_MeasureDriver.hxx>
+#include <GEOMImpl_IMeasure.hxx>
-#include "GEOM_Function.hxx"
-#include "GEOM_PythonDump.hxx"
+#include <GEOM_Function.hxx>
+#include <GEOM_PythonDump.hxx>
#include "utilities.h"
-#include "OpUtil.hxx"
-#include "Utils_ExceptHandlers.hxx"
+#include <OpUtil.hxx>
+#include <Utils_ExceptHandlers.hxx>
#include <TFunction_DriverTable.hxx>
#include <TFunction_Driver.hxx>
class GEOMImpl_IMeasureOperations : public GEOM_IOperations {
public:
- GEOMImpl_IMeasureOperations(GEOM_Engine* theEngine, int theDocID);
- ~GEOMImpl_IMeasureOperations();
+ Standard_EXPORT GEOMImpl_IMeasureOperations(GEOM_Engine* theEngine, int theDocID);
+ Standard_EXPORT ~GEOMImpl_IMeasureOperations();
- Handle(GEOM_Object) GetCentreOfMass (Handle(GEOM_Object) theShape);
+ Standard_EXPORT Handle(GEOM_Object) GetCentreOfMass (Handle(GEOM_Object) theShape);
- void GetBasicProperties (Handle(GEOM_Object) theShape,
+ Standard_EXPORT void GetBasicProperties (Handle(GEOM_Object) theShape,
Standard_Real& theLength,
Standard_Real& theSurfArea,
Standard_Real& theVolume);
- void GetInertia (Handle(GEOM_Object) theShape,
+ Standard_EXPORT void GetInertia (Handle(GEOM_Object) theShape,
Standard_Real& I11, Standard_Real& I12, Standard_Real& I13,
Standard_Real& I21, Standard_Real& I22, Standard_Real& I23,
Standard_Real& I31, Standard_Real& I32, Standard_Real& I33,
Standard_Real& Ix , Standard_Real& Iy , Standard_Real& Iz);
- void GetBoundingBox (Handle(GEOM_Object) theShape,
+ Standard_EXPORT void GetBoundingBox (Handle(GEOM_Object) theShape,
Standard_Real& Xmin, Standard_Real& Xmax,
Standard_Real& Ymin, Standard_Real& Ymax,
Standard_Real& Zmin, Standard_Real& Zmax);
- void GetTolerance (Handle(GEOM_Object) theShape,
+ Standard_EXPORT void GetTolerance (Handle(GEOM_Object) theShape,
Standard_Real& FaceMin, Standard_Real& FaceMax,
Standard_Real& EdgeMin, Standard_Real& EdgeMax,
Standard_Real& VertMin, Standard_Real& VertMax);
- bool CheckShape (Handle(GEOM_Object) theShape,
+ Standard_EXPORT bool CheckShape (Handle(GEOM_Object) theShape,
TCollection_AsciiString& theDump);
- TCollection_AsciiString WhatIs (Handle(GEOM_Object) theShape);
+ Standard_EXPORT TCollection_AsciiString WhatIs (Handle(GEOM_Object) theShape);
- Standard_Real GetMinDistance (Handle(GEOM_Object) theShape1, Handle(GEOM_Object) theShape2,
+ Standard_EXPORT Standard_Real GetMinDistance (Handle(GEOM_Object) theShape1, Handle(GEOM_Object) theShape2,
Standard_Real& X1, Standard_Real& Y1, Standard_Real& Z1,
Standard_Real& X2, Standard_Real& Y2, Standard_Real& Z2);
- void PointCoordinates( Handle(GEOM_Object) theShape,
+ Standard_EXPORT void PointCoordinates( Handle(GEOM_Object) theShape,
Standard_Real& theX, Standard_Real& theY, Standard_Real& theZ );
private:
-using namespace std;
+#include <Standard_Stream.hxx>
-#include "GEOMImpl_IShapesOperations.hxx"
+#include <GEOMImpl_IShapesOperations.hxx>
-#include "GEOMImpl_Types.hxx"
+#include <GEOMImpl_Types.hxx>
-#include "GEOMImpl_VectorDriver.hxx"
-#include "GEOMImpl_ShapeDriver.hxx"
-#include "GEOMImpl_CopyDriver.hxx"
-#include "GEOMImpl_GlueDriver.hxx"
+#include <GEOMImpl_VectorDriver.hxx>
+#include <GEOMImpl_ShapeDriver.hxx>
+#include <GEOMImpl_CopyDriver.hxx>
+#include <GEOMImpl_GlueDriver.hxx>
-#include "GEOMImpl_IVector.hxx"
-#include "GEOMImpl_IShapes.hxx"
-#include "GEOMImpl_IGlue.hxx"
+#include <GEOMImpl_IVector.hxx>
+#include <GEOMImpl_IShapes.hxx>
+#include <GEOMImpl_IGlue.hxx>
-#include "GEOMImpl_Block6Explorer.hxx"
+#include <GEOMImpl_Block6Explorer.hxx>
-#include "GEOM_Function.hxx"
-#include "GEOM_PythonDump.hxx"
+#include <GEOM_Function.hxx>
+#include <GEOM_PythonDump.hxx>
-#include "GEOMAlgo_FinderShapeOn1.hxx"
+#include <GEOMAlgo_FinderShapeOn1.hxx>
#include "utilities.h"
-#include "OpUtil.hxx"
-#include "Utils_ExceptHandlers.hxx"
+#include <OpUtil.hxx>
+#include <Utils_ExceptHandlers.hxx>
#include <TFunction_DriverTable.hxx>
#include <TFunction_Driver.hxx>
class GEOMImpl_IShapesOperations : public GEOM_IOperations {
public:
- GEOMImpl_IShapesOperations(GEOM_Engine* theEngine, int theDocID);
- ~GEOMImpl_IShapesOperations();
+ Standard_EXPORT GEOMImpl_IShapesOperations(GEOM_Engine* theEngine, int theDocID);
+ Standard_EXPORT ~GEOMImpl_IShapesOperations();
- Handle(GEOM_Object) MakeEdge (Handle(GEOM_Object) thePoint1,
+ Standard_EXPORT Handle(GEOM_Object) MakeEdge (Handle(GEOM_Object) thePoint1,
Handle(GEOM_Object) thePoint2);
- Handle(GEOM_Object) MakeWire (list<Handle(GEOM_Object)> theEdgesAndWires);
+ Standard_EXPORT Handle(GEOM_Object) MakeWire (list<Handle(GEOM_Object)> theEdgesAndWires);
- Handle(GEOM_Object) MakeFace (Handle(GEOM_Object) theWire, const bool isPlanarWanted);
+ Standard_EXPORT Handle(GEOM_Object) MakeFace (Handle(GEOM_Object) theWire, const bool isPlanarWanted);
- Handle(GEOM_Object) MakeFaceWires (list<Handle(GEOM_Object)> theWires,
+ Standard_EXPORT Handle(GEOM_Object) MakeFaceWires (list<Handle(GEOM_Object)> theWires,
const bool isPlanarWanted);
- Handle(GEOM_Object) MakeShell (list<Handle(GEOM_Object)> theShapes);
+ Standard_EXPORT Handle(GEOM_Object) MakeShell (list<Handle(GEOM_Object)> theShapes);
- Handle(GEOM_Object) MakeSolidShell (Handle(GEOM_Object) theShell);
+ Standard_EXPORT Handle(GEOM_Object) MakeSolidShell (Handle(GEOM_Object) theShell);
- Handle(GEOM_Object) MakeSolidShells (list<Handle(GEOM_Object)> theShells);
+ Standard_EXPORT Handle(GEOM_Object) MakeSolidShells (list<Handle(GEOM_Object)> theShells);
- Handle(GEOM_Object) MakeCompound (list<Handle(GEOM_Object)> theShapes);
+ Standard_EXPORT Handle(GEOM_Object) MakeCompound (list<Handle(GEOM_Object)> theShapes);
- Handle(GEOM_Object) MakeGlueFaces (Handle(GEOM_Object) theShape,
+ Standard_EXPORT Handle(GEOM_Object) MakeGlueFaces (Handle(GEOM_Object) theShape,
const Standard_Real theTolerance);
- Handle(TColStd_HSequenceOfTransient) MakeExplode (Handle(GEOM_Object) theShape,
+ Standard_EXPORT Handle(TColStd_HSequenceOfTransient) MakeExplode (Handle(GEOM_Object) theShape,
const Standard_Integer theShapeType,
const Standard_Boolean isSorted);
- Handle(TColStd_HSequenceOfInteger) SubShapeAllIDs (Handle(GEOM_Object) theShape,
+ Standard_EXPORT Handle(TColStd_HSequenceOfInteger) SubShapeAllIDs (Handle(GEOM_Object) theShape,
const Standard_Integer theShapeType,
const Standard_Boolean isSorted);
- Handle(GEOM_Object) GetSubShape (Handle(GEOM_Object) theMainShape,
+ Standard_EXPORT Handle(GEOM_Object) GetSubShape (Handle(GEOM_Object) theMainShape,
const Standard_Integer theID);
- Standard_Integer NumberOfFaces (Handle(GEOM_Object) theShape);
- Standard_Integer NumberOfEdges (Handle(GEOM_Object) theShape);
+ Standard_EXPORT Standard_Integer NumberOfFaces (Handle(GEOM_Object) theShape);
+ Standard_EXPORT Standard_Integer NumberOfEdges (Handle(GEOM_Object) theShape);
- Handle(GEOM_Object) ReverseShape(Handle(GEOM_Object) theShapes);
+ Standard_EXPORT Handle(GEOM_Object) ReverseShape(Handle(GEOM_Object) theShapes);
- Handle(TColStd_HSequenceOfInteger) GetFreeFacesIDs (Handle(GEOM_Object) theShape);
+ Standard_EXPORT Handle(TColStd_HSequenceOfInteger) GetFreeFacesIDs (Handle(GEOM_Object) theShape);
- Handle(TColStd_HSequenceOfTransient) GetSharedShapes (Handle(GEOM_Object) theShape1,
+ Standard_EXPORT Handle(TColStd_HSequenceOfTransient) GetSharedShapes (Handle(GEOM_Object) theShape1,
Handle(GEOM_Object) theShape2,
const Standard_Integer theShapeType);
- Handle(TColStd_HSequenceOfTransient) GetShapesOnPlane (const Handle(GEOM_Object)& theShape,
+ Standard_EXPORT Handle(TColStd_HSequenceOfTransient) GetShapesOnPlane (const Handle(GEOM_Object)& theShape,
const Standard_Integer theShapeType,
const Handle(GEOM_Object)& theAx1,
const GEOMAlgo_State theState);
- Handle(TColStd_HSequenceOfTransient) GetShapesOnCylinder (const Handle(GEOM_Object)& theShape,
+ Standard_EXPORT Handle(TColStd_HSequenceOfTransient) GetShapesOnCylinder (const Handle(GEOM_Object)& theShape,
const Standard_Integer theShapeType,
const Handle(GEOM_Object)& theAxis,
const Standard_Real theRadius,
const GEOMAlgo_State theState);
- Handle(TColStd_HSequenceOfTransient) GetShapesOnSphere (const Handle(GEOM_Object)& theShape,
+ Standard_EXPORT Handle(TColStd_HSequenceOfTransient) GetShapesOnSphere (const Handle(GEOM_Object)& theShape,
const Standard_Integer theShapeType,
const Handle(GEOM_Object)& theCenter,
const Standard_Real theRadius,
const GEOMAlgo_State theState);
- Handle(TColStd_HSequenceOfInteger) GetShapesOnPlaneIDs (const Handle(GEOM_Object)& theShape,
+ Standard_EXPORT Handle(TColStd_HSequenceOfInteger) GetShapesOnPlaneIDs (const Handle(GEOM_Object)& theShape,
const Standard_Integer theShapeType,
const Handle(GEOM_Object)& theAx1,
const GEOMAlgo_State theState);
- Handle(TColStd_HSequenceOfInteger) GetShapesOnCylinderIDs (const Handle(GEOM_Object)& theShape,
+ Standard_EXPORT Handle(TColStd_HSequenceOfInteger) GetShapesOnCylinderIDs (const Handle(GEOM_Object)& theShape,
const Standard_Integer theShapeType,
const Handle(GEOM_Object)& theAxis,
const Standard_Real theRadius,
const GEOMAlgo_State theState);
- Handle(TColStd_HSequenceOfInteger) GetShapesOnSphereIDs (const Handle(GEOM_Object)& theShape,
+ Standard_EXPORT Handle(TColStd_HSequenceOfInteger) GetShapesOnSphereIDs (const Handle(GEOM_Object)& theShape,
const Standard_Integer theShapeType,
const Handle(GEOM_Object)& theCenter,
const Standard_Real theRadius,
const GEOMAlgo_State theState);
- Handle(GEOM_Object) GetShapesOnCylinderOld (Handle(GEOM_Object) theShape,
+ Standard_EXPORT Handle(GEOM_Object) GetShapesOnCylinderOld (Handle(GEOM_Object) theShape,
const Standard_Integer theShapeType,
Handle(GEOM_Object) theAxis,
const Standard_Real theRadius);
- Handle(GEOM_Object) GetShapesOnSphereOld (Handle(GEOM_Object) theShape,
+ Standard_EXPORT Handle(GEOM_Object) GetShapesOnSphereOld (Handle(GEOM_Object) theShape,
const Standard_Integer theShapeType,
Handle(GEOM_Object) theCenter,
const Standard_Real theRadius);
- Handle(GEOM_Object) GetInPlace (Handle(GEOM_Object) theShapeWhere,
+ Standard_EXPORT Handle(GEOM_Object) GetInPlace (Handle(GEOM_Object) theShapeWhere,
Handle(GEOM_Object) theShapeWhat);
- static void SortShapes (TopTools_ListOfShape& SL);
+ Standard_EXPORT static void SortShapes (TopTools_ListOfShape& SL);
private:
Handle(GEOM_Object) MakeShape (list<Handle(GEOM_Object)> theShapes,
-using namespace std;
+#include <Standard_Stream.hxx>
-#include "GEOMImpl_ITransformOperations.hxx"
+#include <GEOMImpl_ITransformOperations.hxx>
#include "utilities.h"
-#include "OpUtil.hxx"
-#include "Utils_ExceptHandlers.hxx"
+#include <OpUtil.hxx>
+#include <Utils_ExceptHandlers.hxx>
#include <TFunction_DriverTable.hxx>
#include <TFunction_Driver.hxx>
#include <TFunction_Logbook.hxx>
#include <TDF_Tool.hxx>
-#include "GEOM_Function.hxx"
-#include "GEOM_PythonDump.hxx"
+#include <GEOM_Function.hxx>
+#include <GEOM_PythonDump.hxx>
-#include "GEOMImpl_TranslateDriver.hxx"
-#include "GEOMImpl_MirrorDriver.hxx"
-#include "GEOMImpl_OffsetDriver.hxx"
-#include "GEOMImpl_ScaleDriver.hxx"
-#include "GEOMImpl_RotateDriver.hxx"
-#include "GEOMImpl_PositionDriver.hxx"
+#include <GEOMImpl_TranslateDriver.hxx>
+#include <GEOMImpl_MirrorDriver.hxx>
+#include <GEOMImpl_OffsetDriver.hxx>
+#include <GEOMImpl_ScaleDriver.hxx>
+#include <GEOMImpl_RotateDriver.hxx>
+#include <GEOMImpl_PositionDriver.hxx>
-#include "GEOMImpl_ITranslate.hxx"
-#include "GEOMImpl_IMirror.hxx"
-#include "GEOMImpl_IOffset.hxx"
-#include "GEOMImpl_IScale.hxx"
-#include "GEOMImpl_IRotate.hxx"
-#include "GEOMImpl_IPosition.hxx"
+#include <GEOMImpl_ITranslate.hxx>
+#include <GEOMImpl_IMirror.hxx>
+#include <GEOMImpl_IOffset.hxx>
+#include <GEOMImpl_IScale.hxx>
+#include <GEOMImpl_IRotate.hxx>
+#include <GEOMImpl_IPosition.hxx>
-#include "GEOMImpl_Types.hxx"
+#include <GEOMImpl_Types.hxx>
#include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
class GEOMImpl_ITransformOperations : public GEOM_IOperations {
public:
- GEOMImpl_ITransformOperations(GEOM_Engine* theEngine, int theDocID);
- ~GEOMImpl_ITransformOperations();
+ Standard_EXPORT GEOMImpl_ITransformOperations(GEOM_Engine* theEngine, int theDocID);
+ Standard_EXPORT ~GEOMImpl_ITransformOperations();
- Handle(GEOM_Object) TranslateTwoPoints (Handle(GEOM_Object) theObject,
+ Standard_EXPORT Handle(GEOM_Object) TranslateTwoPoints (Handle(GEOM_Object) theObject,
Handle(GEOM_Object) thePoint1,
Handle(GEOM_Object) thePoint2);
- Handle(GEOM_Object) TranslateTwoPointsCopy (Handle(GEOM_Object) theObject,
+ Standard_EXPORT Handle(GEOM_Object) TranslateTwoPointsCopy (Handle(GEOM_Object) theObject,
Handle(GEOM_Object) thePoint1,
Handle(GEOM_Object) thePoint2);
- Handle(GEOM_Object) TranslateDXDYDZ (Handle(GEOM_Object) theObject, double theX, double theY, double theZ);
+ Standard_EXPORT Handle(GEOM_Object) TranslateDXDYDZ (Handle(GEOM_Object) theObject, double theX, double theY, double theZ);
- Handle(GEOM_Object) TranslateDXDYDZCopy (Handle(GEOM_Object) theObject, double theX, double theY, double theZ);
+ Standard_EXPORT Handle(GEOM_Object) TranslateDXDYDZCopy (Handle(GEOM_Object) theObject, double theX, double theY, double theZ);
- Handle(GEOM_Object) TranslateVector (Handle(GEOM_Object) theObject,
+ Standard_EXPORT Handle(GEOM_Object) TranslateVector (Handle(GEOM_Object) theObject,
Handle(GEOM_Object) theVector);
- Handle(GEOM_Object) TranslateVectorCopy (Handle(GEOM_Object) theObject,
+ Standard_EXPORT Handle(GEOM_Object) TranslateVectorCopy (Handle(GEOM_Object) theObject,
Handle(GEOM_Object) theVector);
- Handle(GEOM_Object) Translate1D (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theVector, double theStep, Standard_Integer theNbTimes);
+ Standard_EXPORT Handle(GEOM_Object) Translate1D (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theVector, double theStep, Standard_Integer theNbTimes);
- Handle(GEOM_Object) Translate2D (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theVector, double theStep1, Standard_Integer theNbTimes1,
+ Standard_EXPORT Handle(GEOM_Object) Translate2D (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theVector, double theStep1, Standard_Integer theNbTimes1,
Handle(GEOM_Object) theVector2, double theStep2, Standard_Integer theNbTimes2);
- Handle(GEOM_Object) MirrorPlane (Handle(GEOM_Object) theObject,
+ Standard_EXPORT Handle(GEOM_Object) MirrorPlane (Handle(GEOM_Object) theObject,
Handle(GEOM_Object) thePlane);
- Handle(GEOM_Object) MirrorPlaneCopy (Handle(GEOM_Object) theObject,
+ Standard_EXPORT Handle(GEOM_Object) MirrorPlaneCopy (Handle(GEOM_Object) theObject,
Handle(GEOM_Object) thePlane);
- Handle(GEOM_Object) MirrorAxis (Handle(GEOM_Object) theObject,
+ Standard_EXPORT Handle(GEOM_Object) MirrorAxis (Handle(GEOM_Object) theObject,
Handle(GEOM_Object) theAxis);
- Handle(GEOM_Object) MirrorAxisCopy (Handle(GEOM_Object) theObject,
+ Standard_EXPORT Handle(GEOM_Object) MirrorAxisCopy (Handle(GEOM_Object) theObject,
Handle(GEOM_Object) theAxis);
- Handle(GEOM_Object) MirrorPoint (Handle(GEOM_Object) theObject,
+ Standard_EXPORT Handle(GEOM_Object) MirrorPoint (Handle(GEOM_Object) theObject,
Handle(GEOM_Object) thePoint);
- Handle(GEOM_Object) MirrorPointCopy (Handle(GEOM_Object) theObject,
+ Standard_EXPORT Handle(GEOM_Object) MirrorPointCopy (Handle(GEOM_Object) theObject,
Handle(GEOM_Object) thePoint);
- Handle(GEOM_Object) OffsetShape (Handle(GEOM_Object) theObject,
+ Standard_EXPORT Handle(GEOM_Object) OffsetShape (Handle(GEOM_Object) theObject,
double theOffset);
- Handle(GEOM_Object) OffsetShapeCopy (Handle(GEOM_Object) theObject,
+ Standard_EXPORT Handle(GEOM_Object) OffsetShapeCopy (Handle(GEOM_Object) theObject,
double theOffset);
- Handle(GEOM_Object) ScaleShape (Handle(GEOM_Object) theObject,
+ Standard_EXPORT Handle(GEOM_Object) ScaleShape (Handle(GEOM_Object) theObject,
Handle(GEOM_Object) thePoint,
double theFactor);
- Handle(GEOM_Object) ScaleShapeCopy (Handle(GEOM_Object) theObject,
+ Standard_EXPORT Handle(GEOM_Object) ScaleShapeCopy (Handle(GEOM_Object) theObject,
Handle(GEOM_Object) thePoint,
double theFactor);
- Handle(GEOM_Object) PositionShape (Handle(GEOM_Object) theObject,
+ Standard_EXPORT Handle(GEOM_Object) PositionShape (Handle(GEOM_Object) theObject,
Handle(GEOM_Object) theStartLCS,
Handle(GEOM_Object) theEndLCS);
- Handle(GEOM_Object) PositionShapeCopy (Handle(GEOM_Object) theObject,
+ Standard_EXPORT Handle(GEOM_Object) PositionShapeCopy (Handle(GEOM_Object) theObject,
Handle(GEOM_Object) theStartLCS,
Handle(GEOM_Object) theEndLCS);
- Handle(GEOM_Object) Rotate (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theAxis, double theAngle);
+ Standard_EXPORT Handle(GEOM_Object) Rotate (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theAxis, double theAngle);
- Handle(GEOM_Object) RotateCopy (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theAxis, double theAngle);
+ Standard_EXPORT Handle(GEOM_Object) RotateCopy (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theAxis, double theAngle);
- Handle(GEOM_Object) Rotate1D (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theAxis, Standard_Integer theNbTimes);
+ Standard_EXPORT Handle(GEOM_Object) Rotate1D (Handle(GEOM_Object) theObject, Handle(GEOM_Object) theAxis, Standard_Integer theNbTimes);
- Handle(GEOM_Object) Rotate2D (Handle(GEOM_Object) theObject,
+ Standard_EXPORT Handle(GEOM_Object) Rotate2D (Handle(GEOM_Object) theObject,
Handle(GEOM_Object) theAxis,
double theAngle,
Standard_Integer theNbTimes1,
-using namespace std;
-#include "GEOMImpl_ImportDriver.hxx"
-#include "GEOMImpl_IImportExport.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_ImportDriver.hxx>
+#include <GEOMImpl_IImportExport.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include "utilities.h"
-using namespace std;
-#include "GEOMImpl_LineDriver.hxx"
-#include "GEOMImpl_ILine.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_LineDriver.hxx>
+#include <GEOMImpl_ILine.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRep_Tool.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx>
-using namespace std;
-#include "GEOMImpl_MarkerDriver.hxx"
-#include "GEOMImpl_IMarker.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_MarkerDriver.hxx>
+#include <GEOMImpl_IMarker.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRepBuilderAPI_MakeFace.hxx>
#include <BRep_Tool.hxx>
-using namespace std;
-#include "GEOMImpl_MeasureDriver.hxx"
-#include "GEOMImpl_IMeasure.hxx"
-#include "GEOMImpl_IMeasureOperations.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_MeasureDriver.hxx>
+#include <GEOMImpl_IMeasure.hxx>
+#include <GEOMImpl_IMeasureOperations.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRep_Tool.hxx>
#include <BRepGProp.hxx>
-using namespace std;
-#include "GEOMImpl_MirrorDriver.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_MirrorDriver.hxx>
#include <GEOMImpl_IMirror.hxx>
#include <GEOMImpl_Types.hxx>
-#include "GEOM_Function.hxx"
+#include <GEOM_Function.hxx>
#include <BRep_Tool.hxx>
#include <BRepBuilderAPI_Transform.hxx>
-using namespace std;
-#include "GEOMImpl_OffsetDriver.hxx"
-#include "GEOMImpl_IOffset.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_OffsetDriver.hxx>
+#include <GEOMImpl_IOffset.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRepOffsetAPI_MakeOffsetShape.hxx>
#include <BRep_Tool.hxx>
-using namespace std;
-#include "GEOMImpl_PartitionDriver.hxx"
-#include "GEOMImpl_IPartition.hxx"
-#include "GEOMImpl_Types.hxx"
+#include <Standard_Stream.hxx>
-#include "GEOM_Object.hxx"
-#include "GEOM_Function.hxx"
+#include <GEOMImpl_PartitionDriver.hxx>
+#include <GEOMImpl_IPartition.hxx>
+#include <GEOMImpl_Types.hxx>
+
+#include <GEOM_Object.hxx>
+#include <GEOM_Function.hxx>
#include <NMTAlgo_Splitter1.hxx>
-using namespace std;
-#include "GEOMImpl_PipeDriver.hxx"
-#include "GEOMImpl_IPipe.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_PipeDriver.hxx>
+#include <GEOMImpl_IPipe.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRep_Tool.hxx>
#include <BRepCheck_Analyzer.hxx>
-using namespace std;
-#include "GEOMImpl_PlaneDriver.hxx"
-#include "GEOMImpl_IPlane.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_PlaneDriver.hxx>
+#include <GEOMImpl_IPlane.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRepBuilderAPI_MakeFace.hxx>
#include <BRep_Tool.hxx>
-using namespace std;
-#include "GEOMImpl_PointDriver.hxx"
-#include "GEOMImpl_IPoint.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_PointDriver.hxx>
+#include <GEOMImpl_IPoint.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRep_Tool.hxx>
#include <BRepBuilderAPI_MakeVertex.hxx>
-using namespace std;
-#include "GEOMImpl_PolylineDriver.hxx"
-#include "GEOMImpl_IPolyline.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_PolylineDriver.hxx>
+#include <GEOMImpl_IPolyline.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRepBuilderAPI_MakePolygon.hxx>
#include <BRep_Tool.hxx>
-using namespace std;
-#include "GEOMImpl_PositionDriver.hxx"
-#include "GEOMImpl_IPosition.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_PositionDriver.hxx>
+#include <GEOMImpl_IPosition.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRepBuilderAPI_Transform.hxx>
#include <BRep_Tool.hxx>
-using namespace std;
-#include "GEOMImpl_PrismDriver.hxx"
-#include "GEOMImpl_IPrism.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_PrismDriver.hxx>
+#include <GEOMImpl_IPrism.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRepPrimAPI_MakePrism.hxx>
#include <BRep_Tool.hxx>
-using namespace std;
-#include "GEOMImpl_RevolutionDriver.hxx"
-#include "GEOMImpl_IRevolution.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_RevolutionDriver.hxx>
+#include <GEOMImpl_IRevolution.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRepPrimAPI_MakeRevol.hxx>
#include <BRep_Tool.hxx>
-using namespace std;
-#include "GEOMImpl_RotateDriver.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_RotateDriver.hxx>
#include <GEOMImpl_IRotate.hxx>
#include <GEOMImpl_Types.hxx>
-#include "GEOM_Function.hxx"
+#include <GEOM_Function.hxx>
#include <gp_Trsf.hxx>
#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
}
Handle(Geom_Line) Line = new Geom_Line(AX1);
- gp_Pnt P2 = GeomAPI_ProjectPointOnCurve( P1, Line ) ;
+ GeomAPI_ProjectPointOnCurve aPrjTool( P1, Line ) ;
+ gp_Pnt P2 = aPrjTool.NearestPoint();
if ( P1.IsEqual(P2, Precision::Confusion() ) ) return 0;
-using namespace std;
-#include "GEOMImpl_ScaleDriver.hxx"
-#include "GEOMImpl_IScale.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_ScaleDriver.hxx>
+#include <GEOMImpl_IScale.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRepBuilderAPI_Transform.hxx>
#include <BRep_Tool.hxx>
-using namespace std;
-#include "GEOMImpl_ShapeDriver.hxx"
-#include "GEOMImpl_IShapes.hxx"
-#include "GEOMImpl_IShapesOperations.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_ShapeDriver.hxx>
+#include <GEOMImpl_IShapes.hxx>
+#include <GEOMImpl_IShapesOperations.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRep_Tool.hxx>
#include <BRep_Builder.hxx>
-using namespace std;
-#include "GEOMImpl_SketcherDriver.hxx"
-#include "GEOMImpl_ISketcher.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_SketcherDriver.hxx>
+#include <GEOMImpl_ISketcher.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRepBuilderAPI_Transform.hxx>
#include <BRep_Tool.hxx>
-using namespace std;
-#include "GEOMImpl_SphereDriver.hxx"
-#include "GEOMImpl_ISphere.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_SphereDriver.hxx>
+#include <GEOMImpl_ISphere.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRepPrimAPI_MakeSphere.hxx>
#include <BRep_Tool.hxx>
-using namespace std;
-#include "GEOMImpl_SplineDriver.hxx"
-#include "GEOMImpl_ISpline.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_SplineDriver.hxx>
+#include <GEOMImpl_ISpline.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx>
#include <BRep_Tool.hxx>
GeomAPI_Interpolate GBC (aHCurvePoints, Standard_False, gp::Resolution());
GBC.Perform();
if (GBC.IsDone())
- aShape = BRepBuilderAPI_MakeEdge(GBC).Edge();
+ aShape = BRepBuilderAPI_MakeEdge(GBC.Curve()).Edge();
else
return 0;
}
-using namespace std;
-#include "GEOMImpl_Template.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_Template.hxx>
+#include <GEOM_Function.hxx>
#include <TopoDS_Shape.hxx>
//=======================================================================
-using namespace std;
-#include "GEOMImpl_TorusDriver.hxx"
-#include "GEOMImpl_ITorus.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_TorusDriver.hxx>
+#include <GEOMImpl_ITorus.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRepPrimAPI_MakeTorus.hxx>
#include <BRep_Tool.hxx>
-using namespace std;
-#include "GEOMImpl_TranslateDriver.hxx"
+#include <Standard_Stream.hxx>
+
+#include <GEOMImpl_TranslateDriver.hxx>
#include <GEOMImpl_ITranslate.hxx>
#include <GEOMImpl_Types.hxx>
-#include "GEOM_Function.hxx"
+#include <GEOM_Function.hxx>
#include <gp_Trsf.hxx>
#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
+#include <Standard_Stream.hxx>
-using namespace std;
-#include "GEOMImpl_VectorDriver.hxx"
-#include "GEOMImpl_IVector.hxx"
-#include "GEOMImpl_Types.hxx"
-#include "GEOM_Function.hxx"
+#include <GEOMImpl_VectorDriver.hxx>
+#include <GEOMImpl_IVector.hxx>
+#include <GEOMImpl_Types.hxx>
+#include <GEOM_Function.hxx>
#include <BRep_Tool.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx>
#include <TCollection_AsciiString.hxx>
#include <TopoDS_Shape.hxx>
+#ifdef WNT
+#include <SALOME_WNT.hxx>
+#else
+#define SALOME_WNT_EXPORT
+#endif
+
//=============================================================================
/*!
*
extern "C"
{
-#ifdef WNT
- __declspec(__dllexport)
-#endif
+SALOME_WNT_EXPORT
int Export(const TopoDS_Shape& theShape, const TCollection_AsciiString& theFileName)
{
MESSAGE("Export IGES into file " << theFileName.ToCString());
#include <TCollection_AsciiString.hxx>
#include <TopoDS_Shape.hxx>
+#ifdef WNT
+#include <SALOME_WNT.hxx>
+#else
+#define SALOME_WNT_EXPORT
+#endif
+
//=============================================================================
/*!
*
extern "C"
{
-#ifdef WNT
- __declspec(__dllexport)
-#endif
+SALOME_WNT_EXPORT
TopoDS_Shape Import (const TCollection_AsciiString& theFileName,
TCollection_AsciiString& theError)
{
aDEP.Do();
//
}
- catch (BOPTColStd_Failure& x) {
+ catch (BOPTColStd_Failure& /*x*/) {
//QQ MESSAGE(x.Message() << flush);
}
}
// Module : GEOM
// $Header$
-using namespace std;
/*!
\class GEOM_AISShape GEOM_AISShape.hxx
\brief ....
#include <TopoDS_Shape.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
+using namespace std;
+
static void getEntityOwners( const Handle(AIS_InteractiveObject)& theObj,
const Handle(AIS_InteractiveContext)& theIC,
SelectMgr_IndexedMapOfOwner& theMap )
// Mapper creating function
//-------------------------------------------------------------
void GEOM_Actor::CreateMapper(int theMode) {
- this->myIsInfinite = myShape.Infinite();
+ this->myIsInfinite = (bool)myShape.Infinite();
if(myShape.ShapeType() == TopAbs_VERTEX) {
gp_Pnt aPnt = BRep_Tool::Pnt(TopoDS::Vertex(myShape));
this->SetPosition(aPnt.X(),aPnt.Y(),aPnt.Z());
class vtkCamera;
class TopoDS_Shape;
-#ifdef _WIN_32
-#define VTKOCC_EXPORT __declspec (dllexport)
+#ifdef WNT
+#include <SALOME_WNT.hxx>
#else
-#define VTKOCC_EXPORT
+#define SALOME_WNT_EXPORT
#endif
-class VTKOCC_EXPORT GEOM_Actor : public SALOME_Actor {
+class SALOME_WNT_EXPORT GEOM_Actor : public SALOME_Actor {
public:
vtkTypeMacro(GEOM_Actor,SALOME_Actor);
// Module : GEOM
// $Header$
-using namespace std;
/*!
\class GEOM_AssemblyBuilder GEOM_AssemblyBuilder.h
\brief ....
#include <TopTools_ListOfShape.hxx>
#include <TopoDS_Iterator.hxx>
+using namespace std;
// SALOME
#define MAX2(X, Y) ( Abs(X) > Abs(Y)? Abs(X) : Abs(Y) )
#include <TopoDS.hxx>
#include <TopoDS_Shape.hxx>
-class GEOM_AssemblyBuilder {
+#ifdef WNT
+#include <SALOME_WNT.hxx>
+#else
+#define SALOME_WNT_EXPORT
+#endif
+
+class SALOME_WNT_EXPORT GEOM_AssemblyBuilder {
private:
// Module : GEOM
// $Header$
-using namespace std;
/*!
\class GEOM_InteractiveObject GEOM_InteractiveObject.hxx
\brief ....
#include "GEOM_InteractiveObject.ixx"
+using namespace std;
+
GEOM_InteractiveObject::GEOM_InteractiveObject()
: SALOME_InteractiveObject()
{
#include "SALOME_Actor.h"
#include "VTKViewer_Trihedron.h"
+#ifdef WNT
+#include <SALOME_WNT.hxx>
+#else
+#define SALOME_WNT_EXPORT
+#endif
+
+
class vtkActorCollection;
class vtkRenderer;
class vtkPolyDataMapper;
Placement of trihedron is chahged with SetPlacement() method
*/
-class GEOM_VTKTrihedron : public SALOME_Actor
+class SALOME_WNT_EXPORT GEOM_VTKTrihedron : public SALOME_Actor
{
protected:
// Module : GEOM
// $Header:
-using namespace std;
-#include "Sketcher_Profile.hxx"
+#include <Standard_Stream.hxx>
+
+#include <Sketcher_Profile.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Face.hxx>
TCollection_AsciiString aCommand(CORBA::string_dup(aCmd));
TCollection_AsciiString aToken = aCommand.Token(":", 1);
int n = 0;
- TCollection_AsciiString aTab[aCommand.Length()];
- while(aToken.Length() != 0) {
- if(aCommand.Token(":", n + 1).Length() > 0)
- aTab[n] = aCommand.Token(":", n + 1);
- aToken = aCommand.Token(":", ++n);
- }
- n = n - 1;
-
- while(i < n) {
- Standard_Real length = 0, radius = 0, angle = 0;
- move = point;
-
- int n1 = 0;
- TCollection_AsciiString a[aTab[0].Length()];
- aToken = aTab[i].Token(" ", 1);
+ // porting to WNT
+ TCollection_AsciiString* aTab = 0;
+ if ( aCommand.Length() )
+ {
+ aTab = new TCollection_AsciiString[ aCommand.Length() ];
while(aToken.Length() != 0) {
- if(aTab[i].Token(" ", n1 + 1).Length() > 0)
- a[n1] = aTab[i].Token(" ", n1 + 1);
- aToken = aTab[i].Token(" ", ++n1);
+ if(aCommand.Token(":", n + 1).Length() > 0)
+ aTab[n] = aCommand.Token(":", n + 1);
+ aToken = aCommand.Token(":", ++n);
}
- n1 = n1 - 1;
-
- switch(a[0].Value(1))
- {
- case 'F':
- {
- if (n1 != 3) goto badargs;
- if (!first) {
- MESSAGE("profile : The F instruction must precede all moves");
- return;
- }
- x0 = x = a[1].RealValue();
- y0 = y = a[2].RealValue();
- stayfirst = Standard_True;
- break;
- }
- case 'O':
- {
- if (n1 != 4) goto badargs;
- P.SetLocation(gp_Pnt(a[1].RealValue(), a[2].RealValue(), a[3].RealValue()));
- stayfirst = Standard_True;
- break;
- }
- case 'P':
- {
- if (n1 != 7) goto badargs;
- gp_Vec vn(a[1].RealValue(), a[2].RealValue(), a[3].RealValue());
- gp_Vec vx(a[4].RealValue(), a[5].RealValue(), a[6].RealValue());
- if (vn.Magnitude() <= Precision::Confusion() || vx.Magnitude() <= Precision::Confusion()) {
- MESSAGE("profile : null direction");
- return;
- }
- gp_Ax2 ax(P.Location(), vn, vx);
- P.SetPosition(ax);
- stayfirst = Standard_True;
- break;
- }
- case 'X':
- {
- if (n1 != 2) goto badargs;
- length = a[1].RealValue();
- if (a[0] == "XX")
- length -= x;
- dx = 1; dy = 0;
- move = line;
- break;
- }
- case 'Y':
- {
- if (n1 != 2) goto badargs;
- length = a[1].RealValue();
- if (a[0] == "YY")
- length -= y;
- dx = 0; dy = 1;
- move = line;
- break;
- }
- case 'L':
- {
- if (n1 != 2) goto badargs;
- length = a[1].RealValue();
- if (Abs(length) > Precision::Confusion())
- move = line;
- else
- move = none;
- break;
- }
- case 'T':
- {
- if (n1 != 3) goto badargs;
- Standard_Real vx = a[1].RealValue();
- Standard_Real vy = a[2].RealValue();
- if (a[0] == "TT") {
- vx -= x;
- vy -= y;
- }
- length = Sqrt(vx * vx + vy * vy);
- if (length > Precision::Confusion()) {
- move = line;
- dx = vx / length;
- dy = vy / length;
- }
- else
- move = none;
- break;
- }
- case 'R':
- {
- if (n1 != 2) goto badargs;
- angle = a[1].RealValue() * PI180;
- if (a[0] == "RR") {
- dx = Cos(angle);
- dy = Sin(angle);
- }
- else {
- Standard_Real c = Cos(angle);
- Standard_Real s = Sin(angle);
- Standard_Real t = c * dx - s * dy;
- dy = s * dx + c * dy;
- dx = t;
- }
- break;
- }
- case 'D':
- {
- if (n1 != 3) goto badargs;
- Standard_Real vx = a[1].RealValue();
- Standard_Real vy = a[2].RealValue();
- length = Sqrt(vx * vx + vy * vy);
- if (length > Precision::Confusion()) {
- dx = vx / length;
- dy = vy / length;
- }
- else
- move = none;
- break;
- }
- case 'C':
- {
- if (n1 != 3) goto badargs;
- radius = a[1].RealValue();
- if (Abs(radius) > Precision::Confusion()) {
- angle = a[2].RealValue() * PI180;
- move = circle;
- }
- else
- move = none;
- break;
- }
- case 'I':
- {
- if (n1 != 2) goto badargs;
- length = a[1].RealValue();
- if (a[0] == "IX") {
- if (Abs(dx) < Precision::Confusion()) {
- MESSAGE("profile : cannot intersect, arg "<<i-1);
- return;
- }
- length = (length - x) / dx;
- }
- else if (a[0] == "IY") {
- if (Abs(dy) < Precision::Confusion()) {
- MESSAGE("profile : cannot intersect, arg "<<i-1);
- return;
- }
- length = (length - y) / dy;
- }
- if (Abs(length) > Precision::Confusion())
- move = line;
- else
- move = none;
- break;
- }
- case 'W':
- {
- if (a[0] == "WW")
- close = Standard_True;
- else if(a[0] == "WF") {
- close = Standard_True;
- face = Standard_True;
- }
- i = n - 1;
- break;
+ n = n - 1;
+ }
+ if ( aTab && aTab[0].Length() )
+ while(i < n) {
+ Standard_Real length = 0, radius = 0, angle = 0;
+ move = point;
+
+ int n1 = 0;
+ TCollection_AsciiString* a = new TCollection_AsciiString[ aTab[0].Length() ];
+ aToken = aTab[i].Token(" ", 1);
+ while(aToken.Length() != 0) {
+ if(aTab[i].Token(" ", n1 + 1).Length() > 0)
+ a[n1] = aTab[i].Token(" ", n1 + 1);
+ aToken = aTab[i].Token(" ", ++n1);
}
- default:
+ n1 = n1 - 1;
+
+ switch(a[0].Value(1))
{
- MESSAGE("profile : unknown code "<<a[i]);
- return;
- }
+ case 'F':
+ {
+ if (n1 != 3) goto badargs;
+ if (!first) {
+ MESSAGE("profile : The F instruction must precede all moves");
+ return;
+ }
+ x0 = x = a[1].RealValue();
+ y0 = y = a[2].RealValue();
+ stayfirst = Standard_True;
+ break;
+ }
+ case 'O':
+ {
+ if (n1 != 4) goto badargs;
+ P.SetLocation(gp_Pnt(a[1].RealValue(), a[2].RealValue(), a[3].RealValue()));
+ stayfirst = Standard_True;
+ break;
+ }
+ case 'P':
+ {
+ if (n1 != 7) goto badargs;
+ gp_Vec vn(a[1].RealValue(), a[2].RealValue(), a[3].RealValue());
+ gp_Vec vx(a[4].RealValue(), a[5].RealValue(), a[6].RealValue());
+ if (vn.Magnitude() <= Precision::Confusion() || vx.Magnitude() <= Precision::Confusion()) {
+ MESSAGE("profile : null direction");
+ return;
+ }
+ gp_Ax2 ax(P.Location(), vn, vx);
+ P.SetPosition(ax);
+ stayfirst = Standard_True;
+ break;
+ }
+ case 'X':
+ {
+ if (n1 != 2) goto badargs;
+ length = a[1].RealValue();
+ if (a[0] == "XX")
+ length -= x;
+ dx = 1; dy = 0;
+ move = line;
+ break;
+ }
+ case 'Y':
+ {
+ if (n1 != 2) goto badargs;
+ length = a[1].RealValue();
+ if (a[0] == "YY")
+ length -= y;
+ dx = 0; dy = 1;
+ move = line;
+ break;
+ }
+ case 'L':
+ {
+ if (n1 != 2) goto badargs;
+ length = a[1].RealValue();
+ if (Abs(length) > Precision::Confusion())
+ move = line;
+ else
+ move = none;
+ break;
+ }
+ case 'T':
+ {
+ if (n1 != 3) goto badargs;
+ Standard_Real vx = a[1].RealValue();
+ Standard_Real vy = a[2].RealValue();
+ if (a[0] == "TT") {
+ vx -= x;
+ vy -= y;
+ }
+ length = Sqrt(vx * vx + vy * vy);
+ if (length > Precision::Confusion()) {
+ move = line;
+ dx = vx / length;
+ dy = vy / length;
+ }
+ else
+ move = none;
+ break;
+ }
+ case 'R':
+ {
+ if (n1 != 2) goto badargs;
+ angle = a[1].RealValue() * PI180;
+ if (a[0] == "RR") {
+ dx = Cos(angle);
+ dy = Sin(angle);
+ }
+ else {
+ Standard_Real c = Cos(angle);
+ Standard_Real s = Sin(angle);
+ Standard_Real t = c * dx - s * dy;
+ dy = s * dx + c * dy;
+ dx = t;
+ }
+ break;
+ }
+ case 'D':
+ {
+ if (n1 != 3) goto badargs;
+ Standard_Real vx = a[1].RealValue();
+ Standard_Real vy = a[2].RealValue();
+ length = Sqrt(vx * vx + vy * vy);
+ if (length > Precision::Confusion()) {
+ dx = vx / length;
+ dy = vy / length;
+ }
+ else
+ move = none;
+ break;
+ }
+ case 'C':
+ {
+ if (n1 != 3) goto badargs;
+ radius = a[1].RealValue();
+ if (Abs(radius) > Precision::Confusion()) {
+ angle = a[2].RealValue() * PI180;
+ move = circle;
+ }
+ else
+ move = none;
+ break;
+ }
+ case 'I':
+ {
+ if (n1 != 2) goto badargs;
+ length = a[1].RealValue();
+ if (a[0] == "IX") {
+ if (Abs(dx) < Precision::Confusion()) {
+ MESSAGE("profile : cannot intersect, arg "<<i-1);
+ return;
+ }
+ length = (length - x) / dx;
+ }
+ else if (a[0] == "IY") {
+ if (Abs(dy) < Precision::Confusion()) {
+ MESSAGE("profile : cannot intersect, arg "<<i-1);
+ return;
+ }
+ length = (length - y) / dy;
+ }
+ if (Abs(length) > Precision::Confusion())
+ move = line;
+ else
+ move = none;
+ break;
+ }
+ case 'W':
+ {
+ if (a[0] == "WW")
+ close = Standard_True;
+ else if(a[0] == "WF") {
+ close = Standard_True;
+ face = Standard_True;
+ }
+ i = n - 1;
+ break;
+ }
+ default:
+ {
+ MESSAGE("profile : unknown code "<<a[i]);
+ return;
+ }
}
- again :
+again :
switch (move)
{
case line :
{
- if (length < 0) {
- length = -length;
- dx = -dx;
- dy = -dy;
- }
- Handle(Geom2d_Line) l = new Geom2d_Line(gp_Pnt2d(x,y),gp_Dir2d(dx,dy));
+ if (length < 0) {
+ length = -length;
+ dx = -dx;
+ dy = -dy;
+ }
+ Handle(Geom2d_Line) l = new Geom2d_Line(gp_Pnt2d(x,y),gp_Dir2d(dx,dy));
BRepBuilderAPI_MakeEdge ME (GeomAPI::To3d(l,P),0,length);
if (!ME.IsDone())
return;
- MW.Add(ME);
- x += length*dx;
- y += length*dy;
- break;
+ MW.Add(ME);
+ x += length*dx;
+ y += length*dy;
+ break;
}
case circle :
{
- Standard_Boolean sense = Standard_True;
- if (radius < 0) {
- radius = -radius;
- sense = !sense;
- dx = -dx;
- dy = -dy;
- }
- gp_Ax2d ax(gp_Pnt2d(x-radius*dy,y+radius*dx),gp_Dir2d(dy,-dx));
- if (angle < 0) {
- angle = -angle;
- sense = !sense;
- }
- Handle(Geom2d_Circle) c = new Geom2d_Circle(ax,radius,sense);
+ Standard_Boolean sense = Standard_True;
+ if (radius < 0) {
+ radius = -radius;
+ sense = !sense;
+ dx = -dx;
+ dy = -dy;
+ }
+ gp_Ax2d ax(gp_Pnt2d(x-radius*dy,y+radius*dx),gp_Dir2d(dy,-dx));
+ if (angle < 0) {
+ angle = -angle;
+ sense = !sense;
+ }
+ Handle(Geom2d_Circle) c = new Geom2d_Circle(ax,radius,sense);
BRepBuilderAPI_MakeEdge ME (GeomAPI::To3d(c,P),0,angle);
if (!ME.IsDone())
return;
- MW.Add(ME);
- gp_Pnt2d p;
- gp_Vec2d v;
- c->D1(angle,p,v);
- x = p.X();
- y = p.Y();
- dx = v.X() / radius;
- dy = v.Y() / radius;
- break;
+ MW.Add(ME);
+ gp_Pnt2d p;
+ gp_Vec2d v;
+ c->D1(angle,p,v);
+ x = p.X();
+ y = p.Y();
+ dx = v.X() / radius;
+ dy = v.Y() / radius;
+ break;
}
case point:
{
- MP = BRepBuilderAPI_MakeVertex(gp_Pnt(x, y, 0.0));
- break;
+ MP = BRepBuilderAPI_MakeVertex(gp_Pnt(x, y, 0.0));
+ break;
}
case none:
{
- i = n - 1;
- break;
+ i = n - 1;
+ break;
}
}
-
+
// update first
first = stayfirst;
stayfirst = Standard_False;
-
+
if(!(dx == 0 && dy == 0))
myLastDir.SetCoord(dx, dy, 0.0);
else
return;
myLastPoint.SetX(x);
myLastPoint.SetY(y);
-
+
// next segment....
i++;
if ((i == n) && close) {
length = Sqrt(dx * dx + dy * dy);
move = line;
if (length > Precision::Confusion()) {
- dx = dx / length;
- dy = dy / length;
- goto again;
+ dx = dx / length;
+ dy = dy / length;
+ goto again;
}
}
+ delete a;
}
-
+ delete aTab;
+ aTab = 0;
+
// get the result, face or wire
if (move == none) {
return;
{
public:
- Sketcher_Profile();
- Sketcher_Profile(const char* aCmd);
+ Standard_EXPORT Sketcher_Profile();
+ Standard_EXPORT Sketcher_Profile(const char* aCmd);
private:
gp_Pnt myLastPoint;
bool myOK;
public:
- gp_Pnt GetLastPoint(){return myLastPoint;};
- gp_Dir GetLastDir(){return myLastDir;};
+ Standard_EXPORT gp_Pnt GetLastPoint(){return myLastPoint;};
+ Standard_EXPORT gp_Dir GetLastDir(){return myLastDir;};
- const TopoDS_Shape& GetShape(){return myShape;};
- bool IsDone(){return myOK;};
+ Standard_EXPORT const TopoDS_Shape& GetShape(){return myShape;};
+ Standard_EXPORT bool IsDone(){return myOK;};
};
#include <TCollection_AsciiString.hxx>
#include <TopoDS_Shape.hxx>
+#ifdef WNT
+#include <SALOME_WNT.hxx>
+#else
+#define SALOME_WNT_EXPORT
+#endif
+
//=============================================================================
/*!
*
extern "C"
{
-#ifdef WNT
- __declspec(__dllexport)
-#endif
+SALOME_WNT_EXPORT
int Export(const TopoDS_Shape& theShape, const TCollection_AsciiString& theFileName)
{
MESSAGE("Export STEP into file " << theFileName.ToCString());
#include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
+#ifdef WNT
+#include <SALOME_WNT.hxx>
+#else
+#define SALOME_WNT_EXPORT
+#endif
+
//=============================================================================
/*!
* Import()
extern "C"
{
-#ifdef WNT
- __declspec(__dllexport)
-#endif
+SALOME_WNT_EXPORT
TopoDS_Shape Import (const TCollection_AsciiString& theFileName,
TCollection_AsciiString& theError)
{
