www.pudn.com > 简单的绘工具.rar > COMMAND.CPP

#include "stdafx.h" 
#include "math.h" 
 
#include "MyPaint.h" 
#include "MyPaintDoc.h" 
#include "MyPaintView.h" 
#include "MainFrm.h" 
#include "Entity.h" 
#include "Command.h" 
 
#ifdef _DEBUG 
#define new DEBUG_NEW 
#undef THIS_FILE 
static char THIS_FILE[] = __FILE__; 
#endif 
 
extern void Prompt(char*); 
 
CCreateLine::CCreateLine() : m_begin(0,0), m_end(0,0) 
{ 
	m_nStep = 0; 
} 
 
CCreateLine::~CCreateLine() 
{ 
} 
 
int CCreateLine::GetType() 
{ 
	return ctCreateLine;  
} 
 
int	CCreateLine::OnLButtonDown(UINT nFlags, const Position& pos)  
{ 
	m_nStep ++;		// 每次单击鼠标左键时操作步加 1  
	switch(m_nStep) // 根据操作步执行相应的操作 
	{ 
		case 1:  
		{ 
			m_begin = m_end = pos; 
			::Prompt("请再点击鼠标，选则线段末尾坐标"); 
			break; 
		} 
		case 2: 
		{ 
			CDC*	pDC = g_pView->GetDC(); // 得到设备环境指针  
 
			// 擦除在拖动状态时显示的最后一条线 
			CLine*	pTempLine = new CLine(m_begin,m_end);  
			pTempLine->Draw(pDC, dmDrag); 
			delete pTempLine; 
 
			// 如果在按鼠标左键的过程中同时按下了Shift键， 
			// 那么根据鼠标单击位置绘制水平线或竖直线 
			if( nFlags & MK_SHIFT ){  
				double dx = pos.x - m_begin.x; 
				double dy = pos.y - m_begin.y; 
 
				if(fabs(dx) <= fabs(dy))			// 如果鼠标单击位置在X方向靠近起点 
					m_end.Set(m_begin.x, pos.y);	// 那么终点的x坐标与起点的相同 
				else 
					m_end.Set(pos.x,m_begin.y); 
			} 
			else { 
				m_end = pos; // 如果未按下Shift键, 则终点为鼠标单击位置 
			} 
						 
 
			CLine*	pNewLine = new CLine(m_begin,m_end);// 根据起点和终点创建直线 
			pNewLine->Draw(pDC,dmNormal);				// 绘制直线 
			g_pDoc->m_EntityList.AddTail(pNewLine);		// 将直线指针添加到图元链表 
			g_pDoc->SetModifiedFlag(TRUE); 
			 
			g_pView->ReleaseDC(pDC); // 释放设备环境指针 
			m_nStep = 0; 
 
			break; 
		} 
		 
	} 
	return 0; 
} 
 
int	CCreateLine::OnMouseMove(UINT nFlags, const Position& pos) 
{ 
	static	int nPreRefresh = g_nRefresh;  
	BOOL	bRefresh = FALSE;  
	int		nCurRefresh = g_nRefresh;  
 
 
	if(nCurRefresh != nPreRefresh){  
		bRefresh = TRUE; 
		nPreRefresh = nCurRefresh;  
	} 
 
	switch(m_nStep) 
	{ 
		case 0: 
			::Prompt("请输入直线的起点："); 
 
			break; 
		case 1: 
		{ 
 
			Position prePos, curPos; 
			prePos = m_end;		// 获得鼠标所在的前一个位置 
			 
			// 如果在按鼠标左键的过程中同时按下了Shift键， 
			// 那么根据鼠标单击位置绘制水平线或竖直线 
			if( nFlags & MK_SHIFT ){ 
				double dx = pos.x - m_begin.x; 
				double dy = pos.y - m_begin.y; 
				if(fabs(dx)>=fabs(dy)) 
					curPos.Set(pos.x,m_begin.y); 
				else 
					curPos.Set(m_begin.x, pos.y); 
			} 
			else 
				curPos = pos; 
 
			CDC*	pDC = g_pView->GetDC(); // 得到设备环境指针 
			 
			// 创建临时对象擦除上一条橡皮线 
			CLine*	pTempLine1 = new CLine(m_begin, prePos); 
			if(!bRefresh)   
				pTempLine1->Draw(pDC, dmDrag); 
			delete pTempLine1; 
 
			// 创建临时对象，根据当前位置绘制一条橡皮线 
			CLine*	pTempLine2 = new CLine(m_begin, curPos);	 
			pTempLine2->Draw(pDC, dmDrag); 
			delete pTempLine2; 
  
			g_pView->ReleaseDC(pDC); // 释放设备环境指针			 
 
			m_end = curPos; // 将当前位置设置为直线终点，以备下一次鼠标移动时用 
			break; 
		} 
	} 
	return 0; 
} 
 
