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

////////////////////////////////////////////////////////////////////////////
// TArch6新增2;TArch7,3,TArch8,4
const Adesk::UInt8 TDbMultiStair::g_nVersion = 4;

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

IMPLEMENT_TENTBASE(TDbMultiStair);

TDbMultiStair::TDbMultiStair()
{
    m_nFlagEx=0;
    m_nStairFlag=1; //楼层标记

    m_nStepHeight=_AS_SYS_UNIT(150.0); //踏步高
    m_nStepWidth=_AS_SYS_UNIT(300); //踏步宽
    m_nStairWidth=_AS_SYS_UNIT(1200); //梯段宽
	m_nStairHeight=_AS_SYS_UNIT(3000.0); //楼梯总高
    m_nElevation=0.0; //标高
    m_nSlabThick=_AS_SYS_UNIT(120); //休息平台尺寸
    m_nBeamThick=_AS_SYS_UNIT(120); //梁厚
	m_nBeamHeight=_AS_SYS_UNIT(200); //边梁高（坡道）

    m_nRailHeight=_AS_SYS_UNIT(900);  
    m_nRailWidth=_AS_SYS_UNIT(60.0);   //扶手宽度
    m_nRailDistToSide=0.0; //扶手距离边

	m_nPathSide = OFFSET_LEFT;
	m_lSectPos=m_rSectPos=0.0;

	m_nViewCtrl=0; //自动确定

	m_iActiveStep=-1;

	//add by xlc on 080718 Tarch8
	m_nRailDistEnd=0;				//终端扶手伸出距离
	m_nRailDist=0;					//起始端扶手伸出距离
	m_dSectElev=_AS_SYS_UNIT(800);	//剖切高度
	m_dSectRotation=PI/6;			//剖断线旋转角度
	m_dTextHeight=3.5;				//字高
	SetLayerText(InitLayer(LAY_TEXT));
	SetTextStyle(InitTextStyle(TS_DIM));
	SetLayerArrow(InitLayer(LAY_OTHER_DIM));
	SetArrow(TRUE);
	SetManualSectPos(TRUE);
}


TDbMultiStair::~TDbMultiStair()
{
}

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

	bRet=(m_polySide2d.Length()>0 && m_polySide2d.GetFlag()==0 && 
//		(m_polySide2d.Length()%2==0) && //基数
               m_nStairHeight>_DIST_SNAP && 
			   m_nStepHeight>_DIST_SNAP && //踏步高
               m_nStepWidth>_DIST_SNAP && //踏步宽
               m_nStairWidth>_DIST_SNAP && //梯段宽
               m_nSlabThick>_DIST_SNAP &&  
               m_nRailHeight>_DIST_SNAP &&
               m_nRailWidth>_DIST_SNAP &&
			   GreatEqual(m_nBeamHeight, 0.0) &&
			   GreatEqual(m_nBeamThick, 0.0) &&
			   GreatEqual(m_nSlabThick, 0.0) &&
               m_nStairFlag<3 &&
               m_nRailDistToSide>-1.0E-6 && 
			   m_nStairWidth>m_nRailWidth+m_nRailDistToSide); 
    return bRet;
}

// 提供对格式刷的支持
void TDbMultiStair::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
{
    assertWriteEnabled();
    TDbEntity::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
    TDbMultiStair *pSrc=TDbMultiStair::cast(pSrcEntity);
    if(pSrc) {
		m_nFlagEx = pSrc->m_nFlagEx;
        m_nStairFlag=pSrc->m_nStairFlag;
		m_nStairWidth = pSrc->m_nStairWidth;
        m_nStairHeight=pSrc->m_nStairHeight;
		m_nStepWidth = pSrc->m_nStepWidth;
		m_nStepHeight = pSrc->m_nStepHeight;
		m_nRailHeight = pSrc->m_nRailHeight;  //扶手高度
		m_nRailWidth = pSrc->m_nRailWidth;   //扶手宽度
		m_nRailDistToSide = pSrc->m_nRailDistToSide; //扶手距离边
		m_nSlabThick = pSrc->m_nSlabThick; //平台厚度
		m_nBeamHeight = pSrc->m_nBeamHeight; //边梁高度
		m_nBeamThick = pSrc->m_nBeamThick; //边梁厚度

		//add by xlc on 090426箭头文字
		SetTextUp(pSrc->GetTextUp());
		SetTextDown(pSrc->GetTextDown());

		if(database()==NULL||
		   pSrcEntity->database()==NULL||
		   database()==pSrcEntity->database())//add by whl on 060317
		{
			m_idLayerStep3d = pSrc->m_idLayerStep3d;
			m_idLayerHand3d = pSrc->m_idLayerHand3d;
			m_idLayerRail3d = pSrc->m_idLayerRail3d;
			m_idLayerBeam3d = pSrc->m_idLayerBeam3d;

			//add by xlc on 080718
			//Tarch8 member
			m_idLayerText=pSrc->m_idLayerText;
			m_idLayerArrow=pSrc->m_idLayerArrow;
			m_idTextStyle=pSrc->m_idTextStyle;
		}
		m_lSectPos = pSrc->m_lSectPos;
		m_rSectPos = pSrc->m_rSectPos;
		m_nViewCtrl=pSrc->m_nViewCtrl;
	
		//add by xlc on 080718
		//Tarch8 member
		m_nRailDistEnd=pSrc->m_nRailDistEnd;	//终端扶手伸出距离
		m_nRailDist=pSrc->m_nRailDist;			//起始端扶手伸出距离
		m_dSectElev=pSrc->m_dSectElev;			//剖切高度
		m_dSectRotation=pSrc->m_dSectRotation;	//剖断线旋转角度
		m_dTextHeight=pSrc->m_dTextHeight;		//字高
    }
}

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


