#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();	
}