ellipse.cpp

一个复杂的画图系统

// Ellipse.cpp: implementation of the CEllipse class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "geditor.h"
#include "geditorView.h"
#include "Ellipse.h"
#include <cmath>
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_SERIAL(CEllipse, CShape,1)

CEllipse::CEllipse(CPoint& pt1,CPoint& pt2)
{
	m_tRect.left = pt1.x, m_tRect.right = pt2.x;
	m_tRect.top = pt1.y, m_tRect.bottom = pt2.y;
	m_tRect.NormalizeRect();
	BeSeled=0;
	NoRotateInit=0;
	edgeclr=0;
}

CEllipse::CEllipse()
{
	NoRotateInit=0;
	edgeclr=0;
}

CEllipse::~CEllipse()
{

}

void CEllipse::Draw(CDC* pDC)
{//注：可将图形的起始点和终点定义为Cshape的变量,简化操作。
	CBrush brush((COLORREF)m_color);
	CBrush* oldBrush = pDC->SelectObject(&brush);
	CPen pen(PS_SOLID,1,(COLORREF)edgeclr);
	CPen *oldPen = pDC->SelectObject(&pen);
	if (fills) pDC->Ellipse(m_tRect);
	else 
	{
		CPen pena(linesty,width,m_color);
		pDC->SelectObject(&pena);
		CPoint pt;
		pt.x=m_tRect.left;
		pt.y=m_tRect.top;
		pDC->Arc(m_tRect,pt,pt);
		DeleteObject(pena);
	};
	if ((dragmode>=1)&&(dragmode<=10))
	{
		UpdateProp(0);
		CPen pens(PS_SOLID,1,RGB(0,0,0));
		pDC->SelectObject(&pens);
		CBrush bs(RGB(255,255,255));
		pDC->SelectObject(&bs);
		int RecWd=4;
		pDC->Rectangle(m_tRect.left-RecWd,m_tRect.top-RecWd,m_tRect.left+RecWd,m_tRect.top+RecWd);
		pDC->Rectangle(m_tRect.right-RecWd,m_tRect.top-RecWd,m_tRect.right+RecWd,m_tRect.top+RecWd);
		pDC->Rectangle(m_tRect.left-RecWd,m_tRect.bottom-RecWd,m_tRect.left+RecWd,m_tRect.bottom+RecWd);
		pDC->Rectangle(m_tRect.right-RecWd,m_tRect.bottom-RecWd,m_tRect.right+RecWd,m_tRect.bottom+RecWd);
		int Mid=(int)((m_tRect.left+m_tRect.right)/2);
		pDC->Rectangle(Mid-RecWd,m_tRect.top-RecWd,Mid+RecWd,m_tRect.top+RecWd);
		pDC->Rectangle(Mid-RecWd,m_tRect.bottom-RecWd,Mid+RecWd,m_tRect.bottom+RecWd);
		Mid=(int)((m_tRect.top+m_tRect.bottom)/2);
		pDC->Rectangle(m_tRect.left-RecWd,Mid-RecWd,m_tRect.left+RecWd,Mid+RecWd);
		pDC->Rectangle(m_tRect.right-RecWd,Mid-RecWd,m_tRect.right+RecWd,Mid+RecWd);
		BeSeled=1;
		DeleteObject(pens);
	}
	else BeSeled=0;//为斜拉选定使用
	pDC->SelectObject(oldBrush);
	pDC->SelectObject(oldPen);
	DeleteObject(pen);
	DeleteObject(brush);
}

void CEllipse::SetBox(CPoint& pt1,CPoint& pt2)
{

	m_tRect.left = pt1.x, m_tRect.right = pt2.x;
	m_tRect.top = pt1.y, m_tRect.bottom = pt2.y;
	m_tRect.NormalizeRect();

}
void CEllipse::SetBox(CRect &rect)
{
	m_tRect=rect;
	m_tRect.NormalizeRect();
}
#ifdef _DEBUG
void CEllipse::AssertValid() const
{
	CObject::AssertValid();
	
}

void CEllipse::Dump(CDumpContext& dc) const
{
	CObject::Dump(dc);
}

#endif //_DEBUG

void CEllipse::Serialize(CArchive &ar)
{
	//Call base class Serialize()
	CObject::Serialize(ar);

	if(ar.IsStoring())
	{ 
		ar<<m_tRect.left<<m_tRect.top<<m_tRect.right<<m_tRect.bottom;
		ar<<m_color<<dragmode<<name<<linesty;
	}
	else
	{
		ar>>m_tRect.left>>m_tRect.top>>m_tRect.right>>m_tRect.bottom;
		ar>>m_color>>dragmode>>name>>linesty;		
	}


}

