Integration of OCCT 6.5.0 from SVN

samples/mfc/standard/01_Geometry/src/ISession2D/ISession2D_Curve.cpp

@@ -0,0 +1,143 @@
+#include "stdafx.h"
+
+#include <ISession2D_Curve.h>
+#include "..\\GeometryApp.h"
+
+IMPLEMENT_STANDARD_HANDLE(ISession2D_Curve,AIS_InteractiveObject)
+IMPLEMENT_STANDARD_RTTIEXT(ISession2D_Curve,AIS_InteractiveObject)
+
+#include <Graphic2d_SetOfCurves.hxx>
+#include <Geom2dAdaptor_Curve.hxx>
+#include <Bnd_Box2d.hxx>
+#include <BndLib_Add2dCurve.hxx>
+#include <Precision.hxx>
+#include <Select2D_SensitiveBox.hxx>
+#include <Select2D_SensitiveSegment.hxx>
+#include <gp_Circ2d.hxx>
+#include <gp_Dir2d.hxx>
+#include <gp_Ax2d.hxx>
+#include <Select2D_SensitiveArc.hxx>
+#include <Geom2d_Curve.hxx>
+#include <GeomTools_Curve2dSet.hxx>
+#include <Geom2d_TrimmedCurve.hxx>
+#include <gp_Pnt2d.hxx>
+#include <GCE2d_MakeSegment.hxx>
+#include <gp_Vec2d.hxx>
+#include <OSD_Environment.hxx>
+#include <Graphic2d_Array1OfVertex.hxx>
+#include <Graphic2d_PolyLine.hxx>
+#include <SelectMgr_Selection.hxx>
+#include <Graphic2d_Segment.hxx>
+#include <GeomAbs_CurveType.hxx>
+#include <Graphic2d_Vertex.hxx>
+#include <Geom2d_BezierCurve.hxx>
+
+ ISession2D_Curve::ISession2D_Curve(const Handle_Geom2d_Curve aGeom2dCurve,
+				                const Aspect_TypeOfLine aTypeOfLine,
+				                const Aspect_WidthOfLine aWidthOfLine,
+				                const Standard_Integer aColorIndex)
+    :AIS_InteractiveObject()
+{
+  myGeom2dCurve = aGeom2dCurve;
+  myTypeOfLine  = aTypeOfLine ;
+  myWidthOfLine = aWidthOfLine;
+  myColorIndex  = aColorIndex ;
+  myDisplayPole = Standard_True;
+  myDisplayCurbure = Standard_False;
+  myDiscretisation = 20;
+  myradiusmax = 10;
+  myradiusratio = 1;
+}
+
+void ISession2D_Curve::Compute(const Handle(PrsMgr_PresentationManager2d)& aPresentationManager,
+			     const Handle(Graphic2d_GraphicObject)& aGrObj,
+			     const Standard_Integer aMode) 
+{
+  Handle(Graphic2d_SetOfCurves) segment;
+  segment = new Graphic2d_SetOfCurves(aGrObj);
+
+
+  segment->Add(myGeom2dCurve);
+  
+  segment->SetColorIndex (myColorIndex);
+  segment->SetWidthIndex (myWidthOfLine + 1);
+  segment->SetTypeIndex  (myTypeOfLine  + 1);
+
+  Geom2dAdaptor_Curve anAdaptor(myGeom2dCurve);
+  if (myDisplayPole) 
+   {
+    if (anAdaptor.GetType() == GeomAbs_BezierCurve  )
+    {
+      Handle(Geom2d_BezierCurve) aBezier = anAdaptor.Bezier();
+      Graphic2d_Array1OfVertex anArrayOfVertex(1,aBezier->NbPoles());
+      for(int i=1;i<=aBezier->NbPoles();i++)
+        {
+          gp_Pnt2d CurrentPoint = aBezier->Pole(i);
+          Graphic2d_Vertex aVertex(CurrentPoint.X(),CurrentPoint.Y());
+          anArrayOfVertex(i)=aVertex;
+        }
+      Handle(Graphic2d_Polyline) aPolyline = new Graphic2d_Polyline(aGrObj,anArrayOfVertex);
+      }
+
+    if (anAdaptor.GetType() == GeomAbs_BSplineCurve  )
+    {
+      Handle(Geom2d_BSplineCurve) aBSpline = anAdaptor.BSpline();
+
+      Graphic2d_Array1OfVertex anArrayOfVertex(1,aBSpline->NbPoles());
+
+      for(int i=1;i<=aBSpline->NbPoles();i++)
+        {
+          gp_Pnt2d CurrentPoint = aBSpline->Pole(i);
+          Graphic2d_Vertex aVertex(CurrentPoint.X(),CurrentPoint.Y());
+          anArrayOfVertex(i)=aVertex;
+        }
+      Handle(Graphic2d_Polyline) aPolyline = new Graphic2d_Polyline(aGrObj,anArrayOfVertex);
+      }
+    }
+
+  if (myDisplayCurbure && (anAdaptor.GetType() != GeomAbs_Line))
+  {
+    Standard_Integer ii;
+    Standard_Integer intrv, nbintv = anAdaptor.NbIntervals(GeomAbs_CN);
+    TColStd_Array1OfReal TI(1,nbintv+1);
+    anAdaptor.Intervals(TI,GeomAbs_CN);
+    Standard_Real Resolution = 1.0e-9, Curvature;
+    Geom2dLProp_CLProps2d LProp(myGeom2dCurve, 2, Resolution);
+    gp_Pnt2d P1, P2;    
+
+    for (intrv = 1; intrv <= nbintv; intrv++) 
+     {
+	  Standard_Real t = TI(intrv);
+	  Standard_Real step = (TI(intrv+1) - t) / GetDiscretisation();
+	  Standard_Real LRad, ratio;
+	  for (ii = 1; ii <= myDiscretisation; ii++) 
+       {	 
+	    LProp.SetParameter(t);
+        if (LProp.IsTangentDefined()) 
+         {
+	       Curvature = Abs(LProp.Curvature());
+	       if ( Curvature >  Resolution) 
+            {
+	          myGeom2dCurve->D0(t, P1);
+	          LRad = 1./Curvature;
+	          ratio = ( (  LRad > myradiusmax) ? myradiusmax/LRad : 1 );
+	          ratio *= myradiusratio;
+	          LProp.CentreOfCurvature(P2);
+	          gp_Vec2d V(P1, P2);
+              gp_Pnt2d P3 = P1.Translated(ratio*V);
+              Handle(Graphic2d_Segment) aSegment = new Graphic2d_Segment(aGrObj,P1.X(),P1.Y(),P3.X(),P3.Y());
+	        }
+	     }
+	     t += step;
+	  }
+    }
+  }
+}
+
+
+void ISession2D_Curve::ComputeSelection(const Handle(SelectMgr_Selection)& aSelection,
+				      const Standard_Integer aMode) 
+{ 
+}
+
+

samples/mfc/standard/01_Geometry/src/ISession2D/ISession2D_Curve.h

