#include "stdafx.h"
#include "dbmatch.h"
#include "AecDbEntityBaseEx.h"
#include "globalFunc.h"
#include "AecDbMText.h"
#include "AcGiExplodeDraw.h"
#include "AcGiViewDraw.h"
#include "PushMemVar.h"
#include "GeCurveInline.h"
#include "aecdbdimension.h"
#include "AcDbObjectPtr.h"
#include "DimOptionData.h"

namespace
{
	AcDbArc* geArc2DbArc(const AcGeCircArc3d &geArc)
	{
		AcGePlane plane = AcGePlane(geArc.center(), geArc.normal());
		double ang = geArc.refVec().angleOnPlane(plane);
		return new AcDbArc(geArc.center()
			, geArc.normal()
			, geArc.radius()
			, geArc.startAng() + ang
			, geArc.endAng() + ang);
	}

	void drawAcDbEntity(AcGiDraw &dc, AcDbEntity *pEnt, int clr, bool bSetDcLayer = true)
	{
		pEnt->setColorIndex(clr);
		if (bSetDcLayer)
			pEnt->setLayer(dc.GetLayerId());
		int oldClr = dc.GetColor();
		dc.SetColor(clr);
		dc.DrawEntity(*pEnt);
		dc.SetColor(oldClr);
	}

	void GetTrueTextExtent(const AcDbEntity*pEnt, GePoly2D &polyExt)
	{
		AcDbEntity *pText = AcDbEntity::cast(pEnt->clone());

		AcDbExtents ext;
		ADSGePoint3d ptLoc;
		double rot = 0;

		if (_tcsicmp(pText->isA()->name(), _T("AecXDbText")) == 0
			|| _tcsicmp(pText->isA()->name(), _T("TDbMText")) == 0)
		{
			AecXDbEntityBaseEx *pText1 = AecXDbEntityBaseEx::cast(pText);

			rot = pText1->TBaseGetRotation() + pText1->GetLayoutRotation();
			pText1->TBaseSetRotation(0);
			pText1->SetLayoutRotation(0);
			ptLoc = pText1->TBaseGetLocation();
		}

		else if (pText->isKindOf(AcDbText::desc()))
		{
			AcDbText*pText1 = AcDbText::cast(pText);
			rot = pText1->rotation();
			pText1->setRotation(0);
			ptLoc = pText1->position();
		}
		else
		{
			AcDbMText*pText1 = AcDbMText::cast(pText);
			rot = pText1->rotation();
			pText1->setRotation(0);
			ptLoc = pText1->location();
		}
		pText->getGeomExtents(ext);
		delete pText;

		ADSGePoint3d pt1 = ext.minPoint(), pt3 = ext.maxPoint();
		ADSGePoint3d pt2(pt3.x, pt1.y), pt4(pt1.x, pt3.y);
		polyExt.AppendNode(pt1);
		polyExt.AppendNode(pt2);
		polyExt.AppendNode(pt3);
		polyExt.AppendNode(pt4);
		ads_matrix mat;
		ptLoc.GetRotationMatrix(rot, mat);
		polyExt.TransUCS(mat);
	}

	void drawProxyEntity(const AcDbVoidPtrArray *pAr, AcGiWorldDraw *pWd)
	{
		if (!pAr) return;
		Adesk::UInt16 clr = pWd->subEntityTraits().color();
		AcDbObjectId layerID = pWd->subEntityTraits().layerId();
		for (int i = 0; i < pAr->length(); ++i)
		{
			AcDbEntity *pEnt((AcDbEntity*)pAr->at(i));
			if (pEnt->isKindOf(AcDbBlockReference::desc()))
			{
				AcDbBlockReference *pRef((AcDbBlockReference*)pEnt);
				AcDbBlockTableRecord *pRec(NULL);
				AcDbObject *pObj(NULL);
				AcDbEntity *pSubEnt(NULL);
				if (acdbOpenAcDbObject(pObj, pRef->blockTableRecord(), AcDb::kForRead) == Acad::eOk)
				{
					pRec = (AcDbBlockTableRecord*)pObj;
					AcDbBlockTableRecordIterator* pBlockIterator;
					pRec->newIterator(pBlockIterator, Adesk::kTrue, Adesk::kFalse);
					for (pBlockIterator->start(); !pBlockIterator->done(); pBlockIterator->step())
					{
						pBlockIterator->getEntity(pSubEnt, AcDb::kForWrite, Adesk::kTrue);
						pSubEnt->setColorIndex(pEnt->colorIndex());
						pSubEnt->setLayer(pEnt->layerId());
						pSubEnt->close();
					}
					pObj->close();
					delete pBlockIterator;
				}
			}
			pWd->subEntityTraits().setColor(pEnt->colorIndex());
			pWd->subEntityTraits().setLayer(pEnt->layerId());
			if (pEnt)
				pEnt->worldDraw(pWd);
		}
		pWd->subEntityTraits().setColor(clr);
		pWd->subEntityTraits().setLayer(layerID);
	}
}

#pragma region BaseEx
const Adesk::UInt8 BaseEx::g_nVersion = 1;
BaseEx::BaseEx()
{
	m_nLayoutRotation = 0.0;
	m_nPaperScale = GlobalFunc::DocGetPScale();
	m_bInJig = FALSE;
}

Acad::ErrorStatus BaseEx::dwgInFields(AcDbDwgFiler *pFiler)
{
	Adesk::UInt8 nVer;
	pFiler->readItem(&nVer);
	if (nVer > g_nVersion)
		return Acad::eMakeMeProxy;

	pFiler->readItem(&m_nPaperScale);
	pFiler->readItem(&m_nLayoutRotation);
	
	m_allFields.DwgIn(pFiler);

	m_XDataMap.dwgInFields(pFiler);

	return Acad::eOk;
}

Acad::ErrorStatus BaseEx::dwgOutFields(AcDbDwgFiler *pFiler) const
{
	pFiler->writeItem(g_nVersion);
	pFiler->writeItem(m_nPaperScale);
	pFiler->writeItem(m_nLayoutRotation);
	m_allFields.DwgOut(pFiler);
	m_XDataMap.dwgOutFields(pFiler);

	return Acad::eOk;
}

Acad::ErrorStatus BaseEx::dxfInFields(AcDbDxfFiler *) { return Acad::ErrorStatus(); }

Acad::ErrorStatus BaseEx::dxfOutFields(AcDbDxfFiler *) const { return Acad::ErrorStatus(); }

AecObjectEditMethod BaseEx::GetEditMethod() const
{
	return NULL;
}

int BaseEx::GetCtrlToggleIndex() const { return -1; }

BOOL & BaseEx::GetCtrlToggle() const
{
	int id = GetCtrlToggleIndex();
	if (id < 0 || id >= 100)
	{
		return g_Option::instance().g_bCtrlToggle;
	}

	return g_Option::instance().g_bCtrlToggle1[id];
}

void BaseEx::copyBy(const BaseEx & frm)
{
	if (frm.m_allFields.GetSubFieldNum())
		this->m_allFields = frm.m_allFields;
	this->m_nLayoutRotation = frm.m_nLayoutRotation;
	this->m_nPaperScale = frm.m_nPaperScale;
	this->m_XDataMap.CopyFrom(&frm.m_XDataMap);
}