void CEllipse::dragobj(int leash,CDC *pDC,CPoint point,CGeditorView* pView)//, CDC * pDC, CPoint point, CGeditorView * pView)
{
	invalid(pView);
	switch (dragmode)
	{
	case 1://move all
		m_tRect.left=m_tRect.left+point.x-movept.x;//deltaX
		m_tRect.right=m_tRect.right+point.x-movept.x;
		m_tRect.top=m_tRect.top+point.y-movept.y;
		m_tRect.bottom=m_tRect.bottom+point.y-movept.y;
		break;
	case 2://(left,top)
		m_tRect.left=m_tRect.left+point.x-movept.x;
		m_tRect.top=m_tRect.top+point.y-movept.y;
		break;
	case 3://(right,bottom)
		m_tRect.right=m_tRect.right+point.x-movept.x;
		m_tRect.bottom=m_tRect.bottom+point.y-movept.y;
		break;
	case 4://(left,bottom)
		m_tRect.left=m_tRect.left+point.x-movept.x;
		m_tRect.bottom=m_tRect.bottom+point.y-movept.y;
		break;
	case 5://(right,top)
		m_tRect.right=m_tRect.right+point.x-movept.x;
		m_tRect.top=m_tRect.top+point.y-movept.y;
		break;
	case 6://top
		m_tRect.top=m_tRect.top+point.y-movept.y;
		break;
	case 7://bottom
		m_tRect.bottom=m_tRect.bottom+point.y-movept.y;
		break;
	case 8://left
		m_tRect.left=m_tRect.left+point.x-movept.x;
		break;
	case 9://right
		m_tRect.right=m_tRect.right+point.x-movept.x;
		break;
	case 0:
		BeSeled=0;
		break;
	default:
		break;
	};
	movept=point;
	Draw(pDC);
}

int CEllipse::InTest(CPoint pt)
{
	HCURSOR	m_hCrossCursor;
	int temp=0;
	int Mid=(int)((m_tRect.left+m_tRect.right)/2);
	if ((abs(m_tRect.left-pt.x)<=4)&&(abs(m_tRect.top-pt.y)<=4)&&(BeSeled))
	{
		m_hCrossCursor=AfxGetApp()->LoadStandardCursor(IDC_SIZENWSE);
		::SetCursor(m_hCrossCursor);
		return 2;
	} 
	else if ((abs(m_tRect.right-pt.x)<=4)&&(abs(m_tRect.bottom-pt.y)<=4)&&(BeSeled))
	{
		m_hCrossCursor=AfxGetApp()->LoadStandardCursor(IDC_SIZENWSE);
		::SetCursor(m_hCrossCursor);
		return 3;  
	}	
	else if ((abs(m_tRect.left-pt.x)<=4)&&(abs(m_tRect.bottom-pt.y)<=4)&&(BeSeled))
	{
		m_hCrossCursor=AfxGetApp()->LoadStandardCursor(IDC_SIZENESW);
		::SetCursor(m_hCrossCursor);
		return 4;
	} 
	else if ((abs(m_tRect.right-pt.x)<=4)&&(abs(m_tRect.top-pt.y)<=4)&&(BeSeled))
	{
		m_hCrossCursor=AfxGetApp()->LoadStandardCursor(IDC_SIZENESW);
		::SetCursor(m_hCrossCursor);
		return 5;  
	}
	else if ((abs(Mid-pt.x)<=4)&&(abs(m_tRect.top-pt.y)<=4))
	{
		m_hCrossCursor=AfxGetApp()->LoadStandardCursor(IDC_SIZENS);
		::SetCursor(m_hCrossCursor);
		return 6;
	}
	else if ((abs(Mid-pt.x)<=4)&&(abs(m_tRect.bottom-pt.y)<=4))
	{
		m_hCrossCursor=AfxGetApp()->LoadStandardCursor(IDC_SIZENS);
		::SetCursor(m_hCrossCursor);
		return 7;
	};
	Mid=(int)((m_tRect.top+m_tRect.bottom)/2);
	if ((abs(Mid-pt.y)<=4)&&(abs(m_tRect.left-pt.x)<=4))
	{
		m_hCrossCursor=AfxGetApp()->LoadStandardCursor(IDC_SIZEWE);
		::SetCursor(m_hCrossCursor);
		return 8;
	};
	if ((abs(Mid-pt.y)<=4)&&(abs(m_tRect.right-pt.x)<=4))
	{
		m_hCrossCursor=AfxGetApp()->LoadStandardCursor(IDC_SIZEWE);
		::SetCursor(m_hCrossCursor);
		return 9;
	};
	int a=(int)((m_tRect.right-m_tRect.left)/2);
	int b=(int)((m_tRect.bottom-m_tRect.top)/2);
	int x=(int)(pt.x-(m_tRect.right+m_tRect.left)/2);
	int y=(int)(pt.y-(m_tRect.bottom+m_tRect.top)/2);
	float t=(float)(x*x)/(a*a);
	float s=(float)(y*y)/(b*b);
	t=t+s;
	s=(float)0.1;
	float w=(float)1;
	if ((t<1)&&(fills))//(((x*x)/(a*a)+(y*y)/(b*b))<1)
	{
		m_hCrossCursor=AfxGetApp()->LoadStandardCursor(IDC_SIZEALL);
		::SetCursor(m_hCrossCursor);
		return 1;
	}
	else if (!fills)
	{
		int nears=width+2;
		if (nears>10)
			nears=width;
		int a=(int)(abs(m_tRect.right-m_tRect.left)/2);
		int b=(int)(abs(m_tRect.top-m_tRect.bottom)/2);
		int c=(int)(sqrt(a*a-b*b));
		int x=pt.x-(int)((m_tRect.right+m_tRect.left)/2);
		int y=pt.y-(int)((m_tRect.top+m_tRect.bottom)/2);
	int distance=(int)(sqrt((x+c)*(x+c)+y*y)+sqrt((x-c)*(x-c)+y*y));
		if (abs(distance-2*a)<=nears)
		{
			::SetCursor(AfxGetApp()->LoadCursor(IDC_CURSEL));
			return 1;
		};
	}else return 0;
	//is out of all point: 
	return 0;
}

