//drawPipe.cpp

#include "stdafx.h"

#include <dbPipeValve.h>
#include <DbEquipment.h>
#include <DbWell.h>
#include <PipeWireMonitor.h>
#include <TipWnd.h>
#include <TAPI.h>
//#include <DbWall.h>
#include <DbPipeCanal.h>

#include "DrawStandPipeDlg.h"
#include "jig.h"
#include "PipeVMultDrawDlg.h"
#include "TwtDef.h"
#include <stack>

extern TELAPI BOOL g_bTgOsnap;

Entity GetVertPipeByPt(XPoint &pt, double &nElevation, int &iPipeSys, double nRadius = 50)
{

    RBList rbMaskPipe(RTDXF0, _T("ATS_PIPE"), 8, GetLayerNames(_T("管")), NULL);
    PickSet ss(SS_FREE);
    XPoint ptUcs = Wcs2Ucs(pt);        
    GetPointPickSet(ptUcs, ss, rbMaskPipe, (int)nRadius);
    if(ss.Length() == 0)
        return Entity();
    //如果发现多个，逐一排查
    if(ss.Length() > 1){
        PickSet ssDel(SS_FREE);
        long len = ss.Length();
        for(long i=0;i<len;i++){
            Entity entTmp = ss[i];
            XPoint pt1 = pt;
            pt1.z = 0;
            OPENOBJ_BEGIN(entTmp, AcDb::kForRead, TDbPipe, pPipe);
            if(pPipe){
                if(!pPipe->IsVertical())
                    ssDel += entTmp;
                XPoint pt2 = pPipe->StartPoint();
                pt2.z = 0;
                if(pt1 != pt2)
                    ssDel += entTmp;
            }
            OPENOBJ_END();        
        }
        ss -= ssDel;
    }
   //zxl 2013.04.18 del 搜到多跟管线 就取第一根
//     if(ss.Length() != 1)
//         return Entity();
    Entity entPipe = ss[0L];
	OPENOBJ_BEGIN(entPipe, AcDb::kForRead, TDbPipe, pPipe);
	if(pPipe){
        nElevation = pPipe->StartPoint().z; 
		CString csLay = pPipe->GetLayer();
		iPipeSys = GetPipeLayerIdxByName(csLay);

       // TPipeSys::SysType sys = pPipe->GetSysType();
       // iPipeSys = GetPipeLayerIdxBySys(sys);
		if(!pPipe->IsVertical())
			return Entity();
        pt = pPipe->GetStartPoint();
	}
	OPENOBJ_END();
//    double x, y;
//    if(!!entPipe)
//        entPipe.GetExtend(pt, &x, &y);
    return entPipe;
}


//已知管线图层名称，返回管线对话框INDEX
int GetPipeDlgIdxByName(const TCHAR* szLayer, int &iPos)
{ 
    CString csLayer;
	csLayer = (const TCHAR*)szLayer;
	
	int ret = 0;
	iPos = 0;
	if(csLayer == LAY_PIPE_FEED || csLayer == LAY_VPIPE_FEED || csLayer == LAY_PIPE_FEED2 || csLayer == LAY_VPIPE_FEED2 || csLayer == LAY_PIPE_FEED3 || csLayer == LAY_VPIPE_FEED3)
	{
		if(csLayer == LAY_PIPE_FEED || csLayer == LAY_VPIPE_FEED)
			iPos = 0;
		else if(csLayer == LAY_PIPE_FEED2 || csLayer == LAY_VPIPE_FEED2)
			iPos = 1;
		else if(csLayer == LAY_PIPE_FEED3 || csLayer == LAY_VPIPE_FEED3)
			iPos = 2;
		ret = 0;
	}
	else if(csLayer == LAY_PIPE_HEADFEED || csLayer == LAY_VPIPE_HEADFEED || csLayer == LAY_PIPE_HEADFEED2 || csLayer == LAY_VPIPE_HEADFEED2 ||csLayer == LAY_PIPE_HEADFEED3 || csLayer == LAY_VPIPE_HEADFEED3)
	{
		if(csLayer == LAY_PIPE_HEADFEED || csLayer == LAY_VPIPE_HEADFEED)
			iPos = 0;
		else if(csLayer == LAY_PIPE_HEADFEED2 || csLayer == LAY_VPIPE_HEADFEED2)
			iPos = 1;
		else if(csLayer == LAY_PIPE_HEADFEED3 || csLayer == LAY_VPIPE_HEADFEED3)
			iPos = 2;
		ret = 1;
	}
	else if(csLayer == LAY_PIPE_HEADBACK || csLayer == LAY_VPIPE_HEADBACK ||csLayer == LAY_PIPE_HEADBACK2 || csLayer == LAY_VPIPE_HEADBACK2 ||csLayer == LAY_PIPE_HEADBACK3 || csLayer == LAY_VPIPE_HEADBACK3)
	{
		if(csLayer == LAY_PIPE_HEADBACK || csLayer == LAY_VPIPE_HEADBACK)
			iPos = 0;
		else if(csLayer == LAY_PIPE_HEADBACK2 || csLayer == LAY_VPIPE_HEADBACK2)
			iPos = 1;
		else if(csLayer == LAY_PIPE_HEADBACK3 || csLayer == LAY_VPIPE_HEADBACK3)
			iPos = 2;
		ret = 2;
	}
	else if(csLayer == LAY_PIPE_DIRT || csLayer == LAY_VPIPE_DIRT)
		ret = 3;
	else if(csLayer == LAY_PIPE_USELESS || csLayer == LAY_VPIPE_USELESS)
		ret = 4;
	else if(csLayer == LAY_PIPE_RAIN || csLayer == LAY_VPIPE_RAIN)
		ret = 5;
	else if(csLayer == LAY_PIPE_USED || csLayer == LAY_VPIPE_USED || csLayer == LAY_PIPE_USED2 || csLayer == LAY_VPIPE_USED2 ||csLayer == LAY_PIPE_USED3 || csLayer == LAY_VPIPE_USED3)
	{
		if(csLayer == LAY_PIPE_USED || csLayer == LAY_VPIPE_USED)
			iPos = 0;
		else if(csLayer == LAY_PIPE_USED2 || csLayer == LAY_VPIPE_USED2)
			iPos = 1;
		else if(csLayer == LAY_PIPE_USED3 || csLayer == LAY_VPIPE_USED3)
			iPos = 2;
		ret = 6;
	}
	else if(csLayer == LAY_PIPE_FIRE || csLayer == LAY_VPIPE_FIRE || csLayer == LAY_PIPE_FIRE2 || csLayer == LAY_VPIPE_FIRE2 ||csLayer == LAY_PIPE_FIRE3 || csLayer == LAY_VPIPE_FIRE3)
	{
		if(csLayer == LAY_PIPE_FIRE || csLayer == LAY_VPIPE_FIRE)
			iPos = 0;
		else if(csLayer == LAY_PIPE_FIRE2 || csLayer == LAY_VPIPE_FIRE2)
			iPos = 1;
		else if(csLayer == LAY_PIPE_FIRE3 || csLayer == LAY_VPIPE_FIRE3)
			iPos = 2;
		ret = 7;
	}
	else if(csLayer == LAY_PIPE_SPRINKLE || csLayer == LAY_VPIPE_SPRINKLE || csLayer == LAY_PIPE_SPRINKLE2 || csLayer == LAY_VPIPE_SPRINKLE2 ||csLayer == LAY_PIPE_SPRINKLE3 || csLayer == LAY_VPIPE_SPRINKLE3)
	{
		if(csLayer == LAY_PIPE_SPRINKLE || csLayer == LAY_VPIPE_SPRINKLE)
			iPos = 0;
		else if(csLayer == LAY_PIPE_SPRINKLE2 || csLayer == LAY_VPIPE_SPRINKLE2)
			iPos = 1;
		else if(csLayer == LAY_PIPE_SPRINKLE3 || csLayer == LAY_VPIPE_SPRINKLE3)
			iPos = 2;
		ret = 8;
	}
    else if(csLayer == LAY_PIPE_COAGULATE || csLayer == LAY_VPIPE_COAGULATE)
        ret = 9;
    else if(csLayer == LAY_PIPE_DRINK || csLayer == LAY_VPIPE_DRINK)
        ret = 10;
    else if(csLayer == LAY_PIPE_PRESSDIRT || csLayer == LAY_VPIPE_PRESSDIRT)
        ret = 11;
    else if(csLayer == LAY_PIPE_PRESSUSELESS || csLayer == LAY_VPIPE_PRESSUSELESS)
        ret = 12;
    else if(csLayer == LAY_PIPE_PRESSRAIN || csLayer == LAY_VPIPE_PRESSRAIN)
        ret = 13;
    else if(csLayer == LAY_PIPE_OTHER || csLayer == LAY_VPIPE_OTHER)
        ret = 14;
    else if(csLayer == LAY_PIPE_USER1 || csLayer == LAY_VPIPE_USER1)
        ret = 15;
    else if(csLayer == LAY_PIPE_USER2 || csLayer == LAY_VPIPE_USER2)
        ret = 16;
	else if (csLayer == LAY_VPIPE_USER3 || csLayer == LAY_PIPE_USER3) // cet 2011.12.1 add 29 - 34
	{
		ret = 29;
	}
	else if (csLayer == LAY_VPIPE_USER4 || csLayer == LAY_PIPE_USER4)
	{
		ret = 30;
	}
	else if (csLayer == LAY_VPIPE_USER5 || csLayer == LAY_PIPE_USER5)
	{
		ret = 31;
	}
	else if (csLayer == LAY_VPIPE_USER6 || csLayer == LAY_PIPE_USER6)
	{
		ret = 32;
	}
	else if (csLayer == LAY_VPIPE_USER7 || csLayer == LAY_PIPE_USER7)
	{
		ret = 33;
	}
	else if (csLayer == LAY_VPIPE_USER8 || csLayer == LAY_PIPE_USER8)
	{
		ret = 34;
	}
	else
		ret = 14;
	return ret;
}

Entity GetVertPipeByPt2(XPoint &pt, int &iPipeSys, int &iPos)
{
    RBList rbMaskPipe(RTDXF0, _T("ATS_PIPE"), 8, GetLayerNames(_T("管")), NULL);
    PickSet ss(SS_FREE);
    XPoint ptUcs = Wcs2Ucs(pt);  
    GetPointPickSet(ptUcs, ss, rbMaskPipe, 50);
    if(ss.Length() == 0){
        GetPointPickSet(ptUcs, ss, rbMaskPipe, 100);
        if(ss.Length() == 0){
            GetPointPickSet(ptUcs, ss, rbMaskPipe, 200);
            if(ss.Length() == 0)
                return Entity();
        }
    }
    if(ss.Length() > 0){
        PickSet ssDel(SS_FREE);
        long len = ss.Length();
        for(long i=0;i<len;i++){
            Entity entTmp = ss[i];
            XPoint pt1 = pt;
            pt1.z = 0;
            OPENOBJ_BEGIN(entTmp, AcDb::kForRead, TDbPipe, pPipe);
            if(pPipe){
                if(!pPipe->IsVertical())
                    ssDel += entTmp;
                else{
                    XPoint pt2 = pPipe->StartPoint();
                    pt2.z = 0;
                    if(pt1 != pt2)
                        ssDel += entTmp;
                }
            }
            OPENOBJ_END();        
        }
        ss -= ssDel;
    }
	long len2 = ss.Length();
    if(ss.Length() == 0)
        return Entity();

    
    Entity entPipe = ss[0L];
    OPENOBJ_BEGIN(entPipe, AcDb::kForRead, TDbPipe, pPipe);
    if(pPipe){
      //  TPipeSys::SysType sys = pPipe->GetSysType();
       // iPipeSys = GetPipeLayerIdxBySys(sys);
		CString csLay = pPipe->GetLayer();
		iPipeSys = GetPipeDlgIdxByName(csLay, iPos);

		pt = pPipe->StartPoint();
    }
    OPENOBJ_END();
//    double x, y;
//    XPoint ptRet;
//    if(!!entPipe)
//        entPipe.GetExtend(pt, &x, &y);
    return entPipe;
}

//得到管线2个端点以及中点
Entity GetPipeByPt2(XPoint pt, double &nElevation, int &iPipeSys, int &iPos)
{
    RBList rbMaskPipe(RTDXF0, _T("ATS_PIPE"), 8, GetLayerNames(_T("管线")), NULL);
    PickSet ss(SS_FREE);
    XPoint ptUcs = Wcs2Ucs(pt);    
    GetPointPickSet(ptUcs, ss, rbMaskPipe, (int)(DocGetPScale()/2));
    double len = ss.Length();
    if(len == 0)
        return Entity();
    else if(len > 1){
        GetPointPickSet(ptUcs, ss, rbMaskPipe, (int)(DocGetPScale()/4));
    }
    if(ss.Length() != 1)
        return Entity();
    Entity entPipe = ss[0L];
    OPENOBJ_BEGIN(entPipe, AcDb::kForRead, TDbPipe, pPipe);
    if(pPipe && !pPipe->IsVertical()){
        nElevation = pPipe->StartPoint().z; 
        TPipeSys::SysType sys = pPipe->GetSysType();
		CString csLay = pPipe->GetLayer();
        iPipeSys = GetPipeDlgIdxByName(csLay, iPos);
    }
    else
        return Entity();
    OPENOBJ_END();
    
    return ss[0L];
}


// COMMAND:  例:
// (setq pt1 (GetPoint))
// (setq pt2 (GetPoint))
// (TPIPE pt1 pt2)
int LispPipe()
{
    resbuf *rb=ads_getargs();
    RBList rbArgs=rb;
    if(rb && rb->restype==RT3DPOINT) {
        XPoint ptStart, ptEnd;
        ptStart = rb->resval.rpoint;

  
        if(rb->rbnext && rb->rbnext->restype==RT3DPOINT) {
            resbuf *rbItem=rb->rbnext;
            ptEnd = rbItem->resval.rpoint;
        }
        ads_relrb(rb);
        if(!!ptStart || !!ptEnd){
            InitPipeLayer(LAY_PIPE_FEED);
            DrawPlanPipeByLayer(ptStart, ptEnd, LAY_PIPE_FEED);
            return RTNORM;
        }
    }
    ads_retnil();
    return RTNORM;
}
 



