#include "stdafx.h"
#include "AecDbEntityCommon.h"
#include "AecDbObjXDataMap.h"
#include "AcGiViewDraw.h"
#include "dbobjptr.h"
#include "simpleproperty.h"
#include "AecGripCback.h"

BOOL ReadModelXData(LPCTSTR pszKey, AecDbObjXDataMap& xDataMap, AcDbDatabase* pDb);

const Adesk::UInt16 kColorByLayer = 256;
static const Adesk::UInt16 kRed = 1;

namespace
{
	void FreeBuffer(int n, AcDbVoidPtrArray& arEntPtrs)
	{
		AcDbEntity* pEnt = NULL;
		while (arEntPtrs.length() > n)
		{
			pEnt = (AcDbEntity*)arEntPtrs.last();
			pEnt->erase();
			pEnt->close();
			DELETE_PTR(pEnt);
			arEntPtrs.removeLast();
		}
	}

	AcGePoint3d MidPoint(AcGePoint3d &pt1, AcGePoint3d &pt2)
	{
		return AcGePoint3d((pt1.x + pt2.x) / 2.0,
			(pt1.y + pt2.y) / 2.0,
			(pt1.z + pt2.z) / 2.0);
	}

	CString IDCreate()
	{
		CString sID = _T("");

		GUID Guid;
		static TCHAR szGuid[39];
		RPC_WSTR pszGuid = NULL;

		UuidCreate(&Guid);

		if (RPC_S_OK != UuidToString(&Guid, &pszGuid))
		{
			return _T("");
		}

		lstrcpyn(szGuid, (TCHAR *)pszGuid, sizeof(szGuid));
		RpcStringFree(&pszGuid);

		szGuid[38] = _T('\0');
		sID = szGuid;
		sID.MakeUpper();
		return sID;
	}

}

void AecDbEntityCommon::AssertWriteEnabled(Adesk::Boolean autoUndo, Adesk::Boolean recordModified)
{
	FreeBuffer(0, m_ar2DDrableBufPtrs_);
	FreeBuffer(0, m_ar3DDrableBufPtrs_);

	m_ar3DDrableBufPtrs_.removeAll();
	m_ar2DDrableBufPtrs_.removeAll();

	GetMe()->assertWriteEnabled(autoUndo, recordModified);
}

AecDbEntityCommon::AecDbEntityCommon(void)
{
	m_eExplodeOrDrawType = kWroldDraw;
	m_nDrawDimCur = -1;
}

AecDbEntityCommon::~AecDbEntityCommon(void)
{
	FreeBuffer(0, m_ar2DDrableBufPtrs_);
	FreeBuffer(0, m_ar3DDrableBufPtrs_);
}

Acad::ErrorStatus AecDbEntityCommon::Draw2d(AcGiDraw & dc) const { return Acad::eOk; }

Acad::ErrorStatus AecDbEntityCommon::Draw3d(AcGiDraw & dc) const { return Acad::eOk; }

bool AecDbEntityCommon::Draw2DBuffers(AcGiDraw & dc) const
{
	if (m_ar2DDrableBufPtrs_.isEmpty())
		return false;

	for (int i = 0; i < m_ar2DDrableBufPtrs_.length(); ++i)
		dc.DrawEntity(*(AcDbEntity *)m_ar2DDrableBufPtrs_[i]);

	return true;
}

const AcDbVoidPtrArray& AecDbEntityCommon::Get2DBuffer() const { return m_ar2DDrableBufPtrs_; }

bool AecDbEntityCommon::Has2DBuffer() const { return !m_ar2DDrableBufPtrs_.isEmpty(); }

void AecDbEntityCommon::Add2DBuffer(AcDbEntity * pEnt) const
{
	if (pEnt && m_ar2DDrableBufPtrs_.find(pEnt) == -1)
		m_ar2DDrableBufPtrs_.append(pEnt);
}

void AecDbEntityCommon::Add2DBuffer(const AcDbVoidPtrArray & arr) const
{
	for (int i = 0; i < arr.length(); ++i)
		Add2DBuffer((AcDbEntity *)arr[i]);
}

bool AecDbEntityCommon::IsIn2DBuffer(AcDbEntity *pEnt) const
{
	if (-1 == m_ar2DDrableBufPtrs_.find(pEnt))
		return false;
	return true;
}

void AecDbEntityCommon::Clean2DBuffer()const
{
	FreeBuffer(0, m_ar2DDrableBufPtrs_);
	m_ar2DDrableBufPtrs_.removeAll();
}

void AecDbEntityCommon::Clean2DBufferNoDel()const { m_ar2DDrableBufPtrs_.removeAll(); }

bool AecDbEntityCommon::Draw3DBuffers(AcGiDraw &dc) const
{
	if (m_ar3DDrableBufPtrs_.isEmpty())
		return false;

	for (int i = 0; i < m_ar3DDrableBufPtrs_.length(); ++i)
		dc.DrawEntity(*(AcDbEntity *)m_ar3DDrableBufPtrs_[i]);

	return true;
}

const AcDbVoidPtrArray& AecDbEntityCommon::Get3DBuffer() const { return m_ar3DDrableBufPtrs_; }

bool AecDbEntityCommon::Has3DBuffer() const { return !m_ar3DDrableBufPtrs_.isEmpty(); }

void AecDbEntityCommon::Add3DBuffer(AcDbEntity * pEnt) const
{
	if (pEnt && m_ar3DDrableBufPtrs_.find(pEnt) == -1)
		m_ar3DDrableBufPtrs_.append(pEnt);
}

void AecDbEntityCommon::Add3DBuffer(const AcDbVoidPtrArray & arr) const
{
	for (int i = 0; i < arr.length(); ++i)
		Add3DBuffer((AcDbEntity *)arr[i]);
}

bool AecDbEntityCommon::IsIn3DBuffer(AcDbEntity *pEnt) const
{
	if (-1 == m_ar3DDrableBufPtrs_.find(pEnt))
		return false;
	return true;
}

void AecDbEntityCommon::Clean3DBuffer()const
{
	FreeBuffer(0, m_ar3DDrableBufPtrs_);
	m_ar3DDrableBufPtrs_.removeAll();
}

void AecDbEntityCommon::Clean3DBufferNoDel()const { m_ar3DDrableBufPtrs_.removeAll(); }

