#include "stdafx.h"
#include "dbobjptr.h"
#include "AcDbObjectPtr.h"
#include "DbVerticalSection.h"
#include "DbWell.h"
#include "DbPipe.h"
#include <DbElipse.h>
#include "AecDbSymbWithText.h"
#include "dbgridsheet.h"
#include "AecDbSymbArrow.h"
#include "AecDbSymbElevation.h"
#include <set>
#include "SHAcDbBlockTableRecPtr.h"
#include "DbPool.h"

AcDbObjectId InitTextStyle(const TCHAR *pszStyle, AcDbDatabase *pDb = NULL);
AcDbObjectId InitTextStyle(TTextStyle ts, AcDbDatabase *pDb = NULL);

namespace
{
	int GetPipeLenPrecision()
	{
		return 3;
	}

	int GetWellDeepPrecision()
	{
		return 3;
	}
}

CString I2Str(double i)
{
	CString csText;
	i = i / 1000;
	int iTmp = int(i * 1000) * 10;
	int iTmp2 = int(i * 10000);
	if (iTmp == iTmp2) {
		iTmp = int(i * 100) * 10;
		iTmp2 = int(i * 1000);
		if (iTmp == iTmp2)
			csText.Format(_T("%.2f"), i);
		else
			csText.Format(_T("%.3f"), i);
	}
	else
		csText.Format(_T("%.4f"), i);
	return csText;
}
extern void FullExplode(const AcDbEntity *pEnt, AcDbVoidPtrArray &entitySet);
namespace
{
	//得到2管线的交点和各自起点到交点的距离
	bool GetCrossPipeInfo(CDbPipe *pPipe1, CDbPipe *pPipe2, XPoint &ptInt, double &nDist2Well1, double &nDist2Well2, bool bShowPipeEndNotLinkedPipe = false)
	{
		XPoint ptWell1, ptWell2;
		XLine line1, line2;
		// 纵断面图干管
		{
			XLine line(pPipe1->GetStartPoint(), pPipe1->GetEndPoint(), 1);
			line.StartPoint().z = 0;
			line.EndPoint().z = 0;
			if (pPipe1->GetFlowDir() == TPipeSys::kFromStart)
				ptWell1 = pPipe1->StartPoint();
			else
				ptWell1 = pPipe1->EndPoint();
			line1 = line;
		}
		// 交叉管
		{
			XLine line(pPipe2->GetStartPoint(), pPipe2->GetEndPoint(), 1);
			line.StartPoint().z = 0;
			line.EndPoint().z = 0;
			if (pPipe2->GetFlowDir() == TPipeSys::kFromStart)
				ptWell2 = pPipe2->StartPoint();
			else
				ptWell2 = pPipe2->EndPoint();
			line2 = line;
		}
		line1.StartPoint().z = 0;
		line1.EndPoint().z = 0;
		line2.StartPoint().z = 0;
		line2.EndPoint().z = 0;
		//  cet 2016.4.29 modify 管道距离原点较远时，无法计算交点
		//  int ret = line1.Intersection(&line2, ptInt);
		//  if(!ptInt)
		//		return;
		AcGeVector3d vt1 = line1.StartPoint() - line1.EndPoint();
		AcGeVector3d vt2 = line2.StartPoint() - line2.EndPoint();
		double dAngle = vt1.angleTo(vt2);
		if (fabs(dAngle) < 0.001 || fabs(dAngle - PI) < 0.001) // 管道平行
		{
			return false;
		}
		XCurveSegment seg;
		seg = line1;
		seg.SetLineFlag(LS_INFINITE);
		if (seg.ProjectToMe(line2.StartPoint(), ptInt) != RTNORM) // 获得投影点
			return false;
		bool bEndWell = false; // 是否为起始井
		ptInt = line2.StartPoint() - vt2.normalize() * ptInt.Distance(line2.StartPoint()) / sin(dAngle); // 真正交点
		if (fabs(ptInt.Distance(line1.StartPoint()) + ptInt.Distance(line1.EndPoint()) - line1.GetLength()) > 0.001 ||
			fabs(ptInt.Distance(line2.StartPoint()) + ptInt.Distance(line2.EndPoint()) - line2.GetLength()) > 0.001)
		{
			// cet 2017.8.24 modify 起始井处穿井并且没有与管道相交的管道交点
			bool bPassWell = false;
			{
				// 是否穿过井或池
				AcDbObjectId id = pPipe1->GetNode(ptInt.Distance2d(pPipe1->StartPoint()) > ptInt.Distance2d(pPipe1->EndPoint()) ? 1 : 0);
				OPENOBJ_BEGIN(id, AcDb::kForRead, CDbEquipment, pEquip);
				if (pEquip != NULL)
				{
					// 管网中的井或池
					if (pEquip->GetInterfaceNum() > 1)
					{
						return false;
					}
					bEndWell = true;
					AcDbLine line(line2.StartPoint(), line2.EndPoint());
					AcDbVoidPtrArray entitySet;
					FullExplode(pEquip, entitySet);
					AcGePoint3dArray arr;
					int nCount = entitySet.length();
					for (int i = 0; i < nCount; ++i)
					{
						AcDbCurve *pCurve = (AcDbCurve*)entitySet[i];
						if (pCurve != NULL)
						{
							line.intersectWith(pCurve, AcDb::kOnBothOperands, AcGePlane::kXYPlane, arr);
							if (arr.length() > 0)
							{
								bPassWell = true;
								break;
							}
						}
					}
					GlobalFunc::ReleaseEntSet(entitySet);
				}
				OPENOBJ_END();
			}
			if (!bPassWell)
			{
				return false;
			}
		}
		if (ptInt == line1.StartPoint() || ptInt == line1.EndPoint() || ptInt == line2.StartPoint() || ptInt == line2.EndPoint())
		{//如果交点在线端，就不考虑了，因为之前已经考虑了
			// cet 2017.8.23 modify 考虑是否显示与管端有交点但没有连接关系的管道
			if (bShowPipeEndNotLinkedPipe)
			{
				// 管道有交点，但在端点没有与井连接时显示交点
				{
					int nPos = ptInt.Distance2d(pPipe1->StartPoint()) < 0.001 ? 0 : 1;
					OPENOBJ_BEGIN(pPipe1->GetNode(nPos), AcDb::kForRead, CDbEquipment, pEquip);
					if (pEquip != NULL)
					{
						int nNum = pEquip->GetInterfaceNum();
						for (int i = 0; i < nNum; ++i)
						{
							const CPipeInterface &face = pEquip->GetInterface(i);
							if (face.m_idPipe == pPipe2->objectId())
							{
								return false;
							}
						}
					}
					OPENOBJ_END();
				}
			}
			else
			{
				ptInt = XPoint();
				return false;
			}
		}
		ptWell1.z = 0;
		ptWell2.z = 0;

		nDist2Well1 = ads_distance(ptInt, ptWell1);   //相交管线起点到交点的距离
		nDist2Well2 = ads_distance(ptInt, ptWell2);   //本管线起点到交点的距离
		if (!GlobalFunc::DocGetMeterUnitDraw()) {
			nDist2Well1 = nDist2Well1 / 1000.0;
			nDist2Well2 = nDist2Well2 / 1000.0;
		}
		// cet 2017.8.24 add 起始井被管道穿过，没有与干管井交叉 
		if (bEndWell && ptWell1.Distance2d(ptInt) < ptWell2.Distance2d(ptInt))
		{
			nDist2Well1 *= -1;
		}
		return true;
	}
	// 交叉管是否已统计
	bool IsExistCrossNode(const std::vector<CrossPoint> &vecCross, const AcDbObjectId &id, const XPoint &pt)
	{
		std::vector<CrossPoint>::const_iterator it, itEnd = vecCross.end();
		for (it = vecCross.begin(); it != itEnd; ++it)
		{
			if (it->IsExistCrossNode(id, pt))
			{
				return true;
			}
		}
		return false;
	}
}

CrossPoint::CrossPoint(const AcDbObjectId &id)
{
	m_id = id;
}

CrossPoint::CrossPoint()
{
	m_id = AcDbObjectId::kNull;
}

AcDbObjectId CrossPoint::PipeId() const
{
	return m_id;
}

bool CrossPoint::IsCross() const
{
	return !m_vecNode.empty();
}

void CrossPoint::AddCrossPoint(const AcDbObjectId &id, const XPoint &ptInt, double dDist2Well1, double dDist2Well2)
{
	CrossNode node;
	node.m_id = id;
	node.m_pt = ptInt;
	node.m_dDist2Well1 = dDist2Well1;
	node.m_dDist2Well2 = dDist2Well2;
	m_vecNode.push_back(node);
}

void CrossPoint::GetAllCrossPipes(DList<AcDbObjectId> &lstPipe) const
{
	std::vector<CrossNode>::const_iterator it, itEnd = m_vecNode.end();
	for (it = m_vecNode.begin(); it != itEnd; ++it)
	{
		lstPipe.Append(new AcDbObjectId(it->m_id));
	}
}

bool CrossPoint::GetCrossInfo(const AcDbObjectId &id, XPoint &ptIns, double &dDist2Well1, double &dDist2Well2) const
{
	std::vector<CrossNode>::const_iterator it, itEnd = m_vecNode.end();
	for (it = m_vecNode.begin(); it != itEnd; ++it)
	{
		if (it->m_id == id)
		{
			ptIns = it->m_pt;
			dDist2Well1 = it->m_dDist2Well1;
			dDist2Well2 = it->m_dDist2Well2;
			return true;
		}
	}
	return false;
}

void CrossPoint::Sort()
{
	std::sort(m_vecNode.begin(), m_vecNode.end());
}

bool CrossPoint::IsExistCrossNode(const AcDbObjectId &id, const XPoint &pt) const
{
	std::vector<CrossNode>::const_iterator it, itEnd = m_vecNode.end();
	for (it = m_vecNode.begin(); it != itEnd; ++it)
	{
		if (it->m_id == id && pt.Distance(it->m_pt) < 0.001)
		{
			return true;
		}
	}
	return false;
}

void CrossPoint::ReadCrossPoint(const EntityFields &fd, const CString &sKey)
{
	// 主管id
	AcDbSoftPointerId idTemp;
	fd.GFD(sKey + _T("_MainPipe"), idTemp);
	m_id = idTemp;
	// 交叉管数据
	Adesk::UInt16 nNum = 0;
	fd.GFD(sKey + _T("_Num"), nNum);
	CString sTemp = sKey + _T("_CrossNode"), sIndex;
	AcGePoint3d pt;
	for (Adesk::UInt16 i = 0; i < nNum; ++i)
	{
		sIndex.Format(_T("_%d"), i);
		sTemp += sIndex;
		CrossNode node;
		// 交叉管
		fd.GFD(sTemp + _T("_CrossPipe"), idTemp);
		node.m_id = idTemp;
		// 交点
		fd.GFD(sTemp + _T("_Point"), pt);
		node.m_pt = pt;
		// 到起点井距离
		double dDistS = 0.0;
		fd.GFD(sTemp + _T("_SDist"), dDistS);
		node.m_dDist2Well1 = dDistS;
		// 到终点井距离
		double dDistE = 0.0;
		fd.GFD(sTemp + _T("_EDist"), dDistE);
		node.m_dDist2Well2 = dDistE;
		// 存储数据
		m_vecNode.push_back(node);
	}
}

void CrossPoint::WriteCrossPoint(EntityFields &fd, const CString &sKey)
{
	// 主管id
	fd.SFD(sKey + _T("_MainPipe"), AcDbSoftPointerId(m_id));
	// 交叉管数据
	fd.SFD(sKey + _T("_Num"), Adesk::UInt16(m_vecNode.size()));
	CString sTemp = sKey + _T("_CrossNode"), sIndex;
	std::vector<CrossNode>::iterator it, itEnd = m_vecNode.end();
	int nIndex = 0;
	for (it = m_vecNode.begin(); it != itEnd; ++it)
	{
		CrossNode &node = *it;
		sIndex.Format(_T("_%d"), nIndex);
		sTemp += sIndex;
		++nIndex;
		// 交叉管
		fd.SFD(sTemp + _T("_CrossPipe"), AcDbSoftPointerId(node.m_id));
		// 交点
		fd.SFD(sTemp + _T("_Point"), node.m_pt.AsAcGePoint3d());
		// 到起点井距离
		fd.SFD(sTemp + _T("_SDist"), node.m_dDist2Well1);
		// 到终点井距离
		fd.SFD(sTemp + _T("_EDist"), node.m_dDist2Well2);
	}
}

void CrossPoint::DelCrossPoint(EntityFields &fd, const CString &sKey)
{
	// 主管id
	DelTEntityField(fd, sKey + _T("_MainPipe"));
	// 交叉管数据
	Adesk::UInt16 nNum = 0;
	fd.GFD(sKey + _T("_Num"), nNum);
	DelTEntityField(fd, sKey + _T("_Num"));
	CString sTemp = sKey + _T("_CrossNode"), sIndex;
	for (Adesk::UInt16 i = 0; i < nNum; ++i)
	{
		sIndex.Format(_T("_%d"), i);
		sTemp += sIndex;
		// 交叉管
		DelTEntityField(fd, sTemp + _T("_CrossPipe"));
		// 交点
		DelTEntityField(fd, sTemp + _T("_Point"));
		// 到起点井距离
		DelTEntityField(fd, sTemp + _T("_SDist"));
		// 到终点井距离
		DelTEntityField(fd, sTemp + _T("_EDist"));
	}
}

bool CrossPoint::DelTEntityField(EntityFields &fd, const CString &sKey)
{
	bool bRet = true;
	long nIndex = fd.Find(sKey);
	if (nIndex != -1)
	{
		fd.Del(nIndex);
		bRet = false;
	}
	return bRet;
}

// 计算管道交叉点
void CalcCrossPipes(DList<AcDbObjectId> &lstPipe, DList<AcDbObjectId> &lstOtherPipe, std::vector<CrossPoint> &vecCross, bool bShowPipeEndNotLinkedPipe)
{
	// 打开管道
	std::vector<CDbPipe*> vecOtherPipe;
	for (int i = 0; i < lstOtherPipe.Length(); ++i)
	{
		CDbPipe *pPipe = NULL;
		acdbOpenObject(pPipe, *lstOtherPipe[i], AcDb::kForRead);
		if (pPipe != NULL)
		{
			vecOtherPipe.push_back(pPipe);
		}
	}
	// 计算管道与其他管交点
	XPoint ptInt;
	double dDist2Well1 = 0.0, dDist2Well2 = 0.0;
	for (int i = 0; i < lstPipe.Length(); ++i)
	{
		OPENOBJ_BEGIN(*lstPipe[i], AcDb::kForRead, CDbPipe, pPipe);
		if (pPipe != NULL)
		{
			CrossPoint cr(pPipe->objectId());
			for (int j = 0; j < vecOtherPipe.size(); ++j)
			{
				// 有管道交叉点且唯一
				if (GetCrossPipeInfo(pPipe, vecOtherPipe[j], ptInt, dDist2Well1, dDist2Well2, bShowPipeEndNotLinkedPipe) && !IsExistCrossNode(vecCross, vecOtherPipe[j]->objectId(), ptInt))
				{
					cr.AddCrossPoint(vecOtherPipe[j]->objectId(), ptInt, dDist2Well1, dDist2Well2);
				}
			}
			// 有交叉点
			if (cr.IsCross())
			{
				cr.Sort();
				vecCross.push_back(cr);
			}
		}
		OPENOBJ_END();
	}
	// 关闭管道
	std::vector<CDbPipe*>::iterator it, itEnd = vecOtherPipe.end();
	for (it = vecOtherPipe.begin(); it != itEnd; ++it)
	{
		(*it)->close();
	}
}
// 干管交叉信息
bool GetCrossInfo(const std::vector<CrossPoint> &vecCross, CrossPoint &cr)
{
	std::vector<CrossPoint>::const_iterator it, itEnd = vecCross.end();
	for (it = vecCross.begin(); it != itEnd; ++it)
	{
		if (it->PipeId() == cr.PipeId())
		{
			cr = *it;
			return true;
		}
	}
	return false;
}

Acad::ErrorStatus TWellData::dwgInFields(AcDbDwgFiler* pFiler, int iVer)
{

	XString xsName;
	GlobalFunc::ReadString(pFiler, xsName);
	m_csName = (const TCHAR*)xsName;
	pFiler->readItem(&m_iDn);
	pFiler->readItem(&m_nLength);
	//  cet 2017.6.1 del 应该在应用层处理数值转换问题
	// 	if(m_nLength > 1000)
	// 		m_nLength = m_nLength / 1000.0; //7.0用MM
	pFiler->readItem(&m_nGroundEle);
	pFiler->readItem(&m_nUpEle);
	pFiler->readItem(&m_nDownEle);
	pFiler->readItem(&m_nFrondDownEle);
	pFiler->readItem(&m_nDeep);
	pFiler->readItem(&m_nI);
	pFiler->readItem(&m_nWellRadius);
	//  cet 2017.6.1 del 应该在应用层处理数值转换问题
	// 	if(fabs(m_nWellRadius) < 100)
	// 		m_nWellRadius = m_nWellRadius*100.0;//7.0
	pFiler->readItem(&m_nSpare);
	//pFiler->readItem(&m_bIsWell);
	//pFiler->readItem(&m_bIsDropWell);
	GlobalFunc::FilerRead(pFiler, m_bIsWell);
	GlobalFunc::FilerRead(pFiler, m_bIsDropWell);
	pFiler->readItem(&m_ID);

	if (iVer > 1)
	{
		pFiler->readItem(&m_dRealLength);
		// cet 2016.5.11 modify 更改了成员变量类型
		// pFiler->readItem(&m_iSpare);
		if (iVer < 3)
		{
			Adesk::UInt16 nVal = 0;
			pFiler->readItem(&nVal);
			m_iSpare = nVal;
		}
		else
		{
			pFiler->readItem(&m_iSpare);
		}
		GlobalFunc::ReadString(pFiler, xsName);
		m_csSpare = (const TCHAR*)xsName;
	}

	return pFiler->filerStatus();
}

Acad::ErrorStatus TWellData::dwgOutFields(AcDbDwgFiler* pFiler, int iVer) const
{
	pFiler->writeItem((const TCHAR *)m_csName);
	pFiler->writeItem(m_iDn);
	pFiler->writeItem(m_nLength);
	pFiler->writeItem(m_nGroundEle);
	pFiler->writeItem(m_nUpEle);
	pFiler->writeItem(m_nDownEle);
	pFiler->writeItem(m_nFrondDownEle);
	pFiler->writeItem(m_nDeep);
	pFiler->writeItem(m_nI);
	pFiler->writeItem(m_nWellRadius);
	pFiler->writeItem(m_nSpare);
	//pFiler->writeItem(m_bIsWell);
	//pFiler->writeItem(m_bIsDropWell);
	GlobalFunc::FilerWrite(pFiler, m_bIsWell);
	GlobalFunc::FilerWrite(pFiler, m_bIsDropWell);
	pFiler->writeItem(m_ID);

	if (iVer > 1)
	{
		pFiler->writeItem(m_dRealLength);
		// cet 2016.5.11 modify 更改了成员变量类型
		//	pFiler->writeItem(m_iSpare);
		if (iVer < 3)
		{
			Adesk::UInt16 nVal = static_cast<Adesk::UInt16>(m_iSpare);
			pFiler->writeItem(nVal);
		}
		else
		{
			pFiler->writeItem(m_iSpare);
		}
		pFiler->writeItem((const TCHAR *)m_csSpare);
	}

	return pFiler->filerStatus();
}



TWellData & TWellData::operator = (const TWellData &src)
{
	m_csName = src.m_csName;
	m_iDn = src.m_iDn;
	m_nLength = src.m_nLength;
	m_nGroundEle = src.m_nGroundEle;
	m_nUpEle = src.m_nUpEle;
	m_nDownEle = src.m_nDownEle;
	m_nFrondDownEle = src.m_nFrondDownEle;
	m_nDeep = src.m_nDeep;
	m_nI = src.m_nI;
	m_nWellRadius = src.m_nWellRadius;
	m_nSpare = src.m_nSpare;
	m_bIsWell = src.m_bIsWell;
	m_bIsDropWell = src.m_bIsDropWell;
	m_ID = src.m_ID;
	m_dRealLength = src.m_dRealLength;
	m_iSpare = src.m_iSpare;
	m_csSpare = src.m_csSpare;

	//  GlobalFunc::CopyObject(src, *this);
	return *this;
}

TWellData::TWellData(const TWellData &src)
{
	*this = src;
}


Acad::ErrorStatus TFeedWellData::dwgInFields(AcDbDwgFiler* pFiler)
{
	XString xsName;
	GlobalFunc::ReadString(pFiler, xsName);
	m_csName = (const TCHAR*)xsName;
	pFiler->readItem(&m_iDn);
	pFiler->readItem(&m_nLength);
	pFiler->readItem(&m_nGroundEle);
	pFiler->readItem(&m_nUpEle);
	pFiler->readItem(&m_nDownEle);
	pFiler->readItem(&m_nFrondDownEle);
	pFiler->readItem(&m_nDeep);
	pFiler->readItem(&m_nI);
	pFiler->readItem(&m_nWellRadius);
	pFiler->readItem(&m_nSpare);
	//pFiler->readItem(&m_bIsWell);
	//pFiler->readItem(&m_bIsDropWell);
	GlobalFunc::FilerRead(pFiler, m_bIsWell);
	GlobalFunc::FilerRead(pFiler, m_bIsDropWell);
	pFiler->readItem(&m_ID);

	Adesk::UInt16 nNum = 0;
	pFiler->readItem(&nNum);
	m_lstID.Reset();
	for (Adesk::UInt16 i = 0; i < nNum; i++) {
		AcDbSoftPointerId id;
		pFiler->readItem(&id);
		m_lstID.Append(new AcDbSoftPointerId(id));
	}
	return pFiler->filerStatus();
}

Acad::ErrorStatus TFeedWellData::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	pFiler->writeItem((const TCHAR *)m_csName);
	pFiler->writeItem(m_iDn);
	pFiler->writeItem(m_nLength);
	pFiler->writeItem(m_nGroundEle);
	pFiler->writeItem(m_nUpEle);
	pFiler->writeItem(m_nDownEle);
	pFiler->writeItem(m_nFrondDownEle);
	pFiler->writeItem(m_nDeep);
	pFiler->writeItem(m_nI);
	pFiler->writeItem(m_nWellRadius);
	pFiler->writeItem(m_nSpare);
	//pFiler->writeItem(m_bIsWell);
	//pFiler->writeItem(m_bIsDropWell);
	GlobalFunc::FilerWrite(pFiler, m_bIsWell);
	GlobalFunc::FilerWrite(pFiler, m_bIsDropWell);
	pFiler->writeItem(m_ID);

	Adesk::UInt16 nCount = (Adesk::UInt16)m_lstID.Length();
	pFiler->writeItem(nCount);
	for (Adesk::UInt16 i = 0; i < nCount; i++) {
		AcDbSoftPointerId id = m_lstID[i];
		pFiler->writeItem(id);
	}

	return pFiler->filerStatus();
}



TFeedWellData & TFeedWellData::operator = (const TFeedWellData &src)
{
	GlobalFunc::CopyObject(src, *this);
	return *this;
}

TFeedWellData::TFeedWellData(const TFeedWellData &src)
{
	*this = src;
}



//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
ACRX_DXF_DEFINE_MEMBERS(CDbVerticalSection, AecXDbEntityBaseEx, AcDb::kDHL_CURRENT,
	AcDb::kMReleaseCurrent, 1, AEC_ZT_VERTICALSECTION,
	"ATS_VERTICALSECTION图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
const Adesk::UInt8 CDbVerticalSection::g_nVersion = 3; // cet 2016.5.11 modify 添加了新成员变量


//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CDbVerticalSection::CDbVerticalSection()
{
	m_iScaleX = 100;
	m_iScaleY = 50;
	m_iCalcMode = 0;
	m_nStartDeep = 0;
	m_nMaxDeep = 0;
	m_nMinDeep = 0;
	m_nSpare = 0;
	m_nGridScale = 1;
	m_idTextLayer = NULL;
	m_idGridLayer = NULL;
	m_idSectLayer = NULL;
	m_idDoteLayer = NULL;
	m_sSheetHead = _T("井编号 设计地面标高（m） 埋设深度（m） 覆土厚度（m） 管内底标高（m） 管道长度（m） 管径（mm） 管道坡度 备注");
	m_sSheetRow = _T("");
}

void CDbVerticalSection::CopyPropertiesFrom(AcDbEntity *pSrc, unsigned gMatchFlag)
{
	assertWriteEnabled();
	CDbVerticalSection *pSect = CDbVerticalSection::cast(pSrc);
	if (pSect) {
		m_iScaleX = pSect->m_iScaleX;
		m_iScaleY = pSect->m_iScaleY;
		m_iCalcMode = pSect->m_iCalcMode;
	}
	AecXDbEntityBaseEx::CopyPropertiesFrom(pSrc, gMatchFlag);
}

//Acad::ErrorStatus CDbVerticalSection::subGetClassID(CLSID* pClsid) const
//{
//	return Acad::eOk;
//}

Acad::ErrorStatus CDbVerticalSection::subGetOsnapPoints(AcDb::OsnapMode osnapMode, INT_PTR gsSelectionMark, const AcGePoint3d& ptPick, const AcGePoint3d& lastPoint, const AcGeMatrix3d& viewXform, AcGePoint3dArray& snapPoints, AcDbIntArray& geomIds) const
{
	Acad::ErrorStatus es = AecXDbEntityBaseEx::subGetOsnapPoints(osnapMode, gsSelectionMark, ptPick, lastPoint, viewXform, snapPoints, geomIds);
	AcDbLine line1(m_ptTopLeft, m_ptBottomLeft);
	line1.getOsnapPoints(osnapMode, gsSelectionMark, ptPick, lastPoint, viewXform, snapPoints, geomIds);
	AcDbLine line2(m_ptBottomLeft, m_ptBottomRight);
	line2.getOsnapPoints(osnapMode, gsSelectionMark, ptPick, lastPoint, viewXform, snapPoints, geomIds);
	AcDbLine line3(m_ptTolRight, m_ptBottomRight);
	line3.getOsnapPoints(osnapMode, gsSelectionMark, ptPick, lastPoint, viewXform, snapPoints, geomIds);
	return es;
}

// 取得所有的夹点
Acad::ErrorStatus
CDbVerticalSection::subGetGripPoints(AcGePoint3dArray&  gripPoints,
	AcDbIntArray&  osnapModes,
	AcDbIntArray&  geomIds) const
{
	assertReadEnabled();
	XPoint pt = m_ptIns;
	ads_polar(pt, m_nLayoutRotation + PI, 10 * GetPScale(), pt);
	gripPoints.append(pt);

	for (int i = 0; i < m_lstPt.Length(); i++) {
		gripPoints.append(m_lstPt[i]);
	}
	// cet 2017.9.6 add 添加表格夹点，便于用户拖动对齐纵断面图
	gripPoints.append(m_ptTopLeft);
	gripPoints.append(m_ptTolRight);
	gripPoints.append(m_ptBottomLeft);
	gripPoints.append(m_ptBottomRight);
	return Acad::eOk;
}

// 功能: 夹点操作
Acad::ErrorStatus
CDbVerticalSection::subMoveGripPointsAt(const AcDbIntArray& indices, const AcGeVector3d& offset)
{
	assertWriteEnabled();
	AcGeMatrix3d mat;
	AcGeVector3d vtOffset = offset;
	vtOffset.z = 0;
	mat.setToTranslation(vtOffset);
	int idx = 0;

	for (int i = 0; i < indices.length(); i++) {
		idx = indices[i];
		if (idx == 0 || idx > m_lstPt.Length()) // cet 2017.9.6 modify 拖动底部两个夹点之一时，移动纵断面图
		{
			m_ptIns.TransformBy(mat);
			ads_matrix mat2;
			GlobalFunc::AsAdsMatrix(mat, mat2);
			m_lstPt.TransUCS(mat2);
			// cet 2017.9.6 add 更新表格夹点
			m_ptTopLeft.TransformBy(mat);
			m_ptTolRight.TransformBy(mat);
			m_ptBottomLeft.TransformBy(mat);
			m_ptBottomRight.TransformBy(mat);
		}
		else {
			XPoint ptOffset = *m_lstPt[idx - 1];
			XPoint ptOld = ptOffset;
			ptOffset.TransformBy(mat);
			double dScaleY = m_iScaleY;
			dScaleY = GetPScale() / dScaleY * 1000;//转化为毫米
			double nDist = (ptOffset.y - ptOld.y) / dScaleY;
			if (m_iCalcMode == 3) {
				m_lstFeedWell[(idx - 1) * 2]->m_nUpEle += nDist;
				for (int j = 0; j < m_lstWell.Length(); j++) {
					if (m_lstWell[j]->m_csName == m_lstFeedWell[(idx - 1) * 2]->m_csName) {
						m_lstWell[j]->m_nUpEle = m_lstFeedWell[(idx - 1) * 2]->m_nUpEle;
						break;
					}
				}
			}
			else {
				if ((idx - 1) * 2 < 0 || (idx - 1) * 2 > m_lstWell.Length() - 1)
					continue;
				m_lstWell[(idx - 1) * 2]->m_nUpEle += nDist;
			}
			Calc();
		}
	}
	Acad::ErrorStatus es = Acad::eOk;
	return es;
}

Acad::ErrorStatus
CDbVerticalSection::GetGripText(int idx, CString &cs) const
{
	Acad::ErrorStatus es = Acad::eOk;
	// cet 2017.9.6 add 底部添加的两个夹点提示
	if (idx > m_lstPt.Length())
	{
		cs = _T("移动");
		return es;
	}
	switch (idx) {
	case 0:
		cs = _T("移动");
		break;
	default:
		cs = _T("修改井面标高");
	}
	return es;
}

// 从DWG读入数据:
Acad::ErrorStatus CDbVerticalSection::dwgInFields(AcDbDwgFiler* pFiler)
{
	assertWriteEnabled();
	Acad::ErrorStatus es = AecXDbEntityBaseEx::dwgInFields(pFiler);
	if (es != Acad::eOk) return es;

	es = CLabelStyle::dwgInFields(pFiler);
	if (es != Acad::eOk) return es;


	Adesk::UInt8  nVer;
	pFiler->readItem(&nVer);
	if (nVer > g_nVersion) {// Version is too new
		return Acad::eMakeMeProxy;
	}
	pFiler->readItem((AcGePoint3d *)&m_ptIns);
	pFiler->readItem(&m_iScaleX);
	pFiler->readItem(&m_iScaleY);
	pFiler->readItem(&m_iCalcMode);
	pFiler->readItem(&m_nStartDeep);
	pFiler->readItem(&m_nSpare);
	pFiler->readItem(&m_nMaxDeep);
	pFiler->readItem(&m_nMinDeep);
	pFiler->readItem(&m_idTextLayer);
	pFiler->readItem(&m_idGridLayer);
	pFiler->readItem(&m_idSectLayer);
	pFiler->readItem(&m_idDoteLayer);
	GlobalFunc::ReadString(pFiler, m_sSheetHead);

	Adesk::UInt16 nNum = 0;
	pFiler->readItem(&nNum);
	m_lstWell.Reset();

	for (Adesk::UInt16 i = 0; i < nNum; i++) {
		TWellData *pData = new TWellData;
		pData->dwgInFields(pFiler, nVer);
		m_lstWell.Append(pData);
	}

	if (m_iCalcMode == 3)//如果是给水系统，则重新构造链表
		GetFeedWellListData(m_lstWell, m_lstFeedWell);

	m_lstPt.Reset();
	pFiler->readItem(&nNum);
	for (i = 0; i < nNum; i++) {
		XPoint PtTemp;
		pFiler->readItem((AcGePoint3d *)&PtTemp);
		m_lstPt.NewAppend(PtTemp);
	}
	if (nVer > 1)
	{
		GlobalFunc::ReadString(pFiler, m_sSheetRow);
	}
	m_nGridScale = GetGridScale();
	return pFiler->filerStatus();
}

Acad::ErrorStatus CDbVerticalSection::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	assertReadEnabled();
	Acad::ErrorStatus es = AecXDbEntityBaseEx::dwgOutFields(pFiler);
	if (es != Acad::eOk) return es;

	es = CLabelStyle::dwgOutFields(pFiler);
	if (es != Acad::eOk) return es;

	//if (g_nSaveTArchVer == 7)
	//	pFiler->writeItem((Adesk::UInt8)1);
	//else if (g_nSaveTArchVer <= 10) // cet 2016.5.13 add 
	//	pFiler->writeItem((Adesk::UInt8)2);
	//else
		pFiler->writeItem(g_nVersion);

	pFiler->writeItem((const AcGePoint3d &)m_ptIns);
	pFiler->writeItem(m_iScaleX);
	pFiler->writeItem(m_iScaleY);
	pFiler->writeItem(m_iCalcMode);
	pFiler->writeItem(m_nStartDeep);
	pFiler->writeItem(m_nSpare);
	pFiler->writeItem(m_nMaxDeep);
	pFiler->writeItem(m_nMinDeep);
	pFiler->writeItem(m_idTextLayer);
	pFiler->writeItem(m_idGridLayer);
	pFiler->writeItem(m_idSectLayer);
	pFiler->writeItem(m_idDoteLayer);
	pFiler->writeItem((const TCHAR *)m_sSheetHead);

	Adesk::UInt16 nCount = (Adesk::UInt16)m_lstWell.Length();
	pFiler->writeItem(nCount);

	int iVer = 1;
	//if (g_nSaveTArchVer == 7)
	//	iVer = 1;
	//else if (g_nSaveTArchVer <= 10) // cet 2016.5.13 add 
	//	iVer = 2;
	//else
		iVer = g_nVersion;

	for (Adesk::UInt16 i = 0; i < nCount; i++) {
		m_lstWell[i].dwgOutFields(pFiler, iVer);
	}

	nCount = (Adesk::UInt16)m_lstPt.Length();
	pFiler->writeItem(nCount);
	for (i = 0; i < nCount; i++) {
		pFiler->writeItem((AcGePoint3d &)m_lstPt[i]);
	}

	//if (g_nSaveTArchVer > 7)
	{
		pFiler->writeItem((const TCHAR *)m_sSheetRow); //8.0数据
	}


	return pFiler->filerStatus();
}

