#include "stdafx.h"
#include "TDbColumn.h"


/////////////////////////////////////////////////////////////
// 屋顶对象类
/////////////////////////////////////////////////////////////

const Adesk::UInt8 TDbStep::g_nVersion = 1;


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

IMPLEMENT_TENTBASE(TDbStep);

TDbStep::TDbStep()
:m_polyOutline(1), m_nStepFlag(0) 
{
    m_nStepWidth=m_nStepHeight=0;
    m_nStepNum=0;
}


TDbStep::~TDbStep()
{
}

BOOL TDbStep::IsValid() const
{
    BOOL bRet=TDbEntity::IsValid();
    if(!bRet)
        return bRet;
    bRet=(m_polyOutline.Length()>1 &&
          //m_nStepNum>1 && //踏步数目
          m_nStepNum>0 && //踏步数目,refreshed by whl on 060209
          //m_nStepHeight>_DIST_SNAP &&
          //m_nStepWidth>_DIST_SNAP); //踏步高和踏步宽

          fabs(m_nStepHeight)>_DIST_SNAP &&//refreshed by whl on 051214
          fabs(m_nStepWidth)>_DIST_SNAP); //踏步高和踏步宽
    return bRet;
}

Acad::ErrorStatus 
TDbStep::audit(AcDbAuditInfo* pAuditInfo)
{
    Acad::ErrorStatus es = Acad::eOk;
	// sg add 090806，解决高版本下修复02图纸，对象丢失的问题
	es = TDbEntity::audit(pAuditInfo);
	if (es != Acad::eOk)
		return es;

    if (m_polyOutline.PathArea() >= 0.0) {
        pAuditInfo->errorsFound(1);
        if (pAuditInfo->fixErrors() == Adesk::kTrue) {
            pAuditInfo->printError(_T("柱子"), _T("轮廓"), _T("必须为逆时针"), _T(""));
            if(m_polyOutline.PathArea()>0) {
                m_polyOutline.Reverse();
                int nEdgeNum=GetEdgeNum();
                DList<int> lstEdgeFlag;
                for(int n=0; n<nEdgeNum; n++) 
                    lstEdgeFlag.Append(new int(HasStepAt(n)));
                lstEdgeFlag.Reverse();
                for(n=0; n<nEdgeNum; n++) 
                    SetStepAt(n, *lstEdgeFlag[n]);
            }
            pAuditInfo->errorsFixed(1);
            es = Acad::eFixedAllErrors;
        } else
            es = Acad::eLeftErrorsUnfixed;
    } 
    return es;
}




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

// 提供对格式刷的支持
void TDbStep::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
{
    assertWriteEnabled();
    TDbEntity::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
    TDbStep *pSrc=TDbStep::cast(pSrcEntity);
    if(pSrc) {
        m_nStepNum=pSrc->m_nStepNum; //踏步数目
        m_nStepHeight=pSrc->m_nStepHeight;
        m_nStepWidth=pSrc->m_nStepWidth; //踏步高和踏步宽
    }
}


Acad::ErrorStatus TDbStep::SetPathPoly(const XPoly2D &polyPath,const AcGeVector3d&normal) 
{
    assertWriteEnabled();
    m_polyOutline=polyPath;
	return Acad::eOk;
}
Acad::ErrorStatus TDbStep::GetPathPoly(XPoly2D &polyPath,AcGeVector3d&normal) const 
{
	assertReadEnabled();
    polyPath=m_polyOutline;
	normal=AcGeVector3d::kZAxis;
	return Acad::eOk;
}
// 从DWG读入数据:
Acad::ErrorStatus TDbStep::dwgInFields (AcDbDwgFiler* pFiler)
{
   assertWriteEnabled();

   Acad::ErrorStatus es = TDbEntity::dwgInFields(pFiler);
   if(es != Acad::eOk) return es;
   Adesk::UInt8  nVer;
   pFiler->readItem(&nVer);
   if(nVer>g_nVersion) {// Version is too new
       return Acad::eMakeMeProxy;
   }

   pFiler->readItem(&m_nStepFlag);

   double nElev=0.0;
   pFiler->readItem(&nElev);
   ReadPoly2D(pFiler, m_polyOutline);
   m_polyOutline.SetElevation(nElev);

   pFiler->readItem(&m_nStepNum);
   pFiler->readItem(&m_nStepWidth);
   pFiler->readItem(&m_nStepHeight);


   return pFiler->filerStatus();
}

