caddoc.cpp

来自「故障诊断工作涉及的领域相当广泛」· C++ 代码 · 共 1,099 行 · 第 1/2 页

// CadDoc.cpp : implementation of the CCadDoc class
//

#include "stdafx.h"
#include "Cad.h"
#include "CadDoc.h"
#include "CadView.h"

#include <math.h>

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

/////////////////////////////////////////////////////////////////////////////
// CCadDoc

IMPLEMENT_DYNCREATE(CCadDoc, CDocument)

BEGIN_MESSAGE_MAP(CCadDoc, CDocument)
	//{{AFX_MSG_MAP(CCadDoc)
		// NOTE - the ClassWizard will add and remove mapping macros here.
		//    DO NOT EDIT what you see in these blocks of generated code!
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CCadDoc construction/destruction
CRichEditCntrItem* CCadDoc::CreateClientItem(REOBJECT* preo) const
{
	// cast away constness of this
	return new CRichEditCntrItem(preo, (CCadDoc*) this);
}

/////////////////////////////////////////////////////////////////////////////
// CRichtestDoc server implementation

COleServerItem* CCadDoc::OnGetEmbeddedItem()
{
	// OnGetEmbeddedItem is called by the framework to get the COleServerItem
	//  that is associated with the document.  It is only called when necessary.

//	COleServerItem* pItem = new COleServerItem(this);
//	ASSERT_VALID(pItem);
	return NULL;
}



CCadDoc::CCadDoc()
{
	//创建链表
	m_pEntityHead=new CEntity;
	m_pEntityTail=m_pEntityHead;
	m_pCurEntity=m_pEntityHead;
	
	//设置当前选择集中实体的数目
	m_nEntitySelCnt=0;
	m_nTotal_cnt=0;
}

CCadDoc::~CCadDoc()
{
	//释放实体链表所占内存
	CEntity*	pEntity=m_pEntityHead;
	while(m_pEntityHead!=m_pEntityTail)
	{
		pEntity=m_pEntityHead;
		m_pEntityHead=pEntity->m_pNext;
		switch(pEntity->m_nType)
		{
		case ID_DRAW_LINE:
			((CLine*) pEntity)->~CLine();
			break;
		case ID_DRAW_CIRCLE:
		case ID_DRAW_ARC:
		case ID_DRAW_FILLED_CIRCLE:
			((CCircle*) pEntity)->~CCircle();
			break;
		case ID_DRAW_RECTANGLE:
		case ID_DRAW_FILLED_RECTANGLE:
			((CRectangle*) pEntity)->~CRectangle();
			break;
		case ID_DRAW_POINT:
			((CPnt*) pEntity)->~CPnt();
			break;
		case ID_DRAW_TEXT:
			((CText*) pEntity)->~CText();
			break;
		default:
			break;
		}
	}
	delete m_pEntityTail;
}

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

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

	return TRUE;
}



/////////////////////////////////////////////////////////////////////////////
// CCadDoc serialization

void CCadDoc::Serialize(CArchive& ar)
{
	if (ar.IsStoring())
	{
		// TODO: add storing code here
		ar<<m_nTotal_cnt;
		CEntity* pEntity=m_pEntityHead;
	while(pEntity!=m_pEntityTail)
	{	ar<<pEntity->m_nType;
		switch(pEntity->m_nType)
		{
		case ID_DRAW_LINE:
			((CLine*) pEntity)->Serialize(ar);
			break;
		case ID_DRAW_CIRCLE:
		case ID_DRAW_ARC:
		case ID_DRAW_FILLED_CIRCLE:
			((CCircle*) pEntity)->Serialize(ar);
			break;
		case ID_DRAW_RECTANGLE:
		case ID_DRAW_FILLED_RECTANGLE:
			((CRectangle*) pEntity)->Serialize(ar);
			break;
		case ID_DRAW_POINT:
			((CPnt*) pEntity)->Serialize(ar);
			break;
		case ID_DRAW_TEXT:
			((CText*) pEntity)->Serialize(ar);
			break;
		default:
			break;
		}
		pEntity=pEntity->m_pNext;
	}

	}
	else
	{
		// TODO: add loading code here
		ar>>m_nTotal_cnt;
	int type;	

	//在链表头部添加新实体链节
	for(unsigned int i=0;i<m_nTotal_cnt;i++)
	{	CEntity* pNewEntity=NULL;
		ar>>type;
		switch(type)
		{
		case ID_DRAW_LINE:
			{
			CLine* pNewLine=new CLine;
			pNewLine->Serialize(ar);
			pNewEntity=(CEntity*) pNewLine;		
			break;
			}
		case ID_DRAW_CIRCLE:
		case ID_DRAW_ARC:
		case ID_DRAW_FILLED_CIRCLE:
			{
			CCircle* pNewCircle=new CCircle;
			pNewCircle->Serialize(ar);
			pNewEntity=(CEntity*) pNewCircle;		
			break;
			}
		case ID_DRAW_RECTANGLE:
		case ID_DRAW_FILLED_RECTANGLE:
			{
			CRectangle* pNewRectangle=new CRectangle;
			pNewRectangle->Serialize(ar);	
			pNewEntity=(CEntity*) pNewRectangle;		
			break;
			}
		case ID_DRAW_POINT:
			{
			CPnt* pNewPnt=new CPnt;
			pNewPnt->Serialize(ar);
			pNewEntity=(CEntity*) pNewPnt;		
			break;
			}
		case ID_DRAW_TEXT:
			{
			CText* pNewText=new CText;
			pNewText->Serialize(ar);
			pNewEntity=(CEntity*) pNewText;		
			break;
			}
		default:
			break;
		}
			
		pNewEntity->m_pNext=m_pEntityHead;
		m_pEntityHead->m_pPre=pNewEntity;
		m_pEntityHead=pNewEntity;
	}
	}
	int c=0;
}

