#include "stdafx.h"
#include "dbobjptr.h"
#include "AcDbObjectPtr.h"
#include "PickEntSet.h"
#include "ElevationCalcDlg.h"
#include "ElevationCalc.h"
#include "DbWell.h"
#include "WellCalcModifyEleDlg.h"
#include "ElevationCheckDlg.h"
#include "EditWellLayingDepthDlg.h"
#include "EditPipeDnGradientDlg.h"
#include "DbPool.h"
#include <stack>
#include <algorithm>

#include "PositiveElevationCalc.h"
#include "ReverseElevationCalc.h"
#include "dbgridsheet.h"
#include "XText.h"
#include "layerdef.h"

#include "DbPipe.h"
#include <set>
#include "TGAs.h"

bool IsCalced(SSearchPipeList *pList, bool bFromImport = true);
AcDbObjectId InitLayer(const TCHAR *szLayer, BOOL bApplyChange = TRUE);
namespace
{
	void ResetPipeDir(SSearchPipeList *pListAll)
	{
		long len = pListAll->m_lstNode.Length();
		if (pListAll->m_iType == 0) {
			XPoint ptFront;
			if (pListAll->m_pPrevious != NULL) {
				OPENOBJ_BEGIN(pListAll->m_pPrevious->m_ID, AcDb::kForRead, CDbPipeNode, pNode);
				if (pNode) {
					ptFront = pNode->GetLocation();
					// cet 2012.7.26 add 考虑化粪池
					CDbPool *pPool = CDbPool::cast(pNode);
					if (pPool != NULL)
					{
						int nNum = pPool->GetInterfaceNum();
						for (int i = 0; i < nNum; i++)
						{
							const CPipeInterface &face = pPool->GetInterface(i);
							if (face.m_idPipe == pListAll->m_ID)
							{
								ptFront = face.m_ptLocation;
								break;
							}
						}
					}
				}
				OPENOBJ_END();
			}
			OPENOBJ_BEGIN(pListAll->m_ID, AcDb::kForWrite, CDbPipe, pPipe);
			if (pPipe && !!ptFront) {
				XPoint p1 = ptFront;
				p1.z = 0;
				XPoint p2 = pPipe->StartPoint();
				p2.z = 0;
				if (pPipe->IsVertical()) // 考虑立管 cet 2011.9.15 add
				{
					if (pPipe->StartPoint().z > pPipe->EndPoint().z)
					{
						pPipe->SetFlowDir(TPipeSys::kFromStart);
					}
					else
					{
						pPipe->SetFlowDir(TPipeSys::kFromEnd);
					}
				}
				else if (p1 == p2)
					pPipe->SetFlowDir(TPipeSys::kFromEnd);
				else
					pPipe->SetFlowDir(TPipeSys::kFromStart);
			}
			OPENOBJ_END();
		}

		for (long i = 0; i < len; i++) {
			SSearchPipeList *pList = pListAll->m_lstNode[i];
			ResetPipeDir(pList);
		}
	}
}

void CloseLayer(const CString &strLayer, BOOL bOff)
{
	AcDbObjectId idLayer = GlobalFunc::GetLayerRecordId(strLayer);
	AcDbLayerTableRecord *pLayer = NULL;
	acdbOpenObject(pLayer, idLayer, AcDb::kForWrite);
	if (pLayer != NULL)
	{
		pLayer->setIsOff(bOff ? false : true);
		pLayer->close();
	}
}

void SetLayer(std::vector<BOOL> &vec)
{
	CloseLayer(LAY_PIPE_FEED, vec[0]);
	CloseLayer(LAY_PIPE_FEED2, vec[0]);
	CloseLayer(LAY_PIPE_FEED3, vec[0]);
	CloseLayer(LAY_VPIPE_FEED, vec[0]);
	CloseLayer(LAY_VPIPE_FEED2, vec[0]);
	CloseLayer(LAY_VPIPE_FEED3, vec[0]);

	CloseLayer(LAY_WELL_FEED, vec[0]);
	CloseLayer(LAY_TEXT_FEED, vec[0]);
	CloseLayer(LAY_VALVE_FEED, vec[0]);
	CloseLayer(LAY_DIM_FEED, vec[0]);

	CloseLayer(LAY_PIPE_HEADFEED, vec[1]);
	CloseLayer(LAY_VPIPE_HEADFEED, vec[1]);
	CloseLayer(LAY_PIPE_HEADFEED2, vec[1]);
	CloseLayer(LAY_VPIPE_HEADFEED2, vec[1]);
	CloseLayer(LAY_PIPE_HEADFEED3, vec[1]);
	CloseLayer(LAY_VPIPE_HEADFEED3, vec[1]);

	CloseLayer(LAY_TEXT_HEADFEED, vec[1]);
	CloseLayer(LAY_VALVE_HEADFEED, vec[1]);
	CloseLayer(LAY_DIM_HEADFEED, vec[1]);

	CloseLayer(LAY_PIPE_HEADBACK, vec[2]);
	CloseLayer(LAY_VPIPE_HEADBACK, vec[2]);
	CloseLayer(LAY_PIPE_HEADBACK2, vec[2]);
	CloseLayer(LAY_VPIPE_HEADBACK2, vec[2]);
	CloseLayer(LAY_PIPE_HEADBACK3, vec[2]);
	CloseLayer(LAY_VPIPE_HEADBACK3, vec[2]);

	CloseLayer(LAY_TEXT_HEADBACK, vec[2]);
	CloseLayer(LAY_VALVE_HEADBACK, vec[2]);
	CloseLayer(LAY_DIM_HEADBACK, vec[2]);

	CloseLayer(LAY_PIPE_DIRT, vec[3]);
	CloseLayer(LAY_VPIPE_DIRT, vec[3]);

	CloseLayer(LAY_TEXT_DIRT, vec[3]);
	CloseLayer(LAY_VALVE_DIRT, vec[3]);
	CloseLayer(LAY_DIM_DIRT, vec[3]);
	CloseLayer(LAY_WELL_DIRT, vec[3]);

	CloseLayer(LAY_PIPE_USELESS, vec[4]);
	CloseLayer(LAY_VPIPE_USELESS, vec[4]);

	CloseLayer(LAY_TEXT_USELESS, vec[4]);
	CloseLayer(LAY_VALVE_USELESS, vec[4]);
	CloseLayer(LAY_DIM_USELESS, vec[4]);
	CloseLayer(LAY_WELL_USELESS, vec[4]);

	CloseLayer(LAY_PIPE_RAIN, vec[5]);
	CloseLayer(LAY_VPIPE_RAIN, vec[5]);

	CloseLayer(LAY_TEXT_RAIN, vec[5]);
	CloseLayer(LAY_VALVE_RAIN, vec[5]);
	CloseLayer(LAY_DIM_RAIN, vec[5]);
	CloseLayer(LAY_WELL_RAIN, vec[5]);

	CloseLayer(LAY_PIPE_USED, vec[6]);
	CloseLayer(LAY_VPIPE_USED, vec[6]);

	CloseLayer(LAY_TEXT_USED, vec[6]);
	CloseLayer(LAY_VALVE_USED, vec[6]);
	CloseLayer(LAY_DIM_USED, vec[6]);
	CloseLayer(LAY_WELL_USED, vec[6]);

	CloseLayer(LAY_PIPE_FIRE, vec[7]);
	CloseLayer(LAY_VPIPE_FIRE, vec[7]);
	CloseLayer(LAY_PIPE_FIRE2, vec[7]);
	CloseLayer(LAY_VPIPE_FIRE2, vec[7]);
	CloseLayer(LAY_PIPE_FIRE3, vec[7]);
	CloseLayer(LAY_VPIPE_FIRE3, vec[7]);

	CloseLayer(LAY_TEXT_FIRE, vec[7]);
	CloseLayer(LAY_VALVE_FIRE, vec[7]);
	CloseLayer(LAY_DIM_FIRE, vec[7]);
	CloseLayer(LAY_WELL_FIRE, vec[7]);

	CloseLayer(LAY_PIPE_SPRINKLE, vec[8]);
	CloseLayer(LAY_VPIPE_SPRINKLE, vec[8]);

	CloseLayer(LAY_TEXT_SPRINKLE, vec[8]);
	CloseLayer(LAY_VALVE_SPRINKLE, vec[8]);
	CloseLayer(LAY_DIM_SPRINKLE, vec[8]);

	CloseLayer(LAY_PIPE_COAGULATE, vec[9]);
	CloseLayer(LAY_VPIPE_COAGULATE, vec[9]);

	CloseLayer(LAY_TEXT_COAGULATE, vec[9]);
	CloseLayer(LAY_VALVE_COAGULATE, vec[9]);
	CloseLayer(LAY_DIM_COAGULATE, vec[9]);

	CloseLayer(LAY_PIPE_DRINK, vec[10]);
	CloseLayer(LAY_VPIPE_DRINK, vec[10]);

	CloseLayer(LAY_TEXT_DRINK, vec[10]);
	CloseLayer(LAY_VALVE_DRINK, vec[10]);
	CloseLayer(LAY_DIM_DRINK, vec[10]);

	CloseLayer(LAY_PIPE_PRESSDIRT, vec[11]);
	CloseLayer(LAY_VPIPE_PRESSDIRT, vec[11]);

	CloseLayer(LAY_TEXT_PRESSDIRT, vec[11]);
	CloseLayer(LAY_VALVE_PRESSDIRT, vec[11]);
	CloseLayer(LAY_DIM_PRESSDIRT, vec[11]);

	CloseLayer(LAY_PIPE_PRESSUSELESS, vec[12]);
	CloseLayer(LAY_VPIPE_PRESSUSELESS, vec[12]);

	CloseLayer(LAY_TEXT_PRESSUSELESS, vec[12]);
	CloseLayer(LAY_VALVE_PRESSUSELESS, vec[12]);
	CloseLayer(LAY_DIM_PRESSUSELESS, vec[12]);

	CloseLayer(LAY_PIPE_PRESSRAIN, vec[13]);
	CloseLayer(LAY_VPIPE_PRESSRAIN, vec[13]);

	CloseLayer(LAY_TEXT_PRESSRAIN, vec[13]);
	CloseLayer(LAY_VALVE_PRESSRAIN, vec[13]);
	CloseLayer(LAY_DIM_PRESSRAIN, vec[13]);


	CloseLayer(LAY_PIPE_OTHER, vec[14]);
	CloseLayer(LAY_VPIPE_OTHER, vec[14]);

	CloseLayer(LAY_TEXT_OTHER, vec[14]);
	CloseLayer(LAY_VALVE_OTHER, vec[14]);
	CloseLayer(LAY_DIM_OTHER, vec[14]);
	CloseLayer(LAY_WELL_OTHER, vec[14]);
}

CString GetPipeLayer(SSearchPipeList *pList)
{
	CString strPipeLayer;
	std::stack<SSearchPipeList *> data;
	data.push(pList);
	while (!data.empty())
	{
		SSearchPipeList *pTemp = data.top();
		data.pop();
		if (pTemp->m_iType == 0)
		{
			CDbPipe *pPipe = NULL;
			acdbOpenObject(pPipe, pTemp->m_ID, AcDb::kForRead);
			if (pPipe != NULL)
			{
				strPipeLayer = pPipe->layer();
				pPipe->close();
			}
			break;
		}

		for (int i = 0; i < pTemp->m_lstNode.Length(); i++)
		{
			data.push(pTemp->m_lstNode[i]);
		}
	}
	return strPipeLayer;
}

// 设置各图层开关 bClosed = true 时 关闭与strPipeLayer 图层无关的图层
// bClosed = false 时 打开所有图层
void SetLayerOpenClose(const CString strPipeLayer, BOOL bClosed)
{
	if (!strPipeLayer.IsEmpty())
	{
		std::vector<BOOL> vec; // 各图层开关值
		for (int i = 0; i < 15; i++)
		{
			vec.push_back(!bClosed);
		}

		if (bClosed) //需关闭其他图层时
		{
			if (strPipeLayer.Compare(LAY_PIPE_FEED) == 0 || strPipeLayer.Compare(LAY_PIPE_FEED2) == 0 || strPipeLayer.Compare(LAY_PIPE_FEED3) == 0 ||
				strPipeLayer.Compare(LAY_VPIPE_FEED) == 0 || strPipeLayer.Compare(LAY_VPIPE_FEED2) == 0 || strPipeLayer.Compare(LAY_VPIPE_FEED3) == 0)
			{
				vec[0] = TRUE;
			}
			else if (strPipeLayer.Compare(LAY_PIPE_HEADFEED) == 0 || strPipeLayer.Compare(LAY_VPIPE_HEADFEED) == 0 ||
				strPipeLayer.Compare(LAY_PIPE_HEADFEED2) == 0 || strPipeLayer.Compare(LAY_PIPE_HEADFEED3) == 0 || strPipeLayer.Compare(LAY_VPIPE_HEADFEED3) == 0)
			{
				vec[1] = TRUE;
			}
			else if (strPipeLayer.Compare(LAY_PIPE_HEADBACK) == 0 || strPipeLayer.Compare(LAY_VPIPE_HEADBACK) == 0 || strPipeLayer.Compare(LAY_PIPE_HEADBACK2) == 0 ||
				strPipeLayer.Compare(LAY_VPIPE_HEADBACK2) == 0 || strPipeLayer.Compare(LAY_PIPE_HEADBACK3) == 0 || strPipeLayer.Compare(LAY_VPIPE_HEADBACK3) == 0)
			{
				vec[2] = TRUE;
			}
			else if (strPipeLayer.Compare(LAY_PIPE_DIRT) == 0 || strPipeLayer.Compare(LAY_VPIPE_DIRT) == 0)
			{
				vec[3] = TRUE;
			}
			else if (strPipeLayer.Compare(LAY_PIPE_USELESS) == 0 || strPipeLayer.Compare(LAY_VPIPE_USELESS) == 0)
			{
				vec[4] = TRUE;
			}
			else if (strPipeLayer.Compare(LAY_PIPE_RAIN) == 0 || strPipeLayer.Compare(LAY_VPIPE_RAIN) == 0)
			{
				vec[5] = TRUE;
			}
			else if (strPipeLayer.Compare(LAY_PIPE_USED) == 0 || strPipeLayer.Compare(LAY_VPIPE_USED) == 0)
			{
				vec[6] = TRUE;
			}
			else if (strPipeLayer.Compare(LAY_PIPE_FIRE) == 0 || strPipeLayer.Compare(LAY_VPIPE_FIRE) == 0 || strPipeLayer.Compare(LAY_PIPE_FIRE2) == 0 ||
				strPipeLayer.Compare(LAY_VPIPE_FIRE2) == 0 || strPipeLayer.Compare(LAY_PIPE_FIRE3) == 0 || strPipeLayer.Compare(LAY_VPIPE_FIRE3) == 0)
			{
				vec[7] = TRUE;
			}
			else if (strPipeLayer.Compare(LAY_PIPE_SPRINKLE) == 0 || strPipeLayer.Compare(LAY_VPIPE_SPRINKLE) == 0)
			{
				vec[8] = TRUE;
			}
			else if (strPipeLayer.Compare(LAY_PIPE_COAGULATE) == 0 || strPipeLayer.Compare(LAY_VPIPE_COAGULATE) == 0)
			{
				vec[9] = TRUE;
			}
			else if (strPipeLayer.Compare(LAY_PIPE_DRINK) == 0 || strPipeLayer.Compare(LAY_VPIPE_DRINK) == 0)
			{
				vec[10] = TRUE;
			}
			else if (strPipeLayer.Compare(LAY_PIPE_PRESSDIRT) == 0 || strPipeLayer.Compare(LAY_VPIPE_PRESSDIRT) == 0)
			{
				vec[11] = TRUE;
			}
			else if (strPipeLayer.Compare(LAY_PIPE_PRESSUSELESS) == 0 || strPipeLayer.Compare(LAY_VPIPE_PRESSUSELESS) == 0)
			{
				vec[12] = TRUE;
			}
			else if (strPipeLayer.Compare(LAY_PIPE_PRESSRAIN) == 0 || strPipeLayer.Compare(LAY_VPIPE_PRESSRAIN) == 0)
			{
				vec[13] = TRUE;
			}
			else if (strPipeLayer.Compare(LAY_PIPE_OTHER) == 0 || strPipeLayer.Compare(LAY_VPIPE_OTHER) == 0)
			{
				vec[14] = TRUE;
			}
		}

		SetLayer(vec);
	}
}

