#include "stdafx.h"
#include "TDbColumn.h"
#include "TDbWallPatch.h"
#include "OpeningLabelData.h"

#include <sstream>



//T20 扩展数据定义 wlw add 150415
#define sKEY_OP_PROWIN_LINE			_T("T20d1")				// 用来标记是否是pc构件增加凸窗

#define  OP_QUANTUM_1  _T("周长")
#define  OP_QUANTUM_2  _T("面积")
#define  OP_QUANTUM_3  _T("宽度")


#define OP_HWINDOW  6
#define OP_HARCWIN  7

#define TDBOPENING_INSULATE _T("TDBOPENING_INSULATE")

extern AcDbObjectId GetValidTextStyle(AcDbDatabase *pDb, const TCHAR *pStyle);

extern void RemoveContainership(class TDbWall *pWall, class TDbOpening *pOpening);
//extern void GemCreateExplodeBlock(AcDbVoidPtrArray& entityArray,AcDbVoidPtrArray& entitySet,AcGePoint3d ip,TCHAR *Layer);
extern int GetViewDrawMode();
//extern int ExplodeBlockRef(AcDbBlockTableRecord &blockRec, ads_matrix matForInsert, DList<AcDbEntity> &entSet);

extern TARCH_IMPEXP void GetWinWidthModel(DList<double> &lstWidth);
extern TARCH_IMPEXP void GetDoorWidthModel(DList<double> &lstWidth);
extern TARCH_IMPEXP double GetModelNumber(DList<double> &lstModel, double nNearNumber);
//extern AcDbObjectId GetPrepickEntity(RBList &rbBaseMask);

//Acad::ErrorStatus ConvertToDouble(const VARIANT *val, double *pRes);
//Acad::ErrorStatus ConvertToInteger(const VARIANT *val, int *pInt);

static AcDbObjectId g_idCurStretchOpening;
//extern BOOL g_bMakeBlock;
//extern double g_nAcadVer;
extern double g_fWinLabelDefaultHeight;

extern BOOL g_bSlotInsulateCap;
extern double g_dSlotInsulateThick;




// 1－TArch5；2－TArch6；3-TArch7；4-TArch8；5-TArch9
// const Adesk::UInt8 TDbOpening::g_nVersion = 4; 
const Adesk::UInt8 TDbOpening::g_nVersion = 5;

ACRX_DXF_DEFINE_MEMBERS(ATSOpening, ATSEntity, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,  
						1, ATS_OPENING, "ATS_OPENING图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");

IMPLEMENT_TENTBASE(TDbOpening);

TDbOpening::TDbOpening()
:m_uFrame(_AS_SYS_UNIT(40.0)), m_vFrame(_AS_SYS_UNIT(40.0)), m_nSlabThickness(_AS_SYS_UNIT(100.0)), m_nTextHeight(g_fWinLabelDefaultHeight)
{
	m_colorText=7;

	m_iEnFlag=0;
	m_dbAbsorption=0;
	m_dbShadeCo=0;
	m_dbOutShadeCoSum=0;
	m_dbOutShadeCoWin=0;

	// 修改人 : lfy 2009-11-08 动态举证单位化
	m_mat3d.setToIdentity();
	// wlw add 门窗保温参数2011-02-15
	m_nMaterial = GetSlotMaterial();
	m_bSlotInsCap = g_bSlotInsulateCap;
	m_dInsWidth = g_dSlotInsulateThick;
}

// 用所在的
TDbOpening::TDbOpening(AcDbObjectId idWall, AcDbObjectId idStyle2d, AcDbObjectId idStyle3d)
:m_uFrame(_AS_SYS_UNIT(40.0)), m_vFrame(_AS_SYS_UNIT(40.0)), m_nSlabThickness(_AS_SYS_UNIT(100.0)), m_nTextHeight(g_fWinLabelDefaultHeight)
{
	m_nIdOfWall=idWall;
	m_nIdStyle2d=idStyle2d;
	m_nIdStyle3d=idStyle3d;
	m_colorText=7;

	m_iEnFlag=0;
	m_dbAbsorption=0;
	m_dbShadeCo=0;
	m_dbOutShadeCoSum=0;
	m_dbOutShadeCoWin=0;

	// 修改人 : lfy 2009-11-08 动态举证单位化
	m_mat3d.setToIdentity();
	// wlw add 门窗保温参数2011-02-15
	m_nMaterial = GetSlotMaterial();
	m_bSlotInsCap = g_bSlotInsulateCap;
	m_dInsWidth = g_dSlotInsulateThick;
}

// sg modify 110224，增加返回标注，告诉用户端是否需要补充数字
// CString TDbOpening::GetAutoLabel()const
CString TDbOpening::GetAutoLabel(bool &bAddNum)const
{
    TOpeningData::OpeningKind opKind;
    double nWidth, nHeight;

    opKind = GetKind();
    nWidth = GetWidth();
    nHeight = GetHeight();

	// 获得门窗类别，以及软件内部固定死的标注前缀
	CString csSectionLabel,
		csFixupLabel;
	if (opKind == TOpeningData::OP_DOOR)
	{
		csSectionLabel = _T("Door");
		csFixupLabel = _T("M");
	}
	else if (opKind == TOpeningData::OP_WINDOW)
	{
		csSectionLabel = _T("Window");
		csFixupLabel = _T("C");
	}
	else if (opKind == TOpeningData::OP_HOLE)
	{
		csSectionLabel = _T("Hole");
		csFixupLabel = _T("DK");
	}
	else if (opKind == TOpeningData::OP_ARCWIN)
	{
		csSectionLabel = _T("ArcWin");
		csFixupLabel = _T("HC");
	}
	else if (opKind == TOpeningData::OP_PROWIN)
	{
		csSectionLabel = _T("BayWin");
		csFixupLabel = _T("TC");
	}
	else if (opKind == TOpeningData::OP_CORNWIN)
	{
		csSectionLabel = _T("CornerWin");
		csFixupLabel = _T("JC");
	}
	else if (opKind == TOpeningData::OP_DOORWIN)
	{
		csSectionLabel = _T("DoorWin");
		csFixupLabel = _T("MC");
	}
	else if (opKind == TOpeningData::OP_TWODOOR)
	{
		csSectionLabel = _T("TwoDoor");
		csFixupLabel = _T("ZM");
	}
	else if (opKind == TOpeningData::OP_GROUP)
	{
		csSectionLabel = _T("GroupOpening");
		if (IsDoor())
			csFixupLabel = _T("ZM");
		else
			csFixupLabel = _T("ZC");
	}

	bool bFlag = false; // 标记是否已经正确从OpeningLabel.ini文件中得到标注前缀
	TOpeningLabelData data;

	CString csNewName;
	if (!csSectionLabel.IsEmpty()) // 类别不为空时
	{
		// 获得门窗类型
		CString csSubKind = GetSubKind();
		bFlag = data.GetOpeningLabel(csSectionLabel, csSubKind, csNewName);
	}

	if (!bFlag) // 如果没有得到正确的数据，输出固定的标注前缀
		csNewName = csFixupLabel;

	// 获得是否需要添加连字符
	CString csHypen = _T("");
	if (data.HasHypen())
		csHypen = _T("-");

	bool bRound = data.IsRound(); // 是否进行四舍五入

	// 获得标注方式
	TOpeningLabelData::ESerialRule nRule = data.GetNumRule();
	if (nRule == TOpeningLabelData::kSize) // 按尺寸标注
	{
		int nWidth1 = AS_INT(nWidth/100),
			nHeight1 = AS_INT(nHeight/100);

		if (!bRound) // 不进行四舍五入
		{
			nWidth1 = AS_INT(nWidth)/100;
			nHeight1 = AS_INT(nHeight)/100;
		}

		if (nWidth1>9&&nHeight1>9)
			csNewName.Format(_T("%s%s%d%d"),csNewName, csHypen, nWidth1, nHeight1);
		else if (nWidth1<10&&nHeight1>9)
			csNewName.Format(_T("%s%s0%d%d"),csNewName, csHypen, nWidth1, nHeight1);//add by whl
		else if (nWidth1>9&&nHeight1<10)
			csNewName.Format(_T("%s%s%d0%d"),csNewName, csHypen, nWidth1, nHeight1);//add by whl
		else // if(nWidth<10&&nHeight<10)
			csNewName.Format(_T("%s%s0%d0%d"),csNewName, csHypen, nWidth1, nHeight1);//add by whl

		bAddNum = false;
	}
	else // 按数序排列
	{
		csNewName.Format(_T("%s%s"), csNewName, csHypen);

		bAddNum = true; // 由对话框处进行+1工作
	}
	return csNewName;
}

BOOL TDbOpening::IsValid() const
{
    BOOL bRet = TDbEntity::IsValid();
    if (!bRet)
        return bRet;

    bRet = (m_nWidth>_DIST_SNAP &&
		m_nThickness>_DIST_SNAP);  
    return bRet;
}

TEntityBase::DrawType TDbOpening::GetDrawType() const
{
	if (!Has3D())
		return k2DOnly;
	return k2Dand3D;
}

// 提供对格式刷的支持
void TDbOpening::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
{
	assertWriteEnabled();
	TDbEntity::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
	TDbOpening *pSrc=TDbOpening::cast(pSrcEntity);
	if(pSrc)
	{
		m_nWidth=pSrc->m_nWidth;
		m_nThickness=pSrc->m_nThickness;
		m_nHeight=pSrc->m_nHeight; 
		if(pSrc->m_nIdOfWall == m_nIdOfWall)
		{
			m_nRotation=pSrc->m_nRotation;
			m_nQuadrant=pSrc->m_nQuadrant;  //象限0,1,2,3代表第1~4象限, m_nRotation为象限的X正方向
		}
		m_opKind=pSrc->m_opKind; // 门窗类型

		// sg add 110908，根据8.5的需求，格式刷要支持子类型
		SetSubKind(pSrc->GetSubKind());

		m_nBulge=pSrc->m_nBulge; //对于弧形窗不为0
		m_sLabel=pSrc->m_sLabel; //标号
		if(database()==NULL||
			pSrcEntity->database()==NULL||
			database()==pSrcEntity->database())//add by whl on 060317
		{
			m_nIdStyle2d=pSrc->m_nIdStyle2d;
			m_nIdStyle3d=pSrc->m_nIdStyle3d; //块表中的ID
		}

		m_nOpStyle=pSrc->m_nOpStyle;  //是否包含门窗套等标记
		m_nSlotExt=pSrc->m_nSlotExt;
		m_nSlotWidth=pSrc->m_nSlotWidth; //伸出墙的距离,窗套宽度
		m_nDoorWidth=pSrc->m_nDoorWidth;
		m_nWinHeight=pSrc->m_nWinHeight; //门联窗门宽(或子母大门宽)和窗高
		m_ptLocation.z=pSrc->m_ptLocation.z;//add by whl on 060411，窗台高
		if(pSrc->m_pBayWin)
		{
			if(!m_pBayWin)
				m_pBayWin=new XBayWindow;
			memcpy(m_pBayWin, pSrc->m_pBayWin, sizeof(XBayWindow));
		} 
		else
		{
			if(m_pBayWin)
			{
				delete m_pBayWin;
				m_pBayWin=NULL;
			}
		}

		// TArch6 data
		if(database()==NULL||
			pSrcEntity->database()==NULL||
			database()==pSrcEntity->database())//add by whl on 060317
		{
			m_idTextStyle=pSrc->m_idTextStyle;
			m_idLayerText=pSrc->m_idLayerText; //文字样式和图层
			m_idLayerGlass3d=pSrc->m_idLayerGlass3d;
			m_idLayerFrame3d=pSrc->m_idLayerFrame3d;
			m_idLayerSlab3d=pSrc->m_idLayerSlab3d; //玻璃、窗框和窗台板的图层
		}
		m_nTextHeight=pSrc->m_nTextHeight; //文字转角，文字高度
		m_uFrame=pSrc->m_uFrame;
		m_vFrame=pSrc->m_vFrame; //窗框(竖直)高度和窗框(水平)厚度
		m_nSlabThickness=pSrc->m_nSlabThickness; //窗台板厚
		m_lstFrameLines.Reset(); //待映射的窗框线，不包括外框
		for(int n=0; n<pSrc->m_lstFrameLines.Length(); n++) 
		{
			m_lstFrameLines.Append(new XCurveSegment(*pSrc->m_lstFrameLines[n]));
		}

		m_colorText=pSrc->m_colorText;
		m_nOpStyleEx=pSrc->m_nOpStyleEx;
		m_nProWinSlabWidth=pSrc->m_nProWinSlabWidth;
    }
}


///////////////////////////////////////////////////////////////////////
// 访问属性的方法
Acad::ErrorStatus 
TDbOpening::subGetClassID(CLSID* pClsid) const
{
    return Acad::eOk;
}

// 从DWG读入数据:
Acad::ErrorStatus TDbOpening::dwgInFields (AcDbDwgFiler* pFiler)
{
   assertWriteEnabled();

   Acad::ErrorStatus es = TDbEntity::dwgInFields(pFiler);
   if(es != Acad::eOk)
	   return es;

   Adesk::UInt8  nVer;
   pFiler->readItem(&nVer);
   if(nVer>g_nVersion)
   {// Version is too new
       return Acad::eMakeMeProxy;
   }

   pFiler->readItem(&(AcGePoint3d &)m_ptLocation); //含Z坐标,作为窗台高度
   pFiler->readItem(&m_nWidth);
   pFiler->readItem(&m_nThickness);
   pFiler->readItem(&m_nHeight);  // nWidth有正负, nHeight>0
   pFiler->readItem(&m_nRotation); // 0~2*PI
   pFiler->readItem(&m_nQuadrant);

   Adesk::UInt8 nKind;
   pFiler->readItem(&nKind);
   m_opKind = (OpeningKind)nKind;
   pFiler->readItem(&m_nBulge); //对于弧形窗不为0

   TCHAR *pBuffer=NULL;
   pFiler->readString(&pBuffer);
   assert(pBuffer);
   m_sLabel=pBuffer;
   acdbFree(pBuffer);

   pFiler->readItem(&m_nIdStyle2d);
   pFiler->readItem(&m_nIdStyle3d);

   pFiler->readItem(&(AcGePoint3d &)m_ptLabel);
   pFiler->readItem(&m_nIdOfWall);

   if(nVer>1) // TArch6
	   pFiler->readItem(&m_nOpStyle);
   else
   { // Upgrade
	   Adesk::UInt8 oldStyle=0;
	   pFiler->readItem(&oldStyle);
	   m_nOpStyle=oldStyle;
	   if(HasSlot())
		   SetSlot3d(TRUE);
   }

   if(HasSlot())
   {
       pFiler->readItem(&m_nSlotExt);
       pFiler->readItem(&m_nSlotWidth);
   }

	if (m_opKind==OP_PROWIN)
	{
		if(!m_pBayWin)
			m_pBayWin = new XBayWindow;
		// sg modify 120518，在凸窗中增加了数据，间接需要版本号来增加数据
		// VERIFY(m_pBayWin->dwgInFields(pFiler)==Acad::eOk);
		VERIFY(m_pBayWin->dwgInFields(pFiler, nVer)==Acad::eOk);
   }
   else if(m_opKind==OP_DOORWIN || m_opKind==OP_TWODOOR)
   {
       pFiler->readItem(&m_nDoorWidth);
       if(m_opKind==OP_DOORWIN)
           pFiler->readItem(&m_nWinHeight);
   }

	m_lstFrameLines.Reset();
	m_idLayerGlass3d=m_idLayerFrame3d=m_idLayerSlab3d=AcDbObjectId::kNull;
    if(nVer>1) { // TArch6
		pFiler->readItem(&m_idTextStyle);
		pFiler->readItem(&m_idLayerText);
		pFiler->readItem(&m_idLayerGlass3d);
		pFiler->readItem(&m_idLayerFrame3d);
		pFiler->readItem(&m_idLayerSlab3d);

		pFiler->readItem(&m_nTextHeight);
		pFiler->readItem(&m_nSlabThickness);
		pFiler->readItem(&m_uFrame);
		pFiler->readItem(&m_vFrame);

		Adesk::UInt16 nCount=0;
		pFiler->readItem(&nCount);
		for(Adesk::UInt16 n=0; n<nCount; n++)
		{
			XPoint pt1, pt2;
			double val;
			pFiler->readItem(&(AcGePoint2d &)pt1);
			pFiler->readItem(&(AcGePoint2d &)pt2);
			pFiler->readItem(&val);
			m_lstFrameLines.Append(new XCurveSegment(pt1, pt2, val, LS_FINITE));
		}
    }
	else
	{
	   if(database()==acdbCurDwg())
	   {
		   m_idTextStyle = InitTextStyle(TS_WINDOW);
		   m_idLayerText = InitLayer(LAY_OPENING_DIM, FALSE);
		   m_idLayerGlass3d = InitLayer(LAY_3DGLASS, FALSE);
		   m_idLayerSlab3d = m_idLayerFrame3d = InitLayer(LAY_3DFRAME, FALSE);
	   }
	   else 
	   {
		   m_idTextStyle = GetValidTextStyle(database(), _T("_TCH_WINDOW"));
		   m_idLayerText = GetLayerIdFromString(LAY_OPENING_DIM, database());
		   m_idLayerGlass3d = GetLayerIdFromString(LAY_3DGLASS, database());
		   m_idLayerSlab3d = m_idLayerFrame3d = GetLayerIdFromString(LAY_3DFRAME, database());
	   }
	}

	if(nVer>2)//TArch7
	{
		pFiler->readItem(&m_nOpStyleEx);
		pFiler->readItem(&m_colorText);

		pFiler->readItem(&m_iEnFlag);
		ReadString(pFiler,m_sCons);
		pFiler->readItem(&m_dbAbsorption);
		pFiler->readItem(&m_dbShadeCo);
		pFiler->readItem(&m_dbOutShadeCoSum);
		pFiler->readItem(&m_dbOutShadeCoWin);
	}

	if(nVer>3)//TArch8
	{
		pFiler->readItem(&m_nProWinSlabWidth);
	}
    return pFiler->filerStatus();
}

// 写出数据到dwg:
Acad::ErrorStatus TDbOpening::dwgOutFields(AcDbDwgFiler* pFiler) const
{
   assertReadEnabled();
   Acad::ErrorStatus es = TDbEntity::dwgOutFields(pFiler);
   if(es != Acad::eOk) return es;

   if(g_nSaveTArchVer==5)
	   pFiler->writeItem((Adesk::UInt8)1);
   else if(g_nSaveTArchVer==6)
	   pFiler->writeItem((Adesk::UInt8)2);
   else if(g_nSaveTArchVer==7)
	   pFiler->writeItem((Adesk::UInt8)3);
   else if(g_nSaveTArchVer==8) // sg modify 1200703，9.0升级版本号
	   pFiler->writeItem((Adesk::UInt8)4);
   else
	   pFiler->writeItem(g_nVersion);

   pFiler->writeItem((AcGePoint3d &)m_ptLocation); //含Z坐标,作为窗台高度
   pFiler->writeItem(m_nWidth);
   pFiler->writeItem(m_nThickness);
   pFiler->writeItem(m_nHeight);  // nWidth有正负, nHeight>0
   pFiler->writeItem(m_nRotation); // 0~2*PI
   pFiler->writeItem(m_nQuadrant); 

   Adesk::UInt8 nKind=m_opKind;
	if(g_nSaveTArchVer<7)
	{
		if(IsDoorAsWin())
			nKind=OP_WINDOW;
	}

   pFiler->writeItem(nKind);
   pFiler->writeItem(m_nBulge); //对于弧形窗不为0
   
   pFiler->writeString(m_sLabel);
   pFiler->writeItem(m_nIdStyle2d);
   pFiler->writeItem(m_nIdStyle3d);
   pFiler->writeItem((AcGePoint3d &)m_ptLabel);

   pFiler->writeItem(m_nIdOfWall);


   if(g_nSaveTArchVer==5)
       pFiler->writeItem((Adesk::UInt8)m_nOpStyle);
   else
       pFiler->writeItem(m_nOpStyle);
   if(HasSlot()) 
   {
       pFiler->writeItem(m_nSlotExt);
       pFiler->writeItem(m_nSlotWidth);
   }
   if(m_opKind==OP_PROWIN)
   {
       ASSERT(m_pBayWin);
       VERIFY(m_pBayWin->dwgOutFields(pFiler)==Acad::eOk);
   } 
   else if(m_opKind==OP_DOORWIN || m_opKind==OP_TWODOOR)
   {
       pFiler->writeItem(m_nDoorWidth);
       if(m_opKind==OP_DOORWIN)
            pFiler->writeItem(m_nWinHeight);
   }

	// TArch6
	if(g_nSaveTArchVer>5)
	{
		pFiler->writeItem(m_idTextStyle);
		pFiler->writeItem(m_idLayerText);
		pFiler->writeItem(m_idLayerGlass3d);
		pFiler->writeItem(m_idLayerFrame3d);
		pFiler->writeItem(m_idLayerSlab3d);

		pFiler->writeItem(m_nTextHeight);
		pFiler->writeItem(m_nSlabThickness);
		pFiler->writeItem(m_uFrame);
		pFiler->writeItem(m_vFrame);

		Adesk::UInt16 nCount=m_lstFrameLines.Length();
		pFiler->writeItem(nCount);
		for(Adesk::UInt16 n=0; n<nCount; n++) 
		{
			const XCurveSegment &rSeg=m_lstFrameLines[(int)n];
			pFiler->writeItem((const AcGePoint2d &)rSeg.StartPoint());
			pFiler->writeItem((const AcGePoint2d &)rSeg.EndPoint());
			pFiler->writeItem(rSeg.GetBulge());
		}
	}

	//TArch7
	if(g_nSaveTArchVer>6)
	{
		pFiler->writeItem(m_nOpStyleEx);
		pFiler->writeItem(m_colorText);

		pFiler->writeItem(m_iEnFlag);
		pFiler->writeString(m_sCons);
		pFiler->writeItem(m_dbAbsorption);
		pFiler->writeItem(m_dbShadeCo);
		pFiler->writeItem(m_dbOutShadeCoSum);
		pFiler->writeItem(m_dbOutShadeCoWin);
	}

	//TArch8
	if(g_nSaveTArchVer>7)
	{
		pFiler->writeItem(m_nProWinSlabWidth);
	}

	return es;
}

Acad::ErrorStatus TDbOpening::dxfInFields (AcDbDxfFiler* pFiler)
{
    assertWriteEnabled();

    Acad::ErrorStatus es =  TDbEntity::dxfInFields(pFiler);
    if(es!=Acad::eOk)
        return es;

    if (!pFiler->atSubclassData(_T("TDbOpening"))) {
        return Acad::eBadDxfSequence;
    }

	int fieldsFlags=0;
	resbuf rb;
	XString s1, s2, s3;
	Adesk::Int32 bitFlags=0;
	int n1, n2, n3, n4;
	double r1, r2, r3, r4, r5, r6;
	double a1, a2;
	XPoint pt1, pt2;
	AcDbObjectId idWall;
    while ((es == Acad::eOk)
        && ((es = pFiler->readResBuf(&rb)) == Acad::eOk))    {
        switch (rb.restype) {
		case 1:
			s1=rb.resval.rstring;
			fieldsFlags |= 0x01;
			free(rb.resval.rstring);
			break;
		case 2:
			s2=rb.resval.rstring;
			fieldsFlags |= 0x02;
			free(rb.resval.rstring);
			break;
		case 302:
			s3=rb.resval.rstring;
			fieldsFlags |= 0x04;
			free(rb.resval.rstring);
			break;
		case AcDb::kDxfXCoord:
			pt1=rb.resval.rpoint;
			fieldsFlags |= 0x08;
			break;
		case AcDb::kDxfXCoord+1:
			pt2=rb.resval.rpoint;
			fieldsFlags |= 0x10;
			break;
		case AcDb::kDxfReal:
			r1=rb.resval.rreal;
			fieldsFlags |= 0x20;
			break;
		case AcDb::kDxfReal+1:
			r2=rb.resval.rreal;
			fieldsFlags |= 0x40;
			break;
		case AcDb::kDxfReal+3:
			r3=rb.resval.rreal;
			fieldsFlags |= 0x80;
			break;
		case AcDb::kDxfReal+4:
			r4=rb.resval.rreal;
			fieldsFlags |= 0x100;
			break;
		case AcDb::kDxfReal+5:
			r5=rb.resval.rreal;
			fieldsFlags |=0x200;
			break;
		case AcDb::kDxfReal+6:
			r6=rb.resval.rreal;
			fieldsFlags |= 0x400;
			break;
        case AcDb::kDxfAngle:
			a1=rb.resval.rreal;
			fieldsFlags |= 0x800;
            break;    
		case AcDb::kDxfAngle+1:
			a2=rb.resval.rreal;
			fieldsFlags |= 0x1000;
			break;
		case AcDb::kDxfInt16:
			n1=rb.resval.rint;
			fieldsFlags |= 0x2000;
			break;
		case AcDb::kDxfInt16+1:
			n2=rb.resval.rint;
			fieldsFlags |= 0x4000;
			break;
		case AcDb::kDxfInt16+2:
			n3=rb.resval.rint;
			fieldsFlags |= 0x8000;
			break;
		case AcDb::kDxfInt16+3:
			n4=rb.resval.rint;
			fieldsFlags |= 0x10000;
			break;
		case AcDb::kDxfInt32:
			bitFlags=rb.resval.rint;
			break;
		case AcDb::kDxfSoftPointerId:
            acdbGetObjectId(idWall, rb.resval.rlname);
			fieldsFlags |= 0x20000;
            break;
        case 147:
			m_nSlabThickness = rb.resval.rreal;
			break;
		case 148:
			m_uFrame = rb.resval.rreal;
			break;
		case 149:
			m_vFrame = rb.resval.rreal;
			break;
		case 7:
			{
				XString sName;
				sName=rb.resval.rstring;
				free(rb.resval.rstring);
				m_idTextStyle=TchExport::GetTextStyleId(sName, database());
			}
			break;
		case 140:
			m_nTextHeight=rb.resval.rreal;
			break;
		case 410:
			m_idLayerText=LayerString2Id(rb.resval.rstring, database());
			free(rb.resval.rstring);
			break;
		case 411:
			m_idLayerGlass3d=LayerString2Id(rb.resval.rstring, database());
			free(rb.resval.rstring);
			break;
		case 412:
			m_idLayerFrame3d=LayerString2Id(rb.resval.rstring, database());
			free(rb.resval.rstring);
			break;
		case 413:
			m_idLayerSlab3d=LayerString2Id(rb.resval.rstring, database());
			free(rb.resval.rstring);
			break;
        default:
            // An unrecognized group. Push it back so that
            // the subclass can read it again.
            pFiler->pushBackItem();
            es = Acad::eEndOfFile;
            break;
        }
    }

    // At this point the es variable must contain eEndOfFile
    // - either from readResBuf() or from pushback. If not,
    // it indicates that an error happened and we should
    // return immediately.
    //
    if (es != Acad::eEndOfFile)
        return Acad::eInvalidResBuf;

	if(!m_idTextStyle) {
		XString style;
		if(database())
			m_idTextStyle=database()->textstyle();
		else {
			xg_getvar(_T("TEXTSTYLE"), style);
			m_idTextStyle = TchExport::GetTextStyleId(style, database());
		}
	}

    if (!(fieldsFlags&0x08)) {
        pFiler->setError(Acad::eMissingDxfField,
            _T("\nMissing DXF group code: 10"));
        return Acad::eMissingDxfField;
	}
    if (!(fieldsFlags&0x10)) {
        pFiler->setError(Acad::eMissingDxfField,
            _T("\nMissing DXF group code: 11"));
        return Acad::eMissingDxfField;
	}
    if (!(fieldsFlags&0x20)) {
        pFiler->setError(Acad::eMissingDxfField,
            _T("\nMissing DXF group code: 40"));
        return Acad::eMissingDxfField;
	}
    if (!(fieldsFlags&0x40)) {
        pFiler->setError(Acad::eMissingDxfField,
            _T("\nMissing DXF group code: 41"));
        return Acad::eMissingDxfField;
	}

	if(!!s1)
		m_nIdStyle2d=GetBlockIdFromString(s1);
	if(!!s2)
		m_nIdStyle3d=GetBlockIdFromString(s2);
	if(fieldsFlags&0x04)
		m_sLabel=s3;
	m_ptLocation=pt1;
    m_ptLabel=pt2;
	m_nWidth=r1;
	m_nHeight=r2;
	if(fieldsFlags&0x80)
		m_nSlotExt=r3;
	if(fieldsFlags&0x100)
		m_nSlotWidth=r4;
	if(fieldsFlags&0x200)
		m_nDoorWidth=r5;
	if(fieldsFlags&0x400)
		m_nWinHeight=r6;
	if(fieldsFlags&0x800)
		m_nRotation=a1;
	if(fieldsFlags&0x1000)
		m_nBulge=a2;
	if(fieldsFlags&0x2000)
		m_nQuadrant=n1;
	if(fieldsFlags&0x4000)
		m_opKind=(OpeningKind)n2;
	if(m_opKind==OP_PROWIN) {
		if(!m_pBayWin)
			m_pBayWin=new XBayWindow;
		if(fieldsFlags&0x200)
			m_pBayWin->m_nProtrude=r5;
		if(fieldsFlags&0x400)
			m_pBayWin->m_nTrapezia=r6;
	}
	if(fieldsFlags&0x8000)
		m_nOpStyle=n3;
	if(fieldsFlags&0x10000) {
		if(m_pBayWin)
			m_pBayWin->m_nStyle=(XBayWindow::XBayWinStyle)n4;
	}
	if(fieldsFlags&0x20000) {
		m_nIdOfWall=idWall;
	}

	//TArch7
	m_nOpStyleEx=bitFlags;

    return pFiler->filerStatus();
}

