#include "stdafx.h"
#include "DbSlopeRoof.h"

//AEC7:0,AEC8:1
Adesk::UInt8 TRoofBase::g_nVersion=1;
TRoofBase::TRoofBase():m_nSlabThick(_AS_SYS_UNIT(200))
{
}
Acad::ErrorStatus TRoofBase::Read(AcDbDwgFiler* pFiler)
{
	Adesk::UInt8  nVer;
	pFiler->readItem(&nVer);
	if(nVer>g_nVersion)
		return Acad::eMakeMeProxy;

	pFiler->readItem(&m_idTopFaceLayer);
	pFiler->readItem(&m_idBotFaceLayer);
	pFiler->readItem(&m_idSlabLayer);
	pFiler->readItem(&m_idRidgeLayer);
	pFiler->readItem(&m_nSlabThick);
	pFiler->readItem(&m_nRidgeWidth);
	pFiler->readItem(&m_nRidgeHeight);
	Adesk::UInt8 nStyle;
	pFiler->readItem(&nStyle);
	m_nRidgeStyle=(RidgeStyle)nStyle;
	
	int temp;
	pFiler->readItem(&temp);//无用数据
	pFiler->readItem(&temp);//无用数据

	if(nVer>0)//AEC8
	{
		Adesk::Int32 num;

		m_lstHole.Reset();
		pFiler->readItem(&num);
		for(long i=0;i<num;i++)
		{
			XPoly2D *pPoly=new XPoly2D;
			ReadPoly2D(pFiler,*pPoly);
			m_lstHole.Append(pPoly);
		}

		m_lstIdOpening.Reset();
		pFiler->readItem(&num);
		for(i=0;i<num;i++)
		{
			AcDbSoftPointerId id;
			pFiler->readItem(&id);
			m_lstIdOpening.Append(new AcDbSoftPointerId(id));
		}
	}
	
	return pFiler->filerStatus();
}
Acad::ErrorStatus TRoofBase::Write(AcDbDwgFiler* pFiler)const
{
	if(g_nSaveTArchVer<8)
		pFiler->writeItem((Adesk::UInt8)0);
	else
		pFiler->writeItem(g_nVersion);

	pFiler->writeItem(m_idTopFaceLayer);
	pFiler->writeItem(m_idBotFaceLayer);
	pFiler->writeItem(m_idSlabLayer);
	pFiler->writeItem(m_idRidgeLayer);
	pFiler->writeItem(m_nSlabThick);
	pFiler->writeItem(m_nRidgeWidth);
	pFiler->writeItem(m_nRidgeHeight);
	pFiler->writeItem((Adesk::UInt8)m_nRidgeStyle);	

	int temp=0;
	pFiler->writeItem(temp);//无用数据
	pFiler->writeItem(temp);//无用数据

	if(g_nSaveTArchVer>7)
	{
		Adesk::Int32 num;

		num=m_lstHole.Length();
		pFiler->writeItem(num);
		for(long i=0;i<num;i++)
			WritePoly2D(pFiler,m_lstHole[i]);

		num=m_lstIdOpening.Length();
		pFiler->writeItem(num);
		for(i=0;i<num;i++)
		{
			const AcDbSoftPointerId &id=m_lstIdOpening[i];
			pFiler->writeItem(id);
		}
	}

	return pFiler->filerStatus();
}
TSlopeRoof::TSlopeRoof(const TSlopeRoof &src)
:m_polyOutline(1)
{
    *this = src;
}

TSlopeRoof &
TSlopeRoof::operator = (const TSlopeRoof &src)
{
    Reset();
    m_polyOutline=src.m_polyOutline;
    for(int i=0; i<src.m_slope.Length(); i++) 
        m_slope.Append(new double(src.m_slope[i]));
    return *this;
}

void
TSlopeRoof::Reset()
{
    m_polyOutline.Reset();
    m_slope.Reset();
}

void
TSlopeRoof::AppendEdge(const XPoint &ptFrom, double nSlope)
{
    m_polyOutline.AppendNode(ptFrom);
    m_slope.Append(new double(nSlope));
}

void
TSlopeRoof::InitEqualSlope(const XPoly2D &poly, double nSlope)
{
    ASSERT(poly.IsClosed());
    m_polyOutline=poly;
    int nEdge=poly.TotalSegments();
    m_slope.Reset();
    for(int i=0; i<nEdge; i++) 
        m_slope.Append(new double(nSlope));
}

double
TSlopeRoof::GetSlopeAngle(int idx) const
{
    ASSERT(idx<GetEdgeNum());
    return m_slope[idx];
}

void
TSlopeRoof::SetSlopeAngle(int idx, double nAngle)
{
    ASSERT(idx<GetEdgeNum());
    *m_slope[idx]=nAngle;
}


XLine
TSlopeRoof::GetSlopeEdge(int idx) const
{
    ASSERT(idx<GetEdgeNum());
    XLine ln;
    m_polyOutline.Nth(idx, ln, XArc());
    return ln;
}

// 求第i边到前一边的角度
double
TSlopeRoof::GetAngleToPrev(int idx) const
{
    int nEdge=m_slope.Length();
    ASSERT(idx<nEdge && nEdge==m_polyOutline.TotalSegments());
    XLine seg;
    m_polyOutline.Nth(idx, seg, XArc());
    int idPrev=LimitCycle(idx-1, nEdge);
    int idNext=LimitCycle(idx+1, nEdge);
    double nPrevAng=CT_std_angle(ads_angle(m_polyOutline[idx], m_polyOutline[idPrev]) -
        ads_angle(m_polyOutline[idx], m_polyOutline[idNext]));
    return nPrevAng;
}

BOOL
TSlopeRoof::OffsetIn(double *pDistArray, TSlopeRoof &result) const
{
    int nEdgeNum=GetEdgeNum();
    TSlopeRoof tmp;
    XLine lnPrev(LS_INFINITE), ln0(LS_INFINITE);
    m_polyOutline.Nth(nEdgeNum-1, ln0, XArc());
    if(ln0.GetLength()<_DIST_SNAP)
        return FALSE;
    lnPrev=ln0.Offset(-pDistArray[nEdgeNum-1]);
//    lnPrev.flag=LS_INFINITE;
	lnPrev.SetLineFlag(LS_INFINITE);
    for(int i=0; i<nEdgeNum; i++) {
        XLine lnCur(LS_INFINITE), ln1(LS_INFINITE);
        m_polyOutline.Nth(i, ln1, XArc());
        if(ln1.GetLength()<_DIST_SNAP)
            return FALSE;
        lnCur=ln1.Offset(-pDistArray[i]);
        XPoint ptInt;
        if(!lnCur.Intersection(&lnPrev, ptInt))
            return FALSE;
        tmp.AppendEdge(ptInt, m_slope[i]);
        lnPrev=lnCur;
    }

    result=tmp;
    if(tmp.m_polyOutline.PathArea()>_DIST_SNAP*_DIST_SNAP ) {
        //需要另外的求解方法, 目前还没有做
        return FALSE;
    }
    return TRUE;
}


// Merge segment
// 有时不能一次性压缩成功
void
TSlopeRoof::Compress()
{
    // private AOL API
   extern BOOL MergeCurve(XCurveSegment &curve, XCurveSegment &seg, int bMinusCurve, int bMinusSeg);

   TSlopeRoof dest;
   int nTotalSeg=GetEdgeNum();
   BOOL bFirst=TRUE;;
   XCurveSegment curve;
   double nSlope=0;
   for(int n=0; n<nTotalSeg; n++) {
      XCurveSegment seg;
      m_polyOutline.Nth(n, seg);
      if(!seg) 
          continue;

      
      if(bFirst)  {
         curve=seg;
         nSlope = *m_slope[n];
         bFirst=FALSE;
         continue;
      } else {
          if(!curve) { //由于合并产生0线段
              curve=seg;
              nSlope = *m_slope[n];
          } else {
			  double nLenCurve=curve.GetLength();
			  double nLenSeg=seg.GetLength();
             BOOL bMerged=MergeCurve(curve, seg, FALSE, FALSE);
             if(!bMerged) { //当前段没有合并进curve, 更新curve
                 dest.AppendEdge(curve.StartPoint(), nSlope);
                 curve=seg;
                 nSlope = *m_slope[n];
             } else { //合并时取较大角度者
				 if(nLenCurve<nLenSeg)
					 nSlope=*m_slope[n];
                 //nSlope = max(nSlope, *m_slope[n]);
             }
          }
      } 
   }

   if(!bFirst) 
      dest.AppendEdge(curve.StartPoint(), nSlope);
   
   if(dest.GetEdgeNum()>=3) {
      int nTotalDest=dest.GetEdgeNum();
      XCurveSegment curveFirst, curveFinal;
      dest.m_polyOutline.Nth(0, curveFirst),
      dest.m_polyOutline.Nth(nTotalDest-1, curveFinal);
	  double nLenFinal=curveFinal.GetLength();
	  double nLenFirst=curveFirst.GetLength();
      if(MergeCurve(curveFinal, curveFirst, FALSE, FALSE)) {
         *dest.m_polyOutline[0]=curveFinal.StartPoint();
//         dest.m_polyOutline.bulges.Remove(nTotalDest-1);
		 dest.m_polyOutline.RemoveBugle(nTotalDest-1);
         dest.m_polyOutline.Remove(nTotalDest-1);
		 double nSlopeFinal=*dest.m_slope[nTotalDest-1];
         dest.m_slope.Remove(nTotalDest-1);
		 if(nLenFinal>nLenFirst)
			 *dest.m_slope[0] = nSlopeFinal;
         if(!curveFinal) {
             dest.m_polyOutline.Remove(0);
//             dest.m_polyOutline.bulges.Remove(0);
	 		 dest.m_polyOutline.RemoveBugle(0);
             dest.m_slope.Remove(0);
         }
      }
      *this = dest;
   } else {
       // Clear me
       Reset();
   }

}

BOOL
TSlopeRoof::IsInOtherEdge(int idx) const
{
    int nEdgeNum=GetEdgeNum();
    ASSERT(idx<nEdgeNum);
    XLine ln;
    m_polyOutline.Nth(idx, ln, XArc());
    for(int i=0; i<nEdgeNum; i++) {
        XLine ln0;
        if(i==idx)
            continue;
        m_polyOutline.Nth(i, ln0, XArc());
        if(!ln0)
            continue;
        int nPrFlag1=ln.StartPoint()&ln0;
        int nPrFlag2=ln.EndPoint()&ln0;
        if((nPrFlag1==PR_INSIDE || nPrFlag1==PR_ONPT1 || nPrFlag1==PR_ONPT2) &&
            (nPrFlag2==PR_INSIDE || nPrFlag2==PR_ONPT1 || nPrFlag2==PR_ONPT2)) {
            return TRUE;
        }
    }
    return FALSE;
}


BOOL
TSlopeRoof::GetGeometry1(XExplodeDraw &dc, BOOL bBotVis) const
{
    XAecRoof roof(bBotVis);
    roof.InitRoof(m_polyOutline, PI/6.0);
    int nEdgeNum=GetEdgeNum();
    for(int iEdge=0; iEdge<nEdgeNum; iEdge++) {
        XRoofEdgeCompact *pEdge = roof.m_lstEdges[iEdge];
        pEdge->m_nSlope = GetSlopeAngle(iEdge);
    }
    BOOL bRet=FALSE;
    if(roof.Calculate()==RTNORM) {
        int nVerticeNum=0, nFaceListLen=0;
        Adesk::Int32 *pFaceList=NULL;
        XPoint *pVerticeList=NULL;
        Adesk::UInt8 *pEdgeVisArray=NULL; 
        if(roof.GetSurfaceData(&nVerticeNum, pVerticeList, &nFaceListLen, pFaceList,
            pEdgeVisArray)==RTNORM) {
            AcGiEdgeData edge;
            edge.setVisibility(pEdgeVisArray);
            dc.DrawShell(nVerticeNum, 
                (const AcGePoint3d *)pVerticeList, 
                nFaceListLen, 
                pFaceList, 
                &edge);
            bRet=TRUE; 
        }
        if(pFaceList) delete []pFaceList;
        if(pVerticeList) delete []pVerticeList;
        if(pEdgeVisArray) delete [] pEdgeVisArray;
    }
    return bRet;
}

// 求二维几何
BOOL
TSlopeRoof::GetGeometry2d1(XExplodeDraw &dc, BOOL bBotVis) const
{
    XAecRoof roof(bBotVis);
    roof.InitRoof(m_polyOutline, PI/6.0);
    int nEdgeNum=GetEdgeNum();
    for(int iEdge=0; iEdge<nEdgeNum; iEdge++) {
        XRoofEdgeCompact *pEdge = roof.m_lstEdges[iEdge];
        pEdge->m_nSlope = GetSlopeAngle(iEdge);
    }
    BOOL bRet=FALSE;
    if(roof.Calculate()==RTNORM) {
		AcDbVoidPtrArray entSet;
		XExplodeStream dcTemp(entSet);
        int nVerticeNum=0, nFaceListLen=0;
        Adesk::Int32 *pFaceList=NULL;
        XPoint *pVerticeList=NULL;
        Adesk::UInt8 *pEdgeVisArray=NULL; 
        if(roof.GetSurfaceData(&nVerticeNum, pVerticeList, &nFaceListLen, pFaceList,
            pEdgeVisArray)==RTNORM) {
            AcGiEdgeData edge;
            edge.setVisibility(pEdgeVisArray);
            dcTemp.DrawShell(nVerticeNum, 
                (const AcGePoint3d *)pVerticeList, 
                nFaceListLen, 
                pFaceList, 
                &edge);
            bRet=TRUE; 
        }
        if(pFaceList) delete []pFaceList;
        if(pVerticeList) delete []pVerticeList;
        if(pEdgeVisArray) delete [] pEdgeVisArray;
		
		int nLen=entSet.length();
		for(int i=0; i<nLen; i++) {
			AcDbEntity *pEnt=(AcDbEntity *)entSet[i];
			if(pEnt->isA()==AcDbFace::desc()) {
				AcDbFace *pFace=(AcDbFace *)pEnt;
				for(int m=0; m<4; m++) {
					int mNext=m+1;
					if(mNext==4)
						mNext=0;
					Adesk::Boolean bVis=Adesk::kTrue;
					if(pFace->isEdgeVisibleAt(m, bVis)==Acad::eOk && bVis) {
						XPoint pt1, pt2;
						pFace->getVertexAt(m, pt1);
						pFace->getVertexAt(mNext, pt2);
						pt1.z=pt2.z=0;
						if(pt1.Distance(pt2)>_DIST_SNAP) {
							dc << XLine(pt1, pt2);
						}
					}
				}
			}
		}
		ReleaseEntSet(entSet);
    }
    return bRet;
}

// i--顶点号, n--边号
double TSlopeRoof::GetHMin(int i, int n) const
{
    int nEdgeNum=GetEdgeNum();
    ASSERT(i>=0 && i<nEdgeNum && n>=0 && n<nEdgeNum);
    if(nEdgeNum<3 || DePeriod(nEdgeNum, i+1)==n || DePeriod(nEdgeNum, i-1)==n)
        return -1.0;

    double h= (-C(n)-A(n)*s(i)-B(n)*v(i))/(A(n)*r(i)+B(n)*u(i)+a(n)*Ctan(n));
    double xi=r(i)*h + s(i);
    double yi=u(i)*h + v(i);
   
    int n1=DePeriod(nEdgeNum, n+1);

    double xn=r(n)*h + s(n);
    double yn=u(n)*h + v(n);

    double xn1=r(n1)*h + s(n1);
    double yn1=u(n1)*h + v(n1);
    /*
    double xn=m_polyOutline[n].x;
    double yn=m_polyOutline[n].y;
    double xn1=m_polyOutline[n1].x;
    double yn1=m_polyOutline[n1].y;
    */
    XPoint pti(xi, yi);
    XLine ln(XPoint(xn, yn), XPoint(xn1, yn1));
    int nPrFlag=pti&ln;
    if(nPrFlag!=PR_INSIDE)
        h=-1.0;
        /*
    if(min(xn, xn1)<xi && xi<max(xn, xn1) &&
        min(yn, yn1)<yi && yi<max(yn, yn1))
        ;
    else
        h=-1.0;
*/
    return h;
}