void BaseEx::CopyPropertiesFrom(AcDbEntity * pSrcEntity, unsigned gMatchFlag)
{
	AcDbEntity *pTrgEntity = dynamic_cast<AcDbEntity*>(this);
	if (!pTrgEntity)
	{
		return;
	}

	// 颜色
	if (gMatchFlag & AcDbMatchProperties::kColorFlag)
	{
		pTrgEntity->setColorIndex(pSrcEntity->colorIndex());
	}

	//图层
	if (pTrgEntity->database() == NULL
		|| pSrcEntity->database() == NULL
		|| pTrgEntity->database() == pSrcEntity->database())	//add by W on 060317
	{
		if (gMatchFlag & AcDbMatchProperties::kLayerFlag)
		{
			pTrgEntity->setLayer(pSrcEntity->layerId());
		}

		// 线型
		if (gMatchFlag & AcDbMatchProperties::kLtypeFlag)
		{
			pTrgEntity->setLinetype(pSrcEntity->linetypeId());
		}

#if ADS > 16
		// 材质
		if (gMatchFlag & AcDbMatchProperties::kMaterialFlag)
		{
			pTrgEntity->setMaterial(pSrcEntity->materialId());
		}
#endif
	}

	// 线型比例
	if (gMatchFlag & AcDbMatchProperties::kLtscaleFlag)
	{
		pTrgEntity->setLinetypeScale(pSrcEntity->linetypeScale());
	}

	// 可见性. 总是被复制
	pTrgEntity->setVisibility(pSrcEntity->visibility());

	const AecXDbEntityBaseEx *pSrc1 = AecXDbEntityBaseEx::cast(pSrcEntity);
	const AecXDbCurveBaseEx *pSrc2 = AecXDbCurveBaseEx::cast(pSrcEntity);
	const BaseEx *pBaseSrc(NULL);
	if (pSrc1)
	{
		m_nPaperScale = pSrc1->m_nPaperScale;
		m_nLayoutRotation = pSrc1->m_nLayoutRotation;
		pBaseSrc = (BaseEx*)pSrc1;
	}
	else if (pSrc2)
	{
		m_nPaperScale = pSrc2->m_nPaperScale;
		m_nLayoutRotation = pSrc2->m_nLayoutRotation;
		pBaseSrc = (BaseEx*)pSrc2;
	}
	//wlw add 131224 xdata的复制
	if (pBaseSrc && pSrcEntity->desc() == pTrgEntity->desc())
	{
		m_XDataMap = pBaseSrc->m_XDataMap;
	}
}

AecDbObjXDataMap * BaseEx::__GetSpecialtyData()
{
	AcDbEntity *pThis = dynamic_cast<AcDbEntity*>(this);
	if (pThis->isWriteEnabled())
	{
		pThis->assertWriteEnabled();
	}
	else
	{
		pThis->assertReadEnabled();
	}
	return &m_XDataMap;
}

AecDbObjXDataMap * BaseEx::__GetSpecialtyDataReadOnly() const
{
	const AcDbEntity *pThis = dynamic_cast<const AcDbEntity*>(this);
	pThis->assertReadEnabled();
	return (AecDbObjXDataMap*)&m_XDataMap;
}

void BaseEx::TBaseSetRotation(double nRot) { }

double BaseEx::TBaseGetRotation() const { return 0.0; }

ADSGePoint3d BaseEx::TBaseGetLocation() const { return ADSGePoint3d(); }

int BaseEx::ConvertText(TConvertTextPtr ptr, void * pData) { return RTNONE; }

void BaseEx::TBaseSetLocation(ADSGePoint3d pt) { } 

TextPosition BaseEx::FindSubText(const TCHAR * sSubText, TextPosition & posStart, TextRange * pRange) const { return TextPosition(); }

TextPosition BaseEx::ReplaceSubText(const TextPosition & posRep, const TCHAR * sRepText, TextRange * pRange) { return TextPosition(); }

double BaseEx::Wcs2Layout(double nAngWcs) const
{
	return GlobalFunc::AngleRangeTo2PI(nAngWcs - m_nLayoutRotation);
}

double BaseEx::Layout2Wcs(double nAngLay) const
{
	return GlobalFunc::AngleRangeTo2PI(nAngLay + m_nLayoutRotation);
}

double BaseEx::GetPScale() const
{
	return m_nPaperScale;
}

Acad::ErrorStatus BaseEx::GetExtents2d(ADSGePoint3d & ptLow, ADSGePoint3d & ptUp) const
{
	//AcGiViewDraw dc;
	//this->_Draw2d(dc);
	const AcDbVoidPtrArray *pAr = this->_Get2DBuffer();
	if (!pAr) return Acad::eNullHandle;

	const AcDbVoidPtrArray &ar(*pAr);
	AcDbExtents ext, extall;
	for (int i = 0; i < ar.length(); ++i)
	{
		AcDbEntity *p((AcDbEntity*)((AcDbEntity*)ar[i])->clone());
		if (!p) continue;
		p->getGeomExtents(ext);
		extall.addExt(ext);
		DELETE_PTR(p);
	}

	ptLow = extall.minPoint();
	ptUp = extall.maxPoint();
	return Acad::eOk;
}

Acad::ErrorStatus BaseEx::GetExtents(ADSGePoint3d & ptLow, ADSGePoint3d & ptUp) const
{
	return GetExtents2d(ptLow, ptUp);
}

double BaseEx::NormalViewAngle(double nAngWcs) const
{
	double nAng1 = GlobalFunc::ChangeAngleTo1_4(Wcs2Layout(nAngWcs));
	nAng1 = GlobalFunc::AngleRangeTo2PI(m_nLayoutRotation + nAng1);
	return nAng1;
}

long BaseEx::GetSubTextNum() const
{
	PushMemVar<BOOL> vTemp(g_Option::instance().g_bExplodeSubText, TRUE);
	//AcGiViewDraw dc;
	//_Draw2d(dc);
	const AcDbVoidPtrArray *pAr = _Get2DBuffer();
	if (!pAr) return Acad::eNullHandle;

	const AcDbVoidPtrArray &allEnt(*pAr);

	long count = 0;
	for (long i = 0; i < allEnt.length(); i++)
	{
		AcDbEntity* pEnt = (AcDbEntity*)((AcDbEntity*)allEnt[i])->clone();
		if (!pEnt) continue;
		if (pEnt->isKindOf(AcDbText::desc())
			|| pEnt->isKindOf(AcDbMText::desc())
			|| (_tcsicmp(pEnt->isA()->name(), _T("AecXDbText")) == 0)
			|| (_tcsicmp(pEnt->isA()->name(), _T("AecXDbMText")) == 0)
			)
		{
			count++;
		}
	}

	return count;
}

long BaseEx::GetNextSubTextIndex(long i, bool bVert, bool bPre) const
{
	long num = GetSubTextNum();
	if (bPre)
	{
		return i = (i - 1 + num) % num;
	}
	else
	{
		return i = (i + 1) % num;
	}
}

SubText * BaseEx::HitTestText(ADSGePoint3d pt) const
{
	PushMemVar<BOOL> vTemp(g_Option::instance().g_bExplodeSubText, TRUE);

	SubText* pSubText = NULL;

	const AcDbEntity *pThis = dynamic_cast<const AcDbEntity*>(this);

	//AcGiViewDraw dc;
	//dc.SetPropertiesFrom(pThis);			//add by W on 060404
	//_Draw2d(dc);

	const AcDbVoidPtrArray *pAr = _Get2DBuffer();
	if (!pAr) return NULL;

	const AcDbVoidPtrArray &allEnt(*pAr);

	long count = 0;
	for (long i = 0; i < allEnt.length(); i++)
	{
		AcDbEntity* pEnt = (AcDbEntity*)((AcDbEntity*)allEnt[i])->clone();
		if (!pEnt) continue;
		if (pEnt->isKindOf(AcDbText::desc())
			|| pEnt->isKindOf(AcDbMText::desc())
			|| _tcsicmp(pEnt->isA()->name(), _T("AecXDbText")) == 0
			|| _tcsicmp(pEnt->isA()->name(), _T("AecXDbMText")) == 0
			)
		{
			AcDbExtents ext;
			pEnt->getGeomExtents(ext);

			ADSGePoint3d ptMin = ext.minPoint();
			ADSGePoint3d ptMax = ext.maxPoint();
			if (pt.x >= ptMin.x
				&& pt.x <= ptMax.x
				&& pt.y >= ptMin.y
				&& pt.y <= ptMax.y)
			{
				//allEnt[i] = NULL;

				GePoly2D polyExt;
				GetTrueTextExtent(pEnt, polyExt);
				polyExt.SetElevation(0);

				pt.z = 0;
				if ((pt & polyExt) != PR_OUTSIDE)
				{
					pSubText = new SubText(pThis->objectId(), pEnt, count);
					break;
				}
			}

			count++;
		}
		DELETE_PTR(pEnt);
	}

	//ReleaseEntSet(allEnt);

	return pSubText;
}