CShape * CEllipse::copys(TCHAR &ch)
{
	CEllipse *e;
	e=new CEllipse;
	e->m_tRect=m_tRect;
	e->m_tRect.OffsetRect(10,10);
	ch='E';
	return e;
}



void CEllipse::Mirror(int syd, CDC *pDC, CPoint &basept, CGeditorView *pView)
{
	invalid(pView);
	int temp;
	switch(syd)
	{//原点对称可以是0 or 1
	case 0://x zhou
		temp=m_tRect.top;
		m_tRect.top=2*basept.y-m_tRect.bottom;
		m_tRect.bottom=2*basept.y-temp;
		break;
	case 1://y zhou
		temp=m_tRect.left;
		m_tRect.left=2*basept.x-m_tRect.right;
		m_tRect.right=2*basept.x-temp;
		break;
	default:
		break;
	};
	Draw(pDC);

}

void CEllipse::rotate(int rsel, CDC *pDC, CPoint pt, CGeditorView *pView)
{

	if((rsel==0)&&(NoRotateInit==1))//90度
	{
		invalid(pView);
		NoRotateInit=0;
		int x0,y0;
		x0=(int)((m_tRect.left+m_tRect.right)/2);
		y0=(int)((m_tRect.top+m_tRect.bottom)/2);
		int ht=abs(m_tRect.bottom-m_tRect.top);
		int wd=abs(m_tRect.right-m_tRect.left);
		m_tRect.left=x0-(int)(ht/2);
		m_tRect.right=x0+(int)(ht/2);
		m_tRect.top=y0-(int)(wd/2);
		m_tRect.bottom=y0+(int)(wd/2);
		Draw(pDC);
	};
}

