//DimPipe.cpp

#include "stdafx.h"
 
#include <DbPipeLabel.h>
#include <xtext.h>
#include <DbEquipment.h>
#include <PipeWireMonitor.h>
#include <DbWell.h>

#include <ctype.h>
#include <vector>
#include <algorithm>

#include "jig.h"
#include "TPipeGraph.h"
#include "DbVPipeDim.h"
#include "TVPipeDimJig.h"
#include "SprinklerDimDlg.h"
#include "GlobalFunction.h"

#define IDC_USER_COMBOX_TYPE3  1092

extern BOOL IsPtOnPipe(XPoint pt, Entity ent);
extern void SearchOneselfPipe(AcDbObjectId idPipe, TPipeGraph &PipeGraph);
//***************************************************************************************************
//                                        标注图层
//***************************************************************************************************
CString GetEquipLayBySys(TPipeSys::SysType sys)
{
    CString csRet;
    if(sys == TPipeSys::kFeedWater || sys == TPipeSys::kFeedWater2 || sys == TPipeSys::kFeedWater3) // cet 2011.12.6 modify 增加中高区
        csRet = LAY_EQ_FEED;
    else if(sys == TPipeSys::kHeatFeedWater || sys == TPipeSys::kHeatFeedWater2 || sys == TPipeSys::kHeatFeedWater3) // cet 2011.12.6 modify 增加中高区
        csRet = LAY_EQ_HEADFEED;
    else if(sys == TPipeSys::kHeatBackWater || sys == TPipeSys::kHeatBackWater2 || sys == TPipeSys::kHeatBackWater3) // cet 2011.12.6 modify 增加中高区
        csRet = LAY_EQ_HEADBACK;
    else if(sys == TPipeSys::kDirtWater)
        csRet = LAY_EQ_DIRT;
    else if(sys == TPipeSys::kUselessWater)
        csRet = LAY_EQ_USELESS;
    else if(sys == TPipeSys::kRainWater)
        csRet = LAY_EQ_RAIN;
    else if(sys == TPipeSys::kUsedWater || sys == TPipeSys::kUsedWater2 || sys == TPipeSys::kUsedWater3) // cet 2011.12.6 modify 增加中高区
        csRet = LAY_EQ_USED;
    else if(sys == TPipeSys::kFireFighting || sys == TPipeSys::kFireFighting2 || sys == TPipeSys::kFireFighting3) // cet 2011.12.6 modify 增加中高区
        csRet = LAY_EQ_FIRE;
    else if(sys == TPipeSys::kSprinkle || sys == TPipeSys::kSprinkle2 || sys == TPipeSys::kSprinkle3) // cet 2011.12.6 modify 增加中高区
        csRet = LAY_EQ_SPRINKLE;
    else if(sys == TPipeSys::kCoagulate)
        csRet = LAY_EQ_COAGULATE;
    else if(sys == TPipeSys::kDrink)
        csRet = LAY_EQ_DRINK;
    else if(sys == TPipeSys::kPressDirt)
        csRet = LAY_EQ_PRESSDIRT;
    else if(sys == TPipeSys::kPressUseless)
        csRet = LAY_EQ_PRESSUSELESS;
    else if(sys == TPipeSys::kPressRain)
        csRet = LAY_EQ_PRESSRAIN;
    else if(sys == TPipeSys::kCivilFeed)
        csRet = LAY_EQ_USER1;
    else if(sys == TPipeSys::kCycleFeed)
        csRet = LAY_EQ_USER2;
    else if(sys == TPipeSys::kOther)
        csRet = LAY_EQ_OTHER;
	else if(sys == TPipeSys::kUser3) // cet 2011.12.2 add user3-user8
		csRet = LAY_EQ_USER3;
	else if(sys == TPipeSys::kUser4)
		csRet = LAY_EQ_USER4;
	else if(sys == TPipeSys::kUser5)
		csRet = LAY_EQ_USER5;
	else if(sys == TPipeSys::kUser6)
		csRet = LAY_EQ_USER6;
	else if(sys == TPipeSys::kUser7)
		csRet = LAY_EQ_USER7;
	else if(sys == TPipeSys::kUser8)
		csRet = LAY_EQ_USER8;
	
    return csRet;
}

//***************************************************************************************************
//                                        立管标注
//***************************************************************************************************
//extern const TCHAR* GetDnByMat(const TCHAR* szMat);

// zxl 2013.08.22 add
static CString GetXDataByName(const AcDbObjectId &id,const TCHAR*szName)
{
	CString sXData;
	AcDbEntity *pEnt = NULL;
	if (acdbOpenAcDbEntity(pEnt,id,AcDb::kForRead) == Acad::eOk)
	{
		resbuf  *pRb = pEnt->xData(szName);	
		if (pRb != NULL)
		{
			CString csRet;
			if (pRb != NULL)  
			{  
				resbuf  *pTemp = pRb; 
				if (pTemp->rbnext != NULL)
				{
					pTemp = pTemp->rbnext;
					if (pTemp->restype == 1000)	
						csRet = pTemp->resval.rstring;	
				}
			}	
			ads_relrb(pRb);	
			sXData = csRet;   
		}
		pEnt->close();
	}
	return sXData;
}

// zxl 2013.08.22 add
double GetDimStrLen(const AcDbObjectId id, double &dDnLength)
{
	CString sText, csDimHead;
	ads_name name;
	acdbGetAdsName(name, id);
	Entity entPipe = name;
	AcDbEntity *pEnt = NULL;
	if (Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForRead))
	{
		TDbPipe *pPipe = TDbPipe::cast(pEnt);
		if (pPipe != NULL)
		{
			CString csLabel = pPipe->GetLabel();
			double dDn = pPipe->GetDnDiameter();
			csDimHead.Format(_T("%s%.0f"), csLabel, dDn);
		}
		pEnt->close();
	}
	
	CString csLay = GetPipeLayer(entPipe);
	CString csDim = g_csPipeDim[GetPipeLayerIdxByName(csLay)] + _T("L");
	if(!g_bIsPipeDimCir)
		csDim += _T("-");
	
	int nFind = csDim.Find(_T("-"),0);
	if (nFind != -1)
		csDim = csDim.Left(nFind);
	
	CString sPipeIndex = GetXDataByName(id, _T("PIPE-SERIAL"));
	CString sFloorNum = GetXDataByName(id, _T("BUILDING-SERIAL"));
	if (!sFloorNum.IsEmpty())
	{
		switch(g_iVPipeDimStyle)
		{
		case TVPipeDim::eType1:
			sText.Format(_T("%s-%s-%s"), sFloorNum, csDim, sPipeIndex);
			break;
		case TVPipeDim::eType2:
			sText.Format(_T("%s-%s-%s"), csDim, sFloorNum, sPipeIndex);
			break;
		case TVPipeDim::eType3:
			sText.Format(_T("%s-%s%s"), csDim, sFloorNum, sPipeIndex);
			break;	
		case TVPipeDim::eType4:
			{
				sText.Format(_T("%s%s-%s"), sFloorNum, csDim, sPipeIndex);
				break;
			}
		case TVPipeDim::eType5:
			sText.Format(_T("%s%s-%s"), csDim, sFloorNum, sPipeIndex);
			break;
		default:
			break;
		}
	}
	else
	{
		sText.Format(_T("%s-%s"), csDim, sPipeIndex);
	}
	
	double dLabelLen = 0.0;
	AcDbObjectId idTextStyle = InitTwtTextStyle(g_csVPipeStyle);
	CString sStyleName = GetSymbolName(idTextStyle).cs();
	struct resbuf* pRb = acutBuildList(RTDXF0, _T("TEXT"),
		1, sText,
		7, sStyleName,
		40, g_nVPipeHeight,
		41, DocGetPScale(),
		0);
	
	ads_point adsPt1, adsPt2;
	int iRet = acedTextBox(pRb, adsPt1, adsPt2);
	dLabelLen = asPnt3d(adsPt1).distanceTo(asPnt3d(adsPt2)) + g_nVPipeHeight*DocGetPScale();
	acutRelRb(pRb);
	
	TDbText text;
	text.SetText((const TCHAR*)sText);
	text.SetStyleId(idTextStyle);
	text.SetLocation(XPoint());
	text.SetHeight(g_nVPipeHeight);
	text.SetAlignment(XExplodeDraw::kMiddleCenter);
	XPoint pt = text.GetExtents();
	dLabelLen = asPnt3d(adsPt1).distanceTo(pt);

	text.SetText((const TCHAR*)csDimHead);
	pt = text.GetExtents();
	dDnLength = asPnt3d(adsPt1).distanceTo(pt);
	
	return dLabelLen;
}

// zxl 2012.06.29 add 通过管线图层获取相对应的立管图层
void GetVPipeLayerByPipeLayer(CString &strPipeLayer)
{
	if (strPipeLayer.Compare(LAY_PIPE_FEED) == 0 || strPipeLayer.Compare(LAY_PIPE_FEED2) == 0 || strPipeLayer.Compare(LAY_PIPE_FEED3) == 0)
	{
		strPipeLayer = LAY_VPIPE_FEED;
	}
	else if (strPipeLayer.Compare(LAY_PIPE_HEADFEED) == 0 || strPipeLayer.Compare(LAY_PIPE_HEADFEED2) == 0 || strPipeLayer.Compare(LAY_PIPE_HEADFEED3) == 0 )
	{
		strPipeLayer = LAY_VPIPE_HEADFEED;
	}
	else if (strPipeLayer.Compare(LAY_PIPE_HEADBACK) == 0 || strPipeLayer.Compare(LAY_PIPE_HEADBACK2) == 0 || strPipeLayer.Compare(LAY_PIPE_HEADBACK3) == 0)
	{
		strPipeLayer = LAY_VPIPE_HEADBACK;
	}
	else if (strPipeLayer.Compare(LAY_PIPE_DIRT) == 0)
	{
		strPipeLayer = LAY_VPIPE_DIRT;
	}
	else if (strPipeLayer.Compare(LAY_PIPE_USELESS) == 0)
	{
		strPipeLayer = LAY_VPIPE_DIRT;
	}
	else if (strPipeLayer.Compare(LAY_PIPE_RAIN) == 0)
	{
		strPipeLayer = LAY_VPIPE_RAIN;
	}
	else if (strPipeLayer.Compare(LAY_PIPE_USED) == 0 || strPipeLayer.Compare(LAY_PIPE_USED2) == 0 || strPipeLayer.Compare(LAY_PIPE_USED3) == 0)
	{
		strPipeLayer = LAY_VPIPE_USED;
	}
	else if (strPipeLayer.Compare(LAY_PIPE_FIRE) == 0 || strPipeLayer.Compare(LAY_PIPE_FIRE2) == 0 || strPipeLayer.Compare(LAY_PIPE_FIRE3) == 0)
	{
		strPipeLayer = LAY_VPIPE_FIRE;
	}
	else if (strPipeLayer.Compare(LAY_PIPE_SPRINKLE) == 0 || strPipeLayer.Compare(LAY_PIPE_SPRINKLE2) == 0 || strPipeLayer.Compare(LAY_PIPE_SPRINKLE3) == 0)
	{
		strPipeLayer = LAY_VPIPE_SPRINKLE;
	}
	else if (strPipeLayer.Compare(LAY_PIPE_COAGULATE) == 0)
	{
		strPipeLayer = LAY_VPIPE_COAGULATE;
	}
	else if (strPipeLayer.Compare(LAY_PIPE_DRINK) == 0)
	{
		strPipeLayer = LAY_VPIPE_DRINK;
	}
	else if (strPipeLayer.Compare(LAY_PIPE_PRESSDIRT) == 0)
	{
		strPipeLayer = LAY_VPIPE_PRESSDIRT;
	}
	else if (strPipeLayer.Compare(LAY_PIPE_PRESSUSELESS) == 0)
	{
		strPipeLayer = LAY_VPIPE_PRESSUSELESS;
	}
	else if (strPipeLayer.Compare(LAY_PIPE_PRESSRAIN) == 0)
	{
		strPipeLayer = LAY_VPIPE_PRESSRAIN;
	}
	else if (strPipeLayer.Compare(LAY_PIPE_OTHER) == 0)
	{
		strPipeLayer = LAY_VPIPE_OTHER;
	}
	else if(strPipeLayer.Compare(LAY_PIPE_USER1) == 0)
	{
        strPipeLayer = LAY_VPIPE_USER1;
	}
    else if(strPipeLayer.Compare(LAY_PIPE_USER2) == 0)
	{
        strPipeLayer = LAY_VPIPE_USER2;
	}
	else if (strPipeLayer.Compare(LAY_PIPE_USER3) == 0)
	{
		strPipeLayer = LAY_VPIPE_USER3;
	}
	else if (strPipeLayer.Compare(LAY_PIPE_USER4) == 0)
	{
		strPipeLayer = LAY_VPIPE_USER4;
	}
	else if (strPipeLayer.Compare(LAY_PIPE_USER5) == 0)
	{
		strPipeLayer = LAY_VPIPE_USER5;
	}
	else if (strPipeLayer.Compare(LAY_PIPE_USER6) == 0)
	{
		strPipeLayer = LAY_VPIPE_USER6;
	}
	else if (strPipeLayer.Compare(LAY_PIPE_USER7) == 0)
	{
		strPipeLayer = LAY_VPIPE_USER7;
	}
	else if (strPipeLayer.Compare(LAY_PIPE_USER8) == 0)
	{
		strPipeLayer = LAY_VPIPE_USER8;
	}
}
void DoDimStandPipe(AcDbObjectId idPipe, const TCHAR* szName, const TCHAR* szSerial)
{  
	DocSetMultiLeaderDistRatio(0.2); //设置文字距线端距离（全局）
    XPoint ptPick1, ptPick2;
    TCHAR szLayer[256];
    double nDn;
    CString csDimHead;
	CString csLay;
	double dRadius(0);
	CString sPipeLayer; // cet 2012.4.19 add
    OPENOBJ_BEGIN(idPipe, AcDb::kForRead, TDbPipe, pPipe);
    if(pPipe){
		dRadius = pPipe->GetRadius()*pPipe->GetPScale();
        TCHAR *layer;
        layer = pPipe->layer();
        _tcscpy(szLayer, layer);
        csDimHead = pPipe->GetLabel();
		sPipeLayer = layer; // cet 2012.4.19 add
        delete [] layer;
		
		if(csDimHead == _T("")){
			int iMaterial = pPipe->GetMaterial();
			CString csMat = GetPipeMaterialByIdx(iMaterial);
			csDimHead = GetDnByMat(csMat);
		}
        nDn = pPipe->GetDnDiameter();
	 // 2013.3.28 cet modify csDimHead用法可能导致崩溃，尤其是debug模式下
     // csDimHead.Format(_T("%s%.0f"), csDimHead, nDn);
		CString sTemp = csDimHead;
		csDimHead.Format(_T("%s%.0f"), sTemp, nDn);

        if(pPipe->IsVertical()){
            ptPick1 = pPipe->StartPoint();
            ptPick1.z = 0;
        }
        else /*if(!g_bIsPipeDimCir)*/{
			if(ads_getpoint(NULL, _T("\n请点取标注起点<退出>:"), ptPick1) != RTNORM)
                return;
			ptPick1 = Ucs2Wcs(ptPick1);
        }
		csLay = GetDimLayBySys(pPipe->GetSysType());
	}
    OPENOBJ_END();
	InitLayer(csLay);
				
//   InitLayer(LAY_VPIPE_DIM);
//    DocSetText2Base(0.2);
    CString csDim = szName;
  //  csDim += szSerial;
	int nFind = csDim.Find(_T("-"),0);
	if (nFind != -1)
		csDim = csDim.Left(nFind);
    AcDbObjectId idTextStyle = InitTwtTextStyle(g_csVPipeStyle);
    if(!idTextStyle)
        return;	

	TDbVPipeDim *pDim = new TDbVPipeDim;
	pDim->SetDimRadius(g_nDimCirDiam);
	pDim->SetDimType(g_bIsPipeDimCir);
	// ZXL 2013.08.22 ADD
	double dDn = 0.0;
	double dDst = GetDimStrLen(idPipe, dDn) + g_dVPipeDimDn2Label * DocGetPScale();
	CString sDst;
	sDst.Format(_T("%.1f"), dDst);
	dDst = _tstof(sDst);
	pDim->SetDnDistance2LabelLoc(dDst);
	pDim->SetDnDistBetweenLabel(g_dVPipeDimDn2Label);
//  cet 2012.8.27 modify 无论当前设置是否是标注4样式都需设置此值，以便编辑标注更改为样式4时，显示正确设置
//	// cet 2012.4.19 add
//	if (g_bIsPipeDimCir == TVPipeDim::eDimType4)
	{
		GetVPipeLayerByPipeLayer(sPipeLayer);// zxl 2012.06.29 add 通过管线图层获取相对应的立管图层
		pDim->SetShowDnForDimType4(IsShowVPipeDimDn(sPipeLayer) ? true : false);
		pDim->SetAlignTypeForDimType4(g_nAlignTypeForVPipeDim4);
	}
	pDim->SetDimTypeText(csDim);
	pDim->SetTextHeight(g_nVPipeHeight);
	if (g_bIsPipeDimCir == TVPipeDim::eDimType2)
	{
		pDim->SetTextStyleId(InitTwtTextStyle(g_csCircleTextStyle));
	}
	else
	{
		pDim->SetTextStyleId(idTextStyle);
		pDim->SetText2BaseRatio(g_nDimCirDiam); // SR 2009-11-5 全局变量g_nDnDimDist2Pipe改为g_nDimCirDiam
	}
	pDim->SetVtDir(AcGeVector3d::kXAxis);
	pDim->SetStartPt(ptPick1);	
	pDim->SetTextLayerId(InitLayer(LAY_TEXT));
	pDim->setLayer(csLay);
	pDim->SetLayoutRotation(Ucs2Wcs(0.0));
	pDim->SetVPipeFloorType(g_iVPipeDimStyle);

	pDim->SetVPipeId(idPipe);

	TVPipeDimJig jig(pDim);
	jig.SetStartPt(ptPick1);
	if(jig.DoIt() == RTNORM)
	{
		if (g_bIsPipeDimCir == TVPipeDim::eDimType2)
		{
			pDim->AddToCSpace(Adesk::kFalse);
            pDim->setLayer(LAY_VPIPE_DIM);
            pDim->close();
		}
		else
		{
			AddToCurrentSpace(pDim,Adesk::kTrue);	
		}

		if(_tcscmp(szLayer, _T("")) != 0)
		{
			Entity entLast;
			entLast.GetLast();
			WriteXdata(entLast, _T("TG-LAYER"), szLayer);
		}
	}
	else
	{
		delete pDim;
	}
}