// 单击鼠标右键取消当前的操作 
int	CCreateLine::OnRButtonDown(UINT nFlags, const Position& pos)  
{ 
	// 如果当前的操作步为 1 ，那么要在结束本次操作前擦除上次鼠标移动时绘制的橡皮线 
	if(m_nStep == 1){  
		CDC*	pDC = g_pView->GetDC();	// 得到设备环境指针 
		Position	prePos = m_end;		// 获得鼠标所在的前一个位置 
		CLine*	pTempLine = new CLine(m_begin, prePos);  
		pTempLine->Draw(pDC, dmDrag);	// 擦除上一次绘制的橡皮线 
		delete pTempLine; 
		g_pView->ReleaseDC(pDC);		// 释放设备环境指针 
	} 
	::Prompt("取消操作"); 
	m_nStep = 0;	// 将操作步重置为 0  
 
	return 0; 
} 
 
// 调用Cancel 函数取消本次操作 
int CCreateLine::Cancel() 
{ 
	// 如果当前的操作步为 1 ，那么要在结束本次操作前擦除上次鼠标移动时绘制的橡皮线 
	if(m_nStep == 1){  
		CDC*	 pDC = g_pView->GetDC(); // 得到设备环境指针 
		Position prePos = m_end; // 获得鼠标所在的前一个位置 
 
		CLine*	 pTempLine = new CLine(m_begin, prePos);  
		pTempLine->Draw(pDC, dmDrag); // 擦除上一次绘制的橡皮线 
		delete pTempLine; 
 
		g_pView->ReleaseDC(pDC); // 释放设备环境指针 
	} 
	m_nStep = 0; // 将操作步重置为 0  
	::Prompt("就绪"); // 等待提示新类型的命令操作 
	return 0 ; 
} 
 
/*----------------------------------------------------------------------------------------**/ 
 
CCreateRect::CCreateRect() 
	: m_LeftTop(0,0), m_RightBottom(0,0) 
{ 
	m_nStep = 0; // 初始化操作步为 0 
} 
 
CCreateRect::~CCreateRect() 
{ 
} 
 
int CCreateRect::GetType() 
{ 
	return ctCreateRectangle;  
} 
 
int	CCreateRect::OnLButtonDown(UINT nFlags, const Position& pos)  
{ 
	m_nStep ++;		// 每次单击鼠标左键时操作步加 1  
	switch(m_nStep) // 根据操作步执行相应的操作 
	{ 
		case 1:  
		{ 
			m_LeftTop = m_RightBottom = pos; 
			::Prompt("请输入矩形的右下角点：") ; 
			break; 
		} 
		case 2: 
		{ 
			CDC*	pDC = g_pView->GetDC(); // 得到设备环境指针  
 
			// 擦除在拖动状态时显示的橡皮线 
			CRectangle*	pTempRect = new CRectangle(m_LeftTop, m_RightBottom);  
			pTempRect->Draw(pDC, dmDrag); 
			delete pTempRect; 
 
			m_RightBottom = pos;  
						 
			CRectangle*	pRect = new CRectangle(m_LeftTop, m_RightBottom); // 根据两点创建矩形 
			pRect->Draw(pDC, dmNormal); 
			g_pDoc->m_EntityList.AddTail(pRect); // 将指针添加到图元链表 
			g_pDoc->SetModifiedFlag(TRUE);// set modified flag ; 
			 
			g_pView->ReleaseDC(pDC); // 释放设备环境指针 
			 
			m_nStep = 0;  // 将操作步重置为 0 
			::Prompt("请输入矩形的左上角点：") ; 
			break; 
		} 
		 
	} 
	return 0; 
} 
 
