www.pudn.com > ³Â½¨´ºVC¿ª·¢GISµÄÔ´Âë.rar > drawDoc.cpp, change:2003-03-07,size:76751b

// DrawDoc.cpp : implementation of the CDrawDoc class 
// 
#include <float.h> 
#include "stdafx.h" 
#include "Draw.h" 
#include <float.h> 
#include <math.h> 
#include "DrawDoc.h" 
#include "Drawview.h" 
#include "CntrItem.h" 
#ifdef _DEBUG 
#define new DEBUG_NEW 
#undef THIS_FILE 
static char THIS_FILE[] = __FILE__; 
#endif 
CGraphPara *p_GraphPara;	//³õÊÔ»¯Ò»¸ö¹«ÓõĹØÓÚͼÐβÎÊýµÄʵÀý 
extern CDrawView *p_View; 
extern CMemFile pFile; 
float xMinScreen,yMinScreen,xMaxScreen,yMaxScreen; 
int RunTimes=0; 
extern BOOL b_Draw; 
void DPtoVP(float x,float y,int *X,int *Y); 
void VPtoDP(int x,int y,float *X,float *Y); 
int DLtoVL(float l); 
float VLtoDL(int l); 
 
BOOL IsRectCross(float minx,float miny,float maxx,float maxy); 
BOOL IsRectCross(float minx,float miny,float maxx,float maxy) 
{ 
	if(minx>xMaxScreen||maxx<xMinScreen||miny>yMaxScreen||maxy<yMinScreen) //Á½¸ö¾ØÐÎÇøÓò²»Ïཻ 
		return 0; //Èç²»Ïཻº¯Êý·µ»Ø0 
	else  
		return 1; //Èç¹ûÏཻ¾Í·µ»Ø1 
} 
 
void DPtoVP(float x,float y,int *X,int *Y) 
{ 
	p_View->DPtoVP(x,y,X,Y); 
} 
 
void VPtoDP(int x,int y,float *X,float *Y) 
{ 
	p_View->VPtoDP(x,y,X,Y); 
} 
				  
int DLtoVL(float l) 
{ 
	return p_View->DLtoVL(l); 
} 
 
float VLtoDL(int l) 
{ 
	return p_View->VLtoDL(l); 
} 
 
	///////////////////////////////////////////////////////////////////////////// 
// CDrawDoc 
 
IMPLEMENT_DYNCREATE(CDrawDoc, COleDocument) 
 
BEGIN_MESSAGE_MAP(CDrawDoc, COleDocument) 
	//{{AFX_MSG_MAP(CDrawDoc) 
	ON_UPDATE_COMMAND_UI(ID_SELECT_CLEAR, OnUpdateSelectClear) 
	ON_UPDATE_COMMAND_UI(ID_EDIT_UNDO, OnUpdateEditUndo) 
	ON_UPDATE_COMMAND_UI(ID_SELECT_DELETE, OnUpdateSelectClear) 
	ON_UPDATE_COMMAND_UI(ID_EDIT_CUT, OnUpdateSelectClear) 
	ON_UPDATE_COMMAND_UI(ID_EDIT_COPY, OnUpdateSelectClear) 
	ON_COMMAND(IDC_TEST, OnTest) 
	//}}AFX_MSG_MAP 
	// Enable default OLE container implementation 
	ON_UPDATE_COMMAND_UI(ID_EDIT_PASTE, COleDocument::OnUpdatePasteMenu) 
	ON_UPDATE_COMMAND_UI(ID_EDIT_PASTE_LINK, COleDocument::OnUpdatePasteLinkMenu) 
	ON_UPDATE_COMMAND_UI(ID_OLE_EDIT_CONVERT, COleDocument::OnUpdateObjectVerbMenu) 
	ON_COMMAND(ID_OLE_EDIT_CONVERT, COleDocument::OnEditConvert) 
	ON_UPDATE_COMMAND_UI(ID_OLE_EDIT_LINKS, COleDocument::OnUpdateEditLinksMenu) 
	ON_COMMAND(ID_OLE_EDIT_LINKS, COleDocument::OnEditLinks) 
	ON_UPDATE_COMMAND_UI(ID_OLE_VERB_FIRST, COleDocument::OnUpdateObjectVerbMenu) 
END_MESSAGE_MAP() 
 
///////////////////////////////////////////////////////////////////////////// 
// CDrawDoc construction/destruction 
 
CDrawDoc::CDrawDoc() 
{ 
 
b_IsOleSelect=0; 
	p_GraphPara=&m_GraphPara;	//½«¹«ÓõÄGraphParaÀàµÄÖ¸ÕëÖ¸Ïòµ±Ç°ÎĵµµÄGraphPara¶ÔÏó 
	n_GraphSelect=0; 
	GraphSelect=new GraphSelectStruct[2000];	//×î¶à¿ÉÑ¡ÖÐ2000¸öͼÐÎÔªËØ 
	n_MaxUnIndex=10000;	//¹æ¶¨¿ÉÒÔ½øÐÐ1Íò²½µÄÄæ²Ù×÷ 
	m_UndoList=new UndoStruct[n_MaxUnIndex];	 
	m_UndoList[0].l_Start=0; 
	char p1[4]; 
	sprintf(p1,"%d",RunTimes); 
	FileName="c:\\draw"; 
	FileName+=p1; 
	FileName+=".tmp"; 
	Fundo.Open(FileName,CFile::modeCreate|CFile::modeReadWrite|CFile::typeBinary); 
	RunTimes++; 
	n_CurUnIndex=0;		//µ±Ç°µÄÄæ²Ù×÷ÐòºÅΪ0 
	EnableCompoundFile(); 
	m_Index=new int[20000]; 
	m_MaxScreen=1000;		//×î¶àÄܹ»¼Ç¼ÔÚ100¸öÀúÊ·ÆÁÄ» 
	m_Screen=new ScreenStruct[m_MaxScreen];//¸ø¼Ç¼ÀúÊ·ÆÁÄ»µÄÊý×é·ÖÅä¿Õ¼ä 
	//ÒÔÏÂÉèÖÃÊ×ÆÁµÄ²ÎÊý²¢½«Ä¿Ç°ÆÁÄ»ÉèÖÃΪÊ×ÆÁ 
	m_CurrentScreen=0; 
	m_Screen[0].sx=0; 
	m_Screen[0].sy=0; 
	m_Screen[0].blc=1; 
	 
	strcpy(DataInfo[0].Name,"³ÇÊÐÐÅÏ¢"); 
	DataInfo[0].only_ID=1; 
	strcpy(DataInfo[1].Name,"Á¬½ÓÐÅÏ¢"); 
	DataInfo[1].only_ID=2; 
	m_NumbData=2;	 
} 
 
CDrawDoc::~CDrawDoc() 
{ 
	delete GraphSelect; 
	delete m_UndoList; 
	delete m_Index; 
	delete m_Screen; 
	Fundo.Close(); 
	remove(FileName); 
} 
 
//»æÖÆÑ¡ÖеÄͼÐÎÔªËØ 
//Lb-ͼÐÎÀà±ð Index-»æÖÆͼÐεÄÐòÁкŠMode-»æÖƸ²¸Çģʽ Mode1-»æÖÆ·½Ê½ 
void CDrawDoc::DrawGraph(CDC* pDC,int Lb,int Index,int Mode,int Mode1,short BackColor) 
{ 
	if(Lb==1)		//Èç¹ûÊÇÖ±Ïß 
		GetLine(Index)->Draw(pDC,Mode,Mode1,BackColor); 
	else if(Lb==2)	//Èç¹ûÊÇÁ¬ÐøÖ±Ïß 
		GetPLine(Index)->Draw(pDC,Mode,Mode1,BackColor); 
	else if(Lb==3)	//Èç¹ûÔ² 
		GetCircle(Index)->Draw(pDC,Mode,Mode1,BackColor); 
	else if(Lb==4)	//Èç¹ûÊÇÔ²»¡ 
		GetArc(Index)->Draw(pDC,Mode,Mode1,BackColor); 
	else if(Lb==5)	//Èç¹ûÊDZê×¢ÎÄ×Ö 
		GetText(Index)->Draw(pDC,Mode,Mode1,BackColor); 
} 
 
void CDrawDoc::Draw(CDC *pDC,int m_DrawMode,int m_DrawMode1,short BackColor) 
{ 
	int nn=GetNumbLines();//µÃµ½Ö±ÏßµÄÊýÄ¿	 
	while(b_Draw&&nn--)					//»æÖÆËùÓÐÖ±Ïß 
		GetLine(nn)->Draw(pDC,m_DrawMode,m_DrawMode1,BackColor); 
	nn=GetNumbPLines();	//µÃµ½Á¬ÐøÖ±ÏߺͶà±ßÐÎÇøÓòÊýÄ¿ 
	while(b_Draw&&nn--)					//»æÖÆËùÓÐÁ¬ÐøÖ±ÏߺͶà±ßÐÎÇøÓò 
		GetPLine(nn)->Draw(pDC,m_DrawMode,m_DrawMode1,BackColor); 
	nn=GetNumbCircles();	//µÃµ½Ô²µÄÊýÄ¿ 
	while(b_Draw&&nn--)					//»æÖÆËùÓÐÔ² 
		GetCircle(nn)->Draw(pDC,m_DrawMode,m_DrawMode1,BackColor); 
	nn=GetNumbArcs();		//µÃµ½Ô²»¡µÄÊýÄ¿ 
	while(b_Draw&&nn--)					//»æÖÆËùÓÐÔ²»¡ 
		GetArc(nn)->Draw(pDC,m_DrawMode,m_DrawMode1,BackColor); 
	nn=GetNumbTexts();	//µÃµ½Îı¾µÄÊýÄ¿ 
	while(b_Draw&&nn--)					//»æÖÆËùÓÐÎı¾ 
		GetText(nn)->Draw(pDC,m_DrawMode,m_DrawMode1,BackColor); 
	for(int i=0;i<n_GraphSelect;i++)	 
		DrawGraph(pDC,GraphSelect[i].Lb,GraphSelect[i].Index,0,1,BackColor); 
} 
 
BOOL CDrawDoc::OnNewDocument() 
{ 
	if (!COleDocument::OnNewDocument()) 
		return FALSE; 
	return TRUE; 
} 
 
///////////////////////////////////////////////////////////////////////////// 
// CDrawDoc serialization 
 
/* 
void CDrawDoc::Serialize(CArchive& ar) 
{ 
	if (ar.IsStoring()) 
	{ 
		// TODO: add storing code here 
	} 
	else 
	{ 
		//line1=new CLine	(0,0,0,0,0,0,0,0,100,100); 
//		ar>>line1; 
		// TODO: add loading code here 
	} 
	int nn=m_LineArray.GetSize(); 
	while(nn--) 
	{ 
		if(m_LineArray.GetAt(nn)->IsDelete()) 
		{	 
			delete m_LineArray.GetAt(nn); 
			m_LineArray.RemoveAt(nn); 
		} 
	} 
	nn=m_PLineArray.GetSize(); 
	while(nn--) 
	{ 
		if(m_PLineArray.GetAt(nn)->IsDelete()) 
		{ 
			delete m_PLineArray.GetAt(nn); 
			m_PLineArray.RemoveAt(nn);			 
		} 
	} 
	nn=m_CircleArray.GetSize(); 
	while(nn--) 
	{ 
		if(m_CircleArray.GetAt(nn)->IsDelete()) 
		{ 
			delete m_CircleArray.GetAt(nn); 
			m_CircleArray.RemoveAt(nn); 
		} 
	} 
	nn=m_ArcArray.GetSize(); 
	while(nn--) 
	{ 
		if(m_ArcArray.GetAt(nn)->IsDelete()) 
		{ 
			delete m_ArcArray.GetAt(nn); 
			m_ArcArray.RemoveAt(nn); 
		} 
	} 
	nn=m_TextArray.GetSize(); 
	while(nn--) 
	{ 
		if(m_TextArray.GetAt(nn)->IsDelete()) 
		{ 
			delete m_TextArray.GetAt(nn); 
			m_TextArray.RemoveAt(nn);		 
		} 
	} 
	m_LineArray.Serialize(ar); 
	m_PLineArray.Serialize(ar); 
	m_CircleArray.Serialize(ar); 
	m_ArcArray.Serialize(ar); 
	m_TextArray.Serialize(ar); 
	n_CurUnIndex=0; 
	SetModifiedFlag(0); 
	// Calling the base class COleDocument enables serialization 
	//  of the container document's COleClientItem objects. 
	COleDocument::Serialize(ar); 
} 
*/ 
 
void CDrawDoc::Serialize(CArchive& ar) 
{ 
	CFile *file1; 
	int n_LineNumb,n_PLineNumb,n_CircleNumb,n_ArcNumb,n_TextNumb; 
	file1=ar.GetFile(); 
	if (ar.IsStoring()) 
	{ 
		int nn=m_LineArray.GetUpperBound()+1; 
		while(nn--) 
		{ 
			if(m_LineArray.GetAt(nn)->IsDelete()) 
			{	 
				delete m_LineArray.GetAt(nn); 
				m_LineArray.RemoveAt(nn); 
			} 
		} 
		nn=m_PLineArray.GetUpperBound()+1; 
		while(nn--) 
		{ 
			if(m_PLineArray.GetAt(nn)->IsDelete()) 
			{ 
				delete m_PLineArray.GetAt(nn); 
				m_PLineArray.RemoveAt(nn);			 
			} 
		} 
		nn=m_CircleArray.GetUpperBound()+1; 
		while(nn--) 
		{ 
			if(m_CircleArray.GetAt(nn)->IsDelete()) 
			{ 
				delete m_CircleArray.GetAt(nn); 
				m_CircleArray.RemoveAt(nn); 
			} 
		} 
		nn=m_ArcArray.GetUpperBound()+1; 
		while(nn--) 
		{ 
			if(m_ArcArray.GetAt(nn)->IsDelete()) 
			{ 
				delete m_ArcArray.GetAt(nn); 
				m_ArcArray.RemoveAt(nn); 
			} 
		} 
		nn=m_TextArray.GetUpperBound()+1; 
		while(nn--) 
		{ 
			if(m_TextArray.GetAt(nn)->IsDelete()) 
			{ 
				delete m_TextArray.GetAt(nn); 
				m_TextArray.RemoveAt(nn);		 
			} 
			// TODO: add storing code here 
		} 
		n_LineNumb=m_LineArray.GetSize(); 
		n_PLineNumb=m_PLineArray.GetSize(); 
		n_CircleNumb=m_CircleArray.GetSize(); 
		n_ArcNumb=m_ArcArray.GetSize(); 
		n_TextNumb=m_TextArray.GetSize(); 
		file1->Write((unsigned char *)&n_LineNumb,sizeof(int)); 
		file1->Write((unsigned char *)&n_PLineNumb,sizeof(int)); 
		file1->Write((unsigned char *)&n_CircleNumb,sizeof(int)); 
		file1->Write((unsigned char *)&n_ArcNumb,sizeof(int)); 
		file1->Write((unsigned char *)&n_TextNumb,sizeof(int)); 
		if(n_LineNumb>0) 
		{ 
			nn=m_LineArray.GetUpperBound()+1; 
			while(nn--) 
			{ 
				if(m_LineArray.GetAt(nn)) 
					GetLine(nn)->Save(file1,1); 
			} 
		} 
		if(n_PLineNumb>0) 
		{ 
			nn=m_PLineArray.GetUpperBound()+1; 
			while(nn--) 
			{ 
				if(m_PLineArray.GetAt(nn)) 
					GetPLine(nn)->Save(file1,1); 
			} 
		} 
		if(n_CircleNumb>0) 
		{ 
			nn=m_CircleArray.GetUpperBound()+1; 
			while(nn--) 
			{ 
				if(m_CircleArray.GetAt(nn)) 
					GetCircle(nn)->Save(file1,1); 
			} 
		} 
		if(n_ArcNumb>0) 
		{ 
			nn=m_ArcArray.GetUpperBound()+1; 
			while(nn--) 
			{ 
				if(m_ArcArray.GetAt(nn)) 
					GetArc(nn)->Save(file1,1); 
			} 
		} 
		if(n_TextNumb>0) 
		{ 
			nn=m_TextArray.GetUpperBound(); 
			while(nn--) 
			{ 
				if(m_TextArray.GetAt(nn)) 
					GetText(nn)->Save(file1,1); 
			} 
		} 
	} 
	else 
	{ 
		file1->Read((unsigned char *)&n_LineNumb,sizeof(int)); 
		file1->Read((unsigned char *)&n_PLineNumb,sizeof(int)); 
		file1->Read((unsigned char *)&n_CircleNumb,sizeof(int)); 
		file1->Read((unsigned char *)&n_ArcNumb,sizeof(int)); 
		file1->Read((unsigned char *)&n_TextNumb,sizeof(int)); 
		for(int i=0;i<n_LineNumb;i++) 
		{ 
			CLine* p_Line=new CLine(); 
			p_Line->Save(file1,0); 
			m_LineArray.Add(p_Line); 
		} 
 
		for(i=0;i<n_PLineNumb;i++) 
		{ 
			CPline* p_PLine=new CPline(); 
			p_PLine->Save(file1,0); 
			m_PLineArray.Add(p_PLine); 
		} 
		for(i=0;i<n_CircleNumb;i++) 
		{ 
			CCircle* p_Circle=new CCircle(); 
			p_Circle->Save(file1,0); 
			m_CircleArray.Add(p_Circle); 
		} 
		for(i=0;i<n_ArcNumb;i++) 
		{ 
			CArc* p_Arc=new CArc(); 
			p_Arc->Save(file1,0); 
			m_ArcArray.Add(p_Arc); 
		} 
		for(i=0;i<n_TextNumb;i++) 
		{ 
			CText* p_Text=new CText(); 
			p_Text->Save(file1,0); 
			m_TextArray.Add(p_Text); 
		} 
	 
		// TODO: add loading code here 
	} 
	SetModifiedFlag(0);	 
	n_CurUnIndex=0; 
	COleDocument::Serialize(ar); 
} 
 
 
CLine* CDrawDoc::AddLine(short ColorPen,short ColorBrush,short LineWide,short LineType,short Layer,int id_only,float X1,float Y1,float X2,float Y2) 
{ 
	CLine* p_Line=new CLine(ColorPen,ColorBrush,LineWide,LineType,Layer,id_only,0,X1,Y1,X2,Y2); 
	m_LineArray.Add(p_Line); 
	return p_Line; 
} 
 
CLine* CDrawDoc::AddLine() 
{ 
	CLine* p_Line=new CLine(); 
	m_LineArray.Add(p_Line); 
	return p_Line; 
} 
 
CLine * CDrawDoc::GetLine(int Index) 
{ 
	if(Index<0||Index>m_LineArray.GetUpperBound()) 
		return 0; 
	return m_LineArray.GetAt(Index); 
 
} 
 
