// DrawStandPipeDlg.cpp : implementation file
//

#include "stdafx.h"
//#include <dbwall.h>
#include <xwall.h>
#include <DbEquipment.h>
#include <PipeWireMonitor.h>
#include <dbPipeValve.h>
#include <DbPipeLabel.h>
#include <xblock.h>
#include <DbDoubleLinePipe.h>

#include "DrawStandPipeDlg.h"
#include "PipeSettingDlg.h"
#include "InsBlockDlg.h" 
#include "PipeSettingFrameDlg.h"
#include "dbxutil.h"
#include <list>

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

const UINT PipeMenuID = 9410;


extern void DoDimStandPipe(AcDbObjectId idPipe, const TCHAR* szName, const TCHAR* szSerial);
//extern TDbPipe * ClonePipe(TDbPipe *pOldPipe);



//***************************************************************************************************
//                                        上下扣弯
//***************************************************************************************************

void GetAllPipeByPipe(AcDbObjectId pipeId, PickSet &ss, XPoint ptStart)
{
 
	OPENOBJ_BEGIN(pipeId, AcDb::kForRead, TDbPipe, pPipe);
	if(pPipe){
		XPoint ptTmp = pPipe->StartPoint(); 
		AcDbObjectId nodeId(NULL);
		if(ptStart == pPipe->StartPoint())
			nodeId = pPipe->GetNode(0);
		else if(ptStart == pPipe->EndPoint())
			nodeId = pPipe->GetNode(1);
		if(!IsEquipment(nodeId)){
			OPENOBJ_BEGIN(nodeId, AcDb::kForRead, TDbPipeNode, pNode);
			if(pNode){
				int num = pNode->GetInterfaceNum();
				if(num == 2){
					TPipeInterface face;
					pNode->GetInterface(0, face);
					AcDbObjectId nextPipeId = face.m_idPipe; 
					if(pipeId == face.m_idPipe){
						pNode->GetInterface(1, face);
						nextPipeId = face.m_idPipe; 
					}
					XPoint nextPt;
					OPENOBJ_BEGIN(nextPipeId, AcDb::kForRead, TDbPipe, pPipe2);
					if(pPipe2){
						nextPt = pPipe2->StartPoint() == ptStart ? pPipe2->EndPoint() : pPipe2->StartPoint();
					}
					OPENOBJ_END();
					GetAllPipeByPipe(nextPipeId, ss, nextPt);
					ss+=nextPipeId;
				}
			}
			OPENOBJ_END();
		}
	}
	OPENOBJ_END();
	return;
}

void CheckStandPipe(Entity ent, XPoint ptPick, double nOldElevation) 
{
	RBList rbMask(RTDXF0, _T("ATS_PIPE"), 8, GetLayerNames(_T("管")), NULL);
	XPoint ptPipeS, ptPipeE, ptTmp;
	GetPipePoint(ent, ptPipeS, ptPipeE);
	CString csLay = GetPipeLayer(ent);
	TPipeSys::SysType sys = GetPipeSys(ent);

	if(ptPipeS == ptPick)
		ptTmp = ptPipeE;
	else
		ptTmp = ptPipeS;

	PickSet ss(SS_FREE);
	GetPointPickSet(ptTmp, ss, rbMask, (int)g_nPipeRadius[GetPipeLayerIdxByName(csLay)]);
	if(ss.Length() != 2 && ss.Length() != 3)
		return;
	Entity entDel;
	for(long i=0;i<ss.Length();i++){
		Entity entTmp = ss[i];
		XPoint pt1, pt2;
		OPENOBJ_BEGIN(entTmp, AcDb::kForRead, TDbPipe, pPipe);
		if(pPipe){
			if(sys != pPipe->GetSysType() || !pPipe->IsVertical())
				continue;
			pt1 = pPipe->StartPoint();
			pt2 = pPipe->EndPoint();
			if(fabs(pt1.z - nOldElevation) < 0.001 || fabs(pt2.z - nOldElevation) < 0.01){

				if(pPipe->upgradeOpen()==Acad::eOk) {
					pPipe->assertWriteEnabled();
					if(fabs(pt1.z - nOldElevation) < 0.001)
						pPipe->StartPoint().z = ptPipeS.z;
					else if(fabs(pt2.z - nOldElevation) < 0.001)
						pPipe->EndPoint().z = ptPipeS.z;
					pPipe->downgradeOpen();
					if(pPipe->StartPoint() == pPipe->EndPoint()){//2段管线同标高，删除扣弯
						entDel = entTmp;
						break;
					}
					return;
				}
			}
		}
		OPENOBJ_END();
	}
	entDel.Erase();
}

BOOL DoModifyPipeEle(Entity entSel, XPoint ptPick, double &nElevation, BOOL bNeed)
{
	double dMeter(1);
	if(!DocGetMeterUnitDraw())
		dMeter = 1000;
	
	Adesk::UInt16 iCol(1), iCol2(1);
    TCHAR szLay[256];
    entSel.GetData(8, szLay);
    
    AcDbLayerTable *pLayertable = NULL;
    AcDbLayerTableRecord *pLayerRec = NULL;
    acdbCurDwg()->getLayerTable(pLayertable, AcDb::kForRead);
    if(!pLayertable)
        return FALSE;
    if((pLayertable->getAt(szLay, pLayerRec, AcDb::kForWrite)) == Acad::eOk)	{
        AcCmColor col = pLayerRec->color();  
        iCol2 = col.colorIndex();
        if(iCol2 == 1)
            iCol2 = 2;
        else
            iCol2 = 1;
        pLayerRec->close();
        pLayertable->close();
    }
    else
        pLayertable->close();
    

	OPENOBJ_BEGIN(entSel, AcDb::kForWrite, TDbPipe, pPipe);
	if(pPipe){
        pPipe->assertWriteEnabled();
		iCol = pPipe->colorIndex();
		XPoint ptTmp = pPipe->StartPoint();  
		nElevation = ptTmp.z/dMeter;
		pPipe->setColorIndex(iCol2);  
		if(pPipe->isKindOf(TDbDoubleLinePipe::desc()) && dMeter < 10)
			dMeter = 1000;
			
	}
	OPENOBJ_END();
	double nOldElevation = nElevation;
	CString csTmp;
	int iRet;
	if(bNeed){
		csTmp.Format(_T("\n请输入管线的标高(米)<%.3f>"), nElevation);
		INITGET_BEG(0, _T("A"));
		iRet = ads_getdist(ptPick, csTmp, &nElevation);
		INITGET_END();
	}
	else{
		csTmp.Format(_T("\n请输入管线的标高(米)<%.3f>"), nElevation);
		iRet = ads_getdist(ptPick, csTmp, &nElevation);
	}

	if(iRet == RTNORM && nElevation < 100){
		OPENOBJ_BEGIN(entSel, AcDb::kForWrite, TDbPipe, pPipe);
		if(pPipe){
			
        //    pPipe->assertWriteEnabled();
		 
			XPoint ptTmp = pPipe->StartPoint();  
			XPoint ptTmp2 = pPipe->EndPoint();  
			ptTmp.z = nElevation*dMeter;
			ptTmp2.z = nElevation*dMeter;

			pPipe->SetStartPoint(ptTmp);
			pPipe->SetEndPoint(ptTmp2);
			pPipe->setColorIndex(iCol); 
	 
            DList<AcDbObjectId> lstAttachment;
            pPipe->GetAttachments(lstAttachment);
            int len = lstAttachment.Length();
            for(int m=0;m<len;m++){
                AcDbObjectId idTmp = *lstAttachment[m];
                OPENOBJ_BEGIN(idTmp, AcDb::kForWrite, TDbPipeAttachment, pValve);
                if(pValve){
                    XPoint ptLoc = pValve->GetLocation();
                    ptLoc.z =  nElevation*dMeter;
                    pValve->SetLocation(ptLoc);
                }
                OPENOBJ_END();
            }
            
		}
		OPENOBJ_END();

	}
	else{
		OPENOBJ_BEGIN(entSel, AcDb::kForWrite, TDbPipe, pPipe);
		if(pPipe){
			pPipe->setColorIndex(iCol);  
		}
		OPENOBJ_END();
	//	if(iRet == RTKWORD)
	//		return FALSE;
	}
	return TRUE;
}

void DynamicDrawStandPipe(Entity ent1, Entity ent2, XPoint ptPick)
{
	XPoint ptTurn, ptStart, ptEnd, ptStart2, ptEnd2;
	GetPipePoint(ent1, ptStart, ptEnd);
	Entity entTmp;
	CString csDwb = g_csDwbPath + _T("TwtSys");
	XString xsTmp;
	if(LoadDwbBlock(csDwb, _T("00000146"), xsTmp) != RTNORM)   //扣弯
		return;
	double nElevation(0);
	nElevation = ptStart.z;

	AcGeVector3d vectBase(ptEnd.x - ptStart.x, ptEnd.y - ptStart.y, 0);
	double nAng = ads_angle(ptStart, ptEnd);
	g_nInsBlkRotate = vectBase.angleTo(AcGeVector3d(1,0,0));
	g_nInsBlkRotate = nAng;
	TBlockEdJig jig((const TCHAR*)xsTmp, ptPick, 50, vectBase);
	jig.SetPrompt(_T("\n请指定扣弯方向<完成>:"));
	if(jig.DoIt() == RTNORM){
		int iQuadrant = jig.m_iQuadrant;
		if(iQuadrant == 0 || iQuadrant == 3){ 
			entTmp = ent1;
		}
		else if(iQuadrant == 1 || iQuadrant == 2){
			entTmp = ent2;
		}
		TDbPipe *pPipe2 = new TDbPipe;
		OPENOBJ_BEGIN(entTmp, AcDb::kForWrite, TDbPipe, pPipe);
		if(pPipe){
			pPipe2 = (TDbPipe *)pPipe->clone();
            
            pPipe->assertWriteEnabled();
			XPoint pt1, pt2;
			pt1 = pPipe->StartPoint();
			pt2 = pPipe->EndPoint();
			pt1.z -= 1000;
			pt2.z -= 1000;
			pPipe->SetStartPoint(pt1);
			pPipe->SetEndPoint(pt2);
		}
		OPENOBJ_END();
		ptPick.z = nElevation;
		pPipe2->SetStartPoint(ptPick);
		ptPick.z = nElevation - 1000;
		pPipe2->SetEndPoint(ptPick);
        pPipe2->SetModelType(TPipeSys::kModel);
		AddToCurrentSpace(pPipe2, Adesk::kTrue);
	//	CheckStandPipe(entTmp, ptPick, nElevation);
	}
	SHads_command(RTNONE);
	g_nInsBlkRotate = 0;
}


extern CString GetVPipeLayerByIdx(int iLayer);

CString GetVPipeLayByPipe(Entity entRef)
{
	CString csRet;
	OPENOBJ_BEGIN(entRef, AcDb::kForRead, TDbPipe, pPipe);
	if(pPipe && !pPipe->IsVertical()){
		TCHAR* szLay = pPipe->layer();
		int idx = GetPipeLayerIdxByName(szLay);
		csRet = szLay;//sr 2010.1.6 改正，把扣弯图层直接改为管线图层，不影响立管排序
	//	csRet = GetVPipeLayerByIdx(idx);
		if(pPipe->isKindOf(TDbDoubleLinePipe::desc()))
			csRet = szLay;
		delete [] szLay;

	}
	OPENOBJ_END();
	return csRet;
}

AcDbObjectId DoDrawStandPipe(Entity entRef, double nEle1, double nEle2, XPoint ptPick)
{
	if(fabs(nEle1 - nEle2) < 0.01){
		adsout << _T("\n立管顶标高等于底标高！");
		return NULL;
	}
	TDbPipe *pPipe2 = new TDbPipe;
	OPENOBJ_BEGIN(entRef, AcDb::kForRead, TDbPipe, pPipe);
	if(pPipe){
		pPipe2 = (TDbPipe *)pPipe->clone();
	}
	OPENOBJ_END();
    pPipe2->setLinetype(_T("CONTINUOUS"));
	CString csLay = GetVPipeLayByPipe(entRef);
	InitPipeLayer(csLay);
	ptPick.z = nEle1;
	pPipe2->SetStartPoint(ptPick);
	ptPick.z = nEle2;
	pPipe2->SetEndPoint(ptPick);
	pPipe2->SetBulge(0.0); // 清除弧度，以免克隆实体来自弧管，造成错误 cet 2013.3.15 add

    pPipe2->SetRadius(g_nPipeRadius[GetPipeLayerIdxByName(csLay)]);
    if(!g_bStandPipeArc)//传统扣弯
        pPipe2->SetRadiusIn(-2);
	if(csLay != _T("")) //双线水管没有立管图层
		pPipe2->setLayer(csLay);
    pPipe2->SetModelType(TPipeSys::kModel);
	AcDbObjectId id = AddToCurrentSpace(pPipe2, Adesk::kTrue);
    return id;
}

//判断1个点，是否在管线上。 不考虑斜管，只要投影在管线上就算
BOOL IsPtOnPipe(XPoint pt, Entity ent)
{
	OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
	if(pPipe){
		pt.z = 0;
		AcGePoint3d p1 = pt;
		AcGePoint3d p2;
		TDbPipe *pNewPipe = ClonePipe(pPipe);
		pNewPipe->StartPoint().z = 0;
		pNewPipe->EndPoint().z = 0;
		//把管线放平
		AcDbCurve *pCurve = pNewPipe->AsAcDbCurve();
		delete pNewPipe;
		pCurve->getClosestPointTo(p1,p2);
		delete pCurve;
		
		double dDist = ads_distance(XPoint(p1), XPoint(p2));
		if(dDist < 0.001){
			pt = p2;
			return TRUE;
		}
		else
			return FALSE;
	}
	OPENOBJ_END();
	return FALSE;
}


void GetPipeByPt(XPoint ptPick, PickSet &ss)
{
    RBList rbMask = ads_buildlist( -4, _T("<or"),
        -4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, _T("*"), -4, _T("and>"),  
        -4, _T("<and"), RTDXF0, _T("ATS_DOUBLELINEPIPE"), 8, _T("*"), -4, _T("and>"),  
        -4, _T("or>"), NULL);
    
    //因为考虑到搜索遮挡管线，所以把选择框放大，有可能多选不必要的管线，例如：2平行管线, 不同系统的管线
    GetPointPickSet(ptPick, ss, rbMask, int(g_nBreakPipeWidth*DocGetPScale()));
    int len = ss.Length();
    if(ss.Length() > 1){
        long len = ss.Length();
        BOOL bEqualHeight = TRUE;
		BOOL bDiffentSys = FALSE;
        double nEleTmp = -9999;
        PickSet ssDel(SS_FREE);
		TPipeSys::SysType sys0=TPipeSys::kUnknownSys;
        for(long j=0;j<len;j++){
            Entity entTmp = ss[j];
			TPipeSys::SysType sys = GetPipeSys(entTmp);
			if(sys != sys0 && sys0 != TPipeSys::kUnknownSys){
				bDiffentSys = TRUE;
				break;
			}
			sys0 = sys;
            if(IsPipeVertical(entTmp)){
                ssDel += entTmp;
                continue;
            }
            XPoint ptS, ptE;
            GetPipePoint(entTmp, ptS, ptE);
            if(nEleTmp < -9998)
                nEleTmp = ptS.z;
            if(fabs(nEleTmp - ptS.z) > 0.01){
                bEqualHeight = FALSE;
                continue;
            }
        }
		if(bDiffentSys){//搜索出不同系统的管线
            GetPointPickSet(ptPick, ss, rbMask, int(g_nCurPipeWidth*DocGetPScale()/2));
			len = ss.Length();
			return;
		}
        ss -= ssDel;
        if(bEqualHeight){//如果所有被选管线等高，缩小框选范围
            GetPointPickSet(ptPick, ss, rbMask, int(g_nCurPipeWidth*DocGetPScale()/2));
            if(ss.Length() > 1){
                double nDist(-1);
                Entity ent2;
                for(j=0;j<len;j++){
                    Entity entTmp = ss[j];
                    XPoint ptS, ptE, ptTmp;
                    GetPipePoint(entTmp, ptS, ptE);
                    XLine line(ptS, ptE);
                    ptPick.Project(&line, ptTmp);
                    double nTmp = ads_distance(ptTmp, ptPick);
                    if(nTmp > 0.001 && (nDist < 0 || nTmp < nDist)){
                        nDist = nTmp;
                        ent2 = entTmp;
                    }
                }
                if(!!ent2){
                    ss.Free();
                    ss+=ent2;
                }
            }
        }
        else{
            len = ss.Length();
            if(len == 2){//如果选择有2个，且平行， 缩小框选范围
                Entity ent1 = ss[0L];
                Entity ent2 = ss[1L];
                if(Is2PipeParallel(ent1, ent2))
                    GetPointPickSet(ptPick, ss, rbMask, int(g_nCurPipeWidth*DocGetPScale()/2));
            }
            else if(len == 3){//如果选择有3个，且平行， 缩小框选范围
                Entity ent1 = ss[0L];
                Entity ent2 = ss[1L];
                Entity ent3 = ss[2L];
                if(Is2PipeParallel(ent1, ent2) && Is2PipeParallel(ent1, ent3))
                    GetPointPickSet(ptPick, ss, rbMask, int(g_nCurPipeWidth*DocGetPScale()/2));
            }
        }
    }
}