void DoDimStandPipe2(AcDbObjectId idPipe, const TCHAR* szName, const TCHAR* szSerial)
{
    XPoint ptPick1, ptPick2;
    TCHAR szLayer[256];
    double nDn;
    CString csDimHead;
	double dRadius(0);
    OPENOBJ_BEGIN(idPipe, AcDb::kForRead, TDbPipe, pPipe);
    if(pPipe){
		dRadius = pPipe->GetRadius()*pPipe->GetPScale();
        TCHAR *layer;
        layer = pPipe->layer();
        _tcscpy(szLayer, layer);
        csDimHead = pPipe->GetLabel();
        delete [] layer;
		
		if(csDimHead == ""){
			int iMaterial = pPipe->GetMaterial();
			CString csMat = GetPipeMaterialByIdx(iMaterial);
			csDimHead = GetDnByMat(csMat);
		}
        nDn = pPipe->GetDnDiameter();
        csDimHead.Format(_T("%s%.0f"), csDimHead, nDn);

        if(pPipe->IsVertical()){
            ptPick1 = pPipe->StartPoint();
            ptPick1.z = 0;
        }
        else if(!g_bIsPipeDimCir){
			if(ads_getpoint(NULL, _T("\n请点取标注起点<退出>:"), ptPick1) != RTNORM)
                return;
        }
    }
    OPENOBJ_END();
    InitLayer(LAY_VPIPE_DIM);
//    DocSetText2Base(0.2);
    CString csDim = szName;
    csDim += szSerial;
    AcDbObjectId idTextStyle = InitTwtTextStyle(g_csVPipeStyle);
    if(!idTextStyle)
        return;	
  
    if(g_bIsPipeDimCir == 1){
        TDbSymbDrawingIndex *pIndex = new TDbSymbDrawingIndex;
        pIndex->SetTextStyleId(InitTwtTextStyle(g_csCircleTextStyle));
        pIndex->SetIndexLabel(szSerial);
        pIndex->SetDrawingLabel(szName);
	 
        pIndex->SetTextLayerId(InitLayer(LAY_TEXT));
        pIndex->SetRadius(g_nDimCirDiam/2);
        pIndex->SetLineWidth(0);
        XPoint ptLoc;
        xg_getvar(_T("VIEWCTR"), ptLoc);
        pIndex->SetCenter(Ucs2Wcs(ptLoc));
        TDrawingIdxEdJig jig(pIndex);
		jig.SetPrompt(_T("\n请给出标注位置<退出>:"));
        if(jig.DoIt()==RTNORM) {
            pIndex->AddToCSpace(Adesk::kFalse);
            pIndex->setLayer(LAY_VPIPE_DIM);
            pIndex->close();
        }
        else
            delete pIndex;
        if(_tcscmp(szLayer, _T("")) != 0){
            Entity entLast;
            entLast.GetLast();
            WriteXdata(entLast, _T("TG-LAYER"), szLayer);
        }
        return;
    }
    else if(g_bIsPipeDimCir == 3){
        TDbSymbMultiLeader *pLeader = new TDbSymbMultiLeader;
        XPointList lstVertexes;
        lstVertexes.Append(new XPoint(ptPick1));
        pLeader->SetLeaderVertexes(lstVertexes);
        pLeader->SetText1(csDim);
        pLeader->SetText2(csDimHead);
        pLeader->SetLeaderPoint(ptPick1);
        pLeader->SetArrow(TDbSymbMultiLeader::kNone);
      
        pLeader->SetTextStyleId(idTextStyle);
        pLeader->SetTextLayerId(InitLayer(LAY_TEXT));
        pLeader->SetTextHeight(g_nVPipeHeight);
        pLeader->SetTextBaseLen(pLeader->GetDefaultTextBaseLen());
      
        TLeaderEdJig jig(pLeader);
        jig.SetOperCode(TLeaderEdJig::kLeader);
		jig.SetPrompt(_T("\n输入引线位置<退出>: "));
        if(jig.DoIt()==RTNORM) {
			XPoint ptPick2 = pLeader->GetLeaderPoint();
		////	double dRotation = ads_angle(ptPick1, ptPick2);
		//	ads_polar(ptPick1, dRotation, dRadius, ptPick1);
			lstVertexes.Reset();
			lstVertexes.Append(new XPoint(ptPick1));
			pLeader->SetLeaderVertexes(lstVertexes);
		 
			
            pLeader->AddToCSpace(Adesk::kFalse);
			pLeader->setLayer(LAY_VPIPE_DIM);
			pLeader->close();
//            ((TDbEntity *)pLeader->clone())->AddToCSpace(Adesk::kTrue);
        }
        else
            delete pLeader;
    }
    else{
        TDbSymbComposing ent;
        ent.setLayer(LAY_VPIPE_DIM);
        ent.SetLayoutRotation(Ucs2Wcs(0.0));
        ent.SetStartPoint(ptPick1);
        ent.SetTurnPoint(ptPick1);
        ent.SetText(csDim);
        ent.SetSideText(0);
        ent.SetTextStyleId(idTextStyle);
        ent.SetTextLayerId(InitLayer(LAY_TEXT));
        ent.SetTextHeight(g_nVPipeHeight);
        ent.SetTextBaseLen(ent.GetDefaultTextBaseLen()*1.3);
        TComposingEdJig jig(&ent);
        jig.SetPrompt(_T("\n请给出标注第二点<退出>:"));
        jig.SetOperCode(TComposingEdJig::kTurnPoint);
        if(jig.DoIt()==RTNORM) {
		//	XPoint ptPick2 = ent.GetTurnPoint();
		//	double dRotation = ads_angle(ptPick1, ptPick2);
		//	ads_polar(ptPick1, dRotation, dRadius, ptPick1);
		//	ent.SetStartPoint(ptPick1);
            ((TDbEntity *)ent.clone())->AddToCSpace(Adesk::kTrue);
        }
    }


    if(_tcscmp(szLayer, _T("")) != 0){
        Entity entLast;
        entLast.GetLast();
        OPENOBJ_BEGIN(entLast, AcDb::kForWrite, TDbSymbComposing, pDim);
        if(pDim){
            pDim->setLayer(LAY_VPIPE_DIM);
        }
        OPENOBJ_END();
        WriteXdata(entLast, _T("TG-LAYER"), szLayer);
    }
    
}

Entity CheckSameSerialPipe(const TCHAR *szLay, const TCHAR *sNum, Entity entPipe)
{
	PickSet ss(SS_FREE);
	XPoint pt1,pt2;
	GetPipePoint(entPipe, pt1, pt2);
	pt1.z = 0;

    RBList rbMask(RTDXF0, _T("ATS_PIPE"), 8, szLay, NULL);
    ss.Get(_T("X"), NULL, NULL, rbMask);
    long len = ss.Length();
    for(long i=0;i<len;i++){
        Entity ent = ss[i];
        OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
        if(pPipe && pPipe->IsVertical()){
			pt2 = pPipe->StartPoint();
			pt2.z = 0;

            CString csSerial = ReadXdata(ent, _T("PIPE-SERIAL"));  
            if(csSerial.Compare(sNum) == 0 && !(entPipe == ent) && pt1 != pt2){
                return ent;
			}
        }
        OPENOBJ_END();        
    }
    return Entity();
	
}

void DrawRedFork(XPoint pt1)
{
	XPoint p1, p2, p3, p4;
	ads_polar(pt1, 0, 500, p1);
	ads_polar(p1, PI/2, 500, p1);
	ads_polar(pt1, PI, 500, p2);
	ads_polar(p2, PI/2, -500, p2);
	ads_grdraw(p1, p2, 1, 0); 
	ads_polar(pt1, PI/2, 500, p3);
	ads_polar(p3, PI, 500, p3);
	ads_polar(pt1, PI/2, -500, p4);
	ads_polar(p4, 0, 500, p4);
	ads_grdraw(p3, p4, 1, 0); 
}

