//-----------------------------------------------------------------------------+
// Copyright (C), 1998-2007, SH Software Co. Ltd.
// = FileName	:   AecCurveEntity.cpp
// = Version	:   ver2.0
// = Author		:   zjq
// = CreateDate	:   2002-09-09
// = Description:   $曲线对象基类的定义
// = Maintainers: 
//                  
//-----------------------------------------------------------------------------+
#include "StdAfx.h"
#include "AecCurveEntity.h"
#include "XConfigBase.h"
#include "XGlobalFunc.h"
#include "XPrivateGlobalFunc.h"

ACRX_NO_CONS_DEFINE_MEMBERS(AecCurveEntity, AcDbCurve);
AEC_IMPLEMENT_MEMBERS(AecCurveEntity, AcDbCurve);
	
AecCurveEntity::AecCurveEntity()
{
}

Acad::ErrorStatus AecCurveEntity::SetBaseCurve(AcDbCurve*)
{
	return Acad::eNotImplementedYet;
}

AcDbCurve* AecCurveEntity::GetBaseCurve()const
{
	return NULL; //临时对象，外部析构
}

void AecCurveEntity::UnionScale(double nScale)
{
	assertWriteEnabled();
	AcGeMatrix3d mat;
	mat.setToScaling(nScale);
	subTransformBy(mat);
}

Adesk::UInt32 AecCurveEntity::subViewportDrawLogicalFlags(AcGiViewportDraw * vd)
{
    Adesk::UInt32 nRet = AcDbEntity::subViewportDrawLogicalFlags(vd);
    nRet = AEntityBase::ViewportDrawLogicalFlags(vd, nRet);

    return nRet;
}

Adesk::UInt32 AecCurveEntity::subSetAttributes(AcGiDrawableTraits * traits)
{
    Adesk::UInt32 nRet = AcDbEntity::subSetAttributes(traits);
    nRet = AEntityBase::SetAttributes(traits, nRet);

    return nRet;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Acad::ErrorStatus AecCurveEntity::getClosestPointTo(const AcGePoint3d&	givenPnt,
													const AcGeVector3d& direction,
													AcGePoint3d&		pointOnCurve,
													Adesk::Boolean		extend) const
{
	assertReadEnabled();
	
	AcDbCurve* pCurve = GetBaseCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getClosestPointTo(givenPnt,direction,pointOnCurve,extend);
		delete pCurve;
		return bRet;
	}
	else
	{
		return AcDbCurve::getClosestPointTo(givenPnt,direction,pointOnCurve,extend);
	}
}

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

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

			delete pCurve1;
		}

		delete pCurve;
		return bRet;
	}
	else
	{
		return AcDbCurve::getOrthoProjectedCurve(plane,projCrv);
	}
}

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

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

			delete pCurve1;
		}

		delete pCurve;
		return bRet;
	}
	else
	{
		return AcDbCurve::getProjectedCurve(plane,projDir,projCrv);
	}
}

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

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

			ReleaseEntSet(offsetCurves0);
		}

		delete pCurve;
		return bRet;
	}
	else
	{
		return AcDbCurve::getOffsetCurves(offsetDist,offsetCurves);
	}
}

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

	AcDbCurve* pCurve = GetBaseCurve();
	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++)
			{
				AecCurveEntity*pCurveEnt = (AecCurveEntity*)clone();
				pCurveEnt->SetBaseCurve((AcDbCurve*)offsetCurves0[i]);
				offsetCurves.append(pCurveEnt);
			}

			ReleaseEntSet(offsetCurves0);
		}

		delete pCurve;
		return bRet;
	}
	else
		return AcDbCurve::getOffsetCurvesGivenPlaneNormal(normal,offsetDist,offsetCurves);
}

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

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

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

	AcDbCurve* pCurve = GetBaseCurve();
	if (pCurve != NULL)
	{
		AcDbVoidPtrArray curveSegments0;
		Acad::ErrorStatus bRet = pCurve->getSplitCurves(params,curveSegments0);
		if (bRet == Acad::eOk)
		{
			for (long i = 0; i < curveSegments0.length(); i++)
			{
				AecCurveEntity*pCurveEnt = (AecCurveEntity*)clone();
				pCurveEnt->SetBaseCurve((AcDbCurve*)curveSegments0[i]);
				curveSegments.append(pCurveEnt);
			}

			ReleaseEntSet(curveSegments0);
		}

		delete pCurve;
		return bRet;
	}
	else
	{
		return AcDbCurve::getSplitCurves(params,curveSegments);
	}
}

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

	AcDbCurve* pCurve = GetBaseCurve();
	if (pCurve != NULL)
	{
		AcDbVoidPtrArray curveSegments0;
		Acad::ErrorStatus bRet = pCurve->getSplitCurves(points,curveSegments0);
		if (bRet == Acad::eOk)
		{
			for (long i = 0; i < curveSegments0.length(); i++)
			{
				AecCurveEntity*pCurveEnt = (AecCurveEntity*)clone();
				pCurveEnt->SetBaseCurve((AcDbCurve*)curveSegments0[i]);
				curveSegments.append(pCurveEnt);
			}

			ReleaseEntSet(curveSegments0);
		}

		delete pCurve;
		return bRet;
	}
	else
	{
		return AcDbCurve::getSplitCurves(points,curveSegments);
	}
}