// 从DWG读入数据:
Acad::ErrorStatus 
TDbMultiStair::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_nFlagEx);
 	pFiler->readItem(&m_nStairFlag);
 	pFiler->readItem(&m_nPathSide);
    m_polySide2d.Reset(); 
    Adesk::UInt8 nCount=0;
    pFiler->readItem(&nCount);
 	for(Adesk::UInt8 i=0; i<nCount; i++) {
 		AcGePoint2d pt2d;
 		pFiler->readItem(&pt2d);
 		XPoint pt(pt2d);
 		m_polySide2d.AppendNode(pt);
 	}

    pFiler->readItem(&m_nElevation); //标高
	pFiler->readItem(&m_nStairWidth);
    pFiler->readItem(&m_nStairHeight); //楼梯高
	pFiler->readItem(&m_nStepWidth);
	pFiler->readItem(&m_nStepHeight); //踏步高
    pFiler->readItem(&m_nRailHeight);  
    pFiler->readItem(&m_nRailWidth);
    pFiler->readItem(&m_nRailDistToSide);
    pFiler->readItem(&m_nSlabThick); 
    pFiler->readItem(&m_nBeamHeight);
	pFiler->readItem(&m_nBeamThick);

	pFiler->readItem(&m_idLayerStep3d);
	pFiler->readItem(&m_idLayerHand3d);
	pFiler->readItem(&m_idLayerRail3d);
	pFiler->readItem(&m_idLayerBeam3d);

	if(IsManualSectPos()) {
		pFiler->readItem(&m_lSectPos);
		pFiler->readItem(&m_rSectPos);
	} else {
		m_lSectPos=m_rSectPos=0.0;
	}

	//add by xlc on 080721     剖切线从低版本到高版本
	if(nVer<4)
	{
		XPoint ptSectLeft2d,ptSectRight2d;
		int nHitLeft=HitTestSectPos(0, ptSectLeft2d),
			nHitRight=HitTestSectPos(1, ptSectRight2d);
		if(nHitLeft == nHitRight && nHitLeft != 0)
		{
			DList<TDbEntity> lstComponents;
			ExplodeTo(lstComponents);
			DStack<TDbStair> stairs;
			for(int i=0; i<lstComponents.Length(); i++) {
				TDbEntity *pEnt=lstComponents[i];
				if(pEnt->isKindOf(TDbStair::desc()))
					stairs.Append((TDbStair *)pEnt);
			}
			double rotation=0;
			XPoint ptLowLeft2d,ptLowRight2d;
			if(nHitLeft<stairs.Length()+1&&nHitLeft>0)
			{
				ptLowLeft2d=stairs[nHitLeft-1]->GetLowLeft2d();
				ptLowRight2d=stairs[nHitLeft-1]->GetLowRight2d();
				rotation=ads_angle(ptLowLeft2d,ptLowRight2d);
			}
			if(!IsManualSectPos())
			{
				if(nHitLeft<stairs.Length()+1&&nHitLeft>0)
					m_dSectElev=0.5*stairs[nHitLeft-1]->GetStairHeight();
			}
			else
			{
				if(nHitLeft<stairs.Length()+1&&nHitLeft>0)
				{
					double length=(ptSectLeft2d.Distance2d(stairs[nHitLeft-1]->GetLowLeft2d())
						+ptSectRight2d.Distance2d(stairs[nHitLeft-1]->GetLowRight2d()))*0.5;
					int stepNum=stairs[nHitLeft-1]->GetStepNum();
					double stepWidth=((TDbLineStair*)stairs[nHitLeft-1])->GetStepWidth();
					double stairLength=stepWidth*(stepNum-(IsAscent()?0:1));
					if(length>0&&length<stairLength)
					{
						m_dSectElev = length*stairs[nHitLeft-1]->GetStairHeight()/(stairLength+(IsAscent()?0:stepWidth));
					}
					for(int i=0;i<nHitLeft-1;i++)
					{
						m_dSectElev += stairs[i]->GetStairHeight();
					}
				}
			}

			m_dSectRotation=CT_std_angle(ads_angle(ptSectRight2d, ptSectLeft2d)-rotation);
			SetArrow(FALSE);
		}
	}

	if(nVer>1)
		pFiler->readItem(&m_nViewCtrl);
 	else
		m_nViewCtrl=0; //自动确定

	if(nVer>2)
	{
		int num;
		pFiler->readItem(&num);//这个值无用,永远是0!
	}

	m_lstSegType.Reset();
	if(nVer>3)//TArch8
	{
		Adesk::Int32 num;
		pFiler->readItem(&num);
		for(long i=0;i<num;i++)
		{
			Adesk::UInt8 *pType=new Adesk::UInt8;
			pFiler->readItem(pType);
			m_lstSegType.Append(pType);
		}

		//add by xlc on 080718
		pFiler->readItem(&m_nRailDistEnd);		//终端扶手伸出距离
		pFiler->readItem(&m_nRailDist);			//起始端扶手伸出距离
		pFiler->readItem(&m_dSectElev);			//剖切高度
		pFiler->readItem(&m_dSectRotation);		//剖断转角
		pFiler->readItem(&m_dTextHeight);		//字高
		pFiler->readItem(&m_idLayerText);
		pFiler->readItem(&m_idTextStyle);
		pFiler->readItem(&m_idLayerArrow);
	}

	return pFiler->filerStatus();
}

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

	if(g_nSaveTArchVer<7)
		pFiler->writeItem((Adesk::UInt8)2);
	else if(g_nSaveTArchVer==7)
		pFiler->writeItem((Adesk::UInt8)3);
	else
		pFiler->writeItem(g_nVersion);

	Adesk::UInt32 nFlagEx=m_nFlagEx;
	if(g_nSaveTArchVer<8)
	{
		nFlagEx |= SFEX_SECTPOS;
	}
	pFiler->writeItem(nFlagEx);
	pFiler->writeItem(m_nStairFlag);
	pFiler->writeItem(m_nPathSide);


    Adesk::UInt8 nCount=m_polySide2d.Length();
 	pFiler->writeItem(nCount);
	for(Adesk::UInt8 i=0; i<nCount; i++) {
		XPoint pt=m_polySide2d[i];
		pFiler->writeItem((AcGePoint2d &)pt);
	}
    pFiler->writeItem(m_nElevation);
	pFiler->writeItem(m_nStairWidth);
    pFiler->writeItem(m_nStairHeight);
	pFiler->writeItem(m_nStepWidth);
	pFiler->writeItem(m_nStepHeight);
    pFiler->writeItem(m_nRailHeight);  
    pFiler->writeItem(m_nRailWidth);
    pFiler->writeItem(m_nRailDistToSide);

    pFiler->writeItem(m_nSlabThick); //休息平台尺寸
    pFiler->writeItem(m_nBeamHeight);
	pFiler->writeItem(m_nBeamThick);

	pFiler->writeItem(m_idLayerStep3d);
	pFiler->writeItem(m_idLayerHand3d);
	pFiler->writeItem(m_idLayerRail3d);
	pFiler->writeItem(m_idLayerBeam3d);
	if(IsManualSectPos()) 
	{
		DStack<TDbStair> stairs;
		DList<TDbEntity> lstComponents;
		ExplodeTo(lstComponents);
		for(int i=0; i<lstComponents.Length(); i++) 
		{
			TDbEntity *pEnt=lstComponents[i];
			if(pEnt->isKindOf(TDbStair::desc()))
				stairs.Append((TDbStair *)pEnt);
		}

		double lSectPos,rSectPos;
		XPoint ptLeft2d,ptRight2d;
		BOOL bSect=CalSectPos(stairs,lSectPos,rSectPos,ptLeft2d,ptRight2d);
		if(bSect)
		{
			XPoly2D lPoly, rPoly;
			GetSidePoly2d(0, lPoly);
			GetSidePoly2d(1, rPoly);
			lSectPos=lPoly.PathDistance2d(ptLeft2d);
			rSectPos=rPoly.PathDistance2d(ptRight2d);
		}
		else
		{
			lSectPos=m_lSectPos;
			rSectPos=m_rSectPos;
		}
		pFiler->writeItem(lSectPos);
		pFiler->writeItem(rSectPos);
	}
	pFiler->writeItem(m_nViewCtrl);

	if(g_nSaveTArchVer>6)
	{
		int num=0;
		pFiler->writeItem(num);//这是个无用值！
	}

	if(g_nSaveTArchVer>7)
	{
		pFiler->writeItem((Adesk::Int32)m_lstSegType.Length());
		for(long i=0;i<m_lstSegType.Length();i++)
			pFiler->writeItem(m_lstSegType[i]);

		//add by xlc on 080718
		pFiler->writeItem(m_nRailDistEnd);		//终端扶手伸出距离
		pFiler->writeItem(m_nRailDist);			//起始端扶手伸出距离
		pFiler->writeItem(m_dSectElev);			//剖切高度
		pFiler->writeItem(m_dSectRotation);		//剖断转角
		pFiler->writeItem(m_dTextHeight);		//字高
		pFiler->writeItem(m_idLayerText);
		pFiler->writeItem(m_idTextStyle);
		pFiler->writeItem(m_idLayerArrow);
	}

    return pFiler->filerStatus();
}


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

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

    if (!pFiler->atSubclassData(_T("TDbMultiStair"))) {
        return Acad::eBadDxfSequence;
    }
	TDbMultiStair *pBakClone=(TDbMultiStair *)clone();
	resbuf rb;
	m_polySide2d.Reset();
	bool bStairHeight=false;
    while ((es == Acad::eOk)
        && ((es = pFiler->readResBuf(&rb)) == Acad::eOk))    {
        switch (rb.restype) {
        case AcDb::kDxfInt16:
            m_nStairFlag=(Adesk::UInt8)rb.resval.rint;
            break;
        case AcDb::kDxfInt16+1:
			m_nPathSide=(Adesk::UInt8)rb.resval.rint;
            break;    
		case 75:
			m_nViewCtrl=(Adesk::UInt8)rb.resval.rint;
			break;
        case 48:
            m_nElevation = rb.resval.rreal;
            break;    
		case 49:
			m_nStairHeight=rb.resval.rreal;
			bStairHeight=true;
			break;
		case 10:
			m_polySide2d.AppendNode(XPoint(rb.resval.rpoint));
			break;
		case 40:
			m_nStepHeight=rb.resval.rreal;
			break;
		case 41:
			m_lSectPos=rb.resval.rreal;
			break;
		case 42:
			m_rSectPos=rb.resval.rreal;
			break;
		case 43:
			m_nStepWidth=rb.resval.rreal;
			break;
		case 44:
			m_nStairWidth=rb.resval.rreal;
			break;
		case 90:
			m_nFlagEx=rb.resval.rlong;
			break;
		case 145:
			m_nBeamHeight=rb.resval.rreal;
			break;
		case 146:
			m_nBeamThick=rb.resval.rreal;
			break;
		case 147:
			m_nSlabThick=rb.resval.rreal;
			break;
		case 412:
			m_idLayerStep3d=LayerString2Id(rb.resval.rstring, database());
			free(rb.resval.rstring);
			break;
		case 413:
			m_idLayerBeam3d=LayerString2Id(rb.resval.rstring, database());
			free(rb.resval.rstring);
			break;
		case 414:
			m_idLayerHand3d=LayerString2Id(rb.resval.rstring, database());
			free(rb.resval.rstring);
			break;
		case 415:
			m_idLayerRail3d=LayerString2Id(rb.resval.rstring, database());
			free(rb.resval.rstring);
			break;
            //fall through intentional
        default:
            // An unrecognized group. Push it back so that
            // the subclass can read it again.
            pFiler->pushBackItem();
            es = Acad::eEndOfFile;
            break;
        }
    }

    // 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 || m_polySide2d.Length()<2) {
		CopyObject(*pBakClone, *this);
		delete pBakClone;
        return Acad::eInvalidResBuf;
	}
	delete pBakClone;
	if(!bStairHeight)
		m_nStairHeight=DocGetLHeight();

    return pFiler->filerStatus();
}

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

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

    es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbMultiStair"));
    assert(es == Acad::eOk);
    pFiler->writeInt16(AcDb::kDxfInt16, (Adesk::UInt16)m_nStairFlag);
	pFiler->writeInt16(AcDb::kDxfInt16+1, (Adesk::UInt16)m_nPathSide);
	pFiler->writeInt16(75,	(Adesk::UInt16)m_nViewCtrl);
	pFiler->writeDouble(48,  m_nElevation);
	pFiler->writeDouble(49, m_nStairHeight);
	for(int n=0; n<m_polySide2d.Length(); n++)
		pFiler->writePoint2d(10, m_polySide2d[n]);

	pFiler->writeDouble(40,	m_nStepHeight);
	pFiler->writeDouble(41,	m_lSectPos);
	pFiler->writeDouble(42,	m_rSectPos);
	pFiler->writeDouble(43, m_nStepWidth);
	pFiler->writeDouble(44,	m_nStairWidth);
	pFiler->writeInt32(90, m_nFlagEx);
	pFiler->writeDouble(145, m_nBeamHeight);
	pFiler->writeDouble(146,m_nBeamThick);
	pFiler->writeDouble(147,m_nSlabThick);
	pFiler->writeString(412, (const TCHAR*)LayerId2String(m_idLayerStep3d));
	pFiler->writeString(413, (const TCHAR*)LayerId2String(m_idLayerBeam3d));
	pFiler->writeString(414, (const TCHAR*)LayerId2String(m_idLayerHand3d));
	pFiler->writeString(415, (const TCHAR*)LayerId2String(m_idLayerRail3d));

    return pFiler->filerStatus();
}
Adesk::UInt8 TDbMultiStair::GetSegType(long i)const
{
	if(m_lstSegType.Length()==0)
		return (Adesk::UInt8)(i%2);
	else if(i<m_lstSegType.Length())
		return m_lstSegType[i];
	else
	{
		Adesk::UInt8 lastType=m_lstSegType[m_lstSegType.Length()-1];
		if(((i-m_lstSegType.Length()+1)%2)==0)
			return lastType;
		else
			return 1-lastType;
	}
}
void TDbMultiStair::SetSegType(long i,Adesk::UInt8 type)
{
	assertWriteEnabled();
	if(i<m_lstSegType.Length())
		*m_lstSegType[i]=type;
	else
	{
		for(long n=m_lstSegType.Length();n<i;n++)
			m_lstSegType.Append(new Adesk::UInt8(GetSegType(n)));

		m_lstSegType.Append(new Adesk::UInt8(type));
	}
}
	
Acad::ErrorStatus 
TDbMultiStair::subGetGripPoints(AcGePoint3dArray&     gripPoints,
                                         AcDbIntArray&  osnapModes,
                                         AcDbIntArray&  geomIds) const
{
    assertReadEnabled();
    for(int i=0; i<m_polySide2d.Length(); i++) {
		XPoint pt=m_polySide2d[i];
		gripPoints.append(pt);
	}
	//if(IsManualSectPos()) 
	//modify by xlc on 080718
	/*{
		XPoint ptLeft, ptRight;
		int nHit1=HitTestSectPos(0, ptLeft);
		int nHit2=HitTestSectPos(1, ptRight);
		if(nHit1 && nHit2) {
			gripPoints.append(ptLeft);
			gripPoints.append(ptRight);
		}
	}*/
	DList<TDbEntity> lstComponents;
	ExplodeTo(lstComponents);
	DStack<TDbStair> stairs;
	for(i=0; i<lstComponents.Length(); i++)
	{
		TDbEntity *pEnt=lstComponents[i];
		if(pEnt->isKindOf(TDbStair::desc()))
			stairs.Append((TDbStair *)pEnt);
	}
	
	//add by xlc on 090427
	if(stairs.Length()<1)
		return Acad::eOk;

	TDbStair *pStair = stairs[0];
	XPoint ptUpLeft2d,ptUpRight2d,ptLowLeft2d,ptLowRight2d;
	ptUpLeft2d=pStair->GetUpLeft2d();
	ptUpRight2d=pStair->GetUpRight2d();
	ptLowLeft2d=pStair->GetLowLeft2d();
	ptLowRight2d=pStair->GetLowRight2d();

	double dir=ads_angle(ptLowLeft2d,ptLowRight2d);
	// 起始端扶手伸出距离
	XPoint ptTmp;
	ads_polar(ptLowLeft2d, dir, GetRailDistToSide()+GetRailWidth()*0.5, ptTmp);
	ads_polar(ptTmp, dir-PI*0.5, GetRailDist(), ptTmp);
	gripPoints.append(ptTmp);
	ads_polar(ptLowRight2d, dir+PI, GetRailDistToSide()+GetRailWidth()*0.5, ptTmp);
	ads_polar(ptTmp, dir-PI*0.5, GetRailDist(), ptTmp);
	gripPoints.append(ptTmp);


	TDbStair *pStairE = stairs[stairs.Length()-1];
	ptUpLeft2d=pStairE->GetUpLeft2d();
	ptUpRight2d=pStairE->GetUpRight2d();
	ptLowLeft2d=pStairE->GetLowLeft2d();
	ptLowRight2d=pStairE->GetLowRight2d();

	dir=ads_angle(ptLowLeft2d,ptLowRight2d);

	// 终端扶手伸出距离	
	ads_polar(ptUpLeft2d, dir, GetRailDistToSide()+GetRailWidth()*0.5, ptTmp);
	ads_polar(ptTmp, dir+PI*0.5, GetRailDistEnd(), ptTmp);
	gripPoints.append(ptTmp);
	ads_polar(ptUpRight2d, dir+PI, GetRailDistToSide()+GetRailWidth()*0.5, ptTmp);
	ads_polar(ptTmp, dir+PI*0.5, GetRailDistEnd(), ptTmp);
	gripPoints.append(ptTmp);

	double lSectPos,rSectPos;
	XPoint ptLeft2d,ptRight2d;
	BOOL bSect=CalSectPos(stairs,lSectPos,rSectPos,ptLeft2d,ptRight2d);
	if(bSect)
	{
		gripPoints.append(ptLeft2d);
		gripPoints.append(ptRight2d);
		XPoint ptMid;
		Midpoint(ptLeft2d,ptRight2d,ptMid);
		gripPoints.append(ptMid);
	}

    return Acad::eOk;
}