Acad::ErrorStatus TDbOpening::dxfOutFields(AcDbDxfFiler* pFiler) const
{
    assertReadEnabled();
   Acad::ErrorStatus es;

   es = TDbEntity::dxfOutFields(pFiler);
   assert(es == Acad::eOk);

   es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbOpening"));
   assert(es == Acad::eOk);

/*
   es = pFiler->writeItem(AcDb::kDxfInt8,g_nVersion);
   assert(es == Acad::eOk);
*/
   XString sName2d, sName3d;
   if(!m_nIdStyle2d) ;
   else
	   sName2d=GetSymbolName(m_nIdStyle2d);
   if(!m_nIdStyle3d) ;
   else
	   sName3d=GetSymbolName(m_nIdStyle3d);
   pFiler->writeString(1, sName2d);
   pFiler->writeString(2, sName3d);
   pFiler->writeString(302, m_sLabel);
   pFiler->writePoint3d(10, m_ptLocation);
   pFiler->writePoint2d(11, m_ptLabel);
   pFiler->writeDouble(AcDb::kDxfReal, m_nWidth);
   pFiler->writeDouble(AcDb::kDxfReal+1, m_nHeight);
   pFiler->writeDouble(AcDb::kDxfAngle, m_nRotation);
   pFiler->writeDouble(AcDb::kDxfAngle+1, m_nBulge);
   pFiler->writeDouble(AcDb::kDxfReal+3, m_nSlotExt);
   pFiler->writeDouble(AcDb::kDxfReal+4, m_nSlotWidth);
   pFiler->writeDouble(AcDb::kDxfReal+5, m_pBayWin? m_pBayWin->m_nProtrude : m_nDoorWidth);
   pFiler->writeDouble(AcDb::kDxfReal+6, m_pBayWin? m_pBayWin->m_nTrapezia : m_nWinHeight);
   pFiler->writeInt16(AcDb::kDxfInt16, m_nQuadrant);
   pFiler->writeInt16(AcDb::kDxfInt16+1, m_opKind);
   pFiler->writeInt16(AcDb::kDxfInt16+2, m_nOpStyle);
   if(m_pBayWin)
	   pFiler->writeInt16(AcDb::kDxfInt16+3, m_pBayWin->m_nStyle);

   es = pFiler->writeItem(AcDb::kDxfSoftPointerId,m_nIdOfWall);


   pFiler->writeDouble(147, m_nSlabThickness);
   pFiler->writeDouble(148, m_uFrame);
   pFiler->writeDouble(149, m_vFrame);
   pFiler->writeString(7, (const TCHAR *)GetSymbolName(m_idTextStyle));
   pFiler->writeDouble(140, m_nTextHeight);
   pFiler->writeString(410, (const TCHAR *)LayerId2String(m_idLayerText));
   pFiler->writeString(411, (const TCHAR *)LayerId2String(m_idLayerGlass3d));
   pFiler->writeString(412, (const TCHAR *)LayerId2String(m_idLayerFrame3d));
   pFiler->writeString(413, (const TCHAR *)LayerId2String(m_idLayerSlab3d));

   //TArch7
   pFiler->writeItem(AcDb::kDxfInt32,m_nOpStyleEx);
   return es;
}

// 克隆门窗的时候
Acad::ErrorStatus
TDbOpening::subDeepClone(AcDbObject*    pOwner,
		      AcDbObject*&   pClonedObject,
		      AcDbIdMapping& idMap,
		      Adesk::Boolean isPrimary) const
{
    Acad::ErrorStatus es=TDbEntity::subDeepClone(pOwner, pClonedObject, idMap, isPrimary);
    return es; // Modify by ZJQ on 2001/11/29

    if(es!=Acad::eOk)
        return es;

    if(!m_nIdOfWall)
        return es;

    // STEP 8:
    // if the wall is not beening cloned then modify pcloned
    if (idMap.deepCloneContext()==AcDb::kDcCopy) 
	{
        AcDbIdPair idPairWall(m_nIdOfWall, AcDbObjectId::kNull,
            false, isPrimary? true :false);
        if(!idMap.compute(idPairWall))
		{
            TDbOpening *pClonedOpening = TDbOpening::cast(pClonedObject);
            assert(pClonedOpening);
            pClonedOpening->m_nIdOfWall=AcDbObjectId();
        }
    }

    // Leave pClonedObject open for the caller
    //
    return Acad::eOk;
}

Acad::ErrorStatus TDbOpening::subGetOsnapPoints(
                                 AcDb::OsnapMode       osnapMode,
                                 INT_PTR                   gsSelectionMark,
                                 const AcGePoint3d&    ptPick,
                                 const AcGePoint3d&    lastPoint,
                                 const AcGeMatrix3d&   viewXform,
                                 AcGePoint3dArray&     snapPoints,
                                 AcDbIntArray&     geomIds) const
{  	
	assertReadEnabled();

	if (osnapMode == AcDb::kOsModeIns)
	{ //插入点捕捉
		XPoint ptIns=m_ptLocation;
		if(!IsExplode3D())
			ptIns.z=0;
		snapPoints.append(ptIns);
		return Acad::eOk;
	}

	return TDbEntity::subGetOsnapPoints(osnapMode, gsSelectionMark, ptPick, lastPoint, viewXform,
		snapPoints, geomIds);
}

// -----------------------------------------------------------------------
// Overriden functions for edit

// 取夹点
//   依次为插入点, 左右侧点, 开启方向控制点,
//   待加标号控制点
Acad::ErrorStatus TDbOpening::subGetGripPoints(AcGePoint3dArray&  gripPoints,
                                             AcDbIntArray&  osnapModes,
                                             AcDbIntArray&  geomIds) const
{
    //if(TArchCmdReactor::g_sCurCommand==_T("GRIP_STRETCH")) {
    //    if(!!objectId())
    //        g_idCurStretchOpening=objectId();
    //}
	gripPoints.append(m_ptLocation);

	// 左右侧点
	XPoint ptSideStart, ptSideEnd;
	GetSidePoints(ptSideStart, ptSideEnd);
	gripPoints.append(ptSideStart);
	gripPoints.append(ptSideEnd);

	XPoint ptQuadrant;
	ads_polar(m_ptLocation, m_nRotation+m_nQuadrant*PI/2+PI/4, m_nWidth/2.0, ptQuadrant);
	gripPoints.append(ptQuadrant);

	if(!(!m_sLabel)) 
	{
		gripPoints.append(m_ptLabel);
	}
	return Acad::eOk;
}

#if ADS>15
void TDbOpening::CreateGrip()
{
	TDbEntity::CreateGrip();

	XCurveSegment curve;
	if(GetCenterCurve(curve)&&curve.Is(CURVE_LINE))
	{
		GetGrip(0)->AppendDim(new TDbGripDistDim(AcDbDimData::kDimResultantLength));
		GetGrip(0)->AppendDim(new TDbGripDistDim(AcDbDimData::kDimDeltaLength,false));

		GetGrip(1)->AppendDim(new TDbGripDistDim(AcDbDimData::kDimResultantLength));
		GetGrip(1)->AppendDim(new TDbGripDistDim(AcDbDimData::kDimDeltaLength));
		GetGrip(1)->AppendDim(new TDbGripDistDim(AcDbDimData::kDimDeltaLength,false));

		GetGrip(2)->AppendDim(new TDbGripDistDim(AcDbDimData::kDimResultantLength));
		GetGrip(2)->AppendDim(new TDbGripDistDim(AcDbDimData::kDimDeltaLength));
		GetGrip(2)->AppendDim(new TDbGripDistDim(AcDbDimData::kDimDeltaLength,false));
	}
}

Acad::ErrorStatus TDbOpening::EntityToDim(long iGrip,long iDim,const AcDbEntity*pEnt0)
{
	XCurveSegment wall;
	if(!GetCenterCurve(wall))//中线
		return Acad::eInvalidInput;

	TDbGripDim*pDim=GetGripDim(iGrip,iDim);
	if(pDim==NULL)
		return Acad::eInvalidInput;
	
	TDbOpening*pEnt=TDbOpening::cast(pEnt0);
	if(pEnt==NULL)
		pEnt=this;
	
	XPoint vt(wall.EndPoint()-wall.StartPoint());
	switch(iGrip)
	{
	case 0://位置夹点
		switch(iDim)
		{
		case 0://宽度
			{
				TDbGripDistDim*pDistDim=(TDbGripDistDim*)pDim;
				XPoint ptSideStart, ptSideEnd;
				pEnt->GetSidePoints(ptSideStart, ptSideEnd);
				pDistDim->SetData(ptSideStart.AsAcGePoint3d(),ptSideEnd.AsAcGePoint3d(),1500);
			}
			break;
		case 1://位置偏移
			{
				TDbGripDistDim*pDistDim=(TDbGripDistDim*)pDim;
				XPoint pt;
				wall.ProjectToMe(pEnt->GetLocation(),pt);
				pDistDim->SetData(pt.AsAcGePoint3d(),pDim->GripPoint(),800);
			}
			break;
		default:
			return Acad::eNotImplementedYet;
		}
		break;
	case 1://起点
		switch(iDim)
		{
		case 0://从终点到起点的宽度
			{
				TDbGripDistDim*pDistDim=(TDbGripDistDim*)pDim;
				XPoint ptSideStart, ptSideEnd;
				pEnt->GetSidePoints(ptSideStart, ptSideEnd);
				pDistDim->SetData(ptSideStart.AsAcGePoint3d(),ptSideEnd.AsAcGePoint3d(),1500);
			}
			break;
		case 1://前垛距
			{
				XCurveSegment seg;
				TDbGripDistDim*pDistDim=(TDbGripDistDim*)pDim;
				XPoint pt;
				if(GetNeighbourPoint(pt,true))
				{
					XPoint ptSideStart,ptSideEnd;
					pEnt->GetSidePoints(ptSideStart, ptSideEnd);
					wall.ProjectToMe(pt,pt);
					wall.ProjectToMe(ptSideStart,ptSideStart);
					pDistDim->SetData(pt.AsAcGePoint3d(),ptSideStart.AsAcGePoint3d(),1200);
				}
			}
			break;	
		case 2://总体偏移或起点偏移
			{
				TDbGripDistDim*pDistDim=(TDbGripDistDim*)pDim;
				XPoint ptSideStart,ptSideEnd;
				pEnt->GetSidePoints(ptSideStart, ptSideEnd);
				wall.ProjectToMe(ptSideStart,ptSideStart);
				pDistDim->SetData(pDim->GripPoint(),ptSideStart.AsAcGePoint3d(),800);
			}
			break;

		default:
			return Acad::eNotImplementedYet;
		}
		break;
	case 2://终点
		switch(iDim)
		{
		case 0://从起点到终点的宽度
			{
				TDbGripDistDim*pDistDim=(TDbGripDistDim*)pDim;
				XPoint ptSideStart, ptSideEnd;
				pEnt->GetSidePoints(ptSideStart, ptSideEnd);
				pDistDim->SetData(ptSideStart.AsAcGePoint3d(),ptSideEnd.AsAcGePoint3d(),1500);
			}
			break;
		case 1://后垛距
			{
				XCurveSegment seg;
				TDbGripDistDim*pDistDim=(TDbGripDistDim*)pDim;
				XPoint pt;
				if(GetNeighbourPoint(pt,false))
				{
					XPoint ptSideStart,ptSideEnd;
					pEnt->GetSidePoints(ptSideStart, ptSideEnd);
					wall.ProjectToMe(pt,pt);
					wall.ProjectToMe(ptSideEnd,ptSideEnd);
					pDistDim->SetData(ptSideEnd.AsAcGePoint3d(),pt.AsAcGePoint3d(),1200);
				}
			}
			break;		
		case 2://总体偏移或起点偏移
			{
				TDbGripDistDim*pDistDim=(TDbGripDistDim*)pDim;
				XPoint ptSideStart,ptSideEnd;
				pEnt->GetSidePoints(ptSideStart, ptSideEnd);
				wall.ProjectToMe(ptSideEnd,ptSideEnd);
				pDistDim->SetData(pDim->GripPoint(),ptSideEnd.AsAcGePoint3d(),800);
			}
			break;

		default:
			return Acad::eNotImplementedYet;
		}
		break;
	default:
		return Acad::eNotImplementedYet;
	}

	return Acad::eOk;
}

Acad::ErrorStatus TDbOpening::DimToEntity(long iGrip,long iDim,double newValue,const AcGeVector3d &offset)
{
	assertWriteEnabled();

	AcGePoint3d ptNew=GetGripPoint(iGrip)+offset;

	XCurveSegment wall;
	GetCenterCurve(wall);
	XPoint vt=wall.EndPoint()-wall.StartPoint();
	vt.Normalize();
	switch(iGrip)
	{
	case 0://位置夹点
		switch(iDim)
		{
		case 0://宽度
			if(newValue>1E-6)
				SetWidth(newValue);
			break;
		case 1://整体偏移
			{
				if(vt.AsAcGeVector3d().dotProduct(offset)>0)
					vt*=newValue;
				else
					vt*=-newValue;
				m_ptLocation+=vt;
				m_ptLabel+=vt;
			}
			break;
		}
		break;
	case 1://起点
		switch(iDim)
		{
		case 0://单侧改宽
			if(newValue>1E-6)
			{
				vt*=((m_nWidth-newValue)/2);
				m_ptLocation+=vt;
				m_ptLabel+=vt;
				SetWidth(newValue);
			}
			break;
		case 1://前垛距
			{
				XCurveSegment seg;
				XPoint pt;
				GetNeighbourPoint(pt,true);
				wall.ProjectToMe(pt,pt);

				double oldValue=pt.Distance2d(GetGripPoint(iGrip));
				// sg modify 110120，根据8.5需求，夹点功能改变，默认为“单侧改宽”
				// if(GetCtrlToggle())//单侧改宽
				if(!GetCtrlToggle())//单侧改宽
				{
					newValue=m_nWidth-newValue+oldValue;
					if(newValue>1E-6)
					{
						vt*=((m_nWidth-newValue)/2);
						m_ptLocation+=vt;
						m_ptLabel+=vt;
						SetWidth(newValue);	
					}
				}
				else//整体偏移
				{
					vt*=(newValue-oldValue);
					m_ptLocation+=vt;
					m_ptLabel+=vt;
				}
			}
			break;
		case 2://总体偏移或起点偏移
			// sg modify 110120，根据8.5需求，夹点功能改变，默认为“单侧改宽”
			//if(GetCtrlToggle())//单侧改宽
			if(!GetCtrlToggle())//单侧改宽
			{
				if(vt.AsAcGeVector3d().dotProduct(offset)>0)
					newValue=m_nWidth-newValue;
				else
					newValue=m_nWidth+newValue;
				if(newValue>1E-6)
				{
					vt*=((m_nWidth-newValue)/2);
					m_ptLocation+=vt;
					m_ptLabel+=vt;
					SetWidth(newValue);	
				}
			}
			else//整体偏移
			{
				if(vt.AsAcGeVector3d().dotProduct(offset)>0)
					vt*=newValue;
				else
					vt*=-newValue;
				m_ptLocation+=vt;
				m_ptLabel+=vt;
			}
			break;
		}
		break;
	case 2://终点
		switch(iDim)
		{
		case 0://单侧改宽
			{
				vt*=((newValue-m_nWidth)/2);
				m_ptLocation+=vt;
				m_ptLabel+=vt;
				SetWidth(newValue);
			}
			break;
		case 1://后垛距
			{
				XCurveSegment seg;
				XPoint pt;
				GetNeighbourPoint(pt,false);
				wall.ProjectToMe(pt,pt);

				double oldValue=pt.Distance2d(GetGripPoint(iGrip));
				// sg modify 110120，根据8.5需求，夹点功能改变，默认为“单侧改宽”
				//if(GetCtrlToggle())//单侧改宽
				if(!GetCtrlToggle())//单侧改宽
				{
					newValue=m_nWidth-newValue+oldValue;
					if(newValue>1E-6)
					{
						vt*=((newValue-m_nWidth)/2);
						m_ptLocation+=vt;
						m_ptLabel+=vt;
						SetWidth(newValue);	
					}
				}
				else//整体偏移
				{
					vt*=(oldValue-newValue);
					m_ptLocation+=vt;
					m_ptLabel+=vt;
				}
			}
			break;
		case 2://总体偏移或终点偏移
			{
				// sg modify 110120，根据8.5需求，夹点功能改变，默认为“单侧改宽”
				//if(GetCtrlToggle())//单侧改宽
				if(!GetCtrlToggle())//单侧改宽
				{
					if(vt.AsAcGeVector3d().dotProduct(offset)>0)
						newValue=m_nWidth+newValue;
					else
						newValue=m_nWidth-newValue;
					if(newValue>1E-6)
					{
						vt*=((newValue-m_nWidth)/2);
						m_ptLocation+=vt;
						m_ptLabel+=vt;
						SetWidth(newValue);
					}
				}
				else//整体偏移
				{
					if(vt.AsAcGeVector3d().dotProduct(offset)>0)
						vt*=newValue;
					else
						vt*=-newValue;
					m_ptLocation+=vt;
					m_ptLabel+=vt;
				}
			}
			break;
		}
		break;
	}

	return Acad::eOk;
}
#endif 

// Stretch的夹点只有插入点和标号位置
Acad::ErrorStatus  TDbOpening::subGetStretchPoints(AcGePoint3dArray & stretchPoints) const
{
   stretchPoints.append(m_ptLocation);
   if (!!m_sLabel)
   {
       stretchPoints.append(m_ptLabel);
   }

   return Acad::eOk;
}

// Active when being rotated, scaled, moved, etc.
// 在全局旋转之后,仍然要保持旋转角度同墙体一致
Acad::ErrorStatus TDbOpening::subTransformBy(const AcGeMatrix3d& xform)
{
    assertWriteEnabled();
	TDbEntity::subTransformBy(xform);

	//修改原因 : 增加记录 boundary,hatch 命令涉及到的 动态变换矩阵 m_mat3d
	// 当AcDbBlockRef 中引用到门窗时,对于boundary,hatch 这样的边界分析命令,
	// 先调用 transformby,然后调用 ExplodeOrDraw2d时，对关联的墙分析有误,此时
	// 墙还没有transformby,导致门窗和墙关系不同步错误,boundary,hatch 分析乱线
	// 该矩阵不序列化
	//修改人 : lfy 2009-11-08
	m_mat3d.setToIdentity();
	struct resbuf rb;
	acedGetVar(_T("CMDNAMES"),&rb);
	CString sCmd = rb.resval.rstring;
	acutDelString(rb.resval.rstring);
	if (sCmd.CompareNoCase(_T("BHATCH") ) == 0 ||
		sCmd.CompareNoCase(_T("_BHATCH") ) == 0 ||
		sCmd.CompareNoCase(_T("BOUNDARY")) == 0||
		sCmd.CompareNoCase(_T("_BOUNDARY")) == 0||
		
		//add by xlc on 110304 解决弧墙上的门窗移动复制时飞线问题
		sCmd.CompareNoCase(_T("MOVE")) == 0||
		sCmd.CompareNoCase(_T("COPY")) == 0||
		sCmd.CompareNoCase(_T("_MOVE")) == 0||
		sCmd.CompareNoCase(_T("_COPY")) == 0
		)
	{
		m_mat3d = xform;
	}

    XPoint ptQuadrant;
    ads_polar(m_ptLocation, m_nRotation+m_nQuadrant*PI/2+PI/4, m_nWidth/2.0, ptQuadrant);

    AcGePoint3d &pt=m_ptLocation;
    pt.transformBy(xform);
    ((AcGePoint3d &)m_ptLabel).transformBy(xform);
	
    /*
    if(!!m_nIdOfWall) { 
        AcDbObjectIdArray idArray;
        if(acdbGetCurrentSelectionSet(idArray)!=Acad::eOk)
            return Acad::eInvalidInput;
        if(idArray.contains(m_nIdOfWall))  ; //墙也参与变换
        else { //墙没有参与变换
            XDbObject obj(m_nIdOfWall, AcDb::kForRead);
            if(!(!obj)) {
                TDbWall *pWall = TDbWall::cast(obj.m_pObject);
                m_nRotation = pWall->Direction(m_ptLocation);
            }
        }
    }*/
    XVector3D vtRot(cos(m_nRotation), sin(m_nRotation));
    ((AcGeVector3d &)vtRot).transformBy(xform);
    m_nRotation=ads_angle(XPoint(), vtRot);

    // 对开向控制点进行变换
    {
       ((AcGePoint3d &)ptQuadrant).transformBy(xform);
       ads_real nAng=CT_std_angle(ads_angle(m_ptLocation, ptQuadrant)-m_nRotation);
       if(nAng>=0.0 && nAng<PI/2.0) m_nQuadrant=0;
       else if(nAng>=PI/2.0 && nAng<PI) m_nQuadrant=1;
       else if(nAng>=PI && nAng<1.5*PI) m_nQuadrant=2;
       else m_nQuadrant=3;
    }

	ads_matrix mat;
	AsAdsMatrix(xform,mat);
	if(IsMirrorMatrix(mat))
	{
		if(HasLeftSlab()&&!HasRightSlab())
			SetSideSlab(3);
		else if(HasRightSlab()&&!HasLeftSlab())
			SetSideSlab(2);
	}
    return Acad::eOk;
}

// 功能: 夹点操作
// 方法: 
//    1. 移动插入点: 固定门窗在墙体的轨迹上移动
//    2. 拖曳镜像点: 用来改变开启方向
Acad::ErrorStatus TDbOpening::subMoveGripPointsAt(
    const AcDbIntArray& indices,
    const AcGeVector3d& offset)
{

    assertWriteEnabled();
    XPoint vtOffset=*(XPoint *)&offset;
    vtOffset.z = 0;

    double nSill=m_ptLocation.z;

    for (int i = 0; i < indices.length(); i++) {
        int idx = indices[i];
        switch(idx) {
            case 0:
            case 1: 
            case 2:
			{
				// 移动边界,单侧改宽度
				// sg modify 110120，根据8.5需求，夹点功能改变，默认为“单侧改宽”
                // if(idx==0 || !GetCtrlToggle())
                if(idx==0 || GetCtrlToggle()) // 移动位置
				{
                    XVector3D vt0=vtOffset;
                    if(g_bModelNumber && IsLinear()) {//模数开关
                        ASSERT(g_nWinStep>1.0E-3);
                        double nLen=vt0.Length();
                        vt0 /= nLen;
                        nLen = AS_INT(nLen/g_nWinStep)*g_nWinStep;
                        vt0 *= nLen;
                    }
                    XDbObject objWall(m_nIdOfWall, AcDb::kForRead);
                    TDbWall *pWall0 = !objWall? NULL : TDbWall::cast(objWall.m_pObject);
                    XPoint ptDest = m_ptLocation + vt0;
                    m_ptLocation += vt0;
                    m_ptLabel += vt0;
                    m_ptLocation.z = nSill;  //不改变窗台高度
                    m_ptLabel.z = 0;
                }
				else // 单侧改宽
				{
                    XPoint ptSideStart, ptSideEnd;
                    GetSidePoints(ptSideStart, ptSideEnd);
                    XPoint &ptSide = (idx==1? ptSideStart:ptSideEnd);
                    XPoint &ptOtherSide = (idx==1? ptSideEnd : ptSideStart);
                    ptSide += vtOffset;
                    OPENOBJ_BEGIN(m_nIdOfWall, AcDb::kForRead, TDbWall, pWall);
                    if(pWall) 
					{
						// sg modify 110127，获得墙体基线时，考虑保温厚，放置门窗对象拖拽夹点后发生宽度错误
						// XCurveSegment segCenter=pWall->OffsetGeomCenter();
						XCurveSegment segCenter=pWall->OffsetGeomCenter(LS_INFINITE, TRUE);
                        segCenter.SetElevation(m_ptLocation.z);
                        segCenter.ProjectToMe(XPoint(ptSide), ptSide);
                    }
                    OPENOBJ_END();
                    if(g_bModelNumber && IsLinear()) {//模数开关
                        ASSERT(g_nWinStep>1.0E-3);
                        double nAng=ads_angle(ptOtherSide, ptSide);
                        double nSize=ads_distance(ptOtherSide, ptSide);
                        nSize = AS_INT(nSize/g_nWinStep)*g_nWinStep;
                        ads_polar(ptOtherSide, nAng, nSize, ptSide);
                    }
                    SetSidePoints(ptSideStart, ptSideEnd);
                }
                    }
                break;
            case 3:  {//Move quadrant point
               XPoint ptQuadrant;
               ads_polar(m_ptLocation, m_nRotation+m_nQuadrant*PI/2+PI/4, m_nWidth/2.0, ptQuadrant);
               ptQuadrant += vtOffset;
               ptQuadrant.z = nSill;
               int nOldQuadrant=m_nQuadrant;
               ads_real nAng=CT_std_angle(ads_angle(m_ptLocation, ptQuadrant)-m_nRotation);
               if(nAng>=0.0 && nAng<PI/2.0) m_nQuadrant=0;
               else if(nAng>=PI/2.0 && nAng<PI) m_nQuadrant=1;
               else if(nAng>=PI && nAng<1.5*PI) m_nQuadrant=2;
               else m_nQuadrant=3;
               // 假如由0/1变为2/3，或由2/3变为0/1，着对标号位置进行镜像
               if((nOldQuadrant<2 && m_nQuadrant>=2) || (nOldQuadrant>=2 && m_nQuadrant<2)) {
                    XLine ln(m_ptLocation, m_nRotation);
                    ln.SetElevation(m_ptLabel.z);
                    XPoint ptPrj;
                    if(m_ptLabel.Project(&ln, ptPrj)==RTNORM) {
                        ptPrj.Mirror(XPoint(m_ptLabel), m_ptLabel);
                    }

					//add by xlc on 110215 调整单侧门口线开启侧
					if (!(
						(m_nOpStyleEx & OPS_DOORLINE_MID)								//居中
						|| (m_nOpStyle & (OPS_DOORLINE1+OPS_DOORLINE2)) == 0			//无门口线
						|| (m_nOpStyle | (OPS_DOORLINE1+OPS_DOORLINE2)) == m_nOpStyle	//双侧门口线
						)
						)
					{
						if (m_nOpStyle & OPS_DOORLINE1)
						{
							m_nOpStyle &= ~OPS_DOORLINE1;
						}
						else
						{
							m_nOpStyle |= OPS_DOORLINE1;
						}
						if (m_nOpStyle & OPS_DOORLINE2)
						{
							m_nOpStyle &= ~OPS_DOORLINE2;
						}
						else
						{
							m_nOpStyle |= OPS_DOORLINE2;
						}
					}
               }
                     }
                break;
            case 4: // move label
                m_ptLabel += vtOffset;
                break;
        }
    }
    return Acad::eOk;
}

