ObjectArx块操作

PhdArxBlock.h

#pragma once
#include 
#include 



class PhdArxBlock final
{
public:
	static PhdArxBlock* Instance();

private:
	PhdArxBlock() = default;

	static std::unique_ptr m_self;	//声明静态对象

public:

//#pragma region 普通块
	//得到块定义中的所有实体id（通过块名和数据库指针）
	bool GetAllEntId(AcDbObjectIdArray& arrid, LPCTSTR szBlkTblRcdName,
		AcDbDatabase* pDb = acdbCurDwg()) const;
	//得到块定义中的所有实体id（通过块定义id）
	bool GetAllEntId(AcDbObjectIdArray& arrid,const AcDbObjectId& idBlkTblRcd) const;

	//得到块定义id（通过块名和数据库指针）
	bool GetBlkDefId(AcDbObjectId& idBlkDef,LPCTSTR szBlkName,AcDbDatabase* pDb = acdbCurDwg()) const;
	//得到块定义id（通过块参照id）
	bool GetBlkDefId(AcDbObjectId& idBlkDef, const AcDbObjectId& idBlkRef) const;
	//得到块定义id（通过图纸、块名和数据库指针；如果数据库中没有该块定义，就从目标图纸中拷贝到指定数据库中）
	bool GetBlkDefId(AcDbObjectId& idBlkDef,  LPCTSTR szDwgPath, LPCTSTR szBlkName,
		AcDbDatabase* pDb = acdbCurDwg()) const;

	//得到所有的块定义名（得到数据库中所有的块名）
	bool GetAllBlkDefName(AcArray& arrBlkDefName,AcDbDatabase* pDb = acdbCurDwg()) const;

	//得到所有的块定义id（得到数据库中所有的块定义id）
	bool GetAllBlkDefId(AcDbObjectIdArray& arridBlkDef,AcDbDatabase* pDb = acdbCurDwg()) const;

	//得到块名（通过块定义id或块参数id）
	bool GetBlkName(CString& strBlkName,const AcDbObjectId& idBlk) const;
	bool GetBlkName(CString& strBlkName,AcDbBlockReference* pBlkRef) const;

	//得到块参照的插入点
	bool GetBlkRefPosition(AcGePoint3d& pt,const AcDbObjectId& idBlkRef) const;

	//创建块定义(图纸作为一个块)（如果pDb存在szBlkName块定义，返回pDb中的块定义）
	bool CreateBlkDef(AcDbObjectId& idBlkDef, LPCTSTR szDwgPath, LPCTSTR szBlkName, AcDbDatabase* pDb = acdbCurDwg()) const;
	//创建块定义（如果pDb存在szBlkName块定义，返回pDb中的块定义）
	bool CreateBlkDef(AcDbObjectId& idBlkDef, const AcDbObjectIdArray& arrid, const AcGePoint3d& ptbase,
		LPCTSTR szBlkName,  AcDbDatabase* pDb = acdbCurDwg()) const;
	bool CreateBlkDef(AcDbObjectId& idBlkDef, const AcArray& arrpEnt, const AcGePoint3d& ptbase,
		LPCTSTR szBlkName, AcDbDatabase* pDb = acdbCurDwg()) const;

	//得到指定块名的块参照id
	bool GetBlkRefId(AcDbObjectId& idBlkRef,LPCTSTR szBlkName, AcDbDatabase* pDb = acdbCurDwg()) const;


//#pragma endregion

//#pragma region 属性块
	//该块参照存不存在该名字的属性名
	bool HaveAttTag(AcDbBlockReference* pAttBlkRef, LPCTSTR szAttTag) const;

	//得到属性块定义所有属性名
	bool GetAttBlkDefAllTag(AcArray& arrAttTag,const AcDbObjectId& idAttBlkDef) const;

	//得到属性块参照所有属性信息
	bool GetAttBlkRefAllAttInfo(std::map& mapAttInfo,const AcDbObjectId& idAttBlkRef) const;

	//得到属性块参照指定属性的文本
	bool GetAttTextOnBlkRef(CString& strAttText,const AcDbObjectId& idAttBlkRef, LPCTSTR szAttTag) const;
	bool GetAttTextOnBlkRef(CString& strAttText, AcDbBlockReference* pAttBlkRef, LPCTSTR szAttTag) const;