int GetPipeIdxByEnt(Entity ent)
{
    TCHAR szLay[256];
    ent.GetData(8, szLay);
    CString csLayer = szLay;
    int idx(-1);
    for(int i=0;i<35;i++){  // cet 2011.12.7 modify 比较次数由11改为35
        if(_tcsicmp(csLayer, GetPipeLayerByIdx(i)) == 0){
            idx = i;
            break;
        }
    }
    return idx;
}

//已知2点和dBulge, 根据对话框的数据，绘制这个线段的pipe
void DoDrawPipe(XPoint ptPick1, XPoint ptPick2, double dBulge, CDrawStandPipeDlg &dlg)
{
	dlg.UpdateData();
	InitPipeLayer(dlg.GetLayer());
	int up(0), low(0);
	double nElevation = _tstof(dlg.m_csEle)*1000;
	BOOL ret = GetInterPipeLevel(ptPick1, ptPick2, nElevation, up, low);
	ptPick1.z = nElevation;
	TDbPipe *pPipe = new TDbPipe;
	CString csMat = GetPipeMaterialByIdx(g_iPipeMaterial[dlg.m_iPipeType]);
	CString csDnHead = GetDnByMat(csMat);
				
	if(dlg.m_iPlace == 0 && ret){
		if(up != 256)
			pPipe->SetHideLevel(up);    
		else
			pPipe->SetHideLevel(low);    
	}
	else if(dlg.m_iPlace == 1 && ret){
		if(up != 256)
			pPipe->SetHideLevel(up+1);
		else
			pPipe->SetHideLevel(low+1);
	}
	else if(dlg.m_iPlace == 2 && ret)
		pPipe->SetHideLevel(low-1);
	else
		pPipe->SetHideLevel(0);
	
	pPipe->SetStartPoint(ptPick1);
	pPipe->SetEndPoint(ptPick2);
	if(fabs(dBulge) > 0.001){
		pPipe->SetPoints(ptPick1, ptPick2, dBulge);
	}
	pPipe->setLayer(dlg.GetLayer());
	pPipe->SetModelType(TPipeSys::kModel);
	pPipe->setLinetype(GetPipeWireLayLineType(dlg.GetLayer()));
	pPipe->SetLabel(csDnHead);
	pPipe->SetMaterial(g_iPipeMaterial[dlg.m_iPipeType]);
	pPipe->SetPipeWeight(g_nPipeWidth[dlg.m_iPipeType]);
	pPipe->SetSysType(dlg.GetPipeSysType());
	pPipe->SetRadius(g_nPipeRadius[dlg.m_iPipeType]);
	pPipe->SetDnDiameter(_ttoi(dlg.m_csDn));
	pPipe->setColor(AcCmColor()); //随层
	AddToCurrentSpace(pPipe, Adesk::kTrue);

}

//已知1根AcDbCurve, 根据对话框的数据，绘制这个曲线的pipe
void DoDrawPipe(AcDbCurve *pCurve, CDrawStandPipeDlg &dlg)
{
	AcDbLine *pLine = NULL;
	AcDbArc *pArc = NULL;
	AcDbPolyline *pPolyLine = NULL;
	TDbWall *pWall = NULL;
	if(pLine = AcDbLine::cast(pCurve)){
		XPoint ptStart = pLine->startPoint();
		XPoint ptEnd = pLine->endPoint();
		DoDrawPipe(ptStart, ptEnd, 0, dlg);
	}
	else if(pArc = AcDbArc::cast(pCurve)){
		XPoint ptCen = pArc->center();
		double dRadius = pArc->radius();
		double dStartAng = pArc->startAngle();
		double dEndAng = pArc->endAngle();
		XArc arc(ptCen, dRadius, dStartAng, dEndAng);
		XPoint ptStart, ptEnd;
		arc.GetStartPoint(ptStart);
		arc.GetEndPoint(ptEnd);
		DoDrawPipe(ptStart, ptEnd, arc.Bulge(), dlg);
	}
	else if(pPolyLine = AcDbPolyline::cast(pCurve)){
		AcDbVoidPtrArray entSet;
		pPolyLine->explode(entSet);
		int len = entSet.length();
		for(int i=0;i<len;i++){
			AcDbEntity *pEnt = (AcDbEntity *)entSet[i];
			if(pLine = AcDbLine::cast(pEnt)){
				XPoint ptStart = pLine->startPoint();
				XPoint ptEnd = pLine->endPoint();
				DoDrawPipe(ptStart, ptEnd, 0, dlg);
			}
			else if(pArc = AcDbArc::cast(pEnt)){
				XPoint ptCen = pArc->center();
				double dRadius = pArc->radius();
				double dStartAng = pArc->startAngle();
				double dEndAng = pArc->endAngle();
				XArc arc(ptCen, dRadius, dStartAng, dEndAng);
				XPoint ptStart, ptEnd;
				arc.GetStartPoint(ptStart);
				arc.GetEndPoint(ptEnd);
				DoDrawPipe(ptStart, ptEnd, arc.Bulge(), dlg);
			}
		}
		ReleaseEntSet(entSet);
	}
}

//***************************************************************************************************
//                                        沿线绘管
//***************************************************************************************************
//通过两点把PLINE线切割成两段（PLINE线必须是环形）
static void GetNeedPolylineTy2Pts(const AcDbPolyline &polyLine,XPoint ptSel1,XPoint ptSel2,XPoint ptNotIn,AcDbPolyline &plineOut)
{
	AcGePoint3d ptT1,ptT2;
	double dSeg1 = 0.0,dSeg2 = 0.0,dSegFirst = 0.0,dSegSecond = 0.0;
	polyLine.getParamAtPoint(ptSel1,dSeg1);
	polyLine.getParamAtPoint(ptSel2,dSeg2);

	AcDbPolyline polyLine1,polyLine2;
	int nSpec1 = 0,nSpec2 = 0; //截取点序号
	//找到切割点附近点序号
	for (UINT i = 0; i < polyLine.numVerts()-1; ++i)
	{
		polyLine.getPointAt(i,ptT1);
		polyLine.getPointAt(i+1,ptT2);
		polyLine.getParamAtPoint(ptT1,dSegFirst);
		polyLine.getParamAtPoint(ptT2,dSegSecond);
		
		if ((dSegFirst - dSeg1)*(dSegSecond - dSeg1) < 0)
			nSpec1 = i + 1;
		if ((dSegFirst - dSeg2)*(dSegSecond - dSeg2) < 0)
			nSpec2 = i + 1;
	}

	//构建两条PLINE线
	if (nSpec1 > nSpec2)
	{
		int nCount = 0;
		polyLine1.addVertexAt(nCount,ptSel2);
		nCount++;
		for (int i = nSpec2; i < nSpec1; ++i)
		{
			polyLine.getPointAt(i,ptT1);
			polyLine1.addVertexAt(nCount,ptT1.convert2d(AcGePlane::kXYPlane));
			nCount++;
		}
		polyLine1.addVertexAt(nCount,ptSel1);

		nCount = 0;
		polyLine2.addVertexAt(nCount,ptSel2);
		nCount++;
		for (int j = nSpec2-1; j >= 0; --j)
		{	
			polyLine.getPointAt(j,ptT1);
			polyLine2.addVertexAt(nCount,ptT1.convert2d(AcGePlane::kXYPlane));
			nCount++;
		}
//      cet 2010.5.19 modify 因UINT类型没有负值，无法满足循环条件
//		for (UINT k = polyLine.numVerts()-1; k >= nSpec1; --k)
		for (int k = polyLine.numVerts()-1; k >= nSpec1; --k)
		{
			polyLine.getPointAt(k,ptT1);
			polyLine2.addVertexAt(nCount,ptT1.convert2d(AcGePlane::kXYPlane));
			nCount++;
		}
		polyLine2.addVertexAt(nCount,ptSel1);
	}
	else
	{
		int nCount = 0;
		polyLine1.addVertexAt(nCount,ptSel1);
		nCount++;
		for (int i = nSpec1; i < nSpec2; ++i)
		{
			polyLine.getPointAt(i,ptT1);
			polyLine1.addVertexAt(nCount,ptT1.convert2d(AcGePlane::kXYPlane));
			nCount++;
		}
		polyLine1.addVertexAt(nCount,ptSel2);
		
		nCount = 0;
		polyLine2.addVertexAt(nCount,ptSel1);
		nCount++;
		for (int j = nSpec1-1; j >= 0; --j)
		{
			polyLine.getPointAt(j,ptT1);
			polyLine2.addVertexAt(nCount,ptT1.convert2d(AcGePlane::kXYPlane));
			nCount++;
		} 

//      cet 2010.5.19 modify 因UINT类型没有负值，无法满足循环条件
//      for (UINT k = polyLine.numVerts()-1; k >= nSpec2; --k)
		for (int k = polyLine.numVerts()-1; k >= nSpec2; --k)
		{
			polyLine.getPointAt(k,ptT1);
			polyLine2.addVertexAt(nCount,ptT1.convert2d(AcGePlane::kXYPlane));
			nCount++;
		}
		polyLine2.addVertexAt(nCount,ptSel2);
	}

	//找到需要的PLINE线
	XPoint ptClose;
	polyLine1.getClosestPointTo(ptNotIn,ptClose);
	if (ptClose.Distance(ptNotIn) < 1e-3 && polyLine2.numVerts() > 0)
	{
		polyLine2.getPointAt(0,ptT1);
		if (ptSel1.Distance(ptT1) < 1e-3)
		{
			for (UINT i = 0; i < polyLine2.numVerts(); ++i)
			{
				polyLine2.getPointAt(i,ptT1);
				plineOut.addVertexAt(i,ptT1.convert2d(AcGePlane::kXYPlane));
			}
		}
		else
		{
		//  cet 2010.5.19 modify 因UINT类型没有负值，无法满足循环条件
		//	for (UINT i = polyLine2.numVerts()-1; i >= 0 ; --i)
			for (int i = polyLine2.numVerts()-1; i >= 0 ; --i)
			{
				polyLine2.getPointAt(i,ptT1);
				plineOut.addVertexAt(polyLine2.numVerts()-1-i,ptT1.convert2d(AcGePlane::kXYPlane));
			}
		}
	}
	else if (ptClose.Distance(ptNotIn) > 1e-3 && polyLine1.numVerts() > 0)
	{
		polyLine1.getPointAt(0,ptT1);
		if (ptSel1.Distance(ptT1) < 1e-3)
		{
			for (UINT i = 0; i < polyLine1.numVerts(); ++i)
			{
				polyLine1.getPointAt(i,ptT1);
				plineOut.addVertexAt(i,ptT1.convert2d(AcGePlane::kXYPlane));
			}
		}
		else
		{
		//  cet 2010.5.19 modify 因UINT类型没有负值，无法满足循环条件
		//	for (UINT i = polyLine1.numVerts()-1; i >= 0 ; --i)
			for (int i = polyLine1.numVerts()-1; i >= 0 ; --i)
			{
				polyLine1.getPointAt(i,ptT1);
				plineOut.addVertexAt(polyLine1.numVerts()-1-i,ptT1.convert2d(AcGePlane::kXYPlane));
			}
		}	
	}
}

static AcDbPolyline* CreatePLineBy2Wall(const XCurveSegment &seg1,const XCurveSegment &seg2,Entity idCol,Entity ent1,Entity ent2,const XPoint &ptPick1,const XPoint &ptPick2,const XCurveSegment &seg)
{
	XPoly2D polyColum;
	XPoint ptCen;
	AcGePoint3dArray arPt;
	XPoint ptSel1,ptSel2;//柱子上需要切的两点
	//得到墙的PLINE线
	AcDbPolyline *pWLine1= NULL; 
	AcDbPolyline *pWLine2= NULL;
	XPoint ptNotIn;  //用于判断切割柱子的哪一块
	OPENOBJ_BEGIN(idCol,AcDb::kForRead,TDbColumn,pColum);
	if (pColum != NULL)
	{
		pColum->GetOutline(polyColum);
		
		//得到柱子上需要切割的两点
		ptCen = pColum->GetLocation();
		if (ptCen.Distance2d(seg1.StartPoint()) < ptCen.Distance2d(seg1.EndPoint()))
		{
			ptSel1 = seg1.StartPoint();
			ptNotIn = seg.StartPoint();
		}
		else
		{
			ptSel1 = seg1.EndPoint();
			ptNotIn = seg.EndPoint();
		}
		
		if (ptCen.Distance2d(seg2.StartPoint()) < ptCen.Distance2d(seg2.EndPoint()))
			ptSel2 = seg2.StartPoint();
		else
			ptSel2 = seg2.EndPoint();
		
		pWLine1 = GetNextPloyLine(ent1,ent1,ptPick1,ptSel1);
		pWLine2 = GetNextPloyLine(ent2,ent2,ptSel2,ptPick2);
		//得到两点的PLINE
		AcDbPolyline polyLine,pline;
		PolyConvert(polyColum,polyLine);

		//通过两点把PLINE线切割成两段（PLINE线必须是环形）
		GetNeedPolylineTy2Pts(polyLine,ptSel1,ptSel2,ptNotIn,pline);
		
		AcGePoint3d ptT1;
		//组合PLINE线
		int nCount = pWLine1->numVerts();
		for (UINT i = 0;i < pline.numVerts(); ++i)
		{
			pline.getPointAt(i,ptT1);
			pWLine1->addVertexAt(nCount,ptT1.convert2d(AcGePlane::kXYPlane));
			nCount++;
		}
 
		for (int j = 0; j < pWLine2->numVerts(); ++j)
		{
			pWLine2->getPointAt(j,ptT1);
			pWLine1->addVertexAt(nCount,ptT1.convert2d(AcGePlane::kXYPlane));
			nCount++;
		}	
	}
	OPENOBJ_END();

	delete pWLine2;
	return pWLine1;
}

