#include "stdafx.h"
#include "wall_xdata_key.h"

ACRX_DXF_DEFINE_MEMBERS(ATSCurtainWall, ATSWall, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,  
						1, ATS_CURTAIN_WALL, "ATS_CURTAIN_WALL图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
IMPLEMENT_TENTBASE(TDbCurtainWall);


//TArch6:1;TArch7:2
const Adesk::UInt8 TDbCurtainWall::g_nVersion=2;   

TDbCurtainWall::TDbCurtainWall()
:m_colAlign(kCenter), //挺的对齐位置
m_uCol(_AS_SYS_UNIT(100.0)), m_vCol(_AS_SYS_UNIT(100.0)), //挺的截面参数，u为沿着墙的方向尺寸
m_uRow(_AS_SYS_UNIT(100.0)), m_vRow(_AS_SYS_UNIT(100.0)), //框的截面参数, u为竖直方向的尺寸
m_nGlazDist(0.0), //玻璃距离基线
m_nRowDist(0.0),  //横框中心距离基线
m_nRowNum(1), m_nColNum(1) //横竖均分数目
{
    m_nWallFlag = WF_TOP_ROW|WF_BOT_ROW|WF_COL_AVERAGE|WF_ROW_AVERAGE;
	m_style=kCurtain;
	SetSimple2D(TRUE);
	UpdateWallWidth();
}

void TDbCurtainWall::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
{
    assertWriteEnabled();
    TDbWall::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
    TDbCurtainWall *pSrc=TDbCurtainWall::cast(pSrcEntity);
    if(pSrc) 
	{
		m_idLayerCol3d=pSrc->m_idLayerCol3d;
		m_idLayerRow3d=pSrc->m_idLayerRow3d;
		m_idLayerGlass3d=pSrc->m_idLayerGlass3d;
		m_colAlign=pSrc->m_colAlign;
		m_uCol=pSrc->m_uCol;
		m_vCol=pSrc->m_vCol;
		m_uRow=pSrc->m_uRow;
		m_vRow=pSrc->m_vRow;
		m_nGlazDist=pSrc->m_nGlazDist;
		m_nRowDist=pSrc->m_nRowDist;
		//wlw add 131125 非均分幕墙处理墙角崩溃
		int nColCount = m_colSpaces.Length();
		if (m_nColNum != nColCount)
		{
			SetColAverage(TRUE);
		}
	}
}

// Override from AcDbEntity

// 从DWG读入数据:
Acad::ErrorStatus 
TDbCurtainWall::dwgInFields(AcDbDwgFiler* pFiler)
{
    assertWriteEnabled();
    Acad::ErrorStatus es = TDbWall::dwgInFields(pFiler);
    if(es != Acad::eOk) return es;

    Adesk::UInt8 nVer=0;
    pFiler->readItem(&nVer);
    if(nVer>g_nVersion) {// Version is too new
          return Acad::eMakeMeProxy;
    }
	
	if(nVer==1)//TArch6图
	{
		//WF_COL_AVERAGE0->WM_COL_AVERAGE
		if((m_nWallFlag&WF_COL_AVERAGE0)!=0)
		{
			m_nWallFlag&=~WF_COL_AVERAGE0;
			m_nWallFlag|=WF_COL_AVERAGE;
		}
	}

    Adesk::UInt8 align;
    pFiler->readItem(&align);
    m_colAlign=(ColAlignment)align; //挺的对齐位置
    pFiler->readItem(&m_uCol);
    pFiler->readItem(&m_vCol); //挺的截面参数，u为沿着墙的方向尺寸
    
    pFiler->readItem(&m_uRow);
    pFiler->readItem(&m_vRow); //框的截面参数, u为竖直方向的尺寸
    pFiler->readItem(&m_nGlazDist); //玻璃距离基线
    pFiler->readItem(&m_nRowDist);  //横框中心距离基线
    pFiler->readItem(&m_nRowNum);
    pFiler->readItem(&m_nColNum); //横竖均分数目

    m_rowSpaces.Reset();
    m_colSpaces.Reset();
    if(!IsRowAverage()) {
        for(Adesk::UInt8 i=0; i<m_nRowNum; i++) {
            double val=0.0;
            pFiler->readItem(&val);
            m_rowSpaces.Append(new double(val));
        }
    }
    if(!IsColAverage()) {
        for(Adesk::UInt8 i=0; i<m_nColNum; i++) {
            double val=0.0;
            pFiler->readItem(&val);
            m_colSpaces.Append(new double(val));
        }
    }
    pFiler->readItem(&m_idLayerGlass3d);
    pFiler->readItem(&m_idLayerCol3d);
    pFiler->readItem(&m_idLayerRow3d);

    es = pFiler->filerStatus();
    return es;
}


// 写出数据到dwg:
Acad::ErrorStatus 
TDbCurtainWall::dwgOutFields(AcDbDwgFiler* pFiler) const
{
    assertReadEnabled();

	int nFlag0=GetWallFlag();
	if(g_nSaveTArchVer==6)
	{
		int flag=nFlag0;
		//~WF_SECT_TERM
		flag&=~WF_SECTTERM;
		//WF_COL_AVERAGE
		if(flag&WF_COL_AVERAGE)
		{
			flag&=~WF_COL_AVERAGE;
			flag|=WF_COL_AVERAGE0;
		}

		TDbCurtainWall*pThis=(TDbCurtainWall*)this;
		pThis->SetFlagData(flag);
	}

    Acad::ErrorStatus es = TDbWall::dwgOutFields(pFiler);

	if(GetWallFlag()!=nFlag0)
	{
		TDbCurtainWall*pThis=(TDbCurtainWall*)this;
		pThis->SetFlagData(nFlag0);//复原
	}


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

	if(g_nSaveTArchVer==6)
		pFiler->writeItem((Adesk::UInt8)1);
	else
		pFiler->writeItem(g_nVersion);

    pFiler->writeItem((Adesk::UInt8)m_colAlign);
    pFiler->writeItem(m_uCol);
    pFiler->writeItem(m_vCol); //挺的截面参数，u为沿着墙的方向尺寸
    
    pFiler->writeItem(m_uRow);
    pFiler->writeItem(m_vRow); //框的截面参数, u为竖直方向的尺寸
    pFiler->writeItem(m_nGlazDist); //玻璃距离基线
    pFiler->writeItem(m_nRowDist);  //横框中心距离基线
    pFiler->writeItem(m_nRowNum);
    pFiler->writeItem(m_nColNum); //横竖均分数目
	Adesk::UInt8 i;
    if(!IsRowAverage()) 
	{
        ASSERT(m_nRowNum==m_rowSpaces.Length());
        for(i=0; i<m_nRowNum; i++)
            pFiler->writeItem(m_rowSpaces[i]);
    }
    if(!IsColAverage())
	{
		//wlw add 131125 非均分幕墙处理墙角崩溃
		int nColCount = m_colSpaces.Length();
		if (m_nColNum != nColCount)
		{
			for(i=0; i< m_nColNum; i++)
				pFiler->writeItem(500.0);
		}
		else
		{
			for(i=0; i< m_nColNum; i++)
				pFiler->writeItem(m_colSpaces[i]);
		}
    }
    pFiler->writeItem(m_idLayerGlass3d);
    pFiler->writeItem(m_idLayerCol3d);
    pFiler->writeItem(m_idLayerRow3d);

    es=pFiler->filerStatus();
    return es;
}

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

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

    if (!pFiler->atSubclassData(_T("TDbCurtainWall"))) {
        return Acad::eBadDxfSequence;
    }
	int n1=1, n2=1;
	DList<double> lstRows, lstCols;
	resbuf rb;
	int fieldsFlags=0;
    while ((es == Acad::eOk)
        && ((es = pFiler->readResBuf(&rb)) == Acad::eOk))    {
        switch (rb.restype) {
		case 77:
			m_colAlign=(ColAlignment)rb.resval.rint;
			break;
		case 78:
			n1=rb.resval.rint;
			fieldsFlags |= 0x01;
			break;
		case 79:
			n2=rb.resval.rint;
			fieldsFlags |= 0x02;
			break;
		case 140:
			m_uRow=rb.resval.rreal;
			break;
		case 141:
			m_vRow=rb.resval.rreal;
			break;
		case 142:
			m_uCol=rb.resval.rreal;
			break;
		case 143:
			m_vCol=rb.resval.rreal;
			break;
		case 144:
			m_nGlazDist=rb.resval.rreal;
			break;
		case 145:
			m_nRowDist=rb.resval.rreal;
			break;
		case 148:
			fieldsFlags |= 0x04;
			lstRows.Append(new double(rb.resval.rreal));
			break;
		case 149:
			fieldsFlags |= 0x08;
			lstCols.Append(new double(rb.resval.rreal));
			break;
		case 415:
			m_idLayerGlass3d=LayerString2Id(rb.resval.rstring, database());
			free(rb.resval.rstring);
			break;
		case 416:
			m_idLayerRow3d=LayerString2Id(rb.resval.rstring, database());
			free(rb.resval.rstring);
			break;
		case 417:
			m_idLayerCol3d=LayerString2Id(rb.resval.rstring, database());
			free(rb.resval.rstring);
			break;

            //fall through intentional
        default:
            // An unrecognized group. Push it back so that
            // the subclass can read it again.
            pFiler->pushBackItem();
            es = Acad::eEndOfFile;
            break;
        }
    }

    if (es != Acad::eEndOfFile)
        return Acad::eInvalidResBuf;

	if((fieldsFlags&0x01)) {
		m_nRowNum=n1;
	} else {
		m_nRowNum=1;
	}
	if((fieldsFlags&0x02)) {
		m_nColNum=n1;
	} else {
		m_nColNum=1;
	}
    m_rowSpaces.Reset();
	m_colSpaces.Reset();
	if(!IsRowAverage()) {
		if(lstRows.Length()!=m_nRowNum)
			SetRowAverage(TRUE);
		else {
			for(int n=0; n<lstRows.Length(); n++)
				m_rowSpaces.Append(new double (*lstRows[n]));
		}
	}

	if(!IsColAverage()) {
		if(lstCols.Length()!=m_nColNum)
			SetColAverage(TRUE);
		else {
			for(int n=0; n<lstCols.Length(); n++)
				m_colSpaces.Append(new double (*lstCols[n]));
		}
	}

    return pFiler->filerStatus();
}


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

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

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

   pFiler->writeInt16(77, (Adesk::UInt16)m_colAlign);
   pFiler->writeInt16(78, (Adesk::UInt16)m_nRowNum);
   pFiler->writeInt16(79, (Adesk::UInt16)m_nColNum);
   pFiler->writeDouble(140, m_uRow);
   pFiler->writeDouble(141, m_vRow);
   pFiler->writeDouble(142, m_uCol);
   pFiler->writeDouble(143, m_vCol);

   pFiler->writeDouble(144, m_nGlazDist);
   pFiler->writeDouble(145, m_nRowDist);

   if(!IsRowAverage()) {
	   for(int i=0; i<m_rowSpaces.Length(); i++) {
		  pFiler->writeDouble(146, m_rowSpaces[i]);
	   }
   }
   if(!IsColAverage()) {
	   for(int i=0; i<m_colSpaces.Length(); i++) {
		  pFiler->writeDouble(146, m_colSpaces[i]);
	   }
   }
   pFiler->writeString(415, (const TCHAR *)LayerId2String(m_idLayerGlass3d));
   pFiler->writeString(416, (const TCHAR *)LayerId2String(m_idLayerRow3d));
   pFiler->writeString(417, (const TCHAR *)LayerId2String(m_idLayerCol3d));
   return es;
}