//  取夹点的说明
Acad::ErrorStatus TDbOpening::GetGripText(int i, CString &cs) const
{
    Acad::ErrorStatus es=Acad::eOk;
    switch(i) {
    case 0: 
        cs=_T("移动门窗");
        break;
    case 1:
    case 2: {
		// sg modify 110120，根据8.5需求，夹点功能改变，默认为“单侧改宽”
        // cs=GetCtrlToggle()? _T("单侧改宽(Ctrl-移动门窗)") : _T("移动门窗(Ctrl-单侧改宽)");
        cs=GetCtrlToggle() ? _T("移动门窗(Ctrl-单侧改宽)") : _T("单侧改宽(Ctrl-移动门窗)");
            }
        break;
    case 3:
        cs=_T("改变开启方向");
        break;
    case 4:
        cs=_T("改变编号位置");
        break;
    default:
        es=Acad::eInvalidInput;
    }
    return es;
}

Acad::ErrorStatus 
TDbOpening::DownGradeSave(int nDrawMode, AcDbVoidPtrArray &entSet, BOOL *bErase)
{
	if(g_nSaveTArchVer==5)
	{
		Acad::ErrorStatus es=Acad::eOk;
		if((nDrawMode&DRAW_2D) && GetKind()==TOpeningData::OP_DOOR) 
		{ //门口线
			XExplodeStream dc(entSet);
			dc.SetPropertiesFrom(this);//add by whl on 060218
			DrawDoorLine(dc);
		}
	}


	return TDbEntity::DownGradeSave(nDrawMode,entSet,bErase);
}

int TDbOpening::ConvertText(TConvertTextPtr ptr, void *pData)
{
    XString sText;
     int nRet=ptr(m_sLabel, sText, pData);
     if(nRet==RTNORM) {
         assertWriteEnabled();
         m_sLabel=sText;
     }
     return nRet;
}

void TDbOpening::GetLabelText(TDbText &text) const
{
    AcDbObjectId idTextStyle=m_idTextStyle;
	if(!idTextStyle.isValid())
		idTextStyle=InitTextStyle(TS_WINDOW,database());
    XString sStyleName=GetSymbolName(idTextStyle);
	text.SetStyleId(idTextStyle);
	text.setPropertiesFrom(this);
	text.SetHeight(m_nTextHeight);
    text.SetAlignment(XExplodeDraw::kMiddleCenter);
    text.SetLocation(XPoint(m_ptLabel.x, m_ptLabel.y));
    double nRotLabel=m_nRotation;

        if(GetKind()==OP_CORNWIN || GetKind()==OP_ARCWIN) {
            if(!!m_nIdOfWall) {
                OPENOBJ_BEGIN(m_nIdOfWall, AcDb::kForRead, TDbWall, pWall);
                if(pWall && pWall->Is(CURVE_ARC)) {
                    XArc ar=pWall->GetArc();
                    nRotLabel=CT_std_angle(ads_angle(ar.GetCenterPt(), m_ptLabel)-PI/2);
                }
                OPENOBJ_END();
            }
        }
        text.SetRotation(xg_angle(nRotLabel));

	text.SetText(m_sLabel);
}

// 返回发现的位置，同时posStart往前移动(以便继续找下一个使用),
TTextPosition  
TDbOpening::FindSubText(const TCHAR *sSubText, TTextPosition &posStart, TTextRange *pRange) const
{
	assertReadEnabled();
	TDbText text;
	GetLabelText(text);
	TTextPosition pos=text.FindSubText(sSubText, posStart, pRange);
	return pos;
}

// 返回下一次查找的开始位置
TTextPosition  
TDbOpening::ReplaceSubText(const TTextPosition &posRep, const TCHAR *sRepText, TTextRange *pRange)
{
	assertWriteEnabled();
	TDbText text;
	GetLabelText(text);
	TTextPosition pos=text.ReplaceSubText(posRep, sRepText, pRange);
	SetLabel(text.GetText());
	return pos;
}

// 功能: 夹点操作
Acad::ErrorStatus TDbOpening::subMoveStretchPointsAt(
    const AcDbIntArray& indices,
    const AcGeVector3d& offset)
{
    assertWriteEnabled();
    XPoint vtOffset=*(XPoint *)&offset;
    vtOffset.z=0;
    for (int i = 0; i < indices.length(); i++) {
        int idx = indices[i];
        switch(idx) {
        case 0:  // InsertPoint
            m_ptLocation += vtOffset;
            break; 
        case 1:
            m_ptLabel += vtOffset;
            break;
        }
    }
    return Acad::eOk;
}

//通知墙体已经被修改过
Acad::ErrorStatus TDbOpening::subClose()
{
   Acad::ErrorStatus es = TDbEntity::subClose();
    if(es==Acad::eOk && !(!m_nIdOfWall) && isModified() && database()==acdbCurDwg()) 
	{
        OPENOBJ_BEGIN(m_nIdOfWall, AcDb::kForRead, TDbWall, pWall);
        if(pWall)
		{
			if(!pWall->isModified())
			{
				if(pWall->upgradeOpen()==Acad::eOk)
					pWall->recordGraphicsModified();
			}
		}
        OPENOBJ_END();
    }
    return es;
}

// 解除同墙体之间的引用关系
Acad::ErrorStatus TDbOpening::subErase(Adesk::Boolean bErasing)
{
	extern BOOL SkipSubErase(const TCHAR *szCmd);
    Acad::ErrorStatus es = TDbEntity::subErase(bErasing);
    if(es==Acad::eOk && bErasing==Adesk::kTrue && !(!m_nIdOfWall)) {
#if (ADS>14)
        XString &sCmd=GetCurDocData()->m_sCurCommand;
#else
        XString &sCmd=TArchCmdReactor::g_sCurCommand;
#endif
        if(!TchPrivate::SkipSubErase(sCmd)) {
            XDbObject obj(m_nIdOfWall, AcDb::kForWrite);
            if(!(!obj)) {
                TDbWall *pWall = TDbWall::cast(obj.m_pObject);
                if(pWall) 
                    pWall->RemoveReferenceOpening(objectId());
            }
        }
    }
    return es;
}

Acad::ErrorStatus TDbOpening::subOpen(AcDb::OpenMode mode)
{
    Acad::ErrorStatus es=TDbEntity::subOpen(mode);
	extern BOOL g_bMonitorDbAction;
    if(es==Acad::eOk && mode==AcDb::kForWrite &&!isNewObject()&& database()==acdbCurDwg() && g_bDwgBegin && TchGeLib::g_bMonitorDbAction) 
		BackupPoints();
	return es;
}

