2372 lines
70 KiB
C++
2372 lines
70 KiB
C++
#include "stdafx.h"
|
|
#include "resource.h"
|
|
#include "TArchCmdReactor.h"
|
|
#include "InsDoorWinDlg.h"
|
|
#include "BayWindowDlg.h"
|
|
#include "RectHoleDlg.h"
|
|
#include "ArcWindowDlg.h"
|
|
#include "DoorWinDlg.h"
|
|
#include "TwoDoorDlg.h"
|
|
#include "PolyHoleDlg.h"
|
|
#include <actrans.h>
|
|
#include "OpeningLabelData.h"
|
|
#include "utility.h"
|
|
#include "wall_xdata_key.h"
|
|
|
|
void InsOpening(TOpeningData::OpeningKind opFlag);
|
|
bool CheckDoorWinLabel(CString strName);
|
|
int GetSequenceNum(CString strlabel);
|
|
// 门窗编号同类型检测函数组：
|
|
enum ESameLabelTypeIndex {eSameLabelDoor = 0, eSameLabelWin, eSameLabelMLC, eSameLabelZMM,
|
|
eSameLabelHC, eSameLabelZHMC, eSameLableHole, eSameLabelTC,
|
|
eSameLabelCornerWin, eSameLabelBanWin, eSameLabelDormer, eSameLabelOpBanWin, eSameLabelNum};
|
|
// 1、大类型相同，2、具体门窗要求子类相同
|
|
// 门或者窗是否可以采用同一编号
|
|
bool CanSameLabelDoorOrWin(TDbEntity *pOpening1, TDbEntity *pOpening2)
|
|
{
|
|
if (pOpening1->isKindOf(TDbOpening::desc()) && pOpening2->isKindOf(TDbOpening::desc()))
|
|
{
|
|
TDbOpening *pOpeningTemp1 = TDbOpening::cast(pOpening1);
|
|
TDbOpening *pOpeningTemp2 = TDbOpening::cast(pOpening2);
|
|
|
|
if (pOpeningTemp1 == NULL || pOpeningTemp2 == NULL)
|
|
return false;
|
|
|
|
if ((pOpeningTemp1->GetKind() == TDbOpening::OP_DOOR && pOpeningTemp2->GetKind() == TDbOpening::OP_DOOR) ||
|
|
(pOpeningTemp1->GetKind() == TDbOpening::OP_WINDOW && pOpeningTemp2->GetKind() == TDbOpening::OP_WINDOW))
|
|
{// 宽、高、二维样式、三维样式
|
|
XString xStyle2d1, xStyle2d2, xStyle3d1, xStyle3d2;
|
|
pOpeningTemp1->GetStyle2dName(xStyle2d1);
|
|
pOpeningTemp1->GetStyle3dName(xStyle3d1);
|
|
pOpeningTemp2->GetStyle2dName(xStyle2d2);
|
|
pOpeningTemp2->GetStyle3dName(xStyle3d2);
|
|
|
|
return ((fabs(pOpeningTemp1->GetWidth() - pOpeningTemp2->GetWidth()) < 1e-6) &&
|
|
(fabs(pOpeningTemp1->GetHeight() - pOpeningTemp2->GetHeight()) < 1e-6) &&
|
|
(xStyle2d1 == xStyle2d2) && (xStyle3d1 == xStyle3d2) &&
|
|
(pOpeningTemp1->GetSubKind().Compare(pOpeningTemp2->GetSubKind()) == 0));
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
// 门连窗
|
|
bool CanSameLabelMLC(TDbEntity *pOpening1, TDbEntity *pOpening2)
|
|
{
|
|
if (pOpening1->isKindOf(TDbOpening::desc()) && pOpening2->isKindOf(TDbOpening::desc()))
|
|
{
|
|
TDbOpening *pOpeningTemp1 = TDbOpening::cast(pOpening1);
|
|
TDbOpening *pOpeningTemp2 = TDbOpening::cast(pOpening2);
|
|
|
|
if (pOpeningTemp1 == NULL || pOpeningTemp2 == NULL)
|
|
return false;
|
|
|
|
if (pOpeningTemp1->GetKind() == TDbOpening::OP_DOORWIN && pOpeningTemp2->GetKind() == TDbOpening::OP_DOORWIN)
|
|
{// 总宽、门宽、门高、窗高、门的三维样式、窗的三维样式
|
|
XString xStyle2d1, xStyle2d2, xStyle3d1, xStyle3d2;
|
|
pOpeningTemp1->GetStyle2dName(xStyle2d1);
|
|
pOpeningTemp1->GetStyle3dName(xStyle3d1);
|
|
pOpeningTemp2->GetStyle2dName(xStyle2d2);
|
|
pOpeningTemp2->GetStyle3dName(xStyle3d2);
|
|
return ((fabs(pOpeningTemp1->GetWidth() - pOpeningTemp2->GetWidth()) < 1e-6) &&
|
|
(fabs(pOpeningTemp1->GetHeight() - pOpeningTemp2->GetHeight()) < 1e-6) &&
|
|
(xStyle2d1 == xStyle2d2) && (xStyle3d1 == xStyle3d2) &&
|
|
(fabs(pOpeningTemp1->m_nDoorWidth - pOpeningTemp2->m_nDoorWidth) < 1e-6) &&
|
|
(fabs(pOpeningTemp1->m_nWinHeight - pOpeningTemp2->m_nWinHeight) < 1e-6));
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
// 子母门
|
|
bool CanSameLabelZMM(TDbEntity *pOpening1, TDbEntity *pOpening2)
|
|
{
|
|
if (pOpening1->isKindOf(TDbOpening::desc()) && pOpening2->isKindOf(TDbOpening::desc()))
|
|
{
|
|
TDbOpening *pOpeningTemp1 = TDbOpening::cast(pOpening1);
|
|
TDbOpening *pOpeningTemp2 = TDbOpening::cast(pOpening2);
|
|
|
|
if (pOpeningTemp1 == NULL || pOpeningTemp2 == NULL)
|
|
return false;
|
|
|
|
if (pOpeningTemp1->GetKind() == TDbOpening::OP_TWODOOR && pOpeningTemp2->GetKind() == TDbOpening::OP_TWODOOR)
|
|
{// 总宽、大门宽、门高、大门的三维样式、小门的三维样式
|
|
XString xStyle2d1, xStyle2d2, xStyle3d1, xStyle3d2;
|
|
pOpeningTemp1->GetStyle2dName(xStyle2d1);
|
|
pOpeningTemp1->GetStyle3dName(xStyle3d1);
|
|
pOpeningTemp2->GetStyle2dName(xStyle2d2);
|
|
pOpeningTemp2->GetStyle3dName(xStyle3d2);
|
|
return ((fabs(pOpeningTemp1->GetWidth() - pOpeningTemp2->GetWidth()) < 1e-6) &&
|
|
(fabs(pOpeningTemp1->GetHeight() - pOpeningTemp2->GetHeight()) < 1e-6) &&
|
|
(xStyle2d1 == xStyle2d2) && (xStyle3d1 == xStyle3d2) &&
|
|
(fabs(pOpeningTemp1->m_nDoorWidth - pOpeningTemp2->m_nDoorWidth) < 1e-6));
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
// 弧窗
|
|
bool CanSameLabelHC(TDbEntity *pOpening1, TDbEntity *pOpening2)
|
|
{
|
|
if (pOpening1->isKindOf(TDbOpening::desc()) && pOpening2->isKindOf(TDbOpening::desc()))
|
|
{
|
|
TDbOpening *pOpeningTemp1 = TDbOpening::cast(pOpening1);
|
|
TDbOpening *pOpeningTemp2 = TDbOpening::cast(pOpening2);
|
|
|
|
if (pOpeningTemp1 == NULL || pOpeningTemp2 == NULL)
|
|
return false;
|
|
|
|
if (pOpeningTemp1->GetKind() == TDbOpening::OP_ARCWIN && pOpeningTemp2->GetKind() == TDbOpening::OP_ARCWIN)
|
|
{// 宽、高、类型
|
|
CString strSubKind1 = pOpeningTemp1->GetSubKind();
|
|
CString strSubKind2 = pOpeningTemp2->GetSubKind();
|
|
|
|
return ((fabs(pOpeningTemp1->GetWidth() - pOpeningTemp2->GetWidth()) < 1e-6) &&
|
|
(fabs(pOpeningTemp1->GetHeight() - pOpeningTemp2->GetHeight()) < 1e-6) &&
|
|
(strSubKind1.CompareNoCase(strSubKind2) == 0));
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
// 组合门窗、矩形洞
|
|
bool CanSameLabelZHMC(TDbEntity *pOpening1, TDbEntity *pOpening2)
|
|
{
|
|
if (pOpening1->isKindOf(TDbOpening::desc()) && pOpening2->isKindOf(TDbOpening::desc()))
|
|
{
|
|
TDbOpening *pOpeningTemp1 = TDbOpening::cast(pOpening1);
|
|
TDbOpening *pOpeningTemp2 = TDbOpening::cast(pOpening2);
|
|
|
|
if (pOpeningTemp1 == NULL || pOpeningTemp2 == NULL)
|
|
return false;
|
|
|
|
if ((pOpeningTemp1->GetKind() == TDbOpening::OP_GROUP && pOpeningTemp2->GetKind() == TDbOpening::OP_GROUP) ||
|
|
(pOpeningTemp1->GetKind() == TDbOpening::OP_HOLE && pOpeningTemp2->GetKind() == TDbOpening::OP_HOLE))
|
|
{// 宽、高
|
|
return ((fabs(pOpeningTemp1->GetWidth() - pOpeningTemp2->GetWidth()) < 1e-6) &&
|
|
(fabs(pOpeningTemp1->GetHeight() - pOpeningTemp2->GetHeight()) < 1e-6));
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
// 凸窗
|
|
bool CanSameLabelTC(TDbEntity *pOpening1, TDbEntity *pOpening2)
|
|
{
|
|
if (pOpening1->isKindOf(TDbOpening::desc()) && pOpening2->isKindOf(TDbOpening::desc()))
|
|
{
|
|
TDbOpening *pOpeningTemp1 = TDbOpening::cast(pOpening1);
|
|
TDbOpening *pOpeningTemp2 = TDbOpening::cast(pOpening2);
|
|
|
|
if ((pOpeningTemp1->GetKind() == TDbOpening::OP_PROWIN && pOpeningTemp2->GetKind() == TDbOpening::OP_PROWIN))
|
|
{// 型式、宽、高、凸出宽、梯形宽
|
|
XBayWindow *pBayWin1 = pOpeningTemp1->m_pBayWin;
|
|
XBayWindow *pBayWin2 = pOpeningTemp2->m_pBayWin;
|
|
return ((fabs(pOpeningTemp1->GetWidth() - pOpeningTemp2->GetWidth()) < 1e-6) &&
|
|
(fabs(pOpeningTemp1->GetHeight() - pOpeningTemp2->GetHeight()) < 1e-6) &&
|
|
(pBayWin1 != NULL && pBayWin2 != NULL) &&
|
|
(pBayWin1->m_nStyle == pBayWin2->m_nStyle) &&
|
|
(fabs(pBayWin1->m_nProtrude - pBayWin2->m_nProtrude) < 1e-6) &&
|
|
fabs(pBayWin1->m_nTrapezia - pBayWin2->m_nTrapezia) < 1e-6);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CanSameLabelOpBandWin(TDbEntity *pOpening1, TDbEntity *pOpening2)
|
|
{
|
|
if (pOpening1->isKindOf(TDbOpening::desc()) && pOpening2->isKindOf(TDbOpening::desc()))
|
|
{
|
|
TDbOpening *pOpeningTemp1 = TDbOpening::cast(pOpening1);
|
|
TDbOpening *pOpeningTemp2 = TDbOpening::cast(pOpening2);
|
|
|
|
if (pOpeningTemp1 == NULL || pOpeningTemp2 == NULL)
|
|
return false;
|
|
|
|
if ((pOpeningTemp1->GetKind() == TDbOpening::OP_CORNWIN && pOpeningTemp2->GetKind() == TDbOpening::OP_CORNWIN))
|
|
{// 宽、高、二维样式、三维样式
|
|
XString xStyle2d1, xStyle2d2, xStyle3d1, xStyle3d2;
|
|
pOpeningTemp1->GetStyle2dName(xStyle2d1);
|
|
pOpeningTemp1->GetStyle3dName(xStyle3d1);
|
|
pOpeningTemp2->GetStyle2dName(xStyle2d2);
|
|
pOpeningTemp2->GetStyle3dName(xStyle3d2);
|
|
|
|
return ((fabs(pOpeningTemp1->GetWidth() - pOpeningTemp2->GetWidth()) < 1e-6) &&
|
|
(fabs(pOpeningTemp1->GetHeight() - pOpeningTemp2->GetHeight()) < 1e-6) &&
|
|
(xStyle2d1 == xStyle2d2) && (xStyle3d1 == xStyle3d2) &&
|
|
(pOpeningTemp1->GetSubKind().Compare(pOpeningTemp2->GetSubKind()) == 0));
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CanSameLabelCorWin(TDbEntity *pOpening1, TDbEntity *pOpening2)
|
|
{
|
|
if (pOpening1->isKindOf(TDbCornerWin::desc()) && pOpening2->isKindOf(TDbCornerWin::desc()) &&
|
|
!pOpening1->isKindOf(TDbBandWin::desc()) && !pOpening2->isKindOf(TDbBandWin::desc()))
|
|
{
|
|
TDbCornerWin *pOpeningTemp1 = TDbCornerWin::cast(pOpening1);
|
|
TDbCornerWin *pOpeningTemp2 = TDbCornerWin::cast(pOpening2);
|
|
|
|
if (pOpeningTemp1 == NULL || pOpeningTemp2 == NULL)
|
|
return false;
|
|
|
|
double dWholeWid1 = pOpeningTemp1->GetWidth1() + pOpeningTemp1->GetWidth2();
|
|
double dWholeWid2 = pOpeningTemp2->GetWidth1() + pOpeningTemp2->GetWidth2();
|
|
{
|
|
TOpeningLabelData labelData;
|
|
TOpeningLabelData::ECalWidthRule nRule = labelData.GetCalWidthRule();
|
|
|
|
if (nRule == TOpeningLabelData::kMiddle)
|
|
{
|
|
dWholeWid1 = dWholeWid1 + pOpeningTemp1->GetWallThick2()*0.5 + pOpeningTemp1->GetWallThick1()*0.5;
|
|
dWholeWid2 = dWholeWid2 + pOpeningTemp2->GetWallThick2()*0.5 + pOpeningTemp2->GetWallThick1()*0.5;
|
|
}
|
|
else if (nRule == TOpeningLabelData::kOutboard)
|
|
{
|
|
dWholeWid1 = dWholeWid1 + pOpeningTemp1->GetWallThick2() + pOpeningTemp1->GetWallThick1();
|
|
dWholeWid2 = dWholeWid2 + pOpeningTemp2->GetWallThick2() + pOpeningTemp2->GetWallThick1();
|
|
}
|
|
}
|
|
// 总宽，高，出挑
|
|
if (pOpeningTemp1->IsProtrude() != pOpeningTemp2->IsProtrude())
|
|
return false;
|
|
else if (pOpeningTemp1->IsProtrude())
|
|
{
|
|
return (fabs(dWholeWid1 - dWholeWid2) < 1e-6 &&
|
|
fabs(pOpeningTemp1->GetHeight() - pOpeningTemp2->GetHeight()) < 1e-6 &&
|
|
fabs(pOpeningTemp1->GetProtrude() - pOpeningTemp2->GetProtrude()) < 1e-6);
|
|
}
|
|
else
|
|
{
|
|
return (fabs(dWholeWid1 - dWholeWid2) < 1e-6 &&
|
|
fabs(pOpeningTemp1->GetHeight() - pOpeningTemp2->GetHeight()) < 1e-6);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool TestCanSameLabel(TDbBandWin *pBandWin, double dWid, double dHei);
|
|
bool CanSameLabelBanWin(TDbEntity *pOpening1, TDbEntity *pOpening2)
|
|
{
|
|
if (pOpening1->isKindOf(TDbBandWin::desc()) && pOpening2->isKindOf(TDbBandWin::desc()))
|
|
{
|
|
TDbBandWin *pOpeningTemp1 = TDbBandWin::cast(pOpening1);
|
|
TDbBandWin *pOpeningTemp2 = TDbBandWin::cast(pOpening2);
|
|
|
|
if (pOpeningTemp1 == NULL || pOpeningTemp2 == NULL)
|
|
return false;
|
|
|
|
// sg modify 120514，根据9.0需求，带形窗宽度的测量改用中心线
|
|
//return TestCanSameLabel(pOpeningTemp1, pOpeningTemp2->GetWidth(), pOpeningTemp2->GetHeight());
|
|
return TestCanSameLabel(pOpeningTemp1, pOpeningTemp2->GetGeomCenterWidth(), pOpeningTemp2->GetHeight());
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
bool TestCanSameLabel(TDbDormer *pDormer, double dWid, double dHei);
|
|
bool CanSameLabelDormer(TDbEntity *pOpening1, TDbEntity *pOpening2)
|
|
{
|
|
if (pOpening1->isKindOf(TDbDormer::desc()) && pOpening2->isKindOf(TDbDormer::desc()))
|
|
{
|
|
TDbDormer *pOpeningTemp1 = TDbDormer::cast(pOpening1);
|
|
TDbDormer *pOpeningTemp2 = TDbDormer::cast(pOpening2);
|
|
|
|
const TDormerPar &dorPar = pOpeningTemp2->GetDormerPar();
|
|
|
|
double dWidOld = dorPar.GetWindowWidth();
|
|
double dHeiOld = dorPar.GetWindowHeight();
|
|
return TestCanSameLabel(pOpeningTemp1, dWidOld, dHeiOld);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
typedef bool (*PFunCanSameLabel)(TDbEntity*, TDbEntity*);
|
|
|
|
// {eSameLabelDoor = 0, eSameLabelWin, eSameLabelMLC, eSameLabelZMM,
|
|
// eSameLabelHC, eSameLabelZHMC, eSameLableHole, eSameLabelTC,
|
|
// eSameLabelCornerWin, eSameLabelBanWin, eSameLabelDormer, eSameLabelNum};
|
|
PFunCanSameLabel g_funSameLabel[eSameLabelNum] =
|
|
{
|
|
CanSameLabelDoorOrWin, CanSameLabelDoorOrWin, CanSameLabelMLC, CanSameLabelZMM,
|
|
CanSameLabelHC, CanSameLabelZHMC, CanSameLabelZHMC, CanSameLabelTC,
|
|
CanSameLabelCorWin, CanSameLabelBanWin, CanSameLabelDormer, CanSameLabelOpBandWin
|
|
};
|
|
|
|
bool CanSameLabel(TDbEntity* pOpening1, TDbEntity *pOpening2)
|
|
{
|
|
if (pOpening1 == NULL || pOpening2 == NULL)
|
|
return false;
|
|
|
|
if (pOpening1->isKindOf(TDbOpening::desc()) && pOpening2->isKindOf(TDbOpening::desc()))
|
|
{
|
|
TDbOpening *p1 = TDbOpening::cast(pOpening1);
|
|
TDbOpening *p2 = TDbOpening::cast(pOpening2);
|
|
if (p1->GetKind() == TDbOpening::OP_DOOR && p2->GetKind() == TDbOpening::OP_DOOR)
|
|
return g_funSameLabel[eSameLabelDoor](pOpening1, pOpening2);
|
|
else if (p1->GetKind() == TDbOpening::OP_WINDOW && p2->GetKind() == TDbOpening::OP_WINDOW)
|
|
return g_funSameLabel[eSameLabelWin](pOpening1, pOpening2);
|
|
else if (p1->GetKind() == TDbOpening::OP_DOORWIN && p2->GetKind() == TDbOpening::OP_DOORWIN)
|
|
return g_funSameLabel[eSameLabelMLC](pOpening1, pOpening2);
|
|
else if (p1->GetKind() == TDbOpening::OP_TWODOOR && p2->GetKind() == TDbOpening::OP_TWODOOR)
|
|
return g_funSameLabel[eSameLabelZMM](pOpening1, pOpening2);
|
|
else if (p1->GetKind() == TDbOpening::OP_ARCWIN && p2->GetKind() == TDbOpening::OP_ARCWIN)
|
|
return g_funSameLabel[eSameLabelHC](pOpening1, pOpening2);
|
|
else if (p1->GetKind() == TDbOpening::OP_GROUP && p2->GetKind() == TDbOpening::OP_GROUP)
|
|
return g_funSameLabel[eSameLabelZHMC](pOpening1, pOpening2);
|
|
else if (p1->GetKind() == TDbOpening::OP_PROWIN && p2->GetKind() == TDbOpening::OP_PROWIN)
|
|
return g_funSameLabel[eSameLabelTC](pOpening1, pOpening2);
|
|
else if (p1->GetKind() == TDbOpening::OP_HOLE && p2->GetKind() == TDbOpening::OP_HOLE)
|
|
return g_funSameLabel[eSameLableHole](pOpening1, pOpening2);
|
|
else if (p1->GetKind() == TDbOpening::OP_CORNWIN && p2->GetKind() == TDbOpening::OP_CORNWIN)
|
|
return g_funSameLabel[eSameLabelOpBanWin](pOpening1, pOpening2);
|
|
}
|
|
else if (pOpening1->isKindOf(TDbBandWin::desc()) && pOpening2->isKindOf(TDbBandWin::desc()))
|
|
return g_funSameLabel[eSameLabelBanWin](pOpening1, pOpening2);
|
|
else if (pOpening1->isKindOf(TDbCornerWin::desc()) && pOpening2->isKindOf(TDbCornerWin::desc()))
|
|
return g_funSameLabel[eSameLabelCornerWin](pOpening1, pOpening2);
|
|
else if (pOpening1->isKindOf(TDbDormer::desc()) && pOpening2->isKindOf(TDbDormer::desc()))
|
|
return g_funSameLabel[eSameLabelDormer](pOpening1, pOpening2);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void MirrorWin(BOOL bLeftRight)
|
|
{
|
|
RBList mask(RTDXF0, _T("TCH_OPENING"), NULL);
|
|
PickSet ss(SS_FREE);
|
|
if (SelectEntities(_T("\n选择待翻转的门窗:"), ss, mask)==RTNORM) {
|
|
long lCount=ss.Length();
|
|
for(long i=0L; i<lCount; i++) {
|
|
Entity ent=ss[i];
|
|
OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbOpening, pWin);
|
|
if (pWin) {
|
|
pWin->MirrorSelf(bLeftRight);
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void MirWinIO()
|
|
{
|
|
MirrorWin(FALSE);
|
|
}
|
|
|
|
void MirWinLR()
|
|
{
|
|
MirrorWin(TRUE);
|
|
}
|
|
|
|
///////////////////////////////
|
|
// Command: 插窗
|
|
// 必须在WCS下
|
|
void InsWin()
|
|
{
|
|
InsOpening(TOpeningData::OP_WINDOW);
|
|
}
|
|
|
|
///////////////////////////////
|
|
// Command: 插窗
|
|
// 必须在WCS下
|
|
void InsHWin()
|
|
{
|
|
/*
|
|
AsureWCS();
|
|
InitLayer(LAY_OPENING_DIM, TRUE);
|
|
InsertOpening(TOpeningData::OP_HWINDOW);
|
|
*/
|
|
}
|
|
|
|
|
|
|
|
|
|
///////////////////////////////////
|
|
// Command: 插门
|
|
// 必须在WCS下
|
|
void InsDoor()
|
|
{
|
|
InsOpening(TOpeningData::OP_DOOR);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// ////////////////////////////////////////////////
|
|
// // Command: 改门窗编号
|
|
// // 必须在WCS下
|
|
// void ChWinLab1()
|
|
// {
|
|
// RBList mask(RTDXF0, _T("TCH_OPENING"),-4,_T("<OR"),8,LAY_WIN,8,LAY_DOOR,-4,_T("OR>"),NULL);
|
|
// PickSet ss(SS_FREE);
|
|
// XString sxLabel;
|
|
//
|
|
//
|
|
// if (SelectEntities(_T("\n请选择需要改编号的门窗的范围:"), ss, mask)==RTNORM)
|
|
// {
|
|
// long lCount = ss.Length();
|
|
// BOOL flag = FALSE;
|
|
// TOpeningData::OpeningKind opKind;
|
|
// double nWidth, nHeight;
|
|
// XString xsName2d, xsName3d, xsTmp2d, xsTmp3d;
|
|
// for(long i=0L; i<lCount; i++)
|
|
// {
|
|
// Entity ent = ss[i];
|
|
// OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbOpening, pOpening);
|
|
// if (pOpening)
|
|
// {
|
|
// if (i == 0)
|
|
// {
|
|
// opKind = pOpening->GetKind();
|
|
// nWidth = pOpening->GetWidth();
|
|
// nHeight = pOpening->GetHeight();
|
|
// pOpening->GetStyle2dName(xsName2d);
|
|
// pOpening->GetStyle3dName(xsName3d);
|
|
// }
|
|
// else
|
|
// {
|
|
// xsTmp3d=_T("");
|
|
// xsTmp2d=_T("");
|
|
// pOpening->GetStyle2dName(xsTmp2d);
|
|
// pOpening->GetStyle3dName(xsTmp3d);
|
|
// if (pOpening->GetKind() != opKind
|
|
// || xsTmp2d != xsName2d
|
|
// || xsTmp3d != xsName3d
|
|
// || fabs(pOpening->GetWidth() - nWidth) > 0.01
|
|
// || fabs(pOpening->GetHeight() - nHeight) > 0.01)
|
|
// {
|
|
// flag = TRUE;//包含不同类型的门窗
|
|
// break;
|
|
// }
|
|
// }
|
|
// }
|
|
// OPENOBJ_END();
|
|
// }
|
|
// PickSet ssNew(SS_FREE);
|
|
// if (flag)//包含不同类型的门窗
|
|
// {
|
|
// Entity entTmp;
|
|
// int nRet=RTNORM;
|
|
// while(nRet==RTNORM)
|
|
// {
|
|
// TCHAR cRet;
|
|
// nRet=SelectEntity(_T("\n请选择需要修改编号的样板门窗或 [自动编号(S)]:"), entTmp, mask,_T("S"),cRet);
|
|
// ss.Redraw(4);
|
|
// ssNew.Free();
|
|
//
|
|
// if (nRet==RTKWORD)
|
|
// {
|
|
// for(long i=0;i<ss.Length();i++)
|
|
// {
|
|
// Entity ent=ss[i];
|
|
// OPENOBJ_BEGIN(ent,AcDb::kForWrite,TDbOpening,pOpening)
|
|
// if (pOpening!=NULL)
|
|
// {
|
|
// pOpening->assertWriteEnabled();
|
|
//
|
|
// // modify by xly on 110224 增加bool变量
|
|
// //pOpening->SetLabel(pOpening->GetAutoLabel());
|
|
// bool bAddNum(true);
|
|
// pOpening->SetLabel(pOpening->GetAutoLabel(bAddNum));
|
|
// }
|
|
// OPENOBJ_END()
|
|
// }
|
|
// return;
|
|
// }
|
|
//
|
|
// xsName3d=_T("");
|
|
// xsName2d=_T("");
|
|
// OPENOBJ_BEGIN(entTmp, AcDb::kForRead, TDbOpening, pOpening);
|
|
// if (pOpening)
|
|
// {
|
|
// opKind = pOpening->GetKind();
|
|
// nWidth = pOpening->GetWidth();
|
|
// nHeight = pOpening->GetHeight();
|
|
// pOpening->GetStyle3dName(xsName3d);
|
|
// pOpening->GetStyle2dName(xsName2d);
|
|
// }
|
|
// OPENOBJ_END();
|
|
// for(long i=0L; i<lCount; i++)
|
|
// {
|
|
// Entity ent = ss[i];
|
|
// OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbOpening, pOpening);
|
|
// if (pOpening)
|
|
// {
|
|
// xsTmp3d=_T("");
|
|
// xsTmp2d=_T("");
|
|
// pOpening->GetStyle3dName(xsTmp3d);
|
|
// pOpening->GetStyle2dName(xsTmp2d);
|
|
// if (pOpening->GetKind() != opKind
|
|
// || xsTmp2d != xsName2d
|
|
// || xsTmp3d != xsName3d
|
|
// || fabs(pOpening->GetWidth() - nWidth) > 0.01
|
|
// || fabs(pOpening->GetHeight() - nHeight) > 0.01)
|
|
// continue;
|
|
// else
|
|
// ssNew += ent;
|
|
// }
|
|
// OPENOBJ_END();
|
|
// }
|
|
//
|
|
// ssNew.Redraw(3);
|
|
// }
|
|
// }
|
|
// else
|
|
// ssNew += ss;
|
|
//
|
|
// if (ssNew.Length() == 0)
|
|
// return;
|
|
//
|
|
// CString csNewName,csPrompt;
|
|
// OPENOBJ_BEGIN(ssNew[0L],AcDb::kForRead,TDbOpening,pOpening)
|
|
// if (pOpening!=NULL)
|
|
// {
|
|
// // modify by xly on 110224 增加bool变量
|
|
// //csNewName=pOpening->GetAutoLabel();
|
|
// bool bAddNum(true);
|
|
// csNewName=pOpening->GetAutoLabel(bAddNum);;
|
|
// }
|
|
// OPENOBJ_END()
|
|
// csPrompt.Format(_T("\n请输入新的门窗编号(删除编号请输入NULL)<%s>:"), csNewName);//modified by whl
|
|
// adsout << (const TCHAR*)csPrompt;
|
|
//
|
|
// if (ads_getstring(0, _T(""), sxLabel)==RTCAN)
|
|
// {
|
|
// ssNew.Redraw(4);
|
|
// return;
|
|
// }
|
|
// if (_tcsicmp(sxLabel, _T("")) == 0)
|
|
// _tcscpy(sxLabel, (const TCHAR*)csNewName);
|
|
// else if (_tcsicmp(sxLabel, _T("NULL")) == 0)
|
|
// _tcscpy(sxLabel, _T(""));
|
|
// for(i=0L; i<lCount; i++)
|
|
// {
|
|
// Entity ent = ssNew[i];
|
|
// XDbObject dbEnt(ent, AcDb::kForWrite);
|
|
// if (!dbEnt) continue;
|
|
// TDbOpening *pOpening = TDbOpening::cast(dbEnt.m_pObject);
|
|
// if (!pOpening)
|
|
// continue;
|
|
// pOpening->assertWriteEnabled();
|
|
// pOpening->SetLabel(sxLabel);
|
|
// }
|
|
// }
|
|
// TArchCmdReactor::ResetAll();
|
|
// }
|
|
|
|
// lgh add 20110304,本ID数组内的数据亮显
|
|
void HighShowIdAry(AcDbObjectIdArray &idAry)
|
|
{
|
|
PickSet ss;
|
|
for (int i = 0; i < (int)idAry.length(); i++)
|
|
ss += idAry[i];
|
|
|
|
ss.Redraw(3);
|
|
}
|
|
|
|
// lgh add 20110304,本ID数组内的数据取消亮显
|
|
void UnHighShowIdAry(AcDbObjectIdArray &idAry)
|
|
{
|
|
PickSet ss;
|
|
for (int i = 0; i < (int)idAry.length(); i++)
|
|
ss += idAry[i];
|
|
|
|
ss.Redraw(4);
|
|
}
|
|
|
|
// lgh add 20110304,是否所有的数据，并且清空
|
|
void ReleaseIdGroup(CArray<AcDbObjectIdArray*, AcDbObjectIdArray*> &aryIdGroup)
|
|
{
|
|
for (int i = 0; i <(int)aryIdGroup.GetSize(); i++)
|
|
{
|
|
delete aryIdGroup[i];
|
|
aryIdGroup[i] = NULL;
|
|
}
|
|
|
|
aryIdGroup.RemoveAll();
|
|
}
|
|
|
|
// lgh add 20110304, 检测两个opening的编号类型是不是相同，需要比较kind和subKind
|
|
bool TestOpeningKind(TDbOpening *pOp1, TDbOpening *pOp2)
|
|
{
|
|
if (pOp1->GetKind() != pOp2->GetKind())
|
|
return false;
|
|
else if (pOp1->GetKind() == TDbOpening::OP_DOOR ||
|
|
pOp1->GetKind() == TDbOpening::OP_WINDOW ||
|
|
pOp1->GetKind() == TDbOpening::OP_ARCWIN)
|
|
return pOp1->GetSubKind().CompareNoCase(pOp2->GetSubKind()) == 0;
|
|
else return true;
|
|
}
|
|
|
|
// lgh add 20110304, 获得门的编号，需要pOp的类型是TDbOpening,TdbCornerWin,TdbBandWin, TDbDormer;
|
|
CString GetOpeningLabel(TDbEntity *pOp)
|
|
{
|
|
if (pOp->isKindOf(TDbOpening::desc()))
|
|
{
|
|
return TDbOpening::cast(pOp)->GetLabel();
|
|
}
|
|
else if (pOp->isKindOf(TDbDormer::desc()))
|
|
{
|
|
return TDbDormer::cast(pOp)->GetLabel();
|
|
}
|
|
else if (pOp->isKindOf(TDbCornerWin::desc()))
|
|
{
|
|
return TDbCornerWin::cast(pOp)->GetLabel();
|
|
}
|
|
else
|
|
return _T("");
|
|
}
|
|
|
|
// lgh add 20110304, 获得门的自动编号，需要pOp的类型是TDbOpening,TdbCornerWin,TdbBandWin, TDbDormer;
|
|
CString GetOpeningAutoLabel(TDbEntity *pOp, bool &bReName)
|
|
{
|
|
if (pOp->isKindOf(TDbOpening::desc()))
|
|
{
|
|
return TDbOpening::cast(pOp)->GetAutoLabel(bReName);
|
|
}
|
|
else if (pOp->isKindOf(TDbDormer::desc()))
|
|
{
|
|
return TDbDormer::cast(pOp)->GetAutoLabel(bReName);
|
|
}
|
|
else if (pOp->isKindOf(TDbCornerWin::desc()))
|
|
{
|
|
return TDbCornerWin::cast(pOp)->GetAutoLabel(bReName);
|
|
}
|
|
else
|
|
return _T("");
|
|
}
|
|
|
|
// lgh add 20110304, 设置门的编号，需要pOp的类型是TDbOpening,TdbCornerWin,TdbBandWin, TDbDormer;
|
|
void SetOpeningLabel(TDbEntity *pOp, CString strName)
|
|
{
|
|
pOp->assertWriteEnabled();
|
|
if (pOp->isKindOf(TDbOpening::desc()))
|
|
{
|
|
TDbOpening::cast(pOp)->SetLabel(strName);
|
|
}
|
|
else if (pOp->isKindOf(TDbDormer::desc()))
|
|
{
|
|
TDbDormer::cast(pOp)->SetLabel(strName);
|
|
}
|
|
else if (pOp->isKindOf(TDbCornerWin::desc()))
|
|
{
|
|
TDbCornerWin::cast(pOp)->SetLabel(strName);
|
|
}
|
|
}
|
|
|
|
// lgh add 20110304, 检测编号类型是否相同，需要pOp的类型是TDbOpening,TdbCornerWin,TdbBandWin, TDbDormer;
|
|
bool TestOpeningKind(TDbEntity *pEnt1, TDbEntity *pEnt2)
|
|
{
|
|
if (pEnt1->isKindOf(TDbOpening::desc()) && pEnt2->isKindOf(TDbOpening::desc()))
|
|
{
|
|
return TestOpeningKind(TDbOpening::cast(pEnt1), TDbOpening::cast(pEnt2));
|
|
}
|
|
else if (pEnt1->isKindOf(TDbBandWin::desc()) && pEnt2->isKindOf(TDbBandWin::desc()))
|
|
return true;
|
|
else if (!pEnt1->isKindOf(TDbBandWin::desc()) && !pEnt2->isKindOf(TDbBandWin::desc()) &&
|
|
pEnt1->isKindOf(TDbCornerWin::desc()) && pEnt2->isKindOf(TDbCornerWin::desc()))
|
|
return true;
|
|
else if (pEnt1->isKindOf(TDbDormer::desc()) && pEnt2->isKindOf(TDbDormer::desc()))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
// lgh add 20110304, 查找，如果没有则返回-1，否则返回id在数组中的位置。
|
|
int FindIdInLst(DList<AcDbObjectId> &idList, const AcDbObjectId &id)
|
|
{
|
|
for (int i = 0; i < (int)idList.Length(); i++)
|
|
{
|
|
if (*(idList[i]) == id)
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
CString GetSequenceHead(CString strlabel);
|
|
// 对门窗执行自动编号。
|
|
void AutoDoorWinLabel(CArray<AcDbObjectIdArray*, AcDbObjectIdArray*> &aryIdGroup)
|
|
{
|
|
// 1、从当前图中读出所有的门窗，
|
|
DList<AcDbObjectId> idList;
|
|
GetEntFromBlockByDxf(idList, _T("TCH_OPENING"));
|
|
GetEntFromBlockByDxf(idList, _T("TCH_CORNER_WINDOW"));
|
|
GetEntFromBlockByDxf(idList, _T("TCH_DORMER"));
|
|
|
|
// 2、从所有门窗中过滤掉aryIdGroup中的门窗
|
|
int i = 0, j = 0;
|
|
for (i = 0; i < (int)aryIdGroup.GetSize(); i++)
|
|
{
|
|
AcDbObjectIdArray *pAry = aryIdGroup[i];
|
|
for (int j = 0; j < (int)pAry->length(); j++)
|
|
{
|
|
if (idList.Length() != 0)
|
|
{
|
|
int nPos = FindIdInLst(idList, (*pAry)[j]);
|
|
if (nPos != -1)
|
|
idList.Remove(nPos);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 3、遍历aryIdGroup从原始数据中找出匹配的编号：并且检索顺序编号的最大值，或者根据尺寸编号。
|
|
for (i = 0; i < (int)aryIdGroup.GetSize(); i++)
|
|
{
|
|
AcDbObjectIdArray *pAry = aryIdGroup[i];
|
|
if (pAry != NULL && pAry->length() != 0)
|
|
{
|
|
AcDbObjectId id = (*pAry)[0]; // 查找跟他相匹配的编号
|
|
|
|
bool bReName = false;
|
|
CString strAutoLabel;
|
|
OPENOBJ_BEGIN(id, AcDb::kForRead, TDbEntity, pEnt)
|
|
{
|
|
if (pEnt == NULL)
|
|
continue;
|
|
|
|
strAutoLabel = GetOpeningAutoLabel(pEnt, bReName);
|
|
CString strHead;
|
|
if (strAutoLabel.IsEmpty())
|
|
strHead = _T("");
|
|
else if (strAutoLabel.Right(1).CompareNoCase(_T("-")) == 0)
|
|
strHead = strAutoLabel.Left(strAutoLabel.GetLength() - 1);
|
|
else
|
|
strHead = strAutoLabel;
|
|
|
|
if (bReName)
|
|
{
|
|
int nBigNum = 1;
|
|
for (j = 0; j < (int)idList.Length(); j++)
|
|
{
|
|
AcDbObjectId idInList = *(idList[j]);
|
|
OPENOBJ_BEGIN(idInList, AcDb::kForRead, TDbEntity, pEntDWG)
|
|
{
|
|
CString sOldLabel = GetOpeningLabel(pEntDWG);
|
|
|
|
if (!CheckDoorWinLabel(sOldLabel))
|
|
continue; // 不是顺序编号不做测试。
|
|
|
|
if (TestOpeningKind(pEnt, pEntDWG))
|
|
{ // 同类型的编号
|
|
// 如果两者匹配，则使用直接使用它的编号。
|
|
if (CanSameLabel(pEntDWG, pEnt))
|
|
{
|
|
strAutoLabel = sOldLabel;
|
|
nBigNum = 0;
|
|
break;
|
|
}
|
|
|
|
// 如果需要重命名，需要提取本类型的最大编号
|
|
int nSeq = GetSequenceNum(sOldLabel) + 1;
|
|
nBigNum = nBigNum > nSeq ? nBigNum : nSeq;
|
|
}
|
|
else
|
|
{ // 不同类型编号的时候，要检测普通门窗的重名编号。（继承自TDBOpening）
|
|
if (pEnt->isKindOf(TDbOpening::desc()) && pEntDWG->isKindOf(TDbOpening::desc()))
|
|
{
|
|
if (GetSequenceHead(sOldLabel).CompareNoCase(strHead) == 0)
|
|
{ // 两编号的前缀相同，
|
|
int nSeq = GetSequenceNum(sOldLabel) + 1;
|
|
nBigNum = nBigNum > nSeq ? nBigNum : nSeq;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
OPENOBJ_END()
|
|
} // end for idlst;
|
|
if (nBigNum > 0)
|
|
strAutoLabel.Format(_T("%s%d"), strAutoLabel, nBigNum);
|
|
}
|
|
}
|
|
OPENOBJ_END()
|
|
|
|
// 执行编号设置，然后把这些东西追加到最后边
|
|
for (j = 0; j < (int)pAry->length(); j++ )
|
|
{
|
|
AcDbObjectId id = (*pAry)[j];
|
|
OPENOBJ_BEGIN(id, AcDb::kForWrite, TDbEntity, pEnt)
|
|
if (pEnt == NULL)
|
|
continue;
|
|
SetOpeningLabel(pEnt, strAutoLabel);
|
|
OPENOBJ_END()
|
|
|
|
// 把这些ID追加到链表中，
|
|
idList.Append(new AcDbObjectId(id));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 获得默认编号，
|
|
//如果当前是尺寸编号，则直接根据洞口尺寸编号。
|
|
// 如果当前是顺序编号，则需要查找当前图中的顺序编号，查找尺寸匹配的编号，否则取本类型和本同前缀（TDbOpening）编号最大的
|
|
CString GetDefaultLabel(CArray<AcDbObjectIdArray*, AcDbObjectIdArray*> &aryIdGroupFilter, AcDbObjectId id)
|
|
{
|
|
// 1、从当前图中读出所有的门窗，
|
|
DList<AcDbObjectId> idList;
|
|
GetEntFromBlockByDxf(idList, _T("TCH_OPENING"));
|
|
GetEntFromBlockByDxf(idList, _T("TCH_CORNER_WINDOW"));
|
|
GetEntFromBlockByDxf(idList, _T("TCH_DORMER"));
|
|
|
|
// 2、从所有门窗中过滤掉aryIdGroup中的门窗
|
|
int i = 0, j = 0;
|
|
for (i = 0; i < (int)aryIdGroupFilter.GetSize(); i++)
|
|
{
|
|
AcDbObjectIdArray *pAry = aryIdGroupFilter[i];
|
|
for (int j = 0; j < (int)pAry->length(); j++)
|
|
{
|
|
if (idList.Length() != 0)
|
|
{
|
|
int nPos = FindIdInLst(idList, (*pAry)[j]);
|
|
if (nPos != -1)
|
|
idList.Remove(nPos);
|
|
}
|
|
}
|
|
}
|
|
|
|
OPENOBJ_BEGIN(id, AcDb::kForRead, TDbEntity, pEnt)
|
|
{
|
|
if (pEnt == NULL)
|
|
return _T("");
|
|
|
|
bool bReLabel;
|
|
CString strAutoLabel = GetOpeningAutoLabel(pEnt, bReLabel);
|
|
CString strHead;
|
|
if (strAutoLabel.IsEmpty())
|
|
strHead = _T("");
|
|
else if (strAutoLabel.Right(1).CompareNoCase(_T("-")) == 0)
|
|
strHead = strAutoLabel.Left(strAutoLabel.GetLength() - 1);
|
|
else
|
|
strHead = strAutoLabel;
|
|
|
|
if (bReLabel)
|
|
{ // 查找按照顺序的同类型编号，并且搜寻最大值
|
|
int nBigNum = 1;
|
|
for (i = 0; i < (int)idList.Length(); i++)
|
|
{
|
|
AcDbObjectId idInList = *(idList[i]);
|
|
OPENOBJ_BEGIN(idInList, AcDb::kForRead, TDbEntity, pEntDWG)
|
|
{
|
|
if (pEntDWG == NULL)
|
|
continue;
|
|
|
|
CString strOldLabel = GetOpeningLabel(pEntDWG);
|
|
if (!CheckDoorWinLabel(strOldLabel))
|
|
continue;
|
|
|
|
if (TestOpeningKind(pEnt, pEntDWG))
|
|
{
|
|
if (CanSameLabel(pEntDWG, pEnt))
|
|
{
|
|
return strOldLabel;
|
|
}
|
|
else
|
|
{
|
|
int nSeq = GetSequenceNum(strOldLabel) + 1;
|
|
nBigNum = nBigNum > nSeq ? nBigNum : nSeq;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (pEnt->isKindOf(TDbOpening::desc()) && pEntDWG->isKindOf(TDbOpening::desc()))
|
|
{
|
|
if (strHead.CompareNoCase(GetSequenceHead(strOldLabel)) == 0)
|
|
{
|
|
int nSeq = GetSequenceNum(strOldLabel) + 1;
|
|
nBigNum = nBigNum > nSeq ? nBigNum : nSeq;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
OPENOBJ_END()
|
|
} // end for idLst;
|
|
|
|
if (nBigNum > 0)
|
|
strAutoLabel.Format(_T("%s%d"), strAutoLabel, nBigNum);
|
|
|
|
return strAutoLabel;
|
|
}
|
|
else
|
|
{
|
|
return strAutoLabel;
|
|
}
|
|
}
|
|
OPENOBJ_END()
|
|
|
|
return _T(""); // 不可能到达
|
|
}
|
|
|
|
void ChWinLab()
|
|
{
|
|
// 8.5版本的门窗编号添加对老虎窗和带形窗以及转角窗的支持
|
|
// sg modify 111018，修改过滤器，选择门窗时，只考虑门窗对象的类型，而不考虑图层
|
|
//RBList mask(RTDXF0, _T("TCH_OPENING,TCH_CORNER_WINDOW,TCH_DORMER"),-4,_T("<OR"),
|
|
// 8,LAY_WIN,8,LAY_DOOR,8,LAY_ROOF,8,LAY_FIRE_DOOR,8,LAY_FIRE_WIN,8,LAY_FIRE_JL,-4,_T("OR>"),NULL);
|
|
RBList mask(RTDXF0, _T("TCH_OPENING,TCH_CORNER_WINDOW,TCH_DORMER"),NULL);
|
|
PickSet ssAll(SS_FREE);
|
|
|
|
if (SelectEntities(_T("\n请选择需要改编号的门窗的范围<退出>:"), ssAll, mask) != RTNORM)
|
|
return; // 其他情况下一律退出。
|
|
|
|
CArray<AcDbObjectIdArray*, AcDbObjectIdArray*> aryIdGroup; // ID分组，归类
|
|
|
|
// 对所有框选的实体执行分组。
|
|
int i = 0;
|
|
for(i = 0; i<(int)ssAll.Length(); i++)
|
|
{
|
|
Entity ent = ssAll[(long)i];
|
|
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbEntity, pOpening1);
|
|
if (pOpening1)
|
|
{
|
|
if (pOpening1->isKindOf(TDbOpening::desc()))
|
|
{
|
|
CString strSubKind = TDbOpening::cast(pOpening1)->GetSubKind();
|
|
if (strSubKind.Compare(_T("隔断门")) == 0 ||
|
|
strSubKind.Compare(_T("电梯门")) == 0)
|
|
continue;// 过滤隔断门和电梯门不执行自动编号。
|
|
|
|
// sg add 110309，过滤隔断门和电梯门
|
|
if ((TDbOpening::cast(pOpening1)->m_nOpStyle&OPS_LVTRY) || ( TDbOpening::cast(pOpening1)->m_nOpStyle&OPS_LIFTDOOR))
|
|
continue;
|
|
}
|
|
bool bAdd = false;
|
|
for (int jGroup = 0; jGroup < (int)aryIdGroup.GetSize(); jGroup++)
|
|
{
|
|
AcDbObjectIdArray *pAry = aryIdGroup[jGroup];
|
|
OPENOBJ_BEGIN((*pAry)[0], AcDb::kForRead, TDbEntity, pOpeningGroup)
|
|
{
|
|
if (CanSameLabel(pOpening1, pOpeningGroup))
|
|
{
|
|
pAry->append(pOpening1->id());
|
|
bAdd = true;
|
|
break;
|
|
}
|
|
}
|
|
OPENOBJ_END()
|
|
}
|
|
if (!bAdd)
|
|
{
|
|
AcDbObjectIdArray *pAryNew = new AcDbObjectIdArray;
|
|
pAryNew->append(pOpening1->id());
|
|
aryIdGroup.Add(pAryNew);
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
PickSet ssNew(SS_FREE);
|
|
while (aryIdGroup.GetSize() > 0) // 具有分组
|
|
{
|
|
int nCurSel = -1; // 所选择的分组。
|
|
if (aryIdGroup.GetSize() > 1)
|
|
{
|
|
Entity entTmp;
|
|
int nRet=RTNORM;
|
|
while(nRet==RTNORM)
|
|
{
|
|
TCHAR cRet;
|
|
nRet=SelectEntity(_T("\n请选择需要修改编号的样板门窗或[自动编号(S)]<退出>:"), entTmp, mask,_T("S"),cRet);
|
|
|
|
if (nRet == RTNORM)
|
|
{ // 正常选择,数据可能为空，
|
|
OPENOBJ_BEGIN(entTmp, AcDb::kForRead, TDbEntity, pSelEnt)
|
|
{
|
|
if (pSelEnt == NULL)
|
|
{
|
|
if (nCurSel > -1 && nCurSel < (int)aryIdGroup.GetSize())
|
|
UnHighShowIdAry(*aryIdGroup[nCurSel]);
|
|
nCurSel = -1; //清空显示
|
|
continue;
|
|
}
|
|
|
|
int nOldSel = nCurSel;
|
|
nCurSel = -1;
|
|
for (int iGroup = 0; iGroup < (int)aryIdGroup.GetSize(); iGroup++)
|
|
{
|
|
if ((*aryIdGroup[iGroup])[0] == pSelEnt->id())
|
|
{
|
|
nCurSel = iGroup;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
OPENOBJ_BEGIN(((*aryIdGroup[iGroup])[0]), AcDb::kForRead, TDbEntity, pGroupEnt)
|
|
{
|
|
if (CanSameLabel(pGroupEnt, pSelEnt))
|
|
{
|
|
nCurSel = iGroup;
|
|
break;
|
|
}
|
|
}
|
|
OPENOBJ_END()
|
|
}
|
|
}
|
|
if (nOldSel > -1 && nOldSel < (int)aryIdGroup.GetSize())
|
|
UnHighShowIdAry(*aryIdGroup[nOldSel]);
|
|
if (nCurSel > -1 && nCurSel < (int)aryIdGroup.GetSize())
|
|
HighShowIdAry(*aryIdGroup[nCurSel]);
|
|
}
|
|
OPENOBJ_END()
|
|
}
|
|
else if (nRet == RTKWORD)
|
|
{ // 自动编号关键字
|
|
// 需要执行自动编号
|
|
AutoDoorWinLabel(aryIdGroup);
|
|
nCurSel = -1;
|
|
TArchCmdReactor::ResetAll();
|
|
}
|
|
else if (nRet == RTCAN)
|
|
{ // 退出命令。
|
|
if (nCurSel > -1 && nCurSel < (int)aryIdGroup.GetSize())
|
|
UnHighShowIdAry(*aryIdGroup[nCurSel]);
|
|
return;
|
|
}
|
|
else
|
|
{ // 如果已经有选择的门窗则开始编号：
|
|
//
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nCurSel = 0;
|
|
HighShowIdAry(*aryIdGroup[nCurSel]);
|
|
}
|
|
|
|
if (nCurSel == -1)
|
|
{
|
|
ReleaseIdGroup(aryIdGroup);
|
|
return; // 退出了。
|
|
}
|
|
|
|
|
|
// 选中了nCurrSel，对他执行编号，当前这一组是亮显的
|
|
AcDbObjectIdArray &aryIdCurrSel = *aryIdGroup[nCurSel];
|
|
// 关于默认编号：
|
|
// 如果是按照尺寸编号，则直接生产尺寸编号。作为默认值。
|
|
// 如果是按照顺序编号，则全局搜索，匹配同尺寸的编号，或者得出当前最大的顺序编号，对该编号执行新的编号
|
|
CString sAutoLabel = GetDefaultLabel(aryIdGroup, aryIdCurrSel[0]);
|
|
CString sPrompt;
|
|
XString sxLabel;
|
|
sPrompt.Format(_T("\n请输入新的门窗编号或[删除编号(E)]<%s>:"), sAutoLabel);
|
|
|
|
int nRet = 0;
|
|
INITGET_BEG(0, _T("E"));
|
|
nRet=ads_getstring(0, sPrompt, sxLabel);
|
|
INITGET_END();
|
|
if (nRet == RTNORM)
|
|
{ // 正常编号，使用用户输入的字符串
|
|
// 使用sxLabel;;
|
|
if (sxLabel == _T(""))
|
|
sxLabel = sAutoLabel;
|
|
else if (sxLabel == _T("E"))
|
|
sxLabel = _T("");
|
|
}
|
|
else if (nRet == RTKWORD)
|
|
{ // 按下了关键字，使用空编号
|
|
sxLabel = _T("");
|
|
}
|
|
else if (nRet == RTNONE)
|
|
{ // 空，使用默认编号
|
|
sxLabel = sAutoLabel;
|
|
}
|
|
else
|
|
{ // 相当于取消处理
|
|
// 退出程序。
|
|
UnHighShowIdAry(aryIdCurrSel);
|
|
ReleaseIdGroup(aryIdGroup);
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < (int)aryIdCurrSel.length(); i++)
|
|
{
|
|
OPENOBJ_BEGIN(aryIdCurrSel[i], AcDb::kForWrite, TDbEntity, pEnt)
|
|
{
|
|
if (pEnt == NULL)
|
|
continue;
|
|
pEnt->assertWriteEnabled();
|
|
if (pEnt->isKindOf(TDbOpening::desc()))
|
|
TDbOpening::cast(pEnt)->SetLabel(sxLabel);
|
|
else if (pEnt->isKindOf(TDbCornerWin::desc()))
|
|
TDbCornerWin::cast(pEnt)->SetLabel(sxLabel);
|
|
else if (pEnt->isKindOf(TDbDormer::desc()))
|
|
TDbDormer::cast(pEnt)->SetLabel(sxLabel);
|
|
}
|
|
OPENOBJ_END()
|
|
}
|
|
|
|
UnHighShowIdAry(aryIdCurrSel);
|
|
delete aryIdGroup[nCurSel];
|
|
aryIdGroup.RemoveAt(nCurSel);
|
|
|
|
TArchCmdReactor::ResetAll();
|
|
}
|
|
|
|
ReleaseIdGroup(aryIdGroup);
|
|
}
|
|
|
|
////////////////////////////////////////////////
|
|
// Command: 改门窗宽度
|
|
// 必须在WCS下
|
|
void ChangeOpeningWidth()
|
|
{
|
|
//AsureWCS();
|
|
RBList mask(RTDXF0, _T("TCH_OPENING"), NULL);
|
|
PickSet ss(SS_FREE);
|
|
|
|
if (SelectEntities(_T("\n请选择门窗: "), ss, mask)==RTNORM) {
|
|
//取缺省宽度
|
|
Entity entFirst=ss[0L];
|
|
double nNewWidth=2100;
|
|
OPENOBJ_BEGIN(entFirst, AcDb::kForRead, TDbOpening, pOpening);
|
|
if (!pOpening) return;
|
|
nNewWidth=pOpening->GetWidth();
|
|
OPENOBJ_END();
|
|
|
|
if (GetReal(_T("\n新的宽度"), nNewWidth, RSG_NONEG|RSG_NOZERO)==RTCAN)
|
|
return;
|
|
long lCount = ss.Length();
|
|
for(long i=0L; i<lCount; i++) {
|
|
Entity ent = ss[i];
|
|
OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbOpening, pOpening);
|
|
if (pOpening) {
|
|
pOpening->assertWriteEnabled();
|
|
pOpening->SetWidth(nNewWidth);
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////
|
|
// Command: 互换窗和高窗, V1.1--Now Canceled
|
|
// 必须在WCS下
|
|
void ChHWin()
|
|
{
|
|
RBList mask(RTDXF0, _T("TCH_OPENING"), NULL);
|
|
PickSet ss(SS_FREE);
|
|
if (SelectEntities(_T("\n请选择窗:"), ss, mask)==RTNORM) {
|
|
long lCount = ss.Length();
|
|
for(long i=0L; i<lCount; i++) {
|
|
Entity ent = ss[i];
|
|
OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbOpening, pOpening);
|
|
if (!pOpening) continue;
|
|
pOpening->assertWriteEnabled();
|
|
if (pOpening->IsHigh()) {
|
|
pOpening->m_nOpStyle &= ~OPS_ATHIGH;
|
|
//pOpening->setLinetype(_T("CONTINUOUS"));
|
|
} else {
|
|
pOpening->m_nOpStyle |= OPS_ATHIGH;
|
|
//pOpening->setLinetype(_T("DASHED"));
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Command: 插入任意洞 V2.0
|
|
void PolyHole()
|
|
{
|
|
//AsureWCS();
|
|
RBList mask(RTDXF0, _T("POLYLINE,LWPOLYLINE"), 70, 1, NULL);
|
|
Entity entWall;
|
|
XPoint ptOnSide;
|
|
double nDrt=0;
|
|
if (SelectWallSide(entWall, ptOnSide, &nDrt)!=RTNORM)
|
|
return;
|
|
|
|
Entity entPline;
|
|
g_ssPickFirst.Free();
|
|
if (entPline.FilterSelect(_T("\n选择墙面上洞口轮廓线的封闭多段线: "), mask)!=RTNORM)
|
|
return;
|
|
|
|
OPENOBJ_BEGIN(entWall, AcDb::kForRead, TDbWall, pWall);
|
|
if (!pWall)
|
|
return;
|
|
if (pWall->Is(CURVE_ARC)) {
|
|
adsout << _T("\n弧墙上不能开任意形状的洞口!");
|
|
return;
|
|
}
|
|
nDrt = pWall->Direction(ptOnSide); //Modify here by ZJQ
|
|
|
|
XPoly2D poly0(entPline);
|
|
if (!poly0 || !poly0.IsClosed() || (poly0.GetFlag() & 0x08)) {
|
|
adsout << _T("\n无效的轮廓线!");
|
|
return;
|
|
}
|
|
CAcModuleResourceOverride vTemp;
|
|
CPolyHoleDlg dlg(acedGetAcadFrame());
|
|
if (dlg.DoModal()!=IDOK)
|
|
return;
|
|
/*
|
|
double nDepth = pWall->GetWidth();
|
|
if (GetDist(_T("\n洞深"), nDepth, RSG_NOZERO|RSG_NONEG)==RTCAN)
|
|
return;
|
|
static nAns=Q_YES;
|
|
nAns = YesNoQuestion(_T("\n是否在视线上方"), nAns);
|
|
if (nAns==RTCAN)
|
|
return;
|
|
*/
|
|
|
|
//确定插入点和门窗的参数
|
|
XPoint ptCen, ptLow, ptUp;
|
|
double nWidth, nHeight;
|
|
poly0.GetExtend(ptLow, ptUp);
|
|
Midpoint(ptLow, ptUp, ptCen);
|
|
nWidth=ptUp.x-ptLow.x;
|
|
nHeight=ptUp.y-ptLow.y;
|
|
|
|
XPoint ptLoc=ptCen;
|
|
ads_trans(ptCen, (resbuf *)&Groups(entPline.name), (resbuf *)&Groups(0), 0, ptLoc);
|
|
ptLoc.z -= nHeight/2.0;
|
|
|
|
OPENOBJ_BEGIN(entPline, AcDb::kForWrite, AcDbPolyline, pOutline);
|
|
if (pOutline) {
|
|
ads_matrix mat;
|
|
ptLoc.GetRotationMatrix(-nDrt, mat);
|
|
VERIFY(pOutline->transformBy(AsAcGeMatrix3d(mat))==Acad::eOk);
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
PickSet ss(SS_FREE);
|
|
ss += entPline;
|
|
TCHAR szAnonymous[256]=_T("*U");
|
|
if (ss.MakeAnonymous(ptLoc, szAnonymous, FALSE)!=RTNORM) {
|
|
//entPline.SetData(210, &vtOld);
|
|
//entPline.Modify();
|
|
return;
|
|
}
|
|
|
|
// Restore
|
|
//ss.Delete(); //Undelete
|
|
//entPline.SetData(210, &vtOld);
|
|
//entPline.Modify();
|
|
|
|
XDbBlockTableRec rec(szAnonymous, AcDb::kForWrite);
|
|
//遍历块表记录,寻找轮廓的POLYLINE
|
|
AcDbBlockTableRecordIterator* pBlockIterator=NULL;
|
|
VERIFY(rec.m_pBlockTableRec->newIterator(pBlockIterator)==Acad::eOk && pBlockIterator);
|
|
XString sOutlineEntHandle;
|
|
for (pBlockIterator->start(); !pBlockIterator->done(); pBlockIterator->step()) {
|
|
AcDbEntity *pEntity;
|
|
VERIFY(pBlockIterator->getEntity(pEntity, AcDb::kForWrite, Adesk::kTrue)==Acad::eOk);
|
|
ASSERT(pEntity->isKindOf(AcDbPolyline::desc()) ||
|
|
pEntity->isKindOf(AcDb2dPolyline::desc()));
|
|
pEntity->setLayer(LAY_BOUNDARY);
|
|
AcDbHandle entHandle;
|
|
pEntity->getAcDbHandle(entHandle);
|
|
#if (ADS > 19)
|
|
entHandle.getIntoAsciiBuffer(sOutlineEntHandle, 1024);
|
|
#else
|
|
entHandle.getIntoAsciiBuffer(sOutlineEntHandle);
|
|
#endif
|
|
pEntity->close();
|
|
break;
|
|
}
|
|
delete pBlockIterator;
|
|
|
|
resbuf *pXData=ads_buildlist(1001, TCHXD, 1040,
|
|
nWidth, 1040, nHeight, 1005, (TCHAR *)sOutlineEntHandle, NULL);
|
|
if (!XSymbolTable(_T("APPID"), TCHXD))
|
|
ads_regapp(TCHXD);
|
|
VERIFY(rec.m_pBlockTableRec->setXData(pXData)==Acad::eOk);
|
|
ads_relrb(pXData);
|
|
AcDbObjectId idStyle3d=rec.m_pBlockTableRec->objectId();
|
|
rec.Close();
|
|
|
|
|
|
|
|
XPoint ptLoc1;
|
|
if (!pWall->GetOpeningLocation(ptLoc, TOpeningData::OP_HOLE, nWidth, ptLoc1)) { //投影到墙心上
|
|
adsout << _T("\n插入后, 该墙上的门窗将发生干涉! 拒绝插入!");
|
|
return;;
|
|
}
|
|
|
|
ptLoc1.z=ptLoc.z;
|
|
TDbOpening *pWin = new TDbOpening(pWall->objectId(), AcDbObjectId::kNull, idStyle3d);
|
|
pWin->SetKind(TOpeningData::OP_HOLE);
|
|
pWin->SetWidth(nWidth);
|
|
pWin->SetHeight(nHeight);
|
|
//pWin->SetThickness(nDepth);
|
|
|
|
// add by xly on 110125 设置门窗对象的转角布局
|
|
pWin->SetLayoutRotation(Ucs2Wcs(0));
|
|
|
|
pWin->m_nOpStyle |= OPS_POLY_HOLE;
|
|
pWin->m_ptLocation = ptLoc1;
|
|
dlg.Dlg2Obj(*pWin);
|
|
pWin->SetLabel(dlg.GetLabel(pWin));
|
|
dlg.AfterModelAdded(pWin);
|
|
//if (nAns==Q_YES)
|
|
// pWin->m_nOpStyle |= OPS_ATHIGH;
|
|
//if (nDepth<pWall->GetWidth()-_DIST_SNAP) {
|
|
// pWin->m_nOpStyle |= OPS_NOT_BORE;
|
|
if (!dlg.m_bBoreHole) {
|
|
XCurveSegment segCen=pWall->OffsetGeomCenter();
|
|
int nSide=segCen.OnWhichSide(ptOnSide);
|
|
pWin->m_nQuadrant = nSide==OFFSET_LEFT? 0:3; //Modify here by ZJQ
|
|
}
|
|
if (!pWall->CanInsertOpening(*pWin)) {
|
|
delete pWin;
|
|
return;
|
|
}
|
|
VERIFY(pWall->upgradeOpen()==Acad::eOk);
|
|
//pWin->setLinetype(_T(_T("DASH")));
|
|
pWin->InitHardPointerId();
|
|
pWin->AddToMSpace(Adesk::kFalse);
|
|
pWall->InsertOpening(pWin);
|
|
pWin->close();
|
|
VERIFY(pWall->downgradeOpen()==Acad::eOk);
|
|
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////
|
|
//// Command: 制作门窗套
|
|
//// 必须在WCS下
|
|
//void OpSlot()
|
|
//{
|
|
// //AsureWCS();
|
|
// PickSet ssOpening(SS_FREE);
|
|
// RBList mask(RTDXF0, _T(_T("TCH_OPENING")), NULL);
|
|
// if (SelectEntities(/*UMSG*/_T(_T("\n请选择外墙上的门窗: ")), ssOpening, mask)==RTNORM) {
|
|
// static double h=200; //出墙长度
|
|
// static double d=200; //门窗套宽度
|
|
// if (GetReal(/*UMSG*/_T(_T("\n伸出墙的长度")), h, RSG_NONEG|RSG_NOZERO)==RTCAN ||
|
|
// GetReal(/*UMSG*/_T(_T("\n门窗套宽度")), d, RSG_NONEG|RSG_NOZERO)==RTCAN)
|
|
// return;
|
|
//
|
|
// long lCount=ssOpening.Length();
|
|
// for(long idx=0L; idx<lCount; idx++) {
|
|
// Entity entOpening=ssOpening[idx];
|
|
// XDbObject obj(entOpening, AcDb::kForRead);
|
|
// if (!obj)
|
|
// continue;
|
|
// TDbOpening *pOpening=TDbOpening::cast(obj.m_pObject);
|
|
// if (!pOpening)
|
|
// continue;
|
|
// AcDbObjectId idWall=pOpening->GetWallId();
|
|
// if (!idWall) {
|
|
// adsout << /*UMSG*/_T(_T("\n门窗没有在墙体内! "));
|
|
// continue;
|
|
// }
|
|
// XDbObject objWall(idWall, AcDb::kForRead);
|
|
// TDbWall *pWall=TDbWall::cast(objWall.m_pObject);
|
|
// ASSERT(pWall);
|
|
// if (!pWall->IsExternal(OFFSET_LEFT) && !pWall->IsExternal(OFFSET_RIGHT)) {
|
|
// XPoint ptBase=pOpening->m_ptLocation;
|
|
// XPoint ptBaseUcs=Wcs2Ucs(ptBase);
|
|
// XPoint ptSide;
|
|
// if (ads_getpoint(ptBaseUcs, _T(_T("\n点取窗套所在的一侧:")), ptSide)!=RTNORM)
|
|
// continue;
|
|
// ptSide=Ucs2Wcs(ptSide);
|
|
// XCurveSegment cvTemp=pWall->OffsetGeomCenter();
|
|
// int nSide=cvTemp.OnWhichSide(ptSide);
|
|
// int nFlag=pWall->GetWallFlag();
|
|
// //nFlag |= WF_EXTERNAL;
|
|
// if (nSide==OFFSET_LEFT) {
|
|
// nFlag |= WF_LEFTEXT;
|
|
// } else {
|
|
// nFlag &= ~WF_LEFTEXT;
|
|
// }
|
|
// if (pWall->upgradeOpen()==Acad::eOk) {
|
|
// pWall->assertWriteEnabled();
|
|
// pWall->SetWallFlag(nFlag);
|
|
// pWall->downgradeOpen();
|
|
// }
|
|
// }
|
|
// objWall.Close();
|
|
// if (pOpening->GetKind()==TOpeningData::OP_CORNWIN) {
|
|
// adsout << _T(_T("\n不能在转角窗上加门窗套!"));
|
|
// continue;
|
|
// }
|
|
// if (pOpening->upgradeOpen()==Acad::eOk) {
|
|
// pOpening->assertWriteEnabled();
|
|
// pOpening->SetSlot(h, d,rand()%2+1);
|
|
// pOpening->downgradeOpen();
|
|
// }
|
|
// }
|
|
// }
|
|
//}
|
|
|
|
|
|
|
|
// Add by lcf on 20050725
|
|
// command:门窗套
|
|
class COpSlotDlg : public CModelessDialog
|
|
{
|
|
public:
|
|
// modify by xly on 110110
|
|
/*COpSlotDlg(CWnd* pParent = NULL): CModelessDialog(COpSlotDlg::ID1, pParent)
|
|
, m_nAdd(0), m_dLength(200), m_dWidth(200){}*/
|
|
COpSlotDlg(CWnd* pParent = NULL);
|
|
|
|
//enum { IDD = IDD_DIALOG_OPSLOT, ID1 = IDD_DIALOG_OPSLOT1 };
|
|
enum { IDD = IDD_DIALOG_OPSLOT};
|
|
|
|
/*BOOL m_nAdd;
|
|
double m_dLength;
|
|
double m_dWidth;*/
|
|
static BOOL m_bAdd;
|
|
static double m_dLength;
|
|
static double m_dWidth;
|
|
|
|
// add by xly on 110110
|
|
static CString m_csMateral; // 记录材料
|
|
CImageDC m_imgPreview; // 幻灯片预览的DC
|
|
|
|
public:
|
|
// 获得门窗套材料的字符串
|
|
CString GetMateral();
|
|
// 获得门窗套材料的索引号，用于设置数据
|
|
int GetMateralIndex(AcDbObjectId idWall);
|
|
|
|
protected:
|
|
virtual void DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CModelessDialog::DoDataExchange(pDX);
|
|
DDX_Radio(pDX, IDC_RADIO_ADD, m_bAdd);
|
|
DDX_Text(pDX, IDC_EDIT_LENGTH, m_dLength);
|
|
DDX_Text(pDX, IDC_EDIT_WIDTH, m_dWidth);
|
|
DDX_CBString(pDX, IDC_COMBO_MATERIAL, m_csMateral);// add by xly 材料控件
|
|
}
|
|
|
|
virtual void OnOK()
|
|
{
|
|
UpdateData();
|
|
CModelessDialog::OnOK();
|
|
m_bAdd=0;
|
|
}
|
|
|
|
virtual void OnCancel()
|
|
{
|
|
UpdateData();
|
|
CModelessDialog::OnOK();
|
|
m_bAdd=1;
|
|
}
|
|
|
|
// 设置幻灯片显示
|
|
void SetPicture();
|
|
|
|
// add by xly on 110110
|
|
virtual BOOL OnInitDialog();
|
|
afx_msg void OnBnClickedAdd();
|
|
afx_msg void OnBnClickedDel();
|
|
afx_msg void OnSelMateral();
|
|
afx_msg void OnPaint();
|
|
DECLARE_MESSAGE_MAP()
|
|
};
|
|
|
|
|
|
// add by xly on 110110 增加静态变量的初始化
|
|
CString COpSlotDlg::m_csMateral = _T("同相邻墙体");
|
|
BOOL COpSlotDlg::m_bAdd = 0;
|
|
double COpSlotDlg::m_dLength = 200;
|
|
double COpSlotDlg::m_dWidth = 200;
|
|
|
|
BEGIN_MESSAGE_MAP(COpSlotDlg, CModelessDialog)
|
|
//{{AFX_MSG_MAP(CModelessDialog)
|
|
ON_BN_CLICKED(IDC_RADIO_ADD, OnBnClickedAdd)// 加门窗套
|
|
ON_BN_CLICKED(IDC_RADIO_DEL, OnBnClickedDel)// 消门窗套
|
|
ON_CBN_SELCHANGE(IDC_COMBO_MATERIAL, OnSelMateral)
|
|
ON_WM_PAINT()
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
COpSlotDlg::COpSlotDlg(CWnd* pParent /*=NULL*/)
|
|
: CModelessDialog(COpSlotDlg::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(COpSlotDlg)
|
|
//}}AFX_DATA_INIT
|
|
}
|
|
|
|
BOOL COpSlotDlg::OnInitDialog()
|
|
{
|
|
CModelessDialog::OnInitDialog();
|
|
|
|
if (m_bAdd)// 消门窗套
|
|
{
|
|
GetDlgItem(IDC_EDIT_LENGTH)->EnableWindow(FALSE);
|
|
GetDlgItem(IDC_EDIT_WIDTH)->EnableWindow(FALSE);
|
|
GetDlgItem(IDC_COMBO_MATERIAL)->EnableWindow(FALSE);
|
|
}
|
|
else
|
|
{
|
|
GetDlgItem(IDC_EDIT_LENGTH)->EnableWindow(TRUE);
|
|
GetDlgItem(IDC_EDIT_WIDTH)->EnableWindow(TRUE);
|
|
GetDlgItem(IDC_COMBO_MATERIAL)->EnableWindow(TRUE);
|
|
}
|
|
|
|
// 设置幻灯片
|
|
SetPicture();
|
|
|
|
// 控件提示工具
|
|
AddTip(IDC_STC_MATERAL, _T("采用保温材料的门窗套只有在墙体对应侧有保温时才可显示。"));
|
|
|
|
UpdateData(FALSE);
|
|
return TRUE;
|
|
}
|
|
|
|
// add by xly on 110110 点击“加门窗套”
|
|
void COpSlotDlg::OnBnClickedAdd()
|
|
{
|
|
UpdateData(TRUE);
|
|
GetDlgItem(IDC_EDIT_LENGTH)->EnableWindow(TRUE);
|
|
GetDlgItem(IDC_EDIT_WIDTH)->EnableWindow(TRUE);
|
|
GetDlgItem(IDC_COMBO_MATERIAL)->EnableWindow(TRUE);
|
|
UpdateData(FALSE);
|
|
}
|
|
|
|
// add by xly on 110110 点击“消门窗套”
|
|
void COpSlotDlg::OnBnClickedDel()
|
|
{
|
|
UpdateData(TRUE);
|
|
GetDlgItem(IDC_EDIT_LENGTH)->EnableWindow(FALSE);
|
|
GetDlgItem(IDC_EDIT_WIDTH)->EnableWindow(FALSE);
|
|
GetDlgItem(IDC_COMBO_MATERIAL)->EnableWindow(FALSE);
|
|
UpdateData(FALSE);
|
|
}
|
|
|
|
// 改变材料
|
|
void COpSlotDlg::OnSelMateral()
|
|
{
|
|
UpdateData(TRUE);
|
|
|
|
SetPicture();
|
|
UpdateData(FALSE);
|
|
}
|
|
|
|
// 设置幻灯片显示
|
|
void COpSlotDlg::SetPicture()
|
|
{
|
|
XString sFilePath(256);
|
|
|
|
CString csStyle = GetMateral();
|
|
if (csStyle==_T("同相邻墙体"))
|
|
{
|
|
sFilePath << _T("TArch(windset01)");
|
|
}
|
|
else if (csStyle==_T("钢筋混凝土"))
|
|
{
|
|
sFilePath << _T("TArch(windset02)");
|
|
}
|
|
else if (csStyle==_T("轻质材料"))
|
|
{
|
|
sFilePath << _T("TArch(windset03)");
|
|
}
|
|
else if (csStyle==_T("保温材料"))
|
|
{
|
|
sFilePath << _T("TArch(windset04)");
|
|
}
|
|
|
|
// 获得图片控件
|
|
CWnd* pWndBmp = GetDlgItem(IDC_PICTURE_OPSLOT);
|
|
ASSERT(pWndBmp);
|
|
|
|
// 获得图片区域
|
|
CDC *pDC = pWndBmp->GetDC();
|
|
CRect rect;
|
|
pWndBmp->GetClientRect(rect);
|
|
|
|
m_imgPreview.InitDC(pDC, rect, GetAcadBackColor());
|
|
m_imgPreview.PaintSlide(sFilePath);
|
|
m_imgPreview.SetDC(NULL);
|
|
pWndBmp->ReleaseDC(pDC);
|
|
}
|
|
|
|
// 窗口重绘消息
|
|
void COpSlotDlg::OnPaint()
|
|
{
|
|
CPaintDC dc(this);
|
|
CRect rcClip, rcImage;
|
|
dc.GetClipBox(&rcClip);
|
|
|
|
CWnd *pImageBox = GetDlgItem(IDC_PICTURE_OPSLOT);
|
|
if (pImageBox)
|
|
{
|
|
pImageBox->GetWindowRect(&rcImage);
|
|
ScreenToClient(&rcImage);
|
|
if (!rcImage.IntersectRect(&rcImage, &rcClip))
|
|
return;
|
|
|
|
CDC *pDC = pImageBox->GetDC();
|
|
m_imgPreview.SetDC(pDC);
|
|
m_imgPreview.Redraw();
|
|
m_imgPreview.SetDC(NULL);
|
|
pImageBox->ReleaseDC(pDC);
|
|
}
|
|
}
|
|
|
|
// 获得墙体材料
|
|
CString COpSlotDlg::GetMateral()
|
|
{
|
|
UpdateData(TRUE);
|
|
return m_csMateral;
|
|
}
|
|
|
|
// 获得门窗套材料的索引号，用于设置数据
|
|
int COpSlotDlg::GetMateralIndex(AcDbObjectId idWall)
|
|
{
|
|
if (m_csMateral == _T("同相邻墙体"))
|
|
{
|
|
return 0;
|
|
}
|
|
else if (m_csMateral == _T("钢筋混凝土"))
|
|
{
|
|
OPENOBJ_BEGIN(idWall, AcDb::kForRead, TDbWall, pWall);
|
|
if (pWall != NULL)
|
|
{
|
|
if (pWall->GetStyle() == TDbWall::kConcrete) // 判断相邻墙体如果也是“钢筋混凝土”，则按照“同相邻墙体”处理
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
return 1;
|
|
}
|
|
else if (m_csMateral == _T("轻质材料"))
|
|
{
|
|
return 2;
|
|
}
|
|
|
|
return 3;
|
|
}
|
|
|
|
void OpSlot()
|
|
{
|
|
// delete by xly on 110110
|
|
/*static double h = 200;
|
|
static double d = 200;
|
|
static BOOL bAdd= 0;*/
|
|
CAcModuleResourceOverride vTemp;
|
|
COpSlotDlg dlg(acedGetAcadFrame());
|
|
|
|
//delete by xly on 110110
|
|
/*dlg.m_dLength = h;
|
|
dlg.m_dWidth = d;
|
|
dlg.m_nAdd=bAdd;*/
|
|
RBList mask(RTDXF0, _T("TCH_OPENING"), NULL);
|
|
PickSet ss(SS_FREE);
|
|
ss = g_ssPickFirst;
|
|
ss.BaseFilter(mask);
|
|
|
|
// modify by xly on 110110不管右键命令和屏幕菜单命令一致
|
|
/*if (ss.Length() > 0)
|
|
{
|
|
if (dlg.DoModal() != IDOK)
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if ( !dlg.Create(dlg.IDD, acedGetAcadFrame()) )
|
|
return;
|
|
dlg.ShowWindow(SW_SHOW);
|
|
acedGetAcadDwgView()->SetFocus();
|
|
if (SelectEntities(_T("\n请选择外墙上的门窗: "), ss, mask)!=RTNORM)
|
|
{
|
|
dlg.DestroyWindow();
|
|
return;
|
|
}
|
|
dlg.UpdateData();
|
|
}*/
|
|
|
|
if ( !dlg.Create(dlg.IDD, acedGetAcadFrame()) )
|
|
return;
|
|
|
|
dlg.ShowWindow(SW_SHOW);
|
|
acedGetAcadDwgView()->SetFocus();
|
|
if (SelectEntities(_T("\n请选择外墙上的门窗: "), ss, mask)!=RTNORM)
|
|
{
|
|
dlg.UpdateData();
|
|
dlg.DestroyWindow();
|
|
return;
|
|
}
|
|
dlg.UpdateData();
|
|
|
|
double h(0.0),
|
|
d(0.0);
|
|
int nAdd = dlg.m_bAdd;
|
|
h = dlg.m_dLength;
|
|
d = dlg.m_dWidth;
|
|
dlg.DestroyWindow();
|
|
|
|
if (nAdd == 0) // 添加
|
|
{
|
|
AcDbObjectId eId;
|
|
long lCount=ss.Length();
|
|
for(long idx=0L; idx<lCount; idx++)
|
|
{
|
|
Entity entOpening=ss[idx];
|
|
XDbObject obj(entOpening, AcDb::kForRead);
|
|
if (!obj)
|
|
continue;
|
|
|
|
TDbOpening *pOpening = TDbOpening::cast(obj.m_pObject);
|
|
if (!pOpening)
|
|
continue;
|
|
|
|
AcDbObjectId idWall = pOpening->GetWallId();
|
|
if (!idWall)
|
|
{
|
|
adsout << /*UMSG*/_T("\n门窗没有在墙体内! ");
|
|
continue;
|
|
}
|
|
|
|
if (eId != idWall)
|
|
{
|
|
eId = idWall;
|
|
XDbObject objWall(idWall, AcDb::kForRead);
|
|
TDbWall *pWall=TDbWall::cast(objWall.m_pObject);
|
|
// sg modify 110215，减少不必要的崩溃
|
|
// ASSERT(pWall);
|
|
if (pWall == NULL)
|
|
continue;
|
|
|
|
if (!pWall->IsExternal(OFFSET_LEFT) && !pWall->IsExternal(OFFSET_RIGHT))
|
|
{
|
|
XPoint ptBase = pOpening->m_ptLocation;
|
|
XPoint ptBaseUcs = Wcs2Ucs(ptBase);
|
|
XPoint ptSide;
|
|
if (ads_getpoint(ptBaseUcs, _T("\n点取窗套所在的一侧:"), ptSide)!=RTNORM)
|
|
return;
|
|
ptSide = Ucs2Wcs(ptSide);
|
|
|
|
XCurveSegment cvTemp = pWall->OffsetGeomCenter();
|
|
int nSide = cvTemp.OnWhichSide(ptSide);
|
|
int nFlag = pWall->GetWallFlag();
|
|
//nFlag |= WF_EXTERNAL;
|
|
if (nSide==OFFSET_LEFT)
|
|
{
|
|
nFlag |= WF_LEFTEXT;
|
|
}
|
|
else
|
|
{
|
|
nFlag &= ~WF_LEFTEXT;
|
|
}
|
|
|
|
if (pWall->upgradeOpen()==Acad::eOk)
|
|
{
|
|
pWall->assertWriteEnabled();
|
|
pWall->SetWallFlag(nFlag);
|
|
pWall->downgradeOpen();
|
|
}
|
|
}
|
|
objWall.Close();
|
|
}
|
|
|
|
if (pOpening->GetKind() == TOpeningData::OP_CORNWIN)
|
|
{
|
|
adsout << _T("\n不能在转角窗上加门窗套!");
|
|
continue;
|
|
}
|
|
|
|
if (pOpening->upgradeOpen() == Acad::eOk)
|
|
{
|
|
pOpening->assertWriteEnabled();
|
|
pOpening->SetSlot(h, d);
|
|
pOpening->SetSlotMaterial(dlg.GetMateralIndex(idWall)); // sg add 110215，增加门窗套材料的设置
|
|
|
|
extern TARCH_IMPEXP double g_dSlotInsulateThick;
|
|
extern TARCH_IMPEXP BOOL g_bSlotInsulateCap;
|
|
pOpening->SetSlotInsulateThick(g_dSlotInsulateThick); // 设置门窗套默认保温厚
|
|
pOpening->SetSlotInsulateCap(g_bSlotInsulateCap); // 设置门窗套保温是否封口
|
|
pOpening->downgradeOpen();
|
|
}
|
|
}
|
|
}
|
|
else // 删除
|
|
{
|
|
long lCount = ss.Length();
|
|
for (long i=0L; i<lCount; i++)
|
|
{
|
|
Entity entOpening=ss[i];
|
|
XDbObject obj(entOpening, AcDb::kForWrite);
|
|
if (!obj)
|
|
return;
|
|
|
|
TDbOpening *pOpening=TDbOpening::cast(obj.m_pObject);
|
|
if (!pOpening)
|
|
return;
|
|
|
|
pOpening->assertWriteEnabled();
|
|
pOpening->RemoveSlot();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////////////////////
|
|
// Command: 取消门窗套
|
|
void DelOpSlot()
|
|
{
|
|
PickSet ss(SS_FREE);
|
|
RBList mask(RTDXF0, _T("TCH_OPENING"), NULL);
|
|
if (SelectEntities(/*UMSG*/_T("\n请选择门窗: "), ss, mask)==RTNORM) {
|
|
long lCount=ss.Length();
|
|
for(long i=0L; i<lCount; i++) {
|
|
Entity entOpening=ss[i];
|
|
XDbObject obj(entOpening, AcDb::kForWrite);
|
|
if (!obj)
|
|
return;
|
|
TDbOpening *pOpening=TDbOpening::cast(obj.m_pObject);
|
|
if (!pOpening)
|
|
return;
|
|
pOpening->assertWriteEnabled();
|
|
pOpening->RemoveSlot();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/////////////////////////////////////
|
|
// Command: 复制上层门窗
|
|
void DupHLOpening()
|
|
{
|
|
PickSet ss(SS_FREE);
|
|
RBList mask(RTDXF0, _T("TCH_OPENING"), NULL);
|
|
adsout << _T("\n请选择门窗和洞!");
|
|
if (ss.Get(NULL, NULL, NULL, mask)!=RTNORM)
|
|
return;
|
|
static double nDist=3000;
|
|
if (GetDist(_T("\n上下层的门窗下缘间距"), nDist, RSG_NONEG|RSG_NOZERO)==RTCAN)
|
|
return;
|
|
int nLevelNum=1;
|
|
ads_initget(RSG_NOZERO|RSG_NONEG, NULL);
|
|
adsout << _T("\n复制的层数<") << nLevelNum << _T(">: ");
|
|
if (ads_getint(_T(""), &nLevelNum)==RTCAN)
|
|
return;
|
|
|
|
long lCount=ss.Length();
|
|
for(long i=0L; i<lCount; i++) {
|
|
Entity ent=ss[i];
|
|
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbOpening, pOpening);
|
|
if (pOpening) {
|
|
AcDbObjectId idWall=pOpening->GetWallId();
|
|
if (idWall) {
|
|
OPENOBJ_BEGIN(idWall, AcDb::kForWrite, TDbWall, pWall);
|
|
if (pWall) {
|
|
for(int j=0; j<nLevelNum; j++) {
|
|
TDbOpening *pClone=TDbOpening::cast(pOpening->clone());
|
|
ASSERT(pClone);
|
|
pClone->SetWallId(idWall);
|
|
pClone->m_ptLocation.z += nDist*(j+1);
|
|
pClone->m_nOpStyle |= OPS_HIGH_LEVEL;
|
|
pClone->AddToMSpace(Adesk::kFalse);
|
|
pWall->assertWriteEnabled();
|
|
pWall->AddOpeningId(pClone->objectId());
|
|
pClone->close();
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
TArchCmdReactor::ResetAll();
|
|
}
|
|
|
|
/////////////////////////////////////////
|
|
int EditOpeningInNewDlg(AcDbObjectId id, CString sCmd)
|
|
{
|
|
//return RTERROR; //wlw 2014版使用
|
|
//wlw mod 新建筑双击出新对话框 2013.5.7
|
|
return RTERROR;
|
|
}
|
|
|
|
//lgd 使用新界面编辑门窗
|
|
int EditOpening(AcDbObjectId idOpening)
|
|
{
|
|
OPENOBJ_BEGIN(idOpening, AcDb::kForWrite, TDbOpening, pOpening);
|
|
if (!pOpening) return 0;
|
|
OPENOBJ_END()
|
|
OPENOBJ_BEGIN(idOpening, AcDb::kForRead, TDbOpening, pOpening);
|
|
if (!pOpening) return 0;
|
|
TOpeningData::OpeningKind opKind=pOpening->GetKind();
|
|
|
|
//lgd 140213 门、窗、门联窗、子母门的双击编辑使用新界面打开
|
|
//如果是凸窗或者墙洞，仍然使用老版本的双击编辑界面
|
|
if (TOpeningData::OP_DOOR==opKind || TOpeningData::OP_DOORWIN==opKind || TOpeningData::OP_TWODOOR==opKind)
|
|
{
|
|
if(EditOpeningInNewDlg(idOpening,_T("TGDoor\n")) == RTNORM)
|
|
return RTNORM;
|
|
}
|
|
else if (TOpeningData::OP_WINDOW==opKind || TOpeningData::OP_ARCWIN==opKind)
|
|
{
|
|
if(EditOpeningInNewDlg(idOpening,_T("TGWindow\n")) == RTNORM )
|
|
return RTNORM;
|
|
}
|
|
|
|
if (opKind==TOpeningData::OP_CORNWIN) {
|
|
double nElev=pOpening->GetLocation().z;
|
|
double nHeight=pOpening->GetHeight();
|
|
if (GetDist(_T("\n新的高度"), nHeight, RSG_NONEG|RSG_NOZERO)==RTCAN)
|
|
return RTERROR;
|
|
if (GetDist(_T("\n新的标高"), nElev, 0)==RTCAN)
|
|
return RTERROR;
|
|
if (pOpening->upgradeOpen()==Acad::eOk) {
|
|
pOpening->SetHeight(nHeight);
|
|
pOpening->m_ptLocation.z = nElev;
|
|
pOpening->downgradeOpen();
|
|
}
|
|
return RTNORM;
|
|
} else if (opKind==TOpeningData::OP_HOLE && (pOpening->m_nOpStyle&OPS_POLY_HOLE)) {
|
|
CAcModuleResourceOverride vTemp;
|
|
CPolyHoleDlg dlg(acedGetAcadFrame());
|
|
dlg.Obj2Dlg(*pOpening);
|
|
if (dlg.DoModal()==IDOK) {
|
|
if (pOpening->upgradeOpen()==Acad::eOk) {
|
|
pOpening->assertWriteEnabled();
|
|
dlg.Dlg2Obj(*pOpening);
|
|
pOpening->downgradeOpen();
|
|
}
|
|
}
|
|
return RTNORM;
|
|
}
|
|
|
|
{
|
|
CAcModuleResourceOverride vTemp;
|
|
CInsertOpeningDlg *pDlg=NULL;
|
|
if (opKind==TOpeningData::OP_WINDOW || opKind==TOpeningData::OP_DOOR ) {
|
|
//门/窗/门联窗
|
|
CDoorOrWinDlg *pDlg1=new CDoorOrWinDlg(opKind, acedGetAcadFrame());
|
|
pDlg=pDlg1;
|
|
} else if (opKind==TOpeningData::OP_DOORWIN) {
|
|
pDlg=new CDoorWinDlg(acedGetAcadFrame());
|
|
} else if (opKind==TOpeningData::OP_TWODOOR) {
|
|
pDlg=new CTwoDoorDlg(acedGetAcadFrame());
|
|
} else if (opKind==TOpeningData::OP_PROWIN) {
|
|
pDlg=new CBayWindowDlg(acedGetAcadFrame());
|
|
} else if (opKind==TOpeningData::OP_ARCWIN) {
|
|
pDlg=new CArcWindowDlg(acedGetAcadFrame());
|
|
} else {
|
|
pDlg=new CRectHoleDlg(acedGetAcadFrame());
|
|
}
|
|
|
|
CInsertOpeningDlg &dlg=*pDlg;
|
|
dlg.SetDlgParamFrom(*pOpening);
|
|
if (dlg.DoModal()==IDOK) { //user edit 只能Read下进行
|
|
dlg.ModifyOpeningWithSameLabel(*pOpening, TRUE);
|
|
}
|
|
delete pDlg;
|
|
}
|
|
OPENOBJ_END();
|
|
return RTNORM;
|
|
}
|
|
|
|
// Command: 窗框展开
|
|
void ExpandWinFrame()
|
|
{
|
|
RBList mask=ads_buildlist(RTDXF0, _T("TCH_CORNER_WINDOW,TCH_OPENING"), NULL);
|
|
Entity ent;
|
|
if (SelectEntity(_T("\n选择窗: "), ent, mask)==RTNORM) {
|
|
xg_setvar(_T("CLAYER"), _T("0"));
|
|
AcDbVoidPtrArray entSetFix, entSetCustom;
|
|
BOOL bContinue=FALSE;
|
|
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbEntity, pWin);
|
|
if (pWin) {
|
|
if (pWin->isKindOf(TDbOpening::desc())) {
|
|
bContinue = ((TDbOpening *)pWin)->ExpandFrame(entSetFix, entSetCustom);
|
|
} else if (pWin->isKindOf(TDbCornerWin::desc())) {
|
|
((TDbCornerWin *)pWin)->ExpandFrame(entSetFix, entSetCustom);
|
|
bContinue=TRUE;
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
if (bContinue) {
|
|
XPoint ptPos;
|
|
if (ads_getpoint(NULL, _T("\n展开到位置<退出>:"), ptPos)==RTNORM) {
|
|
ptPos=Ucs2Wcs(ptPos);
|
|
AcDbObjectId idTemp=InitLayer(LAY_TEMP, FALSE);
|
|
AcGeMatrix3d mat;
|
|
mat.setToTranslation(ptPos);
|
|
int nCount=entSetFix.length();
|
|
for(int n=0; n<nCount; n++) {
|
|
AcDbEntity *pEnt=(AcDbEntity *)entSetFix[n];
|
|
pEnt->setLayer(idTemp);
|
|
pEnt->transformBy(mat);
|
|
AddToModelSpace(pEnt, Adesk::kTrue);
|
|
}
|
|
|
|
nCount=entSetCustom.length();
|
|
for(n=0; n<nCount; n++) {
|
|
AcDbEntity *pEnt=(AcDbEntity *)entSetCustom[n];
|
|
pEnt->transformBy(mat);
|
|
AddToModelSpace(pEnt, Adesk::kTrue);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Command: 窗框映射
|
|
void MapWinFrame()
|
|
{
|
|
RBList mask=ads_buildlist(RTDXF0, _T("TCH_CORNER_WINDOW,TCH_OPENING"), NULL);
|
|
RBList maskCurve=ads_buildlist(RTDXF0, _T("LINE,ARC,CIRCLE"), 8, _T("0"), NULL);
|
|
PickSet ssCurve(SS_FREE), ssWin(SS_FREE);
|
|
if (SelectEntities(_T("\n选择待映射的窗: "), ssWin, mask)!=RTNORM)
|
|
return;
|
|
|
|
adsout << _T("\n提示：空选择则恢复原始默认的窗框!");
|
|
if (SelectEntities(_T("\n选择待映射的棱线: "), ssCurve, maskCurve)==RTCAN)
|
|
return;
|
|
|
|
long nCurveNum=ssCurve.Length();
|
|
XPoint ptBase;
|
|
if (nCurveNum) {
|
|
if (ads_getpoint(NULL, _T("\n基点<退出>:"), ptBase)!=RTNORM)
|
|
return;
|
|
ptBase=Ucs2Wcs(ptBase);
|
|
}
|
|
ads_matrix mat;
|
|
ptBase.GetMoveMatrix(XPoint(), mat);
|
|
DList<XCurveSegment> lstCurves;
|
|
for(long i=0L; i<nCurveNum; i++) {
|
|
XCurveSegment *pSeg=new XCurveSegment(ssCurve[i]);
|
|
pSeg->TransformBy(mat);
|
|
lstCurves.Append(pSeg);
|
|
}
|
|
long nWinNum=ssWin.Length();
|
|
for(i=0L; i<nWinNum; i++) {
|
|
Entity ent=ssWin[i];
|
|
OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbEntity, pWin);
|
|
if (pWin) {
|
|
if (pWin->isKindOf(TDbOpening::desc())) {
|
|
((TDbOpening *)pWin)->SetFrameLines(lstCurves);
|
|
} else if (pWin->isKindOf(TDbCornerWin::desc())) {
|
|
((TDbCornerWin *)pWin)->SetFrameMapping((nCurveNum!=0));
|
|
((TDbCornerWin *)pWin)->SetFrameLines(lstCurves);
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
}
|
|
|
|
// command: 门窗名称复位
|
|
void ResetLabPos()
|
|
{
|
|
RBList mask=ads_buildlist(RTDXF0, _T("TCH_CORNER_WINDOW,TCH_OPENING"), NULL);
|
|
PickSet ssWin(SS_FREE);
|
|
// sg modify 120614，解决命令行提示错误
|
|
//if (SelectEntities(_T("\n选择名称待复位的窗: "), ssWin, mask)!=RTNORM)
|
|
if (SelectEntities(_T("\n选择名称待复位的门窗: "), ssWin, mask)!=RTNORM)
|
|
return;
|
|
|
|
long nWinNum=ssWin.Length();
|
|
for(long i=0L; i<nWinNum; i++) {
|
|
Entity ent=ssWin[i];
|
|
OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbEntity, pEnt);
|
|
if (pEnt) {
|
|
if (pEnt->isKindOf(TDbOpening::desc())) {
|
|
TDbOpening *pWin=TDbOpening::cast(pEnt);
|
|
ASSERT(pWin);
|
|
XPoint ptPos=pWin->GetDefaultLabPos();
|
|
pWin->assertWriteEnabled();
|
|
pWin->SetLabelPos(ptPos);
|
|
} else if (pEnt->isKindOf(TDbCornerWin::desc())) {
|
|
TDbCornerWin *pWin=TDbCornerWin::cast(pEnt);
|
|
ASSERT(pWin);
|
|
pWin->UpdateLabelPos();
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
TArchCmdReactor::ResetAll();
|
|
}
|
|
|
|
//编号后缀
|
|
void LabelFix()
|
|
{
|
|
RBList mask=ads_buildlist(RTDXF0, _T("TCH_CORNER_WINDOW,TCH_OPENING"), NULL);
|
|
PickSet ssWin(SS_FREE);
|
|
// sg modify 120614，解决命令行提示错误
|
|
// if (SelectEntities(_T("\n选择需要在编号后加缀的窗:"), ssWin, mask)!=RTNORM)
|
|
if (SelectEntities(_T("\n选择需要加编号后缀的门窗:"), ssWin, mask)!=RTNORM)
|
|
return;
|
|
|
|
extern TARCH_IMPEXP CString g_sWinLabelPostFix;
|
|
static XString sFix=g_sWinLabelPostFix,sFix1;
|
|
XString sPrompt;
|
|
sPrompt<<_T("\n请输入需要加的门窗编号后缀<")<<sFix<<_T(">:");
|
|
if (acedGetString(FALSE,sPrompt,sFix1)==RTCAN)
|
|
return;
|
|
if (sFix1.Length()>0)
|
|
sFix=sFix1;
|
|
|
|
long nWinNum=ssWin.Length();
|
|
for(long i=0L; i<nWinNum; i++)
|
|
{
|
|
Entity ent=ssWin[i];
|
|
OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbEntity, pEnt);
|
|
if (pEnt)
|
|
{
|
|
if (pEnt->isKindOf(TDbOpening::desc()))
|
|
{
|
|
TDbOpening *pWin=TDbOpening::cast(pEnt);
|
|
ASSERT(pWin);
|
|
|
|
//modify by xlc on 070719
|
|
//XString sLabel=pWin->GetLabel();
|
|
CString sLabel=pWin->GetLabel();
|
|
|
|
pWin->assertWriteEnabled();
|
|
//sLabel<<sFix;
|
|
sLabel += sFix;
|
|
pWin->SetLabel(sLabel);
|
|
}
|
|
else if (pEnt->isKindOf(TDbCornerWin::desc()))
|
|
{
|
|
TDbCornerWin *pWin=TDbCornerWin::cast(pEnt);
|
|
ASSERT(pWin);
|
|
|
|
//modify by xlc on 070719
|
|
//XString sLabel=pWin->GetLabel();
|
|
//sLabel << sFix;
|
|
CString sLabel=pWin->GetLabel();
|
|
sLabel += sFix;
|
|
|
|
pWin->SetLabel(sLabel);
|
|
}
|
|
}
|
|
|
|
OPENOBJ_END();
|
|
}
|
|
TArchCmdReactor::ResetAll();
|
|
}
|
|
|
|
struct SWallFillGroup
|
|
{
|
|
// 墙体
|
|
TDbWall *pWall;
|
|
// 要拆分的数组
|
|
CArray<TDbOpening*, TDbOpening*> aryFillOpening;
|
|
};
|
|
|
|
// 门窗填墙.lgh add 20110324
|
|
void FillOpening()
|
|
{
|
|
TPickEntSet ss;
|
|
CString strPrompt1 = _T("\n请选择需删除的门窗<退出>: ");
|
|
CString strPrompt2 = _T("\n请选择需删除的门窗: ");
|
|
CString strPrompt3 = _T("\n请选择需填补的墙体材料:[填充墙(0)/加气块(1)/空心砖(2)/砖墙(3)/耐火砖(4)/无(5)]<%d>: ");
|
|
static int nDefault = 0;
|
|
strPrompt3.Format(strPrompt3, nDefault);
|
|
// 1、提示用户选择需要删除的门窗
|
|
CString szNullKey = _T("");
|
|
TCHAR chDumpRet;
|
|
if (SelectEnts(strPrompt1, strPrompt2, TRBList(RTDXF0, _T("TCH_OPENING"), NULL), ss, szNullKey, chDumpRet) != RTNORM)
|
|
return;
|
|
|
|
// 2、提示用户选择用填充的墙的类型
|
|
TCHAR sRetKey[100];
|
|
int nRetCode;
|
|
INITGET_BEG(0, _T("0 1 2 3 4 5"));
|
|
nRetCode = ads_getkword(strPrompt3, sRetKey);
|
|
INITGET_END();
|
|
|
|
ss.Redraw(4); // unhilight ent .参考acedRedraw函数
|
|
int nStyle = 0;
|
|
if (nRetCode == RTNORM)
|
|
{
|
|
if (CString("0").CompareNoCase(sRetKey) == 0)
|
|
{
|
|
// ads_printf(_T("\n您选择了0"));
|
|
nStyle = 0;
|
|
}
|
|
// else if (CString("1").CompareNoCase(sRetKey) == 0)
|
|
// {
|
|
// // ads_printf(_T("\n您选择了1"));
|
|
// nStyle = 1;
|
|
// }
|
|
else if (CString("1").CompareNoCase(sRetKey) == 0)
|
|
{
|
|
// ads_printf(_T("\n您选择了2"));
|
|
nStyle = 1;
|
|
}
|
|
else if (CString("2").CompareNoCase(sRetKey) == 0)
|
|
{
|
|
// ads_printf(_T("\n您选择了3"));
|
|
nStyle = 2;
|
|
}
|
|
else if (CString("3").CompareNoCase(sRetKey) == 0)
|
|
{
|
|
// ads_printf(_T("\n您选择了4"));
|
|
nStyle = 3;
|
|
}
|
|
else if (CString("4").CompareNoCase(sRetKey) == 0)
|
|
{
|
|
// ads_printf(_T("\n您选择了5"));
|
|
nStyle = 4;
|
|
}
|
|
else if (CString("5").CompareNoCase(sRetKey) == 0)
|
|
{
|
|
// ads_printf(_T("\n您选择了5"));
|
|
nStyle = 5;
|
|
}
|
|
else
|
|
{
|
|
// ads_printf(_T("\n您取消了命令"));
|
|
return;
|
|
}
|
|
nDefault = nStyle;
|
|
}
|
|
else if (nRetCode == RTNONE)
|
|
{
|
|
// ads_printf(_T("\n你选择了默认值!"));
|
|
nStyle = nDefault;
|
|
}
|
|
else
|
|
return;
|
|
|
|
|
|
// 前边完成了门窗的选择，下面开始进行门窗的填充。
|
|
AcDbObjectIdArray idAry;
|
|
ss.AsIdArray(idAry);
|
|
for (int i = 0; i < (int)idAry.length(); i++)
|
|
{
|
|
AcDbObjectId idWall, idNewWall;
|
|
XPoint ptDoorWin1, ptDoorWin2;
|
|
|
|
OPENOBJ_BEGIN(idAry[i], AcDb::kForWrite, TDbOpening, pOpening)
|
|
if (pOpening == NULL)
|
|
continue;
|
|
|
|
pOpening->GetSidePointsOnBase(ptDoorWin1, ptDoorWin2);
|
|
idWall = pOpening->GetWallId();
|
|
pOpening->erase();// 删除掉这个门窗
|
|
OPENOBJ_END() // end open this door..
|
|
|
|
OPENOBJ_BEGIN(idWall, AcDb::kForWrite, TDbWall, pWall)
|
|
{
|
|
if (pWall == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
XPoint startPoint = pWall->StartPoint();
|
|
XPoint ptStartBreak = ptDoorWin1,ptEndBreak = ptDoorWin2;
|
|
|
|
pWall->ProjectToMe(ptStartBreak, ptDoorWin1);
|
|
pWall->ProjectToMe(ptEndBreak, ptDoorWin2);
|
|
double disStart = ptDoorWin1.Distance(startPoint);
|
|
double disEnd = ptDoorWin2.Distance(startPoint);
|
|
if (disStart < disEnd)
|
|
{
|
|
ptStartBreak = ptDoorWin1;
|
|
ptEndBreak = ptDoorWin2;
|
|
}
|
|
else
|
|
{
|
|
ptStartBreak = ptDoorWin2;
|
|
ptEndBreak = ptDoorWin1;
|
|
}
|
|
|
|
XPoint endPoint = pWall->EndPoint();
|
|
if (endPoint.Distance2d(ptEndBreak) > 1e-6)
|
|
{
|
|
pWall->assertWriteEnabled();
|
|
pWall->BreakAt(ptEndBreak, AcDbObjectId()); // 把后边的一段分出去
|
|
}
|
|
|
|
if (startPoint.Distance2d(ptStartBreak) > 1e-6)
|
|
{
|
|
(pWall->BreakAt(ptStartBreak, idNewWall));
|
|
}
|
|
else
|
|
idNewWall = idWall;
|
|
}
|
|
OPENOBJ_END() // end open wall;
|
|
|
|
OPENOBJ_BEGIN(idNewWall, AcDb::kForWrite, TDbWall, pWall)
|
|
{
|
|
if (pWall == NULL)
|
|
continue;
|
|
AcDbObjectId idSurf=pWall->GetLayerSurf2d();
|
|
if (!idSurf.isValid())
|
|
pWall->SetLayerSurf2d(InitLayer(LAY_SURFACE));//add 090216
|
|
|
|
TWallData::TWallStyle st = pWall->GetStyle();
|
|
CString sT20Mat = WALLMATE_Fill; //lgd add 140428
|
|
switch(nStyle)
|
|
{ // //Xx kDivider, kFill, kFill1, kFill2, kBrick;
|
|
// case 1:
|
|
// st = TWallData::kDivider;
|
|
// pWall->setLayer(InitLayer(LAY_WALL_DIVIDER));
|
|
// break;
|
|
case 0:
|
|
{
|
|
st = TWallData::kFill;
|
|
sT20Mat = WALLMATE_Fill;
|
|
}
|
|
break;
|
|
case 1:
|
|
{
|
|
st = TWallData::kFill1;
|
|
sT20Mat = WALLMATE_Fill1;
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
st = TWallData::kFill2;
|
|
sT20Mat = WALLMATE_Fill2;
|
|
}
|
|
break;
|
|
case 3:
|
|
{
|
|
st = TWallData::kBrick;
|
|
sT20Mat = WALLMATE_Brick;
|
|
}
|
|
break;
|
|
case 4:
|
|
{
|
|
st = TWallData::kBrick;
|
|
sT20Mat = WALLMATE_Brick1;
|
|
}
|
|
break;
|
|
case 5:
|
|
break;
|
|
}
|
|
if (nStyle != 5)
|
|
{
|
|
pWall->SetStyle(st);
|
|
pWall->SetT20WallMat(sT20Mat);
|
|
#if (ADS > 16)
|
|
std::vector< std::pair<CString, CString> > materialName;
|
|
utility::ReadHatchMaterialConfigFile(_T("墙-墙体材料"), materialName);
|
|
std::vector< std::pair<CString, CString> >::iterator iter = materialName.begin();
|
|
for (;iter!=materialName.end();++iter)
|
|
if(iter->first == sT20Mat)
|
|
{
|
|
pWall->GetSpecialtyData()->SetAt(sKEY_WALL_HATCH_PATTERN, iter->second);
|
|
break;
|
|
}
|
|
#endif
|
|
}
|
|
else
|
|
pWall->erase();
|
|
}
|
|
OPENOBJ_END() // end for open new wall;
|
|
}
|
|
|
|
|
|
TArchCmdReactor::UpdateCorners();
|
|
TArchCmdReactor::ResetAll();
|
|
actrTransactionManager->flushGraphics();
|
|
acedUpdateDisplay();
|
|
} |