// i--顶点号, n--边号
double TSlopeRoof::GetHMin(int i, int *n) const
{
    int nEdgeNum=GetEdgeNum();
    int iPrev=DePeriod(nEdgeNum, i-1);
    int iNext=i; //DePeriod(nEdgeNum, i+1);
    double hMin=-1;
    DList<int> lstEdgeN;
    for(int k=0; k<nEdgeNum; k++) {
        if(k==iPrev || k==iNext)
            continue;
        double h=GetHMin(i, k);
        if(h>0) {
            if(hMin<0) {
                hMin=h;
                lstEdgeN.Append(new int(k));
            } else {
                if(fabs(h-hMin)<_DIST_SNAP)
                    lstEdgeN.Append(new int(k));
                else if(h<hMin) {
                    hMin=h;
                    lstEdgeN.Reset();
                    lstEdgeN.Append(new int(k));
                }
            }
        }
    }
    if(lstEdgeN.Length()!=1)
        return -1;
    *n=*lstEdgeN.Head();
    return hMin;
}


// i--顶点号, n--边号
double TSlopeRoof::GetHMin(int *i, int *n) const
{
    int nEdgeNum=GetEdgeNum();
    double hMin=-1;
    DList<CPoint> lstEdgeDot;
    for(int k=0; k<nEdgeNum; k++) {
        int nEdge;
        double h=GetHMin(k, &nEdge);
        if(h>0) {
            if(hMin<0) {
                hMin=h;
                lstEdgeDot.Append(new CPoint(k, nEdge));
            } else {
                if(fabs(h-hMin)<_DIST_SNAP)
                    lstEdgeDot.Append(new CPoint(k, nEdge));
                else if(h<hMin) {
                    hMin=h;
                    lstEdgeDot.Reset();
                    lstEdgeDot.Append(new CPoint(k, nEdge));
                }
            }
        }
    }
    if(lstEdgeDot.Length()!=1)
        return -1;
    *i=lstEdgeDot.Head()->x;
    *n=lstEdgeDot.Head()->y;
    return hMin;
}


BOOL 
TSlopeRoof::SplitRoof(int iVert, int nEdge, TSlopeRoof &roof1, TSlopeRoof &roof2) const
{
    XLine ln=GetSlopeEdge(nEdge);
    XPoint ptVert=m_polyOutline[iVert];
    if((ptVert&ln)!=PR_INSIDE)
        return FALSE;
    int nEdgeNum=GetEdgeNum();
    int nFrom1=iVert, nTo1=nEdge;
    if(nTo1<nFrom1) nTo1 += nEdgeNum;

    roof1.Reset();
    for(int n=nFrom1; n<=nTo1; n++) {
        int n1=DePeriod(nEdgeNum, n);
        roof1.AppendEdge(m_polyOutline[n1], GetSlopeAngle(n1));
    }

    int nFrom2=nEdge, nTo2=iVert-1;;
    if(nTo2<nFrom2) nTo2 += nEdgeNum;
    roof2.Reset();
    for(n=nFrom2; n<=nTo2; n++) {
        int n1=DePeriod(nEdgeNum, n);
        roof2.AppendEdge(m_polyOutline[n1==nEdge? iVert:n1], GetSlopeAngle(n1));
    }
    return TRUE;   
}

// 某一边消失时的HMin
double TSlopeRoof::GetHMin() const
{
    double hMin=-1;
    int nEdgeNum=GetEdgeNum();
    for(int i=0; i<nEdgeNum; i++) {
        double xEq = r(i)-r(i+1);
        double hx=-1;
        BOOL bXEq=FALSE;
        if(fabs(xEq)<1.0E-6) {
            if(fabs(s(i)-s(i+1))>1.0E-6)
                continue;
            bXEq=TRUE;
        } else {
            hx=(s(i+1)-s(i))/xEq;
        }

        double yEq=u(i)-u(i+1);
        double hy=-1;
        BOOL bYEq=FALSE;
        if(fabs(yEq)<1.0E-6) {
            if(fabs(v(i)-v(i+1))>1.0E-6)
                continue;
            bYEq=TRUE;
        } else {
            hy=(v(i+1)-v(i))/yEq;
        }

        double h=-1;
        if(bXEq && bYEq)  //自动满足
            continue; 
        else if(!bXEq && !bYEq) {
            if(fabs(hx-hy)>_DIST_SNAP)
                continue;
            h=hx;
        } else if(!bXEq) {
            h=hx;
        } else  {
            h=hy;
        }

        if(h>0) {
            if(hMin<0) hMin=h;
            else hMin=min(hMin, h);
        }
    }
    return hMin;
}

#if 0
double TSlopeRoof::GetHMin() const
{
       int nEdgeNum=GetEdgeNum();
        double *h=new double[nEdgeNum];
        for(int i=0; i<nEdgeNum; i++) {
            double nEdgeLen=GetSlopeEdge(i).Length();
            double nAngPrev=GetAngleToPrev(i);
            double nAngNext=GetAngleToPrev(LimitCycle(i+1, nEdgeNum)); 
            double nSlope=GetSlopeAngle(i);
            double nSlopePrev=GetSlopeAngle(LimitCycle(i-1, nEdgeNum));
            double nSlopeNext=GetSlopeAngle(LimitCycle(i+1, nEdgeNum));
            //curLoop.GetSlopeAt(i, &nEdgeLen, &nSlope, &nAngPrev, &nAngNext);
            //h[i]=nEdgeLen*tan(nSlope)/(1/tan(nAngPrev/2)+1/tan(nAngNext/2));
            ASSERT(nAngPrev>_angSnap && nAngNext>_angSnap &&
                fabs(nAngPrev-PI)>_angSnap && fabs(nAngNext-PI)>_angSnap);
            BOOL bPrevVert=(fabs(PI/2-nSlopePrev)<_angSnap);
            BOOL bNextVert=(fabs(PI/2-nSlopeNext)<_angSnap);
            BOOL bVert=(fabs(PI/2-nSlope)<_angSnap);
            if(bVert) {
                if(bPrevVert && bNextVert) {
                    h[i]=-1000.0; //没有解
                } else {
                    h[i] = nEdgeLen/
                        ( (bPrevVert? 0 : 1/(tan(nSlopePrev)*sin(nAngPrev)))
                                   +
                          (bNextVert? 0 : 1/(tan(nSlopeNext)*sin(nAngNext)))
                        );
                }
            } else {
                h[i] = nEdgeLen*tan(nSlope)/
                    (
                       (bPrevVert? 1/tan(nAngPrev) : (tan(nSlope)/tan(nSlopePrev)+cos(nAngPrev))/sin(nAngPrev))
                                   +
                       (bNextVert? 1/tan(nAngNext) : (tan(nSlope)/tan(nSlopeNext)+cos(nAngNext))/sin(nAngNext))
                    );
            }
            if(h[i]<0) {
            }
        }
        // 求最小值
        double hMin=-1;
        for(i=0; i<nEdgeNum; i++) {
            if(h[i]<0)
                continue;
            if(hMin<0)
                hMin=h[i];
            else
                hMin=min(hMin, h[i]);
        }
        delete [] h;

        return hMin;
}
#endif

BOOL
TSlopeRoof::GetGeometry(XExplodeDraw &dc, BOOL bFirstLoop) const
{
    TSlopeRoof curLoop;
    curLoop=*this;
    curLoop.Compress();
    curLoop.Compress();

    double hCurrent=0.0;
    BOOL bRet=TRUE;
    while(1) {
        int nEdgeNum=curLoop.GetEdgeNum();
        //ASSERT(nEdgeNum>2); // bug here
        if(nEdgeNum<=2)
            break;
        double hMin1=curLoop.GetHMin();
        int iVert=0, nEdge=0;
        double hMin2=curLoop.GetHMin(&iVert, &nEdge);
        double hMin;
        int nUseMethod=0; // 0-边消失, 1--分解多边形
        if(hMin1<0 && hMin2<0) {
            bRet=curLoop.GetGeometry1(dc, bFirstLoop);
            break;
        } else {
            if(hMin1<0) {
                hMin=hMin2;
                nUseMethod=1;
            } else if(hMin2<0) {
                hMin=hMin1;
                nUseMethod=0;
            } else {
                hMin=min(hMin1, hMin2);
                nUseMethod=(hMin1-hMin2>_DIST_SNAP); // || fabs(hMin2-hMin1)<_DIST_SNAP);
            }
        }

        hCurrent += hMin;

        double *d=new double[nEdgeNum]; //偏移量
        for(int i=0; i<nEdgeNum; i++) {
            d[i]=hMin/tan(curLoop.GetSlopeAngle(i));
        }
        TSlopeRoof nextLoop, nextLoop1;
        if(!curLoop.OffsetIn(d, nextLoop)) {
            delete []d;
            bRet=curLoop.GetGeometry1(dc, bFirstLoop);
            break;
        }
        delete [] d;

        nextLoop.SetElevation(GetElevation()+hCurrent);

        if(!nUseMethod) {
            nextLoop1=nextLoop;
            nextLoop1.Compress();
            nextLoop1.Compress();
            if(nextLoop1.m_polyOutline.IsSelfIntersect())  {
                curLoop.GetGeometry1(dc, bFirstLoop);
                break;
            }
        }

        double nBotArea=nextLoop.GetBottomArea();
        for(i=0; i<nEdgeNum; i++) {
            if(fabs(curLoop.GetSlopeAngle(i)-PI/2.0)<_angSnap) // fix bug here on 2002/8/12
                continue; //90 度的坡不绘制
			double nPrevSlope=curLoop.GetSlopeAngle(DePeriod(nEdgeNum, i-1));
			double nNextSlope=curLoop.GetSlopeAngle(DePeriod(nEdgeNum, i+1));
            XLine ln=curLoop.GetSlopeEdge(i);
            XLine lnOffset=nextLoop.GetSlopeEdge(i);
            X3DFace face;
			face.SetVertex(0, ln.StartPoint());
			face.SetVertex(1, ln.EndPoint());
			face.SetVertex(2, lnOffset.EndPoint());
			face.SetVertex(3, lnOffset.StartPoint());
			face.SetFlag(0); //0x02;

			int nFaceFlag = face.GetFlag();
            if(!bFirstLoop)
				nFaceFlag |= 0x01; //第3边不可见
            if(!nextLoop.IsInOtherEdge(i))
                nFaceFlag |= 0x04;
			face.SetFlag(nFaceFlag);
            dc.DrawFace(face);

            double nRoofThick=_AS_SYS_UNIT(200.0);
            X3DFace face1=face;
            for(int k=0; k<4; k++)
                face1.GetVertex(k).z -= nRoofThick;
            for(k=0; k<4; k++) {
				if( k==0 && bFirstLoop ||
					k==1 && fabs(nNextSlope-PI/2)<_angSnap ||
					k==3 && fabs(nPrevSlope-PI/2)<_angSnap) {
					X3DFace face0;
					face0.SetFlag(0);
					int kNext=k+1;
					if(kNext==4) kNext=0;
					face0.GetVertex(0)=face1.GetVertex(k);
					face0.GetVertex(1)=face1.GetVertex(kNext);
					face0.GetVertex(2)=face.GetVertex(kNext);
					face0.GetVertex(3)=face.GetVertex(k);
					dc.DrawFace(face0);
				}
            }
			face1.Reverse(); //保证正确的法向
            dc.DrawFace(face1);
        }

        bFirstLoop=FALSE;


        if(nUseMethod) { //分解多边形
            TSlopeRoof roof1, roof2;
            bRet=nextLoop.SplitRoof(iVert, nEdge, roof1, roof2);
            if(bRet) {
                int bRet1=TRUE;
                if(roof1.GetBottomArea()>_DIST_SNAP*1.0)
                    bRet1=roof1.GetGeometry(dc, FALSE);
                int bRet2=TRUE;
                if(roof2.GetBottomArea()>_DIST_SNAP*1.0)
                    bRet2=roof2.GetGeometry(dc, FALSE);
                bRet=(bRet1&&bRet2);
            }
            break;
        } 

        curLoop=nextLoop1;

        if(nBotArea<_DIST_SNAP*1.0)
            break;
    }
    return bRet;
}


// 求二维几何
BOOL TSlopeRoof::GetGeometry2d(XExplodeDraw &dc, BOOL bFirstLoop) const
{
    TSlopeRoof curLoop;
    curLoop=*this;
    curLoop.Compress();
    curLoop.Compress();

    double hCurrent=0.0;
    BOOL bRet=TRUE;
    while(1) {
        int nEdgeNum=curLoop.GetEdgeNum();
        if(nEdgeNum<=2)
            break;
        double hMin1=curLoop.GetHMin();
        int iVert=0, nEdge=0;
        double hMin2=curLoop.GetHMin(&iVert, &nEdge);
        double hMin;
        int nUseMethod=0; // 0-边消失, 1--分解多边形
        if(hMin1<0 && hMin2<0) {
            bRet=curLoop.GetGeometry2d1(dc, bFirstLoop);
            break;
        } else {
            if(hMin1<0) {
                hMin=hMin2;
                nUseMethod=1;
            } else if(hMin2<0) {
                hMin=hMin1;
                nUseMethod=0;
            } else {
                hMin=min(hMin1, hMin2);
                nUseMethod=(hMin1-hMin2>_DIST_SNAP); // || fabs(hMin2-hMin1)<_DIST_SNAP);
            }
        }

        hCurrent += hMin;

        double *d=new double[nEdgeNum]; //偏移量
        for(int i=0; i<nEdgeNum; i++) {
            d[i]=hMin/tan(curLoop.GetSlopeAngle(i));
        }
        TSlopeRoof nextLoop, nextLoop1;
        if(!curLoop.OffsetIn(d, nextLoop)) {
            delete []d;
            bRet=curLoop.GetGeometry2d1(dc, bFirstLoop);
            break;
        }
        delete [] d;

        nextLoop.SetElevation(GetElevation()+hCurrent);

        if(!nUseMethod) {
            nextLoop1=nextLoop;
            nextLoop1.Compress();
            nextLoop1.Compress();
            if(nextLoop1.m_polyOutline.IsSelfIntersect())  {
                curLoop.GetGeometry2d1(dc, bFirstLoop);
                break;
            }
        }

        double nBotArea=nextLoop.GetBottomArea();
        for(i=0; i<nEdgeNum; i++) {
            //if(fabs(GetSlopeAngle(i)-PI/2.0)<_angSnap)
            //    continue; //90 度的坡不绘制
            XLine ln=curLoop.GetSlopeEdge(i);
            XLine lnOffset=nextLoop.GetSlopeEdge(i);
            X3DFace face;
            face.GetVertex(0)=lnOffset.StartPoint();
			face.GetVertex(1)=lnOffset.EndPoint();
            face.GetVertex(2)=ln.EndPoint();
			face.GetVertex(3)=ln.StartPoint();
            //face.flag = 0; //0x02;
			face.SetFlag(0x02);

			int nFaceFlag = face.GetFlag();
            if(!bFirstLoop)
                nFaceFlag |= 0x04; //第3边不可见
            if(!nextLoop.IsInOtherEdge(i))
                nFaceFlag |= 0x01;
			face.SetFlag(nFaceFlag);


            for(int m=0; m<4; m++)
			{
				int nBitFlag=(1<<m);
				nFaceFlag = face.GetFlag();
				if(!(nFaceFlag&nBitFlag))
				{
					int mNext=m+1;
					if(mNext==4)
						mNext=0;
					XLine lnTemp(face.GetVertex(m), face.GetVertex(mNext));
					lnTemp.StartPoint().z=lnTemp.EndPoint().z=0;
					if(lnTemp.GetLength()>_DIST_SNAP)
						dc << lnTemp;
				}
			}

        }

        bFirstLoop=FALSE;


        if(nUseMethod) { //分解多边形
            TSlopeRoof roof1, roof2;
            bRet=nextLoop.SplitRoof(iVert, nEdge, roof1, roof2);
            if(bRet) {
                int bRet1=TRUE;
                if(roof1.GetBottomArea()>_DIST_SNAP*1.0)
                    bRet1=roof1.GetGeometry2d(dc, FALSE);
                int bRet2=TRUE;
                if(roof2.GetBottomArea()>_DIST_SNAP*1.0)
                    bRet2=roof2.GetGeometry2d(dc, FALSE);
                bRet=(bRet1&&bRet2);
            }
            break;
        } 

        curLoop=nextLoop1;

        if(nBotArea<_DIST_SNAP*1.0)
            break;
    }
    return bRet;
}