Acad::ErrorStatus AecDbEntityCommon::ReCreateDraw2d()
{
	GetMe()->assertWriteEnabled();
	Clean2DBuffer();
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEntityCommon::ReCreateDraw3d()
{
	GetMe()->assertWriteEnabled();
	Clean3DBuffer();
	return Acad::eOk;
}


int AecDbEntityCommon::GetDrawDimCur() const { return m_nDrawDimCur; }

CString AecDbEntityCommon::getUniqueName() const { return _T(""); }

int AecDbEntityCommon::GetExplodeMode() const
{

	int nDrawMode = GetDrawMode();
	DrawModeType nDrawType = k2Dand3D;
	int nDraw = GetDrawDimOnType(nDrawMode, nDrawType);

	if (nDraw == 1)
	{
		nDraw = DRAW_2D;
	}
	else if (nDraw == 2)
	{
		nDraw = DRAW_3D;
	}
	else if (nDraw == 3)
	{
		ads_point pt;
		struct resbuf rb;
		acedGetVar(_T("VIEWDIR"), &rb);
		ads_point_set(rb.resval.rpoint, pt);

		ads_point viewDir;
		acdbUcs2Wcs(pt, viewDir, false);

		if (fabs(viewDir[X]) > 1.0e-6 || fabs(viewDir[Y]) > 1.0e-6)
		{
			nDraw = DRAW_3D;
		}
		else
		{
			nDraw = DRAW_2D;
		}
	}
	return nDraw;
}

int AecDbEntityCommon::GetDrawMode()
{
	int nDrawMode = 3;
	//从命名字典中取,默认3

	return nDrawMode;
}

void AecDbEntityCommon::SetDrawMode(int nMode)
{
	//写入命名字典
}

void AecDbEntityCommon::BackupColorIndex(AcDbEntity* pEnt)
{
	if (pEnt != NULL)
	{
		struct resbuf* pXData = NULL;
		pXData = pEnt->xData(_T("COLOR_BK"));
		if (pXData == NULL)
		{
			struct resbuf* pTemp = acutNewRb(AcDb::kDxfRegAppName);
			acutNewString(_T("COLOR_BK"),pTemp->resval.rstring);
			pXData = pTemp;

			struct resbuf* pTempNext = NULL;
			pTempNext = acutNewRb(AcDb::kDxfXdInteger32);
			pTempNext->resval.rlong = pEnt->colorIndex();
			pTemp->rbnext = pTempNext;
			pTempNext->rbnext = NULL;

			acdbRegApp(_T("COLOR_BK"));	
			pEnt->setXData(pXData);
			acutRelRb(pXData);
		}
	}
}

int AecDbEntityCommon::SetBackupColorIndex(AcDbEntity* pEnt)
{
	int nColor = kColorByLayer;
	if (pEnt != NULL)
	{
		resbuf* pXData = NULL;
		pXData = pEnt->xData(_T("COLOR_BK"));
		if (pXData != NULL)
		{
			struct resbuf* pTempNext = pXData->rbnext;
			if (pTempNext != NULL)
			{
				if (pTempNext->restype == AcDb::kDxfXdInteger32)
				{
					nColor = pTempNext->resval.rint;
					pEnt->setColorIndex(nColor);
					// 存在清空
					struct resbuf* pTmp = acutNewRb(AcDb::kDxfRegAppName);
					pEnt->setXData(pTmp);
					acutRelRb(pXData);
					acutRelRb(pTmp);
				}
			}
		}
	}
	return nColor;
}

int AecDbEntityCommon::GetDrawDimOnType(int nDrawMode, int nDrawType) const
{
	int nDraw = 0; //0--NONE; 1--2D; 2--3D; 3--2D&3D;
	if (nDrawMode == DRAW_2D && (nDrawType == k2DOnly || nDrawType == k2Dand3D))
	{
		nDraw = 1;
	}
	else if (nDrawMode == DRAW_3D && (nDrawType == k3DOnly || nDrawType == k2Dand3D))
	{
		nDraw = 2;
	}
	else if (nDrawMode == (DRAW_2D | DRAW_3D) && nDrawType == k2Dand3D)
	{
		nDraw = 3;//转到viewportdraw
	}
	else if (nDrawMode == (DRAW_2D | DRAW_3D) && nDrawType == k2DOnly)
	{
		nDraw = 1;
	}
	else if (nDrawMode == (DRAW_2D | DRAW_3D) && nDrawType == k3DOnly)
	{
		nDraw = 2;
	}
	return nDraw;

}

typedef AcArray<AcDbEntity*> AcDbEntityArray;
void AecDbEntityCommon::PreprocessForHlr(const AcGePoint3d &ptPlnO
	, const AcGeVector3d &vtPlnN
	, AcDbEntityArray &ar) const
{
	GetMe()->assertReadEnabled();
	return;
}

void AecDbEntityCommon::ProcessHlrResult(const AcDbEntityArray &ar
	, const std::map<AcDbEntity*, AcDbEntityArray> &preAr
	, AcDbEntityArray &output) const
{
	GetMe()->assertReadEnabled();
	AcDbObjectId idLy(GetMe()->layerId()), idLt(GetMe()->linetypeId());
	int clr(GetMe()->colorIndex());

	const AecDbObjXDataMap *pXData = GetSpecialtyData();
	
	for (int i(0); i < ar.length(); ++i)
	{
		AcDbEntity *pEnt((AcDbEntity*)ar[i]->clone());
		if (pEnt)
		{
			if (pXData) 
				pXData->Write(pEnt, BIMDATA_APP);
			pEnt->setLayer(idLy);
			pEnt->setLinetype(idLt);
			pEnt->setColorIndex(clr);
			output.append(pEnt);
		}
	}
}

bool AecDbEntityCommon::GetBimInfoTip(CString& sInfoTip) const
{
	return false;
}

bool AecDbEntityCommon::GetProperties(SimpleProperty::PropertySetByIndex &porpertys) const
{
	GetMe()->assertReadEnabled();
	CString sLayer(_T("0"));
	TCHAR *pLayer = GetMe()->layer();
	if (pLayer)
	{
		sLayer = pLayer;
		acutDelString(pLayer);
	}

	SimpleProperty::makeAndInsert(porpertys, _T("图层"), sLayer, false);
	const AecDbObjXDataMap *pData = GetSpecialtyData();
	CString sys;
	if (pData->GetAt(PIPE_SYS, sys))
		SimpleProperty::makeAndInsert(porpertys, _T("分系统"), sys, false);
	return true;
}

bool AecDbEntityCommon::SetProperties(SimpleProperty::PropertySetByName & properties)
{
	AssertWriteEnabled();
	using namespace SimpleProperty;
	CString sVal(_T(""));
	if (properties.findAndSet(_T("图层"), sVal))
	{
		GetMe()->setLayer(sVal);
	}
	if (properties.findAndSet(_T("分系统"), sVal))
	{
		AecDbObjXDataMap *pData = GetSpecialtyData(AcDb::kForWrite);
		if (pData)
			pData->SetAt(PIPE_SYS, sVal);
	}
	return true;
}

double AecDbEntityCommon::GetVolume(bool bIsBody) const
{
	GetMe()->assertReadEnabled();

	if (!Has3DBuffer())
	{
		AcGiViewDraw dc(NULL, NULL);
		Draw3d(dc);
	}

	double dVol = 0.0, dVolAll = 0.0, momInertia[3], prodInertia[3], prinMoments[3], radiiGyration[3];
	AcGePoint3d ptCen;
	AcGeVector3d prinAxes[3];
	AcDbExtents extents;

	AcDbVoidPtrArray arEntPtrs;
	GetDraw3dables(arEntPtrs);

	AcDbEntity *pEnt = NULL;
	for (int i = 0; i < arEntPtrs.length(); i++)
	{
		pEnt = (AcDbEntity *)arEntPtrs.at(i);

		AcDb3dSolid *pSolid = AcDb3dSolid::cast(pEnt);
		if (pSolid != NULL)
		{
			pSolid->getMassProp(dVol, ptCen, momInertia, prodInertia, prinMoments, prinAxes, radiiGyration, extents);
			dVolAll += dVol;
		}
	}
	return dVolAll;
}

int AecDbEntityCommon::GetDraw2dables(Adesk::UInt16 nDrawStyle, AcDbVoidPtrArray &arEntPtrs) const
{
	GetMe()->assertReadEnabled();

	AcDbEntity* pEnt = NULL,*pEntT = NULL;
	const AcDbVoidPtrArray &ar2D = Get2DBuffer();
	for (int i = 0;i < ar2D.length();i++)
	{
		pEnt = (AcDbEntity*)ar2D.at(i);
		pEntT = (AcDbEntity*)pEnt->clone();

		pEntT->setLayer(GetMe()->layerId());
		arEntPtrs.append(pEntT);
	}
	return arEntPtrs.length();
}

int  AecDbEntityCommon::GetDraw3dables(AcDbVoidPtrArray& arEntPtrs,bool bWriteBimInfo) const
{
	GetMe()->assertReadEnabled();

	const AecDbObjXDataMap* pXDataMap = GetSpecialtyData();
	if (pXDataMap != NULL)
	{
		AcDbEntity* pEnt = NULL,*pEntClone = NULL;

		if (!Has3DBuffer())
		{
			AcGiViewDraw dc(NULL, NULL);
			Draw3d(dc);
		}

		const AcDbVoidPtrArray &ar3D = Get3DBuffer();
		for (int i = 0;i < ar3D.length();i++)
		{
			pEnt = (AcDbEntity*)ar3D.at(i);
			pEntClone = (AcDbEntity*)pEnt->clone();

			int nColor = 0;
			if ( pXDataMap->GetAt(_T("COLOR"),nColor) )
			{
				pEntClone->setColorIndex(nColor);
			}
			else
			{
				pEntClone->setColorIndex(GetMe()->colorIndex());
			}
			pEntClone->setLayer(GetMe()->layerId());
			if (bWriteBimInfo)
			{
				pXDataMap->Write(pEntClone,_T("BIMDATA"));
			}
			arEntPtrs.append(pEntClone);
		}
	}
	return arEntPtrs.length();
}

SHJson::WValue& AecDbEntityCommon::ToJson(bool bExprotGeo) const
{
	GetMe()->assertReadEnabled();
	using namespace SHJson;
	WValue &v(m_json);
	v.SetObject();
	addMember(v, _T("__class__"), GetMe()->isA()->name());
	addMember(v, _T("__self__"), GetMe()->objectId().asOldId());
	addMember(v, _T("__owner__"), 0);

	const AecDbObjXDataMap *pXMap = GetSpecialtyData();
	if (pXMap)
	{
		addMember(v, _T("__xdata__"), pXMap->ToJson());
	}

	return v;
}

bool AecDbEntityCommon::ByJson(const SHJson::WValue &v)
{
	using namespace SHJson;
	AssertWriteEnabled();
	AecDbObjXDataMap *pXMap = GetSpecialtyData(AcDb::kForWrite);
	if (pXMap)
	{
		MCIt it = v.FindMember(_T("__xdata__"));
		if (it != v.MemberEnd())
			return pXMap->ByJson(it->value);
	}
	return true;
}

bool AecDbEntityCommon::GetSectionHatchPattern(CString& sPattern) const
{
	GetMe()->assertReadEnabled();

	CString sMat;
	if (GetSpecialtyData()->GetAt(KEY_SECTION_HATCH, sMat))
	{
		sPattern = sMat;
		if (sMat == HATCH_NO_NEED)
			return false;

		if (sMat != HATCH_DEFAULT)
			return true;
	}
	if ( GetSpecialtyData()->GetAt(KEY_MATERIAL,sMat))
	{
		//以后从外部配置文件中获取
		//钢筋混凝土
		//石材
		//砖墙
		//填充墙体
		//轻质隔墙
		//玻璃幕墙

		sPattern = _T("AR-CONC");//默认
		if (sMat.CompareNoCase(_T("钢筋混凝土")) == 0)
		{
			sPattern = _T("钢筋混凝土");
		}
		else if(sMat.CompareNoCase(_T("混凝土")) == 0)
		{
			sPattern = _T("混凝土");
		}
		else if(sMat.CompareNoCase(_T("石材")) == 0)
		{
			sPattern = _T("天然石材");
		}
		else if(sMat.CompareNoCase(_T("砖墙")) == 0)
		{
			sPattern = _T("普通砖");
		}
		else if(sMat.CompareNoCase(_T("填充墙体")) == 0)
		{
			sPattern = _T("钢筋混凝土");
		}
		else if(sMat.CompareNoCase(_T("轻质隔墙")) == 0)
		{
			sPattern = _T("混凝土");
		}
		else if(sMat.CompareNoCase(_T("玻璃幕墙")) == 0)
		{
			sPattern = _T("玻璃砖墙");
		}
	}
	return true;
}

void AecDbEntityCommon::BoolSubtractHide() const
{
}

Acad::ErrorStatus AecDbEntityCommon::subGet3dGeomExtents(AcDbExtents &extents) const
{
	AcDbVoidPtrArray entSet;
	if (!Has3DBuffer())
	{
		AcGiViewDraw dc(NULL, NULL);
		Draw3d(dc);
	}
	entSet.append(Get3DBuffer());

	if (entSet.isEmpty())
		return Acad::eNullExtents;

	BOOL bInit = TRUE;
	AcGePoint3d ptMax, ptMin;
	AcDbExtents ext, extT;

	int len = entSet.length();
	for (int i = 0; i < len; i++)
	{
		AcDbEntity *pEnt = (AcDbEntity *)entSet[i];

		if (pEnt->getGeomExtents(extT) == Acad::eOk)
		{
			ext.addExt(extT);
		}
	}

	AcGePoint3d ptLow, ptUp;
	ptLow = ext.minPoint();
	ptUp = ext.maxPoint();
	extents.set(ptLow, ptUp);

	return Acad::eOk;
}

void AecDbEntityCommon::Add3DBoolSubtract(AcDb3dSolid* pSolidBlackHole)
{
	GetMe()->assertWriteEnabled();

	const AcDbVoidPtrArray& ar3D_ = Get3DBuffer();
	AcDbVoidPtrArray ar3D;
	ar3D.append(ar3D_);

	AcDbEntity* pEnt = NULL;
	AcDb3dSolid* pSolid = NULL;
	AcDb3dSolid* pSolidCln = NULL;
	AcDb3dSolid* pSolidNotGet = NULL;
	Acad::ErrorStatus es;

	Adesk::Boolean bSlidInterface = Adesk::kFalse;
	double dArea1 = 0.0,dArea2 = 0.0;

	for (int i = 0;i < ar3D.length();i++)
	{
		pEnt = (AcDbEntity*)ar3D.at(i);

		pSolid = AcDb3dSolid::cast(pEnt);
		if (pSolid != NULL)
		{
			pSolidCln = (AcDb3dSolid*)pSolidBlackHole->clone();

			//有交集才处理
			if ( Acad::eOk == pSolid->checkInterference( pSolidCln,Adesk::kFalse,bSlidInterface,pSolidNotGet))
			{
				pSolid->getArea(dArea1);

				es = pSolid->booleanOper(AcDb::kBoolSubtract,pSolidCln);

				pSolid->getArea(dArea2);

				if ( es ==  Acad::eOk)
				{
					pSolid->recordGraphicsModified(Adesk::kTrue);

					if ( fabs(dArea1 - dArea2) < 1.e-3)//没有变化，被包含
					{
						ar3D.removeAt(i);
						m_ar3DDrableBufPtrs_.removeAt(i);
						i -= 1;
					}
				}
				else if ( es == Acad::eGeneralModelingFailure )
				{
					ar3D.removeAt(i);
					m_ar3DDrableBufPtrs_.removeAt(i);
					i -= 1;
				}
				//delete pSolidCln;			
			}
		}
	}
}

void AecDbEntityCommon::Remove3DBoolSubtract()
{
	GetMe()->assertWriteEnabled();

	//清除3D,重建
	Clean3DBuffer();
}

void AecDbEntityCommon::AddBlackHole(AcDbObjectId& idHole)
{
	AssertWriteEnabled();

	AecDbObjXDataMap* pXdataMap = GetSpecialtyData(AcDb::kForWrite);
	if (pXdataMap != NULL)
	{
		TCHAR szHand[19];
		memset(szHand,0,sizeof(szHand) );
		idHole.handle().getIntoAsciiBuffer(szHand);

		CString sKey;
		sKey.Format(_T("%s_%s"),KEY_HOLE,szHand);
		pXdataMap->SetAt(sKey,idHole.handle());
	}
}

void AecDbEntityCommon::RemoveBlackHole(AcDbObjectId& idHole)
{
	AssertWriteEnabled();

	AecDbObjXDataMap* pXdataMap = GetSpecialtyData(AcDb::kForWrite);
	if (pXdataMap != NULL)
	{
		TCHAR szHand[19];
		memset(szHand,0,sizeof(szHand) );
		idHole.handle().getIntoAsciiBuffer(szHand);

		CString sKey;
		sKey.Format(_T("%s_%s"),KEY_HOLE,szHand);
		pXdataMap->RemoveAt(sKey);
	}
}

void AecDbEntityCommon::DrawBlackHole(AcDbEntity* pSolidEnt) const
{
	AcDb3dSolid* pSolidAll = AcDb3dSolid::cast(pSolidEnt);
	if (pSolidAll == NULL)
		return;

	const AecDbObjXDataMap* pCXDataMap = GetSpecialtyData();
	if (pCXDataMap != NULL)
	{
		AecDbObjXDataMap* pXDataMap = (AecDbObjXDataMap*)pCXDataMap;
		AecDbObjXDataMap::It it = pXDataMap->Begin();
		AecDbObjXDataMap::It end = pXDataMap->End();

		CString sKey;

		AecXData cVal;
		memset(&cVal,0,sizeof(AecXData));

		AcDbEntity* pEnt = NULL;
		AcDbHandle hd;
		AcDbObjectId idHole;

		for (; it != end; )
		{
			if (!pXDataMap->GetNext(it, sKey, cVal))
				break;

			if (sKey.Find(KEY_HOLE) != -1)
			{
				pXDataMap->GetAt(sKey,hd);
				if ( Acad::eOk == acdbCurDwg()->getAcDbObjectId(idHole,false,hd) )
				{
					if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,idHole,AcDb::kForRead))
					{
						if (IsThisMe(pEnt))
						{
							AecDbEntityCommon *pBlackHole = dynamic_cast<AecDbEntityCommon*>(pEnt);
							if (pBlackHole != NULL)
							{
								AcDb3dSolid *pSolidBlackHold = pBlackHole->GetBlackHole();
								if (pSolidBlackHold != NULL)
								{
									pSolidAll->booleanOper(AcDb::kBoolSubtract, pSolidBlackHold);
								}
							}
						}
						pEnt->close();
					}
				}
			}
		}
	}
}