@@ -0,0 +1,189 @@
+#ifndef _ISession2D_Curve_HeaderFile
+#define _ISession2D_Curve_HeaderFile
+
+#include <Standard_Macro.hxx>
+#include <Standard_DefineHandle.hxx>
+
+
+#include <Quantity_Length.hxx>
+#include <Aspect_TypeOfline.hxx>
+#include <Aspect_WidthOfline.hxx>
+#include <Standard_Integer.hxx>
+#include <SelectMgr_SelectableObject.hxx>
+#include <Handle_PrsMgr_PresentationManager2d.hxx>
+#include <Handle_Graphic2d_GraphicObject.hxx>
+#include <Handle_SelectMgr_Selection.hxx>
+#include <Standard_OStream.hxx>
+#include <Standard_IStream.hxx>
+#include <Standard_CString.hxx>
+
+class TColGeom2d_HSequenceOfCurve;
+class PrsMgr_PresentationManager2d;
+class Graphic2d_GraphicObject;
+class SelectMgr_Selection;
+class ISession2D_ObjectOwner;
+
+#include "Geom2d_Curve.hxx"
+
+#include "AIS_InteractiveObject.hxx"
+
+DEFINE_STANDARD_HANDLE(ISession2D_Curve,AIS_InteractiveObject)
+class ISession2D_Curve : public AIS_InteractiveObject {
+
+public:
+
+ // Methods PUBLIC
+ // 
+
+         ISession2D_Curve
+                    (const Handle_Geom2d_Curve aGeom2dCurve,
+                     const Aspect_TypeOfLine aTypeOfline = Aspect_TOL_SOLID,
+                     const Aspect_WidthOfLine aWidthOfLine = Aspect_WOL_MEDIUM,
+                     const Standard_Integer aColorIndex = 4);
+
+inline   Standard_Integer        NbPossibleSelection() const;
+
+inline   Aspect_TypeOfLine  GetTypeOfLine
+                              () const;
+inline   void               SetTypeOfLine
+                              (const Aspect_TypeOfLine aNewTypeOfLine) ;
+inline   Aspect_WidthOfLine GetWidthOfLine
+                              () const;
+inline   void               SetWidthOfLine
+                              (const Aspect_WidthOfLine aNewWidthOfLine) ;
+inline   Standard_Integer   GetColorIndex
+                              () const;
+inline   void               SetColorIndex
+                              (const Standard_Integer aNewColorIndex) ;
+
+inline   Standard_Boolean  GetDisplayPole
+                              () const;
+inline   void               SetDisplayPole
+                              (const Standard_Boolean aNewDisplayPole) ;
+
+inline   Standard_Boolean  ISession2D_Curve::GetDisplayCurbure
+                              () const;
+inline   void               ISession2D_Curve::SetDisplayCurbure
+                              (const Standard_Boolean aNewDisplayCurbure);
+
+
+inline   Standard_Real  GetDiscretisation
+                              () const;
+inline   void               SetDiscretisation
+                              (const Standard_Real aNewDiscretisation) ;
+
+
+DEFINE_STANDARD_RTTI(ISession2D_Curve)
+
+
+protected:
+
+ // Methods PROTECTED
+ // 
+
+
+ // Fields PROTECTED
+ //
+
+
+private: 
+
+ // Methods PRIVATE
+ // 
+virtual  void Compute(const Handle(PrsMgr_PresentationManager2d)& aPresentationManager,const Handle(Graphic2d_GraphicObject)& aGrObj,const Standard_Integer aMode = 0) ;
+void ComputeSelection(const Handle(SelectMgr_Selection)& aSelection,const Standard_Integer aMode) ;
+
+
+ // Fields PRIVATE
+ //
+Handle_Geom2d_Curve myGeom2dCurve;
+Aspect_TypeOfLine   myTypeOfLine;
+Aspect_WidthOfLine  myWidthOfLine;
+Standard_Integer    myColorIndex;
+Standard_Boolean    myDisplayPole;
+Standard_Boolean    myDisplayCurbure;
+Standard_Real       myDiscretisation;
+Standard_Real       myradiusmax ;
+Standard_Real       myradiusratio ;
+
+
+};
+
+
+
+// other inCurve functions and methods (like "C++: function call" methods)
+//
+
+inline   Standard_Integer  ISession2D_Curve::NbPossibleSelection() const
+{
+return 1;
+}
+
+inline  Aspect_TypeOfLine ISession2D_Curve::GetTypeOfLine() const
+{
+  return myTypeOfLine ;
+}
+ 
+inline  void ISession2D_Curve::SetTypeOfLine(const Aspect_TypeOfLine aNewTypeOfLine) 
+{
+  myTypeOfLine = aNewTypeOfLine;
+}
+
+inline  Aspect_WidthOfLine ISession2D_Curve::GetWidthOfLine() const
+{
+  return myWidthOfLine ;
+}
+
+inline  void ISession2D_Curve::SetWidthOfLine(const Aspect_WidthOfLine aNewWidthOfLine) 
+{
+  myWidthOfLine = aNewWidthOfLine;
+}
+
+inline  Standard_Integer ISession2D_Curve::GetColorIndex() const
+{
+  return myColorIndex ;
+}
+
+inline  void ISession2D_Curve::SetColorIndex(const Standard_Integer aNewColorIndex) 
+{
+  myColorIndex = aNewColorIndex;
+}
+
+inline   Standard_Boolean  ISession2D_Curve::GetDisplayPole
+                              () const
+{
+return myDisplayPole;
+}
+inline   void               ISession2D_Curve::SetDisplayPole
+                              (const Standard_Boolean aNewDisplayPole)
+{
+myDisplayPole = aNewDisplayPole;
+}
+
+inline   Standard_Boolean  ISession2D_Curve::GetDisplayCurbure
+                              () const
+{
+return myDisplayCurbure;
+}
+inline   void               ISession2D_Curve::SetDisplayCurbure
+                              (const Standard_Boolean aNewDisplayCurbure)
+{
+myDisplayCurbure = aNewDisplayCurbure;
+}
+
+ 
+inline   Standard_Real  ISession2D_Curve::GetDiscretisation
+                              () const
+{
+return myDiscretisation;
+}
+inline   void               ISession2D_Curve::SetDiscretisation
+                              (const Standard_Real aNewDiscretisation) 
+{
+myDiscretisation = aNewDiscretisation;
+}
+
+
+
+#endif
+

samples/mfc/standard/01_Geometry/src/ISession2D/ISession2D_InteractiveContext.cpp

@@ -0,0 +1,166 @@
+#include "stdafx.h"
+
+#include <ISession2D_InteractiveContext.h>
+
+IMPLEMENT_STANDARD_HANDLE(ISession2D_InteractiveContext,MMgt_TShared)
+IMPLEMENT_STANDARD_RTTIEXT(ISession2D_InteractiveContext,MMgt_TShared)
+
+#include <Aspect_Window.hxx>
+#include <Aspect_Background.hxx>
+#include <SelectMgr_EntityOwner.hxx>
+#include <SelectMgr_SelectionManager.hxx>
+#include <V2d_Viewer.hxx>
+#include <V2d_View.hxx>
+#include <PrsMgr_PresentationManager2d.hxx>
+#include <StdSelect_ViewerSelector2d.hxx>
+#include <SelectMgr_SelectableObject.hxx>
+#include <TColStd_MapIteratorOfMapOfTransient.hxx>
+
+ ISession2D_InteractiveContext::ISession2D_InteractiveContext()
+{
+}
+
+ ISession2D_InteractiveContext::ISession2D_InteractiveContext(const Handle(V2d_Viewer)& aViewer)
+{
+  Initialize(aViewer);
+}
+
+void ISession2D_InteractiveContext::Initialize(const Handle(V2d_Viewer)& aViewer) 
+{
+  myViewer = aViewer;
+  myPrsmgr           = new PrsMgr_PresentationManager2d(myViewer->View());
+  mySelectionManager = new SelectMgr_SelectionManager();
+  mySelector         = new StdSelect_ViewerSelector2d();
+
+  mySelector->Set(3); 
+  // set Sensitivity very very important for SensitiveCurve !!
+  mySelector->SetSensitivity (0.5);   // en mm
+  mySelectionManager->Add(mySelector);
+
+}
+
+void ISession2D_InteractiveContext::Display(const Handle(AIS_InteractiveObject)& anObject,
+				                       const Standard_Boolean Redraw) 
+{
+   myMapOfObject.Add(anObject);
+   myPrsmgr->Display(anObject);//,anObject->DisplayMode()); 
+    
+   mySelectionManager->Load(anObject,mySelector);
+   mySelectionManager->Activate(anObject,0,mySelector);
+
+  if (Redraw) myViewer->Update();
+}
+
+void ISession2D_InteractiveContext::Erase(const Handle(AIS_InteractiveObject)& anObject,
+			                         const Standard_Boolean Redraw) 
+{
+  if (!anObject.IsNull())
+  {
+    myPrsmgr->Erase(anObject);//,anObject->DisplayMode());
+    mySelectionManager
+      ->Deactivate(anObject,mySelector);
+    if (Redraw) myViewer->Update();
+  }
+}
+
+void ISession2D_InteractiveContext::Move(const Handle(V2d_View)& aView,
+                                    const Standard_Integer x1,
+                                    const Standard_Integer y1) 
+{
+  if (!aBuffer.IsNull())
+  {
+    aBuffer->UnPost(); 
+    aBuffer->Clear();
+  }
+
+  if (myViewer->IsActive())  // A propos de la grille !!!
+    {      
+      aView->ShowHit(x1,y1);
+    }
+
+  aBuffer =new Graphic2d_Buffer(aView->View(),0,0,3,5);
+  mySelector->Pick(x1,y1,aView);  
+  
+  Handle(SelectMgr_SelectableObject) aSelectableObject; 
+
+  mySelector->Init();
+
+  while (mySelector->More())
+  {
+      aSelectableObject = Handle(SelectMgr_SelectableObject)::DownCast(mySelector->Picked()->Selectable());
+
+      myPrsmgr->Dump(aBuffer,aSelectableObject) ;
+      aBuffer->Post();
+
+    mySelector->Next();
+  }
+}
+
+void ISession2D_InteractiveContext::Pick(const Handle(V2d_View)& aView,
+                                    const Standard_Integer x1,
+                                    const Standard_Integer y1) 
+{
+
+  if (myViewer->IsActive())  // A propos de la grille !!!
+    {      
+      aView->ShowHit(x1,y1);
+    }
+
+  mySelector->Pick(x1,y1,aView);  
+ 
+  Handle(SelectMgr_SelectableObject) aSelectableObject; 
+  mySelector->Init();
+  while (mySelector->More())
+  {      
+    Handle(SelectMgr_EntityOwner) aOwn= mySelector->Picked();
+    aSelectableObject = Handle(SelectMgr_SelectableObject)::DownCast(aOwn->Selectable());
+    myPrsmgr->ColorHighlight(aSelectableObject,5,0) ;
+    mySelector->Next();
+  }
+
+  if (myViewer->IsActive())  // A propos de la grille !!!
+    {
+      aView->ShowHit(x1,y1);
+    }
+}
+
+
+void ISession2D_InteractiveContext::DisplayAreas() 
+{
+  myViewer->InitActiveViews();
+  while(myViewer->MoreActiveViews())
+    {
+      Handle(V2d_View)  aView  = myViewer->ActiveView();
+      mySelector->DisplayAreas(aView);    
+      myViewer->NextActiveViews();
+    }
+ myViewer->Update();
+}
+
+void ISession2D_InteractiveContext::ClearAreas() 
+{
+   mySelector->ClearAreas();    
+   myViewer->Update();
+}
+
+void ISession2D_InteractiveContext::EraseAll()
+{
+    TColStd_MapIteratorOfMapOfTransient anIterator(myMapOfObject);
+    for (;anIterator.More();anIterator.Next())
+    {
+        Handle(Standard_Transient) aTransient = anIterator.Key();
+        Handle(AIS_InteractiveObject) anObject = Handle(AIS_InteractiveObject)::DownCast(aTransient);
+
+        if (!anObject.IsNull())
+        {
+            myPrsmgr->Erase(anObject);
+            mySelectionManager
+            ->Deactivate(Handle(AIS_InteractiveObject)::DownCast(anObject),mySelector);
+        }
+        else
+        {
+            Standard_CString ObjectTypeName = aTransient->DynamicType()->Name();
+        }
+    }
+    myViewer->Update();
+}

