1461 lines
42 KiB
C++
1461 lines
42 KiB
C++
#include "stdafx.h"
|
|
#include "dbmatch.h"
|
|
#include "AecDbEntityBaseEx.h"
|
|
#include "globalFunc.h"
|
|
#include "AecDbMText.h"
|
|
#include "AcGiExplodeDraw.h"
|
|
#include "AcGiViewDraw.h"
|
|
#include "PushMemVar.h"
|
|
#include "GeCurveInline.h"
|
|
#include "aecdbdimension.h"
|
|
#include "AcDbObjectPtr.h"
|
|
#include "DimOptionData.h"
|
|
|
|
namespace
|
|
{
|
|
AcDbArc* geArc2DbArc(const AcGeCircArc3d &geArc)
|
|
{
|
|
AcGePlane plane = AcGePlane(geArc.center(), geArc.normal());
|
|
double ang = geArc.refVec().angleOnPlane(plane);
|
|
return new AcDbArc(geArc.center()
|
|
, geArc.normal()
|
|
, geArc.radius()
|
|
, geArc.startAng() + ang
|
|
, geArc.endAng() + ang);
|
|
}
|
|
|
|
void drawAcDbEntity(AcGiDraw &dc, AcDbEntity *pEnt, int clr, bool bSetDcLayer = true)
|
|
{
|
|
pEnt->setColorIndex(clr);
|
|
if (bSetDcLayer)
|
|
pEnt->setLayer(dc.GetLayerId());
|
|
int oldClr = dc.GetColor();
|
|
dc.SetColor(clr);
|
|
dc.DrawEntity(*pEnt);
|
|
dc.SetColor(oldClr);
|
|
}
|
|
|
|
void GetTrueTextExtent(const AcDbEntity*pEnt, GePoly2D &polyExt)
|
|
{
|
|
AcDbEntity *pText = AcDbEntity::cast(pEnt->clone());
|
|
|
|
AcDbExtents ext;
|
|
ADSGePoint3d ptLoc;
|
|
double rot = 0;
|
|
|
|
if (_tcsicmp(pText->isA()->name(), _T("AecXDbText")) == 0
|
|
|| _tcsicmp(pText->isA()->name(), _T("TDbMText")) == 0)
|
|
{
|
|
AecXDbEntityBaseEx *pText1 = AecXDbEntityBaseEx::cast(pText);
|
|
|
|
rot = pText1->TBaseGetRotation() + pText1->GetLayoutRotation();
|
|
pText1->TBaseSetRotation(0);
|
|
pText1->SetLayoutRotation(0);
|
|
ptLoc = pText1->TBaseGetLocation();
|
|
}
|
|
|
|
else if (pText->isKindOf(AcDbText::desc()))
|
|
{
|
|
AcDbText*pText1 = AcDbText::cast(pText);
|
|
rot = pText1->rotation();
|
|
pText1->setRotation(0);
|
|
ptLoc = pText1->position();
|
|
}
|
|
else
|
|
{
|
|
AcDbMText*pText1 = AcDbMText::cast(pText);
|
|
rot = pText1->rotation();
|
|
pText1->setRotation(0);
|
|
ptLoc = pText1->location();
|
|
}
|
|
pText->getGeomExtents(ext);
|
|
delete pText;
|
|
|
|
ADSGePoint3d pt1 = ext.minPoint(), pt3 = ext.maxPoint();
|
|
ADSGePoint3d pt2(pt3.x, pt1.y), pt4(pt1.x, pt3.y);
|
|
polyExt.AppendNode(pt1);
|
|
polyExt.AppendNode(pt2);
|
|
polyExt.AppendNode(pt3);
|
|
polyExt.AppendNode(pt4);
|
|
ads_matrix mat;
|
|
ptLoc.GetRotationMatrix(rot, mat);
|
|
polyExt.TransUCS(mat);
|
|
}
|
|
|
|
void drawProxyEntity(const AcDbVoidPtrArray *pAr, AcGiWorldDraw *pWd)
|
|
{
|
|
if (!pAr) return;
|
|
Adesk::UInt16 clr = pWd->subEntityTraits().color();
|
|
AcDbObjectId layerID = pWd->subEntityTraits().layerId();
|
|
for (int i = 0; i < pAr->length(); ++i)
|
|
{
|
|
AcDbEntity *pEnt((AcDbEntity*)pAr->at(i));
|
|
if (pEnt->isKindOf(AcDbBlockReference::desc()))
|
|
{
|
|
AcDbBlockReference *pRef((AcDbBlockReference*)pEnt);
|
|
AcDbBlockTableRecord *pRec(NULL);
|
|
AcDbObject *pObj(NULL);
|
|
AcDbEntity *pSubEnt(NULL);
|
|
if (acdbOpenAcDbObject(pObj, pRef->blockTableRecord(), AcDb::kForRead) == Acad::eOk)
|
|
{
|
|
pRec = (AcDbBlockTableRecord*)pObj;
|
|
AcDbBlockTableRecordIterator* pBlockIterator;
|
|
pRec->newIterator(pBlockIterator, Adesk::kTrue, Adesk::kFalse);
|
|
for (pBlockIterator->start(); !pBlockIterator->done(); pBlockIterator->step())
|
|
{
|
|
pBlockIterator->getEntity(pSubEnt, AcDb::kForWrite, Adesk::kTrue);
|
|
pSubEnt->setColorIndex(pEnt->colorIndex());
|
|
pSubEnt->setLayer(pEnt->layerId());
|
|
pSubEnt->close();
|
|
}
|
|
pObj->close();
|
|
delete pBlockIterator;
|
|
}
|
|
}
|
|
pWd->subEntityTraits().setColor(pEnt->colorIndex());
|
|
pWd->subEntityTraits().setLayer(pEnt->layerId());
|
|
if (pEnt)
|
|
pEnt->worldDraw(pWd);
|
|
}
|
|
pWd->subEntityTraits().setColor(clr);
|
|
pWd->subEntityTraits().setLayer(layerID);
|
|
}
|
|
}
|
|
|
|
#pragma region BaseEx
|
|
const Adesk::UInt8 BaseEx::g_nVersion = 1;
|
|
BaseEx::BaseEx()
|
|
{
|
|
m_nLayoutRotation = 0.0;
|
|
m_nPaperScale = GlobalFunc::DocGetPScale();
|
|
m_bInJig = FALSE;
|
|
}
|
|
|
|
Acad::ErrorStatus BaseEx::dwgInFields(AcDbDwgFiler *pFiler)
|
|
{
|
|
Adesk::UInt8 nVer;
|
|
pFiler->readItem(&nVer);
|
|
if (nVer > g_nVersion)
|
|
return Acad::eMakeMeProxy;
|
|
|
|
pFiler->readItem(&m_nPaperScale);
|
|
pFiler->readItem(&m_nLayoutRotation);
|
|
|
|
m_allFields.DwgIn(pFiler);
|
|
|
|
m_XDataMap.dwgInFields(pFiler);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus BaseEx::dwgOutFields(AcDbDwgFiler *pFiler) const
|
|
{
|
|
pFiler->writeItem(g_nVersion);
|
|
pFiler->writeItem(m_nPaperScale);
|
|
pFiler->writeItem(m_nLayoutRotation);
|
|
m_allFields.DwgOut(pFiler);
|
|
m_XDataMap.dwgOutFields(pFiler);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus BaseEx::dxfInFields(AcDbDxfFiler *) { return Acad::ErrorStatus(); }
|
|
|
|
Acad::ErrorStatus BaseEx::dxfOutFields(AcDbDxfFiler *) const { return Acad::ErrorStatus(); }
|
|
|
|
AecObjectEditMethod BaseEx::GetEditMethod() const
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
int BaseEx::GetCtrlToggleIndex() const { return -1; }
|
|
|
|
BOOL & BaseEx::GetCtrlToggle() const
|
|
{
|
|
int id = GetCtrlToggleIndex();
|
|
if (id < 0 || id >= 100)
|
|
{
|
|
return g_Option::instance().g_bCtrlToggle;
|
|
}
|
|
|
|
return g_Option::instance().g_bCtrlToggle1[id];
|
|
}
|
|
|
|
void BaseEx::copyBy(const BaseEx & frm)
|
|
{
|
|
if (frm.m_allFields.GetSubFieldNum())
|
|
this->m_allFields = frm.m_allFields;
|
|
this->m_nLayoutRotation = frm.m_nLayoutRotation;
|
|
this->m_nPaperScale = frm.m_nPaperScale;
|
|
this->m_XDataMap.CopyFrom(&frm.m_XDataMap);
|
|
}
|
|
|
|
void BaseEx::CopyPropertiesFrom(AcDbEntity * pSrcEntity, unsigned gMatchFlag)
|
|
{
|
|
AcDbEntity *pTrgEntity = dynamic_cast<AcDbEntity*>(this);
|
|
if (!pTrgEntity)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// 颜色
|
|
if (gMatchFlag & AcDbMatchProperties::kColorFlag)
|
|
{
|
|
pTrgEntity->setColorIndex(pSrcEntity->colorIndex());
|
|
}
|
|
|
|
//图层
|
|
if (pTrgEntity->database() == NULL
|
|
|| pSrcEntity->database() == NULL
|
|
|| pTrgEntity->database() == pSrcEntity->database()) //add by W on 060317
|
|
{
|
|
if (gMatchFlag & AcDbMatchProperties::kLayerFlag)
|
|
{
|
|
pTrgEntity->setLayer(pSrcEntity->layerId());
|
|
}
|
|
|
|
// 线型
|
|
if (gMatchFlag & AcDbMatchProperties::kLtypeFlag)
|
|
{
|
|
pTrgEntity->setLinetype(pSrcEntity->linetypeId());
|
|
}
|
|
|
|
#if ADS > 16
|
|
// 材质
|
|
if (gMatchFlag & AcDbMatchProperties::kMaterialFlag)
|
|
{
|
|
pTrgEntity->setMaterial(pSrcEntity->materialId());
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// 线型比例
|
|
if (gMatchFlag & AcDbMatchProperties::kLtscaleFlag)
|
|
{
|
|
pTrgEntity->setLinetypeScale(pSrcEntity->linetypeScale());
|
|
}
|
|
|
|
// 可见性. 总是被复制
|
|
pTrgEntity->setVisibility(pSrcEntity->visibility());
|
|
|
|
const AecXDbEntityBaseEx *pSrc1 = AecXDbEntityBaseEx::cast(pSrcEntity);
|
|
const AecXDbCurveBaseEx *pSrc2 = AecXDbCurveBaseEx::cast(pSrcEntity);
|
|
const BaseEx *pBaseSrc(NULL);
|
|
if (pSrc1)
|
|
{
|
|
m_nPaperScale = pSrc1->m_nPaperScale;
|
|
m_nLayoutRotation = pSrc1->m_nLayoutRotation;
|
|
pBaseSrc = (BaseEx*)pSrc1;
|
|
}
|
|
else if (pSrc2)
|
|
{
|
|
m_nPaperScale = pSrc2->m_nPaperScale;
|
|
m_nLayoutRotation = pSrc2->m_nLayoutRotation;
|
|
pBaseSrc = (BaseEx*)pSrc2;
|
|
}
|
|
//wlw add 131224 xdata的复制
|
|
if (pBaseSrc && pSrcEntity->desc() == pTrgEntity->desc())
|
|
{
|
|
m_XDataMap = pBaseSrc->m_XDataMap;
|
|
}
|
|
}
|
|
|
|
AecDbObjXDataMap * BaseEx::__GetSpecialtyData()
|
|
{
|
|
AcDbEntity *pThis = dynamic_cast<AcDbEntity*>(this);
|
|
if (pThis->isWriteEnabled())
|
|
{
|
|
pThis->assertWriteEnabled();
|
|
}
|
|
else
|
|
{
|
|
pThis->assertReadEnabled();
|
|
}
|
|
return &m_XDataMap;
|
|
}
|
|
|
|
AecDbObjXDataMap * BaseEx::__GetSpecialtyDataReadOnly() const
|
|
{
|
|
const AcDbEntity *pThis = dynamic_cast<const AcDbEntity*>(this);
|
|
pThis->assertReadEnabled();
|
|
return (AecDbObjXDataMap*)&m_XDataMap;
|
|
}
|
|
|
|
void BaseEx::TBaseSetRotation(double nRot) { }
|
|
|
|
double BaseEx::TBaseGetRotation() const { return 0.0; }
|
|
|
|
ADSGePoint3d BaseEx::TBaseGetLocation() const { return ADSGePoint3d(); }
|
|
|
|
int BaseEx::ConvertText(TConvertTextPtr ptr, void * pData) { return RTNONE; }
|
|
|
|
void BaseEx::TBaseSetLocation(ADSGePoint3d pt) { }
|
|
|
|
TextPosition BaseEx::FindSubText(const TCHAR * sSubText, TextPosition & posStart, TextRange * pRange) const { return TextPosition(); }
|
|
|
|
TextPosition BaseEx::ReplaceSubText(const TextPosition & posRep, const TCHAR * sRepText, TextRange * pRange) { return TextPosition(); }
|
|
|
|
double BaseEx::Wcs2Layout(double nAngWcs) const
|
|
{
|
|
return GlobalFunc::AngleRangeTo2PI(nAngWcs - m_nLayoutRotation);
|
|
}
|
|
|
|
double BaseEx::Layout2Wcs(double nAngLay) const
|
|
{
|
|
return GlobalFunc::AngleRangeTo2PI(nAngLay + m_nLayoutRotation);
|
|
}
|
|
|
|
double BaseEx::GetPScale() const
|
|
{
|
|
return m_nPaperScale;
|
|
}
|
|
|
|
Acad::ErrorStatus BaseEx::GetExtents2d(ADSGePoint3d & ptLow, ADSGePoint3d & ptUp) const
|
|
{
|
|
//AcGiViewDraw dc;
|
|
//this->_Draw2d(dc);
|
|
const AcDbVoidPtrArray *pAr = this->_Get2DBuffer();
|
|
if (!pAr) return Acad::eNullHandle;
|
|
|
|
const AcDbVoidPtrArray &ar(*pAr);
|
|
AcDbExtents ext, extall;
|
|
for (int i = 0; i < ar.length(); ++i)
|
|
{
|
|
AcDbEntity *p((AcDbEntity*)((AcDbEntity*)ar[i])->clone());
|
|
if (!p) continue;
|
|
p->getGeomExtents(ext);
|
|
extall.addExt(ext);
|
|
DELETE_PTR(p);
|
|
}
|
|
|
|
ptLow = extall.minPoint();
|
|
ptUp = extall.maxPoint();
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus BaseEx::GetExtents(ADSGePoint3d & ptLow, ADSGePoint3d & ptUp) const
|
|
{
|
|
return GetExtents2d(ptLow, ptUp);
|
|
}
|
|
|
|
double BaseEx::NormalViewAngle(double nAngWcs) const
|
|
{
|
|
double nAng1 = GlobalFunc::ChangeAngleTo1_4(Wcs2Layout(nAngWcs));
|
|
nAng1 = GlobalFunc::AngleRangeTo2PI(m_nLayoutRotation + nAng1);
|
|
return nAng1;
|
|
}
|
|
|
|
long BaseEx::GetSubTextNum() const
|
|
{
|
|
PushMemVar<BOOL> vTemp(g_Option::instance().g_bExplodeSubText, TRUE);
|
|
//AcGiViewDraw dc;
|
|
//_Draw2d(dc);
|
|
const AcDbVoidPtrArray *pAr = _Get2DBuffer();
|
|
if (!pAr) return Acad::eNullHandle;
|
|
|
|
const AcDbVoidPtrArray &allEnt(*pAr);
|
|
|
|
long count = 0;
|
|
for (long i = 0; i < allEnt.length(); i++)
|
|
{
|
|
AcDbEntity* pEnt = (AcDbEntity*)((AcDbEntity*)allEnt[i])->clone();
|
|
if (!pEnt) continue;
|
|
if (pEnt->isKindOf(AcDbText::desc())
|
|
|| pEnt->isKindOf(AcDbMText::desc())
|
|
|| (_tcsicmp(pEnt->isA()->name(), _T("AecXDbText")) == 0)
|
|
|| (_tcsicmp(pEnt->isA()->name(), _T("AecXDbMText")) == 0)
|
|
)
|
|
{
|
|
count++;
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
long BaseEx::GetNextSubTextIndex(long i, bool bVert, bool bPre) const
|
|
{
|
|
long num = GetSubTextNum();
|
|
if (bPre)
|
|
{
|
|
return i = (i - 1 + num) % num;
|
|
}
|
|
else
|
|
{
|
|
return i = (i + 1) % num;
|
|
}
|
|
}
|
|
|
|
SubText * BaseEx::HitTestText(ADSGePoint3d pt) const
|
|
{
|
|
PushMemVar<BOOL> vTemp(g_Option::instance().g_bExplodeSubText, TRUE);
|
|
|
|
SubText* pSubText = NULL;
|
|
|
|
const AcDbEntity *pThis = dynamic_cast<const AcDbEntity*>(this);
|
|
|
|
//AcGiViewDraw dc;
|
|
//dc.SetPropertiesFrom(pThis); //add by W on 060404
|
|
//_Draw2d(dc);
|
|
|
|
const AcDbVoidPtrArray *pAr = _Get2DBuffer();
|
|
if (!pAr) return NULL;
|
|
|
|
const AcDbVoidPtrArray &allEnt(*pAr);
|
|
|
|
long count = 0;
|
|
for (long i = 0; i < allEnt.length(); i++)
|
|
{
|
|
AcDbEntity* pEnt = (AcDbEntity*)((AcDbEntity*)allEnt[i])->clone();
|
|
if (!pEnt) continue;
|
|
if (pEnt->isKindOf(AcDbText::desc())
|
|
|| pEnt->isKindOf(AcDbMText::desc())
|
|
|| _tcsicmp(pEnt->isA()->name(), _T("AecXDbText")) == 0
|
|
|| _tcsicmp(pEnt->isA()->name(), _T("AecXDbMText")) == 0
|
|
)
|
|
{
|
|
AcDbExtents ext;
|
|
pEnt->getGeomExtents(ext);
|
|
|
|
ADSGePoint3d ptMin = ext.minPoint();
|
|
ADSGePoint3d ptMax = ext.maxPoint();
|
|
if (pt.x >= ptMin.x
|
|
&& pt.x <= ptMax.x
|
|
&& pt.y >= ptMin.y
|
|
&& pt.y <= ptMax.y)
|
|
{
|
|
//allEnt[i] = NULL;
|
|
|
|
GePoly2D polyExt;
|
|
GetTrueTextExtent(pEnt, polyExt);
|
|
polyExt.SetElevation(0);
|
|
|
|
pt.z = 0;
|
|
if ((pt & polyExt) != PR_OUTSIDE)
|
|
{
|
|
pSubText = new SubText(pThis->objectId(), pEnt, count);
|
|
break;
|
|
}
|
|
}
|
|
|
|
count++;
|
|
}
|
|
DELETE_PTR(pEnt);
|
|
}
|
|
|
|
//ReleaseEntSet(allEnt);
|
|
|
|
return pSubText;
|
|
}
|
|
|
|
SubText* BaseEx::GetSubText(long iText)const
|
|
{
|
|
PushMemVar<BOOL> vTemp(g_Option::instance().g_bExplodeSubText, TRUE);
|
|
|
|
SubText* pSubText = NULL;
|
|
|
|
const AcDbEntity *pThis = dynamic_cast<const AcDbEntity*>(this);
|
|
|
|
//AcGiViewDraw dc;
|
|
//dc.SetPropertiesFrom(pThis); //add by W on 060404
|
|
//_Draw2d(dc);
|
|
|
|
const AcDbVoidPtrArray *pAr = _Get2DBuffer();
|
|
if (!pAr) return NULL;
|
|
|
|
const AcDbVoidPtrArray &allEnt(*pAr);
|
|
|
|
long count = 0;
|
|
for (long i = 0; i < allEnt.length(); i++)
|
|
{
|
|
AcDbEntity* pEnt = (AcDbEntity*)((AcDbEntity*)allEnt[i])->clone();
|
|
if (!pEnt) continue;
|
|
if (pEnt->isKindOf(AcDbText::desc())
|
|
|| pEnt->isKindOf(AcDbMText::desc())
|
|
|| (_tcsicmp(pEnt->isA()->name(), _T("AecXDbText")) == 0)
|
|
|| (_tcsicmp(pEnt->isA()->name(), _T("AecXDbMText")) == 0)
|
|
)
|
|
{
|
|
if (count == iText)
|
|
{
|
|
//allEnt[i] = NULL;
|
|
pSubText = new SubText(pThis->objectId(), pEnt, iText);
|
|
break;
|
|
}
|
|
count++;
|
|
}
|
|
DELETE_PTR(pEnt);
|
|
}
|
|
|
|
//ReleaseEntSet(allEnt);
|
|
|
|
return pSubText;
|
|
}
|
|
|
|
void BaseEx::SetSubText(long i, CString sText) { }
|
|
|
|
void BaseEx::ResetTextPos() { }
|
|
|
|
void BaseEx::SetPScale(double scale)
|
|
{
|
|
AcDbEntity *pThis = dynamic_cast<AcDbEntity*>(this);
|
|
if (pThis) pThis->assertWriteEnabled();
|
|
|
|
m_nPaperScale = scale;
|
|
}
|
|
|
|
double BaseEx::GetLayoutRotation() const { return m_nLayoutRotation; }
|
|
|
|
void BaseEx::SetLayoutRotation(double nRot)
|
|
{
|
|
AcDbEntity *pThis = dynamic_cast<AcDbEntity*>(this);
|
|
if (pThis) pThis->assertWriteEnabled();
|
|
|
|
m_nLayoutRotation = GlobalFunc::AngleRangeTo2PI(nRot);
|
|
}
|
|
|
|
BOOL BaseEx::IsLayoutRotated() const
|
|
{
|
|
return (fabs(m_nLayoutRotation) > g_DimOption::instance()._angSnap);
|
|
}
|
|
|
|
Acad::ErrorStatus BaseEx::_Draw2d(AcGiDraw & dc) const
|
|
{
|
|
const AcDbEntity *pThis = dynamic_cast<const AcDbEntity*>(this);
|
|
AecXDbEntityBaseEx *pEnt = AecXDbEntityBaseEx::cast(pThis);
|
|
AecXDbCurveBaseEx *pCurve = AecXDbCurveBaseEx::cast(pThis);
|
|
|
|
if (pEnt)
|
|
return pEnt->__Draw2d(dc);
|
|
|
|
if (pCurve)
|
|
return pCurve->__Draw2d(dc);
|
|
|
|
return Acad::eInvalidInput;
|
|
}
|
|
|
|
const AcDbVoidPtrArray* BaseEx::_Get2DBuffer() const
|
|
{
|
|
const AcDbEntity *pThis = dynamic_cast<const AcDbEntity*>(this);
|
|
AecXDbEntityBaseEx *pEnt = AecXDbEntityBaseEx::cast(pThis);
|
|
AecXDbCurveBaseEx *pCurve = AecXDbCurveBaseEx::cast(pThis);
|
|
|
|
if (pEnt)
|
|
return &pEnt->__Get2DBuffer();
|
|
|
|
if (pCurve)
|
|
return &pCurve->__Get2DBuffer();
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void BaseEx::_Add2DBuffer(AcDbEntity * p) const
|
|
{
|
|
if (m_bInJig)
|
|
{
|
|
DELETE_PTR(p);
|
|
return;
|
|
}
|
|
const AcDbEntity *pThis = dynamic_cast<const AcDbEntity*>(this);
|
|
AecXDbEntityBaseEx *pEnt = AecXDbEntityBaseEx::cast(pThis);
|
|
AecXDbCurveBaseEx *pCurve = AecXDbCurveBaseEx::cast(pThis);
|
|
|
|
if (pEnt)
|
|
pEnt->__Add2DBuffer(p);
|
|
|
|
if (pCurve)
|
|
pCurve->__Add2DBuffer(p);
|
|
|
|
}
|
|
|
|
void BaseEx::DrawBlock(AcGiDraw &dc
|
|
, const AcDbObjectId &blkId
|
|
, const AcGePoint3d &ptInsert
|
|
, const AcGeScale3d &scales
|
|
, double nRot
|
|
, int color) const
|
|
{
|
|
AcDbBlockReference *pInsert = new AcDbBlockReference(ptInsert, blkId);
|
|
pInsert->setScaleFactors(scales);
|
|
pInsert->setRotation(nRot);
|
|
pInsert->setColorIndex(color);
|
|
|
|
drawAcDbEntity(dc, pInsert, color);
|
|
_Add2DBuffer(pInsert);
|
|
}
|
|
|
|
void BaseEx::DrawLine(AcGiDraw &dc, const AcGePoint3d &pt1, const AcGePoint3d & pt2, int color) const
|
|
{
|
|
AcDbLine *pLine = new AcDbLine(pt1, pt2);
|
|
drawAcDbEntity(dc, pLine, color);
|
|
_Add2DBuffer(pLine);
|
|
}
|
|
|
|
void BaseEx::DrawLine(AcGiDraw & dc, const GeLine & ln, int color) const
|
|
{
|
|
DrawLine(dc, ln.GetStartPoint(), ln.GetEndPoint(), color);
|
|
}
|
|
|
|
void BaseEx::DrawPoly2D(AcGiDraw &dc, const GePoly2D &poly, int color) const
|
|
{
|
|
AcDbCurve *pCurve = poly.AsAcDbCurve();
|
|
if (pCurve)
|
|
{
|
|
drawAcDbEntity(dc, pCurve, color);
|
|
_Add2DBuffer(pCurve);
|
|
}
|
|
}
|
|
|
|
void BaseEx::DrawPline(AcGiDraw &dc, const AcDbPolyline &pline, int color) const
|
|
{
|
|
AcDbPolyline *p = (AcDbPolyline*)pline.clone();
|
|
if (p)
|
|
{
|
|
drawAcDbEntity(dc, p, color);
|
|
_Add2DBuffer(p);
|
|
}
|
|
}
|
|
|
|
void BaseEx::DrawArc(AcGiDraw &dc, const AcGePoint3d &ptS, const AcGePoint3d &ptM, const AcGePoint3d &ptE, int color) const
|
|
{
|
|
AcDbArc *pArc = geArc2DbArc(AcGeCircArc3d(ptS, ptM, ptE));
|
|
drawAcDbEntity(dc, pArc, color);
|
|
_Add2DBuffer(pArc);
|
|
}
|
|
|
|
void BaseEx::DrawArc(AcGiDraw &dc, const GeArc &arc, int color) const
|
|
{
|
|
ADSGePoint3d ptS, ptM, ptE;
|
|
arc.GetStartPoint(ptS);
|
|
arc.MidPoint(ptM);
|
|
arc.GetEndPoint(ptE);
|
|
DrawArc(dc, ptS, ptM, ptE);
|
|
}
|
|
|
|
void BaseEx::DrawSegment(AcGiDraw &dc, const GeCurveSegment &seg, int color)const
|
|
{
|
|
AcDbCurve *pCurve = seg.AsAcDbCurve();
|
|
if (pCurve)
|
|
{
|
|
drawAcDbEntity(dc, pCurve, color);
|
|
_Add2DBuffer(pCurve);
|
|
}
|
|
}
|
|
|
|
void BaseEx::DrawCircle(AcGiDraw &dc, const GeCircle &cir, int color) const
|
|
{
|
|
AcDbCircle *pCir = new AcDbCircle(cir.GetCenterPt(), AcGeVector3d::kZAxis, cir.GetRadius());
|
|
drawAcDbEntity(dc, pCir, color);
|
|
_Add2DBuffer(pCir);
|
|
}
|
|
|
|
void BaseEx::DrawTextFit(AcGiDraw &dc
|
|
, const TCHAR *pszText
|
|
, const AcGePoint3d &pt1
|
|
, const AcGePoint3d &pt2
|
|
, double nTextHeight
|
|
, AcDbObjectId styleId
|
|
, int color) const
|
|
{
|
|
AcDbText tx;
|
|
tx.setTextString(pszText);
|
|
tx.setColorIndex(color);
|
|
#if ARX > 18
|
|
tx.setJustification(AcDbText::kTextAlignmentFit);
|
|
#endif
|
|
|
|
double XScale(1.);
|
|
{
|
|
AcGiTextStyle textStyle;
|
|
fromAcDbTextStyle(textStyle, styleId);
|
|
XScale = textStyle.xScale();
|
|
textStyle.setTextSize(nTextHeight);
|
|
Adesk::Boolean bIncludeSpace = Adesk::kTrue;
|
|
TCHAR *pTypeface = NULL;
|
|
#if ARX < 21
|
|
Adesk::Boolean bBold, bItalic;
|
|
int tmp0, tmp1;
|
|
BOOL bWinFont = (textStyle.font(pTypeface, bBold, bItalic, tmp0, tmp1) == Acad::eOk);
|
|
if (bWinFont)
|
|
#else
|
|
bool bold, italic;
|
|
Autodesk::AutoCAD::PAL::FontUtils::FontPitch pitch;
|
|
Autodesk::AutoCAD::PAL::FontUtils::FontFamily family;
|
|
Charset charset;
|
|
BOOL bWinFont = (textStyle.font(pTypeface, bold, italic, charset, pitch, family) == Acad::eOk);
|
|
if (bWinFont)
|
|
#endif
|
|
{
|
|
if (!pTypeface || !pTypeface[0])
|
|
{
|
|
bWinFont = FALSE;
|
|
}
|
|
}
|
|
|
|
if (pTypeface)
|
|
{
|
|
delete[] pTypeface;
|
|
}
|
|
|
|
if (bWinFont)
|
|
{
|
|
bIncludeSpace = Adesk::kTrue;
|
|
}
|
|
else
|
|
{
|
|
bIncludeSpace = Adesk::kFalse;
|
|
const TCHAR *pShxFile = textStyle.fileName();
|
|
|
|
if (pShxFile)
|
|
{
|
|
CString s(pShxFile);
|
|
s.MakeUpper();
|
|
TCHAR sFilter[] = _T("GBE*,GOTH*,ISO*,SCRIPT*,ROMAN*");
|
|
|
|
if (ads_wcmatch(s, sFilter) == RTNORM)
|
|
{
|
|
bIncludeSpace = Adesk::kTrue;
|
|
}
|
|
}
|
|
}
|
|
AcGePoint2d ptExt = textStyle.extents(pszText, bIncludeSpace, -1, Adesk::kFalse);
|
|
double nWidth = ptExt[0];
|
|
double nHeight = ptExt[1];
|
|
XScale *= pt1.distanceTo(pt2) / nWidth;
|
|
}
|
|
|
|
tx.setWidthFactor(XScale);
|
|
tx.setHeight(nTextHeight);
|
|
tx.setRotation(Layout2Wcs(0.));
|
|
tx.setAlignmentPoint(pt2);
|
|
tx.setPosition(pt1);
|
|
tx.setTextStyle(styleId);
|
|
|
|
drawAcDbEntity(dc, &tx, color);
|
|
|
|
_Add2DBuffer((AcDbEntity*)tx.clone());
|
|
}
|
|
|
|
/*void BaseEx::DrawBaseEx(AcGiDraw & dc, const BaseEx & ent) const
|
|
{
|
|
const AcDbEntity *pEnt = dynamic_cast<const AcDbEntity*>(&ent);
|
|
if (!pEnt) return;
|
|
|
|
int colorText(257);
|
|
bool bAecDBText(false);
|
|
AecXDbText *pTxt(AecXDbText::cast(pEnt));
|
|
if (pTxt)
|
|
{
|
|
colorText = pTxt->colorIndex();
|
|
bAecDBText = true;
|
|
}
|
|
|
|
//AcDbEntity *pNew = (AcDbEntity*)pEnt->clone();
|
|
|
|
//BaseEx *pBaseNew = dynamic_cast<BaseEx*>(pNew);
|
|
//if (!pBaseNew) return;
|
|
|
|
AcGiViewDraw _dc;
|
|
//pBaseNew->_Draw2d(_dc);
|
|
ent._Draw2d(_dc);
|
|
//const AcDbVoidPtrArray &ar = pBaseNew->_Get2DBuffer();
|
|
const AcDbVoidPtrArray &ar = ent._Get2DBuffer();
|
|
|
|
for (int i = 0; i < ar.length(); ++i)
|
|
{
|
|
AcDbEntity *p((AcDbEntity*)((AcDbEntity*)ar[i])->clone());
|
|
|
|
AcDbText *pAcTxt(AcDbText::cast(p));
|
|
if (pAcTxt && bAecDBText)
|
|
pAcTxt->setColorIndex(colorText);
|
|
|
|
p->setLayer(pEnt->layerId());
|
|
drawAcDbEntity(dc, p, p->colorIndex(), false);
|
|
_Add2DBuffer(p);
|
|
}
|
|
|
|
//DELETE_PTR(pNew);
|
|
}*/
|
|
|
|
void BaseEx::DrawBaseEx(AcGiDraw & dc, const BaseEx & ent) const
|
|
{
|
|
const AcDbEntity *pEnt = dynamic_cast<const AcDbEntity*>(&ent);
|
|
if (!pEnt) return;
|
|
|
|
const AecXDbEntityBaseEx *pEntEx = AecXDbEntityBaseEx::cast(pEnt);
|
|
const AecXDbCurveBaseEx *pCrvEx = AecXDbCurveBaseEx::cast(pEnt);
|
|
const AcDbVoidPtrArray *pAr(NULL);
|
|
AcGiViewDraw _dc;
|
|
AecXDbEntityBaseEx *pNewEntEx(NULL);
|
|
AecXDbCurveBaseEx *pNewCrvEx(NULL);
|
|
if (pEntEx)
|
|
{
|
|
pNewEntEx = (AecXDbEntityBaseEx*)pEntEx->clone();
|
|
pNewEntEx->_Draw2d(_dc);
|
|
pAr = &pNewEntEx->Get2DBuffer();
|
|
}
|
|
else if (pCrvEx)
|
|
{
|
|
pNewCrvEx = (AecXDbCurveBaseEx*)pCrvEx->clone();
|
|
pNewCrvEx->_Draw2d(_dc);
|
|
pAr = &pNewCrvEx->Get2DBuffer();
|
|
}
|
|
|
|
int colorText(257);
|
|
bool bAecDBText(false);
|
|
AecXDbText *pTxt(AecXDbText::cast(pEnt));
|
|
if (pTxt)
|
|
{
|
|
colorText = pTxt->colorIndex();
|
|
bAecDBText = true;
|
|
}
|
|
|
|
//ent._Draw2d(_dc);
|
|
//const AcDbVoidPtrArray &ar = ent._Get2DBuffer();
|
|
|
|
for (int i = 0; i < pAr->length(); ++i)
|
|
{
|
|
AcDbEntity *p((AcDbEntity*)((AcDbEntity*)pAr->at(i))->clone());
|
|
|
|
AcDbText *pAcTxt(AcDbText::cast(p));
|
|
if (pAcTxt && bAecDBText)
|
|
pAcTxt->setColorIndex(colorText);
|
|
|
|
p->setLayer(pEnt->layerId());
|
|
drawAcDbEntity(dc, p, p->colorIndex(), false);
|
|
_Add2DBuffer(p);
|
|
}
|
|
|
|
if (pNewCrvEx)
|
|
delete pNewCrvEx;
|
|
if (pNewEntEx)
|
|
delete pNewEntEx;
|
|
}
|
|
|
|
void BaseEx::_Draw2DBuffers(AcGiDraw &dc, bool bUseEntClr) const
|
|
{
|
|
const AcDbEntity *pThis = dynamic_cast<const AcDbEntity*>(this);
|
|
AecXDbEntityBaseEx *pEnt = AecXDbEntityBaseEx::cast(pThis);
|
|
AecXDbCurveBaseEx *pCurve = AecXDbCurveBaseEx::cast(pThis);
|
|
|
|
const AcDbVoidPtrArray *pAr(NULL);
|
|
if (pEnt) pAr = _Get2DBuffer();
|
|
if (pCurve) pAr = _Get2DBuffer();
|
|
|
|
if (pAr)
|
|
{
|
|
Adesk::UInt16 oldClr = dc.GetColor();
|
|
Adesk::UInt16 newClr;
|
|
for (int i = 0; i < pAr->length(); ++i)
|
|
{
|
|
const AcDbEntity *pEnt = (AcDbEntity*)pAr->at(i);
|
|
newClr = pEnt->colorIndex();
|
|
if (bUseEntClr)
|
|
dc.SetColor(newClr);
|
|
dc.DrawEntity(*pEnt);
|
|
dc.SetColor(oldClr);
|
|
}
|
|
}
|
|
}
|
|
|
|
const EntityFields & BaseEx::GetFields() const
|
|
{
|
|
return m_allFields;
|
|
}
|
|
|
|
EntityFields & BaseEx::Fields()
|
|
{
|
|
return m_allFields;
|
|
}
|
|
|
|
#pragma endregion
|
|
|
|
|
|
#pragma region AecXDbEntityBaseEx
|
|
ACRX_NO_CONS_DEFINE_MEMBERS(AecXDbEntityBaseEx, AecDbEntityBase);
|
|
|
|
AecXDbEntityBaseEx::AecXDbEntityBaseEx(void)
|
|
{
|
|
AecDbEntityBase::m_eExplodeOrDrawType = kWroldDraw;
|
|
AecDbEntityBase::m_nDrawDimCur = -1;
|
|
}
|
|
|
|
AecXDbEntityBaseEx::~AecXDbEntityBaseEx(void)
|
|
{
|
|
}
|
|
|
|
Adesk::UInt32 AecXDbEntityBaseEx::subViewportDrawLogicalFlags(AcGiViewportDraw * vd)
|
|
{
|
|
return AecDbEntityBase::subViewportDrawLogicalFlags(vd);
|
|
}
|
|
|
|
Adesk::UInt32 AecXDbEntityBaseEx::subSetAttributes(AcGiDrawableTraits * traits)
|
|
{
|
|
return AecDbEntityBase::subSetAttributes(traits);
|
|
}
|
|
|
|
Adesk::Boolean AecXDbEntityBaseEx::subWorldDraw(AcGiWorldDraw *pWd)
|
|
{
|
|
assertReadEnabled();
|
|
return AecDbEntityBase::subWorldDraw(pWd);
|
|
}
|
|
|
|
void AecXDbEntityBaseEx::subViewportDraw(AcGiViewportDraw* pMode)
|
|
{
|
|
assertReadEnabled();
|
|
return AecDbEntityBase::subViewportDraw(pMode);
|
|
}
|
|
|
|
//保存代理实体图元
|
|
void AecXDbEntityBaseEx::saveAs(AcGiWorldDraw *pWd, AcDb::SaveType saveType)
|
|
{
|
|
AcGiRegenType rtype = pWd->regenType();
|
|
if (rtype == kAcGiSaveWorldDrawForProxy)
|
|
drawProxyEntity(_Get2DBuffer(), pWd);
|
|
else
|
|
AecDbEntityBase::saveAs(pWd, saveType);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbEntityBaseEx::subExplode(AcDbVoidPtrArray& entitySet) const
|
|
{
|
|
return AecDbEntityBase::subExplode(entitySet);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbEntityBaseEx::subGetGeomExtents(AcDbExtents& extents) const
|
|
{
|
|
return AecDbEntityBase::subGetGeomExtents(extents);
|
|
}
|
|
|
|
void AecXDbEntityBaseEx::subList() const
|
|
{
|
|
AecDbEntityBase::subList();
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbEntityBaseEx::subIntersectWith(const AcDbEntity* ent,
|
|
AcDb::Intersect intType,
|
|
AcGePoint3dArray& points,
|
|
INT_PTR thisGsMarker,
|
|
INT_PTR otherGsMarker) const
|
|
{
|
|
assertReadEnabled();
|
|
return AecDbEntityBase::subIntersectWith(ent, intType, points, thisGsMarker, otherGsMarker);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbEntityBaseEx::subIntersectWith(const AcDbEntity* ent,
|
|
AcDb::Intersect intType,
|
|
const AcGePlane& projPlane,
|
|
AcGePoint3dArray& points,
|
|
INT_PTR thisGsMarker,
|
|
INT_PTR otherGsMarker) const
|
|
{
|
|
assertReadEnabled();
|
|
return AecDbEntityBase::subIntersectWith(ent, intType, projPlane, points, thisGsMarker, otherGsMarker);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbEntityBaseEx::subSetPropertiesFrom(const AcDbEntity* pEntity, Adesk::Boolean doSubents /*= Adesk::kTrue*/)
|
|
{
|
|
assertWriteEnabled();
|
|
m_bInJig = ((AecXDbEntityBaseEx*)pEntity)->m_bInJig;
|
|
if (pEntity->isKindOf(AecXDbEntityBaseEx::desc()))
|
|
{
|
|
const BaseEx *pBase = dynamic_cast<const BaseEx*>(pEntity);
|
|
copyBy(*pBase);
|
|
}
|
|
return AecDbEntityBase::subSetPropertiesFrom(pEntity, doSubents);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbEntityBaseEx::copyFrom(const AcRxObject * pOther)
|
|
{
|
|
AecXDbEntityBaseEx *p = (AecXDbEntityBaseEx*)pOther;
|
|
BaseEx::m_bInJig = p->m_bInJig;
|
|
BaseEx::m_nPaperScale = p->m_nPaperScale;
|
|
return AecDbEntityBase::copyFrom(pOther);
|
|
}
|
|
|
|
#if (ARX > 15)
|
|
Acad::ErrorStatus AecXDbEntityBaseEx::subGetOsnapPoints(AcDb::OsnapMode osnapMode,
|
|
INT_PTR gsSelectionMark,
|
|
const AcGePoint3d& ptPick,
|
|
const AcGePoint3d& lastPoint,
|
|
const AcGeMatrix3d& viewXform,
|
|
AcGePoint3dArray& snapPoints,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
assertReadEnabled();
|
|
return AecDbEntityBase::subGetOsnapPoints(osnapMode, gsSelectionMark, ptPick, lastPoint, viewXform, snapPoints, geomIds);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbEntityBaseEx::subGetOsnapPoints(AcDb::OsnapMode osnapMode,
|
|
INT_PTR gsSelectionMark,
|
|
const AcGePoint3d& ptPick,
|
|
const AcGePoint3d& lastPoint,
|
|
const AcGeMatrix3d& viewXform,
|
|
AcGePoint3dArray& snapPoints,
|
|
AcDbIntArray& geomIds,
|
|
const AcGeMatrix3d& insersionMat) const
|
|
{
|
|
|
|
assertReadEnabled();
|
|
return AecDbEntityBase::subGetOsnapPoints(osnapMode, gsSelectionMark, ptPick, lastPoint, viewXform, snapPoints, geomIds, insersionMat);
|
|
}
|
|
#endif
|
|
|
|
#if ARX>15
|
|
void AecXDbEntityBaseEx::subGripStatus(const AcDb::GripStat status) { }
|
|
|
|
Acad::ErrorStatus AecXDbEntityBaseEx::subGetGripPoints(AcDbGripDataPtrArray& grips,
|
|
const double curViewUnitSize,
|
|
const int gripSize,
|
|
const AcGeVector3d& curViewDir,
|
|
const int bitflags) const { return Acad::eOk; }
|
|
|
|
Acad::ErrorStatus AecXDbEntityBaseEx::subMoveGripPointsAt(const AcDbVoidPtrArray& appData, const AcGeVector3d& offset, const int bitflags)
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
#endif
|
|
|
|
Acad::ErrorStatus AecXDbEntityBaseEx::subGetGripPoints(AcGePoint3dArray& gripPoints, AcDbIntArray& osnapModes, AcDbIntArray& geomIds) const
|
|
{
|
|
assertReadEnabled();
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbEntityBaseEx::subMoveGripPointsAt(const AcDbIntArray& indices, const AcGeVector3d& offset)
|
|
{
|
|
assertWriteEnabled();
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbEntityBaseEx::subGetStretchPoints(AcGePoint3dArray& stretchPoints) const
|
|
{
|
|
assertReadEnabled();
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbEntityBaseEx::subMoveStretchPointsAt(const AcDbIntArray& indices, const AcGeVector3d& offset)
|
|
{
|
|
assertWriteEnabled();
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbEntityBaseEx::subTransformBy(const AcGeMatrix3d& xform)
|
|
{
|
|
assertWriteEnabled();
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbEntityBaseEx::subGetTransformedCopy(const AcGeMatrix3d& xform,
|
|
AcDbEntity*& pEnt) const
|
|
{
|
|
assertReadEnabled();
|
|
return AecDbEntityBase::subGetTransformedCopy(xform, pEnt);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbEntityBaseEx::subDeepClone(AcDbObject* pOwner,
|
|
AcDbObject*& pClonedObject,
|
|
AcDbIdMapping& idMap,
|
|
Adesk::Boolean isPrimary) const
|
|
{
|
|
return AecDbEntityBase::subDeepClone(pOwner, pClonedObject, idMap, isPrimary);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbEntityBaseEx::subWblockClone(AcRxObject* pOwner,
|
|
AcDbObject*& pClonedObject,
|
|
AcDbIdMapping& idMap,
|
|
Adesk::Boolean isPrimary) const
|
|
{
|
|
return AecDbEntityBase::subWblockClone(pOwner, pClonedObject, idMap, isPrimary);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbEntityBaseEx::dwgInFields(AcDbDwgFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
Acad::ErrorStatus es = AecDbEntityBase::dwgInFields(pFiler);
|
|
if (es != Acad::eOk) return es;
|
|
return BaseEx::dwgInFields(pFiler);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbEntityBaseEx::dwgOutFields(AcDbDwgFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es = AecDbEntityBase::dwgOutFields(pFiler);
|
|
if (es != Acad::eOk) return es;
|
|
return BaseEx::dwgOutFields(pFiler);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbEntityBaseEx::dxfInFields(AcDbDxfFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
return AecDbEntityBase::dxfInFields(pFiler);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbEntityBaseEx::dxfOutFields(AcDbDxfFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
return AecDbEntityBase::dxfOutFields(pFiler);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbEntityBaseEx::Draw2d(AcGiDraw &dc) const
|
|
{
|
|
return AecDbEntityBase::Draw2d(dc);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbEntityBaseEx::Draw3d(AcGiDraw &dc) const
|
|
{
|
|
return AecDbEntityBase::Draw3d(dc);
|
|
}
|
|
|
|
|
|
|
|
void AecXDbEntityBaseEx::AssertWriteEnabled(Adesk::Boolean autoUndo /*= true*/, Adesk::Boolean recordModified /*= true*/)
|
|
{
|
|
if (m_bInJig)
|
|
return AecDbEntityBase::assertWriteEnabled(autoUndo, recordModified);
|
|
return AecDbEntityBase::AssertWriteEnabled(autoUndo, recordModified);
|
|
}
|
|
|
|
|
|
|
|
//获取二维视图显示的图形
|
|
int AecXDbEntityBaseEx::GetDraw2dables(Adesk::UInt16 nDrawStyle, AcDbVoidPtrArray& arEntPtrs) const
|
|
{
|
|
assertReadEnabled();
|
|
return AecDbEntityBase::GetDraw2dables(nDrawStyle, arEntPtrs);
|
|
}
|
|
|
|
//获取三维显示图形
|
|
int AecXDbEntityBaseEx::GetDraw3dables(AcDbVoidPtrArray& arEntPtrs, bool bWriteBimInfo) const
|
|
{
|
|
assertReadEnabled();
|
|
return AecDbEntityBase::GetDraw3dables(arEntPtrs, bWriteBimInfo);
|
|
}
|
|
|
|
int AecXDbEntityBaseEx::GetSectionDraw(const AcGePoint3d& ptFr, const AcGePoint3d& ptTo, const AcGeVector3d& vtViewDir, const AcGeVector3d& vtTo, AcDbVoidPtrArray& arRegionPtrs) const
|
|
{
|
|
return AecDbEntityBase::GetSectionDraw(ptFr, ptTo, vtViewDir, vtTo, arRegionPtrs);
|
|
}
|
|
|
|
double AecXDbEntityBaseEx::GetVolume(bool bIsBody/* = false*/) const
|
|
{
|
|
assertReadEnabled();
|
|
return AecDbEntityBase::GetVolume(bIsBody);
|
|
}
|
|
|
|
int AecXDbEntityBaseEx::ComparedTo(AecXDbEntityBaseEx* pEntOther) const
|
|
{
|
|
return AecDbEntityBase::comparedTo(pEntOther);
|
|
}
|
|
|
|
SHJson::WValue& AecXDbEntityBaseEx::ToJson() const
|
|
{
|
|
assertReadEnabled();
|
|
return AecDbEntityBase::ToJson();
|
|
}
|
|
|
|
bool AecXDbEntityBaseEx::ByJson(const SHJson::WValue &v)
|
|
{
|
|
AssertWriteEnabled();
|
|
return AecDbEntityBase::ByJson(v);
|
|
}
|
|
|
|
#pragma endregion
|
|
|
|
#pragma region AecXDbCurveBaseEx
|
|
ACRX_NO_CONS_DEFINE_MEMBERS(AecXDbCurveBaseEx, AecDbCurveBase);
|
|
|
|
AecXDbCurveBaseEx::AecXDbCurveBaseEx(void)
|
|
{
|
|
AecXDbCurveBaseEx::m_eExplodeOrDrawType = kWroldDraw;
|
|
AecXDbCurveBaseEx::m_nDrawDimCur = -1;
|
|
}
|
|
AecXDbCurveBaseEx::~AecXDbCurveBaseEx(void) {}
|
|
|
|
Adesk::Boolean AecXDbCurveBaseEx::isPlanar() const { return AecDbCurveBase::isPlanar(); }
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getPlane(AcGePlane &plane, AcDb::Planarity &planarity) const { return AecDbCurveBase::getPlane(plane, planarity); }
|
|
void AecXDbCurveBaseEx::getEcs(AcGeMatrix3d& retVal) const { return AecDbCurveBase::getEcs(retVal); }
|
|
|
|
Adesk::UInt32 AecXDbCurveBaseEx::subViewportDrawLogicalFlags(AcGiViewportDraw * vd) { return AecDbCurveBase::subViewportDrawLogicalFlags(vd); }
|
|
Adesk::UInt32 AecXDbCurveBaseEx::subSetAttributes(AcGiDrawableTraits * traits) { return AecDbCurveBase::subSetAttributes(traits); }
|
|
|
|
Adesk::Boolean AecXDbCurveBaseEx::subWorldDraw(AcGiWorldDraw *pWd) { return AecDbCurveBase::subWorldDraw(pWd); }
|
|
void AecXDbCurveBaseEx::subViewportDraw(AcGiViewportDraw* pMode) { return AecDbCurveBase::subViewportDraw(pMode); }
|
|
|
|
void AecXDbCurveBaseEx::saveAs(AcGiWorldDraw *pWd, AcDb::SaveType saveType)
|
|
{
|
|
AcGiRegenType rtype = pWd->regenType();
|
|
if (rtype == kAcGiSaveWorldDrawForProxy)
|
|
drawProxyEntity(_Get2DBuffer(), pWd);
|
|
else
|
|
AecDbCurveBase::saveAs(pWd, saveType);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::subExplode(AcDbVoidPtrArray& entitySet) const { return AecDbCurveBase::subExplode(entitySet); }
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::subGetGeomExtents(AcDbExtents& extents) const { return AecDbCurveBase::subGetGeomExtents(extents); }
|
|
void AecXDbCurveBaseEx::subList() const { return AecDbCurveBase::subList(); }
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::subIntersectWith(const AcDbEntity *ent,
|
|
AcDb::Intersect intType,
|
|
AcGePoint3dArray& points,
|
|
INT_PTR thisGsMarker,
|
|
INT_PTR otherGsMarker) const
|
|
{
|
|
return AecDbCurveBase::subIntersectWith(ent, intType, points, thisGsMarker,otherGsMarker);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::subIntersectWith(const AcDbEntity *ent
|
|
, AcDb::Intersect intType
|
|
, const AcGePlane& projPlane
|
|
, AcGePoint3dArray& points
|
|
, INT_PTR thisGsMarker
|
|
, INT_PTR otherGsMarker) const
|
|
{
|
|
return AecDbCurveBase::subIntersectWith(ent, intType, projPlane, points, thisGsMarker, otherGsMarker);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::subSetPropertiesFrom(const AcDbEntity* pEntity, Adesk::Boolean doSubents)
|
|
{
|
|
m_bInJig = ((AecXDbCurveBaseEx*)pEntity)->m_bInJig;
|
|
if (pEntity->isKindOf(AecXDbCurveBaseEx::desc()))
|
|
{
|
|
const BaseEx *pBase = dynamic_cast<const BaseEx*>(pEntity);
|
|
copyBy(*pBase);
|
|
}
|
|
return AecDbCurveBase::subSetPropertiesFrom(pEntity, doSubents);
|
|
}
|
|
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::subGetOsnapPoints(AcDb::OsnapMode osnapMode
|
|
, INT_PTR gsSelectionMark
|
|
, const AcGePoint3d& pickPoint
|
|
, const AcGePoint3d& lastPoint
|
|
, const AcGeMatrix3d& viewXform
|
|
, AcGePoint3dArray& snapPoints
|
|
, AcDbIntArray& geomIds) const
|
|
{
|
|
return AecDbCurveBase::subGetOsnapPoints(osnapMode
|
|
, gsSelectionMark
|
|
, pickPoint
|
|
, lastPoint
|
|
, viewXform
|
|
, snapPoints
|
|
, geomIds);
|
|
}
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::copyFrom(const AcRxObject * pOther)
|
|
{
|
|
AecXDbCurveBaseEx *p = (AecXDbCurveBaseEx*)pOther;
|
|
BaseEx::m_bInJig = p->m_bInJig;
|
|
BaseEx::m_nPaperScale = p->m_nPaperScale;
|
|
return AecDbCurveBase::copyFrom(pOther);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::subGetOsnapPoints(AcDb::OsnapMode osnapMode,
|
|
INT_PTR gsSelectionMark,
|
|
const AcGePoint3d& pickPoint,
|
|
const AcGePoint3d& lastPoint,
|
|
const AcGeMatrix3d& viewXform,
|
|
AcGePoint3dArray& snapPoints,
|
|
AcDbIntArray& geomIds,
|
|
const AcGeMatrix3d& insertionMat) const
|
|
{
|
|
return AecDbCurveBase::subGetOsnapPoints(osnapMode
|
|
, gsSelectionMark
|
|
, pickPoint
|
|
, lastPoint
|
|
, viewXform
|
|
, snapPoints
|
|
, geomIds
|
|
, insertionMat);
|
|
}
|
|
|
|
void AecXDbCurveBaseEx::subGripStatus(const AcDb::GripStat status) { return AecDbCurveBase::subGripStatus(status); }
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::subGetGripPoints(AcDbGripDataPtrArray& grips
|
|
, const double curViewUnitSize
|
|
, const int gripSize
|
|
, const AcGeVector3d& curViewDir
|
|
, const int bitflags) const
|
|
{
|
|
return AecDbCurveBase::subGetGripPoints(grips, curViewUnitSize, gripSize, curViewDir, bitflags);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::subMoveGripPointsAt(const AcDbVoidPtrArray& appData
|
|
, const AcGeVector3d& offset
|
|
, const int bitflags)
|
|
{
|
|
return AecDbCurveBase::subMoveGripPointsAt(appData, offset, bitflags);
|
|
}
|
|
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::subGetGripPoints(AcGePoint3dArray& gripPoints
|
|
, AcDbIntArray& osnapModes
|
|
, AcDbIntArray& geomIds) const
|
|
{
|
|
return AecDbCurveBase::subGetGripPoints(gripPoints, osnapModes, geomIds);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::subMoveGripPointsAt(const AcDbIntArray& indices, const AcGeVector3d& offset) { return AecDbCurveBase::subMoveGripPointsAt(indices, offset); }
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::subGetStretchPoints(AcGePoint3dArray& stretchPoints) const { return AecDbCurveBase::subGetStretchPoints(stretchPoints); }
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::subMoveStretchPointsAt(const AcDbIntArray& indices, const AcGeVector3d& offset) { return AecDbCurveBase::subMoveStretchPointsAt(indices, offset); }
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::subTransformBy(const AcGeMatrix3d& xform) { return AecDbCurveBase::subTransformBy(xform); }
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::subGetTransformedCopy(const AcGeMatrix3d& xform, AcDbEntity*& ent) const { return AecDbCurveBase::subGetTransformedCopy(xform, ent); }
|
|
|
|
//AcDbCurve
|
|
Adesk::Boolean AecXDbCurveBaseEx::isClosed() const { return AecDbCurveBase::isClosed(); }
|
|
Adesk::Boolean AecXDbCurveBaseEx::isPeriodic() const { return AecDbCurveBase::isPeriodic(); }
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getStartParam(double &d) const { return AecDbCurveBase::getStartParam(d); }
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getEndParam(double &d) const { return AecDbCurveBase::getEndParam(d); }
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getStartPoint(AcGePoint3d &pt) const { return AecDbCurveBase::getStartPoint(pt); }
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getEndPoint(AcGePoint3d &pt) const { return AecDbCurveBase::getEndPoint(pt); }
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getPointAtParam(double d, AcGePoint3d &pt) const { return AecDbCurveBase::getPointAtParam(d, pt); }
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getParamAtPoint(const AcGePoint3d &pt, double &d)const { return AecDbCurveBase::getParamAtPoint(pt, d); }
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getDistAtParam(double param, double &dist) const { return AecDbCurveBase::getDistAtParam(param, dist); }
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getParamAtDist(double dist, double ¶m) const { return AecDbCurveBase::getParamAtDist(dist, param); }
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getDistAtPoint(const AcGePoint3d &pt, double &d)const { return AecDbCurveBase::getDistAtPoint(pt, d); }
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getPointAtDist(double d, AcGePoint3d &pt) const { return AecDbCurveBase::getPointAtDist(d, pt); }
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getFirstDeriv(double param, AcGeVector3d &firstDeriv) const { return AecDbCurveBase::getFirstDeriv(param, firstDeriv); }
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getFirstDeriv(const AcGePoint3d &pt, AcGeVector3d &firstDeriv) const { return AecDbCurveBase::getFirstDeriv(pt, firstDeriv); }
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getSecondDeriv(double param, AcGeVector3d &secDeriv) const { return AecDbCurveBase::getSecondDeriv(param, secDeriv); }
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getSecondDeriv(const AcGePoint3d &pt, AcGeVector3d &secDeriv) const { return AecDbCurveBase::getSecondDeriv(pt, secDeriv); }
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getClosestPointTo(const AcGePoint3d &givenPnt
|
|
, AcGePoint3d &pointOnCurve
|
|
, Adesk::Boolean extend) const
|
|
{
|
|
return AecDbCurveBase::getClosestPointTo(givenPnt, pointOnCurve, extend);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getClosestPointTo(const AcGePoint3d &givenPnt
|
|
, const AcGeVector3d &direction
|
|
, AcGePoint3d& pointOnCurve
|
|
, Adesk::Boolean extend) const
|
|
{
|
|
return AecDbCurveBase::getClosestPointTo(givenPnt, direction, pointOnCurve, extend);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getSplitCurves(const AcGeDoubleArray& params, AcDbVoidPtrArray& curveSegments) const { return AecDbCurveBase::getSplitCurves(params, curveSegments); }
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getSplitCurves(const AcGePoint3dArray& points, AcDbVoidPtrArray& curveSegments) const { return AecDbCurveBase::getSplitCurves(points, curveSegments); }
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::extend(double newParam) { return AecDbCurveBase::extend(newParam); }
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::extend(Adesk::Boolean extendStart, const AcGePoint3d& toPoint) { return AecDbCurveBase::extend(extendStart, toPoint); }
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getSpline(AcDbSpline *&spline) const { return AecDbCurveBase::getSpline(spline); }
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getArea(double &d) const { return AecDbCurveBase::getArea(d); }
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getOffsetCurves(double offsetDist, AcDbVoidPtrArray& offsetCurves) const { return AecDbCurveBase::getOffsetCurves(offsetDist, offsetCurves); }
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getProjectedCurve(const AcGePlane &plane, const AcGeVector3d& projDir, AcDbCurve*& projCrv) const { return AecDbCurveBase::getProjectedCurve(plane, projDir,projCrv); }
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getOrthoProjectedCurve(const AcGePlane &plane, AcDbCurve*& projCrv) const { return AecDbCurveBase::getOrthoProjectedCurve(plane, projCrv); }
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::getOffsetCurvesGivenPlaneNormal(const AcGeVector3d& normal
|
|
, double offsetDist
|
|
, AcDbVoidPtrArray& offsetCurves) const
|
|
{
|
|
return AecDbCurveBase::getOffsetCurvesGivenPlaneNormal(normal, offsetDist, offsetCurves);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::dwgInFields(AcDbDwgFiler *pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
Acad::ErrorStatus es = AecDbCurveBase::dwgInFields(pFiler);
|
|
if (es != Acad::eOk) return es;
|
|
return BaseEx::dwgInFields(pFiler);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::dwgOutFields(AcDbDwgFiler *pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es = AecDbCurveBase::dwgOutFields(pFiler);
|
|
if (es != Acad::eOk) return es;
|
|
return BaseEx::dwgOutFields(pFiler);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::dxfInFields(AcDbDxfFiler *pFiler)
|
|
{
|
|
return AecDbCurveBase::dxfInFields(pFiler);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::dxfOutFields(AcDbDxfFiler *pFiler) const
|
|
{
|
|
return AecDbCurveBase::dxfOutFields(pFiler);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::subDeepClone(AcDbObject* pOwnerObject
|
|
, AcDbObject*& pClonedObject
|
|
, AcDbIdMapping& idMap
|
|
, Adesk::Boolean isPrimary) const
|
|
{
|
|
return AecDbCurveBase::subDeepClone(pOwnerObject, pClonedObject, idMap, isPrimary);
|
|
}
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::subWblockClone(AcRxObject* pOwnerObject
|
|
, AcDbObject*& pClonedObject
|
|
, AcDbIdMapping& idMap
|
|
, Adesk::Boolean isPrimary) const
|
|
{
|
|
return AecDbCurveBase::subWblockClone(pOwnerObject, pClonedObject, idMap, isPrimary);
|
|
}
|
|
|
|
|
|
//专业数据 和绘制设置
|
|
AecDbObjXDataMap* AecXDbCurveBaseEx::GetSpecialtyData(AcDb::OpenMode bMode) { return BaseEx::__GetSpecialtyData(); }
|
|
const AecDbObjXDataMap* AecXDbCurveBaseEx::GetSpecialtyData() const { return BaseEx::__GetSpecialtyDataReadOnly(); };
|
|
|
|
//获取二维视图显示的图形
|
|
int AecXDbCurveBaseEx::GetDraw2dables(Adesk::UInt16 nDrawStyle, AcDbVoidPtrArray& arEntPtrs) const { return AecDbCurveBase::GetDraw2dables(nDrawStyle, arEntPtrs); }
|
|
|
|
//获取三维显示图形
|
|
int AecXDbCurveBaseEx::GetDraw3dables(AcDbVoidPtrArray& arEntPtrs, bool bWriteBimInfo) const { return AecDbCurveBase::GetDraw3dables(arEntPtrs, bWriteBimInfo); }
|
|
|
|
//剖切提取
|
|
int AecXDbCurveBaseEx::GetSectionDraw(const AcGePoint3d& ptFr
|
|
, const AcGePoint3d& ptTo
|
|
, const AcGeVector3d& vtViewDir
|
|
, const AcGeVector3d& vtTo
|
|
, AcDbVoidPtrArray& arRegionPtrs) const
|
|
{
|
|
return AecDbCurveBase::GetSectionDraw(ptFr, ptTo, vtViewDir, vtTo, arRegionPtrs);
|
|
}
|
|
|
|
double AecXDbCurveBaseEx::GetVolume(bool bIsBody) const { return AecDbCurveBase::GetVolume(bIsBody); }
|
|
|
|
int AecXDbCurveBaseEx::ComparedTo(AecDbCurveBase* pCurOther) const { return AecDbCurveBase::ComparedTo(pCurOther); }
|
|
|
|
void AecXDbCurveBaseEx::SetActive(bool bActive) {};
|
|
bool AecXDbCurveBaseEx::IsActive() const { return false; }
|
|
|
|
// 导出json
|
|
SHJson::WValue& AecXDbCurveBaseEx::ToJson() const { return AecDbCurveBase::ToJson(); }
|
|
// 通过json创建
|
|
bool AecXDbCurveBaseEx::ByJson(const SHJson::WValue &v) { return AecDbCurveBase::ByJson(v); }
|
|
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::SetBaseCurve(const AcDbCurve* pDbCurve) { return AecDbCurveBase::SetBaseCurve(pDbCurve); }
|
|
AcDbCurve* AecXDbCurveBaseEx::GetBaseCurve(bool bOrthoProjectToXY) const { return AecDbCurveBase::GetBaseCurve(bOrthoProjectToXY); }
|
|
//返回原生Curve,不可以删除
|
|
AcDbCurve* AecXDbCurveBaseEx::GetNativeCurve() const { return AecDbCurveBase::GetNativeCurve(); }
|
|
|
|
//以下需要 AEC 派生
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::Draw2d(AcGiDraw &dc) const { return AecDbCurveBase::Draw2d(dc); }
|
|
|
|
Acad::ErrorStatus AecXDbCurveBaseEx::Draw3d(AcGiDraw &dc) const { return AecDbCurveBase::Draw3d(dc); }
|
|
|
|
//清理图元的特定writeenable
|
|
void AecXDbCurveBaseEx::AssertWriteEnabled(Adesk::Boolean autoUndo, Adesk::Boolean recordModified)
|
|
{
|
|
if (m_bInJig)
|
|
return AecDbCurveBase::assertWriteEnabled(autoUndo, recordModified);
|
|
return AecDbCurveBase::AssertWriteEnabled(autoUndo, recordModified);
|
|
}
|
|
|
|
#pragma endregion
|