//选择2管线交叉处插入扣弯
void DrawStandPipeBy2PipeInter() 
{
    RBList rbMask = ads_buildlist( -4, _T("<or"),
        -4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, _T("*"), -4, _T("and>"),  
        -4, _T("<and"), RTDXF0, _T("ATS_DOUBLELINEPIPE"), 8, _T("*"), -4, _T("and>"),  
        -4, _T("or>"), NULL);
	Entity ent1, ent2;
	if(SelectEntity(_T("\n请选择1根管线:<退出>"), ent1, rbMask) != RTNORM)
		return;
	if(SelectEntity(_T("\n请选择另1根管线:<退出>"), ent2, rbMask) != RTNORM)
		return;

 
	TPipeSys::SysType sys1, sys2;  
	XPoint ptStart1, ptStart2;
	XLine line1, line2;
	OPENOBJ_BEGIN(ent1, AcDb::kForRead, TDbPipe, pPipe);
	if(pPipe && !pPipe->IsVertical()){
		ptStart1 = pPipe->StartPoint();
		sys1 = pPipe->GetSysType();
		line1 = pPipe->GetLine();
	}
	OPENOBJ_END();
	OPENOBJ_BEGIN(ent2, AcDb::kForRead, TDbPipe, pPipe);
	if(pPipe && !pPipe->IsVertical()){
		ptStart2 = pPipe->StartPoint();
		sys2 = pPipe->GetSysType();
		line2 = pPipe->GetLine();
	}
	OPENOBJ_END();
	if(fabs(ptStart1.z - ptStart2.z) < 0.001){
		adsout << _T("\n2根管线高度相同，无法插入扣弯");
		return;
	}
	if(sys1 != sys2){
		adsout << _T("\n2根管线系统不一致，无法插入扣弯");
		return;
	}
	line1.EndPoint().z = 0;
	line1.StartPoint().z = 0;
	line2.EndPoint().z = 0;
	line2.StartPoint().z = 0;
	
	XPoint ptInt;
	int ret = line1.Intersection(&line2, ptInt);
	if(ret == 1)
		DoDrawStandPipe(ent1, ptStart1.z, ptStart2.z, ptInt);
}

void DrawStandPipeBy2Pipe() 
{
    RBList rbMask = ads_buildlist( -4, _T("<or"),
        -4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, _T("*"), -4, _T("and>"),  
        -4, _T("<and"), RTDXF0, _T("ATS_DOUBLELINEPIPE"), 8, _T("*"), -4, _T("and>"),  
        -4, _T("or>"), NULL);
    
	Entity entSel, entLast;
	XPoint ptPick, ptPipeS, ptPipeE;
	int nOsMode=0;
    xg_getvar(_T("OSMODE"), &nOsMode);
    nOsMode &= ~0x4000;
    nOsMode |= OS_INT|OS_NEA|OS_END|OS_INS;
    XPushVar<int> vOsMode2(_T("OSMODE"), nOsMode);
	if(ads_getpoint(NULL, _T("\n请点取插入扣弯的位置<选择2管线交叉处插入扣弯>:"), ptPick) != RTNORM){
		DrawStandPipeBy2PipeInter();
		return;
	}
    double dMeter(1);
	if(!DocGetMeterUnitDraw())
		dMeter = 1000;
	
	PickSet ss(SS_FREE);
    GetPipeByPt(ptPick, ss);

	// cet 2013.3.15 add 过滤掉不经过ptPick的管线
	PickSet ssDel(SS_FREE);
	int nNum = ss.Length();
	XPoint ptTemp = Ucs2Wcs(ptPick);
	ptTemp.z = 0.0;
	XCurveSegment seg;
	XPoint ptPrj;
	for (long i = 0; i < nNum; ++i)
	{
		OPENOBJ_BEGIN(ss[i], AcDb::kForRead, TDbPipe, pPipe);
		if (pPipe != NULL)
		{
			seg = pPipe->GetCurve();
			seg.SetElevation(0.0);
			seg.ProjectToMe(ptTemp, ptPrj);
			if (ptTemp.Distance(ptPrj) > 0.001)
			{
				ssDel += ss[i];
			}
		}
		OPENOBJ_END();
	}
	ss -= ssDel;
 
	int len1 = ss.Length();
	//ptPick = Ucs2Wcs(ptPick);
 
	
    if(ss.Length() == 1){
		entSel = ss[0L];
		if(IsPipeVertical(entSel))
			return;
        XPoint ptWcsPick = Ucs2Wcs(ptPick);
		if(!IsPtOnPipe(ptWcsPick, entSel))
			return;
		GetPipePoint(entSel, ptPipeS, ptPipeE);//打断管线
        if(ads_distance(ptWcsPick, ptPipeS) < 0.1 || ads_distance(ptWcsPick, ptPipeE) < 0.1 ){
            CString csTmp;
            double nElevation = ptPipeS.z;
            csTmp.Format(_T("\n请输入竖管线的另一标高(米)，当前标高＝%.3f<退出>"), nElevation/dMeter);
            ads_getdist(ptPick, csTmp, &nElevation);
            if(ptPick.z == nElevation)
                return;
            DoDrawStandPipe(entSel, nElevation*dMeter, ptWcsPick.z, ptWcsPick);
            return;
        }
		BreakEntity(entSel, ptPick, ptPick);
		entLast.GetLast();

        //以下目的是让新管线更新节点，而又不重新连接到一起
        OPENOBJ_BEGIN(entLast, AcDb::kForWrite, TDbPipe, pPipe);
        if(pPipe){
            pPipe->assertWriteEnabled();
            pPipe->SetDnDiameter(pPipe->GetDnDiameter()+1);//把管径＋1，2断管就不会连接
			if(pPipe->isKindOf(TDbDoubleLinePipe::desc()) && dMeter < 10)
				dMeter = 1000;
        }
		else
		{
			adsout << _T("距离太短，无法打断！");
			return;
		}
        OPENOBJ_END();
        TPipePerDocData *pData = GetCurPipeDocData();
        pData->ApplyUpdates();
	 
		double nElevation(0), nElevation2(0);
		DoModifyPipeEle(entSel, ptPick, nElevation, TRUE);

        //把管径恢复 
        OPENOBJ_BEGIN(entLast, AcDb::kForWrite, TDbPipe, pPipe);
        if(pPipe){
            pPipe->assertWriteEnabled();
            pPipe->SetDnDiameter(pPipe->GetDnDiameter()-1);
        }
        OPENOBJ_END();
	
		DoModifyPipeEle(entLast, ptPick, nElevation2, FALSE);
	 
		
        ptPick = Ucs2Wcs(ptPick);
		if(fabs(nElevation - nElevation2) > 0.001){
			TDbPipe *pPipe2 = new TDbPipe;
			OPENOBJ_BEGIN(entLast, AcDb::kForRead, TDbPipe, pPipe);
			if(pPipe){
				pPipe2 = (TDbPipe *)pPipe->clone();
			}
			OPENOBJ_END();
			CString csLay = GetVPipeLayByPipe(entLast);
			InitPipeLayer(csLay);
			
            pPipe2->assertWriteEnabled();
            pPipe2->setLinetype(_T("CONTINUOUS"));
			ptPick.z = nElevation*dMeter;
			pPipe2->SetStartPoint(ptPick);
			ptPick.z = nElevation2*dMeter;
            pPipe2->SetRadius(g_nPipeRadius[GetPipeLayerIdxByName(csLay)]);

            //pPipe2->SetRadius(g_nPipeRadius[GetPipeLayerIdxBySys(pPipe2->GetSysType())]);
			pPipe2->SetEndPoint(ptPick);
			pPipe2->setLayer(csLay);
            pPipe2->SetModelType(TPipeSys::kModel);
            if(!g_bStandPipeArc)//传统扣弯
                pPipe2->SetRadiusIn(-2);
			AddToCurrentSpace(pPipe2, Adesk::kTrue);
		}
	}
    else if(ss.Length() == 2){ //处理遮挡扣弯的问题
        XPoint p1, p2,  p3, p4, p5;
        GetPipePoint(ss[0L], p1, p2);
        GetPipePoint(ss[1L], p3, p4);
        if(fabs(p1.z - p3.z) < 0.01){ //2管线等高
            double nElevation(0), nElevation2(0);
            DoModifyPipeEle(ss[0L], ptPick, nElevation, FALSE);
            p1.z = nElevation*dMeter;
            DoModifyPipeEle(ss[1L], ptPick, nElevation2, FALSE);
            p3.z = nElevation2*dMeter;
        }
//         cet 2011.5.17 modify 未考虑弧管
//         XLine l1(p1, p2);
//         XLine l2(p3, p4);
//         l1.EndPoint().z = 0;
//         l1.StartPoint().z = 0;
//         l2.EndPoint().z = 0;
//         l2.StartPoint().z = 0;
//         l1.Intersection(&l2, p5);
//         if(!p5 && Is2LineOnLine(l1, l2)){
//             if(l1.StartPoint() == l2.StartPoint())
//                 p5 = l1.StartPoint();
//             else if(l1.EndPoint() == l2.StartPoint())
//                 p5 = l1.EndPoint();
//             else if(l1.StartPoint() == l2.EndPoint())
//                 p5 = l1.StartPoint();
//             else if(l1.EndPoint() == l2.EndPoint())
//                 p5 = l1.EndPoint();
//         }
		double dBulge1 = 0.0, dBulge2 = 0.0;
		OPENOBJ_BEGIN(ss[0L], AcDb::kForRead, TDbPipe, pPipe);
		if (pPipe != NULL)
		{
			dBulge1 = pPipe->GetBulge();
		}
		OPENOBJ_END();

		OPENOBJ_BEGIN(ss[1L], AcDb::kForRead, TDbPipe, pPipe);
		if (pPipe != NULL)
		{
			dBulge2 = pPipe->GetBulge();
		}
		OPENOBJ_END();
		XCurveSegment seg1(p1, p2, dBulge1), seg2(p3, p4, dBulge2);
		seg1.StartPoint().z = 0;
		seg1.EndPoint().z = 0;
		seg2.StartPoint().z = 0;
		seg2.EndPoint().z = 0;
		seg1.Intersection(seg2, p5, XPoint());
		if (!p5)
		{
			if(seg1.StartPoint() == seg2.StartPoint())
			{
                p5 = seg1.StartPoint();
			}
            else if(seg1.EndPoint() == seg2.StartPoint())
			{
                p5 = seg1.EndPoint();
			}
            else if(seg1.StartPoint() == seg2.EndPoint())
			{
                p5 = seg1.StartPoint();
			}
            else if(seg1.EndPoint() == seg2.EndPoint())
			{
                p5 = seg1.EndPoint();
			}
		}

        if(!!p5 && fabs(p1.z - p3.z) > 0.01){
            DoDrawStandPipe(ss[0L], p1.z, p3.z, p5);
        }
    }
    else if(ss.Length() > 2){
        double nHigh(0), nLow(0);
        XPoint ptInt;
        for(long j=0;j<ss.Length();j++){
            XPoint p1, p2, ptInt2;
            Entity entTmp = ss[j];
            if(IsPipeVertical(entTmp)){
                ptInt = XPoint();
                break;
            }
            GetPipePoint(entTmp, p1, p2);
            if(nHigh < p1.z || fabs(nHigh) < 0.01)
                nHigh = p1.z;
            if(nLow > p1.z || fabs(nLow) < 0.01)
                nLow = p1.z;
            p1.z = 0;
            p2.z = 0;
            ptPick.z = 0;
            double nDist2 = ads_distance(ptPick, p1);
            double nDist3 = ads_distance(ptPick, p2);
            if(nDist2 < 0.01)
                ptInt2 = p1;
            if(nDist3 < 0.01)
                ptInt2 = p2;
            if(!ptInt)
                ptInt = ptInt2;
//            else if(ptInt2 != ptInt){ 
//                ptInt = XPoint();
//                break;
//            }
        }
        if(!!ptInt){
            DoDrawStandPipe(ss[0L], nHigh, nLow, ptInt);
        }
    }

}



//***************************************************************************************************
//                                        立管布置
//***************************************************************************************************
bool IsNumberic(const CString &sText);
//cet 2013.1.9 add 考虑楼号
//int GetCurSerial(const TCHAR* szLay)
int GetCurSerial(const TCHAR* szLay, const CString &sFloorNum, PickSet &ss)
{
    long len = ss.Length();
    int iRet(0);
    for(long i=0;i<len;i++){
        Entity ent = ss[i];
        OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
        if(pPipe && pPipe->IsVertical()){
			// cet 2013.1.9 add 考虑楼号
			CString sBuildingSerial = ReadXdata(ent, _T("BUILDING-SERIAL"));
			if (sBuildingSerial.Compare(sFloorNum) != 0)
			{
				continue;
			}

            CString csSerial = ReadXdata(ent, _T("PIPE-SERIAL"));  
			// cet 2013.3.13 add 排除非纯数字
			if (!IsNumberic(csSerial))
			{
				continue;
			}
            if(_ttoi(csSerial) > iRet)
                iRet = _ttoi(csSerial);
        }
        OPENOBJ_END();        
    }
    return iRet;
}

// cet 2013.3.12 add 是否为数字字符串
bool IsNumberic(const CString &sText)
{
	// 空串
	if (sText.IsEmpty())
	{
		return false;
	}

	// 依次检查字符
	int nNum = sText.GetLength();
	for(int i = 0; i < nNum; ++i)
	{
		int nCh = sText.GetAt(i);
		// 非数字(0-9)
		if (!_istdigit(nCh))
		{
			return false;
		}
	}
	return true;
}

// cet 2013.3.12 add 分解字符串
void SplitString(const CString &sText, std::list<CString> &lstStrs)
{
	lstStrs.clear();
	// 空串
	if (sText.IsEmpty())
	{
		return;
	}

	// 只有一个字符
	int nLen = sText.GetLength();
	if (nLen == 1)
	{
		lstStrs.push_back(sText);
		return;
	}

	CString sTemp = sText.GetAt(nLen - 1);
	for (int i = nLen - 2; i >= 0; --i)
	{
		TCHAR nCh = sText.GetAt(i);
		if (_istdigit(nCh)) // 数字
		{
			TCHAR nPreCh = sText.GetAt(i + 1);
			if (_istdigit(nPreCh)) // 上一个字符为数字
			{
				sTemp.Insert(0, nCh);
			}
			else
			{
				lstStrs.push_back(sTemp);
				sTemp = nCh;
			}
		}
		else if (_istalpha(nCh)) // 字母
		{
			TCHAR nPreCh = sText.GetAt(i + 1);
			if (_istalpha(nPreCh)) // 上一个字符为字母
			{
				sTemp.Insert(0, nCh);
			}
			else
			{
				lstStrs.push_back(sTemp);
				sTemp = nCh;
			}
		} 
		else // 非数字字母
		{
			TCHAR nPreCh = sText.GetAt(i + 1);
			if (!_istalpha(nPreCh) && !_istdigit(nPreCh)) // 上一个字符为非数字字母
			{
				sTemp.Insert(0, nCh);
			}
			else
			{
				lstStrs.push_back(sTemp);
				sTemp = nCh;
			}
		}
	}
	lstStrs.push_back(sTemp);
}

// cet 2013.3.12 add 纯字母递增, 返回值表示是否进位, sSerial完全有字母组成
bool IncreaseAlpha(CString &sSerial)
{
	CString sTemp = sSerial;
	bool bCarry = false;
	int nLen = sSerial.GetLength();	
	for (int i = nLen - 1; i >= 0; --i)
	{
		TCHAR ch = sSerial.GetAt(i);
		if (_istupper(ch)) // 大写字母
		{
			if (ch + 1 <= _T('Z'))
			{
				sTemp.SetAt(i, ch + 1);
				bCarry = false;
				break;
			}
			else 
			{
				int nDiff = ch - _T('Z');
				sTemp.SetAt(i, _T('A') + nDiff);
				bCarry = true;
			}
		}
		else // 小写字母
		{
			if (ch + 1 <= _T('z'))
			{
				sTemp.SetAt(i, ch + 1);
				bCarry = false;
				break;
			}
			else
			{
				int nDiff = ch - _T('z');
				sTemp.SetAt(i, _T('a') + nDiff);
				bCarry = true;
			}
		}
	}

	sSerial = sTemp;
	return bCarry;
}

// cet 2013.3.13 add 区间内是否存在数字或字母
bool IsExistDigitOrLetter(std::list<CString>::iterator itBegin, std::list<CString>::iterator itEnd)
{
	CString sTemp;
	while(itBegin != itEnd)
	{
		sTemp = *itBegin;
		++itBegin;
		if (sTemp.IsEmpty())
		{
			continue;
		}
		
		TCHAR ch = sTemp.GetAt(0);
		// 数字或字母
		if (_istdigit(ch) || _istalpha(ch))
		{
			return true;
		}
	}
	return false;
}

// cet 2013.3.12 add 递增编号
CString IncreaseSerial(const CString &sSerial)
{
	CString sRet;
	if (IsNumberic(sSerial)) // 纯数字
	{
		int nNum = _ttoi(sRet);
		sRet.Format(_T("%d"), nNum + 1);
	}
	else
	{
		// 拆分字符串
		std::list<CString> lstStrs;
	    SplitString(sSerial, lstStrs);
		// 递增字符串
		std::list<CString>::iterator it, itTemp, itEnd = lstStrs.end();
		CString sTemp;
		for (it = lstStrs.begin(); it != itEnd; ++it)
		{
			sTemp = *it;
			TCHAR ch = sTemp.GetAt(0);
			if (_istdigit(ch)) // 数字
			{
				int nNum = _ttoi(sTemp);
				sTemp.Format(_T("%d"), nNum + 1);
				*it = sTemp;
				break;
			}
			else if (_istalpha(ch)) // 字符
			{
				bool bCarry = IncreaseAlpha(sTemp);
				if (!bCarry) // 不需要进位，计算到此为止
				{
					*it = sTemp;
					break;
				}

				itTemp = it;
				++itTemp;
				if (IsExistDigitOrLetter(itTemp, itEnd)) // 后续字符串可处理进位
				{
					*it = sTemp;
					continue;;
				}

				// 在本字符串中处理进位
				if (_istupper(ch)) // 大小字母
				{
					sTemp.Insert(0, _T("A"));
				} 
				else // 小写字母
				{
					sTemp.Insert(0, _T("a"));
				}
				*it = sTemp;
			} 
		}
		
		std::list<CString>::reverse_iterator itR, itREnd = lstStrs.rend();
		for (itR = lstStrs.rbegin(); itR != itREnd; ++itR)
		{
			sRet += *itR;
		}
	}
	return sRet;
}