Acad::ErrorStatus 
TDbMultiStair::subGetStretchPoints(AcGePoint3dArray & stretchPoints) const
{
    assertReadEnabled();
    for(int i=0; i<m_polySide2d.Length(); i++) {
		XPoint pt=m_polySide2d[i];
		stretchPoints.append(pt);
	}
    return Acad::eOk;
}

Acad::ErrorStatus 
TDbMultiStair::GetGripText(int i, CString &cs) const
{
	int idx=(i-m_polySide2d.Length());
	if(idx==0||idx==1)
	{
		cs=_T("首梯段扶手伸出距离");
	}
	else if(idx==2||idx==3)
	{
		cs=_T("尾梯段扶手伸出距离");
	}
	else if(idx==4||idx==5)
	{
		cs=_T("移动剖切线角度");
	}
	else if(idx==6)
	{
		cs= _T("移动剖切位置");
	} 
	else
	{
		cs.Format(_T("移动第%d个顶点"), i);
	}
    return Acad::eOk;
}


Acad::ErrorStatus 
TDbMultiStair::subTransformBy(const AcGeMatrix3d& xform)
{
    assertWriteEnabled();
	TDbEntity::subTransformBy(xform);
    if(!IsValid())
        return Acad::eInvalidInput;

    double nOldZ=m_polySide2d[0]->z;
	m_polySide2d.TransformBy(xform);
    double nNewZ=m_polySide2d[0]->z;
    m_nElevation += (nNewZ-nOldZ);
	m_polySide2d.SetElevation(0.0);
	if(IsMirrorMatrix(xform)) {
		m_nPathSide = 1-m_nPathSide;
		BOOL bRail1=HasHandRail(0);
		BOOL bRail2=HasHandRail(1);
		SetHandRail(0, bRail2);
		SetHandRail(1, bRail1);
		BOOL bBeam1=HasSideBeam(0);
		BOOL bBeam2=HasSideBeam(1);
		SetSideBeam(0, bBeam2);
		SetSideBeam(1, bBeam1);
		BOOL bWall1=IsAlongWall(0);
		BOOL bWall2=IsAlongWall(1);
		SetAlongWall(0, bWall2);
		SetAlongWall(1, bWall1);

		TchPrivate::Exchange(m_lSectPos,m_rSectPos);//add by whl on 070416
	}
    return Acad::eOk;
}