void AecDbEntityCommon::UpdateDrableSpecData(LPCTSTR pszApp,LPCTSTR pszKey,CString& sVal)
{
	GetMe()->assertWriteEnabled();

	AecDbObjXDataMap xDataMap;
	AcDbEntity* pEnt = NULL,*pEntT = NULL;
	const AcDbVoidPtrArray &ar2D = Get2DBuffer();
	for (int i = 0;i < ar2D.length();i++)
	{
		pEnt = (AcDbEntity*)ar2D.at(i);
		
		if (xDataMap.Read(pEnt,pszApp))
		{
			xDataMap.RemoveAt(pszKey);
			xDataMap.SetAt(pszKey,sVal);
			xDataMap.Write(pEnt,pszApp);
		}
	}

	const AcDbVoidPtrArray &ar3D = Get3DBuffer();
	for (int i = 0;i < ar3D.length();i++)
	{
		pEnt = (AcDbEntity*)ar3D.at(i);
		if (xDataMap.Read(pEnt,pszApp))
		{
			xDataMap.RemoveAt(pszKey);
			xDataMap.SetAt(pszKey,sVal);
			xDataMap.Write(pEnt,pszApp);
		}
	}
}

extern double PixelToWcs(int nPixel);
bool AecDbEntityCommon::SubAddHitEditGrip(AcDbGripDataPtrArray &grips) const
{
	GetMe()->assertReadEnabled();

	AecGripData *pGrip = NULL;
	GetPositionGrip(grips.length() - 1, pGrip);

	if (pGrip != NULL)
	{
		AcGePoint3d ptHit = pGrip->ptGrip;
		ptHit += AcGeVector3d::kXAxis * PixelToWcs(30);

		AecGripData *pGrip2 = new AecGripData;
		memset(pGrip2, 0, sizeof(AecGripData));

		pGrip2->nIndex = grips.length();
		pGrip2->ePos = eHitEdit;
		pGrip2->nColor = kRed;
		pGrip2->ptGrip = ptHit;
		_tcscpy(pGrip2->szTip, _T("点击修改"));
		_tcscpy(pGrip2->szID, _T("HITEDIT_2023"));
		pGrip2->pOwner = (AcDbEntity *)GetMe();
		pGrip2->idHost = GetMe()->objectId();
		AcDbGripData *pGripData = new AcDbGripData;
		pGripData->setGripPoint(ptHit);
		pGripData->setAppData((void *)pGrip2);
		pGripData->setWorldDraw(AecGripCback::WorldDrawfunc);
		pGripData->setToolTipFunc(AecGripCback::GripToolTipFunc);
		grips.append(pGripData);

		return true;
	}

	return false;
}

