// HydrantPlanDlg.cpp : implementation file
//

#include "stdafx.h"
#include <DbEquipment.h>
#include <PipeWireMonitor.h>
//#include <dbwall.h>
//#include <dbColumn.h>
#include "XBlock.h"
//#include "cbclass.h"

#include "DrawStandPipeDlg.h"
#include "HydrantPlanDlg.h"
#include "InsBlockDlg.h"
#include "SelectBlkDlg.h"
#include "EditWaterBucketDlg.h"
#include "ProtectRadiusDlg.h"
#include "jig.h"
#include "DbFireExtinguisher.h"

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

//#ifdef _WIN64
#include"TGAs.h"
//#endif

//***************************************************************************************************
//                                        保护半径
//***************************************************************************************************

void UnionPoly(DList<XPoly2D> &lstPolyThis)
{
    if(lstPolyThis.Length() >1){
        XPoly2D poly1 = *lstPolyThis[0];
        DList<XPoly2D> lstPolyThis3; 
        lstPolyThis3.Append(new XPoly2D(poly1));
        DList<XPoly2D> lstPolyThis4; 
        for(int nn=1;nn<lstPolyThis.Length();nn++){
            XPoly2D poly5 = *lstPolyThis[nn];
            lstPolyThis4.Append(new XPoly2D(poly5));
        }
        lstPolyThis.Reset();
        Union(lstPolyThis3, lstPolyThis4, lstPolyThis);
    }
}

//pLine线选择范围内的设备 zxl 2011.10.18 add
void GetEquipmentFromPline(PickSet &ss, const resbuf* rbMask = NULL)
{
	Entity entPoly;
	RBList rbMask2(RTDXF0, _T("LWPOLYLINE"), 8, _T("*"), NULL);
	if (SelectEntity(_T("\n请选择闭合PLINE:<退出>"), entPoly, rbMask2) == RTNORM)
	{
		XPoly2D poly(entPoly);
		poly.TransUCS(Groups(0), Groups(1));
		
		RBList rbFence = poly.Fence();
		
		XPoint ptLow, ptUp;
		poly.GetExtend(ptLow, ptUp);
		AssureInCurrentView(Ucs2Wcs(ptLow), Ucs2Wcs(ptUp));
		
		ss.Get(_T("CP"), rbFence, NULL, rbMask);

		CString sNot;
		sNot.Format(_T("\n共得到%d个设备"),ss.Length());
		acutPrintf(sNot);
	}
}

void ShowProtectRadius()
{
    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("ATS_EQUIPMENT"), 8, LAY_EQUIP_HYDRANT, -4, _T("and>"), 
		-4, _T("<and"), RTDXF0, _T("ATS_EQUIPMENT"), 8, LAY_EQ_FIRE, -4, _T("and>"),	//支持消防附件  zxl 2011.10.20 add
		-4, _T("<and"), RTDXF0, _T("ATS_EQUIPMENT"), 8, LAY_TWT_EXTINGUISHER, -4, _T("and>"),   // 支持灭火器 cet 2013.4.22 add
        -4, _T("or>"), NULL);
    
    PickSet ss(SS_FREE), ssDel(SS_FREE), ssFire(SS_FREE), ssHydrant(SS_FREE), ssSprinkle(SS_FREE);
	TCHAR cRet;
	int ret(0);
	while (true)//添加循环，控制用户交互 zxl 2011.10.20 add
	{
		INITGET_BEG(0, _T("P R"));
		ret = SelectEntities(_T("\n请选择要显示的消火栓、灭火器或喷头范围{选取闭合PLINE(P)/修改保护半径(R)}:<整张图>"), ss, rbMask, _T("P R"), cRet);
		INITGET_END();

//		zxl 2011.12.01 modify
//		INITGET_BEG(0, _T("P R S"));
//		ret = SelectEntities(_T("\n请选择要显示的消火栓或灭火器[选取闭合PLINE(P)/修改保护半径(R)/显示喷头保护半径(S)]:<整张图>"), ss, rbMask, _T("P R S"), cRet);
//		INITGET_END();

// 		if(ret == RTKWORD){
// 			if(cRet == _T('R')){
// 				PickSet ssSel(SS_FREE);
// 				if(SelectEntities(_T("\n请选择要修改的消防设备<退出>:"), ssSel, rbMask) != RTNORM)
// 					return;
// 				double nNew(0);
// 				ads_getreal(_T("\n请输入新的保护半径(m)<退出>"), &nNew);
// 				if(nNew <0.001)
// 					return;
// 				long len = ssSel.Length();
// 				for(long j=0;j<len;j++){
// 					Entity entTmp = ssSel[j];
// 					WriteXdata(entTmp, _T("HYDRANT_RADIUS"), XString(_T("%.2f"), nNew));
// 				}
// 				return;
// 			}
// 			else if(cRet == _T('S'))
// 			{
// 				RBList rbMask2 = ads_buildlist( -4, _T("<or"),
// 					-4, _T("<and"), RTDXF0, _T("ATS_EQUIPMENT"), 8, LAY_EQ_FIRE, -4, _T("and>"),	//添加消防附件   zxl 2011.10.18 add
// 					-4, _T("<and"), RTDXF0, _T("ATS_EQUIPMENT"), 8, LAY_EQUIP_SPRINKLE, -4, _T("and>"),  
// 					-4, _T("<and"), RTDXF0, _T("ATS_EQUIPMENT"), 8, LAY_EQUIP_HYDRANT, -4, _T("and>"),  
// 					-4, _T("or>"), NULL);
// // 				if(SelectEntities(_T("\n请选择要显示的消火栓或灭火器或喷头:<退出>"), ss, rbMask2) != RTNORM)
// // 					return;
// 
// 				//增加pline线选取功能 zxl 2011.10.18 modify
// 				TCHAR cRets;
// 				int nRet(0);
// 				INITGET_BEG(0, _T("P"));
// 				nRet = SelectEntities(_T("\n请选择要显示的消火栓或灭火器或喷头[闭合PLINE选取(P)]:<退出>"), ss, rbMask2, _T("P"), cRets);
// 				INITGET_END();
// 				if (cRets == _T('P'))
// 				{
// 					GetEquipmentFromPline(ss, rbMask2);
// 				}
// 				else if (nRet != RTNORM)
// 				{
// 					return;
// 				}
// 			}
// 			else   //  zxl 2011.10.18 add
// 			{
// 				GetEquipmentFromPline(ss, rbMask);
// 			}
// 		}

		if (ret == RTKWORD)
		{
			if (cRet == _T('P'))
			{
				GetEquipmentFromPline(ss, rbMask);
			}
			else if (cRet == _T('R'))
			{
				PickSet ssSel(SS_FREE);
				if(SelectEntities(_T("\n请选择要修改的消防设备<退出>:"), ssSel, rbMask) != RTNORM)
					return;
				double nNew(0);
				ads_getreal(_T("\n请输入新的保护半径(m)<退出>"), &nNew);
				if(nNew <0.001)
					return;
				long len = ssSel.Length();
				for(long j=0;j<len;j++)
				{
					Entity entTmp = ssSel[j];
					WriteXdata(entTmp, _T("HYDRANT_RADIUS"), XString(_T("%.2f"), nNew));
				}
				return;
			}
		}
		else if (ret == RTCAN)//zxl 2011.11.30 add 支持ESC退出
		{
			return;
		}
		else if(ret != RTNORM)
		{
			ss.Get(_T("X"), NULL, NULL, rbMask);
			break;
		}
		if (ss.Length() > 0)
		{
			break;
		}
	}
	
	// cet 2012.6.4 add 断管符号
	AcDbObjectId id = GetBlockIdFromString(_T("$TwtSys$00000132"));
	//zxl 2011.12.01 modify 单独显示消火栓、灭火器、喷头的保护半径
	for (long l = 0; l < ss.Length(); l++)
	{
		Entity entTmp = ss[l];
		XPoint ptEqLoc;
		OPENOBJ_BEGIN(entTmp, AcDb::kForRead, TDbEquipment, pEquip);
		if(pEquip)
		{
			// cet 2012.6.4 add 断管符号除外
			if (id == pEquip->GetBlock2d())
			{
				continue;
			}

			CString sLayer = pEquip->layer();
			if (sLayer.Compare(LAY_EQUIP_SPRINKLE) == 0)
			{
				ssSprinkle += entTmp;
			}
			else if (sLayer.Compare(LAY_EQUIP_HYDRANT) == 0)
			{
				ssHydrant += entTmp;
			}
			else if (sLayer.Compare(LAY_TWT_EXTINGUISHER) == 0)
			{
				ssFire += entTmp;
			}
		}
		OPENOBJ_END();

		// 支持灭火器 cet 2013.4.22 add
		if (entTmp.Is(_T("INSERT")))
		{
			ssFire += entTmp;
		}
	}

	CProtectRadiusDlg dlg;
	dlg.Create(IDD_PROTECT_RADIUS);
	int iIndex = 0;
	int nType = 0;
	double dUint(1);
	if(!DocGetMeterUnitDraw())
		dUint = 1000;
	adsout << _T("红色是喷淋保护范围，白色是消火栓或灭火器保护范围!"); 
	while(true)
	{
		PickSet ssSel(SS_FREE);
		if (iIndex > 0)//初次进入循环顺序显示保护半径
		{
			PickSet ss;
			dlg.m_bModify = false;
			dlg.UpdateData(TRUE);
			ret = SelectEntities(_T(""),ss, rbMask);
			nType = dlg.m_nShowType;

			if (ret == RTERROR && dlg.m_bModify)
			{
				if (nType == 0)
				{
					ssSel += ssHydrant;
				}
				else if (nType == 1)
				{
					ssSel += ssFire;
				}
				else if (nType == 2)
				{
					ssSel += ssSprinkle;
				}
				else if (nType == 4)
				{
					dlg.ShowWindow(FALSE);
					break;
				}
				else if(nType == 3)
				{
					ssDel.Erase();
					dlg.DestroyWindow();
					PickSet ssSel(SS_FREE);
					if(SelectEntities(_T("\n请选择要修改的消防设备<退出>:"), ssSel, rbMask) != RTNORM)
						return;
					double nNew(0);
					ads_getreal(_T("\n请输入新的保护半径(m)<退出>"), &nNew);
					if(nNew < 0.001)
						return;
					long len = ssSel.Length();
					for(long j=0;j<len;j++)
					{
						Entity entTmp = ssSel[j];
						WriteXdata(entTmp, _T("HYDRANT_RADIUS"), XString(_T("%.2f"), nNew));
						OPENOBJ_BEGIN(entTmp, AcDb::kForWrite, TDbFireExtinguisher, pFire);
						if(pFire != NULL)
						{
							pFire->SetProtectRadius(nNew);
						}
						OPENOBJ_END();
					}
					break;
				}
				ssDel.Erase();
			}
			else if (ret != RTNORM)
			{
				ssDel.Erase();
				dlg.DestroyWindow();
				break;
			}
		}
		else
		{
			iIndex++;
			ssSel += ssHydrant;
			dlg.m_nShowType = 0;
			if (ssHydrant.Length() == 0)
			{
				ssSel += ssFire;
				dlg.m_nShowType = 1;
				if (ssFire.Length() == 0)
				{
					ssSel += ssSprinkle;
					dlg.m_nShowType = 2;
				}
			}
			dlg.ShowWindow(TRUE);
			dlg.UpdateData(FALSE);
			nType = dlg.m_nShowType;
		}

		DList<XPoly2D> lstPoly1;
		int itype = -1;
		long len = ssSel.Length();
		for(long i=0;i<len;i++)
		{
			Entity entTmp = ssSel[i];
			CString csCir = ReadXdata(entTmp, _T("HYDRANT_RADIUS"));

			//设置消防附件保护半径 zxl 2011.10.18 add
			if(csCir == _T(""))
			{
				csCir = _T("12");
			}

			if(csCir != _T(""))
			{
				XPoint ptEqLoc;
//				cet 2013.4.22 modify 支持灭火器
// 				OPENOBJ_BEGIN(entTmp, AcDb::kForRead, TDbEquipment, pEquip);
// 				if(pEquip)
// 				{
// 					ptEqLoc = pEquip->GetLocation();
// 				}
// 				OPENOBJ_END();
				if (entTmp.Is(_T("ATS_EQUIPMENT")))
				{
					OPENOBJ_BEGIN(entTmp, AcDb::kForRead, TDbEquipment, pEquip);
					if(pEquip != NULL)
					{
						ptEqLoc = pEquip->GetLocation();
					}
					OPENOBJ_END();

					// 支持灭火器新实体 zxl 2014.02.10 add
					OPENOBJ_BEGIN(entTmp, AcDb::kForRead, TDbFireExtinguisher, pFire);
					if(pFire != NULL)
					{
						double dRadius = pFire->GetProtectRadius();
						csCir.Format(_T("%.0f"), dRadius);
						double dScale = pFire->GetScale();
						if (pFire->GetScaleType() == 0)
						{
							dScale *= (pFire->GetPScale() / 100);
						}
						AcGeScale3d scale(dScale);
						double dWidth = 0.0, dHeight = 0.0;
						AcGePoint3d ptIns = AcGePoint3d::kOrigin;
						AcDbBlockReference blkRef(ptIns, pFire->GetBlock2d());
						blkRef.setScaleFactors(scale);
						AcDbExtents extent;
						blkRef.getGeomExtents(extent);
						AcGePoint3d ptMin = extent.minPoint();
						AcGePoint3d ptMax = extent.maxPoint();
						dWidth = ptMax.x - ptMin.x;
						dHeight = ptMax.y - ptMin.y;

						//插入点
						ptIns = pFire->GetLocation();
						AcGePoint3dArray arrPts;
						if (pFire->GetLayType() == 0) // 按数量进行布置并标注规格
						{
							// 图块出入点
							int nMod = pFire->GetNum() % 2;
							if (nMod == 1) // 奇数个灭火器
							{
								arrPts.append(ptIns);
							}
							
							int nNum = pFire->GetNum();
							nNum /= 2;
							AcGeVector3d vtDir = AcGeVector3d::kXAxis;
							vtDir.rotateBy(pFire->GetAngle(), AcGeVector3d::kZAxis);
							double dDist = 0.0;
							for (int i = 0; i < nNum; ++i)
							{
								if (i == 0 && nMod == 0)
								{
									dDist += dWidth * 0.5;
								} 
								else
								{
									dDist += dWidth;
								}
								arrPts.append(ptIns + vtDir * dDist);
								arrPts.append(ptIns - vtDir * dDist);
							}
						}
						else
						{
							arrPts.append(ptIns);
						}

						for (int i = 0; i < arrPts.length(); i++)
						{
							XPoint pt = arrPts[i];
							XCircle cir2(pt, _tstof(csCir)*dUint);
							XCurveSegment seg;
							seg = cir2;
							XPoly2D poly;
							seg.AsPoly2D(poly);
							lstPoly1.Append(new XPoly2D(poly));
							cir2.Make();
							Entity entCir2;
							entCir2.GetLast();
							if(IsSprinkler(entTmp)){
								entCir2.SetData(62, 1);
								entCir2.Modify();
							}
							ssDel += entCir2;
						}
						continue;
					}
					OPENOBJ_END();
				} 
				else if (entTmp.Is(_T("INSERT")))
				{
					OPENOBJ_BEGIN(entTmp, AcDb::kForRead, AcDbBlockReference, pRef);
					if(pRef != NULL)
					{
						ptEqLoc = pRef->position();
					}
					OPENOBJ_END();
				}
				else
				{
					continue;
				}

				XCircle cir2(ptEqLoc, _tstof(csCir)*dUint);

				XCurveSegment seg;
				seg = cir2;
				XPoly2D poly;
				seg.AsPoly2D(poly);
				lstPoly1.Append(new XPoly2D(poly));
				cir2.Make();
				Entity entCir2;
				entCir2.GetLast();
				if(IsSprinkler(entTmp)){
					entCir2.SetData(62, 1);
					entCir2.Modify();
				}
				ssDel += entCir2;
			}
		}
		// zxl 2011.12.02 add 添加进度条
		acedSetStatusBarProgressMeter(_T("计算中..."), 0, lstPoly1.Length() - 1);
		for(int m=0;m<lstPoly1.Length()-1;m++)
		{
			acedSetStatusBarProgressMeterPos( m + 1 );
			XPoly2D rPoly1 = *lstPoly1[m];
			for(int n=1;n<lstPoly1.Length();n++)
			{
				XPoly2D rPoly2 = *lstPoly1[n];
				if(m == n)
					continue;
				DList<XPoly2D> lstPoly2, lstPoly3,lstDest;
				lstPoly2.Append(new XPoly2D(rPoly1));
				lstPoly3.Append(new XPoly2D(rPoly2));

				Intersect(lstPoly3,lstPoly2,lstDest);
				for(int j=0;j<lstDest.Length();j++)
				{
					XPoly2D rPoly = *lstDest[j];
					AcDbHatch *pHatch = NewHatchFromPoly2D(rPoly, _T("ANSI31"), dlg.m_dScale * 20 * DocGetPScale());
					if(!pHatch)
						continue;
					AddToModelSpace(pHatch,Adesk::kTrue);
					Entity entCir2;
					entCir2.GetLast();
					ssDel += entCir2;
				}
			}
		}
		acedRestoreStatusBar();
	}
	dlg.DestroyWindow();
}


