#include "stdafx.h"
#include "XDrawUGRampEdJig.h"
#include<math.h>
#include "GlwGlobalVariable.h"
#include "GlwUGRampDataManage.h"
#include "UndergroundRampStyle.h"
#include "UndergroundRampDlg.h"

extern void MergerPoly(XPoly2D &polyPre, XPoly2D &polyAdd, XPoly2D &xpolyNew);
extern void CutOutArc(TGGeCurveSegment &segSrc, TGGeCurveSegment &segRet, XPoint &ptOnArc, BOOL bIsFromSt);
extern BOOL GetInterLine(TGGeCurveSegment &segFirst, TGGeCurveSegment &segSec);
extern void FilletRampPoly(XPoly2D &rampPolyBase, XPoly2D &rampPolyLeftOut, XPoly2D &rampPolyLeftIn, XPoly2D &rampPolyRightOut, XPoly2D &rampPolyRightIn, XPoly2D &rampPolyMid);
//取得末端折线
void GetBrokenLine(XPoly2D &rampPolyLeft, XPoly2D &rampPolyRight, XPoly2D &polyBroken)
{
	GlwUGRampDataManage* pRampDataManage = GET_GLOBAL_VARIABLE(GlwUGRampDataManage);
	TGGeCurveSegment segBroken, segBroken1, segEndLine(*(rampPolyLeft.GetPointListAt(rampPolyLeft.Length() - 1)), *(rampPolyRight.GetPointListAt(rampPolyRight.Length() - 1)), 0);
	XPoint ptOnArc, ptTemp, ptMid = segEndLine.MidPoint();
	double dAngle, dlength;
	TGGeCurveSegment seg1, seg2;
	rampPolyLeft.Nth(rampPolyLeft.TotalSegments() - 1, seg1);
	rampPolyRight.Nth(rampPolyRight.TotalSegments() - 1, seg2);
	AcGeVector3d vec = segEndLine.GetEndPoint() - segEndLine.GetStartPoint();
	switch (pRampDataManage->GetDrawStyle())
	{
	case CUndergroundRampDlg::VIEW4:
	case CUndergroundRampDlg::VIEW5:
	case CUndergroundRampDlg::VIEW6:
		{
			double dAngle;
			AcGeVector3d vecTemp = vec;
			ptTemp = segEndLine.GetEndPoint() - _AS_SYS_UNIT(BROKEN_LINE_OFFSET) * vec / vec.length();
			vec = vec.rotateBy(-0.5 * PI, AcGeVector3d::kZAxis);
			ptTemp = ptTemp + _AS_SYS_UNIT(BROKEN_LINE_OFFSET) * vec / vec.length();
			if (seg1.GetLength() > _AS_SYS_UNIT(BROKEN_LINE_OFFSET))
			{	
				dAngle = rampPolyLeft.GetBulge(rampPolyLeft.TotalSegments() - 1);
			}
			else
			{
				if (rampPolyLeft.TotalSegments() <= 1)
				{
					return;
				}
				//rampPolyLeft.Nth(rampPolyLeft.TotalSegments() - 2, seg1);
				rampPolyRight.Nth(rampPolyRight.TotalSegments() - 2, seg2);
				//dAngle = rampPolyLeft.GetBulge(rampPolyLeft.TotalSegments() - 1);
				dAngle = rampPolyRight.GetBulge(rampPolyRight.TotalSegments() - 2);
			}
			if (abs(seg2.GetBulge()) > 1.0E-6)
			{
				if (dAngle > 0)
				{
					TADSGePointDir2d res;
					dlength = seg2.GetLength();
					if (dlength < _AS_SYS_UNIT(BROKEN_LINE_OFFSET))
						seg2.Polar(0.5 * dlength, res);
					else
						seg2.Polar(0.5 * (dlength - _AS_SYS_UNIT(BROKEN_LINE_OFFSET)), res);
					ptOnArc = res.AsAcGePoint3d();
					vecTemp = seg2.GetArc().GetCenterPt() - ptOnArc;
					ptOnArc = ptOnArc + 0.5 * _AS_SYS_UNIT(BROKEN_LINE_OFFSET) * vecTemp / vecTemp.length();
					segBroken = XArc(seg2.GetStartPoint(), ptOnArc, ptTemp);
					segBroken1 = XLine(ptTemp, seg1.GetEndPoint());
				}
				else
				{
					TADSGePointDir2d res;
					dlength = seg2.GetLength();
					if (dlength < _AS_SYS_UNIT(BROKEN_LINE_OFFSET))
						seg2.Polar(0.5 * dlength, res);
					else
						seg2.Polar(0.5 * (dlength - _AS_SYS_UNIT(BROKEN_LINE_OFFSET)) + _AS_SYS_UNIT(BROKEN_LINE_OFFSET), res);
					ptOnArc = res.AsAcGePoint3d();
					vecTemp = seg2.GetArc().GetCenterPt() - ptOnArc;
					ptOnArc = ptOnArc - 0.5 * _AS_SYS_UNIT(BROKEN_LINE_OFFSET) * vecTemp / vecTemp.length();
					if (abs(seg1.GetBulge()) > 1.0E-6)//seg1是弧线
						segBroken = XLine(seg1.GetStartPoint(), ptTemp);
					else//seg1是直线
						segBroken = XLine(seg1.GetEndPoint(), ptTemp);
					segBroken1 = XArc(ptTemp, ptOnArc, seg2.GetEndPoint());
				}
			}
			else
			{
				segBroken = XLine(seg1.GetEndPoint(), ptTemp);
				segBroken1 = XLine(ptTemp, seg2.GetStartPoint());
			}
			break;
		}
		
	case CUndergroundRampDlg::VIEW7:
	case CUndergroundRampDlg::VIEW8:
	case CUndergroundRampDlg::VIEW9:
		{	
			if (abs(rampPolyLeft.GetBulge(rampPolyLeft.TotalSegments() - 1)) > 1.0E-6 )
			{
				if (rampPolyLeft.GetBulge(rampPolyLeft.TotalSegments() - 1) > 0)
				{
					vec = seg1.GetArc().GetCenterPt() - seg1.MidPoint();
					ptTemp = seg1.MidPoint() - 0.2 * segEndLine.GetLength() * vec / vec.length();
					segBroken = XArc(seg1.GetStartPoint(), ptTemp, ptMid);
					vec = seg2.GetArc().GetCenterPt() - seg2.MidPoint();
					ptTemp = seg2.MidPoint() + 0.2 * segEndLine.GetLength() * vec / vec.length();
					segBroken1 = XArc(ptMid , ptTemp, seg2.GetStartPoint());
					dAngle = segBroken1.GetBulge();
					segBroken1.SetStartPoint(ptMid);
					segBroken1.SetEndPoint(seg2.GetStartPoint());
					segBroken1.SetBulge(-dAngle);
				}
				else
				{
					vec = seg1.GetArc().GetCenterPt() - seg1.MidPoint();
					ptTemp = seg1.MidPoint() + 0.2 * segEndLine.GetLength() * vec / vec.length();
					segBroken = XArc(seg1.GetEndPoint(), ptTemp, ptMid);
					dAngle = segBroken.GetBulge();
					segBroken.SetStartPoint(seg1.GetEndPoint());
					segBroken.SetEndPoint(ptMid);
					segBroken.SetBulge(-dAngle);
					vec = seg2.GetArc().GetCenterPt() - seg2.MidPoint();
					ptTemp = seg2.MidPoint() - 0.2 * segEndLine.GetLength() * vec / vec.length();
					segBroken1 = XArc(ptMid , ptTemp, seg2.GetEndPoint());
				}
			}
			else
			{
				segBroken = XLine(seg1.GetStartPoint(), ptMid);
				segBroken1 = XLine(ptMid, seg2.GetStartPoint());
			}
			break;
		}
	}
	polyBroken.AppendSegment(segBroken, 0, 0);
	polyBroken.AppendSegment(segBroken1, 0, 1);
}
void GetRampOutPoly(XPoly2D &rampPolyLeftOut, XPoly2D &rampPolyRightOut, XPoly2D &rampPolyLeftIn, XPoly2D &rampPolyRightIn, XPoly2D &rampPolyMid,TGGeCurveSegment &segStartSec, XPoly2D &xRampOutLine, XPoly2D &xRampInLine, XPoly2D &xRampMidLine, XPoly2D &xBrokenLine, XPoly2D &xArrowPoly, bool bShowOutLine = false)
{
	GlwUGRampDataManage* pRampDataManage = GET_GLOBAL_VARIABLE(GlwUGRampDataManage);
	double dWidth = pRampDataManage->GetRampWidth();
	int nDrawStyle = pRampDataManage->GetDrawStyle();
	TGGeCurveSegment segLeftSecLine, segRightOutLine, segRightInLine;
	XPoint ptStart, ptEnd;
	if ((nDrawStyle == CUndergroundRampDlg::VIEW2) || (nDrawStyle == CUndergroundRampDlg::VIEW5) || (nDrawStyle == CUndergroundRampDlg::VIEW8))
	{
		segStartSec.SetStartPoint(*rampPolyLeftOut.GetPointListAt(0));
		segStartSec.SetEndPoint(*rampPolyRightOut.GetPointListAt(0));
		segStartSec.SetBulge(0);
	}
	else
	{
		segStartSec.SetStartPoint(*rampPolyLeftIn.GetPointListAt(0));
		segStartSec.SetEndPoint(*rampPolyRightIn.GetPointListAt(0));
		segStartSec.SetBulge(0);
	}
	segRightOutLine.SetStartPoint(*rampPolyLeftOut.GetPointListAt(rampPolyLeftOut.Length() - 1));
	segRightOutLine.SetEndPoint(*rampPolyRightOut.GetPointListAt(rampPolyRightOut.Length() - 1));
	segRightOutLine.SetBulge(0);
	segRightInLine.SetStartPoint(*rampPolyLeftIn.GetPointListAt(rampPolyLeftIn.Length() - 1));
	segRightInLine.SetEndPoint(*rampPolyRightIn.GetPointListAt(rampPolyRightIn.Length() - 1));
	segRightInLine.SetBulge(0);
	//判断是不是单线，如果是单线，则不进行偏移
	if (bShowOutLine)
		segRightInLine = segRightInLine.Offset(_AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);
	ptStart = segRightInLine.GetStartPoint();
	ptEnd = segRightInLine.GetEndPoint();

	TGGeCurveSegment segTemp, segRet;
	XPoint ptMid, ptTemp;
	double dAngle;
	XPoly2D polyTemp, polyLast;
	ptMid = segRightInLine.MidPoint();
	rampPolyMid.Nth(rampPolyMid.TotalSegments() - 1, segTemp);
	if (abs(segTemp.GetBulge()) > 1.0E-6 )
	{
		if (rampPolyMid.GetBulge(rampPolyMid.TotalSegments() - 1) < 0)
		{
			dAngle = segTemp.GetBulge();
			ptTemp = segTemp.GetStartPoint();
			segTemp.SetStartPoint(segTemp.GetEndPoint());
			segTemp.SetEndPoint(ptTemp);
			segTemp.SetBulge(-dAngle);
		}
		CutOutArc(segTemp, segRet, ptMid, FALSE);
		polyLast.Reset();
		polyLast.AppendSegment(segRet, 0, 1);
		MergerPoly(rampPolyMid, polyLast, xRampMidLine);
	}
	else
	{
		segRet.SetStartPoint(segTemp.GetStartPoint());
		segRet.SetEndPoint(ptMid);
		segRet.SetBulge(0);
		polyLast.Reset();
		polyLast.AppendSegment(segRet, 0, 1);
		MergerPoly(rampPolyMid, polyLast, xRampMidLine);
	}
	
	rampPolyLeftIn.Nth(rampPolyLeftIn.TotalSegments() - 1, segTemp);
	if (abs(segTemp.GetBulge()) > 1.0E-6 )
	{
		if (rampPolyLeftIn.GetBulge(rampPolyLeftIn.TotalSegments() - 1) < 0)
		{
			dAngle = segTemp.GetBulge();
			ptTemp = segTemp.GetStartPoint();
			segTemp.SetStartPoint(segTemp.GetEndPoint());
			segTemp.SetEndPoint(ptTemp);
			segTemp.SetBulge(-dAngle);
		}
		CutOutArc(segTemp, segRet, ptStart, FALSE);
		polyLast.Reset();
		polyLast.AppendSegment(segRet, 0, 1);
		polyTemp = rampPolyLeftIn;
		rampPolyLeftIn.Reset();
		MergerPoly(polyTemp, polyLast, rampPolyLeftIn);
	}
	else
	{
		segRet.SetStartPoint(segTemp.GetStartPoint());
		segRet.SetEndPoint(ptStart);
		segRet.SetBulge(0);
		polyLast.Reset();
		polyLast.AppendSegment(segRet, 0, 1);
		polyTemp = rampPolyLeftIn;
		rampPolyLeftIn.Reset();
		MergerPoly(polyTemp, polyLast, rampPolyLeftIn);
	}
	
	rampPolyRightIn.Nth(rampPolyRightIn.TotalSegments() - 1, segTemp);
	if (abs(segTemp.GetBulge()) > 1.0E-6 )
	{
		if (rampPolyRightIn.GetBulge(rampPolyRightIn.TotalSegments() - 1) < 0)
		{
			dAngle = segTemp.GetBulge();
			ptTemp = segTemp.GetStartPoint();
			segTemp.SetStartPoint(segTemp.GetEndPoint());
			segTemp.SetEndPoint(ptTemp);
			segTemp.SetBulge(-dAngle);
		}
		CutOutArc(segTemp, segRet, ptEnd, FALSE);
		polyLast.Reset();
		polyLast.AppendSegment(segRet, 0, 1);
		polyTemp = rampPolyRightIn;
		rampPolyRightIn.Reset();
		MergerPoly(polyTemp, polyLast, rampPolyRightIn);
	}
	else
	{
		segRet.SetStartPoint(segTemp.GetStartPoint());
		segRet.SetEndPoint(ptEnd);
		segRet.SetBulge(0);
		polyLast.Reset();
		polyLast.AppendSegment(segRet, 0, 1);
		polyTemp = rampPolyRightIn;
		rampPolyRightIn.Reset();
		MergerPoly(polyTemp, polyLast, rampPolyRightIn);
	}
	//xRampOutLine.AppendSegment(segLeftSecLine, 0, 0);
	for (int i = 0; i < rampPolyRightOut.TotalSegments(); ++i)
	{
		TGGeCurveSegment segTemp;
		rampPolyRightOut.Nth(i, segTemp);
		if (rampPolyRightOut.GetBulge(i) < 0)
		{
			XPoint ptSt = segTemp.GetStartPoint();
			double dAngle = segTemp.GetBulge();
			segTemp.SetStartPoint(segTemp.GetEndPoint());
			segTemp.SetEndPoint(ptSt);
			segTemp.SetBulge(-dAngle);
		}
		xRampOutLine.AppendSegment(segTemp, 0, 0);
	}
	xRampOutLine.AppendSegment(segRightOutLine, 1, 1);
	for (int i = rampPolyLeftOut.TotalSegments() - 1; i >= 0; --i)
	{
		TGGeCurveSegment segTemp;
		rampPolyLeftOut.Nth(i, segTemp);
		if (rampPolyLeftOut.GetBulge(i) < 0)
		{
			XPoint ptSt = segTemp.GetStartPoint();
			double dAngle = segTemp.GetBulge();
			segTemp.SetStartPoint(segTemp.GetEndPoint());
			segTemp.SetEndPoint(ptSt);
			segTemp.SetBulge(-dAngle);
		}
		if (i == 0)
			xRampOutLine.AppendSegment(segTemp, 1, 1);
		else
			xRampOutLine.AppendSegment(segTemp, 1, 0);
	}
	for (int i = 0; i < rampPolyLeftIn.TotalSegments(); ++i)
	{
		TGGeCurveSegment segTemp;
		rampPolyLeftIn.Nth(i, segTemp);
		if (rampPolyLeftIn.GetBulge(i) < 0)
		{
			XPoint ptSt = segTemp.GetStartPoint();
			double dAngle = segTemp.GetBulge();
			segTemp.SetStartPoint(segTemp.GetEndPoint());
			segTemp.SetEndPoint(ptSt);
			segTemp.SetBulge(-dAngle);
		}
		xRampInLine.AppendSegment(segTemp, 0, 0);
	}
	xRampInLine.AppendSegment(segRightInLine, 0, 0);
	for (int i = rampPolyRightIn.TotalSegments() - 1; i >= 0; --i)
	{
		TGGeCurveSegment segTemp;
		rampPolyRightIn.Nth(i, segTemp);
		if (rampPolyRightIn.GetBulge(i) < 0)
		{
			XPoint ptSt = segTemp.GetStartPoint();
			double dAngle = segTemp.GetBulge();
			segTemp.SetStartPoint(segTemp.GetEndPoint());
			segTemp.SetEndPoint(ptSt);
			segTemp.SetBulge(-dAngle);
		}
		if (i == 0)
			xRampInLine.AppendSegment(segTemp, 1, 1);
		else
			xRampInLine.AppendSegment(segTemp, 1, 0);
	}
	switch (nDrawStyle)
	{
	case CUndergroundRampDlg::VIEW4:
	case CUndergroundRampDlg::VIEW5:
	case CUndergroundRampDlg::VIEW6:
	case CUndergroundRampDlg::VIEW7:
	case CUndergroundRampDlg::VIEW8:
	case CUndergroundRampDlg::VIEW9:
		GetBrokenLine(rampPolyLeftIn, rampPolyRightIn, xBrokenLine);
		break;
	}
	if(pRampDataManage->GetIsDimArrow())
	{
		TGGeCurveSegment segFirst;
		rampPolyMid.Nth(0, segFirst);
		if (rampPolyMid.GetBulge(0) < 0)
		{
			XPoint ptSt = segFirst.GetStartPoint();
			double dAngle = segFirst.GetBulge();
			segFirst.SetStartPoint(segFirst.GetEndPoint());
			segFirst.SetEndPoint(ptSt);
			segFirst.SetBulge(-dAngle);
		}
		if (abs(segFirst.GetBulge()) > 1.0e-6)
		{
			TGGeCurveSegment segTemp = segFirst;
			ptMid = segTemp.MidPoint();
			CutOutArc(segTemp, segFirst, ptMid, FALSE);
		}
		else
		{
			segFirst.SetEndPoint(segFirst.MidPoint());
		}
		if(pRampDataManage->GetArrowDrec() == CUndergroundRampDlg::EXITS)
		{
			ptStart = segFirst.GetStartPoint();
			segFirst.SetStartPoint(segFirst.GetEndPoint());
			segFirst.SetEndPoint(ptStart);
			if (abs(segFirst.GetBulge()) > 1.0E-6)
				segFirst.SetBulge(-segFirst.GetBulge());
		}
		xArrowPoly.AppendSegment(segFirst, 0, 1);
	}	
}
XDrawUGRampEdJig::XDrawUGRampEdJig(void)
{
	m_pDrawEnt = new TDbUnderGroundRamp;
}