int CDrawDoc::GetNumbLines() 
{ 
	return m_LineArray.GetSize(); 
} 
 
CPline* CDrawDoc::AddPLine(short ColorPen,short ColorBrush,short LineWide,short LineType,short Layer,int id_only,int Numble,PointStruct* PointList,BOOL Fill) 
{ 
	CPline* p_Pline=new CPline(ColorPen,ColorBrush,LineWide,LineType,Layer,id_only,0,Numble,PointList,Fill); 
	m_PLineArray.Add(p_Pline); 
	return p_Pline; 
} 
 
CPline* CDrawDoc::AddPLine() 
{ 
	CPline* p_Pline=new CPline(); 
	m_PLineArray.Add(p_Pline); 
	return p_Pline; 
} 
 
CPline* CDrawDoc::GetPLine(int Index) 
{ 
	if(Index<0||Index>m_PLineArray.GetUpperBound()) 
		return 0; 
	return m_PLineArray.GetAt(Index); 
} 
 
int CDrawDoc::GetNumbPLines() 
{ 
	return m_PLineArray.GetSize(); 
} 
 
CCircle* CDrawDoc::AddCircle(short ColorPen,short ColorBrush,short LineWide,short LineType,short Layer,int id_only,float CircleX,float CircleY,float CircleR,BOOL Fill) 
{	 
	CCircle* p_Circle=new CCircle(ColorPen,ColorBrush,LineWide,LineType,Layer,id_only,0,CircleX,CircleY,CircleR,Fill); 
	m_CircleArray.Add(p_Circle); 
	return p_Circle; 
} 
 
CCircle* CDrawDoc::AddCircle() 
{	 
	CCircle* p_Circle=new CCircle(); 
	m_CircleArray.Add(p_Circle); 
	return p_Circle; 
} 
 
CCircle* CDrawDoc::GetCircle(int Index) 
{ 
	if(Index<0||Index>m_CircleArray.GetUpperBound()) 
		return 0; 
	return m_CircleArray.GetAt(Index); 
} 
 
int CDrawDoc::GetNumbCircles() 
{ 
	return m_CircleArray.GetSize(); 
} 
 
CArc* CDrawDoc::AddArc(short ColorPen,short ColorBrush,short LineWide,short LineType,short Layer,int id_only,float CircleX,float CircleY,float CircleR,BOOL Fill,float Angle1,float Angle2)	 
{ 
	CArc* p_Arc=new CArc(ColorPen,ColorBrush,LineWide,LineType,Layer,id_only,0,CircleX,CircleY,CircleR,Fill,Angle1,Angle2); 
	m_ArcArray.Add(p_Arc); 
	return p_Arc; 
} 
 
CArc* CDrawDoc::AddArc() 
{ 
	CArc* p_Arc=new CArc(); 
	m_ArcArray.Add(p_Arc); 
	return p_Arc; 
} 
 
int CDrawDoc::GetNumbArcs() 
{ 
	return m_ArcArray.GetSize(); 
} 
 
CText* CDrawDoc::AddText(short ColorPen,short ColorBrush,short LineWide,short LineType,short Layer,int id_only,float StartX,float StartY,float Angle1,float Angle2,float TextHeight,float TextWide,float OffWide,unsigned char TextFont,int TextLong,CString Text) 
{ 
	CText* p_Text=new CText(ColorPen,ColorBrush,LineWide,LineType,Layer,id_only,0,StartX,StartY,Angle1,Angle2,TextHeight,TextWide,OffWide,0,Text); 
	m_TextArray.Add(p_Text); 
	return p_Text; 
} 
 
CText* CDrawDoc::AddText() 
{ 
	CText* p_Text=new CText(); 
	m_TextArray.Add(p_Text); 
	return p_Text; 
} 
 
CText* CDrawDoc::GetText(int Index) 
{ 
	if(Index<0||Index>m_TextArray.GetUpperBound()) 
		return 0; 
	return m_TextArray.GetAt(Index); 
} 
 
int CDrawDoc::GetNumbTexts() 
{ 
	return m_TextArray.GetSize(); 
} 
 
//ÔÚÀúÊ·ÆÁÄ»ÖÐÔö¼ÓÒ»¸öÆÁÄ»£¬ÒÔ¹©ÆÁÄ»»ØËݲÙ×÷ 
//(StartX,StartY)ÆÁÄ»Æðµã£¬blcΪÆÁÄ»µÄ±ÈÀý³ß 
void CDrawDoc::AddScreen(float StartX,float StartY,float blc) 
{ 
	int i; 
	if(m_CurrentScreen==m_MaxScreen)//Èç¹ûµ±Ç°ÆÁÄ»ÔÚ50ÆÁÉÏ£¬¼´Ã»ÓÐÊý×é¿Õ¼äÔÙ´æÐÅÏ¢ 
	{ 
		//½«Êý×é×ö¶Ñʽ¹ö¶¯½«µÚ¶þÆÁÈ¥µô£¨screenxy[0]Öд洢µÄÊÇÊ×ÆÁÐÅÏ¢£¬²Ù×÷ʱ²»¸Ä±ä) 
		for(i=1;i<m_MaxScreen-1;i++) 
			m_Screen[i]=m_Screen[i+1]; 
	} 
	else    //Èç¹û²»ÊÇ×î´óÆÁ,ÆÁÄ»¼Ç¼ºÅÔö¼Ó1 
		m_CurrentScreen++; 
	//¼Ç¼Ï±¾ÆÁÄ»µÄ²ÎÊý 
	m_Screen[m_CurrentScreen].sx=StartX; 
	m_Screen[m_CurrentScreen].sy=StartY; 
	m_Screen[m_CurrentScreen].blc=blc; 
} 
 
///////////////////////////////////////////////////////////////////////////// 
// CDrawDoc diagnostics 
 
#ifdef _DEBUG 
void CDrawDoc::AssertValid() const 
{ 
	COleDocument::AssertValid(); 
} 
 
void CDrawDoc::Dump(CDumpContext& dc) const 
{ 
	COleDocument::Dump(dc); 
} 
#endif //_DEBUG 
 
COLORREF CGraphPara::GetColor(int n) 
{ 
	return m_ColorList[n]; //·µ»ØµÚnÖÖÑÕÉ«µÄʵ¼ÊÖµ 
} 
 
BOOL CGraphPara::GetDisplayStatue(int n) 
{ 
	return m_LayerList[n].b_Display; 
} 
 
//¼ÆËãµã(x1,y1)Óëµã(x2,y2)¼äµÄ¾àÀë 
float CDraw::CalDisp(float x1,float y1,float x2,float y2) 
{ 
	return (float)sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)); 
} 
 
//×÷Ó㺼ÆËãµã£¨xx,yy)µ½Ï߶Σ¨x1,y1)(x2,y2)µÄ¾àÀ룬·µ»Ø¼ÆËãµÄ¾àÀëÖµ 
float CDraw::PointLine(float xx,float yy,float x1,float y1,float x2,float y2) 
{ 
	float a,b,c,ang1,ang2,ang; 
    //¼ÆËãÈýÌõ±ßµÄ¾àÀë 
    a=CalDisp(x1,y1,xx,yy);if(a==0.0)return 0.0; 
    b=CalDisp(x2,y2,xx,yy);if(b==0.0)return 0.0; 
    c=CalDisp(x1,y1,x2,y2); 
    //Èç¹û£¨x1,y1)ºÍ(x2,y2)ÊÇÒ»¸öµãÖ±½Ó·µ»Ø¾àÀë 
    if(c==0.0) return a; 
	if(a<b) //Èç¹û(xx,yy)µÄµã(x1,y1£©ÕâÌõ±ß½Ï¶Ì 
	{ 
		if(y1==y2) 
		{ 
			if(x1<x2) 
				ang1=0; 
			else 
				ang1=(float)pi; 
		} 
		else 
		{ 
			ang1=(float)acos((x2-x1)/c); 
			if(y1>y2)ang1=(float)pi*2-ang1;  //Ö±Ïß(x1,y1)-(x2,y2)µÄ»¡¶È 
		} 
		ang2=(float)acos((xx-x1)/a); 
		if(y1>yy)ang2=(float)pi*2-ang2;  //Ö±Ïß(x1,y1)-(xx,yy)µÄ»¡¶È 
		ang=ang2-ang1; 
		if(ang<0)ang=-ang; 
		if(ang>pi) ang=(float)pi*2-ang;  //½»½ÇµÄ´óС 
		if(ang>pi/2) return a;    //Èç¹ûΪ¶Û½Ç£¬Ö±½Ó·µ»Ø¾àÀë 
		else  
			return (a*(float)sin(ang)); //·ñÔò·µ»Ø¼ÆËãµÃµ½µÄ¾àÀë  
	} 
	else //Èç¹û(xx,yy)µÄµã(x2,y2£©ÕâÌõ±ß½Ï¶Ì 
	{ 
		if(y1==y2) 
		{ 
			if(x1<x2) 
				ang1=(float)pi; 
			else 
				ang1=0; 
		} 
		else 
		{ 
			ang1=(float)acos((x1-x2)/c);     //Ö±Ïߣ¨x2,y2)-(x1,y1)µÄбÂʵĻ¡¶È 
			if(y2>y1)ang1=(float)pi*2-ang1; 
		} 
		ang2=(float)acos((xx-x2)/b);     //Ö±Ïߣ¨x2,x1£©-(xx,yy)µÄбÂʵĻ¡¶È 
		if(y2>yy)ang2=(float)pi*2-ang2; 
		ang=ang2-ang1; 
		if(ang<0) ang=-ang; 
		if(ang>pi) ang=(float)pi*2-ang;  //½»½ÇµÄ´óС Ç
 
		if(ang>pi/2)  return b;   //Èç¹ûΪ¶Û½Ç£¬Ö±½Ó·µ»Ø¾àÀë 
		else  
			return(b*(float)sin(ang));  //·ñÔò·µ»Ø¼ÆËãµÃµ½µÄ¾àÀë 
	} 
} 
 
//º¯ÊýPointRgn×÷ÓãºÅжÏÒ»¸öµãÊÇ·ñÔÚÈÎÒâ¶à±ßÐÎÇøÓòÄÚ 
//²ÎÊý£ºNumble-±ß½çµãÊý£¬x,yÊǵãµÄ×ø±ê£¬¶à±ßÐζ¥µãµÄ×ø±êÔڽṹÊý×éPointListÖÐ 
//·µ»Ø£º1-µãÔÚ¶à±ßÐÎÇøÓò0-²»ÔÚ 
BOOL CDraw::PointRgn(float x,float y,int Numble,PointStruct *PointList,float blc) 
{ 
	CRgn rgn;         //¶¨ÒåÒ»¸öCRgn¶ÔÏó 
	int x1,y1,i; 
	CPoint bbcc[500]; 
	//POINT* bbcc;      // ¶¨ÒåÒ»¸öµã½á¹¹Ö¸Õë 
	if(Numble<3)  
		return 0;//Èç¹ûµãµÄÊýÄ¿<3¼´²»ÊÇÒ»¸öÇøÓò·µ»Ø²»³É¹¦±êÖ¾ 
	//bbcc=new POINT[Numble+1]; //·ÖÅäsm¸öµã 
	//½«µãµÄ×ø±êת±ä³ÉÆÁÄ»×ø±ê 
	x1=(int)(x/blc); 
	y1=(int)(y/blc); 
	//½«·â±ÕÇøÓò¸÷µãµÄ×ø±êת³ÉÆÁÄ»×ø±ê 
	for(i=0;i<Numble;i++) 
	{ 
		bbcc[i].x=(int)((PointList[i].x)/blc); 
		bbcc[i].y=(int)((PointList[i].y)/blc); 
	} 
	rgn.CreatePolygonRgn(bbcc,Numble,1);//³õÊÔ»¯Ò»¸ö¶à±ßÐÎÇøÓò 
	i=(rgn.PtInRegion(x1,y1)!=0);		//Èç¹ûÔÚÇøÓòÄÚj=1,·ñÔòj=0; 
	rgn.DeleteObject();					//ɾ³ý¶¨ÒåµÄrgn¶ÔÏó 
	//delete bbcc; 
	return i; 
} 
 
 
void CDraw::Delete(BOOL Is) 
{ 
	if(Is) 
		b_Delete=TRUE; 
	else 
		b_Delete=FALSE; 
} 
 
BOOL CDraw::IsDelete() 
{ 
	return b_Delete; 
} 
 
int CDraw::GetID() 
{ 
	return m_id_only; 
} 
 
void CDraw::Serialize(CArchive& ar) 
{ 
	if(ar.IsStoring()) 
	{ 
		ar<<b_Delete<<m_ColorPen<<m_ColorBrush<<m_LineWide<<m_LineType<<m_Layer<<m_id_only; 
	} 
	else 
	{ 
		ar>>b_Delete>>m_ColorPen>>m_ColorBrush>>m_LineWide>>m_LineType>>m_Layer>>m_id_only; 
	} 
} 
 
void CDraw::Save(CFile* file,BOOL Yn) 
{ 
	if(Yn)	//Èç¹ûÊÇÔÚ½øÐб£´æ 
	{ 
		file->Write((unsigned char *)&m_ColorPen,sizeof(m_ColorPen)); 
		file->Write((unsigned char *)&m_ColorBrush,sizeof(m_ColorBrush)); 
		file->Write((unsigned char *)&m_LineWide,sizeof(m_LineWide)); 
		file->Write((unsigned char *)&m_LineType,sizeof(m_LineType)); 
		file->Write((unsigned char *)&m_Layer,sizeof(m_Layer)); 
		file->Write((unsigned char *)&b_Delete,sizeof(b_Delete)); 
	} 
	else 
	{ 
		file->Read((unsigned char *)&m_ColorPen,sizeof(m_ColorPen)); 
		file->Read((unsigned char *)&m_ColorBrush,sizeof(m_ColorBrush)); 
		file->Read((unsigned char *)&m_LineWide,sizeof(m_LineWide)); 
		file->Read((unsigned char *)&m_LineType,sizeof(m_LineType)); 
		file->Read((unsigned char *)&m_Layer,sizeof(m_Layer)); 
		file->Read((unsigned char *)&b_Delete,sizeof(b_Delete)); 
	} 
} 
 
void CDraw::toChar(char *p_Char) 
{ 
	char p1[22]; 
	sprintf(p1,"%3d,%3d,%3d,%3d,%3d,%1d",(int)m_ColorPen,(int)m_ColorBrush,(int)m_LineWide,(int)m_LineType,(int)m_Layer,(int)b_Delete); 
	p1[21]=0; 
	lstrcat(p_Char,p1); 
} 
 
char *CDraw::toData(char *p_Char) 
{ 
	char p1[22]; 
	strncpy(p1,p_Char,21); 
	p1[21]=0; 
	sscanf(p1,"%d,%d,%d,%d,%d,%d",&m_ColorPen,&m_ColorBrush,&m_LineWide,&m_LineType,&m_Layer,&b_Delete); 
	p_Char+=21; 
	return p_Char; 
} 
 
IMPLEMENT_SERIAL(CLine,CObject,1) 
void CLine::Draw(CDC *pDC,int m_DrawMode,int m_DrawMode1,short BackColor) 
{ 
	int x1,y1,x2,y2; 
	float minx,miny,maxx,maxy; 
	if(b_Delete)	//Èç¹ûÒѾ­´¦ÓÚɾ³ý״̬ 
		return; 
	short LineType=m_LineType; 
	short ColorPen=m_ColorPen; 
	GetRect(&minx,&miny,&maxx,&maxy); 
	if(!IsRectCross(minx,miny,maxx,maxy)) 
		return; 
	if(m_DrawMode1==1)	//±»Êó±êÑ¡ÔñÑ¡ÔñºóÌØÊâÏÔʾ 
	{ 
		if(m_LineType!=2) 
			LineType=2; 
		else 
			LineType++; 
	} 
	else if(m_DrawMode1==2)	//Ö¸¶¨ÑÕÉ«»æÖÆ 
		ColorPen=BackColor; 
 
	//É趨»­±ÊµÄÏßÐÍ.¿í¶È.ÑÕÉ« 
	CPen pen((int)LineType,(int)m_LineWide,p_GraphPara->GetColor(ColorPen)); 
	CPen* pOldPen=pDC->SelectObject(&pen); 
	if(m_DrawMode==0) 
		pDC->SetROP2(R2_COPYPEN);//É趨¸²¸ÇµÄ»æÖÆģʽ 
	else if(m_DrawMode==1) 
		pDC->SetROP2(R2_NOT); 
	//½«Êµ¼Ê×ø±êת»»³ÉÆÁÄ»µãÕó×ø±ê 
	DPtoVP(m_X1,m_Y1,&x1,&y1); 
	DPtoVP(m_X2,m_Y2,&x2,&y2); 
	//½øÐлæÖÆ 
	pDC->MoveTo(x1,y1); pDC->LineTo(x2,y2); 
	pDC->SelectObject(pOldPen);//»Ö¸´»­±Ê 
} 
 
//º¯ÊýLine::GetRect×÷Ó㺼ÆËã²¢·µ»ØÒ»ÌõÖ±ÏߵľØÐα߽ç 
void CLine::GetRect(float *minX,float *minY,float *maxX,float *maxY) 
{ 
	*minX=min(m_X1,m_X2);  //¼ÆËã²¢·µ»Ø×îСxÖµ 
	*maxX=max(m_X1,m_X2);  //¼ÆËã²¢·µ»Ø×î´óxÖµ 
	*minY=min(m_Y1,m_Y2);  //¼ÆËã²¢·µ»Ø×îСyÖµ 
	*maxY=max(m_Y1,m_Y2);  //¼ÆËã²¢·µ»Ø×î´óyÖµ 
} 
 
//º¯Êý£ºCLine::IsPoint 
//×÷ÓãºÅжϵãÊÇ·ñÔÚÖ±ÏßÉÏ£¬²ÎÊý£¨x,y)ÊǵãÖеãµÄ×ø±ê£¬jlΪµãÖеľàÀ뷶Χ 
//·µ»Ø£º1-µãÖÐÖ±Ïß 0-ûÓеãÖÐ 
BOOL CLine::IsPoint(float x,float y,float jl) 
{ 
	float xx,x1,x2,y1,y2; 
    if(b_Delete) 
		return FALSE; 
	GetRect(&x1,&y1,&x2,&y2);//µÃµ½Ã¿ÌõÖ±Ïߵı߽ç¾ØÐÎ 
    if(!(x>=x1&&x=x2&&y>=y1&&y=y2)) 
		return FALSE; //Èç¹ûµã²»Ôڱ߽ç¾ØÐÎÄÚ,¼ÌÐøÅжÏÏÂÒ»¸öͼÐÎÔªËØ 
	xx=PointLine(x,y,m_X1,m_Y1,m_X2,m_Y2);//µÃµ½µãµ½Ö±Ïß¾àÀë 
	if(xx<jl)//Èç¹ûÑ¡ÖÐ 
		return TRUE; 
	return FALSE; 
} 
 