//输入立管，返回立管编号
Entity GetPipeDimByEnt(Entity ent)
{
	PickSet ssAll(SS_FREE);
	RBList rbMaskVPipe(RTDXF0, _T("ATS_VPIPEDIM"),NULL);
	ssAll.Get(_T("A"),NULL,NULL,rbMaskVPipe);
	long lLen = ssAll.Length();
	PickSet ssRenew(SS_FREE);
	for (long m = 0; m < lLen; ++m)
	{
		OPENOBJ_BEGIN(ssAll[m], AcDb::kForRead, TDbVPipeDim, pDim);
		if (pDim != NULL)
		{
			AcDbObjectId idDim = pDim->GetVPipeId();
			ads_name name;
			acdbGetAdsName(name,idDim);
			Entity ent2(name);

			if (ent2 == ent)
			{
				ssRenew += ssAll[m];
			}
		}
		OPENOBJ_END();
	}
	Entity entRet;
	if(ssRenew.Length() == 1)      //正常情况下，只得到一个编号，返回它
		entRet = ssRenew[0L];
	else if(ssRenew.Length() == 0) //没有得到编号，可能1没有标注 2标注是copy过来的
	{
		XPoint ptS, ptE;
		GetPipePoint(ent, ptS, ptE);
		PickSet ssDim(SS_FREE);
		GetPointPickSet(ptS, ssDim, rbMaskVPipe, 50);
        if(ssDim.Length() == 1)
		{
            entRet = ssDim[0L];
			AcDbObjectId idDim;
			acdbGetObjectId(idDim, entRet);
			RebindVPipeDim(idDim); //重新绑定
        }
	}
	else if(ssRenew.Length() > 1) //如果得到多于1个，说明曾经被复制过
	{
		XPoint ptS, ptE;
		GetPipePoint(ent, ptS, ptE);
		PickSet ssDim(SS_FREE);
		GetPointPickSet(ptS, ssDim, rbMaskVPipe, 50);
        if(ssDim.Length() == 1)
		{
            Entity entTmp = ssDim[0L];
			if(ssRenew.IsInclude(entTmp))
				entRet = entTmp;
        }
	}
	return entRet;
}

//从立管上得到立管标注，圆标注复杂一些，需要扩大搜索范围
/*
Entity GetPipeDimByPt(XPoint pt, int idx)
{
	PickSet ssDim(SS_FREE);

	RBList rbMaskDim = ads_buildlist( -4, _T("<or"),
    -4, _T("<and"), RTDXF0, _T("ATS_COMPOSING"), 8, _T("*"), -4, _T("and>"),  
    -4, _T("<and"), RTDXF0, _T("ATS_MULTILEADER"), 8, _T("*"), -4, _T("and>"),  
    -4, _T("or>"), NULL);


//	RBList rbMaskDim(RTDXF0, _T("ATS_COMPOSING"), 8, LAY_VPIPE_DIM, NULL);
	RBList rbMaskDim2(RTDXF0, _T("ATS_DRAWINGINDEX"), 8, LAY_VPIPE_DIM, NULL);
	RBList rbMaskDim3(RTDXF0, _T("ATS_MULTILEADER"), NULL);
	if(g_bIsPipeDimCir == 0 || g_bIsPipeDimCir == 2){
		GetPointPickSet(pt, ssDim, rbMaskDim, 50);
        if(ssDim.Length() == 1){
            Entity entDim = ssDim[0L];
            return entDim;
        }
		return Entity();
	}
	else if(g_bIsPipeDimCir == 3){
		GetPointPickSet(pt, ssDim, rbMaskDim3, 50);
        if(ssDim.Length() == 1){
            Entity entDim = ssDim[0L];
            return entDim;
        }
		return Entity();
	}

	GetPointPickSet(pt, ssDim, rbMaskDim2, 500);
	if(ssDim.Length() == 0){
		GetPointPickSet(pt, ssDim, rbMaskDim2, 1000);
		if(ssDim.Length() == 0){
			GetPointPickSet(pt, ssDim, rbMaskDim2, 1500);
		}
	}
	long len = ssDim.Length();
	for(long i=0;i<len;i++){
		Entity ent = ssDim[i];
		OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbSymbDrawingIndex, pDim);
		if(pDim){
			CString csText = pDim->GetIndexLabel();
			if(_ttoi(csText) == idx)
				return ent;
		}
		OPENOBJ_END();
	}
	return Entity();
}
*/

void FindStandPipeBySerial()
{
    TCHAR szText[256];
    
	RBList rbMask(RTDXF0, _T("ATS_VPIPEDIM"), NULL);
    PickSet ss(SS_FREE);
    ss.Get(_T("X"), NULL, NULL, rbMask);
    long len = ss.Length();
    XStringList lstWellName, lstRepeat;
    for(long i=0;i<len;i++){
        Entity ent = ss[i];
		CString sFloorNumT;
		sFloorNumT	= ReadXdata(ent,_T("BUILDING-SERIAL"));
        OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbVPipeDim, pDim);
        if(pDim){
			CString csHead, csSerial;
			pDim->GetDimTypeText(csHead);
			CString sSerial;
			pDim->GetDimVPipeNum(sSerial);
			CString csName,csFloor;
			pDim->GetVPipeFloorNum(csFloor);
			if (csFloor.IsEmpty())
				csName.Format(_T("%s-%s"), csHead, sSerial);
			else
				csName.Format(_T("%s-%s-%s"), csHead,csFloor, sSerial);
            if(lstWellName.Index(csName, 0) < 0)
                lstWellName.Append(tstrnew(csName));
            else
                lstRepeat.Append(tstrnew(csName));
        }     
        OPENOBJ_END();  
    }
    
    for(int j=0;j<lstRepeat.Length();j++){
        adsout << XString(_T("\n编号为%s的立管编号有重复。"), lstRepeat[j]); 
    }
	if(ads_getstring(NULL, _T("\n请输入要搜索立管的编号<退出>:"), szText) != RTNORM)
        return;
    if(_tcsicmp(szText, _T("")) == 0)
        return;
    int count = 0;
	AcDbObjectIdArray idArray;
    PickSet ssWell(SS_FREE);
    for(i=0;i<len;i++){
        Entity ent = ss[i];
		OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbVPipeDim, pDim);
        if(pDim){
			CString csHead, csSerial;
			pDim->GetDimTypeText(csHead);
	//		int iSerial = pDim->GetDimVPipeNum();
			CString csName1, csName2;
			pDim->GetDimText(csName1);
			if(_tcsicmp(csName1, szText) == 0){
				AcDbObjectId id = pDim->GetVPipeId();
				idArray.append(id);
				ssWell += ent;
				count ++;
			}
		}
		OPENOBJ_END();  
    }
    
    XPoint ptCen, ptLow, ptUp;
    double x,y,z;
    ssWell.GetExtend(ptCen, &x, &y, &z);
    ptLow = ptUp = ptCen;
    ptLow.x -= x;
    ptLow.y -= y;
    ptUp.x += x;
    ptUp.y += y;
    
    if(count < 1)
        adsout << _T("\n没有发现该编号的立管！");
    else if(count > 1){
        adsout << _T("\n发现多个重名的立管！");
        AssureInCurrentView(ptLow, ptUp);
    }
    else{
        adsout << _T("\n已经成功发现！该立管位于屏幕中心黄叉处。");
        arxZoomTo(ptCen, 100*DocGetPScale(), 100*DocGetPScale());
    }
    
    for(i=0;i<idArray.length();i++){
        AcDbObjectId idTmp = idArray[i];
		ads_name adsent;
		acdbGetAdsName(adsent, idTmp);
		Entity ent = adsent;

        XPoint ptCen;
        double nX(1), nY(1);
        ent.GetExtend(ptCen, &nX, &nY);
        double nDist = DocGetPScale()*10;
        XPoint p1, p2, p3, p4;
        ads_polar(ptCen, 0, nDist, p1);
        ads_polar(p1, PI/2, nDist, p1);
        ads_polar(ptCen, PI, nDist, p2);
        ads_polar(p2, PI/2, -nDist, p2);
        ads_grdraw(p1, p2, 2, 0); 
        ads_polar(ptCen, PI/2, nDist, p3);
        ads_polar(p3, PI, nDist, p3);
        ads_polar(ptCen, PI/2, -nDist, p4);
        ads_polar(p4, 0, nDist, p4);
        ads_grdraw(p3, p4, 2, 0); 
    }
    

}
void FindStandPipeBySerial2()
{
    TCHAR szText[256];
    
	RBList rbMask(RTDXF0, _T("ATS_PIPE"), 8, GetLayerNames(_T("管")), NULL);
    PickSet ss(SS_FREE);
    ss.Get(_T("X"), NULL, NULL, rbMask);
    long len = ss.Length();
    XStringList lstWellName, lstRepeat;
    for(long i=0;i<len;i++){
        Entity ent = ss[i];
        OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
        if(pPipe && pPipe->IsVertical()){
            CString csName = ReadXdata(ent, _T("PIPE-SERIAL"));  
			CString csLay = pPipe->GetLayer();
            CString csDim = g_csPipeDim[GetPipeLayerIdxByName(csLay)] + _T("L");
          //  TPipeSys::SysType sys = pPipe->GetSysType();
           // CString csDim = g_csPipeDim[GetPipeLayerIdxBySys(sys)] + _T("L");
            csName = csDim + _T("-") + csName;
            if(lstWellName.Index(csName, 0) < 0)
			{
                lstWellName.Append(tstrnew(csName));
			}
            else
                lstRepeat.Append(tstrnew(csName));
        }     
        OPENOBJ_END();  
    }
    
    for(int j=0;j<lstRepeat.Length();j++){
        adsout << XString(_T("\n编号为%s的立管编号有重复。"), lstRepeat[j]); 
    }
	if(ads_getstring(NULL, _T("\n请输入要搜索立管的编号<退出>:"), szText) != RTNORM)
        return;
    if(_tcsicmp(szText, _T("")) == 0)
        return;
    int count = 0;
    PickSet ssWell(SS_FREE);
    for(i=0;i<len;i++){
        Entity ent = ss[i];
        OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
        if(pPipe && pPipe->IsVertical()){
            CString csName = ReadXdata(ent, _T("PIPE-SERIAL"));  
			CString csLay = pPipe->GetLayer();
            CString csDim = g_csPipeDim[GetPipeLayerIdxByName(csLay)] + _T("L");
			
         //   TPipeSys::SysType sys = pPipe->GetSysType();
//            CString csDim = g_csPipeDim[GetPipeLayerIdxBySys(sys)] + _T("L");
            csName = csDim + _T("-") + csName;
          
            if(_tcsicmp(csName, szText) == 0){
                ssWell += ent;
                count ++;
            }
        }     
        OPENOBJ_END();  
    }
    
    XPoint ptCen, ptLow, ptUp;
    double x,y,z;
    ssWell.GetExtend(ptCen, &x, &y, &z);
    ptLow = ptUp = ptCen;
    ptLow.x -= x;
    ptLow.y -= y;
    ptUp.x += x;
    ptUp.y += y;
    
    if(count < 1)
        adsout << _T("\n没有发现该编号的立管！");
    else if(count > 1){
        adsout << _T("\n发现多个重名的立管！");
        AssureInCurrentView(ptLow, ptUp);
    }
    else{
        adsout << _T("\n已经成功发现！该立管位于屏幕中心黄叉处。");
        arxZoomTo(ptCen, 100*DocGetPScale(), 100*DocGetPScale());
    }
    
    for(i=0;i<count;i++){
        Entity ent = ssWell[i];
        OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
        if(pPipe){
            XPoint ptCen;
            double nX(1), nY(1);
            ent.GetExtend(ptCen, &nX, &nY);
            double nDist = DocGetPScale()*10;
            XPoint p1, p2, p3, p4;
            ads_polar(ptCen, 0, nDist, p1);
            ads_polar(p1, PI/2, nDist, p1);
            ads_polar(ptCen, PI, nDist, p2);
            ads_polar(p2, PI/2, -nDist, p2);
            ads_grdraw(p1, p2, 2, 0); 
            ads_polar(ptCen, PI/2, nDist, p3);
            ads_polar(p3, PI, nDist, p3);
            ads_polar(ptCen, PI/2, -nDist, p4);
            ads_polar(p4, 0, nDist, p4);
            ads_grdraw(p3, p4, 2, 0); 
        }     
        OPENOBJ_END();  
    }
    

}


// 检查立管是否共线
bool IsPtsParallel(std::map<AcDbObjectId, AcGePoint3d> &mapVPipes, AcGeVector3d &vtDir)
{
	AcGeTol tolVec;
	tolVec.setEqualVector(0.001);
	std::map<AcDbObjectId, AcGePoint3d>::iterator it;
	it = mapVPipes.begin();
	
	AcGeVector3d vtFirst, vtSecond;
	AcGePoint3d ptFirst, ptSecond, ptThird;
	ptFirst = it->second;
	ptFirst.z = 0;
	it++;
	ptSecond = it->second;
	ptSecond.z = 0;
	
	ptFirst = Wcs2Ucs(ptFirst);
	ptSecond = Wcs2Ucs(ptSecond);
	vtFirst = ptFirst - ptSecond;
	it++;

	if (!vtFirst.isParallelTo(AcGeVector3d::kXAxis, tolVec) && !vtFirst.isParallelTo(AcGeVector3d::kYAxis, tolVec))
	{
		return false;
	}
	
	vtDir = vtFirst;
	while (it != mapVPipes.end())
	{
		ptThird = it->second;
		ptThird.z = 0;
		ptThird = Wcs2Ucs(ptThird);
		vtSecond = ptSecond - ptThird;
		if (!vtFirst.isParallelTo(vtSecond, tolVec))
		{
			return false;
		}
		ptSecond = ptThird;
		it++;
	}
	return true;
}

// 对立管按照共线方向进行排序
void SortVPipes(PickSet &ssAll, AcGeVector3d &vtDir)
{
	AcGeTol tolVec;
	tolVec.setEqualVector(0.001);
	std::map<double, Entity> mapPipe;
	Entity ent;
	AcDbObjectId id;
	AcGePoint3d ptLoc;
	double dLoc = 0.0;
	std::map<AcDbObjectId, AcGePoint3d> mapVPipes;
	for (long l = 0l; l < ssAll.Length(); l++)
	{
		ent = ssAll[l];
		acdbGetObjectId(id, ent);
		OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPipe, pPipe);
		if(pPipe != NULL)
		{
			ptLoc = pPipe->GetStartPoint();
			ptLoc.z = 0;
			WCS2UCS(ptLoc);
			if (vtDir.isParallelTo(AcGeVector3d::kXAxis, tolVec))
			{
				dLoc = ptLoc.x;
			}
			else
			{
				dLoc = ptLoc.y;
			}

			if(mapPipe.find(dLoc) != mapPipe.end())
			{
				dLoc += 1;
			}
			mapPipe.insert(std::make_pair(dLoc, ent));
		}
		OPENOBJ_END();
	}
	
	ssAll.Free();
	std::map<double, Entity>::iterator it;
	for (it = mapPipe.begin(); it != mapPipe.end(); it++)
	{
		ssAll += it->second;
	}
}

