OpenGL

开发平台：
Visual C++

MyglDoc.cpp：源码内容
							/////////////////////////////////////////////////////////////////////////////
// MyglDoc.cpp : implementation of the CMyglDoc class
//
// ModelMagic 3D and 'glOOP' (OpenGL Object Oriented Programming library)
// Copyright (c) Craig Fahrnbach 1997, 1999
//
// OpenGL is a registered trademark of Silicon Graphics
//
//
// This program is provided for educational and personal use only and
// is provided without guarantee or warrantee expressed or implied.
//
// Commercial use is strickly prohibited without written permission
// from ImageWare Development.
//
/////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "memory.h"
#include "ModelMagic3D.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CMyglDoc
IMPLEMENT_DYNCREATE(CMyglDoc, CDocument)
BEGIN_MESSAGE_MAP(CMyglDoc, CDocument)
	//{{AFX_MSG_MAP(CMyglDoc)
	ON_COMMAND(ID_MATL_SAVE, OnMatlSave)
	ON_COMMAND(ID_MATL_OPEN, OnMatlOpen)
	ON_COMMAND(ID_OBJECT_OPEN, OnObjectOpen)
	ON_COMMAND(ID_OBJECT_SAVE_AS, OnObjectSaveAs)
	ON_COMMAND(ID_OBJECT_NEW_CUBE, OnObjectNewCube)
	ON_COMMAND(ID_OBJECT_NEW_CONE, OnObjectNewCone)
	ON_COMMAND(ID_OBJECT_NEW_CYLINDER, OnObjectNewCylinder)
	ON_COMMAND(ID_OBJECT_NEW_CSG, OnObjectNewCSG)
	ON_COMMAND(ID_OBJECT_NEW_TORUS, OnObjectNewTorus)
	ON_COMMAND(ID_OBJECT_NEW_PLANE, OnObjectNewPlane)
	ON_COMMAND(ID_OBJECT_NEW_SPHERE, OnObjectNewSphere)
	ON_COMMAND(ID_OBJECT_NEW_TTF, OnObjectNewTTF)
	ON_COMMAND(ID_OBJECT_NEW_LATHE, OnObjectNewLathe)
	ON_COMMAND(ID_OBJECT_NEW_DISK, OnObjectNewDisk)
	ON_COMMAND(ID_OBJECT_NEW_GRID, OnObjectNewGrid)
	ON_COMMAND(ID_OBJECT_NEW_TRIANGLE, OnObjectNewTriangle)
	ON_COMMAND(ID_SNAP_TO_GRID, OnSnapToGrid)
	ON_UPDATE_COMMAND_UI(ID_SNAP_TO_GRID, OnUpdateSnapToGrid)
	ON_COMMAND(ID_ANIMATE_FLY, OnAnimateFly)
	ON_UPDATE_COMMAND_UI(ID_ANIMATE_FLY, OnUpdateAnimateFly)
	ON_COMMAND(ID_KEYFRAME_PLAY, OnKeyframePlay)
	ON_COMMAND(ID_KEYFRAME_FIRST, OnKeyframeFirst)
	ON_UPDATE_COMMAND_UI(ID_KEYFRAME_FIRST, OnUpdateKeyframeFirst)
	ON_COMMAND(ID_KEYFRAME_LAST, OnKeyframeLast)
	ON_UPDATE_COMMAND_UI(ID_KEYFRAME_LAST, OnUpdateKeyframeLast)
	ON_COMMAND(ID_KEYFRAME_NEXT, OnKeyframeNext)
	ON_UPDATE_COMMAND_UI(ID_KEYFRAME_NEXT, OnUpdateKeyframeNext)
	ON_UPDATE_COMMAND_UI(ID_KEYFRAME_PLAY, OnUpdateKeyframePlay)
	ON_COMMAND(ID_KEYFRAME_PREVIOUS, OnKeyframePrevious)
	ON_UPDATE_COMMAND_UI(ID_KEYFRAME_PREVIOUS, OnUpdateKeyframePrevious)
	ON_COMMAND(ID_KEYFRAME_RECORD, OnKeyframeRecord)
	ON_UPDATE_COMMAND_UI(ID_KEYFRAME_RECORD, OnUpdateKeyframeRecord)
	ON_COMMAND(ID_KEYFRAME_UNRECORD, OnKeyframeUnrecord)
	ON_UPDATE_COMMAND_UI(ID_KEYFRAME_UNRECORD, OnUpdateKeyframeUnrecord)
	ON_COMMAND(ID_TEXTURE_OPEN, OnTextureOpen)
	ON_COMMAND(ID_TEXTURE_EDIT, OnTextureEdit)
	ON_COMMAND(ID_TEXTURE_REMOVE, OnTextureRemove)
	ON_COMMAND(ID_OBJECT_NEW_NURB, OnObjectNewNurb)
	ON_COMMAND(ID_OBJECT_NEW_TERRAIN, OnObjectNewTerrain)
	ON_COMMAND(ID_SELECT_CAMERA, OnSelectCamera)
	ON_UPDATE_COMMAND_UI(ID_SELECT_CAMERA, OnUpdateSelectCamera)
	ON_COMMAND(ID_SELECT_PARENT, OnSelectParent)
	ON_UPDATE_COMMAND_UI(ID_SELECT_PARENT, OnUpdateSelectParent)
	ON_COMMAND(ID_SELECT_CHILD, OnSelectChild)
	ON_UPDATE_COMMAND_UI(ID_SELECT_CHILD, OnUpdateSelectChild)
	ON_COMMAND(ID_SELECT_OBJECT_AXIS, OnSelectObjectAxis)
	ON_UPDATE_COMMAND_UI(ID_SELECT_OBJECT_AXIS, OnUpdateSelectObjectAxis)
	ON_COMMAND(ID_SELECT_OBJECT_TEXTURE, OnSelectObjectTexture)
	ON_UPDATE_COMMAND_UI(ID_SELECT_OBJECT_TEXTURE, OnUpdateSelectObjectTexture)
	ON_COMMAND(ID_SELECT_OBJECT_TEXTURE_AXIS, OnSelectObjectTextureAxis)
	ON_UPDATE_COMMAND_UI(ID_SELECT_OBJECT_TEXTURE_AXIS, OnUpdateSelectObjectTextureAxis)
	ON_COMMAND(ID_SELECT_OBJECT_EDGES, OnSelectObjectEdges)
	ON_UPDATE_COMMAND_UI(ID_SELECT_OBJECT_EDGES, OnUpdateSelectObjectEdges)
	ON_COMMAND(ID_SELECT_OBJECT_POINTS, OnSelectObjectPoints)
	ON_UPDATE_COMMAND_UI(ID_SELECT_OBJECT_POINTS, OnUpdateSelectObjectPoints)
	ON_COMMAND(ID_SELECT_POINTS, OnSelectPoints)
	ON_UPDATE_COMMAND_UI(ID_SELECT_POINTS, OnUpdateSelectPoints)
	ON_COMMAND(ID_COMMAND_SELECT, OnCommandSelect)
	ON_UPDATE_COMMAND_UI(ID_COMMAND_SELECT, OnUpdateCommandSelect)
	ON_COMMAND(ID_COMMAND_MOVE, OnCommandMove)
	ON_UPDATE_COMMAND_UI(ID_COMMAND_MOVE, OnUpdateCommandMove)
	ON_COMMAND(ID_COMMAND_ROTATE, OnCommandRotate)
	ON_UPDATE_COMMAND_UI(ID_COMMAND_ROTATE, OnUpdateCommandRotate)
	ON_COMMAND(ID_COMMAND_SCALE, OnCommandScale)
	ON_UPDATE_COMMAND_UI(ID_COMMAND_SCALE, OnUpdateCommandScale)
	ON_COMMAND(ID_COMMAND_PAINT, OnCommandPaint)
	ON_UPDATE_COMMAND_UI(ID_COMMAND_PAINT, OnUpdateCommandPaint)
	ON_COMMAND(ID_COMMAND_POINTS_CREATE, OnCommandPointsCreate)
	ON_UPDATE_COMMAND_UI(ID_COMMAND_POINTS_CREATE, OnUpdateCommandPointsCreate)
	ON_COMMAND(ID_COORDINATE_X_AXIS, OnCoordinateXAxis)
	ON_UPDATE_COMMAND_UI(ID_COORDINATE_X_AXIS, OnUpdateCoordinateXAxis)
	ON_COMMAND(ID_COORDINATE_Y_AXIS, OnCoordinateYAxis)
	ON_UPDATE_COMMAND_UI(ID_COORDINATE_Y_AXIS, OnUpdateCoordinateYAxis)
	ON_COMMAND(ID_COORDINATE_Z_AXIS, OnCoordinateZAxis)
	ON_UPDATE_COMMAND_UI(ID_COORDINATE_Z_AXIS, OnUpdateCoordinateZAxis)
	ON_COMMAND(ID_COORDINATE_OBJECT, OnCoordinateObject)
	ON_UPDATE_COMMAND_UI(ID_COORDINATE_OBJECT, OnUpdateCoordinateObject)
	ON_COMMAND(ID_COORDINATE_WORLD, OnCoordinateWorld)
	ON_UPDATE_COMMAND_UI(ID_COORDINATE_WORLD, OnUpdateCoordinateWorld)
	ON_COMMAND(ID_OBJECT_NEW_LIGHT, OnObjectNewLight)
	ON_COMMAND(ID_OBJECT_NEW_HSPLINE, OnObjectNewHSpline)
	ON_COMMAND(ID_OBJECT_NEW_CLOUD, OnObjectNewCloud)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()
	// USER defined messages