XDrawUGRampEdJig::~XDrawUGRampEdJig(void)
{
	if (m_pDrawEnt)
	{
		delete m_pDrawEnt;
	}
}

void XDrawUGRampEdJig::doIt()
{
	
	m_pDrawEnt = new TDbUnderGroundRamp;

	setDispPrompt(m_pszPrompt);
	if (m_pszKeyword) {
		INITGET_BEG(-1, m_pszKeyword);
		try {
			m_nRetCode = drag();
		} catch(...) {
			m_nRetCode=AcEdJig::kCancel;
		}
		INITGET_END();
	} else {

		try {
			m_nRetCode = drag();
		} catch(...) {
			m_nRetCode=AcEdJig::kCancel;
		}
	}
}

AcEdJig::DragStatus XDrawUGRampEdJig::sampler()
{
	DragStatus stat;
	setUserInputControls((UserInputControls)
		(AcEdJig::kAccept3dCoordinates | AcEdJig::kNullResponseAccepted
		| AcEdJig::kNoNegativeResponseAccepted
		| AcEdJig::kNoZeroResponseAccepted));

	if (m_pszKeyword) setKeywordList(m_pszKeyword);
	XPoint ptTemp;
	if (m_nFlag==0 || m_nFlag==1 ) {
		stat = acquirePoint(ptTemp, m_ptStart);
		if (stat == AcEdJig::kNormal) 
		{
			
			if (m_nFlag == 0 )
			{ 
				if (ads_distance(ptTemp, m_ptEnd)>_DIST_SNAP)
					m_ptEnd=ptTemp;
				else  return AcEdJig::kNoChange;
			} else if (m_nFlag==1) 
			{
				if (ptTemp.Distance(m_ptAny)>_DIST_SNAP)
					m_ptAny=ptTemp;
				else  return AcEdJig::kNoChange;	
			}
		}
	} else if (m_nFlag==2)
	{
		double nTemp;
		//stat = acquirePoint(m_ptAny);
		stat = acquireDist(nTemp, m_ptStart);
		if (fabs(nTemp-m_nRadius)>_DIST_SNAP)
		{
			m_nRadius=nTemp;
		} else if (stat==AcEdJig::kNormal) 
		{
			return AcEdJig::kNoChange;
		}
	}
	return stat;
}

