drawview.cpp

采用VC6.0做的一个画图板程序

// drawView.cpp : implementation of the CDrawView class
//

#include "stdafx.h"
#include "draw.h"

#include "drawDoc.h"
#include "drawView.h"
#include "drawView.h"
#include "Setting.h"
#include "TestLine.h"


#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CDrawView

IMPLEMENT_DYNCREATE(CDrawView, CView)

BEGIN_MESSAGE_MAP(CDrawView, CView)
	//{{AFX_MSG_MAP(CDrawView)
	ON_WM_LBUTTONDOWN()
	ON_COMMAND(ID_DRAW_LINE, OnDrawLine)
	ON_WM_LBUTTONUP()
	ON_WM_CANCELMODE()
	ON_WM_MOUSEMOVE()
	ON_COMMAND(ID_DRAW_RECT, OnDrawRect)
	ON_COMMAND(ID_DRAW_ELLIPSE, OnDrawEllipse)
	ON_COMMAND(ID_DRAW_BEZIER, OnDrawBezier)
	ON_COMMAND(ID_DRAW_BSPLINE, OnDrawBspline)
	ON_WM_RBUTTONDOWN()
	ON_COMMAND(ID_DRAW_CIRCLE, OnDrawCircle)
	ON_COMMAND(ID_DRAW_CUBE, OnDrawCube)
	ON_COMMAND(IDR_TOOL_PEN, OnToolPen)
	ON_COMMAND(IDR_DRAW_CONFIG, OnDrawConfig)
	ON_COMMAND(ID_DDA, OnDdaTest)
	//}}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()

/////////////////////////////////////////////////////////////////////////////
// CDrawView construction/destruction

CDrawView::CDrawView()
{
	// TODO: add construction code here
	m_nDrawType=0;
	m_OriginPos=0;
	m_IsDrawing=false;
	m_BezierPointNum=-1;
}

CDrawView::~CDrawView()
{
}

void CDrawView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add extra initialization before printing
}

void CDrawView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add cleanup after printing
}

BOOL CDrawView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs
	return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CDrawView drawing

void CDrawView::OnDraw(CDC* pDC)
{
	CDrawDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	m_lines.DrawLine((CClientDC *)pDC);
	m_rects.DrawRect((CClientDC *)pDC);
	m_ellipses.DrawEllipse((CClientDC *)pDC);
	m_handpoints.DrawPoint((CClientDC *)pDC);
	
	if(m_BezierPointNum>=1)
	{
		DPoint p[100];
        pDC->SetROP2(R2_COPYPEN);    
 		memcpy(p,m_BezierPoints,sizeof(p));
		
		CPen pen, *oldPen;
		pen.CreatePen(PS_SOLID,1,RGB(255,0,0));  
		oldPen = pDC->SelectObject(&pen);
 		DrawBezier(p,m_BezierPointNum,(CClientDC *)pDC);
		pDC->SelectObject(oldPen);
		
		for(int i=0;i<=m_BezierPointNum-1;i++)
		{
			pDC->MoveTo(m_BezierPoints[i].x,m_BezierPoints[i].y);    
			pDC->LineTo(m_BezierPoints[i+1].x,m_BezierPoints[i+1].y); 
		}
		for(int j=0;j<=m_BezierPointNum;j++)
		{   
			pDC->Ellipse(m_BezierPoints[j].x-3,m_BezierPoints[j].y-3,m_BezierPoints[j].x+3,m_BezierPoints[j].y+3);
		}
	}
	// TODO: add draw code for native data here
}

/////////////////////////////////////////////////////////////////////////////
// CDrawView printing

BOOL CDrawView::OnPreparePrinting(CPrintInfo* pInfo)
{
	// default preparation
	return DoPreparePrinting(pInfo);
}

/////////////////////////////////////////////////////////////////////////////
// CDrawView diagnostics

#ifdef _DEBUG
void CDrawView::AssertValid() const
{
	CView::AssertValid();
}

void CDrawView::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}

CDrawDoc* CDrawView::GetDocument() // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CDrawDoc)));
	return (CDrawDoc*)m_pDocument;
}
#endif //_DEBUG

