www.pudn.com > mischat.rar > Draw.cpp

// Line.cpp: implementation of the CLine class. 
// 
////////////////////////////////////////////////////////////////////// 
 
#include "stdafx.h" 
#include "Draw.h" 
#include "tokenizer.h" 
#include "math.h" 
#ifdef _DEBUG 
#undef THIS_FILE 
static char THIS_FILE[]=__FILE__; 
#define new DEBUG_NEW 
#endif 
 
////////////////////////////////////////////////////////////////////// 
// Construction/Destruction 
////////////////////////////////////////////////////////////////////// 
IMPLEMENT_SERIAL(CCurve, CObject, 0) 
CCurve::CCurve() 
{ 
} 
 
CCurve::~CCurve() 
{ 
	pointList.RemoveAll (); 
} 
 
void CCurve::AddPoint(CPoint point) 
{ 
	pointList.AddTail (point); 
} 
 
void CCurve::Init(UINT w,COLORREF c) 
{ 
	m_width=w; 
	m_crColor=c; 
} 
 
void CCurve::Draw(CDC *pDC) 
{ 
	ASSERT(m_width>=1 && m_width<=10); 
	CPen lpen(PS_SOLID,m_width,m_crColor); 
	CPen* pOldPen=pDC->SelectObject(&lpen); 
	POSITION ps; 
	CPoint p; 
	ps=pointList.GetHeadPosition (); 
	if(ps!=NULL) p=pointList.GetNext(ps);	 
	pDC->MoveTo (p); 
    while(ps!=NULL){ 
		p=pointList.GetNext (ps); 
		pDC->LineTo (p); 
	} 
	pDC->SelectObject(pOldPen); 
} 
 
void CCurve::Serialize(CArchive& ar) 
{ 
	if (ar.IsStoring()) 
	{	// storing code 
		ar<>m_width>>m_crColor; 
	} 
	pointList.Serialize (ar); 
} 
 
bool CCurve::HitTest(CPoint& pt,CDC* pDC) 
{ 
	bool rel=false; 
	CPoint p; 
	POSITION ps; 
	ps=pointList.GetHeadPosition (); 
    while(ps!=NULL){ 
		p=pointList.GetNext (ps); 
		rel=(abs(pt.x-p.x)<=5) && (abs(pt.y-p.y)<=5); 
		if(rel) return rel; 
	} 
	return rel; 
} 
 
CRect CCurve::GetOutside(CDC *pDC) 
{ 
	LONG left,top,right,bottom; 
	POSITION ps; 
	CPoint p; 
	ps=pointList.GetHeadPosition (); 
	if(ps!=NULL){ 
		p=pointList.GetNext(ps); 
		left=right=p.x ; 
		top=bottom=p.y ; 
	} 
    while(ps!=NULL){ 
		p=pointList.GetNext (ps); 
		if(p.xright) right=p.x; 
		if(p.ybottom) bottom=p.y; 
	} 
	CRect rect; 
	rect.left =left; 
	rect.top =top; 
	rect.right =right; 
	rect.bottom =bottom; 
	rect.InflateRect (5,5); 
	return rect; 
} 
 
void CCurve::Offset(CSize& s) 
{ 
	POSITION ps; 
	ps=pointList.GetHeadPosition (); 
 
    while(ps!=NULL){ 
		pointList.GetNext (ps).Offset (s); 
	} 
} 
 
IMPLEMENT_SERIAL(CLine, CObject, 0) 
 
CLine::CLine() 
{ 
} 
 
CLine::~CLine() 
{ 
} 
 
CLine::CLine(CPoint ptFrom, CPoint ptTo,COLORREF crColor,UINT width) 
{ 
	m_ptFrom=ptFrom; 
	m_ptTo=ptTo; 
	m_crColor=crColor; 
	m_width=width; 
} 
 
void CLine::Draw(CDC *pDC) 
{ 
	ASSERT(m_width>=1 && m_width<=10); 
	CPen lpen(PS_SOLID,m_width,m_crColor); 
	CPen* pOldPen=pDC->SelectObject(&lpen); 
	pDC->MoveTo(m_ptFrom); 
	pDC->LineTo(m_ptTo); 
	pDC->SelectObject(pOldPen); 
} 
 
void CLine::Serialize(CArchive& ar) 
{ 
	if (ar.IsStoring()) 
	{	// storing code 
		ar<>m_ptFrom>>m_ptTo>>m_crColor>>m_width; 
	} 
} 
 
bool CLine::HitTest(CPoint& pt,CDC* pDC) 
{ 
	return IsOnline(m_ptFrom,m_ptTo,pt); 
} 
 
CRect CLine::GetOutside(CDC *pDC) 
{ 
	CRect rect(m_ptFrom,m_ptTo); 
	rect.NormalizeRect (); 
	rect.InflateRect (5,5); 
	return rect; 
} 
 
void CLine::Offset(CSize& s) 
{ 
	m_ptFrom.Offset (s); 
	m_ptTo.Offset (s); 
} 
 
IMPLEMENT_SERIAL(CText, CObject, 0) 
CText::CText() 
{ 
 
} 
 