bool CheckPipes(PickSet &ssAll, AcGeVector3d &vtDir)
{
	Entity ent;
	AcDbObjectId id;
	AcGePoint3d ptLoc;
	std::map<AcDbObjectId, AcGePoint3d> mapVPipes;
	long len = ssAll.Length();
	for (long l = 0l; l < ssAll.Length(); l++)
	{
		ent = ssAll[l];
		acdbGetObjectId(id, ent);
		OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPipe, pPipe);
		if(pPipe != NULL)
		{
			if (!pPipe->IsVertical())
			{
				return false;
			}
			ptLoc = pPipe->GetStartPoint();
			ptLoc.z = 0;
			mapVPipes.insert(std::make_pair(id, ptLoc));
		}
		OPENOBJ_END();
	}

	if (IsPtsParallel(mapVPipes, vtDir))
	{
		SortVPipes(ssAll, vtDir);
		return true;
	}
	vtDir = AcGeVector3d::kXAxis;
	SortVPipes(ssAll, vtDir);
	return false;
}

// zxl 2013.08.22 add
double GetMaxDimLen(const std::vector<AcDbObjectId> vecPipe, const XString sHouse, double &nLength)
{
	std::vector<AcDbObjectId>::const_iterator itPipe;
	double nLen = 0;
	for (itPipe = vecPipe.begin(); itPipe != vecPipe.end(); itPipe++)
	{
		ads_name name;
		acdbGetAdsName(name, *itPipe);
		Entity entPipe = name;
		WriteXdata(entPipe,_T("BUILDING-SERIAL"),sHouse);
		double nDnLength = 0.0;
		double nDLen = GetDimStrLen(*itPipe, nDnLength);
		if (nDLen > nLen)
		{
			nLen = nDLen;
		}

		if (nDnLength > nLength)
		{
			nLength = nDnLength;
		}
	}
	return nLen;
}

// 多立管标注
void DoDimStandPipes(PickSet &ssAll, AcGeVector3d &vtDir)
{
	Entity entPipe;
	XPoint ptStart, ptEnd;
	std::vector<TDbVPipeDim *> vecDim;
	std::vector<AcDbObjectId> vecPipe;
	XString sHouse;
	XString sTmp;
	for (long l = 0l; l < ssAll.Length(); l++)
	{
		entPipe = ssAll[l];
		CString csSerial = ReadXdata(entPipe, _T("PIPE-SERIAL"));  
		CString csHouse = ReadXdata(entPipe, _T("BUILDING-SERIAL")); 
		
		CString csLay = GetPipeLayer(entPipe);
		CString csDim = g_csPipeDim[GetPipeLayerIdxByName(csLay)] + _T("L");
		
		TCHAR szName[256];
		CString csPrompt;
		csPrompt.Format(_T("请输入立管编号 %s-<%s>:"), csDim, csSerial);
		int ret = ads_getstring(0, csPrompt, szName);
		if(ret != RTNORM && ret != RTNONE)
			return;
		if(_tcsicmp(szName, _T("")) == 0)
			_tcscpy(szName, csSerial);
		
		if (l == ssAll.Length() - 1)
		{
			csPrompt.Format(_T("请输入立管所属楼号:"));
			if(csHouse != _T(""))
			{
				sTmp = csHouse;
				csPrompt.Format(_T("请输入立管所属楼号(按ESC设置为空):<%s>"), csHouse);
			}
			
			ret = ads_getstring(0, csPrompt, sHouse);
			if(ret != RTNORM && ret != RTNONE && ret != RTCAN)
				return;
			
			if(sTmp != _T("") && sHouse == _T(""))
			{
				sHouse = sTmp;
			}
			if(ret == RTCAN)
			sHouse =  _T("");
		}

// 		int idx = _ttoi(szName);
// 		if(idx < 1)
// 			return;
		AcDbObjectId id = NULL;
		acdbGetObjectId(id, entPipe);
		vecPipe.push_back(id);
		
		WriteXdata(entPipe, _T("PIPE-SERIAL"), szName);
		//WriteXdata(entPipe,_T("BUILDING-SERIAL"),sHouse);
	}

	// zxl 2013.08.22 add
	std::vector<AcDbObjectId>::iterator itPipe;
	double nMaxDimDnLen = 0.0;
	double nMaxLabelLen = 0.0;
	nMaxLabelLen = GetMaxDimLen(vecPipe, sHouse, nMaxDimDnLen);
	nMaxDimDnLen *= 1.05;
	nMaxDimDnLen += nMaxLabelLen;

	int i = 0;
	for (itPipe = vecPipe.begin(); itPipe != vecPipe.end(); itPipe++, i++)
	{
		AcDbObjectId id = *itPipe;
		ads_name name;
		acdbGetAdsName(name, id);
		entPipe = name;
		WriteXdata(entPipe,_T("BUILDING-SERIAL"),sHouse);

		CString csLay = GetPipeLayer(entPipe);
		CString csDim = g_csPipeDim[GetPipeLayerIdxByName(csLay)] + _T("L");

		DocSetMultiLeaderDistRatio(0.2); //设置文字距线端距离（全局）
		XPoint ptPick1, ptPick2;
		TCHAR szLayer[256];
		double nDn;
		CString csDimHead;
		double dRadius(0);
		CString sPipeLayer;
		OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPipe, pPipe);
		if(pPipe)
		{
			dRadius = pPipe->GetRadius()*pPipe->GetPScale();
			TCHAR *layer;
			layer = pPipe->layer();
			_tcscpy(szLayer, layer);
			csDimHead = pPipe->GetLabel();
			sPipeLayer = layer;
			delete [] layer;
			
			if(csDimHead == "")
			{
				int iMaterial = pPipe->GetMaterial();
				CString csMat = GetPipeMaterialByIdx(iMaterial);
				csDimHead = GetDnByMat(csMat);
			}
			nDn = pPipe->GetDnDiameter();
			csDimHead.Format(_T("%s%.0f"), csDimHead, nDn);
			
			ptPick1 = pPipe->StartPoint();
			ptPick1.z = 0;
			if (i == 0)
			{
				ptStart = ptPick1;
			}
			else if (i == vecPipe.size() - 1)
			{
				ptEnd = ptPick1;
			}
			csLay = GetDimLayBySys(pPipe->GetSysType());
		}
		OPENOBJ_END();
		InitLayer(csLay);

		if(!g_bIsPipeDimCir)
			csDim += _T("-");
		
		int nFind = csDim.Find(_T("-"),0);
		if (nFind != -1)
			csDim = csDim.Left(nFind);
		AcDbObjectId idTextStyle = InitTwtTextStyle(g_csVPipeStyle);
		if(!idTextStyle)
			return;	
		
		TDbVPipeDim *pDim = new TDbVPipeDim;
		pDim->SetDimRadius(g_nDimCirDiam);
		pDim->SetDimType(g_bIsPipeDimCir);
	//  cet 2012.8.27 modify 无论当前设置是否是标注4样式都需设置此值，以便编辑标注更改为样式4时，显示正确
	//	if (g_bIsPipeDimCir == TVPipeDim::eDimType4)
		{
			pDim->SetShowDnForDimType4(IsShowVPipeDimDn(sPipeLayer) ? true : false);
			pDim->SetAlignTypeForDimType4(g_nAlignTypeForVPipeDim4);
		}
		pDim->SetDimTypeText(csDim);
		pDim->SetTextHeight(g_nVPipeHeight);
		pDim->SetTextStyleId(idTextStyle);
		pDim->SetText2BaseRatio(g_nDimCirDiam);
		
		pDim->SetVtDir(AcGeVector3d::kXAxis);
		pDim->SetStartPt(ptPick1);	
		pDim->SetTextLayerId(InitLayer(LAY_TEXT));
		pDim->setLayer(csLay);
		pDim->SetLayoutRotation(Ucs2Wcs(0.0));
		pDim->SetVPipeFloorType(g_iVPipeDimStyle);
		// zxl 2013.08.22 add
		double dDst = nMaxLabelLen + g_dVPipeDimDn2Label * DocGetPScale();
		CString sDst;
		sDst.Format(_T("%.1f"), dDst);
		dDst = _tstof(sDst);
		pDim->SetDnDistance2LabelLoc(dDst);
		pDim->SetTextBaseLineLen(nMaxDimDnLen / DocGetPScale() + g_dVPipeDimDn2Label);
		pDim->SetDnDistBetweenLabel(g_dVPipeDimDn2Label);
		
		pDim->SetVPipeId(id);
		vecDim.push_back(pDim);
	}

	TMultVPipeDimJig jig(vecDim, ptEnd, vtDir);
 	XPoint ptTurn;

	jig.SetStartPt(ptStart);
	if(jig.DoIt() != RTNORM)
	{
		return;
	}
	AcGeVector3d vtDimDir;
	vtDimDir = jig.GetDimDir();
	std::vector<TDbVPipeDim *>::iterator it;
	for (it = vecDim.begin(); it != vecDim.end(); it++)
	{
		TDbVPipeDim *pDim = NULL;
		pDim = *it;
		if (pDim != NULL)
		{
			pDim->SetVtDir(vtDimDir);
			AddToCurrentSpace(pDim,Adesk::kTrue);
		}
	}
}

// 用户单选标注立管
bool GetSelPipe(PickSet &ss, Entity &entPipe)
{
	long len = ss.Length();
	XPoint ptCen;
	for (long l = 0l; l < ss.Length(); l++)
	{
		entPipe = ss[l];
		AcDbObjectId id;
		acdbGetObjectId(id, entPipe);
		OPENOBJ_BEGIN(id, AcDb::kForWrite, TDbPipe, pPipe);
		if(pPipe != NULL)
		{
			if (!pPipe->IsVertical())
			{
				continue;
			}
			ptCen = pPipe->GetStartPoint();
			ptCen.z = 0;
			arxZoomTo(ptCen, 10*DocGetPScale(), 10*DocGetPScale());
		}
		OPENOBJ_END();

		ads_name adsent;
		acdbGetAdsName(adsent, id);
		Entity ent = adsent;
		
        double nX(1), nY(1);
        ent.GetExtend(ptCen, &nX, &nY);
        double nDist = DocGetPScale()*0.5;
        XPoint p1, p2, p3, p4;
		WCS2UCS(ptCen);
        ads_polar(ptCen, 0, nDist, p1);
        ads_polar(p1, PI/2, nDist, p1);
        ads_polar(ptCen, PI, nDist, p2);
        ads_polar(p2, PI/2, -nDist, p2);
        ads_grdraw(p1, p2, 2, 0); 
        ads_polar(ptCen, PI/2, nDist, p3);
        ads_polar(p3, PI, nDist, p3);
        ads_polar(ptCen, PI/2, -nDist, p4);
        ads_polar(p4, 0, nDist, p4);
        ads_grdraw(p3, p4, 2, 0);
		
		CString sNote = _T("\n是否为该对象?[是(Y)/否(N)]<Y>:");
		TCHAR szText[256];
		int nStatus = 0;
		INITGET_BEG(0, _T("N Y"));
		nStatus = acedGetString(0, sNote, szText);
		INITGET_END();
		if (nStatus == RTNORM)
		{
			if (szText[0] == _T('y') || szText[0] == _T('Y') || szText[0] == _T('\0'))
			{
				return true;
			}
		}
		else
		{
			return false;
		}
		
		if (l == ss.Length() - 1)
		{
			FindStandPipeBySerial();
			return false;
		}
	}
	return false;
}