// cet 2013.3.12 add 递增字符串,sText表示递增的格式字符串 
CString GetCurSerial(const CString &sLayerName, const CString &sFloorNum, const CString &sText, PickSet &ss)
{
	CString sRet = sText;
	if (IsNumberic(sText)) // 纯数字字符串
	{
		int nNum = GetCurSerial(sLayerName, sFloorNum, ss);
		sRet.Format(_T("%d"), nNum + 1);
	} 
	else
	{
		// 获得同图层立管的编号
		std::vector<CString> vecSerials;
		long nLen = ss.Length();
		CString sTemp;
		for(long i = 0; i < nLen; i++)
		{
			Entity ent = ss[i];
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
			if(pPipe && pPipe->IsVertical())
			{
				//  考虑楼号
				CString sBuildingSerial = ReadXdata(ent, _T("BUILDING-SERIAL"));
				if (sBuildingSerial.Compare(sFloorNum) != 0)
				{
					continue;
				}
				sTemp = ReadXdata(ent, _T("PIPE-SERIAL")); 
				vecSerials.push_back(sTemp);
			}
			OPENOBJ_END();        
		}	
        
		std::vector<CString>::iterator itBegin = vecSerials.begin(), itEnd = vecSerials.end();
		std::vector<CString>::iterator it;
		while(true)
		{
			it = std::find(itBegin, itEnd, sRet);
			if (it == itEnd)
			{
				break;
			}
			sRet = IncreaseSerial(sRet);
		}
	}
	return sRet;    
}
 
void GetExternalBlockWallSeg(Entity entBlk, XCurveSegment &lCurve, XCurveSegment &rCurve, XPoint &ptResult)
{
    XBlock myBlock(entBlk);
    if(!myBlock.m_bInitSuccess)
        return;
    
    XCurveSegment seg;
   // ads_point ptResult;
    ads_name ent;
    ads_matrix xformres;
    resbuf* refstkres;
    while (1) {
        refstkres = NULL;
        //直接选择子实体
		int result = acedNEntSelP(_T("\n外部参照！请继续选择外部参照上墙线<退出>: "), ent, ptResult, 0, xformres, &refstkres);
        if (refstkres != NULL)
            acutRelRb(refstkres);
        if (result == RTNORM) {
            Entity entTemp = ent;
            if(entTemp.Is(_T("ATS_WALL"))){
                OPENOBJ_BEGIN(entTemp, AcDb::kForRead, TDbWall, pWall);
            
                XPoint ptNew1, ptNew2;
                if(pWall) {
                    pWall->GetSideCurve(lCurve, rCurve);
                    AcGePoint3d ptStart = lCurve.StartPoint();
                    ptStart = ptStart.transformBy(myBlock.GetMatrix3d());
                    AcGePoint3d ptEnd = lCurve.EndPoint();
                    ptEnd = ptEnd.transformBy(myBlock.GetMatrix3d());
                    XLine line(asDblArray(ptStart), asDblArray(ptEnd), 1);
                    lCurve = line;

                 
                    ptStart = rCurve.StartPoint();
                    ptStart = ptStart.transformBy(myBlock.GetMatrix3d());
                    ptEnd = rCurve.EndPoint();
                    ptEnd = ptEnd.transformBy(myBlock.GetMatrix3d());
                    XLine line2(asDblArray(ptStart), asDblArray(ptEnd), 1);
                    rCurve = line2;
                    return;

                }
                OPENOBJ_END();
            }
			else{
				if(entTemp.Is(_T("LINE"))){
					XCurveSegment seg1(entTemp);
					lCurve = seg1;
				}
				break;
			}
        }
        else
            break;
    }
    return;
}


void DrawStandPipeCmd() 
{
    RBList rbMaskPipe(RTDXF0, _T("ATS_PIPE"), 8, GetLayerNames(_T("管")), NULL);
    
	CDrawStandPipeDlg dlg(1, acedGetAcadFrame());  
    {
    CTemporaryResourceOverride vTemp;
	dlg.Create(IDD_STAND_PIPE, acedGetAcadFrame());
    }
	dlg.ShowWindow(SW_SHOW);
	acedGetAcadDwgView()->SetFocus();
	XPoint ptOld;

    int nOsMode=0;
    xg_getvar(_T("OSMODE"), &nOsMode);
    nOsMode &= ~0x4000;
    nOsMode |= OS_INT|OS_END;
    XPushVar<int> vOsMode2(_T("OSMODE"), nOsMode);
	double dMeter(1);
	if(!DocGetMeterUnitDraw())
		dMeter = 1000;
	
	while(1){
		dlg.UpdateData(TRUE);
	/*  cet 2013.3.12 modify 支持非纯数字编号
	 // cet 2013.1.9 modify 考虑楼号
     // int idx = GetCurSerial(dlg.GetLayer());
		int idx = GetCurSerial(dlg.GetLayer(), dlg.m_csFloorName);
		dlg.m_csName.Format(_T("%d"), idx+1);
	*/
		PickSet ssPipe(SS_FREE);
		RBList rbMask(RTDXF0, _T("ATS_PIPE"), 8, dlg.GetLayer(), NULL);
        ssPipe.Get(_T("X"), NULL, NULL, rbMask);
		dlg.m_csName = GetCurSerial(dlg.GetLayer(), dlg.m_csFloorName, dlg.GetCurSerialFormat(), ssPipe);
		dlg.SetPickset(ssPipe);
        dlg.UpdateData(FALSE);
 		XPoint ptIns;
		if(dlg.m_iPlace == 0){
			xg_getvar(_T("VIEWCTR"), ptIns);
			ptIns = Ucs2Wcs(ptIns);
			TPipeEdJig jig(ptIns, g_nPipeRadius[dlg.m_iPipeType]);
			jig.SetPrompt(_T("\n请指定立管的插入点[输入参考点(R)]<退出>:"));
			jig.SetKeyword(_T("R V"));
			int nKeyIdx;
			if(!!ptOld)
				jig.m_ptRef = ptOld;
			int nRetCode=jig.DoIt(&nKeyIdx);
			if(nRetCode==RTNORM) {
				ptIns = jig.GetPickPoint();
				ptOld = ptIns;
			}
			else if(nRetCode==RTKWORD){
                if(nKeyIdx == 0){
					if(ads_getpoint(NULL,_T("\n请输入参考点:"), ptIns) != RTNORM)
                        continue;
                    double nXDist(0), nYDist(0);
                    ptIns = Ucs2Wcs(ptIns);
					ads_getdist(ptIns, _T("\n请输入X方向距参考点的距离(注意：反方向用负号)<0>:"), &nXDist);
                    ads_polar(ptIns, 0, nXDist, ptIns);
					ads_getdist(ptIns, _T("\n请输入Y方向距参考点的距离(注意：反方向用负号)<0>:"), &nYDist);
                    ads_polar(ptIns, PI/2, nYDist, ptIns);
                }
                else 
				{
				    continue;
				}
			}
			else{
				dlg.DestroyWindow();
				return;
			}
        } 
		else if(dlg.m_iPlace == 1 || dlg.m_iPlace == 2){
			RBList rbMask = ads_buildlist( -4, _T("<or"),
			   -4, _T("<and"), RTDXF0, _T("LINE"), 8, _T("*"), -4, _T("and>"),  
			   -4, _T("<and"), RTDXF0, _T("ATS_WALL"), 8, _T("*"), -4, _T("and>"),  
               -4, _T("<and"), RTDXF0, _T("INSERT"), 8, _T("*"), -4, _T("and>"),  
			   -4, _T("or>"), NULL);
			XPoint ptPick;
			Entity entWall;
			int ret(0);
			INITGET_BEG(0, _T("R V"));
			ret = SelectEntity1(_T("\n请拾取靠近立管的墙线<退出>"), entWall, ptPick, rbMask);
			INITGET_END();
			if(ret == RTNONE || ret == RTCAN || ret == RTERROR)
				break;
			else if(ret != RTNORM)
				continue;
			if(entWall.Is(_T("ATS_WALL")) || entWall.Is(_T("INSERT"))){
				XCurveSegment lCurve, rCurve, SelCurve, TmpCurve;
				BOOL bIsLeft = TRUE;
                XPoint ptNew1, ptNew2;
                if(entWall.Is(_T("ATS_WALL"))){
                    OPENOBJ_BEGIN(entWall, AcDb::kForRead, TDbWall, pWall);
                    if(pWall) {
                        pWall->GetSideCurve(lCurve, rCurve);
                    }
                    OPENOBJ_END();
                }
                else{
                    GetExternalBlockWallSeg(entWall, lCurve, rCurve, ptPick);
                }

                lCurve.ProjectToMe(ptPick, ptNew1);
                rCurve.ProjectToMe(ptPick, ptNew2);
                if(ads_distance(ptPick, ptNew1) < ads_distance(ptPick, ptNew2)){
                    SelCurve = lCurve;
                    TmpCurve = rCurve;
                    bIsLeft = TRUE;
                }
                else{
                    SelCurve = rCurve;
                    TmpCurve = lCurve;
                    bIsLeft = FALSE;
                }

				double nRotate(0), nRotate2(0);
				if(!SelCurve.Is(CURVE_LINE)){
					ads_prompt(_T("不能选择弧墙！请重新选择墙线"));
					continue;
				}
				XPoint ptS = SelCurve.GetLine().StartPoint();
				XPoint ptE = SelCurve.GetLine().EndPoint();

				if(dlg.m_iPlace == 1){
					XPoint ptOther;
					//与哪边墙角近
					if(ads_distance(ptPick, ptS) < ads_distance(ptPick, ptE)){
						ptIns = ptS;
						ptOther = TmpCurve.GetLine().StartPoint();
						nRotate2 = ads_angle(ptS, ptE);
					}
					else{
						ptIns = ptE;
						ptOther = TmpCurve.GetLine().EndPoint();
						nRotate2 = ads_angle(ptS, ptE) + PI;
					}
					AcGeVector2d v1(AcGePoint2d(ptPick[0],ptPick[1]) - AcGePoint2d(ptIns[0],ptIns[1]));
					AcGeVector2d v2(AcGePoint2d(ptOther[0],ptOther[1]) - AcGePoint2d(ptIns[0],ptIns[1]));
					v1.normalize();
					v2.normalize();
					if(v1.dotProduct(v2) > 0.0000001){
						ads_prompt(_T("请重新选择墙线"));
						continue;
					}
					if(bIsLeft)
						nRotate = ads_angle(ptS, ptE);
					else
						nRotate = ads_angle(ptS, ptE) + PI;
				 
					ads_polar(ptIns, nRotate+(PI/2), g_nStandPipe2Wall, ptIns);
					ads_polar(ptIns, nRotate2, g_nStandPipe2Wall, ptIns);
					ptOld = ptIns;
				}
				else if(dlg.m_iPlace == 2){
					if(rCurve.GetLength() < 0.01){//沿线布置
						AcGeVector3d vectBase(lCurve.EndPoint().x - lCurve.StartPoint().x, lCurve.EndPoint().y - lCurve.StartPoint().y, 0);
						TPipeEdJig jig(ptPick, g_nPipeRadius[dlg.m_iPipeType], vectBase);
						jig.m_nLockAng = g_nStandPipe2Wall;
						jig.SetKeyword(_T("D"));
						jig.SetPrompt(_T("\n请指定立管的插入方向[距墙距离(D)]<退出>:"));
						while(1){
							int nKeyIdx;
							int nRetCode=jig.DoIt(&nKeyIdx);
							if(nRetCode==RTNORM){
								ptIns = jig.m_ptPick;
								break;
							}
							else if(nRetCode == RTKWORD){
								ads_getdist(ptPick, _T("\n请输入立管距墙的距离:"), &g_nStandPipe2Wall);
								jig.m_nLockAng = g_nStandPipe2Wall;
								continue;
							}
							else
								break;
						}
					}
					else{//沿墙布置
						ptIns = ptPick;
						if(bIsLeft)
							nRotate = ads_angle(ptS, ptE);
						else
							nRotate = ads_angle(ptS, ptE) + PI;
						ads_polar(ptIns, nRotate+(PI/2), g_nStandPipe2Wall, ptIns);
						ptOld = ptIns;
					}
				}
					
				
			}
			else{ //3.x版墙体
				XWall myWall(entWall);
				Entity entOther = myWall.GetNextWallLine(ptPick);
				if(!entOther){//单线
					XCurveSegment seg(entWall);
					AcGeVector3d vectBase(seg.EndPoint().x - seg.StartPoint().x, seg.EndPoint().y - seg.StartPoint().y, 0);
					TPipeEdJig jig(ptPick, g_nPipeRadius[dlg.m_iPipeType], vectBase);
					jig.m_nLockAng = g_nStandPipe2Wall;
					jig.SetKeyword(_T("D"));
					jig.SetPrompt(_T("\n请指定立管的插入方向[距墙距离(D)]<退出>:"));
					while(1){
						int nKeyIdx;
						int nRetCode=jig.DoIt(&nKeyIdx);
						if(nRetCode==RTNORM){
							ptIns = jig.m_ptPick;
							break;
						}
						else if(nRetCode == RTKWORD){
							ads_getdist(ptPick, _T("\n请输入立管距墙的距离:"), &g_nStandPipe2Wall);
							jig.m_nLockAng = g_nStandPipe2Wall;
							continue;
						}
						else
							break;
					}
				}
				else{//3.x版墙体
					XCurveSegment SelCurve(entWall);
					XCurveSegment TmpCurve(entOther);
					double angleWall = ads_angle(SelCurve.GetStartPoint(), SelCurve.GetEndPoint());
					double angleWall1 = angleWall;
					double angleWall2 = ads_angle(TmpCurve.GetStartPoint(), TmpCurve.GetEndPoint());
					double dn = fabs(angleWall2 - angleWall1);
					if(fabs(dn - PI) < 0.0001){ //逆向平行
						XLine line(TmpCurve.EndPoint(), TmpCurve.StartPoint(), 1);
						TmpCurve = line;        //纠正过来
					}
					if(TmpCurve.OnWhichSide(ptPick) == OFFSET_RIGHT)
						angleWall = angleWall + PI;
					double nRotate2(0);
					XPoint ptS = SelCurve.GetLine().StartPoint();
					XPoint ptE = SelCurve.GetLine().EndPoint();
					if(dlg.m_iPlace == 1){
						XPoint ptOther;
						if(ads_distance(ptPick, ptS) < ads_distance(ptPick, ptE)){
							ptIns = ptS;
							ptOther = TmpCurve.GetLine().StartPoint();
							nRotate2 = ads_angle(ptS, ptE);
						}
						else{
							ptIns = ptE;
							ptOther = TmpCurve.GetLine().EndPoint();
							nRotate2 = ads_angle(ptS, ptE) + PI;
						}
						AcGeVector2d v1(AcGePoint2d(ptPick[0],ptPick[1]) - AcGePoint2d(ptIns[0],ptIns[1]));
						AcGeVector2d v2(AcGePoint2d(ptOther[0],ptOther[1]) - AcGePoint2d(ptIns[0],ptIns[1]));
						v1.normalize();
						v2.normalize();
						if(v1.dotProduct(v2) > 0.0000001){
							ads_prompt(_T("请重新选择墙线"));
							continue;
						}
						ads_polar(ptIns, angleWall+(PI/2), g_nStandPipe2Wall, ptIns);
						ads_polar(ptIns, nRotate2, g_nStandPipe2Wall, ptIns);
					}
					else if(dlg.m_iPlace == 2){
						ptIns = ptPick;
						ads_polar(ptIns, angleWall+(PI/2), g_nStandPipe2Wall, ptIns);
						ptOld = ptIns;
					}
				}
			}
		}
		InitPipeLayer(dlg.GetLayer());
		int iPipeIdx = GetPipeLayerIdxByName(dlg.GetLayer());
		CString csMat = GetPipeMaterialByIdx(g_iPipeMaterial[iPipeIdx]);
		CString csDnHead = GetDnByMat(csMat);
		
        TDbPipe *pPipe=new TDbPipe;

        PickSet ss(SS_FREE);
        GetPointPickSet(ptIns, ss, rbMaskPipe, 50);
        double len = ss.Length();

        ptIns.z = dlg.m_nEleDown*dMeter;
        pPipe->SetStartPoint(ptIns);
        ptIns.z = dlg.m_nEleUp*dMeter;
        pPipe->SetEndPoint(ptIns);
        pPipe->setLinetype(_T("CONTINUOUS"));
		pPipe->setLayer(dlg.GetLayer());
		pPipe->SetSysType(dlg.GetPipeSysType());
        pPipe->SetDnDiameter(_ttoi(dlg.m_csDn));
        pPipe->SetModelType(TPipeSys::kModel);
        pPipe->SetMaterial(g_iPipeMaterial[iPipeIdx]);
	//	pPipe->SetPipeWeight(dlg.GetPipeWeight());
		pPipe->SetPipeWeight(g_nPipeWidth[iPipeIdx]);
		pPipe->SetRadius(g_nPipeRadius[iPipeIdx]);
		pPipe->SetLabel(csDnHead);
		if(g_bPipeDouble[iPipeIdx])
			pPipe->SetRadiusIn(g_nPipeRadius[iPipeIdx] / 2);
		else
		{
			if(!g_bStandPipeArc)//传统扣弯
                pPipe->SetRadiusIn(-2);
		}
		pPipe->setColor(AcCmColor()); //随层
		AcDbObjectId id = AddToCurrentSpace(pPipe, Adesk::kTrue);
	 
        CString csDim = g_csPipeDim[iPipeIdx] + _T("L");

        if(!g_bIsPipeDimCir || g_bIsPipeDimCir == 3)
            csDim += _T("-");
        Entity entLast;
        entLast.GetLast();
        WriteXdata(entLast, _T("PIPE-SERIAL"), dlg.m_csName);        
		if(_tcsicmp(dlg.m_csFloorName, _T("")) != 0)
			WriteXdata(entLast,_T("BUILDING-SERIAL"),dlg.m_csFloorName);
		
		DoDimStandPipe(id, csDim, dlg.m_csName);
        dlg.UpdateData(TRUE);
	//  cet 2013.3.12 modify 递增编号支持非纯数字
	//	dlg.m_csName.Format(_T("%d"), _ttoi(dlg.m_csName) + 1);
		dlg.UpdateSerial();
		dlg.UpdateData(FALSE);
	}
 
	dlg.DestroyWindow(); 
    SHads_command(RTSTR, _T(".REDRAW"), RTNONE);
}




/////////////////////////////////////////////////////////////////////////////
// CDrawStandPipeDlg dialog