//得到的PLINE线必须在外面DELETE
static AcDbPolyline* GetNextWallLine(Entity ent1,Entity ent2,const XPoint &ptPick1,const XPoint &ptPick2)
{
	AcDbPolyline *pLine = NULL;
	bool bCon = FALSE;
	Entity idCol;
	XCurveSegment seg1,seg2;
	XPoly2D poly1,poly2;
	OPENOBJ_BEGIN(ent1,AcDb::kForRead,TDbWall,pWall1);
	if (pWall1 != NULL)
	{
		OPENOBJ_BEGIN(ent2,AcDb::kForRead,TDbWall,pWall2);
		if (pWall2 != NULL)
		{
			//得到两墙的PLINE线
			XCurveSegment lCurve, rCurve, seg;
			XPoint ptNew1, ptNew2;
			pWall1->GetSideCurve(lCurve, rCurve);
			lCurve.ProjectToMe(ptPick1, ptNew1);
			rCurve.ProjectToMe(ptPick1, ptNew2);
			if(ads_distance(ptPick1, ptNew1) < ads_distance(ptPick1, ptNew2))
			{
				seg1 = lCurve;
				seg = rCurve;
			}
			else
			{
				seg1 = rCurve;
				seg = lCurve;
			}

			pWall2->GetSideCurve(lCurve, rCurve);
			lCurve.ProjectToMe(ptPick2, ptNew1);
			rCurve.ProjectToMe(ptPick2, ptNew2);
			if(ads_distance(ptPick2, ptNew1) < ads_distance(ptPick2, ptNew2))
				seg2 = lCurve;
			else
				seg2 = rCurve;

			pWall1->close();
			pWall2->close();
			
			//找到柱子
			RBList rbMask(RTDXF0, _T("ATS_COLUMN"),  NULL);
			PickSet ss1(SS_FREE);
			PickSet ss2(SS_FREE);

			struct resbuf *pointlist1,*pointlist2;
			pointlist1 = ads_buildlist(RTPOINT, &seg1.StartPoint(), RTPOINT, &seg1.EndPoint(), NULL); 
			pointlist2 = ads_buildlist(RTPOINT, &seg2.StartPoint(), RTPOINT, &seg2.EndPoint(), NULL); 
			ss1.Get(_T("F"), pointlist1, NULL, rbMask);
			ss2.Get(_T("F"), pointlist2, NULL, rbMask);
            ads_relrb(pointlist1);
			ads_relrb(pointlist2);
			
			
			//得到柱子的ID
			for (long i = 0; i < ss1.Length(); ++i)
			{
				for (long j = 0; j < ss2.Length(); ++j)
				{
					if (ss1[i] == ss2[j])
					{
						bCon = true;
						idCol = ss1[i];
						break;
					}
				}
			}

			//两墙连接
			if (bCon)
			{
				//创建两墙的PLINE线
				pLine = CreatePLineBy2Wall(seg1,seg2,idCol,ent1,ent2,ptPick1,ptPick2,seg);
			}
		}
		OPENOBJ_END();
	}
	OPENOBJ_END();

	return pLine;
}

void CmdPipeByLine()
{
	int nOsMode=0;
    xg_getvar(_T("OSMODE"), &nOsMode);
	if(g_bTgOsnap)
	{
		nOsMode &= ~0x4000;
		nOsMode |= OS_INT|OS_NEA|OS_PER|OS_END|OS_CEN;
	}
    XPushVar<int> vOsMode(_T("OSMODE"), nOsMode);
	
	long len = g_ssPickFirst.Length();
	int iFisrtIdx(-1);
    if(len == 1){
        Entity entFirst = g_ssPickFirst[0L];
        iFisrtIdx = GetPipeIdxByEnt(entFirst);
    }
    
	CDrawStandPipeDlg dlg(0, acedGetAcadFrame());  
    {
		if(iFisrtIdx > -1)
			dlg.m_iPipeType = iFisrtIdx;
		CTemporaryResourceOverride vTemp;
		dlg.Create(IDD_STAND_PIPE, acedGetAcadFrame());
    }
	dlg.ShowWindow(SW_SHOW);
	acedGetAcadDwgView()->SetFocus();
	
	XPoint ptPick1, ptPick2, ptOnCurve;
 
	double nElevation(0);
    Entity entLastPipe;
    int iRet;
    INITGET_BEG(0, _T("R"));
	iRet = ads_getpoint(NULL, _T("\n请点取管线的起始点（注意，点取靠近线的一侧，不要点在线上）[输入参考点(R)]<退出>:"), ptPick1);
    ptPick1 = Ucs2Wcs(ptPick1);
    INITGET_END();
    if(iRet != RTNORM && iRet != RTKWORD){
        dlg.DestroyWindow();
        return;
    }
    if(iRet == RTKWORD){
		if(ads_getpoint(NULL,_T("\n请输入参考点:"), ptPick1) != RTNORM){
            dlg.DestroyWindow();
            return;
        }
        double nXDist(0), nYDist(0);
        ptPick1 = Ucs2Wcs(ptPick1);
		ads_getpoint(ptPick1, _T("\n请输入距参考点的距离<确定>:"), ptPick1);
        ptPick1 = Ucs2Wcs(ptPick1);
    }       
	Entity entLine;
	RBList rbMask(RTDXF0, _T("LINE,ARC,ATS_WALL"),  NULL);
	if(SelectEntity1(0.3, _T("\n请拾取布置管线需要沿的直线、弧线、墙线 <退出>"), entLine, ptPick2, rbMask) != RTNORM){
		dlg.DestroyWindow();
		return;
	}
	ptPick2 = Ucs2Wcs(ptPick2);

	PickSet ssPoint(SS_FREE);
	GetPointPickSet(ptPick1, ssPoint, rbMask);
	if(ssPoint.Length() == 1){
		if(entLine == ssPoint[0L]){
			adsout << _T("\n操作有误，请先点取管线起始点，再选取所要沿的线！");
			dlg.DestroyWindow();
			return;
		}
	}

	XPushVar<int> vOsMode2(_T("OSMODE"), 0);
	
	double dOffsetDist(0);
	OPENOBJ_BEGIN(entLine, AcDb::kForRead, AcDbCurve, pCurve);
	if(pCurve){
		TDbWall *pWall = NULL;
		AcDbCurve *pWallCurve = NULL;
		if(pWall = TDbWall::cast(pCurve)){
			XCurveSegment lCurve, rCurve, seg;
			XPoint ptNew1, ptNew2;
			pWall->GetSideCurve(lCurve, rCurve);
			lCurve.ProjectToMe(ptPick2, ptNew1);
			rCurve.ProjectToMe(ptPick2, ptNew2);
			if(ads_distance(ptPick2, ptNew1) < ads_distance(ptPick2, ptNew2))
				seg = lCurve;
			else
				seg = rCurve;
			pWallCurve = seg.AsAcDbCurve();
		}

		XPoint ptOnCurve1, ptOnCurve2;
		if(pWallCurve != NULL)
			pWallCurve->getClosestPointTo(ptPick1, ptOnCurve1);
		else
			pCurve->getClosestPointTo(ptPick1, ptOnCurve1);

		dOffsetDist = ads_distance(ptPick1, ptOnCurve1);
		CString csText;
		csText.Format(_T("\n请输入距线距离<%.f>"), dOffsetDist);
		ads_getreal(csText, &dOffsetDist);
		AcGeVector3d vt(ptPick1 - ptOnCurve1);
		vt.normalize();
		vt *= dOffsetDist;
		AcGeMatrix3d mat;
		mat.setToTranslation(vt);
		ptOnCurve1.TransformBy(mat);
		if(dOffsetDist < 0.001){
			adsout << _T("\n不能距线距离为0");
			dlg.DestroyWindow();
			if(pWallCurve != NULL)
				delete pWallCurve;
			return;
		}
		AcDbCurve *pCurve2 = NULL;
		if(pWallCurve != NULL)
			pCurve2 = GetOffsetCurve(pWallCurve, dOffsetDist, ptOnCurve1);
		else
			pCurve2 = GetOffsetCurve(pCurve, dOffsetDist, ptOnCurve1);
		if(pWallCurve != NULL)
			delete pWallCurve;
		
		//AcDbCurve *pCurve2 = GetOffsetCurve(pCurve, dOffsetDist, ptOnCurve1);
		if(pCurve2 != NULL){
			pCurve2->getClosestPointTo(ptPick2, ptOnCurve2);
			ptOnCurve = ptOnCurve2;
			AcDbCurve *pCurve3 = GetCurveBy2Pt(pCurve2, ptOnCurve1, ptOnCurve2);
			delete pCurve2;
			if(pCurve3 != NULL){
				DoDrawPipe(pCurve3, dlg);
				delete pCurve3;
			}
		}

	}
	OPENOBJ_END();
	if(entLine.Is(_T("LWPOLYLINE"))){
		dlg.DestroyWindow();
		return;
	}
	ptPick1 = ptPick2;
	Entity entLine2;
	while(SelectEntity1(0.3, _T("\n请拾取下一段PLINE、直线、弧线 <退出>"), entLine2, ptPick2, rbMask) == RTNORM){
		ptPick2 = Ucs2Wcs(ptPick2);
 
		//临时创建1条PLINE线，反复调用InsWellByCurve
		AcDbPolyline *pLine = GetNextPloyLine(entLine, entLine2, ptPick1, ptPick2);
		
		if (pLine == NULL)
			pLine = GetNextWallLine(entLine,entLine2,ptPick1,ptPick2);
		
		if(pLine != NULL)
		{
		
			AcDbCurve *pCurveOffset = GetOffsetCurve((AcDbCurve *)pLine, dOffsetDist, ptOnCurve);

			if(pCurveOffset != NULL)
			{
				DoDrawPipe(pCurveOffset, dlg);
				pCurveOffset->getClosestPointTo(ptPick2, ptOnCurve);
				delete pCurveOffset;
			}
			pLine->getClosestPointTo(ptPick2, ptPick2);
			delete pLine;
			ptPick1 = ptPick2;
			entLine = entLine2;
		}
		else
		{
			break;
		}
	}
	dlg.DestroyWindow();
}

//***************************************************************************************************
//                                        绘制管线
//***************************************************************************************************
BOOL GetInterArcPipeLevel(XArc arc, double nElevation, int &up, int &low)
{
    RBList rbMaskPipe(RTDXF0, _T("ATS_PIPE"), 8, GetLayerNames(_T("管线")), NULL);
    PickSet ss(SS_FREE);

	XCurveSegment seg;
	seg = arc;
	XPoly2D xPline;
	seg.AsPoly2D(xPline);
	XPoint pt1, pt2;
	pt1 = *xPline[0];
	xPline.Length();
	pt2 = *xPline[xPline.Length()-1];
	AssureInCurrentView(pt1, pt2);
	xPline.TransUCS(Groups(0),Groups(1)); // 把 UCS 转为 WCS
	RBList rbPoint = xPline.Polygon();
	ss.Get(_T("F"), rbPoint, NULL, rbMaskPipe);
	
	
    BOOL ret = FALSE;
    up = 256;
    low = 256;
   
//    struct resbuf *pointlist;
//	XLine line(pt1, pt2);
//	line.Make();
//    pointlist = ads_buildlist(RTPOINT, &pt1, RTPOINT, &pt2, NULL); 
//    ss.Get(_T("F"), pointlist, NULL, rbMaskPipe);
//    ads_relrb(pointlist);
    for(long i=0;i<ss.Length();i++){
        Entity ent = ss[i];
        OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
        if(pPipe && !pPipe->IsVertical()){
            nElevation = pPipe->StartPoint().z; 
            if(up < pPipe->GetHideLevel() || up == 256)
                up = pPipe->GetHideLevel();
            if(low > pPipe->GetHideLevel() || low == 256)
                low = pPipe->GetHideLevel();
            ret = TRUE;
        }
        OPENOBJ_END();
    }
    return ret;
}

  
#include "OutDimSettingDlg.h"
#include"TGAs.h"
void test()
{
	CodeBase db;
    XString fullFile;
    if(!FindFile(_T("上华标准材质.dbf"), fullFile))
	{
        AfxMessageBox(_T("对不起，没有发现上华标准材质.dbf文件！"));
        return;
    }

    XDbfTable *pTable = db.Open(fullFile);
    if(!pTable) 
	{
        return;
	}
	
	int nId = 1;
	int nType = -1;
    for(pTable->MoveFirst();!pTable->IsEOF();pTable->MoveNext())
	{
		GET_FIELD(pTable, _T("type"), nType);
		if (nType == 0)
		{
			SET_FIELD(pTable, _T("id"), nId++);
		}
		else if (nType == 1)
		{
			SET_FIELD(pTable, _T("id"), -1);
		}
	}

	return;

	XPoint ptStart, ptEnd;
	if(ads_getpoint(NULL,_T("\n请输入起点:"), ptStart) != RTNORM){
		return;
	}
	if(ads_getpoint(ptStart, _T("\n请输入距参考点的距离<确定>:"), ptEnd)!= RTNORM){
		return;
	}
	TDbPipeCanal *pPipe2 = new TDbPipeCanal;
	pPipe2->SetStartPoint(ptStart);
	pPipe2->SetEndPoint(ptEnd);
	pPipe2->SetDoteLayer(InitLayer(LAY_TWT_DOTE));
    pPipe2->setLinetype(_T("CONTINUOUS"));
	pPipe2->SetPipeWeight(g_nPipeWidth[0]);
    pPipe2->SetModelType(TPipeSys::kModel);
    pPipe2->SetMaterial(0);
    pPipe2->SetWidth(500);
    pPipe2->SetHeight(600);
	pPipe2->setColor(AcCmColor()); //随层
	AddToCurrentSpace(pPipe2, Adesk::kTrue);
				
}