	//设置属性块参照属性信息
	bool SetAttBlkRefAttInfo(const AcDbObjectId& idAttBlkRef, LPCTSTR szTag, LPCTSTR szText) const;
	bool SetAttBlkRefAttInfo(AcDbBlockReference* pAttBlkRef, LPCTSTR szTag, LPCTSTR szText) const;
	bool SetAttBlkRefAttInfo(const AcDbObjectId& idAttBlkRef, const std::map& mapData) const;

	//创建属性块参照
	bool CreateAttBlkRef(AcDbBlockReference*& pAttBlkRef,const AcDbObjectId& idAttBlkDef, const AcGePoint3d& ptInsert) const;
	bool CreateAttBlkRef(AcDbBlockReference*& pAttBlkRef,const AcDbObjectId& idAttBlkDef, const AcGePoint3d& ptInsert,
		const std::map& mapAtt) const;

//#pragma endregion

//#pragma region 匿名块
	//创建匿名块（图纸作为块）
	bool CreateAnonyBlkDef(AcDbObjectId& idBlkDef, LPCTSTR szDwgPath,  AcDbDatabase* pDb = acdbCurDwg()) const;
	//创建匿名块（数据库中的实体作为块）
	bool CreateAnonyBlkDef(AcDbObjectId& idBlkDef, const AcDbObjectIdArray& arrid, const AcGePoint3d& ptbase,
		 AcDbDatabase* pDb = acdbCurDwg()) const;

	//判断是否是匿名块参照
	bool IsAnonyBlkRef(AcDbBlockReference* pBlkRef) const;

//#pragma endregion
};

//宏定义
#define g_ArxBlock PhdArxBlock::Instance()

PhdArxBlock.cpp

#include "stdafx.h"
#include "../stdafx.h"
#include "PhdArxBlock.h"

//初始化静态成员变量
std::unique_ptr PhdArxBlock::m_self;

PhdArxBlock* PhdArxBlock::Instance()
{
	//判断智能指针对象是否为空
	if (m_self.get() == nullptr)	//双重检查
	{
		//定义互斥量对象
		static std::mutex mutex;
		//定义智能锁对象
		std::lock_guard alock(mutex);
		//判断智能指针对象对否为空
		if (m_self.get() == nullptr)
		{
			//创建实例，并绑定智能指针
			m_self.reset(new PhdArxBlock);
		}
	}

	return m_self.get();
}

/) const
{
	AcDbBlockTableRecordPointer pBlkTblRcd(szBlkTblRcdName, pDb, AcDb::kForRead);
	if (pBlkTblRcd.openStatus() != Acad::eOk)
		return false;

	AcDbBlockTableRecordIterator* pBTRIter = NULL;
	Acad::ErrorStatus es = pBlkTblRcd->newIterator(pBTRIter);
	if (Acad::eOk != es)
		return false;
	//绑定智能指针
	std::unique_ptr apBTRIter(pBTRIter);

	for (apBTRIter->start(); !apBTRIter->done(); apBTRIter->step())
	{
		AcDbEntity* pTempEnt = NULL;
		es = apBTRIter->getEntity(pTempEnt, AcDb::kForRead);
		if (Acad::eOk != es)
			continue;
		arrid.append(pTempEnt->objectId());
		pTempEnt->close();
	}

	return true;
}

/) const
{
	AcDbBlockTableRecordPointer pBlkTblRec(szBlkName, pDb, AcDb::kForRead);
	if (Acad::eOk != pBlkTblRec.openStatus())
		return false;

	idBlkDef = pBlkTblRec->objectId();
	return true;
}

bool PhdArxBlock::GetBlkDefId(AcDbObjectId& idBlkDef, const AcDbObjectId& idBlkRef) const
{
	AcDbObjectPointer pRef(idBlkRef, AcDb::kForRead);
	if (Acad::eOk != pRef.openStatus())
		return false;

	idBlkDef = pRef->blockTableRecord();
	return true;
}

