Missing headers added; includes of headers "Handle_...hxx" removed.
Misuses of macro Handle() and its use in typedefs corrected.
Alias classes Profile and Option are removed from IFSelect; ones defined in MoniTool are used directly.
Removed header files defining only Handle classes (except Image_PixMap_Handle.hxx)
Classes SelectMgr_BaseFrustum and now inherit Standard_Transient and can be manipulated by Handle (not NCollection_Handle)
Fixed reference-type local variable pointing to temporary object
Use of handle in conditional expressions and comparisons to NULL are replaced by call to method IsNull()
#include <TopoDS_Face.hxx>
#include <TopoDS_Vertex.hxx>
+class AIS_AngleDimension;
DEFINE_STANDARD_HANDLE (AIS_AngleDimension, AIS_Dimension)
//! Angle dimension. Can be constructed:
#include <Standard_Macro.hxx>
#include <Standard_Type.hxx>
+class AIS_DiameterDimension;
DEFINE_STANDARD_HANDLE (AIS_DiameterDimension, AIS_Dimension)
//! Diameter dimension. Can be constructued:
#include <NCollection_Sequence.hxx>
#include <NCollection_Handle.hxx>
+class AIS_Dimension;
DEFINE_STANDARD_HANDLE(AIS_Dimension, AIS_InteractiveObject)
//! AIS_Dimension is a base class for 2D presentations of linear (length, diameter, radius)
#include <Aspect_InteriorStyle.hxx>
#include <Prs3d_ShadingAspect.hxx>
-
+#include <Prs3d_IsoAspect.hxx>
static Handle(Prs3d_LineAspect) GetLineAspect(const Handle(Prs3d_Drawer)& Dr,
const AIS_TypeOfAttribute Att)
anAffinity->SetVisible (aCView->ViewId, theIsVisible == Standard_True);
if (theIsVisible)
{
- theView->View()->ChangeHiddenObjects()->Remove (theIObj);
+ theView->View()->ChangeHiddenObjects()->Remove (theIObj.get());
}
else
{
- theView->View()->ChangeHiddenObjects()->Add (theIObj);
+ theView->View()->ChangeHiddenObjects()->Add (theIObj.get());
}
}
myMainVwr->Viewer()->UnregisterObject (theIObj);
for (myMainVwr->InitDefinedViews(); myMainVwr->MoreDefinedViews(); myMainVwr->NextDefinedViews())
{
- myMainVwr->DefinedView()->View()->ChangeHiddenObjects()->Remove (theIObj);
+ myMainVwr->DefinedView()->View()->ChangeHiddenObjects()->Remove (theIObj.get());
}
if (theToUpdateviewer
theObj->Disconnect (theObjToDisconnect);
mgrSelector->Remove (theObjToDisconnect);
}
- else if (theAssembly->IsInstance ("AIS_ConnectedInteractive") && theObjToDisconnect == NULL)
+ else if (theAssembly->IsInstance ("AIS_ConnectedInteractive") && theObjToDisconnect.IsNull())
{
const Handle(AIS_ConnectedInteractive)& theObj =
Handle(AIS_ConnectedInteractive)::DownCast (theAssembly);
//=======================================================================
Standard_Integer AIS_InteractiveContext::PurgeViewer(const Handle(V3d_Viewer)& Vwr)
{
- const Handle(Graphic3d_StructureManager)& GSM = Vwr->Viewer();
+ Handle(Graphic3d_StructureManager) GSM = Vwr->Viewer();
Standard_Integer NbCleared(0);
Graphic3d_MapOfStructure SOS;
GSM->DisplayedStructures(SOS);
#include <BRepAdaptor_Curve.hxx>
#include <Geom_Ellipse.hxx>
+#include <Geom_OffsetCurve.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <Geom_Plane.hxx>
#include <Geom_Surface.hxx>
else
parStart = par;
- Handle(Geom_TrimmedCurve)TrimCurve;
+ Handle(Geom_Curve)TrimCurve;
if(myIsOffset)
{
Handle(Geom_Curve) aCurve = myOffsetCurve;
#include <BRepAdaptor_Curve.hxx>
#include <Geom_Ellipse.hxx>
+#include <Geom_OffsetCurve.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <Geom_Plane.hxx>
#include <Geom_Surface.hxx>
}
else
parStart = par;
- Handle(Geom_TrimmedCurve)TrimCurve;
+ Handle(Geom_Curve)TrimCurve;
if(myIsOffset)
{
Handle(Geom_Curve) aCurve = myOffsetCurve;
#include <TColgp_HArray1OfDir.hxx>
#include <TColgp_HArray1OfPnt.hxx>
+class AIS_PointCloud;
DEFINE_STANDARD_HANDLE(AIS_PointCloud, AIS_InteractiveObject)
//! Interactive object for set of points.
#include <Standard.hxx>
#include <Standard_Macro.hxx>
+class AIS_RadiusDimension;
DEFINE_STANDARD_HANDLE (AIS_RadiusDimension,AIS_Dimension)
//! Radius dimension. Can be constructued:
const BOPDS_Curve& theNC,
const Standard_Real theTolR3D,
const BOPDS_IndexedMapOfPaveBlock& theMPBOnIn,
- Handle(BOPDS_PaveBlock&) aPBOut)
+ Handle(BOPDS_PaveBlock)& aPBOut)
{
Standard_Boolean bRet;
Standard_Real aT1, aT2, aTm, aTx;
}
//
Handle(BOPDS_CommonBlock) aCB=myDS->CommonBlock(aPB);
- if (!aCB) {
+ if (aCB.IsNull()) {
continue;
}
//
#include <NCollection_List.hxx>
+class BOPDS_PaveBlock;
typedef NCollection_List<Handle(BOPDS_PaveBlock)> BOPDS_ListOfPaveBlock;
typedef BOPDS_ListOfPaveBlock::Iterator BOPDS_ListIteratorOfListOfPaveBlock;
#include <Geom2d_Parabola.hxx>
#include <Geom2d_Hyperbola.hxx>
#include <Geom2d_TrimmedCurve.hxx>
+#include <Geom2d_BSplineCurve.hxx>
#include <Geom2dAdaptor.hxx>
#include <BRepCheck.hxx>
#include <BRepCheck_ListOfStatus.hxx>
-
+class BRepCheck_HSC;
DEFINE_STANDARD_HANDLE(BRepCheck_HSC, MMgt_TShared);
//=======================================================================
//class : BRepCheck_HSC
#include <Geom2d_BezierCurve.hxx>
#include <Geom2d_TrimmedCurve.hxx>
-#include <Geom_Surface.hxx>
+#include <Geom_BSplineSurface.hxx>
#include <TColgp_SequenceOfXY.hxx>
#include <GeomPlate_PlateG0Criterion.hxx>
#include <Geom_BezierCurve.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Geom2d_Line.hxx>
-#include <Geom2d_Curve.hxx>
+#include <Geom2d_BSplineCurve.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <GeomLib.hxx>
#include <GeomLib_IsPlanarSurface.hxx>
//function : Init
//purpose :
//=======================================================================
-void BRepGProp_Gauss::Init(Handle(Vector)& theOutVec,
+void BRepGProp_Gauss::Init(NCollection_Handle<math_Vector>& theOutVec,
const Standard_Real theValue,
const Standard_Integer theFirst,
const Standard_Integer theLast)
const TColStd_Array1OfReal& theKnots,
const Standard_Integer theNumSubs,
InertiaArray& theInerts,
- Handle(Vector)& theParam1,
- Handle(Vector)& theParam2,
- Handle(Vector)& theError,
- Handle(Vector)& theCommonError)
+ NCollection_Handle<math_Vector>& theParam1,
+ NCollection_Handle<math_Vector>& theParam2,
+ NCollection_Handle<math_Vector>& theError,
+ NCollection_Handle<math_Vector>& theCommonError)
{
const Standard_Integer aSize =
Max(theKnots.Upper(), MaxSubs(theKnots.Upper() - 1, theNumSubs));
InertiaArray anInertiaU = new NCollection_Array1<Inertia>(1, SM);
// Prepare Gauss points and weights
- Handle(Vector) LGaussP[2];
- Handle(Vector) LGaussW[2];
- Handle(Vector) UGaussP[2];
- Handle(Vector) UGaussW[2];
+ NCollection_Handle<math_Vector> LGaussP[2];
+ NCollection_Handle<math_Vector> LGaussW[2];
+ NCollection_Handle<math_Vector> UGaussP[2];
+ NCollection_Handle<math_Vector> UGaussW[2];
const Standard_Integer aNbGaussPoint =
RealToInt(Ceiling(ERROR_ALGEBR_RATIO * GPM));
UGaussW[0] = new math_Vector(1, GPM);
UGaussW[1] = new math_Vector(1, aNbGaussPoint);
- Handle(Vector) L1 = new math_Vector(1, SM);
- Handle(Vector) L2 = new math_Vector(1, SM);
- Handle(Vector) U1 = new math_Vector(1, SM);
- Handle(Vector) U2 = new math_Vector(1, SM);
+ NCollection_Handle<math_Vector> L1 = new math_Vector(1, SM);
+ NCollection_Handle<math_Vector> L2 = new math_Vector(1, SM);
+ NCollection_Handle<math_Vector> U1 = new math_Vector(1, SM);
+ NCollection_Handle<math_Vector> U2 = new math_Vector(1, SM);
- Handle(Vector) ErrL = new math_Vector(1, SM, 0.0);
- Handle(Vector) ErrU = new math_Vector(1, SM, 0.0);
- Handle(Vector) ErrUL = new math_Vector(1, SM, 0.0);
+ NCollection_Handle<math_Vector> ErrL = new math_Vector(1, SM, 0.0);
+ NCollection_Handle<math_Vector> ErrU = new math_Vector(1, SM, 0.0);
+ NCollection_Handle<math_Vector> ErrUL = new math_Vector(1, SM, 0.0);
// Face parametrization in U and V direction
Standard_Real BV1, BV2, BU1, BU2;
if (Abs(u2 - u1) < EPS_PARAM)
continue;
- Handle(Vector) aDummy;
+ NCollection_Handle<math_Vector> aDummy;
iUSubEnd = FillIntervalBounds(u1, u2, UKnots, NumSubs, anInertiaU, U1, U2, ErrU, aDummy);
UMaxSubs = BRepGProp_Gauss::MaxSubs(iUSubEnd);
const Standard_Integer theCoeff = 32);
static void Init(
- Handle(Vector)& theOutVec,
+ NCollection_Handle<math_Vector>& theOutVec,
const Standard_Real theValue,
const Standard_Integer theFirst = 0,
const Standard_Integer theLast = 0);
const TColStd_Array1OfReal& theKnots,
const Standard_Integer theNumSubs,
InertiaArray& theInerts,
- Handle(Vector)& theParam1,
- Handle(Vector)& theParam2,
- Handle(Vector)& theError,
- Handle(Vector)& theCommonError);
+ NCollection_Handle<math_Vector>& theParam1,
+ NCollection_Handle<math_Vector>& theParam2,
+ NCollection_Handle<math_Vector>& theError,
+ NCollection_Handle<math_Vector>& theCommonError);
private: //! @name private fields
# include <MAT_ListOfBisector.hxx>
# include <MAT_DataMapOfIntegerBasicElt.hxx>
# include <MAT_DataMapIteratorOfDataMapOfIntegerBasicElt.hxx>
-# include <Geom2d_Curve.hxx>
+# include <Geom2d_TrimmedCurve.hxx>
# include <gp_Pnt2d.hxx>
# include <TColGeom2d_SequenceOfGeometry.hxx>
# include <Precision.hxx>
if(isFirst)
{
gp_Pnt2d aP = theC2d->Value(theC2d->LastParameter());
- theC2d = GCE2d_MakeSegment(theP, aP);
+ theC2d = GCE2d_MakeSegment(theP, aP).Value();
}
else
{
gp_Pnt2d aP = theC2d->Value(theC2d->FirstParameter());
- theC2d = GCE2d_MakeSegment(aP, theP);
+ theC2d = GCE2d_MakeSegment(aP, theP).Value();
}
}
else
class BRepMesh_Vertex;
class TopoDS_Edge;
class TopoDS_Vertex;
+class BRepMesh_FaceAttribute;
class BRepMesh_VertexInspector;
class BRepMesh_CircleInspector;
class BRepMesh_Classifier;
class Poly_PolygonOnTriangulation;
class TopoDS_Edge;
class TopoDS_Face;
+class Geom2d_Curve;
//! Auxiliary class implements functionality retrieving tessellated
//! representation of an edge stored in polygon.
#include <GeomLib.hxx>
#include <Geom_Surface.hxx>
#include <Geom_BSplineSurface.hxx>
+#include <Geom_BezierSurface.hxx>
#include <GCPnts_TangentialDeflection.hxx>
#include <GCPnts_AbscissaPoint.hxx>
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Macro.hxx>
+#include <BRepAdaptor_HSurface.hxx>
#include <BRepMesh_FaceAttribute.hxx>
#include <BRepMesh.hxx>
+class Poly_Triangulation;
class TopoDS_Face;
class TopoDS_Edge;
class Bnd_Box;
#include <Geom_Line.hxx>
#include <Geom_Plane.hxx>
#include <Geom_TrimmedCurve.hxx>
+#include <Geom_BSplineCurve.hxx>
#include <GeomConvert_CompCurveToBSplineCurve.hxx>
#include <Precision.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
#include <Geom_SphericalSurface.hxx>
+#include <Geom_CylindricalSurface.hxx>
#include <TopoDS_Wire.hxx>
#include <BRepTools_Substitution.hxx>
#include <Geom_TrimmedCurve.hxx>
//=======================================================================
static void ComputeCurve3d(TopoDS_Edge Edge,
- Handle(Geom2d_Curve) Curve,
- Handle(Geom_Surface) Surf,
+ const Handle(Geom2d_Curve)& Curve,
+ const Handle(Geom_Surface)& Surf,
const TopLoc_Location Loc,
Standard_Real Tol)
{
#include <GeomAbs_Shape.hxx>
#include <Geom_Curve.hxx>
+#include <Geom_Plane.hxx>
#include <Geom_BSplineSurface.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <Geom_BezierCurve.hxx>
#include <ProjLib_ComputeApproxOnPolarSurface.hxx>
#include <DrawTrSurf.hxx>
+#include <Geom_Plane.hxx>
#include <Draw_Segment3D.hxx>
#include <Draw_Marker3D.hxx>
for (i=1;i<=nb;i++)
{Standard_Integer s=aRakk.NbSection(i);
for (j=1;j<=s;j++)
- {Handle(Geom_TrimmedCurve Sec);
+ {Handle(Geom_TrimmedCurve) Sec;
aRakk.Section(i,j,Sec);
Sprintf(localname, "%s%d%d" ,"sec",i,j);
temp =localname;
#include <gp_Trsf.hxx>
#include <BRepTools_TrsfModification.hxx>
#include <Message_ProgressSentry.hxx>
-
+#include <Geom_Surface.hxx>
//=======================================================================
#include <TColStd_HArray1OfReal.hxx>
#include <Poly_Triangulation.hxx>
#include <Poly_PolygonOnTriangulation.hxx>
+#include <Poly_Polygon2D.hxx>
#include <Message_ProgressIndicator.hxx>
#include <Message_ProgressSentry.hxx>
#include <BVH_SweepPlaneBuilder.hxx>
#include <BVH_SpatialMedianBuilder.hxx>
+#include <Standard_Real.hxx>
+
// Specific instantiations of struct templates to avoid compilation warnings
template class BVH_Box<Standard_Real, 2>;
#include <BinLDrivers.hxx>
#include <BinTObjDrivers.hxx>
-IMPLEMENT_STANDARD_HANDLE (BinTObjDrivers_DocumentRetrievalDriver,
- BinLDrivers_DocumentRetrievalDriver)
-IMPLEMENT_STANDARD_RTTIEXT(BinTObjDrivers_DocumentRetrievalDriver,
- BinLDrivers_DocumentRetrievalDriver)
-
//=======================================================================
//function : BinTObjDrivers_DocumentRetrievalDriver
//purpose :
#include <BinLDrivers.hxx>
#include <BinTObjDrivers.hxx>
-IMPLEMENT_STANDARD_HANDLE (BinTObjDrivers_DocumentStorageDriver,
- BinLDrivers_DocumentStorageDriver)
-IMPLEMENT_STANDARD_RTTIEXT(BinTObjDrivers_DocumentStorageDriver,
- BinLDrivers_DocumentStorageDriver)
-
//=======================================================================
//function : BinTObjDrivers_DocumentStorageDriver
//purpose :
#include <Poly_PolygonOnTriangulation.hxx>
#include <Poly_Polygon3D.hxx>
#include <Poly_Triangulation.hxx>
+#include <Poly_Polygon2D.hxx>
#include <BRepTools.hxx>
#include <BRep_Tool.hxx>
#include <BRep_TVertex.hxx>
#include <Precision.hxx>
#include <gp_Pnt.hxx>
#include <GC_MakeLine.hxx>
+#include <Geom_Line.hxx>
#include <BRep_Tool.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx>
#include <TopoDS_Iterator.hxx>
#include <ElCLib.hxx>
#include <Geom_BSplineCurve.hxx>
+#include <Geom_BSplineSurface.hxx>
#include <Geom_Line.hxx>
#include <Geom_Plane.hxx>
#include <Geom2d_Curve.hxx>
{
GeomAdaptor_Surface& s1 = hs1->ChangeSurface();
GeomAdaptor_Surface& s2 = hs2->ChangeSurface();
- const Handle(Geom_Surface&) surf = s1.Surface();
+ const Handle(Geom_Surface)& surf = s1.Surface();
Standard_Real ud,uf,vd,vf;
surf->Bounds(ud,uf,vd,vf);
Standard_Real milmoins = 0.51*vd+0.49*vf, milplus = 0.49*vd+0.51*vf;
#include <Geom2d_Line.hxx>
#include <Geom_Line.hxx>
#include <Geom_Curve.hxx>
+#include <Geom_BSplineSurface.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <GeomInt_IntSS.hxx>
#include <GeomLib.hxx>
for(;trouve;) {
const HatchGen_PointOnElement& PEtemp = pPH->Point(LeType);
IE = PEtemp.Index();
- Handle(BRepAdaptor_HCurve2d) HE = Handle(BRepAdaptor_HCurve2d::DownCast(M(IE)));
+ Handle(BRepAdaptor_HCurve2d) HE = Handle(BRepAdaptor_HCurve2d)::DownCast(M(IE));
if(!HE.IsNull()) {
const TopoDS_Edge& Etemp = HE->ChangeCurve2d().Edge();
TopExp::Vertices(Etemp,V1,V2);
#include <Geom_Plane.hxx>
#include <Geom2d_Line.hxx>
#include <Geom_Line.hxx>
+#include <Geom_BSplineSurface.hxx>
#include <GeomAdaptor_HSurface.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
+#include <Geom_BSplineSurface.hxx>
#include <Law_Linear.hxx>
#include <BRepBlend_CSCircular.hxx>
#include <BRepBlend_Line.hxx>
#include <Geom2d_Curve.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <Geom2d_Line.hxx>
+#include <Geom_BSplineSurface.hxx>
#include <IntAna_QuadQuadGeo.hxx>
#include <IntCurveSurface_IntersectionPoint.hxx>
// if U1 and U2 coincide-->do nothing
if (Abs (U1 - U2) <= Precision::PConfusion()) continue;
Handle (Geom2d_TrimmedCurve) TrimPCurve = new Geom2d_TrimmedCurve (PCurve, U1, U2);
- AddElement (TrimPCurve, TopologicalEdge.Orientation());
+ Geom2dAdaptor_Curve aGAC (TrimPCurve);
+ AddElement (aGAC, TopologicalEdge.Orientation());
}
}
D = D->Copy();
else
// clear old name
- Draw::Set(a[i],Handle(Draw_Drawable3D()));
+ Draw::Set(a[i],Handle(Draw_Drawable3D)());
Draw::Set(a[i+1],D);
}
#include <FairCurve_Batten.hxx>
#include <FairCurve_AnalysisCode.hxx>
#include <GeomTools_Curve2dSet.hxx>
+#include <Geom2d_BSplineCurve.hxx>
DrawFairCurve_Batten::DrawFairCurve_Batten(const Standard_Address TheBatten)
: DrawTrSurf_BSplineCurve2d( ((FairCurve_Batten*)TheBatten)->Curve()),
#include <NCollection_Array1.hxx>
+class Expr_NamedUnknown;
typedef NCollection_Array1<Handle(Expr_NamedUnknown)> Expr_Array1OfNamedUnknown;
#include <GC_MakeSegment.hxx>
#include <Geom_BezierCurve.hxx>
#include <Geom_BSplineCurve.hxx>
+#include <Geom2d_TrimmedCurve.hxx>
#include <Geom_Plane.hxx>
#include <Geom2d_BezierCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <Geom_Axis1Placement.ixx>
typedef Geom_Axis1Placement Axis1Placement;
-typedef Handle(Geom_Axis1Placement) Handle(Axis1Placement);
typedef gp_Ax2 Ax2;
typedef gp_Dir Dir;
typedef gp_Pnt Pnt;
Handle(Geom_Geometry) Geom_Axis1Placement::Copy() const {
- Handle(Axis1Placement) A1;
+ Handle(Geom_Axis1Placement) A1;
A1 = new Axis1Placement (axis);
return A1;
}
void Geom_Axis1Placement::Transform (const Trsf& T) { axis.Transform (T); }
-Handle(Axis1Placement) Geom_Axis1Placement::Reversed() const {
+Handle(Geom_Axis1Placement) Geom_Axis1Placement::Reversed() const {
gp_Ax1 A1 = axis;
A1.Reverse();
#include <Geom_Axis2Placement.ixx>
-typedef Handle(Geom_Axis2Placement) Handle(Axis2Placement);
typedef Geom_Axis2Placement Axis2Placement;
typedef gp_Ax1 Ax1;
typedef gp_Dir Dir;
Handle(Geom_Geometry) Geom_Axis2Placement::Copy() const {
- Handle(Axis2Placement) A2;
+ Handle(Geom_Axis2Placement) A2;
A2 = new Axis2Placement (axis.Location(), axis.Direction(), vxdir, vydir);
return A2;
}
#include <Geom_AxisPlacement.ixx>
-typedef Handle(Geom_AxisPlacement) Handle(AxisPlacement);
typedef gp_Ax1 Ax1;
typedef gp_Dir Dir;
typedef gp_Pnt Pnt;
void Geom_AxisPlacement::SetLocation (const Pnt& P) {axis.SetLocation (P);}
-Standard_Real Geom_AxisPlacement::Angle (const Handle(AxisPlacement)& Other) const {
+Standard_Real Geom_AxisPlacement::Angle (const Handle(Geom_AxisPlacement)& Other) const {
return axis.Angle (Other->Axis());
}
#include <Geom_CartesianPoint.ixx>
typedef Geom_CartesianPoint CartesianPoint;
-typedef Handle(Geom_CartesianPoint) Handle(CartesianPoint);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Vec Vec;
typedef gp_Trsf Trsf;
-
-
//=======================================================================
//function : Geom_CartesianPoint
//purpose :
Handle(Geom_Geometry) Geom_CartesianPoint::Copy() const {
- Handle(CartesianPoint) P;
+ Handle(Geom_CartesianPoint) P;
P = new CartesianPoint (gpPnt);
return P;
}
#include <Standard_ConstructionError.hxx>
typedef Geom_Circle Circle;
-typedef Handle(Geom_Circle) Handle(Circle);
typedef gp_Ax2 Ax2;
typedef gp_Pnt Pnt;
typedef gp_Trsf Trsf;
Handle(Geom_Geometry) Geom_Circle::Copy() const {
- Handle(Circle) C;
+ Handle(Geom_Circle) C;
C = new Circle (pos, radius);
return C;
}
#include <Geom_Circle.hxx>
typedef Geom_ConicalSurface ConicalSurface;
-typedef Handle(Geom_ConicalSurface) Handle(ConicalSurface);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Ax3 Ax3;
typedef gp_Vec Vec;
typedef gp_XYZ XYZ;
-
-
-
//=======================================================================
//function : Copy
//purpose :
Handle(Geom_Geometry) Geom_ConicalSurface::Copy () const {
- Handle(ConicalSurface) Cs;
+ Handle(Geom_ConicalSurface) Cs;
Cs = new ConicalSurface (pos, semiAngle, radius);
return Cs;
}
#include <Geom_Curve.ixx>
typedef Geom_Curve Curve;
-typedef Handle(Geom_Curve) Handle(Curve);
-
//=======================================================================
//function : Reversed
//purpose :
//=======================================================================
-Handle(Curve) Geom_Curve::Reversed () const
+Handle(Geom_Curve) Geom_Curve::Reversed () const
{
- Handle(Curve) C = Handle(Curve)::DownCast(Copy());
+ Handle(Geom_Curve) C = Handle(Geom_Curve)::DownCast(Copy());
C->Reverse();
return C;
}
#include <ElSLib.hxx>
typedef Geom_CylindricalSurface CylindricalSurface;
-typedef Handle(Geom_CylindricalSurface) Handle(CylindricalSurface);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
Handle(Geom_Geometry) Geom_CylindricalSurface::Copy () const {
- Handle(CylindricalSurface) Cs;
+ Handle(Geom_CylindricalSurface) Cs;
Cs = new CylindricalSurface (pos, radius);
return Cs;
}
#include <Standard_ConstructionError.hxx>
typedef Geom_Direction Direction;
-typedef Handle(Geom_Direction) Handle(Direction);
typedef Geom_Vector Vector;
-typedef Handle(Geom_Vector) Handle(Vector);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Pnt Pnt;
Handle(Geom_Geometry) Geom_Direction::Copy() const {
- Handle(Direction) D;
+ Handle(Geom_Direction) D;
D = new Direction (gpVec);
return D;
}
}
-void Geom_Direction::Cross (const Handle(Vector)& Other) {
+void Geom_Direction::Cross (const Handle(Geom_Vector)& Other) {
gp_Dir V (gpVec.Crossed(Other->Vec()));
gpVec = V;
void Geom_Direction::CrossCross (
-const Handle(Vector)& V1, const Handle(Vector)& V2) {
+const Handle(Geom_Vector)& V1, const Handle(Geom_Vector)& V2) {
gp_Dir V (gpVec.CrossCrossed (V1->Vec(), V2->Vec()));
gpVec = V;
}
-Handle(Vector) Geom_Direction::Crossed (const Handle(Vector)& Other)
+Handle(Geom_Vector) Geom_Direction::Crossed (const Handle(Geom_Vector)& Other)
const {
gp_Dir V (gpVec.Crossed (Other->Vec()));
}
-Handle(Vector) Geom_Direction::CrossCrossed (
-const Handle(Vector)& V1, const Handle(Vector)& V2) const {
+Handle(Geom_Vector) Geom_Direction::CrossCrossed (
+const Handle(Geom_Vector)& V1, const Handle(Geom_Vector)& V2) const {
gp_Dir V (gpVec.CrossCrossed (V1->Vec(), V2->Vec()));
return new Direction (V);
#include <Geom_ElementarySurface.ixx>
-
-
typedef Geom_ElementarySurface ElementarySurface;
-typedef Handle(Geom_ElementarySurface) Handle(ElementarySurface);
-typedef Handle(Geom_Surface) Handle(Surface);
-
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Ax3 Ax3;
typedef gp_Pnt Pnt;
typedef gp_Vec Vec;
-
-
-
//=======================================================================
//function : Continuity
//purpose :
#include <Standard_RangeError.hxx>
typedef Geom_Ellipse Ellipse;
-typedef Handle(Geom_Ellipse) Handle(Ellipse);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Pnt Pnt;
typedef gp_Trsf Trsf;
typedef gp_XYZ XYZ;
-
-
-
-
//=======================================================================
//function : Copy
//purpose :
Handle(Geom_Geometry) Geom_Ellipse::Copy() const
{
- Handle(Ellipse) E;
+ Handle(Geom_Ellipse) E;
E = new Ellipse (pos, majorRadius, minorRadius);
return E;
}
#include <Geom_Geometry.ixx>
#include <Standard_ConstructionError.hxx>
-typedef Handle(Geom_Geometry) Handle(Geometry);
typedef Geom_Geometry Geometry;
typedef gp_Pnt Pnt;
typedef gp_Vec Vec;
typedef gp_Ax2 Ax2;
typedef gp_Trsf Trsf;
-
-
Handle(Geom_Geometry) Geom_Geometry::Copy() const {
Handle(Geom_Geometry) G;
}
-Handle(Geometry) Geom_Geometry::Mirrored (const gp_Pnt& P) const {
-
- Handle(Geometry) me = this;
- Handle(Geometry) G = me->Copy();
+Handle(Geom_Geometry) Geom_Geometry::Mirrored (const gp_Pnt& P) const
+{
+ Handle(Geom_Geometry) G = Copy();
G->Mirror (P);
return G;
}
-Handle(Geometry) Geom_Geometry::Mirrored (const gp_Ax1& A1) const {
-
- Handle(Geometry) me = this;
- Handle(Geometry) G = me->Copy();
+Handle(Geom_Geometry) Geom_Geometry::Mirrored (const gp_Ax1& A1) const
+{
+ Handle(Geom_Geometry) G = Copy();
G->Mirror (A1);
return G;
}
-Handle(Geometry) Geom_Geometry::Mirrored (const gp_Ax2& A2) const {
-
- Handle(Geometry) me = this;
- Handle(Geometry) G = me->Copy();
+Handle(Geom_Geometry) Geom_Geometry::Mirrored (const gp_Ax2& A2) const
+{
+ Handle(Geom_Geometry) G = Copy();
G->Mirror (A2);
return G;
}
-Handle(Geometry) Geom_Geometry::Rotated (
-
-const gp_Ax1& A1,
-const Standard_Real Ang
-) const {
-
- Handle(Geometry) me = this;
- Handle(Geometry) G = me->Copy();
+Handle(Geom_Geometry) Geom_Geometry::Rotated (const gp_Ax1& A1, const Standard_Real Ang) const
+{
+ Handle(Geom_Geometry) G = Copy();
G->Rotate (A1, Ang);
return G;
}
-Handle(Geometry) Geom_Geometry::Scaled (const gp_Pnt& P, const Standard_Real S) const {
-
- Handle(Geometry) me = this;
- Handle(Geometry) G = me->Copy();
+Handle(Geom_Geometry) Geom_Geometry::Scaled (const gp_Pnt& P, const Standard_Real S) const
+{
+ Handle(Geom_Geometry) G = Copy();
G->Scale (P, S);
return G;
}
-Handle(Geometry) Geom_Geometry::Transformed (const gp_Trsf& T) const {
-
- Handle(Geometry) me = this;
- Handle(Geometry) G = me->Copy();
+Handle(Geom_Geometry) Geom_Geometry::Transformed (const gp_Trsf& T) const
+{
+ Handle(Geom_Geometry) G = Copy();
G->Transform (T);
return G;
}
-Handle(Geometry) Geom_Geometry::Translated (const gp_Vec& V) const {
-
- Handle(Geometry) me = this;
- Handle(Geometry) G = me->Copy();
+Handle(Geom_Geometry) Geom_Geometry::Translated (const gp_Vec& V) const
+{
+ Handle(Geom_Geometry) G = Copy();
G->Translate (V);
return G;
}
-Handle(Geometry) Geom_Geometry::Translated (
-
-const gp_Pnt& P1,
-const gp_Pnt& P2
-) const {
-
- Handle(Geometry) me = this;
- Handle(Geometry) G = me->Copy();
+Handle(Geom_Geometry) Geom_Geometry::Translated (const gp_Pnt& P1, const gp_Pnt& P2) const
+{
+ Handle(Geom_Geometry) G = Copy();
G->Translate (P1, P2);
return G;
}
typedef Geom_Hyperbola Hyperbola;
-typedef Handle(Geom_Hyperbola) Handle(Hyperbola);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Pnt Pnt;
typedef gp_Trsf Trsf;
typedef gp_XYZ XYZ;
-
-
-
-
//=======================================================================
//function : Copy
//purpose :
Handle(Geom_Geometry) Geom_Hyperbola::Copy() const {
- Handle(Hyperbola) H;
+ Handle(Geom_Hyperbola) H;
H = new Hyperbola (pos, majorRadius, minorRadius);
return H;
}
#include <CSLib_Offset.hxx>
typedef Geom_OffsetCurve OffsetCurve;
-typedef Handle(Geom_OffsetCurve) Handle(OffsetCurve);
typedef Geom_Curve Curve;
-typedef Handle(Geom_Curve) Handle(Curve);
-typedef Handle(Geom_Geometry) Handle(Geometry);
-
typedef gp_Dir Dir;
typedef gp_Pnt Pnt;
typedef gp_Trsf Trsf;
typedef gp_Vec Vec;
typedef gp_XYZ XYZ;
-
-
-
//ordre de derivation maximum pour la recherche de la premiere
//derivee non nulle
static const int maxDerivOrder = 3;
Handle(Geom_Geometry) Geom_OffsetCurve::Copy () const {
- Handle(OffsetCurve) C;
+ Handle(Geom_OffsetCurve) C;
C = new OffsetCurve (basisCurve, offsetValue, direction);
return C;
}
//purpose :
//=======================================================================
-void Geom_OffsetCurve::SetBasisCurve (const Handle(Curve)& C,
+void Geom_OffsetCurve::SetBasisCurve (const Handle(Geom_Curve)& C,
const Standard_Boolean isNotCheckC0)
{
const Standard_Real aUf = C->FirstParameter(),
aUl = C->LastParameter();
- Handle(Curve) aCheckingCurve = Handle(Curve)::DownCast(C->Copy());
+ Handle(Geom_Curve) aCheckingCurve = Handle(Geom_Curve)::DownCast(C->Copy());
Standard_Boolean isTrimmed = Standard_False;
while(aCheckingCurve->IsKind(STANDARD_TYPE(Geom_TrimmedCurve)) ||
//purpose :
//=======================================================================
-Handle(Curve) Geom_OffsetCurve::BasisCurve () const
+Handle(Geom_Curve) Geom_OffsetCurve::BasisCurve () const
{
return basisCurve;
}
#include <GeomAbs_Shape.hxx>
#include <GeomAbs_CurveType.hxx>
-typedef Handle(Geom_OffsetCurve) Handle(OffsetCurve);
typedef Geom_OffsetCurve OffsetCurve;
-typedef Handle(Geom_Curve) Handle(Curve);
-typedef Handle(Geom_Surface) Handle(Surface);
-typedef Handle(Geom_OffsetSurface) Handle(OffsetSurface);
typedef Geom_OffsetSurface OffsetSurface;
-typedef Handle(Geom_Geometry) Handle(Geometry);
typedef gp_Dir Dir;
typedef gp_Vec Vec;
typedef gp_Pnt Pnt;
Handle(Geom_Geometry) Geom_OffsetSurface::Copy () const {
- Handle(OffsetSurface) S;
+ Handle(Geom_OffsetSurface) S;
S = new OffsetSurface (basisSurf, offsetValue);
return S;
}
//purpose :
//=======================================================================
-void Geom_OffsetSurface::SetBasisSurface (const Handle(Surface)& S,
+void Geom_OffsetSurface::SetBasisSurface (const Handle(Geom_Surface)& S,
const Standard_Boolean isNotCheckC0)
{
Standard_Real aUf, aUl, aVf, aVl;
S->Bounds(aUf, aUl, aVf, aVl);
- Handle(Surface) aCheckingSurf = Handle(Surface)::DownCast(S->Copy());
+ Handle(Geom_Surface) aCheckingSurf = Handle(Geom_Surface)::DownCast(S->Copy());
Standard_Boolean isTrimmed = Standard_False;
while(aCheckingSurf->IsKind(STANDARD_TYPE(Geom_RectangularTrimmedSurface)) ||
//purpose :
//=======================================================================
-Handle(Surface) Geom_OffsetSurface::BasisSurface () const
+Handle(Geom_Surface) Geom_OffsetSurface::BasisSurface () const
{
return basisSurf;
}
GeomAbs_Shape Cont = GeomAbs_C1;
Standard_Integer MaxSeg = 100, MaxDeg =14;
- Geom_OffsetSurface_UIsoEvaluator ev (this, UU);
+ Handle(Geom_OffsetSurface) me (this);
+ Geom_OffsetSurface_UIsoEvaluator ev (me, UU);
AdvApprox_ApproxAFunction Approx(Num1, Num2, Num3, T1, T2, T3,
V1, V2, Cont,
MaxDeg,MaxSeg, ev);
GeomAbs_Shape Cont = GeomAbs_C1;
Standard_Integer MaxSeg = 100, MaxDeg =14;
- Geom_OffsetSurface_VIsoEvaluator ev (this, VV);
+ Handle(Geom_OffsetSurface) me (this);
+ Geom_OffsetSurface_VIsoEvaluator ev (me, VV);
AdvApprox_ApproxAFunction Approx (Num1, Num2, Num3, T1, T2, T3,
U1, U2, Cont, MaxDeg, MaxSeg, ev);
Standard_Boolean Geom_OffsetSurface::IsUClosed () const {
Standard_Boolean UClosed;
- Handle(Surface) SBasis = BasisSurface();
+ Handle(Geom_Surface) SBasis = BasisSurface();
if (SBasis->IsKind (STANDARD_TYPE(Geom_RectangularTrimmedSurface))) {
Handle(Geom_RectangularTrimmedSurface) St =
Handle(Geom_RectangularTrimmedSurface)::DownCast(SBasis);
- Handle(Surface) S = Handle(Surface)::DownCast(St->BasisSurface());
+ Handle(Geom_Surface) S = Handle(Geom_Surface)::DownCast(St->BasisSurface());
if (S->IsKind (STANDARD_TYPE(Geom_ElementarySurface))) {
UClosed = SBasis->IsUClosed();
}
Handle(Geom_SurfaceOfLinearExtrusion) Extru =
Handle(Geom_SurfaceOfLinearExtrusion)::DownCast(S);
- Handle(Curve) C = Extru->BasisCurve();
+ Handle(Geom_Curve) C = Extru->BasisCurve();
if (C->IsKind (STANDARD_TYPE(Geom_Circle)) || C->IsKind (STANDARD_TYPE(Geom_Ellipse))) {
UClosed = SBasis->IsUClosed();
}
Handle(Geom_SurfaceOfLinearExtrusion) Extru =
Handle(Geom_SurfaceOfLinearExtrusion)::DownCast(SBasis);
- Handle(Curve) C = Extru->BasisCurve();
+ Handle(Geom_Curve) C = Extru->BasisCurve();
UClosed = (C->IsKind(STANDARD_TYPE(Geom_Circle)) || C->IsKind(STANDARD_TYPE(Geom_Ellipse)));
}
else if (SBasis->IsKind (STANDARD_TYPE(Geom_SurfaceOfRevolution))) {
Standard_Boolean Geom_OffsetSurface::IsVClosed () const {
Standard_Boolean VClosed;
- Handle(Surface) SBasis = BasisSurface();
+ Handle(Geom_Surface) SBasis = BasisSurface();
if (SBasis->IsKind (STANDARD_TYPE(Geom_RectangularTrimmedSurface))) {
Handle(Geom_RectangularTrimmedSurface) St =
Handle(Geom_RectangularTrimmedSurface)::DownCast(SBasis);
- Handle(Surface) S = Handle(Surface)::DownCast(St->BasisSurface());
+ Handle(Geom_Surface) S = Handle(Geom_Surface)::DownCast(St->BasisSurface());
if (S->IsKind (STANDARD_TYPE(Geom_ElementarySurface))) {
VClosed = SBasis->IsVClosed();
}
#include <Standard_RangeError.hxx>
typedef Geom_Parabola Parabola;
-typedef Handle(Geom_Parabola) Handle(Parabola);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Pnt Pnt;
typedef gp_Vec Vec;
typedef gp_XYZ XYZ;
-
-
-
-
-
//=======================================================================
//function : Copy
//purpose :
Handle(Geom_Geometry) Geom_Parabola::Copy() const {
- Handle(Parabola) Prb;
+ Handle(Geom_Parabola) Prb;
Prb = new Parabola (pos, focalLength);
return Prb;
}
#include <GeomAbs_UVSense.hxx>
typedef Geom_Plane Plane;
-typedef Handle(Geom_Plane) Handle(Plane);
-typedef Handle(Geom_Line) Handle(Line);
-
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Ax3 Ax3;
typedef gp_Vec Vec;
typedef gp_XYZ XYZ;
-
-
//=======================================================================
//function : Copy
//purpose :
Handle(Geom_Geometry) Geom_Plane::Copy () const {
- Handle(Plane) Pl = new Plane ( pos);
+ Handle(Geom_Plane) Pl = new Plane ( pos);
return Pl;
}
#include <Geom_Point.ixx>
-
-typedef Handle(Geom_Point) Handle(Point);
typedef Geom_Point Point;
-
-Standard_Real Geom_Point::Distance (const Handle(Point)& Other) const {
+Standard_Real Geom_Point::Distance (const Handle(Geom_Point)& Other) const {
gp_Pnt P1 = this->Pnt ();
gp_Pnt P2 = Other->Pnt ();
}
-Standard_Real Geom_Point::SquareDistance (const Handle(Point)& Other) const {
+Standard_Real Geom_Point::SquareDistance (const Handle(Geom_Point)& Other) const {
gp_Pnt P1 = this->Pnt ();
gp_Pnt P2 = Other->Pnt ();
#include <Precision.hxx>
#include <ElCLib.hxx>
-typedef Handle(Geom_Surface) Handle(Surface);
-typedef Handle(Geom_Geometry) Handle(Geometry);
typedef Geom_RectangularTrimmedSurface RectangularTrimmedSurface;
-typedef Handle(Geom_RectangularTrimmedSurface) Handle(RectangularTrimmedSurface);
-
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Pnt Pnt;
typedef gp_Trsf Trsf;
typedef gp_Vec Vec;
-
-
-
-
//=======================================================================
//function : Copy
//purpose :
Handle(Geom_Geometry) Geom_RectangularTrimmedSurface::Copy () const {
- Handle(RectangularTrimmedSurface) S;
+ Handle(Geom_RectangularTrimmedSurface) S;
if ( isutrimmed && isvtrimmed )
S = new RectangularTrimmedSurface (basisSurf,
Geom_RectangularTrimmedSurface::Geom_RectangularTrimmedSurface (
-const Handle(Surface)& S,
+const Handle(Geom_Surface)& S,
const Standard_Real U1,
const Standard_Real U2,
const Standard_Real V1,
Handle(Geom_RectangularTrimmedSurface) T =
Handle(Geom_RectangularTrimmedSurface)::DownCast(S);
if (!T.IsNull())
- basisSurf = Handle(Surface)::DownCast(T->BasisSurface()->Copy());
+ basisSurf = Handle(Geom_Surface)::DownCast(T->BasisSurface()->Copy());
else
- basisSurf = Handle(Surface)::DownCast(S->Copy());
+ basisSurf = Handle(Geom_Surface)::DownCast(S->Copy());
Handle(Geom_OffsetSurface) O =
Handle(Geom_OffsetSurface)::DownCast(basisSurf);
Handle(Geom_RectangularTrimmedSurface) S2 =
new Geom_RectangularTrimmedSurface( O->BasisSurface(),U1,U2, V1, V2, USense, VSense);
Handle(Geom_OffsetSurface) OS = new Geom_OffsetSurface(S2, O->Offset());
- basisSurf = Handle(Surface)::DownCast(OS);
+ basisSurf = Handle(Geom_Surface)::DownCast(OS);
}
SetTrim( U1, U2, V1, V2, USense, VSense);
Handle(Geom_RectangularTrimmedSurface) T =
Handle(Geom_RectangularTrimmedSurface)::DownCast(S);
if (!T.IsNull())
- basisSurf = Handle(Surface)::DownCast(T->BasisSurface()->Copy());
+ basisSurf = Handle(Geom_Surface)::DownCast(T->BasisSurface()->Copy());
else
- basisSurf = Handle(Surface)::DownCast(S->Copy());
+ basisSurf = Handle(Geom_Surface)::DownCast(S->Copy());
Handle(Geom_OffsetSurface) O =
Handle(Geom_OffsetSurface)::DownCast(basisSurf);
Handle(Geom_RectangularTrimmedSurface) S2 =
new Geom_RectangularTrimmedSurface( O->BasisSurface(),Param1,Param2, UTrim, Sense);
Handle(Geom_OffsetSurface) OS = new Geom_OffsetSurface(S2, O->Offset());
- basisSurf = Handle(Surface)::DownCast(OS);
+ basisSurf = Handle(Geom_Surface)::DownCast(OS);
}
SetTrim(Param1, Param2, UTrim, Sense);
//purpose :
//=======================================================================
-Handle(Surface) Geom_RectangularTrimmedSurface::BasisSurface () const
+Handle(Geom_Surface) Geom_RectangularTrimmedSurface::BasisSurface () const
{
return basisSurf;
}
typedef Geom_Circle Circle;
typedef Geom_SphericalSurface SphericalSurface;
-typedef Handle(Geom_SphericalSurface) Handle(SphericalSurface);
-typedef Handle(Geom_Curve) Handle(Curve);
-typedef Handle(Geom_Circle) Handle(Circle);
typedef gp_Ax2 Ax2;
typedef gp_Ax3 Ax3;
typedef gp_Circ Circ;
typedef gp_XYZ XYZ;
typedef gp_Vec Vec;
-
-
-
//=======================================================================
//function : Copy
//purpose :
Handle(Geom_Geometry) Geom_SphericalSurface::Copy () const {
- Handle(SphericalSurface) Cs;
+ Handle(Geom_SphericalSurface) Cs;
Cs = new SphericalSurface (pos, radius);
return Cs;
}
//purpose :
//=======================================================================
-Handle(Curve) Geom_SphericalSurface::UIso (const Standard_Real U) const
+Handle(Geom_Curve) Geom_SphericalSurface::UIso (const Standard_Real U) const
{
Handle(Geom_Circle) GC = new Geom_Circle(ElSLib::SphereUIso(pos,radius,U));
Handle(Geom_TrimmedCurve) iso = new Geom_TrimmedCurve(GC,-M_PI/2.,M_PI/2);
//purpose :
//=======================================================================
-Handle(Curve) Geom_SphericalSurface::VIso (const Standard_Real V) const
+Handle(Geom_Curve) Geom_SphericalSurface::VIso (const Standard_Real V) const
{
Handle(Geom_Circle)
GC = new Geom_Circle(ElSLib::SphereVIso(pos,radius,V));
#include <Geom_Surface.ixx>
typedef Geom_Surface Surface;
-typedef Handle(Geom_Surface) Handle(Surface);
-
//=======================================================================
//function : UReversed
//purpose :
//=======================================================================
-Handle(Surface) Geom_Surface::UReversed () const
+Handle(Geom_Surface) Geom_Surface::UReversed () const
{
- Handle(Surface) S = Handle(Surface)::DownCast(Copy());
+ Handle(Geom_Surface) S = Handle(Geom_Surface)::DownCast(Copy());
S->UReverse();
return S;
}
//purpose :
//=======================================================================
-Handle(Surface) Geom_Surface::VReversed () const
+Handle(Geom_Surface) Geom_Surface::VReversed () const
{
- Handle(Surface) S = Handle(Surface)::DownCast(Copy());
+ Handle(Geom_Surface) S = Handle(Geom_Surface)::DownCast(Copy());
S->VReverse();
return S;
}
#define FMULTS (BSplCLib::NoMults())
typedef Geom_SurfaceOfLinearExtrusion SurfaceOfLinearExtrusion;
-typedef Handle(Geom_SurfaceOfLinearExtrusion) Handle(SurfaceOfLinearExtrusion);
typedef Geom_Curve Curve;
-typedef Handle(Geom_Curve) Handle(Curve);
typedef gp_Dir Dir;
typedef gp_Pnt Pnt;
typedef gp_Trsf Trsf;
//=======================================================================
Geom_SurfaceOfLinearExtrusion::Geom_SurfaceOfLinearExtrusion
- ( const Handle(Curve)& C,
+ ( const Handle(Geom_Curve)& C,
const Dir& V) {
- basisCurve = Handle(Curve)::DownCast(C->Copy()); // Copy 10-03-93
+ basisCurve = Handle(Geom_Curve)::DownCast(C->Copy()); // Copy 10-03-93
direction = V;
smooth = C->Continuity();
}
//purpose :
//=======================================================================
-void Geom_SurfaceOfLinearExtrusion::SetBasisCurve (const Handle(Curve)& C) {
+void Geom_SurfaceOfLinearExtrusion::SetBasisCurve (const Handle(Geom_Curve)& C) {
smooth = C->Continuity();
- basisCurve = Handle(Curve)::DownCast(C->Copy()); // Copy 10-03-93
+ basisCurve = Handle(Geom_Curve)::DownCast(C->Copy()); // Copy 10-03-93
}
//purpose :
//=======================================================================
-Handle(Curve) Geom_SurfaceOfLinearExtrusion::VIso (const Standard_Real V) const {
+Handle(Geom_Curve) Geom_SurfaceOfLinearExtrusion::VIso (const Standard_Real V) const {
Vec Vdir (direction);
Vdir.Multiply (V);
- Handle(Curve) C;
+ Handle(Geom_Curve) C;
C = Handle(Geom_Curve)::DownCast(basisCurve->Translated(Vdir));
return C;
}
#define FMULTS (BSplCLib::NoMults())
typedef Geom_SurfaceOfRevolution SurfaceOfRevolution;
-typedef Handle(Geom_SurfaceOfRevolution) Handle(SurfaceOfRevolution);
-typedef Handle(Geom_Geometry) Handle(Geometry);
typedef Geom_Curve Curve;
-typedef Handle(Geom_Curve) Handle(Curve);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Dir Dir;
typedef gp_Trsf Trsf;
typedef gp_Vec Vec;
typedef gp_XYZ XYZ;
+
//=======================================================================
//function : LocateSide
//purpose : This method locates U parameter on basis BSpline curve
//=======================================================================
Geom_SurfaceOfRevolution::Geom_SurfaceOfRevolution
- (const Handle(Curve)& C ,
+ (const Handle(Geom_Curve)& C ,
const Ax1& A1 ) : loc (A1.Location()) {
- basisCurve = Handle(Curve)::DownCast(C->Copy());
+ basisCurve = Handle(Geom_Curve)::DownCast(C->Copy());
direction = A1.Direction();
smooth = C->Continuity();
}
//purpose :
//=======================================================================
-void Geom_SurfaceOfRevolution::SetBasisCurve (const Handle(Curve)& C) {
+void Geom_SurfaceOfRevolution::SetBasisCurve (const Handle(Geom_Curve)& C) {
- basisCurve = Handle(Curve)::DownCast(C->Copy());
+ basisCurve = Handle(Geom_Curve)::DownCast(C->Copy());
smooth = C->Continuity();
}
//purpose :
//=======================================================================
-Handle(Curve) Geom_SurfaceOfRevolution::UIso (const Standard_Real U) const {
+Handle(Geom_Curve) Geom_SurfaceOfRevolution::UIso (const Standard_Real U) const {
- Handle(Curve) C = Handle(Curve)::DownCast(basisCurve->Copy());
+ Handle(Geom_Curve) C = Handle(Geom_Curve)::DownCast(basisCurve->Copy());
Ax1 RotAxis = Ax1 (loc, direction);
C->Rotate (RotAxis, U);
return C;
#include <Standard_RangeError.hxx>
typedef Geom_ToroidalSurface ToroidalSurface;
-typedef Handle(Geom_ToroidalSurface) Handle(ToroidalSurface);
typedef TColStd_Array1OfReal Array1OfReal;
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
Handle(Geom_Geometry) Geom_ToroidalSurface::Copy () const {
- Handle(ToroidalSurface) Cs;
+ Handle(Geom_ToroidalSurface) Cs;
Cs = new ToroidalSurface (pos, majorRadius, minorRadius);
return Cs;
}
#include <Geom_Transformation.ixx>
-typedef Handle(Geom_Transformation) Handle(Transformation);
typedef Geom_Transformation Transformation;
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_TrsfForm TrsfForm;
typedef gp_Vec Vec;
-
-
-
Geom_Transformation::Geom_Transformation () { }
Handle(Geom_Transformation) Geom_Transformation::Copy() const {
- Handle(Transformation) T;
+ Handle(Geom_Transformation) T;
T = new Transformation (gpTrsf);
return T;
}
void Geom_Transformation::Invert () { gpTrsf.Invert(); }
-Handle(Transformation) Geom_Transformation::Inverted () const {
+Handle(Geom_Transformation) Geom_Transformation::Inverted () const {
return new Transformation (gpTrsf.Inverted());
}
-Handle(Transformation) Geom_Transformation::Multiplied (
+Handle(Geom_Transformation) Geom_Transformation::Multiplied (
const Handle(Geom_Transformation)& Other) const {
return new Transformation (gpTrsf.Multiplied (Other->Trsf()));
void Geom_Transformation::Power (const Standard_Integer N) { gpTrsf.Power (N); }
-Handle(Transformation) Geom_Transformation::Powered (const Standard_Integer N) const {
+Handle(Geom_Transformation) Geom_Transformation::Powered (const Standard_Integer N) const {
gp_Trsf T = gpTrsf;
T.Power (N);
#include <Precision.hxx>
#include <ElCLib.hxx>
-
-typedef Handle(Geom_TrimmedCurve) Handle(TrimmedCurve);
typedef Geom_TrimmedCurve TrimmedCurve;
-typedef Handle(Geom_Curve) Handle(Curve);
-typedef Handle(Geom_Geometry) Handle(Geometry);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Pnt Pnt;
Handle(Geom_Geometry) Geom_TrimmedCurve::Copy () const {
- Handle(TrimmedCurve) Tc = new TrimmedCurve (basisCurve, uTrim1, uTrim2);
+ Handle(Geom_TrimmedCurve) Tc = new TrimmedCurve (basisCurve, uTrim1, uTrim2);
return Tc;
}
// kill trimmed basis curves
Handle(Geom_TrimmedCurve) T = Handle(Geom_TrimmedCurve)::DownCast(C);
if (!T.IsNull())
- basisCurve = Handle(Curve)::DownCast(T->BasisCurve()->Copy());
+ basisCurve = Handle(Geom_Curve)::DownCast(T->BasisCurve()->Copy());
else
- basisCurve = Handle(Curve)::DownCast(C->Copy());
+ basisCurve = Handle(Geom_Curve)::DownCast(C->Copy());
SetTrim(U1, U2, Sense, theAdjustPeriodic);
}
//purpose :
//=======================================================================
-Handle(Curve) Geom_TrimmedCurve::BasisCurve () const {
+Handle(Geom_Curve) Geom_TrimmedCurve::BasisCurve () const {
return basisCurve;
}
#include <Geom_Vector.ixx>
typedef Geom_Vector Vector;
-typedef Handle(Geom_Vector) Handle(Vector);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Pnt Pnt;
typedef gp_Trsf Trsf;
-
-
-
void Geom_Vector::Reverse () { gpVec.Reverse(); }
Standard_Real Geom_Vector::X () const { return gpVec.X(); }
const gp_Vec& Geom_Vector::Vec () const { return gpVec; }
-Handle(Vector) Geom_Vector::Reversed () const
+Handle(Geom_Vector) Geom_Vector::Reversed () const
{
- Handle(Vector) V = Handle(Vector)::DownCast(Copy());
+ Handle(Geom_Vector) V = Handle(Geom_Vector)::DownCast(Copy());
V->Reverse();
return V;
}
-Standard_Real Geom_Vector::Angle (const Handle(Vector)& Other) const {
+Standard_Real Geom_Vector::Angle (const Handle(Geom_Vector)& Other) const {
return gpVec.Angle (Other->Vec());
}
Standard_Real Geom_Vector::AngleWithRef (
-const Handle(Vector)& Other, const Handle(Vector)& VRef) const {
+const Handle(Geom_Vector)& Other, const Handle(Geom_Vector)& VRef) const {
return gpVec.AngleWithRef (Other->Vec(), VRef->Vec());
}
}
-Standard_Real Geom_Vector::Dot (const Handle(Vector)& Other) const {
+Standard_Real Geom_Vector::Dot (const Handle(Geom_Vector)& Other) const {
return gpVec.Dot (Other->Vec());
}
Standard_Real Geom_Vector::DotCross (
-const Handle(Vector)& V1, const Handle(Vector)& V2) const {
+const Handle(Geom_Vector)& V1, const Handle(Geom_Vector)& V2) const {
return gpVec.DotCross (V1->Vec(), V2->Vec());
}
#include <Geom_VectorWithMagnitude.ixx>
typedef Geom_VectorWithMagnitude VectorWithMagnitude;
-typedef Handle(Geom_VectorWithMagnitude) Handle(VectorWithMagnitude);
typedef Geom_Vector Vector;
-typedef Handle(Geom_Vector) Handle(Vector);
-typedef Handle(Geom_Geometry) Handle(Geometry);
typedef gp_Ax1 Ax1;
typedef gp_Ax2 Ax2;
typedef gp_Pnt Pnt;
typedef gp_Trsf Trsf;
-
-
-
//=======================================================================
//function : Geom_VectorWithMagnitude
//purpose :
Handle(Geom_Geometry) Geom_VectorWithMagnitude::Copy() const {
- Handle(VectorWithMagnitude) V;
+ Handle(Geom_VectorWithMagnitude) V;
V = new VectorWithMagnitude (gpVec);
return V;
}
//purpose :
//=======================================================================
-void Geom_VectorWithMagnitude::Add (const Handle(Vector)& Other) {
+void Geom_VectorWithMagnitude::Add (const Handle(Geom_Vector)& Other) {
gpVec.Add (Other->Vec());
}
//purpose :
//=======================================================================
-Handle(VectorWithMagnitude) Geom_VectorWithMagnitude::Added (
-const Handle(Vector)& Other) const {
+Handle(Geom_VectorWithMagnitude) Geom_VectorWithMagnitude::Added (
+const Handle(Geom_Vector)& Other) const {
gp_Vec V1 = gpVec;
V1.Add (Other->Vec());
//purpose :
//=======================================================================
-void Geom_VectorWithMagnitude::Cross (const Handle(Vector)& Other) {
+void Geom_VectorWithMagnitude::Cross (const Handle(Geom_Vector)& Other) {
gpVec.Cross (Other->Vec());
}
//purpose :
//=======================================================================
-Handle(Vector) Geom_VectorWithMagnitude::Crossed (
-const Handle(Vector)& Other) const {
+Handle(Geom_Vector) Geom_VectorWithMagnitude::Crossed (
+const Handle(Geom_Vector)& Other) const {
gp_Vec V (gpVec);
V.Cross (Other->Vec());
//=======================================================================
void Geom_VectorWithMagnitude::CrossCross (
-const Handle(Vector)& V1, const Handle(Vector)& V2) {
+const Handle(Geom_Vector)& V1, const Handle(Geom_Vector)& V2) {
gpVec.CrossCross (V1->Vec(), V2->Vec());
}
//purpose :
//=======================================================================
-Handle(Vector) Geom_VectorWithMagnitude::CrossCrossed (
-const Handle(Vector)& V1, const Handle(Vector)& V2) const {
+Handle(Geom_Vector) Geom_VectorWithMagnitude::CrossCrossed (
+const Handle(Geom_Vector)& V1, const Handle(Geom_Vector)& V2) const {
gp_Vec V (gpVec);
V.CrossCross (V1->Vec(), V2->Vec());
//purpose :
//=======================================================================
-Handle(VectorWithMagnitude) Geom_VectorWithMagnitude::Divided (
+Handle(Geom_VectorWithMagnitude) Geom_VectorWithMagnitude::Divided (
const Standard_Real Scalar) const {
gp_Vec V (gpVec);
//purpose :
//=======================================================================
-Handle(VectorWithMagnitude) Geom_VectorWithMagnitude::Multiplied (
+Handle(Geom_VectorWithMagnitude) Geom_VectorWithMagnitude::Multiplied (
const Standard_Real Scalar) const {
gp_Vec V (gpVec);
//purpose :
//=======================================================================
-Handle(VectorWithMagnitude) Geom_VectorWithMagnitude::Normalized () const {
+Handle(Geom_VectorWithMagnitude) Geom_VectorWithMagnitude::Normalized () const {
gp_Vec V (gpVec);
V.Normalize ();
//purpose :
//=======================================================================
-void Geom_VectorWithMagnitude::Subtract (const Handle(Vector)& Other) {
+void Geom_VectorWithMagnitude::Subtract (const Handle(Geom_Vector)& Other) {
gpVec.Subtract (Other->Vec());
}
//purpose :
//=======================================================================
-Handle(VectorWithMagnitude) Geom_VectorWithMagnitude::Subtracted (
-const Handle(Vector)& Other) const {
+Handle(Geom_VectorWithMagnitude) Geom_VectorWithMagnitude::Subtracted (
+const Handle(Geom_Vector)& Other) const {
gp_Vec V (gpVec);
V.Subtract (Other->Vec());
typedef Geom2d_AxisPlacement AxisPlacement;
-typedef Handle(Geom2d_AxisPlacement) Handle(AxisPlacement);
typedef gp_Dir2d Dir2d;
typedef gp_Pnt2d Pnt2d;
typedef gp_Trsf2d Trsf2d;
Handle(Geom2d_Geometry) Geom2d_AxisPlacement::Copy() const {
- Handle(AxisPlacement) A;
+ Handle(Geom2d_AxisPlacement) A;
A = new AxisPlacement (axis);
return A;
}
void Geom2d_AxisPlacement::Reverse() { axis.Reverse(); }
-Handle(AxisPlacement) Geom2d_AxisPlacement::Reversed() const {
+Handle(Geom2d_AxisPlacement) Geom2d_AxisPlacement::Reversed() const {
gp_Ax2d A = axis;
A.Reverse();
- Handle(AxisPlacement) Temp = new AxisPlacement (A);
+ Handle(Geom2d_AxisPlacement) Temp = new AxisPlacement (A);
return Temp;
}
axis.SetDirection(V);
}
-Standard_Real Geom2d_AxisPlacement::Angle (const Handle(AxisPlacement)& Other) const {
+Standard_Real Geom2d_AxisPlacement::Angle (const Handle(Geom2d_AxisPlacement)& Other) const {
return axis.Angle (Other->Ax2d());
}
#include <Geom2d_CartesianPoint.ixx>
typedef Geom2d_CartesianPoint CartesianPoint;
-typedef Handle(Geom2d_CartesianPoint) Handle(CartesianPoint);
typedef gp_Ax2d Ax2d;
typedef gp_Vec2d Vec2d;
typedef gp_Trsf2d Trsf2d;
Handle(Geom2d_Geometry) Geom2d_CartesianPoint::Copy() const {
- Handle(CartesianPoint) P;
+ Handle(Geom2d_CartesianPoint) P;
P = new CartesianPoint (gpPnt2d);
return P;
}
typedef Geom2d_Circle Circle;
-typedef Handle(Geom2d_Circle) Handle(Circle);
typedef gp_Ax2d Ax2d;
typedef gp_Dir2d Dir2d;
typedef gp_Pnt2d Pnt2d;
typedef gp_Vec2d Vec2d;
typedef gp_XY XY;
-
-
-
-
-
-
-
//=======================================================================
//function : Copy
//purpose :
Handle(Geom2d_Geometry) Geom2d_Circle::Copy() const
{
- Handle(Circle) C;
+ Handle(Geom2d_Circle) C;
C = new Circle (pos, radius);
return C;
}
typedef Geom2d_Curve Curve;
-typedef Handle(Geom2d_Curve) Handle(Curve);
//=======================================================================
Handle(Geom2d_Curve) Geom2d_Curve::Reversed () const
{
- Handle(Curve) C = Handle(Curve)::DownCast(Copy());
+ Handle(Geom2d_Curve) C = Handle(Geom2d_Curve)::DownCast(Copy());
C->Reverse();
return C;
}
#include <Standard_ConstructionError.hxx>
typedef Geom2d_Direction Direction;
-typedef Handle(Geom2d_Direction) Handle(Direction);
-typedef Handle(Geom2d_Vector) Handle(Vector);
typedef gp_Ax2d Ax2d;
typedef gp_Pnt2d Pnt2d;
typedef gp_Trsf2d Trsf2d;
Handle(Geom2d_Geometry) Geom2d_Direction::Copy() const {
- Handle(Direction) D;
+ Handle(Geom2d_Direction) D;
D = new Direction (gpVec2d);
return D;
}
Standard_Real Geom2d_Direction::SquareMagnitude () const { return 1.0; }
-Standard_Real Geom2d_Direction::Crossed (const Handle(Vector)& Other) const {
+Standard_Real Geom2d_Direction::Crossed (const Handle(Geom2d_Vector)& Other) const {
return gpVec2d.Crossed (Other->Vec2d());
}
#include <Standard_RangeError.hxx>
#include <Standard_ConstructionError.hxx>
-
typedef Geom2d_Ellipse Ellipse;
-typedef Handle(Geom2d_Ellipse) Handle(Ellipse);
typedef gp_Ax2d Ax2d;
typedef gp_Dir2d Dir2d;
typedef gp_Pnt2d Pnt2d;
typedef gp_Trsf2d Trsf2d;
typedef gp_XY XY;
-
-
-
-
//=======================================================================
//function : Copy
//purpose :
Handle(Geom2d_Geometry) Geom2d_Ellipse::Copy() const
{
- Handle(Ellipse) E;
+ Handle(Geom2d_Ellipse) E;
E = new Ellipse (pos, majorRadius, minorRadius);
return E;
}
#include <Geom2d_Geometry.ixx>
#include <Standard_ConstructionError.hxx>
-typedef Handle(Geom2d_Geometry) Handle(Geometry);
typedef Geom2d_Geometry Geometry;
typedef gp_Ax2d Ax2d;
typedef gp_Pnt2d Pnt2d;
typedef gp_Vec2d Vec2d;
typedef gp_Trsf2d Trsf2d;
-
-
void Geom2d_Geometry::Mirror (const gp_Pnt2d& P) {
Trsf2d T;
}
- Handle(Geometry) Geom2d_Geometry::Mirrored (const gp_Pnt2d& P) const {
-
- Handle(Geometry) me = this;
- Handle(Geometry) G = me->Copy();
+ Handle(Geom2d_Geometry) Geom2d_Geometry::Mirrored (const gp_Pnt2d& P) const
+ {
+ Handle(Geom2d_Geometry) G = Copy();
G->Mirror (P);
return G;
}
-Handle(Geometry) Geom2d_Geometry::Mirrored (const gp_Ax2d& A) const {
-
- Handle(Geometry) me = this;
- Handle(Geometry) G = me->Copy();
+Handle(Geom2d_Geometry) Geom2d_Geometry::Mirrored (const gp_Ax2d& A) const
+{
+ Handle(Geom2d_Geometry) G = Copy();
G->Mirror (A);
return G;
}
-Handle(Geometry) Geom2d_Geometry::Rotated (
-const gp_Pnt2d& P, const Standard_Real Ang) const {
-
- Handle(Geometry) me = this;
- Handle(Geometry) G = me->Copy();
+Handle(Geom2d_Geometry) Geom2d_Geometry::Rotated (const gp_Pnt2d& P, const Standard_Real Ang) const
+{
+ Handle(Geom2d_Geometry) G = Copy();
G->Rotate (P, Ang);
return G;
}
-Handle(Geometry) Geom2d_Geometry::Scaled (
-const gp_Pnt2d& P, const Standard_Real S) const {
-
- Handle(Geometry) me = this;
- Handle(Geometry) G = me->Copy();
+Handle(Geom2d_Geometry) Geom2d_Geometry::Scaled (const gp_Pnt2d& P, const Standard_Real S) const
+{
+ Handle(Geom2d_Geometry) G = Copy();
G->Scale (P, S);
return G;
}
-Handle(Geometry) Geom2d_Geometry::Transformed (const gp_Trsf2d& T) const {
-
- Handle(Geometry) me = this;
- Handle(Geometry) G = me->Copy();
+Handle(Geom2d_Geometry) Geom2d_Geometry::Transformed (const gp_Trsf2d& T) const
+{
+ Handle(Geom2d_Geometry) G = Copy();
G->Transform (T);
return G;
}
-Handle(Geometry) Geom2d_Geometry::Translated (const gp_Vec2d& V) const {
-
- Handle(Geometry) me = this;
- Handle(Geometry) G = me->Copy();
+Handle(Geom2d_Geometry) Geom2d_Geometry::Translated (const gp_Vec2d& V) const
+{
+ Handle(Geom2d_Geometry) G = Copy();
G->Translate (V);
return G;
}
-Handle(Geometry) Geom2d_Geometry::Translated (
-const gp_Pnt2d& P1, const gp_Pnt2d& P2) const {
-
- Handle(Geometry) me = this;
- Handle(Geometry) G = me->Copy();
+Handle(Geom2d_Geometry) Geom2d_Geometry::Translated (const gp_Pnt2d& P1, const gp_Pnt2d& P2) const
+{
+ Handle(Geom2d_Geometry) G = Copy();
G->Translate (P1, P2);
return G;
}
#include <Standard_DomainError.hxx>
#include <Standard_RangeError.hxx>
-
-
typedef Geom2d_Hyperbola Hyperbola;
-typedef Handle(Geom2d_Hyperbola) Handle(Hyperbola);
typedef gp_Ax2d Ax2d;
typedef gp_Dir2d Dir2d;
typedef gp_Pnt2d Pnt2d;
typedef gp_Trsf2d Trsf2d;
typedef gp_XY XY;
-
-
-
-
//=======================================================================
//function : Copy
//purpose :
Handle(Geom2d_Geometry) Geom2d_Hyperbola::Copy() const
{
- Handle(Hyperbola) H;
+ Handle(Geom2d_Hyperbola) H;
H = new Hyperbola (pos, majorRadius, minorRadius);
return H;
}
#include <gp_XY.hxx>
#include <Standard_RangeError.hxx>
-
typedef Geom2d_Line Line;
-typedef Handle(Geom2d_Line) Handle(Line);
typedef gp_Ax2d Ax2d;
typedef gp_Dir2d Dir2d;
typedef gp_Pnt2d Pnt2d;
typedef gp_Trsf2d Trsf2d;
typedef gp_XY XY;
-
-
-
-
//=======================================================================
//function : Copy
//purpose :
Handle(Geom2d_Geometry) Geom2d_Line::Copy() const
{
- Handle(Line) L;
+ Handle(Geom2d_Line) L;
L = new Line (pos);
return L;
}
#include <gp_XY.hxx>
#include <Precision.hxx>
-typedef Handle(Geom2d_OffsetCurve) Handle(OffsetCurve);
typedef Geom2d_OffsetCurve OffsetCurve;
-typedef Handle(Geom2d_Geometry) Handle(Geometry);
-typedef Handle(Geom2d_Curve) Handle(Curve);
typedef Geom2d_Curve Curve;
typedef gp_Dir2d Dir2d;
typedef gp_Pnt2d Pnt2d;
Handle(Geom2d_Geometry) Geom2d_OffsetCurve::Copy () const
{
- Handle(OffsetCurve) C;
+ Handle(Geom2d_OffsetCurve) C;
C = new OffsetCurve (basisCurve, offsetValue);
return C;
}
//purpose :
//=======================================================================
-void Geom2d_OffsetCurve::SetBasisCurve (const Handle(Curve)& C,
+void Geom2d_OffsetCurve::SetBasisCurve (const Handle(Geom2d_Curve)& C,
const Standard_Boolean isNotCheckC0)
{
const Standard_Real aUf = C->FirstParameter(),
//purpose :
//=======================================================================
-Handle(Curve) Geom2d_OffsetCurve::BasisCurve () const
+Handle(Geom2d_Curve) Geom2d_OffsetCurve::BasisCurve () const
{
return basisCurve;
}
#include <Standard_RangeError.hxx>
typedef Geom2d_Parabola Parabola;
-typedef Handle(Geom2d_Parabola) Handle(Parabola);
typedef gp_Ax2d Ax2d;
typedef gp_Dir2d Dir2d;
typedef gp_Pnt2d Pnt2d;
typedef gp_Trsf2d Trsf2d;
typedef gp_XY XY;
-
-
-
-
-
//=======================================================================
//function : Copy
//purpose :
Handle(Geom2d_Geometry) Geom2d_Parabola::Copy() const
{
- Handle(Parabola) Prb;
+ Handle(Geom2d_Parabola) Prb;
Prb = new Parabola (pos, focalLength);
return Prb;
}
#include <Geom2d_Point.ixx>
typedef Geom2d_Point Point;
-typedef Handle(Geom2d_Point) Handle(Point);
-
-Standard_Real Geom2d_Point::Distance (const Handle(Point)& Other) const {
+Standard_Real Geom2d_Point::Distance (const Handle(Geom2d_Point)& Other) const {
gp_Pnt2d P1 = this-> Pnt2d ();
gp_Pnt2d P2 = Other->Pnt2d ();
}
-Standard_Real Geom2d_Point::SquareDistance (const Handle(Point)& Other) const {
+Standard_Real Geom2d_Point::SquareDistance (const Handle(Geom2d_Point)& Other) const {
gp_Pnt2d P1 = this-> Pnt2d ();
gp_Pnt2d P2 = Other->Pnt2d ();
typedef Geom2d_Transformation Transformation;
-typedef Handle(Geom2d_Transformation) Handle(Transformation);
-
typedef gp_Ax2d Ax2d;
typedef gp_Pnt2d Pnt2d;
typedef gp_TrsfForm TrsfForm;
typedef gp_Vec2d Vec2d;
-
-
-
-
-
-
-
Handle(Geom2d_Transformation) Geom2d_Transformation::Copy() const {
- Handle(Transformation) T;
+ Handle(Geom2d_Transformation) T;
T = new Transformation (gpTrsf2d);
return T;
}
: gpTrsf2d (T) { }
-Handle(Transformation) Geom2d_Transformation::Inverted () const {
+Handle(Geom2d_Transformation) Geom2d_Transformation::Inverted () const {
return new Transformation (gpTrsf2d.Inverted());
}
-Handle(Transformation) Geom2d_Transformation::Multiplied (
+Handle(Geom2d_Transformation) Geom2d_Transformation::Multiplied (
-const Handle(Transformation)& Other) const {
+const Handle(Geom2d_Transformation)& Other) const {
return new Transformation (gpTrsf2d.Multiplied (Other->Trsf2d()));
}
-Handle(Transformation) Geom2d_Transformation::Powered (const Standard_Integer N) const{
+Handle(Geom2d_Transformation) Geom2d_Transformation::Powered (const Standard_Integer N) const{
gp_Trsf2d Temp = gpTrsf2d;
Temp.Power (N);
void Geom2d_Transformation::PreMultiply (
-const Handle(Transformation)& Other) {
+const Handle(Geom2d_Transformation)& Other) {
gpTrsf2d.PreMultiply (Other->Trsf2d());
}
#include <Precision.hxx>
-typedef Handle(Geom2d_TrimmedCurve) Handle(TrimmedCurve);
typedef Geom2d_TrimmedCurve TrimmedCurve;
-typedef Handle(Geom2d_Curve) Handle(Curve);
-typedef Handle(Geom2d_Geometry) Handle(Geometry);
typedef gp_Ax2d Ax2d;
typedef gp_Pnt2d Pnt2d;
typedef gp_Trsf2d Trsf2d;
typedef gp_Vec2d Vec2d;
-
-
-
-
//=======================================================================
//function : Copy
//purpose :
Handle(Geom2d_Geometry) Geom2d_TrimmedCurve::Copy () const
{
- Handle(TrimmedCurve) Tc;
+ Handle(Geom2d_TrimmedCurve) Tc;
Tc = new TrimmedCurve (basisCurve, uTrim1, uTrim2);
return Tc;
}
// kill trimmed basis curves
Handle(Geom2d_TrimmedCurve) T = Handle(Geom2d_TrimmedCurve)::DownCast(C);
if (!T.IsNull())
- basisCurve = Handle(Curve)::DownCast(T->BasisCurve()->Copy());
+ basisCurve = Handle(Geom2d_Curve)::DownCast(T->BasisCurve()->Copy());
else
- basisCurve = Handle(Curve)::DownCast(C->Copy());
+ basisCurve = Handle(Geom2d_Curve)::DownCast(C->Copy());
SetTrim(U1, U2, Sense, theAdjustPeriodic);
}
//purpose :
//=======================================================================
-Handle(Curve) Geom2d_TrimmedCurve::BasisCurve () const
+Handle(Geom2d_Curve) Geom2d_TrimmedCurve::BasisCurve () const
{
return basisCurve;
}
#include <Geom2d_Vector.ixx>
typedef Geom2d_Vector Vector;
-typedef Handle(Geom2d_Vector) Handle(Vector);
typedef gp_Ax2d Ax2d;
typedef gp_Pnt2d Pnt2d;
-
-
Standard_Real Geom2d_Vector::Angle (
const Handle(Geom2d_Vector)& Other) const {
Standard_Real Geom2d_Vector::Y () const { return gpVec2d.Y(); }
-Handle(Vector) Geom2d_Vector::Reversed () const {
+Handle(Geom2d_Vector) Geom2d_Vector::Reversed () const {
- Handle(Vector) V = Handle(Vector)::DownCast(Copy());
+ Handle(Geom2d_Vector) V = Handle(Geom2d_Vector)::DownCast(Copy());
V->Reverse();
return V;
}
}
-Standard_Real Geom2d_Vector::Dot (const Handle(Vector)& Other) const {
+Standard_Real Geom2d_Vector::Dot (const Handle(Geom2d_Vector)& Other) const {
return gpVec2d.Dot (Other->Vec2d());
}
typedef Geom2d_Vector Vector;
typedef Geom2d_VectorWithMagnitude VectorWithMagnitude;
-typedef Handle(Geom2d_VectorWithMagnitude) Handle(VectorWithMagnitude);
-typedef Handle(Geom2d_Vector) Handle(Vector);
-
typedef gp_Ax2d Ax2d;
typedef gp_Pnt2d Pnt2d;
typedef gp_Trsf2d Trsf2d;
-
-
Geom2d_VectorWithMagnitude::Geom2d_VectorWithMagnitude (const gp_Vec2d& V)
{ gpVec2d = V; }
Handle(Geom2d_Geometry) Geom2d_VectorWithMagnitude::Copy() const {
- Handle(VectorWithMagnitude) V;
+ Handle(Geom2d_VectorWithMagnitude) V;
V = new VectorWithMagnitude (gpVec2d);
return V;
}
}
-void Geom2d_VectorWithMagnitude::Add (const Handle(Vector)& Other) {
+void Geom2d_VectorWithMagnitude::Add (const Handle(Geom2d_Vector)& Other) {
gpVec2d.Add (Other->Vec2d());
}
-Handle(VectorWithMagnitude) Geom2d_VectorWithMagnitude::Added (
+Handle(Geom2d_VectorWithMagnitude) Geom2d_VectorWithMagnitude::Added (
-const Handle(Vector)& Other) const {
+const Handle(Geom2d_Vector)& Other) const {
gp_Vec2d Temp = Other->Vec2d();
Temp.Add (gpVec2d);
}
-Standard_Real Geom2d_VectorWithMagnitude::Crossed (const Handle(Vector)& Other) const{
+Standard_Real Geom2d_VectorWithMagnitude::Crossed (const Handle(Geom2d_Vector)& Other) const{
return gpVec2d.Crossed (Other->Vec2d());
}
}
-Handle(VectorWithMagnitude) Geom2d_VectorWithMagnitude::Divided (
+Handle(Geom2d_VectorWithMagnitude) Geom2d_VectorWithMagnitude::Divided (
const Standard_Real Scalar) const {
gp_Vec2d V (gpVec2d);
}
-Handle(VectorWithMagnitude) Geom2d_VectorWithMagnitude::Multiplied (
+Handle(Geom2d_VectorWithMagnitude) Geom2d_VectorWithMagnitude::Multiplied (
const Standard_Real Scalar) const {
gp_Vec2d V(gpVec2d);
void Geom2d_VectorWithMagnitude::Normalize () { gpVec2d.Normalize (); }
-Handle(VectorWithMagnitude) Geom2d_VectorWithMagnitude::Normalized () const {
+Handle(Geom2d_VectorWithMagnitude) Geom2d_VectorWithMagnitude::Normalized () const {
gp_Vec2d V = gpVec2d;
V.Normalized ();
}
-void Geom2d_VectorWithMagnitude::Subtract (const Handle(Vector)& Other) {
+void Geom2d_VectorWithMagnitude::Subtract (const Handle(Geom2d_Vector)& Other) {
gpVec2d.Subtract (Other->Vec2d());
}
-Handle(VectorWithMagnitude) Geom2d_VectorWithMagnitude::Subtracted (
-const Handle(Vector)& Other) const {
+Handle(Geom2d_VectorWithMagnitude) Geom2d_VectorWithMagnitude::Subtracted (
+const Handle(Geom2d_Vector)& Other) const {
gp_Vec2d V = gpVec2d;
V.Subtract (Other->Vec2d());
typedef gp_Parab2d Parab2d;
typedef gp_Pnt2d Pnt2d;
typedef gp_Trsf2d Trsf2d;
-
typedef Geom2d_Curve Curve;
typedef Geom2d_BSplineCurve BSplineCurve;
-typedef Handle(Geom2d_Curve) Handle(Curve);
-typedef Handle(Geom2d_Conic) Handle(Conic);
-typedef Handle(Geom2d_Circle) Handle(Circle);
-typedef Handle(Geom2d_Ellipse) Handle(Ellipse);
-typedef Handle(Geom2d_Hyperbola) Handle(Hyperbola);
-typedef Handle(Geom2d_Parabola) Handle(Parabola);
-typedef Handle(Geom2d_Geometry) Handle(Geometry);
-typedef Handle(Geom2d_BezierCurve) Handle(BezierCurve);
-typedef Handle(Geom2d_TrimmedCurve) Handle(TrimmedCurve);
-typedef Handle(Geom2d_BSplineCurve) Handle(BSplineCurve);
-
-
typedef TColStd_Array1OfReal Array1OfReal;
typedef TColStd_Array1OfInteger Array1OfInteger;
typedef TColgp_Array1OfPnt2d Array1OfPnt2d;
-
-
//=======================================================================
//function : BSplineCurveBuilder
//purpose :
//=======================================================================
-static Handle(BSplineCurve) BSplineCurveBuilder (
+static Handle(Geom2d_BSplineCurve) BSplineCurveBuilder (
-const Handle(Conic)& TheConic,
+const Handle(Geom2d_Conic)& TheConic,
const Convert_ConicToBSplineCurve& Convert
) {
- Handle(BSplineCurve) TheCurve;
+ Handle(Geom2d_BSplineCurve) TheCurve;
Standard_Integer NbPoles = Convert.NbPoles();
Standard_Integer NbKnots = Convert.NbKnots();
Array1OfPnt2d Poles (1, NbPoles);
Trsf2d T;
T.SetTransformation (TheConic->XAxis(), gp::OX2d());
- Handle(BSplineCurve) Cres =
- Handle(BSplineCurve)::DownCast(TheCurve->Transformed (T));
+ Handle(Geom2d_BSplineCurve) Cres =
+ Handle(Geom2d_BSplineCurve)::DownCast(TheCurve->Transformed (T));
return Cres;
}
//purpose :
//=======================================================================
-Handle(BSplineCurve) Geom2dConvert::SplitBSplineCurve (
+Handle(Geom2d_BSplineCurve) Geom2dConvert::SplitBSplineCurve (
-const Handle(BSplineCurve)& C,
+const Handle(Geom2d_BSplineCurve)& C,
const Standard_Integer FromK1,
const Standard_Integer ToK2,
const Standard_Boolean SameOrientation
Standard_Integer LastK = Max (FromK1, ToK2);
if (FirstK < TheFirst || LastK > TheLast) Standard_OutOfRange::Raise();
- Handle(BSplineCurve) NewCurve = Handle(BSplineCurve)::DownCast(C->Copy());
+ Handle(Geom2d_BSplineCurve) NewCurve = Handle(Geom2d_BSplineCurve)::DownCast(C->Copy());
NewCurve->Segment(C->Knot(FirstK),C->Knot(LastK));
//purpose :
//=======================================================================
-Handle(BSplineCurve) Geom2dConvert::SplitBSplineCurve (
+Handle(Geom2d_BSplineCurve) Geom2dConvert::SplitBSplineCurve (
-const Handle(BSplineCurve)& C,
+const Handle(Geom2d_BSplineCurve)& C,
const Standard_Real FromU1,
const Standard_Real ToU2,
const Standard_Real, // ParametricTolerance,
//purpose :
//=======================================================================
-Handle(BSplineCurve) Geom2dConvert::CurveToBSplineCurve (
+Handle(Geom2d_BSplineCurve) Geom2dConvert::CurveToBSplineCurve (
-const Handle(Curve)& C,
+const Handle(Geom2d_Curve)& C,
const Convert_ParameterisationType Parameterisation)
{
if (C->IsKind(STANDARD_TYPE(Geom2d_TrimmedCurve))) {
Handle (Curve) Curv;
- Handle(TrimmedCurve) Ctrim = Handle(TrimmedCurve)::DownCast(C);
+ Handle(Geom2d_TrimmedCurve) Ctrim = Handle(Geom2d_TrimmedCurve)::DownCast(C);
Curv = Ctrim->BasisCurve();
Standard_Real U1 = Ctrim->FirstParameter();
Standard_Real U2 = Ctrim->LastParameter();
}
else if (Curv->IsKind(STANDARD_TYPE(Geom2d_Circle))) {
- Handle(Circle) TheConic= Handle(Circle)::DownCast(Curv);
+ Handle(Geom2d_Circle) TheConic= Handle(Geom2d_Circle)::DownCast(Curv);
Circ2d C2d (gp::OX2d(), TheConic->Radius());
if(Parameterisation != Convert_RationalC1) {
Convert_CircleToBSplineCurve Convert (C2d,
}
else if (Curv->IsKind(STANDARD_TYPE(Geom2d_Ellipse))) {
- Handle(Ellipse) TheConic = Handle(Ellipse)::DownCast(Curv);
+ Handle(Geom2d_Ellipse) TheConic = Handle(Geom2d_Ellipse)::DownCast(Curv);
Elips2d E2d (gp::OX2d(),
TheConic->MajorRadius(),
}
else if (Curv->IsKind(STANDARD_TYPE(Geom2d_Hyperbola))) {
- Handle(Hyperbola) TheConic = Handle(Hyperbola)::DownCast(Curv);
+ Handle(Geom2d_Hyperbola) TheConic = Handle(Geom2d_Hyperbola)::DownCast(Curv);
Hypr2d H2d (gp::OX2d(),
TheConic->MajorRadius(), TheConic->MinorRadius());
}
else if (Curv->IsKind(STANDARD_TYPE(Geom2d_Parabola))) {
- Handle(Parabola) TheConic = Handle(Parabola)::DownCast(Curv);
+ Handle(Geom2d_Parabola) TheConic = Handle(Geom2d_Parabola)::DownCast(Curv);
Parab2d Prb2d (gp::OX2d(), TheConic->Focal());
Convert_ParabolaToBSplineCurve Convert (Prb2d, U1, U2);
else if (Curv->IsKind (STANDARD_TYPE(Geom2d_BezierCurve))) {
- Handle(BezierCurve) CBez = Handle(BezierCurve)::DownCast(Curv->Copy());
+ Handle(Geom2d_BezierCurve) CBez = Handle(Geom2d_BezierCurve)::DownCast(Curv->Copy());
CBez->Segment (U1, U2);
Standard_Integer NbPoles = CBez->NbPoles();
else {
if (C->IsKind(STANDARD_TYPE(Geom2d_Ellipse))) {
- Handle(Ellipse) TheConic = Handle(Ellipse)::DownCast(C);
+ Handle(Geom2d_Ellipse) TheConic = Handle(Geom2d_Ellipse)::DownCast(C);
Elips2d E2d (gp::OX2d(),
TheConic->MajorRadius(), TheConic->MinorRadius());
}
else if (C->IsKind(STANDARD_TYPE(Geom2d_Circle))) {
- Handle(Circle) TheConic = Handle(Circle)::DownCast(C);
+ Handle(Geom2d_Circle) TheConic = Handle(Geom2d_Circle)::DownCast(C);
Circ2d C2d (gp::OX2d(), TheConic->Radius());
Convert_CircleToBSplineCurve Convert (C2d,
}
else if (C->IsKind (STANDARD_TYPE(Geom2d_BezierCurve))) {
- Handle(BezierCurve) CBez = Handle(BezierCurve)::DownCast(C);
+ Handle(Geom2d_BezierCurve) CBez = Handle(Geom2d_BezierCurve)::DownCast(C);
Standard_Integer NbPoles = CBez->NbPoles();
Standard_Integer Degree = CBez->Degree();
U2=BSKnots(j);
j++;
- Handle(Geom2d_BSplineCurve) BSbis=Handle(Geom2d_BSplineCurve::DownCast(BS->Copy()));
+ Handle(Geom2d_BSplineCurve) BSbis=Handle(Geom2d_BSplineCurve)::DownCast(BS->Copy());
BSbis->Segment(U1,U2);
ArrayOfCurves(i)=BSbis;
}
j++;
U2=BSKnots(j);
j++;
- Handle(Geom2d_BSplineCurve) BSbis=Handle(Geom2d_BSplineCurve::DownCast(BS->Copy()));
+ Handle(Geom2d_BSplineCurve) BSbis=Handle(Geom2d_BSplineCurve)::DownCast(BS->Copy());
BSbis->Segment(U1,U2);
ArrayOfCurves(i)=BSbis;
}
#include <BSplCLib.hxx>
-typedef Handle(Geom2d_BSplineCurve) Handle(BSplineCurve);
typedef TColStd_Array1OfInteger Array1OfInteger;
typedef TColStd_HArray1OfInteger HArray1OfInteger;
-
-
-
Geom2dConvert_BSplineCurveKnotSplitting::
Geom2dConvert_BSplineCurveKnotSplitting (
-const Handle(BSplineCurve)& BasisCurve,
+const Handle(Geom2d_BSplineCurve)& BasisCurve,
const Standard_Integer ContinuityRange
) {
#include <GccEnt_BadQualifier.hxx>
#include <Geom2d_Circle.hxx>
#include <Geom2d_Line.hxx>
+#include <Geom2d_Point.hxx>
#include <GccEnt_QualifiedCirc.hxx>
#include <GccEnt_QualifiedLin.hxx>
#include <StdFail_NotDone.hxx>
Geom2dGcc_Circ2dTanCen::
Geom2dGcc_Circ2dTanCen (const Geom2dGcc_QualifiedCurve& Qualified1 ,
- const Handle(Geom2d_Point&) PCenter ,
+ const Handle(Geom2d_Point)& PCenter ,
const Standard_Real Tolerance ):
cirsol(1,2) ,
qualifier1(1,2),
}
Geom2dGcc_Circ2dTanOnRad::
- Geom2dGcc_Circ2dTanOnRad (const Handle(Geom2d_Point&) Point1 ,
+ Geom2dGcc_Circ2dTanOnRad (const Handle(Geom2d_Point)& Point1 ,
const Geom2dAdaptor_Curve& OnCurve ,
const Standard_Real Radius ,
const Standard_Real Tolerance ):
U2=BSKnots(j);
j++;
Handle(Geom_BSplineCurve)
- BSbis=Handle(Geom_BSplineCurve::DownCast(BS->Copy()));
+ BSbis=Handle(Geom_BSplineCurve)::DownCast(BS->Copy());
BSbis->Segment(U1,U2);
ArrayOfCurves(i)=BSbis;
}
#include <gp_Trsf.hxx>
#include <gp_GTrsf.hxx>
-
-
typedef Geom_Surface Surface;
typedef Geom_BSplineSurface BSplineSurface;
-typedef Handle(Geom_Curve) Handle(Curve);
-typedef Handle(Geom_BSplineCurve) Handle(BSplineCurve);
-typedef Handle(Geom_BezierSurface) Handle(BezierSurface);
-typedef Handle(Geom_Geometry) Handle(Geometry);
-typedef Handle(Geom_Surface) Handle(Surface);
-typedef Handle(Geom_Plane) Handle(Plane);
-typedef Handle(Geom_CylindricalSurface) Handle(CylindricalSurface);
-typedef Handle(Geom_ConicalSurface) Handle(ConicalSurface);
-typedef Handle(Geom_SphericalSurface) Handle(SphericalSurface);
-typedef Handle(Geom_ToroidalSurface) Handle(ToroidalSurface);
-typedef Handle(Geom_BSplineSurface) Handle(BSplineSurface);
-typedef Handle(Geom_SurfaceOfRevolution) Handle(SurfaceOfRevolution);
-typedef Handle(Geom_SurfaceOfLinearExtrusion) Handle(SurfaceOfLinearExtrusion);
-typedef Handle(Geom_RectangularTrimmedSurface)
- Handle(RectangularTrimmedSurface);
-
-
typedef TColStd_Array1OfReal Array1OfReal;
typedef TColStd_Array2OfReal Array2OfReal;
typedef TColStd_Array1OfInteger Array1OfInteger;
typedef TColStd_Array2OfInteger Array2OfInteger;
typedef TColgp_Array2OfPnt Array2OfPnt;
typedef TColgp_Array1OfPnt Array1OfPnt;
-
-
typedef gp_Pnt Pnt;
-
//=======================================================================
//function : BSplineSurfaceBuilder
//purpose :
//=======================================================================
-Handle(BSplineSurface) BSplineSurfaceBuilder
+Handle(Geom_BSplineSurface) BSplineSurfaceBuilder
(const Convert_ElementarySurfaceToBSplineSurface& Convert)
{
- Handle(BSplineSurface) TheSurface;
+ Handle(Geom_BSplineSurface) TheSurface;
Standard_Integer UDegree = Convert.UDegree ();
Standard_Integer VDegree = Convert.VDegree ();
Standard_Integer NbUPoles = Convert.NbUPoles();
//purpose :
//=======================================================================
-Handle(BSplineSurface) GeomConvert::SplitBSplineSurface
- (const Handle(BSplineSurface)& S,
+Handle(Geom_BSplineSurface) GeomConvert::SplitBSplineSurface
+ (const Handle(Geom_BSplineSurface)& S,
const Standard_Integer FromUK1,
const Standard_Integer ToUK2,
const Standard_Integer FromVK1,
if (FirstUK < FirstU || LastUK > LastU ||
FirstVK < FirstV || LastVK > LastV) { Standard_DomainError::Raise(); }
- Handle(BSplineSurface) S1= Handle(BSplineSurface)::DownCast(S->Copy());
+ Handle(Geom_BSplineSurface) S1= Handle(Geom_BSplineSurface)::DownCast(S->Copy());
S1->Segment(S1->UKnot(FirstUK),S1->UKnot(LastUK),
S1->VKnot(FirstVK),S1->VKnot(LastVK));
//purpose :
//=======================================================================
-Handle(BSplineSurface) GeomConvert::SplitBSplineSurface
- (const Handle(BSplineSurface)& S,
+Handle(Geom_BSplineSurface) GeomConvert::SplitBSplineSurface
+ (const Handle(Geom_BSplineSurface)& S,
const Standard_Integer FromK1,
const Standard_Integer ToK2,
const Standard_Boolean USplit,
if (FromK1 == ToK2) Standard_DomainError::Raise();
- Handle(BSplineSurface) S1 = Handle(BSplineSurface)::DownCast(S->Copy());
+ Handle(Geom_BSplineSurface) S1 = Handle(Geom_BSplineSurface)::DownCast(S->Copy());
if (USplit) {
//purpose :
//=======================================================================
-Handle(BSplineSurface) GeomConvert::SplitBSplineSurface
- (const Handle(BSplineSurface)& S,
+Handle(Geom_BSplineSurface) GeomConvert::SplitBSplineSurface
+ (const Handle(Geom_BSplineSurface)& S,
const Standard_Real FromU1,
const Standard_Real ToU2,
const Standard_Real FromV1,
//purpose :
//=======================================================================
-Handle(BSplineSurface) GeomConvert::SplitBSplineSurface
- (const Handle(BSplineSurface)& S,
+Handle(Geom_BSplineSurface) GeomConvert::SplitBSplineSurface
+ (const Handle(Geom_BSplineSurface)& S,
const Standard_Real FromParam1,
const Standard_Real ToParam2,
const Standard_Boolean USplit,
if (Abs (FromParam1 - ToParam2) <= Abs(ParametricTolerance)) {
Standard_DomainError::Raise();
}
- Handle(BSplineSurface) NewSurface
+ Handle(Geom_BSplineSurface) NewSurface
= Handle(Geom_BSplineSurface)::DownCast(S->Copy());
if (USplit) {
//=======================================================================
Handle(Geom_BSplineSurface) GeomConvert::SurfaceToBSplineSurface
- (const Handle(Surface)& Sr)
+ (const Handle(Geom_Surface)& Sr)
{
Standard_Real U1, U2, V1, V2;
Sr->Bounds (U1, U2, V1, V2);
}
Handle(Geom_BSplineSurface) TheSurface;
- Handle(Surface) S;
+ Handle(Geom_Surface) S;
Handle(Geom_OffsetSurface) OffsetSur;
if (Sr->IsKind(STANDARD_TYPE(Geom_OffsetSurface))) {
OffsetSur = *((Handle(Geom_OffsetSurface)*)& Sr);
#include <BSplCLib.hxx>
-typedef Handle(Geom_BSplineCurve) Handle(BSplineCurve);
typedef TColStd_Array1OfInteger Array1OfInteger;
typedef TColStd_HArray1OfInteger HArray1OfInteger;
-
-
-
GeomConvert_BSplineCurveKnotSplitting::GeomConvert_BSplineCurveKnotSplitting (
-const Handle(BSplineCurve)& BasisCurve,
+const Handle(Geom_BSplineCurve)& BasisCurve,
const Standard_Integer ContinuityRange
) {
#include <Standard_RangeError.hxx>
#include <BSplCLib.hxx>
-typedef Handle(Geom_BSplineSurface) Handle(BSplineSurface);
+
typedef TColStd_Array1OfInteger Array1OfInteger;
typedef TColStd_HArray1OfInteger HArray1OfInteger;
-
-
-
GeomConvert_BSplineSurfaceKnotSplitting::
GeomConvert_BSplineSurfaceKnotSplitting (
-const Handle(BSplineSurface)& BasisSurface,
+const Handle(Geom_BSplineSurface)& BasisSurface,
const Standard_Integer UContinuityRange,
const Standard_Integer VContinuityRange
#include <Law.hxx>
#include <Law_Linear.hxx>
#include <Law_BSpline.hxx>
+#include <Law_BSpFunc.hxx>
#include <GeomFill_DegeneratedBound.hxx>
#include <GeomFill_TgtOnCoons.hxx>
#include <GeomAdaptor_HSurface.hxx>
#include <GeomLProp_SLProps.hxx>
#include <Geom2d_BezierCurve.hxx>
+#include <Geom2d_BSplineCurve.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColStd_SequenceOfInteger.hxx>
#include <Geom_BSplineSurface.hxx>
#include <GeomPlate_SequenceOfAij.hxx>
#include <GeomPlate_MakeApprox.hxx>
+#include <Geom_Plane.hxx>
#ifdef DRAW
#include <DrawTrSurf.hxx>
#include <Approx_Curve2d.hxx>
#include <GeomAbs_Shape.hxx>
#include <BRepAdaptor_HSurface.hxx>
+#include <Geom2d_BSplineCurve.hxx>
//---------------------------------------------------------
// Constructeur vide
#include <Geom2dConvert.hxx>
#include <GeomToStep_MakeBSplineCurveWithKnots.hxx>
#include <GeomToStep_MakeBSplineCurveWithKnotsAndRationalBSplineCurve.hxx>
-
+#include <StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve.hxx>
+#include <StepGeom_BSplineCurveWithKnots.hxx>
//=============================================================================
// Creation d' une BoundedCurve de prostep a partir d' une BoundedCurve de Geom
#include <GeomToStep_MakeBoundedSurface.ixx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_BoundedSurface.hxx>
+#include <StepGeom_BSplineSurfaceWithKnots.hxx>
+#include <StepGeom_RectangularTrimmedSurface.hxx>
+#include <StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface.hxx>
#include <GeomToStep_MakeBoundedSurface.hxx>
#include <Geom_BSplineSurface.hxx>
#include <Geom_RectangularTrimmedSurface.hxx>
#include <gp_Circ2d.hxx>
#include <Geom_Circle.hxx>
#include <StepGeom_Circle.hxx>
+#include <StepGeom_Axis2Placement2d.hxx>
+#include <StepGeom_Axis2Placement3d.hxx>
#include <TCollection_HAsciiString.hxx>
#include <UnitsMethods.hxx>
#include <GeomToStep_MakeConic.ixx>
#include <StdFail_NotDone.hxx>
-#include <StepGeom_Conic.hxx>
+#include <StepGeom_Circle.hxx>
+#include <StepGeom_Ellipse.hxx>
+#include <StepGeom_Hyperbola.hxx>
+#include <StepGeom_Parabola.hxx>
#include <GeomToStep_MakeConic.hxx>
#include <Geom_Circle.hxx>
#include <Geom_Ellipse.hxx>
#include <GeomToStep_MakeCurve.ixx>
#include <StdFail_NotDone.hxx>
-#include <StepGeom_Curve.hxx>
+#include <StepGeom_Conic.hxx>
+#include <StepGeom_Line.hxx>
+#include <StepGeom_BoundedCurve.hxx>
+#include <StepGeom_Axis2Placement3d.hxx>
#include <GeomToStep_MakeCurve.hxx>
#include <Geom_Line.hxx>
#include <Geom2d_Line.hxx>
#include <GeomToStep_MakeElementarySurface.ixx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_ElementarySurface.hxx>
+#include <StepGeom_CylindricalSurface.hxx>
+#include <StepGeom_ConicalSurface.hxx>
+#include <StepGeom_SphericalSurface.hxx>
+#include <StepGeom_ToroidalSurface.hxx>
+#include <StepGeom_Plane.hxx>
#include <GeomToStep_MakeElementarySurface.hxx>
#include <Geom_CylindricalSurface.hxx>
#include <Geom_ConicalSurface.hxx>
#include <Geom_Ellipse.hxx>
#include <gp_Elips2d.hxx>
#include <StepGeom_Ellipse.hxx>
+#include <StepGeom_Axis2Placement2d.hxx>
+#include <StepGeom_Axis2Placement3d.hxx>
#include <TCollection_HAsciiString.hxx>
#include <UnitsMethods.hxx>
#include <GeomToStep_MakeHyperbola.ixx>
#include <StepGeom_Hyperbola.hxx>
+#include <StepGeom_Axis2Placement2d.hxx>
+#include <StepGeom_Axis2Placement3d.hxx>
#include <gp_Hypr.hxx>
#include <gp_Hypr2d.hxx>
#include <Geom_Hyperbola.hxx>
#include <GeomToStep_MakeParabola.ixx>
#include <StepGeom_Parabola.hxx>
+#include <StepGeom_Axis2Placement2d.hxx>
+#include <StepGeom_Axis2Placement3d.hxx>
#include <gp_Parab.hxx>
#include <gp_Parab2d.hxx>
#include <Geom_Parabola.hxx>
#include <GeomToStep_MakeSurface.ixx>
#include <StdFail_NotDone.hxx>
-#include <StepGeom_Surface.hxx>
+#include <StepGeom_BoundedSurface.hxx>
+#include <StepGeom_ElementarySurface.hxx>
+#include <StepGeom_SweptSurface.hxx>
#include <GeomToStep_MakeSurface.hxx>
#include <Geom_BoundedSurface.hxx>
#include <GeomToStep_MakeBoundedSurface.hxx>
#include <GeomToStep_MakeSweptSurface.ixx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_SweptSurface.hxx>
+#include <StepGeom_SurfaceOfLinearExtrusion.hxx>
+#include <StepGeom_SurfaceOfRevolution.hxx>
#include <GeomToStep_MakeSweptSurface.hxx>
#include <Geom_SurfaceOfLinearExtrusion.hxx>
#include <Geom_SurfaceOfRevolution.hxx>
: IsDef (0),
IsSet (0),
MarkerType (Aspect_TOM_POINT),
- Scale (0),
- MarkerImage (NULL)
+ Scale (0)
{
memset (&Color, 0, sizeof(Color));
}
#include <Graphic3d_SequenceOfHClipPlane.hxx>
#include <Graphic3d_TypeOfComposition.hxx>
#include <Graphic3d_ViewAffinity.hxx>
-#include <Graphic3d_StructureManager.hxx>
#include <Graphic3d_Vec3.hxx>
#include <Graphic3d_ZLayerId.hxx>
-#include <Standard_Transient.hxx>
-//! Forward declaration.
+class Graphic3d_GraphicDriver;
+class Graphic3d_StructureManager;
//! Low-level graphic structure interface
class Graphic3d_CStructure : public Standard_Transient
myIsOn (Standard_True),
myIsCapping (Standard_False),
myMaterial (Graphic3d_NOM_DEFAULT),
- myTexture (NULL),
myHatch (Aspect_HS_HORIZONTAL),
myHatchOn (Standard_False),
myId(),
myIsOn (Standard_True),
myIsCapping (Standard_False),
myMaterial (Graphic3d_NOM_DEFAULT),
- myTexture (NULL),
myHatch (Aspect_HS_HORIZONTAL),
myHatchOn (Standard_False),
myId(),
myIsOn (Standard_True),
myIsCapping (Standard_False),
myMaterial (Graphic3d_NOM_DEFAULT),
- myTexture (NULL),
myHatch (Aspect_HS_HORIZONTAL),
myHatchOn (Standard_False),
myId(),
#include <NCollection_Map.hxx>
+class Graphic3d_Structure;
typedef NCollection_Map<Handle(Graphic3d_Structure)> Graphic3d_MapOfStructure;
#endif // _Graphic3d_MapOfStructure
// purpose :
// =======================================================================
Graphic3d_MarkerImage::Graphic3d_MarkerImage (const Handle(Image_PixMap)& theImage)
-: myBitMap (NULL),
- myImage (theImage),
- myImageAlpha (NULL),
+: myImage (theImage),
myMargin (1),
myWidth ((Standard_Integer )theImage->Width()),
myHeight ((Standard_Integer )theImage->Height())
const Standard_Integer& theWidth,
const Standard_Integer& theHeight)
: myBitMap (theBitMap),
- myImage (NULL),
- myImageAlpha (NULL),
myMargin (1),
myWidth (theWidth),
myHeight (theHeight)
#define _Graphic3d_MarkerImage_H__
#include <TColStd_HArray1OfByte.hxx>
-#include <Image_PixMap_Handle.hxx>
#include <Quantity_Parameter.hxx>
#include <TCollection_AsciiString.hxx>
+class Image_PixMap;
+
//! This class is used to store bitmaps and images for markers rendering.
//! It can convert bitmap texture stored in TColStd_HArray1OfByte to Image_PixMap and vice versa.
class Graphic3d_MarkerImage : public Standard_Transient
#include <Standard_Transient.hxx>
#include <NCollection_Map.hxx>
-#include <NCollection_Handle.hxx>
+#include <NCollection_Shared.hxx>
-typedef NCollection_Map<const Standard_Transient* > Graphic3d_NMapOfTransient;
-typedef NCollection_Handle<Graphic3d_NMapOfTransient> Handle(Graphic3d_NMapOfTransient);
+typedef NCollection_Shared< NCollection_Map<const Standard_Transient* > > Graphic3d_NMapOfTransient;
#endif // _Graphic3d_NMapOfTransient_HeaderFile
#include <Graphic3d_ShaderObject.hxx>
#include <Graphic3d_ShaderVariable.hxx>
+#include <Graphic3d_TextureParams.hxx>
#include <NCollection_Sequence.hxx>
//! List of shader objects.
class WorkSession; -- a set of useful facilities
deferred class WorkLibrary; -- capability of user extents
- alias Option is Option from MoniTool; -- pre-defined values for a field
- alias Profile is Profile from MoniTool; -- set of options bound/piloted together
-
class SessionFile;
deferred class SessionDumper;
class BasicDumper;
#include <TColStd_SequenceOfTransient.hxx>
#include <Standard_DomainError.hxx>
-#include <IFSelect_Profile.hxx>
-#include <IFSelect_Option.hxx>
+#include <MoniTool_Profile.hxx>
+#include <MoniTool_Option.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Interface_Macros.hxx>
static TColStd_SequenceOfInteger thenums, themodes;
static TColStd_SequenceOfTransient theacts;
-static Handle(IFSelect_Profile) thealiases;
+static Handle(MoniTool_Profile) thealiases;
void IFSelect_Activator::Adding
(const Standard_Integer number, const Standard_CString command) const
{ Adding (this,number,command,1); }
-
void IFSelect_Activator::Remove (const Standard_CString command)
{ thedico->RemoveItem(command); }
(const Standard_CString conf,
const Standard_CString command, const Standard_CString alias)
{
- if (thealiases.IsNull()) thealiases = new IFSelect_Profile;
- Handle(IFSelect_Option) opt = thealiases->Option(command);
+ if (thealiases.IsNull()) thealiases = new MoniTool_Profile;
+ Handle(MoniTool_Option) opt = thealiases->Option(command);
if (opt.IsNull()) {
- opt = new IFSelect_Option(STANDARD_TYPE(TCollection_HAsciiString),command);
+ opt = new MoniTool_Option(STANDARD_TYPE(TCollection_HAsciiString),command);
thealiases->AddOption (opt);
}
opt->Add (conf,new TCollection_HAsciiString(alias));
Handle(TCollection_HAsciiString) val;
if (!thealiases->Value(command,val)) return str;
str.AssignCat (val->ToCString());
- return str;
+ return str;
}
#include <TCollection_HAsciiString.hxx>
#include <IFSelect_SignType.hxx>
#include <IFSelect_SignatureList.hxx>
+#include <IFSelect_ShareOut.hxx>
#include <IFSelect_IntParam.hxx>
#include <TColStd_HSequenceOfAsciiString.hxx>
#include <TColStd_HSequenceOfHAsciiString.hxx>
#include <IFSelect_SelectCombine.hxx>
#include <IFSelect_SelectAnyType.hxx>
#include <IFSelect_SelectAnyList.hxx>
+#include <IFSelect_ShareOut.hxx>
#include <IFSelect_Dispatch.hxx>
#include <IFSelect_Modifier.hxx>
#include <IFSelect_Transformer.hxx>
#include <TColStd_HSequenceOfExtendedString.hxx>
#include <NCollection_DataMap.hxx>
#include <IGESData_IGESEntity.hxx>
+#include <IGESData_IGESModel.hxx>
namespace
{
#include <TransferBRep_ShapeMapper.hxx>
#include <Interface_Macros.hxx>
#include <IGESData_IGESModel.hxx>
+#include <IGESData_IGESEntity.hxx>
#include <BRepToIGES_BREntity.hxx>
#include <BRepToIGESBRep_Entity.hxx>
#include <Transfer_TransientMapper.hxx>
+#include <Transfer_SimpleBinderOfTransient.hxx>
#include <Geom_Curve.hxx>
#include <Geom_Surface.hxx>
#include <GeomToIGES_GeomCurve.hxx>
#include <IGESSelect_WorkLibrary.hxx>
#include <IGESToBRep_Actor.hxx>
#include <IGESData_IGESModel.hxx>
+#include <IGESData_Protocol.hxx>
#include <IGESSolid.hxx>
#include <IGESAppli.hxx>
#include <GeomToIGES_GeomCurve.hxx>
#include <GeomToIGES_GeomSurface.hxx>
#include <IGESData_IGESWriter.hxx>
+#include <IGESData_Protocol.hxx>
#include <XSControl_TransferWriter.hxx>
#include <Interface_Macros.hxx>
#include <Interface_EntityIterator.hxx>
#include <IGESData_SpecificLib.hxx>
#include <IGESData_SpecificModule.hxx>
+#include <IGESData_TransfEntity.hxx>
+#include <IGESData_ViewKindEntity.hxx>
+#include <IGESData_LineFontEntity.hxx>
+#include <IGESData_LevelListEntity.hxx>
+#include <IGESData_LabelDisplayEntity.hxx>
+#include <IGESData_ColorEntity.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Message_Messenger.hxx>
#include <IGESSelect_SelectDrawingFrom.ixx>
#include <IGESSelect_ViewSorter.hxx>
#include <IGESData_IGESModel.hxx>
+#include <IGESData_IGESEntity.hxx>
#include <Interface_Macros.hxx>
#include <IGESSelect_SelectFromDrawing.ixx>
#include <IGESData_IGESEntity.hxx>
+#include <IGESData_ViewKindEntity.hxx>
#include <Interface_Macros.hxx>
#define PourDrawing 404
#include <IGESSelect_SelectFromSingleView.ixx>
#include <IGESData_IGESEntity.hxx>
+#include <IGESData_ViewKindEntity.hxx>
#include <Interface_Macros.hxx>
#include <IGESSelect_SelectSingleViewFrom.ixx>
#include <IGESSelect_ViewSorter.hxx>
#include <IGESData_IGESModel.hxx>
+#include <IGESData_IGESEntity.hxx>
#include <Interface_Macros.hxx>
#include <Interface_ReportEntity.hxx>
#include <IGESData_IGESEntity.hxx>
#include <IGESData_IGESDumper.hxx>
+#include <IGESSolid_Protocol.hxx>
+#include <IGESAppli_Protocol.hxx>
#include <Interface_Check.hxx>
// commercial license or contractual agreement.
#include <Transfer_TransientProcess.hxx>
+#include <IGESData_IGESEntity.hxx>
//=======================================================================
//function : SetEpsilon
#include <IVtk_Interface.hxx>
#include <IVtk_Types.hxx>
+class IVtk_IShape;
DEFINE_STANDARD_HANDLE( IVtk_IShape, IVtk_Interface )
//! @class IVtk_IShape
#include <IVtk_Interface.hxx>
#include <IVtk_Types.hxx>
+class IVtk_IShapeData;
DEFINE_STANDARD_HANDLE( IVtk_IShapeData, IVtk_Interface )
//! @class IVtk_IShapeData
#include <IVtk_IShape.hxx>
#include <IVtk_IShapeData.hxx>
+class IVtk_IShapeMesher;
DEFINE_STANDARD_HANDLE( IVtk_IShapeMesher, IVtk_Interface )
//! @class IVtk_IShapeMesher
#include <IVtk_IView.hxx>
#include <IVtk_IShape.hxx>
+class IVtk_IShapePickerAlgo;
DEFINE_STANDARD_HANDLE( IVtk_IShapePickerAlgo, IVtk_Interface )
//! @class IVtk_IShapePickerAlgo
#include <gp_Pnt.hxx>
#include <Graphic3d_Mat4d.hxx>
+class IVtk_IView;
DEFINE_STANDARD_HANDLE( IVtk_IView, IVtk_Interface )
//! @class IVtk_IView
#include <Standard_Type.hxx>
#include <Standard_Transient.hxx>
+class IVtk_Interface;
DEFINE_STANDARD_HANDLE( IVtk_Interface, Standard_Transient )
//! @class IVtk_Interface
typedef NCollection_DoubleMap<vtkSmartPointer<vtkActor>, TCollection_AsciiString> DoubleMapOfActorsAndNames;
typedef IVtkDraw_HighlightAndSelectionPipeline PipelinePtr;
-typedef Handle(IVtkDraw_HighlightAndSelectionPipeline) Handle(PipelinePtr);
//================================================================
// GLOBAL VARIABLES
#ifndef _IVtkDraw_HighlightAndSelectionPipeline_HeaderFile
#define _IVtkDraw_HighlightAndSelectionPipeline_HeaderFile
-#ifndef _Standard_HeaderFile
-#include <Standard.hxx>
-#endif
-#ifndef _Standard_Macro_HeaderFile
-#include <Standard_Macro.hxx>
-#endif
-#ifndef _Handle_MMgt_TShared_HeaderFile
-#endif
-
#include <NCollection_DataMap.hxx>
-#include <NCollection_Handle.hxx>
+#include <NCollection_Shared.hxx>
#include <Standard_Transient.hxx>
#include <TopoDS_Shape.hxx>
typedef NCollection_DataMap <IVtk_IdType, vtkSmartPointer<IVtkTools_DisplayModeFilter> > DisplayModeFiltersMap;
typedef NCollection_DataMap <IVtk_IdType, vtkSmartPointer<IVtkTools_SubPolyDataFilter> > SubShapesFiltersMap;
+class IVtkDraw_HighlightAndSelectionPipeline;
DEFINE_STANDARD_HANDLE(IVtkDraw_HighlightAndSelectionPipeline, Standard_Transient)
class IVtkDraw_HighlightAndSelectionPipeline : public Standard_Transient
//! Mapping between OCCT topological shape IDs and their correspondent
//! visualization pipelines.
-typedef NCollection_DataMap<IVtk_IdType, Handle(IVtkDraw_HighlightAndSelectionPipeline)> ShapePipelineMap;
+typedef NCollection_Shared< NCollection_DataMap<IVtk_IdType, Handle(IVtkDraw_HighlightAndSelectionPipeline)> > ShapePipelineMap;
#endif
void IVtkOCC_SelectableObject::SetShape (const IVtkOCC_Shape::Handle& theShape)
{
myShape = theShape;
- if (myShape)
+ if (! myShape.IsNull())
{
myShape->SetSelectableObject (this);
}
void IVtkOCC_SelectableObject::ComputeSelection (const Handle(SelectMgr_Selection)& theSelection,
const Standard_Integer theMode)
{
- if (!myShape)
+ if (myShape.IsNull())
{
return;
}
//============================================================================
const Bnd_Box& IVtkOCC_SelectableObject::BoundingBox()
{
- if (!myShape)
+ if (myShape.IsNull())
{
myBndBox.SetVoid();
return myBndBox;
#include <TopTools_IndexedMapOfShape.hxx>
#include <SelectMgr_SelectableObject.hxx>
+class IVtkOCC_Shape;
DEFINE_STANDARD_HANDLE( IVtkOCC_Shape, IVtk_IShape )
//! @class IVtkOCC_Shape
#include <Hatch_Hatcher.hxx>
#include <GCPnts_QuasiUniformDeflection.hxx>
#include <GCPnts_TangentialDeflection.hxx>
+#include <Geom_BezierSurface.hxx>
+#include <Geom_BSplineSurface.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <gp_Dir2d.hxx>
typedef NCollection_Sequence <gp_Pnt> IVtk_Polyline;
typedef NCollection_List <IVtk_Polyline> IVtk_PolylineList;
+class IVtkOCC_ShapeMesher;
DEFINE_STANDARD_HANDLE( IVtkOCC_ShapeMesher, IVtk_IShapeMesher )
//! @class IVtkOCC_ShapeMesher
{
IVtk_SelectionModeList aRes;
- if (theShape)
+ if (! theShape.IsNull())
{
// Get shape implementation from shape interface.
Handle(IVtkOCC_Shape) aShapeImpl = Handle(IVtkOCC_Shape)::DownCast(theShape);
const IVtk_SelectionMode theMode,
const bool theIsTurnOn)
{
- if (!theShape)
+ if (theShape.IsNull())
{
return;
}
Handle(IVtkOCC_SelectableObject) aSelectable =
Handle(IVtkOCC_SelectableObject)::DownCast (anEntityOwner->Selectable());
- if (!aSelectable)
+ if (aSelectable.IsNull())
{
anOutput << "Error: EntityOwner having null SelectableObject picked!";
continue;
}
Handle(IVtkOCC_Shape) aSelShape = aSelectable->GetShape();
- if (!aSelShape)
+ if (aSelShape.IsNull())
{
anOutput << "Error: SelectableObject with null OccShape pointer picked!";
continue;
#include <IVtk_IShapePickerAlgo.hxx>
#include <IVtkOCC_ViewerSelector.hxx>
+class IVtkOCC_ShapePickerAlgo;
DEFINE_STANDARD_HANDLE( IVtkOCC_ShapePickerAlgo, IVtk_IShapePickerAlgo )
//! @class IVtkOCC_ShapePickerAlgo
//================================================================
IVtk_IdType IVtkTools_ShapeDataSource::GetId() const
{
- return myOccShape ? myOccShape->GetId() : -1;
+ return myOccShape.IsNull() ? -1 : myOccShape->GetId();
}
//================================================================
class vtkIdTypeArray;
class vtkPolyData;
+class IVtkVTK_ShapeData;
DEFINE_STANDARD_HANDLE( IVtkVTK_ShapeData, IVtk_IShapeData )
// macros to export static field in class
class vtkRenderer;
+class IVtkVTK_View;
DEFINE_STANDARD_HANDLE( IVtkVTK_View, IVtk_IView )
//! @class IVtkVTK_View
const Standard_Boolean OnFirst,
Standard_Real& U, Standard_Real& V)
{
+ Handle(IntPatch_WLine) wlin = Handle(IntPatch_WLine)::DownCast(L);
+ Handle(IntPatch_RLine) rlin = Handle(IntPatch_RLine)::DownCast(L);
IntPatch_IType typL = L->ArcType();
- const Handle(IntPatch_WLine)& wlin = (const Handle(IntPatch_WLine)&)L;
- const Handle(IntPatch_RLine)& rlin = (const Handle(IntPatch_RLine)&)L;
Standard_Integer Nbptlin = (typL == IntPatch_Walking
? wlin->NbPnts()
: rlin->NbPnts());
const Handle(Adaptor3d_HSurface)& OtherSurf,
const Standard_Boolean OnFirst,
const Standard_Real Tol,
- const Standard_Boolean hasBeenAdded)
+ const Standard_Boolean hasBeenAdded)
{
// Domain est le domaine de restriction de la surface Surf.
Standard_Integer NbSamplesU, NbSamplesV, i, aNbSamplesU1, aNbSamplesV1;
Standard_Real u0, u1, v0, v1, aU, aV, dU, dV;
//
- const Handle(Adaptor3d_HSurface&) MaSurface=(SurfID==1)? MaSurface1 : MaSurface2;
+ const Handle(Adaptor3d_HSurface)& MaSurface=(SurfID==1)? MaSurface1 : MaSurface2;
NbSamplesU=(SurfID==1)? NbSamplesU1:NbSamplesU2;
NbSamplesV=(SurfID==1)? NbSamplesV1:NbSamplesV2;
//
LDOMString.hxx
LDOM_OSStream.cxx
LDOM_OSStream.hxx
-Handle_LDOM_MemManager.hxx
+++ /dev/null
-// Created on: 2002-02-12
-// Created by: Alexander GRIGORIEV
-// Copyright (c) 2002-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef Handle_LDOM_MemManager_HeaderFile
-#define Handle_LDOM_MemManager_HeaderFile
-
-#include <MMgt_TShared.hxx>
-#include <Standard_Type.hxx>
-
-class LDOM_MemManager;
-
-// Define handle class for LDOM_MemManager
-DEFINE_STANDARD_HANDLE (LDOM_MemManager, MMgt_TShared)
-
-#endif
#include <LDOMBasicString.hxx>
+class LDOM_MemManager;
+
// Class LDOMString
// Represents various object types which can be mapped to XML strings
// LDOMString is not an independent type: you must be sure that the owner
#include <LDOM_CDATASection.hxx>
#include <LDOM_Comment.hxx>
+class LDOM_MemManager;
+
// Class LDOM_Document
class LDOM_Document
#include <LDOM_Document.hxx>
class LDOM_BasicElement;
+class LDOM_MemManager;
+
+// Define handle class for LDOM_MemManager
+DEFINE_STANDARD_HANDLE (LDOM_MemManager, MMgt_TShared)
// Class LDOM_MemManager (underlying structure of LDOM_Document)
//
#include <LDOMString.hxx>
class LDOM_BasicNode;
+class LDOM_MemManager;
// LDOM_Node : base class for LDOM interface objects
// references LDOM_BasicNode - the real data stored in Document
#include <BSplCLib.hxx>
-typedef Handle(Law_BSpline) Handle(BSplineCurve);
typedef TColStd_Array1OfInteger Array1OfInteger;
typedef TColStd_HArray1OfInteger HArray1OfInteger;
-
-
-
Law_BSplineKnotSplitting::
-Law_BSplineKnotSplitting (
-
-const Handle(BSplineCurve)& BasisCurve,
-const Standard_Integer ContinuityRange
-
-) {
-
-
+Law_BSplineKnotSplitting (const Handle(Law_BSpline)& BasisCurve,
+ const Standard_Integer ContinuityRange)
+{
if (ContinuityRange < 0) Standard_RangeError::Raise();
Standard_Integer FirstIndex = BasisCurve->FirstUKnotIndex();
const Standard_Integer Id,
const MeshVS_BuilderPriority& Priority )
{
- if (Id<0 && Parent!=0 )
+ if (Id<0 && ! Parent.IsNull())
myId = Parent->GetFreeId();
else
myId = Id;
continue;
}
- Handle(Message_Msg) aMsgCustom = !myReportMessages.IsNull()
- ? myReportMessages->Value (i)
- : Handle(Message_Msg)();
+ NCollection_Handle<Message_Msg> aMsgCustom;
+ if (! myReportMessages.IsNull())
+ aMsgCustom = myReportMessages->Value (i);
if (!aMsgCustom.IsNull())
{
// print custom message
#include <NCollection_Array1.hxx>
#include <NCollection_Handle.hxx>
-typedef NCollection_Array1<Handle(Message_Msg)> Message_ArrayOfMsg;
-typedef Handle(Message_ArrayOfMsg) Message_HArrayOfMsg;
+typedef NCollection_Array1<NCollection_Handle<Message_Msg> > Message_ArrayOfMsg;
+typedef NCollection_Handle<Message_ArrayOfMsg> Message_HArrayOfMsg;
#endif // _Message_HArrayOfMsg_HeaderFile
#include <MoniTool_MTHasher.hxx>
#include <NCollection_DataMap.hxx>
+class MoniTool_Timer;
typedef NCollection_DataMap<Standard_CString,Handle(MoniTool_Timer),MoniTool_MTHasher> MoniTool_DataMapOfTimer;
typedef NCollection_DataMap<Standard_CString,Handle(MoniTool_Timer),MoniTool_MTHasher>::Iterator MoniTool_DataMapIteratorOfDataMapOfTimer;
#include <TCollection_HAsciiString.hxx>
-
+class MoniTool_TypedValue;
typedef Handle(TCollection_HAsciiString) (*MoniTool_ValueInterpret) (const Handle(MoniTool_TypedValue)& typval,
const Handle(TCollection_HAsciiString)& val,
const Standard_Boolean native);
#include <windows.h>
#endif
-IMPLEMENT_STANDARD_HANDLE (NCollection_WinHeapAllocator,
- NCollection_BaseAllocator)
-IMPLEMENT_STANDARD_RTTIEXT(NCollection_WinHeapAllocator,
- NCollection_BaseAllocator)
-
//=======================================================================
//function : NCollection_WinHeapAllocator
//purpose : Main constructor
EXTERNLIB
OpenGl_CMPLRS.edl
-Handle_OpenGl_GraphicDriver.hxx
OpenGl_GraphicDriver.hxx
OpenGl_GraphicDriver.cxx
OpenGl_GraphicDriver_4.cxx
OpenGl_TextFormatter.cxx
OpenGl_PointSprite.hxx
OpenGl_PointSprite.cxx
-Handle_OpenGl_PointSprite.hxx
OpenGl_PrimitiveArray.hxx
OpenGl_PrimitiveArray.cxx
-Handle_OpenGl_Workspace.hxx
OpenGl_Workspace.hxx
OpenGl_Workspace.cxx
OpenGl_Workspace_2.cxx
OpenGl_Workspace_5.cxx
-Handle_OpenGl_View.hxx
OpenGl_View.hxx
OpenGl_View.cxx
OpenGl_View_2.cxx
OpenGl_PrinterContext.cxx
OpenGl_LineAttributes.hxx
OpenGl_LineAttributes.cxx
-Handle_OpenGl_Window.hxx
OpenGl_Window.hxx
OpenGl_Window.cxx
OpenGl_Window_1.mm
OpenGl_AVIWriter.hxx
OpenGl_AVIWriter.cxx
-Handle_OpenGl_FrameBuffer.hxx
OpenGl_FrameBuffer.hxx
OpenGl_FrameBuffer.cxx
OpenGl_Texture.cxx
OpenGl_Texture.hxx
-Handle_OpenGl_Texture.hxx
OpenGl_Resource.hxx
OpenGl_Resource.cxx
OpenGl_telem_util.hxx
OpenGl_tgl_funcs.hxx
OpenGl_Caps.hxx
OpenGl_Caps.cxx
-Handle_OpenGl_Context.hxx
OpenGl_Context.hxx
OpenGl_Context.cxx
OpenGl_Context_1.mm
OpenGl_ShaderManager.cxx
OpenGl_ShaderStates.hxx
OpenGl_ShaderStates.cxx
-Handle_OpenGl_ShaderObject.hxx
-Handle_OpenGl_ShaderProgram.hxx
-Handle_OpenGl_ShaderManager.hxx
OpenGl_SceneGeometry.hxx
OpenGl_SceneGeometry.cxx
OpenGl_View_Raytrace.cxx
OpenGl_BVHClipPrimitiveSet.cxx
OpenGl_BVHClipPrimitiveSet.hxx
OpenGl_ArbTexBindless.hxx
-Handle_OpenGl_Sampler.hxx
OpenGl_Sampler.hxx
OpenGl_Sampler.cxx
OpenGl_Utils.hxx
+++ /dev/null
-// Created on: 2012-01-26
-// Created by: Kirill GAVRILOV
-// Copyright (c) 2012-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef _Handle_OpenGl_Context_Header
-#define _Handle_OpenGl_Context_Header
-
-#include <Standard_Type.hxx>
-
-class OpenGl_Context;
-DEFINE_STANDARD_HANDLE(OpenGl_Context, Standard_Transient)
-
-#endif // _Handle_OpenGl_Context_Header
+++ /dev/null
-// Copyright (c) 2015 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef _Handle_OpenGl_FrameBuffer_Header
-#define _Handle_OpenGl_FrameBuffer_Header
-
-#include <OpenGl_Resource.hxx>
-
-class OpenGl_FrameBuffer;
-DEFINE_STANDARD_HANDLE(OpenGl_FrameBuffer, OpenGl_Resource)
-
-#endif // _Handle_OpenGl_FrameBuffer_Header
+++ /dev/null
-// Created on: 2011-10-20
-// Created by: Sergey ZERCHANINOV
-// Copyright (c) 2011-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef _Handle_OpenGl_GraphicDriver_Header
-#define _Handle_OpenGl_GraphicDriver_Header
-
-#include <Standard_Type.hxx>
-
-class OpenGl_GraphicDriver;
-
-// Handle definition
-//
-DEFINE_STANDARD_HANDLE(OpenGl_GraphicDriver,Graphic3d_GraphicDriver)
-
-#endif //_Handle_OpenGl_GraphicDriver_Header
+++ /dev/null
-// Created on: 2013-08-26
-// Created by: Kirill GAVRILOV
-// Copyright (c) 2013-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef _Handle_OpenGl_PointSprite_Header
-#define _Handle_OpenGl_PointSprite_Header
-
-
-class OpenGl_PointSprite;
-DEFINE_STANDARD_HANDLE(OpenGl_PointSprite, OpenGl_Texture)
-
-#endif // _Handle_OpenGl_PointSprite_Header
+++ /dev/null
-// Created on: 2014-10-17
-// Created by: Denis BOGOLEPOV
-// Copyright (c) 2013-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef _Handle_OpenGl_Sampler_HeaderFile
-#define _Handle_OpenGl_Sampler_HeaderFile
-
-#include <OpenGl_Resource.hxx>
-
-class OpenGl_Sampler;
-DEFINE_STANDARD_HANDLE(OpenGl_Sampler, OpenGl_Resource)
-
-#endif
+++ /dev/null
-// Created on: 2013-09-26
-// Created by: Denis BOGOLEPOV
-// Copyright (c) 2013-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef _Handle_OpenGl_ShaderManager_HeaderFile
-#define _Handle_OpenGl_ShaderManager_HeaderFile
-
-class OpenGl_ShaderManager;
-DEFINE_STANDARD_HANDLE(OpenGl_ShaderManager, Standard_Transient)
-
-#endif
+++ /dev/null
-// Created on: 2013-09-19
-// Created by: Denis BOGOLEPOV
-// Copyright (c) 2013-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef _Handle_OpenGl_ShaderObject_Header
-#define _Handle_OpenGl_ShaderObject_Header
-
-#include <OpenGl_Resource.hxx>
-
-class OpenGl_ShaderObject;
-DEFINE_STANDARD_HANDLE(OpenGl_ShaderObject, OpenGl_Resource)
-
-#endif
+++ /dev/null
-// Created on: 2013-09-19
-// Created by: Denis BOGOLEPOV
-// Copyright (c) 2013-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef _Handle_OpenGl_ShaderProgram_Header
-#define _Handle_OpenGl_ShaderProgram_Header
-
-#include <OpenGl_Resource.hxx>
-
-class OpenGl_ShaderProgram;
-DEFINE_STANDARD_HANDLE(OpenGl_ShaderProgram, OpenGl_Resource)
-
-#endif
+++ /dev/null
-// Copyright (c) 2013-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef _Handle_OpenGl_Texture_Header
-#define _Handle_OpenGl_Texture_Header
-
-#include <OpenGl_Resource.hxx>
-
-class OpenGl_Texture;
-DEFINE_STANDARD_HANDLE(OpenGl_Texture, OpenGl_Resource)
-
-#endif // _Handle_OpenGl_Texture_Header
+++ /dev/null
-// Created on: 2011-09-20
-// Created by: Sergey ZERCHANINOV
-// Copyright (c) 2011-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef _Handle_OpenGl_View_Header
-#define _Handle_OpenGl_View_Header
-
-#include <Standard_Type.hxx>
-
-class OpenGl_View;
-
-// Handle definition
-//
-DEFINE_STANDARD_HANDLE(OpenGl_View,MMgt_TShared)
-
-
-#endif //_Handle_OpenGl_View_Header
+++ /dev/null
-// Created on: 2011-09-20
-// Created by: Sergey ZERCHANINOV
-// Copyright (c) 2011-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef _Handle_OpenGl_Window_Header
-#define _Handle_OpenGl_Window_Header
-
-#include <Standard_Type.hxx>
-
-class OpenGl_Window;
-
-// Handle definition
-//
-DEFINE_STANDARD_HANDLE(OpenGl_Window,MMgt_TShared)
-
-
-#endif //_Handle_OpenGl_Window_Header
+++ /dev/null
-// Created on: 2011-09-20
-// Created by: Sergey ZERCHANINOV
-// Copyright (c) 2011-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef _Handle_OpenGl_Workspace_Header
-#define _Handle_OpenGl_Workspace_Header
-
-#include <Standard_Type.hxx>
-
-class OpenGl_Workspace;
-
-// Handle definition
-//
-DEFINE_STANDARD_HANDLE(OpenGl_Workspace,OpenGl_Window)
-
-
-#endif //_Handle_OpenGl_Workspace_Header
#include <Graphic3d_ShaderProgram.hxx>
#include <Graphic3d_TextureMap.hxx>
+#include <Graphic3d_TextureParams.hxx>
#include <Graphic3d_TypeOfReflection.hxx>
#include <Graphic3d_MaterialAspect.hxx>
+#include <Image_PixMap.hxx>
+
namespace
{
static OPENGL_SURF_PROP THE_DEFAULT_MATERIAL =
#include <Graphic3d_TextureMap.hxx>
#include <Graphic3d_BSDF.hxx>
+class OpenGl_Texture;
+
#define OPENGL_AMBIENT_MASK (1<<0)
#define OPENGL_DIFFUSE_MASK (1<<1)
#define OPENGL_SPECULAR_MASK (1<<2)
#include <InterfaceGraphic_Graphic3d.hxx>
#include <Aspect_TypeOfLine.hxx>
#include <Graphic3d_CAspectLine.hxx>
-
-
#include <OpenGl_Element.hxx>
+class OpenGl_ShaderProgram;
+
class OpenGl_AspectLine : public OpenGl_Element
{
public:
#include <OpenGl_Element.hxx>
-#include <Image_PixMap_Handle.hxx>
+class OpenGl_PointSprite;
+class OpenGl_ShaderProgram;
class OpenGl_AspectMarker : public OpenGl_Element
{
#include <OpenGl_Element.hxx>
+class OpenGl_ShaderProgram;
+
//! Text representation parameters
class OpenGl_AspectText : public OpenGl_Element
{
#include <OpenGl_BVHClipPrimitiveSet.hxx>
#include <BVH_BinnedBuilder.hxx>
+#include <Graphic3d_GraphicDriver.hxx>
// =======================================================================
// function : OpenGl_BVHClipPrimitiveSet
#include <OpenGl_BVHTreeSelector.hxx>
#include <OpenGl_BVHClipPrimitiveSet.hxx>
+#include <Graphic3d_GraphicDriver.hxx>
// =======================================================================
// function : OpenGl_BVHTreeSelector
#include <Aspect_FillMethod.hxx>
#include <NCollection_AlignedAllocator.hxx>
#include <OpenGl_Texture.hxx>
+#include <Graphic3d_TextureParams.hxx>
// =======================================================================
// method : Constructor
#include <OpenGl_CappingPlaneResource.hxx>
#include <OpenGl_Vec.hxx>
#include <OpenGl_Structure.hxx>
-
+#include <Graphic3d_GraphicDriver.hxx>
namespace
{
#include <Graphic3d_SequenceOfGroup.hxx>
// Forward declaration
-
+class OpenGl_CappingAlgoFilter;
DEFINE_STANDARD_HANDLE (OpenGl_CappingAlgoFilter, OpenGl_RenderFilter)
//! Capping surface rendering algorithm.
#include <OpenGl_Matrix.hxx>
#include <Graphic3d_ClipPlane.hxx>
-
+class OpenGl_CappingPlaneResource;
DEFINE_STANDARD_HANDLE (OpenGl_CappingPlaneResource, OpenGl_Resource)
//! Container of graphical resources for rendering capping plane
#include <Standard_TypeDef.hxx>
#include <OpenGl_Matrix.hxx>
+class OpenGl_Workspace;
+
//! This class contains logics related to tracking and modification of clipping plane
//! state for particular OpenGl context. It contains information about enabled
//! clipping planes and provides method to change clippings in context. The methods
}
}
- if (myActiveProgram != NULL)
+ if (!myActiveProgram.IsNull())
{
myActiveProgram->SetUniform (this, "uPattern", aPattern);
myActiveProgram->SetUniform (this, "uFactor", theFactor);
#include <OpenGl_Clipping.hxx>
#include <OpenGl_GlCore11.hxx>
#include <OpenGl_Utils.hxx>
+#include <OpenGl_ShaderProgram.hxx>
+
+#include <NCollection_Shared.hxx>
//! Forward declarations
#if defined(__APPLE__)
typedef OpenGl_TmplCore44<OpenGl_GlCore43Back> OpenGl_GlCore44Back;
typedef OpenGl_TmplCore44<OpenGl_GlCore43> OpenGl_GlCore44;
+class OpenGl_ShaderManager;
+class OpenGl_Sampler;
+class OpenGl_FrameBuffer;
+
+class OpenGl_Context;
+DEFINE_STANDARD_HANDLE(OpenGl_Context, Standard_Transient)
+
//! This class generalize access to the GL context and available extensions.
//!
//! Functions related to specific OpenGL version or extension are grouped into structures which can be accessed as fields of this class.
private: // context info
- typedef NCollection_DataMap<TCollection_AsciiString, Standard_Integer> OpenGl_DelayReleaseMap;
- typedef NCollection_DataMap<TCollection_AsciiString, Handle(OpenGl_Resource)> OpenGl_ResourcesMap;
- typedef NCollection_List<Handle(OpenGl_Resource)> OpenGl_ResourcesStack;
+ typedef NCollection_Shared< NCollection_DataMap<TCollection_AsciiString, Standard_Integer> > OpenGl_DelayReleaseMap;
+ typedef NCollection_Shared< NCollection_DataMap<TCollection_AsciiString, Handle(OpenGl_Resource)> > OpenGl_ResourcesMap;
+ typedef NCollection_Shared< NCollection_List<Handle(OpenGl_Resource)> > OpenGl_ResourcesStack;
Handle(OpenGl_ResourcesMap) mySharedResources; //!< shared resources with unique identification key
Handle(OpenGl_DelayReleaseMap) myDelayed; //!< shared resources for delayed release
#include <OpenGl_RenderFilter.hxx>
+class OpenGl_Workspace;
+class OpenGl_Context;
+
//! Base interface for drawable elements.
class OpenGl_Element
{
#include <Standard_Boolean.hxx>
#include <InterfaceGraphic.hxx>
+class OpenGl_FrameBuffer;
+DEFINE_STANDARD_HANDLE(OpenGl_FrameBuffer, OpenGl_Resource)
//! Class implements FrameBuffer Object (FBO) resource
//! intended for off-screen rendering.
#include <InterfaceGraphic_Aspect.hxx>
#include <InterfaceGraphic_Visual3d.hxx>
-#ifndef _WIN32
- #include <string.h>
-#endif
-
#include <OpenGl_GraduatedTrihedron.hxx>
#include <Graphic3d_ArrayOfPolylines.hxx>
#include <Graphic3d_ArrayOfSegments.hxx>
+#include <Graphic3d_GraphicDriver.hxx>
#include <gp_Ax3.hxx>
#include <OpenGl_AspectLine.hxx>
#include <OpenGl_Utils.hxx>
#include <OpenGl_Cylinder.hxx>
#include <Precision.hxx>
+#ifndef _WIN32
+ #include <string.h>
+#endif
+
namespace
{
static const OpenGl_TextParam THE_LABEL_PARAMS =
class OpenGl_Element;
class OpenGl_Structure;
class OpenGl_Text;
+class OpenGl_View;
//! Tool class to implement consistent state counter
//! for objects inside the same driver instance.
Standard_Size myCounter;
};
+class OpenGl_GraphicDriver;
+DEFINE_STANDARD_HANDLE(OpenGl_GraphicDriver,Graphic3d_GraphicDriver)
+
//! This class defines an OpenGl graphic driver
class OpenGl_GraphicDriver : public Graphic3d_GraphicDriver
{
myIsRaytracable (Standard_False)
{
Handle(OpenGl_Structure) aStruct = Handle(OpenGl_Structure)::DownCast (myStructure->CStructure());
- if (aStruct == NULL)
+ if (aStruct.IsNull())
{
Graphic3d_GroupDefinitionError::Raise ("OpenGl_Group should be created by OpenGl_Structure!");
}
#include <OpenGl_Structure.hxx>
#include <OpenGl_View.hxx>
#include <OpenGl_Workspace.hxx>
+#include <Graphic3d_GraphicDriver.hxx>
// =======================================================================
// function : OpenGl_PriorityList
#include <InterfaceGraphic_Graphic3d.hxx>
#include <InterfaceGraphic.hxx>
+#include <Graphic3d_GraphicDriver.hxx>
//=======================================================================
//function : OpenGl_LayerList
#include <OpenGl_Texture.hxx>
+class OpenGl_PointSprite;
+DEFINE_STANDARD_HANDLE(OpenGl_PointSprite, OpenGl_Texture)
+
//! Point sprite resource. On modern hardware it will be texture with extra parameters.
//! On ancient hardware sprites will be drawn using bitmaps.
class OpenGl_PointSprite : public OpenGl_Texture
#include <Standard_Type.hxx>
#include <Standard_Transient.hxx>
+class OpenGl_RenderFilter;
DEFINE_STANDARD_HANDLE (OpenGl_RenderFilter, Standard_Transient)
class OpenGl_Element;
#include <OpenGl_Context.hxx>
+class OpenGl_Sampler;
+DEFINE_STANDARD_HANDLE(OpenGl_Sampler, OpenGl_Resource)
+
//! Class implements OpenGL sampler object resource that
//! stores the sampling parameters for a texture access.
class OpenGl_Sampler : public OpenGl_Resource
#include <OpenGl_Structure.hxx>
#include <OSD_Timer.hxx>
#include <Standard_Assert.hxx>
+#include <Graphic3d_GraphicDriver.hxx>
//! Use this macro to output BVH profiling info
// #define RAY_TRACE_PRINT_INFO
//! Map to declare per-program states of OCCT materials.
typedef NCollection_DataMap<Handle(OpenGl_ShaderProgram), OpenGl_MaterialState> OpenGl_MaterialStates;
+class OpenGl_ShaderManager;
+DEFINE_STANDARD_HANDLE(OpenGl_ShaderManager, Standard_Transient)
+
//! This class is responsible for managing shader programs.
class OpenGl_ShaderManager : public Standard_Transient
{
#include <OpenGl_GlCore20.hxx>
#include <OpenGl_Resource.hxx>
+class OpenGl_ShaderObject;
+DEFINE_STANDARD_HANDLE(OpenGl_ShaderObject, OpenGl_Resource)
+
//! Wrapper for OpenGL shader object.
class OpenGl_ShaderObject : public OpenGl_Resource
{
#include <OpenGl_Matrix.hxx>
#include <OpenGl_ShaderObject.hxx>
+class OpenGl_ShaderProgram;
+DEFINE_STANDARD_HANDLE(OpenGl_ShaderProgram, OpenGl_Resource)
+
//! The enumeration of OCCT-specific OpenGL/GLSL variables.
enum OpenGl_StateVariable
{
#include <OpenGl_StructureShadow.hxx>
+#include <Graphic3d_GraphicDriver.hxx>
//=======================================================================
//function : OpenGl_StructureShadow
Handle(OpenGl_Context) aCtx = theCtx;
const TCollection_AsciiString aKey = myFont->ResourceKey();
myFont.Nullify();
- if (aCtx)
+ if (! aCtx.IsNull())
aCtx->ReleaseResource (aKey, Standard_True);
}
}
#include <Graphic3d_HorizontalTextAlignment.hxx>
#include <Graphic3d_VerticalTextAlignment.hxx>
+class OpenGl_PrinterContext;
//! Text rendering
class OpenGl_Text : public OpenGl_Element
#include <Graphic3d_TypeOfTexture.hxx>
class OpenGl_Context;
+class Graphic3d_TextureParams;
class Image_PixMap;
//! Selects preferable texture format for specified parameters.
};
+class OpenGl_Texture;
+DEFINE_STANDARD_HANDLE(OpenGl_Texture, OpenGl_Resource)
+
//! Texture resource.
class OpenGl_Texture : public OpenGl_Resource
{
#include <Graphic3d_ArrayOfSegments.hxx>
#include <Graphic3d_ArrayOfPolylines.hxx>
+#include <Graphic3d_GraphicDriver.hxx>
#include <OpenGl_View.hxx>
#include <OpenGl_Workspace.hxx>
#include <Precision.hxx>
class OpenGl_Structure;
class OpenGl_StateCounter;
+class OpenGl_View;
+DEFINE_STANDARD_HANDLE(OpenGl_View,MMgt_TShared)
+
class OpenGl_View : public MMgt_TShared
{
public:
#include <Graphic3d_TextureParams.hxx>
#include <Graphic3d_Texture2Dmanual.hxx>
+#include <Graphic3d_GraphicDriver.hxx>
#include <Image_AlienPixMap.hxx>
#include <Visual3d_Layer.hxx>
#include <OpenGl_PrimitiveArray.hxx>
#include <OpenGl_VertexBuffer.hxx>
#include <OpenGl_View.hxx>
+#include <Graphic3d_GraphicDriver.hxx>
#include <OSD_Protection.hxx>
#include <OSD_File.hxx>
#include <Aspect_GraphicDeviceDefinitionError.hxx>
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>
+#include <Graphic3d_GraphicDriver.hxx>
#if defined(HAVE_EGL) || defined(__ANDROID__)
#include <EGL/egl.h>
#include <OpenGl_GlCore11.hxx>
#include <InterfaceGraphic_Aspect.hxx>
#include <OpenGl_Caps.hxx>
-
-
#include <MMgt_TShared.hxx>
+
#if defined(__APPLE__)
#import <TargetConditionals.h>
#endif
#endif
#endif
+class OpenGl_Context;
+class OpenGl_GraphicDriver;
+
+class OpenGl_Window;
+DEFINE_STANDARD_HANDLE(OpenGl_Window,MMgt_TShared)
+
//! This class represents low-level wrapper over window with GL context.
//! The window itself should be provided to constructor.
class OpenGl_Window : public MMgt_TShared
#include <OpenGl_Workspace.hxx>
#include <Graphic3d_TextureParams.hxx>
+#include <Graphic3d_GraphicDriver.hxx>
#if defined(_WIN32) && defined(HAVE_VIDEOCAPTURE)
#include <OpenGl_AVIWriter.hxx>
};
+class OpenGl_RaytraceFilter;
DEFINE_STANDARD_HANDLE (OpenGl_RaytraceFilter, OpenGl_RenderFilter)
//! Graphical ray-tracing filter.
DEFINE_STANDARD_RTTI(OpenGl_RaytraceFilter, OpenGl_RenderFilter)
};
+class OpenGl_Workspace;
+DEFINE_STANDARD_HANDLE(OpenGl_Workspace,OpenGl_Window)
+
//! Represents window with GL context.
//! Provides methods to render primitives and maintain GL state.
class OpenGl_Workspace : public OpenGl_Window
#include <OpenGl_FrameBuffer.hxx>
#include <TColStd_Array2OfReal.hxx>
#include <OpenGl_telem_util.hxx>
+#include <Graphic3d_GraphicDriver.hxx>
+
+#include <OpenGl_PrinterContext.hxx>
+#include <OpenGl_Workspace.hxx>
+#include <OpenGl_View.hxx>
#if (defined(_WIN32) || defined(__WIN32__)) && defined(HAVE_FREEIMAGE)
#include <NCollection_Handle.hxx>
typedef NCollection_Handle<fipImage> FipHandle;
#endif
-#include <OpenGl_PrinterContext.hxx>
-#include <OpenGl_Workspace.hxx>
-#include <OpenGl_View.hxx>
-
#ifdef _WIN32
#ifndef HAVE_FREEIMAGE
#include <OpenGl_Context.hxx>
#include <OpenGl_ShaderManager.hxx>
#include <OpenGl_telem_util.hxx>
+#include <Graphic3d_GraphicDriver.hxx>
+
+#include <Aspect_PolygonOffsetMode.hxx>
+#include <OpenGl_View.hxx>
-/* OCC22218 NOTE: project dependency on gl2ps is specified by macro */
#ifdef HAVE_GL2PS
#include <gl2ps.h>
/* OCC22216 NOTE: linker dependency can be switched off by undefining macro.
#endif
#endif
-#include <Aspect_PolygonOffsetMode.hxx>
-#include <OpenGl_View.hxx>
-
/*----------------------------------------------------------------------*/
static void TelUpdatePolygonOffsets (const TEL_POFFSET_PARAM& theOffsetData)
#include <NCollection_IndexedMap.hxx>
#include <TColStd_PackedMapOfInteger.hxx>
#include <TColStd_MapIteratorOfPackedMapOfInteger.hxx>
-#include <NCollection_BaseAllocator.hxx>
+#include <NCollection_IncAllocator.hxx>
#include <NCollection_List.hxx>
class Prs3d_DimensionAspect;
class TCollection_AsciiString;
+class Prs3d_Drawer;
DEFINE_STANDARD_HANDLE(Prs3d_Drawer, MMgt_TShared)
//! A graphic attribute manager which governs how
#include <Quantity_Length.hxx>
class Adaptor3d_Curve;
+class BRepAdaptor_HSurface;
class TopoDS_Edge;
class TopoDS_Shape;
+class Prs3d_Drawer;
class Prs3d_WFShape : Prs3d_Root
{
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
+#include <PrsMgr_Prs.hxx>
+
inline void PrsMgr_Presentation::SetUpdateStatus (const Standard_Boolean theUpdateStatus)
{
myMustBeUpdated = theUpdateStatus;
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
+#include <Visual3d_ViewManager.hxx>
+
inline Standard_Boolean PrsMgr_PresentationManager::IsImmediateModeOn() const
{
return myImmediateModeOn > 0;
#include<BRepAlgo_Cut.hxx>
#include<BRepPrimAPI_MakeHalfSpace.hxx>
-#include<Handle_Geom_CartesianPoint.hxx>
#include<Geom_CartesianPoint.hxx>
#include<AIS_Point.hxx>
HT aHandle;
// QVERIFY (aHandle.IsNull());
QCOMPARE (aHandle.IsNull(), Standard_True);
- const T* p = aHandle.Access();
+ const T* p = aHandle.get();
#if OCC_VERSION_HEX > 0x060700
//QVERIFY (!p);
//QVERIFY (p == 0);
aHandle = new T;
//QVERIFY (!aHandle.IsNull());
QCOMPARE (!aHandle.IsNull(), Standard_True);
- p = aHandle.Access();
+ p = aHandle.get();
//QVERIFY (p);
//QVERIFY (p != 0);
QCOMPARE (p != NULL, Standard_True);
#include <HeaderSection_FileName.hxx>
#include <HeaderSection_FileDescription.hxx>
#include <HeaderSection_FileSchema.hxx>
+#include <HeaderSection_Protocol.hxx>
#include <StepData_UndefinedEntity.hxx>
#include <Interface_Macros.hxx>
RWHeaderSection_GeneralModule::RWHeaderSection_GeneralModule ()
- { Interface_GeneralLib::SetGlobal(this, HeaderSection::Protocol()); }
+{
+ Interface_GeneralLib::SetGlobal(this, HeaderSection::Protocol());
+}
void RWHeaderSection_GeneralModule::FillSharedCase(const Standard_Integer CN, const Handle(Standard_Transient)& ent, Interface_EntityIterator& iter) const
{
#include <StepBasic_ApprovalRelationship.hxx>
#include <StepBasic_ApprovalRole.hxx>
#include <StepBasic_ApprovalStatus.hxx>
+#include <StepBasic_AreaUnit.hxx>
#include <StepVisual_AreaInSet.hxx>
+#include <StepBasic_VolumeUnit.hxx>
#include <StepAP214_AutoDesignActualDateAndTimeAssignment.hxx>
#include <StepAP214_AutoDesignActualDateAssignment.hxx>
#include <StepAP214_AutoDesignApprovalAssignment.hxx>
#include <RWStepShape_RWSeamEdge.ixx>
#include <StepShape_Edge.hxx>
+#include <StepShape_Vertex.hxx>
#include <StepGeom_Pcurve.hxx>
//=======================================================================
#include <StepShape_HArray1OfOrientedEdge.hxx>
#include <StepShape_HArray1OfShell.hxx>
#include <StepShape_ShapeRepresentation.hxx>
+#include <StepShape_OpenShell.hxx>
+#include <StepShape_Vertex.hxx>
#include <StepRepr_NextAssemblyUsageOccurrence.hxx>
#include <StepRepr_AssemblyComponentUsage.hxx>
#include <StepRepr_PropertyDefinitionRepresentation.hxx>
#include <StepVisual_StyledItem.hxx>
#include <StepVisual_PresentationStyleByContext.hxx>
#include <StepVisual_HArray1OfPresentationStyleSelect.hxx>
+#include <StepVisual_PointStyle.hxx>
+#include <StepVisual_CurveStyle.hxx>
+#include <StepVisual_SurfaceStyleUsage.hxx>
#include <TDF_AttributeSequence.hxx>
#include <TColStd_MapOfTransient.hxx>
-// #include <TColStd_IndexedDataMapOfTransientTransient.hxx>
#include <StepRepr_NextAssemblyUsageOccurrence.hxx>
#include <Interface_EntityIterator.hxx>
#include <StepRepr_SpecifiedHigherUsageOccurrence.hxx>
#include <StepBasic_SiUnitAndLengthUnit.hxx>
#include <StepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext.hxx>
#include <StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx.hxx>
+#include <StepGeom_Surface.hxx>
#include <StepBasic_LengthMeasureWithUnit.hxx>
#include <StepShape_EdgeCurve.hxx>
#include <StepShape_AdvancedFace.hxx>
#include <StepBasic_Person.hxx>
#include <StepBasic_Organization.hxx>
#include <StepBasic_SecurityClassification.hxx>
+#include <StepBasic_Product.hxx>
+#include <StepBasic_ProductDefinition.hxx>
+#include <StepBasic_ProductDefinitionFormation.hxx>
+#include <StepBasic_ProductRelatedProductCategory.hxx>
#include <StepAP203_HArray1OfPersonOrganizationItem.hxx>
#include <StepAP203_HArray1OfClassifiedItem.hxx>
#include <StepAP203_HArray1OfDateTimeItem.hxx>
#include <StepBasic_ProductType.hxx> //:i3
#include <Interface_Static.hxx> //:j4
#include <GeomToStep_MakeAxis2Placement3d.hxx>
+#include <StepBasic_ApprovalPersonOrganization.hxx>
+#include <StepBasic_ApprovalDateTime.hxx>
#include <StepBasic_ProductRelatedProductCategory.hxx>
+#include <StepBasic_ProductCategoryRelationship.hxx>
+#include <StepShape_ShapeDefinitionRepresentation.hxx>
+#include <StepAP203_CcDesignPersonAndOrganizationAssignment.hxx>
+#include <StepAP203_CcDesignSecurityClassification.hxx>
+#include <StepAP203_CcDesignDateAndTimeAssignment.hxx>
+#include <StepAP203_CcDesignApproval.hxx>
#include "stdio.h"
#include <gp_Ax2.hxx>
#include <GeomToStep_MakeAxis2Placement3d.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
+#include <StepGeom_Point.hxx>
+#include <StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx.hxx>
#include <STEPConstruct_Part.hxx>
#include <STEPConstruct_Assembly.hxx>
// gka 05.04.99 S4136: parameters definitions changed
#include <STEPControl_Controller.ixx>
#include <StepSelect_WorkLibrary.hxx>
-#include <IFSelect_Option.hxx>
-#include <IFSelect_Profile.hxx>
+#include <MoniTool_Option.hxx>
+#include <MoniTool_Profile.hxx>
//#include <StepAP214.hxx>
#include <RWStepAP214.hxx>
// ActorRead : on ajoute le cas Shape possible, a part du default
// ainsi, on l a tjrs sous la main
- Handle(IFSelect_Option) optacrd = Profile()->Option("tr-read");
+ Handle(MoniTool_Option) optacrd = Profile()->Option("tr-read");
optacrd->Add ("shape",theAdaptorRead);
// ActorWrite : on ajoute les cas possibles (NB : shape == default)
// On garde a part les cas shape compound (= shape traitee globale ou en
// assembly), peuvent etre utiles. Tandis que les autres cas sont
// susceptibles d etre remplaces si on fait du Model-Editor
- Handle(IFSelect_Option) optacwr = Profile()->Option("tr-write");
+ Handle(MoniTool_Option) optacwr = Profile()->Option("tr-write");
Handle(STEPControl_ActorWrite) ActWSh = new STEPControl_ActorWrite;
ActWSh->SetGroupMode(0);
optacwr->Add ("shape",ActWSh);
// commercial license or contractual agreement.
#include <STEPEdit.ixx>
-//#include <StepData_FileProtocol.hxx>
+
#include <StepAP214.hxx>
-//#include <HeaderSection.hxx>
+#include <StepAP214_Protocol.hxx>
#include <APIHeaderSection_MakeHeader.hxx>
#include <StepData_StepModel.hxx>
#include <STEPConstruct_ContextTool.hxx>
-
+#include <StepBasic_ApplicationProtocolDefinition.hxx>
STEPEdit_EditContext::STEPEdit_EditContext ()
: IFSelect_Editor (5)
#include <NCollection_Sequence.hxx>
-
+class Select3D_SensitiveEntity;
typedef NCollection_Sequence<Handle(Select3D_SensitiveEntity)> Select3D_EntitySequence;
typedef NCollection_Sequence<Handle(Select3D_SensitiveEntity)>::Iterator Select3D_EntitySequenceIter;
//! selection. It contains signatures of functions for detection of
//! overlap by sensitive entity and initializes some data for building
//! the selecting frustum
-class SelectMgr_BaseFrustum
+class SelectMgr_BaseFrustum : public Standard_Transient
{
public:
virtual Standard_Boolean IsClipped (const Graphic3d_SequenceOfHClipPlane& thePlanes,
const Standard_Real theDepth);
+ DEFINE_STANDARD_RTTI(SelectMgr_BaseFrustum, Standard_Transient)
+
protected:
Standard_Real myPixelTolerance; //!< Pixel tolerance
Standard_Boolean myIsOrthographic; //!< Defines if current camera is orthographic
#ifndef _SelectMgr_IndexedMapOfOwner_HeaderFile
#define _SelectMgr_IndexedMapOfOwner_HeaderFile
-#include <NCollection_Handle.hxx>
#include <NCollection_IndexedMap.hxx>
+#include <NCollection_Shared.hxx>
class SelectMgr_EntityOwner;
-typedef NCollection_IndexedMap<Handle(SelectMgr_EntityOwner)> SelectMgr_IndexedMapOfOwner;
-typedef NCollection_Handle<NCollection_IndexedMap<Handle(SelectMgr_EntityOwner)> > Handle(SelectMgr_IndexedMapOfOwner);
+typedef NCollection_Shared< NCollection_IndexedMap<Handle(SelectMgr_EntityOwner)> > SelectMgr_IndexedMapOfOwner;
#endif // _SelectMgr_IndexedMapOfOwner_HeaderFile
#include <Graphic3d_AspectLine3d.hxx>
#include <Graphic3d_AspectMarker3d.hxx>
#include <PrsMgr_PresentableObjectPointer.hxx>
+#include <SelectMgr_IndexedMapOfOwner.hxx>
#include <TopLoc_Location.hxx>
#include <gp_Pnt.hxx>
#include <Standard_NullObject.hxx>
+#include <SelectBasics_EntityOwner.hxx>
#include <SelectMgr_Selection.hxx>
-
//==================================================
// Function: SelectMgr_Selection
// Purpose :
if (!theObj->HasOwnPresentations())
return;
- if (theSelector == NULL)
+ if (theSelector.IsNull())
{
if (!(myGlobal.Contains (theObj) || myLocal.IsBound(theObj)))
return;
if (!theObj->HasOwnPresentations())
return;
- if (theSelector == NULL)
+ if (theSelector.IsNull())
{
if (!(myGlobal.Contains (theObj) || myLocal.IsBound(theObj)))
return;
//=======================================================================
void SelectMgr_SelectionManager::rebuildSelectionStructures (const Handle(SelectMgr_ViewerSelector)& theSelector)
{
- if (theSelector == NULL)
+ if (theSelector.IsNull())
{
Handle(SelectMgr_ViewerSelector) aSelector;
for(TColStd_MapIteratorOfMapOfTransient aSelectorsIter (mySelectors); aSelectorsIter.More(); aSelectorsIter.Next())
{
Handle(SelectMgr_Selection) aNewSel = new SelectMgr_Selection (theMode);
theObject->AddSelection (aNewSel, theMode);
- if (theSelector == NULL)
+ if (theSelector.IsNull())
{
if (myGlobal.Contains (theObject))
{
//! Nullifies the handle to corresponding builder instance to prevent memory leaks
void Clear();
+
+ DEFINE_STANDARD_RTTI(SelectMgr_TriangularFrustum,Standard_Transient)
};
#endif // _SelectMgr_TriangularFrustum_HeaderFile
// =======================================================================
void SelectMgr_TriangularFrustumSet::Build (const TColgp_Array1OfPnt2d& thePoints)
{
- for (SelectMgr_TriangFrustumsIter anIter (myFrustums); anIter.More(); anIter.Next())
- {
- SelectMgr_HTriangularFrustum& aFrust = anIter.ChangeValue();
- aFrust.Nullify();
- }
myFrustums.Clear();
Handle(NCollection_IncAllocator) anAllocator = new NCollection_IncAllocator (MEMORY_BLOCK_SIZE);
aPts[aVertIdx] = aVertex.Coord();
}
- SelectMgr_HTriangularFrustum aTrFrustum = new SelectMgr_TriangularFrustum();
+ Handle(SelectMgr_TriangularFrustum) aTrFrustum = new SelectMgr_TriangularFrustum();
aTrFrustum->SetBuilder (myBuilder);
aTrFrustum->Build (aPts[0], aPts[1], aPts[2]);
myFrustums.Append (aTrFrustum);
for (SelectMgr_TriangFrustumsIter anIter (myFrustums); anIter.More(); anIter.Next())
{
- aRes->myFrustums.Append (NCollection_Handle<SelectMgr_TriangularFrustum>::DownCast (anIter.Value()->Transform (theTrsf)));
+ aRes->myFrustums.Append (Handle(SelectMgr_TriangularFrustum)::DownCast (anIter.Value()->Transform (theTrsf)));
}
return NCollection_Handle<SelectMgr_BaseFrustum> (aRes);
#include <SelectMgr_BaseFrustum.hxx>
#include <SelectMgr_TriangularFrustum.hxx>
-typedef NCollection_Handle<SelectMgr_TriangularFrustum> SelectMgr_HTriangularFrustum;
-typedef NCollection_List<SelectMgr_HTriangularFrustum> SelectMgr_TriangFrustums;
-typedef NCollection_List<SelectMgr_HTriangularFrustum>::Iterator SelectMgr_TriangFrustumsIter;
+typedef NCollection_List<Handle(SelectMgr_TriangularFrustum)> SelectMgr_TriangFrustums;
+typedef NCollection_List<Handle(SelectMgr_TriangularFrustum)>::Iterator SelectMgr_TriangFrustumsIter;
//! This class is used to handle polyline selection. The main principle of polyline selection
//! algorithm is to split the polygon defined by polyline onto triangles. Than each of
//purpose :
//=======================================================================
static void AppendControlPoles (TColgp_SequenceOfPnt& seq,
- const Handle(Geom_Curve) curve)
+ const Handle(Geom_Curve)& curve)
{
if ( curve->IsKind(STANDARD_TYPE(Geom_Line))) {
seq.Append(curve->Value(0));
Seq2d->Append(t1);
Seq2d->Append(t2);
Seq2d->Append((t1+t2)/2);
- Handle(TColStd_HSequenceOfReal) Seq3d = new TColStd_HSequenceOfReal;
- Seq3d->Append(SFTP.Perform(Seq2d,Standard_False));
+ Handle(TColStd_HSequenceOfReal) Seq3d = SFTP.Perform(Seq2d,Standard_False);
Standard_Real dist1 = pcurPnt.Distance(crv->Value(Seq3d->Value(1)));// correting Seq3d already project
Standard_Real dist2 = pcurPnt.Distance(crv->Value(Seq3d->Value(2)));
Seq2d->Append(t1);
Seq2d->Append(t2);
Seq2d->Append((t1+t2)/2);
- Handle (TColStd_HSequenceOfReal) Seq3d = new TColStd_HSequenceOfReal;
- Seq3d->Append(SFTP.Perform(Seq2d,Standard_False));
+ Handle (TColStd_HSequenceOfReal) Seq3d = SFTP.Perform(Seq2d,Standard_False);
Standard_Real dist1 = pcurPnt.Distance(crv->Value(Seq3d->Value(1)));// correting Seq3d already project
Standard_Real dist2 = pcurPnt.Distance(crv->Value(Seq3d->Value(2)));
#include <ShapeUpgrade_ShapeDivideAngle.ixx>
#include <ShapeUpgrade_SplitSurfaceAngle.hxx>
#include <ShapeUpgrade_FaceDivide.hxx>
+#include <ShapeUpgrade_WireDivide.hxx>
//=======================================================================
//function : ShapeUpgrade_ShapeDivideAngle
#include <ShapeUpgrade_ShapeDivideClosed.ixx>
#include <ShapeUpgrade_ClosedFaceDivide.hxx>
+#include <ShapeUpgrade_WireDivide.hxx>
//=======================================================================
//function : ShapeUpgrade_ShapeDivideClosed
#include <ShapeUpgrade_ClosedEdgeDivide.hxx>
#include <ShapeUpgrade_WireDivide.hxx>
#include <ShapeUpgrade_FaceDivide.hxx>
+#include <ShapeUpgrade_SplitSurface.hxx>
//=======================================================================
//function : ShapeUpgrade_ShapeDivideClosedEdges
#include <BRepClass3d_SolidClassifier.hxx>
#include <ShapeAnalysis_ShapeTolerance.hxx>
+#include <ShapeUpgrade_WireDivide.hxx>
//=======================================================================
//function : ShapeUpgrade_ShellSewing
//purpose :
//=======================================================================
- void ShapeUpgrade_SplitCurve::SetSplitValues (const Handle(TColStd_HSequenceOfReal& SplitValues))
+ void ShapeUpgrade_SplitCurve::SetSplitValues (const Handle(TColStd_HSequenceOfReal)& SplitValues)
{
Standard_Real precision = Precision::PConfusion();
if(SplitValues.IsNull()) return;
#include <BndLib_Add2dCurve.hxx>
#include <Precision.hxx>
#include <GeomAdaptor_Curve.hxx>
-#include <Geom_Curve.hxx>
+#include <Geom_BezierSurface.hxx>
+#include <Geom_BSplineSurface.hxx>
#include <GeomAbs_SurfaceType.hxx>
#include <Geom_Surface.hxx>
#include <TColgp_SequenceOfPnt2d.hxx>
#include <BndLib_Add2dCurve.hxx>
#include <Precision.hxx>
#include <GeomAdaptor_Curve.hxx>
-#include <Geom_Curve.hxx>
+#include <Geom_BezierSurface.hxx>
+#include <Geom_BSplineSurface.hxx>
#include <GeomAbs_SurfaceType.hxx>
#include <Geom_Surface.hxx>
#include <StdPrs_WFRestrictedFace.hxx>
#include <StepBasic_MechanicalContext.hxx>
#include <StepBasic_DesignContext.hxx>
#include <StepBasic_ApplicationProtocolDefinition.hxx>
+#include <StepBasic_ApplicationContext.hxx>
#include <StepRepr_PropertyDefinitionRepresentation.hxx>
#include <StepRepr_StructuralResponseProperty.hxx>
static Standard_CString schemaAP214IS = "AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }";
static Standard_CString schemaAP203 = "CONFIG_CONTROL_DESIGN";
+#include <HeaderSection_Protocol.hxx>
+
#include <StepBasic_Address.hxx>
#include <StepShape_AdvancedBrepShapeRepresentation.hxx>
#include <StepShape_AdvancedFace.hxx>
#include <StepData_DefaultGeneral.ixx>
#include <StepData.hxx>
#include <Interface_GeneralLib.hxx>
+#include <StepData_Protocol.hxx>
#include <StepData_UndefinedEntity.hxx>
#include <Interface_UndefinedContent.hxx>
#include <Interface_Macros.hxx>
#include <StepToTopoDS_PointPairHasher.ixx>
+#include <StepGeom_CartesianPoint.hxx>
+
//=======================================================================
//function : HashCode
//purpose :
#include <Geom_BoundedSurface.hxx>
#include <StepToGeom_MakeSurface.hxx>
#include <StepGeom_HArray1OfSurfaceBoundary.hxx>
+#include <StepGeom_BoundaryCurve.hxx>
#include <StepToTopoDS_TranslateCompositeCurve.hxx>
#include <TopoDS.hxx>
#include <StepShape_EdgeLoop.hxx>
#include <StepShape_Edge.hxx>
#include <StepShape_OrientedEdge.hxx>
+#include <StepShape_Vertex.hxx>
#include <StepGeom_Curve.hxx>
#include <StepShape_EdgeCurve.hxx>
#include <StepGeom_Pcurve.hxx>
-//#include <StepGeom_Polyline.hxx>
#include <StepGeom_SurfaceCurve.hxx>
#include <StepRepr_DefinitionalRepresentation.hxx>
#include <StepGeom_PcurveOrSurface.hxx>
#ifndef Storage_ArrayOfSchema_HeaderFile
#define Storage_ArrayOfSchema_HeaderFile
-#include <Storage_Schema.hxx>
#include <NCollection_Array1.hxx>
+class Storage_Schema;
typedef NCollection_Array1<Handle(Storage_Schema)> Storage_ArrayOfSchema;
#include <TColStd_MapTransientHasher.hxx>
#include <NCollection_IndexedMap.hxx>
+class TDF_Attribute;
typedef NCollection_IndexedMap<Handle(TDF_Attribute),TColStd_MapTransientHasher> TDF_AttributeIndexedMap;
#include <TDF_LabelNode.hxx>
#include <TDF_TagSource.hxx>
+#include <TDF_Data.hxx>
inline TDF_Label::TDF_Label()
:myLabelNode(NULL)
Standard_Integer i;
for (i = 1; i <= myDocuments.Length(); i++) {
Handle(TDocStd_Document) aDocAddr= myDocuments.Value(i);
- anOS << "\"" << ((Standard_Transient*)aDocAddr);
+ anOS << "\"" << aDocAddr.get();
anOS << "\" ";
}
anOS << ") ";
#include <TDF_ListIteratorOfAttributeDeltaList.hxx>
#include <TDF_Label.hxx>
#include <TDF_Delta.hxx>
+#include <TDF_Reference.hxx>
#include <TDocStd_CompoundDelta.hxx>
#include <TDocStd_Owner.hxx>
#include <TDocStd_Modified.hxx>
anOS << "There are " << myDocuments.Length() << " documents ( ";
for(i = 1; i <= myDocuments.Length(); i++) {
Handle(Standard_Transient) aDoc = myDocuments.Value(i);
- anOS << "\"" << (Standard_Transient*)aDoc;
+ anOS << "\"" << aDoc.get();
anOS << "\" ";
}
anOS << ") in the manager " << endl;
-Handle_TObj_Model.hxx
-Handle_TObj_Object.hxx
TObj_Application.cxx
TObj_Application.hxx
TObj_Assistant.cxx
+++ /dev/null
-// Created on: 2004-11-22
-// Created by: Pavel TELKOV
-// Copyright (c) 2004-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-// The original implementation Copyright: (C) RINA S.p.A
-
-#ifndef Handle_TObj_Model_HeaderFile
-#define Handle_TObj_Model_HeaderFile
-
-#include <TObj_Common.hxx>
-
-//!
-//! Definition of the handle of TObj_Model
-//! to decrease dependances
-//!
-
-class TObj_Model;
-
-//! Define handle class for TObj_Model
-DEFINE_STANDARD_HANDLE(TObj_Model,MMgt_TShared)
-
-#endif
-
-#ifdef _MSC_VER
-#pragma once
-#endif
+++ /dev/null
-// Created on: 2004-11-22
-// Created by: Pavel TELKOV
-// Copyright (c) 2004-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-// The original implementation Copyright: (C) RINA S.p.A
-
-#ifndef Handle_TObj_Object_HeaderFile
-#define Handle_TObj_Object_HeaderFile
-
-#include <TObj_Common.hxx>
-
-//!
-//! Definition of the handle of TObj_Object
-//! to decrease dependances
-//!
-
-class TObj_Object;
-
-//! Define handle class for TObj_Object
-DEFINE_STANDARD_HANDLE(TObj_Object,MMgt_TShared)
-
-#endif
-
-#ifdef _MSC_VER
-#pragma once
-#endif
#include <TColStd_SequenceOfAsciiString.hxx>
#include <TColStd_IndexedMapOfTransient.hxx>
+class TObj_Model;
//! This class provides interface to the static data
//! to be used during save or load models.
#ifndef TObj_Model_HeaderFile
#define TObj_Model_HeaderFile
-
#include <TDF_Label.hxx>
#include <TObj_Partition.hxx>
#include <Message_Messenger.hxx>
+class TObj_TNameContainer;
+class TObj_Partition;
+class TCollection_HExtendedString;
+class TDocStd_Document;
+class TObj_CheckModel;
+class TObj_Application;
+class TObj_Model;
+DEFINE_STANDARD_HANDLE(TObj_Model,MMgt_TShared)
/**
* Base class for OCAF based models.
#include <TDF_Label.hxx>
#include <gp_XYZ.hxx>
+class TObj_Model;
class TObj_Persistence;
-
+class TObj_ObjectIterator;
+class TObj_TNameContainer;
+class TCollection_HExtendedString;
+class TColStd_HArray1OfInteger;
+class TColStd_HArray1OfReal;
+class TColStd_HArray1OfExtendedString;
+
+class TObj_Object;
+DEFINE_STANDARD_HANDLE(TObj_Object,MMgt_TShared)
//! Basis class for transient objects in OCAF-based models
#include <TObj_Common.hxx>
+class TObj_Object;
/**
* This class provides an iterator by objects in a partition.
#include <TObj_Common.hxx>
+class TObj_Object;
typedef NCollection_Sequence<Handle(TObj_Object)> TObj_SequenceOfObject;
DEFINE_HSEQUENCE (TObj_HSequenceOfObject, TObj_SequenceOfObject)
#include <TDF_Attribute.hxx>
+class TObj_Model;
+class TObj_TModel;
/**
* Attribute to store OCAF-based models in OCAF tree
#include <TObj_Container.hxx>
#include <TDF_Attribute.hxx>
+class TObj_TNameContainer;
/**
* This class provides OCAF Attribute to storing the unique names of object in
#include <TDF_Attribute.hxx>
#include <TDF_Label.hxx>
+class TObj_Object;
class Standard_GUID;
/**
//purpose :
//=======================================================================
-TestTopOpeDraw_C3DDisplayer::TestTopOpeDraw_C3DDisplayer(const Handle(Geom_Curve& C))
+TestTopOpeDraw_C3DDisplayer::TestTopOpeDraw_C3DDisplayer(const Handle(Geom_Curve)& C)
{
InitC3DDisplayer();
DisplayC3D(C);
//purpose :
//=======================================================================
-void TestTopOpeDraw_C3DDisplayer::DisplayC3D(const Handle(Geom_Curve& C))
+void TestTopOpeDraw_C3DDisplayer::DisplayC3D(const Handle(Geom_Curve)& C)
{
if (C.IsNull()) return;
Draw_ColorKind col = TestTopOpeDraw_TTOT::GeometryColor(TopOpeBRepDS_CURVE);
//=======================================================================
TestTopOpeDraw_C2DDisplayer::TestTopOpeDraw_C2DDisplayer
-(const Handle(Geom2d_Curve& C))
+(const Handle(Geom2d_Curve)& C)
{
InitC2DDisplayer();
DisplayC2D(C);
//purpose :
//=======================================================================
-void TestTopOpeDraw_C2DDisplayer::DisplayC2D(const Handle(Geom2d_Curve& C))
+void TestTopOpeDraw_C2DDisplayer::DisplayC2D(const Handle(Geom2d_Curve)& C)
{
if (C.IsNull()) return;
Handle(TestTopOpeDraw_DrawableC2D) D = new TestTopOpeDraw_DrawableC2D
//=======================================================================
void TestTopOpeDraw_C2DDisplayer::DisplayC2D
-(const TCollection_AsciiString& namedbrep,const TCollection_AsciiString& namedisp,const Handle(Geom2d_Curve& C))
+(const TCollection_AsciiString& namedbrep,const TCollection_AsciiString& namedisp,const Handle(Geom2d_Curve)& C)
{
Handle(TestTopOpeDraw_DrawableC2D) D = new TestTopOpeDraw_DrawableC2D
(C,myCol,namedisp.ToCString(),myNameColor,
//=======================================================================
TestTopOpeDraw_SurfaceDisplayer::TestTopOpeDraw_SurfaceDisplayer
-(const Handle(Geom_Surface& S))
+(const Handle(Geom_Surface)& S)
{
InitSurfaceDisplayer();
DisplaySurface(S);
//purpose :
//=======================================================================
-void TestTopOpeDraw_SurfaceDisplayer::DisplaySurface(const Handle(Geom_Surface& S))
+void TestTopOpeDraw_SurfaceDisplayer::DisplaySurface(const Handle(Geom_Surface)& S)
{
if (S.IsNull()) return;
Handle(TestTopOpeDraw_DrawableSUR) D;
//purpose :
//=======================================================================
-inline void TopoDS_Shape::TShape (const Handle(TopoDS_TShape& TS))
+inline void TopoDS_Shape::TShape (const Handle(TopoDS_TShape)& TS)
{
myTShape = TS;
}
#include <StepShape_Vertex.hxx>
#include <StepShape_EdgeCurve.hxx>
-#include <StepGeom_Curve.hxx>
+#include <StepGeom_Line.hxx>
#include <StepGeom_HArray1OfPcurveOrSurface.hxx>
#include <StepGeom_SeamCurve.hxx>
#include <StepGeom_SurfaceCurve.hxx>
//Points.SetValue(Nbpt, BRep_Tool::Pnt(Vlast));
Mult.SetValue(1,2);
Mult.SetValue(Nbpt,2);
- Handle(Geom_BSplineCurve) Bs =
+ Handle(Geom_Curve) Bs =
new Geom_BSplineCurve(Points, Knots, Mult, 1);
GeomToStep_MakeCurve MkCurve(Bs);
Gpms = MkCurve.Value();
#include <Geom_Circle.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <Geom_SurfaceOfRevolution.hxx>
+#include <Geom_BSplineCurve.hxx>
#include <Precision.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <Standard_NullObject.hxx>
#include <StepGeom_CartesianPoint.hxx>
-#include <StepGeom_Curve.hxx>
+#include <StepGeom_Line.hxx>
#include <StepGeom_SurfaceCurve.hxx>
#include <StepGeom_SeamCurve.hxx>
#include <StepGeom_TrimmedCurve.hxx>
Points.SetValue(Nbpt, BRep_Tool::Pnt(Vlast));
Mult.SetValue(1,2);
Mult.SetValue(Nbpt,2);
- Handle(Geom_BSplineCurve) Bs =
+ Handle(Geom_Curve) Bs =
new Geom_BSplineCurve(Points, Knots, Mult, 1);
GeomToStep_MakeCurve gtpC(Bs);
Gpms = gtpC.Value();
#include <Transfer_ActorOfFinderProcess.ixx>
#include <Transfer_TransientMapper.hxx>
#include <Transfer_FinderProcess.hxx>
+#include <Transfer_SimpleBinderOfTransient.hxx>
Transfer_ActorOfFinderProcess::Transfer_ActorOfFinderProcess () { themodetrans = 0; }
#include <Transfer_ActorOfTransientProcess.ixx>
#include <Transfer_TransientProcess.hxx>
+#include <Transfer_SimpleBinderOfTransient.hxx>
Transfer_ActorOfTransientProcess::Transfer_ActorOfTransientProcess () { }
#include <Graphic3d_Group.hxx>
#include <Graphic3d_AspectFillArea3d.hxx>
#include <Graphic3d_ArrayOfQuadrangles.hxx>
+#include <Visual3d_ViewManager.hxx>
#include <gp_Pln.hxx>
#include <Graphic3d_Structure.hxx>
#include <V3d_View.hxx>
+class V3d_Plane;
DEFINE_STANDARD_HANDLE (V3d_Plane, MMgt_TShared)
//! Obsolete clip plane presentation class.
return aCircle;
}
-DEFINE_STANDARD_HANDLE(FilledCircle, AIS_InteractiveObject)
-
class FilledCircle : public AIS_InteractiveObject
{
public:
// This class is a wrap for Graphic3d_ArrayOfPrimitives; it is used for
// manipulating and displaying such an array with AIS context
-DEFINE_STANDARD_HANDLE(MyPArrayObject, AIS_InteractiveObject)
+
class MyPArrayObject : public AIS_InteractiveObject
{
//purpose : creates Triangle based on AIS_InteractiveObject.
// This class was implemented for testing Select3D_SensitiveTriangle
//===========================================================================
-DEFINE_STANDARD_HANDLE(Triangle, AIS_InteractiveObject)
+
class Triangle: public AIS_InteractiveObject
{
public:
//class : SegmentObject
//purpose: creates segment based on AIS_InteractiveObject.
// This class was implemented for testing Select3D_SensitiveCurve
-DEFINE_STANDARD_HANDLE(SegmentObject, AIS_InteractiveObject)
+
class SegmentObject: public AIS_InteractiveObject
{
public:
}
// This class is used for testing markers.
-DEFINE_STANDARD_HANDLE(ViewerTest_MarkersArrayObject, AIS_InteractiveObject)
+
class ViewerTest_MarkersArrayObject : public AIS_InteractiveObject
{
Standard_Boolean theReplaceIfExists = Standard_True);
extern ViewerTest_DoubleMapOfInteractiveAndName& GetMapOfAIS();
+namespace {
+
//=======================================================================
//function : VUserDraw
//purpose : Checks availability and operation of UserDraw feature
//=======================================================================
-DEFINE_STANDARD_HANDLE(VUserDrawObj, AIS_InteractiveObject)
class VUserDrawObj : public AIS_InteractiveObject
{
friend class Element;
};
-
void VUserDrawObj::Compute(const Handle(PrsMgr_PresentationManager3d)& /*thePresentationManager*/,
const Handle(Prs3d_Presentation)& thePresentation,
const Standard_Integer /*theMode*/)
glPopAttrib();
}
+} // end of anonymous namespace
+
OpenGl_Element* VUserDrawCallback(const CALL_DEF_USERDRAW * theUserDraw)
{
Handle(VUserDrawObj) anIObj = (VUserDrawObj*)theUserDraw->Data;
return 0;
}
-DEFINE_STANDARD_HANDLE(V3d_TextItem, Visual3d_LayerItem)
-
// this class provides a presentation of text item in v3d view under-/overlayer
class V3d_TextItem : public Visual3d_LayerItem
{
myLayer->DrawText (myText.ToCString (), myX1, myY1, myHeight);
}
-DEFINE_STANDARD_HANDLE(V3d_LineItem, Visual3d_LayerItem)
-
// The Visual3d_LayerItem line item for "vlayerline" command
// it provides a presentation of line with user-defined
// linewidth, linetype and transparency.
}
-void Visual3d_Layer::AddLayerItem( const Handle(Visual3d_LayerItem&) Item )
+void Visual3d_Layer::AddLayerItem( const Handle(Visual3d_LayerItem)& Item )
{
MyListOfLayerItems.Append( Item );
}
-void Visual3d_Layer::RemoveLayerItem( const Handle(Visual3d_LayerItem&) Item )
+void Visual3d_Layer::RemoveLayerItem( const Handle(Visual3d_LayerItem)& Item )
{
if ( MyListOfLayerItems.IsEmpty() )
return;
for (Standard_Integer aViewIter = 1; aViewIter <= aViews.Length(); ++aViewIter)
{
const Handle(Visual3d_View)& aView = aViews.Value (aViewIter);
- if (aView.Access() != this)
+ if (aView != this)
{
aView->EraseImmediate (theStructure);
}
#include <TopoDS_Shape.hxx>
class VrmlData_Scene;
+class VrmlData_Coordinate;
class TopoDS_Face;
+class Poly_Polygon3D;
+class Poly_Triangulation;
+
/**
* Algorithm converting one shape or a set of shapes to VrmlData_Scene.
*/
#ifndef XCAFDoc_GraphNodeSequence_HeaderFile
#define XCAFDoc_GraphNodeSequence_HeaderFile
-#include <XCAFDoc_GraphNode.hxx>
#include <NCollection_Sequence.hxx>
+class XCAFDoc_GraphNode;
typedef NCollection_Sequence<Handle(XCAFDoc_GraphNode)> XCAFDoc_GraphNodeSequence;
-- control of a session
uses Standard , MMgt, TCollection , TColStd, Dico,
- Interface, Transfer, IFSelect, Message,
+ Interface, Transfer, IFSelect, Message, MoniTool,
TopoDS, TopTools, TopAbs , Geom, Geom2d, gp
is
FinderProcess from Transfer,
Shape from TopoDS,
WorkLibrary from IFSelect,
- Profile from IFSelect,
+ Profile from MoniTool,
WorkSession from XSControl,
ReturnStatus from IFSelect
-- rsc = False (D) : True Name attached to the Norm (long name)
-- rsc = True : Name of the ressource set (i.e. short name)
- Profile (me) returns Profile from IFSelect;
+ Profile (me) returns Profile from MoniTool;
---Purpose : Returns the Profile
-- It starts with a first configuration Base (empty) and the
-- following options :
#include <Dico_IteratorOfDictionaryOfTransient.hxx>
#include <Dico_IteratorOfDictionaryOfInteger.hxx>
#include <TColStd_IndexedMapOfTransient.hxx>
-#include <IFSelect_Option.hxx>
+#include <MoniTool_Option.hxx>
#include <IFSelect_SelectModelEntities.hxx>
#include <IFSelect_SelectModelRoots.hxx>
#include <IFSelect_SelectPointed.hxx>
#include <IFSelect_SelectSharing.hxx>
#include <IFSelect_SelectShared.hxx>
+#include <IFSelect_ShareOut.hxx>
#include <IFSelect_GraphCounter.hxx>
#include <XSControl_SelectForTransfer.hxx>
#include <XSControl_ConnectedShapes.hxx>
// Initialisation du Profile
- theProfile = new IFSelect_Profile;
+ theProfile = new MoniTool_Profile;
/* essai option sur parametre
- Handle(IFSelect_Option) optrdprec = new IFSelect_Option
+ Handle(MoniTool_Option) optrdprec = new MoniTool_Option
(Interface_Static::Static ("read.precision.mode"),"readprecision.mode");
optrdprec->AddBasic("default","File");
optrdprec->AddBasic("Session");
theProfile->AddOption (optrdprec);
*/
-// Handle(IFSelect_Option) optproto = new IFSelect_Option
+// Handle(MoniTool_Option) optproto = new MoniTool_Option
// (STANDARD_TYPE(Interface_Protocol),"protocol");
// theProfile->AddOption (optproto);
- Handle(IFSelect_Option) optsign = new IFSelect_Option
+ Handle(MoniTool_Option) optsign = new MoniTool_Option
(STANDARD_TYPE(IFSelect_Signature),"sign-type");
optsign->Add ("default",theSignType);
theProfile->AddOption (optsign);
-// Handle(IFSelect_Option) optwlib = new IFSelect_Option
+// Handle(MoniTool_Option) optwlib = new MoniTool_Option
// (STANDARD_TYPE(IFSelect_WorkLibrary),"access");
// theProfile->AddOption (optwlib);
- Handle(IFSelect_Option) optactrd = new IFSelect_Option
+ Handle(MoniTool_Option) optactrd = new MoniTool_Option
(STANDARD_TYPE(Transfer_ActorOfTransientProcess),"tr-read");
theProfile->AddOption (optactrd);
- Handle(IFSelect_Option) optactwr = new IFSelect_Option
+ Handle(MoniTool_Option) optactwr = new MoniTool_Option
(STANDARD_TYPE(Transfer_ActorOfFinderProcess),"tr-write");
theProfile->AddOption (optactwr);
Standard_Boolean deja;
Handle(Standard_Transient)& newadapt = listadapt()->NewItem (name,deja);
if (deja) {
- Handle(Standard_Transient) thisadapt = this;
+ Handle(Standard_Transient) thisadapt (this);
if (newadapt->IsKind(thisadapt->DynamicType()))
{
}
Handle(XSControl_Controller) XSControl_Controller::Recorded
(const Standard_CString name)
{
- Handle(XSControl_Controller) recorded;
+ Handle(Standard_Transient) recorded;
if (!listadapt()->GetItem (name,recorded)) recorded.Nullify();
- return recorded;
+ return Handle(XSControl_Controller)::DownCast (recorded);
}
Handle(TColStd_HSequenceOfHAsciiString) XSControl_Controller::ListRecorded
// #### PROFILE ####
- Handle(IFSelect_Profile) XSControl_Controller::Profile () const
+ Handle(MoniTool_Profile) XSControl_Controller::Profile () const
{ return theProfile; }
void XSControl_Controller::DefineProfile
{
if (!theProfile->SetCurrent (confname)) return Standard_False;
+ Handle(Standard_Transient) anItem;
// theProfile->Value("protocol",theAdaptorProtocol);
- theProfile->Value("sign-type",theSignType);
+ if (theProfile->Value("sign-type",anItem))
+ theSignType = Handle(IFSelect_Signature)::DownCast (anItem);
// theProfile->Value("access",theAdaptorLibrary);
- theProfile->Value("tr-read",theAdaptorRead);
- theProfile->Value("tr-write",theAdaptorWrite);
+ if (theProfile->Value("tr-read",anItem))
+ theAdaptorRead = Handle(Transfer_ActorOfTransientProcess)::DownCast (anItem);
+ if (theProfile->Value("tr-write",anItem))
+ theAdaptorWrite = Handle(Transfer_ActorOfFinderProcess)::DownCast (anItem);
return SettingProfile (confname);
}
theProfile->SetTypedValues();
// SignType
- Handle(IFSelect_Signature) signtype;
+ Handle(Standard_Transient) signtype;
theProfile->Value ("sign-type",signtype);
- WS->SetSignType (signtype);
+ WS->SetSignType (Handle(IFSelect_Signature)::DownCast (signtype));
// ActorRead
- Handle(Transfer_ActorOfTransientProcess) actrd;
+ Handle(Standard_Transient) actrd;
theProfile->Value ("tr-read",actrd);
- WS->TransferReader()->SetActor (actrd);
+ WS->TransferReader()->SetActor (Handle(Transfer_ActorOfTransientProcess)::DownCast (actrd));
// ActorWrite : dans le Controller meme
- Handle(Transfer_ActorOfFinderProcess) actwr;
+ Handle(Standard_Transient) actwr;
theProfile->Value ("tr-write",actwr);
- theAdaptorWrite = actwr;
+ theAdaptorWrite = Handle (Transfer_ActorOfFinderProcess)::DownCast (actwr);
return ApplyingProfile (WS,confname);
}
// Loading Options of the Profile
// Available Signatures
- Handle(IFSelect_Option) optsign = theProfile->Option ("sign-type");
+ Handle(MoniTool_Option) optsign = theProfile->Option ("sign-type");
// Handle(TColStd_HSequenceOfHAsciiString) signs =
// WS->ItemNames (STANDARD_TYPE(IFSelect_Signature));
// Standard_Integer isign, nbsign = (signs.IsNull() ? 0 : signs->Length());
optsign->Switch ("default"); // garder courante la definition par defaut !
// Actor Read
- Handle(IFSelect_Option) optacrd = theProfile->Option ("tr-read");
+ Handle(MoniTool_Option) optacrd = theProfile->Option ("tr-read");
optacrd->Add ("default",theAdaptorRead);
optacrd->Switch ("default");
// Actor Write
- Handle(IFSelect_Option) optacwr = theProfile->Option ("tr-write");
+ Handle(MoniTool_Option) optacwr = theProfile->Option ("tr-write");
optacwr->Add ("default",theAdaptorWrite);
optacwr->Switch ("default");
#include <XSControl.hxx>
#include <XSControl_Controller.hxx>
-#include <IFSelect_Profile.hxx>
-#include <IFSelect_Option.hxx>
+#include <MoniTool_Profile.hxx>
+#include <MoniTool_Option.hxx>
#include <MoniTool_TypedValue.hxx>
#include <Interface_Static.hxx>
#include <TColStd_HSequenceOfAsciiString.hxx>
Handle(XSControl_WorkSession) WS = XSControl::Session(pilot);
Handle(XSControl_Controller) control = WS->NormAdaptor();
if (control.IsNull()) return IFSelect_RetFail;
- Handle(IFSelect_Profile) prof = control->Profile();
+ Handle(MoniTool_Profile) prof = control->Profile();
Handle(Message_Messenger) sout = Message::DefaultMessenger();
sout<<"Current Profile : "<<prof->Current().ToCString()<<endl;
Handle(XSControl_WorkSession) WS = XSControl::Session(pilot);
Handle(XSControl_Controller) control = WS->NormAdaptor();
if (control.IsNull()) return IFSelect_RetFail;
- Handle(IFSelect_Profile) prof = control->Profile();
+ Handle(MoniTool_Profile) prof = control->Profile();
Handle(Message_Messenger) sout = Message::DefaultMessenger();
sout<<"Current Profile : "<<prof->Current().ToCString()<<endl;
sout<<"Total : "<<nbopt<<" Options"<<endl;
for (iopt = 1; iopt <= nbopt; iopt ++) {
TCollection_AsciiString optname = optlist->Value(iopt);
- Handle(IFSelect_Option) opt = prof->Option (optname.ToCString());
+ Handle(MoniTool_Option) opt = prof->Option (optname.ToCString());
sout<<optname.ToCString()<<" : "<<opt->CaseName()<<endl;
}
return IFSelect_RetVoid;
// xoption optname : description
if (argc == 2) {
- Handle(IFSelect_Option) opt = prof->Option (arg1);
+ Handle(MoniTool_Option) opt = prof->Option (arg1);
if (opt.IsNull()) { sout<<"Not a recorded Option : "<<arg1<<endl; return IFSelect_RetError; }
// On va lister les valeurs admises
for (ial = 1; ial <= nbal; ial ++) sout<<" "<<aliases->Value(ial);
if (!tv.IsNull()) {
// TypedValue : on peut afficher la valeur
- Handle(TCollection_HAsciiString) str;
+ Handle(Standard_Transient) str;
opt->Item (acase.ToCString(),str);
- if (!str.IsNull()) sout<<" - Value:"<<str->ToCString();
+ if (!str.IsNull()) sout<<" - Value:"<< Handle(TCollection_HAsciiString)::DownCast(str)->ToCString();
}
sout<<endl;
Handle(Interface_Static) param = Interface_Static::Static(parname);
if (param.IsNull()) { sout<<"No static parameter is named "<<parname<<endl;
return IFSelect_RetError; }
- Handle(IFSelect_Option) opt = new IFSelect_Option(param,arg2);
+ Handle(MoniTool_Option) opt = new MoniTool_Option(param,arg2);
prof->AddOption (opt);
return IFSelect_RetDone;
}
// xoption optname + case [val]
if (argc >= 4 && arg2[0] == '+' && arg2[1] == '\0') {
- Handle(IFSelect_Option) opt = prof->Option (arg1);
+ Handle(MoniTool_Option) opt = prof->Option (arg1);
if (opt.IsNull()) { sout<<"Not a recorded Option : "<<arg1<<endl; return IFSelect_RetError; }
Handle(MoniTool_TypedValue) tv = opt->TypedValue();
if (tv.IsNull()) { sout<<"Option not for a Parameter : "<<arg1<<endl; return IFSelect_RetError; }
// xoption optname newcase : edition
if (argc == 3) {
- Handle(IFSelect_Option) opt = prof->Option (arg1);
+ Handle(MoniTool_Option) opt = prof->Option (arg1);
if (opt.IsNull()) { sout<<"Not a recorded Option : "<<arg1<<endl; return IFSelect_RetError; }
if (!opt->Switch (arg2)) {
sout<<"Option : "<<arg1<<" , Not a suitable case : "<<arg2<<endl;
#include <XSControl_TransferWriter.ixx>
#include <Standard_ErrorHandler.hxx>
#include <Standard_Failure.hxx>
+#include <Transfer_ActorOfFinderProcess.hxx>
#include <Transfer_SimpleBinderOfTransient.hxx>
#include <Transfer_TransientMapper.hxx>
#include <XSControl_Utils.hxx>
#include <Interface_HGraph.hxx>
#include <Interface_Graph.hxx>
-#include <IFSelect_Profile.hxx>
+#include <MoniTool_Profile.hxx>
#include <Transfer_TransientProcess.hxx>
#include <Transfer_ResultFromModel.hxx>
//purpose : pure virtual method definition
//=======================================================================
void XmlLDrivers_DocumentRetrievalDriver::Make (const Handle(PCDM_Document)&,
- const Handle(CDM_Document&))
+ const Handle(CDM_Document)&)
{
}
//=======================================================================
XmlMNaming_NamedShapeDriver::XmlMNaming_NamedShapeDriver
- (const Handle(CDM_MessageDriver&) theMessageDriver)
+ (const Handle(CDM_MessageDriver)& theMessageDriver)
: XmlMDF_ADriver (theMessageDriver, NULL),
myShapeSet (Standard_False) // triangles mode
{}
#include <XmlLDrivers.hxx>
#include <XmlTObjDrivers.hxx>
-IMPLEMENT_STANDARD_HANDLE (XmlTObjDrivers_DocumentRetrievalDriver,
- XmlLDrivers_DocumentRetrievalDriver)
-IMPLEMENT_STANDARD_RTTIEXT(XmlTObjDrivers_DocumentRetrievalDriver,
- XmlLDrivers_DocumentRetrievalDriver)
-
//=======================================================================
//function : XmlTObjDrivers_DocumentRetrievalDriver
//purpose :
#include <XmlLDrivers.hxx>
#include <XmlTObjDrivers.hxx>
-IMPLEMENT_STANDARD_HANDLE (XmlTObjDrivers_DocumentStorageDriver,
- XmlLDrivers_DocumentStorageDriver)
-IMPLEMENT_STANDARD_RTTIEXT(XmlTObjDrivers_DocumentStorageDriver,
- XmlLDrivers_DocumentStorageDriver)
-
//=======================================================================
//function : XmlTObjDrivers_DocumentStorageDriver
//purpose :
projects / occt-copy.git / commitdiff