void CDrawView::OnLButtonDown(UINT nFlags, CPoint point) 
{
	// TODO: Add your message handler code here and/or call default
	CClientDC* m_pDC;
	m_pDC=new CClientDC(this);
	m_pDC->SelectStockObject(NULL_BRUSH); 
    CPen pen, *oldPen;
	pen.CreatePen(PS_SOLID,1,RGB(0,0,0));  
	oldPen = m_pDC->SelectObject(&pen);
	switch(m_nDrawType)
	{
	case 1:
		m_OriginPos=point;
		m_TargetPos=point;
		m_IsDrawing=true;
		break;
	case 2:
		m_OriginPos=point;
		m_TargetPos=point;
		m_IsDrawing=true;
		break;
	case 3:
		m_OriginPos=point;
		m_TargetPos=point;
		m_IsDrawing=true;
		break;
	case 4:
		//如果控制点数大于2，则画控制多边形
		if(m_BezierPointNum>=1)
		{
			m_pDC->SetROP2(R2_COPYPEN);
			m_pDC->MoveTo(m_BezierPoints[m_BezierPointNum].x,m_BezierPoints[m_BezierPointNum].y);   
			m_pDC->LineTo(point.x,point.y);
		}
		//增加新控制点
		m_BezierPointNum++;
		m_BezierPoints[m_BezierPointNum].x=point.x;
		m_BezierPoints[m_BezierPointNum].y=point.y;
		//将控制点放大为圆
        m_pDC->SetROP2(R2_COPYPEN);    
		m_pDC->Ellipse(CRect(point.x-3,point.y-3,point.x+3,point.y+3));
		break;
	case 6:
		m_OriginPos=point;
		m_TargetPos=point;
		m_IsDrawing=true;
		break;
	case 7:
		m_OriginPos=point;
		m_TargetPos=point;
		m_IsDrawing=true;
		break;
	case 8:
		m_handpoints.AddPoint(point);
		m_IsDrawing=true;
		break;
	}
	m_pDC->SelectObject(oldPen);
	delete m_pDC;
	CView::OnLButtonDown(nFlags, point);
}

void CDrawView::OnLButtonUp(UINT nFlags, CPoint point) 
{
	// TODO: Add your message handler code here and/or call default
	CPoint PointBuffer;
	double R;
	switch(m_nDrawType)
	{
	case 1:
		m_IsDrawing=false;
		m_TargetPos=point;
		m_lines.AddLine(m_OriginPos,m_TargetPos);
		RedrawWindow();
		break;
	case 2:
		m_IsDrawing=false;
		m_TargetPos=point;
		m_rects.AddRect(m_OriginPos,m_TargetPos);
		RedrawWindow();
		break;
	case 3:
		m_IsDrawing=false;
		m_TargetPos=point;
		m_ellipses.AddEllipse(m_OriginPos,m_TargetPos);
		RedrawWindow();
		break;
	case 4:
		m_TargetPos=point;
		RedrawWindow();
 		break;	
	case 6:
		m_IsDrawing=false;
		PointBuffer.x=point.x-m_OriginPos.x;
		m_TargetPos.x=m_OriginPos.x+PointBuffer.x;
		m_TargetPos.y=m_OriginPos.y+PointBuffer.x;
		m_rects.AddRect(m_OriginPos,m_TargetPos);
		RedrawWindow();
		break;
	case 7:
		m_IsDrawing=false;
		PointBuffer=m_OriginPos;
		R=point.x-m_OriginPos.x;
		m_OriginPos.x=PointBuffer.x-R*(2^(1/2))/2;
		m_OriginPos.y=PointBuffer.y-R*(2^(1/2))/2;
		m_TargetPos.x=PointBuffer.x+R*(2^(1/2))/2;
		m_TargetPos.y=PointBuffer.y+R*(2^(1/2))/2;
		m_ellipses.AddEllipse(m_OriginPos,m_TargetPos);
		RedrawWindow();
		break;
	case 8:
		m_IsDrawing=false;
		PointBuffer=m_OriginPos;
		RedrawWindow();
		break;
	}
	CView::OnLButtonUp(nFlags, point);
}

void CDrawView::OnCancelMode() 
{
	CView::OnCancelMode();
	// TODO: Add your message handler code here	
}

