drawcoord.cpp

这是一个程序的一般架构方法

// DrawCoord.cpp: implementation of the CDrawCoord class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "drawbase.h"
#include "inlinefunction.h"
#include "afxtempl.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CDrawCoord::CDrawCoord(HWND hWnd)
{
	m_DrawBase.SetNewHWND(hWnd);
	m_UnDoData.SetSize(VIEW_UNDO_NUMBER );
}

CDrawCoord::~CDrawCoord()
{
	
}

//线段
void CDrawCoord::Line(CPoint2D p1, CPoint2D p2)
{
	POINT dcP1 ,dcP2;

	dcP1 = P2DToPOINT(p1);
	dcP2 = P2DToPOINT(p2);

	m_DrawBase.Line( dcP1 , dcP2 );
}

//圆
void CDrawCoord::DrawCircle(CPoint2D p1,double r)
{
	POINT dcp1 = P2DToPOINT(p1);
	UINT dcr = MFXRounding(r/m_dScale);
	m_DrawBase.DrawCircle(dcp1 , dcr);
}

//多义线
void CDrawCoord::Ployline(CPoint2D * pPo , int nCount)
{
	POINT * dcp = (POINT * )MFXGetMemShareBlack(nCount* sizeof(POINT));
	if(!dcp)
	{
		AfxMessageBox(IDS_MEMMANAGE_SHARE_BLACE_LITTLE);
		return;
	}
	for(int i = 0 ; i < nCount ; i ++)
	{
		dcp[i] = P2DToPOINT(pPo[i]);
	}
	m_DrawBase.Ployline(dcp,nCount);
	MFXUnLockMemShareBlack();
}

//点
void CDrawCoord::Point(CPoint2D p1)
{
	POINT dcp = P2DToPOINT(p1);
	m_DrawBase.Point(dcp);
}

POINT CDrawCoord::P2DToPOINT(CPoint2D sp)
{
	POINT po;
	CPoint2D newP;
	CPoint2D test;
	
	newP = sp * m_MatrixView;
	test = newP/m_MatrixView;
	po.x = (int)floor(newP.x+0.5) ;
	po.y = (int)floor(newP.y+0.5) ;

	return po ;
}

void CDrawCoord::SetPen(int nPenStyle, int nWidth, COLORREF crColor)
{
	m_DrawBase.SetPen( nPenStyle, nWidth , crColor);
}

void CDrawCoord::BeginDraw()
{
	m_DrawBase.BeginDraw();
}

void CDrawCoord::EndDraw()
{
	m_DrawBase.EndDraw();
}
 
void CDrawCoord::ViewRect(CRect2D rect)
{
	int nWidth,nHeight;
	double dOffsetX,dOffsetY;
	double scale ,dTemp;
	CPoint2D Offset;

	//计算缩放比例
	nWidth = m_DrawBase.GetDrawWidth();
	nHeight = m_DrawBase.GetDrawHeight();

	dOffsetX = rect.GetWidth();
	dOffsetY = rect.GetHeight();

	if (dOffsetX < MAX_ZORE_DOUBLE||dOffsetY < MAX_ZORE_DOUBLE) 
	{
		return;
	}
	scale =  nWidth / dOffsetX;
	dTemp =  nHeight / dOffsetY;
	scale = scale<dTemp?scale:dTemp;

	//
	CVector2D mirrorVect(1,0);
	CVector2D vect(  -rect.left * scale,nHeight +rect.bottom * scale);
	m_MatrixView.IdenticalMatrix();
	m_MatrixView *= m_MatrixView.CreateScaleMatrix(scale);
	m_MatrixView *= m_MatrixView.CreateMirrorMatrix(mirrorVect);
	m_MatrixView *= m_MatrixView.CreateTransfMatrix(vect);
	m_MatrixViewInverse = ~m_MatrixView;
	m_dScale = scale;
}

CDrawCoord::CDrawCoord()
{
	m_UnDoData.SetSize(VIEW_UNDO_NUMBER);
}

void CDrawCoord::Attach(HWND hWnd)
{
	m_DrawBase.SetNewHWND(hWnd);
	m_UnDoData.ReInit();
	m_UnDoData.Add(GetViewRect());
}