extern BOOL GetLayerReMark(const TCHAR *szLayer, CString &sRemark);

IMPLEMENT_DYNAMIC(CDrawStandPipeDlg, CModelessDialog)
int	CDrawStandPipeDlg::m_iPipeType = 0;
int	CDrawStandPipeDlg::m_iPipeType2 = 0;  // cet 2011.12.1 add
int	CDrawStandPipeDlg::m_iPipeType3 = 9;  // cet 2011.12.1 add
int	CDrawStandPipeDlg::m_iPlace = 0;
int	CDrawStandPipeDlg::m_iPos = 0;
CString CDrawStandPipeDlg::m_csDn = _T("-1");
CString CDrawStandPipeDlg::m_csName = _T("1");
CString CDrawStandPipeDlg::m_csEle = _T("0");
CString CDrawStandPipeDlg::m_csFloorName = _T("");
std::map<double, bool>  CDrawStandPipeDlg::m_mapAngle; // cet 2012.3.15 add
DWORD CDrawStandPipeDlg::m_nSelSerialID = WM_USER + 1; // cet 2013.3.13 编号菜单默认选项
std::map<int, std::map<CString, CString> > CDrawStandPipeDlg::m_mapPipeSerial;

CDrawStandPipeDlg::CDrawStandPipeDlg(int iType, CWnd* pParent /*=NULL*/)
	: CModelessDialog(CDrawStandPipeDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CDrawStandPipeDlg)
	m_csDim1 = _T("J");
	m_csDim2 = _T("RJ");
	m_csDim3 = _T("RH");
	m_csDim4 = _T("W");
	m_csDim5 = _T("F");
	m_csDim6 = _T("Y");
	m_csDim7 = _T("Z");
	m_csDim8 = _T("X");
	m_csDim9 = _T("H");
	m_nEleDown = 0;
	m_nEleUp = 3;
	m_csDim10 = _T("");
	m_bLockAngle = FALSE;
	//}}AFX_DATA_INIT
	m_spinName.SetBase(1);
   
    if(m_csDn == _T("-1"))
        m_csDn = Itoa(g_iDefaultPipeDn);
	m_iPipeMode = iType;
    m_pMenu = NULL;
	m_pMenuEle = NULL;   // cet 2010.6.23 add
	m_bEle = false;      // cet 2010.6.23 add
	m_pMenuAngle = NULL; // cet 2012.3.15 add
	m_bSendCmdKeyToCAD = FALSE; // cet 2012.3.16 add
	m_pMenuSerial = NULL; // cet 2013.3.13 add
	m_bOpeningMenuSerial = false; // cet 2013.3.18 add
	m_bInitDlg = false; // zxl 2013.10.17 add
}

CDrawStandPipeDlg::~CDrawStandPipeDlg()
{
	if(::IsWindow(m_hWnd))
		DestroyWindow();
	
    if(m_pMenu != NULL) {
        m_pMenu->DestroyMenu();
        delete m_pMenu;
    }

	// 清除角度菜单 cet 2012.3.16 add
	if (m_pMenuAngle != NULL)
	{
		m_pMenuAngle->DestroyMenu();
		delete m_pMenuAngle;
	}

	// cet 2012.10.18 add
	if (m_pMenuEle != NULL)
	{
		m_pMenuEle->DestroyMenu();
		delete m_pMenuEle;
	}

	// cet 2013.3.13 add
	if (m_pMenuSerial != NULL)
	{
		m_pMenuSerial->DestroyMenu();
		delete m_pMenuSerial;
	}
}    

void CDrawStandPipeDlg::DoDataExchange(CDataExchange* pDX)
{
	CModelessDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CDrawStandPipeDlg)
	DDX_Control(pDX, IDC_COMBO_DN, m_comboDn);
	DDX_Control(pDX, IDC_SPIN_NAME, m_spinName);
	DDX_Text(pDX, IDC_STATIC_1, m_csDim1);
	DDX_Text(pDX, IDC_STATIC_2, m_csDim2);
	DDX_Text(pDX, IDC_STATIC_3, m_csDim3);
	DDX_Text(pDX, IDC_STATIC_4, m_csDim4);
	DDX_Text(pDX, IDC_STATIC_5, m_csDim5);
	DDX_Text(pDX, IDC_STATIC_6, m_csDim6);
	DDX_Text(pDX, IDC_STATIC_7, m_csDim7);
	DDX_Text(pDX, IDC_STATIC_8, m_csDim8);
	DDX_Text(pDX, IDC_STATIC_9, m_csDim9);
	DDX_Text(pDX, IDC_EDIT_ELE_DOWN, m_nEleDown);
	DDX_Text(pDX, IDC_EDIT_ELE_UP, m_nEleUp);
	DDX_Text(pDX, IDC_STATIC_10, m_csDim10);
	DDX_Text(pDX, IDC_EDIT_NAME, m_csName);
	DDX_Radio(pDX, IDC_RADIO_PIPETYPE1, m_iPipeType2); // cet 2011.12.1 modify
	DDX_Radio(pDX, IDC_RADIO_PLACE1, m_iPlace);
  //DDX_CBString(pDX, IDC_COMBO_DN, m_csDn); cet 2012.8.30 del
	DDX_Text(pDX, IDC_EDIT_ELEVATION, m_csEle);
	DDX_Text(pDX, IDC_EDIT_FLOOR_NAME, m_csFloorName);
	DDX_Radio(pDX, IDC_RADIO_POS1, m_iPos);
	DDX_Check(pDX, IDC_CHECK_LOCKANGLE, m_bLockAngle);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CDrawStandPipeDlg, CModelessDialog)
	//{{AFX_MSG_MAP(CDrawStandPipeDlg)
	ON_WM_CLOSE()
	ON_BN_CLICKED(IDC_RADIO_PLACE1, OnRadioPlace1)
	ON_BN_CLICKED(IDC_RADIO_PLACE2, OnRadioPlace2)
	ON_BN_CLICKED(IDC_RADIO_PLACE3, OnRadioPlace3)
	ON_BN_CLICKED(IDC_BUTTON_SETTING, OnButtonSetting)
	ON_BN_CLICKED(IDC_RADIO_PIPETYPE1, OnRadioPipetype1)
	ON_BN_CLICKED(IDC_RADIO_PIPETYPE2, OnRadioPipetype2)
	ON_BN_CLICKED(IDC_RADIO_PIPETYPE3, OnRadioPipetype3)
	ON_BN_CLICKED(IDC_RADIO_PIPETYPE4, OnRadioPipetype4)
	ON_BN_CLICKED(IDC_RADIO_PIPETYPE5, OnRadioPipetype5)
	ON_BN_CLICKED(IDC_RADIO_PIPETYPE6, OnRadioPipetype6)
	ON_BN_CLICKED(IDC_RADIO_PIPETYPE7, OnRadioPipetype7)
	ON_BN_CLICKED(IDC_RADIO_PIPETYPE8, OnRadioPipetype8)
	ON_BN_CLICKED(IDC_RADIO_PIPETYPE9, OnRadioPipetype9)
	ON_BN_CLICKED(IDC_RADIO_PIPETYPE10, OnRadioPipetype10)
	/* cet 2011.12.1 del
	ON_BN_CLICKED(IDC_RADIO_PIPETYPE11, OnRadioPipetype11)
	ON_BN_CLICKED(IDC_RADIO_PIPETYPE12, OnRadioPipetype12)
	ON_BN_CLICKED(IDC_RADIO_PIPETYPE13, OnRadioPipetype13)
	ON_BN_CLICKED(IDC_RADIO_PIPETYPE14, OnRadioPipetype14)
	ON_BN_CLICKED(IDC_RADIO_PIPETYPE15, OnRadioPipetype15)
	ON_BN_CLICKED(IDC_RADIO_PIPETYPE16, OnRadioPipetype16)
	ON_BN_CLICKED(IDC_RADIO_PIPETYPE17, OnRadioPipetype17)
	*/
	ON_BN_CLICKED(IDC_BUTTON_MENU, OnButtonMenu)
	ON_BN_CLICKED(IDC_BTN_SERIAL, OnButtonSerial)
	ON_BN_CLICKED(IDC_BUTTON_ANGLEMENU, OnButtonAngleMenu)
	ON_WM_DESTROY()
	ON_BN_CLICKED(IDC_CHECK_LOCKANGLE, OnCheckLockangle)
	ON_BN_CLICKED(IDC_RADIO_POS1, OnRadioPos1)
	ON_BN_CLICKED(IDC_RADIO_POS2, OnRadioPos2)
	ON_BN_CLICKED(IDC_RADIO_POS3, OnRadioPos3)
	ON_CBN_EDITCHANGE(IDC_COMBO_DN, OnEditChangeComboDn)
	ON_CBN_SELCHANGE(IDC_COMBO_DN, OnSelchangeComboDn)
	ON_EN_CHANGE(IDC_EDIT_FLOOR_NAME, OnEditChangeFloorName)
	ON_MESSAGE(WM_ACAD_KEEPFOCUS, onAcadKeepFocus)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CDrawStandPipeDlg message handlers

LONG_PTR CDrawStandPipeDlg::onAcadKeepFocus(UINT_PTR, LONG_PTR)
{
	CWnd *pFoucsWnd = CDrawStandPipeDlg::GetFocus();
	if (pFoucsWnd != NULL && (pFoucsWnd->GetDlgCtrlID() == IDC_EDIT_ELEVATION || pFoucsWnd->GetDlgCtrlID() == 1001 
		|| pFoucsWnd->GetDlgCtrlID() == IDC_EDIT_NAME || pFoucsWnd->GetDlgCtrlID() == IDC_EDIT_ELE_DOWN 
		|| pFoucsWnd->GetDlgCtrlID() == IDC_EDIT_ELE_UP || pFoucsWnd->GetDlgCtrlID() == IDC_EDIT_FLOOR_NAME))
	{
		return TRUE;
	}
	CPoint pt;
	GetCursorPos(&pt);
	CRect rc;
	GetWindowRect(&rc);
	return (rc.PtInRect(pt) ? TRUE : FALSE);
}

BOOL CDrawStandPipeDlg::OnInitDialog() 
{
	CModelessDialog::OnInitDialog();
	m_spinName.SetRange(1, 100);
    CWnd *pWnd5 = GetDlgItem(IDC_STATIC_SET);
    CWnd *pWnd6 = GetDlgItem(IDC_RADIO_PLACE1);
    CWnd *pWnd3 = GetDlgItem(IDC_RADIO_PLACE2);
    CWnd *pWnd4 = GetDlgItem(IDC_RADIO_PLACE3);
    CWnd *pWnd9 = GetDlgItem(IDC_STATIC_NAME);
    CWnd *pWnd12 = GetDlgItem(IDC_SPIN_NAME);    
    CWnd *pWnd10 = GetDlgItem(IDC_EDIT_ELEVATION);
    CWnd *pWnd11 = GetDlgItem(IDC_EDIT_NAME);
	CWnd *pWndM = GetDlgItem(IDC_BUTTON_MENU);			// cet 2010.6.23 add
	CWnd *pWnd13 = GetDlgItem(IDC_CHECK_LOCKANGLE);		// cet 2011.7.27 add
	CWnd *pWnd14 = GetDlgItem(IDC_STATIC_BOTTOMELE);	// cet 2011.7.27 add
	CWnd *pWnd15 = GetDlgItem(IDC_EDIT_ELE_DOWN);		// cet 2011.7.27 add
	CWnd *pWnd16 = GetDlgItem(IDC_BUTTON_ANGLEMENU);    // cet 2012.3.15 add
	CWnd *pWnd17 = GetDlgItem(IDC_BTN_SERIAL);          // cet 2013.3.13 add
    if(m_iPipeMode == 1){
        SetWindowText(_T("立管"));
        pWnd5->SetWindowText(_T("布置方式"));
        pWnd6->SetWindowText(_T("任意布置"));
        pWnd3->SetWindowText(_T("墙角布置"));
        pWnd4->SetWindowText(_T("沿墙布置"));
        m_iPlace = 0;
        pWnd10->ShowWindow(SW_HIDE);
		pWndM->ShowWindow(SW_HIDE);  // cet 2010.6.23 add
		pWnd13->ShowWindow(SW_HIDE); // cet 2011.7.27 add
		pWnd16->ShowWindow(SW_HIDE); // cet 2012.3.15 add
		InitMenuSerial();            // cet 2013.3.13 add
		UpdateSpinVisible();         // cet 2013.3.13 add
    }
	else if(m_iPipeMode == 0){
		CRegProperty regProp(GetRegLocation(), _T("TWT7"));    
		regProp.SetTopRootKey(HKEY_CURRENT_USER);
		CString csMenu;
		regProp.GetValue(_T("menu"), csMenu);
		
		if(csMenu.Find(_T("OUT")) > -1 || csMenu.Find(_T("out")) > -1){
			m_comboDn.ResetContent();
			m_csDn = _T("200");
			m_comboDn.AddString(_T("200"));
			m_comboDn.AddString(_T("300"));
			m_comboDn.AddString(_T("350"));
			m_comboDn.AddString(_T("400"));
			m_comboDn.AddString(_T("500"));   
			m_comboDn.AddString(_T("600"));
			m_comboDn.AddString(_T("700"));
			m_comboDn.AddString(_T("800"));
			m_comboDn.AddString(_T("900"));
			m_comboDn.AddString(_T("1000"));
		}
		SetWindowText(_T("管线"));
        pWnd5->SetWindowText(_T("等标高管线交叉"));
        pWnd6->SetWindowText(_T("生成四通"));
        pWnd3->SetWindowText(_T("管线置上"));
        pWnd4->SetWindowText(_T("管线置下"));
		CWnd *pWnd1 = GetDlgItem(IDC_STATIC_NAME);
		CWnd *pWnd2 = GetDlgItem(IDC_SPIN_NAME);
		pWnd9->SetWindowText(_T("标高(m)："));

		// cet 2010.6.23 add 修改标高编辑框的大小
		int nWidth = 0, nHeight = 0;
		CRect rec;
		pWnd10->GetWindowRect(&rec);
		pWnd10->GetParent()->ScreenToClient(&rec);
		nWidth = rec.Width();
		nHeight = rec.Height();
		CPoint ptL = rec.TopLeft();
		pWnd10->MoveWindow(ptL.x, ptL.y, nWidth * 2 / 3, nHeight);

        pWnd10->ShowWindow(SW_SHOW);
        pWnd11->ShowWindow(SW_HIDE);
        pWnd12->ShowWindow(SW_HIDE);
		pWnd14->ShowWindow(SW_HIDE);  // cet 2011.7.27 add
        pWnd15->ShowWindow(SW_HIDE);  // cet 2011.7.27 add
		pWnd17->ShowWindow(SW_HIDE);  // cet 2013.3.13 add
		m_spinName.SetBase(10);
        CRect rect;
        this->GetWindowRect(&rect);
        // rect.bottom -= 78; cet 2011.7.27 modify
		rect.bottom -= 52;	
        this->MoveWindow(&rect);
        if(fabs(_tstof(m_csEle)) < 0.01)
            m_csEle = _T("0");
		InitAngleData(); // cet 2012.3.15 add

	}
	ResetShowRadio();
	ResetRegion();

	m_csDim1 = g_csPipeDim[0];
	m_csDim2 = g_csPipeDim[1];
	m_csDim3 = g_csPipeDim[2];
	m_csDim4 = g_csPipeDim[3];
	m_csDim5 = g_csPipeDim[4];
	m_csDim6 = g_csPipeDim[5];
	m_csDim7 = g_csPipeDim[6];
	m_csDim8 = g_csPipeDim[7];
    m_csDim9 = g_csPipeDim[8];
	m_csDim10 = g_csPipeDim[m_iPipeType3];
	UpdateData(FALSE);
	// cet 2010.6.23 add
	ReadWriteData();
    UpdateData(FALSE);
	// cet 2011.12.14 add 根据管线当前选择的低中高区设置标注文字
	UpdateDimText();
	// cet 2012.3.15 add 根据是否使用角度盘更新角度菜单可用性
	if (m_iPipeMode == 0)
	{
		EnableAngleMenu(m_bLockAngle); 
	}
	// 更新管径 cet 2012.8.30
	UpdatePipeDn(FALSE);
	m_bInitDlg = true; // zxl 2013.10.17 add
	return TRUE;  
}

