vecdrawdoc.cpp

这是一个VC++写的串口通信程序

bool CRectFill::SelectObject(CPoint pnt)
{
	if(IsPoint(pnt)<5)
		return true;
	return false;
}	
void CRectFill::Draw(CDC *pDC,COLORREF color)
{
	m_LineType=0;m_LineWide=0;
	CPen pen(m_LineType,m_LineWide,color);
	CPen  *pOldPen=pDC->SelectObject(&pen);
	CBrush *pOldBrush=(CBrush *)pDC->SelectStockObject(NULL_BRUSH);
	//pDC->SetBkColor(RGB(0,100,0));
	pDC->Rectangle(m_FirstPoint.x,m_FirstPoint.y,m_SecondPoint.x,m_SecondPoint.y);
	pDC->SelectObject(&pOldPen);
	pDC->SelectObject(&pOldBrush);
}
void CRectFill::CurDraw(CDC *pDC,COLORREF color)
{
//	m_ColorPen=color;
//	Draw(pDC);
	if(b_Select==1)
	{
		Draw(pDC,color);
		DrawChoose(pDC,m_FirstPoint,m_SecondPoint,color);
	}
	else
		Draw(pDC,m_ColorPen);
}

double CRectFill::IsPoint(CPoint pnt)
{
	double fw,aa;
	if(((pnt.x>m_FirstPoint.x)&&(pnt.x>m_SecondPoint.x))||((pnt.x<m_FirstPoint.x)&&(pnt.x<m_SecondPoint.x)))
		return 100;
	if(((pnt.y>m_FirstPoint.y)&&(pnt.y>m_SecondPoint.y))||((pnt.y<m_FirstPoint.y)&&(pnt.y<m_SecondPoint.y)))
		return 100;

	fw=0;
	aa=0;
	aa=abs(pnt.x-m_FirstPoint.x);
    fw=aa;
	aa=abs(pnt.y-m_FirstPoint.y);
	if(aa<fw)fw=aa;
	aa=abs(pnt.x-m_SecondPoint.x);
    if(aa<fw)fw=aa;
	aa=abs(pnt.y-m_SecondPoint.y);
	if(aa<fw)fw=aa;
	return fw;
}
void CRectFill::Offset(int x1,int y1)
{
	m_FirstPoint.x+=x1;
	m_FirstPoint.y+=y1;
	m_SecondPoint.x+=x1;
	m_SecondPoint.y+=y1;
}
/////////////////////////////////////////////////////////////////////////////
//RectFill.cpp

IMPLEMENT_SERIAL( CText,CObject,1)
CText::CText(CPoint p1,CString str)
{
	m_Postion=p1;
	m_Str=str;
	m_ColorPen=RGB(0,0,255);
}

CText::CText(CPoint p1,CString str,COLORREF color)
{
	m_Postion=p1;
	m_Str=str;
	m_ColorPen=color;
}
CText::CText(COLORREF ColorPen,int ColorBrush,int LineWide,int LineType,int Layer,int Delete,int ID_Only,CPoint p1,CString str)
{
	CDraw(ColorPen,ColorBrush,LineWide,LineType,Layer,Delete,ID_Only);
	m_Postion=p1;
	m_Str=str;
}
void CText::Serialize(CArchive &ar)
{
	CDraw::Serialize(ar);
	if(ar.IsStoring())
		ar<<m_Postion<<m_Str;
	else
		ar>>m_Postion>>m_Str;
}
bool CText::SelectObject(CPoint pnt)
{
	if(IsPoint(pnt)<5)
		return true;
	return false;
}	
void CText::Draw(CDC *pDC,COLORREF color)
{
	m_ColorPen=RGB(0,0,255);
	m_LineType=0;m_LineWide=0;

	
	CFont MyFont;
	MyFont.CreateFont(16,16,0,0,0,0,0,0,GB2312_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,FIXED_PITCH," ");
	CFont *pOldFont=pDC->SelectObject(&MyFont);
//	pDC->TextOut(0,40,"测试字体");
//	pDC->SetTextColor(m_ColorPen);
//	pDC->SetBkMode(TRANSPARENT);
	pDC->TextOut(m_Postion.x,m_Postion.y,m_Str);
	pDC->SelectObject(pOldFont);
}
void CText::CurDraw(CDC *pDC,COLORREF color)
{
	CPoint P1,P2;
	int width;
	P1.x=m_Postion.x-5;
	P1.y=m_Postion.y-5;

	width=m_Str.GetLength()*16;
    P2.x=m_Postion.x+width+5;
	P2.y=m_Postion.y+16+5;

	if(b_Select==1)
	{
		Draw(pDC,color);
		DrawChoose(pDC,P1,P2,color);
	}
	else
		Draw(pDC,m_ColorPen);

}