Acad::ErrorStatus TDbStep::dwgOutFields(AcDbDwgFiler* pFiler) const
{
   assertReadEnabled();
   Acad::ErrorStatus es = TDbEntity::dwgOutFields(pFiler);
   if(es != Acad::eOk) return es;

   pFiler->writeItem(g_nVersion);
   pFiler->writeItem(m_nStepFlag);

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

   pFiler->writeItem(m_nStepNum);
   pFiler->writeItem(m_nStepWidth);
   pFiler->writeItem(m_nStepHeight);

   return pFiler->filerStatus();
}

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

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

    if (!pFiler->atSubclassData(_T("TDbStep"))) {
        return Acad::eBadDxfSequence;
    }
    double r1, r2, r3, nAng;
	int nFlag;
	Adesk::UInt32 nFlag32;
	XPoint pt;
    Adesk::UInt32 fieldsFlags = 0;
	resbuf rb;
	DList<AcDbSoftPointerId> lstIds;
	AcDbObjectId id;
	DList<XPoint> pts;
	DList<double> bulges;
    while ((es == Acad::eOk)
        && ((es = pFiler->readResBuf(&rb)) == Acad::eOk))    {
        switch (rb.restype) {
        case 148:
            r1=rb.resval.rreal;
            fieldsFlags |= 0x01;
            break;
        case AcDb::kDxfReal:
            fieldsFlags |= 0x02;
            r2 = rb.resval.rreal;
            break;    
        case AcDb::kDxfReal+1:
            fieldsFlags |= 0x04;
            r3 = rb.resval.rreal;
            break;    
        case AcDb::kDxfInt16:
            fieldsFlags |= 0x08; 
			nFlag=rb.resval.rint;
            break;    
        case AcDb::kDxfInt32:
            nFlag32=rb.resval.rlong;
			fieldsFlags |= 0x10;
            break;    
		case AcDb::kDxfAngle:
			nAng=rb.resval.rreal;
			bulges.Append(new double(nAng));
			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 (!(fieldsFlags & 0x02)) {
        pFiler->setError(Acad::eMissingDxfField,
            _T("\nMissing DXF group code: 40"));
        return Acad::eMissingDxfField;
	}
    if (!(fieldsFlags & 0x04)) {
        pFiler->setError(Acad::eMissingDxfField,
            _T("\nMissing DXF group code: 41"));
        return Acad::eMissingDxfField;
	}
    if (!(fieldsFlags & 0x08)) {
        pFiler->setError(Acad::eMissingDxfField,
            _T("\nMissing DXF group code: 70"));
        return Acad::eMissingDxfField;
	}

    if (pts.Length()<2 || pts.Length()!=bulges.Length()) {
        pFiler->setError(Acad::eMissingDxfField,
            _T("\nError DXF group code: 10, 50"));
        return Acad::eMissingDxfField;
	}
	double nElev=0.0;
	if(fieldsFlags&0x01)
        nElev=r1;
	SetStepHeight(r2);
	SetStepWidth(r2);
	SetStepNum(nFlag);
	if(fieldsFlags&0x10)
		m_nStepFlag=nFlag;

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

Acad::ErrorStatus TDbStep::dxfOutFields(AcDbDxfFiler* pFiler) const
{
    assertReadEnabled();
   Acad::ErrorStatus es= TDbEntity::dxfOutFields(pFiler);
   assert(es == Acad::eOk);

   es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbStep"));
   assert(es == Acad::eOk);
   pFiler->writeDouble(148, GetElevation());
   pFiler->writeDouble(AcDb::kDxfReal, GetStepHeight());
   pFiler->writeDouble(AcDb::kDxfReal+1, GetStepWidth());
   pFiler->writeInt16(AcDb::kDxfInt16, GetStepNum());
   pFiler->writeInt32(AcDb::kDxfInt32, m_nStepFlag);
   for(int i=0; i<m_polyOutline.Length(); i++) {
	   pFiler->writePoint2d(AcDb::kDxfXCoord, m_polyOutline[i].AsAcGePoint2d());
	   pFiler->writeDouble(AcDb::kDxfAngle, m_polyOutline.GetBulge(i));
   }
   return es;
}


// -----------------------------------------------------------------------
// Overriden functions for edit
// to do:
// 允许通过夹点改变边界
Acad::ErrorStatus TDbStep::subGetGripPoints(AcGePoint3dArray&  gripPoints,
                                             AcDbIntArray&  osnapModes,
                                             AcDbIntArray&  geomIds) const
{
    int nEdgeNum=GetEdgeNum();
    for(int i=0; i<nEdgeNum; i++) {
        gripPoints.append(m_polyOutline[i]);
    }
    //边上的夹点
    for(i=0; i<nEdgeNum; i++) {
        XCurveSegment edge;
        m_polyOutline.Nth(i, edge);
        XPoint ptMid=edge.MidPoint();
        gripPoints.append(ptMid);
    }
   
   return Acad::eOk;
}

// stretch points is diffrent from grep points, with no midpoint included
Acad::ErrorStatus  TDbStep::subGetStretchPoints(AcGePoint3dArray & stretchPoints) const
{
    for(int i=0; i<m_polyOutline.Length(); i++) {
        stretchPoints.append(m_polyOutline[i]);
    }
    return Acad::eOk;
}



// Active when being rotated, scaled, moved, etc.
Acad::ErrorStatus TDbStep::subTransformBy(const AcGeMatrix3d& xform)
{
    assertWriteEnabled();
	TDbEntity::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;
        }
    }
    // Add on 2002/1/30 解决弧段镜像后的问题
    if(IsMirrorMatrix(mat)) {
        for(int m=0; m<m_polyOutline.Length(); m++)
            m_polyOutline.SetBulge(m, -m_polyOutline.GetBulge(m));
    }
    if(m_polyOutline.PathArea()>0) {
        m_polyOutline.Reverse();
        int nEdgeNum=GetEdgeNum();
        DList<int> lstEdgeFlag;
        for(int n=0; n<nEdgeNum; n++) 
            lstEdgeFlag.Append(new int(HasStepAt(n)));
        lstEdgeFlag.Reverse();
        for(n=0; n<nEdgeNum; n++) 
            SetStepAt(n, *lstEdgeFlag[n]);
    }

    return Acad::eOk;
}