Acad::ErrorStatus CDbVerticalSection::dxfInFields(AcDbDxfFiler* pFiler)
{
	assertWriteEnabled();
	Acad::ErrorStatus es = Acad::eOk;
	es = AecXDbEntityBaseEx::dxfInFields(pFiler);
	return es;
}

Acad::ErrorStatus CDbVerticalSection::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	Acad::ErrorStatus es = Acad::eOk;
	es = AecXDbEntityBaseEx::dxfOutFields(pFiler);
	return es;
}

// Active when being rotated, scaled, moved, etc.
Acad::ErrorStatus
CDbVerticalSection::subTransformBy(const AcGeMatrix3d& xform)
{
	assertWriteEnabled();
	m_ptIns.TransformBy(xform);
	ads_matrix mat;
	GlobalFunc::AsAdsMatrix(xform, mat);
	m_lstPt.TransUCS(mat);
	Acad::ErrorStatus es = Acad::eOk;
	return es;
}

Acad::ErrorStatus CDbVerticalSection::subIntersectWith(const AcDbEntity* ent,
	AcDb::Intersect intType,
	AcGePoint3dArray& points,
	int thisGsMarker,
	int otherGsMarker) const
{

	return Acad::eOk;
}

Acad::ErrorStatus CDbVerticalSection::subIntersectWith(const AcDbEntity* ent,
	AcDb::Intersect intType,
	const AcGePlane& projPlane,
	AcGePoint3dArray& points,
	int thisGsMarker,
	int otherGsMarker) const
{

	return Acad::eOk;
}

//const TCHAR* CDbVerticalSection::GetSheetRowHeight() const
//{
//	const EntityFields &fd = GetFields();
//	CString sData;
//	fd.GFD(_T("ROW_HEIGHT"), sData);
//	return (const TCHAR*)sData;
//}
//
//void CDbVerticalSection::SetSheetRowHeight(const TCHAR* szSheetRowHeight)
//{
//	assertWriteEnabled();
//	EntityFields &fd = Fields();
//	fd.SFD(_T("ROW_HEIGHT"), szSheetRowHeight);
//}


//判断是否是节点？
BOOL IsNodeWell(AcDbObjectId id)
{
	OPENOBJ_BEGIN(id, AcDb::kForRead, AecXDbWell, pEquip);
	if (pEquip) {
		AcDbObjectId eqId = pEquip->GetBlock2d();
		CString csBlkName = GlobalFunc::GetSymbolName(eqId);
		if (_tcsicmp(_T("$TwtSys$00000389"), csBlkName) == 0)
			return TRUE;
	}
	OPENOBJ_END();
	return FALSE;
}

void CDbVerticalSection::DrawBreakPipe(XPoint ptStart, XPoint ptEnd, AcGiDraw &dc) const
{
	AcDbObjectId idLayerOld = dc.GetLayerId();
	dc.SetLayer(m_idSectLayer);

	XPoint ptMid, ptTmp1, ptTmp2;
	XLine l1(ptStart, ptEnd);
	ptMid = l1.MidPoint();

	XLine l2(ptStart, ptMid);
	ptTmp1 = l2.MidPoint();
	ads_polar(ptTmp1, m_nLayoutRotation + PI, l2.GetLength() / 4, ptTmp1);
	XArc arc(ptStart, ptTmp1, ptMid);

	DrawArc(dc, arc);
	//dc.DrawArc(arc, 0);

	XLine l3(ptEnd, ptMid);
	ptTmp2 = l3.MidPoint();
	ads_polar(ptTmp2, m_nLayoutRotation, l3.GetLength() / 4, ptTmp2);
	XArc arc2(ptMid, ptTmp2, ptEnd);
	//dc.DrawArc(arc2, 0);
	DrawArc(dc, arc2);
	dc.SetLayer(idLayerOld);
}

void CDbVerticalSection::DrawGridLine(XPoint ptStart, XPoint ptEnd, AcGiDraw &dc) const
{

	//2011-9-30 SR 关闭图层，打印的时候依然打印。dc.DrawLine存在问题，改viewDraw.Polyline正常。无法解释李夫银在查
	//    if(m_nGridScale < 0.01)
	//        return;
	//    AcDbObjectId idLayerOld=dc.GetLayerId();
	//    dc.SetLayer(m_idGridLayer);
	//    XLine pLine(ptStart, ptEnd, 1);
	//    dc.DrawLine(pLine,0);
	//    dc.SetLayer(idLayerOld);

	if (m_nGridScale < 0.01)
		return;
	AcDbObjectId idLayerOld = dc.GetLayerId();
	dc.SetLayer(m_idGridLayer);
	XLine pLine(ptStart, ptEnd, 1);
	//if (dc.GetCommonDraw() && dc.IsPlotGeneration()) //如果在打印，换一种方式
	//{
	//	XAcGiViewDraw &viewDraw = (XAcGiViewDraw &)dc;
	//	XCurveSegment seg;
	//	seg = pLine;
	//	XPoly2D poly;
	//	seg.AsPoly2D(poly);
	//	AcDbPolyline pline;
	//	GlobalFunc::PolyConvert(poly, pline);
	//	viewDraw.Polyline(pline);
	//}
	//else
		//dc.DrawLine(pLine, 0);
	BaseEx::DrawLine(dc, pLine);
	dc.SetLayer(idLayerOld);
}

void CDbVerticalSection::DrawDoteLine(XPoint ptStart, XPoint ptEnd, AcGiDraw &dc) const
{
	AcDbObjectId idLayerOld = dc.GetLayerId();
	dc.SetLayer(m_idDoteLayer);
	XLine pLine(ptStart, ptEnd, 1);
	//if (_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor()) == 0 && dc.IsPlotGeneration())//如果在打印，换一种方式
	//{
	//	XAcGiViewDraw &viewDraw = (XAcGiViewDraw &)dc;
	//	XCurveSegment seg;
	//	seg = pLine;
	//	XPoly2D poly;
	//	seg.AsPoly2D(poly);
	//	AcDbPolyline pline;
	//	GlobalFunc::PolyConvert(poly, pline);
	//	viewDraw.Polyline(pline);
	//}
	//else
	//	dc.DrawLine(pLine, 0);
	BaseEx::DrawLine(dc, pLine);
	dc.SetLayer(idLayerOld);
}

void CDbVerticalSection::DrawLine(XPoint ptStart, XPoint ptEnd, AcGiDraw &dc) const
{
	AcDbObjectId idLayerOld = dc.GetLayerId();
	dc.SetLayer(m_idSectLayer);
	XLine pLine(ptStart, ptEnd, 1);
	//dc.DrawLine(pLine, 0);
	BaseEx::DrawLine(dc, pLine);
	dc.SetLayer(idLayerOld);
}

void CDbVerticalSection::DrawPLine(XPoint ptStart, XPoint ptEnd, AcGiDraw &dc, double nWeight) const
{
	AcDbObjectId idLayerOld = dc.GetLayerId();
	dc.SetLayer(m_idSectLayer);
	XLine pLine(ptStart, ptEnd, 1);
	XCurveSegment seg;
	seg = pLine;
	XPoly2D poly;
	seg.AsPoly2D(poly);
	AcDbPolyline pline;
	GlobalFunc::PolyConvert(poly, pline);
	//XAcGiViewDraw &viewDraw = (XAcGiViewDraw &)dc;
	//int nNum = pline.numVerts();
	//if (nNum > 0) {
	//	for (int k = 0; k < nNum; k++) {
	//		pline.setWidthsAt(k, nWeight, nWeight);
	//	}
	//	viewDraw.Polyline(pline);
	//}
	DrawPline(dc, pline);
	dc.SetLayer(idLayerOld);
}

void CDbVerticalSection::DrawText(XPoint ptText, const TCHAR*szText, AcGiDraw::TextAlignment Align, AcGiDraw &dc, double nRotation) const
{
	nRotation = m_nLayoutRotation + nRotation;
	AcDbObjectId idTextStyle = m_idTextStyle;
	if (!idTextStyle)
		idTextStyle = InitTextStyle(_T("Standard"));
	AcDbObjectId idLayerOld = dc.GetLayerId();
	dc.SetLayer(m_idTextLayer);
	AecXDbText text;
	text.SetPScale(GetPScale());
	text.setLayer(m_idTextLayer);
	text.SetStyleId(idTextStyle);
	text.SetText(szText);
	text.SetRotation(nRotation);
	text.SetLocation(ptText);
	text.SetHeight(m_dTextHeight);
	text.SetAlignment(Align);
	//text.ExplodeOrDraw2d(dc);
	DrawBaseEx(dc, text);

	dc.SetLayer(idLayerOld);
}

void CDbVerticalSection::DrawScaleArrow(XPoint ptStart, XPoint ptEnd, const TCHAR*szText, AcGiDraw &dc) const
{
	AcDbObjectId idLayerOld = dc.GetLayerId();
	dc.SetLayer(m_idTextLayer);

	AcDbObjectId idTextStyle = m_idTextStyle;
	if (!idTextStyle)
		idTextStyle = InitTextStyle(_T("Standard"));
	AecXDbSymbArrow pArrow;
	pArrow.setPropertiesFrom(this);

	XPoly2D poly;
	poly.AppendNode(ptStart);
	poly.AppendNode(ptEnd);
	pArrow.SetPoly2D(poly);
	pArrow.setLayer(m_idTextLayer);
	pArrow.SetTextLayerId(m_idTextLayer);
	pArrow.SetTextStyleId(idTextStyle);
	pArrow.SetTextHeight(m_dTextHeight);
	pArrow.SetTextAlign(AecXDbSymbArrow::kAlignMid);
	pArrow.SetArrowSize(2);
	pArrow.SetText(szText);
	XPoint ptText = pArrow.GetDefaultTextLocation();
	pArrow.SetTextLocation(ptText);
	//pArrow.ExplodeOrDraw2d(dc);
	DrawBaseEx(dc, pArrow);

	dc.SetLayer(idLayerOld);
}

void CDbVerticalSection::DrawEllipse(XPoint ptCen, double nRadiusLong, double nRadiusShort, AcDbObjectId idLay, AcGiDraw &dc, bool *pRet) const
{
	if (pRet != NULL)
	{
		*pRet = false;
	}
	// cet 2016.7.5 add 超出管井显示区域
	AcGeVector3d vtDir = AcGeVector3d::kXAxis;
	vtDir.rotateBy(m_nLayoutRotation + PI * 0.5, AcGeVector3d::kZAxis);
	XLine line(ptCen, ptCen + vtDir * 10, INFINITE);
	XPoint pt1, pt2;
	m_ptTop.Project(&line, pt1);
	m_ptBottom.Project(&line, pt2);
	if (pt1.Distance(ptCen) + pt2.Distance(ptCen) > pt1.Distance(pt2) + 0.001 &&
		(pt1.Distance(ptCen) > pt2.Distance(ptCen) && ptCen.Distance(pt2) > nRadiusLong + 0.0001 ||
			pt1.Distance(ptCen) < pt2.Distance(ptCen) && ptCen.Distance(pt1) > nRadiusLong + 0.0001))
	{
		return;
	}
	AcDbEllipse ellipse;
	double ratio = nRadiusShort / nRadiusLong;
	XPoint ptTem;
	ads_polar(ptCen, m_nLayoutRotation + PI / 2, nRadiusLong, ptTem);
	AcGeVector3d majorAxis = ptTem.AsAcGePoint3d() - ptCen.AsAcGePoint3d();
	// cet 2016.7.5 add 长轴小于短轴
	if (nRadiusLong + 0.001 < nRadiusShort)
	{
		ads_polar(ptCen, m_nLayoutRotation, nRadiusShort, ptTem);
		majorAxis = ptTem.AsAcGePoint3d() - ptCen.AsAcGePoint3d();
		ratio = nRadiusLong / nRadiusShort;
	}
	ellipse.set(ptCen, AcGeVector3d::kZAxis, majorAxis, ratio);
	int iColorIdx(7);
	OPENOBJ_BEGIN(idLay, AcDb::kForRead, AcDbLayerTableRecord, pRec);
	if (pRec) {
		AcCmColor color = pRec->color();
		iColorIdx = color.colorIndex();
	}
	OPENOBJ_END();
	ellipse.setColorIndex(iColorIdx);
	ellipse.setLayer(m_idGridLayer); // cet 2018.2.8 add 
	dc.DrawEntity(ellipse);
	if (pRet != NULL)
	{
		*pRet = true;
	}
}


int CDbVerticalSection::HitTestOnVS2(XPoint pt, double &nColWidth, double &nHeight, XPoint &ptRet)
{

	//	if(dc.IsFullExplode()) 
	//    {
	//		AecXDbText text;
	//		text.setPropertiesFrom(this);
	//		text.SetStyleId(m_idTextStyle);
	//		text.SetText(m_sText);
	//		text.SetRotation(GetTextRotation());
	//		text.SetLocation(ptLocation);
	//		text.SetHeight(m_dTextHeight);
	//		text.SetAlignment(AcGiDraw::kMiddleCenter);
	//		
	//    }
	//    else
	//	{
	//		AecXDbText text;
	//		text.setPropertiesFrom(this);
	//		text.SetStyleId(m_idTextStyle);
	//		text.SetText(m_sText);
	//		text.SetRotation(GetTextRotation());
	//		text.SetLocation(ptLocation);
	//		text.SetHeight(m_dTextHeight);
	//		text.SetAlignment(AcGiDraw::kMiddleCenter);
	//		
	//	}

	XPointList lstPt;
	XPoint ptIns = m_ptIns;
	double dScaleY = m_iScaleY;
	double dScaleX = m_iScaleX;
	dScaleX = GetPScale() / dScaleX * 1000;
	dScaleY = GetPScale() / dScaleY * 1000;//转化为毫米

	XPoint ptStart, ptEnd;
	ptStart = ptIns;
	double dPipeLen = 0;
	//1.0 创建点列表，其中z坐标记录宽度
	lstPt.Reset();

	ptIns.z = m_lstWell[0]->m_nWellRadius;
	//	if(GlobalFunc::DocGetMeterUnitDraw())
	ptIns.z = ptIns.z * GetPScale() / 100;

	lstPt.NewAppend(ptIns);
	//  cet 2016.5.10 modify 考虑起点是断管，且断管连接着化粪池的情况
	if (m_iCalcMode < 100)	// 从左往右
	{
		if (m_lstWell[0]->m_csName == _T("断管") && m_lstWell.Length() > 2 && m_lstWell[2]->m_csName == _T("HC"))
		{
			OPENOBJ_BEGIN(m_lstWell[2]->m_ID, AcDb::kForRead, CDbPool, pEquip);
			if (pEquip != NULL)
			{
				double dPoolLength = pEquip->GetPoolLength();
				if (!GlobalFunc::DocGetMeterUnitDraw())
					dPoolLength = dPoolLength / 1000;
				ads_polar(ptIns, m_nLayoutRotation, dPoolLength * dScaleX * 0.5, ptIns);
				ptIns.z = dPoolLength * dScaleX;
				ptIns.z = ptIns.z * GetPScale() / 100;
				lstPt.Reset();
				lstPt.NewAppend(ptIns);
				ads_polar(ptIns, m_nLayoutRotation, dPoolLength * dScaleX * 0.5, ptIns);
				ptStart = ptIns;
			}
			OPENOBJ_END();
		}
	}
	else // 从右到左
	{
		int nCount = m_lstWell.Length();
		if (m_lstWell[nCount - 1]->m_csName == _T("断管") && nCount > 3 && m_lstWell[nCount - 3]->m_csName == _T("HC"))
		{
			OPENOBJ_BEGIN(m_lstWell[nCount - 3]->m_ID, AcDb::kForRead, CDbPool, pEquip);
			if (pEquip != NULL)
			{
				double dPoolLength = pEquip->GetPoolLength();
				if (!GlobalFunc::DocGetMeterUnitDraw())
					dPoolLength = dPoolLength / 1000;
				ads_polar(ptIns, m_nLayoutRotation, dPoolLength * dScaleX * 0.5, ptIns);
				ptIns.z = dPoolLength * dScaleX;
				ptIns.z = ptIns.z * GetPScale() / 100;
				lstPt.Reset();
				lstPt.NewAppend(ptIns);
				ads_polar(ptIns, m_nLayoutRotation, dPoolLength * dScaleX * 0.5, ptIns);
				ptStart = ptIns;
			}
			OPENOBJ_END();
		}
	}
	double dEleStart(0);

	if (m_iCalcMode < 100)	// 从左往右		原代码
		dEleStart = m_lstWell[0]->m_nUpEle;
	else					// 从右向左     王辉 添加 08-05-05
		dEleStart = m_lstWell[m_lstWell.Length() - 1]->m_nUpEle;

	double dLastEle = dEleStart;
	if (m_iCalcMode < 100)	// 从左往右
	{
		for (int i = 0; i < m_lstWell.Length(); i++) {
			double nEle = m_lstWell[i]->m_nUpEle - dLastEle;//地面标高   
			if (m_lstWell[i]->m_bIsWell) {     //井
				if (dPipeLen > 0) {
					ads_polar(ptStart, m_nLayoutRotation, dPipeLen / 2, ptEnd);
					ads_polar(ptEnd, m_nLayoutRotation + PI / 2, nEle * dScaleY, ptEnd);
					ptEnd.z = dPipeLen;
					lstPt.NewAppend(ptEnd);
					dLastEle = m_lstWell[i]->m_nUpEle;

					ads_polar(ptStart, m_nLayoutRotation, dPipeLen, ptEnd);
					ads_polar(ptEnd, m_nLayoutRotation + PI / 2, nEle * dScaleY, ptEnd);

					if (m_lstWell[i]->m_csName == _T("HC")) {
						OPENOBJ_BEGIN(m_lstWell[i]->m_ID, AcDb::kForRead, CDbPool, pEquip);
						if (pEquip) {
							double dPoolLength = pEquip->GetPoolLength();
							if (!GlobalFunc::DocGetMeterUnitDraw())
								dPoolLength = dPoolLength / 1000;
							ads_polar(ptEnd, m_nLayoutRotation, dPoolLength / 2 * dScaleX, ptEnd);
							ptEnd.z = dPoolLength * dScaleX;
							lstPt.NewAppend(ptEnd);
							ads_polar(ptEnd, m_nLayoutRotation, dPoolLength / 2 * dScaleX, ptEnd);
							ptStart = ptEnd;
						}
						OPENOBJ_END();
					}
					else
					{
						ptEnd.z = m_lstWell[i]->m_nWellRadius;
						//	if(GlobalFunc::DocGetMeterUnitDraw())
						ptEnd.z = ptEnd.z * GetPScale() / 100;

						lstPt.NewAppend(ptEnd);
						ptStart = ptEnd;
					}
				}
				dPipeLen = 0;
			}
			else if (!m_lstWell[i]->m_bIsWell) { //管
				dPipeLen = m_lstWell[i]->m_nLength * dScaleX;
				if (m_lstWell[i - 1]->m_csName == _T("断管"))
					dPipeLen = 0;
			}
		}
	}
	else			    	// 从右往左	
	{
		for (int i = m_lstWell.Length() - 1; i >= 0; --i)
		{
			double nEle = m_lstWell[i]->m_nUpEle - dLastEle;//地面标高  
			if (m_lstWell[i]->m_bIsWell)
			{     //井
				if (dPipeLen > 0)
				{
					ads_polar(ptStart, m_nLayoutRotation, dPipeLen / 2, ptEnd);
					ads_polar(ptEnd, m_nLayoutRotation + PI / 2, nEle * dScaleY, ptEnd);
					ptEnd.z = dPipeLen;
					lstPt.NewAppend(ptEnd);
					dLastEle = m_lstWell[i]->m_nUpEle;
					ads_polar(ptStart, m_nLayoutRotation, dPipeLen, ptEnd);
					ads_polar(ptEnd, m_nLayoutRotation + PI / 2, nEle * dScaleY, ptEnd);

					if (m_lstWell[i]->m_csName == _T("HC"))
					{
						OPENOBJ_BEGIN(m_lstWell[i]->m_ID, AcDb::kForRead, CDbPool, pEquip);
						if (pEquip) {
							double dPoolLength = pEquip->GetPoolLength();
							if (!GlobalFunc::DocGetMeterUnitDraw())
								dPoolLength = dPoolLength / 1000;
							ads_polar(ptEnd, m_nLayoutRotation, dPoolLength / 2 * dScaleX, ptEnd);
							ptEnd.z = dPoolLength * dScaleX;
							lstPt.NewAppend(ptEnd);
							ads_polar(ptEnd, m_nLayoutRotation, dPoolLength / 2 * dScaleX, ptEnd);
							ptStart = ptEnd;
						}
						OPENOBJ_END();
					}
					else
					{
						ptEnd.z = m_lstWell[i]->m_nWellRadius;
						//	if(GlobalFunc::DocGetMeterUnitDraw())
						ptEnd.z = ptEnd.z * GetPScale() / 100;
						lstPt.NewAppend(ptEnd);
						ptStart = ptEnd;
					}
				}
				dPipeLen = 0;
			}
			else if (!m_lstWell[i]->m_bIsWell)			//管
			{
				dPipeLen = m_lstWell[i]->m_nLength * dScaleX;
				if (m_lstWell[i + 1]->m_csName == _T("断管"))
					dPipeLen = 0;
			}
		}
	}
	int ret = -1;
	double nRotWcs = Layout2Wcs(0);
	int len = lstPt.Length();
	int nWell = m_lstWell.Length();
	//2.0 根据点列表，判断落点
	for (int i = 0; i < len; i++) {

		XPoint ptTmp = *lstPt[i];
		XPoint ptLeft, ptRight;
		double dLen = ptTmp.z;
		dLen = fabs(dLen);    // cet 2011.11.1 add  方井时半径为负值
		ptTmp.z = 0;

		ads_polar(ptTmp, m_nLayoutRotation + PI, dLen / 2, ptLeft);
		ads_polar(ptTmp, m_nLayoutRotation, dLen / 2, ptRight);
		XLine lnLeft(ptLeft, nRotWcs + PI / 2);
		XLine lnRight(ptRight, nRotWcs + PI / 2);
		int nSide1 = lnLeft.OnWhichSide(pt);
		int nSide2 = lnRight.OnWhichSide(pt);
		if (nSide1 == OFFSET_RIGHT && nSide2 == OFFSET_LEFT)
		{
			ret = i;
			if (m_iCalcMode < 100)				// 原来代码 按选择井的顺序画
			{
				// 正画
				if (m_lstWell[ret]->m_bIsWell)
					nHeight = (m_lstWell[ret]->m_nUpEle - m_lstWell[ret]->m_nDownEle) * dScaleY;
				else
					nHeight = (m_lstWell[ret - 1]->m_nUpEle - m_lstWell[ret - 1]->m_nDownEle) * dScaleY;
			}
			else								// add by 王辉 按选择井的反顺序画 08-05-05
			{
				// 倒画
				if (m_lstWell[ret]->m_bIsWell)
					nHeight = (m_lstWell[nWell - ret - 1]->m_nUpEle - m_lstWell[nWell - ret - 1]->m_nDownEle) * dScaleY;
				else
					nHeight = (m_lstWell[nWell - ret]->m_nUpEle - m_lstWell[nWell - ret]->m_nDownEle) * dScaleY;

			}
			nColWidth = dLen * 2;
			ptRet = ptTmp;
			break;
		}

	}

	return ret;
}


void CDbVerticalSection::UpdateHidePipes()
{
	//本图所有管线
	DList<AcDbObjectId> lstAllPipe;
	GetAllPipes(lstAllPipe);
	// 管网中的管道
	DList<AcDbObjectId> lstPipe;
	for (int i = 0; i < m_lstWell.Length(); ++i)
	{
		if (!m_lstWell[i]->m_bIsWell)
		{
			lstPipe.Append(new AcDbObjectId(m_lstWell[i]->m_ID));
		}
	}
	// 获取所有交叉信息
	std::vector<CrossPoint> vecCrossPoint;
	CalcCrossPipes(lstPipe, lstAllPipe, vecCrossPoint, true);
	// 清除管道遮挡信息，避免出错
	ClearHidePipes();
	// 添加遮挡管道信息
	EntityFields &fd = Fields();
	if (fd.SFD(_T("HidePipesNum"), (Adesk::UInt16)vecCrossPoint.size()))
	{
		std::vector<CrossPoint>::iterator it, itEnd = vecCrossPoint.end();
		CString sKey;
		int nIndex = 0;
		for (it = vecCrossPoint.begin(); it != itEnd; ++it)
		{
			sKey.Format(_T("HidePipe_%d"), nIndex);
			++nIndex;
			it->WriteCrossPoint(fd, sKey);
		}
	}
}

CString CDbVerticalSection::GetFillingPattern() const
{
	const EntityFields &fd = GetFields();
	CString sPattern = _T("AR-HBONE");
	fd.GFD(_T("FILLING_PATTERN"), sPattern);
	return sPattern;
}

void CDbVerticalSection::SetFillingPattern(const CString &sPattern)
{
	assertWriteEnabled();
	EntityFields &fd = Fields();
	fd.SFD(_T("FILLING_PATTERN"), sPattern);
}

double CDbVerticalSection::GetFillingRatio() const
{
	const EntityFields &fd = GetFields();
	double dRatio = 0.5;
	fd.GFD(_T("FILLING_RATIO"), dRatio);
	return dRatio;
}

void CDbVerticalSection::SetFillingRatio(double dRatio)
{
	assertWriteEnabled();
	EntityFields &fd = Fields();
	fd.SFD(_T("FILLING_RATIO"), dRatio);
}

Adesk::UInt16 CDbVerticalSection::GetFillingColor() const
{
	const EntityFields &fd = GetFields();
	Adesk::UInt16 nColor = 256;
	fd.GFD(_T("FILLING_COLOR"), nColor);
	return nColor;
}

void CDbVerticalSection::SetFillingColor(Adesk::UInt16 nColor)
{
	assertWriteEnabled();
	EntityFields &fd = Fields();
	fd.SFD(_T("FILLING_COLOR"), nColor);
}

/*
int CDbVerticalSection::HitTestOnVS2(XPoint pt, double &nColWidth, double &nHeight, XPoint &ptRet)
{
	double dScaleY = m_iScaleY;
	dScaleY = GetPScale() / dScaleY * 1000;//转化为毫米
	double dScaleX = m_iScaleX;
	dScaleX = GetPScale() / dScaleX * 1000;

	pt.z=0;
	int ret=-1;
	double dWellRadius = 4 * GetPScale();
	assertReadEnabled();
	double nRotWcs=Layout2Wcs(0);
	int len = m_lstPt.Length();
	int nWell = m_lstWell.Length();        // add by 王辉 08-05-05

	BOOL bHasPool = FALSE;
	for(int i=0;i<len;i++){
		if(m_lstWell[i]->m_csName == _T("HC"))
		{
			bHasPool = TRUE;
			break;
		}
	}
	if(bHasPool)
	{
	}


	for(int i=0;i<len;i++){
		double nWellRadius = dWellRadius;
		XPoint ptTmp = *m_lstPt[i];
		XPoint ptLeft, ptRight;
		//2009.6.8
//		if(m_lstWell[i]->m_csName == _T("HC"))
//		{
//			OPENOBJ_BEGIN(m_lstWell[i]->m_ID, AcDb::kForRead, CDbPool, pEquip);
//			if(pEquip){
//				double dPoolLen = pEquip->GetSizeX();
//				if(dPoolLen > 100.0)//图纸是毫米单位
//					dPoolLen = dPoolLen / 1000.0;
//				nWellRadius = dPoolLen * dScaleX;//化粪池的长度
//			}
//			OPENOBJ_END();
//
//		}

		ads_polar(ptTmp, m_nLayoutRotation+PI, nWellRadius, ptLeft);
		ads_polar(ptTmp, m_nLayoutRotation, nWellRadius, ptRight);
		XLine lnLeft(ptLeft, nRotWcs+PI/2);
		XLine lnRight(ptRight, nRotWcs+PI/2);
		int nSide1 = lnLeft.OnWhichSide(pt);
		int nSide2 = lnRight.OnWhichSide(pt);
		if(nSide1==OFFSET_RIGHT && nSide2==OFFSET_LEFT)
		{
			ret = i*2;
			if(m_iCalcMode < 100)				// 原来代码 按选择井的顺序画
			{
				// 正画
				nHeight = (m_lstWell[ret]->m_nUpEle - m_lstWell[ret]->m_nDownEle)*dScaleY;
			}
			else								// add by 王辉 按选择井的反顺序画 08-05-05
			{
				// 倒画
				nHeight = (m_lstWell[nWell - ret - 1]->m_nUpEle - m_lstWell[nWell - ret - 1]->m_nDownEle)*dScaleY;
			}
			nColWidth = nWellRadius*2;
			ptRet = ptTmp;
			break;
		}
		if(i != len-1){
			XPoint ptTmp2 = *m_lstPt[i+1];
			XLine line(ptTmp, ptTmp2);
			XPoint ptMid;
			line.MidPoint(ptMid);
			double nLen =  0.0;
			if(m_iCalcMode < 100)				// 原来代码 按选择井的顺序画
			{
				// 正画
				nLen = m_lstWell[i*2+1]->m_nLength* dScaleX;
			}
			else								// add by 王辉 按选择井的反顺序画 08-05-05
			{
				// 倒画
				nLen = m_lstWell[nWell - i*2 - 2]->m_nLength* dScaleX;
			}
			ads_polar(ptMid, m_nLayoutRotation+PI, nLen/2, ptLeft);
			ads_polar(ptMid, m_nLayoutRotation, nLen/2, ptRight);
			XLine lnLeft2(ptLeft, nRotWcs+PI/2);
			XLine lnRight2(ptRight, nRotWcs+PI/2);
			int nSide3 = lnLeft2.OnWhichSide(pt);
			int nSide4 = lnRight2.OnWhichSide(pt);
			if(nSide3==OFFSET_RIGHT && nSide4==OFFSET_LEFT)
			{
				ret = i*2+1;
				if(m_iCalcMode < 100)				// 原来代码 按选择井的顺序画
				{
					// 正画
					nHeight = (m_lstWell[i*2]->m_nUpEle - m_lstWell[i*2]->m_nDownEle)*dScaleY;
				}
				else								// add by 王辉 按选择井的反顺序画 08-05-05
				{
					// 倒画
					nHeight = (m_lstWell[nWell - i*2 - 1]->m_nUpEle - m_lstWell[nWell - i*2 - 1]->m_nDownEle)*dScaleY;
				}
				nColWidth = (nLen-nWellRadius)*2;
				ptRet = ptMid;
				break;
			}
		}

	}
	return ret;
}
	*/

int CDbVerticalSection::HitTestOnVS(XPoint pt, double &nColWidth, double &nHeight, XPoint &ptRet)
{
	pt.z = 0;


	AcDbVoidPtrArray entSet;
	explode(entSet);
	int len = entSet.length();

	//计算纵断面高度
	double dScaleY = m_iScaleY;
	double dScaleX = m_iScaleX;
	dScaleX = GetPScale() / dScaleX * 1000;
	dScaleY = GetPScale() / dScaleY * 1000;//转化为毫米
	double nHighEle = m_nMaxDeep;
	double nLowEle = m_nMinDeep;
	int iHighEle = (int)(nHighEle + 1);
	int iLowEle = (int)nLowEle;
	if (fabs(nLowEle) > iLowEle && nLowEle < 0)
		iLowEle--;

	int iAllMeter = iHighEle - iLowEle;
	nHeight = iAllMeter * dScaleY;
	int ret = -1;
	for (int i = 0; i < len; i++) {
		if (ret > -1)
			break;
		AcDbEntity *pEnt = (AcDbEntity *)entSet[i];
		CDbSheet *pSheet = NULL;
		if (pSheet = CDbSheet::cast(pEnt)) {
			int nColNum = pSheet->GetColumnNum();
			XPoint ptTopLeft = pSheet->GetTopLeft(FALSE);
			double nRotWcs = Layout2Wcs(0);
			for (int n = 0; n < nColNum; n++) {
				XLine lnLeft(ptTopLeft, nRotWcs + PI / 2);
				nColWidth = pSheet->GetColumnWidth(n, FALSE);
				ads_polar(XPoint(ptTopLeft), nRotWcs, nColWidth, ptTopLeft);
				XLine lnRight(ptTopLeft, nRotWcs + PI / 2);
				int nSide1 = lnLeft.OnWhichSide(pt);
				int nSide2 = lnRight.OnWhichSide(pt);
				if (nSide1 == OFFSET_RIGHT && nSide2 == OFFSET_LEFT)
				{
					double d1 = pt.Distance(&lnLeft), d2 = pt.Distance(&lnRight);
					double distPre = (d1 + d2) / 20.0;
					if (!(d1 < distPre || d2 < distPre)) {
						ret = n;
						ptRet = pSheet->GetColumnPoint(n);
						break;
					}
				}
			}
		}
	}
	GlobalFunc::ReleaseEntSet(entSet);
	return ret;
}

