envi-code/SourceCode/Code2026/AecRxBase/AecDbCurveBase.cpp

#include "stdafx.h"
#include <sstream>
#include "AecDbCurveBase.h"
#include "AcGiViewDraw.h"
#include "AcGiExplodeDraw.h"
#include "simpleproperty.h"
#include "dbobjptr.h"
#include "AecDbObjXDataMap.h"
#include "AecDbEntityBase.h"
#include "dbgrip.h"
#include "AecGripCback.h"

extern CString IDCreate();

ACRX_NO_CONS_DEFINE_MEMBERS(AecDbCurveBase, AcDbCurve);

AecDbCurveBase::AecDbCurveBase(void) : AecDbEntityCommon()
{
}

AecDbCurveBase::~AecDbCurveBase(void) { }

Adesk::UInt32 AecDbCurveBase::subViewportDrawLogicalFlags(AcGiViewportDraw * vd)
{
	// 基类实现是 protected，只能在这里取；后续计算交给 Common。
	return AecDbEntityCommon::base_ViewportDrawLogicalFlags(
		AcDbCurve::subViewportDrawLogicalFlags(vd));
}

Adesk::UInt32 AecDbCurveBase::subSetAttributes(AcGiDrawableTraits * traits)
{
	// 基类实现是 protected，只能在这里取；后续计算交给 Common。
	return AecDbEntityCommon::base_SetAttributes(
		AcDbCurve::subSetAttributes(traits));
}

Adesk::Boolean AecDbCurveBase::subWorldDraw(AcGiWorldDraw *pWd)
{
	// 具体实现与另一条根共用 AecDbEntityCommon::base_WorldDraw，
	// 这里只保留 AcGiDrawable 虚函数这一侧的入口。
	return AecDbEntityCommon::base_WorldDraw(pWd);
}

void AecDbCurveBase::subViewportDraw(AcGiViewportDraw* pMode)
{
	// 具体实现与另一条根共用 AecDbEntityCommon::base_ViewportDraw，
	// 这里只保留 AcGiDrawable 虚函数这一侧的入口。
	AecDbEntityCommon::base_ViewportDraw(pMode);
}

//保存代理实体图元
void AecDbCurveBase::saveAs(AcGiWorldDraw *pWd,AcDb::SaveType saveType)
{
	// 具体实现与另一条根共用 AecDbEntityCommon::base_SaveAs，
	// 这里只保留 AcGiDrawable 虚函数这一侧的入口。
	AecDbEntityCommon::base_SaveAs(pWd, saveType);
}

Adesk::Boolean AecDbCurveBase::CallWorldDraw(AcGiWorldDraw *pWd)
{
	// 虚拟调用，回到最派生类的 subWorldDraw
	return subWorldDraw(pWd);
}

Acad::ErrorStatus AecDbCurveBase::subExplode(AcDbVoidPtrArray& entitySet) const
{
	// 具体实现与另一条根共用 AecDbEntityCommon::base_Explode，
	// 这里只保留虚函数这一侧的入口。
	return AecDbEntityCommon::base_Explode(entitySet);
}

Acad::ErrorStatus AecDbCurveBase::subGetGeomExtents(AcDbExtents& extents) const
{
	// 具体实现与另一条根共用 AecDbEntityCommon::base_GetGeomExtents，
	// 这里只保留 AcDbEntity 虚函数这一侧的入口。
	return AecDbEntityCommon::base_GetGeomExtents(extents);
}


void AecDbCurveBase::subList() const
{
	AcDbCurve::subList();
}