Acad::ErrorStatus 
TDbCurtainWall::subGetClassID(CLSID* pClsid) const
{
    return Acad::eOk;
}

Acad::ErrorStatus  
TDbCurtainWall::subTransformBy(const AcGeMatrix3d& xform)
{
    BOOL bRowHide=IsRowHide();
    BOOL bColHide=IsColHide();
	Acad::ErrorStatus es=TDbWall::subTransformBy(xform);
	SetRowHide(bRowHide);
	SetColHide(bColHide);
	return es;
}

// 绘制二维
// 尚未考虑门洞
Acad::ErrorStatus 
TDbCurtainWall::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
	if(IsSimple2D())
		return TDbWall::ExplodeOrDraw2d(dc);

    double nGlazDist=20.0; //玻璃厚度扩大表示
    XPoint ptCen;
	BOOL bLinear=TRUE;
    if(!Is(CURVE_LINE)) {
        ptCen=GetArc().GetCenterPt();
		bLinear=FALSE;
	}
	int nExtSide=OFFSET_RIGHT;
	if((GetWallFlag()&WF_LEFTEXT)!=0)
		nExtSide=OFFSET_LEFT;

    DList<XCurveSegment> segBars, segGlazes;
    //绘制挺
    //XPointDir2d ptCenRect;
    double nAverDist=GetLength()/m_nColNum;
    double nCurDist=0.0;
    XPointDir2d ptLast, ptLastDir2d;;
    for(Adesk::UInt8 i=0; i<=m_nColNum; i++) {
        double nFactor=nExtSide? 1.0 : -1.0;

        XPointDir2d ptDir2d;
        Polar(nCurDist, ptDir2d);
		ptDir2d.z=0;
        XPointDir2d ptCenRect=ptDir2d;
        if(m_colAlign==kInside)
            ads_polar(ptDir2d, ptDir2d.nDirection-PI/2.0*nFactor, m_vCol/2.0, ptCenRect);
        else if(m_colAlign==kOutside)
            ads_polar(ptDir2d, ptDir2d.nDirection+PI/2.0*nFactor, m_vCol/2.0, ptCenRect);
        ptCenRect.z=0;
        XRectAngle box(ptCenRect, m_uCol, m_vCol);
        XPoly2D poly2d(1);
        box.AsPoly2D(poly2d);

        ads_matrix mat;
        ptCenRect.GetRotationMatrix(ptCenRect.nDirection, mat);
        poly2d.TransUCS(mat);
        ExplodePoly2D(poly2d, segBars);
        //dc << poly2d; //绘制竖挺

        if(i>0) {
            XLine lnStartSide, lnEndSide; //竖挺的起始侧和结束侧
            XPoint ptTemp1, ptTemp2;
            ads_polar(ptCenRect, ptDir2d.nDirection+PI/2.0, m_vCol/2.0, ptTemp1);
            ads_polar(ptCenRect, ptDir2d.nDirection-PI/2.0, m_vCol/2.0, ptTemp2);
            lnEndSide = XLine(ptTemp1, ptTemp2).Offset(m_uCol/2.0);
            ads_polar(ptLast, ptLast.nDirection+PI/2.0, m_vCol/2.0, ptTemp1);
            ads_polar(ptLast, ptLast.nDirection-PI/2.0, m_vCol/2.0, ptTemp2);
            lnStartSide = XLine(ptTemp1, ptTemp2).Offset(-m_uCol/2.0);

            XCurveSegment segExt, segInt; //外侧玻璃和内侧玻璃
            double nGlazOffset=min(m_vCol, nGlazDist);
            //绘制玻璃
            if(IsColHide()) { //隐式
                XPoint pt1, pt2;
                ads_polar(ptCenRect, ptCenRect.nDirection - PI/2.0*nFactor, m_vCol/2.0, pt2);
                ads_polar(ptLast, ptLast.nDirection-PI/2.0*nFactor, m_vCol/2.0, pt1);
                if(Is(CURVE_LINE)) {
                    segExt = XLine(pt1, pt2); //XLine(ptLast, ptDir2d); //外侧玻璃（关键） 
                } else {
                    double rad=ads_distance(ptCen, pt1);
                    segExt = XArc(ptCen, rad, ads_angle(ptCen, pt1), ads_angle(ptCen, pt2));
                }
            } else { //显框
                segExt = Offset(m_nGlazDist/2, LS_INFINITE);
				segExt.SetElevation(0.0);
                XPoint ptInt[2];
                XPoint pt1, pt2;
                int iNum=segExt.Intersection(lnStartSide, ptInt[0], ptInt[1]);
                ASSERT(iNum);
                if(iNum==1) pt1=ptInt[0];
                else pt1=XLine(ptInt[0], ptInt[1]).NearPoint(ptLast);
                iNum=segExt.Intersection(lnEndSide, ptInt[0], ptInt[1]);
                ASSERT(iNum);
                if(iNum==1) pt2=ptInt[0];
                else pt2=XLine(ptInt[0], ptInt[1]).NearPoint(ptCenRect);
                segExt.SetPoints(pt1, pt2);
            }
            segInt = segExt.Offset(-nGlazOffset*nFactor*(IsColHide()? -1.0 : 1.0), LS_INFINITE);
            if(!IsColHide()) { //segIn进行裁剪
                XPoint ptInt[2];
                XPoint pt1, pt2;
                int iNum=segInt.Intersection(lnStartSide, ptInt[0], ptInt[1]);
                ASSERT(iNum);
                if(iNum==1) pt1=ptInt[0];
                else pt1=XLine(ptInt[0], ptInt[1]).NearPoint(ptLast);
                iNum=segInt.Intersection(lnEndSide, ptInt[0], ptInt[1]);
                ASSERT(iNum);
                if(iNum==1) pt2=ptInt[0];
                else pt2=XLine(ptInt[0], ptInt[1]).NearPoint(ptCenRect);
                segInt.SetPoints(pt1, pt2);
            } else { //绘制垂直隐框的玻璃线端头
				if(bLinear || nExtSide==OFFSET_RIGHT)
					segGlazes.Append(new XCurveSegment(segExt.StartPoint(), segInt.StartPoint(), 0.0));
				else
					segGlazes.Append(new XCurveSegment(segExt.EndPoint(), segInt.EndPoint(), 0.0));
				if(m_nColNum==i) {
					if(bLinear || nExtSide==OFFSET_RIGHT)
						segGlazes.Append(new XCurveSegment(segExt.EndPoint(), segInt.EndPoint(), 0.0));
					else
						segGlazes.Append(new XCurveSegment(segExt.StartPoint(), segInt.StartPoint(), 0.0));
				}
			}
            //dc << segExt << segInt;
            segGlazes.Append(new XCurveSegment(segExt));
            //if(0) //4线表示
            segGlazes.Append(new XCurveSegment(segInt));
        }
        
        if(i < m_nColNum) 
		{
            double nDist=nAverDist;
            if(!IsColAverage())
                nDist=m_colSpaces[i];
            nCurDist += nDist;
            ptLast = ptCenRect;
            ptLast.nDirection=ptDir2d.nDirection;
			ptLastDir2d = ptDir2d;
        }
    }

    //用门窗洞，扣减
    DList<TOpeningData> lstOpenings;
    GetSortedOpenings(lstOpenings);
    DList<XCurveSegment> segBarOuts, segGlazeOuts;
    for(int k=0; k<lstOpenings.Length(); k++) {
        TOpeningData *pWin=lstOpenings[k];
        XLine lnLeft, lnRight;
        int nRetFlag=pWin->GetSideLine2d(lnLeft, lnRight);
        for(int nIter=0; nIter<2; nIter++) {
            DList<XCurveSegment> &lstSegs=nIter? segGlazes : segBars;
            DList<XCurveSegment> &lstSegOuts=nIter? segGlazeOuts : segBarOuts;

            for(int m=0; m<lstSegs.Length(); m++) {
                XCurveSegment &seg=*lstSegs[m];
                seg.SetLineFlag(LS_FINITE);
                int nFlag1=OFFSET_RIGHT, nFlag2=OFFSET_RIGHT;
                int nTag1=OFFSET_LEFT, nTag2=OFFSET_LEFT;
                if(nRetFlag&0x01) { //有左线
                    nFlag1=lnLeft.OnWhichSide(seg.StartPoint());
                    nFlag2=lnLeft.OnWhichSide(seg.EndPoint());
                }
                if(nRetFlag&0x02) { //有右线
                    nTag1=lnRight.OnWhichSide(seg.StartPoint());
                    nTag2=lnRight.OnWhichSide(seg.EndPoint());
                }

                if(nFlag1!=OFFSET_RIGHT && nFlag2!=OFFSET_RIGHT) { //都在左线左边，输出
                    lstSegOuts.Append(new XCurveSegment(seg));
                    lstSegs.Remove(m);
                    m--;
                } else if(nFlag1!=OFFSET_LEFT && nFlag2!=OFFSET_LEFT) { //都在左线右边
                    if(nTag1!=OFFSET_RIGHT && nTag2!=OFFSET_RIGHT) {
                        //都在右线左边，删除
                        lstSegs.Remove(m);
                        m--;
                    } else if(nTag1!=OFFSET_LEFT && nTag2!=OFFSET_LEFT) {
                        //都在右线右边，继续
                    } else { //与右线相交
                        XPoint ptInt[2];
                        int nIntNum=seg.Intersection(lnRight, ptInt[0], ptInt[1]);
                        ASSERT(nIntNum==1);
                        if(nTag2==OFFSET_RIGHT)
                            seg.SetPoints(ptInt[0], XPoint(seg.EndPoint()));
                        else if(nTag1==OFFSET_RIGHT)
                            seg.SetPoints(seg.StartPoint(), ptInt[0]);
                        else
                            ASSERT(0);
                    }
                } else { //有左有右，与左线相交
                    XPoint ptInt[2];
                    int nIntNum=seg.Intersection(lnLeft, ptInt[0], ptInt[1]);
                    ASSERT(nIntNum==1);
                    XCurveSegment *segOut=new XCurveSegment(seg);
                    if(nFlag1==OFFSET_LEFT) {
                        segOut->SetPoints(seg.StartPoint(), ptInt[0]);
                        seg.SetPoints(ptInt[0], XPoint(seg.EndPoint()));
                    } else if(nFlag2==OFFSET_LEFT) {
                        segOut->SetPoints(ptInt[0], seg.EndPoint());
                        seg.SetPoints(XPoint(seg.StartPoint()), ptInt[0]);
                    } else 
                        ASSERT(0);
                    lstSegOuts.Append(segOut);

                    if(nTag1!=OFFSET_RIGHT && nTag2!=OFFSET_RIGHT) {
                        //都在右线左边，删除
                        lstSegs.Remove(m);
                        m--;
                    } else if(nTag1!=OFFSET_LEFT && nTag2!=OFFSET_LEFT) {
                        //都在右线右边，不可能
                        ASSERT(0); 
                    } else { //与右线相交
                        XPoint ptInt[2];
                        int nIntNum=seg.Intersection(lnRight, ptInt[0], ptInt[1]);
                        ASSERT(nIntNum==1);
                        if(nTag2==OFFSET_RIGHT)
                            seg.SetPoints(ptInt[0], XPoint(seg.EndPoint()));
                        else if(nTag1==OFFSET_RIGHT)
                            seg.SetPoints(seg.StartPoint(), ptInt[0]);
                        else
                            ASSERT(0);
                    }
                }
            }
        } // end for Iter
    } // end for k

	// 输出玻璃
    for(int j=0; j<segGlazeOuts.Length(); j++)
        dc << *segGlazeOuts[j];
    for(j=0; j<segGlazes.Length(); j++)
        dc << *segGlazes[j];

	//输出竖挺
	TMasterProperties prop;
	dc.BackUpProperties(prop);
	dc.SetColorLayer(colorIndex(), m_idLayerCol3d);
    for(j=0; j<segBarOuts.Length(); j++)
        dc << *segBarOuts[j];
    for(j=0; j<segBars.Length(); j++)
        dc << *segBars[j];

	// 输出基线
    int nDrawMethod=g_bShowBase;
    if(nDrawMethod&& // 1 或 2 
		!dc.IsPlotGeneration()&&
		!dc.IsExportTch4())
	{
        dc.SetColor(g_nWallBaseColor);
        XCurveSegment seg = *this;
        seg.SetElevation(0.0);
        dc << seg;
    }

    dc.RestoreProperties(prop);
    return Acad::eOk;
}