bool PhdArxBlock::GetBlkDefId(AcDbObjectId& idBlkDef, LPCTSTR szDwgPath, LPCTSTR szBlkName, AcDbDatabase* pDb ) const
{
	AcDbBlockTableRecordPointer pInsertBlkTblRcd(szBlkName, pDb, AcDb::kForRead);
	if (Acad::eOk == pInsertBlkTblRcd.openStatus())
	{
		idBlkDef = pInsertBlkTblRcd->objectId();//当前数据库存在该块，返回该块定义id
		return true;
	}

	//打开图纸
	AcDbDatabase* pDbDwg = new AcDbDatabase(false);
	std::unique_ptr apDbDwg(pDbDwg);
	//Acad::ErrorStatus es = apDbDwg->readDwgFile(szDwgPath, _SH_DENYNO);//zrx2010
	Acad::ErrorStatus es = apDbDwg->readDwgFile(szDwgPath, AcDbDatabase::kForReadAndAllShare);//arx2017
	if (Acad::eOk != es)
		return false;
	
	//从图纸数据库得到块定义id
	AcDbObjectId idTempBlkDef = AcDbObjectId::kNull;
	if (!GetBlkDefId(idTempBlkDef, szBlkName, apDbDwg.get()))
		return false;

	//将图纸数据库中的块定义拷贝到pDb数据库中
	if (!g_ArxDatabase->DbCopyOfBlock(apDbDwg.get(), idTempBlkDef, pDb, szBlkName, idBlkDef))
		return false;

	return true;
}

bool PhdArxBlock::GetAllBlkDefName(AcArray& arrBlkDefName, AcDbDatabase* pDb ) const
{
	AcDbBlockTablePointer pBlkTbl(pDb, AcDb::kForRead);
	if (Acad::eOk != pBlkTbl.openStatus())
		return false;
	AcDbBlockTableIterator* pIt = NULL;
	Acad::ErrorStatus es = pBlkTbl->newIterator(pIt);
	if (Acad::eOk != es)
		return false;
	std::unique_ptr apIt(pIt);

	for (apIt->start(); !apIt->done(); apIt->step())
	{
		AcDbBlockTableRecord* pBTRecord = NULL;
		if (apIt->getRecord(pBTRecord, AcDb::kForRead) == Acad::eOk)
		{
			TCHAR* szName = NULL;
			pBTRecord->getName(szName);
			CString BlockName = szName;
			if (_tcslen(szName) > 0)//过滤掉名称为空的块表;
			{
				if (BlockName.Find(_T("Model_Space")) == -1 && BlockName.Find(_T("Paper_Space")) == -1)
					arrBlkDefName.append(BlockName);
			}
			acutDelString(szName);//必须清除动态字符串;
			pBTRecord->close();
		}
	}

	return true;
}

bool PhdArxBlock::GetAllBlkDefId(AcDbObjectIdArray& arridBlkDef, AcDbDatabase* pDb ) const
{
	AcDbBlockTablePointer pBlkTbl(pDb, AcDb::kForRead);
	if (Acad::eOk != pBlkTbl.openStatus())
		return false;
	AcDbBlockTableIterator* pIt = NULL;
	Acad::ErrorStatus es = pBlkTbl->newIterator(pIt);
	if (Acad::eOk != es)
		return false;
	std::unique_ptr apIt(pIt);

	for (apIt->start(); !apIt->done(); apIt->step())
	{
		AcDbBlockTableRecord* pBTRecord = NULL;
		if (apIt->getRecord(pBTRecord, AcDb::kForRead) == Acad::eOk)
		{
			TCHAR* szName = NULL;
			pBTRecord->getName(szName);
			CString BlockName = szName;
			if (_tcslen(szName) > 0)//过滤掉名称为空的块表;
			{
				if (BlockName.Find(_T("Model_Space")) == -1 && BlockName.Find(_T("Paper_Space")) == -1)
					arridBlkDef.append(pBTRecord->objectId());
			}
			acutDelString(szName);//必须清除动态字符串;
			pBTRecord->close();
		}
	}

	return true;
}

bool PhdArxBlock::GetBlkName(CString& strBlkName, const AcDbObjectId& idBlk) const
{
	AcDbObjectId idBlkDef;

	AcDbObjectPointer pRef(idBlk, AcDb::kForRead);
	if (Acad::eOk == pRef.openStatus())
		idBlkDef = pRef->blockTableRecord();
	else
		idBlkDef = idBlk;

	AcDbBlockTableRecordPointer pBlkTblRcd(idBlkDef, AcDb::kForRead);
	if (Acad::eOk != pBlkTblRcd.openStatus())
		return false;
	TCHAR* szName = NULL;
	pBlkTblRcd->getName(szName);
	strBlkName = szName;
	acutDelString(szName);

	return true;
}

bool PhdArxBlock::GetBlkName(CString& strBlkName, AcDbBlockReference* pBlkRef) const
{
	AcDbObjectId idBlkDef = pBlkRef->blockTableRecord();
	AcDbBlockTableRecordPointer pBlkTblRcd(idBlkDef, AcDb::kForRead);
	if (Acad::eOk != pBlkTblRcd.openStatus())
		return false;
	TCHAR* szName = NULL;
	pBlkTblRcd->getName(szName);
	strBlkName = szName;
	acutDelString(szName);

	return true;
}