Acad::ErrorStatus AecDbCurveBase::setColorIndex(Adesk::UInt16 color,Adesk::Boolean doSubents/* = true*/)
{
	assertWriteEnabled();
	AecDbObjXDataMap* pMap = GetSpecialtyData();
	if (pMap != NULL)
	{
		int nCr = 0;
		if (pMap->GetAt(_T("COLOR"),nCr))
		{
			pMap->SetAt(_T("COLOR"),color);
		}
	}
	return AcDbCurve::setColorIndex(color,doSubents);
}

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

	Acad::ErrorStatus es;
	AcDbCurve* pNaCrv = GetNativeCurve();
	if (pNaCrv != NULL)
	{
		//放开后很慢
		es = pNaCrv->intersectWith(ent,intType,points,thisGsMarker,otherGsMarker);
	}

	//EXTEND 仅仅需要 m_pBaseCurve 求交
	struct resbuf rb;
	acedGetVar(_T("CMDNAMES"),&rb);
	if (_tcscmp(rb.resval.rstring,_T("EXTEND")) != 0)
	{
		int expMode = GetExplodeMode();
		if (expMode == 2)
		{
			return Acad::eNotImplementedYet;
		}

		const AcDbVoidPtrArray& entSet = Get2DBuffer();
		es = Acad::eNotApplicable;

		int len = entSet.length();
		for(int i = 0; i < len; i++)
		{
			AcDbEntity *pEnt = (AcDbEntity *)entSet[i];
			if (pEnt != NULL && Acad::eOk == pEnt->intersectWith(ent, intType, points, 0, otherGsMarker) )
			{
				es = Acad::eOk;
			}
		}
	}
	return es;
}

Acad::ErrorStatus AecDbCurveBase::subIntersectWith(const AcDbEntity*		ent,
												AcDb::Intersect		intType,
												const AcGePlane&	projPlane,
												AcGePoint3dArray&	points,
												INT_PTR				thisGsMarker,
												INT_PTR				otherGsMarker) const
{
	assertReadEnabled();
	
	Acad::ErrorStatus es;
	AcDbCurve* pNaCrv = GetNativeCurve();
	if (pNaCrv != NULL)
	{
		//放开后很慢
		es = pNaCrv->intersectWith(ent,intType,points,thisGsMarker,otherGsMarker);
	}

	int expMode = GetExplodeMode();
	if (expMode == 2) 
	{
		return Acad::eNotImplementedYet;
	}

	//EXTEND 仅仅需要 m_pBaseCurve 求交
	struct resbuf rb;
	acedGetVar(_T("CMDNAMES"),&rb);
	if (_tcscmp(rb.resval.rstring,_T("EXTEND")) != 0)
	{
		const AcDbVoidPtrArray& entSet = Get2DBuffer();
		es = Acad::eNotApplicable;

		int len = entSet.length();
		for (int i = 0; i < len; i++)
		{
			AcDbEntity *pEnt = (AcDbEntity *)entSet[i];
			if (pEnt != NULL && Acad::eOk == pEnt->intersectWith(ent, intType, projPlane, points, 0, otherGsMarker) )
			{
				es = Acad::eOk;
			}
		}
	}
	return es;
}

Acad::ErrorStatus AecDbCurveBase::subSetPropertiesFrom( const AcDbEntity* pEntity, Adesk::Boolean doSubents/* = Adesk::kTrue*/)
{
	assertWriteEnabled();
	Acad::ErrorStatus es = AcDbCurve::setPropertiesFrom(pEntity, doSubents);

	// 颜色
	{
		setColorIndex(pEntity->colorIndex());
	}

	//图层
	if (database() == NULL || 
		database() == pEntity->database())
	{
		{
			setLayer(layerId());
		}

		// 线型
		{
			setLinetype(pEntity->linetypeId());
		}

#if ARX > 16
		// 材质
		{
			setMaterial(pEntity->materialId());
		}
#endif
	}

	// 线型比例
	{
		setLinetypeScale(pEntity->linetypeScale());
	}

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

	return es;
}

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

Acad::ErrorStatus AecDbCurveBase::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 getOsnapPoints(osnapMode,gsSelectionMark,ptPick,lastPoint,viewXform,snapPoints,geomIds);
}
#endif

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

}

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

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

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

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

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

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

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

Acad::ErrorStatus  AecDbCurveBase::subGetTransformedCopy(const AcGeMatrix3d& xform,AcDbEntity*& pEnt) const
{
	assertReadEnabled();
	AcDbEntity *pCloned = (AcDbEntity *)clone();
	pCloned->setLayer(layerId());//
	((AecDbCurveBase*)pCloned)->m_nDrawDimCur = m_nDrawDimCur;

	Acad::ErrorStatus es = pCloned->transformBy(xform);
	if(es == Acad::eOk)
		pEnt = pCloned;
	else
		DELETE_PTR(pCloned);
	return es;
}