void StandPipeDimCmd()
{
	Entity entPipe;
	RBList rbMask(RTDXF0, _T("ATS_PIPE"), 8, GetLayerNames(_T("管")), NULL);
	
	// zxl 2012.07.04 modify
// 	if(SelectEntity(_T("\n请选择要标注的立管:<搜索立管>"), entPipe, rbMask) != RTNORM){
//         FindStandPipeBySerial();
//         return;
//     }
	PickSet ss(SS_FREE);
	int iIndex = SelectEntities(_T("\n请选择要标注的立管:<搜索立管>"), ss, rbMask);
	if (iIndex != RTNORM)
	{
		if (iIndex == RTCAN)
		{
			return;
		}
		FindStandPipeBySerial();
		return;
	}
	// 立管共线
	long len = ss.Length();
	AcGeVector3d vtDir;
	if (ss.Length() > 1 && CheckPipes(ss, vtDir) && g_bIsPipeDimCir != TVPipeDim::eDimType2)
	{
		DoDimStandPipes(ss, vtDir);
		return;
	}
	len = ss.Length();
	if (len > 1)
	{
		if (!GetSelPipe(ss, entPipe))
		{
			return;
		}
	}
	else
	{
		entPipe = ss[0l];
	}
	
    CString csSerial = ReadXdata(entPipe, _T("PIPE-SERIAL"));  
    CString csHouse = ReadXdata(entPipe, _T("BUILDING-SERIAL"));  
 

	CString csLay = GetPipeLayer(entPipe);
	CString csDim = g_csPipeDim[GetPipeLayerIdxByName(csLay)] + _T("L");
	
    //TPipeSys::SysType sys = GetPipeSys(entPipe);
    //CString csDim = g_csPipeDim[GetPipeLayerIdxBySys(sys)] + _T("L");
	TCHAR szName[256];
    CString csPrompt;
	csPrompt.Format(_T("请输入立管编号 %s-<%s>:"), csDim, csSerial);
	int ret = ads_getstring(0, csPrompt, szName);
	if(ret != RTNORM && ret != RTNONE)
		return;
    if(_tcsicmp(szName, _T("")) == 0)
		_tcscpy(szName, csSerial);

	XString sHouse;
	XString sTmp;

//	TCHAR szHouse[200];
	csPrompt.Format(_T("请输入立管所属楼号:"));
	if(csHouse != _T(""))
	{
		sTmp = csHouse;
		csPrompt.Format(_T("请输入立管所属楼号(按ESC设置为空):<%s>"), csHouse);
	}
//	if(s_sHouse != _T(""))
//	{
//		sTmp = s_sHouse;
//		csPrompt.Format(_T("请输入立管所属楼号:<%s>"), s_sHouse);
//	}
	ret = ads_getstring(0, csPrompt, sHouse);
	if(ret != RTNORM && ret != RTNONE && ret != RTCAN)
		return;
	
	if(sTmp != _T("") && sHouse == _T(""))
	{
		sHouse = sTmp;
	}
	if(ret == RTCAN)
		sHouse =  _T("");
	
	
// 	int idx = _ttoi(szName);	//zxl 2012.08.20 del
// 	if(idx < 1)		
// 		return;
	AcDbObjectId id = NULL;
	acdbGetObjectId(id, entPipe);
	
    if(!g_bIsPipeDimCir)
        csDim += _T("-");
	
	WriteXdata(entPipe, _T("PIPE-SERIAL"), szName);
//	if(_tcsicmp(szHouse, _T("")) != 0)
		WriteXdata(entPipe,_T("BUILDING-SERIAL"),sHouse);
	//得到所有的立管标注
	bool bIsDim = false;
	PickSet ssAll(SS_FREE);
	RBList rbMaskVPipe(RTDXF0, _T("ATS_VPIPEDIM"),NULL);
	ssAll.Get(_T("A"),NULL,NULL,rbMaskVPipe);
	long lLen = ssAll.Length();
	Entity entT;
	for (long i = 0; i < lLen; ++i)
	{
		OPENOBJ_BEGIN(ssAll[i], AcDb::kForRead, TDbVPipeDim, pDim);
		if (pDim != NULL)
		{
			AcDbObjectId idDim = pDim->GetVPipeId();
			if (idDim == id)
			{
				pDim->upgradeOpen();
				pDim->RenewDimLen();
				pDim->SaveCurText();
				pDim->downgradeOpen();
				entT = ssAll[i];
				bIsDim = true;
				break;
			}
		}
		OPENOBJ_END();
	}

	if (!bIsDim)
	{
		//标注立管
		DoDimStandPipe(id, csDim, szName);
	}
	else
	{
		PickSet ssReNew(SS_FREE);
		ssReNew += entT;
		UpdateGraphic(ssReNew);
	}

	
	XPoint pt1,pt2;
	TCHAR szLay[256];
	entPipe.GetData(8, szLay);
	Entity entSame = CheckSameSerialPipe(szLay, szName, entPipe);
	if(!!entSame){
		adsout << _T("\n注意：有一个同编号的立管！请用【标注立管】修改编号，以保证标注与立管信息一致。");
		GetPipePoint(entSame, pt1, pt2);
		pt1.z = 0;
		DrawRedFork(pt1);
	}
}

/*
void StandPipeDimCmd2()
{
	Entity entPipe;
	RBList rbMask(RTDXF0, _T("ATS_PIPE"), 8, GetLayerNames(_T("管")), NULL);
	
	if(SelectEntity(_T("\n请选择要标注的立管:<搜索立管>"), entPipe, rbMask) != RTNORM){
        FindStandPipeBySerial();
        return;
    }

    CString csSerial = ReadXdata(entPipe, _T("PIPE-SERIAL"));        
	CString csLay = GetPipeLayer(entPipe);
	CString csDim = g_csPipeDim[GetPipeLayerIdxByName(csLay)] + _T("L");
	
    //TPipeSys::SysType sys = GetPipeSys(entPipe);
    //CString csDim = g_csPipeDim[GetPipeLayerIdxBySys(sys)] + _T("L");
	TCHAR szName[256];
    CString csPrompt;
	csPrompt.Format(_T("请输入立管编号 %s-<%s>:"), csDim, csSerial);
	int ret = ads_getstring(0, csPrompt, szName);
	if(ret != RTNORM && ret != RTNONE)
		return;
    if(_tcsicmp(szName, _T("")) == 0)
		_tcscpy(szName, csSerial);
	int idx = _ttoi(szName);
	if(idx < 1)
		return;
	AcDbObjectId id = NULL;
	acdbGetObjectId(id, entPipe);

    if(!g_bIsPipeDimCir)
        csDim += _T("-");

	XPoint pt1, pt2;
	GetPipePoint(entPipe, pt1, pt2);
	pt1.z = 0;
 
	XPoint ptUcs = Wcs2Ucs(pt1);
	Entity entDim = GetPipeDimByPt(ptUcs, _ttoi(csSerial));
	if(!!entDim){
		if(g_bIsPipeDimCir){
			OPENOBJ_BEGIN(entDim, AcDb::kForWrite, TDbSymbDrawingIndex, pDim);
			if(pDim){
				pDim->SetIndexLabel(szName);
			}
			OPENOBJ_END();
		}
		else{
			OPENOBJ_BEGIN(entDim, AcDb::kForRead, TDbSymbComposing, pDim);
			if(pDim){
                CString csTmp = pDim->GetText();
                int idx = csTmp.Find(_T("-"));
                csTmp = csTmp.Right(csTmp.GetLength() - idx-1);
                if(csTmp == csSerial){
                    if(pDim->upgradeOpen()==Acad::eOk){
                        csDim += szName;
                        pDim->SetText(csDim);
                        pDim->downgradeOpen();
                    }
                }
                else
                    DoDimStandPipe(id, csDim, szName);
			}
			OPENOBJ_END();
		}
	}
	else
		DoDimStandPipe(id, csDim, szName);
	
	WriteXdata(entPipe, _T("PIPE-SERIAL"), szName);

    PickSet ss(SS_FREE);
    GetAllVertPipeByPt(ss, id);
    long len = ss.Length();
	for(long i=0;i<len;i++){
		Entity entTmp = ss[i];
		WriteXdata(entTmp, _T("PIPE-SERIAL"), szName);
	}

	TCHAR szLay[256];
	entPipe.GetData(8, szLay);
	Entity entSame = CheckSameSerialPipe(szLay, idx, entPipe);
	if(!!entSame){
		adsout << _T("\n注意：有一个同编号的立管！请用【标注立管】修改编号，以保证标注与立管信息一致。");
		GetPipePoint(entSame, pt1, pt2);
		pt1.z = 0;
		DrawRedFork(pt1);
	}

}
*/

//***************************************************************************************************
//                                        管线文字
//***************************************************************************************************

void TextOnPipe()
{
	RBList rbMask(RTDXF0, _T("ATS_PIPE"), 8, GetLayerNames(_T("管线")), NULL);
	Entity entSel;
	XPoint ptPick;
	TCHAR szText[256];
	BOOL bAuto = FALSE;
	if(ads_getstring(0, _T("\n请输入文字内容<自动读取>: "), szText) != RTNORM)
		return;
	CString csText;
	csText = szText;
	if(csText == _T(""))
		bAuto = TRUE;
   // csText.MakeUpper();
 
	AcDbObjectId idTextStyle = InitTwtTextStyle(g_csPipeTextStyle);	
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////
    XText text(_T(""), XPoint(), g_nTwtDimHeight * DocGetPScale(), g_nDimScale, g_csPipeTextStyle, _T("0"));
    text.Draw(AcDb::kTextBase, AcDb::kTextRight);
    Entity ent;
    ent.GetLast();
    ent.Erase();
    //写1个字，然后删除，很弱智。TDbPipeText::GetWidth()第一次执行时AcGiTextStyle计算外框用的是STANDARD样式 
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    
	while(1){
        int ret(0);
	 
        INITGET_BEG(0, _T("M N T F"));
		ret = SelectEntity1(g_nCurPipeWidth*DocGetPScale()/2.0, _T("\n请点取要插入文字管线的位置[多选管线(M)/多选指定层管线(N)/两点栏选(T)/修改文字(F)] <退出>:"), entSel, ptPick, rbMask);
        INITGET_END();
        if(ret == RTKWORD){
            XString sKeyword;
            ads_getinput(sKeyword);
            TCHAR cKey = sKeyword[0];
            if(cKey==_T('M') || cKey==_T('N')){
                PickSet ss(SS_FREE);
				if(cKey==_T('M')){
					if(SelectEntities(_T("\n请选择所有要标注的管线<退出>:"), ss, rbMask) != RTNORM)
						break;
				}
				else{
					Entity entTmp;
					if(SelectEntity(_T("\n请选择要标注的其中一根管线<退出>:"), entTmp, rbMask) != RTNORM)
						break;
					char szLay[256];
					entTmp.GetData(8, szLay);
					RBList rbMask2(RTDXF0, _T("ATS_PIPE"), 8, szLay, NULL);
					if(SelectEntities(_T("\n请选择要标注的管线的范围<退出>:"), ss, rbMask2) != RTNORM)
						break;
				}

                double nDist(5000);
				ads_getreal(_T("\n请输入文字最小间距:<5000>"), &nDist);
                if(nDist < 1)
                    nDist = 5000;
                for(long i=0;i<ss.Length();i++){
                    Entity ent = ss[i];
                    if(bAuto){
                        TCHAR szLayer[256];
                        ent.GetData(8, szLayer);
                        int idx = GetPipeLayerIdxByName(szLayer);
                        if(idx < 0)
                            csText = _T("NO");
                        else
                            csText = g_csPipeDim[idx];
                    }
                    XPointList lstPt, lstNode;
					TPipeSys::SysType sysType;
                    OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
                    if(pPipe){
						if(pPipe->IsVertical()) //立管不标注
							continue;
						sysType = pPipe->GetSysType();
                        DList<AcDbObjectId> lstAttachment;
                        pPipe->GetAttachments(lstAttachment);
                        int leng = lstAttachment.Length();
                        for(int m=0;m<leng;m++){
                            AcDbObjectId idTmp = *lstAttachment[m];
                            OPENOBJ_BEGIN(idTmp, AcDb::kForRead, TDbPipeAttachment, pAttach);
                            if(pAttach){
                                XPoint ptNode = pAttach->GetLocation();
                                lstNode.NewAppend(ptNode);
                            }
                            OPENOBJ_END();
                        }
                    }
                    OPENOBJ_END();
                     
                    XPoint p1, p2;
                    GetPipePoint(ent, p1, p2);
                    XLine line(p1, p2, 1);
                    if(line.GetLength() < nDist)        //太短，无法标注
                        continue;
                    int num = int(line.GetLength()/nDist);
                    XCurveSegment seg;
                    seg = line;
                    GetPointList(seg, num, lstPt);
					CString csLay = GetTextLayBySys(sysType);
					InitLayer(csLay);

                    for(int j=0;j<num;j++){
                        BOOL flag = FALSE;
                        XPoint ptTmp = *lstPt[j];
                        for(int m=0;m<lstNode.Length();m++){
                            XPoint ptTmpNode = *lstNode[m];
                            if(ptTmp.Distance(ptTmpNode) < g_nBreakPipeWidth*DocGetPScale()*1.5){
                                flag = TRUE;
                                break;
                            }
                        }
                        if(flag)
                            continue;
                        TDbPipeText *pText = new TDbPipeText();
                        pText->SetTextStyleId(idTextStyle);
                        pText->SetLocation(ptTmp);
                        pText->SetTextHeight(g_nPipeTextHeight);
                        pText->setLayer(csLay);
                        pText->setColor(AcCmColor()); //随层
                        pText->SetText((const TCHAR*)csText);
                        AddToCurrentSpace(pText, Adesk::kTrue);
                    }
                }
                return;
            }
            if(cKey==_T('T')){
                XPushVar<int> vOrthoMode(_T("ORTHOMODE"), 1); //f8
                while(1){
                    adsout<<_T("\n多管文字标注，与管线相交出进行标注：");
                    XPoint ptStartPick,ptEndPick;
                    if(ads_getpoint(NULL, _T("\n起点："), ptStartPick) != RTNORM)
                        return; 
                    if(ads_getpoint(ptStartPick, _T("\n终点："), ptEndPick) != RTNORM)
                        return;

                    struct resbuf *pointlist;
                    PickSet ss(SS_FREE);
                    pointlist = ads_buildlist(RTPOINT, &ptStartPick, RTPOINT, &ptEndPick, NULL); 
                    ss.Get(_T("F"), pointlist, NULL, RBList(RTDXF0, _T("ATS_PIPE"), 0));
                    ads_relrb(pointlist);
                    if(ss.Length() < 1)
                        return;
                    ptStartPick = Ucs2Wcs(ptStartPick);
                    ptEndPick = Ucs2Wcs(ptEndPick);
                    XLine line1(ptStartPick, ptEndPick, 1);
                    for(long i=0;i<ss.Length();i++){
                        Entity ent = ss[i];
                        XPoint ptPipeS, ptPipeE, ptInt;
                        GetPipePoint(ent, ptPipeS, ptPipeE);
                        if(bAuto){
                            TCHAR szLayer[256];
                            ent.GetData(8, szLayer);
                            int idx = GetPipeLayerIdxByName(szLayer);
                            if(idx < 0)
                                csText = _T("NO");
                            else
                                csText = g_csPipeDim[idx];
                        }
                      
                        XLine line2(ptPipeS, ptPipeE, 1);
                        line2.StartPoint().z = 0;
                        line2.EndPoint().z = 0;
						CString csLay = GetPipeTextLayByEnt(ent);
						InitLayer(csLay);

                        int ret = line1.Intersection(&line2, ptInt);
                        if(!!ptInt){
                            ptInt.z = ptPipeS.z;
                            TDbPipeText *pText = new TDbPipeText();
                            pText->SetTextStyleId(idTextStyle);
                            pText->SetLocation(ptInt);
                            pText->SetTextHeight(g_nPipeTextHeight);
                            pText->setLayer(csLay);
                            pText->setColor(AcCmColor()); //随层
                            pText->SetText((const TCHAR*)csText);
                            AddToCurrentSpace(pText, Adesk::kTrue);
                        }
                    }
                    TPipePerDocData *pData = GetCurPipeDocData();
                    pData->ApplyUpdates();
                }
            }
            else if(cKey==_T('F')){
                if(bAuto){
					if(ads_getstring(0, _T("\n请输入新的标注内容<退出>: "), szText) != RTNORM)
                        return;
                    if(_tcsicmp(szText, _T("")) == 0)
                        return;
                    csText = szText;
                  //  csText.MakeUpper();
                }            
                Entity ent;
				if(SelectEntity(_T("\n请选择系统上其中一根管线<退出>:"), ent, rbMask) != RTNORM)
                    return;
                AcDbObjectId idPipe;
                acdbGetObjectId(idPipe, ent);
                TPipeGraph PipeGraph;
                SearchOneselfPipe(idPipe, PipeGraph);
                int len = PipeGraph.m_lstEdge.Length();
              
                for(int i=0;i<len;i++){
                    AcDbObjectId idTmp = PipeGraph.m_lstEdge[i]->m_idPipe;
                    OPENOBJ_BEGIN(idTmp, AcDb::kForRead, TDbPipe, pPipe);
                    if(pPipe){
                        double dDn = pPipe->GetDnDiameter();
                        CString csDn;
                        csDn.Format(_T("%.0f"), dDn);
                        DList<AcDbObjectId> lstAttachment;
                        pPipe->GetAttachments(lstAttachment);
                        int leng = lstAttachment.Length();
                        for(int m=0;m<leng;m++){
                            AcDbObjectId idTmp = *lstAttachment[m];
                            OPENOBJ_BEGIN(idTmp, AcDb::kForWrite, TDbPipeText, pLabel);
                            if(pLabel){
                                CString csText2 = pLabel->GetText();
                                if(csText2.Find(csDn) < 0)
                                    pLabel->SetText((const TCHAR*)csText);
                            }
                            OPENOBJ_END();
                        }
                    }
                    OPENOBJ_END();
                }
                return;
                
                
            }
            TPipePerDocData *pData = GetCurPipeDocData();
            pData->ApplyUpdates();
            
        }
        else if(ret != RTNORM)
            break;
		if(bAuto){
			TCHAR szLayer[256];
			entSel.GetData(8, szLayer);
			int idx = GetPipeLayerIdxByName(szLayer);
			if(idx < 0)
				csText = _T("NO");
			else
				csText = g_csPipeDim[idx];
		}
        ptPick = Ucs2Wcs(ptPick);
		
		if(!IsPtOnPipe(ptPick, entSel))
			continue;
		CString csLay = GetPipeTextLayByEnt(entSel);
		InitLayer(csLay);
								
		TDbPipeText *pText = new TDbPipeText();
		pText->SetTextStyleId(idTextStyle);
		pText->SetLocation(ptPick);
		pText->SetTextHeight(g_nPipeTextHeight);
		pText->setLayer(csLay);
        pText->setColor(AcCmColor()); //随层
		pText->SetText((const TCHAR*)csText);
		AddToCurrentSpace(pText, Adesk::kTrue);
        TPipePerDocData *pData = GetCurPipeDocData();
        pData->ApplyUpdates();
	}
}