void CLine::Serialize(CArchive& ar) 
{ 
	CDraw::Serialize(ar); 
	if(ar.IsStoring()) 
	{ 
		ar<<m_X1<<m_Y1<<m_X2<<m_Y2; 
	} 
	else 
	{ 
		ar>>m_X1>>m_Y1>>m_X2>>m_Y2; 
	} 
} 
 
void CLine::Save(CFile* file,BOOL Yn) 
{ 
	CDraw::Save(file,Yn); 
	if(Yn) 
	{ 
		file->Write((unsigned char *)&m_X1,sizeof(m_X1)); 
		file->Write((unsigned char *)&m_Y1,sizeof(m_Y1)); 
		file->Write((unsigned char *)&m_X2,sizeof(m_X2)); 
		file->Write((unsigned char *)&m_Y2,sizeof(m_Y2)); 
	} 
	else 
	{ 
		file->Read((unsigned char *)&m_X1,sizeof(m_X1)); 
		file->Read((unsigned char *)&m_Y1,sizeof(m_Y1)); 
		file->Read((unsigned char *)&m_X2,sizeof(m_X2)); 
		file->Read((unsigned char *)&m_Y2,sizeof(m_Y2)); 
	} 
} 
 
void CLine::toChar(char *p_Char) 
{ 
	char p1[53]; 
	CDraw::toChar(p_Char); 
	sprintf(p1,"%12.4f,%12.4f,%12.4f,%12.4f\n",m_X1,m_Y1,m_X2,m_Y2); 
	p1[52]=0; 
	strcat(p_Char,p1); 
} 
 
char *CLine::toData(char *p_Char) 
{ 
	char p1[53]; 
	p_Char=CDraw::toData(p_Char); 
	strncpy(p1,p_Char,52); 
	p_Char+=52; 
	sscanf(p1,"%f,%f,%f,%f\n",&m_X1,&m_Y1,&m_X2,&m_Y2); 
	return p_Char; 
} 
 
void CLine::Move(float x_Move,float y_Move) 
{ 
	m_X1+=x_Move; 
	m_X2+=x_Move; 
	m_Y1+=y_Move; 
	m_Y2+=y_Move; 
} 
 
IMPLEMENT_SERIAL(CPline,CObject,1) 
void CPline::Draw(CDC *pDC,int m_DrawMode,int m_DrawMode1,short BackColor) 
{ 
	float minx,miny,maxx,maxy; 
	int x1,y1; 
	if(b_Delete)	//Èç¹ûÒѾ­´¦ÓÚɾ³ý״̬ 
		return; 
	short LineType=m_LineType; 
	short ColorPen=m_ColorPen; 
	short ColorBrush=m_ColorBrush; 
	GetRect(&minx,&miny,&maxx,&maxy); 
	if(!IsRectCross(minx,miny,maxx,maxy)) 
		return; 
	//É趨»­±ÊµÄÏßÐÍ.¿í¶È.ÑÕÉ« 
	if(m_DrawMode1==1)	//±»Êó±êÑ¡ÔñÑ¡ÔñºóÌØÊâÏÔʾ 
	{ 
		if(m_LineType!=2) 
			LineType=2; 
		else 
			LineType++; 
	} 
	else if(m_DrawMode1==2)	//Ö¸¶¨ÑÕÉ«»æÖÆ 
	{ 
		ColorPen=BackColor; 
		ColorBrush=BackColor; 
	} 
	CPen pen((int)LineType,(int)m_LineWide,p_GraphPara->GetColor(ColorPen)); 
	CPen* pOldPen=pDC->SelectObject(&pen); 
	CBrush brush(p_GraphPara->GetColor(m_ColorBrush)); 
	CBrush* pOldBrush=pDC->SelectObject(&brush); 
	POINT* ppoint; 
	CRgn rgn; 
	if(m_DrawMode==0) 
		pDC->SetROP2(R2_COPYPEN);//É趨¸²¸ÇµÄ»æÖÆģʽ 
	else if(m_DrawMode==1) 
		pDC->SetROP2(R2_NOT); 
	 
	ppoint=new POINT[m_Numble+1]; 
	for(int i=0;i<m_Numble;i++)//½«Êµ¼Ê×ø±êת»»³ÉÆÁÄ»µãÕó×ø±ê£¬´æÈëppoint 
	{ 
		DPtoVP(m_PointList[i].x,m_PointList[i].y,&x1,&y1); 
		ppoint[i].x=x1; 
		ppoint[i].y=y1; 
	} 
	if(!b_Fill)		//»æÖÆÁ¬ÐøÖ±Ïß 
	{ 
		ppoint[m_Numble]=ppoint[0]; 
		pDC->MoveTo(ppoint[0].x,ppoint[0].y); 
		for(i=0;i<m_Numble;i++) 
			pDC->LineTo(ppoint[i].x,ppoint[i].y); 
	} 
	else 
    { 
		if(m_DrawMode1==0||m_DrawMode1==2)	//Èç¹ûÊÇÕý³£ÏÔʾ 
			pDC->Polygon(ppoint,m_Numble);	//»æÖƶà±ßÐÎ  
		else if(m_DrawMode1==1)	//½øÐз´É«ÏÔʾ 
		{ 
			rgn.CreatePolygonRgn(ppoint,m_Numble,1);  
			pDC->InvertRgn(&rgn); 
		} 
	} 
	delete ppoint; 
	pDC->SelectObject(pOldPen);   //»Ö¸´»­±Ê 
	pDC->SelectObject(pOldBrush); //»Ö¸´Ë¢×Ó 
} 
 
//º¯Êý:CPline::GetRect×÷ÓÃ:¼ÆËã²¢·µ»ØÒ»ÌõÁ¬ÐøÖ±Ïߵı߽ç¾ØÐÎ 
//Á¬ÐøÖ±ÏßµÄÖ÷¿Ø²ÎÊýÔÚpline1ÖУ¬×ø±êÔÚPointxyÖÐ 
void CPline::GetRect(float *minX,float *minY,float *maxX,float *maxY) 
{ 
	float x1,y1,x2,y2; 
	//ÓõÚÒ»¸ö¶¥µãµÄ×ø±ê³õÊÔ»¯±äÁ¿ 
	x1=m_PointList[0].x;x2=m_PointList[0].y; 
	y1=m_PointList[0].x;y2=m_PointList[0].y; 
	for(int i=1;i<m_Numble;i++)          //´ÓµÚ¶þ¸ö¶¥µã¿ªÊ¼Ñ­»· 
	{ 
		x1=min(x1,m_PointList[i].x);    //µÃµ½×îСx×ø±ê 
		x2=max(x2,m_PointList[i].x);    //µÃµ½×î´óx×ø±ê 
		y1=min(y1,m_PointList[i].y);    //µÃµ½×îСy×ø±ê 
		y2=max(y2,m_PointList[i].y);    //µÃµ½×î´óy×ø±ê 
	} 
	*minX=x1;*maxX=x2;*minY=y1;*maxY=y2; //½«Öµ¸³¸øµØÖ··µ»Ø 
} 
 
//º¯Êý£ºPLine::IsPoint 
//¹¦ÄÜ£ºÅжϵãÊÇ·ñÔÚÁ¬ÐøÖ±ÏßÉÏ£¬²ÎÊý£¨x,y)ÊǵãÖеãµÄ×ø±ê£¬jlΪµãÖеľàÀ뷶Χ£¬ 
//·µ»Ø£º1-µãÖÐÁ¬ÐøÖ±Ïß»ò·â±ÕÇøÓò 0-ûÓеãÖÐ 
BOOL CPline::IsPoint(float x,float y,float jl,float blc) 
{ 
	int i; 
	float xx,x1,y1,x2,y2; 
    if(b_Delete) 
		return FALSE; 
    GetRect(&x1,&y1,&x2,&y2);  //µÃµ½Ã¿ÌõÁ¬ÐøÖ±Ïߵı߽ç¾ØÐÎ 
	if(!(x>=x1-jl&&x=x2+jl&&y>=y1-jl&&y=y2+jl)) 
		return FALSE;	//Èç¹ûµã²»Ôڱ߽ç¾ØÐÎÄÚ,Ôò²»ÄÜÑ¡ÖÐ 
	    
	if(!b_Fill)			//Èç¹ûÊÇÁ¬ÐøÖ±Ïß 
	{ 
		for(i=0;i<m_Numble-1;i++)  //ÒÀ´Î¶ÔÁ¬ÐøÖ±ÏßµÄÿÌõÖ±Ïß½øÐÐÅÐ¶Ï 
        { 
			xx=PointLine(x,y,m_PointList[i].x,m_PointList[i].y,m_PointList[i+1].x,m_PointList[i+1].y); 
			if(xx<jl)                     //Èç¹ûÑ¡ÖÐ 
				return TRUE;	 
		} 
	} 
	else				//Èç¹ûÊǶà±ßÐÎÇøÓò 
	{ 
		if(PointRgn(x,y,m_Numble,m_PointList,blc))    //Èç¹ûµãÔÚ·â±ÕÇøÓòÄÚ 
			return TRUE; 
	} 
	return FALSE; //ûÓÐÑ¡ÖÐÁ¬ÐøÖ±Ïß»ò·â±ÕÇøÓò£¬·µ»Ø0 
} 
 
BOOL CPline::IsPLine() 
{ 
	return !b_Fill; 
} 
 
void CPline::Serialize(CArchive& ar) 
{ 
	int i; 
	CDraw::Serialize(ar); 
	if(ar.IsStoring()) 
	{ 
		ar<<b_Fill<<m_Numble; 
		for(i=0;i<m_Numble;i++) 
			ar<<m_PointList[i].x<<m_PointList[i].y; 
	} 
	else 
	{ 
		ar>>b_Fill>>m_Numble; 
		m_PointList=new PointStruct[m_Numble]; 
		for(i=0;i<m_Numble;i++) 
			ar>>m_PointList[i].x>>m_PointList[i].y; 
	} 
} 
 
void CPline::Save(CFile* file,BOOL Yn) 
{ 
	int i; 
	CDraw::Save(file,Yn); 
	if(Yn) 
	{ 
		file->Write((unsigned char *)&b_Fill,sizeof(b_Fill)); 
		file->Write((unsigned char *)&m_Numble,sizeof(m_Numble)); 
		for(i=0;i<m_Numble;i++) 
		{ 
			file->Write((unsigned char *)&m_PointList[i],sizeof(m_PointList[i])); 
		} 
	} 
	else 
	{ 
		file->Read((unsigned char *)&b_Fill,sizeof(b_Fill)); 
		file->Read((unsigned char *)&m_Numble,sizeof(m_Numble)); 
		m_PointList=new PointStruct[m_Numble]; 
		for(i=0;i<m_Numble;i++) 
		{ 
			file->Read((unsigned char *)&m_PointList[i],sizeof(m_PointList[i])); 
		} 
	} 
} 
 
void CPline::toChar(char *p_Char) 
{ 
	char p1[27]; 
	CDraw::toChar(p_Char); 
	sprintf(p1,"%4d,%1d\n",m_Numble,(int)b_Fill); 
	p1[7]=0; 
	lstrcat(p_Char,p1); 
	for(int i=0;i<m_Numble;i++) 
	{ 
		sprintf(p1,"%12.4f,%12.4f\n",m_PointList[i].x,m_PointList[i].y); 
		p1[26]=0; 
		lstrcat(p_Char,p1); 
	} 
} 
 
char *CPline::toData(char *p_Char) 
{ 
	char p1[27]; 
	p_Char=CDraw::toData(p_Char); 
	strncpy(p1,p_Char,7); 
	p1[7]=0; 
	p_Char+=7; 
	sscanf(p1,"%d,%d\n",&m_Numble,&b_Fill); 
	m_PointList=new PointStruct[m_Numble]; 
	for(int i=0;i<m_Numble;i++) 
	{ 
		strncpy(p1,p_Char,26); 
		p1[26]=0; 
		p_Char+=26; 
		sscanf(p1,"%f,%f\n",&m_PointList[i].x,&m_PointList[i].y); 
	} 
	return p_Char; 
} 
 
int CPline::GetNumb() 
{ 
	return m_Numble; 
} 
 
void CPline::Move(float x_Move,float y_Move) 
{ 
	for(int i=0;i<m_Numble;i++) 
	{ 
		m_PointList[i].x+=x_Move; 
		m_PointList[i].y+=y_Move; 
	} 
} 
 
IMPLEMENT_SERIAL(CCircle,CObject,1) 
void CCircle::Draw(CDC *pDC,int m_DrawMode,int m_DrawMode1,short BackColor) 
{ 
	if(b_Delete)	//Èç¹ûÒѾ­´¦ÓÚɾ³ý״̬ 
		return; 
	float minx,miny,maxx,maxy; 
	GetRect(&minx,&miny,&maxx,&maxy); 
	if(!IsRectCross(minx,miny,maxx,maxy)) 
		return; 
	int x,y,r; 
	short LineType=m_LineType; 
	short ColorPen=m_ColorPen; 
	short ColorBrush=m_ColorBrush; 
	if(m_DrawMode1==1)	//±»Êó±êÑ¡ÔñÑ¡ÔñºóÌØÊâÏÔʾ 
	{ 
		if(m_LineType!=2) 
			LineType=2; 
		else 
			LineType++; 
	} 
	else if(m_DrawMode1==2)	//Ö¸¶¨ÑÕÉ«»æÖÆ 
	{ 
		ColorPen=BackColor; 
		ColorBrush=BackColor; 
	} 
	//ÒÔÔ²µÄÏßÐÍ£¬Ïß¿íºÍÑÕÉ«³õʼ»¯Ò»¸ö»­±Ê 
	CPen pen((int)LineType,(int)m_LineWide,p_GraphPara->GetColor(ColorPen)); 
	CPen* pOldPen=pDC->SelectObject(&pen); 
	CBrush brush(p_GraphPara->GetColor(m_ColorBrush)); 
	CBrush* pOldBrush=pDC->SelectObject(&brush); 
	if(m_DrawMode==0) 
		pDC->SetROP2(R2_COPYPEN);//É趨¸²¸ÇµÄ»æÖÆģʽ 
	else if(m_DrawMode==1) 
		pDC->SetROP2(R2_NOT);    //ÉèÖ÷´É«µÄ»æ»­Ä£Ê½ 
	if(!b_Fill)	//Èç¹ûÊÇÔ² 
		pDC->SelectStockObject(NULL_BRUSH); //Èç¹ûÊÇÆÕͨԲ£¬ÉèÖò»Ìî³ä״̬ 
		//¼ÆËãµÃµ½Ô²Ðİ뾶µÄÆÁÄ»ÏñËØ×ø±ê  
	DPtoVP(m_CircleX,m_CircleY,&x,&y); 
	r=DLtoVL(m_CircleR); 
	pDC->Ellipse(x-r,y-r,x+r,y+r); //»æÖÆÔ² 
	pDC->SelectObject(pOldPen);    //»Ö¸´»­±Ê 
	pDC->SelectObject(pOldBrush);  //»Ö¸´»­Ë¢ 
} 
 
//º¯Êý£ºCCircle::GetRect×÷Ó㺼ÆËã²¢·µ»ØÒ»Ìõ¸öÔ²µÄ¾ØÐα߽ç 
void CCircle::GetRect(float *minX,float *minY,float *maxX,float *maxY) 
{ 
	*minX=m_CircleX-m_CircleR;  //µÃµ½²¢·µ»Ø×îСxÖµ 
	*minY=m_CircleY-m_CircleR;  //µÃµ½²¢·µ»Ø×î´óxÖµ 
	*maxX=m_CircleX+m_CircleR;  //µÃµ½²¢·µ»Ø×îСyÖµ 
	*maxY=m_CircleY+m_CircleR;  //µÃµ½²¢·µ»Ø×î´óyÖµ 
} 
 
//º¯Êý£ºCCircle::IsPoint 
//¹¦ÄÜ£ºÅжϵãÊÇ·ñÔÚÔ²ÉÏ£¬²ÎÊý£¨x,y)ÊǵãÖеãµÄ×ø±ê£¬jlΪµãÖеľàÀ뷶Χ£¬ 
//·µ»Ø£º1-µãÖÐÔ²»òÔ²ÐÎÇøÓò£¬0-ûÓÐÑ¡ÖÐ 
BOOL CCircle::IsPoint(float x,float y,float jl) 
{ 
	float xx; 
    if(b_Delete) 
		return FALSE; 
	xx=CalDisp(x,y,m_CircleX,m_CircleY);	//µãµ½Ô²ÐĵľàÀë 
	//Èç¹ûÊÇÆÕͨԲ²¢Çҵ㵽ԲµÄ¾àÀëСÓÚjl 
	if(!b_Fill) 
	{ 
		if((xx>m_CircleR-jl&&xx<m_CircleR+jl)) 
			return TRUE; 
	} 
	else	//Èç¹ûÊÇÌî³äÔ² 
	{ 
		if(xx=m_CircleR) //Èç¹ûµãÔÚÔ²ÄÚ 
			return TRUE; 
	} 
	return FALSE;    //Èç¹ûûÓеãÖÐÔ²»òÕßÌî³äÔ²£¬·µ»Ø0 
} 
 
BOOL CCircle::IsCircle() 
{ 
	return !b_Fill; 
} 
 
void CCircle::Serialize(CArchive& ar) 
{ 
	CDraw::Serialize(ar); 
	if(ar.IsStoring()) 
	{ 
		ar<<b_Fill<<m_CircleX<<m_CircleY<<m_CircleR; 
	} 
	else 
	{ 
		ar>>b_Fill>>m_CircleX>>m_CircleY>>m_CircleR; 
	} 
} 
 
void CCircle::Save(CFile* file,BOOL Yn) 
{ 
	CDraw::Save(file,Yn); 
	if(Yn) 
	{ 
		file->Write((unsigned char *)&b_Fill,sizeof(b_Fill)); 
		file->Write((unsigned char *)&m_CircleX,sizeof(m_CircleX)); 
		file->Write((unsigned char *)&m_CircleY,sizeof(m_CircleY)); 
		file->Write((unsigned char *)&m_CircleR,sizeof(m_CircleR)); 
	} 
	else 
	{ 
		file->Read((unsigned char *)&b_Fill,sizeof(b_Fill)); 
		file->Read((unsigned char *)&m_CircleX,sizeof(m_CircleX)); 
		file->Read((unsigned char *)&m_CircleY,sizeof(m_CircleY)); 
		file->Read((unsigned char *)&m_CircleR,sizeof(m_CircleR)); 
	} 
} 
 
