class gp_Dir;
class TopoDS_Vertex;
class Standard_Transient;
-class Handle(Standard_Type);
-class Handle(AIS_Relation);
class AIS_LengthDimension;
DEFINE_STANDARD_HANDLE (AIS_LengthDimension, AIS_Dimension)
}
//! Selectable() method modified to return myAssembly.
- virtual Handle_SelectMgr_SelectableObject Selectable() const;
+ virtual Handle(SelectMgr_SelectableObject) Selectable() const;
Standard_Boolean IsHilighted (const Handle(PrsMgr_PresentationManager)& PM,const Standard_Integer aMode) const;
#define BOPDS_ListOfPaveBlock_HeaderFile
#include <NCollection_List.hxx>
-class Handle_BOPDS_PaveBlock;
typedef NCollection_List<Handle(BOPDS_PaveBlock)> BOPDS_ListOfPaveBlock;
typedef BOPDS_ListOfPaveBlock::Iterator BOPDS_ListIteratorOfListOfPaveBlock;
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Wire.hxx>
-class Handle(NCollection_IncAllocator);
-class Handle(Geom_Surface);
//! This class performs fast sewing of surfaces (faces). It supposes
//! that all surfaces are finite and are naturally restricted by their bounds.
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
#include <GeomAbs_Shape.hxx>
-#include <Handle_Geom2d_Curve.hxx>
-#include <Handle_Geom_Curve.hxx>
#include <Standard_Real.hxx>
class Standard_DomainError;
//function : Init
//purpose :
//=======================================================================
-void BRepGProp_Gauss::Init(Handle_Vector& theOutVec,
+void BRepGProp_Gauss::Init(Handle(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)
+ Handle(Vector)& theParam1,
+ Handle(Vector)& theParam2,
+ Handle(Vector)& theError,
+ Handle(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];
+ Handle(Vector) LGaussP[2];
+ Handle(Vector) LGaussW[2];
+ Handle(Vector) UGaussP[2];
+ Handle(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);
+ 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);
- 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);
+ 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);
// Face parametrization in U and V direction
Standard_Real BV1, BV2, BU1, BU2;
if (Abs(u2 - u1) < EPS_PARAM)
continue;
- Handle_Vector aDummy;
+ Handle(Vector) aDummy;
iUSubEnd = FillIntervalBounds(u1, u2, UKnots, NumSubs, anInertiaU, U1, U2, ErrU, aDummy);
UMaxSubs = BRepGProp_Gauss::MaxSubs(iUSubEnd);
};
typedef NCollection_Handle< NCollection_Array1<Inertia> > InertiaArray;
- typedef NCollection_Handle<math_Vector> Handle_Vector;
typedef Standard_Real(*BRepGProp_GaussFunc)(const Standard_Real, const Standard_Real);
public: //! @name public API
const Standard_Integer theCoeff = 32);
static void Init(
- Handle_Vector& theOutVec,
+ Handle(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);
+ Handle(Vector)& theParam1,
+ Handle(Vector)& theParam2,
+ Handle(Vector)& theError,
+ Handle(Vector)& theCommonError);
private: //! @name private fields
#include <BRepMesh_PairOfIndex.hxx>
#include <BRepMesh_Circle.hxx>
#include <TopTools_ShapeMapHasher.hxx>
-#include <Handle_Poly_Triangulation.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Shape.hxx>
class BRepMesh_Vertex;
class TopoDS_Edge;
class TopoDS_Vertex;
-class Handle_BRepMesh_FaceAttribute;
class BRepMesh_VertexInspector;
class BRepMesh_CircleInspector;
class BRepMesh_Classifier;
typedef NCollection_DataMap<Standard_Integer, Standard_Integer> MapOfIntegerInteger;
typedef NCollection_DataMap<TopoDS_Vertex, Standard_Integer, TopTools_ShapeMapHasher> DMapOfVertexInteger;
- typedef NCollection_DataMap<TopoDS_Face, Handle_BRepMesh_FaceAttribute, TopTools_ShapeMapHasher> DMapOfFaceAttribute;
+ typedef NCollection_DataMap<TopoDS_Face, Handle(BRepMesh_FaceAttribute), TopTools_ShapeMapHasher> DMapOfFaceAttribute;
typedef NCollection_DataMap<TopoDS_Shape, BRepMesh_PairOfPolygon, TopTools_ShapeMapHasher> DMapOfShapePairOfPolygon;
typedef NCollection_DataMap<Standard_Integer, gp_Pnt> DMapOfIntegerPnt;
typedef NCollection_DataMap<Standard_Integer, ListOfXY> DMapOfIntegerListOfXY;
#include <Standard_DefineAlloc.hxx>
#include <BRepMesh_IEdgeTool.hxx>
#include <BRepMesh_EdgeParameterProvider.hxx>
-#include <Handle_Geom2d_Curve.hxx>
-#include <Handle_Poly_PolygonOnTriangulation.hxx>
-#include <Handle_Poly_Triangulation.hxx>
#include <TopLoc_Location.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <BRepMesh_IEdgeTool.hxx>
#include <BRepMesh_GeomTool.hxx>
#include <BRepMesh_FaceAttribute.hxx>
-#include <Handle_Geom_Surface.hxx>
-#include <Handle_Geom2d_Curve.hxx>
-#include <Handle_BRepAdaptor_HSurface.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <BRepMesh_Status.hxx>
#include <BRepMesh.hxx>
#include <BRepMesh_DataStructureOfDelaun.hxx>
-#include <Handle_BRepAdaptor_HSurface.hxx>
class BRepAdaptor_HSurface;
#include <TopTools_ListOfShape.hxx>
#include <TopTools_MutexForShapeProvider.hxx>
#include <Standard_Transient.hxx>
-#include <Handle_BRepAdaptor_HSurface.hxx>
-#include <Handle_Geom2d_Curve.hxx>
#include <BRepMesh_Delaun.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <BRepMesh_Triangle.hxx>
#include <Standard_Transient.hxx>
#include <TopTools_MutexForShapeProvider.hxx>
#include <TopTools_DataMapOfShapeReal.hxx>
-#include <Handle_BRepAdaptor_HSurface.hxx>
-#include <Handle_Poly_Triangulation.hxx>
#include <BRepMesh_Delaun.hxx>
#include <BRepMesh_Triangle.hxx>
#include <BRepMesh_Classifier.hxx>
#include <Standard_Macro.hxx>
#include <GCPnts_TangentialDeflection.hxx>
#include <GeomAbs_IsoType.hxx>
-#include <Handle_BRepAdaptor_HSurface.hxx>
#include <TopoDS_Edge.hxx>
#include <Precision.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopTools_DataMapOfShapeReal.hxx>
#include <BRepMesh_DiscretRoot.hxx>
-#include <Handle_Poly_Triangulation.hxx>
#include <BRepMesh.hxx>
#include <vector>
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Macro.hxx>
-#include <Handle_Poly_PolygonOnTriangulation.hxx>
class Poly_PolygonOnTriangulation;
}
//! Returns first polygon on triangulation.
- inline const Handle_Poly_PolygonOnTriangulation& First() const
+ inline const Handle(Poly_PolygonOnTriangulation)& First() const
{
return myFirst;
}
//! Returns last polygon on triangulation.
- inline const Handle_Poly_PolygonOnTriangulation& Last() const
+ inline const Handle(Poly_PolygonOnTriangulation)& Last() const
{
return myLast;
}
private:
- Handle_Poly_PolygonOnTriangulation myFirst;
- Handle_Poly_PolygonOnTriangulation myLast;
+ Handle(Poly_PolygonOnTriangulation) myFirst;
+ Handle(Poly_PolygonOnTriangulation) myLast;
};
#endif
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Macro.hxx>
-#include <Handle_BRepAdaptor_HSurface.hxx>
#include <BRepMesh_FaceAttribute.hxx>
#include <BRepMesh.hxx>
-#include <Handle_Poly_Triangulation.hxx>
class TopoDS_Face;
class TopoDS_Edge;
//! Converts handle of array of Standard_Real into the pointer to Standard_Real
-static Standard_Real* ConvertArray(const Handle_TColStd_HArray2OfReal& theHArray)
+static Standard_Real* ConvertArray(const Handle(TColStd_HArray2OfReal)& theHArray)
{
const TColStd_Array2OfReal& anArray = theHArray->Array2();
return (Standard_Real*) &(anArray(anArray.LowerRow(), anArray.LowerCol()));
#include <Standard_Type.hxx>
#include <Standard_Transient.hxx>
-#include <Handle_TColStd_HArray1OfReal.hxx>
-#include <Handle_TColStd_HArray2OfReal.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Pnt.hxx>
//! Converts handle of array of Standard_Real into the pointer to Standard_Real
-static Standard_Real* ConvertArray(const Handle_TColStd_HArray2OfReal& theHArray)
+static Standard_Real* ConvertArray(const Handle(TColStd_HArray2OfReal)& theHArray)
{
const TColStd_Array2OfReal& anArray = theHArray->Array2();
return (Standard_Real*) &(anArray(anArray.LowerRow(), anArray.LowerCol()));
#include <TObj_Common.hxx>
#include <Standard_GUID.hxx>
-class Handle(BinMDF_ADriverTable);
-class Handle(CDM_MessageDriver);
// Class for registering storage/retrieval drivers for TObj Bin persistence
//
#include <BinLDrivers_DocumentRetrievalDriver.hxx>
#include <BinMDF_ADriverTable.hxx>
-class Handle(CDM_MessageDriver);
// Retrieval driver of a TObj Bin document
//
#include <BinLDrivers_DocumentStorageDriver.hxx>
#include <BinMDF_ADriverTable.hxx>
-class Handle(CDM_MessageDriver);
// Block of comments describing class BinTObjDrivers_DocumentStorageDriver
//
void SetCurve(const Handle(Geom2d_Curve)& aC);
- const Handle_Geom2d_Curve& Curve() const;
+ const Handle(Geom2d_Curve)& Curve() const;
void SetRange(const Standard_Real aT1,
const Standard_Real aT2);
void PerformOnePoint();
//-----------------------------
protected:
- Handle_Geom2d_Curve myCurve;
+ Handle(Geom2d_Curve) myCurve;
Bnd_Box2d myBox;
Standard_Integer myErrorStatus;
- Handle_Geom2d_Curve myCurveBase;
+ Handle(Geom2d_Curve) myCurveBase;
Standard_Real myOffsetBase;
Standard_Boolean myOffsetFlag;
Standard_Real myT1;
#include <TCollection_ExtendedString.hxx>
#include <NCollection_DataMap.hxx>
-class Handle(CDM_MetaData);
typedef NCollection_DataMap<TCollection_ExtendedString,Handle(CDM_MetaData),TCollection_ExtendedString> CDM_MetaDataLookUpTable;
typedef NCollection_DataMap<TCollection_ExtendedString,Handle(CDM_MetaData),TCollection_ExtendedString>::Iterator CDM_DataMapIteratorOfMetaDataLookUpTable;
#ifndef Expr_Array1OfNamedUnknown_HeaderFile
#define Expr_Array1OfNamedUnknown_HeaderFile
-#include <Handle_Expr_NamedUnknown.hxx>
#include <NCollection_Array1.hxx>
typedef NCollection_Array1<Handle(Expr_NamedUnknown)> Expr_Array1OfNamedUnknown;
#include <Graphic3d_Vec3.hxx>
#include <Graphic3d_ZLayerId.hxx>
#include <Standard_Transient.hxx>
-#include <Handle_Graphic3d_GraphicDriver.hxx>
//! Forward declaration.
-class Handle(Graphic3d_StructureManager);
-class Handle(Graphic3d_CStructure);
//! Low-level graphic structure interface
class Graphic3d_CStructure : public Standard_Transient
#include <Bnd_Box.hxx>
//! Forward declaration
-class Handle(Graphic3d_Camera);
//! Camera class provides object-oriented approach to setting up projection
//! and orientation properties of 3D view.
class gp_Pln;
class Graphic3d_AspectFillArea3d;
-class Handle(Graphic3d_AspectFillArea3d);
-class Handle(Graphic3d_ClipPlane);
//! Container for properties describing graphic driver clipping planes.
//! It is up to application to create instances of this class and specify its
#ifndef _Graphic3d_MapOfStructure
#define _Graphic3d_MapOfStructure
-#include <Handle_Graphic3d_Structure.hxx>
#include <NCollection_Map.hxx>
typedef NCollection_Map<Handle(Graphic3d_Structure)> Graphic3d_MapOfStructure;
#include <Graphic3d_TypeOfShaderObject.hxx>
//! Forward declaration
-class Handle(Graphic3d_ShaderObject);
//! This class is responsible for managing shader objects.
class Graphic3d_ShaderObject : public Standard_Transient
Standard_EXPORT static void Commands (Draw_Interpretor& theCommands);
private:
- Standard_EXPORT static const Handle_MMgt_TShared& WClass();
+ Standard_EXPORT static const Handle(MMgt_TShared)& WClass();
};
#endif
#include <Standard_Macro.hxx>
#endif
#ifndef _Handle_MMgt_TShared_HeaderFile
-#include <Handle_MMgt_TShared.hxx>
#endif
#include <NCollection_DataMap.hxx>
//! Mapping between OCCT topological shape IDs and their correspondent
//! visualization pipelines.
typedef NCollection_DataMap<IVtk_IdType, Handle(IVtkDraw_HighlightAndSelectionPipeline)> ShapePipelineMap;
-typedef NCollection_Handle<ShapePipelineMap> Handle(ShapePipelineMap);
#endif
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>
-class Handle(LDOM_MemManager);
class LDOM_NullPtr;
class TCollection_AsciiString;
class TCollection_ExtendedString;
#define LDOMString_HeaderFile
#include <LDOMBasicString.hxx>
-#include <Handle_LDOM_MemManager.hxx>
// Class LDOMString
// Represents various object types which can be mapped to XML strings
#define LDOM_Document_HeaderFile
#include <LDOM_Element.hxx>
-#include <Handle_LDOM_MemManager.hxx>
#include <LDOM_Text.hxx>
#include <LDOM_CDATASection.hxx>
#include <LDOM_Comment.hxx>
DEFINE_STANDARD_RTTI (LDOM_MemManager, MMgt_TShared)
};
-#include <Handle_LDOM_MemManager.hxx>
#endif
#include <Standard_Macro.hxx>
#include <Standard_TypeDef.hxx>
-#include <Handle_LDOM_MemManager.hxx>
#include <LDOMString.hxx>
class LDOM_BasicNode;
//purpose : Constructor
//=======================================================================
LDOM_SBuffer::LDOM_StringElem::LDOM_StringElem
- ( const int theLength, const Handle_NCollection_BaseAllocator& theAlloc )
+ ( const int theLength, const Handle(NCollection_BaseAllocator)& theAlloc )
: buf (reinterpret_cast<char*>(theAlloc->Allocate (theLength))),
len (0),
next(0)
DEFINE_NCOLLECTION_ALLOC
- LDOM_StringElem(const int, const Handle_NCollection_BaseAllocator&);
+ LDOM_StringElem(const int, const Handle(NCollection_BaseAllocator)&);
~LDOM_StringElem();
private:
Standard_EXPORT void DrawOn(Draw_Display& theDisplay) const;
- Standard_EXPORT virtual Handle_Draw_Drawable3D Copy() const;
+ Standard_EXPORT virtual Handle(Draw_Drawable3D) Copy() const;
Standard_EXPORT virtual void Dump(Standard_OStream& theStream) const;
#include <Select3D_BndBox3d.hxx>
#include <SelectBasics_SensitiveEntity.hxx>
-#include <Handle_SelectBasics_EntityOwner.hxx>
#include <SelectBasics_SelectingVolumeManager.hxx>
class SelectBasics_EntityOwner;
#include <gp_Pnt.hxx>
#include <Select3D_SensitiveFace.hxx>
-#include <Handle_SelectBasics_EntityOwner.hxx>
#include <Select3D_TypeOfSensitivity.hxx>
class SelectBasics_EntityOwner;
#include <Bnd_Box.hxx>
#include <Select3D_SensitiveEntity.hxx>
-#include <Handle_SelectBasics_EntityOwner.hxx>
#include <Select3D_SensitiveEntity.hxx>
#include <Select3D_BndBox3d.hxx>
#include <gp_XY.hxx>
#include <NCollection_List.hxx>
#include <Select3D_SensitiveEntity.hxx>
-#include <Handle_SelectBasics_EntityOwner.hxx>
#include <Select3D_SensitiveEntity.hxx>
#include <Select3D_BndBox3d.hxx>
const TColgp_Array1OfPnt& theNodes,
const Handle(MeshVS_HArray1OfSequenceOfInteger)& theTopo);
- Standard_EXPORT virtual Handle_Select3D_SensitiveEntity GetConnected() Standard_OVERRIDE;
+ Standard_EXPORT virtual Handle(Select3D_SensitiveEntity) GetConnected() Standard_OVERRIDE;
Standard_EXPORT virtual Standard_Boolean Matches (SelectBasics_SelectingVolumeManager& theMgr,
SelectBasics_PickResult& thePickResult) Standard_OVERRIDE;
#include <gp_Pnt.hxx>
#include <Select3D_SensitiveSegment.hxx>
-#include <Handle_SelectBasics_EntityOwner.hxx>
class SelectBasics_EntityOwner;
class gp_Pnt;
#include <NCollection_Array1.hxx>
#include <NCollection_Handle.hxx>
-typedef NCollection_Handle<Message_Msg> Handle(Message_Msg);
typedef NCollection_Array1<Handle(Message_Msg)> Message_ArrayOfMsg;
-typedef NCollection_Handle<Message_ArrayOfMsg> Handle(Message_ArrayOfMsg);
typedef Handle(Message_ArrayOfMsg) Message_HArrayOfMsg;
#endif // _Message_HArrayOfMsg_HeaderFile
#include <MoniTool_MTHasher.hxx>
#include <NCollection_DataMap.hxx>
-class Handle(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 Handle(MoniTool_TypedValue);
typedef Handle(TCollection_HAsciiString) (*MoniTool_ValueInterpret) (const Handle(MoniTool_TypedValue)& typval,
const Handle(TCollection_HAsciiString)& val,
#include <Standard_Type.hxx>
#include <NCollection_TypeDef.hxx>
-class Handle(NCollection_BaseAllocator);
/**
* Purpose: Basic class for memory allocation wizards.
#include <NCollection_BaseAllocator.hxx>
-class Handle(NCollection_HeapAllocator);
/**
* Allocator that uses the global dynamic heap (malloc / free).
#define _Handle_OpenGl_Context_Header
#include <Standard_Type.hxx>
-#include <Handle_Standard_Transient.hxx>
class OpenGl_Context;
DEFINE_STANDARD_HANDLE(OpenGl_Context, Standard_Transient)
#define _Handle_OpenGl_GraphicDriver_Header
#include <Standard_Type.hxx>
-#include <Handle_Graphic3d_GraphicDriver.hxx>
class OpenGl_GraphicDriver;
#ifndef _Handle_OpenGl_PointSprite_Header
#define _Handle_OpenGl_PointSprite_Header
-#include <Handle_OpenGl_Texture.hxx>
class OpenGl_PointSprite;
DEFINE_STANDARD_HANDLE(OpenGl_PointSprite, OpenGl_Texture)
#define _Handle_OpenGl_View_Header
#include <Standard_Type.hxx>
-#include <Handle_MMgt_TShared.hxx>
class OpenGl_View;
#define _Handle_OpenGl_Window_Header
#include <Standard_Type.hxx>
-#include <Handle_MMgt_TShared.hxx>
class OpenGl_Window;
#define _Handle_OpenGl_Workspace_Header
#include <Standard_Type.hxx>
-#include <Handle_OpenGl_Window.hxx>
class OpenGl_Workspace;
#include <Aspect_PolygonOffsetMode.hxx>
#include <TCollection_AsciiString.hxx>
-#include <Handle_Graphic3d_TextureParams.hxx>
-#include <Handle_OpenGl_ShaderProgram.hxx>
-#include <Handle_OpenGl_Texture.hxx>
#include <OpenGl_AspectLine.hxx>
#include <OpenGl_Element.hxx>
#include <Aspect_TypeOfLine.hxx>
#include <Graphic3d_CAspectLine.hxx>
-#include <Handle_OpenGl_ShaderProgram.hxx>
#include <OpenGl_Element.hxx>
#include <TCollection_AsciiString.hxx>
#include <OpenGl_Element.hxx>
-#include <Handle_OpenGl_PointSprite.hxx>
-#include <Handle_OpenGl_ShaderProgram.hxx>
#include <Image_PixMap_Handle.hxx>
#include <TCollection_AsciiString.hxx>
#include <OpenGl_Element.hxx>
-#include <Handle_OpenGl_ShaderProgram.hxx>
//! Text representation parameters
class OpenGl_AspectText : public OpenGl_Element
#include <Graphic3d_SequenceOfGroup.hxx>
// Forward declaration
-class Handle(OpenGl_Workspace);
-class Handle(Graphic3d_ClipPlane);
DEFINE_STANDARD_HANDLE (OpenGl_CappingAlgoFilter, OpenGl_RenderFilter)
#include <OpenGl_Matrix.hxx>
#include <Graphic3d_ClipPlane.hxx>
-class Handle(OpenGl_Context);
DEFINE_STANDARD_HANDLE (OpenGl_CappingPlaneResource, OpenGl_Resource)
#include <Standard_Type.hxx>
#include <Standard_Transient.hxx>
-#include <Handle_Standard_Transient.hxx>
//! Class to define graphic driver capabilities.
//! Notice that these options will be ignored if particular functionality does not provided by GL driver
#include <NCollection_Handle.hxx>
#include <Standard_TypeDef.hxx>
#include <OpenGl_Matrix.hxx>
-#include <Handle_OpenGl_Workspace.hxx>
//! This class contains logics related to tracking and modification of clipping plane
//! state for particular OpenGl context. It contains information about enabled
#include <Aspect_Display.hxx>
#include <Aspect_RenderingContext.hxx>
#include <Aspect_TypeOfLine.hxx>
-#include <Handle_OpenGl_Context.hxx>
-#include <Handle_OpenGl_FrameBuffer.hxx>
-#include <Handle_OpenGl_Sampler.hxx>
-#include <Handle_OpenGl_ShaderManager.hxx>
-#include <Handle_OpenGl_ShaderProgram.hxx>
#include <NCollection_DataMap.hxx>
#include <NCollection_Map.hxx>
#include <NCollection_Handle.hxx>
private: // context info
typedef NCollection_DataMap<TCollection_AsciiString, Standard_Integer> OpenGl_DelayReleaseMap;
- typedef NCollection_Handle<OpenGl_DelayReleaseMap> Handle(OpenGl_DelayReleaseMap);
typedef NCollection_DataMap<TCollection_AsciiString, Handle(OpenGl_Resource)> OpenGl_ResourcesMap;
- typedef NCollection_Handle<OpenGl_ResourcesMap> Handle(OpenGl_ResourcesMap);
typedef NCollection_List<Handle(OpenGl_Resource)> OpenGl_ResourcesStack;
- typedef NCollection_Handle<OpenGl_ResourcesStack> Handle(OpenGl_ResourcesStack);
Handle(OpenGl_ResourcesMap) mySharedResources; //!< shared resources with unique identification key
Handle(OpenGl_DelayReleaseMap) myDelayed; //!< shared resources for delayed release
#ifndef OpenGl_Element_Header
#define OpenGl_Element_Header
-#include <Handle_OpenGl_Context.hxx>
-#include <Handle_OpenGl_Workspace.hxx>
#include <OpenGl_RenderFilter.hxx>
//! Base interface for drawable elements.
#include <OpenGl_Element.hxx>
#include <OpenGl_Vec.hxx>
-#include <Handle_OpenGl_Workspace.hxx>
class gp_Ax2;
#include <Standard_Boolean.hxx>
#include <InterfaceGraphic.hxx>
-#include <Handle_OpenGl_FrameBuffer.hxx>
//! Class implements FrameBuffer Object (FBO) resource
//! intended for off-screen rendering.
#define _OpenGl_GraphicDriver_HeaderFile
#include <Graphic3d_GraphicDriver.hxx>
-#include <Handle_OpenGl_GraphicDriver.hxx>
#include <OpenGl_Context.hxx>
#include <OpenGl_PrinterContext.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <Quantity_PlaneAngle.hxx>
#include <Quantity_NameOfColor.hxx>
-#include <Handle_OpenGl_View.hxx>
-#include <Handle_OpenGl_Workspace.hxx>
#include <Aspect_Display.hxx>
#include <Aspect_DisplayConnection.hxx>
class Graphic3d_Vertex;
class TCollection_ExtendedString;
class Image_PixMap;
-class Handle(OpenGl_Workspace);
class OpenGl_Element;
class OpenGl_Structure;
class OpenGl_Text;
#include <InterfaceGraphic_telem.hxx>
-#include <Handle_OpenGl_Workspace.hxx>
#include <OpenGl_BVHClipPrimitiveSet.hxx>
#include <OpenGl_BVHTreeSelector.hxx>
#include <Graphic3d_ZLayerSettings.hxx>
#include <OpenGl_GlCore11.hxx>
-class Handle(OpenGl_Workspace);
struct OpenGl_GlobalLayerSettings
{
#include <NCollection_DataMap.hxx>
class OpenGl_Structure;
-class Handle(OpenGl_Workspace);
typedef NCollection_Sequence<OpenGl_Layer> OpenGl_SequenceOfLayers;
typedef NCollection_DataMap<int, int> OpenGl_LayerSeqIds;
#include <Font_FontAspect.hxx>
class OpenGl_Context;
-class Handle(OpenGl_Context);
class OpenGl_LineAttributes : public OpenGl_Resource
{
#define _OpenGl_PointSprite_H__
#include <OpenGl_Texture.hxx>
-#include <Handle_OpenGl_PointSprite.hxx>
//! Point sprite resource. On modern hardware it will be texture with extra parameters.
//! On ancient hardware sprites will be drawn using bitmaps.
#include <OpenGl_Element.hxx>
class OpenGl_GraphicDriver;
-class Handle(OpenGl_ShaderProgram);
//! Class for rendering of arbitrary primitive array.
class OpenGl_PrimitiveArray : public OpenGl_Element
#include <Standard_Type.hxx>
#include <TColStd_Array2OfReal.hxx>
-#include <Handle_Standard_Transient.hxx>
#include <OpenGl_Vec.hxx>
//! Class provides specific information for redrawing view to offscreen buffer
#include <Standard_Type.hxx>
class Standard_Transient;
-class Handle(Standard_Type);
class OpenGl_Context;
//! Interface for OpenGl resource with following meaning:
#define OPENGL_SAMPLER_H
#include <OpenGl_Context.hxx>
-#include <Handle_OpenGl_Sampler.hxx>
//! Class implements OpenGL sampler object resource that
//! stores the sampling parameters for a texture access.
#include <NCollection_DataMap.hxx>
#include <NCollection_Sequence.hxx>
-#include <Handle_OpenGl_ShaderManager.hxx>
#include <OpenGl_SetOfShaderPrograms.hxx>
#include <OpenGl_ShaderStates.hxx>
#include <OpenGl_AspectFace.hxx>
#ifndef _OpenGl_ShaderObject_Header
#define _OpenGl_ShaderObject_Header
-#include <Handle_OpenGl_ShaderObject.hxx>
#include <Graphic3d_ShaderObject.hxx>
#include <OpenGl_GlCore20.hxx>
#include <OpenGl_Resource.hxx>
#include <OpenGl_Vec.hxx>
#include <OpenGl_Matrix.hxx>
#include <OpenGl_ShaderObject.hxx>
-#include <Handle_OpenGl_ShaderProgram.hxx>
//! The enumeration of OCCT-specific OpenGL/GLSL variables.
enum OpenGl_StateVariable
#include <Graphic3d_HorizontalTextAlignment.hxx>
#include <Graphic3d_VerticalTextAlignment.hxx>
-class Handle(OpenGl_PrinterContext);
//! Text rendering
class OpenGl_Text : public OpenGl_Element
#include <OpenGl_GlCore13.hxx>
#include <OpenGl_Resource.hxx>
-#include <Handle_OpenGl_Texture.hxx>
#include <Graphic3d_TypeOfTexture.hxx>
-#include <Handle_Graphic3d_TextureParams.hxx>
-class Handle(OpenGl_Context);
class OpenGl_Context;
class Image_PixMap;
#include <OpenGl_Trihedron.hxx>
#include <OpenGl_GraduatedTrihedron.hxx>
-#include <Handle_OpenGl_Context.hxx>
-#include <Handle_OpenGl_GraphicDriver.hxx>
-#include <Handle_OpenGl_Workspace.hxx>
-#include <Handle_OpenGl_View.hxx>
-#include <Handle_OpenGl_Texture.hxx>
struct OPENGL_ZCLIP
{
struct OpenGl_Matrix;
class OpenGl_Structure;
-class Handle(OpenGl_PrinterContext);
class OpenGl_StateCounter;
class OpenGl_View : public MMgt_TShared
#include <InterfaceGraphic_Aspect.hxx>
#include <OpenGl_Caps.hxx>
-#include <Handle_OpenGl_Context.hxx>
-#include <Handle_OpenGl_Window.hxx>
-#include <Handle_OpenGl_GraphicDriver.hxx>
#include <MMgt_TShared.hxx>
#include <map>
#include <set>
-#include <Handle_OpenGl_Workspace.hxx>
#include <OpenGl_Window.hxx>
#include <TColStd_Array2OfReal.hxx>
#include <Graphic3d_TypeOfTexture.hxx>
#include <Graphic3d_PtrFrameBuffer.hxx>
#include <Graphic3d_BufferType.hxx>
-#include <Handle_Graphic3d_TextureParams.hxx>
#include <Aspect_CLayer2d.hxx>
#include <Aspect_Handle.hxx>
#include <OpenGl_LineAttributes.hxx>
#include <OpenGl_CappingAlgo.hxx>
-#include <Handle_OpenGl_View.hxx>
-#include <Handle_OpenGl_Texture.hxx>
#include <OpenGl_ShaderObject.hxx>
#include <OpenGl_ShaderProgram.hxx>
#include <Poly_CoherentLink.hxx>
#include <NCollection_Vector.hxx>
-class Handle(Poly_CoherentTriangulation);
class Poly_CoherentTriangulation;
template <class A> class NCollection_List;
#include <NCollection_BaseAllocator.hxx>
#include <NCollection_List.hxx>
-class Handle(NCollection_IncAllocator);
/**
* Make loops from a set of connected links. A link is represented by
#include <Standard.hxx>
#include <Standard_Type.hxx>
-#include <Handle_Prs3d_IsoAspect.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
-#include <Handle_Prs3d_LineAspect.hxx>
-#include <Handle_Prs3d_TextAspect.hxx>
-#include <Handle_Prs3d_ShadingAspect.hxx>
#include <Quantity_Length.hxx>
#include <Aspect_TypeOfDeflection.hxx>
#include <Standard_Real.hxx>
-#include <Handle_Prs3d_PointAspect.hxx>
#include <Prs3d_VertexDrawMode.hxx>
-#include <Handle_Prs3d_PlaneAspect.hxx>
-#include <Handle_Prs3d_ArrowAspect.hxx>
-#include <Handle_Prs3d_DatumAspect.hxx>
-#include <Handle_Prs3d_DimensionAspect.hxx>
#include <Prs3d_DimensionUnits.hxx>
#include <Prs3d_TypeOfHLR.hxx>
#include <MMgt_TShared.hxx>
class Adaptor3d_Curve;
class TopoDS_Edge;
class TopoDS_Shape;
-class Handle(BRepAdaptor_HSurface);
-class Handle(Prs3d_Drawer);
class Prs3d_WFShape : Prs3d_Root
{
return 0;
}
-#include <Handle_BRepTools_NurbsConvertModification.hxx>
#include <BRepPrimAPI_MakeCylinder.hxx>
#include <BRepBuilderAPI_Copy.hxx>
#include <BRepTools_NurbsConvertModification.hxx>
BRep_Builder aBuilder;
aBuilder.MakeCompound (aComp);
//NURBS modifier is used to increase footprint of each shape
- Handle_BRepTools_NurbsConvertModification aNurbsModif = new BRepTools_NurbsConvertModification;
+ Handle(BRepTools_NurbsConvertModification) aNurbsModif = new BRepTools_NurbsConvertModification;
TopoDS_Shape aRefShape = BRepPrimAPI_MakeCylinder (50., 100.).Solid();
BRepTools_Modifier aModifier (aRefShape, aNurbsModif);
if (aModifier.IsDone()) {
#include <NCollection_Sequence.hxx>
-class Handle(Select3D_SensitiveEntity);
typedef NCollection_Sequence<Handle(Select3D_SensitiveEntity)> Select3D_EntitySequence;
typedef NCollection_Sequence<Handle(Select3D_SensitiveEntity)>::Iterator Select3D_EntitySequenceIter;
#include <NCollection_Vector.hxx>
-#include <Handle_SelectBasics_EntityOwner.hxx>
#include <TColgp_HArray1OfPnt.hxx>
#include <TColStd_HArray1OfInteger.hxx>
protected:
Select3D_VectorOfHPoly myPlanarPolygons; //!< Vector of planar polygons
- Handle_TColStd_HArray1OfInteger myPolygonsIdxs; //!< Indexes array for BVH calculation
+ Handle(TColStd_HArray1OfInteger) myPolygonsIdxs; //!< Indexes array for BVH calculation
gp_Pnt myCOG; //!< Center of the point set
Select3D_BndBox3d myBndBox; //!< Bounding box of the point set
};
#include <Bnd_Box.hxx>
#include <gp_Pnt.hxx>
#include <Select3D_SensitiveEntity.hxx>
-#include <Handle_SelectBasics_EntityOwner.hxx>
#include <SelectMgr_SelectingVolumeManager.hxx>
#include <Standard_OStream.hxx>
#include <Select3D_SensitivePoly.hxx>
#include <Select3D_Pnt.hxx>
-#include <Handle_Geom_Circle.hxx>
-#include <Handle_SelectBasics_EntityOwner.hxx>
#include <TColgp_HArray1OfPnt.hxx>
#include <SelectMgr_SelectingVolumeManager.hxx>
#include <Select3D_TypeOfSensitivity.hxx>
Select3D_TypeOfSensitivity mySensType; //!< True if type of selection is interior, false otherwise
gp_Pnt myCenter3D; //!< Center of a circle
- Handle_Geom_Circle myCircle; //!< Points of the circle
+ Handle(Geom_Circle) myCircle; //!< Points of the circle
Standard_Real myStart; //!< Sensitive arc parameter
Standard_Real myEnd; //!< Sensitive arc parameter
};
#include <Standard_Type.hxx>
#include <Geom_Curve.hxx>
-#include <Handle_Geom_Curve.hxx>
#include <Select3D_SensitivePoly.hxx>
-#include <Handle_SelectBasics_EntityOwner.hxx>
#include <TColgp_HArray1OfPnt.hxx>
#include <Standard_Boolean.hxx>
#include <SelectMgr_SelectingVolumeManager.hxx>
private:
- Handle_Geom_Curve myCurve; //!< Curve points
+ Handle(Geom_Curve) myCurve; //!< Curve points
};
DEFINE_STANDARD_HANDLE(Select3D_SensitiveCurve, Select3D_SensitivePoly)
#include <Standard_Type.hxx>
#include <SelectBasics_SensitiveEntity.hxx>
-#include <Handle_SelectBasics_EntityOwner.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
#include <SelectMgr_SelectingVolumeManager.hxx>
#include <TopLoc_Location.hxx>
class Select3D_SensitiveEntity;
-class Handle(Select3D_SensitiveEntity);
class SelectBasics_EntityOwner;
//! Abstract framework to define 3D sensitive entities.
#include <Select3D_TypeOfSensitivity.hxx>
#include <Select3D_SensitiveSet.hxx>
-#include <Handle_SelectBasics_EntityOwner.hxx>
#include <TColgp_HArray1OfPnt.hxx>
#include <Standard_Boolean.hxx>
#include <SelectBasics_SelectingVolumeManager.hxx>
#include <Select3D_EntitySequence.hxx>
#include <Select3D_SensitiveEntity.hxx>
#include <Select3D_SensitiveSet.hxx>
-#include <Handle_SelectBasics_EntityOwner.hxx>
#include <SelectMgr_SelectingVolumeManager.hxx>
class SelectBasics_EntityOwner;
#include <Select3D_Pnt.hxx>
#include <Select3D_SensitiveEntity.hxx>
-#include <Handle_SelectBasics_EntityOwner.hxx>
#include <Standard_Boolean.hxx>
#include <SelectMgr_SelectingVolumeManager.hxx>
#include <Standard_Real.hxx>
#include <Select3D_SensitiveSet.hxx>
#include <Select3D_TypeOfSensitivity.hxx>
-#include <Handle_SelectBasics_EntityOwner.hxx>
class Standard_ConstructionError;
class Standard_OutOfRange;
Select3D_PointData myPolyg; //!< Points of the poly
mutable gp_Pnt myCOG; //!< Center of the poly
- Handle_TColStd_HArray1OfInteger mySegmentIndexes; //!< Segment indexes for BVH tree build
+ Handle(TColStd_HArray1OfInteger) mySegmentIndexes; //!< Segment indexes for BVH tree build
Select3D_BndBox3d myBndBox; //!< Bounding box of the poly
mutable Standard_Boolean myIsComputed; //!< Is true if all the points and data structures of polygon are initialized
};
#include <Standard_Integer.hxx>
#include <Select3D_Pnt.hxx>
#include <Select3D_SensitiveEntity.hxx>
-#include <Handle_SelectBasics_EntityOwner.hxx>
#include <gp_Pnt.hxx>
#include <SelectMgr_SelectingVolumeManager.hxx>
#include <Standard_OStream.hxx>
#include <Select3D_TypeOfSensitivity.hxx>
#include <Select3D_Pnt.hxx>
#include <Select3D_SensitivePoly.hxx>
-#include <Handle_SelectBasics_EntityOwner.hxx>
#include <SelectMgr_SelectingVolumeManager.hxx>
#include <Standard_OStream.hxx>
#include <Standard_Type.hxx>
#include <Standard_Type.hxx>
-#include <Handle_Poly_Triangulation.hxx>
#include <TopLoc_Location.hxx>
#include <gp_Trsf.hxx>
#include <gp_Pnt.hxx>
#include <Standard_Boolean.hxx>
#include <TColgp_HArray1OfPnt.hxx>
#include <Select3D_SensitiveEntity.hxx>
-#include <Handle_SelectBasics_EntityOwner.hxx>
#include <SelectMgr_SelectingVolumeManager.hxx>
#include <Standard_OStream.hxx>
#include <Select3D_SensitiveSet.hxx>
class TopLoc_Location;
class gp_Pnt;
class Select3D_SensitiveEntity;
-class Handle(Select3D_SensitiveEntity);
//! A framework to define selection of a sensitive entity made of a set of triangles.
class Select3D_SensitiveTriangulation : public Select3D_SensitiveSet
//! Returns the amount of nodes in triangulation
Standard_EXPORT virtual Standard_Integer NbSubElements() Standard_OVERRIDE;
- Standard_EXPORT Handle_Select3D_SensitiveEntity GetConnected() Standard_OVERRIDE;
+ Standard_EXPORT Handle(Select3D_SensitiveEntity) GetConnected() Standard_OVERRIDE;
- const Handle_Poly_Triangulation& Triangulation() const;
+ const Handle(Poly_Triangulation)& Triangulation() const;
Standard_Boolean HasInitLocation() const;
private:
- Handle_Poly_Triangulation myTriangul;
+ Handle(Poly_Triangulation) myTriangul;
TopLoc_Location myInitLocation;
gp_Pnt myCDG3D; //!< Center of the whole triangulation
- Handle_TColStd_HArray1OfInteger myFreeEdges;
+ Handle(TColStd_HArray1OfInteger) myFreeEdges;
Standard_Boolean mySensType; //!< Type of sensitivity: boundary or interior
Standard_Integer myDetectedTr;
Standard_Integer myPrimitivesNb; //!< Amount of free edges or triangles depending on sensitivity type
- Handle_TColStd_HArray1OfInteger myBVHPrimIndexes; //!< Indexes of edges or triangles for BVH build
+ Handle(TColStd_HArray1OfInteger) myBVHPrimIndexes; //!< Indexes of edges or triangles for BVH build
mutable Select3D_BndBox3d myBndBox; //!< Bounding box of the whole triangulation
};
#include <Standard_Type.hxx>
#include <Select3D_SensitiveSet.hxx>
-#include <Handle_SelectBasics_EntityOwner.hxx>
#include <Standard_OStream.hxx>
#include <NCollection_Sequence.hxx>
//! Sets the owner for all entities in wire
Standard_EXPORT void Set (const Handle(SelectBasics_EntityOwner)& theOwnerId);
- Standard_EXPORT Handle_Select3D_SensitiveEntity GetLastDetected() const;
+ Standard_EXPORT Handle(Select3D_SensitiveEntity) GetLastDetected() const;
//! Returns bounding box of the wire. If location
//! transformation is set, it will be applied
#include <NCollection_IndexedMap.hxx>
class SelectMgr_EntityOwner;
-class Handle(SelectMgr_EntityOwner);
typedef NCollection_IndexedMap<Handle(SelectMgr_EntityOwner)> SelectMgr_IndexedMapOfOwner;
typedef NCollection_Handle<NCollection_IndexedMap<Handle(SelectMgr_EntityOwner)> > Handle(SelectMgr_IndexedMapOfOwner);
#include <BVH_PrimitiveSet.hxx>
#include <Select3D_BndBox3d.hxx>
-#include <Handle_SelectMgr_SelectionManager.hxx>
#include <SelectMgr_SelectableObject.hxx>
#include <SelectMgr_VectorTypes.hxx>
#include <SelectMgr_TypeOfUpdate.hxx>
#include <MMgt_TShared.hxx>
-#include <Handle_SelectBasics_SensitiveEntity.hxx>
#include <SelectMgr_SensitiveEntity.hxx>
#include <SelectMgr_StateOfSelection.hxx>
#include <SelectMgr_TypeOfBVHUpdate.hxx>
#define _SelectMgr_SensitiveEntity_HeaderFile
#include <SelectBasics_SensitiveEntity.hxx>
-#include <Handle_SelectBasics_SensitiveEntity.hxx>
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <SelectMgr_Selection.hxx>
#include <SelectMgr_SelectableObject.hxx>
#include <SelectMgr_SelectableObjectSet.hxx>
-#include <Handle_SelectMgr_EntityOwner.hxx>
#include <SelectMgr_StateOfSelection.hxx>
#include <Standard_OStream.hxx>
-#include <Handle_SelectBasics_SensitiveEntity.hxx>
class SelectMgr_SelectionManager;
class SelectMgr_Selection;
void Next();
//! Returns the current selected entity detected by the selector;
- Standard_EXPORT Handle_SelectMgr_EntityOwner Picked() const;
+ Standard_EXPORT Handle(SelectMgr_EntityOwner) Picked() const;
//! Returns the picked element with the highest priority,
//! and which is the closest to the last successful mouse position.
- Standard_EXPORT Handle_SelectMgr_EntityOwner OnePicked();
+ Standard_EXPORT Handle(SelectMgr_EntityOwner) OnePicked();
//! Set preference of selecting one object for OnePicked() method:
//! - If True, objects with less depth (distance fron the view plane) are
//! Returns the entity which is at rank <aRank>
//! in the list of stored ones.
- Standard_EXPORT Handle_SelectMgr_EntityOwner Picked (const Standard_Integer aRank) const;
+ Standard_EXPORT Handle(SelectMgr_EntityOwner) Picked (const Standard_Integer aRank) const;
Standard_EXPORT Standard_Boolean Contains (const Handle(SelectMgr_SelectableObject)& theObject) const;
private:
- Handle_TColStd_HArray1OfInteger myIndexes;
+ Handle(TColStd_HArray1OfInteger) myIndexes;
Standard_Integer myCurRank;
Standard_Boolean myIsLeftChildQueuedFirst;
Standard_Integer myEntityIdx;
#include <Geom_OffsetCurve.hxx>
#include <TColStd_HSequenceOfReal.hxx>
-#include <Handle_Geom2dAdaptor_HCurve.hxx>
#include <Adaptor3d_CurveOnSurface.hxx>
#include <Geom2dAdaptor_HCurve.hxx>
#include <GeomAPI_ProjectPointOnCurve.hxx>
return ::HashCode (const_cast<Standard_Address>(static_cast<const void*>(theHandle.get())), theUpper);
}
-//! For compatibility with previous versions of OCCT, defines typedef opencascade::handle<Class> Handle_Class
+//! For compatibility with previous versions of OCCT, defines typedef opencascade::handle<Class> Handle(Class)
#define DEFINE_STANDARD_HANDLECLASS(C1,C2,BC) typedef Handle(C1) Handle_##C1;
#define DEFINE_STANDARD_HANDLE(C1,C2) DEFINE_STANDARD_HANDLECLASS(C1,C2,Standard_Transient)
#define DEFINE_STANDARD_PHANDLE(C1,C2) DEFINE_STANDARD_HANDLECLASS(C1,C2,Standard_Persistent)
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Macro.hxx>
-#include <Handle_Poly_Triangulation.hxx>
#include <TColgp_Array1OfDir.hxx>
class TopoDS_Shape;
//! @return true if shape is closed manifold Solid or compound of such Solids. <br>
Standard_EXPORT static Standard_Boolean IsClosed(const TopoDS_Shape& theShape);
- Standard_EXPORT static Handle_Poly_Triangulation Triangulation(const TopoDS_Face& aFace,
+ Standard_EXPORT static Handle(Poly_Triangulation) Triangulation(const TopoDS_Face& aFace,
TopLoc_Location& loc);
Standard_EXPORT static void Normal(const TopoDS_Face& aFace,
#include <Standard_Type.hxx>
#include <Standard_Type.hxx>
-#include <Handle_Graphic3d_Group.hxx>
-#include <Handle_Graphic3d_Structure.hxx>
#include <Graphic3d_SequenceOfHClipPlane.hxx>
#include <SelectMgr_ViewerSelector.hxx>
#include <SelectMgr_Selection.hxx>
-#include <Handle_V3d_View.hxx>
-#include <Handle_SelectMgr_EntityOwner.hxx>
#include <NCollection_Handle.hxx>
class Graphic3d_Group;
void ComputeSensitivePrs (const Handle(SelectMgr_Selection)& theSel, const gp_Trsf& theLoc);
- Handle_Graphic3d_Group myareagroup;
- Handle_Graphic3d_Group mysensgroup;
- Handle_Graphic3d_Structure mystruct;
+ Handle(Graphic3d_Group) myareagroup;
+ Handle(Graphic3d_Group) mysensgroup;
+ Handle(Graphic3d_Structure) mystruct;
Graphic3d_SequenceOfHClipPlane myClipPlanes;
};
#ifndef TDF_AttributeIndexedMap_HeaderFile
#define TDF_AttributeIndexedMap_HeaderFile
-#include <Handle_TDF_Attribute.hxx>
#include <TColStd_MapTransientHasher.hxx>
#include <NCollection_IndexedMap.hxx>
class TDF_AttributeIterator;
class TDF_ChildIterator;
class TDF_Data;
-class Handle(TDF_Data);
class TDF_Label;
#define KEEP_LOCAL_ROOT
#include <Message_Messenger.hxx>
#include <TColStd_SequenceOfExtendedString.hxx>
-class Handle(TObj_Application);
//!
//! This is a base class for OCAF based TObj models
#include <TColStd_SequenceOfAsciiString.hxx>
#include <TColStd_IndexedMapOfTransient.hxx>
-class Handle(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 <Handle_TObj_Model.hxx>
#include <TDF_Label.hxx>
#include <TObj_Partition.hxx>
#include <Message_Messenger.hxx>
-class Handle(TObj_Application);
-class Handle(TObj_TNameContainer);
-class Handle(TObj_Object);
-class Handle(TObj_Partition);
-class Handle(TObj_CheckModel);
-class Handle(TCollection_HExtendedString);
-class Handle(TDocStd_Document);
/**
* Base class for OCAF based models.
#include <TObj_ObjectIterator.hxx>
#include <TObj_SequenceOfIterator.hxx>
-class Handle(TObj_Model);
/**
* This class provides an iterator by all objects in the model.
#include <TObj_Common.hxx>
#include <TObj_DeletingMode.hxx>
#include <TObj_SequenceOfObject.hxx>
-#include <Handle_TObj_Model.hxx>
-#include <Handle_TObj_Object.hxx>
#include <TDF_Label.hxx>
#include <gp_XYZ.hxx>
class TObj_Persistence;
-class Handle(TObj_ObjectIterator);
-class Handle(TObj_TNameContainer);
-
-class Handle(TCollection_HAsciiString);
-class Handle(TCollection_HExtendedString);
-class Handle(TColStd_HArray1OfReal);
-class Handle(TColStd_HArray1OfInteger);
-class Handle(TColStd_HArray1OfExtendedString);
+
//! Basis class for transient objects in OCAF-based models
#include <TObj_Common.hxx>
-class Handle(TObj_Object);
/**
* This class provides an iterator by objects in a partition.
#include <TObj_Object.hxx>
#include <TObj_Persistence.hxx>
-class Handle(TCollection_HExtendedString);
-class Handle(TObj_Partition);
/**
* This class privides tool handling one of partitions (the set of
#include <TObj_Container.hxx>
class TDF_Label;
-class Handle(TObj_Object);
/** This class is intended to be a root of tools (one per class)
* to manage persistence of objects inherited from TObj_Object
#include <NCollection_DefineHSequence.hxx>
#include <TObj_Common.hxx>
-#include <Handle_TObj_Object.hxx>
typedef NCollection_Sequence<Handle(TObj_Object)> TObj_SequenceOfObject;
typedef NCollection_SparseArray<Standard_Integer> TObj_TIntSparseArray_VecOfData;
typedef NCollection_SparseArray<Standard_Integer> TObj_TIntSparseArray_MapOfData;
-class Handle(TObj_TIntSparseArray);
class Standard_GUID;
-class Handle(TDF_RelocationTable);
/**
* OCAF Attribute to store a set of positive integer values in the OCAF tree.
#define TObj_TModel_HeaderFile
#include <TDF_Attribute.hxx>
-#include <Handle_TObj_Model.hxx>
-class Handle(TDF_RelocationTable);
-class Handle(TObj_TModel);
/**
* Attribute to store OCAF-based models in OCAF tree
#include <TObj_Container.hxx>
#include <TDF_Attribute.hxx>
-class Handle(TCollection_HExtendedString);
-class Handle(TObj_TNameContainer);
/**
* This class provides OCAF Attribute to storing the unique names of object in
#include <TDF_Attribute.hxx>
-class Handle(TObj_TObject);
class Standard_GUID;
class TDF_Label;
-class Handle(TDF_RelocationTable);
/**
* Purpose: OCAF Attribute to storing objects (interfaces) of OCAF-based
#include <TDF_Attribute.hxx>
#include <TDF_Label.hxx>
-class Handle(TObj_TReference);
-class Handle(TObj_Object);
class Standard_GUID;
-class Handle(TDF_RelocationTable);
/**
* Attribute for storing references to the objects which implement
#include <TDF_Attribute.hxx>
-class Handle(TObj_TXYZ);
class Standard_GUID;
class TDF_Label;
-class Handle(TDF_RelocationTable);
/*
* Attribute for storing gp_XYZ
// Section: General commands
//=======================================================================
-class Handle(TObjDRAW_Model);
//! simple model with redefined pure virtual method
class TObjDRAW_Model : public TObj_Model
DEFINE_STANDARD_HANDLE (TObjDRAW_Model,TObj_Model)
-class Handle(TObjDRAW_Object);
//! simple object to check API and features of TObj_Object
class TObjDRAW_Object : public TObj_Object
#include <Draw_Interpretor.hxx>
#include <Standard_Integer.hxx>
#include <Standard_CString.hxx>
-#include <Handle_V3d_View.hxx>
#include <Standard_Boolean.hxx>
-#include <Handle_MMgt_TShared.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <TopTools_HArray1OfShape.hxx>
-#include <Handle_AIS_InteractiveObject.hxx>
#include <AIS_KindOfInteractive.hxx>
#include <TColStd_HArray1OfTransient.hxx>
-#include <Handle_V3d_Viewer.hxx>
-#include <Handle_AIS_InteractiveContext.hxx>
-#include <Handle_ViewerTest_EventManager.hxx>
#include <Quantity_NameOfColor.hxx>
class TCollection_AsciiString;
class VrmlData_Scene;
class gp_XY;
class gp_XYZ;
-class Handle(VrmlData_Node);
class TCollection_AsciiString;
/**
#include <Standard_Mutex.hxx>
struct VrmlData_InBuffer;
-class Handle(VrmlData_WorldInfo);
class VrmlData_DataMapOfShapeAppearance;
/**
class VrmlData_Scene;
class TopoDS_Face;
-class Handle(Poly_Triangulation);
-class Handle(Poly_Polygon3D);
-class Handle(VrmlData_Coordinate);
/**
* Algorithm converting one shape or a set of shapes to VrmlData_Scene.
*/
#include <TObj_Common.hxx>
#include <Standard_GUID.hxx>
-class Handle(XmlMDF_ADriverTable);
-class Handle(CDM_MessageDriver);
// Class for registering storage/retrieval drivers for TObj XML persistence
//
#include <XmlLDrivers_DocumentRetrievalDriver.hxx>
#include <XmlMDF_ADriverTable.hxx>
-class Handle(CDM_MessageDriver);
// Retrieval driver of a TObj XML document
//
#include <XmlLDrivers_DocumentStorageDriver.hxx>
#include <XmlMDF_ADriverTable.hxx>
-class Handle(CDM_MessageDriver);
// Block of comments describing class XmlTObjDrivers_DocumentStorageDriver
//
projects / occt-copy.git / commitdiff