/********************************************************************
	created:	2004/12/28
	created:	28:12:2004   17:00
	filename: 	f:\tg_dev\telecdev\twtkernal\jig.cpp
	file path:	f:\tg_dev\telecdev\twtkernal
	file base:	jig
	file ext:	cpp
	author:		沈睿
	
	purpose:	多管绘制
*********************************************************************/

#include "stdafx.h"

#include "jig.h"

extern XPoint GetNearPtByLst(XPoint pt, XPointList &lstPtIn);


TMultPipePreview::TMultPipePreview(XPointList &lstPt, double nAng, BOOL bFromVPipe)
{
    m_lstOld = lstPt;
    m_nAng = nAng;
    m_bFromVPipe = bFromVPipe;
}

TMultPipePreview::~TMultPipePreview()
{
}


Adesk::Boolean TMultPipePreview::subWorldDraw(AcGiWorldDraw *pWd)
{
    int len = m_lstOld.Length();
    m_lstEnd.Reset();
    m_lstStart.Reset();
//  XPoint ptMid = GetNearPtByLst(m_ptEnd, m_lstOld); cet 2011.5.18 modify
	XPoint ptMid = *m_lstOld[0];
    ptMid.z = 0;
    double nAngleStart = m_nAng;

    XPoint ptTmpEnd, ptTmpStart;
    double dAng = ads_angle(ptMid, m_ptEnd);
    if(m_nAng < 0)
        nAngleStart = dAng;
    for(int i=0;i<len;i++){
        XPoint ptTurn = *m_lstOld[i];
        ptTurn.z = 0;
        double nAngTmp = dAng;
        double n = ads_distance(ptTurn, ptMid); //2管线距离
        if(m_bFromVPipe){
            XPoint ptTemp, ptTemp2;
            ads_polar(ptMid, dAng, 100, ptTemp);
            XLine line2(ptMid, ptTemp);
            ptTurn.Project(&line2, ptTemp2);
            nAngTmp = ads_angle(ptTemp2, ptTurn);
            n = ads_distance(ptTemp2, ptTurn);
        }

   
        
        double nAn = ads_angle(ptMid, ptTurn);
        if(fabs(nAn - PI*2) < 0.001 || nAn > PI*2)
            nAn -= PI*2;
        
        if(nAngleStart < PI/2 || nAngleStart > (PI/2*3 + 0.1) || fabs(nAngleStart - PI/2) < 0.001){
            if(!m_bFromVPipe){
                if(fabs(nAn) < 0.001)
                    nAngTmp -= PI/2;
                else if(fabs(nAn - PI) < 0.001)
                    nAngTmp += PI/2;
                else if(nAn < PI)
                    nAngTmp += PI/2;
                else
                    nAngTmp -= PI/2;
            }
        }
        else{
            if(!m_bFromVPipe){
                if(fabs(nAn) < 0.001)
                    nAngTmp += PI/2;
                else if(fabs(nAn - PI) < 0.001)
                    nAngTmp -= PI/2;
                else if(nAn < PI)
                    nAngTmp -= PI/2;
                else
                    nAngTmp += PI/2;
            }
        }
        
        if(nAngTmp > PI*2)
            nAngTmp -= PI*2;
        ads_polar(m_ptEnd, nAngTmp, n, ptTmpEnd);
        ads_polar(ptMid, nAngTmp, n, ptTmpStart);
        if(m_bFromVPipe){
            ptTmpStart = ptTurn;
            ads_polar(m_ptEnd, nAngTmp, n, ptTmpEnd);
        }
        m_lstEnd.NewAppend(ptTmpEnd);
        m_lstStart.NewAppend(ptTmpStart);
        AcDbLine line(ptTmpStart, ptTmpEnd);
        line.worldDraw(pWd);
    }
    
    return Adesk::kTrue;
}