double CText::IsPoint(CPoint pnt)
{
	int height,width;
	CPoint P2;
	height=16;
	width=m_Str.GetLength()*16;
    P2.x=m_Postion.x+width;
	P2.y=m_Postion.y+16+2;
	if(pnt.x>m_Postion.x&&pnt.x<P2.x&&pnt.y>m_Postion.y&&pnt.y<P2.y)
		return 0;
	return 100;
}
void CText::Offset(int x1,int y1)
{
	m_Postion.x+=x1;
	m_Postion.y+=y1;
}

// CVecDrawDoc construction/destruction

CVecDrawDoc::CVecDrawDoc()
{
	// TODO: add one-time construction code here

}
void CVecDrawDoc::AddSave(int vT,int vI)
{
	CSave *pSave=new CSave(vT,vI);
	m_SaveArray.Add(pSave);
	SetModifiedFlag();
}
CLine * CVecDrawDoc::AddLine(CPoint P1,CPoint P2)
{
	CLine *pLine=new CLine(P1,P2);
	m_LineArray.Add(pLine);
	return pLine;
}

CLine * CVecDrawDoc::AddLine(CPoint P1,CPoint P2,COLORREF color)
{
	CLine *pLine=new CLine(P1,P2,color);
	m_LineArray.Add(pLine);
	return pLine;
}
CRectAngle * CVecDrawDoc::AddRect(CPoint P1,CPoint P2)
{
	CRectAngle *pRect=new CRectAngle(P1,P2);
	m_RectArray.Add(pRect);
	return pRect;
}

CRectAngle * CVecDrawDoc::AddRect(CPoint P1,CPoint P2,COLORREF color)
{
	CRectAngle *pRect=new CRectAngle(P1,P2,color);
	m_RectArray.Add(pRect);
	return pRect;
}

CCircle * CVecDrawDoc::AddCircle(CPoint P1,int R)
{
	CCircle *pCircle=new CCircle(P1,R);
	m_CircleArray.Add(pCircle);
	return pCircle;
}

CCircle * CVecDrawDoc::AddCircle(CPoint P1,int R,COLORREF color)
{
	CCircle *pCircle=new CCircle(P1,R,color);
	m_CircleArray.Add(pCircle);
	return pCircle;
}
CRectFill * CVecDrawDoc::AddRectFill(CPoint P1,CPoint P2)
{
	CRectFill *pRectFill=new CRectFill(P1,P2);
	m_RectFillArray.Add(pRectFill);
	return pRectFill;
}

CRectFill * CVecDrawDoc::AddRectFill(CPoint P1,CPoint P2,COLORREF color)
{
	CRectFill *pRectFill=new CRectFill(P1,P2,color);
	m_RectFillArray.Add(pRectFill);
	return pRectFill;
}

CText * CVecDrawDoc::AddText(CPoint P1,CString str)
{
	CText *pText=new CText(P1,str);
	m_TextArray.Add(pText);
	return pText;
}

CText * CVecDrawDoc::AddText(CPoint P1,CString str,COLORREF color)
{
	CText *pText=new CText(P1,str,color);
	m_TextArray.Add(pText);
	return pText;
}