//	#define RDB_NEW_USER_VIEW		1
//	ON_MESSAGE( WM_REFRESH_DLG_BAR, OnRefreshDlgBar)
/////////////////////////////////////////////////////////////////////////////
// CMyglDoc construction/destruction
CMyglDoc::CMyglDoc()
{
	// Initialize the handles to the printer information
	m_hDevNames = NULL;
	m_hDevMode = NULL;
	// Create a 3D world
	m_pWorld = C3dWorld::CreateWorld();
	m_dTime = 0.0;
	// Set our default states:
	// Set our Selection Flags
	m_bSelectCamera		= FALSE;
	m_bSelectParentObj	= TRUE;
	m_bSelectChildObj	= FALSE;
	m_bSelectPoint		= FALSE;
	// Set our Object Selection Flags
	m_bSelectObjAxis		= FALSE;
	m_bSelectObjTexture		= FALSE;
	m_bSelectObjTextureAxis	= FALSE;
	m_bSelectObjEdges		= FALSE;
	m_bSelectObjPoints		= FALSE;
	// Set our Command Flags
	m_bSelect		= FALSE;
	m_bMove			= TRUE;
	m_bRotate		= FALSE;
	m_bScale		= FALSE;
	m_bPaint		= FALSE;
	m_bCreatePoints	= FALSE;
	
	// Set our model Coordinate flags
	m_bUnLockXAxis	= TRUE;
	m_bUnLockYAxis	= TRUE;
	m_bUnLockZAxis	= TRUE;
	
	m_bObjectCoordinates = FALSE;
	m_bWorldCoordinates  = TRUE;
	// Misc flags
	m_bSnapToGrid	= FALSE;
//	m_bDisplayPoints;  ** ?? **
}
CMyglDoc::~CMyglDoc()
{
	// Free the printer information 
	if(m_hDevMode)
		GlobalFree(m_hDevMode);
	if(m_hDevNames)
		GlobalFree(m_hDevNames);
	m_pWorld = NULL;
}
/////////////////////////////////////////////////////////////////////////////
// CMyglDoc serialization
void CMyglDoc::Serialize(CArchive& ar)
{
	char buf[80];
	// Get a pointer to our CMDIFrameWnd
	CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
	ASSERT_VALID(pFrame);
	// Get a pointer to our status bar
	CStatusBar* pStatus = &pFrame->m_wndStatusBar;
	ASSERT_VALID(pStatus);
	// Get a pointer to the first view in the list of views:
	POSITION pos = GetFirstViewPosition();
	CMyglView* pView = (CMyglView*)GetNextView(pos);
	ASSERT_VALID(pView);
	if (ar.IsStoring())
	{
		// Store or save our world document
		sprintf(buf, "Saving World data file '%s'n", m_pWorld->m_szName);
		pStatus->SetPaneText(0, buf);
		m_pWorld->Serialize(ar, &pView->m_Camera);
		pStatus->SetPaneText(0, NULL);
	}
	else
	{
		// Load or read our world document
		sprintf(buf, "Reading World data file '%s'n", m_pWorld->m_szName);
		pStatus->SetPaneText(0, buf);
		m_pWorld->Serialize(ar, &pView->m_Camera);
		pStatus->SetPaneText(0, NULL);
	}
}
/////////////////////////////////////////////////////////////////////////////
// CMyglDoc diagnostics
#ifdef _DEBUG
void CMyglDoc::AssertValid() const
{
	CDocument::AssertValid();
}
void CMyglDoc::Dump(CDumpContext& dc) const
{
	CDocument::Dump(dc);
}
#endif //_DEBUG
/////////////////////////////////////////////////////////////////////////////
// CMyglDoc Methods / Implementation
void CMyglDoc::AddObject(C3dObject* pObject)
{
	// Get a pointer to our CMyglView Class
	POSITION pos = GetFirstViewPosition();
	CMyglView* pFirstView = (CMyglView*)GetNextView(pos);
	ASSERT_VALID(pFirstView);
	// Bring up the attributes dialog box for the 
	// user to edit..
	if(pObject->EditAttributes(pFirstView, m_pWorld) ==IDOK)
	{
		// User selected OK, so add the object to the list
		if(m_pWorld->m_pSelectedObj)
			m_pWorld->AddObject(pObject, m_pWorld->m_pSelectedObj);
		else
			m_pWorld->AddObject(pObject, NULL);
		// Set the document as modified...
		SetModifiedFlag(TRUE);
		// Refresh the Tree Control:
		CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
		ASSERT(pFrame);
		if(pFrame->m_wndTreeDlgBar)
			pFrame->m_wndTreeDlgBar.InsertObject(pObject);
		// Set the object color from the curently selected 
		// color dialog bar
		if(pFrame->m_wndColorDlgBar.IsWindowEnabled())
			// Don't set the color if this object is a Cloud or a Terrain
			// object
			if(!pObject->IsKindOf( RUNTIME_CLASS (C3dObjectCloud)) &&
			   !pObject->IsKindOf( RUNTIME_CLASS (C3dObjectTerrain)))
				pObject->SetColor4fv(&pFrame->m_wndColorDlgBar.m_Color);
		// Force a repaint of the window
		UpdateAllViews(NULL);
	}
	else
		delete pObject;
}
void CMyglDoc::ResetSelectionFlags()
{
	m_bSelectCamera		= FALSE;
	m_bSelectParentObj	= FALSE;
	m_bSelectChildObj	= FALSE;
	m_bSelectPoint		= FALSE;
	m_bSelectObjAxis		= FALSE;
	m_bSelectObjTexture		= FALSE;
	m_bSelectObjTextureAxis	= FALSE;
	m_bSelectObjEdges		= FALSE;
	m_bSelectObjPoints		= FALSE;
	m_pWorld->m_bDisplayPoints = FALSE;
}
void CMyglDoc::ResetCommandFlags()
{
	m_bSelect		= FALSE;
	m_bMove			= FALSE;
	m_bRotate		= FALSE;
	m_bScale		= FALSE;
	m_bPaint		= FALSE;
	m_bCreatePoints	= FALSE;
}
void CMyglDoc::UserSelectedAnObject()
{
	if(m_bSelectCamera)
		// Call the protected OnSelectParent() function
		OnSelectParent();
}
/////////////////////////////////////////////////////////////////////////////
// CMyglDoc message commands
BOOL CMyglDoc::OnNewDocument()
{
	if (!CDocument::OnNewDocument())
		return FALSE;
	// TODO: add reinitialization code here
	// (SDI documents will reuse this document)
	return TRUE;
}
void CMyglDoc::OnCloseDocument() 
{
	if(m_pWorld) {
		m_pWorld->DeleteWorld();
		m_pWorld = NULL;
	}
	CDocument::OnCloseDocument();
}
void CMyglDoc::SetTitle(LPCTSTR lpszTitle) 
{
	 // Set the title of world attached to this doc
//	strcpy(&m_pWorld->m_szName[0], lpszTitle);
	m_pWorld->m_szName = lpszTitle;
	CDocument::SetTitle(lpszTitle);
}
/*
void CMyglDoc::OnFileSaveAs() 
{
	// TODO: Add your command handler code here
	CFileDialog fileDlg(FALSE, NULL, GetTitle());
	fileDlg.m_ofn.lpstrFilter =	"World Files (*.wld)*.wldObject Files (*.obj)*.objAll Files (*.*)*.*";
	fileDlg.m_ofn.lpstrTitle = "Save As";
	int retn = fileDlg.DoModal();
	if(retn == IDOK) {
		CString szFile = fileDlg.GetFileName();
		CString szPath = fileDlg.GetPathName();
		CString szFileExt = fileDlg.GetFileExt();
		// Save the docuement
		OnSaveDocument(szPath);
		SetTitle(szFile);
		SetModifiedFlag(FALSE);
	}
}
*/
void CMyglDoc::OnMatlOpen() 
{
	CFileDialog fileDlg(TRUE, NULL, NULL);
	fileDlg.m_ofn.lpstrFilter =	"Material Files (*.mtl)*.mtlObject Files (*.obj)*.objAll Files (*.*)*.*";
	fileDlg.m_ofn.lpstrTitle = "Open";
	int retn = fileDlg.DoModal();
	if(retn == IDOK) {
		CString szFile = fileDlg.GetFileName();
		CString szPath = fileDlg.GetPathName();
		CString szFileExt = fileDlg.GetFileExt();
		if(szFileExt.Compare("mtl") == 0) {
			m_pWorld->m_MaterialList.LoadMaterials(szPath);
			m_pWorld->m_szMatlFile = szPath;
			SetModifiedFlag(TRUE);
		}
		else
			AfxMessageBox("Invalid File Extension!  Select files with 'mtl' extension.", MB_OK, NULL);
	}
}
void CMyglDoc::OnMatlSave() 
{
	CFileDialog fileDlg(FALSE, NULL, m_pWorld->m_szMatlFile);
	fileDlg.m_ofn.lpstrFilter =	"Material Files (*.mtl)*.mtlObject Files (*.obj)*.objAll Files (*.*)*.*";
	fileDlg.m_ofn.lpstrTitle = "Save As";
	int retn = fileDlg.DoModal();
	if(retn == IDOK) {
		CString szFile = fileDlg.GetFileName();
		CString szPath = fileDlg.GetPathName();
		CString szFileExt = fileDlg.GetFileExt();
		if(szFileExt.Compare("mtl") == 0) {
			m_pWorld->m_MaterialList.SaveMaterials(szFile);
//			SetModifiedFlag(FALSE);
		}
		else
			AfxMessageBox("Invalid File Extension!  Select files with 'mtl' extension.", MB_OK, NULL);
	}
}
void CMyglDoc::OnObjectOpen() 
{
	C3dObject* pObject;
	// Save the pointer to the selected object.  (When
	// we open the file save as dialog, CMyglDoc::OnActivateView
	// will NULL the currently slected object...)
	pObject = m_pWorld->m_pSelectedObj;
	// we have an object to save..	
	CFileDialog fileDlg(TRUE, NULL, NULL);
	fileDlg.m_ofn.lpstrFilter =	"Object Files (*.obj)*.objAll Files (*.*)*.*";
	fileDlg.m_ofn.lpstrTitle = "Open";
	int retn = fileDlg.DoModal();
	if(retn == IDOK) {
		CString szFile = fileDlg.GetFileName();
		CString szPath = fileDlg.GetPathName();
		CString szFileExt = fileDlg.GetFileExt();
		// Restore the worlds selected object..
		m_pWorld->m_pSelectedObj = pObject;
		if(szFileExt.Compare("obj") == 0) {
			C3dObject* pNewObj;
			int	iType;
			pNewObj = C3dObject::LoadObject(szFile, &iType);
			if(pNewObj)
			{
				if(pObject)
					m_pWorld->AddObject(pNewObj, pObject);
				else
					m_pWorld->AddObject(pNewObj, NULL);
				// Set the document as modified
				SetModifiedFlag(TRUE);
				// Refresh the Tree Control:
				CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
				ASSERT(pFrame);
				if(pFrame->m_wndTreeDlgBar)
					pFrame->m_wndTreeDlgBar.InsertObject(pNewObj);
				// Force a repaint of the window
				UpdateAllViews(NULL);
			}
		}
		else
			AfxMessageBox("Invalid File Extension!  Select files with 'obj' extension.", MB_OK, NULL);
	}
}
void CMyglDoc::OnObjectSaveAs() 
{
	C3dObject* pObject;
	if(!m_pWorld->m_pSelectedObj) {
		AfxMessageBox("Object not Selected. Please select an object and try again.", MB_OK, NULL);
		return;
	}
	// Save the pointer to the selected object.  (When
	// we open the file save as dialog, CMyglDoc::OnActivateView
	// will NULL the currently slected object...)
	pObject = m_pWorld->m_pSelectedObj;
	CString szFile;
	// load the object name and append file extension
	szFile.Format("%s.obj", m_pWorld->m_pSelectedObj->m_szName);
	// we have an object to save..	
	CFileDialog fileDlg(FALSE, NULL, szFile);
	fileDlg.m_ofn.lpstrFilter =	"Object Files (*.obj)*.objAll Files (*.*)*.*";
	fileDlg.m_ofn.lpstrTitle = "Save As";
	int retn = fileDlg.DoModal();
	if(retn == IDOK) {
		szFile = fileDlg.GetFileName();
		CString szPath = fileDlg.GetPathName();
		CString szFileExt = fileDlg.GetFileExt();
		// Restore the worlds selected object..
		m_pWorld->m_pSelectedObj = pObject;
		if(szFileExt.Compare("obj") == 0) {
			pObject->SaveObject(szFile);
		}
		else
			AfxMessageBox("Invalid File Extension!  Select files with 'obj' extension.", MB_OK, NULL);
	}
}
void CMyglDoc::OnObjectNewLight() 
{
	// Create a light Object
	C3dObjectLight* pLight =  new C3dObjectLight;
	ASSERT(pLight);
	AddObject(pLight);
}
void CMyglDoc::OnObjectNewCloud() 
{
	// Create an Object of type Sky
	C3dObjectCloud* pObject =  new C3dObjectCloud;
	ASSERT(pObject);
	AddObject(pObject);
}
void CMyglDoc::OnObjectNewCone() 
{
	// Create a shape Object of type Cube
	C3dObjectCone* pObject =  new C3dObjectCone;
	ASSERT(pObject);
	AddObject(pObject);
}
void CMyglDoc::OnObjectNewCSG() 
{
	// Create a shape Object of type CSG
	C3dObjectCSG* pObject =  new C3dObjectCSG;
	ASSERT(pObject);
	AddObject(pObject);
}
void CMyglDoc::OnObjectNewCube() 
{
	// Create a shape Object of type Cube
	C3dObjectCube* pObject =  new C3dObjectCube;
	ASSERT(pObject);
	AddObject(pObject);
}
void CMyglDoc::OnObjectNewCylinder() 
{
	// Create a shape Object of type Cylinder
	C3dObjectCylinder* pObject =  new C3dObjectCylinder;
	ASSERT(pObject);
	AddObject(pObject);
}
void CMyglDoc::OnObjectNewDisk() 
{
	// Create an Object of type Disk
	C3dObjectDisk* pObject =  new C3dObjectDisk;
	ASSERT(pObject);
	AddObject(pObject);
}
void CMyglDoc::OnObjectNewGrid() 
{
	// Create an Object of type Grid
	C3dObjectGrid* pObject =  new C3dObjectGrid;
	ASSERT(pObject);
	AddObject(pObject);
}
void CMyglDoc::OnObjectNewHSpline() 
{
	// Create a shape Object of type h-Spline
	C3dObjectHSpline* pObject =  new C3dObjectHSpline;
	ASSERT(pObject);
	AddObject(pObject);
}
void CMyglDoc::OnObjectNewLathe() 
{
	int	iNumPoints;
	iNumPoints = m_pWorld->m_PointList.GetCount();
	if(!iNumPoints) {
		AfxMessageBox("Points List does not exist.  Please create some points first and try again.", MB_OK, NULL);
		return;
	}
	if(iNumPoints < 2) {
		AfxMessageBox("A minimum of two points are required in the Point List.  Please create more points first and try again.", MB_OK, NULL);
		return;
	}
	// Create a shape Object of type Lathe
	C3dObjectLathe* pObject =  new C3dObjectLathe;
	ASSERT(pObject);
	// Create the lathe objects points array
	if(pObject->m_pPointArray->Create(iNumPoints)) {
		AfxMessageBox("Could not create memory for lathe object!  Memory low.", MB_OK, NULL);
		delete pObject;
		return;
	}
	// Copy our PointsList points/vertices into the 
	// lathe objects local list
	pObject->m_pPointArray->CopyFromList(&m_pWorld->m_PointList);
	// Finished with the point list, so lets delete them
	m_pWorld->m_PointList.DeleteAll();
	AddObject(pObject);
}
void CMyglDoc::OnObjectNewNurb() 
{
	// Create an Object of type NURB
	C3dObjectNURB* pObject =  new C3dObjectNURB;
	ASSERT(pObject);
	AddObject(pObject);
}
void CMyglDoc::OnObjectNewPlane() 
{
	// Create an Object of type Plane
	C3dObjectPlane* pObject =  new C3dObjectPlane;
	ASSERT(pObject);
	AddObject(pObject);
}
void CMyglDoc::OnObjectNewSphere() 
{
	// Create an Object of type Sphere
	C3dObjectSphere* pObject =  new C3dObjectSphere;
	ASSERT(pObject);
	AddObject(pObject);
}
void CMyglDoc::OnObjectNewTerrain() 
{
	// Create an new terrain object
	C3dObjectTerrain* pObject =  new C3dObjectTerrain;
	ASSERT(pObject);
	AddObject(pObject);
}
void CMyglDoc::OnObjectNewTorus() 
{
	// Create an Object of type Cube
	C3dObjectTorus* pObject =  new C3dObjectTorus;
	ASSERT(pObject);
	AddObject(pObject);
}
void CMyglDoc::OnObjectNewTriangle() 
{
	// Create an Object of type Cube
	C3dObjectTriangle* pObject =  new C3dObjectTriangle;
	ASSERT(pObject);
	AddObject(pObject);
}
void CMyglDoc::OnObjectNewTTF() 
{
	// Create an Object of type True Type Font
	C3dObjectTTF* pObject =  new C3dObjectTTF;
	ASSERT(pObject);
	AddObject(pObject);
}
void CMyglDoc::OnSnapToGrid() 
{
	if(m_bSnapToGrid)
		m_bSnapToGrid = FALSE;
	else
		m_bSnapToGrid = TRUE;
}
void CMyglDoc::OnUpdateSnapToGrid(CCmdUI* pCmdUI) 
{
	if(m_bSnapToGrid)
		pCmdUI->SetCheck(TRUE);
	else
		pCmdUI->SetCheck(FALSE);
}
void CMyglDoc::OnUpdateCommandPointsCreate(CCmdUI* pCmdUI) 
{
	if(m_bCreatePoints)
		pCmdUI->SetCheck(TRUE);
	else
		pCmdUI->SetCheck(FALSE);
}
void CMyglDoc::OnAnimateFly() 
{
	// Toggle parent/child object selection mode
	m_pWorld->m_bFly = !m_pWorld->m_bFly;
}
void CMyglDoc::OnUpdateAnimateFly(CCmdUI* pCmdUI) 
{
	if(m_pWorld->m_bFly)
		pCmdUI->SetCheck(TRUE);
	else
		pCmdUI->SetCheck(FALSE);
}
void CMyglDoc::OnKeyframeRecord() 
{
	CAnimation* pAnim;
	CAnimKeyFrame*	pAnimKey;
	// Get the 3d World's selected object
	C3dObject* pObj = m_pWorld->m_pSelectedObj;
	if(pObj)
	{
		pAnim = pObj->m_AnimList.Find("KeyFrame");
		if(!pAnim)
		{
			// KeyFrame Animation procedure has not beed
			// created and attached to the object, so 
			// lets create one.
			CAnimKeyFrame* pAnimKeyFrame = new CAnimKeyFrame;
			ASSERT(pAnimKeyFrame);
			// Append to the list of procedures
			pObj->m_AnimList.Append(pAnimKeyFrame);
			pAnimKey = pAnimKeyFrame;
		}
		else
			pAnimKey = (CAnimKeyFrame*)pAnim;
		// Now we have a pointer to our CAnimKeyFrame
		// 
		// Get a pointer to our applications CMDIFrameWnd
		CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
		ASSERT(pFrame);
		// Get the time from the keyframe tool bar
		double dTime = pFrame->m_wndKeyFrameBar.m_fTime;
		
		// Create a new keyframe
		pAnimKey->m_pKeyFrameList->AddKeyFrame(dTime, pObj);
	}
}
void CMyglDoc::OnUpdateKeyframeRecord(CCmdUI* pCmdUI) 
{
	if(m_pWorld->m_pSelectedObj)
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}
void CMyglDoc::OnKeyframeUnrecord() 
{
	// Get the 3d World's selected object
	C3dObject* pObj = m_pWorld->m_pSelectedObj;
	if(pObj)
	{
		// Do we have a KeyFrame Procedure attached to this object?
		CAnimKeyFrame* pAnimKey = (CAnimKeyFrame*) pObj->m_AnimList.Find("KeyFrame");
		if(pAnimKey)
		{
			// Get a pointer to our applications CMDIFrameWnd
			CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
			ASSERT(pFrame);
			// Get the time from the keyframe tool bar
			double dTime = pFrame->m_wndKeyFrameBar.m_fTime;
			// Find the keyframe with the toolbar time value
			CKeyFrame* pKey = pAnimKey->m_pKeyFrameList->Find(dTime);
			if(pKey)
				pAnimKey->m_pKeyFrameList->Delete(pKey);
		}
	}
}
void CMyglDoc::OnUpdateKeyframeUnrecord(CCmdUI* pCmdUI) 
{
	if(m_pWorld->m_pSelectedObj)
	{
		int iNumKeys;
		m_pWorld->m_pSelectedObj->GetKeyFrameList(&iNumKeys);
		if(iNumKeys)
		{
			pCmdUI->Enable(TRUE);
			return;
		}
	}
	pCmdUI->Enable(FALSE);
}
void CMyglDoc::OnKeyframePlay() 
{
	// TODO: Add your command handler code here
	
}
void CMyglDoc::OnUpdateKeyframePlay(CCmdUI* pCmdUI) 
{
	if(m_pWorld->m_pSelectedObj)
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}
void CMyglDoc::OnKeyframeFirst() 
{
	if(m_pWorld->m_pSelectedObj)
	{
		int iNumKeys;
		CAnimKeyFrame* pAnimKey = m_pWorld->m_pSelectedObj->GetKeyFrameList(&iNumKeys);
		if(pAnimKey && iNumKeys)
		{
			// Get the first keyframe from the list
			CKeyFrame* pKey = (CKeyFrame*)pAnimKey->m_pKeyFrameList->GetHead();
			if(pKey)
			{
				// Get a pointer to our applications CMDIFrameWnd
				CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
				ASSERT(pFrame);
				char buf[10];
				sprintf(buf, "%3.1f", pKey->m_dTime);
				pFrame->m_wndKeyFrameBar.m_EditBox.SetSel(0, -1, FALSE);
				pFrame->m_wndKeyFrameBar.m_EditBox.Cut();
				pFrame->m_wndKeyFrameBar.m_EditBox.ReplaceSel(buf, FALSE);
				// Set the objects attributes to the keyframe
				pKey->SetObjectAttributes(m_pWorld->m_pSelectedObj);
				// Force a repaint of all views
				UpdateAllViews(NULL);
			}
		}
	}
}
void CMyglDoc::OnUpdateKeyframeFirst(CCmdUI* pCmdUI) 
{
	if(m_pWorld->m_pSelectedObj)
	{
		int iNumKeys;
		m_pWorld->m_pSelectedObj->GetKeyFrameList(&iNumKeys);
		if(iNumKeys)
		{
			pCmdUI->Enable(TRUE);
			return;
		}
	}
	pCmdUI->Enable(FALSE);
}
void CMyglDoc::OnKeyframePrevious() 
{
	if(m_pWorld->m_pSelectedObj)
	{
		int iNumKeys;
		CAnimKeyFrame* pAnimKey = m_pWorld->m_pSelectedObj->GetKeyFrameList(&iNumKeys);
		if(pAnimKey && iNumKeys)
		{
			// Get a pointer to our applications CMDIFrameWnd
			CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
			ASSERT(pFrame);
			// Get the time from the keyframe tool bar
			double dTime = pFrame->m_wndKeyFrameBar.m_fTime;
			// Find the keyframe with a value smaller, but closest to the
			// toolbar time value
			CKeyFrame* pKey = pAnimKey->m_pKeyFrameList->FindSmaller(dTime);
			if(pKey)
			{
				char buf[10];
				sprintf(buf, "%3.1f", pKey->m_dTime);
				pFrame->m_wndKeyFrameBar.m_EditBox.SetSel(0, -1, FALSE);
				pFrame->m_wndKeyFrameBar.m_EditBox.Cut();
				pFrame->m_wndKeyFrameBar.m_EditBox.ReplaceSel(buf, FALSE);
				// Set the objects attributes to the keyframe
				pKey->SetObjectAttributes(m_pWorld->m_pSelectedObj);
				// Force a repaint of all views
				UpdateAllViews(NULL);
			}
		}
	}
}
void CMyglDoc::OnUpdateKeyframePrevious(CCmdUI* pCmdUI) 
{
	if(m_pWorld->m_pSelectedObj)
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}
void CMyglDoc::OnKeyframeNext() 
{
	if(m_pWorld->m_pSelectedObj)
	{
		int iNumKeys;
		CAnimKeyFrame* pAnimKey = m_pWorld->m_pSelectedObj->GetKeyFrameList(&iNumKeys);
		if(pAnimKey && iNumKeys)
		{
			// Get a pointer to our applications CMDIFrameWnd
			CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
			ASSERT(pFrame);
			// Get the time from the keyframe tool bar
			double dTime = pFrame->m_wndKeyFrameBar.m_fTime;
			// Find the keyframe with a value larger, but closest to the
			// toolbar time value
			CKeyFrame* pKey = pAnimKey->m_pKeyFrameList->FindLarger(dTime);
			if(pKey)
			{
				char buf[10];
				sprintf(buf, "%3.1f", pKey->m_dTime);
				pFrame->m_wndKeyFrameBar.m_EditBox.SetSel(0, -1, FALSE);
				pFrame->m_wndKeyFrameBar.m_EditBox.Cut();
				pFrame->m_wndKeyFrameBar.m_EditBox.ReplaceSel(buf, FALSE);
				// Set the objects attributes to the keyframe
				pKey->SetObjectAttributes(m_pWorld->m_pSelectedObj);
				// Force a repaint of all views
				UpdateAllViews(NULL);
			}
		}
	}
}
void CMyglDoc::OnUpdateKeyframeNext(CCmdUI* pCmdUI) 
{
	if(m_pWorld->m_pSelectedObj)
	{
		int iNumKeys;
		m_pWorld->m_pSelectedObj->GetKeyFrameList(&iNumKeys);
		if(iNumKeys)
		{
			pCmdUI->Enable(TRUE);
			return;
		}
	}
	pCmdUI->Enable(FALSE);
}
void CMyglDoc::OnKeyframeLast() 
{
	if(m_pWorld->m_pSelectedObj)
	{
		int iNumKeys;
		CAnimKeyFrame* pAnimKey = m_pWorld->m_pSelectedObj->GetKeyFrameList(&iNumKeys);
		if(pAnimKey && iNumKeys)
		{
			// Get the Last keyframe from the list
			CKeyFrame* pKey = (CKeyFrame*)pAnimKey->m_pKeyFrameList->GetTail();
			if(pKey)
			{
				// Get a pointer to our applications CMDIFrameWnd
				CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
				ASSERT(pFrame);
				char buf[10];
				sprintf(buf, "%3.1f", pKey->m_dTime);
				pFrame->m_wndKeyFrameBar.m_EditBox.SetSel(0, -1, FALSE);
				pFrame->m_wndKeyFrameBar.m_EditBox.Cut();
				pFrame->m_wndKeyFrameBar.m_EditBox.ReplaceSel(buf, FALSE);
				// Set the objects attributes to the keyframe
				pKey->SetObjectAttributes(m_pWorld->m_pSelectedObj);
				// Force a repaint of all views
				UpdateAllViews(NULL);
			}
		}
	}
}
void CMyglDoc::OnUpdateKeyframeLast(CCmdUI* pCmdUI) 
{
	if(m_pWorld->m_pSelectedObj)
	{
		int iNumKeys;
		m_pWorld->m_pSelectedObj->GetKeyFrameList(&iNumKeys);
		if(iNumKeys)
		{
			pCmdUI->Enable(TRUE);
			return;
		}
	}
	pCmdUI->Enable(FALSE);
}
void CMyglDoc::SetPrinterDeviceDefaults()
{
	// Allocate the structure to store the returned printer info
	PRINTDLG printDlg;
	// Get the printer information
	AfxGetApp()->GetPrinterDeviceDefaults(&printDlg);
	// Lock the handles to the structures to get pointers
	LPDEVNAMES pDevNames = (LPDEVNAMES)::GlobalLock(printDlg.hDevNames);
	LPDEVMODE  pDevMode  = (LPDEVMODE)::GlobalLock(printDlg.hDevMode);
	// Free the old printer information if it exists
	if (m_hDevNames != NULL)
		::GlobalFree(m_hDevNames);
	if (m_hDevMode != NULL)
		::GlobalFree(m_hDevMode);
 
	// Allocate space for the new printer info structures
	m_hDevNames = ::GlobalAlloc(GPTR, ::GlobalSize(printDlg.hDevNames));
	m_hDevMode = ::GlobalAlloc(GPTR, ::GlobalSize(printDlg.hDevMode));
	// Lock the new handles
	LPDEVNAMES m_pDevNames = (LPDEVNAMES)::GlobalLock(m_hDevNames);
	LPDEVMODE  m_pDevMode  = (LPDEVMODE)::GlobalLock(m_hDevMode);
	// Copy the printer information into the document
	memcpy(m_pDevNames, pDevNames,
			(size_t)::GlobalSize(printDlg.hDevNames));
	memcpy(m_pDevMode, pDevMode,
			(size_t)::GlobalSize(printDlg.hDevMode));
	// Unlock the handles
	::GlobalUnlock(printDlg.hDevNames);
	::GlobalUnlock(printDlg.hDevMode);
	::GlobalUnlock(m_hDevNames);
	::GlobalUnlock(m_hDevMode);
}
void CMyglDoc::OnTextureOpen() 
{
	CFileDialog fileDlg(TRUE, NULL, NULL);
	fileDlg.m_ofn.lpstrFilter =	"Texture Files (*.bmp)*.bmpDIB Files (*.dib)*.dibAVI Files (*.avi)*.aviAll Files (*.*)*.*";
	fileDlg.m_ofn.lpstrTitle = "Open Texture Map";
	// Get a pointer to our worlds' selected object
	C3dObject* pObj =  m_pWorld->m_pSelectedObj;
	if(!pObj)
	{
		AfxMessageBox("No Object currently selected", MB_OK, 0);
		return;
	}
	
	int retn = fileDlg.DoModal();
	if(retn == IDOK)
	{
		CString szFile = fileDlg.GetFileName();
		CString szPath = fileDlg.GetPathName();
		CString szFileExt = fileDlg.GetFileExt();
		if(szFileExt.Compare("bmp") == 0 ||
		   szFileExt.Compare("dib") == 0 ||
		   szFileExt.Compare("avi") == 0)
		{
			if(pObj->AddTexture(szFile.GetBuffer(128)))
			{
				// Force a rebuild of the objects display lists
				pObj->m_bBuildLists = TRUE;
				SetModifiedFlag(TRUE);
				// Force a repaint of the window
				UpdateAllViews(NULL);
			}
			else
				AfxMessageBox("Could not create Texture map!", MB_OK, NULL);
		}
		else
			AfxMessageBox("Unsupported File Extension!  Select files with either 'bmp' or 'dib' extensions.", MB_OK, NULL);
	}
}
void CMyglDoc::OnTextureEdit() 
{
	// Get a pointer to our worlds' selected object and
	// selected light
	C3dObject* pObj =  m_pWorld->m_pSelectedObj;
	if(pObj)
	{
		if(pObj->m_pTexture)
		{
			CEditTextureDlg	textureDlg(pObj->m_pTexture, CWnd::GetActiveWindow());
			textureDlg.DoModal();
			// Force a repaint of the window
			UpdateAllViews(NULL);
		}
		else
			AfxMessageBox("Selected Object has no Bitmap texture to edit!", MB_OK, 0);
	}
	else
		AfxMessageBox("Object not selected!", MB_OK, 0);
}
void CMyglDoc::OnTextureRemove() 
{
	// Get a pointer to our worlds' selected object and
	// selected light
	C3dObject* pObj =  m_pWorld->m_pSelectedObj;
	if(pObj)
	{
		pObj->DeleteTexture();
		// Force a repaint of the window
		UpdateAllViews(NULL);
	}
	else
		AfxMessageBox("No Object currently selected", MB_OK, 0);
}
void CMyglDoc::OnSelectCamera() 
{
	if(m_bSelectCamera)
		m_bSelectCamera = FALSE;
	else
	{
		ResetSelectionFlags();
		m_bSelectCamera = TRUE;
	}
	// Get a pointer to our CMDIFrameWnd
	CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
	ASSERT_VALID(pFrame);
	// Post a change message to the Coordinate Dialog Bar.
	pFrame->m_wndCoordDlgBar.PostMessage(WM_UPDATECOORDINATEPAGE, 0, 0L);
	// Force a repaint of the window
	UpdateAllViews(NULL);
}
void CMyglDoc::OnUpdateSelectCamera(CCmdUI* pCmdUI) 
{
	if(m_bSelectCamera)
		pCmdUI->SetCheck(TRUE);
	else
		pCmdUI->SetCheck(FALSE);
}
void CMyglDoc::OnSelectParent() 
{
	if(m_bSelectParentObj)
		m_bSelectParentObj = FALSE;
	else
	{
		ResetSelectionFlags();
		m_bSelectParentObj = TRUE;
	}
	// Get a pointer to our CMDIFrameWnd
	CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
	ASSERT_VALID(pFrame);
	// Post a change message to the Coordinate Dialog Bar.
	pFrame->m_wndCoordDlgBar.PostMessage(WM_UPDATECOORDINATEPAGE, 0, 0L);
	// Force a repaint of the window
	UpdateAllViews(NULL);
}
void CMyglDoc::OnUpdateSelectParent(CCmdUI* pCmdUI) 
{
	if(m_bSelectParentObj)
		pCmdUI->SetCheck(TRUE);
	else
		pCmdUI->SetCheck(FALSE);
}
void CMyglDoc::OnSelectChild() 
{
	if(m_bSelectChildObj)
		m_bSelectChildObj = FALSE;
	else
	{
		ResetSelectionFlags();
		m_bSelectChildObj = TRUE;
	}
	// Get a pointer to our CMDIFrameWnd
	CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
	ASSERT_VALID(pFrame);
	// Post a change message to the Coordinate Dialog Bar.
	pFrame->m_wndCoordDlgBar.PostMessage(WM_UPDATECOORDINATEPAGE, 0, 0L);
	// Force a repaint of the window
	UpdateAllViews(NULL);
}
void CMyglDoc::OnUpdateSelectChild(CCmdUI* pCmdUI) 
{
	if(m_bSelectChildObj)
		pCmdUI->SetCheck(TRUE);
	else
		pCmdUI->SetCheck(FALSE);
}
void CMyglDoc::OnSelectObjectAxis() 
{
	// Get a pointer to our CMDIFrameWnd
	CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
	ASSERT_VALID(pFrame);
	// Post a change message to the Coordinate Dialog Bar.
	pFrame->m_wndCoordDlgBar.PostMessage(WM_CHANGECOORDINATEPAGE, CP_TRANSLATE, 0L);
	if(m_bSelectObjAxis)
		m_bSelectObjAxis = FALSE;
	else
	{
		ResetSelectionFlags();
		m_bSelectObjAxis = TRUE;
	}
}
void CMyglDoc::OnUpdateSelectObjectAxis(CCmdUI* pCmdUI) 
{
	if(m_bSelectObjAxis)
		pCmdUI->SetCheck(TRUE);
	else
		pCmdUI->SetCheck(FALSE);
}
void CMyglDoc::OnSelectObjectTexture() 
{
	if(m_bSelectObjTexture)
		m_bSelectObjTexture = FALSE;
	else
	{
		ResetSelectionFlags();
		m_bSelectObjTexture = TRUE;
	}
}
void CMyglDoc::OnUpdateSelectObjectTexture(CCmdUI* pCmdUI) 
{
	if(m_bSelectObjTexture)
		pCmdUI->SetCheck(TRUE);
	else
		pCmdUI->SetCheck(FALSE);
}
void CMyglDoc::OnSelectObjectTextureAxis() 
{
	if(m_bSelectObjTextureAxis)
		m_bSelectObjTextureAxis = FALSE;
	else
	{
		ResetSelectionFlags();
		m_bSelectObjTextureAxis = TRUE;
	}
}
void CMyglDoc::OnUpdateSelectObjectTextureAxis(CCmdUI* pCmdUI) 
{
	if(m_bSelectObjTextureAxis)
		pCmdUI->SetCheck(TRUE);
	else
		pCmdUI->SetCheck(FALSE);
}
void CMyglDoc::OnSelectObjectEdges() 
{
	if(m_bSelectObjEdges)
		m_bSelectObjEdges = FALSE;
	else
	{
		ResetSelectionFlags();
		m_bSelectObjEdges = TRUE;
	}
}
void CMyglDoc::OnUpdateSelectObjectEdges(CCmdUI* pCmdUI) 
{
	if(m_bSelectObjEdges)
		pCmdUI->SetCheck(TRUE);
	else
		pCmdUI->SetCheck(FALSE);
}
void CMyglDoc::OnSelectObjectPoints() 
{
	// Get a pointer to our CMDIFrameWnd
	CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
	ASSERT_VALID(pFrame);
	if(m_bSelectObjPoints)
		m_bSelectObjPoints = FALSE;
	else
	{
		ResetSelectionFlags();
		m_bSelectObjPoints = TRUE;
	}
	// Set the display flag in the 3dWorld
	m_pWorld->m_bDisplayPoints = m_bSelectObjPoints;
	// Reset our worlds' selected point.  This will force the 
	// user to select a new object point.
	m_pWorld->m_pSelectedPnt = NULL;
	// Post a change message to the Coordinate Dialog Bar.
	pFrame->m_wndCoordDlgBar.PostMessage(WM_CHANGECOORDINATEPAGE, CP_ORIGIN, 0L);
	// Force a repaint of the window
	UpdateAllViews(NULL);
}
void CMyglDoc::OnUpdateSelectObjectPoints(CCmdUI* pCmdUI) 
{
	if(m_bSelectObjPoints)
		pCmdUI->SetCheck(TRUE);
	else
		pCmdUI->SetCheck(FALSE);
}
void CMyglDoc::OnSelectPoints() 
{
	if(m_bSelectPoint)
		m_bSelectPoint = FALSE;
	else
	{
		ResetSelectionFlags();
		m_bSelectPoint = TRUE;
	}
	// Set the display flag in the 3dWorld
	m_pWorld->m_bDisplayPoints = m_bSelectObjPoints;
	// Reset our worlds' selected point.  This will force the 
	// user to select a new object point.
	m_pWorld->m_pSelectedPnt = NULL;
	// Force a repaint of the window
	UpdateAllViews(NULL);
}
void CMyglDoc::OnUpdateSelectPoints(CCmdUI* pCmdUI) 
{
	if(m_bSelectPoint)
		pCmdUI->SetCheck(TRUE);
	else
		pCmdUI->SetCheck(FALSE);
}
void CMyglDoc::OnCommandSelect() 
{
	if(m_bSelect)
		m_bSelect = FALSE;
	else
	{
		ResetCommandFlags();
		m_bSelect = TRUE;
	}
}
void CMyglDoc::OnUpdateCommandSelect(CCmdUI* pCmdUI) 
{
	if(m_bSelect)
		pCmdUI->SetCheck(TRUE);
	else
		pCmdUI->SetCheck(FALSE);
}
void CMyglDoc::OnCommandMove() 
{
	// Get a pointer to our CMDIFrameWnd
	CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
	ASSERT_VALID(pFrame);
	// Post a change message to the Coordinate Dialog Bar.
	pFrame->m_wndCoordDlgBar.PostMessage(WM_CHANGECOORDINATEPAGE, CP_ORIGIN, 0L);
	if(m_bMove)
		m_bMove = FALSE;
	else
	{
		ResetCommandFlags();
		m_bMove = TRUE;
	}
}
void CMyglDoc::OnUpdateCommandMove(CCmdUI* pCmdUI) 
{
	if(m_bMove)
		pCmdUI->SetCheck(TRUE);
	else
		pCmdUI->SetCheck(FALSE);
}
void CMyglDoc::OnCommandRotate() 
{
	// Get a pointer to our CMDIFrameWnd
	CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
	ASSERT_VALID(pFrame);
	// Post a change message to the Coordinate Dialog Bar.
	pFrame->m_wndCoordDlgBar.PostMessage(WM_CHANGECOORDINATEPAGE, CP_ROTATE, 0L);
	if(m_bRotate)
		m_bRotate = FALSE;
	else
	{
		ResetCommandFlags();
		m_bRotate = TRUE;
	}
}
void CMyglDoc::OnUpdateCommandRotate(CCmdUI* pCmdUI) 
{
	if(m_bRotate)
		pCmdUI->SetCheck(TRUE);
	else
		pCmdUI->SetCheck(FALSE);
}
void CMyglDoc::OnCommandScale() 
{
	// Get a pointer to our CMDIFrameWnd
	CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
	ASSERT_VALID(pFrame);
	// Post a change message to the Coordinate Dialog Bar.
	pFrame->m_wndCoordDlgBar.PostMessage(WM_CHANGECOORDINATEPAGE, CP_SCALE, 0L);
	if(m_bScale)
		m_bScale = FALSE;
	else
	{
		ResetCommandFlags();
		m_bScale = TRUE;
	}
}
void CMyglDoc::OnUpdateCommandScale(CCmdUI* pCmdUI) 
{
	if(m_bScale)
		pCmdUI->SetCheck(TRUE);
	else
		pCmdUI->SetCheck(FALSE);
}
void CMyglDoc::OnCommandPaint() 
{
	OSVERSIONINFO	vi;
	if(m_bPaint)
	{
		m_bPaint = FALSE;
		// Restore our cursor to its' default
		::SetCursor(m_hCursorPrev);
	}
	else
	{
		ResetCommandFlags();
		m_bPaint = TRUE;
		// Get the windows version because we want to use our color cursor if 
		// in Win98/NT.  (Win95 supports only Monochrome cursors..)
		vi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
		GetVersionEx(&vi);
		// VER_PLATFORM_WIN32_WINDOWS	Win32 on Windows 95.
		if (vi.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
			m_hPaintCursor = ::LoadCursor(AfxGetInstanceHandle(),
										  MAKEINTRESOURCE(IDC_CURSORPAINT_BW));
		else
			m_hPaintCursor = ::LoadCursor(AfxGetInstanceHandle(),
										  MAKEINTRESOURCE(IDC_CURSORPAINT));
	}
}
void CMyglDoc::OnUpdateCommandPaint(CCmdUI* pCmdUI) 
{
	if(m_bPaint)
		pCmdUI->SetCheck(TRUE);
	else
		pCmdUI->SetCheck(FALSE);
}
void CMyglDoc::OnCommandPointsCreate() 
{
	// Get a pointer to our CMDIFrameWnd
	CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
	ASSERT_VALID(pFrame);
	// Post a change message to the Coordinate Dialog Bar.
	pFrame->m_wndCoordDlgBar.PostMessage(WM_CHANGECOORDINATEPAGE, CP_ORIGIN, 0L);
	if(m_bCreatePoints)
	{
		m_bCreatePoints = FALSE;
		m_pWorld->m_bDisplayPoints = FALSE;
	}
	else
	{
		ResetCommandFlags();
		m_bCreatePoints = TRUE;
		m_pWorld->m_bDisplayPoints = TRUE;
		// Clear the PointList
		m_pWorld->m_PointList.DeleteAll();
		m_pWorld->m_pSelectedPnt = NULL;
		// Force a repaint of the window
		UpdateAllViews(NULL);
	}
}
void CMyglDoc::OnCoordinateXAxis() 
{
	int		iIndex;	// Index of the toolbar button or separator whose information is to be retrieved
	UINT	nID;	// Reference to a UINT that is set to the command ID of the button.
	UINT	nStyle;	// Reference to a UINT that is set to the style of the button.
	int		iImage;	// Reference to an integer that is set to the index of the button抯 image within the bitmap.
	// Get the index of our bitmap button
	iIndex = 6;
	// Get a pointer to our CMDIFrameWnd
	CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
	ASSERT_VALID(pFrame);
	// Get the toolbar button info
	pFrame->m_wndCommandBar.GetButtonInfo(iIndex, nID, nStyle, iImage);
	// Toggle the flag
	m_bUnLockXAxis = ! m_bUnLockXAxis;
	if(m_bUnLockXAxis)
		// Restore the bitmap image to its original index
		pFrame->m_wndCommandBar.SetButtonInfo(iIndex, nID, nStyle, iIndex);
	else
		// Offset the bitmap image by (3) three
		pFrame->m_wndCommandBar.SetButtonInfo(iIndex, nID, nStyle, iIndex+3);
}
void CMyglDoc::OnUpdateCoordinateXAxis(CCmdUI* pCmdUI) 
{
	if(m_bUnLockXAxis)
		pCmdUI->SetCheck(FALSE);
	else
		pCmdUI->SetCheck(TRUE);
}
void CMyglDoc::OnCoordinateYAxis() 
{
	int		iIndex;	// Index of the toolbar button or separator whose information is to be retrieved
	UINT	nID;	// Reference to a UINT that is set to the command ID of the button.
	UINT	nStyle;	// Reference to a UINT that is set to the style of the button.
	int		iImage;	// Reference to an integer that is set to the index of the button抯 image within the bitmap.
	// Get the index of our bitmap button
	iIndex = 7;
	// Get a pointer to our CMDIFrameWnd
	CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
	ASSERT_VALID(pFrame);
	// Get the toolbar button info
	pFrame->m_wndCommandBar.GetButtonInfo(iIndex, nID, nStyle, iImage);
	// Toggle the flag
	m_bUnLockYAxis = ! m_bUnLockYAxis;
	if(m_bUnLockYAxis)
		// Restore the bitmap image to its original index
		pFrame->m_wndCommandBar.SetButtonInfo(iIndex, nID, nStyle, iIndex);
	else
		// Offset the bitmap image by (3) three
		pFrame->m_wndCommandBar.SetButtonInfo(iIndex, nID, nStyle, iIndex+3);
}
void CMyglDoc::OnUpdateCoordinateYAxis(CCmdUI* pCmdUI) 
{
	if(m_bUnLockYAxis)
		pCmdUI->SetCheck(FALSE);
	else
		pCmdUI->SetCheck(TRUE);
}
void CMyglDoc::OnCoordinateZAxis() 
{
	int		iIndex;	// Index of the toolbar button or separator whose information is to be retrieved
	UINT	nID;	// Reference to a UINT that is set to the command ID of the button.
	UINT	nStyle;	// Reference to a UINT that is set to the style of the button.
	int		iImage;	// Reference to an integer that is set to the index of the button抯 image within the bitmap.
	// Get the index of our bitmap button
	iIndex = 8;
	// Get a pointer to our CMDIFrameWnd
	CMainFrame* pFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
	ASSERT_VALID(pFrame);
	// Get the toolbar button info
	pFrame->m_wndCommandBar.GetButtonInfo(iIndex, nID, nStyle, iImage);
	// Toggle the flag
	m_bUnLockZAxis = ! m_bUnLockZAxis;
	if(m_bUnLockZAxis)
		// Restore the bitmap image to its original index
		pFrame->m_wndCommandBar.SetButtonInfo(iIndex, nID, nStyle, iIndex);
	else
		// Offset the bitmap image by (3) three
		pFrame->m_wndCommandBar.SetButtonInfo(iIndex, nID, nStyle, iIndex+3);
}
void CMyglDoc::OnUpdateCoordinateZAxis(CCmdUI* pCmdUI) 
{
	if(m_bUnLockZAxis)
		pCmdUI->SetCheck(FALSE);
	else
		pCmdUI->SetCheck(TRUE);
}
void CMyglDoc::OnCoordinateObject() 
{
	if(m_bObjectCoordinates)
		m_bObjectCoordinates = FALSE;
	else
	{
		m_bObjectCoordinates = TRUE;
		m_bWorldCoordinates  = FALSE;
	}
}
void CMyglDoc::OnUpdateCoordinateObject(CCmdUI* pCmdUI) 
{
	if(m_bObjectCoordinates)
		pCmdUI->SetCheck(TRUE);
	else
		pCmdUI->SetCheck(FALSE);
}
void CMyglDoc::OnCoordinateWorld() 
{
	if(m_bWorldCoordinates)
		m_bWorldCoordinates = FALSE;
	else
	{
		m_bWorldCoordinates   = TRUE;
		m_bObjectCoordinates  = FALSE;
	}
}
void CMyglDoc::OnUpdateCoordinateWorld(CCmdUI* pCmdUI) 
{
	if(m_bWorldCoordinates)
		pCmdUI->SetCheck(TRUE);
	else
		pCmdUI->SetCheck(FALSE);
}

						