BOOL GetBlkRecordMidPt(const TCHAR* szBlkName, double nScale, XPoint &pt, BOOL bMirror, double nInsBlkRotate)
{
    AcDbBlockReference *pBlkRef = new AcDbBlockReference();
    AcDbBlockTable* pBlockTable = NULL;
    AcDbObjectId recordId = NULL;
    acdbCurDwg()->getBlockTable(pBlockTable, AcDb::kForRead);
#if ADS > 24
    if(Acad::eOk != pBlockTable->getAt(szBlkName, recordId)){
#else
    if(Acad::eOk != pBlockTable->getAt(szBlkName, recordId, AcDb::kForRead)){
#endif
        pBlockTable->close();
        delete pBlkRef;
        return FALSE;
    }
    pBlockTable->close();
    pBlkRef->setBlockTableRecord(recordId);
    pBlkRef->setPosition(pt);
    pBlkRef->setRotation(nInsBlkRotate);
    if(bMirror)
        pBlkRef->setScaleFactors(AcGeScale3d(-nScale, nScale, 1));
    else
        pBlkRef->setScaleFactors(AcGeScale3d(nScale, nScale, 1));
    AcDbExtents extents;
    pBlkRef->getGeomExtents(extents);
    AcGePoint3d pMax = extents.maxPoint();
    AcGePoint3d pMin = extents.minPoint();
    XPoint ptCen;
    ptCen[0] = (pMax[0] + pMin[0]) / 2;
    ptCen[1] = (pMax[1] + pMin[1]) / 2;
    ptCen[2] = 0;
    
    AcGeMatrix3d mat;
    mat.setToTranslation(AcGeVector3d(ptCen[0] - pt[0], ptCen[1] - pt[1], 0));
    pt.TransformBy(mat);
    delete pBlkRef;
    
    return TRUE;
}


//***************************************************************************************************
//                                        连消火栓
//***************************************************************************************************
void GetAllLineByEq(Entity ent, DList<XLine> &lstLine)
{
    OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbEquipment, pEquip);
    if(pEquip){
        AcDbVoidPtrArray entSet;
        pEquip->explode(entSet);
        for(int i=0;i<1;i++){
            AcDbEntity *pEnt = (AcDbEntity *)entSet[i];
            AcDbBlockReference *pBlkRef = NULL;
            if(pBlkRef = AcDbBlockReference::cast(pEnt)){
                AcDbVoidPtrArray entSet2;
                pBlkRef->explode(entSet2);
                int len = entSet2.length();
                for(int j=0;j<len;j++){
                    AcDbEntity *pEnt2 = (AcDbEntity *)entSet2[j];
                    AcDbLine *pLine = NULL;
                    if(pLine = AcDbLine::cast(pEnt2)){
                        XPoint pS = pLine->startPoint();
                        XPoint pE = pLine->endPoint();
                        pS.z = 0;
                        pE.z = 0;
                        XLine *line = new XLine(pS, pE);
                        lstLine.Append(line);
                    }
                }
                ReleaseEntSet(entSet2);
            }

        }
        ReleaseEntSet(entSet);
    }
    OPENOBJ_END(); 
}

	
void DoLinkHydrantByUser(Entity entEq, Entity entPipe, double dEle)
{
    int iPolarmode(0);
    xg_getvar(_T("AUTOSNAP"), &iPolarmode);
    XPushVar<int> vOrthoMode(_T("ORTHOMODE"), 1); //f8
    XPoint ptStart, ptEnd, ptJig, ptPick1, ptPick2;
    GetPipePoint(entPipe, ptStart, ptEnd);
    ptJig = ptStart;
    ptPick1 = ptStart;
    ptPick1.z = dEle;
    ptJig.z = 0;
    TPipeEdJig jig(ptJig, ptJig, 0.5);
	jig.SetPrompt(_T("\n请点取管线下一点或消火栓<退出>:"));
    jig.m_bInit = TRUE;
    while(1){
        ptPick1.z = 0;
        jig.m_ptRef = ptPick1;
        int ret = jig.DoIt();
        if(ret == RTNORM){
            ptPick2 = jig.m_ptPick;
            //首先判断是否从设备上引出
            Entity entEq = GetEquipmentByPt(ptPick2);
            if(!entEq){
                ptPick2 = jig.GetCorrectPt();
            }
            else{
                DList<XLine> lstLine;
                GetAllLineByEq(entEq, lstLine);
                int len = lstLine.Length();
                double nDist(-1);
                for(int i=0;i<len;i++){
                    XPoint ptTmp;
                    XLine line = *lstLine[i];
                    line.SetLineFlag(1);
                    XPoint pt = ptPick1;
                    pt.z = 0;
                    pt.Project(&line, ptTmp);
                    if((ptTmp & line) == PR_EXTEND)
                        continue;
                    
                    double n = ads_distance(ptTmp, pt);
                    if(n < nDist || nDist < 0){
                        ptPick2 = ptTmp;
                        nDist = n;
                    }
                }
                ptPick2.z = dEle;
                OPENOBJ_BEGIN(entEq, AcDb::kForWrite, TDbEquipment, pEquip);
                if(pEquip){
                    pEquip->SetLocation(ptPick2);
                }
                OPENOBJ_END();
                ptPick1.z = dEle;
                OPENOBJ_BEGIN(entPipe, AcDb::kForRead, TDbPipe, pPipe);
                if(pPipe){
                    TDbPipe *pNewPipe = (TDbPipe *)pPipe->clone();
                    pNewPipe->SetEndPoint(ptPick2);
                    pNewPipe->SetStartPoint(ptPick1);
                    pNewPipe->SetDnDiameter(65);
                    AddToCurrentSpace(pNewPipe, Adesk::kTrue);
                }
                OPENOBJ_END(); 
                break;
            }
            ptPick1.z = dEle;
            ptPick2.z = dEle;
            OPENOBJ_BEGIN(entPipe, AcDb::kForRead, TDbPipe, pPipe);
            if(pPipe){
                TDbPipe *pNewPipe = (TDbPipe *)pPipe->clone();
                pNewPipe->SetEndPoint(ptPick2);
                pNewPipe->SetStartPoint(ptPick1);
                pNewPipe->SetDnDiameter(65);
                AddToCurrentSpace(pNewPipe, Adesk::kTrue);
            }
            OPENOBJ_END(); 
            ptPick1 = ptPick2;
            ptJig = ptPick2;
            ptJig.z = 0;
            jig.SetStartPoint(ptJig);
            
        }
        else
            break;
    }        
	xg_setvar(_T("AUTOSNAP"), iPolarmode);
	
}

extern CString GetPipeLayerByVPipeLay(const TCHAR* szLayer);

void DoLinkHydrant(Entity entEq, Entity entPipe)
{
	
  //  RBList rbMask(RTDXF0, _T("ATS_EQUIPMENT"), 8, LAY_EQUIP_HYDRANT, NULL);
  //    RBList rbMask2(RTDXF0, _T("ATS_PIPE"), 8, GetLayerNames(_T("消防")), NULL);
  //    Entity entPipe, entEq;
  //	if(SelectEntity(_T("\n请选择消火栓<退出>:"), entEq, rbMask) != RTNORM)
  //        return;
  //
  //	if(SelectEntity(_T("\n请选择消防立管<退出>:"), entPipe, rbMask2) != RTNORM)
  //        return;
	BOOL bIsUpLink = FALSE;
	OPENOBJ_BEGIN(entEq, AcDb::kForRead, TDbEquipment, pEquip);
	if(pEquip){
		double dLen = pEquip->GetPipeLength();
		if(dLen > 10)
			bIsUpLink = TRUE;
	}
	OPENOBJ_END(); 
	

	CString csLay;
	XPoint ptPipe;
	//先把立管设置一个合适的管径
    OPENOBJ_BEGIN(entPipe, AcDb::kForRead, TDbPipe, pPipe);
    if(pPipe && pPipe->IsVertical()){
		csLay = pPipe->GetLayer();
        double nDn = pPipe->GetDnDiameter();
        if(nDn < 50){
            if(pPipe->upgradeOpen()==Acad::eOk) {
                pPipe->SetDnDiameter(100);
                pPipe->downgradeOpen();
            }
        }
		ptPipe = pPipe->StartPoint();
    }
    else
        return;
    OPENOBJ_END(); 
	csLay = GetPipeLayerByVPipeLay(csLay);

    double dEle(1.1);
	if(bIsUpLink)
	{
		dEle = 0.8;
		ads_getreal(_T("\n请输入支管标高(0.8m)<退出>"), &dEle);
	}
	else
		ads_getreal(_T("\n请输入支管标高(1.1m)<退出>"), &dEle);
    dEle = dEle * 1000;
	ptPipe.z = 0;
	TCHAR szText[32];
	int nRet = 0; // cet 2010.6.23 add
	nRet = ads_getstring(0, _T("\n系统自动就近连接消火栓<Y>: "), szText);
	// cet 2010.6.23 add
	if (nRet == RTCAN)
	{
		return;
	}

	if(_tcsicmp(szText, _T("N")) == 0)
	{
		DoLinkHydrantByUser(entEq, entPipe, dEle);
		return;
	}
	DList<XLine> lstLine;
	GetAllLineByEq(entEq, lstLine);//得到消火栓图块全部线段
	
	XPoint ptInsert, ptInt, ptPipeEnd;
	OPENOBJ_BEGIN(entEq, AcDb::kForRead, TDbEquipment, pEquip);
	if(pEquip){
		ptInsert = pEquip->GetInsert();
		ptInsert.z = 0;
		XVector3D vt = pEquip->GetDirection();
		vt.Normalize();
		vt *= 1000;
		XPoint ptTmp;
		ptTmp = ptInsert + vt;
		XLine line1(ptInsert, ptTmp);
		ptPipe.Project(&line1, ptInt);
		XLine line2(ptPipe, ptInt);
		line2.SetLineFlag(1);
	 
		int len = lstLine.Length();
		double nDist(-1);
		for(int i=0;i<len;i++){
			XPoint ptIntTmp;
			XLine line = *lstLine[i];
			line.SetLineFlag(1);
			int ret = line.Intersection(&line2, ptIntTmp);
			if(ret > 0)
			{
				double n = ads_distance(ptPipe, ptIntTmp);
				if(n < nDist || nDist < 0){
					ptPipeEnd = ptIntTmp;// 有交点，立管直接接消火栓
					nDist = n;
				}
			}
		}
		if(!ptPipeEnd) 
		{
			//2008-12-23 SR ADD  如果没有交点，还不能确定不是直接接消火栓，再试试消火栓另外一个方向
			vt = pEquip->GetDirection();
			vt.Normalize();
			vt.Rotate(PI/2.0);
			vt *= 1000;
			ptTmp = ptInsert + vt;
			XLine line4(ptInsert, ptTmp);
			XPoint ptInt2;
			ptPipe.Project(&line4, ptInt2);
			XLine line5(ptPipe, ptInt2);
			line5.SetLineFlag(1);
			
			for(int i=0;i<len;i++){
				XPoint ptIntTmp;
				XLine line = *lstLine[i];
				line.SetLineFlag(1);
				int ret = line.Intersection(&line5, ptIntTmp);
				if(ret > 0)
				{
					double n = ads_distance(ptPipe, ptIntTmp);
					if(n < nDist || nDist < 0){
						ptPipeEnd = ptIntTmp;// 有交点，立管直接接消火栓
						nDist = n;
					}
				}
			}
			
		}

		XPoint ptStart, ptEnd;
		ptStart = ptPipe;
		ptStart.z = dEle;
		if(!!ptPipeEnd)
			ptEnd = ptPipeEnd;
		else
			ptEnd = ptInt;

		ptEnd.z = dEle;

		OPENOBJ_BEGIN(entPipe, AcDb::kForRead, TDbPipe, pPipe);
		if(pPipe){
			TDbPipe *pNewPipe = (TDbPipe *)pPipe->clone();
			pNewPipe->SetEndPoint(ptEnd);
			pNewPipe->SetStartPoint(ptStart);
			pNewPipe->SetDnDiameter(65);
			pNewPipe->setLayer(InitLayer(csLay));
			AddToCurrentSpace(pNewPipe, Adesk::kTrue);
		}
		OPENOBJ_END(); 

		if(!!ptPipeEnd)
		{//立管直接连接消火栓
			if(pEquip->upgradeOpen()==Acad::eOk) {
				pEquip->SetLocation(ptEnd);
				pEquip->downgradeOpen();
			}
		}
		else
		{
			// 2008-12-23 SR REMOVE  对于拐弯连接消火栓的，直接连接到中心而不是就近。哈市院提出2立管连接双拴
			//立管需要拐一下，绘制2根管线连接消火栓
//			nDist = -1;
//			//确定消火栓的连接点
//			for(i=0;i<len;i++){
//				XPoint ptIntTmp;
//				XLine line = *lstLine[i];
//				line.flag = 1;
//				int ret = line.Intersection(line3, ptIntTmp);
//				if(ret > 0)
//				{
//					double n = ads_distance(ptPipe, ptIntTmp);
//					if(n < nDist || nDist < 0){
//						ptPipeEnd = ptIntTmp;
//						nDist = n;
//					}
//				}
//			}
		//	if(!!ptPipeEnd)
			{
				ptStart = ptInt;
				ptStart.z = dEle;
				
				ptEnd = ptInsert;

			//	ptEnd = ptPipeEnd;
				ptEnd.z = dEle;
				OPENOBJ_BEGIN(entPipe, AcDb::kForRead, TDbPipe, pPipe);
				if(pPipe){
					TDbPipe *pNewPipe2 = (TDbPipe *)pPipe->clone();
					pNewPipe2->setLayer(InitLayer(csLay));
					pNewPipe2->SetEndPoint(ptEnd);
					pNewPipe2->SetStartPoint(ptStart);
					pNewPipe2->SetDnDiameter(65);
					AddToCurrentSpace(pNewPipe2, Adesk::kTrue);
				}
				OPENOBJ_END(); 
				if(pEquip->upgradeOpen()==Acad::eOk) {
					ptInsert.z = ptEnd.z;
					pEquip->SetLocation(ptInsert);
					pEquip->downgradeOpen();
				}
			}
		}
	}
	OPENOBJ_END();
}