Acad::ErrorStatus AecCurveEntity::extend(double newParam)
{
	assertWriteEnabled();

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

		delete pCurve;
		return bRet;
	}
	else
	{
		return AcDbCurve::extend(newParam);
	}
}

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

	AcDbCurve* pCurve = GetBaseCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->extend(extendStart,toPoint);
		if (bRet == Acad::eOk)
		{
			bRet = SetBaseCurve(pCurve);
		}

		delete pCurve;
		return bRet;
	}
	else
	{
		return AcDbCurve::extend(extendStart,toPoint);
	}
}

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

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

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

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

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

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

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

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

Acad::ErrorStatus   AecCurveEntity::GetOsnapPoints(
                                 AcDb::OsnapMode     osnapMode,
                                 int     gsSelectionMark,
                                 const AcGePoint3d&  pickPoint,
                                 const AcGePoint3d&  lastPoint,
                                 const AcGeMatrix3d& viewXform,
                                 AcGePoint3dArray&   snapPoints,
                                 AcDbIntArray&       geomIds) const
{
	assertReadEnabled();

	if (XGeLib::g_bSnapCurveBase)
	{
		AcDbCurve* pCurve = GetBaseCurve();
		if (pCurve != NULL)
		{
			Acad::ErrorStatus bRet = pCurve->getOsnapPoints(osnapMode,gsSelectionMark, pickPoint,
												lastPoint,viewXform,snapPoints,geomIds);
			delete pCurve;

			// add by zjq on 100818 墙体捕捉时允许捕捉墙线和保温线
			if (_tcsicmp(isA()->name(),_T("AecDbWall")) != 0)

			{
				return bRet;
			}
		}
	}

	return AEntityBase::GetOsnapPoints(osnapMode,gsSelectionMark, pickPoint,
									lastPoint,viewXform,snapPoints,geomIds);
}

Acad::ErrorStatus   AecCurveEntity::GetOsnapPoints(
                                 AcDb::OsnapMode     osnapMode,
                                 int     gsSelectionMark,
                                 const AcGePoint3d&  pickPoint,
                                 const AcGePoint3d&  lastPoint,
                                 const AcGeMatrix3d& viewXform,
                                 AcGePoint3dArray&   snapPoints,
                                 AcDbIntArray&       geomIds,
                                 const AcGeMatrix3d& insertionMat) const
{
#if ARX<17
	return Acad::eNotImplemented;
#else
	assertReadEnabled();

	if (g_bSnapCurveBase)
	{
		AcDbCurve* pCurve = GetBaseCurve();
		if (pCurve != NULL)
		{
			Acad::ErrorStatus bRet = pCurve->getOsnapPoints(osnapMode,gsSelectionMark,pickPoint, 
													lastPoint,viewXform,snapPoints,geomIds,insertionMat);

			delete pCurve;

			// add by zjq on 100818 墙体捕捉时允许捕捉墙线和保温线
			if (_tcsicmp(isA()->name(),_T("AecDbWall")) != 0)

			{
				return bRet;
			}
		}
	}
	
	return AEntityBase::GetOsnapPoints(osnapMode,gsSelectionMark, pickPoint,
								lastPoint,viewXform,snapPoints,geomIds,insertionMat);
#endif
}