SubText* BaseEx::GetSubText(long iText)const
{
	PushMemVar<BOOL> vTemp(g_Option::instance().g_bExplodeSubText, TRUE);

	SubText* pSubText = NULL;

	const AcDbEntity *pThis = dynamic_cast<const AcDbEntity*>(this);

	//AcGiViewDraw dc;
	//dc.SetPropertiesFrom(pThis);			//add by W on 060404
	//_Draw2d(dc);

	const AcDbVoidPtrArray *pAr = _Get2DBuffer();
	if (!pAr) return NULL;

	const AcDbVoidPtrArray &allEnt(*pAr);

	long count = 0;
	for (long i = 0; i < allEnt.length(); i++)
	{
		AcDbEntity* pEnt = (AcDbEntity*)((AcDbEntity*)allEnt[i])->clone();
		if (!pEnt) continue;
		if (pEnt->isKindOf(AcDbText::desc())
			|| pEnt->isKindOf(AcDbMText::desc())
			|| (_tcsicmp(pEnt->isA()->name(), _T("AecXDbText")) == 0)
			|| (_tcsicmp(pEnt->isA()->name(), _T("AecXDbMText")) == 0)
			)
		{
			if (count == iText)
			{
				//allEnt[i] = NULL;
				pSubText = new SubText(pThis->objectId(), pEnt, iText);
				break;
			}
			count++;
		}
		DELETE_PTR(pEnt);
	}

	//ReleaseEntSet(allEnt);

	return pSubText;
}

void BaseEx::SetSubText(long i, CString sText) { }

void BaseEx::ResetTextPos() { }

void BaseEx::SetPScale(double scale)
{
	AcDbEntity *pThis = dynamic_cast<AcDbEntity*>(this);
	if (pThis) pThis->assertWriteEnabled();

	m_nPaperScale = scale;
}

double BaseEx::GetLayoutRotation() const { return m_nLayoutRotation; }

void BaseEx::SetLayoutRotation(double nRot)
{
	AcDbEntity *pThis = dynamic_cast<AcDbEntity*>(this);
	if (pThis) pThis->assertWriteEnabled();

	m_nLayoutRotation = GlobalFunc::AngleRangeTo2PI(nRot);
}

BOOL BaseEx::IsLayoutRotated() const
{
	return (fabs(m_nLayoutRotation) > g_DimOption::instance()._angSnap);
}

Acad::ErrorStatus BaseEx::_Draw2d(AcGiDraw & dc) const
{
	const AcDbEntity *pThis = dynamic_cast<const AcDbEntity*>(this);
	AecXDbEntityBaseEx *pEnt = AecXDbEntityBaseEx::cast(pThis);
	AecXDbCurveBaseEx *pCurve = AecXDbCurveBaseEx::cast(pThis);

	if (pEnt)
		return pEnt->__Draw2d(dc);

	if (pCurve)
		return pCurve->__Draw2d(dc);

	return Acad::eInvalidInput;
}

const AcDbVoidPtrArray* BaseEx::_Get2DBuffer() const
{
	const AcDbEntity *pThis = dynamic_cast<const AcDbEntity*>(this);
	AecXDbEntityBaseEx *pEnt = AecXDbEntityBaseEx::cast(pThis);
	AecXDbCurveBaseEx *pCurve = AecXDbCurveBaseEx::cast(pThis);

	if (pEnt)
		return &pEnt->__Get2DBuffer();

	if (pCurve)
		return &pCurve->__Get2DBuffer();

	return NULL;
}

void BaseEx::_Add2DBuffer(AcDbEntity * p) const
{
	if (m_bInJig)
	{
		DELETE_PTR(p);
		return;
	}
	const AcDbEntity *pThis = dynamic_cast<const AcDbEntity*>(this);
	AecXDbEntityBaseEx *pEnt = AecXDbEntityBaseEx::cast(pThis);
	AecXDbCurveBaseEx *pCurve = AecXDbCurveBaseEx::cast(pThis);

	if (pEnt)
		pEnt->__Add2DBuffer(p);

	if (pCurve)
		pCurve->__Add2DBuffer(p);

}

void BaseEx::DrawBlock(AcGiDraw &dc
	, const AcDbObjectId &blkId
	, const AcGePoint3d &ptInsert
	, const AcGeScale3d &scales
	, double nRot
	, int color) const
{
	AcDbBlockReference *pInsert = new AcDbBlockReference(ptInsert, blkId);
	pInsert->setScaleFactors(scales);
	pInsert->setRotation(nRot);
	pInsert->setColorIndex(color);

	drawAcDbEntity(dc, pInsert, color);
	_Add2DBuffer(pInsert);
}

void BaseEx::DrawLine(AcGiDraw &dc, const AcGePoint3d &pt1, const AcGePoint3d & pt2, int color) const
{
	AcDbLine *pLine = new AcDbLine(pt1, pt2);
	drawAcDbEntity(dc, pLine, color);
	_Add2DBuffer(pLine);
}

void BaseEx::DrawLine(AcGiDraw & dc, const GeLine & ln, int color) const
{
	DrawLine(dc, ln.GetStartPoint(), ln.GetEndPoint(), color);
}

void BaseEx::DrawPoly2D(AcGiDraw &dc, const GePoly2D &poly, int color) const
{
	AcDbCurve *pCurve = poly.AsAcDbCurve();
	if (pCurve)
	{
		drawAcDbEntity(dc, pCurve, color);
		_Add2DBuffer(pCurve);
	}
}

void BaseEx::DrawPline(AcGiDraw &dc, const AcDbPolyline &pline, int color) const
{
	AcDbPolyline *p = (AcDbPolyline*)pline.clone();
	if (p)
	{
		drawAcDbEntity(dc, p, color);
		_Add2DBuffer(p);
	}
}

void BaseEx::DrawArc(AcGiDraw &dc, const AcGePoint3d &ptS, const AcGePoint3d &ptM, const AcGePoint3d &ptE, int color) const
{
	AcDbArc *pArc = geArc2DbArc(AcGeCircArc3d(ptS, ptM, ptE));
	drawAcDbEntity(dc, pArc, color);
	_Add2DBuffer(pArc);
}

void BaseEx::DrawArc(AcGiDraw &dc, const GeArc &arc, int color) const
{
	ADSGePoint3d ptS, ptM, ptE;
	arc.GetStartPoint(ptS);
	arc.MidPoint(ptM);
	arc.GetEndPoint(ptE);
	DrawArc(dc, ptS, ptM, ptE);
}

void BaseEx::DrawSegment(AcGiDraw &dc, const GeCurveSegment &seg, int color)const
{
	AcDbCurve *pCurve = seg.AsAcDbCurve();
	if (pCurve)
	{
		drawAcDbEntity(dc, pCurve, color);
		_Add2DBuffer(pCurve);
	}
}

void BaseEx::DrawCircle(AcGiDraw &dc, const GeCircle &cir, int color) const
{
	AcDbCircle *pCir = new AcDbCircle(cir.GetCenterPt(), AcGeVector3d::kZAxis, cir.GetRadius());
	drawAcDbEntity(dc, pCir, color);
	_Add2DBuffer(pCir);
}

