1031 lines
22 KiB
C++
1031 lines
22 KiB
C++
//-----------------------------------------------------------------------------+
|
|
// 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());
|
|
}
|
|
} |