//***************************************************************************************************
//                                        喷头尺寸
//***************************************************************************************************

BOOL IsOnLine(XPoint p1, XPoint p2, XPoint p3)
{
	AcGeVector3d vt1(p1 - p2);
	AcGeVector3d vt2(p2 - p3);
	if(vt1.isParallelTo(vt2))
		return TRUE;
	else
		return FALSE;
}
//////////////////////////////////////////////////////////////////////////////////

// cet 2010.12.3 add 点是否存在于data中
bool IsPtExist(XPoint &pt, std::vector<std::vector<XPoint> > &data)
{
	std::vector<std::vector<XPoint> >::iterator it;
	for (it = data.begin(); it != data.end(); it++)
	{
		if (std::find((*it).begin(), (*it).end(), pt) != (*it).end())
		{
			return true;
		}
	}
	return false;
}

// cet 2010.12.3 add
// 当点不共线也不共圆时 调整点使所有点在同一直线上(该直线是所有点中共线点最多的点所在直线) 
// 前提条件所有喷头交度相同，根据喷头插入点与角度做两条直线，一条直线与喷头方向平行，
// 另一条与喷头方向垂直，根据这两条直线寻找共线点
void AdjustPtsToLine(XPointList &lstPt, double dAngle)
{
	dAngle = Ucs2Wcs(dAngle);
	AcGeVector3d vt = AcGeVector3d::kXAxis;
	vt.rotateBy(Ucs2Wcs(0.0), AcGeVector3d::kZAxis);
	vt.rotateBy(dAngle, AcGeVector3d::kZAxis); 
	AcGeVector3d vtDir = vt;
	vtDir.rotateBy(-PI/2, AcGeVector3d::kZAxis); 

	std::vector<std::vector<XPoint> > data1, data2;
	for (int i = 0; i < lstPt.Length(); i++) // 获得共线点
	{
		XPoint pt = *lstPt[i];
		AcDbLine line1(pt, pt + vt), line2(pt, pt + vtDir);
		std::vector<XPoint> vec1, vec2;
		vec1.push_back(pt);
		vec2.push_back(pt);

		bool bExist1 = false, bExist2 = false; 
		if (IsPtExist(pt, data1))
		{
			bExist1 = true;
		} 

		if (IsPtExist(pt, data2))
		{
			bExist2 = true;
		}

		if (bExist1 && bExist2)
		{
			continue;
		}

		for (int j = i + 1; j < lstPt.Length(); j++)
		{
			XPoint ptTemp;
			if (!bExist1)
			{
				line1.getClosestPointTo(*lstPt[j], ptTemp, Adesk::kTrue);
				double d = ptTemp.Distance(*lstPt[j]);
				if (ptTemp.Distance(*lstPt[j]) < 1e-2)
				{
					vec1.push_back(*lstPt[j]);
				}
			}

			if (!bExist2)
			{
				line2.getClosestPointTo(*lstPt[j], ptTemp, Adesk::kTrue);
				double d = ptTemp.Distance(*lstPt[j]);
				if (ptTemp.Distance(*lstPt[j]) < 1e-2)
				{
					vec2.push_back(*lstPt[j]);
				}
			}
		}

		if (vec1.size() > 1)
		{
			data1.push_back(vec1);
		}

		if (vec2.size() > 1)
		{
			data2.push_back(vec2);
		}
	}

	std::vector<std::vector<XPoint> >::iterator it;
	for (it = data2.begin(); it != data2.end(); it++)
	{
		data1.push_back(*it);
	}
	
	std::vector<XPoint> vec;
	for (it = data1.begin(); it != data1.end(); it++)
	{
		if (vec.size() < (*it).size())
		{
			vec = *it;
		}
	}

	XPointList lstPt2;
	if (vec.size() > 0) // 存在共线点
	{
		AcDbLine line(vec[0], vec[1]);
		std::vector<XPoint>::iterator it;
		for (it = vec.begin(); it != vec.end(); it++)
		{
			lstPt2.Append(new XPoint(*it));
		}

		for (int i = 0; i < lstPt.Length(); i++)
		{
			XPoint pt = *lstPt[i];
			if (std::find(vec.begin(), vec.end(), pt) == vec.end())
			{
				XPoint ptTemp;
				line.getClosestPointTo(pt, ptTemp, Adesk::kTrue);
				vec.push_back(ptTemp);
				lstPt2.Append(new XPoint(ptTemp));
			}
		}
		lstPt.Reset();
		lstPt.copyFrom(lstPt2);
	}
}