// cet 2012.10.10 add 删除plist中存在stackData中的节点
void DelNode(std::stack<SSearchPipeList*> &stackData, SSearchPipeList *pList)
{
	if (stackData.empty() || pList == NULL)
	{
		return;
	}

	std::vector<SSearchPipeList*> vecSrc;
	while (!stackData.empty())
	{
		vecSrc.push_back(stackData.top());
		stackData.pop();
	}

	std::stack<SSearchPipeList*> stkTemp;
	stkTemp.push(pList);
	SSearchPipeList *pTemp = NULL;
	std::vector<SSearchPipeList*>::iterator it;
	while (!stkTemp.empty())
	{
		pTemp = stkTemp.top();
		stkTemp.pop();
		it = std::find(vecSrc.begin(), vecSrc.end(), pTemp);
		if (it != vecSrc.end())
		{
			vecSrc.erase(it);
		}

		for (int i = 0; i < pTemp->m_lstNode.Length(); i++)
		{
			stkTemp.push(pTemp->m_lstNode[i]);
		}
	}

	for (it = vecSrc.begin(); it != vecSrc.end(); it++)
	{
		stackData.push(*it);
	}

}

// cet 2011.10.28 add 检查管网系统，保证待计算管网末端均为井
void CheckPipeSys(SSearchPipeList *pListAll)
{
	if (pListAll == NULL)
	{
		return;
	}

	SSearchPipeList *pTemp = NULL;
	std::stack<SSearchPipeList*> stackData;
	stackData.push(pListAll);
	while (!stackData.empty())
	{
		pTemp = stackData.top();
		stackData.pop();
		if (pTemp->m_iType != 3 && pTemp->m_lstNode.Length() == 0) // 叶子非井
		{
			while (pTemp->m_pPrevious != NULL && pTemp->m_pPrevious->m_iType != 3) // 找出父节点为井的节点
			{
				pTemp = pTemp->m_pPrevious;
			}

			if (pTemp->m_pPrevious != NULL) // 父节点为井
			{
				for (int i = 0; i < pTemp->m_pPrevious->m_lstNode.Length(); i++)
				{
					if (pTemp->m_pPrevious->m_lstNode[i] == pTemp)
					{
						DelNode(stackData, pTemp); // 删除堆栈中ptemp链的节点
						pTemp->m_pPrevious->m_lstNode.Remove(i);
						break;
					}
				}
			}
			continue;
		}

		// 将当前节点的子节点放入栈中
		for (int i = 0; i < pTemp->m_lstNode.Length(); i++)
		{
			stackData.push(pTemp->m_lstNode[i]);
		}
	}
}

// cet 2012.10.10 add 在缺少井的地方打叉提示
void DrawTipLabel(PickSet &ss)
{
	std::vector<AcGePoint3d> vecPts;
	for (long i = 0; i < ss.Length(); i++)
	{
		OPENOBJ_BEGIN(ss[i], AcDb::kForWrite, CDbPipe, pPipe);
		if (pPipe != NULL)
		{
			ads_name name0;
			acdbGetAdsName(name0, pPipe->GetNode(0));
			Entity ent0(name0);
			if (!ent0.Is(_T("AEC_ZT_WELL")) && !ent0.Is(_T("AEC_ZT_POOL")))
			{
				vecPts.push_back(pPipe->StartPoint());
			}

			ads_name name1;
			acdbGetAdsName(name1, pPipe->GetNode(1));
			Entity ent1(name1);
			if (!ent1.Is(_T("AEC_ZT_WELL")) && !ent1.Is(_T("AEC_ZT_POOL")))
			{
				vecPts.push_back(pPipe->EndPoint());
			}
		}
		OPENOBJ_END();
	}

	CString sLayer = GlobalFunc::GetPipeLayer(ss[0l]);
	ss.Free();
	std::unique(vecPts.begin(), vecPts.end());
	std::vector<AcGePoint3d>::iterator it;
	double dDist = 13 * GlobalFunc::DocGetPScale();
	XPoint pt1, pt2, pt3, pt4, ptMid;
	for (it = vecPts.begin(); it != vecPts.end(); it++)
	{
		ptMid = *it;
		ptMid = GlobalFunc::Wcs2Ucs(ptMid);
		ads_polar(ptMid, 0, dDist, pt1);
		ads_polar(pt1, PI / 2, dDist, pt1);
		ads_polar(ptMid, PI, dDist, pt2);
		ads_polar(pt2, PI / 2, -dDist, pt2);

		AcDbLine *pLine1 = new AcDbLine(GlobalFunc::Wcs2Ucs(pt1), GlobalFunc::Wcs2Ucs(pt2));
		pLine1->setLayer(sLayer);
		pLine1->setColorIndex(1);
		ss += GlobalFunc::AddToCurrentSpace(pLine1, Adesk::kTrue);

		ads_polar(ptMid, PI / 2, dDist, pt3);
		ads_polar(pt3, PI, dDist, pt3);
		ads_polar(ptMid, PI / 2, -dDist, pt4);
		ads_polar(pt4, 0, dDist, pt4);
		AcDbLine *pLine2 = new AcDbLine(GlobalFunc::Wcs2Ucs(pt3), GlobalFunc::Wcs2Ucs(pt4));
		pLine2->setLayer(sLayer);
		pLine2->setColorIndex(1);
		ss += GlobalFunc::AddToCurrentSpace(pLine2, Adesk::kTrue);
	}
}


// 检查管网中管线两端是否都连接着井或化粪池 cet 2012.10.10 add
bool CheckSysLink(SSearchPipeList *pList, PickSet &ss)
{
	ss.Free();
	if (pList == NULL)
	{
		return true;
	}

	std::stack<SSearchPipeList*> stackData;
	stackData.push(pList);
	SSearchPipeList *pTemp = NULL;
	while (!stackData.empty())
	{
		pTemp = stackData.top();
		stackData.pop();

		if (pTemp->m_iType == 0) // 管线
		{
			if (pTemp->m_pPrevious != NULL && pTemp->m_pPrevious->m_iType != 3 && pTemp->m_pPrevious->m_iType != 4)
			{
				ss += pTemp->m_ID;
			}
		}

		for (int i = 0; i < pTemp->m_lstNode.Length(); i++)
		{
			stackData.push(pTemp->m_lstNode[i]);
			if (pTemp->m_iType == 0 && pTemp->m_lstNode[i]->m_iType != 3 && pTemp->m_lstNode[i]->m_iType != 4)
			{
				ss += pTemp->m_ID;
			}
		}
	}
	return ss.Length() == 0 ? true : false;
}

void ElevationCalc()
{
	RBList rbMask = ads_buildlist(-4, _T("<or"),
		-4, _T("<and"), RTDXF0, _T("AEC_ZT_WELL"), 8, LAY_WELL_DIRT, -4, _T("and>"),
		-4, _T("<and"), RTDXF0, _T("AEC_ZT_WELL"), 8, LAY_WELL_RAIN, -4, _T("and>"),
		-4, _T("<and"), RTDXF0, _T("AEC_ZT_WELL"), 8, LAY_WELL_USELESS, -4, _T("and>"),
		-4, _T("or>"), NULL);

	Entity entMain;
	if (GlobalFunc::SelectEntity(_T("\n请选择排出井<退出>:"), entMain, rbMask) != RTNORM)
	{
		return;
	}

	SSearchPipeList *pListAll = new SSearchPipeList();
	PickSet ssAll(SS_FREE);
	ssAll += entMain;

	if (!GlobalFunc::SearchSprinkPipeSys(entMain, NULL, pListAll, ssAll))
	{
		acutPrintf(_T("\n系统有回路！"));
		delete pListAll;
		return;
	}

	if (entMain.Is(_T("AEC_ZT_WELL")))
	{
		pListAll->m_iType = 3;
	}

	// 处理计算过的管网 cet 2012.7.26 add
	if (IsCalced(pListAll, false))
	{
		ssAll.Redraw(3);
		TCHAR szTmp[256];
		int nRet = 0;
		INITGET_BEG(0, _T("A"));
		nRet = ads_getkword(_T("\n需要计算的管网系统已高亮显示[读取已经算信息(A)]<重新计算>:"), szTmp);
		INITGET_END();
		if (nRet == RTNORM)
		{
			ssAll.Redraw(4);
			// 关闭无关图层
			CString strPipeLayer = GetPipeLayer(pListAll);
			SetLayerOpenClose(strPipeLayer, TRUE);
			// 检查管网系统，保证待计算管网末端(叶子节点)均为井
			CheckPipeSys(pListAll);
			// cet 2012.10.10 add 检查管网连接
			PickSet ss(SS_FREE);
			if (!CheckSysLink(pListAll, ss))
			{
				delete pListAll;
				AfxMessageBox(_T("管线间缺少井，无法计算！"));
				DrawTipLabel(ss);
				GlobalFunc::AnyKeyReturn(_T("\n按任意键清除错误标记:"));
				ss.Erase();
				// 打开所有图层
				SetLayerOpenClose(strPipeLayer, FALSE);
				return;
			}

			CTemporaryResourceOverride vTemp2;
			CElevationCalcDlg dlg;
			dlg.SetCalced(TRUE);
			dlg.SetPipeSysList(pListAll);
			dlg.SetPipeType(strPipeLayer);
			dlg.DoModal();
			delete pListAll;
			// 打开所有图层
			SetLayerOpenClose(strPipeLayer, FALSE);
			return;
		}
		else if (nRet == RTCAN)
		{
			ssAll.Redraw(4);
			delete pListAll;
			return;
		}
	}

	// 关闭无关图层
	CString strPipeLayer = GetPipeLayer(pListAll);
	SetLayerOpenClose(strPipeLayer, TRUE);

	// 设置管径坡度
	CTemporaryResourceOverride vTemp1;
	CEditPipeDnGradientDlg dlg1(0, acedGetAcadFrame());
	dlg1.SetPipeList(pListAll);
	dlg1.Create(IDD_PIPE_RADIUSGRADIENT);
	dlg1.ShowWindow(SW_SHOW);
	dlg1.ModifyPipe();

	// cet 2011.10.28 add 检查管网系统，保证待计算管网末端(叶子节点)均为井
	CheckPipeSys(pListAll);
	// cet 2012.10.10 add 检查管网连接
	PickSet ss(SS_FREE);
	if (!CheckSysLink(pListAll, ss))
	{
		delete pListAll;
		AfxMessageBox(_T("管线间缺少井，无法计算！"));
		DrawTipLabel(ss);
		GlobalFunc::AnyKeyReturn(_T("\n按任意键清除错误标记:"));
		ss.Erase();
		// 打开所有图层
		SetLayerOpenClose(strPipeLayer, FALSE);
		return;
	}

	CTemporaryResourceOverride vTemp2;
	CElevationCalcDlg dlg;
	dlg.SetPipeSysList(pListAll);
	dlg.SetPipeType(strPipeLayer);
	dlg.DoModal();
	delete pListAll;

	// 打开所有图层
	SetLayerOpenClose(strPipeLayer, FALSE);
}

CElevationCalcGrid::CElevationCalcGrid()
{
	m_nRowForEndWell = -1;
	m_bModifyColor = FALSE;
}

BEGIN_MESSAGE_MAP(CElevationCalcGrid, WDGrid)
	//{{AFX_MSG_MAP(CElevationCalcGrid)
	ON_WM_MOUSEMOVE()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

void CElevationCalcGrid::SetWnd(CElevationCalcDlg* pWnd)
{
	m_pWnd = pWnd;
}

void CElevationCalcGrid::OnDblClick(WDGridRow&row)
{
	if (m_pWnd != NULL)
	{
		m_pWnd->DblClickLst();
	}
}

bool CElevationCalcGrid::OnModified(WDGridCell&cell, CString &text)
{
	long i = cell.GetColIndex();
	if ((i == 4 || i == 3) && m_pWnd != NULL)
	{
		m_pWnd->UpdatePipeInfo(cell.GetRowIndex(), i, _tstof(text));
	}

	return true;
}

void CElevationCalcGrid::OnBeforeRefresh(WDGridCell &cell)
{
	if (cell.GetColIndex() == 0 || cell.GetColIndex() == 1)
	{
		std::set<int>::iterator it;
		it = m_setRow.find(cell.GetRowIndex());
		if (it != m_setRow.end())
		{
			CDC&dc = GetDC();
			COLORREF color = acedGetRGB(6);
			dc.SetTextColor(color);
			dc.SetBkMode(TRANSPARENT);
		}

		//		cet 2011.7.26 modify
		// 		else
		// 			WDGrid::OnBeforeRefresh(cell);

		//      cet 2011.11.28 modify 为满足不同情况跌水井设置
		// 		std::vector<CString>::iterator it1;
		// 		it1 = std::find(m_vecWellName.begin(), m_vecWellName.end(), cell.GetText());
		// 		if (it1 != m_vecWellName.end())
		// 		{
		// 			CDC&dc=GetDC();
		// 			COLORREF color=acedGetRGB(2);
		// 			dc.SetBkColor(color);
		// 			dc.SetBkMode(TRANSPARENT);
		// 		}
		// 
		// 		if (it == m_setRow.end() && it1 == m_vecWellName.end())
		// 		{
		// 			WDGrid::OnBeforeRefresh(cell);
		// 		}
		std::map<CString, int>::iterator itS;
		CString sWellName = (LPCTSTR)cell.GetText();
		itS = m_mapWellColor.find(sWellName);
		if (itS != m_mapWellColor.end())
		{
			CDC&dc = GetDC();
			COLORREF color = acedGetRGB((*itS).second);
			dc.SetBkColor(color);
			dc.SetBkMode(TRANSPARENT);
		}

		if (it == m_setRow.end() && itS == m_mapWellColor.end())
		{
			WDGrid::OnBeforeRefresh(cell);
		}
	}
	else if (cell.GetColIndex() == 9 && cell.GetRowIndex() == m_nRowForEndWell &&
		m_bModifyColor)
	{
		CDC&dc = GetDC();
		COLORREF color = acedGetRGB(6);
		dc.SetTextColor(color);
		dc.SetBkMode(TRANSPARENT);
	}
	else
		WDGrid::OnBeforeRefresh(cell);
}

void CElevationCalcGrid::SetColorPipe(const std::vector<AcDbObjectId> &data)
{
	m_setRow.clear();
	std::vector<AcDbObjectId>::const_iterator it;
	for (it = data.begin(); it != data.end(); it++)
	{
		std::map<AcDbObjectId, int>::iterator it2;
		it2 = m_mapRow.find(*it);
		if (it2 != m_mapRow.end())
		{
			m_setRow.insert((*it2).second);
		}
	}
}

void CElevationCalcGrid::SetRowforEndWell(int nRow)
{
	m_nRowForEndWell = nRow;
}

void CElevationCalcGrid::SetPipeRow(const std::map<AcDbObjectId, int> &data)
{
	m_mapRow = data;
}