// 表面积
double 
TSlopeRoof::GetSurfArea() const
{
    AcDbVoidPtrArray entSet;
    XExplodeStream dc(entSet);
    double nArea=0.0;
    if(GetGeometry(dc, TRUE)) {
        int len=entSet.length();
        for(int i=0; i<len; i++) {
            AcDbEntity *pEnt=(AcDbEntity *)entSet[i];
            AcDbFace *pFace=AcDbFace::cast(pEnt);
            if(pFace) {
                XPoint ptArray[4];
                for(int n=0; n<4; n++)
                    pFace->getVertexAt(n, ptArray[n]);
                XLine lnBot(ptArray[2], ptArray[3]), lnTop(ptArray[0], ptArray[1]);
                double nHeight=ptArray[0].Distance(&lnBot);
                double nFaceArea=(lnBot.GetLength()+lnTop.GetLength())*nHeight/2.0;
                nArea += nFaceArea;
            }
        }
    }
    ReleaseEntSet(entSet);
    return nArea;
}


/////////////////////////////////////////////////////////////
// 屋顶对象类
/////////////////////////////////////////////////////////////
//AEC6,1,AEC7=2
const Adesk::UInt8 TDbSlopeRoof::g_nVersion = 2;


ACRX_DXF_DEFINE_MEMBERS(TDbSlopeRoof,TDbPolyPathEnt, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,  
						1, AEC_SLOPEROOF,"AEC_KERNAL|缺乏图形解释器, 请下载插件");

IMPLEMENT_TENTBASE(TDbSlopeRoof);

TDbSlopeRoof::TDbSlopeRoof()
:TSlopeRoof()
{
}


TDbSlopeRoof::~TDbSlopeRoof()
{
}

BOOL 
TDbSlopeRoof::IsValid() const
{
    BOOL bRet=TDbPolyPathEnt::IsValid();
    if(!bRet)
        return bRet;

    bRet=(m_slope.Length()==m_polyOutline.TotalSegments()); //倾角
    return bRet;
}

// 提供对格式刷的支持
void TDbSlopeRoof::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
{
    assertWriteEnabled();
    TDbPolyPathEnt::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
    TDbSlopeRoof *pSrc=TDbSlopeRoof::cast(pSrcEntity);
    if(pSrc) {
    }
}


Acad::ErrorStatus 
TDbSlopeRoof::subGetClassID(CLSID* pClsid) const
{
    *pClsid = CLSID_ComSlopeRoof;
    return Acad::eOk;
	return AcDbEntity::subGetClassID(pClsid);
}

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

   Acad::ErrorStatus es = TDbPolyPathEnt::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;
   }

   double nElev=0.0;
   pFiler->readItem(&nElev);
   Adesk::UInt16 nEdgeNum=0;
   pFiler->readItem(&nEdgeNum);
   for(Adesk::UInt16 i=0; i<nEdgeNum; i++) {
       AcGePoint3d ptVertex;
       double nSlope;
       pFiler->readItem(&ptVertex);
       pFiler->readItem(&nSlope);
       ptVertex[2]=nElev;
       AppendEdge(XPoint(ptVertex), nSlope);
   }

	if(nVer>1)
	{
		es=TRoofBase::Read(pFiler);
		if(es!=Acad::eOk)return es;

		pFiler->readItem(&m_fMaxHeight);
	}
   return pFiler->filerStatus();
}

Acad::ErrorStatus TDbSlopeRoof::dwgOutFields (AcDbDwgFiler* pFiler)const
{
   assertReadEnabled();
   Acad::ErrorStatus es = TDbPolyPathEnt::dwgOutFields(pFiler);
   if(es != Acad::eOk) return es;
	
   if(g_nSaveTArchVer<7)
	   pFiler->writeItem((Adesk::UInt8)1);
   else
		pFiler->writeItem(g_nVersion);

   double nElev=0.0;
   if(!!m_polyOutline)
       nElev=m_polyOutline[0].z;
   pFiler->writeItem(nElev); 

   Adesk::UInt16 nTotalEdge=GetEdgeNum();  
   pFiler->writeItem(nTotalEdge);
   for(Adesk::UInt16 i=0; i<nTotalEdge; i++) {
       pFiler->writeItem(m_polyOutline[i].AsAcGePoint3d());
       pFiler->writeItem(m_slope[i]);
   }

	if(g_nSaveTArchVer>6)
	{
		es=TRoofBase::Write(pFiler);
		if(es!=Acad::eOk)return es;

		pFiler->writeItem(m_fMaxHeight);
	}

   return pFiler->filerStatus();
}

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

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

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

	DList<XPoint> pts;
	DList<double> bulges;
	DList<double> slopes;
	XPoint pt;
	double nElev=0.0;
	resbuf rb;
	int fieldsFlags=0;
    while ((es == Acad::eOk)
        && ((es = pFiler->readResBuf(&rb)) == Acad::eOk))    {
        switch (rb.restype) {
        case 148:
            nElev=rb.resval.rreal;
            fieldsFlags |= 0x01;
            break;
        case AcDb::kDxfAngle:
            bulges.Append(new double(rb.resval.rreal));
            break;    
        case AcDb::kDxfAngle+1:
            slopes.Append(new double(rb.resval.rreal));
            break;    
		case AcDb::kDxfXCoord:
			pt=rb.resval.rpoint;
			pts.Append(new XPoint(pt));
			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;
        }
    }

    // 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 (pts.Length()<2 || pts.Length()!=slopes.Length()) {
        pFiler->setError(Acad::eMissingDxfField,
            _T("\nError DXF group code: 10, 51"));
        return Acad::eMissingDxfField;
	}

	m_polyOutline.Reset();
	m_slope.Reset();
	for(int i=0; i<pts.Length(); i++) {
		m_polyOutline.AppendNode(*pts[i]);
		m_slope.Append(new double(*slopes[i]));
	}
	m_polyOutline.SetElevation(nElev);
    return pFiler->filerStatus();
}

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

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

   es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbSlopeRoof"));
   assert(es == Acad::eOk);
    pFiler->writeDouble(148, GetElevation());
	double nEdgeNum=GetEdgeNum();
	for(int i=0; i<nEdgeNum; i++) {
		pFiler->writePoint2d(AcDb::kDxfXCoord, m_polyOutline[i].AsAcGePoint2d());
		//pFiler->writeDouble(AcDb::kDxfAngle, m_polyOutline.bulges[i]);
		pFiler->writeDouble(AcDb::kDxfAngle+1, GetSlopeAngle(i));
	}
   
   return es;
}




// Active when being rotated, scaled, moved, etc.

Acad::ErrorStatus TDbSlopeRoof::subTransformBy(const AcGeMatrix3d& xform)
{
    assertWriteEnabled();
	AecEntity::subTransformBy(xform);
    ads_matrix mat;
    memcpy(mat, &xform, sizeof(ads_matrix));
    double nElev=0.0;
    for(int i=0; i<m_polyOutline.Length(); i++) {
        XPoint *pt=m_polyOutline[i];
        pt->TransformBy(mat);
        //以第一个顶点的z坐标为基准
        if(i==0) {
            nElev = pt->z;
        } else {
            pt->z = nElev;
        }
    }
    if(IsMirrorMatrix(mat) && m_polyOutline.PathArea()>0) {
        m_polyOutline.Reverse();
        m_slope.Reverse();
    }
    return Acad::eOk;
}

void TDbSlopeRoof::UnionScale(double nScale)
{
	assertWriteEnabled();
	double nOldElev=GetElevation();
	TDbPolyPathEnt::UnionScale(nScale);
	SetElevation(nOldElev*nScale);
	m_nSlabThick*=nScale;//板厚
	m_nRidgeWidth*=nScale;
	m_nRidgeHeight*=nScale;//屋脊大小
	m_fMaxHeight*=nScale;
}


Acad::ErrorStatus
TDbSlopeRoof::ExplodeOrDraw3d(XExplodeDraw &dc) const
{

    assertReadEnabled();
    GetGeometry(dc, TRUE);
    return Acad::eOk;
}

bool TDbSlopeRoof::IsClipMe(const AEntityBase* pEnt)const
{
	return false;
}
Acad::ErrorStatus
TDbSlopeRoof::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
    assertReadEnabled();
    GetGeometry2d(dc, TRUE);
    return Acad::eOk;
}




const TCHAR *TDbSlopeRoof::GetDefaultLayer() const
{
    return LAY_ROOF;
}



/* * * * * * * * * * 取 动 态 属 性 显 示 数 据 的 函 数 * * * * * * * * * */
void TDbSlopeRoof::GetTips(DList<ObjInfoUnit> &lstInfo) const
{
   lstInfo.Append(new ObjInfoUnit(_T("对象类型") ,_T("任意坡顶")));

}
Acad::ErrorStatus TDbSlopeRoof::SetPathPoly(const XPoly2D &polyPath,const AcGeVector3d&normal) 
{
    assertWriteEnabled();
    XPoly2D polyPath1=polyPath;
	if(polyPath1.PathArea()>0)
		polyPath1.Reverse();
	InitEqualSlope(polyPath1,PI/6);
	return Acad::eOk;
}
Acad::ErrorStatus TDbSlopeRoof::GetPathPoly(XPoly2D &polyPath,AcGeVector3d&normal) const 
{
	assertReadEnabled();
    polyPath=m_polyOutline;
	normal=AcGeVector3d::kZAxis;
	return Acad::eOk;
}

// aec add 101115，支持统一标高
bool TDbSlopeRoof::UnifyElevation(double dElevation)
{
    assertWriteEnabled();
    SetElevation(dElevation);
	return true;
}


void InitDbRoof(BOOL bTrue)
{
    if(bTrue) {
        TDbSlopeRoof::rxInit();
         acrxBuildClassHierarchy();
        TDbSlopeRoof::InitMatchProtocol(TRUE);
   } else {
        TDbSlopeRoof::InitMatchProtocol(FALSE);
        deleteAcRxClass(TDbSlopeRoof::desc());
    }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//AEC8:2;
const Adesk::UInt8 TDbDualSlopeRoof::g_nVersion=2;
ACRX_DXF_DEFINE_MEMBERS(TDbDualSlopeRoof,TDbPolyPathEnt, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,  
						1, AEC_DUALROOF,"AEC_KERNAL|缺乏图形解释器, 请下载插件");

IMPLEMENT_TENTBASE(TDbDualSlopeRoof);


Acad::ErrorStatus TDbDualSlopeRoof::SetPathPoly(const XPoly2D &polyPath,const AcGeVector3d&normal) 
{
    assertWriteEnabled();
	SetPolyPath(polyPath);
	return Acad::eOk;
}
Acad::ErrorStatus TDbDualSlopeRoof::GetPathPoly(XPoly2D &polyPath,AcGeVector3d&normal) const 
{
	assertReadEnabled();
    polyPath=m_polyOutline;
	normal=AcGeVector3d::kZAxis;
	return Acad::eOk;
}
BOOL TDbDualSlopeRoof::IsValid()const
{
	if(!TDbPolyPathEnt::IsValid())
		return FALSE;

	return !!m_polyOutline&&m_polyOutline.IsClosed()&&!m_polyOutline.IsSelfIntersect()&&m_ptRidge2!=m_ptRidge1&&
		m_nAngleLeft<PI/2-1E-3&&m_nAngleRight<PI/2-1E-3;
}
bool TDbDualSlopeRoof::IsClipMe(const AEntityBase* pEnt)const
{
	return false;
}
void TDbDualSlopeRoof::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
{
    assertWriteEnabled();
    TDbPolyPathEnt::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
    TDbDualSlopeRoof *pSrc=TDbDualSlopeRoof::cast(pSrcEntity);
    if(pSrc) {
    }
}
Acad::ErrorStatus TDbDualSlopeRoof::subGetClassID(CLSID* pClsid) const
{
	*pClsid=CLSID_ComDualSlopeRoof;
	return Acad::eOk;
	return AcDbEntity::subGetClassID(pClsid);
}
// 从DWG读入数据:
Acad::ErrorStatus TDbDualSlopeRoof::dwgInFields (AcDbDwgFiler* pFiler)
{
	assertWriteEnabled();
	Acad::ErrorStatus es = TDbPolyPathEnt::dwgInFields(pFiler);
	if(es != Acad::eOk)
		return es;

	Adesk::UInt8  nVer;
	pFiler->readItem(&nVer);
	if(nVer>g_nVersion) 
		return Acad::eMakeMeProxy;

	es=TRoofBase::Read(pFiler);
	if(es!=Acad::eOk)return es;

	double nElev;
	pFiler->readItem(&nElev);
	ReadPoly2D(pFiler,m_polyOutline);
	m_polyOutline.SetElevation(nElev);
	
	AcGePoint2d pt;
	pFiler->readItem(&pt);
	m_ptRidge1=pt;
	pFiler->readItem(&pt);
	m_ptRidge2=pt;
	pFiler->readItem(&m_nAngleLeft);
	pFiler->readItem(&m_nAngleRight);
	pFiler->readItem(&m_bEqualAngle);

	//add by aec on 081223
	//AEC8 member
	if(nVer>1)
	{
		pFiler->readItem(&m_bHeightLim);
		pFiler->readItem(&m_dHeight);
	}
	else
	{
		m_bHeightLim = FALSE;
		m_dHeight = _AS_SYS_UNIT(3000);
	}

	return pFiler->filerStatus();
}

Acad::ErrorStatus TDbDualSlopeRoof::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	assertReadEnabled();
	Acad::ErrorStatus es = TDbPolyPathEnt::dwgOutFields(pFiler);
	if(es != Acad::eOk) return es;
	
	//modify by aec on 081223
	if(g_nSaveTArchVer<8)
		pFiler->writeItem((Adesk::UInt8)1);
	else
		pFiler->writeItem(g_nVersion);

	es=TRoofBase::Write(pFiler);
	if(es!=Acad::eOk)return es;

	double nElev=0;
	if(m_polyOutline.Length()>0)
		nElev=m_polyOutline[0].z;
	pFiler->writeItem(nElev);
	WritePoly2D(pFiler,m_polyOutline);
	
	pFiler->writeItem(m_ptRidge1.AsAcGePoint2d());
	pFiler->writeItem(m_ptRidge2.AsAcGePoint2d());
	pFiler->writeItem(m_nAngleLeft);
	pFiler->writeItem(m_nAngleRight);
	pFiler->writeItem(m_bEqualAngle);
		
	//add by aec on 081223
	//AEC8 member
	if(g_nSaveTArchVer>=8)
	{
		pFiler->writeItem(m_bHeightLim);
		pFiler->writeItem(m_dHeight);
	}

	return pFiler->filerStatus();
}
Acad::ErrorStatus TDbDualSlopeRoof::dxfInFields (AcDbDxfFiler* pFiler)
{
    assertWriteEnabled();

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

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

    return pFiler->filerStatus();
}

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

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

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

   return es;
}
Acad::ErrorStatus TDbDualSlopeRoof::subTransformBy(const AcGeMatrix3d& xform)
{
    assertWriteEnabled();
	AecEntity::subTransformBy(xform);
	m_polyOutline.TransformBy(xform);
	m_ptRidge1.TransformBy(xform);
	m_ptRidge2.TransformBy(xform);
    return Acad::eOk;
}
void TDbDualSlopeRoof::UnionScale(double nScale)
{
	assertWriteEnabled();
	double nOldElev=GetElevation();
	AecEntity::UnionScale(nScale);
	SetElevation(nOldElev*nScale);
	m_nSlabThick*=nScale;//板厚
	m_nRidgeWidth*=nScale;
	m_nRidgeHeight*=nScale;//屋脊大小
	m_dHeight*=nScale;//高度 add  by fxj 090916
}