//不得导出,需要数据,增加特定的获取函数
extern AecDbObjXDataMap g_mapGlobalData;
bool AecDbEntityCommon::HitOnGripEdit(const AcDbVoidPtrArray &gripAppData)
{
	AecGripData *pAppData = NULL;
	AcDbIntArray arIndex;

	if (gripAppData.isEmpty())
	{
		return Acad::eOk;
	}

	pAppData = (AecGripData *)gripAppData.first();
	if (pAppData->ePos == eHitEdit)
	{
		//命令名 DBL_DXFNAME
		TCHAR szCmd[65];
		_tcscpy(szCmd, _T("DBL_"));
		_tcscat(szCmd, GetMe()->isA()->dxfName());

		//判断命令是否存在
		AcEdCommand *pCmd = acedRegCmds->lookupLocalCmd(szCmd);
		if (pCmd != NULL)
		{
			//发送ID 到 USERI;
			AcDbObjectId id = pAppData->idHost;

			g_mapGlobalData.SetAt(szCmd, id);

			acedPostCommand(_T("\x03"));

			_tcscat(szCmd, _T(" "));
			acedPostCommand(szCmd);
		}
		else
		{
			acutPrintf(_T("\nLocalCmd %s does not exist!"), szCmd);
		}
		return true;
	}
	return false;
}

//按分隔符拆字符串。来源：AecDbEntityBase.cpp / AecDbCurveBase.cpp（两族逐字相同）
void AecDbEntityCommon::SplitStrintToArray(LPCTSTR pszDescr, CStringArray & arInfo, TCHAR tcSpace)
{
	if (pszDescr == NULL) return;

	CString sDescr = pszDescr;
	int nLen = sDescr.GetLength();
	int i = 0;
	CString sText = _T("");
	TCHAR tchar = _T('\0');

	for (i = 0; i < nLen; i++)
	{
		tchar = sDescr.GetAt(i);
		if (tchar == tcSpace)
		{
			if (!sText.IsEmpty())
				arInfo.Add(sText);
			sText = _T("");
		}
		else
		{
			sText += tchar;
		}

		if (i == nLen - 1 && !sText.IsEmpty())
		{
			arInfo.Add(sText);
		}
	}
}

// 世界绘制：原 AecDbEntityBase::subWorldDraw / AecDbCurveBase::subWorldDraw 逐行一致。
// subWorldDraw 是 AcGiDrawable 的虚函数，本类不在 AcDb 继承链上，只能由两个根各自转发。
Adesk::Boolean AecDbEntityCommon::base_WorldDraw(AcGiWorldDraw *pWd)
{
	GetMe()->assertReadEnabled();

	m_eExplodeOrDrawType = kWroldDraw;
	AcGiViewDraw dc(pWd, NULL);
	dc.SetDrawRaw(GetMe());

	//1.如果是保存代理图形
	AcGiRegenType nRegenType = pWd->regenType();
	if (nRegenType == kAcGiSaveWorldDrawForProxy)
	{
		ads_point pt;
		struct resbuf rb;
		acedGetVar(_T("VIEWDIR"),&rb);
		ads_point_set(rb.resval.rpoint,pt);

		ads_point viewDir;
		acdbUcs2Wcs(pt,viewDir,false);

		if (fabs(viewDir[X]) > 1.0e-6 || fabs(viewDir[Y]) > 1.0e-6)
		{
			Draw3d(dc);
			m_nDrawDimCur = 3;
		}
		else
		{
			Draw2d(dc);
			m_nDrawDimCur = 2;
		}
		return Adesk::kTrue;
	}

	//设属性
	dc.SetLayer(_T("0"));
	dc.SetColor(256);

	//如果图层关闭
	AcDbLayerTableRecordPointer pLayer;
	if ( Acad::eOk == pLayer.open(GetMe()->layerId(), AcDb::kForRead) )
	{
		if ( pLayer->isOff() )
		{
			return Adesk::kTrue;
		}
	}

	int nDrawMode = GetDrawMode();
	DrawModeType nDrawType = k2Dand3D;
	int nDraw = GetDrawDimOnType(nDrawMode, nDrawType);

	if (nRegenType == kAcGiSaveWorldDrawForProxy
		|| nRegenType == kAcGiSaveWorldDrawForR12)
	{
		if (!!GetMe()->ownerId())
		{
			pWd->subEntityTraits().setSelectionMarker(0);
			dc.SetColor(GetMe()->colorIndex());
			dc.SetLayer(GetMe()->layerId());
		}

		if ((nDrawMode & DRAW_2D) && (nDrawType != k3DOnly))
		{
			Draw2d(dc);
			m_nDrawDimCur = 2;
		}
		else if ((nDrawMode & DRAW_3D) && (nDrawType != k2DOnly))
		{
			Draw3d(dc);
			m_nDrawDimCur = 3;
		}
		return Adesk::kTrue;
	}
	return Adesk::kFalse;
}