void LinkHydrant()
{
	
    RBList rbMask(RTDXF0, _T("ATS_EQUIPMENT"), 8, LAY_EQUIP_HYDRANT, NULL);
    RBList rbMask2(RTDXF0, _T("ATS_PIPE"), 8, GetLayerNames(_T("消防")), NULL);
    Entity entPipe, entEq;
	if(SelectEntity(_T("\n请选择消火栓<退出>:"), entEq, rbMask) != RTNORM)
        return;
	
	if(SelectEntity(_T("\n请选择消防立管<退出>:"), entPipe, rbMask2) != RTNORM)
        return;
	DoLinkHydrant(entEq, entPipe);
}


void LinkHydrant2()
{
	
    RBList rbMask(RTDXF0, _T("ATS_EQUIPMENT"), 8, LAY_EQUIP_HYDRANT, NULL);
    RBList rbMask2(RTDXF0, _T("ATS_PIPE"), 8, GetLayerNames(_T("消防")), NULL);
    Entity entPipe, entEq;
	if(SelectEntity(_T("\n请选择消防立管<退出>:"), entPipe, rbMask2) != RTNORM)
        return;
    OPENOBJ_BEGIN(entPipe, AcDb::kForRead, TDbPipe, pPipe);
    if(pPipe && pPipe->IsVertical()){
        double nDn = pPipe->GetDnDiameter();
        if(nDn < 50){
            if(pPipe->upgradeOpen()==Acad::eOk) {
                pPipe->SetDnDiameter(100);
                pPipe->downgradeOpen();
            }
        }
    }
    else
        return;
    OPENOBJ_END(); 
    double dEle(1.1);
    ads_getreal(_T("\n请输入支管标高(1.1m)<退出>"), &dEle);
    dEle = dEle * 1000;

    int iPolarmode(0);
    xg_getvar(_T("AUTOSNAP"), &iPolarmode);
    XPushVar<int> vOrthoMode(_T("ORTHOMODE"), 1); //f8
    XPoint ptStart, ptEnd, ptJig, ptPick1, ptPick2;
    GetPipePoint(entPipe, ptStart, ptEnd);
    ptJig = ptStart;
    ptPick1 = ptStart;
    ptPick1.z = dEle;
    ptJig.z = 0;
    TPipeEdJig jig(ptJig, ptJig, 0.5);
	jig.SetPrompt(_T("\n请点取管线下一点或消火栓<退出>:"));
    jig.m_bInit = TRUE;
    while(1){
        ptPick1.z = 0;
        jig.m_ptRef = ptPick1;
        int ret = jig.DoIt();
        if(ret == RTNORM){
            ptPick2 = jig.m_ptPick;
            //首先判断是否从设备上引出
            Entity entEq = GetEquipmentByPt(ptPick2);
            if(!entEq){
                ptPick2 = jig.GetCorrectPt();
            }
            else{
                DList<XLine> lstLine;
                GetAllLineByEq(entEq, lstLine);
                int len = lstLine.Length();
                double nDist(-1);
                for(int i=0;i<len;i++){
                    XPoint ptTmp;
                    XLine line = *lstLine[i];
                    line.SetLineFlag(1);
                    XPoint pt = ptPick1;
                    pt.z = 0;
                    pt.Project(&line, ptTmp);
                    if((ptTmp & line) == PR_EXTEND)
                        continue;
                    
                    double n = ads_distance(ptTmp, pt);
                    if(n < nDist || nDist < 0){
                        ptPick2 = ptTmp;
                        nDist = n;
                    }
                }
                ptPick2.z = dEle;
                OPENOBJ_BEGIN(entEq, AcDb::kForWrite, TDbEquipment, pEquip);
                if(pEquip){
                    pEquip->SetLocation(ptPick2);
                }
                OPENOBJ_END();
                ptPick1.z = dEle;
                OPENOBJ_BEGIN(entPipe, AcDb::kForRead, TDbPipe, pPipe);
                if(pPipe){
                    TDbPipe *pNewPipe = (TDbPipe *)pPipe->clone();
                    pNewPipe->SetEndPoint(ptPick2);
                    pNewPipe->SetStartPoint(ptPick1);
                    pNewPipe->SetDnDiameter(65);
                    AddToCurrentSpace(pNewPipe, Adesk::kTrue);
                }
                OPENOBJ_END(); 
                break;
            }
            ptPick1.z = dEle;
            ptPick2.z = dEle;
            OPENOBJ_BEGIN(entPipe, AcDb::kForRead, TDbPipe, pPipe);
            if(pPipe){
                TDbPipe *pNewPipe = (TDbPipe *)pPipe->clone();
                pNewPipe->SetEndPoint(ptPick2);
                pNewPipe->SetStartPoint(ptPick1);
                pNewPipe->SetDnDiameter(65);
                AddToCurrentSpace(pNewPipe, Adesk::kTrue);
            }
            OPENOBJ_END(); 
            ptPick1 = ptPick2;
            ptJig = ptPick2;
            ptJig.z = 0;
            jig.SetStartPoint(ptJig);
            
        }
        else
            break;
    }        
   xg_setvar(_T("AUTOSNAP"), iPolarmode);
}

//***************************************************************************************************
//                                        替换消火栓 2007-2-28 SR 取消命令
//***************************************************************************************************
void ReplaceHydrant()
{
    RBList rbMask(RTDXF0, _T("ATS_EQUIPMENT"), 8, LAY_EQUIP_HYDRANT, NULL);
    Entity ent;
    PickSet ss(SS_FREE);
	if(SelectEntities(_T("\n请选择需要替换的消火栓<退出>:"), ss, rbMask) != RTNORM)
        return;
    ent = ss[0L];
    XPoint ptLoc;
    CString csBlkName, csSldName;
    OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbEquipment, pEquip);
    if(pEquip){
        ptLoc = pEquip->GetLocation();
        AcDbObjectId id = pEquip->GetBlock2d();
        csBlkName = GetBlkNameById(id);
    }
    OPENOBJ_END();    
    if(!ptLoc)
        return;
    csSldName = BlockName2SldName(csBlkName);
    CPoint ptDwgView;
    int cvport=0;
    VERIFY(xg_getvar(_T("CVPORT"), &cvport)==RTNORM);
    acedCoordFromWorldToPixel(cvport, ptLoc, ptDwgView);
    acedGetAcadDwgView()->ClientToScreen(&ptDwgView);
    CTemporaryResourceOverride vTemp;
    CSelectBlkDlg dlg;  
    dlg.m_csTkName = _T("TWTSYS");
    if(_tcsicmp(csBlkName, _T("$TwtSys$00000383")) == 0 || _tcsicmp(csBlkName, _T("$TwtSys$00000386")) == 0 || _tcsicmp(csBlkName, _T("$ATTACHMENT$00000086")) == 0 || _tcsicmp(csBlkName, _T("$ATTACHMENT$00000087")) == 0)
        dlg.m_csType = _T("消火栓");	
    else
        dlg.m_csType = _T("平面消火栓");
    dlg.m_ptBase = ptDwgView;
    dlg.m_staticSlide.m_csCurRecord = csSldName;
    if(dlg.DoModal() == IDOK){
        CString csRet = dlg.m_staticSlide.m_csCurRecord;
        XString xsTKName, xsRocord;
        SplitSlbName(csRet, xsTKName, xsRocord);
        XString xsBlk;
        LoadDwbBlock(xsTKName, xsRocord, xsBlk);
        AcDbObjectId recordId = GetBlkIdByName(xsBlk);
        for(long i=0;i<ss.Length();i++){
            Entity entTmp = ss[i];
            OPENOBJ_BEGIN(entTmp, AcDb::kForWrite, TDbEquipment, pEquip);
            if(pEquip){
                XPoint ptMid = pEquip->GetInsert();
                GetBlkRecordMidPt(xsBlk, pEquip->GetScale(), ptMid, pEquip->IsMirrorByY(), pEquip->GetAngle());
                pEquip->SetBlock2d(recordId);
                pEquip->SetLocation(ptMid);
            }
            OPENOBJ_END();    
        }
    }  
}

//***************************************************************************************************
//                                        系统消火栓
//***************************************************************************************************