void CEllipse::invalid(CGeditorView *pView)
{
	int rng=10;
	CPoint apoly[4];
	apoly[0].x=m_tRect.left;
	apoly[0].y=m_tRect.top;
	apoly[1].x=m_tRect.right;
	apoly[1].y=m_tRect.top;
	apoly[2].x=m_tRect.right;
	apoly[2].y=m_tRect.bottom;
	apoly[3].x=m_tRect.left;
	apoly[3].y=m_tRect.bottom;
	CRgn* pRgn=new CRgn();
	pRgn->CreatePolygonRgn(apoly,4,ALTERNATE);
	pView->InvalidateRgn(pRgn);
	delete pRgn;
	apoly[0].x=m_tRect.left-rng;
	apoly[1].x=m_tRect.left-rng;
	apoly[2].x=m_tRect.left+rng;
	apoly[3].x=m_tRect.left+rng;
	apoly[0].y=m_tRect.top-rng;
	apoly[1].y=m_tRect.top+rng;
	apoly[2].y=m_tRect.top+rng;
	apoly[3].y=m_tRect.top-rng;
	CRgn* pRgns=new CRgn();
	pRgns->CreatePolygonRgn(apoly,4,ALTERNATE);
	pView->InvalidateRgn(pRgns);
	delete pRgns;
	apoly[0].x=m_tRect.left-rng;
	apoly[1].x=m_tRect.left-rng;
	apoly[2].x=m_tRect.left+rng;
	apoly[3].x=m_tRect.left+rng;
	apoly[0].y=m_tRect.bottom-rng;
	apoly[1].y=m_tRect.bottom+rng;
	apoly[2].y=m_tRect.bottom+rng;
	apoly[3].y=m_tRect.bottom-rng;
	CRgn* pRgnsl=new CRgn();
	pRgnsl->CreatePolygonRgn(apoly,4,ALTERNATE);
	pView->InvalidateRgn(pRgnsl);
	delete pRgnsl;
	apoly[0].x=m_tRect.right-rng;
	apoly[1].x=m_tRect.right-rng;
	apoly[2].x=m_tRect.right+rng;
	apoly[3].x=m_tRect.right+rng;
	apoly[0].y=m_tRect.top-rng;
	apoly[1].y=m_tRect.top+rng;
	apoly[2].y=m_tRect.top+rng;
	apoly[3].y=m_tRect.top-rng;
	CRgn* pRgnsr=new CRgn();
	pRgnsr->CreatePolygonRgn(apoly,4,ALTERNATE);
	pView->InvalidateRgn(pRgnsr);
	delete pRgnsr;
	apoly[0].x=m_tRect.right-rng;
	apoly[1].x=m_tRect.right-rng;
	apoly[2].x=m_tRect.right+rng;
	apoly[3].x=m_tRect.right+rng;
	apoly[0].y=m_tRect.bottom-rng;
	apoly[1].y=m_tRect.bottom+rng;
	apoly[2].y=m_tRect.bottom+rng;
	apoly[3].y=m_tRect.bottom-rng;
	CRgn* pRgne=new CRgn();
	pRgne->CreatePolygonRgn(apoly,4,ALTERNATE);
	pView->InvalidateRgn(pRgne);
	delete pRgne;

	int mid=(int)((m_tRect.right+m_tRect.left)/2);
	apoly[0].x=mid-rng;
	apoly[1].x=mid-rng;
	apoly[2].x=mid+rng;
	apoly[3].x=mid+rng;
	apoly[0].y=m_tRect.bottom-rng;
	apoly[1].y=m_tRect.bottom+rng;
	apoly[2].y=m_tRect.bottom+rng;
	apoly[3].y=m_tRect.bottom-rng;
	CRgn* pRbtm=new CRgn();
	pRbtm->CreatePolygonRgn(apoly,4,ALTERNATE);
	pView->InvalidateRgn(pRbtm);
	delete pRbtm;

	apoly[0].x=mid-rng;
	apoly[1].x=mid-rng;
	apoly[2].x=mid+rng;
	apoly[3].x=mid+rng;
	apoly[0].y=m_tRect.top-rng;
	apoly[1].y=m_tRect.top+rng;
	apoly[2].y=m_tRect.top+rng;
	apoly[3].y=m_tRect.top-rng;
	CRgn* pRtop=new CRgn();
	pRtop->CreatePolygonRgn(apoly,4,ALTERNATE);
	pView->InvalidateRgn(pRtop);
	delete pRtop;

    mid=(int)((m_tRect.bottom+m_tRect.top)/2);
	apoly[0].y=mid-rng;
	apoly[1].y=mid-rng;
	apoly[2].y=mid+rng;
	apoly[3].y=mid+rng;
	apoly[0].x=m_tRect.left-rng;
	apoly[1].x=m_tRect.left+rng;
	apoly[2].x=m_tRect.left+rng;
	apoly[3].x=m_tRect.left-rng;
	CRgn* pRlft=new CRgn();
	pRlft->CreatePolygonRgn(apoly,4,ALTERNATE);
	pView->InvalidateRgn(pRlft);
	delete pRlft;

 	apoly[0].y=mid-rng;
	apoly[1].y=mid-rng;
	apoly[2].y=mid+rng;
	apoly[3].y=mid+rng;
	apoly[0].x=m_tRect.right-rng;
	apoly[1].x=m_tRect.right+rng;
	apoly[2].x=m_tRect.right+rng;
	apoly[3].x=m_tRect.right-rng;
	CRgn* pRrht=new CRgn();
	pRrht->CreatePolygonRgn(apoly,4,ALTERNATE);
	pView->InvalidateRgn(pRrht);
	delete pRrht;
}

void CEllipse::CalForRot(CPoint &pt)
{
	NoRotateInit=1;
}

void CEllipse::InitProp()
{
}

void CEllipse::UpdateProp(int sel)
{
}