// 视口绘制：原 AecDbEntityBase::subViewportDraw / AecDbCurveBase::subViewportDraw 逐行一致。
// 同样是 AcGiDrawable 的虚函数，只能由两个根各自转发。
void AecDbEntityCommon::base_ViewportDraw(AcGiViewportDraw* pMode)
{
	GetMe()->assertReadEnabled();
	m_eExplodeOrDrawType = kViewportDraw;

	AcGiRegenType nRegenType = pMode->regenType();
	AcGiViewport &vp = pMode->viewport();

	AcGePoint3d ptCamera, ptTarget;
	vp.getCameraTarget(ptTarget);
	vp.getCameraLocation(ptCamera);

	AcGeVector3d vtViewDrt = ptCamera-ptTarget;
	AcGeVector3d vtViewDir1 = vp.viewDir();

	AcGeVector3d vtCamera;
	vp.getCameraUpVector(vtCamera);

	vtViewDrt.normalize();
	AcGiViewDraw dc(NULL, pMode);
	dc.SetDrawRaw(GetMe());

	// 设属性
	dc.SetLayer(_T("0"));
	dc.SetColor(256);

	//如果图层关闭
	AcDbLayerTableRecordPointer pLayer;
	if ( Acad::eOk == pLayer.open(GetMe()->layerId(), AcDb::kForRead) )
	{
		if ( pLayer->isOff() )
		{
			return;
		}
	}

	if (!!GetMe()->ownerId())
	{
		pMode->subEntityTraits().setSelectionMarker(0);
		dc.SetColor(GetMe()->colorIndex());
		dc.SetLayer(GetMe()->layerId());
	}

	int nDrawMode = GetDrawMode();
	DrawModeType nDrawType = k2Dand3D;
	int nDraw = GetDrawDimOnType(nDrawMode, nDrawType);

	if (nDraw == 3)
	{
		if	(  nRegenType == kAcGiRenderCommand
			|| nRegenType == kAcGiHideOrShadeCommand
			|| vp.isPerspective()
			|| vtViewDrt != AcGeVector3d(0,0,1))
		{
			Draw3d(dc);
			m_nDrawDimCur = 3;
		}
		else
		{
			Draw2d(dc);
			m_nDrawDimCur = 2;
		}
	}
	else if (nDraw == 1)
	{
		Draw2d(dc);
		m_nDrawDimCur = 2;
	}
	else if (nDraw == 2)
	{
		Draw3d(dc);
		m_nDrawDimCur = 3;
	}
}

// 保存代理实体图元：原两个根的 saveAs 逐行一致。
void AecDbEntityCommon::base_SaveAs(AcGiWorldDraw *pWd, AcDb::SaveType saveType)
{
	AecDbObjXDataMap xDataMap;
	ReadModelXData(EW_EARTHWORMINIT, xDataMap, NULL);
	int nSaveToProxy(0);
	xDataMap.GetAt(_T("SaveToProxy"), nSaveToProxy);
	if (nSaveToProxy == 0) // 不保存代理图形
		return;

	AcGiRegenType rtype = pWd->regenType();
	if (rtype == kAcGiSaveWorldDrawForProxy)
	{
		// 走实体自己的 subWorldDraw（子类可能重写），不是 Common 的 base_WorldDraw
		CallWorldDraw(pWd);
	}
	else
	{
		GetMe()->AcDbEntity::saveAs(pWd, saveType);
	}
}

// 视口绘制标志：原两个根的 subViewportDrawLogicalFlags 逐行一致。
// nBaseFlags 由两个根用 AcDbEntity::subViewportDrawLogicalFlags(vd) 取到后传入——
// 该接口在 AcGiDrawable / AcDbObject 里是 protected，本类不在继承链上取不到。
Adesk::UInt32 AecDbEntityCommon::base_ViewportDrawLogicalFlags(Adesk::UInt32 nBaseFlags)
{
	Adesk::UInt32 nFlagNew = nBaseFlags;
	int nDrawMode = GetDrawMode();
	DrawModeType nDrawType = k2Dand3D;
	int nDraw = GetDrawDimOnType(nDrawMode, nDrawType);

	if (nDraw != 3)
	{
		nFlagNew |= AcGiDrawable::kDrawableViewIndependentViewportDraw;
	}
	else
	{
		nFlagNew |= AcGiDrawable::kDrawableRegenDraw;
	}
	return nFlagNew;
}

// 绘制属性：原两个根的 subSetAttributes 逐行一致，同样是 protected，base 结果由根传入。
Adesk::UInt32 AecDbEntityCommon::base_SetAttributes(Adesk::UInt32 nBaseFlags)
{
	int nDrawMode = GetDrawMode();
	DrawModeType nDrawType = k2Dand3D;
	int nDraw = GetDrawDimOnType(nDrawMode, nDrawType);

	Adesk::UInt32 nFlagNew = nBaseFlags;
	nFlagNew |= AcGiDrawable::kDrawableViewIndependentViewportDraw;

	return nFlagNew;
}

// 炸开：原两个根的 subExplode 逐行一致。
Acad::ErrorStatus AecDbEntityCommon::base_Explode(AcDbVoidPtrArray& entitySet) const
{
	ExplodeOrDrawType& eExplodeType = (ExplodeOrDrawType&)m_eExplodeOrDrawType;
	eExplodeType = kExplode;

	int expMode = GetExplodeMode();
	if (expMode == 1)
	{
		GetDraw2dables(0,entitySet);
	}
	else if (expMode == 2)
	{
		GetDraw3dables(entitySet);
	}
	return Acad::eOk;
}

// 几何范围：原 AecDbEntityBase::subGetGeomExtents / AecDbCurveBase::subGetGeomExtents 逐行一致。
Acad::ErrorStatus AecDbEntityCommon::base_GetGeomExtents(AcDbExtents& extents) const
{
	AcGePoint3d ptLow, ptUp;

	AcDbVoidPtrArray entSet;
	int expMode = GetExplodeMode();
	if (expMode == 1)
	{
		entSet.append(Get2DBuffer());
	}
	else if (expMode == 2)
	{
		entSet.append(Get3DBuffer());
	}

	BOOL bInit = TRUE;
	AcGePoint3d ptMax,ptMin;
	AcDbExtents ext,extT;

	int len = entSet.length();
	for (int i = 0; i < len; i++)
	{
		AcDbEntity *pEnt = (AcDbEntity *)entSet[i];

		if (pEnt->getGeomExtents(extT) == Acad::eOk)
		{
			ext.addExt(extT);
		}
	}
	ptLow = ext.minPoint();
	ptUp = ext.maxPoint();
	extents.set(ptLow, ptUp);

	return Acad::eOk;
}