void InsSysHydrant()
{
    CString csDwb = g_csDwbPath + _T("TwtSys");
    XString xsTmp1, xsTmp2;
    if(LoadDwbBlock(csDwb, _T("00000386"), xsTmp1) != RTNORM) 
        return;
    if(LoadDwbBlock(csDwb, _T("00000383"), xsTmp2) != RTNORM) 
        return;
    XPoint ptIns, ptLoc;
 
    double nPipeHorLength(600), nPipeVerLength(400);
    BOOL m_bMirror = FALSE;
    AcGeMatrix3d mat;
   
    InitLayer(LAY_EQUIP_HYDRANT);
    InitPipeLayer(LAY_PIPE_FIRE);
    xg_getvar(_T("VIEWCTR"), ptIns);
    ptIns = Wcs2Ucs(ptIns);
    g_csInsBlkName = xsTmp1;
    TBlockEdJig jig(g_csInsBlkName, ptIns, 1);
    int nOsMode=0;
    double nScale = 1;
	PickSet ss(SS_FREE);
    nOsMode |= OS_INT|OS_NEA|OS_MID;
    XPushVar<int> vOsMode(_T("OSMODE"), nOsMode);
    int iMode = 0; //0:平接管 1: 上接管 2: 不接管
    while(1){
		ss.Free();
        if(m_bMirror)
            nPipeHorLength = -fabs(nPipeHorLength);
        else
            nPipeHorLength = fabs(nPipeHorLength);
        if(iMode == 0)
            mat.setToTranslation(Ucs2Wcs(AcGeVector3d(nPipeHorLength, 0, 0)));
        else if(iMode == 1)
            mat.setToTranslation(Ucs2Wcs(AcGeVector3d(nPipeHorLength, nPipeVerLength, 0)));
        else
            mat.setToTranslation(Ucs2Wcs(AcGeVector3d(0, 0, 0)));
        jig.m_nSacle = nScale;
		jig.m_nSacleY = nScale;
        CString csPrompt;
        jig.m_bReversal = m_bMirror;
        jig.m_mat = mat;
        if(g_csInsBlkName == (const TCHAR*)xsTmp1)
			csPrompt = _T("\n请点取消火栓插入点[选择地面位置(W)/放大(E)/缩小(D)/左右翻转(F)/双栓(S)/平接管(1)/上接管(2)/不接管(3)]<完成>:");
        else
			csPrompt = _T("\n请点取消火栓插入点[选择地面位置(W)/放大(E)/缩小(D)/左右翻转(F)/单栓(S)/平接管(1)/上接管(2)/不接管(3)]<完成>:");
        
        jig.SetPrompt(csPrompt);
        jig.SetKeyword(_T("W E D F S 1 2 3"));
        int nKeyIndex = -1;
        int ret = jig.DoIt(&nKeyIndex);
        if(ret == RTKWORD){
			if (nKeyIndex == 0)
			{
				RBList rbMask = ads_buildlist( -4, _T("<or"),
					-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_PIPE_FIRE, -4, _T("and>"),  
					-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_PIPE_FIRE2, -4, _T("and>"),  
					-4, _T("<and"), RTDXF0, _T("ATS_PIPE"), 8, LAY_PIPE_FIRE3, -4, _T("and>"),  
					-4, _T("or>"), NULL);
				
				double nDist(1100);
				ads_getdist(NULL, _T("\n请输入消火栓距地面距离<1100>:"), &nDist);
				while (true)
				{
					if(ads_getpoint(NULL, _T("\n请点取消火栓所在地面位置:<退出>"), ptLoc) != RTNORM)
						return;
					GetPointPickSet(ptLoc, ss, rbMask, 20);
					ptIns = ptLoc;
					ptIns.y += nDist;
					ptIns = Ucs2Wcs(ptIns);
					ptLoc = Ucs2Wcs(ptLoc);
					
					if (ss.Length() > 0)
					{
						Entity entPipe = ss[0L];
						XPoint ptS,ptE;
						GetPipePoint(entPipe, ptS, ptE);
						ptS = Wcs2Ucs(ptS);
						ptE = Wcs2Ucs(ptE);
						AcGeVector3d vt = ptS - ptE;
						AcGeTol tol;
						tol.setEqualVector(0.1);
						if (vt.isParallelTo(AcGeVector3d::kYAxis, tol))
						{
							break;
						}
					}
				}
			}
            else if(nKeyIndex == 1)
                nScale += 0.5;
            else if(nKeyIndex == 2 && jig.m_nSacle > 0.5)
                nScale -= 0.5;
            else if(nKeyIndex == 3)
                m_bMirror = !m_bMirror; 
            else if(nKeyIndex == 4)
                g_csInsBlkName = g_csInsBlkName == (const TCHAR*)xsTmp1 ? xsTmp2 : xsTmp1;
            else if(nKeyIndex == 5)
                iMode = 0;
            else if(nKeyIndex ==6)
                iMode = 1;
            else if(nKeyIndex == 7)
                iMode = 2;

			if (nKeyIndex != 0)
			{
				continue;
			}
        }
        else if(ret != RTNORM)
            break;

		if (nKeyIndex != 0)
		{
			ptIns = jig.GetPickPoint();
			XPoint ptUcs = Wcs2Ucs(ptIns); 
			RBList rbMaskPipe(RTDXF0, _T("ATS_PIPE"), 8, GetLayerNames(_T("管")), NULL);
			GetPointPickSet(ptUcs, ss, rbMaskPipe, 20);
		}

		if(ss.Length() > 0){ //管件插入在管线上
			Entity entPipe = ss[0L];
			XPoint ptStart,ptEnd;
			CString sLayer;
			OPENOBJ_BEGIN(entPipe, AcDb::kForRead, TDbPipe, pPipe);
			if(pPipe != NULL)
			{
				sLayer = pPipe->GetLayer();
			}
			OPENOBJ_END();
			GetPipePoint(entPipe, ptStart, ptEnd);
			XCurveSegment seg(ptStart, ptEnd, 0);
			seg.ProjectToMe(ptIns, ptIns);
			double dAng = ads_angle(seg.GetEndPoint(), seg.GetStartPoint());

            XPoint ptend, ptPipe;
            int itype = -1;
            ads_prompt(_T("\n请选择插入方向<退出>"));
            while(1){
                struct resbuf pointbuf;
                int iRet = ads_grread(5, &itype, &pointbuf); 
                ads_point_set(pointbuf.resval.rpoint, ptend); 
                ptend = Ucs2Wcs(ptend);
                if(itype != 5 && itype != 3 && itype != 11)
                    break;

                AcGeVector3d vectBase(seg.EndPoint().x - seg.StartPoint().x, seg.EndPoint().y - seg.StartPoint().y, 0);
                AcGeVector3d vectTmp(ptend.x - ptIns.x, ptend.y - ptIns.y, 0);
                double dAng2 = vectBase.angleTo(vectTmp, AcGeVector3d::kZAxis);
                if(dAng2 < PI)
                    ads_polar(ptIns, dAng - PI/2, nPipeHorLength, ptPipe);
                else{
                    ads_polar(ptIns, dAng + PI/2, nPipeHorLength, ptPipe);
                }
                ads_redraw(NULL, 1); 
                if(itype == 3 || itype == 11){
					XPoint ptInsEq = ptPipe;
//					DrawSysPipeByLayer(ptIns, ptPipe, LAY_PIPE_FIRE);
//					TDbEquipment *pEquip = new TDbEquipment;
//					pEquip->SetBlock2d(GetBlkIdByName(g_csInsBlkName));
//					pEquip->SetHidePipe(TRUE);
//					pEquip->MirrorByY(m_bMirror);
//					pEquip->SetScale(nScale);
//					pEquip->setLayer(LAY_EQUIP_HYDRANT);
//					pEquip->setColor(AcCmColor()); //随层
//					pEquip->SetLocation(ptPipe);
//					AcDbObjectId id = AddToCurrentSpace(pEquip, Adesk::kTrue);

					if(iMode == 0){
						DrawSysPipeByLayer(ptIns, ptPipe, sLayer);
						ptInsEq = ptPipe;
					}
					else if(iMode == 1){
						mat.setToTranslation(Ucs2Wcs(AcGeVector3d(0, nPipeVerLength, 0)));
						XPoint ptTmp = ptPipe;   
						ptTmp.TransformBy(mat);
						ptInsEq = ptTmp;
						DrawSysPipeByLayer(ptIns, ptPipe, sLayer);
						DrawSysPipeByLayer(ptPipe, ptTmp, sLayer);
					}
					TDbEquipment *pEquip = new TDbEquipment;
					pEquip->SetBlock2d(GetBlkIdByName(g_csInsBlkName));
					pEquip->SetHidePipe(TRUE);
					pEquip->MirrorByY(m_bMirror);
					pEquip->SetScale(nScale);
					pEquip->setLayer(LAY_EQUIP_HYDRANT);
					pEquip->setColor(AcCmColor()); //随层
					pEquip->SetLocation(ptInsEq);
					AcDbObjectId id = AddToCurrentSpace(pEquip, Adesk::kTrue);

					AcGePoint3d ptIns2 = ptIns;
					OPENOBJ_BEGIN(ss[0L], AcDb::kForRead, TDbPipe, pPipe);
					if(pPipe){
						pPipe->getClosestPointTo(ptIns2, ptIns2);
					}
					OPENOBJ_END();
					
					if (nKeyIndex == 0)
					{
						TDbDimension2 *pDim = new TDbDimension2;
						pDim->setLayer(LAY_DIM);
						pDim->SetLocation(ptLoc);
						pDim->SetStyleId(InitDimStyle(DS_LINEAR));
						pDim->SetRotation(ads_angle(XPoint(ptIns2), ptLoc));
						pDim->AddSegment(ptIns2);
						
						TDimensionEdJig jig(pDim, _T("\n请点取尺寸线位置<退出>:"));
						jig.m_nFlag=1;
						if(jig.doIt() != RTNORM)
						{
							delete pDim;
							return;
						}
						AcDbObjectId idDim = pDim->AddToMSpace(Adesk::kTrue);
					}
					
                    break;
                }
                else{
                    XPoint ptTmpUcs1 = Wcs2Ucs(ptIns);
                    XPoint ptTmpUcs2 = Wcs2Ucs(ptPipe);
                    ads_grdraw(ptTmpUcs1, ptTmpUcs2, -1, 0); 
                }
				
            }
		}
		else{//自由插入
			ptIns.TransformBy(jig.m_mat);
			TDbEquipment *pEquip = new TDbEquipment;
			pEquip->SetBlock2d(GetBlkIdByName(g_csInsBlkName));
			pEquip->SetHidePipe(TRUE);
			pEquip->MirrorByY(m_bMirror);
			pEquip->SetScale(nScale);
			pEquip->setLayer(LAY_EQUIP_HYDRANT);
			pEquip->setColor(AcCmColor()); //随层
			pEquip->SetLocation(ptIns);
			AcDbObjectId id = AddToCurrentSpace(pEquip, Adesk::kTrue);
			if(iMode == 0)
				DrawSysPipeByLayer(ptIns, jig.GetPickPoint(), LAY_PIPE_FIRE);
			else if(iMode == 1){
				mat.setToTranslation(AcGeVector3d(nPipeHorLength, 0, 0));
				XPoint ptTmp = jig.GetPickPoint();   
				ptTmp.TransformBy(mat);
				DrawSysPipeByLayer(ptIns, ptTmp, LAY_PIPE_FIRE);
				DrawSysPipeByLayer(ptTmp, jig.GetPickPoint(), LAY_PIPE_FIRE);
			}
		}
    }  
    g_nInsBlkRotate = 0;
}
  
//***************************************************************************************************
//                                        编辑雨水斗
//*************************************************************************************************** 
// cet 2010.10.27 add 
int EditWaterBucket(AcDbObjectId id)
{
	if (!id)
	{
		return RTERROR;
	}

	ads_name name;
	acdbGetAdsName(name, id);
	Entity ent(name);
	CString strDia;
	strDia = ReadXdata(ent, _T("PipeDia"));
	TCHAR szBlkName[256];
	ent.GetData(2, szBlkName);
	
	double dEle = 0.0, dSize = 0.0;
	TDbEquipment *pEquip = NULL;
	acdbOpenObject(pEquip, id, AcDb::kForRead);
	if (pEquip != NULL)
	{
		XPoint pt = pEquip->GetLocation();
		dEle = pt.z;
		dSize = pEquip->GetScale() / DocGetPScale();
		pEquip->close();
	}

	if (!DocGetMeterUnitDraw())
	{
		dEle /= 1000;
	}
	CString strSize, strEle;
	strEle.Format(_T("%f"), dEle);
	if (strEle.Find(_T(".")) != -1)
	{
		strEle.TrimRight(_T("0"));
		strEle.TrimRight(_T("."));
	}
	strSize.Format(_T("%f"), dSize);
	if (strSize.Find(_T(".")) != -1)
	{
		strSize.TrimRight(_T("0"));
		strSize.TrimRight(_T("."));
	}


	CTemporaryResourceOverride vTemp;
	CEditWaterBucketDlg dlg;
	dlg.SetPipeDia(_tstof(strDia));
	dlg.SetEle(_tstof(strEle));
	dlg.SetSize(_tstof(strSize));
	dlg.SetBlkName(szBlkName);
	if (dlg.DoModal() == IDOK)
	{
		CString csBlkName = dlg.GetBlkName();
		CString csTK, csRecord;
		SplitBlkStr(csBlkName, csTK, csRecord);
		XString xsTmp;
		if(LoadDwbBlock((const TCHAR*)csTK, (const TCHAR*)csRecord, xsTmp) != RTNORM) 
		{
			return 1;
		}

		TDbEquipment *pEquip = NULL;
		acdbOpenObject(pEquip, id, AcDb::kForWrite);
		if (pEquip != NULL)
		{
			double dEle = dlg.GetEle();
			if (!DocGetMeterUnitDraw())
			{
				dEle *= 1000;
			}
			XPoint pt = pEquip->GetLocation();
			pt.z = dEle;
			pEquip->SetLocation(pt);
			pEquip->SetBlock2d(GetBlkIdByName(csBlkName));
			pEquip->SetScale(dlg.GetSize() * DocGetPScale());
			pEquip->close();
		}

		strDia.Format(_T("%.3f"), dlg.GetPipeDia());
		strEle.Format(_T("%.3f"), dlg.GetEle());
		strSize.Format(_T("%.3f"), dlg.GetSize());
		WriteXdata(ent, _T("PipeDia"), strDia);
	}

	return 1;
}

//***************************************************************************************************
//                                        翻转消火栓
//***************************************************************************************************
void ReversalHydrant()
{
    RBList rbMask(RTDXF0, _T("ATS_EQUIPMENT"), 8, LAY_EQUIP_HYDRANT, NULL);
    Entity ent;
    XPushVar<int> vOsMode3(_T("OSMODE"), 0);
	if(SelectEntity(_T("\n请选择要翻转的消火栓:<退出>"), ent, rbMask) == RTNORM){
        XPoint ptCen, pt1, pt2;
        ent.GetExtend(pt1, pt2);
        XLine line(pt1, pt2, 1);
        line.MidPoint(ptCen);
        XPoint ptUcs = Wcs2Ucs(ptCen);
        SHads_command(RTSTR,_T("_rotate"), RTENAME, (TLong_ptr*)ent, RTSTR, _T(""), RT3DPOINT, &ptUcs, RTREAL, 180.0, RTNONE);
    }
    
}