void CCircle::toChar(char *p_Char) 
{ 
	char p1[42]; 
 
	CDraw::toChar(p_Char); 
	sprintf(p1,"%12.4f,%12.4f,%12.4f,%1d\n",m_CircleX,m_CircleY,m_CircleR,b_Fill); 
	p1[42]=0; 
	lstrcat(p_Char,p1); 
} 
 
char *CCircle::toData(char *p_Char) 
{ 
	char p1[42]; 
	p_Char=CDraw::toData(p_Char); 
	strncpy(p1,p_Char,41); 
	p_Char+=41; 
	p1[41]=0; 
	sscanf(p1,"%f,%f,%f,%d\n",&m_CircleX,&m_CircleY,&m_CircleR,&b_Fill); 
	return p_Char; 
} 
 
void CCircle::Move(float x_Move,float y_Move) 
{ 
	m_CircleX+=x_Move; 
	m_CircleY+=y_Move; 
} 
 
void CArc::Init(short ColorPen,short ColorBrush,short LineWide,short LineType,short Layer,float CircleX,float CircleY,float CircleR,BOOL Fill,float Angle1,float Angle2) 
{ 
	m_ColorPen=ColorPen; 
	m_ColorBrush=ColorBrush; 
	m_LineWide=LineWide; 
	m_LineType=LineType; 
	m_Layer=Layer; 
	m_CircleX=CircleX; 
	m_CircleY=CircleY; 
	m_CircleR=CircleR; 
	b_Fill=Fill; 
	m_Angle1=Angle1; 
	m_Angle2=Angle2; 
} 
 
CArc* CDrawDoc::GetArc(int Index) 
{ 
	if(Index<0||Index>m_ArcArray.GetUpperBound()) 
		return 0; 
	return m_ArcArray.GetAt(Index); 
} 
 
IMPLEMENT_SERIAL(CArc,CObject,1) 
void CArc::Draw(CDC *pDC,int m_DrawMode,int m_DrawMode1,short BackColor) 
{ 
	if(b_Delete)	//Èç¹ûÒѾ­´¦ÓÚɾ³ý״̬ 
		return; 
	float minx,miny,maxx,maxy; 
	GetRect(&minx,&miny,&maxx,&maxy); 
	if(!IsRectCross(minx,miny,maxx,maxy)) 
		return; 
	int x,y,rr; 
	int x1,x2,y1,y2; 
	short LineType=m_LineType; 
	short ColorPen=m_ColorPen; 
	if(m_DrawMode1==1)	//±»Êó±êÑ¡ÔñÑ¡ÔñºóÌØÊâÏÔʾ 
	{ 
		if(m_LineType!=2) 
			LineType=2; 
		else 
			LineType++; 
	} 
	else if(m_DrawMode1==2)	//Ö¸¶¨ÑÕÉ«»æÖÆ 
		ColorPen=BackColor; 
	//É趨»­±ÊµÄÏßÐÍ.¿í¶È.ÑÕÉ« 
	CPen pen((int)LineType,(int)m_LineWide,p_GraphPara->GetColor(ColorPen)); 
	CPen* pOldPen=pDC->SelectObject(&pen); 
	if(m_DrawMode==0) 
		pDC->SetROP2(R2_COPYPEN);//É趨¸²¸ÇµÄ»æÖÆģʽ 
	else if(m_DrawMode==1) 
		pDC->SetROP2(R2_NOT); 
	//½«Ô²ÐÄʵ¼Ê×ø±êתΪÆÁÄ»×ø±ê 
	DPtoVP(m_CircleX,m_CircleY,&x,&y); 
	rr=DLtoVL(m_CircleR); 
	//µÃµ½ÆðµãµÄ×ø±ê 
	x1=x+DLtoVL(m_CircleR*(float)cos(m_Angle1)); 
	y1=y-DLtoVL(m_CircleR*(float)sin(m_Angle1)); 
 
	//µÃµ½ÖÕµãµÄ×ø±ê 
	x2=x+DLtoVL(m_CircleR*(float)cos(m_Angle2)); 
	y2=y-DLtoVL(m_CircleR*(float)sin(m_Angle2)); 
	pDC->Arc(x-rr,y-rr,x+rr,y+rr,x1,y1,x2,y2);  //»æÖÆÔ²»¡ 
	pDC->SelectObject(pOldPen);             //»Ö¸´»­±Ê 
} 
 
 
//º¯Êý£ºAarc::GetRect×÷Ó㺼ÆËãÒ»Ìõ»¡µÄ±ß½ç¾ØÐΣ¬»¡µÄ×ø±êÔÚarc1ÄÚ 
void CArc::GetRect(float *minX,float *minY,float *maxX,float *maxY) 
{ 
	float x,y,x1,y1,x2,y2; 
	int i; 
	//  µÃµ½Ô²»¡Æðµã×ø±ê 
	x=m_CircleX+(float)(cos(m_Angle1)*m_CircleR); 
	y=m_CircleY+(float)(sin(m_Angle1)*m_CircleR); 
	x1=x; y1=y; 
	x2=x; y2=y;           //¸ø±ß½ç¾ØÐγõÖµ£º 
	// µÃµ½Ô²»¡ÖÕµã×ø±ê 
	x=m_CircleX+(float)(cos(m_Angle2)*m_CircleR);    
	y=m_CircleY+(float)(sin(m_Angle2)*m_CircleR); 
	//µÃµ½×îСºÍ×î´ó×ø±ê  
	x1=min(x,x1);x2=max(x,x2); 
	y1=min(y,y1);y2=max(y,y2); 
	for(i=0;i<4;i++)     //¶ÔÁíÍâÈý¸ö×ø±êÖáÑ­»· 
	{ 
		if(IsInArc(pi/2*i)) 
		{ 
			if(i==0) 
			{ 
				x=m_CircleX+m_CircleR; 
				y=m_CircleY; 
			} 
			else if(i==1)     //ÓëYÖáÕý·½ÏòÏཻ 
			{ 
				x=m_CircleX; 
				y=m_CircleY+m_CircleR;  //µÃµ½½»µã×ø±ê 
			} 
			else if(i==2)    //ÓëxÖḺ·½ÏòÏཻ 
			{ 
				x=m_CircleX-m_CircleR; 
				y=m_CircleY;  
			} 
			else if(i==3)    //ÓëYÖáÕý·½ÏòÏཻ 
			{ 
				x=m_CircleX; 
				y=m_CircleY-m_CircleR;  
			} 
			//µÃµ½×îС×ø±êÖµºÍ×î´ó×ø±êÖµ 
			x1=min(x,x1);x2=max(x,x2); 
			y1=min(y,y1);y2=max(y,y2); 
		} 
	} 
	*minX=x1;*maxX=x2;*minY=y1;*maxY=y2; //¸³Öµ¸øµØÖ··µ»Ø 
} 
 
BOOL CArc::IsInArc(float angle) 
{ 
	if((m_Angle1<m_Angle2&&angle<m_Angle2&&angle>m_Angle1) 
		||m_Angle1>m_Angle2&&(!(angle=m_Angle1&&angle>=m_Angle2))) 
		return TRUE; 
	else 
		return FALSE; 
} 
 
//º¯Êý£ºCArc::IsPoint 
//¹¦ÄÜ£ºÅжϵãÊÇ·ñÔÚÔ²»¡ÉÏ£¬²ÎÊý£¨x,y)ÊǵãÖеãµÄ×ø±ê£¬jlΪµãÖеľàÀ뷶Χ£¬ 
//·µ»Ø£º1-µãÖÐÔ²»¡£¬index·µ»ØµãÖеÄͼÐÎÔªËصÄÐòÁкţ¬index1·µ»ØΨһʶ±ðºÅ 
BOOL CArc::IsPoint(float x,float y,float jl) 
{ 
	if(CCircle::IsPoint(x,y,jl)) 
	{ 
		//µãÖеãÏà¶ÔÓÚ»¡µÄÔ²ÐĽǵĻ¡¶È 
		float xx=CalDisp(x,y,m_CircleX,m_CircleY); 
		float ang=(float)acos((x-m_CircleX)/xx); 
		if(y-m_CircleY<0) 
			ang=(float)pi*2-ang; 
		//Èç¹ûµãÖеĵãÏà¶ÔÓÚ»¡µÄÔ²ÐĵĻ¡¶ÈÔÚ»¡µÄ»¡¶È·¶Î§ÄÚ 
		if(IsInArc(ang)) 
			return TRUE; 
	} 
	return 0;//Èç¹ûûÓеãÖÐÔ²»¡£¬·µ»Ø0 
} 
 
void CArc::Serialize(CArchive& ar) 
{ 
	CCircle::Serialize(ar); 
	if(ar.IsStoring()) 
	{ 
		ar<<m_Angle1<<m_Angle2; 
	} 
	else 
	{ 
		ar>>m_Angle1>>m_Angle2; 
	} 
} 
 
void CArc::Save(CFile* file,BOOL Yn) 
{ 
	CCircle::Save(file,Yn); 
	if(Yn) 
	{ 
		file->Write((unsigned char *)&m_Angle1,sizeof(m_Angle1)); 
		file->Write((unsigned char *)&m_Angle2,sizeof(m_Angle2)); 
	} 
	else 
	{ 
		file->Read((unsigned char *)&m_Angle1,sizeof(m_Angle1)); 
		file->Read((unsigned char *)&m_Angle2,sizeof(m_Angle2)); 
	} 
} 
 
void CArc::toChar(char *p_Char) 
{ 
	char p1[66]; 
	CDraw::toChar(p_Char); 
	sprintf(p1,"%12.4f,%12.4f,%12.4f,%12.4f,%12.4f\n",m_CircleX,m_CircleY,m_CircleR,m_Angle1,m_Angle2); 
	p1[65]=0; 
	lstrcat(p_Char,p1); 
} 
 
char *CArc::toData(char *p_Char) 
{ 
	char p1[66]; 
	p_Char=CDraw::toData(p_Char); 
	strncpy(p1,p_Char,65); 
	p_Char+=65; 
	p1[65]=0; 
	sscanf(p1,"%f,%f,%f,%f,%f\n",&m_CircleX,&m_CircleY,&m_CircleR,&m_Angle1,&m_Angle2); 
	return p_Char; 
} 
 
IMPLEMENT_SERIAL(CText,CObject,1) 
void CText::Init(short ColorPen,short ColorBrush,short LineWide,short LineType,short Layer,float StartX,float StartY,float Angle1,float Angle2,float TextHeight,float TextWide,float OffWide,unsigned char TextFont,CString Text) 
{ 
	m_ColorPen=ColorPen; 
	m_ColorBrush=ColorBrush; 
	m_LineType=LineType; 
	m_LineWide=LineWide; 
	m_Layer=Layer; 
	m_StartX=StartX; 
	m_StartY=StartY; 
	m_Angle1=Angle1; 
	m_Angle2=Angle2; 
	m_TextHeight=TextHeight; 
	m_TextWide=TextWide; 
	m_OffWide=OffWide; 
	m_TextLong=c_Text.GetLength(); 
	m_TextFont=TextFont; 
	c_Text=Text; 
} 
 
void CText::Draw(CDC *pDC,int m_DrawMode,int m_DrawMode1,short BackColor) 
{          
	if(b_Delete)	//Èç¹ûÒѾ­´¦ÓÚɾ³ý״̬ 
		return; 
	float minx,miny,maxx,maxy; 
	GetRect(&minx,&miny,&maxx,&maxy); 
	if(!IsRectCross(minx,miny,maxx,maxy)) 
		return; 
	short ColorPen=m_ColorPen; 
	if(m_DrawMode1==2)	//Ö¸¶¨ÑÕÉ«»æÖÆ 
		ColorPen=BackColor; 
	CFont cjcf;  //¶¨ÒåÒ»¸ö×ÖÄ£ 
	int high,wide,cc1,cc2,cd,angg; 
	unsigned char c1,c2; 
	float x1,y1,ang1; 
	char bz[4]; 
	const char *ls1; 
	if(m_DrawMode==0) 
		pDC->SetROP2(R2_COPYPEN); 
	else if(m_DrawMode==1) 
		pDC->SetROP2(R2_NOT);   
	pDC->SetBkMode(TRANSPARENT); 
	 
	high=DLtoVL(m_TextHeight); //µÃµ½×ÖÌåµÄµãÕó¸ß¶È 
	ang1=(float)(m_Angle1*pi/180); 
	if(high<3||high>200) 
		return;                 //×ÖÌå̫С»òÌ«´ó½«²»ÏÔʾ 
	x1=m_StartX-m_TextHeight*(float)sin(ang1); 
	y1=m_StartY+m_TextHeight*(float)cos(ang1); 
	angg=(int)(m_Angle2*10); 
	wide=DLtoVL(m_TextWide); 
	//ÆðʼµãµÄÆÁÄ»µãÕó×ø±ê 
	DPtoVP(x1,y1,&cc1,&cc2); 
	//´´½¨×ÖÄ£ 
	cjcf.CreateFont(high,wide,angg,0,50,0,0,0,255,OUT_TT_PRECIS,CLIP_CHARACTER_PRECIS,DEFAULT_QUALITY,FIXED_PITCH,"cjc"); 
	//Ñ¡ÖÐ×ÖÄ£ 
	CFont* cjcbakf=pDC->SelectObject(&cjcf); 
	pDC->SetBkMode(TRANSPARENT);          //É趨ÏÔʾ·½Ê½ 
	pDC->SetTextColor(p_GraphPara->GetColor(ColorPen)); //É趨Îı¾ÑÕÉ« 
	ls1=(const char *)c_Text;                     //Îı¾ÄÚÈÝ 
	cd=strlen(ls1);                       //Îı¾×Ö·û³¤¶È 
	while(cd>0)  //»æ³öËùÓеÄ×Ö·û 
	{ 
		c1=*ls1; 
		c2=*(ls1+1); 
		if(c1>127&&c2>127)  //Èç¹ûÊÇÒ»¸öºº×Ö 
		{ 
			strncpy(bz,ls1,2);//¿½±´Ò»¸öºº×Öµ½bzÖÐ 
			bz[2]=0; 
			ls1=ls1+2;        //Ìø¹ýºº×ÖÖ¸ÏòÏÂÒ»¸ö×Ö·ûλÖà 
			pDC->TextOut(cc1,cc2,bz); //ÔÚÆÁÄ»ÉÏдÕâ¸öºº×Ö 
			cd=cd-2;                  //×Ö·ûÊý¼õ2 
			//ÏÂÒ»¸ö×Ö·ûµÄÏÔʾλÖà 
			x1=x1+(m_TextWide*2+m_OffWide)*(float)cos(ang1); 
			y1=y1+(m_TextWide*2+m_OffWide)*(float)sin(ang1); 
			//ÏÂÒ»¸ö×Ö·ûÏÔʾλÖõÄÆÁÄ»×ø±ê 
			DPtoVP(x1,y1,&cc1,&cc2); 
		} 
		else //Èç¹ûÊÇÒ»¸öÎ÷ÎÄ×Ö·û 
		{ 
			strncpy(bz,ls1,1);       //¿½±´Ò»¸ö×Ö·ûµ½bzÖÐ 
			bz[1]=0; 
			ls1++;                   //Ìø¹ýÕâÒ»¸ö×Ö·ûµ½ÏÂÒ»¸ö×Ö·û 
			pDC->TextOut(cc1,cc2,bz);//ÔÚÆÁÄ»ÉÏд×Ö·û 
			cd=cd-1;                 //×Ö·ûÊý¼õ1 
			//ÏÂÒ»¸ö×Ö·ûµÄÏÔʾλÖõÄʵ¼Ê×ø±ê 
 
			x1=x1+(m_TextWide+m_OffWide/2)*(float)cos(ang1); 
			y1=y1+(m_TextWide+m_OffWide/2)*(float)sin(ang1); 
			//ÏÂÒ»¸ö×Ö·ûÏÔʾλÖõÄÆÁÄ»×ø±ê 
			DPtoVP(x1,y1,&cc1,&cc2); 
		} 
	}  
	pDC->SelectObject(cjcbakf);//»Ö¸´×ÖÄ£ 
} 
 
void CText::GetRect(float *minX,float *minY,float *maxX,float *maxY) 
{ 
	float x[4],y[4]; 
	double ang=pi*m_Angle1/180; 
	x[0]=m_StartX; 
	y[0]=m_StartY; 
	x[1]=m_StartX+(float)((m_TextWide+m_OffWide)*m_TextLong*cos(ang)); 
	y[1]=m_StartY+(float)((m_TextWide+m_OffWide)*m_TextLong*sin(ang)); 
	x[2]=x[1]-(float)(sin(ang)*m_TextHeight); 
	y[2]=y[1]+(float)(cos(ang)*m_TextHeight); 
	x[3]=m_StartX-(float)(sin(ang)*m_TextHeight); 
	y[3]=m_StartY+(float)(cos(ang)*m_TextHeight); 
	*minX=m_StartX; 
	*minY=m_StartY; 
	*maxX=m_StartX; 
	*maxY=m_StartY; 
	for(int i=1;i<4;i++) 
	{ 
		if(*minX>x[i])*minX=x[i]; 
		if(*minY>y[i])*minY=y[i]; 
		if(*maxX<x[i])*maxX=x[i]; 
		if(*maxY<y[i])*maxY=y[i]; 
	}  
} 
 
BOOL CText::IsPoint(float x,float y,float jl,float blc) 
{ 
	PointStruct XY[4]; 
	float x1,y1,x2,y2; 
    if(b_Delete) 
		return FALSE; 
	GetRect(&x1,&y1,&x2,&y2);  //µÃµ½Ã¿ÌõÁ¬ÐøÖ±Ïߵı߽ç¾ØÐÎ 
	if(!(x>=x1&&x=x2&&y>=y1&&y=y2)) 
		return FALSE;			//Èç¹ûµã²»Ôڱ߽ç¾ØÐÎÄÚ,¼ÌÐøÅжÏÏÂÒ»¸öͼÐÎÔªËØ 
	float ang=(float)pi*m_Angle1/180; 
	XY[0].x=m_StartX; 
	XY[0].y=m_StartY; 
	XY[1].x=m_StartX+(float)((m_TextWide+m_OffWide)*m_TextLong*cos(ang)); 
	XY[1].y=m_StartY+(float)((m_TextWide+m_OffWide)*m_TextLong*sin(ang)); 
	XY[2].x=XY[1].x-(float)(sin(ang)*m_TextHeight); 
	XY[2].y=XY[1].y+(float)(cos(ang)*m_TextHeight); 
	XY[3].x=m_StartX-(float)(sin(ang)*m_TextHeight); 
	XY[3].y=m_StartY+(float)(cos(ang)*m_TextHeight); 
	if(PointRgn(x,y,4,XY,blc))    //Èç¹ûµãÔÚ·â±ÕÇøÓòÄÚ 
		return TRUE; 
	return FALSE; //ûÓÐÑ¡ÖÐÁ¬ÐøÖ±Ïß»ò·â±ÕÇøÓò£¬·µ»Ø0 
} 
 
