www.pudn.com > 球和立方体.rar > MultiViewsTestView.cpp

/************************************************************************************* 
*MultisTestView 
*************************************************************************************** 
*File name: 
*MultiViewsTestView.cpp 
*Description: 
*This module control painting and display. 
*Revised History: 
*1.0 2003.10.18 New Creation 
*Designer: 
*Tommy.leung 
*Execution environment:VC++6.0 
*OS:Windows 98 
*References: 
* 
*Copyright(C) 2003 VOYAGER Corporation. All Rights Reserved. 
***************************************************************************************/ 
 
 
// MultiViewsTestView.cpp : implementation of the CMultiViewsTestView class 
// 
 
#include "stdafx.h" 
#include "MultiViewsTest.h" 
#include  
 
 
#include "MultiViewsTestDoc.h" 
#include "MultiViewsTestView.h" 
#include "MyLink.h" 
 
#include "MultiViewsTest.h" 
#include "OpenGlTreeView.h" 
#include "TreeDialog.h" 
#include "MainFrm.h" 
#include "ChildFrm.h" 
 
 
 
#ifdef _DEBUG 
#define new DEBUG_NEW 
#undef THIS_FILE 
static char THIS_FILE[] = __FILE__; 
#endif 
 
///////////////////////////////////////////////////////////////////////////// 
GraphNode* glHead; 
extern "C" GraphNode* GraphAddHead(GraphNode* head , GraphNode* pNewNode); 
////////////////////////////////////// 
// CMultiViewsTestView 
 
IMPLEMENT_DYNCREATE(CMultiViewsTestView, CView) 
 
BEGIN_MESSAGE_MAP(CMultiViewsTestView, CView) 
	//{{AFX_MSG_MAP(CMultiViewsTestView) 
	ON_WM_CREATE() 
	ON_WM_DESTROY() 
	ON_COMMAND(ID_DRAW_CUBE, OnDrawCube) 
	ON_COMMAND(ID_DRAW_SPHERE, OnDrawSphere) 
	ON_COMMAND(ID_MOUSE_CUBE, OnMouseCube) 
	ON_COMMAND(ID_MOUSE_SPHERE, OnMouseSphere) 
	ON_WM_LBUTTONDOWN() 
	ON_WM_LBUTTONUP() 
	ON_WM_MOUSEMOVE() 
	ON_WM_KEYDOWN() 
	ON_COMMAND(ID_FILE_OPEN, OnFileOpen) 
	ON_COMMAND(ID_FILE_SAVE, OnFileSave) 
	ON_WM_SIZE() 
	//}}AFX_MSG_MAP 
	// Standard printing commands 
	ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint) 
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint) 
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview) 
END_MESSAGE_MAP() 
 
///////////////////////////////////////////////////////////////////////////// 
// CMultiViewsTestView construction/destruction 
 
CMultiViewsTestView::CMultiViewsTestView() 
{ 
	// TODO: add construction code here 
	fX=0.0; 
	fY=0.0; 
	fZ=0.0; 
	dRadius=0.5; 
	flag = 0; 
	size = 0.5; 
	glHead = NULL; 
	iSequence = 1; 
	m_drawtype = 0; 
} 
 
CMultiViewsTestView::~CMultiViewsTestView() 
{ 
} 
 
BOOL CMultiViewsTestView::PreCreateWindow(CREATESTRUCT& cs) 
{ 
	// TODO: Modify the Window class or styles here by modifying 
	//  the CREATESTRUCT cs 
 
	return CView::PreCreateWindow(cs); 
} 
 
