#include "stdafx.h"
#include "resource.h"
#include "StepDlg.h"
#include "AscentDlg.h"
#include "stepnew.h"
#include "inputpoly.h"
#include "ascentcreatedlg.h"
#include "math.h"//  [11/22/2007 nsh]

using namespace TchSubExport;

// extern GEOAPI int DragPickSet(PickSet &ss, XPoint &ptBase);
///////////////////////////////////////////
// Command: 台阶
// 必须在WCS下
#define  LENGTH 1600
static int CompareInt(const int *p1, const void *p2)
{
	if (*p1==*(const int *)p2)
		return 0;
	return 1;
}
// extern GEOAPI int FindNearestEdge(const XPoly2D &poly, const XPoint &ptEdge);
int GetOpenPoly(const TCHAR *pMsg, XPoly2D &poly2d, Entity &entRet);
extern int SearchBalcony(XPoly2D &polyBalc, XPoly2D &polyWall, XPoly2D &polyOutline);
TPolyEdJig2::TPolyEdJig2(AcDbPolyline *pElev)
{
	m_pDrawEnt=pElev;
}


AcEdJig::DragStatus 
TPolyEdJig2::GetPoint(XPoint &pt)
{
	AcGePoint3d ptBase;
	m_pDrawEnt->getPointAt(m_pDrawEnt->numVerts()-1, ptBase);
	//if (m_nOperCode!=kArcMidPoint m_nOperCode!=kArcRadius)
	//    return acquirePoint(pt);
	return acquirePoint(pt, ptBase);
}

// 开始执行拖动
int TPolyEdJig2::DoIt(int *keyIndex)
{
	XPoly2D poly2d;
	PolyConvert(*m_pDrawEnt, poly2d);
	if (m_nOperCode==kLinePoint || m_nOperCode==kArcPoint) {
		m_ptResult=*poly2d.Tail();
	} else if (m_nOperCode==kArcMidPoint) { // MidPoint
		XCurveSegment cv;
		poly2d.Nth(poly2d.TotalSegments()-1, cv);
		m_ptResult=cv.MidPoint();
	} 
	int nRet = TSymbEdJig::DoIt(keyIndex);
	return nRet;
}


// 更新实体数据
Adesk::Boolean TPolyEdJig2::update()
{
	Adesk::Boolean bRet=Adesk::kTrue;
	XPoly2D poly2d;
	PolyConvert(*m_pDrawEnt, poly2d);
	if (m_nOperCode==kLinePoint || m_nOperCode==kArcPoint) {
		//*poly2d.Tail()=m_ptResult;
	} else if (m_nOperCode==kArcMidPoint) {
		XDirectionCurve cv;
		poly2d.Nth(poly2d.TotalSegments()-1, cv);
		XCurveSegment seg;
		seg = XArc(cv.StartPoint(), m_ptResult, cv.EndPoint());
		if (!!seg) {
			if (seg.StartPoint().Distance(cv.StartPoint())>_DIST_SNAP)
			{
				// 2010-3-15 17:22 wubo
				// 移植Geo
				seg.SetBulge(-seg.GetBulge());
			}
			// *poly2d.bulges[poly2d.Length()-2]=seg.GetBulge();
			poly2d.SetBulge(poly2d.Length()-2, seg.GetBulge());
		}
	} else if (m_nOperCode==kArcRadius) {
		XPoint ptBase, ptPrev;
		int numVert=m_pDrawEnt->numVerts();
		m_pDrawEnt->getPointAt(numVert-1, (AcGePoint3d &)ptBase);
		m_pDrawEnt->getPointAt(numVert-2, (AcGePoint3d &)ptPrev);
		double nChordLen=ptBase.Distance2d(ptPrev);
		double nRadius=ptBase.Distance2d(m_ptResult);
		if (nChordLen<2.0*nRadius+1.0E-6) {
			double bulge=2.0*asin(nChordLen/2.0/nRadius);
			if (XLine(ptPrev, ptBase).OnWhichSide(m_ptResult)==OFFSET_LEFT)
				bulge = -bulge;
			//*poly2d.bulges[poly2d.Length()-2]=bulge;
			poly2d.SetBulge(poly2d.Length()-2, bulge);
		}
	}
	PolyConvert(poly2d, *m_pDrawEnt);
	return bRet;
}

AcDbEntity* TPolyEdJig2::entity() const
{

	return (AcDbEntity *)m_pDrawEnt;
}
int DragInputPoly(XPoint ptStart, XPoly2D &poly2dRet)
{
	AcDbPolyline pline;
	pline.addVertexAt(0, ptStart);
	TPolyEdJig2 jig(&pline);
	//add by xlc on 090505  06以下平台资源冲突
	CAcModuleResourceOverride resOverride(acedGetAcadResourceInstance());

	jig.SetPrompt(_T("\n直段下一点或 [弧段(A)/回退(U)]<结束>: "));
	jig.SetOperCode(TPolyEdJig2::kLinePoint);
	jig.SetKeyword(_T("A U"));
	while(1) {
		int nKeyIndex=0;
		int nRetCode=jig.DoIt(&nKeyIndex);
		if (nRetCode==RTNORM) {
			pline.addVertexAt(pline.numVerts(), (AcGePoint2d &)jig.GetPickPoint());
			if (jig.GetOperCode()==TPolyEdJig2::kArcPoint) {
				TPolyEdJig2 jig1(&pline);
				jig1.SetOperCode(TPolyEdJig2::kArcMidPoint);
				jig1.SetPrompt(_T("\n点取弧上一点或 [输入半径(R)]:"));
				jig1.SetKeyword(_T("R"));
				int nKeyIdx;
				int nRetCode1=jig1.DoIt(&nKeyIdx);
				if (nRetCode1==RTKWORD) {
					TPolyEdJig2 jig2(&pline);
					jig2.SetOperCode(TPolyEdJig2::kArcRadius);
					jig2.SetPrompt(_T("\n输入半径(光标位置确定弧的方向):"));
					jig2.DoIt();
				}
			} //else { //直段
			jig.SetPrompt(_T("\n直段下一点或 [弧段(A)/回退(U)]<结束>: "));
			jig.SetOperCode(TPolyEdJig2::kLinePoint);
			jig.SetKeyword(_T("A U"));
			//}
		} else if (nRetCode==RTKWORD) {
			if (jig.GetOperCode()==TPolyEdJig2::kLinePoint) {
				if (nKeyIndex==0) {
					jig.SetOperCode(TPolyEdJig2::kArcPoint);
					jig.SetPrompt(_T("\n弧段下一点或 [直段(L)/回退(U)]<结束>: "));
					jig.SetKeyword(_T("L U"));
				} else if (nKeyIndex==1) {
					int numVert=pline.numVerts();
					if (numVert>1) {
						pline.removeVertexAt(numVert-1);
						pline.setBulgeAt(numVert-2, 0.0);
					}
				}
			} else if (jig.GetOperCode()==TPolyEdJig2::kArcPoint) {
				if (nKeyIndex==0) {
					jig.SetOperCode(TPolyEdJig2::kLinePoint);
					jig.SetPrompt(_T("\n直段下一点或 [弧段(A)/回退(U)]<结束>: "));
					jig.SetKeyword(_T("A U"));
				} else if (nKeyIndex==1) {
					int numVert=pline.numVerts();
					if (numVert>1) {
						pline.removeVertexAt(numVert-1);
						pline.setBulgeAt(numVert-2, 0.0);
					}
				}
			} 
		} else if (nRetCode==RTNONE) {
			break;
		} else if (nRetCode==RTCAN) {
			return RTERROR;
		}
	}

	int numVert=pline.numVerts();
	if (numVert<2) 
		return RTERROR;
	PolyConvert(pline, poly2dRet);
	return RTNORM;
}

int DragInputPoly(XPoint ptStart, XPoly2D &poly2dRet, CString strLayer)
{
	AcDbPolyline pline;
	pline.addVertexAt(0, ptStart);
	AssureLayer(strLayer, LAYSTAT_UNLOCK);
	pline.setLayer(strLayer);
	TPolyEdJig2 jig(&pline);
	//add by xlc on 090505  06以下平台资源冲突
	CAcModuleResourceOverride resOverride(acedGetAcadResourceInstance());

	jig.SetPrompt(_T("\n直段下一点或 [弧段(A)/回退(U)]<结束>: "));
	jig.SetOperCode(TPolyEdJig2::kLinePoint);
	jig.SetKeyword(_T("A U"));
	while(1) {
		int nKeyIndex=0;
		int nRetCode=jig.DoIt(&nKeyIndex);
		if (nRetCode==RTNORM) {
			pline.addVertexAt(pline.numVerts(), (AcGePoint2d &)jig.GetPickPoint());
			if (jig.GetOperCode()==TPolyEdJig2::kArcPoint) {
				TPolyEdJig2 jig1(&pline);
				jig1.SetOperCode(TPolyEdJig2::kArcMidPoint);
				jig1.SetPrompt(_T("\n点取弧上一点或 [输入半径(R)]:"));
				jig1.SetKeyword(_T("R"));
				int nKeyIdx;
				int nRetCode1=jig1.DoIt(&nKeyIdx);
				if (nRetCode1==RTKWORD) {
					TPolyEdJig2 jig2(&pline);
					jig2.SetOperCode(TPolyEdJig2::kArcRadius);
					jig2.SetPrompt(_T("\n输入半径(光标位置确定弧的方向):"));
					jig2.DoIt();
				}
			} //else { //直段
			jig.SetPrompt(_T("\n直段下一点或 [弧段(A)/回退(U)]<结束>: "));
			jig.SetOperCode(TPolyEdJig2::kLinePoint);
			jig.SetKeyword(_T("A U"));
			//}
		} else if (nRetCode==RTKWORD) {
			if (jig.GetOperCode()==TPolyEdJig2::kLinePoint) {
				if (nKeyIndex==0) {
					jig.SetOperCode(TPolyEdJig2::kArcPoint);
					jig.SetPrompt(_T("\n弧段下一点或 [直段(L)/回退(U)]<结束>: "));
					jig.SetKeyword(_T("L U"));
				} else if (nKeyIndex==1) {
					int numVert=pline.numVerts();
					if (numVert>1) {
						pline.removeVertexAt(numVert-1);
						pline.setBulgeAt(numVert-2, 0.0);
					}
				}
			} else if (jig.GetOperCode()==TPolyEdJig2::kArcPoint) {
				if (nKeyIndex==0) {
					jig.SetOperCode(TPolyEdJig2::kLinePoint);
					jig.SetPrompt(_T("\n直段下一点或 [弧段(A)/回退(U)]<结束>: "));
					jig.SetKeyword(_T("A U"));
				} else if (nKeyIndex==1) {
					int numVert=pline.numVerts();
					if (numVert>1) {
						pline.removeVertexAt(numVert-1);
						pline.setBulgeAt(numVert-2, 0.0);
					}
				}
			} 
		} else if (nRetCode==RTNONE) {
			break;
		} else if (nRetCode==RTCAN) {
			return RTERROR;
		}
	}

	int numVert=pline.numVerts();
	if (numVert<2) 
		return RTERROR;
	PolyConvert(pline, poly2dRet);
	return RTNORM;
}