void ModifyLstPts(XPointList &lstPts, CSprinklerDimDlg &dlg, bool bIsLine)
{
	// 不标注距墙距离
	if (dlg.m_nDim == 0 || lstPts.Length() < 2)
	{
		return;
	}

	XPoint ptS, ptE, ptOnLine;
	double dAngle = 0.0;
//	if (bIsLine)
	{
		ptS = *lstPts[0];
		ptE = *lstPts[1];
		for (int i = 2; i < lstPts.Length(); i++)
		{
			XPoint pt = *lstPts[i];
			double dLen = ptS.Distance2d(ptE);
			double dDstS = pt.Distance2d(ptS);
			double dDstE = pt.Distance2d(ptE);
			if (dDstE - dLen > 0.001)
			{
				ptOnLine = ptS;
				ptS = pt;
			}
			else if (dDstS - dLen > 0.001)
			{
				ptOnLine = ptE;
				ptE = pt;
			}
			else
			{
				ptOnLine = pt;
			}
		}
	}
	if (!bIsLine)
	{
		XArc arc(ptS, ptOnLine, ptE);
		dAngle = arc.Bulge();
		if(fabs(dAngle) > (2*PI-0.001))
		{
			dAngle -= 2*PI;
		}
	}

	if (dlg.m_nDimType == 0)// 距墙体
	{
		XPoint ptOnWall1, ptOnWall2;
		RBList rbMask(RTDXF0, _T("ATS_WALL"), NULL);
		PickSet ss(SS_FREE);
		double dDst = _tstof(dlg.m_sDst);
		if (!DocGetMeterUnitDraw())
		{
			dDst *= 1000;
		}

		GetPointPickSet(Wcs2Ucs(ptS), ss, rbMask, dDst);
		double dMinLen = 0.0;
		for (long l = 0; l < ss.Length(); l++)
		{
			Entity ent = ss[l];
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbWall, pWall);
			if (pWall != NULL)
			{
				XPoint pt;
				XCurveSegment lineWall;
				XCurveSegment lCurve, rCurve;
				pWall->GetSideCurve(lCurve, rCurve);
				if (lCurve.GetDist2Me(ptS) * rCurve.GetDist2Me(ptS) < 0.001) //点在墙内
				{
					continue;
				}

				if (fabs(lCurve.GetDist2Me(ptS)) - fabs(rCurve.GetDist2Me(ptS)) > 0.001)
				{
					lineWall = rCurve;
				}
				else
				{
					lineWall = lCurve;
				}

				if (dAngle < 0.001)
				{
					XLine line(ptS, ptE);
					XPoint pt1, pt2;
					lineWall.Intersection(line,pt1, pt2);
					pt = GetNearPt(ptS, pt1, pt2);
				}
				else
				{
					XArc line(ptS, ptOnLine, ptE);
					AcGePoint3dArray arPt;
					double dRadius = line.GetRadius();
					double dStartAngle = line.GetStarAngle();
					double dEndAngle = line.GetEndAngle();
					AcGePoint3d ptCenter = line.GetCenterPt();
					AcDbArc arc(ptCenter, dRadius, dStartAngle, dEndAngle);
					if (lineWall.GetBulge() > 0.0)
					{
						XArc line2(lineWall.StartPoint(), lineWall.MidPoint(), lineWall.EndPoint());
						dRadius = line2.GetRadius();
						dStartAngle = line2.GetStarAngle();
						dEndAngle = line2.GetEndAngle();
						ptCenter = line2.GetCenterPt();
						AcDbArc arc2(ptCenter, dRadius, dStartAngle, dEndAngle);
						arc.intersectWith(&arc2, AcDb::kExtendBoth, arPt);
					}
					else
					{
						AcDbLine line2;
						line2.setStartPoint(lineWall.GetStartPoint());
						line2.setEndPoint(lineWall.GetEndPoint());
						arc.intersectWith(&line2, AcDb::kExtendBoth, arPt);
					}

					if (arPt.length() > 0)
					{
						GetNearestPoint(arPt, ptS, pt);
					}
				}
				
				if (pt.Distance2d(ptE) - ptS.Distance2d(ptE) > 0.001 && pt.Distance2d(ptS) < dDst)
				{
					if (!ptOnWall1)
					{
						ptOnWall1 = pt;
						dMinLen = pt.Distance2d(ptS);
					}
					else if (pt.Distance2d(ptS) - dMinLen < 0.001)
					{
						ptOnWall1 = pt;
						dMinLen = pt.Distance2d(ptS);
					}
				}
			}
			OPENOBJ_END();
		}
		if (!!ptOnWall1)
		{
			lstPts.NewAppend(ptOnWall1);
		}

		ss.Free();
		GetPointPickSet(Wcs2Ucs(ptE), ss, rbMask, dDst);
		dMinLen = 0.0;
		for (long l = 0; l < ss.Length(); l++)
		{
			Entity ent = ss[l];
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbWall, pWall);
			if (pWall != NULL)
			{
				XPoint pt;
				XCurveSegment lineWall;
				XCurveSegment lCurve, rCurve;
				pWall->GetSideCurve(lCurve, rCurve);
				if (lCurve.GetDist2Me(ptE) * rCurve.GetDist2Me(ptE) < 0.001) //点在墙内
				{
					continue;
				}

				if (fabs(lCurve.GetDist2Me(ptE)) - fabs(rCurve.GetDist2Me(ptE)) > 0.001)
				{
					lineWall = rCurve;
				}
				else
				{
					lineWall = lCurve;
				}
				if (dAngle < 0.001)
				{
					XLine line(ptS, ptE);
					XPoint pt1, pt2;
					lineWall.Intersection(line,pt1, pt2);
					pt = GetNearPt(ptE, pt1, pt2);
				}
				else
				{
					XArc line(ptS, ptOnLine, ptE);
					AcGePoint3dArray arPt;
					double dRadius = line.GetRadius();
					double dStartAngle = line.GetStarAngle();
					double dEndAngle = line.GetEndAngle();
					AcGePoint3d ptCenter = line.GetCenterPt();
					AcDbArc arc(ptCenter, dRadius, dStartAngle, dEndAngle);
					if (lineWall.GetBulge() > 0.0)
					{
						XArc line2(lineWall.StartPoint(), lineWall.MidPoint(), lineWall.EndPoint());
						dRadius = line2.GetRadius();
						dStartAngle = line2.GetStarAngle();
						dEndAngle = line2.GetEndAngle();
						ptCenter = line2.GetCenterPt();
						AcDbArc arc2(ptCenter, dRadius, dStartAngle, dEndAngle);
						arc.intersectWith(&arc2, AcDb::kExtendBoth, arPt);
					}
					else
					{
						AcDbLine line2;
						line2.setStartPoint(lineWall.GetStartPoint());
						line2.setEndPoint(lineWall.GetEndPoint());
						arc.intersectWith(&line2, AcDb::kExtendBoth, arPt);
					}

					if (arPt.length() > 0)
					{
						GetNearestPoint(arPt, ptE, pt);
					}
				}
				if (pt.Distance2d(ptS) - ptS.Distance2d(ptE) > 0.001 && pt.Distance2d(ptE) < dDst)
				{
					if (!ptOnWall2)
					{
						ptOnWall2 = pt;
						dMinLen = pt.Distance2d(ptE);
					}
					else if (pt.Distance2d(ptE) - dMinLen < 0.001)
					{
						ptOnWall2 = pt;
						dMinLen = pt.Distance2d(ptE);
					}
				}
			}
			OPENOBJ_END();
		}
		if (!!ptOnWall2)
		{
			lstPts.NewAppend(ptOnWall2);
		}
		
	}
	else// 距轴线
	{
		XPoint ptOnWall1, ptOnWall2;
		RBList rbMask = ads_buildlist(RTDXF0, _T("LINE,ARC"), NULL);
		PickSet ss(SS_FREE);
		double dDst = _tstof(dlg.m_sDst);
		if (!DocGetMeterUnitDraw())
		{
			dDst *= 1000;
		}

		GetPointPickSet(Wcs2Ucs(ptS), ss, rbMask, dDst);
		double dMinLen = 0.0;
		for (long l = 0; l < ss.Length(); l++)
		{
			Entity ent = ss[l];
			TCHAR szLayer[256];
			ent.GetData(8, szLayer);
			CString sLyer = szLayer;
			sLyer = sLyer.MakeUpper();
			if (sLyer.Compare(LAY_AXIS) != 0 && sLyer.Find(_T("DOTE")) < 0 && sLyer.Find(_T("轴线")) < 0) 
			{
				continue;
			}
			XPoint pt;
			XCurveSegment seg(ent);
			if (dAngle < 0.001)
			{
				XLine line(ptS, ptE);
				XPoint pt1, pt2;
				seg.Intersection(line,pt1, pt2);
				pt = GetNearPt(ptS, pt1, pt2);
			}
			else
			{
				XArc line(ptS, ptOnLine, ptE);
				AcGePoint3dArray arPt;
				double dRadius = line.GetRadius();
				double dStartAngle = line.GetStarAngle();
				double dEndAngle = line.GetEndAngle();
				AcGePoint3d ptCenter = line.GetCenterPt();
				AcDbArc arc(ptCenter, dRadius, dStartAngle, dEndAngle);
				if (seg.GetBulge() > 0.0)
				{
					XArc line2(seg.StartPoint(), seg.MidPoint(), seg.EndPoint());
					dRadius = line2.GetRadius();
					dStartAngle = line2.GetStarAngle();
					dEndAngle = line2.GetEndAngle();
					ptCenter = line2.GetCenterPt();
					AcDbArc arc2(ptCenter, dRadius, dStartAngle, dEndAngle);
					arc.intersectWith(&arc2, AcDb::kExtendBoth, arPt);
				}
				else
				{
					AcDbLine line2;
					line2.setStartPoint(seg.GetStartPoint());
					line2.setEndPoint(seg.GetEndPoint());
					arc.intersectWith(&line2, AcDb::kExtendBoth, arPt);
				}

				if (arPt.length() > 0)
				{
					GetNearestPoint(arPt, ptS, pt);
				}
			}

			if (pt.Distance2d(ptE) - ptS.Distance2d(ptE) > 0.001 && pt.Distance2d(ptS) < dDst)
			{
				if (!ptOnWall1)
				{
					ptOnWall1 = pt;
					dMinLen = pt.Distance2d(ptS);
				}
				else if (pt.Distance2d(ptS) - dMinLen < 0.001)
				{
					ptOnWall1 = pt;
					dMinLen = pt.Distance2d(ptS);
				}
			}
		}
		if (!!ptOnWall1)
		{
			lstPts.NewAppend(ptOnWall1);
		}

		ss.Free();
		GetPointPickSet(Wcs2Ucs(ptE), ss, rbMask, dDst);
		dMinLen = 0.0;
		for (long l = 0; l < ss.Length(); l++)
		{
			Entity ent = ss[l];
			TCHAR szLayer[256];
			ent.GetData(8, szLayer);
			CString sLyer = szLayer;
			sLyer = sLyer.MakeUpper();
			if (sLyer.Compare(LAY_AXIS) != 0 && sLyer.Find(_T("DOTE")) < 0 && sLyer.Find(_T("轴线")) < 0) 
			{
				continue;
			}
			XPoint pt;
			XCurveSegment seg(ent);
			if (dAngle < 0.001)
			{
				XLine line(ptS, ptE);
				XPoint pt1, pt2;
				seg.Intersection(line,pt1, pt2);
				pt = GetNearPt(ptS, pt1, pt2);
			}
			else
			{
				XArc line(ptS, ptOnLine, ptE);
				AcGePoint3dArray arPt;
				double dRadius = line.GetRadius();
				double dStartAngle = line.GetStarAngle();
				double dEndAngle = line.GetEndAngle();
				AcGePoint3d ptCenter = line.GetCenterPt();
				AcDbArc arc(ptCenter, dRadius, dStartAngle, dEndAngle);
				if (seg.GetBulge() > 0.0)
				{
					XArc line2(seg.StartPoint(), seg.MidPoint(), seg.EndPoint());
					dRadius = line2.GetRadius();
					dStartAngle = line2.GetStarAngle();
					dEndAngle = line2.GetEndAngle();
					ptCenter = line2.GetCenterPt();
					AcDbArc arc2(ptCenter, dRadius, dStartAngle, dEndAngle);
					arc.intersectWith(&arc2, AcDb::kExtendBoth, arPt);
				}
				else
				{
					AcDbLine line2;
					line2.setStartPoint(seg.GetStartPoint());
					line2.setEndPoint(seg.GetEndPoint());
					arc.intersectWith(&line2, AcDb::kExtendBoth, arPt);
				}

				if (arPt.length() > 0)
				{
					GetNearestPoint(arPt, ptE, pt);
				}
			}

			if (pt.Distance2d(ptS) - ptS.Distance2d(ptE) > 0.001 && pt.Distance2d(ptE) < dDst)
			{
				if (!ptOnWall2)
				{
					ptOnWall2 = pt;
					dMinLen = pt.Distance2d(ptE);
				}
				else if (pt.Distance2d(ptE) - dMinLen < 0.001)
				{
					ptOnWall2 = pt;
					dMinLen = pt.Distance2d(ptE);
				}
			}
		}
		if (!!ptOnWall2)
		{
			lstPts.NewAppend(ptOnWall2);
		}
	}
}

void DimSprinklerLength()
{
/*
    g_ssPickFirst.Free();
    PickSet ss(SS_FREE), ssNew(SS_FREE);
    RBList rbMask = ads_buildlist( -4, _T("<or"),
        -4, _T("<and"), RTDXF0, _T("ATS_EQUIPMENT"), 8, LAY_EQUIP_SPRINKLE, -4, _T("and>"),  
        -4, _T("<and"), RTDXF0, _T("INSERT"), 8, LAY_SANIWARE, -4, _T("and>"),  
        -4, _T("<and"), RTDXF0, _T("AEC_BLOCK_INSERT"), 8, LAY_SANIWARE, -4, _T("and>"),  
        -4, _T("or>"), NULL);
    
//    RBList rbMask(RTDXF0, _T("ATS_EQUIPMENT"), 8, LAY_EQUIP_SPRINKLE, NULL);
//  cet 2010.12.03 modify 支持不共线、不共圆的情况
// 	if(SelectEntities(_T("\n请选取喷头(所选喷头要共线或共圆)<退出>:"), ss, rbMask) != RTNORM)
//         return;
	// zxl 2014.04.14 add
	CSprinklerDimDlg dlg(acedGetAcadFrame());  
	{
		CTemporaryResourceOverride vTemp;
		dlg.Create(IDD_SPRINKLER_DIM, acedGetAcadFrame());
	}
	dlg.ShowWindow(SW_SHOW);
	acedGetAcadDwgView()->SetFocus();
	double dDist = _tstof(dlg.m_sDst);

	if(SelectEntities(_T("\n请选取喷头<退出>:"), ss, rbMask) != RTNORM)
	{
		dlg.DestroyWindow();
        return;
	}
	dlg.m_bIsSelected = true;
    for(long i=0;i<ss.Length();i++){
        Entity ent = ss[i];
        AcDbObjectId id = NULL;
        acdbGetObjectId(id, ent);
        if(IsSprinkler(id))
            ssNew += id;
    }
    XPointList lstPt;
	bool bSprikle = false; // cet 2010.12.3 add 是否为喷头
	double dAngle = 0.0;   // cet 2010.12.3 add 喷头角度
    for(i=0;i<ssNew.Length();i++){
        Entity ent = ssNew[i];
        OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbEquipment, pEquip);
        if(pEquip){
            XPoint pt = pEquip->GetLocation();
            pt.z = 0;
            lstPt.NewAppend(pt);
			// cet 2010.12.3 add
			if (!bSprikle)
			{
				bSprikle = true;
				dAngle = pEquip->GetAngle();
			}
        }
        OPENOBJ_END();
    }
    if(ssNew.Length() == 0){
        for(i=0;i<ss.Length();i++){
            Entity ent = ss[i];
            if(ent.Is(_T("INSERT")) || ent.Is(_T("AEC_BLOCK_INSERT"))){
                XPoint pt;
                ent.GetData(10, &pt);
                pt.z = 0;
                lstPt.NewAppend(pt);
            }
        }
    }

    if(lstPt.Length() < 2)
        return;
    /////////////////////////////////////////////////////////////////////////////
    //判断他们是共线还是共圆
    BOOL bIsLine = TRUE;
    XArc arDim;
    
    if(lstPt.Length() > 3){
        XPoint p1 = *lstPt[0];
        XPoint p2 = *lstPt[1];
        XPoint p3 = *lstPt[2];
        XPoint p4 = *lstPt[3];
		if(!(IsOnLine(p1,p2,p3) && IsOnLine(p2,p3,p4)))
		{
			XArc arc(p1, p2, p3);
			double nn = arc.Bulge();
			if(fabs(nn) > (2*PI-0.001)){
				nn -= 2*PI;
			}
			if(fabs(nn) > 0.001){
				int ret = arc.HitTest2d(p4);
				if(ret > 2){
					bIsLine = FALSE;
					arDim = arc;
				}
				else{
				   // cet 2010.12.3 modify 处理喷头不共线也不共圆的情况
                   //adsout << _T("\n所选喷头既不共线，又不共圆！");
                   //return; //既不共线， 又不共圆

					if (bSprikle) // 喷头
					{
						AdjustPtsToLine(lstPt, dAngle);
					}
					else // 洁具
					{
						adsout << XString(_T("\n所选洁具既不共线，又不共圆！")); 
                        return; 
					}
				}
			}
		}
    }
    else if(lstPt.Length() == 3){
        XPoint p1 = *lstPt[0];
        XPoint p2 = *lstPt[1];
        XPoint p3 = *lstPt[2];
		if(!IsOnLine(p1,p2,p3))
		{
			XArc arc(p1, p2, p3);
			double nn = arc.Bulge();
			if(fabs(nn) > (2*PI-0.001)){
				nn -= 2*PI;
			}
			if(fabs(nn) > 0.001){
				bIsLine = FALSE;
				arDim = arc;
			}
		}
    }
    /////////////////////////////////////////////////////////////////////////////
    InitLayer(LAY_DIM_SPRINKLE);
	while(true)
	{
		dlg.UpdateData(TRUE);
		XPointList lstPtCp = lstPt;
		ModifyLstPts(lstPt, dlg, bIsLine);
		if(bIsLine){
			TDbDimension2 *pDim = new TDbDimension2;
			pDim->setLayer(LAY_DIM_SPRINKLE);
			pDim->SetDist2DimLine(0);
			pDim->SetLocation(*lstPt[0]);
			pDim->SetStyleId(InitDimStyle(DS_LINEAR));
			pDim->SetRotation(ads_angle(*lstPt[1], *lstPt[0]));
			for(int j=1;j<lstPt.Length();j++){
				XPoint pt = *lstPt[j];
				pDim->AddSegment(pt);
			}
			TDimensionEdJig jig(pDim, _T("\n请点取尺寸线位置<退出>:"), _T("R "));
			jig.m_nFlag=1;
			int nRet = jig.doIt();
			if (nRet == RTKWORD)
			{
				lstPt = lstPtCp;
				delete pDim;
				continue;
			}
			if(nRet != RTNORM){
				delete pDim;
				dlg.DestroyWindow();
				return;
			}
			((TDbEntity *)pDim)->setLayer(LAY_DIM_SPRINKLE);
			
			AcDbObjectId idDim = pDim->AddToMSpace(Adesk::kTrue);
	 
					
	//		OPENOBJ_BEGIN(idDim, AcDb::kForWrite, TDbEntity, pEnt)
	//		if(pEnt){
	//			pEnt->setLayer(LAY_DIM_SPRINKLE);
	//		}
	//		OPENOBJ_END()
					
		}
		else{
			TDbDimension2 *pDim = new TDbDimension2;
			XCurveSegment segDim;
			segDim=arDim;
			pDim->setLayer(LAY_DIM_SPRINKLE);
			pDim->SetStyleId(InitDimStyle(DS_ANGLE));
			pDim->SetDist2DimLine(-6.0);
			XPoint ptFix;
			ads_polar(segDim.GetStartPoint(), segDim.IDirection(0)-PI/2, 2.0*DocGetPScale(), ptFix);
			pDim->SetLocation(ptFix);
			pDim->SetRotation(segDim.IDirection(0));
			pDim->SetAngular(TRUE);
			pDim->SetDimChord(FALSE);
			pDim->SetObjRadius(arDim.GetRadius());
			pDim->SetDimRadius(arDim.GetRadius() + 8.0*DocGetPScale());
			XArc arDimLine=arDim;
			arDimLine.SetRadius(arDimLine.GetRadius() + 8.0*DocGetPScale());
			for(int j=0;j<lstPt.Length();j++){
				XPoint pt = *lstPt[j];
				pDim->AddSegment(pt);
			}
			pDim->SwitchDimChord();
			TDimensionEdJig jig(pDim, _T("\n请点取尺寸线位置<退出>: "), _T("R "));
			jig.m_nFlag=1;
			int nRet = jig.doIt();
			if (nRet == RTKWORD)
			{
				lstPt = lstPtCp;
				delete pDim;
				continue;
			}
			if(nRet != RTNORM){
				delete pDim;
				dlg.DestroyWindow();
				return;
			}
			((TDbEntity *)pDim)->setLayer(LAY_DIM_SPRINKLE);
			AcDbObjectId idDim = pDim->AddToMSpace(Adesk::kTrue);
		}
		break;
	}

	Entity entLast;
	entLast.GetLast();
	
	OPENOBJ_BEGIN(entLast, AcDb::kForWrite, AcDbEntity, pEnt)
	if(pEnt){
		pEnt->setLayer(LAY_DIM_SPRINKLE);
	}
	OPENOBJ_END()
			
	dlg.DestroyWindow();
  //  WriteXdata(entLast, _T("TG-LAYER"), LAY_PIPE_SPRINKLE);
*/			
}

