#include"stdafx.h"
#include"stdarx.h"
#include"distdrag.h"
 


void dist_pl_addpoint(AcDbObjectId PlineId,AcGePoint3d pt,double dBulge=0.0,double dStartWidth=0.0,double dEndWidth=0.0)
{
	AcDbPolyline *pLine=NULL;
	if(acdbOpenObject(pLine,PlineId,AcDb::kForWrite)==Acad::eOk)
	{
		pLine->setWidthsAt(pLine->numVerts()-1,dStartWidth,dEndWidth);
		pLine->addVertexAt(pLine->numVerts(),AcGePoint2d(pt.x,pt.y),0.0,dEndWidth,dEndWidth);
		pLine->close();
		pLine=NULL;
	}
}
BOOL dist_pl_dellastpt(AcDbObjectId PlineId,AcGePoint3d &ptLast,AcGeVector3d &vt,BOOL &bArc)
{
	AcDbPolyline *pLine=NULL;
	BOOL bRet=FALSE;
	double dBulge=0.0;
	bArc=FALSE;
	if(acdbOpenObject(pLine,PlineId,AcDb::kForWrite)==Acad::eOk)
	{
		if(pLine->numVerts()>=2)
		{
			pLine->removeVertexAt(pLine->numVerts()-1);
			pLine->getPointAt(pLine->numVerts()-1,ptLast);
			pLine->getFirstDeriv(ptLast,vt);
			 
			pLine->getBulgeAt(pLine->numVerts()-2,dBulge);
			if(fabs(dBulge)<0.001)
				bArc=FALSE;
			else
				bArc=TRUE;
			 
			bRet=TRUE;
		}
		pLine->close();
		pLine=NULL;
	}
	return bRet;
}
void dist_pl_close(AcDbObjectId PlineId)
{
	AcDbPolyline *pLine=NULL;
	if(acdbOpenObject(pLine,PlineId,AcDb::kForWrite)==Acad::eOk)
	{
		pLine->setClosed(Adesk::kTrue);
		pLine->close();
		pLine=NULL;
	}
}
AsdkCadPolylineJig::AsdkCadPolylineJig()  
{	
	m_pLine=NULL;
}