Acad::ErrorStatus TDbDualSlopeRoof::GetGripText(int i, CString &cs) const
{
	if(i<m_polyOutline.Length()*2)
		return TDbPolyPathEnt::GetGripText(i,cs);
	else if(i==m_polyOutline.Length()*2)
		cs=_T("移动屋脊线的起点");
	else if(i==m_polyOutline.Length()*2+1)
		cs=_T("移动屋脊线的终点");
	else
		cs=_T("平移屋脊线");
	return Acad::eOk;
}
Acad::ErrorStatus TDbDualSlopeRoof::subGetGripPoints(AcGePoint3dArray&     gripPoints,
                                         AcDbIntArray&  osnapModes,
                                         AcDbIntArray&  geomIds) const
{
	TDbPolyPathEnt::subGetGripPoints(gripPoints,osnapModes,geomIds);
	for(long i=0;i<gripPoints.length();i++)
	{
		AcGePoint3d pt=gripPoints[i];
		pt.z=0;
		gripPoints.setAt(i,pt);
	}
	gripPoints.append(m_ptRidge1.AsAcGePoint3d());
	gripPoints.append(m_ptRidge2.AsAcGePoint3d());
	gripPoints.append(XCurveSegment(m_ptRidge1,m_ptRidge2,0).MidPoint().AsAcGePoint3d());
	return Acad::eOk;
}
Acad::ErrorStatus TDbDualSlopeRoof::subMoveGripPointsAt(const AcDbIntArray& indices,
                 const AcGeVector3d& offset)
{
	assertWriteEnabled();
	AcDbIntArray indices2;
	for(long i=0;i<indices.length();i++)
	{
		int iGrip=indices[i]-m_polyOutline.Length()*2;
		if(iGrip>=0)
		{
			if(iGrip==0)
				m_ptRidge1+=offset;
			else if(iGrip==1)
				m_ptRidge2+=offset;
			else
			{
				m_ptRidge1+=offset;
				m_ptRidge2+=offset;
			}
		}
		else
			indices2.append(indices[i]);
	}

	AcGeVector3d offset1=offset;
	offset1.z=0;

	//modify by aec on 090310
//	return TDbPolyPathEnt::moveGripPointsAt(indices2,offset1);
	Acad::ErrorStatus es=TDbPolyPathEnt::subMoveGripPointsAt(indices2,offset1);
	if(es==Acad::eOk
		&&IsHeightLim()
		&&GetRoofHeight()>_DIST_SNAP)
	{
		double angLeft(0),angRight(0);
		if(CalAngle(angLeft,angRight))
		{
			m_nAngleLeft=angLeft;
			m_nAngleRight=angRight;
		}
	}
	return es;
}
BOOL TDbDualSlopeRoof::CalAngle(double &angLeft,	//[out]左坡角（弧度）
								double &angRight	//[out]右坡角（弧度）
								)
{
	BOOL bRet=FALSE;
	XLine xLine(GetRidgeStart(),GetRidgeEnd());	
	xLine.SetElevation(0);

	XPoly2D poly;
	GetPolyPath(poly);
	poly.SetElevation(0);

	XPoint pt;
	double dLowLeft = 0.0,dLowRight = 0.0;	//到屋脊线的水平距离
	for (long i = 0;i < poly.Length();i++)	//距脊线的最远点
	{
		pt = *poly[i];
		int nSide=xLine.OnWhichSide(pt);
		double dTemp;
		if (nSide==0)		//左侧
		{
			dTemp = pt.Distance(&xLine);
			if (dLowLeft < dTemp)
			{
				dLowLeft = dTemp;
			}
		}
		else if(nSide==1)	//右侧
		{
			dTemp = pt.Distance(&xLine);
			if (dLowRight < dTemp)
			{
				dLowRight = dTemp;
			}
		}
	}
	if (fabs(dLowLeft-0.0) <= 1E-6
		&&fabs(dLowRight-0.0) <= 1E-6)		//没有左右坡
	{
		return bRet;
	}
	if (fabs(dLowLeft-0.0) <= 1E-6)			//没有左坡
	{
		double dTempLow = 0.0;
		for (long i = 0;i < poly.Length();i++)
		{
			pt = *poly[i];
			double dTemp = pt.Distance(&xLine);
			if (fabs(dTempLow-0.0) <= 1E-6)
			{
				dTempLow = dTemp;
			}
			else if (dTempLow > dTemp)
			{
				dTempLow = dTemp;
			}
		}
		dLowRight = dLowRight - dTempLow;
		if(dLowRight>_DIST_SNAP)
		{
			angLeft=angRight=atan(GetRoofHeight() / dLowRight);
			bRet = TRUE;
		}
	}
	else if(fabs(dLowRight-0.0) <= 1E-6)		//没有右坡
	{
		double dTempLow = 0.0;
		for (long i = 0;i < poly.Length();i++)
		{
			pt = *poly[i];
			double dTemp = pt.Distance(&xLine);
			if (fabs(dTempLow-0.0) <= 1E-6)
			{
				dTempLow = dTemp;
			}
			else if (dTempLow > dTemp)
			{
				dTempLow = dTemp;
			}
		}
		dLowLeft = dLowLeft - dTempLow;
		if(dLowLeft>_DIST_SNAP)
		{
			angLeft=angRight=atan(GetRoofHeight() / dLowLeft);
			bRet = TRUE;
		}
	}
	else										//左右坡都有
	{
		angLeft=atan(GetRoofHeight() / dLowLeft);
		angRight=atan(GetRoofHeight() / dLowRight);
		bRet = TRUE;
	}
	return bRet;
}
Acad::ErrorStatus TDbDualSlopeRoof::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
	Acad::ErrorStatus es=Acad::eOk;
	XPoly2D poly=m_polyOutline;
	poly.SetElevation(0);
	dc<<poly;
	dc.PushClip(poly,XDcClip::kClipOut&&XDcClip::kNoClipEdge);

	XLine line(m_ptRidge1,m_ptRidge2);
	line.SetElevation(0);
	AcDbLine acLine(line.StartPoint(),line.EndPoint());
	AcDbCurve* pCurveOutline=poly.AsAcDbCurve();
	AcGePoint3dArray pts;
	pCurveOutline->intersectWith(&acLine,AcDb::kExtendArg,pts);
	delete pCurveOutline;
	if(pts.length()>1)
	{
		XPoint ptR1=m_ptRidge1;
		XPoint ptR2=m_ptRidge2;
		ptR1.z=ptR2.z=0;
		XPoint vt=ptR2-ptR1;
		vt.Normalize();
		vt.Scale(_AS_SYS_UNIT(1E7));
		PointList ptList(ptR1-vt,ptR2+vt);
		for(long i=0;i<pts.length();i++)
			ptList.Insert(pts[i]);

		if(ptList.Length()>3)
		{
			line.StartPoint()=*ptList[1];
			line.EndPoint()=*ptList[ptList.Length()-2];
			line.SetElevation(0);
			dc<<line;
		}
	}
	dc.PopClip();
	return es;
}
void TDbDualSlopeRoof::Split(DList<XPoly2D>&lstLeft,DList<XPoly2D>&lstRight)const
{
	DList<XCurveSegment> lstCurve;
	XPoint vt=m_ptRidge2-m_ptRidge1;
	vt.Normalize();
	vt.Scale(_AS_SYS_UNIT(5E6));
	XCurveSegment line(m_ptRidge1-vt,m_ptRidge2+vt,0);
	XCurveSegment line1=line.Offset(_AS_SYS_UNIT(-1E6),0),line2=line.Offset(_AS_SYS_UNIT(1E6),0);
	XPoly2D polyLeft(1),polyRight(1);

	polyLeft.AppendNode(line.StartPoint());
	polyLeft.AppendNode(line.EndPoint());
	polyLeft.AppendNode(line1.EndPoint());
	polyLeft.AppendNode(line1.StartPoint());

	polyRight.AppendNode(line.StartPoint());
	polyRight.AppendNode(line.EndPoint());
	polyRight.AppendNode(line2.EndPoint());
	polyRight.AppendNode(line2.StartPoint());

	XPoly2D poly(m_polyOutline);
	poly.SetElevation(0);
	polyLeft.SetElevation(0);
	polyRight.SetElevation(0);
	XSubExport::Intersect(polyLeft,poly,lstLeft);
	XSubExport::Intersect(polyRight,poly,lstRight);
	for(long i=0;i<lstLeft.Length();i++)
	{
		XPoly2D* pPoly=lstLeft[i];
		if(pPoly->PathArea()>0)
			pPoly->Reverse();
	}
	for(i=0;i<lstRight.Length();i++)
	{
		XPoly2D* pPoly=lstRight[i];
		if(pPoly->PathArea()>0)
			pPoly->Reverse();
	}
}
void TDbDualSlopeRoof::GetPlane(XPlane&leftPlane,XPlane&rightPlane)const
{
	XPoint vt=m_ptRidge2-m_ptRidge1;
	vt.Normalize();
	vt.Scale(_AS_SYS_UNIT(5E6));
	XCurveSegment line(m_ptRidge1-vt,m_ptRidge2+vt,0);
	line.SetElevation(0);

	AcGeVector3d vtAxis=(m_ptRidge2-m_ptRidge1).AsAcGeVector3d();
	{
		AcGeVector3d vt(AcGeVector3d::kZAxis);
		vt.rotateBy(-m_nAngleLeft,vtAxis);
		leftPlane=XPlane(XPoint(m_ptRidge1.x,m_ptRidge1.y,GetElevation()),vt);
	}
	{
		AcGeVector3d vt(AcGeVector3d::kZAxis);
		vt.rotateBy(m_nAngleRight,vtAxis);
		rightPlane=XPlane(XPoint(m_ptRidge1.x,m_ptRidge1.y,GetElevation()),vt);
	}
}
Acad::ErrorStatus TDbDualSlopeRoof::ExplodeOrDraw3d(XExplodeDraw &dc) const
{
	Acad::ErrorStatus es=Acad::eOk;

	XPoint vt=m_ptRidge2-m_ptRidge1;
	vt.Normalize();
	vt.Scale(_AS_SYS_UNIT(5E6));
	XCurveSegment line(m_ptRidge1-vt,m_ptRidge2+vt,0);
	line.SetElevation(0);

	DList<XPoly2D> lstLeft,lstRight;
	Split(lstLeft,lstRight);
	AcGeVector3d vtAxis=(m_ptRidge2-m_ptRidge1).AsAcGeVector3d();
	{
		AcGeVector3d vt(AcGeVector3d::kZAxis);
		vt.rotateBy(-m_nAngleLeft,vtAxis);
		XPlane planeLeft(XPoint(m_ptRidge1.x,m_ptRidge1.y,GetElevation()),vt);
		for(long i=0;i<lstLeft.Length();i++)
		{
			XPoly2D* pPoly=lstLeft[i];
			XPoly2D poly1=*pPoly;
			for(long j=0;j<pPoly->Length();j++)
			{
				XPoint *pPt=(*pPoly)[j];
				pPt->z=-1*(planeLeft.GetParaA()*pPt->x+planeLeft.GetParaB()*pPt->y+planeLeft.GetParaD())/planeLeft.GetParaC();
				poly1[j]->z=pPt->z-m_nSlabThick;
			}
			dc.DrawShell(*pPoly);

			for(long k=0;k<poly1.TotalSegments();k++)
			{
				XCurveSegment e0,e1;
				pPoly->Nth(k,e0);
				poly1.Nth(k,e1);
				X3DFace face;
				face.SetFlag(0);
				face.GetVertex(0)=e1.StartPoint();
				face.GetVertex(1)=e1.EndPoint();
				face.GetVertex(2)=e0.EndPoint();
				face.GetVertex(3)=e0.StartPoint();

				e0.SetElevation(0);
				int nRet0=line.HitTest2d(e0.StartPoint());
				int nRet1=line.HitTest2d(e0.EndPoint());
				if(nRet0==1||nRet0==2||nRet1==1||nRet1==2||lstRight.Length()==0)
					dc.DrawFace(face);
			}

			poly1.Reverse();
			dc.DrawShell(poly1);
		}
		
	}
	
	{
		AcGeVector3d vt(AcGeVector3d::kZAxis);
		vt.rotateBy(m_nAngleRight,vtAxis);
		XPlane planeRight(XPoint(m_ptRidge1.x,m_ptRidge1.y,GetElevation()),vt);
		for(long i=0;i<lstRight.Length();i++)
		{
			XPoly2D* pPoly=lstRight[i];
			XPoly2D poly1=*pPoly;
			for(long j=0;j<pPoly->Length();j++)
			{
				XPoint *pPt=(*pPoly)[j];
				pPt->z=-1*(planeRight.GetParaA()*pPt->x+planeRight.GetParaB()*pPt->y+planeRight.GetParaD())/planeRight.GetParaC();
				poly1[j]->z=pPt->z-m_nSlabThick;
			}
			dc.DrawShell(*pPoly);

			for(long k=0;k<poly1.TotalSegments();k++)
			{
				XCurveSegment e0,e1;
				pPoly->Nth(k,e0);
				poly1.Nth(k,e1);
				X3DFace face;
				face.SetFlag(0);
				face.GetVertex(0)=e1.StartPoint();
				face.GetVertex(1)=e1.EndPoint();
				face.GetVertex(2)=e0.EndPoint();
				face.GetVertex(3)=e0.StartPoint();

				e0.SetElevation(0);
				int nRet0=line.HitTest2d(e0.StartPoint());
				int nRet1=line.HitTest2d(e0.EndPoint());
				if(nRet0==1||nRet0==2||nRet1==1||nRet1==2||lstLeft.Length()==0)
					dc.DrawFace(face);
			}	

			poly1.Reverse();
			dc.DrawShell(poly1);
		}
	}
	return es;
}   
void TDbDualSlopeRoof::GetTips(DList<ObjInfoUnit> &lstInfo) const
{
   lstInfo.Append(new ObjInfoUnit(_T("对象类型") ,_T("人字坡顶")));
}
const TCHAR * TDbDualSlopeRoof::GetDefaultLayer() const
{
	return LAY_ROOF;
}

//add by aec on 081223
void TDbDualSlopeRoof::SetHeightLim(Adesk::Boolean bTrue)
{
	assertWriteEnabled();
	m_bHeightLim=bTrue;
}
Adesk::Boolean TDbDualSlopeRoof::IsHeightLim()const
{
	return m_bHeightLim;
}
//add by aec on 090223
void TDbDualSlopeRoof::SetRoofHeight(double h)
{
	assertWriteEnabled();
	m_dHeight=h;
}
double TDbDualSlopeRoof::GetRoofHeight()const
{
	return m_dHeight;
}

// aec add 101119，支持导出XML
CString TDbDualSlopeRoof::GetXml() const
{
	XmlTree xmlTree;
	POSITION posRoot = xmlTree.Insert(_T("AEC_DUALROOF"), 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("Section"), posRoot, posItem1);
	{
		xmlTree.SetAttribute(posItem2, _T("name"), _T("屋面参数"));
		POSITION posItemAng1 = xmlTree.Insert(_T("Ang_1"), posItem2, NULL);
		{
			xmlTree.SetAttribute(posItemAng1, _T("name"), _T("坡角1"));
			strText.Format(_T("%f"), m_nAngleLeft);
			xmlTree.SetItemText(posItemAng1, strText);
		}

		POSITION posItemAng2 = xmlTree.Insert(_T("Ang_2"), posItem2, posItemAng1);
		{
			xmlTree.SetAttribute(posItemAng2, _T("name"), _T("坡角2"));
			strText.Format(_T("%f"), m_nAngleRight);
			xmlTree.SetItemText(posItemAng2, strText);
		}

		POSITION posItemThick = xmlTree.Insert(_T("Thick"), posItem2, posItemAng2);
		{
			xmlTree.SetAttribute(posItemThick, _T("name"), _T("檐板厚"));
			strText.Format(_T("%f"), m_nSlabThick);
			xmlTree.SetItemText(posItemThick, strText);
		}
	}

	POSITION posItem3 = xmlTree.Insert(_T("Ridge_line"), posRoot, posItem2);
	{
		xmlTree.SetAttribute(posItem3, _T("name"), _T("屋脊线"));
		POSITION posItemStartPt = xmlTree.Insert(_T("Start_point"), posItem3, NULL);
		{
			xmlTree.SetAttribute(posItemStartPt, _T("name"), _T("起始点"));
			strText.Format(_T("%f,%f,%f"), m_ptRidge1.x, m_ptRidge1.y, m_ptRidge1.z);
			xmlTree.SetItemText(posItemStartPt, strText);
		}

		POSITION posItemEndPt = xmlTree.Insert(_T("End_point"), posItem3, posItemStartPt);
		{
			xmlTree.SetAttribute(posItemEndPt, _T("name"), _T("结束点"));
			strText.Format(_T("%f,%f,%f"), m_ptRidge2.x, m_ptRidge2.y, m_ptRidge2.z);
			xmlTree.SetItemText(posItemEndPt, strText);
		}
	}

	POSITION posItem4 = xmlTree.Insert(_T("Baseline"), posRoot, posItem3);
	{
		xmlTree.SetAttribute(posItem4, _T("name"), _T("屋顶线参数"));
		xmlTree.SetAttribute(posItem4, _T("comment"), _T("用于屋顶线角点"));

		POSITION posItemPoint = NULL;
		XPoint ptNode;
		for (int i = 0; i < m_polyOutline.Length(); i++)
		{
			ptNode = m_polyOutline[i];
			strText.Format(_T("Point_%d"), i + 1);
			posItemPoint = xmlTree.Insert(strText, posItem4, posItemPoint);
			{
				strText.Format(_T("第%d点"), i + 1);
				xmlTree.SetAttribute(posItemPoint, _T("name"), strText);
				strText.Format(_T("%f,%f,%f"), ptNode.x, ptNode.y, ptNode.z);
				xmlTree.SetItemText(posItemPoint, strText);
			}
		}

	}

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

	return strXml;
}

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