Acad::ErrorStatus CDbVerticalSection::DrawScale(AcGiDraw &dc, XPoint &ptEnd) const
{
	double dScaleY = m_iScaleY;
	double dScaleX = m_iScaleX;
	dScaleX = GetPScale() / dScaleX * 1000;
	dScaleY = GetPScale() / dScaleY * 1000;//转化为毫米

	XPoint ptStart;
	XPoint ptIns = m_ptIns;
	double nHighEle = m_nMaxDeep;
	double nLowEle = m_nMinDeep;
	double nEleStart = 0.0;
	if (m_iCalcMode < 100)	// 从左往右 原代码
		nEleStart = m_lstWell[0].m_nUpEle;
	else					// add by 王辉 08-05-05
		nEleStart = m_lstWell[m_lstWell.Length() - 1].m_nUpEle;
	//绘制比例尺
	int iHighEle = (int)(nHighEle + 1);
	int iLowEle = (int)nLowEle;
	if (fabs(nLowEle) > iLowEle && nLowEle < 0)
		iLowEle--;
	//2009-6-24 增加以下2句，
	if (fabs(nLowEle - iLowEle) < 0.2)   //如果最低标尺值距实际最低标高就差0.2米，最低标尺再降低1米
		iLowEle--;
	if (fabs(nHighEle - iHighEle) < 0.2) //如果最高标尺值距实际最高标高就差0.2米，最高标尺再提高1米
		iHighEle++;

	int iAllMeter = iHighEle - iLowEle;
	nHighEle = (double)iHighEle - nEleStart;
	ads_polar(ptIns, m_nLayoutRotation + PI, 20 * GetPScale(), ptStart);
	ads_polar(ptStart, m_nLayoutRotation + PI / 2, nHighEle * dScaleY, ptStart);

	//第一行比例尺
	XPoint ptText, ptFisrtStart, ptStart2, ptEnd2, pt1;
	ptFisrtStart = ptStart;
	CString csText;
	csText.Format(_T("%.2f"), (double)iHighEle);
	ads_polar(ptStart, m_nLayoutRotation + PI, 3 * GetPScale(), ptText);
	DrawText(ptText, csText, AcGiDraw::kBottomRight, dc);
	ads_polar(ptStart, m_nLayoutRotation, GetAllPipeLen() + 20 * GetPScale(), pt1);
	DrawGridLine(pt1, ptStart, dc);
	double nHighEleTmp = (double)iHighEle;
	ads_polar(ptStart, m_nLayoutRotation + PI, 2 * GetPScale(), ptStart2);

	DrawGridLine(ptStart, ptStart2, dc);
	double nNum = 1 / m_nGridScale;
	double nGridScale = m_nGridScale;
	if (m_nGridScale < 0.01) {
		nNum = 1;
		nGridScale = 1;
	}

	for (int i = 0; i < iAllMeter * nNum; i++) {
		ads_polar(ptStart, m_nLayoutRotation - PI / 2, dScaleY / nNum, ptEnd);
		if (i % 2 == 0)
			ads_polar(ptStart, m_nLayoutRotation + PI, 1.5 * GetPScale(), ptStart2);
		else
			ads_polar(ptStart, m_nLayoutRotation + PI, 0.5 * GetPScale(), ptStart2);
		ads_polar(ptStart2, m_nLayoutRotation - PI / 2, dScaleY / nNum, ptEnd2);
		DrawPLine(ptStart2, ptEnd2, dc, 1 * GetPScale());

		ads_polar(ptStart, m_nLayoutRotation + PI, 2 * GetPScale(), ptStart2);
		ads_polar(ptStart2, m_nLayoutRotation - PI / 2, dScaleY / nNum, ptEnd2);
		DrawLine(ptStart, ptEnd, dc);
		DrawLine(ptStart2, ptEnd2, dc);

		ads_polar(ptEnd, m_nLayoutRotation + PI, 3 * GetPScale(), ptText);
		nHighEleTmp = nHighEleTmp - nGridScale;
		csText.Format(_T("%.2f"), nHighEleTmp);
		DrawText(ptText, csText, AcGiDraw::kBottomRight, dc);

		ptStart = ptEnd;
		//绘制横网格
		if (m_nGridScale > 0.01) {
			ads_polar(ptEnd, m_nLayoutRotation, GetAllPipeLen() + 20 * GetPScale(), pt1);
			DrawGridLine(pt1, ptEnd, dc);
		}
	}
	ads_polar(ptEnd, m_nLayoutRotation + PI, 2 * GetPScale(), ptEnd2);
	DrawGridLine(ptEnd, ptEnd2, dc);
	// cet 2016.7.5 add 管井Y值方向显示区域
	const_cast<XPoint&>(m_ptTop) = ptFisrtStart;
	const_cast<XPoint&>(m_ptBottom) = ptEnd;

	//绘制比例
	ads_polar(ptStart, m_nLayoutRotation + PI, 30 * GetPScale(), ptEnd);
	ads_polar(ptEnd, m_nLayoutRotation, 15 * GetPScale(), pt1);
	DrawScaleArrow(ptEnd, pt1, XString(_T("1:%d"), m_iScaleX), dc);
	ads_polar(ptEnd, m_nLayoutRotation + PI / 2, 15 * GetPScale(), pt1);
	DrawScaleArrow(ptEnd, pt1, XString(_T("1:%d"), m_iScaleY), dc);



	//绘制竖网格  ptStart当前是比例尺最下端
	if (m_nGridScale > 0.01) {
		double nCount = (GetAllPipeLen() + 20 * GetPScale()) / (dScaleY / nNum);
		for (i = 1; i <= nCount; i++) {
			XPoint ptTmp1, ptTmp2;
			ads_polar(ptStart, m_nLayoutRotation, i * dScaleY / nNum, ptTmp1);
			ads_polar(ptTmp1, m_nLayoutRotation + PI / 2, iAllMeter * dScaleY, ptTmp2);
			DrawGridLine(ptTmp1, ptTmp2, dc);
		}
	}

	//    //绘制井中心线
	//    ads_polar(ptStart, m_nLayoutRotation-PI/2, 10*GetPScale(), ptEnd);
	//    //ads_polar(ptEnd, m_nLayoutRotation+PI, 10*GetPScale(), ptEnd);
	//    for(i=0;i<m_lstPt.Length();i++){
	//        XPoint ptTmp1 = m_lstPt[i];
	//        XPoint ptTmp2 = ptTmp1;
	//        ptTmp2.y = ptEnd.y;
	//        DrawDoteLine(ptTmp1, ptTmp2, dc);
	//    }

		//绘制井中心线
	ads_polar(ptStart, m_nLayoutRotation - PI / 2, 10 * GetPScale(), ptStart);
	ads_polar(ptStart, m_nLayoutRotation, 10 * GetPScale(), ptEnd2);

	XLine lineButton(ptStart, ptEnd2); //底线
	for (i = 0; i < m_lstPt.Length(); i++) {
		XPoint ptTmp1 = m_lstPt[i];
		XPoint ptTmp2;
		ptTmp1.Project(&lineButton, ptTmp2);
		DrawDoteLine(ptTmp1, ptTmp2, dc);
		if (i == 0)
			ptEnd = ptTmp2;
	}

	return Acad::eOk;

}

double CDbVerticalSection::GetAllPipeLen() const
{
	assertReadEnabled();
	double dScaleY = m_iScaleY;
	double dScaleX = m_iScaleX;
	dScaleX = GetPScale() / dScaleX * 1000;
	dScaleY = GetPScale() / dScaleY * 1000;//转化为毫米
	double nAllPipeLen = 0;
	if (m_iCalcMode < 100)				// 原来代码 按选择井的顺序画
	{
		for (int i = 0; i < m_lstWell.Length(); i++)
		{
			if (!m_lstWell[i].m_bIsWell)
			{
				if (m_lstWell[0].m_csName == _T("断管") && i == 1)
					continue;

				//            double dLenPipe = m_lstWell[i].m_nLength;
				//			if(dLenPipe > 1000)// 7.0 管长用mm
				//				dLenPipe = dLenPipe/1000.0;

				double dPipeLen = m_lstWell[i].m_nLength * dScaleX;
				if (m_lstWell[i].m_dRealLength > 0.1)
					dPipeLen = m_lstWell[i].m_dRealLength * dScaleX; //实际管长
				// cet 2016.5.9 add 化粪池紧邻断管时，管道长度许统计上化粪池长度
				if (i < m_lstWell.Length() - 1 && m_lstWell[i + 1].m_csName == _T("断管"))
				{
					OPENOBJ_BEGIN(m_lstWell[i + 1].m_ID, AcDb::kForRead, CDbPool, pEquip);
					if (pEquip != NULL)
					{
						double dPoolLen = pEquip->GetSizeX();
						if (!GlobalFunc::DocGetMeterUnitDraw())//图纸是毫米单位
							dPoolLen = dPoolLen / 1000.0;
						dPipeLen -= dPoolLen * dScaleX * 0.5;
					}
					OPENOBJ_END();
				}
				nAllPipeLen += dPipeLen;
			}
			else if (m_lstWell[i].m_csName == _T("HC") &&
				m_lstWell[0].m_csName == _T("断管") && i == 2) // cet 2016.5.9 add 化粪池紧邻断管时，管道长度许统计上化粪池长度
			{
				OPENOBJ_BEGIN(m_lstWell[i].m_ID, AcDb::kForRead, CDbPool, pEquip);
				if (pEquip != NULL)
				{
					double dPoolLen = pEquip->GetSizeX();
					if (!GlobalFunc::DocGetMeterUnitDraw())//图纸是毫米单位
						dPoolLen = dPoolLen / 1000.0;
					nAllPipeLen += dPoolLen * dScaleX * 0.5;
				}
				OPENOBJ_END();
			}
		}
	}
	else								// add by 王辉 按选择井的反顺序画 08-05-05
	{
		for (int i = m_lstWell.Length() - 1; i >= 0; i--)
		{
			if (!m_lstWell[i].m_bIsWell)
			{
				if (m_lstWell[m_lstWell.Length() - 1].m_csName == _T("断管") && i == m_lstWell.Length() - 2)
					continue;

				//            double dLenPipe = m_lstWell[i].m_nLength;
				//			if(dLenPipe > 1000)// 7.0 管长用mm
				//				dLenPipe = dLenPipe/1000.0;

				double dPipeLen = m_lstWell[i].m_nLength * dScaleX;
				if (m_lstWell[i].m_dRealLength > 0.1)
					dPipeLen = m_lstWell[i].m_dRealLength * dScaleX; //实际管长
				// cet 2016.5.9 add 化粪池紧邻断管时，管道长度许统计上化粪池长度
				if (i > 0 && m_lstWell[i - 1].m_csName == _T("断管"))
				{
					OPENOBJ_BEGIN(m_lstWell[i - 1].m_ID, AcDb::kForRead, CDbPool, pEquip);
					if (pEquip != NULL)
					{
						double dPoolLen = pEquip->GetSizeX();
						if (!GlobalFunc::DocGetMeterUnitDraw())//图纸是毫米单位
							dPoolLen = dPoolLen / 1000.0;
						dPipeLen -= dPoolLen * dScaleX * 0.5;
					}
					OPENOBJ_END();
				}
				nAllPipeLen += dPipeLen;
			}
			else if (m_lstWell[i].m_csName == _T("HC") &&
				m_lstWell[m_lstWell.Length() - 1].m_csName == _T("断管") && i == m_lstWell.Length() - 3) // cet 2016.5.9 add 化粪池紧邻断管时，管道长度许统计上化粪池长度
			{
				OPENOBJ_BEGIN(m_lstWell[i].m_ID, AcDb::kForRead, CDbPool, pEquip);
				if (pEquip != NULL)
				{
					double dPoolLen = pEquip->GetSizeX();
					if (!GlobalFunc::DocGetMeterUnitDraw())//图纸是毫米单位
						dPoolLen = dPoolLen / 1000.0;
					nAllPipeLen += dPoolLen * dScaleX * 0.5;
				}
				OPENOBJ_END();
			}
		}
	}

	return nAllPipeLen;
}
/**********************************************************************
										   2 S 1
					   ______________________________________
					   |  |                |  |
					   |  |                |  |
					   |  |_7_____________6|  |
					   |                      |
					   +--+----------------+  |
							8              |  |_______________
										   |
										   +-------------------+

***********************************************************************/