BOOL TDbOpening::DrawDoorOrWin3d(XExplodeDraw &dc, const XLine &lnPos, BOOL bDoor) const
{
	//TPushProperty vProp(this, dc);
    AcDbObjectId idStyle=bDoor? m_nIdStyle2d : m_nIdStyle3d;
    XPoint origenalSize;
    if(!GetOriginal3DSize(idStyle, origenalSize))
        return FALSE;
    double nScaleX, nScaleY, nScaleZ;
    nScaleX = origenalSize.x>_DIST_SNAP? (lnPos.GetLength()/origenalSize.x) : 1.0;
    nScaleY = 1.0; //origenalSize.y>_DIST_SNAP? (m_nThickness/origenalSize.y) : 1.0;
    double nSizeZ=(bDoor? m_nHeight:m_nWinHeight);
    if(m_opKind==OP_TWODOOR)
        nSizeZ=m_nHeight;
    nScaleZ = origenalSize.z>_DIST_SNAP? (nSizeZ/origenalSize.z) : 1.0;
    if(origenalSize.y>origenalSize.x/2.0) //旋转门
           nScaleY=nScaleX;
    XPoint ptIns;
    OPENOBJ_BEGIN(idStyle, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
    if(!pBlock)
        return FALSE;
    ptIns = lnPos.MidPoint();
    OPENOBJ_END();
	dc<<XBlockRef(idStyle, ptIns, AcGeScale3d(nScaleX, nScaleY, nScaleZ), m_nRotation, g_bMakeBlock);
    return TRUE;
}

// 绘制或分解子母门
void TDbOpening::ExplodeOrDrawTwoDoor(XExplodeDraw &dc, BOOL bDraw3d) const
{
    //double nWinWidth=m_nWidth-m_nDoorWidth;
    double nWidth2=m_nDoorWidth; //大门
    double nWidth1=m_nWidth-m_nDoorWidth;
    ASSERT(nWidth1>_DIST_SNAP);
    XPoint ptArray[5];
    XPoint ptBase=m_ptLocation;
    ptBase.z=0.0;
    ads_polar(ptBase, m_nRotation+PI, m_nWidth/2, ptArray[0]);
    ads_polar(ptArray[0], m_nRotation, nWidth1, ptArray[1]);
    ads_polar(ptBase, m_nRotation, m_nWidth/2, ptArray[2]);
    ads_polar(ptArray[0], m_nRotation+PI/2, nWidth1, ptArray[3]);
    ads_polar(ptArray[2], m_nRotation+PI/2, nWidth2, ptArray[4]);

    AcDbPolyline pline;
    pline.setPropertiesFrom(this);
    pline.addVertexAt(0, ptArray[0]);
    pline.addVertexAt(1, ptArray[3], -tan(PI/8));
    pline.addVertexAt(2, ptArray[1], -tan(PI/8));
    pline.addVertexAt(3, ptArray[4]);
    pline.addVertexAt(4, ptArray[2]);

    AcGeMatrix3d mat;
    if(m_nQuadrant==1) {
        AcGeLine3d ln(ptBase, AcGeVector3d(cos(m_nRotation+PI/2),sin(m_nRotation+PI/2),0));
        mat.setToMirroring(ln);
        VERIFY(pline.transformBy(mat)==Acad::eOk);
    } else if(m_nQuadrant==2) {
        mat.setToMirroring(ptBase);
        VERIFY(pline.transformBy(mat)==Acad::eOk);
    } else if(m_nQuadrant==3) {
        AcGeLine3d ln(ptBase, AcGeVector3d(cos(m_nRotation),sin(m_nRotation),0));
        mat.setToMirroring(ln);
        VERIFY(pline.transformBy(mat)==Acad::eOk);
    }

    if(bDraw3d) {
        XPoint pt0, pt1, pt2;
        pline.getPointAt(0, (AcGePoint3d &)pt0);
        pline.getPointAt(2, (AcGePoint3d &)pt1);
        pline.getPointAt(4, (AcGePoint3d &)pt2);
        XLine ln1(pt0,pt1), ln2(pt1, pt2);
        ln1.SetElevation(m_ptLocation.z);
        ln2.SetElevation(m_ptLocation.z);
        DrawDoorOrWin3d(dc, ln1, FALSE);
        DrawDoorOrWin3d(dc, ln2, TRUE);
    } else {
        dc.DrawEntity(pline);
    }
}

// 绘制或分解门联窗
void TDbOpening::ExplodeOrDrawDoorWin(XExplodeDraw &dc, BOOL bDraw3d) const
{
    double nWinWidth=m_nWidth-m_nDoorWidth;
    ASSERT(nWinWidth>0);
    double nWallThick=GetWallThickness(TRUE);
    if(m_nQuadrant==0 || m_nQuadrant==3) {
        // 画窗
        XPoint ptWinSide[2];
        ads_polar(m_ptLocation, m_nRotation+PI, m_nWidth/2, ptWinSide[0]);
        ads_polar(ptWinSide[0], m_nRotation, nWinWidth, ptWinSide[1]);
        ptWinSide[0].z=ptWinSide[1].z=bDraw3d? m_ptLocation.z+m_nHeight-m_nWinHeight : 0.0;
        XLine lnMidWin(ptWinSide[0], ptWinSide[1]);
        if(!bDraw3d || !DrawDoorOrWin3d(dc, lnMidWin, FALSE)) {
			if(bDraw3d)
			{
				dc.DrawLine(lnMidWin.Offset(nWallThick/6), m_nWinHeight);
				dc.DrawLine(lnMidWin.Offset(-nWallThick/6), m_nWinHeight);
			}
			else
			{
   				dc<<lnMidWin.Offset(nWallThick/6);
				dc<<lnMidWin.Offset(-nWallThick/6);
	            XLine ln1=lnMidWin.Offset(nWallThick/2), ln2=lnMidWin.Offset(-nWallThick/2);
                dc << ln1 << ln2 << XLine(ln1.EndPoint(), ln2.EndPoint());
            }
        }

        // 画门
        XPoint ptDoorSide, ptTemp, ptDoorOtherSide;
        ads_polar(m_ptLocation, m_nRotation, m_nWidth/2, ptDoorSide);
        ads_polar(ptDoorSide, m_nRotation+PI, m_nDoorWidth, ptDoorOtherSide);
        if(!bDraw3d || !DrawDoorOrWin3d(dc, XLine(ptDoorSide, ptDoorOtherSide), TRUE)) {
            if(!bDraw3d)
                ptDoorSide.z=0;
            ads_polar(ptDoorSide, m_nRotation + (m_nQuadrant==0? PI/2.0 : -PI/2.0), m_nDoorWidth, ptTemp);
            XArc ar(ptDoorSide, m_nDoorWidth,
                CT_std_angle(m_nRotation+ (m_nQuadrant==0? PI/2 : PI)),
                CT_std_angle(m_nRotation+ (m_nQuadrant==0? PI : -PI/2)));

			if(bDraw3d)
			{
				dc.DrawArc(ar, m_nHeight);
				dc.DrawLine(XLine(ptDoorSide, ptTemp), m_nHeight);
			}
			else
			{
				dc<<ar;
				dc<<XLine(ptDoorSide, ptTemp);
			}
        }
    } else {
        // 画窗
        XPoint ptWinSide[2];
        ads_polar(m_ptLocation, m_nRotation, m_nWidth/2, ptWinSide[1]);
        ads_polar(ptWinSide[1], m_nRotation+PI, nWinWidth, ptWinSide[0]);
        ptWinSide[0].z=ptWinSide[1].z=bDraw3d? m_ptLocation.z+m_nHeight-m_nWinHeight : 0.0;
        XLine lnMidWin(ptWinSide[0], ptWinSide[1]);
        if(!bDraw3d || !DrawDoorOrWin3d(dc, lnMidWin, FALSE)) {
			if(bDraw3d)
			{
				dc.DrawLine(lnMidWin.Offset(nWallThick/6), m_nWinHeight);
				dc.DrawLine(lnMidWin.Offset(-nWallThick/6), m_nWinHeight);
			}
			else
			{
				dc<<lnMidWin.Offset(nWallThick/6);
				dc<<lnMidWin.Offset(-nWallThick/6);

                XLine ln1=lnMidWin.Offset(nWallThick/2), ln2=lnMidWin.Offset(-nWallThick/2);
                dc << ln1 << ln2 << XLine(ln1.StartPoint(), ln2.StartPoint());
            }
        }

        // 画门
        XPoint ptDoorSide, ptTemp, ptDoorOtherSide;
        ads_polar(m_ptLocation, m_nRotation+PI, m_nWidth/2, ptDoorSide);
        ads_polar(ptDoorSide, m_nRotation, m_nDoorWidth, ptDoorOtherSide);
        if(!bDraw3d || !DrawDoorOrWin3d(dc, XLine(ptDoorSide, ptDoorOtherSide), TRUE)) {
            if(!bDraw3d)
                ptDoorSide.z=0;
            ads_polar(ptDoorSide, m_nRotation + (m_nQuadrant==1? PI/2.0 : -PI/2.0), m_nDoorWidth, ptTemp);
            XArc ar(ptDoorSide, m_nDoorWidth,
                CT_std_angle(m_nRotation+ (m_nQuadrant==1? 0.0 : -PI/2)),
                CT_std_angle(m_nRotation+ (m_nQuadrant==1? PI/2 : 0.0)));

			if(bDraw3d)
			{
				dc.DrawArc(ar, m_nHeight);
				dc.DrawLine(XLine(ptDoorSide, ptTemp), m_nHeight);
			}
			else
			{
				dc<<ar;
				dc<<XLine(ptDoorSide, ptTemp);
			}
        }
    }    
}


//add by xlc on 120510 解决丁字行墙上的带形窗豁口问题
//判断两条曲线在pt点处方向是否相同
BOOL TDbOpening::IsSameDrtAtPt(const TGGeCurveSegment& cvThis, const TGGeCurveSegment& cvThat, const TADSGePoint3d& pt) const
{
	double dDirThis = cvThis.Direction(pt);
	double dDirThat = cvThat.Direction(pt);

	return IsSameDrt(dDirThis, dDirThat, sin(PI / 36));
}

// 求带窗的5条关键线
BOOL TDbOpening::GetBanWinSegs(XCurveSegment &segLeftSide, XCurveSegment &segLeft,
		XCurveSegment &segMid, XCurveSegment &segRight, XCurveSegment &segRightSide) const
{
   XPoint ptStart, ptEnd;
   GetSidePoints(ptStart, ptEnd);
   OPENOBJ_BEGIN(m_nIdOfWall, AcDb::kForRead, TDbWall, pWall);
   if(!pWall) {
        return FALSE;
   }
   pWall->ProjectToMe(XPoint(ptStart), ptStart);
   pWall->ProjectToMe(XPoint(ptEnd), ptEnd);

   segMid = pWall->GetFinalOffsetCurveFromCenter(OFFSET_LEFT, 0.0);
   segLeft = pWall->GetFinalOffsetCurveFromCenter(OFFSET_LEFT, 1.0/6.0);
   segRight = pWall->GetFinalOffsetCurveFromCenter(OFFSET_RIGHT, 1.0/6.0);
   
   //modify by xlc on 110311 墙材料不同时墙边线计算有误
   //pWall->GetSideCurve(segLeftSide, segRightSide, 0.0, TRUE);
   pWall->GetStandardCurve(segLeftSide, segRightSide, 0.0, TRUE);

   XPoint ptLeftStart = segLeft.StartPoint(),
         ptLeftEnd = segLeft.EndPoint(),
         ptRightStart = segRight.StartPoint(),
         ptRightEnd = segRight.EndPoint(),
         ptMidStart=segMid.StartPoint(),
         ptMidEnd=segMid.EndPoint(),
         ptLeftSideStart = segLeftSide.StartPoint(),
         ptLeftSideEnd = segLeftSide.EndPoint(),
         ptRightSideStart = segRightSide.StartPoint(),
         ptRightSideEnd = segRightSide.EndPoint();
   BOOL bAcrossStart=FALSE, bAcrossEnd=FALSE;
   if(ptStart.Distance2d(pWall->StartPoint())<_DIST_SNAP) {
       if(!!pWall->m_idLeftStart) {
           OPENOBJ_BEGIN(pWall->m_idLeftStart, AcDb::kForRead, TDbWall, pLeftStart);
           if(pLeftStart && pLeftStart->HasCornerWinAcrossPoint(ptStart))
		   {
			   //add by xlc on 120510 解决丁字形墙上带形窗缺口问题
			   //转角处两个窗户平行时不作为转角窗处理
			   if (!IsSameDrtAtPt(*pWall, *pLeftStart, ptStart))

			   {
					bAcrossStart=TRUE;
			   }
		   }
           OPENOBJ_END();
       }
       if(!!pWall->m_idRightStart) {
           OPENOBJ_BEGIN(pWall->m_idRightStart, AcDb::kForRead, TDbWall, pRightStart);
           if(pRightStart && pRightStart->HasCornerWinAcrossPoint(ptStart))
		   {
			   //add by xlc on 120510 解决丁字形墙上带形窗缺口问题
			   //转角处两个窗户平行时不作为转角窗处理
			   if (!IsSameDrtAtPt(*pWall, *pRightStart, ptStart))

			   {
					bAcrossStart=TRUE;
			   }
		   }
           OPENOBJ_END();
       }
   }
   if(ptEnd.Distance2d(pWall->EndPoint())<_DIST_SNAP) {
       if(!!pWall->m_idLeftEnd) {
           OPENOBJ_BEGIN(pWall->m_idLeftEnd, AcDb::kForRead, TDbWall, pLeftEnd);
           if(pLeftEnd && pLeftEnd->HasCornerWinAcrossPoint(ptEnd))
		   {
			   //add by xlc on 120510 解决丁字形墙上带形窗缺口问题
			   //转角处两个窗户平行时不作为转角窗处理
			   if (!IsSameDrtAtPt(*pWall, *pLeftEnd, ptEnd))

			   {
					bAcrossEnd=TRUE;
			   }
		   }
           OPENOBJ_END();
       }
       if(!!pWall->m_idRightEnd) {
           OPENOBJ_BEGIN(pWall->m_idRightEnd, AcDb::kForRead, TDbWall, pRightEnd);
           if(pRightEnd && pRightEnd->HasCornerWinAcrossPoint(ptEnd))
		   {
			   //add by xlc on 120510 解决丁字形墙上带形窗缺口问题
			   //转角处两个窗户平行时不作为转角窗处理
			   if (!IsSameDrtAtPt(*pWall, *pRightEnd, ptEnd))

			   {
					bAcrossEnd=TRUE;
			   }
		   }
           OPENOBJ_END();
       }
   }

   if(!bAcrossStart) {//不在起角点
       segLeft.ProjectToMe(ptStart, ptLeftStart);
       segRight.ProjectToMe(ptStart, ptRightStart);
       segMid.ProjectToMe(ptStart, ptMidStart);
       segLeftSide.ProjectToMe(ptStart, ptLeftSideStart);
       segRightSide.ProjectToMe(ptStart, ptRightSideStart);
   }
   if(!bAcrossEnd) {//不在终角点
       segLeft.ProjectToMe(ptEnd, ptLeftEnd);
       segRight.ProjectToMe(ptEnd, ptRightEnd);
       segMid.ProjectToMe(ptEnd, ptMidEnd);
       segLeftSide.ProjectToMe(ptEnd, ptLeftSideEnd);
       segRightSide.ProjectToMe(ptEnd, ptRightSideEnd);
   }

   segLeft.SetPoints(ptLeftStart, ptLeftEnd);
   segRight.SetPoints(ptRightStart, ptRightEnd);
   segMid.SetPoints(ptMidStart, ptMidEnd);
   segLeftSide.SetPoints(ptLeftSideStart, ptLeftSideEnd);
   segRightSide.SetPoints(ptRightSideStart, ptRightSideEnd);
   OPENOBJ_END();

   double nElev=0.0;
   segLeft.SetElevation(nElev);
   segRight.SetElevation(nElev);
   segLeftSide.SetElevation(nElev);
   segRightSide.SetElevation(nElev);
   segMid.SetElevation(nElev);

   return TRUE;
}

// 绘制带窗
BOOL TDbOpening::DrawBanWin(XExplodeDraw &dc, BOOL bDraw3d) const
{
	XCurveSegment segLeftSide, segLeft, segMid, segRight, segRightSide;
	if(!GetBanWinSegs(segLeftSide, segLeft, segMid, segRight, segRightSide))
		return FALSE;
   double nThick= bDraw3d? m_nHeight:0.0;
   double nElev=bDraw3d? GetElevation() : 0.0;
   segLeft.SetElevation(nElev);
   segRight.SetElevation(nElev);
   segLeftSide.SetElevation(nElev);
   segRightSide.SetElevation(nElev);
   segMid.SetElevation(nElev);

   if(bDraw3d) {
	   TMasterProperties prop;
	   dc.BackUpProperties(prop);
	   dc.SetColorLayer(colorIndex(), m_idLayerGlass3d);
       dc.DrawCurve(segMid, nThick);
	   dc.RestoreProperties(prop);
	   // 绘制窗框
	   dc.SetColorLayer(colorIndex(), m_idLayerFrame3d);
	   XPoly2D polyGlass;
	   segMid.AsPoly2D(polyGlass);
	   DrawFrame3d(dc, polyGlass);
	   dc.RestoreProperties(prop);
   }
   else
   {
/*
       if (GetPScale()>g_nCurtainWall3Scale+1.0E-3)
	   {
           dc<<segMid;
       }
	   else
	   {
           dc<<segLeft;
           dc<<segRight;
       }
*/
	   // sg modify 090609，带形窗根据样式绘制
	   if (g_bCurtainWallFixStyle) // 固定样式
	   {
		   if (g_nCurtainWallStyle == 0) // 固定为三线
		   {
			   dc<<segMid;
		   }
		   else // 固定四线
		   {
			   dc<<segLeft;
			   dc<<segRight;
		   }
	   }
	   else // 随比例改变样式
	   {
		   if (GetPScale()>g_nCurtainWall3Scale+1.0E-3)
		   {
			   dc<<segMid;
		   }
		   else
		   {
			   dc<<segLeft;
			   dc<<segRight;
		   }
	   }

       dc<<segLeftSide;
       dc<<segRightSide;
   }
	return TRUE;
}

void TDbOpening::SetSideSlab(int type)
{
	assertWriteEnabled();
	if(type==0)
	{
		m_nOpStyleEx&=~OPSEX_RIGHT_SLAB;
		m_nOpStyleEx&=~OPSEX_LEFT_SLAB;
	}
	else if(type==1)
	{
		m_nOpStyleEx|=OPSEX_RIGHT_SLAB;
		m_nOpStyleEx|=OPSEX_LEFT_SLAB;
	}
	else if(type==2)
	{
		m_nOpStyleEx&=~OPSEX_RIGHT_SLAB;
		m_nOpStyleEx|=OPSEX_LEFT_SLAB;
	}
	else
	{
		m_nOpStyleEx|=OPSEX_RIGHT_SLAB;
		m_nOpStyleEx&=~OPSEX_LEFT_SLAB;
	}
}

// 绘制凸窗二维
BOOL TDbOpening::DrawBayWindow2d(XExplodeDraw &dc) const
{
	if (!m_pBayWin)
		return FALSE;
	if (m_opKind != OP_PROWIN)
		return FALSE;

	double nWallThick = 200;
	// wlw add 100913
	double dWallInsut = 0.0; // 墙线保温厚度
	double dInsutAdd = 0.0;	 // 内保温加挡板时，由于挡板后退，补豁口

	XPoint ptLoc = m_ptLocation;
	TADSGePoint3d ptDir;
	ptLoc.z = 0;

	double nExtDir = m_nRotation + (m_nQuadrant<2 ? PI/2.0 : -PI/2.0);

	// sg modify 120605，标记保温类型
	int nInsulateType = 0;

	OPENOBJ_BEGIN(m_nIdOfWall, AcDb::kForRead, TDbWall, pWall);
	if (pWall)
	{
		nWallThick = pWall->GetWidth(4);
		ads_polar(ptLoc, nExtDir, 10000, ptDir);
	
		int nSide = pWall->OnWhichSide(ptDir);
		// 得到外保温厚度
		if (pWall->IsInsulateOnSide(nSide))
		{
			dWallInsut = pWall->GetInsulateThick(nSide);
			if (DocGetProWinSlabInsu())
			{
				// 外墙和内墙同时使用这一个参数，所以内外只能有一种保温存在
				dInsutAdd = GetSlotInsulateThick();
				nInsulateType = 1;
			}
		}

		// 如果有内保温需要补豁口
		ads_polar(ptLoc, nExtDir, -10000, ptDir);
		if (pWall->IsInsulateOnSide(pWall->OnWhichSide(ptDir)))
		{
			dInsutAdd = GetSlotInsulateThick();
			nInsulateType = (nInsulateType==1) ? 2 : 1;
		}

	}
	OPENOBJ_END();

	// wlw add 100913
	DList<XPoly2D> polyCurves;
	// m_pBayWin->GetPolyCurve(ptLoc, nExtDir, m_nWidth, nWallThick, HasLeftSlab(), HasRightSlab(), polyCurves, dWallInsut, dInsutAdd);
	m_pBayWin->GetPolyCurve(ptLoc, nExtDir, m_nWidth, nWallThick, HasLeftSlab(), HasRightSlab(), polyCurves, dWallInsut, dInsutAdd, nInsulateType==2);
	for (int idx=0; idx<polyCurves.Length(); idx++)
		dc << *polyCurves[idx];

	if (GetSill()>_DIST_SNAP) // 有窗台
	{
		XPoint ptSide1, ptSide2;
		GetSidePoints(ptSide1, ptSide2);

		ads_polar(XPoint(ptSide1), nExtDir-PI, nWallThick/2.0, ptSide1);
		ads_polar(XPoint(ptSide2), nExtDir-PI, nWallThick/2.0, ptSide2);
		ptSide1.z = ptSide2.z = 0;

		double dLine = 0.0;
		m_XDataMap.GetAt(sKEY_OP_PROWIN_LINE, dLine);
		if (dLine < 0.01)
		{
			dc << XLine(ptSide1, ptSide2);
		}
	}
	return TRUE;
}

void TDbOpening::DrawDoorLine(XExplodeDraw &dc) const
{
	// add by xlc on 110222 无门口线时不计算
	if ((m_nOpStyleEx & OPS_DOORLINE_MID)	//门口线居中
		|| (m_nOpStyle&OPS_DOORLINE1)		//门口线单侧
		|| (m_nOpStyle&OPS_DOORLINE2))		//门口线单侧
	{
	}
	else
	{
		return;
	}

	TADSGePoint3d ptSide1, ptSide2;
	GetSidePoints(ptSide1, ptSide2);
	OPENOBJ_BEGIN(m_nIdOfWall, AcDb::kForRead, TDbWall, pDbWall);
	if (pDbWall)
	{
		double dWallThick = pDbWall->GetWidth(4);
		TGGeLine ln1,ln2;
		TGGeLine lnMid(ptSide1, ptSide2);
		TGGeCurveSegment cv1,cv2;
		TGGeCurveSegment segMid = pDbWall->OffsetGeomCenter(LS_FINITE, TRUE);

		// modify by xlc on 110214 增加门口线偏移距离和居中功能
		//cv1 = segMid.Offset(dWallThick / 2.0, LS_FINITE); 
		//cv2 = segMid.Offset(-dWallThick / 2.0, LS_FINITE);
		//ln1 = lnMid.Offset(dWallThick / 2.0);
		//ln2 = lnMid.Offset(-dWallThick / 2.0);
		if (m_nOpStyleEx & OPS_DOORLINE_MID)	//门口线居中
		{
			segMid.SetPoints(ptSide1, ptSide2);
			dc << segMid;
			return;
		}		
		double dOffsetDist = GetDoorLineOffsetDist();
		cv1 = segMid.Offset(dWallThick / 2.0 - dOffsetDist, LS_FINITE); 
		cv2 = segMid.Offset(-dWallThick / 2.0 + dOffsetDist, LS_FINITE);
		ln1 = lnMid.Offset(dWallThick / 2.0 - dOffsetDist);
		ln2 = lnMid.Offset(-dWallThick / 2.0 + dOffsetDist);
		cv1.SetPoints(ln1.StartPoint(), ln1.EndPoint());
		cv2.SetPoints(ln2.StartPoint(), ln2.EndPoint());

		AcGePoint3dArray gripPoints;
		AcDbIntArray ar;
		if (subGetGripPoints(gripPoints, ar, ar) == Acad::eOk && gripPoints.length() >= 4)
		{
			TADSGePoint3d ptGrip=gripPoints[3];
			ptGrip.z=0;

			segMid.SetElevation(0.0);
			int nSideGrip = segMid.OnWhichSide(ptGrip);
			TADSGePoint3d ptMid;
			if (dWallThick / 2.0 - dOffsetDist > -_DIST_SNAP)
			{
				ptMid = cv1.MidPoint();
			}
			else
			{
				ptMid = cv2.MidPoint();
			}
			int nSide1 = segMid.OnWhichSide(ptMid);

			if ((m_nOpStyle&OPS_DOORLINE1))
			{
				if(nSide1 != nSideGrip)
				{
					dc << cv2;
				}
				else 
				{
					dc << cv1;
				}
			}
			if (m_nOpStyle&OPS_DOORLINE2)
			{
				if(nSide1 != nSideGrip)
				{
					dc << cv1;
				}
				else
				{
					dc << cv2;
				}
			}
		}
	}
	OPENOBJ_END();
}

bool TDbOpening::IsClipMe(const TEntityBase* pEnt)const
{
	// 在此进行CAD平台判断
	//TCHAR strVer[20];
	//TGGetVar(_T("ACADVER"), strVer);
	//CString str = strVer;
	//str = str.Left(4);
	//if (_T("19.1") == str)	// 如果是 cad2014 则退出
	//	return false;//wlw cad2014崩溃

	if(TDbEntity::IsClipMe(pEnt))
		return true;

	if(GetKind()==OP_PROWIN)
	{
		if(pEnt->GetMe()->isKindOf(TDbColumn::desc())||//柱裁剪
		   pEnt->GetMe()->isKindOf(TDbWallPatch::desc()))//墙体造型裁剪
			return true;

		TDbWall*pWall=TDbWall::cast(pEnt->GetMe());
		if(pWall!=NULL)
		{
			if(pWall->GetUsageFlag()!=TDbWall::kVirtual&&//不是虚墙
			   GetWallId()!=pWall->objectId())//不在墙上
				return true;

			return false;
		}
	}
	return false;
}

Acad::ErrorStatus TDbOpening::GetClipBoundary(XPoly2D& poly)const
{
	if (GetKind()==OP_PROWIN && m_pBayWin!=NULL)
	{
		OPENOBJ_BEGIN(m_nIdOfWall, AcDb::kForRead, TDbWall, pWall);
		if (pWall)
		{
			XPoint ptLoc = m_ptLocation;
			ptLoc.z = m_ptLocation.z;
			double nWallThick = pWall->GetWidth(4);
			double nExtDir = m_nRotation + (m_nQuadrant<2? PI/2.0 : -PI/2.0);

			// add by xlc on 110624 解决墙上有保温时梯形凸窗，三角凸窗，圆弧凸窗裁剪散水出错的问题
			if (m_pBayWin)
			{
				if (m_pBayWin->m_nStyle == XBayWindow::BWS_TRIANGLE
					|| m_pBayWin->m_nStyle == XBayWindow::BWS_TRAPEZIA
					|| m_pBayWin->m_nStyle == XBayWindow::BWS_ARC)
				{
					TADSGePoint3d ptDir;					
					ads_polar(ptLoc, nExtDir, 10000, ptDir);

					int nSide = pWall->OnWhichSide(ptDir);
					// 得到保温厚度
					if (pWall->IsInsulateOnSide(nSide))
					{
						double dWallInsut = pWall->GetInsulateThick(nSide);
						nWallThick = (nWallThick*0.5-dWallInsut)*2;
					}
				}
			}

			extern Acad::ErrorStatus GetClipBoundary(const XBayWindow*pBayWin,XPoint ptLoc,  double nExtDir, double nWidth, 
			                   double nWallThick,double nSlabThick,BOOL bLeftSlab,BOOL bRightSlab,XPoly2D &poly2d);
			return GetClipBoundary(m_pBayWin, ptLoc, nExtDir, m_nWidth, nWallThick, m_nProWinSlabWidth, HasLeftSlab(), HasRightSlab(), poly);
		}
		OPENOBJ_END();

	}
	return  Acad::eInvalidInput;
}

/////////////////////////////////////////////////////
// 炸碎或者显示二维
// ACAD2002才支持，显示图块之后还可以显示其他图元
// 高窗另存旧版有问题
Acad::ErrorStatus TDbOpening::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
	extern TARCH_IMPEXP BOOL g_bEnableCornWinWarning;
	dc.SetStyle(m_idTextStyle);
	BOOL bIsInsu = TRUE;

	if (!objectId() && !!m_nIdOfWall && _tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0) 
	{
		// 拖曳
		XCurveSegment seg;
		GetCenterCurve(seg);

		// extern double g_nAcadVer;
		if (g_nAcadVer<15.1 || !seg.Is(CURVE_LINE))
			DragDraw((XAcGiViewDraw &)dc);
	}

	AcDbObjectId idLineDash;
	TDbConfig *pConfig = NULL;
	if (g_bSubEntity) // 组合门窗和带型窗
		pConfig = GetDwgGlobal(AcDb::kForRead, g_pCurrentDb);
	else
		pConfig = GetDwgGlobal(AcDb::kForRead, database());
	if (pConfig)
	{
		idLineDash = pConfig->GetLinetypeDash();
		pConfig->close();
	}

    BOOL bDrawLabel = TRUE;
    if (IsHighLevel())
	{
    }
	else if (m_opKind == OP_HOLE) // 绘制洞口示意图
	{
		AcDbObjectId idOldLineType = dc.GetLineTypeId();
		dc.SetLineType(idLineDash);

		XPoly2D poly(1);
		GetOutlinePoly(0.0, poly);
		ASSERT(poly.TotalSegments()==4);

		XCurveSegment seg1, seg2, seg3;
		poly.Nth(0, seg1);
		poly.Nth(2, seg2);
		if (m_nOpStyle&OPS_NOT_BORE) 
		{
			if (!IsHigh())
				dc.SetLineType(idOldLineType);
			else
				dc << seg1 << seg2; //垂直于墙的方向的线

			// modify by xlc on 110215 增加矩形洞样式
			// poly.Nth(IsHigh()? 1 : 3, seg1);
			// dc << seg1;
			poly.Nth(IsHigh()? 1 : 3, seg3);
			if (m_nOpStyle & OPS_POLY_HOLE)	// 异型洞
			{
				dc << seg3;
			}
			else
			{
				if (!(m_nOpStyle & OPS_HOLE_FLAG1) && !(m_nOpStyle & OPS_HOLE_FLAG2)) // 空洞(上下贯通)
				{
					dc << seg1 << seg2;	// 垂直于墙的方向的线
				}
				else if(!(m_nOpStyle & OPS_HOLE_FLAG1) && (m_nOpStyle & OPS_HOLE_FLAG2)) // 空门洞
				{
					dc.SetLineType(idLineDash);
					dc  << seg3;
				} 
				else // 高洞，空窗洞
				{
					dc << seg3;
				}
			}
		} 
		else if (!(m_nOpStyle&OPS_HOLE_FLAG1) && !(m_nOpStyle&OPS_HOLE_FLAG2)) // 空洞(上下贯通)
			dc << seg1 << seg2; // 垂直于墙的方向的线
		else if ((m_nOpStyle&OPS_HOLE_FLAG1) && !(m_nOpStyle&OPS_HOLE_FLAG2)) // 空窗洞
		{
			dc.SetLineType(idOldLineType);
			poly.Nth(1, seg1);
			poly.Nth(3, seg2);
			dc << seg1 << seg2;
		} 
		else if (!(m_nOpStyle&OPS_HOLE_FLAG1) && (m_nOpStyle&OPS_HOLE_FLAG2)) // 空门洞
		{
			// dc << seg1 << seg2; //垂直于墙的方向的线

			poly.Nth(1, seg1);
			poly.Nth(3, seg2);
			dc << seg1 << seg2;
		} 
		else // 高洞
			dc << seg1 << seg2; // 垂直于墙的方向的线
		dc.SetLineType(idOldLineType);
    } 
	else if (m_opKind == OP_DOORWIN)
		ExplodeOrDrawDoorWin(dc, FALSE);
	else if (m_opKind == OP_TWODOOR)
		ExplodeOrDrawTwoDoor(dc, FALSE);
	else if (m_opKind == OP_ARCWIN) 
	{  
		// 弧墙上的弧窗
		// XDbObject objWall(m_nIdOfWall, AcDb::kForWrite);	//modify by xlc on 100528读方式打开，修改时再一些方式打开
		XDbObject objWall(m_nIdOfWall, AcDb::kForRead);

		if (!!objWall) 
		{
			TDbWall *pDbWall=TDbWall::cast(objWall.m_pObject);
			ASSERT(pDbWall && pDbWall->Is(CURVE_ARC));
			if (pDbWall) 
			{ // 弧窗的宽度, 指在墙基线上的宽度
				XArc ar=pDbWall->GetArc();

				//修改原因 : 增加记录 boundary,hatch 命令涉及到的 动态变换矩阵 m_mat3d
				// 当AcDbBlockRef 中引用到门窗时,对于boundary,hatch 这样的边界分析命令,
				// 先调用 transformby,然后调用 ExplodeOrDraw2d时，对关联的墙分析有误,此时
				// 墙还没有transformby,导致门窗和墙关系不同步错误,boundary,hatch 分析乱线
				// 该矩阵不序列化
				//修改人 : lfy 2009-11-08
				BOOL bHatch=FALSE;
				struct resbuf rb;
				acedGetVar(_T("CMDNAMES"),&rb);
				CString sCmd = rb.resval.rstring;
				acutDelString(rb.resval.rstring);
				if (sCmd.CompareNoCase(_T("BHATCH") ) == 0 ||
					sCmd.CompareNoCase(_T("_BHATCH") ) == 0 ||
					sCmd.CompareNoCase(_T("BOUNDARY")) == 0||
					sCmd.CompareNoCase(_T("_BOUNDARY")) == 0)
				{
					bHatch=TRUE;
				}

				//add by xlc on 110304 解决弧墙上的门窗移动复制时飞线问题
				else if (sCmd.CompareNoCase(_T("MOVE")) == 0||
					sCmd.CompareNoCase(_T("COPY")) == 0||
					sCmd.CompareNoCase(_T("_MOVE")) == 0||
					sCmd.CompareNoCase(_T("_COPY")) == 0)
				{
					if(!objectId() && !!m_nIdOfWall && _tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0) 
					{
						bHatch = TRUE;
					}
				}

				if(bHatch)
				{
					TADSGePoint3d ptCen = ar.GetCenterPt();
					ptCen.TransformBy(m_mat3d);
					ar.SetCenterPt(ptCen);
				}

				double nWallThick=pDbWall->GetWidth(4);
				XPoint ptLoc=m_ptLocation;
				ptLoc.z=ar.GetCenterPt().z;
				XPoint ptOnWall=ptLoc;

				//修改原因 : 增加记录 boundary,hatch 命令涉及到的 动态变换矩阵 m_mat3d
				// 当AcDbBlockRef 中引用到门窗时,对于boundary,hatch 这样的边界分析命令,
				// 先调用 transformby,然后调用 ExplodeOrDraw2d时，对关联的墙分析有误,此时
				// 墙还没有transformby,导致门窗和墙关系不同步错误,boundary,hatch 分析乱线
				// 该矩阵不序列化
				//修改人 : lfy 2009-11-08
				if(bHatch)
				{
					Acad::ErrorStatus es = pDbWall->upgradeOpen();			//add by xlc on 100528升级打开方式
					if (es == Acad::eOk || es == Acad::eWasOpenForWrite)
					{
						pDbWall->transformBy(m_mat3d);		
					}		   
					else
					{
						bHatch = FALSE;										//add by xlc on 100625不是写方式打开时不进行变换
					}
				}
				pDbWall->ProjectToMe(ptLoc, ptOnWall);
				if(bHatch) 
				{
					AcGeMatrix3d matInv = m_mat3d;
					matInv.invert();
					pDbWall->assertWriteEnabled();
					pDbWall->transformBy(matInv);
					pDbWall->downgradeOpen();
				}
				double nRad=ads_distance(ar.GetCenterPt(), ptOnWall);
				double nSweepAng=m_nWidth/nRad;
				double nStartAng=CT_std_angle(ads_angle(ar.GetCenterPt(), ptOnWall)-nSweepAng/2.0),
					nEndAng=CT_std_angle(ads_angle(ar.GetCenterPt(), ptOnWall)+nSweepAng/2.0);
				XArc arMid(ar.GetCenterPt(), ads_distance(ar.GetCenterPt(), ptLoc), nStartAng, nEndAng);

				TADSGePoint3d ptTmp = arMid.GetCenterPt();
				ptTmp.z = 0.0;   
				arMid.SetCenterPt(ptTmp);

				AcDbObjectId idOldLineType=dc.GetLineTypeId();
				if(IsHigh() )
					dc.SetLineType(idLineDash);
				/*
				if (GetPScale()>g_nCurtainWall3Scale+1.0E-3)
				dc << arMid;
				else
				dc << arMid.Offset(nWallThick/6.0) << arMid.Offset(-nWallThick/6.0);
				*/
				// sg modify 090609，带形窗根据样式绘制
				if (g_bCurtainWallFixStyle) // 固定样式
				{
					if (g_nCurtainWallStyle == 0) // 固定为三线
						dc<<arMid;
					else // 固定四线
						dc << arMid.Offset(nWallThick/6.0) << arMid.Offset(-nWallThick/6.0);
				}
				else // 随比例改变样式
				{
					if (GetPScale()>g_nCurtainWall3Scale+1.0E-3)
						dc<<arMid;
					else
						dc << arMid.Offset(nWallThick/6.0) << arMid.Offset(-nWallThick/6.0);
				}


				// 假如有门窗套, 则不能绘制外侧边线
				if(HasSlot()) 
				{
					if((pDbWall->GetWallFlag()&WF_LEFTEXT)==0)
						dc << arMid.Offset(-nWallThick/2.0);
					else
						dc << arMid.Offset(nWallThick/2.0);
				}
				else if(!IsHigh())
					dc << arMid.Offset(nWallThick/2.0)<< arMid.Offset(-nWallThick/2.0);
				else
				{
					XArc ar1=arMid.Offset(nWallThick/2.0);
					XArc ar2=arMid.Offset(-nWallThick/2.0);
					XPoint ptVert[4];
					ar1.GetStartPoint(ptVert[0]);
					ar1.GetEndPoint(ptVert[1]);
					ar2.GetStartPoint(ptVert[2]);
					ar2.GetEndPoint(ptVert[3]);

					dc << XLine(ptVert[0], ptVert[2])
						<< XLine(ptVert[1], ptVert[3]);
				}
				dc.SetLineType(idOldLineType);
			}
		} 
		else // 画个示意图
		{
			XPoly2D polyShow(1);
			GetOutlinePoly(0.0, polyShow);
			dc << polyShow;
		}
	} 
	else if (m_opKind == OP_CORNWIN) // 转角窗
	{
		if (!m_nIdOfWall) 
		{
			if(g_bEnableCornWinWarning)
				dc.DrawText(_T("请纠正无墙带形窗!"));
		}
		else 
			DrawBanWin(dc, FALSE);
	} 
	else if (m_opKind==OP_PROWIN) // 凸窗
		DrawBayWindow2d(dc);
	else if (!!m_nIdStyle2d && (m_opKind==OP_DOOR || m_opKind==OP_WINDOW)) // 普通门窗
	{
		// 用图块表示的门窗
		AcDbObjectId idOldLineType = dc.GetLineTypeId();
		if(IsHigh() )
			dc.SetLineType(idLineDash);

		if (IsHigh()) 
		{
			XPoint ptBack, ptFront;
			GetSidePoints(ptBack, ptFront);
			double nWidth = GetWallThickness(TRUE);
			XCurveSegment segCen(ptBack, ptFront, 0.0);
			double nDirection = ads_angle(ptBack, ptFront);
			XPoint ptSide[4];
			ads_polar(ptFront, nDirection+PI/2, nWidth/2, ptSide[0]);
			ads_polar(ptFront, nDirection-PI/2, nWidth/2, ptSide[1]);
			ads_polar(ptBack, nDirection+PI/2, nWidth/2, ptSide[2]);
			ads_polar(ptBack, nDirection-PI/2, nWidth/2, ptSide[3]);

			dc << segCen.Offset(OFFSET_LEFT, nWidth/6.0, LS_FINITE)
				<< segCen.Offset(OFFSET_RIGHT, nWidth/6.0, LS_FINITE)
				<< XCurveSegment(ptSide[0], ptSide[1], 0.0)
				<< XCurveSegment(ptSide[2], ptSide[3], 0.0);
		} 
		else
		{
			BOOL bArcWall=FALSE;
			XDbObject objWall(m_nIdOfWall, AcDb::kForRead);
			BOOL bToTch3=(_tcscmp(dc.Desc(), XExplodeStream::Descriptor())==0
				&&m_lstClipId.Length()==0//add by whl on 070517,有切割时按绘制走
				&& dc.IsExportTch4() && m_nIdStyle2d.isValid());

			// add by whl on 070515,导出上华3时就不要了，否则会多出很多线
			if (m_opKind==OP_WINDOW && !!objWall&& !bToTch3)
			{
				TDbWall *pDbWall=TDbWall::cast(objWall.m_pObject);
				if(pDbWall && pDbWall->Is(CURVE_ARC)) // 弧墙上的弦窗
				{
					if (!HasSlot()) // 假如有门窗套, 则不能绘制
					{
						double nWallThick=pDbWall->GetWidth(4);
						XPoint ptSide1, ptSide2;
						GetSidePoints(ptSide1, ptSide2);
						ptSide1.z=ptSide2.z=0;
						XCurveSegment segMid=pDbWall->OffsetGeomCenter(LS_FINITE, TRUE);
						XLine lnMid(ptSide1, ptSide2);
						/*
						if(GetPScale()>g_nCurtainWall3Scale+1.0E-3)
						dc << lnMid;
						else
						dc << lnMid.Offset(nWallThick/6.0) << lnMid.Offset(-nWallThick/6.0);
						*/
						// sg modify 090609，带形窗根据样式绘制
						if (g_bCurtainWallFixStyle) // 固定样式
						{
							if (g_nCurtainWallStyle == 0) // 固定为三线
								dc << lnMid;
							else // 固定四线
								dc << lnMid.Offset(nWallThick/6.0) << lnMid.Offset(-nWallThick/6.0);
						}
						else // 随比例改变样式
						{
							if (GetPScale()>g_nCurtainWall3Scale+1.0E-3)
								dc << lnMid;
							else
								dc << lnMid.Offset(nWallThick/6.0) << lnMid.Offset(-nWallThick/6.0);
						}

						XCurveSegment cv1=segMid.Offset(nWallThick/2.0, LS_FINITE), 
							cv2=segMid.Offset(-nWallThick/2.0, LS_FINITE);
						XLine ln1=lnMid.Offset(nWallThick/2.0),
							ln2=lnMid.Offset(-nWallThick/2.0);
						cv1.SetPoints(ln1.StartPoint(), ln1.EndPoint());
						cv2.SetPoints(ln2.StartPoint(), ln2.EndPoint());

						dc << cv1 << cv2;
					} 
					bArcWall=TRUE;
				}
			}

			if (bToTch3) 
			{
				// 取墙的宽度作为门窗厚度
				double nScaleX, nScaleY;
				GetInsert2DScale(&nScaleX, &nScaleY);

				XPoint ptInsert=m_ptLocation;
				ptInsert.z = 0.0;
				AcDbBlockReference *pInsert=new AcDbBlockReference(ptInsert, m_nIdStyle2d);

				if(g_bSubEntity)//组合门窗或带型窗
				{
					TMasterProperties prop;
					dc.BackUpProperties(prop);
					prop.SetTo(pInsert);
				}
				else
					pInsert->setPropertiesFrom(this);

				pInsert->setRotation(m_nRotation);

				AcDbVoidPtrArray entArray;
				XExplodeStream dcExp(entArray);
				dcExp.SetAutoProp(FALSE);
				BOOL bEmptyLab=FALSE;
				const TCHAR *szLab=(const TCHAR *)m_sLabel;
				if(!szLab[0]) 
				{
					szLab=_T("MC");
					bEmptyLab=TRUE;
				}
				DrawLabel(dcExp, szLab);
				int num=entArray.length();
				if(num==1) 
				{
					AcDbText *pText=AcDbText::cast((AcDbEntity *)entArray[0]);
					ASSERT(pText);
					AcDbAttribute *attr = new AcDbAttribute;
					attr->setPropertiesFrom(this);
					attr->setLayer(m_idLayerText);
					attr->setHeight(pText->height());
					TCHAR *szText=pText->textString();
					attr->setTextString(bEmptyLab? _T("") : szText);
					if(szText) delete[] szText;
					attr->setRotation(pText->rotation());
					attr->setHorizontalMode(pText->horizontalMode());
					attr->setVerticalMode(pText->verticalMode());
					attr->setAlignmentPoint(pText->alignmentPoint());
					attr->setTextStyle(pText->textStyle());
					attr->setWidthFactor(pText->widthFactor());
					attr->setPosition(pText->position());
					attr->setTag(_T("A"));
					VERIFY(pInsert->appendAttribute(attr)==Acad::eOk);
					bDrawLabel=FALSE;
				} 
				ReleaseEntSet(entArray);

				// 没有注册的APPID导致崩溃
				AcDbDatabase *pDb=database();
				AcDbRegAppTable *pAppTab=NULL;
				if(pDb)
					pDb->getSymbolTable(pAppTab, AcDb::kForRead);
				BOOL bReg=FALSE;
				if(pAppTab) 
				{
					bReg=pAppTab->has(_T("WTHICK"));
					pAppTab->close();
				}
				double nWallWidth=GetWallThickness(TRUE); //Add TRUE argument on 2003/11/10

				if(pDb==acdbCurDwg() && bReg)
				{
					pInsert->setScaleFactors(AcGeScale3d(nScaleX, nScaleY, nScaleX)); 
					resbuf *xdata=ads_buildlist(1001, _T("WTHICK"), 1040, nWallWidth, NULL);
					if(pInsert->setXData(xdata)!=Acad::eOk) 
					{ //只能对当前图设置
						//ASSERT(0);
					}
					ads_relrb(xdata);
				} 
				else 
					pInsert->setScaleFactors(AcGeScale3d(nScaleX, nScaleY, nWallWidth)); // Z比例＝墙厚
				((XExplodeStream &)dc).Append(pInsert, FALSE);
			} 
			else
			{
				/////////////////////////////////////////////////////
				// 显示图块
				if(!bArcWall) 
				{
					// 取墙的宽度作为门窗厚度
					double nScaleX, nScaleY;
					GetInsert2DScale(&nScaleX, &nScaleY);

					//构造插入矩阵
					XPoint ptInsert=m_ptLocation;
					ptInsert.z = 0.0; //GetWallElevation(); //二维的位置同墙基的标高

					BOOL bMakeBlock=g_bMakeBlock;
					if(_tcsicmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0) 
					{
						if (dc.IsPlotGeneration()) // sg add 120507，强制打印时，不使用新方法
							bMakeBlock = FALSE;
						else
							bMakeBlock=(g_nAcadVer>15.0001);
					}

					OPENOBJ_BEGIN(m_nIdOfWall, AcDb::kForRead, TDbWall, pWall);
					if(pWall) 
					{
						//wlw add 110220 门窗套类型是保温材料时，不画外面的线
						BOOL bRightExt = (pWall->GetWallFlag() & WF_LEFTEXT) == 0;
						if (bRightExt)
						{
							if (!pWall->IsInsulateOnSide(OFFSET_RIGHT))
							{
								if (m_nMaterial == 3)
								{//门窗套类型是保温材料时，不画外面的线
									bIsInsu = FALSE;
								}
							}
							else
							{
								if (pWall->GetInsulateThick(OFFSET_RIGHT) < 0.01)
								{
									if (m_nMaterial == 3)
									{
										bIsInsu = FALSE;
									}
								}
							}
						}
						else
						{
							if (!pWall->IsInsulateOnSide(OFFSET_LEFT))
							{
								if (m_nMaterial == 3)
								{//门窗套类型是保温材料时，不画外面的线
									bIsInsu = FALSE;
								}
							}
							else
							{
								if (pWall->GetInsulateThick(OFFSET_LEFT) < 0.01)
								{
									if (m_nMaterial == 3)
									{
										bIsInsu = FALSE;
									}
								}
							}
						}
					}
					OPENOBJ_END();

					if (!DocGetProWinSlabInsu())
					{//wlw add 110114 凸窗挡板保温套加保温为FALSE时保温材料的按照普通模式绘制
						if (m_nMaterial == 3)
						{
							bIsInsu = FALSE;
						}
					}

					if(HasSlot() &&  m_opKind==OP_WINDOW && !!m_nIdOfWall && bIsInsu) 
					{//有门窗套时要将外边线去除,然后分解绘制
						OPENOBJ_BEGIN(m_nIdOfWall, AcDb::kForRead, TDbWall, pWall);
						if(pWall) 
						{
							//计算门窗套一侧的外边线
							XPoint ptStart, ptEnd, ptExtStart,ptExtEnd;
							GetSidePoints(ptStart, ptEnd);
							double nExtDirStart=pWall->OrthoDirection(ptStart);
							double nExtDirEnd=pWall->OrthoDirection(ptEnd);
							XCurveSegment seg;
							if((pWall->GetWallFlag()&WF_LEFTEXT)==0) 
							{
								seg=pWall->GetRelativeSideCurve(OFFSET_RIGHT, pWall->StartPoint(), GetSlotExt());
								ads_polar(ptStart, nExtDirStart, pWall->GetWidth(4)/2.0, ptExtStart);
								ads_polar(ptEnd, nExtDirEnd, pWall->GetWidth(4)/2.0, ptExtEnd);
							} 
							else 
							{
								seg=pWall->GetRelativeSideCurve(OFFSET_LEFT, pWall->StartPoint(), GetSlotExt());
								ads_polar(ptStart, nExtDirStart+PI, pWall->GetWidth(4)/2.0, ptExtStart);
								ads_polar(ptEnd, nExtDirEnd+PI, pWall->GetWidth(4)/2.0, ptExtEnd);
							}
							seg.SetPoints(ptExtStart, ptExtEnd);
							seg.SetElevation(0.0);

							//分解图块后绘制
							ads_matrix mat;
							ConstructMatrix(XPoint(),ptInsert,nScaleX,nScaleY,nScaleX,m_nRotation,mat);
							AcDbVoidPtrArray entSet;
							XExplodeStream dc1(entSet);
							dc1<<XBlockRef(m_nIdStyle2d, ptInsert, AcGeScale3d(nScaleX, nScaleY, nScaleX), m_nRotation, FALSE);//分解　
							for(long i=0;i<entSet.length();i++)
							{
								AcDbEntity *pEnt=(AcDbEntity*)entSet[i];
								if(pEnt->isKindOf(AcDbLine::desc()))
								{
									AcDbLine *pLine=AcDbLine::cast(pEnt);
									AcGePoint3d pt1=pLine->startPoint(),pt2=pLine->endPoint();
									pt1.z=0;
									pt2.z=0;
									if((seg.StartPoint()==pt1&&seg.EndPoint()==pt2)||
										(seg.StartPoint()==pt2&&seg.EndPoint()==pt1))//端点相同视为外边线，不绘制
										continue;
								}
								else if(pEnt->isKindOf(AcDbArc::desc()))
								{
									AcDbArc *pArc=AcDbArc::cast(pEnt);
									AcGePoint3d pt1,pt2;
									pArc->getStartPoint(pt1);
									pArc->getEndPoint(pt2);
									pt1.z=0;
									pt2.z=0;
									if((seg.StartPoint()==pt1&&seg.EndPoint()==pt2)||
										(seg.StartPoint()==pt2&&seg.EndPoint()==pt1))//端点相同视为外边线，不绘制
										continue;
								}

								pEnt->setLayer(layer());
								pEnt->setColorIndex(colorIndex());
								dc.DrawEntity(*pEnt);
							}
							ReleaseEntSet(entSet);
						}
						OPENOBJ_END()
					}
					else
						dc<<XBlockRef(m_nIdStyle2d, ptInsert, AcGeScale3d(nScaleX, nScaleY, nScaleX), m_nRotation, bMakeBlock);
				}
			}
			   }
			   dc.SetLineType(idOldLineType);
		   }


		   if(GetKind()==TOpeningData::OP_DOOR || 
			   GetKind()==TOpeningData::OP_TWODOOR || 
			   GetKind()==TOpeningData::OP_DOORWIN||
			   GetKind()==TOpeningData::OP_GROUP||
			   GetKind()==TOpeningData::OP_HOLE)//add by whl on 051227
			   DrawDoorLine(dc);


		   if(!IsHigh() && HasSlot() && !!m_nIdOfWall && bIsInsu) 
		   { //门窗套的底线,用门窗的颜色和墙的图层
			   OPENOBJ_BEGIN(m_nIdOfWall, AcDb::kForRead, TDbWall, pWall);
			   if(pWall) 
			   {
				   XPoint ptStart, ptEnd, ptExtStart,ptExtEnd;
				   GetSidePoints(ptStart, ptEnd);
				   double nExtDirStart=pWall->OrthoDirection(ptStart);
				   double nExtDirEnd=pWall->OrthoDirection(ptEnd);
				   double dWallInsut = 0.0;
				   XCurveSegment seg;
				   if((pWall->GetWallFlag()&WF_LEFTEXT)==0) 
				   {
					   seg=pWall->GetRelativeSideCurve(OFFSET_RIGHT, pWall->StartPoint(), GetSlotExt());
					   if (pWall->IsInsulateOnSide(OFFSET_RIGHT))
					   {
						   dWallInsut = pWall->GetInsulateThick(OFFSET_RIGHT);
						   if (DocGetProWinSlabInsu())
						   {
							   dWallInsut -= GetSlotInsulateThick();
						   }
					   }

					   ads_polar(ptStart, nExtDirStart, GetSlotExt() - dWallInsut +pWall->GetWidth(4)/2.0, ptExtStart);
					   ads_polar(ptEnd, nExtDirEnd, GetSlotExt() - dWallInsut + pWall->GetWidth(4)/2.0, ptExtEnd);
				   } 
				   else 
				   {
					   if (pWall->IsInsulateOnSide(OFFSET_LEFT))
					   {
						   dWallInsut = pWall->GetInsulateThick(OFFSET_LEFT);
						   if (DocGetProWinSlabInsu())
						   {
							   dWallInsut -= GetSlotInsulateThick();
						   }
					   }
					   seg=pWall->GetRelativeSideCurve(OFFSET_LEFT, pWall->StartPoint(), GetSlotExt());
					   ads_polar(ptStart, nExtDirStart+PI, GetSlotExt() - dWallInsut + pWall->GetWidth(4)/2.0, ptExtStart);
					   ads_polar(ptEnd, nExtDirEnd+PI, GetSlotExt() - dWallInsut + pWall->GetWidth(4)/2.0, ptExtEnd);
				   }
				   seg.SetPoints(ptExtStart, ptExtEnd);
				   seg.SetElevation(0.0);
				   dc << seg;
   //         if(m_opKind==OP_WINDOW) 
			//{ //绘制玻璃线和里边的墙线
   //             seg=pWall->GetRelativeOffsetCurveFromCenter(OFFSET_RIGHT, 1.0/6.0, pWall->StartPoint());
   //             seg.SetElevation(0.0);
   //             XPoint pt1, pt2;
   //             seg.ProjectToMe(ptStart, pt1);
   //             seg.ProjectToMe(ptEnd, pt2);
   //             dc << XLine(pt1, pt2);
   //             seg=pWall->GetRelativeOffsetCurveFromCenter(OFFSET_LEFT, 1.0/6.0, pWall->StartPoint());
   //             seg.SetElevation(0.0);
   //             seg.ProjectToMe(ptStart, pt1);
   //             seg.ProjectToMe(ptEnd, pt2);
   //             dc << XLine(pt1, pt2);
   //             int nInternalSide = (pWall->GetWallFlag()&WF_LEFTEXT)==0? OFFSET_LEFT : OFFSET_RIGHT;
   //             seg=pWall->GetRelativeSideCurve(nInternalSide, pWall->StartPoint(), 0.0, TRUE);
   //             seg.SetElevation(0.0);
   //             seg.ProjectToMe(ptStart, pt1);
   //             seg.ProjectToMe(ptEnd, pt2);

			//	seg.SetPoints(pt1, pt2);
			//	dc << seg;
   //         }
		}
		OPENOBJ_END();
	}

	Acad::ErrorStatus es = Acad::eOk;
	if (g_bExplodeSubText || (!!m_sLabel&& bDrawLabel)) // bug: 如果设置了图层,则插门的时候出错AcGi-SelectionMarker
		DrawLabel(dc, m_sLabel);
	return es;
}