void CText::Serialize(CArchive& ar) 
{ 
	CDraw::Serialize(ar); 
	if(ar.IsStoring()) 
	{ 
		ar<<m_StartX<<m_StartY<<m_Angle1<<m_Angle2<<m_TextHeight; 
		ar<<m_TextWide<<m_OffWide<<m_TextFont<<m_TextLong; 
		ar<<c_Text; 
	} 
	else 
	{ 
		ar>>m_StartX>>m_StartY>>m_Angle1>>m_Angle2>>m_TextHeight; 
		ar>>m_TextWide>>m_OffWide>>m_TextFont>>m_TextLong; 
		ar>>c_Text; 
	} 
} 
 
void CText::Save(CFile* file,BOOL Yn) 
{ 
	//char *p; 
	CDraw::Save(file,Yn); 
	if(Yn) 
	{ 
		file->Write((unsigned char *)&m_StartX,sizeof(m_StartX)); 
		file->Write((unsigned char *)&m_StartY,sizeof(m_StartY)); 
		file->Write((unsigned char *)&m_Angle1,sizeof(m_Angle1)); 
		file->Write((unsigned char *)&m_Angle2,sizeof(m_Angle2)); 
		file->Write((unsigned char *)&m_TextHeight,sizeof(m_TextHeight)); 
		file->Write((unsigned char *)&m_TextWide,sizeof(m_TextWide)); 
		file->Write((unsigned char *)&m_OffWide,sizeof(m_OffWide)); 
		file->Write((unsigned char *)&m_TextFont,sizeof(m_TextFont)); 
		file->Write((unsigned char *)&m_TextLong,sizeof(m_TextLong)); 
		file->Write((unsigned char *)&c_Text,m_TextLong); 
	} 
	else 
	{ 
		file->Read((unsigned char *)&m_StartX,sizeof(m_StartX)); 
		file->Read((unsigned char *)&m_StartY,sizeof(m_StartY)); 
		file->Read((unsigned char *)&m_Angle1,sizeof(m_Angle1)); 
		file->Read((unsigned char *)&m_Angle2,sizeof(m_Angle2)); 
		file->Read((unsigned char *)&m_TextHeight,sizeof(m_TextHeight)); 
		file->Read((unsigned char *)&m_TextWide,sizeof(m_TextWide)); 
		file->Read((unsigned char *)&m_OffWide,sizeof(m_OffWide)); 
		file->Read((unsigned char *)&m_TextFont,sizeof(m_TextFont)); 
		file->Read((unsigned char *)&m_TextLong,sizeof(m_TextLong)); 
		c_Text.Empty(); 
	/*	p=new char[m_TextLong+1]; 
		file->Read((unsigned char *)&p,m_TextLong); 
		CString Text(p,m_TextLong); 
		delete p; 
		c_Text=Text;*/ 
	} 
} 
 
void CText::toChar(char *p_Char) 
{ 
	char p1[101]; 
	CDraw::toChar(p_Char); 
	sprintf(p1,"%12.4f,%12.4f,%12.4f,%12.4f,%12.4f,%12.4f,%12.4f,%4d,%3d\n", 
	m_StartX,m_StartY,m_Angle1,m_Angle2,m_TextHeight,m_TextWide,m_OffWide, 
	m_TextLong,(int)m_TextFont); 
	p1[100]=0; 
	lstrcat(p_Char,p1); 
	strncat(p_Char,(const char *)c_Text,m_TextLong); 
} 
 
char *CText::toData(char *p_Char) 
{ 
	char p1[101],*pp; 
	p_Char=CDraw::toData(p_Char); 
	strncpy(p1,p_Char,100); 
	p_Char+=100; 
	p1[100]=0; 
	sscanf(p1,"%f,%f,%f,%f,%f,%f,%f,%d,%d\n", 
	&m_StartX,&m_StartY,&m_Angle1,&m_Angle2,&m_TextHeight,&m_TextWide,&m_OffWide, 
	&m_TextLong,&m_TextFont); 
	pp=p_Char; 
	p_Char+=m_TextLong; 
	pp[m_TextLong]=0; 
	c_Text=pp; 
	return p_Char; 
} 
 
int CText::GetLong() 
{ 
	return m_TextLong; 
} 
 
void CText::Move(float x_Move,float y_Move) 
{ 
	m_StartX+=x_Move; 
	m_StartY+=y_Move; 
} 
 
void CDrawDoc::DeleteContents()  
{ 
	// TODO: Add your specialized code here and/or call the base class 
	int nn=m_LineArray.GetSize(); 
	while(nn--) 
		delete m_LineArray.GetAt(nn); 
	m_LineArray.RemoveAll(); 
	nn=m_PLineArray.GetSize(); 
	while(nn--) 
		delete m_PLineArray.GetAt(nn); 
	m_PLineArray.RemoveAll(); 
	nn=m_CircleArray.GetSize(); 
	while(nn--) 
		delete m_CircleArray.GetAt(nn); 
	m_CircleArray.RemoveAll(); 
	nn=m_ArcArray.GetSize(); 
	while(nn--) 
		delete m_ArcArray.GetAt(nn); 
	m_ArcArray.RemoveAll(); 
	nn=m_TextArray.GetSize(); 
	while(nn--) 
		delete m_TextArray.GetAt(nn); 
	m_TextArray.RemoveAll(); 
	COleDocument::DeleteContents(); 
} 
 
BOOL CDrawDoc::GetRect(float * m_Xmin, float * m_Ymin, float * m_Xmax, float * m_Ymax) 
{ 
	float m_minX,m_minY,m_maxX,m_maxY; 
	BOOL pb; 
	int nn=GetNumbLines(); 
	pb=0; 
	while(nn--) 
	{ 
		pb=1; 
		GetLine(nn)->GetRect(&m_minX,&m_minY,&m_maxX,&m_maxY); 
		if(*m_Xmin>m_minX)	*m_Xmin=m_minX; 
		if(*m_Xmax<m_maxX)	*m_Xmax=m_maxX; 
		if(*m_Ymin>m_minY)	*m_Ymin=m_minY; 
		if(*m_Ymax<m_maxY)	*m_Ymax=m_maxY; 
	} 
	nn=GetNumbPLines(); 
	while(nn--) 
	{ 
		pb=1; 
		GetPLine(nn)->GetRect(&m_minX,&m_minY,&m_maxX,&m_maxY); 
		if(*m_Xmin>m_minX)	*m_Xmin=m_minX; 
		if(*m_Xmax<m_maxX)	*m_Xmax=m_maxX; 
		if(*m_Ymin>m_minY)	*m_Ymin=m_minY; 
		if(*m_Ymax<m_maxY)	*m_Ymax=m_maxY; 
	} 
	nn=GetNumbCircles(); 
	while(nn--) 
	{ 
		pb=1; 
		GetCircle(nn)->GetRect(&m_minX,&m_minY,&m_maxX,&m_maxY); 
		if(*m_Xmin>m_minX)	*m_Xmin=m_minX; 
		if(*m_Xmax<m_maxX)	*m_Xmax=m_maxX; 
		if(*m_Ymin>m_minY)	*m_Ymin=m_minY; 
		if(*m_Ymax<m_maxY)	*m_Ymax=m_maxY; 
	} 
	nn=GetNumbArcs(); 
	while(nn--) 
	{ 
		pb=1; 
		GetArc(nn)->GetRect(&m_minX,&m_minY,&m_maxX,&m_maxY); 
		if(*m_Xmin>m_minX)	*m_Xmin=m_minX; 
		if(*m_Xmax<m_maxX)	*m_Xmax=m_maxX; 
		if(*m_Ymin>m_minY)	*m_Ymin=m_minY; 
		if(*m_Ymax<m_maxY)	*m_Ymax=m_maxY; 
	} 
	nn=GetNumbTexts(); 
	while(nn--) 
	{ 
		pb=1; 
		GetText(nn)->GetRect(&m_minX,&m_minY,&m_maxX,&m_maxY); 
		if(*m_Xmin>m_minX)	*m_Xmin=m_minX; 
		if(*m_Xmax<m_maxX)	*m_Xmax=m_maxX; 
		if(*m_Ymin>m_minY)	*m_Ymin=m_minY; 
		if(*m_Ymax<m_maxY)	*m_Ymax=m_maxY; 
	} 
	return pb; 
} 
 
BOOL CDrawDoc::PointSelect(float x,float y,float jl,float blc,int *Lb,int *Index,int *pbh) 
{ 
	int nn=GetNumbPLines(); 
	while(nn--) 
	{ 
		if(GetPLine(nn)->IsPoint(x,y,jl,blc)) 
		{ 
			*Index=nn; 
			*Lb=2; 
			*pbh=GetPLine(nn)->GetID();			 
			return TRUE; 
		} 
	} 
	nn=GetNumbCircles(); 
	while(nn--) 
	{ 
		if(GetCircle(nn)->IsPoint(x,y,jl)) 
		{ 
			*Index=nn; 
			*Lb=3; 
			*pbh=GetCircle(nn)->GetID();			 
			return TRUE; 
		} 
	} 
	nn=GetNumbLines(); 
	while(nn--) 
	{ 
		if(GetLine(nn)->IsPoint(x,y,jl)) 
		{ 
			*Index=nn; 
			*Lb=1; 
			*pbh=GetLine(nn)->GetID();			 
			return TRUE; 
		} 
	} 
	nn=GetNumbArcs(); 
	while(nn--) 
	{ 
		if(GetArc(nn)->IsPoint(x,y,jl)) 
		{ 
			*Index=nn; 
			*Lb=4; 
			*pbh=GetArc(nn)->GetID();			 
			return TRUE; 
		} 
	} 
	nn=GetNumbTexts(); 
	while(nn--) 
	{ 
		if(GetText(nn)->IsPoint(x,y,jl,blc)) 
		{ 
			*Index=nn; 
			*Lb=5; 
			*pbh=GetText(nn)->GetID();			 
			return TRUE; 
		} 
	} 
	 
	return FALSE; 
} 
 
void CDrawDoc::OnUpdateSelectClear(CCmdUI* pCmdUI)  
{ 
	if(n_GraphSelect>0) 
		pCmdUI->Enable(TRUE); 
	else 
		pCmdUI->Enable(FALSE); 
} 
 
BOOL CDrawDoc::AddSelectList(int Lb, int Index,int Pbh) 
{ 
	for(int i=0;i<n_GraphSelect;i++) //ÅжÏÕâ¸öͼÐÎÔªËØÊÇ·ñÒѾ­±»Ñ¡ÖÐ 
	{ 
		//Èç¹û´ËÔªËØÒѾ­±»Ñ¡ÖÐ 
		if(Lb==GraphSelect[i].Lb&&Index==GraphSelect[i].Index) 
			return FALSE; 
	} 
	//Èç¹û´ËÔªËØÒÔǰûÓб»Ñ¡ÖÐ 
	//½«Ñ¡ÖÐͼÐεÄÀà±ð£¬ÐòÁкźÍΨһʶ±ðºÅ´æÈëÊý×飬²¢Ê¹Ñ¡ÖеÄͼÐÎÊýÄ¿¼Ó1 
	GraphSelect[n_GraphSelect].Lb=Lb; 
	GraphSelect[n_GraphSelect].pbh=Pbh; 
	GraphSelect[n_GraphSelect++].Index=Index; 
	return TRUE; 
} 
 
BOOL CDrawDoc::WriteClipBoard() 
{ 
	int n_Num[5],n_Long[5]; 
	long LongChar;	 
	char p1[30],*p_Char;; 
	float m_minX,m_minY,m_maxX,m_maxY; 
	float minX,minY; 
	DrawFormat=::RegisterClipboardFormat("MyAppText"); 
	HGLOBAL HMem; 
	char *pMem; 
	n_Long[0]=73; 
	n_Long[1]=28; 
	n_Long[2]=62; 
	n_Long[3]=86; 
	n_Long[4]=121; 
	for(int i=0;i<5;i++) 
		n_Num[i]=0; 
	for(i=0;i<n_GraphSelect;i++) 
		n_Num[GraphSelect[i].Lb-1]++; 
	LongChar=25+26; 
	for(i=0;i<5;i++) 
		LongChar+=n_Long[i]*n_Num[i]; 
	for(i=0;i<n_GraphSelect;i++) 
	{ 
		if(GraphSelect[i].Lb==1)	//Ö±Ïß 
			GetLine(GraphSelect[i].Index)->GetRect(&m_minX,&m_minY,&m_maxX,&m_maxY); 
		else if(GraphSelect[i].Lb==2)	//Á¬ÐøÖ±Ïß 
		{ 
			CPline* p_Pline=GetPLine(GraphSelect[i].Index); 
			p_Pline->GetRect(&m_minX,&m_minY,&m_maxX,&m_maxY); 
			LongChar+=p_Pline->GetNumb()*26; 
		} 
		else if(GraphSelect[i].Lb==3)	//Ô² 
			GetCircle(GraphSelect[i].Index)->GetRect(&m_minX,&m_minY,&m_maxX,&m_maxY); 
		else if(GraphSelect[i].Lb==4)	//Ô²»¡ 
			GetArc(GraphSelect[i].Index)->GetRect(&m_minX,&m_minY,&m_maxX,&m_maxY); 
		else if(GraphSelect[i].Lb==5)	//Îı¾ 
		{ 
		 
			CText* p_Text=GetText(GraphSelect[i].Index); 
			p_Text->GetRect(&m_minX,&m_minY,&m_maxX,&m_maxY); 
			LongChar+=p_Text->GetLong(); 
		} 
		if(i==0) 
		{ 
			minX=m_minX;  
			minY=m_minY; 
		} 
		else 
		{ 
			if(minX>m_minX)	minX=m_minX; 
			if(minY>m_minY)	minY=m_minY; 
		} 
	}		 
	 
	HMem=(char *)::GlobalAlloc(GMEM_MOVEABLE|GMEM_DDESHARE,LongChar+1); 
	if(HMem==NULL) 
	{ 
		return FALSE; 
	} 
	p_Char=new char[LongChar+1]; 
	if(p_Char==NULL) 
	{ 
		return FALSE; 
	} 
	sprintf(p1,"%4d,%4d,%4d,%4d,%4d\n",n_Num[0],n_Num[1],n_Num[2],n_Num[3],n_Num[4]); 
	//µÃµ½¸÷ÖÖͼÐÎÔªËصÄÊýÁ¿ 
	strcpy(p_Char,p1); 
	sprintf(p1,"%12.4f,%12.4f\n",minX,minY); 
	strcat(p_Char,p1); 
	for(int j=0;j<5;j++) 
	{ 
		for(i=0;i<n_GraphSelect;i++) 
		{ 
			if(GraphSelect[i].Lb==1&&j==0)	//Ö±Ïß 
				GetLine(GraphSelect[i].Index)->toChar(p_Char); 
			else if(GraphSelect[i].Lb==2&&j==1)	//Á¬ÐøÖ±Ïß 
				GetPLine(GraphSelect[i].Index)->toChar(p_Char); 
			else if(GraphSelect[i].Lb==3&&j==2)	//Ô² 
				GetCircle(GraphSelect[i].Index)->toChar(p_Char); 
			else if(GraphSelect[i].Lb==4&&j==3)	//Ô²»¡ 
				GetArc(GraphSelect[i].Index)->toChar(p_Char); 
			else if(GraphSelect[i].Lb==5&&j==4)	//Îı¾ 
				GetText(GraphSelect[i].Index)->toChar(p_Char); 
		} 
	} 
 
	pMem=(char *)::GlobalLock(HMem); 
	if(pMem==NULL) 
	{ 
		delete p_Char; 
		return FALSE; 
	} 
	::lstrcpy(pMem,p_Char); 
	::GlobalUnlock(HMem); 
	if(!OpenClipboard(NULL)) 
	{ 
		delete p_Char; 
		return FALSE; 
	} 
	::EmptyClipboard(); 
	::SetClipboardData(DrawFormat,HMem); 
	HMem=0; 
	::CloseClipboard(); 
	delete p_Char; 
	return TRUE; 
} 
 
BOOL CDrawDoc::ReadClipBoard(float x,float y) 
{ 
	char p1[30]; 
	int n_Num[5]; 
	float minX,minY; 
	HANDLE HClipText; 
	char *PClipText; 
	char *CharTemp,*p_Char; 
	OpenClipboard(NULL); 
	HClipText=::GetClipboardData(DrawFormat); 
	if(HClipText==NULL) 
	{ 
		return FALSE; 
	} 
	CharTemp=new char[::GlobalSize(HClipText)]; 
	if(CharTemp==0) 
	{ 
		::CloseClipboard(); 
		return FALSE; 
	} 
	PClipText=(char *)::GlobalLock(HClipText); 
	if(PClipText==NULL) 
	{ 
		return FALSE; 
	} 
	::lstrcpy(CharTemp,PClipText); 
	::GlobalUnlock(HClipText); 
	::CloseClipboard(); 
	p_Char=CharTemp; 
 
	//µÃµ½¸÷ÖÖͼÐÎÔªËصÄÊýÁ¿ 
	strncpy(p1,p_Char,25); 
	p_Char+=25; 
	p1[25]=0; 
	sscanf(p1,"%d,%d,%d,%d,%d\n",&n_Num[0],&n_Num[1],&n_Num[2],&n_Num[3],&n_Num[4]); 
	 
	strncpy(p1,p_Char,26); 
	p_Char+=26; 
	p1[26]=0; 
	sscanf(p1,"%f,%f\n",&minX,&minY); 
	minX=x-minX; 
	minY=y-minY; 
	for(int i=0;i<5;i++) 
	{ 
		for(int j=0;j<n_Num[i];j++) 
		{ 
			GraphSelect[n_GraphSelect++].Lb=i+1; 
			if(i==0) 
			{ 
				CLine *p_Line=new CLine(); 
				m_LineArray.Add(p_Line); 
				p_Char=p_Line->toData(p_Char); 
				p_Line->Move(minX,minY); 
			} 
			else if(i==1) 
			{ 
				CPline *p_PLine=new CPline(); 
				m_PLineArray.Add(p_PLine); 
				p_Char=p_PLine->toData(p_Char); 
				p_PLine->Move(minX,minY); 
			} 
			else if(i==2) 
			{ 
				CCircle *p_Circle=new CCircle(); 
				m_CircleArray.Add(p_Circle); 
				p_Char=p_Circle->toData(p_Char); 
				p_Circle->Move(minX,minY); 
			} 
			else if(i==3) 
			{ 
				CArc *p_Arc=new CArc(); 
				m_ArcArray.Add(p_Arc); 
				p_Char=p_Arc->toData(p_Char); 
				p_Arc->Move(minX,minY); 
			} 
			else if(i==4) 
			{ 
				CText *p_Text=new CText(); 
				m_TextArray.Add(p_Text); 
				p_Char=p_Text->toData(p_Char); 
				p_Text->Move(minX,minY); 
			} 
			GraphSelect[n_GraphSelect++].Index=GetMaxIndex(i+1); 
		} 
	} 
	delete []CharTemp; 
	return TRUE; 
} 
 
 
void CDrawDoc::OnCloseDocument()  
{ 
	// TODO: Add your specialized code here and/or call the base class 
	COleDocument::OnCloseDocument(); 
} 
 