TMultPipeJig::TMultPipeJig(XPointList &lstPt, double nAng, BOOL bFromVPipe)
{
    m_pDrawEnt = new TMultPipePreview(lstPt, nAng, bFromVPipe);
    m_ptStart = *lstPt[0];
}


TMultPipeJig::~TMultPipeJig()
{
    if(m_pDrawEnt)
        delete m_pDrawEnt;
}


AcEdJig::DragStatus 
TMultPipeJig::GetPoint(XPoint &pt)
{
    return acquirePoint(pt, m_ptStart.AsAcGePoint3d());
}


int TMultPipeJig::DoIt(int *keyIndex)
{
    int nRet = TSymbEdJig::DoIt(keyIndex);
    return nRet;
}

// 更新实体数据
Adesk::Boolean TMultPipeJig::update()
{
    Adesk::Boolean bRet=Adesk::kTrue;
//  m_ptStart = GetNearPtByLst(m_ptResult, m_pDrawEnt->m_lstOld); cet 2011.5.18 modify
	m_ptStart = *m_pDrawEnt->m_lstOld[0];
    
    m_pDrawEnt->m_ptEnd = m_ptResult;
    return bRet;
}

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

//***************************************************************************************************
//                                        绘制双管
//***************************************************************************************************

TDoublePipeJig::TDoublePipeJig(XPoint pt1, BOOL bIsVPipe, double nWidth)
{
    m_ptStart = pt1; 
    m_ptEnd = pt1;
    m_nWidth = nWidth;
    m_bIsVPipe = bIsVPipe;
    m_pDrawEnt = new TDbDoubleLinePipe;
    m_pDrawEnt->SetStartPoint(m_ptStart);
    m_pDrawEnt->SetEndPoint(m_ptEnd);
    m_pDrawEnt->SetWidth(nWidth);
    m_pDrawEnt->SetDnDiameter(nWidth);
}


TDoublePipeJig::~TDoublePipeJig()
{
    if(m_pDrawEnt)
        delete m_pDrawEnt;
}

AcEdJig::DragStatus 
TDoublePipeJig::GetPoint(XPoint &pt)
{
    if(m_bIsVPipe)
        return acquirePoint(pt);
        
    return acquirePoint(pt, m_ptStart.AsAcGePoint3d());
}


int TDoublePipeJig::DoIt(int *keyIndex)
{
    int nRet = TSymbEdJig::DoIt(keyIndex);
    return nRet;
}

// 更新实体数据
Adesk::Boolean TDoublePipeJig::update()
{
    Adesk::Boolean bRet=Adesk::kTrue;
    m_pDrawEnt->SetWidth(m_nWidth);
    if(m_bIsVPipe){
        XPoint ptEnd = m_ptResult;
        m_pDrawEnt->SetStartPoint(m_ptResult);
        ptEnd.z += 3000;
        m_pDrawEnt->SetEndPoint(ptEnd);
    }
    else
        m_pDrawEnt->SetEndPoint(m_ptResult);
    
    m_pDrawEnt->SetDnDiameter(m_nWidth);
    return bRet;
}

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