// Helper functions
TSubText* TDbOpening::HitTestText(XPoint pt)const
{
	TSubText* pSubText=TDbEntity::HitTestText(pt);
	if(pSubText!=NULL)
		pSubText->SetMenuType(4);
	return pSubText;
}
TSubText* TDbOpening::GetSubText(long iText)const
{
	TSubText* pSubText=TDbEntity::GetSubText(iText);
	if(pSubText!=NULL)
		pSubText->SetMenuType(4);
	return pSubText;
}
void TDbOpening::DrawLabel(XExplodeDraw &dc, const TCHAR *szLab) const
{
	if (!g_bExplodeSubText && (!szLab || !szLab[0] || !IsShowLabel()))
		return;

	AcDbObjectId id = m_idTextStyle;
	if (!id.isValid())
	{
		id = GetTextStyleId(_T("STANDARD"), database());
	}
	ASSERT(id.isValid());

	TDbText textLabel;
	textLabel.setPropertiesFrom(this);
	if (m_idLayerText.isValid())
		textLabel.setLayer(m_idLayerText); //可否设置图层
	TPushProperty vProp(&textLabel, dc); //由临时对象设置DC的熟悉

	textLabel.SetStyleId(id);
	textLabel.SetLocation(XPoint(m_ptLabel.x, m_ptLabel.y));
	textLabel.SetAlignment(XExplodeDraw::kMiddleCenter);

	double nRotLabel = Wcs2Layout(m_nRotation);

	// sg add 110119，标记是否是弧窗
	bool bArcWin = 0;
	if (GetKind()==OP_CORNWIN || GetKind()==OP_ARCWIN)
	{
		if (!!m_nIdOfWall) 
		{
			OPENOBJ_BEGIN(m_nIdOfWall, AcDb::kForRead, TDbWall, pWall);
			if (pWall && pWall->Is(CURVE_ARC)) 
			{
				XArc ar = pWall->GetArc();

				//修改原因 : 增加记录 boundary,hatch 命令涉及到的 动态变换矩阵 m_mat3d
				// 当AcDbBlockRef 中引用到门窗时,对于boundary,hatch 这样的边界分析命令,
				// 先调用 transformby,然后调用 ExplodeOrDraw2d时，对关联的墙分析有误,此时
				// 墙还没有transformby,导致门窗和墙关系不同步错误,boundary,hatch 分析乱线
				// 该矩阵不序列化
				//修改人 : lfy 2009-11-08
				struct resbuf rb;
				acedGetVar(_T("CMDNAMES"),&rb);
				CString sCmd = rb.resval.rstring;
				acutDelString(rb.resval.rstring);
				if (sCmd.CompareNoCase(_T("BHATCH") ) == 0 ||
					sCmd.CompareNoCase(_T("_BHATCH") ) == 0 ||
					sCmd.CompareNoCase(_T("BOUNDARY")) == 0||
					sCmd.CompareNoCase(_T("_BOUNDARY")) == 0||

					//add by xlc on 110304 解决弧墙上的门窗移动复制时飞线问题
					sCmd.CompareNoCase(_T("MOVE")) == 0||
					sCmd.CompareNoCase(_T("_MOVE")) == 0||
					(!objectId()&&(sCmd.CompareNoCase(_T("COPY")) == 0||
					sCmd.CompareNoCase(_T("_COPY")) == 0))
				)
				{
					TADSGePoint3d ptTmp = ar.GetCenterPt();
					ptTmp.TransformBy(m_mat3d);;   
					ar.SetCenterPt(ptTmp);
				}

				nRotLabel = CT_std_angle(ads_angle(ar.GetCenterPt(), m_ptLabel) - PI/2);
				bArcWin = true; // 弧窗
			}
			OPENOBJ_END();
		}
	}

	// sg modify 110307，解决经过布局旋转后，弧窗标注或者弧墙上的转角窗角度发生变化的情况
	if (bArcWin) // 如果是窗标注或者弧墙上的转角窗，需要将根据墙线计算出来的角度，转换为布局转角下的角度
	{
		nRotLabel = Wcs2Layout(m_nRotation);
	}
	textLabel.SetRotation(xg_angle(nRotLabel));
	textLabel.SetHeight(m_nTextHeight);

	TCHAR szLabel[256]=_T("");
	_tcscpy(szLabel, szLab);

	TDbConfig *pConfig = GetDwgGlobal(AcDb::kForRead, database());
	if (pConfig && pConfig->IsCapLabel()) 
		_tcsupr(szLabel);
	if (pConfig)
		pConfig->close();
	textLabel.SetText(szLabel);

	if (dc.IsFullExplode())
	{
		textLabel.ExplodeOrDraw2d(dc);
	}
	else
		dc.DrawEntity(textLabel);
}

bool TDbOpening::GetNeighbourPoint(XPoint &pt,bool bPre)const
{
    TDbWall *pWall=NULL;
    OPENOBJ_BEGIN(m_nIdOfWall, AcDb::kForRead, TDbWall, pWall0);
	if (pWall0 != NULL)
	{
		pWall=TDbWall::cast(pWall0->clone());
	}
    OPENOBJ_END();
	if(pWall==NULL)
		return false;

    pWall->RemoveReferenceOpening(objectId());
	pt=bPre?pWall->StartPoint():pWall->EndPoint();
	XCurveSegment seg;
	if(pWall->GetSubSegmentAt(m_ptLocation, seg, FALSE)) 
		pt=bPre?seg.StartPoint():seg.EndPoint();

	delete pWall;
	return true;
}
// 绘制拖动时2D的显示
void TDbOpening::DragDraw(XAcGiViewDraw &dc) const
{
	if(g_bSubEntity)
		return;

    extern GEOAPI BOOL GetWcsCursor(XPoint &ptLoc);
    XPoint ptCursor;
	TchExport::GetWcsCursor(ptCursor);

    if(m_idTextStyle.isValid())
		dc.SetStyle(m_idTextStyle); 
	else 
		dc.SetStyle(InitTextStyle(TS_WINDOW));
    TDbWall *pWall=NULL;
    OPENOBJ_BEGIN(m_nIdOfWall, AcDb::kForRead, TDbWall, pWall0);
    pWall=TDbWall::cast(pWall0->clone());
    OPENOBJ_END();
    ASSERT(pWall);
    XCurveSegment seg;
    double nTextHeight=PixelToWcs(10);
	TArchPerDocData*pDocData=GetCurDocData();
    if(pDocData!=NULL&&pDocData->m_sCurCommand==_T("GRIP_STRETCH")) {
        //原始门窗,需要拿掉
        AcDbObjectId idThis=GetPrepickEntity(RBList(RTDXF0, _T("ATS_OPENING"), NULL));
        if(!!idThis)
            pWall->RemoveReferenceOpening(idThis);
    }
 
    for(int nSide=0; nSide<2; nSide++) { //0--墙基上的参数,1--墙边上的参数
        Adesk::UInt16 nOldColor=dc.GetColor();
        dc.SetColor(nSide==0? 1 : 7);
        BOOL bRet;
        if(nSide) {
            bRet=pWall->GetSubSegmentOnSideAt(ptCursor, seg);
            if(bRet) {
                XCurveSegment segThis=*pWall;
                XPoint ptA, ptB;
                pWall->ProjectToMe(seg.StartPoint(), ptA);
                pWall->ProjectToMe(seg.EndPoint(), ptB);
                segThis.SetPoints(ptA, ptB);
                seg=segThis;
            }
        }   else
            bRet=pWall->GetSubSegmentAt(m_ptLocation, seg, FALSE);
        if(bRet) { 
            XSortedVertexList lstPoints(seg.StartPoint(), seg.EndPoint(), seg.GetBulge());
            XPoint pt1, pt2;
            GetSidePointsOnBase(pt1, pt2);
            pt1.z=pt2.z=seg.StartPoint().z;

            int nTextOnSide=0;
            lstPoints.Insert(pt1);
            lstPoints.Insert(pt2);
            if(lstPoints.Length()==4) {
                XPoly2D poly(0);
                lstPoints.AsPoly2D(poly);
                for(int i=0; i<poly.TotalSegments(); i++) {
                    XCurveSegment subSeg;
                    poly.Nth(i, subSeg);
                    XPoint ptMid=subSeg.MidPoint();
                    double nDrt=subSeg.Direction(ptMid);
                    {
                        int nSide0=subSeg.OnWhichSide(ptCursor);
                        if(nSide0==OFFSET_RIGHT)
                            nDrt=CT_std_angle(nDrt+PI);
                    }
                    XPoint ptText;
                    ads_polar(ptMid, nDrt-PI/2.0+nSide*PI, 2*nTextHeight, ptText);
                    if(nSide==1)
                        nTextOnSide=pWall->OnWhichSide(ptText);

                    dc.SetLocation(ptText);
                    dc.SetAlignment(XExplodeDraw::kMiddleCenter);
                    dc.SetHeight(nTextHeight);
                    dc.SetRotation(xg_angle(nDrt));
                    double nDispVal=subSeg.GetLength();
                    XString sDispVal;
                    if(/*g_bDimAngle && */subSeg.Is(CURVE_ARC)) {
                        sDispVal << AS_INT(subSeg.GetBulge()*180.0/PI) << _T("%%d");
                    } else {
                        sDispVal << AS_INT(nDispVal);
                    }
                    dc.DrawText(sDispVal);
                }

                XCurveSegment lCurve, rCurve;
                if(nSide==1)
                    pWall->GetSideCurve(lCurve, rCurve);
                for(i=0; i<poly.Length(); i++) {
                    XPoint &ptMark=*poly[i];
                    if(nSide==1) {
                        if(nTextOnSide==OFFSET_LEFT)
                            lCurve.ProjectToMe(XPoint(ptMark), ptMark);
                        else 
                            rCurve.ProjectToMe(XPoint(ptMark), ptMark);
                    }
                    XRectAngle box(ptMark, nTextHeight/2, nTextHeight/2);
                    dc << XLine(box.GetLowLeft(), box.GetUpRight())
                        << XLine(box.GetLowRight(), box.GetUpLeft());
                }
            }
        }
        dc.SetColor(nOldColor);
    }
    delete pWall;

}

// 绘制三维窗框
BOOL TDbOpening::DrawFrame3d(XExplodeDraw &dc, const XPoly2D &polyGlass) const
{
   TMasterProperties prop;
   dc.BackUpProperties(prop);
   dc.SetColorLayer(colorIndex(), m_idLayerFrame3d);

	double nElev=GetElevation();
	// 底框
	XRectAngle box(XPoint(), m_vFrame, m_uFrame);
	XPoly2D polyShape(1);
	box.AsPoly2D(polyShape);
	TDbCurveMesh mesh;
	mesh.setPropertiesFrom(this);
	if(m_idLayerFrame3d.isValid())
		mesh.setLayer(m_idLayerFrame3d);
	TPushProperty vProp(&mesh, dc);

	XPoly2D polyBot(polyGlass);
	polyBot.SetElevation(nElev);
	mesh.SetPathPoly(polyBot,mesh.GetNormal().AsAcGeVector3d());
	mesh.SetShapePoly(polyShape);
	mesh.SetShapeBase(XPoint(0, -m_uFrame/2));
    if(dc.IsFullExplode())
		mesh.ExplodeOrDraw3d(dc);
	else
		dc.DrawEntity(mesh);

	// 顶框
	XPoly2D polyTop(polyBot);
	polyTop.SetElevation(nElev+GetHeight());
	mesh.SetPathPoly(polyTop,mesh.GetNormal().AsAcGeVector3d());
	mesh.SetShapeBase(XPoint(0, m_uFrame/2));
    if(dc.IsFullExplode())
		mesh.ExplodeOrDraw3d(dc);
	else
		dc.DrawEntity(mesh);

	// 竖框
	for(int i=0; i<polyGlass.Length(); i++) {
		XDirectionCurve segPrev, segNext;
		double nDirPrev=0, nDirNext=0;
		BOOL bPrev=FALSE, bNext=FALSE;
		if(i>0) {
			bPrev=TRUE;
			polyGlass.Nth(i-1, segPrev);
			nDirPrev=segPrev.IDirection(1);
		}
		if(i<polyGlass.Length()-1) {
			bNext=TRUE;
			polyGlass.Nth(i, segNext);
			nDirNext=segNext.IDirection(0);
		}
		if(!bPrev) { //第一
			XPoint ptFirst=polyGlass[i];
			XPoint ptVert[4];
			ads_polar(ptFirst, nDirNext-PI/2, m_vFrame/2, ptVert[0]);
			ads_polar(ptVert[0], nDirNext, m_uFrame, ptVert[1]);
			ads_polar(ptVert[1], nDirNext+PI/2, m_vFrame, ptVert[2]);
			ads_polar(ptVert[0], nDirNext+PI/2, m_vFrame, ptVert[3]);
			XPoly2D poly2d(1);
			for(int k=0; k<4; k++)
				poly2d.AppendNode(ptVert[k]);
			poly2d.SetElevation(nElev);
			dc.DrawMesh(poly2d, XVector3D(0,0,m_nHeight));
		} else	if(!bNext) { //末尾
			XPoint ptEnd=polyGlass[i];
			XPoint ptVert[4];
			ads_polar(ptEnd, nDirPrev-PI/2, m_vFrame/2, ptVert[0]);
			ads_polar(ptVert[0], nDirPrev, m_uFrame, ptVert[1]);
			ads_polar(ptVert[1], nDirPrev+PI/2, m_vFrame, ptVert[2]);
			ads_polar(ptVert[0], nDirPrev+PI/2, m_vFrame, ptVert[3]);
			XPoly2D poly2d(1);
			for(int k=0; k<4; k++)
				poly2d.AppendNode(ptVert[k]);
			poly2d.SetElevation(nElev);
			dc.DrawMesh(poly2d, XVector3D(0,0,m_nHeight));
		} else {
			XPoly2D polyTemp;
			XPoint ptCur=polyGlass[i];
			XPoint ptPrev, ptNext;
			ads_polar(ptCur, nDirPrev, m_uFrame, ptPrev);
			ads_polar(ptCur, nDirNext, m_uFrame, ptNext);
			polyTemp.AppendNode(ptPrev);
			polyTemp.AppendNode(ptCur);
			polyTemp.AppendNode(ptNext);
			XPoly2D polyLeft, polyRight;
			polyTemp.QuickOffset(-m_vFrame/2, polyLeft);
			polyTemp.QuickOffset(m_vFrame/2, polyRight);
			XPoly2D poly2d(polyRight);
			poly2d.SetFlag(1);
			for(int k=polyLeft.Length()-1; k>=0; k--) 
				poly2d.AppendNode(*polyLeft[k]);
			poly2d.SetElevation(nElev);
			dc.DrawMesh(poly2d, XVector3D(0,0,m_nHeight));
		}
	}

	// 其他窗框
	if(1) {
		TDbCurveMesh meshEcs;
		meshEcs.setPropertiesFrom(this);
		if(m_idLayerFrame3d.isValid())
			meshEcs.setLayer(m_idLayerFrame3d);
		TPushProperty vProp1(&meshEcs, dc);

		double nDistPrev=0;
		XRectAngle boxTemp(XPoint(), m_uFrame, m_vFrame);
		XPoly2D polySect(1);
		boxTemp.AsPoly2D(polySect);
		for(i=0; i<polyGlass.TotalSegments(); i++) {
			XDirectionCurve seg;
			polyGlass.Nth(i, seg);
			XPoint ptLowLeft, ptUpRight;
			ptLowLeft.x = nDistPrev;
			nDistPrev += seg.GetLength();
			ptUpRight.x = nDistPrev;
			ptUpRight.y = m_nHeight;
			XPoly2D polyClip(1);
			XRectAngle(ptLowLeft, ptUpRight).AsPoly2D(polyClip);
			DList<XCurveSegment> ssIn, ssOut,ssEdge;
			PolyClip(m_lstFrameLines, polyClip, ssIn, ssOut, ssEdge);

			double nDirNormal=CT_std_angle(seg.IDirection(0)-PI/2); //ECS 法向
			BOOL bCircular=seg.Is(CURVE_ARC);
			XVector3D vtEcs(cos(nDirNormal), sin(nDirNormal), 0.0);

			//meshEcs.setLayer(dc.GetLayerId());
			for(int n=0; n<ssIn.Length(); n++) {
				XCurveSegment segIn=*ssIn[n];
				if(!bCircular) {
					XPoint pt1, pt2;
					polyGlass.Polar2d(segIn.StartPoint().x, pt1); 
					polyGlass.Polar2d(segIn.EndPoint().x, pt2);
					pt1.z = segIn.StartPoint().y + nElev;
					pt2.z = segIn.EndPoint().y + nElev;
					segIn.StartPoint() = Wcs2Ecs(pt1, vtEcs);
					segIn.EndPoint() = Wcs2Ecs(pt2, vtEcs);
					ASSERT(fabs(segIn.StartPoint().z-segIn.EndPoint().z)<_DIST_SNAP);
					XPoly2D polyPath;
					segIn.AsPoly2D(polyPath);
					meshEcs.SetPathPoly(polyPath,vtEcs);
					meshEcs.SetShapePoly(polySect);
					if(dc.IsFullExplode())
						meshEcs.ExplodeOrDraw3d(dc);
					else
						dc.DrawEntity(meshEcs);
				} else if(segIn.Is(CURVE_LINE)) {
                    if(CT_IsSameDrt(segIn.XLine::Direction(), 0.0, _angSnap)) {
						//水平段
						XPoly2D polyBot(0);
						XPoint pt1, pt2;
						polyGlass.Polar2d(segIn.StartPoint().x, pt1);
						polyGlass.Polar2d(segIn.EndPoint().x, pt2);
						XCurveSegment segTemp(seg);
						seg.SetPoints(pt1, pt2);
						//polyBot.AppendNode(pt1);
						//polyBot.AppendNode(pt2);
						seg.AsPoly2D(polyBot);
						polyBot.SetElevation(nElev+segIn.StartPoint().y);
						mesh.SetPathPoly(polyBot,mesh.GetNormal().AsAcGeVector3d());
						mesh.SetShapePoly(polyShape);
						mesh.SetShapeBase(XPoint(0, -m_uFrame/2));
						if(dc.IsFullExplode())
							mesh.ExplodeOrDraw3d(dc);
						else
							dc.DrawEntity(mesh);
					} else {
						//垂直段
						double nDirNext=seg.XLine::Direction();
						XPoint ptFirst;
						polyGlass.Polar2d(segIn.StartPoint().x, ptFirst);
						XPoint ptVert[4];
						ads_polar(ptFirst, nDirNext-PI/2, m_vFrame/2, ptVert[0]);
						ads_polar(ptVert[0], nDirNext, m_uFrame, ptVert[1]);
						ads_polar(ptVert[1], nDirNext+PI/2, m_vFrame, ptVert[2]);
						ads_polar(ptVert[0], nDirNext+PI/2, m_vFrame, ptVert[3]);
						XPoly2D poly2d(1);
						for(int k=0; k<4; k++)
							poly2d.AppendNode(ptVert[k]);
						poly2d.SetElevation(nElev+segIn.StartPoint().y);
						dc.DrawMesh(poly2d, XVector3D(0,0, segIn.EndPoint().y-segIn.StartPoint().y));
					}
				} else {
					//圆弧墙上的圆弧棱，目前还不能处理
				}
			}
		}
	} 
	dc.RestoreProperties(prop);
	return TRUE;
}

