950 lines
20 KiB
C++
950 lines
20 KiB
C++
#include "stdafx.h"
|
|
#include "AecDbBlackHoleEntity.h"
|
|
#include "CoreTools.h"
|
|
#include "KTSetting.h"
|
|
#include "AecDbWall.h"
|
|
#include "AecDbbeam.h"
|
|
#include "AecDbslab.h"
|
|
#include "AecDbcolumn.h"
|
|
#include "AecDbbasestair.h"
|
|
#include "AecDbOpening.h"
|
|
#include "AecDbMultiPartEntity.h"
|
|
#include "AecDbFlume.h"
|
|
#include "AecDbSludgePipe.h"
|
|
#include "AecDbRiverGroove.h"
|
|
#include "AecDbGuardBar.h"
|
|
#include "AecDbRoof.h"
|
|
#include "AecDbEwPipe.h"
|
|
#include "AecDbEwFitting.h"
|
|
#include "AecDbHvacDuct.h"
|
|
#include "AecDbHvacFitting.h"
|
|
#include "AecDbECableTray.h"
|
|
#include "AecDbEcFitting.h"
|
|
#include "AecDbEwEquipment.h"
|
|
#include "AecDbXEquipment.h"
|
|
#include "AecDbHolder.h"
|
|
#include "AecDbHanger.h"
|
|
#include "AecDbBossHolder.h"
|
|
#include "dbgrip.h"
|
|
|
|
|
|
static const Adesk::UInt16 kColorByBlock = 0;
|
|
static const Adesk::UInt16 kRed = 1;
|
|
static const Adesk::UInt16 kYellow = 2;
|
|
static const Adesk::UInt16 kGreen = 3;
|
|
static const Adesk::UInt16 kCyan = 4;
|
|
static const Adesk::UInt16 kBlue = 5;
|
|
static const Adesk::UInt16 kMagenta = 6;
|
|
static const Adesk::UInt16 kWhite = 7;
|
|
static const Adesk::UInt16 kColorByLayer = 256;
|
|
|
|
IMP_XDATA_KEY(AecDbBlackHoleEntity, _IS_CUT_WALL_);
|
|
IMP_XDATA_KEY(AecDbBlackHoleEntity, _IS_CUT_BEAM_);
|
|
IMP_XDATA_KEY(AecDbBlackHoleEntity, _IS_CUT_COLUMN_);
|
|
IMP_XDATA_KEY(AecDbBlackHoleEntity, _IS_CUT_SLAB_);
|
|
IMP_XDATA_KEY(AecDbBlackHoleEntity, _IS_CUT_WINDOOR_);
|
|
IMP_XDATA_KEY(AecDbBlackHoleEntity, _IS_CUT_YXGZ_);
|
|
IMP_XDATA_KEY(AecDbBlackHoleEntity, _IS_CUT_STAIR_);
|
|
IMP_XDATA_KEY(AecDbBlackHoleEntity, _IS_CUT_WEIR_);
|
|
IMP_XDATA_KEY(AecDbBlackHoleEntity, _IS_CUT_GUARDBAR_);
|
|
IMP_XDATA_KEY(AecDbBlackHoleEntity, _IS_CUT_ROOF_);
|
|
IMP_XDATA_KEY(AecDbBlackHoleEntity, _IS_USE_DBCLICK_);
|
|
|
|
IMP_XDATA_KEY(AecDbBlackHoleEntity, _IS_CUT_PIPE_);
|
|
IMP_XDATA_KEY(AecDbBlackHoleEntity, _IS_CUT_EQU_);
|
|
IMP_XDATA_KEY(AecDbBlackHoleEntity, _IS_CUT_DUCT_);
|
|
IMP_XDATA_KEY(AecDbBlackHoleEntity, _IS_CUT_CABTRY_);
|
|
IMP_XDATA_KEY(AecDbBlackHoleEntity, _IS_CUT_HOLDER_);
|
|
|
|
|
|
namespace
|
|
{
|
|
struct resbuf *MakeFence(AcDbPolyline *pPl)
|
|
{
|
|
struct resbuf resF;
|
|
resF.restype = RT3DPOINT;
|
|
|
|
struct resbuf *pHead = NULL;
|
|
struct resbuf *pHeadT = NULL;
|
|
struct resbuf *pTemp = NULL; acutNewRb(RT3DPOINT);
|
|
|
|
AcGePoint3d pt;
|
|
for (int i = 0; i < pPl->numVerts(); i++)
|
|
{
|
|
pPl->getPointAt(i, pt);
|
|
|
|
pTemp = acutNewRb(RT3DPOINT);
|
|
pTemp->resval.rpoint[0] = pt.x;
|
|
pTemp->resval.rpoint[1] = pt.y;
|
|
pTemp->resval.rpoint[2] = 0;
|
|
pTemp->restype = RT3DPOINT;//make sure
|
|
pTemp->rbnext = NULL;
|
|
|
|
if (pHead == NULL)
|
|
{
|
|
pHead = pTemp;
|
|
pHeadT = pHead;
|
|
}
|
|
else
|
|
{
|
|
pHead->rbnext = pTemp;
|
|
pHead = pTemp;
|
|
pHead->rbnext = NULL;
|
|
}
|
|
}
|
|
return pHeadT;
|
|
}
|
|
void clearAssocBuffer(const AcDbObjectIdArray &ids)
|
|
{
|
|
AcDbEntity *pEnt = NULL;
|
|
AcDbObjectId id;
|
|
for (int i = 0; i < ids.length(); i++)
|
|
{
|
|
id = ids.at(i);
|
|
|
|
if (Acad::eOk == acdbOpenAcDbEntity(pEnt, id, AcDb::kForWrite))
|
|
{
|
|
AecDbEntityBase *pEntBase = AecDbEntityBase::cast(pEnt);
|
|
if (pEntBase != NULL)
|
|
{
|
|
pEntBase->Remove3DBoolSubtract();
|
|
}
|
|
|
|
AecDbCurveBase *pCrvBase = AecDbCurveBase::cast(pEnt);
|
|
if (pCrvBase != NULL)
|
|
{
|
|
pCrvBase->Remove3DBoolSubtract();
|
|
}
|
|
|
|
pEnt->close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
extern AcGePoint3d MidPoint(const AcGePoint3d& pt1,const AcGePoint3d& pt2);
|
|
|
|
Adesk::UInt32 AecDbBlackHoleEntity::kCurrentVersionNumber = 2;
|
|
|
|
ACRX_DXF_DEFINE_MEMBERS (AecDbBlackHoleEntity, AecDbEntityBase,
|
|
AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
|
AcDbProxyEntity::kNoOperation | AcDbProxyEntity::kDisableProxyWarning,
|
|
AEC_BLACKHOLE,
|
|
"AecDbBlackHoleEntity"
|
|
"|Product Desc: shanghua earthworm app obj"
|
|
"|Company: shanghua inc"
|
|
"|WEB Address: www.shanghuasoft.com")
|
|
|
|
AecDbBlackHoleEntity::AecDbBlackHoleEntity(void)
|
|
{
|
|
|
|
}
|
|
|
|
AecDbBlackHoleEntity::~AecDbBlackHoleEntity(void)
|
|
{
|
|
|
|
}
|
|
|
|
bool AecDbBlackHoleEntity::Set(AcDbPolyline* pPl,double dH,const AcDbObjectIdArray& arIds)
|
|
{
|
|
AssertWriteEnabled();
|
|
if ( !CoreTools::PolylineToString(pPl,m_sPolyline,true) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
AcDbExtents ext;
|
|
pPl->getGeomExtents(ext);
|
|
|
|
m_ptOrg = MidPoint(ext.minPoint(),ext.maxPoint());
|
|
m_arAssocIds.append(arIds);
|
|
m_dH = dH;
|
|
|
|
return true;
|
|
}
|
|
|
|
AcDb3dSolid* AecDbBlackHoleEntity::GetBlackHole() const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcDb3dSolid* pSolidAll = NULL;
|
|
if (!m_sPolyline.IsEmpty() && m_dH > 0)
|
|
{
|
|
AcDbPolyline* pPl = CoreTools::StringToPolyline(m_sPolyline);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setClosed(Adesk::kTrue);
|
|
|
|
AcGeVector3d vtNorm = pPl->normal();
|
|
vtNorm.normalize();
|
|
|
|
AcDbRegion* pReg = NULL;
|
|
AcDbVoidPtrArray arCrvPtrs,arRegPtrs;
|
|
arCrvPtrs.append(pPl);
|
|
|
|
AcDbRegion::createFromCurves(arCrvPtrs,arRegPtrs);
|
|
if (!arRegPtrs.isEmpty())
|
|
{
|
|
pReg = (AcDbRegion*)arRegPtrs.first();
|
|
|
|
AcDbExtents ext;
|
|
pReg->getGeomExtents(ext);
|
|
|
|
AcGePoint3d ptS,ptE;
|
|
ptS = m_ptOrg;
|
|
|
|
ptS -= vtNorm * m_dH;
|
|
ptE = ptS + vtNorm * 2.0 * m_dH;
|
|
|
|
AcDbLine ln;
|
|
ln.setStartPoint(ptS);
|
|
ln.setEndPoint(ptE);
|
|
|
|
AcDb3dSolid* pSolid = new AcDb3dSolid;
|
|
if (Acad::eOk == pSolid->extrudeAlongPath(pReg,&ln) )
|
|
{
|
|
pSolidAll = pSolid;
|
|
}
|
|
else
|
|
{
|
|
delete pSolid;
|
|
}
|
|
delete pReg;
|
|
}
|
|
delete pPl;
|
|
}
|
|
}
|
|
return pSolidAll;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBlackHoleEntity::copyFrom(const AcRxObject* pSrc)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
AecDbBlackHoleEntity* pBlk = AecDbBlackHoleEntity::cast(pSrc);
|
|
if (pBlk != NULL)
|
|
{
|
|
m_sPolyline = pBlk->m_sPolyline;
|
|
m_arAssocIds.removeAll();
|
|
m_arAssocIds.append(pBlk->m_arAssocIds);
|
|
m_drawable2d.RemoveEdage();
|
|
m_ptOrg = pBlk->m_ptOrg;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBlackHoleEntity::subTransformBy(const AcGeMatrix3d& xform)
|
|
{
|
|
//不可移动
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBlackHoleEntity::subErase(Adesk::Boolean erasing)
|
|
{
|
|
if (erasing)
|
|
{
|
|
clearAssocBuffer(m_arAssocIds);
|
|
}
|
|
return AcDbEntity::subErase(erasing);
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBlackHoleEntity::Draw2d(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
//二维缓存,未知出错!
|
|
if (Has2DBuffer())
|
|
{
|
|
AcDbEntity* pEnt = NULL;
|
|
const AcDbVoidPtrArray &ar2D = Get2DBuffer();
|
|
for (int i = 0;i < ar2D.length();i++)
|
|
{
|
|
pEnt = (AcDbEntity*)ar2D.at(i);
|
|
dc.DrawEntity(*pEnt);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
AcDbPolyline* pPl = CoreTools::StringToPolyline(m_sPolyline);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setColorIndex(4);
|
|
pPl->setLinetype(KTSetting::InitLineStyle(_T("DASHED")));
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBlackHoleEntity::Draw3d(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
if (Has3DBuffer())
|
|
{
|
|
AcDbEntity* pEnt = NULL;
|
|
const AcDbVoidPtrArray &ar3D = Get3DBuffer();
|
|
for (int i = 0;i < ar3D.length();i++)
|
|
{
|
|
pEnt = (AcDbEntity*)ar3D.at(i);
|
|
dc.DrawEntity(*pEnt);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
//绘制中间一个球体 示意
|
|
AcGePoint3d ptOrg = m_ptOrg;
|
|
AcDbEntity* p3dEnt = dc.DrawSphere(ptOrg,10.0);
|
|
if (p3dEnt != NULL)
|
|
{
|
|
Add3DBuffer(p3dEnt);
|
|
}
|
|
|
|
AcDbPolyline* pPl = CoreTools::StringToPolyline(m_sPolyline);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setColorIndex(4);
|
|
pPl->setLinetype(KTSetting::InitLineStyle(_T("DASHED")));
|
|
dc.DrawEntity(pPl);
|
|
Add3DBuffer(pPl);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBlackHoleEntity::dwgInFields (AcDbDwgFiler* pFiler)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
//----- Read parent class information first.
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
es = AecDbEntityBase::dwgInFields (pFiler) ;
|
|
if ( es != Acad::eOk )
|
|
return (es) ;
|
|
|
|
//----- Object version number needs to be read first
|
|
Adesk::UInt32 version =0 ;
|
|
if ( (es = pFiler->readUInt32 (&version)) != Acad::eOk )
|
|
return (es) ;
|
|
|
|
if ( version > AecDbBlackHoleEntity::kCurrentVersionNumber )
|
|
return (Acad::eMakeMeProxy) ;
|
|
|
|
|
|
m_arAssocIds.removeAll();
|
|
|
|
Adesk::Int32 nLen = 0;
|
|
pFiler->readInt32(&nLen);
|
|
|
|
AcDbSoftPointerId id;
|
|
for (int i = 0;i < nLen;i++)
|
|
{
|
|
pFiler->readSoftPointerId(&id);
|
|
m_arAssocIds.append(id);
|
|
}
|
|
|
|
TCHAR* pszPolyline = NULL;
|
|
pFiler->readString(&pszPolyline);
|
|
|
|
if (pszPolyline != NULL)
|
|
{
|
|
m_sPolyline = pszPolyline;
|
|
}
|
|
m_drawable2d.dwgInFields(pFiler);
|
|
|
|
if (version >= 1)
|
|
{
|
|
m_mapSpecXData.dwgInFields(pFiler);
|
|
}
|
|
|
|
return (pFiler->filerStatus ());
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBlackHoleEntity::dwgOutFields(AcDbDwgFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
//----- Save parent class information first.
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
es = AecDbEntityBase::dwgOutFields (pFiler) ;
|
|
if ( es != Acad::eOk )
|
|
return (es) ;
|
|
|
|
//----- Object version number needs to be saved first
|
|
if ( (es =pFiler->writeUInt32 (AecDbBlackHoleEntity::kCurrentVersionNumber)) != Acad::eOk )
|
|
return (es) ;
|
|
|
|
Adesk::Int32 nLen = m_arAssocIds.length();
|
|
pFiler->writeInt32(nLen);
|
|
|
|
AcDbSoftPointerId id;
|
|
for (int i = 0;i < m_arAssocIds.length();i++)
|
|
{
|
|
id = m_arAssocIds.at(i);
|
|
pFiler->writeSoftPointerId(id);
|
|
}
|
|
|
|
pFiler->writeString((LPCTSTR)m_sPolyline);
|
|
|
|
m_drawable2d.dwgOutFields(pFiler);
|
|
|
|
m_mapSpecXData.dwgOutFields(pFiler);
|
|
|
|
return (pFiler->filerStatus ());
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBlackHoleEntity::dxfInFields (AcDbDxfFiler* pFiler)
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBlackHoleEntity::dxfOutFields(AcDbDxfFiler* pFiler) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
void AecDbBlackHoleEntity::AssertWriteEnabled(Adesk::Boolean autoUndo/* = true*/, Adesk::Boolean recordModified/* = true */)
|
|
{
|
|
Clean3DBuffer();
|
|
AecDbEntityBase::AssertWriteEnabled(autoUndo, recordModified);
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBlackHoleEntity::subGetGripPoints(AcDbGripDataPtrArray &grips
|
|
, const double curViewUnitSize
|
|
, const int gripSize
|
|
, const AcGeVector3d &curViewDir
|
|
, const int bitflags) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
int *pData = new int(0);
|
|
AcDbGripData *pGripData = NULL;
|
|
pGripData = new AcDbGripData(m_ptOrg, pData);
|
|
grips.append(pGripData);
|
|
|
|
AcDbPolyline *pl = CoreTools::StringToPolyline(m_sPolyline);
|
|
if (pl)
|
|
{
|
|
AcGePoint3d pt;
|
|
for (int i(0); i < pl->numVerts(); ++i)
|
|
{
|
|
pl->getPointAt(i, pt);
|
|
pData = new int(i + 1);
|
|
pGripData = new AcDbGripData(pt, pData);
|
|
grips.append(pGripData);
|
|
}
|
|
}
|
|
DELETE_PTR(pl);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBlackHoleEntity::subMoveGripPointsAt(const AcDbVoidPtrArray &appData
|
|
, const AcGeVector3d &offset
|
|
, const int bitflags)
|
|
{
|
|
|
|
AssertWriteEnabled();
|
|
|
|
//#ifndef NDEBUG
|
|
// acutPrintf(_T("\n%d"), bitflags);
|
|
//#endif // NDEBUG
|
|
|
|
|
|
if (bitflags == 0 || bitflags == 1 || bitflags == 2)
|
|
{
|
|
AcGeMatrix3d mat;
|
|
mat.setToTranslation(offset);
|
|
int idx = *(int*)appData.first();
|
|
if (idx == 0)
|
|
{
|
|
AcDbPolyline *pl = CoreTools::StringToPolyline(m_sPolyline);
|
|
if (pl)
|
|
{
|
|
pl->transformBy(mat);
|
|
m_ptOrg.transformBy(mat);
|
|
CoreTools::PolylineToString(pl, m_sPolyline);
|
|
DELETE_PTR(pl);
|
|
Refresh();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AcDbPolyline *pl = CoreTools::StringToPolyline(m_sPolyline);
|
|
if (pl)
|
|
{
|
|
AcGePoint3d pt;
|
|
idx -= 1;
|
|
if (idx < pl->numVerts())
|
|
{
|
|
pl->getPointAt(idx, pt);
|
|
pt.transformBy(mat);
|
|
pl->setPointAt(idx, pt.convert2d(AcGePlane::kXYPlane));
|
|
AcDbExtents ext;
|
|
pl->getGeomExtents(ext);
|
|
m_ptOrg = CoreTools::MidPt(ext.maxPoint(), ext.minPoint());
|
|
CoreTools::PolylineToString(pl, m_sPolyline);
|
|
Refresh();
|
|
}
|
|
DELETE_PTR(pl);
|
|
}
|
|
}
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
void AecDbBlackHoleEntity::Refresh()
|
|
{
|
|
AcDbPolyline *pPl = CoreTools::StringToPolyline(m_sPolyline);
|
|
if (!pPl) return;
|
|
|
|
std::shared_ptr<AcDbPolyline> plPtr(pPl);
|
|
|
|
if (plPtr->numVerts() < 2) return;
|
|
|
|
if (!plPtr->isClosed()) plPtr->setClosed(Adesk::kTrue);
|
|
|
|
AcDbObjectIdArray ids;
|
|
AcDbObjectId id, idHole(objectId());
|
|
|
|
ads_name ss, ent;
|
|
struct resbuf *pRb = acutBuildList(RTDXF0, _T("AEC_*"), 0);
|
|
struct resbuf *pRbFence = MakeFence(plPtr.get());
|
|
|
|
int nRes = acedSSGet(_T("CP"), pRbFence, NULL, pRb, ss);
|
|
acutRelRb(pRb);
|
|
acutRelRb(pRbFence);
|
|
if (nRes != RTNORM)
|
|
{
|
|
acutPrintf(_T("\n没有选上构件!"));
|
|
ids.append(m_arAssocIds);
|
|
}
|
|
|
|
|
|
if (ids.isEmpty())
|
|
{
|
|
clearAssocBuffer(m_arAssocIds);
|
|
m_arAssocIds.removeAll();
|
|
}
|
|
|
|
Adesk::Int32 nLen = 0;
|
|
acedSSLength(ss, &nLen);
|
|
for (int i = 0; i < nLen; i++)
|
|
{
|
|
acedSSName(ss, i, ent);
|
|
acdbGetObjectId(id, ent);
|
|
if (!id.isValid()) continue;
|
|
ids.append(id);
|
|
}
|
|
acedSSFree(ss);
|
|
|
|
AcDbEntity *pEnt(NULL);
|
|
for (int i(0); i < ids.length(); ++i)
|
|
{
|
|
id = ids[i];
|
|
if (Acad::eOk != acdbOpenAcDbEntity(pEnt, id, AcDb::kForWrite)) continue;
|
|
if (pEnt->isKindOf(AecDbXWall::desc()))
|
|
{
|
|
if (Get_IS_CUT_WALL())
|
|
{
|
|
AecDbXWall *pWall = (AecDbXWall *)pEnt;
|
|
pWall->AddBlackHole(idHole);
|
|
m_arAssocIds.append(id);
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (pEnt->isKindOf(AecDbBeam::desc()))
|
|
{
|
|
if (Get_IS_CUT_BEAM())
|
|
{
|
|
AecDbBeam *pBeam = (AecDbBeam *)pEnt;
|
|
pBeam->AddBlackHole(idHole);
|
|
m_arAssocIds.append(id);
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (pEnt->isKindOf(AecDbXSlab::desc()))
|
|
{
|
|
if (Get_IS_CUT_SLAB())
|
|
{
|
|
AecDbXSlab *pSlab = (AecDbXSlab *)pEnt;
|
|
pSlab->AddBlackHole(idHole);
|
|
m_arAssocIds.append(id);
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (pEnt->isKindOf(AecDbColumn::desc()))
|
|
{
|
|
if (Get_IS_CUT_COLUMN())
|
|
{
|
|
AecDbColumn *pCol = (AecDbColumn *)pEnt;
|
|
pCol->AddBlackHole(idHole);
|
|
m_arAssocIds.append(id);
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (pEnt->isKindOf(AecDbXOpening::desc()))
|
|
{
|
|
if (Get_IS_CUT_WINDOOR())
|
|
{
|
|
AecDbXOpening *pOpen = (AecDbXOpening *)pEnt;
|
|
pOpen->AddBlackHole(idHole);
|
|
m_arAssocIds.append(id);
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (pEnt->isKindOf(AecDbMultiPartEntity::desc()))
|
|
{
|
|
if (Get_IS_CUT_YXGZ())
|
|
{
|
|
AecDbMultiPartEntity *pMPart = (AecDbMultiPartEntity *)pEnt;
|
|
pMPart->AddBlackHole(idHole);
|
|
m_arAssocIds.append(id);
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (pEnt->isKindOf(AecDbBaseStair::desc()))
|
|
{
|
|
if (Get_IS_CUT_STAIR())
|
|
{
|
|
AecDbBaseStair *pStair = (AecDbBaseStair *)pEnt;
|
|
pStair->AddBlackHole(idHole);
|
|
m_arAssocIds.append(id);
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (pEnt->isKindOf(AecDbFlume::desc()) ||
|
|
pEnt->isKindOf(AecDbSludgePipe::desc()) ||
|
|
pEnt->isKindOf(AecDbRiverGroove::desc()))
|
|
{
|
|
if (Get_IS_CUT_WEIR())
|
|
{
|
|
AecDbCurveBase *pCurBase = (AecDbCurveBase*)pEnt;
|
|
pCurBase->AddBlackHole(idHole);
|
|
m_arAssocIds.append(id);
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (pEnt->isKindOf(AecDbGuardBar::desc()))
|
|
{
|
|
if (Get_IS_CUT_GUARDBAR())
|
|
{
|
|
AecDbGuardBar *pGBar = (AecDbGuardBar *)pEnt;
|
|
pGBar->AddBlackHole(idHole);
|
|
m_arAssocIds.append(id);
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (pEnt->isKindOf(AecDbXRoof::desc()))
|
|
{
|
|
if (Get_IS_CUT_ROOF())
|
|
{
|
|
AecDbXRoof *pRoof = (AecDbXRoof *)pEnt;
|
|
pRoof->AddBlackHole(idHole);
|
|
m_arAssocIds.append(id);
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (pEnt->isKindOf(AecDbEwPipe::desc()))
|
|
{
|
|
if (Get_IS_CUT_PIPE())
|
|
{
|
|
AecDbEwPipe *pPipe = (AecDbEwPipe *)pEnt;
|
|
pPipe->AddBlackHole(idHole);
|
|
m_arAssocIds.append(id);
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (pEnt->isKindOf(AecDbEwFitting::desc()))
|
|
{
|
|
if (Get_IS_CUT_PIPE())
|
|
{
|
|
AecDbEwFitting *pFit = (AecDbEwFitting *)pEnt;
|
|
pFit->AddBlackHole(idHole);
|
|
m_arAssocIds.append(id);
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (pEnt->isKindOf(AecDbEwEquipment::desc()))
|
|
{
|
|
if (Get_IS_CUT_EQU())
|
|
{
|
|
AecDbEwEquipment *pEqu = (AecDbEwEquipment *)pEnt;
|
|
pEqu->AddBlackHole(idHole);
|
|
m_arAssocIds.append(id);
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
if (pEnt->isKindOf(AecDbXEquipment::desc()))
|
|
{
|
|
if (Get_IS_CUT_EQU())
|
|
{
|
|
AecDbXEquipment *pEqu = (AecDbXEquipment *)pEnt;
|
|
pEqu->AddBlackHole(idHole);
|
|
m_arAssocIds.append(id);
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (pEnt->isKindOf(AecDbHvacDuct::desc()))
|
|
{
|
|
if (Get_IS_CUT_DUCT())
|
|
{
|
|
AecDbHvacDuct *pPipe = (AecDbHvacDuct *)pEnt;
|
|
pPipe->AddBlackHole(idHole);
|
|
m_arAssocIds.append(id);
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (pEnt->isKindOf(AecDbHvacFitting::desc()))
|
|
{
|
|
if (Get_IS_CUT_DUCT())
|
|
{
|
|
AecDbHvacFitting *pHFit = (AecDbHvacFitting *)pEnt;
|
|
pHFit->AddBlackHole(idHole);
|
|
m_arAssocIds.append(id);
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (pEnt->isKindOf(AecDbECableTray::desc()))
|
|
{
|
|
if (Get_IS_CUT_CABTRY())
|
|
{
|
|
AecDbECableTray *pPipe = (AecDbECableTray *)pEnt;
|
|
pPipe->AddBlackHole(idHole);
|
|
m_arAssocIds.append(id);
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
|
|
if (pEnt->isKindOf(AecDbEcFitting::desc()))
|
|
{
|
|
if (Get_IS_CUT_CABTRY())
|
|
{
|
|
AecDbEcFitting *pEFit = (AecDbEcFitting *)pEnt;
|
|
pEFit->AddBlackHole(idHole);
|
|
m_arAssocIds.append(id);
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (pEnt->isKindOf(AecDbHolder::desc()))
|
|
{
|
|
if (Get_IS_CUT_HOLDER())
|
|
{
|
|
AecDbHolder *pHolder = (AecDbHolder *)pEnt;
|
|
pHolder->AddBlackHole(idHole);
|
|
m_arAssocIds.append(id);
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (pEnt->isKindOf(AecDbHanger::desc()))
|
|
{
|
|
if (Get_IS_CUT_HOLDER())
|
|
{
|
|
AecDbHanger *pHanger = (AecDbHanger *)pEnt;
|
|
pHanger->AddBlackHole(idHole);
|
|
m_arAssocIds.append(id);
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (pEnt->isKindOf(AecDbBossHolder::desc()))
|
|
{
|
|
if (Get_IS_CUT_HOLDER())
|
|
{
|
|
AecDbBossHolder *pBanger = (AecDbBossHolder *)pEnt;
|
|
pBanger->AddBlackHole(idHole);
|
|
m_arAssocIds.append(id);
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
/*if (pEnt->isKindOf(AecDbEwPipe::desc()) ||
|
|
pEnt->isKindOf(AecDbEwFitting::desc()))
|
|
{
|
|
if (dlg.m_bPipesys)
|
|
{
|
|
pEntBase = AecDbEntityBase::cast(pEnt);
|
|
if (pEntBase != NULL)
|
|
{
|
|
pEntBase->AddBlackHole(idHole);
|
|
}
|
|
|
|
pCurBase = AecDbCurveBase::cast(pEnt);
|
|
if (pCurBase != NULL)
|
|
{
|
|
pCurBase->AddBlackHole(idHole);
|
|
}
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (pEnt->isKindOf(AecDbHvacDuct::desc()) ||
|
|
pEnt->isKindOf(AecDbHvacFitting::desc()))
|
|
{
|
|
if (dlg.m_bHVACsys)
|
|
{
|
|
pEntBase = AecDbEntityBase::cast(pEnt);
|
|
if (pEntBase != NULL)
|
|
{
|
|
pEntBase->AddBlackHole(idHole);
|
|
}
|
|
|
|
pCurBase = AecDbCurveBase::cast(pEnt);
|
|
if (pCurBase != NULL)
|
|
{
|
|
pCurBase->AddBlackHole(idHole);
|
|
}
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (pEnt->isKindOf(AecDbECableTray::desc()) ||
|
|
pEnt->isKindOf(AecDbEcFitting::desc()))
|
|
{
|
|
if (dlg.m_bCableTray)
|
|
{
|
|
pEntBase = AecDbEntityBase::cast(pEnt);
|
|
if (pEntBase != NULL)
|
|
{
|
|
pEntBase->AddBlackHole(idHole);
|
|
}
|
|
|
|
pCurBase = AecDbCurveBase::cast(pEnt);
|
|
if (pCurBase != NULL)
|
|
{
|
|
pCurBase->AddBlackHole(idHole);
|
|
}
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (pEnt->isKindOf(AecDbEwEquipment::desc()) ||
|
|
pEnt->isKindOf(AecDbXEquipment::desc()))
|
|
{
|
|
if (dlg.m_bEqu)
|
|
{
|
|
pEntBase = AecDbEntityBase::cast(pEnt);
|
|
if (pEntBase != NULL)
|
|
{
|
|
pEntBase->AddBlackHole(idHole);
|
|
}
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (pEnt->isKindOf(AecDbHolder::desc()) ||
|
|
pEnt->isKindOf(AecDbHanger::desc()) ||
|
|
pEnt->isKindOf(AecDbBossHolder::desc()))
|
|
{
|
|
if (dlg.m_bHolder)
|
|
{
|
|
pEntBase = AecDbEntityBase::cast(pEnt);
|
|
if (pEntBase != NULL)
|
|
{
|
|
pEntBase->AddBlackHole(idHole);
|
|
}
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (dlg.m_bOther)
|
|
{
|
|
pEntBase = AecDbEntityBase::cast(pEnt);
|
|
if (pEntBase != NULL)
|
|
{
|
|
pEntBase->AddBlackHole(idHole);
|
|
}
|
|
|
|
pCurBase = AecDbCurveBase::cast(pEnt);
|
|
if (pCurBase != NULL)
|
|
{
|
|
pCurBase->AddBlackHole(idHole);
|
|
}
|
|
pEnt->close();
|
|
continue;
|
|
}*/
|
|
pEnt->close();
|
|
}
|
|
}
|
|
|
|
double AecDbBlackHoleEntity::GetHeight() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_dH;
|
|
}
|
|
|
|
void AecDbBlackHoleEntity::SetHeight(const double dH)
|
|
{
|
|
AssertWriteEnabled();
|
|
m_dH = dH;
|
|
}
|
|
|
|
void AecDbBlackHoleEntity::SetElev(const double dH)
|
|
{
|
|
AssertWriteEnabled();
|
|
AcDbPolyline *p = CoreTools::StringToPolyline(m_sPolyline);
|
|
if (p)
|
|
{
|
|
p->setElevation(dH);
|
|
CoreTools::PolylineToString(p, m_sPolyline);
|
|
DELETE_PTR(p);
|
|
}
|
|
}
|
|
|
|
double AecDbBlackHoleEntity::GetElev() const
|
|
{
|
|
double dH(.0);
|
|
assertReadEnabled();
|
|
AcDbPolyline *p = CoreTools::StringToPolyline(m_sPolyline);
|
|
if (p)
|
|
{
|
|
dH = p->elevation();
|
|
DELETE_PTR(p);
|
|
}
|
|
return dH;
|
|
} |