void CmdPipe()
{
	xg_setvar(_T("CMDECHO"), 0);
	int nOsMode=0;
    xg_getvar(_T("OSMODE"), &nOsMode);
	if(g_bTgOsnap)
	{
		nOsMode &= ~0x4000;
		nOsMode |= OS_INT|OS_NEA|OS_PER|OS_END|OS_CEN;
	}
    XPushVar<int> vOsMode(_T("OSMODE"), nOsMode);
	double dCeltScale = 1;
    xg_getvar(_T("CELTSCALE"), &dCeltScale);

  
    long len = g_ssPickFirst.Length();
    int iFisrtIdx(-1);
    if(len == 1){
        Entity entFirst = g_ssPickFirst[0L];
        iFisrtIdx = GetPipeIdxByEnt(entFirst);
    }
    
    CTemporaryResourceOverride vTemp;
	CDrawStandPipeDlg dlg(0, acedGetAcadFrame());  
    {
		if(iFisrtIdx > -1) 
			dlg.m_iPipeType = iFisrtIdx;
		//cet 2011.12.6 add 设置默认选择管线类型
		if (iFisrtIdx >= 0 && iFisrtIdx <= 8)
		{
			dlg.m_iPipeType2 = iFisrtIdx;
			dlg.m_iPipeType3 = 9;
		}
		else if (iFisrtIdx >= 9 && iFisrtIdx <= 16 
			|| iFisrtIdx >= 29 && iFisrtIdx <= 34)
		{
			dlg.m_iPipeType2 = 9;
			dlg.m_iPipeType3 = iFisrtIdx;
		}
		dlg.Create(IDD_STAND_PIPE, acedGetAcadFrame());
    }
	dlg.ShowWindow(SW_SHOW);
	acedGetAcadDwgView()->SetFocus();
 
	XPoint ptPick1, ptPick2;
	double nElevation(0);
    Entity entLastPipe;
    int iRet;
    INITGET_BEG(0, _T("R"));
	iRet = ads_getpoint(NULL, _T("\n请点取管线的起始点[输入参考点(R)]<退出>:"), ptPick1);
    ptPick1 = Ucs2Wcs(ptPick1);
    INITGET_END();
    if(iRet != RTNORM && iRet != RTKWORD){
        dlg.DestroyWindow();
        return;
    }
    if(iRet == RTKWORD){
		if(ads_getpoint(NULL,_T("\n请输入参考点:"), ptPick1) != RTNORM){
            dlg.DestroyWindow();
            return;
        }
        double nXDist(0), nYDist(0);
     // ptPick1 = Ucs2Wcs(ptPick1);  cet 2011.8.26 del 无需转换本来就是需要ucs点
		ads_getpoint(ptPick1, _T("\n请输入距参考点的距离<确定>:"), ptPick1);
        ptPick1 = Ucs2Wcs(ptPick1);
    }    
    double dMeter(1);
	if(!DocGetMeterUnitDraw())
		dMeter = 1000;

	// cet 2012.3.13 add 更新对话框数据
	dlg.UpdateData();

    XPointList lstPt;
	Entity entPipeRef;
	CString csDnType;

	double dFisrtEle(-1);
    int iPipeIdx(-1), iPos(-1);
	if(!GetEquipmentByPt(ptPick1)){
        if(!GetWellByPt(ptPick1, iPipeIdx))
		    if(!GetVertPipeByPt2(ptPick1, iPipeIdx, iPos))
			    entPipeRef = GetPipeByPt2(ptPick1, nElevation, iPipeIdx, iPos);
			else // cet 2013.2.26 add 起始点在立管上，管径设置为初始设置中的默认管径值
			{
				dlg.m_csDn.Format(_T("%d"), g_iDefaultPipeDn);
				dlg.UpdatePipeDn(FALSE);
			}
	}
    else{
		dlg.UpdateData(TRUE);
        dlg.m_csEle.Format(_T("%.3f"), ptPick1.z/dMeter);
        dlg.UpdateData(FALSE);
    }
    if(iPipeIdx > -1){
		int iDn(25);
		//2008－5－26 自动读取上1段管线的管径和DN类型
		OPENOBJ_BEGIN(entPipeRef, AcDb::kForRead, TDbPipe, pPipe);
		if(pPipe){
			iDn = (int)pPipe->GetDnDiameter();
			csDnType = pPipe->GetLabel();
			dFisrtEle = nElevation;
		}
		OPENOBJ_END();
		// cet 2013.2.26 modify entPipeRef有效时设置管径
		if (!!entPipeRef)
		{
			dlg.m_csDn.Format(_T("%d"), iDn);
		    dlg.UpdatePipeDn(FALSE); // cet 2012.8.31 add 更新管径控件当前值
		}
		
        dlg.m_iPipeType = iPipeIdx;
		// cet 2011.12.6 add
		if (iPipeIdx >= 0 && iPipeIdx <= 8)
		{
			dlg.m_iPipeType2 = iPipeIdx;
//			dlg.m_iPipeType3 = 9;  cet 2012.10.19 del 当前选择不变
		}
		else if (iPipeIdx >= 9 && iPipeIdx <= 16 
			    || iPipeIdx >= 29 && iPipeIdx <= 34)
		{
			dlg.m_iPipeType2 = 9;
			dlg.m_iPipeType3 = iPipeIdx;
		}

		if(iPos < 0)
			iPos = 0;
		dlg.m_iPos = iPos;
		
//      dlg.m_csEle.Format(_T("%.3f"), ptPick1.z/dMeter); // cet 2010.6.24 del

		// cet 2010.6.24 add
		bool bRead = dlg.IsGetEle(); // cet 2010.6.23 add 是否自动读取前一管线标高
		if (bRead)
		{
			dlg.m_csEle.Format(_T("%.3f"), ptPick1.z/dMeter);
		}

		dlg.ResetShowRadio();
		dlg.ResetRegion();
//      dlg.UpdateData(FALSE);
		// cet 2010.6.24 del
//		CWnd *pWnd1 = dlg.GetDlgItem(IDC_EDIT_ELEVATION);
//		pWnd1->SetWindowText(dlg.m_csEle);

		// cet 2010.6.24 add
		if (bRead)
		{
			CWnd *pWnd1 = dlg.GetDlgItem(IDC_EDIT_ELEVATION);
			pWnd1->SetWindowText(dlg.m_csEle);
		}
		else
		{
			CWnd *pWnd1 = dlg.GetDlgItem(IDC_EDIT_ELEVATION);
			CString strEle;
			pWnd1->GetWindowText(strEle);
			nElevation = _tstof(strEle) * 1000;
		}
	  //cet 2011.12.1 del 
	  //dlg.CheckRadioButton(IDC_RADIO_PIPETYPE1, IDC_RADIO_PIPETYPE19, IDC_RADIO_PIPETYPE1+iPipeIdx);
		dlg.CheckRadioButton(IDC_RADIO_POS1, IDC_RADIO_POS3, IDC_RADIO_POS1+iPos);
		dlg.UpdateData(FALSE); // cet 2011.12.7 add 更新对话框数据
		dlg.UpdateDimText();   // cet 2011.12.14 add 更新标注文字
    }
    else{
        ptPick1.z = _tstof(dlg.m_csEle)*dMeter;//空点pick1.z = 0, 实际应该从对话框读取上次标高。
    }
    lstPt.Append(new XPoint(ptPick1));
    XPoint ptJig = ptPick1;
    ptJig.z = 0;//必须保证JIG的z为0
	TPipeEdJig jig(ptJig, ptJig, 0.5);
	jig.SetDlg(&dlg); // cet 2011.7.27 add
	CString csPrompt;
	//cet 2012.3.16 增加关键字T用于轴锁其他角度设置
    //jig.SetKeyword(_T("A S D G R U J W Y Z F X H V L")); // cet 2011.8.2 modify  增加关键字L用于控制角度盘是否显示
	jig.SetKeyword(_T("A S D G R U J W Y Z F X H V L T"));
	//adsout << _T("\n[给水(J)/污水(W)/废水(F)/雨水(Y)/中水(Z)/消防(X)/喷淋(H)]");// zxl 2013.10.15 del 删除无用提示信息
	int nKeyIndex;
	AcGeVector3d vt = AcGeVector3d::kXAxis; // cet 2011.8.1 add 记录上次绘制管线方向
	vt.rotateBy(Ucs2Wcs(0.0), AcGeVector3d::kZAxis);
	bool bKey = false; // cet 2011.8.1 add  jig上一个操作是否为关键字, 控制是否刷新
	int nKeyNum = 0;   // cet 2011.8.2 add  连续按关键字的次数，用于控制是否刷新
	// cet 2012.3.16 add 使用角度盘时，重设刻度
	if (dlg.IsLockAngle())
	{
		jig.SetWatchAngle(dlg.GetAngleFromMenu());
	}

	while(1){
		if (!bKey)
		{
			acedRedraw(NULL, 0);	//	cet 2011.7.27 add 刷新
		}

		// cet 2012.3.16 add 对话框可向cad发送命令关键字，以相应jig
		dlg.EnableSendKeyToCAD(TRUE);

        dlg.UpdateData(TRUE);
		jig.m_ptRef = ptPick1;
        jig.m_ptRef.z = 0;  
    	csPrompt.Format(_T("\n请点取管线的终止点[轴锁0度(A)/轴锁30度(S)/轴锁45度(D)/选取行向线(G)/弧管线(R)/回退(U)]<结束> (当前标高:%.0f):"), nElevation);
		jig.SetPrompt(csPrompt);
        jig.m_bInit = TRUE;//保证第一次执行一下acquirePoint(pt, m_ptRef)
		int ret = jig.DoIt(&nKeyIndex);
	 
		if(ret != RTNORM && ret != RTKWORD){
			SHads_command(RTNONE);
			break;
		}
		if(ret == RTNORM){
			bKey = false;  // cet 2011.8.1 add
			nKeyNum = 0;   // cet 2011.8.2 add
			dlg.UpdateData(TRUE);
            jig.m_pPipe->SetPipeWeight(g_nPipeWidth[dlg.m_iPipeType]);
			nElevation = _tstof(dlg.m_csEle)*dMeter;
			ptPick2 = jig.m_ptPick;
            if(ptPick1 == ptPick2)
				continue;
			
            //首先判断是否从设备上引出
			Entity entEq = GetEquipmentByPt(ptPick2);
            if(!entEq){
                ptPick2 = jig.GetCorrectPt();
            }
            else{
                //设备默认标高为0，如果接管标高！＝0， 而且设备还未接管，则强制修改设备标高
                OPENOBJ_BEGIN(entEq, AcDb::kForWrite, TDbEquipment, pEquip);
                if(pEquip){
                    int num = pEquip->GetInterfaceNum();
                    if(num == 0){
                        XPoint ptLoc = pEquip->GetLocation();
                        ptLoc.z = nElevation;
                        pEquip->SetLocation(ptLoc);
                    }
                }
                OPENOBJ_END();
            }
            ptPick2.z = nElevation;
            if(jig.m_nLockAng > 0 && !jig.m_bLock){
                jig.m_nLockAng = 0;
                jig.m_bLock = TRUE;
            }
			lstPt.Append(new XPoint(ptPick2));
			SHads_command(RTSTR, _T(".UNDO"), RTSTR, _T("MARK"), RTNONE); // Make a undo mark
			InitPipeLayer(dlg.GetLayer());
			iPipeIdx = GetPipeLayerIdxByName(dlg.GetLayer());
			CString csMat = GetPipeMaterialByIdx(g_iPipeMaterial[iPipeIdx]);
			CString csDnHead = GetDnByMat(csMat);
            
			//2009-8-3 增加后面的判断
			//lstPt.Length() > 2 连续绘制中变标高
			//lstPt.Length() == 2 第一次绘制，如果跟参考管线有标高差
			if((fabs(ptPick1.z - nElevation) > 0.00001 && lstPt.Length() > 2 ) || (fabs(ptPick1.z - nElevation) > 0.00001 && lstPt.Length() == 2 && fabs(ptPick1.z - dFisrtEle) < 0.00001 ) ) { //与上一根管线有高差
				TDbPipe *pPipe2 = new TDbPipe;
				pPipe2->SetStartPoint(ptPick1);
				ptPick1.z = nElevation;
				pPipe2->SetEndPoint(ptPick1);
                pPipe2->setLinetype(_T("CONTINUOUS"));
                if(!g_bStandPipeArc)//传统扣弯
                   pPipe2->SetRadiusIn(-2);
				pPipe2->setLayer(dlg.GetLayer());
				pPipe2->SetLabel(csDnType);
				pPipe2->SetPipeWeight(g_nPipeWidth[iPipeIdx]);
				pPipe2->SetSysType(dlg.GetPipeSysType());
                pPipe2->SetModelType(TPipeSys::kModel);
				pPipe2->SetLabel(csDnHead);
                pPipe2->SetMaterial(g_iPipeMaterial[iPipeIdx]);
				pPipe2->SetRadius(g_nPipeRadius[dlg.m_iPipeType]);
                pPipe2->SetDnDiameter(_ttoi(dlg.m_csDn));
				pPipe2->setColor(AcCmColor()); //随层
				AddToCurrentSpace(pPipe2, Adesk::kTrue);
			}
            int up(0), low(0);
            BOOL ret = GetInterPipeLevel(ptPick1, ptPick2, nElevation, up, low);
			ptPick1.z = nElevation;
			TDbPipe *pPipe = new TDbPipe;
            if(dlg.m_iPlace == 0 && ret){
                if(up != 256)
                    pPipe->SetHideLevel(up);    
                else
                    pPipe->SetHideLevel(low);    
            }
            else if(dlg.m_iPlace == 1 && ret){
                if(up != 256)
                    pPipe->SetHideLevel(up+1);
                else
                    pPipe->SetHideLevel(low+1);
            }
            else if(dlg.m_iPlace == 2 && ret)
                pPipe->SetHideLevel(low-1);
            else
                pPipe->SetHideLevel(0);

			pPipe->SetStartPoint(ptPick1);
			pPipe->SetEndPoint(ptPick2);
			// 2008.10.27 自动修正上华带文字线型的逆向管线
			CString csLineType = GetPipeWireLayLineType(dlg.GetLayer());
			// 2011.7.8 sr GetPipeWireLayLineType有时候会返回byLayer
			CString csLineType2 = GetLayerLineType(dlg.GetLayer());
			if(csLineType2.Find(_T("TG")) > -1)
			{
				XLine line(ptPick1, ptPick2);
				double nAng = line.Direction();
				if(nAng > PI/2 && nAng < (PI/2*3 + 0.001)){
					pPipe->SetStartPoint(ptPick2);
					pPipe->SetEndPoint(ptPick1);
				}
			}
			pPipe->setLayer(dlg.GetLayer());
			pPipe->SetLabel(csDnType);
			
            pPipe->SetModelType(TPipeSys::kModel);
            pPipe->setLinetype(csLineType);  
			pPipe->setLinetypeScale(dCeltScale);
            pPipe->SetMaterial(g_iPipeMaterial[iPipeIdx]);
			pPipe->SetLabel(csDnHead);
			pPipe->SetPipeWeight(g_nPipeWidth[iPipeIdx]);
			pPipe->SetSysType(dlg.GetPipeSysType());
			pPipe->SetRadius(g_nPipeRadius[iPipeIdx]);
            pPipe->SetDnDiameter(_ttoi(dlg.m_csDn));
			pPipe->setColor(AcCmColor()); //随层
			// cet 2011.8.1 add 
			vt = pPipe->EndPoint() - pPipe->StartPoint();
			vt.normalize();
			jig.SetPipeDir(vt);

			AddToCurrentSpace(pPipe, Adesk::kTrue);
            entLastPipe.GetLast();
			ptPick1 = ptPick2;
            ptJig = ptPick2;
            ptJig.z = 0;
			jig.SetStartPoint(ptJig);
			TPipePerDocData *pData = GetCurPipeDocData();
			pData->ApplyUpdates();

		}
		else if(ret == RTKWORD){
			if (bKey && nKeyNum == 0 || nKeyIndex == 4 || nKeyIndex == 14)
			{
				acedRedraw(NULL, 0);	// cet 2011.8.1 add 刷新
				if (nKeyIndex == 14)
				{
					// cet 2012.3.16 add 重绘角度盘
					if (dlg.IsLockAngle())
					{
						jig.SetWatchAngle(dlg.GetAngleFromMenu());
						jig.RedrawWatch();
					}
					else
					{
						jig.m_iUnit = 0;
					}
					continue;
				}
			}
			bKey = true;            // cet 2011.8.1 add
			++nKeyNum;				// cet 2011.8.2 add
            if(nKeyIndex==0){
                jig.m_iUnit = 0;
				// cet 2012.3.16 禁用角度盘
				dlg.EnableLockAngle(FALSE); 
				dlg.UpdateData(FALSE);  
				acedRedraw(NULL, 0);

                if(fabs(jig.m_nLockAng) > 0.001){
                    jig.m_nLockAng = 0;
                    jig.m_bLock = TRUE;
                }
            }
			else if(nKeyIndex==1)
			{
				jig.m_iUnit = 30; 
				dlg.SelectAngleMenuItem(30); // cet 2012.3.16 add 更新角度菜单选项
				if (dlg.IsLockAngle())       // cet 2012.3.16 add 根据当前刻度重新绘制角度盘
				{
					jig.SetWatchAngle(30);		
				    jig.RedrawWatch();			 
				}
			}
			else if(nKeyIndex==2) 
			{
				jig.m_iUnit = 45;
				dlg.SelectAngleMenuItem(45); // cet 2012.3.16 add 更新角度菜单选项
				if (dlg.IsLockAngle())       // cet 2012.3.16 add 根据当前刻度重新绘制角度盘
				{
					jig.SetWatchAngle(45);		
					jig.RedrawWatch();			 
				}
			}
            else if(nKeyIndex==3){ //选取行向线
				// cet 2012.3.16 禁用角度盘
				dlg.EnableLockAngle(FALSE); 
				dlg.UpdateData(FALSE);  
				jig.m_iUnit = 0.0;

                double s_angle(0);
                int err_value=get_line_angle(s_angle); 
                if(err_value == RTNORM){
                    if(s_angle > (PI+0.001))
                        s_angle -= PI;
                    jig.m_ptRef = ptPick1;
                    jig.m_nLockAng = s_angle;
                    jig.m_bLock = FALSE;
                }
            }
            else if(nKeyIndex==4){ //弧
				vt = AcGeVector3d::kXAxis; // cet 2011.8.1 add
				vt.rotateBy(Ucs2Wcs(0.0), AcGeVector3d::kZAxis); // cet 2011.8.2 add
                XPoint ptArcEnd, ptArcMid, ptPick0, ptArcEnd0;
				if(ads_getpoint(Wcs2Ucs(ptPick1), _T("\n弧线终点<退出>:"), ptArcEnd) != RTNORM)
                    break;
				ptArcEnd = Ucs2Wcs(ptArcEnd);
                ptArcEnd.z = 0;
                ptPick1.z = 0;
                ptPick0 = ptPick1;
                ptArcEnd0 = ptArcEnd;
                TPipeEdJig jig2(ptPick0, ptArcEnd);
				jig2.SetPrompt(_T("\n点取弧上一点:"));
                if(jig2.DoIt() != RTNORM){
                    dlg.DestroyWindow();
                    break;
                }
                ptArcMid = jig2.GetPickPoint();
                dlg.UpdateData(TRUE);
                nElevation = _tstof(dlg.m_csEle)*dMeter;
                ptPick1.z = nElevation;
                ptArcEnd.z = nElevation;

                InitPipeLayer(dlg.GetLayer());
				int iPipeIdx = GetPipeLayerIdxByName(dlg.GetLayer());
				CString csMat = GetPipeMaterialByIdx(g_iPipeMaterial[iPipeIdx]);
				CString csDnHead = GetDnByMat(csMat);
				
				
                TDbPipe *pPipe = new TDbPipe;
                XArc arc(ptPick0, ptArcMid, ptArcEnd0);
                XPoint ptArcS, ptArcE;
				arc.GetStartPoint(ptArcS);
				arc.GetEndPoint(ptArcE);

				//2009-1-8 支持弧管置上置下
				int up(0), low(0);
				BOOL ret = GetInterArcPipeLevel(arc, nElevation, up, low);
				if(dlg.m_iPlace == 0 && ret){
					if(up != 256)
						pPipe->SetHideLevel(up);    
					else
						pPipe->SetHideLevel(low);    
				}
				else if(dlg.m_iPlace == 1 && ret){
					if(up != 256)
						pPipe->SetHideLevel(up+1);
					else
						pPipe->SetHideLevel(low+1);
				}
				else if(dlg.m_iPlace == 2 && ret)
					pPipe->SetHideLevel(low-1);
				else
					pPipe->SetHideLevel(0);
				
 
                if(ptPick0 == ptArcS)
                    pPipe->SetPoints(ptPick1, ptArcEnd, arc.Bulge());
                else
                    pPipe->SetPoints(ptArcEnd, ptPick1, arc.Bulge());
//                if(ptPick0 == ptArcS) sr 2009-1-8 用下面的方法，offset是反的
//                    pPipe->SetPoints(ptPick1, ptArcEnd, arc.Bulge());
//                else
//                    pPipe->SetPoints(ptPick1, ptArcEnd, -arc.Bulge());
                pPipe->setLayer(dlg.GetLayer());
				pPipe->SetLabel(csDnType);
                pPipe->setLinetype(GetPipeWireLayLineType(dlg.GetLayer()));
                pPipe->SetModelType(TPipeSys::kModel);
				pPipe->SetLabel(csDnHead);
                pPipe->SetMaterial(g_iPipeMaterial[iPipeIdx]);
                pPipe->SetPipeWeight(g_nPipeWidth[iPipeIdx]);
                pPipe->SetSysType(dlg.GetPipeSysType());
                pPipe->SetRadius(g_nPipeRadius[iPipeIdx]);
                pPipe->SetDnDiameter(_ttoi(dlg.m_csDn));
                pPipe->setColor(AcCmColor()); //随层
                AddToCurrentSpace(pPipe, Adesk::kTrue);
                ptPick1 = ptArcEnd;
                ptJig = ptArcEnd;
                ptJig.z = 0;
                jig.SetStartPoint(ptJig);
                TPipePerDocData *pData = GetCurPipeDocData();
                pData->ApplyUpdates();
            }
			else if(nKeyIndex==5){
				int len = lstPt.Length();
				if(len == 1) continue;  //最后一个, 不能再退了
				SHads_command(RTSTR, _T("UNDO"), RTSTR, _T("BACK"), RTNONE);
				lstPt.Remove(len - 1);
				XPoint ptTemp = *lstPt[len - 2];
				jig.SetStartPoint(ptTemp);
				ptPick1 = ptTemp;
				acedRedraw(NULL, 0); // cet 2012.3.16 add 刷新
			}
            else if(nKeyIndex==6){//J jig.SetKeyword(_T("A S D G R U J W Y Z F X H V"));
                dlg.UpdateData(TRUE);
                dlg.m_iPipeType = 0;
                dlg.UpdateData(FALSE);
                continue;
            }
            else if(nKeyIndex==7){//W  
                dlg.UpdateData(TRUE);
                dlg.m_iPipeType = 3;
                dlg.UpdateData(FALSE);
                continue;
            }
            else if(nKeyIndex==8){//Y 
                dlg.UpdateData(TRUE);
                dlg.m_iPipeType = 5;
                dlg.UpdateData(FALSE);
                continue;
            }
            else if(nKeyIndex==9){//Z 
                dlg.UpdateData(TRUE);
                dlg.m_iPipeType = 6;
                dlg.UpdateData(FALSE);
                continue;
            }
            else if(nKeyIndex==10){//F 
                dlg.UpdateData(TRUE);
                dlg.m_iPipeType = 4;
                dlg.UpdateData(FALSE);
                continue;
            }
            else if(nKeyIndex==11){//X 
                dlg.UpdateData(TRUE);
                dlg.m_iPipeType = 7;
                dlg.UpdateData(FALSE);
                continue;
            }
            else if(nKeyIndex==12){//H 
                dlg.UpdateData(TRUE);
                dlg.m_iPipeType = 8;
                dlg.UpdateData(FALSE);
                continue;
            }
			else if (nKeyIndex == 15)//T 轴锁其他角度值设置 cet 2012.3.16 add
			{
				dlg.UpdateData(TRUE);
				if (dlg.IsLockAngle())
				{
					double dAngle = dlg.GetAngleFromMenu();
					jig.m_iUnit = dAngle;
					jig.SetWatchAngle(dAngle); // 重新设置角度盘角度
					jig.RedrawWatch();		   // 根据当前刻度重新绘制角度盘
				}
			}
            else
			{
                continue;
			}
		}
	}
	dlg.DestroyWindow(); 
	acedRedraw(NULL, 0);	// cet 2011.8.1 add 刷新
}