void TDimensionEdJig::FindAndRemoveSeg(XPoint pt)
{
    XCurveSegment seg=m_pDrawEnt->GetDimCurve();
	XPoint ptOnSeg;
    seg.ProjectToMe(pt, ptOnSeg);
	double value=seg.StartPoint().Distance2d(ptOnSeg);
	long i=-1;
	if(value>_distSnap)
	{
		double curValue=0;
		for(i=0;i<m_pDrawEnt->GetSegmentNum();i++)
		{
			curValue+=m_pDrawEnt->GetSegment(i);
			if(fabs(curValue-value)<_distSnap)
				break;
		}
	}
	if(i>=m_pDrawEnt->GetSegmentNum())
		return;//useful

	if(i>=0)
	{
		double temp=m_pDrawEnt->GetSegment(i);
		if(i<(m_pDrawEnt->GetSegmentNum()-1))//是中间段
			m_pDrawEnt->SetSegment(i+1,temp+m_pDrawEnt->GetSegment(i+1));//后一段合并之
		m_pDrawEnt->RemoveSegment(i);
	}
	else//第一个标注段的起点（不一定是DimContinue中提示的第一点）特殊处理
	{
		double temp=m_pDrawEnt->GetSegment(0);
		m_pDrawEnt->RemoveSegment(0);
		XVector3D vt=seg.EndPoint()-seg.StartPoint();
		vt.Scale(temp/vt.Length());
		m_pDrawEnt->SetLocation(m_pDrawEnt->GetLocation()+vt);
	}
}
//void TDimensionEdJig::Step()
//{
//	ptStack.Push(m_ptDim);
//}
//bool TDimensionEdJig::CanUndo()
//{
//	return ptStack.GetDepth()>1;
//}
//void TDimensionEdJig::Undo()
//{
//	XPoint pt;
//	ptStack.GetTopData(pt);
//	ptStack.GoBack();
//	if(CanUndo())
//		m_pDrawEnt->FindAndRemoveSegment(pt);
//}
//XPoint TDimensionEdJig::GetLastPoint()
//{
//	XPoint pt;
//	ptStack.GetTopData(pt);
//	return pt;

//end 

void TDimensionEdJig::Swap()
{
    if(m_pTemp) {
        AcDbDeepCloneFiler filer;
        if(m_pTemp->dwgOut(&filer)==Acad::eOk) {
            filer.seek(0L,0);
            VERIFY(m_pDrawEnt->dwgIn(&filer)==Acad::eOk);
        }
        ASSERT(m_pTemp && m_pTemp->IsValid());
    } else {
        m_pTemp = (TDbDimension2 *)m_pDrawEnt->clone();
        ASSERT(m_pTemp && m_pTemp->IsValid());
    }
}

// 转换成ADS代码
int TDimensionEdJig::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;
}


TDimensionEdJig::TDimensionEdJig(TDbDimension2 *pDim, const TCHAR *pszPrompt, const TCHAR *pszKeyword)
:m_pDrawEnt(pDim), m_pszPrompt(pszPrompt),  m_pszKeyword(pszKeyword), m_nRetCode(0)
{
    m_pTemp=NULL;
    m_nFlag=0;
    m_ptDim=pDim->GetLocation();
}

TDimensionEdJig::~TDimensionEdJig()
{
    if(m_pTemp)
        delete m_pTemp;
}

// 开始执行拖动
int TDimensionEdJig::doIt()
{
    setDispPrompt(m_pszPrompt);
        try {
            m_nRetCode = drag();
        } catch(...) {
            m_nRetCode=AcEdJig::kCancel;
        }
     return GetRetCode();
}

// 反馈
AcEdJig::DragStatus TDimensionEdJig::sampler()
{
	DragStatus stat;

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

	if (m_pszKeyword) setKeywordList(m_pszKeyword);
    XPoint ptTemp;
    if(m_nFlag==0) stat=acquirePoint(ptTemp, m_pDrawEnt->GetLocation().AsAcGePoint3d());
    else  if(m_nFlag==1 || m_nFlag==2) stat = acquirePoint(ptTemp);
//    else if(m_nFlag==3) {//modidfied by whl on 03/08/08
//		XPoint ptLast=GetLastPoint();
//        stat=acquirePoint(ptTemp, ptLast);
//    } else if(m_nFlag==4) {
//        XPoint ptLast;
//        xg_getvar("LASTPOINT", ptLast);
//        ptLast = Ucs2Wcs(ptLast);
//        stat=acquirePoint(ptTemp, ptLast);
//	}

    if(stat == AcEdJig::kNormal) {
        if (ptTemp.Distance2d(m_ptDim)>_distSnap) {
            double nDist=m_ptDim.Distance2d(ptTemp);
            m_ptDim=ptTemp;
        }  else 
            return AcEdJig::kNoChange;
    }
 
	return stat;
}