void BaseEx::DrawTextFit(AcGiDraw &dc
	, const TCHAR *pszText
	, const AcGePoint3d &pt1
	, const AcGePoint3d &pt2
	, double nTextHeight
	, AcDbObjectId styleId
	, int color) const
{
	AcDbText tx;
	tx.setTextString(pszText);
	tx.setColorIndex(color);
#if ARX > 18
	tx.setJustification(AcDbText::kTextAlignmentFit);
#endif

	double XScale(1.);
	{
		AcGiTextStyle textStyle;
		fromAcDbTextStyle(textStyle, styleId);
		XScale = textStyle.xScale();
		textStyle.setTextSize(nTextHeight);
		Adesk::Boolean bIncludeSpace = Adesk::kTrue;
		TCHAR *pTypeface = NULL;
#if ARX < 21
		Adesk::Boolean bBold, bItalic;
		int tmp0, tmp1;
		BOOL bWinFont = (textStyle.font(pTypeface, bBold, bItalic, tmp0, tmp1) == Acad::eOk);
		if (bWinFont)
#else
		bool bold, italic;
		Autodesk::AutoCAD::PAL::FontUtils::FontPitch pitch;
		Autodesk::AutoCAD::PAL::FontUtils::FontFamily family;
		Charset charset;
		BOOL bWinFont = (textStyle.font(pTypeface, bold, italic, charset, pitch, family) == Acad::eOk);
		if (bWinFont)
#endif
		{
			if (!pTypeface || !pTypeface[0])
			{
				bWinFont = FALSE;
			}
		}

		if (pTypeface)
		{
			delete[] pTypeface;
		}

		if (bWinFont)
		{
			bIncludeSpace = Adesk::kTrue;
		}
		else
		{
			bIncludeSpace = Adesk::kFalse;
			const TCHAR *pShxFile = textStyle.fileName();

			if (pShxFile)
			{
				CString s(pShxFile);
				s.MakeUpper();
				TCHAR sFilter[] = _T("GBE*,GOTH*,ISO*,SCRIPT*,ROMAN*");

				if (ads_wcmatch(s, sFilter) == RTNORM)
				{
					bIncludeSpace = Adesk::kTrue;
				}
			}
		}
		AcGePoint2d ptExt = textStyle.extents(pszText, bIncludeSpace, -1, Adesk::kFalse);
		double nWidth = ptExt[0];
		double nHeight = ptExt[1];
		XScale *= pt1.distanceTo(pt2) / nWidth;
	}

	tx.setWidthFactor(XScale);
	tx.setHeight(nTextHeight);
	tx.setRotation(Layout2Wcs(0.));
	tx.setAlignmentPoint(pt2);
	tx.setPosition(pt1);
	tx.setTextStyle(styleId);

	drawAcDbEntity(dc, &tx, color);

	_Add2DBuffer((AcDbEntity*)tx.clone());
}

/*void BaseEx::DrawBaseEx(AcGiDraw & dc, const BaseEx & ent) const
{
	const AcDbEntity *pEnt = dynamic_cast<const AcDbEntity*>(&ent);
	if (!pEnt) return;

	int colorText(257);
	bool bAecDBText(false);
	AecXDbText *pTxt(AecXDbText::cast(pEnt));
	if (pTxt)
	{
		colorText = pTxt->colorIndex();
		bAecDBText = true;
	}

	//AcDbEntity *pNew = (AcDbEntity*)pEnt->clone();

	//BaseEx *pBaseNew = dynamic_cast<BaseEx*>(pNew);
	//if (!pBaseNew) return;

	AcGiViewDraw _dc;
	//pBaseNew->_Draw2d(_dc);
	ent._Draw2d(_dc);
	//const AcDbVoidPtrArray &ar = pBaseNew->_Get2DBuffer();
	const AcDbVoidPtrArray &ar = ent._Get2DBuffer();

	for (int i = 0; i < ar.length(); ++i)
	{
		AcDbEntity *p((AcDbEntity*)((AcDbEntity*)ar[i])->clone());

		AcDbText *pAcTxt(AcDbText::cast(p));
		if (pAcTxt && bAecDBText)
			pAcTxt->setColorIndex(colorText);
		
		p->setLayer(pEnt->layerId());
		drawAcDbEntity(dc, p, p->colorIndex(), false);
		_Add2DBuffer(p);
	}

	//DELETE_PTR(pNew);
}*/

void BaseEx::DrawBaseEx(AcGiDraw & dc, const BaseEx & ent) const
{
	const AcDbEntity *pEnt = dynamic_cast<const AcDbEntity*>(&ent);
	if (!pEnt) return;

	const AecXDbEntityBaseEx *pEntEx = AecXDbEntityBaseEx::cast(pEnt);
	const AecXDbCurveBaseEx *pCrvEx = AecXDbCurveBaseEx::cast(pEnt);
	const AcDbVoidPtrArray *pAr(NULL);
	AcGiViewDraw _dc;
	AecXDbEntityBaseEx *pNewEntEx(NULL);
	AecXDbCurveBaseEx *pNewCrvEx(NULL);
	if (pEntEx)
	{
		pNewEntEx = (AecXDbEntityBaseEx*)pEntEx->clone();
		pNewEntEx->_Draw2d(_dc);
		pAr = &pNewEntEx->Get2DBuffer();
	}
	else if (pCrvEx)
	{
		pNewCrvEx = (AecXDbCurveBaseEx*)pCrvEx->clone();
		pNewCrvEx->_Draw2d(_dc);
		pAr = &pNewCrvEx->Get2DBuffer();
	}

	int colorText(257);
	bool bAecDBText(false);
	AecXDbText *pTxt(AecXDbText::cast(pEnt));
	if (pTxt)
	{
		colorText = pTxt->colorIndex();
		bAecDBText = true;
	}
	
	//ent._Draw2d(_dc);
	//const AcDbVoidPtrArray &ar = ent._Get2DBuffer();

	for (int i = 0; i < pAr->length(); ++i)
	{
		AcDbEntity *p((AcDbEntity*)((AcDbEntity*)pAr->at(i))->clone());

		AcDbText *pAcTxt(AcDbText::cast(p));
		if (pAcTxt && bAecDBText)
			pAcTxt->setColorIndex(colorText);

		p->setLayer(pEnt->layerId());
		drawAcDbEntity(dc, p, p->colorIndex(), false);
		_Add2DBuffer(p);
	}

	if (pNewCrvEx)
		delete pNewCrvEx;
	if (pNewEntEx)
		delete pNewEntEx;
}

void BaseEx::_Draw2DBuffers(AcGiDraw &dc, bool bUseEntClr) const
{
	const AcDbEntity *pThis = dynamic_cast<const AcDbEntity*>(this);
	AecXDbEntityBaseEx *pEnt = AecXDbEntityBaseEx::cast(pThis);
	AecXDbCurveBaseEx *pCurve = AecXDbCurveBaseEx::cast(pThis);

	const AcDbVoidPtrArray *pAr(NULL);
	if (pEnt) pAr = _Get2DBuffer();
	if (pCurve) pAr = _Get2DBuffer();

	if (pAr)
	{
		Adesk::UInt16 oldClr = dc.GetColor();
		Adesk::UInt16 newClr;
		for (int i = 0; i < pAr->length(); ++i)
		{
			const AcDbEntity *pEnt = (AcDbEntity*)pAr->at(i);
			newClr = pEnt->colorIndex();
			if (bUseEntClr)
				dc.SetColor(newClr);
			dc.DrawEntity(*pEnt);
			dc.SetColor(oldClr);
		}
	}
}

