//-----------------------------------------------------------------------------+
// Copyright (C), 1998-2007, Beijing Tangent Software Co. Ltd.
// = FileName	:   TDbCurveEntity.cpp
// = Version	:   ver2.0
// = Author		:   xlc
// = CreateDate	:   2002-09-09
// = Description:   上华曲线对象基类的定义
// = Maintainers: 
//                  
//-----------------------------------------------------------------------------+
#include "StdAfx.h"
#include "TDbCurveEntity.h"
#include "TConfigBase.h"
#include "TchGlobalFunc.h"
#include "TchPrivateGlobalFunc.h"

ACRX_NO_CONS_DEFINE_MEMBERS(ATSCurveEntity, AcDbCurve);
TCH_IMPLEMENT_MEMBERS(TDbCurveEntity, AcDbCurve);
	
TDbCurveEntity::TDbCurveEntity()
{

}

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

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

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

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

    return nRet;
}

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

    return nRet;
}

//AcGeCurve3d 验证[lfy 2011-8-29]
Adesk::Boolean TDbCurveEntity::isOn(AcDbCurve* pCurve,const AcGePoint3d& pnt,const AcGeTol& tol) const
{
	if ( pCurve != NULL)
	{
		AcDbLine* pLine = AcDbLine::cast(pCurve);
		if (pLine != NULL)
		{
			AcGeLine3d line3d(pLine->startPoint(),pLine->endPoint());
			if (line3d.isOn(pnt,tol))
			{
				return Adesk::kTrue;
			}
		}

		AcDbArc* pArc = AcDbArc::cast(pCurve);
		if (pArc != NULL)
		{
			AcGePoint3d ptSta,ptMid,ptEnd;
			pArc->getStartPoint(ptSta);
			pArc->getEndPoint(ptEnd);

			double dSta = 0.0,dEnd = 0.0;
			pArc->getStartParam(dSta);
			pArc->getEndParam(dEnd);
			pArc->getPointAtParam( (dSta + dEnd) / 2.0,ptMid);

			AcGeCircArc3d arc(ptSta,ptMid,ptEnd);
			if (arc.isOn(pnt,tol))
			{
				return Adesk::kTrue;
			}
		}

		//...
	}
	return Adesk::kFalse;
}

Adesk::Boolean TDbCurveEntity::isOn(AcDbCurve* pCurve,double param,const AcGeTol& tol) const
{
	if ( pCurve != NULL)
	{
		AcDbLine* pLine = AcDbLine::cast(pCurve);
		if (pLine != NULL)
		{
			AcGeLine3d line3d(pLine->startPoint(),pLine->endPoint());
			if (line3d.isOn(param,tol))
			{
				return Adesk::kTrue;
			}
		}

		AcDbArc* pArc = AcDbArc::cast(pCurve);
		if (pArc != NULL)
		{
			AcGePoint3d ptSta,ptMid,ptEnd;
			pArc->getStartPoint(ptSta);
			pArc->getEndPoint(ptEnd);

			double dSta = 0.0,dEnd = 0.0;
			pArc->getStartParam(dSta);
			pArc->getEndParam(dEnd);
			pArc->getPointAtParam( (dSta + dEnd) / 2.0,ptMid);

			AcGeCircArc3d arc(ptSta,ptMid,ptEnd);
			if (arc.isOn(param,tol))
			{
				return Adesk::kTrue;
			}
		}
	}
	return Adesk::kFalse;
}

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

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

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

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

Acad::ErrorStatus TDbCurveEntity::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 TDbCurveEntity::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 TDbCurveEntity::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 TDbCurveEntity::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 TDbCurveEntity::getPointAtParam(double pa, AcGePoint3d&pt) const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetBaseCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getPointAtParam(pa,pt);
		//lfy 2011-8-29 再确认验证一次
		if (bRet != Acad::eOk)
		{
			if (isOn(pCurve, pa))
			{
				bRet = Acad::eOk;
			}
		}
		delete pCurve;
		return bRet;
	}
	else
	{
		return AcDbCurve::getPointAtParam(pa,pt);
	}
}

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

	AcDbCurve* pCurve = GetBaseCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getParamAtPoint(pt,pa);
		//lfy 2011-8-29 再确认验证一次
		if (bRet != Acad::eOk)
		{
			if (isOn(pCurve, pa))
			{
				bRet = Acad::eOk;
			}
		}
		delete pCurve;
		return bRet;
	}
	else
	{
		return AcDbCurve::getParamAtPoint(pt,pa);
	}
}

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

	AcDbCurve* pCurve = GetBaseCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getDistAtParam(param,dist);
		//lfy 2011-8-29 再确认验证一次
		if (bRet != Acad::eOk)
		{
			if (isOn(pCurve, param))
			{
				bRet = Acad::eOk;
			}
		}
		delete pCurve;
		return bRet;
	}
	else
	{
		return AcDbCurve::getDistAtParam(param,dist);
	}
}

Acad::ErrorStatus TDbCurveEntity::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 TDbCurveEntity::getDistAtPoint (const AcGePoint3d& pt, double& dist)const
{
	assertReadEnabled();

	AcDbCurve* pCurve = GetBaseCurve();
	if (pCurve != NULL)
	{
		Acad::ErrorStatus bRet = pCurve->getDistAtPoint(pt,dist);
		//lfy 2011-8-29 再确认验证一次
		if (bRet != Acad::eOk)
		{
			if (isOn(pCurve, dist))
			{
				bRet = Acad::eOk;
			}
		}
		delete pCurve;
		return bRet;
	}
	else
	{
		return AcDbCurve::getDistAtPoint(pt,dist);
	}
}