samples/mfc/standard/01_Geometry/src/ISession2D/ISession2D_InteractiveContext.h

@@ -0,0 +1,98 @@
+// File generated by CPPExt (Transient)
+//
+//                     Copyright (C) 1991,1995 by
+//  
+//                      MATRA DATAVISION, FRANCE
+//  
+// This software is furnished in accordance with the terms and conditions
+// of the contract and with the inclusion of the above copyright notice.
+// This software or any other copy thereof may not be provided or otherwise
+// be made available to any other person. No title to an ownership of the
+// software is hereby transferred.
+//  
+// At the termination of the contract, the software and all copies of this
+// software must be deleted.
+//
+#ifndef _ISession2D_InteractiveContext_HeaderFile
+#define _ISession2D_InteractiveContext_HeaderFile
+
+#include <Standard_Macro.hxx>
+#include <Standard_DefineHandle.hxx>
+
+#include <Handle_V2d_Viewer.hxx>
+#include <Handle_PrsMgr_PresentationManager2d.hxx>
+#include <Handle_SelectMgr_SelectionManager.hxx>
+#include <Handle_StdSelect_ViewerSelector2d.hxx>
+#include <MMgt_TShared.hxx>
+#include <Handle_SelectMgr_SelectableObject.hxx>
+#include <Standard_Boolean.hxx>
+#include <Handle_V2d_View.hxx>
+#include <Graphic2d_Buffer.hxx>
+
+class V2d_Viewer;
+class PrsMgr_PresentationManager2d;
+class SelectMgr_SelectionManager;
+#include <StdSelect_ViewerSelector2d.hxx>
+class SelectMgr_SelectableObject;
+class V2d_View;
+#include "TColStd_MapOfTransient.hxx"
+DEFINE_STANDARD_HANDLE(ISession2D_InteractiveContext,MMgt_TShared)
+class ISession2D_InteractiveContext : public MMgt_TShared {
+
+public:
+	void EraseAll();
+
+ // Methods PUBLIC
+ // 
+ISession2D_InteractiveContext();
+ISession2D_InteractiveContext(const Handle(V2d_Viewer)& aViewer);
+void Initialize(const Handle(V2d_Viewer)& aViewer) ;
+void Display(const Handle(AIS_InteractiveObject)& anObject,const Standard_Boolean Redraw = Standard_True) ;
+void Erase(const Handle(AIS_InteractiveObject)& anObject,const Standard_Boolean Redraw = Standard_True) ;
+virtual  void Move(const Handle(V2d_View)& aView,const Standard_Integer x1,const Standard_Integer y1) ;
+void Pick(const Handle(V2d_View)& aView,
+          const Standard_Integer x1,
+          const Standard_Integer y1);
+
+void DisplayAreas() ;
+void ClearAreas() ;
+
+DEFINE_STANDARD_RTTI(ISession2D_InteractiveContext)
+
+protected:
+
+ // Methods PROTECTED
+ // 
+
+
+ // Fields PROTECTED
+ //
+
+
+private: 
+	TColStd_MapOfTransient myMapOfObject;
+
+ // Methods PRIVATE
+ // 
+
+
+ // Fields PRIVATE
+ //
+Handle(V2d_Viewer) myViewer;
+Handle_PrsMgr_PresentationManager2d myPrsmgr;
+Handle_SelectMgr_SelectionManager mySelectionManager;
+Handle_StdSelect_ViewerSelector2d mySelector;
+
+
+// for dynamic selection 
+Handle(Graphic2d_Buffer) aBuffer;
+
+
+};
+
+
+// other inline functions and methods (like "C++: function call" methods)
+//
+
+
+#endif

samples/mfc/standard/01_Geometry/src/ISession2D/ISession2D_SensitiveCurve.cpp