void CElevationCalcGrid::SetModifyColorforEndWell(BOOL bModify)
{
	m_bModifyColor = bModify;
}

// void CElevationCalcGrid::SetDropWell(const std::vector<CString> &data)
// {
// 	m_vecWellName.clear();
// 	m_vecWellName = data;
// }

void CElevationCalcGrid::setWellColor(const std::map<CString, int> &mapWellColor)
{
	m_mapWellColor = mapWellColor;
}

void CElevationCalcGrid::setWellTip(const std::map<CString, CString> &mapWellTip)
{
	m_mapWellTip = mapWellTip;
}

void CElevationCalcGrid::OnCellComboString(WDGridCell&cell, CComboBox&combo)
{
	if (cell.GetColIndex() == 3)
	{
		combo.AddString(_T("200"));
		combo.AddString(_T("250"));
		combo.AddString(_T("300"));
		combo.AddString(_T("350"));
		combo.AddString(_T("400"));
		combo.AddString(_T("450"));
		combo.AddString(_T("500"));
		combo.AddString(_T("600"));
	}
	else if (cell.GetColIndex() == 4)
	{
		combo.AddString(_T("1"));
		combo.AddString(_T("2"));
		combo.AddString(_T("3"));
		combo.AddString(_T("4"));
		combo.AddString(_T("5"));
		combo.AddString(_T("6"));
	}
}

BOOL CElevationCalcGrid::PreTranslateMessage(MSG* pMsg)
{
	if (pMsg->message == WM_MOUSEMOVE)
	{
		if (m_ToolTip.m_hWnd != NULL)
		{
			m_ToolTip.RelayEvent(pMsg);
		}
	}

	return  WDGrid::PreTranslateMessage(pMsg);
}

void CElevationCalcGrid::OnMouseMove(UINT nFlags, CPoint point)
{
	CString sCellText = _T("");
	long lRow = -1, lCol = -1;
	PtToCell(point, lRow, lCol);
	std::map<CString, CString>::iterator it; // cet 2011.11.28 add
	if (IsValidRow(lRow) && IsValidCol(lCol) && (lCol == 0 || lCol == 1))
	{
		CString sText = (LPCTSTR)GetCell(lRow, lCol).GetText();
		//      cet 2011.11.28 modify
		//		std::vector<CString>::iterator it;
		// 		it = std::find(m_vecWellName.begin(), m_vecWellName.end(), sText);
		// 		if (it != m_vecWellName.end())
		// 		{
		// 			sCellText = _T("计算中产生的跌水井");
		// 		}

		it = m_mapWellTip.find(sText);
		if (it != m_mapWellTip.end())
		{
			sCellText = (*it).second;
		}
	}

	SetToolTipText(sCellText, TRUE);

	WDGrid::OnMouseMove(nFlags, point);
}

void CElevationCalcGrid::SetToolTipText(LPCTSTR pspText, BOOL bActivate)
{
	if (pspText == NULL) return;

	if (m_ToolTip.m_hWnd == NULL)
	{
		m_ToolTip.Create(this);
		m_ToolTip.SetMaxTipWidth(500);
		CRect rect;
		GetClientRect(rect);
		m_ToolTip.AddTool(this, LPSTR_TEXTCALLBACK, rect);
	}

	m_ToolTip.UpdateTipText(pspText, this);
	m_ToolTip.Activate(bActivate);
}


CElevationCalcDlg::CElevationCalcDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CElevationCalcDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CElevationCalcDlg)
	m_dWndEdtLayingDepth = 1.1;
	m_dMinThick = 0.7;
	m_bWndChkReverseCalc = FALSE;
	m_bWndChkLayingDepth = FALSE;
	m_bWndChkMinThick = FALSE;
	m_strPipeEleDown = _T("");
	//}}AFX_DATA_INIT
	m_bCalc = FALSE;
	//	m_pPositiveCalc = new PositiveElevationCalc;
	m_pPositiveCalc = NULL;
	m_pReverseCalc = NULL;
	m_pElevationCalc = NULL;
	m_bFirstRunCmd = false; // cet 2012.6.21 add
	m_bOnlySWell = false;   // cet 2012.6.26 add
}

CElevationCalcDlg::~CElevationCalcDlg()
{
	if (m_pReverseCalc != NULL)
	{
		delete m_pReverseCalc;
	}

	if (m_pPositiveCalc != NULL)
	{
		delete m_pPositiveCalc;
	}
}

void CElevationCalcDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CElevationCalcDlg)
	DDX_Control(pDX, IDC_LIST_PIPE, m_lstCtrl);
	DDX_Text(pDX, IDC_EDIT_STARTDEEP, m_dWndEdtLayingDepth);
	DDX_Text(pDX, IDC_EDIT_MINTHICK, m_dMinThick);
	DDX_Check(pDX, IDC_CHECK_EDOWNELE, m_bWndChkReverseCalc);
	DDX_Text(pDX, IDC_EDIT_ENDDOWNELE, m_strPipeEleDown);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CElevationCalcDlg, CDialog)
	//{{AFX_MSG_MAP(CElevationCalcDlg)
	ON_BN_CLICKED(IDC_BTN_MODIFYELE, OnBtnModifyele)
	ON_BN_CLICKED(IDC_BTN_CALC, OnBtnCalc)
	ON_BN_CLICKED(IDC_BTN_LAYINGDEPTH, OnBtnLayingdepth)
	ON_BN_CLICKED(IDC_BTN_TODWG, OnBtnTodwg)
	ON_BN_CLICKED(IDC_BTN_TABLE, OnBtnTable)
	ON_BN_CLICKED(IDC_CHECK_EDOWNELE, OnCheckEdownele)
	ON_BN_CLICKED(IDC_BTN_LOOK, OnBtnLook)
	ON_EN_CHANGE(IDC_EDIT_STARTDEEP, OnChangeEditStartdeep)
	ON_EN_CHANGE(IDC_EDIT_MINTHICK, OnChangeEditMinthick)
	ON_WM_CLOSE()
	ON_EN_CHANGE(IDC_EDIT_ENDDOWNELE, OnChangeEditEnddownele)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


void CElevationCalcDlg::SetPipeSysList(SSearchPipeList *pList)
{
	m_pAllList = pList;
}

void CElevationCalcDlg::SetPipeType(CString &sPipeLayer)
{
	if (sPipeLayer.Compare(LAY_PIPE_DIRT) == 0)
	{
		m_sPipeType = _T("污水管道高程表");
	}
	else if (sPipeLayer.Compare(LAY_PIPE_USELESS) == 0)
	{
		m_sPipeType = _T("废水管道高程表");
	}
	else
	{
		m_sPipeType = _T("雨水管道高程表");
	}
}

CString CElevationCalcDlg::GetPipeType()
{
	return m_sPipeType;
}

BOOL CElevationCalcDlg::OnInitDialog()
{
	CDialog::OnInitDialog();

	m_lstCtrl.Clear();
	m_lstCtrl.Create(this, IDC_LIST_PIPE);
	m_lstCtrl.FitLastCol();
	m_lstCtrl.SetNoAppendButton(TRUE);
	m_lstCtrl.SetNoDefaultMenu(true);
	m_lstCtrl.SetWnd(this);

	m_lstCtrl.AppendCol(_T("起点"), 35);
	m_lstCtrl.AppendCol(_T("终点"), 35);
	m_lstCtrl.AppendCol(_T("管长m"), 50);
	m_lstCtrl.AppendCol(_T("管径mm"), 50);

	m_lstCtrl.AppendCol(_T("坡度‰"), 50);
	m_lstCtrl.AppendCol(_T("管底坡降"), 56);

	m_lstCtrl.AppendCol(_T("起点"), 45);
	m_lstCtrl.AppendCol(_T("终点"), 45);

	m_lstCtrl.AppendCol(_T("起点"), 45);
	m_lstCtrl.AppendCol(_T("终点"), 45);
	m_lstCtrl.AppendCol(_T("起点"), 46);
	m_lstCtrl.AppendCol(_T("终点"), 46);

	m_lstCtrl.GetCol(0).SetReadOnly();
	m_lstCtrl.GetCol(1).SetReadOnly();
	m_lstCtrl.GetCol(2).SetReadOnly();
	m_lstCtrl.GetCol(5).SetReadOnly();
	m_lstCtrl.GetCol(6).SetReadOnly();
	m_lstCtrl.GetCol(7).SetReadOnly();
	m_lstCtrl.GetCol(8).SetReadOnly();
	m_lstCtrl.GetCol(9).SetReadOnly();
	m_lstCtrl.GetCol(10).SetReadOnly();
	m_lstCtrl.GetCol(11).SetReadOnly();
	// cet 2011.6.16 add
	m_lstCtrl.GetCol(3).SetComboEdit();
	m_lstCtrl.GetCol(4).SetComboEdit();

	COLORREF color = RGB(255, 0, 0);
	m_lstCtrl.GetCol(3).SetTextColor(color);
	m_lstCtrl.GetCol(4).SetTextColor(color);

	color = RGB(0, 0, 255);
	m_lstCtrl.GetCol(5).SetTextColor(color);
	m_lstCtrl.GetCol(11).SetTextColor(color);
	m_lstCtrl.GetCol(8).SetTextColor(color);
	m_lstCtrl.GetCol(9).SetTextColor(color);
	m_lstCtrl.GetCol(10).SetTextColor(color);

	// cet 2012.6.21 add 初始化系统起点井埋深数据
	InitSWellLayDepth();

	m_pPositiveCalc = new PositiveElevationCalc;
	m_pElevationCalc = m_pPositiveCalc;
	if (m_pPositiveCalc != NULL)
	{
		m_pPositiveCalc->SetPipeSys(m_pAllList);
		m_pPositiveCalc->SetLayingDepth(m_dWndEdtLayingDepth);
		m_pPositiveCalc->SetMinThick(m_dMinThick);
		m_pPositiveCalc->UpDatePipeSys();
		m_pPositiveCalc->CalcLenStartWellToEnd(m_pAllList, 0);

		m_pPositiveCalc->InitCalcSys();
		m_pPositiveCalc->EnableSetLayDepth(!m_bFirstRunCmd);   // cet 2012.6.21 add
		m_pPositiveCalc->SetLayDepthData(&m_mapSWellLayDepth); // cet 2012.6.21 add
		m_pPositiveCalc->SetOnlySWell(m_bOnlySWell);           // cet 2012.6.26 add

		std::vector<CALCNODE> data;
		m_pPositiveCalc->Sort(data);
		std::map<AcDbObjectId, int> mapRow;
		for (size_t i = 0; i < data.size(); i++)
		{
			mapRow.insert(std::make_pair(data[i].idP, i));
			if (data[i].idE == m_pAllList->m_ID) // 排出井
			{
				m_lstCtrl.SetRowforEndWell(i);
			}
		}
		m_lstCtrl.SetPipeRow(mapRow);
	}

	m_pReverseCalc = new ReverseElevationCalc;
	if (m_pReverseCalc != NULL)
	{
		m_pReverseCalc->SetPipeSys(m_pAllList);
		m_pReverseCalc->SetLayingDepth(m_dWndEdtLayingDepth);
		m_pReverseCalc->SetMinThick(m_dMinThick);
		m_pReverseCalc->UpDatePipeSys();
		m_pReverseCalc->CalcLenStartWellToEnd(m_pAllList, 0);

		m_pReverseCalc->InitCalcSys();
		m_pReverseCalc->EnableSetLayDepth(!m_bFirstRunCmd);   // cet 2012.6.21 add
		m_pReverseCalc->SetLayDepthData(&m_mapSWellLayDepth); // cet 2012.6.21 add
		m_pReverseCalc->SetOnlySWell(m_bOnlySWell);           // cet 2012.6.26 add
	}

	// 管网已经计算过 cet 2012.7.26 add
	if (m_bCalc)
	{
		UpdateCalcedData();
	}

	GetWellNodeInfo();
	UpdateGrid();

	OnCheckEdownele();

	// cet 2011.7.26 add 获得跌水井
	GetDropWell(m_vecWellName);

	return TRUE;
}

void CElevationCalcDlg::UpdateGrid()
{
	std::vector<CALCNODE> data;
	m_pElevationCalc->Sort(data);
	std::vector<CALCNODE>::iterator it;
	int nIndex = 0;
	m_lstCtrl.Clear();
	for (it = data.begin(); it != data.end(); it++)
	{
		m_lstCtrl.AppendRow();
		m_lstCtrl.GetCell(nIndex, 0).SetText((*it).strSWellName);
		m_lstCtrl.GetCell(nIndex, 1).SetText((*it).strEWellName);
		CString strTemp;
		strTemp.Format(_T("%.2f"), (*it).dPipeLen);
		m_lstCtrl.GetCell(nIndex, 2).SetText(strTemp);
		strTemp.Format(_T("%.0f"), (*it).dPipeDn);
		m_lstCtrl.GetCell(nIndex, 3).SetText(strTemp);
		strTemp.Format(_T("%.3f"), (*it).dGradient * 1000);
		m_lstCtrl.GetCell(nIndex, 4).SetText(strTemp);
		strTemp.Format(_T("%.3f"), (*it).dGradientDist);
		m_lstCtrl.GetCell(nIndex, 5).SetText(strTemp);
		strTemp.Format(_T("%.3f"), (*it).dWellEleUpS);
		m_lstCtrl.GetCell(nIndex, 6).SetText(strTemp);
		strTemp.Format(_T("%.3f"), (*it).dWellEleUpE);
		m_lstCtrl.GetCell(nIndex, 7).SetText(strTemp);

		strTemp.Format(_T("%.3f"), (*it).dPipeEleS);
		m_lstCtrl.GetCell(nIndex, 8).SetText(strTemp);

		strTemp.Format(_T("%.3f"), (*it).dPipeEleE);
		m_lstCtrl.GetCell(nIndex, 9).SetText(strTemp);

		strTemp.Format(_T("%.3f"), (*it).dDeepS);
		m_lstCtrl.GetCell(nIndex, 10).SetText(strTemp);

		strTemp.Format(_T("%.3f"), (*it).dDeepE);
		m_lstCtrl.GetCell(nIndex, 11).SetText(strTemp);
		++nIndex;
	}
}

void CElevationCalcDlg::UpdateGroundEleForGrid()
{
	std::vector<CALCNODE> data;
	m_pElevationCalc->Sort(data);
	std::vector<CALCNODE>::iterator it;
	int nIndex = 0;
	for (it = data.begin(); it != data.end(); it++)
	{
		CString strTemp;
		strTemp.Format(_T("%.3f"), (*it).dWellEleUpS);
		m_lstCtrl.GetCell(nIndex, 6).SetText(strTemp);
		strTemp.Format(_T("%.3f"), (*it).dWellEleUpE);
		m_lstCtrl.GetCell(nIndex, 7).SetText(strTemp);
		++nIndex;
	}
}

//vector 排序函数 zxl 2011.11.15 add
bool CompareHeight(double dLen1, double dLen2)
{
	if (dLen1 - dLen2 > 0.0001)
	{
		return true;
	}
	return false;
}