Acad::ErrorStatus CDbVerticalSection::DrawSection(AcGiDraw &dc) const
{
	//  DList<AcDbObjectId> lstAllPipe;//本图所有管线
	// 	if(!!objectId())
	// 		GetAllPipes(lstAllPipe);
	double dUnitMeter = 1000;
	if (GlobalFunc::DocGetMeterUnitDraw())
		dUnitMeter = 1;


	XPoint ptIns = m_ptIns;
	double dScaleY = m_iScaleY;
	double dScaleX = m_iScaleX;
	dScaleX = GetPScale() / dScaleX * 1000;
	dScaleY = GetPScale() / dScaleY * 1000;//转化为毫米
	double iDn = InnerDn(m_lstWell[1].m_ID);
	iDn = iDn * dScaleY / 1000;
	double iDn2(0);
	double nEleStart = m_lstWell[0].m_nUpEle;
	XPoint ptStart, ptEnd, pt1, pt2, pt3, pt4, pt5, pt6, pt7, pt8, ptTmp, ptStartG, ptEndG;
	ptStart = ptIns;
	// cet 2016.5.9 add 纵断面图起点包含断管是，修正起点
	if (m_lstWell[0].m_csName == _T("断管") && m_lstWell.Length() > 2)
	{
		OPENOBJ_BEGIN(m_lstWell[2].m_ID, AcDb::kForRead, CDbPool, pEquip);
		if (pEquip != NULL)
		{
			double dPoolLen = pEquip->GetSizeX();
			if (!GlobalFunc::DocGetMeterUnitDraw())//图纸是毫米单位
				dPoolLen = dPoolLen / 1000.0;
			ads_polar(ptStart, m_nLayoutRotation, dPoolLen * dScaleX * 0.5, ptStart);
		}
		OPENOBJ_END();
	}
	ads_polar(ptStart, m_nLayoutRotation + PI / 2, (m_lstWell[0].m_nGroundEle - nEleStart) * dScaleY, ptStartG);
	double dPipeLen = 0;
	BOOL bDrawGround = FALSE;
	for (int i = 0; i < m_lstWell.Length(); i++) {
		if (m_lstWell[i].m_bIsWell) {     //井
			if (fabs(m_lstWell[i].m_nGroundEle) > 0.0001) {
				bDrawGround = TRUE;
				break;
			}
		}
	}
	// 	// cet 2017.8.28 add 获取所有交叉信息
	// 	DList<AcDbObjectId> lstPipe;
	// 	for(int i = 0; i < m_lstWell.Length(); ++i)
	// 	{
	// 		if(!m_lstWell[i].m_bIsWell)
	// 		{     
	// 			lstPipe.Append(new AcDbObjectId(m_lstWell[i].m_ID));
	// 		}
	// 	}
	//	std::vector<CrossPoint> vecCrossPoint;
	//	CalcCrossPipes(lstPipe, lstAllPipe, vecCrossPoint, IsShowPipeEndNotLinkedPipe());
	std::vector<CrossPoint> vecCrossPoint;
	GetCrossPointInfo(vecCrossPoint);
	for (i = 0; i < m_lstWell.Length(); i++) {
		double nEle = m_lstWell[i].m_nUpEle - nEleStart;     //井面标高        
		double nEleG = m_lstWell[i].m_nGroundEle - nEleStart;//地面标高        
		if (m_lstWell[i].m_bIsWell) {     //井
			BOOL bPool = m_lstWell[i].m_csName == _T("HC");

			if (m_lstWell[i].m_csName == _T("断管") && dPipeLen > 0) {
				double nI = m_lstWell[i - 1].m_nI;
				double nLow = nI * dPipeLen / 2;
				ads_polar(pt7, m_nLayoutRotation, dPipeLen / 2, pt3);
				ads_polar(pt8, m_nLayoutRotation, dPipeLen / 2, pt4);
				ads_polar(pt3, m_nLayoutRotation + PI / 2, -nLow, pt3);
				ads_polar(pt4, m_nLayoutRotation + PI / 2, -nLow, pt4);
				DrawPLine(pt7, pt3, dc, 0.35 * GetPScale());//井底边线
				DrawPLine(pt8, pt4, dc, 0.35 * GetPScale());//井底边线
				DrawBreakPipe(pt3, pt4, dc);
				ads_polar(ptStart, m_nLayoutRotation, dPipeLen, ptEnd);
				// cet 2016.5.10 add 右端断管
				int nCount = m_lstWell.Length();
				if (i == nCount - 1)
				{
					double nWellDia = fabs(m_lstWell[i - 2].m_nWellRadius * dScaleX * 0.002);
					ads_polar(ptStart, m_nLayoutRotation, nWellDia / 2, pt1);
					//  管道首端连着化粪池
					if (i >= 2 && m_lstWell[i - 2].m_csName == _T("HC"))
					{
						OPENOBJ_BEGIN(m_lstWell[i - 2].m_ID, AcDb::kForRead, CDbPool, pEquip);
						if (pEquip != NULL)
						{
							double dPoolLen = pEquip->GetSizeX() * GetPScale() / 100;
							ads_polar(ptStart, m_nLayoutRotation, dPoolLen * 0.5, pt1);
						}
						OPENOBJ_END();
					}
					ads_polar(pt1, m_nLayoutRotation, dPipeLen / 2, pt2);
					ads_polar(pt1, m_nLayoutRotation - PI / 2, 3 * GetPScale(), pt3);
					ads_polar(pt2, m_nLayoutRotation - PI / 2, 3 * GetPScale(), pt4);
					XPoly2D poly2d;
					poly2d.AppendNode(pt1);
					poly2d.AppendNode(pt3);
					poly2d.AppendNode(pt4);
					poly2d.AppendNode(pt2);
					//					cet 2018.2.8 modify 填充
					// 					if(!!objectId())
					// 						dc.DrawHatch(poly2d, _T("AR-HBONE"), 0.5*GetPScale());//动态拖动速度极慢
					DrawHatch(dc, poly2d);
				}
				continue;
			}
			else if (m_lstWell[i].m_csName == _T("断管") && dPipeLen < 0.0001) {
				continue;
			}
			double nWellDia = fabs(m_lstWell[i].m_nWellRadius * dScaleX * 0.002);//支持米单位
			// cet 2016.12.8 add 池的长度
			OPENOBJ_BEGIN(m_lstWell[i].m_ID, AcDb::kForRead, CDbPool, pEquip);
			if (pEquip != NULL)
			{
				nWellDia = pEquip->GetSizeX() * dScaleX;
				if (!GlobalFunc::DocGetMeterUnitDraw())//图纸是毫米单位
					nWellDia = nWellDia / 1000.0;
			}
			OPENOBJ_END();
			//  BOOL bIsNode = IsNodeWell(m_lstWell[i].m_ID);
			if (i != m_lstWell.Length() - 1)
				iDn = InnerDn(m_lstWell[i + 1].m_ID) * dScaleY / 1000;
			if (i != 0)
				iDn2 = InnerDn(m_lstWell[i - 1].m_ID) * dScaleY / 1000;

			//把井盖填平
			if (dPipeLen < 0.001) {
				ads_polar(ptStart, m_nLayoutRotation + PI / 2, nEle * dScaleY, ptStart);
				ads_polar(ptStart, m_nLayoutRotation + PI, nWellDia / 2, pt1);
				ads_polar(ptStart, m_nLayoutRotation, nWellDia / 2, pt2);
				DrawLine(pt1, pt2, dc);
			}
			if (dPipeLen > 0) {
				ads_polar(ptStart, m_nLayoutRotation, dPipeLen, ptEnd);
				nEle = m_lstWell[i].m_nUpEle - m_lstWell[i - 2].m_nUpEle;     //井面标高

				//	先得到设计地面标高的点ptEnd
				ads_polar(ptEnd, m_nLayoutRotation + PI / 2, nEle * dScaleY, ptEnd);
				//  再根据设计地面标高的点ptEnd，算出自然地面标高点（根据他们之差）sr 2009-12-21 修改
				ads_polar(ptEnd, m_nLayoutRotation + PI / 2, (m_lstWell[i].m_nGroundEle - m_lstWell[i].m_nUpEle) * dScaleY, ptEndG);
				if (bDrawGround)
					DrawDoteLine(ptStartG, ptEndG, dc);

				ads_polar(ptEnd, m_nLayoutRotation + PI, nWellDia / 2, pt1);
				ads_polar(ptEnd, m_nLayoutRotation, nWellDia / 2, pt2);
				DrawLine(pt1, pt2, dc);//把井盖填平
			 // cet 2016.12.7 modify 使用管道首端井的宽度  
			 // ads_polar(ptStart, m_nLayoutRotation, nWellDia/2, pt3);
				ads_polar(ptStart, m_nLayoutRotation, i >= 2 ? fabs(m_lstWell[i - 2].m_nWellRadius * dScaleX * 0.002) / 2 : nWellDia / 2, pt3);
				if (i >= 2 && m_lstWell[i - 2].m_csName == _T("HC"))
				{
					OPENOBJ_BEGIN(m_lstWell[i - 2].m_ID, AcDb::kForRead, CDbPool, pEquip);
					if (pEquip != NULL)
					{
						double dPoolLen = pEquip->GetSizeX() * dScaleX;
						if (!GlobalFunc::DocGetMeterUnitDraw())//图纸是毫米单位
							dPoolLen = dPoolLen / 1000.0;
						ads_polar(ptStart, m_nLayoutRotation, dPoolLen * 0.5, pt3);
					}
					OPENOBJ_END();
				}
				DrawLine(pt3, pt1, dc);//绘制地面线
			 // cet 2016.12.7 modify 使用管道首端井的宽度 
			 // ads_polar(ptStart, m_nLayoutRotation, nWellDia/2, pt1);
				ads_polar(ptStart, m_nLayoutRotation, i >= 2 ? fabs(m_lstWell[i - 2].m_nWellRadius * dScaleX * 0.002) / 2 : nWellDia / 2, pt1);
				// cet 2016.5.10 add 管道首端连着化粪池
				if (i >= 2 && m_lstWell[i - 2].m_csName == _T("HC"))
				{
					OPENOBJ_BEGIN(m_lstWell[i - 2].m_ID, AcDb::kForRead, CDbPool, pEquip);
					if (pEquip != NULL)
					{
						double dPoolLen = pEquip->GetSizeX() * dScaleX;
						if (!GlobalFunc::DocGetMeterUnitDraw())//图纸是毫米单位
							dPoolLen = dPoolLen / 1000.0;
						ads_polar(ptStart, m_nLayoutRotation, dPoolLen * 0.5, pt1);
					}
					OPENOBJ_END();
				}
				ads_polar(ptEnd, m_nLayoutRotation + PI, nWellDia / 2, pt2);
				// cet 2016.5.10 add 管道尾端连着化粪池
				if (m_lstWell[i].m_csName == _T("HC"))
				{
					OPENOBJ_BEGIN(m_lstWell[i].m_ID, AcDb::kForRead, CDbPool, pEquip);
					if (pEquip != NULL)
					{
						double dPoolLen = pEquip->GetSizeX() * dScaleX;
						if (!GlobalFunc::DocGetMeterUnitDraw())//图纸是毫米单位
							dPoolLen = dPoolLen / 1000.0;
						ads_polar(ptEnd, m_nLayoutRotation + PI, dPoolLen * 0.5, pt2);
					}
					OPENOBJ_END();
				}
				ads_polar(pt1, m_nLayoutRotation - PI / 2, 3 * GetPScale(), pt3);
				ads_polar(pt2, m_nLayoutRotation - PI / 2, 3 * GetPScale(), pt4);
				XPoly2D poly2d;
				poly2d.AppendNode(pt1);
				poly2d.AppendNode(pt3);
				poly2d.AppendNode(pt4);
				poly2d.AppendNode(pt2);

				//				cet 2018.2.8 modify 填充
				// 				if(!!objectId())
				// 					dc.DrawHatch(poly2d, _T("AR-HBONE"), 0.5*GetPScale());//动态拖动速度极慢
				DrawHatch(dc, poly2d);

				ptStart = ptEnd;
				ptStartG = ptEndG;
			}

			double dPoolEleUp(0), dPoolEleDown(0);
			if (bPool) {
				OPENOBJ_BEGIN(m_lstWell[i].m_ID, AcDb::kForRead, CDbPool, pEquip);
				if (pEquip) {
					double dPoolLen = pEquip->GetSizeX();
					if (dPoolLen > 100.0)//图纸是毫米单位
						dPoolLen = dPoolLen / 1000.0;
					nWellDia = dPoolLen * dScaleX;//化粪池的长度
					dPoolEleUp = pEquip->GetTopBanEle();
					dPoolEleDown = pEquip->GetBottomBanEle();
				}
				OPENOBJ_END();
				//                OPENOBJ_BEGIN(m_lstWell[i].m_ID, AcDb::kForRead, TDbPump, pEquip);
				//                if(pEquip){
				//					double dPoolLen = pEquip->GetPumpLength();
				//					if(dPoolLen > 100.0)//图纸是毫米单位
				//						dPoolLen = dPoolLen / 1000.0;
				//                    nWellDia = dPoolLen * dScaleX;//化粪池的长度
				//                    dPoolEleUp = pEquip->GetPumpQ();
				//                    dPoolEleDown = pEquip->GetPumpRaise();
				//                }     
				//                OPENOBJ_END();

								//如果化粪池有顶板，底板标高，则绘制化粪池矩形示意图
				if (fabs(dPoolEleUp) > 0.01 && fabs(dPoolEleDown) > 0.01) {
					XPoint ptPool1, ptPool2, ptPool3, ptPool4;
					ads_polar(ptEnd, m_nLayoutRotation + PI, nWellDia / 2, ptPool1);
					ads_polar(ptEnd, m_nLayoutRotation, nWellDia / 2, ptPool2);

					double dPoolDeepDown = m_lstWell[i].m_nUpEle - dPoolEleDown;
					ads_polar(ptPool1, m_nLayoutRotation - PI / 2, dPoolDeepDown * dScaleY, ptPool3);
					ads_polar(ptPool2, m_nLayoutRotation - PI / 2, dPoolDeepDown * dScaleY, ptPool4);
					DrawLine(ptPool3, ptPool4, dc);

					double dPoolDeepUp = m_lstWell[i].m_nUpEle - dPoolEleUp;
					ads_polar(ptPool1, m_nLayoutRotation - PI / 2, dPoolDeepUp * dScaleY, ptPool1);
					ads_polar(ptPool2, m_nLayoutRotation - PI / 2, dPoolDeepUp * dScaleY, ptPool2);
					DrawLine(ptPool1, ptPool2, dc);

					DrawLine(ptPool1, ptPool3, dc);
					DrawLine(ptPool2, ptPool4, dc);
				}
			}

			XPoint ptUpLeft2;
			ads_polar(ptStart, m_nLayoutRotation, nWellDia / 2, pt1);
			ads_polar(ptStart, m_nLayoutRotation + PI, nWellDia / 2, pt2);
			double nDeep = m_lstWell[i].m_nDeep * dScaleY;
			double nDeepLeft = nDeep;
			if (m_iCalcMode == 0)
				nDeepLeft = nDeep - iDn;
			else if (m_iCalcMode == 1)
				nDeepLeft = nDeep - iDn2;
			else if (m_iCalcMode == 2)
				nDeepLeft = nDeep - iDn2 - (iDn - iDn2) / 2;


			if (i != 0 && (m_lstWell[i].m_bIsDropWell || bPool)) { //给水系统没有跌水井
				double nDropDeep = m_lstWell[i].m_nUpEle - m_lstWell[i].m_nFrondDownEle;
				//  			 cet 2014.5.6 modify 化粪池与跌水井应分开处理
				// 			 // cet 2013.3.13 modify 
				//              // ads_polar(pt2, m_nLayoutRotation-PI/2, nDropDeep * dScaleY - iDn2, pt6); 
				// 				ads_polar(pt2, m_nLayoutRotation-PI/2, nDropDeep * dScaleY - iDn, pt6);
				if (bPool)
				{
					ads_polar(pt2, m_nLayoutRotation - PI / 2, nDropDeep * dScaleY - iDn, pt6);
				}
				else
				{
					ads_polar(pt2, m_nLayoutRotation - PI / 2, nDropDeep * dScaleY - iDn2, pt6);
				}
				ads_polar(pt6, m_nLayoutRotation - PI / 2, iDn, ptTmp);
				ads_polar(pt6, m_nLayoutRotation - PI / 2, iDn2, ptUpLeft2);
			}
			else {
				ads_polar(pt2, m_nLayoutRotation - PI / 2, nDeepLeft, pt6);
				if (m_iCalcMode == 0) {
					ads_polar(pt6, m_nLayoutRotation - PI / 2, iDn, ptTmp);
					ads_polar(pt6, m_nLayoutRotation - PI / 2, iDn2, ptUpLeft2);
				}
				else if (m_iCalcMode == 1) {
					ads_polar(pt6, m_nLayoutRotation - PI / 2, iDn2, ptTmp);
					ptUpLeft2 = ptTmp;
				}
				else if (m_iCalcMode == 2) {
					ads_polar(pt6, m_nLayoutRotation - PI / 2, iDn2 + (iDn - iDn2) / 2, ptTmp);
					ads_polar(pt6, m_nLayoutRotation - PI / 2, iDn2, ptUpLeft2);
				}

			}

			if (!ptUpLeft2)
				ptUpLeft2 = ptTmp;

			if (m_lstWell[i].m_csName != _T("HC")) { //如果是节点或者就不画井了
				if (i == 0)
					DrawPLine(pt2, ptTmp, dc, 0.3 * GetPScale());            //井左边线
				else {
					double nDropDeep2 = m_lstWell[i].m_nFrondDownEle - m_lstWell[i].m_nDownEle;
					DrawPLine(pt2, pt6, dc, 0.3 * GetPScale());              //井左边线
					if (m_lstWell[i].m_bIsDropWell && nDropDeep2 > 0)
					{
						ads_polar(pt2, m_nLayoutRotation - PI / 2, nDeep, ptTmp);
						DrawPLine(ptTmp, ptUpLeft2, dc, 0.3 * GetPScale());  //跌水井左下边线
					}
					else if (ptTmp != ptUpLeft2)
					{
						DrawPLine(ptTmp, ptUpLeft2, dc, 0.3 * GetPScale());  //井2边管径差
					}
				}
			}
			if (dPipeLen > 0) {
				DrawPLine(pt6, pt7, dc, 0.35 * GetPScale());              //横管上线
				DrawPLine(pt8, ptUpLeft2, dc, 0.35 * GetPScale());        //横管下线
			}
			/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
			//                          绘制表示本井其它管标高的管，用椭圆表示
			OPENOBJ_BEGIN(m_lstWell[i].m_ID, AcDb::kForRead, CDbEquipment, pEquip);
			if (pEquip) {
				int num = pEquip->GetInterfaceNum();
				if (num > 1) { // cet 2016.9.6 modify 未考虑起始端井连接的管道
					for (int j = 0; j < num; j++) {
						CPipeInterface face;
						pEquip->GetInterface(j, face);
						if (i > 0 && face.m_idPipe == m_lstWell[i - 1].m_ID)
							continue;
						if (i < m_lstWell.Length() - 1 && face.m_idPipe == m_lstWell[i + 1].m_ID)
							continue;
						// cet 2011.12.5 add 判断交叉管是否需要显示
						if (!IsShowCrossPipe(face.m_idPipe))
						{
							continue;
						}
						double nPipeDownEle = 0.0;
						double dOuterDn = 0.0, dPipeThick = 0.0;
						double nThirdDn(0);
						AcDbObjectId idLay = NULL;
						bool bBranch = true; // cet 2016.9.8 add 是否为支路
						OPENOBJ_BEGIN(face.m_idPipe, AcDb::kForRead, CDbPipe, pPipe);
						if (pPipe) {
							idLay = pPipe->layerId();
							nThirdDn = (pPipe->OuterDn() - pPipe->GetPipeThick() * 2) * dScaleY / 1000;
							// cet 2016.7.6 add 计算管内底标高, 内径
							double dDn = (pPipe->OuterDn() - pPipe->GetPipeThick() * 2) / 2000;
							if (pPipe->StartPoint().Distance2d(face.m_ptLocation) < 0.001)
							{
								nPipeDownEle = pPipe->StartPoint().z / dUnitMeter - dDn;
							}
							else
							{
								nPipeDownEle = pPipe->EndPoint().z / dUnitMeter - dDn;
							}
							dOuterDn = pPipe->OuterDn();
							dPipeThick = pPipe->GetPipeThick();
							bBranch = IsBrach(pPipe, m_lstWell[i].m_ID); // cet 2016.9.8 add 是否为支路
						}
						OPENOBJ_END();
						//						cet 2016.7.6 del 直接获取管底标高                                                
						//                      CString csPipeDownEle = pEquip->GetISysLabel(j);
						// 						if(csPipeDownEle == _T(""))
						//                          continue;
						//                      double nPipeDownEle = _tstof(csPipeDownEle);
						//						cet 2016.9.8 modify 细化显示控制
						//                      if(fabs(nPipeDownEle - m_lstWell[i].m_nDownEle) > 0.001) // cet 2016.9.6 modify 不绘制管内底标高与井底标高一致的管道
						if ((IsOnlyShowBranch() && bBranch || !IsOnlyShowBranch()) &&   // 控制是否只显示支路
							((fabs(nPipeDownEle - m_lstWell[i].m_nDownEle) > 0.001) && !IsShowEqualEleBranch() || IsShowEqualEleBranch())) // 是否只显示等高支路
						{
							XPoint ptEllipse;
							double nThirdPipeDeep = m_lstWell[i].m_nUpEle - nPipeDownEle;
							ads_polar(ptStart, m_nLayoutRotation - PI / 2, nThirdPipeDeep * dScaleY - nThirdDn / 2, ptEllipse);
							bool bRet = false;
							DrawEllipse(ptEllipse, (dOuterDn - dPipeThick * 2) * dScaleY * 0.0005, (dOuterDn - dPipeThick * 2) * dScaleX * 0.0005, idLay, dc, &bRet);

							// cet 2011.6.2 add 标注碰撞管内底标高
							if (bRet && IsDimEle())
							{
								CString s;
								DimEle(ptEllipse, (dOuterDn - dPipeThick * 2) * dScaleY * 0.0005, (dOuterDn - dPipeThick * 2) * dScaleX * 0.0005, nPipeDownEle, s, true, dc);
							}
						}
					}
				}
			}
			OPENOBJ_END();
			/////////////////////////////////////////////////////////////////////////////////////////////////////////////////


			XPoint ptBottomRight, ptUpRight, ptBottomLeft(ptTmp);
			ads_polar(pt1, m_nLayoutRotation - PI / 2, nDeep, ptBottomRight);
			if (i == m_lstWell.Length() - 1)
				ptUpRight = ptBottomRight;        //最后一个井
			else
				ads_polar(pt1, m_nLayoutRotation - PI / 2, nDeep - iDn, ptUpRight);



			if (m_lstWell[i].m_csName != _T("HC")) {
				if (m_lstWell[i].m_nSpare > 0) {//绘制沉沙井
					double nDeepSand = m_lstWell[i].m_nSpare / 1000 * dScaleY;
					XPoint ptSandRight, ptSandLeft;
					ads_polar(ptBottomRight, m_nLayoutRotation + PI / 2 * 3, nDeepSand, ptSandRight);
					ads_polar(ptBottomLeft, m_nLayoutRotation + PI / 2 * 3, nDeepSand, ptSandLeft);
					DrawPLine(ptSandRight, ptSandLeft, dc, 0.35 * GetPScale());   //井底边线
					DrawPLine(ptBottomRight, ptSandRight, dc, 0.35 * GetPScale());//沉沙边线
					DrawPLine(ptBottomLeft, ptSandLeft, dc, 0.35 * GetPScale());  //跌水井左下边线
				}
				else {
					double nDropDeep2 = m_lstWell[i].m_nFrondDownEle - m_lstWell[i].m_nDownEle;
					if (nDropDeep2 < 0) {   //虹吸井，往上跌水
						XPoint ptBottomRight2;
						ads_polar(ptBottomLeft, m_nLayoutRotation, nWellDia, ptBottomRight2);
						DrawPLine(ptBottomRight2, ptBottomLeft, dc, 0.35 * GetPScale());//井底边线
						DrawPLine(ptBottomRight2, ptBottomRight, dc, 0.35 * GetPScale());//井底边线
					}
					else
					{
						DrawPLine(ptBottomRight, ptBottomLeft, dc, 0.35 * GetPScale());//井底边线
					}

				}
				DrawPLine(pt1, ptUpRight, dc, 0.3 * GetPScale());             //井右边线
			}

			pt7 = ptUpRight;                      // PT7井管顶右边点
			pt8 = ptBottomRight;                  // PT8井管底左边点

			//前断管
			if (dPipeLen < 0.001 && i != 0) {
				double nI = m_lstWell[i - 1].m_nI;
				dPipeLen = 10 * GetPScale();
				double nLow = nI * dPipeLen / 2;
				ads_polar(pt6, m_nLayoutRotation + PI, dPipeLen / 2, pt3);
				ads_polar(ptUpLeft2, m_nLayoutRotation + PI, dPipeLen / 2, pt4);
				ads_polar(pt3, m_nLayoutRotation + PI / 2, nLow, pt3);
				ads_polar(pt4, m_nLayoutRotation + PI / 2, nLow, pt4);
				DrawPLine(pt6, pt3, dc, 0.35 * GetPScale());      //井底边线
				DrawPLine(ptUpLeft2, pt4, dc, 0.35 * GetPScale());//井底边线
				DrawBreakPipe(pt3, pt4, dc);
				// cet 2016.5.10 add 左端断管
				int nCount = m_lstWell.Length();
				if (i == 2)
				{
					double nWellDia = fabs(m_lstWell[i].m_nWellRadius * dScaleX * 0.002);
					ads_polar(ptStart, m_nLayoutRotation, -nWellDia / 2, pt1);
					//  管道尾端连着化粪池
					if (m_lstWell[i].m_csName == _T("HC"))
					{
						OPENOBJ_BEGIN(m_lstWell[i].m_ID, AcDb::kForRead, CDbPool, pEquip);
						if (pEquip != NULL)
						{
							double dPoolLen = pEquip->GetSizeX() * dScaleX;
							if (!GlobalFunc::DocGetMeterUnitDraw())//图纸是毫米单位
								dPoolLen = dPoolLen / 1000.0;
							ads_polar(ptStart, m_nLayoutRotation, -dPoolLen * 0.5, pt1);
						}
						OPENOBJ_END();
					}
					ads_polar(pt1, m_nLayoutRotation, -dPipeLen / 2, pt2);
					ads_polar(pt1, m_nLayoutRotation - PI / 2, 3 * GetPScale(), pt3);
					ads_polar(pt2, m_nLayoutRotation - PI / 2, 3 * GetPScale(), pt4);
					XPoly2D poly2d;
					poly2d.AppendNode(pt1);
					poly2d.AppendNode(pt3);
					poly2d.AppendNode(pt4);
					poly2d.AppendNode(pt2);
					//					cet 2018.2.8 modify 填充
					// 					if(!!objectId())
					// 						dc.DrawHatch(poly2d, _T("AR-HBONE"), 0.5*GetPScale());//动态拖动速度极慢
					DrawHatch(dc, poly2d);
				}
			}
			dPipeLen = 0;
		}
		else if (!m_lstWell[i].m_bIsWell) { //管
//			double dLenPipe = m_lstWell[i].m_nLength;
//			if(dLenPipe > 1000)// 7.0 管长用mm
//				dLenPipe = dLenPipe/1000.0;
			dPipeLen = m_lstWell[i].m_nLength * dScaleX;
			if (m_lstWell[i].m_dRealLength > 0.1)
				dPipeLen = m_lstWell[i].m_dRealLength * dScaleX;
			// cet 2016.5.10 add 右侧末尾连接断管
			if (i == m_lstWell.Length() - 2 && m_lstWell[i + 1].m_csName == _T("断管") && i > 0)
			{
				dPipeLen = m_lstWell[i].m_nLength * dScaleX;
			}
			if (m_lstWell[i - 1].m_csName == _T("断管"))
				dPipeLen = 0;
			//2006－10－20  SB 加入考虑其它交叉管线
			AcDbObjectId idPipe = m_lstWell[i].m_ID;
			OPENOBJ_BEGIN(idPipe, AcDb::kForRead, CDbPipe, pPipe);
			if (pPipe && m_lstWell[i - 1].m_csName != _T("断管"))
			{
				//-------------------------------------------------------------------------------------------
				//int nPipeNum = pPipe->GetHidePipes().Length();
				XPoint ptEllipse, ptInt;
				// ZXL 2013.12.06 ADD 管线交叉在此处处理（包括标高高于自身的管线的处理）
				DList<AcDbObjectId> lstCrossPipes;
				CrossPoint cr(pPipe->objectId());
				GetCrossInfo(vecCrossPoint, cr);
				cr.GetAllCrossPipes(lstCrossPipes);
				int nPipeNum = lstCrossPipes.Length();
				int nIndex = 0;

				for (int j = 0; j < nPipeNum; j++) {
					// ZXL 2013.12.06 modify
					//AcDbObjectId idOther = pPipe->GetHidePipes()[j];
					AcDbObjectId idOther = *lstCrossPipes[j];
					OPENOBJ_BEGIN(idOther, AcDb::kForRead, CDbPipe, pPipe2);
					if (pPipe2) {
						// cet 2011.12.5 add 判断交叉管是否需要显示
						if (!IsShowCrossPipe(pPipe2->objectId()))
						{
							continue;
						}
						double dDn = pPipe2->OuterDn() - pPipe2->GetPipeThick() * 2;
						double dI = pPipe2->GetPipeGradient();
						double dPipeStartEle(0);
						dDn = dDn / 2000; //转换为米单位
						if (pPipe2->GetFlowDir() == TPipeSys::kFromStart)
							dPipeStartEle = pPipe2->StartPoint().z / dUnitMeter - dDn;
						else
							dPipeStartEle = pPipe2->EndPoint().z / dUnitMeter - dDn;
						double nDist2Well1(0), nDist2Well2(0);
						cr.GetCrossInfo(idOther, ptInt, nDist2Well1, nDist2Well2);
						if (fabs(nDist2Well1) > 0.001 && fabs(nDist2Well2) > 0.001 || IsShowPipeEndNotLinkedPipe() && (fabs(nDist2Well1) > 0.001 || fabs(nDist2Well2) > 0.001))
						{
							AcDbObjectId idLay = pPipe2->layerId();
							//int iDnTmp = int(dDn*dScaleY/1000);
							double dDnTmp = dDn * dScaleY;
							double nPipeIntEle = dPipeStartEle - nDist2Well2 * dI; //根据相交管线起点标高计算交点标高
							double nThirdPipeDeep = m_lstWell[i - 1].m_nUpEle - nPipeIntEle;//转换为埋深
							ads_polar(ptStart, m_nLayoutRotation - PI / 2, nThirdPipeDeep * dScaleY - dDnTmp, ptEllipse);
							ads_polar(ptEllipse, m_nLayoutRotation, nDist2Well1 * dScaleX, ptEllipse);
							double dOuterDn = pPipe2->OuterDn();
							double dPipeThick = pPipe2->GetPipeThick();
							bool bRet = false;
							DrawEllipse(ptEllipse, (dOuterDn - dPipeThick * 2) * dScaleY * 0.0005, (dOuterDn - dPipeThick * 2) * dScaleX * 0.0005, idLay, dc, &bRet);
							// cet 2011.6.3 add 标注碰撞管内底标高
							if (bRet && IsDimEle())
							{
								CString sPipeName = pPipe2->GetPipeSystemName();
								sPipeName += _T("管");
								CString sLabel = pPipe2->GetLabel();
								sPipeName += sLabel;
								sLabel.Format(_T("%.f"), pPipe2->GetDnDiameter());
								sPipeName += sLabel;
								DimEle(ptEllipse, (dOuterDn - dPipeThick * 2) * dScaleY * 0.0005, (dOuterDn - dPipeThick * 2) * dScaleX * 0.0005, nPipeIntEle, sPipeName, false, dc);
							}
							// zxl 2013.12.10 add
							if (bRet && IsDimDist())
							{
								CString sDim;
								sDim.Format(_T("%.2f"), nDist2Well1 * dUnitMeter);
								if (dUnitMeter > 1.0)
								{
									sDim.Format(_T("%.f"), nDist2Well1 * dUnitMeter);
								}
								DimDist(sDim, ptStart, ptEllipse, dc, nIndex, nThirdPipeDeep, dDnTmp);
							}
						}

					}
					OPENOBJ_END();
				}
			}
			OPENOBJ_END();
		}
	}

	return Acad::eOk;
}
// 反向画井     2008.4.30  add by wanghui
Acad::ErrorStatus CDbVerticalSection::DrawSectionFromRight(AcGiDraw &dc) const
{
	//  DList<AcDbObjectId> lstAllPipe;//本图所有管线
	// 	if(!!objectId())
	// 		GetAllPipes(lstAllPipe);
	double dUnitMeter = 1000;
	if (GlobalFunc::DocGetMeterUnitDraw())
		dUnitMeter = 1;


	XPoint ptIns = m_ptIns;
	double dScaleY = m_iScaleY;
	double dScaleX = m_iScaleX;
	dScaleX = GetPScale() / dScaleX * 1000;
	dScaleY = GetPScale() / dScaleY * 1000;//转化为毫米
	// 管径
	double iDn = InnerDn(m_lstWell[m_lstWell.Length() - 2].m_ID) * dScaleY / 1000;
	double iDn2(0);
	// 开始井面标高
	double dEleStart = m_lstWell[m_lstWell.Length() - 1].m_nUpEle;

	XPoint ptStart, ptEnd, ptTmp, ptStartG, ptEndG;
	XPoint ptWellLeft, ptWellRight, ptPreWellRight, ptPreWellBtmDownRight, ptHatchLeft, ptHatchRight, ptWellDownLeft, ptWellDownRight;       // 左井口点 右井口点
	XPoint ptPreWellBtmUpRight, ptAftWellBtmUpLeft;
	XPoint ptWellDis1, ptWellDis2;
	// 插入点
	ptStart = ptIns;
	// cet 2016.5.9 add 纵断面图起点包含断管是，修正起点
	if (m_lstWell[m_lstWell.Length() - 1].m_csName == _T("断管") && m_lstWell.Length() > 2)
	{
		OPENOBJ_BEGIN(m_lstWell[m_lstWell.Length() - 3].m_ID, AcDb::kForRead, CDbPool, pEquip);
		if (pEquip != NULL)
		{
			double dPoolLen = pEquip->GetSizeX();
			if (!GlobalFunc::DocGetMeterUnitDraw())//图纸是毫米单位
				dPoolLen = dPoolLen / 1000.0;
			ads_polar(ptStart, m_nLayoutRotation, dPoolLen * dScaleX * 0.5, ptStart);
		}
		OPENOBJ_END();
	}
	// ptEndG地面标高
	ads_polar(ptStart, m_nLayoutRotation + PI / 2, (m_lstWell[m_lstWell.Length() - 1].m_nGroundEle - dEleStart) * dScaleY, ptStartG);

	BOOL bDrawGround = FALSE;
	for (int i = 0; i < m_lstWell.Length(); i++)
	{
		if (m_lstWell[i].m_bIsWell)							//井
		{
			if (fabs(m_lstWell[i].m_nGroundEle) > 0.0001)
			{
				bDrawGround = TRUE;
				break;
			}
		}
	}

	// 管线长
	double dPipeLen = 0.0;
	// 	// cet 2017.8.28 add 获取所有交叉信息
	// 	DList<AcDbObjectId> lstPipe;
	// 	for(int i = 0; i < m_lstWell.Length(); ++i)
	// 	{
	// 		if(!m_lstWell[i].m_bIsWell)
	// 		{     
	// 			lstPipe.Append(new AcDbObjectId(m_lstWell[i].m_ID));
	// 		}
	// 	}
	// 	std::vector<CrossPoint> vecCrossPoint;
	// 	CalcCrossPipes(lstPipe, lstAllPipe, vecCrossPoint, IsShowPipeEndNotLinkedPipe());
	std::vector<CrossPoint> vecCrossPoint;
	GetCrossPointInfo(vecCrossPoint);
	for (i = m_lstWell.Length() - 1; i >= 0; i--)
	{
		double dEle = m_lstWell[i].m_nUpEle - dEleStart;     //井面标高        
		double dEleG = m_lstWell[i].m_nGroundEle - dEleStart;//地面标高
		if (m_lstWell[i].m_bIsWell)
		{     //井
			BOOL bPool = m_lstWell[i].m_csName == _T("HC");
			CString str = m_lstWell[i].m_csName;
			if (i != m_lstWell.Length() - 1)
				iDn = InnerDn(m_lstWell[i + 1].m_ID) * dScaleY / 1000;	//前井管径 
			if (i != 0)
				iDn2 = InnerDn(m_lstWell[i - 1].m_ID) * dScaleY / 1000;	// 后井管径

			// 当前井埋深
			double dDeep = m_lstWell[i].m_nDeep * dScaleY;
			double dDeepLeft = dDeep;

			// 井直径
			double nWellDia = fabs(m_lstWell[i].m_nWellRadius * dScaleX * 0.002);//支持米单位   
			// cet 2016.12.8 add 池的长度
			OPENOBJ_BEGIN(m_lstWell[i].m_ID, AcDb::kForRead, CDbPool, pEquip);
			if (pEquip != NULL)
			{
				nWellDia = pEquip->GetSizeX() * dScaleX;
				if (!GlobalFunc::DocGetMeterUnitDraw())//图纸是毫米单位
					nWellDia = nWellDia / 1000.0;
			}
			OPENOBJ_END();
			if (m_lstWell[i].m_csName == _T("断管") && dPipeLen > 0) {
				double nI = m_lstWell[i + 1].m_nI;
				double nLow = nI * dPipeLen / 2;
				XPoint ptEndRight, ptEndRight1;
				ads_polar(ptPreWellBtmUpRight, m_nLayoutRotation, dPipeLen / 2, ptEndRight);
				ads_polar(ptEndRight, m_nLayoutRotation + PI / 2, -nLow, ptEndRight);
				DrawPLine(ptPreWellBtmUpRight, ptEndRight, dc, 0.35 * GetPScale());//井底上边线
				ads_polar(ptPreWellBtmUpRight, m_nLayoutRotation - PI / 2, iDn2, ptPreWellBtmUpRight);
				ads_polar(ptPreWellBtmUpRight, m_nLayoutRotation, dPipeLen / 2, ptEndRight1);
				ads_polar(ptEndRight1, m_nLayoutRotation + PI / 2, -nLow, ptEndRight1);

				DrawPLine(ptPreWellBtmUpRight, ptEndRight1, dc, 0.35 * GetPScale());//井底边线
				DrawBreakPipe(ptEndRight, ptEndRight1, dc);
				ads_polar(ptStart, 0, dPipeLen, ptEnd);
				// cet 2016.5.10 add 右端断管
				int nCount = m_lstWell.Length();
				if (i == 0)
				{
					XPoint pt1, pt2, pt3, pt4;
					double nWellDia = fabs(m_lstWell[2].m_nWellRadius * dScaleX * 0.002);
					ads_polar(ptStart, m_nLayoutRotation, nWellDia / 2, pt1);
					//  管道首端连着化粪池
					if (i < m_lstWell.Length() - 2 && m_lstWell[2].m_csName == _T("HC"))
					{
						OPENOBJ_BEGIN(m_lstWell[2].m_ID, AcDb::kForRead, CDbPool, pEquip);
						if (pEquip != NULL)
						{
							double dPoolLen = pEquip->GetSizeX() * GetPScale() / 100;
							ads_polar(ptStart, m_nLayoutRotation, dPoolLen * 0.5, pt1);
						}
						OPENOBJ_END();
					}
					ads_polar(pt1, m_nLayoutRotation, dPipeLen / 2, pt2);
					ads_polar(pt1, m_nLayoutRotation - PI / 2, 3 * GetPScale(), pt3);
					ads_polar(pt2, m_nLayoutRotation - PI / 2, 3 * GetPScale(), pt4);
					XPoly2D poly2d;
					poly2d.AppendNode(pt1);
					poly2d.AppendNode(pt3);
					poly2d.AppendNode(pt4);
					poly2d.AppendNode(pt2);
					//					cet 2018.2.8 modify 填充
					// 					if(!!objectId())
					// 						dc.DrawHatch(poly2d, _T("AR-HBONE"), 0.5*GetPScale());//动态拖动速度极慢
					DrawHatch(dc, poly2d);
				}
				continue;
			}
			else if (m_lstWell[i].m_csName == _T("断管") && dPipeLen < 0.0001) {
				continue;
			}

			//把井盖填平
			if (dPipeLen < 0.001)
			{
				ads_polar(ptStart, m_nLayoutRotation + PI / 2, dEle * dScaleY, ptStart);
				ads_polar(ptStart, m_nLayoutRotation + PI, nWellDia / 2, ptWellLeft);
				ads_polar(ptStart, m_nLayoutRotation, nWellDia / 2, ptWellRight);

				// 开始井盖
				DrawLine(ptWellLeft, ptWellRight, dc);
			}

			if (dPipeLen > 0)
			{
				ads_polar(ptStart, m_nLayoutRotation, dPipeLen, ptEnd);
				dEle = m_lstWell[i].m_nUpEle - m_lstWell[i + 2].m_nUpEle;     //井面标高

				//	先得到设计地面标高的点ptEnd
				ads_polar(ptEnd, m_nLayoutRotation + PI / 2, dEle * dScaleY, ptEnd);
				//  再根据设计地面标高的点ptEnd，算出自然地面标高点（根据他们之差）sr 2009-12-21 修改
				ads_polar(ptEnd, m_nLayoutRotation + PI / 2, (m_lstWell[i].m_nGroundEle - m_lstWell[i].m_nUpEle) * dScaleY, ptEndG);

				if (bDrawGround)
					DrawDoteLine(ptStartG, ptEndG, dc);


				ads_polar(ptEnd, m_nLayoutRotation + PI, nWellDia / 2, ptWellLeft);
				ads_polar(ptEnd, m_nLayoutRotation, nWellDia / 2, ptWellRight);

				DrawLine(ptWellLeft, ptWellRight, dc);//把井盖填平
			 // cet 2016.12.7 modify 使用管道首端井的宽度 
			 // ads_polar(ptStart, m_nLayoutRotation, nWellDia / 2, ptPreWellRight);
				int nSize = m_lstWell.Length();
				ads_polar(ptStart, m_nLayoutRotation, i < nSize - 2 ? fabs(m_lstWell[i + 2].m_nWellRadius * dScaleX * 0.002) / 2 : nWellDia / 2, ptPreWellRight);
				if (i <= m_lstWell.Length() - 3 && m_lstWell[i + 2].m_csName == _T("HC"))
				{
					OPENOBJ_BEGIN(m_lstWell[i + 2].m_ID, AcDb::kForRead, CDbPool, pEquip);
					if (pEquip != NULL)
					{
						double dPoolLen = pEquip->GetSizeX() * dScaleX;
						if (!GlobalFunc::DocGetMeterUnitDraw())//图纸是毫米单位
							dPoolLen = dPoolLen / 1000.0;
						ads_polar(ptStart, m_nLayoutRotation, dPoolLen * 0.5, ptPreWellRight);
					}
					OPENOBJ_END();
				}
				DrawLine(ptPreWellRight, ptWellLeft, dc);//绘制地面线
			 // cet 2016.12.7 modify 使用管道首端井的宽度 
			 // ads_polar(ptStart, m_nLayoutRotation, nWellDia / 2, ptWellLeft);
				ads_polar(ptStart, m_nLayoutRotation, i < nSize - 2 ? fabs(m_lstWell[i + 2].m_nWellRadius * dScaleX * 0.002) / 2 : nWellDia / 2, ptWellLeft);
				// cet 2016.5.10 add 管道首端连着化粪池
				if (i <= m_lstWell.Length() - 3 && m_lstWell[i + 2].m_csName == _T("HC"))
				{
					OPENOBJ_BEGIN(m_lstWell[i + 2].m_ID, AcDb::kForRead, CDbPool, pEquip);
					if (pEquip != NULL)
					{
						double dPoolLen = pEquip->GetSizeX() * dScaleX;
						if (!GlobalFunc::DocGetMeterUnitDraw())//图纸是毫米单位
							dPoolLen = dPoolLen / 1000.0;
						ads_polar(ptStart, m_nLayoutRotation, dPoolLen * 0.5, ptWellLeft);
					}
					OPENOBJ_END();
				}
				ads_polar(ptEnd, m_nLayoutRotation + PI, nWellDia / 2, ptWellRight);
				// cet 2016.5.10 add 管道尾端连着化粪池
				if (m_lstWell[i].m_csName == _T("HC"))
				{
					OPENOBJ_BEGIN(m_lstWell[i].m_ID, AcDb::kForRead, CDbPool, pEquip);
					if (pEquip != NULL)
					{
						double dPoolLen = pEquip->GetSizeX() * dScaleX;
						if (!GlobalFunc::DocGetMeterUnitDraw())//图纸是毫米单位
							dPoolLen = dPoolLen / 1000.0;
						ads_polar(ptEnd, m_nLayoutRotation + PI, dPoolLen * 0.5, ptWellRight);
					}
					OPENOBJ_END();
				}
				ads_polar(ptWellLeft, m_nLayoutRotation - PI / 2, 3 * GetPScale(), ptHatchLeft);
				ads_polar(ptWellRight, m_nLayoutRotation - PI / 2, 3 * GetPScale(), ptHatchRight);
				XPoly2D poly2d;
				poly2d.AppendNode(ptWellLeft);
				poly2d.AppendNode(ptHatchLeft);
				poly2d.AppendNode(ptHatchRight);
				poly2d.AppendNode(ptWellRight);
				//					cet 2018.2.8 modify 填充
				// 					if(!!objectId())
				// 						dc.DrawHatch(poly2d, _T("AR-HBONE"), 0.5*GetPScale());//动态拖动速度极慢
				DrawHatch(dc, poly2d);

				ptStart = ptEnd;
				ptStartG = ptEndG;
			}

			double dPoolEleUp(0), dPoolEleDown(0);
			if (bPool) {
				OPENOBJ_BEGIN(m_lstWell[i].m_ID, AcDb::kForRead, CDbPool, pEquip);
				if (pEquip) {
					double dPoolLen = pEquip->GetSizeX();
					if (dPoolLen > 100.0)//图纸是毫米单位
						dPoolLen = dPoolLen / 1000.0;
					nWellDia = dPoolLen * dScaleX;//化粪池的长度
					dPoolEleUp = pEquip->GetTopBanEle();
					dPoolEleDown = pEquip->GetBottomBanEle();
				}
				OPENOBJ_END();

				//如果化粪池有顶板，底板标高，则绘制化粪池矩形示意图
				if (fabs(dPoolEleUp) > 0.01 && fabs(dPoolEleDown) > 0.01) {
					XPoint ptPool1, ptPool2, ptPool3, ptPool4;
					ads_polar(ptEnd, m_nLayoutRotation + PI, nWellDia / 2, ptPool1);
					ads_polar(ptEnd, m_nLayoutRotation, nWellDia / 2, ptPool2);

					double dPoolDeepDown = m_lstWell[i].m_nUpEle - dPoolEleDown;
					ads_polar(ptPool1, m_nLayoutRotation - PI / 2, dPoolDeepDown * dScaleY, ptPool3);
					ads_polar(ptPool2, m_nLayoutRotation - PI / 2, dPoolDeepDown * dScaleY, ptPool4);
					DrawLine(ptPool3, ptPool4, dc);

					double dPoolDeepUp = m_lstWell[i].m_nUpEle - dPoolEleUp;
					ads_polar(ptPool1, m_nLayoutRotation - PI / 2, dPoolDeepUp * dScaleY, ptPool1);
					ads_polar(ptPool2, m_nLayoutRotation - PI / 2, dPoolDeepUp * dScaleY, ptPool2);
					DrawLine(ptPool1, ptPool2, dc);

					DrawLine(ptPool1, ptPool3, dc);
					DrawLine(ptPool2, ptPool4, dc);
				}

			}


			// 还原当前井面的左右坐标
			ads_polar(ptStart, m_nLayoutRotation + PI, nWellDia / 2, ptWellLeft);
			ads_polar(ptStart, m_nLayoutRotation, nWellDia / 2, ptWellRight);

			if (m_iCalcMode == 100)							// 计算模式
				dDeepLeft = dDeep - iDn;
			else if (m_iCalcMode == 101)						// 管顶平接
				dDeepLeft = dDeep - iDn2;
			else if (m_iCalcMode == 102)						// 管底平接
				dDeepLeft = dDeep - iDn2 - (iDn - iDn2) / 2;
			else if (m_iCalcMode == 3)						// 给水系统
				break;

			XPoint ptUpLeft2;
			if (i != m_lstWell.Length() - 1 && (m_lstWell[i].m_bIsDropWell || bPool))
			{ //给水系统没有跌水井
				double dDropDeep = m_lstWell[i].m_nUpEle - m_lstWell[i].m_nFrondDownEle;
				ads_polar(ptWellLeft, m_nLayoutRotation - PI / 2, m_lstWell[i].m_nDeep * dScaleY - iDn, ptWellDownLeft);
				ads_polar(ptWellRight, m_nLayoutRotation - PI / 2, m_lstWell[i].m_nDeep * dScaleY - iDn, ptWellDownRight);
			}
			else {
				ads_polar(ptWellLeft, m_nLayoutRotation - PI / 2, dDeepLeft, ptWellDownLeft);
				ads_polar(ptWellRight, m_nLayoutRotation - PI / 2, dDeepLeft, ptWellDownRight);
				if (m_iCalcMode == 100)
				{
					ads_polar(ptWellDownLeft, m_nLayoutRotation - PI / 2, iDn, ptTmp);
					ads_polar(ptWellDownLeft, m_nLayoutRotation - PI / 2, iDn2, ptUpLeft2);
					ads_polar(ptWellDownRight, m_nLayoutRotation - PI / 2, iDn, ptWellDis1);
					ads_polar(ptWellDownRight, m_nLayoutRotation - PI / 2, iDn2, ptWellDis2);
				}
				else if (m_iCalcMode == 101)
				{
					ads_polar(ptWellDownLeft, m_nLayoutRotation - PI / 2, iDn2, ptTmp);
					ads_polar(ptWellDownRight, m_nLayoutRotation - PI / 2, iDn2, ptWellDis1);
					ptWellDis1 = ptWellDis2;
					ads_polar(ptWellLeft, m_nLayoutRotation - PI / 2, dDeep - iDn, ptWellDownLeft);
				}
				else if (m_iCalcMode == 102)
				{
					ads_polar(ptWellDownLeft, m_nLayoutRotation - PI / 2, iDn2 + (iDn - iDn2) / 2, ptTmp);
					ads_polar(ptWellDownRight, m_nLayoutRotation - PI / 2, iDn2 + (iDn - iDn2) / 2, ptWellDis1);
					ads_polar(ptWellDownRight, m_nLayoutRotation - PI / 2, iDn2, ptWellDis2);
					ads_polar(ptWellLeft, m_nLayoutRotation - PI / 2, dDeep - iDn, ptWellDownLeft);
				}

			}

			if (!ptWellDis2)
				ptWellDis2 = ptWellDis1;

			if (m_lstWell[i].m_csName != _T("HC"))		//如果是节点或者就不画井了
			{
				//井左边线
				if (i == m_lstWell.Length() - 1)
				{
					DrawPLine(ptWellLeft, ptTmp, dc, 0.3 * GetPScale());
				}
				else
				{
					DrawPLine(ptWellLeft, ptWellDownLeft, dc, 0.3 * GetPScale());
				}
			}


			/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
			//                          绘制表示本井其它管标高的管，用椭圆表示
			OPENOBJ_BEGIN(m_lstWell[i].m_ID, AcDb::kForRead, CDbEquipment, pEquip);
			if (pEquip)
			{
				int num = pEquip->GetInterfaceNum();
				if (num > 1) // cet 2016.9.6 modify 未考虑起始端井连接的管道
				{
					for (int j = 0; j < num; j++)
					{
						CPipeInterface face;
						pEquip->GetInterface(j, face);
						if (i > 0 && face.m_idPipe == m_lstWell[i - 1].m_ID)
							continue;
						if (i < m_lstWell.Length() - 1 && face.m_idPipe == m_lstWell[i + 1].m_ID)
							continue;
						double nPipeDownEle = 0.0;
						double dOuterDn = 0.0, dPipeThick = 0.0;
						double nThirdDn(0);
						AcDbObjectId idLay = NULL;
						bool bBranch = true; // cet 2016.9.8 add 是否为支路
						OPENOBJ_BEGIN(face.m_idPipe, AcDb::kForRead, CDbPipe, pPipe);
						if (pPipe)
						{
							// cet 2011.12.5 add 判断交叉管是否需要显示
							if (!IsShowCrossPipe(pPipe->objectId()))
							{
								continue;
							}
							idLay = pPipe->layerId();
							nThirdDn = (pPipe->OuterDn() - pPipe->GetPipeThick() * 2) * dScaleY / 1000;
							// cet 2016.7.6 add 计算管内底标高, 内径
							double dDn = (pPipe->OuterDn() - pPipe->GetPipeThick() * 2) / 2000;
							if (pPipe->StartPoint().Distance2d(face.m_ptLocation) < 0.001)
							{
								nPipeDownEle = pPipe->StartPoint().z / dUnitMeter - dDn;
							}
							else
							{
								nPipeDownEle = pPipe->EndPoint().z / dUnitMeter - dDn;
							}
							dOuterDn = pPipe->OuterDn();
							dPipeThick = pPipe->GetPipeThick();
							bBranch = IsBrach(pPipe, m_lstWell[i].m_ID); // cet 2016.9.8 add 是否为支路
						}
						OPENOBJ_END();
						//						cet 2016.7.6 del 直接获取管底标高                                                 
						//                      CString csPipeDownEle = pEquip->GetISysLabel(j);
						//                      if(csPipeDownEle == _T(""))
						//                          continue;
						//                      double nPipeDownEle = _tstof(csPipeDownEle);
						//						cet 2016.9.8 modify 细化显示控制
						//                      if(fabs(nPipeDownEle - m_lstWell[i].m_nDownEle) > 0.001) // cet 2016.9.6 modify 不绘制管内底标高与井底标高一致的管道
						if ((IsOnlyShowBranch() && bBranch || !IsOnlyShowBranch()) &&   // 控制是否只显示支路
							((fabs(nPipeDownEle - m_lstWell[i].m_nDownEle) > 0.001) && !IsShowEqualEleBranch() || IsShowEqualEleBranch())) // 是否只显示等高支路
						{
							XPoint ptEllipse;
							double nThirdPipeDeep = m_lstWell[i].m_nUpEle - nPipeDownEle;
							ads_polar(ptStart, m_nLayoutRotation - PI / 2, nThirdPipeDeep * dScaleY - nThirdDn / 2, ptEllipse);
							bool bRet = false;
							DrawEllipse(ptEllipse, (dOuterDn - dPipeThick * 2) * dScaleY * 0.0005, (dOuterDn - dPipeThick * 2) * dScaleX * 0.0005, idLay, dc, &bRet);
							// cet 2011.6.2 add 标注碰撞管内底标高
							if (bRet && IsDimEle())
							{
								CString s;
								DimEle(ptEllipse, (dOuterDn - dPipeThick * 2) * dScaleY * 0.0005, (dOuterDn - dPipeThick * 2) * dScaleX * 0.0005, nPipeDownEle, s, true, dc);
							}
						}
					}
				}
			}
			OPENOBJ_END();
			/////////////////////////////////////////////////////////////////////////////////////////////////////////////////


			XPoint ptBottomRight, ptUpRight, ptBottomLeft(ptTmp);
			ads_polar(ptWellRight, m_nLayoutRotation - PI / 2, dDeep, ptBottomRight);
			if (i == 0)
				ptUpRight = ptBottomRight;        //最后一个井
			else
			{
				if (i != m_lstWell.Length() - 1 && (m_lstWell[i].m_bIsDropWell || bPool)) // 判断粪池
				{
					double dDropDeep = m_lstWell[i].m_nUpEle - m_lstWell[i].m_nFrondDownEle;
					ads_polar(ptWellRight, m_nLayoutRotation - PI / 2, dDropDeep * dScaleY - iDn, ptUpRight);
				}
				else
				{
					ads_polar(ptWellRight, m_nLayoutRotation - PI / 2, dDeepLeft, ptUpRight);
				}
			}


			if (m_lstWell[i].m_csName != _T("HC"))
			{
				if (m_lstWell[i].m_bIsDropWell)
				{
					if (i > 0)
					{
						// 跌水井的右边线
						XPoint ptTmp1;
						double dDropDeep = m_lstWell[i].m_nUpEle - m_lstWell[i].m_nFrondDownEle;
						ads_polar(ptWellRight, m_nLayoutRotation - PI / 2, dDropDeep * dScaleY - iDn2, ptUpRight);
						DrawPLine(ptWellRight, ptUpRight, dc, 0.3 * GetPScale());
						ads_polar(ptUpRight, m_nLayoutRotation - PI / 2, iDn2, ptBottomRight);
						ads_polar(ptWellRight, m_nLayoutRotation - PI / 2, m_lstWell[i].m_nDeep * dScaleY, ptTmp1);
						DrawPLine(ptBottomRight, ptTmp1, dc, 0.3 * GetPScale());
					}
					else
					{
						DrawPLine(ptWellRight, ptUpRight, dc, 0.3 * GetPScale());             //井右边线
					}
				}
				else
				{
					DrawPLine(ptWellRight, ptUpRight, dc, 0.3 * GetPScale());             //井右边线
					if (ptWellDis1 != ptWellDis2)//管径不一样
						DrawPLine(ptWellDis1, ptWellDis2, dc, 0.3 * GetPScale());
				}
				if (m_lstWell[i].m_nSpare > 0)				//绘制沉沙井
				{
					double dDeepSand = m_lstWell[i].m_nSpare / 1000 * dScaleY;
					XPoint ptSandRight, ptSandLeft;
					ads_polar(ptWellLeft, m_nLayoutRotation - PI / 2, m_lstWell[i].m_nDeep * dScaleY, ptBottomRight);
					ads_polar(ptWellRight, m_nLayoutRotation - PI / 2, m_lstWell[i].m_nDeep * dScaleY, ptBottomLeft);
					ads_polar(ptBottomRight, m_nLayoutRotation + PI / 2 * 3, dDeepSand, ptSandRight);
					ads_polar(ptBottomLeft, m_nLayoutRotation + PI / 2 * 3, dDeepSand, ptSandLeft);
					DrawPLine(ptSandRight, ptSandLeft, dc, 0.35 * GetPScale());   //井底边线
					DrawPLine(ptBottomRight, ptSandRight, dc, 0.35 * GetPScale());//沉沙边线
					DrawPLine(ptBottomLeft, ptSandLeft, dc, 0.35 * GetPScale());  //跌水井左下边线
				}
				else
				{
					double dDropDeep2 = m_lstWell[i].m_nFrondDownEle - m_lstWell[i].m_nDownEle;
					if (dDropDeep2 < 0)
					{   //虹吸井，往上跌水
						XPoint ptBottomRight2;
						ads_polar(ptBottomLeft, m_nLayoutRotation, nWellDia, ptBottomRight2);
						DrawPLine(ptBottomRight2, ptBottomLeft, dc, 0.35 * GetPScale());//井底边线
						DrawPLine(ptBottomRight2, ptBottomRight, dc, 0.35 * GetPScale());//井底边线
					}
					else
					{
						// 跌水井的底线
						ads_polar(ptWellLeft, m_nLayoutRotation - PI / 2, m_lstWell[i].m_nDeep * dScaleY, ptBottomRight);
						ads_polar(ptWellRight, m_nLayoutRotation - PI / 2, m_lstWell[i].m_nDeep * dScaleY, ptBottomLeft);
						DrawPLine(ptBottomRight, ptBottomLeft, dc, 0.35 * GetPScale());//井底边线
					}
				}
			}

			if (dPipeLen > 0)
			{
				DrawPLine(ptPreWellBtmUpRight, ptWellDownLeft, dc, 0.35 * GetPScale());              //横管上线
				ads_polar(ptPreWellBtmUpRight, m_nLayoutRotation - PI / 2, iDn, ptPreWellBtmDownRight);
				ads_polar(ptWellDownLeft, m_nLayoutRotation - PI / 2, iDn, ptTmp);
				DrawPLine(ptPreWellBtmDownRight, ptTmp, dc, 0.35 * GetPScale());        //横管下线
			}

			// 临时记录当前井的右上管线的值
			ptPreWellBtmUpRight = ptUpRight;                      // PT7井管顶右边点

			//前断管
			if (dPipeLen < 0.001 && i != m_lstWell.Length() - 1)
			{
				double nI = m_lstWell[i - 1].m_nI;
				dPipeLen = 10 * GetPScale();
				double nLow = nI * dPipeLen / 2;
				XPoint ptTmp1, ptTmp2;
				ads_polar(ptWellDownLeft, m_nLayoutRotation + PI, dPipeLen / 2, ptTmp);
				ads_polar(ptTmp, m_nLayoutRotation + PI / 2, nLow, ptTmp);
				DrawPLine(ptWellDownLeft, ptTmp, dc, 0.35 * GetPScale());      //井底边线
				ads_polar(ptWellDownLeft, m_nLayoutRotation - PI / 2, iDn, ptWellDownLeft);
				ads_polar(ptWellDownLeft, m_nLayoutRotation + PI, dPipeLen / 2, ptTmp1);
				ads_polar(ptTmp1, m_nLayoutRotation + PI / 2, nLow, ptTmp1);
				DrawPLine(ptWellDownLeft, ptTmp1, dc, 0.35 * GetPScale());//井底边线                

				DrawBreakPipe(ptTmp, ptTmp1, dc);
				// cet 2016.5.10 add 左端断管
				int nCount = m_lstWell.Length();
				if (i == m_lstWell.Length() - 3)
				{
					XPoint pt1, pt2, pt3, pt4;
					double nWellDia = fabs(m_lstWell[i].m_nWellRadius * dScaleX * 0.002);
					ads_polar(ptStart, m_nLayoutRotation, -nWellDia / 2, pt1);
					//  管道尾端连着化粪池
					if (m_lstWell[i].m_csName == _T("HC"))
					{
						OPENOBJ_BEGIN(m_lstWell[i].m_ID, AcDb::kForRead, CDbPool, pEquip);
						if (pEquip != NULL)
						{
							double dPoolLen = pEquip->GetSizeX() * GetPScale() / 100;
							ads_polar(ptStart, m_nLayoutRotation, -dPoolLen * 0.5, pt1);
						}
						OPENOBJ_END();
					}
					ads_polar(pt1, m_nLayoutRotation, -dPipeLen / 2, pt2);
					ads_polar(pt1, m_nLayoutRotation - PI / 2, 3 * GetPScale(), pt3);
					ads_polar(pt2, m_nLayoutRotation - PI / 2, 3 * GetPScale(), pt4);
					XPoly2D poly2d;
					poly2d.AppendNode(pt1);
					poly2d.AppendNode(pt3);
					poly2d.AppendNode(pt4);
					poly2d.AppendNode(pt2);
					//					cet 2018.2.8 modify 填充
					// 					if(!!objectId())
					// 						dc.DrawHatch(poly2d, _T("AR-HBONE"), 0.5*GetPScale());//动态拖动速度极慢
					DrawHatch(dc, poly2d);
				}
			}
			dPipeLen = 0;
		}
		else if (!m_lstWell[i].m_bIsWell) { //管
//			double dLenPipe = m_lstWell[i].m_nLength;
//			if(dLenPipe > 1000)// 7.0 管长用mm
//				dLenPipe = dLenPipe/1000.0;
			dPipeLen = m_lstWell[i].m_nLength * dScaleX;
			if (m_lstWell[i].m_dRealLength > 0.1)
				dPipeLen = m_lstWell[i].m_dRealLength * dScaleX; //实际管长
			// cet 2016.5.10 add 右侧末尾连接断管
			if (i == 1 && m_lstWell[0].m_csName == _T("断管") && m_lstWell.Length() > 3)
			{
				dPipeLen = m_lstWell[i].m_nLength * dScaleX;
			}
			if (m_lstWell[i + 1].m_csName == _T("断管"))
				dPipeLen = 0;
			////////////////////////////////////////////////////////////////////////////////////////////////////
			//2006－10－20  SB 加入考虑其它交叉管线
			AcDbObjectId idPipe = m_lstWell[i].m_ID;
			OPENOBJ_BEGIN(idPipe, AcDb::kForRead, CDbPipe, pPipe);
			if (pPipe != NULL && m_lstWell[i + 1].m_csName != _T("断管"))
			{
				//-------------------------------------------------------------------------------------------
				// ZXL 2013.12.06 ADD 管线交叉在此处处理（包括标高高于自身的管线的处理）
				DList<AcDbObjectId> lstCrossPipes;
				CrossPoint cr(pPipe->objectId());
				GetCrossInfo(vecCrossPoint, cr);
				cr.GetAllCrossPipes(lstCrossPipes);
				int nPipeNum = lstCrossPipes.Length();

				XPoint ptEllipse, ptInt;
				int nIndex = 0;
				for (int j = 0; j < nPipeNum; j++) {
					AcDbObjectId idOther = *lstCrossPipes[j];
					OPENOBJ_BEGIN(idOther, AcDb::kForRead, CDbPipe, pPipe2);
					if (pPipe2) {
						// cet 2011.12.5 add 判断交叉管是否需要显示
						if (!IsShowCrossPipe(pPipe2->objectId()))
						{
							continue;
						}
						double dDn = pPipe2->OuterDn() - pPipe2->GetPipeThick() * 2;
						double dI = pPipe2->GetPipeGradient();
						double dPipeStartEle(0);
						dDn = dDn / 2000;
						if (pPipe2->GetFlowDir() == TPipeSys::kFromStart)
							dPipeStartEle = pPipe2->StartPoint().z / dUnitMeter - dDn;
						else
							dPipeStartEle = pPipe2->EndPoint().z / dUnitMeter - dDn;
						double nDist2Well1(0), nDist2Well2(0);
						cr.GetCrossInfo(idOther, ptInt, nDist2Well1, nDist2Well2);
						if (fabs(nDist2Well1) > 0.001 && fabs(nDist2Well2) > 0.001 || IsShowPipeEndNotLinkedPipe() && (fabs(nDist2Well1) > 0.001 || fabs(nDist2Well2) > 0.001))
						{
							AcDbObjectId idLay = pPipe2->layerId();
							//	int iDnTmp = int(dDn*dScaleY);
							double dDnTmp = dDn * dScaleY;
							double nPipeIntEle = dPipeStartEle - nDist2Well2 * dI; //根据相交管线起点标高计算交点标高
							double nThirdPipeDeep = m_lstWell[i - 1].m_nUpEle - nPipeIntEle;//转换为埋深
							ads_polar(ptStart, m_nLayoutRotation - PI / 2, nThirdPipeDeep * dScaleY - dDnTmp, ptEllipse);
							double dLen = pPipe->GetLength();
							ads_polar(ptEllipse, m_nLayoutRotation, (dLen / dUnitMeter - nDist2Well1) * dScaleX, ptEllipse);
							double dOuterDn = pPipe2->OuterDn();
							double dPipeThick = pPipe2->GetPipeThick();
							bool bRet = false;
							DrawEllipse(ptEllipse, (dOuterDn - dPipeThick * 2) * dScaleY * 0.0005, (dOuterDn - dPipeThick * 2) * dScaleX * 0.0005, idLay, dc, &bRet);
							// cet 2011.6.3 add 标注碰撞管内底标高
							if (bRet && IsDimEle())
							{
								CString sPipeName = pPipe2->GetPipeSystemName();
								sPipeName += _T("管");
								CString sLabel = pPipe2->GetLabel();
								sPipeName += sLabel;
								sLabel.Format(_T("%.f"), pPipe2->GetDnDiameter());
								sPipeName += sLabel;
								DimEle(ptEllipse, (dOuterDn - dPipeThick * 2) * dScaleY * 0.0005, (dOuterDn - dPipeThick * 2) * dScaleX * 0.0005, nPipeIntEle, sPipeName, false, dc);
							}

							// zxl 2013.12.06 add
							if (bRet && IsDimDist())
							{
								XPoint pt;
								ads_polar(ptStart, m_nLayoutRotation, dLen / dUnitMeter * dScaleX, pt);
								CString sDim;
								sDim.Format(_T("%.2f"), nDist2Well1 * dUnitMeter);
								if (dUnitMeter > 1.0)
								{
									sDim.Format(_T("%.f"), nDist2Well1 * dUnitMeter);
								}
								DimDist(sDim, pt, ptEllipse, dc, nIndex, nThirdPipeDeep, dOuterDn * dScaleY * 0.0005, true);
							}
						}

					}
					OPENOBJ_END();
				}
			}
			OPENOBJ_END();
		}
	}

	return Acad::eOk;
}