//***************************************************************************************************
//                                        编辑消火栓
//***************************************************************************************************
int EditHydrant(AcDbObjectId id)
{
    if(!id)
        return RTERROR;
    CTemporaryResourceOverride vTemp;
    CHydrantPlanDlg dlg(1);
    ads_name ent;
    acdbGetAdsName(ent, id);
    dlg.m_csRadius = ReadXdata(ent, _T("HYDRANT_RADIUS"));
    const TCHAR *szBlkName = NULL;
    CString csDwb = g_csDwbPath + _T("TwtSys");    
    XString xsTmp6, xsTmp7;
    
    OPENOBJ_BEGIN(id, AcDb::kForRead, TDbEquipment, pEquip);
    if(pEquip){
        double nLen = pEquip->GetPipeLength();
        if(nLen > 0)
            dlg.m_iMode = 0;
        else
            dlg.m_iMode = 1;
        OPENOBJ_BEGIN(pEquip->GetBlock2d(), AcDb::kForRead, AcDbBlockTableRecord, pRecord);
        if(pRecord){
            pRecord->getName(szBlkName);
        }
        OPENOBJ_END();
        dlg.m_csInsBlkName = szBlkName;
        XPoint ptLoc = pEquip->GetLocation();
        dlg.m_dEle = ptLoc.z / 1000;
		dlg.SetScale(pEquip->GetScale(), pEquip->GetYScale());
    }
    OPENOBJ_END();
    if(dlg.DoModal() != IDOK)
        return 1;
   
    if(g_bBlk3D){
        if(LoadDwbBlock(csDwb, _T("00000441"), xsTmp6) != RTNORM) 
            return 1;
        if(LoadDwbBlock(csDwb, _T("00000442"), xsTmp7) != RTNORM) 
            return 1;
    }
    
    OPENOBJ_BEGIN(id, AcDb::kForWrite, TDbEquipment, pEquip);
    if(pEquip){
		pEquip->SetScale(dlg.m_dScaleX);
		pEquip->SetYScale(dlg.m_dScaleY);

        pEquip->SetBlock2d(GetBlkIdByName(dlg.m_csInsBlkName));
		if(_tcsicmp(dlg.m_csInsBlkName, szBlkName) != 0)
			pEquip->SetSysBlock(dlg.m_csSysBlk);
        XPoint ptLoc = pEquip->GetLocation();
		pEquip->SetAutoScale(dlg.m_bAutoScale);
        ptLoc.z = dlg.m_dEle*1000;
        pEquip->SetLocation(ptLoc);
        if(dlg.m_bMirrorByX){
            pEquip->MirrorByY(!pEquip->IsMirrorByY());
        }
         if(dlg.m_iMode == 0){
             pEquip->SetPipeLength(250);//上
             pEquip->SetBlock3d(GetBlockIdFromString(xsTmp6));
         }
         else{
             pEquip->SetPipeLength(0);  //平
             pEquip->SetBlock3d(GetBlockIdFromString(xsTmp7));
         }
    }
    OPENOBJ_END();
    
    WriteXdata(ent, _T("HYDRANT_RADIUS"), dlg.m_csRadius);
    if(dlg.m_bMirrorByY){
        Entity entTmp = ent;
        g_ssPickFirst.Free();
        g_ssPickFirst += entTmp;
        ReversalHydrant();
    }
    return 1;
}

void EditHydrantCmd()
{
	g_ssPickFirst.Free();
	RBList rbMask(RTDXF0, _T("ATS_EQUIPMENT"), 8, LAY_EQUIP_HYDRANT, NULL);
	PickSet ss(SS_FREE);
	if(SelectEntities(_T("\n请选择要修改的消火栓<退出>"), ss, rbMask) != RTNORM)
		return;
	long len = ss.Length();
	if(len < 1)
		return;
	
    CTemporaryResourceOverride vTemp;
    CHydrantPlanDlg dlg(1);
	dlg.m_csInsBlkName = _T("");
	dlg.m_iMode = -1;
	
    if(dlg.DoModal() != IDOK)
        return;
   
    CString csDwb = g_csDwbPath + _T("TwtSys");    
    XString xsTmp6, xsTmp7;
    if(g_bBlk3D){
        if(LoadDwbBlock(csDwb, _T("00000441"), xsTmp6) != RTNORM) 
            return;
        if(LoadDwbBlock(csDwb, _T("00000442"), xsTmp7) != RTNORM) 
            return;
    }
	XPushVar<int> vOsMode(_T("OSMODE"), 0);			
	for(long i=0;i<len;i++){
		Entity entTmp = ss[i];
		
		OPENOBJ_BEGIN(entTmp, AcDb::kForWrite, TDbEquipment, pEquip);
		if(pEquip){
			if(dlg.m_dScaleX > 0.1 && dlg.m_dScaleY > 0.1){
				pEquip->SetScale(dlg.m_dScaleX);
				pEquip->SetYScale(dlg.m_dScaleY);
			}
			AcDbObjectId idRec = GetBlkIdByName(dlg.m_csInsBlkName);
			if(idRec != NULL){
				pEquip->SetBlock2d(idRec);
				pEquip->SetSysBlock(dlg.m_csSysBlk);
			}

			pEquip->SetAutoScale(dlg.m_bAutoScale);
			XPoint ptLoc = pEquip->GetLocation();
			ptLoc.z = dlg.m_dEle*1000;
			pEquip->SetLocation(ptLoc);
			if(dlg.m_bMirrorByX){
				pEquip->MirrorByY(!pEquip->IsMirrorByY());
			}
			if(dlg.m_iMode == 0){
				pEquip->SetPipeLength(250);//上
				pEquip->SetBlock3d(GetBlockIdFromString(xsTmp6));
			}
			else if(dlg.m_iMode == 1){
				pEquip->SetPipeLength(0);  //平
				pEquip->SetBlock3d(GetBlockIdFromString(xsTmp7));
			}
		}
		OPENOBJ_END();
    
		WriteXdata(entTmp, _T("HYDRANT_RADIUS"), dlg.m_csRadius);
		if(dlg.m_bMirrorByY){//黑白翻转
			XPoint ptCen, pt1, pt2;
			entTmp.GetExtend(pt1, pt2);
			XLine line(pt1, pt2, 1);
			line.MidPoint(ptCen);
			ptCen.z = 0;
			XPoint ptUcs = Wcs2Ucs(ptCen);
			SHads_command(RTSTR,_T("_rotate"), RTENAME, (TLong_ptr*)entTmp, RTSTR, _T(""), RT3DPOINT, &ptUcs, RTREAL, 180.0, RTNONE);
		}
	}
	 
    return;
}


//***************************************************************************************************
//                                        平面消火栓
//***************************************************************************************************

// 两条线相互投影，取共有的长度
void GetShortCurve(XCurveSegment &curve1, XCurveSegment &curve2)
{
	XPoint ptS1 = curve1.GetStartPoint();
	XPoint ptS2 = curve2.GetStartPoint();
	XPoint ptE1 = curve1.GetEndPoint();
	XPoint ptE2 = curve2.GetEndPoint();

	XPoint pt;
	if (curve1.PathDistance(ptS2) < 0.001 && curve2.PathDistance(ptS1) > 0.001)
	{
		curve2.ProjectToMe(ptS1, pt);
		curve2.SetStartPoint(pt);
	}
	else if (curve1.PathDistance(ptS2) > 0.001 && curve2.PathDistance(ptS1) < 0.001)
	{
		curve1.ProjectToMe(ptS2, pt);
		curve1.SetStartPoint(pt);
	}

	if (curve1.PathDistance(ptE2, 0) > 0.001 && curve2.PathDistance(ptE1, 0) < 0.001)
	{
		curve1.ProjectToMe(ptE2, pt);
		curve1.SetEndPoint(pt);
	}
	else if (curve1.PathDistance(ptE2, 0) < 0.001 && curve2.PathDistance(ptE1, 0) > 0.001)
	{
		curve2.ProjectToMe(ptE1, pt);
		curve2.SetEndPoint(pt);
	}
}

XCurveSegment GetOtherWallSegByPt(XPoint ptPick, Entity entWall, AcGeMatrix3d mat)
{
	XCurveSegment seg;
	if(entWall.Is(_T("ATS_WALL"))){
		OPENOBJ_BEGIN(entWall, AcDb::kForRead, TDbWall, pWall);
		XCurveSegment lCurve, rCurve;
		XPoint ptNew1, ptNew2;
		if(pWall) {
			pWall->GetSideCurve(lCurve, rCurve);
			double dBulge = lCurve.GetBulge();
			AcGePoint3d ptStart = lCurve.StartPoint();
			ptStart = ptStart.transformBy(mat);
			AcGePoint3d ptEnd = lCurve.EndPoint();
			ptEnd = ptEnd.transformBy(mat);
			XLine line(asDblArray(ptStart), asDblArray(ptEnd), 1);
			lCurve = line;
			lCurve.SetBulge(dBulge);
			
			dBulge = rCurve.GetBulge();
			ptStart = rCurve.StartPoint();
			ptStart = ptStart.transformBy(mat);
			ptEnd = rCurve.EndPoint();
			ptEnd = ptEnd.transformBy(mat);
			XLine line2(asDblArray(ptStart), asDblArray(ptEnd), 1);
            rCurve = line2;
			rCurve.SetBulge(dBulge);

			GetShortCurve(lCurve, rCurve);
			lCurve.ProjectToMe(ptPick, ptNew1);
			rCurve.ProjectToMe(ptPick, ptNew2);
			if(ads_distance(ptPick, ptNew1) < ads_distance(ptPick, ptNew2))
				seg = rCurve;
			else
				seg = lCurve;
		}
		OPENOBJ_END();
	}
	return seg;
}

bool IsEntInBlk(Entity ent, Entity entBlk)
{
	AcDbObjectId idEnt;
	acdbGetObjectId(idEnt, ent);
	OPENOBJ_BEGIN(entBlk, AcDb::kForRead, AcDbBlockReference, pEnt);
	if(pEnt != NULL)
	{
		XPoint ptIns;
		AcDbObjectId idRecord = pEnt->blockTableRecord();
		OPENOBJ_BEGIN(idRecord,AcDb::kForRead,AcDbBlockTableRecord,pRec);
		if (pRec != NULL)
		{
			AcDbBlockTableRecordIterator *pIter = NULL;
			pRec->newIterator(pIter);
			
			if (pIter != NULL)
			{
				for (pIter->start();!pIter->done();pIter->step())
				{
					AcDbObjectId id;
					pIter->getEntityId(id);
					if (id == idEnt)
					{
						return true;
					}
				}
				delete pIter;
			}
		}
		OPENOBJ_END();
	}
	OPENOBJ_END();
	return false;
}

//选取外部参照上1根曲线
XCurveSegment GetExternalBlockSeg2(Entity &entBlk, XPoint &ptPick, AcGeMatrix3d &mat)
{
    XBlock myBlock(entBlk);
    if(!myBlock.m_bInitSuccess)
        return XCurveSegment();

	mat = myBlock.GetMatrix3d();
    XCurveSegment seg;
    XPoint 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;
			entBlk = ent;
			ptResult = Ucs2Wcs(ptResult);
            if(entTemp.Is(_T("LINE"))){
                ptPick = ptResult;
                XCurveSegment seg2(entTemp);
                AcGePoint3d ptStart = seg2.StartPoint();
                ptStart = ptStart.transformBy(*(AcGeMatrix3d*)xformres);
                AcGePoint3d ptEnd = seg2.EndPoint();
                ptEnd = ptEnd.transformBy(*(AcGeMatrix3d*)xformres);
                XLine line(asDblArray(ptStart), asDblArray(ptEnd), 1);
                seg = line;
                return seg;
            }
            else if(entTemp.Is(_T("ATS_WALL"))){
                OPENOBJ_BEGIN(entTemp, AcDb::kForRead, TDbWall, pWall);
                XCurveSegment lCurve, rCurve;
                XPoint ptNew1, ptNew2;
                if(pWall) {
                    ptPick = ptResult;
                    pWall->GetSideCurve(lCurve, rCurve);
					AcGePoint3d ptStart = lCurve.StartPoint();
                    ptStart = ptStart.transformBy(*(AcGeMatrix3d*)xformres);
                    AcGePoint3d ptEnd = lCurve.EndPoint();
                    ptEnd = ptEnd.transformBy(*(AcGeMatrix3d*)xformres);
                    XLine line(asDblArray(ptStart), asDblArray(ptEnd), 1);
                    lCurve = line;

					ptStart = rCurve.StartPoint();
                    ptStart = ptStart.transformBy(*(AcGeMatrix3d*)xformres);
                    ptEnd = rCurve.EndPoint();
                    ptEnd = ptEnd.transformBy(*(AcGeMatrix3d*)xformres);
                    XLine line2(asDblArray(ptStart), asDblArray(ptEnd), 1);
                    rCurve = line2;

                    lCurve.ProjectToMe(ptPick, ptNew1);
                    rCurve.ProjectToMe(ptPick, ptNew2);
                    if(ads_distance(ptPick, ptNew1) < ads_distance(ptPick, ptNew2))
                        seg = lCurve;
                    else
                        seg = rCurve;
                    return seg;
                }
                OPENOBJ_END();
            }
			else if(entTemp.Is(_T("LWPOLYLINE"))){// zxl 2014.01.15 add 支持外部参照的PLINE线
				ptPick = ptResult;
				OPENOBJ_BEGIN(entTemp, AcDb::kForRead, AcDbPolyline, pLine);
                if(pLine) {
                    ptPick = ptResult;
					double dDist = 0.0;
					for (int i = 0; i < pLine->numVerts(); i++)
					{
						XCurveSegment segNew;
						AcGePoint3d ptStart;
						pLine->getPointAt(i, ptStart);
						ptStart = ptStart.transformBy(*(AcGeMatrix3d*)xformres);
						AcGePoint3d ptEnd;
						pLine->getPointAt(i + 1, ptEnd);
						// zxl 2014.02.10 add
						if (pLine->isClosed() && i == pLine->numVerts() - 1)
						{
							pLine->getPointAt(0, ptEnd);
						}
						ptEnd = ptEnd.transformBy(*(AcGeMatrix3d*)xformres);
						XLine line(asDblArray(ptStart), asDblArray(ptEnd), 1);
						segNew = line;
						double dDistNew = segNew.GetDist2Me(ptPick);
						if (i == 0 || fabs(dDistNew) < fabs(dDist))
						{
							dDist = dDistNew;
							seg = segNew;
						}
					}
                    return seg;
                }
                OPENOBJ_END();
			}
        }
        else
            break;
    }
    return seg;
}