CText::~CText() 
{ 
 
} 
 
CText::CText(CPoint ptFrom,CString strText,LOGFONT lf,COLORREF crColor) 
{ 
	m_ptFrom=ptFrom; 
	m_crColor=crColor; 
	m_lf=lf; 
	m_strText=strText; 
} 
 
void CText::Draw(CDC *pDC) 
{ 
	CFont font; 
	CFont* def_font; 
	if(!font.CreateFontIndirect (&m_lf)) 
	{ 
		CFont* pfont = CFont::FromHandle ((HFONT) GetStockObject (DEFAULT_GUI_FONT)); 
		def_font = pDC->SelectObject(pfont); 
	} 
	else def_font = pDC->SelectObject(&font); 
 
	int m=pDC->SetBkMode (TRANSPARENT); 
	COLORREF cr=pDC->SetTextColor (m_crColor); 
	pDC->TextOut (m_ptFrom.x ,m_ptFrom.y ,m_strText); 
	pDC->SelectObject(def_font); 
	pDC->SetTextColor(cr); 
	pDC->SetBkMode (m); 
} 
 
void CText::Serialize(CArchive& ar) 
{ 
	if (ar.IsStoring()) 
	{	// storing code 
		ar<>m_ptFrom>>m_crColor>>m_strText; 
		ar.Read (&m_lf,sizeof(LOGFONT)); 
	} 
} 
 
bool CText::HitTest(CPoint& pt,CDC* pDC) 
{ 
	CRect rect=GetOutside(pDC); 
	rect.NormalizeRect (); 
	return rect.PtInRect (pt); 
} 
 
CRect CText::GetOutside(CDC *pDC) 
{ 
	CFont font; 
	CFont* def_font; 
	if(!font.CreateFontIndirect (&m_lf)) 
	{ 
		CFont* pfont = CFont::FromHandle ((HFONT) GetStockObject (DEFAULT_GUI_FONT)); 
		def_font = pDC->SelectObject(pfont); 
	} 
	else def_font = pDC->SelectObject(&font); 
	return CRect(m_ptFrom,pDC->GetTextExtent (m_strText)); 
} 
 
void CText::Offset(CSize& s) 
{ 
	m_ptFrom.Offset (s); 
} 
 
IMPLEMENT_SERIAL(CRectangle, CObject, 0) 
CRectangle::CRectangle() 
{ 
 
} 
 
CRectangle::~CRectangle() 
{ 
 
} 
 
CRectangle::CRectangle(CRect rect,COLORREF crPen,COLORREF crBrush,UINT width,int shape) 
{ 
	m_rect=rect; 
	m_crPen=crPen; 
	m_crBrush=crBrush; 
	m_width=width; 
	DrawShape=shape; 
} 
 
void CRectangle::Draw(CDC *pDC) 
{ 
	ASSERT(m_width>=1 && m_width<=10); 
	CPen* pOldPen; 
	CBrush* pOldBrush; 
	CPen pen(PS_SOLID,m_width,m_crPen); 
	CBrush brush(m_crBrush); 
	int xCorner=m_rect.Width ()/4; 
	int yCorner=m_rect.Height ()/4; 
    CPoint point; 
	point.x =point.y=xCornerSelectObject(&pen); 
		pOldBrush=pDC->SelectObject(&brush); 
		pDC->Rectangle(m_rect); 
		break; 
	case SOLIDRECTANGLE: 
		pOldPen=(CPen*)pDC->SelectStockObject(NULL_PEN); 
		pOldBrush=pDC->SelectObject(&brush); 
		pDC->Rectangle(m_rect); 
		break; 
	case RECTANGLE: 
		pOldPen=pDC->SelectObject(&pen); 
		pOldBrush=(CBrush*)pDC->SelectStockObject(NULL_BRUSH); 
		pDC->Rectangle(m_rect); 
		break; 
	case BLANKROUNDRECT: 
		pOldPen=pDC->SelectObject(&pen); 
		pOldBrush=pDC->SelectObject(&brush); 
		pDC->RoundRect(m_rect,point); 
		break; 
	case SOLIDROUNDRECT: 
		pOldPen=(CPen*)pDC->SelectStockObject(NULL_PEN); 
		pOldBrush=pDC->SelectObject(&brush); 
		pDC->RoundRect(m_rect,point);		 
		break; 
	case ROUNDRECT: 
		pOldPen=pDC->SelectObject(&pen); 
		pOldBrush=(CBrush*)pDC->SelectStockObject(NULL_BRUSH); 
		pDC->RoundRect(m_rect,point);		 
		break; 
	} 
	pDC->SelectObject(pOldPen); 
	pDC->SelectObject(pOldBrush); 
} 
 
void CRectangle::Serialize(CArchive& ar) 
{ 
	if (ar.IsStoring()) 
	{	// storing code 
		ar<>m_rect>>m_crPen>>m_crBrush>>m_width>>DrawShape; 
	} 
} 
 