// 绘制三维
// 尚未考虑洞口
Acad::ErrorStatus
TDbCurtainWall::ExplodeOrDraw3d(XExplodeDraw &dc) const
{
    XCurveSegment segOnZero=*this;
    segOnZero.SetElevation(0.0);

    if(m_nHeight<_DIST_SNAP)
        return Acad::eOk;

	TMasterProperties prop;
	dc.BackUpProperties(prop);
    XPoint ptCen;
    if(!Is(CURVE_LINE))
        ptCen=GetArc().GetCenterPt();
	int nExtSide=OFFSET_RIGHT;
	if((GetWallFlag()&WF_LEFTEXT)!=0)
		nExtSide=OFFSET_LEFT;

    double nFactor=nExtSide? 1.0 : -1.0;

    DList<XPointDir2d> lstColPos;
    DList<XCurveSegment> lstRow;

    //确定竖挺位置和转角
    double nAverDist=GetLength()/m_nColNum;
    double nCurDist=0.0;
    double nElev=GetElevation();
    for(Adesk::UInt8 i=0; i<=m_nColNum; i++) {
        XPointDir2d ptDir2d;
        Polar(nCurDist, ptDir2d);
        XPointDir2d ptCenRect=ptDir2d;
        if(m_colAlign==kInside)
            ads_polar(ptDir2d, ptDir2d.nDirection-PI/2.0*nFactor, m_vCol/2.0, ptCenRect);
        else if(m_colAlign==kOutside)
            ads_polar(ptDir2d, ptDir2d.nDirection+PI/2.0*nFactor, m_vCol/2.0, ptCenRect);
        ptCenRect.z=nElev;
        lstColPos.Append(new XPointDir2d(ptCenRect));

        if(i<m_nColNum) {
            double nDist=nAverDist;
            if(!IsColAverage() && i < m_colSpaces.Length())
                nDist=m_colSpaces[i];
            nCurDist += nDist;
        }
    }

    XCurveSegment segRowBase;
    XCurveSegment segColBase, //竖挺中心基线
        segGlaz; //玻璃位置

    if(m_colAlign==kCenter)
        segColBase = *this;
    else if(m_colAlign==kInside)
        segColBase=Offset(m_vCol/2*nFactor, LS_FINITE);
    else
        segColBase=Offset(-m_vCol/2*nFactor, LS_FINITE);
    if(IsColHide()) { //隐式竖挺
        segGlaz = segColBase.Offset(m_vCol/2.0*nFactor, LS_FINITE);
    } else { //显式竖挺
        segGlaz = Offset(m_nGlazDist, LS_FINITE);
    }

    if(IsRowHide()) { //隐式横框
        segRowBase = segGlaz.Offset(-m_vRow/2.0*nFactor, LS_FINITE);
    } else {
        segRowBase=Offset(m_nRowDist, LS_FINITE);
    }


    segRowBase.SetElevation(nElev);
    lstRow.Append(new XCurveSegment(segRowBase));
    double nElevCur=nElev;
    double nAverRowDist=m_nHeight/m_nRowNum;
    //确定横框中心线
    for(i=0; i<m_nRowNum; i++) {
        double nDist=nAverRowDist;
        if(!IsRowAverage())
            nDist=m_rowSpaces[i];
        nElevCur += nDist;
        XCurveSegment *segNew=new XCurveSegment(segRowBase);
        segNew->SetElevation(nElevCur);
        lstRow.Append(segNew);
    }

    // 构造门窗洞
    DList<TOpeningData> lstOpenings;
    GetOpenings(lstOpenings, FALSE);
    DList<XPoly2D> holes, holeExpands;
    for(i=0; i<lstOpenings.Length(); i++) {
        TOpeningData &opening=*lstOpenings[i];
        XPoly2D *poly=new XPoly2D(1);
        opening.GetElevOutline(*poly); //分弧精度的控制未使用
        if(!*poly)
            delete poly;
        else
            holes.Append(poly);
        XPoly2D *polyExpand=new XPoly2D(1);
        segOnZero.Wcs2Ecs(*poly, *polyExpand);
        polyExpand->SetElevation(0.0);
        holeExpands.Append(polyExpand);
    }

    dc.SetColorLayer(colorIndex(), m_idLayerCol3d);

	double nExtrude=10.0; // 凸出距离以便造成隐框错觉
    //绘制竖挺
    for(i=0; i<lstColPos.Length(); i++) {
        XPointDir2d &pos=*lstColPos[i];
        XPoint ptLow=pos;
        XPoint ptLowEcs=segOnZero.Wcs2Ecs(ptLow);
        ptLowEcs.z=0.0;
        XPoint ptUpEcs=ptLowEcs;
        ptUpEcs.y += m_nHeight;
        XCurveSegment *pSeg=new XCurveSegment(ptLowEcs, ptUpEcs, 0.0, LS_FINITE);
        DList<XCurveSegment> srcSegs, inSegs, outSegs, edgeSegs, *pSource, *pDest;;
        srcSegs.Append(pSeg);
        pSource=&srcSegs;
        pDest=&outSegs;

        for(int n=0; n<holeExpands.Length(); n++) {
            pDest->Reset();
            PolyClip(*pSource, *holeExpands[n], inSegs, *pDest, edgeSegs);
            TchPrivate::Exchange(pSource, pDest);
        }
        for(int k=0; k<pSource->Length(); k++) {
            XCurveSegment *segOut=(*pSource)[k];
            double yMin=min(segOut->StartPoint().y, segOut->EndPoint().y);
            double yMax=max(segOut->StartPoint().y, segOut->EndPoint().y);
   
            XPoint ptBoxCen=pos;
            ptBoxCen.z = yMin;

            XRectAngle box(ptBoxCen, m_uCol, m_vCol);
            XPoly2D poly2d(1);
            box.AsPoly2D(poly2d);
			if(IsColHide()) {
				if(nExtSide) {
					XPoint ptAdd[4];
					ptAdd[0].x=-nExtrude/2; ptAdd[0].y=-m_vCol/2;
					ptAdd[1].x=-nExtrude/2; ptAdd[1].y=-m_vCol/2-nExtrude;
					ptAdd[2].x=nExtrude/2; ptAdd[2].y=-m_vCol/2-nExtrude;
					ptAdd[3].x=nExtrude/2; ptAdd[3].y=-m_vCol/2;
					for(int mm=0; mm<4; mm++) 
						ptAdd[mm] += XVector3D(ptBoxCen.x, ptBoxCen.y);

					poly2d.InsertNodeAt(1, ptAdd[0]);
					poly2d.InsertNodeAt(2, ptAdd[1]);
					poly2d.InsertNodeAt(3, ptAdd[2]);
					poly2d.InsertNodeAt(4, ptAdd[3]);
				} else {
					XPoint ptAdd[4];
					ptAdd[0].x=nExtrude/2; ptAdd[0].y=m_vCol/2;
					ptAdd[1].x=nExtrude/2; ptAdd[1].y=m_vCol/2+nExtrude;
					ptAdd[2].x=-nExtrude/2; ptAdd[2].y=m_vCol/2+nExtrude;
					ptAdd[3].x=-nExtrude/2; ptAdd[3].y=m_vCol/2;
					for(int mm=0; mm<4; mm++) 
						ptAdd[mm] += XVector3D(ptBoxCen.x, ptBoxCen.y);

					poly2d.InsertNodeAt(3, ptAdd[0]);
					poly2d.InsertNodeAt(4, ptAdd[1]);
					poly2d.InsertNodeAt(5, ptAdd[2]);
					poly2d.InsertNodeAt(6, ptAdd[3]);
				}
			}

            ads_matrix mat;
            pos.GetRotationMatrix(pos.nDirection, mat);
            poly2d.TransUCS(mat);
            poly2d.SetElevation(ptBoxCen.z);
            dc.DrawMesh(poly2d, XVector3D(0,0,yMax-yMin)); 
        }
    }
    dc.RestoreProperties(prop);
    dc.SetColorLayer(colorIndex(), m_idLayerRow3d);


    XPoly2D polyShape;
    XRectAngle(XPoint(), m_vRow, m_uRow).AsPoly2D(polyShape);
	if(IsRowHide()) {
		if(nExtSide) {
			XPoint ptAdd[4];
			ptAdd[0].x=m_vRow/2; ptAdd[0].y=-nExtrude/2;
			ptAdd[1].x=m_vRow/2+nExtrude; ptAdd[1].y=-nExtrude/2;
			ptAdd[2].x=m_vRow/2+nExtrude; ptAdd[2].y=nExtrude/2;
			ptAdd[3].x=m_vRow/2; ptAdd[3].y=nExtrude/2;
			polyShape.InsertNodeAt(2, ptAdd[0]);
			polyShape.InsertNodeAt(3, ptAdd[1]);
			polyShape.InsertNodeAt(4, ptAdd[2]);
			polyShape.InsertNodeAt(5, ptAdd[3]);
		} else {
			XPoint ptAdd[4];
			ptAdd[0].x=-m_vRow/2; ptAdd[0].y=nExtrude/2;
			ptAdd[1].x=-m_vRow/2-nExtrude; ptAdd[1].y=nExtrude/2;
			ptAdd[2].x=-m_vRow/2-nExtrude; ptAdd[2].y=-nExtrude/2;
			ptAdd[3].x=-m_vRow/2; ptAdd[3].y=-nExtrude/2;
			polyShape.AppendNode(ptAdd[0]);
			polyShape.AppendNode(ptAdd[1]);
			polyShape.AppendNode(ptAdd[2]);
			polyShape.AppendNode(ptAdd[3]);
		}
	}

    //绘制横框
    for(i=0; i<lstRow.Length(); i++) { 
        if(!HasBotRow() && i==0)
            continue;
        if(!HasTopRow() && i==lstRow.Length()-1)
            continue;
		// 隐框用微小的显框替代
        XCurveSegment &segRow=*lstRow[i];
        XPoint ptEcs1=segOnZero.Wcs2Ecs(segRow.StartPoint());
        XPoint ptEcs2=segOnZero.Wcs2Ecs(segRow.EndPoint());
        double z1=ptEcs1.z, z2=ptEcs2.z;
        ptEcs1.z=ptEcs2.z=0.0;
        ASSERT(fabs(z1-z2)<_DIST_SNAP);

        XCurveSegment *pSeg=new XCurveSegment(ptEcs1, ptEcs2, 0.0, LS_FINITE);
        DList<XCurveSegment> srcSegs, inSegs, outSegs, edgeSegs, *pSource, *pDest;;
        srcSegs.Append(pSeg);
        pSource=&srcSegs;
        pDest=&outSegs;
        for(int n=0; n<holeExpands.Length(); n++) {
            pDest->Reset();
            PolyClip(*pSource, *holeExpands[n], inSegs, *pDest, edgeSegs);
            TchPrivate::Exchange(pSource, pDest);
        }

        TDbCurveMesh obj;
        obj.setPropertiesFrom(this);
        obj.setLayer(m_idLayerRow3d);
		TPushProperty vProp(&obj, dc);

        for(int k=0; k<pSource->Length(); k++) {
            XCurveSegment *segBase=(*pSource)[k];
            segBase->SetElevation(z1);
            XCurveSegment segWcs(segRow);
            XPoint pt1=segOnZero.Ecs2Wcs(segBase->StartPoint());
            XPoint pt2=segOnZero.Ecs2Wcs(segBase->EndPoint());
            segWcs.SetPoints(pt1, pt2);
            XPoly2D polyBase; 
            segWcs.AsPoly2D(polyBase);
            obj.setColorIndex(256);
            obj.SetBasePoly(polyBase);
            obj.SetShapePoly(polyShape);
            obj.ExplodeOrDraw3d(dc);
        }
    }
    dc.RestoreProperties(prop);
    dc.SetColorLayer(colorIndex(), m_idLayerGlass3d);

	XCurveSegment segGlazTemp=segGlaz.Offset(nFactor*nExtrude/2, LS_FINITE);
	segGlaz=segGlazTemp;
    // 绘制玻璃
	//t20 wlw add 14.02.17 幕墙三维颜色
	AcCmColor crRef;
	Adesk::UInt32  ncolor(0);

	m_XDataMap.GetAt(uKEY_CURTAIN_GLASS_COLOUR_INDEX, (int&)ncolor);
	if (ncolor > 0)
	{
	#if ADS > 23
	#if defined(ZWCAD) && (ADS == 24 || defined(R24))
		crRef.setRGB(GetRValue(ncolor), GetGValue(ncolor), GetBValue(ncolor));
	#else
		crRef.setRGB(ncolor);
	#endif
	#else
		crRef.setColor(ncolor);
	#endif
		dc.SetTrueColor(crRef);
	}
	if(!holes) 
        dc.DrawCurve(segGlaz, m_nHeight);
    else {
		if(Is(CURVE_ARC)) {
			XArc iAr=segGlaz.GetArc();
			DrawArcFace(dc, iAr, m_nHeight, holes);
		} else {
			XPoly2D polyOut(1);
            polyOut.AppendNode(segGlaz.StartPoint());
			polyOut.AppendNode(segGlaz.EndPoint());
			XCurveSegment segTemp(segGlaz);
			segTemp.SetElevation(m_nHeight+segGlaz.StartPoint().z);
			polyOut.AppendNode(segTemp.EndPoint());
			polyOut.AppendNode(segTemp.StartPoint());
			// 要把holes投影到合适的polyOut
			XPlane plan;
			plan.SetFrom3p(segGlaz.StartPoint(), segGlaz.EndPoint(), segTemp.EndPoint());
			for(int n=0; n<holes.Length(); n++) {
				XPoly2D &rHole=*holes[n];
				for(int m=0; m<rHole.Length(); m++) 
					*rHole[m]=rHole[m]->Project(&plan);
			}
			dc.DrawShell(polyOut, holes);
		}
	}
    dc.RestoreProperties(prop);
    return Acad::eOk;
}

 //取动态属性显示数据