Acad::ErrorStatus AecDbCurveBase::subDeepClone(	AcDbObject*    pOwner,
														AcDbObject*&   pClonedObject,
														AcDbIdMapping& idMap,
														Adesk::Boolean isPrimary) const
{
	// 具体实现与 AecDbEntityBase 共用 AecDbEntityCommon::base_DeepClone，
	// 这里只保留 AcDbObject 虚函数这一侧的入口。
	return AecDbEntityCommon::base_DeepClone(pOwner, pClonedObject, idMap, isPrimary);
}

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

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

Adesk::Boolean AecDbCurveBase::isClosed() const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		Adesk::Boolean bRet = pCurve->isClosed();
		return bRet;
	}
	else
	{
		return AcDbCurve::isClosed();
	}
}

Adesk::Boolean AecDbCurveBase::isPeriodic() const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		Adesk::Boolean bRet = pCurve->isPeriodic();
		return bRet;
	}
	else
	{
		return AcDbCurve::isPeriodic();
	}
}

Acad::ErrorStatus AecDbCurveBase::getStartParam(double&pa) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getStartParam(pa);
		return bRet;
	}
	else
	{
		return AcDbCurve::getStartParam(pa);
	}
}

Acad::ErrorStatus AecDbCurveBase::getEndParam  (double&pa) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getEndParam(pa);
		return bRet;
	}
	else
	{
		return AcDbCurve::getEndParam(pa);
	}
}

Acad::ErrorStatus AecDbCurveBase::getStartPoint(AcGePoint3d&pt) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getStartPoint(pt);
		return bRet;
	}
	else
	{
		return AcDbCurve::getStartPoint(pt);
	}
}

Acad::ErrorStatus AecDbCurveBase::getEndPoint  (AcGePoint3d&pt) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getEndPoint(pt);
		return bRet;
	}
	else
	{
		return AcDbCurve::getEndPoint(pt);
	}
}

Acad::ErrorStatus AecDbCurveBase::getPointAtParam(double pa, AcGePoint3d&pt) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getPointAtParam(pa,pt);
		return bRet;
	}
	else
	{
		return AcDbCurve::getPointAtParam(pa,pt);
	}
}

Acad::ErrorStatus AecDbCurveBase::getParamAtPoint(const AcGePoint3d& pt, double&pa)const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getParamAtPoint(pt,pa);
		return bRet;
	}
	else
	{
		return AcDbCurve::getParamAtPoint(pt,pa);
	}
}

Acad::ErrorStatus AecDbCurveBase::getDistAtParam (double param, double& dist) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getDistAtParam(param,dist);
		return bRet;
	}
	else
	{
		return AcDbCurve::getDistAtParam(param,dist);
	}
}

Acad::ErrorStatus AecDbCurveBase::getParamAtDist (double dist, double& param) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getParamAtDist(dist,param);
		return bRet;
	}
	else
	{
		return AcDbCurve::getParamAtDist(dist,param);
	}
}

Acad::ErrorStatus AecDbCurveBase::getDistAtPoint (const AcGePoint3d&pt, double&dist)const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getDistAtPoint(pt,dist);
		return bRet;
	}
	else
	{
		return AcDbCurve::getDistAtPoint(pt,dist);
	}
}

Acad::ErrorStatus AecDbCurveBase::getPointAtDist (double dist, AcGePoint3d&pt) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getPointAtDist(dist,pt);
		return bRet;
	}
	else
	{
		return AcDbCurve::getPointAtDist(dist,pt);
	}
}

Acad::ErrorStatus AecDbCurveBase::getFirstDeriv  (double param,AcGeVector3d& firstDeriv) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getFirstDeriv(param,firstDeriv);
		return bRet;
	}
	else
	{
		return AcDbCurve::getFirstDeriv(param,firstDeriv);
	}
}

Acad::ErrorStatus AecDbCurveBase::getFirstDeriv  (const AcGePoint3d&pt,AcGeVector3d& firstDeriv) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getFirstDeriv(pt,firstDeriv);
		return bRet;
	}
	else
	{
		return AcDbCurve::getFirstDeriv(pt,firstDeriv);
	}
}

