Standard_Boolean okstat = Standard_True;
//#ifndef DEB
- Handle_SelectMgr_SelectableObject aSelectable = anObj->Selectable() ;
+ Handle(SelectMgr_SelectableObject) aSelectable = anObj->Selectable() ;
if( hasC && ((Handle(AIS_InteractiveObject)&) aSelectable)->HasColor() )
//#else
// if(hasC && ((Handle(AIS_InteractiveObject)&) anObj->Selectable())->HasColor())
}
-void AIS_Axis::Compute(const Handle_Prs3d_Projector& aProjector, const Handle_Geom_Transformation& aTransformation, const Handle_Prs3d_Presentation& aPresentation)
+void AIS_Axis::Compute(const Handle(Prs3d_Projector)& aProjector, const Handle(Geom_Transformation)& aTransformation, const Handle(Prs3d_Presentation)& aPresentation)
{
-// Standard_NotImplemented::Raise("AIS_Axis::Compute(const Handle_Prs3d_Projector&, const Handle_Geom_Transformation&, const Handle_Prs3d_Presentation&)");
+// Standard_NotImplemented::Raise("AIS_Axis::Compute(const Handle(Prs3d_Projector)&, const Handle(Geom_Transformation)&, const Handle(Prs3d_Presentation)&)");
PrsMgr_PresentableObject::Compute( aProjector , aTransformation , aPresentation ) ;
}
PrsMgr_PresentableObject::Compute( aProjector , aPresentation ) ;
}
-void AIS_Chamf2dDimension::Compute(const Handle_Prs3d_Projector& aProjector, const Handle_Geom_Transformation& aTransformation, const Handle_Prs3d_Presentation& aPresentation)
+void AIS_Chamf2dDimension::Compute(const Handle(Prs3d_Projector)& aProjector, const Handle(Geom_Transformation)& aTransformation, const Handle(Prs3d_Presentation)& aPresentation)
{
-// Standard_NotImplemented::Raise("AIS_Chamf2dDimension::Compute(const Handle_Prs3d_Projector&, const Handle_Geom_Transformation&, const Handle_Prs3d_Presentation&)");
+// Standard_NotImplemented::Raise("AIS_Chamf2dDimension::Compute(const Handle(Prs3d_Projector)&, const Handle(Geom_Transformation)&, const Handle(Prs3d_Presentation)&)");
PrsMgr_PresentableObject::Compute( aProjector , aTransformation , aPresentation ) ;
}
PrsMgr_PresentableObject::Compute( aProjector , aPresentation ) ;
}
-void AIS_Chamf3dDimension::Compute(const Handle_Prs3d_Projector& aProjector, const Handle_Geom_Transformation& aTransformation, const Handle_Prs3d_Presentation& aPresentation)
+void AIS_Chamf3dDimension::Compute(const Handle(Prs3d_Projector)& aProjector, const Handle(Geom_Transformation)& aTransformation, const Handle(Prs3d_Presentation)& aPresentation)
{
-// Standard_NotImplemented::Raise("AIS_Chamf3dDimension::Compute(const Handle_Prs3d_Projector&, const Handle_Geom_Transformation&, const Handle_Prs3d_Presentation&)");
+// Standard_NotImplemented::Raise("AIS_Chamf3dDimension::Compute(const Handle(Prs3d_Projector)&, const Handle(Geom_Transformation)&, const Handle(Prs3d_Presentation)&)");
PrsMgr_PresentableObject::Compute( aProjector , aTransformation , aPresentation ) ;
}
//purpose :
//=======================================================================
-void AIS_Circle::Compute(const Handle_Prs3d_Projector& aProjector,
- const Handle_Geom_Transformation& aTransformation,
- const Handle_Prs3d_Presentation& aPresentation)
+void AIS_Circle::Compute(const Handle(Prs3d_Projector)& aProjector,
+ const Handle(Geom_Transformation)& aTransformation,
+ const Handle(Prs3d_Presentation)& aPresentation)
{
-// Standard_NotImplemented::Raise("AIS_Circle::Compute(const Handle_Prs3d_Projector&, const Handle_Geom_Transformation&, const Handle_Prs3d_Presentation&)");
+// Standard_NotImplemented::Raise("AIS_Circle::Compute(const Handle(Prs3d_Projector)&, const Handle(Geom_Transformation)&, const Handle(Prs3d_Presentation)&)");
PrsMgr_PresentableObject::Compute( aProjector , aTransformation , aPresentation ) ;
}
}
}
-void AIS_ConcentricRelation::Compute(const Handle_Prs3d_Projector& aProjector, const Handle_Geom_Transformation& aTransformation, const Handle_Prs3d_Presentation& aPresentation)
+void AIS_ConcentricRelation::Compute(const Handle(Prs3d_Projector)& aProjector, const Handle(Geom_Transformation)& aTransformation, const Handle(Prs3d_Presentation)& aPresentation)
{
-// Standard_NotImplemented::Raise("AIS_ConcentricRelation::Compute(const Handle_Prs3d_Projector&, const Handle_Geom_Transformation&, const Handle_Prs3d_Presentation&)");
+// Standard_NotImplemented::Raise("AIS_ConcentricRelation::Compute(const Handle(Prs3d_Projector)&, const Handle(Geom_Transformation)&, const Handle(Prs3d_Presentation)&)");
PrsMgr_PresentableObject::Compute( aProjector , aTransformation , aPresentation ) ;
}
thePrs->ReCompute();
}
-void AIS_ConnectedInteractive::Compute(const Handle_Prs3d_Projector& aProjector, const Handle_Geom_Transformation& aTransformation, const Handle_Prs3d_Presentation& aPresentation)
+void AIS_ConnectedInteractive::Compute(const Handle(Prs3d_Projector)& aProjector, const Handle(Geom_Transformation)& aTransformation, const Handle(Prs3d_Presentation)& aPresentation)
{
-// Standard_NotImplemented::Raise("AIS_ConnectedInteractive::Compute(const Handle_Prs3d_Projector&, const Handle_Geom_Transformation&, const Handle_Prs3d_Presentation&)");
+// Standard_NotImplemented::Raise("AIS_ConnectedInteractive::Compute(const Handle(Prs3d_Projector)&, const Handle(Geom_Transformation)&, const Handle(Prs3d_Presentation)&)");
PrsMgr_PresentableObject::Compute( aProjector , aTransformation , aPresentation ) ;
}
-void AIS_ConnectedInteractive::Compute(const Handle_Prs3d_Projector& aProjector, const Handle_Prs3d_Presentation& aPresentation)
+void AIS_ConnectedInteractive::Compute(const Handle(Prs3d_Projector)& aProjector, const Handle(Prs3d_Presentation)& aPresentation)
{
-// Standard_NotImplemented::Raise("AIS_ConnectedInteractive::Compute(const Handle_Prs3d_Projector&, const Handle_Prs3d_Presentation&)");
+// Standard_NotImplemented::Raise("AIS_ConnectedInteractive::Compute(const Handle(Prs3d_Projector)&, const Handle(Prs3d_Presentation)&)");
PrsMgr_PresentableObject::Compute( aProjector , aPresentation ) ;
}
// Standard_NotImplemented::Raise("AIS_ConnectedInteractive::UpdateLocation(const Handle(SelectMgr_Selection)& Sel)");
SelectMgr_SelectableObject::UpdateLocation(Sel) ;
}
-/*void AIS_ConnectedInteractive::UpdateLocation(const Handle_Prs3d_Presentation& aPresentation)
+/*void AIS_ConnectedInteractive::UpdateLocation(const Handle(Prs3d_Presentation)& aPresentation)
{
-// Standard_NotImplemented::Raise("AIS_ConnectedInteractive::UpdateLocation(const Handle_Prs3d_Presentation&)");
+// Standard_NotImplemented::Raise("AIS_ConnectedInteractive::UpdateLocation(const Handle(Prs3d_Presentation)&)");
SelectMgr_SelectableObject::UpdateLocation(aPresentation) ;
}*/
// function : FaceBoundaryAspect
// purpose :
// =======================================================================
-Handle_Prs3d_LineAspect AIS_Drawer::FaceBoundaryAspect()
+Handle(Prs3d_LineAspect) AIS_Drawer::FaceBoundaryAspect()
{
if (!IsOwnFaceBoundaryAspect ())
{
//purpose :
//=======================================================================
-void AIS_EqualRadiusRelation::Compute(const Handle_Prs3d_Projector& aProjector,
- const Handle_Geom_Transformation& aTransformation,
- const Handle_Prs3d_Presentation& aPresentation)
+void AIS_EqualRadiusRelation::Compute(const Handle(Prs3d_Projector)& aProjector,
+ const Handle(Geom_Transformation)& aTransformation,
+ const Handle(Prs3d_Presentation)& aPresentation)
{
-// Standard_NotImplemented::Raise("AIS_EqualRadiusRelation::Compute(const Handle_Prs3d_Projector&, const Handle_Geom_Transformation&, const Handle_Prs3d_Presentation&)");
+// Standard_NotImplemented::Raise("AIS_EqualRadiusRelation::Compute(const Handle(Prs3d_Projector)&, const Handle(Geom_Transformation)&, const Handle(Prs3d_Presentation)&)");
PrsMgr_PresentableObject::Compute( aProjector , aTransformation , aPresentation ) ;
}
//purpose :
//=======================================================================
-void AIS_FixRelation::Compute(const Handle_Prs3d_Projector& aProjector,
- const Handle_Geom_Transformation& aTransformation,
- const Handle_Prs3d_Presentation& aPresentation)
+void AIS_FixRelation::Compute(const Handle(Prs3d_Projector)& aProjector,
+ const Handle(Geom_Transformation)& aTransformation,
+ const Handle(Prs3d_Presentation)& aPresentation)
{
-// Standard_NotImplemented::Raise("AIS_FixRelation::Compute(const Handle_Prs3d_Projector&, const Handle_Geom_Transformation&, const Handle_Prs3d_Presentation&)");
+// Standard_NotImplemented::Raise("AIS_FixRelation::Compute(const Handle(Prs3d_Projector)&, const Handle(Geom_Transformation)&, const Handle(Prs3d_Presentation)&)");
PrsMgr_PresentableObject::Compute( aProjector , aTransformation , aPresentation ) ;
}
PrsMgr_PresentableObject::Compute( aProjector , aPresentation ) ;
}
-void AIS_IdenticRelation::Compute(const Handle_Prs3d_Projector& aProjector, const Handle_Geom_Transformation& aTransformation, const Handle_Prs3d_Presentation& aPresentation)
+void AIS_IdenticRelation::Compute(const Handle(Prs3d_Projector)& aProjector, const Handle(Geom_Transformation)& aTransformation, const Handle(Prs3d_Presentation)& aPresentation)
{
-// Standard_NotImplemented::Raise("AIS_IdenticRelation::Compute(const Handle_Prs3d_Projector&, const Handle_Geom_Transformation&, const Handle_Prs3d_Presentation&)");
+// Standard_NotImplemented::Raise("AIS_IdenticRelation::Compute(const Handle(Prs3d_Projector)&, const Handle(Geom_Transformation)&, const Handle(Prs3d_Presentation)&)");
PrsMgr_PresentableObject::Compute( aProjector , aTransformation , aPresentation ) ;
}
//purpose :
//=======================================================================
-void AIS_InteractiveContext::SetSelectionMode(const Handle_AIS_InteractiveObject&, const Standard_Integer )
+void AIS_InteractiveContext::SetSelectionMode(const Handle(AIS_InteractiveObject)&, const Standard_Integer )
{
}
//purpose :
//=======================================================================
-void AIS_InteractiveContext::UnsetSelectionMode(const Handle_AIS_InteractiveObject&)
+void AIS_InteractiveContext::UnsetSelectionMode(const Handle(AIS_InteractiveObject)&)
{
}
//purpose :
//=======================================================================
-Standard_Boolean AIS_InteractiveContext::IsInLocal(const Handle_AIS_InteractiveObject& anIObj,
+Standard_Boolean AIS_InteractiveContext::IsInLocal(const Handle(AIS_InteractiveObject)& anIObj,
Standard_Integer& TheIndex) const
{
if(anIObj.IsNull()) return Standard_False;
inline Standard_Boolean AIS_InteractiveContext::HasOpenedContext() const
{return myCurLocalIndex != 0;}
-inline Handle_AIS_LocalContext AIS_InteractiveContext::LocalContext() const
+inline Handle(AIS_LocalContext) AIS_InteractiveContext::LocalContext() const
{ return (myCurLocalIndex > 0) ? myLocalContexts(myCurLocalIndex) : NULL; }
inline const TCollection_AsciiString& AIS_InteractiveContext::CurrentName() const
}
-void AIS_Line::Compute(const Handle_Prs3d_Projector& aProjector, const Handle_Geom_Transformation& aTransformation, const Handle_Prs3d_Presentation& aPresentation)
+void AIS_Line::Compute(const Handle(Prs3d_Projector)& aProjector, const Handle(Geom_Transformation)& aTransformation, const Handle(Prs3d_Presentation)& aPresentation)
{
-// Standard_NotImplemented::Raise("AIS_Line::Compute(const Handle_Prs3d_Projector&, const Handle_Geom_Transformation&, const Handle_Prs3d_Presentation&)");
+// Standard_NotImplemented::Raise("AIS_Line::Compute(const Handle(Prs3d_Projector)&, const Handle(Geom_Transformation)&, const Handle(Prs3d_Presentation)&)");
PrsMgr_PresentableObject::Compute( aProjector , aTransformation , aPresentation) ;
}
//purpose :
//=======================================================================
-void AIS_MaxRadiusDimension::Compute(const Handle_Prs3d_Projector& aProjector,
- const Handle_Geom_Transformation& aTransformation,
- const Handle_Prs3d_Presentation& aPresentation)
+void AIS_MaxRadiusDimension::Compute(const Handle(Prs3d_Projector)& aProjector,
+ const Handle(Geom_Transformation)& aTransformation,
+ const Handle(Prs3d_Presentation)& aPresentation)
{
-// Standard_NotImplemented::Raise("AIS_MaxRadiusDimension::Compute(const Handle_Prs3d_Projector&, const Handle_Geom_Transformation&, const Handle_Prs3d_Presentation&)");
+// Standard_NotImplemented::Raise("AIS_MaxRadiusDimension::Compute(const Handle(Prs3d_Projector)&, const Handle(Geom_Transformation)&, const Handle(Prs3d_Presentation)&)");
PrsMgr_PresentableObject::Compute( aProjector , aTransformation , aPresentation ) ;
}
// PrsMgr_PresentableObject::Compute( aProjector , aPresentation ) ;
}
-void AIS_MidPointRelation::Compute(const Handle_Prs3d_Projector& aProjector,
- const Handle_Geom_Transformation& aTransformation,
- const Handle_Prs3d_Presentation& aPresentation)
+void AIS_MidPointRelation::Compute(const Handle(Prs3d_Projector)& aProjector,
+ const Handle(Geom_Transformation)& aTransformation,
+ const Handle(Prs3d_Presentation)& aPresentation)
{
- Standard_NotImplemented::Raise("AIS_MidPointRelation::Compute(const Handle_Prs3d_Projector&, const Handle_Geom_Transformation&, const Handle_Prs3d_Presentation&)");
+ Standard_NotImplemented::Raise("AIS_MidPointRelation::Compute(const Handle(Prs3d_Projector)&, const Handle(Geom_Transformation)&, const Handle(Prs3d_Presentation)&)");
PrsMgr_PresentableObject::Compute( aProjector , aTransformation , aPresentation ) ;
}
//purpose :
//=======================================================================
-void AIS_MinRadiusDimension::Compute(const Handle_Prs3d_Projector& aProjector,
- const Handle_Geom_Transformation& aTransformation,
- const Handle_Prs3d_Presentation& aPresentation)
+void AIS_MinRadiusDimension::Compute(const Handle(Prs3d_Projector)& aProjector,
+ const Handle(Geom_Transformation)& aTransformation,
+ const Handle(Prs3d_Presentation)& aPresentation)
{
-// Standard_NotImplemented::Raise("AIS_MinRadiusDimension::Compute(const Handle_Prs3d_Projector&, const Handle_Geom_Transformation&, const Handle_Prs3d_Presentation&)");
+// Standard_NotImplemented::Raise("AIS_MinRadiusDimension::Compute(const Handle(Prs3d_Projector)&, const Handle(Geom_Transformation)&, const Handle(Prs3d_Presentation)&)");
PrsMgr_PresentableObject::Compute( aProjector , aTransformation , aPresentation ) ;
}
//purpose :
//=======================================================================
-void AIS_MultipleConnectedInteractive::Compute(const Handle_Prs3d_Projector& aProjector,
- const Handle_Prs3d_Presentation& aPresentation)
+void AIS_MultipleConnectedInteractive::Compute(const Handle(Prs3d_Projector)& aProjector,
+ const Handle(Prs3d_Presentation)& aPresentation)
{
-// Standard_NotImplemented::Raise("AIS_MultipleConnectedInteractive::Compute(const Handle_Prs3d_Projector&, const Handle_Prs3d_Presentation&)");
+// Standard_NotImplemented::Raise("AIS_MultipleConnectedInteractive::Compute(const Handle(Prs3d_Projector)&, const Handle(Prs3d_Presentation)&)");
PrsMgr_PresentableObject::Compute( aProjector , aPresentation ) ;
}
//purpose :
//=======================================================================
-void AIS_MultipleConnectedInteractive::Compute(const Handle_Prs3d_Projector& aProjector,
- const Handle_Geom_Transformation& aTransformation,
- const Handle_Prs3d_Presentation& aPresentation)
+void AIS_MultipleConnectedInteractive::Compute(const Handle(Prs3d_Projector)& aProjector,
+ const Handle(Geom_Transformation)& aTransformation,
+ const Handle(Prs3d_Presentation)& aPresentation)
{
-// Standard_NotImplemented::Raise("AIS_MultipleConnectedInteractive::Compute(const Handle_Prs3d_Projector&, const Handle_Geom_Transformation&, const Handle_Prs3d_Presentation&)");
+// Standard_NotImplemented::Raise("AIS_MultipleConnectedInteractive::Compute(const Handle(Prs3d_Projector)&, const Handle(Geom_Transformation)&, const Handle(Prs3d_Presentation)&)");
PrsMgr_PresentableObject::Compute( aProjector , aTransformation , aPresentation ) ;
}
//purpose :
//=======================================================================
-void AIS_MultipleConnectedShape::Compute(const Handle_PrsMgr_PresentationManager3d& aPresentationManager3d,
- const Handle_Prs3d_Presentation& aPresentation,
+void AIS_MultipleConnectedShape::Compute(const Handle(PrsMgr_PresentationManager3d)& aPresentationManager3d,
+ const Handle(Prs3d_Presentation)& aPresentation,
const int anint)
{
AIS_MultipleConnectedInteractive::Compute( aPresentationManager3d , aPresentation , anint ) ;
PrsMgr_PresentableObject::Compute( aProjector , aPresentation ) ;
}
-void AIS_ParallelRelation::Compute(const Handle_Prs3d_Projector& aProjector, const Handle_Geom_Transformation& aTransformation, const Handle_Prs3d_Presentation& aPresentation)
+void AIS_ParallelRelation::Compute(const Handle(Prs3d_Projector)& aProjector, const Handle(Geom_Transformation)& aTransformation, const Handle(Prs3d_Presentation)& aPresentation)
{
-// Standard_NotImplemented::Raise("AIS_ParallelRelation::Compute(const Handle_Prs3d_Projector&, const Handle_Geom_Transformation&, const Handle_Prs3d_Presentation&)");
+// Standard_NotImplemented::Raise("AIS_ParallelRelation::Compute(const Handle(Prs3d_Projector)&, const Handle(Geom_Transformation)&, const Handle(Prs3d_Presentation)&)");
PrsMgr_PresentableObject::Compute( aProjector , aTransformation , aPresentation ) ;
}
PrsMgr_PresentableObject::Compute( aProjector , aPresentation ) ;
}
-void AIS_PerpendicularRelation::Compute(const Handle_Prs3d_Projector& aProjector, const Handle_Geom_Transformation& aTransformation, const Handle_Prs3d_Presentation& aPresentation)
+void AIS_PerpendicularRelation::Compute(const Handle(Prs3d_Projector)& aProjector, const Handle(Geom_Transformation)& aTransformation, const Handle(Prs3d_Presentation)& aPresentation)
{
-// Standard_NotImplemented::Raise("AIS_PerpendicularRelation::Compute(const Handle_Prs3d_Projector&, const Handle_Geom_Transformation&, const Handle_Prs3d_Presentation&)");
+// Standard_NotImplemented::Raise("AIS_PerpendicularRelation::Compute(const Handle(Prs3d_Projector)&, const Handle(Geom_Transformation)&, const Handle(Prs3d_Presentation)&)");
PrsMgr_PresentableObject::Compute( aProjector , aTransformation , aPresentation ) ;
}
}
}
-void AIS_Plane::Compute(const Handle_Prs3d_Projector& aProjector, const Handle_Geom_Transformation& aTransformation, const Handle_Prs3d_Presentation& aPresentation)
+void AIS_Plane::Compute(const Handle(Prs3d_Projector)& aProjector, const Handle(Geom_Transformation)& aTransformation, const Handle(Prs3d_Presentation)& aPresentation)
{
PrsMgr_PresentableObject::Compute(aProjector, aTransformation, aPresentation);
}
aPresentation->SetInfiniteState (Standard_True);
}
-void AIS_PlaneTrihedron::Compute(const Handle_Prs3d_Projector& aProjector, const Handle_Geom_Transformation& aTransformation, const Handle_Prs3d_Presentation& aPresentation)
+void AIS_PlaneTrihedron::Compute(const Handle(Prs3d_Projector)& aProjector, const Handle(Geom_Transformation)& aTransformation, const Handle(Prs3d_Presentation)& aPresentation)
{
-// Standard_NotImplemented::Raise("AIS_PlaneTrihedron::Compute(const Handle_Prs3d_Projector&, const Handle_Geom_Transformation&, const Handle_Prs3d_Presentation&)");
+// Standard_NotImplemented::Raise("AIS_PlaneTrihedron::Compute(const Handle(Prs3d_Projector)&, const Handle(Geom_Transformation)&, const Handle(Prs3d_Presentation)&)");
PrsMgr_PresentableObject::Compute( aProjector , aTransformation , aPresentation) ;
}
//purpose :
//=======================================================================
-void AIS_Point::Compute(const Handle_Prs3d_Projector& aProjector,
- const Handle_Geom_Transformation& aTransformation,
- const Handle_Prs3d_Presentation& aPresentation)
+void AIS_Point::Compute(const Handle(Prs3d_Projector)& aProjector,
+ const Handle(Geom_Transformation)& aTransformation,
+ const Handle(Prs3d_Presentation)& aPresentation)
{
-// Standard_NotImplemented::Raise("AIS_Point::Compute(const Handle_Prs3d_Projector&, const Handle_Geom_Transformation&, const Handle_Prs3d_Presentation&)");
+// Standard_NotImplemented::Raise("AIS_Point::Compute(const Handle(Prs3d_Projector)&, const Handle(Geom_Transformation)&, const Handle(Prs3d_Presentation)&)");
PrsMgr_PresentableObject::Compute( aProjector , aTransformation , aPresentation) ;
}
// PrsMgr_PresentableObject::Compute( aProjector , aPresentation ) ;
}
-void AIS_SymmetricRelation::Compute(const Handle_Prs3d_Projector& aProjector,
- const Handle_Geom_Transformation& aTransformation,
- const Handle_Prs3d_Presentation& aPresentation)
+void AIS_SymmetricRelation::Compute(const Handle(Prs3d_Projector)& aProjector,
+ const Handle(Geom_Transformation)& aTransformation,
+ const Handle(Prs3d_Presentation)& aPresentation)
{
- Standard_NotImplemented::Raise("AIS_SymmetricRelation::Compute(const Handle_Prs3d_Projector&, const Handle_Geom_Transformation&, const Handle_Prs3d_Presentation&)");
+ Standard_NotImplemented::Raise("AIS_SymmetricRelation::Compute(const Handle(Prs3d_Projector)&, const Handle(Geom_Transformation)&, const Handle(Prs3d_Presentation)&)");
PrsMgr_PresentableObject::Compute( aProjector , aTransformation , aPresentation ) ;
}
PrsMgr_PresentableObject::Compute( aProjector , aPresentation ) ;
}
-void AIS_TangentRelation::Compute(const Handle_Prs3d_Projector& aProjector,
- const Handle_Geom_Transformation& aTransformation,
- const Handle_Prs3d_Presentation& aPresentation)
+void AIS_TangentRelation::Compute(const Handle(Prs3d_Projector)& aProjector,
+ const Handle(Geom_Transformation)& aTransformation,
+ const Handle(Prs3d_Presentation)& aPresentation)
{
-// Standard_NotImplemented::Raise("AIS_TangentRelation::Compute(const Handle_Prs3d_Projector&, const Handle_Geom_Transformation&, const Handle_Prs3d_Presentation&)");
+// Standard_NotImplemented::Raise("AIS_TangentRelation::Compute(const Handle(Prs3d_Projector)&, const Handle(Geom_Transformation)&, const Handle(Prs3d_Presentation)&)");
PrsMgr_PresentableObject::Compute( aProjector , aTransformation , aPresentation ) ;
}
//purpose :
//=======================================================================
-void AIS_Trihedron::Compute(const Handle_Prs3d_Projector& aProjector,
- const Handle_Geom_Transformation& aTransformation,
- const Handle_Prs3d_Presentation& aPresentation)
+void AIS_Trihedron::Compute(const Handle(Prs3d_Projector)& aProjector,
+ const Handle(Geom_Transformation)& aTransformation,
+ const Handle(Prs3d_Presentation)& aPresentation)
{
-// Standard_NotImplemented::Raise("AIS_Trihedron::Compute(const Handle_Prs3d_Projector&, const Handle_Geom_Transformation&, const Handle_Prs3d_Presentation&)");
+// Standard_NotImplemented::Raise("AIS_Trihedron::Compute(const Handle(Prs3d_Projector)&, const Handle(Geom_Transformation)&, const Handle(Prs3d_Presentation)&)");
PrsMgr_PresentableObject::Compute( aProjector , aTransformation , aPresentation) ;
}
return Standard_False;
//#ifndef DEB
- Handle_SelectMgr_SelectableObject aSelectableObject = anObj->Selectable() ;
+ Handle(SelectMgr_SelectableObject) aSelectableObject = anObj->Selectable() ;
return ((Handle(AIS_InteractiveObject)&) aSelectableObject)->Type()== myKind;
//#else
// return ((Handle(AIS_InteractiveObject)&)anObj->Selectable())->Type()== myKind;
Surf->VIntervals(Tab,S);
}
-inline Handle_Adaptor3d_HSurface Adaptor3d_HSurfaceTool::UTrim(const Handle(Adaptor3d_HSurface)& Surf,
+inline Handle(Adaptor3d_HSurface) Adaptor3d_HSurfaceTool::UTrim(const Handle(Adaptor3d_HSurface)& Surf,
const Standard_Real F,
const Standard_Real L,
const Standard_Real Tol)
return Surf->UTrim(F,L,Tol);
}
-inline Handle_Adaptor3d_HSurface Adaptor3d_HSurfaceTool::VTrim(const Handle(Adaptor3d_HSurface)& Surf,
+inline Handle(Adaptor3d_HSurface) Adaptor3d_HSurfaceTool::VTrim(const Handle(Adaptor3d_HSurface)& Surf,
const Standard_Real F,
const Standard_Real L,
const Standard_Real Tol)
AdvApprox_ApproxAFunction(const Standard_Integer Num1DSS,
const Standard_Integer Num2DSS,
const Standard_Integer Num3DSS,
- const Handle_TColStd_HArray1OfReal& OneDTol,
- const Handle_TColStd_HArray1OfReal& TwoDTol,
- const Handle_TColStd_HArray1OfReal& ThreeDTol,
+ const Handle(TColStd_HArray1OfReal)& OneDTol,
+ const Handle(TColStd_HArray1OfReal)& TwoDTol,
+ const Handle(TColStd_HArray1OfReal)& ThreeDTol,
const Standard_Real First,
const Standard_Real Last,
const GeomAbs_Shape Continuity,
AdvApprox_ApproxAFunction(const Standard_Integer Num1DSS,
const Standard_Integer Num2DSS,
const Standard_Integer Num3DSS,
- const Handle_TColStd_HArray1OfReal& OneDTol,
- const Handle_TColStd_HArray1OfReal& TwoDTol,
- const Handle_TColStd_HArray1OfReal& ThreeDTol,
+ const Handle(TColStd_HArray1OfReal)& OneDTol,
+ const Handle(TColStd_HArray1OfReal)& TwoDTol,
+ const Handle(TColStd_HArray1OfReal)& ThreeDTol,
const Standard_Real First,
const Standard_Real Last,
const GeomAbs_Shape Continuity,
#include <TColgp_HArray1OfVec2d.hxx>
-#define tabTang (*(Handle_TColgp_HArray1OfVec*)&ttabTang)
-#define tabCurv (*(Handle_TColgp_HArray1OfVec*)&ttabCurv)
-#define tabTang2d (*(Handle_TColgp_HArray1OfVec2d*)&ttabTang2d)
-#define tabCurv2d (*(Handle_TColgp_HArray1OfVec2d*)&ttabCurv2d)
+#define tabTang (*(Handle(TColgp_HArray1OfVec)*)&ttabTang)
+#define tabCurv (*(Handle(TColgp_HArray1OfVec)*)&ttabCurv)
+#define tabTang2d (*(Handle(TColgp_HArray1OfVec2d)*)&ttabTang2d)
+#define tabCurv2d (*(Handle(TColgp_HArray1OfVec2d)*)&ttabCurv2d)
#include <Standard_OutOfRange.hxx>
-#define tabPoint (*(Handle_TColgp_HArray1OfPnt*)&ttabPoint)
-#define tabPoint2d (*(Handle_TColgp_HArray1OfPnt2d*)&ttabPoint2d)
+#define tabPoint (*(Handle(TColgp_HArray1OfPnt)*)&ttabPoint)
+#define tabPoint2d (*(Handle(TColgp_HArray1OfPnt2d)*)&ttabPoint2d)
AppParCurves_MultiPoint::AppParCurves_MultiPoint() {}
typedef BOPCol_TBBContextFunctor
<BOPAlgo_VFI,
BOPAlgo_VectorOfVFI,
- Handle_BOPInt_Context,
+ Handle(BOPInt_Context),
BOPInt_Context> BOPAlgo_VFIFunctor;
//
typedef BOPCol_TBBContextCnt
<BOPAlgo_VFIFunctor,
BOPAlgo_VectorOfVFI,
- Handle_BOPInt_Context> BOPAlgo_VFICnt;
+ Handle(BOPInt_Context)> BOPAlgo_VFICnt;
//
//=======================================================================
//function : FillImagesFaces
typedef BOPCol_TBBContextFunctor
<BOPAlgo_VertexEdge,
BOPAlgo_VectorOfVertexEdge,
- Handle_BOPInt_Context,
+ Handle(BOPInt_Context),
BOPInt_Context> BOPAlgo_VertexEdgeFunctor;
//
typedef BOPCol_TBBContextCnt
<BOPAlgo_VertexEdgeFunctor,
BOPAlgo_VectorOfVertexEdge,
- Handle_BOPInt_Context> BOPAlgo_VertexEdgeCnt;
+ Handle(BOPInt_Context)> BOPAlgo_VertexEdgeCnt;
//
//=======================================================================
// function: PerformVE
myDS->AddInterf(nV, nE);
// 3
BOPDS_ListOfPaveBlock& aLPB=myDS->ChangePaveBlocks(nE);
- Handle(BOPDS_PaveBlock)& aPB=*((Handle_BOPDS_PaveBlock*)&aLPB.First());
+ Handle(BOPDS_PaveBlock)& aPB=*((Handle(BOPDS_PaveBlock)*)&aLPB.First());
//
aPave.SetIndex(nVx);
aPave.SetParameter(aT);
typedef BOPCol_TBBContextFunctor
<BOPAlgo_PVE,
BOPAlgo_VectorOfPVE,
- Handle_BOPInt_Context,
+ Handle(BOPInt_Context),
BOPInt_Context> BOPAlgo_PVEFunctor;
//
typedef BOPCol_TBBContextCnt
<BOPAlgo_PVEFunctor,
BOPAlgo_VectorOfPVE,
- Handle_BOPInt_Context> BOPAlgo_PVECnt;
+ Handle(BOPInt_Context)> BOPAlgo_PVECnt;
/////////////////////////////////////////////////////////////////////////
//=======================================================================
// function: PerformEE
typedef BOPCol_TBBContextFunctor
<BOPAlgo_VertexFace,
BOPAlgo_VectorOfVertexFace,
- Handle_BOPInt_Context,
+ Handle(BOPInt_Context),
BOPInt_Context> BOPAlgo_VertexFaceFunctor;
//
typedef BOPCol_TBBContextCnt
<BOPAlgo_VertexFaceFunctor,
BOPAlgo_VectorOfVertexFace,
- Handle_BOPInt_Context> BOPAlgo_VertexFaceCnt;
+ Handle(BOPInt_Context)> BOPAlgo_VertexFaceCnt;
//
//=======================================================================
// function: PerformVF
typedef BOPCol_TBBContextFunctor
<BOPAlgo_EdgeFace,
BOPAlgo_VectorOfEdgeFace,
- Handle_BOPInt_Context,
+ Handle(BOPInt_Context),
BOPInt_Context> BOPAlgo_EdgeFaceFunctor;
//
typedef BOPCol_TBBContextCnt
<BOPAlgo_EdgeFaceFunctor,
BOPAlgo_VectorOfEdgeFace,
- Handle_BOPInt_Context> BOPAlgo_EdgeFaceCnt;
+ Handle(BOPInt_Context)> BOPAlgo_EdgeFaceCnt;
//
//=======================================================================
//function : PerformEF
typedef BOPCol_TBBContextFunctor
<BOPAlgo_ShrunkRange,
BOPAlgo_VectorOfShrunkRange,
- Handle_BOPInt_Context,
+ Handle(BOPInt_Context),
BOPInt_Context> BOPAlgo_ShrunkRangeFunctor;
//
typedef BOPCol_TBBContextCnt
<BOPAlgo_ShrunkRangeFunctor,
BOPAlgo_VectorOfShrunkRange,
- Handle_BOPInt_Context> BOPAlgo_ShrunkRangeCnt;
+ Handle(BOPInt_Context)> BOPAlgo_ShrunkRangeCnt;
//
//=======================================================================
// function: FillShrunkData
#include <NCollection_BaseAllocator.hxx>
-typedef Handle_NCollection_BaseAllocator BOPCol_BaseAllocator;
+typedef Handle(NCollection_BaseAllocator) BOPCol_BaseAllocator;
#endif
{
public:
BOPCol_NCVector(const Standard_Integer theIncrement=256,
- const Handle_NCollection_BaseAllocator& theAlloc = NULL)
+ const Handle(NCollection_BaseAllocator)& theAlloc = NULL)
: NCollection_Vector<Type>(theIncrement, theAlloc) {
};
//
//=======================================================================
inline Handle(BOPDS_PaveBlock)& BOPDS_Curve::ChangePaveBlock1()
{
- Handle_BOPDS_PaveBlock* pPB=(Handle_BOPDS_PaveBlock*)&myPaveBlocks.First();
+ Handle(BOPDS_PaveBlock)* pPB=(Handle(BOPDS_PaveBlock)*)&myPaveBlocks.First();
return *pPB;
}
//=======================================================================
//=======================================================================
Standard_Boolean BRep_CurveOn2Surfaces::IsRegularity
- (const Handle_Geom_Surface& S1,
- const Handle_Geom_Surface& S2,
+ (const Handle(Geom_Surface)& S1,
+ const Handle(Geom_Surface)& S2,
const TopLoc_Location& L1,
const TopLoc_Location& L2)const
{
//=======================================================================
Standard_Boolean BRep_CurveRepresentation::IsPolygonOnTriangulation
- (const Handle_Poly_Triangulation&, const TopLoc_Location&) const
+ (const Handle(Poly_Triangulation)&, const TopLoc_Location&) const
{
return Standard_False;
}
//=======================================================================
Standard_Boolean BRep_CurveRepresentation::IsPolygonOnSurface
- (const Handle_Geom_Surface&,
+ (const Handle(Geom_Surface)&,
const TopLoc_Location&) const
{
return Standard_False;
}
else {
Handle(Adaptor3d_HCurveOnSurface) sav = myConSurf;
- *((Handle_Adaptor3d_HCurveOnSurface*) (void*) &myConSurf) =
+ *((Handle(Adaptor3d_HCurveOnSurface)*) (void*) &myConSurf) =
Handle(Adaptor3d_HCurveOnSurface)::DownCast(myConSurf->Trim(First,Last,Tol));
res->ChangeCurve() = *this;
- *((Handle_Adaptor3d_HCurveOnSurface*) (void*) &myConSurf) = sav;
+ *((Handle(Adaptor3d_HCurveOnSurface)*) (void*) &myConSurf) = sav;
}
return res;
}
}
-inline Handle_Adaptor3d_HSurface BRepApprox_SurfaceTool::UTrim(const BRepAdaptor_Surface& Surf,
+inline Handle(Adaptor3d_HSurface) BRepApprox_SurfaceTool::UTrim(const BRepAdaptor_Surface& Surf,
const Standard_Real F,
const Standard_Real L,
const Standard_Real Tol) {
return Surf.UTrim(F,L,Tol);
}
-inline Handle_Adaptor3d_HSurface BRepApprox_SurfaceTool::VTrim(const BRepAdaptor_Surface& Surf,
+inline Handle(Adaptor3d_HSurface) BRepApprox_SurfaceTool::VTrim(const BRepAdaptor_Surface& Surf,
const Standard_Real F,
const Standard_Real L,
const Standard_Real Tol) {
}
-inline const Handle_Adaptor3d_HVertex& BRepBlend_Extremity::Vertex () const
+inline const Handle(Adaptor3d_HVertex)& BRepBlend_Extremity::Vertex () const
{
if (!isvtx) {Standard_DomainError::Raise();}
return vtx;
#include <Standard_DomainError.hxx>
-inline const Handle_Adaptor2d_HCurve2d& BRepBlend_PointOnRst::Arc () const
+inline const Handle(Adaptor2d_HCurve2d)& BRepBlend_PointOnRst::Arc () const
{
return arc;
}
private:
Extrema_ExtCC myExtCC;
- Handle_BRepAdaptor_HCurve myHC;
+ Handle(BRepAdaptor_HCurve) myHC;
};
#endif
TColStd_SequenceOfReal mySqDist;
Extrema_SequenceOfPOnSurf myPointsOnS;
Extrema_SequenceOfPOnCurv myPointsOnC;
- Handle_BRepAdaptor_HSurface myHS;
+ Handle(BRepAdaptor_HSurface) myHS;
};
#endif
TColStd_SequenceOfReal mySqDist;
Extrema_SequenceOfPOnSurf myPointsOnS1;
Extrema_SequenceOfPOnSurf myPointsOnS2;
- Handle_BRepAdaptor_HSurface myHS;
+ Handle(BRepAdaptor_HSurface) myHS;
};
#endif
private:
Extrema_ExtPC myExtPC;
- Handle_BRepAdaptor_HCurve myHC;
+ Handle(BRepAdaptor_HCurve) myHC;
};
#endif
//=======================================================================
-//function : Handle_Geom_Curve&
+//function : Handle(Geom_Curve)&
//purpose :
//=======================================================================
//=======================================================================
-//function : Handle_Geom2d_Curve&
+//function : Handle(Geom2d_Curve)&
//purpose :
//=======================================================================
//=======================================================================
-//function : Handle_Geom2d_Curve&
+//function : Handle(Geom2d_Curve)&
//purpose :
//=======================================================================
#include <NCollection_IncAllocator.hxx>
-typedef Handle_NCollection_IncAllocator BRepMesh_BaseAllocator;
+typedef Handle(NCollection_IncAllocator) BRepMesh_BaseAllocator;
Handle (Geom_Surface) S = BRep_Tool::Surface(F,L);
if (S->IsInstance(STANDARD_TYPE(Geom_RectangularTrimmedSurface))) {
- S = (*(Handle_Geom_RectangularTrimmedSurface*)&S)->BasisSurface();
+ S = (*(Handle(Geom_RectangularTrimmedSurface)*)&S)->BasisSurface();
}
//---------------
// Recadre en U.
Standard_Boolean vmindegen = isVminDegen, vmaxdegen = isVmaxDegen;
Handle(Geom_Surface) theSurf = S;
if (S->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface))
- theSurf = (*(Handle_Geom_RectangularTrimmedSurface*)&S)->BasisSurface();
+ theSurf = (*(Handle(Geom_RectangularTrimmedSurface)*)&S)->BasisSurface();
if (theSurf->DynamicType() == STANDARD_TYPE(Geom_ConicalSurface))
{
Handle(Geom_ConicalSurface) ConicalS = *((Handle(Geom_ConicalSurface)*) &theSurf);
//Special treatment for conical surfaces
Handle(Geom_Surface) theSurf = S;
if (S->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface))
- theSurf = (*(Handle_Geom_RectangularTrimmedSurface*)&S)->BasisSurface();
+ theSurf = (*(Handle(Geom_RectangularTrimmedSurface)*)&S)->BasisSurface();
if (theSurf->DynamicType() == STANDARD_TYPE(Geom_ConicalSurface))
{
Handle(Geom_ConicalSurface) ConicalS = *((Handle(Geom_ConicalSurface)*) &theSurf);
Draw_Color Couleur;
if (type == STANDARD_TYPE(Geom2d_TrimmedCurve)) {
- curve = (*(Handle_Geom2d_TrimmedCurve*)&aCurve)->BasisCurve();
+ curve = (*(Handle(Geom2d_TrimmedCurve)*)&aCurve)->BasisCurve();
type = curve->DynamicType();
if (type == STANDARD_TYPE(Bisector_BisecAna)) {
- curve =(*(Handle_Bisector_BisecAna*)&curve)->Geom2dCurve();
+ curve =(*(Handle(Bisector_BisecAna)*)&curve)->Geom2dCurve();
type = curve->DynamicType();
}
// PB of representation of semi_infinite curves.
myloaded=Standard_True;
}
-Handle_BRepTopAdaptor_TopolTool BRepTopAdaptor_Tool::GetTopolTool() {
+Handle(BRepTopAdaptor_TopolTool) BRepTopAdaptor_Tool::GetTopolTool() {
if(myloaded) {
return(myTopolTool);
}
else {
- cout<<"\n*** Error ds Handle_BRepTopAdaptor_TopolTool BRepTopAdaptor_Tool::GetTopolTool()\n"<<endl;
+ cout<<"\n*** Error ds Handle(BRepTopAdaptor_TopolTool) BRepTopAdaptor_Tool::GetTopolTool()\n"<<endl;
return(myTopolTool);
}
}
-Handle_Adaptor3d_HSurface BRepTopAdaptor_Tool::GetSurface() {
+Handle(Adaptor3d_HSurface) BRepTopAdaptor_Tool::GetSurface() {
if(myloaded) {
return(myHSurface);
}
else {
- cout<<"\n*** Error ds Handle_BRepTopAdaptor_TopolTool BRepTopAdaptor_Tool::GetSurface()\n"<<endl;
+ cout<<"\n*** Error ds Handle(BRepTopAdaptor_TopolTool) BRepTopAdaptor_Tool::GetSurface()\n"<<endl;
return(myHSurface);
}
}
void BinLDrivers_DocumentStorageDriver::WriteSection
(const TCollection_AsciiString& /*theName*/,
- const Handle_CDM_Document& /*theDocument*/,
+ const Handle(CDM_Document)& /*theDocument*/,
Standard_OStream& /*theOS*/)
{
// empty; should be redefined in subclasses
Handle(Standard_Type) type = afirstcurve->DynamicType();
if (type == STANDARD_TYPE(Geom2d_TrimmedCurve)) {
- curve = (*(Handle_Geom2d_TrimmedCurve*)&afirstcurve)->BasisCurve();
+ curve = (*(Handle(Geom2d_TrimmedCurve)*)&afirstcurve)->BasisCurve();
}
else {
curve = afirstcurve;
//function : Init
// purpose :
//=============================================================================
-void Bisector_BisecPC::Init (const Handle_Geom2d_Curve& Curve,
+void Bisector_BisecPC::Init (const Handle(Geom2d_Curve)& Curve,
const gp_Pnt2d& Point,
const Standard_Real Sign,
const TColStd_SequenceOfReal& StartIntervals,
//purpose :
//=======================================================================
-void Bnd_BoundSortBox2d::Initialize(const Handle_Bnd_HArray1OfBox2d& SetOfBox)
+void Bnd_BoundSortBox2d::Initialize(const Handle(Bnd_HArray1OfBox2d)& SetOfBox)
{
myBndComponents=SetOfBox;
discrX=SetOfBox->Length();
bs.Update(umin,vmin,umax,vmax);
Standard_Boolean aIN = Standard_True;
for(Standard_Integer ii = 1; ii <= 4 && aIN; ii++) {
- if(bs.IsOut((*((Handle_Geom2d_BezierCurve*) &Pcurv))->Pole(ii))) {
+ if(bs.IsOut((*((Handle(Geom2d_BezierCurve)*) &Pcurv))->Pole(ii))) {
aIN = Standard_False;
TColgp_Array1OfPnt2d qoles(1,2);
qoles(1)=UV1;
//=======================================================================
-//function : Handle_Geom2d_Curve&
+//function : Handle(Geom2d_Curve)&
//purpose :
//=======================================================================
Standard_Boolean ChFiKPart_ComputeData::Compute
(TopOpeBRepDS_DataStructure& DStr,
Handle(ChFiDS_SurfData)& Data,
- const Handle_Adaptor3d_HSurface& S1,
- const Handle_Adaptor3d_HSurface& S2,
+ const Handle(Adaptor3d_HSurface)& S1,
+ const Handle(Adaptor3d_HSurface)& S2,
const TopAbs_Orientation Or1,
const TopAbs_Orientation Or2,
const Handle(ChFiDS_Spine)& Sp,
return;
}
- const Handle_Adaptor2d_HCurve2d& thearc = Line.Arc();
+ const Handle(Adaptor2d_HCurve2d)& thearc = Line.Arc();
const Handle(Adaptor3d_HSurface)& Surf = SFunc.Surface();
Contap_TFunction TypeFunc(SFunc.FunctionType());
break;
case GeomAbs_BSplineSurface:
{
- //-- Handle_Geom_BSplineSurface& HBS=S->BSpline();
+ //-- Handle(Geom_BSplineSurface)& HBS=S->BSpline();
nbs = S->NbVKnots();
nbs*= S->VDegree();
if(nbs < 2) nbs=2;
break;
case GeomAbs_BSplineSurface:
{
- //-- Handle_Geom_BSplineSurface& HBS=S->BSpline();
+ //-- Handle(Geom_BSplineSurface)& HBS=S->BSpline();
nbs = S->NbUKnots();
nbs*= S->UDegree();
if(nbs < 2) nbs=2;
nbsOnC = A->NbPoles();
break;
case GeomAbs_BSplineCurve: {
- //-- Handle_Geom2d_BSplineCurve& BSC=A->BSpline();
+ //-- Handle(Geom2d_BSplineCurve)& BSC=A->BSpline();
nbsOnC = 2 + A->NbKnots() * A->Degree();
break;
}
return onarc;
}
-inline const Handle_Adaptor2d_HCurve2d& Contap_Point::Arc () const {
+inline const Handle(Adaptor2d_HCurve2d)& Contap_Point::Arc () const {
if (!onarc) {Standard_DomainError::Raise();}
return arc;
return isvtx;
}
-inline const Handle_Adaptor3d_HVertex& Contap_Point::Vertex () const {
+inline const Handle(Adaptor3d_HVertex)& Contap_Point::Vertex () const {
if (!isvtx) {Standard_DomainError::Raise();}
return vtx;
return d2d;
}
-inline const Handle_Adaptor3d_HSurface& Contap_SurfFunction::Surface() const
+inline const Handle(Adaptor3d_HSurface)& Contap_SurfFunction::Surface() const
{
return mySurf;
}
const Standard_Integer Continuity,
const Standard_Integer Dimension,
const Standard_Integer MaxDegree,
- const Handle_TColStd_HArray1OfInteger& NumCoeffPerCurve,
- const Handle_TColStd_HArray1OfReal& Coefficients,
- const Handle_TColStd_HArray2OfReal& PolynomialIntervals,
- const Handle_TColStd_HArray1OfReal& TrueIntervals)
+ const Handle(TColStd_HArray1OfInteger)& NumCoeffPerCurve,
+ const Handle(TColStd_HArray1OfReal)& Coefficients,
+ const Handle(TColStd_HArray2OfReal)& PolynomialIntervals,
+ const Handle(TColStd_HArray1OfReal)& TrueIntervals)
: myDone(Standard_False)
{
Standard_Integer ii, delta;
//=======================================================================
void Convert_CompPolynomialToPoles::Poles(
- Handle_TColStd_HArray2OfReal& P) const
+ Handle(TColStd_HArray2OfReal)& P) const
{ if (myDone) {
P = myPoles ; }
}
//=======================================================================
void Convert_CompPolynomialToPoles::Knots(
- Handle_TColStd_HArray1OfReal& K) const
+ Handle(TColStd_HArray1OfReal)& K) const
{ if (myDone) {
K = myKnots ; }
}
//=======================================================================
void Convert_CompPolynomialToPoles::Multiplicities(
- Handle_TColStd_HArray1OfInteger& M) const
+ Handle(TColStd_HArray1OfInteger)& M) const
{ if (myDone) {
M = myMults ; }
}
// should be d_Varray for 4.6
// Use an Collection of StandardDB_O2Handle
// for none primitive type to avoid to import
-// Handle_Standard_Persistent.
+// Handle(Standard_Persistent).
// --------------------------------------------------------------------
// Last revision : January 1996 JMS/CLE
// portage OBJY 3.8
#ifdef CSFDB
#include <PStandard_ArrayNode.hxx>
-//typedef Handle_PStandard_ArrayNode* DBC_DBVArray;
+//typedef Handle(PStandard_ArrayNode)* DBC_DBVArray;
typedef void* DBC_DBVArray;
#endif
}
//=======================================================================
-//function : Handle_Geom2d_Curve&
+//function : Handle(Geom2d_Curve)&
//purpose :
//=======================================================================
//=======================================================================
-//function : Handle_Geom2d_Curve&
+//function : Handle(Geom2d_Curve)&
//purpose :
//=======================================================================
Handle(Dynamic_CompiledMethod) method_1 = Handle(Dynamic_CompiledMethod)::DownCast(method);
typedef void (*function)(const Handle(Dynamic_DynamicInstance)&);
-// ((function)((*(Handle_Dynamic_CompiledMethod*)&method)->Function().ToCString()))(me);
+// ((function)((*(Handle(Dynamic_CompiledMethod)*)&method)->Function().ToCString()))(me);
((function)(method_1->Function().ToCString()))(me);
}
else
/* Standard_Integer argc = 2;
char* argv[2];
argv[0] = "source";
- argv[1] = (*(Handle_Dynamic_InterpretedMethod*)&method)->Function();
+ argv[1] = (*(Handle(Dynamic_InterpretedMethod)*)&method)->Function();
source(argc,argv);*/
}
}
parameter = parameternode->Object();
if(parameter->Name() == aparameter)
{
- avalue = (*(Handle_Dynamic_BooleanParameter*)¶meter)->Value();
+ avalue = (*(Handle(Dynamic_BooleanParameter)*)¶meter)->Value();
return Standard_True;
}
parameternode = parameternode->Next();
parameter = parameternode->Object();
if(parameter->Name() == aparameter)
{
- avalue = (*(Handle_Dynamic_IntegerParameter*)¶meter)->Value();
+ avalue = (*(Handle(Dynamic_IntegerParameter)*)¶meter)->Value();
return Standard_True;
}
parameternode = parameternode->Next();
parameter = parameternode->Object();
if(parameter->Name() == aparameter)
{
- avalue = (*(Handle_Dynamic_RealParameter*)¶meter)->Value();
+ avalue = (*(Handle(Dynamic_RealParameter)*)¶meter)->Value();
return Standard_True;
}
parameternode = parameternode->Next();
parameter = parameternode->Object();
if(parameter->Name() == aparameter)
{
- avalue = (*(Handle_Dynamic_StringParameter*)¶meter)->Value();
+ avalue = (*(Handle(Dynamic_StringParameter)*)¶meter)->Value();
return Standard_True;
}
parameternode = parameternode->Next();
parameter = parameternode->Object();
if(parameter->Name() == aparameter)
{
- anobject = (*(Handle_Dynamic_ObjectParameter*)¶meter)->Value();
+ anobject = (*(Handle(Dynamic_ObjectParameter)*)¶meter)->Value();
return Standard_True;
}
parameternode = parameternode->Next();
}
else
{
- definition = *(Handle_Dynamic_FuzzyInstance*)&thedefinition;
+ definition = *(Handle(Dynamic_FuzzyInstance)*)&thedefinition;
return definition->Definition();
}
}
Handle(Dynamic_MethodDefinition) methoddefinition;
if(adefinition->IsKind(STANDARD_TYPE(Dynamic_MethodDefinition)))
{
- methoddefinition = *(Handle_Dynamic_MethodDefinition*)&adefinition;
+ methoddefinition = *(Handle(Dynamic_MethodDefinition)*)&adefinition;
thesequenceofmethoddefinitions->Append(methoddefinition);
return Standard_True;
}
Standard_OutOfRange::Raise();
}
}
- return *( ( Handle_Expr_GeneralExpression* )NULL );
+ return *( ( Handle(Expr_GeneralExpression)* )NULL );
}
Standard_Boolean Expr_BinaryExpression::ContainsUnknowns () const
Standard_Integer theDegree,
Standard_Real theParMin,
Standard_Real theParMax,
- Handle_TColStd_HArray1OfReal& theParams,
+ Handle(TColStd_HArray1OfReal)& theParams,
Standard_Integer theSample)
{
NCollection_Vector<Standard_Real> aParams;
return Standard_True;
}
-void FilletSurf_InternalBuilder::PerformSurf(ChFiDS_SequenceOfSurfData&, const Handle_ChFiDS_HElSpine&, const Handle_ChFiDS_Spine&, const int, const Handle_BRepAdaptor_HSurface&, const Handle_Adaptor3d_TopolTool&, const Handle_BRepAdaptor_HCurve2d&, const Handle_BRepAdaptor_HSurface&, const Handle_BRepAdaptor_HCurve2d&, unsigned int&, const Handle_BRepAdaptor_HSurface&, const Handle_Adaptor3d_TopolTool&, const TopAbs_Orientation, const double, const double, const double, double&, double&, const unsigned int, const unsigned int, const unsigned int, const unsigned int, const unsigned int, const unsigned int, const math_Vector&)
+void FilletSurf_InternalBuilder::PerformSurf(ChFiDS_SequenceOfSurfData&, const Handle(ChFiDS_HElSpine)&, const Handle(ChFiDS_Spine)&, const int, const Handle(BRepAdaptor_HSurface)&, const Handle(Adaptor3d_TopolTool)&, const Handle(BRepAdaptor_HCurve2d)&, const Handle(BRepAdaptor_HSurface)&, const Handle(BRepAdaptor_HCurve2d)&, unsigned int&, const Handle(BRepAdaptor_HSurface)&, const Handle(Adaptor3d_TopolTool)&, const TopAbs_Orientation, const double, const double, const double, double&, double&, const unsigned int, const unsigned int, const unsigned int, const unsigned int, const unsigned int, const unsigned int, const math_Vector&)
{
Standard_DomainError::Raise("BlendFunc_CSConstRad::Section : Not implemented");
}
-void FilletSurf_InternalBuilder::PerformSurf(ChFiDS_SequenceOfSurfData&, const Handle_ChFiDS_HElSpine&, const Handle_ChFiDS_Spine&, const int, const Handle_BRepAdaptor_HSurface&, const Handle_Adaptor3d_TopolTool&, const Handle_BRepAdaptor_HCurve2d&, const Handle_BRepAdaptor_HSurface&, const Handle_BRepAdaptor_HCurve2d&, unsigned int&, const TopAbs_Orientation, const Handle_BRepAdaptor_HSurface&, const Handle_Adaptor3d_TopolTool&, const Handle_BRepAdaptor_HCurve2d&, const Handle_BRepAdaptor_HSurface&, const Handle_BRepAdaptor_HCurve2d&, unsigned int&, const TopAbs_Orientation, const double, const double, const double, double&, double&, const unsigned int, const unsigned int, const unsigned int, const unsigned int, const unsigned int, const unsigned int, const unsigned int, const math_Vector&)
+void FilletSurf_InternalBuilder::PerformSurf(ChFiDS_SequenceOfSurfData&, const Handle(ChFiDS_HElSpine)&, const Handle(ChFiDS_Spine)&, const int, const Handle(BRepAdaptor_HSurface)&, const Handle(Adaptor3d_TopolTool)&, const Handle(BRepAdaptor_HCurve2d)&, const Handle(BRepAdaptor_HSurface)&, const Handle(BRepAdaptor_HCurve2d)&, unsigned int&, const TopAbs_Orientation, const Handle(BRepAdaptor_HSurface)&, const Handle(Adaptor3d_TopolTool)&, const Handle(BRepAdaptor_HCurve2d)&, const Handle(BRepAdaptor_HSurface)&, const Handle(BRepAdaptor_HCurve2d)&, unsigned int&, const TopAbs_Orientation, const double, const double, const double, double&, double&, const unsigned int, const unsigned int, const unsigned int, const unsigned int, const unsigned int, const unsigned int, const unsigned int, const math_Vector&)
{
Standard_DomainError::Raise("BlendFunc_CSConstRad::Section : Not implemented");
}
-void FilletSurf_InternalBuilder::PerformSurf(ChFiDS_SequenceOfSurfData&, const Handle_ChFiDS_HElSpine&, const Handle_ChFiDS_Spine&, const int, const Handle_BRepAdaptor_HSurface&, const Handle_Adaptor3d_TopolTool&, const TopAbs_Orientation, const Handle_BRepAdaptor_HSurface&, const Handle_Adaptor3d_TopolTool&, const Handle_BRepAdaptor_HCurve2d&, const Handle_BRepAdaptor_HSurface&, const Handle_BRepAdaptor_HCurve2d&, unsigned int&, const double, const double, const double, double&, double&, const unsigned int, const unsigned int, const unsigned int, const unsigned int, const unsigned int, const unsigned int, const math_Vector&)
+void FilletSurf_InternalBuilder::PerformSurf(ChFiDS_SequenceOfSurfData&, const Handle(ChFiDS_HElSpine)&, const Handle(ChFiDS_Spine)&, const int, const Handle(BRepAdaptor_HSurface)&, const Handle(Adaptor3d_TopolTool)&, const TopAbs_Orientation, const Handle(BRepAdaptor_HSurface)&, const Handle(Adaptor3d_TopolTool)&, const Handle(BRepAdaptor_HCurve2d)&, const Handle(BRepAdaptor_HSurface)&, const Handle(BRepAdaptor_HCurve2d)&, unsigned int&, const double, const double, const double, double&, double&, const unsigned int, const unsigned int, const unsigned int, const unsigned int, const unsigned int, const unsigned int, const math_Vector&)
{
Standard_DomainError::Raise("BlendFunc_CSConstRad::Section : Not implemented");
}
//=======================================================================
static void BuildParameters(const Standard_Boolean PeriodicFlag,
const TColgp_Array1OfPnt2d& PointsArray,
- Handle_TColStd_HArray1OfReal& ParametersPtr)
+ Handle(TColStd_HArray1OfReal)& ParametersPtr)
{
Standard_Integer ii,
index ;
//=======================================================================
Geom2dAPI_Interpolate::Geom2dAPI_Interpolate
- (const Handle_TColgp_HArray1OfPnt2d& PointsPtr,
+ (const Handle(TColgp_HArray1OfPnt2d)& PointsPtr,
const Standard_Boolean PeriodicFlag,
const Standard_Real Tolerance) :
myTolerance(Tolerance),
//=======================================================================
Geom2dAPI_Interpolate::Geom2dAPI_Interpolate
- (const Handle_TColgp_HArray1OfPnt2d& PointsPtr,
- const Handle_TColStd_HArray1OfReal& ParametersPtr,
+ (const Handle(TColgp_HArray1OfPnt2d)& PointsPtr,
+ const Handle(TColStd_HArray1OfReal)& ParametersPtr,
const Standard_Boolean PeriodicFlag,
const Standard_Real Tolerance) :
myTolerance(Tolerance),
void Geom2dAPI_Interpolate::Load(
const TColgp_Array1OfVec2d& Tangents,
- const Handle_TColStd_HArray1OfBoolean& TangentFlagsPtr)
+ const Handle(TColStd_HArray1OfBoolean)& TangentFlagsPtr)
{
Standard_Boolean result ;
}
}
//=======================================================================
-//function : Handle_Geom2d_BSplineCurve&
+//function : Handle(Geom2d_BSplineCurve)&
//purpose :
//=======================================================================
}
//=======================================================================
-//function : Handle_Geom2d_BSplineCurve&
+//function : Handle(Geom2d_BSplineCurve)&
//purpose :
//=======================================================================
#include <Geom2d_Curve.hxx>
#include <GeomAbs_Shape.hxx>
-void Geom2dLProp_Curve2dTool::Value(const Handle_Geom2d_Curve& C,
+void Geom2dLProp_Curve2dTool::Value(const Handle(Geom2d_Curve)& C,
const Standard_Real U, gp_Pnt2d& P)
{
P = C->Value(U);
}
-void Geom2dLProp_Curve2dTool::D1(const Handle_Geom2d_Curve& C,
+void Geom2dLProp_Curve2dTool::D1(const Handle(Geom2d_Curve)& C,
const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1)
{
C->D1(U, P, V1);
}
-void Geom2dLProp_Curve2dTool::D2(const Handle_Geom2d_Curve& C,
+void Geom2dLProp_Curve2dTool::D2(const Handle(Geom2d_Curve)& C,
const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2)
{
C->D2(U, P, V1, V2);
}
-void Geom2dLProp_Curve2dTool::D3(const Handle_Geom2d_Curve& C,
+void Geom2dLProp_Curve2dTool::D3(const Handle(Geom2d_Curve)& C,
const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V3)
{
C->D3(U, P, V1, V2, V3);
}
-Standard_Integer Geom2dLProp_Curve2dTool::Continuity(const Handle_Geom2d_Curve& C)
+Standard_Integer Geom2dLProp_Curve2dTool::Continuity(const Handle(Geom2d_Curve)& C)
{
GeomAbs_Shape s = C->Continuity();
switch (s) {
return 0;
}
-Standard_Real Geom2dLProp_Curve2dTool::FirstParameter(const Handle_Geom2d_Curve& C)
+Standard_Real Geom2dLProp_Curve2dTool::FirstParameter(const Handle(Geom2d_Curve)& C)
{
return C->FirstParameter();
}
-Standard_Real Geom2dLProp_Curve2dTool::LastParameter(const Handle_Geom2d_Curve& C)
+Standard_Real Geom2dLProp_Curve2dTool::LastParameter(const Handle(Geom2d_Curve)& C)
{
return C->LastParameter();
}
//=======================================================================
static void BuildParameters(const Standard_Boolean PeriodicFlag,
const TColgp_Array1OfPnt& PointsArray,
- Handle_TColStd_HArray1OfReal& ParametersPtr)
+ Handle(TColStd_HArray1OfReal)& ParametersPtr)
{
Standard_Integer ii,
index ;
//=======================================================================
GeomAPI_Interpolate::GeomAPI_Interpolate
- (const Handle_TColgp_HArray1OfPnt& PointsPtr,
+ (const Handle(TColgp_HArray1OfPnt)& PointsPtr,
const Standard_Boolean PeriodicFlag,
const Standard_Real Tolerance) :
myTolerance(Tolerance),
//=======================================================================
GeomAPI_Interpolate::GeomAPI_Interpolate
- (const Handle_TColgp_HArray1OfPnt& PointsPtr,
- const Handle_TColStd_HArray1OfReal& ParametersPtr,
+ (const Handle(TColgp_HArray1OfPnt)& PointsPtr,
+ const Handle(TColStd_HArray1OfReal)& ParametersPtr,
const Standard_Boolean PeriodicFlag,
const Standard_Real Tolerance) :
myTolerance(Tolerance),
void GeomAPI_Interpolate::Load(
const TColgp_Array1OfVec& Tangents,
- const Handle_TColStd_HArray1OfBoolean& TangentFlagsPtr,
+ const Handle(TColStd_HArray1OfBoolean)& TangentFlagsPtr,
const Standard_Boolean Scale )
{
}
}
//=======================================================================
-//function : Handle_Geom_BSplineCurve&
+//function : Handle(Geom_BSplineCurve)&
//purpose :
//=======================================================================
//=======================================================================
-//function : Handle_Geom_BSplineCurve&
+//function : Handle(Geom_BSplineCurve)&
//purpose :
//=======================================================================
//=======================================================================
-//function : Handle_Geom_BSplineSurface&
+//function : Handle(Geom_BSplineSurface)&
//purpose :
//=======================================================================
HasDF,HasDL,DF,DL,
Rev,30);
myPar = new Law_BSpFunc();
- (*((Handle_Law_BSpFunc*) &myPar))->SetCurve(curve);
+ (*((Handle(Law_BSpFunc)*) &myPar))->SetCurve(curve);
}
//=======================================================================
if(!CheckTgte(i)) {
Handle(Law_Function) fu1,fu2;
ptch->Func(fu1,fu2);
- fu1 = Law::MixBnd(*((Handle_Law_Linear*) &fu1));
- fu2 = Law::MixBnd(*((Handle_Law_Linear*) &fu2));
+ fu1 = Law::MixBnd(*((Handle(Law_Linear)*) &fu1));
+ fu2 = Law::MixBnd(*((Handle(Law_Linear)*) &fu2));
ptch->Func(fu1,fu2);
break;
}
if(!CheckTgte(i)) {
Handle(Law_Function) fu1,fu2;
ptch->Func(fu1,fu2);
- Handle(Law_Function) ffu1 = Law::MixBnd(*((Handle_Law_Linear*) &fu1));
- Handle(Law_Function) ffu2 = Law::MixBnd(*((Handle_Law_Linear*) &fu2));
+ Handle(Law_Function) ffu1 = Law::MixBnd(*((Handle(Law_Linear)*) &fu1));
+ Handle(Law_Function) ffu2 = Law::MixBnd(*((Handle(Law_Linear)*) &fu2));
ptch->SetFunc(ffu1,ffu2);
break;
}
Standard_Real deb0, deb1, fin0, fin1;
B2->Bounds(deb1,fin1);
a[0] = new Law_Linear();
- (*((Handle_Law_Linear*) &a[0]))->Set(deb1,1.,fin1,0.);
+ (*((Handle(Law_Linear)*) &a[0]))->Set(deb1,1.,fin1,0.);
B1->Bounds(deb0,fin0);
a[1] = new Law_Linear();
- (*((Handle_Law_Linear*) &a[1]))->Set(deb0,0.,fin0,1.);
+ (*((Handle(Law_Linear)*) &a[1]))->Set(deb0,0.,fin0,1.);
gp_XYZ temp;
temp = B4->Value(deb1).XYZ().Added(B1->Value(deb0).XYZ());
#endif
// fonction d'evaluation des poles et des poids de mySurface pour D1 et D2
-static void ResultEval(const Handle_Geom_BSplineSurface& surf,
+static void ResultEval(const Handle(Geom_BSplineSurface)& surf,
const Standard_Real V,
const Standard_Integer deriv,
TColStd_Array1OfReal& Result)
//purpose :
//=======================================================================
-void GeomFill_SectionGenerator::SetParam(const Handle_TColStd_HArray1OfReal & Params)
+void GeomFill_SectionGenerator::SetParam(const Handle(TColStd_HArray1OfReal) & Params)
{
Standard_Integer ii, L = Params->Upper()-Params->Lower()+1;
myParams = Params;
HasDF,HasDL,DF,DL,
Rev,30);
myPar = new Law_BSpFunc();
- (*((Handle_Law_BSpFunc*) &myPar))->SetCurve(curve);
+ (*((Handle(Law_BSpFunc)*) &myPar))->SetCurve(curve);
}
//=======================================================================
#include <Geom_Curve.hxx>
#include <GeomAbs_Shape.hxx>
-void GeomLProp_CurveTool::Value(const Handle_Geom_Curve& C,
+void GeomLProp_CurveTool::Value(const Handle(Geom_Curve)& C,
const Standard_Real U, gp_Pnt& P)
{
P = C->Value(U);
}
-void GeomLProp_CurveTool::D1(const Handle_Geom_Curve& C,
+void GeomLProp_CurveTool::D1(const Handle(Geom_Curve)& C,
const Standard_Real U, gp_Pnt& P, gp_Vec& V1)
{
C->D1(U, P, V1);
}
-void GeomLProp_CurveTool::D2(const Handle_Geom_Curve& C,
+void GeomLProp_CurveTool::D2(const Handle(Geom_Curve)& C,
const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2)
{
C->D2(U, P, V1, V2);
}
-void GeomLProp_CurveTool::D3(const Handle_Geom_Curve& C,
+void GeomLProp_CurveTool::D3(const Handle(Geom_Curve)& C,
const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2, gp_Vec& V3)
{
C->D3(U, P, V1, V2, V3);
}
-Standard_Integer GeomLProp_CurveTool::Continuity(const Handle_Geom_Curve& C)
+Standard_Integer GeomLProp_CurveTool::Continuity(const Handle(Geom_Curve)& C)
{
GeomAbs_Shape s = C->Continuity();
switch (s) {
return 0;
}
-Standard_Real GeomLProp_CurveTool::FirstParameter(const Handle_Geom_Curve& C)
+Standard_Real GeomLProp_CurveTool::FirstParameter(const Handle(Geom_Curve)& C)
{
return C->FirstParameter();
}
-Standard_Real GeomLProp_CurveTool::LastParameter(const Handle_Geom_Curve& C)
+Standard_Real GeomLProp_CurveTool::LastParameter(const Handle(Geom_Curve)& C)
{
return C->LastParameter();
}
#include <GeomAbs_Shape.hxx>
-void GeomLProp_SurfaceTool::Value(const Handle_Geom_Surface& S,
+void GeomLProp_SurfaceTool::Value(const Handle(Geom_Surface)& S,
const Standard_Real U, const Standard_Real V, gp_Pnt& P)
{
P = S->Value(U, V);
}
-void GeomLProp_SurfaceTool::D1(const Handle_Geom_Surface& S,
+void GeomLProp_SurfaceTool::D1(const Handle(Geom_Surface)& S,
const Standard_Real U, const Standard_Real V,
gp_Pnt& P, gp_Vec& D1U, gp_Vec& D1V)
{
S->D1(U, V, P, D1U, D1V);
}
-void GeomLProp_SurfaceTool::D2(const Handle_Geom_Surface& S,
+void GeomLProp_SurfaceTool::D2(const Handle(Geom_Surface)& S,
const Standard_Real U, const Standard_Real V,
gp_Pnt& P, gp_Vec& D1U, gp_Vec& D1V, gp_Vec& D2U, gp_Vec& D2V, gp_Vec& DUV)
{
//function : DN
//purpose :
//=======================================================================
-gp_Vec GeomLProp_SurfaceTool::DN(const Handle_Geom_Surface& S,
+gp_Vec GeomLProp_SurfaceTool::DN(const Handle(Geom_Surface)& S,
const Standard_Real U,
const Standard_Real V,
const Standard_Integer IU,
return S->DN(U, V, IU, IV);
}
-Standard_Integer GeomLProp_SurfaceTool::Continuity(const Handle_Geom_Surface& S)
+Standard_Integer GeomLProp_SurfaceTool::Continuity(const Handle(Geom_Surface)& S)
{
GeomAbs_Shape s = S->Continuity();
switch (s) {
return 0;
}
-void GeomLProp_SurfaceTool::Bounds(const Handle_Geom_Surface& S,
+void GeomLProp_SurfaceTool::Bounds(const Handle(Geom_Surface)& S,
Standard_Real& U1, Standard_Real& V1,
Standard_Real& U2, Standard_Real& V2)
{
Adaptor3d_CurveOnSurface& Curve,
const Standard_Real FirstParameter,
const Standard_Real LastParameter,
- Handle_Geom_Curve& NewCurvePtr,
+ Handle(Geom_Curve)& NewCurvePtr,
Standard_Real& MaxDeviation,
Standard_Real& AverageDeviation,
const GeomAbs_Shape Continuity,
//---------------------------------------------------------
// fonction : Surface
//---------------------------------------------------------
-Handle_GeomPlate_Surface GeomPlate_BuildPlateSurface::Surface() const
+Handle(GeomPlate_Surface) GeomPlate_BuildPlateSurface::Surface() const
{ return myGeomPlateSurface ;
}
//---------------------------------------------------------
// fonction : SurfInit
//---------------------------------------------------------
-Handle_Geom_Surface GeomPlate_BuildPlateSurface::SurfInit() const
+Handle(Geom_Surface) GeomPlate_BuildPlateSurface::SurfInit() const
{ return mySurfInit ;
}
//---------------------------------------------------------
// fonction : Sense
//---------------------------------------------------------
-Handle_TColStd_HArray1OfInteger GeomPlate_BuildPlateSurface::Sense() const
+Handle(TColStd_HArray1OfInteger) GeomPlate_BuildPlateSurface::Sense() const
{ Standard_Integer NTCurve = myLinCont->Length();
Handle(TColStd_HArray1OfInteger) Sens = new TColStd_HArray1OfInteger(1,
NTCurve);
//---------------------------------------------------------
// fonction : Curve2d
//---------------------------------------------------------
-Handle_TColGeom2d_HArray1OfCurve GeomPlate_BuildPlateSurface::Curves2d() const
+Handle(TColGeom2d_HArray1OfCurve) GeomPlate_BuildPlateSurface::Curves2d() const
{ Standard_Integer NTCurve = myLinCont->Length();
Handle(TColGeom2d_HArray1OfCurve) C2dfin =
new TColGeom2d_HArray1OfCurve(1,NTCurve);
//---------------------------------------------------------
//fonction : Order
//---------------------------------------------------------
-Handle_TColStd_HArray1OfInteger GeomPlate_BuildPlateSurface::Order() const
-{ Handle_TColStd_HArray1OfInteger result=
+Handle(TColStd_HArray1OfInteger) GeomPlate_BuildPlateSurface::Order() const
+{ Handle(TColStd_HArray1OfInteger) result=
new TColStd_HArray1OfInteger(1,myLinCont->Length());
for (Standard_Integer i=1;i<=myLinCont->Length();i++)
result->SetValue(myInitOrder->Value(i),i);
//---------------------------------------------------------
// Fonction : SetG0Criterion
//---------------------------------------------------------
-void GeomPlate_CurveConstraint :: SetG0Criterion(const Handle_Law_Function &G0Crit)
+void GeomPlate_CurveConstraint :: SetG0Criterion(const Handle(Law_Function) &G0Crit)
{ myG0Crit=G0Crit;
myConstG0=Standard_False;
}
//---------------------------------------------------------
// Fonction : SetG1Criterion
//---------------------------------------------------------
-void GeomPlate_CurveConstraint :: SetG1Criterion(const Handle_Law_Function &G1Crit)
+void GeomPlate_CurveConstraint :: SetG1Criterion(const Handle(Law_Function) &G1Crit)
{ if (!my3dCurve.IsNull())
Standard_Failure::Raise("GeomPlate_CurveConstraint.cxx : Curve must be on a Surface");
myG1Crit=G1Crit;
//---------------------------------------------------------
// Fonction : SetG2Criterion
//---------------------------------------------------------
-void GeomPlate_CurveConstraint :: SetG2Criterion(const Handle_Law_Function &G2Crit)
+void GeomPlate_CurveConstraint :: SetG2Criterion(const Handle(Law_Function) &G2Crit)
{ if (!my3dCurve.IsNull())
Standard_Failure::Raise("GeomPlate_CurveConstraint.cxx : Curve must be on a Surface");
myG2Crit=G2Crit;
char dimen[3];
iFile >> dimen;
if (!strcmp(dimen,"3d")) {
- Handle_TColgp_HArray1OfPnt Point =
+ Handle(TColgp_HArray1OfPnt) Point =
new TColgp_HArray1OfPnt(1, nbp);
for (i = 1; i <= nbp; i++) {
iFile >> x >> y >> z;
if ( n < num_parameters * 3 + num_read) {
return 1 ;
}
- Handle_TColgp_HArray1OfPnt PointsArrayPtr=
+ Handle(TColgp_HArray1OfPnt) PointsArrayPtr=
new TColgp_HArray1OfPnt(1,num_parameters) ;
num_tangents = ((n - num_read) / 3) - num_parameters ;
if (num_tangents > 0) {
TColgp_Array1OfVec TangentsArray(1,num_parameters) ;
- Handle_TColStd_HArray1OfBoolean
+ Handle(TColStd_HArray1OfBoolean)
TangentFlagsPtr =
new TColStd_HArray1OfBoolean(1,num_parameters) ;
return 1;
//test nbPoints for Geom_Ellipse
- Handle_Geom_Ellipse ellip;
+ Handle(Geom_Ellipse) ellip;
try
//purpose :
//=======================================================================
-inline Handle_Adaptor3d_HSurface
+inline Handle(Adaptor3d_HSurface)
HLRBRep_BSurfaceTool::UTrim(const BRepAdaptor_Surface& Surf,
const Standard_Real F,
const Standard_Real L,
//purpose :
//=======================================================================
-inline Handle_Adaptor3d_HSurface
+inline Handle(Adaptor3d_HSurface)
HLRBRep_BSurfaceTool::VTrim(const BRepAdaptor_Surface& Surf,
const Standard_Real F,
const Standard_Real L,
}
-inline Handle_Adaptor3d_HSurface HLRBRep_SurfaceTool::UTrim(const Standard_Address Surf,
+inline Handle(Adaptor3d_HSurface) HLRBRep_SurfaceTool::UTrim(const Standard_Address Surf,
const Standard_Real F,
const Standard_Real L,
const Standard_Real Tol) {
return ((BRepAdaptor_Surface *)Surf)->UTrim(F,L,Tol);
}
-inline Handle_Adaptor3d_HSurface HLRBRep_SurfaceTool::VTrim(const Standard_Address Surf,
+inline Handle(Adaptor3d_HSurface) HLRBRep_SurfaceTool::VTrim(const Standard_Address Surf,
const Standard_Real F,
const Standard_Real L,
const Standard_Real Tol) {
}
}
else checks = thecopier->SendAll(filename,thegraph->Graph(),thelibrary,theprotocol);
- Handle_Interface_Check aMainFail = checks.CCheck(0);
+ Handle(Interface_Check) aMainFail = checks.CCheck(0);
if (!aMainFail.IsNull() && aMainFail->HasFailed ())
{
return IFSelect_RetStop;
const Standard_Real AngDef);
static
- Standard_Boolean SameCurve(const Handle_Adaptor2d_HCurve2d& C1,
- const Handle_Adaptor2d_HCurve2d& C2);
+ Standard_Boolean SameCurve(const Handle(Adaptor2d_HCurve2d)& C1,
+ const Handle(Adaptor2d_HCurve2d)& C2);
static
void RecadreMemePeriode(Standard_Real& u1,
//function : SameCurve
//purpose :
//=======================================================================
-Standard_Boolean SameCurve(const Handle_Adaptor2d_HCurve2d& C1,const Handle_Adaptor2d_HCurve2d& C2)
+Standard_Boolean SameCurve(const Handle(Adaptor2d_HCurve2d)& C1,const Handle(Adaptor2d_HCurve2d)& C2)
{
Standard_Real C1f = C1->FirstParameter();
Standard_Real C2f = C2->FirstParameter();
Standard_Real IntPatch_CSFunction::Root() const { return f;}
-const Handle_Adaptor3d_HSurface& IntPatch_CSFunction::AuxillarSurface() const {
+const Handle(Adaptor3d_HSurface)& IntPatch_CSFunction::AuxillarSurface() const {
return SURFACE1;}
-const Handle_Adaptor2d_HCurve2d& IntPatch_CSFunction::AuxillarCurve() const {
+const Handle(Adaptor2d_HCurve2d)& IntPatch_CSFunction::AuxillarCurve() const {
return CURVE;}
#undef SURFACE1
nbsOnC = A->NbPoles();
break;
case GeomAbs_BSplineCurve: {
- //-- Handle_Geom2d_BSplineCurve& BSC=A->BSpline();
+ //-- Handle(Geom2d_BSplineCurve)& BSC=A->BSpline();
nbsOnC = 2 + A->NbKnots() * A->Degree();
break;
}
}
else//OffsetSurface
{
- const Handle(Geom_OffsetSurface) gos = *(Handle_Geom_OffsetSurface*)&GS;
+ const Handle(Geom_OffsetSurface) gos = *(Handle(Geom_OffsetSurface)*)&GS;
const Handle(Geom_Surface) bs = gos->BasisSurface();
Handle(Geom_Curve) gcbs = bs->UIso(U);
GeomAdaptor_Curve gac(gcbs);
}
else//OffsetSurface
{
- const Handle(Geom_OffsetSurface) gos = *(Handle_Geom_OffsetSurface*)&GS;
+ const Handle(Geom_OffsetSurface) gos = *(Handle(Geom_OffsetSurface)*)&GS;
const Handle(Geom_Surface) bs = gos->BasisSurface();
Handle(Geom_Curve) gcbs = bs->VIso(V);
GeomAdaptor_Curve gac(gcbs);
else if(!S1->IsVPeriodic() && !S1->IsVClosed()) {
if(T1 != GeomAbs_OffsetSurface) C1 = gs1->UIso(MS1[0]);
else {
- const Handle(Geom_OffsetSurface) gos = *(Handle_Geom_OffsetSurface*)&gs1;
+ const Handle(Geom_OffsetSurface) gos = *(Handle(Geom_OffsetSurface)*)&gs1;
const Handle(Geom_Surface) bs = gos->BasisSurface();
C1 = bs->UIso(MS1[0]);
}
if(!S1->IsUPeriodic() && !S1->IsUClosed()) {
if(T1 != GeomAbs_OffsetSurface) C1 = gs1->VIso(MS1[1]);
else {
- const Handle(Geom_OffsetSurface) gos = *(Handle_Geom_OffsetSurface*)&gs1;
+ const Handle(Geom_OffsetSurface) gos = *(Handle(Geom_OffsetSurface)*)&gs1;
const Handle(Geom_Surface) bs = gos->BasisSurface();
C1 = bs->VIso(MS1[1]);
}
else if(!S2->IsVPeriodic() && !S2->IsVClosed()) {
if(T2 != GeomAbs_OffsetSurface) C2 = gs2->UIso(MS2[0]);
else {
- const Handle(Geom_OffsetSurface) gos = *(Handle_Geom_OffsetSurface*)&gs2;
+ const Handle(Geom_OffsetSurface) gos = *(Handle(Geom_OffsetSurface)*)&gs2;
const Handle(Geom_Surface) bs = gos->BasisSurface();
C2 = bs->UIso(MS2[0]);
}
if(!S2->IsUPeriodic() && !S2->IsUClosed()) {
if(T2 != GeomAbs_OffsetSurface) C2 = gs2->VIso(MS2[1]);
else {
- const Handle(Geom_OffsetSurface) gos = *(Handle_Geom_OffsetSurface*)&gs2;
+ const Handle(Geom_OffsetSurface) gos = *(Handle(Geom_OffsetSurface)*)&gs2;
const Handle(Geom_Surface) bs = gos->BasisSurface();
C2 = bs->VIso(MS2[1]);
}
GeomProjLib::ProjectOnPlane(C2,GPln,gp_Dir(DV),Standard_True);
if(C1Prj.IsNull() || C2Prj.IsNull()) return;
Handle(Geom2d_Curve) C1Prj2d =
- GeomProjLib::Curve2d(C1Prj,*(Handle_Geom_Surface *)&GPln);
+ GeomProjLib::Curve2d(C1Prj,*(Handle(Geom_Surface) *)&GPln);
Handle(Geom2d_Curve) C2Prj2d =
- GeomProjLib::Curve2d(C2Prj,*(Handle_Geom_Surface *)&GPln);
+ GeomProjLib::Curve2d(C2Prj,*(Handle(Geom_Surface) *)&GPln);
Geom2dAPI_InterCurveCurve ICC(C1Prj2d,C2Prj2d,1.0e-7);
if(ICC.NbPoints() > 0 )
{
if(T1 != GeomAbs_OffsetSurface){ visoS1 = gs1->VIso(VM1); uisoS1 = gs1->UIso(UM1); }
else
{
- const Handle(Geom_OffsetSurface) gos = *(Handle_Geom_OffsetSurface*)&gs1;
+ const Handle(Geom_OffsetSurface) gos = *(Handle(Geom_OffsetSurface)*)&gs1;
const Handle(Geom_Surface) bs = gos->BasisSurface();
visoS1 = bs->VIso(VM1); uisoS1 = bs->UIso(UM1);
}
if(T2 != GeomAbs_OffsetSurface){ visoS2 = gs2->VIso(VM2); uisoS2 = gs2->UIso(UM2); }
else
{
- const Handle(Geom_OffsetSurface) gos = *(Handle_Geom_OffsetSurface*)&gs2;
+ const Handle(Geom_OffsetSurface) gos = *(Handle(Geom_OffsetSurface)*)&gs2;
const Handle(Geom_Surface) bs = gos->BasisSurface();
visoS2 = bs->VIso(VM2); uisoS2 = bs->UIso(UM2);
}
{
gp_Lin lin(sop.Value(ip),gp_Dir(v));
Handle(IntPatch_GLine) gl = new IntPatch_GLine(lin,Standard_False);
- slin.Append(*(Handle_IntPatch_Line *)&gl);
+ slin.Append(*(Handle(IntPatch_Line) *)&gl);
}
done = Standard_True;
for (Standard_Integer i = 1; i <= interii.NbLines(); i++)
{
- const Handle_IntPatch_Line& line = interii.Line(i);
+ const Handle(IntPatch_Line)& line = interii.Line(i);
if (line->ArcType() == IntPatch_Analytic)
{
const GeomAbs_SurfaceType typs1 = theS1->GetType();
}
IntPatch_ALineToWLine AToW(Quad1,Quad2,0.01,0.05,aNbPointsInALine);
- Handle(IntPatch_Line) wlin=AToW.MakeWLine((*((Handle_IntPatch_ALine *)(&line))));
+ Handle(IntPatch_Line) wlin=AToW.MakeWLine((*((Handle(IntPatch_ALine) *)(&line))));
slin.Append(wlin);
}
else
{
gp_Lin lin(sop.Value(ip),gp_Dir(v));
Handle(IntPatch_GLine) gl = new IntPatch_GLine(lin,Standard_False);
- slin.Append(*(Handle_IntPatch_Line *)&gl);
+ slin.Append(*(Handle(IntPatch_Line) *)&gl);
}
done = Standard_True;
#define MAXR 200
-//void IntPatch_Intersection__MAJ_R(Handle_Adaptor2d_HCurve2d *R1,
-// Handle_Adaptor2d_HCurve2d *R2,
+//void IntPatch_Intersection__MAJ_R(Handle(Adaptor2d_HCurve2d) *R1,
+// Handle(Adaptor2d_HCurve2d) *R2,
// int *NR1,
// int *NR2,
// Standard_Integer nbR1,
// Standard_Integer nbR2,
// const IntPatch_Point& VTX)
-void IntPatch_Intersection__MAJ_R(Handle_Adaptor2d_HCurve2d *,
- Handle_Adaptor2d_HCurve2d *,
+void IntPatch_Intersection__MAJ_R(Handle(Adaptor2d_HCurve2d) *,
+ Handle(Adaptor2d_HCurve2d) *,
int *,
int *,
Standard_Integer ,
/*
if(VTX.IsOnDomS1()) {
- //-- long unsigned ptr= *((long unsigned *)(((Handle_Standard_Transient *)(&(VTX.ArcOnS1())))));
+ //-- long unsigned ptr= *((long unsigned *)(((Handle(Standard_Transient) *)(&(VTX.ArcOnS1())))));
for(Standard_Integer i=0; i<nbR1;i++) {
if(VTX.ArcOnS1()==R1[i]) {
NR1[i]++;
//-- construction de la liste des restrictions & vertex
//--
int NR1[MAXR],NR2[MAXR];
- Handle_Adaptor2d_HCurve2d R1[MAXR],R2[MAXR];
+ Handle(Adaptor2d_HCurve2d) R1[MAXR],R2[MAXR];
Standard_Integer nbR1=0,nbR2=0;
for(D1->Init();D1->More() && nbR1<MAXR; D1->Next()) {
R1[nbR1]=D1->Value();
imax++;
if(imin<imax) {
- Handle_IntSurf_LineOn2S PWLine = new IntSurf_LineOn2S();
+ Handle(IntSurf_LineOn2S) PWLine = new IntSurf_LineOn2S();
for(i=imin;i<=imax;i++)
PWLine->Add(PW.Line()->Value(i));
imax++;
if(imin<imax) {
- Handle_IntSurf_LineOn2S PWLine = new IntSurf_LineOn2S();
+ Handle(IntSurf_LineOn2S) PWLine = new IntSurf_LineOn2S();
for(i=imin;i<=imax;i++)
PWLine->Add(PW.Line()->Value(i));
// function : NewLine
// purpose :
//==================================================================================
-Handle_IntPatch_Line IntPatch_PrmPrmIntersection::NewLine (const Handle(Adaptor3d_HSurface)& Surf1,
+Handle(IntPatch_Line) IntPatch_PrmPrmIntersection::NewLine (const Handle(Adaptor3d_HSurface)& Surf1,
const Handle(Adaptor3d_HSurface)& Surf2,
const Standard_Integer NumLine,
const Standard_Integer Low,
#include <NCollection_BaseAllocator.hxx>
-typedef Handle_NCollection_BaseAllocator IntSurf_Allocator;
+typedef Handle(NCollection_BaseAllocator) IntSurf_Allocator;
#endif
{
// Solaris Forte C++ compiler insisted it couldn't cast this,
// even though it seems to do so elsewhere
- Handle_Standard_Transient tmp = Handle_Standard_Transient(theents[3]);
+ Handle(Standard_Transient) tmp = Handle(Standard_Transient)(theents[3]);
return ( !tmp.IsNull() );
}
}
//=======================================================================
-//function : Handle_Geom_BSplineCurve&
+//function : Handle(Geom_BSplineCurve)&
//purpose :
//=======================================================================
// function: SetSecondNode
// purpose :
//========================================================================
-void MAT_Arc::SetSecondNode(const Handle_MAT_Node& aNode)
+void MAT_Arc::SetSecondNode(const Handle(MAT_Node)& aNode)
{
secondNode = aNode;
}
// function: SetStartArc
// purpose :
//========================================================================
-void MAT_BasicElt::SetStartArc(const Handle_MAT_Arc& anArc)
+void MAT_BasicElt::SetStartArc(const Handle(MAT_Arc)& anArc)
{
startLeftArc = anArc.operator->();
}
// function: SetEndArc
// purpose :
//========================================================================
-void MAT_BasicElt::SetEndArc(const Handle_MAT_Arc& anArc)
+void MAT_BasicElt::SetEndArc(const Handle(MAT_Arc)& anArc)
{
endLeftArc = anArc.operator->();
}
// Detection Lignes ouvertes.
//----------------------------
for ( i = 1; i <= NbLines; i++) {
- Handle_Geom2d_TrimmedCurve Curve;
+ Handle(Geom2d_TrimmedCurve) Curve;
Curve = Handle(Geom2d_TrimmedCurve)::DownCast(FigItem.Value(i).First());
gp_Pnt2d P1 = Curve->StartPoint();
Curve = Handle(Geom2d_TrimmedCurve)::DownCast(FigItem.Value(i).Last());
Atof(value3),
Quantity_TOC_RGB));
objectparameter = new Dynamic_ObjectParameter(aname,pcolor);
- parameter = *(Handle_Dynamic_Parameter*)&objectparameter;
+ parameter = *(Handle(Dynamic_Parameter)*)&objectparameter;
}
else
// Function : GetNonDeformedDataSource
// Purpose :
//================================================================
-Handle_MeshVS_DataSource MeshVS_DeformedDataSource::GetNonDeformedDataSource() const
+Handle(MeshVS_DataSource) MeshVS_DeformedDataSource::GetNonDeformedDataSource() const
{
return myNonDeformedDataSource;
}
{ SetHashCode ( TColStd_MapTransientHasher::HashCode (akey, IntegerLast() ) ); }
- const Handle_Standard_Transient& MoniTool_TransientElem::Value () const
+ const Handle(Standard_Transient)& MoniTool_TransientElem::Value () const
{ return theval; }
Standard_Boolean MoniTool_TransientElem::Equates
const Handle(NCollection_BaseAllocator)& IterAllocator(void) const
{
if (myIterAllocator.IsNull())
- (Handle_NCollection_BaseAllocator&) myIterAllocator =
+ (Handle(NCollection_BaseAllocator)&) myIterAllocator =
new NCollection_IncAllocator(64);
return myIterAllocator;
}
//! }
template <class T>
-class NCollection_Handle : public Handle_Standard_Transient
+class NCollection_Handle : public Handle(Standard_Transient)
{
private:
//! Note that additional argument is used to avoid ambiguity with
//! public constructor from pointer when Handle is intilialized by 0.
NCollection_Handle (Ptr* thePtr, int)
- : Handle_Standard_Transient (thePtr) {}
+ : Handle(Standard_Transient) (thePtr) {}
public:
//! Constructor of handle from pointer on newly allocated object
NCollection_Handle (T* theObject)
- : Handle_Standard_Transient (theObject ? new Ptr (theObject) : 0) {}
+ : Handle(Standard_Transient) (theObject ? new Ptr (theObject) : 0) {}
//! Cast handle to contained type
T* operator -> () { return ((Ptr*)ControlAccess())->myPtr; }
//purpose :
//=======================================================================
-const Handle_NCollection_HeapAllocator&
+const Handle(NCollection_HeapAllocator)&
NCollection_HeapAllocator::GlobalHeapAllocator()
{
static Handle(NCollection_HeapAllocator) pAllocator;
#include <NCollection_BaseAllocator.hxx>
-class Handle_NCollection_HeapAllocator;
+class Handle(NCollection_HeapAllocator);
/**
* Allocator that uses the global dynamic heap (malloc / free).
Standard_EXPORT virtual void* Allocate (const Standard_Size theSize);
Standard_EXPORT virtual void Free (void * anAddress);
- Standard_EXPORT static const Handle_NCollection_HeapAllocator&
+ Standard_EXPORT static const Handle(NCollection_HeapAllocator)&
GlobalHeapAllocator();
protected:
DEFINE_BASECOLLECTION(NCollection_BaseCollExtendedString,
TCollection_ExtendedString)
DEFINE_BASECOLLECTION(NCollection_BaseCollTransient ,
- Handle_Standard_Transient)
+ Handle(Standard_Transient))
#endif
\
_HUBTREE () : myTree(new UBTree) {} \
/* Empty constructor */ \
- _HUBTREE (const Handle_NCollection_BaseAllocator& theAlloc) \
+ _HUBTREE (const Handle(NCollection_BaseAllocator)& theAlloc) \
: myTree(new UBTree(theAlloc)) {} \
/* Constructor */ \
\
* the tree filling is faster due to better utilisation of CPU L1/L2 cache.
*/
NCollection_UBTreeFiller (UBTree& theTree,
- const Handle_NCollection_BaseAllocator& theAlloc=0L,
+ const Handle(NCollection_BaseAllocator)& theAlloc=0L,
const Standard_Boolean isFullRandom = Standard_True)
: myTree(theTree), mySeqPtr(1000, theAlloc),
mySeed(1), myIsFullRandom (isFullRandom)
//! Constructor
NCollection_Vector (const Standard_Integer theIncrement = 256,
- const Handle_NCollection_BaseAllocator& theAlloc = NULL)
+ const Handle(NCollection_BaseAllocator)& theAlloc = NULL)
: NCollection_BaseCollection<TheItemType> (theAlloc),
NCollection_BaseVector (NCollection_BaseCollection<TheItemType>::myAllocator, initMemBlocks, sizeof(TheItemType), theIncrement) {}
//purpose : Constructor
//=======================================================================
-NIS_DrawList::NIS_DrawList (const Handle_NIS_View& theView)
+NIS_DrawList::NIS_DrawList (const Handle(NIS_View)& theView)
: myView (theView)
{
#ifdef ARRAY_LISTS
//purpose : Set myListID to 0.
//=======================================================================
-void NIS_DrawList::ClearListID (const Handle_NIS_View& theView)
+void NIS_DrawList::ClearListID (const Handle(NIS_View)& theView)
{
#ifdef ARRAY_LISTS
if (myListID > 0)
Standard_Boolean NIS_DrawList::SetDynHilighted
(const Standard_Boolean isHili,
- const Handle_NIS_InteractiveObject& theObj)
+ const Handle(NIS_InteractiveObject)& theObj)
{
Standard_Boolean aResult (Standard_False);
- NCollection_List<Handle_NIS_InteractiveObject>::Iterator anIt(myDynHilighted);
+ NCollection_List<Handle(NIS_InteractiveObject)>::Iterator anIt(myDynHilighted);
for (; anIt.More(); anIt.Next())
if (anIt.Value() == theObj)
break;
/**
* Constructor
*/
- Standard_EXPORT NIS_DrawList (const Handle_NIS_View& theView);
+ Standard_EXPORT NIS_DrawList (const Handle(NIS_View)& theView);
/**
* Destructor.
* @return
* Previous value of myListID
*/
- Standard_EXPORT void ClearListID (const Handle_NIS_View& theView=NULL);
+ Standard_EXPORT void ClearListID (const Handle(NIS_View)& theView=NULL);
/**
* This method is called to start recording a new list. It must be eventually
/**
* Query if the given list should be processed by Dynamic Hilighting.
*/
- inline const NCollection_List<Handle_NIS_InteractiveObject>&
+ inline const NCollection_List<Handle(NIS_InteractiveObject)>&
DynHilightedList() const
{ return myDynHilighted; }
/**
* Query the View.
*/
- inline const Handle_NIS_View& GetView () const
+ inline const Handle(NIS_View)& GetView () const
{ return myView; }
/**
*/
Standard_EXPORT Standard_Boolean SetDynHilighted
(const Standard_Boolean isHilight,
- const Handle_NIS_InteractiveObject& theObj);
+ const Handle(NIS_InteractiveObject)& theObj);
protected:
// ---------- PROTECTED METHODS ----------
private:
// ---------- PRIVATE FIELDS ----------
- Handle_NIS_View myView;
+ Handle(NIS_View) myView;
#ifdef ARRAY_LISTS
Standard_Integer myListID;
#else
Standard_Integer myListID[5];
#endif
Standard_Boolean myIsUpdated[5];
- NCollection_List<Handle_NIS_InteractiveObject> myDynHilighted;
+ NCollection_List<Handle(NIS_InteractiveObject)> myDynHilighted;
};
//purpose :
//=======================================================================
-void NIS_Drawer::Assign (const Handle_NIS_Drawer& theOther)
+void NIS_Drawer::Assign (const Handle(NIS_Drawer)& theOther)
{
if (theOther->IsKind(DynamicType()) == Standard_False)
Standard_TypeMismatch::Raise ("NIS_Drawer::Assign");
//purpose :
//=======================================================================
-Standard_Boolean NIS_Drawer::IsEqual (const Handle_NIS_Drawer& theOther) const
+Standard_Boolean NIS_Drawer::IsEqual (const Handle(NIS_Drawer)& theOther) const
{
Standard_Boolean aResult (Standard_False);
if (theOther.IsNull() == Standard_False)
//purpose :
//=======================================================================
-void NIS_Drawer::UpdateExListId (const Handle_NIS_View& theView) const
+void NIS_Drawer::UpdateExListId (const Handle(NIS_View)& theView) const
{
if (theView.IsNull()) {
if (myCtx) {
//=======================================================================
void NIS_Drawer::redraw (const DrawType theType,
- const Handle_NIS_View& theView)
+ const Handle(NIS_View)& theView)
{
if (myCtx &&
myMapID.IsEmpty() == Standard_False &&
NCollection_List<NIS_DrawList*>::Iterator anIter (myLists);
for (; anIter.More(); anIter.Next()) {
NIS_DrawList& aDrawList = * anIter.ChangeValue();
- const Handle_NIS_View& aView = aDrawList.GetView();
+ const Handle(NIS_View)& aView = aDrawList.GetView();
if (aView == theView || aView.IsNull()) {
if (aDrawList.IsUpdated(theType)) {
// Get the IDs of objects concerned
void NIS_Drawer::SetDynamicHilighted
(const Standard_Boolean isHilighted,
- const Handle_NIS_InteractiveObject& theObj,
- const Handle_NIS_View& theView)
+ const Handle(NIS_InteractiveObject)& theObj,
+ const Handle(NIS_View)& theView)
{
if (myCtx && theObj.IsNull() == Standard_False) {
NCollection_List<NIS_DrawList*>::Iterator anIter (myLists);
if (isShareList)
myLists.Append (createDefaultList(NULL));
else {
- NCollection_List<Handle_NIS_View>::Iterator anIter(GetContext()->myViews);
+ NCollection_List<Handle(NIS_View)>::Iterator anIter(GetContext()->myViews);
for (; anIter.More(); anIter.Next())
myLists.Append (createDefaultList(anIter.Value()));
}
// Dynamic hilighting is treated in a separate loop because the hilighted
// instances are contained in the special list rather than in the Context
if (theType == NIS_Drawer::Draw_DynHilighted) {
- NCollection_List<Handle_NIS_InteractiveObject>::Iterator
+ NCollection_List<Handle(NIS_InteractiveObject)>::Iterator
anIter (theDrawList.DynHilightedList());
if (anIter.More()) {
BeforeDraw (theType, theDrawList);
//purpose :
//=======================================================================
NIS_DrawList* NIS_Drawer::createDefaultList
- (const Handle_NIS_View& theView) const
+ (const Handle(NIS_View)& theView) const
{
return new NIS_DrawList(theView);
}
#pragma warning (disable:4480)
#endif
-class Handle_NIS_InteractiveObject;
-class Handle_NIS_View;
-class Handle_NIS_Drawer;
+class Handle(NIS_InteractiveObject);
+class Handle(NIS_View);
+class Handle(NIS_Drawer);
class NIS_InteractiveContext;
class NIS_View;
template <class A> class NCollection_Vector;
* Copy the relevant information from another instance of Drawer.
* raises exception if theOther has incompatible type (test IsKind).
*/
- Standard_EXPORT virtual void Assign (const Handle_NIS_Drawer& theOther);
+ Standard_EXPORT virtual void Assign (const Handle(NIS_Drawer)& theOther);
/**
* Create a3D bounding box of drawn objects.
*/
Standard_EXPORT void SetDynamicHilighted
(const Standard_Boolean isHilighted,
- const Handle_NIS_InteractiveObject& theObj,
- const Handle_NIS_View& theView = 0L);
+ const Handle(NIS_InteractiveObject)& theObj,
+ const Handle(NIS_View)& theView = 0L);
/**
* Hash value, for Map interface.
* Matching two instances, for Map interface.
*/
Standard_EXPORT virtual Standard_Boolean
- IsEqual (const Handle_NIS_Drawer& theOth) const;
+ IsEqual (const Handle(NIS_Drawer)& theOth) const;
/**
* Obtain the iterator of IDs of associated objects.
* Called to add draw list IDs to ex-list Ids of view. These draw lists are
* eventually released in the callback function, before anything is displayed
*/
- Standard_EXPORT void UpdateExListId (const Handle_NIS_View& theView) const;
+ Standard_EXPORT void UpdateExListId (const Handle(NIS_View)& theView) const;
// ---------- PROTECTED METHODS ----------
/**
* Main function: display the given interactive object in the given view.
*/
- Standard_EXPORT virtual void Draw (const Handle_NIS_InteractiveObject&,
+ Standard_EXPORT virtual void Draw (const Handle(NIS_InteractiveObject)&,
const DrawType theType,
const NIS_DrawList& theDrawList)= 0;
Standard_EXPORT virtual void redraw (const DrawType theType,
- const Handle_NIS_View& theView);
+ const Handle(NIS_View)& theView);
Standard_EXPORT void addObject (const NIS_InteractiveObject * theObj,
const Standard_Boolean isShareList,
const Standard_Boolean isUpVws);
Standard_EXPORT virtual NIS_DrawList*
- createDefaultList (const Handle_NIS_View&) const;
+ createDefaultList (const Handle(NIS_View)&) const;
protected:
//! Get the number of interactive objects in this drawer
//purpose :
//=======================================================================
-inline Standard_Integer HashCode (const Handle_NIS_Drawer& theDrawer,
+inline Standard_Integer HashCode (const Handle(NIS_Drawer)& theDrawer,
const Standard_Integer theN)
{ return theDrawer.IsNull() ? 0 : theDrawer->HashCode (theN); }
//purpose :
//=======================================================================
-inline Standard_Boolean IsEqual (const Handle_NIS_Drawer& theDrawer1,
- const Handle_NIS_Drawer& theDrawer2)
+inline Standard_Boolean IsEqual (const Handle(NIS_Drawer)& theDrawer1,
+ const Handle(NIS_Drawer)& theDrawer2)
{ return theDrawer1.IsNull()? Standard_False: theDrawer1->IsEqual(theDrawer2); }
#ifdef WNT
IMPLEMENT_STANDARD_HANDLE (NIS_InteractiveContext, Standard_Transient)
IMPLEMENT_STANDARD_RTTIEXT (NIS_InteractiveContext, Standard_Transient)
-static void markAllDrawersUpdated (const NCollection_Map<Handle_NIS_Drawer>&);
+static void markAllDrawersUpdated (const NCollection_Map<Handle(NIS_Drawer)>&);
//=======================================================================
//function : NIS_InteractiveContext()
NIS_InteractiveContext::~NIS_InteractiveContext ()
{
// Unregister this context in all referred views
- NCollection_List<Handle_NIS_View>::Iterator anIterV (myViews);
+ NCollection_List<Handle(NIS_View)>::Iterator anIterV (myViews);
for (; anIterV.More(); anIterV.Next())
if (anIterV.Value().IsNull() == Standard_False)
anIterV.Value()->RemoveContext(this);
// // Unregister this context in all referred drawers
-// NCollection_Map<Handle_NIS_Drawer>::Iterator anIterD (myDrawers);
+// NCollection_Map<Handle(NIS_Drawer)>::Iterator anIterD (myDrawers);
// for (; anIterD.More(); anIterD.Next())
// if (anIterD.Value().IsNull() == Standard_False)
// anIterD.Value()->myCtx = 0L;
//purpose :
//=======================================================================
-void NIS_InteractiveContext::AttachView (const Handle_NIS_View& theView)
+void NIS_InteractiveContext::AttachView (const Handle(NIS_View)& theView)
{
if (theView.IsNull() == Standard_False) {
- NCollection_List<Handle_NIS_View>::Iterator anIter (myViews);
+ NCollection_List<Handle(NIS_View)>::Iterator anIter (myViews);
for (; anIter.More(); anIter.Next())
if (anIter.Value() == theView)
break;
if (anIter.More() == Standard_False) {
myViews.Append (theView);
theView->AddContext (this);
- NCollection_Map<Handle_NIS_Drawer>::Iterator anIterD (myDrawers);
+ NCollection_Map<Handle(NIS_Drawer)>::Iterator anIterD (myDrawers);
for (; anIterD.More(); anIterD.Next()) {
const Handle(NIS_Drawer)& aDrawer = anIterD.Value();
if (aDrawer.IsNull() == Standard_False)
//purpose :
//=======================================================================
-void NIS_InteractiveContext::DetachView (const Handle_NIS_View& theView)
+void NIS_InteractiveContext::DetachView (const Handle(NIS_View)& theView)
{
if (theView.IsNull() == Standard_False) {
- NCollection_List<Handle_NIS_View>::Iterator anIter (myViews);
+ NCollection_List<Handle(NIS_View)>::Iterator anIter (myViews);
for (; anIter.More(); anIter.Next())
if (anIter.Value() == theView) {
myViews.Remove(anIter);
theView->RemoveContext(this);
- NCollection_Map<Handle_NIS_Drawer>::Iterator anIterD (myDrawers);
+ NCollection_Map<Handle(NIS_Drawer)>::Iterator anIterD (myDrawers);
for (; anIterD.More(); anIterD.Next()) {
const Handle(NIS_Drawer)& aDrawer = anIterD.Value();
if (aDrawer.IsNull() == Standard_False) {
//purpose :
//=======================================================================
-const Handle_NIS_InteractiveObject& NIS_InteractiveContext::GetObject
+const Handle(NIS_InteractiveObject)& NIS_InteractiveContext::GetObject
(const Standard_Integer theID) const
{
if (!myObjects.IsBound(theID))
{
- static Handle_NIS_InteractiveObject aNull;
+ static Handle(NIS_InteractiveObject) aNull;
return aNull;
}
return myObjects(theID);
void NIS_InteractiveContext::redraw (const Handle(NIS_View)& theView,
const NIS_Drawer::DrawType theType)
{
- NCollection_Map <Handle_NIS_Drawer>::Iterator anIter (myDrawers);
+ NCollection_Map <Handle(NIS_Drawer)>::Iterator anIter (myDrawers);
for (; anIter.More(); anIter.Next())
if (anIter.Value().IsNull() == Standard_False)
anIter.Value()->redraw (theType, theView);
void NIS_InteractiveContext::GetBox (Bnd_B3f& theBox,
const NIS_View * theView) const
{
- NCollection_Map <Handle_NIS_Drawer>::Iterator anIterD (myDrawers);
+ NCollection_Map <Handle(NIS_Drawer)>::Iterator anIterD (myDrawers);
for (; anIterD.More(); anIterD.Next())
if (anIterD.Value().IsNull() == Standard_False)
theBox.Add(anIterD.Value()->GetBox(theView));
//=======================================================================
void NIS_InteractiveContext::Display
- (Handle_NIS_InteractiveObject& theObj,
- const Handle_NIS_Drawer& theDrawer,
+ (Handle(NIS_InteractiveObject)& theObj,
+ const Handle(NIS_Drawer)& theDrawer,
const Standard_Boolean isUpdateViews)
{
if (theObj.IsNull())
//=======================================================================
void NIS_InteractiveContext::DisplayOnTop
- (Handle_NIS_InteractiveObject& theObj,
- const Handle_NIS_Drawer& theDrawer,
+ (Handle(NIS_InteractiveObject)& theObj,
+ const Handle(NIS_Drawer)& theDrawer,
const Standard_Boolean isUpdateViews)
{
if (theObj.IsNull())
//purpose :
//=======================================================================
-void NIS_InteractiveContext::Erase (const Handle_NIS_InteractiveObject& theObj,
+void NIS_InteractiveContext::Erase (const Handle(NIS_InteractiveObject)& theObj,
const Standard_Boolean isUpdateViews)
{
if (theObj->IsHidden() == Standard_False) {
if (aDrawer.IsNull() == Standard_False) {
// Unhilight the erased object
if (theObj->IsDynHilighted()) {
- NCollection_List<Handle_NIS_View>::Iterator anIterV (myViews);
+ NCollection_List<Handle(NIS_View)>::Iterator anIterV (myViews);
for (; anIterV.More(); anIterV.Next())
if (anIterV.Value().IsNull() == Standard_False)
anIterV.Value()->DynamicUnhilight (theObj);
//purpose :
//=======================================================================
-void NIS_InteractiveContext::Remove (const Handle_NIS_InteractiveObject& theObj,
+void NIS_InteractiveContext::Remove (const Handle(NIS_InteractiveObject)& theObj,
const Standard_Boolean isUpdateViews)
{
if (theObj.IsNull() == Standard_False) {
if (aDrawer->myCtx == this) {
// Remove the hilighting if the object has been hilighted
if (theObj->IsDynHilighted()) {
- NCollection_List<Handle_NIS_View>::Iterator anIterV (myViews);
+ NCollection_List<Handle(NIS_View)>::Iterator anIterV (myViews);
for (; anIterV.More(); anIterV.Next())
if (anIterV.Value().IsNull() == Standard_False)
anIterV.Value()->DynamicUnhilight (theObj);
void NIS_InteractiveContext::DisplayAll ()
{
// UnHide all objects in the Context
- NCollection_SparseArray <Handle_NIS_InteractiveObject>::ConstIterator
+ NCollection_SparseArray <Handle(NIS_InteractiveObject)>::ConstIterator
anIter(myObjects);
for (; anIter.More(); anIter.Next()) {
const Handle(NIS_InteractiveObject)& anObj = anIter.Value();
}
// Update status of objects in Drawers (particularly cancel dyn. hilighting)
- NCollection_Map<Handle_NIS_Drawer>::Iterator anIterD (myDrawers);
+ NCollection_Map<Handle(NIS_Drawer)>::Iterator anIterD (myDrawers);
for (; anIterD.More(); anIterD.Next()) {
const Handle(NIS_Drawer)& aDrawer = anIterD.Value();
if (aDrawer.IsNull() == Standard_False) {
void NIS_InteractiveContext::EraseAll ()
{
// Hide all objects in the Context
- NCollection_SparseArray <Handle_NIS_InteractiveObject>::ConstIterator
+ NCollection_SparseArray <Handle(NIS_InteractiveObject)>::ConstIterator
anIter(myObjects);
for (; anIter.More(); anIter.Next()) {
const Handle(NIS_InteractiveObject)& anObj = anIter.Value();
if (anObj->IsHidden() == Standard_False)
anObj->myIsHidden = Standard_True;
if (anObj->IsDynHilighted()) {
- NCollection_List<Handle_NIS_View>::Iterator anIterV (myViews);
+ NCollection_List<Handle(NIS_View)>::Iterator anIterV (myViews);
for (; anIterV.More(); anIterV.Next())
if (anIterV.Value().IsNull() == Standard_False)
anIterV.Value()->DynamicUnhilight (anObj);
}
// Update status of objects in Drawers (particularly cancel dyn. hilighting)
- NCollection_Map<Handle_NIS_Drawer>::Iterator anIterD (myDrawers);
+ NCollection_Map<Handle(NIS_Drawer)>::Iterator anIterD (myDrawers);
for (; anIterD.More(); anIterD.Next()) {
const Handle(NIS_Drawer)& aDrawer = anIterD.Value();
if (aDrawer.IsNull() == Standard_False) {
void NIS_InteractiveContext::RemoveAll ()
{
// Remove objects from the Context
- NCollection_SparseArray <Handle_NIS_InteractiveObject>::Iterator
+ NCollection_SparseArray <Handle(NIS_InteractiveObject)>::Iterator
anIter(myObjects);
for (; anIter.More(); anIter.Next()) {
Handle(NIS_InteractiveObject)& anObj = anIter.ChangeValue();
if (anObj.IsNull() == Standard_False) {
if (anObj->IsDynHilighted()) {
- NCollection_List<Handle_NIS_View>::Iterator anIterV (myViews);
+ NCollection_List<Handle(NIS_View)>::Iterator anIterV (myViews);
for (; anIterV.More(); anIterV.Next())
if (anIterV.Value().IsNull() == Standard_False)
anIterV.Value()->DynamicUnhilight (anObj);
}
// Mark all draw lists to be removed in the view callback
- NCollection_Map<Handle_NIS_Drawer>::Iterator anIterD (myDrawers);
+ NCollection_Map<Handle(NIS_Drawer)>::Iterator anIterD (myDrawers);
for (; anIterD.More(); anIterD.Next()) {
const Handle(NIS_Drawer)& aDrawer = anIterD.Value();
if (aDrawer.IsNull() == Standard_False) {
void NIS_InteractiveContext::RebuildViews ()
{
- const Handle_NIS_Allocator aNewAlloc = compactObjects();
+ const Handle(NIS_Allocator) aNewAlloc = compactObjects();
// Recalculate all DrawLists in all drawers
markAllDrawersUpdated(myDrawers);
if (aNewAlloc.IsNull() == Standard_False)
myAllocator = aNewAlloc;
- NCollection_List<Handle_NIS_View>::Iterator anIterV(myViews);
+ NCollection_List<Handle(NIS_View)>::Iterator anIterV(myViews);
for (; anIterV.More(); anIterV.Next()) {
const Handle(NIS_View)& aView = anIterV.Value();
if (aView.IsNull() == Standard_False)
void NIS_InteractiveContext::UpdateViews ()
{
- const Handle_NIS_Allocator aNewAlloc = compactObjects();
+ const Handle(NIS_Allocator) aNewAlloc = compactObjects();
if (aNewAlloc.IsNull() == Standard_False)
myAllocator = aNewAlloc;
- NCollection_List<Handle_NIS_View>::Iterator anIterV(myViews);
+ NCollection_List<Handle(NIS_View)>::Iterator anIterV(myViews);
for (; anIterV.More(); anIterV.Next()) {
const Handle(NIS_View)& aView = anIterV.Value();
if (aView.IsNull() == Standard_False)
//=======================================================================
Standard_Boolean NIS_InteractiveContext::SetSelected
- (const Handle_NIS_InteractiveObject& theObj,
+ (const Handle(NIS_InteractiveObject)& theObj,
const Standard_Boolean isSelected)
{
Standard_Boolean aResult (Standard_False);
//=======================================================================
Standard_Boolean NIS_InteractiveContext::ProcessSelection
- (const Handle_NIS_InteractiveObject& theObj,
+ (const Handle(NIS_InteractiveObject)& theObj,
const Standard_Boolean isMultiple)
{
Standard_Boolean aResult (Standard_False);
//=======================================================================
Standard_Boolean NIS_InteractiveContext::IsSelected
- (const Handle_NIS_InteractiveObject& theObj)
+ (const Handle(NIS_InteractiveObject)& theObj)
{
Standard_Boolean aResult (Standard_False);
if (theObj.IsNull() == Standard_False) {
//=======================================================================
Standard_Real NIS_InteractiveContext::selectObject
- (Handle_NIS_InteractiveObject& theSel,
+ (Handle(NIS_InteractiveObject)& theSel,
NCollection_List<DetectedEnt>& theDetected,
const gp_Ax1& theAxis,
const Standard_Real theOver,
if (mySelectionMode != Mode_NoSelection || isOnlySel == Standard_False)
{
DetectedEnt anEnt;
- NCollection_SparseArray <Handle_NIS_InteractiveObject>::ConstIterator
+ NCollection_SparseArray <Handle(NIS_InteractiveObject)>::ConstIterator
anIter(myObjects);
for (; anIter.More(); anIter.Next()) {
const Handle(NIS_InteractiveObject)& anObj = anIter.Value();
{
Standard_Boolean aResult (Standard_False);
if (mySelectionMode != Mode_NoSelection) {
- NCollection_SparseArray <Handle_NIS_InteractiveObject>::ConstIterator
+ NCollection_SparseArray <Handle(NIS_InteractiveObject)>::ConstIterator
anIter(myObjects);
for (; anIter.More(); anIter.Next()) {
const Handle(NIS_InteractiveObject)& anObj = anIter.Value();
Standard_Boolean aResult (Standard_False);
if (mySelectionMode != Mode_NoSelection) {
- NCollection_SparseArray <Handle_NIS_InteractiveObject>::ConstIterator
+ NCollection_SparseArray <Handle(NIS_InteractiveObject)>::ConstIterator
anIter(myObjects);
for (; anIter.More(); anIter.Next()) {
//purpose :
//=======================================================================
-const Handle_NIS_Drawer& NIS_InteractiveContext::drawerForDisplay
- (const Handle_NIS_InteractiveObject& theObj,
- const Handle_NIS_Drawer& theDrawer)
+const Handle(NIS_Drawer)& NIS_InteractiveContext::drawerForDisplay
+ (const Handle(NIS_InteractiveObject)& theObj,
+ const Handle(NIS_Drawer)& theDrawer)
{
Handle(NIS_Drawer) aDrawer;
if (theDrawer.IsNull() == Standard_False) {
//=======================================================================
void NIS_InteractiveContext::objectForDisplay
- (Handle_NIS_InteractiveObject& theObj,
+ (Handle(NIS_InteractiveObject)& theObj,
const NIS_Drawer::DrawType theDrawType)
{
if (theObj->ID() == 0) {
//purpose :
//=======================================================================
-Handle_NIS_Allocator NIS_InteractiveContext::compactObjects()
+Handle(NIS_Allocator) NIS_InteractiveContext::compactObjects()
{
Handle(NIS_Allocator) aNewAlloc;
- NCollection_List<Handle_NIS_View>::Iterator anIterV;
+ NCollection_List<Handle(NIS_View)>::Iterator anIterV;
// Check if the memory used by objects has to be compacted.
const Standard_Size nAllocated = myAllocator->NAllocated();
// Compact the memory: clone all objects to a new allocator, release
// the old allocator instance.
aNewAlloc = new NIS_Allocator;
- NCollection_SparseArray<Handle_NIS_InteractiveObject>::Iterator
+ NCollection_SparseArray<Handle(NIS_InteractiveObject)>::Iterator
anIter(myObjects);
for (; anIter.More(); anIter.Next()) {
if (anIter.Value().IsNull() == Standard_False) {
//purpose :
//=======================================================================
-void markAllDrawersUpdated (const NCollection_Map<Handle_NIS_Drawer>& lstDrv)
+void markAllDrawersUpdated (const NCollection_Map<Handle(NIS_Drawer)>& lstDrv)
{
- NCollection_Map<Handle_NIS_Drawer>::Iterator anIterD (lstDrv);
+ NCollection_Map<Handle(NIS_Drawer)>::Iterator anIterD (lstDrv);
for (; anIterD.More(); anIterD.Next()) {
const Handle(NIS_Drawer)& aDrawer = anIterD.Value();
if (aDrawer.IsNull() == Standard_False) {
/**
* Associate this Context with the given View.
*/
- Standard_EXPORT void AttachView (const Handle_NIS_View& theView);
+ Standard_EXPORT void AttachView (const Handle(NIS_View)& theView);
/**
* Stop the association of the Context with the given View.
*/
- Standard_EXPORT void DetachView (const Handle_NIS_View& theView);
+ Standard_EXPORT void DetachView (const Handle(NIS_View)& theView);
//@}
/**
* Query the InteractiveObject instance by its ID.
*/
- Standard_EXPORT const Handle_NIS_InteractiveObject&
+ Standard_EXPORT const Handle(NIS_InteractiveObject)&
GetObject (const Standard_Integer theID) const;
/**
* Access to Drawers, can be used for specific operations where it is not
* desirale to iterate InteractiveObjects.
*/
- inline NCollection_Map<Handle_NIS_Drawer>::Iterator
+ inline NCollection_Map<Handle(NIS_Drawer)>::Iterator
GetDrawers () const
- { return NCollection_Map<Handle_NIS_Drawer>::Iterator(myDrawers); }
+ { return NCollection_Map<Handle(NIS_Drawer)>::Iterator(myDrawers); }
// ================ BEGIN Mangement of Objects ================
///@name Management of Objects
* to False if you have to make a number of similar calls, then you would
* call UpdateViews() in the end.
*/
- Standard_EXPORT void Display (Handle_NIS_InteractiveObject& theObj,
- const Handle_NIS_Drawer& theDrawer = NULL,
+ Standard_EXPORT void Display (Handle(NIS_InteractiveObject)& theObj,
+ const Handle(NIS_Drawer)& theDrawer = NULL,
const Standard_Boolean isUpdateViews
= Standard_True);
* to False if you have to make a number of similar calls, then you would
* call UpdateViews() in the end.
*/
- Standard_EXPORT void DisplayOnTop (Handle_NIS_InteractiveObject& theObj,
- const Handle_NIS_Drawer& theDrawer = NULL,
+ Standard_EXPORT void DisplayOnTop (Handle(NIS_InteractiveObject)& theObj,
+ const Handle(NIS_Drawer)& theDrawer = NULL,
const Standard_Boolean isUpdateViews
= Standard_True);
* to False if you have to make a number of similar calls, then you would
* call UpdateViews() in the end.
*/
- Standard_EXPORT void Erase (const Handle_NIS_InteractiveObject& theObj,
+ Standard_EXPORT void Erase (const Handle(NIS_InteractiveObject)& theObj,
const Standard_Boolean isUpdateViews
= Standard_True);
* to False if you have to make a number of similar calls, then you would
* call UpdateViews() in the end.
*/
- Standard_EXPORT void Remove (const Handle_NIS_InteractiveObject& theObj,
+ Standard_EXPORT void Remove (const Handle(NIS_InteractiveObject)& theObj,
const Standard_Boolean isUpdateViews
= Standard_True);
* Query the current selection filter. Use the method SetFilter to install it.
* By default returns a NULL handle.
*/
- inline const Handle_NIS_SelectFilter&
+ inline const Handle(NIS_SelectFilter)&
GetFilter () const
{ return mySelectFilter; }
/**
* Install a selection filter.
*/
- inline void SetFilter (const Handle_NIS_SelectFilter& theFilter)
+ inline void SetFilter (const Handle(NIS_SelectFilter)& theFilter)
{ mySelectFilter = theFilter; }
/**
* True if the selection status has been changed, False if nothing changed
*/
Standard_EXPORT Standard_Boolean
- ProcessSelection(const Handle_NIS_InteractiveObject& O,
+ ProcessSelection(const Handle(NIS_InteractiveObject)& O,
const Standard_Boolean isMultiple
= Standard_False);
* True if the selection status has been changed, False if noithing changed
*/
Standard_EXPORT Standard_Boolean
- SetSelected (const Handle_NIS_InteractiveObject& theObj,
+ SetSelected (const Handle(NIS_InteractiveObject)& theObj,
const Standard_Boolean isSelected
= Standard_True);
* Query if the given object is selected.
*/
Standard_EXPORT Standard_Boolean
- IsSelected (const Handle_NIS_InteractiveObject& theOb);
+ IsSelected (const Handle(NIS_InteractiveObject)& theOb);
/**
* Reset all previous selection.
// ---------- PROTECTED METHODS ----------
- Standard_EXPORT void redraw (const Handle_NIS_View& theView,
+ Standard_EXPORT void redraw (const Handle(NIS_View)& theView,
const NIS_Drawer::DrawType theType);
/**
* The ray distance of the intersection point between the ray and theSel.
*/
Standard_EXPORT Standard_Real
- selectObject (Handle_NIS_InteractiveObject& theSel,
+ selectObject (Handle(NIS_InteractiveObject)& theSel,
NCollection_List<DetectedEnt>& theDet,
const gp_Ax1& theAxis,
const Standard_Real theOver,
const Standard_Boolean isFullyIn) const;
private:
- void deselectObj (const Handle_NIS_InteractiveObject&,
+ void deselectObj (const Handle(NIS_InteractiveObject)&,
const Standard_Integer);
- void selectObj (const Handle_NIS_InteractiveObject&,
+ void selectObj (const Handle(NIS_InteractiveObject)&,
const Standard_Integer);
- const Handle_NIS_Drawer&
- drawerForDisplay (const Handle_NIS_InteractiveObject&,
- const Handle_NIS_Drawer&);
+ const Handle(NIS_Drawer)&
+ drawerForDisplay (const Handle(NIS_InteractiveObject)&,
+ const Handle(NIS_Drawer)&);
- void objectForDisplay (Handle_NIS_InteractiveObject&,
+ void objectForDisplay (Handle(NIS_InteractiveObject)&,
const NIS_Drawer::DrawType);
- Handle_NIS_Allocator
+ Handle(NIS_Allocator)
compactObjects ();
private:
/**
* Allocator for all data associated with objects.
*/
- Handle_NIS_Allocator myAllocator;
+ Handle(NIS_Allocator) myAllocator;
/**
* The last added object ID.
/**
* Container of InteractiveObject instances.
*/
- NCollection_SparseArray <Handle_NIS_InteractiveObject>
+ NCollection_SparseArray <Handle(NIS_InteractiveObject)>
myObjects;
/**
* List of Views.
*/
- NCollection_List <Handle_NIS_View> myViews;
+ NCollection_List <Handle(NIS_View)> myViews;
/**
* Container of Drawers. There should be one or more Drawers for each type of
* contained InteractiveObject.
*/
- NCollection_Map <Handle_NIS_Drawer> myDrawers;
+ NCollection_Map <Handle(NIS_Drawer)> myDrawers;
/**
* Three maps indicating the state of contained objects:
/**
* Instance of selection filter used for interactive selections.
*/
- Handle_NIS_SelectFilter mySelectFilter;
+ Handle(NIS_SelectFilter) mySelectFilter;
/**
* Current mode of selection.
//purpose :
//=======================================================================
-const Handle_NIS_Drawer& NIS_InteractiveObject::SetDrawer
+const Handle(NIS_Drawer)& NIS_InteractiveObject::SetDrawer
(const Handle(NIS_Drawer)& theDrawer,
const Standard_Boolean setUpdated)
{
//purpose :
//=======================================================================
-void NIS_InteractiveObject::Clone (const Handle_NCollection_BaseAllocator&,
- Handle_NIS_InteractiveObject& theDest) const
+void NIS_InteractiveObject::Clone (const Handle(NCollection_BaseAllocator)&,
+ Handle(NIS_InteractiveObject)& theDest) const
{
if (theDest.IsNull() == Standard_False)
{
//=======================================================================
void NIS_InteractiveObject::CloneWithID
- (const Handle_NCollection_BaseAllocator& theAlloc,
- Handle_NIS_InteractiveObject& theDest)
+ (const Handle(NCollection_BaseAllocator)& theAlloc,
+ Handle(NIS_InteractiveObject)& theDest)
{
Clone(theAlloc, theDest);
theDest->myID = myID;
* the virtual method Clone() should be correctly defined for every interactive
* object subtype. Supposing that MyIOClass inherits MyBaseIOBase :
* @code
- * void MyIOCalss::Clone (const Handle_NCollection_BaseAllocator& theAlloc,
- * Handle_NIS_InteractiveObject& theDest) const
+ * void MyIOCalss::Clone (const Handle(NCollection_BaseAllocator)& theAlloc,
+ * Handle(NIS_InteractiveObject)& theDest) const
* {
* Handle(MyIOClass) aNewObj;
* if (theDest.IsNull()) {
* Reference to the finally stored or found Drawer instance inside
* the Context.
*/
- Standard_EXPORT const Handle_NIS_Drawer&
- SetDrawer (const Handle_NIS_Drawer& theDrawer,
+ Standard_EXPORT const Handle(NIS_Drawer)&
+ SetDrawer (const Handle(NIS_Drawer)& theDrawer,
const Standard_Boolean setUpdated
= Standard_True);
/**
* Query the current drawer.
*/
- inline const Handle_NIS_Drawer&
+ inline const Handle(NIS_Drawer)&
GetDrawer () const
{ return myDrawer; }
* <tt>[in-out]</tt> The target object where the data are copied.
*/
Standard_EXPORT virtual void
- Clone (const Handle_NCollection_BaseAllocator& theAll,
- Handle_NIS_InteractiveObject& theDest) const;
+ Clone (const Handle(NCollection_BaseAllocator)& theAll,
+ Handle(NIS_InteractiveObject)& theDest) const;
/**
* The same as Clone() but also copies the ID.
*/
- Standard_EXPORT void CloneWithID (const Handle_NCollection_BaseAllocator&,
- Handle_NIS_InteractiveObject&);
+ Standard_EXPORT void CloneWithID (const Handle(NCollection_BaseAllocator)&,
+ Handle(NIS_InteractiveObject)&);
/**
* Intersect the InteractiveObject geometry with a line/ray.
private:
// ---------- PRIVATE FIELDS ----------
- Handle_NIS_Drawer myDrawer;
+ Handle(NIS_Drawer) myDrawer;
Standard_Integer myID;
NIS_Drawer::DrawType myDrawType : 3;
NIS_Drawer::DrawType myBaseType : 3;
(const Handle(NIS_InteractiveContext)& theCtx)
{
if (theCtx.IsNull())
- myIter = NCollection_SparseArray <Handle_NIS_InteractiveObject>::Iterator();
+ myIter = NCollection_SparseArray <Handle(NIS_InteractiveObject)>::Iterator();
else
for (myIter.Init (theCtx->myObjects); myIter.More(); myIter.Next())
if (myIter.Value().IsNull() == Standard_False)
#include <NCollection_SparseArray.hxx>
#include <Handle_NIS_InteractiveObject.hxx>
-class Handle_NIS_InteractiveContext;
+class Handle(NIS_InteractiveContext);
/**
* Iterator of objects contained in a NIS_InteractiveContext instance. The
* @param theCtx
* Interactive context that is to be iterated for all objects.
*/
- inline NIS_ObjectsIterator (const Handle_NIS_InteractiveContext& theCtx)
+ inline NIS_ObjectsIterator (const Handle(NIS_InteractiveContext)& theCtx)
{ Initialize (theCtx); }
/**
* Interactive context that is to be iterated for all objects.
*/
Standard_EXPORT void Initialize
- (const Handle_NIS_InteractiveContext& theCtx);
+ (const Handle(NIS_InteractiveContext)& theCtx);
/**
* Query if the Iterator has an object (not yet finished the iteration
* Returns the current object at the iteration pointer. If the iteration is
* over (More() == False) this method returns NULL Handle.
*/
- Standard_EXPORT const Handle_NIS_InteractiveObject&
+ Standard_EXPORT const Handle(NIS_InteractiveObject)&
Value () const;
/**
protected:
// ---------- PROTECTED FIELDS ----------
- NCollection_SparseArray <Handle_NIS_InteractiveObject>::ConstIterator myIter;
+ NCollection_SparseArray <Handle(NIS_InteractiveObject)>::ConstIterator myIter;
};
//purpose :
//=======================================================================
-Standard_Boolean NIS_SelectFilter::ActsOn (const Handle_Standard_Type&) const
+Standard_Boolean NIS_SelectFilter::ActsOn (const Handle(Standard_Type)&) const
{
return Standard_True;
}
#include <Standard_Transient.hxx>
class NIS_InteractiveObject;
-class Handle_Standard_Type;
+class Handle(Standard_Type);
/**
* Interface for selection filters. It can be used in NIS_InteractiveContext by methods SetFilter and GetFilter.
* objects are excluded from Selection before any checking.
*/
Standard_EXPORT virtual Standard_Boolean
- ActsOn (const Handle_Standard_Type& theType) const;
+ ActsOn (const Handle(Standard_Type)& theType) const;
protected:
//purpose : Compare two triangulations, for NCollection_Map interface.
//=======================================================================
-inline Standard_Boolean IsEqual(const Handle_Poly_Triangulation& theT0,
- const Handle_Poly_Triangulation& theT1)
+inline Standard_Boolean IsEqual(const Handle(Poly_Triangulation)& theT0,
+ const Handle(Poly_Triangulation)& theT1)
{
return (theT0 == theT1);
}
//purpose :
//=======================================================================
-NIS_Surface::NIS_Surface(const Handle_NCollection_BaseAllocator& theAlloc)
+NIS_Surface::NIS_Surface(const Handle(NCollection_BaseAllocator)& theAlloc)
: myAlloc (theAlloc),
mypNodes (NULL),
mypNormals (NULL),
//=======================================================================
NIS_Surface::NIS_Surface (const Handle(Poly_Triangulation)& theTri,
- const Handle_NCollection_BaseAllocator& theAlloc)
+ const Handle(NCollection_BaseAllocator)& theAlloc)
: myAlloc (theAlloc),
mypNodes (NULL),
mypNormals (NULL),
NIS_Surface::NIS_Surface (const TopoDS_Shape& theShape,
const Standard_Real theDeflection,
- const Handle_NCollection_BaseAllocator& theAlloc)
+ const Handle(NCollection_BaseAllocator)& theAlloc)
: myAlloc (theAlloc),
mypNodes (NULL),
mypNormals (NULL),
TopLoc_Location aLoc, aLocSurf;
// Count the nodes and triangles in faces
- NCollection_Map<Handle_Poly_Triangulation> mapTri;
+ NCollection_Map<Handle(Poly_Triangulation)> mapTri;
TopExp_Explorer fexp (theShape, TopAbs_FACE);
for (; fexp.More(); fexp.Next())
{
//purpose :
//=======================================================================
-void NIS_Surface::Clone (const Handle_NCollection_BaseAllocator& theAlloc,
- Handle_NIS_InteractiveObject& theDest) const
+void NIS_Surface::Clone (const Handle(NCollection_BaseAllocator)& theAlloc,
+ Handle(NIS_InteractiveObject)& theDest) const
{
Handle(NIS_Surface) aNewObj;
if (theDest.IsNull()) {
#include <gp_XYZ.hxx>
class Quantity_Color;
-class Handle_Poly_Triangulation;
+class Handle(Poly_Triangulation);
class TopoDS_Shape;
/**
/**
* Constructor
*/
- Standard_EXPORT NIS_Surface(const Handle_Poly_Triangulation& theTri,
- const Handle_NCollection_BaseAllocator&
+ Standard_EXPORT NIS_Surface(const Handle(Poly_Triangulation)& theTri,
+ const Handle(NCollection_BaseAllocator)&
theAlloc =0L);
/**
* Constructor. Creates the presentation of all faces in 'theShape' object.
*/
Standard_EXPORT NIS_Surface(const TopoDS_Shape& theShape,
const Standard_Real theDeflection,
- const Handle_NCollection_BaseAllocator& theAl=0L);
+ const Handle(NCollection_BaseAllocator)& theAl=0L);
/**
* Destructor
* passed NULL then the target should be created.
*/
Standard_EXPORT virtual void
- Clone (const Handle_NCollection_BaseAllocator& theAll,
- Handle_NIS_InteractiveObject& theDest) const;
+ Clone (const Handle(NCollection_BaseAllocator)& theAll,
+ Handle(NIS_InteractiveObject)& theDest) const;
/**
* Intersect the surface shading/wireframe geometry with a line/ray.
/**
* Allocator for method Clone().
*/
- Standard_EXPORT NIS_Surface (const Handle_NCollection_BaseAllocator& theAl);
+ Standard_EXPORT NIS_Surface (const Handle(NCollection_BaseAllocator)& theAl);
/**
* Create a 3D bounding box of the object.
gp_XYZ& theNormal) const;
private:
- Handle_NCollection_BaseAllocator myAlloc;
+ Handle(NCollection_BaseAllocator) myAlloc;
//! Array of nodes in triangles
Standard_ShortReal * mypNodes;
//! Array of normals (TriNodes)
//purpose :
//=======================================================================
-void NIS_SurfaceDrawer::Assign (const Handle_NIS_Drawer& theOther)
+void NIS_SurfaceDrawer::Assign (const Handle(NIS_Drawer)& theOther)
{
if (theOther.IsNull() == Standard_False) {
NIS_Drawer::Assign (theOther);
//=======================================================================
Standard_Boolean NIS_SurfaceDrawer::IsEqual
- (const Handle_NIS_Drawer& theOther)const
+ (const Handle(NIS_Drawer)& theOther)const
{
static const Standard_Real anEpsilon2 (1e-7);
Standard_Boolean aResult (Standard_False);
//=======================================================================
void NIS_SurfaceDrawer::redraw (const DrawType theType,
- const Handle_NIS_View& theView)
+ const Handle(NIS_View)& theView)
{
glMatrixMode( GL_MODELVIEW );
glPushMatrix();
//purpose :
//=======================================================================
-void NIS_SurfaceDrawer::Draw (const Handle_NIS_InteractiveObject& theObj,
+void NIS_SurfaceDrawer::Draw (const Handle(NIS_InteractiveObject)& theObj,
const DrawType theType,
const NIS_DrawList&)
{
* Copy the relevant information from another instance of Drawer.
* raises exception if theOther has incompatible type (test IsKind).
*/
- Standard_EXPORT virtual void Assign (const Handle_NIS_Drawer& theOther);
+ Standard_EXPORT virtual void Assign (const Handle(NIS_Drawer)& theOther);
/**
* Called before execution of Draw(), once per group of interactive objects.
/**
* Main function: display the given interactive object in the given view.
*/
- Standard_EXPORT virtual void Draw (const Handle_NIS_InteractiveObject&,
+ Standard_EXPORT virtual void Draw (const Handle(NIS_InteractiveObject)&,
const DrawType theType,
const NIS_DrawList& theDrawList);
* Matching two instances, for Map interface.
*/
Standard_EXPORT virtual Standard_Boolean
- IsEqual (const Handle_NIS_Drawer& theOth)const;
+ IsEqual (const Handle(NIS_Drawer)& theOth)const;
protected:
Standard_EXPORT virtual void redraw (const DrawType theType,
- const Handle_NIS_View& theView);
+ const Handle(NIS_View)& theView);
private:
//purpose :
//=======================================================================
-void NIS_Triangulated::Clone (const Handle_NCollection_BaseAllocator& theAlloc,
- Handle_NIS_InteractiveObject& theDest) const
+void NIS_Triangulated::Clone (const Handle(NCollection_BaseAllocator)& theAlloc,
+ Handle(NIS_InteractiveObject)& theDest) const
{
Handle(NIS_Triangulated) aNewObj;
if (theDest.IsNull()) {
#include <NIS_InteractiveObject.hxx>
#include <Quantity_Color.hxx>
-class Handle_NIS_TriangulatedDrawer;
+class Handle(NIS_TriangulatedDrawer);
class NCollection_BaseAllocator;
-class Handle_NCollection_BaseAllocator;
+class Handle(NCollection_BaseAllocator);
class NIS_TriangulatedDrawer;
/**
*/
Standard_EXPORT NIS_Triangulated(const Standard_Integer nNodes = 0,
const Standard_Boolean is2D = Standard_False,
- const Handle_NCollection_BaseAllocator&
+ const Handle(NCollection_BaseAllocator)&
theAlloc = 0L);
/**
* passed NULL then the target should be created.
*/
Standard_EXPORT virtual void
- Clone (const Handle_NCollection_BaseAllocator& theAll,
- Handle_NIS_InteractiveObject& theDest) const;
+ Clone (const Handle(NCollection_BaseAllocator)& theAll,
+ Handle(NIS_InteractiveObject)& theDest) const;
/**
* Intersect the InteractiveObject geometry with a line/ray.
//purpose :
//=======================================================================
-void NIS_TriangulatedDrawer::Assign (const Handle_NIS_Drawer& theOther)
+void NIS_TriangulatedDrawer::Assign (const Handle(NIS_Drawer)& theOther)
{
if (theOther.IsNull() == Standard_False) {
NIS_Drawer::Assign (theOther);
//=======================================================================
Standard_Boolean NIS_TriangulatedDrawer::IsEqual
- (const Handle_NIS_Drawer& theOther)const
+ (const Handle(NIS_Drawer)& theOther)const
{
static const Standard_Real anEpsilon2 (1e-7);
Standard_Boolean aResult (Standard_False);
//purpose :
//=======================================================================
-void NIS_TriangulatedDrawer::Draw (const Handle_NIS_InteractiveObject& theObj,
+void NIS_TriangulatedDrawer::Draw (const Handle(NIS_InteractiveObject)& theObj,
const DrawType /*theType*/,
const NIS_DrawList&)
{
* Copy the relevant information from another instance of Drawer.
* raises exception if theOther has incompatible type (test IsKind).
*/
- Standard_EXPORT virtual void Assign (const Handle_NIS_Drawer& theOther);
+ Standard_EXPORT virtual void Assign (const Handle(NIS_Drawer)& theOther);
/**
* Called before execution of Draw(), once per group of interactive objects.
/**
* Main function: display the given interactive object in the given view.
*/
- Standard_EXPORT virtual void Draw (const Handle_NIS_InteractiveObject&,
+ Standard_EXPORT virtual void Draw (const Handle(NIS_InteractiveObject)&,
const DrawType theType,
const NIS_DrawList& theDrawList);
* Matching two instances, for Map interface.
*/
Standard_EXPORT virtual Standard_Boolean
- IsEqual (const Handle_NIS_Drawer& theOth)const;
+ IsEqual (const Handle(NIS_Drawer)& theOth)const;
protected:
/**
break;
}
- NCollection_Map<Handle_NIS_Drawer>::Iterator anIterD (theCtx->GetDrawers ());
+ NCollection_Map<Handle(NIS_Drawer)>::Iterator anIterD (theCtx->GetDrawers ());
for (; anIterD.More(); anIterD.Next()) {
const Handle(NIS_Drawer)& aDrawer = anIterD.Value();
if (aDrawer.IsNull() == Standard_False) {
Bnd_B3f aBox;
NCollection_List<NIS_InteractiveContext *>::Iterator anIterC (myContexts);
for (; anIterC.More(); anIterC.Next()) {
- NCollection_Map<Handle_NIS_Drawer>::Iterator anIterD
+ NCollection_Map<Handle(NIS_Drawer)>::Iterator anIterD
(anIterC.Value()->myDrawers);
for (; anIterD.More(); anIterD.Next()) {
const Handle(NIS_Drawer)& aDrawer = anIterD.Value();
//purpose :
//=======================================================================
-void NIS_View::DynamicUnhilight(const Handle_NIS_InteractiveObject& theObj)
+void NIS_View::DynamicUnhilight(const Handle(NIS_InteractiveObject)& theObj)
{
if (theObj == myDynHilighted && theObj.IsNull() == Standard_False) {
const Handle(NIS_View) aView (this);
//purpose :
//=======================================================================
-Handle_NIS_InteractiveObject NIS_View::Pick (const Standard_Integer theX,
+Handle(NIS_InteractiveObject) NIS_View::Pick (const Standard_Integer theX,
const Standard_Integer theY)
{
// Find the ray passing through the clicked point in the view window.
//purpose :
//=======================================================================
-Handle_NIS_InteractiveObject NIS_View::Pick
+Handle(NIS_InteractiveObject) NIS_View::Pick
(const gp_Ax1& theAxis,
const Standard_Real theOver,
const Standard_Boolean isOnlySelectable)
/**
* Attach the view to the window.
*/
- Standard_EXPORT NIS_View (const Handle_V3d_Viewer& theViewer,
- const Handle_Aspect_Window& theWindow = NULL);
+ Standard_EXPORT NIS_View (const Handle(V3d_Viewer)& theViewer,
+ const Handle(Aspect_Window)& theWindow = NULL);
/**
* Attach the view to the window.
*/
- Standard_EXPORT void SetWindow(const Handle_Aspect_Window &theWindow);
+ Standard_EXPORT void SetWindow(const Handle(Aspect_Window) &theWindow);
/**
* Indicate whether to draw hilighted objects on top of all other ones
* Unhilights the hilighted object if it coincides with the given
* object instance.
*/
- Standard_EXPORT void DynamicUnhilight(const Handle_NIS_InteractiveObject&);
+ Standard_EXPORT void DynamicUnhilight(const Handle(NIS_InteractiveObject)&);
/**
* Unhilights the currently hilighted object.
* the selected object picked by the minimal intersection distance among
* all contexts attached to this View.
*/
- Standard_EXPORT Handle_NIS_InteractiveObject
+ Standard_EXPORT Handle(NIS_InteractiveObject)
Pick (const Standard_Integer theX,
const Standard_Integer theY);
* the selected object picked by the minimal intersection distance among
* all contexts attached to this View.
*/
- Standard_EXPORT Handle_NIS_InteractiveObject
+ Standard_EXPORT Handle(NIS_InteractiveObject)
Pick (const gp_Ax1& theAxis,
const Standard_Real theOver,
const Standard_Boolean isOnlySel);
// ---------- PRIVATE FIELDS ----------
NCollection_List<NIS_InteractiveContext *> myContexts;
- Handle_NIS_InteractiveObject myDynHilighted;
+ Handle(NIS_InteractiveObject) myDynHilighted;
Standard_Boolean myIsTopHilight : 1;
Standard_Boolean myDoHilightSelected : 1;
NCollection_Vector<NIS_InteractiveObject *> myDetected;
struct OpenGl_CView
{
- Handle_OpenGl_Workspace WS;
- Handle_OpenGl_View View;
+ Handle(OpenGl_Workspace) WS;
+ Handle(OpenGl_View) View;
DEFINE_STANDARD_ALLOC
};
public:
//! @return messenger instance
- inline const Handle_Message_Messenger& Messenger() const
+ inline const Handle(Message_Messenger)& Messenger() const
{
return ::Message::DefaultMessenger();
}
//============================================================================
#ifndef CSFDB
class _Oid_PMMgt_PManaged : public Oid_PMMgt_PManaged {
- friend class Handle_PMMgt_PManaged;
+ friend class Handle(PMMgt_PManaged);
};
-void Handle_PMMgt_PManaged::Delete()
+void Handle(PMMgt_PManaged)::Delete()
{
// PMMgt_PManaged* aMng;
_Oid_PMMgt_PManaged *aOid;
inline Standard_Integer PNaming_Name::ShapeType() const
{return myShapeType;}
-inline Handle_PNaming_HArray1OfNamedShape PNaming_Name::Arguments() const
+inline Handle(PNaming_HArray1OfNamedShape) PNaming_Name::Arguments() const
{return myArgs;}
-inline Handle_PNaming_NamedShape PNaming_Name::StopNamedShape() const
+inline Handle(PNaming_NamedShape) PNaming_Name::StopNamedShape() const
{return myStop;}
inline Standard_Integer PNaming_Name::Index() const
inline Standard_Integer PNaming_Name_1::ShapeType() const
{return myShapeType;}
-inline Handle_PNaming_HArray1OfNamedShape PNaming_Name_1::Arguments() const
+inline Handle(PNaming_HArray1OfNamedShape) PNaming_Name_1::Arguments() const
{return myArgs;}
-inline Handle_PNaming_NamedShape PNaming_Name_1::StopNamedShape() const
+inline Handle(PNaming_NamedShape) PNaming_Name_1::StopNamedShape() const
{return myStop;}
inline Standard_Integer PNaming_Name_1::Index() const
inline Standard_Integer PNaming_Name_2::ShapeType() const
{return myShapeType;}
-inline Handle_PNaming_HArray1OfNamedShape PNaming_Name_2::Arguments() const
+inline Handle(PNaming_HArray1OfNamedShape) PNaming_Name_2::Arguments() const
{return myArgs;}
-inline Handle_PNaming_NamedShape PNaming_Name_2::StopNamedShape() const
+inline Handle(PNaming_NamedShape) PNaming_Name_2::StopNamedShape() const
{return myStop;}
inline Standard_Integer PNaming_Name_2::Index() const
// the polynomial part of the Plate function
//=======================================================================
- void Plate_Plate::CoefPol(Handle_TColgp_HArray2OfXYZ& Coefs) const
+ void Plate_Plate::CoefPol(Handle(TColgp_HArray2OfXYZ)& Coefs) const
{
Coefs = new TColgp_HArray2OfXYZ(0,order-1,0,order-1,gp_XYZ(0.,0.,0.));
Standard_Integer i = n_el;
//purpose :
//=======================================================================
-void Poly_CoherentNode::Clear (const Handle_NCollection_BaseAllocator& theAlloc)
+void Poly_CoherentNode::Clear (const Handle(NCollection_BaseAllocator)& theAlloc)
{
Poly_CoherentTriPtr::RemoveList (myTriangles, theAlloc);
myUV[0] = Precision::Infinite();
void Poly_CoherentNode::AddTriangle
(const Poly_CoherentTriangle& theTri,
- const Handle_NCollection_BaseAllocator& theAlloc)
+ const Handle(NCollection_BaseAllocator)& theAlloc)
{
if (myTriangles == NULL)
myTriangles = new (theAlloc) Poly_CoherentTriPtr(theTri);
Standard_Boolean Poly_CoherentNode::RemoveTriangle
(const Poly_CoherentTriangle& theTri,
- const Handle_NCollection_BaseAllocator& theAlloc)
+ const Handle(NCollection_BaseAllocator)& theAlloc)
{
Standard_Boolean aResult(Standard_False);
if (&myTriangles->GetTriangle() == &theTri) {
/**
* Reset the Node to void.
*/
- Standard_EXPORT void Clear (const Handle_NCollection_BaseAllocator&);
+ Standard_EXPORT void Clear (const Handle(NCollection_BaseAllocator)&);
/**
* Connect a triangle to this Node.
*/
Standard_EXPORT void AddTriangle
(const Poly_CoherentTriangle& theTri,
- const Handle_NCollection_BaseAllocator& theA);
+ const Handle(NCollection_BaseAllocator)& theA);
/**
* Disconnect a triangle from this Node.
Standard_EXPORT Standard_Boolean
RemoveTriangle
(const Poly_CoherentTriangle& theTri,
- const Handle_NCollection_BaseAllocator& theA);
+ const Handle(NCollection_BaseAllocator)& theA);
/**
* Create an iterator of incident triangles.
void Poly_CoherentTriPtr::Append
(const Poly_CoherentTriangle * pTri,
- const Handle_NCollection_BaseAllocator& theAlloc)
+ const Handle(NCollection_BaseAllocator)& theAlloc)
{
Handle(NCollection_BaseAllocator) anAlloc = theAlloc;
if (theAlloc.IsNull())
void Poly_CoherentTriPtr::Prepend
(const Poly_CoherentTriangle * pTri,
- const Handle_NCollection_BaseAllocator& theAlloc)
+ const Handle(NCollection_BaseAllocator)& theAlloc)
{
Handle(NCollection_BaseAllocator) anAlloc = theAlloc;
if (theAlloc.IsNull())
void Poly_CoherentTriPtr::Remove
(Poly_CoherentTriPtr * thePtr,
- const Handle_NCollection_BaseAllocator& theAlloc)
+ const Handle(NCollection_BaseAllocator)& theAlloc)
{
Handle(NCollection_BaseAllocator) anAlloc = theAlloc;
if (theAlloc.IsNull())
void Poly_CoherentTriPtr::RemoveList
(Poly_CoherentTriPtr * thePtr,
- const Handle_NCollection_BaseAllocator& theAlloc)
+ const Handle(NCollection_BaseAllocator)& theAlloc)
{
Handle(NCollection_BaseAllocator) anAlloc = theAlloc;
if (theAlloc.IsNull())
* Allocator where the new pointer instance is created.
*/
Standard_EXPORT void Append (const Poly_CoherentTriangle * pTri,
- const Handle_NCollection_BaseAllocator& theA);
+ const Handle(NCollection_BaseAllocator)& theA);
/**
* Prepend a pointer to triangle into the list before the current instance.
* Allocator where the new pointer instance is created.
*/
Standard_EXPORT void Prepend (const Poly_CoherentTriangle * pTri,
- const Handle_NCollection_BaseAllocator& theA);
+ const Handle(NCollection_BaseAllocator)& theA);
/**
* Remove a pointer to triangle from its list.
*/
Standard_EXPORT static void
Remove (Poly_CoherentTriPtr * thePtr,
- const Handle_NCollection_BaseAllocator& theA);
+ const Handle(NCollection_BaseAllocator)& theA);
/**
* Remove the list containing the given pointer to triangle.
*/
Standard_EXPORT static void
RemoveList (Poly_CoherentTriPtr * thePtr,
- const Handle_NCollection_BaseAllocator&);
+ const Handle(NCollection_BaseAllocator)&);
protected:
// ---------- PROTECTED METHODS ----------
//=======================================================================
Poly_CoherentTriangulation::Poly_CoherentTriangulation
- (const Handle_NCollection_BaseAllocator& theAlloc)
+ (const Handle(NCollection_BaseAllocator)& theAlloc)
: myAlloc (theAlloc.IsNull() ? NCollection_BaseAllocator::CommonBaseAllocator()
: theAlloc),
myDeflection (0.)
Poly_CoherentTriangulation::Poly_CoherentTriangulation
(const Handle(Poly_Triangulation)& theTriangulation,
- const Handle_NCollection_BaseAllocator& theAlloc)
+ const Handle(NCollection_BaseAllocator)& theAlloc)
: myAlloc (theAlloc.IsNull() ? NCollection_BaseAllocator::CommonBaseAllocator()
: theAlloc)
{
//purpose :
//=======================================================================
-Handle_Poly_Triangulation Poly_CoherentTriangulation::GetTriangulation() const
+Handle(Poly_Triangulation) Poly_CoherentTriangulation::GetTriangulation() const
{
Handle(Poly_Triangulation) aResult;
const Standard_Integer nNodes = NNodes();
//=======================================================================
Poly_CoherentTriangulation::IteratorOfTriangle::IteratorOfTriangle
- (const Handle_Poly_CoherentTriangulation& theTri)
+ (const Handle(Poly_CoherentTriangulation)& theTri)
{
if (!theTri.IsNull()) {
Init(theTri->myTriangles);
//=======================================================================
Poly_CoherentTriangulation::IteratorOfNode::IteratorOfNode
- (const Handle_Poly_CoherentTriangulation& theTri)
+ (const Handle(Poly_CoherentTriangulation)& theTri)
{
if (!theTri.IsNull()) {
Init(theTri->myNodes);
//=======================================================================
Poly_CoherentTriangulation::IteratorOfLink::IteratorOfLink
- (const Handle_Poly_CoherentTriangulation& theTri)
+ (const Handle(Poly_CoherentTriangulation)& theTri)
{
if (!theTri.IsNull()) {
Init(theTri->myLinks);
//=======================================================================
Handle(Poly_CoherentTriangulation) Poly_CoherentTriangulation::Clone
- (const Handle_NCollection_BaseAllocator& theAlloc) const
+ (const Handle(NCollection_BaseAllocator)& theAlloc) const
{
Handle(Poly_CoherentTriangulation) newTri;
#include <Poly_CoherentLink.hxx>
#include <NCollection_Vector.hxx>
-class Handle_Poly_CoherentTriangulation;
+class Handle(Poly_CoherentTriangulation);
class Poly_CoherentTriangulation;
template <class A> class NCollection_List;
public:
//! Constructor
Standard_EXPORT IteratorOfTriangle
- (const Handle_Poly_CoherentTriangulation& theTri);
+ (const Handle(Poly_CoherentTriangulation)& theTri);
//! Make step
Standard_EXPORT virtual void Next ();
};
public:
//! Constructor
Standard_EXPORT IteratorOfNode
- (const Handle_Poly_CoherentTriangulation& theTri);
+ (const Handle(Poly_CoherentTriangulation)& theTri);
//! Make step
Standard_EXPORT virtual void Next ();
};
public:
//! Constructor
Standard_EXPORT IteratorOfLink
- (const Handle_Poly_CoherentTriangulation& theTri);
+ (const Handle(Poly_CoherentTriangulation)& theTri);
//! Make step
Standard_EXPORT virtual void Next ();
};
* Empty constructor.
*/
Standard_EXPORT Poly_CoherentTriangulation
- (const Handle_NCollection_BaseAllocator& theAlloc = 0L);
+ (const Handle(NCollection_BaseAllocator)& theAlloc = 0L);
/**
* Constructor. It does not create Links, you should call ComputeLinks
* following this constructor if you need these links.
*/
Standard_EXPORT Poly_CoherentTriangulation
- (const Handle_Poly_Triangulation& theTriangulation,
- const Handle_NCollection_BaseAllocator& theAlloc = 0L);
+ (const Handle(Poly_Triangulation)& theTriangulation,
+ const Handle(NCollection_BaseAllocator)& theAlloc = 0L);
/**
* Destructor.
/**
* Create an instance of Poly_Triangulation from this object.
*/
- Standard_EXPORT Handle_Poly_Triangulation
+ Standard_EXPORT Handle(Poly_Triangulation)
GetTriangulation () const;
/**
* Query the allocator of elements, this allocator can be used for other
* objects
*/
- inline const Handle_NCollection_BaseAllocator&
+ inline const Handle(NCollection_BaseAllocator)&
Allocator () const
{
return myAlloc;
/**
* Create a copy of this Triangulation, using the given allocator.
*/
- Standard_EXPORT Handle_Poly_CoherentTriangulation Clone
- (const Handle_NCollection_BaseAllocator& theAlloc) const;
+ Standard_EXPORT Handle(Poly_CoherentTriangulation) Clone
+ (const Handle(NCollection_BaseAllocator)& theAlloc) const;
/**
* Debugging output.
NCollection_Vector<Poly_CoherentTriangle> myTriangles;
NCollection_Vector<Poly_CoherentNode> myNodes;
NCollection_Vector<Poly_CoherentLink> myLinks;
- Handle_NCollection_BaseAllocator myAlloc;
+ Handle(NCollection_BaseAllocator) myAlloc;
Standard_Real myDeflection;
public:
* List of Poly_Triangulation instances.
*/
-typedef NCollection_List<Handle_Poly_Triangulation> Poly_ListOfTriangulation;
+typedef NCollection_List<Handle(Poly_Triangulation)> Poly_ListOfTriangulation;
#endif
//=======================================================================
Poly_MakeLoops::Poly_MakeLoops(const Helper* theHelper,
- const Handle_NCollection_BaseAllocator& theAlloc)
+ const Handle(NCollection_BaseAllocator)& theAlloc)
: myHelper (theHelper),
myAlloc (theAlloc),
myMapLink (4000, myAlloc),
void Poly_MakeLoops::Reset
(const Helper* theHelper,
- const Handle_NCollection_BaseAllocator& theAlloc)
+ const Handle(NCollection_BaseAllocator)& theAlloc)
{
myHelper = theHelper;
myMapLink.Clear();
Standard_Integer Poly_MakeLoops::findContour
(Standard_Integer theIndexS,
NCollection_IndexedMap<Standard_Integer> &theContour,
- const Handle_NCollection_BaseAllocator& theTempAlloc,
- const Handle_NCollection_IncAllocator& theTempAlloc1) const
+ const Handle(NCollection_BaseAllocator)& theTempAlloc,
+ const Handle(NCollection_IncAllocator)& theTempAlloc1) const
{
theContour.Clear();
Standard_Integer aStartIndex = 0;
//=======================================================================
Poly_MakeLoops3D::Poly_MakeLoops3D(const Helper* theHelper,
- const Handle_NCollection_BaseAllocator& theAlloc)
+ const Handle(NCollection_BaseAllocator)& theAlloc)
: Poly_MakeLoops (theHelper, theAlloc)
{
}
Poly_MakeLoops2D::Poly_MakeLoops2D(const Standard_Boolean theLeftWay,
const Helper* theHelper,
- const Handle_NCollection_BaseAllocator& theAlloc)
+ const Handle(NCollection_BaseAllocator)& theAlloc)
: Poly_MakeLoops (theHelper, theAlloc),
myRightWay(!theLeftWay)
{
#include <NCollection_BaseAllocator.hxx>
#include <NCollection_List.hxx>
-class Handle_NCollection_IncAllocator;
+class Handle(NCollection_IncAllocator);
/**
* Make loops from a set of connected links. A link is represented by
//! Constructor. If helper is NULL then the algorithm will
//! probably return a wrong result
Standard_EXPORT Poly_MakeLoops(const Helper* theHelper,
- const Handle_NCollection_BaseAllocator& theAlloc = 0L);
+ const Handle(NCollection_BaseAllocator)& theAlloc = 0L);
//! It is to reset the algorithm to the initial state.
Standard_EXPORT void Reset
(const Helper* theHelper,
- const Handle_NCollection_BaseAllocator& theAlloc = 0L);
+ const Handle(NCollection_BaseAllocator)& theAlloc = 0L);
//! Adds a link to the set. theOrient defines which orientations of the link
//! are allowed.
private:
int findContour(Standard_Integer theIndexS, NCollection_IndexedMap<Standard_Integer>& theContour,
- const Handle_NCollection_BaseAllocator& theTempAlloc,
- const Handle_NCollection_IncAllocator& theTempAlloc1) const;
+ const Handle(NCollection_BaseAllocator)& theTempAlloc,
+ const Handle(NCollection_IncAllocator)& theTempAlloc1) const;
void acceptContour(const NCollection_IndexedMap<Standard_Integer>& theContour,
Standard_Integer theStartNumber);
Standard_Integer getFirstNode(Standard_Integer theIndexS) const;
// FIELDS
const Helper* myHelper;
- Handle_NCollection_BaseAllocator myAlloc;
+ Handle(NCollection_BaseAllocator) myAlloc;
NCollection_IndexedMap<Link> myMapLink;
NCollection_Sequence<Loop> myLoops;
HeapOfInteger myStartIndices;
//! Constructor. If helper is NULL then the algorithm will
//! probably return a wrong result
Standard_EXPORT Poly_MakeLoops3D(const Helper* theHelper,
- const Handle_NCollection_BaseAllocator& theAlloc);
+ const Handle(NCollection_BaseAllocator)& theAlloc);
protected:
Standard_EXPORT virtual Standard_Integer chooseLeftWay
//! probably return a wrong result
Standard_EXPORT Poly_MakeLoops2D(const Standard_Boolean theLeftWay,
const Helper* theHelper,
- const Handle_NCollection_BaseAllocator& theAlloc);
+ const Handle(NCollection_BaseAllocator)& theAlloc);
protected:
Standard_EXPORT virtual Standard_Integer chooseLeftWay
{
myTolerance = tol3d; //OCC217
//myTolerance = Max(tolerance,Precision::PApproximation());
- const Handle_Adaptor2d_HCurve2d InitCurve2d ;
+ const Handle(Adaptor2d_HCurve2d) InitCurve2d ;
myBSpline = Perform(InitCurve2d,Curve,S);
}
// function : FaceBoundaryAspect
// purpose :
// =======================================================================
-Handle_Prs3d_LineAspect Prs3d_Drawer::FaceBoundaryAspect ()
+Handle(Prs3d_LineAspect) Prs3d_Drawer::FaceBoundaryAspect ()
{
if (myFaceBoundaryAspect.IsNull ())
{
//purpose :
//=======================================================================
-void Prs3d_Presentation::Compute(const Handle_Graphic3d_DataStructureManager& aDataStruct,
- Handle_Graphic3d_Structure& aStruct)
+void Prs3d_Presentation::Compute(const Handle(Graphic3d_DataStructureManager)& aDataStruct,
+ Handle(Graphic3d_Structure)& aStruct)
{
Graphic3d_Structure::Compute(aDataStruct,aStruct );
}
//purpose :
//=======================================================================
-Handle_Graphic3d_Structure Prs3d_Presentation::Compute(const Handle_Graphic3d_DataStructureManager& aDataStruc,
+Handle(Graphic3d_Structure) Prs3d_Presentation::Compute(const Handle(Graphic3d_DataStructureManager)& aDataStruc,
const TColStd_Array2OfReal& anArray)
{
return Graphic3d_Structure::Compute(aDataStruc,anArray);
//purpose :
//=======================================================================
-void Prs3d_Presentation::Compute(const Handle_Graphic3d_DataStructureManager& aDataStruc,
+void Prs3d_Presentation::Compute(const Handle(Graphic3d_DataStructureManager)& aDataStruc,
const TColStd_Array2OfReal& anArray,
- Handle_Graphic3d_Structure& aStruc)
+ Handle(Graphic3d_Structure)& aStruc)
{
Graphic3d_Structure::Compute(aDataStruc,anArray,aStruc);
}
TopoDS_Shape ShapeCut = aBoolenaOperation.Shape();
//#ifdef OCC40
-// Handle_TopOpeBRepBuild_HBuilder build = aBoolenaOperation.Builder();
+// Handle(TopOpeBRepBuild_HBuilder) build = aBoolenaOperation.Builder();
//#endif
TopTools_ListIteratorOfListOfShape its;
TopoDS_Shape theCylinder3 = BRepPrimAPI_MakeCylinder(gp_Ax2(gp_Pnt(0, - 10, 0),
gp_Dir(0, 1, 0)), 3, 20).Shape();
TopoDS_Shape theTmp1 = OCC1077_cut_blend(theCommon,theCylinder1,0.7);
- Handle_ShapeFix_Shape fixer = new ShapeFix_Shape(theTmp1);
+ Handle(ShapeFix_Shape) fixer = new ShapeFix_Shape(theTmp1);
fixer->Perform();
theTmp1 = fixer->Shape();
TopoDS_Shape theTmp2 = OCC1077_cut_blend(theTmp1,theCylinder2,0.7);
nCount = Draw::Atoi(argv[1]);
TCollection_AsciiString aFilePath = argv[2];
STEPCAFControl_Writer writer;
- Handle_TDocStd_Document document;
+ Handle(TDocStd_Document) document;
document = new TDocStd_Document("Pace Test-StepExporter-");
- Handle_XCAFDoc_ShapeTool shapeTool;
+ Handle(XCAFDoc_ShapeTool) shapeTool;
shapeTool = XCAFDoc_DocumentTool::ShapeTool(document->Main());
shapeTool->AddShape(AddTestStructure(nCount), Standard_True);
STEPControl_StepModelType mode = STEPControl_AsIs;
gp_Circ circ1 = makeCirc1.Value();
GC_MakeArcOfCircle makeArc1(circ1, 0, M_PI/2, Standard_True);
if(!makeArc1.IsDone()) return 1;
- Handle_Geom_TrimmedCurve arc1 = makeArc1.Value();
+ Handle(Geom_TrimmedCurve) arc1 = makeArc1.Value();
// Create wire 1
BRepBuilderAPI_MakeEdge makeEdge1(arc1, arc1->StartPoint(), arc1->EndPoint());
gp_Circ circ2 = makeCirc2.Value();
GC_MakeArcOfCircle makeArc2(circ2, 0, M_PI/2, Standard_True);
if(!makeArc2.IsDone()) return 1;
- Handle_Geom_TrimmedCurve arc2 = makeArc2.Value();
+ Handle(Geom_TrimmedCurve) arc2 = makeArc2.Value();
// Create wire 2
BRepBuilderAPI_MakeEdge makeEdge2(arc2, arc2->StartPoint(), arc2->EndPoint());
TopExp_Explorer spineWireExp(spineWire, TopAbs_EDGE);
Standard_Real first, last;
- Handle_Geom_Curve curl_ = BRep_Tool::Curve(TopoDS::Edge(spineWireExp.Current()), first, last);
+ Handle(Geom_Curve) curl_ = BRep_Tool::Curve(TopoDS::Edge(spineWireExp.Current()), first, last);
gp_Pnt firstPnt;
gp_Vec tanVec;
curl_->D1(first, firstPnt, tanVec);
BRepPrimAPI_MakeBox box2(gp_Pnt(120, 120, 120), gp_Pnt(300, 300,300));
BRepPrimAPI_MakeBox box3(gp_Pnt(320, 320, 320), gp_Pnt(500, 500,500));
- Handle_AIS_Shape ais1 = new AIS_Shape(box1.Shape());
- Handle_AIS_Shape ais2 = new AIS_Shape(box2.Shape());
- Handle_AIS_Shape ais3 = new AIS_Shape(box3.Shape());
+ Handle(AIS_Shape) ais1 = new AIS_Shape(box1.Shape());
+ Handle(AIS_Shape) ais2 = new AIS_Shape(box2.Shape());
+ Handle(AIS_Shape) ais3 = new AIS_Shape(box3.Shape());
aContext->Display(ais1);
aContext->Display(ais2);
while(aContext->MoreCurrent())
{
di << "\n count is = " << count++;
- Handle_AIS_InteractiveObject ais = aContext->Current();
+ Handle(AIS_InteractiveObject) ais = aContext->Current();
aContext->AddOrRemoveCurrentObject(ais);
aContext->InitCurrent();
}
static int geom_get_2Dpt_from_3Dpt(const gp_Pnt& pnt3d, const gp_Pln& pln, gp_Pnt2d& pnt2d)
{
int ret = 0;
- Handle_Geom_Plane gpln = new Geom_Plane(pln);
+ Handle(Geom_Plane) gpln = new Geom_Plane(pln);
GeomAdaptor_Surface adsur(gpln);
Extrema_ExtPS extps(pnt3d, adsur, 0.001, 0.001);
if( extps.IsDone() )
static Standard_Integer OCC353 (Draw_Interpretor& di, Standard_Integer , const char ** )
{
gp_Ax2 ax21( gp_Pnt(100,0,0), gp_Dir(0,0,1) );
- Handle_Geom_Circle h_cir1 = new Geom_Circle( ax21, 25 );
+ Handle(Geom_Circle) h_cir1 = new Geom_Circle( ax21, 25 );
gp_Ax2 ax22( gp_Pnt(-100,0,0), gp_Dir(0,0,1) );
- Handle_Geom_Circle h_cir2 = new Geom_Circle( ax22, 25 );
+ Handle(Geom_Circle) h_cir2 = new Geom_Circle( ax22, 25 );
gp_Pln refpln( gp_Pnt(0,0,0), gp_Dir(0,0,1) );
- Handle_Geom2d_Curve cir2d1 = GeomAPI::To2d(h_cir1, refpln);
- Handle_Geom2d_Curve cir2d2 = GeomAPI::To2d(h_cir2, refpln);
+ Handle(Geom2d_Curve) cir2d1 = GeomAPI::To2d(h_cir1, refpln);
+ Handle(Geom2d_Curve) cir2d2 = GeomAPI::To2d(h_cir2, refpln);
Geom2dAdaptor_Curve adop1(cir2d1);
Geom2dAdaptor_Curve adop2(cir2d2);
Geom2dGcc_QualifiedCurve qcur1(adop1, GccEnt_enclosing);
Geom2dGcc_QualifiedCurve qcur2(adop2, GccEnt_enclosing);
- Handle_Geom_CartesianPoint h_carpt = new Geom_CartesianPoint(0,175,0);
+ Handle(Geom_CartesianPoint) h_carpt = new Geom_CartesianPoint(0,175,0);
gp_Pnt pt3d = h_carpt->Pnt();
gp_Pnt2d pt2d;
st = "pt2d";
DrawTrSurf::Set(st,pt2d);
- Handle_Geom2d_CartesianPoint pt = new Geom2d_CartesianPoint(pt2d);
+ Handle(Geom2d_CartesianPoint) pt = new Geom2d_CartesianPoint(pt2d);
Geom2dGcc_Circ2d3Tan sol( qcur1, qcur2, pt, 0.001, 0.0, 0.0);
int res = 0;
builder.Add(comp, cs1);
builder.Add(comp, cs2);
- Handle_AIS_Shape ais = new AIS_Shape(comp);
+ Handle(AIS_Shape) ais = new AIS_Shape(comp);
aContext->Display(ais);
TopExp_Explorer exp(comp, TopAbs_COMPSOLID);
BRepPrimAPI_MakeBox box2(gp_Pnt(120, 120, 120), gp_Pnt(300, 300,300));
BRepPrimAPI_MakeBox box3(gp_Pnt(320, 320, 320), gp_Pnt(500, 500,500));
- Handle_AIS_Shape ais1 = new AIS_Shape(box1.Shape());
- Handle_AIS_Shape ais2 = new AIS_Shape(box2.Shape());
- Handle_AIS_Shape ais3 = new AIS_Shape(box3.Shape());
+ Handle(AIS_Shape) ais1 = new AIS_Shape(box1.Shape());
+ Handle(AIS_Shape) ais2 = new AIS_Shape(box2.Shape());
+ Handle(AIS_Shape) ais3 = new AIS_Shape(box3.Shape());
aContext->Display(ais1);
aContext->Display(ais2);
while(aContext->MoreSelected())
{
di << "\n count is = %d" << count++;
- Handle_AIS_InteractiveObject ais = aContext->SelectedInteractive();
+ Handle(AIS_InteractiveObject) ais = aContext->SelectedInteractive();
aContext->AddOrRemoveSelected(ais);
aContext->InitSelected();
}
BRepPrimAPI_MakeBox box2(gp_Pnt(120, 120, 120), gp_Pnt(300, 300, 300));
BRepPrimAPI_MakeBox box3(gp_Pnt(320, 320, 320), gp_Pnt(500, 500, 500));
- Handle_AIS_Shape ais1 = new AIS_Shape(box1.Shape());
- Handle_AIS_Shape ais2 = new AIS_Shape(box2.Shape());
- Handle_AIS_Shape ais3 = new AIS_Shape(box3.Shape());
+ Handle(AIS_Shape) ais1 = new AIS_Shape(box1.Shape());
+ Handle(AIS_Shape) ais2 = new AIS_Shape(box2.Shape());
+ Handle(AIS_Shape) ais3 = new AIS_Shape(box3.Shape());
aContext1->Display(ais1);
aContext1->Display(ais2);
while(aContext1->MoreCurrent())
{
di << "\n count1 is = " << count1++;
- Handle_AIS_InteractiveObject ais = aContext1->Current();
+ Handle(AIS_InteractiveObject) ais = aContext1->Current();
aContext1->AddOrRemoveCurrentObject(ais);
aContext1->InitCurrent();
}
while(aContext2->MoreCurrent())
{
di << "\n count2 is = " << count2++;
- Handle_AIS_InteractiveObject ais = aContext2->Current();
+ Handle(AIS_InteractiveObject) ais = aContext2->Current();
aContext2->AddOrRemoveCurrentObject(ais);
aContext2->InitCurrent();
}
BRepBuilderAPI_MakeFace face(twire);
TopoDS_Face tface = face.Face();
- ////////Handle_AIS_Shape face_ais = new AIS_Shape( tface );
+ ////////Handle(AIS_Shape) face_ais = new AIS_Shape( tface );
////////aContext->Display(face_ais);
TopoDS_Solid box;
for(int i=1; i<=poles; i++)
arr.SetValue(i, gp_Pnt(i+10, i*2+20, i*3+45));
- Handle_Geom_BezierCurve bez = new Geom_BezierCurve(arr);
+ Handle(Geom_BezierCurve) bez = new Geom_BezierCurve(arr);
if(bez.IsNull()) {
di << "\n The curve is not created.\n";
} else {
di << "\n Degree = " << bez->Degree() << "\n";
}
TopoDS_Edge sh = BRepBuilderAPI_MakeEdge(bez).Edge();
- Handle_AIS_Shape ais = new AIS_Shape(sh);
+ Handle(AIS_Shape) ais = new AIS_Shape(sh);
aContext->Display(ais);
DrawTrSurf::Set(argv[2],bez);
return 0;
}
- Handle_ShapeFix_Wire sfw = new ShapeFix_Wire;
+ Handle(ShapeFix_Wire) sfw = new ShapeFix_Wire;
sfw->Load(TopoDS::Wire(wire));
sfw->SetFace(face);
sfw->SetPrecision(Precision::Confusion());
return 1;
}
- Handle_Geom_Plane plane(new Geom_Plane(
+ Handle(Geom_Plane) plane(new Geom_Plane(
gp_Ax3( gp_Pnt(-72.948737453424499, 754.30437716359393, 259.52151854671678),
gp_Dir(6.2471473085930200e-007, -0.99999999999980493, 0.00000000000000000),
gp_Dir(0.99999999999980493, 6.2471473085930200e-007, 0.00000000000000000))));
{
if (n != 1) return 1;
- DoIsNull<Standard_Transient, Handle_Standard_Transient>(di);
- DoIsNull<Standard_Persistent, Handle_Standard_Persistent>(di);
+ DoIsNull<Standard_Transient, Handle(Standard_Transient)>(di);
+ DoIsNull<Standard_Persistent, Handle(Standard_Persistent)>(di);
return 0;
}
// Bnd_Box __emptyBox; // Box is void !
-// Handle_Bnd_HArray1OfBox __aSetOfBox = new Bnd_HArray1OfBox( 1, siMaxNbrBox, __emptyBox );
+// Handle(Bnd_HArray1OfBox) __aSetOfBox = new Bnd_HArray1OfBox( 1, siMaxNbrBox, __emptyBox );
for (i=1,aExplorer.ReInit(); aExplorer.More(); aExplorer.Next(),i++ )
{
gp_Pnt pt3d(0, 20, 150);
gp_Ax2 anAx2(gp_Pnt(0, 0, 0), gp_Dir(1, 0, 0), gp_Dir(0, 0, 1));
gp_Circ circ(anAx2, 50.0);
- Handle_Geom_Circle gcir = new Geom_Circle(circ);
- Handle_Geom_Plane pln = new Geom_Plane(gp_Ax3(gp_Pnt(0, 0, 0), gp_Dir(1, 0, 0)));
- Handle_Geom2d_Curve gcir1 = GeomAPI::To2d(gcir, pln->Pln());
+ Handle(Geom_Circle) gcir = new Geom_Circle(circ);
+ Handle(Geom_Plane) pln = new Geom_Plane(gp_Ax3(gp_Pnt(0, 0, 0), gp_Dir(1, 0, 0)));
+ Handle(Geom2d_Curve) gcir1 = GeomAPI::To2d(gcir, pln->Pln());
TopoDS_Shape sh1 = BRepBuilderAPI_MakeEdge(gcir1, pln).Shape();
- Handle_AIS_Shape ais1 = new AIS_Shape(sh1);
+ Handle(AIS_Shape) ais1 = new AIS_Shape(sh1);
aContext->SetColor(ais1, Quantity_NOC_INDIANRED);
aContext->Display(ais1);
DBRep::Set("sh0",sh1);
gp_Pnt2d thepoint;
// local_get_2Dpointfrom3Dpoint(pt3d, pln->Pln(), thepoint);
thepoint = ProjLib::Project(pln->Pln(),pt3d);
- Handle_Geom2d_CartesianPoint ThePoint = new Geom2d_CartesianPoint(thepoint);
+ Handle(Geom2d_CartesianPoint) ThePoint = new Geom2d_CartesianPoint(thepoint);
Geom2dAdaptor_Curve acur1(gcir1) ;
Geom2dGcc_QualifiedCurve qcur1(acur1, GccEnt_outside) ;
Geom2dGcc_Circ2d2TanRad cirtanrad(qcur1, ThePoint, 200.0, 0.0001);
printf("\n No. of solutions = %d\n", cirtanrad.NbSolutions());
- Handle_Geom2d_Circle gccc;
+ Handle(Geom2d_Circle) gccc;
if( cirtanrad.NbSolutions() ) {
for( int i = 1; i<=cirtanrad.NbSolutions(); i++) {
gp_Circ2d ccc = cirtanrad.ThisSolution(i);
Standard_Character aStr[5];
Sprintf(aStr,"sh%d",i);
DBRep::Set(aStr,sh);
- Handle_AIS_Shape ais = new AIS_Shape(sh);
+ Handle(AIS_Shape) ais = new AIS_Shape(sh);
if( i ==1 )
aContext->SetColor(ais, Quantity_NOC_GREEN);
if( i == 2)
TopoDS_Shape FP1;
TopoDS_Solid solid;
Handle(AIS_Shape) ais1;
- Handle_AIS_Shape ais2;
+ Handle(AIS_Shape) ais2;
Handle(Geom_BezierSurface) BZ1;
TColgp_Array2OfPnt array1(1,3,1,3);
array1.SetValue(1,1,gp_Pnt(0,100,0));
DBRep::Set("FP",FP);
//step 2. offseting the surface.
- Handle_Geom_OffsetSurface offsurf;
+ Handle(Geom_OffsetSurface) offsurf;
offsurf = new Geom_OffsetSurface(BZ1, -100);
BRepBuilderAPI_MakeFace bzf2( offsurf, Precision::Confusion() );
TopoDS_Face F2= bzf2.Face();
- Handle_AIS_Shape ais22 = new AIS_Shape(F2);
+ Handle(AIS_Shape) ais22 = new AIS_Shape(F2);
aContext->Display(ais22);
DBRep::Set("F2",F2);
{
TopoDS_Edge e1 = TopoDS::Edge(Ex.Current());
Standard_Real f = 0.0, l = 0.0;
- Handle_Geom_Curve newBSplin = BRep_Tool::Curve(e1, f, l);
+ Handle(Geom_Curve) newBSplin = BRep_Tool::Curve(e1, f, l);
newBSplin = new Geom_TrimmedCurve(newBSplin, f, l);
Handle(Geom_Curve) projCurve = GeomProjLib::Project(newBSplin,offsurf);
myWire->Add((BRepBuilderAPI_MakeEdge(projCurve)).Edge());
}
- Handle_AIS_Shape ais33 = new AIS_Shape( myWire->Wire() );
+ Handle(AIS_Shape) ais33 = new AIS_Shape( myWire->Wire() );
aContext->Display(ais33);
DBRep::Set("Wire",myWire->Wire());
}
DBRep::Set("fsh2",fsh2);
- Handle_AIS_Shape aisp1 = new AIS_Shape(fsh2);
+ Handle(AIS_Shape) aisp1 = new AIS_Shape(fsh2);
// aContext->Display(aisp1);
return 0;
}
}
TopoDS_Shape theSphere = BRepPrimAPI_MakeSphere(gp_Pnt(-40,0,0),20).Shape();
- Handle_AIS_Shape theAISShape = new AIS_Shape(theSphere);
+ Handle(AIS_Shape) theAISShape = new AIS_Shape(theSphere);
//display mode = Shading
theAISShape->SetDisplayMode(1);
//get the drawer
- Handle_AIS_Drawer theDrawer = theAISShape->Attributes();
- Handle_Prs3d_ShadingAspect theShadingAspect = theDrawer->ShadingAspect();
- Handle_Graphic3d_AspectFillArea3d theAspectFillArea3d = theShadingAspect->Aspect();
+ Handle(AIS_Drawer) theDrawer = theAISShape->Attributes();
+ Handle(Prs3d_ShadingAspect) theShadingAspect = theDrawer->ShadingAspect();
+ Handle(Graphic3d_AspectFillArea3d) theAspectFillArea3d = theShadingAspect->Aspect();
//allow to display the edges
theAspectFillArea3d->SetEdgeOn();
BRepPrimAPI_MakeBox box2(gp_Pnt(120, 120 + deltaY, 120), gp_Pnt(300, 300 + deltaY,300));
BRepPrimAPI_MakeBox box3(gp_Pnt(320, 320 + deltaY, 320), gp_Pnt(500, 500 + deltaY,500));
- Handle_AIS_Shape ais1 = new AIS_Shape(box1.Shape());
- Handle_AIS_Shape ais2 = new AIS_Shape(box2.Shape());
- Handle_AIS_Shape ais3 = new AIS_Shape(box3.Shape());
+ Handle(AIS_Shape) ais1 = new AIS_Shape(box1.Shape());
+ Handle(AIS_Shape) ais2 = new AIS_Shape(box2.Shape());
+ Handle(AIS_Shape) ais3 = new AIS_Shape(box3.Shape());
aContext->Display(ais1);
aContext->Display(ais2);
while(aContext->MoreCurrent())
{
//printf("\n count is = %d", count++);
- Handle_AIS_InteractiveObject ais = aContext->Current();
+ Handle(AIS_InteractiveObject) ais = aContext->Current();
aContext->Remove(ais, UpdateViewer);
aContext->InitCurrent();
}
gp_Elips2d ellipse1 = gp_Elips2d( gp_Ax2d(p0,gp::DX2d()),majorRadius, minorRadius,true);
gp_Elips2d ellipse2 = gp_Elips2d( gp_Ax2d(p1,gp::DX2d()),majorRadius, minorRadius,true);
- Handle_Geom2d_Curve curve1 = new Geom2d_Ellipse(ellipse1);
- Handle_Geom2d_Curve curve2 = new Geom2d_Ellipse(ellipse2);
+ Handle(Geom2d_Curve) curve1 = new Geom2d_Ellipse(ellipse1);
+ Handle(Geom2d_Curve) curve2 = new Geom2d_Ellipse(ellipse2);
DrawTrSurf::Set("c1", curve1);
DrawTrSurf::Set("c2", curve2);
//Expected tangent
const Standard_Integer /*aMode*/ )
{
aPresentation->Clear();
- Handle_Prs3d_TextAspect asp = myDrawer->TextAspect();
+ Handle(Prs3d_TextAspect) asp = myDrawer->TextAspect();
asp->SetFont(myNameOfFont);
asp->SetColor(myNameOfColor);
{
Handle(Graphic3d_Structure) aStructure = Handle(Graphic3d_Structure)::DownCast (thePrs);
Handle(Graphic3d_Group) aGroup = aStructure->NewGroup();
- Handle_Prs3d_ShadingAspect anAspect = myDrawer->ShadingAspect();
+ Handle(Prs3d_ShadingAspect) anAspect = myDrawer->ShadingAspect();
Graphic3d_MaterialAspect aMat = anAspect->Aspect()->FrontMaterial();
aMat.SetReflectionModeOff (Graphic3d_TOR_AMBIENT);
aMat.SetReflectionModeOff (Graphic3d_TOR_DIFFUSE);
}
//type definitions
- typedef Handle_Standard_Transient elem_type;
+ typedef Handle(Standard_Transient) elem_type;
typedef NCollection_StdAllocator<elem_type> allocator_type;
Standard_STATIC_ASSERT (sizeof (allocator_type::value_type) == sizeof (elem_type));
Standard_STATIC_ASSERT (sizeof (allocator_type::pointer) == sizeof (void*));
//Warning :
//=======================================================================
-Handle_StlMesh_Mesh RWStl::ReadFile (const OSD_Path& thePath,
+Handle(StlMesh_Mesh) RWStl::ReadFile (const OSD_Path& thePath,
const Handle(Message_ProgressIndicator)& theProgInd)
{
OSD_File file (thePath);
//Warning :
//=======================================================================
-Handle_StlMesh_Mesh RWStl::ReadBinary (const OSD_Path& thePath,
+Handle(StlMesh_Mesh) RWStl::ReadBinary (const OSD_Path& thePath,
const Handle(Message_ProgressIndicator)& /*theProgInd*/)
{
Standard_Integer NBFACET;
//Warning :
//=======================================================================
-Handle_StlMesh_Mesh RWStl::ReadAscii (const OSD_Path& thePath,
+Handle(StlMesh_Mesh) RWStl::ReadAscii (const OSD_Path& thePath,
const Handle(Message_ProgressIndicator)& theProgInd)
{
TCollection_AsciiString filename;
//purpose :
//=======================================================================
-void Select3D_SensitiveCircle::Project(const Handle_Select3D_Projector &aProjector)
+void Select3D_SensitiveCircle::Project(const Handle(Select3D_Projector) &aProjector)
{
Select3D_SensitivePoly::Project(aProjector);
gp_Pnt2d aCenter;
//purpose :
//=======================================================================
-void Select3D_SensitiveWire::Set(const Handle_SelectBasics_EntityOwner &TheOwnerId)
+void Select3D_SensitiveWire::Set(const Handle(SelectBasics_EntityOwner) &TheOwnerId)
{
Select3D_SensitiveEntity::Set(TheOwnerId);
SelectBasics_SortAlgo::SelectBasics_SortAlgo
(const Bnd_Box2d& ClippingRectangle,
const Standard_Real sizeOfSensitiveArea,
- const Handle_Bnd_HArray1OfBox2d& theRectangles)
+ const Handle(Bnd_HArray1OfBox2d)& theRectangles)
: clipRect(ClippingRectangle), sizeArea(sizeOfSensitiveArea)
{
sortedRect.Initialize(clipRect, theRectangles);
//=======================================================================
void SelectBasics_SortAlgo::Initialize(const Bnd_Box2d& ClippingRectangle,
const Standard_Real sizeOfSensitiveArea,
- const Handle_Bnd_HArray1OfBox2d& theRectangles)
+ const Handle(Bnd_HArray1OfBox2d)& theRectangles)
{
clipRect=ClippingRectangle;
sizeArea=sizeOfSensitiveArea;
#include <SelectMgr_SelectableObject.hxx>
#include <SelectMgr_SequenceOfOwner.hxx>
-inline Standard_Boolean IsEqual (const Handle_SelectMgr_SelectableObject& theH1,
- const Handle_SelectMgr_SelectableObject& theH2)
+inline Standard_Boolean IsEqual (const Handle(SelectMgr_SelectableObject)& theH1,
+ const Handle(SelectMgr_SelectableObject)& theH2)
{
return (theH1 == theH2);
}
//purpose : Returns sequence of notches on the contour
//=======================================================================
-inline Handle_TopTools_HSequenceOfShape ShapeAnalysis_FreeBoundData::Notches() const
+inline Handle(TopTools_HSequenceOfShape) ShapeAnalysis_FreeBoundData::Notches() const
{
return myNotches;
}
#include <Standard_Type.hxx>
// The Initialization of the Standard_Persistent variables
-const Handle_Standard_Type& Standard_Persistent_Type_()
+const Handle(Standard_Type)& Standard_Persistent_Type_()
{
- static const Handle_Standard_Type _Ancestors[]={NULL};
- static Handle_Standard_Type _aType
+ static const Handle(Standard_Type) _Ancestors[]={NULL};
+ static Handle(Standard_Type) _aType
= new Standard_Type("Standard_Persistent",
sizeof(Standard_Persistent),
0,
// The Method This
//
-Handle_Standard_Persistent Standard_Persistent::This() const
+Handle(Standard_Persistent) Standard_Persistent::This() const
{
- Handle_Standard_Persistent aHand(this);
+ Handle(Standard_Persistent) aHand(this);
return aHand;
}
EndScope();
}
-void Handle_Standard_Persistent::RaiseNullObject(const Standard_CString S) const
+void Handle(Standard_Persistent)::RaiseNullObject(const Standard_CString S) const
{
Standard_NullObject::Raise(S);
}
// The Method This
//
-Handle_Standard_Transient Standard_Transient::This() const
+Handle(Standard_Transient) Standard_Transient::This() const
{
- return Handle_Standard_Transient(this);
+ return Handle(Standard_Transient)(this);
}
// Empty Destructor
}
//============================================================================
-Standard_Boolean Standard_Type::SubType(const Handle_Standard_Type& anOther)const
+Standard_Boolean Standard_Type::SubType(const Handle(Standard_Type)& anOther)const
{
// Among ancestors of the type of this, there is the type of anOther
return anOther == this ||
StdPrs_WFShape::Add(P,mysh,DRWR);
}
-void StdSelect_Shape::Compute(const Handle_Prs3d_Projector& aProjector ,
- const Handle_Geom_Transformation& aGeomTrans,
- const Handle_Prs3d_Presentation& aPresentation )
+void StdSelect_Shape::Compute(const Handle(Prs3d_Projector)& aProjector ,
+ const Handle(Geom_Transformation)& aGeomTrans,
+ const Handle(Prs3d_Presentation)& aPresentation )
{
PrsMgr_PresentableObject::Compute(aProjector,aGeomTrans,aPresentation);
}
-void StdSelect_Shape::Compute(const Handle_Prs3d_Projector& aProjector,
- const Handle_Prs3d_Presentation& aPresentation)
+void StdSelect_Shape::Compute(const Handle(Prs3d_Projector)& aProjector,
+ const Handle(Prs3d_Presentation)& aPresentation)
{
PrsMgr_PresentableObject::Compute(aProjector,aPresentation);
}
#include <NCollection_BaseAllocator.hxx>
-typedef Handle_NCollection_BaseAllocator TDF_HAllocator;
+typedef Handle(NCollection_BaseAllocator) TDF_HAllocator;
#endif
class TDF_AttributeIterator;
class TDF_ChildIterator;
class TDF_Data;
-class Handle_TDF_Data;
+class Handle(TDF_Data);
class TDF_Label;
#define KEEP_LOCAL_ROOT
//=======================================================================
-//function : Handle_TNaming_NamedShape
+//function : Handle(TNaming_NamedShape)
//purpose :
//=======================================================================
DEFINE_DATAMAP (TObj_DataMapOfObjectHSequenceOcafObjects,
TObj_CollectionOfHSeqOfObject,
- Handle_TObj_Object,Handle_TObj_HSequenceOfObject)
+ Handle(TObj_Object),Handle(TObj_HSequenceOfObject))
DEFINE_DATAMAP(TObj_DataMapOfStringPointer,TObj_CollectionOfPointer,
TCollection_AsciiString,Standard_Address)
#include <TObj_Common.hxx>
#include <Handle_TObj_Object.hxx>
-DEFINE_BASECOLLECTION (TObj_CollectionOfObject,Handle_TObj_Object)
+DEFINE_BASECOLLECTION (TObj_CollectionOfObject,Handle(TObj_Object))
DEFINE_SEQUENCE (TObj_SequenceOfObject,
TObj_CollectionOfObject,Handle(TObj_Object))
GetGoodShape(shape3);
const TopoDS_Edge& E = TopoDS::Edge(shape3);
BRepAdaptor_Curve CURVE(E);
- Handle_Geom_Geometry aGeomGeometry = CURVE.Curve().Curve()->Transformed(CURVE.Trsf()) ;
+ Handle(Geom_Geometry) aGeomGeometry = CURVE.Curve().Curve()->Transformed(CURVE.Trsf()) ;
gp_Dir Dir = ((Handle(Geom_Line)&) aGeomGeometry)->Lin().Direction();
gp_Dir xdir(aplane->Pln().Position().XDirection());
if (Dir.IsParallel(xdir,Precision::Confusion()))
if (CURVE.GetType() == GeomAbs_Line) {
// Works only with line !!
//#ifndef DEB
- Handle_Geom_Geometry aGeomGeometry = CURVE.Curve().Curve()->Transformed(CURVE.Trsf()) ;
+ Handle(Geom_Geometry) aGeomGeometry = CURVE.Curve().Curve()->Transformed(CURVE.Trsf()) ;
gp_Lin OLin = ((Handle(Geom_Line)&) aGeomGeometry)->Lin();
//#else
// gp_Lin OLin = ((Handle(Geom_Line)&) CURVE.Curve().Curve()->Transformed(CURVE.Trsf()))->Lin();
else
if (CURVE.GetType() == GeomAbs_Circle) {
//#ifndef DEB
- Handle_Geom_Geometry aGeomGeometry = CURVE.Curve().Curve()->Transformed(CURVE.Trsf()) ;
+ Handle(Geom_Geometry) aGeomGeometry = CURVE.Curve().Curve()->Transformed(CURVE.Trsf()) ;
gp_Ax1 ax = ((Handle(Geom_Circle)&) aGeomGeometry)->Circ().Axis();
//#else
// gp_Ax1 ax = ((Handle(Geom_Circle)&) CURVE.Curve().Curve()->Transformed(CURVE.Trsf()))->Circ().Axis();
BRepBuilderAPI_MakeFace MkF (w1,Standard_True);
if (MkF.IsDone()) {
//#ifndef DEB
- Handle_Geom_Surface aGeomSurface = BRep_Tool::Surface(MkF.Face());
+ Handle(Geom_Surface) aGeomSurface = BRep_Tool::Surface(MkF.Face());
aplane = (Handle(Geom_Plane)&) aGeomSurface ;
//#else
// aplane = ((Handle(Geom_Plane)&) BRep_Tool::Surface(MkF.Face()));
const char* mykeys[TESTTOPOPE_NKEYS];
const char* myresnamdef;
VarsTopo myVarsTopo;
- Handle_TopOpeBRepDS_HDataStructure myHDS;
- Handle_TopOpeBRepBuild_HBuilder myHB;
+ Handle(TopOpeBRepDS_HDataStructure) myHDS;
+ Handle(TopOpeBRepBuild_HBuilder) myHB;
TCollection_AsciiString mynameS1,mynameS2;
TopoDS_Shape myS1,myS2;
TopAbs_ShapeEnum myS1type,myS2type;
else if (!strcmp(a[ia],"-AB")) outAB = Standard_True;
}
- Handle_TopOpeBRepBuild_HBuilder HB = PBOOP->HBuilder();
- Handle_TopOpeBRepDS_HDataStructure HDS = HB->DataStructure();
+ Handle(TopOpeBRepBuild_HBuilder) HB = PBOOP->HBuilder();
+ Handle(TopOpeBRepDS_HDataStructure) HDS = HB->DataStructure();
const TopOpeBRepDS_DataStructure& BDS = HDS->DS();
const TopTools_ListOfShape& loe = HB->Section();
Standard_Boolean GetI(const Standard_Integer i) const;
void Allocate();
protected:
- Handle_TopOpeBRepDS_HDataStructure myHDS;
- Standard_Integer myne; Handle_TColStd_HArray1OfBoolean myhe;
+ Handle(TopOpeBRepDS_HDataStructure) myHDS;
+ Standard_Integer myne; Handle(TColStd_HArray1OfBoolean) myhe;
};
class TopOpeBRepDS_traceCURVE : public TopOpeBRepDS_traceDS {
TopTools_MutexForShapeProvider & operator = (const TopTools_MutexForShapeProvider &);
- NCollection_DataMap<Handle_TopoDS_TShape, Standard_Mutex *> myMap;
+ NCollection_DataMap<Handle(TopoDS_TShape), Standard_Mutex *> myMap;
};
if(move) {
Standard_Integer last = theunitssequence->Length();
unit = theunitssequence->Value(last);
- shiftedunit = *(Handle_Units_ShiftedUnit*)&unit;
+ shiftedunit = *(Handle(Units_ShiftedUnit)*)&unit;
shiftedunit->Move(move);
}
}
void Units_UnitsSystem::Dump() const
{
Handle(Standard_Transient) transient = This();
- Handle(Units_UnitsSystem) unitssystem = *(Handle_Units_UnitsSystem*)&transient;
+ Handle(Units_UnitsSystem) unitssystem = *(Handle(Units_UnitsSystem)*)&transient;
Units_Explorer explorer(unitssystem);
cout<<" UNITSSYSTEM : "<<endl;
for(; explorer.MoreQuantity(); explorer.NextQuantity()) {
//function : TextureEnv
//purpose :
//=============================================================================
-Handle_Graphic3d_TextureEnv V3d_View::TextureEnv() const
+Handle(Graphic3d_TextureEnv) V3d_View::TextureEnv() const
{
Handle(Graphic3d_TextureEnv) SM = MyViewContext.TextureEnv() ;
return SM ;
return aFace;
}
-void FilledCircle::Compute(const Handle_PrsMgr_PresentationManager3d &/*thePresentationManager*/,
- const Handle_Prs3d_Presentation &thePresentation,
+void FilledCircle::Compute(const Handle(PrsMgr_PresentationManager3d) &/*thePresentationManager*/,
+ const Handle(Prs3d_Presentation) &thePresentation,
const Standard_Integer theMode)
{
thePresentation->Clear();
StdPrs_ShadedShape::Add(thePresentation, aFace, myDrawer);
}
-void FilledCircle::ComputeSelection(const Handle_SelectMgr_Selection &theSelection,
+void FilledCircle::ComputeSelection(const Handle(SelectMgr_Selection) &theSelection,
const Standard_Integer /*theMode*/)
{
Handle(SelectMgr_EntityOwner) anEntityOwner = new SelectMgr_EntityOwner(this);
aPresentation->Clear();
- Handle_Prs3d_TextAspect asp = myDrawer->TextAspect();
+ Handle(Prs3d_TextAspect) asp = myDrawer->TextAspect();
asp->SetFont(aFont.ToCString());
asp->SetColor(aColor);
myPoint2 = thePnt2;
}
-void SegmentObject::Compute (const Handle_PrsMgr_PresentationManager3d &/*thePresentationManager*/,
- const Handle_Prs3d_Presentation &thePresentation,
+void SegmentObject::Compute (const Handle(PrsMgr_PresentationManager3d) &/*thePresentationManager*/,
+ const Handle(Prs3d_Presentation) &thePresentation,
const Standard_Integer /*theMode*/)
{
thePresentation->Clear();
StdPrs_Curve::Add(thePresentation, aCurveAdaptor, myDrawer);
}
-void SegmentObject::ComputeSelection (const Handle_SelectMgr_Selection &theSelection,
+void SegmentObject::ComputeSelection (const Handle(SelectMgr_Selection) &theSelection,
const Standard_Integer /*theMode*/)
{
Handle(SelectMgr_EntityOwner) anOwner = new SelectMgr_EntityOwner(this);
}
-Handle_Graphic3d_TextureEnv Visual3d_ContextView::TextureEnv() const
+Handle(Graphic3d_TextureEnv) Visual3d_ContextView::TextureEnv() const
{
return MyTextureEnv;
}
if (theIsSingleView)
{
- Handle_Visual3d_HSetOfView aViews = MyViewManager->DefinedView();
+ Handle(Visual3d_HSetOfView) aViews = MyViewManager->DefinedView();
for (Visual3d_SetIteratorOfSetOfView aViewIter (aViews->Set()); aViewIter.More(); aViewIter.Next())
{
if (aViewIter.Value().Access() != this)
* and the corresponding Appearance.
*/
class VrmlData_DataMapOfShapeAppearance
- : public NCollection_DataMap<Handle_TopoDS_TShape, Handle_VrmlData_Appearance>
+ : public NCollection_DataMap<Handle(TopoDS_TShape), Handle(VrmlData_Appearance)>
{
public:
//! Constructor
inline VrmlData_DataMapOfShapeAppearance
(const Standard_Integer NbBuckets=1,
const Handle(NCollection_BaseAllocator)& theAllocator = 0L)
- : NCollection_DataMap<Handle_TopoDS_TShape,
- Handle_VrmlData_Appearance> (NbBuckets, theAllocator)
+ : NCollection_DataMap<Handle(TopoDS_TShape),
+ Handle(VrmlData_Appearance)> (NbBuckets, theAllocator)
{}
//! Copy constructor
inline VrmlData_DataMapOfShapeAppearance
(const VrmlData_DataMapOfShapeAppearance& theOther)
- : NCollection_DataMap<Handle_TopoDS_TShape,
- Handle_VrmlData_Appearance> (theOther)
+ : NCollection_DataMap<Handle(TopoDS_TShape),
+ Handle(VrmlData_Appearance)> (theOther)
{}
- friend Standard_Boolean IsEqual (const Handle_TopoDS_TShape& one,
- const Handle_TopoDS_TShape& two);
+ friend Standard_Boolean IsEqual (const Handle(TopoDS_TShape)& one,
+ const Handle(TopoDS_TShape)& two);
};
//function : IsEqual
//purpose : for NCollection_DataMap interface
//=======================================================================
-inline Standard_Boolean IsEqual (const Handle_TopoDS_TShape& one,
- const Handle_TopoDS_TShape& two)
+inline Standard_Boolean IsEqual (const Handle(TopoDS_TShape)& one,
+ const Handle(TopoDS_TShape)& two)
{
return one == two;
}
* Container of List type, holding handles to VrmlData_Node objects
*/
-typedef NCollection_List<Handle_VrmlData_Node> VrmlData_ListOfNode;
+typedef NCollection_List<Handle(VrmlData_Node)> VrmlData_ListOfNode;
#endif
* Container of Map type, holding handles to VrmlData_Node objects
*/
-typedef NCollection_Map<Handle_VrmlData_Node> VrmlData_MapOfNode;
+typedef NCollection_Map<Handle(VrmlData_Node)> VrmlData_MapOfNode;
#endif
class VrmlData_Scene;
class gp_XY;
class gp_XYZ;
-class Handle_VrmlData_Node;
+class Handle(VrmlData_Node);
class TCollection_AsciiString;
/**
// Definition of HANDLE object using Standard_DefineHandle.hxx
DEFINE_STANDARD_HANDLE (VrmlData_Node, Standard_Transient)
-Standard_EXPORT Standard_Integer HashCode(const Handle_VrmlData_Node& theNode,
+Standard_EXPORT Standard_Integer HashCode(const Handle(VrmlData_Node)& theNode,
const Standard_Integer theUpper);
Standard_EXPORT Standard_Boolean IsEqual (const Handle(VrmlData_Node)& theOne,
const Handle(VrmlData_Node)& theTwo);
//purpose :
//=======================================================================
-const Handle_VrmlData_WorldInfo& VrmlData_Scene::WorldInfo() const
+const Handle(VrmlData_WorldInfo)& VrmlData_Scene::WorldInfo() const
{
return myWorldInfo;
}
#include <Standard_Mutex.hxx>
struct VrmlData_InBuffer;
-class Handle_VrmlData_WorldInfo;
+class Handle(VrmlData_WorldInfo);
class VrmlData_DataMapOfShapeAppearance;
/**
/**
* Query the WorldInfo member.
*/
- Standard_EXPORT const Handle_VrmlData_WorldInfo&
+ Standard_EXPORT const Handle(VrmlData_WorldInfo)&
WorldInfo() const;
/**
*/
Standard_EXPORT VrmlData_ErrorStatus
WriteNode (const char * thePrefix,
- const Handle_VrmlData_Node&) const;
+ const Handle(VrmlData_Node)&) const;
/**
* Query if the current write operation is dummy, i.e., for the purpose of
VrmlData_ListOfNode myLstNodes; ///! top-level nodes
VrmlData_ListOfNode myAllNodes; ///! all nodes
VrmlData_ErrorStatus myStatus;
- Handle_NCollection_IncAllocator myAllocator;
- Handle_VrmlData_WorldInfo myWorldInfo;
+ Handle(NCollection_IncAllocator) myAllocator;
+ Handle(VrmlData_WorldInfo) myWorldInfo;
VrmlData_MapOfNode myNamedNodes;
// read from stream
//purpose :
//=======================================================================
-Handle_VrmlData_Geometry VrmlData_ShapeConvert::triToIndexedFaceSet
- (const Handle_Poly_Triangulation& theTri,
+Handle(VrmlData_Geometry) VrmlData_ShapeConvert::triToIndexedFaceSet
+ (const Handle(Poly_Triangulation)& theTri,
const TopoDS_Face& theFace,
- const Handle_VrmlData_Coordinate& theCoord)
+ const Handle(VrmlData_Coordinate)& theCoord)
{
Standard_Integer i;
const Standard_Integer nNodes (theTri->NbNodes());
//purpose : single polygon3D => IndexedLineSet
//=======================================================================
-Handle_VrmlData_Geometry VrmlData_ShapeConvert::polToIndexedLineSet
- (const Handle_Poly_Polygon3D& thePol)
+Handle(VrmlData_Geometry) VrmlData_ShapeConvert::polToIndexedLineSet
+ (const Handle(Poly_Polygon3D)& thePol)
{
Standard_Integer i;
const Standard_Integer nNodes (thePol->NbNodes());
class VrmlData_Scene;
class TopoDS_Face;
-class Handle_Poly_Triangulation;
-class Handle_Poly_Polygon3D;
-class Handle_VrmlData_Coordinate;
+class Handle(Poly_Triangulation);
+class Handle(Poly_Polygon3D);
+class Handle(VrmlData_Coordinate);
/**
* Algorithm converting one shape or a set of shapes to VrmlData_Scene.
*/
protected:
// ---------- PROTECTED METHODS ----------
- Handle_VrmlData_Geometry triToIndexedFaceSet
- (const Handle_Poly_Triangulation&,
+ Handle(VrmlData_Geometry) triToIndexedFaceSet
+ (const Handle(Poly_Triangulation)&,
const TopoDS_Face&,
- const Handle_VrmlData_Coordinate&);
+ const Handle(VrmlData_Coordinate)&);
- Handle_VrmlData_Geometry polToIndexedLineSet
- (const Handle_Poly_Polygon3D&);
+ Handle(VrmlData_Geometry) polToIndexedLineSet
+ (const Handle(Poly_Polygon3D)&);
- Handle_VrmlData_Appearance defaultMaterialFace () const;
+ Handle(VrmlData_Appearance) defaultMaterialFace () const;
- Handle_VrmlData_Appearance defaultMaterialEdge () const;
+ Handle(VrmlData_Appearance) defaultMaterialEdge () const;
private:
// ---------- PRIVATE FIELDS ----------
// FONCTION POUR LE DEBUG
-Standard_Integer XSDRAW_WHAT (const Handle_Standard_Transient& ent)
+Standard_Integer XSDRAW_WHAT (const Handle(Standard_Transient)& ent)
{
if (ent.IsNull()) { cout<<"(Null Handle)"<<endl; return 0; }
Handle(Interface_InterfaceModel) model = XSDRAW::Model();
//purpose :
//=======================================================================
Handle(XmlMDF_ADriverTable) XmlDrivers::AttributeDrivers
- (const Handle_CDM_MessageDriver& theMessageDriver)
+ (const Handle(CDM_MessageDriver)& theMessageDriver)
{
Handle(XmlMDF_ADriverTable) aTable = new XmlMDF_ADriverTable();
//
//purpose :
//=======================================================================
Handle(XmlMDF_ADriverTable) XmlLDrivers::AttributeDrivers
- (const Handle_CDM_MessageDriver& theMessageDriver)
+ (const Handle(CDM_MessageDriver)& theMessageDriver)
{
Handle(XmlMDF_ADriverTable) aTable = new XmlMDF_ADriverTable();
//
projects / occt-copy.git / commitdiff