Acad::ErrorStatus 
TDbMultiStair::subMoveGripPointsAt(const AcDbIntArray& indices,
                 const AcGeVector3d& offset)
{
    assertWriteEnabled();
    XPoint vtOffset=*(XPoint *)&offset;
    vtOffset.z = 0;

	for(int i=0; i<indices.length(); i++) {
		int idx=indices[i];
		if(idx<m_polySide2d.Length())
		{
			//modify by xlc on 080722 不让夹点拖到一起
			// *m_polySide2d[idx] += vtOffset;
			XPoint pt=*m_polySide2d[idx];
			pt += vtOffset;
			if(idx>0&&idx<m_polySide2d.Length()-1)
			{
				if(pt.Distance2d(*m_polySide2d[idx-1])>_DIST_SNAP
					&&pt.Distance2d(*m_polySide2d[idx+1])>_DIST_SNAP)
				{
					*m_polySide2d[idx] += vtOffset;
				}
			}
			else if(idx==0)
			{
				if(pt.Distance2d(*m_polySide2d[idx+1])>_DIST_SNAP)
				{
					*m_polySide2d[idx] += vtOffset;
				}
			}
			else if(idx==m_polySide2d.Length()-1)
			{
				if(pt.Distance2d(*m_polySide2d[idx-1])>_DIST_SNAP)
				{
					*m_polySide2d[idx] += vtOffset;
				}
			}
		} 
		else 
		{
			idx -= m_polySide2d.Length();
			
			DList<TDbEntity> lstComponents;
			ExplodeTo(lstComponents);
			DStack<TDbStair> stairs;
			for(int i=0; i<lstComponents.Length(); i++)
			{
				TDbEntity *pEnt=lstComponents[i];
				if(pEnt->isKindOf(TDbStair::desc()))
					stairs.Append((TDbStair *)pEnt);
			}
			if(idx==0||idx==1)
			{
				TDbLineStair *pStair=(TDbLineStair *)stairs[0];
				double dRotation=pStair->GetRotation();
				double nVtRot=CT_std_angle(ads_angle(XPoint(), vtOffset)-dRotation);
				double nIncWidth=ads_distance(XPoint(), vtOffset) * cos(nVtRot);
				double nIncLen=ads_distance(XPoint(), vtOffset) * sin(nVtRot);

				if(m_nRailDist-nIncLen>-0.5*pStair->GetStairLength()-_DIST_SNAP)
				{
					m_nRailDist -= nIncLen;
				}				
			}
			else if(idx==2|| idx==3)
			{
				TDbLineStair *pStair=(TDbLineStair *)stairs[stairs.Length()-1];
				double dRotation=pStair->GetRotation();
				double nVtRot=CT_std_angle(ads_angle(XPoint(), vtOffset)-dRotation);
				double nIncWidth=ads_distance(XPoint(), vtOffset) * cos(nVtRot);
				double nIncLen=ads_distance(XPoint(), vtOffset) * sin(nVtRot);

				if(m_nRailDistEnd+nIncLen>-0.5*pStair->GetStairLength()-_DIST_SNAP)
				{
					m_nRailDistEnd += nIncLen;
				}				
			}
			else if(idx==4 || idx==5 || idx == 6)
			{
				//modify by xlc on 080718
				/*XPoint ptHit2d;
				XPoly2D poly2d;
				GetSidePoly2d(idx, poly2d);
				if(HitTestSectPos(idx, ptHit2d)) {
					if(!IsManualSectPos())
					{
						SetManualSectPos(TRUE);
						SetDefaultSectPos();
					}
					ptHit2d += vtOffset;
					AcDbPolyline pline;
					PolyConvert(poly2d, pline);
					XPoint ptNear=ptHit2d;
					pline.getClosestPointTo(ptNear, ptHit2d);
					double val=poly2d.PathDistance2d(ptHit2d);
					if(idx==0)
						m_lSectPos=val;
					else
						m_rSectPos=val;
				}*/
				
				double lSectPos,rSectPos;
				XPoint ptLeft2d,ptRight2d;
				double angle=m_dSectRotation;
				BOOL bSect=CalSectPos(stairs,lSectPos,rSectPos,ptLeft2d,ptRight2d);
				int nSectStair=GetSectStairPos(stairs);
				if(bSect)
				{
					XPoint ptMid;
					Midpoint(ptLeft2d,ptRight2d,ptMid);
					if(idx==6)
					{
						XPoint ptHit2d;
						ptHit2d=ptMid;
						ptHit2d += vtOffset;
						double elev=HitElevationByPoint2d(stairs,ptHit2d);
						if(elev>_DIST_SNAP)
							m_dSectElev=elev;
					}
					else
					{
						XPoint ptTmp;
						TDbLineStair *pStair=(TDbLineStair *)stairs[nSectStair];
						ads_polar(ptMid, pStair->GetRotation(), pStair->GetStairWidth(), ptTmp);
						AcGeVector3d vectFrom,vectTo;
						vectFrom=ptMid-ptTmp;
						if(idx%2==0)
						{
							ptTmp=ptLeft2d+vtOffset;
							vectTo=ptTmp-ptMid;
						}
						else
						{
							ptTmp=ptRight2d+vtOffset;
							vectTo=ptMid-ptTmp;
						}
						angle=vectFrom.angleTo(vectTo,AcGeVector3d::kZAxis);
						SetSectRotation(angle);
					}
					CalSectPos(stairs,m_lSectPos,m_rSectPos,ptLeft2d,ptRight2d);
				}
			} 
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus 
TDbMultiStair::subMoveStretchPointsAt(const AcDbIntArray& indices,
                 const AcGeVector3d& offset)
{
    return subMoveGripPointsAt(indices, offset);
}

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

void 
TDbMultiStair::GetTips(DList<TObjInfoUnit> &lstInfo) const
{
    lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("多跑楼梯")));
    //lstInfo.Append(new TObjInfoUnit(_T("总步数"), XString(_T("%d"), int(GetTotalStepNum()))));
    lstInfo.Append(new TObjInfoUnit(_T("踏步高"), Dist2Str(GetStepHeight())));
    lstInfo.Append(new TObjInfoUnit(_T("楼梯高"), Dist2Str(GetStairHeight())));
    lstInfo.Append(new TObjInfoUnit(_T("边梁宽"), Dist2Str(GetBeamThick())));
    lstInfo.Append(new TObjInfoUnit(_T("板厚"), Dist2Str(GetSlabThick())));
    lstInfo.Append(new TObjInfoUnit(_T("扶手宽"), Dist2Str(GetRailWidth())));
    lstInfo.Append(new TObjInfoUnit(_T("扶手边距"), Dist2Str(GetRailDistToSide())));

	lstInfo.Append(new TObjInfoUnit(_T("首梯段扶手距离"), Dist2Str(GetRailDist())));
	lstInfo.Append(new TObjInfoUnit(_T("尾梯段扶手距离"), Dist2Str(GetRailDistEnd())));
	lstInfo.Append(new TObjInfoUnit(_T("剖切高度"), Dist2Str(GetSectElev())));
	lstInfo.Append(new TObjInfoUnit(_T("低标高"), Dist2Str(GetElevation())));

    const TCHAR *pszFloor=_T("首层");
    if(m_nStairFlag==1)
        pszFloor=_T("中间层");
    else if(m_nStairFlag==2)
        pszFloor=_T("顶层");
    lstInfo.Append(new TObjInfoUnit(_T("基线位置"), m_nPathSide? _T("右边") : _T("左边")));
    lstInfo.Append(new TObjInfoUnit(_T("左边梁"), HasSideBeam(OFFSET_LEFT)? _T("有") : _T("无")));
    lstInfo.Append(new TObjInfoUnit(_T("右边梁"), HasSideBeam(OFFSET_RIGHT)? _T("有") : _T("无")));
}

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


// lstComponents－梯段、平台、扶手
Acad::ErrorStatus
TDbMultiStair::ExplodeTo(DList<TDbEntity> &lstComponents) const
{
    assertReadEnabled();
    if(!IsValid())
        return Acad::eInvalidInput;

    int nStairIdx=0;
    double nStepHeight=GetStepHeight();
	int numVerts=m_polySide2d.Length();
	XPoly2D polyLeft, polyRight;
	if(m_nPathSide)
	{
		polyRight=m_polySide2d;
		polyRight.QuickOffset(-m_nStairWidth, polyLeft);
	} 
	else
	{
		polyLeft=m_polySide2d; 
		polyLeft.QuickOffset(m_nStairWidth, polyRight);
	}

	//add by xlc on 090427 拖动夹点后自相交时崩溃
	if(polyLeft.Length()!=polyRight.Length())
		return Acad::eInvalidInput;

	BOOL bLeftWall=IsAlongWall(0); //是否左边靠墙
	BOOL bRightWall=IsAlongWall(1); //是否右边靠墙
	double nSegHeight=m_nStairHeight;
	BOOL bStairSeg=TRUE;
	double nElev=m_nElevation;
	XLine lnPrevTop; //上一个梯段的末尾
	XPoly2D lPolySide, rPolySide;

	//add by xlc on 080718
	XPoly2D polyArrowDown,polyArrowUp;//箭头线
	double dHeight=0;				  //起始高度
	BOOL bEnd=FALSE;				  //是否结束上楼箭头
	if(m_nStairFlag==SF_TOP)
		bEnd=TRUE;
	double dStepHeight=nStepHeight,dStepWidth=GetStepWidth();

    for(int i=0; i<numVerts-1; i++) 
	{
		bStairSeg=GetSegType(i)==0;
		
		XLine lCurrent(*polyLeft[i], *polyLeft[i+1], LS_INFINITE);
		XLine rCurrent(*polyRight[i], *polyRight[i+1], LS_INFINITE);
		XLine lNext, lPrev, rNext, rPrev;
		BOOL bNext=(i+2<numVerts);
		BOOL bPrev=(i>0);
		if(bNext)
		{
			lNext.StartPoint()=*polyLeft[i+1];
			lNext.EndPoint()=*polyLeft[i+2];
			rNext.StartPoint()=*polyRight[i+1];
			rNext.EndPoint()=*polyRight[i+2];
		}
		if(bPrev) 
		{
			lPrev.StartPoint()=*polyLeft[i-1];
			lPrev.EndPoint()=*polyLeft[i];
			rPrev.StartPoint()=*polyRight[i-1];
			rPrev.EndPoint()=*polyRight[i];
		}

		if(bStairSeg) 
		{ //梯段
			XPoint pt1, pt2;
			rCurrent.StartPoint().Project(&lCurrent, pt1);
			rCurrent.EndPoint().Project(&lCurrent, pt2);
			XLine lnLeftSeg;
			if((pt1&lCurrent)!=PR_INSIDE)
				lnLeftSeg.StartPoint()=lCurrent.StartPoint();
			else 
				lnLeftSeg.StartPoint()=pt1;
			if((pt2&lCurrent)!=PR_INSIDE)
				lnLeftSeg.EndPoint()=lCurrent.EndPoint();
			else
				lnLeftSeg.EndPoint()=pt2;
			if(!CT_IsExactSameDrt(lCurrent.Direction(), lnLeftSeg.Direction(), _angSnap))
				return Acad::eInvalidInput;
			TDbLineStair *pStair=new TDbLineStair;
			pStair->setPropertiesFrom(this);
			pStair->SetLocation(lnLeftSeg.StartPoint());
			pStair->SetElevation(nElev);
			pStair->SetStepHeight(m_nStepHeight);
			pStair->SetStepWidth(m_nStepWidth);
            pStair->SetAscent(IsAscent());
			pStair->SetAlongWall(0, bLeftWall);
			pStair->SetAlongWall(1, bRightWall);
            double nLeftLen=lnLeftSeg.GetLength();
			int nStepNum=TNumeric(nLeftLen/m_nStepWidth).AsInt();
            if(!IsAscent()) nStepNum++;
			if(nStepNum*m_nStepHeight>nSegHeight+_DIST_SNAP) 
			{//基线太长了
				nStepNum = AS_INT(nSegHeight/m_nStepHeight); //按照四舍五入
				pStair->SetStepHeight(nSegHeight/nStepNum);
			}
			nSegHeight -= nStepNum*pStair->GetStepHeight();
			if(nSegHeight<2*m_nStepHeight) 
			{
				pStair->SetStepHeight((nSegHeight+nStepNum*m_nStepHeight)/nStepNum);
				nSegHeight=0.0;
			}
			pStair->SetStepNum(nStepNum);
			pStair->SetRotation(CT_std_angle(lnLeftSeg.Direction()-PI/2));
			pStair->SetStairWidth(m_nStairWidth);
			pStair->SetBeamHeight(GetBeamHeight());
			pStair->SetBeamThick(GetBeamThick());
			pStair->SetSlabThick(GetSlabThick());
			pStair->SetOnGround(IsOnGround());
			pStair->SetSlant(HasSlant());
			pStair->SetSideBeam(0, HasSideBeam(0));
			pStair->SetSideBeam(1, HasSideBeam(1));
			pStair->Set2DFlag(SF_NOSECT);

			//add by xlc on 080718
			if(IsArrow())
			{
				XPoint ptStartMid;
				ads_polar(pStair->GetLocation(),pStair->GetRotation(),pStair->GetStairWidth()*0.5,ptStartMid);
				ptStartMid.z=0;

				XPoint ptStart;
				if(!bPrev)//首梯段
				{
					if(m_nStairFlag==SF_TOP)
					{
						ads_polar(ptStartMid,pStair->GetRotation()+PI*0.5,pStair->GetStepWidth(),ptStart);
						polyArrowDown.AppendNode(ptStart);
					}
					else
					{
						ads_polar(ptStartMid,pStair->GetRotation()-PI*0.5,pStair->GetStepWidth()*0.5,ptStart);
						polyArrowUp.AppendNode(ptStart);
					}
				}
				if(m_nStairFlag!=SF_TOP)
				{
					double	dSectElev=GetSectElev();
					if(IsAscent()&&fabs(dSectElev-dHeight)<0.2*pStair->GetStepHeight())
					{
						if(dSectElev-dHeight>_DIST_SNAP)
						{
							dSectElev=dHeight+0.3*pStair->GetStepHeight();
						}
						else
						{
							dSectElev=dHeight-0.3*pStair->GetStepHeight();
						}
					}
					if(!bEnd&&dSectElev>dHeight&&dSectElev<dHeight+pStair->GetStairHeight())		//剖切当前梯段
					{
						bEnd=TRUE;
						if(m_nStairFlag==SF_FIRST)
							pStair->Set2DFlag(SF_1SECT);
						else
							pStair->Set2DFlag(SF_2SECT);

						double dist=(dSectElev-dHeight)*pStair->GetStairLength()/pStair->GetStairHeight();//剖切位置到当前梯段顶点的距离
						if(!IsAscent())
						{
							dist=(dSectElev-dHeight)*(pStair->GetStepWidth())/pStair->GetStepHeight();
							if(dist>pStair->GetStairLength())
							{
								dist -= pStair->GetStepWidth();
							}
						}
						
						ads_polar(ptStartMid,pStair->GetRotation()+PI*0.5,dist-pStair->GetStepWidth()*0.5,ptStart);
						polyArrowUp.AppendNode(ptStart);

						ads_polar(ptStartMid,pStair->GetRotation()+PI*0.5,dist+pStair->GetStepWidth()*0.5,ptStart);
						polyArrowDown.AppendNode(ptStart);
					}
					else if(GetSectElev()>dHeight+pStair->GetStairHeight())
					{
						dHeight+=pStair->GetStairHeight();
					}
				}
				if(!bNext
					||nSegHeight<_DIST_SNAP		//add by xlc on 090428梯段结束时路径还有边未结束
					)//末梯段
				{
					ads_polar(ptStartMid,pStair->GetRotation()+PI*0.5,pStair->GetStairLength()+pStair->GetStepWidth()*0.5,ptStart);
					polyArrowDown.AppendNode(ptStart);
				}
			}
			dStepWidth=pStair->GetStepWidth();
			dStepHeight=pStair->GetStepHeight();

			if(m_nStairFlag==SF_TOP)
				pStair->SetHas3D(FALSE);

			// 设置图层
			pStair->SetLayerBeam3d(m_idLayerBeam3d);
			pStair->SetLayerStep3d(m_idLayerStep3d);

			lstComponents.Append(pStair);
			lnPrevTop.StartPoint() = pStair->GetUpLeft2d();
			lnPrevTop.EndPoint() = pStair->GetUpRight2d();

			// 设置扶手路径，拐角处
			if(HasHandRail(OFFSET_LEFT))
			{
				XPoint qt1=pStair->GetLowLeft2d();
				XPoint qt2=pStair->GetUpLeft2d();
				qt1.z=qt2.z=nElev; 
				qt2.z += pStair->GetStairHeight();
				if(!lPolySide.Tail() || lPolySide.Tail()->Distance2d(qt1)>_DIST_SNAP)
					lPolySide.AppendNode(qt1);
				lPolySide.AppendNode(qt2);
			}
			if(HasHandRail(OFFSET_RIGHT)) 
			{
				XPoint qt1=pStair->GetLowRight2d();
				XPoint qt2=pStair->GetUpRight2d();
				qt1.z=qt2.z=nElev; 
				qt2.z += pStair->GetStairHeight();
				if(!rPolySide.Tail() || rPolySide.Tail()->Distance2d(qt1)>_DIST_SNAP)
					rPolySide.AppendNode(qt1);
				rPolySide.AppendNode(qt2);
			}
			
			nElev += pStair->GetStairHeight();
			if(nSegHeight<_DIST_SNAP)
				break;
		} 
		else 
		{ //平台
			if(!bPrev || !bNext)//平台不能在首尾
				return Acad::eInvalidInput;

			XPoint pt1, pt2;
			rNext.StartPoint().Project(&lNext, pt1);
			rNext.EndPoint().Project(&lNext, pt2);
			XLine lnLeftNext;
			if((pt1&lNext)!=PR_INSIDE)
				lnLeftNext.StartPoint()=lNext.StartPoint();
			else
				lnLeftNext.StartPoint()=pt1;
			if((pt2&lNext)!=PR_INSIDE)
				lnLeftNext.EndPoint()=lNext.EndPoint();
			else
				lnLeftNext.EndPoint()=pt2;
			if(!CT_IsExactSameDrt(lNext.Direction(), lnLeftNext.Direction(), _angSnap))
				return Acad::eInvalidInput;

			XLine lnRightNext=lnLeftNext.Offset(m_nStairWidth);
            
			XPoly2D poly2d(1);
			XPoint ptStartMid,ptEndMid;
			if(GetSegType(i-1)==0&&GetSegType(i+1)==0)//前后都是梯段
			{
				poly2d.AppendNode(lnPrevTop.StartPoint());
				poly2d.AppendNode(lnPrevTop.EndPoint());
				poly2d.AppendNode(rCurrent.StartPoint());
				poly2d.AppendNode(rCurrent.EndPoint());
				poly2d.AppendNode(lnRightNext.StartPoint());
				poly2d.AppendNode(lnLeftNext.StartPoint());
				poly2d.AppendNode(lCurrent.EndPoint());
				poly2d.AppendNode(lCurrent.StartPoint());

				ptStartMid = lnPrevTop.MidPoint();
				Midpoint(lnRightNext.StartPoint(),lnLeftNext.StartPoint(),ptEndMid);
			}
			else if(GetSegType(i-1)==0)//前面梯段后面平台
			{
				poly2d.AppendNode(lnPrevTop.StartPoint());
				poly2d.AppendNode(lnPrevTop.EndPoint());
				poly2d.AppendNode(rCurrent.StartPoint());
				poly2d.AppendNode(rCurrent.EndPoint());
				poly2d.AppendNode(lCurrent.EndPoint());
				poly2d.AppendNode(lCurrent.StartPoint());

				ptStartMid = lnPrevTop.MidPoint();
				Midpoint(rCurrent.EndPoint(),lCurrent.EndPoint(),ptEndMid);
			}
			else if(GetSegType(i-1)==1&&GetSegType(i+1)==0)//前面平台后面梯段
			{
				poly2d.AppendNode(rCurrent.StartPoint());
				poly2d.AppendNode(rCurrent.EndPoint());
				poly2d.AppendNode(lnRightNext.StartPoint());
				poly2d.AppendNode(lnLeftNext.StartPoint());
				poly2d.AppendNode(lCurrent.EndPoint());
				poly2d.AppendNode(lCurrent.StartPoint());

				Midpoint(rCurrent.StartPoint(),lCurrent.StartPoint(),ptStartMid);
				Midpoint(lnRightNext.StartPoint(),lnLeftNext.StartPoint(),ptEndMid);
			}
			else//前后都平台
			{
				poly2d.AppendNode(rCurrent.StartPoint());
				poly2d.AppendNode(rCurrent.EndPoint());
				poly2d.AppendNode(lCurrent.EndPoint());
				poly2d.AppendNode(lCurrent.StartPoint());

				Midpoint(rCurrent.StartPoint(),lCurrent.StartPoint(),ptStartMid);
				Midpoint(rCurrent.EndPoint(),lCurrent.EndPoint(),ptEndMid);
			}
			
			//add by xlc on 080718
			if(IsArrow())
			{
				int bAddInt=FALSE;			//添加折点
				XPoint ptInt1,ptInt2;		//平台转折点
				if(!(GetSegType(i-1)==1&&GetSegType(i+1)==1))//前后都是平台除外
				{
					Midpoint(lCurrent.StartPoint(),rCurrent.StartPoint(),ptInt1);
					Midpoint(lCurrent.EndPoint(),rCurrent.EndPoint(),ptInt2);
					bAddInt=TRUE;
				}
				if(bEnd)
				{
					polyArrowDown.AppendNode(ptStartMid);
					if(bAddInt)
					{
						polyArrowDown.AppendNode(ptInt1);
						polyArrowDown.AppendNode(ptInt2);
					}
					polyArrowDown.AppendNode(ptEndMid);
				}
				else
				{
					polyArrowUp.AppendNode(ptStartMid);
					if(bAddInt)
					{
						polyArrowUp.AppendNode(ptInt1);
						polyArrowUp.AppendNode(ptInt2);
					}
					polyArrowUp.AppendNode(ptEndMid);
				}
			}
	
			poly2d.Compress(false);
			if(poly2d.PathArea()<-_DIST_SNAP*_DIST_SNAP) 
			{
				TDbSlab *pSlab = new TDbSlab;
				pSlab->setPropertiesFrom(this);
				pSlab->SetOutline(poly2d);
				pSlab->SetElevation(nElev);
				if(IsAscent()&&IsOnGround()) 
					pSlab->SetThickness(m_nElevation-nElev);
				else
					pSlab->SetThickness(-m_nSlabThick);
				pSlab->setLayer(m_idLayerStep3d);

				int nTest=poly2d.HitTestOnCurve(ptStartMid);
				if(nTest<0)
				{
					int nEdgeIndex=abs(nTest)-1; 
					pSlab->SetVisibilityAt(nEdgeIndex, FALSE);
				}
				nTest=poly2d.HitTestOnCurve(ptEndMid);
				if(nTest<0)
				{
					int nEdgeIndex=abs(nTest)-1; 
					pSlab->SetVisibilityAt(nEdgeIndex, FALSE);
				}

				if(bLeftWall) 
				{ //左边不可见
					XPoint ptTest1, ptTest2, ptTest3;
					ptTest1 = lCurrent.MidPoint();
					Midpoint(lCurrent.EndPoint(), lnLeftNext.StartPoint(), ptTest2);
					Midpoint(lCurrent.StartPoint(), lnPrevTop.StartPoint(), ptTest3);
					int nTest1=poly2d.HitTestOnCurve(ptTest1);
					int nTest2=poly2d.HitTestOnCurve(ptTest2);
					int nTest3=poly2d.HitTestOnCurve(ptTest3);
					if(nTest1<0) 
					{
						int nEdgeIndex=abs(nTest1)-1; 
						pSlab->SetVisibilityAt(nEdgeIndex, FALSE);
					}
					if(nTest2<0 && nTest2!=nTest1)
					{
						int nEdgeIndex=abs(nTest2)-1;
						pSlab->SetVisibilityAt(nEdgeIndex, FALSE);
					}
					if(nTest3<0 && nTest3!=nTest1 && nTest3!=nTest2)
					{
						int nEdgeIndex=abs(nTest3)-1;
						pSlab->SetVisibilityAt(nEdgeIndex, FALSE);
					}
				}
				if(bRightWall) 
				{
					XPoint ptTest1, ptTest2, ptTest3;
					ptTest1 = rCurrent.MidPoint();
					Midpoint(rCurrent.EndPoint(), lnRightNext.StartPoint(), ptTest2);
					Midpoint(rCurrent.StartPoint(), lnPrevTop.EndPoint(), ptTest3);
					int nTest1=poly2d.HitTestOnCurve(ptTest1);
					int nTest2=poly2d.HitTestOnCurve(ptTest2);
					int nTest3=poly2d.HitTestOnCurve(ptTest3);
					if(nTest1<0) 
					{
						int nEdgeIndex=abs(nTest1)-1; 
						pSlab->SetVisibilityAt(nEdgeIndex, FALSE);
					}
					if(nTest2<0 && nTest2!=nTest1)
					{
						int nEdgeIndex=abs(nTest2)-1;
						pSlab->SetVisibilityAt(nEdgeIndex, FALSE);
					}
					if(nTest3<0 && nTest3!=nTest1 && nTest3!=nTest2)
					{
						int nEdgeIndex=abs(nTest3)-1;
						pSlab->SetVisibilityAt(nEdgeIndex, FALSE);
					}
				}
				lstComponents.Append(pSlab);
			}
			if(lnPrevTop.StartPoint().Distance2d(lCurrent.StartPoint())>_DIST_SNAP)
				lPolySide.AppendNode(XPoint(lCurrent.StartPoint().x, lCurrent.StartPoint().y, nElev));
			if(lnLeftNext.StartPoint().Distance(lCurrent.EndPoint())>_DIST_SNAP)
				lPolySide.AppendNode(XPoint(lCurrent.EndPoint().x, lCurrent.EndPoint().y, nElev));
			if(lnPrevTop.EndPoint().Distance2d(rCurrent.StartPoint())>_DIST_SNAP)
				rPolySide.AppendNode(XPoint(rCurrent.StartPoint().x, rCurrent.StartPoint().y, nElev));
			if(lnRightNext.StartPoint().Distance2d(rCurrent.EndPoint())>_DIST_SNAP)
				rPolySide.AppendNode(XPoint(rCurrent.EndPoint().x, rCurrent.EndPoint().y, nElev));
		}
    }
	
	double width=dStepWidth*0.5,height=dStepHeight*0.5;
	if(IsAscent())
	{
		width=0;
		height=0;
	}

	double elevS=0,elevE=0;     //扶手伸出产生的高差
	elevS=m_nRailDist*dStepHeight/dStepWidth;
	elevE=m_nRailDistEnd*dStepHeight/dStepWidth;
	

	if(HasHandRail(OFFSET_LEFT)) 
	{
		lPolySide.Compress(false);
		XPoly2D polyPath0(lPolySide), polyPath;
		polyPath0.SetElevation(0.0);
		
		//modified by whl on 090326
		if(polyPath0.QuickOffset(m_nRailDistToSide+m_nRailWidth/2, polyPath)==RTNORM&&
			polyPath.Length()==lPolySide.Length()&&polyPath.Length()>1) 
		{
			for(int kk=0; kk<polyPath.Length(); kk++) 
				polyPath[kk]->z = lPolySide[kk]->z;
			
			// add by xlc on 080721  扶手伸出距离
			double dir=ads_angle(*polyPath[1],*polyPath[0]);
			XPoint ptA=*polyPath[0],ptB;
			if(m_nRailDist>width+_DIST_SNAP)
			{
				ads_polar(ptA, dir, width, ptB);
				*polyPath.Head() = ptB;
				ads_polar(ptB, dir, m_nRailDist-width, ptB);
				polyPath.InsertNodeAt(0,ptB);
			}
			else
			{
				ads_polar(ptA, dir, m_nRailDist, ptB);
				ptB.z=GetElevation()+height-elevS;
				*polyPath.Head() = ptB;
			}
			dir=ads_angle(*polyPath[polyPath.Length()-2],*polyPath[polyPath.Length()-1]);
			ptA=*polyPath.Tail();
			if(m_nRailDistEnd>width+_DIST_SNAP)
			{
				ads_polar(ptA, dir, width, ptB);
				*polyPath.Tail() = ptB;
				ads_polar(ptB, dir, m_nRailDistEnd-width, ptB);
				polyPath.AppendNode(ptB);
			}
			else
			{
				ads_polar(ptA, dir, m_nRailDistEnd, ptB);
				ptB.z=ptA.z-height+elevE;
				*polyPath.Tail() = ptB;
			}
			
			TDbHandRail *pHand=new TDbHandRail;
			pHand->setPropertiesFrom(this);
			pHand->SetOutline(polyPath);
			pHand->setLayer(m_idLayerHand3d);
			pHand->SetHeight(m_nRailHeight);
			pHand->SetWidth(m_nRailWidth);
			if(m_nStairFlag==SF_TOP)
				pHand->SetHas3D(FALSE);
			lstComponents.Append(pHand);
		}
	}

	if(HasHandRail(OFFSET_RIGHT)) 
	{
		rPolySide.Compress(false);
		XPoly2D polyPath, polyPath0(rPolySide);
		polyPath0.SetElevation(0.0);
		
		//modified by whl on 090326
		if(polyPath0.QuickOffset(-m_nRailDistToSide-m_nRailWidth/2, polyPath)==RTNORM&&
			polyPath.Length()==rPolySide.Length()&&polyPath.Length()>1) 
		{
			for(int kk=0; kk<polyPath.Length(); kk++) 
				polyPath[kk]->z = rPolySide[kk]->z;

			// add by xlc on 080721  扶手伸出距离
			double dir=ads_angle(*polyPath[1],*polyPath[0]);
			XPoint ptA=*polyPath[0],ptB;
			if(m_nRailDist>width+_DIST_SNAP)
			{
				ads_polar(ptA, dir, width, ptB);
				*polyPath.Head() = ptB;
				ads_polar(ptB, dir, m_nRailDist-width, ptB);
				polyPath.InsertNodeAt(0,ptB);
			}
			else
			{
				ads_polar(ptA, dir, m_nRailDist, ptB);
				ptB.z=GetElevation()+height-elevS;
				*polyPath.Head() = ptB;
			}
			dir=ads_angle(*polyPath[polyPath.Length()-2],*polyPath[polyPath.Length()-1]);
			ptA=*polyPath.Tail();
			if(m_nRailDistEnd>width+_DIST_SNAP)
			{
				ads_polar(ptA, dir, width, ptB);
				*polyPath.Tail() = ptB;
				ads_polar(ptB, dir, m_nRailDistEnd-width, ptB);
				polyPath.AppendNode(ptB);
			}
			else
			{
				ads_polar(ptA, dir, m_nRailDistEnd, ptB);
				ptB.z=ptA.z-height+elevE;
				*polyPath.Tail() = ptB;
			}

			TDbHandRail *pHand=new TDbHandRail;
			pHand->setPropertiesFrom(this);
			pHand->SetOutline(polyPath);
			pHand->setLayer(m_idLayerHand3d);
			pHand->SetHeight(m_nRailHeight);
			pHand->SetWidth(m_nRailWidth);
			if(m_nStairFlag==SF_TOP)
				pHand->SetHas3D(FALSE);
			lstComponents.Append(pHand);
		}
	}

	//add by xlc on 080718
	if(IsArrow())
	{
		if(m_nStairFlag!=SF_TOP)
		{
			polyArrowUp.Compress();
			if(polyArrowUp.Length()>1)
			{
				TDbSymbArrow *pArrowUp=new TDbSymbArrow;
				pArrowUp->SetPoly2D(polyArrowUp);
				pArrowUp->setPropertiesFrom(this);

				//add by xlc on 090212
				pArrowUp->SetTextHeight(m_dTextHeight);

				//modify by xlc on 090205
				pArrowUp->SetLayoutRotation(GetLayoutRotation());
		
				//modify by xlc on 090426
				//pArrowUp->SetText(_T("上"));
				pArrowUp->SetText(GetTextUp());

				pArrowUp->SetTextAlign(TDbSymbArrow::kAtSide);	
				pArrowUp->SetTextLocation(pArrowUp->GetDefaultTextLocation());
				pArrowUp->SetTextLayerId(m_idLayerText);
				pArrowUp->SetTextStyleId(m_idTextStyle);
				if(m_idLayerArrow.isValid())
				{
					pArrowUp->setLayer(m_idLayerArrow);
				}
				lstComponents.Append(pArrowUp);
			}
		}
		if(m_nStairFlag!=SF_FIRST)
		{
			polyArrowDown.Reverse();
			polyArrowDown.Compress();
			if(polyArrowDown.Length()>1)
			{
				TDbSymbArrow *pArrowDown=new TDbSymbArrow;
				pArrowDown->SetPoly2D(polyArrowDown);
				pArrowDown->setPropertiesFrom(this);
				
				//add by xlc on 090212
				pArrowDown->SetTextHeight(m_dTextHeight);

				pArrowDown->SetLayoutRotation(GetLayoutRotation());
					
				//modify by xlc on 090426
				//pArrowDown->SetText(_T("下"));
				pArrowDown->SetText(GetTextDown());

				pArrowDown->SetTextAlign(TDbSymbArrow::kAtSide);	
				pArrowDown->SetTextLocation(pArrowDown->GetDefaultTextLocation());
				pArrowDown->SetTextLayerId(m_idLayerText);
				pArrowDown->SetTextStyleId(m_idTextStyle);
				if(m_idLayerArrow.isValid())
				{
					pArrowDown->setLayer(m_idLayerArrow);
				}
				lstComponents.Append(pArrowDown);
			}
		}
		
	}
    return Acad::eOk;
}
void TDbMultiStair::SwapPolySide()
{
	assertWriteEnabled();
	XPoly2D poly;
	GetSidePoly2d(1-m_nPathSide,poly);
	m_nPathSide=1-m_nPathSide;
	m_polySide2d=poly;
}
Acad::ErrorStatus
TDbMultiStair::ExplodeOrDraw3d(XExplodeDraw &dc) const
{
	if(m_nViewCtrl==1)
		return Acad::eOk; //三维被禁止

    assertReadEnabled();
    if(m_nStairFlag==SF_TOP) 
		return Acad::eOk; // nothing is drawn

	DList<TDbEntity> lstComponents;
	Acad::ErrorStatus es = ExplodeTo(lstComponents);
    for(int i=0; i<lstComponents.Length(); i++) {
		TDbEntity *pEnt=lstComponents[i];
		TPushProperty vProp(pEnt, dc);
		if(dc.IsFullExplode()) {
			pEnt->ExplodeOrDraw3d(dc);
		} else {
			dc.DrawEntity(*pEnt);
		}
		if(IsAscent()&&IsOnGround() && pEnt->isKindOf(TDbStair::desc())) { //补充一平台到底部
			TDbStair *pStair=TDbStair::cast(pEnt);
			ASSERT(pStair);
			double nTopElev=pStair->GetElevation();
			double nBotElev=GetElevation();
			XPoint pt[4];
			pt[0]=pStair->GetLowLeft2d();
			pt[1]=pStair->GetLowRight2d();
			pt[2]=pStair->GetUpRight2d();
			pt[3]=pStair->GetUpLeft2d();
			XPoly2D polyOutline(1);
			for(int k=0; k<4; k++)
				polyOutline.AppendNode(pt[k]);
			TDbSlab slab;
			slab.setPropertiesFrom(this);
			slab.SetOutline(polyOutline);
			slab.SetElevation(nBotElev);
			slab.SetThickness(nTopElev-nBotElev);
			TPushProperty vProp(&slab, dc);

			if(dc.IsFullExplode()) {
				slab.ExplodeOrDraw3d(dc);
			} else {
				dc.DrawEntity(slab);
			}
		}
		if(IsAutoRail() && pEnt->isKindOf(TDbHandRail::desc())) {
            dc.SetColorLayer(colorIndex(), m_idLayerRail3d);
			TDbHandRail *pRail=TDbHandRail::cast(pEnt);
			XPoly2D polyPath=pRail->GetOutline();
			double nTotalDist=polyPath.Distance2d();
            int nRailNum=AS_INT(nTotalDist/(IsAscent()? _AS_SYS_UNIT(300.0) : m_nStepWidth));
			if(nRailNum<1)
				nRailNum=1;
			double nStepW=nTotalDist/nRailNum;
			for(int iRail=1; iRail<=nRailNum; iRail++) {
				double nDist=iRail*nStepW;
				XPoint pt;
				double nDir=0.0;
				polyPath.Polar2d(nDist-nStepW/2, pt, &nDir);
				XRectAngle box(pt, _AS_SYS_UNIT(40), _AS_SYS_UNIT(40));
				XPoly2D poly2d;
				box.AsPoly2D(poly2d);
				dc.DrawMesh(poly2d, XVector3D(0,0,m_nRailHeight-_AS_SYS_UNIT(20)));
			}
		}
	}

    return es;
}

bool TDbMultiStair::IsClipMe(const TEntityBase* pEnt)const
{
	if(TDbEntity::IsClipMe(pEnt))
		return true;

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

	return false;
}
Acad::ErrorStatus
TDbMultiStair::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
	if(m_nViewCtrl==2)
		return Acad::eOk; //二维被禁止

    assertReadEnabled();
	Acad::ErrorStatus es=Acad::eOk;
	if(_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0 || 
		g_bOsnapExpl) {
		XPushMemVar<BOOL> bExpl(g_bOsnapExpl, FALSE);
		XPushMemVar<BOOL> bFull(XExplodeStream::m_bFullExplode, TRUE);
		AcDbVoidPtrArray entSet;
		XExplodeStream dcExp(entSet);
		dcExp.SetPropertiesFrom(this);	//add by whl on 060404
		es = ExplodeOrDraw2d(dcExp);
		INT_PTR nQuickMarker=GetQuickMarker();
		int nGsMarker=1; 
		int nCount=entSet.length();
		for(int i=0; i<nCount; i++) {
			AcDbEntity *pEnt=(AcDbEntity *)entSet[i];
			dc.SetSelectionMarker(nGsMarker);
			nGsMarker++;
            if(nQuickMarker && (nGsMarker-1)!=nQuickMarker) //用于捕捉时加速
                continue;

			dc.DrawEntity(*pEnt);
            if(nQuickMarker && (nGsMarker-1)==nQuickMarker)
                break;
		}
		ReleaseEntSet(entSet);
	} else {
		DList<TDbEntity> lstComponents;
		es = ExplodeTo(lstComponents);
		DStack<TDbHandRail> hands;
		DStack<TDbStair> stairs;
		DStack<TDbSlab> slabs;
		DStack<TDbSymbArrow> symbArrows;
		for(int i=0; i<lstComponents.Length(); i++) {
			TDbEntity *pEnt=lstComponents[i];
			if(pEnt->isKindOf(TDbHandRail::desc()))
				hands.Append((TDbHandRail *)pEnt);
			else if(pEnt->isKindOf(TDbStair::desc()))
				stairs.Append((TDbStair *)pEnt);
			else if(pEnt->isKindOf(TDbSlab::desc()))
				slabs.Append((TDbSlab *)pEnt);

			//add by xlc on 080718
			else if(pEnt->isKindOf(TDbSymbArrow::desc()))
				symbArrows.Append((TDbSymbArrow*)pEnt);
		}

		int nHit=0;
// 		XPoint ptHitLeft2d, ptHitRight2d;
// 		if(IsManualSectPos()) {
// 			int nHitLeft=HitTestSectPos(0, stairs, ptHitLeft2d);
// 			int nHitRight=HitTestSectPos(1, stairs, ptHitRight2d);
// 			if(nHitLeft==nHitRight && nHitLeft>0)
// 				nHit=nHitLeft;
// 		}

		//add by xlc on 080718
		if(IsArrow())
		{
			for(int i=0;i<symbArrows.Length();i++)
			{
				TDbSymbArrow *pSymbArrow=symbArrows[i];
				if(dc.IsFullExplode())
				{
					TPushProperty vProp(pSymbArrow, dc);
					pSymbArrow->ExplodeOrDraw2d(dc);
				}
				else
					dc.DrawEntity(*pSymbArrow);
			}
		}

		//add by xlc on 080718
		double lSectPos,rSectPos;
		XPoint ptLeft2d,ptRight2d;
		BOOL bSect=CalSectPos(stairs,lSectPos,rSectPos,ptLeft2d,ptRight2d);
		int nSectStair=GetSectStairPos(stairs);

		TDbStair *pStair1=stairs.Head();

		//del by xlc on 080718
		/*if(pStair1 && !database()) { //绘制箭头
			pStair1->SetArrow(TRUE);
		}*/

		if(m_nStairFlag==SF_FIRST && pStair1)
		{ //首层，只绘制第一个梯段和扶手。如果定义剖切位置，则由剖切位置决定
			
			// modified by xlc on 080718 
			/*if(nHit) 
				pStair1=stairs[nHit-1];
			pStair1->Set2DFlag(SF_1SECT);
			if(nHit) {
				XDirectionCurve lCurve=pStair1->GetSideCurve2d(0);
				XDirectionCurve rCurve=pStair1->GetSideCurve2d(1);
				pStair1->SetSectionPos(0, lCurve.PathDistance(ptHitLeft2d)/lCurve.Length());
				pStair1->SetSectionPos(1, rCurve.PathDistance(ptHitRight2d)/rCurve.Length());
			}*/
			if(bSect && nSectStair>=0)
			{
				pStair1=stairs[nSectStair];
				pStair1->SetSectionPos(0, lSectPos);
				pStair1->SetSectionPos(1, rSectPos);
				pStair1->Set2DFlag(SF_1SECT);
				nHit=nSectStair+1;
			}

			for(int k=0; k<hands.Length(); k++) {
				TDbHandRail *pHand=hands[k];
				pHand->setPropertiesFrom(this);
				pHand->SetTempStair(pStair1);
				pStair1->AddTempRail(pHand);
				if(dc.IsFullExplode())
					pHand->ExplodeOrDraw2d(dc);
				else
					dc.DrawEntity(*pHand);
			}

			if(nHit) 
			{
				for(int iii=0; iii<nHit; iii++) 
				{
					TDbStair *pStair=stairs[iii];
					if(iii!=nHit) { //加入相关扶手信息, nHit已经加入过
						for(int kk=0; kk<hands.Length(); kk++)
							pStair->AddTempRail(hands[kk]);
					}
					if(dc.IsFullExplode())
						pStair->ExplodeOrDraw2d(dc);
					else
						dc.DrawEntity(*pStair);
				}
				int slabNum=0,stairNum=nHit;
				for(i=0;i<m_lstSegType.Length(),stairNum>0;i++)
				{
					if(GetSegType(i)==0)
					{
						stairNum--;
					}
					else
					{
						slabNum++;
					}
				}
				// 绘制平台
				for(iii=0; iii<slabNum; iii++) 
				{
					if(iii<slabs.Length())
					{
						TDbSlab *pSlab=slabs[iii];
						for(int kk=0; kk<hands.Length(); kk++)
							pSlab->AddTempRail(hands[kk]);
						if(dc.IsFullExplode())
							pSlab->ExplodeOrDraw2d(dc);
						else
							dc.DrawEntity(*pSlab);
					}
				}
			}
			else 
			{
				if(dc.IsFullExplode())
					pStair1->ExplodeOrDraw2d(dc);
				else
					dc.DrawEntity(*pStair1);
			}
		} 
		else if(pStair1)
		{ // 中间层或顶层
			
			//modified by xlc on 080718
			/*if(nHit)
			{
				pStair1=stairs[nHit-1];
				XDirectionCurve lCurve=pStair1->GetSideCurve2d(0);
				XDirectionCurve rCurve=pStair1->GetSideCurve2d(1);
				double nRatio1=lCurve.PathDistance(ptHitLeft2d)/lCurve.Length(),
					nRatio2=rCurve.PathDistance(ptHitRight2d)/rCurve.Length();
				pStair1->SetSectionPos(0, nRatio1);
				pStair1->SetSectionPos(1, nRatio2);
			}
			if(m_nStairFlag==SF_MIDDLE)
				pStair1->Set2DFlag(SF_2SECT);*/
			if(bSect && m_nStairFlag!=SF_TOP && nSectStair>=0)
			{
				pStair1=stairs[nSectStair];
				pStair1->SetSectionPos(0, lSectPos);
				pStair1->SetSectionPos(1, rSectPos);
				pStair1->Set2DFlag(SF_2SECT);
				if(m_nStairFlag==SF_TOP)
				{
					nHit=0;
				}
				else
				{	
					nHit=nSectStair+1;
				}
			}

			for(int k=0; k<hands.Length(); k++)
			{
				TDbHandRail *pHand=hands[k];
				pHand->setPropertiesFrom(this);
				if(m_nStairFlag==SF_MIDDLE)
					pHand->SetTempStair(pStair1);
				for(int kk=0; kk<stairs.Length(); kk++)
					stairs[kk]->AddTempRail(pHand);
				for(kk=0; kk<slabs.Length(); kk++) 
					slabs[kk]->AddTempRail(pHand);
				if(dc.IsFullExplode())
					pHand->ExplodeOrDraw2d(dc);
				else
					dc.DrawEntity(*pHand);
			}

			int count=0;
            for(k=0; k<stairs.Length(); k++)
			{
				if(dc.IsFullExplode())
					stairs[k]->ExplodeOrDraw2d(dc);
				else
					dc.DrawEntity(*stairs[k]);

				//为JIG服务
				count+=stairs[k]->GetStepNum();
				if((m_iActiveStep==0&&k==stairs.Length()-1)||//最后一个梯段
					(m_iActiveStep==1&&k==stairs.Length()-2))//倒数第二个梯段
				{
					TDbLineStair*pStair=(TDbLineStair*)stairs[k];
					TDbText *pText=new TDbText;
					pStair->setPropertiesFrom(this);
					pText->SetHeight(GetStepWidth(),FALSE);
					if(k>0)
						pText->SetText(XString(_T("%d,%d/%d"),(int)pStair->GetStepNum(),count,(int)GetTotalStepNum()));
					else
						pText->SetText(XString(_T("%d/%d"),count,(int)GetTotalStepNum()));
					pText->SetStyleId(InitTextStyle(TS_DIM));
					pText->SetLayoutRotation(pStair->GetRotation());
					XPoint ptMid;
					Midpoint(pStair->GetUpLeft2d(),pStair->GetUpRight2d(),ptMid);
					pText->SetAlignment(XExplodeDraw::kBottomCenter);
					pText->SetLocation(ptMid);
					dc.DrawEntity(*pText);
					delete pText;
				}
			}
            for(k=0; k<slabs.Length(); k++) 
			{
				slabs[k]->setPropertiesFrom(this);
				if(dc.IsFullExplode())
					slabs[k]->ExplodeOrDraw2d(dc);
				else
					dc.DrawEntity(*slabs[k]);
			}
		}
	}
	
    return es;
}