// 对象捕捉点：原两个根的 subGetOsnapPoints（第一个重载）逐行一致。
Acad::ErrorStatus AecDbEntityCommon::base_GetOsnapPoints(	 AcDb::OsnapMode		osnapMode,
														 INT_PTR		gsSelectionMark,
														 const AcGePoint3d&  ptPick,
														 const AcGePoint3d&  lastPoint,
														 const AcGeMatrix3d& viewXform,
														 AcGePoint3dArray&   snapPoints,
														 AcDbIntArray&		geomIds) const
{
	GetMe()->assertReadEnabled();

	AcDbVoidPtrArray entSet;
	int expMode = GetExplodeMode();
	if (expMode == 1)
	{
		entSet.append(Get2DBuffer());
	}
	else if (expMode == 2)
	{
		entSet.append(Get3DBuffer());
	}

	Acad::ErrorStatus es = Acad::eOk;
	if (es == Acad::eOk)
	{
		int len = entSet.length();
		for (int i = 0; i < len; i++)
		{
			AcDbEntity *pEnt=(AcDbEntity *)entSet[i];
			if (pEnt->isKindOf(AcDbText::desc()))
			{
				if (osnapMode == AcDb::kOsModeIns)
				{
					snapPoints.append(AcDbText::cast(pEnt)->position());
				}
				else
				{
					continue;
				}
			}

			es = pEnt->getOsnapPoints(osnapMode, 0, ptPick, lastPoint, viewXform,
				snapPoints,  geomIds);
		}
		es = Acad::eOk;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEntityCommon::base_DeepClone(	AcDbObject*    pOwner,
											   AcDbObject*&   pClonedObject,
											   AcDbIdMapping& idMap,
											   Adesk::Boolean isPrimary) const
{
	// You should always pass back pClonedObject == NULL
	// if, for any reason, you do not actually clone it
	// during this call.  The caller should pass it in
	// as NULL, but to be safe, we set it here as well.
	//
	pClonedObject = NULL;

	// If this object is in the idMap and is already
	// cloned, then return.
	//
	bool isPrim = false;
	if (isPrimary)
		isPrim = true;
	AcDbIdPair idPair(GetMe()->objectId(), (AcDbObjectId)NULL,
		false, isPrim);
	if (idMap.compute(idPair) && (idPair.value() != NULL))
		return Acad::eOk;    

	// Create the clone
	//
	AcDbEntity *pClone = (AcDbEntity*)GetMe()->isA()->create();
	AecDbEntityCommon *pCloneCommon = dynamic_cast<AecDbEntityCommon *>(pClone);
	if (pClone != NULL && pCloneCommon != NULL)
		pClonedObject = pClone;    // set the return value
	else
		return Acad::eOutOfMemory;

	AcDbDeepCloneFiler filer;
	GetMe()->dwgOut(&filer);

	filer.seek(0L, AcDb::kSeekFromStart);
	pClone->dwgIn(&filer);
	pCloneCommon->NewGUID();
	pClone->setLayer(GetMe()->layerId());

	bool bOwnerXlated = false;
	if (isPrimary)
	{
		AcDbBlockTableRecord *pBTR =
			AcDbBlockTableRecord::cast(pOwner);
		if (pBTR != NULL)
		{
			pBTR->appendAcDbEntity(pClone);
			bOwnerXlated = true;
		}
		else
		{
			pOwner->database()->addAcDbObject(pClone);
		}
	} else {
		pOwner->database()->addAcDbObject(pClone);
		pClone->setOwnerId(pOwner->objectId());
		bOwnerXlated = true;
	}

	// This must be called for all newly created objects
	// in deepClone.  It is turned off by endDeepClone()
	// after it has translated the references to their
	// new values.
	//
	pClone->setAcDbObjectIdsInFlux();
	pClone->disableUndoRecording(true);


	// Add the new information to the idMap.  We can use
	// the idPair started above.
	//
	idPair.setValue(pClonedObject->objectId());
	idPair.setIsCloned(Adesk::kTrue);
	idPair.setIsOwnerXlated(bOwnerXlated);
	idMap.assign(idPair);

	// Using the filer list created above, find and clone
	// any owned objects.
	//
	AcDbObjectId id;
	while (filer.getNextOwnedObject(id)) {

		AcDbObject *pSubObject(NULL);
		AcDbObject *pClonedSubObject(NULL);

		// Some object's references may be set to NULL, 
		// so don't try to clone them.
		//
		if (id == NULL)
			continue;

		// Open the object and clone it.  Note that we now
		// set "isPrimary" to kFalse here because the object
		// is being cloned, not as part of the primary set,
		// but because it is owned by something in the
		// primary set.
		//
		acdbOpenAcDbObject(pSubObject, id, AcDb::kForRead);
		if (pSubObject == NULL)
			continue;
		pClonedSubObject = NULL;
		pSubObject->deepClone(pClonedObject,
			pClonedSubObject,
			idMap, Adesk::kFalse);

		// If this is a kDcInsert context, the objects
		// may be "cheapCloned".  In this case, they are
		// "moved" instead of cloned.  The result is that
		// pSubObject and pClonedSubObject will point to
		// the same object.  So, we only want to close
		// pSubObject if it really is a different object
		// than its clone.
		//
		if (pSubObject != pClonedSubObject)
			pSubObject->close();

		// The pSubObject may either already have been
		// cloned, or for some reason has chosen not to be
		// cloned.  In that case, the returned pointer will
		// be NULL.  Otherwise, since we have no immediate
		// use for it now, we can close the clone.
		//
		if (pClonedSubObject != NULL)
			pClonedSubObject->close();
	}

	//xdataMap 复制
	//到mep中找建立新的关系
	AecDbObjXDataMap* pXDataMapCloned = pCloneCommon->GetSpecialtyData();
	AecDbObjXDataMap* pXDataMap = (AecDbObjXDataMap*)GetSpecialtyData();

	if (pXDataMap != NULL && pXDataMapCloned != NULL)
	{
		pXDataMapCloned->CopyFrom(pXDataMap);
		//发送提资需要相同的ID
		Adesk::Int16 nVal = acdbCurDwg()->useri4();
		if (nVal != KEY_NOPROTECT)
		{
			int nVt = 0;
			CString sID = IDCreate();
			if (pXDataMapCloned->HasKey(KEY_NO, nVt))
			{
				pXDataMapCloned->SetAt(KEY_NO, sID);
			}
		}

		AecDbObjXDataMap::It it = pXDataMap->Begin();
		AecDbObjXDataMap::It end = pXDataMap->End();

		CString sKey;
		CStringArray arHandKeys;

		AecXData cVal;
		memset(&cVal,0,sizeof(AecXData));

		AcDbObjectId idSrc,idCloned;
		for (; it != end; )
		{
			if (!pXDataMap->GetNext(it, sKey, cVal)) break;
			if (cVal.nVt == AecXData::kTypeSoftId || cVal.nVt == AecXData::kTypeHardId)//soft,hard
			{
				idSrc.setFromOldId(cVal.nVal);

				AcDbObject *pSubObject;
				AcDbObject *pClonedSubObject;

				// Some object's references may be set to NULL, 
				// so don't try to clone them.
				//
				if (idSrc == NULL)
					continue;

				AcDbIdPair idPair2(idSrc, (AcDbObjectId)NULL,
					false, isPrim);
				if (idMap.compute(idPair2) && (idPair2.value() != NULL))
				{
					if (pXDataMapCloned != NULL)
					{
						pXDataMapCloned->RemoveAt(sKey);
						pXDataMapCloned->SetAt(sKey, idPair2.value(), cVal.nVt == AecXData::kTypeSoftId ? TRUE : FALSE);
					}
					continue;
				}

				// Open the object and clone it.  Note that we now
				// set "isPrimary" to kFalse here because the object
				// is being cloned, not as part of the primary set,
				// but because it is owned by something in the
				// primary set.
				//
				pSubObject = NULL;
				acdbOpenAcDbObject(pSubObject, idSrc, AcDb::kForRead);
				pClonedSubObject = NULL;

				if (pSubObject != NULL)
				{
					//只考虑上华AEC的实体
					LPCTSTR pszDxf = pSubObject->isA()->dxfName();
					if (_tcsstr(pszDxf, _T("AEC_'")) != NULL)
					{
						pSubObject->deepClone(pClonedObject,
							pClonedSubObject,
							idMap, Adesk::kFalse);
					}
					else
					{
						pSubObject->close();
						pSubObject = NULL;
					}
				}

				// If this is a kDcInsert context, the objects
				// may be "cheapCloned".  In this case, they are
				// "moved" instead of cloned.  The result is that
				// pSubObject and pClonedSubObject will point to
				// the same object.  So, we only want to close
				// pSubObject if it really is a different object
				// than its clone.
				//
				if (pSubObject != NULL && pSubObject != pClonedSubObject)
					pSubObject->close();

				// The pSubObject may either already have been
				// cloned, or for some reason has chosen not to be
				// cloned.  In that case, the returned pointer will
				// be NULL.  Otherwise, since we have no immediate
				// use for it now, we can close the clone.
				//
				if (pClonedSubObject != NULL)
					idCloned = pClonedSubObject->objectId();

				if (pClonedSubObject != NULL)
					pClonedSubObject->close();

				if (pXDataMapCloned != NULL && idCloned.isValid())
				{
					pXDataMapCloned->RemoveAt(sKey);
					pXDataMapCloned->SetAt(sKey, idCloned, cVal.nVt == AecXData::kTypeSoftId ? TRUE : FALSE);
				}
				idCloned = AcDbObjectId::kNull;
			}
			else if (sKey.Find(_T("$H")) != -1 && cVal.nVt == AecXData::kTypeString)//可能的实体句柄
			{
				arHandKeys.Add(sKey);
			}
		}

		//2022-05-04 需要测试
		CString sHand;
		AcDbHandle hd;
		for (int n = 0; n < arHandKeys.GetSize(); n++)
		{
			sKey = arHandKeys.GetAt(n);
			sHand = sKey;
			sHand.TrimRight(_T("$H"));

			AcDbHandle handle(sHand);

			AcDbObjectId idSrc;
			if (Acad::eOk == acdbCurDwg()->getAcDbObjectId(idSrc, false, handle))
			{
				AcDbObject *pSubObject;
				AcDbObject *pClonedSubObject;

				// Some object's references may be set to NULL, 
				// so don't try to clone them.
				//
				if (idSrc == NULL)
					continue;

				AcDbIdPair idPair2(idSrc, (AcDbObjectId)NULL,
					false, isPrim);
				if (idMap.compute(idPair2) && (idPair2.value() != NULL))
				{
					CString sKeyNew;
					//sKey.Format(_T("%s$H"),szHand);

					if (pXDataMapCloned != NULL)
					{
						TCHAR szHand[19];
						memset(szHand, 0, sizeof(szHand));
						idPair2.value().handle().getIntoAsciiBuffer(szHand);
						sKeyNew.Format(_T("%s$H"), szHand);

						pXDataMapCloned->RemoveAt(sKey);
						pXDataMapCloned->SetAt(sKeyNew, szHand);
					}
					continue;
				}

				// Open the object and clone it.  Note that we now
				// set "isPrimary" to kFalse here because the object
				// is being cloned, not as part of the primary set,
				// but because it is owned by something in the
				// primary set.
				//
				pSubObject = NULL;
				acdbOpenAcDbObject(pSubObject, idSrc, AcDb::kForRead);
				pClonedSubObject = NULL;

				if (pSubObject != NULL)
				{
					//只考虑上华AEC的实体
					LPCTSTR pszDxf = pSubObject->isA()->dxfName();
					if (_tcsstr(pszDxf, _T("AEC_'")) != NULL)
					{
						pSubObject->deepClone(pClonedObject,
							pClonedSubObject,
							idMap, Adesk::kFalse);
					}
					else
					{
						pSubObject->close();
						pSubObject = NULL;
					}
				}

				// If this is a kDcInsert context, the objects
				// may be "cheapCloned".  In this case, they are
				// "moved" instead of cloned.  The result is that
				// pSubObject and pClonedSubObject will point to
				// the same object.  So, we only want to close
				// pSubObject if it really is a different object
				// than its clone.
				//
				if (pSubObject != pClonedSubObject)
					pSubObject->close();

				// The pSubObject may either already have been
				// cloned, or for some reason has chosen not to be
				// cloned.  In that case, the returned pointer will
				// be NULL.  Otherwise, since we have no immediate
				// use for it now, we can close the clone.
				//
				if (pClonedSubObject != NULL)
					idCloned = pClonedSubObject->objectId();

				if (pClonedSubObject != NULL)
					pClonedSubObject->close();

				if (pXDataMapCloned != NULL && idCloned.isValid())
				{
					CString sKeyNew;
					TCHAR szHand[19];
					memset(szHand, 0, sizeof(szHand));

					idCloned.handle().getIntoAsciiBuffer(szHand);
					sKeyNew.Format(_T("%s$H"), szHand);

					pXDataMapCloned->RemoveAt(sKey);
					pXDataMapCloned->SetAt(sKeyNew, szHand);
				}
				idCloned = AcDbObjectId::kNull;
			}
		}
	}

	// Leave pClonedObject open for the caller
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEntityCommon::base_WblockClone(AcRxObject*    pOwner,
												 AcDbObject*&   pClonedObject,
												 AcDbIdMapping& idMap,
												 Adesk::Boolean isPrimary) const
{
	// You should always pass back pClonedObject == NULL
	// if, for any reason, you do not actually clone it
	// during this call.  The caller should pass it in
	// as NULL, but to be safe, we set it here as well.
	//
	pClonedObject = NULL;

	// fast wblock（源库与目标库相同）不做任何克隆，交回 AcDb 一侧。
	AcDbDatabase *pDest, *pOrig;
	idMap.destDb(pDest);
	idMap.origDb(pOrig);
	if (pDest == pOrig)
		return CallAcDbWblockClone(pOwner, pClonedObject, idMap, isPrimary);

	// If this is an Xref bind operation and this AsdkPoly
	// entity is in Paper Space,  then we don't want to
	// clone because Xref bind doesn't support cloning
	// entities in Paper Space.  So we simply return
	// Acad::eOk
	//
	AcDbObjectId pspace;
	AcDbBlockTable *pTable(NULL);
	GetMe()->database()->getSymbolTable(pTable, AcDb::kForRead);
	if (pTable == NULL)
		return Acad::eOk;
	pTable->getAt(ACDB_PAPER_SPACE, pspace);
	pTable->close();

	if (idMap.deepCloneContext() == AcDb::kDcXrefBind
		&& GetMe()->ownerId() == pspace)
		return Acad::eOk;

	// If this object is in the idMap and is already
	// cloned, then return.
	//
	bool isPrim = false;
	if (isPrimary)
		isPrim = true;

	AcDbIdPair idPair(GetMe()->objectId(), (AcDbObjectId)NULL,
		false, isPrim);
	if (idMap.compute(idPair) && (idPair.value() != NULL))
		return Acad::eOk;

	// The owner object can be either an AcDbObject, or an
	// AcDbDatabase.  AcDbDatabase is used if the caller is
	// not the owner of the object being cloned (because it
	// is being cloned as part of an AcDbHardPointerId
	// reference).  In this case, the correct ownership
	// will be set during reference translation.  So, if
	// the owner is an AcDbDatabase, then pOwn will be left
	// NULL here, and is used as a "flag" later.
	//

	AcDbObject *pOwn = AcDbObject::cast(pOwner);
	AcDbDatabase *pDb = AcDbDatabase::cast(pOwner);
	if (pDb == NULL)
		pDb = pOwn->database();

	// STEP 1:
	// Create the clone
	//
	AcDbEntity *pClone = (AcDbEntity*)GetMe()->isA()->create();
	AecDbEntityCommon *pCloneCommon(NULL);
	if (pClone)
	{
		pCloneCommon = dynamic_cast<AecDbEntityCommon *>(pClone);
		if (pCloneCommon != NULL)
			pClonedObject = pClone;    // set the return value
		else
		{
			DELETE_PTR(pClone);
			return Acad::eOutOfMemory;
		}
	}
	else
		return Acad::eOutOfMemory;


	// STEP 2:
	// If the owner is an AcDbBlockTableRecord, go ahead
	// and append the clone.  If not, but we know who the
	// owner is, set the clone's ownerId to it.  Otherwise,
	// we set the clone's ownerId to our own ownerId (in
	// other words, the original owner Id).  This Id will
	// then be used later, in reference translation, as
	// a key to finding who the new owner should be.  This
	// means that the original owner must also be cloned at
	// some point during the wblock operation. 
	// EndDeepClone's reference translation aborts if the
	// owner is not found in the idMap.
	//
	// The most common situation where this happens is
	// AcDbEntity references to Symbol Table Records, such
	// as the Layer an Entity is on.  This is when you will
	// have to pass in the destination database as the owner
	// of the Layer Table Record.  Since all Symbol Tables
	// are always cloned in Wblock, you do not need to make
	// sure that Symbol Table Record owners are cloned. 
	//
	// However, if the owner is one of your own classes,
	// then it is up to you to make sure that it gets
	// cloned.  This is probably easiest to do at the end
	// of this function.  Otherwise you may have problems
	// with recursion when the owner, in turn, attempts
	// to clone this object as one of its subObjects.
	// 
	AcDbBlockTableRecord *pBTR = NULL;
	if (pOwn != NULL)
		pBTR = AcDbBlockTableRecord::cast(pOwn);
	if (pBTR != NULL && isPrimary) {
		pBTR->appendAcDbEntity(pClone);
	}
	else {
		pDb->addAcDbObject(pClonedObject);
	}

	// STEP 3:
	// The AcDbWblockCloneFiler makes a list of
	// AcDbHardOwnershipIds and AcDbHardPointerIds.  These
	// are the references which must be cloned during a
	// Wblock operation.
	//
	AcDbWblockCloneFiler filer;
	GetMe()->dwgOut(&filer);

	// STEP 4:
	// Rewind the filer and read the data into the clone.
	//
	filer.seek(0L, AcDb::kSeekFromStart);
	pClone->dwgIn(&filer);
	pCloneCommon->NewGUID();

	idMap.assign(AcDbIdPair(GetMe()->objectId(), pClonedObject->objectId(), Adesk::kTrue,
		isPrim, (Adesk::Boolean)(pOwn != NULL)));

	pClonedObject->setOwnerId((pOwn != NULL) ?
		pOwn->objectId() : GetMe()->ownerId());

	// STEP 5:
	// This must be called for all newly created objects
	// in wblockClone.  It is turned off by endDeepClone()
	// after it has translated the references to their
	// new values.
	//
	pClone->setAcDbObjectIdsInFlux();

	// STEP 6:
	// Add the new information to the idMap.  We can use
	// the idPair started above.  We must also let the
	// idMap entry know whether the clone's owner is
	// correct, or needs to be translated later.
	//

	// STEP 7:
	// Using the filer list created above, find and clone
	// any hard references.
	//

	AcDbObjectId id;
	while (filer.getNextHardObject(id))
	{
		AcDbObject *pSubObject(NULL);
		AcDbObject *pClonedSubObject(NULL);

		// Some object's references may be set to NULL, 
		// so don't try to clone them.
		//
		if (id == NULL)
			continue;

		// If the referenced object is from a different
		// database, such as an xref, do not clone it.
		//
		acdbOpenAcDbObject(pSubObject, id, AcDb::kForRead);
		if (pSubObject == NULL)
			continue;
		if (pSubObject->database() != GetMe()->database()) {
			pSubObject->close();
			continue;
		}

		// We can find out if this is an AcDbHardPointerId
		// verses an AcDbHardOwnershipId, by seeing if we
		// are the owner of the pSubObject.  If we are not,
		// then we cannot pass our clone in as the owner
		// for the pSubObject's clone.  In that case, we
		// pass in our clone's database (the destination
		// database).
		// 
		// Note that we now set "isPrimary" to kFalse here
		// because the object is being cloned, not as part
		// of the primary set, but because it is owned by
		// something in the primary set.
		//
		pClonedSubObject = NULL;
		if (pSubObject->ownerId() == GetMe()->objectId()) {
			pSubObject->wblockClone(pClone,
				pClonedSubObject,
				idMap, Adesk::kFalse);
		}
		else {
			pSubObject->wblockClone(pClone->database(),
				pClonedSubObject,
				idMap, Adesk::kFalse);
		}
		pSubObject->close();

		// The pSubObject may either already have been
		// cloned, or for some reason has chosen not to be
		// cloned.  In that case, the returned pointer will
		// be NULL.  Otherwise, since we have no immediate
		// use for it now, we can close the clone.
		//
		if (pClonedSubObject != NULL)
			pClonedSubObject->close();
	}

	//xdataMap 复制
	//到mep中找建立新的关系

	AecDbObjXDataMap *pXDataMapCloned = pCloneCommon->GetSpecialtyData();


	AecDbObjXDataMap *pXDataMap = (AecDbObjXDataMap *)GetSpecialtyData();

	if (pXDataMap != NULL && pXDataMapCloned != NULL)
	{
		//发送提资需要相同的ID
		Adesk::Int16 nVal = acdbCurDwg()->useri4();
		if (nVal != KEY_NOPROTECT)
		{
			int nVt = 0;
			CString sID = IDCreate();
			if (pXDataMapCloned->HasKey(KEY_NO, nVt))
			{
				pXDataMapCloned->SetAt(KEY_NO, sID);
			}
		}

		AecDbObjXDataMap::It it = pXDataMap->Begin();
		AecDbObjXDataMap::It end = pXDataMap->End();

		CString sKey;
		CStringArray arHandKeys;

		AecXData cVal;
		memset(&cVal, 0, sizeof(AecXData));

		AcDbObjectId idSrc, idCloned;
		for (; it != end;)
		{
			if (!pXDataMap->GetNext(it, sKey, cVal)) break;
			if (cVal.nVt == AecXData::kTypeSoftId || cVal.nVt == AecXData::kTypeHardId)//soft,hard
			{
				idSrc.setFromOldId(cVal.nVal);

				AcDbObject *pSubObject;
				AcDbObject *pClonedSubObject;

				// Some object's references may be set to NULL, 
				// so don't try to clone them.
				//
				if (idSrc == NULL)
					continue;

				AcDbIdPair idPair2(idSrc, (AcDbObjectId)NULL,
					false, isPrim);
				if (idMap.compute(idPair2) && (idPair2.value() != NULL))
				{
					if (pXDataMapCloned != NULL)
					{
						pXDataMapCloned->SetAt(sKey, idPair2.value(), cVal.nVt == AecXData::kTypeSoftId ? TRUE : FALSE);
					}
					continue;
				}

				// Open the object and clone it.  Note that we now
				// set "isPrimary" to kFalse here because the object
				// is being cloned, not as part of the primary set,
				// but because it is owned by something in the
				// primary set.
				//
				acdbOpenAcDbObject(pSubObject, idSrc, AcDb::kForRead);
				if (pSubObject == NULL)
					continue;
				pClonedSubObject = NULL;

				if (pSubObject->ownerId() == GetMe()->objectId()) {
					pSubObject->wblockClone(pClone,
						pClonedSubObject,
						idMap, Adesk::kFalse);
				}
				else {
					pSubObject->wblockClone(pClone->database(),
						pClonedSubObject,
						idMap, Adesk::kFalse);
				}

				// If this is a kDcInsert context, the objects
				// may be "cheapCloned".  In this case, they are
				// "moved" instead of cloned.  The result is that
				// pSubObject and pClonedSubObject will point to
				// the same object.  So, we only want to close
				// pSubObject if it really is a different object
				// than its clone.
				//
				if (pSubObject != NULL && pSubObject != pClonedSubObject)
					pSubObject->close();

				// The pSubObject may either already have been
				// cloned, or for some reason has chosen not to be
				// cloned.  In that case, the returned pointer will
				// be NULL.  Otherwise, since we have no immediate
				// use for it now, we can close the clone.
				//
				if (pClonedSubObject != NULL)
					idCloned = pClonedSubObject->objectId();

				if (pClonedSubObject != NULL)
					pClonedSubObject->close();

				if (pXDataMapCloned != NULL && idCloned.isValid())
				{
					pXDataMapCloned->RemoveAt(sKey);
					pXDataMapCloned->SetAt(sKey, idCloned, cVal.nVt == AecXData::kTypeSoftId ? TRUE : FALSE);
				}
				idCloned = AcDbObjectId::kNull;
			}
			else if (sKey.Find(_T("$H")) != -1 && cVal.nVt == AecXData::kTypeString)//可能的实体句柄
			{
				arHandKeys.Add(sKey);
			}
		}
	}
	return Acad::eOk;
}