1330 lines
35 KiB
C++
1330 lines
35 KiB
C++
#include "StdAfx.h"
|
|
#include <acly.h>
|
|
#include "TDocCreateLayer.h"
|
|
#import "msxml6.dll"
|
|
#include "utility.h"
|
|
|
|
using namespace MSXML2;
|
|
|
|
namespace
|
|
{
|
|
//int CompareString( const CString& strFirst, const CString& strSecond )
|
|
//{
|
|
// int nRet = CompareString(GetThreadLocale(),
|
|
// NORM_IGNOREWIDTH|SORT_STRINGSORT, strFirst,strFirst.GetLength(), strSecond, strSecond.GetLength()/*, NULL, NULL, 0*/);
|
|
// if(nRet == CSTR_LESS_THAN) //升序
|
|
// return -1;
|
|
// else if(nRet == CSTR_GREATER_THAN)
|
|
// return 1;
|
|
// else
|
|
// return 0;
|
|
//}
|
|
|
|
bool JudgeDocIsNewOrExist()
|
|
{
|
|
CString sDwgName = curDoc()->fileName();
|
|
int iIndex = sDwgName.Find(_T(":"));
|
|
if (iIndex < 0)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
MSXML2::IXMLDOMDocument2Ptr LoadXMLFile( LPCTSTR path)
|
|
{
|
|
do{
|
|
::CoInitialize(NULL);
|
|
MSXML2::IXMLDOMDocument2Ptr pXMLDoc;
|
|
HRESULT hr = pXMLDoc.CreateInstance(__uuidof(MSXML2::DOMDocument60));
|
|
if (!SUCCEEDED(hr)) break;
|
|
pXMLDoc->async = false;
|
|
pXMLDoc->validateOnParse = true;
|
|
if (pXMLDoc->load(_bstr_t(path)) != VARIANT_TRUE) break;
|
|
return pXMLDoc;
|
|
}while(false);
|
|
return NULL;
|
|
}
|
|
|
|
void AddLayerNameToFilterGroup(CString sLayerNameVec, SLayerGrpRecord *pGrpRecord)
|
|
{
|
|
int iIndex(0);
|
|
CString sLayerName(_T(""));
|
|
iIndex = sLayerNameVec.Find(_T('*'));
|
|
if(iIndex < 0)
|
|
{
|
|
pGrpRecord->arContainLayerName.push_back(sLayerNameVec);
|
|
}
|
|
else
|
|
{
|
|
sLayerName = sLayerNameVec.Left(iIndex);
|
|
pGrpRecord->arContainLayerName.push_back(sLayerName);
|
|
sLayerNameVec = sLayerNameVec.Right(sLayerNameVec.GetLength() - iIndex - 1);
|
|
if (sLayerNameVec.GetLength() != 0)
|
|
{
|
|
AddLayerNameToFilterGroup(sLayerNameVec, pGrpRecord);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ReadXMLFileToGetChildNode(SLayerGrpRecord *pParent, MSXML2::IXMLDOMNodeListPtr pGrps)
|
|
{
|
|
MSXML2::IXMLDOMNodePtr pGrp = pGrps->nextNode();
|
|
CString strNodeName(_T(""));
|
|
CString sLayerName(_T(""));
|
|
MSXML2::IXMLDOMNodePtr pNodePtrValue(NULL);
|
|
MSXML2::IXMLDOMNamedNodeMapPtr pMap(NULL);
|
|
MSXML2::IXMLDOMNodeListPtr pChildListNode(NULL);
|
|
while (pGrp)
|
|
{
|
|
pMap = pGrp->Getattributes();
|
|
if(!pMap)
|
|
continue;
|
|
pNodePtrValue = pMap->getNamedItem((LPCTSTR)TARCH_LAYER_GROUP_NODE_VALUE_CSTRING);
|
|
if(!pNodePtrValue)
|
|
continue;
|
|
strNodeName = pNodePtrValue->GetnodeValue();
|
|
SLayerGrpRecord *pChild = new SLayerGrpRecord(strNodeName, pParent);
|
|
pParent->arLayerGrpChild.push_back(pChild);
|
|
pNodePtrValue = pMap->getNamedItem((LPCTSTR)TARCH_LAYER_GROUP_NODE_LAYERNAME_CSTRING);
|
|
if(pNodePtrValue)
|
|
{
|
|
strNodeName = pNodePtrValue->GetnodeValue();
|
|
if (strNodeName.GetLength() != 0)
|
|
{
|
|
AddLayerNameToFilterGroup(strNodeName, pChild);
|
|
}
|
|
}
|
|
pChildListNode = pGrp->GetchildNodes();
|
|
ReadXMLFileToGetChildNode(pChild, pChildListNode);
|
|
pGrp = pGrps->nextNode();
|
|
}
|
|
}
|
|
|
|
void ReadXMLFileToGetGrpFilterSort(MSXML2::IXMLDOMNodeListPtr pGrps, int& iSort)
|
|
{
|
|
MSXML2::IXMLDOMNodePtr pGrp = pGrps->nextNode();
|
|
CString strNodeName(_T(""));
|
|
MSXML2::IXMLDOMNodePtr pNodePtrValue(NULL);
|
|
MSXML2::IXMLDOMNamedNodeMapPtr pMap(NULL);
|
|
MSXML2::IXMLDOMNodeListPtr pChildListNode(NULL);
|
|
while (pGrp)
|
|
{
|
|
pMap = pGrp->Getattributes();
|
|
if(!pMap)
|
|
continue;
|
|
pNodePtrValue = pMap->getNamedItem((LPCTSTR)TARCH_LAYER_GROUP_NODE_VALUE_CSTRING);
|
|
if(!pNodePtrValue)
|
|
continue;
|
|
strNodeName = pNodePtrValue->GetnodeValue();
|
|
if (!strNodeName.IsEmpty())
|
|
{
|
|
iSort = _ttoi(strNodeName);
|
|
break;
|
|
}
|
|
pGrp = pGrps->nextNode();
|
|
}
|
|
}
|
|
|
|
int SetNumberOfSliderControl(int iNumber)
|
|
{
|
|
double dSwap(0.000);
|
|
int iSwap(0);
|
|
dSwap = (double)(255 * 20 - 20 * iNumber) / 51.000;
|
|
iSwap = (int)dSwap;
|
|
return iSwap;
|
|
}
|
|
|
|
bool CompareStringSort(const CString& strFirst, const CString& strSecond)
|
|
{
|
|
int rel = utility::CompareString(strFirst, strSecond);
|
|
if (rel >= 0)
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
|
|
bool CompareColorByString(CString sColorL, CString sColorR, bool bAscending, CString sNameL, CString sNameR)
|
|
{
|
|
int iColorL(0), iColorR(0);
|
|
if (sColorL.Find(_T(',')) >= 0 && sColorR.Find(_T(',')) >= 0)
|
|
{
|
|
int iIndexL = sColorL.Find(_T(','));
|
|
int iIndexR = sColorR.Find(_T(','));
|
|
CString sAL(sColorL.Left(iIndexL)), sAR(sColorR.Left(iIndexR));
|
|
if (sAL.CompareNoCase(sAR))
|
|
{
|
|
iColorL = _ttoi(sAL);
|
|
iColorR = _ttoi(sAR);
|
|
if (bAscending)
|
|
return iColorL < iColorR;
|
|
else
|
|
return iColorL > iColorR;
|
|
}
|
|
else
|
|
{
|
|
sColorL = sColorL.Right(sColorL.GetLength() - iIndexL - 1);
|
|
sColorR = sColorR.Right(sColorR.GetLength() - iIndexR - 1);
|
|
iIndexL = sColorL.Find(_T(','));
|
|
iIndexR = sColorR.Find(_T(','));
|
|
sAL = sColorL.Left(iIndexL);
|
|
sAR = sColorR.Left(iIndexR);
|
|
if (sAL.CompareNoCase(sAR))
|
|
{
|
|
iColorL = _ttoi(sAL);
|
|
iColorR = _ttoi(sAR);
|
|
if (bAscending)
|
|
return iColorL < iColorR;
|
|
else
|
|
return iColorL > iColorR;
|
|
}
|
|
else
|
|
{
|
|
sAL = sColorL.Right(sColorL.GetLength() - iIndexL - 1);
|
|
sAR = sColorR.Right(sColorR.GetLength() - iIndexR - 1);
|
|
if (sAL.CompareNoCase(sAR))
|
|
{
|
|
iColorL = _ttoi(sAL);
|
|
iColorR = _ttoi(sAR);
|
|
if (bAscending)
|
|
return iColorL < iColorR;
|
|
else
|
|
return iColorL > iColorR;
|
|
}
|
|
else
|
|
{
|
|
if (bAscending)
|
|
return sNameL > sNameR;
|
|
else
|
|
return sNameL < sNameR;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if(sColorL.Find(_T(',')) >= 0 && sColorR.Find(_T(',')) < 0)
|
|
{
|
|
if (bAscending)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
else if (sColorL.Find(_T(',')) < 0 && sColorR.Find(_T(',')) >= 0)
|
|
{
|
|
if (bAscending)
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
if(sColorL == _T("红"))
|
|
iColorL = 1;
|
|
else if(sColorL == _T("黄"))
|
|
iColorL = 2;
|
|
else if(sColorL == _T("绿"))
|
|
iColorL = 3;
|
|
else if(sColorL == _T("青"))
|
|
iColorL = 4;
|
|
else if(sColorL == _T("蓝"))
|
|
iColorL = 5;
|
|
else if(sColorL == _T("洋红"))
|
|
iColorL = 6;
|
|
else if(sColorL == _T("白") || sColorL == _T("黑"))
|
|
iColorL = 7;
|
|
else
|
|
iColorL = _ttoi(sColorL);
|
|
|
|
if(sColorR == _T("红"))
|
|
iColorR = 1;
|
|
else if(sColorR == _T("黄"))
|
|
iColorR = 2;
|
|
else if(sColorR == _T("绿"))
|
|
iColorR = 3;
|
|
else if(sColorR == _T("青"))
|
|
iColorR = 4;
|
|
else if(sColorR == _T("蓝"))
|
|
iColorR = 5;
|
|
else if(sColorR == _T("洋红"))
|
|
iColorR = 6;
|
|
else if(sColorR == _T("白") || sColorR == _T("黑"))
|
|
iColorR = 7;
|
|
else
|
|
iColorR = _ttoi(sColorR);
|
|
|
|
if (iColorL == iColorR)
|
|
{
|
|
if (bAscending)
|
|
return sNameL > sNameR;
|
|
else
|
|
return sNameL < sNameR;
|
|
}
|
|
else
|
|
{
|
|
if (bAscending)
|
|
return iColorL < iColorR;
|
|
else
|
|
return iColorL > iColorR;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool IsColorByIndex(AcCmColor &cmclr)
|
|
{
|
|
return cmclr.isByACI();
|
|
}
|
|
|
|
bool IsColorByRGB(AcCmColor &cmclr)
|
|
{
|
|
if (!cmclr.isByColor()) return false;
|
|
const TCHAR *psz = cmclr.colorName();
|
|
if (!psz) return true;
|
|
CString str(psz);
|
|
return str.IsEmpty() ? true : false;
|
|
}
|
|
|
|
bool IsColorByPeise(AcCmColor &cmclr) // 配色
|
|
{
|
|
if (!cmclr.isByColor()) return false;
|
|
const TCHAR *psz = cmclr.colorName(); // 只有 colorName() 得到的指针可能为空 详见ARX文档
|
|
if (!psz) return false;
|
|
CString str1(psz), str2(cmclr.colorNameForDisplay());
|
|
if (str1.CompareNoCase(str2) == 0 && !str1.IsEmpty())
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
bool sort_by_peise(AcCmColor& obj1, AcCmColor& obj2, bool bAscending, CString sLayerNameL, CString sLayerNameR)
|
|
{
|
|
CString sColorL(obj1.colorNameForDisplay()), sColorR(obj2.colorNameForDisplay());
|
|
if (sColorL.CompareNoCase(sColorR))
|
|
{
|
|
if(utility::CompareString(sColorL, sColorR) == -1)
|
|
{
|
|
if (bAscending)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if (bAscending)
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (utility::CompareString(sLayerNameL, sLayerNameR) == -1)
|
|
{
|
|
if (bAscending)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if (bAscending)
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool sort_by_index(const AcCmColor& obj1, const AcCmColor& obj2, bool bAscending, CString sLayerNameL, CString sLayerNameR)
|
|
{
|
|
if (obj1.colorIndex() != obj2.colorIndex())
|
|
{
|
|
if(bAscending)
|
|
return obj1.colorIndex() < obj2.colorIndex();
|
|
else
|
|
return obj1.colorIndex() > obj2.colorIndex();
|
|
}
|
|
else
|
|
{
|
|
if (utility::CompareString(sLayerNameL, sLayerNameR) == -1)
|
|
{
|
|
if (bAscending)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if (bAscending)
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool sort_by_rgb(AcCmColor& obj1, AcCmColor& obj2, bool bAscending, CString sLayerNameL, CString sLayerNameR)
|
|
{
|
|
CString sColorL(obj1.colorNameForDisplay()), sColorR(obj2.colorNameForDisplay());
|
|
int iColorL(0), iColorR(0);
|
|
int iIndexL = sColorL.Find(_T(','));
|
|
int iIndexR = sColorR.Find(_T(','));
|
|
CString sAL(sColorL.Left(iIndexL)), sAR(sColorR.Left(iIndexR));
|
|
if (sAL.CompareNoCase(sAR))
|
|
{
|
|
iColorL = _ttoi(sAL);
|
|
iColorR = _ttoi(sAR);
|
|
if (bAscending)
|
|
return iColorL < iColorR;
|
|
else
|
|
return iColorL > iColorR;
|
|
}
|
|
else
|
|
{
|
|
sColorL = sColorL.Right(sColorL.GetLength() - iIndexL - 1);
|
|
sColorR = sColorR.Right(sColorR.GetLength() - iIndexR - 1);
|
|
iIndexL = sColorL.Find(_T(','));
|
|
iIndexR = sColorR.Find(_T(','));
|
|
sAL = sColorL.Left(iIndexL);
|
|
sAR = sColorR.Left(iIndexR);
|
|
if (sAL.CompareNoCase(sAR))
|
|
{
|
|
iColorL = _ttoi(sAL);
|
|
iColorR = _ttoi(sAR);
|
|
if (bAscending)
|
|
return iColorL < iColorR;
|
|
else
|
|
return iColorL > iColorR;
|
|
}
|
|
else
|
|
{
|
|
sAL = sColorL.Right(sColorL.GetLength() - iIndexL - 1);
|
|
sAR = sColorR.Right(sColorR.GetLength() - iIndexR - 1);
|
|
if (sAL.CompareNoCase(sAR))
|
|
{
|
|
iColorL = _ttoi(sAL);
|
|
iColorR = _ttoi(sAR);
|
|
if (bAscending)
|
|
return iColorL < iColorR;
|
|
else
|
|
return iColorL > iColorR;
|
|
}
|
|
else
|
|
{
|
|
if (utility::CompareString(sLayerNameL, sLayerNameR) == -1)
|
|
{
|
|
if (bAscending)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if (bAscending)
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CompareColorSort(SLayerRecord *pLayerL, SLayerRecord *pLayerR, bool bAscending)
|
|
{
|
|
if (IsColorByIndex(pLayerL->cmColor) && !IsColorByIndex(pLayerR->cmColor))
|
|
{
|
|
if (bAscending)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
else if (IsColorByIndex(pLayerL->cmColor) && IsColorByIndex(pLayerR->cmColor))
|
|
return sort_by_index(pLayerL->cmColor, pLayerR->cmColor, bAscending, pLayerL->sLayerName, pLayerR->sLayerName);
|
|
else if (IsColorByRGB(pLayerL->cmColor) && IsColorByIndex(pLayerR->cmColor))
|
|
{
|
|
if (bAscending)
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
else if (IsColorByRGB(pLayerL->cmColor) && IsColorByRGB(pLayerR->cmColor))
|
|
return sort_by_rgb(pLayerL->cmColor, pLayerR->cmColor, bAscending, pLayerL->sLayerName, pLayerR->sLayerName);
|
|
else if (IsColorByRGB(pLayerL->cmColor) && IsColorByPeise(pLayerR->cmColor))
|
|
{
|
|
if (bAscending)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
else if (IsColorByPeise(pLayerL->cmColor) && !IsColorByPeise(pLayerR->cmColor))
|
|
{
|
|
if (bAscending)
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
else if (IsColorByPeise(pLayerL->cmColor) && IsColorByPeise(pLayerR->cmColor))
|
|
return sort_by_peise(pLayerL->cmColor, pLayerR->cmColor, bAscending, pLayerL->sLayerName, pLayerR->sLayerName);
|
|
}
|
|
}
|
|
|
|
void CreateLayerForNewDoc(AcDbDatabase* pCurDocData)
|
|
{
|
|
if (JudgeDocIsNewOrExist())
|
|
{
|
|
TDocCreateLayer docLay(pCurDocData);
|
|
docLay.DoCreateDocLayer();
|
|
}
|
|
}
|
|
|
|
TDocCreateLayer::TDocCreateLayer(AcDbDatabase* pDatabase)
|
|
{
|
|
m_bWhetherCreatStandardLayer = false;
|
|
m_pDatabase = pDatabase;
|
|
m_sInstallDirectory = utility::GetInstallDir();
|
|
m_bRegistryIsExist = true;
|
|
m_bTarchLayIsExist = true;
|
|
m_bFilterIsExist = true;
|
|
m_bNotCreatLayer = true;
|
|
m_bValidModify = true;
|
|
m_iGrpFilterSort = 0;
|
|
|
|
m_arStandardLayerRecord.clear();
|
|
m_arSystemGrpFilter.clear();
|
|
m_arNotCreatStandardLayer.clear();
|
|
m_pCurLayerRecordHeader.clear();
|
|
m_arAllDocLayerRecordParamNumHeader.clear();
|
|
}
|
|
TDocCreateLayer::~TDocCreateLayer()
|
|
{
|
|
|
|
}
|
|
|
|
void TDocCreateLayer::InitJudgeRegistryIsWhole()
|
|
{
|
|
m_sInstallDirectory = utility::GetInstallDir();
|
|
if (m_sInstallDirectory.IsEmpty())
|
|
{
|
|
m_bRegistryIsExist = false;
|
|
return;
|
|
}
|
|
m_bRegistryIsExist = true;
|
|
}
|
|
|
|
void TDocCreateLayer::InitarSystemGrpFilter()
|
|
{
|
|
AcLyLayerFilterManager *pAclyMager = aclyGetLayerFilterManager(m_pDatabase);
|
|
if (!pAclyMager)
|
|
{
|
|
return;
|
|
}
|
|
AcLyLayerFilter *pFilterRoot(NULL);
|
|
AcLyLayerFilter *pFilterCur(NULL);
|
|
Acad::ErrorStatus bOk(Acad::eOk);
|
|
bOk = pAclyMager->getFilters(pFilterRoot, pFilterCur);
|
|
if (bOk != Acad::eOk)
|
|
{
|
|
return;
|
|
}
|
|
if(!pFilterRoot)
|
|
{
|
|
return;
|
|
}
|
|
InitarSystemGrpFilterImplementationDetails(pFilterRoot);
|
|
|
|
}
|
|
void TDocCreateLayer::GetCurFilterGrpNameByCAD()
|
|
{
|
|
AcLyLayerFilterManager *pAclyMager = aclyGetLayerFilterManager(m_pDatabase);
|
|
if (!pAclyMager)
|
|
{
|
|
return;
|
|
}
|
|
Acad::ErrorStatus bError(Acad::eOk);
|
|
AcLyLayerFilter *pFilterRoot(NULL);
|
|
AcLyLayerFilter *pFilterCurRoot(NULL);
|
|
bError = pAclyMager->getFilters(pFilterRoot, pFilterCurRoot);
|
|
if (bError != Acad::eOk)
|
|
{
|
|
return;
|
|
}
|
|
if (pFilterCurRoot)
|
|
{
|
|
m_sCurFilterGrpName = pFilterCurRoot->name();
|
|
}
|
|
else
|
|
{
|
|
m_sCurFilterGrpName = _T("");
|
|
}
|
|
}
|
|
void TDocCreateLayer::InitFirstSetGrpFilter()
|
|
{
|
|
TDocAutoLock lock;
|
|
AcLyLayerFilterManager *pAclyMager = aclyGetLayerFilterManager(m_pDatabase);
|
|
if (!pAclyMager)
|
|
{
|
|
return;
|
|
}
|
|
Acad::ErrorStatus bError(Acad::eOk);
|
|
AcLyLayerFilter *pFilterRoot(NULL);
|
|
AcLyLayerFilter *pFilterCurRoot(NULL);
|
|
bError = pAclyMager->getFilters(pFilterRoot, pFilterCurRoot);
|
|
if (bError != Acad::eOk)
|
|
{
|
|
return;
|
|
}
|
|
bError = pAclyMager->setFilters(pFilterRoot, pFilterRoot);
|
|
m_sCurFilterGrpName = pFilterRoot->name();
|
|
}
|
|
|
|
void TDocCreateLayer::InitarSystemGrpFilterImplementationDetails(AcLyLayerFilter *pFilter)
|
|
{
|
|
AcArray<AcLyLayerFilter*> arRootFilters = pFilter->getNestedFilters();
|
|
CString sName(_T(""));
|
|
for (int i = 0; i < arRootFilters.length(); ++i)
|
|
{
|
|
sName = arRootFilters[i]->name();
|
|
if (sName.CompareNoCase(_T("所有使用的图层")))
|
|
{
|
|
m_arSystemGrpFilter.push_back(sName);
|
|
}
|
|
InitarSystemGrpFilterImplementationDetails(arRootFilters[i]);
|
|
}
|
|
}
|
|
|
|
void TDocCreateLayer::InitWhetherCreatStandard()
|
|
{
|
|
CString sNotCreatStandardLayerPath = m_sInstallDirectory + TARCH_INSTALL_DIRECTORY_INCLUDE_SYS + TARCH_LAYER_NOT_CAEAT_STANDARD_LAYER;
|
|
CFileFind finder;
|
|
BOOL bIsExist = finder.FindFile(sNotCreatStandardLayerPath);
|
|
if (!bIsExist)
|
|
{
|
|
CString str = sNotCreatStandardLayerPath;
|
|
str += _T("文件不存在");
|
|
AfxMessageBox(str);
|
|
m_bNotCreatLayer = false;
|
|
m_bWhetherCreatStandardLayer= true;
|
|
return;
|
|
}
|
|
setlocale(0,"chs");
|
|
CStdioFile *fp(NULL);
|
|
fp = new CStdioFile(sNotCreatStandardLayerPath, CFile::modeRead);
|
|
CString sReadWords(_T(""));
|
|
fp->ReadString(sReadWords);
|
|
if (!sReadWords.CompareNoCase(_T("是否需要生成图层_No")))
|
|
{
|
|
m_bWhetherCreatStandardLayer = false;
|
|
}
|
|
else
|
|
{
|
|
m_bWhetherCreatStandardLayer = true;
|
|
}
|
|
fp->Close();
|
|
deletePtr(fp);
|
|
}
|
|
|
|
void TDocCreateLayer::InitStandardGrpRoot()
|
|
{
|
|
MSXML2::IXMLDOMDocumentPtr pDoc;
|
|
HRESULT hr = pDoc.CreateInstance(__uuidof(MSXML2::DOMDocument60));
|
|
if(!SUCCEEDED(hr))
|
|
{
|
|
CString str(_T("无法创建DOMDocument对象，请检查是否安装了MS XML Parser 运行库!"));
|
|
AfxMessageBox(str);
|
|
//GlwLayerWarnMessageBox WndDlgLayerNotDeleteWarn(str, acedGetAcadFrame());
|
|
//WndDlgLayerNotDeleteWarn.DoModal(WS_POPUP | WS_CAPTION
|
|
// | WS_SYSMENU, NULL, acedGetAcadFrame());
|
|
return;
|
|
}
|
|
CString sLayerGrpXml = m_sInstallDirectory + TARCH_INSTALL_DIRECTORY_INCLUDE_SYS + TARCH_LAYER_GROUP_FILE_NAME_XML;
|
|
CFileFind finder;
|
|
BOOL bIsExist = finder.FindFile(sLayerGrpXml); //查看安装路径下的图层标准文件是否存在
|
|
if (!bIsExist)
|
|
{
|
|
CString str = sLayerGrpXml;
|
|
str += _T("文件不存在");
|
|
AfxMessageBox(str);
|
|
/*GlwLayerWarnMessageBox WndDlgLayerNotDeleteWarn(str, acedGetAcadFrame());
|
|
WndDlgLayerNotDeleteWarn.DoModal(WS_POPUP | WS_CAPTION
|
|
| WS_SYSMENU, NULL, acedGetAcadFrame());
|
|
m_bFilterIsExist = false;*/
|
|
return;
|
|
}
|
|
m_pLayerGrpRoot = new SLayerGrpRecord(_T("全部"), NULL);
|
|
if(!ReadLayerGrpFromXMLFile(m_pLayerGrpRoot, sLayerGrpXml))
|
|
{
|
|
CString str(_T("读取LayerGroup.XML文件失败"));
|
|
AfxMessageBox(str);
|
|
/*GlwLayerWarnMessageBox WndDlgLayerNotDeleteWarn(str, acedGetAcadFrame());
|
|
WndDlgLayerNotDeleteWarn.DoModal(WS_POPUP | WS_CAPTION
|
|
| WS_SYSMENU, NULL, acedGetAcadFrame());*/
|
|
}
|
|
}
|
|
|
|
bool TDocCreateLayer::ReadLayerGrpFromXMLFile(SLayerGrpRecord *pRoot, CString sGrpXml, bool bIsSort)
|
|
{
|
|
MSXML2::IXMLDOMDocument2Ptr pXMLDoc = LoadXMLFile(sGrpXml);
|
|
if(!pXMLDoc)
|
|
{
|
|
return false;
|
|
}
|
|
MSXML2::IXMLDOMElementPtr pXMLEl = pXMLDoc->GetdocumentElement();
|
|
if (!pXMLEl)
|
|
return false;
|
|
if (bIsSort)
|
|
{
|
|
MSXML2::IXMLDOMNodeListPtr pGrps = pXMLEl->selectNodes(TARCH_LAYER_GROUP_NODE_SORT_CSTRING);
|
|
if(!pGrps)
|
|
return false;
|
|
MSXML2::IXMLDOMNodePtr pGrp = pGrps->nextNode();
|
|
if(!pGrp)
|
|
return false;
|
|
//因为之前做判断调用过nextNode()方法，跳过第一个结点了，所以再重新赋值一次
|
|
pGrps = pXMLEl->selectNodes(TARCH_LAYER_GROUP_NODE_SORT_CSTRING);
|
|
ReadXMLFileToGetGrpFilterSort(pGrps, m_iGrpFilterSort);
|
|
}
|
|
else
|
|
{
|
|
MSXML2::IXMLDOMNodeListPtr pGrps = pXMLEl->selectNodes(TARCH_LAYER_GROUP_NODE_NAME_CSTRING);
|
|
if(!pGrps)
|
|
return false;
|
|
MSXML2::IXMLDOMNodePtr pGrp = pGrps->nextNode();
|
|
if(!pGrp)
|
|
return false;
|
|
//因为之前做判断调用过nextNode()方法，跳过第一个结点了，所以再重新赋值一次
|
|
pGrps = pXMLEl->selectNodes(TARCH_LAYER_GROUP_NODE_NAME_CSTRING);
|
|
ReadXMLFileToGetChildNode(pRoot, pGrps);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void TDocCreateLayer::InitDocLayerRecordParamNumMap()
|
|
{
|
|
if (JudgeDocIsNewOrExist())
|
|
{
|
|
CreatNewDwgToInitLayerAndGroup();
|
|
}
|
|
ChangeDocToChangeLayerRecordParamNum();
|
|
}
|
|
|
|
void TDocCreateLayer::ChangeDocToChangeLayerRecordParamNum()
|
|
{
|
|
CString sName = utility::GetCurFileName(m_pDatabase);
|
|
std::map<CString, LayerRecordParamNum*>::iterator itrParamNum = m_arAllDocLayerRecordParamNumHeader.begin();
|
|
itrParamNum = m_arAllDocLayerRecordParamNumHeader.find(sName);
|
|
if (itrParamNum != m_arAllDocLayerRecordParamNumHeader.end())
|
|
{
|
|
m_pCurLayerRecordParamNumHeader = itrParamNum->second;
|
|
}
|
|
else
|
|
{
|
|
UpdateLayerInUseStateByCAD();
|
|
LayerRecordParamNum *m_pCurHeader = new LayerRecordParamNum;
|
|
AcDbLayerTable *pLayerTable = NULL;
|
|
Acad::ErrorStatus bError = m_pDatabase->getSymbolTable(pLayerTable, AcDb::kForRead);
|
|
if (bError != Acad::eOk)
|
|
return;
|
|
AcDbLayerTableIterator *pItor = NULL;
|
|
bError = pLayerTable->newIterator(pItor);
|
|
bError = pLayerTable->close();
|
|
if (!pItor)
|
|
return;
|
|
AcDbLayerTableRecord *pLayerTableRecord = NULL;
|
|
for (pItor->start();!pItor->done(); pItor->step())
|
|
{
|
|
pLayerTableRecord = NULL;
|
|
bError = pItor->getRecord(pLayerTableRecord, AcDb::kForRead);
|
|
if (bError != Acad::eOk)
|
|
continue;
|
|
else
|
|
{
|
|
m_pCurHeader->iLayerFreezonNum += pLayerTableRecord->isFrozen() ? 1 : 0;
|
|
m_pCurHeader->iLayerLockNum += pLayerTableRecord->isLocked() ? 1 : 0;
|
|
m_pCurHeader->iLayerOffNum += pLayerTableRecord->isOff() ? 1 : 0;
|
|
bError = pLayerTableRecord->close();
|
|
}
|
|
}
|
|
delete pItor;
|
|
m_arAllDocLayerRecordParamNumHeader.insert(std::make_pair(sName, m_pCurHeader));
|
|
m_pCurLayerRecordParamNumHeader = m_pCurHeader;
|
|
}
|
|
}
|
|
|
|
void TDocCreateLayer::DoCreateDocLayer()
|
|
{
|
|
InitJudgeRegistryIsWhole();
|
|
|
|
if (m_bRegistryIsExist)
|
|
{
|
|
InitWhetherCreatStandard();
|
|
InitFirstSetGrpFilter();
|
|
InitarSystemGrpFilter();
|
|
InitNotCreatStandardLayer();
|
|
UpdateStandardLayer();
|
|
|
|
InitStandardGrpRoot();
|
|
InitDocLayerRecordParamNumMap();
|
|
InitCurLayerRecordHeader();
|
|
|
|
GetCurFilterGrpNameByCAD();
|
|
}
|
|
}
|
|
|
|
void TDocCreateLayer::UpdateStandardLayer()
|
|
{
|
|
std::vector<SLayStandardRecord*>::iterator itr = m_arStandardLayerRecord.begin();
|
|
for (; itr != m_arStandardLayerRecord.end(); ++itr)
|
|
{
|
|
deletePtr(*itr);
|
|
}
|
|
m_arStandardLayerRecord.clear();
|
|
InitStandardLayerData();
|
|
}
|
|
|
|
void TDocCreateLayer::InitStandardLayerData()
|
|
{
|
|
m_arStandardLayerRecord.clear();
|
|
CString sTitle(_T(""));
|
|
sTitle.Format(_T("%s"),LAY_STD);
|
|
sTitle += _T(".lay");
|
|
CString sStandardLayerPath = m_sInstallDirectory + TARCH_INSTALL_DIRECTORY_INCLUDE_SYS + sTitle;
|
|
CFileFind finder;
|
|
BOOL bIsExist = finder.FindFile(sStandardLayerPath);
|
|
if (!bIsExist)
|
|
{
|
|
CString str(sStandardLayerPath + _T("图层标准文件不存在"));
|
|
AfxMessageBox(str);
|
|
//GlwLayerWarnMessageBox WndDlgLayerNotDeleteWarn(str, acedGetAcadFrame());
|
|
//WndDlgLayerNotDeleteWarn.DoModal(WS_POPUP | WS_CAPTION
|
|
// | WS_SYSMENU, NULL, acedGetAcadFrame());
|
|
m_bTarchLayIsExist = false;
|
|
return;
|
|
}
|
|
CString sStandardLayerPathDATFile = m_sInstallDirectory + TARCH_INSTALL_DIRECTORY_INCLUDE_SYS + TARCH_CURRENT_LAYER_STANDARD_FILE_NAME;
|
|
bIsExist = finder.FindFile(sStandardLayerPathDATFile);
|
|
if (!bIsExist)
|
|
{
|
|
CString str = sStandardLayerPathDATFile;
|
|
str += _T("文件不存在");
|
|
AfxMessageBox(str);
|
|
//GlwLayerWarnMessageBox WndDlgLayerNotDeleteWarn(str, acedGetAcadFrame());
|
|
//WndDlgLayerNotDeleteWarn.DoModal(WS_POPUP | WS_CAPTION
|
|
// | WS_SYSMENU, NULL, acedGetAcadFrame());
|
|
m_bTarchLayIsExist = false;
|
|
return;
|
|
}
|
|
setlocale(0,"chs");
|
|
CStdioFile *fp(NULL);
|
|
fp = new CStdioFile(sStandardLayerPathDATFile, CFile::modeRead);
|
|
ReadLayerFromTextFile(fp, &m_arStandardLayerRecord);
|
|
fp->Close();
|
|
deletePtr(fp);
|
|
}
|
|
|
|
void TDocCreateLayer::InitCurLayerRecordHeader()
|
|
{
|
|
UpdateLayerInUseStateByCAD();
|
|
Acad::ErrorStatus bError(Acad::eOk);
|
|
AcDbLayerTable *pLayerTable = NULL;
|
|
bError = m_pDatabase->getSymbolTable(pLayerTable, AcDb::kForRead);
|
|
if (bError != Acad::eOk)
|
|
return;
|
|
AcDbLayerTableIterator *pItor = NULL;
|
|
bError = pLayerTable->newIterator(pItor);
|
|
bError = pLayerTable->close();
|
|
if (!pItor)
|
|
return;
|
|
|
|
if (m_pCurLayerRecordHeader.size() > 0)
|
|
{
|
|
std::list<SLayerRecord*>::iterator itr = m_pCurLayerRecordHeader.begin();
|
|
for(; itr != m_pCurLayerRecordHeader.end(); ++itr)
|
|
{
|
|
deletePtr(*itr);
|
|
}
|
|
}
|
|
m_pCurLayerRecordHeader.clear();
|
|
|
|
AcDbLayerTableRecord *pLayerTableRecord(NULL);
|
|
CString sName(_T("")), strLineType(_T(""));
|
|
TCHAR *pStr = NULL;
|
|
AcDbObjectId idLayer(AcDbObjectId::kNull);
|
|
AcDbLinetypeTableRecord* pLinetypeTblRcd(NULL);
|
|
for (pItor->start();!pItor->done(); pItor->step())
|
|
{
|
|
pLayerTableRecord = NULL;
|
|
bError = pItor->getRecord(pLayerTableRecord, AcDb::kForRead);
|
|
if ( bError != Acad::eOk)
|
|
continue;
|
|
bError = pItor->getRecordId(idLayer);
|
|
pLayerTableRecord->getName(pStr);
|
|
sName = pStr;
|
|
acutDelString(pStr);
|
|
bError = acdbOpenObject(pLinetypeTblRcd, pLayerTableRecord->linetypeObjectId(),AcDb::kForRead);
|
|
if (bError == Acad::eOk)
|
|
{
|
|
TCHAR *linetypeName = NULL;
|
|
bError = pLinetypeTblRcd->getName(linetypeName);
|
|
strLineType = linetypeName;
|
|
acutDelString(linetypeName);
|
|
pLinetypeTblRcd->close();
|
|
}
|
|
SLayerRecord *pLayerRecord = new SLayerRecord;
|
|
int iState = pLayerTableRecord->objectId() == m_pDatabase->clayer() ? 0 : (pLayerTableRecord->isInUse() ? 1 : 2);
|
|
pLayerRecord->idLayerObject = idLayer;
|
|
pLayerRecord->iLayerState = iState;
|
|
pLayerRecord->sLayerName = sName;
|
|
pLayerRecord->bLayerOff = pLayerTableRecord->isOff();
|
|
pLayerRecord->bLayerFreeze = pLayerTableRecord->isFrozen();
|
|
pLayerRecord->bLayerLock = pLayerTableRecord->isLocked();
|
|
pLayerRecord->cmColor = pLayerTableRecord->color();
|
|
pLayerRecord->sLTypeName = strLineType;
|
|
pLayerRecord->iLayerLineWidth = pLayerTableRecord->lineWeight();
|
|
pLayerRecord->bLayerPlottable = pLayerTableRecord->isPlottable();
|
|
pLayerRecord->bLayerNewFreeze = pLayerTableRecord->VPDFLT();
|
|
pLayerRecord->sLayerDescription = pLayerTableRecord->description();
|
|
bError = pLayerTableRecord->close();
|
|
m_pCurLayerRecordHeader.push_back(pLayerRecord);
|
|
}
|
|
delete pItor;
|
|
}
|
|
|
|
void TDocCreateLayer::ReadLayerFromTextFile(CStdioFile *fp, std::vector<SLayStandardRecord*>* pLayerStandard)
|
|
{
|
|
CString sReadWords(_T(""));
|
|
CString StandardLayer[5];
|
|
int i(0), j(0), m(0); //i记录读出来的字符串的字符，j记录每行有几个词组，m记录每个词组的字符
|
|
bool bJudge(false);
|
|
while(fp->ReadString(sReadWords))
|
|
{
|
|
for (i = 0; i < 5; ++i)
|
|
{
|
|
StandardLayer[i].Format(_T(""));
|
|
}
|
|
if (!sReadWords.IsEmpty())
|
|
{
|
|
i = 0;
|
|
j = 0;
|
|
m = 0;
|
|
bJudge = false;
|
|
while(sReadWords[i] != _T('\0'))
|
|
{
|
|
if (sReadWords[i] == _T(' '))
|
|
{
|
|
if (bJudge)
|
|
{
|
|
j++;
|
|
bJudge = false;
|
|
}
|
|
i++;
|
|
m = 0;
|
|
}
|
|
else
|
|
{
|
|
StandardLayer[j].Insert(m, sReadWords[i]);
|
|
i++;
|
|
m++;
|
|
bJudge = true;
|
|
}
|
|
}
|
|
if (j >= 2)
|
|
{
|
|
bool bIsIn(false);
|
|
if (m_bNotCreatLayer)
|
|
{
|
|
std::vector<CString>::iterator itrNot = m_arNotCreatStandardLayer.begin();
|
|
for (; itrNot != m_arNotCreatStandardLayer.end(); ++itrNot)
|
|
{
|
|
if (*itrNot == StandardLayer[0])
|
|
{
|
|
bIsIn = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (bIsIn)
|
|
{
|
|
continue;
|
|
}
|
|
if(StandardLayer[2].IsEmpty())
|
|
StandardLayer[2] = _T("7");
|
|
if(StandardLayer[3].IsEmpty())
|
|
StandardLayer[3] = _T("CONTINUOUS");
|
|
SLayStandardRecord *pStandardLayerRecord = new SLayStandardRecord;
|
|
pStandardLayerRecord->sLayerKeyword = StandardLayer[0];
|
|
pStandardLayerRecord->sLayerName = StandardLayer[1];
|
|
pStandardLayerRecord->sColor = StandardLayer[2];
|
|
pStandardLayerRecord->sLineType = StandardLayer[3];
|
|
pStandardLayerRecord->sDescription = StandardLayer[4];
|
|
pLayerStandard->push_back(pStandardLayerRecord);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void TDocCreateLayer::UpdateLayerInUseStateByCAD()
|
|
{
|
|
TDocAutoLock lock;
|
|
AcDbLayerTable *pLayerTableRead = NULL;
|
|
Acad::ErrorStatus bError = m_pDatabase->getSymbolTable(pLayerTableRead, AcDb::kForRead);
|
|
if (bError == Acad::eOk)
|
|
{
|
|
m_bValidModify = false;
|
|
pLayerTableRead->generateUsageData();
|
|
pLayerTableRead->close();
|
|
m_bValidModify = true;
|
|
}
|
|
else
|
|
{
|
|
Acad::ErrorStatus bError = m_pDatabase->getSymbolTable(pLayerTableRead, AcDb::kForWrite);
|
|
if (bError == Acad::eOk)
|
|
{
|
|
m_bValidModify = false;
|
|
pLayerTableRead->generateUsageData();
|
|
pLayerTableRead->close();
|
|
m_bValidModify = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void TDocCreateLayer::InitNotCreatStandardLayer()
|
|
{
|
|
m_arNotCreatStandardLayer.clear();
|
|
CString sNotCreatStandardLayerPath = m_sInstallDirectory + TARCH_INSTALL_DIRECTORY_INCLUDE_SYS + TARCH_LAYER_NOT_CAEAT_STANDARD_LAYER;
|
|
CFileFind finder;
|
|
BOOL bIsExist = finder.FindFile(sNotCreatStandardLayerPath);
|
|
if (!bIsExist)
|
|
{
|
|
CString str = sNotCreatStandardLayerPath;
|
|
str += _T("文件不存在");
|
|
/*GlwLayerWarnMessageBox WndDlgLayerNotDeleteWarn(str, acedGetAcadFrame());
|
|
WndDlgLayerNotDeleteWarn.DoModal(WS_POPUP | WS_CAPTION
|
|
| WS_SYSMENU, NULL, acedGetAcadFrame());*/
|
|
m_bNotCreatLayer = false;
|
|
AfxMessageBox(str);
|
|
return;
|
|
}
|
|
setlocale(0,"chs");
|
|
CStdioFile *fp(NULL);
|
|
fp = new CStdioFile(sNotCreatStandardLayerPath, CFile::modeRead);
|
|
CString sReadWords(_T(""));
|
|
while(fp->ReadString(sReadWords))
|
|
{
|
|
bool bAllIsBlank(false);
|
|
if (sReadWords.GetLength() > 0)
|
|
{
|
|
int i(0);
|
|
for (; i < sReadWords.GetLength(); ++i)
|
|
{
|
|
if (sReadWords.GetAt(i) != _T(' '))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if(i == sReadWords.GetLength())
|
|
{
|
|
bAllIsBlank = true; //不能全部为空格，必须含有一个字符
|
|
}
|
|
}
|
|
if (sReadWords.IsEmpty() || bAllIsBlank)
|
|
{
|
|
continue;
|
|
}
|
|
m_arNotCreatStandardLayer.push_back(sReadWords);
|
|
}
|
|
fp->Close();
|
|
deletePtr(fp);
|
|
}
|
|
|
|
|
|
void TDocCreateLayer::InitNewDocToCreatStandardLayer()
|
|
{
|
|
UpdateLayerInUseStateByCAD();
|
|
TDocAutoLock lock;
|
|
std::vector<SLayStandardRecord*>::iterator itrStandard;
|
|
Acad::ErrorStatus bError(Acad::eOk);
|
|
bool bIsIn(false);
|
|
AcDbLayerTable *pLayerTbl = NULL;
|
|
AcDbObjectId layerid(AcDbObjectId::kNull);
|
|
AcCmColor color;
|
|
wchar_t buf[255];
|
|
AcDbLayerTableRecord *pLayerTableRecord(NULL);
|
|
bool bIsInUse(false);
|
|
for (itrStandard = m_arStandardLayerRecord.begin(); itrStandard != m_arStandardLayerRecord.end(); ++itrStandard)
|
|
{
|
|
bError = m_pDatabase->getSymbolTable(pLayerTbl, AcDb::kForWrite);
|
|
if (bError != Acad::eOk)
|
|
{
|
|
return;
|
|
}
|
|
bIsIn = false;
|
|
bError = pLayerTbl->getAt((*itrStandard)->sLayerName, pLayerTableRecord, AcDb::kForRead);
|
|
if (bError == Acad::eOk)
|
|
{
|
|
bIsIn = true;
|
|
pLayerTableRecord->close();
|
|
}
|
|
if (bIsIn)
|
|
{
|
|
bError = pLayerTbl->close();
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
AcDbLayerTableRecord *pLayerTblRcd = new AcDbLayerTableRecord;
|
|
bError = pLayerTbl->add(layerid, pLayerTblRcd);
|
|
bError = pLayerTbl->close();
|
|
bError = pLayerTblRcd->setName((*itrStandard)->sLayerName); //设定图层名
|
|
utility::GetAccmColorByString((*itrStandard)->sColor, color);
|
|
pLayerTblRcd->setColor(color); //设定图层颜色
|
|
pLayerTblRcd->setLinetypeObjectId(utility::GetIdByName((*itrStandard)->sLineType));
|
|
wcscpy_s(buf, 255, (*itrStandard)->sDescription);
|
|
bError = pLayerTblRcd->setDescription(buf);
|
|
bError = pLayerTblRcd->setLineWeight(AcDb::LineWeight(AcDb::kLnWtByLwDefault)); //设定图层线宽
|
|
bError = pLayerTblRcd->setIsFrozen(false); //设定图层解冻
|
|
pLayerTblRcd->setIsOff(false); //设定图层打开
|
|
if (!bIsInUse)
|
|
{
|
|
bIsInUse = pLayerTblRcd->isInUse();
|
|
}
|
|
pLayerTblRcd->setIsLocked(false); //设定图层解锁
|
|
bError = pLayerTblRcd->setIsPlottable(true); //设定图层可以打印
|
|
pLayerTblRcd->setVPDFLT(false); //设定图层新视口打开
|
|
bError = pLayerTblRcd->close();
|
|
}
|
|
}
|
|
}
|
|
|
|
void TDocCreateLayer::InitNewDocToCreatLayerGroup()
|
|
{
|
|
TDocAutoLock lock;
|
|
AcLyLayerFilterManager *pAclyMager = aclyGetLayerFilterManager(m_pDatabase);
|
|
if (!pAclyMager)
|
|
{
|
|
return;
|
|
}
|
|
Acad::ErrorStatus bOk(Acad::eOk);
|
|
AcLyLayerFilter *pFilterRoot(NULL);
|
|
AcLyLayerFilter *pFilterCur(NULL);
|
|
bOk = pAclyMager->getFilters(pFilterRoot, pFilterCur);
|
|
if (bOk != Acad::eOk)
|
|
{
|
|
return;
|
|
}
|
|
AddLayerFilterGroupNode(pFilterRoot, m_pLayerGrpRoot, pAclyMager, pFilterRoot, pFilterCur);
|
|
if (pFilterCur)
|
|
{
|
|
bOk = pAclyMager->setFilters(pFilterRoot, pFilterCur);
|
|
m_sCurFilterGrpName = pFilterCur->name();
|
|
}
|
|
else
|
|
{
|
|
bOk = pAclyMager->setFilters(pFilterRoot, pFilterRoot);
|
|
m_sCurFilterGrpName = pFilterRoot->name();
|
|
}
|
|
}
|
|
|
|
void TDocCreateLayer::GetCADAcLyLayerFilterByName(CString sGrpName, AcLyLayerFilter* &pFilter, AcLyLayerFilter* &pFilterRoot, AcLyLayerFilter* &pCurRoot, bool bIsXref)
|
|
{
|
|
bool bOk(false);
|
|
AcLyLayerFilterManager *pAclyMager = aclyGetLayerFilterManager(m_pDatabase);
|
|
if (!pAclyMager)
|
|
{
|
|
return;
|
|
}
|
|
Acad::ErrorStatus bError(Acad::eOk);
|
|
bError = pAclyMager->getFilters(pFilterRoot, pCurRoot);
|
|
if (bError != Acad::eOk)
|
|
{
|
|
return;
|
|
}
|
|
bool bHaveXref(false);
|
|
RecursionGetCADGrpFilter(sGrpName, pFilterRoot, bOk, pFilter, bIsXref, bHaveXref);
|
|
}
|
|
|
|
void TDocCreateLayer::RecursionGetCADGrpFilter(CString sGrpName, AcLyLayerFilter* pFilter, bool &bOk, AcLyLayerFilter* &pGetFilter, bool bIsXref, bool &bHaveXref)
|
|
{
|
|
if (bOk) return;
|
|
if (!pFilter) return;
|
|
|
|
CString sName = pFilter->name();
|
|
if (!sName.CompareNoCase(_T("外部参照")) && !pFilter->allowRename())
|
|
{
|
|
bHaveXref = true;
|
|
}
|
|
if (!sGrpName.CompareNoCase(sName))
|
|
{
|
|
if (bIsXref)
|
|
{
|
|
if (bHaveXref)
|
|
{
|
|
bOk = true;
|
|
pGetFilter = pFilter;
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bOk = true;
|
|
pGetFilter = pFilter;
|
|
return;
|
|
}
|
|
}
|
|
AcArray<AcLyLayerFilter*> arRootFilters = pFilter->getNestedFilters();
|
|
for (int i = 0; i < arRootFilters.length(); ++i)
|
|
{
|
|
RecursionGetCADGrpFilter(sGrpName, arRootFilters[i], bOk, pGetFilter, bIsXref, bHaveXref);
|
|
}
|
|
}
|
|
|
|
void TDocCreateLayer::AddLayerFilterGroupNode(AcLyLayerFilter *pFilterGroup, SLayerGrpRecord *pParent, AcLyLayerFilterManager *&pAclyMager, AcLyLayerFilter *&pFilterRoot, AcLyLayerFilter *&pCurRoot, bool bOk)
|
|
{
|
|
std::vector<SLayerGrpRecord*>::iterator itrGrpRecord = pParent->arLayerGrpChild.begin();
|
|
Acad::ErrorStatus bError(Acad::eOk);
|
|
for (; itrGrpRecord!= pParent->arLayerGrpChild.end(); itrGrpRecord++)
|
|
{
|
|
AcLyLayerFilter *pGrpFilterRoot(NULL);
|
|
AcLyLayerFilter *pGrpFilterCur(NULL);
|
|
AcLyLayerFilter *pGrpCur(NULL);
|
|
GetCADAcLyLayerFilterByName((*itrGrpRecord)->sGrpName, pGrpFilterCur, pGrpFilterRoot, pGrpCur,true);
|
|
if (!pGrpFilterCur)
|
|
{
|
|
GetCADAcLyLayerFilterByName((*itrGrpRecord)->sGrpName, pGrpFilterCur, pGrpFilterRoot, pGrpCur, false);
|
|
if (!pGrpFilterCur)
|
|
{
|
|
AcLyLayerGroup* pNewChild = new AcLyLayerGroup;
|
|
bError = pFilterGroup->addNested(pNewChild);
|
|
bError = pNewChild->setName((*itrGrpRecord)->sGrpName);
|
|
if(bOk)
|
|
{
|
|
if (pCurRoot)
|
|
{
|
|
bError = pAclyMager->setFilters(pFilterRoot, pCurRoot);
|
|
m_sCurFilterGrpName = pCurRoot->name();
|
|
}
|
|
else
|
|
{
|
|
bError = pAclyMager->setFilters(pFilterRoot, pFilterRoot);
|
|
m_sCurFilterGrpName = pFilterRoot->name();
|
|
}
|
|
}
|
|
AddLayerFilterGroupNode((AcLyLayerFilter*)pNewChild, (*itrGrpRecord), pAclyMager, pFilterRoot, pCurRoot, bOk);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void TDocCreateLayer::InitClassifyStandardLayerToGroup()
|
|
{
|
|
TDocAutoLock lock;
|
|
AcLyLayerFilterManager *pAclyMager = aclyGetLayerFilterManager(acdbCurDwg());
|
|
if (!pAclyMager)
|
|
{
|
|
return;
|
|
}
|
|
AcLyLayerFilter *pFilterRoot(NULL);
|
|
AcLyLayerFilter *pFilterCur(NULL);
|
|
Acad::ErrorStatus bOk(Acad::eOk);
|
|
bOk = pAclyMager->getFilters(pFilterRoot, pFilterCur);
|
|
if (bOk != Acad::eOk)
|
|
{
|
|
return;
|
|
}
|
|
if(!pFilterRoot)
|
|
{
|
|
return;
|
|
}
|
|
CString sName = pFilterRoot->name();
|
|
if (!sName.CompareNoCase(m_pLayerGrpRoot->sGrpName))
|
|
{
|
|
InitClassifyStandardLayerToGroupImplementationDetails(pFilterRoot, m_pLayerGrpRoot);
|
|
}
|
|
|
|
if (pFilterCur)
|
|
{
|
|
bOk = pAclyMager->setFilters(pFilterRoot, pFilterCur);
|
|
m_sCurFilterGrpName = pFilterCur->name();
|
|
}
|
|
else
|
|
{
|
|
bOk = pAclyMager->setFilters(pFilterRoot, pFilterRoot);
|
|
m_sCurFilterGrpName = pFilterRoot->name();
|
|
}
|
|
}
|
|
|
|
void TDocCreateLayer::GetLayerObjectIDByLayerKeyWord( AcDbObjectId &layerId, CString sKeyWord )
|
|
{
|
|
Acad::ErrorStatus bError(Acad::eOk);
|
|
AcDbLayerTable *pLayerTable(NULL);
|
|
AcDbLayerTableRecord *pLayerTableRecord(NULL);
|
|
bError = acdbCurDwg()->getSymbolTable(pLayerTable, AcDb::kForRead);
|
|
if (bError != Acad::eOk)
|
|
{
|
|
layerId = AcDbObjectId::kNull;
|
|
return;
|
|
}
|
|
CString sLayerName(_T("||||"));
|
|
std::vector<SLayStandardRecord*>::iterator itr = m_arStandardLayerRecord.begin();
|
|
for (; itr != m_arStandardLayerRecord.end(); ++itr)
|
|
{
|
|
if (!(*itr)->sLayerKeyword.CompareNoCase(sKeyWord))
|
|
{
|
|
sLayerName = (*itr)->sLayerName;
|
|
break;
|
|
}
|
|
}
|
|
bError = pLayerTable->getAt(sLayerName, pLayerTableRecord, AcDb::kForRead);
|
|
pLayerTable->close();
|
|
if (bError == Acad::eOk)
|
|
{
|
|
layerId = pLayerTableRecord->objectId();
|
|
pLayerTableRecord->close();
|
|
}
|
|
else
|
|
{
|
|
layerId = AcDbObjectId::kNull;
|
|
}
|
|
}
|
|
|
|
void TDocCreateLayer::InitClassifyStandardLayerToGroupImplementationDetails(AcLyLayerFilter *pFilterGroup, SLayerGrpRecord *pGrpRecord)
|
|
{
|
|
std::vector<CString>::iterator itrLayer = pGrpRecord->arContainLayerName.begin();
|
|
Acad::ErrorStatus bError(Acad::eOk);
|
|
AcDbObjectId IdLayer(AcDbObjectId::kNull);
|
|
for(; itrLayer != pGrpRecord->arContainLayerName.end(); itrLayer++)
|
|
{
|
|
GetLayerObjectIDByLayerKeyWord(IdLayer, *itrLayer);
|
|
if (IdLayer != AcDbObjectId::kNull)
|
|
{
|
|
if (pFilterGroup->isKindOf(AcLyLayerGroup::desc()))
|
|
{
|
|
AcDbObjectIdArray ArrIdLayer = ((AcLyLayerGroup*)pFilterGroup)->layerIds();
|
|
if(ArrIdLayer.find(IdLayer) < 0)
|
|
{
|
|
bError = ((AcLyLayerGroup*)pFilterGroup)->addLayerId(IdLayer);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
AcArray<AcLyLayerFilter*> arRootFilters = pFilterGroup->getNestedFilters();
|
|
CString sName(_T(""));
|
|
for (int i = 0; i < arRootFilters.length(); ++i)
|
|
{
|
|
std::vector<SLayerGrpRecord*>::iterator itrGrpRecord = pGrpRecord->arLayerGrpChild.begin();
|
|
for (; itrGrpRecord!= pGrpRecord->arLayerGrpChild.end(); itrGrpRecord++)
|
|
{
|
|
sName = arRootFilters[i]->name();
|
|
if(!sName.CompareNoCase((*itrGrpRecord)->sGrpName))
|
|
{
|
|
InitClassifyStandardLayerToGroupImplementationDetails((AcLyLayerFilter*)arRootFilters[i], *itrGrpRecord);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void TDocCreateLayer::CreatNewDwgToInitLayerAndGroup()
|
|
{
|
|
if (m_bRegistryIsExist && m_bTarchLayIsExist && m_bWhetherCreatStandardLayer)
|
|
InitNewDocToCreatStandardLayer();
|
|
if (m_bRegistryIsExist && m_bFilterIsExist)
|
|
InitNewDocToCreatLayerGroup();
|
|
|
|
InitClassifyStandardLayerToGroup();
|
|
} |