Adesk::UInt8 TDbMultiStair::GetTotalStepNum() const
{
	double nHeight=GetStairHeight();
	double nStepHeight=GetStepHeight();
	int nStepNum=AS_INT(nHeight/nStepHeight);
	return (Adesk::UInt8)nStepNum;
}

//看剖切位置命中的目标，ptHit为剖切位置，返回值：0－没有命中，否则为命中的第n个梯段
int TDbMultiStair::HitTestSectPos(int nSide, const DList<TDbStair> &stairs, XPoint &ptHit2d) const
{
	XPoly2D polySide;
	GetSidePoly2d(nSide, polySide);
	double nPathDist=nSide? m_rSectPos : m_lSectPos;
	if(nPathDist<0.0 || nPathDist>polySide.Distance2d())
		return 0;
	polySide.Polar2d(nPathDist, ptHit2d);
	ptHit2d.z=0;

	for(int i=0; i<stairs.Length(); i++) {
		const TDbStair &rStair=stairs[i];
		XDirectionCurve cv=rStair.GetSideCurve2d(nSide);

		if((ptHit2d&cv.GetCurve())==PR_INSIDE)
			return (i+1);
	}
	return 0;
}

//看剖切位置命中的目标，ptHit为剖切位置，返回值：0－没有命中，否则为命中的第n个梯段
int TDbMultiStair::HitTestSectPos(int nSide, XPoint &ptHit2d) const
{
	XPoly2D polySide;
	GetSidePoly2d(nSide, polySide);
	double nPathDist=nSide? m_rSectPos : m_lSectPos;

	if(!IsManualSectPos())
	{
		DList<TDbEntity> lstComponents;
		ExplodeTo(lstComponents);
		DStack<TDbStair> stairs;
		for(int i=0; i<lstComponents.Length(); i++) {
			TDbEntity *pEnt=lstComponents[i];
			if(pEnt->isKindOf(TDbStair::desc()))
				stairs.Append((TDbStair *)pEnt);
		}
		TDbStair *pStair=stairs.Head();
		
		//add by xlc on 090518 打开旧图时崩溃
		if (pStair==NULL)
		{
			return 0;
		}

		if(m_nStairFlag==SF_FIRST)
			pStair->Set2DFlag(SF_1SECT);
		else if(m_nStairFlag==SF_MIDDLE)
			pStair->Set2DFlag(SF_2SECT);
		double lRatio=pStair->GetSectionPos(0);
		double rRatio=pStair->GetSectionPos(1);
		XDirectionCurve lCurve=pStair->GetSideCurve2d(0),
			rCurve=pStair->GetSideCurve2d(1);
		XPointDir2d ptLeft, ptRight;
		lCurve.Polar(lRatio*lCurve.GetLength(), ptLeft);
		rCurve.Polar(rRatio*rCurve.GetLength(), ptRight);
		

		XPoly2D lPoly, rPoly;
		GetSidePoly2d(0, lPoly);
		GetSidePoly2d(1, rPoly);

		nPathDist = nSide?rPoly.PathDistance2d(ptRight):lPoly.PathDistance2d(ptLeft);
	}

	if(nPathDist<0.0 || nPathDist>polySide.Distance2d())
		return 0;
	polySide.Polar2d(nPathDist, ptHit2d);
	ptHit2d.z=0;

	DList<TDbEntity> lstComponents;
	ExplodeTo(lstComponents);
	DStack<TDbStair> stairs;
	for(int i=0; i<lstComponents.Length(); i++) {
		TDbEntity *pEnt=lstComponents[i];
		if(pEnt->isKindOf(TDbStair::desc()))
			stairs.Append((TDbStair *)pEnt);
	}

	for(i=0; i<stairs.Length(); i++) {
		TDbStair *pStair=stairs[i];
		XDirectionCurve cv=pStair->GetSideCurve2d(nSide);

		if((ptHit2d&cv.GetCurve())==PR_INSIDE)
			return (i+1);
	}
	return 0;
}