XCurveSegment GetEntitySegByPt(XPoint &ptPick, Entity &entWall, AcGeMatrix3d &mat)
{
	XCurveSegment seg;
	if(entWall.Is(_T("ATS_WALL"))){
		OPENOBJ_BEGIN(entWall, AcDb::kForRead, TDbWall, pWall);
		XCurveSegment lCurve, rCurve;
		XPoint ptNew1, ptNew2;
		if(pWall) {
			pWall->GetSideCurve(lCurve, rCurve);
			GetShortCurve(lCurve, rCurve);
			lCurve.ProjectToMe(ptPick, ptNew1);
			rCurve.ProjectToMe(ptPick, ptNew2);
			if(ads_distance(ptPick, ptNew1) < ads_distance(ptPick, ptNew2))
				seg = lCurve;
			else
				seg = rCurve;
		}
		OPENOBJ_END();
	}
	else if(entWall.Is(_T("ATS_COLUMN"))){
		OPENOBJ_BEGIN(entWall, AcDb::kForRead, TDbColumn, pColumn);
		if(pColumn){
			XPoly2D poly(1);
			pColumn->GetOutline(poly);
			int nSeg = poly.TotalSegments();
			for(int j=0; j<nSeg; j++) {
				XCurveSegment segTmp;
				poly.Nth(j, segTmp);
				int nPrFlag=(ptPick&segTmp);
				if(nPrFlag==PR_INSIDE || nPrFlag==PR_ONPT1 || nPrFlag==PR_ONPT2) {
					seg = segTmp;
					break;
				}
			}
		}
		OPENOBJ_END();
	}
	else if(entWall.Is(_T("INSERT")) && IsExternalBlock(entWall)){
		seg = GetExternalBlockSeg2(entWall, ptPick, mat);// seg = GetBlkPickSeg(entWall, ptPick);
		seg.ProjectToMe(ptPick, ptPick);
		if(!seg)
			return seg;
	}
	else if(entWall.Is(_T("LWPOLYLINE"))){
		double dAngle;
		seg = GetSegByPt(XPoly2D(entWall), ptPick, dAngle);
	}
	else
		seg = XCurveSegment(entWall);
	return seg;
}

bool IsHydrantNear2Seg(Entity &ent, XCurveSegment seg)
{
	bool bRet = false;
	double dLenMin = 0.0, dLenMax = 0.0, dLenMid = 0.0;
	seg.SetElevation(0.0);
	OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbEquipment, pEquip);
    if(pEquip != NULL)
	{
        AcDbVoidPtrArray entSet;
        pEquip->explode(entSet);
        for(int i=0;i<1;i++)
		{
            AcDbEntity *pEnt = (AcDbEntity *)entSet[i];
            AcDbBlockReference *pBlkRef = NULL;
            if(pBlkRef = AcDbBlockReference::cast(pEnt))
			{
				XPoint ptIns;
				AcGeScale3d scRef;
				AcDbVoidPtrArray entSet2;
				AcDbObjectId idRecord = pBlkRef->blockTableRecord();
				OPENOBJ_BEGIN(idRecord,AcDb::kForRead,AcDbBlockTableRecord,pRec);
				if (pRec != NULL)
				{
					AcDbBlockTableRecordIterator *pIter = NULL;
					pRec->newIterator(pIter);
					
					if (pIter != NULL)
					{
						AcDbObjectId idEnt;
						for (pIter->start();!pIter->done();pIter->step())
						{
							pIter->getEntityId(idEnt);
							AcDbEntity *pEnt1 = NULL;
							acdbOpenObject(pEnt1, idEnt, AcDb::kForWrite);
							AcDbBlockReference *pBlkRef1 = NULL;
							if (pBlkRef1 = AcDbBlockReference::cast(pEnt1))
							{
								ptIns = pBlkRef->position();
								scRef = pBlkRef->scaleFactors();
								double dRotat = pBlkRef->rotation();

								AcDbBlockReference *pBlkRef2 = (AcDbBlockReference *)pBlkRef1->clone();
								pBlkRef2->setScaleFactors(scRef);
								AcGeVector3d vt = ptIns - XPoint();
								AcGeMatrix3d mat;
								mat.setToTranslation(vt);
								pBlkRef2->transformBy(mat);
								pBlkRef2->setRotation(dRotat);

								pBlkRef2->explode(entSet2);
								if (pBlkRef2 != NULL)
								{
									delete pBlkRef2;
									pBlkRef2 = NULL;
								}
							}
							pEnt1->close();
						}
						delete pIter;
					}
				}
				OPENOBJ_END();

				int len = entSet2.length();
                if (len == 0)
                {
					pBlkRef->explode(entSet2);
                }
                len = entSet2.length();
                for(int j=0;j<len;j++)
				{
                    AcDbEntity *pEnt2 = (AcDbEntity *)entSet2[j];
                    AcDbLine *pLine = NULL;
                    if(pLine = AcDbLine::cast(pEnt2))
					{
						XPoint pS = pLine->startPoint();
                        XPoint pE = pLine->endPoint();
                        pS.z = 0;
                        pE.z = 0;
						XPoint ptMid;
						Midpoint(pS, pE, ptMid);
						double dLenS = seg.GetDist2Me(pS);
						double dLenE = seg.GetDist2Me(pE);
						double dLenM = seg.GetDist2Me(ptMid);
						if (fabs(seg.GetBulge()) < 0.001 && fabs(dLenE) < 0.001 && fabs(dLenS) < 0.001)
						{
							bRet = true;
						}
						else if (fabs(seg.GetBulge()) > 0.001 && fabs(dLenM) < 0.001)
						{
							bRet = true;
						}
                    }
                }
                ReleaseEntSet(entSet2);
            }
			
        }
        ReleaseEntSet(entSet);
    }
    OPENOBJ_END();
	return bRet;
}

XPoint GetNearestEntPt(XPoint ptPick, XCurveSegment seg)
{
	XPoint ptS = seg.GetStartPoint();
	XPoint ptE = seg.GetEndPoint();

	RBList rbMask(RTDXF0, _T("ATS_EQUIPMENT"), 8, LAY_EQUIP_HYDRANT, NULL);
	PickSet ss(SS_FREE);
	XPoint ptUcs = Wcs2Ucs(ptPick);
	
	// 设置外包框大小
	int nLen = 0.0;
	double dLen1 = ptPick.Distance2d(ptS);
	double dLen2 = ptPick.Distance2d(ptE);
	nLen = dLen1 > dLen2 ? dLen1 : dLen2;
	double dLenMin = dLen1 > dLen2 ? dLen2 : dLen1;
	XPoint ptRet = dLen1 > dLen2 ? ptE : ptS;
	
	GetPointPickSet(ptUcs, ss, rbMask, nLen);
	for (long i = 0; i < ss.Length(); i++)
	{
		Entity ent = ss[i];
		XPoint pt1;
		OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbEquipment, pEquip);
		if(pEquip)
		{
			pt1 = pEquip->GetLocation();
			seg.ProjectToMe(pt1, pt1);
			if (IsHydrantNear2Seg(ent, seg) && pt1.Distance2d(ptPick) < dLenMin)
			{
				ptRet = pt1;
				dLenMin = pt1.Distance2d(ptPick);
			}
		}
		OPENOBJ_END();
	}
	return ptRet;
}