//绘制给水的支管， 要求必须是TDbPipeFitting，且连接水管在2根以上
//往AcDbObjectIdArray中添加一个对象， 如何已经存在就不添加
BOOL CDbVerticalSection::AppendIdArray(AcDbObjectIdArray &idArray, AcDbObjectId id) const
{
	BOOL bFlag = FALSE;
	//OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPipeFitting, pNode);
	//if (pNode) {
	//	if (pNode->GetInterfaceNum() > 2)
	//		bFlag = TRUE;
	//}
	//OPENOBJ_END();
	//if (!bFlag)
	//	return FALSE;

	int len = idArray.length();
	for (int i = 0; i < len; i++) {
		AcDbObjectId idTmp = idArray[i];
		if (idTmp == id)
			return FALSE;
	}
	idArray.append(id);
	return TRUE;
}

Acad::ErrorStatus CDbVerticalSection::DrawCivilSheet(AcGiDraw &dc, XPoint ptEnd) const
{
	double nSheetHeight = m_dTextHeight + 3;
	XStringList lstHead;
	int idx2(1);
	double nWellNameRow(0), nStakeRow(0), nWellRaiusRow(0), nDeepRow(0), nGroundEleRow(0), nUpEleRow(0), nThicknessRow(0), nDownEleRow(0), nTmpHeight(0);
	while (1) {
		TCHAR sBuf[256] = _T("");
		GlobalFunc::GetStringAtIndex(m_sSheetHead, idx2, sBuf);
		if (_tcsicmp(sBuf, _T("")) == 0)
			break;
		lstHead.Append(tstrnew(sBuf));
		idx2++;
		if (_tcsicmp(sBuf, _T("井编号")) == 0) {
			nWellNameRow = nTmpHeight;
			nTmpHeight += nSheetHeight;
		}
		else if (_tcsicmp(sBuf, _T("桩号")) == 0) {
			nStakeRow = nTmpHeight;
			nTmpHeight += nSheetHeight;
		}
		else if (_tcsicmp(sBuf, _T("井径（mm）")) == 0) {
			nWellRaiusRow = nTmpHeight;
			nTmpHeight += nSheetHeight;
		}
		else if (_tcsicmp(sBuf, _T("设计地面标高（m）")) == 0) {
			nUpEleRow = nTmpHeight;
			nTmpHeight += nSheetHeight * 2.5;
		}
		else if (_tcsicmp(sBuf, _T("自然地面标高（m）")) == 0) {
			nGroundEleRow = nTmpHeight;
			nTmpHeight += nSheetHeight * 2.5;
		}
		else if (_tcsicmp(sBuf, _T("埋设深度（m）")) == 0) {
			nDeepRow = nTmpHeight;
			nTmpHeight += nSheetHeight * 2;
		}
		else if (_tcsicmp(sBuf, _T("覆土厚度（m）")) == 0) {
			nThicknessRow = nTmpHeight;
			nTmpHeight += nSheetHeight * 2;
		}
		else if (_tcsicmp(sBuf, _T("管标高（m）")) == 0) {
			nDownEleRow = nTmpHeight;
			nTmpHeight += nSheetHeight * 2.5;
		}
		else
			nTmpHeight += nSheetHeight;
	}
	int iDemoRow = lstHead.Index(_T("备注"));
	int iPipeLenRow = lstHead.Index(_T("管道长度（m）"));
	int iGradientRow = lstHead.Index(_T("管道坡度"));
	int iDnRow = lstHead.Index(_T("管径（mm）"));
	int iWellNameRow = lstHead.Index(_T("井编号"));
	int iUpEleRow = lstHead.Index(_T("设计地面标高（m）"));
	int iDeepRow = lstHead.Index(_T("埋设深度（m）"));
	int iThicknessRow = lstHead.Index(_T("覆土厚度（m）"));
	int iGroundEleRow = lstHead.Index(_T("自然地面标高（m）"));
	int iWellRadiusRow = lstHead.Index(_T("井径（mm）"));
	int iDownEleRow = lstHead.Index(_T("管标高（m）"));
	int iPipePlanRow = lstHead.Index(_T("管线平面"));
	int iStakeRow = lstHead.Index(_T("桩号"));

	BOOL bBreak1 = FALSE;
	BOOL bBreak2 = FALSE;
	if (m_iCalcMode < 100)				// 原来代码 按选择井的顺序画
	{
		if (m_lstWell[0].m_csName == _T("断管"))
			bBreak1 = TRUE;
		if (m_lstWell[m_lstWell.Length() - 1].m_csName == _T("断管"))
			bBreak2 = TRUE;
	}
	else								// add by 王辉 按选择井的反顺序画 08-05-05
	{
		if (m_lstWell[0].m_csName == _T("断管"))
			bBreak2 = TRUE;
		if (m_lstWell[m_lstWell.Length() - 1].m_csName == _T("断管"))
			bBreak1 = TRUE;
	}

	double dScaleY = m_iScaleY;
	double dScaleX = m_iScaleX;
	dScaleX = GetPScale() / dScaleX * 1000;
	dScaleY = GetPScale() / dScaleY * 1000;//转化为毫米

	XPoint ptCivilIns = ptEnd;
	XPoint ptIns = ptCivilIns;
	ads_polar(ptCivilIns, m_nLayoutRotation + PI, 45 * GetPScale(), ptCivilIns);

	//绘制表格
	AcDbObjectId idTextStyle = m_idTextStyle;
	CDbSheet pSheet;
	//	cet 2018.2.7 modify 表格图层与网格一致
	//	pSheet.setLayer(this->layerId());
	pSheet.setLayer(this->GetGridLayer());
	pSheet.SetPScale(GetPScale());
	pSheet.SetRotation(m_nLayoutRotation);
	GridStyle gridStyle;
	gridStyle.SetOverrideAll(TRUE);
	gridStyle.SetTextHeight(m_dTextHeight);
	gridStyle.SetTextStyleId(idTextStyle);

	SheetTitle &title = pSheet.GetTitle();
	title.SetHeight(nSheetHeight);
	title.SetVisible(FALSE);

	gridStyle.SetHorMode(AcDb::kTextCenter);
	gridStyle.SetVerMode(AcDb::kTextVertMid);
	gridStyle.SetLineSpaceFactor(0.2);
	gridStyle.SetTextWrap(FALSE);
	pSheet.SetGridStyle(gridStyle);
	pSheet.SetRowHeight(m_dTextHeight + 2);
	if (bBreak2 || bBreak1)
		pSheet.InitSheet(lstHead.Length(), bBreak1 && bBreak2 ? m_lstWell.Length() / 2 + 1 : m_lstWell.Length() / 2 + 2, nSheetHeight, 50); // cet 2016.5.9 modify 没有考虑两端同时存在断管的情况
	else
		pSheet.InitSheet(lstHead.Length(), m_lstWell.Length() / 2 + 3, nSheetHeight, 50);

	SheetColumn column;
	column.SetWidth(25);   //表头
	pSheet.SetColumnAt(0, column);

	SheetColumn column2;
	if (!bBreak2 && !bBreak1) {
		column2.SetWidth(5);   //表尾
		pSheet.SetColumnAt(m_lstWell.Length() / 2 + 2, column2);
	}
	if (bBreak1) {
		column2.SetWidth(5);   //表尾
		pSheet.SetColumnAt(bBreak2 ? m_lstWell.Length() / 2 : m_lstWell.Length() / 2 + 1, column2); // cet 2016.5.9 modify 未考虑两端同为断管的情况
	}
	double nWidth = 20 * GetPScale();

	XPoint ptCellS, ptCellE, ptText, ptWell;

	ptCellS = ptIns;
	double dPipeLen(0);
	int idx = 1;
	int iDn(0);
	int nGsMarker = 1;
	pSheet.SetLocation(ptCivilIns);

	if (m_iCalcMode < 100)				// 原来代码 按选择井的顺序画
	{
		for (int i = 0; i < m_lstWell.Length(); i++)
		{

			AcDbObjectId id = m_lstWell[i].m_ID;
			if (m_lstWell[i].m_bIsWell) {     //井
				if (m_lstWell[i].m_csName == _T("断管") && dPipeLen > 0) {
					SheetColumn column3;
					column3.SetWidth(dPipeLen / GetPScale());   //表尾
					pSheet.SetColumnAt(pSheet.GetColumnNum() - 1, column3); // cet 2016.5.9 modify 未考虑两端同为断管的情况
					continue;
				}
				if (m_lstWell[i].m_csName == _T("断管") && dPipeLen < 0.001) {
					continue;
				}

				double nEle = m_lstWell[i].m_nUpEle;
				double nDeep = m_lstWell[i].m_nDeep;
				double nDownEle = m_lstWell[i].m_nDownEle;
				double nGroundDeep = m_lstWell[i].m_nDeep;
				double nFrondEle = m_lstWell[i].m_nFrondDownEle;
				double nGroundEle = m_lstWell[i].m_nGroundEle;
				double dWellRadius = m_lstWell[i].m_nWellRadius;
				//				cet 2016.5.12 modify 覆土厚度=埋设深度-管内径-壁厚
				// 				//先试试外径 2009-6.9 sr
				// 				double dOutDn(0), dDn(0);
				// 				if(i == m_lstWell.Length() - 1)
				// 				{
				// 					dOutDn = (double)m_lstWell[i-1].m_iSpare / 1000;
				// 					dDn = (double)m_lstWell[i-1].m_iDn / 1000;
				// 				}
				// 				else
				// 				{
				// 					dOutDn = (double)m_lstWell[i+1].m_iSpare / 1000;
				// 					dDn = (double)m_lstWell[i+1].m_iDn / 1000;
				// 				}
				// 
				// 				if(dOutDn < 0.0001)
				// 					nGroundDeep -= dDn; //不带外径
				// 				else
				// 				{
				// 				 // cet 2016.5.11 modify 覆土厚度=埋设深度-管外径的一半
				// 				 // nGroundDeep -= (dDn + (dOutDn-dDn) / 2);//带外径
				// 					nGroundDeep -= dOutDn / 2.0;
				// 				}
				double dOuterDn = 0.0, dThick = 0.0;
				int nIndex = (i == m_lstWell.Length() - 1) ? i - 1 : i + 1;
				dOuterDn = m_lstWell[nIndex].m_iDn;
				OPENOBJ_BEGIN(m_lstWell[nIndex].m_ID, AcDb::kForRead, CDbPipe, pPipe);
				if (pPipe != NULL)
				{
					if (pPipe->OuterDn() > 0.001)
					{
						dOuterDn = pPipe->OuterDn();
					}
					dThick = pPipe->GetPipeThick();
				}
				OPENOBJ_END();
				dOuterDn *= 0.001;
				dThick *= 0.001;
				nGroundDeep = nDeep - (dOuterDn - dThick * 2) - dThick;

				CString csWellUpEle, csDeep, csDownEle, csGroundDeep, csFrontEle, csGroundEle, csWellRaius;
				CString csWellName = m_lstWell[i].m_csName;

				csWellRaius.Format(_T("%%%%c%.0f"), dWellRadius * 2.0);
				if (dWellRadius < 0)
					csWellRaius = _T("矩形井");

				int iPre = GetWellDeepPrecision();
				CString sHead, sFormat;
				sHead.Format(_T("%d"), iPre);
				sFormat = _T("%.") + sHead + _T("f");
				csDeep.Format(sFormat, nDeep);
				csGroundEle.Format(sFormat, nGroundEle);
				csDownEle.Format(sFormat, nDownEle);
				csWellUpEle.Format(sFormat, nEle);
				csGroundDeep.Format(sFormat, nGroundDeep);
				csFrontEle.Format(sFormat, nFrondEle);

				ads_polar(ptCellS, m_nLayoutRotation, dPipeLen, ptCellS);
				XPoint ptCellS2 = ptCellS;
				double dPoolLength(0);
				if (m_lstWell[i].m_csName == _T("HC"))
				{
					OPENOBJ_BEGIN(m_lstWell[i].m_ID, AcDb::kForRead, CDbPool, pEquip);
					if (pEquip) {
						dPoolLength = pEquip->GetPoolLength();
						if (!GlobalFunc::DocGetMeterUnitDraw())
							dPoolLength = dPoolLength / 1000;
						if (iDemoRow > -1 && i > 1 && m_lstWell[i].m_csName == _T("HC"))  //备注
						{
							GridCell &cell24 = *(pSheet)(iDemoRow, idx + 1);
							//  cet 2016.11.3 modify 池名称可能不是化粪池
							//	cell24.SetText(XString(_T("化粪池L=%.2f"), dPoolLength));
							CString sName = _T("化粪池"), sTemp;
							bool bRet = true;
							sTemp = pEquip->GetName(&bRet);
							if (bRet) // 池设置了名称
							{
								sName = sTemp;
							}
							cell24.SetText(XString(_T("%sL=%.2f"), sName, dPoolLength));
						}
						dPoolLength = dPoolLength * dScaleX;
					}
					OPENOBJ_END();
					ads_polar(ptCellS, m_nLayoutRotation, dPoolLength, ptCellS2);
				}

				if (iWellNameRow > -1) {//名称
//					cet 2013.3.1 modify 获得池子的真实名称
// 					if(m_lstWell[i].m_csName == _T("HC"))
// 						csWellName = _T("HC进");
					CString sName;
					if (m_lstWell[i].m_csName == _T("HC"))
					{
						sName = GetPoolName(m_lstWell[i].m_ID);
						csWellName = sName + _T("进");
					}

					ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nWellNameRow + nSheetHeight / 2) * GetPScale(), ptText);
					DrawText(ptText, csWellName, AcGiDraw::kMiddleCenter, dc);
					if (m_lstWell[i].m_csName == _T("HC"))
					{
						ads_polar(ptCellS2, m_nLayoutRotation - PI / 2, (nWellNameRow + nSheetHeight / 2) * GetPScale(), ptText);
						//  cet 2013.3.1 modify 获得池子的真实名称
						//	DrawText(ptText, _T("HC出"), AcGiDraw::kMiddleCenter, dc);
						DrawText(ptText, sName + _T("出"), AcGiDraw::kMiddleCenter, dc);
					}
				}
				if (iWellRadiusRow > -1) {
					ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nWellRaiusRow + nSheetHeight / 2) * GetPScale(), ptText);
					DrawText(ptText, csWellRaius, AcGiDraw::kMiddleCenter, dc);
				}

				if (iUpEleRow > -1) {//地面标高
					ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nUpEleRow + nSheetHeight / 3) * GetPScale(), ptText);
					DrawText(ptText, csWellUpEle, AcGiDraw::kMiddleRight, dc, PI / 2);
					if (m_lstWell[i].m_csName == _T("HC"))
					{
						ads_polar(ptCellS2, m_nLayoutRotation - PI / 2, (nUpEleRow + nSheetHeight / 3) * GetPScale(), ptText);
						DrawText(ptText, csWellUpEle, AcGiDraw::kMiddleRight, dc, PI / 2);
					}
				}
				if (iGroundEleRow > -1) {//自然地面标高
					ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nGroundEleRow + nSheetHeight / 3) * GetPScale(), ptText);
					DrawText(ptText, csGroundEle, AcGiDraw::kMiddleRight, dc, PI / 2);
					if (m_lstWell[i].m_csName == _T("HC"))
					{
						ads_polar(ptCellS2, m_nLayoutRotation - PI / 2, (nGroundEleRow + nSheetHeight / 3) * GetPScale(), ptText);
						DrawText(ptText, csGroundEle, AcGiDraw::kMiddleRight, dc, PI / 2);
					}
				}
				if (iStakeRow > -1) {//桩号
					AcDbObjectId id = m_lstWell[i].m_ID;
					ads_name entWell;
					acdbGetAdsName(entWell, id);
					CString csStake = GlobalFunc::ReadXdata(entWell, _T("TWT-STAKEVALUE"));

					ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nStakeRow + nSheetHeight / 2) * GetPScale(), ptText);
					DrawText(ptText, csStake, AcGiDraw::kMiddleCenter, dc);
				}
				if (iDeepRow > -1 && m_iCalcMode != 3) {//埋深
					if (!m_lstWell[i].m_bIsDropWell) {
						if (m_lstWell[i].m_csName == _T("HC"))
						{
							CString csDeep2;
							double nDeep2 = m_lstWell[i].m_nUpEle - m_lstWell[i].m_nFrondDownEle;
							csDeep2.Format(sFormat, fabs(nDeep2));
							ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nDeepRow + nSheetHeight / 3) * GetPScale(), ptText);
							DrawText(ptText, csDeep2, AcGiDraw::kMiddleRight, dc, PI / 2);
							ads_polar(ptCellS2, m_nLayoutRotation - PI / 2, (nDeepRow + nSheetHeight / 3) * GetPScale(), ptText);
							DrawText(ptText, csDeep, AcGiDraw::kMiddleRight, dc, PI / 2);
						}
						else
						{
							ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nDeepRow + nSheetHeight / 3) * GetPScale(), ptText);
							DrawText(ptText, csDeep, AcGiDraw::kMiddleRight, dc, PI / 2);
						}

					}
					else {
						ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nDeepRow + nSheetHeight / 3) * GetPScale(), ptText);
						XPoint ptTmpText = ptText;
						if (i != 0) {
							CString csDeep2;
							double nDeep2 = m_lstWell[i].m_nUpEle - m_lstWell[i].m_nFrondDownEle;
							csDeep2.Format(sFormat, fabs(nDeep2));
							ads_polar(ptText, m_nLayoutRotation + PI, GetPScale() * 2, ptTmpText);
							DrawText(ptTmpText, csDeep2, AcGiDraw::kMiddleRight, dc, PI / 2);
						}
						//	if(i != m_lstWell.Length() - 1){
						ads_polar(ptText, m_nLayoutRotation, GetPScale() * 2, ptTmpText);
						DrawText(ptTmpText, csDeep, AcGiDraw::kMiddleRight, dc, PI / 2);
						//	}
					}
				}
				if (iThicknessRow > -1 && m_iCalcMode != 3) {// 雨污 覆土厚度
					// cet 2016.5.12 add 获得外径和壁厚
					double dOuterDn = 0.0, dThick = 0.0;
					if (!m_lstWell[i].m_bIsDropWell && m_lstWell[i].m_csName == _T("HC") || i != 0)
					{
						dOuterDn = m_lstWell[i - 1].m_iDn;
						OPENOBJ_BEGIN(m_lstWell[i - 1].m_ID, AcDb::kForRead, CDbPipe, pPipe);
						if (pPipe != NULL)
						{
							if (pPipe->OuterDn() > 0.001)
							{
								dOuterDn = pPipe->OuterDn();
							}
							dThick = pPipe->GetPipeThick();
						}
						OPENOBJ_END();
					}
					if (!m_lstWell[i].m_bIsDropWell) {
						if (m_lstWell[i].m_csName == _T("HC"))
						{
							CString csDeep2;
							//  cet 2016.5.12 modify 应使用内径和壁厚计算
							//	double nDeep2 = m_lstWell[i].m_nUpEle - m_lstWell[i].m_nFrondDownEle-(double)m_lstWell[i-1].m_iDn/1000;
							double nDeep2 = m_lstWell[i].m_nUpEle - m_lstWell[i].m_nFrondDownEle - (dOuterDn - dThick * 2) * 0.001 - dThick * 0.001;
							csDeep2.Format(sFormat, fabs(nDeep2));
							ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nThicknessRow + nSheetHeight / 2) * GetPScale(), ptText);
							DrawText(ptText, csDeep2, AcGiDraw::kMiddleRight, dc, PI / 2);
							ads_polar(ptCellS2, m_nLayoutRotation - PI / 2, (nThicknessRow + nSheetHeight / 2) * GetPScale(), ptText);
							DrawText(ptText, csGroundDeep, AcGiDraw::kMiddleRight, dc, PI / 2);
						}
						else
						{
							ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nThicknessRow + nSheetHeight / 2) * GetPScale(), ptText);
							DrawText(ptText, csGroundDeep, AcGiDraw::kMiddleRight, dc, PI / 2);
						}
					}
					else {
						ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nThicknessRow + nSheetHeight / 3) * GetPScale(), ptText);
						XPoint ptTmpText = ptText;
						if (i != 0) {
							CString csDeep2;
							//  cet 2016.5.12 modify 应使用内径和壁厚计算
							//	double nDeep2 = m_lstWell[i].m_nUpEle - m_lstWell[i].m_nFrondDownEle-(double)m_lstWell[i-1].m_iDn/1000;
							double nDeep2 = m_lstWell[i].m_nUpEle - m_lstWell[i].m_nFrondDownEle - (dOuterDn - dThick * 2) * 0.001 - dThick * 0.001;
							csDeep2.Format(sFormat, fabs(nDeep2));
							ads_polar(ptText, m_nLayoutRotation + PI, GetPScale() * 2, ptTmpText);
							DrawText(ptTmpText, csDeep2, AcGiDraw::kMiddleRight, dc, PI / 2);
						}
						//	if(i != m_lstWell.Length() - 1){
						ads_polar(ptText, m_nLayoutRotation, GetPScale() * 2, ptTmpText);
						DrawText(ptTmpText, csGroundDeep, AcGiDraw::kMiddleRight, dc, PI / 2);
						//	}
					}
				}

				if (iDownEleRow > -1) { //管内底标高
					if (csFrontEle == csDownEle || i == 0) {
						ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nDownEleRow + nSheetHeight / 3) * GetPScale(), ptText);
						DrawText(ptText, csDownEle, AcGiDraw::kMiddleRight, dc, PI / 2);
					}
					else {
						if (m_lstWell[i].m_csName == _T("HC"))
						{
							ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nDownEleRow + nSheetHeight / 3) * GetPScale(), ptText);
							DrawText(ptText, csFrontEle, AcGiDraw::kMiddleRight, dc, PI / 2);
							ads_polar(ptCellS2, m_nLayoutRotation - PI / 2, (nDownEleRow + nSheetHeight / 3) * GetPScale(), ptText);
							DrawText(ptText, csDownEle, AcGiDraw::kMiddleRight, dc, PI / 2);
						}
						else
						{
							ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nDownEleRow + nSheetHeight / 3) * GetPScale(), ptText);
							XPoint ptTmpText = ptText;
							if (i != 0) {
								ads_polar(ptText, m_nLayoutRotation + PI, GetPScale() * 2, ptTmpText);
								DrawText(ptTmpText, csFrontEle, AcGiDraw::kMiddleRight, dc, PI / 2);
							}
							//	if(i != m_lstWell.Length() - 1){ //2009-6-11 最后1个井，刚好是跌水井
							ads_polar(ptText, m_nLayoutRotation, GetPScale() * 2, ptTmpText);
							DrawText(ptTmpText, csDownEle, AcGiDraw::kMiddleRight, dc, PI / 2);
							//	}
						}
					}
				}


				SheetColumn column4;
				column4.SetWidth(nWidth / GetPScale());   //序号
				pSheet.SetColumnAt(idx, column4);
				idx++;
				if (m_lstWell[i].m_csName == _T("HC"))
				{
					pSheet.AddColumnAt(pSheet.GetColumnNum());
					SheetColumn column5;
					column5.SetWidth(dPoolLength / GetPScale());   //序号
					pSheet.SetColumnAt(idx, column5);
					idx++;
					ads_polar(ptCellS, m_nLayoutRotation, dPoolLength, ptCellS);
				}


			}
			else if (!m_lstWell[i].m_bIsWell)
			{ //管
				dPipeLen = m_lstWell[i].m_nLength * dScaleX;
				nWidth = dPipeLen;
				if (m_lstWell[i - 1].m_csName == _T("断管")) {
					nWidth = 20 * GetPScale();
					dPipeLen = 0;
				}

				iDn = m_lstWell[i].m_iDn;
				CString csDn, csPipeLen, csI, csLable;
				OPENOBJ_BEGIN(id, AcDb::kForRead, CDbPipe, pPipe);
				if (pPipe) {
					csLable = pPipe->GetLabel();
				}
				OPENOBJ_END();

				csDn.Format(_T("%s%d"), csLable, iDn);

				csI = I2Str(m_lstWell[i].m_nI * 1000);

				////////////////////////
				int iPre = GetPipeLenPrecision();
				CString sHead, sFormat;
				sHead.Format(_T("%d"), iPre);
				sFormat = _T("%.") + sHead + _T("f");
				csPipeLen.Format(sFormat, m_lstWell[i].m_nLength);


				if (iDnRow > -1) {
					GridCell &cell21 = *(pSheet)(iDnRow, idx);
					cell21.SetText(csDn);
				}
				if (iPipeLenRow > -1) {
					GridCell &cell22 = *(pSheet)(iPipeLenRow, idx);
					cell22.SetText(csPipeLen);
				}
				if (iGradientRow > -1) {
					GridCell &cell23 = *(pSheet)(iGradientRow, idx);
					cell23.SetText(csI);
				}

				if (iDemoRow > -1 && i > 1 && m_lstWell[i - 1].m_bIsDropWell && m_iCalcMode != 3) {
					GridCell &cell24 = *(pSheet)(iDemoRow, idx);
					double nDrop = m_lstWell[i - 1].m_nDownEle - m_lstWell[i - 1].m_nFrondDownEle;
					cell24.SetText(XString(_T("跌落%.2f米"), fabs(nDrop)));
					GridStyle gridStyle2;
					gridStyle2.SetOverrideAll(TRUE);
					gridStyle2.SetHorMode(AcDb::kTextLeft);
					gridStyle2.SetTextHeight(m_dTextHeight);
					cell24.SetGridStyle(gridStyle2);
				}
			}//if 管
		}//FOR m_lstWell
	}
	else								// add by 王辉 按选择井的反顺序画 08-05-05
	{
		for (int i = m_lstWell.Length() - 1; i >= 0; i--)
		{
			AcDbObjectId id = m_lstWell[i].m_ID;
			if (m_lstWell[i].m_bIsWell)
			{     //井
				if (m_lstWell[i].m_csName == _T("断管") && dPipeLen > 0)
				{
					SheetColumn column3;
					column3.SetWidth(dPipeLen / GetPScale());   //表尾
					pSheet.SetColumnAt(pSheet.GetColumnNum() - 1, column3); // cet 2016.5.9 modify 未考虑两端同为断管的情况
					continue;
				}

				if (m_lstWell[i].m_csName == _T("断管") && dPipeLen < 0.001)
				{
					continue;
				}
				double nEle = m_lstWell[i].m_nUpEle;
				double nDeep = m_lstWell[i].m_nDeep;
				double nDownEle = m_lstWell[i].m_nDownEle;
				double nGroundDeep = m_lstWell[i].m_nDeep;
				double nFrondEle = m_lstWell[i].m_nFrondDownEle;
				double nGroundEle = m_lstWell[i].m_nGroundEle;
				double dWellRadius = m_lstWell[i].m_nWellRadius;
				//				cet 2016.5.12 modify 覆土厚度=埋设深度-管内径-壁厚	
				//				//先试试外径 2009-6.9 sr
				// 				double dOutDn(0), dDn(0);
				// 				if(i == m_lstWell.Length() - 1)
				// 				{
				// 					dOutDn = (double)m_lstWell[i-1].m_iSpare / 1000;
				// 					dDn = (double)m_lstWell[i-1].m_iDn / 1000;
				// 				}
				// 				else
				// 				{
				// 					dOutDn = (double)m_lstWell[i+1].m_iSpare / 1000;
				// 					dDn = (double)m_lstWell[i+1].m_iDn / 1000;
				// 				}
				// 				if(dOutDn < 0.0001)
				// 					nGroundDeep -= dDn; //不带外径
				// 				else
				// 					nGroundDeep -= (dDn + (dOutDn-dDn) / 2);//带外径
				double dOuterDn = 0.0, dThick = 0.0;
				int nIndex = (i == m_lstWell.Length() - 1) ? i - 1 : i + 1;
				dOuterDn = m_lstWell[nIndex].m_iDn;
				OPENOBJ_BEGIN(m_lstWell[nIndex].m_ID, AcDb::kForRead, CDbPipe, pPipe);
				if (pPipe != NULL)
				{
					if (pPipe->OuterDn() > 0.001)
					{
						dOuterDn = pPipe->OuterDn();
					}
					dThick = pPipe->GetPipeThick();
				}
				OPENOBJ_END();
				dOuterDn *= 0.001;
				dThick *= 0.001;
				nGroundDeep = nDeep - (dOuterDn - dThick * 2) - dThick;

				CString csWellUpEle, csDeep, csDownEle, csGroundDeep, csFrontEle, csGroundEle, csWellRaius;
				CString csWellName = m_lstWell[i].m_csName;
				csWellRaius.Format(_T("%%%%c%.0f"), dWellRadius * 2.0);
				if (dWellRadius < 0)
					csWellRaius = _T("矩形井");

				int iPre = GetWellDeepPrecision();
				CString sHead, sFormat;
				sHead.Format(_T("%d"), iPre);
				sFormat = _T("%.") + sHead + _T("f");
				csDeep.Format(sFormat, nDeep);
				csGroundEle.Format(sFormat, nGroundEle);
				csDownEle.Format(sFormat, nDownEle);
				csWellUpEle.Format(sFormat, nEle);
				csGroundDeep.Format(sFormat, nGroundDeep);
				csFrontEle.Format(sFormat, nFrondEle);

				ads_polar(ptCellS, m_nLayoutRotation, dPipeLen, ptCellS);
				XPoint ptCellS2 = ptCellS;
				double dPoolLength(0);
				if (m_lstWell[i].m_csName == _T("HC"))
				{
					OPENOBJ_BEGIN(m_lstWell[i].m_ID, AcDb::kForRead, CDbPool, pEquip);
					if (pEquip) {
						dPoolLength = pEquip->GetPoolLength();
						if (!GlobalFunc::DocGetMeterUnitDraw())
							dPoolLength = dPoolLength / 1000;
						if (iDemoRow > -1 && i > 1 && m_lstWell[i].m_csName == _T("HC"))  //备注
						{
							GridCell &cell24 = *(pSheet)(iDemoRow, idx + 1);
							//  cet 2016.11.3 modify 池名称可能不是化粪池
							//	cell24.SetText(XString(_T("化粪池L=%.2f"), dPoolLength));
							CString sName = _T("化粪池"), sTemp;
							bool bRet = true;
							sTemp = pEquip->GetName(&bRet);
							if (bRet) // 池设置了名称
							{
								sName = sTemp;
							}
							cell24.SetText(XString(_T("%sL=%.2f"), sName, dPoolLength));
						}
						dPoolLength = dPoolLength * dScaleX;
					}
					OPENOBJ_END();
					ads_polar(ptCellS, m_nLayoutRotation, dPoolLength, ptCellS2);
				}


				if (iWellNameRow > -1)//名称
				{
					//					cet 2013.3.1 modify 获得池子的真实名称
					// 					if(m_lstWell[i].m_csName == _T("HC"))
					// 						csWellName = _T("HC出");
					CString sName;
					if (m_lstWell[i].m_csName == _T("HC"))
					{
						sName = GetPoolName(m_lstWell[i].m_ID);
						csWellName = sName + _T("出");
					}

					ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nWellNameRow + nSheetHeight / 2) * GetPScale(), ptText);
					DrawText(ptText, csWellName, AcGiDraw::kMiddleCenter, dc);
					if (m_lstWell[i].m_csName == _T("HC"))
					{
						ads_polar(ptCellS2, m_nLayoutRotation - PI / 2, (nWellNameRow + nSheetHeight / 2) * GetPScale(), ptText);
						//  cet 2013.3.1 modify 获得池子的真实名称
						//	DrawText(ptText, _T("HC进"), AcGiDraw::kMiddleCenter, dc);
						DrawText(ptText, sName + _T("进"), AcGiDraw::kMiddleCenter, dc);
					}
				}
				if (iWellRadiusRow > -1)
				{
					ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nWellRaiusRow + nSheetHeight / 2) * GetPScale(), ptText);
					DrawText(ptText, csWellRaius, AcGiDraw::kMiddleCenter, dc);
				}

				if (iUpEleRow > -1)//地面标高
				{
					ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nUpEleRow + nSheetHeight / 3) * GetPScale(), ptText);
					DrawText(ptText, csWellUpEle, AcGiDraw::kMiddleRight, dc, PI / 2);
					if (m_lstWell[i].m_csName == _T("HC"))
					{
						ads_polar(ptCellS2, m_nLayoutRotation - PI / 2, (nUpEleRow + nSheetHeight / 3) * GetPScale(), ptText);
						DrawText(ptText, csWellUpEle, AcGiDraw::kMiddleRight, dc, PI / 2);
					}
				}
				if (iGroundEleRow > -1)//自然地面标高
				{
					ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nGroundEleRow + nSheetHeight / 3) * GetPScale(), ptText);
					DrawText(ptText, csGroundEle, AcGiDraw::kMiddleRight, dc, PI / 2);
					if (m_lstWell[i].m_csName == _T("HC"))
					{
						ads_polar(ptCellS2, m_nLayoutRotation - PI / 2, (nGroundEleRow + nSheetHeight / 3) * GetPScale(), ptText);
						DrawText(ptText, csGroundEle, AcGiDraw::kMiddleRight, dc, PI / 2);
					}
				}
				if (iStakeRow > -1) {
					AcDbObjectId id = m_lstWell[i].m_ID;
					ads_name entWell;
					acdbGetAdsName(entWell, id);
					CString csStake = GlobalFunc::ReadXdata(entWell, _T("TWT-STAKEVALUE"));

					ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nStakeRow + nSheetHeight / 2) * GetPScale(), ptText);
					DrawText(ptText, csStake, AcGiDraw::kMiddleCenter, dc);
				}

				if (iDeepRow > -1 && m_iCalcMode != 3)				//埋深
				{
					if (!m_lstWell[i].m_bIsDropWell) {
						if (m_lstWell[i].m_csName == _T("HC"))
						{
							CString csDeep2;
							double nDeep2 = m_lstWell[i].m_nUpEle - m_lstWell[i].m_nFrondDownEle;
							csDeep2.Format(sFormat, fabs(nDeep2));
							ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nDeepRow + nSheetHeight / 3) * GetPScale(), ptText);
							DrawText(ptText, csDeep, AcGiDraw::kMiddleRight, dc, PI / 2);
							ads_polar(ptCellS2, m_nLayoutRotation - PI / 2, (nDeepRow + nSheetHeight / 3) * GetPScale(), ptText);
							DrawText(ptText, csDeep2, AcGiDraw::kMiddleRight, dc, PI / 2);
						}
						else
						{
							ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nDeepRow + nSheetHeight / 3) * GetPScale(), ptText);
							DrawText(ptText, csDeep, AcGiDraw::kMiddleRight, dc, PI / 2);
						}

					}
					else {
						ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nDeepRow + nSheetHeight / 3) * GetPScale(), ptText);
						XPoint ptTmpText = ptText;
						//if(i != 0){
						ads_polar(ptText, m_nLayoutRotation + PI, GetPScale() * 2, ptTmpText);
						DrawText(ptTmpText, csDeep, AcGiDraw::kMiddleRight, dc, PI / 2);
						//}
						if (i != 0) {
							CString csDeep2;
							double nDeep2 = m_lstWell[i].m_nUpEle - m_lstWell[i].m_nFrondDownEle;
							csDeep2.Format(sFormat, fabs(nDeep2));

							ads_polar(ptText, m_nLayoutRotation, GetPScale() * 2, ptTmpText);
							DrawText(ptTmpText, csDeep2, AcGiDraw::kMiddleRight, dc, PI / 2);
						}
					}

				}
				if (iThicknessRow > -1 && m_iCalcMode != 3)			// 雨污 覆土厚度
				{
					// cet 2016.5.12 add 获得外径和壁厚
					double dOuterDn = 0.0, dThick = 0.0;
					if (!m_lstWell[i].m_bIsDropWell && m_lstWell[i].m_csName == _T("HC") || i != 0)
					{
						dOuterDn = m_lstWell[i - 1].m_iDn;
						OPENOBJ_BEGIN(m_lstWell[i - 1].m_ID, AcDb::kForRead, CDbPipe, pPipe);
						if (pPipe != NULL)
						{
							if (pPipe->OuterDn() > 0.001)
							{
								dOuterDn = pPipe->OuterDn();
							}
							dThick = pPipe->GetPipeThick();
						}
						OPENOBJ_END();
					}
					if (!m_lstWell[i].m_bIsDropWell) {
						if (m_lstWell[i].m_csName == _T("HC"))
						{
							CString csDeep2;
							//  cet 2016.5.12 modify 应使用内径和壁厚计算
							//	double nDeep2 = m_lstWell[i].m_nUpEle - m_lstWell[i].m_nFrondDownEle-(double)m_lstWell[i-1].m_iDn/1000;
							double nDeep2 = m_lstWell[i].m_nUpEle - m_lstWell[i].m_nFrondDownEle - (dOuterDn - dThick * 2) * 0.001 - dThick * 0.001;
							csDeep2.Format(sFormat, fabs(nDeep2));
							ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nThicknessRow + nSheetHeight / 2) * GetPScale(), ptText);
							DrawText(ptText, csGroundDeep, AcGiDraw::kMiddleRight, dc, PI / 2);
							ads_polar(ptCellS2, m_nLayoutRotation - PI / 2, (nThicknessRow + nSheetHeight / 2) * GetPScale(), ptText);
							DrawText(ptText, csDeep2, AcGiDraw::kMiddleRight, dc, PI / 2);
						}
						else
						{
							ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nThicknessRow + nSheetHeight / 2) * GetPScale(), ptText);
							DrawText(ptText, csGroundDeep, AcGiDraw::kMiddleRight, dc, PI / 2);
						}
					}
					else {
						ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nThicknessRow + nSheetHeight / 3) * GetPScale(), ptText);
						XPoint ptTmpText = ptText;
						//	if(i != 0){
						ads_polar(ptText, m_nLayoutRotation + PI, GetPScale() * 2, ptTmpText);
						DrawText(ptTmpText, csGroundDeep, AcGiDraw::kMiddleRight, dc, PI / 2);
						//	}
						if (i != 0) {
							CString csDeep2;
							//  cet 2016.5.12 modify 应使用内径和壁厚计算
							//	double nDeep2 = m_lstWell[i].m_nUpEle - m_lstWell[i].m_nFrondDownEle-(double)m_lstWell[i-1].m_iDn/1000;
							double nDeep2 = m_lstWell[i].m_nUpEle - m_lstWell[i].m_nFrondDownEle - (dOuterDn - dThick * 2) * 0.001 - dThick * 0.001;
							csDeep2.Format(sFormat, fabs(nDeep2));
							ads_polar(ptText, m_nLayoutRotation, GetPScale() * 2, ptTmpText);
							DrawText(ptTmpText, csDeep2, AcGiDraw::kMiddleRight, dc, PI / 2);
						}
					}
				}

				if (iDownEleRow > -1)
				{ //管内底标高， 或给水的管中标高
					if (csFrontEle == csDownEle || i == 0) {
						ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nDownEleRow + nSheetHeight / 3) * GetPScale(), ptText);
						DrawText(ptText, csDownEle, AcGiDraw::kMiddleRight, dc, PI / 2);
					}
					else {
						if (m_lstWell[i].m_csName == _T("HC"))
						{
							ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nDownEleRow + nSheetHeight / 3) * GetPScale(), ptText);
							DrawText(ptText, csDownEle, AcGiDraw::kMiddleRight, dc, PI / 2);
							ads_polar(ptCellS2, m_nLayoutRotation - PI / 2, (nDownEleRow + nSheetHeight / 3) * GetPScale(), ptText);
							DrawText(ptText, csFrontEle, AcGiDraw::kMiddleRight, dc, PI / 2);
						}
						else
						{
							ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nDownEleRow + nSheetHeight / 3) * GetPScale(), ptText);
							XPoint ptTmpText = ptText;
							if (i != 0) {
								ads_polar(ptText, m_nLayoutRotation + PI, GetPScale() * 2, ptTmpText);
								DrawText(ptTmpText, csDownEle, AcGiDraw::kMiddleRight, dc, PI / 2);
							}
							//	if(i != m_lstWell.Length() - 1){
							ads_polar(ptText, m_nLayoutRotation, GetPScale() * 2, ptTmpText);
							DrawText(ptTmpText, csFrontEle, AcGiDraw::kMiddleRight, dc, PI / 2);
							//		}
						}
					}
				}

				ptWell = ptText;
				SheetColumn column4;
				column4.SetWidth(nWidth / GetPScale());   //序号
				pSheet.SetColumnAt(idx, column4);
				idx++;
				if (m_lstWell[i].m_csName == _T("HC"))
				{
					pSheet.AddColumnAt(pSheet.GetColumnNum());
					SheetColumn column5;
					column5.SetWidth(dPoolLength / GetPScale());   //序号
					pSheet.SetColumnAt(idx, column5);
					idx++;
					ads_polar(ptCellS, m_nLayoutRotation, dPoolLength, ptCellS);
				}
			}
			else if (!m_lstWell[i].m_bIsWell)			//管
			{
				dPipeLen = m_lstWell[i].m_nLength * dScaleX;
				nWidth = dPipeLen;
				if (m_lstWell[i + 1].m_csName == _T("断管"))
				{
					nWidth = 20 * GetPScale();
					dPipeLen = 0;
				}

				iDn = m_lstWell[i].m_iDn;
				CString csDn, csPipeLen, csI, csLable;
				OPENOBJ_BEGIN(id, AcDb::kForRead, CDbPipe, pPipe);
				if (pPipe) {
					csLable = pPipe->GetLabel();
				}
				OPENOBJ_END();

				csDn.Format(_T("%s%d"), csLable, iDn);
				csI = I2Str(m_lstWell[i].m_nI * 1000);

				////////////////////////
				int iPre = GetPipeLenPrecision();
				CString sHead, sFormat;
				sHead.Format(_T("%d"), iPre);
				sFormat = _T("%.") + sHead + _T("f");
				csPipeLen.Format(sFormat, m_lstWell[i].m_nLength);

				if (iDnRow > -1)
				{
					GridCell &cell21 = *(pSheet)(iDnRow, idx);
					cell21.SetText(csDn);
				}
				if (iPipeLenRow > -1)
				{
					GridCell &cell22 = *(pSheet)(iPipeLenRow, idx);
					cell22.SetText(csPipeLen);
				}
				if (iGradientRow > -1)
				{
					GridCell &cell23 = *(pSheet)(iGradientRow, idx);
					cell23.SetText(csI);
				}

				if (iDemoRow > -1 && i > 1 && m_lstWell[i + 1].m_bIsDropWell && m_iCalcMode != 3)
				{
					GridCell &cell24 = *(pSheet)(iDemoRow, idx);
					double nDrop = m_lstWell[i + 1].m_nDownEle - m_lstWell[i + 1].m_nFrondDownEle;
					cell24.SetText(XString(_T("跌落%.2f米"), fabs(nDrop)));
					GridStyle gridStyle2;
					gridStyle2.SetOverrideAll(TRUE);
					gridStyle2.SetHorMode(AcDb::kTextLeft);
					gridStyle2.SetTextHeight(m_dTextHeight);
					cell24.SetGridStyle(gridStyle2);
				}

			}

		}
	}

	for (int j = 0; j < lstHead.Length(); j++) {
		GridCell &cell = *(pSheet)(j, 0);
		CString csHead = lstHead[j];
		if (csHead == _T("管标高（m）")) {
			if (m_iCalcMode == 3)
				cell.SetText(_T("管中标高（m）"));
			else
				cell.SetText(_T("管内底标高（m）"));
		}
		else
			cell.SetText(csHead);

		if (csHead.Find(_T("埋设深度")) > -1 || csHead.Find(_T("覆土厚度")) > -1 || csHead.Find(_T("管线平面")) > -1)
		{
			SheetRow *row = pSheet.GetRow(j);
			row->SetRowHeightStyle(SheetRow::kFree);
			row->SetHeight(nSheetHeight * 2);
		}
		else if (csHead.Find(_T("设计地面标高")) > -1 || csHead.Find(_T("自然地面标高")) > -1 || csHead.Find(_T("管标高（m）")) > -1)
		{//这几个标高的行，很容易出界
			SheetRow *row = pSheet.GetRow(j);
			row->SetRowHeightStyle(SheetRow::kFree);
			row->SetHeight(nSheetHeight * 2.5);
		}

		if (csHead.Find(_T("设计地面标高")) > -1 || csHead.Find(_T("埋设深度")) > -1
			|| csHead.Find(_T("桩号")) > -1 || csHead.Find(_T("管道基础")) > -1 || csHead.Find(_T("自然地面标高")) > -1
			|| csHead.Find(_T("管材")) > -1 || csHead.Find(_T("管线平面")) > -1 || csHead.Find(_T("井径（mm）")) > -1
			|| csHead.Find(_T("覆土厚度")) > -1 || csHead.Find(_T("井编号")) > -1 || csHead.Find(_T("管标高")) > -1)
		{
			pSheet.MergeCells(j, 1, j, pSheet.GetColumnNum() - 1);
		}
	}

	//绘制管线平面  sr add 2007-8-17  sr modify 2009-7-20 支持断管，支持反向绘制
	if (iPipePlanRow > -1) {
		XPoint ptS, ptSize;
		ptS = pSheet.GetCellPoint(iPipePlanRow, 1);
		ads_polar(ptS, m_nLayoutRotation + PI / 2, -nSheetHeight * GetPScale(), ptS);
		ads_polar(ptS, m_nLayoutRotation, 20 * GetPScale(), ptS);
		if (m_iCalcMode < 100)
		{
			for (int i = 0; i < m_lstWell.Length(); i++) {
				AcDbObjectId id = m_lstWell[i].m_ID;
				if (m_lstWell[i].m_bIsWell) {     //井
					CString csName = m_lstWell[i].m_csName;
					if (csName == _T("断管"))
						continue;
					OPENOBJ_BEGIN(id, AcDb::kForRead, AecXDbWell, pEquip);
					if (pEquip) {
						AcDbObjectId eqId = pEquip->GetBlock2d();
						CString csBlkName = GlobalFunc::GetSymbolName(eqId);
						OPENOBJ_BEGIN(eqId, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
						if (pBlock) {
							AcGeScale3d scale(pEquip->GetScale() * GetPScale(), pEquip->GetScale() * GetPScale(), pEquip->GetScale() * GetPScale());
							dc.DrawBlock(*pBlock, ptS, scale, 0, TRUE);
						}
						OPENOBJ_END();
					}
					OPENOBJ_END();
					//	idx++;
				}
				else if (!m_lstWell[i].m_bIsWell) {
					if (m_lstWell[i - 1].m_csName == _T("断管") || m_lstWell[i + 1].m_csName == _T("断管"))
						continue;
					XPoint ptTmp1, ptTmp2;
					dPipeLen = m_lstWell[i].m_nLength * dScaleX;
					if (m_lstWell[i].m_dRealLength > 0.1)
						dPipeLen = m_lstWell[i].m_dRealLength * dScaleX; //实际管长
					ptTmp1 = ptS;
					ads_polar(ptS, m_nLayoutRotation, dPipeLen, ptS);
					ptTmp2 = ptS;
					AcDbObjectId id2 = m_lstWell[i - 1].m_ID;
					OPENOBJ_BEGIN(id2, AcDb::kForRead, AecXDbWell, pEquip);
					if (pEquip) {
						if (pEquip->IsHidePipe()) {
							double dScale = pEquip->GetScale() * GetPScale();
							ads_polar(ptTmp1, m_nLayoutRotation, dScale / 2, ptTmp1);
						}
					}
					OPENOBJ_END();
					AcDbObjectId id3 = m_lstWell[i + 1].m_ID;
					OPENOBJ_BEGIN(id3, AcDb::kForRead, AecXDbWell, pEquip);
					if (pEquip) {
						if (pEquip->IsHidePipe()) {
							double dScale = pEquip->GetScale() * GetPScale();
							ads_polar(ptTmp2, m_nLayoutRotation, -dScale / 2, ptTmp2);
						}
					}
					OPENOBJ_END();
					DrawLine(ptTmp1, ptTmp2, dc);
				}
			}
		}
		else //反向绘制
		{
			for (int i = m_lstWell.Length() - 1; i >= 0; i--) {
				AcDbObjectId id = m_lstWell[i].m_ID;
				if (m_lstWell[i].m_bIsWell) {     //井
					CString csName = m_lstWell[i].m_csName;
					if (csName == _T("断管"))
						continue;
					OPENOBJ_BEGIN(id, AcDb::kForRead, AecXDbWell, pEquip);
					if (pEquip) {
						AcDbObjectId eqId = pEquip->GetBlock2d();
						CString csBlkName = GlobalFunc::GetSymbolName(eqId);
						OPENOBJ_BEGIN(eqId, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
						if (pBlock) {
							AcGeScale3d scale(pEquip->GetScale() * GetPScale(), pEquip->GetScale() * GetPScale(), pEquip->GetScale() * GetPScale());
							dc.DrawBlock(*pBlock, ptS, scale, 0, TRUE);
						}
						OPENOBJ_END();
					}
					OPENOBJ_END();
					//	idx++;
				}
				else if (!m_lstWell[i].m_bIsWell) {
					if (m_lstWell[i - 1].m_csName == _T("断管") || m_lstWell[i + 1].m_csName == _T("断管"))
						continue;
					XPoint ptTmp1, ptTmp2;
					dPipeLen = m_lstWell[i].m_nLength * dScaleX;
					if (m_lstWell[i].m_dRealLength > 0.1)
						dPipeLen = m_lstWell[i].m_dRealLength * dScaleX; //实际管长
					ptTmp1 = ptS;
					ads_polar(ptS, m_nLayoutRotation, dPipeLen, ptS);
					ptTmp2 = ptS;
					AcDbObjectId id2 = m_lstWell[i - 1].m_ID;
					OPENOBJ_BEGIN(id2, AcDb::kForRead, AecXDbWell, pEquip);
					if (pEquip) {
						if (pEquip->IsHidePipe()) {
							double dScale = pEquip->GetScale() * GetPScale();
							ads_polar(ptTmp1, m_nLayoutRotation, dScale / 2, ptTmp1);
						}
					}
					OPENOBJ_END();
					AcDbObjectId id3 = m_lstWell[i + 1].m_ID;
					OPENOBJ_BEGIN(id3, AcDb::kForRead, AecXDbWell, pEquip);
					if (pEquip) {
						if (pEquip->IsHidePipe()) {
							double dScale = pEquip->GetScale() * GetPScale();
							ads_polar(ptTmp2, m_nLayoutRotation, -dScale / 2, ptTmp2);
						}
					}
					OPENOBJ_END();
					DrawLine(ptTmp1, ptTmp2, dc);
				}
			}

		}
	}


	//    int nGsMarker=1;
	//    pSheet.SetLocation(ptCivilIns);
	XPoint ptBase = pSheet.GetTopLeft(FALSE);
	//if (dc.IsFullExplode()) //炸开时，以防多绘制一遍文字
	//	pSheet.DrawCellText(ptBase, dc, nGsMarker);
	//if (dc.IsFullExplode())
	//	pSheet.ExplodeOrDraw2d(dc);
	//else
		//dc.DrawEntity(pSheet);
	DrawBaseEx(dc, pSheet);
	// cet 2017.9.6 add 获得表格角点
	double dAngle = pSheet.GetRotation();
	AcGeVector3d vtX = AcGeVector3d::kXAxis;
	GlobalFunc::Ucs2Wcs(vtX, TRUE);
	vtX.rotateBy(dAngle, AcGeVector3d::kZAxis);
	AcGeVector3d vtY = vtX;
	vtY.rotateBy(PI / 2, AcGeVector3d::kZAxis);
	double dWidth = 0.0;
	for (int i = 0; i < pSheet.GetColumnNum(); ++i)
	{
		dWidth += pSheet.GetColumnWidth(i, FALSE);
	}
	double dHeight = pSheet.GetRowsHeight(0, pSheet.GetRowNum() - 1, FALSE);
	const_cast<XPoint&>(m_ptTopLeft) = ptCivilIns;
	const_cast<XPoint&>(m_ptTolRight) = m_ptTopLeft + vtX * dWidth;
	const_cast<XPoint&>(m_ptBottomLeft) = ptCivilIns - vtY * dHeight;
	const_cast<XPoint&>(m_ptBottomRight) = m_ptBottomLeft + vtX * dWidth;
	return Acad::eOk;

}


Acad::ErrorStatus CDbVerticalSection::DrawCivilSheetFeed(AcGiDraw &dc, XPoint ptEnd) const
{
	double nSheetHeight = m_dTextHeight + 3;
	XStringList lstHead;
	int idx2(1);
	double nWellNameRow(0), nWellRaiusRow(0), nDeepRow(0), nGroundEleRow(0), nUpEleRow(0), nThicknessRow(0), nDownEleRow(0), nTmpHeight(0);
	while (1) {
		TCHAR sBuf[256] = _T("");
		GlobalFunc::GetStringAtIndex(m_sSheetHead, idx2, sBuf);
		if (_tcsicmp(sBuf, _T("")) == 0)
			break;
		lstHead.Append(tstrnew(sBuf));
		idx2++;
		if (_tcsicmp(sBuf, _T("井编号")) == 0) {
			nWellNameRow = nTmpHeight;
			nTmpHeight += nSheetHeight;
		}
		else if (_tcsicmp(sBuf, _T("井径（mm）")) == 0) {
			nWellRaiusRow = nTmpHeight;
			nTmpHeight += nSheetHeight;
		}
		else if (_tcsicmp(sBuf, _T("设计地面标高（m）")) == 0) {
			nUpEleRow = nTmpHeight;
			nTmpHeight += nSheetHeight * 2;
		}
		else if (_tcsicmp(sBuf, _T("自然地面标高（m）")) == 0) {
			nGroundEleRow = nTmpHeight;
			nTmpHeight += nSheetHeight * 2;
		}
		else if (_tcsicmp(sBuf, _T("埋设深度（m）")) == 0) {
			nDeepRow = nTmpHeight;
			nTmpHeight += nSheetHeight * 2;
		}
		else if (_tcsicmp(sBuf, _T("覆土厚度（m）")) == 0) {
			nThicknessRow = nTmpHeight;
			nTmpHeight += nSheetHeight * 2;
		}
		else if (_tcsicmp(sBuf, _T("管标高（m）")) == 0) {
			nDownEleRow = nTmpHeight;
			nTmpHeight += nSheetHeight * 2;
		}
		else
			nTmpHeight += nSheetHeight;
	}
	int iDemoRow = lstHead.Index(_T("备注"));
	int iPipeLenRow = lstHead.Index(_T("管道长度（m）"));
	int iGradientRow = lstHead.Index(_T("管道坡度"));
	int iDnRow = lstHead.Index(_T("管径（mm）"));
	int iWellNameRow = lstHead.Index(_T("井编号"));
	int iUpEleRow = lstHead.Index(_T("设计地面标高（m）"));
	int iDeepRow = lstHead.Index(_T("埋设深度（m）"));
	int iThicknessRow = lstHead.Index(_T("覆土厚度（m）"));
	int iGroundEleRow = lstHead.Index(_T("自然地面标高（m）"));
	int iWellRadiusRow = lstHead.Index(_T("井径（mm）"));
	int iDownEleRow = lstHead.Index(_T("管标高（m）"));
	int iPipePlanRow = lstHead.Index(_T("管线平面"));

	BOOL bBreak1 = FALSE;
	BOOL bBreak2 = FALSE;
	if (m_lstFeedWell[0].m_csName == _T("断管"))
		bBreak1 = TRUE;
	if (m_lstFeedWell[m_lstFeedWell.Length() - 1].m_csName == _T("断管"))
		bBreak2 = TRUE;
	double dScaleY = m_iScaleY;
	double dScaleX = m_iScaleX;
	dScaleX = GetPScale() / dScaleX * 1000;
	dScaleY = GetPScale() / dScaleY * 1000;//转化为毫米

//    XPoint ptIns = m_ptIns;
//    XPoint ptCivilIns = ptIns;
//    ptCivilIns.y = ptEnd.y;
//    ptIns = ptCivilIns;
//    ads_polar(ptCivilIns, m_nLayoutRotation+PI, 45*GetPScale(), ptCivilIns);
	XPoint ptCivilIns = ptEnd;
	XPoint ptIns = ptCivilIns;
	ads_polar(ptCivilIns, m_nLayoutRotation + PI, 45 * GetPScale(), ptCivilIns);


	//绘制表格
	AcDbObjectId idTextStyle = m_idTextStyle;
	CDbSheet pSheet;
	//	cet 2018.2.7 modify 表格图层与网格一致
	//	pSheet.setLayer(this->layerId());
	pSheet.setLayer(this->GetGridLayer());
	pSheet.SetPScale(GetPScale());
	pSheet.SetRotation(m_nLayoutRotation);
	GridStyle gridStyle;
	gridStyle.SetOverrideAll(TRUE);
	gridStyle.SetTextHeight(m_dTextHeight);
	gridStyle.SetTextStyleId(idTextStyle);

	SheetTitle &title = pSheet.GetTitle();
	title.SetHeight(nSheetHeight);
	title.SetVisible(FALSE);

	gridStyle.SetHorMode(AcDb::kTextCenter);
	gridStyle.SetVerMode(AcDb::kTextVertMid);
	gridStyle.SetLineSpaceFactor(0.2);
	gridStyle.SetTextWrap(FALSE);
	pSheet.SetGridStyle(gridStyle);
	pSheet.SetRowHeight(m_dTextHeight + 2);
	if (bBreak2 || bBreak1)
		pSheet.InitSheet(lstHead.Length(), m_lstFeedWell.Length() / 2 + 2, nSheetHeight, 50);
	else
		pSheet.InitSheet(lstHead.Length(), m_lstFeedWell.Length() / 2 + 3, nSheetHeight, 50);

	SheetColumn column;
	column.SetWidth(25);   //表头
	pSheet.SetColumnAt(0, column);

	SheetColumn column2;
	if (!bBreak2 && !bBreak1) {
		column2.SetWidth(5);   //表尾
		pSheet.SetColumnAt(m_lstFeedWell.Length() / 2 + 2, column2);
	}
	if (bBreak1) {
		column2.SetWidth(5);   //表尾
		pSheet.SetColumnAt(m_lstFeedWell.Length() / 2 + 1, column2);
	}
	double nWidth = 20 * GetPScale();

	XPoint ptCellS, ptCellE, ptText, ptWell;

	ptCellS = ptIns;
	double dPipeLen(0);
	int idx = 1;
	int iDn(0);
	int nGsMarker = 1;
	pSheet.SetLocation(ptCivilIns);
	for (int i = 0; i < m_lstFeedWell.Length(); i++) {

		AcDbObjectId id = m_lstFeedWell[i].m_ID;
		if (m_lstFeedWell[i].m_bIsWell) {     //井
			if (m_lstFeedWell[i].m_csName == _T("断管") && dPipeLen > 0) {
				SheetColumn column3;
				column3.SetWidth(dPipeLen / GetPScale());   //表尾
				pSheet.SetColumnAt(m_lstFeedWell.Length() / 2 + 1, column3);
				continue;
			}
			if (m_lstFeedWell[i].m_csName == _T("断管") && dPipeLen < 0.001) {
				continue;
			}
			double nEle = m_lstFeedWell[i].m_nUpEle;
			double nDeep = m_lstFeedWell[i].m_nDeep;
			double nDownEle = m_lstFeedWell[i].m_nDownEle;
			double nGroundDeep = m_lstFeedWell[i].m_nDeep;
			double nFrondEle = m_lstFeedWell[i].m_nFrondDownEle;
			double nGroundEle = m_lstFeedWell[i].m_nGroundEle;
			double dWellRadius = m_lstFeedWell[i].m_nWellRadius;
			if (i == m_lstFeedWell.Length() - 1)
				nGroundDeep -= (double)m_lstFeedWell[i - 1].m_iDn / 1000;
			else
				nGroundDeep -= (double)m_lstFeedWell[i + 1].m_iDn / 1000;

			int iPre = GetWellDeepPrecision();
			CString sHead, sFormat;
			sHead.Format(_T("%d"), iPre);
			sFormat = _T("%.") + sHead + _T("f");

			CString csWellUpEle, csDeep, csDownEle, csGroundDeep, csFrontEle, csGroundEle, csWellRaius;
			csDeep.Format(sFormat, nDeep);
			csGroundEle.Format(sFormat, nGroundEle);
			csDownEle.Format(sFormat, nDownEle);
			csWellUpEle.Format(sFormat, nEle);
			csGroundDeep.Format(sFormat, nGroundDeep);
			csFrontEle.Format(sFormat, nFrondEle);
			CString csWellName = m_lstFeedWell[i].m_csName;
			csWellRaius.Format(_T("D%.0f"), dWellRadius * 2.0);


			ads_polar(ptCellS, m_nLayoutRotation, dPipeLen, ptCellS);
			if (iWellNameRow > -1) {
				ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nWellNameRow + nSheetHeight / 2) * GetPScale(), ptText);
				DrawText(ptText, csWellName, AcGiDraw::kMiddleCenter, dc);
			}
			if (iWellRadiusRow > -1) {
				ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nWellRaiusRow + nSheetHeight / 2) * GetPScale(), ptText);
				DrawText(ptText, csWellRaius, AcGiDraw::kMiddleCenter, dc);
			}

			if (iUpEleRow > -1) {
				ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nUpEleRow + nSheetHeight / 3) * GetPScale(), ptText);
				DrawText(ptText, csWellUpEle, AcGiDraw::kMiddleRight, dc, PI / 2);
			}
			if (iGroundEleRow > -1) {
				ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nGroundEleRow + nSheetHeight / 3) * GetPScale(), ptText);
				DrawText(ptText, csGroundEle, AcGiDraw::kMiddleRight, dc, PI / 2);
			}
			if (iDeepRow > -1 && m_iCalcMode != 3) {//埋深
				if (!m_lstFeedWell[i].m_bIsDropWell) {
					ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nDeepRow + nSheetHeight / 2) * GetPScale(), ptText);
					DrawText(ptText, csDeep, AcGiDraw::kMiddleRight, dc, PI / 2);
				}
				else {
					ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nDeepRow + nSheetHeight / 3) * GetPScale(), ptText);
					XPoint ptTmpText = ptText;
					if (i != 0) {
						CString csDeep2;
						double nDeep2 = m_lstFeedWell[i].m_nUpEle - m_lstFeedWell[i].m_nFrondDownEle;
						csDeep2.Format(sFormat, fabs(nDeep2));
						ads_polar(ptText, m_nLayoutRotation + PI, GetPScale() * 2, ptTmpText);
						DrawText(ptTmpText, csDeep2, AcGiDraw::kMiddleRight, dc, PI / 2);
					}
					if (i != m_lstFeedWell.Length() - 1) {
						ads_polar(ptText, m_nLayoutRotation, GetPScale() * 2, ptTmpText);
						DrawText(ptTmpText, csDeep, AcGiDraw::kMiddleRight, dc, PI / 2);
					}
				}
			}
			if (iThicknessRow > -1 && m_iCalcMode != 3) {// 雨污 覆土厚度
				if (!m_lstFeedWell[i].m_bIsDropWell) {
					ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nThicknessRow + nSheetHeight / 2) * GetPScale(), ptText);
					DrawText(ptText, csGroundDeep, AcGiDraw::kMiddleRight, dc, PI / 2);
				}
				else {
					ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nThicknessRow + nSheetHeight / 3) * GetPScale(), ptText);
					XPoint ptTmpText = ptText;
					if (i != 0) {
						CString csDeep2;
						double nDeep2 = m_lstFeedWell[i].m_nUpEle - m_lstFeedWell[i].m_nFrondDownEle - (double)m_lstFeedWell[i - 1].m_iDn / 1000;
						csDeep2.Format(sFormat, fabs(nDeep2));
						ads_polar(ptText, m_nLayoutRotation + PI, GetPScale() * 2, ptTmpText);
						DrawText(ptTmpText, csDeep2, AcGiDraw::kMiddleRight, dc, PI / 2);
					}
					if (i != m_lstFeedWell.Length() - 1) {
						ads_polar(ptText, m_nLayoutRotation, GetPScale() * 2, ptTmpText);
						DrawText(ptTmpText, csGroundDeep, AcGiDraw::kMiddleRight, dc, PI / 2);
					}
				}
			}
			else if (iThicknessRow > -1 && m_iCalcMode == 3) {// 给水 覆土厚度
				CString csFeedDeep;
				double dDn(0);

				if (csFrontEle == csDownEle || i == 0) {
					if (i == m_lstFeedWell.Length() - 1)
						dDn = (double)m_lstFeedWell[i - 1].m_iDn / 2000;
					else
						dDn = (double)m_lstFeedWell[i + 1].m_iDn / 2000;
					double dFeedDeep = nEle - nDownEle - dDn;
					csFeedDeep.Format(sFormat, dFeedDeep);
					ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nThicknessRow + nSheetHeight / 2) * GetPScale(), ptText);
					DrawText(ptText, csFeedDeep, AcGiDraw::kMiddleRight, dc, PI / 2);
				}
				else {
					ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nThicknessRow + nSheetHeight / 3) * GetPScale(), ptText);
					XPoint ptTmpText = ptText;
					if (i != 0) {
						dDn = (double)m_lstFeedWell[i - 1].m_iDn / 2000;
						double nFrondEle2 = m_lstFeedWell[i].m_nFrondDownEle;
						double dFeedDeep = nEle - nFrondEle2 - dDn;
						csFeedDeep.Format(sFormat, dFeedDeep);

						ads_polar(ptText, m_nLayoutRotation + PI, GetPScale() * 2, ptTmpText);
						DrawText(ptTmpText, csFeedDeep, AcGiDraw::kMiddleRight, dc, PI / 2);
					}
					if (i != m_lstFeedWell.Length() - 1) {
						dDn = (double)m_lstFeedWell[i + 1].m_iDn / 2000;
						double dFeedDeep = nEle - nDownEle - dDn;
						csFeedDeep.Format(sFormat, dFeedDeep);

						ads_polar(ptText, m_nLayoutRotation, GetPScale() * 2, ptTmpText);
						DrawText(ptTmpText, csFeedDeep, AcGiDraw::kMiddleRight, dc, PI / 2);
					}
				}
			}

			if (iDownEleRow > -1) { //管内底标高， 或给水的管中标高
				if (csFrontEle == csDownEle || i == 0) {
					ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nDownEleRow + nSheetHeight / 2) * GetPScale(), ptText);
					DrawText(ptText, csDownEle, AcGiDraw::kMiddleRight, dc, PI / 2);
				}
				else {
					ads_polar(ptCellS, m_nLayoutRotation - PI / 2, (nDownEleRow + nSheetHeight / 3) * GetPScale(), ptText);
					XPoint ptTmpText = ptText;
					if (i != 0) {
						ads_polar(ptText, m_nLayoutRotation + PI, GetPScale() * 2, ptTmpText);
						DrawText(ptTmpText, csFrontEle, AcGiDraw::kMiddleRight, dc, PI / 2);
					}
					if (i != m_lstFeedWell.Length() - 1) {
						ads_polar(ptText, m_nLayoutRotation, GetPScale() * 2, ptTmpText);
						DrawText(ptTmpText, csDownEle, AcGiDraw::kMiddleRight, dc, PI / 2);
					}
				}
			}

			ads_polar(ptCellS, m_nLayoutRotation - PI / 2, nSheetHeight * 12 * GetPScale(), ptText);
			int num(0);

			ptWell = ptText;
			SheetColumn column4;
			column4.SetWidth(nWidth / GetPScale());   //序号
			pSheet.SetColumnAt(idx, column4);
			idx++;

		}
		else if (!m_lstFeedWell[i].m_bIsWell) { //管
//			double dLenPipe = m_lstWell[i].m_nLength;
//			if(dLenPipe > 1000)// 7.0 管长用mm
//				dLenPipe = dLenPipe/1000.0;

			dPipeLen = m_lstFeedWell[i].m_nLength * dScaleX;
			nWidth = dPipeLen;
			if (m_lstFeedWell[i - 1].m_csName == _T("断管")) {
				nWidth = 20 * GetPScale();
				dPipeLen = 0;
			}

			iDn = m_lstFeedWell[i].m_iDn;
			CString csDn, csPipeLen, csI;
			csDn.Format(_T("%d"), iDn);
			csI = I2Str(m_lstFeedWell[i].m_nI * 1000);
			csPipeLen.Format(_T("%.2f"), m_lstFeedWell[i].m_nLength);
			if (iDnRow > -1) {
				GridCell &cell21 = *(pSheet)(iDnRow, idx);
				cell21.SetText(csDn);
			}
			if (iPipeLenRow > -1) {
				GridCell &cell22 = *(pSheet)(iPipeLenRow, idx);
				cell22.SetText(csPipeLen);
			}
			if (iGradientRow > -1) {
				GridCell &cell23 = *(pSheet)(iGradientRow, idx);
				cell23.SetText(csI);
			}

			if (iDemoRow > -1 && i > 1 && m_lstFeedWell[i - 1].m_bIsDropWell && m_iCalcMode != 3) {
				GridCell &cell24 = *(pSheet)(iDemoRow, idx);
				double nDrop = m_lstFeedWell[i - 1].m_nDownEle - m_lstFeedWell[i - 1].m_nFrondDownEle;
				cell24.SetText(XString(_T("跌落%.2f米"), fabs(nDrop)));
				GridStyle gridStyle2;
				gridStyle2.SetOverrideAll(TRUE);
				gridStyle2.SetHorMode(AcDb::kTextLeft);
				gridStyle2.SetTextHeight(m_dTextHeight);
				cell24.SetGridStyle(gridStyle2);
			}

		}

	}


	for (int j = 0; j < lstHead.Length(); j++) {
		GridCell &cell = *(pSheet)(j, 0);
		CString csHead = lstHead[j];
		if (csHead == _T("管标高（m）")) {
			if (m_iCalcMode == 3)
				cell.SetText(_T("管中标高（m）"));
			else
				cell.SetText(_T("管内底标高（m）"));
		}
		else
			cell.SetText(csHead);

		if (csHead.Find(_T("设计地面标高")) > -1 || csHead.Find(_T("埋设深度")) > -1 || csHead.Find(_T("自然地面标高")) > -1
			|| csHead.Find(_T("覆土厚度")) > -1 || csHead.Find(_T("管标高（m）")) > -1 || csHead.Find(_T("管线平面")) > -1) {
			SheetRow *row = pSheet.GetRow(j);
			row->SetRowHeightStyle(SheetRow::kFree);
			row->SetHeight(nSheetHeight * 2);
		}
		if (csHead.Find(_T("设计地面标高")) > -1 || csHead.Find(_T("埋设深度")) > -1
			|| csHead.Find(_T("桩号")) > -1 || csHead.Find(_T("管道基础")) > -1 || csHead.Find(_T("自然地面标高")) > -1
			|| csHead.Find(_T("管材")) > -1 || csHead.Find(_T("管线平面")) > -1 || csHead.Find(_T("井径（mm）")) > -1
			|| csHead.Find(_T("覆土厚度")) > -1 || csHead.Find(_T("井编号")) > -1 || csHead.Find(_T("管标高")) > -1) {
			if (bBreak2 || bBreak1) {
				pSheet.MergeCells(j, 1, j, m_lstFeedWell.Length() / 2 + 1);
			}
			else {
				pSheet.MergeCells(j, 1, j, m_lstFeedWell.Length() / 2 + 2);
			}
		}
	}

	//绘制管线平面  sr add 2007-8-17
	if (iPipePlanRow > -1) {
		XPoint ptS;
		ptS = pSheet.GetCellPoint(iPipePlanRow, 1);
		ads_polar(ptS, m_nLayoutRotation + PI / 2, -nSheetHeight * GetPScale(), ptS);
		ads_polar(ptS, m_nLayoutRotation, 20 * GetPScale(), ptS);

		for (int i = 0; i < m_lstFeedWell.Length(); i++) {
			AcDbObjectId id = m_lstFeedWell[i].m_ID;
			if (m_lstFeedWell[i].m_bIsWell) {     //井
				OPENOBJ_BEGIN(id, AcDb::kForRead, AecXDbWell, pEquip);
				if (pEquip) {
					AcDbObjectId eqId = pEquip->GetBlock2d();
					CString csBlkName = GlobalFunc::GetSymbolName(eqId);
					OPENOBJ_BEGIN(eqId, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
					if (pBlock) {
						AcGeScale3d scale(pEquip->GetScale() * GetPScale(), pEquip->GetScale() * GetPScale(), pEquip->GetScale() * GetPScale());
						dc.DrawBlock(*pBlock, ptS, scale, 0, TRUE);
					}
					OPENOBJ_END();
				}
				OPENOBJ_END();
				//	idx++;
			}
			else if (!m_lstFeedWell[i].m_bIsWell) {//管
				XPoint ptTmp1, ptTmp2;
				dPipeLen = m_lstFeedWell[i].m_nLength * dScaleX;
				ptTmp1 = ptS;
				ads_polar(ptS, m_nLayoutRotation, dPipeLen, ptS);
				ptTmp2 = ptS;
				AcDbObjectId id2 = m_lstFeedWell[i - 1].m_ID;
				OPENOBJ_BEGIN(id2, AcDb::kForRead, AecXDbWell, pEquip);
				if (pEquip) {
					if (pEquip->IsHidePipe()) {
						double dScale = pEquip->GetScale() * GetPScale();
						ads_polar(ptTmp1, m_nLayoutRotation, dScale / 2, ptTmp1);
					}
				}
				OPENOBJ_END();

				AcDbObjectId id3 = m_lstFeedWell[i + 1].m_ID;
				OPENOBJ_BEGIN(id3, AcDb::kForRead, AecXDbWell, pEquip);
				if (pEquip) {
					if (pEquip->IsHidePipe()) {
						double dScale = pEquip->GetScale() * GetPScale();
						ads_polar(ptTmp2, m_nLayoutRotation, -dScale / 2, ptTmp2);
					}
				}
				OPENOBJ_END();
				DrawLine(ptTmp1, ptTmp2, dc);

				// 绘制给水管道中间的支路 sr add 2008-7-8
				int iPipeLen = m_lstFeedWell[i].m_lstID.Length();
				XPoly2D poly;
				AcDbObjectIdArray  idArray;
				for (int j = 0; j < iPipeLen; j++) {
					AcDbObjectId idPipe = m_lstFeedWell[i].m_lstID[j];
					OPENOBJ_BEGIN(idPipe, AcDb::kForRead, CDbPipe, pPipe);
					if (pPipe) {
						AcDbObjectId idNode1 = pPipe->GetNode(0);
						AcDbObjectId idNode2 = pPipe->GetNode(1);
						AppendIdArray(idArray, idNode1);
						AppendIdArray(idArray, idNode2);
						XCurveSegment seg = *pPipe;
						seg.SetElevation(0);
						if (j == iPipeLen - 1)
							poly.AppendSegment(seg, 0, 1);
						else
							poly.AppendSegment(seg);
					}
					OPENOBJ_END();

				}
				AcDbPolyline pline;
				GlobalFunc::PolyConvert(poly, pline);
				int iNodeLen = idArray.length();
				for (j = 0; j < iNodeLen; j++) {
					AcDbObjectId idNode = idArray[j];
					double dDist2Well(0);
					//OPENOBJ_BEGIN(idNode, AcDb::kForRead, TDbPipeFitting, pNode);
					//if (pNode) {
					//	XPoint ptLoc = pNode->GetLocation();
					//	ptLoc.z = 0;//仅算投影距离
					//	pline.getDistAtPoint(ptLoc, dDist2Well);
					//}
					//OPENOBJ_END();
					if (!GlobalFunc::DocGetMeterUnitDraw())
						dDist2Well = dDist2Well / 1000.0; //转换为米
					XPoint ptPipe1, ptPipe2;
					ads_polar(ptTmp1, m_nLayoutRotation, dDist2Well * dScaleX, ptPipe1);
					ads_polar(ptPipe1, m_nLayoutRotation + PI / 2, nSheetHeight * GetPScale() / 2.0, ptPipe2);
					DrawLine(ptPipe1, ptPipe2, dc);
				}

			}
		}
	}

	XPoint ptBase = pSheet.GetTopLeft(FALSE);
	//if (dc.IsFullExplode()) //炸开时，以防多绘制一遍文字
	//	pSheet.DrawCellText(ptBase, dc, nGsMarker);
	//if (dc.IsFullExplode())
	//	pSheet.ExplodeOrDraw2d(dc);
	//else
	//	dc.DrawEntity(pSheet);
	DrawBaseEx(dc, pSheet);

	return Acad::eOk;

}