//计算井的跌落高度  zxl 2011.11.15 add
bool CElevationCalcDlg::GetWellDropHeight(AcDbObjectId &id, CString &sWellDorp)
{
	std::vector<CALCNODE> vecData = m_pElevationCalc->GetLstData();
	std::vector<double> vec;
	std::vector<CALCNODE>::iterator it;
	CString sTemp;
	for (it = vecData.begin(); it != vecData.end(); it++)
	{
		sTemp.Empty();
		if ((*it).idS == id)
		{
			sTemp.Format(_T("%0.3f"), (*it).dPipeEleS);
		}
		else if ((*it).idE == id)
		{
			sTemp.Format(_T("%0.3f"), (*it).dPipeEleE);
		}
		if (!sTemp.IsEmpty())
		{
			double dEle = _tstof(sTemp);
			vec.push_back(dEle);
		}
	}

	if (vec.size() > 1)
	{
		sTemp.Empty();
		std::sort(vec.begin(), vec.end(), CompareHeight);
		double dEleS = vec.front();
		double dEleE = vec.back();
		double dEle = fabs(dEleE - dEleS);
		sTemp.Format(_T("%0.3f"), dEle);
		if (fabs(dEle - 0.0) > 0.001)
		{
			sWellDorp = sTemp;
		}
		return true;
	}
	return false;
}

void CElevationCalcDlg::OnBtnModifyele()
{
	CTemporaryResourceOverride vTemp;
	CWellCalcModifyEleDlg dlg(0);
	dlg.SetDropWell(m_vecWellName);//获取跌水井信息 zxl 2012.01.16 add
	dlg.SetDlgType(true);

	std::vector<WELLNODE>::iterator it;
	for (it = m_vecWellInfo.begin(); it != m_vecWellInfo.end(); it++)
	{
		TWellData *pList = new TWellData;
		pList->m_ID = (*it).id;
		pList->m_bIsWell = TRUE;
		pList->m_nGroundEle = (*it).dGroundEle;
		pList->m_bIsDropWell = (*it).bIsDropWell;
		pList->m_csName = (*it).strWellName;
		pList->m_nUpEle = (*it).dWellEleUp;
		pList->m_nDownEle = (*it).dWellEleDown;
		pList->m_nWellRadius = (*it).dWellRadius;
		pList->m_nSpare = (*it).dSand * 1000;
		pList->m_nFrondDownEle = -9999;

		//zxl 2011.11.15 add 设置跌落高度
		GetWellDropHeight((*it).id, pList->m_csSpare);
		dlg.m_lstWellSys.Append(pList);
	}

	if (dlg.DoModal() == IDOK)
	{
		// cet 2011.7.26 add 修改前的跌水井信息
		std::vector<CString> vecOrigin;
		GetDropWell(vecOrigin);

		std::map<AcDbObjectId, double> data;
		for (int i = 0; i < dlg.m_lstWellSys.Length(); i++)
		{
			TWellData *plist = dlg.m_lstWellSys[i];

			if (plist->m_csName == _T("HC")) // 防止乱改出错
			{
				plist->m_nDownEle = 0.0;
				plist->m_bIsDropWell = FALSE;
			}

			if (m_pPositiveCalc != NULL)
			{
				m_pPositiveCalc->ModifyWellInfo(plist->m_ID, plist->m_nUpEle, plist->m_nDownEle, plist->m_bIsDropWell); // 修改井面标高
			}

			if (plist->m_bIsDropWell)
			{
				data.insert(std::make_pair(plist->m_ID, plist->m_nDownEle));
			}

			if (m_pReverseCalc != NULL)
			{
				m_pReverseCalc->ModifyWellInfo(plist->m_ID, plist->m_nUpEle, plist->m_nDownEle, plist->m_bIsDropWell); // 修改井面标高
				m_pReverseCalc->UpdateDropWell(data);
			}
			UpdateWellNode(plist->m_ID, plist->m_nGroundEle, plist->m_nUpEle, plist->m_nWellRadius, plist->m_nSpare, plist->m_nDownEle, plist->m_bIsDropWell);
		}

		// 		// cet 2011.7.26 add 获得跌水井
		// 		std::vector<CString> vecNew;
		// 		GetDropWell(vecNew);
		// 		std::vector<CString>::iterator it, it1;
		// 		for (it = vecNew.begin(); it != vecNew.end(); it++)
		// 		{
		// 			it1 = std::find(vecOrigin.begin(), vecOrigin.end(), *it);
		// 			if (it1 == vecOrigin.end()) // 用户增加的跌水井
		// 			{
		// 				m_vecWellName.push_back(*it);
		// 			}
		// 		}
		// 
		// 		for (it = vecOrigin.begin(); it != vecOrigin.end(); it++)
		// 		{
		// 			it1 = std::find(vecNew.begin(), vecNew.end(), *it);
		// 			if (it1 == vecNew.end()) // 用户删除的跌水井
		// 			{
		// 				it1 = std::find(m_vecWellName.begin(), m_vecWellName.end(), *it);
		// 				if (it1 != m_vecWellName.end())
		// 				{
		// 					m_vecWellName.erase(it1);
		// 				}
		// 			}
		// 		}

		dlg.GetDropWellByCustom(m_vecWellName);//zxl 2012.01.18 add

		SetDropWellColor();
		UpdateGroundEleForGrid(); //更新表格地面标高值
		m_lstCtrl.Invalidate();
		UpdateData(FALSE);
	}
}

void CElevationCalcDlg::OnBtnCalc()
{
	//zxl 2012.01.18 add
	std::vector<CString> vecOld;
	GetDropWell(vecOld);
	std::map<CString, double> mapDropWellEle;
	GetDropWellEle(vecOld, mapDropWellEle);

	if (m_pReverseCalc == m_pElevationCalc) // 反算
	{
		if (m_strPipeEleDown.IsEmpty())
		{
			AfxMessageBox(_T("请输入终点管内底标高！"));
			return;
		}
	}

	if (m_pElevationCalc != NULL)
	{
		// cet 2011.7.26 add 
		SetDropWellColor();

		m_bCalc = TRUE;
		m_lstCtrl.SetModifyColorforEndWell(FALSE);
		m_pElevationCalc->LayingDepthCalc(); // 埋深计算
		m_pElevationCalc->CheckSys(this);
		std::vector<AcDbObjectId> data;
		m_pElevationCalc->GetCheckInfoforPipe(data);
		m_lstCtrl.SetColorPipe(data);

		// 反算时计算排出井管内底标高是否与用户设定值相同
		m_lstCtrl.SetModifyColorforEndWell(FALSE);
		if (m_pElevationCalc == m_pReverseCalc)
		{
			ReverseElevationCalc *pCalc = static_cast<ReverseElevationCalc*>(m_pReverseCalc);
			if (pCalc != NULL && pCalc->IsModifyEleforEndWell())
			{
				m_lstCtrl.SetModifyColorforEndWell(TRUE);
			}
		}
		UpdateWellNode();
		// cet 2012.6.21 add 更新起点井埋深数据
		UpdatelayDepthData();

		//获取当前所有跌水井并更新计算后的跌水井信息 zxl 2012.01.18 add
		std::vector<CString> vecCalc;
		GetDropWell(vecCalc);
		UpdateDropWellByCustom(mapDropWellEle, vecCalc);

		// cet 2011.7.26 add
		SetDropWellColor();

		UpdateGrid(); // 在表格中显示信息
	}
}

//获取跌水井井底标高
void CElevationCalcDlg::GetDropWellEle(std::vector<CString> &vecWell, std::map<CString, double> &mapEle)
{
	std::vector<WELLNODE>::iterator it;
	std::vector<CString>::iterator itWell;
	for (it = m_vecWellInfo.begin(); it != m_vecWellInfo.end(); it++)
	{
		itWell = std::find(vecWell.begin(), vecWell.end(), (*it).strWellName);
		if (itWell != vecWell.end())
		{
			mapEle.insert(std::make_pair(*itWell, (*it).dWellEleDown));
		}
	}
}

//设置计算后生成的跌水井
void CElevationCalcDlg::UpdateDropWellByCustom(std::map<CString, double> &mapEle, std::vector<CString> &vecCalc)
{
	std::vector<WELLNODE>::iterator it;
	std::vector<CString>::iterator itWell;
	std::map<CString, double>::iterator itmap;
	ads_name name;
	for (it = m_vecWellInfo.begin(); it != m_vecWellInfo.end(); it++)
	{
		itWell = std::find(vecCalc.begin(), vecCalc.end(), (*it).strWellName);
		if (itWell != vecCalc.end())
		{
			itmap = mapEle.find((*it).strWellName);
			if ((itmap != mapEle.end() && fabs((*it).dWellEleDown - itmap->second) > 0.001) || itmap == mapEle.end())
			{
				acdbGetAdsName(name, (*it).id);
				GlobalFunc::WriteXdata(name, _T("DropWellType"), _T("calc"));
				itWell = std::find(m_vecWellName.begin(), m_vecWellName.end(), (*it).strWellName);
				if (itWell != m_vecWellName.end())//清除计算后生成的跌水井
				{
					m_vecWellName.erase(itWell);
				}
			}
		}
	}
}

void CElevationCalcDlg::OnBtnLayingdepth()
{
	GlobalFunc::HideDialog(this, TRUE);
	RBList rbMask = ads_buildlist(-4, _T("<or"),
		-4, _T("<and"), RTDXF0, _T("AEC_ZT_WELL"), 8, LAY_WELL_DIRT, -4, _T("and>"),
		-4, _T("<and"), RTDXF0, _T("AEC_ZT_WELL"), 8, LAY_WELL_RAIN, -4, _T("and>"),
		-4, _T("<and"), RTDXF0, _T("AEC_ZT_WELL"), 8, LAY_WELL_USELESS, -4, _T("and>"),
		-4, _T("or>"), NULL);

	//显示井埋设深度标注
	if (m_mapWellDim.empty())
	{
		std::vector<SSearchPipeList*> &m_vecWell = m_pReverseCalc->GetStartWell();
		std::vector<SSearchPipeList*>::iterator it;
		for (it = m_vecWell.begin(); it != m_vecWell.end(); it++)
		{
			double dLayingDepth = m_pElevationCalc->GetWellLayDepth((*it)->m_ID);
			CString strLayingDepth;
			strLayingDepth.Format(_T("%.3f"), dLayingDepth);
			AcDbObjectId id = InsertWellDim(GetWellLayingDepthDimPt((*it)->m_ID), strLayingDepth);
			m_mapWellDim.insert(std::make_pair((*it)->m_ID, id));
		}
	}
	else
	{
		UpdateWellDim();
		ShowWellDim(TRUE);
	}

	PickSet ss(SS_FREE);
	while (TRUE)
	{
		AcDbObjectId id;
		CString strTip = _T("\n请选择需要更改埋深的起点井<退出>：");
		while (TRUE)
		{
			if (GlobalFunc::SelectEntities(strTip, ss, rbMask) == RTNORM)
			{
				std::vector<SSearchPipeList*> &m_vecWell = m_pPositiveCalc->GetStartWell();
				BOOL bSysSWell = TRUE;
				for (long i = 0; i < ss.Length(); i++)
				{
					Entity ent = ss[i];
					acdbGetObjectId(id, ent);
					std::vector<SSearchPipeList*>::iterator it;
					for (it = m_vecWell.begin(); it != m_vecWell.end(); it++)
					{
						if ((*it)->m_ID == id)
						{
							break;
						}
					}

					if (it == m_vecWell.end())
					{
						strTip = _T("\n请选择起点井<退出>：");
						bSysSWell = FALSE;
						break;
					}
				}

				if (bSysSWell)
				{
					break;
				}
				else
				{
					continue;
				}

			}
			else
			{
				ShowWellDim(FALSE);
				GlobalFunc::HideDialog(this, FALSE);
				acedUpdateDisplay();
				actrTransactionManager->flushGraphics();            //acad 刷新
				return;
			}
		}

		double dLayingDepth = m_dWndEdtLayingDepth;
		CTemporaryResourceOverride vTemp;
		CEditWellLayingDepthDlg dlg;
		dlg.SetLayingDepth(dLayingDepth);
		dlg.SetFocus();
		if (dlg.DoModal() == IDOK)
		{
			dLayingDepth = dlg.GetLayingDepth();
			for (long i = 0; i < ss.Length(); i++)
			{
				acdbGetObjectId(id, ss[i]);
				if (m_pPositiveCalc != NULL)
				{
					m_pPositiveCalc->ModifyWellLayingDepth(id, dLayingDepth);
				}

				if (m_pReverseCalc != NULL)
				{
					m_pReverseCalc->ModifyWellLayingDepth(id, dLayingDepth);
				}

				UpdateWellNode(id, dLayingDepth);
				UpdatelayDepthData(id, dLayingDepth); // cet 2012.6.21 add 

				// 更新井埋设深度标注值
				CString strLayingDepth;
				strLayingDepth.Format(_T("%.3f"), dLayingDepth);
				std::map<AcDbObjectId, AcDbObjectId>::iterator it;
				for (it = m_mapWellDim.begin(); it != m_mapWellDim.end(); it++)
				{
					if ((*it).first == id)
					{
						UpdateWellDim((*it).second, strLayingDepth);
					}
				}
			}
		}
	}
}

// cet 2011.8.30 add 获取文字宽度
double GetTextLength(const TCHAR*  fontName, const TCHAR*  bigFontName, const double textSize, const double xScale, const CString &sText)
{
	AcGePoint2d ptMin, ptMax;
	AcGiTextStyle style(fontName, bigFontName, textSize, xScale, 0, 0, Adesk::kFalse, Adesk::kFalse, Adesk::kFalse, Adesk::kFalse, Adesk::kFalse);
	style.extentsBox(sText, FALSE, sText.GetLength(), FALSE, ptMin, ptMax);
	return fabs(ptMax.x - ptMin.x);
}

// cet 2012.1.6 add 获取管线标注文字宽度
double GetPipeDimLen(CDbPipe *pPipe)
{
	AecXDbText text;
	text.setPropertiesFrom(pPipe);
	text.SetHeight(pPipe->GetTextHeight());
	AcDbObjectId id = pPipe->GetTextStyle();
	if (id.isNull())
	{
		id = GlobalFunc::InitTwtTextStyle(g_Option::instance().g_csPipeDnStyle);
		text.SetHeight(g_Option::instance().g_nPipeDnHeight);
	}
	text.SetStyleId(id);
	CString sLabel = pPipe->GetLabel();
	if (sLabel.IsEmpty()) // 无前缀时添加默认前缀以便获得正确的标注文字
	{
		pPipe->SetLabel(_T("DN"));
	}
	CString sText = (LPCTSTR)pPipe->GetLabelText();

	// zxl add 2012.12.17 支持竖排情形
	if (pPipe->GetPipeLableDrawType() == 1)
	{
		// 		int nIndex = sText.ReverseFind(_T('\n'));
		// 		if (nIndex > 0)
		// 		{
		// 			sText = sText.Right(sText.GetLength() - nIndex - 1);
		// 		}
		CString sText1 = pPipe->GetPipeLenDimStr();
		CString sText2 = pPipe->GetPipeDnDimStr();
		CString sText3 = pPipe->GetPipeGradienDimtStr();
		int nLen1 = sText1.GetLength();
		int nLen2 = sText2.GetLength();
		int nLen3 = sText3.GetLength();
		int nLen = nLen1 > nLen2 ? nLen1 : nLen2;
		nLen = nLen > nLen3 ? nLen : nLen3;

		if (nLen == nLen1)
		{
			sText = sText1;
		}
		else if (nLen == nLen2)
		{
			sText = sText2;
		}
		else
		{
			sText = sText3;
		}
	}
	pPipe->SetLabel(sLabel); // 恢复为默认前缀
	text.SetText(sText);

	text.SetRotation(0.0);
	XPoint ptMin, ptMax;
	text.GetExtents2d(ptMin, ptMax);
	double dLen = fabs(ptMax.x - ptMin.x);

	return dLen;
}