#if (ARX > 15 && ARX < 18)
Acad::ErrorStatus AecCurveEntity::subGetOsnapPoints(
                                 AcDb::OsnapMode     osnapMode,
                                 INT_PTR     gsSelectionMark,
                                 const AcGePoint3d&  pickPoint,
                                 const AcGePoint3d&  lastPoint,
								 const AcGeFastTransform& viewXform,
                                 AcGePoint3dArray&   snapPoints,
                                 AcDbIntArray&       geomIds) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetBaseCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getOsnapPoints(osnapMode,gsSelectionMark, 
												pickPoint,lastPoint,viewXform,snapPoints,geomIds);
		delete pCurve;
		return bRet;
	}
	else
	{
		return AcDbCurve::subGetOsnapPoints(osnapMode,gsSelectionMark, 
									pickPoint,lastPoint,viewXform,snapPoints,geomIds);
	}
}

Acad::ErrorStatus   AecCurveEntity::subGetOsnapPoints(
                                 AcDb::OsnapMode     osnapMode,
                                 INT_PTR     gsSelectionMark,
                                 const AcGePoint3d&  pickPoint,
                                 const AcGePoint3d&  lastPoint,
								 const AcGeFastTransform& viewXform,
                                 AcGePoint3dArray&   snapPoints,
                                 AcDbIntArray&       geomIds,
                                 const AcGeMatrix3d& insertionMat) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetBaseCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getOsnapPoints(osnapMode,gsSelectionMark, pickPoint,
												lastPoint,viewXform,snapPoints,geomIds,insertionMat);

		delete pCurve;
		return bRet;
	}
	else
	{
		return AcDbCurve::subGetOsnapPoints(osnapMode,gsSelectionMark, pickPoint,
										lastPoint,viewXform,snapPoints,geomIds,insertionMat);
	}
}

Acad::ErrorStatus AecCurveEntity::subTransformBy(const AcGeFastTransform& xform)
{
	assertWriteEnabled();
	
	AcDbCurve* pCurve = GetBaseCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->transformBy(xform);
		if (bRet == Acad::eOk)
		{
			SetBaseCurve(pCurve);
		}
		
		delete pCurve;
		return bRet;
	}
	else
	{
		return AcDbCurve::subTransformBy(xform);
	}
}

#endif

Acad::ErrorStatus AecCurveEntity::subGetGripPoints(AcGePoint3dArray&	gripPoints,
												   AcDbIntArray&		osnapModes,
												   AcDbIntArray&		geomIds)const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetBaseCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getGripPoints(gripPoints,osnapModes,geomIds);
		delete pCurve;
		return bRet;
	}
	else
	{
		return AcDbCurve::subGetGripPoints(gripPoints,osnapModes,geomIds);
	}
}

Acad::ErrorStatus AecCurveEntity::subMoveGripPointsAt(const AcDbIntArray& indices,
												        const AcGeVector3d& offset)
{
	assertWriteEnabled();

	AcDbCurve* pCurve = GetBaseCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->moveGripPointsAt(indices,offset);
		if (bRet == Acad::eOk)
		{
			SetBaseCurve(pCurve);
		}

		delete pCurve;
		return bRet;
	}
	else
	{
		return AcDbCurve::subMoveGripPointsAt(indices,offset);
	}
}