void TDbCurtainWall::GetTips(DList<TObjInfoUnit> &lstInfos) const
{
    TDbWall::GetTips(lstInfos);
}


// SetData
void TDbCurtainWall::SetRowNum(Adesk::UInt8 rowNum)
{
    assertWriteEnabled();
	if(rowNum) 
		m_nRowNum=rowNum;
	/*
    if(IsRowAverage() && rowNum) {
        m_nRowNum=rowNum;
        m_rowSpaces.Reset();
        for(Adesk::UInt8 i=0; i<m_nRowNum; i++) {
            m_rowSpaces.Append(new double(m_nHeight/rowNum));
        }
    } else 
	*/
}

// 设置列数
void TDbCurtainWall::SetColNum(Adesk::UInt8 colNum) 
{
    assertWriteEnabled(); 
	if(colNum)
		m_nColNum=colNum;
	/*
    if(IsColAverage() && colNum) {
        m_nColNum=colNum;
        m_colSpaces.Reset();
        for(Adesk::UInt8 i=0; i<m_nColNum; i++) {
            double nLen=Length();
            m_colSpaces.Append(new double(nLen/colNum));
        }
    }*/
}

void TDbCurtainWall::SetRowAverage(BOOL bTrue)
{
    assertWriteEnabled();
    if(bTrue)
        m_nWallFlag |= WF_ROW_AVERAGE;
    else
        m_nWallFlag &= ~WF_ROW_AVERAGE;
};