Acad::ErrorStatus AecDbCurveBase::getSecondDeriv (double param,AcGeVector3d& secDeriv) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getSecondDeriv(param,secDeriv);
		return bRet;
	}
	else
	{
		return AcDbCurve::getSecondDeriv(param,secDeriv);
	}
}

Acad::ErrorStatus AecDbCurveBase::getSecondDeriv (const AcGePoint3d&pt,AcGeVector3d& secDeriv) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getSecondDeriv(pt,secDeriv);
		return bRet;
	}
	else
	{
		return AcDbCurve::getSecondDeriv(pt,secDeriv);
	}
}

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

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getClosestPointTo(givenPnt,pointOnCurve,extend);
		return bRet;
	}
	else
	{
		return AcDbCurve::getClosestPointTo(givenPnt,pointOnCurve,extend);
	}
}

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

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getClosestPointTo(givenPnt,direction,pointOnCurve,extend);
		return bRet;
	}
	else
	{
		return AcDbCurve::getClosestPointTo(givenPnt,direction,pointOnCurve,extend);
	}
}

Acad::ErrorStatus AecDbCurveBase::getOrthoProjectedCurve(const AcGePlane&	plane,
														 AcDbCurve*&		projCrv) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		AcDbCurve* pCurve1 = NULL;
		Acad::ErrorStatus bRet = pCurve->getOrthoProjectedCurve(plane,pCurve1);
		if (bRet == Acad::eOk)
		{
			AecDbCurveBase* pCurveEnt = (AecDbCurveBase*)clone();
			bRet = pCurveEnt->SetBaseCurve(pCurve1);
			projCrv = pCurveEnt;

			DELETE_PTR(pCurve1);
		}
		return bRet;
	}
	else
	{
		return AcDbCurve::getOrthoProjectedCurve(plane,projCrv);
	}
}

Acad::ErrorStatus AecDbCurveBase::getProjectedCurve(const AcGePlane&	plane,
													const AcGeVector3d& projDir,
													AcDbCurve*&			projCrv) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		AcDbCurve* pCurve1 = NULL;
		Acad::ErrorStatus bRet = pCurve->getProjectedCurve(plane,projDir,pCurve1);
		if (bRet == Acad::eOk)
		{
			AecDbCurveBase* pCurveEnt = (AecDbCurveBase*)clone();
			bRet = pCurveEnt->SetBaseCurve(pCurve1);
			projCrv = pCurveEnt;

			DELETE_PTR(pCurve1);
		}
		return bRet;
	}
	else
	{
		return AcDbCurve::getProjectedCurve(plane,projDir,projCrv);
	}
}

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

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		AcDbVoidPtrArray offsetCurves0;
		Acad::ErrorStatus bRet = pCurve->getOffsetCurves(offsetDist,offsetCurves0);
		if (bRet == Acad::eOk)
		{
			for (long i = 0; i < offsetCurves0.length(); i++)
			{
				AecDbCurveBase*pCurveEnt = (AecDbCurveBase*)clone();
				pCurveEnt->SetBaseCurve((AcDbCurve*)offsetCurves0[i]);
				offsetCurves.append(pCurveEnt);
			}

			deleteArrayVoidPtrs<AcDbEntity>(offsetCurves0);
		}
		return bRet;
	}
	else
	{
		return AcDbCurve::getOffsetCurves(offsetDist,offsetCurves);
	}
}

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

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		AcDbVoidPtrArray offsetCurves0;
		Acad::ErrorStatus bRet = pCurve->getOffsetCurvesGivenPlaneNormal(normal,offsetDist,offsetCurves0);
		if (bRet == Acad::eOk)
		{
			for (long i = 0; i < offsetCurves0.length(); i++)
			{
				AecDbCurveBase*pCurveEnt = (AecDbCurveBase*)clone();
				pCurveEnt->SetBaseCurve((AcDbCurve*)offsetCurves0[i]);
				offsetCurves.append(pCurveEnt);
			}

			deleteArrayVoidPtrs<AcDbEntity>(offsetCurves0);
		}
		return bRet;
	}
	else
		return AcDbCurve::getOffsetCurvesGivenPlaneNormal(normal,offsetDist,offsetCurves);
}