// 输入多段线
int GetOpenPoly(const TCHAR *pMsg, XPoly2D &poly2d, Entity &entRet)
{
	XString szPrompt;
	if (pMsg)
		szPrompt << pMsg;
	else szPrompt << _T("\n曲线起点<退出>:");
	//szPrompt << _T("或 [点取图中曲线(P)/点取参考点(R)]<退出>:");
	XPoint ptStart;

	int nCode;
	//INITGET_BEG(0, _T("P R"));
	nCode=ads_getpoint(NULL, szPrompt, ptStart);
	//INITGET_END();
	if (nCode==RTKWORD) {
		XString sKeyword;
		VERIFY(ads_getinput(sKeyword)==RTNORM);
		if (sKeyword[0]==_T('R')) {
			XPoint ptRef;
			if (ads_getpoint(NULL, _T("\n输入参考点<退出>:"), ptRef)!=RTNORM)
				return RTERROR;
			if (ads_getpoint(ptRef, _T("\n曲线起点<退出>:"), ptStart)!=RTNORM)
				return RTERROR;
			ptStart=Ucs2Wcs(ptStart);
			nCode=DragInputPoly(ptStart, poly2d);
		} else {
			RBList mask(RTDXF0, _T("POLYLINE,LWPOLYLINE,LINE,ARC"), NULL);
			Entity ent;
LAB_RESELECT:
			if ((nCode=ent.FilterSelect(_T("\n选择一曲线(LINE/ARC/PLINE):"), mask))!=RTNORM)
				return RTERROR;
			if (ent.Is(_T("LINE")) || ent.Is(_T("ARC"))) {
				XCurveSegment cv(ent);
				poly2d.Reset();
				cv.AsPoly2D(poly2d);
			} else {
				XPoly2D poly(ent);
				if (!!poly) {
					poly2d=poly;
				} else {
					adsout << _T("\n无效的选择!");
					goto LAB_RESELECT;
				}
			}
			entRet=ent;
		}
	} else if (nCode==RTNORM) {
		ptStart=Ucs2Wcs(ptStart);
		nCode=DragInputPoly(ptStart, poly2d);
	} else { //
		return nCode;
	}

	return nCode;
}
/*void Poly2Step()
{
XPoly2D polyRail, poly(1);
Entity entRet;
if (GetOpenPoly2D(_T("\n台阶平台轮廓线的起点"), polyRail, entRet)==RTNORM) {
//XPoly2D polyRail(ent), poly(1);
if (!polyRail || polyRail.flag>1) 
return;
polyRail.Compress();

XScreenDc dc(1,1);
DList<int> lstEdgeIndex;
if (!polyRail.IsClosed()) {
XScreenDc dc0;
XPoly2D polyTemp(polyRail);
polyTemp.TransUCS(Groups(0), Groups(1));
dc0 << polyTemp;

XPoly2D polyWall(0);
if (SearchBalcony(polyRail, polyWall, poly)!=RTNORM) {
ads_redraw(NULL,0);
return;
}

for(int n=0; n<polyWall.TotalSegments(); n++) {
XCurveSegment cvSeg;
polyWall.Nth(n, cvSeg);
XPoint ptEdge = cvSeg.MidPoint();
int nEdge=FindNearestEdge(poly, ptEdge);
if (nEdge>=0 && !lstEdgeIndex.FindNode(&nEdge, CompareInt)) {
lstEdgeIndex.Append(new int(nEdge));
XCurveSegment seg;
poly.Nth(nEdge, seg);
dc << seg;
}
}
} else {
poly=polyRail;
if (poly.PathArea()>0) //确保逆时针
poly.Reverse();
}


while(1) {
XPushVar<int> tVar(_T("OSMODE"), OS_NEA);
XPoint ptEdge;
int nRet=ads_getpoint(NULL, _T("\n请点取没有踏步的边: "), ptEdge);
if (nRet==RTNONE)
break;
else if (nRet==RTCAN)
return;

ptEdge=Ucs2Wcs(ptEdge);
int nEdge=FindNearestEdge(poly, ptEdge);
if (nEdge>=0 && !lstEdgeIndex.FindNode(&nEdge, CompareInt)) {
lstEdgeIndex.Append(new int(nEdge));
XCurveSegment seg;
poly.Nth(nEdge, seg);
seg.StartPoint()=Wcs2Ucs(seg.StartPoint());
seg.EndPoint()=Wcs2Ucs(seg.EndPoint());
dc << seg;
}
}

static int nStepNum=3;
static double nStepWidth=300;
static double nStepHeight=150;
CStepDlg myStep(acedGetAcadFrame());
CAcModuleResourceOverride vTemp;
if (myStep.DoModal()==IDOK) {
nStepNum = 	 myStep.m_nCount;
nStepWidth = _tstof(myStep.m_strWidth);
nStepHeight = _tstof(myStep.m_strHeight);
if (!myStep.m_bTop)		{
nStepHeight = 0 - nStepHeight;
nStepWidth = 0 - nStepWidth;
}
poly.SetElevation(_tstof(myStep.m_strElevation));


TDbStep *pStep = new TDbStep;
pStep->SetPolyOutline(poly); 
pStep->SetStepWidth(nStepWidth);
pStep->SetStepHeight(nStepHeight);
pStep->SetStepNum(nStepNum);
for(int i=0; i<lstEdgeIndex.Length(); i++)
pStep->SetStepAt(*lstEdgeIndex[i], FALSE);
if (!entRet) ;
else entRet.Delete();
pStep->AddToMSpace(Adesk::kTrue);
}
ads_redraw(NULL,0);
}
}*/

//提供一个由两点搜索墙边线函数
BOOL SearchWallSide(XPoint ptStart,XPoint ptEnd,//世界坐标系下点
					PickSet &ssWalls,//传入用户选的墙,不能有柱子
					XPoly2D &polyWall)//返回沿墙poly
{
	ptStart.z=0;
	ptEnd.z=0;
	//找起点终点的墙
	RBList entmask(RTDXF0,_T("TCH_WALL,TCH_CURTAIN_WALL"),NULL);
	PickSet ssStart(SS_FREE),ssEnd(SS_FREE);
	ssStart.Get(Wcs2Ucs(ptStart),entmask);
	ssEnd.Get(Wcs2Ucs(ptEnd),entmask);
	if (ssStart.Length()==0||ssEnd.Length()==0)
		return FALSE;

	Entity eStart=ssStart[0L];
	Entity eEnd=ssEnd[0L];

	for(long i=0;i<ssStart.Length();i++)
	{
		Entity ent=ssStart[i];
		if (ssWalls.IsInclude(ent))
			eStart=ent;
	}
	for(i=0;i<ssEnd.Length();i++)
	{
		Entity ent=ssEnd[i];
		if (ssWalls.IsInclude(ent))
			eEnd=ent;
	}


	//墙柱准备
	//ssWalls+=ssStart;
	//ssWalls+=ssEnd;
	DList<AcDbObjectId> lstColu;//放柱子

	//搜索
	XAecSpaceWall *pWallStart=NULL, *pWallEnd=NULL;
	XSearchSpaceFromWall aSearch;
	try 
	{
		aSearch.InitStart(ssWalls, lstColu);
	} 
	catch(...) 
	{
		return FALSE;
	}
	int nWallNum=aSearch.walls.Length();
	for(i=0; i<nWallNum; i++) 
	{
		XAecSpaceWall *pWall=aSearch.walls[i];
		if (pWall->m_ent == eStart)
			pWallStart=pWall;
		if (pWall->m_ent == eEnd)
			pWallEnd = pWall;
	}
	if (!pWallStart||!pWallEnd)
		return FALSE;

	//确定起始点所在一侧
	int type=2;//LEFT
	XCurveSegment cvCenter;
	OPENOBJ_BEGIN(eStart,AcDb::kForRead,TDbWall,pWall)
		if (pWall==NULL)
			return FALSE;
	cvCenter=pWall->OffsetGeomCenter();
	OPENOBJ_END()
		cvCenter.SetElevation(0);
	int nRet=cvCenter.OnWhichSide(ptStart);
	if (nRet==0)
		type=2;
	else if (nRet==1)
		type=3;
	else
		return FALSE;

	//构建路径
	XPoly2D poly;
	if (aSearch.SearchPath(*pWallStart, *pWallEnd, poly, type)!=RTNORM)
		return FALSE;
	XCurveSegment segStart, segEnd;
	poly.Nth(0, segStart);
	poly.Nth(poly.TotalSegments()-1, segEnd);
	XPoint ptBrkS, ptBrkE;
	segStart.ProjectToMe(ptStart, ptBrkS);
	segEnd.ProjectToMe(ptEnd, ptBrkE);
	poly.SetFlag(1); //临时封闭
	return SplitPoly2D(poly, ptBrkS, ptBrkE, polyWall,XPoly2D())==RTNORM;
}