void CDrawStandPipeDlg::ResetShowRadio() 
{
/*  cet 2011.12.1 modify
 	//其他
    CWnd *pWnd10 = GetDlgItem(IDC_RADIO_PIPETYPE10);
    CWnd *pWnd11 = GetDlgItem(IDC_RADIO_PIPETYPE11);
    CWnd *pWnd12 = GetDlgItem(IDC_RADIO_PIPETYPE12);
    CWnd *pWnd13 = GetDlgItem(IDC_RADIO_PIPETYPE13);
    CWnd *pWnd14 = GetDlgItem(IDC_RADIO_PIPETYPE14);
    CWnd *pWnd15 = GetDlgItem(IDC_RADIO_PIPETYPE15);//其它
    CWnd *pWnd16 = GetDlgItem(IDC_RADIO_PIPETYPE16);
    CWnd *pWnd17 = GetDlgItem(IDC_RADIO_PIPETYPE17);
	
    pWnd10->ShowWindow(SW_HIDE);
    pWnd11->ShowWindow(SW_HIDE);
    pWnd12->ShowWindow(SW_HIDE);
    pWnd13->ShowWindow(SW_HIDE);
    pWnd14->ShowWindow(SW_HIDE);
    pWnd15->ShowWindow(SW_HIDE);
    pWnd16->ShowWindow(SW_HIDE);
    pWnd17->ShowWindow(SW_HIDE);
	
	pWnd10->EnableWindow(FALSE);
	pWnd11->EnableWindow(FALSE);
	pWnd12->EnableWindow(FALSE);
	pWnd13->EnableWindow(FALSE);
	pWnd14->EnableWindow(FALSE);
	pWnd15->EnableWindow(FALSE);
	pWnd16->EnableWindow(FALSE);
	pWnd17->EnableWindow(FALSE);
    
    pWnd10->SetWindowText(g_csPipeName[0]);
    pWnd11->SetWindowText(g_csPipeName[1]);
    pWnd12->SetWindowText(g_csPipeName[2]);
    pWnd13->SetWindowText(g_csPipeName[3]);
    pWnd14->SetWindowText(g_csPipeName[4]);
    pWnd16->SetWindowText(g_csPipeName[5]);
    pWnd17->SetWindowText(g_csPipeName[6]);

    if(m_iPipeType == 9)
	{
        pWnd10->EnableWindow(TRUE);
        pWnd10->ShowWindow(SW_SHOW);
	}
    else if(m_iPipeType == 10)
	{
        pWnd11->EnableWindow(TRUE);
        pWnd11->ShowWindow(SW_SHOW);
	}
    else if(m_iPipeType == 11)
	{
        pWnd12->EnableWindow(TRUE);
        pWnd12->ShowWindow(SW_SHOW);
	}
    else if(m_iPipeType == 12)
	{
        pWnd13->EnableWindow(TRUE);
        pWnd13->ShowWindow(SW_SHOW);
	}
    else if(m_iPipeType == 13)
	{
        pWnd14->EnableWindow(TRUE);
        pWnd14->ShowWindow(SW_SHOW);
	}
    else if(m_iPipeType == 15)
	{
        pWnd16->EnableWindow(TRUE);
        pWnd16->ShowWindow(SW_SHOW);
	}
    else if(m_iPipeType == 16)
	{
        pWnd17->EnableWindow(TRUE);
        pWnd17->ShowWindow(SW_SHOW);
	}
    else
	{
        pWnd15->EnableWindow(TRUE);
        pWnd15->ShowWindow(SW_SHOW);
	}
*/
	CWnd *pWnd = GetDlgItem(IDC_RADIO_PIPETYPE10);
	if (pWnd == NULL)
	{
		return;
	}
	
	std::vector<CString> vecPipeName;
	GetPipeName(vecPipeName);
	if (m_iPipeType3 == 9)
	{
		pWnd->SetWindowText(vecPipeName[0]);
	}
	else if (m_iPipeType3 == 10)
	{
		pWnd->SetWindowText(vecPipeName[1]);
	}
	else if (m_iPipeType3 == 11)
	{
		pWnd->SetWindowText(vecPipeName[2]);
	}
	else if (m_iPipeType3 == 12)
	{
		pWnd->SetWindowText(vecPipeName[3]);
	}
	else if (m_iPipeType3 == 13)
	{
		pWnd->SetWindowText(vecPipeName[4]);
	}
	else if (m_iPipeType3 == 14)
	{
		pWnd->SetWindowText(_T("其它管"));
	}
	else if (m_iPipeType3 == 15)
	{
		pWnd->SetWindowText(vecPipeName[5]);
	}
	else if (m_iPipeType3 == 16)
	{
		pWnd->SetWindowText(vecPipeName[6]);
	}
	else if (m_iPipeType3 == 29)
	{
		pWnd->SetWindowText(vecPipeName[7]);
	}
	else if (m_iPipeType3 == 30)
	{
		pWnd->SetWindowText(vecPipeName[8]);
	}
	else if (m_iPipeType3 == 31)
	{
		pWnd->SetWindowText(vecPipeName[9]);
	}
	else if (m_iPipeType3 == 32)
	{
		pWnd->SetWindowText(vecPipeName[10]);
	}
	else if (m_iPipeType3 == 33)
	{
		pWnd->SetWindowText(vecPipeName[11]);
	}
	else if (m_iPipeType3 == 34)
	{
		pWnd->SetWindowText(vecPipeName[12]);
	}

	CString sText;
	pWnd->GetWindowText(sText);
	if (sText.Find(_T("↓")) == -1)
	{
		sText+=_T("↓");
		pWnd->SetWindowText(sText);
	}
	m_csDim10 = g_csPipeDim[m_iPipeType3]; // 更新下拉菜单当前项对应的标注文字
}

void CDrawStandPipeDlg::OnClose() 
{
	CModelessDialog::OnClose();
	acedPostCommand(_T("\33\33"));
}

TPipeSys::SysType CDrawStandPipeDlg::GetPipeSysType()
{
	UpdateData();
	if(m_iPipeType == 0)
	{
		//cet 2011.12.6 modify
		//return TPipeSys::kFeedWater;
		if (m_iPos == 0)
		{
			return TPipeSys::kFeedWater;
		}
		else if (m_iPos == 1)
		{
			return TPipeSys::kFeedWater2;
		}
		else
		{
			return TPipeSys::kFeedWater3;
		}
	}
	else if(m_iPipeType == 1)
	{
		//cet 2011.12.6 modify 
		//return TPipeSys::kHeatFeedWater;
		if (m_iPos == 0)
		{
			return TPipeSys::kHeatFeedWater;
		}
		else if (m_iPos == 1)
		{
			return TPipeSys::kHeatFeedWater2;
		}
		else
		{
			return TPipeSys::kHeatFeedWater3;
		}
	}
	else if(m_iPipeType == 2)
	{
		//cet 2011.12.6 modify
		//return TPipeSys::kHeatBackWater;
		if (m_iPos == 0)
		{
			return TPipeSys::kHeatBackWater;
		}
		else if (m_iPos == 1)
		{
			return TPipeSys::kHeatBackWater2;
		} 
		else
		{
			return TPipeSys::kHeatBackWater3;
		}
	}
	else if(m_iPipeType == 3)
		return TPipeSys::kDirtWater;
	else if(m_iPipeType == 4)
		return TPipeSys::kUselessWater;
	else if(m_iPipeType == 5)
		return TPipeSys::kRainWater;
	else if(m_iPipeType == 6)
	{
		//cet 2011.12.6 modify
		//return TPipeSys::kUsedWater;
		if (m_iPos == 0)
		{
			return TPipeSys::kUsedWater;
		}
		else if (m_iPos == 1)
		{
			return TPipeSys::kUsedWater2;
		} 
		else
		{
			return TPipeSys::kUsedWater3;
		}
	}
	else if(m_iPipeType == 7)
	{
		//cet 2011.12.6 modify
		//return TPipeSys::kFireFighting;
		if (m_iPos == 0)
		{
			return TPipeSys::kFireFighting;
		}
		else if (m_iPos == 1)
		{
			return TPipeSys::kFireFighting2;
		} 
		else
		{
			return TPipeSys::kFireFighting3;
		}
	}
	else if(m_iPipeType == 8)
	{
		//cet 2011.12.6 modify
		//return TPipeSys::kSprinkle;
		if (m_iPos == 0)
		{
			return TPipeSys::kSprinkle;
		}
		else if (m_iPos == 1)
		{
			return TPipeSys::kSprinkle2;
		} 
		else
		{
			return TPipeSys::kSprinkle3;
		}
	}
	else if(m_iPipeType == 9)
		return TPipeSys::kCoagulate;
    else if(m_iPipeType == 10)
        return TPipeSys::kDrink;
    else if(m_iPipeType == 11)
        return TPipeSys::kPressDirt;
    else if(m_iPipeType == 12)
        return TPipeSys::kPressUseless;
    else if(m_iPipeType == 13)
        return TPipeSys::kPressRain;
    else if(m_iPipeType == 14)
        return TPipeSys::kOther;
    else if(m_iPipeType == 15)
        return TPipeSys::kCivilFeed;
    else if(m_iPipeType == 16)
        return TPipeSys::kCycleFeed;
	else if (m_iPipeType == 29) // cet 2011.12.1 add 29-34
	{
		return TPipeSys::kUser3;
	}
	else if (m_iPipeType == 30)
	{
		return TPipeSys::kUser4;
	}
	else if (m_iPipeType == 31)
	{
		return TPipeSys::kUser5;
	}
	else if (m_iPipeType == 32)
	{
		return TPipeSys::kUser6;
	}
	else if (m_iPipeType == 33)
	{
		return TPipeSys::kUser7;
	}
	else if (m_iPipeType == 34)
	{
		return TPipeSys::kUser8;
	}
	else
		return TPipeSys::kUnknownSys;
}
 
const TCHAR* CDrawStandPipeDlg::GetLayer() 
{
	UpdateData();
	if(m_iPipeMode == 1){
		if(m_iPipeType == 0)
		{
			if(m_iPos == 0)
				return LAY_VPIPE_FEED;
			else if(m_iPos == 1)
				return LAY_VPIPE_FEED2;
			else if(m_iPos == 2)
				return LAY_VPIPE_FEED3;
		}
		else if(m_iPipeType == 1)
		{
			if(m_iPos == 0)
				return LAY_VPIPE_HEADFEED;
			else if(m_iPos == 1)
				return LAY_VPIPE_HEADFEED2;
			else if(m_iPos == 2)
				return LAY_VPIPE_HEADFEED3;
		}
		else if(m_iPipeType == 2)
		{
			if(m_iPos == 0)
				return LAY_VPIPE_HEADBACK;
			else if(m_iPos == 1)
				return LAY_VPIPE_HEADBACK2;
			else if(m_iPos == 2)
				return LAY_VPIPE_HEADBACK3;
		}
		else if(m_iPipeType == 3)
			return LAY_VPIPE_DIRT;
		else if(m_iPipeType == 4)
			return LAY_VPIPE_USELESS;
		else if(m_iPipeType == 5)
			return LAY_VPIPE_RAIN;
		else if(m_iPipeType == 6)
		{
			if(m_iPos == 0)
				return LAY_VPIPE_USED;
			else if(m_iPos == 1)
				return LAY_VPIPE_USED2;
			else if(m_iPos == 2)
				return LAY_VPIPE_USED3;
		}
		else if(m_iPipeType == 7)
		{
			if(m_iPos == 0)
				return LAY_VPIPE_FIRE;
			else if(m_iPos == 1)
				return LAY_VPIPE_FIRE2;
			else if(m_iPos == 2)
				return LAY_VPIPE_FIRE3;
		}
		else if(m_iPipeType == 8)
		{
			if(m_iPos == 0)
				return LAY_VPIPE_SPRINKLE;
			else if(m_iPos == 1)
				return LAY_VPIPE_SPRINKLE2;
			else if(m_iPos == 2)
				return LAY_VPIPE_SPRINKLE3;
		}
		else if(m_iPipeType == 9)
			return LAY_VPIPE_COAGULATE;
		else if(m_iPipeType == 10)
			return LAY_VPIPE_DRINK;
		else if(m_iPipeType == 11)
			return LAY_VPIPE_PRESSDIRT;
		else if(m_iPipeType == 12)
			return LAY_VPIPE_PRESSUSELESS;
		else if(m_iPipeType == 13)
			return LAY_VPIPE_PRESSRAIN;
		else if(m_iPipeType == 14)
			return LAY_VPIPE_OTHER;
		else if(m_iPipeType == 15)
			return LAY_VPIPE_USER1;
		else if(m_iPipeType == 16)
			return LAY_VPIPE_USER2;
		else if (m_iPipeType == 29) // cet 2011.12.1 add 29-34
		{
			return LAY_VPIPE_USER3;
		}
		else if (m_iPipeType == 30)
		{
			return LAY_VPIPE_USER4;
		}
		else if (m_iPipeType == 31)
		{
			return LAY_VPIPE_USER5;
		}
		else if (m_iPipeType == 32)
		{
			return LAY_VPIPE_USER6;
		}
		else if (m_iPipeType == 33)
		{
			return LAY_VPIPE_USER7;
		}
		else if (m_iPipeType == 34)
		{
			return LAY_VPIPE_USER8;
		}
		else
			return _T("");
	}
	else{
		if(m_iPipeType == 0) 
		{
			if(m_iPos == 0)
				return LAY_PIPE_FEED;
			else if(m_iPos == 1)
				return LAY_PIPE_FEED2;
			else if(m_iPos == 2)
				return LAY_PIPE_FEED3;
		}
		else if(m_iPipeType == 1)
		{
			if(m_iPos == 0)
				return LAY_PIPE_HEADFEED;
			else if(m_iPos == 1)
				return LAY_PIPE_HEADFEED2;
			else if(m_iPos == 2)
				return LAY_PIPE_HEADFEED3;
		}
		else if(m_iPipeType == 2)
		{
			if(m_iPos == 0)
				return LAY_PIPE_HEADBACK;
			else if(m_iPos == 1)
				return LAY_PIPE_HEADBACK2;
			else if(m_iPos == 2)
				return LAY_PIPE_HEADBACK3;
		}
		else if(m_iPipeType == 3)
			return LAY_PIPE_DIRT;
		else if(m_iPipeType == 4)
			return LAY_PIPE_USELESS;
		else if(m_iPipeType == 5)
			return LAY_PIPE_RAIN;
		else if(m_iPipeType == 6)
		{
			if(m_iPos == 0)
				return LAY_PIPE_USED;
			else if(m_iPos == 1)
				return LAY_PIPE_USED2;
			else if(m_iPos == 2)
				return LAY_PIPE_USED3;
		}
		else if(m_iPipeType == 7)
		{
			if(m_iPos == 0)
				return LAY_PIPE_FIRE;
			else if(m_iPos == 1)
				return LAY_PIPE_FIRE2;
			else if(m_iPos == 2)
				return LAY_PIPE_FIRE3;
		}
		else if(m_iPipeType == 8)
		{
			if(m_iPos == 0)
				return LAY_PIPE_SPRINKLE;
			else if(m_iPos == 1)
				return LAY_PIPE_SPRINKLE2;
			else if(m_iPos == 2)
				return LAY_PIPE_SPRINKLE3;
		}
		else if(m_iPipeType == 9)
			return LAY_PIPE_COAGULATE;
		else if(m_iPipeType == 10)
			return LAY_PIPE_DRINK;
		else if(m_iPipeType == 11)
			return LAY_PIPE_PRESSDIRT;
		else if(m_iPipeType == 12)
			return LAY_PIPE_PRESSUSELESS;
		else if(m_iPipeType == 13)
			return LAY_PIPE_PRESSRAIN;
		else if(m_iPipeType == 14)
			return LAY_PIPE_OTHER;
		else if(m_iPipeType == 15)
			return LAY_PIPE_USER1;
		else if(m_iPipeType == 16)
			return LAY_PIPE_USER2;
		else if (m_iPipeType == 29) // cet 2011.12.1 add 29-34
		{
			return LAY_PIPE_USER3;
		}
		else if (m_iPipeType == 30)
		{
			return LAY_PIPE_USER4;
		}
		else if (m_iPipeType == 31)
		{
			return LAY_PIPE_USER5;
		}
		else if (m_iPipeType == 32)
		{
			return LAY_PIPE_USER6;
		}
		else if (m_iPipeType == 33)
		{
			return LAY_PIPE_USER7;
		}
		else if (m_iPipeType == 34)
		{
			return LAY_PIPE_USER8;
		}
		else
			return _T("");
	}
	return _T("");
}

//返回全局pipe index
int CDrawStandPipeDlg::GetPipeIdx() 
{
	int ret = 0;
	if(m_iPipeType == 0) 
	{
		if(m_iPos == 0)
			ret = 0;
		else if(m_iPos == 1)
			ret = 17;
		else if(m_iPos == 2)
			ret = 18;
	}
	else if(m_iPipeType == 1)
	{
		if(m_iPos == 0)
			ret = 1;
		else if(m_iPos == 1)
			ret = 19;
		else if(m_iPos == 2)
			ret = 20;
	}
	else if(m_iPipeType == 2)
	{
		if(m_iPos == 0)
			ret = 2;
		else if(m_iPos == 1)
			ret = 21;
		else if(m_iPos == 2)
			ret = 22;
	}
	else if(m_iPipeType == 3)
		ret = 3;
	else if(m_iPipeType == 4)
		ret = 4;
	else if(m_iPipeType == 5)
		ret = 5;
	else if(m_iPipeType == 6)
	{
		if(m_iPos == 0)
			ret = 6;
		else if(m_iPos == 1)
			ret = 27;
		else if(m_iPos == 2)
			ret = 28;
	}
	else if(m_iPipeType == 7)
	{
		if(m_iPos == 0)
			ret = 7;
		else if(m_iPos == 1)
			ret = 23;
		else if(m_iPos == 2)
			ret = 24;
	}
	else if(m_iPipeType == 8)
	{
		if(m_iPos == 0)
			ret = 8;
		else if(m_iPos == 1)
			ret = 25;
		else if(m_iPos == 2)
			ret = 26;
	}
	else if(m_iPipeType == 9)
		ret = 9;
	else if(m_iPipeType == 10)
		ret = 10;
	else if(m_iPipeType == 11)
		ret = 11;
	else if(m_iPipeType == 12)
		ret = 12;
	else if(m_iPipeType == 13)
		ret = 13;
	else if(m_iPipeType == 14)
		ret = 14;
	else if(m_iPipeType == 15)
		ret = 15;
	else if(m_iPipeType == 16)
		ret = 16;
	else if (m_iPipeType == 29) // cet 2011.12.1 add 29-34
	{
		ret = 29;
	}
	else if (m_iPipeType == 30)
	{
		ret = 30;
	}
	else if (m_iPipeType == 31)
	{
		ret = 31;
	}
	else if (m_iPipeType == 32)
	{
		ret = 32;
	}
	else if (m_iPipeType == 33)
	{
		ret = 33;
	}
	else if (m_iPipeType == 34)
	{
		ret = 34;
	}
	else
		return 0;
	return ret;
}

void CDrawStandPipeDlg::OnRadioPlace1() 
{
	UpdateData();
	PostCommand(_T("V "), false);
}

void CDrawStandPipeDlg::OnRadioPlace2() 
{
	UpdateData();
   	PostCommand(_T("V "), false);
}

void CDrawStandPipeDlg::OnRadioPlace3() 
{
    UpdateData();
    PostCommand(_T("V "), false);
}