Acad::ErrorStatus TDbCurveEntity::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 TDbCurveEntity::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 TDbCurveEntity::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 TDbCurveEntity::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 TDbCurveEntity::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 TDbCurveEntity::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 TDbCurveEntity::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 TDbCurveEntity::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)
		{
			TDbCurveEntity* pCurveEnt = (TDbCurveEntity*)clone();
			bRet = pCurveEnt->SetBaseCurve(pCurve1);
			projCrv = pCurveEnt;

			delete pCurve1;
		}

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

Acad::ErrorStatus TDbCurveEntity::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)
		{
			TDbCurveEntity* pCurveEnt = (TDbCurveEntity*)clone();
			bRet = pCurveEnt->SetBaseCurve(pCurve1);
			projCrv = pCurveEnt;

			delete pCurve1;
		}

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

Acad::ErrorStatus TDbCurveEntity::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++)
			{
				TDbCurveEntity*pCurveEnt = (TDbCurveEntity*)clone();
				pCurveEnt->SetBaseCurve((AcDbCurve*)offsetCurves0[i]);
				offsetCurves.append(pCurveEnt);
			}

			ReleaseEntSet(offsetCurves0);
		}

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

Acad::ErrorStatus TDbCurveEntity::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++)
			{
				TDbCurveEntity*pCurveEnt = (TDbCurveEntity*)clone();
				pCurveEnt->SetBaseCurve((AcDbCurve*)offsetCurves0[i]);
				offsetCurves.append(pCurveEnt);
			}

			ReleaseEntSet(offsetCurves0);
		}

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

Acad::ErrorStatus TDbCurveEntity::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 TDbCurveEntity::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++)
			{
				TDbCurveEntity*pCurveEnt = (TDbCurveEntity*)clone();
				pCurveEnt->SetBaseCurve((AcDbCurve*)curveSegments0[i]);
				curveSegments.append(pCurveEnt);
			}

			ReleaseEntSet(curveSegments0);
		}

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

Acad::ErrorStatus TDbCurveEntity::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++)
			{
				TDbCurveEntity*pCurveEnt = (TDbCurveEntity*)clone();
				pCurveEnt->SetBaseCurve((AcDbCurve*)curveSegments0[i]);
				curveSegments.append(pCurveEnt);
			}

			ReleaseEntSet(curveSegments0);
		}

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

Acad::ErrorStatus TDbCurveEntity::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 TDbCurveEntity::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 TDbCurveEntity::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 TDbCurveEntity::isPlanar() const
{
	assertReadEnabled();

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

Acad::ErrorStatus   TDbCurveEntity::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 TDbCurveEntity::getEcs(AcGeMatrix3d& retVal) const
{
	assertReadEnabled();

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

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

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

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

			{
				return bRet;
			}
		}
	}

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

Acad::ErrorStatus   TDbCurveEntity::GetOsnapPoints(
                                 AcDb::OsnapMode     osnapMode,
                                 INT_PTR     gsSelectionMark,
                                 const AcGePoint3d&  pickPoint,
                                 const AcGePoint3d&  lastPoint,
                                 const AcGeMatrix3d& viewXform,
                                 AcGePoint3dArray&   snapPoints,
                                 AcDbIntArray&       geomIds,
                                 const AcGeMatrix3d& insertionMat) const
{
#if ADS<16
	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 xlc on 100818 墙体捕捉时允许捕捉墙线和保温线
			if (_tcsicmp(isA()->name(),_T("TDbWall")) != 0)

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

#if (ADS > 15 && ADS < 18)
Acad::ErrorStatus TDbCurveEntity::subGetOsnapPoints(
                                 AcDb::OsnapMode     osnapMode,
                                 int                 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   TDbCurveEntity::subGetOsnapPoints(
                                 AcDb::OsnapMode     osnapMode,
                                 int                 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 TDbCurveEntity::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 TDbCurveEntity::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 TDbCurveEntity::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 TDbCurveEntity::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 TDbCurveEntity::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 TDbCurveEntity::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 TDbCurveEntity::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   TDbCurveEntity::TransformBy(const AcGeMatrix3d& xform)
{
	assertWriteEnabled();
	
	TDbCurveEntity::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 ADS > 15

void TDbCurveEntity::subGripStatus(const AcDb::GripStat status)
{
	assertReadEnabled();
	TEntityBase::GripStatus(status);
}

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

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

#endif

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

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

	return idLay;
}
//t20
TDbXDataMap* TDbCurveEntity::GetSpecialtyData()
{
	if (isWriteEnabled())
	{
		assertWriteEnabled();
	}
	else
	{
		assertReadEnabled();
	}
	return &m_XDataMap;
}

TDbXDataMap* TDbCurveEntity::GetSpecialtyDataReadOnly() const
{
	assertReadEnabled();
	return (TDbXDataMap*)&m_XDataMap;
}

BOOL TDbCurveEntity::SetAt(LPCTSTR pszKey,TXData& XData)
{
	assertWriteEnabled();
	TDbXDataMap* pXMap = GetSpecialtyData();
	if (pXMap != NULL)
	{
		pXMap->SetAt(pszKey,XData);
		return TRUE;
	}
	return FALSE;
}

BOOL TDbCurveEntity::GetAt(LPCTSTR pszKey,TXData& XData) const
{
	assertReadEnabled();

	TDbXDataMap* pXMap = GetSpecialtyDataReadOnly();
	if (pXMap != NULL)
	{
		return pXMap->GetAt(pszKey,XData);
	}
	return FALSE;
}