void CDbVerticalSection::GetAllPipes(DList<AcDbObjectId> &lstAllPipe) const
{
	// cet 2016.7.6 add 纵断面图上的管道
	std::set<AcDbObjectId> setId;
	for (int i = 0; i < m_lstWell.Length(); ++i)
	{
		setId.insert(m_lstWell[i].m_ID);
	}
	lstAllPipe.Reset();
	SHAcDbBlockTableRecPtr objMSpace;
	if (!objMSpace)
		return;
	AcDbBlockTableRecordIterator* pBlockIterator = NULL;
	Acad::ErrorStatus es = objMSpace.m_pBlockTableRec->newIterator(pBlockIterator);
	ASSERT(es == Acad::eOk && pBlockIterator != NULL);
	for (pBlockIterator->start(); !pBlockIterator->done(); pBlockIterator->step()) {
		AcDbEntity *pEntity = NULL;
		es = pBlockIterator->getEntity(pEntity, AcDb::kForRead);
		if (pEntity != NULL) {
			if (pEntity->isKindOf(CDbPipe::desc())) {
				AcDbObjectId id = pEntity->objectId();
				if (setId.count(id) == 0) // cet 2016.7.6 add 排除纵断面图上的管道
				{
					lstAllPipe.Append(new AcDbObjectId(id));
				}
			}
			pEntity->close();
		}
	}
	delete pBlockIterator;
	return;

}