int Zihuitaijie(CStepNew *dlg,TDbStep *pStep)
{
	// [12/13/2007 nsh]
	//---------------------------------begin-------------------------
	dlg->GetDlgItem(IDC_CHECK_QIWUTABU)->EnableWindow(FALSE);
	dlg->GetDlgItem(IDC_CHECK_ZHONGWUTABU)->EnableWindow(FALSE);
	//----------------------------------end--------------------------

	XPoly2D polyRail, poly(1);
	Entity entRet;
	dlg->EnableToolbarButtons(TRUE);
	int ret = GetOpenPoly(_T("\n台阶平台轮廓线的起点<退出>:"), polyRail, entRet);
	if (ret==RTNORM) 
	{
		dlg->EnableToolbarButtons(FALSE);
		if (!polyRail || polyRail.GetFlag()>1) 
			return RTERROR;
		polyRail.Compress();		
		XScreenDc dc(1,1);
		DList<int> lstEdgeIndex;
		if (!polyRail.IsClosed()) 
		{
			XScreenDc dc0;
			XPoly2D polyTemp(polyRail);
			polyTemp.TransUCS(Groups(0), Groups(1));
			dc0 << polyTemp;

			XPoly2D polyWall(0);
			if (SearchBalcony(polyRail, polyWall, poly)!=RTNORM) 
			{
				ads_redraw(NULL,0);
				return RTERROR;
			}
			for(int n=0; n<polyWall.TotalSegments(); n++) 
			{
				XCurveSegment cvSeg;
				polyWall.Nth(n, cvSeg);
				XPoint ptEdge = cvSeg.MidPoint();
				int nEdge=FindNearestEdge(poly, ptEdge);
				if (nEdge>=0 && !lstEdgeIndex.FindNode(&nEdge, CompareInt)) 
				{
					lstEdgeIndex.Append(new int(nEdge));
					XCurveSegment seg;
					poly.Nth(nEdge, seg);
					//  [12/5/2007 nsh]
					seg.StartPoint()=Wcs2Ucs(seg.StartPoint());
					seg.EndPoint()=Wcs2Ucs(seg.EndPoint());
					//end
					dc << seg;
				}
			}
		} 
		else 
		{
			poly=polyRail;
			if (poly.PathArea()>0) //确保逆时针
				poly.Reverse();
		}
		poly.Compress();
		while(1)
		{
			XPushVar<int> tVar(_T("OSMODE"), OS_NEA);
			XPoint ptEdge;
			int nRet=ads_getpoint(NULL, _T("\n请点取没有踏步的边: "), ptEdge);
			if (nRet==RTNONE)
				break;
			else if (nRet==RTCAN)
				return RTCAN;			
			ptEdge=Ucs2Wcs(ptEdge);
			int nEdge=FindNearestEdge(poly, ptEdge);
			if (nEdge>=0 && !lstEdgeIndex.FindNode(&nEdge, CompareInt)) 
			{
				lstEdgeIndex.Append(new int(nEdge));
				XCurveSegment seg;
				poly.Nth(nEdge, seg);
				seg.StartPoint()=Wcs2Ucs(seg.StartPoint());
				seg.EndPoint()=Wcs2Ucs(seg.EndPoint());
				dc << seg;
			}
		}		
		{
			int nStepNum = 	 dlg->m_nTabushu;
			double nStepWidth  = dlg->m_dTabukuan;
			double nStepHeight = dlg->m_dTabugao;

			//modified by whl
			if (!dlg->m_bTaijiedingmian)//基面为外轮廓面
			{
				if (dlg->m_bPutongTaijie)//上升台阶
					nStepHeight = - nStepHeight;
				nStepWidth = -nStepWidth;
			}
			else//基面为内轮廓面
			{
				if (!dlg->m_bPutongTaijie)//下降台阶
					nStepHeight = - nStepHeight;
			}

			poly.SetElevation(dlg->m_dElevation);
			pStep->SetPolyOutline(poly); 
			pStep->SetStepWidth(nStepWidth);
			pStep->SetStepHeight(nStepHeight);
			pStep->SetStepNum(nStepNum);
			for(int i=0; i<lstEdgeIndex.Length(); i++)
				pStep->SetStepAt(*lstEdgeIndex[i], FALSE);
			if (!entRet) ;
			else entRet.Delete();
		}
		return RTNORM;
	}
	else
	{
		if (dlg->m_nType != 7)
			return RTKWORD;
		else if (ret == RTCAN)
			return RTCAN;
		else if (ret == RTNONE)
			return RTNONE;
		else
			return RTERROR;
	}
}
int PlateYIxingtaijie(CStepNew *dlg,TDbStep *pStep)
{	
	dlg->GetDlgItem(IDC_CHECK_QIWUTABU)->EnableWindow(FALSE);
	dlg->GetDlgItem(IDC_CHECK_ZHONGWUTABU)->EnableWindow(FALSE);

	Entity entRet;
	RBList mask(RTDXF0, _T("POLYLINE,LWPOLYLINE,LINE,ARC"), NULL);
	int  ret = SelectEntity(_T("\n请选择平台轮廓<退出>"), entRet, mask);
	if (ret==RTNORM)
	{
		XPoly2D polyRail(entRet), poly(1);
		int n = polyRail.GetFlag();
		if (n!=0)
			polyRail.SetFlag(1);
		if (!polyRail) 
			return RTERROR;
		polyRail.Compress();	
		XScreenDc dc(1,1);
		DList<int> lstEdgeIndex;
		if (!polyRail.IsClosed()) 
		{
			XScreenDc dc0;
			XPoly2D polyTemp(polyRail);
			polyTemp.TransUCS(Groups(0), Groups(1));
			dc0 << polyTemp;

			XPoly2D polyWall(0);
			if (SearchBalcony(polyRail, polyWall, poly)!=RTNORM) 
			{
				ads_redraw(NULL,0);
				return RTERROR;
			}

			for(int n=0; n<polyWall.TotalSegments(); n++) 
			{
				XCurveSegment cvSeg;
				polyWall.Nth(n, cvSeg);
				XPoint ptEdge = cvSeg.MidPoint();
				int nEdge=FindNearestEdge(poly, ptEdge);
				if (nEdge>=0 && !lstEdgeIndex.FindNode(&nEdge, CompareInt)) 
				{
					lstEdgeIndex.Append(new int(nEdge));
					XCurveSegment seg;
					poly.Nth(nEdge, seg);
					seg.StartPoint()=Wcs2Ucs(seg.StartPoint());
					seg.EndPoint()=Wcs2Ucs(seg.EndPoint());
					dc << seg;
				}
			}
		} 
		else 
		{
			poly=polyRail;
			if (poly.PathArea()>0) //确保逆时针
				poly.Reverse();
		}
		poly.Compress();
		while(1)
		{
			XPushVar<int> tVar(_T("OSMODE"), OS_NEA);
			XPoint ptEdge;
			int nRet=ads_getpoint(NULL, _T("\n请点取没有踏步的边: "), ptEdge);
			if (nRet==RTNONE)
				break;
			else if (nRet==RTCAN)
				return RTCAN;			
			ptEdge=Ucs2Wcs(ptEdge);
			int nEdge=FindNearestEdge(poly, ptEdge);
			if (nEdge>=0 && !lstEdgeIndex.FindNode(&nEdge, CompareInt)) 
			{
				lstEdgeIndex.Append(new int(nEdge));
				XCurveSegment seg;
				poly.Nth(nEdge, seg);
				seg.StartPoint()=Wcs2Ucs(seg.StartPoint());
				seg.EndPoint()=Wcs2Ucs(seg.EndPoint());
				dc << seg;
			}
		}		
		{
			int nStepNum = 	 dlg->m_nTabushu;
			double nStepWidth  = dlg->m_dTabukuan;
			double nStepHeight = dlg->m_dTabugao;

			//modified by whl
			if (!dlg->m_bTaijiedingmian)//基面为外轮廓面
			{
				if (dlg->m_bPutongTaijie)//上升台阶
					nStepHeight = - nStepHeight;
				nStepWidth = -nStepWidth;
			}
			else//基面为内轮廓面
			{
				if (!dlg->m_bPutongTaijie)//下降台阶
					nStepHeight = - nStepHeight;
			}

			poly.SetElevation(dlg->m_dElevation);
			pStep->SetPolyOutline(poly); 
			pStep->SetStepWidth(nStepWidth);
			pStep->SetStepHeight(nStepHeight);
			pStep->SetStepNum(nStepNum);
			for(int i=0; i<lstEdgeIndex.Length(); i++)
				pStep->SetStepAt(*lstEdgeIndex[i], FALSE);
			if (!entRet) ;
			else entRet.Delete();
		}
		return RTNORM;
	}
	else
	{
		if (dlg->m_nType != 6)
			return RTKWORD;
		else if (ret == RTCAN)
			return RTCAN;
		else if (ret == RTNONE)
			return RTNONE;
		else
			return RTERROR;
	}
}
int Yanqiangyixingtaijie(CStepNew *dlg,TDbStep *pStep)
{
	int nRet1,nRet2;
	ads_point point1,point2;
	while(1)
	{
		dlg->EnableToolbarButtons(TRUE);
		dlg->GetDlgItem(IDC_CHECK_QIWUTABU)->EnableWindow(TRUE);
		dlg->GetDlgItem(IDC_CHECK_ZHONGWUTABU)->EnableWindow(TRUE);	

		while(1)
		{
			nRet1 = ads_getpoint(NULL,_T("\n第一点<退出>:"),point1);
			if (nRet1 == RTCAN)
			{
				if (dlg->m_nType != 5)
					return RTKWORD;
				return RTCAN;
			}
			if (nRet1 != RTNORM)
			{
				if (nRet1 == RTNONE)
					return RTNONE;
				else
					return RTERROR;
			}
			dlg->EnableToolbarButtons(FALSE);
			if (nRet1 == RTNORM)
			{
				PickSet ss(SS_FREE);
				RBList entmask(RTDXF0,_T("TCH_WALL,TCH_CURTAIN_WALL"),NULL);
				ss.Get(XPoint(point1[0],point1[1],point1[2]),entmask);
				if (ss.Length()==0)
				{
					acutPrintf(_T("请在墙上获取点!"));
					continue;
				}
				else
					break;
			}
		}	
		while(1)
		{
			nRet2 = ads_getpoint(NULL,_T("\n第二点<取消>:"),point2);
			if (nRet2 == RTCAN)
			{
				if (dlg->m_nType != 5)
					return RTKWORD;
				return RTCAN;
			}
			if (nRet2 != RTNORM)
			{
				if (nRet2 == RTNONE)
					break;
				else
					return RTERROR;
			}
			if (nRet2 == RTNORM)
			{
				PickSet ss(SS_FREE);
				RBList entmask(RTDXF0,_T("TCH_WALL,TCH_CURTAIN_WALL"),NULL);
				ss.Get(XPoint(point2[0],point2[1],point2[2]),entmask);
				if (ss.Length()==0)
				{
					acutPrintf(_T("请在墙上获取点!"));
					continue;
				}
				else
					break;
			}
		}
		if (nRet1 == RTNORM && nRet2 == RTNORM)
			break;
	}

	if (nRet1 == RTNORM && nRet2 == RTNORM)
	{
		XPoly2D polyWall(0);
		XPoly2D polyTemp(1);
		DList<int> lstEdgeIndex;
		PickSet ssBound(SS_FREE);
		if (SelectEntities(_T("\n请选择邻接的墙(或门窗):"), ssBound,RBList(RTDXF0, _T("TCH_WALL,TCH_CURTAIN_WALL,TCH_OPENING"), NULL))!=RTNORM)
			return RTERROR;

		extern void MakeWallSet(PickSet &ssWalls);
		MakeWallSet(ssBound);//add by whl

		if (SearchWallSide(Ucs2Wcs(XPoint(point1[0],point1[1],point1[2])),Ucs2Wcs(XPoint(point2[0],point2[1],point2[2])),ssBound,polyWall))
		{
			PickSet ss(SS_FREE);
			RBList entmask(RTDXF0,_T("TCH_WALL,TCH_CURTAIN_WALL"),NULL);
			ss.Get(XPoint(point1[0],point1[1],point1[2]),entmask);
			if (ss.Length()==0)
				return FALSE;
			Entity eStart=ss[0L];//起点的墙

			//add by fxj针对起始点在端点起始墙不唯一情况
			for(long i=0;i<ss.Length();i++)
			{
				Entity ent=ss[i];
				if (ssBound.IsInclude(ent))
					eStart=ent;
			}


			XPoint pt0 = *polyWall[0];
			XPoint pt1 = *polyWall[1];
			XLine line(pt0,pt1);
			XLine lineWall;

			int nRet;
			if (ss.Length() >=1)
			{
				XDbObject obj(eStart,AcDb::kForRead);
				TDbWall  *pWall = TDbWall::cast(obj.m_pObject);
				if (pWall!=NULL)
					lineWall.SetPoints(pWall->StartPoint(),pWall->EndPoint());
				XCurveSegment cvCenter;
				cvCenter=pWall->OffsetGeomCenter();
				cvCenter.SetElevation(0);
				nRet = cvCenter.OnWhichSide(Ucs2Wcs(XPoint(point1[0],point1[1],point1[2])));

			}
			else
				return RTERROR;

			int m_nSide;
			{
				XDirectionCurve lineWallCurve;

				polyWall.Nth(0,lineWallCurve);
				if (lineWallCurve.GetBulge()>1E-6)
				{
					if (nRet==0)
						m_nSide=OFFSET_LEFT;
					else if (nRet==1)
						m_nSide=OFFSET_RIGHT;
					else
						return RTERROR;
				}
				else if (lineWallCurve.GetBulge()<-1E-6)
				{
					if (nRet==0)
						m_nSide=OFFSET_RIGHT;
					else if (nRet==1)
						m_nSide=OFFSET_LEFT;
					else
						return RTERROR;
				}
				else
				{
					XLine line(pt0,pt1);

					XLine line1 = lineWall;
					XVector3D vt1(line.EndPoint()-line.StartPoint());
					XVector3D vt2(line1.EndPoint()-line1.StartPoint());
					vt1.Normalize();
					vt2.Normalize();
					double s=vt1&vt2;
					if (s>0)
					{
						if (nRet==0)
							m_nSide=OFFSET_LEFT;
						else if (nRet==1)
							m_nSide=OFFSET_RIGHT;
						else
							return RTERROR;
					}
					else
					{
						if (nRet==0)
							m_nSide=OFFSET_RIGHT;
						else if (nRet==1)
							m_nSide=OFFSET_LEFT;
						else
							return RTERROR;
					}
				}					
			}

			polyTemp.Reset();


			//modified by fxj 解决台阶一侧边线成弧形问题 
			//begin fxj
			polyWall.Compress(true);//add by fxj 2007-4-19 解决起止边有无踏步问题

			XPoly2D poly2d=polyWall;

			if (m_nSide == OFFSET_RIGHT)
			{
				Offset(dlg->m_dPlateWidth,poly2d);
			}	
			else 
			{
				Offset(-dlg->m_dPlateWidth,poly2d);
			}
			int nLen=polyWall.Length();

			for(int j=0;j<nLen;j++)
			{
				if (j<nLen-1)
					polyTemp.InsertNodeAt(j,*polyWall[j],polyWall.GetBulge(j));
				else
					polyTemp.InsertNodeAt(j,*polyWall[j],0.0);
			}
			poly2d.Reverse();
			for(i=0;i<nLen;i++)
			{
				if (i<nLen-1)
					polyTemp.InsertNodeAt(i+nLen,*poly2d[i],poly2d.GetBulge(i));
				else
					polyTemp.InsertNodeAt(i+nLen,*poly2d[i],0.0);
			}

			if (polyTemp.PathArea()>0) //确保逆时针
			{
				polyTemp.Reverse();
				if (dlg->m_bZhongbianwutabu)
					pStep->SetStepAt(poly2d.TotalSegments()+1, FALSE);
				if (dlg->m_bQibianwutabu)
					pStep->SetStepAt(0, FALSE);
			}
			else
			{
				if (dlg->m_bQibianwutabu)
					pStep->SetStepAt(polyTemp.TotalSegments() - 1, FALSE);
				if (dlg->m_bZhongbianwutabu)
					pStep->SetStepAt(poly2d.TotalSegments() , FALSE);
			}//起止边踏步设置 modified by fxj 2007-4-19

			for(int n=0; n<poly2d.TotalSegments(); n++) 
			{
				XCurveSegment cvSeg;
				polyWall.Nth(n, cvSeg);
				XPoint ptEdge = cvSeg.MidPoint();
				int nEdge=FindNearestEdge(polyTemp, ptEdge);
				if (nEdge>=0 && !lstEdgeIndex.FindNode(&nEdge, CompareInt)) 
					lstEdgeIndex.Append(new int(nEdge));
			}
			//end fxj


		}
		else
		{
			acutPrintf(_T("请在墙上获取点!"));
			return RTERROR;
		}
		{
			int nStepNum = 	 dlg->m_nTabushu;
			double nStepWidth  = dlg->m_dTabukuan;
			double nStepHeight = dlg->m_dTabugao;

			//modified by whl
			if (!dlg->m_bTaijiedingmian)//基面为外轮廓面
			{
				if (dlg->m_bPutongTaijie)//上升台阶
					nStepHeight = - nStepHeight;
				nStepWidth = -nStepWidth;
			}
			else//基面为内轮廓面
			{
				if (!dlg->m_bPutongTaijie)//下降台阶
					nStepHeight = - nStepHeight;
			}	

			polyTemp.SetElevation(dlg->m_dElevation);
			pStep->SetPolyOutline(polyTemp); 
			pStep->SetStepWidth(nStepWidth);
			pStep->SetStepHeight(nStepHeight);
			pStep->SetStepNum(nStepNum);
			for(int i=0; i<lstEdgeIndex.Length(); i++)
				pStep->SetStepAt(*lstEdgeIndex[i], FALSE);
		}
		return RTNORM;
	}
	else
	{
		if (dlg->m_nType != 5)
			return RTKWORD;
		else
			return RTERROR;
	}
}
//  [11/23/2007 nsh]
//定义状态位
static int iChoose=0;//0为端点定位R，1为中心定位C,2为门窗对中D