// 功能: 夹点操作
Acad::ErrorStatus TDbStep::subMoveGripPointsAt(
    const AcDbIntArray& indices,
    const AcGeVector3d& offset)
{
    assertWriteEnabled();
    XPoly2D polyBack(m_polyOutline);

    XPoint vtOffset=*(XPoint *)&offset;
    vtOffset.z=0;
    int nTotalEdge=GetEdgeNum();
    for (int i = 0; i < indices.length(); i++) {
        int idx = indices[i];
        ASSERT(idx<2*nTotalEdge);
        if(idx<nTotalEdge) {
            *m_polyOutline[idx] += vtOffset;
        } else {
            int nEdgeIndex=idx-nTotalEdge;
            ASSERT(nEdgeIndex<nTotalEdge);

            XDirectionCurve cv;
            m_polyOutline.Nth(nEdgeIndex, cv);
            ASSERT(!!cv);
            if(cv.Is(CURVE_LINE)) { // Move
                XLine ln=cv.GetLine();
                ln.StartPoint() += vtOffset;
                ln.EndPoint() += vtOffset;
                ln.SetLineFlag(LS_INFINITE);
                XDirectionCurve prevSeg, nextSeg;
                int nPrev=nEdgeIndex-1, nNext=nEdgeIndex+1;
                nPrev=DePeriod(nTotalEdge, nPrev);
                nNext=DePeriod(nTotalEdge, nNext);

                XPoint ptStart, ptEnd;
                BOOL bUpdateIt=TRUE;
                //更新起点
                if(nPrev>=0 && nPrev<nTotalEdge) { 
                    m_polyOutline.Nth(nPrev, prevSeg);
                    prevSeg.SetLineFlag(LS_INFINITE);
                    XPoint ptInt[2];
                    int nIntNum=prevSeg.Intersection(ln, ptInt[0], ptInt[1]);
                    if(nIntNum==1) ptStart=ptInt[0];
                    else if(nIntNum==2) {
                        ptStart=XLine(ptInt[0], ptInt[1]).NearPoint(ln.StartPoint());
                    } else bUpdateIt=FALSE;
                } else {
                    ptStart = *m_polyOutline[nEdgeIndex] + vtOffset;
                }

                // 更新下一点
                if(nNext>=0 && nNext<nTotalEdge) { 
                    m_polyOutline.Nth(nNext, nextSeg);
                    nextSeg.SetLineFlag(LS_INFINITE);
                    XPoint ptInt[2];
                    int nIntNum=nextSeg.Intersection(ln, ptInt[0], ptInt[1]);
                    if(nIntNum==1) ptEnd=ptInt[0];
                    else if(nIntNum==2) {
                        ptEnd=XLine(ptInt[0], ptInt[1]).NearPoint(ln.EndPoint());
                    } else bUpdateIt=FALSE;
                } else {
                    ptEnd = *m_polyOutline[nEdgeIndex+1] + vtOffset;
                }

                if(bUpdateIt) {
                    double nPrevBulge=0.0, nNextBulge=0.0;
                    if(fabs(prevSeg.GetBulge())>1.0E-5) {
                        XArc prevArc=prevSeg.GetArc();
                        double nAngBeg=ads_angle(prevArc.GetCenterPt(), prevSeg.StartPoint());
                        double nAngEnd=ads_angle(prevArc.GetCenterPt(), ptStart);
                        if(prevSeg.IsMinusArc()) {
                            nPrevBulge=-CT_std_angle(nAngBeg-nAngEnd);
                        } else {
                            nPrevBulge=CT_std_angle(nAngEnd-nAngBeg);
                        }
                    }
                    if(fabs(nextSeg.GetBulge())>1.0E-5) {
                        XArc nextArc=nextSeg.GetArc();
                        double nAngBeg=ads_angle(nextArc.GetCenterPt(), ptEnd);
                        double nAngEnd=ads_angle(nextArc.GetCenterPt(), nextSeg.EndPoint());
                        if(nextSeg.IsMinusArc()) {
                            nNextBulge=-CT_std_angle(nAngBeg-nAngEnd);
                        } else {
                            nNextBulge=CT_std_angle(nAngEnd-nAngBeg);
                        }
                    }

                    *m_polyOutline[nEdgeIndex] = ptStart;
                    if(nNext>=0 && nNext<m_polyOutline.Length()) {
                        *m_polyOutline[nNext] = ptEnd;
                        m_polyOutline.SetBulge(nNext, nNextBulge);
                    }
                    if(nPrev>=0 && nPrev<m_polyOutline.Length())
                        m_polyOutline.SetBulge(nPrev, nPrevBulge);
                    
                }
            
            } else { // Change Arc Segment--bulge
                XPoint ptMid=cv.MidPoint();
                XPoint ptMidNew= ptMid + vtOffset;
                XArc arNew(cv.StartPoint(), ptMidNew, cv.EndPoint());
                if(!!arNew) { //新的弧有效
                    XCurveSegment cvLine(cv.StartPoint(), cv.EndPoint(), 0.0);
                    int nSideOld=cvLine.OnWhichSide(ptMid);
                    int nSideNew=cvLine.OnWhichSide(ptMidNew);
                    double nSignal=cv.GetBulge()/fabs(cv.GetBulge());
                    if(nSideOld==nSideNew) 
					{
                        m_polyOutline.SetBulge(nEdgeIndex, nSignal*arNew.Bulge());
                    }
					else 
					{
                        m_polyOutline.SetBulge(nEdgeIndex, -nSignal*arNew.Bulge());
                    }
                }
            }

        }
    }
    Acad::ErrorStatus es = Acad::eOk;
    if(m_polyOutline.IsSelfIntersect()) {
        m_polyOutline=polyBack;
        es = Acad::eInvalidInput;
    }
    return es;
}