Acad::ErrorStatus AecDbCurveBase::getSpline(AcDbSpline*& spline) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getSpline(spline);
		return bRet;
	}
	else
	{
		return AcDbCurve::getSpline(spline);
	}
}

Acad::ErrorStatus AecDbCurveBase::getSplitCurves (const AcGeDoubleArray& params,
												  AcDbVoidPtrArray& curveSegments) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		AcDbVoidPtrArray curveSegments0;
		Acad::ErrorStatus bRet = pCurve->getSplitCurves(params,curveSegments0);
		if (bRet == Acad::eOk)
		{
			for (long i = 0; i < curveSegments0.length(); i++)
			{
				AecDbCurveBase*pCurveEnt = (AecDbCurveBase*)clone();
				AecDbObjXDataMap* pXDataMap = pCurveEnt->GetSpecialtyData();
				if (pXDataMap != NULL)
				{
					CString sNo;
					if (pXDataMap->GetAt(KEY_NO,sNo))
					{
						sNo = IDCreate();
						pXDataMap->SetAt(KEY_NO,sNo);
					}
				}
				pCurveEnt->SetBaseCurve((AcDbCurve*)curveSegments0[i]);
				curveSegments.append(pCurveEnt);
			}

			deleteArrayVoidPtrs<AcDbEntity>(curveSegments0);
		}
		return bRet;
	}
	else
	{
		return AcDbCurve::getSplitCurves(params,curveSegments);
	}
}

Acad::ErrorStatus AecDbCurveBase::getSplitCurves (const AcGePoint3dArray& points,
												  AcDbVoidPtrArray& curveSegments) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		AcDbVoidPtrArray curveSegments0;
		Acad::ErrorStatus bRet = pCurve->getSplitCurves(points,curveSegments0);
		if (bRet == Acad::eOk)
		{
			for (long i = 0; i < curveSegments0.length(); i++)
			{
				AecDbCurveBase*pCurveEnt = (AecDbCurveBase*)clone();
				AecDbObjXDataMap* pXDataMap = pCurveEnt->GetSpecialtyData();
				if (pXDataMap != NULL)
				{
					CString sNo;
					if (pXDataMap->GetAt(KEY_NO,sNo))
					{
						sNo = IDCreate();
						pXDataMap->SetAt(KEY_NO,sNo);
					}
				}
				pCurveEnt->SetBaseCurve((AcDbCurve*)curveSegments0[i]);
				curveSegments.append(pCurveEnt);
			}

			deleteArrayVoidPtrs<AcDbEntity>(curveSegments0);
		}
		return bRet;
	}
	else
	{
		return AcDbCurve::getSplitCurves(points,curveSegments);
	}
}

Acad::ErrorStatus AecDbCurveBase::extend(double newParam)
{
	AssertWriteEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->extend(newParam);
		if (bRet == Acad::eOk)
		{
			//bRet = SetBaseCurve(pCurve);
		}
		return bRet;
	}
	else
	{
		return AcDbCurve::extend(newParam);
	}
}

static AcDbArc* FormatArc(const AcGePoint3d& ptGe1,const AcGePoint3d& ptGe2,const AcGePoint3d& ptGe3)
{
	AcDbArc* pArcThis = NULL;
	AcGeCircArc3d cirArc3d;
	cirArc3d.set(ptGe1,ptGe2,ptGe3);//可能逆弧

	AcGeVector3d vtNorm = cirArc3d.normal();
	if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))
	{
		if (!vtNorm.isCodirectionalTo(AcGeVector3d::kZAxis))
		{
			vtNorm.negate();//相反
		}
	}
	AcDbCircle cir;
	cir.setCenter(cirArc3d.center());
	cir.setRadius(cirArc3d.radius());
	cir.setNormal(vtNorm);

	AcGePoint3dArray arPts;
	arPts.append(ptGe1);
	arPts.append(ptGe3);

	AcDbVoidPtrArray arCurPtrs;
	cir.getSplitCurves(arPts,arCurPtrs);

	double dPara = 0.0;
	AcDbCurve* pCurve = NULL;
	for (int j = 0;j < arCurPtrs.length();j++)
	{
		pCurve = (AcDbCurve*)arCurPtrs.at(j);
		if (pCurve != NULL)
		{
			if (Acad::eOk == pCurve->getParamAtPoint(ptGe2,dPara))//中点在圆弧上
			{
				AcDbArc* pArc = AcDbArc::cast(pCurve);
				if (pArc != NULL)
				{
					pArcThis = pArc;
					arCurPtrs.removeAt(j);
					break;
				}
			}
		}
	}
	deleteArrayVoidPtrs<AcDbEntity>(arCurPtrs);
	return pArcThis;
}