//***************************************************************************************************
//                                        绘制多管
//***************************************************************************************************
XPoint GetMidPtByLst(XPointList &lstPtIn)
{
    XPoint ptRet;
    int iNum = lstPtIn.Length();
    double nLong(0);
	for(int i=0; i<iNum-1; i++){
        XPoint ptTmp1 = *lstPtIn[i];
	    for(int j=0; j<iNum; j++){
            XPoint ptTmp2 = *lstPtIn[j];
            XLine line(ptTmp1, ptTmp2, 1);
            if(line.GetLength() > nLong){
                line.MidPoint(ptRet);
                nLong = line.GetLength();
            }
        }
    }
    return ptRet;
}

XPoint GetNearPtByLst(XPoint pt, XPointList &lstPtIn)
{
    pt.z = 0;
    XPoint ptRet;
    int iNum = lstPtIn.Length();
    double nLong(-1);
	for(int i=0; i<iNum; i++){
        XPoint ptTmp = *lstPtIn[i];
        ptTmp.z = 0;
        double n = ads_distance(pt, ptTmp);
        if(nLong < 0 || nLong > n){
            nLong = n;
            ptRet = ptTmp;
        }
    }
    return ptRet;
}

BOOL LstDemoDisplayPoint(XPointList &lstPtIn, XPointList &lstPtOut, double dAngle, BOOL bFree = FALSE)
{
	int itype;
	double dAng, dDis;
	XPoint ptStart, ptEnd, ptTurn, ptstart, ptend, ptMid;
	XPointList lstStart, lstEnd;
	int iNum = lstPtIn.Length();

   
    int nOsMode=0;
    xg_getvar(_T("ORTHOMODE"), &nOsMode);
    
    XPointList lstTmp;
	BOOL bFisrt = TRUE;
	while(1){
		struct resbuf pointbuf;
		int iRet = ads_grread(5, &itype, &pointbuf);//得到动态点pointbuf
		ads_point_set(pointbuf.resval.rpoint, ptEnd);//ptTurn动态点,也就是引出支线的结束点
		if(itype != 5 && bFisrt)
			continue;
		ads_redraw(NULL, 1);                       //不画线演示
		if(itype == 11 || itype == 2)    // 11右键取消 2:空格，回车
			return FALSE;
		else if(itype == 5 || itype == 3){
			lstStart.Reset();
			lstEnd.Reset();
			bFisrt = FALSE;
            ptMid = GetNearPtByLst(ptEnd, lstPtIn);
            dAng = ads_angle(ptMid, ptEnd);
            dDis = fabs(ads_distance(ptMid, ptEnd));
 
            XPoint ptEndTmp = ptEnd;
            if(bFree && nOsMode == 1){//实现正交
                int Ang = (int)Radian2Angle(dAng);
                int nTmp = Ang % 90;
                int multiple = Ang / 90;
                if(nTmp > 45){
                    dAng = 90 * (multiple + 1);
                }
                else{
                    dAng = 90 * multiple;
                }
                dAng = dAng / 180 * PI;
                dDis = fabs(ads_distance(ptMid, ptEnd)*cos(ads_angle(ptMid, ptEnd) - dAng));
                ads_polar(ptMid, dAng, dDis, ptEndTmp);
            }
            

			for(int i=0; i<iNum; i++){
				ptTurn = *lstPtIn[i];//ptTurn引出线起点
                if(!bFree){
                    XPoint ptEndTmp;
                    int Ang = (int)Radian2Angle(dAng);
                    int nTmp = Ang % 90;
                    int multiple = Ang / 90;
                    if(nTmp > 45){
                        dAng = 90 * (multiple + 1);
                    }
                    else{
                        dAng = 90 * multiple;
                    }
                    dAng = dAng / 180 * PI;
                    dDis = fabs(ads_distance(ptTurn, ptEnd)*cos(ads_angle(ptTurn, ptEnd) - dAng));
                    ads_polar(ptTurn, dAng, dDis, ptEndTmp);
                    
                    if(itype == 5)
				        ads_grdraw(ptTurn, ptEndTmp, -1, 0);    //演示
                    else
                        lstPtOut.NewAppend(ptEndTmp);
                }
                else{
                    XPoint ptTmpEnd = ptEndTmp;
                    double nAngTmp = dAng;
                    if(ptMid != ptTurn){
                        double n = ads_distance(ptTurn, ptMid); //2管线距离
                        double nAn = ads_angle(ptMid, ptTurn);
                        if(fabs(nAn - PI*2) < 0.001 || nAn > PI*2)
                            nAn -= PI*2;

                        if(dAngle < (PI/2-1) || dAngle > PI/2*3 || fabs(dAngle - PI/2*3) < 0.001){
                            if(nAn < PI)
                                nAngTmp += PI/2;
                            else
                                nAngTmp -= PI/2;
                        }
                        else{
                            if(nAn > PI || fabs(nAn - PI) < 0.001)
                                nAngTmp += PI/2;
                            else
                                nAngTmp -= PI/2;
                        }

                        if(nAngTmp > PI*2)
                            nAngTmp -= PI*2;
                        ads_polar(ptEndTmp, nAngTmp, n, ptTmpEnd);
                        ads_polar(ptMid, nAngTmp, n, ptTurn);
                    }
                    if(itype == 5)
                        ads_grdraw(ptTurn, ptTmpEnd, -1, 0);    //演示
                    else{
                        lstTmp.NewAppend(ptTurn);
                        lstPtOut.NewAppend(ptTmpEnd);
                    }
                }
			}
            if(itype == 3){
                if(bFree){
                    lstPtIn.Reset();
                    lstPtIn = lstTmp;
                }
                return TRUE;
            }
		}
		
	}
	return FALSE;
}

