Integration of OCCT 6.5.0 from SVN

samples/mfc/standard/01_Geometry/src/ChildFrm.cpp

@@ -0,0 +1,96 @@
+// ChildFrm.cpp : implementation of the CChildFrame class
+//
+
+#include "stdafx.h"
+#include "GeometryApp.h"
+
+#include "ChildFrm.h"
+
+/////////////////////////////////////////////////////////////////////////////
+// CChildFrame
+
+IMPLEMENT_DYNCREATE(CChildFrame, CMDIChildWnd)
+
+BEGIN_MESSAGE_MAP(CChildFrame, CMDIChildWnd)
+	//{{AFX_MSG_MAP(CChildFrame)
+	ON_WM_CREATE()
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+/////////////////////////////////////////////////////////////////////////////
+// CChildFrame construction/destruction
+
+CChildFrame::CChildFrame()
+{
+	// TODO: add member initialization code here
+	
+}
+
+CChildFrame::~CChildFrame()
+{
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// CChildFrame diagnostics
+
+#ifdef _DEBUG
+void CChildFrame::AssertValid() const
+{
+	CMDIChildWnd::AssertValid();
+}
+
+void CChildFrame::Dump(CDumpContext& dc) const
+{
+	CMDIChildWnd::Dump(dc);
+}
+
+#endif //_DEBUG
+
+void CChildFrame::ActivateFrame(int nCmdShow) 
+{
+	// TODO: Add your specialized code here and/or call the base class
+	
+	static BOOL first=true;
+	if(first){
+		first=false;
+		CMDIChildWnd::ActivateFrame(SW_SHOWMAXIMIZED);
+		return;
+	}
+/*
+	POSITION pos=AfxGetApp()->GetFirstDocTemplatePosition();
+	CDocTemplate* DocT=AfxGetApp()->GetNextDocTemplate(pos);
+	POSITION p=DocT->GetFirstDocPosition();
+	DocT->GetNextDoc(p);
+	if(p==NULL)
+		nCmdShow = SW_SHOWMAXIMIZED;      
+*/
+	CMDIChildWnd::ActivateFrame(nCmdShow);
+}
+
+int CChildFrame::OnCreate(LPCREATESTRUCT lpCreateStruct) 
+{
+	if (CMDIChildWnd::OnCreate(lpCreateStruct) == -1)
+		return -1;
+	
+	if (!m_wndToolBar.Create(this) || !m_wndToolBar.LoadToolBar(IDR_3dCHILDFRAME))
+	{
+		TRACE0("Failed to create toolbar\n");
+		return -1; // fail to create
+	}
+
+	m_wndToolBar.SetBarStyle(m_wndToolBar.GetBarStyle() | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
+	m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);
+	EnableDocking(CBRS_ALIGN_ANY);
+	DockControlBar(&m_wndToolBar);
+
+	return 0;
+}
+
+
+
+BOOL CChildFrame::DestroyWindow() 
+{
+	// TODO: Add your specialized code here and/or call the base class
+	
+	return CMDIChildWnd::DestroyWindow();
+}

samples/mfc/standard/01_Geometry/src/ChildFrm.h

@@ -0,0 +1,40 @@
+// ChildFrm.h : interface of the CChildFrame class
+//
+/////////////////////////////////////////////////////////////////////////////
+#if !defined(AFX_ChildFrame_H__338883C5_510A_11D1_A4A8_00C04FB15CA3__INCLUDED_)
+#define AFX_ChildFrame_H__338883C5_510A_11D1_A4A8_00C04FB15CA3__INCLUDED_
+
+#include <OCC_BaseChildFrame.h>
+
+class CChildFrame : public OCC_BaseChildFrame
+{
+	DECLARE_DYNCREATE(CChildFrame)
+public:
+	CChildFrame();
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CChildFrame)
+	public:
+	virtual void ActivateFrame(int nCmdShow = -1);
+	virtual BOOL DestroyWindow();
+	//}}AFX_VIRTUAL
+
+// Implementation
+public:
+	virtual ~CChildFrame();
+#ifdef _DEBUG
+	virtual void AssertValid() const;
+	virtual void Dump(CDumpContext& dc) const;
+#endif
+
+// Generated message map functions
+protected:
+	//{{AFX_MSG(CChildFrame)
+	afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+};
+
+/////////////////////////////////////////////////////////////////////////////
+#endif// MainFrm.cpp : implementation of the CMainFrame class

samples/mfc/standard/01_Geometry/src/ChildFrm2d.cpp

@@ -0,0 +1,91 @@
+// ChildFrm2D.cpp : implementation of the CChildFrame2D class/
+
+#include "stdafx.h"
+
+#include "ChildFrm2d.h"
+
+#include "GeometryApp.h"
+
+IMPLEMENT_DYNCREATE(CChildFrame2D, CMDIChildWnd)
+
+BEGIN_MESSAGE_MAP(CChildFrame2D, CMDIChildWnd)
+	//{{AFX_MSG_MAP(CChildFrame2D)
+	ON_WM_CREATE()
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+static UINT indicators[] =
+{
+	ID_SEPARATOR,           // status line indicator
+	ID_INDICATOR_CAPS,
+	ID_INDICATOR_NUM,
+	ID_INDICATOR_SCRL,
+};
+
+
+/////////////////////////////////////////////////////////////////////////////
+// CChildFrame2D construction/destruction
+
+CChildFrame2D::CChildFrame2D()
+{
+	// TODO: add member initialization code here
+	
+}
+
+CChildFrame2D::~CChildFrame2D()
+{
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// CChildFrame2D diagnostics
+
+#ifdef _DEBUG
+void CChildFrame2D::AssertValid() const
+{
+	CMDIChildWnd::AssertValid();
+}
+
+void CChildFrame2D::Dump(CDumpContext& dc) const
+{
+	CMDIChildWnd::Dump(dc);
+}
+
+#endif //_DEBUG
+
+/////////////////////////////////////////////////////////////////////////////
+// CChildFrame2D message handlers
+
+int CChildFrame2D::OnCreate(LPCREATESTRUCT lpCreateStruct) 
+{
+	
+	if (CMDIChildWnd::OnCreate(lpCreateStruct) == -1)
+		return -1;
+	
+	if (!m_wndToolBar.Create(this) ||
+		!m_wndToolBar.LoadToolBar(IDR_2dCHILDFRAME))
+	{
+		TRACE0("Failed to create toolbar\n");
+		return -1;      // fail to create
+	}
+
+	// TODO: Remove this if you don't want tool tips or a resizeable toolbar
+	m_wndToolBar.SetBarStyle(m_wndToolBar.GetBarStyle() |
+		CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
+
+	// TODO: Delete these three lines if you don't want the toolbar to
+	//  be dockable
+	m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);
+	EnableDocking(CBRS_ALIGN_ANY);
+	DockControlBar(&m_wndToolBar);
+	
+	return 0;
+
+}
+
+
+void CChildFrame2D::ActivateFrame(int nCmdShow) 
+{
+	// TODO: Add your specialized code here and/or call the base class
+	
+	CMDIChildWnd::ActivateFrame(nCmdShow);
+}

samples/mfc/standard/01_Geometry/src/ChildFrm2d.h

@@ -0,0 +1,46 @@
+// ChildFrm.h : interface of the CChildFrame2D class
+//
+/////////////////////////////////////////////////////////////////////////////
+#if !defined(AFX_ChildFrame2D_H__338883C5_510A_11D1_A4A8_00C04FB15CA3__INCLUDED_)
+#define AFX_ChildFrame2D_H__338883C5_510A_11D1_A4A8_00C04FB15CA3__INCLUDED_
+
+#include <OCC_BaseChildFrame.h>
+
+class CChildFrame2D : public OCC_BaseChildFrame
+{
+	DECLARE_DYNCREATE(CChildFrame2D)
+public:
+	CChildFrame2D();
+
+// Attributes
+public:
+
+// Operations
+public:
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CChildFrame2D)
+	public:
+	virtual void ActivateFrame(int nCmdShow = -1);
+	//}}AFX_VIRTUAL
+
+// Implementation
+public:
+	virtual ~CChildFrame2D();
+#ifdef _DEBUG
+	virtual void AssertValid() const;
+	virtual void Dump(CDumpContext& dc) const;
+#endif
+
+// Generated message map functions
+protected:
+	//CToolBar m_wndToolBar;
+	//{{AFX_MSG(CChildFrame2D)
+	afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+};
+
+/////////////////////////////////////////////////////////////////////////////
+#endif

samples/mfc/standard/01_Geometry/src/GeoAlgo_Sol.cxx