Acad::ErrorStatus CDbVerticalSection::Draw2d(AcGiDraw &dc) const
{
	// cet 2016.10.17 add 图层关闭时，实体不显示，不进行绘制（打印时，也不会绘制）
	AcDbLayerTableRecordPointer player(this->layerId(), AcDb::kForRead);
	if (player.openStatus() == Acad::eOk && player->isOff())
	{
		return Acad::eOk;
	}
	assertReadEnabled();
	//if (g_bOsnapExpl)//不支持求交，速度太慢
	//	return Acad::eOk;
	InitPipeData(); // cet 2016.9.23 add 获得最新管道信息
	XPoint ptEnd;
	if (!!objectId())
		DrawScale(dc, ptEnd);

	if (m_iCalcMode >= 100)
		DrawSectionFromRight(dc); //雨污系统 从右往左
	else
		DrawSection(dc);          //雨污系统 从左往右

	if (!!objectId()) {
		if (m_iCalcMode == 3)
			DrawCivilSheetFeed(dc, ptEnd); //给水系统
		else
			DrawCivilSheet(dc, ptEnd);     //雨污系统		
	}
	return Acad::eOk;
}


void CDbVerticalSection::Calc()
{
	UpdateHidePipes(); // cet 2017.11.22 add 更新遮挡数据
	if (m_iCalcMode == 3) {
		CalcFeed();
		return;
	}
	InitPipeData(); // cet 2016.7.6 add 获得管道信息,
	int iCalcMode = m_iCalcMode;
	if (iCalcMode >= 100)
		iCalcMode -= 100;
	m_nMaxDeep = m_lstWell[0]->m_nUpEle;
	m_nMinDeep = m_lstWell[0]->m_nUpEle;

	double nDeepStart = m_nStartDeep;
	m_lstWell[0]->m_nDeep = nDeepStart;
	double dPipeLen(0), nI(0), nFrontPipeEle(0);
	double dEleStart = m_lstWell[0]->m_nUpEle;
	nDeepStart = dEleStart - nDeepStart;      //井底标高 = 起点井地面标高-最小埋深
	m_lstWell[0]->m_nDownEle = nDeepStart;
	for (int i = 0; i < m_lstWell.Length(); i++) {
		if (m_lstWell[i]->m_bIsWell) {     //井
			AcDbObjectId id = m_lstWell[i]->m_ID;
			if (dPipeLen > 0) {
				double nWellEle = m_lstWell[i]->m_nUpEle;
				double nWellDownEle = m_lstWell[i]->m_nDownEle;
				double nLastEnd = nDeepStart - nI * dPipeLen;
				double nFrontPipeDeep = nWellEle - nLastEnd; //埋深  地面－前管
				double nWellDeep = nWellEle - nWellDownEle;  //埋深  地面－井底
				nFrontPipeEle = nLastEnd;

				if (m_lstWell[i]->m_bIsDropWell) {
					nDeepStart = m_lstWell[i]->m_nDownEle;
					m_lstWell[i]->m_nFrondDownEle = nFrontPipeEle;
				}
				else {
					double nRadiusFront(0), nRadiusBack(0);
					nRadiusFront = m_lstWell[i - 1]->m_iDn;
					if (i != m_lstWell.Length() - 1)
						nRadiusBack = m_lstWell[i + 1]->m_iDn;
					double nDifference(0);
					if (nRadiusFront > 0 && nRadiusBack > 0) {//井前后管径差
						nDifference = (nRadiusBack - nRadiusFront) / 1000;
					}
					m_lstWell[i]->m_nFrondDownEle = nDeepStart - nI * dPipeLen;
					if (iCalcMode == 0)         //管顶平接
						nDeepStart = nDeepStart - nI * dPipeLen - nDifference;
					else if (iCalcMode == 1)    //管底平接
						nDeepStart = nDeepStart - nI * dPipeLen;
					else if (iCalcMode == 2)    //水面平接
						nDeepStart = nDeepStart - nI * dPipeLen - nDifference / 2;
				}
				/////////////////////////////////////////////////////////////////
				if (m_lstWell[i]->m_csName == _T("HC")) {
					m_lstWell[i]->m_nFrondDownEle = nDeepStart;

					//最小标高也要考虑化粪池，sr add 2007-516
					OPENOBJ_BEGIN(m_lstWell[i]->m_ID, AcDb::kForRead, CDbPool, pEquip);
					if (pEquip) {
						double dPoolEleDown = pEquip->GetBottomBanEle();
						if (fabs(dPoolEleDown) > 0.001 && dPoolEleDown < m_nMinDeep)
							m_nMinDeep = dPoolEleDown;
						if (pEquip->GetSpare() > 0.01)
							nDeepStart -= pEquip->GetSpare();
						else
							nDeepStart -= 0.1;//化粪池
					}
					OPENOBJ_END();
				}
				/////////////////////////////////////////////////////////////////

				m_lstWell[i]->m_nDownEle = nDeepStart;
				if (nDeepStart < m_nMinDeep)        //找出最小标高
					m_nMinDeep = nDeepStart;
				if (nWellEle > m_nMaxDeep)          //找出最大标高, 绘制Y比例尺
					m_nMaxDeep = nWellEle;
				nWellDeep = nWellEle - nDeepStart;
				m_lstWell[i]->m_nDeep = nWellDeep;
			}
		}
		else if (!m_lstWell[i]->m_bIsWell) { //管
			if (i == m_lstWell.Length() - 1)
				continue;
			dPipeLen = m_lstWell[i]->m_nLength;
			nI = m_lstWell[i]->m_nI;
			CString csPipeName = m_lstWell[i - 1]->m_csName + m_lstWell[i + 1]->m_csName;
		}
	}



	XPoint ptIns = m_ptIns;
	double dScaleY = m_iScaleY;
	double dScaleX = m_iScaleX;
	dScaleX = GetPScale() / dScaleX * 1000;
	dScaleY = GetPScale() / dScaleY * 1000;//转化为毫米
	if (m_iCalcMode < 100)	// 从左往右		原代码
		dEleStart = m_lstWell[0]->m_nUpEle;
	else					// 从右向左     王辉 添加 08-05-05
		dEleStart = m_lstWell[m_lstWell.Length() - 1]->m_nUpEle;

	XPoint ptStart, ptEnd;
	ptStart = ptIns;
	dPipeLen = 0;
	m_lstPt.Reset();
	m_lstPt.NewAppend(ptIns);


	double dLastEle = dEleStart;
	if (m_iCalcMode < 100)	// 从左往右
	{
		for (i = 0; i < m_lstWell.Length(); i++) {
			double nEle = m_lstWell[i]->m_nUpEle - dLastEle;//地面标高        
			if (m_lstWell[i]->m_bIsWell) {     //井
				if (dPipeLen > 0) {
					ads_polar(ptStart, m_nLayoutRotation, dPipeLen, ptEnd);
					ads_polar(ptEnd, m_nLayoutRotation + PI / 2, nEle * dScaleY, ptEnd);
					m_lstPt.NewAppend(ptEnd);
					ptStart = ptEnd;
					dLastEle = m_lstWell[i]->m_nUpEle;
					if (m_lstWell[i]->m_csName == _T("HC")) {
						OPENOBJ_BEGIN(m_lstWell[i]->m_ID, AcDb::kForRead, CDbPool, pEquip);
						if (pEquip) {
							double dPoolLength = pEquip->GetPoolLength();
							if (!GlobalFunc::DocGetMeterUnitDraw())
								dPoolLength = dPoolLength / 1000;
							ads_polar(ptStart, m_nLayoutRotation, dPoolLength * dScaleX, ptEnd);
							m_lstPt.NewAppend(ptStart); // cet 2016.5.9 add 化粪池需要考虑两点
							m_lstPt.NewAppend(ptEnd);
							ptStart = ptEnd;
						}
						OPENOBJ_END();
					}
				}
				else if (m_lstWell[i]->m_csName == _T("HC") && m_lstWell[0]->m_csName == _T("断管")) // cet 2016.5.9 add 存在断管
				{
					OPENOBJ_BEGIN(m_lstWell[i]->m_ID, AcDb::kForRead, CDbPool, pEquip);
					if (pEquip != NULL)
					{
						double dPoolLength = pEquip->GetPoolLength();
						if (!GlobalFunc::DocGetMeterUnitDraw())
							dPoolLength = dPoolLength / 1000;
						ads_polar(ptStart, m_nLayoutRotation, dPoolLength * dScaleX, ptEnd);
						m_lstPt.NewAppend(ptStart);
						m_lstPt.NewAppend(ptEnd);
						ptStart = ptEnd;
					}
					OPENOBJ_END();
				}
				dPipeLen = 0;
			}
			else if (!m_lstWell[i]->m_bIsWell) { //管
				dPipeLen = m_lstWell[i]->m_nLength * dScaleX;
				if (m_lstWell[i - 1]->m_csName == _T("断管"))
					dPipeLen = 0;
			}
		}
	}
	else			    	// 从右往左	
	{
		for (i = m_lstWell.Length() - 1; i >= 0; --i)
		{
			double nEle = m_lstWell[i]->m_nUpEle - dLastEle;//地面标高        
			if (m_lstWell[i]->m_bIsWell)
			{     //井
				if (dPipeLen > 0)
				{
					ads_polar(ptStart, m_nLayoutRotation, dPipeLen, ptEnd);
					ads_polar(ptEnd, m_nLayoutRotation + PI / 2, nEle * dScaleY, ptEnd);
					m_lstPt.NewAppend(ptEnd);
					ptStart = ptEnd;
					dLastEle = m_lstWell[i]->m_nUpEle;

					if (m_lstWell[i]->m_csName == _T("HC")) {
						OPENOBJ_BEGIN(m_lstWell[i]->m_ID, AcDb::kForRead, CDbPool, pEquip);
						if (pEquip) {
							double dPoolLength = pEquip->GetPoolLength();
							if (!GlobalFunc::DocGetMeterUnitDraw())
								dPoolLength = dPoolLength / 1000;
							ads_polar(ptStart, m_nLayoutRotation, dPoolLength * dScaleX, ptEnd);
							m_lstPt.NewAppend(ptStart); // cet 2016.5.9 add 化粪池需要考虑两点
							m_lstPt.NewAppend(ptEnd);
							ptStart = ptEnd;
						}
						OPENOBJ_END();

					}
				}
				else if (m_lstWell[i]->m_csName == _T("HC") && m_lstWell[m_lstWell.Length() - 1]->m_csName == _T("断管")) // cet 2016.5.9 add 存在断管
				{
					OPENOBJ_BEGIN(m_lstWell[i]->m_ID, AcDb::kForRead, CDbPool, pEquip);
					if (pEquip != NULL)
					{
						double dPoolLength = pEquip->GetPoolLength();
						if (!GlobalFunc::DocGetMeterUnitDraw())
							dPoolLength = dPoolLength / 1000;
						ads_polar(ptStart, m_nLayoutRotation, dPoolLength * dScaleX, ptEnd);
						m_lstPt.NewAppend(ptStart);
						m_lstPt.NewAppend(ptEnd);
						ptStart = ptEnd;
					}
					OPENOBJ_END();
				}
				dPipeLen = 0;
			}
			else if (!m_lstWell[i]->m_bIsWell)			//管
			{
				dPipeLen = m_lstWell[i]->m_nLength * dScaleX;
				if (m_lstWell[i + 1]->m_csName == _T("断管"))
					dPipeLen = 0;
			}
		}
	}


}

BOOL CDbVerticalSection::GetFeedWellListData(DList<TWellData> &lstWellSys, DList<TFeedWellData> &lstFeedWellSys)
{
	lstFeedWellSys.Reset();
	BOOL bRet = TRUE;
	int len = lstWellSys.Length();
	for (int i = 0; i < len; i++) {
		if (lstWellSys[i]->m_bIsWell) {
			TFeedWellData *pNewList = new TFeedWellData();
			pNewList->m_csName = lstWellSys[i]->m_csName;
			pNewList->m_iDn = lstWellSys[i]->m_iDn;
			pNewList->m_nLength = lstWellSys[i]->m_nLength;
			pNewList->m_nGroundEle = lstWellSys[i]->m_nGroundEle;
			pNewList->m_nUpEle = lstWellSys[i]->m_nUpEle;
			pNewList->m_nDownEle = lstWellSys[i]->m_nDownEle;
			pNewList->m_nFrondDownEle = lstWellSys[i]->m_nFrondDownEle;
			pNewList->m_nDeep = lstWellSys[i]->m_nDeep;
			pNewList->m_bIsWell = lstWellSys[i]->m_bIsWell;
			pNewList->m_bIsDropWell = lstWellSys[i]->m_bIsDropWell;;
			pNewList->m_nWellRadius = lstWellSys[i]->m_nWellRadius;
			pNewList->m_ID = lstWellSys[i]->m_ID;
			pNewList->m_nI = lstWellSys[i]->m_nI;
			pNewList->m_nSpare = lstWellSys[i]->m_nSpare;
			lstFeedWellSys.Append(pNewList);
		}
		else { //管线
			TFeedWellData *pNewList = new TFeedWellData();
			pNewList->m_csName = lstWellSys[i]->m_csName;
			pNewList->m_iDn = lstWellSys[i]->m_iDn;
			pNewList->m_nGroundEle = lstWellSys[i]->m_nGroundEle;
			pNewList->m_nUpEle = lstWellSys[i]->m_nUpEle;
			pNewList->m_nDownEle = lstWellSys[i]->m_nDownEle;
			pNewList->m_nFrondDownEle = lstWellSys[i]->m_nFrondDownEle;
			pNewList->m_nDeep = lstWellSys[i]->m_nDeep;
			pNewList->m_bIsWell = lstWellSys[i]->m_bIsWell;
			pNewList->m_bIsDropWell = lstWellSys[i]->m_bIsDropWell;;
			pNewList->m_nWellRadius = lstWellSys[i]->m_nWellRadius;
			pNewList->m_nI = lstWellSys[i]->m_nI;
			pNewList->m_nSpare = lstWellSys[i]->m_nSpare;
			pNewList->m_nLength = 0;
			int idx = i;
			while (idx < len) {
				AcDbSoftPointerId id = lstWellSys[idx]->m_ID;
				pNewList->m_nLength += lstWellSys[idx]->m_nLength;
				pNewList->m_lstID.Append(new AcDbSoftPointerId(id));
				i = idx;
				idx++;
				if (lstWellSys[idx]->m_bIsWell)
					break;
			}
			lstFeedWellSys.Append(pNewList);
		}
	}
	return bRet;
}