void DrawSuperposablePipe(CPipeVMultDrawDlg *pDlg)
{
    XPoint ptStart, ptEnd;
	if(ads_getpoint(NULL, _T("\n请点取起点<退出>:"), ptStart) != RTNORM)
        return;
    ptStart = Ucs2Wcs(ptStart);
    while(1){
		if(ads_getpoint(ptStart, _T("\n请点取终点<退出>:"), ptEnd) != RTNORM)
            return;

        for(pDlg->m_grid.MoveToFirst(); !pDlg->m_grid.IsOut(); pDlg->m_grid.MoveToNext()){
            WDGridRow *pRow = pDlg->m_grid.CurRow();
            CString csPipe = (*pRow)[0].GetText().cs();
            CString csDist = (*pRow)[1].GetText().cs();
            CString csEle = (*pRow)[2].GetText().cs();
      
            int idx(0);
            if(csPipe == _T("给水"))
                idx = 0;
            else if(csPipe == _T("热给水"))
                idx = 1;
            else if(csPipe == _T("热回水"))
                idx = 2;
            else if(csPipe == _T("污水"))
                idx = 3;
            else if(csPipe == _T("废水"))
                idx = 4;
            else if(csPipe == _T("中水"))
                idx = 6;
            else if(csPipe == _T("消防"))
                idx = 7;
            else if(csPipe == _T("喷淋"))
                idx = 8;
            else if(csPipe == g_csPipeName[0])
                idx = 9;
            else if(csPipe == g_csPipeName[1])
                idx = 10;
            else if(csPipe == g_csPipeName[2])
                idx = 11;
            else if(csPipe == g_csPipeName[3])
                idx = 12;
            else if(csPipe == g_csPipeName[4])
                idx = 13;
            else if(csPipe == _T("其它"))
                idx = 14;
			CString csMat = GetPipeMaterialByIdx(g_iPipeMaterial[idx]);
			CString csDnHead = GetDnByMat(csMat);
			
            TDbPipe *pPipe=new TDbPipe;
            ptStart.z = _tstof(csEle)*1000;
            ptEnd.z = _tstof(csEle)*1000;
            pPipe->SetStartPoint(ptStart);
            pPipe->SetEndPoint(ptEnd);
            InitPipeLayer(GetPipeLayerByIdx(idx));
            pPipe->setLayer(GetPipeLayerByIdx(idx));
            pPipe->setLinetype(GetPipeWireLayLineType(GetPipeLayerByIdx(idx)));
            pPipe->SetModelType(TPipeSys::kModel);
			pPipe->SetLabel(csDnHead);
            pPipe->SetDnDiameter(g_iDefaultPipeDn);
            pPipe->SetMaterial(g_iPipeMaterial[idx]);
            pPipe->SetPipeWeight(g_nPipeWidth[idx]);
            pPipe->SetRadius(g_nPipeRadius[idx]);
            if(g_bPipeDouble[idx])
                pPipe->SetRadiusIn(g_nPipeRadius[idx] / 2);
            pPipe->setColor(AcCmColor()); //随层
            AcDbObjectId id = AddToCurrentSpace(pPipe, Adesk::kTrue);
        }
        ptStart = ptEnd;
    }
}

//已知管线类别INDEX，返回立管线图层名称
CString GetVPipeLayerByIdx(int iLayer)
{
    //if(iLayer > 29 || iLayer < 0)
	if(iLayer > 34 || iLayer < 0)
        return CString();
    CString csLayer[] = {LAY_VPIPE_FEED, LAY_VPIPE_HEADFEED, LAY_VPIPE_HEADBACK, LAY_VPIPE_DIRT,
		LAY_VPIPE_USELESS, LAY_VPIPE_RAIN, LAY_VPIPE_USED, LAY_VPIPE_FIRE, LAY_VPIPE_SPRINKLE,
		LAY_VPIPE_COAGULATE, LAY_VPIPE_DRINK, LAY_VPIPE_PRESSDIRT, LAY_VPIPE_PRESSUSELESS, 
		LAY_VPIPE_PRESSRAIN, LAY_VPIPE_OTHER, LAY_VPIPE_USER1, LAY_VPIPE_USER2, 
		LAY_VPIPE_FEED2,LAY_VPIPE_FEED3, LAY_VPIPE_HEADFEED2,LAY_VPIPE_HEADFEED3,
		LAY_VPIPE_HEADBACK2,LAY_VPIPE_HEADBACK3,LAY_VPIPE_FIRE2,LAY_VPIPE_FIRE3,
		LAY_VPIPE_SPRINKLE2,LAY_VPIPE_SPRINKLE3,LAY_VPIPE_USED2,LAY_VPIPE_USED3,
		LAY_VPIPE_USER3, LAY_VPIPE_USER4, LAY_VPIPE_USER5, LAY_VPIPE_USER6, LAY_VPIPE_USER7, // cet 2011.12.8 add user3-user8
		LAY_VPIPE_USER8
	};
	return csLayer[iLayer];
}

// zxl 2013.04.17 add 通过立管图层获取该管线图层名
CString GetLayerName(const CString &strLayer)
{
	CString sName;
	if (strLayer.Compare(LAY_VPIPE_FEED) == 0) //给水 
	{
		sName = _T("给水管");
	}
	else if (strLayer.Compare(LAY_VPIPE_FEED2) == 0) //给水中
	{
		sName = _T("给水中区管");
	}
	else if (strLayer.Compare(LAY_VPIPE_FEED3) == 0) //给水高
	{
		sName = _T("给水高区管");
	}
	else if (strLayer.Compare(LAY_VPIPE_HEADFEED) == 0) //热给水 
	{
		sName = _T("热给水管");
	} 
	else if (strLayer.Compare(LAY_VPIPE_HEADFEED2) == 0) 
	{
		sName = _T("热给水中区管");
	} 
	else if (strLayer.Compare(LAY_VPIPE_HEADFEED3) == 0)
	{
		sName = _T("热给水高区管");
	} 
	else if (strLayer.Compare(LAY_VPIPE_HEADBACK) == 0) //热回水
	{
		sName = _T("热回水管");
	}
	else if (strLayer.Compare(LAY_VPIPE_HEADBACK2) == 0) //热回水
	{
		sName = _T("热回水中区管");
	}
	else if (strLayer.Compare(LAY_VPIPE_HEADBACK3) == 0) //热回水
	{
		sName = _T("热回水高区管");
	}
	else if (strLayer.Compare(LAY_VPIPE_DIRT) == 0) //污水
	{
		sName = _T("污水管");
	}
	else if (strLayer.Compare(LAY_VPIPE_USELESS) == 0) //废水
	{
		sName = _T("废水管");
	}
	else if (strLayer.Compare(LAY_VPIPE_RAIN) == 0) //雨水
	{
		sName = _T("雨水管");
	}
	else if (strLayer.Compare(LAY_VPIPE_USED) == 0) //中水
	{
		sName = _T("中水管");
	}
	else if (strLayer.Compare(LAY_VPIPE_USED2) == 0) //中水
	{
		sName = _T("中水中区管");
	}
	else if (strLayer.Compare(LAY_VPIPE_USED3) == 0) //中水
	{
		sName = _T("中水高区管");
	}
	else if (strLayer.Compare(LAY_VPIPE_FIRE) == 0) //消防
	{
		sName = _T("消防管");
	}
	else if (strLayer.Compare(LAY_VPIPE_FIRE2) == 0) //消防
	{
		sName = _T("消防中区管");
	}
	else if (strLayer.Compare(LAY_VPIPE_FIRE3) == 0) //消防
	{
		sName = _T("消防高区管");
	}
	else if (strLayer.Compare(LAY_VPIPE_SPRINKLE) == 0) //喷淋
	{
		sName = _T("喷淋管");
	}
	else if (strLayer.Compare(LAY_VPIPE_SPRINKLE2) == 0) //喷淋
	{
		sName = _T("喷淋中区管");
	}
	else if (strLayer.Compare(LAY_VPIPE_SPRINKLE3) == 0) //喷淋
	{
		sName = _T("喷淋高区管");
	}
	else if (strLayer.Compare(LAY_VPIPE_COAGULATE) == 0) //凝结水
	{
		GetLayerReMark(LAY_PIPE_COAGULATE, sName);
		if (sName.IsEmpty())
		{
			sName = _T("凝结水管");
		}
		else
		{
			sName += _T("水管");
		}
	}
	else if (strLayer.Compare(LAY_VPIPE_DRINK) == 0) //直饮水
	{
		GetLayerReMark(LAY_PIPE_DRINK, sName);
		if (sName.IsEmpty())
		{
			sName = _T("直饮水管");
		}
		else
		{
			sName += _T("水管");
		}
	}
	else if (strLayer.Compare(LAY_VPIPE_PRESSDIRT) == 0) //压力污水
	{
		GetLayerReMark(LAY_PIPE_PRESSDIRT, sName);
		if (sName.IsEmpty())
		{
			sName = _T("压力污水管");
		}
		else
		{
			sName += _T("水管");
		}
	}
	else if (strLayer.Compare(LAY_VPIPE_PRESSUSELESS) == 0) //压力废水
	{
		GetLayerReMark(LAY_PIPE_PRESSUSELESS, sName);
		if (sName.IsEmpty())
		{
			sName = _T("压力废水管");
		}
		else
		{
			sName += _T("水管");
		}
	}
	else if (strLayer.Compare(LAY_VPIPE_PRESSRAIN) == 0) //压力雨水
	{
		GetLayerReMark(LAY_PIPE_PRESSRAIN, sName);
		if (sName.IsEmpty())
		{
			sName = _T("压力雨水管");
		}
		else
		{
			sName += _T("水管");
		}
	}
	else if (strLayer.Compare(LAY_VPIPE_OTHER) == 0) //其他
	{
		sName = _T("其它管");
	}
	else if (strLayer.Compare(LAY_VPIPE_USER1) == 0)
	{
		GetLayerReMark(LAY_PIPE_USER1, sName);
		if (sName.IsEmpty())
		{
			sName = _T("用1管线");
		}
		else
		{
			sName += _T("管");
		}
	}
	else if (strLayer.Compare(LAY_VPIPE_USER2) == 0)
	{
		GetLayerReMark(LAY_PIPE_USER2, sName);
		if (sName.IsEmpty())
		{
			sName = _T("用户2管线");
		}
		else
		{
			sName += _T("管");
		}
	}
	else if (strLayer.Compare(LAY_VPIPE_USER3) == 0) 
	{
		GetLayerReMark(LAY_PIPE_USER3, sName);
		if (sName.IsEmpty())
		{
			sName = _T("用户3管线");
		}
		else
		{
			sName += _T("管");
		}
	}
	else if (strLayer.Compare(LAY_VPIPE_USER4) == 0) 
	{
		GetLayerReMark(LAY_PIPE_USER4, sName);
		if (sName.IsEmpty())
		{
			sName = _T("用户4管线");
		}
		else
		{
			sName += _T("管");
		}
	}
	else if (strLayer.Compare(LAY_VPIPE_USER5) == 0) 
	{
		GetLayerReMark(LAY_PIPE_USER5, sName);
		if (sName.IsEmpty())
		{
			sName = _T("用户5管线");
		}
		else
		{
			sName += _T("管");
		}
	}
	else if (strLayer.Compare(LAY_VPIPE_USER6) == 0) 
	{
		GetLayerReMark(LAY_PIPE_USER6, sName);
		if (sName.IsEmpty())
		{
			sName = _T("用户6管线");
		}
		else
		{
			sName += _T("管");
		}
	}
	else if (strLayer.Compare(LAY_VPIPE_USER7) == 0) 
	{
		GetLayerReMark(LAY_PIPE_USER7, sName);
		if (sName.IsEmpty())
		{
			sName = _T("用户7管线");
		}
		else
		{
			sName += _T("管");
		}
	}
	else if (strLayer.Compare(LAY_VPIPE_USER8) == 0) 
	{
		GetLayerReMark(LAY_PIPE_USER8, sName);
		if (sName.IsEmpty())
		{
			sName = _T("用户8管线");
		}
		else
		{
			sName += _T("管");
		}
	}

	return sName;
}