void CDrawView::OnMouseMove(UINT nFlags, CPoint point) 
{
	// TODO: Add your message handler code here and/or call default
	if(m_IsDrawing==false)
		return;
	CClientDC* m_pDC;
	m_pDC=new CClientDC(this);
	m_pDC->SelectStockObject(NULL_BRUSH);
	CPen pen, *oldPen;
	pen.CreatePen(PS_SOLID,1,RGB(0,0,0));  
	oldPen = m_pDC->SelectObject(&pen);

	CPoint PointBuffer;
	CPoint PointBuffer1;
	CPoint PointBuffer2;
	double R;

	switch(m_nDrawType)
	{
	case 1:   
		m_pDC->SetROP2(R2_NOT);
		m_pDC->MoveTo(m_OriginPos.x,m_OriginPos.y);    
		m_pDC->LineTo(m_TargetPos.x,m_TargetPos.y);     
		m_TargetPos = point;     
		m_pDC->MoveTo(m_OriginPos.x,m_OriginPos.y);    
		m_pDC->LineTo(m_TargetPos.x,m_TargetPos.y);    
		break;
	case 2:  
		m_pDC->SetROP2(R2_NOT);
		m_pDC->Rectangle(CRect(m_OriginPos,m_TargetPos));    
		m_TargetPos = point;     
		m_pDC->Rectangle(CRect(m_OriginPos,m_TargetPos));    
		break;
	case 3: 
		m_pDC->SetROP2(R2_NOT);
		m_pDC->Ellipse(CRect(m_OriginPos,m_TargetPos));    
		m_TargetPos = point;    
		m_pDC->Ellipse(CRect(m_OriginPos,m_TargetPos));    
		break;
	case 4:
		break;
	case 6: 	
		m_pDC->SetROP2(R2_NOT);
		PointBuffer.x=m_TargetPos.x;
		PointBuffer.y=m_OriginPos.y+(m_TargetPos.x-m_OriginPos.x);
		m_pDC->Rectangle(CRect(m_OriginPos,PointBuffer));    
		m_TargetPos = point; 
		PointBuffer.x=m_TargetPos.x;
		PointBuffer.y=m_OriginPos.y+(m_TargetPos.x-m_OriginPos.x);
		m_pDC->Rectangle(CRect(m_OriginPos,PointBuffer));    
		break;
	case 7: 	
		m_pDC->SetROP2(R2_NOT);
		PointBuffer=m_OriginPos;	
		R=point.x-m_OriginPos.x;
		PointBuffer1.x=PointBuffer.x-R*(2^(1/2))/2;
		PointBuffer1.y=PointBuffer.y-R*(2^(1/2))/2;
		PointBuffer2.x=PointBuffer.x+R*(2^(1/2))/2;
		PointBuffer2.y=PointBuffer.y+R*(2^(1/2))/2;
		m_pDC->MoveTo(m_OriginPos.x,m_OriginPos.y);    
		m_pDC->LineTo(m_TargetPos.x,m_TargetPos.y);
		m_pDC->Ellipse(CRect(PointBuffer1,PointBuffer2));

		m_TargetPos = point; 
		
		PointBuffer=m_OriginPos;
		R=point.x-m_OriginPos.x;
		PointBuffer1.x=PointBuffer.x-R*(2^(1/2))/2;
		PointBuffer1.y=PointBuffer.y-R*(2^(1/2))/2;
		PointBuffer2.x=PointBuffer.x+R*(2^(1/2))/2;
		PointBuffer2.y=PointBuffer.y+R*(2^(1/2))/2;
		m_pDC->MoveTo(m_OriginPos.x,m_OriginPos.y);    
		m_pDC->LineTo(m_TargetPos.x,m_TargetPos.y);
		m_pDC->Ellipse(CRect(PointBuffer1,PointBuffer2));   
		break;
	case 8:
		m_handpoints.AddPoint(point);
		m_pDC->SetPixel(point,RGB(255,0,0));
		PointBuffer.x=point.x-1;
		PointBuffer.y=point.y-1;
		m_pDC->SetPixel(point,RGB(255,0,0));
		break;
	}
	m_pDC->SelectObject(oldPen);
	delete m_pDC;
	CView::OnMouseMove(nFlags, point);
}

void CDrawView::OnDrawLine()
{
	// TODO: Add your command handler code here
	m_nDrawType=1;
}

void CDrawView::OnDrawRect() 
{
	// TODO: Add your command handler code here
	m_nDrawType=2;
}

void CDrawView::OnDrawEllipse() 
{
	// TODO: Add your command handler code here
	m_nDrawType=3;
}

void CDrawView::OnDrawBezier()
{
	// TODO: Add your command handler code here
	m_nDrawType=4;
}

void CDrawView::OnDrawBspline() 
{
	// TODO: Add your command handler code here
	m_nDrawType=5;
}

void CDrawView::OnDrawCube() 
{
	// TODO: Add your command handler code here
	m_nDrawType=6;
}
void CDrawView::OnDrawCircle() 
{
	// TODO: Add your command handler code here
	m_nDrawType=7;
}

void CDrawView::OnToolPen() 
{
	// TODO: Add your command handler code here
	m_nDrawType=8;	
}


void CDrawView::DrawBezier(DPoint * p,int n,CClientDC * m_pDC)
{
	
	if (n <= 0) return;
	if((p[n].x < p[0].x+1) && (p[n].x > p[0].x-1) && (p[n].y < p[0].y+1) && (p[n].y > p[0].y-1))
	{
		m_pDC->SetPixel(p[0].x, p[0].y, RGB(0,0,0));
		return;
	}
	DPoint *p1;
	p1 = new DPoint[n+1];
	
	int i, j;
	p1[0] = p[0];
	for(i=1; i<=n; i++)
	{
		for(j=0; j<=n-i;j++)
		{
			p[j].x = (p[j].x + p[j+1].x)/2;
			p[j].y = (p[j].y + p[j+1].y)/2;
		}
		p1[i] = p[0];
	}
	DrawBezier(p,n,m_pDC);
	DrawBezier(p1,n,m_pDC);
	delete p1;
}