// 更新实体数据
Adesk::Boolean TDimensionEdJig::update()
{
    if(m_nFlag==0) {
        m_pDrawEnt->SetRotation(ads_angle(m_ptDim, m_pDrawEnt->GetLocation())+PI);
        double nVal=m_ptDim.Distance2d(m_pDrawEnt->GetLocation());
        if(m_pDrawEnt->IsValidSegment(nVal))
            m_pDrawEnt->SetSegment(0, nVal);
    } else if(m_nFlag==1) {
        XCurveSegment seg=m_pDrawEnt->GetDimCurve();
        XPoint ptOnSeg;
        if(seg.ProjectToMe(m_ptDim, ptOnSeg)==RTNORM) {
            double nDistMove=m_ptDim.Distance2d(ptOnSeg);
            int nSideLoc=seg.OnWhichSide(m_pDrawEnt->GetLocation());
            int nSide=seg.OnWhichSide(m_ptDim);
            double nDist2Dim=m_pDrawEnt->GetDist2DimLine(FALSE);
            
            if(fabs(nDist2Dim)>1.0E-6) {
                double nFactor=nDist2Dim/fabs(nDist2Dim);
                if(nSide!=nSideLoc) 
                    nDistMove *= nFactor;
                else 
                    nDistMove *= -nFactor;
            } else {
                if(nSideLoc=OFFSET_LEFT) nDistMove=-nDistMove;
                //else nDist2Dim=nDistMove;
            }
         
            if(m_pDrawEnt->IsAngular()) { //弧墙有错，不知道原因
                nDist2Dim += nDistMove; 
                double nDistRad= m_pDrawEnt->GetDimRadius();
                    //seg.GetArc().center.Distance(m_ptDim); 
                nDistRad -= nDistMove;
                if(nDistRad>_distSnap) {
                    m_pDrawEnt->SetDimRadius(nDistRad);
                    m_pDrawEnt->SetDist2DimLine(nDist2Dim, FALSE);
                }
            } else {
                nDist2Dim += nDistMove; 
                m_pDrawEnt->SetDist2DimLine(nDist2Dim, FALSE);
            }

        }
    } else if(m_nFlag==2) { //修改标注位置
        AcDbIntArray indices;
        indices.append(3);
        AcGePoint3dArray ptArray;
        m_pDrawEnt->getStretchPoints(ptArray);
        ASSERT(ptArray.length()>3);
        AcGeVector3d vtOffset=m_ptDim.AsAcGePoint3d()-ptArray[3];
        m_pDrawEnt->moveGripPointsAt(indices, vtOffset);
    } 
//    else if(m_nFlag==3) {//modified by whl on 03/08/08
//        ASSERT(m_pTemp);
//        CopyObject(*m_pDrawEnt, *m_pTemp);
//		if(CanUndo()){
//			if(!m_pTemp->AddSegment(m_ptDim))
//				return Adesk::kFalse;
//		}else{
//			m_pTemp->SetRotation(ads_angle(m_ptDim, m_pTemp->GetLocation())+PI);
//			double nVal=m_ptDim.Distance2d(m_pTemp->GetLocation());
//			if(m_pTemp->IsValidSegment(nVal))
//				m_pTemp->SetSegment(0, nVal);
//		}
//        ASSERT(m_pTemp && m_pTemp->IsValid());
//    } else if(m_nFlag==4) {
//        ASSERT(m_pTemp);
//        CopyObject(*m_pDrawEnt, *m_pTemp);
//		m_pTemp->AddSegment(m_ptDim);
//	}
    ASSERT(m_pDrawEnt && m_pDrawEnt->IsValid());
	return Adesk::kTrue;
}