void TDbMultiStair::GetSidePoly2d(int nSide, XPoly2D &polySide) const
{
	if(nSide==0) {
		if(m_nPathSide) {
			m_polySide2d.QuickOffset(-m_nStairWidth, polySide);
		} else {
			polySide=m_polySide2d; 
		} 
	} else {
		if(m_nPathSide) {
			polySide=m_polySide2d;
		} else {
			m_polySide2d.QuickOffset(m_nStairWidth, polySide);
		} 
	}
}

// 设置缺省的剖切位置
void TDbMultiStair::SetDefaultSectPos()
{
	assertWriteEnabled();
	DList<TDbEntity> lstComponents;
	ExplodeTo(lstComponents);
	DStack<TDbStair> stairs;
	for(int i=0; i<lstComponents.Length(); i++) {
		TDbEntity *pEnt=lstComponents[i];
		if(pEnt->isKindOf(TDbStair::desc()))
			stairs.Append((TDbStair *)pEnt);
	}
	TDbStair *pStair=stairs.Head();
	
	//add by xlc on 090518 打开旧图时崩溃
	if (pStair==NULL)
	{
		return;
	}

	if(m_nStairFlag==SF_FIRST)
		pStair->Set2DFlag(SF_1SECT);
	else if(m_nStairFlag==SF_MIDDLE)
		pStair->Set2DFlag(SF_2SECT);
	double lRatio=pStair->GetSectionPos(0);
	double rRatio=pStair->GetSectionPos(1);
	XDirectionCurve lCurve=pStair->GetSideCurve2d(0),
		rCurve=pStair->GetSideCurve2d(1);
	XPointDir2d ptLeft, ptRight;
	lCurve.Polar(lRatio*lCurve.GetLength(), ptLeft);
	rCurve.Polar(rRatio*rCurve.GetLength(), ptRight);
	

	XPoly2D lPoly, rPoly;
	GetSidePoly2d(0, lPoly);
	GetSidePoly2d(1, rPoly);

	m_lSectPos = lPoly.PathDistance2d(ptLeft);
	m_rSectPos = rPoly.PathDistance2d(ptRight);
}
//add by xlc on 080718
//计算剖切高度和剖切点
BOOL TDbMultiStair::CalSectPos(const DList<TDbStair> &stairs,double &lSectPos,double &rSectPos,XPoint &ptLeft2d,XPoint &ptRight2d)const
{
	if(m_nStairFlag==SF_TOP)
		return FALSE;
	
	int nSectStair=GetSectStairPos(stairs);
	if(nSectStair == -1)						//剖断位置不正确
		return FALSE;

	if(nSectStair>=stairs.Length())
		return FALSE;

	const TDbStair &pStair=stairs[nSectStair];
	XDirectionCurve cvLeft,cvRight;
	cvLeft=pStair.GetSideCurve2d(0);
	cvRight=pStair.GetSideCurve2d(1);
	double height=0;
	for(int i=0;i<nSectStair;i++)
	{
		height+=stairs[i].GetStairHeight();
	}
	double dStairLength=cvLeft.StartPoint().Distance2d(cvLeft.EndPoint());
	double len=(GetSectElev()-height)*dStairLength/pStair.GetStairHeight();//剖切位置点
	double nStepWidth=dStairLength/pStair.GetStepNum();
	
	if(!IsAscent())
	{
		nStepWidth=dStairLength/(pStair.GetStepNum()-1);
		double nStepHeight=pStair.GetStepHeight();
		len=(GetSectElev()-height)*nStepWidth/nStepHeight;
		if(len>dStairLength)
		{
			len -= nStepWidth;
		}
	}
	double width=cvLeft.StartPoint().Distance2d(cvRight.StartPoint())*0.5;
	double dLen=0;					//投影长
	if(fabs(cos(m_dSectRotation))>_DIST_SNAP)
	{
		dLen=width*tan(m_dSectRotation);
	}
	else
	{
		return FALSE;
	}

	if((len+fabs(dLen)+nStepWidth/3.0 )>dStairLength 
		||(len-fabs(dLen)-nStepWidth/3.0 )<_DIST_SNAP)		//剖断线转角过大，不能与梯段两边都相交
	{
		double dist=(len<dStairLength-len)?len:dStairLength-len;
		dist -= nStepWidth/2;
	
		if(tan(m_dSectRotation)>_DIST_SNAP)
		{
			dLen=dist;
		}
		else
		{
			dLen=-dist;
		}
	}

	lSectPos=(len-dLen)/dStairLength;
	rSectPos=(len+dLen)/dStairLength;

	XPointDir2d pt;
	cvLeft.Polar(len-dLen, pt);
	ptLeft2d=pt;
	cvRight.Polar(len+dLen, pt);
	ptRight2d=pt;

	return TRUE;
}
int TDbMultiStair::GetSectStairPos(const DList<TDbStair> &stairs)const//剖切梯段
{
	if(GetSectElev()<_DIST_SNAP||GetSectElev()>GetStairHeight()-_DIST_SNAP)
		return -1;
	int nSectStair=-1;
	double height=0;
	for(int i=0; i<stairs.Length();i++)
	{
		double	dSectElev=GetSectElev();
		if(IsAscent()&&fabs(dSectElev-height)<0.2*stairs[i].GetStepHeight())
		{
			if(dSectElev-height>_DIST_SNAP)
			{
				dSectElev=height+0.3*stairs[i].GetStepHeight();
			}
			else
			{
				dSectElev=height-0.3*stairs[i].GetStepHeight();
			}
		}
		if(dSectElev>height&&dSectElev<height+stairs[i].GetStairHeight()+_DIST_SNAP)
		{
			nSectStair=i;
			break;
		}
		else
		{
			height+=stairs[i].GetStairHeight();
		}
	}

	return nSectStair;
}
// 由平面二维点推算命中的相对高度
double TDbMultiStair::HitElevationByPoint2d(const DList<TDbStair> &stairs,XPoint ptHit2d) const
{
	BOOL bHit=FALSE;
	double nElevHit=0.0;
	for(int i=0;i<stairs.Length();i++)
	{
		XDirectionCurve cvLeft1=stairs[i].GetSideCurve2d(0);
		XDirectionCurve cvRight1=stairs[i].GetSideCurve2d(1);
		XPoly2D poly1(1);
		poly1.AppendNode(cvLeft1.StartPoint());
		poly1.AppendNode(cvRight1.StartPoint());
		poly1.AppendNode(cvRight1.EndPoint());
		poly1.AppendNode(cvLeft1.EndPoint());
		
		if((ptHit2d&poly1)!=PR_OUTSIDE)
		{
			XPoint ptPrj;
			cvLeft1.ProjectToMe(ptHit2d, ptPrj);
			if(IsAscent())
				nElevHit+=ptPrj.Distance2d(cvLeft1.StartPoint())/cvLeft1.GetLength()*stairs[i].GetStairHeight();
			else
			{
				double h=ptPrj.Distance2d(cvLeft1.StartPoint())/cvLeft1.GetLength()*stairs[i].GetStairHeight();
				double height=stairs[i].GetStepHeight();
				double num=stairs[i].GetStepNum();
				for(int k=0;k<num;k++)
				{
					if(h>height*k&&h<height*(k+1)+_DIST_SNAP)
					{
						nElevHit+=height*(k+0.5);
						break;
					}
				}
			}
			bHit=TRUE;
			break;
		}
		else
		{
			nElevHit += stairs[i].GetStairHeight();
		}
	}
	if(bHit)
		return nElevHit;
	else
		return 0;
}
//add by xlc on 080722
Acad::ErrorStatus TDbMultiStair::DownGradeSave(int nDrawMode, AcDbVoidPtrArray &entSet, BOOL *bErase)
{
	Acad::ErrorStatus es=Acad::eOk;
	
	//modify by xlc on 090213
// 	if((g_nSaveTArchVer<8&&g_nVersion>3))	//8.0添加扶手伸出距离，剖切高度
// 	{
// 		explode(entSet);
// 		if(bErase)
// 			*bErase=TRUE;
// 	}
//	else
//		es=TDbEntity::DownGradeSave(nDrawMode,entSet,bErase);
	if(g_nSaveTArchVer<8&&g_nSaveTArchVer>5)	//8.0添加扶手伸出距离，剖切高度
	{
		BOOL bFlag=FALSE;
		for(long i=0;i<m_lstSegType.Length();i++)
		{
			int type=*m_lstSegType[i];
			if(!((i%2==0&&type==0)
				 ||(i%2==1&&type==1)))
			{
				bFlag=TRUE;
				break;
			}
		}
		if(bFlag)
		{
			subExplode(entSet);
			if(bErase)
				*bErase=TRUE;
			return es;
		}
		else 
		{
			TDbMultiStair *pNewSet=NULL;
			{
				XPushMemVar<int> vTemp(g_nSaveTArchVer,_TCH_VERSION);//add by whl on 090325，解决8导出7崩溃问题
				pNewSet=(TDbMultiStair*)clone();
			}
			pNewSet->SetManualSectPos(TRUE);
			pNewSet->SetArrow(FALSE);
			
			//modify by xlc on 090618 解决梯段错误不显示时导出T6，04平台下打开崩溃的问题
			//entSet.append(pNewSet);
			DList<TDbEntity> lstComponents;
			ExplodeTo(lstComponents);
			if(lstComponents.Length()>0)
				entSet.append(pNewSet);
			else
				delete pNewSet;

			if(IsArrow())
			{
				//DList<TDbEntity> lstComponents;
				//ExplodeTo(lstComponents);
				for(int i=0; i<lstComponents.Length(); i++) 
				{
					TDbEntity *pEnt=lstComponents[i];
					if(pEnt->isKindOf(TDbSymbArrow::desc()))
					{
						XPushMemVar<int> vTemp(g_nSaveTArchVer,_TCH_VERSION);//add by xlc on 090427，解决8导出7崩溃问题
						entSet.append((TDbSymbArrow*)pEnt->clone());
					}
				}
			}
			
			if(bErase)
				*bErase=TRUE;
			return es;
		}
	}

	es=TDbEntity::DownGradeSave(nDrawMode,entSet,bErase);
	return es;
}
double TDbMultiStair::GetSectStepNum() const
{
	assertReadEnabled();
	double nStepNum=m_dSectElev/GetStepHeight();
	
	return nStepNum+0.5;
}