//------------------------------------------------------------------------------------------------------------------------------
class TStepJig: public AcEdJig
{
public:
	TStepJig();
	~TStepJig();
	int  doIt();
	virtual DragStatus sampler();
	virtual Adesk::Boolean update();
	virtual AcDbEntity* entity() const;
	void SetPrompt(const TCHAR *m_pTemp);
	int GetRetCode() const;

	BOOL m_bFlag;
	int m_nRetCode; //返回码
	const TCHAR *m_pszPrompt1; //提示信息1
	const TCHAR *m_pszPrompt2; //提示信息2
	const TCHAR *m_pszKeyword; //关键字
	AcDbVoidPtrArray entSet;
	AcGePoint3d m_point;
	AcGePoint3dArray m_pointArr;
	AcGePoint3d pt;
	TDbStep *m_pStep;
	CStepNew *m_dlg;
};
TStepJig::TStepJig()
{
	m_bFlag = FALSE;
}
TStepJig::~TStepJig()
{
}
int TStepJig::GetRetCode() const
{
	int ret = m_nRetCode;
	if (ret == AcEdJig::kCancel)
		ret = RTCAN;
	else if (ret == AcEdJig::kNull)
		ret = RTNONE;
	else if (ret == AcEdJig::kNormal) 
		ret = RTNORM;
	else
		ret = RTKWORD;
	return ret;
}
int TStepJig::doIt()
{	
	m_dlg->GetDlgItem(IDC_CHECK_QIWUTABU)->EnableWindow(FALSE);
	m_dlg->GetDlgItem(IDC_CHECK_ZHONGWUTABU)->EnableWindow(FALSE);

	if (m_dlg->GetDrawType() == 7)
	{
		return Zihuitaijie(m_dlg,m_pStep);
	}
	else if (m_dlg->GetDrawType() == 6)
	{
		return PlateYIxingtaijie(m_dlg,m_pStep);
	}
	else if (m_dlg->GetDrawType() == 5)
	{
		return Yanqiangyixingtaijie(m_dlg,m_pStep);
	}
	else if (m_dlg->GetDrawType() == 4)
	{
		acutPrintf(m_pszPrompt1);
		//  [11/23/2007 nsh]
		//----------------------------------------///////////////////////////////////////////////////////////////////////////////////
		while(1)
		{
			//在这里除了判断关键字返回外，还有其他的返回处理问题，都要判断
			//如果不判断，则可能产生死循环的现象
			INITGET_BEG(-1,_T("C D R"));
			m_nRetCode = drag();
			INITGET_END();
			if (m_nRetCode==AcEdJig::kKW1)
			{//中心定位
				iChoose=1;
				m_pszPrompt1=_T("\n指定中心点或　[端点定位(R)/门窗对中(D)]<退出>:");
				acutPrintf(m_pszPrompt1);
				continue;

			}
			else if (m_nRetCode==AcEdJig::kKW2)
			{//iChoose=2为门窗对中
				iChoose=2;
				return 1000;
			}
			else if (m_nRetCode ==AcEdJig::kKW3)
			{//为0为端点定位
				iChoose=0;
				m_pszPrompt1=_T("\n指定第一点或　[中心定位(C)/门窗对中(D)]<退出>:");
				acutPrintf(m_pszPrompt1);
				continue;
			}
			if (m_nRetCode!=RTKWORD)break;
		}

		//--------------------------------------//////////////////////////////////////////////////////////////////////////////////
		int nRet = GetRetCode();
		if (nRet == RTCAN || nRet == RTNONE)
		{			
			if (m_dlg->m_nType != 4)
				return RTKWORD;
			return nRet;
		}
		m_pointArr.append(m_point);
	}
	else if (m_dlg->GetDrawType() == 3)
	{
		m_pszPrompt1=_T("\n指定第一点 <退出>:");
		acutPrintf(m_pszPrompt1);
		m_nRetCode = drag();
		int nRet = GetRetCode();
		if (nRet == RTCAN || nRet == RTNONE)
		{			
			if (m_dlg->m_nType != 3)
				return RTKWORD;
			return nRet;
		}
		m_pointArr.append(m_point);
	}
	else if (m_dlg->GetDrawType() == 2)
	{
		acutPrintf(m_pszPrompt1);
		//  [11/23/2007 nsh]
		//----------------------------------------///////////////////////////////////////////////////////////////////////////////////
		while(1)
		{
			//在这里除了判断关键字返回外，还有其他的返回处理问题，都要判断
			//如果不判断，则可能产生死循环的现象
			INITGET_BEG(-1,_T("C D R"));
			m_nRetCode = drag();
			INITGET_END();
			if (m_nRetCode==AcEdJig::kKW1)
			{//中心定位
				iChoose=1;
				m_pszPrompt1=_T("\n指定中心点或　[端点定位(R)/门窗对中(D)]<退出>:");
				acutPrintf(m_pszPrompt1);
				continue;

			}
			else if (m_nRetCode==AcEdJig::kKW2)
			{//iChoose=2为门窗对中
				iChoose=2;
				return 1000;
			}
			else if (m_nRetCode ==AcEdJig::kKW3)
			{//为0为端点定位
				iChoose=0;
				m_pszPrompt1=_T("\n指定第一点或　[中心定位(C)/门窗对中(D)]<退出>:");
				acutPrintf(m_pszPrompt1);
				continue;
			}
			if (m_nRetCode!=RTKWORD)break;
		}

		//--------------------------------------//////////////////////////////////////////////////////////////////////////////////
		int nRet = GetRetCode();
		if (nRet == RTCAN || nRet == RTNONE)
		{			
			if (m_dlg->m_nType != 2)
				return RTKWORD;
			return nRet;
		}
		m_pointArr.append(m_point);
	}
	else if (m_dlg->GetDrawType() == 1)
	{
		acutPrintf(m_pszPrompt1);
		while(1)
		{
			//在这里除了判断关键字返回外，还有其他的返回处理问题，都要判断
			//如果不判断，则可能产生死循环的现象
			INITGET_BEG(-1,_T("C D R"));
			m_nRetCode = drag();
			INITGET_END();
			if (m_nRetCode==AcEdJig::kKW1)
			{//中心定位
				iChoose=1;
				m_pszPrompt1=_T("\n指定中心点或　[端点定位(R)/门窗对中(D)]<退出>:");
				acutPrintf(m_pszPrompt1);
				continue;

			}
			else if (m_nRetCode==AcEdJig::kKW2)
			{//iChoose=2为门窗对中
				iChoose=2;
				return 1000;
			}
			else if (m_nRetCode ==AcEdJig::kKW3)
			{//为0为端点定位
				iChoose=0;
				m_pszPrompt1=_T("\n指定第一点或　[中心定位(C)/门窗对中(D)]<退出>:");
				acutPrintf(m_pszPrompt1);
				continue;
			}
			if (m_nRetCode!=RTKWORD)break;
		}
		//m_nRetCode = drag();
		int nRet = GetRetCode();
		if (nRet == RTCAN || nRet == RTNONE)
		{			
			if (m_dlg->m_nType != 1)
				return RTKWORD;
			return nRet;
		}
		m_pointArr.append(m_point);
	}
	m_dlg->EnableToolbarButtons(FALSE);
	acutPrintf(m_pszPrompt2);
	INITGET_BEG(-1, m_pszKeyword);
	m_nRetCode = drag();
	INITGET_END();
	int nRet = GetRetCode();
	m_dlg->EnableToolbarButtons(TRUE);
	return nRet;
}

