Integration of OCCT 6.5.0 from SVN

src/DrawFairCurve/DrawFairCurve.cdl

@@ -0,0 +1,18 @@
+-- File:	DrawFairCurve.cdl
+-- Created:	Fri Feb 16 14:30:11 1996
+-- Author:	Philippe MANGIN
+--		<pmn@sgi29>
+---Copyright:	 Matra Datavision 1996
+
+
+package DrawFairCurve 
+
+	---Purpose: Batten and MVC to display
+
+uses FairCurve, DrawTrSurf, Draw, gp
+
+is
+class Batten;
+class MinimalVariation;
+
+end DrawFairCurve;

src/DrawFairCurve/DrawFairCurve_Batten.cdl

@@ -0,0 +1,35 @@
+-- File:	DrawFairCurve_Batten.cdl
+-- Created:	Fri Feb 16 14:32:26 1996
+-- Author:	Philippe MANGIN
+--		<pmn@sgi29>
+---Copyright:	 Matra Datavision 1996
+
+
+class Batten from DrawFairCurve inherits  BSplineCurve2d from DrawTrSurf
+
+	---Purpose: Interactive Draw object of type "Batten"
+
+uses Batten from FairCurve, 
+     BSplineCurve2d from DrawTrSurf,
+     Pnt2d from gp
+
+is
+   Create(TheBatten : Address)
+   returns mutable Batten from DrawFairCurve;
+   Compute(me:mutable);
+   SetPoint(me: mutable; Side : Integer; Point : Pnt2d);
+   SetAngle(me: mutable; Side : Integer; Angle : Real);
+   SetSliding(me: mutable; Length : Real);
+   SetHeight(me: mutable; Heigth : Real);
+   SetSlope(me: mutable; Slope : Real);
+   GetAngle(me; Side : Integer) returns Real;
+   GetSliding(me) returns Real;
+   FreeSliding(me:mutable);
+   FreeAngle(me:mutable; Side : Integer);
+   Dump(me; S : in out OStream)
+	---Purpose: For variable dump.
+  is redefined;
+   
+fields
+ MyBatten : Address is protected;
+end Batten;

src/DrawFairCurve/DrawFairCurve_Batten.cxx

@@ -0,0 +1,110 @@
+// File:	DrawFairCurve_Batten.cxx
+// Created:	Fri Feb 16 14:32:26 1996
+// Author:	Philippe MANGIN
+//		<pmn@sgi29>
+// Copyright:	 Matra Datavision 1996
+
+#include <DrawFairCurve_Batten.ixx>
+
+#include <FairCurve_Batten.hxx>
+#include <FairCurve_AnalysisCode.hxx>
+#include <GeomTools_Curve2dSet.hxx>
+
+DrawFairCurve_Batten::DrawFairCurve_Batten(const Standard_Address TheBatten)
+                     : DrawTrSurf_BSplineCurve2d( ((FairCurve_Batten*)TheBatten)->Curve()),
+                       MyBatten( TheBatten)
+                      
+{
+  Compute();
+  ShowCurvature();
+}
+
+void DrawFairCurve_Batten::Compute()
+{
+  FairCurve_AnalysisCode Iana;
+#ifdef DEB
+  Standard_Boolean Ok =
+#endif
+                        ((FairCurve_Batten*)MyBatten)->Compute(Iana, 50, 1.0e-2);
+  curv = ((FairCurve_Batten*)MyBatten)->Curve();
+}
+void DrawFairCurve_Batten::SetPoint(const Standard_Integer Side, const gp_Pnt2d& Point)
+{
+  if (Side == 1) {
+    ((FairCurve_Batten*)MyBatten)->SetP1(Point);
+   }
+  else {
+    ((FairCurve_Batten*)MyBatten)-> SetP2(Point);
+   }
+  Compute();
+}
+
+void DrawFairCurve_Batten::SetAngle(const Standard_Integer Side, const Standard_Real Angle)
+{
+  if (Side == 1) {
+     ((FairCurve_Batten*)MyBatten)->SetAngle1(Angle*PI/180);
+     if ( ((FairCurve_Batten*)MyBatten)->GetConstraintOrder1() == 0 ) 
+     {
+       ((FairCurve_Batten*)MyBatten)->SetConstraintOrder1(1);
+     }
+   }
+  else {
+     ((FairCurve_Batten*)MyBatten)->SetAngle2(Angle*PI/180);
+     if ( ((FairCurve_Batten*)MyBatten)->GetConstraintOrder2() == 0 ) 
+     {
+     ((FairCurve_Batten*)MyBatten)->SetConstraintOrder2(1);
+     }
+   }
+  Compute();
+}
+
+void DrawFairCurve_Batten::SetSliding(const Standard_Real Length)
+{
+  ((FairCurve_Batten*)MyBatten)-> SetFreeSliding(Standard_False);
+  ((FairCurve_Batten*)MyBatten)->SetSlidingFactor(Length);
+  Compute();
+}
+
+void DrawFairCurve_Batten::SetHeight(const Standard_Real Height)
+{
+ ((FairCurve_Batten*)MyBatten)->SetHeight(Height);
+ Compute();
+}
+
+void DrawFairCurve_Batten::SetSlope(const Standard_Real Slope)
+{
+ ((FairCurve_Batten*)MyBatten)->SetSlope(Slope);
+ Compute();
+}
+
+Standard_Real DrawFairCurve_Batten::GetAngle(const Standard_Integer Side) const 
+{
+ if (Side == 1) return ((FairCurve_Batten*)MyBatten)->GetAngle1();
+ else           return ((FairCurve_Batten*)MyBatten)->GetAngle2();
+}
+
+Standard_Real DrawFairCurve_Batten::GetSliding() const 
+{
+   return ((FairCurve_Batten*)MyBatten)->GetSlidingFactor();
+}
+
+
+void DrawFairCurve_Batten::FreeSliding()
+{
+  ((FairCurve_Batten*)MyBatten)->SetFreeSliding(Standard_True);
+  Compute();
+}
+
+void DrawFairCurve_Batten::FreeAngle(const Standard_Integer Side)
+{
+ if (Side == 1) ((FairCurve_Batten*)MyBatten)->SetConstraintOrder1(0);
+ else           ((FairCurve_Batten*)MyBatten)->SetConstraintOrder2(0);
+
+ Compute();
+}
+
+void DrawFairCurve_Batten::Dump(Standard_OStream& S)const 
+{
+  GeomTools_Curve2dSet::PrintCurve2d(curv,S);
+  ((FairCurve_Batten*)MyBatten)->Dump(S);
+}