@@ -0,0 +1,145 @@
+// Copyright: 	Matra-Datavision 1995
+
+#include "stdafx.h"
+
+#include <ISession2D_SensitiveCurve.h>
+
+IMPLEMENT_STANDARD_HANDLE(ISession2D_SensitiveCurve,Select2D_SensitiveEntity)
+IMPLEMENT_STANDARD_RTTIEXT(ISession2D_SensitiveCurve,Select2D_SensitiveEntity)
+
+#include <Bnd_Box2d.hxx>
+#include <gp_Lin2d.hxx>
+#include <gp_Dir2d.hxx>
+#include <gp_Vec2d.hxx>
+#include <TColgp_Array1OfPnt2d.hxx>
+#include <SelectBasics_BasicTool.hxx>
+#include "GCPnts_TangentialDeflection.hxx"
+#include "Geom2dAdaptor_Curve.hxx"
+
+//=====================================================
+// Function : Create
+// Purpose  :Constructor
+//=====================================================
+
+
+ISession2D_SensitiveCurve::
+ISession2D_SensitiveCurve(const Handle(SelectBasics_EntityOwner)& OwnerId,
+                        const Handle(Geom2d_Curve)& C,
+                        const Standard_Real CDeflect,
+                        const Standard_Integer MaxRect):
+Select2D_SensitiveEntity(OwnerId),
+myMaxRect(MaxRect),
+myCurve(C),
+myCDeflect(CDeflect)
+{
+  Compute();
+}
+
+void     ISession2D_SensitiveCurve::Compute()
+{
+   Geom2dAdaptor_Curve Curve (myCurve);
+   Standard_Real ADeflect = 180; //Angular deflection
+    
+   GCPnts_TangentialDeflection PointsOnCurve;
+   PointsOnCurve.Initialize (Curve, ADeflect, myCDeflect,myMaxRect,1.0e-9); 
+
+
+   myPolyP2d = new TColgp_HArray1OfPnt2d(1,PointsOnCurve.NbPoints());
+
+   gp_Pnt P; 
+   for (Standard_Integer i=1; i<=PointsOnCurve.NbPoints();i++) {
+   P = PointsOnCurve.Value (i);
+   myPolyP2d->SetValue(i,gp_Pnt2d(P.X(),P.Y()));
+   }
+
+}
+
+
+//=====================================================
+// Function : Areas 
+// Purpose  :  return the bounding boxes
+//=====================================================
+void  ISession2D_SensitiveCurve::Areas(SelectBasics_ListOfBox2d& boxes) 
+{ 
+    // calcul des Areas --> le nombre voulu est myMaxRect
+    //  mais il y a myPolyP2d->Length() segments
+
+  Standard_Integer NbSeg = myPolyP2d->Length()-1;
+  Standard_Integer nbPerBoxes= NbSeg/myMaxRect;
+
+  Standard_Integer CurrentPoint =1;
+  for (Standard_Integer i=1;i<=myMaxRect-1;i++)
+  { 
+    Bnd_Box2d abox;
+    abox.Set(myPolyP2d->Value(CurrentPoint));
+    for(Standard_Integer j=1;j<=nbPerBoxes;j++)
+    {
+      CurrentPoint++;
+      abox.Add(myPolyP2d->Value(CurrentPoint));
+    }
+   boxes.Append(abox);
+  }
+    Bnd_Box2d abox;
+    abox.Set(myPolyP2d->Value(CurrentPoint));
+    for(Standard_Integer j=CurrentPoint;j<=myPolyP2d->Length()-1;j++)
+    {
+      CurrentPoint++;
+      abox.Add(myPolyP2d->Value(CurrentPoint));
+    }
+   boxes.Append(abox);
+
+} 
+
+//=======================================================
+// Function : Matches 
+// Purpose  : test : segments in the bounding boxe
+//=======================================================
+Standard_Boolean ISession2D_SensitiveCurve::
+Matches (const Standard_Real XMin,
+         const Standard_Real YMin,
+         const Standard_Real XMax,
+         const Standard_Real YMax,
+         const Standard_Real aTol)
+{
+
+  Bnd_Box2d BoundBox;
+  BoundBox.Update(XMin-aTol,YMin-aTol,XMax+aTol,YMax+aTol);
+  
+  for(Standard_Integer j=1;j<=myPolyP2d->Length()-1;j++)
+    {
+      if(BoundBox.IsOut(myPolyP2d->Value(j))) return Standard_False;
+    }
+  return Standard_True;
+
+}
+
+//====================================================
+// Function : Matches 
+// Purpose  : test the real dist to the segments
+//====================================================
+Standard_Boolean ISession2D_SensitiveCurve::
+  Matches(const Standard_Real X,
+        const Standard_Real Y,
+        const Standard_Real aTol,
+        Standard_Real&  DMin)
+{
+  // VERY VERY IMPORTANT : set the selector sensibility !!! ( it's aTol !! )
+  Standard_Integer Rank=0; // New in 2.0
+  if (aTol == 0) {TRACE0("VERY VERY IMPORTANT : set the selector sensibility !!! ( it's aTol !! )");}
+
+  Standard_Boolean Result =  SelectBasics_BasicTool::MatchPolyg2d(myPolyP2d->Array1(),
+                                                X,Y,
+                                                aTol,
+                                                DMin,
+												Rank); // new in 2.0
+  return Result;
+}
+
+
+Handle(TColgp_HArray1OfPnt2d) ISession2D_SensitiveCurve::
+SensitivePolygon()
+{
+  return myPolyP2d;
+}
+
+

samples/mfc/standard/01_Geometry/src/ISession2D/ISession2D_SensitiveCurve.h

@@ -0,0 +1,109 @@
+// File generated by CPPExt (Transient)
+//
+//                     Copyright (C) 1991,1995 by
+//  
+//                      MATRA DATAVISION, FRANCE
+//  
+// This software is furnished in accordance with the terms and conditions
+// of the contract and with the inclusion of the above copyright notice.
+// This software or any other copy thereof may not be provided or otherwise
+// be made available to any other person. No title to an ownership of the
+// software is hereby transferred.
+//  
+// At the termination of the contract, the software and all copies of this
+// software must be deleted.
+//
+#ifndef _ISession2D_SensitiveCurve_HeaderFile
+#define _ISession2D_SensitiveCurve_HeaderFile
+#include <Standard_Macro.hxx>
+#include <Standard_DefineHandle.hxx>
+
+
+#include <Standard_Integer.hxx>
+#include <gp_Pnt2d.hxx>
+#include <Select2D_SensitiveEntity.hxx>
+#include <Handle_SelectBasics_EntityOwner.hxx>
+#include <Standard_Boolean.hxx>
+#include <Standard_Real.hxx>
+class SelectBasics_EntityOwner;
+class gp_Pnt2d;
+#include <SelectBasics_ListOfBox2d.hxx>
+#include "TColgp_HArray1OfPnt2d.hxx"
+#include <Geom2d_Curve.hxx>
+
+
+DEFINE_STANDARD_HANDLE(ISession2D_SensitiveCurve,Select2D_SensitiveEntity)
+class ISession2D_SensitiveCurve : public Select2D_SensitiveEntity {
+
+public:
+
+ // Methods PUBLIC
+ // 
+Standard_EXPORT ISession2D_SensitiveCurve(const Handle(SelectBasics_EntityOwner)& OwnerId,
+                                        const Handle(Geom2d_Curve)& C,
+                                        const Standard_Real CDeflect,
+                                        const Standard_Integer      MaxRect  = 3);
+inline   void SetMaxBoxes(const Standard_Integer MaxRect) ;
+inline virtual  Standard_Integer MaxBoxes() const;
+
+inline   void SetCurve(const Handle(Geom2d_Curve) aCurve) ;
+inline   Handle(Geom2d_Curve) GetCurve() ;
+
+void     Compute();
+
+
+Standard_EXPORT   void Areas(SelectBasics_ListOfBox2d& aSeq) ;
+
+Standard_EXPORT   Standard_Boolean Matches(const Standard_Real XMin,const Standard_Real YMin,const Standard_Real XMax,const Standard_Real YMax,const Standard_Real aTol) ;
+Standard_EXPORT   Standard_Boolean Matches(const Standard_Real X,const Standard_Real Y,const Standard_Real aTol,Standard_Real& DMin) ;
+
+Handle(TColgp_HArray1OfPnt2d) SensitivePolygon();
+
+DEFINE_STANDARD_RTTI(ISession2D_SensitiveCurve)
+
+protected:
+
+ // Methods PROTECTED
+ // 
+
+
+ // Fields PROTECTED
+ //
+
+
+private: 
+
+ // Methods PRIVATE
+ // 
+
+
+ // Fields PRIVATE
+ //
+Standard_Real myCDeflect;
+Standard_Integer     myMaxRect;
+Handle(Geom2d_Curve) myCurve;
+
+Handle(TColgp_HArray1OfPnt2d) myPolyP2d;
+
+};
+
+inline Standard_Integer ISession2D_SensitiveCurve::
+MaxBoxes() const {return myMaxRect;}
+
+inline void ISession2D_SensitiveCurve::
+SetMaxBoxes(const Standard_Integer nbrect)
+{myMaxRect = nbrect;}
+
+inline void ISession2D_SensitiveCurve::
+SetCurve(const Handle(Geom2d_Curve) aCurve) 
+{myCurve = aCurve;} 
+
+inline Handle(Geom2d_Curve) ISession2D_SensitiveCurve::
+GetCurve() 
+{return myCurve;} 
+
+// other inline functions and methods (like "C++: function call" methods)
+//
+
+
+#endif

samples/mfc/standard/01_Geometry/src/ISession2D/ISession_Curve.cpp

