#include "stdafx.h"
#include "dbcfilrs.h"

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

static BOOL DeepCloneObject(AcDbObject* pSrc, AcDbObject*& pDest)
{
	ASSERT(pSrc);
	if (pSrc == NULL)
		return FALSE;

	AcDbDeepCloneFiler cloneFiler;
	if (pSrc->dwgOut(&cloneFiler) != Acad::eOk)
		return FALSE;
    cloneFiler.seek(0L, AcDb::kSeekFromStart);

	AcDbObject* pClone = AcDbObject::cast(pSrc->isA()->create());
	if (pClone == NULL)
		return FALSE;

	if (pClone->dwgIn(&cloneFiler) != Acad::eOk)
	{
		delete pClone;
		return FALSE;
	}

	pDest = pClone;
	return TRUE;
}

CSolidData::CSolidData()
{
	m_eType = CSolidData::eNull;
	m_pData = NULL;
	m_nColorIndex = 256;

	m_ptUcsXDir.set(1.0, 0.0, 0.0);
	m_ptUcsYDir.set(0.0, 1.0, 0.0);
	m_ptUcsZDir.set(0.0, 0.0, 1.0);
}

CSolidData::CSolidData(CSolidData& data)
{
	m_eType = CSolidData::eNull;
	m_pData = NULL;
	Copy(&data);
}

CSolidData::~CSolidData()
{
	Clean();
}

void CSolidData::Clean()
{
	m_eType = CSolidData::eNull;
	m_idSolid = NULL;
	m_nColorIndex = 256;

	m_ptPosition.set(0.0, 0.0, 0.0);
	m_ptUcsOrigin.set(0.0, 0.0, 0.0);
	m_ptUcsXDir.set(1.0, 0.0, 0.0);
	m_ptUcsYDir.set(0.0, 1.0, 0.0);
	m_ptUcsZDir.set(0.0, 0.0, 1.0);

	if (m_pData)
		delete m_pData;
	m_pData = NULL;
}

BOOL CSolidData::SetType(CSolidData::SolidType eType)
{
	Clean();
	m_eType = eType;
	return CreateData();
}

CSolidData::SolidType CSolidData::GetType() const
{
	return m_eType;
}

void CSolidData::SetColorIndex(UINT nColor)
{
	m_nColorIndex = nColor;
}

UINT CSolidData::GetColorIndex()
{
	return m_nColorIndex;
}

AcDbObjectId CSolidData::GetObjectId()
{
	return m_idSolid;
}

void CSolidData::SetObjectId(AcDbObjectId idEnt)
{
	m_idSolid = idEnt;
}

void CSolidData::SetPosition(AcGePoint3d ptPosition)
{
	m_ptPosition = ptPosition;
}

AcGePoint3d CSolidData::GetPosition()
{
	return m_ptPosition;
}

void CSolidData::SetUcsCoordinateSystem(AcGePoint3d pt, AcGeVector3d vecX, AcGeVector3d vecY, AcGeVector3d vecZ)
{
	m_ptUcsOrigin = pt;
	m_ptUcsXDir = pt + vecX;
	m_ptUcsYDir = pt + vecY;
	m_ptUcsZDir = pt + vecZ;
}

void CSolidData::GetUcsCoordinateSystem(AcGePoint3d& pt, AcGeVector3d& vecX, AcGeVector3d& vecY, AcGeVector3d& vecZ)
{
	pt = m_ptUcsOrigin;
	vecX = m_ptUcsXDir - m_ptUcsOrigin;
	vecY = m_ptUcsYDir - m_ptUcsOrigin;
	vecZ = m_ptUcsZDir - m_ptUcsOrigin;
}

void CSolidData::GetUcsScale(double& dXScale, double& dYScale, double& dZScale)
{
	dXScale = m_ptUcsXDir.distanceTo(m_ptUcsOrigin);
	dYScale = m_ptUcsYDir.distanceTo(m_ptUcsOrigin);
	dZScale = m_ptUcsZDir.distanceTo(m_ptUcsOrigin);
}

const CBaseData* CSolidData::GetData() const
{
	return m_pData;
}

BOOL CSolidData::CreateData()
{
	switch (m_eType)
	{
	case CSolidData::eUnknown:
		m_pData = new CUnknownData;
		break;
	case CSolidData::eBox:
		m_pData = new CBoxData;
		break;
	case CSolidData::eFrustum:
		m_pData = new CFrustumData;
		break;
	case CSolidData::eSphere:
		m_pData = new CSphereData;
		break;
	case CSolidData::eTorus:
		m_pData = new CTorusData;
		break;
	case CSolidData::eWedge:
		m_pData = new CWedgeData;
		break;
	case CSolidData::eExtrude:
		m_pData = new CExtrudeData;
		break;
	case CSolidData::eRevolve:
		m_pData = new CRevolveData;
		break;
	case CSolidData::eBoolean:
		m_pData = new CBooleanData;
		break;
	case CSolidData::eSlice:
		m_pData = new CSliceData;
		break;
	case CSolidData::eArcBridge:
		m_pData = new CArcBridgeData;
		break;
	case CSolidData::eArcColumn:
		m_pData = new CArcColumnData;
		break;
	case CSolidData::eHillWall:
		m_pData = new CHillWallData;
		break;
	case CSolidData::ePyramid:
		m_pData = new CPyramidData;
		break;
	case CSolidData::eSpherePiece:
		m_pData = new CSpherePieceData;
		break;
	default:
		return FALSE;
	}
	ASSERT(m_pData);
	return (m_pData != NULL);
}