BOOL CDrawDoc::OnOpenDocument(LPCTSTR lpszPathName)  
{ 
	if (!COleDocument::OnOpenDocument(lpszPathName)) 
		return FALSE; 
	// TODO: Add your specialized creation code here 
	return TRUE; 
} 
 
BOOL CDrawDoc::AddUndo(float sx, float sy, float blc) 
{ 
	long l; 
	l=m_UndoList[n_CurUnIndex].l_Start;	//µÃµ½ÔÚÎļþÖеÄÆðµã 
	Fundo.Seek(0,l); 
	Fundo.Write((unsigned char *)&sx,sizeof(sx)); 
	Fundo.Write((unsigned char *)&sy,sizeof(sy)); 
	Fundo.Write((unsigned char *)&blc,sizeof(blc)); 
	m_UndoList[n_CurUnIndex].Lb=1;	//ͼÐÎÆÁÄ»±ä»¯²Ù×÷ 
	n_CurUnIndex++; 
	m_UndoList[n_CurUnIndex].Index=l+3*sizeof(float); 
	return TRUE; 
} 
 
BOOL CDrawDoc::AddUndo(int Lb, int Numble, GraphSelectStruct * GraphList) 
{ 
	long l; 
	l=m_UndoList[n_CurUnIndex].l_Start;	//µÃµ½ÔÚÎļþÖеÄÆðµã 
	Fundo.Seek(l,0); 
	for(int i=0;i<Numble;i++) 
		Fundo.Write((unsigned char *)&GraphList[i],sizeof(GraphList[i])); 
	m_UndoList[n_CurUnIndex].Lb=Lb;	//ÅбðÊÇʲô²Ù×÷ 
	m_UndoList[n_CurUnIndex].Index=Numble; 
	n_CurUnIndex++; 
	m_UndoList[n_CurUnIndex].l_Start=l+sizeof(GraphList[0])*Numble; 
	SetModifiedFlag(1); 
	return TRUE; 
} 
 
int CDrawDoc::GetMaxIndex(int Lb) 
{ 
	if(Lb==1) 
		return m_LineArray.GetUpperBound(); 
	else if(Lb==2) 
		return m_PLineArray.GetUpperBound(); 
	else if(Lb==3) 
		return m_CircleArray.GetUpperBound(); 
	else if(Lb==4) 
		return m_ArcArray.GetUpperBound(); 
	else if(Lb==5) 
		return m_TextArray.GetUpperBound(); 
	return -1; 
} 
 
int CDrawDoc::GetLineId() 
{ 
	int nn=m_LineArray.GetUpperBound(); 
	for(int i=0;i<20000;i++) 
		m_Index[i]=0; 
	for(i=0;i=nn;i++) 
	{ 
		if(GetLine(i)) 
			m_Index[GetLine(i)->GetID()]=1; 
	} 
	for(i=0;i<20000;i++) 
	{ 
		if(m_Index[i]==0) 
			return i; 
	} 
	return -1; 
} 
 
int CDrawDoc::GetPLineId() 
{ 
	int nn=m_PLineArray.GetUpperBound(); 
	for(int i=0;i<20000;i++) 
		m_Index[i]=0; 
	for(i=0;i=nn;i++) 
	{ 
		if(GetPLine(i)) 
			m_Index[GetPLine(i)->GetID()]=1; 
	} 
	for(i=0;i<20000;i++) 
	{ 
		if(m_Index[i]==0) 
			return i; 
	} 
	return -1; 
} 
 
int CDrawDoc::GetArcId() 
{ 
	int nn=m_ArcArray.GetUpperBound(); 
	for(int i=0;i<20000;i++) 
		m_Index[i]=0; 
	for(i=0;i=nn;i++) 
	{ 
		if(GetArc(i)) 
			m_Index[GetArc(i)->GetID()]=1; 
	} 
	for(i=0;i<20000;i++) 
	{ 
		if(m_Index[i]==0) 
			return i; 
	} 
	return -1; 
} 
 
int CDrawDoc::GetTextId() 
{ 
	int nn=m_TextArray.GetUpperBound(); 
	for(int i=0;i<20000;i++) 
		m_Index[i]=0; 
	for(i=0;i=nn;i++) 
	{ 
		if(GetText(i)) 
			m_Index[GetText(i)->GetID()]=1; 
	} 
	for(i=0;i<20000;i++) 
	{ 
		if(m_Index[i]==0) 
			return i; 
	} 
	return -1; 
} 
 
int CDrawDoc::GetCircleId() 
{ 
	int nn=m_CircleArray.GetUpperBound(); 
	for(int i=0;i<20000;i++) 
		m_Index[i]=0; 
	for(i=0;i=nn;i++) 
	{ 
		if(GetCircle(i)) 
			m_Index[GetCircle(i)->GetID()]=1; 
	} 
	for(i=0;i<20000;i++) 
	{ 
		if(m_Index[i]==0) 
			return i; 
	} 
	return -1; 
} 
 
void CDrawDoc::OnEditUndo() 
{ 
	int i,Numble; 
	if(n_CurUnIndex=0) 
		return; 
	if(m_UndoList[n_CurUnIndex-1].Lb==2)//Èç¹ûÔ­À´ÊÇÔö¼Ó²Ù×÷ 
	{ 
		Numble=m_UndoList[n_CurUnIndex-1].Index; 
		Fundo.Seek(m_UndoList[n_CurUnIndex-1].l_Start,0); 
		for(i=0;i<Numble;i++) 
			Fundo.Read((unsigned char *)&GraphSelect[i],sizeof(GraphSelect[i])); 
		for(i=Numble-1;i>=0;i--) 
		{ 
			int Lb=GraphSelect[i].Lb; 
			if(Lb==1) 
			{ 
				delete GetLine(GraphSelect[i].Index); 
				m_LineArray.RemoveAt(GraphSelect[i].Index); 
			} 
			else if(Lb==2) 
			{ 
				delete GetPLine(GraphSelect[i].Index); 
				m_PLineArray.RemoveAt(GraphSelect[i].Index); 
			} 
			else if(Lb==3) 
			{ 
				delete GetCircle(GraphSelect[i].Index); 
				m_CircleArray.RemoveAt(GraphSelect[i].Index); 
			} 
			else if(Lb==4) 
			{ 
				delete GetArc(GraphSelect[i].Index); 
				m_ArcArray.RemoveAt(GraphSelect[i].Index); 
			} 
			else if(Lb==5) 
			{ 
				delete GetText(GraphSelect[i].Index); 
				m_TextArray.RemoveAt(GraphSelect[i].Index); 
			} 
		} 
	} 
	if(m_UndoList[n_CurUnIndex-1].Lb==3)//Èç¹ûÔ­À´ÊÇɾ³ý²Ù×÷ 
	{ 
		Numble=m_UndoList[n_CurUnIndex-1].Index; 
		Fundo.Seek(m_UndoList[n_CurUnIndex-1].l_Start,0); 
		for(i=0;i<Numble;i++) 
		{ 
			Fundo.Read((unsigned char *)&GraphSelect[i],sizeof(GraphSelect[i])); 
			int Lb=GraphSelect[i].Lb; 
			if(Lb==1) 
				GetLine(GraphSelect[i].Index)->Delete(0); 
			else if(Lb==2) 
				GetPLine(GraphSelect[i].Index)->Delete(0); 
			else if(Lb==3) 
				GetCircle(GraphSelect[i].Index)->Delete(0); 
			else if(Lb==4) 
				GetArc(GraphSelect[i].Index)->Delete(0); 
			else if(Lb==5) 
				GetText(GraphSelect[i].Index)->Delete(0); 
		} 
	} 
	n_CurUnIndex--; 
	UpdateAllViews(NULL); 
} 
 
BOOL CDrawDoc::OnSaveDocument(LPCTSTR lpszPathName)  
{ 
	return COleDocument::OnSaveDocument(lpszPathName); 
} 
 
void CDrawDoc::OnUpdateEditUndo(CCmdUI* pCmdUI)  
{ 
	if(n_CurUnIndex>0) 
		pCmdUI->Enable(TRUE); 
	else 
		pCmdUI->Enable(FALSE); 
} 
 
CDataBaseSet* CDrawDoc::GetDataSet(int Index) 
{ 
	CDataBaseSet *m_pSet; 
	if(Index<0||Index>=m_NumbData) 
		return NULL; 
	short ID=DataInfo[Index].only_ID; 
	switch(ID) 
	{ 
		case 1: 
			m_pSet=&m_data1; 
			break; 
		case 2: 
			m_pSet=&m_data2; 
			break; 
/*		case 3: 
			m_pSet=&m_data3; 
			break; 
		case 4: 
			m_pSet=&m_data4; 
			break; 
		case 5: 
			m_pSet=&m_data5; 
			break; 
		case 6: 
			m_pSet=&m_data6; 
			break;*/ 
		default: 
			m_pSet=NULL; 
	} 
	return m_pSet; 
} 
 
short CDrawDoc::GetDataID(int Index) 
{ 
	if(Index<0||Index>=m_NumbData) 
		return -1; 
	return DataInfo[Index].only_ID; 
} 
 
short CDrawDoc::GetDataIndex(int ID) 
{ 
	for(int i=0;i<m_NumbData;i++) 
	{ 
		if(ID==DataInfo[i].only_ID) 
			return i; 
	} 
	return -1; 
} 
 
//int CLine::LineLine(float xx1,float yy1,float xx2,float yy2,float *xxx1,float *yyy1,float *xxx2,float *yyy2) 
int CLine::LineLine(CLine* line1,float *xxx1,float *yyy1,float *xxx2,float *yyy2) 
{ 
	float xx1,xx2,yy1,yy2; 
	float x1,x2,y1,y2,n1,n2,n3,n4; 
	float k1,k2; 
	if(m_X1>m_X2) 	//½«µÚÒ»ÌõÖ±Ï߶εÄÁ½¸ö¶¥µã°´ºá×ø±êÓÉСµ½´óÅÅÐò 
	{ 
		xx1=m_X2; 
		xx2=m_X1; 
		yy1=m_Y2; 
		yy2=m_Y1; 
	} 
	else 
	{ 
		xx1=m_X1; 
		xx2=m_X2; 
		yy1=m_Y1; 
		yy2=m_Y2; 
	} 
	if(xx1==xx2&&yy1==yy2)	//Èç¹ûµÚÒ»ÌõÖ±ÏßÊÇÒ»¸öµã£¬·µ»Ø0£¨²»Ïཻ£© 
		return 0; 
	 
	if(line1->m_X1>line1->m_X2) 	//½«µÚÒ»ÌõÖ±Ï߶εÄÁ½¸ö¶¥µã°´ºá×ø±êÓÉСµ½´óÅÅÐò 
	{ 
		x1=line1->m_X2; 
		x2=line1->m_X1; 
		y1=line1->m_Y2; 
		y2=line1->m_Y1; 
	} 
	else 
	{ 
		x1=line1->m_X1; 
		x2=line1->m_X2; 
		y1=line1->m_Y1; 
		y2=line1->m_Y2; 
	} 
 
	if(x1==x2&&y1==y2)	//Èç¹ûµÚ¶þÌõÖ±ÏßÊÇÒ»¸öµã·µ»Ø0£¨²»Ïཻ£© 
		return 0; 
 
	if(x1==x2&&xx1==xx2) 	//Á½ÌõÖ±Ï߶¼ÊÇÊúÖ±Ïß 
	{ 
		if(x1!=xx1) 	//Á½¸öƽÐÐÊúÖ±Ïߵĺá×ø±ê²»Í¬£¬Á½ÌõÖ±Ï߶β»Ïཻ£¬º¯Êý·µ»Ø0 
			return 0;	 
		*xxx1=x1;		//µÃµ½½»µãµÄºá×ø±ê 
		n1=min(yy1,yy2);	//µÚÒ»ÌõÖ±Ï߶εÄ×îС×Ý×ø±ê 
		n2=max(yy1,yy2);	//µÚÒ»ÌõÖ±Ï߶εÄ×î´ó×Ý×ø±ê 
		n3=min(y1,y2);		//µÚ¶þÌõÖ±Ï߶εÄ×îС×Ý×ø±ê 
		n4=max(y1,y2);		//µÚ¶þÌõÖ±Ï߶εÄ×î´ó×Ý×ø±ê 
		if(n1>n4||n2<n3) 	//Á½Ìõºá×ø±êÏàͬµÄÊúÖ±Ïß×Ý×ø±êûÓн»²æ£¬Á½ÌõÖ±Ïß²»Ïཻ 
			return 0; 
		else if(n1==n4||n2==n3)	//Á½Ìõºá×ø±êÏàͬµÄÊúÖ±Ïß×Ý×ø±êÓÐÒ»µãÏཻ£¨Á¬½Ó£© 
		{ 
			if(n1==n4)	//µÚÒ»ÌõÖ±ÏߵĿªÊ¼µãÓëµÚ¶þÌõÖ±ÏߵĽáÊøµãÏàͬ 
			{ 
				*yyy1=n1; 
				return 1; 
			} 
			if(n2==n3)	//µÚÒ»ÌõÖ±ÏߵĽáÊøµãÓëµÚ¶þÌõÖ±ÏߵĿªÊ¼µãÏàͬ 
			{ 
				*yyy1=n2; 
				return 1; 
			} 
		} 
		else		//Èç¹ûÁ½ÌõÖ±ÏßµÄ×Ý×ø±êÖصþ 
		{ 
			*yyy1=max(n1,n3);	//ÖصþÖ±Ï߶εÄÆðµã×Ý×ø±ê 
			*yyy2=min(n2,n4);	//ÖصþÖ±Ï߶εĽáÊø×÷×ø±ê 
			return 2;	//Ö±ÏßÖصþ 
		} 
	} 
 
	else if(x1==x2&&xx1!=xx2)	//µÚÒ»ÌõÖ±ÏßÊÇбÏߣ¬µÚ¶þÌõÖ±Ï߶ÎÊÇÊúÖ±Ïß 
	{ 
		*xxx1=x1;		//µÃµ½½»µãµÄºá×ø±ê 
		if(!(x1>=xx1&&x1=xx2))	//Èç¹û½»µãºá×ø±êûÓÐÔÚµÚÒ»ÌõÖ±Ïߵĺá×ø±ê·¶Î§ÄÚ£¬²»Ïཻ 
			return 0; 
		*yyy1=yy1+(x1-xx1)/(xx2-xx1)*(yy2-yy1);	//¼ÆËãµÃµ½½»µãµÄ×÷×ø±ê 
		if(*yyy1>=y1&&*yyy1=y2||*yyy1>=y2&&*yyy1=y1)	//½»µã×Ý×ø±êÔÚµÚ¶þÖ±Ïß×Ý×ø±ê·¶Î§ 
			return 1;		//·µ»Ø1£¬ÓÐÒ»¸ö½»µã 
		else 	//½»µã×Ý×ø±êûÓÐÔÚµÚ¶þÖ±Ïß×Ý×ø±ê·¶Î§ÄÚ 
			return 0;		//·µ»Ø0£¬Á½ÌõÖ±Ïß²»Ïཻ 
	} 
	else if(x1!=x2&&xx1==xx2)	//Èç¹ûµÚÒ»ÌõÖ±ÏßÊÇÊúÖ±Ïߣ¬µÚ¶þÌõÖ±ÏßÊÇбÏß 
	{ 
		*xxx1=x1; 
		if(!(xx1>=x1&&xx1=x2))  
			return 0; 
		*yyy1=y1+(xx1-x1)/(x2-x1)*(y2-y1); 
		if(*yyy1>=yy1&&*yyy1=yy2||*yyy1>=yy2&&*yyy1=yy1) 
			return 1;//Ïཻ 
		else  
			return 0; 
	} 
	else //Èç¹ûÁ½ÌõÖ±Ï߶¼ÊÇбÏß 
	{ 
		//µÃµ½Á½ÌõÖ±ÏßµÄбÂÊ 
		k1=(y2-y1)/(x2-x1); 
		k2=(yy2-yy1)/(xx2-xx1); 
		if(k1==k2) //Èç¹ûÁ½ÌõÖ±ÏßƽÐÐ 
		{ 
			if(x1>xx2||x2<xx1) //Á½ÌõÖ±Ïߵĺá×ø±ê²»Öصþ 
				return 0;		//·µ»Ø0£¬Á½ÌõÖ±Ïß²»Ïཻ 
			else 
			{ 
				//ÒÔÏ·ֱðµÃµ½Í¬Ò»ºá×ø±êx1Ï£¬ÔÚÁ½ÌõÖ±ÏßÉϵÄ×Ý×ø±ê 
				n1=y1+(0-x1)*k1;	//µÚ¶þÌõÖ±ÏßµÄ×Ý×ø±ê 
				n2=yy1+(0-x1)*k2;	//µÚÒ»ÌõÖ±ÏßµÄ×Ý×ø±ê 
				if(n1!=n2)	//Á½ÌõÖ±ÏßµÄ×Ý×ø±ê²»Í¬£¬¼´Á½ÌõÖ±ÏßƽÐÐ 
					return 0; 
				else			//Èç¹ûÁ½ÌõÖ±ÏßµÄ×Ý×ø±êÏàµÈ£¬¼´Á½ÌõÖ±ÏßÖØºÏ 
				{ 
					n3=max(xx1,x1);	//Öغ϶ÎÆðµãºá×ø±ê 
					n4=min(xx2,x2); 	//Æðµã¶ÎÖÕµãºá×ø±ê 
					*xxx1=n3;			//Æðµãºá×ø±ê 
					*yyy1=y1+(n3-x1)*k1;	//Öغ϶ÎÆðµã×Ý×ø±ê 
					if(n3==n4) 		//Èç¹ûÖغ϶ÎÊÇÒ»¸öµã 
						return 1; 
					*xxx2=n4;			//Öغ϶ÎÖÕµãºá×ø±ê 
					*yyy2=y1+(n4-x1)*k1;	//Öغ϶ÎÖصã×Ý×ø±ê 
					return 2; 
				}       
			}    
		} 
		else	//Èç¹ûÁ½ÌõÖ±Ï߶¼ÊÇбÏß 
		{ 
			*xxx1=(yy1-y1+x1*k1-xx1*k2)/(k1-k2);	//½»µãµÄºá×ø±ê 
			*yyy1=y1+(*xxx1-x1)*k1;				//½»µãµÄ×Ý×ø±ê 
			//Èç¹û½»µãºá×ø±êÔÚÁ½ÌõÖ±Ï߶εĺá×ø±ê·¶Î§ÄÚ 
			if((*xxx1>=x1&&*xxx1=x2)&&(*xxx1>=xx1&&*xxx1=xx2)) 
				return 1;	//ÓÐÒ»¸ö½»µã 
			else //Èç¹û½»µãºá×ø±ê²»È«ÔÚÁ½ÌõÖ±Ï߶εĺá×ø±ê·¶Î§ÄÚ 
				return 0; 
		} 
	} 
	return 0; 
} 
 
 
	int CPline::LineRgn(CLine* line1,int *nCross,PointStruct* Pointxy1) 
	{ 
		int pb,sm,pb1; 
		float x1,y1,x2,y2; 
		float xx1,yy1,xx2,yy2; 
		CLine line2; 
		xx1=line1->m_X1; 
		yy1=line1->m_Y1; 
		xx2=line1->m_X2; 
		yy2=line1->m_Y2; 
		//¼ÓÉÏÒ»¸ö¶¥µã£¬ÐγɱպÍÇøÓò 
		m_PointList[m_Numble].x=m_PointList[0].x; 
		m_PointList[m_Numble].y=m_PointList[0].y; 
		//½«Á¬ÐøÖ±ÏߵĵÚÒ»¸ö¶¥µã×÷ΪµÚÒ»¸ö½»µã 
		Pointxy1[0].x=xx1; 
		Pointxy1[0].y=yy1; 
		sm=1; 	//½»µãµÄÊýĿΪ1£¬Ö±ÏßµÄÆðµã×÷ΪµÚÒ»¸ö½»µã 
		 
		for(int i=0;i<m_Numble;i++)	//¶ÔÁ¬ÐøÖ±ÏßµÄËùÓÐÖ±Ï߶ÎÑ­»· 
		{ 
			x1=line2.m_X1=m_PointList[i].x;	//Ö±Ï߶εÄÆðµãºá×ø±ê 
			y1=line2.m_Y1=m_PointList[i].y;	//Ö±Ï߶εÄÆðµãÖØ×ø±ê 
			x2=line2.m_X2=m_PointList[i+1].x;	//Ö±Ï߶εÄÖÕµãºá×ø±ê 
			y2=line2.m_Y2=m_PointList[i+1].y;	//Ö±Ï߶εÄÖÕµã×Ý×ø±ê 
			//¼ÆËãÖ±ÏßÓëÁ¬ÐøÖ±ÏßµÄÒ»¸öÖ±Ï߶εĽ»µã 
			pb=line2.LineLine(line1,&x1,&y1,&x2,&y2); 
			if(pb>=1)	//Èç¹ûÓн»µã£¬½«µÚÒ»¸ö½»µãµÄ×ø±ê¼Ç¼ÔڽṹָÕëPointxy1Ö¸ÏòµÄ½á¹¹Êý×é 
			{ 
				Pointxy1[sm].x=x1;		 
				Pointxy1[sm++].y=y1;	 
			} 
			if(pb==2)	//ÈçÓÐÁ½¸ö½»µã£¬½«µÚ¶þ¸ö½»µãµÄ×ø±ê¼Ç¼ÔÚÖ¸ÕëPointxy1Ö¸ÏòµÄ½á¹¹Êý×é 
			{ 
				Pointxy1[sm].x=x2; 
				Pointxy1[sm++].y=y2; 
			} 
		} 
		//½«Ö±ÏßµÄÖÕµã×÷Ϊ×îºóÒ»¸ö½»µã 
		Pointxy1[sm].x=xx2; 
		Pointxy1[sm++].y=yy2; 
		//ÒÔ϶Խ»µãµÄ×ø±ê½øÐÐÅÅÐò 
		pb=1;//°´ºá×ø±êÅÅÐò 
		if(xx1==xx2) //Èç¹ûÖ±ÏßÊÇÊúÖ±Ïߣ¬°´×Ý×ø±êÅÅÐò 
			pb=2; 
		do  //°´ºá×ø±ê»ò×Ý×ø±êÅÅÐò 
		{ 
			pb1=0; 
			for(i=0;i<sm-1;i++) 
			{ 
				//Èç¹ûÁ¬ÐøÁ½¸ö½»µãµÄºá×ø±ê»ò×Ý×ø±ê˳ÐòÓëÆðµãµ½ÖÕµãµÄ˳Ðò·´Ïò£¬ 
				//½»»»Á½¸ö½»µãµÄλÖà 
				if(pb==1&&(Pointxy1[i].x>Pointxy1[i+1].x&&xx1<xx2 
					||Pointxy1[i].x<Pointxy1[i+1].x&&xx1>xx2) 
					||pb==2&&(Pointxy1[i].y>Pointxy1[i+1].y&&yy1<yy2 
					||Pointxy1[i].y<Pointxy1[i+1].y&&yy1>yy2)) 
				{ 
					x1=Pointxy1[i].x; y1=Pointxy1[i].y; 
					Pointxy1[i].x=Pointxy1[i+1].x; Pointxy1[i].y=Pointxy1[i+1].y; 
					Pointxy1[i+1].x=x1; Pointxy1[i+1].y=y1; 
					pb1=1; 
				} 
			} 
		}while(pb1==1);//Ö±µ½ËùÓеĽ»µã¶¼ÊÇ°´ÕÕºá×ø±ê»ò×Ý×ø±ê˳ÐòÅÅÁÐ 
 
		for(i=0;i<sm-1;i++)//¼ì²éÁ½¸öÏàÁÚ½»µãµÄÖмäµãÊÇ·ñÔÚ¶à±ßÐÎÇøÓò 
		{ 
			x1=(Pointxy1[i].x+Pointxy1[i+1].x)/2;	//ÖеãµÄºá×ø±ê 
			y1=(Pointxy1[i].y+Pointxy1[i+1].y)/2;	//ÖеãµÄ×Ý×ø±ê 
			if(PointRgn(x1,y1,m_Numble,m_PointList,1)) 	//ÅжÏÖеãÊÇ·ñÔÚ¶à±ßÐÎÇøÓòÄÚ 
				Pointxy1[i].z=1; 	//ÖеãÔÚ¶à±ßÐÎÇøÓòÄÚ 
			else 
				Pointxy1[i].z=0;	//Öе㲻ÔÚ¶à±ßÐÎÇøÓòÄÚ 
		} 
		*nCross=sm;		//½»µãµÄÊýÄ¿ 
		if(*nCross==2)		//Èç¹ûÖ»ÓÐÁ½¸ö½»µã 
		{ 
			if(Pointxy1[0].z==1)	//Èç¹ûÕâÁ½¸ö½»µãµÄÖеãÔÚÇøÓòÄÚ 
				return 1;			//Ö±Ïß°üº¬ÔÚ¶à±ßÐÎÇøÓòÄÚ£¬º¯Êý·µ»Ø1 
			else 				//Èç¹ûÖе㲻ÔÚÇøÓòÄÚ 
				return 0;			//Ö±ÏßÔÚ¶à±ßÐÎÇøÓòÍ⣬º¯Êý·µ»Ø0 
		} 
		else			//Èç¹û¶àÓÚ2¸ö½»µã 
			return 2;//Ö±ÏßÓë¶à±ßÐÎÇøÓòÏཻ£¬º¯Êý·µ»Ø2 
	} 
 
 