bool PhdArxBlock::GetBlkRefPosition(AcGePoint3d& pt, const AcDbObjectId& idBlkRef) const
{
	AcDbObjectPointer pRef(idBlkRef, AcDb::kForRead);
	if (Acad::eOk != pRef.openStatus())
		return false;

	pt = pRef->position();
	return true;
}

/) const
{
	if (GetBlkDefId(idBlkDef, szBlkName, pDb))
		return true;

	AcDbDatabase* pDbDwg = new AcDbDatabase(Adesk::kFalse);
	std::unique_ptr apDbDwg(pDbDwg);
	Acad::ErrorStatus es = apDbDwg->readDwgFile(szDwgPath);
	es = pDb->insert(idBlkDef, szBlkName, apDbDwg.get());
	if (es != Acad::eOk)
		return false;

	return true;
}

/) const
{
	if (GetBlkDefId(idBlkDef, szBlkName, pDb))
		return true;

	//打开块表
	AcDbBlockTablePointer pBlkTbl(pDb, AcDb::kForWrite);
	if (Acad::eOk != pBlkTbl.openStatus())
		return false;
	//创建块表记录
	AcDbBlockTableRecord* newBlkRec = new AcDbBlockTableRecord();
	Acad::ErrorStatus es = newBlkRec->setName(szBlkName);
	if (es != Acad::eOk)
	{
		delete newBlkRec;
		return false;
	}
	//将块表记录添加到块表中
	es = pBlkTbl->add(idBlkDef, newBlkRec);
	//将选中的实体，拷贝一份，添加到块表记录中
	AcDbObjectId idTemp;
	AcGeVector3d vec = AcGePoint3d::kOrigin - ptbase;
	AcGeMatrix3d mat;
	mat.setTranslation(vec);
	for (int i = 0; i < arrid.length(); i++)
	{
		AcDbEntityPointer pEnt(arrid[i], AcDb::kForRead);
		if (Acad::eOk != pEnt.openStatus())
			continue;
		AcDbEntity* pCopy = AcDbEntity::cast(pEnt->clone());
		pCopy->transformBy(mat);
		es = newBlkRec->appendAcDbEntity(idTemp, pCopy);
		pCopy->close();		//关闭实体
	}
	newBlkRec->close();		//关闭块表记录

	return true;
}

bool PhdArxBlock::CreateBlkDef(AcDbObjectId& idBlkDef, const AcArray& arrpEnt, 
	const AcGePoint3d& ptbase, LPCTSTR szBlkName, AcDbDatabase* pDb ) const
{
	if (GetBlkDefId(idBlkDef, szBlkName, pDb))
		return true;

	//打开块表
	AcDbBlockTablePointer pBlkTbl(pDb, AcDb::kForWrite);
	if (Acad::eOk != pBlkTbl.openStatus())
		return false;
	//创建块表记录
	AcDbBlockTableRecord* newBlkRec = new AcDbBlockTableRecord();
	Acad::ErrorStatus es = newBlkRec->setName(szBlkName);
	if (es != Acad::eOk)
	{
		delete newBlkRec;
		return false;
	}
	//将块表记录添加到块表中
	es = pBlkTbl->add(idBlkDef, newBlkRec);
	//将选中的实体，拷贝一份，添加到块表记录中
	AcDbObjectId idTemp;
	AcGeVector3d vec = AcGePoint3d::kOrigin - ptbase;
	AcGeMatrix3d mat;
	mat.setTranslation(vec);
	for (int i = 0; i < arrpEnt.length(); i++)
	{
		AcDbEntity* pCopy = AcDbEntity::cast(arrpEnt[i]->clone());
		pCopy->transformBy(mat);
		es = newBlkRec->appendAcDbEntity(idTemp, pCopy);
		pCopy->close();		//关闭实体
	}
	newBlkRec->close();		//关闭块表记录

	return true;
}