CSolidData& CSolidData::operator=(const CSolidData& data)
{
	Copy(&data);
	return (*this);
}

BOOL CSolidData::Clone(const CBaseData* pData)
{
	ASSERT(pData);

	if (m_eType != ((CSolidData*)pData)->m_eType)
	{
		return FALSE;
	}

	m_idSolid = ((CSolidData*)pData)->m_idSolid;
	m_nColorIndex = ((CSolidData*)pData)->m_nColorIndex;
	m_ptPosition = ((CSolidData*)pData)->m_ptPosition;
	m_ptUcsOrigin = ((CSolidData*)pData)->m_ptUcsOrigin;
	m_ptUcsXDir = ((CSolidData*)pData)->m_ptUcsXDir;
	m_ptUcsYDir = ((CSolidData*)pData)->m_ptUcsYDir;
	m_ptUcsZDir = ((CSolidData*)pData)->m_ptUcsZDir;
	
	if (m_pData)
	{
		m_pData->Clone(((CSolidData*)pData)->m_pData);
	}

	return TRUE;
}

BOOL CSolidData::Copy(const CBaseData* pData)
{
	ASSERT(pData);

	Clean();

	m_eType = ((CSolidData*)pData)->m_eType;

	m_idSolid = ((CSolidData*)pData)->m_idSolid;

	m_nColorIndex = ((CSolidData*)pData)->m_nColorIndex;

	m_ptPosition = ((CSolidData*)pData)->m_ptPosition;

	m_ptUcsOrigin = ((CSolidData*)pData)->m_ptUcsOrigin;
	m_ptUcsXDir = ((CSolidData*)pData)->m_ptUcsXDir;
	m_ptUcsYDir = ((CSolidData*)pData)->m_ptUcsYDir;
	m_ptUcsZDir = ((CSolidData*)pData)->m_ptUcsZDir;

	if (CreateData())
	{
		m_pData->Copy(((CSolidData*)pData)->m_pData);
	}

	return TRUE;
}

Acad::ErrorStatus CSolidData::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CSolidData::dxfInFields(AcDbDxfFiler* pFiler)
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CSolidData::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	pFiler->writeItem((Adesk::Int32)m_eType);

	pFiler->writeItem((Adesk::Int32)m_nColorIndex);

	pFiler->writeItem(m_ptPosition);

	pFiler->writeItem(m_ptUcsOrigin);
	pFiler->writeItem(m_ptUcsXDir);
	pFiler->writeItem(m_ptUcsYDir);
	pFiler->writeItem(m_ptUcsZDir);

	if (m_pData != NULL)
	{
		m_pData->dwgOutFields(pFiler);
	}

	return pFiler->filerStatus();
}

Acad::ErrorStatus CSolidData::dwgInFields(AcDbDwgFiler* pFiler)
{
	if (pFiler->filerStatus() != Acad::eOk)
		return pFiler->filerStatus();

	Clean();

	pFiler->readItem((Adesk::Int32*)&m_eType);

	pFiler->readItem((Adesk::Int32*)&m_nColorIndex);

	pFiler->readItem(&m_ptPosition);

	pFiler->readItem(&m_ptUcsOrigin);
	pFiler->readItem(&m_ptUcsXDir);
	pFiler->readItem(&m_ptUcsYDir);
	pFiler->readItem(&m_ptUcsZDir);

	if (CreateData())
	{
		m_pData->dwgInFields(pFiler);
	}

	return pFiler->filerStatus();
}


/////////////////////////////////////////////////////////////////////////
CUnknownData::CUnknownData()
{
}

CUnknownData::~CUnknownData()
{
}

BOOL CUnknownData::Clone(const CBaseData* pData)
{
	return Copy(pData);
}

BOOL CUnknownData::Copy(const CBaseData* pData)
{
	ASSERT(pData);
	m_arsAcis.RemoveAll();
	m_arsAcis.Copy(((CUnknownData*)pData)->m_arsAcis);
	return TRUE;
}

BOOL CUnknownData::Create3dSolid(AcDb3dSolid*& pSolid)
{
	INT_PTR iCount = m_arsAcis.GetSize();
	if (iCount <= 0)
	{
		return FALSE;
	}

	struct resbuf* pRb = acutNewRb(0);
	struct resbuf* pRbTemp = pRb;
	RBList rb(pRb);
	pRbTemp->resval.rstring = _tcsdup(_T("3DSOLID"));

	pRbTemp->rbnext = acutNewRb(100);
	pRbTemp = pRbTemp->rbnext;
	pRbTemp->resval.rstring = _tcsdup(_T("AcDbEntity"));

	pRbTemp->rbnext = acutNewRb(100);
	pRbTemp = pRbTemp->rbnext;
	pRbTemp->resval.rstring = _tcsdup(_T("AcDbModelerGeometry"));

	pRbTemp->rbnext = acutNewRb(70);
	pRbTemp = pRbTemp->rbnext;
	pRbTemp->resval.rint = 1;

	for (INT_PTR i = 0; i < iCount; i++)
	{
		pRbTemp->rbnext = acutNewRb(1);
		pRbTemp = pRbTemp->rbnext;
		pRbTemp->resval.rstring = _tcsdup(m_arsAcis[i]);
	}
	pRbTemp->rbnext = NULL;

	ads_name adsName;
	if (acdbEntMake(pRb) != RTNORM || acdbEntLast(adsName) != RTNORM)
		return FALSE;

	AcDbObjectId idEnt;
	acdbGetObjectId(idEnt, adsName);
	AcDbObject* pObj;
	if (acdbOpenObject(pObj, idEnt, AcDb::kForWrite) != Acad::eOk)
		return FALSE;

	if (!pObj->isKindOf(AcDb3dSolid::desc()))
	{
		pObj->close();
		return FALSE;
	}
	pSolid = (AcDb3dSolid*)pObj;

	return TRUE;
}