int CPline::PLineRgn(CPline* pline1,int *nCross,PointStruct* Pointxy1) 
{ 
	float x1,y1,x2,y2; 
	int NumbAll,Numb; 
	BOOL pb1,pb2; 
	PointStruct* Pointxy; 
	CLine line2; 
	Pointxy=new PointStruct[m_Numble*2+2]; 
	NumbAll=0; 
	for(int i=0;i<m_Numble-1;i++)	//¶ÔÁ¬ÐøÖ±ÏßµÄËùÓÐÖ±Ï߶ÎÑ­»· 
	{ 
		x1=line2.m_X1=m_PointList[i].x;	//Ö±Ï߶εÄÆðµãºá×ø±ê 
		y1=line2.m_Y1=m_PointList[i].y;	//Ö±Ï߶εÄÆðµãÖØ×ø±ê 
		x2=line2.m_X2=m_PointList[i+1].x;	//Ö±Ï߶εÄÖÕµãºá×ø±ê 
		y2=line2.m_Y2=m_PointList[i+1].y;	//Ö±Ï߶εÄÖÕµã×Ý×ø±ê 
		pline1->LineRgn(&line2,&Numb,Pointxy); 
		for(int j=0;j<Numb-1;j++) 
			Pointxy1[NumbAll++]=Pointxy[j]; 
 
	} 
	Pointxy1[NumbAll++]=Pointxy[Numb-1]; 
	*nCross=NumbAll;	 
	pb1=0; 
	pb2=0; 
	for(i=0;i<NumbAll-1;i++) 
	{ 
		if(Pointxy1[i].z==1) 
			pb1=1; 
		else  
			pb2=1; 
	} 
	delete Pointxy; 
	if(pb1==1&&pb2==1) 
		return 2; 
	else if(pb1==1&&pb2==0) 
		return 1; 
	else  
		return 0; 
} 
 
int CCircle::CircleLine(CLine* line1,float *angle1,float *angle2,float *X1, float *Y1, float *X2, float *Y2) 
{ 
	float x1,y1,x2,y2; 
	float xx1,yy1,xx2,yy2,k,k1,k2; 
	float yy,miny,maxy; 
	int pb; 
	float x,y,r; 
	x=m_CircleX; 
	y=m_CircleY; 
	r=m_CircleR; 
	//½«Ô­µãµÄλÖÃÒƶ¯µ½(x,y),Ö±ÏßµÄ×ø±êÒ²×öÏàÓ¦µÄ¸Ä±ä 
	x1=line1->m_X1-x; 
	y1=line1->m_Y1-y; 
	x2=line1->m_X2-x; 
	y2=line1->m_Y2-y; 
	if(x1==x2) //Èç¹ûÊÇ´¹Ö±Ïß 
	{ 
		if(x1*x1>r*r) 
			return 0; 
		else 
		{ 
			yy=(float)sqrt(r*r-x1*x1);  
			yy1=-yy;  yy2=yy; //µÃµ½Á½¸ö½»µãµÄy×ø±ê 
			//µÃµ½Ï߶εÄ×îСºÍ×î´óy×ø±ê 
			miny=min(y1,y2); maxy=max(y1,y2); 
			if(miny>yy1&&maxy<yy2) 
			{ 
				return 3; 
			} 
			pb=0; 
			if(yy1>=miny&&yy1=maxy)//Èç¹ûµÚÒ»¸ö½»µãÔÚÏ߶ÎÉÏ 
			{ 
				*Y1=yy1+y; //·µ»ØµÚÒ»¸ö½»µãµÄ×ø±ê 
				*angle1=(float)pi*3/2; 
				pb=1; 
			} 
			//Èç¹ûµÚ¶þ¸ö½»µãÔÚÏ߶ÎÉÏÇÒµÚ¶þ¸ö½»µã²»µÈµÚÒ»¸ö½»µã 
			if(yy1!=yy2&&yy2>=miny&&yy2=miny) 
			{ 
				if(pb==1)     //Èç¹ûµÚÒ»¸ö½»µãÒѾ­ÔÚÏ߶ÎÉÏ 
				{ 
					*Y2=yy2+y; 
					*angle2=(float)pi/2; 
					pb=2;                  //Á½¸ö½»µã 
 
				} 
				else                   //Èç¹ûµÚÒ»¸ö½»µã²»ÔÚÏ߶ÎÉÏ 
				{ 
					*Y1=yy2+y;    //Ö»ÓÐÒ»¸ö½»µã£¬·µ»Ø½»µã×ø±ê 
					*angle1=(float)pi/2; 
					pb=1; 
				} 
			} 
			return pb;//·µ»ØÏཻµÄµãÊý 
		} 
	} 
	else    //Èç¹ûÖ±Ïß²»´¹Ö± 
	{ 
		k=(y1-y2)/(x1-x2);  //µÃµ½Ö±ÏßµÄбÂÊ 
		k1=y1-k*x1; 
		k2=4*k*k*k1*k1-4*(k*k+1)*(k1*k1-r*r);//½â·½³ÌʱµÄb2-4ac 
		if(k2<0)return 0; 
		else  // Èç¹ûb*b-4ac,Ö±ÏßÓëÔ²Óн»µã 
		{ 
			//µÃµ½Á½¸ö½»µãµÄ×ø±ê 
			xx1=(-2*k*k1-(float)sqrt(k2))/(2*(k*k+1)); 
			xx2=(-2*k*k1+(float)sqrt(k2))/(2*(k*k+1)); 
			yy1=y1+k*(xx1-x1); 
			yy2=y1+k*(xx2-x1); 
			if(x1>xx1&&x1<xx2&&x2>xx1&&x2<xx2)	//Èç¹ûÖ±Ï߶ÎÔÚÁ½¸ö½»µãÄÚ 
				return 3; 
			pb=0; 
		 
			if(xx1>=x1&&xx1=x2||xx1=x1&&xx1>=x2)//ÅжϵÚÒ»¸ö½»µãÊÇ·ñÔÚÏ߶ÎÉÏ 
			{ 
				*X1=xx1+x; 
				*Y1=yy1+y; 
				*angle1=GetAngle(0,0,xx1,yy1); 
				pb=1; //·µ»ØµÚÒ»¸ö½»µãµÄ×ø±ê 
			} 
			//Èç¹ûÓÐÁ½¸ö½»µã²¢ÇÒµÚ¶þ¸ö½»µãÔÚÖ±Ï߶ÎÉÏ 
			if(k2!=0&&xx1!=xx2&&xx2>=x1&&xx2=x2||xx2=x1&&xx2>=x2) 
			{ 
				if(pb==1) //Èç¹ûµÚÒ»¸ö½»µãÒѾ­ÔÚÏ߶ÎÉÏ£¬ÔòÓÐÁ½¸ö½»µã 
				{ 
					*X2=xx2+x;*Y2=yy2+y;pb=2; //·µ»ØµÚ¶þ¸ö½»µãµÄ×ø±ê 
					*angle2=GetAngle(0,0,xx2,yy2); 
				} 
				else      //Èç¹ûµÚÒ»¸ö½»µã²»ÔÚÏ߶ÎÉÏ 
				{ 
					*X1=xx2+x;*Y1=yy2+y; 
					*angle1=GetAngle(0,0,xx2,yy2); 
					pb=1; 
 
				} 
			} 
			return pb; //·µ»Ø½»µãÊýÄ¿ 
		} 
	} 
	return 0; 
} 
 
int CArc::ArcLine(CLine *line1, float *angle1, float *angle2, float *X1, float *Y1, float *X2, float *Y2) 
{ 
	float x1,y1,x2,y2; 
	float angl1,angl2; 
	int pb,pb1; 
	//µ÷Óú¯ÊýµÃµ½Ô²ºÍÏ߶εĽ»µãÊýÄ¿ºÍ½»µãµÄ×ø±ê 
	pb=CircleLine(line1,&angl1,&angl2,&x1,&y1,&x2,&y2); 
	pb1=0; 
	if(pb==0||pb==3) // Ô²ÓëÏ߶β»Ïཻ£¬Ôò»¡ÓëÏ߶ÎÒ²²»Ïཻ 
		return 0; 
	else     //Ô²ÓëÖ±ÏßÓн»µã 
	{ 
		//Èç¹ûÕâ¸ö½»µãµÄ»¡¶ÈÔÚÔ²»¡µÄ·¶Î§ÄÚ 
		if(IsInArc(angl1)) 
		{ 
			pb1=1;      //ÓÐÒ»¸ö½»µã 
			*angle1=angl1; //µÚÒ»¸ö½»µãµÄ»¡¶È 
			*X1=x1;	*Y1=y1;		 
		} 
		if(pb==2)     //Èç¹ûÓÐÁ½¸ö½»µã 
		{ 
			//Èç¹ûÕâ¸ö½»µãµÄ»¡¶ÈÔÚÔ²»¡µÄ·¶Î§ÄÚ 
			if(IsInArc(angl2)) 
			{ 
				if(pb1==1)  
				{ 
					*X2=x2;	*Y2=y2; 
					*angle2=angl2;//Èç¹ûÕâÊǵڶþ¸ö½»µã 
				} 
				else          //Èç¹ûÕâÊÇÔ²»¡ÓëÖ±ÏߵĵÚÒ»¸ö½»µã 
				{ 
					*angle1=angl2; //·µ»Ø½»µãµÄ»¡¶È 
					*X1=x2;	*Y1=y2; 
				} 
				pb1++; //Ô²»¡ÓëÖ±Ïß½»µãµÄÊýÄ¿ 
			} 
		}   
		return pb1; //·µ»Ø½»µãÊýÄ¿ 
	} 
	return 0; 
} 
 
float CDraw::GetAngle(float x, float y, float xx, float yy) 
{ 
	float r,ang; 
	if(x==xx&&y==yy) 
		return 0; 
	if(x==xx) //Èç¹ûÁ¬½ÓÁ½µãµÄÖ±Ïß´¹Ö± 
	{ 
		if(yy>y) 
			ang=(float)(pi/2);   //YÖáÕý·½Ïò 
		else 
			ang=(float)(pi*3/2); //YÖḺ·½Ïò 
		return ang; 
	}  
	else 
	{ 
		r=(float)sqrt((xx-x)*(xx-x)+(yy-y)*(yy-y));//µÃµ½Á½µãµÄ¾àÀë 
		ang=(float)acos((xx-x)/r);                 //µÃµ½»¡¶È 
		if(yy<y)  
			ang=(float)(pi*2)-ang;              //½«»¡¶È·¶Î§ÔÚ0-2pi 
		return ang; 
	} 
} 
 