// 取得夹点说明
Acad::ErrorStatus TDbStep::GetGripText(int i, CString &cs) const
{
    Acad::ErrorStatus es=Acad::eOk;
    XString sInfo;
    if(i<GetEdgeNum()) {
        sInfo << _T("移动第") << (i+1) <<  _T("个顶点");
    } else {
        sInfo << _T("移动第") << (i-GetEdgeNum()+1) <<  _T("条边");
    }
    cs = sInfo;
    return es;
}
#if ADS>15
void TDbStep::CreateGrip()
{
	TDbEntity::CreateGrip();
	::CreateGrip(this,m_polyOutline,0);
}
Acad::ErrorStatus TDbStep::EntityToDim(long iGrip,long iDim,const AcDbEntity*pEnt)
{
	TEntityBase *pCurve=TDbStep::cast(pEnt);
	if(pCurve==NULL)
		pCurve=this;
	XPoly2D polyPath;
	AcGeVector3d normal;
	pCurve->GetPathPoly(polyPath,normal);
	return ::EntityToDim(this,polyPath,iGrip,iDim,0);
}

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

	TDbStep curve;
	curve.CopyPropertiesFrom(this,0);

	Acad::ErrorStatus es=::DimToEntity(this,m_polyOutline,iGrip,iDim,newValue,offset,0);
	if(es==Acad::eOk&&!IsValid())
	{
		CopyPropertiesFrom(&curve,0);
		return Acad::eInvalidInput;
	}

	return es;
}
#endif 
// 功能: 夹点操作
// 状态: 有待完成修改相关墙体门窗的操作
Acad::ErrorStatus TDbStep::subMoveStretchPointsAt(
    const AcDbIntArray& indices,
    const AcGeVector3d& offset)
{
    int nCount=indices.length();
    return subMoveGripPointsAt(indices, offset);
}





Acad::ErrorStatus
TDbStep::ExplodeOrDraw3d(XExplodeDraw &dc) const
{
    assertReadEnabled();
    XPoly2D polyCur(1);
    polyCur=m_polyOutline;

	//modified by whl on 070213,支持下沉
	//if(m_nStepWidth>0)
    if((m_nStepWidth>0&&m_nStepHeight>0)||
		(m_nStepWidth<0&&m_nStepHeight<0)||
		(m_nStepWidth>0&&m_nStepHeight<0))
	{//绘制平台
        dc.DrawShell(polyCur, DList<XPoly2D> ());
    }

    // 绘制踏步
    for(int i=0; i<m_nStepNum; i++) 
	{
        // 垂直方向的侧面
        XPoly poly;
        polyCur.AsOpenPoly1(poly, _AS_SYS_UNIT(g_nCirDeviation)); //变成开口的poly, 如果原先封闭, 则起点复制为终点
        int nColumn=poly.Length(); //+1;
        int nRow=2;
        XPoint *ptArray=new XPoint[nColumn*nRow];
        for(int m=0; m<nRow; m++)
		{
           for(int n=0; n<nColumn; n++)
		   {
               int nBase=m*nColumn;
               ptArray[nBase+n]=*poly[n];
               if(m==1) 
                   ptArray[nBase+n].z -= m_nStepHeight;
           }
        }
        int nEdgeNum=nRow*(nColumn-1)+nColumn*(nRow-1);
        Adesk::UInt8 *pEdgeVisArray=new Adesk::UInt8[nEdgeNum];
        for(int j=0; j<nEdgeNum; j++)
            pEdgeVisArray[j]=kAcGiVisible; //kAcGiInvisible;

        if(m_nStepWidth<0 && i==0) 
		{//没有绘制顶平台
            // 第一行的边应当可见
            for(j=0; j<nColumn-1; j++)
                pEdgeVisArray[j]=kAcGiVisible;
        }
        if(i==m_nStepNum-1 &&  m_nStepWidth>0) 
		{
            for(j=nColumn-1; j<2*(nColumn-1); j++)
                pEdgeVisArray[j]=kAcGiVisible;
        }

        // 拐点处的边应当可见
        j=nRow*(nColumn-1);
        for(int kk=0; kk<nColumn; j++, kk++)
		{
            XPoint ptVert=ptArray[kk];
            BOOL bOnNode=FALSE;
            for(int mm=0; mm<polyCur.Length(); mm++) 
			{
                if(polyCur[mm]->Distance(ptVert)<_DIST_SNAP) 
				{
                    bOnNode=TRUE;
                    break;
                }
            }
            if(bOnNode)
                pEdgeVisArray[j]=kAcGiVisible;
        }


        AcGiEdgeData edgeData;
        edgeData.setVisibility(pEdgeVisArray);
        dc.DrawMesh(nRow, nColumn, (AcGePoint3d *)ptArray, &edgeData);
        delete []pEdgeVisArray;
        delete []ptArray;


        double nNewElev=polyCur[0]->z-m_nStepHeight;
        polyCur.SetElevation(nNewElev);
        if(i!=m_nStepNum-1) { //绘制平的部分
            XPoly2D polyNext(1);
            if(!Offset(polyCur, polyNext))
                break;
            if(m_nStepFlag==0) 
			{ //所有边都有台阶
                DList<XPoly2D> lstPolys;
                if(m_nStepWidth>0) 
				{ 
                    lstPolys.Append(new XPoly2D(polyCur));
                    dc.DrawShell(polyNext, lstPolys);
                } else {
                    lstPolys.Append(new XPoly2D(polyNext));
                    dc.DrawShell(polyCur, lstPolys);
                }
            } 
			else 
			{
                DList<XPoly2D> lstPolys;
                if(m_nStepWidth>0)
					TchSubExport::Subtract(polyNext, polyCur, lstPolys);
                else
                    TchSubExport::Subtract(polyCur, polyNext, lstPolys);
                for(int ii=0; ii<lstPolys.Length(); ii++) 
				{
                    XPoly2D &rPoly=*lstPolys[ii];
                    //rPoly.SetElevation(nNewElev);
                    dc.DrawShell(rPoly, DList<XPoly2D>());
                }
            }

            polyCur=polyNext;
        }
        if(i==m_nStepNum-1 ) 
		{
			//add by whl on 070213,支持下沉
			if((m_nStepWidth>0&&m_nStepHeight>0)||
				(m_nStepWidth<0&&m_nStepHeight<0)||
				(m_nStepWidth<0&&m_nStepHeight>0))
				dc.DrawShell(polyCur, DList<XPoly2D>());
        }
    }
    return Acad::eOk;
}
Acad::ErrorStatus TDbStep::GetClipBoundary(XPoly2D& poly)const
{
	return GetOutline2d(poly);
}
bool TDbStep::IsClipMe(const TEntityBase* pEnt)const
{
	if(TDbEntity::IsClipMe(pEnt))
		return true;

	if(pEnt->GetMe()->isKindOf(TDbColumn::desc()))
		return true;

	return false;
}
Acad::ErrorStatus
TDbStep::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
    assertReadEnabled();
    XPoly2D polyCur(1);
    polyCur=m_polyOutline;
    polyCur.SetElevation(0.0);


    XCurveStream dcCurve;

    // 绘制踏步
    for(int i=0; i<m_nStepNum; i++) {
        // 垂直方向的侧面 
        for(int n=0; n<polyCur.TotalSegments(); n++) {
            if(!HasStepAt(n))
                continue;
            XCurveSegment seg;
            polyCur.Nth(n, seg);
            dcCurve << seg;
        }

        XPoly2D polyNext(1); 
        if(!Offset(polyCur, polyNext))
            break;
        polyCur=polyNext;
    }

    XPoly2D polyOutline(1);
    GetOutline2d(polyOutline);
    AcDbObjectId idOwner=ownerId();
    AcDbObjectIdArray railArray;
    if(!!objectId() && !!polyOutline && !!idOwner && TDbHandRail::GetRailsByCP(polyOutline, idOwner, railArray)) {
        int nCount=railArray.length();
        for(int cnt=0; cnt<nCount; cnt++) {
            AcDbObjectId idRail=railArray[cnt];
            OPENOBJ_BEGIN(idRail, AcDb::kForRead, TDbHandRail, pRail);
            if(pRail)
                pRail->ClipCurveByTrace(dcCurve.m_lstCurves);
            OPENOBJ_END();
        }
    }
    dcCurve.CopyTo(dc);

    return Acad::eOk;
}