void InsPlanHydrant()
{
	int nOsMode=0;
    xg_getvar(_T("OSMODE"), &nOsMode);
    nOsMode &= ~0x4000;   
    nOsMode |= OS_INT|OS_NEA;
    XPushVar<int> vOsMode(_T("OSMODE"), nOsMode);
    CString csDwb = g_csDwbPath + _T("TwtSys");
    XString xsTmp1, xsTmp6, xsTmp7, xsTmp0;
    if(LoadDwbBlock(csDwb, _T("00000434"), xsTmp1) != RTNORM) 
        return;
	xsTmp0 = xsTmp1;
   
    if(g_bBlk3D){
        if(LoadDwbBlock(csDwb, _T("00000441"), xsTmp6) != RTNORM) 
            return;
        if(LoadDwbBlock(csDwb, _T("00000442"), xsTmp7) != RTNORM) 
            return;
    }
	CHydrantPlanDlg dlg(0, acedGetAcadFrame());  
	if(dlg.m_csInsBlkName == _T(""))
		dlg.m_csInsBlkName = xsTmp1;
	else{
        CString csTKName, csRocord;
        SplitBlkStr(dlg.m_csInsBlkName, csTKName, csRocord);
        LoadDwbBlock(csTKName, csRocord, xsTmp1);
	}

	
    {
		CTemporaryResourceOverride vTemp;
		dlg.Create(IDD_HYDRANT_PLAN, acedGetAcadFrame());
		dlg.ShowWindow(SW_SHOW);
		acedGetAcadDwgView()->SetFocus();
	}

 
	InitLayer(LAY_EQUIP_HYDRANT);
	g_nInsBlkRotate = 0;

	RBList rbMask = ads_buildlist( -4, _T("<or"), RTDXF0, _T("INSERT"), RTDXF0, _T("LWPOLYLINE"), RTDXF0, _T("LINE"), RTDXF0, _T("ARC"),  RTDXF0, _T("ATS_WALL"), RTDXF0, _T("ATS_COLUMN"),
               -4, _T("or>"),  NULL);

	PickSet ssAll(SS_FREE);
	RBList rbMask2(RTDXF0, _T("ATS_EQUIPMENT"), 8, LAY_EQUIP_HYDRANT, NULL);
	ssAll.Get(_T("X"),NULL,NULL, rbMask2);
	PickSet ssDel(SS_FREE);
	std::map<XPoint,double> mapData; // cet 2010.6.23 add
	ssDel.IncludeBegin();
	for(long j=0;j<ssAll.Length();j++)
	{
		Entity entTmp = ssAll[j];
		XPoint ptPick;
		CString csRadius = ReadXdata(entTmp, _T("HYDRANT_RADIUS"));
		OPENOBJ_BEGIN(entTmp, AcDb::kForRead, TDbEquipment, pEquip);
		if(pEquip){
			ptPick = pEquip->GetLocation();
		}
		OPENOBJ_END();
	
		// cet 2010.6.23 add
		mapData.insert(std::make_pair(ptPick,_tstof(csRadius)*1000));
		if (!dlg.IsShowCircle())
		{
			continue;
		}

		XCircle cir(ptPick, _tstof(csRadius)*1000);
		cir.Make();
	}
	ssDel.IncludeEnd();
	


	XPoint ptPick;
	Entity entWall;
    BOOL bFree = TRUE;
//  cet 2010.6.23 del
//	while(SelectEntity1(0.3, _T("\n请拾取布置消火栓的外部参照、墙线、柱子、直线、弧线 <退出>"), entWall, ptPick, rbMask) == RTNORM){
	// cet 2010.6.23 add
	PickSet ssNew(SS_FREE); // 保存新插入的保护圆
	// 对话框选择布置方式 郑晓龙2014.01.10 modify
	double dMeter = 1000.0;
	if (DocGetMeterUnitDraw())
	{
		dMeter = 1.0;
	}
	bool bRet = false;
	bool bBlk = false;
	while(!bRet)
	{
		dlg.UpdateData(TRUE);
		if (dlg.m_iPlanType == 0)
		{
			int nRet(0);
			if (!bBlk)
			{
				INITGET_BEG(0, _T("R "));
				nRet = SelectEntity1(0.3, _T("\n请拾取布置消火栓的外部参照、墙线、柱子、直线、弧线 <退出>"), entWall, ptPick, rbMask);
				INITGET_END();
				if (nRet != RTNORM && nRet != RTKWORD)
				{
					break;
				}
			}

			ssDel.Erase();
			ssDel.Free();
			dlg.UpdateData();
			if (dlg.IsShowCircle()) 
			{
				std::map<XPoint,double>::iterator it;
				for(it = mapData.begin(); it != mapData.end(); it++)
				{
					XCircle cir((*it).first, (*it).second);
					cir.Make();
					Entity entCir;
					entCir.GetLast();
					ssDel += entCir;
				}
			}

			if (nRet == RTKWORD)
			{
				continue;
			}

			ptPick = Ucs2Wcs(ptPick);
			bFree = FALSE;
			dlg.UpdateData();
			g_csInsBlkName = dlg.m_csInsBlkName;

			if(entWall.Is(_T("INSERT")) && IsExternalBlock(entWall))
			{
				bBlk = true;
			}
			Entity entBlk = entWall;

			XCurveSegment seg; // 得到点所在的线段
			AcGeMatrix3d mat;
			seg = GetEntitySegByPt(ptPick, entWall, mat);
			if(!seg)
				break;
			entWall = entBlk;

			g_nInsBlkRotate = GetInsRotate(ptPick, seg);
		 
			AcGeVector3d vect;
			vect.x = cos(g_nInsBlkRotate);
			vect.y = sin(g_nInsBlkRotate);
			vect.z = 0;
			BOOL m_bMirror = FALSE;
			double nScale = 1;
	//        if(g_bEquipByScale)
	 //           nScale = DocGetPScale()/100;
        
			BOOL bCancel = FALSE;
			double nWidth(0), nHeight(0);
			double dScaleX(0), dScaleY(0);

			XCircle cir(ptPick, _tstof(dlg.m_csRadius)*1000);
			cir.Make();
			Entity entCir;
			entCir.GetLast();
	//		ssDel+= entCir;  // cet 2010.6.23 del
			ssNew += entCir; // cet 2010.6.23 add
		 
			
			while(1){
				dlg.UpdateData();
				dlg.GetScale(dScaleX, dScaleY);
				
				double dScaleMater = dlg.m_bAutoScale ? DocGetPScale() / 100 : 1;
				GetBlkRecordWidth(xsTmp0, dScaleX * dScaleMater, dScaleY * dScaleMater, nWidth, nHeight);
			//	TBlockEdJig jig(g_csInsBlkName, ptPick, 1, vect, nWidth*DocGetPScale()/100.0 + dlg.m_iDist);
				TBlockEdJig jig(g_csInsBlkName, ptPick, 1, vect, nWidth + dlg.m_iDist);
				jig.m_nSacle = dScaleX * dScaleMater;
				jig.m_nSacleY = dScaleY * dScaleMater;
	//			jig.m_nSacle = dScaleX*(DocGetPScale()/100.0);
	//			jig.m_nSacleY = dScaleY*(DocGetPScale()/100.0);
				jig.SetPrompt(_T("\n请指定附件的插入方向<完成>:"));
				int nKeyIndex = 0;
				int nRetCode = jig.DoIt(&nKeyIndex);
				if(nRetCode == RTNORM){
					if(jig.m_iQuadrant == 2 || jig.m_iQuadrant == 3){
						g_nInsBlkRotate += PI;
					}
					if(jig.m_iQuadrant == 1 || jig.m_iQuadrant == 3){
						m_bMirror = TRUE;
					}
					ptPick = jig.m_ptRetIns;
					break;
				}
				else{
					bCancel = TRUE;
					ssNew -= entCir; // cet 2010.7.9 add  当前消火栓布置取消时其保护半径应删除
					entCir.Erase();  // cet 2010.7.9 add
					break;
				}
			}
		//	entCir.Erase();
      
			if(bCancel){
				continue;
			}

			dlg.UpdateData();
			dlg.GetScale(dScaleX, dScaleY);
			
			TDbEquipment *pEquip = new TDbEquipment;
			pEquip->SetBlock2d(GetBlkIdByName(g_csInsBlkName));
			pEquip->SetInsert(ptPick);
			pEquip->SetHidePipe(TRUE);
			pEquip->SetScale(dScaleX);
			pEquip->SetYScale(dScaleY);
			pEquip->SetAutoScale(dlg.m_bAutoScale);
			pEquip->MirrorByY(m_bMirror);
			double dAngle = g_nInsBlkRotate;
			pEquip->SetAngle(dAngle);
			if(dlg.m_iMode == 0){
				pEquip->SetPipeLength(250);//上
				pEquip->SetBlock3d(GetBlockIdFromString(xsTmp6));
			}
			else
				pEquip->SetBlock3d(GetBlockIdFromString(xsTmp7));
			pEquip->SetSysBlock((const TCHAR*)dlg.m_csSysBlk);
			pEquip->setLayer(LAY_EQUIP_HYDRANT);
			pEquip->setColor(AcCmColor()); //随层
			pEquip->SetLocation(ptPick);
			AcDbObjectId id = AddToCurrentSpace(pEquip, Adesk::kTrue);
			Entity entLast;
			entLast.GetLast();
			WriteXdata(entLast, _T("HYDRANT_RADIUS"), dlg.m_csRadius);
		}
		else if (dlg.m_iPlanType == 1)
		{
	//	if(bFree){ //任意布置
	//		PickSet ssAll(SS_FREE);
	//		RBList rbMask2(RTDXF0, _T("ATS_EQUIPMENT"), 8, LAY_EQUIP_HYDRANT, NULL);
	//		ssAll.Get(_T("X"),NULL,NULL, rbMask2);
	//		PickSet ssDel(SS_FREE);
	//		ssDel.IncludeBegin();
	//		for(long j=0;j<ssAll.Length();j++)
	//		{
	//			Entity entTmp = ssAll[j];
	//			XPoint ptPick;
	//			CString csRadius = ReadXdata(entTmp, _T("HYDRANT_RADIUS"));
	//			OPENOBJ_BEGIN(entTmp, AcDb::kForRead, TDbEquipment, pEquip);
	//			if(pEquip){
	//				ptPick = pEquip->GetLocation();
	//			}
	//			OPENOBJ_END();
	//			
	//			XCircle cir(ptPick, _tstof(csRadius)*1000);
	//			cir.Make();
	//		}
	//		ssDel.IncludeEnd();
			
			XPoint ptIns;
			double nScale = 1;
			InitLayer(LAY_TWT_GULLY);
			xg_getvar(_T("VIEWCTR"), ptIns);
			ptIns = Ucs2Wcs(ptIns);

			BOOL bMirror = FALSE;
			while(1){
				dlg.UpdateData();
				// cet 2010.6.23 add
				ssDel.Erase();
				ssDel.Free();
				if (dlg.IsShowCircle()) 
				{
					std::map<XPoint,double>::iterator it;
					for(it = mapData.begin(); it != mapData.end(); it++)
					{
						XCircle cir((*it).first, (*it).second);
						cir.Make();
						Entity entCir;
						entCir.GetLast();
						ssDel += entCir;
					}
				}

				double dScaleX(0), dScaleY(0);
				dlg.GetScale(dScaleX, dScaleY);
				g_csInsBlkName = dlg.m_csInsBlkName;
				double dScaleMater = dlg.m_bAutoScale ? DocGetPScale() / 100 : 1;

				//支持预览保护圆 2009-4-2
				TBlockExJig jig(g_csInsBlkName, ptIns, dScaleX * dScaleMater, dScaleY * dScaleMater, _tstof(dlg.m_csRadius)*1000);
	//			jig.SetRadius(_tstof(dlg.m_csRadius)*1000);
	//			jig.m_nSacle = dScaleX;
	//			jig.m_nSacleY = dScaleY;
	//			jig.m_nSacle = dScaleX*(DocGetPScale()/100.0);
	//			jig.m_nSacleY = dScaleY*(DocGetPScale()/100.0);
				jig.SetPrompt(_T("\n请点取消火栓插入点[90度旋转(A)/左右翻转(F)]:<退出>"));
				jig.SetKeyword(_T("A F R"));
				int nKeyIndex = 0;
			  //  jig.m_bReversal = bMirror;
				jig.SetReversal(bMirror);
				int ret = jig.DoIt(&nKeyIndex);
				if(ret == RTKWORD){
					if(nKeyIndex == 0)
						g_nInsBlkRotate += PI/2;
					else if(nKeyIndex == 1)
						bMirror = !bMirror;
					else
						break;
					continue;
				}
				else if(ret != RTNORM)
				{
					bRet = true;
					break;
				}
				ptIns = jig.GetPickPoint();
				XPoint ptMid = ptIns;
			//    GetBlkRecordMidPt(g_csInsBlkName, nScale, ptMid, bMirror, g_nInsBlkRotate);
				dlg.UpdateData();
				TDbEquipment *pEquip = new TDbEquipment;
				pEquip->SetBlock2d(GetBlkIdByName(g_csInsBlkName));
				pEquip->SetScale(dScaleX);
				pEquip->SetYScale(dScaleY);
				pEquip->SetAutoScale(dlg.m_bAutoScale);

				pEquip->SetInsert(ptIns);
				pEquip->SetHidePipe(TRUE);
				pEquip->MirrorByY(bMirror);
				double nAngle = Ucs2Wcs(g_nInsBlkRotate);
				pEquip->SetAngle(nAngle);
				if(dlg.m_iMode == 0){
					pEquip->SetPipeLength(250);//上
					pEquip->SetBlock3d(GetBlockIdFromString(xsTmp6));
				}
				else
					pEquip->SetBlock3d(GetBlockIdFromString(xsTmp7));
            
				pEquip->SetSysBlock((const TCHAR*)dlg.m_csSysBlk);
				pEquip->setLayer(LAY_EQUIP_HYDRANT);
				pEquip->setColor(AcCmColor()); //随层
				pEquip->SetLocation(ptMid);
				AcDbObjectId id = AddToCurrentSpace(pEquip, Adesk::kTrue);
				Entity entLast;
				entLast.GetLast();
				WriteXdata(entLast, _T("HYDRANT_RADIUS"), dlg.m_csRadius);

				XCircle cir(ptIns, _tstof(dlg.m_csRadius)*1000);
				cir.Make();
				Entity entCir;
				entCir.GetLast();
	//			ssDel+= entCir;  // cet 2010.6.23 del
				ssNew += entCir; // cet 2010.6.23 add
				
			}            
		}
		else
		{
			int nRet(0);
			if (!bBlk)
			{
				INITGET_BEG(0, _T("R "));
				nRet = SelectEntity1(0.3, _T("\n请拾取布置消火栓的外部参照、墙线、柱子、直线、弧线 <退出>"), entWall, ptPick, rbMask);
				INITGET_END();
				if (nRet != RTNORM && nRet != RTKWORD)
				{
					break;
				}
			}

			ssDel.Erase();
			ssDel.Free();
			dlg.UpdateData();
			if (dlg.IsShowCircle()) 
			{
				std::map<XPoint,double>::iterator it;
				for(it = mapData.begin(); it != mapData.end(); it++)
				{
					XCircle cir((*it).first, (*it).second);
					cir.Make();
					Entity entCir;
					entCir.GetLast();
					ssDel += entCir;
				}
			}

			if (nRet == RTKWORD)
			{
				continue;
			}

			ptPick = Ucs2Wcs(ptPick);
			bFree = FALSE;
			dlg.UpdateData();
			g_csInsBlkName = dlg.m_csInsBlkName;

			if(entWall.Is(_T("INSERT")) && IsExternalBlock(entWall))
			{
				bBlk = true;
			}
			Entity entBlk = entWall;

			XCurveSegment seg;
			AcGeMatrix3d mat;
			seg = GetEntitySegByPt(ptPick, entWall, mat);
			if(!seg)
				break;

			XPoint ptRet = GetNearestEntPt(ptPick, seg);
			if (entWall.Is(_T("ATS_WALL")))
			{
				XCurveSegment seg2;
				seg2 = GetOtherWallSegByPt(ptPick, entWall, mat);
				XPoint ptPick2;
				seg2.ProjectToMe(ptPick, ptPick2);
				XPoint ptRet2 = GetNearestEntPt(ptPick2, seg2);
				seg.ProjectToMe(ptRet2, ptRet2);
				if (ads_distance(ptRet2, ptPick) < ads_distance(ptRet, ptPick))
				{
					ptRet = ptRet2;
				}
			}
			entWall = entBlk;

			double dLenPick = seg.PathDistance(ptPick);
			double dLenRet = seg.PathDistance(ptRet);
			TADSGePointDir2d pt;
			double dBulge = seg.GetBulge();
			double dDst = dlg.m_dByDist * dMeter;
			if (fabs(dBulge) > 0.001)// 弧线时重新计算距离,使两点之间的直线距离为dDst
			{
				XCircle cir = seg.GetCircle();
				double r = cir.GetRadius();
				dDst = 2 * r * asin(dDst/2/r);
			}
			
			if (dLenRet == 0.0)
			{
				if (ptRet.Distance2d(seg.GetStartPoint()) < 1)
				{
					seg.Polar(dDst, pt);
				}
				else
				{
					seg.Polar(seg.GetLength() - dDst, pt);
				}
			}
			else if (dLenPick > dLenRet)
			{
				seg.Polar(dLenRet + dDst, pt);
			}
			else
			{
				seg.Polar(dLenRet - dDst, pt);
			}
			ptPick = pt.AsAcGePoint3d();
			double dLenS = seg.PathDistance(ptPick, 1);
			double dLenE = seg.PathDistance(ptPick, 0);
			if (dLenS < 0.0 || dLenE < 0.0)// 布置点不在线上
			{
				continue;
			}
			g_nInsBlkRotate = GetInsRotate(ptPick, seg);
		 
			AcGeVector3d vect;
			vect.x = cos(g_nInsBlkRotate);
			vect.y = sin(g_nInsBlkRotate);
			vect.z = 0;
			BOOL m_bMirror = FALSE;
			double nScale = 1;
        
			BOOL bCancel = FALSE;
			double nWidth(0), nHeight(0);
			double dScaleX(0), dScaleY(0);
			XCircle cir(ptPick, _tstof(dlg.m_csRadius)*1000);
			cir.Make();
			Entity entCir;
			entCir.GetLast();
			ssNew += entCir;
		 
			while(1)
			{
				dlg.UpdateData();
				dlg.GetScale(dScaleX, dScaleY);
				double dScaleMater = dlg.m_bAutoScale ? DocGetPScale() / 100 : 1;
				
				GetBlkRecordWidth(xsTmp0, dScaleX * dScaleMater, dScaleY * dScaleMater, nWidth, nHeight);
				TBlockEdJig jig(g_csInsBlkName, ptPick, 1, vect, nWidth + dlg.m_iDist);
				jig.m_nSacle = dScaleX * dScaleMater;
				jig.m_nSacleY = dScaleY* dScaleMater;
				jig.SetPrompt(_T("\n请指定附件的插入方向<完成>:"));
				int nKeyIndex = 0;
				int nRetCode = jig.DoIt(&nKeyIndex);
				if(nRetCode == RTNORM)
				{
					if(jig.m_iQuadrant == 2 || jig.m_iQuadrant == 3){
						g_nInsBlkRotate += PI;
					}
					if(jig.m_iQuadrant == 1 || jig.m_iQuadrant == 3){
						m_bMirror = TRUE;
					}
					ptPick = jig.m_ptRetIns;
					break;
				}
				else
				{
					bCancel = TRUE;
					ssNew -= entCir;
					entCir.Erase();
					break;
				}
			}
      
			if(bCancel)
			{
				continue;
			}

			dlg.UpdateData();
			dlg.GetScale(dScaleX, dScaleY);
			
			TDbEquipment *pEquip = new TDbEquipment;
			pEquip->SetBlock2d(GetBlkIdByName(g_csInsBlkName));
			pEquip->SetInsert(ptPick);
			pEquip->SetHidePipe(TRUE);
			pEquip->SetScale(dScaleX);
			pEquip->SetYScale(dScaleY);
			pEquip->SetAutoScale(dlg.m_bAutoScale);
			pEquip->MirrorByY(m_bMirror);
			double dAngle = g_nInsBlkRotate;
			pEquip->SetAngle(dAngle);
			if(dlg.m_iMode == 0)
			{
				pEquip->SetPipeLength(250);
				pEquip->SetBlock3d(GetBlockIdFromString(xsTmp6));
			}
			else
				pEquip->SetBlock3d(GetBlockIdFromString(xsTmp7));
			pEquip->SetSysBlock((const TCHAR*)dlg.m_csSysBlk);
			pEquip->setLayer(LAY_EQUIP_HYDRANT);
			pEquip->setColor(AcCmColor());
			pEquip->SetLocation(ptPick);
			AcDbObjectId id = AddToCurrentSpace(pEquip, Adesk::kTrue);
			Entity entLast;
			entLast.GetLast();
			WriteXdata(entLast, _T("HYDRANT_RADIUS"), dlg.m_csRadius);
		}
	}
	ssDel.Erase();
	ssNew.Erase(); // cet2010.6.23 add
	g_nInsBlkRotate = 0;
	dlg.DestroyWindow();
}




IMPLEMENT_DYNAMIC(CHydrantPlanDlg, CModelessDialog)

BOOL CHydrantPlanDlg::m_bWndChkRadius = FALSE;
int CHydrantPlanDlg::m_iMode = 0;
CString CHydrantPlanDlg::m_csOldDim = _T("700*200");
CString CHydrantPlanDlg::m_csInsBlkName = _T("");
CString CHydrantPlanDlg::m_csSysBlk = _T("");
BOOL CHydrantPlanDlg::m_bAutoScale = FALSE;
CString	CHydrantPlanDlg::m_csRadius = _T("28"); // cet 2010.7.22 add 记忆半径
int CHydrantPlanDlg::m_iPlanType = 0;

