#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;
}