static AcGePoint3d GetArcMidPoint(AcDbArc* pArc)
{
	double dSta = 0.0,dEnd = 0.0;
	pArc->getStartParam(dSta);
	pArc->getEndParam(dEnd);

	AcGePoint3d ptMid;
	pArc->getPointAtParam((dSta + dEnd) / 2.0,ptMid);

	return ptMid;
}

Acad::ErrorStatus AecDbCurveBase::extend(Adesk::Boolean extendStart,
										 const AcGePoint3d& toPoint)
{
	AssertWriteEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		AcGePoint3d ptS,ptE;
		pCurve->getStartPoint(ptS);
		pCurve->getEndPoint(ptE);

		if (toPoint.distanceTo(ptS) < toPoint.distanceTo(ptE))
			extendStart = Adesk::kTrue;
		else
			extendStart = Adesk::kFalse;

		Acad::ErrorStatus bRet = pCurve->extend(extendStart,toPoint);
		if (bRet == Acad::eOk)
		{
			//延长到外部一点
			//GetNativeCurve
			//bRet = SetBaseCurve(pCurve);
		}
		else
		{
			//内部,缩短到内部一点
			AcDbLine* pLn = AcDbLine::cast(pCurve);
			if (pLn != NULL)
			{
				if (extendStart)
				{
					pLn->setStartPoint(toPoint);
				}
				else
				{
					pLn->setEndPoint(toPoint);
				}
				bRet = Acad::eOk;
			}

			AcDbArc* pArc = AcDbArc::cast(pCurve);
			if (pArc != NULL)
			{
				if (extendStart)//开始缩短
				{
					AcGePoint3d ptE,ptM;
					pArc->getEndPoint(ptE);
					ptM = GetArcMidPoint(pArc);

					AcDbArc* pArc2 = FormatArc(toPoint,ptM,ptE);
					if (pArc2 != NULL)
					{
						pArc->setStartAngle(pArc2->startAngle());
						pArc->setEndAngle(pArc2->endAngle());
						delete pArc2;
					}
				}
				else//末尾缩短
				{
					AcGePoint3d ptE,ptM;
					pArc->getStartPoint(ptE);
					ptM = GetArcMidPoint(pArc);

					AcDbArc* pArc2 = FormatArc(ptE,ptM,toPoint);
					if (pArc2 != NULL)
					{
						pArc->setStartAngle(pArc2->startAngle());
						pArc->setEndAngle(pArc2->endAngle());
						delete pArc2;
					}
				}
				bRet = Acad::eOk;
			}
		}
		return bRet;
	}
	else
	{
		return AcDbCurve::extend(extendStart,toPoint);
	}
}

Acad::ErrorStatus AecDbCurveBase::getArea(double&area) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getArea(area);
		return bRet;
	}
	else
	{
		return AcDbCurve::getArea(area);
	}
}

Adesk::Boolean AecDbCurveBase::isPlanar() const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		Adesk::Boolean bRet = pCurve->isPlanar();
		return bRet;
	}
	else
	{
		return AcDbCurve::isPlanar();
	}
}

Acad::ErrorStatus AecDbCurveBase::getPlane(AcGePlane&plane, AcDb::Planarity&pr) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getPlane(plane,pr);
		return bRet;
	}
	else
	{
		return AcDbCurve::getPlane(plane,pr);
	}
}

void AecDbCurveBase::getEcs(AcGeMatrix3d& retVal) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetNativeCurve();
	if (pCurve != NULL)
	{
		pCurve->getEcs(retVal);
	}
	else
	{
		AcDbCurve::getEcs(retVal);
	}
}