// cet 2011.8.30 add 根据默认标注样式和短管标注样式设置管标注样式
// 需比较管长和标注长度
void SetPipeLabelType(CDbPipe *pPipe)
{
	if (pPipe == NULL)
	{
		return;
	}

	// 	if (g_iDimPipeGradientType == -1) // 不标注
	// 	{
	// 		pPipe->SetSpare(-1);
	// 	}

		// 管长
	XPoint ptS, ptE;
	pPipe->getStartPoint(ptS);
	pPipe->getEndPoint(ptE);
	double dPipeLen = ptS.Distance2d(ptE);

	// 遮挡长度
	double dHideLen = 0.0;
	AcDbObjectId id = pPipe->GetNode(0);
	AecXDbWell *pWell = NULL;
	acdbOpenObject(pWell, id, AcDb::kForRead);
	if (pWell != NULL)
	{
		dHideLen = pWell->GetScale() * 100;
		pWell->close();
	}

	if (fabs(dHideLen) < g_Option::instance()._DIST_SNAP)
	{
		id = pPipe->GetNode(1);
		acdbOpenObject(pWell, id, AcDb::kForRead);
		if (pWell != NULL)
		{
			dHideLen = pWell->GetScale() * 100;
			pWell->close();
		}
	}

	if (GlobalFunc::DocGetMeterUnitDraw())
	{
		dHideLen *= 0.01;
	}

	dPipeLen -= dHideLen;

	// 管线标注新形式 zxl 2012.12.17 modify
	// 默认标注管长
  //int iType = g_iDimPipeGradientType == 0 ? g_iDimPipeGradientType : g_iDimPipeGradientType * 100 + g_iDimPipeLen + 1;
  //pPipe->SetSpare(iType);
	pPipe->SetPipeLableDrawType(g_Option::instance().g_nDimPipeDrawType);
	pPipe->SetPipeDnDimType(g_Option::instance().g_nDimPipeDnType);
	pPipe->SetPipeLenDimType(g_Option::instance().g_iDimPipeLen);
	pPipe->SetPipeDimLableType(g_Option::instance().g_nDimPipeLabelType);
	pPipe->SetPipeGradientDimType(g_Option::instance().g_nDimPipeGradientType);
	pPipe->EnableDrawLabel(TRUE);
	if (g_Option::instance().g_nDimPipeDnType == 0 && g_Option::instance().g_iDimPipeLen == 0 && g_Option::instance().g_nDimPipeGradientType == 0)
	{
		pPipe->EnableDrawLabel(FALSE);
		pPipe->SetPipeDnDimType(1);
	}

	//cet 2012.1.9 modify 原方法存在计算误差
	//CString sText = pPipe->GetLabelText();
	//double dTextLen = GetTextLength(g_csPipeDnEng, g_csPipeDnChn, g_nPipeDnHeight * GlobalFunc::DocGetPScale(), g_nPipeDnScale, sText);
	double dTextLen = GetPipeDimLen(pPipe);
	if (dPipeLen > dTextLen)
	{
		return;
	}
	else if (g_Option::instance().g_iDimShortPipeGradientType != -1) // 短管标注
	{
		// 管线标注新形式 zxl 2012.12.17 modify
// 		iType = g_iDimShortPipeGradientType == 0 ? g_iDimShortPipeGradientType : g_iDimShortPipeGradientType * 100 + g_iDimPipeLen + 1;
// 		pPipe->SetSpare(iType);
		pPipe->SetPipeLableDrawType(g_Option::instance().g_nDimPipeDrawType);
		pPipe->SetPipeDnDimType(g_Option::instance().g_nDimShortPipeDnType);
		pPipe->SetPipeLenDimType(g_Option::instance().g_nDimShortPipeLenType);
		pPipe->SetPipeDimLableType(g_Option::instance().g_nDimPipeLabelType);
		pPipe->SetPipeGradientDimType(g_Option::instance().g_nDimShortPipeGradientType);
		if (g_Option::instance().g_nDimShortPipeDnType == 0 
			&& g_Option::instance().g_nDimShortPipeLenType == 0
			&& g_Option::instance().g_nDimShortPipeGradientType == 0)
		{
			pPipe->EnableDrawLabel(FALSE);
		}

		//cet 2012.1.9 modify 原方法存在计算误差
		//sText = pPipe->GetLabelText();
		//dTextLen = GetTextLength(g_csPipeDnEng, g_csPipeDnChn, g_nPipeDnHeight * GlobalFunc::DocGetPScale(), g_nPipeDnScale, sText);
		dTextLen = GetPipeDimLen(pPipe);
		if (dPipeLen > dTextLen)
		{
			return;
		}
		else
		{
			//pPipe->SetSpare(-1); zxl 2012.12.18 modify
			pPipe->SetPipeDnDimType(1);
			pPipe->SetPipeLenDimType(0);
			pPipe->SetPipeGradientDimType(0);
			pPipe->EnableDrawLabel(FALSE);
		}
	}
	else
	{
		//pPipe->SetSpare(-1); zxl 2012.12.18 modify
		pPipe->SetPipeDnDimType(1);
		pPipe->SetPipeLenDimType(0);
		pPipe->SetPipeGradientDimType(0);
		pPipe->EnableDrawLabel(FALSE);
	}
}

// cet 2012.1.5 add 根据初始设置中管线标注样式,计算管线可进行的标注样式
int GetPipeDimType(CDbPipe *pPipe)
{
	if (g_Option::instance().g_iDimPipeGradientType == -1) // 不标注
	{
		return -1;
	}

	// 管长
	XPoint ptS, ptE;
	pPipe->getStartPoint(ptS);
	pPipe->getEndPoint(ptE);
	double dPipeLen = ptS.Distance2d(ptE);

	// 遮挡长度
	double dHideLen = 0.0;
	AcDbObjectId id = pPipe->GetNode(0);
	AecXDbWell *pWell = NULL;
	acdbOpenObject(pWell, id, AcDb::kForRead);
	if (pWell != NULL)
	{
		dHideLen = pWell->GetScale() * 100;
		pWell->close();
	}

	if (fabs(dHideLen) < g_Option::instance()._DIST_SNAP)
	{
		id = pPipe->GetNode(1);
		acdbOpenObject(pWell, id, AcDb::kForRead);
		if (pWell != NULL)
		{
			dHideLen = pWell->GetScale() * 100;
			pWell->close();
		}
	}

	if (GlobalFunc::DocGetMeterUnitDraw())
	{
		dHideLen *= 0.01;
	}

	dPipeLen -= dHideLen;

	// 默认标注管长
	int nOriginType = static_cast<int>(pPipe->GetSpare());
	int nType = g_Option::instance().g_iDimPipeGradientType == 0 ? g_Option::instance().g_iDimPipeGradientType : g_Option::instance().g_iDimPipeGradientType * 100 + g_Option::instance().g_iDimPipeLen + 1;
	pPipe->SetSpare(nType);
	double dTextLen = GetPipeDimLen(pPipe);
	pPipe->SetSpare(nOriginType);
	if (dPipeLen > dTextLen)
	{
		return nType;
	}
	else if (g_Option::instance().g_iDimShortPipeGradientType != -1) // 短管标注
	{
		nType = g_Option::instance().g_iDimShortPipeGradientType == 0 ? g_Option::instance().g_iDimShortPipeGradientType : g_Option::instance().g_iDimShortPipeGradientType * 100 + g_Option::instance().g_iDimPipeLen + 1;
		pPipe->SetSpare(nType);
		dTextLen = GetPipeDimLen(pPipe);
		pPipe->SetSpare(nOriginType);
		if (dPipeLen > dTextLen)
		{
			return nType;
		}
		else
		{
			return -1;
		}
	}
	else
	{
		return -1;
	}
}

// 检查管线标注样式是否和默认样式相同 zxl 2012.12.19 add
bool CheckPipeDimTypeChanged(CDbPipe *pPipe)
{
	Adesk::UInt16 nDnType = pPipe->GetPipeDnDimType();
	Adesk::UInt16 nLenType = pPipe->GetPipeLenDimType();
	Adesk::UInt16 nLabelType = pPipe->GetPipeDimLableType();
	Adesk::UInt16 nDrawType = pPipe->GetPipeLableDrawType();
	Adesk::UInt16 nGradientType = pPipe->GetPipeGradientDimType();

	if ((nDnType == g_Option::instance().g_nDimPipeDnType 
		&& nLenType == g_Option::instance().g_iDimPipeLen
		&& nLabelType == g_Option::instance().g_nDimPipeLabelType
		&& nDrawType == g_Option::instance().g_nDimPipeDrawType
		&& nGradientType == g_Option::instance().g_nDimPipeGradientType)
		|| (nDnType == g_Option::instance().g_nDimShortPipeDnType 
			&& nLenType == g_Option::instance().g_nDimShortPipeLenType 
			&& nLabelType == g_Option::instance().g_nDimPipeLabelType 
			&& nDrawType == g_Option::instance().g_nDimPipeDrawType 
			&& nGradientType == g_Option::instance().g_nDimShortPipeGradientType))
	{
		return false;
	}
	return true;
}


// cet 2012.1.5 add 交叉显示管线
void ShowPipe(CDbPipe *pPipe)
{
	XPoint ptCen, p1, p2, p3, p4;
	ptCen = pPipe->MidPoint();
	double nDist = pPipe->Length() * 2000;
	if (GlobalFunc::DocGetMeterUnitDraw())
	{
		nDist *= 0.001;
	}
	GlobalFunc::ArxZoomTo(ptCen, nDist, nDist);
	ads_polar(GlobalFunc::Wcs2Ucs(ptCen), 0, nDist / 5, p1);
	ads_polar(p1, PI / 2, nDist / 5, p1);
	ads_polar(GlobalFunc::Wcs2Ucs(ptCen), PI, nDist / 5, p2);
	ads_polar(p2, PI / 2, -nDist / 5, p2);
	ads_grdraw(p1, p2, 2, 0);
	ads_polar(GlobalFunc::Wcs2Ucs(ptCen), PI / 2, nDist / 5, p3);
	ads_polar(p3, PI, nDist / 5, p3);
	ads_polar(GlobalFunc::Wcs2Ucs(ptCen), PI / 2, -nDist / 5, p4);
	ads_polar(p4, 0, nDist / 5, p4);
	ads_grdraw(p3, p4, 2, 0);
}

// cet 2012.1.9 add
void ShowPipe(const AcDbObjectId &idPipe)
{
	OPENOBJ_BEGIN(idPipe, AcDb::kForRead, CDbPipe, pPipe);
	if (pPipe != NULL)
	{
		ShowPipe(pPipe);
	}
	OPENOBJ_END();
}


// cet 2012.1.5 add 根据管线原有标注与初始设置获得的标注样式，用户选择标注操作
int GetSelHandle(CDbPipe *pPipe)
{
	// 显示待修改管线
	ShowPipe(pPipe);
	static CString sDefaultSel = _T("<当前管线N>:");
	static int nDefaultSel = 1;
	int nRet = -1;
	TCHAR szKey[20];
	CString sTip = _T("\n是否按初始设置进行管径样式标注[当前管线是(Y)/当前管线否(N)/全部管线是(A)/全部管线否(D)]");
	sTip += sDefaultSel;
	XPoint pt;
	while (true)
	{
		int nStatus = 0;
		INITGET_BEG(0, _T("Y N A D"));
		nStatus = acedGetPoint(0, sTip, pt);
		INITGET_END();
		if (nStatus == RTNORM)
		{
			acedPrompt(_T("\n无效操作,请重新选择!"));
			continue;
		}
		else if (nStatus == RTKWORD)
		{
			acedGetInput(szKey);
			if (szKey[0] == _T('Y') || szKey[0] == _T('y'))
			{
				nRet = 0;
				sDefaultSel = _T("<当前管线Y>:");
				nDefaultSel = 0;
			}
			else if (szKey[0] == _T('N') || szKey[0] == _T('n'))
			{
				nRet = 1;
				sDefaultSel = _T("<当前管线N>:");
				nDefaultSel = 1;
			}
			else if (szKey[0] == _T('A') || szKey[0] == _T('a'))
			{
				nRet = 2;
				sDefaultSel = _T("<全部管线A>:");
				nDefaultSel = 2;
			}
			else if (szKey[0] == _T('D') || szKey[0] == _T('d'))
			{
				nRet = 3;
				sDefaultSel = _T("<全部管线D>:");
				nDefaultSel = 3;
			}
		}
		else if (nStatus == RTCAN)
		{
			nRet = 3;
		}
		else if (nStatus == RTNONE)
		{
			nRet = nDefaultSel;
		}
		break;
	}
	return nRet;
}

// 2012.1.6 add 管线原本有标注时，处理方式
// 返回值表示是否交叉显示处理的管线，nSelType 记录上次选择的操作及返回本次操作选择
bool HandlePipeDimType(CDbPipe *pPipe, int &nSelType)
{
	bool bShow = false;
	// 更改标注样式 zxl 2012.12.19 modify
	//int nOriginType = static_cast<int>(pPipe->GetSpare()); // 原有标注样式
	//int nType = GetPipeDimType(pPipe); // 按初始设置标注管线时样式
	//if (nOriginType != nType) 
	if (CheckPipeDimTypeChanged(pPipe))
	{
		if (nSelType == 2) // 全部修改
		{
			//pPipe->SetSpare(nType);
			SetPipeLabelType(pPipe);
		}
		else if (nSelType != 3) // 用户重新选择
		{
			pPipe->downgradeOpen();
			nSelType = GetSelHandle(pPipe);
			pPipe->upgradeOpen();
			if (nSelType == 0 || nSelType == 2)
			{
				//pPipe->SetSpare(nType);
				SetPipeLabelType(pPipe);
			}

			if (nSelType == 0)
			{
				bShow = true;
			}
		}
	}
	return bShow;
}

// cet 2012.1.9 add 
// cet 2012.1.9 add 按任意键返回