void CDbVerticalSection::CalcFeed()
{
	m_nMaxDeep = m_lstWell[0]->m_nUpEle;
	m_nMinDeep = m_lstWell[0]->m_nUpEle;
	for (int i = 0; i < m_lstWell.Length(); i++) {
		if (m_lstWell[i]->m_bIsWell) {     //井
			AcDbObjectId id = m_lstWell[i]->m_ID;

			double nWellEle = m_lstWell[i]->m_nUpEle;
			double nWellDownEle = m_lstWell[i]->m_nDownEle;

			if (nWellDownEle < m_nMinDeep)        //找出最小标高
				m_nMinDeep = nWellDownEle;
			if (nWellEle > m_nMaxDeep)          //找出最大标高, 绘制Y比例尺
				m_nMaxDeep = nWellEle;

		}
		else if (!m_lstWell[i]->m_bIsWell) { //管
			if (i == m_lstWell.Length() - 1)
				continue;
		}
	}

	XPoint ptIns = m_ptIns;
	double dScaleY = m_iScaleY;
	double dScaleX = m_iScaleX;
	dScaleX = GetPScale() / dScaleX * 1000;
	dScaleY = GetPScale() / dScaleY * 1000;//转化为毫米
	double nEleStart = m_lstFeedWell[0]->m_nUpEle;
	XPoint ptStart, ptEnd;
	ptStart = ptIns;
	double dPipeLen = 0;
	m_lstPt.Reset();
	m_lstPt.NewAppend(ptIns);
	for (i = 0; i < m_lstFeedWell.Length(); i++) {
		double nEle = m_lstFeedWell[i]->m_nUpEle - nEleStart;//地面标高        
		if (m_lstFeedWell[i]->m_bIsWell) {     //井
			if (dPipeLen > 0) {
				ads_polar(ptStart, m_nLayoutRotation, dPipeLen, ptEnd);
				//  ptEnd.y = ptIns.y;
				nEle = m_lstFeedWell[i]->m_nUpEle - m_lstFeedWell[i - 2]->m_nUpEle;     //井面标高
				ads_polar(ptEnd, m_nLayoutRotation + PI / 2, nEle * dScaleY, ptEnd);
				m_lstPt.NewAppend(ptEnd);
				ptStart = ptEnd;
			}
			dPipeLen = 0;
		}
		else if (!m_lstFeedWell[i]->m_bIsWell) { //管
			dPipeLen = m_lstFeedWell[i]->m_nLength * dScaleX;
			if (m_lstFeedWell[i - 1]->m_csName == _T("断管"))
				dPipeLen = 0;
		}
	}


}

void CDbVerticalSection::GetWellDatas(DList<TWellData>& lstWell) const
{
	int nCount = m_lstWell.Length();
	for (int i = 0; i < nCount; i++) {
		TWellData *pData = new TWellData;
		*pData = m_lstWell[i];
		lstWell.Append(pData);
	}
}

void CDbVerticalSection::SetWellDatas(DList<TWellData>& lstWell)
{
	assertWriteEnabled();
	m_lstWell.Reset();
	int nCount = lstWell.Length();
	for (int i = 0; i < nCount; i++) {
		TWellData *pData = new TWellData;
		*pData = *lstWell[i];//值拷贝
		m_lstWell.Append(pData);
	}
	if (m_iCalcMode == 3)//如果是给水系统，则重新构造链表
		GetFeedWellListData(m_lstWell, m_lstFeedWell);

}

//取动态属性显示数据
void CDbVerticalSection::GetTips(DList<ObjInfoUnit> &info) const
{
	info.Append(new ObjInfoUnit(_T("对象类型"), _T("纵断面图")));
}

void CDbVerticalSection::GetLine(XLine &line) const
{
	XPoint ptEnd;
	double dScaleY = m_iScaleY;
	double dScaleX = m_iScaleX;
	dScaleX = GetPScale() / dScaleX * 1000;
	dScaleY = GetPScale() / dScaleY * 1000;//转化为毫米

	XPoint ptStart;
	XPoint ptIns = m_ptIns;
	double nHighEle = m_nMaxDeep;
	double nLowEle = m_nMinDeep;
	double nEleStart = 0.0;
	if (m_iCalcMode < 100)	// 从左往右 原代码
		nEleStart = m_lstWell[0].m_nUpEle;
	else					// add by 王辉 08-05-05
		nEleStart = m_lstWell[m_lstWell.Length() - 1].m_nUpEle;
	//绘制比例尺
	int iHighEle = (int)(nHighEle + 1);
	int iLowEle = (int)nLowEle;
	if (fabs(nLowEle) > iLowEle && nLowEle < 0)
		iLowEle--;
	//2009-6-24 增加以下2句，
	if (fabs(nLowEle - iLowEle) < 0.2)   //如果最低标尺值距实际最低标高就差0.2米，最低标尺再降低1米
		iLowEle--;
	if (fabs(nHighEle - iHighEle) < 0.2) //如果最高标尺值距实际最高标高就差0.2米，最高标尺再提高1米
		iHighEle++;

	int iAllMeter = iHighEle - iLowEle;
	nHighEle = (double)iHighEle - nEleStart;
	ads_polar(ptIns, m_nLayoutRotation + PI, 20 * GetPScale(), ptStart);
	ads_polar(ptStart, m_nLayoutRotation + PI / 2, nHighEle * dScaleY, ptStart);

	//第一行比例尺
	XPoint ptText, ptFisrtStart, ptStart2, ptEnd2, pt1;
	ptFisrtStart = ptStart;
	ads_polar(ptStart, m_nLayoutRotation + PI, 3 * GetPScale(), ptText);
	ads_polar(ptStart, m_nLayoutRotation, GetAllPipeLen() + 20 * GetPScale(), pt1);
	double nHighEleTmp = (double)iHighEle;
	ads_polar(ptStart, m_nLayoutRotation + PI, 2 * GetPScale(), ptStart2);

	double nNum = 1 / m_nGridScale;
	double nGridScale = m_nGridScale;
	if (m_nGridScale < 0.01)
	{
		nNum = 1;
		nGridScale = 1;
	}

	for (int i = 0; i < iAllMeter * nNum; i++)
	{
		ads_polar(ptStart, m_nLayoutRotation - PI / 2, dScaleY / nNum, ptEnd);
		if (i % 2 == 0)
			ads_polar(ptStart, m_nLayoutRotation + PI, 1.5 * GetPScale(), ptStart2);
		else
			ads_polar(ptStart, m_nLayoutRotation + PI, 0.5 * GetPScale(), ptStart2);
		ads_polar(ptStart2, m_nLayoutRotation - PI / 2, dScaleY / nNum, ptEnd2);

		ads_polar(ptStart, m_nLayoutRotation + PI, 2 * GetPScale(), ptStart2);
		ads_polar(ptStart2, m_nLayoutRotation - PI / 2, dScaleY / nNum, ptEnd2);

		ads_polar(ptEnd, m_nLayoutRotation + PI, 3 * GetPScale(), ptText);
		nHighEleTmp = nHighEleTmp - nGridScale;
		ptStart = ptEnd;
		//绘制横网格
		if (m_nGridScale > 0.01)
		{
			ads_polar(ptEnd, m_nLayoutRotation, GetAllPipeLen() + 20 * GetPScale(), pt1);
		}
	}

	//绘制井中心线
	ads_polar(ptStart, m_nLayoutRotation - PI / 2, 10 * GetPScale(), ptStart);
	ads_polar(ptStart, m_nLayoutRotation, 10 * GetPScale(), ptEnd2);

	XLine lineButton(ptStart, ptEnd2); //底线
	line = lineButton;
}

void CDbVerticalSection::DimEle(const XPoint &ptCen, double dRadiusLong, double dRadiusShort, double dEle, CString &sText, bool bOnlyDimEle, AcGiDraw &dc) const
{
	XLine line;
	GetLine(line);
	XPoint pt;
	ptCen.Project(&line, pt);
	AcDbLine line2(ptCen, pt);

	AcDbEllipse ellipse;
	double ratio = dRadiusShort / dRadiusLong;
	XPoint ptTem;
	ads_polar(ptCen, m_nLayoutRotation + PI / 2, dRadiusLong, ptTem);
	AcGeVector3d majorAxis = ptTem.AsAcGePoint3d() - ptCen.AsAcGePoint3d();
	// cet 2016.7.5 add 长轴小于短轴
	if (dRadiusLong + 0.001 < dRadiusShort)
	{
		ads_polar(ptCen, m_nLayoutRotation, dRadiusShort, ptTem);
		majorAxis = ptTem.AsAcGePoint3d() - ptCen.AsAcGePoint3d();
		ratio = dRadiusLong / dRadiusShort;
	}
	ellipse.set(ptCen, AcGeVector3d::kZAxis, majorAxis, ratio);

	AcGePoint3dArray ptArr;
	line2.intersectWith(&ellipse, AcDb::kOnBothOperands, ptArr);
	if (ptArr.length() == 1)
	{
		// cet 2014.7.7 add 当标高处于line之下时标注位置不对，现加以调整
		int nFactor = 1;
		AcGeVector3d vtTemp = ptArr[0] - pt.AsAcGePoint3d();
		vtTemp.z = 0.0;
		vtTemp.normalize();
		AcGeTol tol;
		tol.setEqualVector(0.001);
		// cet 2014.7.16 modify 布局转角发生变化时，计算错误
		AcGeVector3d vtY = AcGeVector3d::kXAxis;
		vtY.rotateBy(m_nLayoutRotation + PI / 2, AcGeVector3d::kZAxis);
		if (vtTemp.isCodirectionalTo(-vtY, tol))
		{
			nFactor = -1;
			ptArr[0] += vtTemp * dRadiusLong * 2;
		}

		if (!bOnlyDimEle)
		{
			// 管线名称管径标注
			XPoint ptMid;
			Midpoint(pt, asDblArray(ptArr[0]), ptMid);
			AecXDbText text1;
			text1.SetPScale(GetPScale());
			text1.setLayer(m_idTextLayer);
			text1.SetStyleId(m_idTextStyle);
			text1.SetText(sText);
			text1.SetRotation(m_nLayoutRotation + PI / 2); // cet 2014.7.16 modify 考虑布局转角
			text1.SetLocation(ptMid);
			text1.SetHeight(m_dTextHeight);
			text1.SetAlignment(AcGiDraw::kMiddle);
			double dWidth = 0.0;
			text1.GetExtents(&dWidth, NULL);
			//if (dc.IsFullExplode())
			//{
			//	text1.ExplodeOrDraw2d(dc);
			//}
			//else
			//{
			//	dc.DrawEntity(text1);
			//}
			DrawBaseEx(dc, text1);

			// 直线
			double dLen = pt.Distance2d(ptArr[0]);
			AcGeVector3d vt = ptArr[0] - asPnt3d(pt);
			vt.normalize();
			XPoint pt2;
			pt2 = pt + vt * (dLen - dWidth) * 0.5;
			//  cet 2018.2.8 modify 调整直线图层
			//  dc << TGGeLine(pt, pt2);
			DrawGridLine(pt, pt2, dc);

			pt2 = ptArr[0] - vt * (dLen - dWidth) * 0.5;
			//  cet 2018.2.8 modify 调整直线图层
			//  dc << TGGeLine(asDblArray(ptArr[0]), pt2);
			DrawGridLine(ptArr[0], pt2, dc);
		}

		// 标高
		AcGeVector3d vt = ptArr[0] - asPnt3d(pt);
		vt.normalize();
		vt.rotateBy(-PI / 2 * nFactor, AcGeVector3d::kZAxis); // cet 2014.7.7 add 当标高处于line之下时标注位置不对，现加以调整
		XPoint pt3;
		pt3 = ptArr[0] + vt * 1000;
		if (GlobalFunc::DocGetMeterUnitDraw()) // cet 2011.6.30 add 
		{
			pt3 = ptArr[0] + vt * 10;
		}
		//  cet 2018.2.8 modify 调整直线图层
		//	dc << TGGeLine(pt3, asDblArray(ptArr[0]));
		DrawGridLine(pt3, ptArr[0], dc);
		CString sEle;
		sEle.Format(_T("%.3f"), dEle);
		AecXDbSymbElevation text;
		pt3 = ptArr[0] + vt * 500;
		if (GlobalFunc::DocGetMeterUnitDraw()) // cet 2011.6.30 add 
		{
			pt3 = ptArr[0] + vt * 5;
		}
		text.setLayer(m_idTextLayer);
		text.SetLocation(pt3);
		text.SetText(sEle);
		text.SetBaseLine(FALSE);
		text.SetLeader(FALSE);
		text.SetTextHeight(m_dTextHeight);
		text.SetTextStyleId(m_idTextStyle);
		text.SetLayoutRotation(GlobalFunc::Ucs2Wcs(0.0));

		AcDbIntArray indices;
		indices.append(1);
		AcGeVector3d vtOffset(0, -1, 0);
		vtOffset = GlobalFunc::Ucs2Wcs(vtOffset, TRUE); // cet 2011.6.30 add
		if (vtOffset.length() > g_Option::instance()._DIST_SNAP * 10)
		{
			vtOffset.normalize();
			double dScale = (2 * GlobalFunc::DocGetEleTriangleSize() + 0.5) * GlobalFunc::DocGetPScale();
			vtOffset *= dScale;
			text.moveGripPointsAt(indices, vtOffset);
		}

		text.SetLayoutRotation(m_nLayoutRotation);

		int nColor = dc.GetColor();
		dc.SetColor(3);
		text.SetPScale(this->GetPScale()); // cet 2016.11.3 add 缺少比例设置，导致图纸空间中实体大小发生变化
		//if (dc.IsFullExplode())
		//{
		//	text.ExplodeOrDraw2d(dc);
		//}
		//else
		//{
		//	dc.DrawEntity(text);
		//}
		DrawBaseEx(dc, text);
		dc.SetColor(nColor);
	}
}

void CDbVerticalSection::DimDist(const CString &sDim, const XPoint &ptStart, const XPoint &ptEnd, AcGiDraw &dc, int &nDist, const double dDeep, const double dLong, bool bFromRight) const
{
	// cet 2017.8.29 add 长度为0不标注
	if (fabs(_tstof(sDim)) < 0.0001)
	{
		return;
	}
	double d = m_iScaleY;
	double dScale = (50 / d);
	double dDist2Line = 2.3;
	if (m_nGridScale == 2.0)
	{
		dDist2Line = 4.3;
	}
	XLine line;
	GetLine(line);
	XPoint pt1, pt2;
	pt1 = line.GetStartPoint();
	pt2 = line.GetEndPoint();
	ads_polar(pt1, m_nLayoutRotation + PI / 2, (1 + (dDist2Line * dScale)) * (GlobalFunc::DocGetMeterUnitDraw() ? 10 : 1000), pt1);
	ads_polar(pt2, m_nLayoutRotation + PI / 2, (1 + (dDist2Line * dScale)) * (GlobalFunc::DocGetMeterUnitDraw() ? 10 : 1000), pt2);
	line.SetStartPoint(pt1);
	line.SetEndPoint(pt2);
	ptStart.Project(&line, pt1);
	ptEnd.Project(&line, pt2);
	AcGeVector3d vt = pt2 - pt1;
	if (bFromRight)
	{
		vt = pt1 - pt2;
	}

	double dFact = 0.0;
	if (dDeep < 0.001 || dDeep > 3.0)// 埋深与管线的距离不在合适的范围时，长度标注位置随管线
	{
		pt2 = ptEnd;
		if (dDeep < 0.001)
		{
			dFact = 0.8;
		}
		else
		{
			dFact = -0.8;
		}

		if (bFromRight)
		{
			pt1 = pt2 + vt;
		}
		else
		{
			pt1 = pt2 - vt;
		}
	}
	else
	{
		nDist++;
		dFact = nDist;
	}
	//  cet 2016.7.25 modify 转T3 T5 T6时，提示错误，更改标注方法
	// 	TDbDimension2 entDim;
	// 	entDim.setLayer(LAY_DIM);
	// 	entDim.SetLocation(pt1);
	// 	entDim.SetStyleId(InitDimStyle(DS_LINEAR));
	// 	entDim.SetRotation(m_nLayoutRotation);
	// 	entDim.SetLayoutRotation(m_nLayoutRotation); // cet 2014.7.16 add 考虑布局转角
	// 	entDim.AddSegment(pt2);
	// 	entDim.SetTextContent(0, sDim);
	//     entDim.SetDist2DimLine(-0.6 * dFact * (GlobalFunc::DocGetMeterUnitDraw() ? 10 : 1000), FALSE);
	// 	
	// 
	// 	int nIndex = dc.GetColor();
	// 	dc.SetColor(3);
	// 	if(dc.IsFullExplode())
	// 	{
	// 		entDim.ExplodeOrDraw2d(dc);
	// 	}
	// 	else
	// 	{
	// 		dc.DrawEntity(entDim);
	// 	}
	// 	dc.SetColor(nIndex);
	XPoint ptMid;
	Midpoint(pt1, pt2, ptMid);
	AecXDbText text;
	text.SetPScale(GetPScale());
	text.setLayer(m_idTextLayer);
	text.SetStyleId(m_idTextStyle);
	text.SetText(sDim);
	text.SetRotation(m_nLayoutRotation);
	text.SetHeight(m_dTextHeight);
	text.SetAlignment(AcGiDraw::kBottomCenter);
	double dWidth = 0.0, dHeight = 0.0;
	text.GetExtents(&dWidth, &dHeight);
	AcGeVector3d vtDir = AcGeVector3d::kXAxis;
	vtDir.rotateBy(m_nLayoutRotation + PI * 0.5, AcGeVector3d::kZAxis);
	double dOffset = dHeight * 0.3;
	text.SetLocation(ptMid + vtDir * dOffset);
	//if (dc.IsFullExplode())
	//{
	//	text.ExplodeOrDraw2d(dc);
	//}
	//else
	//{
	//	dc.DrawEntity(text);
	//}
	DrawBaseEx(dc, text);
	AcDbObjectId idLayerOld = dc.GetLayerId();
	dc.SetLayer(m_idSectLayer);
	int nIndex = dc.GetColor();
	int nNewColor = 3;
	dc.SetColor(nNewColor);
	//  cet 2018.2.8 modify 调整直线图层
	// 	dc << XLine(pt1, pt2);
	// 	dc << XLine(pt1 + vtDir * dHeight, pt1 - vtDir * dHeight);
	// 	dc << XLine(pt2 + vtDir * dHeight, pt2 - vtDir * dHeight);
	DrawGridLine(pt1, pt2, dc);
	DrawGridLine(pt1 + vtDir * dHeight, pt1 - vtDir * dHeight, dc);
	DrawGridLine(pt2 + vtDir * dHeight, pt2 - vtDir * dHeight, dc);
	double dLineWidth = 0.05 * GetPScale();
	vtDir.rotateBy(-PI * 0.25, AcGeVector3d::kZAxis);
	AcDbPolyline polyLine1, polyLine2;
	polyLine1.addVertexAt(0, (pt1 + vtDir * dHeight * 0.25).AsAcGePoint2d());
	polyLine1.addVertexAt(1, (pt1 - vtDir * dHeight * 0.25).AsAcGePoint2d());
	polyLine2.addVertexAt(0, (pt2 + vtDir * dHeight * 0.25).AsAcGePoint2d());
	polyLine2.addVertexAt(1, (pt2 - vtDir * dHeight * 0.25).AsAcGePoint2d());
	polyLine1.setConstantWidth(dLineWidth);
	polyLine2.setConstantWidth(dLineWidth);
	polyLine1.setLayer(m_idSectLayer);
	polyLine2.setLayer(m_idSectLayer);
	polyLine1.setColorIndex(nNewColor);
	polyLine2.setColorIndex(nNewColor);
	dc.DrawEntity(polyLine1);
	dc.DrawEntity(polyLine2);
	dc.SetColor(nIndex);
	dc.SetLayer(idLayerOld);
}

bool CDbVerticalSection::IsDimDist() const
{
	const EntityFields &fd = GetFields();
	Adesk::Boolean bVal = Adesk::kFalse;
	fd.GFD(_T("DIM_DIST"), bVal);
	return bVal == Adesk::kTrue ? true : false;
}

void CDbVerticalSection::SetDimDist(bool bDim)
{
	assertWriteEnabled();
	EntityFields &fd = Fields();
	fd.SFD(_T("DIM_DIST"), bDim ? Adesk::kTrue : Adesk::kFalse);
}

bool CDbVerticalSection::IsDimEle() const
{
	const EntityFields &fd = GetFields();
	Adesk::Boolean bVal = Adesk::kFalse;
	fd.GFD(_T("DIM_ELE"), bVal);
	return bVal == Adesk::kTrue ? true : false;
}

void CDbVerticalSection::SetDimEle(bool bDim)
{
	assertWriteEnabled();
	EntityFields &fd = Fields();
	fd.SFD(_T("DIM_ELE"), bDim ? Adesk::kTrue : Adesk::kFalse);
}

bool CDbVerticalSection::IsShowCrossPipe(TPipeSys::SysType sys) const
{
	int nDx = GetPipeIndex(sys);
	if (nDx == -1)
	{
		return false;
	}
	Adesk::UInt32 nCrossPipe = 0xffff;
	const EntityFields &fd = GetFields();
	fd.GFD(_T("ShowCrossPipe"), nCrossPipe);
	Adesk::UInt32 nTemp = 0x01;
	nTemp <<= nDx;
	return ((nCrossPipe & nTemp) > 0);
}

bool CDbVerticalSection::IsShowCrossPipe(const CString &sSysName) const
{
	const EntityFields &fd = GetFields();
	Adesk::Boolean bShow = Adesk::kFalse;
	fd.GFD(sSysName, bShow);
	return bShow == Adesk::kTrue ? true : false;
}

bool CDbVerticalSection::IsShowCrossPipe(const AcDbObjectId &idPipe) const
{
	bool bShow = false;
	CDbPipe *pPipe = NULL;
	acdbOpenObject(pPipe, idPipe, AcDb::kForRead);
	if (pPipe != NULL)
	{
		if (pPipe->HavePipeSystemName()) // 新版管道系统
		{
			bShow = IsShowCrossPipe(pPipe->GetPipeSystemName());
		}
		else // 旧版管道系统
		{
			bShow = IsShowCrossPipe(pPipe->GetSysType());
		}
		pPipe->close();
	}
	return bShow;
}

void CDbVerticalSection::SetShowCrossPipe(TPipeSys::SysType sys, bool bShow)
{
	int nDx = GetPipeIndex(sys);
	if (nDx == -1)
	{
		return;
	}
	Adesk::UInt32 nCrossPipe = 0;
	EntityFields &fd = Fields();
	fd.GFD(_T("ShowCrossPipe"), nCrossPipe);
	Adesk::UInt32 nTemp = 0x01;
	nTemp <<= nDx;
	if (bShow)
	{
		nCrossPipe |= nTemp;
	}
	else
	{
		nCrossPipe &= ~nTemp;
	}
	fd.SFD(_T("ShowCrossPipe"), nCrossPipe);
}

void CDbVerticalSection::SetShowCrossPipe(const CString &sSysName, bool bShow)
{
	assertWriteEnabled();
	EntityFields &fd = Fields();
	fd.SFD(sSysName, bShow ? Adesk::kTrue : Adesk::kFalse);
}

int CDbVerticalSection::GetPipeIndex(TPipeSys::SysType sys) const
{
	int nRet = -1;
	switch (sys)
	{
	case TPipeSys::kFeedWater:
	case TPipeSys::kFeedWater2:
	case TPipeSys::kFeedWater3:
	{
		nRet = 0;
		break;
	}
	case TPipeSys::kDirtWater:
	{
		nRet = 1;
		break;
	}
	case TPipeSys::kUselessWater:
	{
		nRet = 2;
		break;
	}
	case TPipeSys::kRainWater:
	{
		nRet = 3;
		break;
	}
	case TPipeSys::kUsedWater:
	case TPipeSys::kUsedWater2:
	case TPipeSys::kUsedWater3:
	{
		nRet = 4;
		break;
	}
	case TPipeSys::kFireFighting:
	case TPipeSys::kFireFighting2:
	case TPipeSys::kFireFighting3:
	{
		nRet = 5;
		break;
	}
	case TPipeSys::kOther:
	{
		nRet = 6;
		break;
	}
	}
	return nRet;
}

// cet 2013.3.1 add 获得池子名
CString CDbVerticalSection::GetPoolName(const AcDbObjectId &id) const
{
	CString sName;
	OPENOBJ_BEGIN(id, AcDb::kForRead, CDbPool, pPool);
	if (pPool != NULL)
	{
		sName = pPool->GetLabel();
	}
	OPENOBJ_END();
	return sName;
}

inline double CDbVerticalSection::OuterDn(const AcDbSoftPointerId &idPipe) const
{
	std::map<AcDbHandle, PIPEDATA>::const_iterator it = m_mapPipeData.find(idPipe.handle());
	if (it != m_mapPipeData.end())
	{
		return it->second.dOutDn;
	}
	return 0.0;
}

inline double CDbVerticalSection::InnerDn(const AcDbSoftPointerId &idPipe) const
{
	std::map<AcDbHandle, PIPEDATA>::const_iterator it = m_mapPipeData.find(idPipe.handle());
	if (it != m_mapPipeData.end())
	{
		return it->second.dInnerDn;
	}
	return 0.0;
}

inline void CDbVerticalSection::InitPipeData() const
{
	std::map<AcDbHandle, PIPEDATA> &mapData = const_cast<std::map<AcDbHandle, PIPEDATA>&>(m_mapPipeData);
	mapData.clear();
	for (int i = 0; i < m_lstWell.Length(); ++i)
	{
		if (m_lstWell[i].m_bIsWell) // cet 2016.9.23 add 
		{
			continue;
		}
		PIPEDATA data;
		data.dDn = m_lstWell[i].m_iDn; // cet 2016.9.23 add 
		InitPipeData(m_lstWell[i].m_ID, data);
		mapData[m_lstWell[i].m_ID.handle()] = data;
	}
}

inline void CDbVerticalSection::InitPipeData(const AcDbSoftPointerId &idPipe, PIPEDATA &node) const
{
	//  cet 2016.9.22 modify 读取计算数据,以便实现单独修改纵断面图数据而不影响管道实体（如单元修改管道管径，只对纵断面图产生影响，而不对管道进行任何修改）
	// 	OPENOBJ_BEGIN(idPipe, AcDb::kForRead, CDbPipe, pPipe);
	// 	if (pPipe != NULL)
	// 	{
	// 		node.dDn = pPipe->GetDnDiameter();
	// 		node.dOutDn = ((pPipe->OuterDn() > 0.001) ? pPipe->OuterDn() : node.dDn);
	// 		node.dPipeThick = pPipe->GetPipeThick();
	// 		node.dInnerDn = node.dOutDn - node.dPipeThick * 2;
	// 	}
	// 	OPENOBJ_END();
	AcDbHandle handle = idPipe.handle();
	TCHAR szHandle[256] = _T("");
	handle.getIntoAsciiBuffer(szHandle);
	CString sHandle = szHandle;
	node.dOutDn = node.dDn;
	node.dInnerDn = node.dDn;
	GetPipeOuterDnInnerDn(idPipe, node.dOutDn, node.dInnerDn);
	node.dPipeThick = (node.dOutDn - node.dInnerDn) * 0.5;
}

bool CDbVerticalSection::IsOnlyShowBranch() const
{
	assertReadEnabled();
	const EntityFields &fd = GetFields();
	Adesk::Boolean bFlag = Adesk::kTrue;
	fd.GFD(_T("ONLY_SHOW_BRANCH"), bFlag);
	return bFlag == Adesk::kTrue ? true : false;
}

void CDbVerticalSection::SetOnlyShowBranch(bool bShow)
{
	assertWriteEnabled();
	EntityFields &fd = Fields();
	fd.SFD(_T("ONLY_SHOW_BRANCH"), bShow ? Adesk::kTrue : Adesk::kFalse);
}

bool CDbVerticalSection::IsShowEqualEleBranch() const
{
	assertReadEnabled();
	const EntityFields &fd = GetFields();
	Adesk::Boolean bFlag = Adesk::kFalse;
	fd.GFD(_T("SHOW_EQUAL_ELEVATION_BRANCH"), bFlag);
	return bFlag == Adesk::kTrue ? true : false;
}

void CDbVerticalSection::SetShowEqualEleBranch(bool bShow)
{
	assertWriteEnabled();
	EntityFields &fd = Fields();
	fd.SFD(_T("SHOW_EQUAL_ELEVATION_BRANCH"), bShow ? Adesk::kTrue : Adesk::kFalse);
}

bool CDbVerticalSection::IsBrach(CDbPipe *pPipe, const AcDbObjectId &idMainLinked) const
{
	for (int i = 0; i < 2; ++i)
	{
		AcDbObjectId id = pPipe->GetNode(i);
		if (id == idMainLinked) // 主干一端连接的实体
		{
			continue;
		}
		// 判断管道另一端连接的实体类型
		OPENOBJ_BEGIN(id, AcDb::kForRead, CDbPipeNode, pEqup);
		if (pEqup != NULL)
		{
			return pEqup->isKindOf(AecXDbWell::desc()) || pEqup->isKindOf(CDbPool::desc());
		}
		OPENOBJ_END();
	}
	return false;
}

void CDbVerticalSection::UpdatePipeOuterDnInnerDn(const AcDbObjectId &id, double dOuterDn, double dInnerDn)
{
	assertWriteEnabled();
	AcDbHandle handle = id.handle();
	TCHAR szHandle[256] = _T("");
	handle.getIntoAsciiBuffer(szHandle);
	CString sHandle = szHandle;
	EntityFields &fd = Fields();
	fd.SFD(sHandle + _T("-outerDn"), dOuterDn);
	fd.SFD(sHandle + _T("-innerDn"), dInnerDn);
}

bool CDbVerticalSection::IsShowPipeEndNotLinkedPipe() const
{
	assertReadEnabled();
	const EntityFields &fd = GetFields();
	Adesk::Boolean bFlag = Adesk::kFalse;
	fd.GFD(_T("SHOW_PIPEEND_NOTLINKE_PIPE"), bFlag);
	return bFlag == Adesk::kTrue ? true : false;
}

void CDbVerticalSection::SetShowPipeEndNotLinkedPipe(bool bShow)
{
	assertWriteEnabled();
	EntityFields &fd = Fields();
	fd.SFD(_T("SHOW_PIPEEND_NOTLINKE_PIPE"), bShow ? Adesk::kTrue : Adesk::kFalse);
}

void CDbVerticalSection::GetPipeOuterDnInnerDn(const AcDbObjectId &id, double &dOuterDn, double &dInnerDn) const
{
	assertReadEnabled();
	const EntityFields &fd = GetFields();
	AcDbHandle handle = id.handle();
	TCHAR szHandle[256] = _T("");
	handle.getIntoAsciiBuffer(szHandle);
	CString sHandle = szHandle;
	fd.GFD(sHandle + _T("-outerDn"), dOuterDn);
	fd.GFD(sHandle + _T("-innerDn"), dInnerDn);
}

void CDbVerticalSection::ClearHidePipes()
{
	EntityFields &fd = Fields();
	Adesk::UInt16 nNum = 0;
	if (fd.GFD(_T("HidePipesNum"), nNum))
	{
		// 删除遮挡管道数参数
		long nIndex = fd.Find(_T("HidePipesNum"));
		if (nIndex != -1)
		{
			fd.Del(nIndex);
		}
		// 删除遮挡管道记录
		CString sIndex;
		CrossPoint crossTemp(AcDbObjectId::kNull);
		for (Adesk::UInt16 i = 0; i < nNum; ++i)
		{
			sIndex.Format(_T("HidePipe_%d"), i);
			crossTemp.DelCrossPoint(fd, sIndex);
		}
	}
}

void CDbVerticalSection::GetCrossPointInfo(std::vector<CrossPoint> &vecCrossPoint) const
{
	const EntityFields &fd = GetFields();
	Adesk::UInt16 nNum = 0;
	if (fd.GFD(_T("HidePipesNum"), nNum)) // 有交叉点数据
	{
		CString sKey;
		for (Adesk::UInt16 i = 0; i < nNum; ++i)
		{
			CrossPoint cr;
			sKey.Format(_T("HidePipe_%d"), i);
			cr.ReadCrossPoint(fd, sKey);
			vecCrossPoint.push_back(cr);
		}
	}
	else // 没有现成数据，计算获得
	{
		CDbVerticalSection *pVal = const_cast<CDbVerticalSection*>(this);
		if (pVal != NULL)
		{
			pVal->UpdateHidePipes();
		}
	}
}

void CDbVerticalSection::DrawHatch(AcGiDraw &dc, XPoly2D &ploy) const
{
	AcDbObjectId idOldLayer = dc.GetLayerId();
	dc.SetLayer(m_idGridLayer);
	//	cet 2018.2.8 modify 修改填充比例，颜色, 类型 
	//	dc.DrawHatch(ploy, _T("AR-HBONE"), 0.5*GetPScale());
	Adesk::UInt16 nOldColor = dc.GetColor();
	dc.SetColor(GetFillingColor());
	//dc.DrawHatch(ploy, GetFillingPattern(), GetFillingRatio() * GetPScale());
	DrawPoly2D(dc, ploy);
	dc.SetColor(nOldColor);
	dc.SetLayer(idOldLayer);
}

void InitDbVerticalSection(BOOL bTrue)
{
	if (bTrue) {
		CDbVerticalSection::rxInit();
		//CDbVerticalSection::InitMatchProtocol(TRUE);
	}
	else {
		//CDbVerticalSection::InitMatchProtocol(FALSE);
		deleteAcRxClass(CDbVerticalSection::desc());
	}
}