#include "stdafx.h"
#include "AecDbParaLlelStair.h"
#include "AecDbParaLlelStairDraw.h"
#include "AecDbEarthWorm.h"
#include "AcDbX3dSolid.h"
#include "EarThwormDef.h"
#include "CoreTools.h"
#include "gpc.h"

static const Adesk::UInt16 kColorByBlock = 0;
static const Adesk::UInt16 kRed = 1;
static const Adesk::UInt16 kYellow = 2;
static const Adesk::UInt16 kGreen = 3;
static const Adesk::UInt16 kCyan = 4;
static const Adesk::UInt16 kBlue = 5;
static const Adesk::UInt16 kMagenta = 6;
static const Adesk::UInt16 kWhite = 7;
static const Adesk::UInt16 kColorByLayer = 256;

DLLIMPEXP AcDbPolyline *FormatPolyline(AcGePoint3d *ppPts, int nCount);
DLLIMPEXP AcDb3dPolyline *Format3dPolyline(const AcGePoint3dArray &arPts);

ACRX_CONS_DEFINE_MEMBERS(AecDbParaLlelStairDraw, AecDbXDraw, 0);

namespace
{
	AcDbRegion *makeRectRegion(const AcGePoint3d& ptOrg, const double& dL, const double& dW, const AcGeVector3d& vecL, const AcGeVector3d& vecW)
	{
		AcGePoint3d ptGe[5];
		AcGePoint3d pt1(ptOrg), pt2, pt3, pt4;

		pt1 += vecW * dW * .5;
		pt1 += vecL * dL * .5;
		pt2 = pt1 - vecW * dW;
		pt3 = pt2 - vecL * dL;
		pt4 = pt3 + vecW * dW;

		ptGe[0] = pt1;
		ptGe[1] = pt2;
		ptGe[2] = pt3;
		ptGe[3] = pt4;
		ptGe[4] = ptGe[0];
		AcDbRegion *pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 5);
		if (!pReg) return NULL;
		return pReg;
	}

	AcDbRegion *makeCircleRegion(const AcGePoint3d& ptOrg, const AcGeVector3d& vtZ, const double& dR)
	{
		AcDbCircle *pCir(new AcDbCircle(ptOrg, vtZ, dR));
		AcDbRegion *pReg = CoreTools::createRegion(pCir);
		DELETE_PTR(pCir);
		return pReg;
	}

	void drawText(AcGiDraw& dc
		, const ACHAR* text
		, const double& dTextH
		, const AcGePoint3d& ptAlign
		, const double& dAngle
		, const AcGeVector3d& vtTrans
		, AcDb::TextHorzMode nHorMode
		, AcDb::TextVertMode nVerMode
		, AcGiDraw::TextAlignment nAlign)
	{
		AcDbText* pText = new AcDbText();
		if (pText == NULL) return;

		pText->setTextString(text);
		pText->setHeight(dTextH);

		AcDbExtents ext;
		pText->getGeomExtents(ext);
		pText->setHorizontalMode(nHorMode);
		pText->setVerticalMode(nVerMode);
		pText->setAlignmentPoint(ptAlign);
		AcGeMatrix3d mat;
		mat.setToRotation(dAngle, vtTrans, ptAlign);
		pText->setPosition(dc.Align2Base(nAlign, ptAlign, ext.maxPoint()));
		pText->transformBy(mat);
		pText->setColorIndex(1);

		dc.DrawEntity(pText);
		dc.Add2dBuffer(pText);
	}
}

AecDbParaLlelStairDraw::AecDbParaLlelStairDraw(void)
{
}

AecDbParaLlelStairDraw::~AecDbParaLlelStairDraw(void)
{

}