//***************************************************************************************************
//                                        更改管径
//***************************************************************************************************
void DoChangeAllPipeDnDim()
{
    Entity entPipe;
    RBList rbMask(RTDXF0, _T("ATS_PIPE"), 8, GetLayerNames(_T("管")), NULL);
	if(SelectEntity(_T("\n请选取要更改管径的管线 <退出>:"), entPipe, rbMask)!=RTNORM) 
        return;
 
    int iDnNew(0), iDnOld(0);
    int iMat(0);
    OPENOBJ_BEGIN(entPipe, AcDb::kForRead, TDbPipe, pPipe);
    if(pPipe){
        iDnOld = (int)pPipe->GetDnDiameter();
        iMat = pPipe->GetMaterial();
    }
    OPENOBJ_END();
    
    CString csPrompt;
    csPrompt.Format(_T("\n请输入新管径<%d>"), iDnOld);
    if(ads_getint(csPrompt, &iDnNew) != RTNORM)
		return;
	
    if(iDnNew == iDnOld)
        return;
    PickSet ss(SS_FREE);
    ss.Get(_T("X"), NULL, NULL, rbMask);
    for(long i=0;i<ss.Length();i++){
        Entity ent = ss[i];
        OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbPipe, pPipe);
        if(pPipe){
            int iDn = (int)pPipe->GetDnDiameter();
            int iMat2 = pPipe->GetMaterial();
            if(iDn == iDnOld && iMat == iMat2){
                if(pPipe->upgradeOpen()==Acad::eOk) {
                    pPipe->SetDnDiameter(iDnNew);
                    pPipe->downgradeOpen();
                }
            }
        }
        OPENOBJ_END();
    }
}

void ChangeDnDim()
{
    Entity entPipe;
    RBList rbMask(RTDXF0, _T("ATS_PIPE"), 8, GetLayerNames(_T("管")), NULL);
    XPoint ptPick;
    InitLayer(LAY_PIPE_DIM);
    AcDbObjectId idTextStyle = InitTwtTextStyle(g_csTwtDimStyle);	
    while(1){
        acedGetAcadDwgView()->SetFocus();
        
		if(SelectEntity1(g_nCurPipeWidth*DocGetPScale(), _T("\n请选取要更改管径的管线<替换所有同管材同规格的管线>:"), entPipe, ptPick, rbMask)!=RTNORM) {
            DoChangeAllPipeDnDim();
            break;
        }
         
        
        InitSheetHook(TRUE);
        CPoint ptDwgView;
        int cvport=0;
        VERIFY(xg_getvar(_T("CVPORT"), &cvport)==RTNORM);
        acedCoordFromWorldToPixel(cvport, ptPick, ptDwgView);
        
        CTemporaryResourceOverride vTmp;
        CString csText;
        OPENOBJ_BEGIN(entPipe, AcDb::kForRead, TDbPipe, pPipe);
        if(pPipe){
            if(pPipe->IsVertical()){
                InitSheetHook(FALSE);
                continue;
            }
            if(pPipe->GetDnDiameter() < 0)
                csText = _T("无信息");
            else
                csText.Format(_T("%.0f"), pPipe->GetDnDiameter());
        }
        OPENOBJ_END();

        CComboBox *pEdit = new CComboBox();
        pEdit->Create(WS_CHILD|WS_VISIBLE|WS_VSCROLL|CBS_DROPDOWN |CBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP, 
            CRect(ptDwgView.x, ptDwgView.y, ptDwgView.x+80, ptDwgView.y +200), acedGetAcadDwgView(), IDC_USER_COMBOX_TYPE3);
        pEdit->AddString(_T("不标注"));
        pEdit->AddString(_T("25"));
        pEdit->AddString(_T("32"));
        pEdit->AddString(_T("40"));
        pEdit->AddString(_T("50"));
        pEdit->AddString(_T("70"));
        pEdit->AddString(_T("80"));
        pEdit->AddString(_T("100"));
        pEdit->AddString(_T("125"));
        pEdit->AddString(_T("150"));
        
        pEdit->SetWindowText(csText);
        int lenText = csText.GetLength();
        pEdit->SetEditSel(0, lenText);
        pEdit->SetFocus();	
        int nKey, ret;
        ads_prompt(_T("\n请在编辑框内输入文字<回车键或鼠标右键完成, ESC键退出>"));
        BOOL bFisrt = TRUE;
        while(1){
            ret = ads_getint(_T(""), &nKey);
            if(ret == RTNONE && g_nKey != 0)	{ 
                if(g_nKey == VK_ESCAPE)
                    break;
                if(g_nKey == VK_RETURN || (g_nKey == VK_RBUTTON && bFisrt) || (g_nKey == VK_LBUTTON && bFisrt)){
                    CString csTmp;
                    pEdit->GetWindowText(csTmp);
                    OPENOBJ_BEGIN(entPipe, AcDb::kForWrite, TDbPipe, pPipe);
                    if(pPipe){
                        if(csTmp == _T("不标注"))
                            pPipe->EnableDrawLabel(FALSE);
                        else{
                            if(csText == _T("无信息")){
                                pPipe->SetTextStyle(InitTwtTextStyle(g_csTwtDimStyle));
                                pPipe->SetTextHeight(g_nTwtDimHeight);
                                pPipe->SetLabel(_T("DN"));
                            }
                            pPipe->SetDnDiameter(_tstof(csTmp));
                            pPipe->EnableDrawLabel(TRUE);
                        }
                    }
                    OPENOBJ_END();
                    UpdateMultDim(entPipe);
                    break;
                }
            }
            else if(ret == RTCAN)
                break;
            bFisrt = TRUE;
        }
        InitSheetHook(FALSE);
        if(pEdit)
            pEdit->DestroyWindow();
        delete pEdit;
    }
    SHads_command(RTSTR, _T(".REDRAW"), RTNONE);
}

#define WHV_ON		0x0	//原点
#define WHV_UP		0x2	//上
#define WHV_RIGHT	0x4	//右
int WhereOfVector2d(const XPoint& ptWho, const ads_real dRotation, const XPoint &ptQst)
{
    int flag=0x0;
    ads_matrix mat1;
    ads_matrix mat2;
    ptWho.GetRotationMatrix( dRotation*-1, mat1 );
    ptWho.GetMoveMatrix(XPoint(), mat2);
    XPoint ptTmp(ptQst);
    ptTmp.TransformBy( mat1 );
    ptTmp.TransformBy( mat2 );
    
    if (ptTmp == ptQst) {
        flag |= WHV_ON;
    }
    if (ptTmp.x > 0.0) {
        flag |= WHV_RIGHT;
    }
    if (ptTmp.y > 0.0) {
        flag |= WHV_UP;
    }
    return flag;
}

 
TComposingEdJig::TComposingEdJig(TDbSymbComposing *pElev)
{
    m_pDrawEnt=pElev;
    using namespace std;
    std::vector <CString> vTxt;
    m_cs1 = m_pDrawEnt->GetText() ;
    
    CString csTmp;
    for(int i=0; i<=m_cs1.GetLength(); i++)
    {
        if (_istspace(m_cs1[i])||m_cs1[i]==NULL) {
            vTxt.push_back(csTmp);
            csTmp.Empty();
        }else{
            csTmp+=m_cs1[i];
        }
    }
    
    std::reverse(vTxt.begin(), vTxt.end());
    for(std::vector<CString>::iterator pvTxt=vTxt.begin(); pvTxt !=vTxt.end(); pvTxt++)
    {
        m_cs2 += (*pvTxt + _T("\n"));
    }
    if (m_cs2.GetLength () !=0) {
        m_cs2.TrimRight(_T("\n"));
    }
}

AcEdJig::DragStatus 
TComposingEdJig::GetPoint(XPoint &pt)
{
    if( m_nOperCode == kDimPos )
        return acquirePoint(pt);
    XPoint ptBase=m_nOperCode==kTextLine? m_pDrawEnt->GetTurnPoint() : m_pDrawEnt->GetStartPoint();
    return acquirePoint(pt, ptBase);
}

// 开始执行拖动
int TComposingEdJig::DoIt(int *keyIndex)
{
    if(m_nOperCode==kTurnPoint) {
        m_ptResult=m_pDrawEnt->GetStartPoint();
    } else if(m_nOperCode==kTextLine) {
        XPoint ptTemp;
        ads_polar(m_pDrawEnt->GetTurnPoint(), 0.0, m_pDrawEnt->GetTextBaseLen(FALSE), ptTemp);
        m_ptResult=ptTemp;
    } else if(m_nOperCode == kDimPos ){
        m_ptResult=m_pDrawEnt->GetTurnPoint();
    }
    int nRet = TSymbEdJig::DoIt(keyIndex);
    return nRet;
}


// 更新实体数据
Adesk::Boolean TComposingEdJig::update()
{
    Adesk::Boolean bRet=Adesk::kTrue;
    if(m_nOperCode==kTurnPoint) {
        XPoint ptStart = m_pDrawEnt->GetStartPoint();
        ptStart = Wcs2Ucs(ptStart);
        XPoint ptResult = Wcs2Ucs(m_ptResult);

        double nAng = ads_angle(ptStart, ptResult);
        double nLen = m_pDrawEnt->GetTextBaseLen();
        if(nAng > PI/2 && nAng < PI/2*3)
            nLen = -fabs(nLen);
        else
            nLen = fabs(nLen);
        m_pDrawEnt->SetTextBaseLen(nLen);
        m_pDrawEnt->SetTurnPoint(m_ptResult);
    } else if(m_nOperCode==kTextLine) {
       // double nVal=m_ptResult.x - m_pDrawEnt->GetTurnPoint().x;
        double nVal=Wcs2Ucs(m_ptResult).x - Wcs2Ucs(m_pDrawEnt->GetTurnPoint()).x;
        
        m_pDrawEnt->SetTextBaseLen(nVal, FALSE);
    } else if(m_nOperCode == kDimPos ){
        XLine lnMin(m_ptLeftUp, m_ptRightUp);
        double dir = lnMin.Direction();
        int flagLeftUp = WhereOfVector2d(m_ptLeftUp, dir, m_ptResult);
        int flagRightUp = WhereOfVector2d(m_ptRightUp, dir, m_ptResult);
        int flagLeftDown = WhereOfVector2d(m_ptLeftDown, dir, m_ptResult);
        if ( (flagLeftUp&WHV_RIGHT) == WHV_RIGHT 
            && (flagRightUp&WHV_RIGHT) != WHV_RIGHT  )
        {
            XPoint ptTmp1,ptTmp2;
            m_ptResult.Project(&lnMin, ptTmp1);
            if ((flagLeftUp&WHV_UP) == WHV_UP )
            {
                ads_polar(ptTmp1, dir-PI/2, m_ptLeftUp.Distance2d(m_ptLeftDown)+DocGetPScale(), ptTmp2);
                m_pDrawEnt->SetStartPoint(ptTmp2);
                m_pDrawEnt->SetTurnPoint(m_ptResult);
                m_pDrawEnt->SetText(m_cs1);
                //m_pDrawEnt->SetLayoutRotation(XLine(m_ptLeftUp,m_ptRightUp).Direction() );
            } 
            else if ((flagLeftDown&WHV_UP) != WHV_UP)
            {
                ads_polar(ptTmp1, dir+PI/2, 0.5*DocGetPScale(), ptTmp2);
                m_pDrawEnt->SetStartPoint(ptTmp2);
                m_pDrawEnt->SetTurnPoint(m_ptResult);
                m_pDrawEnt->SetText(m_cs2);
                //m_pDrawEnt->SetLayoutRotation(XLine(m_ptLeftUp,m_ptRightUp).Direction()+PI );
            }
        }
    }
    return bRet;
}

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