AcDbEntity* TDimensionEdJig::entity() const
{
    if((m_nFlag==3 || m_nFlag==4) && m_pTemp)
        return m_pTemp;
    else
	    return m_pDrawEnt;
}


//////////////////////////////////////////////////////////////////////////////////////////////////////


TLeaderEdJig::TLeaderEdJig(TDbSymbMultiLeader *pElev)
{
    m_nOperCode=TLeaderEdJig::kNone;
    m_pDrawEnt=pElev;
}

XPoint TLeaderEdJig::GetDragPoint() const
{
    XPoint ptDrag=m_ptResult;
    if(m_nOperCode==TLeaderEdJig::kLeader)
        ptDrag=m_pDrawEnt->GetLeaderPoint();
    else if(m_nOperCode==TLeaderEdJig::kTextLine)
        ptDrag=m_pDrawEnt->GetTextBasePoint();
    return ptDrag;
}

XPoint TLeaderEdJig::GetBasePoint() const
{
    XPoint ptDrag=m_ptResult;
    if(m_nOperCode==TLeaderEdJig::kLeader) {
        XPointList pts;
        m_pDrawEnt->GetLeaderVertexes(pts);
        if(pts.Length())
            ptDrag=*pts[0];
    } else {
        ptDrag=m_pDrawEnt->GetLeaderPoint();
    }
    return ptDrag;
}


// 开始执行拖动
int TLeaderEdJig::DoIt(int *keyIndex)
{
    m_ptResult=GetDragPoint();
    
    XPushVar<int> osmode(_T("OSMODE"), 0);//add by whl
    return TSymbEdJig::DoIt(keyIndex);
}

// 反馈
AcEdJig::DragStatus 
TLeaderEdJig::GetPoint(XPoint &pt)
{
    DragStatus stat;
    if(m_nOperCode==kTextLine)
        stat=acquirePoint(pt);
    else
        stat = acquirePoint(pt, GetBasePoint().AsAcGePoint3d());
    return stat;
}


// 更新实体数据
Adesk::Boolean TLeaderEdJig::update()
{
    Adesk::Boolean bRet=Adesk::kTrue;
    if(m_nOperCode==TLeaderEdJig::kLeader) { 
        XVector3D vtOffset=m_ptResult-GetBasePoint();
		vtOffset.Rotate(-Ucs2Wcs(0.0));// zxl 2013.07.23 add
        m_pDrawEnt->SetLeaderPoint(m_ptResult);
        if(vtOffset.x<0.0) 
            m_pDrawEnt->SetTextBaseLen(-fabs(m_pDrawEnt->GetTextBaseLen()));
        else
            m_pDrawEnt->SetTextBaseLen(fabs(m_pDrawEnt->GetTextBaseLen()));
    } else if(m_nOperCode==TLeaderEdJig::kVertex) {
    } else if(m_nOperCode==TLeaderEdJig::kTextLine) {
        XPoint ptLeader=m_pDrawEnt->GetLeaderPoint();
        m_pDrawEnt->SetTextBaseLen(m_ptResult.x - ptLeader.x, FALSE);
    }
    return bRet;
}

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

TDrawingIdxEdJig::TDrawingIdxEdJig(TDbSymbDrawingIndex *pIdx)
{
    m_pDrawEnt = pIdx;
}

AcEdJig::DragStatus 
TDrawingIdxEdJig::GetPoint(XPoint &pt)
{
	if(!m_ptRef)
		return acquirePoint(pt);
	else
		return acquirePoint(pt, m_ptRef);
}

// 开始执行拖动
int TDrawingIdxEdJig::DoIt(int *keyIndex)
{
    int nRet = TSymbEdJig::DoIt(keyIndex);
    return nRet;
}


// 更新实体数据
Adesk::Boolean TDrawingIdxEdJig::update()
{
    Adesk::Boolean bRet=Adesk::kTrue;
    m_pDrawEnt->SetCenter(m_ptResult);
	return bRet;
}

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