src/DrawFairCurve/DrawFairCurve_MinimalVariation.cdl

@@ -0,0 +1,25 @@
+-- File:	DrawFairCurve_MinimalVariation.cdl
+-- Created:	Fri Apr 12 11:03:34 1996
+-- Author:	Philippe MANGIN
+--		<pmn@sgi29>
+---Copyright:	 Matra Datavision 1996
+
+class MinimalVariation from DrawFairCurve inherits Batten from DrawFairCurve
+
+	---Purpose: Interactive Draw object of type "MVC"
+
+uses MinimalVariation from FairCurve
+
+is
+   Create(TheMVC : Address)
+   returns mutable MinimalVariation from DrawFairCurve;
+   
+   SetCurvature(me: mutable; Side : Integer; Rho : Real);
+   SetPhysicalRatio(me: mutable; Ratio : Real);
+   GetCurvature(me; Side : Integer) returns Real;
+   GetPhysicalRatio(me) returns Real;
+   FreeCurvature(me: mutable; Side : Integer);
+
+end MinimalVariation;
+
+

src/DrawFairCurve/DrawFairCurve_MinimalVariation.cxx

@@ -0,0 +1,60 @@
+#include <DrawFairCurve_MinimalVariation.ixx>
+
+#include <FairCurve_MinimalVariation.hxx>
+#include <Draw_ColorKind.hxx>
+
+DrawFairCurve_MinimalVariation::DrawFairCurve_MinimalVariation(const Standard_Address TheMVC)
+                               : DrawFairCurve_Batten(TheMVC)
+                                 
+{
+ SetColor(Draw_jaune);
+}
+
+void DrawFairCurve_MinimalVariation::SetCurvature(const Standard_Integer Side,
+						  const Standard_Real Rho)
+{
+  if (Side == 1) {
+     ((FairCurve_MinimalVariation*)MyBatten)->SetCurvature1(Rho);
+     ((FairCurve_MinimalVariation*)MyBatten)->SetConstraintOrder1(2);
+   }
+  else {
+     ((FairCurve_MinimalVariation*)MyBatten)->SetCurvature2(Rho);
+     ((FairCurve_MinimalVariation*)MyBatten)->SetConstraintOrder2(2);
+   }
+  Compute();
+}
+
+void DrawFairCurve_MinimalVariation::FreeCurvature(const Standard_Integer Side)
+{
+  if (Side == 1) {
+     if ( ((FairCurve_MinimalVariation*)MyBatten)->GetConstraintOrder1()>1) 
+       {
+	 ((FairCurve_MinimalVariation*)MyBatten)->SetConstraintOrder1(1);
+       }
+   }
+  else {
+     if ( ((FairCurve_MinimalVariation*)MyBatten)->GetConstraintOrder2()>1) 
+       {
+	 ((FairCurve_MinimalVariation*)MyBatten)->SetConstraintOrder2(1);
+       }
+   }
+  Compute();
+}  
+
+
+void DrawFairCurve_MinimalVariation::SetPhysicalRatio( const Standard_Real Ratio)
+{
+ ((FairCurve_MinimalVariation*)MyBatten)->SetPhysicalRatio(Ratio);
+ Compute();
+}
+
+Standard_Real DrawFairCurve_MinimalVariation::GetCurvature(const Standard_Integer Side) const
+{
+ if (Side == 1) {return ((FairCurve_MinimalVariation*)MyBatten)->GetCurvature1();}
+ else           {return ((FairCurve_MinimalVariation*)MyBatten)->GetCurvature2();}
+}
+
+Standard_Real DrawFairCurve_MinimalVariation::GetPhysicalRatio() const
+{
+  return ((FairCurve_MinimalVariation*)MyBatten)->GetPhysicalRatio();
+}