void CDrawStandPipeDlg::ResetRegion()
{
//	UpdateData();
	CWnd *pWnd1 = GetDlgItem(IDC_RADIO_POS1);
	CWnd *pWnd2 = GetDlgItem(IDC_RADIO_POS2);
	CWnd *pWnd3 = GetDlgItem(IDC_RADIO_POS3);
  //cet 2011.12.1 modify
  //if(m_iPipeType == 0 || m_iPipeType == 1 || m_iPipeType == 2 || m_iPipeType == 6 || m_iPipeType == 7 || m_iPipeType == 8)
	if(m_iPipeType2 == 0 || m_iPipeType2 == 1 || m_iPipeType2 == 2 || m_iPipeType2 == 6 || m_iPipeType2 == 7 || m_iPipeType2 == 8)
	{
		pWnd1->EnableWindow(TRUE);
		pWnd2->EnableWindow(TRUE);
		pWnd3->EnableWindow(TRUE);
	}
	else
	{
		pWnd1->EnableWindow(FALSE);
		pWnd2->EnableWindow(FALSE);
		pWnd3->EnableWindow(FALSE);
	}

}

void CDrawStandPipeDlg::OnRadioPipetype1() 
{
	 UpdateData();
	 m_iPipeType = 0;
	 UpdateData(FALSE);
	 ResetRegion();
     PostCommand(_T("V "), false);
}

void CDrawStandPipeDlg::OnRadioPipetype2() 
{
	UpdateData();
	m_iPipeType = 1;
	UpdateData(FALSE);

	ResetRegion();
    PostCommand(_T("V "), false);
}

void CDrawStandPipeDlg::OnRadioPipetype3() 
{
	UpdateData();
	m_iPipeType = 2;
	UpdateData(FALSE);
	ResetRegion();
    PostCommand(_T("V "), false);   
}

void CDrawStandPipeDlg::OnRadioPipetype4() 
{
	UpdateData();
	m_iPipeType = 3;
	UpdateData(FALSE);
	ResetRegion();
    PostCommand(_T("V "), false);    
}

void CDrawStandPipeDlg::OnRadioPipetype5() 
{
	UpdateData();
	m_iPipeType = 4;
	UpdateData(FALSE);
	ResetRegion();
    PostCommand(_T("V "), false);    
}

void CDrawStandPipeDlg::OnRadioPipetype6() 
{
	UpdateData();
	m_iPipeType = 5;
	UpdateData(FALSE);
	ResetRegion();
    PostCommand(_T("V "), false);    
}

void CDrawStandPipeDlg::OnRadioPipetype7() 
{
	UpdateData();
	m_iPipeType = 6;
	UpdateData(FALSE);
	ResetRegion();
    PostCommand(_T("V "), false);    
}

void CDrawStandPipeDlg::OnRadioPipetype8() 
{
	UpdateData();
	m_iPipeType = 7;
	UpdateData(FALSE);
	ResetRegion();
    PostCommand(_T("V "), false);    
}

void CDrawStandPipeDlg::OnRadioPipetype9() 
{
	UpdateData();
	m_iPipeType = 8;
	UpdateData(FALSE);
	ResetRegion();
    PostCommand(_T("V "), false);    
}

void CDrawStandPipeDlg::PullMenu()
{
//	if(m_iPipeType < 9)//sr 2009-10-20 有时候无缘无故会激发这个出来，比如选图上管线，系统从其它跳到指定管线系统
//		return;
	
    CWnd *pWnd = GetDlgItem(IDC_RADIO_PIPETYPE10); // GetDlgItem(IDC_RADIO_PIPETYPE15) cet 2011.12.1 modify
    CRect rc;
    pWnd->GetWindowRect(rc);
    
    
    if(m_pMenu) {
        m_pMenu->DestroyMenu();
        m_pMenu->CreatePopupMenu();
    } else {
        m_pMenu = new CMenu;
        m_pMenu->CreatePopupMenu();
    }
    
/*  cet 2011.12.1 modify
    m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 1, g_csPipeName[0]);
    m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 2, g_csPipeName[1]);
    m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 3, g_csPipeName[2]);
    m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 4, g_csPipeName[3]);
    m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 5, g_csPipeName[4]);
    m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 6, g_csPipeName[5]);
    m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 7, g_csPipeName[6]);
    m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 8, _T("其 它 管"));
 */
	
	std::vector<CString> vecPipeName;
	GetPipeName(vecPipeName);
	m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 1, vecPipeName[0]);
    m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 2, vecPipeName[1]);
    m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 3, vecPipeName[2]);
    m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 4, vecPipeName[3]);
    m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 5, vecPipeName[4]);
    m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 6, vecPipeName[5]);
    m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 7, vecPipeName[6]);
	m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 8, vecPipeName[7]);
    m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 9, vecPipeName[8]);
    m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 10, vecPipeName[9]);
    m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 11, vecPipeName[10]);
    m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 12, vecPipeName[11]);
    m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 13, vecPipeName[12]);
    m_pMenu->AppendMenu(MF_STRING, PipeMenuID + 14, _T("其 它 管"));

    m_pMenu->TrackPopupMenu( TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_VERTICAL,
        rc.left, rc.bottom, this, &rc);
    
    PostCommand(_T("V "), false);   
  //  if(m_iPipeMode == 1)
    //    PostCommand(_T("W "), false);    
}

void CDrawStandPipeDlg::OnRadioPipetype10() 
{
	// cet 2012.10.19 add 判断鼠标点是否在控件上
	CPoint pt;
	::GetCursorPos(&pt);
	CRect rect;
	GetDlgItem(IDC_RADIO_PIPETYPE10)->GetWindowRect(rect);
	if (!rect.PtInRect(pt))
	{
		return;
	}
	
	UpdateData();
	// cet 2011.12.6 add
	m_iPipeType = m_iPipeType3;
	ResetRegion();
    PullMenu();
}

/* cet 2011.12.1 del
void CDrawStandPipeDlg::OnRadioPipetype11() 
{
	UpdateData();
	ResetRegion();
    PullMenu();
}

void CDrawStandPipeDlg::OnRadioPipetype12() 
{
	UpdateData();
	ResetRegion();
    PullMenu();
}

void CDrawStandPipeDlg::OnRadioPipetype13() 
{
	UpdateData();
	ResetRegion();
    PullMenu();
}

void CDrawStandPipeDlg::OnRadioPipetype14() 
{
	UpdateData();
	ResetRegion();
    PullMenu();
}

void CDrawStandPipeDlg::OnRadioPipetype15() 
{
	UpdateData();
	ResetRegion();
    PullMenu();
}

void CDrawStandPipeDlg::OnRadioPipetype16() 
{
	UpdateData();
	ResetRegion();
    PullMenu();
}

void CDrawStandPipeDlg::OnRadioPipetype17() 
{
	UpdateData();
	ResetRegion();
    PullMenu();
}
*/

void CDrawStandPipeDlg::OnButtonSetting() 
{
    CTemporaryResourceOverride vTemp;
	CPipeSettingFrameDlg dlg;
	if(dlg.DoModal() != IDOK)
		return;
	
	m_csDim1 = g_csPipeDim[0];
	m_csDim2 = g_csPipeDim[1];
	m_csDim3 = g_csPipeDim[2];
	m_csDim4 = g_csPipeDim[3];
	m_csDim5 = g_csPipeDim[4];
	m_csDim6 = g_csPipeDim[5];
	m_csDim7 = g_csPipeDim[6];
	m_csDim8 = g_csPipeDim[7];
	m_csDim9 = g_csPipeDim[8];
	UpdateData(FALSE);
}

#define GET_WM_COMMAND_CMD(wp, lp)	HIWORD(wp)
#define GET_WM_COMMAND_ID(wp, lp)	LOWORD(wp)
#define GET_WM_COMMAND_HWND(wp, lp)	((HWND)lp)


BOOL CDrawStandPipeDlg::OnCommand(WPARAM wParam, LPARAM lParam) 
{
    CString csCommand;
	
	//2010-9-2 SR 增加以下7句。对话框启动的时候m_iPipeType有1个默认值，会临时产生单击事件，更换管线类型后点击其他控件，会无缘无故引发这个消息从而改变管线类型
	int  nID = GET_WM_COMMAND_ID(wParam,lParam);
	UINT nCodeNotify = GET_WM_COMMAND_CMD(wParam,lParam);
	HWND hwndCtl = GET_WM_COMMAND_HWND(wParam,lParam);
	CPoint pt;
	::GetCursorPos(&pt);
	if (hwndCtl != ::WindowFromPoint(pt) && (nID >= IDC_RADIO_PIPETYPE1 && nID <= IDC_RADIO_PIPETYPE9))
		return TRUE;//如果点所在的控件不是当前控件，终止消息执行

	// cet 2013.3.13 add 处理立管编号菜单
	if (m_iPipeMode == 1 && m_pMenuSerial != NULL && m_bOpeningMenuSerial)
	{
		m_bOpeningMenuSerial = false;
		std::map<DWORD, std::pair<CString, bool> >::iterator it, itEnd = m_mapSerial.end();
		it = m_mapSerial.find(nID);
		if (it != itEnd)
		{
			CWnd *pWnd = GetDlgItem(IDC_EDIT_NAME);
			if (pWnd != NULL) 
			{
				pWnd->SetFocus();
			}
			// 选项没有变化
			if (it->second.second)
			{
				return TRUE;
			}
			
			std::map<DWORD, std::pair<CString, bool> >::iterator itBegin;
			for (itBegin = m_mapSerial.begin(); itBegin != itEnd; ++itBegin)
			{
				if (itBegin != it)
				{
					itBegin->second.second = false;
				}
				else
				{
					itBegin->second.second  = true;
				}
			}
			m_nSelSerialID = nID;
			UpdateSpinVisible();
			PostCommand(_T("V "), false);
			return TRUE;
		}
	}
	
	// cet 2012.3.16 add 处理角度菜单
	int nAngleID = PipeMenuID + 15;
	if (nAngleID <= nID && nID < nAngleID + m_mapAngle.size())
	{
		if (m_pMenuAngle != NULL)
		{
			m_pMenuAngle->GetMenuString(wParam, csCommand, MF_BYCOMMAND); 
			double dAngle = _tstof(csCommand);
			if (!SelectAngleMenuItem(dAngle))
			{
				return CDialog::OnCommand(wParam, lParam);
			}
			else if (m_bSendCmdKeyToCAD)
			{
				 PostCommand(_T("T "), false);
			}
		} 
		else
		{
			return CDialog::OnCommand(wParam, lParam);
		}
	}
	
	// cet 2010.6.23
	if (m_pMenuEle != NULL)
	{
		m_pMenuEle->GetMenuString(wParam, csCommand, MF_BYCOMMAND); 
		if (csCommand.Compare(_T("自动读取前一管线标高")) == 0)
		{
			m_bEle = true;
		} 
		else if (csCommand.Compare(_T("不读取前一管线标高")) == 0)
		{
			m_bEle = false;
		}
	}

    if(m_pMenu == NULL)
	{
		return CModelessDialog::OnCommand(wParam, lParam);
	 
	}
//        return TRUE;
 
    m_pMenu->GetMenuString(wParam, csCommand, MF_BYCOMMAND);  //判断用户是否点的是弹出菜单
    if(csCommand.IsEmpty()){
		return CModelessDialog::OnCommand(wParam, lParam);
	}

/*	cet 2011.12.1 modify
	CWnd *pWnd1 = GetDlgItem(IDC_RADIO_PIPETYPE10);
	CWnd *pWnd2 = GetDlgItem(IDC_RADIO_PIPETYPE11);
	CWnd *pWnd3 = GetDlgItem(IDC_RADIO_PIPETYPE12);
	CWnd *pWnd4 = GetDlgItem(IDC_RADIO_PIPETYPE13);
	CWnd *pWnd5 = GetDlgItem(IDC_RADIO_PIPETYPE14);
	CWnd *pWnd6 = GetDlgItem(IDC_RADIO_PIPETYPE15);
	CWnd *pWnd7 = GetDlgItem(IDC_RADIO_PIPETYPE16);
	CWnd *pWnd8 = GetDlgItem(IDC_RADIO_PIPETYPE17);

	pWnd1->ShowWindow(SW_HIDE);
	pWnd2->ShowWindow(SW_HIDE);
	pWnd3->ShowWindow(SW_HIDE);
	pWnd4->ShowWindow(SW_HIDE);
	pWnd5->ShowWindow(SW_HIDE);
	pWnd6->ShowWindow(SW_HIDE);
	pWnd7->ShowWindow(SW_HIDE);
	pWnd8->ShowWindow(SW_HIDE);
	
	pWnd1->EnableWindow(FALSE);
	pWnd2->EnableWindow(FALSE);
	pWnd3->EnableWindow(FALSE);
	pWnd4->EnableWindow(FALSE);
	pWnd5->EnableWindow(FALSE);
	pWnd6->EnableWindow(FALSE);
	pWnd7->EnableWindow(FALSE);
	pWnd8->EnableWindow(FALSE);
		
	if(csCommand == g_csPipeName[0]){
		m_iPipeType = 9;
		pWnd1->ShowWindow(SW_SHOW);
		pWnd1->EnableWindow(TRUE);
		pWnd1->SetWindowText(g_csPipeName[0]);
	}
	else if(csCommand == g_csPipeName[1]){
		m_iPipeType = 10;
		pWnd2->EnableWindow(TRUE);
		pWnd2->ShowWindow(SW_SHOW);
		pWnd2->SetWindowText(g_csPipeName[1]);
	}
	else if(csCommand == g_csPipeName[2]){
		m_iPipeType = 11;
		pWnd3->EnableWindow(TRUE);
		pWnd3->ShowWindow(SW_SHOW);
		pWnd3->SetWindowText(g_csPipeName[2]);
	}
	else if(csCommand == g_csPipeName[3]){
		m_iPipeType = 12;
		pWnd4->ShowWindow(SW_SHOW);
		pWnd4->EnableWindow(TRUE);
		pWnd4->SetWindowText(g_csPipeName[3]);
	}
	else if(csCommand == g_csPipeName[4]){
		m_iPipeType = 13;
		pWnd5->EnableWindow(TRUE);
		pWnd5->ShowWindow(SW_SHOW);
		pWnd5->SetWindowText(g_csPipeName[4]);
	}
	else if(csCommand == _T("其 它 管")){
		m_iPipeType = 14;
		pWnd6->EnableWindow(TRUE);
		pWnd6->ShowWindow(SW_SHOW);
	}
	else if(csCommand == g_csPipeName[5]){
		m_iPipeType = 15;
		pWnd7->EnableWindow(TRUE);
		pWnd7->ShowWindow(SW_SHOW);
		pWnd7->SetWindowText(g_csPipeName[5]);
	}
	else if(csCommand == g_csPipeName[6]){
		m_iPipeType = 16;
		pWnd8->EnableWindow(TRUE);
		pWnd8->ShowWindow(SW_SHOW);
		pWnd8->SetWindowText(g_csPipeName[6]);
	}
	m_csDim10 = g_csPipeDim[m_iPipeType];
*/
	std::vector<CString> vecPipeName;
	GetPipeName(vecPipeName);
	CWnd *pWnd = GetDlgItem(IDC_RADIO_PIPETYPE10);	
	if(csCommand == vecPipeName[0]){
		m_iPipeType = 9;
		pWnd->SetWindowText(vecPipeName[0]);
	}
	else if(csCommand == vecPipeName[1]){
		m_iPipeType = 10;
		pWnd->SetWindowText(vecPipeName[1]);
	}
	else if(csCommand == vecPipeName[2]){
		m_iPipeType = 11;
		pWnd->SetWindowText(vecPipeName[2]);
	}
	else if(csCommand == vecPipeName[3]){
		m_iPipeType = 12;
		pWnd->SetWindowText(vecPipeName[3]);
	}
	else if(csCommand == vecPipeName[4]){
		m_iPipeType = 13;
		pWnd->SetWindowText(vecPipeName[4]);
	}
	else if(csCommand == _T("其 它 管")){
		m_iPipeType = 14;
		pWnd->SetWindowText(_T("其 它 管"));
	}
	else if(csCommand == vecPipeName[5]){
		m_iPipeType = 15;
		pWnd->SetWindowText(vecPipeName[5]);
	}
	else if(csCommand == vecPipeName[6]){
		m_iPipeType = 16;
		pWnd->SetWindowText(vecPipeName[6]);
	}
	else if(csCommand == vecPipeName[7]){
		m_iPipeType = 29;
		pWnd->SetWindowText(vecPipeName[7]);
	}
	else if(csCommand == vecPipeName[8]){
		m_iPipeType = 30;
		pWnd->SetWindowText(vecPipeName[8]);
	}
	else if(csCommand == vecPipeName[9]){
		m_iPipeType = 31;
		m_iPipeType2 = 9;
		pWnd->SetWindowText(vecPipeName[9]);
	}
	else if(csCommand == vecPipeName[10]){
		m_iPipeType = 32;
		pWnd->SetWindowText(vecPipeName[10]);
	}
	else if(csCommand == vecPipeName[11]){
		m_iPipeType = 33;
		pWnd->SetWindowText(vecPipeName[11]);
	}
	else if(csCommand == vecPipeName[12]){
		m_iPipeType = 34;
		pWnd->SetWindowText(vecPipeName[12]);
	}
	m_csDim10 = g_csPipeDim[m_iPipeType];
	m_iPipeType3 = m_iPipeType;
	m_iPipeType2 = 9;
	CString sText;
	pWnd->GetWindowText(sText);
	if (sText.Find(_T("↓")) == -1)
	{
		sText+=_T("↓");
	    pWnd->SetWindowText(sText);
	}
    
    UpdateData(FALSE);
    if(m_iPipeMode == 1)
        PostCommand(_T("V "), false);
    
    return CModelessDialog::OnCommand(wParam, lParam);
}

void CDrawStandPipeDlg::ReadWriteData(bool bRead)
{
	UpdateData(TRUE);
	CRegProperty reg(GetRegLocation(), _T("DrawPipe"));    
//  reg.SetTopRootKey(HKEY_LOCAL_MACHINE); // cet 2010.7.19 del 存储位置错误
	reg.SetTopRootKey(HKEY_CURRENT_USER); // cet 2010.7.19 add

	if (bRead)
	{
		if(!reg.GetValue(_T("Elevation"), m_bEle))
		{
			m_bEle = false;
		}

		if (!reg.GetValue(_T("LockAngle"), m_bLockAngle)) // cet 2011.7.27 add
		{
			m_bLockAngle = FALSE; 
		}
	} 
	else
	{
		reg.SetValue(_T("Elevation"), m_bEle);
		reg.SetValue(_T("LockAngle"), m_bLockAngle); // cet 2011.7.27 add
	}
}