void TDbCurtainWall::SetColAverage(BOOL bTrue)
{
    assertWriteEnabled();
    if(bTrue)
        m_nWallFlag |= WF_COL_AVERAGE;
    else
        m_nWallFlag &= ~WF_COL_AVERAGE;
};

void TDbCurtainWall::SetRowHide(BOOL bTrue)
{
    assertWriteEnabled();
    if(bTrue)
        m_nWallFlag |= WF_ROW_INVIS;
    else
        m_nWallFlag &= ~WF_ROW_INVIS;
};

void TDbCurtainWall::SetColHide(BOOL bTrue)
{
    assertWriteEnabled();
    if(bTrue)
        m_nWallFlag |= WF_COL_INVIS;
    else
        m_nWallFlag &= ~WF_COL_INVIS;
};

void TDbCurtainWall::SetTopRow(BOOL bTrue)
{
    assertWriteEnabled();
    if(bTrue)
        m_nWallFlag |= WF_TOP_ROW;
    else
        m_nWallFlag &= ~WF_TOP_ROW;
};

void TDbCurtainWall::SetBotRow(BOOL bTrue)
{
    assertWriteEnabled();
    if(bTrue)
        m_nWallFlag |= WF_BOT_ROW;
    else
        m_nWallFlag &= ~WF_BOT_ROW;
};
void TDbCurtainWall::SetSimple2D(BOOL bTrue)
{
    assertWriteEnabled();
    if(bTrue)
        m_nWallFlag |= WF_SIMPLE2D;
    else
        m_nWallFlag &= ~WF_SIMPLE2D;
};

void TDbCurtainWall::SetColAlignment(TDbCurtainWall::ColAlignment align)
{
    assertWriteEnabled();
    m_colAlign=align;
}

void TDbCurtainWall::SetGlazeDist(double nDist)
{
    assertWriteEnabled();
    m_nGlazDist=nDist;
}

void TDbCurtainWall::SetRowDist(double nDist)
{
    assertWriteEnabled();
    m_nRowDist=nDist;
}

void TDbCurtainWall::SetColU(double u)
{
	assertWriteEnabled();
	m_uCol = u;
}

void TDbCurtainWall::SetColV(double v)
{
	assertWriteEnabled();
	m_vCol = v;
	//UpdateWallWidth();
}

void TDbCurtainWall::SetRowU(double u)
{
	assertWriteEnabled();
	m_uRow = u;
}

void TDbCurtainWall::SetRowV(double v)
{
	assertWriteEnabled();
	m_vRow = v;
}

// 根据竖挺参数更新墙宽
void TDbCurtainWall::UpdateWallWidth()
{
	assertWriteEnabled();
	int nExtSide=OFFSET_RIGHT;
	if((GetWallFlag()&WF_LEFTEXT)!=0)
		nExtSide=OFFSET_LEFT;

    if(m_colAlign==kInside) {
		if(nExtSide==OFFSET_RIGHT) {
			m_rWidth = m_vCol;
			m_lWidth = 0.0;
		} else {
			m_lWidth = m_vCol;
			m_rWidth = 0.0;
		}
	} else if(m_colAlign==kOutside) {
		if(nExtSide==OFFSET_LEFT) {
			m_rWidth = m_vCol;
			m_lWidth = 0.0;
		} else {
			m_lWidth = m_vCol;
			m_rWidth = 0.0;
		}
	} else {
		m_lWidth = m_rWidth = m_vCol/2;
	}
}

Acad::ErrorStatus TDbCurtainWall::DownGradeSave(int nDrawMode, AcDbVoidPtrArray &entSet, BOOL *bErase)
{
	return TDbCurveEntity::DownGradeSave(nDrawMode,entSet,bErase);
}

const TCHAR *TDbCurtainWall::GetDefaultLayer() const
{
	return LAY_CURTWALL;
}