/////////////////////////////////////////////////////////////////////////////
// CCadDoc diagnostics

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

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

/////////////////////////////////////////////////////////////////////////////
// CCadDoc commands
//创建新实体
void CCadDoc::Create(CDC * pDC,BOOL bSure)
{
	BOOL		bIsCreated=FALSE;
	CEntity*	pNewEntity=NULL;
	double		x[16],y[16];
	int			cnt=0;

	switch(g_nCurTask)
	{
	case ID_DRAW_LINE:
		bIsCreated=m_Line.Create(pDC,bSure);
		if(bIsCreated==TRUE)
		{
			CLine* pNewLine=new CLine(m_Line.m_dSx,m_Line.m_dSy,
									 m_Line.m_dEx,m_Line.m_dEy);
			pNewEntity=(CEntity*) pNewLine;		
			pNewLine->Draw(pDC);

			x[cnt]=m_Line.m_dSx;
			y[cnt]=m_Line.m_dSy;
			cnt++;
			x[cnt]=m_Line.m_dEx;
			y[cnt]=m_Line.m_dEy;
			cnt++;
		}
		break;
	case ID_DRAW_CIRCLE:
	case ID_DRAW_ARC:
	case ID_DRAW_FILLED_CIRCLE:
		bIsCreated=m_Circle.Create(pDC,bSure);
		if(bIsCreated==TRUE)
		{
			CCircle* pNewCircle;
			if(g_nCurTask==ID_DRAW_CIRCLE)
			{
				pNewCircle=new CCircle(m_Circle.m_dCenterX,
								m_Circle.m_dCenterY,m_Circle.m_dR);
			}
			else if(g_nCurTask==ID_DRAW_ARC)
			{
				pNewCircle=new CCircle(m_Circle.m_dCenterX,
							m_Circle.m_dCenterY,m_Circle.m_dR,
							m_Circle.m_dSx,m_Circle.m_dSy,
							m_Circle.m_dEx,m_Circle.m_dEy);
			}
			else
			{
				pNewCircle=new CCircle(m_Circle.m_dCenterX,
								m_Circle.m_dCenterY,m_Circle.m_dR,
								m_Circle.m_nFillPattern);
			}
			pNewEntity=(CEntity*) pNewCircle;		
			pNewCircle->Draw(pDC);

			x[cnt]=m_Circle.m_dCenterX+m_Circle.m_dR;
			y[cnt]=m_Circle.m_dCenterY+m_Circle.m_dR;
			cnt++;
			x[cnt]=m_Circle.m_dCenterX-m_Circle.m_dR;
			y[cnt]=m_Circle.m_dCenterY-m_Circle.m_dR;
			cnt++;
		}
		break;
	case ID_DRAW_RECTANGLE:
	case ID_DRAW_FILLED_RECTANGLE:
		bIsCreated=m_Rectangle.Create(pDC,bSure);
		if(bIsCreated==TRUE)
		{
			CRectangle* pNewRectangle;
			if(g_nCurTask==ID_DRAW_RECTANGLE)
			{
				pNewRectangle=new CRectangle(m_Rectangle.m_dLeft,
							m_Rectangle.m_dTop,m_Rectangle.m_dRight,
							m_Rectangle.m_dBottom);
			}
			else
			{
				pNewRectangle=new CRectangle(m_Rectangle.m_dLeft,
							m_Rectangle.m_dTop,m_Rectangle.m_dRight,
							m_Rectangle.m_dBottom,m_Rectangle.m_nFillPattern);
			}
			pNewEntity=(CEntity*) pNewRectangle;		
			pNewRectangle->Draw(pDC);

			x[cnt]=m_Rectangle.m_dLeft;
			y[cnt]=m_Rectangle.m_dTop;
			cnt++;
			x[cnt]=m_Rectangle.m_dRight;
			y[cnt]=m_Rectangle.m_dBottom;
			cnt++;
		}
		break;
	case ID_DRAW_POINT:
		bIsCreated=m_Pnt.Create(pDC,bSure);
		if(bIsCreated==TRUE)
		{
			CPnt* pNewPnt=new CPnt(m_Pnt.m_dX,m_Pnt.m_dY);
			pNewEntity=(CEntity*) pNewPnt;		
			pNewPnt->Draw(pDC);

			x[cnt]=m_Pnt.m_dX;
			y[cnt]=m_Pnt.m_dY;
			cnt++;
		}
		break;
	case ID_DRAW_TEXT:
		bIsCreated=m_Text.Create(pDC,bSure);
		if(bIsCreated==TRUE)
		{
			CText* pNewText=new CText(m_Text.m_dX,m_Text.m_dY,
									m_Text.m_strText);
			pNewEntity=(CEntity*) pNewText;		
			pNewText->Draw(pDC);

			x[cnt]=m_Text.m_dX;
			y[cnt]=m_Text.m_dY;
			cnt++;
		}
		break;
	default:
		break;
	}

	if(bIsCreated==TRUE&&pNewEntity!=NULL)
	{
		pNewEntity->m_pNext=m_pEntityHead;
		m_pEntityHead->m_pPre=pNewEntity;
		m_pEntityHead=pNewEntity;
		m_nTotal_cnt++;
		//获取当前图形所在空间大小
		for(int i=0;i<cnt;i++)
		{
			if(x[i]>g_dMaxX) g_dMaxX=x[i];
			if(x[i]<g_dMinX) g_dMinX=x[i];
			if(y[i]>g_dMaxY) g_dMaxY=y[i];
			if(y[i]<g_dMinY) g_dMinY=y[i];
		}			
	}		
}