const EntityFields & BaseEx::GetFields() const
{
	return m_allFields;
}

EntityFields & BaseEx::Fields()
{
	return m_allFields;
}

#pragma endregion


#pragma region AecXDbEntityBaseEx
ACRX_NO_CONS_DEFINE_MEMBERS(AecXDbEntityBaseEx, AecDbEntityBase);

AecXDbEntityBaseEx::AecXDbEntityBaseEx(void)
{
	AecDbEntityBase::m_eExplodeOrDrawType = kWroldDraw;
	AecDbEntityBase::m_nDrawDimCur = -1;
}

AecXDbEntityBaseEx::~AecXDbEntityBaseEx(void)
{
}

Adesk::UInt32 AecXDbEntityBaseEx::subViewportDrawLogicalFlags(AcGiViewportDraw * vd)
{
	return AecDbEntityBase::subViewportDrawLogicalFlags(vd);
}

Adesk::UInt32 AecXDbEntityBaseEx::subSetAttributes(AcGiDrawableTraits * traits)
{
	return AecDbEntityBase::subSetAttributes(traits);
}

Adesk::Boolean AecXDbEntityBaseEx::subWorldDraw(AcGiWorldDraw *pWd)
{
	assertReadEnabled();
	return AecDbEntityBase::subWorldDraw(pWd);
}

void AecXDbEntityBaseEx::subViewportDraw(AcGiViewportDraw* pMode)
{
	assertReadEnabled();
	return AecDbEntityBase::subViewportDraw(pMode);
}

//保存代理实体图元
void AecXDbEntityBaseEx::saveAs(AcGiWorldDraw *pWd, AcDb::SaveType saveType)
{
	AcGiRegenType rtype = pWd->regenType();
	if (rtype == kAcGiSaveWorldDrawForProxy)
		drawProxyEntity(_Get2DBuffer(), pWd);
	else
		AecDbEntityBase::saveAs(pWd, saveType);
}

Acad::ErrorStatus AecXDbEntityBaseEx::subExplode(AcDbVoidPtrArray& entitySet) const
{
	return AecDbEntityBase::subExplode(entitySet);
}

Acad::ErrorStatus AecXDbEntityBaseEx::subGetGeomExtents(AcDbExtents& extents) const
{
	return AecDbEntityBase::subGetGeomExtents(extents);
}

void AecXDbEntityBaseEx::subList() const
{
	AecDbEntityBase::subList();
}

Acad::ErrorStatus AecXDbEntityBaseEx::subIntersectWith(const AcDbEntity*		ent,
	AcDb::Intersect		intType,
	AcGePoint3dArray&	points,
	INT_PTR				thisGsMarker,
	INT_PTR				otherGsMarker) const
{
	assertReadEnabled();
	return AecDbEntityBase::subIntersectWith(ent, intType, points, thisGsMarker, otherGsMarker);
}

Acad::ErrorStatus AecXDbEntityBaseEx::subIntersectWith(const AcDbEntity*		ent,
	AcDb::Intersect		intType,
	const AcGePlane&	projPlane,
	AcGePoint3dArray&	points,
	INT_PTR				thisGsMarker,
	INT_PTR				otherGsMarker) const
{
	assertReadEnabled();
	return AecDbEntityBase::subIntersectWith(ent, intType, projPlane, points, thisGsMarker, otherGsMarker);
}

Acad::ErrorStatus AecXDbEntityBaseEx::subSetPropertiesFrom(const AcDbEntity* pEntity, Adesk::Boolean doSubents /*= Adesk::kTrue*/)
{
	assertWriteEnabled();
	m_bInJig = ((AecXDbEntityBaseEx*)pEntity)->m_bInJig;
	if (pEntity->isKindOf(AecXDbEntityBaseEx::desc()))
	{
		const BaseEx *pBase = dynamic_cast<const BaseEx*>(pEntity);
		copyBy(*pBase);
	}
	return AecDbEntityBase::subSetPropertiesFrom(pEntity, doSubents);
}

Acad::ErrorStatus AecXDbEntityBaseEx::copyFrom(const AcRxObject * pOther)
{
	AecXDbEntityBaseEx *p = (AecXDbEntityBaseEx*)pOther;
	BaseEx::m_bInJig = p->m_bInJig;
	BaseEx::m_nPaperScale = p->m_nPaperScale;
	return AecDbEntityBase::copyFrom(pOther);
}

#if (ARX > 15)
Acad::ErrorStatus AecXDbEntityBaseEx::subGetOsnapPoints(AcDb::OsnapMode		osnapMode,
	INT_PTR		gsSelectionMark,
	const AcGePoint3d&  ptPick,
	const AcGePoint3d&  lastPoint,
	const AcGeMatrix3d& viewXform,
	AcGePoint3dArray&   snapPoints,
	AcDbIntArray&		geomIds) const
{
	assertReadEnabled();
	return AecDbEntityBase::subGetOsnapPoints(osnapMode, gsSelectionMark, ptPick, lastPoint, viewXform, snapPoints, geomIds);
}

Acad::ErrorStatus AecXDbEntityBaseEx::subGetOsnapPoints(AcDb::OsnapMode		osnapMode,
	INT_PTR		gsSelectionMark,
	const AcGePoint3d&  ptPick,
	const AcGePoint3d&  lastPoint,
	const AcGeMatrix3d& viewXform,
	AcGePoint3dArray&   snapPoints,
	AcDbIntArray&		geomIds,
	const AcGeMatrix3d& insersionMat) const
{

	assertReadEnabled();
	return AecDbEntityBase::subGetOsnapPoints(osnapMode, gsSelectionMark, ptPick, lastPoint, viewXform, snapPoints, geomIds, insersionMat);
}
#endif

#if ARX>15
void AecXDbEntityBaseEx::subGripStatus(const AcDb::GripStat status) { }

Acad::ErrorStatus AecXDbEntityBaseEx::subGetGripPoints(AcDbGripDataPtrArray& grips,
	const double curViewUnitSize,
	const int gripSize,
	const AcGeVector3d& curViewDir,
	const int bitflags) const { return Acad::eOk; }

Acad::ErrorStatus AecXDbEntityBaseEx::subMoveGripPointsAt(const AcDbVoidPtrArray& appData, const AcGeVector3d& offset, const int bitflags)
{
	return Acad::eOk;
}
#endif

Acad::ErrorStatus AecXDbEntityBaseEx::subGetGripPoints(AcGePoint3dArray&  gripPoints, AcDbIntArray&  osnapModes, AcDbIntArray&  geomIds) const
{
	assertReadEnabled();
	return Acad::eOk;
}

Acad::ErrorStatus AecXDbEntityBaseEx::subMoveGripPointsAt(const AcDbIntArray& indices, const AcGeVector3d& offset)
{
	assertWriteEnabled();
	return Acad::eOk;
}

Acad::ErrorStatus AecXDbEntityBaseEx::subGetStretchPoints(AcGePoint3dArray& stretchPoints) const
{
	assertReadEnabled();
	return Acad::eOk;
}

Acad::ErrorStatus AecXDbEntityBaseEx::subMoveStretchPointsAt(const AcDbIntArray& indices, const AcGeVector3d& offset)
{
	assertWriteEnabled();
	return Acad::eOk;
}

Acad::ErrorStatus AecXDbEntityBaseEx::subTransformBy(const AcGeMatrix3d& xform)
{
	assertWriteEnabled();
	return Acad::eOk;
}

Acad::ErrorStatus  AecXDbEntityBaseEx::subGetTransformedCopy(const AcGeMatrix3d& xform,
	AcDbEntity*& pEnt) const
{
	assertReadEnabled();
	return AecDbEntityBase::subGetTransformedCopy(xform, pEnt);
}