/////////////////////////////////////////////////////////////////////////////////////////////////////////////
const Adesk::UInt8 TDbMountRoof::g_nVersion=1;
ACRX_DXF_DEFINE_MEMBERS(TDbMountRoof,TDbPolyPathEnt, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,  
						1, AEC_MOUNTROOF,"AEC_KERNAL|缺乏图形解释器, 请下载插件");

IMPLEMENT_TENTBASE(TDbMountRoof);

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

	Adesk::UInt8  nVer;
	pFiler->readItem(&nVer);
	if(nVer>g_nVersion) 
		return Acad::eMakeMeProxy;

	es=TRoofBase::Read(pFiler);
	if(es!=Acad::eOk)return es;

	AcGePoint3d pt;
	pFiler->readItem(&pt);
	m_ptLocation=pt;
	pFiler->readItem(&m_nRotation);
	pFiler->readItem(&m_nLength);
	pFiler->readItem(&m_nWidth);
	pFiler->readItem(&m_nSlopeAngle2);

	pFiler->readItem(&m_dEavesLen);
	pFiler->readItem(&m_dMountLen);
	pFiler->readItem(&m_dRoofHeight);
	pFiler->readItem(&m_dMountHeight);
	pFiler->readItem(&m_bShowSide);
	return pFiler->filerStatus();
}

Acad::ErrorStatus TDbMountRoof::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	assertReadEnabled();
	Acad::ErrorStatus es = TDbPolyPathEnt::dwgOutFields(pFiler);
	if(es != Acad::eOk) return es;
		
	pFiler->writeItem(g_nVersion);

	es=TRoofBase::Write(pFiler);
	if(es!=Acad::eOk)return es;

	pFiler->writeItem(m_ptLocation.AsAcGePoint3d());
	pFiler->writeItem(m_nRotation);
	pFiler->writeItem(m_nLength);
	pFiler->writeItem(m_nWidth);
	pFiler->writeItem(m_nSlopeAngle2);
	pFiler->writeItem(m_dEavesLen);
	pFiler->writeItem(m_dMountLen);
	pFiler->writeItem(m_dRoofHeight);
	pFiler->writeItem(m_dMountHeight);
	pFiler->writeItem(m_bShowSide);

	return pFiler->filerStatus();
}

Acad::ErrorStatus TDbMountRoof::subGetClassID(CLSID* pClsid) const
{
	*pClsid=CLSID_ComMountRoof;
	return Acad::eOk;
	return AcDbEntity::subGetClassID(pClsid);
}
Acad::ErrorStatus TDbMountRoof::subTransformBy(const AcGeMatrix3d& xform)
{
	assertWriteEnabled();
	AecEntity::subTransformBy(xform);
	
	XPoint ptX,ptY;
	ads_polar(m_ptLocation, m_nRotation, GetLength(), ptX);
	ads_polar(m_ptLocation, m_nRotation+PI/2.0, GetWidth(), ptY);
	((AcGePoint3d &)ptX).transformBy(xform);
	((AcGePoint3d &)ptY).transformBy(xform);
	((AcGePoint3d &)m_ptLocation).transformBy(xform);
	double nAng = CT_std_angle(ads_angle(m_ptLocation, ptY)-
		ads_angle(m_ptLocation, ptX));
	if(fabs(nAng-PI*1.5)<_angSnap)
	{
		XPrivate::Exchange(m_ptLocation, ptX);
	}

	m_nRotation = ads_angle(m_ptLocation, ptX);

	return Acad::eOk;
}
Acad::ErrorStatus TDbMountRoof::subGetGripPoints(AcGePoint3dArray&     gripPoints,
										AcDbIntArray&  osnapModes,
										AcDbIntArray&  geomIds) const
{
	assertReadEnabled();
	XPoint ptLoc=GetLocation();
//	ptLoc.z=0;

	XPoint ptCenter;
	ads_polar(ptLoc,m_nRotation,0.5*GetLength(),ptCenter);
	ads_polar(ptCenter,m_nRotation+PI*0.5,0.5*GetWidth(),ptCenter);
	gripPoints.append(ptCenter);
	
	gripPoints.append(ptLoc);
	
	XPoint ptFirst;
	ads_polar(ptLoc,m_nRotation,GetLength(),ptFirst);
	gripPoints.append(ptFirst);
	ads_polar(ptFirst,m_nRotation+PI*0.5,GetWidth(),ptFirst);
	gripPoints.append(ptFirst);
	ads_polar(ptLoc,m_nRotation+PI*0.5,GetWidth(),ptFirst);
	gripPoints.append(ptFirst);

	ads_polar(ptLoc,m_nRotation,GetLength()*0.5,ptFirst);
	ads_polar(ptFirst,m_nRotation-PI*0.5,GetEavesLen(),ptFirst);
	gripPoints.append(ptFirst);		//出檐长
	ads_polar(ptFirst,m_nRotation+PI*0.5,GetWidth()+GetEavesLen()*2,ptFirst);
	gripPoints.append(ptFirst);		//出檐长

	ads_polar(ptLoc,m_nRotation+PI*0.5,GetWidth()*0.5,ptFirst);
	ads_polar(ptFirst,m_nRotation+PI,GetMountLen(),ptFirst);
	gripPoints.append(ptFirst);		//出山长
	ads_polar(ptFirst,m_nRotation,GetLength()+GetMountLen()*2,ptFirst);
	gripPoints.append(ptFirst);		//出山长

	XLine leftLine, rightLine, midLine;
	GetMountLine(leftLine,rightLine,midLine);
	midLine.SetElevation(ptLoc.z);
	if (!(GetRoofHeight()-GetMountHeight()<_DIST_SNAP
			||fabs(cos(GetSlopeAngle2()))<1E-3))	//四坡，歇山，攒尖
	{
		if (midLine.GetLength()>_DIST_SNAP)			//四坡，歇山
		{
			gripPoints.append(midLine.StartPoint());	//脊线长
			gripPoints.append(midLine.EndPoint());	//脊线长
		}
	}


	return Acad::eOk;
}
Acad::ErrorStatus TDbMountRoof::subMoveGripPointsAt(const AcDbIntArray& indices,
											const AcGeVector3d& offset)
{
	assertWriteEnabled();
	XPoint vtOffset=*(XPoint *)&offset;
	vtOffset.z = 0;
	
	double nVtRot=CT_std_angle(ads_angle(XPoint(), vtOffset)-m_nRotation);
	double nIncWidth=ads_distance(XPoint(), vtOffset) * cos(nVtRot);
	double nIncLen=ads_distance(XPoint(), vtOffset) * sin(nVtRot);
	int nLen=indices.length();
	for (int i = 0; i < nLen; i++) 
	{
		int idx = indices[i];
		switch(idx) {
		case 0:				
			if(GetCtrlToggle())	//移动
			{
				m_ptLocation += vtOffset;
			}
			else				//旋转
			{
 				XPoint ptCenter=GetLocation();
				ptCenter.z=0;
				ads_polar(ptCenter,m_nRotation,0.5*GetLength(),ptCenter);
 				ads_polar(ptCenter,m_nRotation+PI*0.5,0.5*GetWidth(),ptCenter);

				ads_matrix mat;
				ptCenter.GetRotationMatrix(AcGeVector2d(offset.x,offset.y).angle(),mat);
				subTransformBy(AsAcGeMatrix3d(mat));
			}
			break;
		case 1:				//拉伸
			{
				if (GetRoofHeight()-GetMountHeight()<_DIST_SNAP
						||fabs(cos(GetSlopeAngle2()))<1E-3)		//人字坡
				{
					if(((m_nLength-nIncWidth)>_DIST_SNAP)		//脊线长度>0
						&&(m_nWidth-nIncLen)>_DIST_SNAP)
					{
						m_ptLocation += vtOffset;
						m_nLength -= nIncWidth;
						m_nWidth -= nIncLen;
					}
				}
				else											//四坡,歇山,攒尖
				{
					if (GetTopLength()<_DIST_SNAP				//攒尖
						&&m_nLength-nIncWidth>_DIST_SNAP
						&&m_nWidth-nIncLen>_DIST_SNAP
						)
					{
						m_ptLocation += vtOffset;
						m_nLength -= nIncWidth;
						m_nWidth -= nIncLen;
						m_nSlopeAngle2=atan(GetRoofHeight()*2/GetLength());
					}
					else if((((m_nLength-nIncWidth)*0.5)>(m_dRoofHeight-m_dMountHeight)/tan(GetSlopeAngle2()))		//脊线长度>0
						&&(m_nWidth-nIncLen)>_DIST_SNAP)
					{
						m_ptLocation += vtOffset;
						m_nLength -= nIncWidth;
						m_nWidth -= nIncLen;
					}			
				}
				
			}
			break;
		case 2:				//拉伸
			{
				if (GetRoofHeight()-GetMountHeight()<_DIST_SNAP
					||fabs(cos(GetSlopeAngle2()))<1E-3)		//人字坡
				{
					if(((m_nLength+nIncWidth)>_DIST_SNAP)		//脊线长度>0
						&&(m_nWidth-nIncLen)>_DIST_SNAP)
					{
						ads_polar(m_ptLocation,m_nRotation+PI*0.5,nIncLen,m_ptLocation);
						m_nLength += nIncWidth;
						m_nWidth -= nIncLen;
					}
				}
				else											//四坡，歇山，攒尖
				{
					if (GetTopLength()<_DIST_SNAP				//攒尖
						&&m_nLength+nIncWidth>_DIST_SNAP
						&&m_nWidth-nIncLen>_DIST_SNAP
						)
					{
						ads_polar(m_ptLocation,m_nRotation+PI*0.5,nIncLen,m_ptLocation);
						m_nLength += nIncWidth;
						m_nWidth -= nIncLen;
						m_nSlopeAngle2=atan(GetRoofHeight()*2/GetLength());
					}
					else if((((m_nLength+nIncWidth)*0.5)>(m_dRoofHeight-m_dMountHeight)/tan(GetSlopeAngle2()))		//脊线长度>0
						&&(m_nWidth-nIncLen)>_DIST_SNAP)
					{
						ads_polar(m_ptLocation,m_nRotation+PI*0.5,nIncLen,m_ptLocation);
						m_nLength += nIncWidth;
						m_nWidth -= nIncLen;
					}			
				}
				
			}
			break;
		case 3:				//拉伸
			{
				if (GetRoofHeight()-GetMountHeight()<_DIST_SNAP
					||fabs(cos(GetSlopeAngle2()))<1E-3)		//人字坡
				{
					if(((m_nLength+nIncWidth)>_DIST_SNAP)		//脊线长度>0
						&&(m_nWidth+nIncLen)>_DIST_SNAP)
					{
						m_nLength += nIncWidth;
						m_nWidth += nIncLen;
					}
				}
				else											//四坡，歇山，攒尖
				{
					if (GetTopLength()<_DIST_SNAP				//攒尖
						&&m_nLength+nIncWidth>_DIST_SNAP
						&&m_nWidth+nIncLen>_DIST_SNAP
						)
					{
						m_nLength += nIncWidth;
						m_nWidth += nIncLen;
						m_nSlopeAngle2=atan(GetRoofHeight()*2/GetLength());
					}
					else if((((m_nLength+nIncWidth)*0.5)>(m_dRoofHeight-m_dMountHeight)/tan(GetSlopeAngle2()))		//脊线长度>0
						&&(m_nWidth+nIncLen)>_DIST_SNAP)
					{
						m_nLength += nIncWidth;
						m_nWidth += nIncLen;
					}			
				}
				
			}
			break;
		case 4:				//拉伸
			{
				if (GetRoofHeight()-GetMountHeight()<_DIST_SNAP
					||fabs(cos(GetSlopeAngle2()))<1E-3)		//人字坡
				{
					if(((m_nLength-nIncWidth)>_DIST_SNAP)		//脊线长度>0
						&&(m_nWidth+nIncLen)>_DIST_SNAP)
					{
						ads_polar(m_ptLocation,m_nRotation,nIncWidth,m_ptLocation);
						m_nLength -= nIncWidth;
						m_nWidth += nIncLen;
					}
				}
				else											//四坡，歇山，攒尖
				{
					if (GetTopLength()<_DIST_SNAP				//攒尖
						&&m_nLength-nIncWidth>_DIST_SNAP
						&&m_nWidth+nIncLen>_DIST_SNAP
						)
					{
						ads_polar(m_ptLocation,m_nRotation,nIncWidth,m_ptLocation);
						m_nLength -= nIncWidth;
						m_nWidth += nIncLen;
						m_nSlopeAngle2=atan(GetRoofHeight()*2/GetLength());
					}
					else if((((m_nLength-nIncWidth)*0.5)>(m_dRoofHeight-m_dMountHeight)/tan(GetSlopeAngle2()))		//脊线长度>0
						&&(m_nWidth+nIncLen)>_DIST_SNAP)
					{
						ads_polar(m_ptLocation,m_nRotation,nIncWidth,m_ptLocation);
						m_nLength -= nIncWidth;
						m_nWidth += nIncLen;
					}			
				}
				
			}
			break;
		case 5:				//调整出檐长
		case 6:
			{
				double dIncLen=nIncLen;
				if(idx==6)
					dIncLen=-nIncLen;

				if(m_dEavesLen-dIncLen>_DIST_SNAP)
				{
					m_dEavesLen -= dIncLen;
				}
				else
				{
					m_dEavesLen = 0;
				}
			}

			break;
		case 7:				//调整出山长
		case 8:
			{
				double dIncWidth=nIncWidth;
				if(idx==8)
					dIncWidth=-nIncWidth;
				if (GetRoofHeight()-GetMountHeight()<_DIST_SNAP
					||fabs(cos(GetSlopeAngle2()))<1E-3)		//人字坡
				{
					if(m_dMountLen-dIncWidth>_DIST_SNAP)
					{
						m_dMountLen -= dIncWidth;
					}
					else if(m_dMountLen-dIncWidth<-_DIST_SNAP&&m_dMountLen-dIncWidth>-GetLength()*0.5-_DIST_SNAP)//可能改变为歇山或四坡或攒尖屋顶
					{
						if (GetRoofHeight()-GetMountHeight()<_DIST_SNAP)//仍为人字坡
						{
							m_dMountLen = 0;
						}
						else if (fabs(cos(GetSlopeAngle2()))<1E-3)
						{
							if ((fabs(m_dMountLen-dIncWidth)<_DIST_SNAP&&GetMountHeight()<_DIST_SNAP)	//变为攒尖屋顶
								||(fabs(m_dMountLen-dIncWidth)>_DIST_SNAP)								//变为四坡或歇山屋顶
								)
							{
								m_nSlopeAngle2=atan((GetRoofHeight()-GetMountHeight())*2/fabs(m_dMountLen-dIncWidth));
							}
						}
					}
					else
					{
						m_dMountLen = 0;
					}
				}
				else
				{
					double dLen=dIncWidth*tan(GetSlopeAngle2())/tan(GetSlopeAngle1());
					
					if(m_dEavesLen-dLen>_DIST_SNAP)
					{
						m_dEavesLen -= dLen;
					}
					else
					{
						m_dEavesLen = 0;
					}
				}
				
			}
			break;
		case 9:
		case 10:
			{
				double dIncWidth=nIncWidth;
				if (idx==10)
				{
					dIncWidth=-nIncWidth;
				}
				if (!(GetRoofHeight()-GetMountHeight()<_DIST_SNAP
						||fabs(cos(GetSlopeAngle2()))<1E-3))	//四坡，歇山，攒尖
				{
					XLine leftLine, rightLine, midLine;
					GetMountLine(leftLine,rightLine,midLine);
					midLine.SetElevation(0);
					if (GetMountHeight()<_DIST_SNAP)			//四坡
					{
						if (midLine.GetLength()-dIncWidth*2<_DIST_SNAP)//变为攒尖屋顶
						{
							m_nSlopeAngle2=atan(GetRoofHeight()*2/GetLength());
						}
						else if(midLine.GetLength()-dIncWidth*2>GetLength()-_DIST_SNAP)//变为人字屋顶
						{
							m_nSlopeAngle2=PI*0.5;
							m_dMountLen=0;
						}
						else
						{
							m_nSlopeAngle2=atan(GetRoofHeight()/(0.5*GetLength()-midLine.GetLength()*0.5+dIncWidth));
						}
					}
					else										//歇山
					{
						if (midLine.GetLength()-dIncWidth*2<_DIST_SNAP)//歇山屋顶脊线长为0时不能直接变为攒尖屋顶
						{
							//m_nSlopeAngle2=atan(GetRoofHeight()*2/GetLength());
						}
						else if(midLine.GetLength()-dIncWidth*2>GetLength()-_DIST_SNAP)//变为人字屋顶
						{
							m_nSlopeAngle2=PI*0.5;
							m_dMountLen=0;
						}
						else
						{
							m_nSlopeAngle2=atan((GetRoofHeight()-GetMountHeight())/(0.5*GetLength()-midLine.GetLength()*0.5+dIncWidth));
						}
					}
				}
			}
			break;
		default:
			break;
		}
	}
	return Acad::eOk;
}
Acad::ErrorStatus TDbMountRoof::subGetStretchPoints(AcGePoint3dArray& stretchPoints) const
{
	assertReadEnabled();
	XPoint ptLoc=GetLocation();
	ptLoc.z=0;

	XPoint ptCenter;
	ads_polar(ptLoc,m_nRotation,0.5*GetLength(),ptCenter);
	ads_polar(ptCenter,m_nRotation+PI*0.5,0.5*GetWidth(),ptCenter);
	stretchPoints.append(ptCenter);

	XPoint ptFirst;
	ads_polar(ptLoc,m_nRotation,GetLength()*0.5,ptFirst);
	ads_polar(ptFirst,m_nRotation-PI*0.5,GetEavesLen(),ptFirst);
	stretchPoints.append(ptFirst);		//出檐长
	ads_polar(ptFirst,m_nRotation+PI*0.5,GetWidth()+GetEavesLen()*2,ptFirst);
	stretchPoints.append(ptFirst);		//出檐长

	ads_polar(ptLoc,m_nRotation+PI*0.5,GetWidth()*0.5,ptFirst);
	ads_polar(ptFirst,m_nRotation+PI,GetMountLen(),ptFirst);
	stretchPoints.append(ptFirst);		//出山长
	ads_polar(ptFirst,m_nRotation,GetLength()+GetMountLen()*2,ptFirst);
	stretchPoints.append(ptFirst);		//出山长

	return Acad::eOk;
}
Acad::ErrorStatus TDbMountRoof::subMoveStretchPointsAt(const AcDbIntArray& indices,
									  const AcGeVector3d& offset)
{
	assertWriteEnabled();
	
	XPoint vtOffset=*(XPoint *)&offset;
	vtOffset.z = 0;

	double nVtRot=CT_std_angle(ads_angle(XPoint(), vtOffset)-m_nRotation);
	double nIncWidth=ads_distance(XPoint(), vtOffset) * cos(nVtRot);
	double nIncLen=ads_distance(XPoint(), vtOffset) * sin(nVtRot);

	int nLen=indices.length();
	if(nLen>1)
	{
		m_ptLocation += vtOffset;
	}
	else if(nLen==1)
	{
		int idx=indices[0];
		switch(idx)
		{
		case 1:
			{
				if(m_nWidth-nIncLen>_DIST_SNAP)
				{
					m_nWidth -= nIncLen;
					ads_polar(m_ptLocation,m_nRotation+PI*0.5,nIncLen,m_ptLocation);
				}
			}
			break;
		case 2:
			{
				if(m_nWidth+nIncLen>_DIST_SNAP)
				{
					m_nWidth += nIncLen;
				}
			}
			break;
		case 3:
			{
				if(m_nLength-nIncWidth>_DIST_SNAP)
				{
					if (GetRoofHeight()-GetMountHeight()<_DIST_SNAP
						||fabs(cos(GetSlopeAngle2()))<1E-3)		//人字坡
					{
						m_nLength -= nIncWidth;
						ads_polar(m_ptLocation,m_nRotation,nIncWidth,m_ptLocation);
					}
					else											//四坡，歇山，攒尖
					{
						if (GetTopLength()<_DIST_SNAP				//攒尖
							)
						{
							m_nLength -= nIncWidth;
							m_nSlopeAngle2=atan(GetRoofHeight()*2/GetLength());
							ads_polar(m_ptLocation,m_nRotation,nIncWidth,m_ptLocation);
						}
						else if((((m_nLength-nIncWidth)*0.5)>(m_dRoofHeight-m_dMountHeight)/tan(GetSlopeAngle2()))		//脊线长度>0
							)
						{
							m_nLength -= nIncWidth;
							ads_polar(m_ptLocation,m_nRotation,nIncWidth,m_ptLocation);
						}			
					}
				}
			}
			break;
		case 4:
			if(m_nLength+nIncWidth>_DIST_SNAP)
			{
				if (GetRoofHeight()-GetMountHeight()<_DIST_SNAP
					||fabs(cos(GetSlopeAngle2()))<1E-3)		//人字坡
				{
					m_nLength += nIncWidth;
				}
				else											//四坡，歇山，攒尖
				{
					if (GetTopLength()<_DIST_SNAP				//攒尖
						)
					{
						m_nLength += nIncWidth;
						m_nSlopeAngle2=atan(GetRoofHeight()*2/GetLength());
					}
					else if((((m_nLength+nIncWidth)*0.5)>(m_dRoofHeight-m_dMountHeight)/tan(GetSlopeAngle2()))		//脊线长度>0
						)
					{
						m_nLength += nIncWidth;
					}			
				}
			}
			break;
		default:
			m_ptLocation += vtOffset;
		}

	}
	return Acad::eOk;
}