// 绘制凸窗三维
BOOL TDbOpening::DrawBayWindow3d(XExplodeDraw &dc) const
{
	if (!m_pBayWin)
		return FALSE;
	if (m_opKind != OP_PROWIN)
		return FALSE;

	AcDbObjectId idOldLay = dc.GetLayerId();
	int nOldColor = dc.GetColor();

	XPoly2D polyGlass;
	TADSGePoint3d ptDir;
	//绘制玻璃和平板
	OPENOBJ_BEGIN(m_nIdOfWall, AcDb::kForRead, TDbWall, pWall);
	if (pWall)
	{
		XPoint ptLoc = m_ptLocation;
		ptLoc.z = m_ptLocation.z;
		double nWallThick = pWall->GetWidth(4);
		double nExtDir = m_nRotation + (m_nQuadrant<2? PI/2.0 : -PI/2.0);

		ads_polar(ptLoc, nExtDir, 10000, ptDir);
		double dWallInsut = 0.0;

		int nSide = pWall->OnWhichSide(ptDir);
		if (pWall->IsInsulateOnSide(nSide)) // 得到外保温厚度
		{
			dWallInsut = pWall->GetInsulateThick(nSide);
		}

		DList<XPoly2D> polyCurves;
		m_pBayWin->GetPolyCurve(ptLoc, nExtDir, m_nWidth,  nWallThick, HasLeftSlab(), HasRightSlab(), polyCurves, dWallInsut);

		if (polyCurves.Length() > 1)
		{
			polyGlass = *polyCurves[1];
			DList<XCurveSegment> lstCurve;
			ExplodePoly2D(polyGlass, lstCurve);
			dc.SetColorLayer(colorIndex(), m_idLayerGlass3d);
			dc.DrawCurveList(lstCurve, m_nHeight);
		}

		if ((HasLeftSlab() || HasRightSlab()) && m_pBayWin->m_nStyle==XBayWindow::BWS_RECT)
		{
			XPoly2D polyLeft(1),polyRight(1);
			m_pBayWin->GetVertSlabPoly(ptLoc, nExtDir, m_nWidth, nWallThick, m_nProWinSlabWidth, polyLeft, polyRight);
			if (HasLeftSlab())
			{
				dc.SetColorLayer(colorIndex(), m_idLayerSlab3d);
				// wlw add 150611 pc构件增加凸窗板三维显示到墙顶
				double dLine = 0.0;
				m_XDataMap.GetAt(sKEY_OP_PROWIN_LINE, dLine);
				if (dLine > 0.0)
				{
					polyLeft.SetElevation(pWall->StartPoint().z);
					XVector3D vtUp(0, 0, pWall->GetHeight());
					dc.DrawBody(polyLeft, vtUp);
				}
				else
				{
					polyLeft.SetElevation(ptLoc.z);
					XVector3D vtUp(0, 0, m_nHeight);
					dc.DrawBody(polyLeft, vtUp);
				}
			}
			if (HasRightSlab())
			{
				dc.SetColorLayer(colorIndex(), m_idLayerSlab3d);
				// wlw add 150611 pc构件增加凸窗板三维显示到墙顶
				double dLine = 0.0;
				m_XDataMap.GetAt(sKEY_OP_PROWIN_LINE, dLine);
				if (dLine > 0.0)
				{
					polyRight.SetElevation(pWall->StartPoint().z);
					XVector3D vtUp(0,0,pWall->GetHeight());
					dc.DrawBody(polyRight, vtUp);

				}
				else
				{
					polyRight.SetElevation(ptLoc.z);
					XVector3D vtUp(0,0,m_nHeight);
					dc.DrawBody(polyRight, vtUp);
				}
			}
			polyCurves.Reset();
			m_pBayWin->GetPolyCurve(ptLoc, nExtDir, m_nWidth,  nWallThick,FALSE,FALSE, polyCurves,dWallInsut);
		}

		if (polyCurves.Tail()) 
		{
			dc.SetColorLayer(colorIndex(), m_idLayerSlab3d);
			XPoly2D polyOut = *polyCurves.Tail();
			polyOut.SetFlag(1);
			polyOut.SetElevation(ptLoc.z);
			XVector3D vtUp(0,0,m_nSlabThickness), vtDown(0,0,-m_nSlabThickness);
			dc.DrawBody(polyOut, vtDown);
			polyOut.SetElevation(ptLoc.z+m_nHeight);
			dc.DrawBody(polyOut, vtUp);
		}
		dc.SetLayer(idOldLay);
		dc.SetColor(nOldColor);
	}
	OPENOBJ_END();

	// 绘制窗框
	if (polyGlass.Length())
	{
		DrawFrame3d(dc, polyGlass);
	}
	dc.SetLayer(idOldLay);
	dc.SetColor(nOldColor);
	return TRUE;
}

// 绘制圆弧窗
BOOL TDbOpening::DrawArcWin3d(XExplodeDraw &dc) const
{
	Acad::ErrorStatus es=Acad::eOk;
   XDbObject objWall(m_nIdOfWall, AcDb::kForRead);
   if(!!objWall) {
       TDbWall *pDbWall=TDbWall::cast(objWall.m_pObject);
       ASSERT(pDbWall && pDbWall->Is(CURVE_ARC));
       if(pDbWall) {
           XArc ar=pDbWall->GetArc();
           double nWallThick=pDbWall->GetWidth();
           XPoint ptLoc=m_ptLocation;
		   
		   TADSGePoint3d ptCen = ar.GetCenterPt();
		   ptCen.z = ptLoc.z;
           ar.SetCenterPt(ptCen);

           XPoint ptOnWall=ptLoc;
           pDbWall->ProjectToMe(ptLoc, ptOnWall);
           double nRad=ar.GetCenterPt().Distance2d(ptOnWall);
           double nSweepAng=m_nWidth/nRad;
           double nStartAng=CT_std_angle(ads_angle(ar.GetCenterPt(), ptOnWall)-nSweepAng/2.0),
               nEndAng=CT_std_angle(ads_angle(ar.GetCenterPt(), ptOnWall)+nSweepAng/2.0);
           XArc arMid(ar.GetCenterPt(), ads_distance(ar.GetCenterPt(), ptLoc), nStartAng, nEndAng);
		   TMasterProperties prop;
		   dc.BackUpProperties(prop);
           //AcDbObjectId idLay=dc.GetLayerId();
		   int nOldColor=dc.GetColor();
           dc.SetColorLayer(colorIndex(),m_idLayerGlass3d);
           dc.DrawArc(arMid, m_nHeight);
		   dc.RestoreProperties(prop);
		   XCurveSegment seg;
		   seg=arMid;
		   XPoly2D polyGlass;
		   seg.AsPoly2D(polyGlass);
		   DrawFrame3d(dc, polyGlass);
       }
   } else { //画个示意图
       XPoly2D polyShow(1);
       GetOutlinePoly(0.0, polyShow);
       dc << polyShow;
	   es=Acad::eInvalidInput;
   }

   return es;
}

// 炸碎或者绘制三维门窗
Acad::ErrorStatus TDbOpening::ExplodeOrDraw3d(XExplodeDraw &dc) const
{
	if(!Has3D())
		return Acad::eOk;

    Acad::ErrorStatus es=Acad::eCannotExplodeEntity;
	//下面代码导致工程管理导出三维实体时洞口被屏蔽，特此注释，但该代码以前的用处并不明朗，如发现其确实有用，再商讨是否打开。2015-7-21
	/*if(m_opKind==OxianzaP_HOLE && _tcscmp(dc.Desc(), XExplodeStream::Descriptor())==0)
	return es;*/
    OPENOBJ_BEGIN(m_nIdOfWall, AcDb::kForRead, TDbWall, pWall);
    if(pWall) {
        if(!g_bIntWall3DVisible && !pWall->IsExternal(OFFSET_LEFT) && !pWall->IsExternal(OFFSET_RIGHT))
            return Acad::eOk; //关闭内墙显示
    }
    OPENOBJ_END();


	
    if(!objectId() && !!m_nIdOfWall && _tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0) {
        //拖曳
        DragDraw((XAcGiViewDraw &)dc);
    }


    if(m_opKind==OP_HOLE) {
        XPoly2D poly(1);
        GetElevOutline(poly); //已经折线化了
        dc << poly;
        return Acad::eOk;
    }

    if(m_opKind==OP_ARCWIN) { //弧墙上的弧窗
		DrawArcWin3d(dc);
   } else if(m_opKind==OP_CORNWIN) { //转角窗
       DrawBanWin(dc, TRUE);
   } else if(m_opKind==OP_DOORWIN) {
       ExplodeOrDrawDoorWin(dc, TRUE);
   } else if(m_opKind==OP_TWODOOR) {
       ExplodeOrDrawTwoDoor(dc, TRUE);
   } else if(m_opKind==OP_PROWIN) { //凸窗
	   DrawBayWindow3d(dc);
   } else  if(g_bOsnapExpl) { // OSNAP需要加速
        XPoly2D poly(1);
        GetElevOutline(poly); //已经折线化了
        dc << poly;
   } else {
	   if(m_lstFrameLines.Length()) {
		   XPoly2D polyGlass;
		   XCurveSegment segGlass;
		   GetSidePoints(segGlass.StartPoint(), segGlass.EndPoint());
		   segGlass.AsPoly2D(polyGlass);
		   DrawFrame3d(dc, polyGlass);

		   TMasterProperties prop;
		   dc.BackUpProperties(prop);
		   segGlass.SetElevation(GetElevation());
		   dc.SetColorLayer(colorIndex(), m_idLayerGlass3d);
		   dc.DrawCurve(segGlass, m_nHeight);
		   dc.RestoreProperties(prop);
	   } else {
		   double nScaleX, nScaleY, nScaleZ;
		   if(GetInsert3DScale(&nScaleX, &nScaleY, &nScaleZ)!=Acad::eOk)
			   return es;

		   AcDbObjectId idStyle=!m_nIdStyle3d? m_nIdStyle2d:m_nIdStyle3d;

		   XPoint ptInsert=m_ptLocation; 
		   if(!(!m_nIdStyle3d)) { //显示真三维
			   dc<<XBlockRef(idStyle, ptInsert, AcGeScale3d(nScaleX, nScaleY, nScaleZ), m_nRotation, g_bMakeBlock);
		   } else if(!!m_nIdStyle2d) {
			   dc<<XBlockRef(idStyle, ptInsert, AcGeScale3d(nScaleX, nScaleY, m_nHeight), m_nRotation, g_bMakeBlock);
		   }
	   }
   }

   return Acad::eOk;
}

//展开
// entSetFix－固定的窗框，entSetCustom－客户定义的窗棱
BOOL TDbOpening::ExpandFrame(AcDbVoidPtrArray &entSetFix, AcDbVoidPtrArray &entSetCustom) const
{
    XPoly2D polyGlass;
	
    if(m_opKind==OP_HOLE) 
		return FALSE;
    if(m_opKind==OP_ARCWIN) { //弧墙上的弧窗
       XDbObject objWall(m_nIdOfWall, AcDb::kForRead);
       if(!!objWall) {
           TDbWall *pDbWall=TDbWall::cast(objWall.m_pObject);
           ASSERT(pDbWall && pDbWall->Is(CURVE_ARC));
           if(pDbWall) {
               XArc ar=pDbWall->GetArc();
               double nWallThick=pDbWall->GetWidth();
               XPoint ptLoc=m_ptLocation;
               			   
			   TADSGePoint3d ptCen = ar.GetCenterPt();
			   ptCen.z = ptLoc.z;
			   ar.SetCenterPt(ptCen);
			   
               XPoint ptOnWall=ptLoc;
               pDbWall->ProjectToMe(ptLoc, ptOnWall);
               double nRad=ar.GetCenterPt().Distance2d(ptOnWall);
               double nSweepAng=m_nWidth/nRad;
               double nStartAng=CT_std_angle(ads_angle(ar.GetCenterPt(), ptOnWall)-nSweepAng/2.0),
                   nEndAng=CT_std_angle(ads_angle(ar.GetCenterPt(), ptOnWall)+nSweepAng/2.0);
               XArc arMid(ar.GetCenterPt(), ads_distance(ar.GetCenterPt(), ptLoc), nStartAng, nEndAng);
			   XCurveSegment seg;
			   seg=arMid;
			   seg.AsPoly2D(polyGlass);
           }
       } else { 
		   return FALSE;
       }
   } else if(m_opKind==OP_CORNWIN) { //带形窗
       XCurveSegment segLeftSide, segLeft, segMid, segRight, segRightSide;
	   if(!GetBanWinSegs(segLeftSide, segLeft, segMid, segRight, segRightSide))
			return FALSE;
	   segMid.AsPoly2D(polyGlass);
   } else if(m_opKind==OP_DOORWIN) {
       return FALSE;
   } else if(m_opKind==OP_TWODOOR) {
       return FALSE;
   } else if(m_opKind==OP_PROWIN) { //凸窗
	   if(!m_pBayWin)
		   return FALSE;
       DList<XPoly2D> polyCurves;
	   OPENOBJ_BEGIN(m_nIdOfWall, AcDb::kForRead, TDbWall, pWall);
	   if(pWall) 
	   {
		   XPoint ptLoc=m_ptLocation,ptDir;
		   ptLoc.z = m_ptLocation.z;
		   double nWallThick=pWall->GetWidth(4);
		   double nExtDir=m_nRotation + (m_nQuadrant<2? PI/2.0 : -PI/2.0);

		   ads_polar(ptLoc, nExtDir, 10000, ptDir);
		   double dWallInsut = 0.0;
		   int nSide = pWall->OnWhichSide(ptDir);
		   //得到外保温厚度
		   if (pWall->IsInsulateOnSide(nSide))
		   {
			   dWallInsut = pWall->GetInsulateThick(nSide);
		   }
		   m_pBayWin->GetPolyCurve(ptLoc, nExtDir, m_nWidth,  nWallThick,HasLeftSlab(),HasRightSlab(),polyCurves);
		   polyGlass=*polyCurves[1];
	   }
	   OPENOBJ_END();
   } else { //普通门窗
	   XCurveSegment segLine;
	   GetSidePoints(segLine.StartPoint(), segLine.EndPoint());
	   segLine.AsPoly2D(polyGlass);
   }
   if(!polyGlass)
	   return FALSE;

	XPoly2D polyOut(1);
	XPoint ptOut[4];
	ptOut[1].x = ptOut[2].x = polyGlass.Distance2d();
	ptOut[2].y = ptOut[3].y = m_nHeight;
	for(int n=0; n<4; n++)
		polyOut.AppendNode(ptOut[n]);
	AcDbPolyline *pOutline=new AcDbPolyline;
	PolyConvert(polyOut, *pOutline);
	entSetFix.append(pOutline);

	double nDist=0.0;
	for(int i=1; i<polyGlass.Length()-1; i++) {
		XCurveSegment seg;
		polyGlass.Nth(i-1, seg);
		nDist += seg.GetLength();
		XPoint ptSep[2];
		ptSep[0].x=ptSep[1].x=nDist;
		ptSep[1].y=m_nHeight;
		entSetFix.append(new AcDbLine(ptSep[0], ptSep[1]));
	}

	for(i=0; i<m_lstFrameLines.Length(); i++)
		entSetCustom.append(m_lstFrameLines[i].AsAcDbCurve());
	return TRUE;
}


//modified by whl on 0806024
//子母门作为门，组合门窗根据KindString识别
const TCHAR * TDbOpening::GetDefaultLayer() const
{
	const TCHAR *pLay = NULL;
	// if (m_opKind==OP_DOOR || m_opKind==OP_DOORWIN || m_opKind==OP_TWODOOR)
	//    pLay = LAY_DOOR;
	// sg modify 110217，对防火门、防火卷帘进行了特殊图层设置
	if (m_opKind == OP_DOOR) // 门
	{
		CString csSubType = GetSubKind(); // 子类型
		if (csSubType.Find(_T("防火门")) >= 0)
		{
			pLay = LAY_FIRE_DOOR;
		}
		else if (csSubType.Find(_T("防火卷帘")) >= 0)
		{
			pLay = LAY_FIRE_JL;
		}
		// sg add 111018，增加考虑隔断门在特殊的图层上，以前没有考虑
		else if ((m_nOpStyle&OPS_LVTRY) || csSubType.Compare(_T("隔断门"))==0)
		{
			pLay = LAY_LATRINE;
		}
		else
		{
			pLay = LAY_DOOR;
		}
	}
	else if (m_opKind==OP_DOORWIN || m_opKind==OP_TWODOOR) // 门连窗、子母门
		pLay = LAY_DOOR;
	else if (m_opKind == OP_HOLE) // 洞口
		pLay = LAY_HOLE2D;
	else 
	{
		// sg modify 110217，对防火门、防火卷帘进行了特殊图层设置
		CString csSubType = GetSubKind(); // 子类型
		if (csSubType.Find(_T("防火窗")) >= 0)
		{
			pLay = LAY_FIRE_WIN;
		}
		else if (csSubType.Find(_T("防火卷帘")) >= 0)
		{
			pLay = LAY_FIRE_JL;
		}
		else
		{
			CString sKind = GetKindString();
			if (sKind.Find(_T("门")) >= 0)
				pLay = LAY_DOOR;
			else
				pLay = LAY_WIN;
		}
	}
    return pLay;
}

// 设置类型: 门,窗,洞
void TDbOpening::SetKind(OpeningKind opk) 
{
	m_opKind=opk;
	const TCHAR *szLay=NULL;
	switch(m_opKind) 
	{
		case OP_HWINDOW: szLay=LAY_DOOR; break;
		case OP_WINDOW: szLay=LAY_WIN; break;
		case OP_DOOR: szLay=LAY_DOOR; break;
		case OP_HOLE: szLay=LAY_HOLE2D; break;
	}
	if(szLay) 
		setLayer(szLay);
}