int	CCreateRect::OnMouseMove(UINT nFlags, const Position& pos) 
{ 
	static	int nPreRefresh = g_nRefresh;  
	BOOL	bRefresh = FALSE;  
	int		nCurRefresh = g_nRefresh;  
 
	if(nCurRefresh != nPreRefresh){  
		bRefresh = TRUE; 
		nPreRefresh = nCurRefresh;  
	} 
 
	switch(m_nStep) 
	{ 
		case 0: 
			::Prompt("请输入矩形的左上角点：") ; 
			break; 
		case 1: 
		{ 
			Position	prePos, curPos; 
			prePos = m_RightBottom;			// 获得鼠标所在的前一个位置 
			 
			curPos = pos; 
 
			CDC*	pDC = g_pView->GetDC(); // 得到设备环境指针 
			 
			// 创建临时对象擦除上一条橡皮线 
			CRectangle*	pTempRect = new CRectangle(m_LeftTop, prePos); 
			if(!bRefresh)  
				pTempRect->Draw(pDC, dmDrag); 
			delete pTempRect; 
 
			// 创建临时对象，根据当前位置绘制一条橡皮线 
			CRectangle*	pTempRect2 = new CRectangle(m_LeftTop, curPos); 
			pTempRect2->Draw(pDC, dmDrag); 
			delete pTempRect2; 
  
			g_pView->ReleaseDC(pDC);	// 释放设备环境指针			 
 
			m_RightBottom = curPos ;	// 将当前位置设置为直线终点，以备下一次鼠标移动时用 
			break; 
		} 
	} 
	return 0; 
} 
 
// 单击鼠标右键取消当前的操作 
int	CCreateRect::OnRButtonDown(UINT nFlags, const Position& pos)  
{ 
	if(m_nStep == 1){  
		CDC*	pDC = g_pView->GetDC();		// 得到设备环境指针 
		Position	prePos = m_RightBottom; // 获得鼠标所在的前一个位置 
 
		CRectangle*	pTempRect = new CRectangle(m_LeftTop, m_RightBottom); 
		pTempRect->Draw(pDC, dmDrag);		// 擦除上一次绘制的橡皮线 
		delete pTempRect; 
 
		g_pView->ReleaseDC(pDC); // 释放设备环境指针 
	} 
	m_nStep = 0; 
	::Prompt("取消操作") ; 
	return 0; 
} 
 
// 调用Cancel 函数取消本次操作 
int CCreateRect::Cancel() 
{ 
	if(m_nStep == 1){  
		CDC*	pDC = g_pView->GetDC();		// 得到设备环境指针 
		Position	prePos = m_RightBottom; // 获得鼠标所在的前一个位置 
 
		CRectangle*	pTempRect = new CRectangle(m_LeftTop, m_RightBottom); 
		pTempRect->Draw(pDC, dmDrag);		// 擦除上一次绘制的橡皮线 
		delete pTempRect; 
 
		g_pView->ReleaseDC(pDC); // 释放设备环境指针 
	} 
 
	m_nStep = 0;		// 将操作步重置为 0  
	::Prompt("就绪");	// 等待提示新类型的命令操作 
 
	return 0 ; 
} 
 
 
/*----------------------------------------------------------------------------------------**/ 
 
CCreateArc::CCreateArc() : m_center(0,0), m_begin(0,0), m_end(0,0) 
{ 
	m_nStep = 0;  
} 
 
CCreateArc::~CCreateArc() 
{ 
} 
 
int CCreateArc::GetType() 
{ 
	return ctCreateArc; 
} 
 