BOOL CUnknownData::GetAcisString(AcDbObjectId idEnt, CStringArray& arsAcis)
{
	arsAcis.RemoveAll();
	ads_name adsName;
	acdbGetAdsName(adsName, idEnt);
	struct resbuf* pRb = acdbEntGet(adsName);
	RBList rb(pRb); 

	if (pRb == NULL)
		return FALSE;

	struct resbuf* pRbTemp;
	for (pRbTemp = pRb; pRbTemp != NULL; pRbTemp = pRbTemp->rbnext)
	{
		if (pRbTemp->restype == 1)
			break;
	}

	for (; pRbTemp != NULL; pRbTemp = pRbTemp->rbnext)
	{
		if (pRbTemp->restype == 1)
			arsAcis.Add(pRbTemp->resval.rstring);
	}

	return TRUE;
}

BOOL CUnknownData::From3dSolid(AcDbObjectId idEnt)
{
	return GetAcisString(idEnt, m_arsAcis);
}

Acad::ErrorStatus CUnknownData::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CUnknownData::dxfInFields(AcDbDxfFiler* pFiler)
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CUnknownData::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	INT_PTR iCount = m_arsAcis.GetSize();
	pFiler->writeItem((Adesk::Int32)iCount);
	for (INT_PTR i = 0; i < iCount; i++)
		pFiler->writeItem((LPCTSTR)m_arsAcis[i]);

	return pFiler->filerStatus();
}

Acad::ErrorStatus CUnknownData::dwgInFields(AcDbDwgFiler* pFiler)
{
	if (pFiler->filerStatus() != Acad::eOk)
		return pFiler->filerStatus();

	m_arsAcis.RemoveAll();

	int iCount = 0;
	LPTSTR pszAcis = NULL;
	pFiler->readItem((Adesk::Int32*)&iCount);
	for (int i = 0; i < iCount; i++)
	{
		pFiler->readItem(&pszAcis);
		m_arsAcis.Add(pszAcis);
	}

	return pFiler->filerStatus();
}


/////////////////////////////////////////////////////////////////////////////
CBoxData::CBoxData()
{
	m_eBaseType = CBoxData::eCorner;
	m_dXLen = 0.0;
	m_dYLen = 0.0;
	m_dZLen = 0.0;
}

CBoxData::~CBoxData()
{
}

BOOL CBoxData::Clone(const CBaseData* pData)
{
	return Copy(pData);
}

BOOL CBoxData::Copy(const CBaseData* pData)
{
	ASSERT(pData);
	m_eBaseType = ((CBoxData*)pData)->m_eBaseType;
	m_dXLen = ((CBoxData*)pData)->m_dXLen;
	m_dYLen = ((CBoxData*)pData)->m_dYLen;
	m_dZLen = ((CBoxData*)pData)->m_dZLen;
	return TRUE;
}

Acad::ErrorStatus CBoxData::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CBoxData::dxfInFields(AcDbDxfFiler* pFiler)
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CBoxData::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	pFiler->writeItem((Adesk::Int32)m_eBaseType);
	pFiler->writeItem(m_dXLen);
	pFiler->writeItem(m_dYLen);
	pFiler->writeItem(m_dZLen);

	return pFiler->filerStatus();
}

Acad::ErrorStatus CBoxData::dwgInFields(AcDbDwgFiler* pFiler)
{
	if (pFiler->filerStatus() != Acad::eOk)
		return pFiler->filerStatus();

	pFiler->readItem((Adesk::Int32*)&m_eBaseType);
	pFiler->readItem(&m_dXLen);
	pFiler->readItem(&m_dYLen);
	pFiler->readItem(&m_dZLen);

	return pFiler->filerStatus();
}


/////////////////////////////////////////////////////////////////////////////
CBooleanData::CBooleanData()
{
	m_eOperateType = AcDb::kBoolUnite;
}

CBooleanData::~CBooleanData()
{
	Clean();
}

void CBooleanData::Clean()
{
	INT_PTR iCount = m_arpSrcObj.GetSize();
	for (INT_PTR i = 0; i < iCount; i++)
		delete m_arpSrcObj[i];
	iCount = m_arpDesObj.GetSize();
	for (i = 0; i < iCount; i++)
		delete m_arpDesObj[i];
	m_arpSrcObj.RemoveAll();
	m_arpDesObj.RemoveAll();
}