void CDrawStandPipeDlg::OnButtonMenu() 
{
    CWnd *pWnd = GetDlgItem(IDC_BUTTON_MENU);
    CRect rc;
    pWnd->GetWindowRect(rc);
    
    if(m_pMenuEle != NULL) 
	{
        m_pMenuEle->DestroyMenu();
        m_pMenuEle->CreatePopupMenu();
    } 
	else 
	{
        m_pMenuEle = new CMenu;
        m_pMenuEle->CreatePopupMenu();
    }
	
	if (m_bEle)
	{
		m_pMenuEle->AppendMenu(MF_CHECKED, PipeMenuID + 11, _T("自动读取前一管线标高"));
		m_pMenuEle->AppendMenu(MF_UNCHECKED, PipeMenuID + 12, _T("不读取前一管线标高"));
	} 
	else
	{
		m_pMenuEle->AppendMenu(MF_UNCHECKED, PipeMenuID + 11, _T("自动读取前一管线标高"));
		m_pMenuEle->AppendMenu(MF_CHECKED, PipeMenuID + 12, _T("不读取前一管线标高"));
	}
    
    m_pMenuEle->TrackPopupMenu( TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_VERTICAL,
								rc.left, rc.bottom, this, &rc);
	
}

void CDrawStandPipeDlg::OnButtonSerial()
{
	CWnd *pWnd = GetDlgItem(IDC_BTN_SERIAL);
	if (pWnd == NULL)
	{
		return;
	}

	CRect rect;
	pWnd->GetWindowRect(&rect);
	if (m_pMenuSerial == NULL)
	{
		m_pMenuSerial = new CMenu;
	} 
	else
	{
		m_pMenuSerial->DestroyMenu();
	}
	m_pMenuSerial->CreatePopupMenu();

	std::map<DWORD, std::pair<CString, bool> >::iterator it, itEnd = m_mapSerial.end();
	for (it = m_mapSerial.begin(); it != itEnd; ++it)
	{
		UINT nflag = it->second.second ? MF_CHECKED : MF_UNCHECKED;
		m_pMenuSerial->AppendMenu(nflag, it->first, it->second.first);
	}
	m_pMenuSerial->TrackPopupMenu(TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_VERTICAL, rect.left, rect.bottom, this, &rect);
	m_bOpeningMenuSerial = true;
}

void CDrawStandPipeDlg::OnButtonAngleMenu()
{
	CWnd *pWnd = GetDlgItem(IDC_BUTTON_ANGLEMENU);
    CRect rc;
    pWnd->GetWindowRect(rc);
    
    if(m_pMenuAngle != NULL) 
	{
        m_pMenuAngle->DestroyMenu();
        m_pMenuAngle->CreatePopupMenu();
    }
	else 
	{
        m_pMenuAngle = new CMenu;
        m_pMenuAngle->CreatePopupMenu();
    }
	
	CString sAngle;
	int nID = PipeMenuID + 15;
	std::map<double,bool>::iterator it;
	for (it = m_mapAngle.begin(); it != m_mapAngle.end(); it++)
	{
		sAngle.Format(_T("%.3f"), it->first);
		sAngle.TrimRight(_T("0"));
		sAngle.TrimRight(_T("."));
		m_pMenuAngle->AppendMenu(it->second ? MF_CHECKED : MF_UNCHECKED, nID++, (LPCTSTR)sAngle);
	}
    m_pMenuAngle->TrackPopupMenu( TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_VERTICAL,
								rc.left, rc.bottom, this, &rc);
}

void CDrawStandPipeDlg::OnDestroy() 
{
	CModelessDialog::OnDestroy();
	ReadWriteData(false);	
}

void CDrawStandPipeDlg::GetPipeName(std::vector<CString> &vecPipeName)
{
	CString sTemp;
	if(GetLayerReMark(LAY_PIPE_COAGULATE, sTemp) && !sTemp.IsEmpty()) 
    {
		vecPipeName.push_back(sTemp);
	}
	else
	{
		vecPipeName.push_back(_T("凝结"));
	}
    if(GetLayerReMark(LAY_PIPE_DRINK, sTemp) && !sTemp.IsEmpty())
	{
		vecPipeName.push_back(sTemp);
	}
	else
	{
		vecPipeName.push_back(_T("直饮"));
	}
    if(GetLayerReMark(LAY_PIPE_PRESSDIRT, sTemp) && !sTemp.IsEmpty())
	{
		vecPipeName.push_back(sTemp);
	}
	else
	{
		vecPipeName.push_back(_T("压力污"));
	}
    if(GetLayerReMark(LAY_PIPE_PRESSUSELESS, sTemp) && !sTemp.IsEmpty())
	{
		vecPipeName.push_back(sTemp);
	}
	else
	{
		vecPipeName.push_back(_T("压力废"));
	}
    if(GetLayerReMark(LAY_PIPE_PRESSRAIN, sTemp) && !sTemp.IsEmpty())
	{
		vecPipeName.push_back(sTemp);
	}
	else
	{
		vecPipeName.push_back(_T("压力雨"));
	}
    if(GetLayerReMark(LAY_PIPE_USER1, sTemp) && !sTemp.IsEmpty())
	{
		vecPipeName.push_back(sTemp);
	}
	else
	{
		vecPipeName.push_back(_T("用户1管线"));
	}
    if(GetLayerReMark(LAY_PIPE_USER2, sTemp) && !sTemp.IsEmpty())
	{
		vecPipeName.push_back(sTemp);
	}
	else
	{
		vecPipeName.push_back(_T("用户2管线"));
	}
	if(GetLayerReMark(LAY_PIPE_USER3, sTemp) && !sTemp.IsEmpty())
	{
		vecPipeName.push_back(sTemp);
	}
	else
	{
		vecPipeName.push_back(_T("用户3管线"));
	}
    if(GetLayerReMark(LAY_PIPE_USER4, sTemp) && !sTemp.IsEmpty())
	{
		vecPipeName.push_back(sTemp);
	}
	else
	{
		vecPipeName.push_back(_T("用户4管线"));
	}
    if(GetLayerReMark(LAY_PIPE_USER5, sTemp) && !sTemp.IsEmpty())
	{
		vecPipeName.push_back(sTemp);
	}
	else
	{
		vecPipeName.push_back(_T("用户5管线"));
	}
    if(GetLayerReMark(LAY_PIPE_USER6, sTemp) && !sTemp.IsEmpty())
	{
		vecPipeName.push_back(sTemp);
	}
	else
	{
		vecPipeName.push_back(_T("用户6管线"));
	}
	if(GetLayerReMark(LAY_PIPE_USER7, sTemp) && !sTemp.IsEmpty())
	{
		vecPipeName.push_back(sTemp);
	}
	else
	{
		vecPipeName.push_back(_T("用户7管线"));
	}
    if(GetLayerReMark(LAY_PIPE_USER8, sTemp) && !sTemp.IsEmpty())
	{
		vecPipeName.push_back(sTemp);
	}
	else
	{
		vecPipeName.push_back(_T("用户8管线"));
	}
}

//******************************************************************************
//******************************************************************************
int	TPipeEdJig::m_iUnit = 0;
TPipeEdJig::TPipeEdJig(XPoint pt, double nRadius) 
{
	m_iType = 1;
	m_pt1 = pt;
	m_pt2 = pt;
	m_nRadius = nRadius;
	m_pPipe = new TDbPipe;
    m_pPipe->SetDnDiameter(25);
	m_pPipe->SetStartPoint(m_pt1);
	m_pt2.z += 3000;
	m_pPipe->SetEndPoint(m_pt2);
	m_pPipe->SetRadius(nRadius);
	m_bLock = FALSE;
    m_bInit = TRUE;
	m_iUnit = 0;
    m_nLockAng = -1;
	m_bGreen = false; // cet 2010.6.23 add
	m_dWatchScale = 15; // cet 2011.7.27 add 
	m_pDlg = NULL;      // cet 2011.7.27 add
	m_pVirtualPipe = new TdbVirtualPipe; // cet 2011.7.27 add
	m_pVirtualPipe->SetPipe(m_pPipe);    // cet 2011.7.27 add
	m_vtWatch = AcGeVector3d::kXAxis;    // cet 2011.7.28 add
	m_vtWatch.rotateBy(Ucs2Wcs(0.0), AcGeVector3d::kZAxis); // cet 2011.8.2 add
	m_dViewSize = GetViewSize();		 // cet 2011.8.1 add
	m_ptViewCenter = GetViewCenter();    // cet 2011.8.1 add
}

TPipeEdJig::TPipeEdJig(XPoint pt, double nRadius, AcGeVector3d vectBase)//沿线布置
{
	m_iType = 3;
	m_ptRef = pt;
	m_pt1 = pt;
	m_pt2 = pt;
	m_nRadius = nRadius;
	m_pPipe = new TDbPipe;
    m_pPipe->SetDnDiameter(25);
	m_pPipe->SetStartPoint(m_pt1);
	m_pt2.z += 3000;
	m_pPipe->SetEndPoint(m_pt2);
	m_pPipe->SetRadius(nRadius);
	m_bLock = FALSE;
    m_bInit = TRUE;
	m_iUnit = 0;
    m_nLockAng = -1;
	m_vectBase = vectBase;
	m_bGreen = false; // cet 2010.6.23 add
	m_dWatchScale = 15; // cet 2011.7.27 add 
	m_pDlg = NULL;      // cet 2011.7.27 add
	m_pVirtualPipe = new TdbVirtualPipe; // cet 2011.7.27 add
	m_pVirtualPipe->SetPipe(m_pPipe);    // cet 2011.7.27 add
	m_vtWatch = AcGeVector3d::kXAxis;    // cet 2011.7.28 add
	m_vtWatch.rotateBy(Ucs2Wcs(0.0), AcGeVector3d::kZAxis); // cet 2011.8.2 add
	m_dViewSize = GetViewSize();		 // cet 2011.8.1 add
	m_ptViewCenter = GetViewCenter();    // cet 2011.8.1 add
}

TPipeEdJig::TPipeEdJig(XPoint pt1, XPoint pt2)
{
    m_iType = 2;
    m_pt1 = pt1;
    m_pt2 = pt2;
    m_pPipe = new TDbPipe;
    m_pPipe->SetDnDiameter(25);
    m_pPipe->SetStartPoint(m_pt1);
    m_pPipe->DrawPropertyText(TRUE);
    m_pPipe->SetEndPoint(m_pt2);
    m_pPipe->setColorIndex(1);
    m_bLock = TRUE;
    m_bInit = TRUE;
    m_nLockAng = -1;
	m_bGreen = false; // cet 2010.6.23 add
	m_dWatchScale = 15; // cet 2011.7.27 add 
	m_pDlg = NULL;      // cet 2011.7.27 add
	m_pVirtualPipe = new TdbVirtualPipe; // cet 2011.7.27 add
	m_pVirtualPipe->SetPipe(m_pPipe);    // cet 2011.7.27 add
	m_vtWatch = AcGeVector3d::kXAxis;    // cet 2011.7.28 add
	m_vtWatch.rotateBy(Ucs2Wcs(0.0), AcGeVector3d::kZAxis); // cet 2011.8.2 add			
	m_dViewSize = GetViewSize();		 // cet 2011.8.1 add
	m_ptViewCenter = GetViewCenter();    // cet 2011.8.1 add
}

TPipeEdJig::TPipeEdJig(XPoint pt1, XPoint pt2, double nRadius)
{
	m_iType = 0;
	m_pt1 = pt1;
	m_pt2 = pt2;
	m_nRadius = nRadius;
	m_pPipe = new TDbPipe;
    m_pPipe->SetDnDiameter(25);
	m_pPipe->SetStartPoint(m_pt1);
	m_pPipe->DrawPropertyText(TRUE);
	m_pPipe->SetEndPoint(m_pt2);
	m_pPipe->SetRadius(nRadius);
    m_pPipe->setColorIndex(1);
	m_bLock = TRUE;
    m_bInit = TRUE;
    m_nLockAng = -1;
	m_bGreen = false; // cet 2010.6.23 add
	m_dWatchScale = 15; // cet 2011.7.27 add 
	m_pDlg = NULL;      // cet 2011.7.27 add
	m_pVirtualPipe = new TdbVirtualPipe; // cet 2011.7.27 add
	m_pVirtualPipe->SetPipe(m_pPipe);    // cet 2011.7.27 add
	m_vtWatch = AcGeVector3d::kXAxis;    // cet 2011.7.28 add
	m_vtWatch.rotateBy(Ucs2Wcs(0.0), AcGeVector3d::kZAxis); // cet 2011.8.2 add
	m_dViewSize = GetViewSize();		 // cet 2011.8.1 add
	m_ptViewCenter = GetViewCenter();    // cet 2011.8.1 add
}

TPipeEdJig::~TPipeEdJig()
{
	if(m_pPipe)
		delete m_pPipe;
}

AcEdJig::DragStatus 
TPipeEdJig::GetPoint(XPoint &pt)
{
    if(m_bInit){
        m_bInit = FALSE;
        if(!m_ptRef)
            return acquirePoint(pt);
        else
		{
			XPoint ptTmp = m_ptRef;
			ptTmp.z = 0;
            return acquirePoint(pt, ptTmp);
		}
    }
    if(!m_ptRef || m_iUnit != 0){
        return acquirePoint(pt);
    }
    else
		return acquirePoint(pt, m_ptRef);
}

void TPipeEdJig::SetStartPoint(XPoint pt)
{
	m_pt1 = pt;
	m_pPipe->SetStartPoint(m_pt1);
}
 
int TPipeEdJig::DoIt(int *keyIndex)
{
    int nRet = TSymbEdJig::DoIt(keyIndex);
    return nRet;
}


XPoint TPipeEdJig::GetCorrectPt()
{
	XPoint ptTmp = m_ptResult;
	if(m_bLock && m_iUnit>=5){
        XPoint ptTmp2 = m_pt1;
        ptTmp2.z = 0;

		// 2008－2－18 轴锁支持UCS
		double dUcs = Radian2Angle(Ucs2Wcs(0.0));
		XPoint ptStartUcs = Wcs2Ucs(ptTmp2);
		XPoint ptEndUcs = Wcs2Ucs(m_ptResult);
		double nAngle = ads_angle(ptStartUcs, ptEndUcs); //注意，ads_angle必须是UCS
	//	double nAngle = ads_angle(ptTmp2, m_ptResult);
		int Ang = (int)Radian2Angle(nAngle);
		double nDist = ads_distance(ptTmp2, m_ptResult);
		int nTmp = Ang % m_iUnit;
		int multiple = Ang / m_iUnit;
		if(nTmp > m_iUnit / 2)
			nAngle = m_iUnit * (multiple + 1);
		else
			nAngle = m_iUnit * multiple;
		nAngle = nAngle + dUcs;
		nAngle = nAngle / 180 * PI;
		ads_polar(m_pt1, nAngle, nDist, ptTmp);
	}
    else if(!m_bLock && m_nLockAng > -1){
        m_ptRef = XPoint();
        XPoint ptTmp2 = m_pt1;
        ptTmp2.z = 0;
		XPoint ptTmp3 = m_ptResult;
		ptTmp3.z = 0;

        double nAngle = ads_angle(ptTmp2, m_ptResult) - m_nLockAng;
        double nDist = ads_distance(ptTmp2, ptTmp3);
        if(nAngle > PI/2 &&  nAngle < PI/2*3)
            ads_polar(m_pt1, m_nLockAng, -nDist, ptTmp);
        else
            ads_polar(m_pt1, m_nLockAng, nDist, ptTmp);
    }

	// cet 2011.7.27 add 普通管线，有角度盘时调整点位置
	if (m_pDlg != NULL && m_iType == 0 && m_pDlg->m_bLockAngle)
	{
		double dAngle = 0.0;
		GetWatchPt(TADSGePoint3d(ptTmp), ptTmp, dAngle); 
	}
	
	return ptTmp;
}

// 更新实体数据
Adesk::Boolean TPipeEdJig::update()
{
    Adesk::Boolean bRet=Adesk::kTrue;
 
	m_ptPick = m_ptResult;
	XPoint ptTmp = m_ptResult;
	if(m_iType == 1){
		m_pt1 = m_ptResult;
		m_pt2 = m_ptResult;
		m_pPipe->SetStartPoint(m_pt1);
		m_pt2.z += 3000;
		m_pPipe->SetEndPoint(m_pt2);
    }
    else if(m_iType == 2){
        XArc arc(m_pt1, m_ptResult, m_pt2);
        XPoint ptArcS, ptArcE;
		arc.GetStartPoint(ptArcS);
		arc.GetEndPoint(ptArcE);
        if(m_pt1 == ptArcS)
            m_pPipe->SetPoints(m_pt1, m_pt2, arc.Bulge());
        else
            m_pPipe->SetPoints(m_pt1, m_pt2, -arc.Bulge());
    }
    else if(m_iType == 3){//沿线布置立管
		AcGeVector3d vectTmp(m_ptPick.x - m_ptRef.x, m_ptPick.y - m_ptRef.y, 0);
		double dAng = m_vectBase.angleTo(vectTmp, AcGeVector3d::kZAxis);
		//求橡皮筋向量投影到 以m_vectBase为法向量的 平面
		AcGeVector3d vtOrtho = vectTmp.orthoProject(m_vectBase);
		vtOrtho.normalize();
		vtOrtho *= m_nLockAng;
		m_pt1 = m_ptRef;
		m_pt1 += vtOrtho;

		m_pt2 = m_pt1;
		m_pt2.z += 3000;
		m_pPipe->SetStartPoint(m_pt1);
		m_pPipe->SetEndPoint(m_pt2);
		m_ptPick = m_pt1;
	}
	else{
		if(m_bLock && m_iUnit>=5 ){
			ptTmp = GetCorrectPt();
		}
        else if(!m_bLock && m_nLockAng > -1){
            ptTmp = GetCorrectPt();
        }
    
		m_pt2 = ptTmp;
		// cet 2011.7.27 add 调整值
		if (m_pDlg != NULL && m_pDlg->m_bLockAngle)
		{
			double dAngle = 0.0;
			GetWatchPt(m_pt2, ptTmp, dAngle); 
			m_pVirtualPipe->SetAngleDim(m_pt2, dAngle);
		}

		m_pVirtualPipe->ShowAngleDim((m_pDlg != NULL && m_pDlg->m_bLockAngle) ? true : false);

		m_pPipe->SetEndPoint(ptTmp);
	}
	// cet 2010.6.23
	if (m_bGreen)
	{
		m_pPipe->setColorIndex(3);
	}

	// cet 2011.7.27 add 普通管线，有角度盘时调整点位置
	double dViewSize = GetViewSize();
	AcGePoint3d ptViewCenter = GetViewCenter();
	if (m_pDlg != NULL && m_iType == 0 && m_pDlg->m_bLockAngle && m_ptWatch.Distance(m_pt1) > _DIST_SNAP
		|| (m_pDlg != NULL && m_iType == 0 && fabs(dViewSize - m_dViewSize) > 0.00001 && m_pDlg->m_bLockAngle) 
		|| (m_pDlg != NULL && m_iType == 0 && ptViewCenter.distanceTo(m_ptViewCenter) > _DIST_SNAP && m_pDlg->m_bLockAngle))
	{
		m_dViewSize = dViewSize;
		m_ptViewCenter = ptViewCenter;
		m_ptWatch = m_pt1;
		DrawDuctWatch(m_ptWatch);
	}
	return bRet;
}