const TCHAR *TDbStep::GetDefaultLayer() const
{
    return LAY_STAIR;
}



/* * * * * * * * * * 取 动 态 属 性 显 示 数 据 的 函 数 * * * * * * * * * */
void TDbStep::GetTips(DList<TObjInfoUnit> &lstInfo) const
{
   lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("台阶")));
   lstInfo.Append(new TObjInfoUnit(_T("踏步宽度"), Dist2Str(fabs(GetStepWidth()))));
   lstInfo.Append(new TObjInfoUnit(_T("踏步高度"), Dist2Str(fabs(GetStepHeight()))));
   lstInfo.Append(new TObjInfoUnit(_T("踏步数目"), XString(_T("%d"), int(GetStepNum()))));
   lstInfo.Append(new TObjInfoUnit(_T("台阶总高"), Dist2Str(fabs(GetTotalHeight()))));
   lstInfo.Append(new TObjInfoUnit(_T("平台高度"), Dist2Str(GetElevation())));
   lstInfo.Append(new TObjInfoUnit(_T("基面位置"), (GetStepWidth()>0 && GetStepHeight()>0.0)?
       _T("在顶部") : _T("在底部")));

}


int
TDbStep::GetEdgeNum() const
{
    return m_polyOutline.TotalSegments();
}

BOOL
TDbStep::HasStepAt(int idx) const
{
    ASSERT(idx<GetEdgeNum());
    int nTestBit=0x01;
    nTestBit <<= idx;
    return ((m_nStepFlag&nTestBit)==0);
}

double
TDbStep::GetOffsetDist(int idx) const
{
    double nDist= HasStepAt(idx)? m_nStepWidth : 0.0;
    return nDist;
}