Acad::ErrorStatus AecXDbEntityBaseEx::subDeepClone(AcDbObject*    pOwner,
	AcDbObject*&   pClonedObject,
	AcDbIdMapping& idMap,
	Adesk::Boolean isPrimary) const
{
	return AecDbEntityBase::subDeepClone(pOwner, pClonedObject, idMap, isPrimary);
}

Acad::ErrorStatus AecXDbEntityBaseEx::subWblockClone(AcRxObject*    pOwner,
	AcDbObject*&   pClonedObject,
	AcDbIdMapping& idMap,
	Adesk::Boolean isPrimary) const
{
	return AecDbEntityBase::subWblockClone(pOwner, pClonedObject, idMap, isPrimary);
}

Acad::ErrorStatus AecXDbEntityBaseEx::dwgInFields(AcDbDwgFiler* pFiler)
{
	assertWriteEnabled();
	Acad::ErrorStatus es = AecDbEntityBase::dwgInFields(pFiler);
	if (es != Acad::eOk) return es;
	return BaseEx::dwgInFields(pFiler);
}

Acad::ErrorStatus AecXDbEntityBaseEx::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	assertReadEnabled();
	Acad::ErrorStatus es = AecDbEntityBase::dwgOutFields(pFiler);
	if (es != Acad::eOk) return es;
	return BaseEx::dwgOutFields(pFiler);
}

Acad::ErrorStatus AecXDbEntityBaseEx::dxfInFields(AcDbDxfFiler* pFiler)
{
	assertWriteEnabled();
	return AecDbEntityBase::dxfInFields(pFiler);
}

Acad::ErrorStatus AecXDbEntityBaseEx::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	assertReadEnabled();
	return AecDbEntityBase::dxfOutFields(pFiler);
}

Acad::ErrorStatus AecXDbEntityBaseEx::Draw2d(AcGiDraw &dc) const
{
	return AecDbEntityBase::Draw2d(dc);
}

Acad::ErrorStatus AecXDbEntityBaseEx::Draw3d(AcGiDraw &dc) const
{
	return AecDbEntityBase::Draw3d(dc);
}



void AecXDbEntityBaseEx::AssertWriteEnabled(Adesk::Boolean autoUndo /*= true*/, Adesk::Boolean recordModified /*= true*/)
{
	if (m_bInJig)
		return AecDbEntityBase::assertWriteEnabled(autoUndo, recordModified);
	return AecDbEntityBase::AssertWriteEnabled(autoUndo, recordModified);
}



//获取二维视图显示的图形
int  AecXDbEntityBaseEx::GetDraw2dables(Adesk::UInt16 nDrawStyle, AcDbVoidPtrArray& arEntPtrs) const
{
	assertReadEnabled();
	return AecDbEntityBase::GetDraw2dables(nDrawStyle, arEntPtrs);
}

//获取三维显示图形
int  AecXDbEntityBaseEx::GetDraw3dables(AcDbVoidPtrArray& arEntPtrs, bool bWriteBimInfo) const
{
	assertReadEnabled();
	return AecDbEntityBase::GetDraw3dables(arEntPtrs, bWriteBimInfo);
}

int AecXDbEntityBaseEx::GetSectionDraw(const AcGePoint3d& ptFr, const AcGePoint3d& ptTo, const AcGeVector3d& vtViewDir, const AcGeVector3d& vtTo, AcDbVoidPtrArray&  arRegionPtrs) const
{
	return AecDbEntityBase::GetSectionDraw(ptFr, ptTo, vtViewDir, vtTo, arRegionPtrs);
}

double AecXDbEntityBaseEx::GetVolume(bool bIsBody/* = false*/) const
{
	assertReadEnabled();
	return AecDbEntityBase::GetVolume(bIsBody);
}

int AecXDbEntityBaseEx::ComparedTo(AecXDbEntityBaseEx* pEntOther) const
{
	return AecDbEntityBase::comparedTo(pEntOther);
}

SHJson::WValue& AecXDbEntityBaseEx::ToJson() const
{
	assertReadEnabled();
	return AecDbEntityBase::ToJson();
}

bool AecXDbEntityBaseEx::ByJson(const SHJson::WValue &v)
{
	AssertWriteEnabled();
	return AecDbEntityBase::ByJson(v);
}

#pragma endregion

#pragma region AecXDbCurveBaseEx
ACRX_NO_CONS_DEFINE_MEMBERS(AecXDbCurveBaseEx, AecDbCurveBase);

AecXDbCurveBaseEx::AecXDbCurveBaseEx(void)
{
	AecXDbCurveBaseEx::m_eExplodeOrDrawType = kWroldDraw;
	AecXDbCurveBaseEx::m_nDrawDimCur = -1;
}
AecXDbCurveBaseEx::~AecXDbCurveBaseEx(void) {}

Adesk::Boolean AecXDbCurveBaseEx::isPlanar() const { return AecDbCurveBase::isPlanar(); }
Acad::ErrorStatus AecXDbCurveBaseEx::getPlane(AcGePlane &plane, AcDb::Planarity &planarity) const { return AecDbCurveBase::getPlane(plane, planarity); }
void AecXDbCurveBaseEx::getEcs(AcGeMatrix3d& retVal) const { return AecDbCurveBase::getEcs(retVal); }

Adesk::UInt32 AecXDbCurveBaseEx::subViewportDrawLogicalFlags(AcGiViewportDraw * vd) { return AecDbCurveBase::subViewportDrawLogicalFlags(vd); }
Adesk::UInt32 AecXDbCurveBaseEx::subSetAttributes(AcGiDrawableTraits * traits) { return AecDbCurveBase::subSetAttributes(traits); }

Adesk::Boolean AecXDbCurveBaseEx::subWorldDraw(AcGiWorldDraw *pWd) { return AecDbCurveBase::subWorldDraw(pWd); }
void AecXDbCurveBaseEx::subViewportDraw(AcGiViewportDraw* pMode) { return AecDbCurveBase::subViewportDraw(pMode); }

void AecXDbCurveBaseEx::saveAs(AcGiWorldDraw *pWd, AcDb::SaveType saveType)
{
	AcGiRegenType rtype = pWd->regenType();
	if (rtype == kAcGiSaveWorldDrawForProxy)
		drawProxyEntity(_Get2DBuffer(), pWd);
	else
		AecDbCurveBase::saveAs(pWd, saveType);
}

Acad::ErrorStatus AecXDbCurveBaseEx::subExplode(AcDbVoidPtrArray& entitySet) const { return AecDbCurveBase::subExplode(entitySet); }
Acad::ErrorStatus AecXDbCurveBaseEx::subGetGeomExtents(AcDbExtents& extents) const { return AecDbCurveBase::subGetGeomExtents(extents); }
void AecXDbCurveBaseEx::subList() const { return AecDbCurveBase::subList(); }

Acad::ErrorStatus	AecXDbCurveBaseEx::subIntersectWith(const AcDbEntity *ent,
	AcDb::Intersect		intType,
	AcGePoint3dArray&	points,
	INT_PTR				thisGsMarker,
	INT_PTR				otherGsMarker) const
{
	return AecDbCurveBase::subIntersectWith(ent, intType, points, thisGsMarker,otherGsMarker);
}

Acad::ErrorStatus	AecXDbCurveBaseEx::subIntersectWith(const AcDbEntity *ent
	, AcDb::Intersect	intType
	, const AcGePlane&	projPlane
	, AcGePoint3dArray&	points
	, INT_PTR			thisGsMarker
	, INT_PTR			otherGsMarker) const
{
	return AecDbCurveBase::subIntersectWith(ent, intType, projPlane,  points, thisGsMarker, otherGsMarker);
}