@@ -0,0 +1,180 @@
+// File:	GeoAlgo_Sol.cxx
+// Created:	Mon Dec 15 16:32:27 1997
+// Author:	Cascade_Manager
+//		<cascade@savv04>
+
+#include "stdafx.h"
+
+#include "GeoAlgo_Sol.hxx"
+
+#include <Geom_BSplineSurface.hxx>
+#include <Geom_Plane.hxx>
+
+#include <GeomPlate_Surface.hxx>
+#include <GeomPlate_MakeApprox.hxx>
+
+#include <Plate_Plate.hxx>
+#include <Plate_PinpointConstraint.hxx>
+
+#include <TColgp_SequenceOfXYZ.hxx>
+#include <TColgp_Array1OfXYZ.hxx>
+#include <TColgp_Array1OfXY.hxx>
+#include <TColgp_Array2OfPnt.hxx>
+
+#include <TCollection_AsciiString.hxx>
+
+#include <gp_Vec.hxx>
+
+#include <Standard_Stream.hxx>
+
+
+
+//=============================================================================
+// Empty constructor
+//=============================================================================
+GeoAlgo_Sol::GeoAlgo_Sol():myIsDone(Standard_False)
+{
+	
+}
+
+
+
+//=============================================================================
+// Constructor with a file name 
+//=============================================================================
+GeoAlgo_Sol::GeoAlgo_Sol(const Standard_CString aGroundName)
+{
+  myGround = Read(aGroundName);
+  // if an error occurs in the construction the method IsDone 
+  // returns False.
+}
+
+
+
+//=============================================================================
+// Build(File)
+// Build method from an empty object
+//=============================================================================
+void GeoAlgo_Sol::Build(const Standard_CString aGroundName)
+{
+  myGround = Read(aGroundName);
+  // if an error occurs in the construction the method IsDone 
+  // returns False.
+}
+
+//=============================================================================
+// Build(Sequence of Points)
+// Build method from an empty object
+// Called also from the Builde method from a file
+//=============================================================================
+void GeoAlgo_Sol::Build(const TColgp_SequenceOfXYZ& seqOfXYZ)
+{
+  // Build the surface:
+  // points are projected on plane z = 0
+  // the projection vector for each point is computed 
+  // These data give the input constraints loaded into plate algorithm
+
+  myIsDone = Standard_True;
+  Standard_Integer nbPnt = seqOfXYZ.Length();
+  Standard_Integer i;
+
+  //Filling plate
+  Plate_Plate myPlate;
+  cout<<"  * Nunber of points  = "<< nbPnt << endl;
+  for (i=1; i<= nbPnt; i++) {
+    gp_Pnt ptProj(seqOfXYZ.Value(i).X(), seqOfXYZ.Value(i).Y(), 0. );
+    gp_Vec aVec( ptProj, seqOfXYZ.Value(i));
+    gp_XY  pntXY(seqOfXYZ.Value(i).X(),seqOfXYZ.Value(i).Y());
+    Plate_PinpointConstraint PCst( pntXY,aVec.XYZ()  );
+    myPlate.Load(PCst);// Load plate
+  }
+  myPlate.SolveTI(2, 1.);// resolution 
+  if (!myPlate.IsDone()) {
+    cout<<" plate computation has failed"<< endl;
+    myIsDone=Standard_False;
+  }
+
+// Computation of plate surface
+  gp_Pnt Or(0,0,0.);
+  gp_Dir Norm(0., 0., 1.);
+  Handle(Geom_Plane) myPlane = 
+    new Geom_Plane(Or, Norm);// Plane of normal Oz
+  Handle(GeomPlate_Surface) myPlateSurf = 
+    new GeomPlate_Surface( myPlane, myPlate);//plate surface
+
+  GeomPlate_MakeApprox aMKS(myPlateSurf, Precision::Approximation(), 4, 7, 0.001, 0);//bspline surface
+  myGround = aMKS.Surface();
+  // if an error occurs in the construction the method IsDone 
+  // returns False.
+}
+
+
+//=============================================================================
+// Surface() 
+// Returns the resulting surface as a bspline surface
+//=============================================================================
+Handle(Geom_BSplineSurface) GeoAlgo_Sol::Surface() const
+{
+
+  return myGround;
+}
+
+
+
+//============================================================================
+// IsDone()
+// Checks the  construction of the surface
+//============================================================================ 
+Standard_Boolean GeoAlgo_Sol::IsDone() const
+{
+// Returns True if the construction successes, False otherwise
+  return myIsDone;
+}
+
+
+
+//=============================================================================
+// Read(File)
+// Private method called from constructor
+//=============================================================================
+Handle(Geom_BSplineSurface) GeoAlgo_Sol::Read(const Standard_CString aGroundName)
+{
+// This methods read a file of points ans build a surface using plate algorithm
+
+  myIsDone = Standard_True;
+  Standard_Integer nbPnt=0;
+
+// Read points from the file
+  filebuf fic;
+  istream in(&fic);
+  
+  if (!fic.open(aGroundName,ios::in)){
+    cout << " impossible to open a file : "<<aGroundName<<endl;
+    myIsDone = Standard_False;
+    return 0;
+  }
+  // Store the points into a sequence
+  TColgp_SequenceOfXYZ seqOfXYZ;
+  gp_XYZ pntXYZ;
+  Standard_Real x,y,z;
+  while (!in.fail()|| !in.eof()){
+    if (in >> x && in >> y && in >> z){
+	  pntXYZ.SetX(x);
+	  pntXYZ.SetY(y);
+	  pntXYZ.SetZ(z);
+      nbPnt++;
+      seqOfXYZ.Append(pntXYZ);
+    }
+  }
+  fic.close();
+  Build(seqOfXYZ);
+  return myGround;
+
+}
+
+
+
+
+
+
+

samples/mfc/standard/01_Geometry/src/GeoAlgo_Sol.hxx

@@ -0,0 +1,87 @@
+// File generated by CPPExt (Value)
+//                     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 _GeoAlgo_Sol_HeaderFile
+#define _GeoAlgo_Sol_HeaderFile
+
+#ifndef _Handle_Geom_BSplineSurface_HeaderFile
+#include <Handle_Geom_BSplineSurface.hxx>
+#endif
+#ifndef _Standard_Boolean_HeaderFile
+#include <Standard_Boolean.hxx>
+#endif
+#ifndef _Standard_CString_HeaderFile
+#include <Standard_CString.hxx>
+#endif
+#include <TColgp_SequenceOfXYZ.hxx>
+
+class Geom_BSplineSurface;
+
+
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#endif
+
+class GeoAlgo_Sol  {
+
+public:
+
+ // Methods PUBLIC
+ // 
+Standard_EXPORT GeoAlgo_Sol();
+Standard_EXPORT GeoAlgo_Sol(const Standard_CString aGroundName);
+Standard_EXPORT   void Build(const Standard_CString aGroundName) ;
+Standard_EXPORT   void Build(const TColgp_SequenceOfXYZ& aSeqofPoints) ;
+Standard_EXPORT   Handle_Geom_BSplineSurface Surface() const;
+Standard_EXPORT   Standard_Boolean IsDone() const;
+
+
+
+
+
+protected:
+
+ // Methods PROTECTED
+ // 
+
+
+ // Fields PROTECTED
+ //
+
+
+private: 
+
+ // Methods PRIVATE
+ // 
+Standard_EXPORT   Handle_Geom_BSplineSurface Read(const Standard_CString aGroundName) ;
+
+
+
+ // Fields PRIVATE
+ //
+Handle_Geom_BSplineSurface myGround;
+Standard_Boolean myIsDone;
+
+
+};
+
+
+
+
+
+// other inline functions and methods (like "C++: function call" methods)
+//
+
+
+#endif

samples/mfc/standard/01_Geometry/src/GeomSources.h