@@ -0,0 +1,64 @@
+// ISession_Curve.cpp: implementation of the ISession_Curve class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#include "stdafx.h"
+#include "..\\GeometryApp.h"
+#include "ISession_Curve.h"
+
+IMPLEMENT_STANDARD_HANDLE(ISession_Curve,AIS_InteractiveObject)
+IMPLEMENT_STANDARD_RTTIEXT(ISession_Curve,AIS_InteractiveObject)
+
+#include "StdPrs_Curve.hxx"
+#include "GeomAdaptor_Curve.hxx"
+#include "StdPrs_PoleCurve.hxx"
+#ifdef _DEBUG
+#undef THIS_FILE
+static char THIS_FILE[]=__FILE__;
+#endif
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+
+ISession_Curve::ISession_Curve(Handle(Geom_Curve)& aCurve)
+:AIS_InteractiveObject(),myCurve(aCurve)
+{
+
+}
+
+ISession_Curve::~ISession_Curve()
+{
+
+}
+void ISession_Curve::Compute(const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,
+                             const Handle(Prs3d_Presentation)& aPresentation,
+                             const Standard_Integer aMode)
+{
+    GeomAdaptor_Curve anAdaptorCurve(myCurve);
+    Handle(AIS_Drawer) aDrawer = new AIS_Drawer();
+    aDrawer->LineAspect()->SetColor(Quantity_NOC_RED);
+
+    switch (aMode)
+    {
+        case 1 :
+        StdPrs_PoleCurve::Add(aPresentation, anAdaptorCurve,aDrawer);
+        case 0 :
+        StdPrs_Curve::Add( aPresentation, anAdaptorCurve ,myDrawer);
+        break;
+    }
+}
+
+void ISession_Curve::Compute(const Handle(Prs3d_Projector)& aProjector,
+                             const Handle(Prs3d_Presentation)& aPresentation) 
+ {
+
+ }
+
+void ISession_Curve::ComputeSelection(const Handle(SelectMgr_Selection)& aSelection,
+				      const Standard_Integer aMode) 
+{ 
+}
+
+

samples/mfc/standard/01_Geometry/src/ISession2D/ISession_Curve.h

@@ -0,0 +1,31 @@
+// ISession_Curve.h: interface for the ISession_Curve class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_ISESSION_CURVE_H__F981CB93_A3CC_11D1_8DA3_0800369C8A03__INCLUDED_)
+#define AFX_ISESSION_CURVE_H__F981CB93_A3CC_11D1_8DA3_0800369C8A03__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+#include <Standard_Macro.hxx>
+#include <Standard_DefineHandle.hxx>
+#include "AIS_InteractiveObject.hxx"
+DEFINE_STANDARD_HANDLE(ISession_Curve,AIS_InteractiveObject)
+
+class ISession_Curve : public AIS_InteractiveObject  
+{
+public:
+	ISession_Curve(Handle(Geom_Curve)& aCurve);
+	virtual ~ISession_Curve();
+DEFINE_STANDARD_RTTI(ISession_Curve)
+private:
+
+Standard_EXPORT virtual  void Compute(const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,const Handle(Prs3d_Presentation)& aPresentation,const Standard_Integer aMode = 0) ;
+Standard_EXPORT virtual  void Compute(const Handle(Prs3d_Projector)& aProjector,const Handle(Prs3d_Presentation)& aPresentation) ;
+void ComputeSelection(const Handle(SelectMgr_Selection)& aSelection,const Standard_Integer aMode) ;
+
+Handle(Geom_Curve) myCurve;
+};
+
+#endif // !defined(AFX_ISESSION_CURVE_H__F981CB93_A3CC_11D1_8DA3_0800369C8A03__INCLUDED_)

samples/mfc/standard/01_Geometry/src/ISession2D/ISession_Direction.cpp

@@ -0,0 +1,120 @@
+// ISession_Direction.cpp: implementation of the ISession_Direction class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#include "stdafx.h"
+#include "..\\GeometryApp.h"
+#include "ISession_Direction.h"
+
+#ifdef _DEBUG
+#undef THIS_FILE
+static char THIS_FILE[]=__FILE__;
+#endif
+
+IMPLEMENT_STANDARD_HANDLE(ISession_Direction,AIS_InteractiveObject)
+IMPLEMENT_STANDARD_RTTIEXT(ISession_Direction,AIS_InteractiveObject)
+
+#include "Graphic2d_SetOfSegments.hxx"
+#include "gp_Vec2d.hxx"
+#include "DsgPrs_LengthPresentation.hxx"
+#include "Prs3d_ArrowAspect.hxx"
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+ISession_Direction::ISession_Direction()
+{
+
+}
+
+ISession_Direction::ISession_Direction(gp_Pnt& aPnt,gp_Dir&   aDir,Standard_Real aLength,Standard_Real anArrowLength)
+:myPnt(aPnt),myDir(aDir),myLength(aLength),myArrowLength(anArrowLength)
+{}
+
+ISession_Direction::ISession_Direction(gp_Pnt& aPnt,gp_Vec&   aVec,Standard_Real anArrowLength)
+:myPnt(aPnt),myDir(aVec),myArrowLength(anArrowLength)
+{
+  myLength = aVec.Magnitude();
+}
+
+ISession_Direction::ISession_Direction(gp_Pnt2d& aPnt2d,
+                                       gp_Dir2d& aDir2d,
+                                       Standard_Real aLength)
+:myPnt(gp_Pnt(aPnt2d.X(),aPnt2d.Y(),0)),myDir(gp_Dir(aDir2d.X(),aDir2d.Y(),0)),myLength(aLength)
+{}
+
+ISession_Direction::ISession_Direction(gp_Pnt2d& aPnt2d,
+                                       gp_Vec2d&   aVec2d)
+:myPnt(gp_Pnt(aPnt2d.X(),aPnt2d.Y(),0)),myDir(gp_Dir(aVec2d.X(),aVec2d.Y(),0))
+{
+  myLength = aVec2d.Magnitude();
+}
+
+
+ISession_Direction::~ISession_Direction()
+{
+
+}
+
+void ISession_Direction::Compute(const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,
+                             const Handle(Prs3d_Presentation)& aPresentation,
+                             const Standard_Integer aMode)
+{
+    Handle(Prs3d_ArrowAspect) anArrowAspect = myDrawer->ArrowAspect();
+    anArrowAspect->SetLength(myArrowLength);
+    myDrawer->SetArrowAspect(anArrowAspect);
+
+    gp_Pnt LastPoint = myPnt  ;
+    LastPoint.Translate (myLength*gp_Vec(myDir))  ;
+
+    if (myText.Length() == 0)
+        DsgPrs_LengthPresentation::Add(aPresentation,myDrawer,myPnt,LastPoint,DsgPrs_AS_LASTAR);
+    else
+    {
+        gp_Pnt OffsetPoint = myPnt;
+        OffsetPoint.Translate ( (myLength) *gp_Vec(myDir))  ;
+        DsgPrs_LengthPresentation::Add(aPresentation,myDrawer,myText,myPnt,LastPoint, -myDir, OffsetPoint,  DsgPrs_AS_LASTAR);
+    }
+}
+
+
+void ISession_Direction::Compute(const Handle(Prs3d_Projector)& aProjector,
+                             const Handle(Prs3d_Presentation)& aPresentation) 
+ {
+ }
+
+void ISession_Direction::Compute(const Handle(PrsMgr_PresentationManager2d)& aPresentationManager,
+			     const Handle(Graphic2d_GraphicObject)& aGrObj,
+			     const Standard_Integer aMode) 
+{
+    Handle(Graphic2d_SetOfSegments) segment;
+    segment = new Graphic2d_SetOfSegments(aGrObj);
+
+    segment->Add(myPnt.X(),
+                 myPnt.Y(),
+                 myPnt.X()+myLength*myDir.X(),
+                 myPnt.Y()+myLength*myDir.Y());
+
+    gp_Dir2d aFirstDir = gp_Dir2d(myDir.X(),myDir.Y()).Rotated (200*PI180) ;
+    segment->Add(myPnt.X()+myLength*myDir.X(),
+                 myPnt.Y()+myLength*myDir.Y(),
+                 myPnt.X()+myLength*myDir.X()+ myLength*aFirstDir.X()/5 ,
+                 myPnt.Y()+myLength*myDir.Y()+ myLength*aFirstDir.Y()/5 );
+
+    gp_Dir2d aSecondDir = gp_Dir2d(myDir.X(),myDir.Y()).Rotated (-200*PI180) ;
+    segment->Add(myPnt.X()+myLength*myDir.X(),
+                 myPnt.Y()+myLength*myDir.Y(),
+                 myPnt.X()+myLength*myDir.X()+ myLength*aSecondDir.X()/5 ,
+                 myPnt.Y()+myLength*myDir.Y()+ myLength*aSecondDir.Y()/5 );
+
+}
+void ISession_Direction::ComputeSelection(const Handle(SelectMgr_Selection)& aSelection,
+				      const Standard_Integer aMode) 
+{ 
+}
+
+void ISession_Direction::SetText(TCollection_ExtendedString & aText)
+{
+    myText = aText;
+}