//绘制系统中的所有实体
void CCadDoc::Draw(CDC * pDC)
{
	//遍历实体链表绘图
	CEntity* pEntity=m_pEntityHead;
	while(pEntity!=m_pEntityTail)
	{
		switch(pEntity->m_nType)
		{
		case ID_DRAW_LINE:
			((CLine*) pEntity)->Draw(pDC);
			break;
		case ID_DRAW_CIRCLE:
		case ID_DRAW_ARC:
		case ID_DRAW_FILLED_CIRCLE:
			((CCircle*) pEntity)->Draw(pDC);
			break;
		case ID_DRAW_RECTANGLE:
		case ID_DRAW_FILLED_RECTANGLE:
			((CRectangle*) pEntity)->Draw(pDC);
			break;
		case ID_DRAW_POINT:
			((CPnt*) pEntity)->Draw(pDC);
			break;
		case ID_DRAW_TEXT:
			((CText*) pEntity)->Draw(pDC);
			break;
		default:
			break;
		}
		pEntity=pEntity->m_pNext;
	}
}

//对象捕捉
void CCadDoc::OSnap(CDC * pDC, BOOL bSure)
{
	//捕捉到对象了
	if(bSure==TRUE&&g_bOSnapped==TRUE)
	{
		DrawOSnapPnt(pDC,FALSE);
		g_dCurX=g_dPreX;
		g_dCurY=g_dPreY;
		g_nOpqTask=0;
		return ;
	}

	//遍历实体链表查看是否捕捉到对象
	if(m_pCurEntity==NULL||m_pCurEntity==m_pEntityTail)
	{
		m_pCurEntity=m_pEntityHead;
	}
	BOOL bOSnapped=FALSE;
	while(m_pCurEntity!=m_pEntityTail&&bOSnapped==FALSE)
	{
		switch(m_pCurEntity->m_nType)
		{
		case ID_DRAW_LINE:
			bOSnapped=((CLine*) m_pCurEntity)->OSnap();
			break;
		case ID_DRAW_CIRCLE:
		case ID_DRAW_ARC:
		case ID_DRAW_FILLED_CIRCLE:
			bOSnapped=((CCircle*) m_pCurEntity)->OSnap();
			break;
		case ID_DRAW_RECTANGLE:
		case ID_DRAW_FILLED_RECTANGLE:
			bOSnapped=((CRectangle*) m_pCurEntity)->OSnap();
			break;
		case ID_DRAW_POINT:
			bOSnapped=((CPnt*) m_pCurEntity)->OSnap();
			break;
		case ID_DRAW_TEXT:
			bOSnapped=((CText*) m_pCurEntity)->OSnap();
			break;
		default:
			break;
		}
		m_pCurEntity=m_pCurEntity->m_pNext;
	}
	//绘制捕捉点
	DrawOSnapPnt(pDC,bOSnapped);
}