AsdkCadPolylineJig::~AsdkCadPolylineJig()
{ 
	if(m_pLine)
	{
	//	acutPrintf(_T("delete"));
		delete m_pLine;
		m_pLine=NULL;
	}
}
double AsdkCadPolylineJig::m_dStartWidth=0.0;
double AsdkCadPolylineJig::m_dEndWidth=0.0;
void AsdkCadPolylineJig::AddPoint(AcGePoint3d ptAdd)
{
	m_pLine->setPointAt(m_pLine->numVerts()-1,AcGePoint2d(ptAdd.x,ptAdd.y));
				m_pLine->getFirstDeriv(ptAdd,m_vt);
				if(m_objId==NULL)
				{
					AcDbPolyline *pLine=(AcDbPolyline*)m_pLine->clone();
					BaseFuncs::AddEntToDb(pLine,m_objId);
				}
				else
				{
					dist_pl_addpoint(m_objId,ptAdd,0.0,m_dStartWidth,m_dEndWidth);
				//m_pLine->setPointAt(m_pLine->numVerts()-1,AcGePoint2d(m_ptEnd.x,m_ptEnd.y));
				}

				AcDbPolyline *pLine=NULL;
				if(acdbOpenObject(pLine,m_objId,AcDb::kForWrite)==Acad::eOk)
				{
					pLine->setBulgeAt(pLine->numVerts()-2,m_dBulge);
				//	pLine->getFirstDeriv(m_ptEnd,m_vt);
					pLine->close();
					pLine=NULL;
				}

				m_ptStart=ptAdd;
				m_pLine->setPointAt(0,AcGePoint2d(ptAdd.x,ptAdd.y));
				m_pLine->setPointAt(1,AcGePoint2d(ptAdd.x,ptAdd.y));
			//	m_pLine->addVertexAt(m_pLine->numVerts(),AcGePoint2d(m_ptEnd.x,m_ptEnd.y),m_dStartWidth,m_dEndWidth);
				m_dStartWidth=m_dEndWidth; 
}
static BOOL m_bSnap=FALSE;
void AsdkCadPolylineJig::doIt()
{ 
	m_bMidPt=FALSE;
	m_dBulge=0.0;
	if(acedGetPoint(NULL,_T("\n指定起点:"),asDblArray(m_ptStart))!=RTNORM)
		return;
	m_pLine=new AcDbPolyline;
	m_pLine->addVertexAt(0,AcGePoint2d(m_ptStart.x,m_ptStart.y),0,m_dStartWidth,m_dEndWidth);
	m_pLine->addVertexAt(1,AcGePoint2d(m_ptStart.x,m_ptStart.y),0,m_dStartWidth,m_dEndWidth);
	m_bArc=FALSE;
	 
	while(1)
	{  
		if(!m_bArc)
		{
			if(m_objId==NULL)
				setDispPrompt(_T("\n指定下一个点或 [圆弧(A)/半宽(H)/长度(L)/放弃(U)/宽度(W)/正交(O)]:"));
			else
				setDispPrompt(_T("\n指定下一个点或 [圆弧(A)/闭合(C)/半宽(H)/长度(L)/放弃(U)/宽度(W)/正交(O)]:"));

		}
		else
			setDispPrompt(_T("\n[角度(A)/圆心(CE)/闭合(CL)/方向(D)/半宽(H)/直线(L)/半径(R)/第二个点(S)/放弃(U)/宽度(W)]:"));
		AcEdJig::DragStatus stat=drag();
		if(!m_bArc)
		{
			if(stat==AcEdJig::kNormal)  //插入
			{ 
			//	acutPrintf("\nvvvvv");
				 AddPoint(m_ptEnd);
			}
			else if(stat==AcEdJig::kKW1)  //圆弧
			{
				m_bArc=TRUE;
				AcDbPolyline  *pLine=NULL;
				AcGePoint3d ptEnd;
				if(acdbOpenObject(pLine,m_objId,AcDb::kForRead)==Acad::eOk)
				{
					pLine->getEndPoint(ptEnd);
				//	pLine->getFirstDeriv(ptEnd,m_vt);
					pLine->close();
					pLine=NULL;
				}
				continue;
			}
			else if(stat==AcEdJig::kKW2)  //半宽
			{
				CString strFormat;
				m_dStartWidth/=2.0;
				m_dEndWidth/=2.0;
				strFormat.Format(_T("\n输入起点半宽<%0.4f>:"),m_dStartWidth);
				acedGetReal(strFormat,&m_dStartWidth);
				strFormat.Format(_T("\n输入终点半宽<%0.4f>:"),m_dEndWidth);
				acedGetReal(strFormat,&m_dEndWidth);
				m_dStartWidth*=2.0;
				m_dEndWidth*=2.0;
			}
			else if(stat==AcEdJig::kKW3)  //L 长度
			{
				double dDist=0.0;
				AcDbPolyline  *pLine=NULL;
				AcGePoint3d ptEnd;
				if(acdbOpenObject(pLine,m_objId,AcDb::kForRead)==Acad::eOk)
				{
					pLine->getEndPoint(ptEnd); 
					pLine->close();
					pLine=NULL;
				}

				if(acedGetDist(asDblArray(ptEnd),_T("\n指定长度:"),&dDist)!=RTNORM)
					continue;
				AcGeVector3d vt=m_vt;
				vt=vt.normal();
				AcGePoint3d ptAdd=ptEnd+vt*dDist;
				AddPoint(ptAdd);
				// dist_pl_dellastpt(m_objId,m_ptStart);
				// m_pLine->setPointAt(0,AcGePoint2d(m_ptStart.x,m_ptStart.y));
			}
			else if(stat==AcEdJig::kKW4)  //回退
			{
				 dist_pl_dellastpt(m_objId,m_ptStart,m_vt,m_bArc);
				 m_pLine->setPointAt(0,AcGePoint2d(m_ptStart.x,m_ptStart.y));
			}
			else if(stat==AcEdJig::kKW5)  //宽度
			{
				CString strFormat;
				strFormat.Format(_T("\n输入起点线宽<%0.4f>:"),m_dStartWidth);
				acedGetReal(strFormat,&m_dStartWidth);
				strFormat.Format(_T("\n输入终点线宽<%0.4f>:"),m_dEndWidth);
				acedGetReal(strFormat,&m_dEndWidth);
			}
			else if(stat==AcEdJig::kKW6)  //正交
			{  
				m_bSnap=!m_bSnap;
				if(m_bSnap)
					acutPrintf(_T("\n<正交 开>"));
				else
					acutPrintf(_T("\n<正交 关>")); 
			}
			else if(stat==AcEdJig::kKW7)  //闭合
			{

				ClosePolyline();
				return;
			}
			 
			else if(stat==AcEdJig::kCancel)
			{
				BaseFuncs::DeleteEnt(m_objId);
				m_objId=NULL;
				return;
			}
			else 
			{
				return;
			}
		}
		else
		{
			if(stat==AcEdJig::kNormal)  //插入
			{ 
				m_bMidPt=FALSE;
				AddPoint(m_ptEnd);
			}
			else if(stat==AcEdJig::kKW3)  //闭合
			{
				//dist_pl_close(m_objId);
				 ClosePolyline();
				return;
			}
			else if(stat==AcEdJig::kKW4)  //方向
			{ 
				AcGePoint3d ptDir;
				if(acedGetPoint(asDblArray(m_ptStart),_T("\n指定方向:"),asDblArray(ptDir))==RTNORM)
				{
					m_vt=ptDir-m_ptStart;
				}
			//	return;
			}
			else if(stat==AcEdJig::kKW5)  //半宽
			{
				CString strFormat;
				m_dStartWidth/=2.0;
				m_dEndWidth/=2.0;
				strFormat.Format(_T("\n输入起点半宽<%0.4f>:"),m_dStartWidth);
				acedGetReal(strFormat,&m_dStartWidth);
				strFormat.Format(_T("\n输入终点半宽<%0.4f>:"),m_dEndWidth);
				acedGetReal(strFormat,&m_dEndWidth);
				m_dStartWidth*=2.0;
				m_dEndWidth*=2.0;
			}

			else if(stat==AcEdJig::kKW6)  //直线
			{ 
				m_pLine->setBulgeAt(0,0);
				m_bArc=FALSE;
				m_dBulge=0.0;
			}
			else if(stat==AcEdJig::kKW8)  //中间点圆弧
			{  
				 m_bMidPt=TRUE;
				 if(acedGetPoint(NULL,_T("\n指定圆弧上的第二个点:"),asDblArray(m_ptMid))!=RTNORM)
				 {
					 m_bMidPt=FALSE;
					 continue;
				 }
			}
			else if(stat==AcEdJig::kKW9)  //放弃
			{ 
				 dist_pl_dellastpt(m_objId,m_ptStart,m_vt,m_bArc);
				 m_pLine->setPointAt(0,AcGePoint2d(m_ptStart.x,m_ptStart.y));
			}
			else if(stat==AcEdJig::kKW9+1)  //宽度
			{ 
				 	CString strFormat;
				strFormat.Format(_T("\n输入起点线宽<%0.4f>:"),m_dStartWidth);
				acedGetReal(strFormat,&m_dStartWidth);
				strFormat.Format(_T("\n输入终点线宽<%0.4f>:"),m_dEndWidth);
				acedGetReal(strFormat,&m_dEndWidth);
			}
			else if(stat==AcEdJig::kCancel)
			{
				BaseFuncs::DeleteEnt(m_objId);
				m_objId=NULL;
				return;
			}
			else 
			{
				return;
			}
		}

	} 
} 
void AsdkCadPolylineJig::ClosePolyline()
{
	AcDbPolyline *pLine=NULL;
	if(acdbOpenObject(pLine,m_objId,AcDb::kForWrite)==Acad::eOk)
	{ 
		if(m_bArc)
		{
			pLine->getPointAt(0,m_ptStart);
			pLine->getPointAt(pLine->numVerts()-1,m_ptEnd);
			pLine->getFirstDeriv(m_ptEnd,m_vt);
			GetArcBulge(m_ptEnd,m_ptStart,m_dBulge); 
			pLine->setBulgeAt(pLine->numVerts()-1,m_dBulge);
		}
		pLine->setWidthsAt(pLine->numVerts()-1,m_dStartWidth,m_dEndWidth);
		pLine->setClosed(Adesk::kTrue);
		pLine->close();
		pLine=NULL;
	}
}