Acad::ErrorStatus AecXDbCurveBaseEx::subSetPropertiesFrom(const AcDbEntity* pEntity, Adesk::Boolean doSubents)
{
	m_bInJig = ((AecXDbCurveBaseEx*)pEntity)->m_bInJig;
	if (pEntity->isKindOf(AecXDbCurveBaseEx::desc()))
	{
		const BaseEx *pBase = dynamic_cast<const BaseEx*>(pEntity);
		copyBy(*pBase);
	}
	return AecDbCurveBase::subSetPropertiesFrom(pEntity, doSubents);
}


Acad::ErrorStatus AecXDbCurveBaseEx::subGetOsnapPoints(AcDb::OsnapMode osnapMode
	, INT_PTR             gsSelectionMark
	, const AcGePoint3d&  pickPoint
	, const AcGePoint3d&  lastPoint
	, const AcGeMatrix3d& viewXform
	, AcGePoint3dArray&   snapPoints
	, AcDbIntArray&       geomIds) const
{
	return AecDbCurveBase::subGetOsnapPoints(osnapMode
		, gsSelectionMark
		, pickPoint
		, lastPoint
		, viewXform
		, snapPoints
		, geomIds);
}
Acad::ErrorStatus AecXDbCurveBaseEx::copyFrom(const AcRxObject * pOther)
{
	AecXDbCurveBaseEx *p = (AecXDbCurveBaseEx*)pOther;
	BaseEx::m_bInJig = p->m_bInJig;
	BaseEx::m_nPaperScale = p->m_nPaperScale;
	return AecDbCurveBase::copyFrom(pOther);
}

Acad::ErrorStatus AecXDbCurveBaseEx::subGetOsnapPoints(AcDb::OsnapMode osnapMode,
	INT_PTR             gsSelectionMark,
	const AcGePoint3d&  pickPoint,
	const AcGePoint3d&  lastPoint,
	const AcGeMatrix3d& viewXform,
	AcGePoint3dArray&   snapPoints,
	AcDbIntArray&       geomIds,
	const AcGeMatrix3d& insertionMat) const
{
	return AecDbCurveBase::subGetOsnapPoints(osnapMode
		, gsSelectionMark
		, pickPoint
		, lastPoint
		, viewXform
		, snapPoints
		, geomIds
		, insertionMat);
}

void AecXDbCurveBaseEx::subGripStatus(const AcDb::GripStat status) { return AecDbCurveBase::subGripStatus(status); }

Acad::ErrorStatus AecXDbCurveBaseEx::subGetGripPoints(AcDbGripDataPtrArray& grips
	, const double curViewUnitSize
	, const int gripSize
	, const AcGeVector3d& curViewDir
	, const int bitflags) const
{
	return AecDbCurveBase::subGetGripPoints(grips, curViewUnitSize, gripSize, curViewDir, bitflags);
}

Acad::ErrorStatus AecXDbCurveBaseEx::subMoveGripPointsAt(const AcDbVoidPtrArray& appData
	, const AcGeVector3d& offset
	, const int bitflags)
{
	return AecDbCurveBase::subMoveGripPointsAt(appData, offset, bitflags);
}


Acad::ErrorStatus AecXDbCurveBaseEx::subGetGripPoints(AcGePoint3dArray&  gripPoints
	, AcDbIntArray&  osnapModes
	, AcDbIntArray&  geomIds) const
{
	return AecDbCurveBase::subGetGripPoints(gripPoints, osnapModes, geomIds);
}

Acad::ErrorStatus AecXDbCurveBaseEx::subMoveGripPointsAt(const AcDbIntArray& indices, const AcGeVector3d& offset) { return AecDbCurveBase::subMoveGripPointsAt(indices, offset); }

Acad::ErrorStatus AecXDbCurveBaseEx::subGetStretchPoints(AcGePoint3dArray& stretchPoints) const { return AecDbCurveBase::subGetStretchPoints(stretchPoints); }

Acad::ErrorStatus AecXDbCurveBaseEx::subMoveStretchPointsAt(const AcDbIntArray& indices, const AcGeVector3d& offset) { return AecDbCurveBase::subMoveStretchPointsAt(indices, offset); }

Acad::ErrorStatus AecXDbCurveBaseEx::subTransformBy(const AcGeMatrix3d& xform) { return AecDbCurveBase::subTransformBy(xform); }

Acad::ErrorStatus AecXDbCurveBaseEx::subGetTransformedCopy(const AcGeMatrix3d& xform, AcDbEntity*& ent) const { return AecDbCurveBase::subGetTransformedCopy(xform, ent); }

//AcDbCurve
Adesk::Boolean AecXDbCurveBaseEx::isClosed() const { return AecDbCurveBase::isClosed(); }
Adesk::Boolean AecXDbCurveBaseEx::isPeriodic() const { return AecDbCurveBase::isPeriodic(); }

Acad::ErrorStatus AecXDbCurveBaseEx::getStartParam(double &d) const { return AecDbCurveBase::getStartParam(d); }
Acad::ErrorStatus AecXDbCurveBaseEx::getEndParam(double &d) const { return AecDbCurveBase::getEndParam(d); }

Acad::ErrorStatus AecXDbCurveBaseEx::getStartPoint(AcGePoint3d &pt) const { return AecDbCurveBase::getStartPoint(pt); }
Acad::ErrorStatus AecXDbCurveBaseEx::getEndPoint(AcGePoint3d &pt) const { return AecDbCurveBase::getEndPoint(pt); }

Acad::ErrorStatus AecXDbCurveBaseEx::getPointAtParam(double d, AcGePoint3d &pt) const { return AecDbCurveBase::getPointAtParam(d, pt); }
Acad::ErrorStatus AecXDbCurveBaseEx::getParamAtPoint(const AcGePoint3d &pt, double &d)const { return AecDbCurveBase::getParamAtPoint(pt, d); }

Acad::ErrorStatus AecXDbCurveBaseEx::getDistAtParam(double param, double &dist) const { return AecDbCurveBase::getDistAtParam(param, dist); }
Acad::ErrorStatus AecXDbCurveBaseEx::getParamAtDist(double dist, double &param) const { return AecDbCurveBase::getParamAtDist(dist, param); }
Acad::ErrorStatus AecXDbCurveBaseEx::getDistAtPoint(const AcGePoint3d &pt, double &d)const { return AecDbCurveBase::getDistAtPoint(pt, d); }
Acad::ErrorStatus AecXDbCurveBaseEx::getPointAtDist(double d, AcGePoint3d &pt) const { return AecDbCurveBase::getPointAtDist(d, pt); }

Acad::ErrorStatus AecXDbCurveBaseEx::getFirstDeriv(double param, AcGeVector3d &firstDeriv) const { return AecDbCurveBase::getFirstDeriv(param, firstDeriv); }
Acad::ErrorStatus AecXDbCurveBaseEx::getFirstDeriv(const AcGePoint3d &pt, AcGeVector3d &firstDeriv) const { return AecDbCurveBase::getFirstDeriv(pt, firstDeriv); }
Acad::ErrorStatus AecXDbCurveBaseEx::getSecondDeriv(double param, AcGeVector3d &secDeriv) const { return AecDbCurveBase::getSecondDeriv(param, secDeriv); }
Acad::ErrorStatus AecXDbCurveBaseEx::getSecondDeriv(const AcGePoint3d &pt, AcGeVector3d &secDeriv) const { return AecDbCurveBase::getSecondDeriv(pt, secDeriv); }

Acad::ErrorStatus AecXDbCurveBaseEx::getClosestPointTo(const AcGePoint3d &givenPnt
	, AcGePoint3d &pointOnCurve
	, Adesk::Boolean extend) const
{
	return AecDbCurveBase::getClosestPointTo(givenPnt, pointOnCurve, extend);
}