Acad::ErrorStatus AecDbCurveBase::SetBaseCurve(const AcDbCurve* pDbCurve)
{
	return Acad::eNotImplementedYet;
}

AcDbCurve* AecDbCurveBase::GetBaseCurve(bool bOrthoProjectToXY) const
{
	return NULL;
}

AcDbCurve* AecDbCurveBase::GetNativeCurve() const
{
	return NULL;
}

Acad::ErrorStatus AecDbCurveBase::dwgInFields (AcDbDwgFiler* pFiler)
{
	assertWriteEnabled () ;

	//----- Read parent class information first.
	Acad::ErrorStatus es = AcDbCurve::dwgInFields (pFiler) ;
	if ( es != Acad::eOk )
		return (es) ;

	return (pFiler->filerStatus ()) ;
}

Acad::ErrorStatus AecDbCurveBase::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	assertReadEnabled () ;
	//----- Save parent class information first.
	Acad::ErrorStatus es = AcDbCurve::dwgOutFields (pFiler) ;
	if ( es != Acad::eOk )
		return (es) ;

	return (pFiler->filerStatus ()) ;
}

Acad::ErrorStatus AecDbCurveBase::dxfInFields (AcDbDxfFiler* pFiler)
{
	assertWriteEnabled () ;

	//----- Read parent class information first.
	Acad::ErrorStatus es = AcDbCurve::dxfInFields (pFiler) ;
	if ( es != Acad::eOk )
		return (es) ;

	return (pFiler->filerStatus ()) ;
}

Acad::ErrorStatus AecDbCurveBase::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	assertReadEnabled () ;
	//----- Save parent class information first.
	Acad::ErrorStatus es = AcDbCurve::dxfOutFields (pFiler) ;
	if ( es != Acad::eOk )
		return (es) ;

	return (pFiler->filerStatus ()) ;
}

bool AecDbCurveBase::Draw2DBuffers(AcGiDraw &dc)const
{
	if (m_ar2DDrableBufPtrs_.isEmpty())
	{
		return false;
	}
	AcDbEntity *pEnt = NULL;
	for (int i = 0; i < m_ar2DDrableBufPtrs_.length(); ++i)
	{
		pEnt = (AcDbEntity *)m_ar2DDrableBufPtrs_[i];
		pEnt->setLayer(dc.GetLayerId());
		pEnt->setColorIndex(colorIndex());
		dc.DrawEntity(*pEnt);
	}
	return true;
}

int AecDbCurveBase::ComparedTo(AecDbCurveBase* pCurOther) const
{
	return -1;//不做比较
}

double AecDbCurveBase::GetArea() const
{
	assertReadEnabled();

	if (!Has3DBuffer())
	{
		AcGiViewDraw dc(NULL,NULL);
		Draw3d(dc);
	}

	double dArea = 0.0,dAreaAll = 0.0;
	AcDbVoidPtrArray arEntPtrs;
	GetDraw3dables(arEntPtrs);

	AcDbEntity* pEnt = NULL;
	for (int i = 0;i < arEntPtrs.length();i++)
	{
		pEnt = (AcDbEntity*)arEntPtrs.at(i);

		AcDb3dSolid* pSolid = AcDb3dSolid::cast(pEnt);
		if (pSolid != NULL)
		{
			pSolid->getArea(dArea);
			dAreaAll += fabs(dArea);
		}

		AcDbRegion* pReg = AcDbRegion::cast(pEnt);
		if (pReg != NULL)
		{
			pReg->getArea(dArea);
			dAreaAll += fabs(dArea);
		}
	}
	return dAreaAll;
}

static AcGePoint3d MidPoint(AcGePoint3d& pt1, AcGePoint3d& pt2)
{
	return AcGePoint3d((pt1.x + pt2.x) / 2.0,
		(pt1.y + pt2.y) / 2.0,
		(pt1.z + pt2.z) / 2.0);
}

typedef AcArray<AcDbEntity*> AcDbEntityArray;
Acad::ErrorStatus AecDbCurveBase::setTransparency(const AcCmTransparency &trans, Adesk::Boolean doSubents)
{
	AssertWriteEnabled();
	return AcDbEntity::setTransparency(trans, doSubents);
}