AcDbEntity* AsdkCadPolylineJig::entity() const
{
    return m_pLine;
} 


BOOL GetPointofVector(AcDbObjectId PlineId,AcGePoint3d ptAt,AcGePoint3d &ptVT,AcGePoint3d &ptVF)
{
	int nNumvert=3; 
	AcGePoint3d ptLast; 
	AcGeVector3d vt;
	AcGeVector3d vF;
	AcDbPolyline *pLine=NULL;
	if(acdbOpenObject(pLine,PlineId,AcDb::kForRead)!=Acad::eOk)
		return FALSE;
	if((nNumvert=pLine->numVerts())<2)
	{ 
		ptVT=ptVF=ptAt;
		pLine->close();
		pLine=NULL;
		 
		return FALSE;   
	} 
 
	pLine->getPointAt(nNumvert-1,ptLast); 
	Acad::ErrorStatus es=pLine->getFirstDeriv(ptLast,vt);
 
	pLine->close();
		pLine=NULL; 
	vF=vt;
	vF=vF.rotateBy(PI/2.0,AcGeVector3d::kZAxis);
	if(!BaseFuncs::GetJd(ptLast,ptLast+vt,vF,ptAt,ptVF))
	{ 
		return FALSE;
	}
	if(!BaseFuncs::GetJd(ptLast,ptLast+vF,vt,ptAt,ptVT))
	{ 
		return FALSE;
	} 
	return TRUE;
}
AcEdJig::DragStatus	 
AsdkCadPolylineJig::sampler()
{
    // set the special cursor type. If no cursor type is 
    // specified then acquireXXX method selects one for you.
    //
	if(!m_bArc)
	{
		if(m_objId==NULL)
			setKeywordList(_T("A H L U W O"));	//设置关键字
		else
			setKeywordList(_T("A H L U W O C"));	//设置关键字
	}
	else
		setKeywordList(_T("A CE CL D H L R S U W"));	//设置关键字

	 setSpecialCursorType(AcEdJig::kCrosshair);

   //  kNullResponseAccepted
    setUserInputControls((UserInputControls)
	                 ( AcEdJig::kNullResponseAccepted|AcEdJig::kAccept3dCoordinates ));

/*	setUserInputControls((UserInputControls)(AcEdJig::kAccept3dCoordinates
		|AcEdJig::kNoNegativeResponseAccepted
		|AcEdJig::kNoZeroResponseAccepted
		|AcEdJig::kAcceptOtherInputString)); */
    AcGePoint3d center;
	DragStatus  stat = acquirePoint(center,m_ptStart); //m_ptStart 
	if(stat==AcEdJig::kNormal&&m_ptEnd.distanceTo(center)<0.02)
		return AcEdJig::kNoChange;
	if(m_bSnap&&!m_bArc)
	{
		AcGePoint3d ptVT;
		AcGePoint3d ptVF;
		if(GetPointofVector(m_objId,center,ptVT,ptVF))
			{
				if(ptVT.distanceTo(m_ptStart)>ptVF.distanceTo(m_ptStart))
					m_ptEnd=ptVT;
				else
					m_ptEnd=ptVF; 
			}  
		else
			m_ptEnd=center; 
	}
	else
		m_ptEnd=center;
	 
    return stat ;
}
void  AsdkCadPolylineJig::GetArcBulge(AcGePoint3d ptStart,AcGePoint3d ptEnd,double &dBulge)
{
	dBulge=0.0;
	double dAngle=AcGeVector2d(m_vt.x,m_vt.y).angle();
	AcGeVector3d vF=m_vt;
	vF=vF.rotateBy(PI/2.0,AcGeVector3d::kZAxis);
	vF=vF.normal(); 
	AcGePoint3d ptCenter=ptStart+(ptEnd-ptStart)/2.0;
	AcGeVector3d vt1=ptEnd-ptStart;
	AcGeVector3d vF1=vt1;
	vF1=vF1.rotateBy(PI/2.0,AcGeVector3d::kZAxis);
	double dAngle1=AcGeVector2d(vt1.x,vt1.y).angle();
	double dDeltaAngle=fabs(dAngle-dAngle1);
		if(fabs(dDeltaAngle)<0.001||fabs(dDeltaAngle-PI)<0.001)
			m_pLine->setPointAt(1,AcGePoint2d(ptEnd.x,ptEnd.y));
		else
		{
			//全圆心
			AcDbLine *pLine1=new AcDbLine(ptStart,ptStart+vF);
			AcDbLine *pLine2=new AcDbLine(ptCenter,ptCenter+vF1);
			AcGePoint3dArray ptJds;
			pLine1->intersectWith(pLine2,AcDb::kExtendBoth,ptJds);
			delete pLine1;
			delete pLine2;
			if(ptJds.logicalLength()==1)
			{
				double dRadius=ptStart.distanceTo(ptJds[0]);
				AcGeVector3d vt=ptCenter-ptJds[0]; 
				vt=vt.normal();
				AcGePoint3d ptNext=ptJds[0]+vt*dRadius;
				BaseFuncs::GetBulge(ptStart,ptNext,ptEnd,dBulge);
				dAngle=m_vt.angleTo(vt1,AcGeVector3d::kZAxis);
			//	acutPrintf(_T("\n%0.2f,%0.2f dbulge=%0.2f"),ptJds[0].x,ptJds[0].y,m_dBulge); 
				if(dAngle<PI)
				{
					if(dBulge<0.0)
					{
						ptNext=ptJds[0]-vt*dRadius;
						BaseFuncs::GetBulge(ptStart,ptNext,ptEnd,dBulge);
					} 
				}
				else
				{
					if(dBulge>0.0)
					{
						ptNext=ptJds[0]-vt*dRadius;
						BaseFuncs::GetBulge(ptStart,ptNext,ptEnd,dBulge);
					}  
				} 
			} 
		}
}
Adesk::Boolean	
AsdkCadPolylineJig::update()
{  
	m_dBulge=0.0;
	if(!m_bArc)
	{
		m_pLine->setPointAt(1,AcGePoint2d(m_ptEnd.x,m_ptEnd.y));
		m_pLine->setBulgeAt(0,0);
	}
	else
	{
		if(!m_bMidPt)
			GetArcBulge(m_ptStart,m_ptEnd,m_dBulge);
		else
			BaseFuncs::GetBulge(m_ptStart,m_ptMid,m_ptEnd,m_dBulge);
		m_pLine->setPointAt(1,AcGePoint2d(m_ptEnd.x,m_ptEnd.y));
		m_pLine->setBulgeAt(0,m_dBulge); 
	}
	m_pLine->setWidthsAt(0,m_dStartWidth,m_dEndWidth);
	m_pLine->setWidthsAt(1,m_dEndWidth,m_dEndWidth);
    return Adesk::kTrue;
}