void CElevationCalcDlg::OnBtnTodwg()
{
	if (m_bCalc) // 已进行埋深计算
	{
		GlobalFunc::HideDialog(this, TRUE);

		// cet 2012.7.26 add 更改管道流向
		ResetPipeDir(m_pAllList);

		// 更新图面井信息
		acedSetStatusBarProgressMeter(_T("标注中..."), 0, m_vecWellInfo.size());
		RBList rbMaskDim(RTDXF0, _T("AEC_ZT_WELLDIM"), NULL);
		std::vector<WELLNODE>::iterator it;
		int i = 0;
		std::vector<XPoint> vecPoolPts;  // cet 2012.10.25 add 池子插入点
		for (it = m_vecWellInfo.begin(); it != m_vecWellInfo.end(); it++)
		{
			acedSetStatusBarProgressMeterPos(i++);
			if (!(*it).bWell) // 化粪池
			{
				OPENOBJ_BEGIN((*it).id, AcDb::kForWrite, CDbPool, pEquip);
				if (pEquip != NULL)
				{
					pEquip->SetGroundEle((*it).dWellEleUp);
					vecPoolPts.push_back(pEquip->GetLocation());   // cet 2012.10.25 add 记录池子插入点以便更新池子连接的管底标注
				}
				OPENOBJ_END();
				continue;
			}

			AecXDbWell *pWell = NULL;
			XPoint pt;
			acdbOpenObject(pWell, (*it).id, AcDb::kForWrite);
			if (pWell != NULL)
			{
				XPoint ptLoc = pWell->GetLocation();
				pWell->SetWellEleUp((*it).dWellEleUp);
				pWell->SetDropWell((*it).bIsDropWell);
				pWell->SetWellEleDown(GetWellEleDown((*it).id));
				pt = pWell->GetLabelLocation();
				if (m_pElevationCalc != NULL)
				{
					std::vector<CALCNODE>& vecLstData = m_pElevationCalc->GetLstData();
					std::vector<CALCNODE>::iterator it2;
					for (it2 = vecLstData.begin(); it2 != vecLstData.end(); it2++)
					{
						// 设置前管道 管底标高
						if ((*it2).idE == (*it).id)
						{
							pWell->SetPipeEndEle((*it2).idP, XString(_T("%.3f"), (*it2).dPipeEleE));
						}

						// 设置后管道 管底标高
						if ((*it2).idS == (*it).id)
						{
							pWell->SetPipeEndEle((*it2).idP, XString(_T("%.3f"), (*it2).dPipeEleS));
						}
					}
				}

				// zxl 2013.06.17 add 更新管底标注时的搜索半径
				double dR = pWell->GetScale() * pWell->GetPScale() / 2;
				pWell->close();

				PickSet ss2(SS_FREE);
				XPoint ptUcs = GlobalFunc::Wcs2Ucs(ptLoc);
				GlobalFunc::GetPointPickSet(ptUcs, ss2, rbMaskDim, dR);
				GlobalFunc::UpdateGraphic(ss2);
			}
			acedRestoreStatusBar();

			ads_name name;
			acdbGetAdsName(name, (*it).id);

			// 自然地面高度
			CString strGroundEle;
			strGroundEle.Format(_T("%f"), (*it).dGroundEle);
			GlobalFunc::WriteXdata(name, _T("TG-WELL-GroundEle"), strGroundEle);

			// 井半径
			CString strWellRadius;
			//strWellRadius.Format(_T("%f"), (*it).dWellRadius); cet 2011.5.3 modify "TG-WELL-RADIUS" 为直径值
			strWellRadius.Format(_T("%f"), (*it).dWellRadius * 2);
			GlobalFunc::WriteXdata(name, _T("TG-WELL-RADIUS"), strWellRadius);

			// 沉沙量
			CString strSand;
			strSand.Format(_T("%f"), (*it).dSand * 1000);
			GlobalFunc::WriteXdata(name, _T("TG-WELL-DeepSand"), strSand);
		}

		// 更新图面管段信息
		double dMeter = 1.0, dMeter1 = 1000;
		if (!GlobalFunc::DocGetMeterUnitDraw())
		{
			dMeter = 1000;
			dMeter1 = 1.0; // cet 2011.9.1 add
		}

		std::vector<CALCNODE>& vecLstData = m_pElevationCalc->GetLstData();
		std::vector<CALCNODE>::iterator it1;
		acedSetStatusBarProgressMeter(_T("标注中..."), 0, vecLstData.size());
		i = 0;
		CDbPool *pPool = NULL; // cet 2011.11.8 add
		CPipeInterface face;   // cet 2011.11.8 add
		int nSelType = -1;     // cet 2012.1.5 add 管线标注与管线原有标注不同时，用户的选择 0: Y  1: N  2: A  3: D
		bool bShow = false;    // cet 2012.1.5 add
		for (it1 = vecLstData.begin(); it1 != vecLstData.end(); it1++)
		{
			bShow = false; // cet 2012.1.6 add
			BOOL bDrawLabel = FALSE;// zxl 2012.12.26 add
			acedSetStatusBarProgressMeterPos(i++);
			ads_name ent;
			acdbGetAdsName(ent, (*it1).idP);
			OPENOBJ_BEGIN(ent, AcDb::kForWrite, CDbPipe, pPipe);
			if (pPipe != NULL)
			{
				pPipe->SetDnDiameter((*it1).dPipeDn);
				pPipe->SetPipeGradient((*it1).dGradient);
				XPoint pt1(pPipe->GetStartPoint()), pt2(pPipe->GetEndPoint());
				XPoint ptWell = GetWellpt((*it1).idS);
				if (!ptWell) // cet 2011.10.8 add 管连化粪池
				{
					acdbOpenObject(pPool, (*it1).idS, AcDb::kForRead);
					if (pPool != NULL)
					{
						int nNum = pPool->GetInterfaceNum();
						for (int j = 0; j < nNum; j++)
						{
							pPool->GetInterface(j, face);
							if (face.m_idPipe == pPipe->objectId())
							{
								ptWell = face.m_ptLocation;
								break;
							}
						}
						pPool->close();
					}
				}

				double dLen1 = ptWell.Distance2d(pt1), dLen2 = ptWell.Distance2d(pt2);
				// cet 2011.9.1 modify
// 				if (dLen1 < 1e-3)
// 				{
// 					pt1.z = (*it1).dPipeEleS * dMeter + (*it1).dPipeDn * 0.5 / dMeter;
// 					pt2.z = (*it1).dPipeEleE * dMeter + (*it1).dPipeDn * 0.5 / dMeter;
// 				}
// 				else if (dLen2 < 1e-3)
// 				{
// 					pt2.z = (*it1).dPipeEleS * dMeter + (*it1).dPipeDn * 0.5 / dMeter;
// 					pt1.z = (*it1).dPipeEleE * dMeter + (*it1).dPipeDn * 0.5 / dMeter;
// 				}
				if (dLen1 < 1e-3)
				{
					pt1.z = (*it1).dPipeEleS * dMeter + (*it1).dPipeDn * 0.5 / dMeter1;
					pt2.z = (*it1).dPipeEleE * dMeter + (*it1).dPipeDn * 0.5 / dMeter1;
				}
				else if (dLen2 < 1e-3)
				{
					pt2.z = (*it1).dPipeEleS * dMeter + (*it1).dPipeDn * 0.5 / dMeter1;
					pt1.z = (*it1).dPipeEleE * dMeter + (*it1).dPipeDn * 0.5 / dMeter1;
				}

				XPoint ptDimTmp = pPipe->GetLabelLocation(); //先把标注点读出来，setstartpoint会修改这个点
				pPipe->SetStartPoint(pt1);
				pPipe->SetEndPoint(pt2);
				if (!pPipe->IsDrawLabel())
				{
					SetPipeLabelType(pPipe);
				}
				else  // cet 2012.1.5 add 管线存在标注时
				{
					bShow = HandlePipeDimType(pPipe, nSelType);
				}
				pPipe->SetLabelLocation(ptDimTmp);
				// cet 2012.1.9 add 标注样式为-1时不标注
				if (static_cast<int>(pPipe->GetSpare()) == -1)
				{
					pPipe->EnableDrawLabel(FALSE);
				}

				bDrawLabel = pPipe->IsDrawLabel();// zxl 2012.12.26 add
			}
			OPENOBJ_END();
			// cet 2012.1.9 add 显示交叉线
			if (bShow)
			{
				ShowPipe((*it1).idP);
				GlobalFunc::AnyKeyReturn(_T("\n按任意键继续查找下一段待修改管标注..."));
			}

			// zxl 2012.12.25 modify
			//DoDimPipeDn(ent, pListAll->m_iDn, _T("自动"), g_nPipeDnHeight, FALSE);
			GlobalFunc::DoDimPipeDn(ent, (int)(*it1).dPipeDn, _T("自动"), g_Option::instance().g_nPipeDnHeight, FALSE, TRUE);
			OPENOBJ_BEGIN(ent, AcDb::kForWrite, CDbPipe, pPipe);
			if (pPipe)
			{
				pPipe->EnableDrawLabel(bDrawLabel);
			}
			OPENOBJ_END();
		}
		WriteXDataToWell(); // cet 2012.6.21 add 
		acedRedraw(0, 0);    // cet 2012.1.6 add 刷新清除显示管线时的X
		acedRestoreStatusBar();

		// 更新化粪池连接的管底标注 cet 2012.10.25 add
		std::vector<XPoint>::iterator itPt;
		PickSet ss2(SS_FREE);
		for (itPt = vecPoolPts.begin(); itPt != vecPoolPts.end(); itPt++)
		{
			GlobalFunc::GetPointPickSet(GlobalFunc::Wcs2Ucs(*itPt), ss2, rbMaskDim, 50);
			GlobalFunc::UpdateGraphic(ss2);
			ss2.Free();
		}

		actrTransactionManager->flushGraphics();            //acad 刷新
		TCHAR szTmp[32];
		ads_getstring(NULL, _T("\n按任意键返回对话框:<返回>"), szTmp);

		GlobalFunc::HideDialog(this, FALSE);
	}
}

void CElevationCalcDlg::GetWellNodeInfo()
{
	std::stack<SSearchPipeList*> data;
	data.push(m_pAllList);
	while (!data.empty())
	{
		SSearchPipeList *pList = data.top();
		data.pop();

		if (pList->m_iType == 3 || pList->m_iType == 4)
		{
			WELLNODE node;
			node.bWell = TRUE;
			ads_name ent;
			acdbGetAdsName(ent, pList->m_ID);
			CString strGroundEle = GlobalFunc::ReadXdata(ent, _T("TG-WELL-GroundEle"));
			node.dGroundEle = _tstof(strGroundEle);
			CString strWellRadius = GlobalFunc::ReadXdata(ent, _T("TG-WELL-RADIUS"));
			node.dWellRadius = _tstof(strWellRadius) * 0.5;
			CString strSand = GlobalFunc::ReadXdata(ent, _T("TG-WELL-DeepSand"));  // 沉沙量
			node.dSand = _tstof(strSand) * 0.001;

			if (pList->m_iType == 3) // 井
			{
				AecXDbWell *pWell = NULL;
				acdbOpenObject(pWell, pList->m_ID, AcDb::kForRead);
				if (pWell != NULL)
				{
					node.dWellEleDown = pWell->GetWellEleDown();
					node.bIsDropWell = pWell->IsDropWell();
					node.strWellName = pWell->GetWellName();
					node.dWellEleUp = pWell->GetWellEleUp();
					node.id = pWell->objectId();
					pWell->close();
				}

				node.bSysSWell = FALSE;
				std::vector<SSearchPipeList*> &m_vecWell = m_pPositiveCalc->GetStartWell();
				if (std::find(m_vecWell.begin(), m_vecWell.end(), pList) != m_vecWell.end())
				{
					node.bSysSWell = TRUE;
					node.dLayingDepth = m_dWndEdtLayingDepth;
				}
			}
			else if (pList->m_iType == 4) // 化粪池
			{
				node.bWell = FALSE;
				node.bIsDropWell = FALSE;
				CDbPool *pPool = NULL;
				acdbOpenObject(pPool, pList->m_ID, AcDb::kForRead);
				if (pPool != NULL)
				{
					node.strWellName = pPool->GetLabel();
					node.dWellEleUp = pPool->GetGroundEle();
					pPool->close();
				}
				node.id = pList->m_ID;
			}

			m_vecWellInfo.push_back(node);
		}

		for (int i = 0; i < pList->m_lstNode.Length(); i++)
		{
			data.push(pList->m_lstNode[i]);
		}
	}
}

void CElevationCalcDlg::UpdateWellNode(const AcDbObjectId &id, double dGroundEle, double dEleUp, double dWellRadius, double dSand, double dEleDown, BOOL bDrop)
{
	std::vector<WELLNODE>::iterator it;
	for (it = m_vecWellInfo.begin(); it != m_vecWellInfo.end(); it++)
	{
		if ((*it).id == id)
		{
			(*it).dGroundEle = dGroundEle;
			(*it).dWellEleUp = dEleUp;
			(*it).dWellRadius = dWellRadius;
			(*it).dSand = dSand * 0.001;
			(*it).bIsDropWell = bDrop;
			if (bDrop)
			{
				(*it).dWellEleDown = dEleDown;
			}
			break;
		}
	}
}

void CElevationCalcDlg::UpdateWellNode(const CalcNode &node)
{
	std::vector<WELLNODE>::iterator it;
	for (it = m_vecWellInfo.begin(); it != m_vecWellInfo.end(); it++)
	{
		if ((*it).id == node.idS)
		{
			(*it).bIsDropWell = node.bIsDropWell;
			(*it).dWellEleDown = node.dWellEleDownS;
			break;
		}
	}
}

void CElevationCalcDlg::UpdateWellNode(const AcDbObjectId &id, double dLayingDepth)
{
	std::vector<WELLNODE>::iterator it;
	for (it = m_vecWellInfo.begin(); it != m_vecWellInfo.end(); it++)
	{
		if ((*it).id == id)
		{
			(*it).bSysSWell = TRUE;
			(*it).dLayingDepth = dLayingDepth;
			break;
		}
	}
}