CHydrantPlanDlg::CHydrantPlanDlg(int iMode, CWnd* pParent /*=NULL*/)
	: CModelessDialog(CHydrantPlanDlg::IDD, pParent), m_spinDist(50)
{
	//{{AFX_DATA_INIT(CHydrantPlanDlg)
	m_iDist = 0;
	m_bMirrorByX = FALSE;
	m_bMirrorByY = FALSE;
	m_dEle = 1.1;
	m_iDim = -1;
	m_dByDist = 3.0;
	//}}AFX_DATA_INIT
	m_csSysBlk1 = _T("TWTSYS(00000386)");
	m_csSysBlk2 = _T("TWTSYS(00000383)");
   // m_csSysBlk = m_csSysBlk1;
    m_iOpenMode = iMode;
	m_dScaleX = 0;
	m_dScaleY = 0;
}


void CHydrantPlanDlg::DoDataExchange(CDataExchange* pDX)
{
	CModelessDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CHydrantPlanDlg)
	DDX_Control(pDX, IDC_EDIT_BYDIST, m_edtByDist);
	DDX_Control(pDX, IDC_LIST_DN, m_listDim);
	DDX_Control(pDX, IDC_SPIN_DIST, m_spinDist);
	DDX_Text(pDX, IDC_EDIT_DIST, m_iDist);
	DDV_MinMaxInt(pDX, m_iDist, -100, 1000);
	DDX_Check(pDX, IDC_CHECK_LR, m_bMirrorByX);
	DDX_Check(pDX, IDC_CHECK_UD, m_bMirrorByY);
	DDX_Text(pDX, IDC_EDIT_ELE, m_dEle);
	DDX_LBIndex(pDX, IDC_LIST_DN, m_iDim);
	DDX_Text(pDX, IDC_EDIT_BYDIST, m_dByDist);
	DDV_MinMaxDouble(pDX, m_dByDist, 0., 10000000000.);
	DDX_CBString(pDX, IDC_COMBO_RADIUS, m_csRadius);
	DDX_Radio(pDX, IDC_RADIO_MODE1, m_iMode);
	DDX_Check(pDX, IDC_CHECK_AUTOSCALE, m_bAutoScale);
	DDX_Check(pDX, IDC_CHECK_RADIUS, m_bWndChkRadius);
	DDX_Radio(pDX, IDC_RADIO_BYLINE, m_iPlanType);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CHydrantPlanDlg, CModelessDialog)
	//{{AFX_MSG_MAP(CHydrantPlanDlg)
	ON_WM_PAINT()
	ON_WM_CLOSE()
	ON_BN_CLICKED(IDC_BUTTON_CALC, OnButtonCalc)
	ON_BN_CLICKED(IDC_RADIO_MODE1, OnRadioMode1)
	ON_BN_CLICKED(IDC_RADIO_MODE2, OnRadioMode2)
	ON_BN_CLICKED(IDC_PREVIEW, OnPreview)
	ON_BN_CLICKED(IDC_BUTTON_DIM, OnButtonDim)
	ON_LBN_SELCHANGE(IDC_LIST_DN, OnSelchangeListDn)
	ON_BN_CLICKED(IDC_CHECK_RADIUS, OnCheckRadius)
	ON_BN_CLICKED(IDC_RADIO_BYDIST, OnRadioBydist)
	ON_BN_CLICKED(IDC_RADIO_BYLINE, OnRadioByline)
	ON_BN_CLICKED(IDC_RADIO_BYUSER, OnRadioByuser)
	ON_EN_KILLFOCUS(IDC_EDIT_BYDIST, OnKillfocusEditBydist)
	ON_BN_CLICKED(IDC_CHECK_AUTOSCALE, OnCheckAutoscale)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CHydrantPlanDlg message handlers

BOOL CHydrantPlanDlg::OnInitDialog() 
{
	CModelessDialog::OnInitDialog();
	m_spinDist.SetRange(0,1000);
	OpenSlide();
    if(m_iOpenMode == 0){
        CRect rect;
        this->GetWindowRect(&rect);
        rect.bottom -= 80;
        this->MoveWindow(&rect);
    }
    else{
        CWnd *pWnd1 = GetDlgItem(IDC_EDIT_DIST);
        CWnd *pWnd2 = GetDlgItem(IDC_SPIN_DIST);
        CWnd *pWnd3 = GetDlgItem(IDC_BUTTON_CALC);
	    pWnd1->EnableWindow(FALSE);
        pWnd2->EnableWindow(FALSE);
        pWnd3->EnableWindow(FALSE);

		CWnd *pWnd4 = GetDlgItem(IDC_RADIO_BYLINE);
        CWnd *pWnd5 = GetDlgItem(IDC_RADIO_BYUSER);
        CWnd *pWnd6 = GetDlgItem(IDC_RADIO_BYDIST);
		pWnd4->EnableWindow(FALSE);
        pWnd5->EnableWindow(FALSE);
        pWnd6->EnableWindow(FALSE);
        UpdateData(FALSE);
    }
	ResetDim();
	if(m_iOpenMode == 1){
		CString csText;
		csText.Format(_T("%.0f*%.0f"), m_dScaleX, m_dScaleY);
		int idx = m_listDim.FindString(0, csText);
		if(idx > -1){
			m_iDim = idx;
		}
		else{
			m_listDim.AddString(csText);
			m_iDim = m_listDim.GetCount()-1;
		}
		UpdateData(FALSE);
	}
	else{
		int idx = m_listDim.FindString(0, m_csOldDim);
		if(idx > -1)
			m_iDim = idx;
		else
			m_iDim = 0;
		UpdateData(FALSE);
	}
	if(m_csSysBlk == _T(""))
		m_csSysBlk = m_csSysBlk1;

	CRegProperty regProp(GetRegLocation(), _T("TWTConfig"));    
    regProp.SetTopRootKey(HKEY_CURRENT_USER);
	if (!regProp.GetValue(_T("HydrantPlanByDist"), m_dByDist))
	{
		m_dByDist = 3;
	}

	if (!regProp.GetValue(_T("HydrantPlanType"), m_iPlanType))
	{
		m_iPlanType = 0;
	}
	UpdateData(FALSE);
	InitEditStatus();

	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

void CHydrantPlanDlg::InitEditStatus()
{
	UpdateData(TRUE);
	CWnd *pWnd = GetDlgItem(IDC_EDIT_BYDIST);
	if (m_iPlanType == 2 && m_iOpenMode == 0)
	{
		pWnd->EnableWindow(TRUE);
	}
	else
	{
		pWnd->EnableWindow(FALSE);
	}
}

void CHydrantPlanDlg::OnPaint() 
{
	CPaintDC dc(this); // device context for painting
	OpenSlide();
}

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

void CHydrantPlanDlg::OpenSlide()
{
	UpdateData(TRUE);
	CWnd *pImageBox = GetDlgItem(IDC_PREVIEW);
    CString csTKName, csRocord;
    CString csSlb;
    SplitBlkStr(m_csInsBlkName, csTKName, csRocord);
    csSlb.Format(_T("%s(%s)"), csTKName, csRocord);
    
	DrawSlide((const TCHAR*)csSlb, pImageBox);
}

void CHydrantPlanDlg::OnButtonCalc() 
{
    CModelessDialog::OnClose();
    acedPostCommand(_T("\33\33"));    
    acedPostCommand(_T("xhsjs "));    
}


void CHydrantPlanDlg::OnRadioMode1() 
{
	PostCommand(_T("R "), false);
}

void CHydrantPlanDlg::OnRadioMode2() 
{
	PostCommand(_T("R "), false);
}

void CHydrantPlanDlg::OnSelchangeListDn() 
{
	UpdateData(TRUE);
	m_listDim.GetText(m_iDim, m_csOldDim);
	PostCommand(_T("R "), false);
	
}

void CHydrantPlanDlg::OnPreview() 
{
    UpdateData();
 
    CTemporaryResourceOverride vTemp;
    CSelectBlkDlg dlg;  
    dlg.m_csTkName = _T("TWTSYS");
    dlg.m_csType = _T("平面消火栓");	
    CWnd *pWnd = GetDlgItem(IDC_PREVIEW);
    CRect rect;
    dlg.m_staticSlide.m_csCurRecord = m_csSysBlk1;
    pWnd->GetWindowRect(&rect);
    dlg.m_ptBase = rect.TopLeft();
    if(dlg.DoModal() == IDOK){
        CString csRet = dlg.m_staticSlide.m_csCurRecord;
        CString csDes = dlg.m_staticSlide.m_csCurDesName;
        if(csDes.Find(_T("双")) > -1){
            m_csSysBlk = m_csSysBlk2;
        }
        else{
            m_csSysBlk = m_csSysBlk1;
        }
        
        XString xsTKName, xsRocord;
        SplitSlbName(csRet, xsTKName, xsRocord);
        acDocManager->lockDocument(curDoc(),AcAp::kWrite,NULL,NULL,true);
        XString xsBlk;
        LoadDwbBlock(xsTKName, xsRocord, xsBlk);
        m_csInsBlkName = xsBlk;
        acDocManager->unlockDocument(curDoc());
        OpenSlide();
    }
    PostCommand(_T("R "), false);
}



BOOL InvokeDataStore(int iMode, CString csText)
{
	CString csRet;
    RBList rbCmd=ads_buildlist(RTSTR, _T("IDataStore"), RTSTR, csText, RTSHORT, iMode, NULL);
    resbuf *rbRes=NULL;
    if(ads_invoke(rbCmd, &rbRes)==RTNORM && rbRes) {
        if(rbRes && rbRes->restype==RTSTR)
            csRet=rbRes->resval.rstring;
        ads_relrb(rbRes);
        return TRUE;
    }
    return FALSE;
}


void CHydrantPlanDlg::OnButtonDim() 
{
	InvokeDataStore(41, _T("消火栓尺寸"));
	ResetDim();
	m_iDim = 0;
	UpdateData(FALSE);
	
}

void CHydrantPlanDlg::ResetDim() 
{
	m_listDim.ResetContent();

	CodeBase db;
	int Number;
	CString csType, csValue, csRemark;
	XString fullFile;
    if(!FindFile(_T("DataStore.dbf"), fullFile)) {
		Callme(_T("对不起，没有发现DataStore.dbf文件！"));
		return;
	}
	XDbfTable *pTable = db.Open(fullFile);
	if(!pTable) {
		Callme(_T("DataStore.dbf文件出错！"));
		return;
	}
	pTable->MoveFirst();
	while(!pTable->IsEOF())	{
		GET_FIELD(pTable, _T("TypeNumber"), Number);
		GET_FIELD(pTable, _T("TypeName"), csType);
		GET_FIELD(pTable, _T("TypeValue"), csValue);
		GET_FIELD(pTable, _T("REMARK"), csRemark);
		if(csType == _T("消火栓尺寸") && Number == 41){
			m_listDim.AddString(csValue);
		}
		pTable->MoveNext();
	}

//	m_iDim = 0;
//	UpdateData(FALSE);
	
}

void CHydrantPlanDlg::GetScale(double &dX, double &dY)
{
	UpdateData(TRUE);
	CString csText;
	m_listDim.GetText(m_iDim, csText);
	int idx = csText.Find(_T("*"));
	CString csLeft, csRight;
	csLeft = csText.Left(idx);
	csRight = csText.Right(csText.GetLength() - idx - 1);
	dX = _tstof(csLeft);
	dY = _tstof(csRight);
}

void CHydrantPlanDlg::SetScale(double dX, double dY)
{
	m_dScaleX = dX;
	m_dScaleY = dY;

}
 


void CHydrantPlanDlg::OnOK() 
{
	UpdateData(TRUE);
	CString csText;
	m_listDim.GetText(m_iDim, csText);
	int idx = csText.Find(_T("*"));
	CString csLeft, csRight;
	csLeft = csText.Left(idx);
	csRight = csText.Right(csText.GetLength() - idx - 1);
	m_dScaleX = _tstof(csLeft);
	m_dScaleY = _tstof(csRight);
	
	CModelessDialog::OnOK();
}
 

void CHydrantPlanDlg::OnCheckRadius() 
{
    PostCommand(_T("R "), false);	
}

void CHydrantPlanDlg::OnRadioBydist() 
{
	InitEditStatus();
	PostCommand(_T("R "), false);
	acedGetAcadDwgView()->SetFocus();
}

void CHydrantPlanDlg::OnRadioByline() 
{
	InitEditStatus();
	PostCommand(_T("R "), false);
	acedGetAcadDwgView()->SetFocus();
}

void CHydrantPlanDlg::OnRadioByuser() 
{
	InitEditStatus();
	PostCommand(_T("R "), false);
	acedGetAcadDwgView()->SetFocus();
}

BOOL CHydrantPlanDlg::DestroyWindow() 
{
	UpdateData(TRUE);
	CRegProperty regProp(GetRegLocation(), _T("TWTConfig"));    
    regProp.SetTopRootKey(HKEY_CURRENT_USER);
	regProp.SetValue(_T("HydrantPlanByDist"), m_dByDist);
	regProp.SetValue(_T("HydrantPlanType"), m_iPlanType);
	return CModelessDialog::DestroyWindow();
}

extern bool IsStrAllNum(CString csText);
void CHydrantPlanDlg::OnKillfocusEditBydist() 
{
	double dData = m_dByDist;
	CString sText;
	m_edtByDist.GetWindowText(sText);
	m_dByDist = _tstof(sText);
	if (m_dByDist <= 0 || !IsStrAllNum(sText))
	{
		m_dByDist = dData;
		UpdateData(FALSE);
		acedGetAcadDwgView()->SetFocus();
		m_edtByDist.SetFocus();
		m_edtByDist.SetSel(0, -1);
	}
}

void CHydrantPlanDlg::OnCheckAutoscale() 
{
	UpdateData(TRUE);
	PostCommand(_T("R "), false);
	acedGetAcadDwgView()->SetFocus();
}