shape.cpp

聊天的

// Shape.cpp: implementation of the CShape class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Meeting.h"
#include "Shape.h"

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

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

IMPLEMENT_SERIAL(CShape,CObject,1)
CShape::CShape()
{
	m_nPenWidth=1;

}

CShape::~CShape()
{
}
/*
void CShape::CalculateShapeRect(CPoint& pt)
{

	m_sizeShape.top=min(m_sizeShape.top,pt.y);
	m_sizeShape.left=min(m_sizeShape.left,pt.x);
	m_sizeShape.right=max(m_sizeShape.right,pt.x);
	m_sizeShape.bottom=max(m_sizeShape.bottom,pt.y);
}
CRect& CShape::GetShapeRect()
{
	return m_sizeShape;

}

void CShape::InitShapeSize(CPoint &pt)
{
	m_sizeShape=CRect(pt.x,pt.y,pt.x,pt.y);

}
*/
void CShape::Serialize(CArchive &ar)
{
	if(ar.IsStoring())
	{
		ar<<m_nPenWidth;
		ar<<m_colorPen;
	}
	else
	{
		ar>>m_nPenWidth;
		ar>>m_colorPen;
	}
}



IMPLEMENT_SERIAL(CLine,CShape,1)

CLine::CLine()
{

}

CLine::~CLine()
{
}
BOOL CLine::DrawShape(CDC* pDC)
{
	CPen penShape;
	if(!penShape.CreatePen(PS_SOLID,m_nPenWidth,m_colorPen))
		return false;
	CPen* pOldPen=pDC->SelectObject(&penShape);
	pDC->MoveTo(m_pointStart);
	pDC->LineTo(m_pointEnd);
	pDC->SelectObject(pOldPen);
	return true;
}
void CLine::Serialize(CArchive &ar)
{
	if(ar.IsStoring())
	{
		ar<<m_pointStart;
		ar<<m_pointEnd;
	}else
	{
		ar>>m_pointStart;
		ar>>m_pointEnd;
	}
	CShape::Serialize(ar);
}

CLine::CLine(UINT nPenWidth,COLORREF colorpen)
{
	m_nPenWidth=nPenWidth;
	m_colorPen=colorpen;


}

//////////////////////////////////////////////////////////////////////
// CRectangle Class
//////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_SERIAL(CRectangle,CShape,1)
CRectangle::CRectangle()
{

}

CRectangle::~CRectangle()
{

}

BOOL CRectangle::DrawShape(CDC *pDC)
{
	CPen penShape;
	CBrush brushFill;
	if(!penShape.CreatePen(PS_SOLID,m_nPenWidth,m_colorPen))
		return false;
	CBrush* pOldBrush;
	CPen* pOldPen=pDC->SelectObject(&penShape);
	if(m_bFill)
	{
		
		brushFill.CreateSolidBrush(m_colorFill);
		pOldBrush=pDC->SelectObject(&brushFill);
	}
	else
	{
		
		pOldBrush=(CBrush*)pDC->SelectStockObject(NULL_BRUSH);
	}
	pDC->SelectObject(&brushFill);
	pDC->Rectangle(&m_rectRect);
	pDC->SelectObject(pOldPen);
	pDC->SelectObject(pOldBrush);


	return true;

}

void CRectangle::Serialize(CArchive &ar)
{
	if(ar.IsStoring())
	{
		ar<<m_rectRect;
		ar<<m_colorFill;
		ar<<m_bFill;
	}
	else
	{
		ar>>m_rectRect;
		ar>>m_colorFill;
		ar>>m_bFill;
	}
	CShape::Serialize(ar);


}

CRectangle::CRectangle(UINT nPenWidth,COLORREF colorFill,
					   COLORREF colorPen,BOOL bFill)
{
	m_nPenWidth=nPenWidth;
	m_colorFill=colorFill;
	m_colorPen=colorPen;
	m_bFill=bFill;



}

//////////////////////////////////////////////////////////////////////
// CHand Class
//////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

IMPLEMENT_SERIAL(CHand,CShape,1)
CHand::CHand()
{

}

CHand::~CHand()
{
}

CHand::CHand(UINT nPenWidth,COLORREF colorPen)
{
	m_nPenWidth=nPenWidth;
	m_colorPen=colorPen;


}