void TDbMultiStair::SetSectStepNum(double d)
{
	assertWriteEnabled();
	double nSectStepNum=(int)(GetTotalStepNum()/2);
	if(d>0&&d<GetTotalStepNum())
	{
		nSectStepNum=d;
	}
	m_dSectElev=(nSectStepNum-0.5)*m_nStepHeight;
}

//add by xlc 090426，箭头文字，动态数据
CString TDbMultiStair::GetTextUp() const
{
	assertReadEnabled();
	CString sVal(_T("上"));
	const TEntityFields &fd = GetFields();
	fd.GFD(_T("上楼箭头文字"), sVal);
	return sVal;
}

void TDbMultiStair::SetTextUp(const TCHAR *sVal)
{
	assertWriteEnabled();
	TEntityFields &fd = Fields();
	fd.SFD(_T("上楼箭头文字"), sVal);
}
CString TDbMultiStair::GetTextDown() const
{
	assertReadEnabled();
	CString sVal(_T("下"));
	const TEntityFields &fd = GetFields();
	fd.GFD(_T("下楼箭头文字"), sVal);
	return sVal;
}

void TDbMultiStair::SetTextDown(const TCHAR *sVal)
{
	assertWriteEnabled();
	TEntityFields &fd = Fields();
	fd.SFD(_T("下楼箭头文字"), sVal);
}