int CPline::ArcRgn(CArc* arc1,int *nCross,PointStruct *Pointxy1) 
{ 
	int i,numb,nn,pb; 
	float ang1,ang2,x1,y1,x2,y2; 
	float angle[400]; 
	CLine line1; 
	float angl1,angl2; 
	/* 
		´Ë´¦Ê¡ÂÔ¼ì²é»¡µÄ±ß½ç¾ØÐκͶà±ßÐεı߽ç¾ØÐÎÊÇ·ñÖصþµÄ´úÂëÈç¹û²» 
		Öصþ£¬·µ»Ø²»Ïཻ±êÖ¾ 
	*/ 
	numb=0;//»¡ÓëÁ¬ÐøÖ±Ïß½»µãµÄÊýĿΪ0£» 
	angl1=arc1->m_Angle1; 
	angl2=arc1->m_Angle2; 
	angle[numb++]=angl1; //½«Ô²»¡µÄÆðʼ»¡¶È×÷ΪµÚÒ»¸öÏཻ»¡¶È 
	m_PointList[m_Numble].x=m_PointList[0].x; 
	m_PointList[m_Numble].y=m_PointList[0].y; 
	for(i=0;i<m_Numble;i++) 
	{ 
		 
		//µÃµ½Ö±ÏßµÄÆðÖÕ×ø±ê 
		line1.m_X1=m_PointList[i].x; 
		line1.m_Y1=m_PointList[i].y; 
		line1.m_X2=m_PointList[i+1].x; 
		line1.m_Y2=m_PointList[i+1].y; 
		 
		nn=arc1->ArcLine(&line1,&ang1,&ang2,&x1,&y1,&x2,&y2); //¼ÆËãÔ²»¡ÓëÖ±ÏߵĽ»µã 
		if(nn>=1)   //Èç¹û´æÔÚ½»µã 
		{ 
			angle[numb++]=ang1; //½«½»µãµÄ»¡¶È´æÊý×éangle 
			if(nn==2)  //Èç¹ûÓÐÁ½¸ö½»µãµÄ»°   
				angle[numb++]=ang2; 
		} 
	} 
	angle[numb++]=angl2;//Ô²»¡µÄÖÕµã×÷Ϊ×îºóÒ»¸ö½»µã 
	//Èç¹û»¡ÊÇ¿çXÖáÕýÏòµÄ£¬XÖáÕýÏòµ½½áÊø²¿·ÖµÄ»¡¶ÈÖµ¼Ó2pi£¬ÒÔÀûÓÚÅÅÐò 
	if(angl1>angl2) 
	{ 
		for(i=0;i<numb;i++) 
		{ 
			if(angle[i]>=0&&angle[i]=angl2) 
				angle[i]=(float)pi*2+angle[i]; 
		} 
	} 
		//ÒÔ϶ÔangleÊý×éÖеĻ¡¶ÈÖµ½øÐÐÅÅÐò 
	do 
	{ 
		pb=0; 
		for(i=0;i<numb-1;i++) 
		{ 
			if(angle[i]>angle[i+1])//Èç¹û˳ÐòÏà·´     
			{ 
				pb=1; 
				ang1=angle[i]; angle[i]=angle[i+1];angle[i+1]=ang1; 
			}  
		} 
	}while(pb==1);//Èç¹û»¹Óе¹ÐòµÄ£¬ÔÙ½øÐÐÑ­»·±È½Ï 
	pb=0; 
	for(i=0;i<numb-1;i++) 
	{ 
		Pointxy1[i].x=angle[i]; //½«½»µãµÄ»¡¶ÈÖµ´æÈëPointxy1ÖÐ 
		ang1=(angle[i]+angle[i+1])/2; //Á½¸öÏàÁÙ½»µãµÄÖм仡¶ÈÖµ 
		//µÃµ½ÏàÁÚÔ²»¡½»µãµÄÖм仡¶ÈµãµÄ×ø±ê 
		x1=arc1->m_CircleX+arc1->m_CircleR*(float)cos(ang1);  
		y1=arc1->m_CircleY+arc1->m_CircleR*(float)sin(ang1); 
		if(PointRgn(x1,y1,m_Numble,m_PointList,1)) //Èç¹ûÖмäµãÔÚ¶à±ßÐÎÇøÓòÄÚ 
			Pointxy1[i].z=1; 
		else 
			Pointxy1[i].z=0; 
	}   
	Pointxy1[numb-1].x=angle[numb-1]; //×îºóÒ»¸ö½»µãµÄ»¡¶ÈÖµ 
	*nCross=numb; 
	if(numb==2)	//Èç¹ûÖ»ÓÐÁ½¸ö¶¥µã£¬¼´Ô²»¡Óë¶à±ßÐα߲»Ïཻ 
	{ 
		if(Pointxy1[0].z==1)	//Èç¹ûÔ²»¡¶ÎÔÚ¶à±ßÐÎÇøÓòÄÚ 
			return 1;			//Ô²»¡ÔÚ¶à±ßÐÎÇøÓòÄÚ£¬·µ»Ø1 
		else					//Èç¹ûÔ²»¡¶ÎûÓÐÔÚ¶à±ßÐÎÇøÓòÄÚ 
			return 0;			//Ô²»¡Óë¶à±ßÐÎÇøÓò²»Ïཻ£¬·µ»Ø0 
	} 
	else	//Èç¹û¶àÓÚ2¸ö¶¥µã 
		return 2;	//Ô²»¡Óë¶à±ßÐÎÇøÓòÏཻ£¬·µ»Ø2 
} 
 
 
	int CCircle::CircleCircle(CCircle* cir1,float *angl1,float *angl2) 
	{ 
		float jl,ang,ang1; 
		float x1,y1,r1,x2,y2,r2; 
		x1=m_CircleX; 
		y1=m_CircleY; 
		r1=m_CircleR; 
		x2=cir1->m_CircleX; 
		y2=cir1->m_CircleY; 
		r2=cir1->m_CircleR; 
		 
		//µÚ¶þ¸öÔ²ÐÄÏà¶ÔµÚÒ»¸öÔ²ÐĵĻ¡¶È 
		ang=GetAngle(x1,y1,x2,y2);			//¼ÆËãÁ½¸öÔ²ÐļäµÄ¾àÀë 
		jl=(float)sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)); 
		if(jl+r1<r2)  	//µÚÒ»¸öÔ²ÔÚµÚ¶þ¸öÔ²ÄÚ£¬·µ»Ø10£» 
			return 10;  //  
		else if(jl+r1==r2) //µÚÒ»¸öÔ²ÄÚÇÐÓÚµÚ¶þ¸öÔ² 
		{ 
			*angl1=ang; //·µ»ØÏà¶ÔÓÚµÚÒ»¸öÔ²µÄÔ²ÐĵĻ¡¶È 
			return 11; 
		} 
		else if(r2+jl<r1)	//µÚ¶þ¸öÔ²ÔÚµÚÒ»¸öÔ²ÄÚ£¬·µ»Ø20 
			return 20; 
		else if(jl+r2==r1)	//µÚ¶þ¸öÔ²ÄÚÇÐÓÚµÚÒ»¸öÔ² 
		{ 
			*angl1=ang; //·µ»ØÏà¶ÔÓÚµÚÒ»¸öÔ²ÐĵĻ¡¶È 
			return 21; 
		} 
		else if(r2+r1<jl) //Á½¸öÔ²ÇøÓò²»Öصþ£¬Ã»Óн»µã·µ»Ø0 
			return 0;  
		else if(r2+r1==jl) //Á½¸öÔ²ÍâÇУ¬Ö»ÓÐÒ»¸ö½»µã 
		{                                                   
			*angl1=ang;	//·µ»ØÇеãÏà¶ÔÓÚµÚÒ»¸öÔ²ÐĵĻ¡¶È 
			return 3l; 
		} 
		else  //Èç¹ûÁ½¸öÔ²Ïཻ£¬Ôò·µ»ØÁ½¸ö½»µãÏà¶ÔÓÚµÚÒ»¸öÔ²µÄ»¡¶È 
		{ 
			//µÃµ½½»µãµ½µÚÒ»¸öÔ²ÐĵÄÖ±ÏßÓëÁ½¸öÔ²ÐĵÄÖ±ÏߵĽ»½Ç 
			ang1=(float)acos((r1*r1+jl*jl-r2*r2)/(2*r1*jl)); 
			*angl1=ang-ang1;	//µÃµ½Ò»¸ö½»µãÏà¶ÔÓÚµÚÒ»¸öÔ²ÐĵĻ¡¶È 
			if(*angl1<0) 
				*angl1=(float)pi*2+*angl1; 
			*angl2=ang+ang1;	//µÃµ½µÚ¶þ¸ö½»µãÏà¶ÔÓÚµÚÒ»¸öÔ²ÐĵĻ¡¶È 
			if(*angl2>2*pi) 
				*angl2=*angl2-(float)pi*2; 
			return 2;			//ÓÐÁ½¸ö½»µã 
		} 
	} 
 
int CArc::ArcCircle(CCircle* cir1,int *nCross,PointStruct* Pointxy1) 
{ 
	float ang1,ang2,angle[5],x1,y1,r; 
	int pb,numb,i; 
	numb=0; 
	angle[numb++]=m_Angle1; 
	pb=CircleCircle(cir1,&ang1,&ang2);//µ÷ÓÃCircleCircleº¯ÊýÀ´¼ÆËãÔ²ºÍÔ²µÄÏ໥¹Øϵ 
	if(pb==1||pb==11||pb==21)	//Èç¹ûÔ²»¡ËùÔÚµÄÔ²ºÍÔ²ÐÎÇøÓòÓÐÒ»¸ö½»µã 
	{ 
		if(IsInArc(ang1))		//Èç¹û½»µãÔÚÔ²»¡µÄ»¡¶È·¶Î§ÄÚ 
		{ 
			angle[numb++]=ang1;  
		} 
	}  
	else if(pb==2) //Èç¹ûÔ²»¡ËùÔÚµÄÔ²ºÍÔ²ÐÎÇøÓòÓÐÁ½¸ö½»µã 
	{ 
		if(IsInArc(ang1)) 
		{ 
			angle[numb++]=ang1;  
		} 
		if(IsInArc(ang2)) 
		{ 
			angle[numb++]=ang2;  
		} 
	} 
 
	angle[numb++]=m_Angle2; 
	if(m_Angle1>m_Angle2) 
	{ 
		for(i=0;i<numb;i++) 
		{ 
			if(angle[i]>=0&&angle[i]=m_Angle2) 
				angle[i]=(float)pi*2+angle[i]; 
		} 
	} 
	pb=0; 
	for(i=0;i<numb-1;i++) 
	{ 
		Pointxy1[i].x=angle[i]; 
		ang1=(angle[i]+angle[i+1])/2; 
		x1=m_CircleX+m_CircleR*(float)cos(ang1); 
		y1=m_CircleY+m_CircleR*(float)sin(ang1); 
		r=(float)sqrt((x1-cir1->m_CircleX)*(x1-cir1->m_CircleX)+(y1-cir1->m_CircleY)*(y1-cir1->m_CircleY)); 
		if(r=cir1->m_CircleR) 
			Pointxy1[i].z=1; 
		else 
			Pointxy1[i].z=0; 
	} 
	Pointxy1[numb-1].x=angle[numb-1]; 
	*nCross=numb; 
	if(numb==2)	//Èç¹ûÖ»ÓÐÁ½¸ö¶¥µã£¬¼´Ô²»¡ÓëÔ²ÐÎÇøÓò²»Ïཻ 
	{ 
		if(Pointxy1[0].z==1)	//Èç¹ûÔ²»¡¶ÎÔÚÔ²ÐÎÇøÓòÄÚ 
			return 1;			//Ô²»¡ÔÚÔ²ÐÎÇøÓòÄÚ£¬·µ»Ø1 
		else					//Èç¹ûÔ²»¡¶ÎûÓÐÔÚÔ²ÐÎÇøÓòÄÚ 
			return 0;			//Ô²»¡ÓëÔ²ÐÎÇøÓò²»Ïཻ£¬·µ»Ø0 
	} 
	else	//Èç¹û¶àÓÚ2¸ö¶¥µã 
		return 2;	//Ô²»¡ÓëÔ²ÐÎÇøÓòÏཻ£¬·µ»Ø2 
} 
 
void CDrawDoc::OnTest()  
{ 
	// TODO: Add your command handler code here 
/*	CLine *line1,*line2; 
	line1=GetLine(0); 
	line2=GetLine(1); 
	float x1,y1,x2,y2; 
	int numb; 
	numb=line1->LineLine(line2,&x1,&y1,&x2,&y2); 
	if(numb==0) 
	{ 
		;//Á½ÌõÖ±Ïß²»Ïཻ 
	} 
	else if(numb==1) 
	{ 
		;//Á½ÌõÓÐÒ»¸ö½»µã£¬½»µã×ø±êΪ(x1,y1) 
	} 
	else if(numb==2) 
	{ 
		;//Á½ÌõÖ±Ïß²¿·ÖÖغϣ¬Öغ϶εÄÆðµãºÍÖÕµã×ø±êΪ(x1,y1)ºÍ£¨x2,y2£© 
	} 
*/ 
 
/* 
	CLine* line1; 
	CPline* pline1; 
	PointStruct *Pointxy1; 
	int crossNumb,numb; 
	line1=GetLine(0); 
	pline1=GetPLine(0); 
	Pointxy1=new PointStruct[pline1->GetNumb()*2]; 
	numb=pline1->LineRgn(line1,&crossNumb,Pointxy1); 
	if(numb==0) 
	{ 
		;//Ö±ÏßÔÚ¶à±ßÐÎÇøÓòÍâ 
	} 
	else if(numb==1) 
	{ 
		;//Ö±ÏßÔÚ¶à±ßÐÎÇøÓòÄÚ 
	} 
	else if(numb==2) 
	{ 
		;//Ö±ÏßÓë¶à±ßÐÎÇøÓòÏཻ£¬numb-2Êǽ»µãÊý£¬¸÷¸ö·Ö¸î¶ÎµÄÐÅÏ¢´æ´¢ÔÚPointxy1ÖÐ 
	} 
	delete Pointxy1; 
*/ 
	/* 
	CPline* pline1; 
	CPline* pline2; 
	PointStruct *Pointxy1; 
	int crossNumb,numb; 
	pline1=GetPLine(0); 
	pline2=GetPLine(1); 
	Pointxy1=new PointStruct[pline1->GetNumb()*pline2->GetNumb()+2]; 
	numb=pline1->PLineRgn(pline2,&crossNumb,Pointxy1); 
	if(numb==0) 
	{ 
		;//Ö±ÏßÔÚ¶à±ßÐÎÇøÓòÍâ 
	} 
	else if(numb==1) 
	{ 
		;//Ö±ÏßÔÚ¶à±ßÐÎÇøÓòÄÚ 
	} 
	else if(numb==2) 
	{ 
		;//Ö±ÏßÓë¶à±ßÐÎÇøÓòÏཻ£¬crossNumb-2Êǽ»µãÊý£¬¸÷¸ö·Ö¸î¶ÎµÄÐÅÏ¢´æ´¢ÔÚPointxy1ÖÐ 
	} 
	delete Pointxy1; 
*/ 
/* 
	 
	CCircle* circle1; 
	CLine* line1; 
	float x1,y1,x2,y2,angle1,angle2; 
	circle1=GetCircle(0); 
	line1=GetLine(0); 
	int numb=circle1->CircleLine(line1,&angle1,&angle2,&x1,&y1,&x2,&y2); 
	if(numb==0) 
	{ 
		;//Ö±ÏßÔÚÔ²Íâ 
	} 
	else if(numb==3) 
	{ 
		;//Ö±ÏßÔÚÔ²ÄÚ 
	} 
	else  
	{ 
		;	//Ö±ÏßÓëÔ²Ïཻ£¬numbΪ½»µãÊýÄ¿£¬½»µãµÄ×ø±êΪ(x1,y1)ºÍ(x2,y2) 
			//½»µãÏà¶ÔÓÚÔ²ÐĵĻ¡¶ÈΪangle1ºÍangle2 
	} 
	*/ 
	/* 
	CArc* arc1; 
	CPline* pline1; 
	PointStruct *Pointxy1; 
	int crossNumb,numb; 
	pline1=GetPLine(0); 
	arc1=GetArc(0); 
	Pointxy1=new PointStruct[pline1->GetNumb()*2+2]; 
	numb=pline1->ArcRgn(arc1,&crossNumb,Pointxy1); 
	if(numb==0) 
	{ 
		;//Ô²»¡ÔÚ¶à±ßÐÎÇøÓòÍâ 
	} 
	else if(numb==1) 
	{ 
		;//Ô²»¡ÔÚ¶à±ßÐÎÇøÓòÄÚ 
	} 
	else if(numb==2) 
	{ 
		;//Ô²»¡Óë¶à±ßÐÎÇøÓòÏཻ£¬crossNumb-2Êǽ»µãÊý£¬¸÷¸ö¶¥µã¼°·Ö¸î¶ÎµÄÐÅÏ¢´æ´¢ÔÚPointxy1ÖÐ 
	} 
	delete Pointxy1; 
	*/   
/*	CCircle* circle1; 
	CCircle* circle2; 
	float angle1,angle2; 
	circle1=GetCircle(0); 
	circle2=GetCircle(1); 
	int ret=circle1->CircleCircle(circle2,&angle1,&angle2); 
	if(ret==0) 
	{ 
		;//Á½¸öÔ²·ÖÀë²»Ïཻ£» 
	} 
	else if(ret==10) 
	{ 
		;//µÚÒ»¸öÔ²ÔÚµÚ¶þ¸öÔ²ÄÚ£» 
	} 
	else if(ret==20) 
	{ 
		;//µÚ¶þ¸öÔ²ÔÚµÚÒ»¸öÔ²ÄÚ£» 
	} 
	else if(ret==11) 
	{ 
		;//µÚÒ»¸öÔ²ÄÚÇÐÓÚµÚ¶þ¸öÔ²,angle1·µ»ØÇеãÏà¶ÔÓÚµÚÒ»¸öÔ²ÐĵĻ¡¶È 
	} 
	else if(ret==21) 
	{ 
		;//µÚ¶þ¸öÔ²ÄÚÇÐÓÚµÚÒ»¸öÔ²£¬angle1·µ»ØÇеãÏà¶ÔÓÚµÚÒ»¸öÔ²ÐĵĻ¡¶È 
	} 
	else if(ret==31) 
	{ 
		;//Á½¸öÔ²ÍâÇУ¬angle1·µ»ØÇеãÏà¶ÔÓÚµÚÒ»¸öÔ²ÐĵĻ¡¶È 
	} 
	else if(ret==2) 
	{ 
		;//Á½¸öÔ²Ïཻ£¬angle1ºÍangle2·µ»Ø½»µãÏà¶ÔÓÚµÚÒ»¸öÔ²ÐĵĻ¡¶È 
	} 
*/ 
 
	CArc* arc1; 
	CCircle* circle1; 
	PointStruct Pointxy1[5]; 
	int crossNumb; 
	arc1=GetArc(0); 
	circle1=GetCircle(0); 
	int ret=arc1->ArcCircle(circle1,&crossNumb,Pointxy1);  
	if(ret==0) 
	{ 
		;//Ô²»¡ÔÚÔ²ÐÎÇøÓòÍâ 
	} 
	else if(ret==1) 
	{ 
		;//Ô²»¡ÔÚÔ²ÐÎÇøÓòÄÚ 
	} 
	else if(ret==2) 
	{ 
		;//Ô²»¡ÓëÔ²ÐÎÇøÓòÏཻ£¬crossNumb-2Êǽ»µãÊý£¬¸÷·Ö¸î¶¥µãÒÔ¼° 
		 //¶¥µãºóµÄ·Ö¸î¶ÎµÄÐÅÏ¢´æ´¢ÔÚPointxy1ÖÐ 
	} 
}