int	CCreateArc::OnLButtonDown(UINT nFlags, const Position& pos)  
{ 
	m_nStep ++; // 每次单击鼠标左键时操作步加 1  
	switch(m_nStep) 
	{ 
		case 1: 
		{ 
			m_center = pos; 
			::Prompt("请输入圆弧的起始点：") ; 
			break; 
		} 
		case 2: 
		{ 
			m_begin = m_end = pos ; 
			::Prompt("请输入圆弧的终点：") ; 
			break; 
		} 
		case 3: 
		{ 
 			CDC*	pDC = g_pView->GetDC(); // a pointer to internal dc  
			 
			// 擦除在拖动状态时显示的橡皮线 
			CLine*	pTempLine1 = new CLine(m_center, m_begin); 
			CLine*	pTempLine2 = new CLine(m_center, m_end); 
			CArc*	pTempArc = new CArc(m_center,m_begin, m_end); 
			pTempLine1->Draw(pDC, dmDrag); 
			pTempLine2->Draw(pDC, dmDrag); 
			pTempArc->Draw(pDC, dmDrag); 
			delete pTempLine1; 
			delete pTempLine2; 
			delete pTempArc; 
 
			m_end = pos ; 
 
			CArc*	pNewArc = new CArc(m_center,m_begin, m_end);			 
			pNewArc->Draw(pDC,dmNormal); 
			g_pDoc->m_EntityList.AddTail(pNewArc); 
			g_pDoc->SetModifiedFlag(TRUE);	// 
			 
			g_pView->ReleaseDC(pDC);		// 
			 
			m_nStep = 0;  
			::Prompt("请输入圆弧的中心点：") ; 
			break; 
		} 
		 
	} 
	return 0; 
} 
 
int	CCreateArc::OnMouseMove(UINT nFlags, const Position& pos) 
{ 
	static	int nPreRefresh = g_nRefresh;  
	BOOL	bRefresh = FALSE;  
	int		nCurRefresh = g_nRefresh;  
 
	if(nCurRefresh != nPreRefresh){  
		bRefresh = TRUE; 
		nPreRefresh = nCurRefresh;  
	} 
	switch(m_nStep) 
	{ 
		case 0: 
			::Prompt("请输入圆的中心点：") ; 
			break; 
		case 1: 
			break; 
		case 2: 
		{ 
			Position	prePos, curPos; 
			prePos = m_end ; 
			curPos = pos; 
			 
			CDC*	pDC = g_pView->GetDC(); // 得到设备环境指针 
			 
			// 创建临时对象擦除上一次的橡皮线 
			CLine*	pTempLine1 = new CLine(m_center, prePos); 
			CArc*	pTempArc1 = new CArc(m_center,m_begin, prePos); 
			if(!bRefresh){  
				pTempLine1->Draw(pDC, dmDrag); 
				pTempArc1->Draw(pDC, dmDrag); 
			} 
			delete pTempLine1; 
			delete pTempArc1; 
 
			// 创建临时对象，根据当前位置绘制橡皮线 
			CLine*	pTempLine2 = new CLine(m_center, curPos); 
			CArc*	pTempArc2 = new CArc(m_center,m_begin, curPos); 
			if(!bRefresh){  
				pTempLine2->Draw(pDC, dmDrag); 
				pTempArc2->Draw(pDC, dmDrag); 
			} 
			delete pTempLine2; 
			delete pTempArc2; 
 
			g_pView->ReleaseDC(pDC);	// 释放设备环境指针			 
 
			m_end = curPos;	// 将当前位置设置为直线终点，以备下一次鼠标移动时用			 
 
			break; 
		} 
	} 
	return 0; 
} 
 
int	CCreateArc::OnRButtonDown(UINT nFlags, const Position& pos)  
{ 
	if(m_nStep == 2){  
		CDC*	pDC = g_pView->GetDC();	// 得到设备环境指针 
	 
		Position	prePos = m_end;		// 获得鼠标所在的前一个位置 
		CLine*		pTempLine1 = new CLine(m_center, m_begin); 
		CLine*		pTempLine2 = new CLine(m_center, prePos); 
		CArc*		pTempArc = new CArc(m_center, m_begin, prePos); 
		pTempLine1->Draw(pDC, dmDrag);	// 擦除上一次绘制的橡皮线 
		pTempLine2->Draw(pDC, dmDrag);  
		pTempArc->Draw(pDC, dmDrag);  
		delete		pTempLine1; 
		delete		pTempLine2; 
		delete		pTempArc; 
		 
		g_pView->ReleaseDC(pDC); // 释放设备环境指针 
	} 
	m_nStep = 0; // 将操作步重置为 0  
	::Prompt("请输入圆弧的中心点：") ; 
 
	return 0; 
} 
 