// sg add 101119，支持导出XML
CString TDbCurtainWall::GetXml(const AcGeMatrix3d& mat) const
{
	TXmlTree xmlTree;
	POSITION posRoot = xmlTree.Insert(_T("ATS_CURTAIN_WALL"), 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 posItem2 = xmlTree.Insert(_T("Link_WinDoor"), posRoot, posItem1);
	{
		xmlTree.SetAttribute(posItem2, _T("name"), _T("墙内门窗"));
		xmlTree.SetAttribute(posItem2, _T("comment"), _T("墙内门窗"));

		POSITION posItemLinkId = NULL;
		for (int i = 0; i < m_lstOpeningId.Length(); i++)
		{
			posItemLinkId = xmlTree.Insert(_T("Link_ID"), posItem2, posItemLinkId);
			{
				xmlTree.SetAttribute(posItemLinkId, _T("name"), _T("门窗句柄"));
				strText.Format(_T("门窗句柄%d"), i + 1);
				xmlTree.SetAttribute(posItemLinkId, _T("comment"), strText);
				strText.Format(_T("%ld"), m_lstOpeningId[i]);
				xmlTree.SetItemText(posItemLinkId, strText);
			}
		}
	}

	POSITION posItem3 = xmlTree.Insert(_T("Link_Col"), posRoot, posItem2);
	{
		xmlTree.SetAttribute(posItem3, _T("name"), _T("连接柱子"));
		xmlTree.SetAttribute(posItem3, _T("name"), _T("两端连接柱子"));
		POSITION posItemColStart = xmlTree.Insert(_T("Link_ID"), posItem3, NULL);
		{
			xmlTree.SetAttribute(posItemColStart, _T("name"), _T("柱子句柄"));
			xmlTree.SetAttribute(posItemColStart, _T("comment"), _T("起点端柱子句柄"));
			strText.Format(_T("%ld"), m_idColuStart);
			xmlTree.SetItemText(posItemColStart, strText);
		}
		POSITION posItemColEnd = xmlTree.Insert(_T("Link_ID"), posItem3, posItemColStart);
		{
			xmlTree.SetAttribute(posItemColEnd, _T("name"), _T("柱子句柄"));
			xmlTree.SetAttribute(posItemColEnd, _T("comment"), _T("终点端柱子句柄"));
			strText.Format(_T("%ld"), m_idColuEnd);
			xmlTree.SetItemText(posItemColEnd, strText);
		}
	}

	POSITION posItem4 = xmlTree.Insert(_T("Feature"), posRoot, posItem3);
	{
		xmlTree.SetAttribute(posItem4, _T("name"), _T("墙体性质"));
		xmlTree.SetAttribute(posItem4, _T("comment"), _T("墙是内墙还是外墙"));
		strText = IsExternal() ? _T("外墙") : _T("内墙");
		xmlTree.SetItemText(posItem4, strText);
	}

	POSITION posItem5 = xmlTree.Insert(_T("Width"), posRoot, posItem4);
	{
		xmlTree.SetAttribute(posItem5, _T("name"), _T("墙体宽度"));

		POSITION posItemLeftWidth = xmlTree.Insert(_T("Left_Width"), posItem5, NULL);
		{
			xmlTree.SetAttribute(posItemLeftWidth, _T("name"), _T("墙体左宽"));
			strText.Format(_T("%f"), GetWidth(0));
			xmlTree.SetItemText(posItemLeftWidth, strText);
		}
		POSITION posItemRightWidth = xmlTree.Insert(_T("Right_Width"), posItem5, posItemLeftWidth);
		{
			xmlTree.SetAttribute(posItemRightWidth, _T("name"), _T("墙体右宽"));
			strText.Format(_T("%f"), GetWidth(1));
			xmlTree.SetItemText(posItemRightWidth, strText);
		}
	}

	POSITION posItem6 = xmlTree.Insert(_T("Height"), posRoot, posItem5);
	{
		xmlTree.SetAttribute(posItem6, _T("name"), _T("墙体高度参数"));

		POSITION posItemNetHeight = xmlTree.Insert(_T("Net_height"), posItem6, NULL);
		{
			xmlTree.SetAttribute(posItemNetHeight, _T("name"), _T("墙体高"));
			xmlTree.SetAttribute(posItemNetHeight, _T("comment"), _T("从墙底起算的墙体净高"));
			strText.Format(_T("%f"), GetHeight());
			xmlTree.SetItemText(posItemNetHeight, strText);
		}

		POSITION posItemBottomHeight = xmlTree.Insert(_T("Botton_height"), posItem6, posItemNetHeight);
		{
			xmlTree.SetAttribute(posItemBottomHeight, _T("name"), _T("墙底高"));
			xmlTree.SetAttribute(posItemBottomHeight, _T("comment"), _T("从零标高到墙底的相对高度"));
			strText.Format(_T("%f"), GetElevation());
			xmlTree.SetItemText(posItemBottomHeight, strText);
		}
	}

	POSITION posItem7 = xmlTree.Insert(_T("Planview_type"), posRoot, posItem6);
	{
		xmlTree.SetAttribute(posItem7, _T("name"), _T("平面显示样式"));
		xmlTree.SetAttribute(posItem7, _T("comment"), _T("示意为1，详图为0"));
		strText.Format(_T("%d"), IsSimple2D());
		xmlTree.SetItemText(posItem7, strText);
	}

	POSITION posItem8 = xmlTree.Insert(_T("Baseline"), posRoot, posItem7);
	{
		xmlTree.SetAttribute(posItem8, _T("name"), _T("基线参数"));
		POSITION posItem = NULL;
		posItem = xmlTree.Insert(_T("Start_point"), posItem8, posItem);
		{
			// sg modify 120117，对点进行坐标变换
			TADSGePoint3d ptTransformBy = StartPoint();
			ptTransformBy.TransformBy(mat);

			xmlTree.SetAttribute(posItem, _T("name"), _T("起始点"));
			// strText.Format(_T("%f,%f,%f"), StartPoint().x, StartPoint().y, StartPoint().z);
			strText.Format(_T("%f,%f,%f"), ptTransformBy.x, ptTransformBy.y, ptTransformBy.z);
			xmlTree.SetItemText(posItem, strText);
		}

		posItem = xmlTree.Insert(_T("End_point"), posItem8, posItem);
		{
			// sg modify 120117，对点进行坐标变换
			TADSGePoint3d ptTransformBy = EndPoint();
			ptTransformBy.TransformBy(mat);

			xmlTree.SetAttribute(posItem, _T("name"), _T("结束点"));
			// strText.Format(_T("%f,%f,%f"), EndPoint().x, EndPoint().y, EndPoint().z);
			strText.Format(_T("%f,%f,%f"), ptTransformBy.x, ptTransformBy.y, ptTransformBy.z);
			xmlTree.SetItemText(posItem, strText);
		}

		posItem = xmlTree.Insert(_T("Central_ang"), posItem8, posItem);
		{
			xmlTree.SetAttribute(posItem, _T("name"), _T("圆心角"));
			strText.Format(_T("%f"), GetBulge());
			xmlTree.SetItemText(posItem, strText);
		}
	}

	POSITION posItem9 = xmlTree.Insert(_T("Cell_grid"), posRoot, posItem8);
	{
		xmlTree.SetAttribute(posItem9, _T("name"), _T("幕墙分格参数"));
		CString sTemp;
		POSITION posItemCellRows = xmlTree.Insert(_T("Cell_rows"), posItem9, NULL);
		{
			xmlTree.SetAttribute(posItemCellRows, _T("name"), _T("竖向行数"));
			strText.Format(_T("%d"), GetRowNum());
			xmlTree.SetItemText(posItemCellRows, strText);

			POSITION posItem = NULL;
			if (IsRowAverage())
			{
				strText.Format(_T("%f"), GetHeight() / GetRowNum());
				for (int i = 0; i < GetRowNum(); i++)
				{
					sTemp.Format(_T("Cell_height%d"), i + 1);
					posItem = xmlTree.Insert(sTemp, posItemCellRows, posItem);
					{
						xmlTree.SetAttribute(posItem, _T("name"), _T("竖向行高"));
						xmlTree.SetItemText(posItem, strText);
					}
				}
			}
			else
			{
				for (int i = 0; i < m_rowSpaces.Length(); i++)
				{
					sTemp.Format(_T("Cell_height%d"), i + 1);
					posItem = xmlTree.Insert(sTemp, posItemCellRows, posItem);
					{
						xmlTree.SetAttribute(posItem, _T("name"), _T("竖向行高"));
						strText.Format(_T("%f"), m_rowSpaces[i]);
						xmlTree.SetItemText(posItem, strText);
					}
				}
			}
		}

		POSITION posItemCellCols = xmlTree.Insert(_T("Cell_columns"), posItem9, posItemCellRows);
		{
			xmlTree.SetAttribute(posItemCellCols, _T("name"), _T("横向列数"));
			strText.Format(_T("%d"), GetColNum());
			xmlTree.SetItemText(posItemCellCols, strText);

			POSITION posItem = NULL;
			if (IsColAverage())
			{
				strText.Format(_T("%f"), m_startPoint.Distance2d(m_endPoint) / GetColNum());
				for (int i = 0; i < GetColNum(); i++)
				{
					sTemp.Format(_T("Cell_width%d"), i + 1);
					posItem = xmlTree.Insert(sTemp, posItemCellCols, posItem);
					{
						xmlTree.SetAttribute(posItem, _T("name"), _T("横向列宽"));
						xmlTree.SetItemText(posItem, strText);
					}
				}
			}
			else
			{
				for (int i = 0; i < m_colSpaces.Length(); i++)
				{
					sTemp.Format(_T("Cell_width%d"), i + 1);
					posItem = xmlTree.Insert(sTemp, posItemCellCols, posItem);
					{
						xmlTree.SetAttribute(posItem, _T("name"), _T("横向列宽"));
						strText.Format(_T("%f"), m_colSpaces[i]);
						xmlTree.SetItemText(posItem, strText);
					}
				}
			}
		}

		POSITION posItemMullionSize = xmlTree.Insert(_T("Mullion_size"), posItem9, posItemCellCols);
		{
			xmlTree.SetAttribute(posItemMullionSize, _T("name"), _T("竖梃尺寸"));
			strText.Format(_T("%f,%f"), GetColV(), GetColU());
			xmlTree.SetItemText(posItemMullionSize, strText);
		}

		POSITION posItemFrameSize = xmlTree.Insert(_T("Frame_size"), posItem9, posItemMullionSize);
		{
			xmlTree.SetAttribute(posItemFrameSize, _T("name"), _T("横框尺寸"));
			strText.Format(_T("%f,%f"), GetRowV(), GetRowU());
			xmlTree.SetItemText(posItemFrameSize, strText);
		}

		POSITION posItemFrameHide = xmlTree.Insert(_T("Frame_hide"), posItem9, posItemFrameSize);
		{
			xmlTree.SetAttribute(posItemFrameHide, _T("name"), _T("置顶框和底框"));
			xmlTree.SetAttribute(posItemFrameHide, _T("comment"), _T("需要顶框和底框为1,1"));
			strText.Format(_T("%d,%d"), HasTopRow(), HasBotRow());
			xmlTree.SetItemText(posItemFrameHide, strText);
		}
	}

	POSITION posItem10 = xmlTree.Insert(_T("Offset"), posRoot, posItem9);
	{
		xmlTree.SetAttribute(posItem10, _T("name"), _T("玻璃与框架与基线偏移"));
		POSITION posItemMullionOffset = xmlTree.Insert(_T("Mullion_offset"), posItem10, NULL);
		{
			xmlTree.SetAttribute(posItemMullionOffset, _T("name"), _T("竖梃与基线关系"));
			strText.Format(_T("%d"), GetColAlignment());
			xmlTree.SetItemText(posItemMullionOffset, strText);
		}

		POSITION posItemGlassOffset = xmlTree.Insert(_T("Glass_offset"), posItem10, posItemMullionOffset);
		{
			xmlTree.SetAttribute(posItemGlassOffset, _T("name"), _T("玻璃与基线偏移"));
			strText.Format(_T("%f"), GetGlazeDist());
			xmlTree.SetItemText(posItemGlassOffset, strText);
		}

		POSITION posItemFrameOffset = xmlTree.Insert(_T("Frame_offset"), posItem10, posItemGlassOffset);
		{
			xmlTree.SetAttribute(posItemFrameOffset, _T("name"), _T("横框与基线偏移"));
			strText.Format(_T("%f"), GetRowDist());
			xmlTree.SetItemText(posItemFrameOffset, strText);
		}
	}

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

	return strXml;
}

void InitDbCurtainWall(BOOL bTrue)
{
    if(bTrue) {
        TDbCurtainWall::rxInit();
        acrxBuildClassHierarchy();
        TDbCurtainWall::InitMatchProtocol(TRUE);
    } else {
        TDbCurtainWall::InitMatchProtocol(FALSE);
        deleteAcRxClass(TDbCurtainWall::desc());
    }
}

void TDbCurtainWall::RearrangeCol(TDbWall* pNewWall, double dOldLenght)
{
	if (!pNewWall->isKindOf(TDbCurtainWall::desc())) return;
	TDbCurtainWall* pWall = (TDbCurtainWall*)pNewWall;
	double dNewLenght = pWall->GetLength();
	if(fabs(dNewLenght - dOldLenght) < 0.01) return;

	if(pWall->IsColAverage())
	{
		int nColNum = pWall->GetColNum();
		if(nColNum <= 0) 
			nColNum = 1;
		pWall->SetColAverage(true);
		if(dOldLenght < DocGetMinLenWall())
		{
			pWall->SetColNum(nColNum);
			return;
		}
		double dAveColLen = dOldLenght / nColNum;
		nColNum = ((int)dNewLenght) / (int)dAveColLen;
		double dTemp = dNewLenght - nColNum * dAveColLen;
		if( fabs(dTemp) < 0.01)			//墙的长度刚好是pWallData->dFixedGapLen的倍数
		{

		}
		else if(dTemp > 0.0)
		{
			++nColNum;
		}
		else
		{
			--nColNum;
		}
		if(nColNum <= 0)
			nColNum = 1;
		pWall->SetColNum(nColNum);
	}
	else
	{
		pWall->SetColAverage(false);

		int nColNum = pWall->m_colSpaces.Length();
		if(nColNum == 0)
		{
			nColNum = 1;
			pWall->SetColNum(1);
			pWall->m_colSpaces.Reset();
			pWall->m_colSpaces.Append(new double(dNewLenght));
			return;
		}
		double dFirstLen = *(pWall->m_colSpaces.GetAt(0));
		double dTempLen;
		double dSumColLen = dFirstLen;
		bool bIsSame = true;
		//判断前nColNum - 1个是否相等
		for(int i = 1; i < pWall->m_colSpaces.Length() - 1; ++i)
		{
			dTempLen = *(pWall->m_colSpaces.GetAt(i));
			dSumColLen += dTempLen;
			if(bIsSame)
			{
				if(fabs(dTempLen - dFirstLen) > 0.01)
				{
					bIsSame = false;
				}
			}
		}
		dSumColLen += *(pWall->m_colSpaces.GetAt(pWall->m_colSpaces.Length() - 1));


		if(bIsSame)
		{
			pWall->m_colSpaces.Reset();
			nColNum = (int)(dNewLenght / dFirstLen);
			for(int i = 0; i < nColNum; ++i)
				pWall->m_colSpaces.Append(new double(dFirstLen));
			double dOdd = dNewLenght - nColNum * dFirstLen;
			if(dOdd > 0.01)
			{
				pWall->m_colSpaces.Append(new double(dOdd));
				++nColNum;
			}
			pWall->SetColNum(nColNum);
		}
		else
		{
			if(dOldLenght < dNewLenght)
			{
				double dSumLen = dOldLenght;
				while(dSumLen + dFirstLen < dNewLenght)
				{
					pWall->m_colSpaces.Append(new double(dFirstLen));
					dSumLen += dFirstLen;
				}
				if(fabs(dNewLenght - dSumLen) > 0.01)
				{
					pWall->m_colSpaces.Append(new double(dNewLenght - dSumLen));
				}
				pWall->SetColNum(pWall->m_colSpaces.Length());
			}
			else
			{
				int nColNum = pWall->m_colSpaces.Length();
				double dLastLen;
				while(1)
				{
					dLastLen = *(pWall->m_colSpaces.GetAt(nColNum-1));
					if(dSumColLen - dLastLen > dNewLenght)
					{
						pWall->m_colSpaces.Remove(nColNum -1);
						dSumColLen -= dLastLen;
						--nColNum;
					}
					else
					{
						pWall->m_colSpaces.Remove(nColNum -1);
						pWall->m_colSpaces.Append(new double(dNewLenght - dSumColLen));
						break;
					}
				}
				pWall->SetColNum(nColNum);
			}
		}
	}

}

void TDbCurtainWall::WallSegmentateColumnAdjust(TDbCurtainWall* pWall, const double &lenght, double dSegmentatePos, 
								BOOL& bFirstAve, UINT& nFirstColumnNum, std::vector<double>& vecFirstColumnGap,
								BOOL& bSecondAve, UINT& nSecondColumnNum, std::vector<double>& vecSecondColumnGap)
{
	if(!pWall)
		return;
	double dWallLen = lenght;
	//如果分段位置不对 则对其进行容错性处理
	if(dSegmentatePos < 0 || dSegmentatePos > dWallLen)
	{
		bFirstAve = TRUE;
		nFirstColumnNum = 1;
		bSecondAve = TRUE;
		nSecondColumnNum = 1;
		return ;
	}
	vecFirstColumnGap.clear();
	vecSecondColumnGap.clear();
	double dFirstWallLen = dSegmentatePos;
	double dSecondWallLen = dWallLen - dFirstWallLen;
	BOOL bAve = pWall->IsColAverage();
	if(dWallLen < g_nMinLenWall)
	{
		bFirstAve = bAve;
		bSecondAve = bAve;
		if(bAve)
		{
			nFirstColumnNum = 1;
			nSecondColumnNum = 1;
		}
		else
		{
			vecFirstColumnGap.push_back(dFirstWallLen);
			vecSecondColumnGap.push_back(dSecondWallLen);
		}
		return;
	}

	bFirstAve = bAve;
	bSecondAve = bAve;
	if(bAve)
	{
		//认为是等分接近值
		//那么分段后，两端新墙也将使用相同的等分接近值，但两端墙立柱间平均值不一定相当

		UINT nColumnNum = pWall->GetColNum();
		if(nColumnNum == 0) nColumnNum = 1;
		double dAveLen = dWallLen / nColumnNum;

		nFirstColumnNum = (UINT)(dFirstWallLen / dAveLen);
		if((dFirstWallLen - dAveLen * nFirstColumnNum) > 0.0)
			++nFirstColumnNum;
		else if(fabs(dFirstWallLen - dAveLen * nFirstColumnNum) < 0.00001)
			nFirstColumnNum = nFirstColumnNum;
		else
			--nFirstColumnNum;

		nSecondColumnNum = (UINT)(dSecondWallLen / dAveLen);
		if((dSecondWallLen - dAveLen * nSecondColumnNum) > 0.0)
			++nSecondColumnNum;
		else if(fabs(dSecondWallLen - dAveLen * nFirstColumnNum) < 0.00001)
			nSecondColumnNum = nSecondColumnNum;
		else
			--nSecondColumnNum;
	}
	else
	{
		//不等分， 分为两种情况， 先判断其是不是等间距的， 如果是等间距的，则新墙也将是等间距的
		int nOldColNum =  pWall->m_colSpaces.Length();
		if(nOldColNum == 0)
		{
			vecFirstColumnGap.push_back(dFirstWallLen);
			vecSecondColumnGap.push_back(dSecondWallLen);
			return;
		}
		bool bIsEqualGap = true;
		double dFirstGap = *(pWall->m_colSpaces.GetAt(0));
		double dNewGap;

		for(int i = 1; i < nOldColNum - 1; ++i)
		{
			dNewGap = *(pWall->m_colSpaces.GetAt(i));
			if(fabs(dFirstGap - dNewGap) > 0.001)
			{
				bIsEqualGap = false;
				break;
			}
		}

		if(bIsEqualGap)			//说明是等距的
		{
			double dSum = dFirstGap;
			//第一段墙设置立柱间距
			while(dSum < dFirstWallLen)
			{
				vecFirstColumnGap.push_back(dFirstGap);
				dSum += dFirstGap;
			}
			double dVestigialLen = dFirstWallLen - (dSum - dFirstGap);
			if(fabs(dVestigialLen) > 0.0)
				vecFirstColumnGap.push_back(dVestigialLen);

			dSum = dFirstGap;
			//第二段墙设置立柱间距
			while(dSum < dSecondWallLen)
			{
				vecSecondColumnGap.push_back(dFirstGap);
				dSum += dFirstGap;
			}
			dVestigialLen = dSecondWallLen - (dSum - dFirstGap);
			if(fabs(dVestigialLen) > 0.0)
				vecSecondColumnGap.push_back(dVestigialLen);
		}
		else
		{
			bool bFirstWallHaveSet = false;
			double dFirstWallSumLen = 0.0;
			double dSecondWallSumLen = 0.0;
			for(int i = 0; i < nOldColNum; ++i)
			{	
				dNewGap = *(pWall->m_colSpaces.GetAt(i));
				if(dNewGap <= 0.0) continue;
				if(!bFirstWallHaveSet)
				{
					//先设置第一段墙
					dFirstWallSumLen += dNewGap;
					if(dFirstWallSumLen < dFirstWallLen)
					{
						vecFirstColumnGap.push_back(dNewGap);
					}
					else
					{
						double dVestigialLen = dFirstWallLen - (dFirstWallSumLen - dNewGap);
						if(fabs(dVestigialLen) > 0.001)
						{
							vecFirstColumnGap.push_back(dVestigialLen);
							dFirstWallSumLen = dFirstWallLen;
						}
						bFirstWallHaveSet = true;
					}
				}
				else
				{
					dSecondWallSumLen += dNewGap;
					if(dSecondWallSumLen < dSecondWallLen)
					{
						vecSecondColumnGap.push_back(dNewGap);
					}
					else
					{
						double dVestigialLen = dSecondWallLen - (dSecondWallSumLen -dNewGap);
						if(fabs(dVestigialLen) > 0.001)
						{
							vecSecondColumnGap.push_back(dVestigialLen);
							dSecondWallSumLen = dSecondWallLen;
						}
					}
				}
			}
			//最后保证立柱的间距之和等于墙的长度
			if(dFirstWallLen > dFirstWallSumLen)
				vecFirstColumnGap.push_back(dFirstWallLen - dFirstWallSumLen);
			if(dSecondWallLen > dSecondWallSumLen)
				vecSecondColumnGap.push_back(dSecondWallLen - dSecondWallSumLen);
		}
	}
}

Acad::ErrorStatus TDbCurtainWall::subMoveGripPointsAt( const AcDbIntArray& indices, const AcGeVector3d& offset )
{
	assertWriteEnabled();
	Acad::ErrorStatus eRet;
	BOOL bColAve = IsColAverage();
	if((eRet = TDbWall::subMoveGripPointsAt(indices, offset)) != Acad::eOk)
		return eRet;
	if(bColAve)
		return eRet;
	bool bWallLenghtChanged = false;
	for (int i = 0; i < indices.length(); i++) 
	{
		if(indices[i] == 1 || indices[i] == 0)
		{
			bWallLenghtChanged = true;
		}
	}
	if(!bWallLenghtChanged) return eRet;
	int nColNum = m_colSpaces.Length();
	if(nColNum == 0) 
		return eRet;
	double dWallLen = GetLength();
	bool bPreColLenSame = true;
	double dFirstColLen = *(m_colSpaces.GetAt(0));
	double dCurColLen;
	double dColSum = dFirstColLen;
	if(dColSum >= dWallLen)
	{
		m_colSpaces.Reset();
		m_colSpaces.Append(new double(dWallLen));
		SetColNum(1);
		SetColAverage(FALSE);
		return eRet;
	}
	for(int i = 1; i < nColNum - 1; ++i)		//最后一个列元素暂时不考虑,因为这个会影响判断前几个元素是否相等的判断
	{
		dCurColLen = *(m_colSpaces.GetAt(i));
		//判断前几个元素是否相等
		if(bPreColLenSame)
		{
			if(fabs(dCurColLen - dFirstColLen) > 0.001)
				bPreColLenSame = false;
		}
		dColSum += dCurColLen;
		if(dColSum >= dWallLen)
		{
			//如果立柱长度之和大于墙的长度，说明墙缩短了， 此时删除后面的立柱
			dColSum -= dCurColLen;
			//删除此位置后面的所有的元素 
			for(int j = i; j < nColNum; ++j)
				m_colSpaces.Remove();
			nColNum = i;
			if(fabs(dWallLen - dColSum) > 0.001)
			{
				m_colSpaces.Append(new double(dWallLen - dColSum));
				++nColNum;
			}
			SetColNum(nColNum);
			SetColAverage(FALSE);
			return eRet;
		}
	}
	//考虑最后一个立柱
	dCurColLen = *(m_colSpaces.GetAt(nColNum - 1));
	m_colSpaces.Remove();		//上一句GetAt将指针置为最后一个元素位置， 此函数删除当前元素
	nColNum = nColNum - 1;		//新的立柱数目， 下面将会对此值进行修正

	if(!bPreColLenSame)
	{
		if(dCurColLen > g_nMinLenWall)
			dFirstColLen = dCurColLen;
	}

	dColSum += dFirstColLen;
	while(dColSum < dWallLen)
	{
		m_colSpaces.Append(new double(dFirstColLen));
		dColSum += dFirstColLen;
		++nColNum;
	}
	double dLastColLen = dWallLen - (dColSum - dFirstColLen);
	if(dLastColLen > 0.001)
	{
		m_colSpaces.Append(new double(dLastColLen));
		++nColNum;
	}
	SetColNum(nColNum);
	SetColAverage(FALSE);
	return eRet;

}

#if (ADS == 17)
void TDbCurtainWall::AppendForColSpaces(const double & d)
{
	m_colSpaces.Append(new double(d));
}

void TDbCurtainWall::AppendForRowSpaces(const double & d)
{
	m_rowSpaces.Append(new double(d));
}
#endif