BOOL CBooleanData::Clone(const CBaseData* pData)
{
	ASSERT(pData);
	m_eOperateType = ((CBooleanData*)pData)->m_eOperateType;
	m_arpDesObj.Copy(((CBooleanData*)pData)->m_arpDesObj);
	m_arpSrcObj.Copy(((CBooleanData*)pData)->m_arpSrcObj);
	return TRUE;
}

BOOL CBooleanData::Copy(const CBaseData* pData)
{
	ASSERT(pData);
	Clean();
	m_eOperateType = ((CBooleanData*)pData)->m_eOperateType;
	CSolidData* pSubData;
	INT_PTR iCount = ((CBooleanData*)pData)->m_arpSrcObj.GetSize();
	for (INT_PTR i = 0; i < iCount; i++)
	{
		pSubData = new CSolidData;
		ASSERT(pSubData);
		pSubData->Copy((const CBaseData *)((CBooleanData*)pData)->m_arpSrcObj[i]);
		m_arpSrcObj.Add(pSubData);
	}
	iCount = ((CBooleanData*)pData)->m_arpDesObj.GetSize();
	for (i = 0; i < iCount; i++)
	{
		pSubData = new CSolidData;
		ASSERT(pSubData);
		pSubData->Copy((const CBaseData *)((CBooleanData*)pData)->m_arpDesObj[i]);
		m_arpDesObj.Add(pSubData);
	}
	return TRUE;
}

Acad::ErrorStatus CBooleanData::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CBooleanData::dxfInFields(AcDbDxfFiler* pFiler)
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CBooleanData::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	pFiler->writeItem((Adesk::Int32)m_eOperateType);

	INT_PTR iCount = m_arpSrcObj.GetSize();
	pFiler->writeItem((Adesk::Int32)iCount);
	for (INT_PTR i = 0; i < iCount; i++)
	{
		((CSolidData*)m_arpSrcObj[i])->dwgOutFields(pFiler);
	}

	iCount = m_arpDesObj.GetSize();
	pFiler->writeItem((Adesk::Int32)iCount);
	for (i = 0; i < iCount; i++)
	{
		((CSolidData*)m_arpDesObj[i])->dwgOutFields(pFiler);
	}

	return pFiler->filerStatus();
}

Acad::ErrorStatus CBooleanData::dwgInFields(AcDbDwgFiler* pFiler)
{
	if (pFiler->filerStatus() != Acad::eOk)
		return pFiler->filerStatus();

	Clean();

	pFiler->readItem((Adesk::Int32*)&m_eOperateType);

	int iCount = 0;
	CSolidData* pData;
	pFiler->readItem((Adesk::Int32*)&iCount);
	for (int i = 0; i < iCount; i++)
	{
		pData = new CSolidData;
		ASSERT(pData);
		pData->dwgInFields(pFiler);
		m_arpSrcObj.Add(pData);
	}

	iCount = 0;
	pFiler->readItem((Adesk::Int32*)&iCount);
	for (i = 0; i < iCount; i++)
	{
		pData = new CSolidData;
		ASSERT(pData);
		pData->dwgInFields(pFiler);
		m_arpDesObj.Add(pData);
	}

	return pFiler->filerStatus();
}


/////////////////////////////////////////////////////////////////////////////
CFrustumData::CFrustumData()
{
	m_eBaseType = CFrustumData::eBase;
	m_dHeight = 0.0;
	m_dXRadius = 0.0;
	m_dYRadius = 0.0;
	m_dTopXRadius = 0.0;
}

CFrustumData::~CFrustumData()
{
}

BOOL CFrustumData::Clone(const CBaseData* pData)
{
	return Copy(pData);
}

BOOL CFrustumData::Copy(const CBaseData* pData)
{
	m_eBaseType = ((CFrustumData*)pData)->m_eBaseType;
	m_dHeight = ((CFrustumData*)pData)->m_dHeight;
	m_dXRadius = ((CFrustumData*)pData)->m_dXRadius;
	m_dYRadius = ((CFrustumData*)pData)->m_dYRadius;
	m_dTopXRadius = ((CFrustumData*)pData)->m_dTopXRadius;
	return TRUE;
}

Acad::ErrorStatus CFrustumData::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CFrustumData::dxfInFields(AcDbDxfFiler* pFiler)
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CFrustumData::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	pFiler->writeItem((Adesk::Int32)m_eBaseType);
	pFiler->writeItem(m_dHeight);
	pFiler->writeItem(m_dXRadius);
	pFiler->writeItem(m_dYRadius);
	pFiler->writeItem(m_dTopXRadius);

	return pFiler->filerStatus();
}

Acad::ErrorStatus CFrustumData::dwgInFields(AcDbDwgFiler* pFiler)
{
	if (pFiler->filerStatus() != Acad::eOk)
		return pFiler->filerStatus();

	pFiler->readItem((Adesk::Int32*)&m_eBaseType);
	pFiler->readItem(&m_dHeight);
	pFiler->readItem(&m_dXRadius);
	pFiler->readItem(&m_dYRadius);
	pFiler->readItem(&m_dTopXRadius);

	return pFiler->filerStatus();
}


/////////////////////////////////////////////////////////////////////////////
CSphereData::CSphereData()
{
	m_dRadius = 0.0;
}

CSphereData::~CSphereData()
{
}