// zxl 2013.04.23 add 通过管线图层获取该管线图层名
CString GetPipeLayerName(const CString &strLayer)
{
	CString sName;
	if (strLayer.Compare(LAY_PIPE_FEED) == 0) //给水 
	{
		sName = _T("给水管");
	}
	else if (strLayer.Compare(LAY_PIPE_FEED2) == 0) //给水中
	{
		sName = _T("给水中区管");
	}
	else if (strLayer.Compare(LAY_PIPE_FEED3) == 0) //给水高
	{
		sName = _T("给水高区管");
	}
	else if (strLayer.Compare(LAY_PIPE_HEADFEED) == 0) //热给水 
	{
		sName = _T("热给水管");
	} 
	else if (strLayer.Compare(LAY_PIPE_HEADFEED2) == 0) 
	{
		sName = _T("热给水中区管");
	} 
	else if (strLayer.Compare(LAY_PIPE_HEADFEED3) == 0)
	{
		sName = _T("热给水高区管");
	} 
	else if (strLayer.Compare(LAY_PIPE_HEADBACK) == 0) //热回水
	{
		sName = _T("热回水管");
	}
	else if (strLayer.Compare(LAY_PIPE_HEADBACK2) == 0) //热回水
	{
		sName = _T("热回水中区管");
	}
	else if (strLayer.Compare(LAY_PIPE_HEADBACK3) == 0) //热回水
	{
		sName = _T("热回水高区管");
	}
	else if (strLayer.Compare(LAY_PIPE_DIRT) == 0) //污水
	{
		sName = _T("污水管");
	}
	else if (strLayer.Compare(LAY_PIPE_USELESS) == 0) //废水
	{
		sName = _T("废水管");
	}
	else if (strLayer.Compare(LAY_PIPE_RAIN) == 0) //雨水
	{
		sName = _T("雨水管");
	}
	else if (strLayer.Compare(LAY_PIPE_USED) == 0) //中水
	{
		sName = _T("中水管");
	}
	else if (strLayer.Compare(LAY_PIPE_USED2) == 0) //中水
	{
		sName = _T("中水中区管");
	}
	else if (strLayer.Compare(LAY_PIPE_USED3) == 0) //中水
	{
		sName = _T("中水高区管");
	}
	else if (strLayer.Compare(LAY_PIPE_FIRE) == 0) //消防
	{
		sName = _T("消防管");
	}
	else if (strLayer.Compare(LAY_PIPE_FIRE2) == 0) //消防
	{
		sName = _T("消防中区管");
	}
	else if (strLayer.Compare(LAY_PIPE_FIRE3) == 0) //消防
	{
		sName = _T("消防高区管");
	}
	else if (strLayer.Compare(LAY_PIPE_SPRINKLE) == 0) //喷淋
	{
		sName = _T("喷淋管");
	}
	else if (strLayer.Compare(LAY_PIPE_SPRINKLE2) == 0) //喷淋
	{
		sName = _T("喷淋中区管");
	}
	else if (strLayer.Compare(LAY_PIPE_SPRINKLE3) == 0) //喷淋
	{
		sName = _T("喷淋高区管");
	}
	else if (strLayer.Compare(LAY_PIPE_COAGULATE) == 0) //凝结水
	{
		GetLayerReMark(LAY_PIPE_COAGULATE, sName);
		if (sName.IsEmpty())
		{
			sName = _T("凝结水管");
		}
		else
		{
			sName += _T("水管");
		}
	}
	else if (strLayer.Compare(LAY_PIPE_DRINK) == 0) //直饮水
	{
		GetLayerReMark(LAY_PIPE_DRINK, sName);
		if (sName.IsEmpty())
		{
			sName = _T("直饮水管");
		}
		else
		{
			sName += _T("水管");
		}
	}
	else if (strLayer.Compare(LAY_PIPE_PRESSDIRT) == 0) //压力污水
	{
		GetLayerReMark(LAY_PIPE_PRESSDIRT, sName);
		if (sName.IsEmpty())
		{
			sName = _T("压力污水管");
		}
		else
		{
			sName += _T("水管");
		}
	}
	else if (strLayer.Compare(LAY_PIPE_PRESSUSELESS) == 0) //压力废水
	{
		GetLayerReMark(LAY_PIPE_PRESSUSELESS, sName);
		if (sName.IsEmpty())
		{
			sName = _T("压力废水管");
		}
		else
		{
			sName += _T("水管");
		}
	}
	else if (strLayer.Compare(LAY_PIPE_PRESSRAIN) == 0) //压力雨水
	{
		GetLayerReMark(LAY_PIPE_PRESSRAIN, sName);
		if (sName.IsEmpty())
		{
			sName = _T("压力雨水管");
		}
		else
		{
			sName += _T("水管");
		}
	}
	else if (strLayer.Compare(LAY_PIPE_OTHER) == 0) //其他
	{
		sName = _T("其它管");
	}
	else if (strLayer.Compare(LAY_PIPE_USER1) == 0)
	{
		GetLayerReMark(LAY_PIPE_USER1, sName);
		if (sName.IsEmpty())
		{
			sName = _T("用1管线");
		}
		else
		{
			sName += _T("管");
		}
	}
	else if (strLayer.Compare(LAY_PIPE_USER2) == 0)
	{
		GetLayerReMark(LAY_PIPE_USER2, sName);
		if (sName.IsEmpty())
		{
			sName = _T("用户2管线");
		}
		else
		{
			sName += _T("管");
		}
	}
	else if (strLayer.Compare(LAY_PIPE_USER3) == 0) 
	{
		GetLayerReMark(LAY_PIPE_USER3, sName);
		if (sName.IsEmpty())
		{
			sName = _T("用户3管线");
		}
		else
		{
			sName += _T("管");
		}
	}
	else if (strLayer.Compare(LAY_PIPE_USER4) == 0) 
	{
		GetLayerReMark(LAY_PIPE_USER4, sName);
		if (sName.IsEmpty())
		{
			sName = _T("用户4管线");
		}
		else
		{
			sName += _T("管");
		}
	}
	else if (strLayer.Compare(LAY_PIPE_USER5) == 0) 
	{
		GetLayerReMark(LAY_PIPE_USER5, sName);
		if (sName.IsEmpty())
		{
			sName = _T("用户5管线");
		}
		else
		{
			sName += _T("管");
		}
	}
	else if (strLayer.Compare(LAY_PIPE_USER6) == 0) 
	{
		GetLayerReMark(LAY_PIPE_USER6, sName);
		if (sName.IsEmpty())
		{
			sName = _T("用户6管线");
		}
		else
		{
			sName += _T("管");
		}
	}
	else if (strLayer.Compare(LAY_PIPE_USER7) == 0) 
	{
		GetLayerReMark(LAY_PIPE_USER7, sName);
		if (sName.IsEmpty())
		{
			sName = _T("用户7管线");
		}
		else
		{
			sName += _T("管");
		}
	}
	else if (strLayer.Compare(LAY_PIPE_USER8) == 0) 
	{
		GetLayerReMark(LAY_PIPE_USER8, sName);
		if (sName.IsEmpty())
		{
			sName = _T("用户8管线");
		}
		else
		{
			sName += _T("管");
		}
	}

	return sName;
}

// 立管信息 zxl 2013.04.17 add
struct VPipeInfo 
{
	Entity ent;
	AcGePoint3d pt;
};

// 点在XOY平面排序 zxl 2013.04.17 add
// 排序规则：先在Y轴从大到小排序，Y轴相同时，按X轴从小到大排序
bool Less(VPipeInfo &info1, VPipeInfo &info2) 
{
	bool bVal = false;
	XPoint pt1 = info1.pt, pt2 = info2.pt;
	if (pt1.y > pt2.y)
	{
		bVal = true;
	}
	else if (fabs(pt1.y - pt2.y) < 1e-3 && pt1.x < pt2.x)
	{
		bVal = true;
	}
	return bVal;
}

// 立管在XOY平面排序 zxl 2013.04.17 add
void SortVPipe(PickSet &ss)
{
	std::vector<VPipeInfo> vec;
	for(long i=0;i<ss.Length();i++)
	{
        Entity ent = ss[i];
        OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
        if(pPipe)
		{
            if(pPipe->IsVertical())
			{
				VPipeInfo info;
				info.ent = ent;
				info.pt = pPipe->StartPoint();
				std::vector<VPipeInfo>::iterator it;
				for (it = vec.begin(); it != vec.end(); it++)
				{
					XPoint pt1, pt2;
					pt1 = info.pt;
					pt2 = (*it).pt;
					if (pt1.Distance2d(pt2) < 1e-3)
					{
						if (pt1.z > pt2.z)
						{
							(*it).ent = ent;
							(*it).pt = info.pt;
						}
						break;
					}
				}
				if (it == vec.end())
				{
					vec.push_back(info);
				}
            }
        }
        OPENOBJ_END();
    }

	if (vec.empty())
	{
		return;
	}
	PickSet ssVpipe(SS_FREE);
	std::sort(vec.begin(), vec.end(), ::Less);
	std::vector<VPipeInfo>::iterator it;
	for (it = vec.begin(); it != vec.end(); it++)
	{
		ssVpipe += (*it).ent;
	}

	if (ssVpipe.Length() > 0)
	{
		ss.Free();
		ss+=ssVpipe;
	}
}

// 搜索经过pt点的管线，若多于一条，返回标高最小的管线 zxl 2013.04.23 add
Entity GetPipeByPt(XPoint pt, int &iPipeSys)
{
    RBList rbMaskPipe(RTDXF0, _T("ATS_PIPE"), 8, GetLayerNames(_T("管线")), NULL);
    PickSet ss(SS_FREE);
    XPoint ptUcs = Wcs2Ucs(pt);    
    GetPointPickSet(ptUcs, ss, rbMaskPipe, (int)(DocGetPScale()/2));
    double len = ss.Length();
    if(len == 0)
        return Entity();
    else if(len > 1){
        GetPointPickSet(ptUcs, ss, rbMaskPipe, (int)(DocGetPScale()/4));
    }

	double dElev = 0.0;
	Entity entPipeSel = ss[0l];
	int iPos = 0;
	for (long l = 0l; l < ss.Length(); l++)
	{
		Entity entPipe = ss[l];
		OPENOBJ_BEGIN(entPipe, AcDb::kForRead, TDbPipe, pPipe);
		if(pPipe && !pPipe->IsVertical())
		{
			double dEle = pPipe->StartPoint().z;
			if (l == 0l)
			{
				dElev = dEle;
				TPipeSys::SysType sys = pPipe->GetSysType();
				CString csLay = pPipe->GetLayer();
				iPipeSys = GetPipeDlgIdxByName(csLay, iPos);
			}
			else if (dElev > dEle)
			{
				TPipeSys::SysType sys = pPipe->GetSysType();
				CString csLay = pPipe->GetLayer();
				iPipeSys = GetPipeDlgIdxByName(csLay, iPos);
				dElev = dEle;
				entPipeSel = entPipe;
			}
		}
		OPENOBJ_END();
	}
    
    return entPipeSel;
}

// 延长立管到接管标高处 zxl 2013.04.17 add
void ModifyPipePt(const AcGePoint3d &pt,  TDbPipe * const pPipe)
{
	AcGePoint3d ptS, ptE;
	ptS = pPipe->StartPoint();
	ptE = pPipe->EndPoint();
	double dDist1 = pt.distanceTo(ptS);
	double dDist2 = pt.distanceTo(ptE);
	double dLen = ptS.distanceTo(ptE);

	if(pPipe->upgradeOpen()==Acad::eOk) 
	{
		if (fabs(dLen + dDist2 - dDist1) < 1e-3)// 从立管末端延长
		{
			pPipe->SetEndPoint(pt);
		}
		else if (fabs(dLen + dDist1 - dDist2) < 1e-3)// 从立管起始端延长
		{
			pPipe->SetStartPoint(pt);
		}
		pPipe->downgradeOpen();
	}
}