samples/mfc/standard/01_Geometry/src/ISession2D/ISession_Direction.h

@@ -0,0 +1,47 @@
+// ISession_Direction.h: interface for the ISession_Direction class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_ISession_Direction_H__767C0DB3_A3B0_11D1_8DA3_0800369C8A03__INCLUDED_)
+#define AFX_ISession_Direction_H__767C0DB3_A3B0_11D1_8DA3_0800369C8A03__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+#include "gp_Dir2d.hxx"
+
+DEFINE_STANDARD_HANDLE(ISession_Direction,AIS_InteractiveObject)
+class ISession_Direction : public AIS_InteractiveObject  
+{
+public:
+	TCollection_ExtendedString myText;
+	void SetText(TCollection_ExtendedString& aText);
+	ISession_Direction();
+    ISession_Direction(gp_Pnt& aPnt,gp_Dir&   aDir,Standard_Real aLength=1,Standard_Real anArrowLength=1);
+    ISession_Direction(gp_Pnt& aPnt,gp_Vec&   aVec,Standard_Real anArrowLength=1);
+
+    ISession_Direction(gp_Pnt2d& aPnt2d,gp_Dir2d&   aDir2d,Standard_Real aLength=1);
+    ISession_Direction(gp_Pnt2d& aPnt2d,gp_Vec2d&   aVec2d);
+
+	virtual ~ISession_Direction();
+    DEFINE_STANDARD_RTTI(ISession_Direction)
+
+private:
+
+    void Compute         (const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,
+                          const Handle(Prs3d_Presentation)& aPresentation,
+                          const Standard_Integer aMode);
+    void Compute         (const Handle(Prs3d_Projector)& aProjector,
+                          const Handle(Prs3d_Presentation)& aPresentation) ;
+    virtual  void Compute(const Handle(PrsMgr_PresentationManager2d)& aPresentationManager,
+                          const Handle(Graphic2d_GraphicObject)& aGrObj,
+                          const Standard_Integer aMode = 0) ;
+    void ComputeSelection(const Handle(SelectMgr_Selection)& aSelection,const Standard_Integer aMode) ;
+
+    gp_Pnt myPnt;
+    gp_Dir myDir;
+    Standard_Real myLength;
+    Quantity_Length myArrowLength;
+};
+
+#endif // !defined(AFX_ISession_Direction_H__767C0DB3_A3B0_11D1_8DA3_0800369C8A03__INCLUDED_)

samples/mfc/standard/01_Geometry/src/ISession2D/ISession_Point.cpp

@@ -0,0 +1,73 @@
+// ISession_Point.cpp: implementation of the ISession_Point class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#include "stdafx.h"
+#include "..\\GeometryApp.h"
+#include "ISession_Point.h"
+
+#ifdef _DEBUG
+#undef THIS_FILE
+static char THIS_FILE[]=__FILE__;
+//#define new DEBUG_NEW
+#endif
+IMPLEMENT_STANDARD_HANDLE(ISession_Point,AIS_InteractiveObject)
+IMPLEMENT_STANDARD_RTTIEXT(ISession_Point,AIS_InteractiveObject)
+
+#include "Graphic2d_CircleMarker.hxx"
+#include "StdPrs_Point.hxx"
+#include "Geom_CartesianPoint.hxx"
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+ISession_Point::ISession_Point(Standard_Real X,Standard_Real Y ,Standard_Real Z)
+:myPoint(gp_Pnt(X,Y,Z))
+{
+
+}
+
+ISession_Point::ISession_Point(gp_Pnt2d& aPoint,Standard_Real Elevation)
+:myPoint(gp_Pnt(aPoint.X(),aPoint.Y(),Elevation))
+{
+
+}
+
+ISession_Point::ISession_Point(gp_Pnt& aPoint)
+:myPoint(aPoint)
+{
+
+}
+
+ISession_Point::~ISession_Point()
+{
+
+}
+
+void ISession_Point::Compute(const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,
+                             const Handle(Prs3d_Presentation)& aPresentation,
+                             const Standard_Integer aMode)
+{
+    Handle(Geom_CartesianPoint) aGeomPoint = new Geom_CartesianPoint(myPoint);
+
+    StdPrs_Point::Add(aPresentation,aGeomPoint,myDrawer);
+ }
+
+
+void ISession_Point::Compute(const Handle(Prs3d_Projector)& aProjector,
+                             const Handle(Prs3d_Presentation)& aPresentation) 
+ {
+ }
+
+void ISession_Point::Compute(const Handle(PrsMgr_PresentationManager2d)& aPresentationManager, 
+                         const Handle(Graphic2d_GraphicObject)& aGrObj, 
+                         const Standard_Integer unMode)
+{
+  Handle(Graphic2d_CircleMarker) aCircleMarker;
+  aCircleMarker = new Graphic2d_CircleMarker(aGrObj,myPoint.X(),myPoint.Y(),0,0,1);
+}
+
+void ISession_Point::ComputeSelection(const Handle(SelectMgr_Selection)& aSelection, 
+				      const Standard_Integer unMode)
+{
+}
+

samples/mfc/standard/01_Geometry/src/ISession2D/ISession_Point.h

@@ -0,0 +1,45 @@
+// ISession_Point.h: interface for the ISession_Point class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_ISESSION_POINT_H__A9B277C3_A69E_11D1_8DA4_0800369C8A03__INCLUDED_)
+#define AFX_ISESSION_POINT_H__A9B277C3_A69E_11D1_8DA4_0800369C8A03__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#include <Standard_Macro.hxx>
+#include <Standard_DefineHandle.hxx>
+
+
+DEFINE_STANDARD_HANDLE(ISession_Point,AIS_InteractiveObject)
+class ISession_Point : public AIS_InteractiveObject  
+{
+public:
+	ISession_Point();
+    ISession_Point(Standard_Real X,Standard_Real Y ,Standard_Real Z);
+    ISession_Point(gp_Pnt2d& aPoint,Standard_Real Elevation = 0);
+    ISession_Point(gp_Pnt& aPoint);
+
+	virtual ~ISession_Point();
+    DEFINE_STANDARD_RTTI(ISession_Point)
+
+private :
+
+void Compute          (const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,
+                       const Handle(Prs3d_Presentation)& aPresentation,
+                       const Standard_Integer aMode);
+void Compute          (const Handle(Prs3d_Projector)& aProjector,
+                       const Handle(Prs3d_Presentation)& aPresentation) ;
+void Compute          (const Handle(PrsMgr_PresentationManager2d)& aPresentationManager,
+                       const Handle(Graphic2d_GraphicObject)& aGrObj,
+                       const Standard_Integer unMode = 0) ;
+void ComputeSelection (const Handle(SelectMgr_Selection)& aSelection,
+                       const Standard_Integer unMode) ;
+
+gp_Pnt myPoint;
+
+};
+
+#endif // !defined(AFX_ISESSION_POINT_H__A9B277C3_A69E_11D1_8DA4_0800369C8A03__INCLUDED_)

samples/mfc/standard/01_Geometry/src/ISession2D/ISession_Surface.cpp