BOOL CSphereData::Clone(const CBaseData* pData)
{
	return Copy(pData);
}

BOOL CSphereData::Copy(const CBaseData* pData)
{
	m_dRadius = ((CSphereData*)pData)->m_dRadius;
	return TRUE;
}

Acad::ErrorStatus CSphereData::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CSphereData::dxfInFields(AcDbDxfFiler* pFiler)
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CSphereData::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	pFiler->writeItem(m_dRadius);

	return pFiler->filerStatus();
}

Acad::ErrorStatus CSphereData::dwgInFields(AcDbDwgFiler* pFiler)
{
	if (pFiler->filerStatus() != Acad::eOk)
		return pFiler->filerStatus();

	pFiler->readItem(&m_dRadius);

	return pFiler->filerStatus();
}


/////////////////////////////////////////////////////////////////////////////
CTorusData::CTorusData()
{
	m_dMajorRadius = 0.0;
	m_dMinorRadius = 0.0;
}

CTorusData::~CTorusData()
{
}

BOOL CTorusData::Clone(const CBaseData* pData)
{
	return Copy(pData);
}

BOOL CTorusData::Copy(const CBaseData* pData)
{
	m_dMajorRadius = ((CTorusData*)pData)->m_dMajorRadius;
	m_dMinorRadius = ((CTorusData*)pData)->m_dMinorRadius;
	return TRUE;
}

Acad::ErrorStatus CTorusData::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CTorusData::dxfInFields(AcDbDxfFiler* pFiler)
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CTorusData::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	pFiler->writeItem(m_dMajorRadius);
	pFiler->writeItem(m_dMinorRadius);

	return pFiler->filerStatus();
}

Acad::ErrorStatus CTorusData::dwgInFields(AcDbDwgFiler* pFiler)
{
	if (pFiler->filerStatus() != Acad::eOk)
		return pFiler->filerStatus();

	pFiler->readItem(&m_dMajorRadius);
	pFiler->readItem(&m_dMinorRadius);

	return pFiler->filerStatus();
}


/////////////////////////////////////////////////////////////////////////////
CWedgeData::CWedgeData()
{
	m_eBaseType = CWedgeData::eCorner;
	m_bEqualSide = FALSE;
	m_dXLen = 0.0;
	m_dYLen = 0.0;
	m_dZLen = 0.0;
}

CWedgeData::~CWedgeData()
{
}

BOOL CWedgeData::Clone(const CBaseData* pData)
{
	return Copy(pData);
}

BOOL CWedgeData::Copy(const CBaseData* pData)
{
	ASSERT(pData);
	m_eBaseType = ((CWedgeData*)pData)->m_eBaseType;
	m_bEqualSide = ((CWedgeData*)pData)->m_bEqualSide;
	m_dXLen = ((CWedgeData*)pData)->m_dXLen;
	m_dYLen = ((CWedgeData*)pData)->m_dYLen;
	m_dZLen = ((CWedgeData*)pData)->m_dZLen;
	return TRUE;
}

Acad::ErrorStatus CWedgeData::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CWedgeData::dxfInFields(AcDbDxfFiler* pFiler)
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CWedgeData::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	pFiler->writeItem((Adesk::Int32)m_eBaseType);
	pFiler->writeItem((Adesk::Boolean)m_bEqualSide);
	pFiler->writeItem(m_dXLen);
	pFiler->writeItem(m_dYLen);
	pFiler->writeItem(m_dZLen);

	return pFiler->filerStatus();
}

Acad::ErrorStatus CWedgeData::dwgInFields(AcDbDwgFiler* pFiler)
{
	if (pFiler->filerStatus() != Acad::eOk)
		return pFiler->filerStatus();

	pFiler->readItem((Adesk::Int32*)&m_eBaseType);
	pFiler->readItem((Adesk::Boolean*)&m_bEqualSide);
	pFiler->readItem(&m_dXLen);
	pFiler->readItem(&m_dYLen);
	pFiler->readItem(&m_dZLen);

	return pFiler->filerStatus();
}


/////////////////////////////////////////////////////////////////////////////
CExtrudeData::CExtrudeData()
{
	m_eBaseType = CExtrudeData::eBase;
	m_pProfile = NULL;
	m_pPath = NULL;
	m_dHeight = 0.0;
	m_dTaper = 0.0;
}

CExtrudeData::~CExtrudeData()
{
	Clean();
}

void CExtrudeData::Clean()
{
	m_eBaseType = CExtrudeData::eBase;
	if (m_pProfile != NULL)
		delete m_pProfile;
	m_pProfile = NULL;

	if (m_pPath != NULL)
		delete m_pPath;
	m_pPath = NULL;
}

BOOL CExtrudeData::Clone(const CBaseData* pData)
{
	ASSERT(pData);
	m_eBaseType = ((CExtrudeData*)pData)->m_eBaseType;
	m_dHeight = ((CExtrudeData*)pData)->m_dHeight;
	m_dTaper = ((CExtrudeData*)pData)->m_dTaper;
	return TRUE;
}