void CDrawCoord::ViewOffset(double dOffsetX, double dOffsetY)
{
	CRect2D rect = GetViewRect();
	if (rect.GetHeight() < MAX_ZORE_DOUBLE) 
	{
		return;
	}
//	double dScale = m_DrawBase.GetDrawHeight()/rect.GetHeight();
	CVector2D Vect(-dOffsetX*m_dScale,dOffsetY*m_dScale);

	m_MatrixView *= m_MatrixView.CreateTransfMatrix(Vect);
	m_MatrixViewInverse = ~m_MatrixView;
	m_UnDoData.Add(GetViewRect());
}

void CDrawCoord::ViewScale(double dScale)
{
	int nWidth = m_DrawBase.GetDrawWidth();
	int nHeight = m_DrawBase.GetDrawHeight();
	if (dScale < MAX_ZORE_DOUBLE) 
	{
		return;
	}
	CRect2D rect = GetViewRect();
	
	rect.Scale(1/dScale);
	ViewRect(rect);
	m_UnDoData.Add(rect);
//	m_MatrixViewInverse = ~m_MatrixView;
	
}

CRect2D CDrawCoord::GetViewRect()
{
	int nWidth = m_DrawBase.GetDrawWidth();
	int nHeight = m_DrawBase.GetDrawHeight();
	CPoint2D p1(0,0);
	CPoint2D p2(nWidth,nHeight);
	p1 *= m_MatrixViewInverse;
	p2 *= m_MatrixViewInverse;
	CRect2D rect(p1,p2);
	return rect;
}

CPoint2D CDrawCoord::PointToP2D(POINT po)
{
	int nWidth = m_DrawBase.GetDrawWidth();
	int nHeight = m_DrawBase.GetDrawHeight();
	CPoint2D p1(po.x,po.y);
	p1 *= m_MatrixViewInverse;
	return p1;
}

void CDrawCoord::ViewScale(double dScale, CPoint2D toPoint)
{
	if (dScale < MAX_ZORE_DOUBLE) 
	{
		return;
	}
	CRect2D rect = GetViewRect();
	
	double dwidth = rect.GetWidth()/2;
	double dheight = rect.GetHeight()/2;

	CPoint2D pcon = toPoint;
	CPoint2D p1,p2;
	p1.x = pcon.x - dwidth;
	p1.y = pcon.y - dheight;
	p2.x = pcon.x + dwidth;
	p2.y = pcon.y + dheight;

	CRect2D rectnew (p1,p2);
	ASSERT(dScale > MAX_ZORE_DOUBLE);
	rectnew.Scale(1/dScale);
	ViewRect(rectnew);
	m_UnDoData.Add(rectnew);
}

CRect2D CDrawCoord::GetViewRect(CPoint2D p1, CPoint2D p2)
{
	int nWidth = m_DrawBase.GetDrawWidth();
	int nHeight = m_DrawBase.GetDrawHeight();
	if (!nWidth||!nHeight) 
	{
		return CRect2D(0,0,0,0);
	}
	CRect2D rect1(p1,p2);
	double dOffsetX = rect1.GetWidth();
	double dOffsetY = rect1.GetHeight();
	
	BOOL isWidth = dOffsetX/nWidth	> dOffsetY / nHeight;
	if (isWidth) 
	{
		double dLength = dOffsetY*nWidth/nHeight;
		p1.y = (p1.y + p2.y - dLength) / 2;
		p2.y = (p1.y + p2.y + dLength) / 2;
	}
	else
	{
		double dLength = dOffsetX*nHeight/nWidth;
		p1.x = (p1.x + p2.x - dLength) / 2;
		p2.x = (p1.x + p2.x + dLength) / 2;
	}
	CRect2D rect(p1,p2);
	return rect;	
}

void CDrawCoord::ViewUndo()
{
	if (!m_UnDoData.Undo()) 
	{
		return;
	}
	CRect2D rect = m_UnDoData.GetCurrenData();
	ViewRect(rect);
}

BOOL CDrawCoord::CanUndo()
{
	return m_UnDoData.CanUndo();
}

void CDrawCoord::ViewRedo()
{
	if (!m_UnDoData.Redo()) 
	{
		return;
	}
	CRect2D rect = m_UnDoData.GetCurrenData();
	ViewRect(rect);
}

BOOL CDrawCoord::CanRedo()
{
	return m_UnDoData.CanRedo();
	
}