// 调用Cancel 函数取消本次操作 
int CCreateArc::Cancel() 
{ 
	if(m_nStep == 2){  
		CDC*	pDC = g_pView->GetDC(); // 得到设备环境指针 
		 
		Position	prePos = m_end;		// 获得鼠标所在的前一个位置 
		CLine*		pTempLine1 = new CLine(m_center, m_begin); 
		CLine*		pTempLine2 = new CLine(m_center, prePos); 
		CArc*		pTempArc = new CArc(m_center, m_begin, prePos); 
		pTempLine1->Draw(pDC, dmDrag);	// 擦除上一次绘制的橡皮线 
		pTempLine2->Draw(pDC, dmDrag);  
		pTempArc->Draw(pDC, dmDrag);  
		delete		pTempLine1; 
		delete		pTempLine2; 
		delete		pTempArc; 
 
		g_pView->ReleaseDC(pDC); // 释放设备环境指针 
	} 
	 
	m_nStep = 0; // 将操作步重置为 0  
	::Prompt("就绪"); // 等待提示新类型的命令操作 
	 
	return 0 ; 
} 
 
/*---------------------------------------------------------------------------------------*/ 
 
CMove::CMove() : m_basePos(0,0), m_desPos(0,0) 
{ 
	m_nStep = 0; 
} 
 
CMove::~CMove() 
{ 
} 
 
int	CMove::GetType() 
{ 
	return ctMove; 
} 
 
int	CMove::OnLButtonDown(UINT nFlags, const Position& pos)  
{ 
	m_nStep ++ ; 
	switch(m_nStep) 
	{ 
		case 1: 
			m_basePos = m_desPos = pos; 
			::Prompt("请输入移动的目标点：单击鼠标右键取消") ; 
			break; 
		case 2: 
		{ 
			m_desPos = pos; 
			CDC*	pDC = g_pView->GetDC();		// 获得视类的设备环境指针 
 
			CLine*	pTempLine = new CLine(m_basePos, m_desPos); 
			pTempLine->Draw(pDC, dmDrag); 
			delete pTempLine; 
 
			int i, n; 
			for(n = g_pDoc->m_selectArray.GetSize(), i = 0; i < n; i++) 
			{ 
				CEntity*	pEntity = (CEntity*)g_pDoc->m_selectArray[i]; 
				pEntity->Draw(pDC,dmInvalid);	// 清除原来位置上的图元 
				pEntity->Move(m_basePos, m_desPos);	// 将图元移动到目标位置 
				pEntity->Draw(pDC,dmNormal);	// 在目标位置上绘制图元 
			} 
			g_pDoc->m_selectArray.RemoveAll();	//  清空选择集 
			g_pDoc->SetModifiedFlag(TRUE);		// 标志文档数据已被修改 
			g_pView->ReleaseDC(pDC);			// 释放视类的设备环境指针 
			m_nStep = 0;  
			break; 
		} 
		default: 
			break; 
	} 
	 
	return 0; 
} 
int	CMove::OnMouseMove(UINT nFlags, const Position& pos) 
{ 
	static	int nPreRefresh = g_nRefresh;  
	BOOL	bRefresh = FALSE;  
	int		nCurRefresh = g_nRefresh;  
 
	if(nCurRefresh != nPreRefresh){  
		bRefresh = TRUE; 
		nPreRefresh = nCurRefresh;  
	} 
	switch(m_nStep) 
	{ 
		case 0: 
			::Prompt("请输入移动的起始点：") ; 
			break; 
		case 1: 
		{ 
			Position	prePos, curPos; 
			prePos = m_desPos;	// 获得上一个目标位置 
			curPos = pos;		// 得到当前位置 
 
			CDC*	pDC = g_pView->GetDC();  
 
			if(!bRefresh) 
			{ 
				CLine*	pTempLine1 = new CLine(m_basePos, prePos); 
				pTempLine1->Draw(pDC, dmDrag); 
				delete pTempLine1; 
			} 
 
			// 在当前位置绘制橡皮线 
			CLine*	pTempLine2 = new CLine(m_basePos, curPos); 
			pTempLine2->Draw(pDC, dmDrag); 
			delete pTempLine2; 
 
			// 根据当前位置给出选中图元的实时位置 
			int i, n; 
			for(n = g_pDoc->m_selectArray.GetSize(), i = 0; i < n; i++) 
			{ 
				CEntity*	pEntity = (CEntity*)g_pDoc->m_selectArray[i]; 
				pEntity->Draw(pDC,dmSelect); 
 
				// 如果在操作过程中窗口没有被刷新，则要清除上一个位置上绘制的图元 
				if(!bRefresh)  
				{ 
					CEntity*	pCopyEntity1 = pEntity->Copy();	// 得到图元的拷贝 
					pCopyEntity1->Move(m_basePos, prePos);		// 将拷贝移动到上一个位置 
					pCopyEntity1->Draw(pDC,dmDrag);				// 对在上一个位置对拷贝进行重画 
					delete pCopyEntity1;						// 删除临时拷贝 
				} 
 
				// 在当前位置上绘制图元 
				CEntity*	pCopyEntity2 = pEntity->Copy();// 得到图元的拷贝 
				pCopyEntity2->Move(m_basePos, curPos);// 将拷贝移动到当前位置 
				pCopyEntity2->Draw(pDC,dmDrag);	// 对当前位置绘制拷贝 
				delete pCopyEntity2; // 删除临时拷贝  
			} 
			g_pView->ReleaseDC(pDC); 
			m_desPos = pos; // 将目标设置为当前位置 
		} 
		default: 
			break; 
	} 
	return 0; 
} 
 