bool TDbOpening::IsDoorAsWin()const
{
	if(GetKind()!=OP_DOOR)
		return false;

    if(!m_nIdStyle2d)
        return false;

    OPENOBJ_BEGIN(m_nIdStyle2d, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
    if(pBlock!=NULL)
	{
		// 从扩展实体数据取出原始墙厚
		resbuf *pxData=pBlock->xData(TCHXD);
		if(pxData!=NULL)
		{
			resbuf *pNext=pxData->rbnext;
			if(pNext && pNext->restype==1040) 
			{
				double nWallThick= pNext->resval.rreal;
				if(fabs(nWallThick)>1E-6)//这个墙厚只用来判断是不是推拉门
					return true;
			}
			ads_relrb(pxData);
		}
	}
    OPENOBJ_END();
    return false;
}
Acad::ErrorStatus TDbOpening::GetInsert2DScale(double *pScaleX, double *pScaleY) const
{
   assertReadEnabled();
   double nScaleX, nScaleY;

   nScaleY = GetWallThickness(TRUE);
   if(m_opKind==OP_DOOR
	   &&!IsDoorAsWin())//add by whl on 050728,不是推拉门等与墙厚有关的门
	   nScaleY=m_nWidth;

   nScaleX=m_nWidth;
   if(m_nQuadrant==1) 
	   nScaleX = -nScaleX;
   else if(m_nQuadrant==2) 
   {
       nScaleX = -nScaleX;
       nScaleY = -nScaleY;
   }
   else if(m_nQuadrant==3) 
	   nScaleY = -nScaleY;

   *pScaleX = nScaleX;
   *pScaleY = nScaleY;
   return Acad::eOk;
}

///////////////////////////////////////////////////////////
//  static 求3D图块的原始尺寸
BOOL TDbOpening::GetOriginal3DSize(AcDbObjectId idStyle3d, XPoint &sizeXYZ)
{
    if(!idStyle3d)
        return FALSE;
    BOOL nRet=FALSE;
    OPENOBJ_BEGIN(idStyle3d, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
    if(!pBlock)
        return FALSE;

    // 从扩展实体数据取出原始尺寸
    resbuf *pxData=pBlock->xData(TCHXD);
    if(!pxData) {
        AcDbBlockReference entInsert;
        entInsert.setBlockTableRecord(idStyle3d);
        AcDbExtents ext;
        if(entInsert.getGeomExtents(ext)!=Acad::eOk)
            return FALSE;
        AcGePoint3d ptMax=ext.maxPoint(), ptMin=ext.minPoint();
        double sx=ptMax.x-ptMin.x;
        double sz=ptMax.z-ptMin.z;
        if(sx<_DIST_SNAP || sz<_DIST_SNAP)
            return FALSE;
        sizeXYZ=XPoint(sx,60.0,sz);
        nRet=TRUE;
    } else {
        resbuf *pNext=pxData->rbnext;
        if(pNext && pNext->restype==1040) {
           double sx = pNext->resval.rreal;
           pNext=pNext->rbnext;
           if(pNext && pNext->restype==1040) {
               double sz = pNext->resval.rreal;
               ASSERT(sx>_DIST_SNAP && sz>_DIST_SNAP);
               sizeXYZ = XPoint(sx,60.0,sz);
               nRet = TRUE;
           }
        }
        ads_relrb(pxData);
    }

    OPENOBJ_END();
    return nRet;
}

// 求3D插入比例
Acad::ErrorStatus TDbOpening::GetInsert3DScale(double *pScaleX, double *pScaleY, double *pScaleZ) const
{
   assertReadEnabled();

   double nScaleX, nScaleY, nScaleZ;
   if(!(!m_nIdStyle3d)) { // Use 3dStyle
       XPoint origenalSize;
       if(!GetOriginal3DSize(m_nIdStyle3d, origenalSize))
           return Acad::eInvalidInput;
       nScaleX = origenalSize.x>_DIST_SNAP? (m_nWidth/origenalSize.x) : 1.0;
       nScaleY = origenalSize.y>_DIST_SNAP? (m_nThickness/origenalSize.y) : 1.0;
       nScaleZ = origenalSize.z>_DIST_SNAP? (m_nHeight/origenalSize.z) : 1.0;
       if(origenalSize.y>origenalSize.x/2.0) //旋转门
           nScaleY=nScaleX;
       else
           nScaleY=1.0;
   } else { // Use 2d Extrude
       XDbObject objBlock(m_nIdStyle2d, AcDb::kForRead);
       if(!objBlock)
           return Acad::eInvalidInput;
       AcDbBlockTableRecord *pBlock = AcDbBlockTableRecord::cast(objBlock.m_pObject);
       if(m_opKind==OP_DOOR) nScaleY=m_nWidth;
       else   nScaleY=GetWallThickness();
       nScaleX=m_nWidth;
       nScaleZ=1.0;
   }

   // 镜像情况
   if(m_nQuadrant==1) nScaleX = -nScaleX;
   else if(m_nQuadrant==2) {
       nScaleX = -nScaleX;
       nScaleY = -nScaleY;
   } else if(m_nQuadrant==3) nScaleY = -nScaleY;

   *pScaleX = nScaleX;
   *pScaleY = nScaleY;
   *pScaleZ = nScaleZ;
   return Acad::eOk;
}



// 把门窗插入墙内
Acad::ErrorStatus 
TDbOpening::InsertIntoWall(TDbWall *pWall)
{
    assertWriteEnabled();
    m_nRotation = pWall->Direction(m_ptLocation); 
    //m_nThickness = pWall->GetWidth();

    XPoint ptNewLoc;
    pWall->GetOpeningLocation(m_ptLocation, GetKind(), m_nWidth, ptNewLoc);
    m_ptLocation = ptNewLoc;

    m_nIdOfWall = pWall->objectId();

    AcDbObjectId idTextStyle = m_idTextStyle; //
	if(!idTextStyle.isValid())
		idTextStyle=InitTextStyle(TS_WINDOW,database());
    XDbObject objTextStyle(idTextStyle, AcDb::kForRead);
    ads_real nDistToLocation=pWall->GetWidth();
    if(!objTextStyle) ;
    else {
        AcDbTextStyleTableRecord *pTextStyle=AcDbTextStyleTableRecord::cast(objTextStyle.m_pObject);
        if(pTextStyle) nDistToLocation += pTextStyle->textSize()*GetPScale();
    }


    //门的标号搁到开向的另一侧,窗总搁到外侧
	/*
    ads_real nExtDrt = pWall->ExtDirection(m_ptLocation);
    ads_real nDrtLabel= CT_std_angle(nExtDrt+PI);
    ads_polar(m_ptLocation, nDrtLabel, nDistToLocation, m_ptLabel);
    m_ptLabel.z = 0; 
	*/

	double nWallWidth=pWall->GetWidth();
    nDistToLocation=nWallWidth/2;
	double nDist2Wall=GetTextHeight()/2;
	nDist2Wall += DocGetText2Base();
	nDistToLocation += nDist2Wall*GetPScale();
    XPoint ptLab;
    ads_polar(m_ptLocation, m_nRotation+(m_nQuadrant>=2? 1.0 : -1.0)*PI/2, nDistToLocation, ptLab);
    ptLab.z = 0; 
    m_ptLabel= ptLab;

    return Acad::eOk;
}


XPoint TDbOpening::GetDefaultLabPos() const
{
    double nWallWidth=GetWallThickness(TRUE);

    ads_real nDistToLocation=nWallWidth/2;
	double nDist2Wall=GetTextHeight()/2;
	nDist2Wall += DocGetText2Base();
	nDistToLocation += nDist2Wall*GetPScale();
    XPoint ptLab;
    ads_polar(m_ptLocation, m_nRotation+(m_nQuadrant>=2? 1.0 : -1.0)*PI/2, nDistToLocation, ptLab);
    ptLab.z = 0; 
    return ptLab;
}


// 验证调整和墙的配属关系
// 方法: 如果有配属的墙则验证是否成立配属关系; 否则寻找一配属墙,确立新的关系
// 注意: 在命令结束时处理
void TDbOpening::ValidateContainership(DList<AcDbObjectId> &lstWalls)
{
    assertWriteEnabled();
	
	// add by xlc on 110131 普通的独立门窗不进行验证
	if ((m_opKind == OP_DOOR || m_opKind == OP_WINDOW) && IsLoneOpening())
	{
		return;
	}

   if(!(!m_nIdOfWall)) 
   {  //验证原来的配属关系是否成立
       XDbObject obj(m_nIdOfWall, AcDb::kForRead);
       if(!(!obj))
	   {
           TDbWall *pWall = TDbWall::cast(obj.m_pObject);
           if(pWall) 
		   {
               if(!pWall->CanContain(*this)) 
			   {
                   if(pWall->upgradeOpen()==Acad::eOk) 
				   {
                       pWall->assertWriteEnabled();
                       ::RemoveContainership(pWall, this);
                       pWall->downgradeOpen();
                   }
               } 
			   else 
			   { //确保互相引用关系
				   AcDbObjectId __id = objectId();
					if(!pWall->m_lstOpeningId.FindNode(&__id, CompareObjectId)) 
					{
						if(pWall->upgradeOpen()==Acad::eOk) 
						{
							pWall->assertWriteEnabled();
							pWall->m_lstOpeningId.Append(new AcDbSoftPointerId(objectId()));
							pWall->downgradeOpen();
						}
					}
					XPoint ptLoc;
					if(pWall->GetOpeningLocation(m_ptLocation, GetKind(), GetWidth(), ptLoc)) 
					{
						m_ptLocation=ptLoc;
						ptLoc.z = pWall->GetElevation();
						
						double nWallDirection = pWall->Direction(ptLoc);
						
						double nDirectionOld=m_nRotation;
						m_nRotation=nWallDirection;
						//计算相对角(<=PI）
						double nA=CT_std_angle(m_nRotation-nDirectionOld);
						if(nA>PI)
							nA=PI*2-nA;
						if(nA>(PI/2+1E-6))//墙方向与当前方向夹角大于90度时，尽量维持原开启方向
						{
							if(m_nQuadrant==0)
								m_nQuadrant=2;
							else if(m_nQuadrant==2)
								m_nQuadrant=0;
							else if(m_nQuadrant==1)
								m_nQuadrant=3;
							else
								m_nQuadrant=1;
						}
					}
               }
           }
       }
   }

   // 如果没有配属关系,则重新建立
   if(!m_nIdOfWall) 
   { 
       for(int i=0; i<lstWalls.Length(); i++) 
	   {
           XDbObject obj(*lstWalls[i], AcDb::kForWrite);
           if(!obj) continue;
           TDbWall *pWall = TDbWall::cast(obj.m_pObject);
           if(!pWall) continue;
           
           if(pWall->CanContain(*this)) 
		   { 
               XPoint ptOld=m_ptLabel;
               double nDirectionOld=m_nRotation;
               pWall->InsertOpening(this);
               resbuf *xdata=xData(_T("TDOTE"));
               if(xdata && xdata->rbnext && xdata->rbnext->restype==1010) 
			   { //转换旧图
                    XPoint ptData=xdata->rbnext->resval.rpoint;
                    if(CT_IsExactSameDrt(ptData.z, m_nRotation, _angSnap)) 
					{
                        if(ptData.x>0) 
						{
                            if(ptData.y>0)  
								m_nQuadrant=0;
                            else 
								m_nQuadrant=3;
                        } 
						else 
						{
                            if(ptData.y>0) m_nQuadrant=1;
                            else m_nQuadrant=2;
                        }
                    }
					else 
					{
                        ptData.x = - ptData.x;  
                        ptData.y = - ptData.y;
                        if(ptData.x>0) 
						{
                            if(ptData.y>0) 
								m_nQuadrant=0;
                            else 
								m_nQuadrant=3;
                        } 
						else 
						{
                            if(ptData.y>0) 
								m_nQuadrant=1;
                            else
								m_nQuadrant=2;
                        }
                    }
                    if(xdata->rbnext)
                        ads_relrb(xdata->rbnext);
                    xdata->rbnext=NULL;
                    m_ptLabel=ptOld;

                    setXData(xdata);
                    ads_relrb(xdata);
               } 
			   else
			   {
                   //modified by whl on 070611
				    //计算相对角(<=PI）
					double nA=CT_std_angle(m_nRotation-nDirectionOld);
					if(nA>PI)
						nA=PI*2-nA;
					if(nA>(PI/2+1E-6))//墙方向与当前方向夹角大于90度时，尽量维持原开启方向
					{
					   if(m_nQuadrant==0)
						   m_nQuadrant=2;
					   else if(m_nQuadrant==2)
						   m_nQuadrant=0;
					   else if(m_nQuadrant==1)
						   m_nQuadrant=3;
					   else
						   m_nQuadrant=1;
                   }

				   if(CT_IsSameDrt(nDirectionOld, m_nRotation, _angSnap))//墙方向不变时，编号位置不变,否则成为默认位置
					   m_ptLabel=ptOld;
               }
               break;
           }
       }
   }
}
void TDbOpening::ValidateDim(DList<AcDbObjectId> &lstDims)
{
	if(lstDims.Length()<1)
		return;

    assertWriteEnabled();	
	bool bErased=isErased()==Adesk::kTrue; 
	XPoint ptNew0,ptNew1;
	GetSidePoints(ptNew0,ptNew1);
	for(long i=0;i<lstDims.Length();i++)
	{
		AcDbObjectId id=*lstDims[i];
		TDbDimension2 *pDim=NULL;
		acdbOpenObject(pDim,id,AcDb::kForRead);
		if(pDim!=NULL)
		{
			if(pDim->ownerId()==ownerId()&&//add by whl on 060829，属于同一块内
				!pDim->IsAngular()&&pDim->IsAssociate())
				pDim->UpdateFrom(ptNew0,ptNew1,m_ptBackOld,m_ptFrontOld,bErased);
			pDim->close();
		}
	}
}


void TDbOpening::MirrorSelf(BOOL bLeftRight) //左右镜像或上下进行
{
    assertWriteEnabled();
    int nQua=m_nQuadrant;
    switch(nQua) {
    case 0:
        nQua=bLeftRight? 1 : 3;
        break;
    case 1:
        nQua=bLeftRight? 0 : 2;
        break;
    case 2:
        nQua=bLeftRight? 3: 1;
        break;
    case 3:
        nQua=bLeftRight? 2 : 0;
        break;
    }
    m_nQuadrant=nQua;
                
    if(!bLeftRight) { //编号位置镜像
        XLine ln(m_ptLocation, m_nRotation);
        ln.SetElevation(m_ptLabel.z);
        XPoint ptPrj;
        if(m_ptLabel.Project(&ln, ptPrj)==RTNORM) {
            ptPrj.Mirror(XPoint(m_ptLabel), m_ptLabel);
        }

		//add by xlc on 110215 调整单侧门口线开启侧
		if (!(
			(m_nOpStyleEx & OPS_DOORLINE_MID)								//居中
			|| (m_nOpStyle & (OPS_DOORLINE1+OPS_DOORLINE2)) == 0			//无门口线
			|| (m_nOpStyle | (OPS_DOORLINE1+OPS_DOORLINE2)) == m_nOpStyle	//双侧门口线
			)
			)
		{
			if (m_nOpStyle & OPS_DOORLINE1)
			{
				m_nOpStyle &= ~OPS_DOORLINE1;
			}
			else
			{
				m_nOpStyle |= OPS_DOORLINE1;
			}
			if (m_nOpStyle & OPS_DOORLINE2)
			{
				m_nOpStyle &= ~OPS_DOORLINE2;
			}
			else
			{
				m_nOpStyle |= OPS_DOORLINE2;
			}
		}
    }
}



/* * * * * * * * * * 取 动 态 属 性 显 示 数 据 的 函 数 * * * * * * * * * */
void TDbOpening::GetTips(DList<TObjInfoUnit> &lstInfo) const
{
	//add by whl
	AcDbHandle h;
	getAcDbHandle(h);
	TCHAR pBuf[1024];
	h.getIntoAsciiBuffer(pBuf);
	lstInfo.Append(new TObjInfoUnit(_T("对象句柄"), pBuf));

	XString sName=GetKindString();
	lstInfo.Append(new TObjInfoUnit(_T("门窗类型"), sName));
	lstInfo.Append(new TObjInfoUnit(_T("门窗编号"), m_sLabel));
	lstInfo.Append(new TObjInfoUnit(_T("宽度"), Dist2Str(m_nWidth)));
	lstInfo.Append(new TObjInfoUnit(_T("高度"), Dist2Str(m_nHeight)));
	lstInfo.Append(new TObjInfoUnit(_T("离地高度"), Dist2Str(m_ptLocation[2])));
	lstInfo.Append(new TObjInfoUnit(_T("转角"), Angle2Str(m_nRotation*180.0/PI)));
	lstInfo.Append(new TObjInfoUnit(_T("洞墙面积比"), XString(_T("%.3f"), GetAreaIndex())));
}

//只能用于当前图对象，设置缺省子图层和文字样式
void TDbOpening::InitHardPointerId()
{
	m_idTextStyle=InitTextStyle(TS_WINDOW);
	m_idLayerFrame3d=InitLayer(LAY_3DFRAME, FALSE);
	m_idLayerGlass3d=InitLayer(LAY_3DGLASS, FALSE);
	m_idLayerSlab3d=InitLayer(LAY_WALL, FALSE);

	// sg modify 110223，防火门、防火窗、防火卷帘中的门窗标注单独存放一个图层
	// m_idLayerText=InitLayer(LAY_OPENING_DIM, FALSE);
	if (m_opKind==OP_DOOR || m_opKind==OP_WINDOW || m_opKind==OP_ARCWIN)
	{
		CString csSubType = GetSubKind(); // 子类型
		if (csSubType.Find(_T("防火门"))>=0 || csSubType.Find(_T("防火卷帘"))>=0 || csSubType.Find(_T("防火窗"))>=0)
		{
			m_idLayerText=InitLayer(LAY_FILEOPENING_DIM, FALSE);
		}
		else
		{
			m_idLayerText=InitLayer(LAY_OPENING_DIM, FALSE);
		}
	}
	else
	{
		m_idLayerText=InitLayer(LAY_OPENING_DIM, FALSE);
	}

	TDbConfig *pConfig=GetDwgGlobal(AcDb::kForWrite,g_pCurrentDb);
	if(pConfig)
		pConfig->close();
}

/* ----------------------------------------------------------------------- */
void TDbOpening::UpdateOwnerWallGraphic() const
{
    if(!!m_nIdOfWall) {
        PickSet ss(SS_FREE);
        ss += m_nIdOfWall;
        UpdateGraphic(ss);
    }
}

//--------------------------------------------------------------------------------------------------------
//////////////////////////////////////////////////////////////////////////////////////////////////////////
// 节能属性

//窗墙面积比：>0正常，其他为错误发生
double TDbOpening::GetAreaIndex() const
{
	double nRatio=0.0;
	OPENOBJ_BEGIN(m_nIdOfWall, AcDb::kForRead, TDbWall, pWall);
	if(pWall && pWall->IsValid()) {
		XCurveSegment segCen=pWall->OffsetGeomCenter(LS_FINITE, TRUE);
		double nAreaWall=_AS_METER(segCen.GetLength())*_AS_METER(pWall->GetHeight())*pWall->GetShapeRatio();
		double nAreaWin=_AS_SQMETER(GetOutlineArea());
		nRatio=nAreaWin/nAreaWall;
	}
	OPENOBJ_END();
	return nRatio;
}

//求方位角：弧窗取中心点的朝向
//弧度：>=0正常，<0错误发生：如内门窗等
double TDbOpening::GetAzimuth() const
{
	double nAzimuth=-1.0;
	OPENOBJ_BEGIN(m_nIdOfWall, AcDb::kForRead, TDbWall, pWall);
	if(pWall && pWall->IsValid()) {
		int nSide=pWall->GetExtSide();
		if(nSide==0 || nSide==1) {
			nAzimuth=pWall->GetAzimuth(nSide, m_ptLocation);
		}
	}
	OPENOBJ_END();
	return nAzimuth;
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////
//--------------------------------------------------------------------------------------------------------

#if 0

///////////////////////////////////////////////////////////////////
// 通过量化属性取得属性量
Acad::ErrorStatus TDbOpening::GetQuantumByName(const TCHAR *pszName, double *pQuantum) const 
{
    ASSERT(pszName && pQuantum);
    Acad::ErrorStatus es = Acad::eOk; 
    double nRes=0.0;
    if(_tcscmp(pszName, OP_QUANTUM_1)==0) {
        nRes = AS_METER(GetOutlineLength());
    } else if(_tcscmp(pszName, OP_QUANTUM_2)==0) {
        nRes = _AS_SQMETER(GetOutlineArea());
    } else if(_tcscmp(pszName, OP_QUANTUM_3)==0) {
        nRes = AS_METER(GetWidth());
    }  else {
        es = Acad::eInvalidInput;
    }
    *pQuantum = nRes;
    return es;
}

///////////////////////////////////////////////////////////
// 初始化注册量化的属性名字
void TDbOpening::InitQuantumProtocol(BOOL bTrue)
{
    static XQuantumProtocol *pProtocol=NULL;
    if(bTrue) {
        pProtocol=new XQuantumProtocol;
        pProtocol->m_lstQuantumNames.Append(strnew(OP_QUANTUM_1));
        pProtocol->m_lstQuantumNames.Append(strnew(OP_QUANTUM_2));
        pProtocol->m_lstQuantumNames.Append(strnew(OP_QUANTUM_3));
        desc()->addX(XQuantumProtocol::desc(), pProtocol);
    } else {
        desc()->delX(XQuantumProtocol::desc());
        delete pProtocol;
        pProtocol = NULL;
    }
}

void TDbOpening::InitProperty(BOOL bTrue)
{
    m_lstProperties.Reset();
    if(!bTrue)
        return;
    m_lstProperties.Append(new XAccessObjectProperty(/*UMSG*/_T("类别"), (PropertyFun)AccessKind, FALSE));
    m_lstProperties.Append(new XAccessObjectProperty(/*UMSG*/"编号", (PropertyFun)AccessLabel, TRUE));
    m_lstProperties.Append(new XAccessObjectProperty(
        /*UMSG*/"宽度,(mm)", (PropertyFun)AccessWidth, TRUE, VT_I4, "%d"));
    m_lstProperties.Append(new XAccessObjectProperty(
        /*UMSG*/"高度,(mm)", (PropertyFun)AccessHeight, TRUE, VT_I4, "%d"));
    m_lstProperties.Append(new XAccessObjectProperty(
        /*UMSG*/"厚度,(mm)", (PropertyFun)AccessThickness, TRUE, VT_I4, "%d"));
    m_lstProperties.Append(new XAccessObjectProperty(
        /*UMSG*/"窗台高度,(mm)", (PropertyFun)AccessSill, TRUE, VT_I4, "%d"));
    m_lstProperties.Append(new XAccessObjectProperty(
        /*UMSG*/"面积,(m^2)", (PropertyFun)AccessArea, FALSE, VT_R8, "%6.2f"));
    m_lstProperties.Append(new XAccessObjectProperty(
        /*UMSG*/"周长,(mm)", (PropertyFun)AccessPerimeter, FALSE, VT_I4, "%d"));
}

#endif

void InitDbOpening(BOOL bTrue)
{
    if(bTrue) {
        TDbOpening::rxInit();
        acrxBuildClassHierarchy();
        TDbOpening::InitMatchProtocol(TRUE);
        //TDbOpening::InitProperty(TRUE);
        //TDbOpening::InitQuantumProtocol(TRUE);
    } else {
        //TDbOpening::InitQuantumProtocol(FALSE);
        //TDbOpening::InitProperty(FALSE);
        TDbOpening::InitMatchProtocol(FALSE);
        deleteAcRxClass(TDbOpening::desc());
    }
}

TARCH_IMPEXP void CheckOp3dStyle(AcDbObjectId idStyle3d)
{
    AssureLayer(LAY_KEY, LAYSTAT_UNLOCK);
    OPENOBJ_BEGIN(idStyle3d, AcDb::kForWrite, AcDbBlockTableRecord, pBlockRec);
    if(pBlockRec) {
        resbuf *rbxdOld=pBlockRec->xData(TCHXD);
        if(!rbxdOld) {
            BOOL bSetXD=FALSE;
            XPoint ptMin, ptMax;
            BOOL bInitExt=FALSE;
            XString sBoundHandle;
			RBList rbPointMask(RTDXF0, _T("POINT"), 8, LAY_KEY, 62, 1, NULL);
			RBList rbBoundMask(RTDXF0, _T("LWPOLYLINE,POLYLINE"), 8, LAY_BOUNDARY, 70, 1, NULL);
			RBList rbShadeMask(8, _T("ASHADE"), NULL);
			RBList rbMaterMask(RTDXF0,_T("INSERT"),2, _T("RM_SDB"), NULL);

            //遍历块表记录,寻找轮廓的POLYLINE
            AcDbBlockTableRecordIterator* pBlockIterator=NULL;
            VERIFY(pBlockRec->newIterator(pBlockIterator)==Acad::eOk);
            for (pBlockIterator->start(); !pBlockIterator->done();  pBlockIterator->step())     {
                AcDbEntity *pEntity;
                VERIFY(pBlockIterator->getEntity(pEntity, AcDb::kForRead)==Acad::eOk);
                Entity ent;
                acdbGetAdsName(ent.name, pEntity->objectId());
                if(ent.MatchBase(rbPointMask)) {
                    resbuf *rbxd=pEntity->xData(TCHXD);
                    if(pEntity->upgradeOpen()==Acad::eOk) {
                        pEntity->erase();
                        pEntity->downgradeOpen();
                    }
                    if(rbxd) {
                        pBlockRec->setXData(rbxd);
                        ads_relrb(rbxd);
                        bSetXD=TRUE;
                        pEntity->close();
                        break;
                    }
                } else if(ent.MatchBase(rbBoundMask)){
                    ent.GetData(5, (TCHAR *)sBoundHandle);
				} else if(ent.MatchBase(rbShadeMask)) {
				} else if(ent.MatchBase(rbMaterMask)) {
                } else {
                    XPoint pt1, pt2;
                    if(ent.GetExtend(pt1, pt2)==RTNORM) {
                        if(!bInitExt) {
                            ptMin=pt1;
                            ptMax=pt2;
                        } else {
                            ptMin=Min(ptMin, pt1);
                            ptMax=Max(ptMax, pt2);
                        }
                        bInitExt=TRUE;
                    }
                }
                pEntity->close();
            }
            delete pBlockIterator;
            if(!bSetXD && bInitExt) {
                XVector3D vtSize=ptMax-ptMin;
                resbuf *rbxd=NULL;
                if(!sBoundHandle)
                    rbxd=ads_buildlist(1001, TCHXD, 1040, vtSize.x, 1040, vtSize.z,NULL);
                else
                    rbxd=ads_buildlist(1001, TCHXD, 1040, vtSize.x, 1040, vtSize.z, 1005, (const TCHAR *)sBoundHandle, NULL);
				if(!XSymbolTable(_T("APPID"), TCHXD))
					ads_regapp(TCHXD);
                pBlockRec->setXData(rbxd);
                ads_relrb(rbxd);
            }
        } else {
            ads_relrb(rbxdOld);
        }
    }
    OPENOBJ_END();
    AssureLayer(LAY_KEY, LAYSTAT_LOCK);
}
TARCH_IMPEXP void CheckOp2dStyle(AcDbObjectId idStyle2d)
{
    AssureLayer(LAY_KEY, LAYSTAT_UNLOCK);
    OPENOBJ_BEGIN(idStyle2d, AcDb::kForWrite, AcDbBlockTableRecord, pBlockRec);
    if(pBlockRec) 
	{
        resbuf *rbxdOld=pBlockRec->xData(TCHXD);
        if(!rbxdOld)
		{
            BOOL bSetXD=FALSE;
			RBList rbPointMask(RTDXF0, _T("POINT"), 8, LAY_KEY, 62, 1, NULL);

            AcDbBlockTableRecordIterator* pBlockIterator=NULL;
            VERIFY(pBlockRec->newIterator(pBlockIterator)==Acad::eOk);
            for (pBlockIterator->start(); !pBlockIterator->done();  pBlockIterator->step())  
			{
                AcDbEntity *pEntity;
                VERIFY(pBlockIterator->getEntity(pEntity, AcDb::kForRead)==Acad::eOk);
                Entity ent;
                acdbGetAdsName(ent.name, pEntity->objectId());
                if(ent.MatchBase(rbPointMask))
				{
                    resbuf *rbxd=pEntity->xData(TCHXD);
                    if(pEntity->upgradeOpen()==Acad::eOk)
					{
                        pEntity->erase();
                        pEntity->downgradeOpen();
                    }

                    if(rbxd) 
					{
                        pBlockRec->setXData(rbxd);
                        ads_relrb(rbxd);
                        bSetXD=TRUE;
                        pEntity->close();
                        break;
                    }
                }
                pEntity->close();
            }
            delete pBlockIterator;
        } 
		else 
            ads_relrb(rbxdOld);
    }
    OPENOBJ_END();
    AssureLayer(LAY_KEY, LAYSTAT_LOCK);
}

// 门窗套材料
int TDbOpening::GetSlotMaterial() const
{
	double dThick = 0.0;
	int nMat = 0;
	BOOL bSlotInsCap = TRUE;
	ReadInsulateFromXData(nMat, dThick,bSlotInsCap);
	return nMat;
}

void TDbOpening::SetSlotMaterial(int nMat) 
{
	double dThick = 0.0;
	int nMatT = 0;
	BOOL bSlotInsCap = TRUE;
	ReadInsulateFromXData(nMatT, dThick,bSlotInsCap);
	
	WriteInsulateToXData(nMat,dThick,bSlotInsCap);
	//wlw add 100913
	m_nMaterial = nMat;
}

// 门窗套保温厚
double TDbOpening::GetSlotInsulateThick() const 
{
	if (!DocGetProWinSlabInsu())
	{
		return 0.0;
	}
	double dThick = 0.0;
	int nMat = 0;
	BOOL bSlotInsCap = TRUE;
	ReadInsulateFromXData(nMat, dThick, bSlotInsCap);
	if (nMat == 2 || nMat == 3)
	{//材质是保温和轻质材料时，没有保温层
		return 0.0;
	}
	return dThick;
}

void TDbOpening::SetSlotInsulateThick(double dThick) 
{
	double dThickT = 0.0;
	int nMat = 0;
	BOOL bSlotInsCap = TRUE;

	ReadInsulateFromXData(nMat, dThickT, bSlotInsCap);

	WriteInsulateToXData(nMat,dThick,bSlotInsCap);
	//wlw add 100913
	m_dInsWidth = dThick;
}

// 门窗套保温是否封口，默认封口
BOOL TDbOpening::HasSlotInsulateCap() const
{
	assertReadEnabled();
	double dThickT = 0.0;
	int nMat = 0;
	BOOL bSlotInsCap = TRUE;

	ReadInsulateFromXData(nMat, dThickT, bSlotInsCap);
	return bSlotInsCap;
}

void TDbOpening::SetSlotInsulateCap(BOOL bSlotInsCap)
{
	assertWriteEnabled();
	double dThick = 0.0;
	int nMat = 0;
	BOOL bSlotInsCapT = TRUE;
	ReadInsulateFromXData(nMat, dThick, bSlotInsCapT);

	WriteInsulateToXData(nMat,dThick, bSlotInsCap);
	//wlw add 110118
	m_bSlotInsCap = bSlotInsCap;
}

// 凸窗挡板保温厚与门窗套共用
double TDbOpening::GetProWinSlabInsuThick() const
{
	return GetSlotInsulateThick();
}

void TDbOpening::SetProWinSlabInsuThick(double dThick)
{
	SetSlotInsulateThick(dThick);
}

// 门口线偏移距离（只对单侧、双侧起作用）
double TDbOpening::GetDoorLineOffsetDist() const
{
	assertReadEnabled();
	const TEntityFields &fd = GetFields();

	double dOffsetDist = 0;
	fd.GFD(_T("门口线偏移距离"), dOffsetDist);
	return dOffsetDist;
}

void TDbOpening::SetDoorLineOffsetDist(double dOffsetDist)
{
	assertWriteEnabled();

	TEntityFields &fd = Fields();
	fd.SFD(_T("门口线偏移距离"), dOffsetDist);
}

// 门、窗、弧窗的自类型（支持用户设置，无法用枚举类型）
CString TDbOpening::GetSubKind() const
{
	assertReadEnabled();
	const TEntityFields &fd = GetFields();

	CString csSubKind = _T("普通门");
	switch (m_opKind)
	{
	case TDbOpening::OP_DOOR:	// 门
		break;
	case TDbOpening::OP_WINDOW:	// 窗
		csSubKind = _T("普通窗");
		break;
	case TDbOpening::OP_ARCWIN:	// 弧窗
		csSubKind = _T("弧窗");
		break;
	default:					// 其他类型
		csSubKind = GetKindString();
		break;
	}

	fd.GFD(_T("门窗用途"), csSubKind);
	return csSubKind;
}

void TDbOpening::SetSubKind(const TCHAR *csKind)
{
	assertWriteEnabled();
	if (GetKind() == TOpeningData::OP_DOOR) // 门
	{
		bool bAddFlag1 = _tcsicmp(csKind, _T("隔断门"))==0,

			bAddFlag2 = _tcsicmp(csKind, _T("电梯门"))==0;
		if (bAddFlag1) // 是隔断门
		{
			m_nOpStyle |= OPS_LVTRY;
			m_nOpStyle &= ~OPS_LIFTDOOR;
		}
		else if (bAddFlag2) // 是电梯门
		{
			m_nOpStyle |= OPS_LIFTDOOR;
			m_nOpStyle &= ~OPS_LVTRY;
		}
		else // 都不是
		{
			m_nOpStyle &= ~OPS_LVTRY;
			m_nOpStyle &= ~OPS_LIFTDOOR;
		}
	}

	TEntityFields &fd = Fields();
	fd.SFD(_T("门窗用途"), csKind);
}

BOOL TDbOpening::HasInsulate() const 
{
	return ((m_nOpStyle & OPS_SLOT_INSULATE) != 0);
}

void TDbOpening::SetInsulate(BOOL bTrue) 
{
	if (bTrue)
	{
		m_nOpStyle |= OPS_SLOT_INSULATE;
	}
	else
	{
		m_nOpStyle &= ~OPS_SLOT_INSULATE;
	}
}

bool TDbOpening::ReadInsulateFromXData(int& nMaterial, double& dThick, BOOL &bSlotInsCap)const
{
	assertReadEnabled();
	
	nMaterial = 0;
	dThick = 0.0;
	bSlotInsCap = TRUE;

	AcGeVector3d vtTemp;
	resbuf *pXData = NULL;
	pXData = this->xData(TDBOPENING_INSULATE);
	if (pXData != NULL)
	{
		resbuf* pRb = pXData;
		pRb = pRb->rbnext;
		if (NULL != pRb && pRb->restype == AcDb::kDxfXdInteger32)
		{
			nMaterial = pRb->resval.rint;
		}
		
		pRb = pRb->rbnext;
		if (NULL != pRb && pRb->restype == AcDb::kDxfXdReal)
		{
			dThick = pRb->resval.rreal;
		}
		
		pRb = pRb->rbnext;
		if (NULL != pRb && pRb->restype == AcDb::kDxfXdInteger32)
		{
			bSlotInsCap = pRb->resval.rint;
		}

		acutRelRb(pXData);
		return true;
	}
	return false;
}

bool TDbOpening::WriteInsulateToXData(int nMaterial, double dThick, BOOL bSlotInsCap)
{
	assertWriteEnabled();
	resbuf *pXData = NULL;
	TGRegApp(TDBOPENING_INSULATE, database());
	pXData = this->xData(TDBOPENING_INSULATE);
	if (pXData == NULL)
	{
		pXData = ads_buildlist(1001, TDBOPENING_INSULATE, NULL);
	}

	resbuf* pRbTemp = NULL;
	resbuf* pRb = NULL;
	pRbTemp = acutNewRb(AcDb::kDxfXdInteger32);
	pRbTemp->resval.rint = nMaterial;
	pXData->rbnext = pRbTemp;
	pRb = pRbTemp;

	pRbTemp = acutNewRb(AcDb::kDxfXdReal);
	pRbTemp->resval.rreal = dThick;
	pRb->rbnext = pRbTemp;
	pRb = pRbTemp;

	pRbTemp = acutNewRb(AcDb::kDxfXdInteger32);
	pRbTemp->resval.rint = bSlotInsCap;
	pRb->rbnext = pRbTemp;
	pRb = pRbTemp;

	Acad::ErrorStatus es = this->setXData(pXData);
	acutRelRb(pXData);
	if (es == Acad::eOk)
	{
		return true;
	}
	return false;
}

// sg add 101115，支持统一标高
// 需要特殊说明，此类中的dElevation形参，表示的是门窗所在墙，未来会变成的标高值
bool TDbOpening::UnifyElevation(double dElevation)
{
    assertWriteEnabled();
	// 获得当前门槛高、窗台高
	double dSill = GetSill();
	// 仿照SetSill函数的实现，在门槛高、窗台高不变的情况下，修改门窗的绝对标高
	m_ptLocation.z = dElevation + dSill;

	return true;
}

void Matrix3D2String( const AcGeMatrix3d &mat, CString &str )
{
#if ADS <= 15
	std::ostringstream stream;
#else
	std::wostringstream stream;
#endif
	for (int ln = 0; ln < 4; ++ln)
	{
		for (int col = 0; col < 4; ++col)
		{
			stream << mat.entry[ln][col];
			#if ADS <= 15
				stream << " ";
			#else
				stream << L" ";
			#endif

		}
	}
	str = stream.str().c_str();
}

//add by xlc on 101112
CString TDbOpening::GetXml(const AcGeMatrix3d& mat) const
{
	TXmlTree xmlTree;
	POSITION posRoot = xmlTree.Insert(_T("ATS_OPENING"), NULL, NULL);
	{
		xmlTree.SetAttribute(posRoot, _T("name"), _T("门窗"));
		xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称"));
	}

	CString strText;
	POSITION posItem1 = xmlTree.Insert(_T("Object_ID"), posRoot, NULL);
	{
		xmlTree.SetAttribute(posItem1, _T("name"), _T("对象编号"));
		xmlTree.SetAttribute(posItem1, _T("comment"), _T("当前对象的句柄"));
		strText.Format(_T("%ld"), objectId());
		xmlTree.SetItemText(posItem1, strText);
	}

	POSITION posItem = NULL;
	POSITION posItem2 = xmlTree.Insert(_T("Link_WALL"), posRoot, posItem1);
	{ 
		xmlTree.SetAttribute(posItem2, _T("name"), _T("连接墙体"));

		posItem = xmlTree.Insert(_T("Link_ID"), posItem2, NULL);
		{
			xmlTree.SetAttribute(posItem, _T("name"), _T("墙体句柄"));
			strText.Format(_T("%ld"), m_nIdOfWall);
			xmlTree.SetItemText(posItem, strText);
		}
	}

	POSITION posItem3 = xmlTree.Insert(_T("Property"), posRoot, posItem2);
	{ 
		xmlTree.SetAttribute(posItem3, _T("name"), _T("门窗类型"));
		xmlTree.SetAttribute(posItem3, _T("comment"), _T("门窗的类型"));
		xmlTree.SetItemText(posItem3, GetKindString());
	}
	//	double m_nProtrude; //突出宽
	//	double m_nTrapezia; //梯形宽 


	if (GetKind()==OP_PROWIN && m_pBayWin!=NULL)
	{
		POSITION posType = xmlTree.Insert(_T("PrType"), posRoot, posItem3);
		{
			xmlTree.SetAttribute(posType, _T("name"), _T("凸窗类型"));
			strText.Format(_T("%d"), m_pBayWin->m_nStyle);
			xmlTree.SetItemText(posType,strText);	
		}

		POSITION posStrude = xmlTree.Insert(_T("ProTrude"), posRoot, posType);
		{
			xmlTree.SetAttribute(posStrude, _T("name"), _T("出挑长"));
			strText.Format(_T("%f"), m_pBayWin->m_nProtrude);
			xmlTree.SetItemText(posStrude,strText);
		}

		POSITION posZia = xmlTree.Insert(_T("B"), posRoot, posStrude);
		{
			xmlTree.SetAttribute(posZia, _T("name"), _T("梯形宽"));
			strText.Format(_T("%f"), m_pBayWin->m_nTrapezia);
			xmlTree.SetItemText(posZia,strText);
		}
		posItem3 = posZia;
	}

	POSITION posItem4 = xmlTree.Insert(_T("Height"), posRoot, posItem3);
	{ 
		xmlTree.SetAttribute(posItem4, _T("name"), _T("门窗高"));
		xmlTree.SetAttribute(posItem4, _T("comment"), _T("从门窗底起算的窗高"));
		strText.Format(_T("%f"), GetHeight());
		xmlTree.SetItemText(posItem4, strText);
	}

	POSITION posItem5 = xmlTree.Insert(_T("Length"), posRoot, posItem4);
	{ 
		xmlTree.SetAttribute(posItem5, _T("name"), _T("门窗宽"));
		xmlTree.SetAttribute(posItem5, _T("comment"), _T("门窗沿墙面的宽度"));
		strText.Format(_T("%f"), GetWidth());
		xmlTree.SetItemText(posItem5, strText);
	}
	POSITION posItem51 = xmlTree.Insert(_T("LengthTwoDoor"), posRoot, posItem5);
	{ 
		xmlTree.SetAttribute(posItem51, _T("name"), _T("主门宽"));
		xmlTree.SetAttribute(posItem51, _T("comment"), _T("门连窗、子母门"));
		strText.Format(_T("%f"), m_nDoorWidth);
		xmlTree.SetItemText(posItem51, strText);
	}
	POSITION posItem52 = xmlTree.Insert(_T("LengthDoorWinH"), posRoot, posItem51);
	{ 
		xmlTree.SetAttribute(posItem52, _T("name"), _T("窗高"));
		xmlTree.SetAttribute(posItem52, _T("comment"), _T("门连窗"));
		strText.Format(_T("%f"), m_nWinHeight);
		xmlTree.SetItemText(posItem52, strText);
	}
	POSITION posItem6 = xmlTree.Insert(_T("Thickness"), posRoot, posItem5);
	{ 
		xmlTree.SetAttribute(posItem6, _T("name"), _T("窗厚"));
		xmlTree.SetAttribute(posItem6, _T("comment"), _T("窗厚与推拉门厚随墙"));
		strText.Format(_T("%f"), GetWallThickness());
		xmlTree.SetItemText(posItem6, strText);
	}

	POSITION posItem7 = xmlTree.Insert(_T("Ang"), posRoot, posItem6);
	{ 
		xmlTree.SetAttribute(posItem7, _T("name"), _T("圆心角"));
		strText = _T("0");
		if (GetKind() == TOpeningData::OP_ARCWIN)
		{
			TAcDbObjectPtr objWall(m_nIdOfWall, AcDb::kForRead);
			if(!!objWall) 
			{
				TDbWall *pDbWall = TDbWall::cast(objWall.m_pObject);
				if(pDbWall) 
				{ 
					TGGeArc ar = pDbWall->GetArc();
					double dRadius = ar.GetRadius();
					if(dRadius > _DIST_SNAP)
					{
						double dAng = GetWidth() / dRadius;
						strText.Format(_T("%f"), dAng);
					}
				}
			}
		}



		xmlTree.SetItemText(posItem7, strText);
	}

	// 旋转角度
	POSITION posRotate = xmlTree.Insert(_T("RoataeAngle"), posRoot, posItem7);
	{
		xmlTree.SetAttribute(posRotate, _T("name"), _T("旋转角度"));
		strText.Format(_T("%f"), m_nRotation);
		xmlTree.SetItemText(posRotate, strText);
		posItem7 = posRotate;
	}

	POSITION posItem8 = xmlTree.Insert(_T("Open_ang"), posRoot, posItem7);
	{ 
		xmlTree.SetAttribute(posItem8, _T("name"), _T("开启方向"));
		strText.Format(_T("%d"), m_nQuadrant);
		xmlTree.SetItemText(posItem8, strText);
	}

	POSITION posItem9 = xmlTree.Insert(_T("Highwin_ID"), posRoot, posItem8);
	{ 
		xmlTree.SetAttribute(posItem9, _T("name"), _T("高窗标志"));
		xmlTree.SetAttribute(posItem9, _T("comment"), _T("高窗为1"));
		strText.Format(_T("%d"), IsHigh());
		xmlTree.SetItemText(posItem9, strText);
	}

	POSITION posItem10 = xmlTree.Insert(_T("Upperwin_ID"), posRoot, posItem9);
	{ 
		xmlTree.SetAttribute(posItem10, _T("name"), _T("上层窗标志"));
		xmlTree.SetAttribute(posItem10, _T("comment"), _T("上层窗为1"));
		strText.Format(_T("%d"), IsHighLevel());
		xmlTree.SetItemText(posItem10, strText);
	}

	POSITION posItem11 = xmlTree.Insert(_T("Center_point"), posRoot, posItem10);
	{ 
		// sg modify 120117，对点进行坐标变换
		TADSGePoint3d ptTransformBy = GetLocation();
		ptTransformBy.TransformBy(mat);

		xmlTree.SetAttribute(posItem11, _T("name"), _T("基点"));
		xmlTree.SetAttribute(posItem11, _T("comment"), _T("窗台中点坐标"));
		// strText.Format(_T("%f,%f,%f"), GetLocation().x, GetLocation().y, GetLocation().z);
		strText.Format(_T("%f,%f,%f"), ptTransformBy.x, ptTransformBy.y, ptTransformBy.z);
		xmlTree.SetItemText(posItem11, strText);
	}

	POSITION posItem12 = xmlTree.Insert(_T("Lib_Block"), posRoot, posItem11);
	{ 
		xmlTree.SetAttribute(posItem12, _T("name"), _T("图块符号表"));

		posItem = NULL;
		posItem = xmlTree.Insert(_T("Lib_2D"), posItem12, posItem);
		{
			xmlTree.SetAttribute(posItem, _T("name"), _T("二维门窗块名"));
			TCString sName;
			GetStyle2dName(sName);
			xmlTree.SetItemText(posItem, sName);
		}

		posItem = xmlTree.Insert(_T("Lib_3D"), posItem12, posItem);
		{
			xmlTree.SetAttribute(posItem, _T("name"), _T("三维门窗块名"));
			TCString sName;
			GetStyle3dName(sName);
			xmlTree.SetItemText(posItem, sName);
		}
	}

	POSITION pos = posItem12;
	AcDbObjectId idStyle = !m_nIdStyle3d ? m_nIdStyle2d : m_nIdStyle3d;
	if(idStyle != NULL)
	{
		POSITION posItem13 = xmlTree.Insert(_T("Matrix3d"), posRoot, posItem12);
		{
			double dScaleX(0), dScaleY(0), dScaleZ(0),
				dRotation(m_nRotation);
			GetInsert3DScale(&dScaleX, &dScaleY, &dScaleZ);
			AcDbBlockReference block(GetLocation(), idStyle);
			block.setRotation(dRotation);
			if (!(!m_nIdStyle3d)) // 显示真三维
				block.setScaleFactors(AcGeScale3d(dScaleX, dScaleY, dScaleZ));
			else if (!!m_nIdStyle2d)
				block.setScaleFactors(AcGeScale3d(dScaleX, dScaleY, m_nHeight));
			AcGeMatrix3d matBlock = block.blockTransform();
			matBlock = mat * matBlock;
			CString sMat;
			Matrix3D2String(matBlock, sMat);
			xmlTree.SetAttribute(posItem13, _T("name"), _T("矩阵"));
			xmlTree.SetAttribute(posItem13, _T("comment"), _T("图块转换矩阵"));
			xmlTree.SetItemText(posItem13, sMat);
		}
		pos = posItem13;
	}

	if (IsShowLabel())
	{

		POSITION posLabel = xmlTree.Insert(_T("Label"), posRoot, pos); 
		xmlTree.SetAttribute(posLabel, _T("name"), _T("门窗编号"));
		xmlTree.SetItemText(posLabel, m_sLabel);
		pos = posLabel;
	}

	// add by hh 2013-9-6 从xData中读取节能相关的数据
	if(11 == g_nProductId)
	{
		acdbRegApp(_T("TBEC_XDAPP_OPENING"));
		resbuf* xdata = xData(_T("TBEC_XDAPP_OPENING"));
		if(NULL != xdata)
		{
			static struct _XDataList{
				int nCode;         // CODE
				LPCTSTR pszItem;   // 节点
				LPCTSTR pszName;   // 节点名称
			} xDList1[] = {  // 门
				{ AcDb::kDxfXdAsciiString, _T("Struct_name"),     _T("构造名称") },
				{ AcDb::kDxfXdReal,        _T("Struct_K"),        _T("传热系数") },
			}, xDList2[] = { // 外窗
				{ AcDb::kDxfXdAsciiString, _T("Struct_name"),     _T("构造名称") },
				{ AcDb::kDxfXdReal,        _T("Struct_K"),        _T("传热系数") },
				{ AcDb::kDxfXdReal,        _T("Struct_SC"),       _T("遮阳系数") },
				{ AcDb::kDxfXdAsciiString, _T("SD_name"),         _T("外遮阳类型") },
				{ AcDb::kDxfXdReal,        _T("Struct_SDs"),      _T("夏季外遮阳系数") },
				{ AcDb::kDxfXdReal,        _T("Struct_SDw"),      _T("冬季外遮阳系数") },
			}, xDList3[] = { // 内窗
				{ AcDb::kDxfXdAsciiString, _T("Struct_name"),     _T("构造名称") },
				{ AcDb::kDxfXdReal,        _T("Struct_K"),        _T("传热系数") },
				{ AcDb::kDxfXdReal,        _T("Struct_SC"),       _T("遮阳系数") },
				}, xDList4[] = { // 外凸窗
					{ AcDb::kDxfXdAsciiString, _T("Struct_name"),     _T("构造名称") },
					{ AcDb::kDxfXdReal,        _T("Struct_K"),        _T("传热系数") },
					{ AcDb::kDxfXdReal,        _T("Struct_SC"),       _T("遮阳系数") },
					{ AcDb::kDxfXdAsciiString, _T("SD_name"),         _T("外遮阳类型") },
					{ AcDb::kDxfXdReal,        _T("Struct_SDs"),      _T("夏季外遮阳系数") },
					{ AcDb::kDxfXdReal,        _T("Struct_SDw"),      _T("冬季外遮阳系数") },
					{ AcDb::kDxfXdAsciiString, _T("TopSlab_name"),    _T("顶板构造名称") },
					{ AcDb::kDxfXdReal,        _T("TopSlab_K"),       _T("顶板传热系数") },
					{ AcDb::kDxfXdReal,        _T("TopSlab_D"),       _T("顶板热惰性指标") },
					{ AcDb::kDxfXdReal,        _T("TopSlab_R"),       _T("顶板热阻") },
					{ AcDb::kDxfXdAsciiString, _T("BottomSlab_name"), _T("底板构造名称") },
					{ AcDb::kDxfXdReal,        _T("BottomSlab_K"),    _T("底板传热系数") },
					{ AcDb::kDxfXdReal,        _T("BottomSlab_D"),    _T("底板热惰性指标") },
					{ AcDb::kDxfXdReal,        _T("BottomSlab_R"),    _T("底板热阻") },
					{ AcDb::kDxfXdAsciiString, _T("SideSlab_name"),   _T("侧板构造名称") },
					{ AcDb::kDxfXdReal,        _T("SideSlab_K"),      _T("侧板传热系数") },
					{ AcDb::kDxfXdReal,        _T("SideSlab_D"),      _T("侧板热惰性指标") },
					{ AcDb::kDxfXdReal,        _T("SideSlab_R"),      _T("侧板热阻") },
				}, xDListShadow[] = { // 外遮阳绘制参数
					{ AcDb::kDxfXdInteger32,   _T("SD_mask%d"),        _T("外遮阳") },
					{ AcDb::kDxfXdReal,        _T("SD_para%d"),        _T("参数A") },
					{ AcDb::kDxfXdReal,        _T("SD_parb%d"),        _T("参数B") },
					{ AcDb::kDxfXdReal,        _T("SD_parc%d"),        _T("参数C") },
				};


					// 取得门窗标记
					resbuf* px = xdata;
					px = px->rbnext;
					int nOpening = 1;  // 1 门  2 窗 3 凸窗
					if(NULL != px && AcDb::kDxfXdInteger32 == px->restype)
					{
						nOpening = px->resval.rint;
					}
					int nOut = 0; // 0 内窗; 1 外窗; 2 带外遮阳的外窗
					if(1 != nOpening) // 如果是窗户或者凸窗 再读取一下内外窗标记
					{
						px = px->rbnext;
						if(NULL != px && AcDb::kDxfXdInteger32 == px->restype)
						{
							nOut = px->resval.rint;
						}
					}

					// 根据门窗标记 选择数据
					_XDataList* xDList = NULL;
					int nSize = 0;
					if(1 == nOpening) // 门
					{
						xDList = xDList1;
						nSize = sizeof(xDList1) / sizeof(xDList1[0]);
					}
					else // 窗 凸窗
					{
						if(0 == nOut) // 内窗
						{
							xDList = xDList3;
							nSize = sizeof(xDList3) / sizeof(xDList3[0]);
						}
						else
						{
							if(3 == nOpening) // 外凸窗
							{
								xDList = xDList4;
								nSize = sizeof(xDList4) / sizeof(xDList4[0]);
							}
							else // 普通外窗
							{
								xDList = xDList2;
								nSize = sizeof(xDList2) / sizeof(xDList2[0]);
							}
						}
					}

					// 根节点
					POSITION posBec = xmlTree.Insert(_T("TBecParam"), posRoot, pos);
					xmlTree.SetAttribute(posBec, _T("name"), _T("节能参数"));

					// 节能数据
					CString sTemp;
					posItem = NULL;
					for(int i = 0; i < nSize && NULL != px; i++)
					{
						px = px->rbnext;
						if(NULL != px && xDList[i].nCode == px->restype)
						{
							if(AcDb::kDxfXdAsciiString == xDList[i].nCode)
								sTemp = px->resval.rstring;
							else if(AcDb::kDxfXdReal == xDList[i].nCode)
								sTemp.Format(_T("%.2f"), px->resval.rreal);

							posItem = xmlTree.Insert(xDList[i].pszItem, posBec, posItem);
							xmlTree.SetAttribute(posItem, _T("name"), xDList[i].pszName);
							xmlTree.SetItemText(posItem, sTemp);
						}
					}
					// 外遮阳绘制参数
					if(NULL != px && 2 == nOut)
					{
						CString sItem;
						px = px->rbnext;
						if(NULL != px && AcDb::kDxfXdInteger32 == px->restype)
						{
							int nLoop = ((1 == px->resval.rint) ? 2 : 1); // 单一遮阳/组合遮阳
							nSize = sizeof(xDListShadow) / sizeof(xDListShadow[0]);
							for(int k = 0; k < nLoop; k++)
							{
								for(int j = 0; j < nSize && NULL != px; j++)
								{
									px = px->rbnext;
									if(NULL != px && xDListShadow[j].nCode == px->restype)
									{
										if(AcDb::kDxfXdInteger32 == xDListShadow[j].nCode)
											sTemp.Format(_T("%d"), px->resval.rint);
										else if(AcDb::kDxfXdReal == xDListShadow[j].nCode)
											sTemp.Format(_T("%.2f"), px->resval.rreal);

										sItem.Format(xDListShadow[j].pszItem, k + 1);

										posItem = xmlTree.Insert(sItem, posBec, posItem);
										xmlTree.SetAttribute(posItem, _T("name"), xDListShadow[j].pszName);
										xmlTree.SetItemText(posItem, sTemp);
									}
								}
							}
						}
					}

					acutRelRb(xdata);
					pos = posBec;
		}
	}

	CString strBase = TEntityBase::GetXml(mat);
	CString strXml = xmlTree.GetXml();
	int nIndex = strXml.Find(_T("<Object_ID"));
	strXml.Insert(nIndex, strBase);

	return strXml;
}

bool TDbOpening::GetSection( const AcDbFace &face, const AcGeVector3d& vtPlaneSecDir, 
							std::vector<TObjSectionRecord> &sectionRecords, 
							AcDbVoidPtrArray& arFillPtrs ) const
{
	TGGeSectionPlane section(face, vtPlaneSecDir); // 构造投影面
	OpeningKind kind = GetKind();
	AcDbObjectId id = objectId();
	AcDbObjectId layer = layerId();
	double elev = GetElevation();
	double height = GetHeight();
	TGGePoly2D poly_elev, poly_xy; // 立面曲线,x-y面曲线
	TObjSectionRecord::SectionType type = TObjSectionRecord::eTCH_OPENING;
	GetElevOutline(poly_elev);
	GetOutlinePoly(0., poly_xy);
	switch (kind)
	{
	case OP_DOOR:
	case OP_WINDOW:
	case OP_HOLE:
	case OP_TWODOOR:
	case OP_GROUP:
	case OP_ARCWIN:
		{
			SectionUtility::FillRecordsByPoly(poly_xy, section, sectionRecords,
				elev, height, *this, type);
		}
		break;
	case OP_DOORWIN:
		{
			// 利用 立面曲线 左右拉伸得到两个立面
			AcGeMatrix3d mat;
			TGGePoly2D poly;
			TGGePoly2D poly1(poly_elev), poly2(poly_elev);
			TADSGePoint3d ptB, ptF;
			GetSidePoints(ptB, ptF);
			AcGeVector3d vt = ptB - ptF;
			vt.normalize();
			vt *= GetWallThickness() * .5;
			vt.rotateBy(PI * -.5, AcGeVector3d::kZAxis);
			mat.setTranslation(vt);
			poly1.TransformBy(mat);
			vt.rotateBy(PI, AcGeVector3d::kZAxis);
			mat.setTranslation(vt);
			poly2.TransformBy(mat);
			TGGeSectionPlane plane1(poly1, AcGeVector3d::kZAxis), plane2(poly2, AcGeVector3d::kZAxis);
			// 两个立面进行投影
			poly.Reset();
			double dDis = SectionUtility::Projection_plane2plane(section, plane1, poly);
			if (poly.Length())
				sectionRecords.push_back(TObjSectionRecord(id, layer, type, dDis, poly));

			poly.Reset();
			dDis = SectionUtility::Projection_plane2plane(section, plane2, poly);
			if (poly.Length())
				sectionRecords.push_back(TObjSectionRecord(id, layer, type, dDis, poly));
		}
		break;
// 	case OP_ARCWIN:
// 		{
// 			SectionUtility::DrawPoly2D(poly_elev);
// 			SectionUtility::DrawPoly2D(poly_xy);
// 		}
// 		break;
	case OP_PROWIN:
		{
			double nWallThick = 200.;
			double dWallInsut = 0., dInsutAdd = 0.;
			TADSGePoint3d ptDir;
			double nExtDir = m_nRotation + (m_nQuadrant<2? PI/2.0 : -PI/2.0);
			TADSGePoint3d ptLoc = GetLocation();
			ptLoc.z = 0;
			// sg modify 120605，标记保温类型
			int nInsulateType = 0;
			OPENOBJ_BEGIN(m_nIdOfWall, AcDb::kForRead, TDbWall, pWall);
			if(pWall) 
			{
				nWallThick = pWall->GetWidth(4);
				ads_polar(ptLoc, nExtDir, 10000, ptDir);
				int nSide = pWall->OnWhichSide(ptDir);
				if (pWall->IsInsulateOnSide(nSide))
				{
					dWallInsut = pWall->GetInsulateThick(nSide);
					if (DocGetProWinSlabInsu())
					{
						dInsutAdd = GetSlotInsulateThick();
						nInsulateType = 1;
					}
				}
				ads_polar(ptLoc, nExtDir, -10000, ptDir);
				if (pWall->IsInsulateOnSide(pWall->OnWhichSide(ptDir)))
				{
					dInsutAdd = GetSlotInsulateThick();
					nInsulateType = (nInsulateType==1) ? 2 : 1;
				}
			}
			OPENOBJ_END();

			DList<XPoly2D> polyCurves;
			//m_pBayWin->GetPolyCurve(ptLoc, nExtDir, GetWidth(), nWallThick, HasLeftSlab(), HasRightSlab(), polyCurves, dWallInsut, dInsutAdd);
			m_pBayWin->GetPolyCurve(ptLoc, nExtDir, GetWidth(), nWallThick, HasLeftSlab(), HasRightSlab(), polyCurves, dWallInsut, dInsutAdd, nInsulateType==2);
			if (m_pBayWin->m_nStyle != 3) 
			{
				SectionUtility::FillRecordsByPoly(*polyCurves[polyCurves.Length()-1], 
					section, sectionRecords, elev, height, *this, type);
			}
			else// 拱形
			{
				TGGePoly2D poly = *polyCurves[polyCurves.Length() - 1];
				if (poly.Length() == 2)
				{
					double dAng = poly.GetBulge(0) * .5;
					AcGePoint3d pt1(*poly[0]), pt2(*poly[1]);
					double dLen = pt1.distanceTo(pt2) * .5;
					AcGeVector3d vt = pt1 - pt2;
					vt.normalize();
					vt *= (dLen/sin(dAng) - dLen/tan(dAng));
					vt.rotateBy(PI*.5, AcGeVector3d::kZAxis);
					AcGePoint3d pt3 = pt2 + vt;
					AcGePoint3d pt4 = pt1 + vt;
					TGGePoly2D _poly;
					_poly.AppendNode(pt1);
					_poly.AppendNode(pt2);
					_poly.AppendNode(pt3);
					_poly.AppendNode(pt4);
					_poly.SetClosed();
					SectionUtility::FillRecordsByPoly(_poly, section, sectionRecords,
						elev, height, *this, type);
				}
			}
		}
		break;
	case OP_CORNWIN:
		break;
	default:
		break;
	}
	// 处理添充线
	switch (kind)
	{
	case OP_DOOR:
		break;
	case OP_WINDOW:
		break;
	case OP_DOORWIN:
		break;
	case OP_TWODOOR:
		break;
	default:
		break;
	}
	return true;
}