BOOL CExtrudeData::Copy(const CBaseData* pData)
{
	ASSERT(pData);

	Clean();
	m_eBaseType = ((CExtrudeData*)pData)->m_eBaseType;
	m_dHeight = ((CExtrudeData*)pData)->m_dHeight;
	m_dTaper = ((CExtrudeData*)pData)->m_dTaper;

	if (((CExtrudeData*)pData)->m_pPath)
	{
		DeepCloneObject(((CExtrudeData*)pData)->m_pPath, (AcDbObject*&)m_pPath);
	}

	if (((CExtrudeData*)pData)->m_pProfile)
	{
		DeepCloneObject(((CExtrudeData*)pData)->m_pProfile, (AcDbObject*&)m_pProfile);
	}

	return TRUE;
}

Acad::ErrorStatus CExtrudeData::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CExtrudeData::dxfInFields(AcDbDxfFiler* pFiler)
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CExtrudeData::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	pFiler->writeItem((Adesk::Int32)m_eBaseType);
	pFiler->writeItem(m_pProfile->isA()->name());
	m_pProfile->dwgOutFields(pFiler);

	if (m_eBaseType == CExtrudeData::ePath)
	{
		pFiler->writeItem(m_pPath->isA()->name());
		m_pPath->dwgOutFields(pFiler);
	}
	else
	{
		pFiler->writeItem(m_dHeight);
		pFiler->writeItem(m_dTaper);
	}
	return pFiler->filerStatus();
}

Acad::ErrorStatus CExtrudeData::dwgInFields(AcDbDwgFiler* pFiler)
{
	if (pFiler->filerStatus() != Acad::eOk)
		return pFiler->filerStatus();

	Clean();

	pFiler->readItem((Adesk::Int32*)&m_eBaseType);

	LPTSTR pszTemp = NULL;
	AcDbObject* pObj;
	AcRxClass* pClass;

	pFiler->readItem(&pszTemp);
	pClass = AcRxClass::cast(acrxClassDictionary->at(pszTemp));
	if (pClass == NULL)
	{
		return Acad::eMakeMeProxy;
	}

	pObj = AcDbObject::cast(pClass->create());
	if (pObj == NULL)
	{
		return Acad::eMakeMeProxy;
	}
	pObj->dwgInFields(pFiler);
	m_pProfile = AcDbRegion::cast(pObj);

	if (m_eBaseType == CExtrudeData::ePath)
	{
		pFiler->readItem(&pszTemp);
		pClass = AcRxClass::cast(acrxClassDictionary->at(pszTemp));
		if (pClass == NULL)
		{
			return Acad::eMakeMeProxy;
		}

		pObj = AcDbObject::cast(pClass->create());
		if (pObj == NULL)
		{
			return Acad::eMakeMeProxy;
		}
		pObj->dwgInFields(pFiler);
		m_pPath = AcDbCurve::cast(pObj);
	}
	else
	{
		pFiler->readItem(&m_dHeight);
		pFiler->readItem(&m_dTaper);
	}

	return pFiler->filerStatus();
}


/////////////////////////////////////////////////////////////////////////////
CRevolveData::CRevolveData()
{
	m_dAngle = 0.0;
	m_ptAxis.set(0.0, 0.0, 0.0);
	m_vecAxis.set(0.0, 0.0, 1.0);
	m_pProfile = NULL;
}

CRevolveData::~CRevolveData()
{
	Clean();
}

void CRevolveData::Clean()
{
	if (m_pProfile != NULL)
		delete m_pProfile;
	m_pProfile = NULL;
}

BOOL CRevolveData::Clone(const CBaseData* pData)
{
	ASSERT(pData);
	m_dAngle = ((CRevolveData*)pData)->m_dAngle;
	m_ptAxis = ((CRevolveData*)pData)->m_ptAxis;
	m_vecAxis = ((CRevolveData*)pData)->m_vecAxis;
	return TRUE;
}

BOOL CRevolveData::Copy(const CBaseData* pData)
{
	ASSERT(pData);

	Clean();
	m_dAngle = ((CRevolveData*)pData)->m_dAngle;
	m_ptAxis = ((CRevolveData*)pData)->m_ptAxis;
	m_vecAxis = ((CRevolveData*)pData)->m_vecAxis;
	if (((CRevolveData*)pData)->m_pProfile)
		DeepCloneObject(((CRevolveData*)pData)->m_pProfile, (AcDbObject*&)m_pProfile);

	return TRUE;
}

Acad::ErrorStatus CRevolveData::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CRevolveData::dxfInFields(AcDbDxfFiler* pFiler)
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CRevolveData::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	pFiler->writeItem(m_dAngle);
	pFiler->writeItem(m_ptAxis);
	pFiler->writeItem(m_vecAxis);
	pFiler->writeItem(m_pProfile->isA()->name());
	m_pProfile->dwgOutFields(pFiler);

	return pFiler->filerStatus();
}

Acad::ErrorStatus CRevolveData::dwgInFields(AcDbDwgFiler* pFiler)
{
	if (pFiler->filerStatus() != Acad::eOk)
		return pFiler->filerStatus();

	Clean();

	pFiler->readItem(&m_dAngle);
	pFiler->readItem(&m_ptAxis);
	pFiler->readItem(&m_vecAxis);

	LPTSTR pszTemp = NULL;
	AcDbObject* pObj;
	AcRxClass* pClass;

	pFiler->readItem(&pszTemp);
	pClass = AcRxClass::cast(acrxClassDictionary->at(pszTemp));
	if (pClass == NULL)
		return Acad::eMakeMeProxy;
	pObj = AcDbObject::cast(pClass->create());
	if (pObj == NULL)
		return Acad::eMakeMeProxy;
	pObj->dwgInFields(pFiler);
	m_pProfile = AcDbRegion::cast(pObj);

	return pFiler->filerStatus();
}


