ForkMaster/geom
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/geom.git synced 2025-01-27 13:10:34 +05:00
Code Issues Packages Projects Releases Wiki Activity

ENV: Windows porting.

Browse Source
This commit is contained in:
env 2005-08-11 04:43:57 +00:00
parent f931ebe5b6
commit e2dcf4323c
80 changed files with 981 additions and 884 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/GEOMImpl/GEOMImpl_ArcDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_ArcDriver.hxx"
#include "GEOMImpl_IArc.hxx" #include <GEOMImpl_ArcDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_IArc.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx> #include <BRepBuilderAPI_MakeEdge.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>

16
src/GEOMImpl/GEOMImpl_Block6Explorer.cxx
View File

@ -1,8 +1,8 @@
using namespace std; #include <Standard_Stream.hxx>
#include <BRepOffsetAPI_MakeFilling.hxx> #include <BRepOffsetAPI_MakeFilling.hxx>
#include "GEOMImpl_Block6Explorer.hxx" #include <GEOMImpl_Block6Explorer.hxx>
#include "utilities.h" #include "utilities.h"
@ -720,7 +720,8 @@ void GEOMImpl_Block6Explorer::InitByBlockAndVertices (const TopoDS_Shape& theBlo
TopTools_IndexedMapOfShape aFaceEdges; TopTools_IndexedMapOfShape aFaceEdges;
TopExp::MapShapes(myFaces(1), TopAbs_EDGE, 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 // Get i-th vertex of the face 1
TopoDS_Shape Vi = myVertices(vertex_id(1, i)); TopoDS_Shape Vi = myVertices(vertex_id(1, i));
if (!MB.Contains(Vi)) { if (!MB.Contains(Vi)) {
@ -757,7 +758,7 @@ void GEOMImpl_Block6Explorer::InitByBlockAndVertices (const TopoDS_Shape& theBlo
} }
// 3. Store edges of the second (opposite to the first) face // 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 // Get i-th and (i+1)-th vertices of the face 2
TopoDS_Shape Vi = myVertices(vertex_id(2, i)); TopoDS_Shape Vi = myVertices(vertex_id(2, i));
TopoDS_Shape Vj = myVertices(vertex_id(2, mod4(i + 1))); TopoDS_Shape Vj = myVertices(vertex_id(2, mod4(i + 1)));
@ -792,7 +793,7 @@ void GEOMImpl_Block6Explorer::InitByBlockAndVertices (const TopoDS_Shape& theBlo
Standard_TypeMismatch::Raise("Block has wrong number of edges"); 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 Ei1 = myEdges(edge_id(i, 1));
TopoDS_Shape Ei2 = myEdges(edge_id(i, 2)); TopoDS_Shape Ei2 = myEdges(edge_id(i, 2));
const TopTools_ListOfShape& aFacesOfEi1 = MBE.FindFromKey(Ei1); const TopTools_ListOfShape& aFacesOfEi1 = MBE.FindFromKey(Ei1);
@ -915,7 +916,8 @@ void GEOMImpl_Block6Explorer::InitByTwoFaces (const TopoDS_Shape& theFace1,
Standard_Real Dist_min = RealLast(); Standard_Real Dist_min = RealLast();
// try all possible locations to find the best (with minimum sum distance) // 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 // try direct orientation
Standard_Real Dist_plus = aPnts1(1).Distance(aPnts2(i)) + Standard_Real Dist_plus = aPnts1(1).Distance(aPnts2(i)) +
aPnts1(2).Distance(aPnts2(mod4(i + 1))) + aPnts1(2).Distance(aPnts2(mod4(i + 1))) +
@ -941,7 +943,7 @@ void GEOMImpl_Block6Explorer::InitByTwoFaces (const TopoDS_Shape& theFace1,
// 3. Put vertices and edges of the second face to they // 3. Put vertices and edges of the second face to they
// permanent location in <myVertices> and <myEdges> // 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)); Standard_Integer nb = mod4(i_min + s_min*(i - 1));
if (aPnts1(i).Distance(aPnts2(nb)) < Precision::Confusion()) { if (aPnts1(i).Distance(aPnts2(nb)) < Precision::Confusion()) {

26
src/GEOMImpl/GEOMImpl_BlockDriver.cxx
View File

@ -1,22 +1,22 @@
using namespace std; #include <Standard_Stream.hxx>
#include <BRepOffsetAPI_MakeFilling.hxx> #include <BRepOffsetAPI_MakeFilling.hxx>
#include "GEOMImpl_BlockDriver.hxx" #include <GEOMImpl_BlockDriver.hxx>
#include "GEOMImpl_IBlocks.hxx" #include <GEOMImpl_IBlocks.hxx>
#include "GEOMImpl_IBlockTrsf.hxx" #include <GEOMImpl_IBlockTrsf.hxx>
#include "GEOMImpl_GlueDriver.hxx" #include <GEOMImpl_GlueDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_Types.hxx>
#include "GEOMImpl_ILocalOperations.hxx" #include <GEOMImpl_ILocalOperations.hxx>
#include "GEOMImpl_Block6Explorer.hxx" #include <GEOMImpl_Block6Explorer.hxx>
#include "GEOMImpl_IBlocksOperations.hxx" #include <GEOMImpl_IBlocksOperations.hxx>
#include "GEOM_Function.hxx" #include <GEOM_Function.hxx>
#include "ShHealOper_Sewing.hxx" #include <ShHealOper_Sewing.hxx>
#include "NMTAlgo_Splitter1.hxx" #include <NMTAlgo_Splitter1.hxx>
#include "BlockFix_BlockFixAPI.hxx" #include <BlockFix_BlockFixAPI.hxx>
#include "utilities.h" #include "utilities.h"

11
src/GEOMImpl/GEOMImpl_BooleanDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_BooleanDriver.hxx"
#include "GEOMImpl_IBoolean.hxx" #include <GEOMImpl_BooleanDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_IBoolean.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRepAlgo.hxx> #include <BRepAlgo.hxx>
#include <BRepAlgoAPI_Common.hxx> #include <BRepAlgoAPI_Common.hxx>

11
src/GEOMImpl/GEOMImpl_BoxDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_BoxDriver.hxx"
#include "GEOMImpl_IBox.hxx" #include <GEOMImpl_BoxDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_IBox.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRepPrimAPI_MakeBox.hxx> #include <BRepPrimAPI_MakeBox.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>

15
src/GEOMImpl/GEOMImpl_ChamferDriver.cxx
View File

@ -1,11 +1,12 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_ChamferDriver.hxx"
#include "GEOMImpl_IChamfer.hxx" #include <GEOMImpl_ChamferDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_IChamfer.hxx>
#include "GEOMImpl_ILocalOperations.hxx" #include <GEOMImpl_Types.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_ILocalOperations.hxx>
#include "GEOMImpl_Block6Explorer.hxx" #include <GEOM_Function.hxx>
#include <GEOMImpl_Block6Explorer.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>
#include <BRepTools.hxx> #include <BRepTools.hxx>

11
src/GEOMImpl/GEOMImpl_CircleDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_CircleDriver.hxx"
#include "GEOMImpl_ICircle.hxx" #include <GEOMImpl_CircleDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_ICircle.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx> #include <BRepBuilderAPI_MakeEdge.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>

11
src/GEOMImpl/GEOMImpl_ConeDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_ConeDriver.hxx"
#include "GEOMImpl_ICone.hxx" #include <GEOMImpl_ConeDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_ICone.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRepPrimAPI_MakeCone.hxx> #include <BRepPrimAPI_MakeCone.hxx>
#include <BRepPrimAPI_MakeCylinder.hxx> #include <BRepPrimAPI_MakeCylinder.hxx>

11
src/GEOMImpl/GEOMImpl_CopyDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_CopyDriver.hxx"
#include "GEOMImpl_ICopy.hxx" #include <GEOMImpl_CopyDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_ICopy.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>
#include <gp_Pnt.hxx> #include <gp_Pnt.hxx>

11
src/GEOMImpl/GEOMImpl_CylinderDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_CylinderDriver.hxx"
#include "GEOMImpl_ICylinder.hxx" #include <GEOMImpl_CylinderDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_ICylinder.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRepPrimAPI_MakeCylinder.hxx> #include <BRepPrimAPI_MakeCylinder.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>

11
src/GEOMImpl/GEOMImpl_EllipseDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_EllipseDriver.hxx"
#include "GEOMImpl_IEllipse.hxx" #include <GEOMImpl_EllipseDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_IEllipse.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx> #include <BRepBuilderAPI_MakeEdge.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>

11
src/GEOMImpl/GEOMImpl_ExportDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_ExportDriver.hxx"
#include "GEOMImpl_IImportExport.hxx" #include <GEOMImpl_ExportDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_IImportExport.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <TopoDS_Shape.hxx> #include <TopoDS_Shape.hxx>
#include <TCollection_AsciiString.hxx> #include <TCollection_AsciiString.hxx>

13
src/GEOMImpl/GEOMImpl_FilletDriver.cxx
View File

@ -1,10 +1,11 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_FilletDriver.hxx"
#include "GEOMImpl_IFillet.hxx" #include <GEOMImpl_FilletDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_IFillet.hxx>
#include "GEOMImpl_ILocalOperations.hxx" #include <GEOMImpl_Types.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_ILocalOperations.hxx>
#include <GEOM_Function.hxx>
#include <BRepFilletAPI_MakeFillet.hxx> #include <BRepFilletAPI_MakeFillet.hxx>
#include <BRepCheck_Analyzer.hxx> #include <BRepCheck_Analyzer.hxx>

10
src/GEOMImpl/GEOMImpl_FillingDriver.cxx
View File

@ -1,10 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_FillingDriver.hxx" #include <GEOMImpl_FillingDriver.hxx>
#include "GEOM_Function.hxx" #include <GEOM_Function.hxx>
#include "GEOMImpl_IFilling.hxx" #include <GEOMImpl_IFilling.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_Types.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>
#include <BRepAlgo.hxx> #include <BRepAlgo.hxx>

90
src/GEOMImpl/GEOMImpl_Gen.cxx
View File

@ -1,53 +1,57 @@
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 "utilities.h"
#include "OpUtil.hxx" #include <OpUtil.hxx>
#include "Utils_ExceptHandlers.hxx" #include <Utils_ExceptHandlers.hxx>
#include <TFunction_Driver.hxx> #include <TFunction_Driver.hxx>
#include <TFunction_DriverTable.hxx> #include <TFunction_DriverTable.hxx>
#include "GEOMImpl_PointDriver.hxx" #include <GEOMImpl_PointDriver.hxx>
#include "GEOMImpl_VectorDriver.hxx" #include <GEOMImpl_VectorDriver.hxx>
#include "GEOMImpl_LineDriver.hxx" #include <GEOMImpl_LineDriver.hxx>
#include "GEOMImpl_PlaneDriver.hxx" #include <GEOMImpl_PlaneDriver.hxx>
#include "GEOMImpl_MarkerDriver.hxx" #include <GEOMImpl_MarkerDriver.hxx>
#include "GEOMImpl_ArcDriver.hxx" #include <GEOMImpl_ArcDriver.hxx>
#include "GEOMImpl_CircleDriver.hxx" #include <GEOMImpl_CircleDriver.hxx>
#include "GEOMImpl_EllipseDriver.hxx" #include <GEOMImpl_EllipseDriver.hxx>
#include "GEOMImpl_PolylineDriver.hxx" #include <GEOMImpl_PolylineDriver.hxx>
#include "GEOMImpl_SplineDriver.hxx" #include <GEOMImpl_SplineDriver.hxx>
#include "GEOMImpl_SketcherDriver.hxx" #include <GEOMImpl_SketcherDriver.hxx>
#include "GEOMImpl_BoxDriver.hxx" #include <GEOMImpl_BoxDriver.hxx>
#include "GEOMImpl_ConeDriver.hxx" #include <GEOMImpl_ConeDriver.hxx>
#include "GEOMImpl_CylinderDriver.hxx" #include <GEOMImpl_CylinderDriver.hxx>
#include "GEOMImpl_PrismDriver.hxx" #include <GEOMImpl_PrismDriver.hxx>
#include "GEOMImpl_PipeDriver.hxx" #include <GEOMImpl_PipeDriver.hxx>
#include "GEOMImpl_RevolutionDriver.hxx" #include <GEOMImpl_RevolutionDriver.hxx>
#include "GEOMImpl_ShapeDriver.hxx" #include <GEOMImpl_ShapeDriver.hxx>
#include "GEOMImpl_BlockDriver.hxx" #include <GEOMImpl_BlockDriver.hxx>
#include "GEOMImpl_SphereDriver.hxx" #include <GEOMImpl_SphereDriver.hxx>
#include "GEOMImpl_TorusDriver.hxx" #include <GEOMImpl_TorusDriver.hxx>
#include "GEOMImpl_BooleanDriver.hxx" #include <GEOMImpl_BooleanDriver.hxx>
#include "GEOMImpl_ChamferDriver.hxx" #include <GEOMImpl_ChamferDriver.hxx>
#include "GEOMImpl_FilletDriver.hxx" #include <GEOMImpl_FilletDriver.hxx>
#include "GEOMImpl_TranslateDriver.hxx" #include <GEOMImpl_TranslateDriver.hxx>
#include "GEOMImpl_RotateDriver.hxx" #include <GEOMImpl_RotateDriver.hxx>
#include "GEOMImpl_MirrorDriver.hxx" #include <GEOMImpl_MirrorDriver.hxx>
#include "GEOMImpl_OffsetDriver.hxx" #include <GEOMImpl_OffsetDriver.hxx>
#include "GEOMImpl_ScaleDriver.hxx" #include <GEOMImpl_ScaleDriver.hxx>
#include "GEOMImpl_PositionDriver.hxx" #include <GEOMImpl_PositionDriver.hxx>
#include "GEOMImpl_PartitionDriver.hxx" #include <GEOMImpl_PartitionDriver.hxx>
#include "GEOMImpl_CopyDriver.hxx" #include <GEOMImpl_CopyDriver.hxx>
#include "GEOMImpl_ExportDriver.hxx" #include <GEOMImpl_ExportDriver.hxx>
#include "GEOMImpl_ImportDriver.hxx" #include <GEOMImpl_ImportDriver.hxx>
#include "GEOMImpl_ArchimedeDriver.hxx" #include <GEOMImpl_ArchimedeDriver.hxx>
#include "GEOMImpl_HealingDriver.hxx" #include <GEOMImpl_HealingDriver.hxx>
#include "GEOMImpl_FillingDriver.hxx" #include <GEOMImpl_FillingDriver.hxx>
#include "GEOMImpl_GlueDriver.hxx" #include <GEOMImpl_GlueDriver.hxx>
#include "GEOMImpl_MeasureDriver.hxx" #include <GEOMImpl_MeasureDriver.hxx>
//============================================================================= //=============================================================================
/*! /*!

8
src/GEOMImpl/GEOMImpl_Gen.hxx
View File

@ -18,7 +18,13 @@
#include "GEOMImpl_IGroupOperations.hxx" #include "GEOMImpl_IGroupOperations.hxx"
#include "GEOM_Engine.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: public:
GEOMImpl_Gen(); GEOMImpl_Gen();

15
src/GEOMImpl/GEOMImpl_GlueDriver.cxx
View File

@ -1,13 +1,14 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_GlueDriver.hxx"
#include "GEOMImpl_IGlue.hxx"
#include "GEOMImpl_Types.hxx"
#include "GEOM_Object.hxx" #include <GEOMImpl_GlueDriver.hxx>
#include "GEOM_Function.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" #include "utilities.h"

25
src/GEOMImpl/GEOMImpl_HealingDriver.cxx
View File

@ -1,17 +1,18 @@
using namespace std; #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 <GEOMImpl_HealingDriver.hxx>
#include "ShHealOper_RemoveFace.hxx" #include <GEOMImpl_Types.hxx>
#include "ShHealOper_CloseContour.hxx" #include <GEOMImpl_IHealing.hxx>
#include "ShHealOper_RemoveInternalWires.hxx" #include <GEOM_Function.hxx>
#include "ShHealOper_FillHoles.hxx"
#include "ShHealOper_Sewing.hxx" #include <ShHealOper_ShapeProcess.hxx>
#include "ShHealOper_EdgeDivide.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 <TopoDS.hxx>
#include <TopExp.hxx> #include <TopExp.hxx>

54
src/GEOMImpl/GEOMImpl_I3DPrimOperations.cxx
View File

@ -1,42 +1,42 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_I3DPrimOperations.hxx" #include <GEOMImpl_I3DPrimOperations.hxx>
#include "utilities.h" #include "utilities.h"
#include "OpUtil.hxx" #include <OpUtil.hxx>
#include "Utils_ExceptHandlers.hxx" #include <Utils_ExceptHandlers.hxx>
#include <TFunction_DriverTable.hxx> #include <TFunction_DriverTable.hxx>
#include <TFunction_Driver.hxx> #include <TFunction_Driver.hxx>
#include <TFunction_Logbook.hxx> #include <TFunction_Logbook.hxx>
#include <TDF_Tool.hxx> #include <TDF_Tool.hxx>
#include "GEOM_Function.hxx" #include <GEOM_Function.hxx>
#include "GEOM_PythonDump.hxx" #include <GEOM_PythonDump.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_Types.hxx>
#include "GEOMImpl_BoxDriver.hxx" #include <GEOMImpl_BoxDriver.hxx>
#include "GEOMImpl_CylinderDriver.hxx" #include <GEOMImpl_CylinderDriver.hxx>
#include "GEOMImpl_ConeDriver.hxx" #include <GEOMImpl_ConeDriver.hxx>
#include "GEOMImpl_SphereDriver.hxx" #include <GEOMImpl_SphereDriver.hxx>
#include "GEOMImpl_TorusDriver.hxx" #include <GEOMImpl_TorusDriver.hxx>
#include "GEOMImpl_PrismDriver.hxx" #include <GEOMImpl_PrismDriver.hxx>
#include "GEOMImpl_PipeDriver.hxx" #include <GEOMImpl_PipeDriver.hxx>
#include "GEOMImpl_RevolutionDriver.hxx" #include <GEOMImpl_RevolutionDriver.hxx>
#include "GEOMImpl_ShapeDriver.hxx" #include <GEOMImpl_ShapeDriver.hxx>
#include "GEOMImpl_FillingDriver.hxx" #include <GEOMImpl_FillingDriver.hxx>
#include "GEOMImpl_IBox.hxx" #include <GEOMImpl_IBox.hxx>
#include "GEOMImpl_ICylinder.hxx" #include <GEOMImpl_ICylinder.hxx>
#include "GEOMImpl_ICone.hxx" #include <GEOMImpl_ICone.hxx>
#include "GEOMImpl_ISphere.hxx" #include <GEOMImpl_ISphere.hxx>
#include "GEOMImpl_ITorus.hxx" #include <GEOMImpl_ITorus.hxx>
#include "GEOMImpl_IPrism.hxx" #include <GEOMImpl_IPrism.hxx>
#include "GEOMImpl_IPipe.hxx" #include <GEOMImpl_IPipe.hxx>
#include "GEOMImpl_IRevolution.hxx" #include <GEOMImpl_IRevolution.hxx>
#include "GEOMImpl_IShapes.hxx" #include <GEOMImpl_IShapes.hxx>
#include "GEOMImpl_IFilling.hxx" #include <GEOMImpl_IFilling.hxx>
#include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC #include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC

36
src/GEOMImpl/GEOMImpl_I3DPrimOperations.hxx
View File

@ -10,49 +10,49 @@
class GEOMImpl_I3DPrimOperations : public GEOM_IOperations { class GEOMImpl_I3DPrimOperations : public GEOM_IOperations {
public: public:
GEOMImpl_I3DPrimOperations(GEOM_Engine* theEngine, int theDocID); Standard_EXPORT GEOMImpl_I3DPrimOperations(GEOM_Engine* theEngine, int theDocID);
~GEOMImpl_I3DPrimOperations(); Standard_EXPORT ~GEOMImpl_I3DPrimOperations();
Handle(GEOM_Object) MakeBoxDXDYDZ (double theDX, double theDY, double theDZ); Standard_EXPORT Handle(GEOM_Object) MakeBoxDXDYDZ (double theDX, double theDY, double theDZ);
Handle(GEOM_Object) MakeBoxTwoPnt (Handle(GEOM_Object) thePnt1, Standard_EXPORT Handle(GEOM_Object) MakeBoxTwoPnt (Handle(GEOM_Object) thePnt1,
Handle(GEOM_Object) thePnt2); Handle(GEOM_Object) thePnt2);
Handle(GEOM_Object) MakeCylinderRH (double theR, double theH); Standard_EXPORT Handle(GEOM_Object) MakeCylinderRH (double theR, double theH);
Handle(GEOM_Object) MakeCylinderPntVecRH (Handle(GEOM_Object) thePnt, Standard_EXPORT Handle(GEOM_Object) MakeCylinderPntVecRH (Handle(GEOM_Object) thePnt,
Handle(GEOM_Object) theVec, Handle(GEOM_Object) theVec,
double theR, double theH); double theR, double theH);
Handle(GEOM_Object) MakeConeR1R2H (double theR1, double theR2, double theH); Standard_EXPORT Handle(GEOM_Object) MakeConeR1R2H (double theR1, double theR2, double theH);
Handle(GEOM_Object) MakeConePntVecR1R2H (Handle(GEOM_Object) thePnt, Standard_EXPORT Handle(GEOM_Object) MakeConePntVecR1R2H (Handle(GEOM_Object) thePnt,
Handle(GEOM_Object) theVec, Handle(GEOM_Object) theVec,
double theR1, double theR2, double theH); double theR1, double theR2, double theH);
Handle(GEOM_Object) MakeSphereR (double theR); Standard_EXPORT Handle(GEOM_Object) MakeSphereR (double theR);
Handle(GEOM_Object) MakeSpherePntR (Handle(GEOM_Object) thePnt, 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, Handle(GEOM_Object) theVec,
double theRMajor, double theRMinor); 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) 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) thePoint1,
Handle(GEOM_Object) thePoint2); 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) thePath);
Handle(GEOM_Object) MakeRevolutionAxisAngle (Handle(GEOM_Object) theBase, Standard_EXPORT Handle(GEOM_Object) MakeRevolutionAxisAngle (Handle(GEOM_Object) theBase,
Handle(GEOM_Object) theAxis, Handle(GEOM_Object) theAxis,
double theAngle); 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);
}; };

34
src/GEOMImpl/GEOMImpl_IBasicOperations.cxx
View File

@ -1,32 +1,32 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_IBasicOperations.hxx" #include <GEOMImpl_IBasicOperations.hxx>
#include "utilities.h" #include "utilities.h"
#include "OpUtil.hxx" #include <OpUtil.hxx>
#include "Utils_ExceptHandlers.hxx" #include <Utils_ExceptHandlers.hxx>
#include <TFunction_DriverTable.hxx> #include <TFunction_DriverTable.hxx>
#include <TFunction_Driver.hxx> #include <TFunction_Driver.hxx>
#include <TFunction_Logbook.hxx> #include <TFunction_Logbook.hxx>
#include <TDF_Tool.hxx> #include <TDF_Tool.hxx>
#include "GEOM_Function.hxx" #include <GEOM_Function.hxx>
#include "GEOM_PythonDump.hxx" #include <GEOM_PythonDump.hxx>
#include "GEOMImpl_PointDriver.hxx" #include <GEOMImpl_PointDriver.hxx>
#include "GEOMImpl_VectorDriver.hxx" #include <GEOMImpl_VectorDriver.hxx>
#include "GEOMImpl_LineDriver.hxx" #include <GEOMImpl_LineDriver.hxx>
#include "GEOMImpl_PlaneDriver.hxx" #include <GEOMImpl_PlaneDriver.hxx>
#include "GEOMImpl_MarkerDriver.hxx" #include <GEOMImpl_MarkerDriver.hxx>
#include "GEOMImpl_IPoint.hxx" #include <GEOMImpl_IPoint.hxx>
#include "GEOMImpl_IVector.hxx" #include <GEOMImpl_IVector.hxx>
#include "GEOMImpl_ILine.hxx" #include <GEOMImpl_ILine.hxx>
#include "GEOMImpl_IPlane.hxx" #include <GEOMImpl_IPlane.hxx>
#include "GEOMImpl_IMarker.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 #include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC

26
src/GEOMImpl/GEOMImpl_IBasicOperations.hxx
View File

@ -10,45 +10,45 @@
class GEOMImpl_IBasicOperations : public GEOM_IOperations { class GEOMImpl_IBasicOperations : public GEOM_IOperations {
public: public:
GEOMImpl_IBasicOperations(GEOM_Engine* theEngine, int theDocID); Standard_EXPORT GEOMImpl_IBasicOperations(GEOM_Engine* theEngine, int theDocID);
~GEOMImpl_IBasicOperations(); Standard_EXPORT ~GEOMImpl_IBasicOperations();
// Point // 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); 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); double theParameter);
// Vector // 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); Handle(GEOM_Object) thePnt2);
// Line // 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) thePnt2);
Handle(GEOM_Object) MakeLine (Handle(GEOM_Object) thePnt, Standard_EXPORT Handle(GEOM_Object) MakeLine (Handle(GEOM_Object) thePnt,
Handle(GEOM_Object) theDir); Handle(GEOM_Object) theDir);
// Plane // 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) thePnt2,
Handle(GEOM_Object) thePnt3, Handle(GEOM_Object) thePnt3,
double theSize); double theSize);
Handle(GEOM_Object) MakePlanePntVec (Handle(GEOM_Object) thePnt, Standard_EXPORT Handle(GEOM_Object) MakePlanePntVec (Handle(GEOM_Object) thePnt,
Handle(GEOM_Object) theVec, Handle(GEOM_Object) theVec,
double theSize); 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 // 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 theXDX, double theXDY, double theXDZ,
double theYDX, double theYDY, double theYDZ); double theYDX, double theYDY, double theYDZ);
}; };

38
src/GEOMImpl/GEOMImpl_IBlocksOperations.cxx
View File

@ -1,27 +1,31 @@
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_Types.hxx>
#include "GEOMImpl_IBlocks.hxx"
#include "GEOMImpl_IBlockTrsf.hxx"
#include "GEOMImpl_CopyDriver.hxx"
#include "GEOMImpl_Block6Explorer.hxx"
#include "GEOM_Function.hxx" #include <GEOMImpl_BlockDriver.hxx>
#include "GEOM_PythonDump.hxx" #include <GEOMImpl_IBlocks.hxx>
#include <GEOMImpl_IBlockTrsf.hxx>
#include <GEOMImpl_CopyDriver.hxx>
#include <GEOMImpl_Block6Explorer.hxx>
#include "GEOMAlgo_GlueAnalyser.hxx" #include <GEOM_Function.hxx>
#include "GEOMAlgo_CoupleOfShapes.hxx" #include <GEOM_PythonDump.hxx>
#include "GEOMAlgo_ListOfCoupleOfShapes.hxx"
#include "GEOMAlgo_ListIteratorOfListOfCoupleOfShapes.hxx" #include <GEOMAlgo_GlueAnalyser.hxx>
#include "BlockFix_CheckTool.hxx" #include <GEOMAlgo_CoupleOfShapes.hxx>
#include <GEOMAlgo_ListOfCoupleOfShapes.hxx>
#include <GEOMAlgo_ListIteratorOfListOfCoupleOfShapes.hxx>
#include <BlockFix_CheckTool.hxx>
#include "utilities.h" #include "utilities.h"
#include "OpUtil.hxx" #include <OpUtil.hxx>
#include "Utils_ExceptHandlers.hxx" #include <Utils_ExceptHandlers.hxx>
#include <TFunction_DriverTable.hxx> #include <TFunction_DriverTable.hxx>
#include <TFunction_Driver.hxx> #include <TFunction_Driver.hxx>

60
src/GEOMImpl/GEOMImpl_IBlocksOperations.hxx
View File

@ -15,70 +15,70 @@ class Handle(TColStd_HArray1OfInteger);
class GEOMImpl_IBlocksOperations : public GEOM_IOperations { class GEOMImpl_IBlocksOperations : public GEOM_IOperations {
public: public:
GEOMImpl_IBlocksOperations(GEOM_Engine* theEngine, int theDocID); Standard_EXPORT GEOMImpl_IBlocksOperations(GEOM_Engine* theEngine, int theDocID);
~GEOMImpl_IBlocksOperations(); Standard_EXPORT ~GEOMImpl_IBlocksOperations();
// Creation of blocks and block faces // 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) theEdge2,
Handle(GEOM_Object) theEdge3, Handle(GEOM_Object) theEdge3,
Handle(GEOM_Object) theEdge4); 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) 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) thePoint2,
Handle(GEOM_Object) thePoint3, Handle(GEOM_Object) thePoint3,
Handle(GEOM_Object) thePoint4); 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) theFace2,
Handle(GEOM_Object) theFace3, Handle(GEOM_Object) theFace3,
Handle(GEOM_Object) theFace4, Handle(GEOM_Object) theFace4,
Handle(GEOM_Object) theFace5, Handle(GEOM_Object) theFace5,
Handle(GEOM_Object) theFace6); 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) 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 // 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 theX,
const Standard_Real theY, const Standard_Real theY,
const Standard_Real theZ, const Standard_Real theZ,
const Standard_Real theEpsilon); 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) thePoint1,
Handle(GEOM_Object) thePoint2); 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) 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) thePoint1,
Handle(GEOM_Object) thePoint2, Handle(GEOM_Object) thePoint2,
Handle(GEOM_Object) thePoint3, Handle(GEOM_Object) thePoint3,
Handle(GEOM_Object) thePoint4); 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) theEdge1,
Handle(GEOM_Object) theEdge2); 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) 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) thePoint);
Handle(GEOM_Object) GetFaceByNormale (Handle(GEOM_Object) theBlock, Standard_EXPORT Handle(GEOM_Object) GetFaceByNormale (Handle(GEOM_Object) theBlock,
Handle(GEOM_Object) theVector); Handle(GEOM_Object) theVector);
// Check blocks compounds // 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 theMinNbFaces,
const Standard_Integer theMaxNbFaces, const Standard_Integer theMaxNbFaces,
Standard_Integer& theNbBlocks); Standard_Integer& theNbBlocks);
@ -96,48 +96,48 @@ class GEOMImpl_IBlocksOperations : public GEOM_IOperations {
list<int> incriminated; list<int> incriminated;
}; };
Standard_Boolean CheckCompoundOfBlocksOld (Handle(GEOM_Object) theCompound, Standard_EXPORT Standard_Boolean CheckCompoundOfBlocksOld (Handle(GEOM_Object) theCompound,
list<BCError>& theErrors); list<BCError>& theErrors);
Standard_Boolean CheckCompoundOfBlocks (Handle(GEOM_Object) theCompound, Standard_EXPORT Standard_Boolean CheckCompoundOfBlocks (Handle(GEOM_Object) theCompound,
list<BCError>& theErrors); list<BCError>& theErrors);
TCollection_AsciiString PrintBCErrors (Handle(GEOM_Object) theCompound, Standard_EXPORT TCollection_AsciiString PrintBCErrors (Handle(GEOM_Object) theCompound,
const list<BCError>& theErrors); 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& BLO,
TopTools_ListOfShape& NOT, TopTools_ListOfShape& NOT,
TopTools_ListOfShape& EXT); TopTools_ListOfShape& EXT);
// Extract blocks from blocks compounds // Extract blocks from blocks compounds
Handle(TColStd_HSequenceOfTransient) ExplodeCompoundOfBlocks Standard_EXPORT Handle(TColStd_HSequenceOfTransient) ExplodeCompoundOfBlocks
(Handle(GEOM_Object) theCompound, (Handle(GEOM_Object) theCompound,
const Standard_Integer theMinNbFaces, const Standard_Integer theMinNbFaces,
const Standard_Integer theMaxNbFaces); 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) thePoint);
Handle(GEOM_Object) GetBlockByParts Standard_EXPORT Handle(GEOM_Object) GetBlockByParts
(Handle(GEOM_Object) theCompound, (Handle(GEOM_Object) theCompound,
const Handle(TColStd_HSequenceOfTransient)& theParts); const Handle(TColStd_HSequenceOfTransient)& theParts);
Handle(TColStd_HSequenceOfTransient) GetBlocksByParts Standard_EXPORT Handle(TColStd_HSequenceOfTransient) GetBlocksByParts
(Handle(GEOM_Object) theCompound, (Handle(GEOM_Object) theCompound,
const Handle(TColStd_HSequenceOfTransient)& theParts); const Handle(TColStd_HSequenceOfTransient)& theParts);
// Operations on blocks with gluing of result // 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 theDirFace1,
const Standard_Integer theDirFace2, const Standard_Integer theDirFace2,
const Standard_Integer theNbTimes); 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 theDirFace1U,
const Standard_Integer theDirFace2U, const Standard_Integer theDirFace2U,
const Standard_Integer theNbTimesU, const Standard_Integer theNbTimesU,
@ -146,7 +146,7 @@ class GEOMImpl_IBlocksOperations : public GEOM_IOperations {
const Standard_Integer theNbTimesV); const Standard_Integer theNbTimesV);
// Build groups for Propagation of 1D hypotheses // 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 #endif

18
src/GEOMImpl/GEOMImpl_IBooleanOperations.cxx
View File

@ -1,17 +1,17 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_IBooleanOperations.hxx" #include <GEOMImpl_IBooleanOperations.hxx>
#include "GEOM_Function.hxx" #include <GEOM_Function.hxx>
#include "GEOM_PythonDump.hxx" #include <GEOM_PythonDump.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_Types.hxx>
#include "GEOMImpl_BooleanDriver.hxx" #include <GEOMImpl_BooleanDriver.hxx>
#include "GEOMImpl_IBoolean.hxx" #include <GEOMImpl_IBoolean.hxx>
#include "GEOMImpl_PartitionDriver.hxx" #include <GEOMImpl_PartitionDriver.hxx>
#include "GEOMImpl_IPartition.hxx" #include <GEOMImpl_IPartition.hxx>
#include <TDF_Tool.hxx> #include <TDF_Tool.hxx>

10
src/GEOMImpl/GEOMImpl_IBooleanOperations.hxx
View File

@ -14,14 +14,14 @@ class Handle(TColStd_HArray1OfInteger);
class GEOMImpl_IBooleanOperations : public GEOM_IOperations { class GEOMImpl_IBooleanOperations : public GEOM_IOperations {
public: public:
GEOMImpl_IBooleanOperations(GEOM_Engine* theEngine, int theDocID); Standard_EXPORT GEOMImpl_IBooleanOperations(GEOM_Engine* theEngine, int theDocID);
~GEOMImpl_IBooleanOperations(); 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, Handle(GEOM_Object) theShape2,
Standard_Integer theOp); 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)& theTools,
const Handle(TColStd_HSequenceOfTransient)& theKeepInside, const Handle(TColStd_HSequenceOfTransient)& theKeepInside,
const Handle(TColStd_HSequenceOfTransient)& theRemoveInside, const Handle(TColStd_HSequenceOfTransient)& theRemoveInside,
@ -29,7 +29,7 @@ class GEOMImpl_IBooleanOperations : public GEOM_IOperations {
const Standard_Boolean theRemoveWebs, const Standard_Boolean theRemoveWebs,
const Handle(TColStd_HArray1OfInteger)& theMaterials); 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); Handle(GEOM_Object) thePlane);
}; };

34
src/GEOMImpl/GEOMImpl_ICurvesOperations.cxx
View File

@ -1,25 +1,25 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_ICurvesOperations.hxx" #include <GEOMImpl_ICurvesOperations.hxx>
#include "GEOM_Function.hxx" #include <GEOM_Function.hxx>
#include "GEOM_PythonDump.hxx" #include <GEOM_PythonDump.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_Types.hxx>
#include "GEOMImpl_PolylineDriver.hxx" #include <GEOMImpl_PolylineDriver.hxx>
#include "GEOMImpl_CircleDriver.hxx" #include <GEOMImpl_CircleDriver.hxx>
#include "GEOMImpl_SplineDriver.hxx" #include <GEOMImpl_SplineDriver.hxx>
#include "GEOMImpl_EllipseDriver.hxx" #include <GEOMImpl_EllipseDriver.hxx>
#include "GEOMImpl_ArcDriver.hxx" #include <GEOMImpl_ArcDriver.hxx>
#include "GEOMImpl_SketcherDriver.hxx" #include <GEOMImpl_SketcherDriver.hxx>
#include "GEOMImpl_IPolyline.hxx" #include <GEOMImpl_IPolyline.hxx>
#include "GEOMImpl_ICircle.hxx" #include <GEOMImpl_ICircle.hxx>
#include "GEOMImpl_ISpline.hxx" #include <GEOMImpl_ISpline.hxx>
#include "GEOMImpl_IEllipse.hxx" #include <GEOMImpl_IEllipse.hxx>
#include "GEOMImpl_IArc.hxx" #include <GEOMImpl_IArc.hxx>
#include "GEOMImpl_ISketcher.hxx" #include <GEOMImpl_ISketcher.hxx>
#include "utilities.h" #include "utilities.h"

22
src/GEOMImpl/GEOMImpl_ICurvesOperations.hxx
View File

@ -12,30 +12,30 @@ class Handle(GEOM_Object);
class GEOMImpl_ICurvesOperations : public GEOM_IOperations { class GEOMImpl_ICurvesOperations : public GEOM_IOperations {
public: public:
GEOMImpl_ICurvesOperations(GEOM_Engine* theEngine, int theDocID); Standard_EXPORT GEOMImpl_ICurvesOperations(GEOM_Engine* theEngine, int theDocID);
~GEOMImpl_ICurvesOperations(); 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) thePnt2,
Handle(GEOM_Object) thePnt3); 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) 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, Handle(GEOM_Object) theVec,
double theRMajor, double theRMinor); 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) thePnt2,
Handle(GEOM_Object) thePnt3); Handle(GEOM_Object) thePnt3);
Handle(GEOM_Object) MakeSplineBezier (list<Handle(GEOM_Object)> thePoints); Standard_EXPORT Handle(GEOM_Object) MakeSplineBezier (list<Handle(GEOM_Object)> thePoints);
Handle(GEOM_Object) MakeSplineInterpolation (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); Standard_EXPORT Handle(GEOM_Object) MakeSketcher (const char* theCommand, list<double> theWorkingPlane);
Handle(GEOM_Object) MakeSketcherOnPlane (const char* theCommand, Standard_EXPORT Handle(GEOM_Object) MakeSketcherOnPlane (const char* theCommand,
Handle(GEOM_Object) theWorkingPlane); Handle(GEOM_Object) theWorkingPlane);
}; };

16
src/GEOMImpl/GEOMImpl_IGroupOperations.cxx
View File

@ -1,16 +1,16 @@
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_Function.hxx>
#include "GEOM_ISubShape.hxx" #include <GEOM_ISubShape.hxx>
#include "GEOM_PythonDump.hxx" #include <GEOM_PythonDump.hxx>
#include "utilities.h" #include "utilities.h"
#include "OpUtil.hxx" #include <OpUtil.hxx>
#include "Utils_ExceptHandlers.hxx" #include <Utils_ExceptHandlers.hxx>
#include <TFunction_DriverTable.hxx> #include <TFunction_DriverTable.hxx>
#include <TFunction_Driver.hxx> #include <TFunction_Driver.hxx>

24
src/GEOMImpl/GEOMImpl_IGroupOperations.hxx
View File

@ -13,32 +13,32 @@
class GEOMImpl_IGroupOperations : public GEOM_IOperations { class GEOMImpl_IGroupOperations : public GEOM_IOperations {
public: public:
GEOMImpl_IGroupOperations(GEOM_Engine* theEngine, int theDocID); Standard_EXPORT GEOMImpl_IGroupOperations(GEOM_Engine* theEngine, int theDocID);
~GEOMImpl_IGroupOperations(); 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); const Handle(TColStd_HSequenceOfTransient)& theSubShapes);
void DifferenceList (Handle(GEOM_Object) theGroup, Standard_EXPORT void DifferenceList (Handle(GEOM_Object) theGroup,
const Handle(TColStd_HSequenceOfTransient)& theSubShapes); const Handle(TColStd_HSequenceOfTransient)& theSubShapes);
void UnionIDs (Handle(GEOM_Object) theGroup, Standard_EXPORT void UnionIDs (Handle(GEOM_Object) theGroup,
const Handle(TColStd_HSequenceOfInteger)& theSubShapes); const Handle(TColStd_HSequenceOfInteger)& theSubShapes);
void DifferenceIDs (Handle(GEOM_Object) theGroup, Standard_EXPORT void DifferenceIDs (Handle(GEOM_Object) theGroup,
const Handle(TColStd_HSequenceOfInteger)& theSubShapes); 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);
}; };

24
src/GEOMImpl/GEOMImpl_IHealingOperations.cxx
View File

@ -1,19 +1,23 @@
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 <GEOM_PythonDump.hxx>
#include "GEOMImpl_Types.hxx"
#include "GEOMImpl_IHealing.hxx"
#include "GEOMImpl_CopyDriver.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 "utilities.h"
#include "OpUtil.hxx" #include <OpUtil.hxx>
#include "Utils_ExceptHandlers.hxx" #include <Utils_ExceptHandlers.hxx>
#include <ShapeAnalysis_FreeBounds.hxx> #include <ShapeAnalysis_FreeBounds.hxx>

26
src/GEOMImpl/GEOMImpl_IHealingOperations.hxx
View File

@ -13,45 +13,45 @@
class GEOMImpl_IHealingOperations : public GEOM_IOperations { class GEOMImpl_IHealingOperations : public GEOM_IOperations {
public: public:
GEOMImpl_IHealingOperations(GEOM_Engine* theEngine, int theDocID); Standard_EXPORT GEOMImpl_IHealingOperations(GEOM_Engine* theEngine, int theDocID);
~GEOMImpl_IHealingOperations(); Standard_EXPORT ~GEOMImpl_IHealingOperations();
// Apply Shape Processing to the selected Object // 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)& theOperations,
const Handle(TColStd_HArray1OfExtendedString)& theParams, const Handle(TColStd_HArray1OfExtendedString)& theParams,
const Handle(TColStd_HArray1OfExtendedString)& theValues ); const Handle(TColStd_HArray1OfExtendedString)& theValues );
// Retrieve default Shape Process parameters (from resource file) // 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>& theParams,
list<string>& theValues ); list<string>& theValues );
// Retrieve default Shape Process parameters for given operator // 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>& theParams,
list<string>& theValues ); list<string>& theValues );
// returns all parameters that are valid for the given operation (Shape Process operator) // 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); 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, const Handle(TColStd_HArray1OfInteger)& theWires,
bool isCommonVertex ); 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); 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); 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 ); double theTolerance );
Handle(GEOM_Object) DivideEdge( Handle(GEOM_Object) theObject, Standard_EXPORT Handle(GEOM_Object) DivideEdge( Handle(GEOM_Object) theObject,
int theIndex, int theIndex,
double theValue, double theValue,
bool isByParameter ); bool isByParameter );
@ -59,7 +59,7 @@ class GEOMImpl_IHealingOperations : public GEOM_IOperations {
// this function does not use Function-Driver mechanism, it just computes the free // 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 // 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.. // 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)& theOutClosedWires,
Handle(TColStd_HSequenceOfTransient)& theOutOpenWires ); Handle(TColStd_HSequenceOfTransient)& theOutOpenWires );
}; };

24
src/GEOMImpl/GEOMImpl_IInsertOperations.cxx
View File

@ -1,27 +1,27 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_IInsertOperations.hxx" #include <GEOMImpl_IInsertOperations.hxx>
#include "utilities.h" #include "utilities.h"
#include "OpUtil.hxx" #include <OpUtil.hxx>
#include "Utils_ExceptHandlers.hxx" #include <Utils_ExceptHandlers.hxx>
#include <TFunction_DriverTable.hxx> #include <TFunction_DriverTable.hxx>
#include <TFunction_Driver.hxx> #include <TFunction_Driver.hxx>
#include <TFunction_Logbook.hxx> #include <TFunction_Logbook.hxx>
#include <TDF_Tool.hxx> #include <TDF_Tool.hxx>
#include "GEOM_Function.hxx" #include <GEOM_Function.hxx>
#include "GEOM_PythonDump.hxx" #include <GEOM_PythonDump.hxx>
#include "GEOMImpl_CopyDriver.hxx" #include <GEOMImpl_CopyDriver.hxx>
#include "GEOMImpl_ExportDriver.hxx" #include <GEOMImpl_ExportDriver.hxx>
#include "GEOMImpl_ImportDriver.hxx" #include <GEOMImpl_ImportDriver.hxx>
#include "GEOMImpl_ICopy.hxx" #include <GEOMImpl_ICopy.hxx>
#include "GEOMImpl_IImportExport.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 #include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC

16
src/GEOMImpl/GEOMImpl_IInsertOperations.hxx
View File

@ -13,25 +13,25 @@
class GEOMImpl_IInsertOperations : public GEOM_IOperations { class GEOMImpl_IInsertOperations : public GEOM_IOperations {
public: public:
GEOMImpl_IInsertOperations(GEOM_Engine* theEngine, int theDocID); Standard_EXPORT GEOMImpl_IInsertOperations(GEOM_Engine* theEngine, int theDocID);
~GEOMImpl_IInsertOperations(); 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* theFileName,
const char* theFormatType); const char* theFormatType);
Standard_Boolean ImportTranslators (Handle(TColStd_HSequenceOfAsciiString)& theFormats, Standard_EXPORT Standard_Boolean ImportTranslators (Handle(TColStd_HSequenceOfAsciiString)& theFormats,
Handle(TColStd_HSequenceOfAsciiString)& thePatterns); Handle(TColStd_HSequenceOfAsciiString)& thePatterns);
Standard_Boolean ExportTranslators (Handle(TColStd_HSequenceOfAsciiString)& theFormats, Standard_EXPORT Standard_Boolean ExportTranslators (Handle(TColStd_HSequenceOfAsciiString)& theFormats,
Handle(TColStd_HSequenceOfAsciiString)& thePatterns); Handle(TColStd_HSequenceOfAsciiString)& thePatterns);
Standard_Boolean IsSupported (const Standard_Boolean isImport, Standard_EXPORT Standard_Boolean IsSupported (const Standard_Boolean isImport,
const TCollection_AsciiString theFormat, const TCollection_AsciiString theFormat,
Handle(TCollection_HAsciiString)& theLibName); Handle(TCollection_HAsciiString)& theLibName);

26
src/GEOMImpl/GEOMImpl_ILocalOperations.cxx
View File

@ -1,24 +1,24 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_ILocalOperations.hxx" #include <GEOMImpl_ILocalOperations.hxx>
#include "GEOM_Function.hxx" #include <GEOM_Function.hxx>
#include "GEOM_PythonDump.hxx" #include <GEOM_PythonDump.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_Types.hxx>
#include "GEOMImpl_FilletDriver.hxx" #include <GEOMImpl_FilletDriver.hxx>
#include "GEOMImpl_ChamferDriver.hxx" #include <GEOMImpl_ChamferDriver.hxx>
#include "GEOMImpl_IFillet.hxx" #include <GEOMImpl_IFillet.hxx>
#include "GEOMImpl_IChamfer.hxx" #include <GEOMImpl_IChamfer.hxx>
#include "GEOMImpl_IArchimede.hxx" #include <GEOMImpl_IArchimede.hxx>
#include "GEOMImpl_ArchimedeDriver.hxx" #include <GEOMImpl_ArchimedeDriver.hxx>
#include "utilities.h" #include "utilities.h"
#include "OpUtil.hxx" #include <OpUtil.hxx>
#include "Utils_ExceptHandlers.hxx" #include <Utils_ExceptHandlers.hxx>
#include <TFunction_DriverTable.hxx> #include <TFunction_DriverTable.hxx>
#include <TFunction_Driver.hxx> #include <TFunction_Driver.hxx>

22
src/GEOMImpl/GEOMImpl_ILocalOperations.hxx
View File

@ -12,31 +12,31 @@
class GEOMImpl_ILocalOperations : public GEOM_IOperations { class GEOMImpl_ILocalOperations : public GEOM_IOperations {
public: public:
GEOMImpl_ILocalOperations(GEOM_Engine* theEngine, int theDocID); Standard_EXPORT GEOMImpl_ILocalOperations(GEOM_Engine* theEngine, int theDocID);
~GEOMImpl_ILocalOperations(); Standard_EXPORT ~GEOMImpl_ILocalOperations();
Handle(GEOM_Object) MakeFilletAll (Handle(GEOM_Object) theShape, double theR); Standard_EXPORT 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) MakeFilletEdges (Handle(GEOM_Object) theShape, double theR,
list<int> theEdges); 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); list<int> theFaces);
Handle(GEOM_Object) MakeChamferAll (Handle(GEOM_Object) theShape, double theD); Standard_EXPORT Handle(GEOM_Object) MakeChamferAll (Handle(GEOM_Object) theShape, double theD);
Handle(GEOM_Object) MakeChamferEdge (Handle(GEOM_Object) theShape, Standard_EXPORT Handle(GEOM_Object) MakeChamferEdge (Handle(GEOM_Object) theShape,
double theD1, double theD2, double theD1, double theD2,
int theFace1, int theFace2); 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, double theD1, double theD2,
list<int> theFaces); 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 theWeight, double theWaterDensity,
double theMeshingDeflection); double theMeshingDeflection);
Standard_Integer GetSubShapeIndex (Handle(GEOM_Object) theShape, Standard_EXPORT Standard_Integer GetSubShapeIndex (Handle(GEOM_Object) theShape,
Handle(GEOM_Object) theSubShape); Handle(GEOM_Object) theSubShape);
static bool GetSubShape (const TopoDS_Shape& theShape, Standard_EXPORT static bool GetSubShape (const TopoDS_Shape& theShape,
const int theIndex, const int theIndex,
TopoDS_Shape& theSubShape); TopoDS_Shape& theSubShape);
}; };

18
src/GEOMImpl/GEOMImpl_IMeasureOperations.cxx
View File

@ -1,17 +1,17 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_IMeasureOperations.hxx" #include <GEOMImpl_IMeasureOperations.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_Types.hxx>
#include "GEOMImpl_MeasureDriver.hxx" #include <GEOMImpl_MeasureDriver.hxx>
#include "GEOMImpl_IMeasure.hxx" #include <GEOMImpl_IMeasure.hxx>
#include "GEOM_Function.hxx" #include <GEOM_Function.hxx>
#include "GEOM_PythonDump.hxx" #include <GEOM_PythonDump.hxx>
#include "utilities.h" #include "utilities.h"
#include "OpUtil.hxx" #include <OpUtil.hxx>
#include "Utils_ExceptHandlers.hxx" #include <Utils_ExceptHandlers.hxx>
#include <TFunction_DriverTable.hxx> #include <TFunction_DriverTable.hxx>
#include <TFunction_Driver.hxx> #include <TFunction_Driver.hxx>

22
src/GEOMImpl/GEOMImpl_IMeasureOperations.hxx
View File

@ -14,42 +14,42 @@ class Handle(GEOM_Object);
class GEOMImpl_IMeasureOperations : public GEOM_IOperations { class GEOMImpl_IMeasureOperations : public GEOM_IOperations {
public: public:
GEOMImpl_IMeasureOperations(GEOM_Engine* theEngine, int theDocID); Standard_EXPORT GEOMImpl_IMeasureOperations(GEOM_Engine* theEngine, int theDocID);
~GEOMImpl_IMeasureOperations(); 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& theLength,
Standard_Real& theSurfArea, Standard_Real& theSurfArea,
Standard_Real& theVolume); 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& I11, Standard_Real& I12, Standard_Real& I13,
Standard_Real& I21, Standard_Real& I22, Standard_Real& I23, Standard_Real& I21, Standard_Real& I22, Standard_Real& I23,
Standard_Real& I31, Standard_Real& I32, Standard_Real& I33, Standard_Real& I31, Standard_Real& I32, Standard_Real& I33,
Standard_Real& Ix , Standard_Real& Iy , Standard_Real& Iz); 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& Xmin, Standard_Real& Xmax,
Standard_Real& Ymin, Standard_Real& Ymax, Standard_Real& Ymin, Standard_Real& Ymax,
Standard_Real& Zmin, Standard_Real& Zmax); 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& FaceMin, Standard_Real& FaceMax,
Standard_Real& EdgeMin, Standard_Real& EdgeMax, Standard_Real& EdgeMin, Standard_Real& EdgeMax,
Standard_Real& VertMin, Standard_Real& VertMax); 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& 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& X1, Standard_Real& Y1, Standard_Real& Z1,
Standard_Real& X2, Standard_Real& Y2, Standard_Real& Z2); 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 ); Standard_Real& theX, Standard_Real& theY, Standard_Real& theZ );
private: private:

32
src/GEOMImpl/GEOMImpl_IShapesOperations.cxx
View File

@ -1,28 +1,28 @@
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_VectorDriver.hxx>
#include "GEOMImpl_ShapeDriver.hxx" #include <GEOMImpl_ShapeDriver.hxx>
#include "GEOMImpl_CopyDriver.hxx" #include <GEOMImpl_CopyDriver.hxx>
#include "GEOMImpl_GlueDriver.hxx" #include <GEOMImpl_GlueDriver.hxx>
#include "GEOMImpl_IVector.hxx" #include <GEOMImpl_IVector.hxx>
#include "GEOMImpl_IShapes.hxx" #include <GEOMImpl_IShapes.hxx>
#include "GEOMImpl_IGlue.hxx" #include <GEOMImpl_IGlue.hxx>
#include "GEOMImpl_Block6Explorer.hxx" #include <GEOMImpl_Block6Explorer.hxx>
#include "GEOM_Function.hxx" #include <GEOM_Function.hxx>
#include "GEOM_PythonDump.hxx" #include <GEOM_PythonDump.hxx>
#include "GEOMAlgo_FinderShapeOn1.hxx" #include <GEOMAlgo_FinderShapeOn1.hxx>
#include "utilities.h" #include "utilities.h"
#include "OpUtil.hxx" #include <OpUtil.hxx>
#include "Utils_ExceptHandlers.hxx" #include <Utils_ExceptHandlers.hxx>
#include <TFunction_DriverTable.hxx> #include <TFunction_DriverTable.hxx>
#include <TFunction_Driver.hxx> #include <TFunction_Driver.hxx>

58
src/GEOMImpl/GEOMImpl_IShapesOperations.hxx
View File

@ -18,100 +18,100 @@ class Handle(TColStd_HArray1OfInteger);
class GEOMImpl_IShapesOperations : public GEOM_IOperations { class GEOMImpl_IShapesOperations : public GEOM_IOperations {
public: public:
GEOMImpl_IShapesOperations(GEOM_Engine* theEngine, int theDocID); Standard_EXPORT GEOMImpl_IShapesOperations(GEOM_Engine* theEngine, int theDocID);
~GEOMImpl_IShapesOperations(); 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) 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); 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); 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_Integer theShapeType,
const Standard_Boolean isSorted); 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_Integer theShapeType,
const Standard_Boolean isSorted); 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); const Standard_Integer theID);
Standard_Integer NumberOfFaces (Handle(GEOM_Object) theShape); Standard_EXPORT Standard_Integer NumberOfFaces (Handle(GEOM_Object) theShape);
Standard_Integer NumberOfEdges (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, Handle(GEOM_Object) theShape2,
const Standard_Integer theShapeType); 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 Standard_Integer theShapeType,
const Handle(GEOM_Object)& theAx1, const Handle(GEOM_Object)& theAx1,
const GEOMAlgo_State theState); 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 Standard_Integer theShapeType,
const Handle(GEOM_Object)& theAxis, const Handle(GEOM_Object)& theAxis,
const Standard_Real theRadius, const Standard_Real theRadius,
const GEOMAlgo_State theState); 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 Standard_Integer theShapeType,
const Handle(GEOM_Object)& theCenter, const Handle(GEOM_Object)& theCenter,
const Standard_Real theRadius, const Standard_Real theRadius,
const GEOMAlgo_State theState); 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 Standard_Integer theShapeType,
const Handle(GEOM_Object)& theAx1, const Handle(GEOM_Object)& theAx1,
const GEOMAlgo_State theState); 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 Standard_Integer theShapeType,
const Handle(GEOM_Object)& theAxis, const Handle(GEOM_Object)& theAxis,
const Standard_Real theRadius, const Standard_Real theRadius,
const GEOMAlgo_State theState); 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 Standard_Integer theShapeType,
const Handle(GEOM_Object)& theCenter, const Handle(GEOM_Object)& theCenter,
const Standard_Real theRadius, const Standard_Real theRadius,
const GEOMAlgo_State theState); 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, const Standard_Integer theShapeType,
Handle(GEOM_Object) theAxis, Handle(GEOM_Object) theAxis,
const Standard_Real theRadius); 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, const Standard_Integer theShapeType,
Handle(GEOM_Object) theCenter, Handle(GEOM_Object) theCenter,
const Standard_Real theRadius); 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); Handle(GEOM_Object) theShapeWhat);
static void SortShapes (TopTools_ListOfShape& SL); Standard_EXPORT static void SortShapes (TopTools_ListOfShape& SL);
private: private:
Handle(GEOM_Object) MakeShape (list<Handle(GEOM_Object)> theShapes, Handle(GEOM_Object) MakeShape (list<Handle(GEOM_Object)> theShapes,

38
src/GEOMImpl/GEOMImpl_ITransformOperations.cxx
View File

@ -1,34 +1,34 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_ITransformOperations.hxx" #include <GEOMImpl_ITransformOperations.hxx>
#include "utilities.h" #include "utilities.h"
#include "OpUtil.hxx" #include <OpUtil.hxx>
#include "Utils_ExceptHandlers.hxx" #include <Utils_ExceptHandlers.hxx>
#include <TFunction_DriverTable.hxx> #include <TFunction_DriverTable.hxx>
#include <TFunction_Driver.hxx> #include <TFunction_Driver.hxx>
#include <TFunction_Logbook.hxx> #include <TFunction_Logbook.hxx>
#include <TDF_Tool.hxx> #include <TDF_Tool.hxx>
#include "GEOM_Function.hxx" #include <GEOM_Function.hxx>
#include "GEOM_PythonDump.hxx" #include <GEOM_PythonDump.hxx>
#include "GEOMImpl_TranslateDriver.hxx" #include <GEOMImpl_TranslateDriver.hxx>
#include "GEOMImpl_MirrorDriver.hxx" #include <GEOMImpl_MirrorDriver.hxx>
#include "GEOMImpl_OffsetDriver.hxx" #include <GEOMImpl_OffsetDriver.hxx>
#include "GEOMImpl_ScaleDriver.hxx" #include <GEOMImpl_ScaleDriver.hxx>
#include "GEOMImpl_RotateDriver.hxx" #include <GEOMImpl_RotateDriver.hxx>
#include "GEOMImpl_PositionDriver.hxx" #include <GEOMImpl_PositionDriver.hxx>
#include "GEOMImpl_ITranslate.hxx" #include <GEOMImpl_ITranslate.hxx>
#include "GEOMImpl_IMirror.hxx" #include <GEOMImpl_IMirror.hxx>
#include "GEOMImpl_IOffset.hxx" #include <GEOMImpl_IOffset.hxx>
#include "GEOMImpl_IScale.hxx" #include <GEOMImpl_IScale.hxx>
#include "GEOMImpl_IRotate.hxx" #include <GEOMImpl_IRotate.hxx>
#include "GEOMImpl_IPosition.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 #include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC

52
src/GEOMImpl/GEOMImpl_ITransformOperations.hxx
View File

@ -10,79 +10,79 @@
class GEOMImpl_ITransformOperations : public GEOM_IOperations { class GEOMImpl_ITransformOperations : public GEOM_IOperations {
public: public:
GEOMImpl_ITransformOperations(GEOM_Engine* theEngine, int theDocID); Standard_EXPORT GEOMImpl_ITransformOperations(GEOM_Engine* theEngine, int theDocID);
~GEOMImpl_ITransformOperations(); 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) thePoint1,
Handle(GEOM_Object) thePoint2); 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) thePoint1,
Handle(GEOM_Object) thePoint2); 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) 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) 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) 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) 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) 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) 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) 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) 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) thePoint);
Handle(GEOM_Object) OffsetShape (Handle(GEOM_Object) theObject, Standard_EXPORT Handle(GEOM_Object) OffsetShape (Handle(GEOM_Object) theObject,
double theOffset); double theOffset);
Handle(GEOM_Object) OffsetShapeCopy (Handle(GEOM_Object) theObject, Standard_EXPORT Handle(GEOM_Object) OffsetShapeCopy (Handle(GEOM_Object) theObject,
double theOffset); double theOffset);
Handle(GEOM_Object) ScaleShape (Handle(GEOM_Object) theObject, Standard_EXPORT Handle(GEOM_Object) ScaleShape (Handle(GEOM_Object) theObject,
Handle(GEOM_Object) thePoint, Handle(GEOM_Object) thePoint,
double theFactor); double theFactor);
Handle(GEOM_Object) ScaleShapeCopy (Handle(GEOM_Object) theObject, Standard_EXPORT Handle(GEOM_Object) ScaleShapeCopy (Handle(GEOM_Object) theObject,
Handle(GEOM_Object) thePoint, Handle(GEOM_Object) thePoint,
double theFactor); 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) theStartLCS,
Handle(GEOM_Object) theEndLCS); 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) theStartLCS,
Handle(GEOM_Object) theEndLCS); 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, Handle(GEOM_Object) theAxis,
double theAngle, double theAngle,
Standard_Integer theNbTimes1, Standard_Integer theNbTimes1,

11
src/GEOMImpl/GEOMImpl_ImportDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_ImportDriver.hxx"
#include "GEOMImpl_IImportExport.hxx" #include <GEOMImpl_ImportDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_IImportExport.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include "utilities.h" #include "utilities.h"

11
src/GEOMImpl/GEOMImpl_LineDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_LineDriver.hxx"
#include "GEOMImpl_ILine.hxx" #include <GEOMImpl_LineDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_ILine.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx> #include <BRepBuilderAPI_MakeEdge.hxx>

11
src/GEOMImpl/GEOMImpl_MarkerDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_MarkerDriver.hxx"
#include "GEOMImpl_IMarker.hxx" #include <GEOMImpl_MarkerDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_IMarker.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRepBuilderAPI_MakeFace.hxx> #include <BRepBuilderAPI_MakeFace.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>

13
src/GEOMImpl/GEOMImpl_MeasureDriver.cxx
View File

@ -1,10 +1,11 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_MeasureDriver.hxx"
#include "GEOMImpl_IMeasure.hxx" #include <GEOMImpl_MeasureDriver.hxx>
#include "GEOMImpl_IMeasureOperations.hxx" #include <GEOMImpl_IMeasure.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_IMeasureOperations.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>
#include <BRepGProp.hxx> #include <BRepGProp.hxx>

7
src/GEOMImpl/GEOMImpl_MirrorDriver.cxx
View File

@ -1,10 +1,11 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_MirrorDriver.hxx"
#include <GEOMImpl_MirrorDriver.hxx>
#include <GEOMImpl_IMirror.hxx> #include <GEOMImpl_IMirror.hxx>
#include <GEOMImpl_Types.hxx> #include <GEOMImpl_Types.hxx>
#include "GEOM_Function.hxx" #include <GEOM_Function.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>
#include <BRepBuilderAPI_Transform.hxx> #include <BRepBuilderAPI_Transform.hxx>

11
src/GEOMImpl/GEOMImpl_OffsetDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_OffsetDriver.hxx"
#include "GEOMImpl_IOffset.hxx" #include <GEOMImpl_OffsetDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_IOffset.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRepOffsetAPI_MakeOffsetShape.hxx> #include <BRepOffsetAPI_MakeOffsetShape.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>

13
src/GEOMImpl/GEOMImpl_PartitionDriver.cxx
View File

@ -1,11 +1,12 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_PartitionDriver.hxx"
#include "GEOMImpl_IPartition.hxx"
#include "GEOMImpl_Types.hxx"
#include "GEOM_Object.hxx" #include <GEOMImpl_PartitionDriver.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_IPartition.hxx>
#include <GEOMImpl_Types.hxx>
#include <GEOM_Object.hxx>
#include <GEOM_Function.hxx>
#include <NMTAlgo_Splitter1.hxx> #include <NMTAlgo_Splitter1.hxx>

11
src/GEOMImpl/GEOMImpl_PipeDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_PipeDriver.hxx"
#include "GEOMImpl_IPipe.hxx" #include <GEOMImpl_PipeDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_IPipe.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>
#include <BRepCheck_Analyzer.hxx> #include <BRepCheck_Analyzer.hxx>

11
src/GEOMImpl/GEOMImpl_PlaneDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_PlaneDriver.hxx"
#include "GEOMImpl_IPlane.hxx" #include <GEOMImpl_PlaneDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_IPlane.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRepBuilderAPI_MakeFace.hxx> #include <BRepBuilderAPI_MakeFace.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>

11
src/GEOMImpl/GEOMImpl_PointDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_PointDriver.hxx"
#include "GEOMImpl_IPoint.hxx" #include <GEOMImpl_PointDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_IPoint.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>
#include <BRepBuilderAPI_MakeVertex.hxx> #include <BRepBuilderAPI_MakeVertex.hxx>

11
src/GEOMImpl/GEOMImpl_PolylineDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_PolylineDriver.hxx"
#include "GEOMImpl_IPolyline.hxx" #include <GEOMImpl_PolylineDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_IPolyline.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRepBuilderAPI_MakePolygon.hxx> #include <BRepBuilderAPI_MakePolygon.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>

11
src/GEOMImpl/GEOMImpl_PositionDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_PositionDriver.hxx"
#include "GEOMImpl_IPosition.hxx" #include <GEOMImpl_PositionDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_IPosition.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRepBuilderAPI_Transform.hxx> #include <BRepBuilderAPI_Transform.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>

11
src/GEOMImpl/GEOMImpl_PrismDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_PrismDriver.hxx"
#include "GEOMImpl_IPrism.hxx" #include <GEOMImpl_PrismDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_IPrism.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRepPrimAPI_MakePrism.hxx> #include <BRepPrimAPI_MakePrism.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>

11
src/GEOMImpl/GEOMImpl_RevolutionDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_RevolutionDriver.hxx"
#include "GEOMImpl_IRevolution.hxx" #include <GEOMImpl_RevolutionDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_IRevolution.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRepPrimAPI_MakeRevol.hxx> #include <BRepPrimAPI_MakeRevol.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>

10
src/GEOMImpl/GEOMImpl_RotateDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_RotateDriver.hxx"
#include <GEOMImpl_RotateDriver.hxx>
#include <GEOMImpl_IRotate.hxx> #include <GEOMImpl_IRotate.hxx>
#include <GEOMImpl_Types.hxx> #include <GEOMImpl_Types.hxx>
#include "GEOM_Function.hxx" #include <GEOM_Function.hxx>
#include <gp_Trsf.hxx> #include <gp_Trsf.hxx>
#include <gp_Pnt.hxx> #include <gp_Pnt.hxx>
#include <gp_Vec.hxx> #include <gp_Vec.hxx>
@ -149,7 +150,8 @@ Standard_Integer GEOMImpl_RotateDriver::Execute(TFunction_Logbook& log) const
} }
Handle(Geom_Line) Line = new Geom_Line(AX1); 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; if ( P1.IsEqual(P2, Precision::Confusion() ) ) return 0;

11
src/GEOMImpl/GEOMImpl_ScaleDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_ScaleDriver.hxx"
#include "GEOMImpl_IScale.hxx" #include <GEOMImpl_ScaleDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_IScale.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRepBuilderAPI_Transform.hxx> #include <BRepBuilderAPI_Transform.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>

13
src/GEOMImpl/GEOMImpl_ShapeDriver.cxx
View File

@ -1,10 +1,11 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_ShapeDriver.hxx"
#include "GEOMImpl_IShapes.hxx" #include <GEOMImpl_ShapeDriver.hxx>
#include "GEOMImpl_IShapesOperations.hxx" #include <GEOMImpl_IShapes.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_IShapesOperations.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>
#include <BRep_Builder.hxx> #include <BRep_Builder.hxx>

11
src/GEOMImpl/GEOMImpl_SketcherDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_SketcherDriver.hxx"
#include "GEOMImpl_ISketcher.hxx" #include <GEOMImpl_SketcherDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_ISketcher.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRepBuilderAPI_Transform.hxx> #include <BRepBuilderAPI_Transform.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>

11
src/GEOMImpl/GEOMImpl_SphereDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_SphereDriver.hxx"
#include "GEOMImpl_ISphere.hxx" #include <GEOMImpl_SphereDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_ISphere.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRepPrimAPI_MakeSphere.hxx> #include <BRepPrimAPI_MakeSphere.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>

13
src/GEOMImpl/GEOMImpl_SplineDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_SplineDriver.hxx"
#include "GEOMImpl_ISpline.hxx" #include <GEOMImpl_SplineDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_ISpline.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx> #include <BRepBuilderAPI_MakeEdge.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>
@ -95,7 +96,7 @@ Standard_Integer GEOMImpl_SplineDriver::Execute(TFunction_Logbook& log) const
GeomAPI_Interpolate GBC (aHCurvePoints, Standard_False, gp::Resolution()); GeomAPI_Interpolate GBC (aHCurvePoints, Standard_False, gp::Resolution());
GBC.Perform(); GBC.Perform();
if (GBC.IsDone()) if (GBC.IsDone())
aShape = BRepBuilderAPI_MakeEdge(GBC).Edge(); aShape = BRepBuilderAPI_MakeEdge(GBC.Curve()).Edge();
else else
return 0; return 0;
} }

7
src/GEOMImpl/GEOMImpl_Template.cxx
View File

@ -1,7 +1,8 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_Template.hxx"
#include "GEOM_Function.hxx" #include <GEOMImpl_Template.hxx>
#include <GEOM_Function.hxx>
#include <TopoDS_Shape.hxx> #include <TopoDS_Shape.hxx>
//======================================================================= //=======================================================================

11
src/GEOMImpl/GEOMImpl_TorusDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_TorusDriver.hxx"
#include "GEOMImpl_ITorus.hxx" #include <GEOMImpl_TorusDriver.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOMImpl_ITorus.hxx>
#include "GEOM_Function.hxx" #include <GEOMImpl_Types.hxx>
#include <GEOM_Function.hxx>
#include <BRepPrimAPI_MakeTorus.hxx> #include <BRepPrimAPI_MakeTorus.hxx>
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>

7
src/GEOMImpl/GEOMImpl_TranslateDriver.cxx
View File

@ -1,9 +1,10 @@
using namespace std; #include <Standard_Stream.hxx>
#include "GEOMImpl_TranslateDriver.hxx"
#include <GEOMImpl_TranslateDriver.hxx>
#include <GEOMImpl_ITranslate.hxx> #include <GEOMImpl_ITranslate.hxx>
#include <GEOMImpl_Types.hxx> #include <GEOMImpl_Types.hxx>
#include "GEOM_Function.hxx" #include <GEOM_Function.hxx>
#include <gp_Trsf.hxx> #include <gp_Trsf.hxx>
#include <gp_Pnt.hxx> #include <gp_Pnt.hxx>
#include <gp_Vec.hxx> #include <gp_Vec.hxx>

10
src/GEOMImpl/GEOMImpl_VectorDriver.cxx
View File

@ -1,9 +1,9 @@
#include <Standard_Stream.hxx>
using namespace std; #include <GEOMImpl_VectorDriver.hxx>
#include "GEOMImpl_VectorDriver.hxx" #include <GEOMImpl_IVector.hxx>
#include "GEOMImpl_IVector.hxx" #include <GEOMImpl_Types.hxx>
#include "GEOMImpl_Types.hxx" #include <GEOM_Function.hxx>
#include "GEOM_Function.hxx"
#include <BRep_Tool.hxx> #include <BRep_Tool.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx> #include <BRepBuilderAPI_MakeEdge.hxx>

10
src/IGESExport/IGESExport.cxx
View File

@ -12,6 +12,12 @@
#include <TCollection_AsciiString.hxx> #include <TCollection_AsciiString.hxx>
#include <TopoDS_Shape.hxx> #include <TopoDS_Shape.hxx>
#ifdef WNT
#include <SALOME_WNT.hxx>
#else
#define SALOME_WNT_EXPORT
#endif
//============================================================================= //=============================================================================
/*! /*!
* *
@ -20,9 +26,7 @@
extern "C" extern "C"
{ {
#ifdef WNT SALOME_WNT_EXPORT
__declspec(__dllexport)
#endif
int Export(const TopoDS_Shape& theShape, const TCollection_AsciiString& theFileName) int Export(const TopoDS_Shape& theShape, const TCollection_AsciiString& theFileName)
{ {
MESSAGE("Export IGES into file " << theFileName.ToCString()); MESSAGE("Export IGES into file " << theFileName.ToCString());

10
src/IGESImport/IGESImport.cxx
View File

@ -11,6 +11,12 @@
#include <TCollection_AsciiString.hxx> #include <TCollection_AsciiString.hxx>
#include <TopoDS_Shape.hxx> #include <TopoDS_Shape.hxx>
#ifdef WNT
#include <SALOME_WNT.hxx>
#else
#define SALOME_WNT_EXPORT
#endif
//============================================================================= //=============================================================================
/*! /*!
* *
@ -19,9 +25,7 @@
extern "C" extern "C"
{ {
#ifdef WNT SALOME_WNT_EXPORT
__declspec(__dllexport)
#endif
TopoDS_Shape Import (const TCollection_AsciiString& theFileName, TopoDS_Shape Import (const TCollection_AsciiString& theFileName,
TCollection_AsciiString& theError) TCollection_AsciiString& theError)
{ {

2
src/NMTTools/NMTTools_PaveFiller.cxx
View File

@ -206,7 +206,7 @@
aDEP.Do(); aDEP.Do();
// //
} }
catch (BOPTColStd_Failure& x) { catch (BOPTColStd_Failure& /*x*/) {
//QQ MESSAGE(x.Message() << flush); //QQ MESSAGE(x.Message() << flush);
} }
} }

3
src/OBJECT/GEOM_AISShape.cxx
View File

@ -26,7 +26,6 @@
// Module : GEOM // Module : GEOM
// $Header$ // $Header$
using namespace std;
/*! /*!
\class GEOM_AISShape GEOM_AISShape.hxx \class GEOM_AISShape GEOM_AISShape.hxx
\brief .... \brief ....
@ -59,6 +58,8 @@ using namespace std;
#include <TopoDS_Shape.hxx> #include <TopoDS_Shape.hxx>
#include <TopTools_IndexedMapOfShape.hxx> #include <TopTools_IndexedMapOfShape.hxx>
using namespace std;
static void getEntityOwners( const Handle(AIS_InteractiveObject)& theObj, static void getEntityOwners( const Handle(AIS_InteractiveObject)& theObj,
const Handle(AIS_InteractiveContext)& theIC, const Handle(AIS_InteractiveContext)& theIC,
SelectMgr_IndexedMapOfOwner& theMap ) SelectMgr_IndexedMapOfOwner& theMap )

2
src/OBJECT/GEOM_Actor.cxx
View File

@ -185,7 +185,7 @@ void GEOM_Actor::SetShadingProperty(vtkProperty* Prop) {
// Mapper creating function // Mapper creating function
//------------------------------------------------------------- //-------------------------------------------------------------
void GEOM_Actor::CreateMapper(int theMode) { void GEOM_Actor::CreateMapper(int theMode) {
this->myIsInfinite = myShape.Infinite(); this->myIsInfinite = (bool)myShape.Infinite();
if(myShape.ShapeType() == TopAbs_VERTEX) { if(myShape.ShapeType() == TopAbs_VERTEX) {
gp_Pnt aPnt = BRep_Tool::Pnt(TopoDS::Vertex(myShape)); gp_Pnt aPnt = BRep_Tool::Pnt(TopoDS::Vertex(myShape));
this->SetPosition(aPnt.X(),aPnt.Y(),aPnt.Z()); this->SetPosition(aPnt.X(),aPnt.Y(),aPnt.Z());

8
src/OBJECT/GEOM_Actor.h
View File

@ -38,13 +38,13 @@
class vtkCamera; class vtkCamera;
class TopoDS_Shape; class TopoDS_Shape;
#ifdef _WIN_32 #ifdef WNT
#define VTKOCC_EXPORT __declspec (dllexport) #include <SALOME_WNT.hxx>
#else #else
#define VTKOCC_EXPORT #define SALOME_WNT_EXPORT
#endif #endif
class VTKOCC_EXPORT GEOM_Actor : public SALOME_Actor { class SALOME_WNT_EXPORT GEOM_Actor : public SALOME_Actor {
public: public:
vtkTypeMacro(GEOM_Actor,SALOME_Actor); vtkTypeMacro(GEOM_Actor,SALOME_Actor);

2
src/OBJECT/GEOM_AssemblyBuilder.cxx
View File

@ -26,7 +26,6 @@
// Module : GEOM // Module : GEOM
// $Header$ // $Header$
using namespace std;
/*! /*!
\class GEOM_AssemblyBuilder GEOM_AssemblyBuilder.h \class GEOM_AssemblyBuilder GEOM_AssemblyBuilder.h
\brief .... \brief ....
@ -48,6 +47,7 @@ using namespace std;
#include <TopTools_ListOfShape.hxx> #include <TopTools_ListOfShape.hxx>
#include <TopoDS_Iterator.hxx> #include <TopoDS_Iterator.hxx>
using namespace std;
// SALOME // SALOME
#define MAX2(X, Y) ( Abs(X) > Abs(Y)? Abs(X) : Abs(Y) ) #define MAX2(X, Y) ( Abs(X) > Abs(Y)? Abs(X) : Abs(Y) )

8
src/OBJECT/GEOM_AssemblyBuilder.h
View File

@ -34,7 +34,13 @@
#include <TopoDS.hxx> #include <TopoDS.hxx>
#include <TopoDS_Shape.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: private:

3
src/OBJECT/GEOM_InteractiveObject.cxx
View File

@ -26,7 +26,6 @@
// Module : GEOM // Module : GEOM
// $Header$ // $Header$
using namespace std;
/*! /*!
\class GEOM_InteractiveObject GEOM_InteractiveObject.hxx \class GEOM_InteractiveObject GEOM_InteractiveObject.hxx
\brief .... \brief ....
@ -34,6 +33,8 @@ using namespace std;
#include "GEOM_InteractiveObject.ixx" #include "GEOM_InteractiveObject.ixx"
using namespace std;
GEOM_InteractiveObject::GEOM_InteractiveObject() GEOM_InteractiveObject::GEOM_InteractiveObject()
: SALOME_InteractiveObject() : SALOME_InteractiveObject()
{ {

9
src/OBJECT/GEOM_VTKTrihedron.hxx
View File

@ -33,6 +33,13 @@
#include "SALOME_Actor.h" #include "SALOME_Actor.h"
#include "VTKViewer_Trihedron.h" #include "VTKViewer_Trihedron.h"
#ifdef WNT
#include <SALOME_WNT.hxx>
#else
#define SALOME_WNT_EXPORT
#endif
class vtkActorCollection; class vtkActorCollection;
class vtkRenderer; class vtkRenderer;
class vtkPolyDataMapper; class vtkPolyDataMapper;
@ -43,7 +50,7 @@ class vtkPolyDataMapper;
Placement of trihedron is chahged with SetPlacement() method Placement of trihedron is chahged with SetPlacement() method
*/ */
class GEOM_VTKTrihedron : public SALOME_Actor class SALOME_WNT_EXPORT GEOM_VTKTrihedron : public SALOME_Actor
{ {
protected: protected:

471
src/SKETCHER/Sketcher_Profile.cxx
View File

@ -26,8 +26,9 @@
// Module : GEOM // Module : GEOM
// $Header: // $Header:
using namespace std; #include <Standard_Stream.hxx>
#include "Sketcher_Profile.hxx"
#include <Sketcher_Profile.hxx>
#include <TopoDS_Vertex.hxx> #include <TopoDS_Vertex.hxx>
#include <TopoDS_Face.hxx> #include <TopoDS_Face.hxx>
@ -90,267 +91,272 @@ Sketcher_Profile::Sketcher_Profile(const char* aCmd)
TCollection_AsciiString aCommand(CORBA::string_dup(aCmd)); TCollection_AsciiString aCommand(CORBA::string_dup(aCmd));
TCollection_AsciiString aToken = aCommand.Token(":", 1); TCollection_AsciiString aToken = aCommand.Token(":", 1);
int n = 0; int n = 0;
TCollection_AsciiString aTab[aCommand.Length()]; // porting to WNT
while(aToken.Length() != 0) { TCollection_AsciiString* aTab = 0;
if(aCommand.Token(":", n + 1).Length() > 0) if ( aCommand.Length() )
aTab[n] = aCommand.Token(":", n + 1); {
aToken = aCommand.Token(":", ++n); aTab = new TCollection_AsciiString[ aCommand.Length() ];
}
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);
while(aToken.Length() != 0) { while(aToken.Length() != 0) {
if(aTab[i].Token(" ", n1 + 1).Length() > 0) if(aCommand.Token(":", n + 1).Length() > 0)
a[n1] = aTab[i].Token(" ", n1 + 1); aTab[n] = aCommand.Token(":", n + 1);
aToken = aTab[i].Token(" ", ++n1); aToken = aCommand.Token(":", ++n);
} }
n1 = n1 - 1; n = n - 1;
}
switch(a[0].Value(1)) if ( aTab && aTab[0].Length() )
{ while(i < n) {
case 'F': Standard_Real length = 0, radius = 0, angle = 0;
{ move = point;
if (n1 != 3) goto badargs;
if (!first) { int n1 = 0;
MESSAGE("profile : The F instruction must precede all moves"); TCollection_AsciiString* a = new TCollection_AsciiString[ aTab[0].Length() ];
return; aToken = aTab[i].Token(" ", 1);
} while(aToken.Length() != 0) {
x0 = x = a[1].RealValue(); if(aTab[i].Token(" ", n1 + 1).Length() > 0)
y0 = y = a[2].RealValue(); a[n1] = aTab[i].Token(" ", n1 + 1);
stayfirst = Standard_True; aToken = aTab[i].Token(" ", ++n1);
break;
} }
case 'O': n1 = n1 - 1;
switch(a[0].Value(1))
{ {
if (n1 != 4) goto badargs; case 'F':
P.SetLocation(gp_Pnt(a[1].RealValue(), a[2].RealValue(), a[3].RealValue())); {
stayfirst = Standard_True; if (n1 != 3) goto badargs;
break; if (!first) {
} MESSAGE("profile : The F instruction must precede all moves");
case 'P': return;
{ }
if (n1 != 7) goto badargs; x0 = x = a[1].RealValue();
gp_Vec vn(a[1].RealValue(), a[2].RealValue(), a[3].RealValue()); y0 = y = a[2].RealValue();
gp_Vec vx(a[4].RealValue(), a[5].RealValue(), a[6].RealValue()); stayfirst = Standard_True;
if (vn.Magnitude() <= Precision::Confusion() || vx.Magnitude() <= Precision::Confusion()) { break;
MESSAGE("profile : null direction"); }
return; case 'O':
} {
gp_Ax2 ax(P.Location(), vn, vx); if (n1 != 4) goto badargs;
P.SetPosition(ax); P.SetLocation(gp_Pnt(a[1].RealValue(), a[2].RealValue(), a[3].RealValue()));
stayfirst = Standard_True; stayfirst = Standard_True;
break; break;
} }
case 'X': case 'P':
{ {
if (n1 != 2) goto badargs; if (n1 != 7) goto badargs;
length = a[1].RealValue(); gp_Vec vn(a[1].RealValue(), a[2].RealValue(), a[3].RealValue());
if (a[0] == "XX") gp_Vec vx(a[4].RealValue(), a[5].RealValue(), a[6].RealValue());
length -= x; if (vn.Magnitude() <= Precision::Confusion() || vx.Magnitude() <= Precision::Confusion()) {
dx = 1; dy = 0; MESSAGE("profile : null direction");
move = line; return;
break; }
} gp_Ax2 ax(P.Location(), vn, vx);
case 'Y': P.SetPosition(ax);
{ stayfirst = Standard_True;
if (n1 != 2) goto badargs; break;
length = a[1].RealValue(); }
if (a[0] == "YY") case 'X':
length -= y; {
dx = 0; dy = 1; if (n1 != 2) goto badargs;
move = line; length = a[1].RealValue();
break; if (a[0] == "XX")
} length -= x;
case 'L': dx = 1; dy = 0;
{ move = line;
if (n1 != 2) goto badargs; break;
length = a[1].RealValue(); }
if (Abs(length) > Precision::Confusion()) case 'Y':
move = line; {
else if (n1 != 2) goto badargs;
move = none; length = a[1].RealValue();
break; if (a[0] == "YY")
} length -= y;
case 'T': dx = 0; dy = 1;
{ move = line;
if (n1 != 3) goto badargs; break;
Standard_Real vx = a[1].RealValue(); }
Standard_Real vy = a[2].RealValue(); case 'L':
if (a[0] == "TT") { {
vx -= x; if (n1 != 2) goto badargs;
vy -= y; length = a[1].RealValue();
} if (Abs(length) > Precision::Confusion())
length = Sqrt(vx * vx + vy * vy); move = line;
if (length > Precision::Confusion()) { else
move = line; move = none;
dx = vx / length; break;
dy = vy / length; }
} case 'T':
else {
move = none; if (n1 != 3) goto badargs;
break; Standard_Real vx = a[1].RealValue();
} Standard_Real vy = a[2].RealValue();
case 'R': if (a[0] == "TT") {
{ vx -= x;
if (n1 != 2) goto badargs; vy -= y;
angle = a[1].RealValue() * PI180; }
if (a[0] == "RR") { length = Sqrt(vx * vx + vy * vy);
dx = Cos(angle); if (length > Precision::Confusion()) {
dy = Sin(angle); move = line;
} dx = vx / length;
else { dy = vy / length;
Standard_Real c = Cos(angle); }
Standard_Real s = Sin(angle); else
Standard_Real t = c * dx - s * dy; move = none;
dy = s * dx + c * dy; break;
dx = t; }
} case 'R':
break; {
} if (n1 != 2) goto badargs;
case 'D': angle = a[1].RealValue() * PI180;
{ if (a[0] == "RR") {
if (n1 != 3) goto badargs; dx = Cos(angle);
Standard_Real vx = a[1].RealValue(); dy = Sin(angle);
Standard_Real vy = a[2].RealValue(); }
length = Sqrt(vx * vx + vy * vy); else {
if (length > Precision::Confusion()) { Standard_Real c = Cos(angle);
dx = vx / length; Standard_Real s = Sin(angle);
dy = vy / length; Standard_Real t = c * dx - s * dy;
} dy = s * dx + c * dy;
else dx = t;
move = none; }
break; break;
} }
case 'C': case 'D':
{ {
if (n1 != 3) goto badargs; if (n1 != 3) goto badargs;
radius = a[1].RealValue(); Standard_Real vx = a[1].RealValue();
if (Abs(radius) > Precision::Confusion()) { Standard_Real vy = a[2].RealValue();
angle = a[2].RealValue() * PI180; length = Sqrt(vx * vx + vy * vy);
move = circle; if (length > Precision::Confusion()) {
} dx = vx / length;
else dy = vy / length;
move = none; }
break; else
} move = none;
case 'I': break;
{ }
if (n1 != 2) goto badargs; case 'C':
length = a[1].RealValue(); {
if (a[0] == "IX") { if (n1 != 3) goto badargs;
if (Abs(dx) < Precision::Confusion()) { radius = a[1].RealValue();
MESSAGE("profile : cannot intersect, arg "<<i-1); if (Abs(radius) > Precision::Confusion()) {
return; angle = a[2].RealValue() * PI180;
} move = circle;
length = (length - x) / dx; }
} else
else if (a[0] == "IY") { move = none;
if (Abs(dy) < Precision::Confusion()) { break;
MESSAGE("profile : cannot intersect, arg "<<i-1); }
return; case 'I':
} {
length = (length - y) / dy; if (n1 != 2) goto badargs;
} length = a[1].RealValue();
if (Abs(length) > Precision::Confusion()) if (a[0] == "IX") {
move = line; if (Abs(dx) < Precision::Confusion()) {
else MESSAGE("profile : cannot intersect, arg "<<i-1);
move = none; return;
break; }
} length = (length - x) / dx;
case 'W': }
{ else if (a[0] == "IY") {
if (a[0] == "WW") if (Abs(dy) < Precision::Confusion()) {
close = Standard_True; MESSAGE("profile : cannot intersect, arg "<<i-1);
else if(a[0] == "WF") { return;
close = Standard_True; }
face = Standard_True; length = (length - y) / dy;
} }
i = n - 1; if (Abs(length) > Precision::Confusion())
break; move = line;
} else
default: move = none;
{ break;
MESSAGE("profile : unknown code "<<a[i]); }
return; 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) switch (move)
{ {
case line : case line :
{ {
if (length < 0) { if (length < 0) {
length = -length; length = -length;
dx = -dx; dx = -dx;
dy = -dy; dy = -dy;
} }
Handle(Geom2d_Line) l = new Geom2d_Line(gp_Pnt2d(x,y),gp_Dir2d(dx,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); BRepBuilderAPI_MakeEdge ME (GeomAPI::To3d(l,P),0,length);
if (!ME.IsDone()) if (!ME.IsDone())
return; return;
MW.Add(ME); MW.Add(ME);
x += length*dx; x += length*dx;
y += length*dy; y += length*dy;
break; break;
} }
case circle : case circle :
{ {
Standard_Boolean sense = Standard_True; Standard_Boolean sense = Standard_True;
if (radius < 0) { if (radius < 0) {
radius = -radius; radius = -radius;
sense = !sense; sense = !sense;
dx = -dx; dx = -dx;
dy = -dy; dy = -dy;
} }
gp_Ax2d ax(gp_Pnt2d(x-radius*dy,y+radius*dx),gp_Dir2d(dy,-dx)); gp_Ax2d ax(gp_Pnt2d(x-radius*dy,y+radius*dx),gp_Dir2d(dy,-dx));
if (angle < 0) { if (angle < 0) {
angle = -angle; angle = -angle;
sense = !sense; sense = !sense;
} }
Handle(Geom2d_Circle) c = new Geom2d_Circle(ax,radius,sense); Handle(Geom2d_Circle) c = new Geom2d_Circle(ax,radius,sense);
BRepBuilderAPI_MakeEdge ME (GeomAPI::To3d(c,P),0,angle); BRepBuilderAPI_MakeEdge ME (GeomAPI::To3d(c,P),0,angle);
if (!ME.IsDone()) if (!ME.IsDone())
return; return;
MW.Add(ME); MW.Add(ME);
gp_Pnt2d p; gp_Pnt2d p;
gp_Vec2d v; gp_Vec2d v;
c->D1(angle,p,v); c->D1(angle,p,v);
x = p.X(); x = p.X();
y = p.Y(); y = p.Y();
dx = v.X() / radius; dx = v.X() / radius;
dy = v.Y() / radius; dy = v.Y() / radius;
break; break;
} }
case point: case point:
{ {
MP = BRepBuilderAPI_MakeVertex(gp_Pnt(x, y, 0.0)); MP = BRepBuilderAPI_MakeVertex(gp_Pnt(x, y, 0.0));
break; break;
} }
case none: case none:
{ {
i = n - 1; i = n - 1;
break; break;
} }
} }
// update first // update first
first = stayfirst; first = stayfirst;
stayfirst = Standard_False; stayfirst = Standard_False;
if(!(dx == 0 && dy == 0)) if(!(dx == 0 && dy == 0))
myLastDir.SetCoord(dx, dy, 0.0); myLastDir.SetCoord(dx, dy, 0.0);
else else
return; return;
myLastPoint.SetX(x); myLastPoint.SetX(x);
myLastPoint.SetY(y); myLastPoint.SetY(y);
// next segment.... // next segment....
i++; i++;
if ((i == n) && close) { if ((i == n) && close) {
@ -360,13 +366,16 @@ Sketcher_Profile::Sketcher_Profile(const char* aCmd)
length = Sqrt(dx * dx + dy * dy); length = Sqrt(dx * dx + dy * dy);
move = line; move = line;
if (length > Precision::Confusion()) { if (length > Precision::Confusion()) {
dx = dx / length; dx = dx / length;
dy = dy / length; dy = dy / length;
goto again; goto again;
} }
} }
delete a;
} }
delete aTab;
aTab = 0;
// get the result, face or wire // get the result, face or wire
if (move == none) { if (move == none) {
return; return;

12
src/SKETCHER/Sketcher_Profile.hxx
View File

@ -34,8 +34,8 @@ class Sketcher_Profile
{ {
public: public:
Sketcher_Profile(); Standard_EXPORT Sketcher_Profile();
Sketcher_Profile(const char* aCmd); Standard_EXPORT Sketcher_Profile(const char* aCmd);
private: private:
gp_Pnt myLastPoint; gp_Pnt myLastPoint;
@ -45,10 +45,10 @@ private:
bool myOK; bool myOK;
public: public:
gp_Pnt GetLastPoint(){return myLastPoint;}; Standard_EXPORT gp_Pnt GetLastPoint(){return myLastPoint;};
gp_Dir GetLastDir(){return myLastDir;}; Standard_EXPORT gp_Dir GetLastDir(){return myLastDir;};
const TopoDS_Shape& GetShape(){return myShape;}; Standard_EXPORT const TopoDS_Shape& GetShape(){return myShape;};
bool IsDone(){return myOK;}; Standard_EXPORT bool IsDone(){return myOK;};
}; };

10
src/STEPExport/STEPExport.cxx
View File

@ -12,6 +12,12 @@
#include <TCollection_AsciiString.hxx> #include <TCollection_AsciiString.hxx>
#include <TopoDS_Shape.hxx> #include <TopoDS_Shape.hxx>
#ifdef WNT
#include <SALOME_WNT.hxx>
#else
#define SALOME_WNT_EXPORT
#endif
//============================================================================= //=============================================================================
/*! /*!
* *
@ -20,9 +26,7 @@
extern "C" extern "C"
{ {
#ifdef WNT SALOME_WNT_EXPORT
__declspec(__dllexport)
#endif
int Export(const TopoDS_Shape& theShape, const TCollection_AsciiString& theFileName) int Export(const TopoDS_Shape& theShape, const TCollection_AsciiString& theFileName)
{ {
MESSAGE("Export STEP into file " << theFileName.ToCString()); MESSAGE("Export STEP into file " << theFileName.ToCString());

10
src/STEPImport/STEPImport.cxx
View File

@ -17,6 +17,12 @@
#include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC #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() * Import()
@ -25,9 +31,7 @@
extern "C" extern "C"
{ {
#ifdef WNT SALOME_WNT_EXPORT
__declspec(__dllexport)
#endif
TopoDS_Shape Import (const TCollection_AsciiString& theFileName, TopoDS_Shape Import (const TCollection_AsciiString& theFileName,
TCollection_AsciiString& theError) TCollection_AsciiString& theError)
{ {