bool CRectangle::HitTest(CPoint& pt,CDC* pDC) 
{ 
	m_rect.NormalizeRect (); 
	bool rel=false; 
	switch(DrawShape) 
	{ 
	case BLANKRECTANGLE:case SOLIDRECTANGLE:case BLANKROUNDRECT:case SOLIDROUNDRECT: 
		rel=m_rect.PtInRect (pt); 
		break; 
	case RECTANGLE:case ROUNDRECT: 
		rel=IsOnRect(m_rect,pt); 
		break; 
	} 
	return rel; 
} 
 
CRect CRectangle:: GetOutside(CDC* pDC) 
{ 
	CRect rect=m_rect; 
	rect.InflateRect (5,5); 
	return rect; 
} 
 
void CRectangle::Offset(CSize& s) 
{ 
	m_rect.OffsetRect (s); 
} 
 
IMPLEMENT_SERIAL(CEllipse, CObject, 0) 
CEllipse::CEllipse() 
{ 
 
} 
 
CEllipse::~CEllipse() 
{ 
 
} 
 
CEllipse::CEllipse(CRect rect,COLORREF crPen,COLORREF crBrush,UINT width,int shape) 
{ 
	m_rect=rect; 
	m_crPen=crPen; 
	m_crBrush=crBrush; 
	m_width=width; 
	DrawShape=shape; 
} 
 
void CEllipse::Draw(CDC *pDC) 
{ 
	ASSERT(m_width>=1 && m_width<=10); 
	CPen* pOldPen; 
	CBrush* pOldBrush; 
	CPen pen(PS_SOLID,m_width,m_crPen); 
	CBrush brush(m_crBrush); 
	switch(DrawShape) 
	{ 
	case BLANKELLIPSE: 
		pOldPen=pDC->SelectObject(&pen); 
		pOldBrush=pDC->SelectObject(&brush); 
		pDC->Ellipse (m_rect); 
		break; 
	case SOLIDELLIPSE: 
		pOldPen=(CPen*)pDC->SelectStockObject(NULL_PEN); 
		pOldBrush=pDC->SelectObject(&brush); 
		pDC->Ellipse (m_rect); 
		break; 
	case ELLIPSE: 
		pOldPen=pDC->SelectObject(&pen); 
		pOldBrush=(CBrush*)pDC->SelectStockObject(NULL_BRUSH); 
		pDC->Ellipse (m_rect); 
		break; 
	} 
	pDC->SelectObject(pOldPen); 
	pDC->SelectObject(pOldBrush); 
} 
 
void CEllipse::Serialize(CArchive& ar) 
{ 
	if (ar.IsStoring()) 
	{	// storing code 
		ar<>m_rect>>m_crPen>>m_crBrush>>m_width>>DrawShape; 
	} 
} 
 
bool CEllipse::HitTest(CPoint& pt,CDC* pDC) 
{ 
	m_rect.NormalizeRect (); 
	bool rel=false; 
	switch(DrawShape) 
	{ 
	case BLANKELLIPSE: case SOLIDELLIPSE: 
		rel=m_rect.PtInRect (pt); 
		break; 
	case ELLIPSE: 
		rel=IsOnRect(m_rect,pt); 
		break; 
	} 
	return rel; 
} 
 
CRect CEllipse:: GetOutside(CDC* pDC) 
{ 
	CRect rect=m_rect; 
	rect.InflateRect (5,5); 
	return rect;} 
 
void CEllipse::Offset(CSize& s) 
{ 
	m_rect.OffsetRect (s); 
} 
 
// CDraw 
CDraw::CDraw() 
{ 
} 
 
CDraw::~CDraw() 
{ 
} 
 
bool CDraw::IsOnline(CPoint& pFrom,CPoint& pTo,CPoint& pTest) 
{ 
	bool rel=false; 
	double a,b,c; 
	a=sqrt((double)(pTest.x-pFrom.x)*(pTest.x-pFrom.x)+(pTest.y-pFrom.y)*(pTest.y-pFrom.y)); 
	b=sqrt((double)(pTest.x-pTo.x)*(pTest.x-pTo.x)+(pTest.y-pTo.y)*(pTest.y-pTo.y)); 
	c=sqrt((double)(pFrom.x-pTo.x)*(pFrom.x-pTo.x)+(pFrom.y-pTo.y)*(pFrom.y-pTo.y)); 
	rel=abs(a+b-c)<=5; 
	return rel; 
} 
 
bool CDraw::IsOnRect(CRect& rect,CPoint& pTest) 
{ 
	bool rel=false; 
	CPoint top_left,top_right,bottom_right,bottom_left; 
	top_left=rect.TopLeft (); 
	bottom_right=rect.BottomRight (); 
	top_right.x=rect.right ; 
	top_right.y=rect.top ; 
	bottom_left.x=rect.left; 
	bottom_left.y=rect.bottom ; 
	if(rel=IsOnline(top_left,top_right,pTest)) return rel; 
	if(rel=IsOnline(top_right,bottom_right,pTest)) return rel; 
	if(rel=IsOnline(bottom_left,bottom_right,pTest)) return rel; 
	if(rel=IsOnline(top_left,bottom_left,pTest)) return rel; 
	return rel; 
} 
// CDraw ³ÉÔ±º¯Êý