2897 lines
72 KiB
C++
2897 lines
72 KiB
C++
#include "StdAfx.h"
|
|
#include "frame.h"
|
|
#include "OpeningLabelData.h"
|
|
#include "OpeningCheck.h"
|
|
//#include "SetWinLab.h"
|
|
|
|
namespace NDoorWinCheck
|
|
{
|
|
|
|
extern CDoorWinFrame *pFrame;
|
|
static CString strDoorTypeName[eDoorTypeNum] =
|
|
{
|
|
_T("门"), _T("门连窗"), _T("子母门"), _T("组合门窗"), _T("窗"),
|
|
_T("弧窗"), _T("凸窗"), _T("转角窗"), _T("带形窗"), _T("老虎窗"),
|
|
_T("洞口")
|
|
};
|
|
|
|
static CString strDoorTyeHead[eDoorTypeNum] =
|
|
{
|
|
_T("M"), _T("MC"), _T("ZM"), _T("ZM"), _T("C"),
|
|
_T("HC"), _T("TC"), _T("ZJC"), _T("DC"), _T("LHC"),
|
|
_T("DK")
|
|
};
|
|
|
|
static CString s_strParaName[eDoorWinParmNum] =
|
|
{
|
|
_T("编号"), _T("新编号"), _T("类型"), _T("宽度"), _T("高度"), _T("底高"), _T("型式"), _T("出挑长"), _T("梯形宽")
|
|
};
|
|
|
|
static EShowItem s_showItem[eDoorWinParmNum] =
|
|
{
|
|
eLabelProp, eNewLabelProp, eTypeProp, eWidProp, eHeiProp, eEle, eGeoTypeProp, eChutiaoProp, eTixingkuanProp
|
|
};
|
|
|
|
#ifndef NDEBUG
|
|
static DWORD dwtime = 0;
|
|
static DWORD dwRead = 0;
|
|
static DWORD dwRead1 = 0;
|
|
static DWORD dwRead2 = 0;
|
|
static DWORD dwRead3 = 0;
|
|
#endif
|
|
EShowItem GetShowItem(EShowItem eShowIndex)
|
|
{
|
|
ASSERT(eShowIndex < eDoorWinParmNum);
|
|
return s_showItem[eShowIndex];
|
|
}
|
|
|
|
EShowItem ShowItem2Index(EShowItem eShowItem)
|
|
{
|
|
for (int i = 0; i < eDoorWinParmNum; i++)
|
|
{
|
|
if (GetShowItem(EShowItem(i)) == eShowItem)
|
|
return EShowItem(i);
|
|
}
|
|
|
|
return eLabelIndex;// 这里不能走到
|
|
}
|
|
|
|
CString ParamTypeToString(EShowItem eShowItem)
|
|
{
|
|
return s_strParaName[ShowItem2Index(eShowItem)];
|
|
}
|
|
|
|
BOOL IsTextShowItem(EShowItem eItem)
|
|
{
|
|
return eItem == eLabelProp ||
|
|
eItem == eNewLabelProp ||
|
|
eItem == eWidProp ||
|
|
eItem == eHeiProp;
|
|
}
|
|
|
|
// 更新显示，不管ID对应的是普通实体，块参照实体，或者外部参照实体
|
|
void UpdateGraphicAny(const TDPtrList<AcDbObjectId> &ss)
|
|
{
|
|
AcDbBlockTable *pTable;
|
|
AcDbObjectId modelId;
|
|
if (curDoc()->database()->getBlockTable(pTable, AcDb::kForRead) == Acad::eOk)
|
|
{
|
|
pTable->getAt(ACDB_MODEL_SPACE, modelId, AcDb::kForRead);
|
|
pTable->close();
|
|
}
|
|
|
|
bool bHasBolck = false;
|
|
for (int i = 0; i < (int)ss.Length(); i++)
|
|
{
|
|
OPENOBJ_BEGIN((ss[i]), AcDb::kForRead, AcDbEntity, pEnt)
|
|
if (pEnt != NULL && pEnt->ownerId() != modelId)
|
|
{
|
|
bHasBolck = true;
|
|
break;
|
|
}
|
|
OPENOBJ_END()
|
|
}
|
|
|
|
if (bHasBolck)
|
|
{
|
|
PickSet ssp(SS_FREE);
|
|
ssp.Get(_T("X"), NULL, NULL, RBList(RTDXF0, _T("INSERT"), NULL));
|
|
UpdateGraphic(ssp);
|
|
}
|
|
|
|
UpdateGraphic(ss);
|
|
}
|
|
|
|
|
|
void LockDocumentChange()
|
|
{
|
|
if (acDocManager->isDocumentActivationEnabled())
|
|
{
|
|
Acad::ErrorStatus error = acDocManager->disableDocumentActivation();
|
|
// acDocManager->enableDocumentActivation();
|
|
if (error == Acad::eOk)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
void UnLockDocumentChange()
|
|
{
|
|
if (!acDocManager->isDocumentActivationEnabled())
|
|
{
|
|
Acad::ErrorStatus error = acDocManager->enableDocumentActivation();
|
|
if (error == Acad::eOk)
|
|
{
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL IsSlideType(EEntType eEntType)
|
|
{
|
|
if (eEntType == eM ||
|
|
eEntType == eC ||
|
|
eEntType == eMLC ||
|
|
eEntType == eZMM)
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL IsEmptyProject()
|
|
{
|
|
CString strProj = _T("");
|
|
BOOL bEmpty = !g_project.GetProjectName(strProj);
|
|
return bEmpty;
|
|
}
|
|
|
|
CString ProjectName()
|
|
{
|
|
CString strProj = _T("");
|
|
BOOL bEmpty = !g_project.GetProjectName(strProj);
|
|
if (strProj.GetLength() > 4)
|
|
{ // 去掉工程名字的后缀，.tpr
|
|
strProj = strProj.Left(strProj.GetLength() - 4);
|
|
}
|
|
return strProj;
|
|
}
|
|
|
|
CString ProjectFullName()
|
|
{
|
|
CString strProj = _T("");
|
|
BOOL bEmpty = !g_project.GetFileFullName();
|
|
return strProj;
|
|
}
|
|
|
|
CString Type2Name(EEntType eEntType)
|
|
{
|
|
return strDoorTypeName[eEntType];
|
|
}
|
|
|
|
CWidItem* FindWidItem(const AryWidItemPtr &aryWidItem, CString strLabel)
|
|
{
|
|
for (int i = 0; i < (int)aryWidItem.GetSize(); i++)
|
|
{
|
|
if (aryWidItem[i]->strLabel.CompareNoCase(strLabel) == 0)
|
|
return aryWidItem[i];
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
int FindIdArry(const DList<AcDbObjectId> &lstId, const AcDbObjectId &id)
|
|
{
|
|
for (int i = 0; i < (int)lstId.Length(); i++)
|
|
{
|
|
const AcDbObjectId &tempId = lstId[i];
|
|
// CAD的老版本中，如果某ID所在的图形当前没有打开，直接进行的ID相等比较会导致程序崩溃
|
|
if (id.asOldId() == tempId.asOldId())
|
|
return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
int FindIdArry(const AcDbObjectIdArray &idArry, const AcDbObjectId &id)
|
|
{
|
|
for (int i = 0; i < (int)idArry.length(); i++)
|
|
{
|
|
// CAD的老版本中，如果某ID所在的图形当前没有打开，直接进行的ID相等比较会导致程序崩溃
|
|
if (id.asOldId() == idArry[i].asOldId())
|
|
return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
// 向widItem数组中添加pItem
|
|
void AddItemToWidItemAry(AryWidItemPtr &aryWidItem, CItem *pItem)
|
|
{
|
|
if (pItem == NULL)
|
|
return;
|
|
|
|
CWidItem *pWidItem = FindWidItem(aryWidItem, pItem->strLabel);
|
|
if (pWidItem == NULL)
|
|
{
|
|
pWidItem = new CWidItem;
|
|
aryWidItem.Add(pWidItem);
|
|
}
|
|
|
|
pWidItem->AddItem(pItem);
|
|
}
|
|
|
|
void ClearAryWidItemPtr(AryWidItemPtr &aryWidItemPtr)
|
|
{
|
|
for (int i = 0; i < (int)aryWidItemPtr.GetSize(); i++)
|
|
{
|
|
delete aryWidItemPtr[i];
|
|
aryWidItemPtr[i] = NULL;
|
|
}
|
|
|
|
aryWidItemPtr.RemoveAll();
|
|
}
|
|
void ItemPtrAry2Wid(const AryItemPtr &aryItemPtr, AryWidItemPtr &aryWidItem)
|
|
{
|
|
for (int i = 0; i < (int)aryItemPtr.GetSize(); i++)
|
|
{
|
|
CWidItem *pWidItem = new CWidItem(aryItemPtr[i]);
|
|
aryWidItem.Add(pWidItem);
|
|
}
|
|
}
|
|
|
|
// 将当前的属性数据覆盖DWG图纸中的数据，需要pEnt是门窗类型。
|
|
void UpdateProp2DWG(AcDbEntity* pEnt, EEntType eEntType, AryEShowItem &aryEShowItem, CStringArray &aryProp)
|
|
{
|
|
if (pEnt == NULL)
|
|
return;
|
|
|
|
pEnt->assertWriteEnabled();
|
|
pEnt->recordGraphicsModified();
|
|
if (pEnt->isKindOf(AcDbText::desc()))
|
|
{
|
|
AcDbText *pText = AcDbText::cast(pEnt);
|
|
for (int i = 0; i < (int)aryProp.GetSize(); i++)
|
|
{
|
|
if (aryEShowItem[i] == eNewLabelProp)
|
|
{
|
|
pText->setTextString(aryProp[i]);
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
else if (pEnt->isKindOf(TDbText::desc()))
|
|
{
|
|
TDbText *pText = TDbText::cast(pEnt);
|
|
for (int i = 0; i < (int)aryProp.GetSize(); i++)
|
|
{
|
|
if (aryEShowItem[i] == eNewLabelProp)
|
|
{
|
|
pText->SetText(aryProp[i]);
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
switch(eEntType)
|
|
{
|
|
case eM: // 门
|
|
case eC: // 窗
|
|
case eHC: // 弧窗
|
|
case eMLC: // 门连窗
|
|
case eZMM: // 子母门
|
|
case eZHMC: // 组合门窗
|
|
case eDK: // 洞口
|
|
case eTC:// 凸窗
|
|
{
|
|
TDbOpening *pOpening = TDbOpening::cast(pEnt);
|
|
if (pOpening == NULL)
|
|
break;
|
|
|
|
for (int i = 0; i < (int)aryEShowItem.GetSize(); i++)
|
|
{
|
|
if (aryEShowItem[i] == eTypeProp)
|
|
{
|
|
if (eEntType == eTC)
|
|
{
|
|
XBayWindow::XBayWinStyle style = GeoType2Style(aryProp[i]);
|
|
if (style != XBayWindow::BWS_UNKNOWN)
|
|
{
|
|
pOpening->m_pBayWin->m_nStyle = style;
|
|
}
|
|
}
|
|
else if (eEntType == eM || eEntType == eC || eEntType == eHC)
|
|
{
|
|
pOpening->SetSubKind(aryProp[i]);
|
|
}
|
|
}
|
|
else if (aryEShowItem[i] == eNewLabelProp)
|
|
{
|
|
pOpening->SetLabel(aryProp[i]);
|
|
}
|
|
else if (aryEShowItem[i] == eWidProp)
|
|
{
|
|
double iWid = _tstof(aryProp[i]);
|
|
if (iWid > 0)
|
|
pOpening->SetWidth(iWid);
|
|
|
|
}
|
|
else if (aryEShowItem[i] == eHeiProp)
|
|
{
|
|
double iHei = _tstof(aryProp[i]);
|
|
if (iHei > 0)
|
|
{
|
|
pOpening->SetHeight(iHei);
|
|
}
|
|
|
|
}
|
|
else if (aryEShowItem[i] == eEle)
|
|
{
|
|
double iEle = _tstof(aryProp[i]);
|
|
if (iEle > -1e-6)
|
|
{
|
|
//modify by lgy 20120301 标高无法设置到门窗实体中的主要原因是
|
|
//不知道谁出于什么原因把下面这句代码给注释了故无法设置标高
|
|
//pOpening->SetElevation(iEle);
|
|
pOpening->SetSill(iEle);
|
|
}
|
|
}
|
|
else if (aryEShowItem[i] == eGeoTypeProp)
|
|
{
|
|
if (eEntType == eTC)
|
|
{
|
|
XBayWindow::XBayWinStyle style = GeoType2Style(aryProp[i]);
|
|
if (style != XBayWindow::BWS_UNKNOWN)
|
|
{
|
|
pOpening->m_pBayWin->m_nStyle = style;
|
|
}
|
|
} // 其他的不用修改
|
|
}
|
|
else if (aryEShowItem[i] == eChutiaoProp)
|
|
{
|
|
double iChuTiao = _tstof(aryProp[i]);
|
|
pOpening->m_pBayWin->m_nProtrude = iChuTiao;
|
|
}
|
|
else if (aryEShowItem[i] == eTixingkuanProp)
|
|
{
|
|
if (eEntType == eTC && pOpening->m_pBayWin->m_nStyle == XBayWindow::BWS_TRAPEZIA)
|
|
{ // 梯形凸窗
|
|
double iTiXingkuan = _tstof(aryProp[i]);
|
|
pOpening->m_pBayWin->m_nTrapezia = iTiXingkuan;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
break;
|
|
case eDXC: // 带型窗
|
|
{
|
|
TDbBandWin *pBanWin = TDbBandWin::cast(pEnt);
|
|
if (pBanWin == NULL)
|
|
break;
|
|
|
|
for (int i = 0; i < (int)aryEShowItem.GetSize(); i++)
|
|
{
|
|
if (aryEShowItem[i] == eHeiProp)
|
|
{
|
|
double iHei = _tstof(aryProp[i]);
|
|
if (iHei > 0)
|
|
pBanWin->SetHeight(iHei);
|
|
}
|
|
else if (aryEShowItem[i] == eNewLabelProp)
|
|
{
|
|
pBanWin->SetLabel(aryProp[i]);
|
|
}
|
|
else if (aryEShowItem[i] == eEle)
|
|
{
|
|
double iEle = _tstof(aryProp[i]);
|
|
pBanWin->SetElevation(iEle);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case eZJC: // 转角窗
|
|
{
|
|
TDbCornerWin *pCorWin = TDbCornerWin::cast(pEnt);
|
|
if (pCorWin == NULL)
|
|
break;
|
|
|
|
for (int i = 0; i < (int)aryEShowItem.GetSize(); i++)
|
|
{
|
|
if (aryEShowItem[i] == eHeiProp)
|
|
{
|
|
double iHei = _tstof(aryProp[i]);
|
|
if (iHei > 0)
|
|
pCorWin->SetHeight(iHei);
|
|
}
|
|
else if (aryEShowItem[i] == eNewLabelProp)
|
|
{
|
|
pCorWin->SetLabel(aryProp[i]);
|
|
}
|
|
else if (aryEShowItem[i] == eEle)
|
|
{
|
|
double iEle = _tstof(aryProp[i]);
|
|
pCorWin->SetElevation(iEle);
|
|
}
|
|
else if (aryEShowItem[i] == eChutiaoProp && pCorWin->IsProtrude())
|
|
{ // 转交凸窗才可以编辑出挑长
|
|
double iChuTiao = _tstof(aryProp[i]);
|
|
if (iChuTiao >= 0)
|
|
{
|
|
pCorWin->SetProtrude(iChuTiao);
|
|
// sg modify 120530，增加凸窗出挑长2
|
|
pCorWin->SetProtrude2(iChuTiao);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case eLHC: // 老虎窗
|
|
{
|
|
TDbDormer *pDormer = TDbDormer::cast(pEnt);
|
|
if (pDormer == NULL)
|
|
break;
|
|
TDormerPar dp = pDormer->GetDormerPar();
|
|
|
|
for (int i = 0; i < (int)aryEShowItem.GetSize(); i++)
|
|
{
|
|
if (aryEShowItem[i] == eHeiProp)
|
|
{
|
|
double iHei = _tstof(aryProp[i]);
|
|
if (iHei > 0)
|
|
dp.SetWindowHeight(iHei);
|
|
}
|
|
else if (aryEShowItem[i] == eNewLabelProp)
|
|
{
|
|
pDormer->SetLabel(aryProp[i]);
|
|
}
|
|
}
|
|
|
|
pDormer->SetDormerPar(dp);
|
|
}
|
|
break;
|
|
default:
|
|
return;
|
|
break;
|
|
}
|
|
}
|
|
extern TARCH_IMPEXP void CheckOp3dStyle(AcDbObjectId idStyle3d);
|
|
extern TARCH_IMPEXP void CheckOp2dStyle(AcDbObjectId idStyle2d);
|
|
void UpdateEntStyle(TDbEntity *pEnt, EEntType eEntType, CString strStyle, bool b2dOr3d)
|
|
{
|
|
if (pEnt == NULL)
|
|
return;
|
|
|
|
pEnt->assertWriteEnabled();
|
|
if (IsSlideType(eEntType))
|
|
{
|
|
TDbOpening *pOpening = TDbOpening::cast(pEnt);
|
|
if (pOpening == NULL)
|
|
return;
|
|
|
|
AcDbObjectId idStyle;
|
|
|
|
XString sBlock2d(_T("%s%s"), g_sDwbPath, strStyle);
|
|
XString szBlock2d;
|
|
Adesk::Boolean bLoad2d=(LoadDwbBlock(sBlock2d, szBlock2d)==RTNORM);
|
|
idStyle=InitBlock(szBlock2d);
|
|
|
|
if (b2dOr3d)
|
|
{
|
|
// CheckOp2dStyle(idStyle);
|
|
if (!!idStyle)
|
|
pOpening->m_nIdStyle2d = idStyle;
|
|
}
|
|
else
|
|
{
|
|
// CheckOp3dStyle(idStyle);
|
|
if (!!idStyle)
|
|
pOpening->m_nIdStyle3d = idStyle;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
BOOL CheckName(const CString &strName)
|
|
{
|
|
CString strHead = _T(""), strHei = _T(""), strWid = _T("");
|
|
|
|
if (GetSize(strName, strHead, strHei, strWid))
|
|
{
|
|
if (TextLabelType(strHead) < eDoorTypeNum)
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
// 获取尺寸编号的尺寸 === "前缀 + 高（2位） + 宽（2位）"
|
|
BOOL GetSize(const CString &strName, CString &strHead, CString &strHei, CString &strWid)
|
|
{
|
|
if (strName.GetLength() < 5)
|
|
return FALSE; // 不够5个长度肯定不是尺寸编号，
|
|
|
|
CString strSize = strName.Right(4);
|
|
strWid = strSize.Left(2);
|
|
strHei = strSize.Right(2);
|
|
|
|
if (_ttoi(strHei) > 0 && _ttoi(strWid) > 0)
|
|
{
|
|
strHead = strName.Left(strName.GetLength() - 4);
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL GetSize(const CString &strName, CString &strHead, double &dHei, double &dWid)
|
|
{
|
|
CString strHei = _T(""), strWid = _T("");
|
|
if (GetSize(strName, strHead, strHei, strWid))
|
|
{
|
|
dHei = _tstof(strHei) * 100;
|
|
dWid = _tstof(strWid) * 100;
|
|
return TRUE;
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
EEntType TextLabelType(const CString &strLabelHead)
|
|
{
|
|
CString sHead = strLabelHead;
|
|
if (strLabelHead.GetLength()>1 && strLabelHead.GetAt(strLabelHead.GetLength()-1) == _T('-'))
|
|
{
|
|
sHead = strLabelHead.Left(strLabelHead.GetLength()-1);
|
|
}
|
|
|
|
const CString sDoorDatas[eDoorTypeNum] =
|
|
{
|
|
_T("Door"), _T("DoorWin"), _T("TwoDoor"), _T("GroupOpening"),
|
|
_T("Window"), _T("ArcWin"), _T("BayWin"), _T("CornerWin"),
|
|
_T("BandWin"), _T("Dormer"), _T("Hole")
|
|
};
|
|
|
|
TOpeningLabelData ddd;
|
|
|
|
for (int i = 0; i < eDoorTypeNum; i++)
|
|
{
|
|
CStringArray arystr;
|
|
ddd.GetSubLabelPrefix(sDoorDatas[i], arystr);
|
|
|
|
for (int j = 0; j < (int)arystr.GetSize(); j++)
|
|
{
|
|
if (arystr[j].CompareNoCase(sHead) == 0)
|
|
return EEntType(i);
|
|
}
|
|
}
|
|
|
|
return eDoorTypeNum;
|
|
}
|
|
|
|
BOOL TestEmptyItem(CItem *pItem, BOOL bText, BOOL bBlock)
|
|
{
|
|
if (pItem == NULL)
|
|
return TRUE;
|
|
else
|
|
{
|
|
for (int jProp = 0; jProp < (int)pItem->aryProp.GetSize(); jProp++)
|
|
{
|
|
if ((!bBlock && pItem->aryProp[jProp].bBlock) ||
|
|
(!bText && pItem->aryProp[jProp].bText))
|
|
continue;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
BOOL TestItemEmpty(const AryItemPtr &aryItemPtr, BOOL bText, BOOL bBlock)
|
|
{
|
|
if (bText && bBlock)
|
|
{ // 文字和快都显示，则直接查看该数组是否为空
|
|
return IsEmpty(aryItemPtr);
|
|
}
|
|
|
|
for (int i = 0; i < (int)aryItemPtr.GetSize(); i++)
|
|
{
|
|
if (TestEmptyItem(aryItemPtr[i], bText, bBlock))
|
|
continue;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
BOOL TestItemEmpty(const AryWidItemPtr &aryItemPtr, BOOL bText, BOOL bBlock)
|
|
{
|
|
if (bText && bBlock)
|
|
{ // 文字和快都显示，则直接查看该数组是否为空
|
|
return IsEmpty(aryItemPtr);
|
|
}
|
|
|
|
for (int iWid = 0; iWid < (int)aryItemPtr.GetSize(); iWid++)
|
|
{
|
|
CWidItem *pWid = aryItemPtr[iWid];
|
|
if (pWid == NULL)
|
|
continue;
|
|
|
|
for (int iItem = 0; iItem < (int)pWid->aryItem.GetSize(); iItem++)
|
|
{
|
|
if (TestEmptyItem(pWid->aryItem[iItem], bText, bBlock))
|
|
continue;
|
|
else
|
|
return FALSE;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
//add by lgy 20120227 添加该函数是为了解析获得的参照中的实体样式字符串，以用来
|
|
//解决在门窗检查命令中如果图纸中保存的是DWG参照，无法读取实体的样式
|
|
CString FindSpace(CString &str, const CString &sSep)
|
|
{
|
|
CString sLeft = _T("");
|
|
int iPos = 0;
|
|
if((iPos = str.Find(sSep)) != -1)
|
|
{
|
|
sLeft = str.Left(iPos);
|
|
sLeft.TrimLeft();
|
|
sLeft.TrimRight();
|
|
int iLen = sSep.GetLength();
|
|
str = str.Mid(iPos+iLen);
|
|
str.TrimLeft();
|
|
str.TrimRight();
|
|
return sLeft;
|
|
}
|
|
return str;
|
|
}
|
|
|
|
BOOL GetDoorWinProp(AcDbObjectId &id, SOpeningProp &soprop, EEntType &eOpType)
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForRead, AcDbEntity, pEnt)
|
|
if (pEnt == NULL)
|
|
return FALSE;
|
|
|
|
soprop.bText = false;
|
|
if (pEnt->isKindOf(TDbOpening::desc()))
|
|
{
|
|
TDbOpening *pOpening = TDbOpening::cast(pEnt);
|
|
TDbOpening::OpeningKind kind = pOpening->GetKind();
|
|
|
|
if ((pOpening->GetSubKind() == _T("电梯门")) || (pOpening->GetSubKind() == _T("隔断门")) ||
|
|
(pOpening->m_nOpStyle&OPS_LIFTDOOR) || (pOpening->m_nOpStyle&OPS_LVTRY))
|
|
{ // 隔断门和电梯门，不处理
|
|
return FALSE;
|
|
}
|
|
|
|
soprop.strLabel = pOpening->GetLabel();
|
|
soprop.nHei = (int)(pOpening->GetHeight());
|
|
soprop.nWid = (int)(pOpening->GetWidth()); // 这几个属性是共有的。
|
|
soprop.nEle = (int)(pOpening->GetElevation());
|
|
soprop.strType = pOpening->GetSubKind();
|
|
XString sDwb2D, sDwb3D, sDwg2D, sDwg3D;
|
|
if (pOpening->GetStyle2dName(sDwb2D, sDwg2D)==Acad::eOk)
|
|
{
|
|
soprop.str2DShowStyle = XString(_T("%s(%s)"), (TCHAR *)sDwb2D, (TCHAR *)sDwg2D);
|
|
}
|
|
else
|
|
{
|
|
//modify by lgy 20120227 图块参照中的实体读不出来样式
|
|
//原来如果图纸中是DWG参照，则无法读取实体的三维样式和二维样式
|
|
//旧版图纸转化而来
|
|
//soprop.str2DShowStyle = _T("");
|
|
XString strDwbTemp;
|
|
pOpening->GetStyle2dName(strDwbTemp);
|
|
|
|
CString strDwb2D = strDwbTemp;
|
|
FindSpace(strDwb2D, _T("$"));
|
|
CString strTemp = FindSpace(strDwb2D, _T("$"));
|
|
strTemp = strTemp + _T("(") + strDwb2D + _T(")");
|
|
soprop.str2DShowStyle = strTemp;
|
|
}
|
|
|
|
if (pOpening->GetStyle3dName(sDwb3D, sDwg3D)==Acad::eOk)
|
|
{
|
|
soprop.str3DShowStyle = XString(_T("%s(%s)"), (TCHAR *)sDwb3D, (TCHAR *)sDwg3D);
|
|
}
|
|
//add by lgy 20120227 图块参照中的实体读不出来三维样式
|
|
//原来如果图纸中是DWG参照，则无法读取实体的三维样式和二维样式
|
|
//现在添加else分支，这样可以保证读取3维样式能读取出来
|
|
else
|
|
{
|
|
XString strDwbTemp;
|
|
pOpening->GetStyle3dName(strDwbTemp);
|
|
|
|
CString strDwb3D = strDwbTemp;
|
|
FindSpace(strDwb3D, _T("$")); //首先保证读取出来的3维样式字符串中只有一个$分隔符
|
|
|
|
CString strTemp = FindSpace(strDwb3D, _T("$"));
|
|
strTemp = strTemp + _T("(") + strDwb3D + _T(")");
|
|
soprop.str3DShowStyle = strTemp;
|
|
}
|
|
|
|
switch(kind)
|
|
{
|
|
case TDbOpening::OP_DOOR: // 门
|
|
eOpType = eM;
|
|
break;
|
|
case TDbOpening::OP_WINDOW: // 窗
|
|
eOpType = eC;
|
|
break;
|
|
case TDbOpening::OP_CORNWIN:
|
|
eOpType = eC;
|
|
break;
|
|
case TDbOpening::OP_ARCWIN: // 弧窗
|
|
eOpType = eHC;
|
|
break;
|
|
case TDbOpening::OP_DOORWIN: // 门连窗
|
|
eOpType = eMLC;
|
|
break;
|
|
case TDbOpening::OP_TWODOOR: // 子母门
|
|
eOpType = eZMM;
|
|
break;
|
|
case TDbOpening::OP_GROUP: // 组合门窗
|
|
eOpType = eZHMC;
|
|
break;
|
|
case TDbOpening::OP_HOLE: // 洞口
|
|
eOpType = eDK;
|
|
break;
|
|
case TDbOpening::OP_PROWIN:// 凸窗
|
|
eOpType = eTC;
|
|
soprop.eProWinGeo = pOpening->m_pBayWin->m_nStyle; // 型式
|
|
soprop.nChuTiaoChang = (int)(pOpening->m_pBayWin->m_nProtrude);
|
|
soprop.nTixingkuan = (int)(pOpening->m_pBayWin->m_nTrapezia);
|
|
break;
|
|
default:
|
|
return FALSE;
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
else if (pEnt->isKindOf(TDbCornerWin::desc()))
|
|
{
|
|
soprop.str2DShowStyle = _T("");
|
|
soprop.str3DShowStyle = _T("");
|
|
|
|
if (pEnt->isKindOf(TDbBandWin::desc()))
|
|
{ // 带型窗
|
|
TDbBandWin *pBanWin = TDbBandWin::cast(pEnt);
|
|
soprop.strLabel = pBanWin->GetLabel();
|
|
soprop.nHei = (int)(pBanWin->GetHeight());
|
|
// sg modify 120514，根据9.0需求，带形窗宽度的测量改用中心线
|
|
//soprop.nWid = (int)(pBanWin->GetWidth());
|
|
soprop.nWid = (int)(pBanWin->GetGeomCenterWidth());
|
|
soprop.nEle = (int)(pBanWin->GetElevation());
|
|
eOpType = eDXC;
|
|
}
|
|
else
|
|
{ // 转角窗
|
|
TDbCornerWin *pCorWin = TDbCornerWin::cast(pEnt);
|
|
soprop.strLabel = pCorWin->GetLabel();
|
|
soprop.nHei = (int)(pCorWin->GetHeight());
|
|
|
|
// sg modify 120514，根据9.0需求，转角窗宽度的测量要根据编号设置，分别按阴角、中线、阳角分别读取
|
|
//soprop.nWid = (int)(pCorWin->GetWidth1() + pCorWin->GetWidth2());
|
|
{
|
|
TOpeningLabelData labelData;
|
|
TOpeningLabelData::ECalWidthRule nRule = labelData.GetCalWidthRule();
|
|
|
|
double dWidth1 = pCorWin->GetWidth1(),
|
|
dWidth2 = pCorWin->GetWidth2();
|
|
if (nRule == TOpeningLabelData::kMiddle)
|
|
{
|
|
dWidth1 = dWidth1 + pCorWin->GetWallThick2()*0.5;
|
|
dWidth2 = dWidth2 + pCorWin->GetWallThick1()*0.5;
|
|
}
|
|
else if (nRule == TOpeningLabelData::kOutboard)
|
|
{
|
|
dWidth1 = dWidth1 + pCorWin->GetWallThick2();
|
|
dWidth2 = dWidth2 + pCorWin->GetWallThick1();
|
|
}
|
|
soprop.nWid = (int)(dWidth1 + dWidth2);
|
|
}
|
|
|
|
soprop.nEle = (int)(pCorWin->GetElevation());
|
|
soprop.nChuTiaoChang = (int)(pCorWin->GetProtrude()); // 出挑长
|
|
soprop.bZJCTuChuang = pCorWin->IsProtrude() ? true : false;
|
|
eOpType = eZJC;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
else if (pEnt->isKindOf(TDbDormer::desc()))
|
|
{ // 老虎窗
|
|
soprop.str2DShowStyle = _T("");
|
|
soprop.str3DShowStyle = _T("");
|
|
TDbDormer *pDormer = TDbDormer::cast(pEnt);
|
|
|
|
const TDormerPar &dp = pDormer->GetDormerPar();
|
|
soprop.strLabel = pDormer->GetLabel();
|
|
|
|
soprop.nHei = (int)(dp.GetWindowHeight());
|
|
soprop.nWid = (int)(dp.GetWindowWidth());
|
|
|
|
eOpType = eLHC;
|
|
|
|
return TRUE;
|
|
}
|
|
else if (pEnt->isKindOf(AcDbText::desc()))
|
|
{
|
|
AcDbText *pText = AcDbText::cast(pEnt);
|
|
CString strText = pText->textString();
|
|
soprop.bText = true;
|
|
CString strHead;
|
|
double dHei = 0.0, dWid = 0.0;
|
|
if (GetSize(strText, strHead, dHei, dWid))
|
|
{
|
|
soprop.strLabel = strText;
|
|
soprop.nWid = (int)dWid;
|
|
soprop.nHei = (int)dHei;
|
|
eOpType = TextLabelType(strHead);
|
|
if (eOpType >= eDoorTypeNum)
|
|
return FALSE;
|
|
}
|
|
else
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
else if (pEnt->isKindOf(TDbText::desc()))
|
|
{
|
|
TDbText *pText = TDbText::cast(pEnt);
|
|
CString strText = pText->GetText();
|
|
soprop.bText = true;
|
|
CString strHead;
|
|
double dHei = 0.0, dWid = 0.0;
|
|
if (GetSize(strText, strHead, dHei, dWid))
|
|
{
|
|
soprop.strLabel = strText;
|
|
soprop.nWid = (int)dWid;
|
|
soprop.nHei = (int)dHei;
|
|
eOpType = TextLabelType(strHead);
|
|
if (eOpType >= eDoorTypeNum)
|
|
return FALSE;
|
|
}
|
|
else
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
else
|
|
return FALSE;
|
|
|
|
OPENOBJ_END();
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
CString GetDoorWinSizeLabel(EEntType eEntType, const SOpeningProp &sProp)
|
|
{
|
|
const CString sDoorDatas[eDoorTypeNum] =
|
|
{
|
|
_T("Door"), _T("DoorWin"), _T("TwoDoor"), _T("GroupOpening"),
|
|
_T("Window"), _T("ArcWin"), _T("BayWin"), _T("CornerWin"),
|
|
_T("BandWin"), _T("Dormer"), _T("Hole")
|
|
};
|
|
|
|
TOpeningLabelData ddd;
|
|
CStringArray arystr;
|
|
CString strHead;
|
|
ddd.GetSubLabelPrefix(sDoorDatas[eEntType], arystr);
|
|
if (arystr.GetSize() == 1)
|
|
strHead = arystr[0];
|
|
else
|
|
{
|
|
int i ;
|
|
for (i = 0; i < (int)arystr.GetSize(); i++)
|
|
{
|
|
if (arystr[i].CompareNoCase(sProp.strType) == 0)
|
|
{
|
|
strHead = arystr[i];
|
|
break;
|
|
}
|
|
}
|
|
if (i == (int)arystr.GetSize())
|
|
strHead = arystr[0];
|
|
}
|
|
|
|
CString strHei, strWid;
|
|
strWid.Format(_T("%i"), sProp.nWid/100);
|
|
strHei.Format(_T("%i"), sProp.nHei/100);
|
|
while (strWid.GetLength() < 2)
|
|
strWid = _T("0")+strWid;
|
|
while (strHei.GetLength() < 2)
|
|
strHei = _T("0")+strHei;
|
|
|
|
strHead.Format(_T("%s%s%s%s"), strHead, (ddd.HasHypen() ? _T("-") : _T("")), strWid, strHei);
|
|
return strHead;
|
|
}
|
|
|
|
CString GeoType2String(XBayWindow::XBayWinStyle eProWinGeo)
|
|
{
|
|
if (eProWinGeo == XBayWindow::BWS_TRAPEZIA)
|
|
{
|
|
return _T("梯形");
|
|
}
|
|
else if (eProWinGeo == XBayWindow::BWS_TRIANGLE)
|
|
{
|
|
return _T("三角形");
|
|
}
|
|
else if (eProWinGeo == XBayWindow::BWS_ARC)
|
|
{
|
|
return _T("弧形");
|
|
}
|
|
else if (eProWinGeo == XBayWindow::BWS_RECT)
|
|
{
|
|
return _T("矩形");
|
|
}
|
|
else
|
|
return _T("");
|
|
}
|
|
|
|
XBayWindow::XBayWinStyle GeoType2Style(CString &strGeoType)
|
|
{
|
|
if (strGeoType.CompareNoCase(_T("梯形")) == 0)
|
|
{
|
|
return XBayWindow::BWS_TRAPEZIA;
|
|
}
|
|
else if (strGeoType.CompareNoCase(_T("三角形")) == 0)
|
|
{
|
|
return XBayWindow::BWS_TRIANGLE;
|
|
}
|
|
else if (strGeoType.CompareNoCase(_T("弧形")) == 0)
|
|
{
|
|
return XBayWindow::BWS_ARC;
|
|
}
|
|
else if (strGeoType.CompareNoCase(_T("矩形")) == 0)
|
|
{
|
|
return XBayWindow::BWS_RECT;
|
|
}
|
|
else
|
|
return XBayWindow::BWS_UNKNOWN;
|
|
}
|
|
|
|
void SetPropData(SOpeningProp &sProp, EShowItem eShowItem, CString strData)
|
|
{
|
|
strData.TrimLeft();
|
|
strData.TrimRight();
|
|
|
|
int nValData = _ttoi(strData);
|
|
switch (eShowItem)
|
|
{
|
|
case eWidProp:
|
|
sProp.nWid = nValData;
|
|
break;
|
|
case eTypeProp:
|
|
sProp.strType = strData;
|
|
break;
|
|
case eHeiProp:
|
|
sProp.nHei = nValData;
|
|
break;
|
|
case eEle:
|
|
sProp.nEle = nValData;
|
|
break;
|
|
case eGeoTypeProp:
|
|
sProp.eProWinGeo = GeoType2Style(strData);
|
|
break;
|
|
case eChutiaoProp:
|
|
sProp.nChuTiaoChang = nValData;
|
|
break;
|
|
case eTixingkuanProp:
|
|
sProp.nTixingkuan = nValData;
|
|
break;
|
|
case eNewLabelProp:
|
|
sProp.strLabel = strData;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
CString PropToString(const SOpeningProp &prop, EShowItem eShowItem)
|
|
{
|
|
CString strRet;
|
|
switch (eShowItem)
|
|
{
|
|
case eLabelProp:
|
|
if (prop.strLabel.IsEmpty())
|
|
{
|
|
if (prop.pItem == NULL)
|
|
{
|
|
ASSERT(0);
|
|
strRet = _T("empty");
|
|
}
|
|
else
|
|
strRet = prop.pItem->strLabel;
|
|
|
|
}
|
|
else
|
|
strRet = prop.strLabel;
|
|
break;
|
|
case eNewLabelProp:
|
|
strRet = prop.strLabel;
|
|
break;
|
|
case eTypeProp:
|
|
strRet = prop.strType;
|
|
break;
|
|
case eWidProp:
|
|
strRet.Format(_T("%d"), prop.nWid);
|
|
break;
|
|
case eHeiProp:
|
|
strRet.Format(_T("%d"), prop.nHei);
|
|
break;
|
|
case eEle:
|
|
strRet.Format(_T("%d"), prop.nEle);
|
|
break;
|
|
case eGeoTypeProp:
|
|
strRet = GeoType2String(prop.eProWinGeo);
|
|
break;
|
|
case eChutiaoProp:
|
|
strRet.Format(_T("%d"), prop.nChuTiaoChang);
|
|
break;
|
|
case eTixingkuanProp:
|
|
strRet.Format(_T("%d"), prop.nTixingkuan);
|
|
break;
|
|
default:
|
|
return prop.strLabel;
|
|
}
|
|
|
|
return strRet;
|
|
}
|
|
|
|
// 检测属性是否冲突,
|
|
// 检测当前显示的属性是否一致，排除底高，门窗显示的二、三维样式也是判断冲突的依据
|
|
BOOL TestConflict(EEntType eEnttype, const SOpeningProp &sprop1, const SOpeningProp &sprop2)
|
|
{
|
|
// 文字不存于冲突测试，
|
|
if (sprop1.bText || sprop2.bText)
|
|
return FALSE;
|
|
|
|
AryEtype aryEtype;
|
|
aryEtype.Add(eEnttype); // 类型
|
|
AryEShowItem aryEShowItem; // 参数
|
|
DWORD flagCheck = CSetDlg::GetCheckFlag(aryEtype, aryEShowItem);
|
|
|
|
for (int i = 0; i < (int)aryEShowItem.GetSize(); i++)
|
|
{
|
|
if (aryEShowItem[i] == eEle || aryEShowItem[i] == eLabelProp || aryEShowItem[i] == eNewLabelProp)
|
|
continue;
|
|
CString str1 = PropToString(sprop1, aryEShowItem[i]);
|
|
CString str2 = PropToString(sprop2, aryEShowItem[i]);
|
|
|
|
if (str1.CompareNoCase(str2) != 0)
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
if ((sprop1.str2DShowStyle.Compare(sprop2.str2DShowStyle) != 0) ||
|
|
(sprop1.str3DShowStyle.Compare(sprop2.str3DShowStyle) != 0))
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL TestConflict(CItem *pItem)
|
|
{
|
|
for (int i = 0; i < (int)pItem->aryProp.GetSize(); i++)
|
|
{
|
|
for (int j = 0; j < (int)pItem->aryProp.GetSize(); j++)
|
|
{
|
|
if (TestConflict(pItem->eDoorWinType, pItem->aryProp[i], pItem->aryProp[j]))
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL TestConflict(CItem *pItem1, CItem *pItem2)
|
|
{
|
|
for (int i = 0; i < (int)pItem1->aryProp.GetSize(); i++)
|
|
{
|
|
for (int j = 0; j < (int)pItem2->aryProp.GetSize(); j++)
|
|
{
|
|
if (TestConflict(pItem1->eDoorWinType, pItem1->aryProp[i], pItem2->aryProp[j]))
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
int FindEType(AryWidItemPtr &aryWidItem, AryEtype &aryEtype)
|
|
{
|
|
BOOL bFlag[eDoorTypeNum];
|
|
memset(bFlag, 0, sizeof(BOOL)*eDoorTypeNum);
|
|
|
|
for (int i = 0; i < (int)aryWidItem.GetSize(); i++)
|
|
{
|
|
if (!IsEmpty(aryWidItem[i]->aryItem))
|
|
{
|
|
bFlag[aryWidItem[i]->aryItem[0]->eDoorWinType] = TRUE;
|
|
}
|
|
}
|
|
|
|
for (int k = 0; k < eDoorTypeNum; k++)
|
|
{
|
|
EEntType eEntType = EEntType(k);
|
|
if (bFlag[k])
|
|
aryEtype.Add(eEntType);
|
|
}
|
|
|
|
return (int)aryEtype.GetSize();
|
|
}
|
|
|
|
int FindEType(CWidItem *pWidItem, AryEtype &aryEtype)
|
|
{
|
|
if (pWidItem != NULL && !IsEmpty(pWidItem->aryItem))
|
|
{
|
|
aryEtype.Add(pWidItem->aryItem[0]->eDoorWinType);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
CString CItem::GetItemName(bool bCheckText, bool bBlock) const
|
|
{
|
|
CString sLabel = _T("");
|
|
if (this->strLabel.IsEmpty())
|
|
sLabel = _T("未命名");
|
|
|
|
{
|
|
sLabel.Format(_T("%s[%d]"), strLabel, ItemNum(bCheckText, bBlock));
|
|
}
|
|
|
|
|
|
return sLabel;
|
|
}
|
|
|
|
// 非文字的个数。
|
|
int CItem::NoTextDataNum() const
|
|
{
|
|
int iCount = 0;
|
|
for (int i = 0; i < (int)aryProp.GetSize(); i++)
|
|
{
|
|
if (!aryProp[i].bText)
|
|
iCount++;
|
|
}
|
|
return iCount;
|
|
}
|
|
|
|
int CItem::ItemNum(bool bText, bool bBlock) const
|
|
{
|
|
AcDbObjectIdArray idAryTemp;
|
|
for (int i = 0; i < (int)aryId.length(); i++)
|
|
{
|
|
if (!bText && aryProp[i].bText)
|
|
continue;
|
|
if (!bBlock && aryProp[i].bBlock)
|
|
continue;
|
|
|
|
if (FindIdArry(idAryTemp, aryId[i]) == -1)
|
|
{ // 如果之前没有添加的话， 那么添加
|
|
idAryTemp.append(aryId[i]);
|
|
}
|
|
}
|
|
//modify by lgy 20120229 框选块参照时无法正确显示出来选中的实体个数
|
|
//9.0需求导致实际上以上代码多没有用处，只需要返回该行的id数组的长度就可以，不用
|
|
//处理这些id是否是同名的块参照或者外部参照
|
|
//return (int)idAryTemp.length();
|
|
return (int)aryId.length();
|
|
}
|
|
|
|
bool CItem::HasItem(bool bText, bool bBlock) const
|
|
{
|
|
return ItemNum(bText, bBlock) != 0;
|
|
}
|
|
|
|
void CItem::AddProp(SOpeningProp &prop)
|
|
{
|
|
prop.pItem = this;
|
|
aryProp.Add(const_cast<SOpeningProp&>(prop));
|
|
}
|
|
|
|
bool CItem::TestRepeatBlock(int index) const
|
|
{
|
|
if (aryId.length() < index)
|
|
return true;
|
|
|
|
if (!aryProp[index].bBlock)
|
|
return false;
|
|
|
|
int iFind = FindIdArry(aryId, aryId[index]);
|
|
return (iFind != index);
|
|
}
|
|
|
|
|
|
CString EntTypeToString(EEntType eEntType)
|
|
{
|
|
if (eEntType == eM)
|
|
return _T("普通门");
|
|
else if (eEntType == eC)
|
|
return _T("普通窗");
|
|
else if (eEntType == eHC)
|
|
return _T("普通窗");
|
|
else
|
|
return _T("");
|
|
}
|
|
|
|
// 检测id对应实体的属性跟sValue是否相等
|
|
BOOL IsPropModify(AcDbObjectId id, EShowItem eShowItem, CString sValue)
|
|
{
|
|
SOpeningProp sp;
|
|
EEntType eEntType;
|
|
if (GetDoorWinProp(id, sp, eEntType) && eEntType >= 0 && eEntType < eDoorTypeNum)
|
|
{
|
|
CString strValue;
|
|
if (PropToString(sp, eShowItem).CompareNoCase(sValue) == 0)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
void CWidItem::CopyFrom(const CWidItem &widItem)
|
|
{
|
|
this->aryItem.Append(widItem.aryItem);
|
|
this->strLabel = widItem.strLabel;
|
|
}
|
|
|
|
int CWidItem::GetEntNum(bool bCheckText, bool bBlock) const
|
|
{
|
|
AcDbObjectIdArray aryIdTemp;
|
|
for (int i = 0; i < (int)aryItem.GetSize(); i++)
|
|
{
|
|
CItem *pItem = aryItem[i];
|
|
for (int j = 0; j < (int)pItem->aryId.length(); j++)
|
|
{
|
|
if (pItem->aryProp[j].bText && !bCheckText)
|
|
continue;
|
|
if (pItem->aryProp[j].bBlock && !bBlock)
|
|
continue;
|
|
AcDbObjectId idTemp = pItem->aryId[j];
|
|
// if (FindIdArry(aryIdTemp, idTemp) == -1)
|
|
{
|
|
aryIdTemp.append(pItem->aryId[j]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return (int)aryIdTemp.length();
|
|
}
|
|
|
|
void CWidItem::AddItem(CItem* pItem)
|
|
{
|
|
if (pItem == NULL)
|
|
return;
|
|
|
|
int i = 0;
|
|
for (i = 0; i < (int)aryItem.GetSize(); i++)
|
|
{
|
|
if (aryItem[i] == pItem)
|
|
return; // 已经添加了该指针
|
|
}
|
|
|
|
if (IsEmpty(aryItem))
|
|
{
|
|
strLabel = pItem->strLabel;
|
|
}
|
|
|
|
aryItem.Add(pItem);
|
|
}
|
|
|
|
CString CWidItem::GetItemName(bool bCheckText, bool bBlock) const
|
|
{
|
|
if (IsEmpty(aryItem))
|
|
return _T("");
|
|
|
|
int nNum = GetEntNum(bCheckText, bBlock);
|
|
|
|
CString sLabelDump;
|
|
sLabelDump.Format(_T("%s[%d]"), strLabel, nNum);
|
|
return sLabelDump;
|
|
}
|
|
|
|
CString CWidItem::StyleString(BOOL is2D) const
|
|
{
|
|
CString strStyle;
|
|
for (int iWid = 0; iWid < (int)aryItem.GetSize(); iWid++)
|
|
{
|
|
CItem *pItem = aryItem[iWid];
|
|
for (int iItem = 0; iItem < (int)pItem->aryProp.GetSize(); iItem++)
|
|
{
|
|
CString strCurr = is2D ? pItem->aryProp[iItem].str2DShowStyle : pItem->aryProp[iItem].str3DShowStyle;
|
|
if (iWid == 0 && iItem == 0)
|
|
{
|
|
strStyle = strCurr;
|
|
}
|
|
else
|
|
{
|
|
if (strStyle.CompareNoCase(strCurr) != 0)
|
|
return CString(_T(""));
|
|
}
|
|
}
|
|
}
|
|
return strStyle;
|
|
}
|
|
|
|
bool CWidItem::TestRepeatBlock(int nItem, int index) const
|
|
{
|
|
if (aryItem.GetSize() < nItem + 1)
|
|
return true;
|
|
if (aryItem[nItem]->aryId.length() < index + 1)
|
|
return true;
|
|
|
|
AcDbObjectId id = aryItem[nItem]->aryId[index];
|
|
for (int i = 0; i < nItem; i++)
|
|
{
|
|
if (FindIdArry(aryItem[i]->aryId, id) != -1)
|
|
return true; // 找到了
|
|
}
|
|
|
|
return aryItem[i]->TestRepeatBlock(index);
|
|
}
|
|
|
|
void CWidItem::GetIdAry(TDPtrList<AcDbObjectId> &idLst)
|
|
{
|
|
for (int i = 0; i < (int)aryItem.GetSize(); i++)
|
|
{
|
|
CItem *pItem = aryItem[i];
|
|
if (pItem != NULL)
|
|
{
|
|
for (int j = 0; j < (int)pItem->aryId.length(); j++)
|
|
{
|
|
idLst.Append(new AcDbObjectId(pItem->aryId[j]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
CGroup::CGroup()
|
|
{
|
|
m_strFloor = _T("");
|
|
m_bCurrDoc = FALSE;
|
|
}
|
|
|
|
CGroup::~CGroup()
|
|
{
|
|
for (int i = 0; i < eDoorTypeNum; i++)
|
|
{
|
|
for (int j = 0; j < (int)m_doors[i].GetSize(); j++)
|
|
{
|
|
delete m_doors[i].GetAt(j);
|
|
m_doors[i][j] = NULL;
|
|
}
|
|
m_doors[i].RemoveAll();
|
|
}
|
|
}
|
|
|
|
void CGroup::Clear()
|
|
{
|
|
for (int i = 0; i < eDoorTypeNum; i++)
|
|
{
|
|
for (int j = 0; j < (int)m_doors[i].GetSize(); j++)
|
|
{
|
|
delete m_doors[i].GetAt(j);
|
|
m_doors[i][j] = NULL;
|
|
}
|
|
m_doors[i].RemoveAll();
|
|
}
|
|
|
|
m_bCurrDoc = FALSE;
|
|
}
|
|
|
|
// 按照类型添加门窗，返回门窗对应的check指针
|
|
// 同名，同类型，放在同一个下边，注意监测冲突标记
|
|
CItem* CGroup::AddOpening(AcDbObjectId &id, SOpeningProp &prop, EEntType eEntType)
|
|
{
|
|
AryItemPtr &aryDoorCheckPtr = m_doors[eEntType];
|
|
CItem *pItem = NULL;
|
|
int i = 0;
|
|
CString strComparLabel = prop.strLabel.IsEmpty() ? GetDoorWinSizeLabel(eEntType, prop) : prop.strLabel;
|
|
for (i = 0; i < (int)aryDoorCheckPtr.GetSize(); i++)
|
|
{
|
|
if (aryDoorCheckPtr[i]->strLabel.CompareNoCase(strComparLabel) == 0)
|
|
{
|
|
pItem = aryDoorCheckPtr[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (pItem == NULL)
|
|
{
|
|
pItem = new CItem;
|
|
pItem->strLabel = strComparLabel;
|
|
pItem->eDoorWinType = eEntType;
|
|
pItem->pGroup = this;
|
|
aryDoorCheckPtr.Add(pItem);
|
|
}
|
|
|
|
pItem->aryId.append(id);
|
|
// 添加属性，并且检测是否冲突.
|
|
pItem->AddProp(prop);
|
|
prop.strType = EntTypeToString(eEntType);
|
|
|
|
return pItem;
|
|
}
|
|
|
|
// 获取楼层名字
|
|
CString CGroup::GetFloorName() const
|
|
{
|
|
return m_strFloor + _T("层");
|
|
}
|
|
|
|
void CGroup::SetFloorName(CString strName)
|
|
{
|
|
m_strFloor = strName;
|
|
}
|
|
|
|
// 是否当前文档
|
|
BOOL CGroup::IsCurrDoc() const
|
|
{
|
|
return m_bCurrDoc;
|
|
}
|
|
|
|
// 根据类型获取CheckItem;
|
|
const AryItemPtr& CGroup::GetItemAry(EEntType eType) const
|
|
{
|
|
return m_doors[eType];
|
|
}
|
|
|
|
int CGroup::FindEType(AryEtype &aryEType) const
|
|
{
|
|
for (int i = 0; i < eDoorTypeNum; i++)
|
|
{
|
|
if (!IsEmpty(GetItemAry(EEntType(i))))
|
|
{
|
|
EEntType eEntType = EEntType(i);
|
|
aryEType.Add(eEntType);
|
|
}
|
|
}
|
|
|
|
return (int)aryEType.GetSize();
|
|
}
|
|
|
|
void CGroup::FilterId(AcDbObjectIdArray &idArray)
|
|
{
|
|
for (int iEntType = 0; iEntType < eDoorTypeNum; iEntType++)
|
|
{
|
|
AryItemPtr& aryItemPtr = m_doors[iEntType];
|
|
|
|
for (int iAryItem = 0; iAryItem < (int)aryItemPtr.GetSize(); iAryItem++)
|
|
{
|
|
CItem *pItem = aryItemPtr.GetAt(iAryItem);
|
|
|
|
for (int iItem = (int)pItem->aryId.length()-1; iItem >= 0 ; iItem--)
|
|
{
|
|
int iPos = FindIdArry(idArray, pItem->aryId[iItem]);
|
|
if (iPos == -1)
|
|
{ // 没找到
|
|
// pItem->aryId.RemoveAt(iItem);
|
|
pItem->aryId.removeAt(iItem);
|
|
pItem->aryProp.RemoveAt(iItem);
|
|
}
|
|
else
|
|
{
|
|
idArray.removeAt(iPos);
|
|
}
|
|
}
|
|
|
|
// 检测，如果pItem空了，则需要删除这个pItem；
|
|
if ((pItem->aryId.isEmpty()))
|
|
{
|
|
aryItemPtr.RemoveAt(iAryItem--);
|
|
delete pItem;
|
|
pItem = NULL;
|
|
}
|
|
|
|
// pItem更新之后，这里没有重新作出冲突检测，因为相对全图来说，这里还是冲突的。
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// projectInfo....
|
|
void SProjectInfo::Clear()
|
|
{
|
|
strProjectName = _T("");
|
|
strProjectFullName = _T("");
|
|
aryFloorInfo.RemoveAll();
|
|
// lstFloorData.();
|
|
}
|
|
|
|
void SProjectInfo::Init()
|
|
{
|
|
strProjectName = _T("");
|
|
strProjectFullName = _T("");
|
|
aryFloorInfo.RemoveAll();
|
|
}
|
|
void SProjectInfo::AddFloorInfoByDoc(CString _strFloorNo, CString _strFloorDoc)
|
|
{
|
|
_SFloorInfo sfi;
|
|
sfi.bInFrame = false;
|
|
sfi.strfloorNo = _strFloorNo;
|
|
sfi.strFloorDoc = _strFloorDoc;
|
|
aryFloorInfo.Add(sfi);
|
|
}
|
|
|
|
void SProjectInfo::AddFloorByRange(CString _strFloorNo, CString _strFloorDoc, XPoint _ptMin, XPoint _ptMax)
|
|
{
|
|
_SFloorInfo sfi;
|
|
sfi.bInFrame = true;
|
|
sfi.strfloorNo = _strFloorNo;
|
|
sfi.strFloorDoc = _strFloorDoc;
|
|
sfi.ptMin = _ptMin;
|
|
sfi.ptMax = _ptMax;
|
|
aryFloorInfo.Add(sfi);
|
|
}
|
|
|
|
// 比较，没有差异的话，返回true.否则返回false;
|
|
bool SProjectInfo::Compare(const SProjectInfo &sProjectInfo) const
|
|
{
|
|
if (strProjectName.CompareNoCase(sProjectInfo.strProjectName) != 0 ||
|
|
strProjectFullName.CompareNoCase(sProjectInfo.strProjectFullName) != 0 ||
|
|
aryFloorInfo.GetSize() != sProjectInfo.aryFloorInfo.GetSize())
|
|
return false; //
|
|
|
|
// 比较每一层是否有差异：
|
|
for (int i = 0; i < (int)aryFloorInfo.GetSize(); i++)
|
|
{
|
|
const _SFloorInfo &sfi1 = aryFloorInfo[i];
|
|
const _SFloorInfo &sfi2 = sProjectInfo.aryFloorInfo[i];
|
|
|
|
if (sfi1.strfloorNo.CompareNoCase(sfi2.strfloorNo) != 0 ||
|
|
sfi1.strFloorDoc.CompareNoCase(sfi2.strFloorDoc) != 0 ||
|
|
sfi1.bInFrame != sfi2.bInFrame)
|
|
return false;
|
|
|
|
if (sfi1.bInFrame)
|
|
{
|
|
if (sfi1.ptMin != sfi2.ptMin ||
|
|
sfi1.ptMax != sfi2.ptMax)
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void SProjectInfo::ReadProjInfo()
|
|
{
|
|
TProjectGroupItem *pFloorLst = GetFloorTable();
|
|
// 楼层参数，用来取得每个楼层对应得名字
|
|
// DList<XFloorData> lstFloorData;
|
|
// GetFloorData(this->lstFloorData);
|
|
}
|
|
|
|
|
|
CDataTable::CDataTable() : m_strCurrDoc(_T("")), m_bOldData(false)
|
|
{
|
|
m_dataNoProject.m_pDataTable = this;
|
|
m_projectInfo.Init();
|
|
}
|
|
|
|
CDataTable::~CDataTable()
|
|
{
|
|
for (int i = 0; i < m_aryDataAll.GetSize(); i++)
|
|
{
|
|
if (m_aryDataAll[i] != NULL)
|
|
{
|
|
delete m_aryDataAll[i];
|
|
m_aryDataAll[i] = NULL;
|
|
}
|
|
}
|
|
m_aryDataAll.RemoveAll();
|
|
}
|
|
|
|
|
|
void CDataTable::Clear()
|
|
{
|
|
for (int i = 0; i < m_aryDataAll.GetSize(); i++)
|
|
{
|
|
if (m_aryDataAll[i] != NULL)
|
|
{
|
|
delete m_aryDataAll[i];
|
|
m_aryDataAll[i] = NULL;
|
|
}
|
|
}
|
|
m_aryDataAll.RemoveAll();
|
|
|
|
|
|
m_dataNoProject.Clear();
|
|
// m_strProjName = _T("");
|
|
// m_strProjFullName = _T("");
|
|
m_projectInfo.Clear();
|
|
m_strCurrDoc = _T("");
|
|
m_bSelBox = false;
|
|
}
|
|
|
|
// 判断数据是否为空
|
|
BOOL CDataTable::IsEmptyTable() const
|
|
{
|
|
return m_projectInfo.strProjectName.IsEmpty() && m_strCurrDoc.IsEmpty();
|
|
}
|
|
|
|
BOOL CDataTable::IsProjChange() const
|
|
{
|
|
CString strCurrProj, strCurrDoc, strCurrProjFullName;
|
|
GetCurrProjAndDoc(strCurrProj, strCurrDoc, strCurrProjFullName);
|
|
|
|
|
|
// CString strKeepFull = ProjectFullName();
|
|
// CString strKeepProj =
|
|
return (GetProjFullName().CompareNoCase(strCurrProjFullName) != 0
|
|
|| GetProjName().CompareNoCase(strCurrProj) != 0);
|
|
}
|
|
|
|
BOOL CDataTable::IsDocChange() const
|
|
{
|
|
CString strCurrProj, strCurrDoc, strCurrProjFullName;
|
|
GetCurrProjAndDoc(strCurrProj, strCurrDoc, strCurrProjFullName);
|
|
|
|
return (GetDocName().CompareNoCase(strCurrDoc) != 0);
|
|
}
|
|
|
|
bool CDataTable::IsCurrDocNotInProj() const
|
|
{
|
|
XStringList sFiles;
|
|
::GetFloorFiles(sFiles); // 所有的DWG
|
|
XString sCurDoc = curDoc()->fileName();
|
|
for (int i = 0; i < sFiles.Length(); i++)
|
|
{
|
|
XString str = sFiles[i];
|
|
if (str == sCurDoc)
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// 根据楼层添加ID。nFloor是GetFloorTable()中的索引顺序，并非真正的楼层编号
|
|
void CDataTable::AddIdByFloor(AcDbObjectIdArray &idAry, int nFloor, CString &floorName, BOOL bCurrDoc, AcDbObjectIdArray *pAryIdBlock)
|
|
{
|
|
#ifndef NDEBUG
|
|
DWORD d1 = GetTickCount();
|
|
#endif
|
|
int i = 0, j = 0;
|
|
m_aryDataAll[nFloor] = new CGroup();
|
|
m_aryDataAll[nFloor]->SetFloorName(floorName);
|
|
m_aryDataAll[nFloor]->m_bCurrDoc = bCurrDoc;
|
|
m_aryDataAll[nFloor]->m_pDataTable = this;
|
|
|
|
for (i = 0; i < (int)idAry.length(); i++)
|
|
{
|
|
SOpeningProp soprop;
|
|
EEntType eEntType;
|
|
AcDbObjectId id = idAry[i];
|
|
if (GetDoorWinProp(id, soprop, eEntType) && eEntType >= 0 && eEntType < eDoorTypeNum)
|
|
{
|
|
if (pAryIdBlock != NULL && FindIdArry(*pAryIdBlock, id) != -1)
|
|
soprop.bBlock = true;
|
|
m_aryDataAll[nFloor]->AddOpening(id, soprop, eEntType);
|
|
}
|
|
}
|
|
#ifndef NDEBUG
|
|
dwtime += (GetTickCount() - d1);
|
|
#endif
|
|
}
|
|
|
|
// 添加不属于工程的数据，只有当前图才考虑添加不属于工程的数据
|
|
void CDataTable::AddIdNoProject(AcDbObjectIdArray &idAry, AcDbObjectIdArray *pAryIdBlock)
|
|
{
|
|
#ifndef NDEBUG
|
|
DWORD d1 = GetTickCount();
|
|
#endif
|
|
|
|
m_dataNoProject.m_bCurrDoc = TRUE;// 冲突门窗只有本图的。
|
|
|
|
AcDbObjectId _refID(AcDbObjectId::kNull), _tblRecID(AcDbObjectId::kNull);
|
|
AcDbEntity *_pEnt = NULL;
|
|
AcDbBlockTableRecord *_pTblRec = NULL;
|
|
|
|
for (int i = 0; i < (int)idAry.length(); i++)
|
|
{
|
|
SOpeningProp soprop;
|
|
EEntType eEntType;
|
|
_refID = idAry[i];
|
|
if (GetDoorWinProp(idAry[i], soprop, eEntType) && eEntType >= 0 && eEntType < eDoorTypeNum)
|
|
{
|
|
if (pAryIdBlock != NULL && FindIdArry(*pAryIdBlock, idAry[i]) != -1)
|
|
{
|
|
// 下面判断是否是dwg文件参照块
|
|
acdbOpenObject(_pEnt, _refID, AcDb::kForRead);
|
|
if (_pEnt)
|
|
{
|
|
AcDbObjectId idtmp = _pEnt->ownerId();
|
|
acdbOpenObject(_pTblRec, idtmp, AcDb::kForRead);
|
|
if (_pTblRec)
|
|
{
|
|
LPCTSTR scomm;
|
|
_pTblRec->getName(scomm);
|
|
CString sName = scomm;
|
|
//LH 20120925 转换字符串均为小写
|
|
sName.MakeLower();
|
|
if (sName.CompareNoCase(_T("*model_space")) == 0 || -1 != sName.Find(_T('|')))
|
|
soprop.bExternBlock = true;
|
|
else
|
|
soprop.bExternBlock = false;
|
|
|
|
_pTblRec->close();
|
|
}
|
|
_pEnt->close();
|
|
}
|
|
soprop.bBlock = true;
|
|
}
|
|
|
|
m_dataNoProject.AddOpening(idAry[i], soprop, eEntType);
|
|
}
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
dwtime += (GetTickCount() - d1);
|
|
#endif
|
|
}
|
|
|
|
void CDataTable::SetFloorNum(int n)
|
|
{
|
|
if (n > 0)
|
|
{
|
|
m_aryDataAll.SetSize(n);
|
|
for (int i = 0; i < (int)m_aryDataAll.GetSize(); i++)
|
|
m_aryDataAll[i] = NULL;
|
|
}
|
|
}
|
|
|
|
int CDataTable::GetFloorNum() const
|
|
{
|
|
return (int)m_aryDataAll.GetSize();
|
|
}
|
|
|
|
CGroup* CDataTable::GetFloor(int nFloor) const
|
|
{
|
|
return m_aryDataAll[nFloor];
|
|
}
|
|
|
|
// 本工程的数据包含的所有的门窗类型
|
|
int CDataTable::FindETypeProj(AryEtype &aryEType) const
|
|
{
|
|
BOOL bFlag[eDoorTypeNum];
|
|
memset(bFlag, 0, sizeof(BOOL)*eDoorTypeNum);
|
|
|
|
for (int i = 0; i < (int)m_aryDataAll.GetSize(); i++)
|
|
{
|
|
for (int j = 0; j < eDoorTypeNum; j++)
|
|
{
|
|
if (GetFloor(i) != NULL && !IsEmpty(m_aryDataAll[i]->GetItemAry(eDoorTypeNum)))
|
|
{
|
|
bFlag[j] = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int k = 0; k < eDoorTypeNum; k++)
|
|
{
|
|
EEntType eEntType = EEntType(k);
|
|
if (bFlag[k])
|
|
aryEType.Add(eEntType);
|
|
}
|
|
|
|
return (int)aryEType.GetSize();
|
|
}
|
|
|
|
int CDataTable::FindETypeDwg(AryEtype &aryEType) const
|
|
{
|
|
BOOL bFlag[eDoorTypeNum];
|
|
memset(bFlag, 0, sizeof(BOOL)*eDoorTypeNum);
|
|
|
|
for (int i = 0; i < (int)m_aryDataAll.GetSize(); i++)
|
|
{
|
|
if (GetFloor(i) == NULL || !m_aryDataAll[i]->IsCurrDoc())
|
|
continue;
|
|
|
|
for (int j = 0; j < eDoorTypeNum; j++)
|
|
{
|
|
if (!IsEmpty(m_aryDataAll[i]->GetItemAry(eDoorTypeNum)))
|
|
{
|
|
bFlag[j] = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int k = 0; k < eDoorTypeNum; k++)
|
|
{
|
|
EEntType eEntType = EEntType(k);
|
|
if (bFlag[k])
|
|
aryEType.Add(eEntType);
|
|
}
|
|
|
|
return (int)aryEType.GetSize();
|
|
}
|
|
|
|
int CDataTable::FindETypeNoProj(AryEtype &aryEtype) const
|
|
{
|
|
for (int i = 0; i < eDoorTypeNum; i++)
|
|
{
|
|
if (!IsEmpty(m_dataNoProject.GetItemAry(EEntType(i))))
|
|
{
|
|
EEntType eEntType = EEntType(i);
|
|
aryEtype.Add(eEntType);
|
|
}
|
|
}
|
|
|
|
return (int)aryEtype.GetSize();
|
|
}
|
|
|
|
int CDataTable::FindEType(AryWidItemPtr widItemPtr[eDoorTypeNum], AryEtype &aryEtype)
|
|
{
|
|
for (int i = 0; i < eDoorTypeNum; i++)
|
|
{
|
|
AryWidItemPtr &widItemPtrCurr = widItemPtr[i];
|
|
if (!IsEmpty(widItemPtrCurr))
|
|
{
|
|
EEntType eEntType = EEntType(i);
|
|
aryEtype.Add(eEntType);
|
|
}
|
|
}
|
|
|
|
return (int)aryEtype.GetSize();
|
|
}
|
|
|
|
|
|
// 合并本工程的所有的数据，不分楼层。
|
|
void CDataTable::GetDataPNf(AryWidItemPtr doors[eDoorTypeNum]) const
|
|
{
|
|
for (int i = 0; i < (int)m_aryDataAll.GetSize(); i++)
|
|
{ // 遍历AllData;
|
|
CGroup *pFloor = m_aryDataAll[i];
|
|
if (pFloor == NULL)
|
|
continue;
|
|
for (int iType = 0; iType < eDoorTypeNum; iType++)
|
|
{ // 添加本类型
|
|
AryItemPtr &aryItemPtr = const_cast<AryItemPtr&>(pFloor->GetItemAry(EEntType(iType)));
|
|
for (int k = 0; k < (int)aryItemPtr.GetSize(); k++)
|
|
{
|
|
AddItemToWidItemAry(doors[iType], aryItemPtr[k]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CDataTable::GetDataPF(AryAllData &data) const
|
|
{
|
|
data.Append(m_aryDataAll);
|
|
}
|
|
|
|
// 工程内冲突工程数据
|
|
void CDataTable::GetConflictProj(AryWidItemPtr widItem[eDoorTypeNum]) const
|
|
{// 合并所有的数据，取出其中冲突的
|
|
for (int i = 0; i < eDoorTypeNum; i++)
|
|
{
|
|
for (int j = 0; j < (int)m_aryDataAll.GetSize(); j++)
|
|
{
|
|
if (GetFloor(j) == NULL)
|
|
continue;
|
|
AryItemPtr &aryItem = const_cast<AryItemPtr &>(m_aryDataAll[j]->GetItemAry(EEntType(i)));
|
|
for (int k = 0; k < (int)aryItem.GetSize(); k++)
|
|
{
|
|
if (aryItem[k]->bConflict)
|
|
AddItemToWidItemAry(widItem[i], aryItem[k]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 获取工程内本图的数据，分楼层
|
|
void CDataTable::GetDataDPF(AryAllData &data) const
|
|
{
|
|
for (int i = 0; i < (int)m_aryDataAll.GetSize(); i++)
|
|
{
|
|
if (m_aryDataAll[i] != NULL && m_aryDataAll[i]->IsCurrDoc())
|
|
data.Add(const_cast<CGroup*>(m_aryDataAll[i]) );
|
|
}
|
|
}
|
|
|
|
// 获取工程内本图内不分楼层的数据
|
|
void CDataTable::GetCurrDPNf(AryWidItemPtr widItem[eDoorTypeNum]) const
|
|
{
|
|
for (int i = 0; i < eDoorTypeNum; i++)
|
|
{
|
|
for (int j = 0; j < (int)m_aryDataAll.GetSize(); j++)
|
|
{
|
|
CGroup *pFloor = m_aryDataAll[j];
|
|
if (pFloor == NULL || !pFloor->IsCurrDoc())
|
|
continue;
|
|
|
|
AryItemPtr &aryItemPtrCurr = const_cast<AryItemPtr&>(pFloor->GetItemAry(EEntType(i)));
|
|
for (int k = 0; k < (int)aryItemPtrCurr.GetSize(); k++)
|
|
{
|
|
AddItemToWidItemAry(widItem[EEntType(i)], aryItemPtrCurr[k]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 工程内本图内冲突数据
|
|
void CDataTable::GetConflictDP(AryWidItemPtr widItem[eDoorTypeNum]) const
|
|
{
|
|
for (int i = 0; i < eDoorTypeNum; i++)
|
|
{
|
|
for (int j = 0; j < (int)m_aryDataAll.GetSize(); j++)
|
|
{
|
|
CGroup *pFloor = m_aryDataAll[j];
|
|
if (pFloor == NULL || !pFloor->IsCurrDoc())
|
|
continue;
|
|
|
|
AryItemPtr &aryItem = const_cast<AryItemPtr&>(pFloor->GetItemAry(EEntType(i)));
|
|
for (int k = 0; k < (int)aryItem.GetSize(); k++)
|
|
{
|
|
if (aryItem[k]->bConflict)
|
|
AddItemToWidItemAry(widItem[i], aryItem[k]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 获取全部本图数据，不管工程，
|
|
void CDataTable::GetDataDNpNf(AryWidItemPtr widItem[eDoorTypeNum]) const
|
|
{
|
|
for (int i = 0; i < eDoorTypeNum; i++)
|
|
{
|
|
for (int j = -1; j < (int)m_aryDataAll.GetSize(); j++)
|
|
{
|
|
const CGroup *pFloor = NULL;
|
|
if (j == -1)
|
|
pFloor = (&m_dataNoProject);
|
|
else
|
|
pFloor = m_aryDataAll[j];
|
|
|
|
if (pFloor == NULL || !pFloor->IsCurrDoc())
|
|
continue;
|
|
|
|
AryItemPtr &aryItemPtrCurr = const_cast<AryItemPtr&>(pFloor->GetItemAry(EEntType(i)));
|
|
for (int k = 0; k < (int)aryItemPtrCurr.GetSize(); k++)
|
|
{
|
|
AddItemToWidItemAry(widItem[EEntType(i)], aryItemPtrCurr[k]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 全部本图的冲突数据
|
|
void CDataTable::GetConflictDNp(AryWidItemPtr widItem[eDoorTypeNum]) const
|
|
{
|
|
for (int i = 0; i < eDoorTypeNum; i++)
|
|
{
|
|
for (int j = -1; j < (int)m_aryDataAll.GetSize(); j++)
|
|
{
|
|
const CGroup *pFloor = NULL;
|
|
if (j == -1)
|
|
pFloor = (&m_dataNoProject);
|
|
else
|
|
pFloor = m_aryDataAll[j];
|
|
|
|
if (pFloor == NULL || !pFloor->IsCurrDoc())
|
|
continue;
|
|
|
|
AryItemPtr &aryItem = const_cast<AryItemPtr&>(pFloor->GetItemAry(EEntType(i)));
|
|
for (int k = 0; k < (int)aryItem.GetSize(); k++)
|
|
{
|
|
if (aryItem[k]->bConflict)
|
|
AddItemToWidItemAry(widItem[i], aryItem[k]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 获取未创建工程数据
|
|
void CDataTable::GetDataNp(AryWidItemPtr widItem[eDoorTypeNum]) const
|
|
{
|
|
for (int i = 0; i < eDoorTypeNum; i++)
|
|
{
|
|
ItemPtrAry2Wid(m_dataNoProject.GetItemAry(EEntType(i)), widItem[i]);
|
|
}
|
|
}
|
|
|
|
// 未创建工程的冲突数据
|
|
void CDataTable::GetConflictNoProj(AryWidItemPtr widItem[eDoorTypeNum]) const
|
|
{
|
|
for (int i = 0; i < eDoorTypeNum; i++)
|
|
{
|
|
AryItemPtr& aryItem = const_cast<AryItemPtr&>(m_dataNoProject.GetItemAry(EEntType(i)));
|
|
for (int j = 0; j < (int)aryItem.GetSize(); j++)
|
|
{
|
|
if ((aryItem[j])->bConflict)
|
|
AddItemToWidItemAry(widItem[i], aryItem[j]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 根据当前的形式计算冲突数据，在CItem中设置标记
|
|
void CDataTable::CalcConflictData()
|
|
{
|
|
// 1、得到要排序的数据集合，
|
|
_AryDataStruct aryDataStruct;
|
|
bool bProj = IsSelData() ? false : IsCheckProj();
|
|
GetAryDataStruct(aryDataStruct, IsCheckDWG(), bProj, IsCheckText(), IsCheckBlock());
|
|
|
|
// 2、对这些数据按照编号进行排序
|
|
_DataStruct *pData = aryDataStruct.GetData();
|
|
qsort(pData, (size_t)aryDataStruct.GetSize(), sizeof(_DataStruct), CDataTable::Cmp_DataStruct);
|
|
|
|
// 3、同名数据检测冲突，并且在CItem中设置冲突标记。
|
|
CString strName;
|
|
if (!IsEmpty(aryDataStruct)) strName = aryDataStruct[0].prop->pItem->strLabel;
|
|
int iStart = 0;
|
|
for (int i = 0; i < (int)aryDataStruct.GetSize()+1; i++)
|
|
{
|
|
if ((i == (int)aryDataStruct.GetSize()) ||
|
|
(strName.CompareNoCase(aryDataStruct[i].prop->pItem->strLabel) != 0) )
|
|
|
|
{
|
|
// 比较从iStart到i【）这段数据的冲突性
|
|
// 循环检测：
|
|
int iTestStart = iStart;
|
|
int iTestEnd = i; //
|
|
bool bConflict = false;
|
|
for (iTestStart; iTestStart < iTestEnd - 1; iTestStart++)
|
|
{
|
|
_DataStruct *pDs1 = &(aryDataStruct[iTestStart]);
|
|
for (int j = iTestStart+1; j < iTestEnd; j++)
|
|
{
|
|
_DataStruct *pDs2 = &(aryDataStruct[j]);
|
|
if (pDs1->prop->pItem->eDoorWinType != pDs2->prop->pItem->eDoorWinType)
|
|
{
|
|
bConflict = true;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if (TestConflict(pDs1->prop->pItem->eDoorWinType, *(pDs1->prop), *(pDs2->prop)))
|
|
{
|
|
bConflict = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bConflict)
|
|
break;
|
|
}
|
|
|
|
iTestStart = iStart;
|
|
iTestEnd = i;
|
|
for (iTestStart; iTestStart < iTestEnd; iTestStart++)
|
|
{
|
|
aryDataStruct[iTestStart].prop->pItem->bConflict = bConflict;// 设置冲突标记
|
|
}
|
|
|
|
if (i < (int)aryDataStruct.GetSize())
|
|
{
|
|
strName = aryDataStruct[i].prop->pItem->strLabel;
|
|
iStart = i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// // 获取本图不分楼层的数据
|
|
// void CDataTable::GetNoFloorCurrProj(AryWidItemPtr widItem[eDoorTypeNum]) const
|
|
// {
|
|
// for (int i = 0; i < eDoorTypeNum; i++)
|
|
// {
|
|
// for (int j = 0; j < (int)m_aryDataAll.GetSize(); j++)
|
|
// {
|
|
// CGroup *pFloor = m_aryDataAll[j];
|
|
// if (pFloor == NULL)
|
|
// continue;
|
|
//
|
|
// AryItemPtr &aryItemPtrCurr = const_cast<AryItemPtr&>(pFloor->GetItemAry(EEntType(i)));
|
|
// for (int k = 0; k < (int)aryItemPtrCurr.GetSize(); k++)
|
|
// {
|
|
// AddItemToWidItemAry(widItem[EEntType(i)], aryItemPtrCurr[k]);
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// 判断有没有未创建工程的数据
|
|
BOOL CDataTable::HasNoProjData() const
|
|
{
|
|
for (int i = 0; i < eDoorTypeNum; i++)
|
|
{
|
|
if (!IsEmpty(m_dataNoProject.GetItemAry(EEntType(i))))
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
int CDataTable::Cmp_DataStruct(const void *ds1, const void *ds2)
|
|
{
|
|
_DataStruct *pDataStruct1 = (_DataStruct*)ds1;
|
|
_DataStruct *pDataStruct2 = (_DataStruct*)ds2;
|
|
|
|
// 注意这里使用过的是CItem中的编号，因为prop中的编号是可能为空的。
|
|
return pDataStruct1->prop->pItem->strLabel.CompareNoCase(pDataStruct2->prop->pItem->strLabel);
|
|
}
|
|
|
|
|
|
//enum EDataChange {eProjChange = 0x01, eDocChange = 0x02, eLabelChange = 0x04};
|
|
DWORD CDataTable::Compare(const CDataTable &dataTable) const
|
|
{
|
|
DWORD dwFlag = 0;
|
|
|
|
// if (this->GetProjFullName().CompareNoCase(dataTable.GetProjFullName()) != 0)
|
|
// CDataTable::SetDataChange(dwFlag, eProjChange, TRUE);
|
|
if (!this->m_projectInfo.Compare(dataTable.m_projectInfo))
|
|
CDataTable::SetDataChange(dwFlag, eProjChange, TRUE);
|
|
if (this->GetDocName().CompareNoCase(dataTable.GetDocName()) != 0)
|
|
CDataTable::SetDataChange(dwFlag, eDocChange, TRUE);
|
|
if (!TestDataChange(dwFlag, eProjChange) && !TestDataChange(dwFlag, eDocChange))
|
|
{
|
|
DWORD dwDataFlag = this->DataCompare(dataTable, IsCheckDWG(), IsCheckProj(), IsCheckText(), IsCheckBlock());
|
|
dwFlag |= dwDataFlag;
|
|
}
|
|
|
|
return dwFlag;
|
|
}
|
|
|
|
// 比较数据查看是否有以下问题
|
|
// 编号修改，实体添加，实体删除，实体属性修改。
|
|
DWORD CDataTable::DataCompare(const CDataTable &dataTable, bool bOnlyDWG, bool bOnlyProj, bool bNeedText, bool bNeedBlock) const
|
|
{
|
|
DWORD dwFlagRet = 0;
|
|
|
|
_AryDataStruct _aryDataStruct1, _aryDataStruct2;
|
|
this->GetAryDataStruct(_aryDataStruct1, bOnlyDWG, bOnlyProj, bNeedText, bNeedBlock);
|
|
dataTable.GetAryDataStruct(_aryDataStruct2, bOnlyDWG, bOnlyProj, bNeedText, bNeedBlock);
|
|
|
|
int iIndex = 0;
|
|
for (iIndex = 0; iIndex < (int)_aryDataStruct1.GetSize(); iIndex++)
|
|
{
|
|
if (!_aryDataStruct1[iIndex].prop->pItem->pGroup->IsCurrDoc())
|
|
continue;
|
|
SOpeningProp *pProp = GetProp(_aryDataStruct2, _aryDataStruct1[iIndex].id);
|
|
if (pProp == NULL)
|
|
{ // 新的数据里找不到该数据，判断为删除
|
|
SetDataChange(dwFlagRet, eIdDel, TRUE);
|
|
#ifndef NDEBUG
|
|
ads_printf(_T("Add id Num: %d \n"), _aryDataStruct1[iIndex].id.asOldId());
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
CString strLabelTemp = _aryDataStruct1[iIndex].prop->strLabel;
|
|
if (strLabelTemp.IsEmpty())
|
|
{
|
|
strLabelTemp = GetDoorWinSizeLabel(_aryDataStruct1[iIndex].eEntType, *(_aryDataStruct1[iIndex].prop));
|
|
}
|
|
if (pProp->pItem->strLabel.CompareNoCase(strLabelTemp) != 0)
|
|
SetDataChange(dwFlagRet, eLabelChange, TRUE);
|
|
else
|
|
{
|
|
for (int j = 0; j < eDoorWinParmNum; j++)
|
|
{
|
|
CString str1 = PropToString(*pProp, GetShowItem(EShowItem(j)));
|
|
CString str2 = PropToString(*_aryDataStruct1[iIndex].prop, GetShowItem(EShowItem(j)));
|
|
|
|
if (str1.CompareNoCase(str2) != 0)
|
|
{
|
|
SetDataChange(dwFlagRet, ePropChange, TRUE);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ((pProp->str2DShowStyle.CompareNoCase(_aryDataStruct1[iIndex].prop->str2DShowStyle) != 0) ||
|
|
(pProp->str3DShowStyle.CompareNoCase(_aryDataStruct1[iIndex].prop->str3DShowStyle) != 0))
|
|
{
|
|
SetDataChange(dwFlagRet, ePropChange, TRUE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (iIndex = 0; iIndex < (int)_aryDataStruct2.GetSize(); iIndex++)
|
|
{
|
|
if (!_aryDataStruct2[iIndex].prop->pItem->pGroup->IsCurrDoc())
|
|
continue;
|
|
|
|
SOpeningProp *pProp = GetProp(_aryDataStruct1, _aryDataStruct2[iIndex].id);
|
|
if (pProp == NULL)
|
|
{ // 旧的数据里找不到该数据，判断为添加
|
|
SetDataChange(dwFlagRet, eIdAdd, TRUE);
|
|
#ifndef NDEBUG
|
|
ads_printf(_T("Del id Num: %d \n"), _aryDataStruct2[iIndex].id.asOldId());
|
|
#endif
|
|
}
|
|
}
|
|
|
|
//add by lgy 20120306 如果删除了同名块参照或者外部参照，应该处理为删除了实体，而现有程序无法处理该种情况
|
|
if ((int)_aryDataStruct1.GetSize() != (int)_aryDataStruct2.GetSize())//重新获得的数据和原有数据其中实体个数是否一样
|
|
{
|
|
if (dwFlagRet == 0) //重新获得的实体个数跟原有实体个数不一致，并且标志却没有改变，认为是删除或者添加了参照
|
|
{
|
|
SetDataChange(dwFlagRet, eIdDel, TRUE);
|
|
}
|
|
}
|
|
return dwFlagRet;
|
|
}
|
|
|
|
BOOL CDataTable::TestDataChange(const DWORD dwFlag, EDataChange eChange)
|
|
{
|
|
return dwFlag & eChange;
|
|
}
|
|
void CDataTable::SetDataChange(DWORD &dwFlag, EDataChange eChange, BOOL bSet)
|
|
{
|
|
if (bSet)
|
|
{
|
|
dwFlag |= eChange;
|
|
}
|
|
else
|
|
{
|
|
dwFlag &= (~eChange);
|
|
}
|
|
}
|
|
|
|
// 更新属性：更新属性中除了编号之外的其他内容，只更新当前文档
|
|
void CDataTable::UpdateProp(const CDataTable &dataTable)
|
|
{
|
|
_AryDataStruct _aryDataStruct1, _aryDataStruct2;
|
|
this->GetAryDataStruct(_aryDataStruct1, true, false, true, true);
|
|
dataTable.GetAryDataStruct(_aryDataStruct2, true, false, true, true);
|
|
|
|
int iIndex = 0;
|
|
for (iIndex = 0; iIndex < (int)_aryDataStruct1.GetSize(); iIndex++)
|
|
{
|
|
SOpeningProp *pProp = GetProp(_aryDataStruct2, _aryDataStruct1[iIndex].id);
|
|
|
|
if (pProp != NULL)
|
|
{
|
|
SOpeningProp *thisProp = _aryDataStruct1[iIndex].prop;
|
|
|
|
thisProp->nHei = pProp->nHei;
|
|
thisProp->nWid = pProp->nWid;
|
|
thisProp->nEle = pProp->nEle;
|
|
thisProp->strType = pProp->strType;
|
|
thisProp->eProWinGeo = pProp->eProWinGeo;
|
|
thisProp->nChuTiaoChang = pProp->nChuTiaoChang;
|
|
thisProp->nTixingkuan = pProp->nTixingkuan;
|
|
thisProp->str3DShowStyle = pProp->str3DShowStyle;
|
|
thisProp->str2DShowStyle = pProp->str2DShowStyle;
|
|
thisProp->bZJCTuChuang = pProp->bZJCTuChuang;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CDataTable::FilterId(AcDbObjectIdArray &idArray)
|
|
{
|
|
// AcDbObjectIdArray idArray;
|
|
// ss.AsIdArray(idArray);
|
|
for (int i = 0; i < (int)m_aryDataAll.GetSize(); i++)
|
|
{
|
|
CGroup *pGroup = m_aryDataAll[i];
|
|
|
|
if (pGroup == NULL || !pGroup->IsCurrDoc())
|
|
{
|
|
m_aryDataAll.RemoveAt(i--);
|
|
delete pGroup;
|
|
pGroup = NULL;
|
|
}
|
|
else
|
|
pGroup->FilterId(idArray);
|
|
}
|
|
|
|
m_dataNoProject.FilterId(idArray);
|
|
}
|
|
|
|
|
|
int CDataTable::GetNoNameLabeNum(bool bOnlyDWG, bool bOnlyProj, bool bNeedText, bool bNeedBlock) const
|
|
{
|
|
_AryDataStruct aryDataStruct;
|
|
GetAryDataStruct(aryDataStruct, bOnlyDWG, bOnlyProj, bNeedText, bNeedBlock);
|
|
|
|
int nNum = 0;
|
|
for (int i = 0; i < (int)aryDataStruct.GetSize(); i++)
|
|
{
|
|
if (aryDataStruct[i].prop->strLabel.IsEmpty())
|
|
nNum++;
|
|
}
|
|
|
|
return nNum;
|
|
}
|
|
|
|
bool CDataTable::TestHasData(bool bOnlyDWG, bool bOnlyProj, bool bNeedText, bool bNeedBlock) const
|
|
{
|
|
_AryDataStruct aryDataStruct;
|
|
GetAryDataStruct(aryDataStruct, bOnlyDWG, bOnlyProj, bNeedText, bNeedBlock);
|
|
|
|
return !IsEmpty(aryDataStruct);
|
|
}
|
|
|
|
bool CDataTable::HasFloor() const
|
|
{
|
|
return !IsEmpty(m_aryDataAll);
|
|
}
|
|
|
|
// 检测是否有未创建工程的数据。
|
|
bool CDataTable::TestHasNoProjData(bool bNeedText, bool bNeedBlock) const
|
|
{
|
|
for (int i = 0; i < eDoorTypeNum; i++)
|
|
{
|
|
const AryItemPtr &aryItemPtr = m_dataNoProject.GetItemAry(EEntType(i));
|
|
for (int j = 0; j < (int)aryItemPtr.GetSize(); j++)
|
|
{
|
|
CItem *pItem = aryItemPtr[j];
|
|
if (pItem != NULL)
|
|
{
|
|
if (pItem->HasItem(bNeedText, bNeedBlock))
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false; // 空的情况。
|
|
}
|
|
|
|
void CDataTable::SetFileInfo()
|
|
{
|
|
CString strCurrProj, strCurrDoc, strCurrProjFullName;
|
|
GetCurrProjAndDoc(strCurrProj, strCurrDoc, strCurrProjFullName);
|
|
SetProjName(strCurrProj);
|
|
SetDocName(strCurrDoc);
|
|
SetProjFullName(strCurrProjFullName);
|
|
SetSelFlag(false); // 非框选
|
|
|
|
}
|
|
|
|
void CDataTable::ClearNullFloor()
|
|
{
|
|
for (int i = 0; i < (int)m_aryDataAll.GetSize(); i++)
|
|
{
|
|
if (m_aryDataAll[i] == NULL)
|
|
m_aryDataAll.RemoveAt(i--);
|
|
}
|
|
}
|
|
|
|
void CDataTable::AddFloorInfo(CString strFloorNo, CString strFloorDoc, bool bInFrame, const XPoint &ptMin, const XPoint &ptMax)
|
|
{
|
|
if (bInFrame)
|
|
m_projectInfo.AddFloorByRange(strFloorNo, strFloorDoc, ptMin, ptMax);
|
|
else
|
|
m_projectInfo.AddFloorInfoByDoc(strFloorNo, strFloorDoc);
|
|
}
|
|
|
|
|
|
SOpeningProp* CDataTable::GetProp(CDataTable::_AryDataStruct &_aryDataStruct, const AcDbObjectId &id)
|
|
{
|
|
for (int i = 0; i < (int)_aryDataStruct.GetSize(); i++)
|
|
{
|
|
if (_aryDataStruct[i].id.asOldId() == id.asOldId())
|
|
return _aryDataStruct[i].prop;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void CDataTable::GetAryDataStruct(CDataTable::_AryDataStruct &aryDataStruct,
|
|
bool bOnLyDWG, bool bOnLyProj, bool bNeedText, bool bNeedBlock)const
|
|
{
|
|
_DataStruct dsTemp;
|
|
for (int iFloor = 0; iFloor < (int)m_aryDataAll.GetSize(); iFloor++)
|
|
{
|
|
CGroup *pGroup = m_aryDataAll[iFloor];
|
|
if (pGroup == NULL)
|
|
continue;
|
|
if (bOnLyDWG && !pGroup->IsCurrDoc())
|
|
continue;
|
|
|
|
for (int iType = 0; iType < eDoorTypeNum; iType++)
|
|
{
|
|
const AryItemPtr& aryItemPtr = pGroup->GetItemAry(EEntType(iType));
|
|
|
|
for (int iItem = 0; iItem < (int)aryItemPtr.GetSize(); iItem++)
|
|
{
|
|
CItem *pItem = aryItemPtr[iItem];
|
|
for (int iId = 0; iId < (int)pItem->aryId.length(); iId++)
|
|
{
|
|
if (pItem->aryProp[iId].bText && !bNeedText)
|
|
continue;
|
|
dsTemp.id = pItem->aryId[iId];
|
|
dsTemp.prop = &(pItem->aryProp[iId]);
|
|
dsTemp.eEntType = pItem->eDoorWinType;
|
|
aryDataStruct.Add(dsTemp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!bOnLyProj)
|
|
{
|
|
for (int iType = 0; iType < eDoorTypeNum; iType++)
|
|
{
|
|
const AryItemPtr& aryItemPtr = m_dataNoProject.GetItemAry(EEntType(iType));
|
|
|
|
for (int iItem = 0; iItem < (int)aryItemPtr.GetSize(); iItem++)
|
|
{
|
|
CItem *pItem = aryItemPtr[iItem];
|
|
for (int iId = 0; iId < (int)pItem->aryId.length(); iId++)
|
|
{
|
|
if (pItem->aryProp[iId].bText && !bNeedText)
|
|
continue;
|
|
dsTemp.id = pItem->aryId[iId];
|
|
dsTemp.prop = &(pItem->aryProp[iId]);
|
|
dsTemp.eEntType = pItem->eDoorWinType;
|
|
aryDataStruct.Add(dsTemp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CDataTable::ClearFloorDataAry(AryAllData &aryData)
|
|
{
|
|
for (int i = 0; i < (int)aryData.GetSize(); i++)
|
|
{
|
|
CGroup *pGroup = aryData[i];
|
|
delete pGroup;
|
|
}
|
|
|
|
aryData.RemoveAll();
|
|
}
|
|
|
|
void GetOpeningIdListNew(DList<AcDbDatabase> &dbList, DList<AcDbObjectId> &idList)
|
|
{
|
|
XStringList lstFiles;
|
|
::GetFloorFiles(lstFiles);
|
|
CString sCurDwg=curDoc()->fileName();
|
|
for(int i=0; i<lstFiles.Length(); i++)
|
|
{
|
|
LPCTSTR szddd = lstFiles[i];
|
|
if (_tcsicmp(sCurDwg, lstFiles[i])==0)
|
|
continue; // Disalbe CurDwg
|
|
AcDbDatabase *dwgDb=new AcDbDatabase(false, true);
|
|
dbList.Append(dwgDb);
|
|
#if ADS < 21
|
|
if (dwgDb->readDwgFile(lstFiles[i], _SH_DENYNO, false)==Acad::eOk)
|
|
#else
|
|
if (dwgDb->readDwgFile(lstFiles[i], AcDbDatabase::kForReadAndAllShare, false)==Acad::eOk)
|
|
#endif
|
|
{
|
|
GetEntityFromDatabase(idList, *dwgDb, _T("TCH_OPENING"), 0, ACDB_MODEL_SPACE);
|
|
}
|
|
}
|
|
|
|
GetEntFromBlockByDxf(idList, _T("TCH_OPENING"));
|
|
}
|
|
|
|
// 构建跟pFloorLst对应的DWG列表
|
|
void BulidFloorFile(CStringArray &aryDWG, TProjectGroupItem *pFloorLst, DList<XFloorData> &lstFloorData)
|
|
{
|
|
if (pFloorLst == NULL || pFloorLst->GetDataNum() == 0)
|
|
return;
|
|
|
|
aryDWG.SetSize(pFloorLst->GetDataNum());
|
|
|
|
int i = 0, j = 0;
|
|
// 查找FloorList中每个数据所对应的DWG文件，
|
|
for (i=0; i<pFloorLst->GetDataNum(); i++)
|
|
{
|
|
TProjectFloor *pFloor = (TProjectFloor *)pFloorLst->GetAt(i);
|
|
|
|
DList<int> lstFloor;
|
|
// 对应的多个楼层，比较第一个就可以
|
|
if (StrToIntList(pFloor->GetLayerNo(), lstFloor))
|
|
{
|
|
int iFloor = *(lstFloor[0]);
|
|
|
|
for (j = 0; j < lstFloorData.Length(); j++)
|
|
{
|
|
if (lstFloorData[j]->m_nIndex == iFloor)
|
|
{
|
|
aryDWG[i] = lstFloorData[j]->m_sDwgFile;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int IdCmp(const AcDbObjectId *id1, const void *_id2)
|
|
{
|
|
AcDbObjectId *id2 = (AcDbObjectId*)_id2;
|
|
|
|
if (id1->asOldId() == id2->asOldId())
|
|
return 0;
|
|
else
|
|
return 1;
|
|
}
|
|
|
|
void GetCurrProjAndDoc(CString &strCurrProj, CString &strCurrDoc, CString &strCurrProjFullName)
|
|
{
|
|
strCurrDoc = curDoc()->fileName();
|
|
strCurrProj = ProjectName();
|
|
strCurrProjFullName = ProjectFullName();
|
|
}
|
|
|
|
BOOL TextLayCompare(CString &strTextLay);
|
|
bool FilterDoorWinText(AcDbEntity *pTextEnt)
|
|
{
|
|
if (pTextEnt == NULL)
|
|
return false;
|
|
|
|
CString strText;
|
|
if (pTextEnt->isKindOf(TDbText::desc()))
|
|
{
|
|
strText = TDbText::cast(pTextEnt)->GetText();
|
|
}
|
|
else if (pTextEnt->isKindOf(AcDbText::desc()))
|
|
{
|
|
strText = AcDbText::cast(pTextEnt)->textString();
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// lgh 修改了参数图层的替换条件
|
|
|
|
if (TextLayCompare(CString(pTextEnt->layer())) && CheckName(strText))
|
|
{
|
|
return true;
|
|
}
|
|
else return false;
|
|
|
|
// if ((strLayer1.Compare(pTextEnt->layer()) == 0 || strLayer2.Compare(pTextEnt->layer()) == 0) &&
|
|
// CheckName(strText))
|
|
// return true;
|
|
// else return false;
|
|
}
|
|
|
|
bool FilterDoorWinText(AcDbObjectId &idText)
|
|
{
|
|
OPENOBJ_BEGIN(idText, AcDb::kForRead, AcDbEntity, pEnt)
|
|
|
|
return FilterDoorWinText(pEnt);
|
|
|
|
OPENOBJ_END()
|
|
|
|
return false;
|
|
}
|
|
|
|
void FilterDoorWinText(AcDbObjectIdArray &aryId)
|
|
{
|
|
for (long iT = 0; iT < (int)aryId.length(); iT++)
|
|
{
|
|
if (!FilterDoorWinText(aryId[iT]))
|
|
{
|
|
aryId.removeAt(iT--);
|
|
}
|
|
}
|
|
}
|
|
|
|
void FilterDoorWinText(DList<AcDbObjectId> &lstId)
|
|
{
|
|
for (long iT = 0; iT < lstId.Length(); iT++)
|
|
{
|
|
if (!FilterDoorWinText(*(lstId[iT])))
|
|
{
|
|
lstId.Remove(iT--);
|
|
}
|
|
}
|
|
}
|
|
|
|
void GetDoorWinIdsAll(AcDbObjectIdArray &aryIdAll, XPoint ptMin, XPoint ptMax)
|
|
{
|
|
#ifndef NDEBUG
|
|
DWORD d1 = GetTickCount();
|
|
#endif
|
|
XPoint _ptMax = Max(ptMax, ptMin);
|
|
XPoint _ptMin = Min(ptMax, ptMin);
|
|
|
|
ptMin = _ptMin;
|
|
ptMax = _ptMax;
|
|
|
|
GetViewSafeSelection(aryIdAll, TRUE, ptMin, ptMax, _T("TCH_OPENING,TCH_DORMER,TCH_CORNER_WINDOW,TCH_TEXT,TEXT,INSERT"), 1);
|
|
|
|
for (int i = 0; i < (int)aryIdAll.length(); i++)
|
|
{
|
|
OPENOBJ_BEGIN(aryIdAll[i], AcDb::kForRead, AcDbEntity, pEnt)
|
|
{
|
|
if (pEnt->isKindOf(AcDbText::desc()) || pEnt->isKindOf(TDbText::desc()))
|
|
{
|
|
if (FilterDoorWinText(pEnt))
|
|
continue;
|
|
else
|
|
aryIdAll.removeAt(i--);
|
|
}
|
|
}
|
|
OPENOBJ_END()
|
|
|
|
}
|
|
#ifndef NDEBUG
|
|
dwRead += (GetTickCount() - d1);
|
|
dwRead1 += (GetTickCount() - d1);
|
|
#endif
|
|
}
|
|
|
|
void GetDoorWinIdsNoBlock(AcDbObjectIdArray &aryIdsNoblock, AcDbDatabase *pDataBase, XPoint ptMin, XPoint ptMax)
|
|
{
|
|
#ifndef NDEBUG
|
|
DWORD d1 = GetTickCount();
|
|
#endif
|
|
DList<AcDbObjectId> lstIdAll;
|
|
GetEntityFromDatabase(lstIdAll, *pDataBase,
|
|
_T("TCH_OPENING,TCH_CORNER_WINDOW,TCH_DORMER"), 1, ACDB_MODEL_SPACE, ptMin, ptMax);
|
|
int i = 0;
|
|
#ifndef NDEBUG
|
|
for (i = 0; i < (int)lstIdAll.Length(); i++)
|
|
{
|
|
acutPrintf(_T("ID%d: = %d\t"), i, lstIdAll[i]->asOldId());
|
|
}
|
|
#endif
|
|
|
|
DList<AcDbObjectId> lstTextId;
|
|
GetEntityFromDatabase(lstTextId, *pDataBase, _T("TCH_TEXT,TEXT"), 1, ACDB_MODEL_SPACE, ptMin, ptMax);
|
|
FilterDoorWinText(lstTextId);
|
|
lstIdAll << lstTextId; // 所有的ID，不带block
|
|
|
|
for (i = 0; i < (int)lstIdAll.Length(); i++)
|
|
{
|
|
aryIdsNoblock.append(*(lstIdAll[i]));
|
|
}
|
|
#ifndef NDEBUG
|
|
dwRead += (GetTickCount() - d1);
|
|
dwRead2 += (GetTickCount() - d1);
|
|
#endif
|
|
}
|
|
|
|
void GetDoorWinIds(AcDbObjectIdArray &aryIdAll, AcDbObjectIdArray &aryIdBlock)
|
|
{
|
|
#ifndef NDEBUG
|
|
DWORD d1 = GetTickCount();
|
|
#endif
|
|
XPoint ptMax = curDoc()->database()->extmax();
|
|
XPoint ptMin = curDoc()->database()->extmin();
|
|
|
|
double dExtx = (ptMax.x - ptMin.x) * 0.1;
|
|
double dExty = (ptMax.y - ptMin.y) * 0.1;
|
|
|
|
ptMin.x -= dExtx;
|
|
ptMin.y -= dExty;
|
|
|
|
ptMax.x += dExtx;
|
|
ptMax.y += dExty;
|
|
|
|
// 读出所有的实体的ID，包括块内实体。块内实体如果有多个，会重复列出。
|
|
GetDoorWinIdsAll(aryIdAll, ptMin, ptMax);
|
|
|
|
AcDbObjectIdArray aryIdNoBlock;
|
|
GetDoorWinIdsNoBlock(aryIdNoBlock, curDoc()->database(), ptMin, ptMax);
|
|
|
|
for (int i = 0; i < (int)aryIdAll.length(); i++)
|
|
{
|
|
if (FindIdArry(aryIdNoBlock, aryIdAll[i]) == -1)
|
|
{
|
|
aryIdBlock.append(aryIdAll[i]);
|
|
}
|
|
}
|
|
#ifndef NDEBUG
|
|
// dwRead += (GetTickCount() - d1);
|
|
#endif
|
|
}
|
|
|
|
// 下面的算法设计考虑了一下效率的问题：因为一个图形可能会对应多个楼层，
|
|
// 所以希望打开一个图形的时候，能够一次读出该图形中所有的楼层，而不用多次打开一个图形。
|
|
void GetOpeningDataTable(CDataTable &dataTable)
|
|
{
|
|
#ifndef NDEBUG
|
|
dwtime = 0;
|
|
dwRead = 0;
|
|
#endif
|
|
|
|
CString strCurrProj, strCurrDoc, strCurrProjFullName;
|
|
GetCurrProjAndDoc(strCurrProj, strCurrDoc, strCurrProjFullName);
|
|
dataTable.SetProjName(strCurrProj);
|
|
dataTable.SetDocName(strCurrDoc);
|
|
dataTable.SetProjFullName(strCurrProjFullName);
|
|
dataTable.SetSelFlag(false); // 非框选
|
|
|
|
if (IsEmptyProject())
|
|
{ // 没有工程，则本图全部数据都是未创建工程数据
|
|
// DList<AcDbObjectId> lstId;
|
|
AcDbObjectIdArray aryIdAll, aryIDBlock;
|
|
GetDoorWinIds(aryIdAll, aryIDBlock);
|
|
dataTable.AddIdNoProject(aryIdAll, &aryIDBlock);
|
|
}
|
|
else
|
|
{ // 本工程，
|
|
// 读取工程文件的算法有些诡异，为了保证每个文件不被多次打开（效率问题），使用一下方法：
|
|
// 读取所有的楼层，和楼层对应的文件；
|
|
// 读取所有的文件，
|
|
// 遍历所有的文件，跟楼层表对应，如果某楼层在该文件内，则读取该楼层的数据。
|
|
// 另外本图需要识别工程内，和工程外。
|
|
|
|
|
|
// 因为需要识别本图未创建工程数据，因此，总是需要打开楼层列表，检测不在楼层列表的数据。
|
|
|
|
// 楼层列表，用它来跟XFloorData匹配检测对应的文档
|
|
TProjectGroupItem *pFloorLst = GetFloorTable();
|
|
CStringArray aryDWGPath; // 跟楼层对应,每个楼层所对应的floor文件
|
|
// 楼层参数，用来取得每个楼层对应得名字
|
|
DList<XFloorData> lstFloorData;
|
|
GetFloorData(lstFloorData);
|
|
// 构建了楼层对应的DWG数组，就可以用该数组来打开对应的文件。
|
|
BulidFloorFile(aryDWGPath, pFloorLst, lstFloorData);
|
|
|
|
dataTable.SetFloorNum((int)aryDWGPath.GetSize());
|
|
|
|
DList<AcDbDatabase> dbList; // 本工程的Database;保持打开的状态，以保存ID
|
|
XStringList lstFiles;
|
|
::GetFloorFiles(lstFiles); // 所有的DWG
|
|
CString sCurDwg=curDoc()->fileName();
|
|
int i = 0, j = 0;
|
|
bool bFindCurrDoc = false;
|
|
for(i=0; i<lstFiles.Length(); i++)
|
|
{
|
|
LPCTSTR file = lstFiles[i];
|
|
|
|
if (_tcsicmp(sCurDwg, lstFiles[i])==0)
|
|
{ // 当前图
|
|
bFindCurrDoc = true;
|
|
AcDbObjectIdArray aryIdAll, aryIDBlock;
|
|
GetDoorWinIds(aryIdAll, aryIDBlock);
|
|
|
|
for (j = 0; j < (int)aryDWGPath.GetSize(); j++)
|
|
{ // 打开该图形对应的所有的楼层
|
|
if (aryDWGPath[j].CompareNoCase(lstFiles[i]) == 0)
|
|
{ // 本图中的楼层
|
|
TProjectFloor *pFloor = (TProjectFloor *)pFloorLst->GetAt(j);
|
|
if (pFloor != NULL)
|
|
{
|
|
XPoint ptMin, ptMax;
|
|
if (!pFloor->IsFloorInFrame())
|
|
{
|
|
ptMax = curDoc()->database()->extmax();
|
|
ptMin = curDoc()->database()->extmin();
|
|
}
|
|
else
|
|
pFloor->GetRange(ptMin, ptMax);
|
|
|
|
AcDbObjectIdArray aryIdFloor;
|
|
GetDoorWinIdsAll(aryIdFloor, ptMin, ptMax);
|
|
|
|
dataTable.AddIdByFloor(aryIdFloor, j, pFloor->GetLayerNo(), TRUE, &aryIDBlock);
|
|
dataTable.AddFloorInfo(pFloor->GetLayerNo(), lstFiles[i], pFloor->IsFloorInFrame(), ptMin, ptMax);
|
|
// 从中删除属于楼层的ID,剩余的都是不在工程中的ID;
|
|
for (int k = 0; k < (int)aryIdFloor.length(); k++)
|
|
{
|
|
int nPos = FindIdArry(aryIdAll, aryIdFloor[k]);
|
|
if (nPos != -1)
|
|
aryIdAll.removeAt(nPos);
|
|
}
|
|
}
|
|
}
|
|
} // end read DWG;
|
|
|
|
dataTable.AddIdNoProject(aryIdAll, &aryIDBlock); // 当前图层的所有的ID
|
|
}
|
|
else
|
|
{ // 其他图只读取工程内的数据
|
|
AcDbDatabase *dwgDb=new AcDbDatabase(false, true);
|
|
dbList.Append(dwgDb);
|
|
#if ADS < 21
|
|
if (dwgDb->readDwgFile(lstFiles[i], _SH_DENYNO, false)==Acad::eOk)
|
|
#else
|
|
if (dwgDb->readDwgFile(lstFiles[i], AcDbDatabase::kForReadAndAllShare, false)==Acad::eOk)
|
|
#endif
|
|
{
|
|
for (j = 0; j < (int)aryDWGPath.GetSize(); j++)
|
|
{ // 打开该图形对应的所有的楼层
|
|
if (aryDWGPath[j].CompareNoCase(lstFiles[i]) == 0)
|
|
{
|
|
TProjectFloor *pFloor = (TProjectFloor *)pFloorLst->GetAt(j);
|
|
if (pFloor != NULL)
|
|
{
|
|
DList<AcDbObjectId> idList;
|
|
XPoint ptMin, ptMax;
|
|
if (!pFloor->IsFloorInFrame())
|
|
{
|
|
ptMax = dwgDb->extmax();
|
|
ptMin = dwgDb->extmin();
|
|
}
|
|
else
|
|
pFloor->GetRange(ptMin, ptMax);
|
|
AcDbObjectIdArray aryIdFloor;
|
|
// 其他图中无提供读取块实体的接口
|
|
GetDoorWinIdsNoBlock(aryIdFloor, dwgDb, ptMin, ptMax);
|
|
dataTable.AddIdByFloor(aryIdFloor, j, pFloor->GetLayerNo(), FALSE, NULL);
|
|
dataTable.AddFloorInfo(pFloor->GetLayerNo(), lstFiles[i], pFloor->IsFloorInFrame(), ptMin, ptMax);
|
|
}
|
|
}
|
|
}
|
|
} // end read dwg;
|
|
}
|
|
}// end for(i=0; i<lstFiles.Length(); i++) , 遍历所有的DWG
|
|
|
|
if (!bFindCurrDoc)
|
|
{ // 如果当前楼层不在工程中：
|
|
AcDbObjectIdArray aryIdAll, aryIDBlock;
|
|
GetDoorWinIds(aryIdAll, aryIDBlock);
|
|
dataTable.AddIdNoProject(aryIdAll, &aryIDBlock);
|
|
}
|
|
|
|
// 清除空的楼层：
|
|
dataTable.ClearNullFloor();
|
|
} // end else 本工程
|
|
#ifndef NDEBUG
|
|
ads_printf(XString(_T("\n属性检测花费的时间：%d"), dwtime));
|
|
ads_printf(XString(_T("\n读取DWG花费的时间：%d"), dwRead));
|
|
ads_printf(XString(_T("\n读取DWG111花费的时间：%d"), dwRead1));
|
|
ads_printf(XString(_T("\n读取DWG222花费的时间：%d"), dwRead2));
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// 门窗检查
|
|
using namespace NDoorWinCheck;
|
|
void ValidateOpening()
|
|
{
|
|
#ifndef NDEBUG
|
|
DWORD d1 = GetTickCount();
|
|
#endif
|
|
|
|
//LH 2013-2-23 解决门窗检查时Create界面崩溃的问题
|
|
CAcModuleResourceOverride vTemp;
|
|
|
|
if (pFrame == NULL)
|
|
{
|
|
pFrame = new CDoorWinFrame;
|
|
BOOL bRes = pFrame->Create(NULL, _T("门窗检查"),
|
|
WS_OVERLAPPEDWINDOW,
|
|
CRect(0, 0, 480, 600), acedGetAcadDwgView());
|
|
}
|
|
|
|
// 如果没有的话，则显示出来。
|
|
// if (!pFrame->IsWindowVisible())
|
|
{
|
|
pFrame->ReadDWG();
|
|
pFrame->ShowWindow(SW_SHOWNORMAL);
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
ads_printf(XString(_T("\n窗口显示的时间：%d"), GetTickCount() - d1));
|
|
#endif
|
|
}
|
|
|
|
|
|
void CloseDoorWindow()
|
|
{
|
|
if (pFrame != NULL)
|
|
{
|
|
pFrame->DestroyWindow();
|
|
pFrame = NULL;
|
|
|
|
}
|
|
}
|
|
|