// 单击鼠标右键取消正在进行的操作 
int	CMove::OnRButtonDown(UINT nFlags, const Position& pos)  
{ 
	Position	prePos = m_desPos; // 得到上一个鼠标位置 
	if(m_nStep == 1){ 
		CDC*	pDC = g_pView->GetDC(); 
 
		// 清除上一个绘制的橡皮线 
		CLine*	pTempLine = new CLine(m_basePos, prePos); 
		pTempLine->Draw(pDC, dmDrag); 
		delete	pTempLine; 
		 
		int i, n; 
		for(n = g_pDoc->m_selectArray.GetSize(), i = 0; i < n; i++) 
		{ 
			CEntity*	pEntity = (CEntity*)g_pDoc->m_selectArray[i]; 
 
			// 清除上一次绘制的临时对象 
			CEntity*	pCopyEntity = pEntity->Copy(); 
			pCopyEntity->Move(m_basePos, prePos); 
			pCopyEntity->Draw(pDC,dmDrag); 
			delete		pCopyEntity;  
 
			// 重新绘制选择集中的对象 
			pEntity->Draw(pDC, dmSelect); // redraw the selected entity 
		} 
		g_pView->ReleaseDC(pDC); // don't forget this 
	} 
	m_nStep = 0; 
	::Prompt("请输入移动的起始点：") ; 
	return 0; 
} 
 
// 调用Cancel 函数取消本次操作 
int CMove::Cancel() 
{ 
	Position	prePos = m_desPos; // 得到上一个鼠标位置 
	if(m_nStep == 1){ 
		CDC*	pDC = g_pView->GetDC(); 
 
		// 清除上一个绘制的橡皮线 
		CLine*	pTempLine = new CLine(m_basePos, prePos); 
		pTempLine->Draw(pDC, dmDrag); 
		delete	pTempLine; 
		 
		int i, n; 
		for(n = g_pDoc->m_selectArray.GetSize(), i = 0; i < n; i++) 
		{ 
			CEntity*	pEntity = (CEntity*)g_pDoc->m_selectArray[i]; 
			// 清除上一次绘制的临时对象 
			CEntity*	pCopyEntity = pEntity->Copy(); 
			pCopyEntity->Move(m_basePos, prePos); 
			pCopyEntity->Draw(pDC,dmDrag); 
			delete		pCopyEntity;  
			// 重新绘制选择集中的对象 
			pEntity->Draw(pDC, dmSelect);  
		} 
		g_pView->ReleaseDC(pDC);  
	} 
	m_nStep = 0;		// 将操作步重置为 0  
	::Prompt("就绪");	//  
	return 0; 
} 
 