void XDrawUGRampEdJig::SetPreview(XPoly2D &rampPolyBase)
{
	XPoly2D rampPolyLeftOut, rampPolyRightOut, rampPolyLeftIn, rampPolyRightIn, rampPolyMid, xRampPolyMid, xRampOutLine, xRampInLine, xBrokenLine, xArrowPoly;
	TGGeCurveSegment segSatrtSec;
	FilletRampPoly(rampPolyBase, rampPolyLeftOut, rampPolyLeftIn, rampPolyRightOut, rampPolyRightIn, rampPolyMid);
	if (rampPolyLeftOut.TotalSegments() < 1)
		return;
	GetRampOutPoly(rampPolyLeftOut, rampPolyRightOut, rampPolyLeftIn, rampPolyRightIn, rampPolyMid, segSatrtSec, xRampOutLine, xRampInLine, xRampPolyMid, xBrokenLine, xArrowPoly);
	m_pDrawEnt->SetPolyOutLine(xRampOutLine, xRampInLine, segSatrtSec);
	m_pDrawEnt->SetPolyMidLine(xRampPolyMid);
	m_pDrawEnt->SetBrokenLine(xBrokenLine);
	m_pDrawEnt->SetArrowPoly2D(xArrowPoly);
}

// 更新实体数据
Adesk::Boolean XDrawUGRampEdJig::update()
{
	XCurveSegment segNew(LS_INFINITE), segTemp(LS_INFINITE), segAr(LS_INFINITE), segLast(LS_INFINITE);
	XPoint ptStart, ptEnd;
	XPoly2D rampPolyBase;
	GlwUGRampDataManage* pRampDataManage = GET_GLOBAL_VARIABLE(GlwUGRampDataManage);
	double dWidth, dTurnningRad, dOffset(0.0);
	dWidth = pRampDataManage->GetRampWidth();
	dTurnningRad = pRampDataManage->GetTurningRad();
	int nLOPLoc = pRampDataManage->GetLOPLoc();
	if (nLOPLoc == CUndergroundRampDlg::MIDLINE)
	{
		dOffset = 0.5 * dWidth ;
	}
	else if(nLOPLoc == CUndergroundRampDlg::RIGHTLINE)
	{
		dOffset = dWidth;
	}
	if (m_nFlag==0) 
	{
		
		if (m_ptStart == m_ptEnd)
		{
			rampPolyBase = m_rampPolyBase;
			if (m_rampPolyBase.TotalSegments() > 0)
			{
			}
			else
				return Adesk::kFalse;
		}
		else if (m_ptEnd != m_ptStart)
		{
			segNew = XCurveSegment(m_ptStart, m_ptEnd, LS_INFINITE);		
			if (m_rampPolyBase.TotalSegments() < 1)
			{	
				if ((nLOPLoc == CUndergroundRampDlg::LEFTLINE) || (nLOPLoc == CUndergroundRampDlg::MIDLINE) || (nLOPLoc == CUndergroundRampDlg::RIGHTLINE))
				{
					segNew = segNew.Offset(-dOffset, LS_INFINITE);
				}
				rampPolyBase.AppendSegment(segNew, 0, 1);
			}
			else if (m_rampPolyBase.TotalSegments() >= 1)
			{
				
				m_rampPolyBase.Nth(m_rampPolyBase.TotalSegments() - 1,segLast);
				if ((nLOPLoc == CUndergroundRampDlg::LEFTLINE) || (nLOPLoc == CUndergroundRampDlg::MIDLINE) || (nLOPLoc == CUndergroundRampDlg::RIGHTLINE))
				{
					segNew = segNew.Offset(-dOffset, LS_INFINITE);
				}
				if (m_rampPolyBase.GetBulge(m_rampPolyBase.TotalSegments() - 1) < 0)
				{
					XPoint ptSt = segLast.GetStartPoint();
					double dAngle = segLast.GetBulge();
					segLast.SetStartPoint(segLast.GetEndPoint());
					segLast.SetEndPoint(ptSt);
					segLast.SetBulge(-dAngle);
				}
				/*if (segLast.GetBulge() < 0)
				{
					XPoint ptTemp;
					TGGeCurveSegment segRightPreOut, segRightSecondOut, segPre, segSec;
					segPre = segLast, segSec = segNew;
					if(!GetInterLine(segPre, segSec))
						return Adesk::kFalse;
					double dAngle = segPre.GetBulge();
					segRightPreOut = segPre.Offset(-(dWidth + _AS_SYS_UNIT(DOUBLET_SPACING)), LS_INFINITE);
					segRightSecondOut = segSec.Offset(dWidth + _AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);
					ptTemp = segRightPreOut.GetStartPoint();
					segRightPreOut.SetStartPoint(segRightPreOut.GetEndPoint());
					segRightPreOut.SetEndPoint(ptTemp);
					segRightPreOut.SetBulge(dAngle);		
					if(!GetInterLine(segRightPreOut, segRightSecondOut))
						return Adesk::kFalse;	
				}		*/
				for (int i = 0; i < m_rampPolyBase.TotalSegments()-1; ++i)
				{
					m_rampPolyBase.Nth(i, segTemp);
					if (m_rampPolyBase.GetBulge(i) < 0)
					{
						XPoint ptSt = segTemp.GetStartPoint();
						double dAngle = segTemp.GetBulge();
						segTemp.SetStartPoint(segTemp.GetEndPoint());
						segTemp.SetEndPoint(ptSt);
						segTemp.SetBulge(-dAngle);
					}
					rampPolyBase.AppendSegment(segTemp, 0, 0);
				}	
				//由于平移方向造成两线无交点时，直接返回，预览图不变
				/*if(!GetInterLine(segLast, segNew))*/
					/*return Adesk::kFalse;*/
				GetInterLine(segLast, segNew);
				rampPolyBase.AppendSegment(segLast, 0, 0);
				rampPolyBase.AppendSegment(segNew, 0, 1);
			}
		}
		SetPreview(rampPolyBase);
	} else if (m_nFlag==1) 
	{
		if ((m_ptEnd == m_ptStart) || (m_ptEnd==m_ptAny) || (m_ptAny == m_ptStart))
		{
			rampPolyBase = m_rampPolyBase;
			if (m_rampPolyBase.TotalSegments() > 0)
			{
			}
			else
				return Adesk::kFalse;
		}
		else if ((m_ptStart != m_ptEnd) && (m_ptAny != m_ptEnd) && (m_ptAny != m_ptStart))
		{
			segNew=XArc(m_ptStart, m_ptAny, m_ptEnd);
			XLine linePath(m_ptStart, m_ptEnd);
			if(!linePath.OnWhichSide(m_ptAny))
			{
				double dAngle = segNew.GetBulge();
				segNew.SetStartPoint(m_ptStart);
				segNew.SetEndPoint(m_ptEnd);
				segNew.SetBulge(-dAngle);
			}
			if (m_rampPolyBase.TotalSegments() < 1)
			{
				if ((nLOPLoc == CUndergroundRampDlg::LEFTLINE) ||(nLOPLoc == CUndergroundRampDlg::MIDLINE) || (nLOPLoc == CUndergroundRampDlg::RIGHTLINE))
				{
					if (segNew.GetBulge() > 0)
					{
						segNew = segNew.Offset(-dOffset, LS_INFINITE);		
					}
					else
					{
						double dAngle = segNew.GetBulge();
						segNew = segNew.Offset(dOffset, LS_INFINITE);
						ptStart = segNew.GetEndPoint();
						segNew.SetEndPoint(segNew.GetStartPoint());
						segNew.SetStartPoint(ptStart);
						segNew.SetBulge(dAngle);
					}
				}
				rampPolyBase.AppendSegment(segNew, 0, 1);
			}
			else if (m_rampPolyBase.TotalSegments() >= 1)
			{
				m_rampPolyBase.Nth(m_rampPolyBase.TotalSegments() - 1,segLast);
				if (m_rampPolyBase.GetBulge(m_rampPolyBase.TotalSegments() - 1) < 0)
				{
					XPoint ptSt = segLast.GetStartPoint();
					double dAngle = segLast.GetBulge();
					segLast.SetStartPoint(segLast.GetEndPoint());
					segLast.SetEndPoint(ptSt);
					segLast.SetBulge(-dAngle);
				}	
				if ((nLOPLoc == CUndergroundRampDlg::LEFTLINE) || (nLOPLoc == CUndergroundRampDlg::MIDLINE) || (nLOPLoc == CUndergroundRampDlg::RIGHTLINE))
				{
					if (segNew.GetBulge() > 0)
					{
						segNew = segNew.Offset(-dOffset, LS_INFINITE);
						XPoint ptTemp;
						TGGeCurveSegment segRightPreOut, segRightSecondOut, segPre, segSec;
						segPre = segLast, segSec = segNew;
						if(!GetInterLine(segPre, segSec))
							return Adesk::kFalse;
						segRightPreOut = segPre.Offset(dWidth + _AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);
						segRightSecondOut = segSec.Offset(dWidth + _AS_SYS_UNIT(DOUBLET_SPACING), LS_INFINITE);		
						if(!GetInterLine(segRightPreOut, segRightSecondOut))
							return Adesk::kFalse;	
					}
					else
					{
						double dAngle = segNew.GetBulge();
						segNew = segNew.Offset(dOffset, LS_INFINITE);
						ptStart = segNew.GetEndPoint();
						segNew.SetEndPoint(segNew.GetStartPoint());
						segNew.SetStartPoint(ptStart);
						segNew.SetBulge(dAngle);
					}
				}
				for (int i = 0; i < m_rampPolyBase.TotalSegments() - 1; ++i)
				{
					m_rampPolyBase.Nth(i, segTemp);
					if (m_rampPolyBase.GetBulge(i) < 0)
					{
						XPoint ptSt = segTemp.GetStartPoint();
						double dAngle = segTemp.GetBulge();
						segTemp.SetStartPoint(segTemp.GetEndPoint());
						segTemp.SetEndPoint(ptSt);
						segTemp.SetBulge(-dAngle);
					}
					rampPolyBase.AppendSegment(segTemp, 0, 0);
				}
				if(!GetInterLine(segLast, segNew))
					return Adesk::kFalse;
				rampPolyBase.AppendSegment(segLast, 0, 0);
				rampPolyBase.AppendSegment(segNew, 0, 1);
			}
		}
		SetPreview(rampPolyBase);
	}
	 else if (m_nFlag==2) 
	{
		double nChordLen=ads_distance(m_ptStart, m_ptEnd);
		if (nChordLen<2.0*fabs(m_nRadius)-1.0E-6) 
		{
			double bulge=2.0*asin(nChordLen/2.0/m_nRadius);
			XLine lineChord(m_ptStart, m_ptEnd);
			if (lineChord.OnWhichSide(m_ptAny))
			{
				segNew = TGGeCurveSegment(m_ptStart, m_ptEnd, bulge);
			}
			else
			{
				segNew = TGGeCurveSegment(m_ptStart, m_ptEnd, -bulge);
			}
			if ((nLOPLoc == CUndergroundRampDlg::LEFTLINE) || (nLOPLoc == CUndergroundRampDlg::MIDLINE) || (nLOPLoc == CUndergroundRampDlg::RIGHTLINE))
			{
				if (segNew.GetBulge() > 0)
				{
					segNew = segNew.Offset(-0.5 * dOffset, LS_INFINITE);		
				}
				else
				{
					segNew = segNew.Offset(0.5 * dOffset, LS_INFINITE);
					double dAngle = segNew.GetBulge();
					ptStart = segNew.GetEndPoint();
					segNew.SetEndPoint(segNew.GetStartPoint());
					segNew.SetStartPoint(ptStart);
					segNew.SetBulge(dAngle);
				}
			}
			if (m_rampPolyBase.TotalSegments() < 1)
			{
				
				rampPolyBase.AppendSegment(segNew, 0, 1);
			}
			else if (m_rampPolyBase.TotalSegments() >= 1)
			{
				m_rampPolyBase.Nth(m_rampPolyBase.TotalSegments() - 1,segLast);
				if (m_rampPolyBase.GetBulge(m_rampPolyBase.TotalSegments() - 1) < 0)
				{
					XPoint ptSt = segLast.GetStartPoint();
					double dAngle = segLast.GetBulge();
					segLast.SetStartPoint(segLast.GetEndPoint());
					segLast.SetEndPoint(ptSt);
					segLast.SetBulge(-dAngle);
				}	
				if ((nLOPLoc == CUndergroundRampDlg::LEFTLINE) || (nLOPLoc == CUndergroundRampDlg::MIDLINE) || (nLOPLoc == CUndergroundRampDlg::RIGHTLINE))
				{
					if (segNew.GetBulge() > 0)
					{
						segNew = segNew.Offset(-0.5 * dOffset, LS_INFINITE);
					}
					else
					{
						segNew = segNew.Offset(0.5 * dOffset, LS_INFINITE);
						double dAngle = segNew.GetBulge();
						ptStart = segNew.GetEndPoint();
						segNew.SetEndPoint(segNew.GetStartPoint());
						segNew.SetStartPoint(ptStart);
						segNew.SetBulge(dAngle);
					}
				}
				for (int i = 0; i < m_rampPolyBase.TotalSegments() - 1; ++i)
				{
					m_rampPolyBase.Nth(i, segTemp);
					if (m_rampPolyBase.GetBulge(i) < 0)
					{
						XPoint ptSt = segTemp.GetStartPoint();
						double dAngle = segTemp.GetBulge();
						segTemp.SetStartPoint(segTemp.GetEndPoint());
						segTemp.SetEndPoint(ptSt);
						segTemp.SetBulge(-dAngle);
					}
					rampPolyBase.AppendSegment(segTemp, 0, 0);
				}
				if(!GetInterLine(segLast, segNew))
					return Adesk::kFalse;
				rampPolyBase.AppendSegment(segLast, 0, 0);
				rampPolyBase.AppendSegment(segNew, 0, 1);
			}
			SetPreview(rampPolyBase);
		} 
		else 
		{
			return Adesk::kFalse;
		}
	}
	else 
	{
		return Adesk::kFalse;
	}
	return Adesk::kTrue;
}

AcDbEntity* XDrawUGRampEdJig::entity() const
{
	return m_pDrawEnt;
}

int XDrawUGRampEdJig::GetRetCode(int *kwordId) const
{
	int ret = m_nRetCode;
	if (ret == AcEdJig::kCancel)
		ret = RTCAN;
	else if (ret == AcEdJig::kNull)
		ret = RTNONE;
	else if (ret <= 0) 
		ret = RTNORM;
	else {
		if (kwordId) *kwordId = ret;
		ret = RTKWORD;
	}
	return ret;
}

void XDrawUGRampEdJig::SetRampPoly(XPoly2D &rampPolyBase)
{
	m_rampPolyBase = rampPolyBase;
}