@@ -0,0 +1,72 @@
+// ISession_Surface.cpp: implementation of the ISession_Surface class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#include "stdafx.h"
+#include "..\\GeometryApp.h"
+#include "ISession_Surface.h"
+
+#ifdef _DEBUG
+#undef THIS_FILE
+static char THIS_FILE[]=__FILE__;
+//#define new DEBUG_NEW
+#endif
+IMPLEMENT_STANDARD_HANDLE(ISession_Surface,AIS_InteractiveObject)
+IMPLEMENT_STANDARD_RTTIEXT(ISession_Surface,AIS_InteractiveObject)
+
+#include "GeomAdaptor_Surface.hxx"
+#include "StdPrs_WFSurface.hxx"
+#include "StdPrs_WFPoleSurface.hxx"
+#include "GeomAdaptor_HSurface.hxx"
+#include "AIS_Drawer.hxx"
+#include "Prs3d_IsoAspect.hxx"
+#include "StdPrs_WFDeflectionShape.hxx"
+#include "StdPrs_ShadedSurface.hxx"
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+ISession_Surface::ISession_Surface(Handle(Geom_Surface)& aSurface)
+:AIS_InteractiveObject(),mySurface(aSurface)
+{
+}
+
+ISession_Surface::~ISession_Surface()
+{
+
+}
+void ISession_Surface::Compute(const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,
+                             const Handle(Prs3d_Presentation)& aPresentation,
+                             const Standard_Integer aMode)
+{
+
+    GeomAdaptor_Surface anAdaptorSurface(mySurface);
+    Handle(GeomAdaptor_HSurface) anAdaptorHSurface = new GeomAdaptor_HSurface(mySurface);
+
+    Handle(AIS_Drawer) aDrawer = new AIS_Drawer();
+    aDrawer->LineAspect()->SetColor(Quantity_NOC_YELLOW3);
+
+    switch (aMode)
+    {
+        case 2:
+	      StdPrs_ShadedSurface::Add(aPresentation,anAdaptorSurface,myDrawer);
+        break;
+        case 1 :
+          StdPrs_WFPoleSurface::Add(aPresentation,anAdaptorSurface,aDrawer);
+        case 0 :
+          StdPrs_WFSurface::Add(aPresentation,anAdaptorHSurface,myDrawer);
+        break;
+    }
+
+}
+
+void ISession_Surface::Compute(const Handle(Prs3d_Projector)& aProjector,
+                             const Handle(Prs3d_Presentation)& aPresentation) 
+{
+}
+
+void ISession_Surface::ComputeSelection(const Handle(SelectMgr_Selection)& aSelection,
+				      const Standard_Integer aMode) 
+{ 
+}

samples/mfc/standard/01_Geometry/src/ISession2D/ISession_Surface.h

@@ -0,0 +1,34 @@
+// ISession_Surface.h: interface for the ISession_Surface class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_ISESSION_SURFACE_H__27F86F5A_A6A4_11D1_8DA4_0800369C8A03__INCLUDED_)
+#define AFX_ISESSION_SURFACE_H__27F86F5A_A6A4_11D1_8DA4_0800369C8A03__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#include <Standard_Macro.hxx>
+#include <Standard_DefineHandle.hxx>
+
+DEFINE_STANDARD_HANDLE(ISession_Surface,AIS_InteractiveObject)
+class ISession_Surface : public AIS_InteractiveObject  
+{
+public:
+	ISession_Surface();
+	ISession_Surface(Handle(Geom_Surface)& aSurface);
+	virtual ~ISession_Surface();
+
+DEFINE_STANDARD_RTTI(ISession_Surface)
+private:
+
+Standard_EXPORT virtual  void Compute(const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,const Handle(Prs3d_Presentation)& aPresentation,const Standard_Integer aMode = 0) ;
+Standard_EXPORT virtual  void Compute(const Handle(Prs3d_Projector)& aProjector,const Handle(Prs3d_Presentation)& aPresentation) ;
+void ComputeSelection(const Handle(SelectMgr_Selection)& aSelection,const Standard_Integer aMode) ;
+
+Handle(Geom_Surface) mySurface;
+
+};
+
+#endif // !defined(AFX_ISESSION_SURFACE_H__27F86F5A_A6A4_11D1_8DA4_0800369C8A03__INCLUDED_)

samples/mfc/standard/01_Geometry/src/ISession2D/ISession_Text.cpp

@@ -0,0 +1,113 @@
+// ISession_Text.cpp: implementation of the ISession_Text class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#include "stdafx.h"
+#include "..\\GeometryApp.h"
+#include "ISession_Text.h"
+
+#ifdef _DEBUG
+#undef THIS_FILE
+static char THIS_FILE[]=__FILE__;
+//#define new DEBUG_NEW
+#endif
+IMPLEMENT_STANDARD_HANDLE(ISession_Text,AIS_InteractiveObject)
+IMPLEMENT_STANDARD_RTTIEXT(ISession_Text,AIS_InteractiveObject)
+
+#include <Graphic2d_Text.hxx>
+#include <Select2D_SensitiveBox.hxx>
+#include <Graphic2d_Segment.hxx>
+#include <OSD_Environment.hxx>
+#include <Graphic2d_View.hxx>
+#include <Graphic2d_Drawer.hxx>
+#include "PrsMgr_PresentationManager2d.hxx"
+#include "SelectMgr_Selection.hxx"
+#include "Graphic2d_Array1OfVertex.hxx"
+#include "Graphic2d_Polyline.hxx"
+#include "Graphic2d_Vertex.hxx"
+#include "Graphic2d_DisplayList.hxx"
+#include "Prs3d_Text.hxx"
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+ISession_Text::ISession_Text()
+{
+
+}
+
+
+ISession_Text::ISession_Text
+                 (const TCollection_AsciiString& aText, 
+                  const Standard_Real            anX ,        // = 0
+                  const Standard_Real            anY ,        // = 0
+                  const Standard_Real            aZ  ,        // = 0
+			      const Aspect_TypeOfText        aType,       // = SOLID,
+			      const Quantity_PlaneAngle      anAngle,     // = 0.0
+			      const Standard_Real            aslant,      // = 0.0
+			      const Standard_Integer         aColorIndex, // = 0
+			      const Standard_Integer         aFontIndex,  // = 1
+			      const Quantity_Factor          aScale)      // = 1
+                  :AIS_InteractiveObject(),MyText(aText),MyX(anX),MyY(anY),MyZ(aZ),
+                  MyTypeOfText(aType),MyAngle(anAngle),MySlant(aslant),MyFontIndex(aFontIndex),
+                  MyColorIndex(aColorIndex),MyScale(aScale),MyWidth(0),MyHeight(0)
+{}
+
+ISession_Text::ISession_Text
+                 (const TCollection_AsciiString& aText, 
+                  gp_Pnt&                        aPoint,
+			      const Aspect_TypeOfText        aType,       // = SOLID,
+			      const Quantity_PlaneAngle      anAngle,     // = 0.0
+			      const Standard_Real            aslant,      // = 0.0
+			      const Standard_Integer         aColorIndex, // = 0
+			      const Standard_Integer         aFontIndex,  // = 1
+			      const Quantity_Factor          aScale)      // = 1
+                  :AIS_InteractiveObject(),MyText(aText),MyX(aPoint.X()),MyY(aPoint.Y()),MyZ(aPoint.Z()),
+                  MyTypeOfText(aType),MyAngle(anAngle),MySlant(aslant),MyFontIndex(aFontIndex),
+                  MyColorIndex(aColorIndex),MyScale(aScale),MyWidth(0),MyHeight(0)
+{}
+
+
+
+ISession_Text::~ISession_Text()
+{
+
+}
+
+void ISession_Text::Compute(const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,
+                             const Handle(Prs3d_Presentation)& aPresentation,
+                             const Standard_Integer aMode)
+{
+    Prs3d_Text::Draw(aPresentation,myDrawer,MyText,gp_Pnt(  MyX ,MyY,MyZ ));
+}
+
+void ISession_Text::Compute(const Handle(Prs3d_Projector)& aProjector,
+                             const Handle(Prs3d_Presentation)& aPresentation) 
+ {
+ }
+
+void ISession_Text::Compute(const Handle(PrsMgr_PresentationManager2d)& aPresentationManager, 
+                         const Handle(Graphic2d_GraphicObject)& aGrObj, 
+                         const Standard_Integer unMode)
+{
+  Handle(Graphic2d_Text) text;
+  text = new Graphic2d_Text(aGrObj, MyText, MyX, MyY, MyAngle,MyTypeOfText,MyScale);
+  text->SetFontIndex(MyFontIndex);
+ 
+  text->SetColorIndex(MyColorIndex);
+ 
+  text->SetSlant(MySlant);
+  text->SetUnderline(Standard_False);
+  text->SetZoomable(Standard_True);
+  aGrObj->Display();
+  Quantity_Length anXoffset,anYoffset;
+  text->TextSize(MyWidth, MyHeight,anXoffset,anYoffset);
+
+}
+
+void ISession_Text::ComputeSelection(const Handle(SelectMgr_Selection)& aSelection, 
+				      const Standard_Integer unMode)
+{
+}
+