Acad::ErrorStatus AecCurveEntity::subGetStretchPoints(
									   AcGePoint3dArray& stretchPoints) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetBaseCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getStretchPoints(stretchPoints);
		delete pCurve;
		return bRet;
	}
	else
	{
		return AcDbCurve::subGetStretchPoints(stretchPoints);
	}
}

Acad::ErrorStatus AecCurveEntity::subMoveStretchPointsAt(const AcDbIntArray&	indices,
														const AcGeVector3d&		offset)
{
	assertWriteEnabled();

	AcDbCurve* pCurve = GetBaseCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->moveStretchPointsAt(indices,offset);
		if (bRet == Acad::eOk)
		{
			SetBaseCurve(pCurve);
		}

		delete pCurve;
		return bRet;
	}
	else
	{
		return AcDbCurve::subMoveStretchPointsAt(indices,offset);
	}
}

Acad::ErrorStatus AecCurveEntity::IntersectWith(const AcDbEntity*	pEnt,
												AcDb::Intersect		intType, 
												AcGePoint3dArray&	points,
												INT_PTR	 thisGsMarker , 
												INT_PTR	 otherGsMarker ) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetBaseCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->intersectWith(pEnt,intType,points,thisGsMarker,otherGsMarker);
		delete pCurve;
		return bRet;
	}
	else
	{
		return AcDbCurve::subIntersectWith(pEnt,intType,points,thisGsMarker,otherGsMarker);
	}
}

Acad::ErrorStatus AecCurveEntity::IntersectWith(const AcDbEntity*	pEnt,
												 AcDb::Intersect	intType, 
												 const AcGePlane&	projPlane,
												 AcGePoint3dArray&	points, 
												 INT_PTR thisGsMarker,
												 INT_PTR otherGsMarker) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetBaseCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->intersectWith(pEnt,intType,projPlane,points,thisGsMarker,otherGsMarker);
		delete pCurve;
		return bRet;
	}
	else
	{
		return AcDbCurve::subIntersectWith(pEnt,intType,projPlane,points,thisGsMarker,otherGsMarker);
	}
}

Acad::ErrorStatus   AecCurveEntity::TransformBy(const AcGeMatrix3d& xform)
{
	assertWriteEnabled();
	
	AecCurveEntity::subTransformBy(xform);

	AcDbCurve* pCurve = GetBaseCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->transformBy(xform);
		if (bRet == Acad::eOk)
		{
			SetBaseCurve(pCurve);
		}

		delete pCurve;
		return bRet;
	}
	else
	{
		return AcDbCurve::subTransformBy(xform);
	}
}

#if ARX> 17

void AecCurveEntity::subGripStatus(const AcDb::GripStat status)
{
	assertReadEnabled();
	AEntityBase::GripStatus(status);
}

Acad::ErrorStatus AecCurveEntity::subGetGripPoints(AcDbGripDataPtrArray&	grips, 
												   const double				curViewUnitSize, 
												   const int				gripSize,
												   const AcGeVector3d&		curViewDir, 
												   const int				bitflags) const
{
	assertReadEnabled();
	return AEntityBase::GetGripPoints(grips,curViewUnitSize,gripSize,curViewDir,bitflags);
}

Acad::ErrorStatus AecCurveEntity::subMoveGripPointsAt(const AcDbVoidPtrArray&	appData,
													  const AcGeVector3d&		offset,
													  const int					bitflags)							
{
	assertWriteEnabled();
	return AEntityBase::MoveGripPointsAt(appData,offset,bitflags);
}

#endif

AcDbObjectId AecCurveEntity::InitLayer(LPCTSTR pszLayer, BOOL bApplyChange )
{
	AcDbObjectId idLay;
	XConfigBase* pBase = GetGlobalConfigBase();

	if (pBase != NULL)
	{
		idLay = pBase->InitLayer(pszLayer,bApplyChange);
	}

	return idLay;
}

void InitCurveEntity(BOOL bTrue)
{
	if (bTrue)
	{
		AecCurveEntity::rxInit();
	}
	else
	{
		deleteAcRxClass(AecCurveEntity::desc());
	}
}