//////////////////////////////////////////////////////////////////////
//动态输入
#if ADS>15
Acad::ErrorStatus TDbMountRoof::EntityToDim(long iGrip, long iDim, const AcDbEntity *pEnt)
{
	AecDbGripDim *pDim = GetGripDim(iGrip, iDim);
	if (pDim == NULL)
	{
		return Acad::eInvalidInput;
	}

	TDbMountRoof *pRoof = TDbMountRoof::cast(pEnt);
	if (pRoof == NULL)
	{
		pRoof = this;	//动态输入打开，查看夹点时，也显示标注
	}

	if (iGrip>8||iGrip<5)	// 与基类处理相同 
	{
		return Acad::eNotImplementedYet;
	}

	XPoly2D poly;
	pRoof->GetPolyPath(poly);
	poly.SetElevation(0);

	XPoly2D polyIn(1);
	XPoint pt=GetLocation();
	polyIn.AppendNode(pt);			//墙皮左下角点
	ads_polar(pt,m_nRotation,GetLength(),pt);
	polyIn.AppendNode(pt);			//墙皮右下角点
	ads_polar(pt,m_nRotation+PI*0.5,GetWidth(),pt);
	polyIn.AppendNode(pt);			//墙皮右上角点
	ads_polar(pt,m_nRotation+PI,GetLength(),pt);
	polyIn.AppendNode(pt);			//墙皮左上角点

	XPoint ptMidOut,ptNew, ptMidIn;
	int nNum=iGrip-5;
	if(iGrip==6)
	{
		nNum=2;
	}
	else if(iGrip==7)
	{
		nNum=3;
	}
	else if(iGrip==8)
	{
		nNum=1;
	}
	XDirectionCurve cvOut,cvIn;
	poly.Nth(nNum,cvOut);
	ptMidOut=cvOut.MidPoint();

	polyIn.Nth(nNum,cvIn);
	ptMidIn=cvIn.MidPoint();

	double dAngle = 0,dDist=0;
	dAngle = ads_angle(XPoint(), XVector3D(ptMidOut-ptMidIn));
	dDist = ptMidOut.Distance(ptMidIn);
	ads_polar(ptMidIn, dAngle, dDist, ptNew);

	switch(iDim)
	{
	case 0: // 宽度
		{
			AecDbGripDistDim *pDistDim = (AecDbGripDistDim*)pDim;
			pDistDim->SetData(ptMidIn, ptNew, _AS_SYS_UNIT(800));
		}
		return Acad::eNotImplementedYet;
		break;
	default:
		return Acad::eNotImplementedYet;
	}
	return Acad::eOk;
}

Acad::ErrorStatus TDbMountRoof::DimToEntity(long iGrip, long iDim, double newValue, const AcGeVector3d& offset)
{
	assertWriteEnabled();
	if (iGrip>8||iGrip<5)	// 与基类处理相同 
	{
		return Acad::eNotImplementedYet;
	}

	double dNewDist(newValue);
	switch(iDim)
	{
	case 0: // 宽度
		if(dNewDist < 0)
			break;
		if(iGrip==5||iGrip==7)
		{
			m_dEavesLen = dNewDist;
		}
		else
		{
			if (GetRoofHeight()-GetMountHeight()<_DIST_SNAP
				||fabs(cos(GetSlopeAngle2()))<1E-3)		//人字坡
			{
				m_dMountLen = dNewDist;
			}
			else
			{
				m_dEavesLen = dNewDist*tan(GetSlopeAngle2())/tan(GetSlopeAngle1());
			}
		}
		break;
	default:
		return Acad::eNotImplementedYet;
	}

	return Acad::eOk;
}
#endif

void TDbMountRoof::UnionScale(double nScale)
{
	assertWriteEnabled();
	double nOldElev=GetElevation();
	AecEntity::UnionScale(nScale);
	SetElevation(nOldElev*nScale);
	m_nSlabThick*=nScale;			//板厚
	m_nWidth*=nScale;				//屋顶宽
	m_nLength*=nScale;				//屋顶长
	m_dRoofHeight*=nScale;				//高度
	m_dEavesLen*=nScale;			//出檐长
	m_dMountLen*=nScale;			//出山长
	m_dMountHeight*=nScale;			//歇山高
}

BOOL TDbMountRoof::IsValid() const
{
	BOOL bRet=AecEntity::IsValid();
	if(!bRet)
		return bRet;
	bRet=(m_nLength>_DIST_SNAP
		&&m_nWidth>_DIST_SNAP
		&&m_nSlopeAngle2>0
		&&m_nSlopeAngle2<PI*0.5+1E-5
		&&m_dEavesLen>=0
		&&m_dRoofHeight>=m_dMountHeight
		&&m_dMountHeight>=0
		);

	if(!bRet)
		return bRet;

	if (m_dRoofHeight-m_dMountHeight<_DIST_SNAP		//高度设置的人字坡
		||fabs(cos(m_nSlopeAngle2))<1E-3			//转化的人字坡
		)
	{
		return m_dMountLen>=0;						//出山长不为负
	}
	else if (m_dMountHeight<_DIST_SNAP)				//四坡或攒尖屋顶
	{
		return (m_nLength*0.5) - m_dRoofHeight/tan(m_nSlopeAngle2) > -_DIST_SNAP;
	}
	else											//歇山屋顶
	{
		return (m_nLength*0.5)>(m_dRoofHeight-m_dMountHeight)/tan(m_nSlopeAngle2);
	}

	return bRet;
}
bool TDbMountRoof::IsClipMe(const AEntityBase* pEnt)const
{
	return false;
}
void TDbMountRoof::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
{
	assertWriteEnabled();
	TDbPolyPathEnt::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
	TDbMountRoof *pSrc=TDbMountRoof::cast(pSrcEntity);
	if(pSrc) 
	{
		m_nLength		= pSrc->m_nLength;
		m_nWidth		= pSrc->m_nWidth;
		m_dRoofHeight	= pSrc->m_dRoofHeight;
		m_dMountHeight	= pSrc->m_dMountHeight;
		m_dEavesLen		= pSrc->m_dEavesLen;
		m_nSlopeAngle2	= pSrc->m_nSlopeAngle2;
		m_bShowSide		= pSrc->m_bShowSide;
		m_dMountLen		= pSrc->m_dMountLen;
	}
}
void TDbMountRoof::GetTips(DList<ObjInfoUnit> &lstInfo) const
{
	lstInfo.Append(new ObjInfoUnit(_T("对象类型") ,_T("矩形屋顶")));
	if (!(GetRoofHeight()-GetMountHeight()<_DIST_SNAP
		||fabs(cos(GetSlopeAngle2()))<1E-3
		||GetMountHeight()<_DIST_SNAP))					//歇山
	{
		lstInfo.Append(new ObjInfoUnit(_T("歇山高"), Dist2Str(GetMountHeight())));
	}
	lstInfo.Append(new ObjInfoUnit(_T("屋顶高"), Dist2Str(GetRoofHeight())));
	lstInfo.Append(new ObjInfoUnit(_T("出檐长"), Dist2Str(GetEavesLen())));
	lstInfo.Append(new ObjInfoUnit(_T("出山长"), Dist2Str(GetMountLen())));

}
Acad::ErrorStatus TDbMountRoof::GetGripText(int i, CString &cs) const
{
	if(i==0)
		cs=GetCtrlToggle()? _T("移动屋顶0(Ctrl-中心旋转)") : _T("中心旋转0(Ctrl-移动屋顶)");
	else if(i==1||i==2||i==3||i==4)
	{
		cs=_T("调整屋顶大小");
	}
	else if(i==5||i==6||i==7||i==8)
	{
		cs=_T("调整出檐长和出山长");
	}
	else
	{
		cs=_T("调整脊线长");
	}
	return Acad::eOk;
}
const TCHAR *TDbMountRoof::GetDefaultLayer() const
{
	return LAY_ROOF;
}