Adesk::Boolean TStepJig::update()
{
	if (m_dlg->GetDrawType() == 4) 
	{//圆弧台阶///////////////////////////////////////////////////////////////////
		// ---------------------------------------------------------------------------------- [11/27/2007 nsh]
		XPoint pt1,pt2;
		if (m_pointArr.length() == 0)
		{
			pt1 = pt2 = m_point;
			pt2.x = pt2.x + m_dlg->m_dPlateWidth;
		}
		else if (m_pointArr.length() == 1)
		{
			if (iChoose==0)
			{//端点定位的情况
				pt1 = m_pointArr.at(0);
				pt2 = m_point;
			}

			//  [11/27/2007 nsh]
			if (iChoose==1)
			{//中心定位的情况
				pt2=m_point;//pt2为鼠标的当前移动的点
				double dDist;//pt2与中点之间的距离
				dDist=pt2.Distance(m_pointArr[0]);
				XPoint pTemp;
				pTemp=m_pointArr[0];
				ads_polar(pTemp,ads_angle(pt2,pTemp),dDist,pt1);
			}
			//------------------------------
		}
		XPoint pt3;
		{
			XLine line(pt1,pt2);
			if (!m_bFlag)
				line = line.Offset(m_dlg->m_dPlateWidth);
			else
				line = line.Offset(-m_dlg->m_dPlateWidth);
			// 2010-3-15 17:39 wubo
			// 移植Geo
			//line.MidPoint(pt3);
			pt3 = line.MidPoint();
		}		
		XCurveSegment cv;
		cv = XArc(pt1,pt3,pt2);
		/*{
		if (!m_bFlag)
		{
		XCurveSegment cvTemp(pt1,pt2,PI);
		cv = cvTemp;
		}
		else
		{
		XCurveSegment cvTemp(pt2,pt1,PI);
		cv = cvTemp;
		}		
		} */
		XPoly2D poly2d(1);
		cv.AsPoly2D(poly2d);
		poly2d.SetFlag(1);
		DList<int> lstEdgeIndex;
		lstEdgeIndex.Append(new int(1));
		{
			int nStepNum = 	 m_dlg->m_nTabushu;
			double nStepWidth  = m_dlg->m_dTabukuan;
			double nStepHeight = m_dlg->m_dTabugao;

			//modified by whl
			if (!m_dlg->m_bTaijiedingmian)//基面为外轮廓面
			{
				if (m_dlg->m_bPutongTaijie)//上升台阶
					nStepHeight = - nStepHeight;
				nStepWidth = -nStepWidth;
			}
			else//基面为内轮廓面
			{
				if (!m_dlg->m_bPutongTaijie)//下降台阶
					nStepHeight = - nStepHeight;
			}			

			poly2d.SetElevation(m_dlg->m_dElevation);			
			m_pStep->SetPolyOutline(poly2d); 
			m_pStep->SetStepWidth(nStepWidth);
			m_pStep->SetStepHeight(nStepHeight);
			m_pStep->SetStepNum(nStepNum);
			for(int i=0; i<lstEdgeIndex.Length(); i++)
				m_pStep->SetStepAt(*lstEdgeIndex[i], FALSE);	
		}
	}
	else if (m_dlg->GetDrawType() == 3) 
	{//矩形双面台阶/////////////////////////////////////////////////////////////////////////////////
		XPoint pt1,pt2;
		XPoly2D poly2d(1);
		if (m_pointArr.length() == 0)
		{
			pt1 = pt2 = m_point;
			pt1.y = pt1.y - m_dlg->m_dPlateWidth;
			poly2d.AppendNode(pt1);
			pt1.x = pt1.x + LENGTH;
			poly2d.AppendNode(pt1);
			pt2.x = pt2.x + LENGTH;
			poly2d.AppendNode(pt2);
			poly2d.AppendNode(m_point);
		}
		else if (m_pointArr.length() == 1)
		{
			pt1 = m_pointArr.at(0);
			pt2 = m_point;
			if (!m_bFlag)
			{
				XLine line(pt1,pt2);
				line = line.Offset(m_dlg->m_dPlateWidth);
				poly2d.AppendNode(line.StartPoint());
				poly2d.AppendNode(line.EndPoint());
				poly2d.AppendNode(pt2);
				poly2d.AppendNode(pt1);
			}
			else
			{
				XLine line(pt1,pt2);
				line = line.Offset(-m_dlg->m_dPlateWidth);
				poly2d.AppendNode(line.StartPoint());
				poly2d.AppendNode(line.EndPoint());
				poly2d.AppendNode(pt2);
				poly2d.AppendNode(pt1);
			}
		}
		if (poly2d.PathArea()>0) //确保逆时针
			poly2d.Reverse();
		DList<int> lstEdgeIndex;	
		if (!m_bFlag)
		{
			lstEdgeIndex.Append(new int(2));
			lstEdgeIndex.Append(new int(3));
		}
		else
		{
			lstEdgeIndex.Append(new int(0));
			lstEdgeIndex.Append(new int(1));	
		}
		{
			int nStepNum = 	 m_dlg->m_nTabushu;
			double nStepWidth  = m_dlg->m_dTabukuan;
			double nStepHeight = m_dlg->m_dTabugao;

			//modified by whl
			if (!m_dlg->m_bTaijiedingmian)//基面为外轮廓面
			{
				if (m_dlg->m_bPutongTaijie)//上升台阶
					nStepHeight = - nStepHeight;
				nStepWidth = -nStepWidth;
			}
			else//基面为内轮廓面
			{
				if (!m_dlg->m_bPutongTaijie)//下降台阶
					nStepHeight = - nStepHeight;
			}

			poly2d.SetElevation(m_dlg->m_dElevation);			
			m_pStep->SetPolyOutline(poly2d); 
			m_pStep->SetStepWidth(nStepWidth);
			m_pStep->SetStepHeight(nStepHeight);
			m_pStep->SetStepNum(nStepNum);
			for(int i=0; i<lstEdgeIndex.Length(); i++)
				m_pStep->SetStepAt(*lstEdgeIndex[i], FALSE);			
		}
	}
	else if (m_dlg->GetDrawType() == 2)
	{//选择矩形三面楼梯的情况/////////////////////////////////////////////////////////////////////////////////////
		//////////////////////////////////////////////////////////////////////////
		//在选择了三面矩形台阶后，有三种情况。
		XPoint pt1,pt2;
		XPoly2D poly2d(1);
		if (m_pointArr.length() == 0)
		{
			pt1 = pt2 = m_point;
			poly2d.AppendNode(pt1);
			pt1.y = pt1.y - m_dlg->m_dPlateWidth;
			poly2d.AppendNode(pt1);
			pt1.x = pt1.x + LENGTH;
			poly2d.AppendNode(pt1);
			pt2.x = pt2.x + LENGTH;
			poly2d.AppendNode(pt2);
		}
		else if (m_pointArr.length() == 1)
		{
			//  [11/27/2007 nsh]
			//-----------------------------begin---------------------
			if (iChoose==0)
			{//端点对中的情况下
				pt1 = m_pointArr.at(0);
				pt2 = m_point;
				poly2d.AppendNode(pt1);
				if (!m_bFlag)
				{
					XLine line(pt1,pt2);
					line = line.Offset(m_dlg->m_dPlateWidth);
					poly2d.AppendNode(line.StartPoint());
					poly2d.AppendNode(line.EndPoint());
					poly2d.AppendNode(pt2);
				}
				else
				{
					XLine line(pt1,pt2);
					line = line.Offset(-m_dlg->m_dPlateWidth);
					poly2d.AppendNode(line.StartPoint());
					poly2d.AppendNode(line.EndPoint());
					poly2d.AppendNode(pt2);
				}
			}
			//-------------------------------end-----------------------

			//  [11/27/2007 nsh]
			//--------------------------begin--------------------------
			//当为中心定位的时候，绘图的方式
			if (iChoose==1)
			{
				pt2=m_point;//pt2为鼠标的当前移动的点
				double dDist;//pt2与中点之间的距离
				dDist=pt2.Distance(m_pointArr[0]);
				XPoint pTemp;
				pTemp=m_pointArr[0];
				ads_polar(pTemp,ads_angle(pt2,pTemp),dDist,pt1);
				poly2d.AppendNode(pt1);
				if (!m_bFlag)
				{
					XLine line(pt1,pt2);
					line = line.Offset(m_dlg->m_dPlateWidth);
					poly2d.AppendNode(line.StartPoint());
					poly2d.AppendNode(line.EndPoint());
					poly2d.AppendNode(pt2);

				}
				else
				{
					XLine line(pt1,pt2);
					line = line.Offset(-m_dlg->m_dPlateWidth);
					poly2d.AppendNode(line.StartPoint());
					poly2d.AppendNode(line.EndPoint());
					poly2d.AppendNode(pt2);
				}

			}
			//---------------------------end---------------------------
		}
		if (poly2d.PathArea()>0) //确保逆时针
			poly2d.Reverse();
		DList<int> lstEdgeIndex;
		if (!m_bFlag)
			lstEdgeIndex.Append(new int(3));
		else
			lstEdgeIndex.Append(new int(0));
		{
			int nStepNum = 	 m_dlg->m_nTabushu;
			double nStepWidth  = m_dlg->m_dTabukuan;
			double nStepHeight = m_dlg->m_dTabugao;

			//modified by whl
			if (!m_dlg->m_bTaijiedingmian)//基面为外轮廓面
			{
				if (m_dlg->m_bPutongTaijie)//上升台阶
					nStepHeight = - nStepHeight;
				nStepWidth = -nStepWidth;
			}
			else//基面为内轮廓面
			{
				if (!m_dlg->m_bPutongTaijie)//下降台阶
					nStepHeight = - nStepHeight;
			}

			poly2d.SetElevation(m_dlg->m_dElevation);			
			m_pStep->SetPolyOutline(poly2d); 
			m_pStep->SetStepWidth(nStepWidth);
			m_pStep->SetStepHeight(nStepHeight);
			m_pStep->SetStepNum(nStepNum);
			for(int i=0; i<lstEdgeIndex.Length(); i++)
				m_pStep->SetStepAt(*lstEdgeIndex[i], FALSE);			
		}
		//  [11/23/2007 nsh] //////////////////////////////////////////////////////////////////////////

	}
	else if (m_dlg->GetDrawType() == 1)
	{//矩形一面台阶//////////////////////////////////////////////////////////////////////////
		XPoint pt1,pt2;
		XPoly2D poly2d(1);
		if (m_pointArr.length() == 0)
		{
			pt1 = pt2 = m_point;
			poly2d.AppendNode(pt1);
			pt1.y = pt1.y - m_dlg->m_dPlateWidth;
			poly2d.AppendNode(pt1);
			pt1.x = pt1.x + LENGTH;
			poly2d.AppendNode(pt1);
			pt2.x = pt2.x + LENGTH;
			poly2d.AppendNode(pt2);
		}
		else if (m_pointArr.length() == 1)
		{
			if (iChoose==0)
			{
				pt1 = m_pointArr.at(0);
				pt2 = m_point;
				poly2d.AppendNode(pt1);
				if (!m_bFlag)
				{
					XLine line(pt1,pt2);
					line = line.Offset(m_dlg->m_dPlateWidth);
					poly2d.AppendNode(line.StartPoint());
					poly2d.AppendNode(line.EndPoint());
					poly2d.AppendNode(pt2);
				}
				else
				{
					XLine line(pt1,pt2);
					line = line.Offset(-m_dlg->m_dPlateWidth);
					poly2d.AppendNode(line.StartPoint());
					poly2d.AppendNode(line.EndPoint());
					poly2d.AppendNode(pt2);
				}
			}

			//  [11/27/2007 nsh]
			if (iChoose==1)
			{
				pt2=m_point;//pt2为鼠标的当前移动的点
				double dDist;//pt2与中点之间的距离
				dDist=pt2.Distance(m_pointArr[0]);
				XPoint pTemp;
				pTemp=m_pointArr[0];
				ads_polar(pTemp,ads_angle(pt2,pTemp),dDist,pt1);
				poly2d.AppendNode(pt1);
				if (!m_bFlag)
				{
					XLine line(pt1,pt2);
					line = line.Offset(m_dlg->m_dPlateWidth);
					poly2d.AppendNode(line.StartPoint());
					poly2d.AppendNode(line.EndPoint());
					poly2d.AppendNode(pt2);

				}
				else
				{
					XLine line(pt1,pt2);
					line = line.Offset(-m_dlg->m_dPlateWidth);
					poly2d.AppendNode(line.StartPoint());
					poly2d.AppendNode(line.EndPoint());
					poly2d.AppendNode(pt2);
				}
			}
			//--------------------------------------------------
		}
		if (poly2d.PathArea()>0) //确保逆时针
		{
			poly2d.Reverse();
		}
		DList<int> lstEdgeIndex;
		if (!m_bFlag)
		{
			lstEdgeIndex.Append(new int(0));
			lstEdgeIndex.Append(new int(2));
			lstEdgeIndex.Append(new int(3));
		}
		else
		{		
			lstEdgeIndex.Append(new int(0));
			lstEdgeIndex.Append(new int(1));
			lstEdgeIndex.Append(new int(3));
		}
		{
			int nStepNum = 	 m_dlg->m_nTabushu;
			double nStepWidth  = m_dlg->m_dTabukuan;
			double nStepHeight = m_dlg->m_dTabugao;

			//modified by whl
			if (!m_dlg->m_bTaijiedingmian)//基面为外轮廓面
			{
				if (m_dlg->m_bPutongTaijie)//上升台阶
					nStepHeight = - nStepHeight;
				nStepWidth = -nStepWidth;
			}
			else//基面为内轮廓面
			{
				if (!m_dlg->m_bPutongTaijie)//下降台阶
					nStepHeight = - nStepHeight;
			}

			poly2d.SetElevation(m_dlg->m_dElevation);			
			m_pStep->SetPolyOutline(poly2d); 
			m_pStep->SetStepWidth(nStepWidth);
			m_pStep->SetStepHeight(nStepHeight);
			m_pStep->SetStepNum(nStepNum);
			for(int i=0; i<lstEdgeIndex.Length(); i++)
				m_pStep->SetStepAt(*lstEdgeIndex[i], FALSE);			
		}
	}
	return Adesk::kTrue;
}