/////////////////////////////////////////////////////////////////////////////
CSliceData::CSliceData()
{
	m_ptOrigin.set(0.0, 0.0, 0.0);
	m_vecNormal.set(0.0, 0.0, 1.0);
}

CSliceData::~CSliceData()
{
}

BOOL CSliceData::Clone(const CBaseData* pData)
{
	ASSERT(pData);
	m_ptOrigin = ((CSliceData*)pData)->m_ptOrigin;
	m_vecNormal = ((CSliceData*)pData)->m_vecNormal;
	return TRUE;
}

BOOL CSliceData::Copy(const CBaseData* pData)
{
	ASSERT(pData);
	m_ptOrigin = ((CSliceData*)pData)->m_ptOrigin;
	m_vecNormal = ((CSliceData*)pData)->m_vecNormal;
	m_Solid = ((CSliceData*)pData)->m_Solid;
	return TRUE;
}

Acad::ErrorStatus CSliceData::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CSliceData::dxfInFields(AcDbDxfFiler* pFiler)
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CSliceData::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	pFiler->writeItem(m_ptOrigin);
	pFiler->writeItem(m_vecNormal);
	m_Solid.dwgOutFields(pFiler);

	return pFiler->filerStatus();
}

Acad::ErrorStatus CSliceData::dwgInFields(AcDbDwgFiler* pFiler)
{
	if (pFiler->filerStatus() != Acad::eOk)
		return pFiler->filerStatus();

	pFiler->readItem(&m_ptOrigin);
	pFiler->readItem(&m_vecNormal);
	m_Solid.dwgInFields(pFiler);

	return pFiler->filerStatus();
}


/////////////////////////////////////////////////////////////////////////////
CArcBridgeData::CArcBridgeData()
{
	m_eBaseType = CArcBridgeData::eCorner;
	m_dX = 0.0;
	m_dY = 0.0;
	m_dZ = 0.0;
	m_dW = 0.0;
	m_dH = 0.0;
}

CArcBridgeData::~CArcBridgeData()
{
}

BOOL CArcBridgeData::Clone(const CBaseData* pData)
{
	return Copy(pData);
}

BOOL CArcBridgeData::Copy(const CBaseData* pData)
{
	ASSERT(pData);

	m_eBaseType = ((CArcBridgeData*)pData)->m_eBaseType;
	m_dX = ((CArcBridgeData*)pData)->m_dX;
	m_dY = ((CArcBridgeData*)pData)->m_dY;
	m_dZ = ((CArcBridgeData*)pData)->m_dZ;
	m_dW = ((CArcBridgeData*)pData)->m_dW;
	m_dH = ((CArcBridgeData*)pData)->m_dH;
	return TRUE;
}

Acad::ErrorStatus CArcBridgeData::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CArcBridgeData::dxfInFields(AcDbDxfFiler* pFiler)
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CArcBridgeData::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	pFiler->writeItem((Adesk::Int32)m_eBaseType);
	pFiler->writeItem(m_dX);
	pFiler->writeItem(m_dY);
	pFiler->writeItem(m_dZ);
	pFiler->writeItem(m_dW);
	pFiler->writeItem(m_dH);

	return pFiler->filerStatus();
}

Acad::ErrorStatus CArcBridgeData::dwgInFields(AcDbDwgFiler* pFiler)
{
	if (pFiler->filerStatus() != Acad::eOk)
		return pFiler->filerStatus();

	pFiler->readItem((Adesk::Int32*)&m_eBaseType);
	pFiler->readItem(&m_dX);
	pFiler->readItem(&m_dY);
	pFiler->readItem(&m_dZ);
	pFiler->readItem(&m_dW);
	pFiler->readItem(&m_dH);

	return pFiler->filerStatus();
}


/////////////////////////////////////////////////////////////////////////////
CArcColumnData::CArcColumnData()
{
	m_eBaseType = CArcColumnData::eCorner;
	m_dX = 0.0;
	m_dY = 0.0;
	m_dZ = 0.0;
}

CArcColumnData::~CArcColumnData()
{
}

BOOL CArcColumnData::Clone(const CBaseData* pData)
{
	return Copy(pData);
}

BOOL CArcColumnData::Copy(const CBaseData* pData)
{
	ASSERT(pData);

	m_eBaseType = ((CArcColumnData*)pData)->m_eBaseType;
	m_dX = ((CArcColumnData*)pData)->m_dX;
	m_dY = ((CArcColumnData*)pData)->m_dY;
	m_dZ = ((CArcColumnData*)pData)->m_dZ;
	return TRUE;
}

Acad::ErrorStatus CArcColumnData::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CArcColumnData::dxfInFields(AcDbDxfFiler* pFiler)
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CArcColumnData::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	pFiler->writeItem((Adesk::Int32)m_eBaseType);
	pFiler->writeItem(m_dX);
	pFiler->writeItem(m_dY);
	pFiler->writeItem(m_dZ);

	return pFiler->filerStatus();
}

