899 lines
22 KiB
C++
899 lines
22 KiB
C++
#include "StdAfx.h"
|
|
#include "FindAndReplaceUtil.h"
|
|
|
|
extern TARCH_IMPEXP BOOL g_bTextStyleEx;
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Zyu add on 101019,抽象类，定义不同类型对象对应的查找替换方法
|
|
CFAREntity::CFAREntity()
|
|
{
|
|
}
|
|
|
|
CFAREntity::~CFAREntity()
|
|
{
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// 上华对象的查找替换类
|
|
// 搜索文字
|
|
TTextPosition CFARTDbEntity::FindText(AcDbEntity *pEnt, const TCHAR *sSubText, TTextPosition &posStart, TTextRange *pRange)
|
|
{
|
|
TTextPosition posFind;
|
|
|
|
TEntityBase *pText = NULL;
|
|
|
|
if (pEnt->isKindOf(TDbEntity::desc()))
|
|
{
|
|
pText = (TEntityBase*)TDbEntity::cast(pEnt);
|
|
}
|
|
else if (pEnt->isKindOf(TDbCurveEntity::desc()))
|
|
{
|
|
pText = (TEntityBase*)TDbCurveEntity::cast(pEnt);
|
|
}
|
|
|
|
if (NULL != pText&& pEnt->isReadEnabled())
|
|
{
|
|
posFind = pText->FindSubText(sSubText, posStart, pRange);
|
|
}
|
|
|
|
return posFind;
|
|
}
|
|
|
|
// 替换文字
|
|
TTextPosition CFARTDbEntity::ReplaceText(AcDbEntity *pEnt, TTextPosition posFind, const TCHAR *szRepText)
|
|
{
|
|
TTextPosition posStart;
|
|
TEntityBase *pText = NULL;
|
|
|
|
if (pEnt->isKindOf(TDbEntity::desc()))
|
|
{
|
|
pText = (TEntityBase*)TDbEntity::cast(pEnt);
|
|
}
|
|
else if (pEnt->isKindOf(TDbCurveEntity::desc()))
|
|
{
|
|
pText = (TEntityBase*)TDbCurveEntity::cast(pEnt);
|
|
}
|
|
|
|
if(NULL != pText && pEnt->isWriteEnabled())
|
|
{
|
|
posStart = pText->ReplaceSubText(posFind, szRepText);
|
|
}
|
|
return posStart;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// 块参照的查找替换类
|
|
CFARInsert::CFARInsert()
|
|
{
|
|
m_bFindAttrib = true;
|
|
m_bFindContent = true;
|
|
m_bFindXref = true;
|
|
m_bNoHidden = false;
|
|
}
|
|
|
|
|
|
// 查找文字
|
|
TTextPosition CFARInsert::FindText(AcDbEntity *pEnt, const TCHAR *sSubText, TTextPosition &posStart, TTextRange *pRange)
|
|
{
|
|
/*
|
|
算法描述：在块参照/外部参照中搜索文字对象的方法（支持查找块属性，支持块嵌套，支持动态块）
|
|
首先要明确的是，在块参照中只存在块属性的实体，块参照通过一个坐标系转换矩阵将对应的块表记录中的实体
|
|
表现出来，块表记录中存在块属性定义，它与块参照中的块属性对应，但在生成块参照之后，属性定义和属性之间就
|
|
不在相关，它们之间唯一的关系在于，当对参照和块表记录进行迭代遍历时，得到它们的顺序是相同的。对于动态块，
|
|
处于不可见性状态下的实体，在块表记录中，是以不可见状态（AcDb::kInvisible）保存的。
|
|
在CFARUtil类中，聚合了所有支持对象的查找替换方法类，当对一个实体进行查找时，首先被CFARUtil类进行分
|
|
析，根据实体类型匹配不同的查找方法，如果是一个块参照/外部参照，将使用如下描述的方法：
|
|
首先得到块参照中的 所有块属性的id，然后打开对应的块表记录，得到所有的块属性定义的id，形成块属性和
|
|
块属性定义的对应关系。
|
|
然后对块表记录进行迭代遍历，在遍历之前，首先要恢复到上一次搜索结束的位置。
|
|
最后，在遍历过程中得到的实体，都要根据其状态和查找选项的设置判断是否进一步查找，如果继续搜索，则创
|
|
建一个新的CFARUtil类来完成工作。
|
|
在这个查找的过程中，如果是嵌套的块，则会出现递归。类成员中的m_arObjId，记录了打开实体的顺序，用于
|
|
恢复上一次查找结束时，对应的实体。
|
|
*/
|
|
// 查找到的位置
|
|
TTextPosition posFind;
|
|
if (pEnt != NULL && pEnt->isReadEnabled())
|
|
{
|
|
// 转为块参照的指针
|
|
AcDbBlockReference *pRef = AcDbBlockReference::cast(pEnt);
|
|
if (NULL != pRef)
|
|
{
|
|
// 查找块属性文字
|
|
if (m_bFindAttrib)
|
|
{
|
|
// 得到块参照的所有属性ID
|
|
GetAttribIds(pRef);
|
|
}
|
|
// 块参照与块表记录中实体的位置转换矩阵
|
|
AcGeMatrix3d matrix = pRef->blockTransform();
|
|
|
|
// 打开块表记录
|
|
OPENOBJ_BEGIN(pRef->blockTableRecord(), AcDb::kForRead, AcDbBlockTableRecord, pBlkRec);
|
|
if (pBlkRec != NULL)
|
|
{
|
|
// 是否继续搜索
|
|
bool bContinue = false;
|
|
// 是否是外部参照
|
|
bool bIsXref = pBlkRec->isFromExternalReference() || pBlkRec->isFromOverlayReference();
|
|
// 不是外部参照或者可以查找外部参照，则继续查找
|
|
bContinue = !bIsXref || m_bFindXref;
|
|
|
|
if (bContinue)
|
|
{
|
|
if (m_bFindAttrib)
|
|
{
|
|
// 得到块表记录的所有属性定义的ID
|
|
GetAttribDefIds(pBlkRec);
|
|
}
|
|
|
|
// 对块表记录进行迭代查看
|
|
AcDbBlockTableRecordIterator *pIter = NULL;
|
|
if (Acad::eOk == pBlkRec->newIterator(pIter))
|
|
{
|
|
// 继续从上一次搜索结束的位置开始查找
|
|
// 调整迭代器指针，指向m_arObjId中的第一个id代表的实体
|
|
AcDbObjectId entId;
|
|
pIter->getEntityId(entId);
|
|
//wlw del 130708 测试信息应该删掉
|
|
SeekBlockRecIter(pIter);
|
|
pIter->getEntityId(entId);
|
|
for (; !pIter->done(); pIter->step())
|
|
{
|
|
AcDbEntity *pEntity = NULL;
|
|
// 打开块表记录中的实体
|
|
if (Acad::eOk == pIter->getEntity(pEntity, AcDb::kForRead))
|
|
{
|
|
// 判断实体是否满足搜索选项要求
|
|
if (ContinueFind(pEntity, bIsXref))
|
|
{
|
|
bool bIsAttrib = pEntity->isKindOf(AcDbAttributeDefinition::desc());
|
|
// 如果pEntity指向的是一个块属性定义，则令指针pEntity指向属性定义在块参照中对应的实体
|
|
if (bIsAttrib)
|
|
{
|
|
AcDbObjectId objIdAttrib;
|
|
// 匹配属性和属性定义的ID
|
|
int iIndex = -1;
|
|
m_arAttribDefId.find(pEntity->id(), iIndex);
|
|
if (iIndex > -1 && iIndex < m_arAttribId.length())
|
|
{
|
|
objIdAttrib = m_arAttribId.at(iIndex);
|
|
}
|
|
if (objIdAttrib.isValid())
|
|
{
|
|
AcDbEntity *pTempEnt = NULL;
|
|
// 打开对应的属性
|
|
if (Acad::eOk == acdbOpenAcDbEntity(pTempEnt, objIdAttrib, AcDb::kForRead))
|
|
{
|
|
pEntity->close();
|
|
pEntity = pTempEnt;
|
|
AcDbAttribute *pAttr = (AcDbAttribute*)pTempEnt;
|
|
CString strAttr = pAttr->textString();
|
|
}
|
|
}
|
|
}
|
|
|
|
// 使用查找替换工具类对pEntity进行进一步的查找
|
|
CFARUtil farUtil;
|
|
farUtil.SetFindOption(true, true, true, m_bNoHidden);
|
|
// 传递当前的id数组，以便进一步恢复现场
|
|
farUtil.SetEntityIds(m_arObjId);
|
|
posFind = farUtil.FindEntText(pEntity, sSubText, posStart, pRange);
|
|
|
|
// 查找成功
|
|
if (!!posFind)
|
|
{
|
|
AcDbObjectId __id = pEntity->id();
|
|
|
|
// 更新id数组
|
|
ClearObjIdArray(m_arObjId);
|
|
m_arObjId.append(farUtil.GetEntityIds());
|
|
m_arObjId.insertAt(0, pEntity->id());
|
|
|
|
// 如果当前的实体不是属性实体，则要将pRang指示框从块表记录
|
|
// 的坐标系转到块参照的坐标系
|
|
if (!bIsAttrib)
|
|
{
|
|
TransformRange(pRange, matrix);
|
|
}
|
|
pEntity->close();
|
|
break;
|
|
}
|
|
}
|
|
ClearObjIdArray(m_arObjId);
|
|
posStart.m_nCookies = 0;
|
|
posStart.m_nTextPos = -1;
|
|
pEntity->close();
|
|
}
|
|
}
|
|
if (pIter->done())
|
|
{
|
|
ClearObjIdArray(m_arAttribId);
|
|
ClearObjIdArray(m_arAttribDefId);
|
|
}
|
|
delete pIter;
|
|
}
|
|
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
}
|
|
return posFind;
|
|
}
|
|
|
|
// 替换文字
|
|
TTextPosition CFARInsert::ReplaceText(AcDbEntity *pEnt, TTextPosition posFind, const TCHAR *szRepText)
|
|
{
|
|
TTextPosition posStart;
|
|
if (m_arObjId.length() != 0 && m_arObjId.last().isValid())
|
|
{
|
|
// 打开ID对应的实体，调用查找替换工具类的方法进行替换
|
|
OPENOBJ_BEGIN(m_arObjId.last(), AcDb::kForWrite, AcDbEntity, pEntity);
|
|
CFARUtil farUtil;
|
|
posStart = farUtil.ReplaceEntText(pEntity, posFind, szRepText);
|
|
OPENOBJ_END();
|
|
}
|
|
return posStart;
|
|
}
|
|
|
|
// 设置实体数组
|
|
void CFARInsert::SetEntityIds(const AcDbObjectIdArray& arObjId)
|
|
{
|
|
m_arObjId.append(arObjId);
|
|
}
|
|
|
|
// 得到实体数组
|
|
const AcDbObjectIdArray& CFARInsert::GetEntityIds() const
|
|
{
|
|
return m_arObjId;
|
|
}
|
|
|
|
// 设置搜索选项
|
|
void CFARInsert::SetFindInsertOption(BOOL bFindAttrib, BOOL bFindContent, BOOL bFindXref, BOOL bNoHidden)
|
|
{
|
|
m_bFindAttrib = bFindAttrib;
|
|
m_bFindContent = bFindContent;
|
|
m_bFindXref = bFindXref;
|
|
m_bNoHidden = bNoHidden;
|
|
}
|
|
|
|
// 根据给出的矩阵关系，转换指示文本范围的线框位置
|
|
void CFARInsert::TransformRange(TTextRange *& pRange, const AcGeMatrix3d &matrix) const
|
|
{
|
|
if (pRange != NULL)
|
|
{
|
|
int iLen = pRange->m_lstRanges.Length();
|
|
for (int i = 0; i < iLen; i++)
|
|
{
|
|
pRange->m_lstRanges.GetAt(i)->TransformBy(matrix);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 得到块参照的所有属性ID
|
|
void CFARInsert::GetAttribIds(AcDbBlockReference *pRef)
|
|
{
|
|
// 如果内容不为空，说明当前是在查找同一实体，不重复进行遍历
|
|
if (m_arAttribId.length() != 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
AcDbObjectIterator *pObjIter = pRef->attributeIterator();
|
|
for (pObjIter->start(); !pObjIter->done(); pObjIter->step())
|
|
{
|
|
m_arAttribId.append(pObjIter->objectId());
|
|
}
|
|
delete pObjIter;
|
|
}
|
|
|
|
// 得到块表记录中所有属性定义的ID
|
|
void CFARInsert::GetAttribDefIds(AcDbBlockTableRecord *pBlkRec)
|
|
{
|
|
// 如果内容不为空，说明当前是在查找同一实体，不重复进行遍历
|
|
if (m_arAttribDefId.length() != 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
AcDbBlockTableRecordIterator *pIter = NULL;
|
|
if (Acad::eOk == pBlkRec->newIterator(pIter))
|
|
{
|
|
AcDbEntity *pEnt = NULL;
|
|
for (pIter->start(); !pIter->done(); pIter->step())
|
|
{
|
|
if (Acad::eOk == pIter->getEntity(pEnt, AcDb::kForRead))
|
|
{
|
|
// 当前实体是属性定义，则添加到数组中
|
|
if (pEnt->isKindOf(AcDbAttributeDefinition::desc()))
|
|
{
|
|
m_arAttribDefId.append(pEnt->objectId());
|
|
}
|
|
pEnt->close();
|
|
}
|
|
}
|
|
delete pIter;
|
|
pIter = NULL;
|
|
}
|
|
}
|
|
|
|
// 调整迭代器指针，指向m_arObjId中的第一个id代表的实体
|
|
bool CFARInsert::SeekBlockRecIter(AcDbBlockTableRecordIterator *pIter)
|
|
{
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
if (m_arObjId.length() != 0)
|
|
{
|
|
// 取出ID数组中的第一个ID
|
|
AcDbObjectId objId = m_arObjId.first();
|
|
m_arObjId.removeFirst();
|
|
|
|
int iIndex = -1;
|
|
// 如果在属性id数组中存在该id，说明是一个块属性的id，
|
|
// seek迭代器指针到块表记录中对应的属性定义实体
|
|
// m_arAttribId.find(m_arObjId.first(), iIndex);
|
|
m_arAttribId.find(objId, iIndex);
|
|
if (iIndex != -1)
|
|
{
|
|
objId = m_arAttribDefId.at(iIndex);
|
|
}
|
|
|
|
es = pIter->seek(objId);
|
|
|
|
if (Acad::eOk != es)
|
|
{
|
|
for (; !pIter->done(); pIter->step())
|
|
{
|
|
AcDbObjectId objIdTemp;
|
|
if (pIter->getEntityId(objIdTemp) == Acad::eOk)
|
|
{
|
|
if (objId == objIdTemp)
|
|
{
|
|
es = Acad::eOk;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return (Acad::eOk == es);
|
|
}
|
|
|
|
// 判断实体是否满足搜索选项要求，不满足返回false
|
|
bool CFARInsert::ContinueFind(AcDbEntity *pEnt, bool bIsXref) const
|
|
{
|
|
bool bContinue = false;
|
|
if (NULL != pEnt && pEnt->isReadEnabled())
|
|
{
|
|
// 是否是属性定义
|
|
bool bIsAttrib = pEnt->isKindOf(AcDbAttributeDefinition::desc());
|
|
if (bIsAttrib)
|
|
{
|
|
bContinue = !!m_bFindAttrib;
|
|
}
|
|
// 所在块是否是外部参照
|
|
else if (bIsXref)
|
|
{
|
|
bContinue = !!m_bFindXref;
|
|
}
|
|
// 是否查找块内容
|
|
else
|
|
{
|
|
bContinue = !!m_bFindContent;
|
|
}
|
|
|
|
// 如果实体是隐藏的并且搜索时要忽略隐藏选项，则不继续搜索
|
|
if (m_bNoHidden && pEnt->visibility() == AcDb::kInvisible)
|
|
{
|
|
bContinue = false;
|
|
}
|
|
}
|
|
|
|
return bContinue;
|
|
}
|
|
|
|
// 重新开始搜索
|
|
void CFARInsert::ResetFind()
|
|
{
|
|
// 清空数组
|
|
ClearObjIdArray(m_arObjId);
|
|
ClearObjIdArray(m_arAttribId);
|
|
ClearObjIdArray(m_arAttribDefId);
|
|
}
|
|
|
|
// 清空id数组
|
|
void CFARInsert::ClearObjIdArray(AcDbObjectIdArray &arObjId)
|
|
{
|
|
int iLen = arObjId.length();
|
|
if (0 != iLen)
|
|
{
|
|
arObjId.removeSubArray(0, iLen - 1);
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// 块属性的查找替换类
|
|
CFARInsertAttrib::CFARInsertAttrib()
|
|
{
|
|
m_bNoHidden = false;
|
|
}
|
|
|
|
|
|
TTextPosition CFARInsertAttrib::FindText(AcDbEntity *pEnt, const TCHAR *sSubText, TTextPosition &posStart, TTextRange *pRange)
|
|
{
|
|
TTextPosition posFind;
|
|
if (pEnt != NULL && pEnt->isReadEnabled())
|
|
{
|
|
AcDbAttribute *pAttrib = AcDbAttribute::cast(pEnt);
|
|
if (NULL != pAttrib)
|
|
{
|
|
// 如果忽略隐藏项并且当前的块属性是隐藏的，则返回
|
|
if (m_bNoHidden && pAttrib->isInvisible())
|
|
{
|
|
return posFind;
|
|
}
|
|
else
|
|
{
|
|
#if (ADS > 17)
|
|
// 是多行的属性，则使用多行文字的查找方法
|
|
if (pAttrib->isMTextAttribute())
|
|
{
|
|
AcDbMText *pMText = pAttrib->getMTextAttribute();
|
|
CFARMText farMText;
|
|
posFind = farMText.FindText(pMText, sSubText, posStart, pRange);
|
|
delete pMText;
|
|
}
|
|
// 否则使用单行文字的查找方法
|
|
else
|
|
#endif
|
|
{
|
|
CFARText farText;
|
|
posFind = farText.FindText(pEnt, sSubText, posStart, pRange);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return posFind;
|
|
}
|
|
|
|
TTextPosition CFARInsertAttrib::ReplaceText(AcDbEntity *pEnt, TTextPosition posFind, const TCHAR *szRepText)
|
|
{
|
|
TTextPosition posStart;
|
|
if (pEnt != NULL && pEnt->isWriteEnabled())
|
|
{
|
|
AcDbAttribute *pAttrib = AcDbAttribute::cast(pEnt);
|
|
if (pAttrib != NULL)
|
|
{
|
|
#if (ADS > 17)
|
|
// 是多行的属性，则使用多行文字的替换方法
|
|
if (pAttrib->isMTextAttribute())
|
|
{
|
|
AcDbMText *pMText = pAttrib->getMTextAttribute();
|
|
CFARMText farMText;
|
|
posStart = farMText.ReplaceText(pMText, posFind, szRepText);
|
|
if (!!posFind)
|
|
{
|
|
pAttrib->setMTextAttribute(pMText);
|
|
}
|
|
}
|
|
// 否则使用单行文字的替换方法
|
|
else
|
|
#endif
|
|
{
|
|
CFARText farText;
|
|
posStart = farText.ReplaceText(pEnt, posFind, szRepText);
|
|
}
|
|
}
|
|
}
|
|
|
|
return posStart;
|
|
}
|
|
|
|
// 设置忽略隐藏项
|
|
void CFARInsertAttrib::SetNoHidden(BOOL bNoHidden)
|
|
{
|
|
m_bNoHidden = bNoHidden;
|
|
}
|
|
|
|
// 单行文字的查找替换类
|
|
TTextPosition CFARText::FindText(AcDbEntity *pEnt, const TCHAR *sSubText, TTextPosition &posStart, TTextRange *pRange)
|
|
{
|
|
TTextPosition posFind;
|
|
CStringArray arString;
|
|
CString sSrcText(sSubText);
|
|
posStart.m_nCookies = 0;
|
|
XPushMemVar<BOOL> vTemp(g_bTextStyleEx, FALSE);
|
|
TDbText text;
|
|
AcDbText *pText = AcDbText::cast(pEnt);
|
|
// 单行文字转成上华单行文字，再做查找
|
|
if(text.ConvertFrom(pText))
|
|
{
|
|
posFind = text.FindSubText(sSrcText, posStart, pRange);
|
|
}
|
|
|
|
return posFind;
|
|
}
|
|
|
|
TTextPosition CFARText::ReplaceText(AcDbEntity *pEnt, TTextPosition posFind, const TCHAR *szRepText)
|
|
{
|
|
TTextPosition posStart;
|
|
XPushMemVar<BOOL> vTemp(g_bTextStyleEx, FALSE);
|
|
TDbText text;
|
|
AcDbText *pText=AcDbText::cast(pEnt);
|
|
// 单行文字转成上华单行文字，再做替换
|
|
if(text.ConvertFrom(pText))
|
|
{
|
|
posStart = text.ReplaceSubText(posFind, szRepText);
|
|
pText->setTextString((const TCHAR *)text.GetText());
|
|
}
|
|
|
|
return posStart;
|
|
}
|
|
|
|
// 得到单行文字内的字符串
|
|
bool CFARText::GetEntityStrings(AcDbEntity *pEnt, CStringArray &arString)
|
|
{
|
|
AcDbText *pEntity = AcDbText::cast(pEnt);
|
|
if (NULL != pEnt && pEnt->isReadEnabled())
|
|
{
|
|
LPTSTR pszText = pEntity->textString();
|
|
arString.Add(pszText);
|
|
delete[] pszText;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// 多行文字的查找替换类
|
|
TTextPosition CFARMText::FindText(AcDbEntity *pEnt, const TCHAR *sSubText, TTextPosition &posStart, TTextRange *pRange)
|
|
{
|
|
TTextPosition posFind;
|
|
XPushMemVar<BOOL> vTemp(g_bTextStyleEx, FALSE);
|
|
AcDbVoidPtrArray arEnts;
|
|
|
|
// 将多行文字对象炸开成单行文字，再进行查找
|
|
if (Acad::eOk == pEnt->explode(arEnts))
|
|
{
|
|
CFARText farText;
|
|
for (int i = posStart.m_nCookies; i < arEnts.length(); i++)
|
|
{
|
|
posFind = farText.FindText((AcDbEntity*)arEnts.at(i), sSubText, posStart, pRange);
|
|
if (!!posFind)
|
|
{
|
|
posFind.m_nCookies = i;
|
|
posStart.m_nCookies = i;
|
|
posStart.m_nTextPos = posFind.m_nTextPos + 1;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
posStart.m_nTextPos = -1;
|
|
}
|
|
}
|
|
ReleaseEntSet(arEnts);
|
|
}
|
|
return posFind;
|
|
}
|
|
|
|
TTextPosition CFARMText::ReplaceText(AcDbEntity *pEnt, TTextPosition posFind, const TCHAR *szRepText)
|
|
{
|
|
TTextPosition posStart;
|
|
if (!pEnt->isWriteEnabled())
|
|
{
|
|
return posStart;
|
|
}
|
|
|
|
CStringArray arString;
|
|
// 得到多行文字包含的所有字符串
|
|
if (GetEntityStrings(pEnt, arString))
|
|
{
|
|
CString sChange;
|
|
CString sContent;
|
|
// 取出要替换的字符串
|
|
sChange = arString.GetAt(posFind.m_nCookies);
|
|
// 替换文字
|
|
sChange.Delete(posFind.m_nTextPos, (int)posFind.m_nBufLen);
|
|
sChange.Insert(posFind.m_nTextPos, szRepText);
|
|
// 放回被替换的字符串
|
|
arString.SetAt(posFind.m_nCookies, sChange);
|
|
|
|
// 重新组合成AcdbMText格式的字符串
|
|
INT_PTR iLen = arString.GetSize();
|
|
for (int i = 0; i < iLen; i++)
|
|
{
|
|
if (i + 1 != iLen)
|
|
{
|
|
sContent += arString.GetAt(i) + _T("\\P");
|
|
}
|
|
else
|
|
{
|
|
sContent += arString.GetAt(i) ;
|
|
}
|
|
}
|
|
|
|
AcDbMText *pMText = AcDbMText::cast(pEnt);
|
|
|
|
if (pMText != NULL && pMText->isWriteEnabled())
|
|
{
|
|
// 更新字符串内容
|
|
pMText->setContents(sContent);
|
|
|
|
// 修改下一个搜索开始的位置
|
|
posStart.m_nCookies = posFind.m_nCookies;
|
|
posStart.m_nBufLen = _tcslen(szRepText);
|
|
posStart.m_nTextPos = posFind.m_nTextPos + (int)posStart.m_nBufLen;
|
|
}
|
|
}
|
|
return posStart;
|
|
}
|
|
|
|
// 得到多行文字内的字符串
|
|
bool CFARMText::GetEntityStrings(AcDbEntity *pEnt, CStringArray &arString)
|
|
{
|
|
if (pEnt != NULL && pEnt->isReadEnabled())
|
|
{
|
|
AcDbVoidPtrArray arEnts;
|
|
if ( Acad::eOk == pEnt->explode(arEnts))
|
|
{
|
|
int iNum = arEnts.length();
|
|
CFARText farText;
|
|
for (int i = 0; i < iNum; i++)
|
|
{
|
|
AcDbEntity *pEntity = (AcDbEntity*)arEnts.at(i);
|
|
if (pEntity->isKindOf(AcDbText::desc()))
|
|
{
|
|
farText.GetEntityStrings(pEntity, arString);
|
|
}
|
|
}
|
|
ReleaseEntSet(arEnts);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// 标注的查找替换类
|
|
TTextPosition CFARDimension::FindText(AcDbEntity *pEnt, const TCHAR *sSubText, TTextPosition &posStart, TTextRange *pRange)
|
|
{
|
|
TTextPosition posFind;
|
|
AcDbDimension *pDim = AcDbDimension::cast(pEnt);
|
|
if (NULL != pDim)
|
|
{
|
|
AcDbVoidPtrArray arEnts;
|
|
// 炸开标注对象，从其中的多行文字对象中进行查找
|
|
if (Acad::eOk == pDim->explode(arEnts))
|
|
{
|
|
CFARMText farMtext;
|
|
for(int i = 0; i < arEnts.length(); i++)
|
|
{
|
|
AcDbEntity *pEntity = (AcDbEntity*)arEnts.at(i);
|
|
AcDbMText *pText = AcDbMText::cast(pEntity);
|
|
if (NULL != pText)
|
|
{
|
|
posFind = farMtext.FindText(pText, sSubText, posStart, pRange);
|
|
break;
|
|
}
|
|
}
|
|
ReleaseEntSet(arEnts);
|
|
}
|
|
}
|
|
return posFind;
|
|
}
|
|
|
|
TTextPosition CFARDimension::ReplaceText(AcDbEntity *pEnt, TTextPosition posFind, const TCHAR *szRepText)
|
|
{
|
|
TTextPosition posStart;
|
|
AcDbDimension *pDim = AcDbDimension::cast(pEnt);
|
|
if (NULL != pDim && pDim->isWriteEnabled())
|
|
{
|
|
AcDbVoidPtrArray arEnts;
|
|
// 炸开标注对象，替换其中的多行文字对象
|
|
if (Acad::eOk == pDim->explode(arEnts))
|
|
{
|
|
CFARMText farMtext;
|
|
for(int i = 0; i < arEnts.length(); i++)
|
|
{
|
|
AcDbEntity *pEntity = (AcDbEntity*)arEnts.at(i);
|
|
AcDbMText *pText = AcDbMText::cast(pEntity);
|
|
if (NULL != pText)
|
|
{
|
|
posStart = farMtext.ReplaceText(pText, posFind, szRepText);
|
|
if (!!posStart)
|
|
{
|
|
LPTSTR pszContents = pText->contents();
|
|
pDim->setDimensionText(pszContents);
|
|
pDim->recomputeDimBlock();
|
|
delete[] pszContents;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
ReleaseEntSet(arEnts);
|
|
}
|
|
}
|
|
return posStart;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// 查找替换工具集
|
|
// 查找文字
|
|
TTextPosition CFARUtil::FindEntText(TEntitySet ent, const TCHAR *sSubText, TTextPosition &posStart, TTextRange *pRange)
|
|
{
|
|
TTextPosition posFind;
|
|
if(sSubText == NULL)
|
|
return posFind;
|
|
|
|
OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbEntity, pEnt);
|
|
posFind = FindEntText(pEnt, sSubText, posStart, pRange);
|
|
OPENOBJ_END();
|
|
|
|
return posFind;
|
|
}
|
|
|
|
TTextPosition CFARUtil::FindEntText(AcDbEntity *pEnt, const TCHAR *sSubText, TTextPosition &posStart, TTextRange *pRange)
|
|
{
|
|
TTextPosition posFind;
|
|
|
|
if (pEnt != NULL && pEnt->isReadEnabled())
|
|
{
|
|
// 忽略隐藏层上的实体
|
|
if (m_bNoHidden)
|
|
{
|
|
if (IsHiddenEntity(pEnt))
|
|
{
|
|
return posFind;
|
|
}
|
|
}
|
|
|
|
// 所有上华对象，使用统一的函数
|
|
if (pEnt->isKindOf(TDbEntity::desc()) || pEnt->isKindOf(TDbCurveEntity::desc()))
|
|
{
|
|
posFind = m_TDbEntity.FindText(pEnt, sSubText, posStart, pRange);
|
|
}
|
|
// 属性定义
|
|
else if (pEnt->isKindOf(AcDbAttribute::desc()))
|
|
{
|
|
posFind = m_InsertAttrib.FindText(pEnt, sSubText, posStart, pRange);
|
|
}
|
|
// 单行文字
|
|
else if (pEnt->isKindOf(AcDbText::desc()))
|
|
{
|
|
posFind = m_Text.FindText(pEnt, sSubText, posStart, pRange);
|
|
}
|
|
// 多行文字
|
|
else if (pEnt->isKindOf(AcDbMText::desc()))
|
|
{
|
|
posFind = m_MText.FindText(pEnt, sSubText, posStart, pRange);
|
|
}
|
|
// 块参照/外部参照
|
|
else if (pEnt->isKindOf(AcDbBlockReference::desc()))
|
|
{
|
|
posFind = m_Insert.FindText(pEnt, sSubText, posStart, pRange);
|
|
}
|
|
// 标注
|
|
else if (pEnt->isKindOf(AcDbDimension::desc()))
|
|
{
|
|
posFind = m_Dimension.FindText(pEnt, sSubText, posStart, pRange);
|
|
}
|
|
}
|
|
|
|
return posFind;
|
|
}
|
|
|
|
// 替换文字
|
|
TTextPosition CFARUtil::ReplaceEntText(TEntitySet ent, TTextPosition posFind, const TCHAR *szRepText)
|
|
{
|
|
TTextPosition posStart;
|
|
OPENOBJ_BEGIN(ent, AcDb::kForWrite, AcDbEntity, pEnt);
|
|
if (pEnt != NULL)
|
|
{
|
|
posStart = ReplaceEntText(pEnt, posFind, szRepText);
|
|
}
|
|
OPENOBJ_END();
|
|
return posStart;
|
|
}
|
|
|
|
TTextPosition CFARUtil::ReplaceEntText(AcDbEntity *pEnt, TTextPosition posFind, const TCHAR *szRepText)
|
|
{
|
|
TTextPosition posStart;
|
|
if (NULL != pEnt && pEnt->isWriteEnabled())
|
|
{
|
|
// 上华对象
|
|
if(pEnt->isKindOf(TDbEntity::desc()) || pEnt->isKindOf(TDbCurveEntity::desc()))
|
|
{
|
|
posStart = m_TDbEntity.ReplaceText(pEnt, posFind, szRepText);
|
|
}
|
|
// 块属性
|
|
else if (pEnt->isKindOf(AcDbAttribute::desc()))
|
|
{
|
|
posStart = m_InsertAttrib.ReplaceText(pEnt, posFind, szRepText);
|
|
}
|
|
// 单行文字
|
|
else if(pEnt->isKindOf(AcDbText::desc()))
|
|
{
|
|
posStart = m_Text.ReplaceText(pEnt, posFind, szRepText);
|
|
}
|
|
// 多行文字
|
|
else if (pEnt->isKindOf(AcDbMText::desc()))
|
|
{
|
|
posStart = m_MText.ReplaceText(pEnt, posFind, szRepText);
|
|
}
|
|
// 块参照/外部参照
|
|
else if(pEnt->isKindOf(AcDbBlockReference::desc()))
|
|
{
|
|
posStart = m_Insert.ReplaceText(pEnt, posFind, szRepText);
|
|
}
|
|
// 标注
|
|
else if (pEnt->isKindOf(AcDbDimension::desc()))
|
|
{
|
|
posStart = m_Dimension.ReplaceText(pEnt, posFind, szRepText);
|
|
}
|
|
}
|
|
return posStart;
|
|
}
|
|
|
|
// 设置id数组
|
|
void CFARUtil::SetEntityIds(const AcDbObjectIdArray &arObjId)
|
|
{
|
|
m_Insert.SetEntityIds(arObjId);
|
|
}
|
|
|
|
// 获得id数组
|
|
const AcDbObjectIdArray& CFARUtil::GetEntityIds() const
|
|
{
|
|
return m_Insert.GetEntityIds();
|
|
}
|
|
|
|
// 设置查找选项
|
|
void CFARUtil::SetFindOption(BOOL bFindAttrib, BOOL bFindContent, BOOL bFindXref, BOOL bNoHidden)
|
|
{
|
|
m_Insert.SetFindInsertOption(bFindAttrib, bFindContent, bFindXref, bNoHidden);
|
|
m_InsertAttrib.SetNoHidden(bNoHidden);
|
|
m_bNoHidden = bNoHidden;
|
|
}
|
|
|
|
// 重新开始搜索
|
|
void CFARUtil::ResetFind()
|
|
{
|
|
m_Insert.ResetFind();
|
|
}
|
|
|
|
// 判断实体是否是在关闭或者隐藏层上
|
|
bool CFARUtil::IsHiddenEntity(AcDbEntity *&pEnt)
|
|
{
|
|
// 返回值
|
|
bool bRet = false;
|
|
if (pEnt != NULL && pEnt->isReadEnabled())
|
|
{
|
|
LPTSTR pszLayerName = pEnt->layer();
|
|
// 在记录中查找
|
|
if (!m_mapLayer.Lookup(pszLayerName, bRet))
|
|
{
|
|
// 如果记录中不存在，则打开图层判断，并记录结果
|
|
bRet = IsHiddenLayer(pEnt->layerId());
|
|
m_mapLayer.SetAt(pszLayerName, bRet);
|
|
}
|
|
delete[] pszLayerName;
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
// 判断id对应的层是否是关闭或者隐藏层
|
|
bool CFARUtil::IsHiddenLayer(const AcDbObjectId &objIdLayer) const
|
|
{
|
|
if (objIdLayer.isValid())
|
|
{
|
|
OPENOBJ_BEGIN(objIdLayer, AcDb::kForRead, AcDbLayerTableRecord, pLayer);
|
|
if (pLayer != NULL)
|
|
{
|
|
// 判断是否是关闭或者隐藏层
|
|
return (pLayer->isOff() || pLayer->isFrozen());
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
return false;
|
|
}
|