void CDrawView::OnRButtonDown(UINT nFlags, CPoint point) 
{
	// TODO: Add your message handler code here and/or call default
	m_nDrawType=0;
	m_BezierPointNum=-1;
	CView::OnRButtonDown(nFlags, point);
}

CLine::CLine()
{
	m_LinesNum=0;
}
CLine::~CLine()
{
}

void CLine::AddLine(CPoint StartPoint, CPoint EndPoint)
{
	m_StartPoint[m_LinesNum]=StartPoint;
	m_EndPoint[m_LinesNum]=EndPoint;
	m_LinesNum++;
	return;
}

void CLine::DrawLine(CClientDC * pDC)
{
	if(m_LinesNum<=0)	
		return;
	
	pDC->SelectStockObject(NULL_BRUSH); 
    CPen pen, *oldPen;
	pen.CreatePen(PS_SOLID,1,RGB(255,0,0));  
	oldPen = pDC->SelectObject(&pen);

	for(int i=0;i<=m_LinesNum-1;i++)
	{
		pDC->SetROP2(R2_COPYPEN);   
		pDC->MoveTo(m_StartPoint[i].x,m_StartPoint[i].y);   
		pDC->LineTo(m_EndPoint[i].x,m_EndPoint[i].y);	
	}
	pDC->SelectObject(oldPen);
	
	return;
}

CHandPoints::CHandPoints()
{
	m_PointsNum=0;
}
CHandPoints::~CHandPoints()
{
}

void CHandPoints::AddPoint(CPoint Point)
{
	m_Point[m_PointsNum]=Point;
	m_PointsNum++;
	return;
}

void CHandPoints::DrawPoint(CClientDC * pDC)
{
	if(m_PointsNum<=0)	
		return;
	
	pDC->SelectStockObject(NULL_BRUSH); 
    CPen pen, *oldPen;
	pen.CreatePen(PS_SOLID,1,RGB(255,0,0));  
	oldPen = pDC->SelectObject(&pen);

	for(int i=0;i<=m_PointsNum-1;i++)
	{
		pDC->SetROP2(R2_COPYPEN);   
		pDC->SetPixel(m_Point[i],RGB(255,0,0));
	}
	pDC->SelectObject(oldPen);
	return;
}

CNewRect::CNewRect()
{
	m_RectsNum=0;
}

void CNewRect::AddRect(CPoint StartPoint, CPoint EndPoint)
{
	m_StartPoint[m_RectsNum]=StartPoint;
	m_EndPoint[m_RectsNum]=EndPoint;
	m_RectsNum++;
	return;
}

void CNewRect::DrawRect(CClientDC *pDC)
{

	if(m_RectsNum<=0)	
		return;
	
	pDC->SelectStockObject(NULL_BRUSH); 
    CPen pen, *oldPen;
	pen.CreatePen(PS_SOLID,1,RGB(255,0,0));  
	oldPen = pDC->SelectObject(&pen);

	for(int i=0;i<=m_RectsNum-1;i++)
	{
		pDC->SetROP2(R2_COPYPEN);   
		pDC->Rectangle(CRect(m_StartPoint[i],m_EndPoint[i]));	
	}
	pDC->SelectObject(oldPen);
	
	return;
}

CEllipse::CEllipse()
{
	m_EllipsesNum=0;
}

void CEllipse::AddEllipse(CPoint StartPoint, CPoint EndPoint)
{
	m_StartPoint[m_EllipsesNum]=StartPoint;
	m_EndPoint[m_EllipsesNum]=EndPoint;
	m_EllipsesNum++;
	return;
}

void CEllipse::DrawEllipse(CClientDC *pDC)
{

	if(m_EllipsesNum<=0)	
		return;
	
	pDC->SelectStockObject(NULL_BRUSH); 
    CPen pen, *oldPen;
	pen.CreatePen(PS_SOLID,1,RGB(255,0,0));  
	oldPen = pDC->SelectObject(&pen);

	for(int i=0;i<=m_EllipsesNum-1;i++)
	{
		pDC->SetROP2(R2_COPYPEN);   
		pDC->Ellipse(CRect(m_StartPoint[i],m_EndPoint[i]));	
	}
	pDC->SelectObject(oldPen);
	
	return;
}
void CDrawView::OnDrawConfig() 
{
	// TODO: Add your command handler code here
	CSetting drawconfig("画图属性");
	drawconfig.DoModal();
}

void CDrawView::OnDdaTest() 
{
	// TODO: Add your command handler code here
	CTestLine my_test;
	my_test.DoModal();
}