@@ -0,0 +1,131 @@
+// GeomSources.h: interface for the GeomSources class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX__H__FE726813_A2C6_11D1_8DA3_0800369C8A03__INCLUDED_)
+#define AFX__H__FE726813_A2C6_11D1_8DA3_0800369C8A03__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#include "Standard_Macro.hxx"
+#include "ResultDialog.h"
+#include "GeometryDoc.h"
+
+class GeomSources  
+{
+public:
+	Standard_EXPORT static void gpTest1(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest2(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest3(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest4(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest5(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest6(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest7(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest8(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest9(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest10(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest11(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest12(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest13(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest14(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest15(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest16(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest17(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest18(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest19(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest20(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest21(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest22(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest23(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest24(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest25(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest26(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest27(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest28(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest29(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest30(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest31(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest32(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest33(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest34(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest35(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest36(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest37(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest38(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest39(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest40(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest41(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest42(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest43(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest44(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest45(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest46(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest47(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest48(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest49(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest50(CGeometryDoc* aDoc);
+	Standard_EXPORT static void gpTest51(CGeometryDoc* aDoc);
+	GeomSources();
+	virtual ~GeomSources();
+
+private:
+
+  enum DisplayType{No2DNo3D,   // 0 0 0
+                   No2D3D  ,   // 0 0 1
+                   a2DNo3D  ,   // 0 1 0
+                   a2D3D    };  // 1 1 1
+  static  void PreProcess (CGeometryDoc* aDoc,DisplayType aDisplayType);
+  static void PostProcess(CGeometryDoc* aDoc,UINT anID,DisplayType aDisplayType,const char* aString="",Quantity_Coefficient Coef = -1/*double zoom =-1*/);
+  static void DisplayPoint(CGeometryDoc* aDoc,
+                           gp_Pnt2d& aPoint,
+                           const char* aText,
+                           Standard_Boolean UpdateViewer = Standard_False,
+                           Standard_Real anXoffset =0,
+                           Standard_Real anYoffset =0,
+                           Standard_Real TextScale = 0.05);
+  static void DisplayPoint(CGeometryDoc* aDoc,
+                           gp_Pnt& aPoint,
+                           const char* aText,
+                           Standard_Boolean UpdateViewer = Standard_False,
+                           Standard_Real anXoffset = 0,
+                           Standard_Real anYoffset = 0,
+                           Standard_Real aZoffset  = 0,
+                           Standard_Real TextScale = 0.05);
+
+    static void DisplayCurve(CGeometryDoc* aDoc,
+                          Handle(Geom2d_Curve) aCurve,
+                          Standard_Integer aColorIndex = 4,
+                          Standard_Boolean UpdateViewer = false);
+    static void DisplayCurveAndCurvature(CGeometryDoc* aDoc,
+                          Handle(Geom2d_Curve) aCurve,
+                          Standard_Integer aColorIndex = 4,
+                          Standard_Boolean UpdateViewer = false);
+
+    static void DisplayCurve(CGeometryDoc* aDoc,
+                          Handle(Geom_Curve) aCurve,
+                          Quantity_NameOfColor aNameOfColor, 
+                          Standard_Boolean UpdateViewer = false);
+
+    static void DisplayCurve(CGeometryDoc* aDoc,
+                          Handle(Geom_Curve) aCurve,
+                          Standard_Boolean UpdateViewer = false);
+
+    static void DisplaySurface  (CGeometryDoc* aDoc,
+                          Handle(Geom_Surface) aSurface,
+                          Quantity_NameOfColor aNameOfColor, 
+                          Standard_Boolean UpdateViewer = false);
+
+    static void DisplaySurface  (CGeometryDoc* aDoc,
+                          Handle(Geom_Surface) aSurface,
+                          Standard_Boolean UpdateViewer = false);
+
+
+
+  static void AddSeparator(CGeometryDoc* aDoc,TCollection_AsciiString& aMessage);
+
+
+};
+
+#endif // !defined(AFX__H__FE726813_A2C6_11D1_8DA3_0800369C8A03__INCLUDED_)

samples/mfc/standard/01_Geometry/src/GeometryApp.cpp

@@ -0,0 +1,127 @@
+// GeometryApp.cpp : Defines the class behaviors for the application.
+//
+
+#include "stdafx.h"
+
+#include "GeometryApp.h"
+#include "MainFrm.h"
+#include "ChildFrm.h"
+#include "GeometryDoc.h"
+#include "GeometryView.h"
+#include "GeometryView2d.h"
+#include "ChildFrm2D.h"
+#include "GeometryView2d.h"
+
+/////////////////////////////////////////////////////////////////////////////
+// CGeometryApp construction
+
+CGeometryApp::CGeometryApp()
+{
+	SampleName = "Geometry";	//for about dialog
+
+}
+
+CGeometryApp::~CGeometryApp()
+{
+    delete pDocTemplateForView2d;
+}
+/////////////////////////////////////////////////////////////////////////////
+// The one and only CGeometryApp object
+
+CGeometryApp theApp;
+
+/////////////////////////////////////////////////////////////////////////////
+// CGeometryApp initialization
+
+BOOL CGeometryApp::InitInstance()
+{
+    AfxInitRichEdit();
+	AfxEnableControlContainer();
+
+	// Standard initialization
+	// If you are not using these features and wish to reduce the size
+	//  of your final executable, you should remove from the following
+	//  the specific initialization routines you do not need.
+
+	// Change the registry key under which our settings are stored.
+	// You should modify this string to be something appropriate
+	// such as the name of your company or organization.
+	SetRegistryKey(_T("Local AppWizard-Generated Applications"));
+
+	LoadStdProfileSettings();  // Load standard INI file options (including MRU)
+
+	// Register the application's document templates.  Document templates
+	//  serve as the connection between documents, frame windows and views.
+
+	pDocTemplateForView3d = new CMultiDocTemplate(
+		IDR_3DTYPE,
+		RUNTIME_CLASS(CGeometryDoc),
+		RUNTIME_CLASS(CChildFrame), // custom MDI child frame
+		RUNTIME_CLASS(CGeometryView));
+	AddDocTemplate(pDocTemplateForView3d);
+    
+    pDocTemplateForView2d = new CMultiDocTemplate(
+		IDR_2DTYPE,
+		RUNTIME_CLASS(CGeometryDoc),
+		RUNTIME_CLASS(CChildFrame2D), // custom MDI child frame
+		RUNTIME_CLASS(CGeometryView2D));
+	//AddDocTemplate(pDocTemplateForView2d);
+
+	// create main MDI Frame window
+	CMainFrame* pMainFrame = new CMainFrame;
+	if (!pMainFrame->LoadFrame(IDR_MAINFRAME))
+		return FALSE;
+	m_pMainWnd = pMainFrame;
+
+	// Parse command line for standard shell commands, DDE, file open
+	CCommandLineInfo cmdInfo;
+	ParseCommandLine(cmdInfo);
+
+	// Dispatch commands specified on the command line
+	if (!ProcessShellCommand(cmdInfo))
+		return FALSE;
+
+	// The main window has been initialized, so show and update it.
+	pMainFrame->ShowWindow(m_nCmdShow);
+	pMainFrame->UpdateWindow();
+
+
+	return TRUE;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// CGeometryApp commands
+
+//===================================================
+
+CFrameWnd*  CGeometryApp::CreateView2D(CGeometryDoc* pDoc )
+{
+  ASSERT_VALID(pDoc);
+  ASSERT_VALID(pDocTemplateForView2d);
+  CRuntimeClass * pViewClass = RUNTIME_CLASS(CGeometryView2D);
+  ASSERT(pViewClass != (CRuntimeClass *)NULL );
+  // Create a new frame window
+  CFrameWnd* pNewFrame = pDocTemplateForView2d->CreateNewFrame(pDoc, NULL);
+  pDocTemplateForView2d->InitialUpdateFrame(pNewFrame, pDoc);
+return pNewFrame;
+}
+
+BOOL CGeometryApp::IsViewExisting(CDocument * pDoc, CRuntimeClass * pViewClass, CView * & pView)
+{
+  ASSERT_VALID(pDoc);
+  ASSERT(pViewClass != (CRuntimeClass *)NULL );
+
+  POSITION position = pDoc->GetFirstViewPosition();
+  while (position != (POSITION)NULL)
+  {
+    CView* pCurrentView = pDoc->GetNextView(position);
+    ASSERT_VALID(pCurrentView);
+    if (pCurrentView->IsKindOf(pViewClass))
+	{
+      pView = pCurrentView;
+	  return TRUE;
+	}
+  }
+  return FALSE;
+}
+

samples/mfc/standard/01_Geometry/src/GeometryApp.h

@@ -0,0 +1,39 @@
+// GeometryApp.h : main header file for the GEOMETRY application
+//
+
+#if !defined(AFX_VIEWER_H__4EF39FB2_4EBB_11D1_8D67_0800369C8A03__INCLUDED_)
+#define AFX_VIEWER_H__4EF39FB2_4EBB_11D1_8D67_0800369C8A03__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#include <OCC_3dApp.h>
+#include <GeometryDoc.h>
+
+class CGeometryApp : public OCC_3dApp
+{
+public:
+	CGeometryApp();
+    ~CGeometryApp();
+    // =========================================
+	CFrameWnd*  CreateView2D(CGeometryDoc* pDoc);
+    // =========================================
+    // =========================================
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CGeometryApp)
+	public:
+	virtual BOOL InitInstance();
+	//}}AFX_VIRTUAL
+private :
+     BOOL IsViewExisting(CDocument* pDoc,CRuntimeClass* pViewClass,CView*& pView); 	 
+     CMultiDocTemplate* pDocTemplateForView3d;
+	 CMultiDocTemplate* pDocTemplateForView2d;
+
+};
+
+/////////////////////////////////////////////////////////////////////////////
+
+#endif // !defined(AFX_VIEWER_H__4EF39FB2_4EBB_11D1_8D67_0800369C8A03__INCLUDED_)

samples/mfc/standard/01_Geometry/src/GeometryDoc.h

@@ -0,0 +1,244 @@
+// GeometryDoc.h : interface of the CGeometryDoc class
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_VIEWERDOC_H__4EF39FBA_4EBB_11D1_8D67_0800369C8A03__INCLUDED_)
+#define AFX_VIEWERDOC_H__4EF39FBA_4EBB_11D1_8D67_0800369C8A03__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#include "ISession2D_InteractiveContext.h"
+#include "ResultDialog.h"
+
+class Handle_AIS_Point;
+
+class CGeometryDoc : public CDocument
+{
+public:
+	void Put2DOnTop(bool isMax = true);
+	void Put3DOnTop(bool isMax = true);
+	void Fit2DViews();
+    void Set3DViewsZoom(const Quantity_Factor& Coef );
+	void Fit3DViews(Quantity_Coefficient Coef);
+	void simplify(const TopoDS_Shape& aShape);
+
+
+	static void Fit();
+
+    //              2D
+
+    void DragEvent2D       (const Standard_Integer  x       ,
+	    			        const Standard_Integer  y       ,
+		    		        const Standard_Integer  TheState,
+                            const Handle_V2d_View& aView   );
+    void InputEvent2D      (const Standard_Integer  x       ,
+	    			        const Standard_Integer  y       ,
+                            const Handle_V2d_View& aView   );  
+    void MoveEvent2D       (const Standard_Integer  x       ,
+                            const Standard_Integer  y       ,
+                            const Handle_V2d_View& aView   ); 
+    void ShiftMoveEvent2D  (const Standard_Integer  x       ,
+                            const Standard_Integer  y       ,
+                            const Handle_V2d_View& aView   ); 
+    void ShiftDragEvent2D  (const Standard_Integer  x       ,
+	    				    const Standard_Integer  y       ,
+		    			    const Standard_Integer  TheState,
+                            const Handle_V2d_View& aView   ); 
+    void ShiftInputEvent2D (const Standard_Integer  x       ,
+	    				    const Standard_Integer  y       ,
+                            const Handle_V2d_View& aView   ); 
+    void Popup2D           (const Standard_Integer  x       ,
+		    			    const Standard_Integer  y       ,
+                            const Handle_V2d_View& aView   ); 
+
+	Handle_AIS_InteractiveObject drawSurface
+                           (const Handle_Geom_Surface& theSurface,
+                            const Quantity_Color& theColor,
+                            const Standard_Boolean toDisplay);
+
+	Standard_Boolean WaitForInput (unsigned long aMilliSeconds);
+	// Waits for a user input or a period of time has been elapsed
+
+	Handle_AIS_Point drawPoint (const gp_Pnt& thePnt,
+         const Quantity_Color& theColor = Quantity_Color(Quantity_NOC_GREEN),
+         const Standard_Boolean toDisplay = Standard_True);
+	// creates a presentation of the given point
+	// and displays it in the viewer if toDisplay = Standard_True
+
+	Handle_AIS_Shape drawShape (const TopoDS_Shape& theShape,
+         const Graphic3d_NameOfMaterial theMaterial = Graphic3d_NOM_BRASS,
+         const Standard_Boolean toDisplay = Standard_True);
+	// creates a presentation of the given shape with the given material
+	// (color is default for a given material)
+	// and displays it in the viewer if toDisplay = Standard_True
+
+protected: // create from serialization only
+	CGeometryDoc();
+	DECLARE_DYNCREATE(CGeometryDoc)
+
+// Attributes
+public:
+
+// Operations
+public:
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CGeometryDoc)
+	public:
+	virtual BOOL OnNewDocument();
+	virtual void Serialize(CArchive& ar);
+	virtual void OnCloseDocument();
+	//}}AFX_VIRTUAL
+
+// Implementation
+public:
+	virtual ~CGeometryDoc();
+#ifdef _DEBUG
+	virtual void AssertValid() const;
+	virtual void Dump(CDumpContext& dc) const;
+#endif
+
+protected:
+
+// Generated message map functions
+protected:
+	//{{AFX_MSG(CGeometryDoc)
+	afx_msg void OnWindowNew2d();
+	afx_msg void OnBUTTONTest1();
+	afx_msg void OnBUTTONTest2();
+	afx_msg void OnBUTTONTest3();
+	afx_msg void OnBUTTONTest4();
+	afx_msg void OnBUTTONTest5();
+	afx_msg void OnBUTTONTest6();
+	afx_msg void OnBUTTONTest7();
+	afx_msg void OnBUTTONTest8();
+	afx_msg void OnBUTTONTest9();
+	afx_msg void OnBUTTONTest10();
+	afx_msg void OnBUTTONTest11();
+	afx_msg void OnBUTTONTest12();
+	afx_msg void OnBUTTONTest13();
+	afx_msg void OnBUTTONTest14();
+	afx_msg void OnBUTTONTest15();
+	afx_msg void OnBUTTONTest16();
+	afx_msg void OnBUTTONTest17();
+	afx_msg void OnBUTTONTest18();
+	afx_msg void OnBUTTONTest19();
+	afx_msg void OnBUTTONTest20();
+	afx_msg void OnBUTTONTest21();
+	afx_msg void OnBUTTONTest22();
+	afx_msg void OnBUTTONTest23();
+	afx_msg void OnBUTTONTest24();
+	afx_msg void OnBUTTONTest25();
+	afx_msg void OnBUTTONTest26();
+	afx_msg void OnBUTTONTest27();
+	afx_msg void OnBUTTONTest28();
+	afx_msg void OnBUTTONTest29();
+	afx_msg void OnBUTTONTest30();
+	afx_msg void OnBUTTONTest31();
+	afx_msg void OnBUTTONTest32();
+	afx_msg void OnBUTTONTest33();
+	afx_msg void OnBUTTONTest34();
+	afx_msg void OnBUTTONTest35();
+	afx_msg void OnBUTTONTest36();
+	afx_msg void OnBUTTONTest37();
+	afx_msg void OnBUTTONTest38();
+	afx_msg void OnBUTTONTest39();
+	afx_msg void OnBUTTONTest40();
+	afx_msg void OnBUTTONTest41();
+	afx_msg void OnBUTTONTest42();
+	afx_msg void OnBUTTONTest43();
+	afx_msg void OnBUTTONTest44();
+	afx_msg void OnBUTTONTest45();
+	afx_msg void OnBUTTONTest46();
+	afx_msg void OnBUTTONTest47();
+	afx_msg void OnBUTTONTest48();
+	afx_msg void OnBUTTONTest49();
+	afx_msg void OnBUTTONTest50();
+	afx_msg void OnUpdateBUTTONTest1(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest2(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest3(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest4(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest5(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest6(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest7(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest8(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest9(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest10(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest11(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest12(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest13(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest14(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest15(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest16(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest17(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest18(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest19(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest20(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest21(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest22(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest23(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest24(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest25(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest26(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest27(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest28(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest29(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest30(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest31(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest32(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest33(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest34(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest35(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest36(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest37(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest38(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest39(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest40(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest41(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest42(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest43(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest44(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest45(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest46(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest47(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest48(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest49(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONTest50(CCmdUI* pCmdUI);
+	afx_msg void OnCreateSol();
+	afx_msg void OnSimplify();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+
+
+private:
+	Handle_V3d_Viewer myViewer;
+	Handle_V3d_Viewer myViewerCollector;
+	Handle_AIS_InteractiveContext myAISContext;
+public :
+  	Handle_AIS_InteractiveContext& GetAISContext(){ return myAISContext; };
+	Handle_V3d_Viewer GetViewer()  { return myViewer; };
+	Handle_V3d_Viewer GetViewerCollector()  { return myViewerCollector; };
+
+
+private:
+	Handle_V2d_Viewer myViewer2D;
+	Handle_ISession2D_InteractiveContext myISessionContext;
+public :
+	int Current;
+	void Minimize3D();
+	void Minimize2D();
+	Handle_V2d_Viewer GetViewer2D()  { return myViewer2D; };
+  	Handle_ISession2D_InteractiveContext& GetISessionContext(){ return myISessionContext; };
+	BOOL FitMode;
+
+public :
+	CResultDialog myCResultDialog;
+
+};
+
+/////////////////////////////////////////////////////////////////////////////
+
+#endif // !defined(AFX_VIEWERDOC_H__4EF39FBA_4EBB_11D1_8D67_0800369C8A03__INCLUDED_)

samples/mfc/standard/01_Geometry/src/GeometryView.cpp

@@ -0,0 +1,497 @@
+// GeometryView.cpp : implementation of the CGeometryView class
+//
+
+#include "stdafx.h"
+#include "GeometryApp.h"
+
+#include <GeometryApp.h>
+#include "GeometryDoc.h"
+#include "GeometryView.h"
+
+#define ValZWMin 1
+
+#ifdef _DEBUG
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+// CGeometryView
+
+IMPLEMENT_DYNCREATE(CGeometryView, OCC_3dView)
+
+BEGIN_MESSAGE_MAP(CGeometryView, OCC_3dView)
+	//{{AFX_MSG_MAP(CGeometryView)
+	ON_COMMAND(ID_FILE_EXPORT_IMAGE, OnFileExportImage)
+	ON_WM_SIZE()
+	ON_WM_LBUTTONDOWN()
+	ON_WM_LBUTTONUP()
+	ON_WM_MBUTTONDOWN()
+	ON_WM_MBUTTONUP()
+	ON_WM_MOUSEMOVE()
+	ON_WM_RBUTTONDOWN()
+	ON_WM_RBUTTONUP()
+	ON_UPDATE_COMMAND_UI(ID_BUTTONHlrOff, OnUpdateBUTTONHlrOff)
+	ON_UPDATE_COMMAND_UI(ID_BUTTONHlrOn, OnUpdateBUTTONHlrOn)
+	ON_UPDATE_COMMAND_UI(ID_BUTTONPanGlo, OnUpdateBUTTONPanGlo)
+	ON_UPDATE_COMMAND_UI(ID_BUTTONPan, OnUpdateBUTTONPan)
+	ON_UPDATE_COMMAND_UI(ID_BUTTONZoomProg, OnUpdateBUTTONZoomProg)
+	ON_UPDATE_COMMAND_UI(ID_BUTTONZoomWin, OnUpdateBUTTONZoomWin)
+	ON_UPDATE_COMMAND_UI(ID_BUTTONRot, OnUpdateBUTTONRot)
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+/////////////////////////////////////////////////////////////////////////////
+// CGeometryView construction/destruction
+
+CGeometryView::CGeometryView()
+{
+}
+
+CGeometryView::~CGeometryView()
+{
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// CGeometryView diagnostics
+
+#ifdef _DEBUG
+void CGeometryView::AssertValid() const
+{
+	CView::AssertValid();
+}
+
+void CGeometryView::Dump(CDumpContext& dc) const
+{
+	CView::Dump(dc);
+}
+
+CGeometryDoc* CGeometryView::GetDocument() // non-debug version is inline
+{
+	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CGeometryDoc)));
+	return (CGeometryDoc*)m_pDocument;
+}
+#endif //_DEBUG
+
+/////////////////////////////////////////////////////////////////////////////
+// CGeometryView message handlers
+
+
+void CGeometryView::OnFileExportImage()
+{
+  CFileDialog dlg(FALSE,_T("*.BMP"),NULL,OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
+                  _T("BMP Files (*.BMP)|*.bmp |GIF Files (*.GIF)|*.gif | XWD Files (*.XWD)|*.xwd||"), 
+                  NULL );
+
+  if (dlg.DoModal() == IDOK) 
+  {
+    SetCursor(AfxGetApp()->LoadStandardCursor(IDC_WAIT));
+    CString filename = dlg.GetPathName();
+    Handle(Aspect_Window) anAspectWindow = myView->Window();
+    Handle(WNT_Window) aWNTWindow = Handle(WNT_Window)::DownCast(anAspectWindow);
+    CString ext = dlg.GetFileExt();
+    if (ext == "bmp")     aWNTWindow->SetOutputFormat ( WNT_TOI_BMP );
+    if (ext == "gif")     aWNTWindow->SetOutputFormat ( WNT_TOI_GIF );
+    if (ext == "xwd")     aWNTWindow->SetOutputFormat ( WNT_TOI_XWD );
+    aWNTWindow->Dump ((Standard_CString)(LPCTSTR)filename);
+    SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
+  }
+}
+
+void CGeometryView::OnSize(UINT nType, int cx, int cy) 
+{
+  if (!myView.IsNull())
+   myView->MustBeResized();
+}
+
+void CGeometryView::OnLButtonDown(UINT nFlags, CPoint point) 
+{
+  //  save the current mouse coordinate in min 
+  myXmin=point.x;  myYmin=point.y;
+  myXmax=point.x;  myYmax=point.y;
+
+  if ( nFlags & MK_CONTROL ) 
+	  {
+	    // Button MB1 down Control :start zomming 
+        // SetCursor(AfxGetApp()->LoadStandardCursor());
+	  }
+	else // if ( Ctrl )
+	  {
+        switch (myCurrentMode)
+        {
+         case CurAction3d_Nothing : // start a drag
+           if (nFlags & MK_SHIFT)
+        	    ShiftDragEvent(myXmax,myYmax,-1);
+           else
+                DragEvent(myXmax,myYmax,-1);
+        break;
+         break;
+         case CurAction3d_DynamicZooming : // noting
+             // SetCursor(AfxGetApp()->LoadStandardCursor());
+         break;
+         case CurAction3d_WindowZooming : 
+         break;
+         case CurAction3d_DynamicPanning :// noting
+             // SetCursor(AfxGetApp()->LoadStandardCursor());
+         break;
+         case CurAction3d_GlobalPanning :// noting
+             // SetCursor(AfxGetApp()->LoadStandardCursor());
+        break;
+        case  CurAction3d_DynamicRotation :
+             // SetCursor(AfxGetApp()->LoadStandardCursor());
+			if (!myDegenerateModeIsOn)
+			  myView->SetDegenerateModeOn();
+			myView->StartRotation(point.x,point.y);  
+        break;
+        default :
+           Standard_Failure::Raise(" incompatible Current Mode ");
+        break;
+        }
+    }
+}
+
+void CGeometryView::OnLButtonUp(UINT nFlags, CPoint point) 
+{
+   if ( nFlags & MK_CONTROL ) 
+	  {
+        return;
+	  }
+	else // if ( Ctrl )
+	  {
+        switch (myCurrentMode)
+        {
+         case CurAction3d_Nothing :
+         if (point.x == myXmin && point.y == myYmin)
+         { // no offset between down and up --> selectEvent
+            myXmax=point.x;  
+            myYmax=point.y;
+            if (nFlags & MK_SHIFT )
+              ShiftInputEvent(point.x,point.y);
+            else
+              InputEvent     (point.x,point.y);
+         } else
+         {
+            myXmax=point.x;    myYmax=point.y;
+            DrawRectangle(myXmin,myYmin,myXmax,myYmax,Standard_False);
+		    if (nFlags & MK_SHIFT)
+				ShiftDragEvent(point.x,point.y,1);
+			else
+				DragEvent(point.x,point.y,1);
+         }
+         break;
+         case CurAction3d_DynamicZooming :
+             // SetCursor(AfxGetApp()->LoadStandardCursor());         
+	       myCurrentMode = CurAction3d_Nothing;
+         break;
+         case CurAction3d_WindowZooming :
+           myXmax=point.x;  myYmax=point.y;
+            DrawRectangle(myXmin,myYmin,myXmax,myYmax,Standard_False,LongDash);
+	       if ((abs(myXmin-myXmax)>ValZWMin) || (abs(myYmin-myYmax)>ValZWMin))
+					 // Test if the zoom window is greater than a minimale window.
+			{
+			  // Do the zoom window between Pmin and Pmax
+			  myView->WindowFitAll(myXmin,myYmin,myXmax,myYmax);  
+			}  
+	       myCurrentMode = CurAction3d_Nothing;
+         break;
+         case CurAction3d_DynamicPanning :
+           myCurrentMode = CurAction3d_Nothing;
+         break;
+         case CurAction3d_GlobalPanning :
+	       myView->Place(point.x,point.y,myCurZoom); 
+	       myCurrentMode = CurAction3d_Nothing;
+        break;
+        case  CurAction3d_DynamicRotation :
+	       myCurrentMode = CurAction3d_Nothing;
+        break;
+        default :
+           Standard_Failure::Raise(" incompatible Current Mode ");
+        break;
+        } //switch (myCurrentMode)
+    } //	else // if ( Ctrl )
+}
+
+void CGeometryView::OnMButtonDown(UINT nFlags, CPoint point) 
+{
+   if ( nFlags & MK_CONTROL ) 
+	  {
+      	// Button MB2 down Control : panning init  
+        // SetCursor(AfxGetApp()->LoadStandardCursor());   
+	  }
+}
+
+void CGeometryView::OnMButtonUp(UINT nFlags, CPoint point) 
+{
+   if ( nFlags & MK_CONTROL ) 
+	  {
+      	// Button MB2 down Control : panning init  
+        // SetCursor(AfxGetApp()->LoadStandardCursor());   
+	  }
+}
+
+void CGeometryView::OnRButtonDown(UINT nFlags, CPoint point) 
+{
+   if ( nFlags & MK_CONTROL ) 
+	  {
+        // SetCursor(AfxGetApp()->LoadStandardCursor());   
+	    if (!myDegenerateModeIsOn)
+	      myView->SetDegenerateModeOn();
+	      myView->StartRotation(point.x,point.y);  
+	  }
+	else // if ( Ctrl )
+	  {
+	    Popup(point.x,point.y);
+      }	
+}
+
+void CGeometryView::OnRButtonUp(UINT nFlags, CPoint point) 
+{
+    SetCursor(AfxGetApp()->LoadStandardCursor(IDC_WAIT));
+    if (!myDegenerateModeIsOn)
+    {  
+      myView->SetDegenerateModeOff();
+      myDegenerateModeIsOn = Standard_False;
+    } else
+    {
+      myView->SetDegenerateModeOn();
+      myDegenerateModeIsOn = Standard_True;
+    }
+    SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
+}
+
+void CGeometryView::OnMouseMove(UINT nFlags, CPoint point) 
+{
+    //   ============================  LEFT BUTTON =======================
+  if ( nFlags & MK_LBUTTON)
+    {
+     if ( nFlags & MK_CONTROL ) 
+	  {
+	    // move with MB1 and Control : on the dynamic zooming  
+	    // Do the zoom in function of mouse's coordinates  
+	    myView->Zoom(myXmax,myYmax,point.x,point.y); 
+	    // save the current mouse coordinate in min 
+		myXmax = point.x; 
+        myYmax = point.y;	
+	  }
+	  else // if ( Ctrl )
+	  {
+        switch (myCurrentMode)
+        {
+         case CurAction3d_Nothing :
+            DrawRectangle(myXmin,myYmin,myXmax,myYmax,Standard_False);
+		   myXmax = point.x; 
+           myYmax = point.y;
+           if (nFlags & MK_SHIFT)		
+       	     ShiftDragEvent(myXmax,myYmax,0);
+           else
+             DragEvent(myXmax,myYmax,0);
+            DrawRectangle(myXmin,myYmin,myXmax,myYmax,Standard_True);
+          break;
+         case CurAction3d_DynamicZooming :
+	       myView->Zoom(myXmax,myYmax,point.x,point.y); 
+	       // save the current mouse coordinate in min \n";
+	       myXmax=point.x;  myYmax=point.y;
+         break;
+         case CurAction3d_WindowZooming :
+		   myXmax = point.x; myYmax = point.y;	
+            DrawRectangle(myXmin,myYmin,myXmax,myYmax,Standard_False,LongDash);
+            DrawRectangle(myXmin,myYmin,myXmax,myYmax,Standard_True,LongDash);
+         break;
+         case CurAction3d_DynamicPanning :
+		   myView->Pan(point.x-myXmax,myYmax-point.y); // Realize the panning
+		   myXmax = point.x; myYmax = point.y;	
+         break;
+         case CurAction3d_GlobalPanning : // nothing           
+        break;
+        case  CurAction3d_DynamicRotation :
+          myView->Rotation(point.x,point.y);
+	      myView->Redraw();
+        break;
+        default :
+           Standard_Failure::Raise(" incompatible Current Mode ");
+        break;
+        }//  switch (myCurrentMode)
+      }// if ( nFlags & MK_CONTROL )  else 
+    } else //   if ( nFlags & MK_LBUTTON) 
+    //   ============================  MIDDLE BUTTON =======================
+    if ( nFlags & MK_MBUTTON)
+    {
+     if ( nFlags & MK_CONTROL ) 
+	  {
+		myView->Pan(point.x-myXmax,myYmax-point.y); // Realize the panning
+		myXmax = point.x; myYmax = point.y;	
+
+	  }
+    } else //  if ( nFlags & MK_MBUTTON)
+    //   ============================  RIGHT BUTTON =======================
+    if ( nFlags & MK_RBUTTON)
+    {
+     if ( nFlags & MK_CONTROL ) 
+	  {
+      	 myView->Rotation(point.x,point.y);
+	  }
+    }else //if ( nFlags & MK_RBUTTON)
+    //   ============================  NO BUTTON =======================
+    {  // No buttons 
+	  myXmax = point.x; myYmax = point.y;	
+	  if (nFlags & MK_SHIFT)
+		ShiftMoveEvent(point.x,point.y);
+	  else
+		MoveEvent(point.x,point.y);
+   }
+}
+
+void CGeometryView::OnUpdateBUTTONHlrOff(CCmdUI* pCmdUI) 
+{
+    pCmdUI->SetCheck (myDegenerateModeIsOn);
+	pCmdUI->Enable   (!myDegenerateModeIsOn);	
+}
+
+void CGeometryView::OnUpdateBUTTONHlrOn(CCmdUI* pCmdUI) 
+{
+    pCmdUI->SetCheck (!myDegenerateModeIsOn);
+	pCmdUI->Enable   (myDegenerateModeIsOn);	
+}
+
+void CGeometryView::OnUpdateBUTTONPanGlo(CCmdUI* pCmdUI) 
+{
+    pCmdUI->SetCheck (myCurrentMode == CurAction3d_GlobalPanning);
+	pCmdUI->Enable   (myCurrentMode != CurAction3d_GlobalPanning);	
+	
+}
+
+void CGeometryView::OnUpdateBUTTONPan(CCmdUI* pCmdUI) 
+{
+    pCmdUI->SetCheck (myCurrentMode == CurAction3d_DynamicPanning);
+	pCmdUI->Enable   (myCurrentMode != CurAction3d_DynamicPanning );	
+}
+
+void CGeometryView::OnUpdateBUTTONZoomProg(CCmdUI* pCmdUI) 
+{
+    pCmdUI->SetCheck (myCurrentMode == CurAction3d_DynamicZooming );
+	pCmdUI->Enable   (myCurrentMode != CurAction3d_DynamicZooming);	
+}
+
+void CGeometryView::OnUpdateBUTTONZoomWin(CCmdUI* pCmdUI) 
+{
+    pCmdUI->SetCheck (myCurrentMode == CurAction3d_WindowZooming);
+	pCmdUI->Enable   (myCurrentMode != CurAction3d_WindowZooming);	
+}
+
+void CGeometryView::OnUpdateBUTTONRot(CCmdUI* pCmdUI) 
+{
+    pCmdUI->SetCheck (myCurrentMode == CurAction3d_DynamicRotation);
+	pCmdUI->Enable   (myCurrentMode != CurAction3d_DynamicRotation);	
+}
+
+//==========================================================================================
+//==========================================================================================
+//==========================================================================================
+
+//-----------------------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------------------
+void CGeometryView::DragEvent(const Standard_Integer  x        ,
+				                  const Standard_Integer  y        ,
+				                  const Standard_Integer  TheState )
+{
+
+    // TheState == -1  button down
+	// TheState ==  0  move
+	// TheState ==  1  button up
+
+    static Standard_Integer theButtonDownX=0;
+    static Standard_Integer theButtonDownY=0;
+
+	if (TheState == -1)
+    {
+      theButtonDownX=x;
+      theButtonDownY=y;
+    }
+
+	if (TheState == 0)
+	  GetDocument()->GetAISContext()->Select(theButtonDownX,theButtonDownY,x,y,myView);  
+} 
+
+//-----------------------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------------------
+void CGeometryView::InputEvent(const Standard_Integer  x     ,
+				                   const Standard_Integer  y     ) 
+{
+    GetDocument()->GetAISContext()->Select(); 
+}
+
+//-----------------------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------------------
+void CGeometryView::MoveEvent(const Standard_Integer  x       ,
+                                  const Standard_Integer  y       ) 
+{
+      GetDocument()->GetAISContext()->MoveTo(x,y,myView);
+}
+
+//-----------------------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------------------
+void CGeometryView::ShiftMoveEvent(const Standard_Integer  x       ,
+                                  const Standard_Integer  y       ) 
+{
+      GetDocument()->GetAISContext()->MoveTo(x,y,myView);
+}
+
+//-----------------------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------------------
+void CGeometryView::ShiftDragEvent(const Standard_Integer  x        ,
+									   const Standard_Integer  y        ,
+									   const Standard_Integer  TheState ) 
+{
+    static Standard_Integer theButtonDownX=0;
+    static Standard_Integer theButtonDownY=0;
+
+	if (TheState == -1)
+    {
+      theButtonDownX=x;
+      theButtonDownY=y;
+    }
+
+	if (TheState == 0)
+	  GetDocument()->GetAISContext()->ShiftSelect(theButtonDownX,theButtonDownY,x,y,myView);  
+}
+
+
+//-----------------------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------------------
+void CGeometryView::ShiftInputEvent(const Standard_Integer  x       ,
+									    const Standard_Integer  y       ) 
+{
+	GetDocument()->GetAISContext()->ShiftSelect(); 
+}
+
+//-----------------------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------------------
+void  CGeometryView::Popup(const Standard_Integer  x,
+							   const Standard_Integer  y ) 
+{
+  Standard_Integer PopupMenuNumber=0;
+  GetDocument()->GetAISContext()->InitCurrent();
+  if (GetDocument()->GetAISContext()->MoreCurrent())
+    PopupMenuNumber=1;
+
+  CMenu menu;
+  VERIFY(menu.LoadMenu(IDR_Popup3D));
+  CMenu* pPopup = menu.GetSubMenu(PopupMenuNumber);
+  ASSERT(pPopup != NULL);
+ 
+  POINT winCoord = { x , y };
+  Handle(WNT_Window) aWNTWindow=
+  Handle(WNT_Window)::DownCast(myView->Window());
+  ClientToScreen ( &winCoord);
+  pPopup->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON , winCoord.x, winCoord.y , 
+                         AfxGetMainWnd());
+}
+
+

samples/mfc/standard/01_Geometry/src/GeometryView.h

@@ -0,0 +1,97 @@
+// GeometryView.h : interface of the CGeometryView class
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_VIEWERVIEW_H__4EF39FBC_4EBB_11D1_8D67_0800369C8A03__INCLUDED_)
+#define AFX_VIEWERVIEW_H__4EF39FBC_4EBB_11D1_8D67_0800369C8A03__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#include <OCC_3dView.h>
+
+class CGeometryView : public OCC_3dView
+{
+protected: // create from serialization only
+public:
+	CGeometryView();
+	DECLARE_DYNCREATE(CGeometryView)
+
+// Attributes
+public:
+	CGeometryDoc* GetDocument();
+
+// Operations
+public:
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CGeometryView)
+	public:
+	//}}AFX_VIRTUAL
+
+// Implementation
+public:
+	virtual ~CGeometryView();
+	void FitAll(Quantity_Coefficient Coef) {   if (Coef != -1) 	myView->FitAll(Coef);
+												else myView->FitAll();
+												myView->ZFitAll();  };
+#ifdef _DEBUG
+	virtual void AssertValid() const;
+	virtual void Dump(CDumpContext& dc) const;
+#endif
+
+// Generated message map functions
+protected:
+	//{{AFX_MSG(CGeometryView)
+	afx_msg void OnFileExportImage();
+	afx_msg void OnSize(UINT nType, int cx, int cy);
+	afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
+	afx_msg void OnLButtonUp(UINT nFlags, CPoint point);
+	afx_msg void OnMButtonDown(UINT nFlags, CPoint point);
+	afx_msg void OnMButtonUp(UINT nFlags, CPoint point);
+	afx_msg void OnMouseMove(UINT nFlags, CPoint point);
+	afx_msg void OnRButtonDown(UINT nFlags, CPoint point);
+	afx_msg void OnRButtonUp(UINT nFlags, CPoint point);
+	afx_msg void OnUpdateBUTTONHlrOff(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONHlrOn(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONPanGlo(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONPan(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONZoomProg(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONZoomWin(CCmdUI* pCmdUI);
+	afx_msg void OnUpdateBUTTONRot(CCmdUI* pCmdUI);
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+
+private:
+	void DragEvent      (const Standard_Integer  x       ,
+	    			     const Standard_Integer  y       ,
+		    		     const Standard_Integer  TheState);
+    void InputEvent     (const Standard_Integer  x       ,
+	    			     const Standard_Integer  y       );  
+    void MoveEvent      (const Standard_Integer  x       ,
+                         const Standard_Integer  y       ); 
+    void ShiftMoveEvent (const Standard_Integer  x       ,
+                         const Standard_Integer  y       ); 
+    void ShiftDragEvent (const Standard_Integer  x       ,
+	    				 const Standard_Integer  y       ,
+		    			 const Standard_Integer  TheState); 
+    void ShiftInputEvent(const Standard_Integer  x       ,
+	    				 const Standard_Integer  y       ); 
+    void Popup          (const Standard_Integer  x       ,
+		    			 const Standard_Integer  y       ); 
+
+};
+
+#ifndef _DEBUG  // debug version in GeometryView.cpp
+inline CGeometryDoc* CGeometryView::GetDocument()
+   { return (CGeometryDoc*)m_pDocument; }
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Developer Studio will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_VIEWERVIEW_H__4EF39FBC_4EBB_11D1_8D67_0800369C8A03__INCLUDED_)

samples/mfc/standard/01_Geometry/src/GeometryView2D.cpp

@@ -0,0 +1,315 @@
+// NSGViewBibliotheque.cpp : implementation of the CGeometryView2D class
+//
+
+#include "stdafx.h"
+#include "GeometryApp.h"
+#include "GeometryDoc.h"
+#include "GeometryView2D.h"
+#include ".\Resource2d\RectangularGrid.h"
+#include ".\Resource2d\CircularGrid.h"
+#include <Aspect.hxx>
+
+/////////////////////////////////////////////////////////////////////////////
+// CNSGView
+
+IMPLEMENT_DYNCREATE(CGeometryView2D, CView)
+BEGIN_MESSAGE_MAP(CGeometryView2D, OCC_2dView)
+	//{{AFX_MSG_MAP(CGeometryView2D)
+	ON_WM_LBUTTONDOWN()
+	ON_WM_LBUTTONUP()
+	ON_WM_MBUTTONDOWN()
+	ON_WM_MBUTTONUP()
+	ON_WM_RBUTTONDOWN()
+	ON_WM_RBUTTONUP()
+	ON_WM_MOUSEMOVE()
+	ON_WM_SIZE()
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+/////////////////////////////////////////////////////////////////////////////
+// CNSGView construction/destruction
+
+CGeometryView2D::CGeometryView2D()
+{
+}
+
+CGeometryView2D::~CGeometryView2D()
+{
+}
+
+// CNSGView drawing
+
+void CGeometryView2D::OnDraw(CDC* pDC)
+{
+	CGeometryDoc* pDoc = GetDocument();
+	ASSERT_VALID(pDoc);
+
+	if (!myV2dView.IsNull())
+	myV2dView->Update();
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// CGeometryView2D diagnostics
+
+#ifdef _DEBUG
+void CGeometryView2D::AssertValid() const
+{
+	CView::AssertValid();
+}
+
+void CGeometryView2D::Dump(CDumpContext& dc) const
+{
+	CView::Dump(dc);
+}
+
+CGeometryDoc* CGeometryView2D::GetDocument() // non-debug version is inline
+{
+	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CGeometryDoc)));
+	return (CGeometryDoc*)m_pDocument;
+}
+#endif //_DEBUG
+
+/////////////////////////////////////////////////////////////////////////////
+// CNSGView message handlers
+
+
+
+//=================================================================
+
+void CGeometryView2D::OnLButtonDown(UINT nFlags, CPoint point) 
+{
+  //  save the current mouse coordinate in min 
+  myXmin=point.x;  myYmin=point.y;
+  myXmax=point.x;  myYmax=point.y;
+
+  if ( nFlags & MK_CONTROL ) 
+	  {
+	    // Button MB1 down Control :start zomming 
+        // SetCursor(AfxGetApp()->LoadStandardCursor());
+	  }
+	else // if ( Ctrl )
+	  {
+        switch (myCurrentMode)
+        {
+         case CurAction2d_Nothing : // start a drag
+             GetDocument()->DragEvent2D(point.x,point.y,-1,myV2dView);
+         break;
+         case CurAction2d_DynamicZooming : // noting
+         break;
+         case CurAction2d_WindowZooming : 
+         break;
+         case CurAction2d_DynamicPanning :// noting
+         break;
+         case CurAction2d_GlobalPanning :// noting
+        break;
+        default :
+           Standard_Failure::Raise(" incompatible Current Mode ");
+        break;
+        }
+    }
+}
+
+void CGeometryView2D::OnLButtonUp(UINT nFlags, CPoint point) 
+{
+	// TODO: Add your message handler code here and/or call default
+   if ( nFlags & MK_CONTROL ) 
+	  {
+        return;
+	  }
+	else // if ( Ctrl )
+	  {
+        switch (myCurrentMode)
+        {
+         case CurAction2d_Nothing :
+         if (point.x == myXmin && point.y == myYmin)
+         { // no offset between down and up --> selectEvent
+            myXmax=point.x;  
+            myYmax=point.y;
+            if (nFlags & MK_SHIFT )
+              GetDocument()->ShiftInputEvent2D(point.x,point.y,myV2dView);
+            else
+              GetDocument()->InputEvent2D     (point.x,point.y,myV2dView);
+         } else
+         {
+            DrawRectangle2D(myXmin,myYmin,myXmax,myYmax,Standard_False);
+            myXmax=point.x;  
+            myYmax=point.y;
+		    if (nFlags & MK_SHIFT)
+				GetDocument()->ShiftDragEvent2D(point.x,point.y,1,myV2dView);
+			else
+				GetDocument()->DragEvent2D(point.x,point.y,1,myV2dView);
+         }
+         break;
+         case CurAction2d_DynamicZooming :
+             // SetCursor(AfxGetApp()->LoadStandardCursor());         
+	       myCurrentMode = CurAction2d_Nothing;
+         break;
+         case CurAction2d_WindowZooming :
+           myXmax=point.x;         myYmax=point.y;
+            DrawRectangle2D(myXmin,myYmin,myXmax,myYmax,Standard_False,LongDash);
+	       if ((abs(myXmin-myXmax)>ValZWMin) || (abs(myYmin-myYmax)>ValZWMin))
+					 // Test if the zoom window is greater than a minimale window.
+			{
+			  // Do the zoom window between Pmin and Pmax
+			  myV2dView->WindowFit(myXmin,myYmin,myXmax,myYmax);  
+			}  
+	       myCurrentMode = CurAction2d_Nothing;
+         break;
+         case CurAction2d_DynamicPanning :
+           myCurrentMode = CurAction2d_Nothing;
+         break;
+         case CurAction2d_GlobalPanning :
+	       myV2dView->Place(point.x,point.y,myCurZoom); 
+	       myCurrentMode = CurAction2d_Nothing;
+        break;
+        default :
+           Standard_Failure::Raise(" incompatible Current Mode ");
+        break;
+        } //switch (myCurrentMode)
+    } //	else // if ( Ctrl )
+	
+}
+
+void CGeometryView2D::OnMButtonDown(UINT nFlags, CPoint point) 
+{
+   if ( nFlags & MK_CONTROL ) 
+	  {
+      	// Button MB2 down Control : panning init  
+        // SetCursor(AfxGetApp()->LoadStandardCursor());   
+	  }
+
+}
+
+void CGeometryView2D::OnMButtonUp(UINT nFlags, CPoint point) 
+{
+   if ( nFlags & MK_CONTROL ) 
+	  {
+      	// Button MB2 up Control : panning stop 
+        // SetCursor(AfxGetApp()->LoadStandardCursor());   
+	  }
+
+}
+
+void CGeometryView2D::OnRButtonDown(UINT nFlags, CPoint point) 
+{
+	// TODO: Add your message handler code here and/or call default
+   if ( nFlags & MK_CONTROL ) 
+	  {
+        // SetCursor(AfxGetApp()->LoadStandardCursor());   
+	  }
+	else // if ( Ctrl )
+	  {
+	    GetDocument()->Popup2D(point.x,point.y,myV2dView);
+      }	
+
+}
+
+void CGeometryView2D::OnRButtonUp(UINT nFlags, CPoint point) 
+{
+	OCC_2dView::Popup2D(point.x,point.y);
+}
+
+void CGeometryView2D::OnMouseMove(UINT nFlags, CPoint point) 
+{
+    //   ============================  LEFT BUTTON =======================
+  if ( nFlags & MK_LBUTTON)
+    {
+     if ( nFlags & MK_CONTROL ) 
+	  {
+	    // move with MB1 and Control : on the dynamic zooming  
+	    // Do the zoom in function of mouse's coordinates  
+	    myV2dView->Zoom(myXmax,myYmax,point.x,point.y); 
+	    // save the current mouse coordinate in min 
+		myXmax = point.x; 
+        myYmax = point.y;	
+	  }
+	  else // if ( Ctrl )
+	  {
+        switch (myCurrentMode)
+        {
+         case CurAction2d_Nothing :
+            DrawRectangle2D(myXmin,myYmin,myXmax,myYmax,Standard_False);
+		   myXmax = point.x; 
+           myYmax = point.y;	
+       	   GetDocument()->DragEvent2D(myXmax,myYmax,0,myV2dView);
+            DrawRectangle2D(myXmin,myYmin,myXmax,myYmax,Standard_True);
+         break;
+         case CurAction2d_DynamicZooming :
+	       myV2dView->Zoom(myXmax,myYmax,point.x,point.y); 
+	       // save the current mouse coordinate in min \n";
+	       myXmax=point.x;  myYmax=point.y;
+         break;
+         case CurAction2d_WindowZooming :
+		   myXmax = point.x; myYmax = point.y;	
+            DrawRectangle2D(myXmin,myYmin,myXmax,myYmax,Standard_False,LongDash);
+            DrawRectangle2D(myXmin,myYmin,myXmax,myYmax,Standard_True,LongDash);
+         break;
+         case CurAction2d_DynamicPanning :
+		   myV2dView->Pan(point.x-myXmax,myYmax-point.y); // Realize the panning
+		   myXmax = point.x; myYmax = point.y;	
+         break;
+         case CurAction2d_GlobalPanning : // nothing           
+        break;
+        default :
+           Standard_Failure::Raise(" incompatible Current Mode ");
+        break;
+        }//  switch (myCurrentMode)
+      }// if ( nFlags & MK_CONTROL )  else 
+    } else //   if ( nFlags & MK_LBUTTON) 
+    //   ============================  MIDDLE BUTTON =======================
+    if ( nFlags & MK_MBUTTON)
+    {
+     if ( nFlags & MK_CONTROL ) 
+	  {
+		myV2dView->Pan(point.x-myXmax,myYmax-point.y); // Realize the panning
+		myXmax = point.x; myYmax = point.y;	
+
+	  }
+    } else //  if ( nFlags & MK_MBUTTON)
+    //   ============================  RIGHT BUTTON =======================
+    if ( nFlags & MK_RBUTTON)
+    {
+    }else //if ( nFlags & MK_RBUTTON)
+    //   ============================  NO BUTTON =======================
+    {  // No buttons 
+	  myXmax = point.x; myYmax = point.y;	
+	  if (nFlags & MK_SHIFT)
+		GetDocument()->ShiftMoveEvent2D(point.x,point.y,myV2dView);
+	  else
+		GetDocument()->MoveEvent2D(point.x,point.y,myV2dView);
+    }
+}
+
+void CGeometryView2D::OnSize(UINT nType, int cx, int cy) 
+{
+	if (!myV2dView.IsNull())
+	{
+      myV2dView->MustBeResized(V2d_TOWRE_ENLARGE_SPACE); // added sro
+	}
+	
+}
+
+void CGeometryView2D::OnInitialUpdate()
+
+{
+	Handle(WNT_Window) aWNTWindow;
+	aWNTWindow = new WNT_Window(((CGeometryApp*)AfxGetApp())->GetGraphicDevice(),GetSafeHwnd());	  
+   aWNTWindow->SetBackground(Quantity_NOC_BLACK);
+
+	Handle(WNT_WDriver)  aDriver= new WNT_WDriver(aWNTWindow);
+	myV2dView = new V2d_View(aDriver, GetDocument()->GetViewer2D(),0,0,50);
+
+    // initialyse the grids dialogs
+    TheRectangularGridDialog.Create(CRectangularGrid::IDD, NULL);
+    TheCircularGridDialog.Create(CCircularGrid::IDD, NULL);
+    TheRectangularGridDialog.SetViewer (GetDocument()->GetViewer2D());
+    TheCircularGridDialog.SetViewer (GetDocument()->GetViewer2D());
+
+	Standard_Integer w=100 , h=100 ;   /* Debug Matrox                         */
+	aWNTWindow->Size (w,h) ;           /* Keeps me unsatisfied (rlb).....      */
+	                                   /* Resize is not supposed to be done on */
+	                                   /* Matrox                               */
+	                                   /* I suspect another problem elsewhere  */
+	::PostMessage ( GetSafeHwnd () , WM_SIZE , SIZE_RESTORED , w + h*65536 ) ;
+
+}

samples/mfc/standard/01_Geometry/src/GeometryView2D.h

@@ -0,0 +1,79 @@
+// NSGViewBib.h : interface of the CNSGView class
+//
+
+#if !defined(AFX_NSGVIEWBIB_H__7BCE3513_40A8_11D1_8BEC_00C04FB657CF__INCLUDED_)
+#define AFX_NSGVIEWBIB_H__7BCE3513_40A8_11D1_8BEC_00C04FB657CF__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+
+#include <OCC_2dView.h>
+
+/////////////////////////////////////////////////////////////////////////////
+/*
+enum CurrentAction2d { 
+  CurAction_Nothing,
+  CurAction_DynamicZooming,
+  CurAction_WindowZooming,
+  CurAction_DynamicPanning,
+  CurAction_GlobalPanning,
+};
+*/
+#define ValZWMin 1
+
+
+
+class CGeometryView2D : public OCC_2dView
+{
+protected: // create from serialization only
+	CGeometryView2D();
+	DECLARE_DYNCREATE(CGeometryView2D)
+
+// Attributes
+public:
+	CGeometryDoc* GetDocument();
+public:
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CNSGViewBib)
+	public:
+	virtual void OnDraw(CDC* pDC);  // overridden to draw this view
+	virtual void OnInitialUpdate(); // called first time after construct
+
+	//}}AFX_VIRTUAL
+
+
+
+// Implementation
+public:
+	virtual ~CGeometryView2D();
+#ifdef _DEBUG
+	virtual void AssertValid() const;
+	virtual void Dump(CDumpContext& dc) const;
+#endif
+
+// Generated message map functions
+protected:
+	//{{AFX_MSG(CGeometryView2D)
+	afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
+	afx_msg void OnLButtonUp(UINT nFlags, CPoint point);
+	afx_msg void OnMButtonDown(UINT nFlags, CPoint point);
+	afx_msg void OnMButtonUp(UINT nFlags, CPoint point);
+	afx_msg void OnRButtonDown(UINT nFlags, CPoint point);
+	afx_msg void OnRButtonUp(UINT nFlags, CPoint point);
+	afx_msg void OnMouseMove(UINT nFlags, CPoint point);
+	afx_msg void OnSize(UINT nType, int cx, int cy);
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+};
+
+#ifndef _DEBUG  // debug version in NSGViewBibliotheque.cpp
+inline CGeometryDoc* CGeometryView2D::GetDocument()
+   { return (CGeometryDoc*)m_pDocument; }
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+#endif

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_)

samples/mfc/standard/01_Geometry/src/MainFrm.cpp

@@ -0,0 +1,121 @@
+// MainFrm.cpp : implementation of the CMainFrame class
+//
+
+#include "stdafx.h"
+#include "GeometryApp.h"
+
+#include "MainFrm.h"
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+// CMainFrame
+
+IMPLEMENT_DYNAMIC(CMainFrame, CMDIFrameWnd)
+
+BEGIN_MESSAGE_MAP(CMainFrame, CMDIFrameWnd)
+	//{{AFX_MSG_MAP(CMainFrame)
+	ON_WM_CREATE()
+	//}}AFX_MSG_MAP
+END_MESSAGE_MAP()
+
+static UINT indicators[] =
+{
+	ID_SEPARATOR,           // status line indicator
+	ID_INDICATOR_CAPS,
+	ID_INDICATOR_NUM,
+	ID_INDICATOR_SCRL,
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// CMainFrame construction/destruction
+
+CMainFrame::CMainFrame()
+{
+	// TODO: add member initialization code here
+	
+}
+
+CMainFrame::~CMainFrame()
+{
+}
+
+int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
+{
+	if (CMDIFrameWnd::OnCreate(lpCreateStruct) == -1)
+		return -1;
+	
+	if (!m_wndToolBar.Create(this) ||
+		!m_wndToolBar.LoadToolBar(IDR_MAINFRAME))
+	{
+		TRACE0("Failed to create toolbar\n");
+		return -1;      // fail to create
+	}
+	if (!m_wndToolBar2.Create(this) ||
+		!m_wndToolBar2.LoadToolBar(IDR_MAINFRAME2))
+	{
+		TRACE0("Failed to create toolbar\n");
+		return -1;      // fail to create
+	}
+
+	if (!m_wndStatusBar.Create(this) ||
+		!m_wndStatusBar.SetIndicators(indicators,
+		  sizeof(indicators)/sizeof(UINT)))
+	{
+		TRACE0("Failed to create status bar\n");
+		return -1;      // fail to create
+	}
+
+	// TODO: Remove this if you don't want tool tips or a resizeable toolbar
+	m_wndToolBar.SetBarStyle(m_wndToolBar.GetBarStyle() |
+		CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
+
+	// TODO: Delete these three lines if you don't want the toolbar to
+	//  be dockable
+	m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);
+	EnableDocking(CBRS_ALIGN_ANY);
+	DockControlBar(&m_wndToolBar);
+
+	// TODO: Remove this if you don't want tool tips or a resizeable toolbar
+	m_wndToolBar2.SetBarStyle(m_wndToolBar2.GetBarStyle() |
+		CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
+
+	// TODO: Delete these three lines if you don't want the toolbar to
+	//  be dockable
+	m_wndToolBar2.EnableDocking(CBRS_ALIGN_ANY);
+	EnableDocking(CBRS_ALIGN_ANY);
+	DockControlBar(&m_wndToolBar2);
+	return 0;
+}
+
+BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
+{
+	// TODO: Modify the Window class or styles here by modifying
+	//  the CREATESTRUCT cs
+
+	return CMDIFrameWnd::PreCreateWindow(cs);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// CMainFrame diagnostics
+
+#ifdef _DEBUG
+void CMainFrame::AssertValid() const
+{
+	CMDIFrameWnd::AssertValid();
+}
+
+void CMainFrame::Dump(CDumpContext& dc) const
+{
+	CMDIFrameWnd::Dump(dc);
+}
+
+#endif //_DEBUG
+
+/////////////////////////////////////////////////////////////////////////////
+// CMainFrame message handlers
+

samples/mfc/standard/01_Geometry/src/MainFrm.h

@@ -0,0 +1,56 @@
+// MainFrm.h : interface of the CMainFrame class
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_MAINFRM_H__4EF39FB6_4EBB_11D1_8D67_0800369C8A03__INCLUDED_)
+#define AFX_MAINFRM_H__4EF39FB6_4EBB_11D1_8D67_0800369C8A03__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+class CMainFrame : public CMDIFrameWnd
+{
+	DECLARE_DYNAMIC(CMainFrame)
+public:
+	CMainFrame();
+
+// Attributes
+public:
+
+// Operations
+public:
+
+// Overrides
+	// ClassWizard generated virtual function overrides
+	//{{AFX_VIRTUAL(CMainFrame)
+	virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
+	//}}AFX_VIRTUAL
+
+// Implementation
+public:
+	virtual ~CMainFrame();
+#ifdef _DEBUG
+	virtual void AssertValid() const;
+	virtual void Dump(CDumpContext& dc) const;
+#endif
+
+protected:  // control bar embedded members
+	CStatusBar  m_wndStatusBar;
+	CToolBar    m_wndToolBar;
+	CToolBar    m_wndToolBar2;
+
+// Generated message map functions
+protected:
+	//{{AFX_MSG(CMainFrame)
+	afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+};
+
+/////////////////////////////////////////////////////////////////////////////
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Developer Studio will insert additional declarations immediately before the previous line.
+
+#endif // !defined(AFX_MAINFRM_H__4EF39FB6_4EBB_11D1_8D67_0800369C8A03__INCLUDED_)

samples/mfc/standard/01_Geometry/src/StdAfx.cpp

@@ -0,0 +1,6 @@
+// stdafx.cpp : source file that includes just the standard includes
+//	SampleGeometry.pch will be the pre-compiled header
+//	stdafx.obj will contain the pre-compiled type information
+
+#include "stdafx.h"
+

samples/mfc/standard/01_Geometry/src/StdAfx.h

@@ -0,0 +1,272 @@
+// stdafx.h : include file for standard system include files,
+//  or project specific include files that are used frequently, but
+//      are changed infrequently
+//
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#define VC_EXTRALEAN		// Exclude rarely-used stuff from Windows headers
+
+#include <afxwin.h>         // MFC core and standard components
+#include <afxext.h>         // MFC extensions
+#include <afxdisp.h>        // MFC OLE automation classes
+#ifndef _AFX_NO_AFXCMN_SUPPORT
+#include <afxcmn.h>			// MFC support for Windows Common Controls
+#endif // _AFX_NO_AFXCMN_SUPPORT
+
+#if !defined(WNT)
+   #error WNT precompiler directive is mandatory for CasCade 
+#endif
+
+#pragma warning(  disable : 4244 )        // Issue warning 4244
+#include "Standard_ShortReal.hxx"
+#pragma warning(  default : 4244 )        // Issue warning 4244
+
+#include <Standard.hxx>
+/*
+#ifndef Version15B
+# ifndef Version15D
+#  ifndef Version20
+#   define Version15B
+#  endif // Version20
+# endif // Version15D
+#endif // Version15B
+
+#pragma message ("=============================")
+#ifdef Version15B
+# pragma message ("Set the libs for version 1.5B")
+#endif // Version15B
+
+#ifdef Version15D
+# pragma message ("Set the libs for version 1.5D")
+#endif // Version15D
+
+#ifdef Version20
+# pragma message ("Set the libs for version 2.0 ")
+#endif // Version20
+#pragma message ("=============================")
+
+#ifdef Version15B
+# pragma comment (lib,"TKTop.lib")
+# pragma comment (lib,"TShort.lib")
+# pragma comment (lib,"TColQuantity.lib")
+#endif
+
+#ifdef Version15D
+# pragma comment (lib,"TKTop.lib")
+#endif
+
+#ifdef Version20
+# pragma comment (lib,"TKTop1.lib")
+# pragma comment (lib,"TKTop2.lib")
+#endif
+
+#pragma message ("Set the specific libs for the application")
+# pragma comment (lib,"TKPrs.lib")
+# pragma comment (lib,"TKGeom.lib")
+# pragma comment (lib,"TKGlt.lib")
+# pragma comment (lib,"TKGraphic.lib")
+# pragma comment (lib,"TKPrsMgr.lib")
+# pragma comment (lib,"TKViewers.lib")
+# pragma comment (lib,"TKSession.lib")
+# pragma comment (lib,"Bnd.lib")
+# pragma comment (lib,"gp.lib")
+# pragma comment (lib,"TColgp.lib")
+# pragma comment (lib,"TKernel.lib")
+# pragma comment (lib,"TKXSBase.lib")
+# pragma comment (lib,"TKXSIGES.lib")
+# pragma comment (lib,"TKXS214.lib")
+# pragma comment (lib,"UnitsAPI.lib")
+*/
+ 
+#include <AIS_InteractiveContext.hxx>
+#include <AIS_Shape.hxx>
+//#include <AIS_Trihedron.hxx>
+#include <BRepAlgo.hxx>
+#include <BRep_Builder.hxx>
+#include <BRepTools.hxx>
+#include <Graphic3d_WNTGraphicDevice.hxx>
+#include <TopExp_Explorer.hxx>
+#include <TopoDS_Compound.hxx>
+#include <TopoDS_Shape.hxx>
+#include <TopoDS_Solid.hxx>
+#include <TopoDS.hxx>
+#include <V3d_Viewer.hxx>
+#include <V3d_View.hxx>
+#include <WNT_Window.hxx>
+
+
+#include <Standard_ErrorHandler.hxx>
+#include <TopoDS_Shape.hxx>
+#include <TopoDS_Solid.hxx>
+#include <TopoDS.hxx>
+#include <TopExp_Explorer.hxx>
+//#include <ShapeTool_Face.hxx>
+//#include <ShapeTool_PCurves.hxx>
+//#include <ShapeTool_Reshape.hxx>
+//#include <ShapeTool_ShellSolid.hxx>
+#include <TopoDS_ListIteratorOfListOfShape.hxx>
+
+#include "WNT_WDriver.hxx"
+#include "V2d_View.hxx"
+#include "V2d_Viewer.hxx"
+
+
+//#include "UnitsAPI.hxx"
+
+
+#include "GProp_PEquation.hxx"
+#include "gp.hxx"
+#include "TColgp_Array1OfPnt.hxx"
+#include "Geom2d_Circle.hxx"
+#include "gp_Vec2d.hxx"
+#include "Geom2d_Circle.hxx"
+#include "Geom2dLProp_Curve2dTool.hxx"
+
+#include "Geom2dLProp_CLProps2d.hxx"
+#include "gp_Dir.hxx"
+#include "Precision.hxx"
+#include "GCPnts_AbscissaPoint.hxx"
+#include "Geom2dAdaptor_Curve.hxx"
+#include "GCPnts_UniformAbscissa.hxx"
+#include "Geom_SphericalSurface.hxx"
+#include "Geom_Circle.hxx"
+#include "GC_MakeTranslation.hxx"
+#include "Geom_Transformation.hxx"
+#include "GC_MakeCircle.hxx"
+#include "gp_Mat.hxx"
+#include "GeomAPI_IntCS.hxx"
+#include "GC_MakeSegment.hxx"
+#include "GC_MakeConicalSurface.hxx"
+#include "gp_Lin.hxx"
+#include "Geom2d_Ellipse.hxx"
+#include "GCE2d_MakeEllipse.hxx"
+#include "GCE2d_MakeArcOfEllipse.hxx"
+#include "TColgp_HArray1OfPnt.hxx"
+#include "Geom_BSplineCurve.hxx"
+#include "GeomAPI_PointsToBSpline.hxx"
+#include "GeomAPI_Interpolate.hxx"
+#include "GccEnt_QualifiedLin.hxx"
+#include "GccAna_Circ2d2TanRad.hxx"
+#include "gce_MakeCirc2d.hxx"
+#include "GccEnt.hxx"
+#include "GccAna_Lin2d2Tan.hxx"
+#include "GccEnt_QualifiedCirc.hxx"
+#include "gce_MakeLin2d.hxx"
+#include "Geom2d_OffsetCurve.hxx"
+#include "Geom2dAPI_InterCurveCurve.hxx"
+#include "Geom2dAPI_ExtremaCurveCurve.hxx"
+#include "GeomAPI.hxx"
+#include "Geom2d_TrimmedCurve.hxx"
+#include "GCE2d_MakeSegment.hxx"
+#include "Geom2dConvert.hxx"
+#include "TColgp_Array1OfPnt2d.hxx"
+#include "TColgp_HArray1OfPnt2d.hxx"
+#include "gp_Parab2d.hxx"
+#include "gp_Trsf.hxx"
+#include "gp_Pln.hxx"
+#include "gp_Elips.hxx"
+#include "IntAna_IntConicQuad.hxx"
+#include "GeomAPI_ProjectPointOnSurf.hxx"
+#include "GeomAPI_ProjectPointOnCurve.hxx"
+#include "Geom2dAPI_PointsToBSpline.hxx"
+#include "Geom2dAPI_Interpolate.hxx"
+#include "GccAna_Pnt2dBisec.hxx"
+#include "BRepBuilderAPI_MakeVertex.hxx"
+#include "BRepBuilderAPI_MakeFace.hxx"
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+#include "GeomTools.hxx"
+
+#include "TColgp_SequenceOfPnt2d.hxx"
+#include "GC_MakePlane.hxx"
+#include "GC_MakeEllipse.hxx"
+#include "Geom_Plane.hxx"
+#include "Geom2d_Line.hxx"
+#include "Geom_Circle.hxx"
+#include "AIS_Drawer.hxx"
+#include "Prs3d_IsoAspect.hxx"
+#include "GCE2d_MakeArcOfCircle.hxx"
+#include "Geom_Line.hxx"
+#include "Geom2d_BSplineCurve.hxx"
+#include "TColgp_Array2OfPnt2d.hxx"
+#include "Geom_RectangularTrimmedSurface.hxx"
+#include "GeomFill_FillingStyle.hxx"
+#include "GeomFill_BSplineCurves.hxx"
+#include "TopoDS_Vertex.hxx"
+#include "TopoDS_Shape.hxx"
+#include "TopoDS_Face.hxx"
+
+#include "GeomAdaptor_HCurve.hxx"
+#include "GeomFill_SimpleBound.hxx"
+#include "GeomFill_Pipe.hxx"
+#include "GeomConvert.hxx"
+#include "TColgp_Array2OfPnt.hxx"
+#include "Geom_BezierSurface.hxx"
+#include "TColGeom_Array2OfBezierSurface.hxx"
+#include "GeomConvert_CompBezierSurfacesToBSplineSurface.hxx"
+#include "TColStd_HArray1OfInteger.hxx"
+#include "Geom_OffsetSurface.hxx"
+#include "Geom_SurfaceOfLinearExtrusion.hxx"
+#include "Geom_SurfaceOfRevolution.hxx"
+#include "GeomLib.hxx"
+#include "Geom_BSplineSurface.hxx"
+#include "Geom2d_Parabola.hxx"
+#include "GCE2d_MakeParabola.hxx"
+#include "Geom_TrimmedCurve.hxx"
+#include "GeomFill_ConstrainedFilling.hxx"
+
+#include "Geom_Curve.hxx"
+#include "Geom_Surface.hxx"
+#include "BndLib_Add2dCurve.hxx"
+#include "BndLib.hxx"
+#include "FairCurve_Batten.hxx"
+#include "FairCurve_MinimalVariation.hxx"
+#include "Geom2d_Parabola.hxx"
+#include "GCE2d_MakeParabola.hxx"
+#include "Geom_TrimmedCurve.hxx"
+#include "GeomFill_ConstrainedFilling.hxx"
+#include <GeomAPI_ExtremaSurfaceSurface.hxx>
+#include <TColgp_Array2OfPnt.hxx>
+#include <GeomAPI_PointsToBSplineSurface.hxx>
+#include <GeomAdaptor_Surface.hxx>
+#include <BndLib_AddSurface.hxx>   
+#include <BndLib_Add3dCurve.hxx>
+#include "Prs3d_TextAspect.hxx"
+#include "Prs3d_ArrowAspect.hxx"
+#include "Prs3d_PointAspect.hxx"
+#include <BRepMesh.hxx>
+#include <TColgp_SequenceOfPnt.hxx>
+#include <BRep_Tool.hxx>
+#include <Poly_Triangulation.hxx>
+#include <GeomPlate_BuildPlateSurface.hxx>
+#include <GeomPlate_PointConstraint.hxx>
+#include <GeomPlate_MakeApprox.hxx>
+#include <ShapeAnalysis_FreeBounds.hxx>
+#include <TopTools_IndexedMapOfShape.hxx>
+#include <TopExp.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Builder.hxx>
+#include <ShapeFix_Shape.hxx>
+#include <AIS_Point.hxx>
+#include <Geom_CartesianPoint.hxx>
+
+#include "ISession2D_Curve.h"
+#include "ISession_Direction.h"
+#include "ISession2D_InteractiveContext.h"
+#include "ISession_Curve.h"
+#include "ISession_Surface.h"
+#include "ISession_Text.h"
+#include "ISession_Point.h"
+
+#include <UnitsAPI.hxx>
+#include "..\res\resource.h"
+
+
+//{{AFX_INSERT_LOCATION}}
+// Microsoft Developer Studio will insert additional declarations immediately before the previous line.
+