bool PhdArxBlock::GetBlkRefId(AcDbObjectId& idBlkRef, LPCTSTR szBlkName, AcDbDatabase* pDb ) const
{
	//打开模型空间的块表记录
	AcDbBlockTableRecordPointer pBlkTblRcd(ACDB_MODEL_SPACE, pDb, AcDb::kForRead);
	if (pBlkTblRcd.openStatus() != Acad::eOk)
		return false;

	//得到对应的块表记录迭代器
	AcDbBlockTableRecordIterator* pBTRIter = NULL;
	Acad::ErrorStatus es = pBlkTblRcd->newIterator(pBTRIter);
	if (Acad::eOk != es)
		return false;
	//绑定智能指针
	std::unique_ptr apBTRIter(pBTRIter);

	for (apBTRIter->start(); !apBTRIter->done(); apBTRIter->step())
	{
		AcDbEntity* pTempEnt = NULL;
		es = apBTRIter->getEntity(pTempEnt, AcDb::kForRead);
		if (Acad::eOk != es)
			continue;
		//是否是块参照
		if (!pTempEnt->isKindOf(AcDbBlockReference::desc()))
		{
			pTempEnt->close();
			continue;
		}
		//
		AcDbBlockReference* pBlkRef = AcDbBlockReference::cast(pTempEnt);
		CString strBlkName;
		if (!GetBlkName(strBlkName, pBlkRef))
		{
			pTempEnt->close();
			continue;
		}
		//
		if (_tcsicmp(szBlkName, strBlkName) == 0)
		{
			idBlkRef = pTempEnt->objectId();
			pTempEnt->close();
			return true;
		}

		pTempEnt->close();
	}

	return false;
}

bool PhdArxBlock::HaveAttTag(AcDbBlockReference* pAttBlkRef, LPCTSTR szAttTag) const
{
	AcDbObjectIterator* pIter = pAttBlkRef->attributeIterator();
	if (!pIter)
		return false;
	std::unique_ptr apIter(pIter);

	for (apIter->start(); !apIter->done(); apIter->step())
	{
		AcDbObjectId attId = apIter->objectId();
		AcDbAttribute* pAtt = NULL;
		if (pAttBlkRef->openAttribute(pAtt, attId, AcDb::kForRead) != Acad::eOk)
			continue;
		CString strTempTag = pAtt->tagConst();
		if (_tcsicmp(szAttTag, strTempTag) == 0)
		{
			pAtt->close();
			return true;
		}
		pAtt->close();
	}

	return false;
}

bool PhdArxBlock::GetAttBlkDefAllTag(AcArray& arrAttTag, const AcDbObjectId& idAttBlkDef) const
{
	AcDbBlockTableRecordPointer pBlkRc(idAttBlkDef, AcDb::kForRead);
	if (Acad::eOk != pBlkRc.openStatus())
		return false;
	if (!pBlkRc->hasAttributeDefinitions())
		return false;

	AcDbBlockTableRecordIterator* pIter = NULL;
	if (Acad::eOk != pBlkRc->newIterator(pIter))
		return false;
	std::unique_ptr apIter(pIter);

	AcDbObjectId attId;
	for (apIter->start(); !apIter->done(); apIter->step())
	{
		if (Acad::eOk != apIter->getEntityId(attId))
			continue;
		AcDbObjectPointer pDef(attId, AcDb::kForRead);
		if (Acad::eOk != pDef.openStatus())
			continue;
		arrAttTag.append(pDef->tagConst());
	}

	return true;
}

bool PhdArxBlock::GetAttBlkRefAllAttInfo(std::map& mapAttInfo, const AcDbObjectId& idAttBlkRef) const
{
	AcDbObjectPointer pBlkRef(idAttBlkRef, AcDb::kForRead);
	if (pBlkRef.openStatus() != Acad::eOk)
		return false;

	AcDbObjectIterator* pIter = pBlkRef->attributeIterator();
	if (!pIter)
		return false;
	std::unique_ptr apIter(pIter);

	for (apIter->start(); !apIter->done(); apIter->step())
	{
		AcDbObjectId attId = apIter->objectId();
		AcDbAttribute* pAtt = NULL;
		if (pBlkRef->openAttribute(pAtt, attId, AcDb::kForRead) != Acad::eOk)
			continue;
		mapAttInfo.insert(std::pair(pAtt->tagConst(), pAtt->textStringConst()));
		pAtt->close();
	}

	return true;
}