Acad::ErrorStatus CArcColumnData::dwgInFields(AcDbDwgFiler* pFiler)
{
	if (pFiler->filerStatus() != Acad::eOk)
		return pFiler->filerStatus();

	pFiler->readItem((Adesk::Int32*)&m_eBaseType);
	pFiler->readItem(&m_dX);
	pFiler->readItem(&m_dY);
	pFiler->readItem(&m_dZ);

	return pFiler->filerStatus();
}


/////////////////////////////////////////////////////////////////////////////
CHillWallData::CHillWallData()
{
	m_eBaseType = CHillWallData::eCorner;
	m_dX = 0.0;
	m_dY = 0.0;
	m_dZ = 0.0;
	m_dH = 0.0;
}

CHillWallData::~CHillWallData()
{
}

BOOL CHillWallData::Clone(const CBaseData* pData)
{
	return Copy(pData);
}

BOOL CHillWallData::Copy(const CBaseData* pData)
{
	ASSERT(pData);

	m_eBaseType = ((CHillWallData*)pData)->m_eBaseType;
	m_dX = ((CHillWallData*)pData)->m_dX;
	m_dY = ((CHillWallData*)pData)->m_dY;
	m_dZ = ((CHillWallData*)pData)->m_dZ;
	m_dH = ((CHillWallData*)pData)->m_dH;
	return TRUE;
}

Acad::ErrorStatus CHillWallData::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CHillWallData::dxfInFields(AcDbDxfFiler* pFiler)
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CHillWallData::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	pFiler->writeItem((Adesk::Int32)m_eBaseType);
	pFiler->writeItem(m_dX);
	pFiler->writeItem(m_dY);
	pFiler->writeItem(m_dZ);
	pFiler->writeItem(m_dH);

	return pFiler->filerStatus();
}

Acad::ErrorStatus CHillWallData::dwgInFields(AcDbDwgFiler* pFiler)
{
	if (pFiler->filerStatus() != Acad::eOk)
		return pFiler->filerStatus();

	pFiler->readItem((Adesk::Int32*)&m_eBaseType);
	pFiler->readItem(&m_dX);
	pFiler->readItem(&m_dY);
	pFiler->readItem(&m_dZ);
	pFiler->readItem(&m_dH);

	return pFiler->filerStatus();
}


/////////////////////////////////////////////////////////////////////////////
CPyramidData::CPyramidData()
{
	m_eBaseType = CPyramidData::eCorner;
	m_dX = 0.0;
	m_dY = 0.0;
	m_dZ = 0.0;
}

CPyramidData::~CPyramidData()
{
}

BOOL CPyramidData::Clone(const CBaseData* pData)
{
	return Copy(pData);
}

BOOL CPyramidData::Copy(const CBaseData* pData)
{
	ASSERT(pData);

	m_eBaseType = ((CPyramidData*)pData)->m_eBaseType;
	m_dX = ((CPyramidData*)pData)->m_dX;
	m_dY = ((CPyramidData*)pData)->m_dY;
	m_dZ = ((CPyramidData*)pData)->m_dZ;
	return TRUE;
}

Acad::ErrorStatus CPyramidData::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CPyramidData::dxfInFields(AcDbDxfFiler* pFiler)
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CPyramidData::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	pFiler->writeItem((Adesk::Int32)m_eBaseType);
	pFiler->writeItem(m_dX);
	pFiler->writeItem(m_dY);
	pFiler->writeItem(m_dZ);

	return pFiler->filerStatus();
}

Acad::ErrorStatus CPyramidData::dwgInFields(AcDbDwgFiler* pFiler)
{
	if (pFiler->filerStatus() != Acad::eOk)
		return pFiler->filerStatus();

	pFiler->readItem((Adesk::Int32*)&m_eBaseType);
	pFiler->readItem(&m_dX);
	pFiler->readItem(&m_dY);
	pFiler->readItem(&m_dZ);

	return pFiler->filerStatus();
}


/////////////////////////////////////////////////////////////////////////////
CSpherePieceData::CSpherePieceData()
{
	m_dW = 0.0;
	m_dH = 0.0;
}

CSpherePieceData::~CSpherePieceData()
{
}

BOOL CSpherePieceData::Clone(const CBaseData* pData)
{
	return Copy(pData);
}

BOOL CSpherePieceData::Copy(const CBaseData* pData)
{
	ASSERT(pData);

	m_dW = ((CSpherePieceData*)pData)->m_dW;
	m_dH = ((CSpherePieceData*)pData)->m_dH;
	return TRUE;
}

Acad::ErrorStatus CSpherePieceData::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CSpherePieceData::dxfInFields(AcDbDxfFiler* pFiler)
{
	return pFiler->filerStatus();
}

Acad::ErrorStatus CSpherePieceData::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	pFiler->writeItem(m_dW);
	pFiler->writeItem(m_dH);

	return pFiler->filerStatus();
}

Acad::ErrorStatus CSpherePieceData::dwgInFields(AcDbDwgFiler* pFiler)
{
	if (pFiler->filerStatus() != Acad::eOk)
		return pFiler->filerStatus();

	pFiler->readItem(&m_dW);
	pFiler->readItem(&m_dH);

	return pFiler->filerStatus();
}



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

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

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