BOOL CHand::DrawShape(CDC *pDC)
{
	CPen penShape;
	if(!penShape.CreatePen(PS_SOLID,m_nPenWidth,m_colorPen))
		return false;
	CPen* pOldPen=pDC->SelectObject(&penShape);
	pDC->MoveTo(m_pointArray[0]);
	for(int i=1;i<m_pointArray.GetSize();i++)
	{
		pDC->LineTo(m_pointArray[i]);
	}
	pDC->SelectObject(pOldPen);
	return true;

}

void CHand::Serialize(CArchive &ar)
{
	if(ar.IsStoring())
	{
		m_pointArray.Serialize(ar);
	}
	else
	{
		m_pointArray.Serialize(ar);
	}
	CShape::Serialize(ar);


}






//////////////////////////////////////////////////////////////////////
// CCircle Class
//////////////////////////////////////////////////////////////////////

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

CCircle::CCircle()
{

}

CCircle::~CCircle()
{

}


CCircle::CCircle(UINT nPenWidth,COLORREF colorFill,
				 COLORREF colorPen,BOOL bFill)
{
	m_colorPen=colorPen;
	m_nPenWidth=nPenWidth;
	m_colorFill=colorFill;
	m_bFill=bFill;
	
}

void CCircle::Serialize(CArchive &ar)
{
	if(ar.IsStoring())
	{
		ar<<m_rectCircle;
		ar<<m_colorFill;
		ar<<m_bFill;
	}
	else
	{
		ar>>m_rectCircle;
		ar>>m_colorFill;
		ar>>m_bFill;
	}
	CShape::Serialize(ar);


}

BOOL CCircle::DrawShape(CDC *pDC)
{
	CPen penShape;
	if(!penShape.CreatePen(PS_SOLID,m_nPenWidth,m_colorPen))
		return false;
	CPen* pOldPen=pDC->SelectObject(&penShape);
	CBrush FillBrush;
	CBrush* pOldBrush;
	if(m_bFill)
	{
		
		FillBrush.CreateSolidBrush(m_colorFill);
		pOldBrush=pDC->SelectObject(&FillBrush);
	}
	else
	{
		
		pOldBrush=(CBrush*)pDC->SelectStockObject(NULL_BRUSH);
	}
	
	pDC->Ellipse(m_rectCircle);
	pDC->SelectObject(pOldPen);
	pDC->SelectObject(pOldBrush);

	return true;
	
}

////////////////////////////////////////////
IMPLEMENT_SERIAL(CTask,CShape,1)

CTask::CTask()
{
}
CTask::~CTask()
{
}

CTask::CTask(CString& str)
{
	m_strTask=str;
}
void CTask::Serialize(CArchive& ar)
{
	if (ar.IsStoring())
	{	
		ar<<m_strTask;
	}
	else
	{
		ar>>m_strTask;
	}
	CShape::Serialize(ar);
}

BOOL CTask::DrawShape(CDialog* pDlg)
{

	CTalkDlg* pTDlg=(CTalkDlg*)pDlg;
	CEdit* pEdit=(CEdit*)pTDlg->GetDlgItem(IDC_EDIT1);
	CString str;
	pEdit->GetWindowText(str);
	if(str.GetLength()>1000)str.IsEmpty();
	pEdit->SetWindowText(str+m_strTask);
	
	pEdit->LineScroll(pEdit->GetLineCount(),0);
	return TRUE;
}



//////////////////////////////////////

IMPLEMENT_SERIAL(CAudio,CShape,1)
CAudio::CAudio()
{
}
CAudio::~CAudio()
{
}
CAudio::CAudio(int len,char buf[])
{
	buf_len=len;
	memcpy(buffer,buf,len);

}
void CAudio::Serialize(CArchive &ar)
{
	if(ar.IsStoring())
	{
		ar<<buf_len;
		for(int i=0;i<buf_len;i++)ar<<buffer[i];
	}
	else
	{
		ar>>buf_len;
		for(int i=0;i<buf_len;i++)ar>>buffer[i];
	}

}


///////////////////////////////////////////////////////
IMPLEMENT_SERIAL(COrder,CShape,1)

COrder::COrder()
{
}
COrder::~COrder()
{
}
COrder::COrder(OrderFlag order,CString str,int n)
:m_Order(order)
,m_strParam(str)
,m_nParam(n)
{

}
void COrder::Serialize(CArchive& ar)
{
	if(ar.IsStoring())
	{
		ar<<(int)m_Order;
		ar<<m_strParam;
		ar<<m_nParam;
	}
	else
	{
		int order;
		ar>>order;
		m_Order=(OrderFlag)order;
		ar>>m_strParam;
		ar>>m_nParam;
	}
}