BOOL
TDbStep::Offset(const XPoly2D &src, XPoly2D &dest) const
{
    int nTotalSeg=src.TotalSegments();
    ASSERT(nTotalSeg==GetEdgeNum());
    dest.Reset();
    dest.SetFlag(1);

    XDirectionCurve finalMidSeg, lastSeg;
    src.Nth(nTotalSeg-1, finalMidSeg);
    if(!finalMidSeg && fabs(src.GetBulge(nTotalSeg-1))<1.0E-6) {
        // 2001/8/20, 有可能出现长度为0的边
        XCurveSegment lnTemp;
        m_polyOutline.Nth(nTotalSeg-1, lnTemp);
        XLine ln1(src[nTotalSeg-1], ads_angle(lnTemp.StartPoint(), lnTemp.EndPoint()));
        (XLine &)finalMidSeg=ln1;
    }
    lastSeg = finalMidSeg.Offset(GetOffsetDist(nTotalSeg-1), LS_INFINITE);
    if(!lastSeg)
       return FALSE;

   XPoint nextPt;
   for(int i=0; i<nTotalSeg; i++) {
      XDirectionCurve curMidSeg;
      src.Nth(i, curMidSeg);
        if(!curMidSeg && fabs(src.GetBulge(i))<1.0E-6) {
            // 2001/8/20, 有可能出现长度为0的边
            XCurveSegment lnTemp;
            m_polyOutline.Nth(i, lnTemp);
            (XLine &)curMidSeg=XLine(src[i], ads_angle(lnTemp.StartPoint(), lnTemp.EndPoint()));
        }

      XDirectionCurve curSeg=curMidSeg.Offset(GetOffsetDist(i), LS_INFINITE);
      if(!curSeg) 
          return FALSE;

      XPoint pt1, pt2, curPt;
      if(!i) {  // 求当前点
         if(!lastSeg) curPt=curSeg.StartPoint();
         else {
            int ptNum=curSeg.Intersection(lastSeg, pt1, pt2);
            if(ptNum==2) curPt=XLine(pt1,pt2).NearPoint(curSeg.StartPoint());
            else if(ptNum==1) curPt=pt1;
            else {
                //if(lastSeg.EndPoint().Distance2d(curSeg.StartPoint())>_DIST_SNAP)
                //    dest.AppendNode(lastSeg.EndPoint(), 0.0);
                //curPt=curSeg.StartPoint();
                return FALSE;
            }
         }
      } else curPt=nextPt; //上次求得的下一点

         int nextIndex= i>=nTotalSeg-1? 0 : i+1; // 当前段为最后时, 下一段为起始段
         XDirectionCurve nextMidSeg;
         src.Nth(nextIndex, nextMidSeg);
        if(!nextMidSeg && fabs(src.GetBulge(nextIndex))<1.0E-6) {
            // 2001/8/20, 有可能出现长度为0的边
            XCurveSegment lnTemp;
            m_polyOutline.Nth(nextIndex, lnTemp);
            (XLine &)nextMidSeg=XLine(src[nextIndex], ads_angle(lnTemp.StartPoint(), lnTemp.EndPoint()));
        }

         XDirectionCurve nextSeg=nextMidSeg.Offset(GetOffsetDist(nextIndex), LS_INFINITE);
         if(!nextSeg)
             return FALSE;
         int ptNum=curSeg.Intersection(nextSeg, pt1, pt2);
         if(ptNum==2) nextPt=XLine(pt1, pt2).NearPoint(curSeg.EndPoint());
         else if(ptNum==1) nextPt=pt1;
         else {
             return FALSE;
         }
 
      lastSeg=curSeg;
      if(curSeg.Is(CURVE_ARC)) {
         XArc arc=curSeg.GetArc();
         if(!curSeg.IsMinusArc()) { //逆时针
            arc.SetStarAngle(ads_angle(arc.GetCenterPt(), curPt));
            arc.SetEndAngle(ads_angle(arc.GetCenterPt(), nextPt));
			curSeg.SetBulge(arc.Bulge());
         } else {
            arc.SetStarAngle(ads_angle(arc.GetCenterPt(), nextPt));
            arc.SetEndAngle(ads_angle(arc.GetCenterPt(), curPt));
			curSeg.SetBulge(-arc.Bulge());
         }
         curSeg.StartPoint()=curPt;
         curSeg.EndPoint()=nextPt;
      }  

      //添一段
      dest.Append(new XPoint(curPt));
      dest.AppendBugle(curSeg.GetBulge());
   }
   return TRUE;
}


Acad::ErrorStatus
TDbStep::GetExtents2d(XPoint &ptLow, XPoint &ptUp) const
{
    assertReadEnabled();
    XPoly2D poly2d(1);
    GetOutline2d(poly2d);
    poly2d.GetExtend(ptLow, ptUp);
    return Acad::eOk;
}

Acad::ErrorStatus
TDbStep::GetExtents(XPoint &ptLow, XPoint &ptUp) const
{
	Acad::ErrorStatus es=Acad::eOk;
	es=GetExtents2d(ptLow, ptUp);
	double nElev=GetElevation();
	double nElev1=nElev+GetStepHeight();
	ptLow.z=min(nElev, nElev1);
	ptUp.z=max(nElev, nElev1);
	return es;
}


Acad::ErrorStatus
TDbStep::GetOutline2d(XPoly2D &poly2d) const
{
    assertReadEnabled();
    poly2d=GetStepOutline();
    poly2d.SetElevation(0.0);
    if(m_nStepWidth>0) {
        for(int i=1; i<m_nStepNum; i++) { 
            XPoly2D polyNext(1);
            if(Offset(poly2d, polyNext)) {
                poly2d=polyNext;
            } else {
                return Acad::eInvalidInput;
            }
        }
    }
    return Acad::eOk;
}