Acad::ErrorStatus TDbMountRoof::ExplodeOrDraw3d(XExplodeDraw &dc) const
{
	if(GetLength()<_DIST_SNAP
		||GetWidth()<_DIST_SNAP
		)
		return Acad::eOk;

	XPoly2D poly;
	GetPolyPath(poly);

	XLine leftLine, rightLine, midLine;
	GetMountLine(leftLine,rightLine,midLine);
	
	XLine midLine0;
	midLine0=midLine;
	midLine0.StartPoint().z+=m_nSlabThick;
	midLine0.EndPoint().z+=m_nSlabThick;

	if (GetRoofHeight()-GetMountHeight()<_DIST_SNAP
		||fabs(cos(GetSlopeAngle2()))<1E-3
		||GetMountHeight()<_DIST_SNAP)		//人字屋顶,四坡屋顶,攒尖屋顶
	{
		if (poly.Length()!=4)
		   return Acad::eOk;

		XCurveSegment e0,e1;
		poly.Nth(0,e0);
		e1=e0;
		e1.StartPoint().z+=m_nSlabThick;
		e1.EndPoint().z+=m_nSlabThick;
		
		//前后檐屋顶面
		X3DFace face;
		face.SetFlag(0);
		face.GetVertex(0)=midLine.EndPoint();
		face.GetVertex(1)=e0.EndPoint();
		face.GetVertex(2)=e0.StartPoint();
		face.GetVertex(3)=midLine.StartPoint();
		dc.DrawFace(face);			//主坡内面
		
		face.GetVertex(0)=midLine0.StartPoint();
		face.GetVertex(1)=e1.StartPoint();
		face.GetVertex(2)=e1.EndPoint();
		face.GetVertex(3)=midLine0.EndPoint();
		dc.DrawFace(face);			//主坡外面
		
		face.GetVertex(0)=e0.StartPoint();
		face.GetVertex(1)=e0.EndPoint();
		face.GetVertex(2)=e1.EndPoint();
		face.GetVertex(3)=e1.StartPoint();
		dc.DrawFace(face);			//主坡立面	
		
		
		poly.Nth(2,e0);
		e1=e0;
		e1.StartPoint().z+=m_nSlabThick;
		e1.EndPoint().z+=m_nSlabThick;
		
		face.GetVertex(0)=midLine.StartPoint();
		face.GetVertex(1)=e0.EndPoint();
		face.GetVertex(2)=e0.StartPoint();
		face.GetVertex(3)=midLine.EndPoint();
		dc.DrawFace(face);			//主坡内面
		
		face.GetVertex(0)=midLine0.EndPoint();
		face.GetVertex(1)=e1.StartPoint();
		face.GetVertex(2)=e1.EndPoint();
		face.GetVertex(3)=midLine0.StartPoint();
		dc.DrawFace(face);			//主坡外面

		face.GetVertex(0)=e0.StartPoint();
		face.GetVertex(1)=e0.EndPoint();
		face.GetVertex(2)=e1.EndPoint();
		face.GetVertex(3)=e1.StartPoint();
		dc.DrawFace(face);			//主坡立面	

		//山墙屋顶面
		if (GetRoofHeight()-GetMountHeight()<_DIST_SNAP
			||fabs(cos(GetSlopeAngle2()))<1E-3)	//人字屋顶
		{
			if (IsShowSide())		//显示侧坡
			{
				poly.Nth(1,e0);	
				e1=e0;
				e1.StartPoint().z+=m_nSlabThick;
				e1.EndPoint().z+=m_nSlabThick;
				
				X3DFace face1;
				face1.SetFlag(0);
				face1.GetVertex(0)=midLine0.EndPoint();
				face1.GetVertex(1)=e1.StartPoint();
				face1.GetVertex(2)=e1.EndPoint();
				face1.GetVertex(3)=midLine0.EndPoint();
				dc.DrawFace(face1);	//侧坡面
				
				face1.GetVertex(0)=e1.StartPoint();
				face1.GetVertex(1)=e0.StartPoint();
				face1.GetVertex(2)=e0.EndPoint();
				face1.GetVertex(3)=e1.EndPoint();
				dc.DrawFace(face1);	//侧坡立面
				
				poly.Nth(3,e0);	
				e1=e0;
				e1.StartPoint().z+=m_nSlabThick;
				e1.EndPoint().z+=m_nSlabThick;
				
				face1.GetVertex(0)=midLine0.StartPoint();
				face1.GetVertex(1)=e1.StartPoint();
				face1.GetVertex(2)=e1.EndPoint();
				face1.GetVertex(3)=midLine0.StartPoint();
				dc.DrawFace(face1);	//侧坡面
				
				face1.GetVertex(0)=e1.StartPoint();
				face1.GetVertex(1)=e0.StartPoint();
				face1.GetVertex(2)=e0.EndPoint();
				face1.GetVertex(3)=e1.EndPoint();
				dc.DrawFace(face1);	//侧坡立面
			}
		}
		else						//四坡屋顶，攒尖屋顶
		{
			poly.Nth(1,e0);	
			e1=e0;
			e1.StartPoint().z+=m_nSlabThick;
			e1.EndPoint().z+=m_nSlabThick;
			
			X3DFace face1;
			face1.SetFlag(0);
			face1.GetVertex(0)=midLine0.EndPoint();
			face1.GetVertex(1)=e1.StartPoint();
			face1.GetVertex(2)=e1.EndPoint();
			face1.GetVertex(3)=midLine0.EndPoint();
			dc.DrawFace(face1);	//侧坡外面
			
			face1.GetVertex(0)=midLine.EndPoint();
			face1.GetVertex(1)=e0.EndPoint();
			face1.GetVertex(2)=e0.StartPoint();
			face1.GetVertex(3)=midLine.EndPoint();
			dc.DrawFace(face1);	//侧坡内面
			
			face1.GetVertex(0)=e1.StartPoint();
			face1.GetVertex(1)=e0.StartPoint();
			face1.GetVertex(2)=e0.EndPoint();
			face1.GetVertex(3)=e1.EndPoint();
			dc.DrawFace(face1);	//侧坡立面
			
			poly.Nth(3,e0);	
			e1=e0;
			e1.StartPoint().z+=m_nSlabThick;
			e1.EndPoint().z+=m_nSlabThick;
			
			face1.GetVertex(0)=midLine0.StartPoint();
			face1.GetVertex(1)=e1.StartPoint();
			face1.GetVertex(2)=e1.EndPoint();
			face1.GetVertex(3)=midLine0.StartPoint();
			dc.DrawFace(face1);	//侧坡外面
			
			face1.GetVertex(0)=midLine.StartPoint();
			face1.GetVertex(1)=e0.EndPoint();
			face1.GetVertex(2)=e0.StartPoint();
			face1.GetVertex(3)=midLine.StartPoint();
			dc.DrawFace(face1);	//侧坡内面
			
			face1.GetVertex(0)=e1.StartPoint();
			face1.GetVertex(1)=e0.StartPoint();
			face1.GetVertex(2)=e0.EndPoint();
			face1.GetVertex(3)=e1.EndPoint();
			dc.DrawFace(face1);	//侧坡立面
		}
	}
	else							//歇山屋顶
	{
		XPoly2D poly0(1);
		poly0.AppendNode(leftLine.StartPoint());
		poly0.AppendNode(rightLine.StartPoint());
		poly0.AppendNode(rightLine.EndPoint());
		poly0.AppendNode(leftLine.EndPoint());

		for(int i=0;i<poly.TotalSegments();i++)
		{
			XCurveSegment e0,e1,e2,e3;
			poly.Nth(i,e0);
			e1=e0;
			e1.StartPoint().z+=m_nSlabThick;
			e1.EndPoint().z+=m_nSlabThick;
			poly0.Nth(i,e2);
			e3=e2;
			e3.StartPoint().z+=m_nSlabThick;
			e3.EndPoint().z+=m_nSlabThick;
			

			X3DFace face;
			face.SetFlag(0);
			face.GetVertex(0)=e0.StartPoint();
			face.GetVertex(1)=e0.EndPoint();
			face.GetVertex(2)=e1.EndPoint();
			face.GetVertex(3)=e1.StartPoint();
			dc.DrawFace(face);		//立面		

			face.GetVertex(0)=e2.EndPoint();
			face.GetVertex(1)=e0.EndPoint();
			face.GetVertex(2)=e0.StartPoint();
			face.GetVertex(3)=e2.StartPoint();
			if(i%2==0)
				face.SetVisible(3,FALSE);
			dc.DrawFace(face);		//坡内面

			face.GetVertex(0)=e3.StartPoint();
			face.GetVertex(1)=e1.StartPoint();
			face.GetVertex(2)=e1.EndPoint();
			face.GetVertex(3)=e3.EndPoint();
			if(i%2==0)
				face.SetVisible(3,FALSE);
			dc.DrawFace(face);		//坡外面
		}
		
		if(midLine.GetLength()>_DIST_SNAP&&poly0.TotalSegments()==4)
		{
			XCurveSegment e0,e1;
			poly0.Nth(0,e0);
			e1=e0;
			e1.StartPoint().z+=m_nSlabThick;
			e1.EndPoint().z+=m_nSlabThick;

			X3DFace face;
			face.SetFlag(0);
			face.GetVertex(0)=e0.StartPoint();
			face.GetVertex(1)=midLine.StartPoint();
			face.GetVertex(2)=midLine.EndPoint();
			face.GetVertex(3)=e0.EndPoint();
			face.SetVisible(3,FALSE);
			dc.DrawFace(face);		//坡内面

			X3DFace face1;
			face1.SetFlag(0);
			face1.GetVertex(0)=e1.StartPoint();
			face1.GetVertex(1)=e1.EndPoint();
			face1.GetVertex(2)=midLine0.EndPoint();
			face1.GetVertex(3)=midLine0.StartPoint();
			face1.SetVisible(0,FALSE);
			dc.DrawFace(face1);		//坡外面

			poly0.Nth(2,e0);
			e1=e0;
			e1.StartPoint().z+=m_nSlabThick;
			e1.EndPoint().z+=m_nSlabThick;

			X3DFace face2;
			face2.SetFlag(0);
			face2.GetVertex(0)=e0.StartPoint();
			face2.GetVertex(1)=midLine.EndPoint();
			face2.GetVertex(2)=midLine.StartPoint();
			face2.GetVertex(3)=e0.EndPoint();
			face2.SetVisible(3,FALSE);
			dc.DrawFace(face2);		//坡内面

			X3DFace face3;
			face3.SetFlag(0);
			face3.GetVertex(0)=e1.StartPoint();
			face3.GetVertex(1)=e1.EndPoint();
			face3.GetVertex(2)=midLine0.StartPoint();
			face3.GetVertex(3)=midLine0.EndPoint();
			face3.SetVisible(0,FALSE);
			dc.DrawFace(face3);		//坡外面

			poly0.Nth(1,e0);
			e1=e0;
			e1.StartPoint().z+=m_nSlabThick;
			e1.EndPoint().z+=m_nSlabThick;

			X3DFace face4;
			face4.SetFlag(0);
			face4.GetVertex(0)=midLine0.EndPoint();
			face4.GetVertex(1)=e1.StartPoint();
			face4.GetVertex(2)=e1.EndPoint();
			face4.GetVertex(3)=midLine0.EndPoint();
			dc.DrawFace(face4);		//山头面

			poly0.Nth(3,e0);
			e1=e0;
			e1.StartPoint().z+=m_nSlabThick;
			e1.EndPoint().z+=m_nSlabThick;

			face4.GetVertex(0)=midLine0.StartPoint();
			face4.GetVertex(1)=e1.StartPoint();
			face4.GetVertex(2)=e1.EndPoint();
			face4.GetVertex(3)=midLine0.StartPoint();
			dc.DrawFace(face4);		//山头面
		}
	}

	return Acad::eOk;
}
Acad::ErrorStatus TDbMountRoof::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
	if(GetLength()<_DIST_SNAP
		||GetWidth()<_DIST_SNAP
		)
		return Acad::eOk;
	XPoly2D poly;
	GetPolyPath(poly);
	poly.SetElevation(0);
	dc<<poly;

	XLine leftLine, rightLine, midLine;
	GetMountLine(leftLine,rightLine,midLine);
	midLine.SetElevation(0);
	if(midLine.GetLength()>_DIST_SNAP)
		dc<<midLine;

	if (GetRoofHeight()-GetMountHeight()<_DIST_SNAP
		||fabs(cos(GetSlopeAngle2()))<1E-3)		//人字屋顶
	{
		return Acad::eOk;
	}
	else if (GetMountHeight()<_DIST_SNAP)		//四坡屋顶或攒尖屋顶			
	{
		if(poly.Length()==4)
		{
			dc<<XLine(midLine.StartPoint(),*poly[0]);
			dc<<XLine(midLine.EndPoint(),*poly[1]);
			dc<<XLine(midLine.EndPoint(),*poly[2]);
			dc<<XLine(midLine.StartPoint(),*poly[3]);
		}
		return Acad::eOk;
	}
	else										//歇山屋顶
	{
		leftLine.SetElevation(0);
		if(leftLine.GetLength()>_DIST_SNAP)
			dc<<XLine(leftLine.StartPoint(),leftLine.EndPoint());
		rightLine.SetElevation(0);
		if(rightLine.GetLength()>_DIST_SNAP)
			dc<<rightLine;
		if(poly.Length()==4)
		{
			dc<<XLine(leftLine.StartPoint(),*poly[0]);
			dc<<XLine(leftLine.EndPoint(),*poly[3]);
			dc<<XLine(rightLine.StartPoint(),*poly[1]);
			dc<<XLine(rightLine.EndPoint(),*poly[2]);
		}
	}

	return Acad::eOk;
}
void TDbMountRoof::GetMountLine(XLine &leftLine,XLine &rightLine,XLine &midLine)const
{
	XPoint pt=GetLocation();
	//modify by aec on 090713 调整基点标高
	//pt.z+=GetRoofHeight();
	pt.z+=(GetRoofHeight()-m_nSlabThick);

	if (GetRoofHeight()-GetMountHeight()<_DIST_SNAP||fabs(cos(GetSlopeAngle2()))<1E-3)//人字屋顶
	{
		ads_polar(pt,m_nRotation+PI*0.5,GetWidth()*0.5,pt);
		ads_polar(pt,m_nRotation+PI,GetMountLen(),pt);
		midLine.StartPoint() = pt;		//屋脊线起点
		ads_polar(pt,m_nRotation,GetTopLength(),pt);
		midLine.EndPoint() = pt;			//屋脊线终点

	}
	else if (GetMountHeight()<_DIST_SNAP)		//四坡屋顶或攒尖屋顶			
	{
		double dDist=GetRoofHeight()/tan(GetSlopeAngle2());//侧坡在平面上的间距
		ads_polar(pt,m_nRotation+PI*0.5,GetWidth()*0.5,pt);
		ads_polar(pt,m_nRotation,dDist,pt);
		midLine.StartPoint() = pt;		//屋脊线起点
		ads_polar(pt,m_nRotation,GetTopLength(),pt);
		midLine.EndPoint() = pt;			//屋脊线终点		
	}
	else										//歇山屋顶
	{
		double dWidth=GetMountHeight()/tan(GetSlopeAngle1());//歇山半宽
		double dDist=(GetRoofHeight()-GetMountHeight())/tan(GetSlopeAngle2());//侧坡在平面上的间距
	
		pt.z-=GetMountHeight();
		
		ads_polar(pt,m_nRotation,dDist,pt);
		ads_polar(pt,m_nRotation+PI*0.5,GetWidth()*0.5-dWidth,pt);
		leftLine.StartPoint() = pt;		//歇山左下角点
		
		ads_polar(pt,m_nRotation+PI*0.5,dWidth*2,pt);
		leftLine.EndPoint() = pt;			//歇山左上角点
		
		ads_polar(leftLine.StartPoint(),m_nRotation,GetLength()-dDist*2,pt);
		rightLine.StartPoint() = pt;		//歇山右下角点
		
		ads_polar(leftLine.EndPoint(),m_nRotation,GetLength()-dDist*2,pt);
		rightLine.EndPoint() = pt;		//歇山右上角点
		
		Midpoint(leftLine.StartPoint(),leftLine.EndPoint(),pt);
		pt.z=GetLocation().z+GetRoofHeight()-m_nSlabThick;
		midLine.StartPoint() = pt;		//屋脊线起点
		
		ads_polar(pt,m_nRotation,GetLength()-dDist*2,pt);
		midLine.EndPoint() = pt;			//屋脊线终点
	}
}
void TDbMountRoof::GetPolyPath(XPoly2D& poly)const
{
	poly.SetFlag(1);
	poly.Reset();
	
	double dHeight=0;//屋檐产生的高差
	dHeight=GetEavesLen()*tan(GetSlopeAngle1());

	XPoint pt=GetLocation();
	//modify by aec on 090713 调整基点标高
	//pt.z -= dHeight;
	pt.z -= (dHeight+m_nSlabThick);

	ads_polar(pt,m_nRotation+PI,GetMountLen(),pt);
	ads_polar(pt,m_nRotation-PI*0.5,GetEavesLen(),pt);
	poly.AppendNode(pt);			//屋顶左下角点

	ads_polar(pt,m_nRotation,GetMountLen()*2+GetLength(),pt);
	poly.AppendNode(pt);			//屋顶右下角点

	ads_polar(pt,m_nRotation+PI*0.5,GetEavesLen()*2+GetWidth(),pt);
	poly.AppendNode(pt);			//屋顶右上角点

	ads_polar(pt,m_nRotation+PI,GetMountLen()*2+GetLength(),pt);
	poly.AppendNode(pt);			//屋顶左上角点
}

Acad::ErrorStatus TDbMountRoof::GetPathPoly(XPoly2D &polyPath,AcGeVector3d&normal) const 
{
	assertReadEnabled();
	normal=AcGeVector3d::kZAxis;
	GetPolyPath(polyPath);
	return Acad::eOk;
}

XPoint TDbMountRoof::GetLocation()const
{
	assertReadEnabled();
	return m_ptLocation;
}
void TDbMountRoof::SetLocation(const XPoint &pt)
{
	assertWriteEnabled();
	m_ptLocation=pt;
}
double TDbMountRoof::GetRotation()const
{
	assertReadEnabled();
	return m_nRotation;
}
void TDbMountRoof::SetRotation(double d)
{
	assertWriteEnabled();
	m_nRotation=d;
}
double TDbMountRoof::GetEavesLen()const
{	
	assertReadEnabled();
	return m_dEavesLen;
}
void TDbMountRoof::SetEavesLen(double d)
{
	assertWriteEnabled();
	m_dEavesLen=d;
}
double TDbMountRoof::GetMountLen()const
{
	assertReadEnabled();
	
	double dMountLen=0;
	if (GetRoofHeight()-GetMountHeight()<_DIST_SNAP||fabs(cos(GetSlopeAngle2()))<1E-3)//人字坡
	{
		return m_dMountLen;
	}
	else
	{
		dMountLen=GetEavesLen()*tan(GetSlopeAngle1())/tan(GetSlopeAngle2());
	}
	return dMountLen;
}
void TDbMountRoof::SetMountLen(double d)//出山长
{
	assertWriteEnabled();
	m_dMountLen=d;
}
double TDbMountRoof::GetLength()const
{
	assertReadEnabled();
	return m_nLength;
}
void TDbMountRoof::SetLength(double d)
{
	assertWriteEnabled();
	if(d>_DIST_SNAP)
		m_nLength=d;
}
double TDbMountRoof::GetWidth()const
{
	assertReadEnabled();
	return m_nWidth;
}
void TDbMountRoof::SetWidth(double d)
{
	assertWriteEnabled();
	if(d>_DIST_SNAP)
		m_nWidth=d;
}
double TDbMountRoof::GetSlopeAngle1()const
{
	assertReadEnabled();
	double nSlopeAngle1=PI/6.0;
	if(GetWidth()>_DIST_SNAP)
	{
		nSlopeAngle1=atan(GetRoofHeight()*2/GetWidth());
	}
	return nSlopeAngle1;
}
void TDbMountRoof::SetSlopeAngle1(double d)
{
	assertWriteEnabled();
	if(d>0)
		m_nSlopeAngle1=d;
}
double TDbMountRoof::GetSlopeAngle2()const
{
	assertReadEnabled();
	return m_nSlopeAngle2;
}
void TDbMountRoof::SetSlopeAngle2(double d)
{
	assertWriteEnabled();
	if(d>0)
		m_nSlopeAngle2=d;
}
double TDbMountRoof::GetMountHeight()const
{
	assertReadEnabled();
	return m_dMountHeight;
}
void TDbMountRoof::SetMountHeight(double d)
{
	assertWriteEnabled();
	m_dMountHeight=d;
}
double TDbMountRoof::GetRoofHeight()const
{
	assertReadEnabled();
	return m_dRoofHeight;
}
void TDbMountRoof::SetRoofHeight(double d)
{
	assertWriteEnabled();
	m_dRoofHeight=d;
}