Acad::ErrorStatus AecDbParaLlelStairDraw::Draw2d(AcGiDraw &dc) const
{
	AcDbObjectId idCurLay = dc.GetLayerId();
	AcDbObjectId idCurLty = dc.GetLineTypeId();
	AcDbEntity* pEntReal = GetAttach();
	if (pEntReal == NULL)
		return Acad::eOk;

	AecDbParaLlelStair* pParlStair = AecDbParaLlelStair::cast(pEntReal);
	if (pParlStair == NULL)
		return Acad::eOk;

	Adesk::UInt16 nCrBk = 256;
	nCrBk = pEntReal->colorIndex();
	dc.SetLayer(pEntReal->layerId());

	int nColor = nCrBk;
	if (GetSpecialtyData()->GetAt(_T("COLOR"), nColor))
	{
		dc.SetColor(nColor);
	}

	SFPXStair data;
	memset(&data, 0, sizeof(SFPXStair));
	pParlStair->GetSFPXStair(data);

	//.....
	AcDbVoidPtrArray arEntPtrs;
	AcDbCurve* pBaseCurve = pParlStair->GetBaseCurve();
	if (pBaseCurve != NULL)
	{
		AcDbLine* pLn = AcDbLine::cast(pBaseCurve);
		if (pLn != NULL)
		{
			AcGePoint3d ptSta, ptEnd;
			ptSta = pLn->startPoint();
			ptEnd = pLn->endPoint();
			ptSta.z = ptEnd.z = 0.0;

			AcGeVector3d vtSE, vtSEDir, Z(AcGeVector3d::kZAxis);
			vtSEDir = (ptSta - ptEnd).normalize();
			vtSE = vtSEDir;
			vtSE.rotateBy(PI / 2.0, Z);
			vtSE.normalize();

			if (data.nRestShape == 0)
			{
				DrawRestPlatRect2d(dc, ptSta, vtSE, vtSEDir, data);
			}
			else if (data.nRestShape == 1)
			{
				DrawRestPlatCir2d(dc, ptSta, vtSE, vtSEDir, data);
			}

			DrawWithin(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
			DrawStairSpace2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);

			if (data.nSteepMs == data.nSteepsS)
			{
				DrawStair2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.dStairSW, data.nSteepsS, data);
				DrawOutHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
				DrawBeam2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);

				DrawStair2d(dc, ptSta - vtSE * (data.dStairTW - data.dStairMW) * .5, ptEnd, vtSE, vtSEDir, data.dStairMW, data.nSteepMs, data);
				DrawInHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.nSteepsS, data);

				DrawStair2d(dc, ptSta - vtSE * data.dStairTW, ptEnd, -vtSE, vtSEDir, data.dStairSW, data.nSteepsS, data);
				DrawOutHandRail2d(dc, ptSta - vtSE * data.dStairTW, ptEnd, -vtSE, vtSEDir, data);
			}
			else
			{
				if (data.nSteepAlign == 0 || data.nSteepAlign == 3)
				{
					DrawStair2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.dStairSW, data.nSteepsS, data);
					DrawOutHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
					DrawBeam2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);

					DrawStair2d(dc, ptSta - vtSE * (data.dStairTW - data.dStairMW) * .5, ptEnd, vtSE, vtSEDir, data.dStairMW, data.nSteepMs, data);
					if (data.nSteepMs > data.nSteepsS)
					{
						DrawInHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.nSteepMs, data);
					}
					else if (data.nSteepMs < data.nSteepsS)
					{
						DrawInHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.nSteepsS, data);
					}

					DrawStair2d(dc, ptSta - vtSE * data.dStairTW, ptEnd, -vtSE, vtSEDir, data.dStairSW, data.nSteepsS, data);
					DrawOutHandRail2d(dc, ptSta - vtSE * data.dStairTW, ptEnd, -vtSE, vtSEDir, data);
				}
				else if (data.nSteepAlign == 1)
				{
					if (data.nSteepMs > data.nSteepsS)
					{
						ptSta -= vtSEDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
						DrawStair2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.dStairSW, data.nSteepsS, data);
						DrawOutHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
						DrawBeam2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);

						ptSta -= vtSE * ((data.dStairTW - data.dStairMW) * .5);
						ptSta += vtSEDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
						DrawStair2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.dStairMW, data.nSteepMs, data);

						ptSta += vtSE * ((data.dStairTW - data.dStairMW) * .5);
						DrawInHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.nSteepMs, data);

						ptSta -= vtSEDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
						ptSta -= vtSE * data.dStairTW;
						DrawStair2d(dc, ptSta, ptEnd, -vtSE, vtSEDir, data.dStairSW, data.nSteepsS, data);
						DrawOutHandRail2d(dc, ptSta, ptEnd, -vtSE, vtSEDir, data);
					}
					else if (data.nSteepMs < data.nSteepsS)
					{
						DrawStair2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.dStairSW, data.nSteepsS, data);
						DrawOutHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
						DrawBeam2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);

						DrawInHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.nSteepsS, data);
						ptSta -= vtSE * ((data.dStairTW - data.dStairMW) * .5);
						ptSta -= vtSEDir * (data.nSteepsS - data.nSteepMs) * data.dSteepW * .5;
						DrawStair2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.dStairMW, data.nSteepMs, data);

						ptSta += vtSE * ((data.dStairTW - data.dStairMW) * .5);
						ptSta += vtSEDir * (data.nSteepsS - data.nSteepMs) * data.dSteepW * .5;
						ptSta -= vtSE * data.dStairTW;
						DrawStair2d(dc, ptSta, ptEnd, -vtSE, vtSEDir, data.dStairSW, data.nSteepsS, data);
						DrawOutHandRail2d(dc, ptSta, ptEnd, -vtSE, vtSEDir, data);
					}
				}
				else if (data.nSteepAlign == 2)
				{
					if (data.nSteepMs > data.nSteepsS)
					{
						ptSta -= vtSEDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
						DrawStair2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.dStairSW, data.nSteepsS, data);
						DrawOutHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
						DrawBeam2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);

						ptSta -= vtSE * ((data.dStairTW - data.dStairMW) * .5);
						ptSta += vtSEDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
						DrawStair2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.dStairMW, data.nSteepMs, data);
						ptSta += vtSE * ((data.dStairTW - data.dStairMW) * .5);
						DrawInHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.nSteepMs, data);

						ptSta -= vtSEDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
						ptSta -= vtSE * data.dStairTW;
						DrawStair2d(dc, ptSta, ptEnd, -vtSE, vtSEDir, data.dStairSW, data.nSteepsS, data);
						DrawOutHandRail2d(dc, ptSta, ptEnd, -vtSE, vtSEDir, data);
					}
					else if (data.nSteepMs < data.nSteepsS)
					{
						DrawStair2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.dStairSW, data.nSteepsS, data);
						DrawOutHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
						DrawBeam2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data);

						DrawInHandRail2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.nSteepsS, data);
						ptSta -= vtSE * ((data.dStairTW - data.dStairMW) * .5);
						ptSta -= vtSEDir * (data.nSteepsS - data.nSteepMs) * data.dSteepW;
						DrawStair2d(dc, ptSta, ptEnd, vtSE, vtSEDir, data.dStairMW, data.nSteepMs, data);

						ptSta += vtSE * ((data.dStairTW - data.dStairMW) * .5);
						ptSta += vtSEDir * (data.nSteepsS - data.nSteepMs) * data.dSteepW;
						ptSta -= vtSE * data.dStairTW;
						DrawStair2d(dc, ptSta, ptEnd, -vtSE, vtSEDir, data.dStairSW, data.nSteepsS, data);
						DrawOutHandRail2d(dc, ptSta, ptEnd, -vtSE, vtSEDir, data);
					}
				}
			}
		}
	}

	//////////////////////////////
	dc.SetColor(nCrBk);
	dc.SetLayer(idCurLay);
	dc.SetLineType(idCurLty);
	dc.Add2dBuffer(arEntPtrs);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbParaLlelStairDraw::Draw3d(AcGiDraw &dc) const
{
	del3DCache<AecDbParaLlelStair>();
	AcDbObjectId idCurLay = dc.GetLayerId();
	AcDbObjectId idCurLty = dc.GetLineTypeId();
	AcDbEntity *pEntReal = GetAttach();
	if (pEntReal == NULL)
		return Acad::eOk;

	AecDbParaLlelStair *pParlStair = AecDbParaLlelStair::cast(pEntReal);
	if (pParlStair == NULL)
		return Acad::eOk;

	Adesk::UInt16 nCrBk = pEntReal->colorIndex();
	dc.SetLayer(pEntReal->layerId());

	int nColor = nCrBk;
	if (GetSpecialtyData()->GetAt(_T("COLOR"), nColor))
	{
		dc.SetColor(nColor);
	}

	SFPXStair data;
	memset(&data, 0, sizeof(SFPXStair));
	pParlStair->GetSFPXStair(data);

	AcDbCurve *pBaseCurve = pParlStair->GetBaseCurve();
	if (pBaseCurve != NULL)
	{
		AcDbLine* pLn = AcDbLine::cast(pBaseCurve);
		if (pLn != NULL)
		{
			if (data.nSteepsS == 15)
			{
				data.nSteepMs = 5;
			}
			else if (data.nSteepsS == 5)
			{
				data.nSteepMs = 15;
			}
			else if (data.nSteepsS == 10)//边梯步数
			{
				data.nSteepMs = 10;//中梯步数
			}

			AcGePoint3d ptSta, ptEnd, ptPathSta, ptPathEnd;
			ptSta = pLn->startPoint();
			ptEnd = pLn->endPoint();

			AcGeVector3d vtSE, vtSEDir, Z(AcGeVector3d::kZAxis);

			ptSta += Z * data.dBomEl;
			ptEnd += Z * data.dBomEl;

			vtSEDir = (ptSta - ptEnd).normalize();
			vtSE = vtSEDir;
			vtSE.rotateBy(PI / 2.0, Z);
			vtSE.normalize();

			DrawRestPlatform(dc, ptSta, vtSE, vtSEDir, data);

			//踏步取齐
			if (data.nSteepAlign == 0 || data.nSteepAlign == 3)
			{
				if (data.nUpSide == 0)
				{
					DrawAlignPlatMid(dc, ptSta, vtSE, vtSEDir, 0, data.nSteepMs * data.dSteepH, data);
				}
				else
				{
					DrawAlignPlatSide(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
				}
				
			}

			else if (data.nSteepAlign == 1)
			{
				if (data.nUpSide == 0)
				{
					DrawAlignCenMid(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
				}
				else
				{
					DrawAlignCenSide(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
				}
			}

			else if (data.nSteepAlign == 2)
			{
				if (data.nUpSide == 0)
				{
					DrawAlignFloorMid(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
				}
				else
				{
					DrawAlignFloorSide(dc, ptSta, vtSE, vtSEDir, data.nSteepsS * data.dSteepH, data);
				}
			}

		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbParaLlelStairDraw::DrawRestPlatRect2d(AcGiDraw& dc
	, const AcGePoint3d& ptS
	, const AcGeVector3d& vtL
	, const AcGeVector3d& vtW
	, const SFPXStair& data) const
{
	AcGePoint3d ptGe[13];
	AcGePoint3d ptOrg(ptS);
	AcDbPolyline* pPl(NULL);
	if (data.nSteepAlign == 0 || data.nSteepAlign == 3 || data.nSteepMs == data.nSteepsS)
	{
		ptGe[0] = ptOrg;
		ptGe[1] = ptGe[0] - vtW * data.dRestPtW;
		ptGe[2] = ptGe[1] - vtL * data.dStairTW;
		ptGe[3] = ptGe[2] + vtW * data.dRestPtW;
		ptGe[4] = ptGe[0];

		pPl = (AcDbPolyline*)FormatPolyline(ptGe, 5);
		if (!pPl) return Acad::eOk;
		pPl->setColorIndex(2);
		dc.DrawEntity(pPl);
		dc.Add2dBuffer(pPl);
	}

	else if (data.nSteepAlign == 1)
	{
		if (data.nSteepMs > data.nSteepsS)
		{
			ptGe[0] = ptOrg;
			ptGe[1] = ptGe[0] - vtW * (data.dRestPtW + (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5);
			ptGe[2] = ptGe[1] - vtL * (data.dStairSW - data.dGarSize[0] - data.dBarSide);
			ptGe[3] = ptGe[2] + vtW * (data.dGarExt + (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5 + data.dGarSize[0]);
			ptGe[4] = ptGe[3] - vtL * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 + data.dGarSize[0] * 2 + data.dBarSide * 2);
			ptGe[5] = ptGe[4] - vtW * (data.dGarExt + data.dGarSize[0]);
			ptGe[6] = ptGe[5] - vtL * (data.dStairMW - data.dGarSize[0] * 2 - data.dBarSide * 2);
			ptGe[7] = ptGe[6] + vtW * (data.dGarExt + data.dGarSize[0]);
			ptGe[8] = ptGe[7] - vtL * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 + data.dGarSize[0] * 2 + data.dBarSide * 2);
			ptGe[9] = ptGe[8] - vtW * (data.dGarExt + (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5 + data.dGarSize[0]);
			ptGe[10] = ptGe[9] - vtL * (data.dStairSW - data.dGarSize[0] - data.dBarSide);
			ptGe[11] = ptGe[10] + vtW * (data.dRestPtW + (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5);
			ptGe[12] = ptGe[0];
		}

		if (data.nSteepMs < data.nSteepsS)
		{
			ptGe[0] = ptOrg;
			ptGe[1] = ptGe[0] - vtW * data.dRestPtW;
			ptGe[2] = ptGe[1] - vtL * (data.dStairSW - data.dGarSize[0] - data.dBarSide);
			ptGe[3] = ptGe[2] + vtW * (data.dGarExt + data.dGarSize[0]);
			ptGe[4] = ptGe[3] - vtL * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 + data.dGarSize[0] * 2 + data.dBarSide * 2);
			ptGe[5] = ptGe[4] - vtW * (data.dGarExt + (data.nSteepsS - data.nSteepMs) * data.dSteepW * .5 + data.dGarSize[0]);

			ptGe[6] = ptGe[5] - vtL * (data.dStairMW - data.dGarSize[0] * 2 - data.dBarSide * 2);
			ptGe[7] = ptGe[6] + vtW * (data.dGarExt + (data.nSteepsS - data.nSteepMs) * data.dSteepW * .5 + data.dGarSize[0]);

			ptGe[8] = ptGe[7] - vtL * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 + data.dGarSize[0] * 2 + data.dBarSide * 2);
			ptGe[9] = ptGe[8] - vtW * (data.dGarExt + data.dGarSize[0]);
			ptGe[10] = ptGe[9] - vtL * (data.dStairSW - data.dGarSize[0] - data.dBarSide);
			ptGe[11] = ptGe[10] + vtW * data.dRestPtW;
			ptGe[12] = ptGe[0];
		}

		pPl = (AcDbPolyline*)FormatPolyline(ptGe, 13);
		if (!pPl) return Acad::eOk;
		pPl->setColorIndex(2);
		dc.DrawEntity(pPl);
		dc.Add2dBuffer(pPl);
	}

	else if (data.nSteepAlign == 2)
	{
		if (data.nSteepMs > data.nSteepsS)
		{
			ptGe[0] = ptOrg;
			ptGe[1] = ptGe[0] - vtW * (data.dRestPtW + (data.nSteepMs - data.nSteepsS) * data.dSteepW);
			ptGe[2] = ptGe[1] - vtL * (data.dStairSW - data.dGarSize[0] - data.dBarSide);
			ptGe[3] = ptGe[2] + vtW * (data.dGarExt + (data.nSteepMs - data.nSteepsS) * data.dSteepW + data.dGarSize[0]);
			ptGe[4] = ptGe[3] - vtL * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 + data.dGarSize[0] * 2 + data.dBarSide * 2);
			ptGe[5] = ptGe[4] - vtW * (data.dGarExt + data.dGarSize[0]);
			ptGe[6] = ptGe[5] - vtL * (data.dStairMW - data.dGarSize[0] * 2 - data.dBarSide * 2);
			ptGe[7] = ptGe[6] + vtW * (data.dGarExt + data.dGarSize[0]);
			ptGe[8] = ptGe[7] - vtL * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 + data.dGarSize[0] * 2 + data.dBarSide * 2);
			ptGe[9] = ptGe[8] - vtW * (data.dGarExt + (data.nSteepMs - data.nSteepsS) * data.dSteepW + data.dGarSize[0]);
			ptGe[10] = ptGe[9] - vtL * (data.dStairSW - data.dGarSize[0] - data.dBarSide);
			ptGe[11] = ptGe[10] + vtW * (data.dRestPtW + (data.nSteepMs - data.nSteepsS) * data.dSteepW);
			ptGe[12] = ptGe[0];
		}

		if (data.nSteepMs < data.nSteepsS)
		{
			ptGe[0] = ptOrg;
			ptGe[1] = ptGe[0] - vtW * data.dRestPtW;
			ptGe[2] = ptGe[1] - vtL * (data.dStairSW - data.dGarSize[0] - data.dBarSide);
			ptGe[3] = ptGe[2] + vtW * (data.dGarExt + data.dGarSize[0]);
			ptGe[4] = ptGe[3] - vtL * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 + data.dGarSize[0] * 2 + data.dBarSide * 2);
			ptGe[5] = ptGe[4] - vtW * (data.dGarExt + (data.nSteepsS - data.nSteepMs) * data.dSteepW + data.dGarSize[0]);
			ptGe[6] = ptGe[5] - vtL * (data.dStairMW - data.dGarSize[0] * 2 - data.dBarSide * 2);
			ptGe[7] = ptGe[6] + vtW * (data.dGarExt + (data.nSteepsS - data.nSteepMs) * data.dSteepW + data.dGarSize[0]);
			ptGe[8] = ptGe[7] - vtL * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 + data.dGarSize[0] * 2 + data.dBarSide * 2);
			ptGe[9] = ptGe[8] - vtW * (data.dGarExt + data.dGarSize[0]);
			ptGe[10] = ptGe[9] - vtL * (data.dStairSW - data.dGarSize[0] - data.dBarSide);
			ptGe[11] = ptGe[10] + vtW * data.dRestPtW;
			ptGe[12] = ptGe[0];
		}

		pPl = (AcDbPolyline*)FormatPolyline(ptGe, 13);
		if (!pPl) return Acad::eOk;
		pPl->setColorIndex(2);
		dc.DrawEntity(pPl);
		dc.Add2dBuffer(pPl);
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbParaLlelStairDraw::DrawRestPlatCir2d(AcGiDraw& dc
	, const AcGePoint3d& ptSta
	, const AcGeVector3d& vtL
	, const AcGeVector3d& vtW
	, const SFPXStair& data) const
{
	AcGePoint3d ptGeL[2];
	AcGePoint3d ptGeR[2];

	AcGePoint3d ptOrg(ptSta), pt, ptS, ptE, ptS1, ptE1;
	AcDbPolyline *pPl(NULL), *pPl1(NULL);

	AcDbVoidPtrArray ar;
	AcDbRegion *pReg(NULL);

	pt = ptOrg - vtL * data.dStairTW;
	AcDbPolyline* pPoly = new AcDbPolyline();
	pPoly->addVertexAt(0, ptOrg.convert2d(AcGePlane::kXYPlane), -1);
	pPoly->addVertexAt(1, pt.convert2d(AcGePlane::kXYPlane));
	if (!pPoly) return Acad::eOk;

	pPoly->getStartPoint(ptS);
	pPoly->getEndPoint(ptE);
	ptS1 = ptS - vtW * data.dRestPtW;
	ptE1 = ptE - vtW * data.dRestPtW;

	ar.append(new AcDbLine(ptS, ptS1));
	ar.append(new AcDbLine(ptS1, ptE1));
	ar.append(new AcDbLine(ptE1, ptE));
	ar.append(pPoly);

	pReg = CoreTools::createRegion(ar);
	if (pReg == NULL) return Acad::eOk;

	pReg->setColorIndex(2);
	dc.DrawEntity(pReg);
	dc.Add2dBuffer(pReg);

	if (data.nSteepMs > data.nSteepsS)
	{
		if (data.nSteepAlign == 1)
		{
			ptGeL[0] = ptS;
			ptGeL[1] = ptGeL[0] - vtW * (data.dRestPtW + (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5);

			pPl = (AcDbPolyline*)FormatPolyline(ptGeL, 2);
			if (!pPl) return Acad::eOk;
			pPl->setColorIndex(2);
			dc.DrawEntity(pPl);
			dc.Add2dBuffer(pPl);

			ptGeR[0] = ptS - vtL * data.dStairTW;
			ptGeR[1] = ptGeR[0] - vtW * (data.dRestPtW + (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5);

			pPl1 = (AcDbPolyline*)FormatPolyline(ptGeR, 2);
			if (!pPl1) return Acad::eOk;
			pPl1->setColorIndex(2);
			dc.DrawEntity(pPl1);
			dc.Add2dBuffer(pPl1);
		}
		else if (data.nSteepAlign == 2)

		{
			ptGeL[0] = ptS;
			ptGeL[1] = ptGeL[0] - vtW * (data.dRestPtW + (data.nSteepMs - data.nSteepsS) * data.dSteepW);

			pPl = (AcDbPolyline*)FormatPolyline(ptGeL, 2);
			if (!pPl) return Acad::eOk;
			pPl->setColorIndex(2);
			dc.DrawEntity(pPl);
			dc.Add2dBuffer(pPl);

			ptGeR[0] = ptS - vtL * data.dStairTW;
			ptGeR[1] = ptGeR[0] - vtW * (data.dRestPtW + (data.nSteepMs - data.nSteepsS) * data.dSteepW);

			pPl1 = (AcDbPolyline*)FormatPolyline(ptGeR, 2);
			if (!pPl1) return Acad::eOk;
			pPl1->setColorIndex(2);
			dc.DrawEntity(pPl1);
			dc.Add2dBuffer(pPl1);
		}
	}
	
	return Acad::eOk;
}

Acad::ErrorStatus AecDbParaLlelStairDraw::DrawStair2d(AcGiDraw& dc
	, const AcGePoint3d& ptSta
	, const AcGePoint3d& ptEnd
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const double& dist
	, const int& num
	, const SFPXStair& data) const
{
	AcGePoint3d ptS(ptSta), ptE;
	AcGePoint3d ptGe[5];
	AcDbPolyline *pPoly(NULL);
	AcDbLine *pLine(NULL);

	ptGe[0] = ptS - vtDir * data.dRestPtW;
	ptGe[1] = ptGe[0] - vtDir * (num - 1) * data.dSteepW;
	ptGe[2] = ptGe[1] - vt * dist;
	ptGe[3] = ptGe[2] + vtDir * (num - 1) * data.dSteepW;
	ptGe[4] = ptGe[0];

	AcDbPolyline* pPl = NULL;
	pPl = FormatPolyline(ptGe, 5);
	dc.DrawEntity(pPl);
	dc.Add2dBuffer(pPl);

	ptS -= vtDir * data.dRestPtW;
	for (int i(0); i < num; ++i)
	{
		ptGe[0] = ptS - vtDir * data.dSteepW * i;
		ptGe[1] = ptGe[0] - vt * dist;
		pPoly = (AcDbPolyline*)FormatPolyline(ptGe, 2);
		if (!pPoly) return Acad::eOk;
		pPoly->setColorIndex(2);
		dc.DrawEntity(pPoly);
		dc.Add2dBuffer(pPoly);
	}
	
	return Acad::eOk;
}

Acad::ErrorStatus AecDbParaLlelStairDraw::DrawStairSpace2d(AcGiDraw& dc
	, const AcGePoint3d& ptSta
	, const AcGePoint3d& ptEnd
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const SFSPStair& data) const
{
	AcGePoint3d ptS(ptSta);
	AcGePoint3d ptGe[5];
	int num;

	if (data.nSteepMs == data.nSteepsS || data.nSteepMs > data.nSteepsS)
	{
		num = data.nSteepMs;
	}
	else
	{
		num = data.nSteepsS;
	}

	ptGe[0] = ptS - vtDir * data.dRestPtW;
	ptGe[0] -= vt * data.dStairSW;
	ptGe[1] = ptGe[0] - vtDir * (num - 1) * data.dSteepW;
	ptGe[2] = ptGe[1] - vt * (data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5;
	ptGe[3] = ptGe[2] + vtDir * (num - 1) * data.dSteepW;
	ptGe[4] = ptGe[0];

	AcDbPolyline* pPl = NULL;
	pPl = FormatPolyline(ptGe, 5);
	dc.DrawEntity(pPl);
	dc.Add2dBuffer(pPl);

	ptGe[0] = ptS - vtDir * data.dRestPtW;
	ptGe[0] -= vt * (data.dStairTW - data.dStairSW - (data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5);
	ptGe[1] = ptGe[0] - vtDir * (num - 1) * data.dSteepW;
	ptGe[2] = ptGe[1] - vt * (data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5;
	ptGe[3] = ptGe[2] + vtDir * (num - 1) * data.dSteepW;
	ptGe[4] = ptGe[0];

	AcDbPolyline* pPl1 = NULL;
	pPl1 = FormatPolyline(ptGe, 5);
	dc.DrawEntity(pPl1);
	dc.Add2dBuffer(pPl1);
	return Acad::eOk;
}

Acad::ErrorStatus AecDbParaLlelStairDraw::DrawBeam2d(AcGiDraw& dc
	, const AcGePoint3d& ptSta
	, const AcGePoint3d& ptEnd
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const SFPXStair& data) const
{
	AcGePoint3d ptS(ptSta);
	AcGePoint3d ptGeL[5];
	AcGePoint3d ptGeR[5];
	AcGePoint3d ptGeL1[5];
	AcGePoint3d ptGeR1[5];
	
	double dSidet = 120;

	if (data.bLBeam)
	{
		ptGeL[0] = ptS - vtDir * data.dRestPtW;
		ptGeL[0] -= vt * (data.dStairSW - dSidet);
		ptGeL[1] = ptGeL[0] - vtDir * (data.nSteepsS - 1) * data.dSteepW;
		ptGeL[2] = ptGeL[1] - vt * dSidet;
		ptGeL[3] = ptGeL[2] + vtDir * (data.nSteepsS - 1) * data.dSteepW;
		ptGeL[4] = ptGeL[0];

		AcDbPolyline* pPl = NULL;
		pPl = FormatPolyline(ptGeL, 5);
		if (pPl == NULL) return Acad::eOk;
		dc.DrawEntity(pPl);
		dc.Add2dBuffer(pPl);

		if (data.nSteepMs > data.nSteepsS && data.nSteepAlign == 1)
		{
			ptGeL[0] += vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
		}
		if (data.nSteepMs > data.nSteepsS && data.nSteepAlign == 2)
		{
			ptGeL[0] += vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
		}
		if (data.nSteepMs < data.nSteepsS && data.nSteepAlign == 1)
		{
			ptGeL[0] -= vtDir * (data.nSteepsS - data.nSteepMs) * data.dSteepW * .5;
		}
		if (data.nSteepMs < data.nSteepsS && data.nSteepAlign == 2)
		{
			ptGeL[0] -= vtDir * (data.nSteepsS - data.nSteepMs) * data.dSteepW;
		}
		ptGeR[0] = ptGeL[0] - vt * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 + dSidet);
		ptGeR[1] = ptGeR[0] - vtDir * (data.nSteepMs - 1) * data.dSteepW;
		ptGeR[2] = ptGeR[1] - vt * dSidet;
		ptGeR[3] = ptGeR[2] + vtDir * (data.nSteepMs - 1) * data.dSteepW;
		ptGeR[4] = ptGeR[0];

		AcDbPolyline* pPl1 = NULL;
		pPl1 = FormatPolyline(ptGeR, 5);
		if (pPl1 == NULL) return Acad::eOk;
		dc.DrawEntity(pPl1);
		dc.Add2dBuffer(pPl1);

		ptGeL1[0] = ptGeR[0] - vt * (data.dStairMW - dSidet);
		ptGeL1[1] = ptGeL1[0] - vtDir * (data.nSteepMs - 1) * data.dSteepW;
		ptGeL1[2] = ptGeL1[1] - vt * dSidet;
		ptGeL1[3] = ptGeL1[2] + vtDir * (data.nSteepMs - 1) * data.dSteepW;
		ptGeL1[4] = ptGeL1[0];

		AcDbPolyline* pPl2 = NULL;
		pPl2 = FormatPolyline(ptGeL1, 5);
		if (pPl2 == NULL) return Acad::eOk;
		dc.DrawEntity(pPl2);
		dc.Add2dBuffer(pPl2);

		if (data.nSteepMs > data.nSteepsS && data.nSteepAlign == 1)
		{
			ptGeL[0] -= vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
		}
		if (data.nSteepMs > data.nSteepsS && data.nSteepAlign == 2)
		{
			ptGeL[0] -= vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
		}
		if (data.nSteepMs < data.nSteepsS && data.nSteepAlign == 1)
		{
			ptGeL[0] += vtDir * (data.nSteepsS - data.nSteepMs) * data.dSteepW * .5;
		}
		if (data.nSteepMs < data.nSteepsS && data.nSteepAlign == 2)
		{
			ptGeL[0] += vtDir * (data.nSteepsS - data.nSteepMs) * data.dSteepW;
		}
		ptGeR1[0] = ptGeL[0] - vt * (data.dStairTW - data.dStairSW * 2 + dSidet);
		ptGeR1[1] = ptGeR1[0] - vtDir * (data.nSteepsS - 1) * data.dSteepW;
		ptGeR1[2] = ptGeR1[1] - vt * dSidet;
		ptGeR1[3] = ptGeR1[2] + vtDir * (data.nSteepsS - 1) * data.dSteepW;
		ptGeR1[4] = ptGeR1[0];

		AcDbPolyline* pPl3 = NULL;
		pPl3 = FormatPolyline(ptGeR1, 5);
		if (pPl3 == NULL) return Acad::eOk;
		dc.DrawEntity(pPl3);
		dc.Add2dBuffer(pPl3);
	}

	if (data.bRBeam)
	{
		ptGeL[0] = ptS - vtDir * data.dRestPtW;
		ptGeL[1] = ptGeL[0] - vtDir * (data.nSteepsS - 1) * data.dSteepW;
		ptGeL[2] = ptGeL[1] - vt * dSidet;
		ptGeL[3] = ptGeL[2] + vtDir * (data.nSteepsS - 1) * data.dSteepW;
		ptGeL[4] = ptGeL[0];

		AcDbPolyline* pPl = NULL;
		pPl = FormatPolyline(ptGeL, 5);
		if (pPl == NULL) return Acad::eOk;
		dc.DrawEntity(pPl);
		dc.Add2dBuffer(pPl);

		ptGeR[0] = ptGeL[0] - vt * (data.dStairTW - dSidet);
		ptGeR[1] = ptGeR[0] - vtDir * (data.nSteepsS - 1) * data.dSteepW;
		ptGeR[2] = ptGeR[1] - vt * dSidet;
		ptGeR[3] = ptGeR[2] + vtDir * (data.nSteepsS - 1) * data.dSteepW;
		ptGeR[4] = ptGeR[0];

		AcDbPolyline* pPl1 = NULL;
		pPl1 = FormatPolyline(ptGeR, 5);
		if (pPl1 == NULL) return Acad::eOk;
		dc.DrawEntity(pPl1);
		dc.Add2dBuffer(pPl1);
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbParaLlelStairDraw::DrawOutHandRail2d(AcGiDraw& dc
	, const AcGePoint3d& ptSta
	, const AcGePoint3d& ptEnd
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const SFSPStair& data) const
{
	AcGePoint3d ptOrg(ptSta);
	AcGePoint3d pt0, pt1, pt2, pt3;
	AcGePoint3d ptGe[5];

	if (data.bOutSideHRail)
	{
		ptOrg -= vtDir * (data.dRestPtW + (data.nSteepsS - 1) * data.dSteepW * .5);
		ptOrg -= vt * (data.dBarSide + data.dGarSize[0] * .5);
		if (data.nSteepMs == data.nSteepsS)
		{
			pt0 = ptOrg + vt * (data.dGarSize[0] * .5);
			pt0 += vtDir * ((data.nSteepsS - 1) * data.dSteepW * .5 + data.dGarExt);
			pt1 = pt0 - vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
			pt2 = pt1 - vt * data.dGarSize[0];
			pt3 = pt2 + vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
		}

		else if (data.nSteepMs > data.nSteepsS)
		{
			if (data.nSteepAlign == 0 || data.nSteepAlign == 3)
			{
				pt0 = ptOrg + vt * (data.dGarSize[0] * .5);
				pt0 += vtDir * ((data.nSteepsS - 1) * data.dSteepW * .5 + data.dGarExt);
				pt1 = pt0 - vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
				pt2 = pt1 - vt * data.dGarSize[0];
				pt3 = pt2 + vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
			}
			else if (data.nSteepAlign == 1)
			{
				pt0 = ptOrg + vt * (data.dGarSize[0] * .5);
				pt0 += vtDir * ((data.nSteepsS - 1) * data.dSteepW * .5 + data.dGarExt + (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5);
				pt1 = pt0 - vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt + (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5);
				pt2 = pt1 - vt * data.dGarSize[0];
				pt3 = pt2 + vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt + (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5);
			}
			else if (data.nSteepAlign == 2)
			{
				pt0 = ptOrg + vt * (data.dGarSize[0] * .5);
				pt0 += vtDir * ((data.nSteepsS - 1) * data.dSteepW * .5 + data.dGarExt + (data.nSteepMs - data.nSteepsS) * data.dSteepW);
				pt1 = pt0 - vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt + (data.nSteepMs - data.nSteepsS) * data.dSteepW);
				pt2 = pt1 - vt * data.dGarSize[0];
				pt3 = pt2 + vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt + (data.nSteepMs - data.nSteepsS) * data.dSteepW);
			}
		}

		else if (data.nSteepMs < data.nSteepsS)
		{
			if (data.nSteepAlign == 0 || data.nSteepAlign == 3)
			{
				pt0 = ptOrg + vt * (data.dGarSize[0] * .5);
				pt0 += vtDir * ((data.nSteepsS - 1) * data.dSteepW * .5 + data.dGarExt);
				pt1 = pt0 - vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
				pt2 = pt1 - vt * data.dGarSize[0];
				pt3 = pt2 + vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
			}
			else if (data.nSteepAlign == 1)
			{
				pt0 = ptOrg + vt * (data.dGarSize[0] * .5);
				pt0 += vtDir * ((data.nSteepsS - 1) * data.dSteepW * .5 + data.dGarExt);
				pt1 = pt0 - vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
				pt2 = pt1 - vt * data.dGarSize[0];
				pt3 = pt2 + vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
			}
			else if (data.nSteepAlign == 2)
			{
				pt0 = ptOrg + vt * (data.dGarSize[0] * .5);
				pt0 += vtDir * ((data.nSteepsS - 1) * data.dSteepW * .5 + data.dGarExt);
				pt1 = pt0 - vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
				pt2 = pt1 - vt * data.dGarSize[0];
				pt3 = pt2 + vtDir * ((data.nSteepsS - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
			}
		}

		ptGe[0] = pt0;
		ptGe[1] = pt1;
		ptGe[2] = pt2;
		ptGe[3] = pt3;
		ptGe[4] = ptGe[0];

		AcDbPolyline* pPl = FormatPolyline(ptGe, 5);
		if (pPl == NULL) return Acad::eOk;
		dc.DrawEntity(pPl);
		dc.Add2dBuffer(pPl);
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbParaLlelStairDraw::DrawInHandRail2d(AcGiDraw& dc
	, const AcGePoint3d& ptSta
	, const AcGePoint3d& ptEnd
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const double& dBarL
	, const SFSPStair& data) const
{
	AcGePoint3d ptOrg(ptSta);
	AcGePoint3d pt0, pt1, pt2, pt3, pt4, pt5, pt6, pt7;
	AcGePoint3d ptGeL[5];
	AcGePoint3d ptGeR[5];

	ptOrg -= vtDir * (data.dRestPtW + (dBarL- 1) * data.dSteepW * .5);
	ptOrg -= vt * (data.dStairSW + (data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 * .5);

	pt0 = ptOrg + vt * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 * .5 + data.dBarSide);
	pt0 += vtDir * ((dBarL - 1) * data.dSteepW * .5 + data.dGarExt);
	pt1 = pt0 - vtDir * ((dBarL - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
	pt2 = pt1 - vt * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 + data.dBarSide * 2);
	pt3 = pt2 + vtDir * ((dBarL - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);

	ptGeL[0] = pt0;
	ptGeL[1] = pt1;
	ptGeL[2] = pt2;
	ptGeL[3] = pt3;
	ptGeL[4] = ptGeL[0];

	AcDbPolyline *pPl = FormatPolyline(ptGeL, 5);
	if (pPl == NULL) return Acad::eOk;
	dc.DrawEntity(pPl);
	dc.Add2dBuffer(pPl);

	AcDbVoidPtrArray ar;
	pPl->getOffsetCurves(60, ar);
	if (ar.isEmpty()) return Acad::eOk;
	AcDbPolyline* pNewPoly = (AcDbPolyline*)(((AcDbEntity*)ar.first())->clone());
	deleteArrayVoidPtrs<AcDbEntity>(ar);
	if (pNewPoly == NULL) return Acad::eOk;
	pNewPoly->setColorIndex(2);
	dc.DrawEntity(pNewPoly);
	dc.Add2dBuffer(pNewPoly);

	ptOrg -= vt * (data.dStairMW + (data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5);
	pt4 = ptOrg + vt * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 * .5 + data.dBarSide);
	pt4 += vtDir * ((dBarL - 1) * data.dSteepW * .5 + data.dGarExt);
	pt5 = pt4 - vtDir * ((dBarL - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);
	pt6 = pt5 - vt * ((data.dStairTW - data.dStairMW - data.dStairSW * 2) * .5 + data.dBarSide * 2);
	pt7 = pt6 + vtDir * ((dBarL - 1) * data.dSteepW + data.dGarExt + data.dZGarExt);

	ptGeR[0] = pt4;
	ptGeR[1] = pt5;
	ptGeR[2] = pt6;
	ptGeR[3] = pt7;
	ptGeR[4] = ptGeR[0];

	AcDbPolyline* pPl1 = FormatPolyline(ptGeR, 5);
	if (pPl1 == NULL) return Acad::eOk;
	dc.DrawEntity(pPl1);
	dc.Add2dBuffer(pPl1);

	AcDbVoidPtrArray ar1;
	pPl1->getOffsetCurves(60, ar1);
	if (ar1.isEmpty()) return Acad::eOk;
	AcDbPolyline* pNewPoly1 = (AcDbPolyline*)(((AcDbEntity*)ar1.first())->clone());
	deleteArrayVoidPtrs<AcDbEntity>(ar1);
	if (pNewPoly1 == NULL) return Acad::eOk;
	pNewPoly1->setColorIndex(2);
	dc.DrawEntity(pNewPoly1);
	dc.Add2dBuffer(pNewPoly1);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbParaLlelStairDraw::DrawWithin(AcGiDraw& dc
	, const AcGePoint3d& ptSta
	, const AcGePoint3d& ptEnd
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const SFSPStair& data) const
{
	AcGePoint3d pt1(ptSta), pt2, pt3, pt4, pt5, pt6, pt7, pt8, pt9, pt10, pt11, pt12, pt13, pt14;
	AcGePoint3d ptGeIn[3];
	AcGePoint3d ptGeOut[4];
	double dCir;
	double dScale = CoreTools::getPScaleForSymb();
	double dW(dScale * .8);
	double dH(dScale * 3);
	double dTextH(dScale * 3.5);
	AcGeVector3d Z(AcGeVector3d::kZAxis);
	double angle = vtDir.angleTo(AcGeVector3d::kXAxis) - PI * .5;

	if (data.nRestShape == 1)
	{
		dCir = data.dRestPtW;
	}
	else
	{
		dCir = 0;
	}

	if (!data.nUpSide)
	{
		if (data.nSteepMs == data.nSteepsS || data.nSteepAlign == 0 || data.nSteepAlign == 3)
		{
			pt1 -= vt * data.dStairSW * .5;
			pt1 -= vtDir * (data.dRestPtW + (data.nSteepsS - .5) * data.dSteepW);
			pt2 = pt1 + vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5) * data.dSteepW + dCir);
			pt3 = pt2 - vt * (data.dStairTW - data.dStairSW) * .5;
			pt4 = pt3 - vtDir * (data.dRestPtW * .5 + (data.nSteepMs - 1 - data.nSSteeps) * data.dSteepW + dCir);
			pt5 = pt4 + vtDir * dH;

			ptGeOut[0] = pt1;
			ptGeOut[1] = pt2;
			ptGeOut[2] = pt3;

			AcDbPolyline* pPl = FormatPolyline(ptGeOut, 3);
			if (pPl == NULL) return Acad::eOk;
			pPl->setColorIndex(3);
			dc.DrawEntity(pPl);
			dc.Add2dBuffer(pPl);

			ptGeIn[0] = pt3;
			ptGeIn[1] = pt4;
			ptGeIn[2] = pt5;

			AcDbPolyline* pPl1 = FormatPolyline(ptGeIn, 3);
			if (pPl1 == NULL) return Acad::eOk;
			pPl1->setColorIndex(3);
			pPl1->setWidthsAt(1, 0, dW);
			dc.DrawEntity(pPl1);
			dc.Add2dBuffer(pPl1);

			pt6 = pt4 - vtDir * (data.nSSteeps + .5) * data.dSteepW;
			pt7 = pt6 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
			pt8 = pt7 - vtDir * dH;

			ptGeIn[0] = pt6;
			ptGeIn[1] = pt7;
			ptGeIn[2] = pt8;

			AcDbPolyline* pPl2 = FormatPolyline(ptGeIn, 3);
			if (pPl2 == NULL) return Acad::eOk;
			pPl2->setColorIndex(3);
			pPl2->setWidthsAt(1, 0, dW);
			dc.DrawEntity(pPl2);
			dc.Add2dBuffer(pPl2);

			pt9 = pt3 - vt * (data.dStairTW - data.dStairSW) * .5;
			pt10 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5) * data.dSteepW + dCir);

			ptGeOut[0] = pt3;
			ptGeOut[1] = pt9;
			ptGeOut[2] = pt10;

			AcDbPolyline* pPl3 = FormatPolyline(ptGeOut, 3);
			if (pPl3 == NULL) return Acad::eOk;
			pPl3->setColorIndex(3);
			dc.DrawEntity(pPl3);
			dc.Add2dBuffer(pPl3);
		}

		else if (data.nSteepMs > data.nSteepsS)
		{
			if (data.nSteepAlign == 1)
			{
				pt1 -= vt * data.dStairSW * .5;
				pt1 -= vtDir * (data.dRestPtW + (data.nSteepsS - .5 + (data.nSteepMs - data.nSteepsS) * .5) * data.dSteepW);
				pt2 = pt1 + vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5 + (data.nSteepMs - data.nSteepsS) * .5) * data.dSteepW + dCir);
				pt3 = pt2 - vt * (data.dStairTW - data.dStairSW) * .5;
				pt4 = pt3 - vtDir * (data.dRestPtW * .5 + (data.nSteepMs - 1 - data.nSSteeps) * data.dSteepW + dCir);
				pt5 = pt4 + vtDir * dH;

				ptGeOut[0] = pt1;
				ptGeOut[1] = pt2;
				ptGeOut[2] = pt3;

				AcDbPolyline* pPl = FormatPolyline(ptGeOut, 3);
				if (pPl == NULL) return Acad::eOk;
				pPl->setColorIndex(3);
				dc.DrawEntity(pPl);
				dc.Add2dBuffer(pPl);

				ptGeIn[0] = pt3;
				ptGeIn[1] = pt4;
				ptGeIn[2] = pt5;

				AcDbPolyline* pPl1 = FormatPolyline(ptGeIn, 3);
				if (pPl1 == NULL) return Acad::eOk;
				pPl1->setColorIndex(3);
				pPl1->setWidthsAt(1, 0, dW);
				dc.DrawEntity(pPl1);
				dc.Add2dBuffer(pPl1);

				pt6 = pt4 - vtDir * (data.nSSteeps + .5) * data.dSteepW;
				pt7 = pt6 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
				pt8 = pt7 - vtDir * dH;

				ptGeIn[0] = pt6;
				ptGeIn[1] = pt7;
				ptGeIn[2] = pt8;

				AcDbPolyline* pPl2 = FormatPolyline(ptGeIn, 3);
				if (pPl2 == NULL) return Acad::eOk;
				pPl2->setColorIndex(3);
				pPl2->setWidthsAt(1, 0, dW);
				dc.DrawEntity(pPl2);
				dc.Add2dBuffer(pPl2);

				pt9 = pt3 - vt * (data.dStairTW - data.dStairSW) * .5;
				pt10 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5 + (data.nSteepMs - data.nSteepsS) * .5) * data.dSteepW + dCir);

				ptGeOut[0] = pt3;
				ptGeOut[1] = pt9;
				ptGeOut[2] = pt10;

				AcDbPolyline* pPl3 = FormatPolyline(ptGeOut, 3);
				if (pPl3 == NULL) return Acad::eOk;
				pPl3->setColorIndex(3);
				dc.DrawEntity(pPl3);
				dc.Add2dBuffer(pPl3);
			}
			else if (data.nSteepAlign == 2)
			{
				pt1 -= vt * data.dStairSW * .5;
				pt1 -= vtDir * (data.dRestPtW + (data.nSteepsS - .5 + (data.nSteepMs - data.nSteepsS)) * data.dSteepW);
				pt2 = pt1 + vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5 + (data.nSteepMs - data.nSteepsS)) * data.dSteepW + dCir);
				pt3 = pt2 - vt * (data.dStairTW - data.dStairSW) * .5;
				pt4 = pt3 - vtDir * (data.dRestPtW * .5 + (data.nSteepMs - 1 - data.nSSteeps) * data.dSteepW + dCir);
				pt5 = pt4 + vtDir * dH;

				ptGeOut[0] = pt1;
				ptGeOut[1] = pt2;
				ptGeOut[2] = pt3;

				AcDbPolyline* pPl = FormatPolyline(ptGeOut, 3);
				if (pPl == NULL) return Acad::eOk;
				pPl->setColorIndex(3);
				dc.DrawEntity(pPl);
				dc.Add2dBuffer(pPl);

				ptGeIn[0] = pt3;
				ptGeIn[1] = pt4;
				ptGeIn[2] = pt5;

				AcDbPolyline* pPl1 = FormatPolyline(ptGeIn, 3);
				if (pPl1 == NULL) return Acad::eOk;
				pPl1->setColorIndex(3);
				pPl1->setWidthsAt(1, 0, dW);
				dc.DrawEntity(pPl1);
				dc.Add2dBuffer(pPl1);

				pt6 = pt4 - vtDir * (data.nSSteeps + .5) * data.dSteepW;
				pt7 = pt6 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
				pt8 = pt7 - vtDir * dH;

				ptGeIn[0] = pt6;
				ptGeIn[1] = pt7;
				ptGeIn[2] = pt8;

				AcDbPolyline* pPl2 = FormatPolyline(ptGeIn, 3);
				if (pPl2 == NULL) return Acad::eOk;
				pPl2->setColorIndex(3);
				pPl2->setWidthsAt(1, 0, dW);
				dc.DrawEntity(pPl2);
				dc.Add2dBuffer(pPl2);

				pt9 = pt3 - vt * (data.dStairTW - data.dStairSW) * .5;
				pt10 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5 + (data.nSteepMs - data.nSteepsS)) * data.dSteepW + dCir);

				ptGeOut[0] = pt3;
				ptGeOut[1] = pt9;
				ptGeOut[2] = pt10;

				AcDbPolyline* pPl3 = FormatPolyline(ptGeOut, 3);
				if (pPl3 == NULL) return Acad::eOk;
				pPl3->setColorIndex(3);
				dc.DrawEntity(pPl3);
				dc.Add2dBuffer(pPl3);
			}
		}

		else if (data.nSteepMs < data.nSteepsS)
		{
			if (data.nSteepAlign == 1)
			{
				pt1 -= vt * data.dStairSW * .5;
				pt1 -= vtDir * (data.dRestPtW + (data.nSteepsS - .5) * data.dSteepW);
				pt2 = pt1 + vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5) * data.dSteepW + dCir);
				pt3 = pt2 - vt * (data.dStairTW - data.dStairSW) * .5;
				pt4 = pt3 - vtDir * (data.dRestPtW * .5 + (data.nSteepMs - 1 - data.nSSteeps + (data.nSteepsS - data.nSteepMs) * .5) * data.dSteepW + dCir);
				pt5 = pt4 + vtDir * dH;

				ptGeOut[0] = pt1;
				ptGeOut[1] = pt2;
				ptGeOut[2] = pt3;

				AcDbPolyline* pPl = FormatPolyline(ptGeOut, 3);
				if (pPl == NULL) return Acad::eOk;
				pPl->setColorIndex(3);
				dc.DrawEntity(pPl);
				dc.Add2dBuffer(pPl);

				ptGeIn[0] = pt3;
				ptGeIn[1] = pt4;
				ptGeIn[2] = pt5;

				AcDbPolyline* pPl1 = FormatPolyline(ptGeIn, 3);
				if (pPl1 == NULL) return Acad::eOk;
				pPl1->setColorIndex(3);
				pPl1->setWidthsAt(1, 0, dW);
				dc.DrawEntity(pPl1);
				dc.Add2dBuffer(pPl1);

				pt6 = pt4 - vtDir * (data.nSSteeps + .5) * data.dSteepW;
				pt7 = pt6 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
				pt8 = pt7 - vtDir * dH;

				ptGeIn[0] = pt6;
				ptGeIn[1] = pt7;
				ptGeIn[2] = pt8;

				AcDbPolyline* pPl2 = FormatPolyline(ptGeIn, 3);
				if (pPl2 == NULL) return Acad::eOk;
				pPl2->setColorIndex(3);
				pPl2->setWidthsAt(1, 0, dW);
				dc.DrawEntity(pPl2);
				dc.Add2dBuffer(pPl2);

				pt9 = pt3 - vt * (data.dStairTW - data.dStairSW) * .5;
				pt10 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5) * data.dSteepW + dCir);

				ptGeOut[0] = pt3;
				ptGeOut[1] = pt9;
				ptGeOut[2] = pt10;

				AcDbPolyline* pPl3 = FormatPolyline(ptGeOut, 3);
				if (pPl3 == NULL) return Acad::eOk;
				pPl3->setColorIndex(3);
				dc.DrawEntity(pPl3);
				dc.Add2dBuffer(pPl3);
			}
			else if (data.nSteepAlign == 2)
			{
				pt1 -= vt * data.dStairSW * .5;
				pt1 -= vtDir * (data.dRestPtW + (data.nSteepsS - .5) * data.dSteepW);
				pt2 = pt1 + vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5) * data.dSteepW + dCir);
				pt3 = pt2 - vt * (data.dStairTW - data.dStairSW) * .5;
				pt4 = pt3 - vtDir * (data.dRestPtW * .5 + (data.nSteepMs - 1 - data.nSSteeps + (data.nSteepsS - data.nSteepMs)) * data.dSteepW + dCir);
				pt5 = pt4 + vtDir * dH;

				ptGeOut[0] = pt1;
				ptGeOut[1] = pt2;
				ptGeOut[2] = pt3;

				AcDbPolyline* pPl = FormatPolyline(ptGeOut, 3);
				if (pPl == NULL) return Acad::eOk;
				pPl->setColorIndex(3);
				dc.DrawEntity(pPl);
				dc.Add2dBuffer(pPl);

				ptGeIn[0] = pt3;
				ptGeIn[1] = pt4;
				ptGeIn[2] = pt5;

				AcDbPolyline* pPl1 = FormatPolyline(ptGeIn, 3);
				if (pPl1 == NULL) return Acad::eOk;
				pPl1->setColorIndex(3);
				pPl1->setWidthsAt(1, 0, dW);
				dc.DrawEntity(pPl1);
				dc.Add2dBuffer(pPl1);

				pt6 = pt4 - vtDir * (data.nSSteeps + .5) * data.dSteepW;
				pt7 = pt6 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
				pt8 = pt7 - vtDir * dH;

				ptGeIn[0] = pt6;
				ptGeIn[1] = pt7;
				ptGeIn[2] = pt8;

				AcDbPolyline* pPl2 = FormatPolyline(ptGeIn, 3);
				if (pPl2 == NULL) return Acad::eOk;
				pPl2->setColorIndex(3);
				pPl2->setWidthsAt(1, 0, dW);
				dc.DrawEntity(pPl2);
				dc.Add2dBuffer(pPl2);

				pt9 = pt3 - vt * (data.dStairTW - data.dStairSW) * .5;
				pt10 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5) * data.dSteepW + dCir);

				ptGeOut[0] = pt3;
				ptGeOut[1] = pt9;
				ptGeOut[2] = pt10;

				AcDbPolyline* pPl3 = FormatPolyline(ptGeOut, 3);
				if (pPl3 == NULL) return Acad::eOk;
				pPl3->setColorIndex(3);
				dc.DrawEntity(pPl3);
				dc.Add2dBuffer(pPl3);
			}
		}
	}

	else
	{
		if (data.nSteepMs == data.nSteepsS || data.nSteepAlign == 0 || data.nSteepAlign == 3)
		{
			pt1 -= vt * data.dStairSW * .5;
			pt1 -= vtDir * (data.dRestPtW + (data.nSteepsS - .5) * data.dSteepW);
			pt2 = pt1 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
			pt3 = pt2 - vtDir * dH;

			ptGeOut[0] = pt1;
			ptGeOut[1] = pt2;
			ptGeOut[2] = pt3;

			AcDbPolyline* pPl = FormatPolyline(ptGeOut, 3);
			if (pPl == NULL) return Acad::eOk;
			pPl->setColorIndex(3);
			pPl->setWidthsAt(1, 0, dW);
			dc.DrawEntity(pPl);
			dc.Add2dBuffer(pPl);

			pt4 = pt1 + vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5) * data.dSteepW + dCir);
			pt5 = pt4 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - 1 - data.nSSteeps) * data.dSteepW + dCir);
			pt6 = pt5 + vtDir * dH;

			ptGeOut[0] = pt4;
			ptGeOut[1] = pt5;
			ptGeOut[2] = pt6;

			AcDbPolyline* pPl1 = FormatPolyline(ptGeOut, 3);
			if (pPl1 == NULL) return Acad::eOk;
			pPl1->setColorIndex(3);
			pPl1->setWidthsAt(1, 0, dW);
			dc.DrawEntity(pPl1);
			dc.Add2dBuffer(pPl1);

			pt7 = pt4 - vt * (data.dStairTW - data.dStairSW) * .5;
			pt8 = pt7 - vtDir * (data.dRestPtW * .5 + (data.nSteepMs - .5) * data.dSteepW + dCir);
			
			ptGeIn[0] = pt4;
			ptGeIn[1] = pt7;
			ptGeIn[2] = pt8;

			AcDbPolyline* pPl2 = FormatPolyline(ptGeIn, 3);
			if (pPl2 == NULL) return Acad::eOk;
			pPl2->setColorIndex(3);
			dc.DrawEntity(pPl2);
			dc.Add2dBuffer(pPl2);

			pt9 = pt7 - vt * (data.dStairTW - data.dStairSW) * .5;

			ptGeIn[0] = pt7;
			ptGeIn[1] = pt9;

			AcDbPolyline* pPl3 = FormatPolyline(ptGeIn, 2);
			if (pPl3 == NULL) return Acad::eOk;
			pPl3->setColorIndex(3);
			dc.DrawEntity(pPl3);
			dc.Add2dBuffer(pPl3);

			pt10 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - 1 - data.nSSteeps) * data.dSteepW + dCir);
			pt11 = pt10 + vtDir * dH;

			ptGeOut[0] = pt9;
			ptGeOut[1] = pt10;
			ptGeOut[2] = pt11;

			AcDbPolyline* pPl4 = FormatPolyline(ptGeOut, 3);
			if (pPl4 == NULL) return Acad::eOk;
			pPl4->setColorIndex(3);
			pPl4->setWidthsAt(1, 0, dW);
			dc.DrawEntity(pPl4);
			dc.Add2dBuffer(pPl4);

			pt12 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5) * data.dSteepW + dCir);
			pt13 = pt12 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
			pt14 = pt13 - vtDir * dH;

			ptGeOut[0] = pt12;
			ptGeOut[1] = pt13;
			ptGeOut[2] = pt14;

			AcDbPolyline* pPl5 = FormatPolyline(ptGeOut, 3);
			if (pPl5 == NULL) return Acad::eOk;
			pPl5->setColorIndex(3);
			pPl5->setWidthsAt(1, 0, dW);
			dc.DrawEntity(pPl5);
			dc.Add2dBuffer(pPl5);
		}
		
		else if (data.nSteepMs > data.nSteepsS)
		{
			if (data.nSteepAlign == 1)
			{
				pt1 -= vt * data.dStairSW * .5;
				pt1 -= vtDir * (data.dRestPtW + (data.nSteepsS - .5 + (data.nSteepMs - data.nSteepsS) * .5) * data.dSteepW);
				pt2 = pt1 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
				pt3 = pt2 - vtDir * dH;

				ptGeOut[0] = pt1;
				ptGeOut[1] = pt2;
				ptGeOut[2] = pt3;

				AcDbPolyline* pPl = FormatPolyline(ptGeOut, 3);
				if (pPl == NULL) return Acad::eOk;
				pPl->setColorIndex(3);
				pPl->setWidthsAt(1, 0, dW);
				dc.DrawEntity(pPl);
				dc.Add2dBuffer(pPl);

				pt4 = pt1 + vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5 + (data.nSteepMs - data.nSteepsS) * .5) * data.dSteepW + dCir);
				pt5 = pt4 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - 1 - data.nSSteeps + (data.nSteepMs - data.nSteepsS) * .5) * data.dSteepW + dCir);
				pt6 = pt5 + vtDir * dH;

				ptGeOut[0] = pt4;
				ptGeOut[1] = pt5;
				ptGeOut[2] = pt6;

				AcDbPolyline* pPl1 = FormatPolyline(ptGeOut, 3);
				if (pPl1 == NULL) return Acad::eOk;
				pPl1->setColorIndex(3);
				pPl1->setWidthsAt(1, 0, dW);
				dc.DrawEntity(pPl1);
				dc.Add2dBuffer(pPl1);

				pt7 = pt4 - vt * (data.dStairTW - data.dStairSW) * .5;
				pt8 = pt7 - vtDir * (data.dRestPtW * .5 + (data.nSteepMs - .5) * data.dSteepW + dCir);

				ptGeIn[0] = pt4;
				ptGeIn[1] = pt7;
				ptGeIn[2] = pt8;

				AcDbPolyline* pPl2 = FormatPolyline(ptGeIn, 3);
				if (pPl2 == NULL) return Acad::eOk;
				pPl2->setColorIndex(3);
				dc.DrawEntity(pPl2);
				dc.Add2dBuffer(pPl2);

				pt9 = pt7 - vt * (data.dStairTW - data.dStairSW) * .5;

				ptGeIn[0] = pt7;
				ptGeIn[1] = pt9;

				AcDbPolyline* pPl3 = FormatPolyline(ptGeIn, 2);
				if (pPl3 == NULL) return Acad::eOk;
				pPl3->setColorIndex(3);
				dc.DrawEntity(pPl3);
				dc.Add2dBuffer(pPl3);

				pt10 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - 1 - data.nSSteeps + (data.nSteepMs - data.nSteepsS) * .5) * data.dSteepW + dCir);
				pt11 = pt10 + vtDir * dH;

				ptGeOut[0] = pt9;
				ptGeOut[1] = pt10;
				ptGeOut[2] = pt11;

				AcDbPolyline* pPl4 = FormatPolyline(ptGeOut, 3);
				if (pPl4 == NULL) return Acad::eOk;
				pPl4->setColorIndex(3);
				pPl4->setWidthsAt(1, 0, dW);
				dc.DrawEntity(pPl4);
				dc.Add2dBuffer(pPl4);

				pt12 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5 + (data.nSteepMs - data.nSteepsS) * .5) * data.dSteepW + dCir);
				pt13 = pt12 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
				pt14 = pt13 - vtDir * dH;

				ptGeOut[0] = pt12;
				ptGeOut[1] = pt13;
				ptGeOut[2] = pt14;

				AcDbPolyline* pPl5 = FormatPolyline(ptGeOut, 3);
				if (pPl5 == NULL) return Acad::eOk;
				pPl5->setColorIndex(3);
				pPl5->setWidthsAt(1, 0, dW);
				dc.DrawEntity(pPl5);
				dc.Add2dBuffer(pPl5);
			}
			else if (data.nSteepAlign == 2)
			{
				pt1 -= vt * data.dStairSW * .5;
				pt1 -= vtDir * (data.dRestPtW + (data.nSteepsS - .5 + (data.nSteepMs - data.nSteepsS)) * data.dSteepW);
				pt2 = pt1 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
				pt3 = pt2 - vtDir * dH;

				ptGeOut[0] = pt1;
				ptGeOut[1] = pt2;
				ptGeOut[2] = pt3;

				AcDbPolyline* pPl = FormatPolyline(ptGeOut, 3);
				if (pPl == NULL) return Acad::eOk;
				pPl->setColorIndex(3);
				pPl->setWidthsAt(1, 0, dW);
				dc.DrawEntity(pPl);
				dc.Add2dBuffer(pPl);

				pt4 = pt1 + vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5 + (data.nSteepMs - data.nSteepsS)) * data.dSteepW + dCir);
				pt5 = pt4 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - 1 - data.nSSteeps + (data.nSteepMs - data.nSteepsS)) * data.dSteepW + dCir);
				pt6 = pt5 + vtDir * dH;

				ptGeOut[0] = pt4;
				ptGeOut[1] = pt5;
				ptGeOut[2] = pt6;

				AcDbPolyline* pPl1 = FormatPolyline(ptGeOut, 3);
				if (pPl1 == NULL) return Acad::eOk;
				pPl1->setColorIndex(3);
				pPl1->setWidthsAt(1, 0, dW);
				dc.DrawEntity(pPl1);
				dc.Add2dBuffer(pPl1);

				pt7 = pt4 - vt * (data.dStairTW - data.dStairSW) * .5;
				pt8 = pt7 - vtDir * (data.dRestPtW * .5 + (data.nSteepMs - .5) * data.dSteepW + dCir);

				ptGeIn[0] = pt4;
				ptGeIn[1] = pt7;
				ptGeIn[2] = pt8;

				AcDbPolyline* pPl2 = FormatPolyline(ptGeIn, 3);
				if (pPl2 == NULL) return Acad::eOk;
				pPl2->setColorIndex(3);
				dc.DrawEntity(pPl2);
				dc.Add2dBuffer(pPl2);

				pt9 = pt7 - vt * (data.dStairTW - data.dStairSW) * .5;

				ptGeIn[0] = pt7;
				ptGeIn[1] = pt9;

				AcDbPolyline* pPl3 = FormatPolyline(ptGeIn, 2);
				if (pPl3 == NULL) return Acad::eOk;
				pPl3->setColorIndex(3);
				dc.DrawEntity(pPl3);
				dc.Add2dBuffer(pPl3);

				pt10 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - 1 - data.nSSteeps + (data.nSteepMs - data.nSteepsS)) * data.dSteepW + dCir);
				pt11 = pt10 + vtDir * dH;

				ptGeOut[0] = pt9;
				ptGeOut[1] = pt10;
				ptGeOut[2] = pt11;

				AcDbPolyline* pPl4 = FormatPolyline(ptGeOut, 3);
				if (pPl4 == NULL) return Acad::eOk;
				pPl4->setColorIndex(3);
				pPl4->setWidthsAt(1, 0, dW);
				dc.DrawEntity(pPl4);
				dc.Add2dBuffer(pPl4);

				pt12 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5 + (data.nSteepMs - data.nSteepsS)) * data.dSteepW + dCir);
				pt13 = pt12 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
				pt14 = pt13 - vtDir * dH;

				ptGeOut[0] = pt12;
				ptGeOut[1] = pt13;
				ptGeOut[2] = pt14;

				AcDbPolyline* pPl5 = FormatPolyline(ptGeOut, 3);
				if (pPl5 == NULL) return Acad::eOk;
				pPl5->setColorIndex(3);
				pPl5->setWidthsAt(1, 0, dW);
				dc.DrawEntity(pPl5);
				dc.Add2dBuffer(pPl5);
			}
		}
		
		else if (data.nSteepMs < data.nSteepsS)
		{
			if (data.nSteepAlign == 1)
			{
				pt1 -= vt * data.dStairSW * .5;
				pt1 -= vtDir * (data.dRestPtW + (data.nSteepsS - .5) * data.dSteepW);
				pt2 = pt1 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
				pt3 = pt2 - vtDir * dH;

				ptGeOut[0] = pt1;
				ptGeOut[1] = pt2;
				ptGeOut[2] = pt3;

				AcDbPolyline* pPl = FormatPolyline(ptGeOut, 3);
				if (pPl == NULL) return Acad::eOk;
				pPl->setColorIndex(3);
				pPl->setWidthsAt(1, 0, dW);
				dc.DrawEntity(pPl);
				dc.Add2dBuffer(pPl);

				pt4 = pt1 + vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5) * data.dSteepW + dCir);
				pt5 = pt4 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - 1 - data.nSSteeps) * data.dSteepW + dCir);
				pt6 = pt5 + vtDir * dH;

				ptGeOut[0] = pt4;
				ptGeOut[1] = pt5;
				ptGeOut[2] = pt6;

				AcDbPolyline* pPl1 = FormatPolyline(ptGeOut, 3);
				if (pPl1 == NULL) return Acad::eOk;
				pPl1->setColorIndex(3);
				pPl1->setWidthsAt(1, 0, dW);
				dc.DrawEntity(pPl1);
				dc.Add2dBuffer(pPl1);

				pt7 = pt4 - vt * (data.dStairTW - data.dStairSW) * .5;
				pt8 = pt7 - vtDir * (data.dRestPtW * .5 + (data.nSteepMs - .5 + (data.nSteepsS - data.nSteepMs) * .5) * data.dSteepW + dCir);

				ptGeIn[0] = pt4;
				ptGeIn[1] = pt7;
				ptGeIn[2] = pt8;

				AcDbPolyline* pPl2 = FormatPolyline(ptGeIn, 3);
				if (pPl2 == NULL) return Acad::eOk;
				pPl2->setColorIndex(3);
				dc.DrawEntity(pPl2);
				dc.Add2dBuffer(pPl2);

				pt9 = pt7 - vt * (data.dStairTW - data.dStairSW) * .5;

				ptGeIn[0] = pt7;
				ptGeIn[1] = pt9;

				AcDbPolyline* pPl3 = FormatPolyline(ptGeIn, 2);
				if (pPl3 == NULL) return Acad::eOk;
				pPl3->setColorIndex(3);
				dc.DrawEntity(pPl3);
				dc.Add2dBuffer(pPl3);

				pt10 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - 1 - data.nSSteeps) * data.dSteepW + dCir);
				pt11 = pt10 + vtDir * dH;

				ptGeOut[0] = pt9;
				ptGeOut[1] = pt10;
				ptGeOut[2] = pt11;

				AcDbPolyline* pPl4 = FormatPolyline(ptGeOut, 3);
				if (pPl4 == NULL) return Acad::eOk;
				pPl4->setColorIndex(3);
				pPl4->setWidthsAt(1, 0, dW);
				dc.DrawEntity(pPl4);
				dc.Add2dBuffer(pPl4);

				pt12 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5) * data.dSteepW + dCir);
				pt13 = pt12 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
				pt14 = pt13 - vtDir * dH;

				ptGeOut[0] = pt12;
				ptGeOut[1] = pt13;
				ptGeOut[2] = pt14;

				AcDbPolyline* pPl5 = FormatPolyline(ptGeOut, 3);
				if (pPl5 == NULL) return Acad::eOk;
				pPl5->setColorIndex(3);
				pPl5->setWidthsAt(1, 0, dW);
				dc.DrawEntity(pPl5);
				dc.Add2dBuffer(pPl5);
			}
			else if (data.nSteepAlign == 2)
			{
				pt1 -= vt * data.dStairSW * .5;
				pt1 -= vtDir * (data.dRestPtW + (data.nSteepsS - .5) * data.dSteepW);
				pt2 = pt1 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
				pt3 = pt2 - vtDir * dH;

				ptGeOut[0] = pt1;
				ptGeOut[1] = pt2;
				ptGeOut[2] = pt3;

				AcDbPolyline* pPl = FormatPolyline(ptGeOut, 3);
				if (pPl == NULL) return Acad::eOk;
				pPl->setColorIndex(3);
				pPl->setWidthsAt(1, 0, dW);
				dc.DrawEntity(pPl);
				dc.Add2dBuffer(pPl);

				pt4 = pt1 + vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5) * data.dSteepW + dCir);
				pt5 = pt4 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - 1 - data.nSSteeps) * data.dSteepW + dCir);
				pt6 = pt5 + vtDir * dH;

				ptGeOut[0] = pt4;
				ptGeOut[1] = pt5;
				ptGeOut[2] = pt6;

				AcDbPolyline* pPl1 = FormatPolyline(ptGeOut, 3);
				if (pPl1 == NULL) return Acad::eOk;
				pPl1->setColorIndex(3);
				pPl1->setWidthsAt(1, 0, dW);
				dc.DrawEntity(pPl1);
				dc.Add2dBuffer(pPl1);

				pt7 = pt4 - vt * (data.dStairTW - data.dStairSW) * .5;
				pt8 = pt7 - vtDir * (data.dRestPtW * .5 + (data.nSteepMs - .5 + (data.nSteepsS - data.nSteepMs)) * data.dSteepW + dCir);

				ptGeIn[0] = pt4;
				ptGeIn[1] = pt7;
				ptGeIn[2] = pt8;

				AcDbPolyline* pPl2 = FormatPolyline(ptGeIn, 3);
				if (pPl2 == NULL) return Acad::eOk;
				pPl2->setColorIndex(3);
				dc.DrawEntity(pPl2);
				dc.Add2dBuffer(pPl2);

				pt9 = pt7 - vt * (data.dStairTW - data.dStairSW) * .5;

				ptGeIn[0] = pt7;
				ptGeIn[1] = pt9;

				AcDbPolyline* pPl3 = FormatPolyline(ptGeIn, 2);
				if (pPl3 == NULL) return Acad::eOk;
				pPl3->setColorIndex(3);
				dc.DrawEntity(pPl3);
				dc.Add2dBuffer(pPl3);

				pt10 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - 1 - data.nSSteeps) * data.dSteepW + dCir);
				pt11 = pt10 + vtDir * dH;

				ptGeOut[0] = pt9;
				ptGeOut[1] = pt10;
				ptGeOut[2] = pt11;

				AcDbPolyline* pPl4 = FormatPolyline(ptGeOut, 3);
				if (pPl4 == NULL) return Acad::eOk;
				pPl4->setColorIndex(3);
				pPl4->setWidthsAt(1, 0, dW);
				dc.DrawEntity(pPl4);
				dc.Add2dBuffer(pPl4);

				pt12 = pt9 - vtDir * (data.dRestPtW * .5 + (data.nSteepsS - .5) * data.dSteepW + dCir);
				pt13 = pt12 + vtDir * (data.nSSteeps - .5) * data.dSteepW;
				pt14 = pt13 - vtDir * dH;

				ptGeOut[0] = pt12;
				ptGeOut[1] = pt13;
				ptGeOut[2] = pt14;

				AcDbPolyline* pPl5 = FormatPolyline(ptGeOut, 3);
				if (pPl5 == NULL) return Acad::eOk;
				pPl5->setColorIndex(3);
				pPl5->setWidthsAt(1, 0, dW);
				dc.DrawEntity(pPl5);
				dc.Add2dBuffer(pPl5);
			}
		}
	}
	
	return Acad::eOk;
}