/////////////////////////////////////////////////////////////////////////////////////// 
// CMultiViewsTestView drawing 
/************************************************************************************* 
*OnDraw 
************************************************************************************** 
*Description: 
*This Function control redraw. 
*Argument: 
*CDC* pDC 
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::OnDraw(CDC* pDC) 
{ 
   	 CMultiViewsTestDoc* pDoc = GetDocument(); 
	 ASSERT_VALID(pDoc); 
	// TODO: add draw code for native data here 
	 OnSize(glType, glcx, glcy); 
     GRAPHDATA* pObject; 
     CUBEDATA* pCubeData; 
     SPHEREDATA* pSphereData; 
	 GraphNode* current; 
 
	 wglMakeCurrent(pDC->m_hDC,m_hrc); 
 
	 Init(); 
	 current =glHead; 
	  
	 while(current) 
	 { 
 
	    pObject =  (GRAPHDATA*)current->pGraphData; 
        switch(pObject->iType) 
		{ 
	    case 1: 
		 		    
		 pCubeData = (CUBEDATA*)current->pGraphData; 
			  
    	 DrawCube(pCubeData); 
		 break; 
 
	    case 2: 
	      
	     pSphereData = (SPHEREDATA*)current->pGraphData; 
 
	     DrawSphere(pSphereData); 
		 break; 
 
	    default: 
		 break; 
		} 
	   	 current = current->next; 
	 } 
	 glFlush(); 
	 wglMakeCurrent(pDC->m_hDC,NULL); 
	 SwapBuffers(pDC->m_hDC);	 
 
} 
 
///////////////////////////////////////////////////////////////////////////// 
// CMultiViewsTestView printing 
/************************************************************************************* 
*OnCreate 
************************************************************************************** 
*Description: 
*This Function control set up windows. 
*Argument: 
*LPCREATESTRUCT lpCreateStruct 
*Global: 
*return: 
*TURE 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
int CMultiViewsTestView::OnCreate(LPCREATESTRUCT lpCreateStruct)  
{ 
	if (CView::OnCreate(lpCreateStruct) == -1) 
		return -1; 
	 
 PIXELFORMATDESCRIPTOR pfd={ 
		sizeof(PIXELFORMATDESCRIPTOR), 
			1, 
			PFD_DRAW_TO_WINDOW| 
			PFD_SUPPORT_OPENGL| 
			PFD_DOUBLEBUFFER, 
			PFD_TYPE_RGBA, 
			24, 
			0,0,0,0,0,0, 
			0, 
			0, 
			0, 
			0,0,0,0, 
			32, 
			0, 
			0, 
			PFD_MAIN_PLANE, 
			0, 
			0,0,0 
	}; 
 
//	OnCreate(pWnd,&pfd); 
 
	m_pdc=new CClientDC(this); //构造CDC对象 
 
	int nPixelFormat=ChoosePixelFormat(m_pdc->m_hDC,&pfd); //选择像素格式 
 
	if (nPixelFormat==0) 
	{ 
		return FALSE; 
	} 
 
	if (!SetPixelFormat(m_pdc->m_hDC,nPixelFormat,&pfd)) 
	{ //设置像素格式 
		int i; 
		AfxMessageBox ("设置像素失败! "); 
        i = GetLastError(); 
		return FALSE; 
 
	} 
 
	m_hrc=wglCreateContext(m_pdc->m_hDC); //创建RC 
	 
 
	if (!m_hrc) 
	{ 
 
		AfxMessageBox ("产生设备描述表失败!"); 
 
		return FALSE; 
 
	} 
 
	return TRUE; 
} 
BOOL CMultiViewsTestView::OnPreparePrinting(CPrintInfo* pInfo) 
{ 
	// default preparation 
	return DoPreparePrinting(pInfo); 
} 
 
void CMultiViewsTestView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/) 
{ 
	// TODO: add extra initialization before printing 
} 
 
void CMultiViewsTestView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/) 
{ 
	// TODO: add cleanup after printing 
} 
 
///////////////////////////////////////////////////////////////////////////// 
// CMultiViewsTestView diagnostics 
 
#ifdef _DEBUG 
void CMultiViewsTestView::AssertValid() const 
{ 
	CView::AssertValid(); 
} 
 
void CMultiViewsTestView::Dump(CDumpContext& dc) const 
{ 
	CView::Dump(dc); 
} 
 
CMultiViewsTestDoc* CMultiViewsTestView::GetDocument() // non-debug version is inline 
{ 
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CMultiViewsTestDoc))); 
	return (CMultiViewsTestDoc*)m_pDocument; 
} 
#endif //_DEBUG 
 
///////////////////////////////////////////////////////////////////////////// 
// CMultiViewsTestView message handlers 
/************************************************************************************* 
*OnDestroy 
************************************************************************************** 
*Description: 
*This Function control destroy windows. 
*Argument: 
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::OnDestroy()  
{ 
	CView::OnDestroy(); 
	 
	// TODO: Add your message handler code here 
	if (m_hrc) 
	{ 
 
		if (m_hrc==::wglGetCurrentContext()) 
 
		::wglMakeCurrent(NULL,NULL); 
 
		::wglDeleteContext(m_hrc); //释放当前RC 
 
		m_hrc=NULL; 
 
	} 
 
	if (m_pdc) 
	{ 
 
	delete m_pdc; //释放DC句柄`` 
 
	m_pdc=NULL; 
 
	} 
	 
} 
/************************************************************************************* 
*OnDrawCube 
************************************************************************************** 
*Description: 
*This Function control botton draw cube. 
*Argument: 
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::OnDrawCube()  
{ 
	// TODO: Add your command handler code here 
	int f; 
	f = 1; 
    dRadius += 0.1; 
	CUBEDATA* strCubeData = new CUBEDATA; 
	strCubeData->dCubeSize = dRadius; 
	strCubeData->strData.iType= 1; 
	strCubeData->strData.fX = 0; 
	strCubeData->strData.fY = 0; 
	strCubeData->strData.fZ = 0; 
 
    strCubeData->strData.iIndex = iSequence++; 
	strCubeData->strData.iSelect = 0; 
 
	GraphNode* strNewNode = new GraphNode; 
    strNewNode->pGraphData = (char *) strCubeData; 
	strNewNode->next = NULL; 
	glHead = GraphAddHead(glHead, strNewNode); 
    size += 0.1; 
	SetFlag(f); 
	Invalidate(FALSE);	 
 
	CMultiViewsTestDoc* pDoc = GetDocument(); 
 
	CMultiViewsTestApp* app=(CMultiViewsTestApp* )AfxGetApp(); 
    CMainFrame*   pframe=(CMainFrame*)app->m_pMainWnd; 
    CChildFrame*  pchild=(CChildFrame*)pframe->MDIGetActive(); 
    CMultiViewsTestDoc* pdoc=(CMultiViewsTestDoc*)pchild->GetActiveDocument(); 
 
    CView* pview; 
    OpenGlTreeView *ppview; 
    POSITION pos=pdoc->GetFirstViewPosition(); 
	  while(pos) 
	{ 
	  pview=pdoc->GetNextView(pos); 
	  if(pview->IsKindOf(RUNTIME_CLASS(OpenGlTreeView))) 
		  break; 
	} 
    ppview=(OpenGlTreeView*)pview; 
	ppview->AddNode(f); 
} 
/************************************************************************************* 
*OnDrawSphere 
************************************************************************************** 
*Description: 
*This Function control botton draw sphere 
*Argument: 
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::OnDrawSphere()  
{ 
	// TODO: Add your command handler code here 
    int f; 
	f = 2; 
	dRadius += 0.1; 
	SPHEREDATA* strSphereData = new SPHEREDATA; 
	strSphereData->dSphereRadius = dRadius; 
	strSphereData->strData.iType= 2; 
	strSphereData->strData.fX = 0; 
	strSphereData->strData.fY = 0; 
	strSphereData->strData.fZ = 0; 
 
	strSphereData->strData.iIndex = iSequence++; 
	strSphereData->strData.iSelect = 0; 
 
	GraphNode* strNewNode = new GraphNode; 
	strNewNode->pGraphData = (char *) strSphereData; 
	strNewNode->next = NULL; 
	glHead = GraphAddHead(glHead, strNewNode); 
	size += 0.1;    
    SetFlag(f);     
    DrawSphere(strSphereData); 
	Invalidate(FALSE);	 
	CMultiViewsTestDoc* pDoc = GetDocument(); 
 
	CMultiViewsTestApp* app=(CMultiViewsTestApp* )AfxGetApp(); 
    CMainFrame*   pframe=(CMainFrame*)app->m_pMainWnd; 
    CChildFrame*  pchild=(CChildFrame*)pframe->MDIGetActive(); 
    CMultiViewsTestDoc* pdoc=(CMultiViewsTestDoc*)pchild->GetActiveDocument(); 
 
    CView* pview; 
    OpenGlTreeView *ppview; 
    POSITION pos=pdoc->GetFirstViewPosition(); 
	  while(pos) 
	{ 
	  pview=pdoc->GetNextView(pos); 
	  if(pview->IsKindOf(RUNTIME_CLASS(OpenGlTreeView))) 
		  break; 
	} 
    ppview=(OpenGlTreeView*)pview; 
	ppview->AddNode(f); 
} 
/************************************************************************************* 
*MakeCurrent 
************************************************************************************** 
*Description: 
*This Function control receive RC. 
*Argument: 
*Global: 
*return: 
*0 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::MakeCurrent() 
 
{ 
	ASSERT(m_hrc); 
	if (m_hrc!=wglGetCurrentContext()) 
	{ 
		if (!wglMakeCurrent(m_pdc->m_hDC,m_hrc)) 
		{ //使成为当前调用线程的RC 
			AfxMessageBox("使成为当前RC失败！"); 
			return ; 
		} 
	} 
} 
/************************************************************************************* 
*Init 
************************************************************************************** 
*Description: 
*This Function initialization windows. 
*Argument: 
*void 
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::Init(void) 
 
{ 
	glClearColor(0.0,0.0,0.0,1.0);		 
	glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);	 
	glShadeModel(GL_SMOOTH); 
	 
	// 设置混色函数取得半透明效果 
	glBlendFunc(GL_SRC_ALPHA,GL_ONE); 	 
	glEnable(GL_BLEND);  
	 
	//平滑线条 
    glEnable (GL_LINE_SMOOTH); 
    glEnable (GL_BLEND); 
 
// 真正精细的透视修正 
    glHint (GL_POLYGON_SMOOTH_HINT|GL_LINE_SMOOTH_HINT, GL_NICEST); 
	 
	//充许深度测试 
	glEnable(GL_DEPTH_TEST); 
	glDepthFunc(GL_LEQUAL); 
 
	glMatrixMode(GL_PROJECTION); 
} 
/************************************************************************************* 
*SteFlag 
************************************************************************************** 
*Description: 
*This Function receive flag. 
*Argument: 
*int f  
*int flag  
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::SetFlag(int f) 
{ 
	flag = f; 
} 
/************************************************************************************* 
*OnMouseCube 
************************************************************************************** 
*Description: 
*This Function control mouse draw cube. 
*Argument: 
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::OnMouseCube()  
{ 
	// TODO: Add your command handler code here		 
	CMDIFrameWnd *pFrame =  
             (CMDIFrameWnd*)AfxGetApp()->m_pMainWnd; 
	CToolBar *pToolBar = (CToolBar *)(pFrame 
		->GetControlBar(AFX_IDW_TOOLBAR)); 
	CToolBarCtrl *pToolBarCtrl = &(pToolBar->GetToolBarCtrl()); 
 
	if( (m_drawtype ==0) ) 
	{ 
		m_drawtype = 1; 
		pToolBarCtrl->SetState(ID_MOUSE_CUBE,true); 
	} 
	else 
	{  
		if(m_drawtype ==1) 
		{ 
			pToolBarCtrl->SetState(ID_MOUSE_CUBE,false); 
			m_drawtype= 0; 
		} 
		else 
		{ 
			m_drawtype = 1; 
			pToolBarCtrl->SetState(ID_MOUSE_CUBE,true); 
			pToolBarCtrl->SetState(ID_MOUSE_SPHERE,false); 
		} 
	} 
 
} 
/************************************************************************************* 
*OnMouseSphere 
************************************************************************************** 
*Description: 
*This Function control mouse draw sphere. 
*Argument: 
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::OnMouseSphere()  
{ 
	// TODO: Add your command handler code here 
 
	CMDIFrameWnd *pFrame = (CMDIFrameWnd*)AfxGetApp()->m_pMainWnd; 
	CToolBar *pToolBar = (CToolBar *)(pFrame->GetControlBar(AFX_IDW_TOOLBAR)); 
	CToolBarCtrl *pToolBarCtrl = &(pToolBar->GetToolBarCtrl()); 
	if( (m_drawtype ==0) ) 
	{ 
		m_drawtype = 2; 
		pToolBarCtrl->SetState(ID_MOUSE_SPHERE,true); 
	} 
	else 
	{  
		if(m_drawtype ==2) 
		{ 
			pToolBarCtrl->SetState(ID_MOUSE_SPHERE,false); 
			m_drawtype = 0; 
		} 
		else 
		{ 
			m_drawtype = 2; 
			pToolBarCtrl->SetState(ID_MOUSE_SPHERE,true); 
			pToolBarCtrl->SetState(ID_MOUSE_CUBE,false); 
		} 
	} 
	 
} 
/************************************************************************************* 
*OnLButtonDown 
************************************************************************************** 
*Description: 
*This Function control mouse left button down. 
*Argument: 
*UINT nFlags  
*CPoint point  
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::OnLButtonDown(UINT nFlags, CPoint point)  
{ 
	// TODO: Add your message handler code here and/or call default 
	SetCapture(); 
	CClientDC ClientDC (this); 
    m_glPoint.x = point.x; 
	m_glPoint.y = point.y; 
	CView::OnLButtonDown(nFlags, point); 
} 
/************************************************************************************* 
*OnLButtonUp 
************************************************************************************** 
*Description: 
*This Function control mouse right button up. 
*Argument: 
*UINT nFlags  
*CPoint point  
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::OnLButtonUp(UINT nFlags, CPoint point)  
{ 
	// TODO: Add your message handler code here and/or call default 
	ReleaseCapture(); 
	CClientDC ClientDC (this); 
 
	double dDistance; 
	float  fX, fY, fEX, fEY; 
	fX = (float)(10.6/glcx * m_glPoint.x) - 5.3; 
	fY = (float) 2.8 - 5.4/glcy * m_glPoint.y; 
	fEX = (float)(10.6/glcx * point.x) - 5.3; 
	fEY = (float) 2.8 - 5.4/glcy * point.y; 
	dDistance = (fX - fEX) * (fX - fEX); 
	dDistance += (fY - fEY) * (fY - fEY); 
	dDistance = sqrt(dDistance); 
	 
 
	GRAPHDATA* pObject; 
    CUBEDATA* pCubeData; 
    SPHEREDATA* pSphereData; 
	GraphNode* pNewNode; 
 
	CMultiViewsTestApp* app=(CMultiViewsTestApp* )AfxGetApp(); 
    CMainFrame*   pframe=(CMainFrame*)app->m_pMainWnd; 
    CChildFrame*  pchild=(CChildFrame*)pframe->MDIGetActive(); 
    CMultiViewsTestDoc* pdoc=(CMultiViewsTestDoc*)pchild->GetActiveDocument(); 
 
    CView* pview; 
    OpenGlTreeView *ppview; 
    POSITION pos=pdoc->GetFirstViewPosition(); 
	  while(pos) 
	{ 
	  pview=pdoc->GetNextView(pos); 
	  if(pview->IsKindOf(RUNTIME_CLASS(OpenGlTreeView))) 
		  break; 
	} 
    ppview=(OpenGlTreeView*)pview; 
	switch(m_drawtype) 
	{ 
	case 1: 
		pCubeData = new CUBEDATA; 
		pCubeData->strData.fX = fX; 
		pCubeData->strData.fY = fY; 
		pCubeData->strData.fZ = 0; 
		pCubeData->strData.iType = 1; 
		pCubeData->strData.iIndex = iSequence++; 
		pCubeData->strData.iSelect = 0; 
		pCubeData->dCubeSize = dDistance; 
		pNewNode = new GraphNode; 
		pNewNode->pGraphData = (char *) pCubeData; 
		pNewNode->next = NULL; 
		glHead = GraphAddHead(glHead, pNewNode); 
		break; 
 
    case 2: 
		pSphereData = new SPHEREDATA; 
		pSphereData->strData.fX = fX; 
		pSphereData->strData.fY = fY; 
		pSphereData->strData.fZ = 0; 
		pSphereData->strData.iType = 2; 
		pSphereData->strData.iIndex = iSequence++; 
		pSphereData->strData.iSelect = 0; 
		pSphereData->dSphereRadius = dDistance; 
		pNewNode = new GraphNode; 
		pNewNode->pGraphData = (char *) pSphereData; 
		pNewNode->next = NULL; 
		glHead = GraphAddHead(glHead, pNewNode); 
		break; 
 
	default: 
		break; 
	} 
	if(m_drawtype>0) 
        ppview->AddNode(m_drawtype); 
	    CView::OnLButtonUp(nFlags, point); 
	    Invalidate(FALSE);	 
} 
 
void CMultiViewsTestView::OnMouseMove(UINT nFlags, CPoint point)  
{ 
	// TODO: Add your message handler code here and/or call default 
 
	CView::OnMouseMove(nFlags, point); 
} 
/************************************************************************************* 
*OnKeyDown 
************************************************************************************** 
*Description: 
*This Function control keyborad. 
*Argument: 
*UINT nChar  
*UINT nRepCnt  
*UINT nFlags  
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)  
{ 
	// TODO: Add your message handler code here and/or call default 
		switch(nChar) 
		{ 
		case VK_LEFT: 
			MoveLeft(glHead); 
			break; 
		case VK_RIGHT: 
			MoveRight(glHead); 
			break; 
		case VK_UP: 
		    MoveUp(glHead); 
			break; 
		case VK_DOWN: 
			MoveDown(glHead); 
			break;	 
		case VK_F2: 
		    ChangeBig (glHead); 
		    break; 
        case VK_F1: 
	        ChangeSmall (glHead); 
		    break; 
		case VK_F3: 
		    MoveInside(glHead); 
		    break; 
        case VK_F4: 
	        MoveOut(glHead); 
		    break; 
        default: 
			break; 
		} 
	CView::OnKeyDown(nChar, nRepCnt, nFlags); 
	Invalidate(FALSE);	 
} 
/************************************************************************************* 
*OnFileOpen 
************************************************************************************** 
*Description: 
*This Function control file open. 
*Argument: 
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::OnFileOpen()  
{ 
	// TODO: Add your command handler code here 
	CFileDialog mFileDlg(true, NULL, NULL, 
		OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT | OFN_ALLOWMULTISELECT,  
		"All Files (*.*)|*.*| |", AfxGetMainWnd()); 
 
	if ( (mFileDlg.DoModal() ) == IDOK) 
	{	 
		 SPHEREDATA* strSphereData; 
		 GRAPHDATA pObject; 
 
		 CUBEDATA*  strCubeData; 
		 CString csFilePath; 
		 long int  currentsize; 
		 long int filesize;  
		 GLFILEHEAD strGLFileHead; 
	     FILE *fp; 
		  
		 csFilePath = mFileDlg.GetPathName(); 
         fp=fopen(csFilePath, "rb"); 
 
		 fread(&strGLFileHead, sizeof(GLFILEHEAD), 1, fp); 
		 currentsize = sizeof(GLFILEHEAD); 
		 filesize = strGLFileHead.wLength; 
		 GraphNode* strNewNode; 
 
		while(currentsize < filesize) 
		{ 
            fseek(fp ,currentsize, SEEK_SET);  
			fread( &pObject, sizeof(GRAPHDATA), 1, fp); 
			switch(pObject.iType) 
			{ 
			case 1: 
				fseek(fp ,currentsize, SEEK_SET); 
				strCubeData = new CUBEDATA; 
				fread(strCubeData,sizeof(CUBEDATA), 1, fp); 
                 
				strNewNode = new GraphNode; 
				strNewNode->pGraphData = (char *) strCubeData; 
				strNewNode->next = NULL; 
				glHead = GraphAddHead(glHead, strNewNode); 
 
				currentsize += sizeof(CUBEDATA); 
				break; 
	 
			case 2: 
			 
		    	fseek(fp ,currentsize, SEEK_SET); 
				strSphereData = new SPHEREDATA; 
				fread(strSphereData,sizeof(SPHEREDATA), 1, fp); 
 
                strNewNode = new GraphNode; 
				strNewNode->pGraphData = (char *) strSphereData; 
				strNewNode->next = NULL; 
				glHead = GraphAddHead(glHead, strNewNode); 
 
				currentsize += sizeof(SPHEREDATA); 
			     
 
				break; 
 
			default: 
				break; 
			} 
 
		} 
		fclose(fp); 
	} 
		Invalidate(FALSE);	 
} 
/************************************************************************************* 
*OnFileSave 
************************************************************************************** 
*Description: 
*This Function control file save. 
*Argument: 
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::OnFileSave()  
{ 
	// TODO: Add your command handler code here 
	CFileDialog mFileDlg(false, NULL, NULL, 
	OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT | OFN_ALLOWMULTISELECT,  
	"All Files (*.*)|*.*| |", AfxGetMainWnd()); 
	if ( (mFileDlg.DoModal()) == IDOK ) 
	{ 
		 
		 GRAPHDATA* pObject; 
		 CString csFilePath; 
		 GraphNode* current; 
		 long int filesize; 
	   	 FILE *fp;  
 
		csFilePath = mFileDlg.GetPathName(); 
		fp=fopen(csFilePath, "wb");  
		GLFILEHEAD* pGLFileHead = new GLFILEHEAD; 
        
		fseek (fp, sizeof(GLFILEHEAD), SEEK_SET); 
		filesize = sizeof(GLFILEHEAD); 
		current = glHead; 
		while(current) 
		{ 
 
			pObject =  (GRAPHDATA*)current->pGraphData; 
			switch(pObject->iType) 
			{ 
			case 1: 
                fseek (fp, filesize, SEEK_SET); 
				fwrite(current->pGraphData, 
					sizeof(CUBEDATA), 1, fp); 
				filesize += sizeof(CUBEDATA); 
				break; 
	 
			case 2: 
				fseek (fp, filesize, SEEK_SET); 
				fwrite(current->pGraphData, 
					sizeof(SPHEREDATA), 1, fp); 
				filesize += sizeof(SPHEREDATA); 
				break; 
 
			default: 
				break; 
			} 
	   	 current = current->next; 
		} 
		pGLFileHead->wLength = filesize; 
      	fseek (fp, 0, SEEK_SET); 
		fwrite(pGLFileHead,sizeof(GLFILEHEAD), 1, fp); 
	    fclose(fp);	 
	} 
} 
/************************************************************************************* 
*DrawSphere 
************************************************************************************** 
*Description: 
*This Function control draw sphere. 
*Argument: 
*SPHEREDATA* strSphereData  
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::DrawSphere(SPHEREDATA* strSphereData) 
{ 
         
	if(strSphereData->strData.iSelect == 1) 
		glColor3f(1., 0., 1.); 
	else 
		glColor3f(0., 1, 0.); 
		glPushMatrix(); 
		glTranslatef(strSphereData->strData.fX, 
		strSphereData->strData.fY, strSphereData->strData.fZ); 
	    GLUquadricObj* q = gluNewQuadric(); 
    	gluQuadricDrawStyle(q, GLU_LINE); 
    	gluSphere(q, strSphereData->dSphereRadius, 16, 16); 
	    gluDeleteQuadric(q); 
		glPopMatrix(); 
} 
/************************************************************************************* 
*DrawCube 
************************************************************************************** 
*Description: 
*This Function control draw cube. 
*Argument: 
*CUBEDATA* strCubeData 
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::DrawCube(CUBEDATA* strCubeData)	 
{ 
	if(strCubeData->strData.iSelect == 1) 
  		glColor3f(1., 0., 1.); 
	else 
		glColor3f(0., 1., 0.); 
		glPushMatrix(); 
		glTranslatef(strCubeData->strData.fX, 
			         strCubeData->strData.fY,  
					 strCubeData->strData.fZ); 
	    MyDrawWireCube (strCubeData->dCubeSize); 
		glPopMatrix(); 
} 
/************************************************************************************* 
*OnSize 
************************************************************************************** 
*Description: 
*This Function control windows size. 
*Argument: 
*UINT nType  
*int vcx  
*int vcy  
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::OnSize(UINT nType, int vcx, int vcy)  
{ 
	CView::OnSize(nType, vcx, vcy); 
	 
	// TODO: Add your message handler code here 
	glcx = vcx; 
	glcy = vcy; 
	GLsizei w=vcx; 
    GLsizei h=vcy; 
   // int f; 
	//avoid divided by zero 
	if(!h)return; 
	//make it the calling thread's current rendering context 
	wglMakeCurrent(m_pdc->m_hDC,m_hrc); 
	//define the viewport 
	glViewport(0,0,w,h); 
	//prepare for and then 
	glMatrixMode(GL_PROJECTION); 
	//define the projecton transformation 
	glLoadIdentity(); 
	gluPerspective(60.,(GLfloat)w/(GLfloat)h,1.,20.); 
	//back to modeview matrix 
	glMatrixMode(GL_MODELVIEW); 
	glLoadIdentity(); 
	glTranslatef(0.,0.,-5.); 
 
	 
} 
/************************************************************************************* 
*MoveDown 
************************************************************************************** 
*Description: 
*This Function control graph move down. 
*Argument: 
*GraphNode* glCurrent 
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::MoveDown(GraphNode* glCurrent) 
{ 
   GRAPHDATA* pObject; 
   CUBEDATA* pCubeData; 
   SPHEREDATA* pSphereData; 
   pObject =  (GRAPHDATA*) glCurrent->pGraphData; 
   switch(pObject->iType) 
   { 
   case 1: 
	    
	   pCubeData = (CUBEDATA*) glCurrent->pGraphData; 
	   pCubeData->strData.fY -= 0.1; 
	   break; 
 
   case 2: 
	   pSphereData = (SPHEREDATA*) glCurrent->pGraphData; 
	   pSphereData->strData.fY -= 0.1; 
	   break; 
 
   default: 
	   break; 
   } 
} 
/************************************************************************************* 
*MoveUp 
************************************************************************************** 
*Description: 
*This Function control graph move up. 
*Argument: 
*GraphNode* glCurrent 
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::MoveUp(GraphNode* glCurrent) 
{ 
   GRAPHDATA* pObject; 
   CUBEDATA* pCubeData; 
   SPHEREDATA* pSphereData; 
   pObject =  (GRAPHDATA*) glCurrent->pGraphData; 
   switch(pObject->iType) 
   { 
   case 1: 
	    
	   pCubeData = (CUBEDATA*) glCurrent->pGraphData; 
	   pCubeData->strData.fY += 0.1; 
	   break; 
 
   case 2: 
	   pSphereData = (SPHEREDATA*) glCurrent->pGraphData; 
	   pSphereData->strData.fY += 0.1; 
	   break; 
 
   default: 
	   break; 
   } 
} 
//////////////////////////////////////////////////////// 
/************************************************************************************* 
*MoveInside 
************************************************************************************** 
*Description: 
*This Function control graph move inside. 
*Argument: 
*SPHEREDATA* strSphereData  
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::MoveInside(GraphNode* glCurrent) 
{   
   GRAPHDATA* pObject; 
   CUBEDATA* pCubeData; 
   SPHEREDATA* pSphereData; 
   pObject = (GRAPHDATA*) glCurrent->pGraphData; 
   switch(pObject->iType) 
   { 
   case 1: 
	    
	   pCubeData = (CUBEDATA*) glCurrent->pGraphData; 
	   pCubeData->strData.fZ += 0.1; 
	   break; 
 
   case 2: 
	   pSphereData = (SPHEREDATA*) glCurrent->pGraphData; 
	   pSphereData->strData.fZ += 0.1; 
	   break; 
 
   default: 
	   break; 
   } 
} 
/////////////////////////////////////////////////////// 
/************************************************************************************* 
*MoveOut 
************************************************************************************** 
*Description: 
*This Function control graph move out. 
*Argument: 
*graphNode* glCurrent 
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::MoveOut(GraphNode* glCurrent) 
{ 
   GRAPHDATA* pObject; 
   CUBEDATA* pCubeData; 
   SPHEREDATA* pSphereData; 
   pObject =  (GRAPHDATA*) glCurrent->pGraphData; 
   switch(pObject->iType) 
   { 
   case 1: 
	    
	   pCubeData = (CUBEDATA*) glCurrent->pGraphData; 
	   pCubeData->strData.fZ -= 0.1; 
	   break; 
 
   case 2: 
	   pSphereData = (SPHEREDATA*) glCurrent->pGraphData; 
	   pSphereData->strData.fZ -= 0.1; 
	   break; 
 
   default: 
	   break; 
   } 
} 
//////////////////////////////////////////////// 
/************************************************************************************* 
*ChangeBig 
************************************************************************************** 
*Description: 
*This Function control graph change big. 
*Argument: 
*GraphNode* glCurrent  
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::ChangeBig(GraphNode* glCurrent) 
{ 
   GRAPHDATA* pObject; 
   CUBEDATA* pCubeData; 
   SPHEREDATA* pSphereData; 
   pObject =  (GRAPHDATA*) glCurrent->pGraphData; 
   switch(pObject->iType) 
   { 
   case 1: 
	    
	   pCubeData = (CUBEDATA*) glCurrent->pGraphData; 
	   pCubeData->dCubeSize += 0.1; 
	   break; 
 
   case 2: 
	   pSphereData = (SPHEREDATA*) glCurrent->pGraphData; 
	   pSphereData->dSphereRadius += 0.1; 
	   break; 
 
   default: 
	   break; 
   } 
	 
} 
///////////////////////////////////////////////////////////// 
/************************************************************************************* 
*ChangeSmall 
************************************************************************************** 
*Description: 
*This Function control graph change small. 
*Argument: 
*GraphNode* glCurrent  
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::ChangeSmall(GraphNode* glCurrent) 
{ 
   GRAPHDATA* pObject; 
   CUBEDATA* pCubeData; 
   SPHEREDATA* pSphereData; 
 
   pObject =  (GRAPHDATA*) glCurrent->pGraphData; 
   switch(pObject->iType) 
   { 
   case 1: 
	    
	   pCubeData = (CUBEDATA*) glCurrent->pGraphData; 
	   pCubeData->dCubeSize -= 0.1; 
	   break; 
 
   case 2: 
	   pSphereData = (SPHEREDATA*) glCurrent->pGraphData; 
	   pSphereData->dSphereRadius -= 0.1; 
	   break; 
 
   default: 
	   break; 
   } 
} 
/************************************************************************************* 
*MoveLeft 
************************************************************************************** 
*Description: 
*This Function control graph move left. 
*Argument: 
*GraphNode* glCurrent  
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::MoveLeft (GraphNode* glCurrent) 
{ 
   GRAPHDATA* pObject; 
   CUBEDATA* pCubeData; 
   SPHEREDATA* pSphereData; 
   pObject =  (GRAPHDATA*) glCurrent->pGraphData; 
   switch(pObject->iType) 
   { 
   case 1: 
	    
	   pCubeData = (CUBEDATA*) glCurrent->pGraphData; 
	   pCubeData->strData.fX -= 0.1; 
	   break; 
 
   case 2: 
	   pSphereData = (SPHEREDATA*) glCurrent->pGraphData; 
	   pSphereData->strData.fX -= 0.1; 
	   break; 
 
   default: 
	   break; 
   } 
} 
 
//////////////////////////////////////////////// 
/************************************************************************************* 
*MoveRight 
************************************************************************************** 
*Description: 
*This Function control graph move right. 
*Argument: 
*GraphNode* glCurrent  
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::MoveRight (GraphNode* glCurrent) 
{ 
   GRAPHDATA* pObject; 
   CUBEDATA* pCubeData; 
   SPHEREDATA* pSphereData; 
   pObject =  (GRAPHDATA*) glCurrent->pGraphData; 
   switch(pObject->iType) 
   { 
   case 1: 
	    
	   pCubeData = (CUBEDATA*) glCurrent->pGraphData; 
	   pCubeData->strData.fX += 0.1; 
	   break; 
 
   case 2: 
	   pSphereData = (SPHEREDATA*) glCurrent->pGraphData; 
	   pSphereData->strData.fX += 0.1; 
	   break; 
 
   default: 
	   break; 
   } 
} 
 
/************************************************************************************* 
*Select 
************************************************************************************** 
*Description: 
*This Function control graph index number choose. 
*Argument: 
*int i 
*Global: 
*return: 
*Designer: 
*Tommy.Leung 
*Revised History: 
*1.0 2003.10.18 New Creation 
**************************************************************************************/ 
void CMultiViewsTestView::Select(int i) 
{ 
	GraphNode* p; 
	p = glHead; 
	GRAPHDATA* pObject; 
 
 
	while (p!=NULL) 
	{ 
		pObject =  (GRAPHDATA*) p->pGraphData; 
		if(pObject->iIndex == iCurrent) 
		{ 
			pObject->iSelect = 0; 
            break; 
		} 
        p=p->next; 
	} 
	    p = glHead; 
   
	while (p!=NULL) 
	{ 
		pObject =  (GRAPHDATA*) p->pGraphData; 
		if(pObject->iIndex == i) 
		{ 
			pObject->iSelect = 1; 
            break; 
		} 
        p=p->next; 
	} 
    iCurrent = i; 
    Invalidate(FALSE);	 
} 
void CMultiViewsTestView::MyDrawWireCube(const float fWidth) 
{ 
	glBegin(GL_LINE_LOOP); 
		glVertex3f(fWidth/2,fWidth/2,fWidth/2); 
		glVertex3f(-fWidth/2,fWidth/2,fWidth/2); 
		glVertex3f(-fWidth/2,-fWidth/2,fWidth/2); 
		glVertex3f(fWidth/2,-fWidth/2,fWidth/2); 
	glEnd(); 
 
	glBegin(GL_LINE_LOOP); 
		glVertex3f(fWidth/2,fWidth/2,-fWidth/2); 
		glVertex3f(-fWidth/2,fWidth/2,-fWidth/2); 
		glVertex3f(-fWidth/2,-fWidth/2,-fWidth/2); 
		glVertex3f(fWidth/2,-fWidth/2,-fWidth/2); 
	glEnd(); 
 
	glBegin(GL_LINES); 
		glVertex3f(fWidth/2,fWidth/2,-fWidth/2); 
		glVertex3f(fWidth/2,fWidth/2,fWidth/2); 
 
		glVertex3f(-fWidth/2,fWidth/2,-fWidth/2); 
		glVertex3f(-fWidth/2,fWidth/2,fWidth/2); 
 
		glVertex3f(-fWidth/2,-fWidth/2,-fWidth/2); 
		glVertex3f(-fWidth/2,-fWidth/2,fWidth/2); 
 
		glVertex3f(fWidth/2,-fWidth/2,-fWidth/2); 
		glVertex3f(fWidth/2,-fWidth/2,fWidth/2); 
	glEnd(); 
}