double TDbMountRoof::GetTopLength()const
{
	assertReadEnabled();
	double dTopLength=0;
	if (GetRoofHeight()-GetMountHeight()<_DIST_SNAP||fabs(cos(GetSlopeAngle2()))<1E-3)//人字坡
	{
		dTopLength=GetMountLen()*2+GetLength();
	}
	else
	{
		double dDist=(GetRoofHeight()-GetMountHeight())/tan(GetSlopeAngle2());//侧坡在平面上的间距
		if (GetLength()-dDist*2>_DIST_SNAP)			//歇山屋顶,四坡屋顶
		{
			dTopLength=GetLength()-dDist*2;
		}
	}

	return dTopLength;
}

void TDbMountRoof::SetShowSide(Adesk::Boolean bTrue)
{
	assertWriteEnabled();
	m_bShowSide=bTrue;
}
Adesk::Boolean TDbMountRoof::IsShowSide()const
{
	return m_bShowSide;
}

 // aec add 100722，支持统一标高
bool TDbMountRoof::UnifyElevation(double dElevation)
{
	SetElevation(dElevation);
	return true;
}

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



/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//1:AEC7;2:AEC8
const Adesk::UInt8 TDbCuspRoof::g_nVersion=2;
ACRX_DXF_DEFINE_MEMBERS(TDbCuspRoof,TDbPolyPathEnt, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,  
						1, AEC_CUSPROOF,"AEC_KERNAL|缺乏图形解释器, 请下载插件");

IMPLEMENT_TENTBASE(TDbCuspRoof);


void TDbCuspRoof::GetPolyPath(XPoly2D& poly)const
{
	poly.SetFlag(1);
	poly.Reset();
	double nAngle=PI*2.0/m_nSideNum;
	
	//add by aec on 090225
	if(GetRadius()<_DIST_SNAP || m_nSideNum < 2)
		return;

	//add by aec on 081223
	double dEaves=GetEavesLen()/cos(PI/GetSideNum());
	XPoint ptCenter=m_ptCenter;
	ptCenter.z-=((GetHeight()-m_nSlabThick)*GetEavesLen()/(GetRadius()*cos(PI/GetSideNum()))+m_nSlabThick);
	
	for(long i=0;i<m_nSideNum;i++)
	{
		XPoint pt;
		ads_polar(ptCenter,m_nRotation+i*nAngle,m_nRadius+dEaves,pt);
		poly.AppendNode(pt);
	}
}
Acad::ErrorStatus TDbCuspRoof::GetPathPoly(XPoly2D &polyPath,AcGeVector3d&normal) const 
{
	assertReadEnabled();
	normal=AcGeVector3d::kZAxis;
	GetPolyPath(polyPath);
	return Acad::eOk;
}
BOOL TDbCuspRoof::IsValid()const
{
	if(!TDbPolyPathEnt::IsValid())
		return FALSE;

	return m_nSideNum>2&&m_nRadius>1E-6;
}
bool TDbCuspRoof::IsClipMe(const AEntityBase* pEnt)const
{
	return false;
}
void TDbCuspRoof::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
{
    assertWriteEnabled();
    TDbPolyPathEnt::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
    TDbCuspRoof *pSrc=TDbCuspRoof::cast(pSrcEntity);
    if(pSrc) {
    }
}
Acad::ErrorStatus TDbCuspRoof::subGetClassID(CLSID* pClsid) const
{
	*pClsid=CLSID_ComCuspRoof;
	return Acad::eOk; 
	return AcDbEntity::subGetClassID(pClsid);
}
// 从DWG读入数据:
Acad::ErrorStatus TDbCuspRoof::dwgInFields (AcDbDwgFiler* pFiler)
{
	assertWriteEnabled();
	Acad::ErrorStatus es = TDbPolyPathEnt::dwgInFields(pFiler);
	if(es != Acad::eOk)
		return es;

	Adesk::UInt8  nVer;
	pFiler->readItem(&nVer);
	if(nVer>g_nVersion) 
		return Acad::eMakeMeProxy;

	es=TRoofBase::Read(pFiler);
	if(es!=Acad::eOk)return es;

	AcGePoint3d pt;
	pFiler->readItem(&pt);
	m_ptCenter=pt;
	pFiler->readItem(&m_nRotation);
	pFiler->readItem(&m_nHeight);
	pFiler->readItem(&m_nRadius);
	pFiler->readItem(&m_nSideNum);

	//add by aec on 081223
	if(nVer>1)
	{
		pFiler->readItem(&m_dEavesLen);
	}
	else
	{
		//modify by aec on 090721 屋顶高为到基点的高度
		//m_nHeight += m_nSlabThick;

		//del by aec on 090713调整标高，与日照0出檐长时一致 
		//m_ptCenter.z -= m_nSlabThick;
		m_dEavesLen = 0;
	}

	return pFiler->filerStatus();
}

Acad::ErrorStatus TDbCuspRoof::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	assertReadEnabled();
	Acad::ErrorStatus es = TDbPolyPathEnt::dwgOutFields(pFiler);
	if(es != Acad::eOk) return es;
	
	if(g_nSaveTArchVer<8)
		pFiler->writeItem((Adesk::UInt8)1);
	else
		pFiler->writeItem(g_nVersion);

	es=TRoofBase::Write(pFiler);
	if(es!=Acad::eOk)return es;

	if(g_nSaveTArchVer<8)
	{
		//modify by aec on 090721 屋顶高为到基点的高度
		//double dHeight = m_nHeight-m_nSlabThick;//出檐长产生的高差
		double dHeight = m_nHeight;//出檐长产生的高差

		dHeight=dHeight*m_dEavesLen/(m_nRadius*cos(PI/m_nSideNum));

		double nRadius = m_nRadius+(m_dEavesLen/cos(PI/m_nSideNum));
		double nHeight=m_nHeight +dHeight/*-m_nSlabThick*/;
		XPoint ptCenter=m_ptCenter;
		ptCenter.z-=(dHeight/*-m_nSlabThick*/);
		
		pFiler->writeItem(ptCenter.AsAcGePoint3d());
		pFiler->writeItem(m_nRotation);
		pFiler->writeItem(nHeight);
		pFiler->writeItem(nRadius);
		pFiler->writeItem(m_nSideNum);
	}
	else
	{
		pFiler->writeItem(m_ptCenter.AsAcGePoint3d());
		pFiler->writeItem(m_nRotation);
		pFiler->writeItem(m_nHeight);
		pFiler->writeItem(m_nRadius);
		pFiler->writeItem(m_nSideNum);
		pFiler->writeItem(m_dEavesLen);
	}


	return pFiler->filerStatus();
}
Acad::ErrorStatus TDbCuspRoof::dxfInFields (AcDbDxfFiler* pFiler)
{
    assertWriteEnabled();

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

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

    return pFiler->filerStatus();
}

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

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

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

   return es;
}
Acad::ErrorStatus TDbCuspRoof::subTransformBy(const AcGeMatrix3d& xform)
{
    assertWriteEnabled();
	AecEntity::subTransformBy(xform);
	m_ptCenter.TransformBy(xform);
	AcGeVector3d vt(cos(m_nRotation),sin(m_nRotation),0);
	vt.transformBy(xform);
	AcGeVector2d vt2d(vt.x,vt.y);
	m_nRotation=vt2d.angle();
    return Acad::eOk;
}
void TDbCuspRoof::UnionScale(double nScale)
{
	assertWriteEnabled();
	double nOldElev=GetElevation();
	AecEntity::UnionScale(nScale);
	SetElevation(nOldElev*nScale);
	m_nSlabThick*=nScale;//板厚
	m_nRidgeWidth*=nScale;
	m_nRidgeHeight*=nScale;//屋脊大小
	m_nHeight*=nScale;//高度
	m_nRadius*=nScale;//半径
	m_dEavesLen*=nScale;//出檐长 add by fxj 090916
}
Acad::ErrorStatus TDbCuspRoof::GetGripText(int i, CString &cs) const
{
	if(i==0)
		cs=_T("移动");
	else if(i==1)
		cs=_T("调整半径和角度");
	else
		cs=_T("调整出檐长");

	return Acad::eOk;
}
Acad::ErrorStatus TDbCuspRoof::subGetGripPoints(AcGePoint3dArray&     gripPoints,
                                         AcDbIntArray&  osnapModes,
                                         AcDbIntArray&  geomIds) const
{
	gripPoints.append(m_ptCenter);
	XPoint ptFirst;
	ads_polar(m_ptCenter,m_nRotation,m_nRadius,ptFirst);
	gripPoints.append(ptFirst);

	//add by aec on 081224
	ads_polar(m_ptCenter,m_nRotation+PI/m_nSideNum,m_nRadius*cos(PI/m_nSideNum)+m_dEavesLen,ptFirst);
	gripPoints.append(ptFirst);		//出檐长

	return Acad::eOk;
}
Acad::ErrorStatus TDbCuspRoof::subMoveGripPointsAt(const AcDbIntArray& indices,
                 const AcGeVector3d& offset)
{
	assertWriteEnabled();
	for(long i=0;i<indices.length();i++)
	{
		int iGrip=indices[i];
		if(iGrip==0)
			m_ptCenter+=offset;
		else if(iGrip==1)
		{
			AcGeVector2d vt0(m_nRadius*cos(m_nRotation),m_nRadius*sin(m_nRotation));
			AcGeVector2d vt=vt0+AcGeVector2d(offset.x,offset.y);
			m_nRadius=vt.length();
			m_nRotation=vt.angle();
		}

		//add by aec on 081224
		else
		{
			XPoint vtOffset=*(XPoint *)&offset;
			vtOffset.z = 0;
			double nVtRot=CT_std_angle(ads_angle(XPoint(), vtOffset)-(m_nRotation+PI/m_nSideNum));
			double nIncWidth=ads_distance(XPoint(), vtOffset) * cos(nVtRot);

			if(m_dEavesLen+nIncWidth>_DIST_SNAP)
			{
				m_dEavesLen+=nIncWidth;
			}
			else if(fabs(m_dEavesLen+nIncWidth)<_DIST_SNAP)
			{
				m_dEavesLen = 0;
			}

		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus TDbCuspRoof::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
	Acad::ErrorStatus es=Acad::eOk;
	XPoly2D poly;
	GetPolyPath(poly);
	poly.SetElevation(0);
	dc<<poly;
	for(long i=0;i<poly.Length();i++)
	{
		XPoint  ptCenter=m_ptCenter;
		ptCenter.z=0;
		dc<<XLine(ptCenter,*poly[i]);
	}
	return es;
}
Acad::ErrorStatus TDbCuspRoof::ExplodeOrDraw3d(XExplodeDraw &dc) const
{
	Acad::ErrorStatus es=Acad::eOk;
	XPoly2D poly;
	GetPolyPath(poly);

//	for(long i=0;i<poly.Length();i++)
//		poly[i]->z-=m_nSlabThick;

	XPoint ptTop=m_ptCenter,ptTop1=m_ptCenter;
	ptTop.z+=m_nHeight-m_nSlabThick;		//下
	ptTop1.z+=m_nHeight/*-m_nSlabThick*/;					//上
	for(long i=0;i<poly.TotalSegments();i++)
	{
		XCurveSegment e0,e1;
		poly.Nth(i,e0);
		e1=e0;
		e1.StartPoint().z+=m_nSlabThick;
		e1.EndPoint().z+=m_nSlabThick;
		X3DFace face;
		face.SetFlag(0);
		face.GetVertex(0)=e0.StartPoint();
		face.GetVertex(1)=e0.EndPoint();
		face.GetVertex(2)=e1.EndPoint();
		face.GetVertex(3)=e1.StartPoint();
		dc.DrawFace(face);

		face.GetVertex(0)=ptTop;
		face.GetVertex(1)=e0.EndPoint();
		face.GetVertex(2)=e0.StartPoint();
		face.GetVertex(3)=ptTop;
		dc.DrawFace(face);

		face.GetVertex(0)=ptTop1;
		face.GetVertex(1)=e1.StartPoint();
		face.GetVertex(2)=e1.EndPoint();
		face.GetVertex(3)=ptTop1;
		dc.DrawFace(face);
	}
	return es;
}   
void TDbCuspRoof::GetTips(DList<ObjInfoUnit> &lstInfo) const
{
   lstInfo.Append(new ObjInfoUnit(_T("对象类型") ,_T("攒尖屋顶")));
}
const TCHAR * TDbCuspRoof::GetDefaultLayer() const
{
	return LAY_ROOF;
}

//add by aec on 081223
double TDbCuspRoof::GetEavesLen()const
{	
	assertReadEnabled();
	return m_dEavesLen;
}
void TDbCuspRoof::SetEavesLen(double d)
{
	assertWriteEnabled();
	m_dEavesLen=d;
}

//动态输入
#if ADS>15
Acad::ErrorStatus TDbCuspRoof::EntityToDim(long iGrip, long iDim, const AcDbEntity *pEnt)
{
	AecDbGripDim *pDim = GetGripDim(iGrip, iDim);
	if (pDim == NULL)
	{
		return Acad::eInvalidInput;
	}

	TDbCuspRoof *pRoof = TDbCuspRoof::cast(pEnt);
	if (pRoof == NULL)
	{
		pRoof = this;	//动态输入打开，查看夹点时，也显示标注
	}

	if (iGrip!=2)	// 与基类处理相同 
	{
		return Acad::eNotImplementedYet;
	}

	XPoly2D poly;
	pRoof->GetPolyPath(poly);
	poly.SetElevation(0);

	XPoly2D polyIn(1);
	XPoint ptCenter=m_ptCenter;
	double nAngle=PI*2.0/m_nSideNum;
	for(long i=0;i<m_nSideNum;i++)
	{
		XPoint pt;
		ads_polar(ptCenter,m_nRotation+i*nAngle,m_nRadius,pt);
		polyIn.AppendNode(pt);
	}

	XPoint ptMidOut,ptNew, ptMidIn;
	int nNum=iGrip-2;
	XDirectionCurve cvOut,cvIn;
	poly.Nth(nNum,cvOut);
	ptMidOut=cvOut.MidPoint();

	polyIn.Nth(nNum,cvIn);
	ptMidIn=cvIn.MidPoint();

	double dAngle = 0,dDist=0;
	dAngle = ads_angle(XPoint(), XVector3D(ptMidOut-ptMidIn));
	dDist = ptMidOut.Distance(ptMidIn);
	ads_polar(ptMidIn, dAngle, dDist, ptNew);

	switch(iDim)
	{
	case 0: // 宽度
		{
			AecDbGripDistDim *pDistDim = (AecDbGripDistDim*)pDim;
			pDistDim->SetData(ptMidIn, ptNew, _AS_SYS_UNIT(800));
		}
		return Acad::eNotImplementedYet;
		break;
	default:
		return Acad::eNotImplementedYet;
	}
	return Acad::eOk;
}

Acad::ErrorStatus TDbCuspRoof::DimToEntity(long iGrip, long iDim, double newValue, const AcGeVector3d& offset)
{
	assertWriteEnabled();
	if (iGrip!=2)	// 与基类处理相同 
	{
		return Acad::eNotImplementedYet;
	}

	double dNewDist(newValue);
	switch(iDim)
	{
	case 0: // 宽度
		if(dNewDist < 0)
			break;
		m_dEavesLen = dNewDist;
		break;
	default:
		return Acad::eNotImplementedYet;
	}

	return Acad::eOk;
}
#endif

// aec add 101115，支持统一标高
bool TDbCuspRoof::UnifyElevation(double dElevation)
{
    assertWriteEnabled();
    SetElevation(dElevation);
	return true;
}

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