bool PhdArxBlock::GetAttTextOnBlkRef(CString& strAttText, const AcDbObjectId& idAttBlkRef, LPCTSTR szAttTag) const
{
	AcDbObjectPointer pBlkRef(idAttBlkRef, AcDb::kForRead);
	if (pBlkRef.openStatus() != Acad::eOk)
		return false;
	AcDbObjectIterator* pIter = pBlkRef->attributeIterator();
	if (!pIter)
		return false;
	std::unique_ptr apIter(pIter);

	bool bFind = false;
	for (apIter->start(); !apIter->done(); apIter->step())
	{
		AcDbObjectId attId = apIter->objectId();
		AcDbAttribute* pAtt = NULL;
		if (pBlkRef->openAttribute(pAtt, attId, AcDb::kForRead) != Acad::eOk)
			continue;
		CString strTempTag = pAtt->tagConst();
		if (_tcsicmp(szAttTag, strTempTag) == 0)
		{
			strAttText = pAtt->textStringConst();
			pAtt->close();
			bFind = true;
			break;
		}
		pAtt->close();
	}

	return bFind;
}

bool PhdArxBlock::GetAttTextOnBlkRef(CString& strAttText, AcDbBlockReference* pAttBlkRef, LPCTSTR szAttTag) const
{
	AcDbObjectIterator* pIter = pAttBlkRef->attributeIterator();
	if (!pIter)
		return false;
	std::unique_ptr apIter(pIter);

	bool bFind = false;
	for (apIter->start(); !apIter->done(); apIter->step())
	{
		AcDbObjectId attId = apIter->objectId();
		AcDbAttribute* pAtt = NULL;
		if (pAttBlkRef->openAttribute(pAtt, attId, AcDb::kForRead) != Acad::eOk)
			continue;
		CString strTempTag = pAtt->tagConst();
		if (_tcsicmp(szAttTag, strTempTag) == 0)
		{
			strAttText = pAtt->textStringConst();
			pAtt->close();
			bFind = true;
			break;
		}
		pAtt->close();
	}

	return bFind;
}

bool PhdArxBlock::SetAttBlkRefAttInfo(const AcDbObjectId& idAttBlkRef, LPCTSTR szTag, LPCTSTR szText) const
{
	AcDbObjectPointer pBlkRef(idAttBlkRef, AcDb::kForWrite);
	if (pBlkRef.openStatus() != Acad::eOk)
		return false;
	AcDbObjectIterator* pIter = pBlkRef->attributeIterator();
	if (!pIter)
		return false;
	std::unique_ptr apIter(pIter);

	bool bFlag = false;
	for (apIter->start(); !apIter->done(); apIter->step())
	{
		AcDbObjectId attId = apIter->objectId();
		AcDbAttribute* pAtt = NULL;
		if (pBlkRef->openAttribute(pAtt, attId, AcDb::kForWrite) != Acad::eOk)
			continue;
		CString strTempTag = pAtt->tagConst();
		if (_tcsicmp(szTag, strTempTag) == 0)
		{
			pAtt->setTextString(szText);
			pAtt->close();
			bFlag = true;
			break;
		}
		pAtt->close();
	}

	return bFlag;
}

bool PhdArxBlock::SetAttBlkRefAttInfo(AcDbBlockReference* pAttBlkRef, LPCTSTR szTag, LPCTSTR szText) const
{
	AcDbObjectIterator* pIter = pAttBlkRef->attributeIterator();
	if (!pIter)
		return false;
	std::unique_ptr apIter(pIter);

	bool bFlag = false;
	for (apIter->start(); !apIter->done(); apIter->step())
	{
		AcDbObjectId attId = apIter->objectId();
		AcDbAttribute* pAtt = NULL;
		if (pAttBlkRef->openAttribute(pAtt, attId, AcDb::kForWrite) != Acad::eOk)
			continue;
		CString strTempTag = pAtt->tagConst();
		if (_tcsicmp(szTag, strTempTag) == 0)
		{
			pAtt->setTextString(szText);
			pAtt->close();
			bFlag = true;
			break;
		}
		pAtt->close();
	}

	return bFlag;
}

bool PhdArxBlock::SetAttBlkRefAttInfo(const AcDbObjectId& idAttBlkRef, const std::map& mapData) const
{
	AcDbObjectPointer pBlkRef(idAttBlkRef, AcDb::kForWrite);
	if (pBlkRef.openStatus() != Acad::eOk)
		return false;
	AcDbObjectIterator* pIter = pBlkRef->attributeIterator();
	if (!pIter)
		return false;
	std::unique_ptr apIter(pIter);

	for (apIter->start(); !apIter->done(); apIter->step())
	{
		AcDbObjectId attId = apIter->objectId();
		AcDbAttribute* pAtt = NULL;
		if (pBlkRef->openAttribute(pAtt, attId, AcDb::kForWrite) != Acad::eOk)
			continue;
		CString strTempTag = pAtt->tagConst();

		auto iter = mapData.find(strTempTag);
		if (iter == mapData.end())
		{
			pAtt->close();
			continue;
		}
		pAtt->setTextString(iter->second);
		pAtt->close();
	}

	return true;
}