int CVecDrawDoc::GetGraphNumb(int vType)
{
	switch(vType)
	{
	case 0:
		return m_SaveArray.GetSize();
	case 1:
		return m_LineArray.GetSize();
		break;
	case 2:
		return m_RectArray.GetSize();
		break;
	case 3:
		return m_CircleArray.GetSize();
		break;	
	case 4:
		return m_RectFillArray.GetSize();
		break;	
	case 8:
		return m_TextArray.GetSize();
		break;	
	default:
		break;
	}
	return 0;
}
int CVecDrawDoc::GetSaveSize()
{
	return m_SaveArray.GetSize();
}
CDraw* CVecDrawDoc::GetGraph(int vType,int Indx)
{
	switch(vType)
	{
	case 0:
		{
			int nn=0;
			nn=GetGraphNumb(0)-1;
			if(Indx<0||Indx>nn)
				return 0;
			return m_SaveArray.GetAt(Indx);
		}		
		break;
	case 1:
		{
			int nn=0;
			nn=GetGraphNumb(1)-1;
			if(Indx<0||Indx>nn)
				return 0;
			return m_LineArray.GetAt(Indx);
		}		
		break;
	case 2:
		{
			int nn=0;
			nn=GetGraphNumb(2)-1;
			if(Indx<0||Indx>nn)
				return 0;
			return m_RectArray.GetAt(Indx);
		}		
		break;
	case 3:
		{
			int nn=0;
			nn=GetGraphNumb(3)-1;
			if(Indx<0||Indx>nn)
				return 0;
			return m_CircleArray.GetAt(Indx);
		}		
		break;	
	case 4:
		{
			int nn=0;
			nn=GetGraphNumb(4)-1;
			if(Indx<0||Indx>nn)
				return 0;
			return m_RectFillArray.GetAt(Indx);
		}		
		break;	
	case 8:
		{
			int nn=0;
			nn=GetGraphNumb(8)-1;
			if(Indx<0||Indx>nn)
				return 0;
			return m_TextArray.GetAt(Indx);
		}		
		break;
	default:
		break;
	}
    return 0;
}
void CVecDrawDoc::DeleteSave(int vType,int Indx)
{
	int vT,vI,nn;
	nn=GetSaveSize();
	for(int i=0;i<nn;i++)
	{
		vT=GetSaveOrder(i)->GetType();
		vI=GetSaveOrder(i)->GetIndex();
		if((vType==vT)&&(Indx==vI))
		{
			delete	m_SaveArray.GetAt(i);
			m_SaveArray.RemoveAt(i);			
		}
	}	
}

CSave* CVecDrawDoc::GetSaveOrder(int index)
{
			int nn=0;
			nn=m_SaveArray.GetSize();
			nn-=1;
			if(index<0||index>nn)
				return 0;
			return m_SaveArray.GetAt(index);
}
/*
void CVecDrawDoc::Draw(CDC *pDC,int vType)
{
	switch(vType)
	{
	case 1:
		{
			int nn=m_LineArray.GetSize();
			while(nn--)
				GetGraph(nn,1)->Draw(pDC);
		}
		break;
	case 2:
		{
			int nn=m_RectArray.GetSize();
			while(nn--)
				GetGraph(nn,2)->Draw(pDC);
		}
		break;
	case 3:
		{
			int nn=m_RectArray.GetSize();
			while(nn--)
				GetGraph(nn,3)->Draw(pDC);
		}
		break;	
	default:
		break;
	}
}
*/
void CVecDrawDoc::Draw(CDC *pDC,int vType,int vIndex)
{
	COLORREF color=GetGraph(vType,vIndex)->GetColor();
	GetGraph(vType,vIndex)->Draw(pDC,color);
}


CVecDrawDoc::~CVecDrawDoc()
{
}

BOOL CVecDrawDoc::OnNewDocument()
{
	if (!CDocument::OnNewDocument())
		return FALSE;

	// TODO: add reinitialization code here
	// (SDI documents will reuse this document)

	return TRUE;
}
void CVecDrawDoc::SetMode(CDC *pDC)
{
//	pDC->SetMapMode(MM_TWIPS);
}

/////////////////////////////////////////////////////////////////////////////
// CVecDrawDoc serialization

void CVecDrawDoc::Serialize(CArchive& ar)
{
	if (ar.IsStoring())
	{
		// TODO: add storing code here
	}
	else
	{
		// TODO: add loading code here
		
	}
	m_SaveArray.Serialize(ar);
	m_LineArray.Serialize(ar);
	m_RectArray.Serialize(ar);
	m_CircleArray.Serialize(ar);
//	m_RectRoundArray.Serialize(ar);
	m_RectFillArray.Serialize(ar);
//	m_RectRoundFillArray.Serialize(ar);
//	m_CircleFillArray.Serialize(ar);	
	m_TextArray.Serialize(ar);
}

/////////////////////////////////////////////////////////////////////////////
// CVecDrawDoc diagnostics

#ifdef _DEBUG
void CVecDrawDoc::AssertValid() const
{
	CDocument::AssertValid();
}

void CVecDrawDoc::Dump(CDumpContext& dc) const
{
	CDocument::Dump(dc);
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CVecDrawDoc commands