void CElevationCalcDlg::OnBtnTable()
{
	UpdateData(TRUE);
	GlobalFunc::HideDialog(this, TRUE);
	XPoint pt;
	if (acedGetPoint(NULL, _T("\n点取表格左上角位置"), pt) != RTNORM)
	{
		GlobalFunc::HideDialog(this, FALSE);
		return;
	}

	double nTextSize = g_Option::instance().g_nSheetHeight; //字高
	double nTableHeight = g_Option::instance().g_nSheetHeight + 2;

	AcDbObjectId idTextStyle = GlobalFunc::InitTwtTextStyle(g_Option::instance().g_csSheetStyle);
	CDbSheet *pSheet = new CDbSheet;

	GridStyle gridStyle;
	gridStyle.SetOverrideAll(TRUE);
	gridStyle.SetTextHeight(nTextSize);
	gridStyle.SetTextStyleId(idTextStyle);

	SheetTitle &title = pSheet->GetTitle();
	title.SetHeight(7.0);
	title.SetText(GetPipeType());//设置标题文字  zxl 2011.11.29 modify

	GridStyle &gridStyle2 = title.GetGridStyle();
	gridStyle2.SetTextHeight(7.0);//设置标题文字高度  zxl 2011.11.29 modify
	gridStyle2.SetTextStyleId(idTextStyle);

	DividerStyle &style = title.GetDividerStyle();
	style.SetDividerFlag(DividerStyle::kNone);

	gridStyle.SetHorMode(AcDb::kTextCenter);
	gridStyle.SetVerMode(AcDb::kTextVertMid);
	gridStyle.SetLineSpaceFactor(0.2);
	gridStyle.SetTextWrap(FALSE);
	pSheet->SetGridStyle(gridStyle);
	pSheet->SetRowHeight(nTableHeight);
	pSheet->SetLayoutRotation(GlobalFunc::Wcs2Ucs(0.0));
	pSheet->SetLocation(GlobalFunc::Wcs2Ucs(pt));
	int nAllRow = (int)m_lstCtrl.GetRowNum();

	//pSheet->InitSheet(nAllRow + 3, 12, nTableHeight, 50); cet 2011.6.20 modify 增加备注
	//pSheet->InitSheet(nAllRow + 3, 13, nTableHeight, 50); zxl 2011.11.25 modify 增加序号
	pSheet->InitSheet(nAllRow + 3, 14, nTableHeight, 50);

	//zxl 0.11.11.25 add 设置外框线宽为中粗
	DividerStyle &styleBorder = pSheet->GetBorderStyle();
	styleBorder.SetLineWidth(0.2);
	SheetRow *pRow = pSheet->GetRow(2);
	if (pRow != NULL)
	{
		DividerStyle &styleRow = pRow->GetDividerStyle();
		styleRow.SetLineWidth(0.2);
		styleRow.SetDividerFlag(DividerStyle::kLocal);
	}

	SheetColumn column;
	// 序号 zxl 2011.11.25 add
	column.SetWidth(15);
	pSheet->SetColumnAt(0, column);
	// 管段编号
	column.SetWidth(15);   // 起点
	pSheet->SetColumnAt(1, column);
	column.SetWidth(15);   // 终点
	pSheet->SetColumnAt(2, column);
	// 管线信息
	column.SetWidth(15);   // 管长
	pSheet->SetColumnAt(3, column);
	column.SetWidth(15);   // 管径
	pSheet->SetColumnAt(4, column);
	column.SetWidth(15);   // 坡度
	pSheet->SetColumnAt(5, column);
	column.SetWidth(15);   // 管底坡降
	pSheet->SetColumnAt(6, column);
	// 设计地面标高
	column.SetWidth(15);   // 起点
	pSheet->SetColumnAt(7, column);
	column.SetWidth(15);   // 终点
	pSheet->SetColumnAt(8, column);
	// 管内底标高
	column.SetWidth(15);   // 起点
	pSheet->SetColumnAt(9, column);
	column.SetWidth(15);   // 终点
	pSheet->SetColumnAt(10, column);
	// 埋深
	column.SetWidth(15);   // 起点
	pSheet->SetColumnAt(11, column);
	column.SetWidth(15);   // 终点
	pSheet->SetColumnAt(12, column);
	// cet 2011.6.20 add
	column.SetWidth(30);
	pSheet->SetColumnAt(13, column);

	pSheet->MergeCells(0, 0, 2, 0);//zxl 2011.11.25 add
	pSheet->MergeCells(0, 1, 1, 2);
	pSheet->MergeCells(0, 3, 1, 6);
	pSheet->MergeCells(0, 7, 1, 8);
	pSheet->MergeCells(0, 9, 1, 10);
	pSheet->MergeCells(0, 11, 1, 12);
	pSheet->MergeCells(0, 13, 2, 13); // cet 2011.6.20 add

	//zxl 2011.11.25 add
	GridCell &cellNum = *(*pSheet)(0, 0);
	cellNum.SetText(_T("序号"));

	GridCell &cell0 = *(*pSheet)(0, 1);
	cell0.SetText(_T("管段编号"));
	GridCell &cell1 = *(*pSheet)(0, 3);
	cell1.SetText(_T("管线信息"));
	GridCell &cell2 = *(*pSheet)(0, 7);
	cell2.SetText(_T("设计地面标高(m)"));
	GridCell &cell3 = *(*pSheet)(0, 9);
	cell3.SetText(_T("管内底标高(m)"));
	GridCell &cell4 = *(*pSheet)(0, 11);
	cell4.SetText(_T("埋深(m)"));

	GridCell &cell01 = *(*pSheet)(2, 1);
	cell01.SetText(_T("起点"));
	GridCell &cell02 = *(*pSheet)(2, 2);
	cell02.SetText(_T("终点"));
	GridCell &cell03 = *(*pSheet)(2, 3);
	cell03.SetText(_T("管长m"));
	GridCell &cell04 = *(*pSheet)(2, 4);
	cell04.SetText(_T("管径mm"));
	GridCell &cell05 = *(*pSheet)(2, 5);
	cell05.SetText(_T("坡度‰"));
	GridCell &cell06 = *(*pSheet)(2, 6);
	cell06.SetText(_T("管底坡降"));
	GridCell &cell = *(*pSheet)(2, 7);
	cell.SetText(_T("起点"));
	GridCell &cell07 = *(*pSheet)(2, 8);
	cell07.SetText(_T("终点"));
	GridCell &cell08 = *(*pSheet)(2, 9);
	cell08.SetText(_T("起点"));
	GridCell &cell09 = *(*pSheet)(2, 10);
	cell09.SetText(_T("终点"));
	GridCell &cell10 = *(*pSheet)(2, 11);
	cell10.SetText(_T("起点"));
	GridCell &cell11 = *(*pSheet)(2, 12);
	cell11.SetText(_T("终点"));
	// cet 2011.6.20 add
	GridCell &cell12 = *(*pSheet)(0, 13);
	cell12.SetText(_T("备注"));
	std::vector<CALCNODE> data;
	m_pElevationCalc->Sort(data);

	for (int i = 0; i < nAllRow; i++)
	{
		//zxl 2011.11.25 add
		GridCell &CellNO = *(*pSheet)(i + 3, 0);
		CellNO.SetText(XString(_T("%d"), i));

		GridCell &Cell11 = *(*pSheet)(i + 3, 1);
		Cell11.SetText(m_lstCtrl.GetCell(i, 0).GetText());

		GridCell &Cell12 = *(*pSheet)(i + 3, 2);
		Cell12.SetText(m_lstCtrl.GetCell(i, 1).GetText());

		GridCell &Cell13 = *(*pSheet)(i + 3, 3);
		// zxl 2013.03.19 add 调整精度随初始设置
		CString sData = (LPCTSTR)m_lstCtrl.GetCell(i, 2).GetText();
		double dData = _tstof(sData);
		sData = GlobalFunc::GetDimPipeLen(dData);
		Cell13.SetText(sData);

		GridCell &Cell14 = *(*pSheet)(i + 3, 4);
		Cell14.SetText(m_lstCtrl.GetCell(i, 3).GetText());

		GridCell &Cell15 = *(*pSheet)(i + 3, 5);
		Cell15.SetText(m_lstCtrl.GetCell(i, 4).GetText());

		GridCell &Cell16 = *(*pSheet)(i + 3, 6);
		Cell16.SetText(m_lstCtrl.GetCell(i, 5).GetText());

		GridCell &Cell17 = *(*pSheet)(i + 3, 7);
		// zxl 2013.03.19 add 调整精度随初始设置
		sData = m_lstCtrl.GetCell(i, 6).GetText();
		dData = _tstof(sData);
		sData = GlobalFunc::GetDimWellDeep(dData);
		Cell17.SetText(sData);

		GridCell &Cell18 = *(*pSheet)(i + 3, 8);
		// zxl 2013.03.19 add 调整精度随初始设置
		sData = m_lstCtrl.GetCell(i, 7).GetText();
		dData = _tstof(sData);
		sData = GlobalFunc::GetDimWellDeep(dData);
		Cell18.SetText(sData);

		GridCell &Cell19 = *(*pSheet)(i + 3, 9);
		// zxl 2013.03.19 add 调整精度随初始设置
		sData = m_lstCtrl.GetCell(i, 8).GetText();
		dData = _tstof(sData);
		sData = GlobalFunc::GetDimWellDeep(dData);
		Cell19.SetText(sData);

		GridCell &Cell110 = *(*pSheet)(i + 3, 10);
		// zxl 2013.03.19 add 调整精度随初始设置
		sData = m_lstCtrl.GetCell(i, 9).GetText();
		dData = _tstof(sData);
		sData = GlobalFunc::GetDimWellDeep(dData);
		Cell110.SetText(sData);

		GridCell &Cell111 = *(*pSheet)(i + 3, 11);
		// zxl 2013.03.19 add 调整精度随初始设置
		sData = m_lstCtrl.GetCell(i, 10).GetText();
		dData = _tstof(sData);
		sData = GlobalFunc::GetDimWellDeep(dData);
		Cell111.SetText(sData);

		GridCell &Cell112 = *(*pSheet)(i + 3, 12);
		// zxl 2013.03.19 add 调整精度随初始设置
		sData = m_lstCtrl.GetCell(i, 11).GetText();
		dData = _tstof(sData);
		sData = GlobalFunc::GetDimWellDeep(dData);
		Cell112.SetText(sData);

		// cet 2011.6.20 add
		if (isDropWell(i, data))
		{
			GridCell &Cell113 = *(*pSheet)(i + 3, 13);
			double dDeep = data[i].dDeepE;  // 最大埋深
			std::vector<CALCNODE>::iterator it;
			for (it = data.begin(); it != data.end(); it++)
			{
				if ((*it).idS == data[i].idE && dDeep < (*it).dDeepS)
				{
					dDeep = (*it).dDeepS;
				}
			}
			double dEle = data[i].dWellEleUpE;
			double dFrontDownEle = data[i].dPipeEleE;
			CString strTemp;
			strTemp.Format(_T("跌水%.3f"), dDeep - (dEle - dFrontDownEle));

			// 跌水0.000时,不显示跌水值  zxl 2011.11.16 add
			double dDropHeight = dDeep - (dEle - dFrontDownEle);
			if (fabs(dDropHeight - 0.0) < 0.001)
			{
				strTemp = _T("");
			}

			Cell113.SetText(strTemp);
		}
	}
	GlobalFunc::AddToCurrentSpace(pSheet, TRUE);
	//pSheet->AddToCSpace(TRUE);
	TCHAR szTmp[32];
	ads_getstring(NULL, _T("\n按任意键返回对话框:<返回>"), szTmp);
	GlobalFunc::HideDialog(this, FALSE);
}

void CElevationCalcDlg::OnCheckEdownele()
{
	UpdateData(TRUE);
	CWnd *pWnd = GetDlgItem(IDC_EDIT_ENDDOWNELE);
	if (m_bWndChkReverseCalc)
	{
		pWnd->EnableWindow(TRUE);
		m_pElevationCalc = m_pReverseCalc;
	}
	else
	{
		pWnd->EnableWindow(FALSE);
		m_pElevationCalc = m_pPositiveCalc;
	}
}

void CElevationCalcDlg::OnBtnLook()
{
	UpdateData(TRUE);
	int nIndex = m_lstCtrl.GetCurRowIndex();
	if (nIndex == -1)
	{
		return;
	}
	GlobalFunc::HideDialog(this, TRUE);

	std::vector<CALCNODE> data;
	m_pElevationCalc->Sort(data);
	AcDbObjectId idPipe = data[nIndex].idP;
	ShowPipe(idPipe);

	TCHAR szTmp[32];
	ads_getstring(NULL, _T("\n按任意键返回对话框:<返回>"), szTmp);
	GlobalFunc::HideDialog(this, FALSE);
}

void CElevationCalcDlg::ShowPipe(AcDbObjectId &idPipe)
{
	CDbPipe *pPipe = NULL;
	acdbOpenObject(pPipe, idPipe, AcDb::kForRead);
	if (pPipe != NULL)
	{
		XPoint ptCen, p1, p2, p3, p4;
		ptCen = pPipe->MidPoint();
		double nDist = pPipe->Length() * 2000;
		if (GlobalFunc::DocGetMeterUnitDraw())
		{
			nDist *= 0.001;
		}
		GlobalFunc::ArxZoomTo(ptCen, nDist, nDist);
		ads_polar(GlobalFunc::Wcs2Ucs(ptCen), 0, nDist / 5, p1);
		ads_polar(p1, PI / 2, nDist / 5, p1);
		ads_polar(GlobalFunc::Wcs2Ucs(ptCen), PI, nDist / 5, p2);
		ads_polar(p2, PI / 2, -nDist / 5, p2);
		ads_grdraw(p1, p2, 2, 0);
		ads_polar(GlobalFunc::Wcs2Ucs(ptCen), PI / 2, nDist / 5, p3);
		ads_polar(p3, PI, nDist / 5, p3);
		ads_polar(GlobalFunc::Wcs2Ucs(ptCen), PI / 2, -nDist / 5, p4);
		ads_polar(p4, 0, nDist / 5, p4);
		ads_grdraw(p3, p4, 2, 0);
		pPipe->close();
	}
}

void CElevationCalcDlg::DblClickLst()
{
	OnBtnLook();
}

void CElevationCalcDlg::UpdatePipeInfo(long nRow, long nCol, double dVal)
{
	std::vector<CALCNODE> vec;
	m_pElevationCalc->Sort(vec);
	if (nRow > -1 && nRow < vec.size())
	{
		if (nCol == 3)
		{
			m_pPositiveCalc->ModifyPipe(vec[nRow].idP, dVal, TRUE);
			m_pReverseCalc->ModifyPipe(vec[nRow].idP, dVal, TRUE);
		}
		else if (nCol == 4)
		{
			m_pPositiveCalc->ModifyPipe(vec[nRow].idP, dVal, FALSE);
			m_pReverseCalc->ModifyPipe(vec[nRow].idP, dVal, FALSE);
		}
	}
}

void CElevationCalcDlg::OnChangeEditStartdeep()
{
	UpdateData(TRUE);
	if (m_pPositiveCalc != NULL)
	{
		m_pPositiveCalc->SetLayingDepth(m_dWndEdtLayingDepth);
	}

	if (m_pReverseCalc != NULL)
	{
		m_pReverseCalc->SetLayingDepth(m_dWndEdtLayingDepth);
	}

	// 	// 更新埋深 cet 2012.6.21 add
	// 	std::map<AcDbObjectId,LayingDepthNode>::iterator it;
	// 	for (it = m_mapSWellLayDepth.begin(); it != m_mapSWellLayDepth.end(); it++)
	// 	{
	// 		if (it->second.type == eLayingDepth)
	// 		{
	// 			it->second.dLayingDepth = m_dWndEdtLayingDepth; 
	// 		}
	// 	}
}

void CElevationCalcDlg::OnChangeEditMinthick()
{
	UpdateData(TRUE);
	if (m_pPositiveCalc != NULL)
	{
		m_pPositiveCalc->SetMinThick(m_dMinThick);
	}

	if (m_pReverseCalc != NULL)
	{
		m_pReverseCalc->SetMinThick(m_dMinThick);
	}
}

AcDbObjectId CElevationCalcDlg::InsertWellDim(const XPoint &ptIns, const CString &strText)
{
	AcDbObjectId id;
	AecXDbText *pText = new AecXDbText;
	AcDbObjectId idTextStyle = GlobalFunc::InitTwtTextStyle(g_Option::instance().g_csSheetStyle);
	pText->SetStyleId(idTextStyle);
	pText->SetHeight(4);
	pText->SetAlignment(AcGiDraw::kBottomLeft);
	pText->SetRotation(GlobalFunc::Wcs2Ucs(0.0));
	pText->SetText(strText);
	pText->setLayer(InitLayer(LAY_WELL_TEXT));
	pText->SetLocation(ptIns);
	pText->setColorIndex(1);
	id = GlobalFunc::AddToCurrentSpace(pText, Adesk::kTrue);
	return id;
}

void CElevationCalcDlg::UpdateWellDim(const AcDbObjectId &idDim, const CString &strText)
{
	AecXDbText *pText = NULL;
	acdbOpenObject(pText, idDim, AcDb::kForWrite);
	if (pText != NULL)
	{
		pText->SetText(strText);
		pText->close();
	}
}

XPoint CElevationCalcDlg::GetWellpt(const AcDbObjectId &id)
{
	XPoint ptLoc;
	AecXDbWell *pWell = NULL;
	acdbOpenObject(pWell, id, AcDb::kForRead);
	if (pWell != NULL)
	{
		ptLoc = pWell->GetLocation();
		pWell->close();
	}

	return ptLoc;
}

XPoint CElevationCalcDlg::GetWellLayingDepthDimPt(const AcDbObjectId &id)
{
	XPoint ptLoc;
	AecXDbWell *pWell = NULL;
	double dWellDn = 0.0;
	acdbOpenObject(pWell, id, AcDb::kForRead);
	if (pWell != NULL)
	{
		ptLoc = pWell->GetLocation();
		dWellDn = pWell->GetScale();
		pWell->close();
	}

	dWellDn *= GlobalFunc::DocGetPScale();
	ptLoc = GlobalFunc::Wcs2Ucs(ptLoc);
	ptLoc += (AcGeVector3d::kXAxis + AcGeVector3d::kYAxis) * sqrt(dWellDn * dWellDn / 2);
	ptLoc = GlobalFunc::Wcs2Ucs(ptLoc);

	return ptLoc;
}