bool PhdArxBlock::CreateAttBlkRef(AcDbBlockReference*& pAttBlkRef, const AcDbObjectId& idAttBlkDef, const AcGePoint3d& ptInsert) const
{
	//判断指定的块表是否包含属性定义
	AcDbBlockTableRecordPointer pBlkTblRcd(idAttBlkDef, AcDb::kForWrite);
	if (Acad::eOk != pBlkTblRcd.openStatus())
		return false;
	if (!pBlkTblRcd->hasAttributeDefinitions())
		return false;

	//创建块表记录遍历器，用于访问块定义中的所有实体
	AcDbBlockTableRecordIterator* pIter = NULL;
	Acad::ErrorStatus es = pBlkTblRcd->newIterator(pIter);
	if (Acad::eOk != es)
		return false;
	std::unique_ptr apIter(pIter);

	//创建块参照
	pAttBlkRef = new AcDbBlockReference(ptInsert, idAttBlkDef);

	//遍历添加属性
	for (apIter->start(); !apIter->done(); apIter->step())
	{
		AcDbEntity* pEnt = NULL;
		if (Acad::eOk != apIter->getEntity(pEnt, AcDb::kForRead))
			continue;
		//如果是属性定义，就向块参照添加属性
		AcDbAttributeDefinition* pAttDef = AcDbAttributeDefinition::cast(pEnt);
		if (pAttDef != NULL)
		{
			//创建一个新的属性对象
			AcDbAttribute* pAtt = new AcDbAttribute();
			//从属性定义获得属性对象的对象特征
			pAtt->setPropertiesFrom(pAttBlkRef);
			pAtt->setLayer(pAttBlkRef->layerId());
			//设置属性对象的其它特性
			pAtt->setInvisible(pAttDef->isInvisible());
			pAtt->setPosition(pAttDef->position());
			pAtt->setHeight(pAttDef->height());
			pAtt->setWidthFactor(pAttDef->widthFactor());
			pAtt->setRotation(pAttDef->rotation());
			pAtt->setHorizontalMode(pAttDef->horizontalMode());
			pAtt->setVerticalMode(pAttDef->verticalMode());
			pAtt->setAlignmentPoint(pAttDef->alignmentPoint());
			pAtt->setTextStyle(pAttDef->textStyle());
			pAtt->setAttributeFromBlock(pAttBlkRef->blockTransform());
			//获得属性对象的Tag、prompt和TextString
			pAtt->setTag(pAttDef->tagConst());
			pAtt->setFieldLength(pAttDef->fieldLength());
			pAtt->setTextString(pAttDef->textStringConst());
			//设置颜色
			pAtt->setColorIndex(pAttDef->colorIndex());
			//向块参照追加属性对象
			pAttBlkRef->appendAttribute(pAtt);
			pAtt->close();
		}
		pEnt->close();
	}

	return true;
}