AcDbEntity* TPipeEdJig::entity() const
{
//	return (AcDbEntity *)m_pPipe; cet 2011.7.27 modify
	return (AcDbEntity*)m_pVirtualPipe;
}

// 绘制刻度盘
void TPipeEdJig::DrawDuctWatch(const AcGePoint3d& ptCenter)
{	
	if (Is3DView()) // 三维下不绘制
	{
		return;
	}

	double dScale = m_dWatchScale * PI / 180.0;
	int iSegs = (int)(0.5 * PI / dScale);
	if (iSegs < 1)
		iSegs = 1;
	dScale = 0.5 * PI / iSegs;
	
	// 刻度盘支持0~180之间的任意角度
	double dScale2 = m_dWatchScale * PI / 180.0;
	int iSegs2 = (int)(PI * 2 / dScale2);
	if(1e-6 < PI * 2 - iSegs2 * dScale2)
		iSegs2++;
	
	AcGeVector3d vt = m_vtWatch * PixelToWcs(40);
	AcGePoint3d pt1, pt2, pt3, pt4;
	pt1 = ptCenter + vt;
	
	ads_point ptS, ptE;
	if(EQUAL_ZERO(dScale2 - dScale))
	{
		for (int i = 0; i < iSegs * 4; i++)
		{	
			pt3 = pt1 + vt / 10.0;
			pt4 = pt1 - vt / 10.0;		
			
			ptS[0] = pt3.x; ptS[1] = pt3.y; ptS[2] = pt3.z;
			ptE[0] = pt4.x; ptE[1] = pt4.y; ptE[2] = pt4.z;
			acdbWcs2Ucs(ptS, ptS, FALSE);
			acdbWcs2Ucs(ptE, ptE, FALSE);
			acedGrDraw(ptS, ptE, -1, 0);
			
			vt.rotateBy(dScale, AcGeVector3d::kZAxis);
			pt2 = ptCenter + vt;
			
			ptS[0] = pt1.x; ptS[1] = pt1.y; ptS[2] = pt1.z;
			ptE[0] = pt2.x; ptE[1] = pt2.y; ptE[2] = pt2.z;
			acdbWcs2Ucs(ptS, ptS, FALSE);
			acdbWcs2Ucs(ptE, ptE, FALSE);
			acedGrDraw(ptS, ptE, -1, 0);
			
			pt1 = pt2;
		}
	}
	else
	{
		AcGePoint3d ptEnd = pt1;
		for (int i = 0; i < iSegs2; i++)
		{
			pt3 = pt1 + vt / 10.0;
			pt4 = pt1 - vt / 10.0;
			
			ptS[0] = pt3.x; ptS[1] = pt3.y; ptS[2] = pt3.z;
			ptE[0] = pt4.x; ptE[1] = pt4.y; ptE[2] = pt4.z;
			acdbWcs2Ucs(ptS, ptS, FALSE);
			acdbWcs2Ucs(ptE, ptE, FALSE);
			acedGrDraw(ptS, ptE, -1, 0);
			
			vt.rotateBy(dScale2, AcGeVector3d::kZAxis);
			pt2 = ptCenter + vt;
			if(iSegs2 - 1 == i)
				pt2 = ptEnd;
			
			ptS[0] = pt1.x; ptS[1] = pt1.y; ptS[2] = pt1.z;
			ptE[0] = pt2.x; ptE[1] = pt2.y; ptE[2] = pt2.z;
			acdbWcs2Ucs(ptS, ptS, FALSE);
			acdbWcs2Ucs(ptE, ptE, FALSE);
			acedGrDraw(ptS, ptE, -1, 0);
			pt1 = pt2;
		}
	}
}

void TPipeEdJig::GetWatchPt(const TADSGePoint3d pt1, TADSGePoint3d &pt, double &dAngleRet)
{
	if (Is3DView())
	{
		pt = pt1;
		dAngleRet = 0.0;
		return;
	}

	if (!m_ptWatch) // 第一次使用直接返回，防止出现错误管线
	{
		return;
	}

	AcGeVector3d vt = pt1 - m_ptWatch;
	if(vt.isZeroLength()) // cet 2011.8.23 add
	{
		return;
	}
	AcGeVector3d vtX = m_vtWatch;
	double dAngle = vtX.angleTo(vt, AcGeVector3d::kZAxis);
	dAngle *= 180 / PI;
	double dAngle1 = 0.0;
	while(dAngle > dAngle1) // 找到大于dAngle的角度
	{
		dAngle1 += m_dWatchScale;
	}

	// 获得角度盘上小于dAngle的最大角度
	double dMax = dAngle1 - m_dWatchScale; 
	// 获得角度盘上大于dAngle的最小角度
	double dMin = dAngle1;
	if (dMin > 2 * 180)
	{
		dMin = 2 * 180;
	}

	if (fabs(dAngle - dMax) < fabs(dAngle - dMin))
	{
		vt.rotateBy((dMax - dAngle) * PI / 180, AcGeVector3d::kZAxis);
		dAngleRet = dMax;
	}
	else
	{
		vt.rotateBy((dMin - dAngle) * PI / 180, AcGeVector3d::kZAxis);
		dAngleRet = dMin;
	}

	if (dAngleRet > 180)
	{
		dAngleRet = 180 - (dAngleRet - 180);
	}

	pt = m_ptWatch + vt;
}

void TPipeEdJig::SetDlg(CDrawStandPipeDlg *pDlg)
{
	m_pDlg = pDlg;
}

void TPipeEdJig::SetPipeDir(const AcGeVector3d &vt)
{
	m_vtWatch = vt;
}

double TPipeEdJig::GetViewSize()
{
	struct resbuf rb = {NULL, RTREAL, 0};
	acedGetVar(_T("VIEWSIZE"), &rb);
	double dViewSize = rb.resval.rreal;
	return dViewSize;
}

AcGePoint3d TPipeEdJig::GetViewCenter()
{
	struct resbuf rb = {NULL, RT3DPOINT, 0};
	acedGetVar(_T("VIEWCTR"), &rb);
	AcGePoint3d ptViewCenter = asPnt3d(rb.resval.rpoint);
	return ptViewCenter;
}

bool TPipeEdJig::Is3DView()
{
	struct resbuf rb = {NULL, RT3DPOINT, 0};
	acedGetVar(_T("VIEWDIR"), &rb);
	AcGePoint3d ptView = asPnt3d(rb.resval.rpoint);
	AcGeVector3d vtView = ptView.asVector();
	return !vtView.isCodirectionalTo(AcGeVector3d::kZAxis);
}

// cet 2012.3.16 add 设置角度盘角度
void TPipeEdJig::SetWatchAngle( double dAngle )
{
	m_dWatchScale = dAngle;
}

void TPipeEdJig::RedrawWatch()
{
	acedRedraw(NULL, 0); // 清除当前表盘
	DrawDuctWatch(m_ptWatch);
}

BOOL CDrawStandPipeDlg::PreTranslateMessage(MSG* pMsg) 
{
	
	return CModelessDialog::PreTranslateMessage(pMsg);
}


void CDrawStandPipeDlg::OnCheckLockangle() 
{
	UpdateData(TRUE);
//  cet 2012.3.16 modify 操作角度盘时发送关键字	
// 	if (!m_bLockAngle)
// 	{
// 		PostCommand(_T("L "), false); 	//	cet 2011.8.1 add 刷新
// 	}
	if (m_bSendCmdKeyToCAD)
	{
		PostCommand(_T("L "), false);
	}

	// cet 2012.3.15 add
	EnableAngleMenu(m_bLockAngle); 
}

void CDrawStandPipeDlg::OnRadioPos1()
{
	UpdateData(TRUE);
	m_csDim1 = g_csPipeDim[0]; 
	m_csDim2 = g_csPipeDim[1]; 
	m_csDim3 = g_csPipeDim[2]; 
	m_csDim7 = g_csPipeDim[6]; 
	m_csDim8 = g_csPipeDim[7]; 
	m_csDim9 = g_csPipeDim[8]; 
	UpdateData(FALSE);
	//PostCommand(_T("V "), false);
	// zxl 2013.10.17 add
	if (m_bInitDlg)
	{
		PostCommand(_T("V "), false);
	}
}

void CDrawStandPipeDlg::OnRadioPos2()
{
	UpdateData(TRUE);
	m_csDim1 = g_csPipeDim[17]; 
	m_csDim2 = g_csPipeDim[19]; 
	m_csDim3 = g_csPipeDim[21]; 
	m_csDim7 = g_csPipeDim[27]; 
	m_csDim8 = g_csPipeDim[23]; 
	m_csDim9 = g_csPipeDim[25]; 
	UpdateData(FALSE);
	//PostCommand(_T("V "), false);
	// zxl 2013.10.17 add
	if (m_bInitDlg)
	{
		PostCommand(_T("V "), false);
	}
}

void CDrawStandPipeDlg::OnRadioPos3()
{
	UpdateData(TRUE);
	m_csDim1 = g_csPipeDim[18]; 
	m_csDim2 = g_csPipeDim[20]; 
	m_csDim3 = g_csPipeDim[22]; 
	m_csDim7 = g_csPipeDim[28]; 
	m_csDim8 = g_csPipeDim[24]; 
	m_csDim9 = g_csPipeDim[26]; 
	UpdateData(FALSE);
	//PostCommand(_T("V "), false);
	// zxl 2013.10.17 add
	if (m_bInitDlg)
	{
		PostCommand(_T("V "), false);
	}
}

void CDrawStandPipeDlg::UpdateDimText()
{
	if (m_iPos == 0)
	{
		OnRadioPos1();
	}
	else if (m_iPos == 1)
	{
		OnRadioPos2(); 
	}
	else if (m_iPos == 2)
	{
		OnRadioPos3();
	}
}

void CDrawStandPipeDlg::InitAngleData()
{
	if (m_mapAngle.empty())
	{
		m_mapAngle.insert(std::make_pair(15, true));
		m_mapAngle.insert(std::make_pair(22.5, false));
		m_mapAngle.insert(std::make_pair(30, false));
		m_mapAngle.insert(std::make_pair(45, false));
		m_mapAngle.insert(std::make_pair(60, false));
	}
}

void CDrawStandPipeDlg::EnableAngleMenu( BOOL bEnable )
{
	// 设置角度菜单  cet 2012.3.15
	CWnd *pWnd = GetDlgItem(IDC_BUTTON_ANGLEMENU);
	if (pWnd != NULL)
	{
		pWnd->EnableWindow(bEnable);
	}
}

BOOL CDrawStandPipeDlg::SelectAngleMenuItem( double dAngle )
{
	std::map<double,bool>::iterator it;
	it = m_mapAngle.find(dAngle);
	if (it != m_mapAngle.end())
	{
		std::map<double,bool>::iterator itM;
		for (itM = m_mapAngle.begin(); itM != m_mapAngle.end(); itM++)
		{
			if (it != itM)
			{
				itM->second = false;
			}
			else
			{
				itM->second = true;
			}
		}
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

double CDrawStandPipeDlg::GetAngleFromMenu()
{
	double dRet = 0.0;
	std::map<double,bool>::iterator it;
	for (it = m_mapAngle.begin(); it != m_mapAngle.end(); it++)
	{
		if(it->second) 
		{
			dRet = it->first;
			break;
		}
	}
	return dRet;
}

BOOL CDrawStandPipeDlg::IsLockAngle()
{
	return m_bLockAngle;
}

void CDrawStandPipeDlg::EnableSendKeyToCAD( BOOL bSend )
{
	m_bSendCmdKeyToCAD = bSend;
}

void CDrawStandPipeDlg::EnableLockAngle( BOOL bEanble )
{
	m_bLockAngle = bEanble;
	EnableAngleMenu(bEanble);
}

void CDrawStandPipeDlg::UpdatePipeDn( BOOL bRead /*= TRUE*/, BOOL bCmbSel /*= FALSE*/ )
{
	CWnd *pWnd = GetDlgItem(IDC_COMBO_DN);
	if (pWnd == NULL)
	{
		return;
	}
	if (bRead)
	{
		if (bCmbSel)
		{
			CComboBox *pBox = (CComboBox*)pWnd;
			if (pBox != NULL)
			{
				int nIndex = pBox->GetCurSel();
				if (nIndex != -1)
				{
					pBox->GetLBText(nIndex, m_csDn);
				}
			}
		} 
		else
		{
			pWnd->GetWindowText(m_csDn);
		}
	}
	else
	{
		pWnd->SetWindowText(m_csDn);
	}
}

void CDrawStandPipeDlg::OnEditChangeComboDn() 
{
	UpdateData(TRUE);
	UpdatePipeDn();
}

void CDrawStandPipeDlg::OnSelchangeComboDn() 
{
	UpdateData(TRUE);
	UpdatePipeDn(TRUE, TRUE);
}

void CDrawStandPipeDlg::OnEditChangeFloorName()
{
//  cet 2013.3.18 modify 不能连续输入
//  UpdateData(TRUE);
//  // 更新编号
//  PostCommand(_T("V "), false);
	UpdateData(TRUE);
	m_csName = ::GetCurSerial(GetLayer(), m_csFloorName, GetCurSerialFormat(), m_ssEnt);
	UpdateData(FALSE);
}  

void CDrawStandPipeDlg::InitMenuSerial()
{
	m_mapSerial.clear();
	DWORD id = WM_USER + 1;
	CString sName = _T("数字编号递增");
	m_mapSerial.insert(std::make_pair(id, std::make_pair(sName, false)));
	sName = _T("英文编号递增");
	m_mapSerial.insert(std::make_pair(++id, std::make_pair(sName, false)));

	std::map<DWORD, std::pair<CString, bool> >::iterator it;
	std::map<DWORD, std::pair<CString, bool> >::iterator itEnd = m_mapSerial.end();
	it = m_mapSerial.find(m_nSelSerialID);
	if (it != itEnd)
	{
		it->second.second = true;
	}
	else
	{
		std::map<DWORD, std::pair<CString, bool> >::iterator itBegin = m_mapSerial.begin();
		itBegin->second.second = true;
	}
}

void CDrawStandPipeDlg::UpdateSpinVisible()
{
	CWnd *pWnd = GetDlgItem(IDC_SPIN_NAME);
	if (pWnd == NULL)
	{
		return;
	}

	CWnd *pWndSerial = GetDlgItem(IDC_EDIT_NAME);
	if (pWndSerial == NULL)
	{
		return;
	}

	CRect rect;
	pWnd->GetWindowRect(&rect);
	CRect rectNew;
 	pWndSerial->GetWindowRect(&rectNew);
 	ScreenToClient(&rectNew);
 	ScreenToClient(&rect);

	if (m_nSelSerialID == WM_USER + 1)
	{
		pWnd->ShowWindow(SW_SHOW);
		rectNew.right = rect.left;
		pWndSerial->MoveWindow(&rectNew);
	}
	else if (m_nSelSerialID == WM_USER + 2)
	{
		pWnd->ShowWindow(SW_HIDE);	
		rectNew.right = rect.right;
		pWndSerial->MoveWindow(&rectNew);
	}
}

CString CDrawStandPipeDlg::GetCurSerialFormat()
{
	CString sRet;
	if (m_nSelSerialID == WM_USER + 1) 
	{
		sRet = _T("1");
	}
	else if (m_nSelSerialID == WM_USER + 2)
	{
		sRet = _T("A");
		std::map<int, std::map<CString, CString> > ::iterator it;
		int nPipeIdx = GetPipeIdx();
		it = m_mapPipeSerial.find(nPipeIdx);
		if (it != m_mapPipeSerial.end())
		{
			std::map<CString, CString>::iterator itTemp;
			itTemp = it->second.find(m_csFloorName);
			if (itTemp != it->second.end())
			{
				sRet = itTemp->second;
			}
		}
	}
	return sRet;
}

void CDrawStandPipeDlg::SetPickset( PickSet &ssPipe )
{
	m_ssEnt.Free();
	m_ssEnt += ssPipe;
}

void CDrawStandPipeDlg::UpdateSerial()
{
	// 只更新英文编号
	if (m_nSelSerialID != WM_USER + 2)
	{
		return;
	}

	m_csName = IncreaseSerial(m_csName);
	int nPipeIdx = GetPipeIdx();
	std::map<int, std::map<CString, CString> > ::iterator it;
	it = m_mapPipeSerial.find(nPipeIdx);
	if (it != m_mapPipeSerial.end())
	{
		std::map<CString, CString>::iterator it1;
		it1 = it->second.find(m_csFloorName);
		if (it1 != it->second.end())
		{
			it1->second = m_csName;
		}
		else
		{
			it->second.insert(std::make_pair(m_csFloorName, m_csName));
		}
	}
	else
	{
		std::map<CString, CString> mapTemp;
		mapTemp.insert(std::make_pair(m_csFloorName, m_csName));
		m_mapPipeSerial.insert(std::make_pair(nPipeIdx, mapTemp));
	}
}