samples/mfc/standard/01_Geometry/src/ISession2D/ISession_Text.h

@@ -0,0 +1,180 @@
+// ISession_Text.h: interface for the ISession_Text class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_ISESSION_TEXT_H__A9B277C4_A69E_11D1_8DA4_0800369C8A03__INCLUDED_)
+#define AFX_ISESSION_TEXT_H__A9B277C4_A69E_11D1_8DA4_0800369C8A03__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#include <Standard_Macro.hxx>
+#include <Standard_DefineHandle.hxx>
+
+#include <TCollection_AsciiString.hxx>
+#include <Aspect_TypeOfText.hxx>
+#include <Standard_Real.hxx>
+#include <Standard_Integer.hxx>
+#include <Quantity_Factor.hxx>
+#include <Quantity_PlaneAngle.hxx>
+#include <Handle_PrsMgr_PresentationManager2d.hxx>
+#include <Handle_Graphic2d_GraphicObject.hxx>
+#include <Handle_SelectMgr_Selection.hxx>
+#include <Standard_OStream.hxx>
+#include <Standard_IStream.hxx>
+#include <Standard_CString.hxx>
+#include <SelectMgr_SelectableObject.hxx>
+
+class TCollection_AsciiString;
+class PrsMgr_PresentationManager2d;
+class Graphic2d_GraphicObject;
+class SelectMgr_Selection;
+
+DEFINE_STANDARD_HANDLE(ISession_Text,AIS_InteractiveObject)
+class ISession_Text : public AIS_InteractiveObject  
+{
+public:
+	ISession_Text();
+
+    ISession_Text           (const TCollection_AsciiString& aText,
+                             const Standard_Real            anX         = 0   ,
+                             const Standard_Real            anY         = 0   ,
+                             const Standard_Real            aZ          = 0   ,
+                             const Aspect_TypeOfText        aType       = Aspect_TOT_SOLID,
+                             const Quantity_PlaneAngle      anAngle     = 0.0 ,
+                             const Standard_Real            aSlant      = 0.0 ,
+                             const Standard_Integer         aColorIndex = 1   ,
+                             const Standard_Integer         aFontIndex  = 1   ,
+                             const Quantity_Factor          aScale      = 0.1   );
+    ISession_Text
+                            (const TCollection_AsciiString& aText, 
+                             gp_Pnt&                        aPoint,
+                             const Aspect_TypeOfText        aType       = Aspect_TOT_SOLID,
+                             const Quantity_PlaneAngle      anAngle     = 0.0 ,
+                             const Standard_Real            aSlant      = 0.0 ,
+                             const Standard_Integer         aColorIndex = 1   ,
+                             const Standard_Integer         aFontIndex  = 1   ,
+                             const Quantity_Factor          aScale      = 0.1   );
+
+	virtual ~ISession_Text();
+
+inline   Standard_Integer        NbPossibleSelection() const;
+inline   TCollection_AsciiString GetText() const;
+inline   void                    SetText(const TCollection_AsciiString& atext) ;
+inline   void                    GetCoord(Standard_Real& X, Standard_Real& Y, Standard_Real& Z) const ;
+inline   void                    SetCoord(const Standard_Real X, const Standard_Real Y, const Standard_Real Z=0);
+inline   Aspect_TypeOfText       GetTypeOfText() const;
+inline   void                    SetTypeOfText(const Aspect_TypeOfText aNewTypeOfText) ;
+inline   Standard_Real           GetAngle() const;
+inline   void                    SetAngle(const Standard_Real aNewAngle) ;
+inline   Standard_Real           GetSlant() const;
+inline   void                    SetSlant(const Standard_Real aNewSlant) ;
+inline   Standard_Integer        GetColorIndex() const;
+inline   void                    SetColorIndex(const Standard_Integer aNewColorIndex) ;
+inline   Standard_Integer        GetFontIndex() const;
+inline   void                    SetFontIndex(const Standard_Integer aNewFontIndex) ;
+inline   Quantity_Factor         GetScale() const;
+inline   void                    SetScale  (const Quantity_Factor aNewScale) ;
+
+
+DEFINE_STANDARD_RTTI(ISession_Text)
+
+
+protected:
+
+ // Methods PROTECTED
+ // 
+
+
+ // Fields PROTECTED
+ //
+
+
+private: 
+
+ // Methods PRIVATE
+ // 
+
+void Compute          (const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,
+                       const Handle(Prs3d_Presentation)& aPresentation,
+                       const Standard_Integer aMode);
+void Compute          (const Handle(Prs3d_Projector)& aProjector,
+                       const Handle(Prs3d_Presentation)& aPresentation);
+void Compute          (const Handle(PrsMgr_PresentationManager2d)& aPresentationManager,
+                       const Handle(Graphic2d_GraphicObject)& aGrObj,
+                       const Standard_Integer unMode = 0) ;
+void ComputeSelection (const Handle(SelectMgr_Selection)& aSelection,
+                       const Standard_Integer unMode) ;
+
+
+ // Fields PRIVATE
+ //
+TCollection_AsciiString MyText       ; 
+Standard_Real           MyX          ;
+Standard_Real           MyY          ;
+Standard_Real           MyZ          ;
+Aspect_TypeOfText       MyTypeOfText ;
+Standard_Real           MyAngle      ;
+Standard_Real           MySlant      ;
+Standard_Integer        MyColorIndex ;
+Standard_Integer        MyFontIndex  ;
+Quantity_Factor         MyScale      ;
+Standard_Real           MyWidth      ;
+Standard_Real           MyHeight     ;
+
+
+};
+
+ inline Standard_Integer ISession_Text::NbPossibleSelection() const 
+{ return 1; }
+
+inline TCollection_AsciiString ISession_Text::GetText() const 
+{  return MyText ; }
+
+inline void ISession_Text::SetText(const TCollection_AsciiString& atext)
+{  MyText = atext; }
+
+inline void ISession_Text::GetCoord(Standard_Real& X, Standard_Real& Y, Standard_Real& Z) const 
+{  X = MyX;  Y = MyY; Z = MyZ;}
+
+inline void ISession_Text::SetCoord(const Standard_Real X, const Standard_Real Y, const Standard_Real Z)
+{  MyX = X ;  MyY = Y ;  MyZ = Z ;}
+
+inline Aspect_TypeOfText ISession_Text::GetTypeOfText() const 
+{  return MyTypeOfText; }
+
+inline void ISession_Text::SetTypeOfText(const Aspect_TypeOfText aNewTypeOfText)
+{  MyTypeOfText = aNewTypeOfText; }
+
+inline Standard_Real ISession_Text::GetAngle() const 
+{  return MyAngle; }
+
+inline void ISession_Text::SetAngle(const Standard_Real aNewAngle)
+{  MyAngle = aNewAngle; }
+
+inline Standard_Real ISession_Text::GetSlant() const 
+{  return MySlant; }
+
+inline void ISession_Text::SetSlant(const Standard_Real aNewSlant)
+{  MySlant = aNewSlant; }
+
+inline Standard_Integer ISession_Text::GetColorIndex() const 
+{  return MyColorIndex; }
+
+inline void ISession_Text::SetColorIndex(const Standard_Integer aNewColorIndex)
+{  MyColorIndex = aNewColorIndex; }
+
+inline Standard_Integer ISession_Text::GetFontIndex() const 
+{ return MyFontIndex; }
+
+inline void ISession_Text::SetFontIndex(const Standard_Integer aNewFontIndex)
+{  MyFontIndex = aNewFontIndex; }
+
+inline Quantity_Factor ISession_Text::GetScale() const 
+{  return MyScale; }
+
+inline void ISession_Text::SetScale(const Quantity_Factor aNewScale)
+{  MyScale  = aNewScale; }
+
+#endif // !defined(AFX_ISESSION_TEXT_H__A9B277C4_A69E_11D1_8DA4_0800369C8A03__INCLUDED_)