Acad::ErrorStatus AecDbParaLlelStairDraw::DrawSide3d(AcGiDraw& dc
	, const AcGePoint3d& ptFr
	, const AcGePoint3d& ptTo
	, const SFPXStair& data
	, const double& dW) const
{
	if (data.bLBeam || data.bRBeam)
	{
		AcGePoint3d ptSta = ptFr;
		AcGeVector3d vtL = ptTo - ptFr;
		vtL.normalize();

		double dLx = data.nSteepS * data.dSteepW;
		double dLh = data.nSteepS * data.dSteepH + (data.dSteepW - data.dSteepH);
		double dL = sqrt(dLx * dLx + dLh * dLh);

		AcGePoint3d ptEnd = ptSta + vtL * dL;

		AcGeVector3d vtLXY = vtL;
		vtLXY.z = 0.0;

		//一共多少步
		int nCount = data.nSteepS - 1;

		vtL.normalize();
		vtLXY.normalize();

		AcGeVector3d vtW = vtLXY;
		vtW.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
		vtW.normalize();

		//踏步左右总长
		double dSteepL = (dW/* - 2.0 * data.dSidet*/);//无论左右有无梁

		AcGePoint3d ptV, ptV0;
		AcGePoint3dArray arSecPts;

		ptV = ptSta;
		ptV -= vtW * 0.5 * dSteepL;

		//插入楼板的点 [AAA]
		ptV.z -= (data.dSteepW - data.dSteepH);
		ptV0 = ptV;
		arSecPts.append(ptV);

		ptV.z += data.dSteepW;//第一层等边直角
		arSecPts.append(ptV);

		for (int i = 0; i < nCount - 1; i++)
		{
			ptV += vtLXY * data.dSteepW;
			//arSecPts.append(ptV);

			ptV.z += data.dSteepH;
			if (i == (nCount - 2))//只需最后踏步上位点
				arSecPts.append(ptV);
		}

		AcGeVector3d vtUp = arSecPts.last() - arSecPts.at(1);
		AcGeLine3d ln3d;
		ln3d.set(ptV0, vtUp);

		AcGePoint3d ptV1 = ptV + vtLXY * data.dSteepW;
		arSecPts.append(ptV1);

		AcGeLine3d lnEnd;
		lnEnd.set(ptV1, AcGeVector3d::kZAxis);

		AcGePoint3d ptInt;
		if (ln3d.intersectWith(lnEnd, ptInt))
		{
			arSecPts.append(ptInt);

			//闭合
			arSecPts.append(arSecPts.first());

			AcGePoint3d ptGe[5];
			
			ptGe[0] = arSecPts.at(0);
			ptGe[1] = arSecPts.at(1);

			vtUp = ptGe[1] - ptGe[0];
			ptGe[2] = ptInt + vtUp;
			ptGe[3] = ptInt;
			ptGe[4] = ptGe[0];

			double dSidet = 120;
			AcDbLine ln;
			ln.setStartPoint(ptGe[1]);
			ln.setEndPoint(ptGe[1] + vtW * dSidet);

			AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(ptGe, 5);
			if (pReg != NULL)
			{
				//TEST
				//AcDbEntity* pRegCln = (AcDbEntity*)pReg->clone();
				//pRegCln->setColorIndex(4);
				//CoreTools::CloneAndAddToModelSpace(pRegCln);

				AcDbX3dSolid xSolid;
				if (xSolid.CreateExtrude(pReg, ln))
				{
					AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
					if (pSolid != NULL)
					{
						if (data.bLBeam)
						{
							dc.DrawEntity(pSolid);
							dc.Add3dBuffer(pSolid);
							add3DCache<AecDbParaLlelStair>(&xSolid);
						}

						AcGeMatrix3d xform;
						vtW *= (dW - dSidet);
						xform.setTranslation(vtW);

						if (data.bRBeam)
						{
							AcDb3dSolid* pOtherSide = (AcDb3dSolid*)pSolid->clone();
							if (pOtherSide != NULL)
							{
								pOtherSide->transformBy(xform);
								dc.DrawEntity(pOtherSide);
								dc.Add3dBuffer(pOtherSide);
								xSolid.TransformBy(xform);
								add3DCache<AecDbParaLlelStair>(&xSolid);
							}
						}

						if (!data.bLBeam && pSolid != NULL)
							delete pSolid;
					}
				}
			}
		}
	}
	else
	{
		return Acad::eOk;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbParaLlelStairDraw::DrawSteep3d(AcGiDraw& dc
	, const AcGePoint3d& ptFr
	, const AcGePoint3d& ptTo
	, const SFPXStair& data
	, const double& dW) const
{
	AcGePoint3d ptSta = ptFr;
	AcGeVector3d vtL = ptTo - ptFr;
	vtL.normalize();

	double dLx = data.nSteepS * data.dSteepW;
	double dLh = data.nSteepS * data.dSteepH + (data.dSteepW - data.dSteepH);
	double dL = sqrt(dLx * dLx + dLh * dLh);

	AcGePoint3d ptEnd = ptSta + vtL * dL;

	AcGeVector3d vtLXY = vtL;
	vtLXY.z = 0.0;

	//一共多少步
	int nCount = data.nSteepS;

	vtL.normalize();
	vtLXY.normalize();

	AcGeVector3d vtW = vtLXY;
	vtW.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
	vtW.normalize();

	//踏步左右总宽
	double dSteepL = dW;

	AcGePoint3d ptV, ptV0;
	AcGePoint3dArray arSecPts;

	ptV = ptSta;
	ptV -= vtW * 0.5 * dSteepL;

	if (data.bLBeam)
		ptV += vtW * 120.0;//变量宽,国家标准120

	//插入楼板的点 [AAA]
	ptV.z -= (data.dSteepW - data.dSteepH);

	ptV0 = ptV;
	arSecPts.append(ptV);

	ptV.z += data.dSteepW;//第一层等边直角
	arSecPts.append(ptV);

	for (int i = 0; i < nCount - 1; i++)
	{
		ptV += vtLXY * data.dSteepW;
		arSecPts.append(ptV);

		ptV.z += data.dSteepH;
		arSecPts.append(ptV);
	}

	AcGeVector3d vtUp = arSecPts.last() - arSecPts.at(1);
	AcGeLine3d ln3d;
	ln3d.set(ptV0, vtUp);

	AcGePoint3d ptV1 = ptV + vtLXY * data.dSteepW;
	int nLast = arSecPts.append(ptV1);

	AcGeLine3d lnEnd;
	lnEnd.set(ptV1, AcGeVector3d::kZAxis);

	AcGePoint3d ptInt;
	if (ln3d.intersectWith(lnEnd, ptInt))
	{
		arSecPts.append(ptInt);

		AcGePoint3d& ptT = arSecPts.first();

		//闭合
		arSecPts.append(ptT);

		//测试
		//AcDb3dPolyline* pPl = Format3dPolyline(arSecPts);
		//pPl->setColorIndex(3);
		//CoreTools::AddToModelSpace(pPl);

		AcDbRegion* pReg = AecDbEarthWorm::CreatePolygonRegionOnly(arSecPts.asArrayPtr(), arSecPts.length());
		if (pReg != NULL)
		{
			AcDbLine lnPath;
			lnPath.setStartPoint(ptV0);

			if (data.bLBeam)
				ptV = ptV0 + vtW * (dSteepL - 120.0);
			else
				ptV = ptV0 + vtW * dSteepL;

			if (data.bRBeam)
				ptV -= vtW * 120.0;//变梁宽,国标120

			lnPath.setEndPoint(ptV);

			AcDbX3dSolid xSolid;
			if (xSolid.CreateExtrude(pReg, lnPath))
			{
				AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
				if (pSolid != NULL)
				{
					dc.DrawEntity(pSolid);
					dc.Add3dBuffer(pSolid);
					add3DCache<AecDbParaLlelStair>(&xSolid);
					return Acad::eOk;
				}
			}
		}
	}
	return Acad::eInvalidInput;
}

Acad::ErrorStatus AecDbParaLlelStairDraw::DrawPlatform(AcGiDraw& dc
	, const AcGePoint3d& ptSta
	, const double& dL
	, const double& dW
	, const AcGeVector3d& vtSE
	, const AcGeVector3d& vtSEDir
	, const int& bRect, const SFSPStair& data) const
{
	AcDbRegion *pReg(NULL);
	AcGePoint3d ptOrg(ptSta), pt;
	AcDbLine ln;

	if (!bRect)
	{
		ptOrg -= vtSE * dL * .5;
		ptOrg -= vtSEDir * dW * .5;
		pReg = makeRectRegion(ptOrg, dL, dW, vtSE, vtSEDir);
		if (pReg == NULL) return Acad::eOk;
	}
	else
	{
		AcDbVoidPtrArray ar;
		AcGePoint3d ptS, ptE, ptS1, ptE1;
	
		pt = ptOrg - vtSE * data.dStairTW;
		AcDbPolyline* pPoly = new AcDbPolyline();
		pPoly->addVertexAt(0, ptOrg.convert2d(AcGePlane::kXYPlane), -1);
		pPoly->addVertexAt(1, pt.convert2d(AcGePlane::kXYPlane));
		if (!pPoly) return Acad::eOk;

		pPoly->getStartPoint(ptS);
		pPoly->getEndPoint(ptE);
		ptS1 = ptS - vtSEDir * dW;
		ptE1 = ptE - vtSEDir * dW;

		ar.append(new AcDbLine(ptS, ptS1));
		ar.append(new AcDbLine(ptS1, ptE1));
		ar.append(new AcDbLine(ptE1, ptE));
		ar.append(pPoly);

		pReg = CoreTools::createRegion(ar);
		if (pReg == NULL) return Acad::eOk;

		deleteArrayVoidPtrs<AcDbEntity>(ar);

		AcDbExtents ext;
		pReg->getGeomExtents(ext);
		AcGePoint3d ptCen(CoreTools::MidPt(ext.maxPoint(), ext.minPoint()));
		ptOrg = ptCen;
	}

	ln.setStartPoint(ptOrg);
	ln.setEndPoint(ptOrg - AcGeVector3d::kZAxis * data.dSbThick);

	AcDbX3dSolid xSolid;
	AcGeMatrix3d mat;
	double dH(.0);
	if (xSolid.CreateExtrude(pReg, ln))
	{
		AcDb3dSolid *pSolid = xSolid.GetDraw3dSolid();
		if (pSolid != NULL)
		{
			if (data.nUpSide == 0)
			{
				dH = data.nSteepMs * data.dSteepH + data.dBomEl;
			}
			else
			{
				dH = data.nSteepsS * data.dSteepH + data.dBomEl;
			}

			if (data.nRestShape == 0)
			{
				dH -= data.dBomEl;
			}

			mat.setTranslation(AcGeVector3d::kZAxis * dH);
			pSolid->transformBy(mat);
			dc.DrawEntity(pSolid);
			dc.Add3dBuffer(pSolid);
			xSolid.TransformBy(mat);
			add3DCache<AecDbParaLlelStair>(&xSolid);
		}
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbParaLlelStairDraw::DrawAlignPlatMid(AcGiDraw& dc
	, const AcGePoint3d& ptFr
	, const AcGeVector3d& vtSE
	, const AcGeVector3d& vtSEDir
	, const double& dCenter
	, const double& dSide
	, const SFSPStair& data) const
{
	AcGePoint3d ptSta(ptFr), ptEnd;
	SFSPStair data1(data);
	AcGeVector3d Z(AcGeVector3d::kZAxis);
	AcGePoint3d ptGeL[4];
	AcGePoint3d ptGeR[4];

	ptSta += Z * dCenter;
	ptSta -= vtSE * data1.dStairTW * .5;
	ptSta -= vtSEDir * (data1.dRestPtW + (data1.nSteepMs - 1) * data1.dSteepW);
	ptEnd = ptSta + vtSEDir * data1.nSteepMs * data1.dSteepW;

	data1.nSteepS = data1.nSteepMs;
	DrawSide3d(dc, ptSta, ptEnd, data1, data.dStairMW);
	DrawSteep3d(dc, ptSta, ptEnd, data1, data.dStairMW);

	data1.nSteepS = data1.nSteepMs - 1;
	if (data.bInsideRail)
	{
		DrawGuard(dc, ptSta, ptEnd, 0, data.dStairMW, data1);
		DrawGuard(dc, ptSta, ptEnd, 1, data.dStairMW, data1);
	}
	if (data.bOutSideRail)
	{
		DrawGuard(dc, ptSta, ptEnd, 1, data.dStairMW, data1);
	}
	
	ptGeL[0] = ptSta;
	ptGeL[1] = ptEnd;

	ptGeR[0] = ptSta;
	ptGeR[1] = ptEnd;

	ptSta += Z * dSide;
	ptEnd += Z * dSide;
	
	ptSta += vtSE * (data.dStairTW - data.dStairSW) * .5;
	ptEnd += vtSE * (data.dStairTW - data.dStairSW) * .5;
	ptSta -= vtSEDir * data.dSteepW;
	ptEnd -= vtSEDir * data.dSteepW;

	data1.nSteepS = data1.nSteepsS;
	DrawSide3d(dc, ptEnd, ptSta, data1, data.dStairSW);
	DrawSteep3d(dc, ptEnd, ptSta, data1, data.dStairSW);
	if (data.bInsideRail)
	{
		DrawGuard(dc, ptEnd, ptSta, 0, data.dStairSW, data1);
	}
	if (data.bOutSideRail)
	{
		DrawGuard(dc, ptEnd, ptSta, 1, data.dStairSW, data1);
	}

	ptGeL[2] = ptEnd;
	ptGeL[3] = ptSta;
	
	ptSta -= vtSE * (data.dStairTW - data.dStairSW);
	ptEnd -= vtSE * (data.dStairTW - data.dStairSW);

	data1.nSteepS = data1.nSteepsS;
	DrawSide3d(dc, ptEnd, ptSta, data1, data.dStairSW);
	DrawSteep3d(dc, ptEnd, ptSta, data1, data.dStairSW);
	if (data.bInsideRail)
	{
		DrawGuard(dc, ptEnd, ptSta, 1, data.dStairSW, data1);
	}
	if (data.bOutSideRail)
	{
		DrawGuard(dc, ptEnd, ptSta, 0, data.dStairSW, data1);
	}

	ptGeR[2] = ptEnd;
	ptGeR[3] = ptSta;

	DrawHandRail3d(dc, ptGeL, 0, vtSE, vtSEDir, 0, data1);
	DrawHandRail3d(dc, ptGeR, 0, vtSE, vtSEDir, 1, data1);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbParaLlelStairDraw::DrawAlignCenMid(AcGiDraw& dc
	, const AcGePoint3d& ptFr
	, const AcGePoint3d& ptTo
	, const AcGeVector3d& vtSE
	, const AcGeVector3d& vtSEDir
	, const SFPXStair& data) const                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
{
	AcGePoint3d ptSta(ptFr), ptEnd(ptTo);
	SFPXStair data1(data);
	AcGePoint3d ptGeL[4];
	AcGePoint3d ptGeR[4];
	AcGeVector3d Z(AcGeVector3d::kZAxis);

	if (data1.nSteepMs > data1.nSteepsS)
	{
		ptSta -= vtSE * data1.dStairTW * .5;
		ptSta -= vtSEDir * (data1.dRestPtW + (data1.nSteepMs - 1) * data1.dSteepW);
		ptEnd = ptSta + vtSEDir * data1.nSteepMs * data1.dSteepW;

		data1.nSteepS = data1.nSteepMs;
		DrawSide3d(dc, ptSta, ptEnd, data1, data1.dStairMW);
		DrawSteep3d(dc, ptSta, ptEnd, data1, data1.dStairMW);

		data1.nSteepS = data1.nSteepMs - 1;
		if (data.bInsideRail)
		{
			DrawGuard(dc, ptSta, ptEnd, 0, data.dStairMW, data1);
			DrawGuard(dc, ptSta, ptEnd, 1, data.dStairMW, data1);
		}
		if (data.bOutSideRail)
		{
			DrawGuard(dc, ptSta, ptEnd, 1, data.dStairMW, data1);
		}

		ptGeL[0] = ptSta;
		ptGeL[1] = ptEnd;

		ptGeR[0] = ptSta;
		ptGeR[1] = ptEnd;

		ptSta += Z * data1.nSteepMs * data1.dSteepH;
		ptEnd += Z * data1.nSteepMs * data1.dSteepH;
		ptSta -= vtSEDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW * .5);
		ptEnd -= vtSEDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW * .5);
		ptSta += vtSE * (data1.dStairTW - data1.dStairSW) * .5;
		ptEnd += vtSE * (data1.dStairTW - data1.dStairSW) * .5;
		ptSta -= vtSEDir * data.dSteepW;
		ptEnd -= vtSEDir * data.dSteepW;

		data1.nSteepS = data1.nSteepsS;
		DrawSide3d(dc, ptEnd, ptSta, data1, data.dStairSW);
		DrawSteep3d(dc, ptEnd, ptSta, data1, data.dStairSW);
		if (data.bInsideRail)
		{
			DrawGuard(dc, ptEnd, ptSta, 0, data.dStairSW, data1);
		}
		if (data.bOutSideRail)
		{
			DrawGuard(dc, ptEnd, ptSta, 1, data.dStairSW, data1);
		}

		ptGeL[2] = ptEnd;
		ptGeL[3] = ptSta;

		ptSta -= vtSE * (data1.dStairTW - data1.dStairSW);
		ptEnd -= vtSE * (data1.dStairTW - data1.dStairSW);
		DrawSide3d(dc, ptEnd, ptSta, data1, data.dStairSW);
		DrawSteep3d(dc, ptEnd, ptSta, data1, data.dStairSW);
		if (data.bInsideRail)
		{
			DrawGuard(dc, ptEnd, ptSta, 1, data.dStairSW, data1);
		}
		if (data.bOutSideRail)
		{
			DrawGuard(dc, ptEnd, ptSta, 0, data.dStairSW, data1);
		}

		ptGeR[2] = ptEnd;
		ptGeR[3] = ptSta;

		DrawHandRail3d(dc, ptGeL, 0, vtSE, vtSEDir, 0, data1);
		DrawHandRail3d(dc, ptGeR, 0, vtSE, vtSEDir, 1, data1);
	}

	else if (data1.nSteepMs < data1.nSteepsS)
	{
		//中梯
		ptSta -= vtSE * data1.dStairTW * .5;
		ptSta -= vtSEDir * (data1.dRestPtW + (data1.nSteepsS - data1.nSteepMs - 2) * data1.dSteepW * .5);
		ptEnd = ptSta - vtSEDir * data1.nSteepMs * data1.dSteepW;

		data1.nSteepS = data1.nSteepMs;
		DrawSide3d(dc, ptEnd, ptSta, data1, data1.dStairMW);
		DrawSteep3d(dc, ptEnd, ptSta, data1, data1.dStairMW);

		data1.nSteepS = data1.nSteepMs - 1;
		if (data.bInsideRail)
		{
			DrawGuard(dc, ptEnd, ptSta, 0, data.dStairMW, data1);
			DrawGuard(dc, ptEnd, ptSta, 1, data.dStairMW, data1);
		}
		if (data.bOutSideRail)
		{
			DrawGuard(dc, ptEnd, ptSta, 1, data.dStairMW, data1);
		}

		ptGeL[0] = ptEnd;
		ptGeL[1] = ptSta;

		ptGeR[0] = ptEnd;
		ptGeR[1] = ptSta;
		
		ptSta += Z * data1.nSteepMs * data1.dSteepH;
		ptSta += vtSE * (data1.dStairTW - data1.dStairSW) * .5;
		ptSta += vtSEDir * (data1.nSteepsS - data1.nSteepMs) * data1.dSteepW * .5;
		ptEnd = ptSta - vtSEDir * data1.nSteepsS * data1.dSteepW;
		ptSta -= vtSEDir * data.dSteepW;
		ptEnd -= vtSEDir * data.dSteepW;

		data1.nSteepS = data1.nSteepsS;
		DrawSide3d(dc, ptSta, ptEnd, data1, data1.dStairSW);
		DrawSteep3d(dc, ptSta, ptEnd, data1, data1.dStairSW);
		if (data.bInsideRail)
		{
			DrawGuard(dc, ptSta, ptEnd, 0, data.dStairSW, data1);
		}
		if (data.bOutSideRail)
		{
			DrawGuard(dc, ptSta, ptEnd, 1, data.dStairSW, data1);
		}

		ptGeL[2] = ptSta;
		ptGeL[3] = ptEnd;

		ptSta -= vtSE * (data1.dStairTW - data1.dStairSW);
		ptEnd -= vtSE * (data1.dStairTW - data1.dStairSW);
		DrawSide3d(dc, ptSta, ptEnd, data1, data1.dStairSW);
		DrawSteep3d(dc, ptSta, ptEnd, data1, data1.dStairSW);
		if (data.bInsideRail)
		{
			DrawGuard(dc, ptSta, ptEnd, 1, data.dStairSW, data1);
		}
		if (data.bOutSideRail)
		{
			DrawGuard(dc, ptSta, ptEnd, 0, data.dStairSW, data1);
		}

		ptGeR[2] = ptSta;
		ptGeR[3] = ptEnd;

		DrawHandRail3d(dc, ptGeL, (data1.nSteepsS - data1.nSteepMs) * data1.dSteepW * .5, vtSE, vtSEDir, 0, data1);
		DrawHandRail3d(dc, ptGeR, (data1.nSteepsS - data1.nSteepMs) * data1.dSteepW * .5, vtSE, vtSEDir, 1, data1);
	}

	else if(data1.nSteepMs == data1.nSteepsS)
	{
		DrawAlignPlatMid(dc, ptSta, vtSE, vtSEDir, 0, data.nSteepMs* data.dSteepH, data);
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbParaLlelStairDraw::DrawAlignFloorMid(AcGiDraw& dc
	, const AcGePoint3d& ptFr
	, const AcGePoint3d& ptTo
	, const AcGeVector3d& vtSE
	, const AcGeVector3d& vtSEDir
	, const SFSPStair& data) const
{
	AcGePoint3d ptSta(ptFr), ptEnd(ptTo);
	SFPXStair data1(data);
	AcGePoint3d ptGeL[4] ;
	AcGePoint3d ptGeR[4];
	AcGeVector3d Z(AcGeVector3d::kZAxis);

	if (data1.nSteepMs > data1.nSteepsS)
	{
		//中梯
		ptSta -= vtSE * data1.dStairTW * .5;
		ptSta -= vtSEDir * (data1.dRestPtW + (data1.nSteepMs - 1) * data1.dSteepW);
		ptEnd = ptSta + vtSEDir * data1.nSteepMs * data1.dSteepW;
		data1.nSteepS = data1.nSteepMs;

		DrawSide3d(dc, ptSta, ptEnd, data1, data1.dStairMW);
		DrawSteep3d(dc, ptSta, ptEnd, data1, data1.dStairMW);

		data1.nSteepS = data1.nSteepMs - 1;
		if (data.bInsideRail)
		{
			DrawGuard(dc, ptSta, ptEnd, 0, data.dStairMW, data1);
			DrawGuard(dc, ptSta, ptEnd, 1, data.dStairMW, data1);
		}
		if (data.bOutSideRail)
		{
			DrawGuard(dc, ptSta, ptEnd, 1, data.dStairMW, data1);
		}

		ptGeL[0] = ptSta;
		ptGeL[1] = ptEnd;

		ptGeR[0] = ptSta;
		ptGeR[1] = ptEnd;

		//边梯
		ptSta += vtSE * (data1.dStairTW - data1.dStairSW) * .5;
		ptEnd += vtSE * (data1.dStairTW - data1.dStairSW) * .5;
		ptSta += Z * data1.nSteepMs * data1.dSteepH;
		ptEnd += Z * data1.nSteepMs * data1.dSteepH;
		ptSta -= vtSEDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW);
		ptEnd -= vtSEDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW);
		ptSta -= vtSEDir * data.dSteepW;
		ptEnd -= vtSEDir * data.dSteepW;

		data1.nSteepS = data1.nSteepsS;
		DrawSide3d(dc, ptEnd, ptSta, data1, data1.dStairSW);
		DrawSteep3d(dc, ptEnd, ptSta, data1, data1.dStairSW);
		if (data.bInsideRail)
		{
			DrawGuard(dc, ptEnd, ptSta, 0, data.dStairSW, data1);
		}
		if (data.bOutSideRail)
		{
			DrawGuard(dc, ptEnd, ptSta, 1, data.dStairSW, data1);
		}

		ptGeL[2] = ptEnd;
		ptGeL[3] = ptSta;

		ptSta -= vtSE * (data1.dStairTW - data1.dStairSW);
		ptEnd -= vtSE * (data1.dStairTW - data1.dStairSW);
		data1.nSteepS = data1.nSteepsS;

		DrawSide3d(dc, ptEnd, ptSta, data1, data1.dStairSW);
		DrawSteep3d(dc, ptEnd, ptSta, data1, data1.dStairSW);
		if (data.bInsideRail)
		{
			DrawGuard(dc, ptEnd, ptSta, 1, data.dStairSW, data1);
		}
		if (data.bOutSideRail)
		{
			DrawGuard(dc, ptEnd, ptSta, 0, data.dStairSW, data1);
		}

		ptGeR[2] = ptEnd;
		ptGeR[3] = ptSta;

		DrawHandRail3d(dc, ptGeL, 0, vtSE, vtSEDir, 0, data1);
		DrawHandRail3d(dc, ptGeR, 0, vtSE, vtSEDir, 1, data1);

	}

	else if (data1.nSteepMs < data1.nSteepsS)
	{
		//中梯
		ptSta -= vtSE * data1.dStairTW * .5;
		ptSta -= vtSEDir * data1.dRestPtW;
		ptSta -= vtSEDir * ((data1.nSteepsS - data1.nSteepMs - 1) * data1.dSteepW);
		ptEnd = ptSta - vtSEDir * data1.nSteepMs * data1.dSteepW;

		data1.nSteepS = data1.nSteepMs;
		DrawSide3d(dc, ptEnd, ptSta, data1, data1.dStairMW);
		DrawSteep3d(dc, ptEnd, ptSta, data1, data1.dStairMW);

		data1.nSteepS = data1.nSteepMs - 1;
		if (data.bInsideRail)
		{
			DrawGuard(dc, ptEnd, ptSta, 0, data.dStairMW, data1);
			DrawGuard(dc, ptEnd, ptSta, 1, data.dStairMW, data1);
		}
		if (data.bOutSideRail)
		{
			DrawGuard(dc, ptEnd, ptSta, 1, data.dStairMW, data1);
		}

		ptGeL[0] = ptEnd;
		ptGeL[1] = ptSta;

		ptGeR[0] = ptEnd;
		ptGeR[1] = ptSta;

		ptSta += Z * data1.nSteepMs * data1.dSteepH;
		ptSta += vtSE * (data1.dStairTW - data1.dStairSW) * .5;
		ptSta += vtSEDir * (data1.nSteepsS - data1.nSteepMs) * data1.dSteepW;
		ptEnd = ptSta - vtSEDir * data1.nSteepsS * data1.dSteepW;
		ptSta -= vtSEDir * data.dSteepW;
		ptEnd -= vtSEDir * data.dSteepW;

		data1.nSteepS = data1.nSteepsS;
		DrawSide3d(dc, ptSta, ptEnd, data1, data1.dStairSW);
		DrawSteep3d(dc, ptSta, ptEnd, data1, data1.dStairSW);
		if (data.bInsideRail)
		{
			DrawGuard(dc, ptSta, ptEnd, 0, data.dStairSW, data1);
		}
		if (data.bOutSideRail)
		{
			DrawGuard(dc, ptSta, ptEnd, 1, data.dStairSW, data1);
		}

		ptGeL[2] = ptSta;
		ptGeL[3] = ptEnd;

		ptSta -= vtSE * (data1.dStairTW - data1.dStairSW);
		ptEnd -= vtSE * (data1.dStairTW - data1.dStairSW);
		DrawSide3d(dc, ptSta, ptEnd, data1, data1.dStairSW);
		DrawSteep3d(dc, ptSta, ptEnd, data1, data1.dStairSW);
		if (data.bInsideRail)
		{
			DrawGuard(dc, ptSta, ptEnd, 1, data.dStairSW, data1);
		}
		if (data.bOutSideRail)
		{
			DrawGuard(dc, ptSta, ptEnd, 0, data.dStairSW, data1);
		}

		ptGeR[2] = ptSta;
		ptGeR[3] = ptEnd;

		DrawHandRail3d(dc, ptGeL, (data1.nSteepsS - data1.nSteepMs) * data1.dSteepW, vtSE, vtSEDir, 0, data1);
		DrawHandRail3d(dc, ptGeR, (data1.nSteepsS - data1.nSteepMs) * data1.dSteepW, vtSE, vtSEDir, 1, data1);
	}

	else if (data1.nSteepMs == data1.nSteepsS)
	{
		DrawAlignPlatMid(dc, ptSta, vtSE, vtSEDir, 0, data.nSteepMs * data.dSteepH, data);
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbParaLlelStairDraw::DrawAlignPlatSide(AcGiDraw& dc
	, const AcGePoint3d& ptFr
	, const AcGePoint3d& ptTo
	, const AcGeVector3d& vtSE
	, const AcGeVector3d& vtSEDir
	, const SFPXStair& data) const
{
	AcGePoint3d ptSta(ptFr), ptEnd(ptTo);
	SFPXStair data1(data);
	AcGePoint3d ptGeL[4];
	AcGePoint3d ptGeR[4];
	AcGeVector3d Z(AcGeVector3d::kZAxis);

	ptSta += Z * data1.nSteepsS * data1.dSteepH;
	ptSta -= vtSE * data1.dStairTW * .5;
	ptSta -= vtSEDir * data1.dRestPtW;
	ptEnd = ptSta - vtSEDir * data1.nSteepMs * data1.dSteepW;

	data1.nSteepS = data1.nSteepMs;
	DrawSide3d(dc, ptSta, ptEnd, data1, data.dStairMW);
	DrawSteep3d(dc, ptSta, ptEnd, data1, data.dStairMW);
	if (data.bInsideRail)
	{
		DrawGuard(dc, ptSta, ptEnd, 0, data.dStairMW, data1);
		DrawGuard(dc, ptSta, ptEnd, 1, data.dStairMW, data1);
	}
	if (data.bOutSideRail)
	{
		DrawGuard(dc, ptSta, ptEnd, 1, data.dStairMW, data1);
	}

	ptGeL[0] = ptSta;
	ptGeL[1] = ptEnd;

	ptGeR[0] = ptSta;
	ptGeR[1] = ptEnd;

	ptSta -= Z * data1.nSteepsS * data1.dSteepH;
	ptSta += vtSE * (data.dStairTW - data.dStairSW) * .5;
	ptEnd = ptSta - vtSEDir * data1.nSteepsS * data1.dSteepW;
	ptSta += vtSEDir * data.dSteepW;
	ptEnd += vtSEDir * data.dSteepW;

	data1.nSteepS = data1.nSteepsS;
	DrawSide3d(dc, ptEnd, ptSta, data1, data.dStairSW);
	DrawSteep3d(dc, ptEnd, ptSta, data1, data.dStairSW);

	data1.nSteepS = data1.nSteepsS - 1;
	if (data.bInsideRail)
	{
		DrawGuard(dc, ptEnd, ptSta, 0, data.dStairSW, data1);
	}
	if (data.bOutSideRail)
	{
		DrawGuard(dc, ptEnd, ptSta, 1, data.dStairSW, data1);
	}

	ptGeL[2] = ptEnd;
	ptGeL[3] = ptSta;

	ptSta -= vtSE * (data.dStairTW - data.dStairSW);
	ptEnd -= vtSE * (data.dStairTW - data.dStairSW);

	data1.nSteepS = data1.nSteepsS;
	DrawSide3d(dc, ptEnd, ptSta, data1, data.dStairSW);
	DrawSteep3d(dc, ptEnd, ptSta, data1, data.dStairSW);

	data1.nSteepS = data1.nSteepsS - 1;
	if (data.bInsideRail)
	{
		DrawGuard(dc, ptEnd, ptSta, 1, data.dStairSW, data1);
	}
	if (data.bOutSideRail)
	{
		DrawGuard(dc, ptEnd, ptSta, 0, data.dStairSW, data1);
	}

	ptGeR[2] = ptEnd;
	ptGeR[3] = ptSta;

	DrawHandRail3d(dc, ptGeL, 0, vtSE, vtSEDir, 0, data1);
	DrawHandRail3d(dc, ptGeR, 0, vtSE, vtSEDir, 1, data1);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbParaLlelStairDraw::DrawAlignCenSide(AcGiDraw& dc
	, const AcGePoint3d& ptFr
	, const AcGePoint3d& ptTo
	, const AcGeVector3d& vtSE
	, const AcGeVector3d& vtSEDir
	, const SFPXStair& data) const
{
	AcGePoint3d ptSta(ptFr), ptEnd(ptTo);
	SFPXStair data1(data);
	AcGePoint3d ptGeL[4];
	AcGePoint3d ptGeR[4];
	AcGeVector3d Z(AcGeVector3d::kZAxis);

	if (data1.nSteepMs > data1.nSteepsS)
	{
		ptSta += Z * data1.nSteepsS * data1.dSteepH;
		ptSta -= vtSE * data1.dStairTW * .5;
		ptSta -= vtSEDir * data1.dRestPtW;
		ptEnd = ptSta - vtSEDir * data1.nSteepMs * data1.dSteepW;

		data1.nSteepS = data1.nSteepMs;
		DrawSide3d(dc, ptSta, ptEnd, data1, data1.dStairMW);
		DrawSteep3d(dc, ptSta, ptEnd, data1, data1.dStairMW);
		if (data.bInsideRail)
		{
			DrawGuard(dc, ptSta, ptEnd, 0, data.dStairMW, data1);
			DrawGuard(dc, ptSta, ptEnd, 1, data.dStairMW, data1);
		}
		if (data.bOutSideRail)
		{
			DrawGuard(dc, ptSta, ptEnd, 1, data.dStairMW, data1);
		}

		ptGeL[0] = ptSta;
		ptGeL[1] = ptEnd;

		ptGeR[0] = ptSta;
		ptGeR[1] = ptEnd;

		ptSta -= Z * data1.nSteepsS * data1.dSteepH;
		ptSta += vtSE * (data1.dStairTW - data1.dStairSW) * .5;
		ptEnd = ptSta - vtSEDir * data1.nSteepsS * data1.dSteepW;
		ptSta -= vtSEDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW * .5);
		ptEnd -= vtSEDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW * .5);
		ptSta += vtSEDir * data.dSteepW;
		ptEnd += vtSEDir * data.dSteepW;

		data1.nSteepS = data1.nSteepsS;
		DrawSide3d(dc, ptEnd, ptSta, data1, data1.dStairSW);
		DrawSteep3d(dc, ptEnd, ptSta, data1, data1.dStairSW);

		data1.nSteepS = data1.nSteepsS - 1;
		if (data.bInsideRail)
		{
			DrawGuard(dc, ptEnd, ptSta, 0, data.dStairSW, data1);
		}
		if (data.bOutSideRail)
		{
			DrawGuard(dc, ptEnd, ptSta, 1, data.dStairSW, data1);
		}

		ptGeL[2] = ptEnd;
		ptGeL[3] = ptSta;

		data1.nSteepS = data1.nSteepsS;
		ptSta -= vtSE * (data1.dStairTW - data1.dStairSW);
		ptEnd -= vtSE * (data1.dStairTW - data1.dStairSW);
		DrawSide3d(dc, ptEnd, ptSta, data1, data1.dStairSW);
		DrawSteep3d(dc, ptEnd, ptSta, data1, data1.dStairSW);

		data1.nSteepS = data1.nSteepsS - 1;
		if (data.bInsideRail)
		{
			DrawGuard(dc, ptEnd, ptSta, 1, data.dStairSW, data1);
		}
		if (data.bOutSideRail)
		{
			DrawGuard(dc, ptEnd, ptSta, 0, data.dStairSW, data1);
		}

		ptGeR[2] = ptEnd;
		ptGeR[3] = ptSta;

		DrawHandRail3d(dc, ptGeL, (data1.nSteepMs - data1.nSteepsS) * data1.dSteepW * .5, vtSE, vtSEDir, 0, data1);
		DrawHandRail3d(dc, ptGeR, (data1.nSteepMs - data1.nSteepsS) * data1.dSteepW * .5, vtSE, vtSEDir, 1, data1);
	}

	else if (data1.nSteepMs < data1.nSteepsS)
	{
		ptSta += Z * data1.nSteepsS * data1.dSteepH;
		ptSta -= vtSE * data1.dStairTW * .5;
		ptSta -= vtSEDir * (data1.dRestPtW + (data1.nSteepsS - data1.nSteepMs) * data1.dSteepW * .5);
		ptEnd = ptSta - vtSEDir * data1.nSteepMs * data1.dSteepW;

		data1.nSteepS = data1.nSteepMs;
		DrawSide3d(dc, ptSta, ptEnd, data1, data1.dStairMW);
		DrawSteep3d(dc, ptSta, ptEnd, data1, data1.dStairMW);
		if (data.bInsideRail)
		{
			DrawGuard(dc, ptSta, ptEnd, 0, data.dStairMW, data1);
			DrawGuard(dc, ptSta, ptEnd, 1, data.dStairMW, data1);
		}
		if (data.bOutSideRail)
		{
			DrawGuard(dc, ptSta, ptEnd, 1, data.dStairMW, data1);
		}

		ptGeL[0] = ptSta;
		ptGeL[1] = ptEnd;

		ptGeR[0] = ptSta;
		ptGeR[1] = ptEnd;

		ptSta -= Z * data1.nSteepsS * data1.dSteepH;
		ptSta += vtSEDir * (data1.nSteepsS - data1.nSteepMs) * data1.dSteepW * .5;
		ptSta += vtSE * (data1.dStairTW - data1.dStairSW) * .5;
		ptEnd = ptSta - vtSEDir * data1.nSteepsS * data1.dSteepW;
		ptSta += vtSEDir * data.dSteepW;
		ptEnd += vtSEDir * data.dSteepW;

		data1.nSteepS = data1.nSteepsS;
		DrawSide3d(dc, ptEnd, ptSta, data1, data1.dStairSW);
		DrawSteep3d(dc, ptEnd, ptSta, data1, data1.dStairSW);

		data1.nSteepS = data1.nSteepsS - 1;
		if (data.bInsideRail)
		{
			DrawGuard(dc, ptEnd, ptSta, 0, data.dStairSW, data1);
		}
		if (data.bOutSideRail)
		{
			DrawGuard(dc, ptEnd, ptSta, 1, data.dStairSW, data1);
		}

		ptGeL[2] = ptEnd;
		ptGeL[3] = ptSta;

		data1.nSteepS = data1.nSteepsS;
		ptSta -= vtSE * (data1.dStairTW - data1.dStairSW);
		ptEnd -= vtSE * (data1.dStairTW - data1.dStairSW);
		DrawSide3d(dc, ptEnd, ptSta, data1, data1.dStairSW);
		DrawSteep3d(dc, ptEnd, ptSta, data1, data1.dStairSW);

		data1.nSteepS = data1.nSteepsS - 1;
		if (data.bInsideRail)
		{
			DrawGuard(dc, ptEnd, ptSta, 1, data.dStairSW, data1);
		}
		if (data.bOutSideRail)
		{
			DrawGuard(dc, ptEnd, ptSta, 0, data.dStairSW, data1);
		}

		ptGeR[2] = ptEnd;
		ptGeR[3] = ptSta;

		DrawHandRail3d(dc, ptGeL, (data1.nSteepsS - data1.nSteepMs) * data1.dSteepW * .5, vtSE, vtSEDir, 0, data1);
		DrawHandRail3d(dc, ptGeR, (data1.nSteepsS - data1.nSteepMs) * data1.dSteepW * .5, vtSE, vtSEDir, 1, data1);
	}

	else if (data1.nSteepMs == data1.nSteepsS)
	{
		DrawAlignPlatSide(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbParaLlelStairDraw::DrawAlignFloorSide(AcGiDraw& dc
	, const AcGePoint3d& ptFr
	, const AcGeVector3d& vtSE
	, const AcGeVector3d& vtSEDir
	, const double& dCenter
	, const SFSPStair& data) const
{
	AcGePoint3d ptSta(ptFr), ptEnd;
	SFSPStair data1(data);
	AcGePoint3d ptGeL[4];
	AcGePoint3d ptGeR[4];
	AcGeVector3d Z(AcGeVector3d::kZAxis);

	if (data1.nSteepMs > data1.nSteepsS)
	{
		ptSta += Z * dCenter;
		ptSta -= vtSE * data1.dStairTW * .5;
		ptSta -= vtSEDir * (data1.dRestPtW + data1.nSteepsS * data1.dSteepW);
		ptSta += vtSEDir * (data1.nSteepsS - data1.nSteepMs) * data1.dSteepW;
		ptEnd = ptSta + vtSEDir * data1.nSteepMs * data1.dSteepW;

		data1.nSteepS = data1.nSteepMs;
		DrawSide3d(dc, ptEnd, ptSta, data1, data.dStairMW);
		DrawSteep3d(dc, ptEnd, ptSta, data1, data.dStairMW);
		if (data.bInsideRail)
		{
			DrawGuard(dc, ptEnd, ptSta, 0, data.dStairMW, data1);
			DrawGuard(dc, ptEnd, ptSta, 1, data.dStairMW, data1);
		}
		if (data.bOutSideRail)
		{
			DrawGuard(dc, ptEnd, ptSta, 1, data.dStairMW, data1);
		}

		ptGeL[0] = ptEnd;
		ptGeL[1] = ptSta;

		ptGeR[0] = ptEnd;
		ptGeR[1] = ptSta;

		ptSta -= Z * dCenter;
		ptEnd -= Z * dCenter;
		ptSta += vtSE * (data.dStairTW - data.dStairSW) * .5;
		ptEnd += vtSE * (data.dStairTW - data.dStairSW) * .5;
		ptSta += vtSEDir * data.dSteepW;
		ptEnd += vtSEDir * data.dSteepW;

		data1.nSteepS = data1.nSteepsS;
		DrawSide3d(dc, ptSta, ptEnd, data1, data.dStairSW);
		DrawSteep3d(dc, ptSta, ptEnd, data1, data.dStairSW);

		data1.nSteepS = data1.nSteepsS - 1;
		if (data.bInsideRail)
		{
			DrawGuard(dc, ptSta, ptEnd, 0, data.dStairSW, data1);
		}
		if (data.bOutSideRail)
		{
			DrawGuard(dc, ptSta, ptEnd, 1, data.dStairSW, data1);
		}
		
		ptGeL[2] = ptSta;
		ptGeL[3] = ptEnd;

		ptSta -= vtSE * (data.dStairTW - data.dStairSW);
		ptEnd -= vtSE * (data.dStairTW - data.dStairSW);

		data1.nSteepS = data1.nSteepsS;
		DrawSide3d(dc, ptSta, ptEnd, data1, data.dStairSW);
		DrawSteep3d(dc, ptSta, ptEnd, data1, data.dStairSW);

		data1.nSteepS = data1.nSteepsS - 1;
		if (data.bInsideRail)
		{
			DrawGuard(dc, ptSta, ptEnd, 1, data.dStairSW, data1);
		}
		if (data.bOutSideRail)
		{
			DrawGuard(dc, ptSta, ptEnd, 0, data.dStairSW, data1);
		}

		ptGeR[2] = ptSta;
		ptGeR[3] = ptEnd;

		DrawHandRail3d(dc, ptGeL, (data1.nSteepMs - data1.nSteepsS) * data1.dSteepW, vtSE, vtSEDir, 0, data1);
		DrawHandRail3d(dc, ptGeR, (data1.nSteepMs - data1.nSteepsS) * data1.dSteepW, vtSE, vtSEDir, 1, data1);
	}

	else if (data1.nSteepMs < data1.nSteepsS)
	{
		ptSta += Z * dCenter;
		ptSta -= vtSE * data1.dStairTW * .5;
		ptSta -= vtSEDir * (data1.dRestPtW + data1.nSteepsS * data1.dSteepW);
		ptEnd = ptSta + vtSEDir * data1.nSteepMs * data1.dSteepW;

		data1.nSteepS = data1.nSteepMs;
		DrawSide3d(dc, ptEnd, ptSta, data1, data.dStairMW);
		DrawSteep3d(dc, ptEnd, ptSta, data1, data.dStairMW);
		if (data.bInsideRail)
		{
			DrawGuard(dc, ptEnd, ptSta, 0, data.dStairMW, data1);
			DrawGuard(dc, ptEnd, ptSta, 1, data.dStairMW, data1);
		}
		if (data.bOutSideRail)
		{
			DrawGuard(dc, ptEnd, ptSta, 1, data.dStairMW, data1);
		}

		ptGeL[0] = ptEnd;
		ptGeL[1] = ptSta;

		ptGeR[0] = ptEnd;
		ptGeR[1] = ptSta;

		ptSta -= Z * dCenter;
		ptEnd -= Z * dCenter;
		ptSta += vtSE * (data.dStairTW - data.dStairSW) * .5;
		ptEnd += vtSE * (data.dStairTW - data.dStairSW) * .5;
		ptSta += vtSEDir * data.dSteepW;
		ptEnd += vtSEDir * data.dSteepW;

		data1.nSteepS = data1.nSteepsS;
		DrawSide3d(dc, ptSta, ptEnd, data1, data.dStairSW);
		DrawSteep3d(dc, ptSta, ptEnd, data1, data.dStairSW);

		data1.nSteepS = data1.nSteepsS - 1;
		if (data.bInsideRail)
		{
			DrawGuard(dc, ptSta, ptEnd, 0, data.dStairSW, data1);
		}
		if (data.bOutSideRail)
		{
			DrawGuard(dc, ptSta, ptEnd, 1, data.dStairSW, data1);
		}

		ptGeL[2] = ptSta;
		ptGeL[3] = ptEnd;

		ptSta -= vtSE * (data.dStairTW - data.dStairSW);
		ptEnd -= vtSE * (data.dStairTW - data.dStairSW);

		data1.nSteepS = data1.nSteepsS;
		DrawSide3d(dc, ptSta, ptEnd, data1, data.dStairSW);
		DrawSteep3d(dc, ptSta, ptEnd, data1, data.dStairSW);

		data1.nSteepS = data1.nSteepsS - 1;
		if (data.bInsideRail)
		{
			DrawGuard(dc, ptSta, ptEnd, 1, data.dStairSW, data1);
		}
		if (data.bOutSideRail)
		{
			DrawGuard(dc, ptSta, ptEnd, 0, data.dStairSW, data1);
		}

		ptGeR[2] = ptSta;
		ptGeR[3] = ptEnd;

		DrawHandRail3d(dc, ptGeL, (data1.nSteepMs - data1.nSteepsS) * data1.dSteepW, vtSE, vtSEDir, 0, data1);
		DrawHandRail3d(dc, ptGeR, (data1.nSteepMs - data1.nSteepsS) * data1.dSteepW, vtSE, vtSEDir, 1, data1);
	}

	else if (data1.nSteepMs == data1.nSteepsS)
	{
		DrawAlignPlatSide(dc, ptSta, ptEnd, vtSE, vtSEDir, data);
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbParaLlelStairDraw::DrawRestPlatform(AcGiDraw& dc
	, const AcGePoint3d& ptFr
	, const AcGeVector3d& vtSE
	, const AcGeVector3d& vtSEDir
	, const SFSPStair& data) const
{
	AcGePoint3d ptSta(ptFr);
	SFSPStair data1(data);
	AcGeVector3d Z(AcGeVector3d::kZAxis);

	if (data1.nRestShape == 0)
	{
		DrawPlatform(dc, ptSta, data.dStairTW, data.dRestPtW, vtSE, vtSEDir, 0, data);
	}
	else if (data1.nRestShape == 1)
	{
		ptSta -= Z * data.dBomEl;
		DrawPlatform(dc, ptSta, data.dStairTW, data.dRestPtW, vtSE, vtSEDir, 1, data);
	}

	if (data1.nSteepMs > data1.nSteepsS && data1.nSteepAlign == 1)
	{
		ptSta -= vtSEDir * data1.dRestPtW;
		DrawPlatform(dc, ptSta, data.dStairSW, (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5, vtSE, vtSEDir, 0, data);

		ptSta -= vtSE * (data1.dStairTW - data1.dStairSW);
		DrawPlatform(dc, ptSta, data.dStairSW, (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5, vtSE, vtSEDir, 0, data);
	}

	else if (data1.nSteepMs < data1.nSteepsS && data1.nSteepAlign == 1)
	{
		ptSta -= vtSEDir * data1.dRestPtW;
		ptSta -= vtSE * (data1.dStairTW - data1.dStairMW) * .5;
		DrawPlatform(dc, ptSta, data.dStairMW, (data.nSteepsS - data.nSteepMs)* data.dSteepW * .5,  vtSE, vtSEDir, 0, data);
	}

	else if (data1.nSteepMs > data1.nSteepsS && data1.nSteepAlign == 2)
	{
		ptSta -= vtSEDir * data1.dRestPtW;
		DrawPlatform(dc, ptSta, data.dStairSW, (data.nSteepMs - data.nSteepsS) * data.dSteepW, vtSE, vtSEDir, 0, data);

		ptSta -= vtSE * (data1.dStairTW - data1.dStairSW);
		DrawPlatform(dc, ptSta, data.dStairSW, (data.nSteepMs - data.nSteepsS) * data.dSteepW, vtSE, vtSEDir, 0, data);
	}

	else if (data1.nSteepMs < data1.nSteepsS && data1.nSteepAlign == 2)
	{
		ptSta -= vtSEDir * data1.dRestPtW;
		ptSta -= vtSE * (data1.dStairTW - data1.dStairMW) * .5;
		DrawPlatform(dc, ptSta, data.dStairMW, (data.nSteepsS - data.nSteepMs) * data.dSteepW, vtSE, vtSEDir, 0, data);
	}

	return Acad::eOk;
}

//栏杆
Acad::ErrorStatus AecDbParaLlelStairDraw::DrawGuard(AcGiDraw& dc
	, const AcGePoint3d& ptFr
	, const AcGePoint3d& ptTo
	, const int& num
	, const double& dW
	, const SFSPStair& data) const
{
	AcDbEntity *pEntReal = GetAttach();
	if (pEntReal == NULL)	return Acad::eOk;

	AecDbBaseStair *pBaseStair = AecDbBaseStair::cast(pEntReal);
	if (pBaseStair == NULL)	return Acad::eOk;
	AcGePoint3d ptSta(ptFr), ptEnd(ptTo);
	AcGeVector3d vtL = (ptFr - ptTo).normalize();
	vtL.z = 0.0;

	AcGeVector3d vtLDir(vtL);
	vtLDir.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
	vtLDir.normalize();

	//一共多少步
	int nCount = data.nSteepS;

	AcGePoint3dArray arSecPts;
	double dSidet(120);

	if (data.nUpSide == 0)
	{
		ptSta += vtLDir * ((dW - data.dGarSize[0]) * .5 - data.dBarSide);
		ptSta -= vtLDir * ((dW - data.dGarSize[0]) * .5 - data.dBarSide) * 2 * num;
	}
	else
	{
		ptSta -= vtLDir * ((dW - data.dGarSize[0]) * .5 - data.dBarSide);
		ptSta += vtLDir * ((dW - data.dGarSize[0]) * .5 - data.dBarSide) * 2 * num;
	}

	//插入楼板的点 [AAA]
	ptSta.z -= (data.dSteepW - data.dSteepH);
	ptSta.z += data.dSteepW;//第一层等边直角

	arSecPts.removeAll();
	for (int i = 0; i < nCount; i++)
	{
		ptSta -= vtL * data.dSteepW * .5;
		arSecPts.append(ptSta);

		ptSta -= vtL * data.dSteepW * .5;
		ptSta.z += data.dSteepH;
	}

	AcDbX3dSolid xSolid;
	AcDbRegion *pReg(NULL);

	for (int i = 0; i < arSecPts.length(); i++)
	{
		if (!data.nBShape)
		{
			pReg = makeRectRegion(arSecPts.at(i), data.dBarSize[0], data.dBarSize[1], vtL, vtLDir);
		}
		else
		{
			pReg = makeCircleRegion(arSecPts.at(i), AcGeVector3d::kZAxis, data.dBarSize[0] * .5);
		}
		if (pReg == NULL) return Acad::eOk;
		AcDbLine line(arSecPts.at(i), arSecPts.at(i) + AcGeVector3d::kZAxis * data.dBarH);
		if (xSolid.CreateExtrude(pReg, line))
		{
			AcDb3dSolid *pSolid = xSolid.GetDraw3dSolid();
			if (pSolid == NULL) return Acad::eOk;
			dc.DrawEntity(pSolid);
			dc.Add3dBuffer(pSolid);
			add3DCache<AecDbParaLlelStair>(&xSolid);
		}
	}

	return Acad::eOk;
}

//扶手
AcDbLine* AecDbParaLlelStairDraw::DrawHandRail(AcGiDraw& dc
	, const AcGePoint3d& ptFr
	, const AcGePoint3d& ptTo
	, const int& num
	, const double& dW
	, const SFSPStair& data) const
{
	AcGePoint3d ptSta(ptFr);
	AcGeVector3d vtL = (ptFr - ptTo).normalize();
	vtL.z = 0.0;

	AcGeVector3d vtLDir(vtL);
	vtLDir.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
	vtLDir.normalize();

	//一共多少步
	int nCount = data.nSteepS;

	//踏步左右总长
	double dSteepL = (dW/* - 2.0 * data.dSidet*/);//无论左右有无梁

	AcGePoint3d ptV, ptV0;
	AcGePoint3dArray arSecPts;

	if (data.nUpSide == 0)
	{
		ptSta += vtLDir * ((dW - data.dGarSize[0]) * .5 - data.dBarSide);
		ptSta -= vtLDir * ((dW - data.dGarSize[0]) * .5 - data.dBarSide) * 2 * num;
	}
	else
	{
		ptSta -= vtLDir * ((dW - data.dGarSize[0]) * .5 - data.dBarSide);
		ptSta += vtLDir * ((dW - data.dGarSize[0]) * .5 - data.dBarSide) * 2 * num;
	}

	ptSta.z += (data.dBarH - data.dSteepH * .5);

	//插入楼板的点 [AAA]
	ptSta.z -= (data.dSteepW - data.dSteepH);
	ptV0 = ptSta;
	arSecPts.append(ptSta);

	ptSta.z += data.dSteepW;//第一层等边直角
	arSecPts.append(ptSta);

	for (int i = 0; i < nCount - 1; i++)
	{
		ptSta -= vtL * data.dSteepW;
		ptSta.z += data.dSteepH;

		if (i == (nCount - 2))//只需最后踏步上位点
			arSecPts.append(ptSta);
	}

	AcGeVector3d vtUp = arSecPts.last() - arSecPts.at(1);
	AcGeLine3d ln3d;
	ln3d.set(ptV0, vtUp);

	AcGePoint3d ptV1 = ptSta - vtL * data.dSteepW;
	arSecPts.append(ptV1);

	AcGeLine3d lnEnd;
	lnEnd.set(ptV1, AcGeVector3d::kZAxis);

	AcGePoint3d ptInt;
	if (ln3d.intersectWith(lnEnd, ptInt))
	{
		arSecPts.append(ptInt);

		AcGePoint3d ptGe[4];
		ptGe[0] = arSecPts.at(0);
		ptGe[1] = arSecPts.at(1);

		vtUp = ptGe[1] - ptGe[0];
		ptGe[2] = ptInt + vtUp;
		ptGe[3] = ptInt;

		AcDbLine *pLine = new AcDbLine(ptGe[1], ptGe[2]);
		return pLine;
	}

	return NULL;
}

Acad::ErrorStatus AecDbParaLlelStairDraw::DrawHandRailPath3d(AcGiDraw& dc
	, const AcGePoint3dArray& arPts
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const SFSPStair& data) const
{
	AcDbRegion* pReg(NULL);
	AcGeVector3d vec = (arPts.at(0) - arPts.at(1)).normalize();
	if (!data.nBShape)
	{
		vec.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
		vec.normalize();
		pReg = makeRectRegion(arPts.at(0), data.dGarSize[0], data.dGarSize[1], vec, AcGeVector3d::kZAxis);
	}
	else
	{
		pReg = makeCircleRegion(arPts.at(0), vec, data.dGarSize[0] * .5);
	}
	if (pReg == NULL) return Acad::eOk;
	AcDbPolyline* pPoly = (AcDbPolyline*)Format3dPolyline(arPts);
	AcDbX3dSolid xSolid;
	if (xSolid.CreateSweep(pReg, pPoly))
	{
		AcDb3dSolid* pSolid = xSolid.GetDraw3dSolid();
		if (pSolid == NULL) return Acad::eOk;
		dc.DrawEntity(pSolid);
		dc.Add3dBuffer(pSolid);
		add3DCache<AecDbParaLlelStair>(&xSolid);
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbParaLlelStairDraw::DrawHandRail3d(AcGiDraw& dc
	, const AcGePoint3d* ptAr
	, const double& dRestL
	, const AcGeVector3d& vt
	, const AcGeVector3d& vtDir
	, const int& num
	, const SFSPStair& data) const
{
	AcGePoint3d ptS, ptE, pt;
	SFSPStair data1(data);
	AcDbLine* pLine1(NULL);
	AcGePoint3dArray ptGeIn, ptGeOut;

	AcGeVector3d vtM, vtS;
	double dTanAngle = data.dSteepH / data.dSteepW;
	double dOutStr = sqrt(data.dSteepH * data.dSteepH + data.dSteepW * data.dSteepW);
	double dSinAngle = data.dSteepH / dOutStr;
	double dCosAngle = data.dSteepW / dOutStr;

	AcGePoint3d ptGe[4];
	AcDbLine* pLineM(NULL), * pLineS(NULL);

	if (data.nSteepMs > data.nSteepsS)
	{
		if (data.nSteepAlign == 1)
		{
			ptGe[2] = ptGe[2] - vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
			ptGe[3] = ptGe[3] - vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
		}
		else if (data.nSteepAlign == 2)
		{
			ptGe[2] = ptGe[2] - vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
			ptGe[3] = ptGe[3] - vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
		}
		else
		{
			ptGe[2] = ptGe[2];
			ptGe[3] = ptGe[3];
		}

		/*ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[0] * .5) * 2 + data.dStairTW - data.dStairSW * 2);
		ptGe[3] = ptGe[3] + vt * ((data.dBarSide + data.dGarSize[0] * .5) * 2 + data.dStairTW - data.dStairSW * 2);*/
	}
	else if (data.nSteepMs < data.nSteepsS)
	{
		ptGe[0] = ptGe[0];
		ptGe[1] = ptGe[1];

		/*ptGe[0] = ptGe[0] + vt * ((data.dBarSide + data.dGarSize[0] * .5) * 2 + data.dStairTW - data.dStairSW * 2);
		ptGe[1] = ptGe[1] + vt * ((data.dBarSide + data.dGarSize[0] * .5) * 2 + data.dStairTW - data.dStairSW * 2);*/
		if (data.nSteepAlign == 1)
		{
			ptGe[0] -= vtDir * (data.nSteepsS - data.nSteep2s) * data.dSteepW * .5;
			ptGe[1] -= vtDir * (data.nSteepsS - data.nSteep2s) * data.dSteepW * .5;
		}
		else if (data.nSteepAlign == 2)
		{
			ptGe[0] -= vtDir * (data.nSteepsS - data.nSteep2s) * data.dSteepW;
			ptGe[1] -= vtDir * (data.nSteepsS - data.nSteep2s) * data.dSteepW;
		}
	}

	if (data1.nSteepMs == data1.nSteepsS)
	{
		if (data.nUpSide == 0)
		{
			data1.nSteepS = data1.nSteepMs - 1;
			pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], num, data1.dStairMW, data1);
			pLine1->getStartPoint(ptS);
			pLine1->getEndPoint(ptE);
			ptGeIn.removeAll();
			ptGeIn.append(ptS);
			ptGeIn.append(ptE);

			data1.nSteepS = data1.nSteepsS;
			pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], num, data1.dStairSW, data1);
			pLine1->getStartPoint(ptS);
			pLine1->getEndPoint(ptE);
			ptGeIn.append(ptS);
			ptGeIn.append(ptE);

			ptGe[0] = ptGeIn[0];
			ptGe[1] = ptGeIn[1];
			ptGe[2] = ptGeIn[2];
			ptGe[3] = ptGeIn[3];

			ptS = ptGeIn[3] - vtDir * data1.dZGarExt;
			ptGeIn.append(ptS);

			pLineM = new AcDbLine(ptGe[0], ptGe[1]);

			if (num == 0)
			{
				ptGe[2] = ptGe[2] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
				ptGe[3] = ptGe[3] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
				pLineS = new AcDbLine(ptGe[2], ptGe[3]);

				double dLXY(.0), dLX(.0);
				AcGePoint3dArray pts;
				pts.removeAll();
				pLineM->intersectWith(pLineS, AcDb::kExtendBoth, pts);
				if (pts.length() == 1)
				{
					dLXY = ptGe[1].distanceTo(pts.first());
					dLX = dLXY * dCosAngle;
				}

				if (data.dGarExt <= dLX)
				{
					vtM = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vtM * data.dGarExt / dCosAngle;
					ptGeIn.insertAt(2, pt);
				}
				else
				{
					vtM = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vtM * dLXY;
					ptGeIn.insertAt(2, pt);

					if ((data.dGarExt - dLX) < data.dGarSize[0] * .5)
					{
						pt += vtDir * data.dGarSize[0] * .5;
						ptGeIn.insertAt(3, pt);
					}
					else
					{
						pt += vtDir * (data.dGarExt - dLX);
						ptGeIn.insertAt(3, pt);
					}

					pt += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
					ptGeIn.insertAt(4, pt);
				}
			}
			else
			{
				ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
				ptGe[3] = ptGe[3] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
				pLineS = new AcDbLine(ptGe[2], ptGe[3]);

				double dLXY(.0), dLX(.0);
				AcGePoint3dArray pts;
				pts.removeAll();
				pLineM->intersectWith(pLineS, AcDb::kExtendBoth, pts);
				if (pts.length() == 1)
				{
					dLXY = ptGe[1].distanceTo(pts.first());
					dLX = dLXY * dCosAngle;
				}

				if (data.dGarExt <= dLX)
				{
					vtM = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vtM * data.dGarExt / dCosAngle;
					ptGeIn.insertAt(2, pt);
				}
				else
				{
					vtM = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vtM * dLXY;
					ptGeIn.insertAt(2, pt);

					if ((data.dGarExt - dLX) < data.dGarSize[0] * .5)
					{
						pt += vtDir * data.dGarSize[0] * .5;
						ptGeIn.insertAt(3, pt);
					}
					else
					{
						pt += vtDir * (data.dGarExt - dLX);
						ptGeIn.insertAt(3, pt);
					}
					pt -= vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
					ptGeIn.insertAt(4, pt);
				}
			}

			// 层间伸出
			if (UP_ZERO(data1.dZGarExt))
			{
				ptS = ptGeIn.at(0) - vtDir * data1.dZGarExt;
				ptGeIn.insertAt(0, ptS);

				if (num == 0)
				{
					ptS += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
					ptGeIn.insertAt(0, ptS);
				}
				else
				{
					ptS -= vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
					ptGeIn.insertAt(0, ptS);
				}
			}
			DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);

			if (data1.bOutSideHRail)
			{
				data1.nSteepS = data1.nSteepsS;
				pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], !num, data1.dStairSW, data1);
				pLine1->getStartPoint(ptS);
				pLine1->getEndPoint(ptE);
				ptGeIn.removeAll();
				ptGeIn.append(ptE);
				ptGeIn.append(ptS);

				// 层间伸出
				if (UP_ZERO(data1.dZGarExt))
				{
					ptS = ptGeIn.at(0) - vtDir * data.dZGarExt;
					ptGeIn.insertAt(0, ptS);
				}
				//转角伸出
				if (UP_ZERO(data1.dGarExt))
				{
					ptE = ptGeIn.at(2) + vtDir * data.dGarExt;
					ptGeIn.append(ptE);
				}

				DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
			}
		}
		else
		{
			data1.nSteepS = data1.nSteepMs;
			pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], num, data1.dStairMW, data1);
			pLine1->getStartPoint(ptS);
			pLine1->getEndPoint(ptE);
			ptGeIn.removeAll();
			ptGeIn.append(ptE);
			ptGeIn.append(ptS);

			data1.nSteepS = data1.nSteepsS - 1;
			pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], num, data1.dStairSW, data1);
			pLine1->getStartPoint(ptS);
			pLine1->getEndPoint(ptE);
			ptGeIn.append(ptE);
			ptGeIn.append(ptS);

			ptGe[0] = ptGeIn[0];
			ptGe[1] = ptGeIn[1];
			ptGe[2] = ptGeIn[2];
			ptGe[3] = ptGeIn[3];

			ptS = ptGeIn[3] - vtDir * data1.dZGarExt;
			ptGeIn.append(ptS);

			if (num == 0)
			{
				ptS -= vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
				ptGeIn.append(ptS);
			}
			else
			{
				ptS += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
				ptGeIn.append(ptS);
			}

			pLineM = new AcDbLine(ptGe[0], ptGe[1]);

			if (num == 0)
			{
				ptGe[2] = ptGe[2] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
				ptGe[3] = ptGe[3] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
				pLineS = new AcDbLine(ptGe[2], ptGe[3]);

				double dLXY(.0), dLX(.0);
				AcGePoint3dArray pts;
				pts.removeAll();
				pLineM->intersectWith(pLineS, AcDb::kExtendBoth, pts);
				if (pts.length() == 1)
				{
					dLXY = ptGe[1].distanceTo(pts.first());
					dLX = dLXY * dCosAngle;
				}

				if (data.dGarExt <= dLX)
				{
					vtM = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vtM * data.dGarExt / dCosAngle;
					ptGeIn.insertAt(2, pt);
				}
				else
				{
					vtM = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vtM * dLXY;
					ptGeIn.insertAt(2, pt);

					if ((data.dGarExt - dLX) < data.dGarSize[0] * .5)
					{
						pt += vtDir * data.dGarSize[0] * .5;
						ptGeIn.insertAt(3, pt);
					}
					else
					{
						pt += vtDir * (data.dGarExt - dLX);
						ptGeIn.insertAt(3, pt);
					}

					/*pt += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
					ptGeIn.insertAt(4, pt);*/
				}
			}
			else
			{
				ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
				ptGe[3] = ptGe[3] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
				pLineS = new AcDbLine(ptGe[2], ptGe[3]);

				double dLXY(.0), dLX(.0);
				AcGePoint3dArray pts;
				pts.removeAll();
				pLineM->intersectWith(pLineS, AcDb::kExtendBoth, pts);
				if (pts.length() == 1)
				{
					dLXY = ptGe[1].distanceTo(pts.first());
					dLX = dLXY * dCosAngle;
				}

				if (data.dGarExt <= dLX)
				{
					vtM = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vtM * data.dGarExt / dCosAngle;
					ptGeIn.insertAt(2, pt);
				}
				else
				{
					vtM = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vtM * dLXY;
					ptGeIn.insertAt(2, pt);

					if ((data.dGarExt - dLX) < data.dGarSize[0] * .5)
					{
						pt += vtDir * data.dGarSize[0] * .5;
						ptGeIn.insertAt(3, pt);
					}
					else
					{
						pt += vtDir * (data.dGarExt - dLX);
						ptGeIn.insertAt(3, pt);
					}
					/*pt -= vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
					ptGeIn.insertAt(4, pt);*/
				}
			}

			// 层间伸出
			if (UP_ZERO(data1.dZGarExt))
			{
				ptS = ptGeIn.at(0) - vtDir * data1.dZGarExt;
				ptGeIn.insertAt(0, ptS);
			}
			DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);

			if (data1.bOutSideHRail)
			{
				data1.nSteepS = data1.nSteepsS - 1;
				pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], !num, data1.dStairSW, data1);
				pLine1->getStartPoint(ptS);
				pLine1->getEndPoint(ptE);
				ptGeIn.removeAll();
				ptGeIn.append(ptE);
				ptGeIn.append(ptS);

				//转角伸出
				if (UP_ZERO(data1.dGarExt))
				{
					ptS = ptGeIn.at(0) + vtDir * data.dGarExt;
					ptGeIn.insertAt(0, ptS);
				}
				// 层间伸出
				if (UP_ZERO(data1.dZGarExt))
				{
					ptE = ptGeIn.at(2) - vtDir * data.dZGarExt;
					ptGeIn.append(ptE);
				}

				DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
			}
		}
	}

	else if (data1.nSteepMs > data1.nSteepsS)
	{
		if (data1.nUpSide == 0)
		{
			data1.nSteepS = data1.nSteepMs - 1;
			pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], num, data1.dStairMW, data1);
			pLine1->getStartPoint(ptS);
			pLine1->getEndPoint(ptE);
			ptGeIn.removeAll();
			ptGeIn.append(ptS);
			ptGeIn.append(ptE);

			data1.nSteepS = data1.nSteepsS;
			pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], num, data1.dStairSW, data1);
			pLine1->getStartPoint(ptS);
			pLine1->getEndPoint(ptE);
			ptGeIn.append(ptS);
			ptGeIn.append(ptE);

			ptGe[0] = ptGeIn[0];
			ptGe[1] = ptGeIn[1];
			ptGe[2] = ptGeIn[2];
			ptGe[3] = ptGeIn[3];

			ptS = ptGeIn[3] - vtDir * data1.dZGarExt;
			ptGeIn.append(ptS);

			pLineM = new AcDbLine(ptGe[0], ptGe[1]);

			if (num == 0)
			{
				ptGe[2] = ptGe[2] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
				ptGe[3] = ptGe[3] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
				pLineS = new AcDbLine(ptGe[2], ptGe[3]);

				double dLXY(.0), dLX(.0);
				AcGePoint3dArray pts;
				pts.removeAll();
				pLineM->intersectWith(pLineS, AcDb::kExtendBoth, pts);
				if (pts.length() == 1)
				{
					dLXY = ptGe[1].distanceTo(pts.first());
					dLX = dLXY * dCosAngle;
				}

				if (data.dGarExt <= dLX)
				{
					vtM = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vtM * data.dGarExt / dCosAngle;
					ptGeIn.insertAt(2, pt);

					pt += vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
					ptGeIn.insertAt(3, pt);

					ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
					if (data.nSteepAlign == 0 || data.nSteepAlign == 3)
					{
						/*pt = ptGe[2] + vtDir * data.dZGarExt;
						ptGeIn.insertAt(4, pt);*/
					}
					
					else if (data.nSteepAlign == 1)
					{
						pt = ptGe[2] + vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
						ptGeIn.insertAt(4, pt);
					}
					else if (data.nSteepAlign == 2)
					{
						pt = ptGe[2] + vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
						ptGeIn.insertAt(4, pt);
					}

				}
				else
				{
					vtM = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vtM * dLXY;
					ptGeIn.insertAt(2, pt);

					if ((data.dGarExt - dLX) < data.dGarSize[0] * .5)
					{
						pt += vtDir * data.dGarSize[0] * .5;
						ptGeIn.insertAt(3, pt);

						pt += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
						ptGeIn.insertAt(4, pt);

						if (data.nSteepAlign == 0 || data.nSteepAlign == 3)
						{
							pt -= vtDir * (data.dGarExt - dLX);
							ptGeIn.insertAt(5, pt);
						}

						else if (data.nSteepAlign == 1)
						{
							ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);

							/*pt = ptGe[2] + vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
							ptGeIn.insertAt(5, pt);*/

							pt -= vtDir * (data.dGarExt - dLX + (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5);
							ptGeIn.insertAt(5, pt);
						}
						else if (data.nSteepAlign == 2)
						{
							/*ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);

							pt = ptGe[2] + vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
							ptGeIn.insertAt(5, pt);*/

							pt -= vtDir * (data.dGarExt - dLX + (data.nSteepMs - data.nSteepsS) * data.dSteepW);
							ptGeIn.insertAt(5, pt);
						}
					}
					else
					{
						pt += vtDir * (data.dGarExt - dLX);
						ptGeIn.insertAt(3, pt);

						pt += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
						ptGeIn.insertAt(4, pt);

					}

				}
			}
			else
			{
				ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
				ptGe[3] = ptGe[3] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
				pLineS = new AcDbLine(ptGe[2], ptGe[3]);

				double dLXY(.0), dLX(.0);
				AcGePoint3dArray pts;
				pts.removeAll();
				pLineM->intersectWith(pLineS, AcDb::kExtendBoth, pts);
				if (pts.length() == 1)
				{
					dLXY = ptGe[1].distanceTo(pts.first());
					dLX = dLXY * dCosAngle;
				}

				if (data.dGarExt <= dLX)
				{
					vtM = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vtM * data.dGarExt / dCosAngle;
					ptGeIn.insertAt(2, pt);

					pt -= vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
					ptGeIn.insertAt(3, pt);

					ptGe[2] = ptGe[2] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
					if (data.nSteepAlign == 0)
					{
						/*pt = ptGe[2] + vtDir * data.dZGarExt;
						ptGeIn.insertAt(4, pt);*/
					}

					else if (data.nSteepAlign == 1)
					{
						pt = ptGe[2] + vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
						ptGeIn.insertAt(4, pt);
					}
					else if (data.nSteepAlign == 2)
					{
						pt = ptGe[2] + vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
						ptGeIn.insertAt(4, pt);
					}
				}
				else
				{
					vtM = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vtM * dLXY;
					ptGeIn.insertAt(2, pt);

					if ((data.dGarExt - dLX) < data.dGarSize[0] * .5)
					{
						pt += vtDir * data.dGarSize[0] * .5;
						ptGeIn.insertAt(3, pt);
					}
					else
					{
						pt += vtDir * (data.dGarExt - dLX);
						ptGeIn.insertAt(3, pt);
					}

					pt -= vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
					ptGeIn.insertAt(4, pt);

					if (data.nSteepAlign == 0 || data.nSteepAlign == 3)
					{
						pt -= vtDir * (data.dGarExt - dLX);
						ptGeIn.insertAt(5, pt);
					}
					else if (data.nSteepAlign == 1)
					{
						ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);

						pt = ptGe[2] + vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
						ptGeIn.insertAt(5, pt);
					}
					else if (data.nSteepAlign == 2)
					{
						ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);

						pt = ptGe[2] + vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
						ptGeIn.insertAt(5, pt);
					}
				}
				
			}

			// 层间伸出
			if (UP_ZERO(data1.dZGarExt))
			{
				ptS = ptGeIn.at(0) - vtDir * data1.dZGarExt;
				ptGeIn.insertAt(0, ptS);

				if (data1.nUpSide == 0)
				{
					if (num == 0)
					{
						ptS += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
						ptGeIn.insertAt(0, ptS);
					}
					else
					{
						ptS -= vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
						ptGeIn.insertAt(0, ptS);
					}
				}

			}
			DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);

			if (data1.bOutSideHRail)
			{
				data1.nSteepS = data1.nSteepsS;
				pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], !num, data1.dStairSW, data1);
				pLine1->getStartPoint(ptS);
				pLine1->getEndPoint(ptE);
				ptGeIn.removeAll();
				ptGeIn.append(ptS);
				ptGeIn.append(ptE);

				// 转角伸出
				if (UP_ZERO(data1.dGarExt))
				{
					if (data1.nUpSide == 0)
					{
						if (data1.nSteepAlign == 0 || data1.nSteepAlign == 3)
						{
							ptS = ptGeIn.at(0) + vtDir * data.dGarExt;
							ptGeIn.insertAt(0, ptS);
						}
						else if (data1.nSteepAlign == 1)
						{
							ptS = ptGeIn.at(0) + vtDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW * .5 + data.dGarExt);
							ptGeIn.insertAt(0, ptS);
						}
						else if (data1.nSteepAlign == 2)
						{
							ptS = ptGeIn.at(0) + vtDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW + data.dGarExt);
							ptGeIn.insertAt(0, ptS);
						}
					}
					else
					{
						if (data1.nSteepAlign == 0 || data1.nSteepAlign == 3)
						{
							ptS = ptGeIn.at(1) + vtDir * data.dGarExt;
							ptGeIn.append(ptS);
						}
						else if (data1.nSteepAlign == 1)
						{
							ptS = ptGeIn.at(1) + vtDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW * .5 + data.dGarExt);
							ptGeIn.append(ptS);
						}
						else if (data1.nSteepAlign == 2)
						{
							ptS = ptGeIn.at(1) + vtDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW + data.dGarExt);
							ptGeIn.append(ptS);
						}
					}
				}
				// 层间伸出
				if (UP_ZERO(data1.dZGarExt))
				{
					if (data1.nUpSide == 0)
					{
						ptS = ptGeIn.at(2) - vtDir * data.dZGarExt;
						ptGeIn.append(ptS);
					}
					else
					{
						ptE = ptGeIn.at(0) - vtDir * data.dZGarExt;
						ptGeIn.insertAt(0, ptE);
					}
				}
				DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
			}
		}
		else
		{
			data1.nSteepS = data1.nSteepMs;
			pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], num, data1.dStairMW, data1);
			pLine1->getStartPoint(ptS);
			pLine1->getEndPoint(ptE);
			ptGeIn.append(ptE);
			ptGeIn.append(ptS);

			data1.nSteepS = data1.nSteepsS - 1;
			pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], num, data1.dStairSW, data1);
			pLine1->getStartPoint(ptS);
			pLine1->getEndPoint(ptE);
			ptGeIn.append(ptE);
			ptGeIn.append(ptS);

			ptGe[0] = ptGeIn[0];
			ptGe[1] = ptGeIn[1];
			ptGe[2] = ptGeIn[2];
			ptGe[3] = ptGeIn[3];

			ptS = ptGeIn[3] - vtDir * data1.dZGarExt;
			ptGeIn.append(ptS);

			if (num == 0)
			{
				ptS -= vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
				ptGeIn.append(ptS);
			}
			else
			{
				ptS += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
				ptGeIn.append(ptS);
			}

			pLineM = new AcDbLine(ptGe[0], ptGe[1]);

			if (num == 0)
			{
				ptGe[2] = ptGe[2] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
				ptGe[3] = ptGe[3] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
				pLineS = new AcDbLine(ptGe[2], ptGe[3]);

				double dLXY(.0), dLX(.0);
				AcGePoint3dArray pts;
				pts.removeAll();
				pLineM->intersectWith(pLineS, AcDb::kExtendBoth, pts);
				if (pts.length() == 1)
				{
					dLXY = ptGe[1].distanceTo(pts.first());
					dLX = dLXY * dCosAngle;
				}

				if (data.dGarExt <= dLX)
				{
					vtM = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vtM * data.dGarExt / dCosAngle;
					ptGeIn.insertAt(2, pt);

					ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
					ptGe[3] = ptGe[3] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);

					if (data.nSteepAlign == 1)
					{
						/*pt -= vtDir * (data.dGarExt - dLX);
						ptGeIn.insertAt(3, pt);*/

						pt += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
						ptGeIn.insertAt(3, pt);

						/*pt -= vtDir * (data.dGarExt - dLX + (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5);
						ptGeIn.insertAt(4, pt);*/
					/*	AcDbLine* pLine = new AcDbLine(pt, pt - vtDir * data.dStairMW);
						pLine->setColorIndex(10);
						CoreTools::AddToModelSpace(pLine);*/

						/*pt -= vtDir * (data.dGarExt - dLX + (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5);
						ptGeIn.insertAt(5, pt);*/
					}
				}
				else
				{
					vtM = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vtM * dLXY;
					ptGeIn.insertAt(2, pt);

					if ((data.dGarExt - dLX) < data.dGarSize[0] * .5)
					{
						pt += vtDir * data.dGarSize[0] * .5;
						ptGeIn.insertAt(3, pt);

						pt += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
						ptGeIn.insertAt(4, pt);

					}
					else
					{
						pt += vtDir * (data.dGarExt - dLX);
						ptGeIn.insertAt(3, pt);

						pt += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
						ptGeIn.insertAt(4, pt);
					}

					if (data.nSteepAlign == 0 || data.nSteepAlign == 3)
					{
						pt -= vtDir * (data.dGarExt - dLX);
						ptGeIn.insertAt(5, pt);
					}
					///*pt += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
					//ptGeIn.insertAt(4, pt);*/
					// 
					//else

					//else if (data.nSteepAlign == 2)
					//{
					//	pt -= vtDir * (data.dGarExt - dLX + (data.nSteepMs - data.nSteepsS) * data.dSteepW);
					//	ptGeIn.insertAt(5, pt);
					//}
				}
			}
			else
			{
				ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
				ptGe[3] = ptGe[3] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
				pLineS = new AcDbLine(ptGe[2], ptGe[3]);

				double dLXY(.0), dLX(.0);
				AcGePoint3dArray pts;
				pts.removeAll();
				pLineM->intersectWith(pLineS, AcDb::kExtendBoth, pts);
				if (pts.length() == 1)
				{
					dLXY = ptGe[1].distanceTo(pts.first());
					dLX = dLXY * dCosAngle;
				}

				if (data.dGarExt <= dLX)
				{
					vtM = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vtM * data.dGarExt / dCosAngle;
					ptGeIn.insertAt(2, pt);
				}
				else
				{
					vtM = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vtM * dLXY;
					ptGeIn.insertAt(2, pt);

					if ((data.dGarExt - dLX) < data.dGarSize[0] * .5)
					{
						pt += vtDir * data.dGarSize[0] * .5;
						ptGeIn.insertAt(3, pt);
					}
					else
					{
						pt += vtDir * (data.dGarExt - dLX);
						ptGeIn.insertAt(3, pt);

						pt -= vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
						ptGeIn.insertAt(4, pt);
					}
				}
			}

			DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);

			// 层间伸出
			if (UP_ZERO(data1.dZGarExt))
			{
				ptS = ptGeIn.at(0) - vtDir * data1.dZGarExt;
				ptGeIn.insertAt(0, ptS);

				if (data1.nUpSide == 0)
				{
					if (num == 0)
					{
						ptS += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
						ptGeIn.insertAt(0, ptS);
					}
					else
					{
						ptS -= vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
						ptGeIn.insertAt(0, ptS);
					}
				}

			}
			DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);

			if (data1.bOutSideHRail)
			{
				data1.nSteepS = data1.nSteepsS - 1;
				pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], !num, data1.dStairSW, data1);
				pLine1->getStartPoint(ptS);
				pLine1->getEndPoint(ptE);
				ptGeIn.removeAll();
				ptGeIn.append(ptS);
				ptGeIn.append(ptE);

				// 转角伸出
				if (UP_ZERO(data1.dGarExt))
				{
					if (data1.nUpSide == 0)
					{
						if (data1.nSteepAlign == 0 || data1.nSteepAlign == 3)
						{
							ptS = ptGeIn.at(0) + vtDir * data.dGarExt;
							ptGeIn.insertAt(0, ptS);
						}
						else if (data1.nSteepAlign == 1)
						{
							ptS = ptGeIn.at(0) + vtDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW * .5 + data.dGarExt);
							ptGeIn.insertAt(0, ptS);
						}
						else if (data1.nSteepAlign == 2)
						{
							ptS = ptGeIn.at(0) + vtDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW + data.dGarExt);
							ptGeIn.insertAt(0, ptS);
						}
					}
					else
					{
						if (data1.nSteepAlign == 0 || data1.nSteepAlign == 3)
						{
							ptS = ptGeIn.at(1) + vtDir * data.dGarExt;
							ptGeIn.append(ptS);
						}
						else if (data1.nSteepAlign == 1)
						{
							ptS = ptGeIn.at(1) + vtDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW * .5 + data.dGarExt);
							ptGeIn.append(ptS);
						}
						else if (data1.nSteepAlign == 2)
						{
							ptS = ptGeIn.at(1) + vtDir * ((data1.nSteepMs - data1.nSteepsS) * data1.dSteepW + data.dGarExt);
							ptGeIn.append(ptS);
						}
					}
				}
				// 层间伸出
				if (UP_ZERO(data1.dZGarExt))
				{
					if (data1.nUpSide == 0)
					{
						ptS = ptGeIn.at(2) - vtDir * data.dZGarExt;
						ptGeIn.append(ptS);
					}
					else
					{
						ptE = ptGeIn.at(0) - vtDir * data.dZGarExt;
						ptGeIn.insertAt(0, ptE);
					}
				}
				DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
			}
		}	
	}

	else if (data1.nSteepMs < data1.nSteepsS)
	{
		if (data1.nUpSide == 0)
		{
			data1.nSteepS = data1.nSteepMs - 1;
			pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], num, data1.dStairMW, data1);
			pLine1->getStartPoint(ptS);
			pLine1->getEndPoint(ptE);
			ptGeIn.removeAll();
			ptGeIn.append(ptS);
			ptGeIn.append(ptE);

			data1.nSteepS = data1.nSteepsS;
			pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], num, data1.dStairSW, data1);
			pLine1->getStartPoint(ptS);
			pLine1->getEndPoint(ptE);
			ptGeIn.append(ptS);
			ptGeIn.append(ptE);

			ptGe[0] = ptGeIn[0];
			ptGe[1] = ptGeIn[1];
			ptGe[2] = ptGeIn[2];
			ptGe[3] = ptGeIn[3];

			ptS = ptGeIn[3] - vtDir * data1.dZGarExt;
			ptGeIn.append(ptS);

			pLineM = new AcDbLine(ptGe[0], ptGe[1]);

			if (num == 0)
			{
				ptGe[2] = ptGe[2] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
				ptGe[3] = ptGe[3] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
				pLineS = new AcDbLine(ptGe[2], ptGe[3]);

				double dLXY(.0), dLX(.0);
				AcGePoint3dArray pts;
				pts.removeAll();
				pLineM->intersectWith(pLineS, AcDb::kExtendBoth, pts);
				if (pts.length() == 1)
				{
					dLXY = ptGe[1].distanceTo(pts.first());
					dLX = dLXY * dCosAngle;
				}

				if (data.dGarExt <= dLX)
				{
					vtM = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vtM * data.dGarExt / dCosAngle;
					ptGeIn.insertAt(2, pt);

					ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
					ptGe[3] = ptGe[3] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);

					if (data.nSteepAlign == 1)
					{
						pt = ptGe[1] - vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
						ptGeIn.insertAt(3, pt);

						pt += vt * data.dGarExt;
						ptGeIn.insertAt(4, pt);

						pt += vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
						ptGeIn.insertAt(5, pt);
					}
					else if (data.nSteepAlign == 2)
					{
						pt = ptGe[1] - vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
						ptGeIn.insertAt(3, pt);

						pt += vt * data.dGarExt;
						ptGeIn.insertAt(4, pt);

						pt += vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
						ptGeIn.insertAt(5, pt);
					}
				}
				else
				{
					vtM = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vtM * dLXY;
					ptGeIn.insertAt(2, pt);

					if ((data.dGarExt - dLX) < data.dGarSize[0] * .5)
					{
						pt += vtDir * data.dGarSize[0] * .5;
						ptGeIn.insertAt(3, pt);
					}
					else
					{
						pt += vtDir * (data.dGarExt - dLX);
						ptGeIn.insertAt(3, pt);
					}

					pt += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
					ptGeIn.insertAt(4, pt);

				}
			}
			else
			{
				ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
				ptGe[3] = ptGe[3] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
				pLineS = new AcDbLine(ptGe[2], ptGe[3]);

				double dLXY(.0), dLX(.0);
				AcGePoint3dArray pts;
				pts.removeAll();
				pLineM->intersectWith(pLineS, AcDb::kExtendBoth, pts);
				if (pts.length() == 1)
				{
					dLXY = ptGe[1].distanceTo(pts.first());
					dLX = dLXY * dCosAngle;
				}

				if (data.dGarExt <= dLX)
				{
					vtM = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vtM * data.dGarExt / dCosAngle;
					ptGeIn.insertAt(2, pt);

					ptGe[2] = ptGe[2] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
					ptGe[3] = ptGe[3] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);

					if (data.nSteepAlign == 1)
					{
						pt = ptGe[1] - vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW * .5;
						ptGeIn.insertAt(3, pt);

						pt -= vt * data.dGarExt;
						ptGeIn.insertAt(4, pt);

						pt -= vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
						ptGeIn.insertAt(5, pt);
					}
					else if (data.nSteepAlign == 2)
					{
						pt = ptGe[1] - vtDir * (data.nSteepMs - data.nSteepsS) * data.dSteepW;
						ptGeIn.insertAt(3, pt);

						pt -= vt * data.dGarExt;
						ptGeIn.insertAt(4, pt);

						pt -= vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
						ptGeIn.insertAt(5, pt);
					}
				}
				else
				{
					vtM = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vtM * dLXY;
					ptGeIn.insertAt(2, pt);

					if ((data.dGarExt - dLX) < data.dGarSize[0] * .5)
					{
						pt += vtDir * data.dGarSize[0] * .5;
						ptGeIn.insertAt(3, pt);
					}
					else
					{
						pt += vtDir * (data.dGarExt - dLX);
						ptGeIn.insertAt(3, pt);
					}
				}
			}
		
			DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);

			// 层间伸出
			if (UP_ZERO(data1.dZGarExt))
			{
				ptS = ptGeIn.at(0) - vtDir * data1.dZGarExt;
				ptGeIn.insertAt(0, ptS);

				if (num == 0)
				{
					ptS += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
					ptGeIn.insertAt(0, ptS);
				}
				else
				{
					ptS -= vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
					ptGeIn.insertAt(0, ptS);
				}
				DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
			}

			if (data1.bOutSideHRail)
			{
				data1.nSteepS = data1.nSteepsS;
				pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], !num, data1.dStairSW, data1);
				pLine1->getStartPoint(ptS);
				pLine1->getEndPoint(ptE);
				ptGeIn.removeAll();
				ptGeIn.append(ptS);
				ptGeIn.append(ptE);
				// 转角伸出
				if (UP_ZERO(data1.dGarExt))
				{
					ptS = ptGeIn.at(0) + vtDir * data.dGarExt;
					ptGeIn.insertAt(0, ptS);
				}
				// 层间伸出
				if (UP_ZERO(data1.dZGarExt))
				{
					ptE = ptGeIn.at(2) - vtDir * data.dZGarExt;
					ptGeIn.append(ptE);
				}
				DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
			}
		}
		else
		{
			data1.nSteepS = data1.nSteepMs;
			pLine1 = DrawHandRail(dc, ptAr[0], ptAr[1], num, data1.dStairMW, data1);
			pLine1->getStartPoint(ptS);
			pLine1->getEndPoint(ptE);
			ptGeIn.removeAll();
			ptGeIn.append(ptE);
			ptGeIn.append(ptS);

			data1.nSteepS = data1.nSteepsS - 1;
			pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], num, data1.dStairSW, data1);
			pLine1->getStartPoint(ptS);
			pLine1->getEndPoint(ptE);
			ptGeIn.append(ptE);
			ptGeIn.append(ptS);

			ptGe[0] = ptGeIn[0];
			ptGe[1] = ptGeIn[1];
			ptGe[2] = ptGeIn[2];
			ptGe[3] = ptGeIn[3];

			ptS = ptGeIn[3] - vtDir * data1.dZGarExt;
			ptGeIn.append(ptS);

			if (num == 0)
			{
				ptS -= vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
				ptGeIn.append(ptS);
			}
			else
			{
				ptS += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
				ptGeIn.append(ptS);
			}

			pLineM = new AcDbLine(ptGe[0], ptGe[1]);

			if (num == 0)
			{
				ptGe[2] = ptGe[2] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
				ptGe[3] = ptGe[3] - vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
				pLineS = new AcDbLine(ptGe[2], ptGe[3]);

				double dLXY(.0), dLX(.0);
				AcGePoint3dArray pts;
				pts.removeAll();
				pLineM->intersectWith(pLineS, AcDb::kExtendBoth, pts);
				if (pts.length() == 1)
				{
					dLXY = ptGe[1].distanceTo(pts.first());
					dLX = dLXY * dCosAngle;
				}

				if (data.dGarExt <= dLX)
				{
					vtM = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vtM * data.dGarExt / dCosAngle;
					ptGeIn.insertAt(2, pt);

					ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
					ptGe[3] = ptGe[3] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);

				}
				else
				{
					vtM = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vtM * dLXY;
					ptGeIn.insertAt(2, pt);

					if ((data.dGarExt - dLX) < data.dGarSize[0] * .5)
					{
						pt += vtDir * data.dGarSize[0] * .5;
						ptGeIn.insertAt(3, pt);
					}
					else
					{
						pt += vtDir * (data.dGarExt - dLX);
						ptGeIn.insertAt(3, pt);
					}

					pt += vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
					ptGeIn.insertAt(4, pt);
				}

			}
			else
			{
				ptGe[2] = ptGe[2] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
				ptGe[3] = ptGe[3] + vt * ((data.dBarSide + data.dGarSize[1] * .5) * 2 + (data.dStairTW - data.dStairSW * 2 - data.dStairMW) * .5);
				pLineS = new AcDbLine(ptGe[2], ptGe[3]);

				double dLXY(.0), dLX(.0);
				AcGePoint3dArray pts;
				pts.removeAll();
				pLineM->intersectWith(pLineS, AcDb::kExtendBoth, pts);
				if (pts.length() == 1)
				{
					dLXY = ptGe[1].distanceTo(pts.first());
					dLX = dLXY * dCosAngle;
				}

				if (data.dGarExt <= dLX)
				{
					vtM = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vtM * data.dGarExt / dCosAngle;
					ptGeIn.insertAt(2, pt);
				}
				else
				{
					vtM = (ptGe[0] - ptGe[1]).normalize();
					pt = ptGe[1] - vtM * dLXY;
					ptGeIn.insertAt(2, pt);

					if ((data.dGarExt - dLX) < data.dGarSize[0] * .5)
					{
						pt += vtDir * data.dGarSize[0] * .5;
						ptGeIn.insertAt(3, pt);
					}
					else
					{
						pt += vtDir * (data.dGarExt - dLX);
						ptGeIn.insertAt(3, pt);
					}

					pt -= vt * ((data1.dStairTW - data1.dStairSW * 2 - data1.dStairMW) * .5 + data.dGarSize[0] + data.dBarSide * 2);
					ptGeIn.insertAt(4, pt);
				}
			}

			DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);

			if (data1.bOutSideHRail)
			{
				data1.nSteepS = data1.nSteepsS - 1;
				pLine1 = DrawHandRail(dc, ptAr[2], ptAr[3], !num, data1.dStairSW, data1);
				pLine1->getStartPoint(ptS);
				pLine1->getEndPoint(ptE);
				ptGeIn.removeAll();
				ptGeIn.append(ptS);
				ptGeIn.append(ptE);
				// 层间伸出
				if (UP_ZERO(data1.dZGarExt))
				{
					ptS = ptGeIn.at(0) - vtDir * data.dZGarExt;
					ptGeIn.insertAt(0, ptS);
				}
				// 转角伸出
				if (UP_ZERO(data1.dGarExt))
				{
					ptE = ptGeIn.at(2) + vtDir * data.dGarExt;
					ptGeIn.append(ptE);
				}
				DrawHandRailPath3d(dc, ptGeIn, vt, vtDir, data1);
			}
		}
	}

	return Acad::eOk;
}