Acad::ErrorStatus AecXDbCurveBaseEx::getClosestPointTo(const AcGePoint3d &givenPnt
	, const AcGeVector3d &direction
	, AcGePoint3d& pointOnCurve
	, Adesk::Boolean extend) const
{
	return AecDbCurveBase::getClosestPointTo(givenPnt, direction, pointOnCurve, extend);
}

Acad::ErrorStatus AecXDbCurveBaseEx::getSplitCurves(const AcGeDoubleArray& params, AcDbVoidPtrArray& curveSegments) const { return AecDbCurveBase::getSplitCurves(params, curveSegments); }
Acad::ErrorStatus AecXDbCurveBaseEx::getSplitCurves(const AcGePoint3dArray& points, AcDbVoidPtrArray& curveSegments) const { return AecDbCurveBase::getSplitCurves(points, curveSegments); }

Acad::ErrorStatus AecXDbCurveBaseEx::extend(double newParam) { return AecDbCurveBase::extend(newParam); }
Acad::ErrorStatus AecXDbCurveBaseEx::extend(Adesk::Boolean extendStart, const AcGePoint3d& toPoint) { return AecDbCurveBase::extend(extendStart, toPoint); }

Acad::ErrorStatus AecXDbCurveBaseEx::getSpline(AcDbSpline *&spline) const { return AecDbCurveBase::getSpline(spline); }
Acad::ErrorStatus AecXDbCurveBaseEx::getArea(double &d) const { return AecDbCurveBase::getArea(d); }

Acad::ErrorStatus AecXDbCurveBaseEx::getOffsetCurves(double offsetDist, AcDbVoidPtrArray& offsetCurves) const { return AecDbCurveBase::getOffsetCurves(offsetDist, offsetCurves); }

Acad::ErrorStatus AecXDbCurveBaseEx::getProjectedCurve(const AcGePlane &plane, const AcGeVector3d& projDir, AcDbCurve*& projCrv) const { return AecDbCurveBase::getProjectedCurve(plane, projDir,projCrv); }
Acad::ErrorStatus AecXDbCurveBaseEx::getOrthoProjectedCurve(const AcGePlane &plane, AcDbCurve*& projCrv) const { return AecDbCurveBase::getOrthoProjectedCurve(plane, projCrv); }

Acad::ErrorStatus AecXDbCurveBaseEx::getOffsetCurvesGivenPlaneNormal(const AcGeVector3d& normal
	, double offsetDist
	, AcDbVoidPtrArray& offsetCurves) const
{
	return AecDbCurveBase::getOffsetCurvesGivenPlaneNormal(normal, offsetDist, offsetCurves);
}

Acad::ErrorStatus AecXDbCurveBaseEx::dwgInFields(AcDbDwgFiler *pFiler)
{
	assertWriteEnabled();
	Acad::ErrorStatus es = AecDbCurveBase::dwgInFields(pFiler);
	if (es != Acad::eOk) return es;
	return BaseEx::dwgInFields(pFiler);
}

Acad::ErrorStatus AecXDbCurveBaseEx::dwgOutFields(AcDbDwgFiler *pFiler) const
{
	assertReadEnabled();
	Acad::ErrorStatus es = AecDbCurveBase::dwgOutFields(pFiler);
	if (es != Acad::eOk) return es;
	return BaseEx::dwgOutFields(pFiler);
}

Acad::ErrorStatus AecXDbCurveBaseEx::dxfInFields(AcDbDxfFiler *pFiler)
{
	return AecDbCurveBase::dxfInFields(pFiler); 
}

Acad::ErrorStatus AecXDbCurveBaseEx::dxfOutFields(AcDbDxfFiler *pFiler) const
{
	return AecDbCurveBase::dxfOutFields(pFiler);
}

Acad::ErrorStatus AecXDbCurveBaseEx::subDeepClone(AcDbObject* pOwnerObject
	, AcDbObject*& pClonedObject
	, AcDbIdMapping& idMap
	, Adesk::Boolean isPrimary) const
{
	return AecDbCurveBase::subDeepClone(pOwnerObject, pClonedObject, idMap, isPrimary);
}

Acad::ErrorStatus AecXDbCurveBaseEx::subWblockClone(AcRxObject* pOwnerObject
	, AcDbObject*& pClonedObject
	, AcDbIdMapping& idMap
	, Adesk::Boolean isPrimary) const
{
	return AecDbCurveBase::subWblockClone(pOwnerObject, pClonedObject, idMap, isPrimary);
}


//专业数据 和绘制设置
AecDbObjXDataMap* AecXDbCurveBaseEx::GetSpecialtyData(AcDb::OpenMode bMode) { return BaseEx::__GetSpecialtyData(); }
const AecDbObjXDataMap* AecXDbCurveBaseEx::GetSpecialtyData() const { return BaseEx::__GetSpecialtyDataReadOnly(); };

//获取二维视图显示的图形
int  AecXDbCurveBaseEx::GetDraw2dables(Adesk::UInt16 nDrawStyle, AcDbVoidPtrArray& arEntPtrs) const { return AecDbCurveBase::GetDraw2dables(nDrawStyle, arEntPtrs); }

//获取三维显示图形
int  AecXDbCurveBaseEx::GetDraw3dables(AcDbVoidPtrArray& arEntPtrs, bool bWriteBimInfo) const { return AecDbCurveBase::GetDraw3dables(arEntPtrs, bWriteBimInfo); }

//剖切提取
int AecXDbCurveBaseEx::GetSectionDraw(const AcGePoint3d& ptFr
	, const AcGePoint3d& ptTo
	, const AcGeVector3d& vtViewDir
	, const AcGeVector3d& vtTo
	, AcDbVoidPtrArray&  arRegionPtrs) const
{
	return AecDbCurveBase::GetSectionDraw(ptFr, ptTo, vtViewDir, vtTo, arRegionPtrs);
}

double AecXDbCurveBaseEx::GetVolume(bool bIsBody) const { return AecDbCurveBase::GetVolume(bIsBody); }

int AecXDbCurveBaseEx::ComparedTo(AecDbCurveBase* pCurOther) const { return AecDbCurveBase::ComparedTo(pCurOther); }

void AecXDbCurveBaseEx::SetActive(bool bActive) {};
bool AecXDbCurveBaseEx::IsActive() const { return false; }

// 导出json
SHJson::WValue& AecXDbCurveBaseEx::ToJson() const { return AecDbCurveBase::ToJson(); }
// 通过json创建
bool AecXDbCurveBaseEx::ByJson(const SHJson::WValue &v) { return AecDbCurveBase::ByJson(v); }


Acad::ErrorStatus AecXDbCurveBaseEx::SetBaseCurve(const AcDbCurve* pDbCurve) { return AecDbCurveBase::SetBaseCurve(pDbCurve); }
AcDbCurve* AecXDbCurveBaseEx::GetBaseCurve(bool bOrthoProjectToXY) const { return AecDbCurveBase::GetBaseCurve(bOrthoProjectToXY); }
//返回原生Curve,不可以删除
AcDbCurve* AecXDbCurveBaseEx::GetNativeCurve() const { return AecDbCurveBase::GetNativeCurve(); }

//以下需要 AEC 派生
Acad::ErrorStatus AecXDbCurveBaseEx::Draw2d(AcGiDraw &dc) const { return AecDbCurveBase::Draw2d(dc); }

Acad::ErrorStatus AecXDbCurveBaseEx::Draw3d(AcGiDraw &dc) const { return AecDbCurveBase::Draw3d(dc); }

//清理图元的特定writeenable
void AecXDbCurveBaseEx::AssertWriteEnabled(Adesk::Boolean autoUndo, Adesk::Boolean recordModified)
{
	if (m_bInJig)
		return AecDbCurveBase::assertWriteEnabled(autoUndo, recordModified);
	return AecDbCurveBase::AssertWriteEnabled(autoUndo, recordModified); 
}

#pragma endregion