// 0--没有命中; 1--任意穿越; 2--任意包含; 3--重边穿越; 4--重边包含
// segHit--重边穿越或包含时的纠正位置
int 
TDbStep::HitTest(const XCurveSegment &seg, double nTol, XCurveSegment &segHit) const
{
    XPoly2D polyMe(1);
    GetOutline2d(polyMe);
    PointList ptInts(seg.StartPoint(), seg.EndPoint(), seg.GetBulge());

    XCurveSegment seg0=seg;
    seg0.SetElevation(0.0);
    seg0.SetLineFlag(LS_FINITE);

    int nIntNum=Intersect(seg0, polyMe, ptInts);
    XPoint ptMid=seg0.MidPoint();
    if(!nIntNum && (ptMid&polyMe)==PR_OUTSIDE)
        return 0;

    for(int n=0; n<polyMe.TotalSegments(); n++) {
        XDirectionCurve seg1;
        polyMe.Nth(n, seg1);
        double nOffDist=-nTol/2.0;
        if(polyMe.PathArea()>0)
            nOffDist=-nOffDist;
        XCurveSegment segRail=seg1.Offset(nOffDist, LS_INFINITE).GetCurve();

        if(seg1.IsMinusArc() || seg1.Is(CURVE_ARC)) {
            XArc ar0=seg0.GetArc();
            XArc ar1=seg1.GetArc();
            XPoint ptOn;
            if(ar0.GetCenterPt().Distance(ar1.GetCenterPt())<_DIST_SNAP &&
                fabs(ar0.GetRadius()-ar1.GetRadius())<nTol && seg0.MidPoint().Project(&ar1, ptOn)==RTNORM &&
                (ptOn&seg1)==PR_INSIDE) {

                XPoint pt1, pt2, ptMid;
                segRail.ProjectToMe(seg0.StartPoint(), pt1);
                segRail.ProjectToMe(seg0.EndPoint(), pt2);
                XPoint ptTemp=seg0.MidPoint();
                segRail.ProjectToMe(ptTemp, ptMid);

                segHit=XArc(pt1, ptMid, pt2);
                segHit.SetLineFlag(LS_FINITE);
                return (nIntNum? 3:4);
            }
        } else {
            XLine ln0=seg0.GetLine();
            XLine ln1=seg1.GetLine();
            XPoint ptOn;
            if(CT_IsSameDrt(ln0.Direction(), ln1.Direction(), _angSnap)) {
                if(seg0.MidPoint().Project(&ln1, ptOn)==RTNORM &&
                    seg0.MidPoint().Distance(ptOn)<nTol) {
                    if((ptOn&seg1)==PR_INSIDE) {
                        XPoint pt1, pt2, ptMid;
                        segRail.ProjectToMe(seg0.StartPoint(), pt1);
                        segRail.ProjectToMe(seg0.EndPoint(), pt2);

                        segHit=XLine(pt1, pt2);
                        segHit.SetLineFlag(LS_FINITE);
                        return (nIntNum? 3:4);
                    }
                }
            }
        }
    }

    return (nIntNum?  1 : 2);
}


double
TDbStep::GetStepHeight() const
{
    return m_nStepHeight;
}

double
TDbStep::GetStepWidth() const
{
    return m_nStepWidth;
}

double
TDbStep::GetTotalHeight() const
{
    return fabs(GetStepHeight()*GetStepNum());
}

const XPoly2D &
TDbStep::GetStepOutline() const
{
    return m_polyOutline;
}

int
TDbStep::GetStepNum() const
{
    return m_nStepNum;
}

void
TDbStep::SetStepNum(int nNum)
{
    assertWriteEnabled();
    m_nStepNum=nNum;
}

void
TDbStep::SetStepHeight(double h)
{
    assertWriteEnabled();
    m_nStepHeight=h;
}

void
TDbStep::SetStepWidth(double w)
{
    assertWriteEnabled();
    m_nStepWidth = w;
}

void
TDbStep::SetPolyOutline(const XPoly2D &poly)
{
    assertWriteEnabled();
    ASSERT(poly.PathArea()<0.0 && poly.GetFlag()==1);
    m_polyOutline = poly;
}

void 
TDbStep::SetStepAt(int idx, BOOL bHasStep)
{
    assertWriteEnabled();
    ASSERT(idx<GetEdgeNum());
    int nTestBit=0x01;
    nTestBit <<= idx;
    if(!bHasStep)
        m_nStepFlag |= nTestBit;
    else
        m_nStepFlag &= ~nTestBit;
}

double
TDbStep::GetElevation() const
{
    double nElev=0;
    if(!!m_polyOutline)
        nElev=m_polyOutline[0].z;
    return nElev;
}

void
TDbStep::SetElevation(double nElev)
{
    assertWriteEnabled();
    m_polyOutline.SetElevation(nElev);
}


// sg add 101119，支持导出XML
CString TDbStep::GetXml(const AcGeMatrix3d& mat) const
{
	TXmlTree xmlTree;
	POSITION posRoot = xmlTree.Insert(_T("ATS_STEP"), NULL, NULL);
	{
		xmlTree.SetAttribute(posRoot, _T("name"), _T("台阶"));
		xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称"));
	}

	CString strText;
	POSITION posItem = NULL;

	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, NULL);
	{
		xmlTree.SetAttribute(posItem2, _T("name"), _T("截面参数"));
		POSITION posItemRiser = xmlTree.Insert(_T("Riser"), posItem2, NULL);
		{
			xmlTree.SetAttribute(posItemRiser, _T("name"), _T("台阶踏步高"));
			strText.Format(_T("%f"), GetStepHeight());
			xmlTree.SetItemText(posItemRiser, strText);
		}

		POSITION posItemTread = xmlTree.Insert(_T("Tread"), posItem2, posItemRiser);
		{
			xmlTree.SetAttribute(posItemTread, _T("name"), _T("台阶踏步宽"));
			strText.Format(_T("%f"), GetStepWidth());
			xmlTree.SetItemText(posItemTread, strText);
		}

		POSITION posItemSteps = xmlTree.Insert(_T("Steps"), posItem2, posItemTread);
		{
			xmlTree.SetAttribute(posItemSteps, _T("name"), _T("台阶踏步数"));
			strText.Format(_T("%d"), GetStepNum());
			xmlTree.SetItemText(posItemSteps, strText);
		}

		POSITION posItemBaseSet = xmlTree.Insert(_T("Base_set"), posItem2, posItemSteps);
		{
			xmlTree.SetAttribute(posItemBaseSet, _T("name"), _T("基面设置"));
			strText = (GetStepWidth() < 0) ? _T("轮廓面") : _T("平台面");
			xmlTree.SetItemText(posItemBaseSet, strText);
		}
	}

	POSITION posItem3 = xmlTree.Insert(_T("Step_REC"), posRoot, posItem2);
	{
		xmlTree.SetAttribute(posItem3, _T("name"), _T("踏步边记录"));
		xmlTree.SetAttribute(posItem3, _T("comment"), _T("记录平台有踏步的边号"));
		strText.Format(_T("%d"), m_nStepFlag);
		xmlTree.SetItemText(posItem3, strText);
	}

	POSITION posItem4 = xmlTree.Insert(_T("Baseline"), posRoot, posItem3);
	{
		xmlTree.SetAttribute(posItem4, _T("name"), _T("基线参数"));
		xmlTree.SetAttribute(posItem4, _T("comment"), _T("用于台阶或平台的外轮廓线"));

		posItem = NULL;
		TADSGePoint3d ptNode;
		int iLen = m_polyOutline.Length();
		for (int i = 0; i < iLen; i++)
		{
			ptNode = m_polyOutline[i];
			// sg add 120117，对点进行坐标变换
			ptNode.TransformBy(mat);

			strText.Format(_T("Point_%d"), i + 1);
			posItem = xmlTree.Insert(strText, posItem4, posItem);
			{
				strText.Format(_T("第%d点"), i + 1);
				xmlTree.SetAttribute(posItem, _T("name"), strText);
				strText.Format(_T("%f,%f,%f"), ptNode.x, ptNode.y, ptNode.z);
				xmlTree.SetItemText(posItem, strText);
			}

			strText.Format(_T("Ang_%d"), i + 1);
			posItem = xmlTree.Insert(strText, posItem4, posItem);
			{
				strText.Format(_T("圆心角%d"), i + 1);
				xmlTree.SetAttribute(posItem, _T("name"), strText);
				strText.Format(_T("%f"), m_polyOutline.GetBulge(i));
				xmlTree.SetItemText(posItem, strText);
			}

			strText.Format(_T("Step_flag_%d"), i + 1);
			posItem = xmlTree.Insert(strText, posItem4, posItem);
			{
				xmlTree.SetAttribute(posItem, _T("name"), _T("踏步标志"));
				strText.Format(_T("%d"), HasStepAt(i));
				xmlTree.SetItemText(posItem, strText);
			}
		}
	}

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

	return strXml;
}