AcEdJig::DragStatus TStepJig::sampler()
{
	DragStatus stat;
	setUserInputControls((UserInputControls)
		(AcEdJig::kAccept3dCoordinates|AcEdJig::kNullResponseAccepted));
	if (m_pszKeyword != NULL)
		setKeywordList(m_pszKeyword);
	AcGePoint3d m_Temp;
	if (m_dlg->GetDrawType() == 5 || m_dlg->GetDrawType() == 6 || m_dlg->GetDrawType() == 7)
	{
		stat = acquirePoint(m_Temp);
	}
	else
	{
		if (m_pointArr.length() == 0)
			stat = acquirePoint(m_Temp);
		else
			stat = acquirePoint(m_Temp,m_pointArr[0]);
	}
	if (stat == AcEdJig::kNormal)
	{
		if (m_point == m_Temp)
			return AcEdJig::kNoChange;
		m_point = m_Temp;
	}
	return stat;
}
AcDbEntity* TStepJig::entity() const
{
	return (AcDbEntity*)m_pStep;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////绘制台阶///////////////////////
void Poly2Step()
{
	CAcModuleResourceOverride vTemp;
	CStepNew dlg;
	dlg.Create(CStepNew::IDD,acedGetAcadFrame());
	dlg.ShowWindow(SW_SHOW);
	while(1)
	{
		TStepJig jig;
		int nType = dlg.GetDrawType();
		TDbStep *pStep = new TDbStep;
		//  [11/26/2007 nsh]
		//------------------------------------------------------------------------begin--------------------------------------------------
		if (nType==2 || nType==1 || nType==4)//当为单面矩形台阶，三面矩形台阶和圆弧台阶的时候
		{
			if (iChoose==2)
			{//当门窗对中的时候
				BOOL m_bFlag=FALSE;
				DList<int> lstEdgeIndex;
				XPoly2D poly2d(1);
				//  得到的相关的点的信息
				XPoint pWin;//门窗中点的信息
				XPoint pWinMapping;//中点在一边上的映射
				XPoint pLeft,pRight;//台阶的左右端点
				XPoint wallLeft,wallRight;//门窗的左右中点
				double wallThick;//墙厚
				int rt;//PickSet的返回码
				if (iChoose==2)
				{
					AcDbEntity *pEntity=NULL;			
					Entity ent;
					RBList rbMask;
					resbuf * rf=ads_buildlist(RTDXF0,_T("TCH_OPENING"),NULL);
					rbMask.Append(rf);
					TCHAR *kword=_T("C D R");
					TCHAR rkword;//返回的关键字
					rt=SelectEntity(_T("\n选择门窗或　[端点定位(R)/中心定位(C)]<退出>:"),ent,rbMask,kword,rkword);
					if (rt==RTCAN || rt==RTERROR)
					{
						if (CStepNew::m_bESC==TRUE)
						{
							delete pStep;
							break;
						}
						else
						{
							CStepNew::m_bESC =TRUE;
							continue;
						}
					}
					if (rt==RTNONE)
					{
						delete pStep;
						break;
					}
					if (rt==RTKWORD)
					{
						switch(rkword)
						{
						case _T('C'):
							{
								iChoose=1;
								continue;
							}
							break;
						case _T('D'):
							{
								iChoose =2;
								continue;
							}
							break;
						case _T('R'):					
							{
								iChoose=0;
								continue;

							}
							break;
						default:
							break;
						}
					}
					if (!ent.Is(_T("TCH_OPENING")) && rt!=RTCAN)
					{
						delete pStep;
						break;
					}
					if (rt==RTNORM)
					{//正常的处理
						OPENOBJ_BEGIN(ent,AcDb::kForRead,TDbOpening,pOpening);
						pWin=pOpening->GetDoorPos();//得到门的中心点
						pOpening->GetSidePoints(wallLeft,wallRight);//得到门窗的边界点
						wallLeft=Wcs2Ucs(wallLeft);
						wallRight=Wcs2Ucs(wallRight);
						wallThick =pOpening->GetWallThickness();	
						acdbOpenObject(pEntity,pOpening->GetWallId(),AcDb::kForRead,FALSE);//打开与窗相邻的墙体对象
						TDbWall *pWall = TDbWall::cast(pEntity);
						XCurveSegment xcs;
						XCurveSegment xcs1;
						pWall->GetSideCurve(xcs,xcs1);//得到
						//现在判断m_point是在墙体的哪一侧！
						XPoint pTemp;
						int rtp=ads_getpoint(NULL,_T("\n点取台阶所在一侧<退出>:"),pTemp);
						if (rtp==RTCAN || rtp==RTERROR||rtp ==RTNONE)
						{
							delete pStep;
							if (pEntity)
							{
								pEntity->close();
							}
							break;
						}
						pTemp=Ucs2Wcs(pTemp);
						int nDir=pWall->OnWhichSide(pTemp);
						if (nDir==OFFSET_LEFT)
						{
							pWin.Project(&xcs,pWinMapping);
							double centerDist;
							pWinMapping =Wcs2Ucs(pWinMapping);
							rtp=acedGetDist(pWinMapping,_T("\n请点取墙外皮与台阶平台边界的交点[或键入中点到边界距离]<退出>:"),&centerDist);
							if (rtp==RTCAN || rtp==RTERROR||rtp ==RTNONE)
							{
								delete pStep;
								if (pEntity)
								{
									pEntity->close();
								}
								break;
							}
							ads_polar(pWinMapping,ads_angle(wallLeft,wallRight),centerDist,pLeft);
							ads_polar(pWinMapping,ads_angle(wallRight,wallLeft),centerDist,pRight);
							m_bFlag =TRUE;
						}
						else
						{
							pWin.Project(&xcs1,pWinMapping);
							double centerDist;
							pWinMapping =Wcs2Ucs(pWinMapping);
							rtp=acedGetDist(pWinMapping,_T("\n请点取墙外皮与台阶平台边界的交点[或键入中点到边界距离]<退出>:"),&centerDist);
							if (rtp==RTCAN || rtp==RTERROR||rtp ==RTNONE)
							{
								delete pStep;
								if (pEntity)
								{
									pEntity->close();
								}
								break;
							}
							ads_polar(pWinMapping,ads_angle(wallLeft,wallRight),centerDist,pRight);
							ads_polar(pWinMapping,ads_angle(wallRight,wallLeft),centerDist,pLeft);
							m_bFlag =FALSE;
						}
						pWall->close();
						pRight=Ucs2Wcs(pRight);
						pLeft=Ucs2Wcs(pLeft);
						OPENOBJ_END();
						//生成台阶的操作
						if (nType==1 || nType==2)
						{
							if (!m_bFlag)
							{
								poly2d.AppendNode(pLeft);
								XLine line(pLeft,pRight);
								line = line.Offset(dlg.m_dPlateWidth);
								poly2d.AppendNode(line.StartPoint());
								poly2d.AppendNode(line.EndPoint());
								poly2d.AppendNode(pRight);
							}
							else
							{
								poly2d.AppendNode(pLeft);
								XLine line(pLeft,pRight);
								line = line.Offset(dlg.m_dPlateWidth);
								poly2d.AppendNode(line.StartPoint());
								poly2d.AppendNode(line.EndPoint());
								poly2d.AppendNode(pRight);
							}
						}
						else if (nType==4)
						{//圆弧台阶的处理方式
							XPoint pt3;
							XLine line(pLeft,pRight);
							if (!m_bFlag)
								line = line.Offset(dlg.m_dPlateWidth);
							else
								line = line.Offset(dlg.m_dPlateWidth);
							// 2010-3-15 17:40 wubo
							// 移植Geo
							// line.MidPoint(pt3);		
							pt3 = line.MidPoint();
							XCurveSegment cv;
							cv = XArc(pLeft,pt3,pRight);
							cv.AsPoly2D(poly2d);
							poly2d.SetFlag(1);
						}

						if (nType==2)
							lstEdgeIndex.Append(new int(3));//三面矩形台阶
						else if (nType==4)
							lstEdgeIndex.Append(new int(1));//圆弧台阶
						else if (nType==1)//单面矩形台阶
						{
							lstEdgeIndex.Append(new int(0));
							lstEdgeIndex.Append(new int(2));
							lstEdgeIndex.Append(new int(3));
						}

						{
							int nStepNum = 	 dlg.m_nTabushu;
							double nStepWidth  = dlg.m_dTabukuan;
							double nStepHeight = dlg.m_dTabugao;
							if (!dlg.m_bTaijiedingmian)//基面为外轮廓面
							{
								if (dlg.m_bPutongTaijie)//上升台阶
									nStepHeight = - nStepHeight;
								nStepWidth = -nStepWidth;
							}
							else//基面为内轮廓面
							{
								if (!dlg.m_bPutongTaijie)//下降台阶
									nStepHeight = - nStepHeight;
							}
							poly2d.SetElevation(dlg.m_dElevation);			
							pStep->SetPolyOutline(poly2d); 
							pStep->SetStepWidth(nStepWidth);
							pStep->SetStepHeight(nStepHeight);
							pStep->SetStepNum(nStepNum);
							for(int i=0; i<lstEdgeIndex.Length(); i++)
								pStep->SetStepAt(*lstEdgeIndex[i], FALSE);	
							pStep->AddToMSpace(TRUE);
						}
						pStep->close();
						continue;
					}

				}

			}
		}
		//-------------------------------------------------------------------------end---------------------------------------------------
		jig.m_dlg = &dlg;
		jig.m_pStep = pStep;
		pStep->setLayer(InitLayer(pStep->GetDefaultLayer()));//add by whl
		if (iChoose==0)
		{
			jig.m_pszPrompt1 = _T("\n指定第一点或　[中心定位(C)/门窗对中(D)]<退出>:");
			jig.m_pszPrompt2 = _T("\n第二点或 [翻转到另一侧(F)]<取消>:");
		}
		else if (iChoose==1)
		{
			jig.m_pszPrompt1 = _T("\n指定中心点或　[端点定位(R)/门窗对中(D)]<退出>:");
			jig.m_pszPrompt2 = _T("\n第二点或 [翻转到另一侧(F)]<取消>:");	
		}
		else
		{
			jig.m_pszPrompt1 = _T("\n指定第一点<退出>:");
			jig.m_pszPrompt2 = _T("\n第二点或 [翻转到另一侧(F)]<取消>:");
		}
		jig.m_pszKeyword = _T("C D R F");// add by nsh
		int m = jig.doIt();
		if (m == RTCAN ||(m == RTNONE && jig.m_pointArr.length() == 0) || (m == RTERROR && dlg.GetDrawType() == 6))
		{
			if (pStep!=NULL)
				delete pStep;
			break;
		}
		if (m != RTNORM && m != RTKWORD)
		{
			if (pStep!=NULL)
				delete pStep;
			continue;
		}
RETURN:		if (m == RTKWORD) 
			{
				if (nType==dlg.GetDrawType())//翻转到另一侧
				{
					jig.m_bFlag = !jig.m_bFlag;
					if (pStep!=NULL)
					{
						delete pStep;
						pStep = new TDbStep;
						pStep->setLayer(InitLayer(pStep->GetDefaultLayer()));//add by whl
					}
					acutPrintf(jig.m_pszPrompt2);
					INITGET_BEG(-1, jig.m_pszKeyword);
					jig.m_nRetCode = jig.drag();
					INITGET_END();
					int nRet = jig.GetRetCode();
					if (nRet != RTNORM && nRet != RTKWORD)
					{
						if (pStep!=NULL)
							delete pStep;
						if (::IsWindow(dlg.m_hWnd))
							dlg.DestroyWindow();
						return;
					}
					if (nRet == RTKWORD)
					{
						m = RTKWORD;
						goto RETURN;
					}
					if (nRet == RTNORM)
						m = RTNORM;
				}
				if (dlg.GetDrawType() == 7)
				{
					if (pStep!=NULL)
					{
						delete pStep;
						pStep = new TDbStep;
						pStep->setLayer(InitLayer(pStep->GetDefaultLayer()));//add by whl
					}
					m = Zihuitaijie(&dlg,pStep);
					if (m != RTNORM && m != RTKWORD)
					{
						if (pStep!=NULL)
							delete pStep;
						break;
					}
				}
				else if (dlg.GetDrawType() == 6)
				{
					if (pStep!=NULL)
					{
						delete pStep;
						pStep = new TDbStep;
						pStep->setLayer(InitLayer(pStep->GetDefaultLayer()));//add by whl
					}
					m = PlateYIxingtaijie(&dlg,pStep);
					if (m != RTNORM && m != RTKWORD)
					{
						if (pStep!=NULL)
							delete pStep;
						break;
					}
				}
				else if (dlg.GetDrawType() == 5)
				{
					if (pStep!=NULL)
					{
						delete pStep;
						pStep = new TDbStep;
						pStep->setLayer(InitLayer(pStep->GetDefaultLayer()));//add by whl
					}
					m = Yanqiangyixingtaijie(&dlg,pStep);
					if (m != RTNORM && m != RTKWORD)
					{
						if (pStep!=NULL)
							delete pStep;
						break;
					}
				}
			}
			if (m == RTNORM)
			{
				jig.m_pStep->AddToMSpace(Adesk::kTrue);
				ads_redraw(NULL,0);
			}
	}//while循环结束
	if (::IsWindow(dlg.m_hWnd))
		dlg.DestroyWindow();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Command:编辑台阶
int EditStep(AcDbObjectId id)
{
	/*
	int nCmdDia=0;
	VERIFY(xg_getvar(_T("CMDDIA"), &nCmdDia)==RTNORM);
	if (!nCmdDia) 
	return EditStep0(id);
	*/
	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbStep, pStep);
	if (!pStep)
		return RTERROR;

	double nStepWidth=pStep->GetStepWidth();
	double nStepHeight=pStep->GetStepHeight();
	int nStepNum=pStep->GetStepNum();
	double nElev=pStep->GetElevation();

	CStepDlg myStep(acedGetAcadFrame());
	myStep.m_strElevation = (const TCHAR *)Dist2Str(nElev);
	myStep.m_nCount = nStepNum;
	if (nStepWidth < 0)		{
		myStep.m_bTop = false;
	}
	myStep.m_strAllHeight = (const TCHAR *)Dist2Str(fabs(nStepNum * nStepHeight));
	myStep.m_strHeight.Format(_T("%.2f"), fabs(nStepHeight));
	myStep.m_strWidth = (const TCHAR *)Dist2Str(fabs(nStepWidth));
	if ((nStepWidth > 0.0 && nStepHeight < 0.0)||(nStepWidth < 0.0 && nStepHeight > 0.0))
		myStep.m_bIsDownStep = TRUE;

	CAcModuleResourceOverride tVar;        
	if (myStep.DoModal()==IDOK) {
		nStepNum = 	myStep.m_nCount;
		nElev = _tstof(myStep.m_strElevation);
		nStepWidth = _tstof(myStep.m_strWidth);
		nStepHeight = _tstof(myStep.m_strHeight);
		/*if (!myStep.m_bTop)		{
		nStepHeight = 0 - nStepHeight;
		nStepWidth = 0 - nStepWidth;
		}*/
		if (!myStep.m_bTop)//基面为外轮廓面
		{
			if (!myStep.m_bIsDownStep)//上升台阶
				nStepHeight = - nStepHeight;
			nStepWidth = -nStepWidth;
		}
		else//基面为内轮廓面
		{
			if (myStep.m_bIsDownStep)//下降台阶
				nStepHeight = - nStepHeight;
		}


		if (pStep->upgradeOpen()!=Acad::eOk)
			return RTERROR;
		pStep->assertWriteEnabled();

		pStep->SetStepWidth(nStepWidth);
		pStep->SetStepHeight(nStepHeight);
		pStep->SetStepNum(nStepNum);
		pStep->SetElevation(nElev);
		pStep->downgradeOpen();
	}
	OPENOBJ_END();

	return RTNORM;
}

// 斜坡
void Ascent()
{
	//CAscentDlg dlg(acedGetAcadFrame());

	//   {
	//CAcModuleResourceOverride vTemp;
	//if (dlg.DoModal() != IDOK){
	//	return;
	//}
	//   }
	//   TDbAscent *pStep = new TDbAscent;
	//dlg.Dlg2Obj(pStep);
	//   CPoint ptCursor;
	//   XPoint ptLoc;
	//   if (GetCursorPos(&ptCursor)) 
	//{
	//       acedGetAcadDwgView()->ScreenToClient(&ptCursor);
	//       acedCoordFromPixelToWorld(ptCursor, ptLoc);
	//       ptLoc=Wcs2Ucs(ptLoc);
	//   }

	//   pStep->SetLocation(Ucs2Wcs(ptLoc));

	//   XVector3D vtRot(1,0,0);
	//   vtRot=Ucs2Wcs(vtRot, TRUE);
	//   pStep->SetRotation(ads_angle(XPoint(), vtRot));
	//   AcDbObjectId idLast=pStep->AddToMSpace(Adesk::kTrue);
	//   ASSERT(!!idLast);
	//   OPENOBJ_BEGIN(idLast, AcDb::kForRead, AcDbEntity, pEnt);
	//   if (pEnt)
	//       pEnt->draw();
	//   OPENOBJ_END();
	//   PickSet ss(SS_FREE);
	//   ss += idLast;
	//   if (DragPickSet(ss, ptLoc)!=RTNORM) {
	//       ss.Redraw(1);
	//       ss.Delete();
	//   }

	////add by xlc on 070514
	////设置斜坡标高
	//else
	//{
	//	OPENOBJ_BEGIN(idLast, AcDb::kForWrite, TDbAscent, pEnt);
	//	if (pEnt)
	//		pEnt->SetElevation(_tstof(dlg.m_strAscentElev));
	//	OPENOBJ_END();
	//}
	CAcModuleResourceOverride vTemp;
	CAscentCreateDlg *dlg=new CAscentCreateDlg(acedGetAcadFrame());
	dlg->Create(IDD_ASCENT1,acedGetAcadFrame());
	CAscentCreateDlg::m_bpSelfCAC=dlg;
	while(CAscentCreateDlg::m_bpSelfCAC!=NULL && CAscentCreateDlg::m_bpSelfCAC->GetSafeHwnd()!=NULL)
	{
		TDbAscent *pStep = new TDbAscent;
		dlg->Dlg2Obj(pStep);
		CPoint ptCursor;
		XPoint ptLoc;
		if (GetCursorPos(&ptCursor)) 
		{
			acedGetAcadDwgView()->ScreenToClient(&ptCursor);
			acedCoordFromPixelToWorld(ptCursor, ptLoc);
			ptLoc=Wcs2Ucs(ptLoc);
		}

		pStep->SetLocation(Ucs2Wcs(ptLoc));

		XVector3D vtRot(1,0,0);
		vtRot=Ucs2Wcs(vtRot, TRUE);
		pStep->SetRotation(ads_angle(XPoint(), vtRot));
		AcDbObjectId idLast=pStep->AddToMSpace(Adesk::kTrue);
		ASSERT(!!idLast);
		OPENOBJ_BEGIN(idLast, AcDb::kForRead, AcDbEntity, pEnt);
		if (pEnt)
			pEnt->draw();
		OPENOBJ_END();
		PickSet ss(SS_FREE);
		ss += idLast;
		int i=DragPickSet(ss,ptLoc);
		if (i!=RTNORM) {
			if (i==RTCAN)
			{
				if (CAscentCreateDlg::m_bUpdateEdit==TRUE)
				{
					CAscentCreateDlg::m_bUpdateEdit=FALSE;
				}
				else
				{
					ss.Redraw(1);
					ss.Delete();
					break;
				}
			}
			if (i==RTNONE)
			{
				ss.Redraw(1);
				ss.Delete();
				break;
			}

			ss.Redraw(1);
			ss.Delete();
		}
		//add by xlc on 070514
		//设置斜坡标高
		else
		{
			OPENOBJ_BEGIN(idLast, AcDb::kForWrite, TDbAscent, pEnt);
			if (pEnt)
				pEnt->SetElevation(_tstof(dlg->m_strAscentElev));
			OPENOBJ_END();
		}
		pStep=NULL;
	}
	dlg->DestroyWindow();
}


// Command:编辑台阶
int EditAscent(AcDbObjectId id)
{
	/*
	int nCmdDia=0;
	VERIFY(xg_getvar(_T("CMDDIA"), &nCmdDia)==RTNORM);
	if (!nCmdDia) 
	return EditAscent0(id);
	*/
	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbAscent, pStep);
	if (!pStep)
		return RTERROR;

	// Zyu modify on 100722，支持64位
	//int ret;
	INT_PTR ret;
	CAscentDlg dlg(acedGetAcadFrame());
	dlg.Obj2Dlg(pStep);
	{
		CAcModuleResourceOverride vTemp;
		ret = dlg.DoModal();
	}
	if (ret != IDOK)
		return RTERROR;
	if (pStep->upgradeOpen()!=Acad::eOk)
		return RTERROR;
	pStep->assertWriteEnabled();
	dlg.Dlg2Obj(pStep);
	pStep->downgradeOpen();

	OPENOBJ_END();

	return RTNORM;
}