//绘制对象捕捉点
void CCadDoc::DrawOSnapPnt(CDC * pDC,BOOL bOSnapped)
{
	static double dPreX,dPreY;

	//设置R2_NOT的绘图方式
	int nDrawMode=pDC->SetROP2(R2_NOT);

	//覆盖先前的捕捉标记
	if(g_bOSnapped==TRUE)
	{
		CPoint	point;
		g_pCurView->WorldToScreen(point,dPreX,dPreY);
		pDC->MoveTo(point.x-4,point.y-4);
		pDC->LineTo(point.x+4,point.y-4);
		pDC->LineTo(point.x+4,point.y+4);
		pDC->LineTo(point.x-4,point.y+4);
		pDC->LineTo(point.x-4,point.y-4);
	}

	//绘制新的捕捉标记
	if(bOSnapped==TRUE)
	{
		CPoint	point;
		g_pCurView->WorldToScreen(point,g_dCurX,g_dCurY);
		pDC->MoveTo(point.x-4,point.y-4);
		pDC->LineTo(point.x+4,point.y-4);
		pDC->LineTo(point.x+4,point.y+4);
		pDC->LineTo(point.x-4,point.y+4);
		pDC->LineTo(point.x-4,point.y-4);
		dPreX=g_dCurX;
		dPreY=g_dCurY;
	}
	//设置先前的绘图方式
	pDC->SetROP2(nDrawMode); 

	g_bOSnapped=bOSnapped;
	return ;
}

//拾取实体
void CCadDoc::PickEntity(CDC* pDC)
{
	BOOL	bPicked=FALSE;

	if(m_pCurEntity==NULL||m_pCurEntity==m_pEntityTail)
	{
		m_pCurEntity=m_pEntityHead;
	}

	//遍历实体链表查看是否拾取到实体
	while(m_pCurEntity!=m_pEntityTail)
	{
		switch(m_pCurEntity->m_nType)
		{
		case ID_DRAW_LINE:
			bPicked=((CLine*) m_pCurEntity)->Pick();
			if(bPicked==TRUE)
				((CLine *)m_pCurEntity)->Draw(pDC,RGB(255,0,0),PS_DASHDOT);
			break;
		case ID_DRAW_CIRCLE:
		case ID_DRAW_ARC:
		case ID_DRAW_FILLED_CIRCLE:
			bPicked=((CCircle*) m_pCurEntity)->Pick();
			if(bPicked==TRUE)
				((CCircle *)m_pCurEntity)->Draw(pDC,RGB(255,0,0),PS_DASHDOT);
			break;
		case ID_DRAW_RECTANGLE:
		case ID_DRAW_FILLED_RECTANGLE:
			bPicked=((CRectangle*) m_pCurEntity)->Pick();
			if(bPicked==TRUE)
				((CRectangle *)m_pCurEntity)->Draw(pDC,RGB(255,0,0),PS_DASHDOT);
			break;
		case ID_DRAW_POINT:
			bPicked=((CPnt*) m_pCurEntity)->Pick();
			if(bPicked==TRUE)
				((CPnt *)m_pCurEntity)->Draw(pDC,RGB(255,0,0),PS_DASHDOT);
			break;
		case ID_DRAW_TEXT:
			bPicked=((CText*) m_pCurEntity)->Pick();
			if(bPicked==TRUE)
				((CText *)m_pCurEntity)->Draw(pDC,RGB(255,0,0),PS_DASHDOT);
			break;
		default:
			break;
		}

		if(bPicked==TRUE) 
		{
			BOOL	bSelected=FALSE;
			for(int i=0;i<m_nEntitySelCnt;i++)
			{
				if(m_pEntitySelected[m_nEntitySelCnt]==m_pCurEntity)
				{
					bSelected=TRUE;
					break;
				}