void InitDbStep(BOOL bTrue)
{
    AecObjectEditMethod pOldEdit=NULL;
    if(bTrue) {
        TDbStep::rxInit();
        pOldEdit=TDbStep::SetEditMethod(EditStep0);
        acrxBuildClassHierarchy();
        TDbStep::InitMatchProtocol(TRUE);
    } else {
        TDbStep::InitMatchProtocol(FALSE);
        TDbStep::SetEditMethod(pOldEdit);
        deleteAcRxClass(TDbStep::desc());
    }
}



// Command:编辑台阶
int EditStep0(AcDbObjectId id)
{
    OPENOBJ_BEGIN(id, AcDb::kForRead, TDbStep, pStep);
    if(!pStep)
        return RTERROR;
    while(1) {
        const TCHAR *szPrompt1=_T("\n选择 [踏步宽(W)/踏步高(H)/踏步数(N)/平台标高(T)/参数列表(L)]<退出>:");
        XString sKeyword;
        int nRet=0;
        INITGET_BEG(0, _T("W H N T L"));
        nRet=ads_getkword(szPrompt1, sKeyword);
        INITGET_END();

        if(nRet!=RTNORM)
            break;
        if(sKeyword[0]==_T('W')) {
            double nStepWidth=pStep->GetStepWidth();
            nRet=GetReal(_T("\n踏步宽度"), nStepWidth);
            if(nRet==RTCAN)
                break;
            if(nRet==RTNORM) {
                if(pStep->upgradeOpen()!=Acad::eOk)
                    return RTERROR;
                pStep->assertWriteEnabled();
                pStep->SetStepWidth(nStepWidth);
                if(nStepWidth>0)
                    pStep->SetStepHeight(fabs(pStep->GetStepHeight()));
                else
                    pStep->SetStepHeight(-fabs(pStep->GetStepHeight()));
                pStep->downgradeOpen();
            }
        } else if(sKeyword[0]==_T('H')) {
            double nStepHeight=pStep->GetStepHeight();
            nRet=GetReal(_T("\n踏步高度"), nStepHeight);
            if(nRet==RTCAN)
                break;
            if(nRet==RTNORM) {
                if(pStep->upgradeOpen()!=Acad::eOk)
                    return RTERROR;
                pStep->assertWriteEnabled();
                pStep->SetStepHeight(nStepHeight);
                if(nStepHeight>0)
                    pStep->SetStepWidth(fabs(pStep->GetStepWidth()));
                else
                    pStep->SetStepWidth(-fabs(pStep->GetStepWidth()));
                pStep->downgradeOpen();
            }
        } else if(sKeyword[0]==_T('N')) {
            int nStepNum=pStep->GetStepNum();
            ads_initget(RSG_NOZERO|RSG_NONEG, NULL);
            adsout << _T("\n踏步数目<") << nStepNum << _T(">:");
            nRet=ads_getint(_T(""), &nStepNum);
            if(nRet==RTCAN)
                break;
            if(nRet==RTNORM) {
                if(pStep->upgradeOpen()!=Acad::eOk)
                    return RTERROR;
                pStep->assertWriteEnabled();
                pStep->SetStepNum(nStepNum);
                pStep->downgradeOpen();
            }
        } else if(sKeyword[0]==_T('T')) {
            double nElev=pStep->GetElevation();
            nRet=GetReal(_T("\n平台标高"), nElev);
            if(nRet==RTCAN)
                break;
            if(nRet==RTNORM) {
                if(pStep->upgradeOpen()!=Acad::eOk)
                    return RTERROR;
                pStep->assertWriteEnabled();
                pStep->SetElevation(nElev);
                pStep->downgradeOpen();
            }
        } else if(sKeyword[0]==_T('L')) {
            pStep->list();
        }
    }
    OPENOBJ_END();

    return RTNORM;
}