/*---------------------------------------------------------------------------------------*/ 
 
CRotate::CRotate() : m_basePos(0,0), m_desPos(0,0) 
{ 
	m_nStep = 0; 
} 
 
CRotate::~CRotate() 
{ 
} 
 
int	CRotate::GetType() 
{ 
	return ctRotate; 
} 
 
int	CRotate::OnLButtonDown(UINT nFlags, const Position& pos)  
{ 
	m_nStep ++ ; 
	switch(m_nStep) 
	{ 
		case 1: 
			// 第一次单击鼠标左键时得到基点位置，并初步设定目标位置 
			m_basePos = m_desPos = pos; 
			::Prompt("请输入第二点：单击鼠标右键取消") ; 
			break; 
		case 2: 
		{ 
			m_desPos = pos; 
			CDC*	pDC = g_pView->GetDC(); // 获得视类的设备环境指针 
 
			// 清除鼠标移动时最后遗留下的橡皮线 
			CLine*	pTempLine = new CLine(m_basePos, m_desPos); 
			pTempLine->Draw(pDC, dmDrag); 
			delete pTempLine; 
 
			// 将选择集中的图元移动到目标位置并进行绘制 
			int i, n; 
			for(n = g_pDoc->m_selectArray.GetSize(), i = 0; i < n; i++) 
			{ 
				CEntity*	pEntity = (CEntity*)g_pDoc->m_selectArray[i]; 
				pEntity->Draw(pDC,dmInvalid);		// 清除原来位置上的图元 
				double angle = ::GetAngleToXAxis(m_basePos, m_desPos); 
				pEntity->Rotate(m_basePos, angle);	// 将图元移动到目标位置 
				pEntity->Draw(pDC,dmNormal);		// 在目标位置上绘制图元 
			} 
			g_pDoc->m_selectArray.RemoveAll();	//  清空选择集 
			g_pDoc->SetModifiedFlag(TRUE);		// 标志文档数据已被修改 
			g_pView->ReleaseDC(pDC);			// 释放视类的设备环境指针 
			m_nStep = 0;  
			break; 
		} 
		default: 
			break; 
	} 
	return 0; 
} 
 
int	CRotate::OnMouseMove(UINT nFlags, const Position& pos) 
{ 
	// 用一静态变量nPreRefresh记录进入OnMouseMove状态时的刷新次数 
	static	int nPreRefresh = g_nRefresh;  
	BOOL	bRefresh = FALSE;  
	int		nCurRefresh = g_nRefresh;  
 
	if(nCurRefresh != nPreRefresh){  
		bRefresh = TRUE; 
		nPreRefresh = nCurRefresh;  
	} 
 
	switch(m_nStep) 
	{ 
		case 0: 
			::Prompt("请输入旋转的基点：") ; 
			break; 
		case 1: 
		{ 
			Position	prePos, curPos; 
			prePos = m_desPos;	// 获得上一个目标位置 
			curPos = pos;		// 得到当前位置 
 
			CDC*	pDC = g_pView->GetDC();  
 
			// 如果在操作过程中窗口没有被刷新，则要清除上一次绘制的橡皮线 
			if(!bRefresh) 
			{ 
				CLine*	pTempLine1 = new CLine(m_basePos, prePos); 
				pTempLine1->Draw(pDC, dmDrag); 
				delete pTempLine1; 
			} 
 
			// 在当前位置绘制橡皮线 
			CLine*	pTempLine2 = new CLine(m_basePos, curPos); 
			pTempLine2->Draw(pDC, dmDrag); 
			delete pTempLine2; 
 
			// 根据当前位置给出选中图元的实时位置 
			int i, n; 
			for(n = g_pDoc->m_selectArray.GetSize(), i = 0; i < n; i++) 
			{ 
				CEntity*	pEntity = (CEntity*)g_pDoc->m_selectArray[i]; 
				pEntity->Draw(pDC,dmSelect); 
 
				// 如果在操作过程中窗口没有被刷新，则要清除上一个位置上绘制的图元 
				if(!bRefresh)  
				{ 
					// 清除上一个位置上绘制的图元 
					CEntity*	pCopyEntity1 = pEntity->Copy();	// 得到图元的拷贝 
					double angle1 = ::GetAngleToXAxis(m_basePos, prePos); 
					pCopyEntity1->Rotate(m_basePos, angle1);	// 将拷贝移动到上一个位置 
					pCopyEntity1->Draw(pDC,dmDrag);				// 对在上一个位置对拷贝进行重画 
					delete pCopyEntity1;						// 删除临时拷贝 
				} 
 
				// 在当前位置上绘制图元 
				CEntity*	pCopyEntity2 = pEntity->Copy();	// 得到图元的拷贝 
				double angle2 = ::GetAngleToXAxis(m_basePos, curPos); 
				pCopyEntity2->Rotate(m_basePos, angle2);	// 将拷贝移动到当前位置 
				pCopyEntity2->Draw(pDC,dmDrag);				// 对当前位置绘制拷贝 
				delete pCopyEntity2;						// 删除临时拷贝  
			} 
 
			g_pView->ReleaseDC(pDC); 
			m_desPos = pos; // 将目标设置为当前位置 
		} 
		default: 
			break; 
	} 
	return 0; 
} 
 