bool PhdArxBlock::CreateAttBlkRef(AcDbBlockReference*& pAttBlkRef, const AcDbObjectId& idAttBlkDef,
	const AcGePoint3d& ptInsert, const std::map& mapAtt) const
{
	//判断指定的块表是否包含属性定义
	AcDbBlockTableRecordPointer pBlkTblRcd(idAttBlkDef, AcDb::kForWrite);
	if (Acad::eOk != pBlkTblRcd.openStatus())
		return false;
	if (!pBlkTblRcd->hasAttributeDefinitions())
		return false;

	//创建块表记录遍历器，用于访问块定义中的所有实体
	AcDbBlockTableRecordIterator* pIter = NULL;
	Acad::ErrorStatus es = pBlkTblRcd->newIterator(pIter);
	if (Acad::eOk != es)
		return false;
	std::unique_ptr apIter(pIter);

	//创建块参照
	pAttBlkRef = new AcDbBlockReference(ptInsert, idAttBlkDef);

	//遍历添加属性
	for (apIter->start(); !apIter->done(); apIter->step())
	{
		AcDbEntity* pEnt = NULL;
		if (Acad::eOk != apIter->getEntity(pEnt, AcDb::kForRead))
			continue;
		//如果是属性定义，就向块参照添加属性
		AcDbAttributeDefinition* pAttDef = AcDbAttributeDefinition::cast(pEnt);
		if (pAttDef != NULL)
		{
			//创建一个新的属性对象
			AcDbAttribute* pAtt = new AcDbAttribute();
			//从属性定义获得属性对象的对象特征
			pAtt->setPropertiesFrom(pAttBlkRef);
			pAtt->setLayer(pAttBlkRef->layerId());
			//设置属性对象的其它特性
			pAtt->setInvisible(pAttDef->isInvisible());
			pAtt->setPosition(pAttDef->position());
			pAtt->setHeight(pAttDef->height());
			pAtt->setWidthFactor(pAttDef->widthFactor());
			pAtt->setRotation(pAttDef->rotation());
			pAtt->setHorizontalMode(pAttDef->horizontalMode());
			pAtt->setVerticalMode(pAttDef->verticalMode());
			pAtt->setAlignmentPoint(pAttDef->alignmentPoint());
			pAtt->setTextStyle(pAttDef->textStyle());
			pAtt->setAttributeFromBlock(pAttBlkRef->blockTransform());
			//获得属性对象的Tag、prompt和TextString
			pAtt->setTag(pAttDef->tagConst());
			pAtt->setFieldLength(pAttDef->fieldLength());

			auto iter = mapAtt.find(pAttDef->tagConst());
			if (iter != mapAtt.end())
				pAtt->setTextString(iter->second);
			else
				pAtt->setTextString(pAttDef->textStringConst());
	
			//向块参照追加属性对象
			pAttBlkRef->appendAttribute(pAtt);
			pAtt->close();
		}
		pEnt->close();
	}

	return true;
}

bool PhdArxBlock::CreateAnonyBlkDef(AcDbObjectId& idBlkDef, LPCTSTR szDwgPath, AcDbDatabase* pDb ) const
{
	AcDbDatabase* pDbDwg = new AcDbDatabase(Adesk::kFalse);
	std::unique_ptr apDbDwg(pDbDwg);

	Acad::ErrorStatus es = apDbDwg->readDwgFile(szDwgPath);
	es = pDb->insert(idBlkDef, _T("*U"), apDbDwg.get());
	if (es != Acad::eOk)
		return false;
	
	return true;
}

bool PhdArxBlock::CreateAnonyBlkDef(AcDbObjectId& idBlkDef, const AcDbObjectIdArray& arrid, 
	const AcGePoint3d& ptbase, AcDbDatabase* pDb ) const
{
	//打开块表
	AcDbBlockTablePointer pBlkTbl(pDb, AcDb::kForWrite);
	if (Acad::eOk != pBlkTbl.openStatus())
		return false;

	//创建匿名块表记录
	AcDbBlockTableRecord* newBlkRec = new AcDbBlockTableRecord;
	newBlkRec->setPathName(_T(""));    // constructor doesn't do it properly
	Acad::ErrorStatus es = newBlkRec->setName(_T("*U"));
	if (es != Acad::eOk)
	{
		delete newBlkRec;
		return false;
	}

	//添加到块表中
	es = pBlkTbl->add(idBlkDef, newBlkRec);

	AcDbObjectId idTemp;
	AcGeVector3d vec = AcGePoint3d::kOrigin - ptbase;
	AcGeMatrix3d mat;
	mat.setTranslation(vec);
	for (int i = 0; i < arrid.length(); i++)
	{
		AcDbEntityPointer pEnt(arrid[i], AcDb::kForRead);
		if (Acad::eOk != pEnt.openStatus())
			continue;
		AcDbEntity* pCopy = AcDbEntity::cast(pEnt->clone());
		pCopy->transformBy(mat);
		es = newBlkRec->appendAcDbEntity(idTemp, pCopy);
		pCopy->close();		//关闭实体
	}

	newBlkRec->close();		//关闭块表记录
	return true;
}

//************************************
// Summary:  判断是否是匿名块参照
// Parameter:
//	  pBlkRef -	输入块参照指针
// Return:	 true：是匿名块参照		false：不是匿名块参照
// Update Time: 2021-7-21 21:47:13
//************************************
bool PhdArxBlock::IsAnonyBlkRef(AcDbBlockReference* pBlkRef) const
{
	CString strBlkName;
	if (!g_ArxBlock->GetBlkName(strBlkName, pBlkRef))
		return false;

	if (strBlkName.Find(_T("*U")) != -1)
		return true;
	else
		return false;
}