// cet 2013.9.6 add
CString TDbMultiStair::GetXml(const AcGeMatrix3d& mat) const
{
	CString sXml;
	AcDbVoidPtrArray arrEnts;
	explode(arrEnts);
	int nSize = arrEnts.length();
	for (int i = 0; i < nSize; ++i)
	{
		AcDbEntity *pEnt = (AcDbEntity*)arrEnts[i];
		if (pEnt == NULL)
		{
			continue;
		}
		
		TDbLineStair *pLineStair = TDbLineStair::cast(pEnt);
		if (pLineStair != NULL)
		{
			sXml += pLineStair->GetXml(mat);
			continue;
		}
		
		TDbSlab *pSlab = TDbSlab::cast(pEnt);
		if (pSlab != NULL)
		{
			sXml += pSlab->GetXml(mat);
		}
	}
	ReleaseEntSet(arrEnts);	
	return sXml;
}

/////////////////////////////////////////////////////////////////////////////
void InitDbStair(BOOL bTrue)
{
    if(bTrue) {
        TDbStair::rxInit();
        TDbLineStair::rxInit();
        TDbArcStair::rxInit();
        TDbCurveStair::rxInit();
        TDbRectStair::rxInit();
		TDbMultiStair::rxInit();
        acrxBuildClassHierarchy();
        TDbLineStair::InitMatchProtocol(TRUE);
        TDbArcStair::InitMatchProtocol(TRUE);
        TDbCurveStair::InitMatchProtocol(TRUE);
        TDbRectStair::InitMatchProtocol(TRUE);
		TDbMultiStair::InitMatchProtocol(TRUE);
    } else {
        TDbLineStair::InitMatchProtocol(FALSE);
        TDbArcStair::InitMatchProtocol(FALSE);
        TDbCurveStair::InitMatchProtocol(FALSE);
        TDbRectStair::InitMatchProtocol(FALSE);
		TDbMultiStair::InitMatchProtocol(FALSE);

		deleteAcRxClass(TDbMultiStair::desc());
        deleteAcRxClass(TDbRectStair::desc());
        deleteAcRxClass(TDbCurveStair::desc());
        deleteAcRxClass(TDbLineStair::desc());
        deleteAcRxClass(TDbArcStair::desc());
        deleteAcRxClass(TDbStair::desc());
    }
}