// 单击鼠标右键取消正在进行的操作 
int	CRotate::OnRButtonDown(UINT nFlags, const Position& pos)  
{ 
	Position	prePos = m_desPos; // 得到上一个鼠标位置 
	if(m_nStep == 1){ 
		CDC*	pDC = g_pView->GetDC(); 
 
		// 清除上一个绘制的橡皮线 
		CLine*	pTempLine = new CLine(m_basePos, prePos); 
		pTempLine->Draw(pDC, dmDrag); 
		delete	pTempLine; 
		 
		int i, n; 
		for(n = g_pDoc->m_selectArray.GetSize(), i = 0; i < n; i++) 
		{ 
			CEntity*	pEntity = (CEntity*)g_pDoc->m_selectArray[i]; 
 
			// 清除上一次绘制的临时对象 
			CEntity*	pCopyEntity = pEntity->Copy(); 
			double angle = ::GetAngleToXAxis(m_basePos, prePos); 
			pCopyEntity->Rotate(m_basePos, angle); 
			pCopyEntity->Draw(pDC,dmDrag); 
			delete		pCopyEntity;  
 
			// 重新绘制选择集中的对象 
			pEntity->Draw(pDC, dmSelect); // redraw the selected entity 
		} 
		g_pView->ReleaseDC(pDC); // don't forget this 
	} 
	m_nStep = 0; 
	::Prompt("请输入旋转的基点：") ; 
	return 0; 
} 
 
// 调用Cancel 函数取消本次操作 
int CRotate::Cancel() 
{ 
	Position	prePos = m_desPos; // 得到上一个鼠标位置 
	if(m_nStep == 1){ 
		CDC*	pDC = g_pView->GetDC(); 
 
		// 清除上一个绘制的橡皮线 
		CLine*	pTempLine = new CLine(m_basePos, prePos); 
		pTempLine->Draw(pDC, dmDrag); 
		delete	pTempLine; 
		 
		int i, n; 
		for(n = g_pDoc->m_selectArray.GetSize(), i = 0; i < n; i++) 
		{ 
			CEntity*	pEntity = (CEntity*)g_pDoc->m_selectArray[i]; 
 
			// 清除上一次绘制的临时对象 
			CEntity*	pCopyEntity = pEntity->Copy(); 
			double angle = ::GetAngleToXAxis(m_basePos, prePos); 
			pCopyEntity->Rotate(m_basePos, angle); 
			pCopyEntity->Draw(pDC,dmDrag); 
			delete		pCopyEntity;  
 
			// 重新绘制选择集中的对象 
			pEntity->Draw(pDC, dmSelect); // redraw the selected entity 
		} 
		g_pView->ReleaseDC(pDC); // don't forget this 
	} 
	m_nStep = 0;		// 将操作步重置为 0  
	::Prompt("就绪");	// 等待提示新类型的命令操作 
	return 0; 
}