double CElevationCalcDlg::GetWellEleDown(const AcDbObjectId &id)
{
	double dWellDownEle = 0.0;
	if (m_pElevationCalc != NULL)
	{
		std::vector<CALCNODE>& vecLstData = m_pElevationCalc->GetLstData();
		std::vector<CALCNODE>::iterator it;
		BOOL bFirst = TRUE;
		for (it = vecLstData.begin(); it != vecLstData.end(); it++)
		{
			if ((*it).idS == id)
			{
				if (bFirst)
				{
					dWellDownEle = (*it).dPipeEleS;
					bFirst = FALSE;
				}
				else if (dWellDownEle > (*it).dPipeEleS)
				{
					dWellDownEle = (*it).dPipeEleS;
				}
			}
			else if ((*it).idE == id)
			{
				if (bFirst)
				{
					dWellDownEle = (*it).dPipeEleE;
					bFirst = FALSE;
				}
				else if (dWellDownEle > (*it).dPipeEleE)
				{
					dWellDownEle = (*it).dPipeEleE;
				}
			}
		}

		double dSand = 0.0;
		std::vector<WELLNODE>::iterator it2;
		for (it2 = m_vecWellInfo.begin(); it2 != m_vecWellInfo.end(); it2++)
		{
			if ((*it2).id == id)
			{
				dSand = (*it2).dSand;
				break;
			}
		}
	}

	return dWellDownEle;
}

void CElevationCalcDlg::UpdateWellNode()
{
	std::vector<CALCNODE>& vecLstData = m_pElevationCalc->GetLstData();
	std::vector<CALCNODE>::iterator it;
	std::vector<WELLNODE>::iterator it2;

	for (it2 = m_vecWellInfo.begin(); it2 != m_vecWellInfo.end(); it2++)
	{
		for (it = vecLstData.begin(); it != vecLstData.end(); it++)
		{
			if ((*it2).id == (*it).idS)
			{
				(*it2).bIsDropWell = (*it).bIsDropWell;
				(*it2).dWellEleDown = (*it).dWellEleDownS;
				(*it2).dLayingDepth = (*it).dDeepS; // cet 2012.6.21 add 更新埋深
				break;
			}
		}
	}
}

void CElevationCalcDlg::DeleteWellDim()
{
	std::map<AcDbObjectId, AcDbObjectId>::iterator it;
	for (it = m_mapWellDim.begin(); it != m_mapWellDim.end(); it++)
	{
		AecXDbText *pText = NULL;
		acdbOpenObject(pText, (*it).second, AcDb::kForWrite);
		if (pText != NULL)
		{
			pText->erase();
			pText->close();
		}
	}
}

void CElevationCalcDlg::UpdateWellDim()
{
	std::map<AcDbObjectId, AcDbObjectId>::iterator it;
	for (it = m_mapWellDim.begin(); it != m_mapWellDim.end(); it++)
	{
		double dLayingDepth = m_pElevationCalc->GetWellLayDepth((*it).first);
		CString strLayingDepth;
		strLayingDepth.Format(_T("%.3f"), dLayingDepth);

		AecXDbText *pText = NULL;
		acdbOpenObject(pText, (*it).second, AcDb::kForWrite);
		if (pText != NULL)
		{
			pText->SetText(strLayingDepth);
			pText->close();
		}
	}
}

void CElevationCalcDlg::ShowWellDim(BOOL bShow)
{
	std::map<AcDbObjectId, AcDbObjectId>::iterator it;
	for (it = m_mapWellDim.begin(); it != m_mapWellDim.end(); it++)
	{
		AecXDbText *pText = NULL;
		acdbOpenObject(pText, (*it).second, AcDb::kForWrite);
		if (pText != NULL)
		{
			pText->setVisibility(bShow ? AcDb::kVisible : AcDb::kInvisible);
			pText->close();
		}
	}
}

void CElevationCalcDlg::OnClose()
{
	DeleteWellDim();
	CDialog::OnClose();
}

void CElevationCalcDlg::OnCancel()
{
	DeleteWellDim();
	CDialog::OnCancel();
}

void CElevationCalcDlg::OnChangeEditEnddownele()
{
	UpdateData(TRUE);
	if (m_pPositiveCalc != NULL)
	{
		m_pPositiveCalc->SetPipeEleDown(_tstof(m_strPipeEleDown));
	}

	if (m_pReverseCalc != NULL)
	{
		m_pReverseCalc->SetPipeEleDown(_tstof(m_strPipeEleDown));
	}
}

bool CElevationCalcDlg::isDropWell(int nIndex, const std::vector<CALCNODE> data)
{
	if (nIndex < 0 || nIndex >= data.size())
	{
		return false;
	}

	bool bRet = false;
	AcDbObjectId idWell = data[nIndex].idE;
	std::vector<CALCNODE>::const_iterator it;
	for (it = data.begin(); it != data.end(); it++)
	{
		if ((*it).idS == idWell && (*it).bIsDropWell)
		{
			bRet = true;
			break;
		}
	}
	return bRet;
}

void CElevationCalcDlg::GetDropWell(std::vector<CString> &vecWellName)
{
	std::vector<WELLNODE>::iterator it;
	for (it = m_vecWellInfo.begin(); it != m_vecWellInfo.end(); it++)
	{
		if (it->bIsDropWell)
		{
			vecWellName.push_back(it->strWellName);
		}
	}
}

void CElevationCalcDlg::SetDropWellColor()
{
	//  cet 2011.11.28 modify 根据跌水井的情况进行颜色和提示更改
	// 	std::vector<CString> vecData, data;
	// 	GetDropWell(vecData);
	// 	std::vector<CString>::iterator it, it1;
	// 	for (it = vecData.begin(); it != vecData.end(); it++)
	// 	{
	// 		it1 = std::find(m_vecWellName.begin(), m_vecWellName.end(), *it);
	// 		if (it1 == m_vecWellName.end()) // 新产生的跌水井
	// 		{
	// 			data.push_back(*it);
	// 		}
	// 	}
	// 
	// 	m_lstCtrl.SetDropWell(data);
	std::vector<CString> vecData;
	GetDropWell(vecData);
	std::map<CString, CString> mapWellTip;
	std::map<CString, int> mapWellColor;
	std::vector<CString>::iterator it, it1;
	std::vector<WELLNODE>::iterator it2;
	AcDbObjectId idWell;
	CString sDrop;
	for (it = vecData.begin(); it != vecData.end(); it++)
	{
		it1 = std::find(m_vecWellName.begin(), m_vecWellName.end(), *it);
		if (it1 == m_vecWellName.end()) // 计算中产生的跌水井
		{

			for (it2 = m_vecWellInfo.begin(); it2 != m_vecWellInfo.end(); it2++)
			{
				if (it2->strWellName == *it)
				{
					idWell = it2->id;
					break;
				}
			}

			if (it2 != m_vecWellInfo.end())
			{
				// 跌水井跌落高度
				if (!GetWellDropHeight(idWell, sDrop))
				{
					continue;
				}

				double dDrop = _tstof(sDrop);
				if (dDrop < 1.0) // 跌水井跌落高度小于1米
				{
					mapWellColor.insert(std::make_pair(*it, 2));
					mapWellTip.insert(std::make_pair(*it, CString(_T("计算中产生的跌水井，跌落高度小于1米"))));
				}
				else
				{
					mapWellColor.insert(std::make_pair(*it, 3));
					mapWellTip.insert(std::make_pair(*it, CString(_T("计算中产生的跌水井，跌落高度大于或等于1米"))));
				}
			}
		}
		else // 用户设置的跌水井
		{
			mapWellColor.insert(std::make_pair(*it, 4));
			mapWellTip.insert(std::make_pair(*it, CString(_T("用户设定的跌水井"))));
		}
	}

	m_lstCtrl.setWellColor(mapWellColor);
	m_lstCtrl.setWellTip(mapWellTip);

}

void CElevationCalcDlg::InitSWellLayDepth()
{
	std::stack<SSearchPipeList *> dataSt;
	dataSt.push(m_pAllList);
	ads_name name;
	CString sLayDepth;
	int nSWell = 0;
	while (!dataSt.empty())
	{
		SSearchPipeList *pTemp = dataSt.top();
		dataSt.pop();
		if (pTemp->m_iType == 3 && pTemp->m_lstNode.Length() == 0) //起点井
		{
			++nSWell;
			acdbGetAdsName(name, pTemp->m_ID);
			Entity ent(name);
			sLayDepth = GlobalFunc::ReadXdata(ent, _T("LAYDEPTH"));
			if (!sLayDepth.IsEmpty())
			{
				LayingDepthNode node;
				GetLayDepthData(sLayDepth, node.type, node.dLayingDepth);
				double dWellDownEle = GetWellEleDown2(pTemp->m_ID);
				if (fabs(dWellDownEle) > 0.001) // 检查埋深是否与扩展数据中的一样
				{
					double dLayDepth = GetWellEleUp(pTemp->m_ID) - dWellDownEle;
					if (fabs(dLayDepth - node.dLayingDepth) > 0.001) // 不一致，说明用户更改了埋深
					{
						node.type = eUserSet;
						node.dLayingDepth = dLayDepth;
					}
				}
				m_mapSWellLayDepth.insert(std::make_pair(pTemp->m_ID, node));
			}
			else
			{
				double dWellDownEle = GetWellEleDown2(pTemp->m_ID);
				if (fabs(dWellDownEle) > 0.001) // 用户设置了埋设深度
				{
					LayingDepthNode node;
					node.type = eUserSet;
					node.dLayingDepth = GetWellEleUp(pTemp->m_ID) - dWellDownEle;
					m_mapSWellLayDepth.insert(std::make_pair(pTemp->m_ID, node));
				}
				else // 未设置埋设深度
				{
					LayingDepthNode node;
					node.type = eLayingDepth;
					node.dLayingDepth = m_dWndEdtLayingDepth;
					m_mapSWellLayDepth.insert(std::make_pair(pTemp->m_ID, node));
					m_bFirstRunCmd = true;
				}
			}
			continue;
		}

		for (int i = 0; i < pTemp->m_lstNode.Length(); i++)
		{
			dataSt.push(pTemp->m_lstNode[i]);
		}
	}

	// 只有一个起点井
	if (nSWell == 1)
	{
		m_bOnlySWell = true;
	}
}

double CElevationCalcDlg::GetWellEleUp(const AcDbObjectId &id)
{
	double dRet = 0.0;
	AecXDbWell *pWell = NULL;
	acdbOpenObject(pWell, id, AcDb::kForRead);
	if (pWell != NULL)
	{
		dRet = pWell->GetWellEleUp();
		pWell->close();
	}

	return dRet;
}

void CElevationCalcDlg::GetLayDepthData(const CString &sLayDepth, LayingDepthType &type, double &dLayDepth)
{
	CString sType, sEle;
	int nIndex = sLayDepth.Find(_T("@"), 0);
	if (nIndex != -1)
	{
		sType = sLayDepth.Left(nIndex);
		sEle = sLayDepth.Right(sLayDepth.GetLength() - nIndex - 1);
		dLayDepth = _tstof(sEle);
		int nType = _ttoi(sType);
		switch (nType)
		{
		case 0:
		{
			type = eUserSet;
			break;
		}
		case 1:
		{
			type = eLayingDepth;
			break;
		}
		case 2:
		{
			type = eCalc;
			break;
		}
		case 3:
		{
			type = eUserModify;
			break;
		}
		}
	}
}

void CElevationCalcDlg::UpdatelayDepthData(const AcDbObjectId &idWell, double dLayDepth)
{
	std::map<AcDbObjectId, LayingDepthNode>::iterator it;
	it = m_mapSWellLayDepth.find(idWell);
	if (it != m_mapSWellLayDepth.end() && fabs(it->second.dLayingDepth - dLayDepth) > 0.001)
	{
		it->second.type = eUserModify;
		it->second.dLayingDepth = dLayDepth;
	}
}

void CElevationCalcDlg::UpdatelayDepthData()
{
	std::vector<WELLNODE>::iterator it;
	std::map<AcDbObjectId, LayingDepthNode>::iterator itM;
	for (it = m_vecWellInfo.begin(); it != m_vecWellInfo.end(); it++)
	{
		if (it->bSysSWell) // 系统起点井
		{
			itM = m_mapSWellLayDepth.find(it->id);
			if (itM != m_mapSWellLayDepth.end() && fabs(itM->second.dLayingDepth - it->dLayingDepth) > 0.001)
			{
				itM->second.type = eCalc;
				itM->second.dLayingDepth = it->dLayingDepth;
			}
		}
	}
}

void CElevationCalcDlg::WriteXDataToWell()
{
	std::map<AcDbObjectId, LayingDepthNode>::iterator it;
	ads_name name;
	CString sData;
	for (it = m_mapSWellLayDepth.begin(); it != m_mapSWellLayDepth.end(); it++)
	{
		acdbGetAdsName(name, it->first);
		Entity ent(name);
		sData.Format(_T("%d@%f"), it->second.type, it->second.dLayingDepth);
		GlobalFunc::WriteXdata(ent, _T("LAYDEPTH"), sData);
	}
}

double CElevationCalcDlg::GetWellEleDown2(const AcDbObjectId &id)
{
	double dRet = 0.0;
	AecXDbWell *pWell = NULL;
	acdbOpenObject(pWell, id, AcDb::kForRead);
	if (pWell != NULL)
	{
		dRet = pWell->GetWellEleDown();
		pWell->close();
	}
	return dRet;
}

void CElevationCalcDlg::SetCalced(BOOL bCalced)
{
	m_bCalc = bCalced;
}

void CElevationCalcDlg::UpdateCalcedData()
{
	std::vector<CalcNode> &vecNode = m_pPositiveCalc->GetLstData();
	std::vector<CalcNode>::iterator it;
	CDbPipe *pPipe = NULL;
	AecXDbWell *pWellS = NULL, *pWellE = NULL;
	double dElevUp = 0.0, dElevDown = 0.0;
	double dUnit = 0.001;
	if (GlobalFunc::DocGetMeterUnitDraw())
	{
		dUnit = 1.0;
	}
	for (it = vecNode.begin(); it != vecNode.end(); it++)
	{
		acdbOpenObject(pPipe, (*it).idP, AcDb::kForRead);
		if (pPipe != NULL)
		{
			double dDn = pPipe->GetDnDiameter();

			// 内径改为工程直径，和图面赋值保持一致 zxl 2013.10.12 modify
			//int iMaterial = pPipe->GetMaterial();
			//CString csMat = GlobalFunc::GetPipeMaterialByIdx(iMaterial);
			//dDn  = GetPipeDjByDn(csMat, (int)dDn) / 2;  //内径
			dDn = dDn * 0.001 / 2;

			TPipeSys::FlowDirection dir = pPipe->GetFlowDir();
			if (dir == TPipeSys::kFromStart)
			{
				(*it).dPipeEleS = pPipe->StartPoint().z * dUnit - dDn;
				(*it).dPipeEleE = pPipe->EndPoint().z * dUnit - dDn;
			}
			else
			{
				(*it).dPipeEleE = pPipe->StartPoint().z * dUnit - dDn;
				(*it).dPipeEleS = pPipe->EndPoint().z * dUnit - dDn;
			}
			pPipe->close();
		}
		acdbOpenObject(pWellS, (*it).idS, AcDb::kForRead);
		if (pWellS != NULL)
		{
			dElevUp = pWellS->GetWellEleUp();
			dElevDown = pWellS->GetWellEleDown();
			(*it).dDeepS = dElevUp - dElevDown;
			pWellS->close();
		}

		acdbOpenObject(pWellE, (*it).idE, AcDb::kForRead);
		if (pWellE != NULL)
		{
			dElevUp = pWellE->GetWellEleUp();
			dElevDown = pWellE->GetWellEleDown();
			if (pWellE->IsDropWell())
			{
				double dEle = (*it).dWellEleUpE;
				double dFrontDownEle = (*it).dPipeEleE;
				(*it).dDeepE += (dEle - dFrontDownEle);
			}
			else
			{
				(*it).dDeepE = dElevUp - dElevDown;
			}
			pWellE->close();
		}
	}
}