// sg add 111130，根据9.0需求，增加踏步切换命令
void StepStoneSwitchCmd()
{
	//对象捕捉增加“最近点”
	int iOsMode = 0;
	TGGetVar(_T("OSMODE"), &iOsMode);
	iOsMode %= 0x4000;	   // 在对象捕捉关闭时,打开对象捕捉
	XPushVar<int> vOsMode(_T("OSMODE"), iOsMode | OS_NEA);

	//选择台阶
	RBList mask(RTDXF0, _T("TCH_STEP"), NULL);
	Entity entStep;
	int istats = entStep.FilterSelect1(0,_T("\n请选择台阶<退出>: "), mask, NULL);
	if(istats != RTNORM)
	{	
		return;
	}

	//高亮显示
	OPENOBJ_BEGIN(entStep,AcDb::kForRead,TDbStep,pEntHighlight);
	if (pEntHighlight)
	{
		pEntHighlight->draw();
		pEntHighlight->highlight();
	}
	OPENOBJ_END();

	while (true)
	{
		//取点
		AcGePoint3d pt;
		if (acedGetPoint(NULL,_T("\n请点取需要添加或删除踏步的台阶边界<退出>:"),asDblArray(pt)) != RTNORM)
		{
			break;
		}

		//打开台阶对象修改属性
		OPENOBJ_BEGIN(entStep,AcDb::kForWrite,TDbStep,pStep);
		if (pStep)
		{
			int iEdNum = pStep->GetEdgeNum();          //边数
			XPoly2D outline = pStep->GetStepOutline(); //轮廓线

			double dMin = 1000000.0;
			int index = -1;

			for (int i=0;i<iEdNum;i++)
			{
				TGGeCurveSegment cvSegent;
				outline.Nth(i,cvSegent);

				TADSGePoint3d ptProject;//投影点
				cvSegent.ProjectToMe(pt,ptProject);
			
				int iType = cvSegent.GetCurveType();
				bool bOnSegent= false;
				if (iType == CURVE_ARC)//弧
				{
					TGGeArc arc = cvSegent.GetArc();
					TADSGePoint3d ptCenter = arc.GetCenterPt();
					ads_real startAngle = arc.GetStarAngle();
					ads_real endAngle = arc.GetEndAngle();
					if (startAngle > endAngle)
					{
						endAngle+=2*PI;
					}
			     	ads_real angle = ads_angle(ptCenter,ptProject);
					if (startAngle< angle && angle<endAngle)
					{
						bOnSegent = true;
					}
 				}
				else 
				{
					int iRe = cvSegent.HitTest2d(ptProject);
					if (iRe == 5)
					{
						bOnSegent = true;
					}
				}

				if (bOnSegent)//投影点在"曲线段上"
				{
					double dDist = acutDistance(asDblArray(pt),asDblArray(ptProject.AsAcGePoint3d()));
					if (dDist < dMin)
					{
						dMin = dDist;
						index = i;
					}
				}
			}

			if (index >=0)
			{
				if (pStep->HasStepAt(index))
				{
					pStep->SetStepAt(index,false);
				}
				else
				{
					pStep->SetStepAt(index,true);
				}
			}
		}

		//高亮显示
		pStep->draw();
		pStep->highlight();

		OPENOBJ_END();

	}//end of true

	//取消高亮
	OPENOBJ_BEGIN(entStep,AcDb::kForRead,TDbStep,pEntunHighlight);
	if (pEntunHighlight)
	{
		pEntunHighlight->draw();
		pEntunHighlight->unhighlight();
	}
	OPENOBJ_END();

}