void DrawMutiPipe()
{
    g_ssPickFirst.Free();
	// zxl 2013.10.15 add 消除UNDO命令行提示
	xg_setvar(_T("CMDECHO"), 0);
	int nOsMode=0;
    xg_getvar(_T("OSMODE"), &nOsMode);
	if(g_bTgOsnap)
	{
		nOsMode &= ~0x4000;
		nOsMode |= OS_INT|OS_NEA|OS_PER|OS_END|OS_CEN;
	}
    XPushVar<int> vOsMode(_T("OSMODE"), nOsMode);
	
	bool bModifyElev = false;// zxl 2013.04.17 add
    RBList rbMask(RTDXF0, _T("ATS_PIPE"), 8, GetLayerNames(_T("管")), NULL);
    PickSet ss(SS_FREE);
	if(SelectEntities(_T("\n请选择需要引出的立管或管线: <新绘制>"), ss, rbMask) != RTNORM){
		bModifyElev = true;// zxl 2013.04.17 add
        CTemporaryResourceOverride vTemp;
        CPipeVMultDrawDlg dlg;
        if(dlg.DoModal() != IDOK)
            return;
        if(dlg.m_grid.GetRowNum() < 2)
            return;
        if(dlg.m_bIsSuperposable){
            DrawSuperposablePipe(&dlg);
            return;
        }
        XPoint ptIns, ptEnd, ptUcs;
        TPipeEdJig jig(ptIns, 0.5);
		jig.SetPrompt(_T("\n请点选基点(第一个立管的位置)<退出>:"));
        if(jig.DoIt()!=RTNORM) 
            return;
        ptIns = jig.GetPickPoint();
        ptUcs = Wcs2Ucs(ptIns);
		if(ads_getpoint(ptUcs, _T("\n请点选方向<退出>:"), ptEnd) != RTNORM)
            return;
        ptEnd = Ucs2Wcs(ptEnd);
        double nAngle = ads_angle(ptIns, ptEnd);
        for(dlg.m_grid.MoveToFirst(); !dlg.m_grid.IsOut(); dlg.m_grid.MoveToNext()){
            WDGridRow *pRow = dlg.m_grid.CurRow();
            CString csPipe = (*pRow)[0].GetText().cs();
            CString csDist = (*pRow)[1].GetText().cs();
            CString csEle = (*pRow)[2].GetText().cs();
            ads_polar(ptIns, nAngle, _tstof(csDist), ptIns);
            int idx(0);
		/*  cet 2011.12.9 add
            if(csPipe == _T("给水"))
                idx = 0;
            else if(csPipe == _T("热给水"))
                idx = 1;
            else if(csPipe == _T("热回水"))
                idx = 2;
            else if(csPipe == _T("污水"))
                idx = 3;
            else if(csPipe == _T("废水"))
                idx = 4;
            else if(csPipe == _T("中水"))
                idx = 6;
            else if(csPipe == _T("消防"))
                idx = 7;
            else if(csPipe == _T("喷淋"))
                idx = 8;
            else if(csPipe == g_csPipeName[0])
                idx = 9;
            else if(csPipe == g_csPipeName[1])
                idx = 10;
            else if(csPipe == g_csPipeName[2])
                idx = 11;
            else if(csPipe == g_csPipeName[3])
                idx = 12;
            else if(csPipe == g_csPipeName[4])
                idx = 13;
            else if(csPipe == _T("其它"))
                idx = 14;
		*/
			idx = dlg.GetPipeIdxByPipeName(csPipe);

			CString csMat = GetPipeMaterialByIdx(g_iPipeMaterial[idx]);
			CString csDnHead = GetDnByMat(csMat);
			
            TDbPipe *pPipe=new TDbPipe;
            ptIns.z = _tstof(csEle)*1000;
            pPipe->SetStartPoint(ptIns);
            ptIns.z += 3000;
            pPipe->SetEndPoint(ptIns);
            InitPipeLayer(GetVPipeLayerByIdx(idx));
            pPipe->setLayer(GetVPipeLayerByIdx(idx));
            pPipe->setLinetype(GetPipeWireLayLineType(GetPipeLayerByIdx(idx)));
            pPipe->SetModelType(TPipeSys::kModel);
			pPipe->SetSysType(GetPipeSysByLayer(GetPipeLayerByIdx(idx)));
            pPipe->SetDnDiameter(g_iDefaultPipeDn);
            pPipe->SetMaterial(g_iPipeMaterial[idx]);
            pPipe->SetPipeWeight(g_nPipeWidth[idx]);
            pPipe->SetRadius(g_nPipeRadius[idx]);
			pPipe->SetLabel(csDnHead);
            if(g_bPipeDouble[idx])
                pPipe->SetRadiusIn(g_nPipeRadius[idx] / 2);
            pPipe->setColor(AcCmColor()); //随层
            AcDbObjectId id = AddToCurrentSpace(pPipe, Adesk::kTrue);
            ss += id;
            
        }
        //return;  
    }
    BOOL bFromVerPipe = FALSE;
    XPointList lstPt, lstPtOut;
    double nRotate(-1), nRadius(0);
	ss.Redraw(4);
	SortVPipe(ss);
    for(long i=0;i<ss.Length();i++){
        Entity ent = ss[i];
        OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
        if(pPipe){
            if(pPipe->IsVertical()){
                bFromVerPipe = TRUE;
				// lstPt.NewAppend(pPipe->StartPoint());
				// zxl 2013.04.17 add 用户设置管线标高
				PickSet ssSel(SS_FREE);
				if (!bModifyElev)
				{
					ssSel += ent;
					ssSel.Redraw(3);
					AcGePoint3d ptS = pPipe->StartPoint();
					double dOut = ptS.z / 1000;
					CString sPipeName = GetLayerName(pPipe->GetLayer());
					CString sNote;
					sNote.Format(_T("\n请输入%s标高<%.1fm>:"), sPipeName, dOut);
					double dElev = 0.0;
					int nRet = ads_getreal(sNote, &dElev);
					if (nRet == RTNORM)
					{
						ptS.z = dElev * 1000;
					}
					else if (nRet != RTNONE)
					{
						return;
					}
					lstPt.NewAppend(ptS);
					ModifyPipePt(ptS, pPipe);
					ssSel.Redraw(4);
				}
				else
				{
					lstPt.NewAppend(pPipe->StartPoint());
				}

                if(pPipe->GetRadius() > nRadius)
                    nRadius = pPipe->GetRadius();
            }
        }
        OPENOBJ_END();
    }
    BOOL bFree = FALSE;
    BOOL bFromVer = TRUE;
    
    if(lstPt.Length() < 1){//从干管上引出
        bFree = TRUE;
        bFromVer = FALSE;
        XPoint ptPick, ptPick2;
        Entity entSel;
		if(SelectEntity1(g_nCurPipeWidth*DocGetPScale(), _T("\n请选取要引出管线的位置<退出>:"), entSel, ptPick, rbMask)!=RTNORM) 
            return;
        if(entSel.In(&ss) == 0)
            return;
        OPENOBJ_BEGIN(entSel, AcDb::kForRead, TDbPipe, pPipe);
        if(pPipe){
            if(ptPick == pPipe->EndPoint() || ptPick == pPipe->StartPoint()){
                bFromVer = TRUE;
                nRotate = ads_angle(pPipe->GetStartPoint(), pPipe->GetEndPoint());
            }
        }
        OPENOBJ_END();
        
		std::vector<VPipeInfo> vec;
		VPipeInfo info;
		info.ent = entSel;
		info.pt = ptPick;
		vec.push_back(info);
        ss -= entSel;
//         ptPick.z = 0;
//         lstPt.NewAppend(ptPick);
        for(long i=0;i<ss.Length();i++){
            Entity ent = ss[i];
            OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
            if(pPipe){
//                 XLine line(pPipe->EndPoint(), pPipe->StartPoint());
//                 XCurveSegment seg;
//                 seg = line;
//                 seg.ProjectToMe(ptPick, ptPick2);
				XPoint ptPick3;
				AcDbLine line(pPipe->EndPoint(), pPipe->StartPoint());
				line.getClosestPointTo(ptPick, ptPick2, Adesk::kTrue);
				line.getClosestPointTo(ptPick, ptPick3);
				if (ptPick2.Distance2d(ptPick3) > 1e-3)// 投影点在延长线上
				{
					continue;
				}
				info.ent = ent;
				info.pt = ptPick2;

				std::vector<VPipeInfo>::iterator it;
				for (it = vec.begin(); it != vec.end(); it++)
				{
					XPoint pt1, pt2;
					pt1 = info.pt;
					pt2 = (*it).pt;
					if (pt1.Distance2d(pt2) < 1e-3)
					{
						if (pt1.z < pt2.z)
						{
							(*it).ent = ent;
							(*it).pt = info.pt;
						}
						break;
					}
				}
				if (it == vec.end())
				{
					vec.push_back(info);
				}
//                ptPick2.z = 0;
//                lstPt.NewAppend(ptPick2);
            }
            OPENOBJ_END();
        }

		// zxl 2013.04.23 add 用户输入管线标高
		std::sort(vec.begin(), vec.end(), ::Less);
		std::vector<VPipeInfo>::iterator it;
		for (it = vec.begin(); it != vec.end();)
		{
			XPoint pt;
			pt = (*it).pt;
			PickSet ssPipe(SS_FREE);
			ssPipe += (*it).ent;
			ssPipe.Redraw(3);
			TCHAR szEqLay[256];;
			(*it).ent.GetData(8, &szEqLay);
			CString sPipeName = GetPipeLayerName(szEqLay);
			CString sNote;
			sNote.Format(_T("\n请输入%s标高<%.1fm>:"), sPipeName, pt.z / 1000);
			double dElev = 0.0;
			int nRet = ads_getreal(sNote, &dElev);
			if (nRet == RTNORM)
			{
				pt.z = dElev * 1000;
				(*it).pt.z = pt.z;
			}
			else if (nRet != RTNONE)
			{
				return;
			}

			ssPipe.Redraw(4);
			if (pt.Distance2d(ptPick) < 1e-3)
			{
				lstPt.NewAppend(pt);
				it = vec.erase(it);
			}
			else
			{
				it++;
			}
		}

		for (it = vec.begin(); it != vec.end(); it++)
		{
			XPoint pt;
			pt = (*it).pt;
			lstPt.NewAppend(pt);
		}
    }
    InitPipeLayer(LAY_PIPE_FEED);
    XPushVarStr clayer(_T("CLAYER"), LAY_PIPE_FEED);
    CString csPrompt;
    int iMode = 1;
    XPointList lstOld = lstPt;
    XPointList lstOldOld = lstPt;
    double nRotateOld = nRotate;
    BOOL bFromVerPipeFirst = bFromVerPipe;
	// zxl 2013.10.16 add
	std::stack<std::pair<XPointList, double> > stkPtLst;
	bool bUndo = false;
	bool bStart = true;
	bool bInsertPt = true;
    while(1){
		// zxl 2013.10.16 add
		if (!bUndo && bInsertPt)
		{
			stkPtLst.push(std::make_pair(lstPt, nRotate));
		}
		if (stkPtLst.size() > 1)
		{
			bStart = false;
		}
        XPointList lstTmp = lstPt;
        TMultPipeJig jig(lstTmp, nRotate, bFromVerPipe);
        bFromVerPipe = FALSE;
        if(iMode == 0)
			csPrompt.Format(_T("\n请输入终点<退出>[生成四通(S)/管线置上(D)/管线置下(F)/回退(U)]: (当前状态:打断)"));
        else if(iMode == 1)
			csPrompt.Format(_T("\n请输入终点<退出>[生成四通(S)/管线置上(D)/管线置下(F)/回退(U)]: (当前状态:置上)"));
        else if(iMode == 2)
			csPrompt.Format(_T("\n请输入终点<退出>[生成四通(S)/管线置上(D)/管线置下(F)/回退(U)]: (当前状态:置下)"));
        jig.SetPrompt(csPrompt);
        int nKeyIndex;
        jig.SetKeyword(_T("S D F U"));
        int ret = jig.DoIt(&nKeyIndex);
        if(ret == RTKWORD){
			// zxl 2013.10.16 modify 支持连续UNDO到起始处
//            if(nKeyIndex == 3){
//                 if(*lstOldOld[0] == *lstPt[0])
//                     continue;
//                 if(*lstOldOld[0] == *lstOld[0] && bFromVerPipeFirst){
//                     bFree = FALSE;
//                     bFromVerPipe = TRUE;
//                 }
				bInsertPt = false;
				if(nKeyIndex == 3 && !bStart){
				bUndo = true;
				stkPtLst.pop();
				lstOld = (stkPtLst.top()).first;
				nRotateOld = (stkPtLst.top()).second;
				if (*lstOldOld[0] == *lstOld[0])
				{
					bStart = true;
					if (bFromVerPipeFirst)
					{
						bFree = FALSE;
						bFromVerPipe = TRUE;
					}
				}
				
                SHads_command(RTSTR, _T("UNDO"), RTSTR, _T("BACK"), RTNONE);
                nRotate = nRotateOld;
                lstPt = lstOld;
            }
            else
                iMode = nKeyIndex;
            continue;
        }            
        else if(ret != RTNORM){
            break;
        }
		// zxl 2013.10.16 add
		bUndo = false;
		bInsertPt = true;

        nRotateOld = nRotate;
        lstPtOut = jig.m_pDrawEnt->m_lstEnd;
        lstPt = jig.m_pDrawEnt->m_lstStart;
        int len = lstPtOut.Length();
        AssureInCurrentView(*lstPtOut[0], *lstTmp[0]);
        AssureInCurrentView(*lstPtOut[len-1], *lstTmp[len-1]);
        SHads_command(RTSTR, _T(".UNDO"), RTSTR, _T("MARK"), RTNONE); // Make a undo mark
        
        for(int j=0;j<len;j++){
            XPoint pe1, pe2, pe3, ptTmp, ptInt;
            pe3 = *lstTmp[j];
            pe1 = *lstPt[j];
            pe2 = *lstPtOut[j];
            AssureInCurrentView(pe3, pe2);
            double nElevation(0);
            int iPipeIdx(0);
            Entity entPipe;
            if(bFree){
				double dElev = pe3.z;
                entPipe = GetPipeByPt(pe3, iPipeIdx);
				if(!entPipe)
					//break;
// 				pe1.z = nElevation;
//              pe2.z = nElevation;
//              pe3.z = nElevation;
					continue;
                 pe1.z = dElev;
                 pe2.z = dElev;
                 pe3.z = dElev;
            }
            else{
				double dElevOld = pe3.z;// zxl 2013.04.17 add
                entPipe = GetVertPipeByPt(pe3, nElevation, iPipeIdx, nRadius*DocGetPScale());
				// zxl 2013.04.17 add
				if (!bModifyElev)
				{
					nElevation = dElevOld;
				}

                pe1.z = nElevation;
                pe2.z = nElevation;
                pe3.z = nElevation;
            }
            
            OPENOBJ_BEGIN(entPipe, AcDb::kForRead, TDbPipe, pPipe);
            if(pPipe){
                if(pe3 != pe1 && bFree){
                    XLine line1(pPipe->StartPoint(), pPipe->EndPoint());
                    XLine line2(pe1, pe2);
                    int ret = line1.Intersection(&line2, ptInt);
                    if(ret != 1){
                        if(bFromVer){//第一次画, 从立管引出, 如果不是正交, 很可能没有交点
                            TDbPipe *pNewPipe2 = (TDbPipe *)pPipe->clone();
                            pNewPipe2->SetEndPoint(pe2);
                            pNewPipe2->SetStartPoint(pe1);
                            AddToCurrentSpace(pNewPipe2, Adesk::kTrue);
                        }
                        continue;
                    }
					double dEle = pe1.z;
                    pe1 = ptInt;
					pe1.z = dEle;
                    if(bFromVer){ //把之前的管线往前补齐
                        TDbPipe *pNewPipe2 = (TDbPipe *)pPipe->clone();
                        pNewPipe2->SetEndPoint(pe3);
                        pNewPipe2->SetStartPoint(pe1);
                        AddToCurrentSpace(pNewPipe2, Adesk::kTrue);
                    }
                }

                int up(0), low(0);
                BOOL bHasOther = GetInterPipeLevel(pe1, pe2, nElevation, up, low);
                TDbPipe *pNewPipe = (TDbPipe *)pPipe->clone();
				if(pPipe->IsVertical()){//如果从立管引出, 图层不能随立管
					CString csNewLay = GetPipeLayerByIdx(iPipeIdx);
					InitPipeLayer(csNewLay);
					pNewPipe->setLayer(csNewLay);
				}
                pNewPipe->SetEndPoint(pe2);
                if(bFree)
                    pNewPipe->SetStartPoint(pe1);
                else
                    pNewPipe->SetStartPoint(pe3);

				// 标高不同 生成立管 zxl 2013.04.23 add
				XPoint ptS = pNewPipe->StartPoint();
				XPoint pt;
				pPipe->getClosestPointTo(ptS, pt);
				if (ptS.Distance(pt) > 1e-3)
				{
					TDbPipe *pNewPipe2 = (TDbPipe *)pPipe->clone();
                    pNewPipe2->SetEndPoint(ptS);
                    pNewPipe2->SetStartPoint(pt);
                    AddToCurrentSpace(pNewPipe2, Adesk::kTrue);
				}

                if(bHasOther){
                    if(iMode == 0){      //生成四通
                        if(up != 256)
                            pNewPipe->SetHideLevel(up);    
                        else
                            pNewPipe->SetHideLevel(low);    
                    }
                    else if(iMode == 1){ //置上
                        if(up != 256)
                            pNewPipe->SetHideLevel(up+1);
                        else
                            pNewPipe->SetHideLevel(low+1);
                    }
                    else if(iMode == 2)  //置下
                        pNewPipe->SetHideLevel(low-1);
                }
                AddToCurrentSpace(pNewPipe, Adesk::kTrue);
                
                nRotate = ads_angle(pe1, pe2);
                
            }
            OPENOBJ_END();
        }
        bFree = TRUE;
        bFromVer = TRUE;
        lstOld = lstTmp;
        lstPt.Reset();
        lstPt = lstPtOut;
        lstPtOut.Reset();
        TPipePerDocData *pData = GetCurPipeDocData();
        pData->ApplyUpdates();
    }
    SHads_command(RTNONE);
}