#include "stdafx.h"
#include "StdArx.h"
#include "dbproxy.h"
#include "AecDbEwPipeDim.h"
#include "AcGiExplodeDraw.h"
#include "dbgrip.h"
#include "AecGripCback.h"
#include "coretools.h"


const CString AecDbEwPipeDim::_Custom_No_R_ = L"_Custom_No_R_";

namespace
{
	void GetTextAlignment(const AcGiDraw::TextAlignment &align
		, AcDb::TextHorzMode &nHMode
		, AcDb::TextVertMode &nVMode)
	{
		// 对齐方式需要进行换算
		switch (align)
		{
		case AcGiDraw::kTopLeft:
			nHMode = AcDb::kTextLeft;
			nVMode = AcDb::kTextTop;
			break;
		case AcGiDraw::kTopCenter:
			nHMode = AcDb::kTextCenter;
			nVMode = AcDb::kTextTop;
			break;
		case AcGiDraw::kTopRight:
			nHMode = AcDb::kTextRight;
			nVMode = AcDb::kTextTop;
			break;
		case AcGiDraw::kMiddleLeft:
			nHMode = AcDb::kTextLeft;
			nVMode = AcDb::kTextVertMid;
			break;
		case AcGiDraw::kMiddleCenter:
			nHMode = AcDb::kTextCenter;
			nVMode = AcDb::kTextVertMid;
			break;
		case AcGiDraw::kMiddleRight:
			nHMode = AcDb::kTextRight;
			nVMode = AcDb::kTextVertMid;
			break;
		case AcGiDraw::kBottomLeft:
			nHMode = AcDb::kTextLeft;
			nVMode = AcDb::kTextBottom;
			break;
		case AcGiDraw::kBottomCenter:
			nHMode = AcDb::kTextCenter;
			nVMode = AcDb::kTextBottom;
			break;
		case AcGiDraw::kBottomRight:
			nHMode = AcDb::kTextRight;
			nVMode = AcDb::kTextBottom;
			break;
		case AcGiDraw::kLeft:
			nHMode = AcDb::kTextLeft;
			nVMode = AcDb::kTextBase;
			break;
		case AcGiDraw::kCenter:
			nHMode = AcDb::kTextCenter;
			nVMode = AcDb::kTextBase;
			break;
		case AcGiDraw::kRight:
			nHMode = AcDb::kTextRight;
			nVMode = AcDb::kTextBase;
		case AcGiDraw::kMiddle:
			nHMode = AcDb::kTextMid;
			nVMode = (AcDb::TextVertMode)0;
			break;
		default:
			nHMode = (AcDb::TextHorzMode)0;
			nVMode = (AcDb::TextVertMode)0;
			break;
		}
	}

	AcGiDraw::TextAlignment GetTextAlignment(const AcDb::TextHorzMode &nHMode, const AcDb::TextVertMode &nVMode)
	{
		AcGiDraw::TextAlignment nAlign;

		// 上
		if (nHMode == AcDb::kTextLeft && nVMode == AcDb::kTextTop)
		{
			nAlign = AcGiDraw::kTopLeft;
		}
		else if (nHMode == AcDb::kTextCenter && nVMode == AcDb::kTextTop)
		{
			nAlign = AcGiDraw::kTopCenter;
		}
		else if (nHMode == AcDb::kTextRight && nVMode == AcDb::kTextTop)
		{
			nAlign = AcGiDraw::kTopRight;
		}

		// 中
		else if (nHMode == AcDb::kTextLeft && nVMode == AcDb::kTextVertMid)
		{
			nAlign = AcGiDraw::kMiddleLeft;
		}
		else if (nHMode == AcDb::kTextCenter && nVMode == AcDb::kTextVertMid)
		{
			nAlign = AcGiDraw::kMiddleCenter;
		}
		else if (nHMode == AcDb::kTextRight && nVMode == AcDb::kTextVertMid)
		{
			nAlign = AcGiDraw::kMiddleRight;
		}

		// 下
		else if (nHMode == AcDb::kTextLeft && nVMode == AcDb::kTextBottom)
		{
			nAlign = AcGiDraw::kBottomLeft;
		}
		else if (nHMode == AcDb::kTextCenter && nVMode == AcDb::kTextBottom)
		{
			nAlign = AcGiDraw::kBottomCenter;
		}
		else if (nHMode == AcDb::kTextRight && nVMode == AcDb::kTextBottom)
		{
			nAlign = AcGiDraw::kBottomRight;
		}

		// 基线
		else if (nHMode == AcDb::kTextLeft && nVMode == AcDb::kTextBase)
		{
			nAlign = AcGiDraw::kLeft;
		}
		else if (nHMode == AcDb::kTextCenter && nVMode == AcDb::kTextBase)
		{
			nAlign = AcGiDraw::kCenter;
		}
		else if (nHMode == AcDb::kTextRight && nVMode == AcDb::kTextBase)
		{
			nAlign = AcGiDraw::kRight;
		}

		else if (nHMode == AcDb::kTextMid)
		{
			nAlign = AcGiDraw::kMiddle;
		}
		else    //kTextAlign, kTextFit
		{
			nAlign = AcGiDraw::kUnknown;
		}

		return nAlign;
	}

	void drawProxyEntity(const AcDbVoidPtrArray *pAr, AcGiWorldDraw *pWd)
	{
		if (!pAr) return;
		Adesk::UInt16 clr = pWd->subEntityTraits().color();
		AcDbObjectId layerID = pWd->subEntityTraits().layerId();
		for (int i = 0; i < pAr->length(); ++i)
		{
			AcDbEntity *pEnt((AcDbEntity *)pAr->at(i));
			if (pEnt->isKindOf(AcDbBlockReference::desc()))
			{
				AcDbBlockReference *pRef((AcDbBlockReference *)pEnt);
				AcDbBlockTableRecord *pRec(NULL);
				AcDbObject *pObj(NULL);
				AcDbEntity *pSubEnt(NULL);
				if (acdbOpenAcDbObject(pObj, pRef->blockTableRecord(), AcDb::kForRead) == Acad::eOk)
				{
					pRec = (AcDbBlockTableRecord *)pObj;
					AcDbBlockTableRecordIterator *pBlockIterator;
					pRec->newIterator(pBlockIterator, Adesk::kTrue, Adesk::kFalse);
					for (pBlockIterator->start(); !pBlockIterator->done(); pBlockIterator->step())
					{
						pBlockIterator->getEntity(pSubEnt, AcDb::kForWrite, Adesk::kTrue);
						pSubEnt->setColorIndex(pEnt->colorIndex());
						pSubEnt->setLayer(pEnt->layerId());
						pSubEnt->close();
					}
					pObj->close();
					delete pBlockIterator;
				}
			}
			pWd->subEntityTraits().setColor(pEnt->colorIndex());
			pWd->subEntityTraits().setLayer(pEnt->layerId());
			if (pEnt)
				pEnt->worldDraw(pWd);
		}
		pWd->subEntityTraits().setColor(clr);
		pWd->subEntityTraits().setLayer(layerID);
	}
}


//#define VERSION_TDBFITTINGBASE 1
// 增加了 m_mapSpecXData
#define VERSION_TDBFITTINGBASE 2
#define MESH_N 20
#define MESH_M 2

#define DIM_EL		_T("\\U+2200")
#define DIM_TOP_EL	_T("\\U+2201")
#define DIM_CEN_EL	_T("\\U+2202")
#define DIM_BOM_EL	_T("\\U+2203")

static const Adesk::UInt16 kBlue           = 5;

ACRX_DXF_DEFINE_MEMBERS( AecDbEwPipeDim
	, AecDbEntityBase
	, AcDb::kDHL_CURRENT
	, AcDb::kMReleaseCurrent
	, 1
	, AEC_EWPIPEDIM
	, "AecDbEwPipeDim | 缺乏解释器,图形看不见,请下载插件");

AecDbEwPipeDim::AecDbEwPipeDim(void)
{
	m_nStyle = 1;			//0: 引出标注  1: 在线标注 //2: 批量标注
	m_nDir = 0;				//0: 水平标注  1: 垂直标注
	m_nDimText = 0;			//0: 只标上标  1: 上下标

	m_sUpScr = _T("");		//上标脚本
	m_sDownScr = _T("");	//下标脚本

	m_dTextH = 2.5;			//打印纸面字高度 2.5
	m_dWScale = 0.75;			//打印纸面字宽度 1
	m_dD = 100;			    //上下标的间隙,在线标注用到
	m_pGripAppData = new AecGripData[9];
}

AecDbEwPipeDim::~AecDbEwPipeDim(void)
{
}

void AecDbEwPipeDim::AddAecDbWEntity(const AcDbObjectId& idObj)
{
	AssertWriteEnabled();
	m_aridAttachs.append(idObj);
}

AcDbObjectId AecDbEwPipeDim::GetAecDbWEntity(int nIndex)
{
	assertReadEnabled();
	if (nIndex > -1 && nIndex < m_aridAttachs.length() )
	{
		return m_aridAttachs.at(nIndex);
	}
	return AcDbObjectId::kNull;
}

int  AecDbEwPipeDim::GetAecDbWEntityCount()
{
	assertReadEnabled();
	return m_aridAttachs.length();
}

void AecDbEwPipeDim::SetDimStyle(short nStyle)
{
	AssertWriteEnabled();
	m_nStyle = nStyle;
}

short AecDbEwPipeDim::GetDimStyle()
{
	assertReadEnabled();
	return m_nStyle;
}

void AecDbEwPipeDim::SetDimDir(short nDir)
{
	AssertWriteEnabled();
	m_nDir = nDir;
}

short AecDbEwPipeDim::GetDimDir()
{
	assertReadEnabled();
	return m_nDir;
}

void AecDbEwPipeDim::SetDimTextUporDownFlag(short nDimText)
{
	AssertWriteEnabled();
	m_nDimText = nDimText;
}

short AecDbEwPipeDim::GetDimTextUporDownnFlag()
{
	assertReadEnabled();
	return m_nDimText;
}

void AecDbEwPipeDim::SetISODim(short nIsISO)
{
	AssertWriteEnabled();
	m_nIsISO = nIsISO;
}

short AecDbEwPipeDim::IsISODim()
{
	assertReadEnabled();
	return m_nIsISO;
}

void AecDbEwPipeDim::SetTextStyleId(AcDbObjectId& idStyle)
{
	AssertWriteEnabled();
	m_idTextSty = idStyle;
}

AcDbObjectId AecDbEwPipeDim::GetTextStyleId()
{
	assertReadEnabled();
	return m_idTextSty;
}

void AecDbEwPipeDim::SetTextLayerId(AcDbObjectId id)
{
	AssertWriteEnabled();
	m_idTextLayer = id;
}

AcDbObjectId AecDbEwPipeDim::GetTextLayerId()
{
	assertReadEnabled();
	return m_idTextLayer;
}

void AecDbEwPipeDim::AddDimText(LPCTSTR pszUp,LPCTSTR pszDown)
{
	AssertWriteEnabled();
	if (pszUp != NULL)
	{
		m_arsUps.Add(pszUp);
	}
	if (pszDown != NULL)
	{
		m_arsDowns.Add(pszDown);
	}
}

void AecDbEwPipeDim::RemoveAt(int nPos,int nIndex)
{
	AssertWriteEnabled();
	if (nPos == -1)
	{
		if (nIndex > -1 && nIndex < m_arsDowns.GetSize())
		{
			m_arsDowns.RemoveAt(nIndex);
		}
	}
	else
	{
		if (nIndex > -1 && nIndex < m_arsUps.GetSize())
		{
			m_arsUps.RemoveAt(nIndex);
		}
	}
}

void AecDbEwPipeDim::RemoveAll(int nPos)
{
	AssertWriteEnabled();
	if (nPos == -1)
	{
		m_arsDowns.RemoveAll();
	}
	else
	{
		m_arsUps.RemoveAll();
	}
}

void AecDbEwPipeDim::GetDimText(int nIndex,CString& sUp,CString& sDown)
{
	assertReadEnabled();

	if (nIndex > -1 && nIndex < m_arsUps.GetSize() )
	{
		sUp = m_arsUps.GetAt(nIndex);
	}
	if (nIndex > -1 && nIndex < m_arsDowns.GetSize() )
	{
		sDown = m_arsDowns.GetAt(nIndex);
	}
}

void AecDbEwPipeDim::SetDimupScript(LPCTSTR pszUpScr)
{
	AssertWriteEnabled();
	m_sUpScr = pszUpScr;
}

void AecDbEwPipeDim::GetDimupScript(CString& sUpScr)
{
	assertReadEnabled();
	sUpScr = m_sUpScr;
}

void AecDbEwPipeDim::SetDimdownScript(LPCTSTR pszDownScr)
{
	AssertWriteEnabled();
	m_sDownScr = pszDownScr;
}

void AecDbEwPipeDim::GetDimdownScript(CString& sDownScr)
{
	assertReadEnabled();
	sDownScr = m_sDownScr;
}

double AecDbEwPipeDim::GetTextHeight()
{
	assertReadEnabled();
	return m_dTextH;
}

void AecDbEwPipeDim::SetTextHeight(double dH)
{
	AssertWriteEnabled();
	m_dTextH = dH;
}

double AecDbEwPipeDim::GetTextWidthScale()
{
	assertReadEnabled();
	return m_dWScale;
}

void AecDbEwPipeDim::SetTextWidthScale(double dScale)
{
	AssertWriteEnabled();
	m_dWScale = dScale;
}

void AecDbEwPipeDim::AppendPoint(AcGePoint3d& pt)
{
	AssertWriteEnabled();
	m_arPoints.append(pt);
}

void AecDbEwPipeDim::AppendNoPoint(AcGePoint3d& pt)
{
	AssertWriteEnabled();
	m_arNoPoints.append(pt);
}

void AecDbEwPipeDim::UpdateFromParam()
{
	
}

void AecDbEwPipeDim::SetDimupdownSpace(double dD)
{
	AssertWriteEnabled();
	m_dD = dD;
}

Acad::ErrorStatus AecDbEwPipeDim::Draw2d(AcGiDraw &dc) const
{
	assertReadEnabled();

	dc.SetTextStyle(m_idTextSty);
	dc.SetLayer(m_idTextLayer);

	if (Has2DBuffer())
	{
		const AcDbVoidPtrArray &Ar = Get2DBuffer();

		Adesk::UInt16 oldClr = dc.GetColor();
		Adesk::UInt16 newClr;
		for (int i = 0; i < Ar.length(); ++i)
		{
			const AcDbEntity *pEnt = (AcDbEntity *)Ar.at(i);
			dc.DrawEntity(*pEnt);
		}
		dc.SetColor(oldClr);
		return Acad::eOk;
	}

	switch (m_nStyle)
	{
	case 0: //引出标注
		{
			DrawLeaderDim(dc);
			break;
		}
	case 1: //在线标注
		{
			DrawOnlineDim(dc);
			break;
		}
	case 2: //批量标注
		{
			DrawPolylineDim(dc);
			break;
		}
	case 3: //序号标注
		{
			DrawSNo(dc);
			break;
		}
	case 4: //引出多行带框标注---桥架用
		{
			DrawMBoxLineLdDim(dc);
			break;
		}
	default:
		break;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEwPipeDim::DrawLeaderDim(AcGiDraw &dc) const
{
	if (m_arPoints.length() < 2 )
	{
		return Acad::eInvalidInput;
	}

	if (m_arsUps.IsEmpty() && m_arsDowns.IsEmpty()) return Acad::eInvalidInput;

	double len(.0);

	AcGePoint3d ptFr = m_arPoints.first();
	AcGePoint3d ptTo = m_arPoints.at(1);
	CString sDimUp =_T("");
	CString sDimDown = _T("");
	dc.SetLayer(layerId());
	//dc.DrawLine(AcGeLineSeg3d(ptFr,ptTo));
	AcDbLine *pLine(new AcDbLine(ptFr,ptTo));
	if (pLine)
	{
		pLine->setLayer(layerId());
		Add2DBuffer(pLine);
		dc.DrawEntity(*pLine);
	}

	//绘制点
	MakeWDot(dc, ptFr);

	AcGeVector3d vtDir = ptTo - ptFr;

	// 得到引线长度
	CString sUp(_T("")), sDown(_T(""));
	if (!m_arsUps.IsEmpty()) sUp = m_arsUps[0];
	if (!m_arsDowns.IsEmpty()) sDown = m_arsDowns[0];

	CString sLeft(_T("")), sRight(_T(""));
	short elType(-1);
	ParseDownString(sDown, elType, sLeft, sRight);
	//if (sLeft.IsEmpty())
	//	sLeft = sDown;

	double d1 = UnderLineLength(sUp);

	double d2 = UnderLineLength(sLeft + sRight) + m_dTextH * m_dPScale;
	if (sLeft.IsEmpty() && sRight.IsEmpty())
		d2 = UnderLineLength(sDown);

	if (sUp.IsEmpty())
		d1 = UnderLineLength(sDown);

	double dLenderLen = d1 > d2 ? d1 : d2;

	// 得到引线的方向,和文字位置
	AcGePoint3d ptPosUp = ptTo;
	AcGePoint3d ptPosDw = ptPosUp;
	AcGeVector3d vtLeader(AcGeVector3d::kIdentity);
	AcGeVector3d vtText(AcGeVector3d::kIdentity);
	if (m_nDir == 0)
	{
		vtText = AcGeVector3d::kXAxis;
		if (vtDir.x < 1.e-10)
		{
			vtLeader = -AcGeVector3d::kXAxis;
			ptPosUp = ptTo + vtLeader * dLenderLen;
		}
		else
		{
			vtLeader = AcGeVector3d::kXAxis;
		}
		ptPosUp += AcGeVector3d::kYAxis * .1;
		ptPosDw = ptPosUp - AcGeVector3d::kYAxis * .2;
	}
	else
	{
		vtText = AcGeVector3d::kYAxis;
		if (vtDir.y < 1.e-10)
		{
			vtLeader = -AcGeVector3d::kYAxis;
			ptPosUp = ptTo + vtLeader * dLenderLen;
		}
		else
		{
			vtLeader = AcGeVector3d::kYAxis;
		}
		ptPosUp -= AcGeVector3d::kXAxis * .1;
		ptPosDw = ptPosUp + AcGeVector3d::kXAxis * .2;
	}

	// 绘制引线
	//dc.DrawLine(AcGeLineSeg3d(ptTo, ptTo + vtLeader * dLenderLen));
	pLine = new AcDbLine(ptTo, ptTo + vtLeader * dLenderLen);
	if (pLine)
	{
		pLine->setLayer(layerId());
		Add2DBuffer(pLine);
		dc.DrawEntity(*pLine);
	}

	// 绘制上文字
	TextEx(dc, AcGiDraw::kBottomLeft, ptPosUp, vtText, sUp, len);
	if (/*m_nDimText != 0 &&*/ !sDown.IsEmpty())//允许下标
	{
		len = 0.0;
		if (!sDown.IsEmpty())
		TextEx(dc, AcGiDraw::kTopLeft, ptPosDw, vtText, sDown, len,-1);

		/*if (elType > -1)//有标高 不用标高字体自画
		{
			ptPosDw += vtText * len;
			DrawEl(dc
				, (ptPosDw + (m_nDir == 0 ? -AcGeVector3d::kYAxis : AcGeVector3d::kXAxis) * m_dTextH * m_dPScale)
				, m_nDir == 0 ? .0 : (PI * .5)
				, elType
				, m_dTextH * m_dPScale,-1);

			ptPosDw += vtText * m_dTextH * m_dPScale;
			TextEx(dc, AcGiDraw::kTopLeft, ptPosDw, vtText, sRight, len,-1);
		}*/
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEwPipeDim::MakeWDot(AcGiDraw &dc,AcGePoint3d &ptGeCen) const
{
	//打印点 0.25
	double dPlotDotD = 0.25 * m_dPScale;

	double dDotRadius = dPlotDotD * 0.5;
	AcGePoint2d ptGeCenDot = ptGeCen.convert2d(AcGePlane::kXYPlane);
	AcGePoint2d ptGe[4];
	double dBulge = tan(PI / 8.0);

	ptGe[0] = ptGeCenDot + dDotRadius * AcGeVector2d::kYAxis;
	ptGe[1] = ptGeCenDot + dDotRadius * AcGeVector2d::kXAxis;
	ptGe[2] = ptGeCenDot - dDotRadius * AcGeVector2d::kYAxis;
	ptGe[3] = ptGeCenDot - dDotRadius * AcGeVector2d::kXAxis;

	AcDbPolyline *pDot = new AcDbPolyline;
	pDot->addVertexAt(0, ptGe[0], -dBulge);
	pDot->addVertexAt(1, ptGe[1], -dBulge);
	pDot->addVertexAt(2, ptGe[2], -dBulge);
	pDot->addVertexAt(3, ptGe[3], -dBulge);
	pDot->addVertexAt(4, ptGe[0], 0.0);
	pDot->setConstantWidth(dPlotDotD);
	pDot->setClosed(Adesk::kTrue);
	pDot->setNormal(AcGeVector3d::kZAxis);
	
	Add2DBuffer(pDot);
	dc.DrawEntity(*pDot);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbEwPipeDim::DrawMBoxLineLdDim(AcGiDraw& dc) const
{
	if (m_arPoints.length() != 3)
	{
		return Acad::eInvalidInput;
	}

	if (m_arsUps.IsEmpty()) return Acad::eInvalidInput;

	double len(.0);

	AcGePoint3d ptFr = m_arPoints.first();
	AcGePoint3d ptTo = m_arPoints.at(1);
	AcGePoint3d ptDir = m_arPoints.last();
	CString sDimUp = _T("");
	CString sDimDown = _T("");
	dc.SetLayer(layerId());
	//dc.DrawLine(AcGeLineSeg3d(ptFr,ptTo));
	AcDbLine *pLine(new AcDbLine(ptFr, ptTo));
	if (pLine)
	{
		pLine->setLayer(layerId());
		Add2DBuffer(pLine);
		dc.DrawEntity(*pLine);
	}

	//绘制点
	MakeWDot(dc,ptFr);

	//
	AcGeVector3d vtDir = ptDir - ptTo;
	double dLenderLen = 0;
	AcGePoint3d ptPosUp;
	AcGeVector3d vtLeader, vtText,vtV;
	AcGePoint2d ptTxtBox;
	AcGePoint3d ptGe[4];

	// 得到引线长度
	CString sUp(_T("")), sDown(_T(""));
	for (int i = 0;i < m_arsUps.GetSize();i++)
	{
		sUp = m_arsUps.GetAt(i);

		ptTxtBox = DimTextExtent(sUp);
		dLenderLen = ptTxtBox.x;
		dLenderLen += (0.5 * m_dTextH * m_dPScale);//加上半个字高

		ptPosUp = ptTo;

		//得到引线的方向,和文字位置
		vtLeader = AcGeVector3d::kIdentity;
		vtText = AcGeVector3d::kIdentity;

		if (m_nDir == 0)
		{
			vtText = AcGeVector3d::kXAxis;
			if (vtDir.x < 1.e-10)
			{
				vtLeader = -AcGeVector3d::kXAxis;
				ptPosUp = ptTo + vtLeader * dLenderLen;
			}
			else
			{
				vtLeader = AcGeVector3d::kXAxis;
			}
			ptPosUp += AcGeVector3d::kYAxis * .1;
		}
		else
		{
			vtText = AcGeVector3d::kYAxis;
			if (vtDir.y < 1.e-10)
			{
				vtLeader = -AcGeVector3d::kYAxis;
				ptPosUp = ptTo + vtLeader * dLenderLen;
			}
			else
			{
				vtLeader = AcGeVector3d::kYAxis;
			}
			ptPosUp -= AcGeVector3d::kXAxis * .1;
		}

		vtV = vtLeader;
		vtV.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
		vtV.normalize();

		// 绘制引线 U 型线
		ptGe[0] = ptTo + vtV * ptTxtBox.y;
		ptGe[1] = ptTo;
		ptGe[2] = ptTo + vtLeader * dLenderLen;
		ptGe[3] = ptGe[2] + vtV * ptTxtBox.y;
		
		ptGe[0] += vtV * 0.5 * m_dTextH * m_dPScale;//文字有0.4空隙
		ptGe[3] += vtV * 0.5 * m_dTextH * m_dPScale;//文字有0.4空隙

		for (int ii = 0;ii < 3;ii++)
		{
			pLine = new AcDbLine(ptGe[ii], ptGe[ii+1]);
			if (pLine)
			{
				pLine->setLayer(layerId());
				Add2DBuffer(pLine);
				dc.DrawEntity(*pLine);
			}
		}

		// 绘制上文字
		TextEx(dc, AcGiDraw::kBottomLeft, ptPosUp, vtText, sUp, len);
		
		//封口
		if (i == m_arsUps.GetSize() - 1)
		{
			pLine = new AcDbLine(ptGe[0], ptGe[3]);
			if (pLine)
			{
				pLine->setLayer(layerId());
				Add2DBuffer(pLine);
				dc.DrawEntity(*pLine);
			}
		}

		ptTo += vtV * ptTxtBox.y;
		ptTo += vtV * 0.5 * m_dTextH * m_dPScale;//文字有0.4空隙
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEwPipeDim::DrawOnlineDim(AcGiDraw & dc) const
{
	//在线标注为单个的在线标注
	if (m_arPoints.length() != 2 ) return Acad::eInvalidInput; 

	double txtLen(.0);

	AcGePoint3d ptFr(m_arPoints.first()), ptTo(m_arPoints.last());

	AcGeVector3d vtDir = ptTo - ptFr;
	vtDir.normalize();

	AcGeVector3d vtV(vtDir);
	vtV.rotateBy(-PI * .5, AcGeVector3d::kZAxis);
	vtV.normalize();

	CString sDimUp(_T("")), sDimDown(_T(""));
	if (!m_arsUps.IsEmpty())
	{
		sDimUp = m_arsUps.GetAt(0);
		TextEx(dc, AcGiDraw::kBottomLeft, ptFr, vtDir, sDimUp, txtLen);
	}

	if (!m_arsDowns.IsEmpty())
	{
		sDimDown = m_arsDowns.GetAt(0);
		ptFr += (vtV * (m_dD + 20));

		short nType(-1);
		CString sLeft, sRight;
		if (ParseDownString(sDimDown, nType, sLeft, sRight) != Acad::eOk)
			return Acad::eInvalidInput;

		TextEx(dc, AcGiDraw::kTopLeft, ptFr, vtDir, sDimDown, txtLen,-1);

		/*if (nType > -1)//有标高
		{
			ptFr += (vtDir * txtLen);

			double dAngle = AcGeVector3d::kXAxis.angleTo(vtDir, AcGeVector3d::kZAxis);
			DrawEl(dc, ptFr + (vtV * m_dTextH * m_dPScale), dAngle, nType, m_dTextH * m_dPScale,-1);

			ptFr += (vtDir * (m_dTextH * m_dPScale));
			TextEx(dc, AcGiDraw::kTopLeft, ptFr, vtDir, sRight, txtLen,-1);
		}*/
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEwPipeDim::DrawPolylineDim(AcGiDraw &dc) const
{
	if (m_arPoints.length() == 0)
	{
		return Acad::eInvalidInput;
	}

	AcGePoint3d ptFr;
	AcGePoint3d ptTo;
	dc.SetLayer(layerId());
	for (int i = 0; i < m_arPoints.length() - 1; i++)
	{
		ptFr = m_arPoints.at(i);
		ptTo = m_arPoints.at(i + 1);
		//dc.DrawLine(AcGeLineSeg3d(ptFr, ptTo));
		AcDbLine *pL(new AcDbLine(ptFr, ptTo));
		if (pL)
		{
			pL->setLayer(layerId());
			Add2DBuffer(pL);
			dc.DrawEntity(pL);
		}
	}

	ptTo = m_arPoints.last();
	
	//计算最大的文字需要的下画线长度
	double dLen = 0.0;
	CString sDimup,sDimDown = _T("");
	for (int i = 0;i < m_arsUps.GetSize();i++)
	{
		sDimup = m_arsUps.GetAt(i);
		dLen = __max(dLen, UnderLineLength(sDimup));
	}

	//文字标注比例
	struct resbuf rb;
	double dDimScale = 1.0;
	acedGetVar(_T("dimscale"),&rb);
	dDimScale = rb.resval.rreal;

	AcGeVector3d vtH = AcGeVector3d::kYAxis;
	vtH *= m_dTextH * 1.2 * GetPScale();//全局比例

	ptFr = ptTo;
	ptTo += dLen * AcGeVector3d::kXAxis;

	for (int i = 0;i < m_arsUps.GetSize();i++)
	{
		sDimup = m_arsUps.GetAt(i);
		DrawText(dc,ptFr,ptTo,sDimup,sDimDown,AcGeVector3d::kXAxis);
		ptTo += vtH;
		ptFr += vtH;
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEwPipeDim::DrawSNo(AcGiDraw &dc) const
{
	assertReadEnabled();

	if (m_arPoints.length() == 0)
	{
		return Acad::eInvalidInput;
	}

	AcDbObjectId idLayOld = dc.GetLayerId();
	AcDbObjectId idTextSt = dc.GetTextStyle();

	AcGePoint3d ptFr;
	AcGePoint3d ptTo;
	dc.SetLayer(m_idTextLayer);
	dc.SetTextStyle(m_idTextSty);

	double dR = m_dTextH *m_dPScale;
	AcGeVector3d vt;
	
	ptFr = m_arPoints.last();
	ptFr.z = 0.0;
	AcGeVector3d vtH = AcGeVector3d::kXAxis;
	vtH *= 2.0 * dR;

	CString sDimup;
	double dRLen = dR;

	double dCirR = 1.2 * dR;
	m_mapSpecXData.GetAt(_Custom_No_R_, dCirR);

	for (int i = 0;i < m_arsUps.GetSize();i++)
	{
		sDimup = m_arsUps.GetAt(i);
		
		//dc.DrawText(sDimup, ptFr, AcGiDraw::kMiddle, m_dTextH * m_dPScale,1.0, 0.0, NULL);

		TextEx(dc, AcGiDraw::kTopCenter, ptFr, AcGeVector3d::kXAxis, sDimup, dRLen);

		//dc.DrawCircle(ptFr,1.2 * dR,AcGeVector3d::kZAxis);

		AcDbCircle *pC(new AcDbCircle(ptFr, AcGeVector3d::kZAxis, dCirR));
		if (pC)
		{
			Add2DBuffer(pC);
			dc.DrawEntity(pC);
		}

		ptFr += vtH;
	}

	for (int i = 0;i < m_arPoints.length() - 1;i++)
	{
		ptFr = m_arPoints.at(i);
		ptTo = m_arPoints.at(i+1);
		ptFr.z = 0.0;
		ptTo.z = 0.0;

		vt = ptFr - ptTo;
		vt.normalize();
		vt *= dCirR;

		ptTo += vt;
		//dc.DrawLine(AcGeLineSeg3d(ptFr,ptTo));
		AcDbLine *pL(new AcDbLine(ptFr,ptTo));
		if (pL)
		{
			pL->setLayer(layerId());
			Add2DBuffer(pL);
			dc.DrawEntity(pL);
		}
	}

	dc.SetLayer(idLayOld);
	dc.SetTextStyle(idTextSt);

	return Acad::eOk;
}

Acad::ErrorStatus AecDbEwPipeDim::DrawText(AcGiDraw &dc,AcGePoint3d ptFr,AcGePoint3d ptTo,
										  LPCTSTR pszDimup,LPCTSTR pszDimDown,
										  const AcGeVector3d& vtDimType,BOOL bHasUnderline) const
{
	//可能含有标高,三角形标注!!!
	//1. 在线标注
	if (vtDimType.isZeroLength()) //在线标注,方向同管线
	{
		double dAngle = 0;
		AcGeVector3d vtFrTo = ptTo - ptFr;
		AcGeVector3d vtV = vtFrTo;

		dAngle = AcGeVector3d::kXAxis.angleTo(vtFrTo,AcGeVector3d::kZAxis);

		double dDot = vtFrTo.dotProduct(AcGeVector3d::kXAxis);
		if (dDot > 0 ) //I,IV 象限 同向绘制文字
		{
			if (pszDimup != NULL)
			{
				DrawText(dc,pszDimup,ptFr,dAngle);
			}
			
			if (pszDimDown != NULL)
			{
				vtV.normalize();
				vtV.rotateBy(-PI / 2.0,AcGeVector3d::kZAxis);
				vtV *= m_dTextH * 1.2 * GetPScale();//间隙0.1

				ptFr += vtV;
				DrawText(dc,pszDimDown,ptFr,dAngle);
			}
		}
		else if (dDot < 1.e-10)//反方向 II III 象限，或垂直
		{
			if (dDot > -1.e-10) //如果垂直 Y
			{
				if (vtFrTo.isCodirectionalTo(AcGeVector3d::kYAxis)) //垂直 和 Y+ 同向绘制文字
				{
					if (pszDimup != NULL)
					{
						DrawText(dc,pszDimup,ptFr,PI / 2.0);
					}

					if (pszDimDown != NULL)
					{
						ptFr += m_dTextH * 1.1 * GetPScale() * AcGeVector3d::kXAxis;//间隙0.1;
						DrawText(dc,pszDimDown,ptFr,PI / 2.0);
					}
				}
				else //反方向绘制文字 -Y 方向
				{
					if (pszDimup != NULL)
					{
						double dLen = UnderLineLength(pszDimup);
						AcGePoint3d ptPos = ptFr - dLen * AcGeVector3d::kYAxis;
						DrawText(dc,pszDimup,ptPos,PI / 2.0);
					}
						
					if (pszDimDown != NULL)
					{
						double dLen = UnderLineLength(pszDimDown);
						AcGePoint3d ptPos = ptFr - dLen * AcGeVector3d::kYAxis;
						ptPos.x += m_dTextH * 1.1 * GetPScale();//间隙0.1;
						DrawText(dc,pszDimDown,ptPos,PI / 2.0);
					}
				}
			}
			else // 不垂直 反方向绘制文字
			{
				dAngle = AcGeVector3d::kXAxis.angleTo(vtFrTo,AcGeVector3d::kZAxis);
				if (vtFrTo.x < 1.e-10 && vtFrTo.y > 1.e-10)
				{
					dAngle += PI;
				}

				//if (vtFrTo.x < 1.e-10 && vtFrTo.y < 1.e-10)
				//{
				//	dAngle = PI - dAngle;
				//}

				if (pszDimup != NULL)
				{
					vtFrTo.normalize();
					double dLen = UnderLineLength(pszDimup);
					AcGePoint3d ptPos = ptFr + dLen * vtFrTo;

					DrawText(dc,pszDimup,ptPos,dAngle);
				}

				if (pszDimDown != NULL)
				{
					vtFrTo.normalize();
					double dLen = UnderLineLength(pszDimDown);
					AcGePoint3d ptPos = ptFr + dLen * vtFrTo;
					vtFrTo.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
					ptPos += vtFrTo * m_dTextH * 1.1 * GetPScale();
					DrawText(dc,pszDimDown,ptPos,dAngle);
				}
			}
		}
	}
	else //水平或垂直标注
	{
		AcGeVector3d vtFrTo = ptTo - ptFr;

		//2.水平标注
		if (vtDimType.isParallelTo(AcGeVector3d::kXAxis)) //水平标注
		{
			if (pszDimup != NULL)
			{
				DrawText(dc,pszDimup,ptFr,0.0);
			}

			if (pszDimDown != NULL)
			{
				AcGePoint3d ptPos = ptFr;
				ptPos.y -= m_dTextH * 1.1 * GetPScale();
				DrawText(dc,pszDimDown,ptPos,0.0);
			}
		}

		//3.垂直标注
		if (vtDimType.isParallelTo(AcGeVector3d::kYAxis))//垂直标注
		{
			if (vtFrTo.isCodirectionalTo(AcGeVector3d::kYAxis)) //垂直 和 Y+ 同向绘制文字
			{
				if (pszDimup != NULL)
				{
					DrawText(dc,pszDimup,ptFr,PI / 2.0);
				}

				if (pszDimDown != NULL)
				{
					ptFr.x += m_dTextH * 1.1 * GetPScale();//间隙0.1;
					DrawText(dc,pszDimDown,ptFr,PI / 2.0);
				}
			}
			else //反方向绘制文字 -Y 方向
			{
				if (pszDimup != NULL)
				{
					double dLen = UnderLineLength(pszDimup);
					AcGePoint3d ptPos = ptFr - dLen * AcGeVector3d::kYAxis;
					DrawText(dc,pszDimup,ptPos,PI / 2.0);
				}

				if (pszDimDown != NULL)
				{
					double dLen = UnderLineLength(pszDimDown);
					AcGePoint3d ptPos = ptFr - dLen * AcGeVector3d::kYAxis;
					ptPos.x += m_dTextH * 1.1 * GetPScale();//间隙0.1;
					DrawText(dc,pszDimDown,ptPos,PI / 2.0);
				}
			}
		}
	}

	if (bHasUnderline)
	{
		AcGeLineSeg3d ln(ptFr,ptTo);
		//dc.DrawLine(ln);
		AcDbLine *pL(new AcDbLine(ptFr,ptTo));
		if (pL)
		{
			pL->setLayer(layerId());
			Add2DBuffer(pL);
			dc.DrawEntity(pL);
		}
	}
	return Acad::eOk;
}

/*
#define DIM_EL		_T("\\U+2200")
#define DIM_TOP_EL	_T("\\U+2201")
#define DIM_CEN_EL	_T("\\U+2202")
#define DIM_BOM_EL	_T("\\U+2203")
*/

Acad::ErrorStatus AecDbEwPipeDim::ParseDownString(LPCTSTR psz
		, short &nElType
		, CString &sLeft
		, CString &sRight ) const
{
	if (!psz) return Acad::eInvalidInput;

	CString sDimTxt(psz);

	nElType = -1;
	if (sDimTxt.Find(DIM_EL) != -1 ||
		sDimTxt.Find(DIM_TOP_EL) != -1 ||
		sDimTxt.Find(DIM_CEN_EL) != -1 ||
		sDimTxt.Find(DIM_BOM_EL) != -1)
	{
		int nPos = -1, nLen = 0;
		if ((nPos = sDimTxt.Find(DIM_EL)) != -1)
		{
			sLeft = sDimTxt.Mid(0, nPos);
			nLen = (int)_tcslen(DIM_EL);
			sRight = sDimTxt.Mid(nPos + nLen);
			nElType = 0;
		}

		if ((nPos = sDimTxt.Find(DIM_TOP_EL)) != -1)
		{
			sLeft = sDimTxt.Mid(0, nPos);
			nLen = (int)_tcslen(DIM_TOP_EL);
			sRight = sDimTxt.Mid(nPos + nLen);
			nElType = 1;
		}

		if ((nPos = sDimTxt.Find(DIM_CEN_EL)) != -1)
		{
			sLeft = sDimTxt.Mid(0, nPos);
			nLen = (int)_tcslen(DIM_CEN_EL);
			sRight = sDimTxt.Mid(nPos + nLen);
			nElType = 2;
		}

		if ((nPos = sDimTxt.Find(DIM_BOM_EL)) != -1)
		{
			sLeft = sDimTxt.Mid(0, nPos);
			nLen = (int)_tcslen(DIM_BOM_EL);
			sRight = sDimTxt.Mid(nPos + nLen);
			nElType = 3;
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEwPipeDim::DrawText(AcGiDraw &dc,LPCTSTR pszText,AcGePoint3d& ptFr,double dAngle) const
{
	//标高问题
	CString sDimTxt = pszText;
	if (sDimTxt.IsEmpty())
		return Acad::eOk;

	if (sDimTxt.Find(DIM_EL) != -1 ||
		sDimTxt.Find(DIM_TOP_EL) != -1 ||
		sDimTxt.Find(DIM_CEN_EL) != -1 ||
		sDimTxt.Find(DIM_BOM_EL) != -1)
	{
		int nPos = -1,nLen = 0,nElType = 0;
		CString sLeft = _T(""),sEl = _T(""),sRight = _T("");
		if ( (nPos = sDimTxt.Find(DIM_EL)) != -1)
		{
			sLeft = sDimTxt.Mid(0,nPos);
			nLen = (int)_tcslen(DIM_EL);
			sEl = sDimTxt.Mid(nPos,nLen);
			sRight = sDimTxt.Mid(nPos + nLen);
			nElType = 0;
		}

		if ( (nPos = sDimTxt.Find(DIM_TOP_EL)) != -1)
		{
			sLeft = sDimTxt.Mid(0,nPos);
			nLen = (int)_tcslen(DIM_TOP_EL);
			sEl = sDimTxt.Mid(nPos,nLen);
			sRight = sDimTxt.Mid(nPos + nLen);
			nElType = 1;
		}

		if ( (nPos = sDimTxt.Find(DIM_CEN_EL)) != -1)
		{
			sLeft = sDimTxt.Mid(0,nPos);
			nLen = (int)_tcslen(DIM_CEN_EL);
			sEl = sDimTxt.Mid(nPos,nLen);
			sRight = sDimTxt.Mid(nPos + nLen);
			nElType = 2;
		}

		if ( (nPos = sDimTxt.Find(DIM_BOM_EL) ) != -1)
		{
			sLeft = sDimTxt.Mid(0,nPos);
			nLen = (int)_tcslen(DIM_BOM_EL);
			sEl = sDimTxt.Mid(nPos,nLen);
			sRight = sDimTxt.Mid(nPos + nLen);
			nElType = 3;
		}

		//标左
		sLeft.TrimRight();
		DrawText2(dc,sLeft,ptFr,dAngle);

		//标中
		//AcGeVector3d vtDir = AcGeVector3d::kXAxis;
		//vtDir.rotateBy(dAngle,AcGeVector3d::kZAxis);
		DrawEl(dc,ptFr,dAngle,nElType,m_dTextH * GetPScale());

		//标右
		if (!sRight.IsEmpty())
		{
			DrawText2(dc,sRight,ptFr,dAngle);
		}
	}
	else
	{
		DrawText2(dc,pszText,ptFr,dAngle);
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEwPipeDim::TextEx( AcGiDraw & dc
	, const AcGiDraw::TextAlignment & ta
	, const AcGePoint3d & ptPos
	, const AcGeVector3d & vtDir
	, LPCTSTR psz
	, double &len
	, int nUpOrDwn/* = 1*/) const
{
	if (!psz || CString(psz).IsEmpty()) return Acad::eInvalidInput;

	dc.SetLayer(m_idTextLayer);
	dc.SetTextStyle(m_idTextSty);

	double dAngle = AcGeVector3d::kXAxis.angleTo(vtDir, AcGeVector3d::kZAxis);
	if (dAngle > PI && dAngle < 1.5 * PI)
		dAngle -= PI;

	if (dAngle > 0.5 * PI && dAngle < PI)
		dAngle = 2.0 * PI - (PI - dAngle);

	AcGeVector3d vtUD = vtDir;
	vtUD.rotateBy(nUpOrDwn * PI / 2.0,AcGeVector3d::kZAxis);
	vtUD.normalize();
	vtUD *= 0.4 * m_dTextH * m_dPScale;//文字高度0.4空隙
	AcGePoint3d ptPos2 = ptPos + vtUD;

	dc.DrawText(psz, ptPos2, ta, m_dTextH * m_dPScale, m_dWScale, dAngle, NULL);

	AcDbVoidPtrArray arTxt;
	AcGiExplodeDraw dc2(arTxt);
	dc2.SetLayer(m_idTextLayer);
	dc2.SetTextStyle(m_idTextSty);
	dc2.DrawText(psz, ptPos2, ta, m_dTextH * m_dPScale, m_dWScale, dAngle, NULL);

	if (!arTxt.isEmpty())
	{
		Add2DBuffer((AcDbEntity*)arTxt.first());
	}

	////错误，标注方向可能任意方向，内部y 减加不对2023-6-1
	// 求 vDir 方向长度
	// 不需要设置角度，因为无论什么角度，文字对象长是一样的
	/*AcDbText *pDbTxt = new AcDbText;
	if (pDbTxt)
	{
		pDbTxt->setTextString(psz);

		pDbTxt->setTextStyle(m_idTextSty);
		pDbTxt->setHeight(m_dTextH * m_dPScale);
		pDbTxt->setWidthFactor(m_dWScale);
		pDbTxt->setRotation(dAngle);

		AcDbExtents ext;
		pDbTxt->getGeomExtents(ext);
		len = ext.maxPoint().distanceTo(ext.minPoint());
		AcGePoint3d pt, ptExt(ext.maxPoint().x - ext.minPoint().x
			, ext.maxPoint().y
			, m_dTextH * m_dPScale);

			//错误，标注方向可能任意方向，内部y 减加不对
		pt = AcGiDraw::Align2Base(ta, ptPos2, ptExt);

		pDbTxt->setPosition(pt);

		pDbTxt->setColorIndex(dc.GetColor());

		pDbTxt->setLayer(m_idTextLayer);

		dc.DrawEntity(*pDbTxt);
		Add2DBuffer(pDbTxt);
	}*/
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEwPipeDim::DrawText2(AcGiDraw &dc,LPCTSTR pszText,AcGePoint3d& ptFr,double dAngle) const
{
	dc.SetLayer(m_idTextLayer);
	dc.SetTextStyle(m_idTextSty);
	//dc.DrawText(pszText, ptFr, AcGiDraw::kBottomLeft, m_dTextH * GetPScale(), 1, dAngle, NULL);
	
	AcDbText *pDbTxt = new AcDbText;
	if (pDbTxt)
	{
		pDbTxt->setTextString(pszText);

		pDbTxt->setTextStyle(m_idTextSty);
		pDbTxt->setHeight(m_dTextH * GetPScale());
		pDbTxt->setWidthFactor(1);
		pDbTxt->setRotation(dAngle);

		AcDbExtents ext;
		pDbTxt->getGeomExtents(ext);
		AcGePoint3d pt, ptExt(ext.maxPoint().x - ext.minPoint().x
			, ext.maxPoint().y
			, m_dTextH * m_dPScale);

		pt = AcGiDraw::Align2Base(AcGiDraw::kBottomLeft, ptFr, ptExt);
		pDbTxt->setPosition(pt);
		pDbTxt->setColorIndex(dc.GetColor());
		pDbTxt->setLayer(m_idTextLayer);

		dc.DrawEntity(*pDbTxt);
		Add2DBuffer(pDbTxt);
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbEwPipeDim::DrawEl(AcGiDraw &dc,AcGePoint3d& ptFr,double dAngle,short nElType,double dH, int nUpOrDwn/* = 1*/) const
{
	AcGeVector3d vtDir = AcGeVector3d::kXAxis;
	vtDir.rotateBy(dAngle,AcGeVector3d::kZAxis);
	
	AcGeVector3d vtV = vtDir;
	vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);

	dH *= 0.8;
	double dL = dH / 0.866;
	AcGePoint3d ptGe[8];

	AcGeVector3d vtUD = vtV;
	vtUD.normalize();
	vtUD *= nUpOrDwn;
	vtUD *= 0.4 * m_dTextH * m_dPScale;//文字高度0.4空隙
	AcGePoint3d ptPos2 = ptFr + vtUD;

	ptGe[0] = ptPos2;
	ptGe[0] += dL * 0.5 * vtDir;
	ptGe[1] = ptGe[0] + dL * 0.5 * vtDir;
	ptGe[1] += dH * vtV;
	ptGe[2] = ptGe[1] - dL * vtDir;
	ptGe[3] = ptGe[0];

	ptFr += dL * 1.1 * vtDir;

	AcDbLine *pLine(NULL);
	AcGeLineSeg3d ln;
	switch(nElType)
	{
	case 0://DIM_EL
		{
			for (int i = 0;i <= 2;i++)
			{
				ln.set(ptGe[i], ptGe[i+1]);
				//dc.DrawLine(ln);
				pLine = new AcDbLine(ptGe[i], ptGe[i+1]);
				if (pLine)
				{
					pLine->setLayer(layerId());
					Add2DBuffer(pLine);
					dc.DrawEntity(pLine);
				}
			}
			break;
		}
	case 1://DIM_TOP_EL
		{
			for (int i = 0;i <= 2;i++)
			{
				ln.set(ptGe[i], ptGe[i+1]);
				//dc.DrawLine(ln);

				pLine = new AcDbLine(ptGe[i], ptGe[i + 1]);
				if (pLine)
				{
					pLine->setLayer(layerId());
					Add2DBuffer(pLine);
					dc.DrawEntity(pLine);
				}
			}

			Midpoint(ptGe[0],ptGe[1],ptGe[4]);
			Midpoint(ptGe[0],ptGe[2],ptGe[5]);

			ln.set(ptGe[4], ptGe[5]);
			//dc.DrawLine(ln);

			pLine = new AcDbLine(ptGe[4], ptGe[5]);
			if (pLine)
			{
				pLine->setLayer(layerId());
				Add2DBuffer(pLine);
				dc.DrawEntity(pLine);
			}

			break;
		}
	case 2://DIM_CEN_EL
		{
			for (int i = 0;i <= 2;i++)
			{
				ln.set(ptGe[i], ptGe[i+1]);
				//dc.DrawLine(ln);
				pLine = new AcDbLine(ptGe[i], ptGe[i + 1]);
				if (pLine)
				{
					pLine->setLayer(layerId());
					Add2DBuffer(pLine);
					dc.DrawEntity(pLine);
				}
			}
			Midpoint(ptGe[1],ptGe[2],ptGe[4]);
			ln.set(ptGe[0], ptGe[4]);
			//dc.DrawLine(ln);

			pLine = new AcDbLine(ptGe[0], ptGe[4]);
			if (pLine)
			{
				pLine->setLayer(layerId());
				Add2DBuffer(pLine);
				dc.DrawEntity(pLine);
			}

			break;
		}
	case 3://DIM_BOM_EL
		{
			for (int i = 0;i <= 2;i++)
			{
				ln.set(ptGe[i], ptGe[i+1]);
				//dc.DrawLine(ln);

				pLine = new AcDbLine(ptGe[i], ptGe[i + 1]);
				if (pLine)
				{
					pLine->setLayer(layerId());
					Add2DBuffer(pLine);
					dc.DrawEntity(pLine);
				}
			}

			Midpoint(ptGe[0],ptGe[1],ptGe[4]);
			Midpoint(ptGe[0],ptGe[2],ptGe[5]);

			AcGiDraw::AcGiPoly2d pl;
			AcGiDraw::Vertex3d vt;

			vt.pt = ptGe[0];
			vt.dBulge = .0;
			pl.append(vt);

			vt.pt = ptGe[4];
			vt.dBulge = .0;
			pl.append(vt);

			vt.pt = ptGe[5];
			vt.dBulge = .0;
			pl.append(vt);

			vt.pt = ptGe[0];
			vt.dBulge = .0;
			pl.append(vt);

			//dc.DrawSolid(pl);

			AcDbPolyline *pPoly = new AcDbPolyline();
			if (pPoly)
			{
				pPoly->addVertexAt(0, AcGePoint2d(ptGe[0].x, ptGe[0].y));
				pPoly->addVertexAt(1, AcGePoint2d(ptGe[4].x, ptGe[4].y));
				pPoly->addVertexAt(2, AcGePoint2d(ptGe[5].x, ptGe[5].y));
				pPoly->addVertexAt(3, AcGePoint2d(ptGe[0].x, ptGe[0].y));
				Add2DBuffer(pPoly);
				dc.DrawEntity(*pPoly);
			}

			break;
		}
	default:
		break;
	}
	return Acad::eOk;
}

double AecDbEwPipeDim::UnderLineLength(LPCTSTR pszDimup) const
{
	AcGiTextStyle giTxtStyle;
	fromAcDbTextStyle(giTxtStyle,m_idTextSty);

	giTxtStyle.setTextSize(m_dTextH * GetPScale());
	giTxtStyle.setXScale(m_dWScale);

	//标高脚本按一个'W'字处理
	CString sDimup = pszDimup;
	sDimup.Replace(DIM_EL,_T("W"));
	sDimup.Replace(DIM_TOP_EL,_T("W"));
	sDimup.Replace(DIM_CEN_EL,_T("W"));
	sDimup.Replace(DIM_BOM_EL,_T("W"));

	int nLen = sDimup.GetLength();
	AcGePoint2d pt2d = giTxtStyle.extents(sDimup,Adesk::kFalse,nLen,Adesk::kTrue);

	return pt2d.x;
}

AcGePoint2d AecDbEwPipeDim::DimTextExtent(LPCTSTR pszDimup) const
{
	AcGiTextStyle giTxtStyle;
	fromAcDbTextStyle(giTxtStyle, m_idTextSty);

	giTxtStyle.setTextSize(m_dTextH * GetPScale());
	giTxtStyle.setXScale(m_dWScale);

	//标高脚本按一个'W'字处理
	CString sDimup = pszDimup;
	sDimup.Replace(DIM_EL, _T("W"));
	sDimup.Replace(DIM_TOP_EL, _T("W"));
	sDimup.Replace(DIM_CEN_EL, _T("W"));
	sDimup.Replace(DIM_BOM_EL, _T("W"));

	int nLen = sDimup.GetLength();
	AcGePoint2d pt2d = giTxtStyle.extents(sDimup, Adesk::kFalse, nLen, Adesk::kTrue);
	return pt2d;
}

Acad::ErrorStatus AecDbEwPipeDim::subGetGripPoints (AcDbGripDataPtrArray& grips, 
											const double curViewUnitSize, 
											const int gripSize,
											const AcGeVector3d& curViewDir, 
											const int bitflags) const
{
	assertReadEnabled();

	if (m_arPoints.length() > 0)
	{
		memset(&m_pGripAppData[0],0,sizeof(AecGripData));
		m_pGripAppData[0].nIndex = 0;
		m_pGripAppData[0].ePos = eStart;
		m_pGripAppData[0].nColor = kBlue;
		m_pGripAppData[0].ptGrip = m_arPoints.at(0);
		m_pGripAppData[0].pOwner = (AcDbEntity*)this;

		AcDbGripData* pGripData = new AcDbGripData;
		pGripData->setGripPoint(m_arPoints.at(0));
		pGripData->setAppData((void*)&m_pGripAppData[0]);
		pGripData->setWorldDraw(AecGripCback::WorldDrawfunc);
		pGripData->setToolTipFunc(AecGripCback::GripToolTipFunc);
		grips.append(pGripData);

		if (m_arPoints.length() > 1)
		{
			memset(&m_pGripAppData[1],0,sizeof(AecGripData));
			m_pGripAppData[1].nIndex = 1;
			m_pGripAppData[1].ePos = eEnd;
			m_pGripAppData[1].nColor = kBlue;
			m_pGripAppData[1].ptGrip = m_arPoints.at(1);
			m_pGripAppData[1].pOwner = (AcDbEntity*)this;

			pGripData = new AcDbGripData;
			pGripData->setGripPoint(m_arPoints.at(1));
			pGripData->setAppData((void*)&m_pGripAppData[1]);
			pGripData->setWorldDraw(AecGripCback::WorldDrawfunc);
			pGripData->setToolTipFunc(AecGripCback::GripToolTipFunc);
			grips.append(pGripData);
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEwPipeDim::subMoveGripPointsAt(const AcDbVoidPtrArray& appData,const AcGeVector3d& offset,const int bitflags)
{
	AssertWriteEnabled();

	AecGripData* pAppData = NULL;
	AcDbIntArray arIndex;

	if ( !appData.isEmpty() )
	{
		pAppData = (AecGripData*)appData.first();
		arIndex.append(pAppData->nIndex);
	}
	else
	{
		return Acad::eOk;
	}

	int nGripIndex = arIndex.first();
	AcGePoint3d ptGe;
	switch(nGripIndex)
	{
	case 0:
		{
			ptGe = m_arPoints.at(0);
			ptGe += offset;
			m_arPoints.setAt(0,ptGe);

			break;
		}
	case 1:
		{
			ptGe = m_arPoints.at(1);
			ptGe += offset;
			m_arPoints.setAt(1,ptGe);

			break;
		}
	default:
		break;
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbEwPipeDim::copyFrom(const AcRxObject* pSrc)
{
	AssertWriteEnabled();

	AecDbEwPipeDim* pDimSrc = AecDbEwPipeDim::cast(pSrc);
	if (pDimSrc != NULL)
	{
		m_nStyle = pDimSrc->m_nStyle;			
		m_nDir = pDimSrc->m_nDir;			
		m_nDimText = pDimSrc->m_nDimText;		
		m_nIsISO = pDimSrc->m_nIsISO;			

		m_arsUps.RemoveAll();
		m_arsUps.Append(pDimSrc->m_arsUps);

		m_sUpScr = pDimSrc->m_sUpScr;

		m_arsDowns.RemoveAll();
		m_arsDowns.Append(pDimSrc->m_arsDowns);		

		m_sDownScr = pDimSrc->m_sDownScr;		

		m_dTextH = pDimSrc->m_dTextH;			
		m_dWScale = pDimSrc->m_dWScale;			
		m_dD = pDimSrc->m_dD;			    
		m_dPScale = pDimSrc->m_dPScale;			
		m_idTextSty = pDimSrc->m_idTextSty;		
		m_idTextLayer = pDimSrc->m_idTextLayer;		

		m_arPoints.removeAll();
		m_arPoints.append(pDimSrc->m_arPoints);

		m_arNoPoints.removeAll();
		m_arNoPoints.append(pDimSrc->m_arNoPoints);	

		m_aridAttachs.removeAll();
		m_aridAttachs.append(pDimSrc->m_aridAttachs);
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEwPipeDim::subGetOsnapPoints( AcDb::OsnapMode osnapMode,
													INT_PTR gsSelectionMark,
													const AcGePoint3d& pickPoint,
													const AcGePoint3d& lastPoint,
													const AcGeMatrix3d& viewXform,
													AcGePoint3dArray& snapPoints,
													AcDbIntArray& geomIds) const
{
	assertReadEnabled();

	AcDbPolyline pl;
	for (int i = 0;i < m_arPoints.length();i++)
	{
		pl.addVertexAt(i,m_arPoints.at(i).convert2d(AcGePlane::kXYPlane));
	}
	return pl.getOsnapPoints(osnapMode,gsSelectionMark,pickPoint,lastPoint,viewXform,snapPoints,geomIds);
}

Acad::ErrorStatus AecDbEwPipeDim::subTransformBy(const AcGeMatrix3d& xform)
{
	AssertWriteEnabled();

	AcGePoint3d ptGe;
	for (int i = 0;i < m_arPoints.length();i++)
	{
		ptGe = m_arPoints.at(i);
		ptGe.transformBy(xform);
		m_arPoints.setAt(i,ptGe);
	}

	return Acad::eOk;
}

Acad::ErrorStatus AecDbEwPipeDim::subExplode(AcDbVoidPtrArray& entitySet) const
{
	AcGiExplodeDraw draw(entitySet);
	Draw2d(draw);

	return Acad::eOk;
}

bool AecDbEwPipeDim::GetSNDimCircle(AcDbCircle& cir) const
{
	assertReadEnabled();

	if (m_arPoints.isEmpty())
		return false;

	AcGePoint3d ptFr = m_arPoints.last();
	ptFr.z = 0.0;
	AcGeVector3d vtH = AcGeVector3d::kXAxis;

	double dR = m_dTextH * m_dPScale;
	vtH *= 2.0 * dR;

	if (m_arsUps.IsEmpty())
		return false;

	cir.setCenter(ptFr);
	cir.setRadius(1.2 * dR);
	cir.setNormal(AcGeVector3d::kZAxis);

	return true;
}

bool AecDbEwPipeDim::IsSNOverlapping(const AecDbEwPipeDim* pDim) const
{
	assertReadEnabled();

	AcDbCircle cir1;
	if ( GetSNDimCircle(cir1) )
	{
		AcDbCircle cir2;
		if ( pDim->GetSNDimCircle(cir2) )
		{
			AcGePoint3dArray arPts;
			cir2.intersectWith(&cir1,AcDb::kOnBothOperands,arPts);

			return !arPts.isEmpty();
		}
	}
	return false;
}

Acad::ErrorStatus AecDbEwPipeDim::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEwPipeDim::dxfInFields(AcDbDxfFiler* pFiler)
{
	AssertWriteEnabled();
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEwPipeDim::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	Acad::ErrorStatus es;

	// Call dwgOutFields from TDbInterfacesObj
	if ((es = AecDbEntityBase::dwgOutFields(pFiler)) != Acad::eOk)
	{
		return es;
	}

	// Write version number.
	pFiler->writeItem((Adesk::UInt16) VERSION_TDBFITTINGBASE);

	pFiler->writeInt16(m_nStyle);
	pFiler->writeInt16(m_nDir);
	pFiler->writeInt16(m_nDimText);
	pFiler->writeInt16(m_nIsISO);
	
	pFiler->writeInt32((Adesk::Int32)m_arsUps.GetSize());
	for (int i = 0;i < m_arsUps.GetSize();i++)
	{
		pFiler->writeString((const TCHAR *)m_arsUps.GetAt(i));
	}
	pFiler->writeString((const TCHAR *)m_sUpScr);

	Adesk::UInt32 nSize;
	nSize = (Adesk::UInt32)m_arsDowns.GetSize();

	pFiler->writeUInt32(nSize);
	for (int i = 0;i < m_arsDowns.GetSize();i++)
	{
		pFiler->writeString((const TCHAR *)m_arsDowns.GetAt(i));
	}
	pFiler->writeString((const TCHAR *)m_sDownScr);

	pFiler->writeDouble(m_dTextH);
	pFiler->writeDouble(m_dWScale);
	pFiler->writeDouble(m_dD);
	pFiler->writeDouble(m_dPScale);

	pFiler->writeSoftPointerId(m_idTextSty);
	pFiler->writeSoftPointerId(m_idTextLayer);

	pFiler->writeInt32(m_arPoints.length());
	for (int i = 0;i < m_arPoints.length();i++)
	{
		pFiler->writePoint3d(m_arPoints.at(i));
	}

	pFiler->writeInt32(m_arNoPoints.length());
	for (int i = 0;i < m_arNoPoints.length();i++)
	{
		pFiler->writePoint3d(m_arNoPoints.at(i));
	}

	pFiler->writeInt32(m_aridAttachs.length());
	for (int i = 0;i < m_aridAttachs.length();i++)
	{
		pFiler->writeSoftPointerId(m_aridAttachs.at(i));
	}

	m_mapSpecXData.dwgOutFields(pFiler);
	return Acad::eOk;
}

Acad::ErrorStatus AecDbEwPipeDim::dwgInFields(AcDbDwgFiler* pFiler)
{
	AssertWriteEnabled();

	Acad::ErrorStatus es;

	// Call dwgInFields from TDbInterfacesObj
	if ((es = AecDbEntityBase::dwgInFields(pFiler)) != Acad::eOk)
	{
		return es;
	}

	// Read version number.
	Adesk::UInt16 version;
	pFiler->readItem(&version);

	if (version > VERSION_TDBFITTINGBASE)
		return Acad::eMakeMeProxy;

	pFiler->readInt16(&m_nStyle);
	pFiler->readInt16(&m_nDir);
	pFiler->readInt16(&m_nDimText);
	pFiler->readInt16(&m_nIsISO);

	Adesk::Int32 nUps = 0;
	pFiler->readInt32(&nUps);

	m_arsUps.RemoveAll();
	TCHAR* pszText = NULL;
	for (int i = 0;i < nUps;i++)
	{
		pFiler->readString(&pszText);
		m_arsUps.Add(pszText);
	}
	pFiler->readString(&pszText);
	m_sUpScr = pszText;

	Adesk::Int32 nDowns = 0;
	pFiler->readInt32(&nDowns);

	m_arsDowns.RemoveAll();
	for (int i = 0;i < nDowns;i++)
	{
		pFiler->readString(&pszText);
		m_arsDowns.Add(pszText);
	}

	pFiler->readString(&pszText);
	m_sDownScr = pszText;

	pFiler->readDouble(&m_dTextH);
	pFiler->readDouble(&m_dWScale);
	pFiler->readDouble(&m_dD);
	pFiler->readDouble(&m_dPScale);

	AcDbSoftPointerId id;
	pFiler->readSoftPointerId(&id);
	m_idTextSty = id;

	pFiler->readSoftPointerId(&id);
	m_idTextLayer = id;

	Adesk::Int32 nPts = 0;
	pFiler->readInt32(&nPts);

	m_arPoints.removeAll();
	AcGePoint3d ptGe;
	for (int i = 0;i < nPts;i++)
	{
		pFiler->readPoint3d(&ptGe);
		m_arPoints.append(ptGe);
	}

	nPts = 0;
	pFiler->readInt32(&nPts);

	m_arNoPoints.removeAll();
	for (int i = 0;i < nPts;i++)
	{
		pFiler->readPoint3d(&ptGe);
		m_arNoPoints.append(ptGe);
	}

	Adesk::Int32 nLen = 0;
	pFiler->readInt32(&nLen);

	m_aridAttachs.removeAll();
	for (int i = 0;i < nLen;i++)
	{
		pFiler->readSoftPointerId(&id);
		m_aridAttachs.append(id);
	}

	if (version >= 2)
	{
		m_mapSpecXData.dwgInFields(pFiler);
	}
	return Acad::eOk;
}

void AecDbEwPipeDim::SetPScale(double dScale)
{
	AssertWriteEnabled();
	m_dPScale = dScale;
}

double AecDbEwPipeDim::GetPScale() const
{
	assertReadEnabled();
	return m_dPScale;
}

#define ELE_FLAG _T("标高")
namespace
{
	bool isHoleElevDim(AecDbEwPipeDim *pDim)
	{
		CString sUp, sDw;
		pDim->GetDimText(0, sUp, sDw);
		if (sUp.Find(ELE_FLAG) != -1)
			return true;

		if (sDw.Find(ELE_FLAG) != -1)
			return true;

		return false;
	}

	bool isPipeElevDim(AecDbEwPipeDim *pDim)
	{
		CString sUp, sDw;
		pDim->GetDimupScript(sUp);
		pDim->GetDimdownScript(sDw);
		if (sUp.Find(ELE_FLAG) != -1)
			return true;

		if (sDw.Find(ELE_FLAG) != -1)
			return true;

		return false;
	}
	// {}-{}*{}&{}
	// 收集-，*，&
	void collectSplite(LPCTSTR psz, std::set<CString> &ss)
	{
		CString str(psz);
		int idx1(0), idx2(0);
		while (true)
		{
			idx1 = str.Find(_T("}{"), idx2);
			idx2 = str.Find(_T("}{"), idx1 + 1);
			if (idx1 == -1 || idx2 == -1) break;

			ss.insert(str.Mid(idx1 + 2, idx2 - idx1 - 2));
		}
	}

	bool IsHit(LPCTSTR psz, const std::set<CString> &sps)
	{
		std::set<CString>::const_iterator it(sps.begin());
		for (; it != sps.end(); ++it)
		{
			const CString &sp(*it);
			if (sp == psz)
				return true;
		}
		return false;
	}

	int getIndexByFilter(LPCTSTR psz, LPCTSTR filter, const std::set<CString> &sps)
	{
		CString str(psz), sMid;
		int idx1(0), idx2(0), idx(0);
		while (true)
		{
			idx1 = str.Find(_T("{"), idx2);
			idx2 = str.Find(_T("}"), idx1);
			if (idx1 == -1 || idx2 == -1) break;
			sMid = str.Mid(idx1 + 1, idx2 - idx1 - 1);
			if (IsHit(sMid, sps))
				continue;
			if (sMid == filter)
				break;
			++idx;
		}
		return idx;
	}

	// 判断 psz 的 start 位置的字符在不在 sps 里面,如果在里面，说明start后面是一个分隔符
	// end则是分隔符后的第一个字符位置
	bool IsHit(LPCTSTR psz, const std::set<CString> &sps, const int &start, int &end)
	{
		std::set<CString>::const_iterator it(sps.begin());
		CString strSrc(psz), sMid;
		int spLen(0), srcLen(strSrc.GetLength());
		for (; it != sps.end(); ++it)
		{
			const CString &sp(*it);
			spLen = sp.GetLength();
			if (spLen + start >= srcLen) continue;
			sMid = strSrc.Mid(start, spLen);
			if (sMid == sp)	// 击中
			{
				end = start + spLen;
				return true;
			}
		}

		return false;
	}
	
	int SplitString(LPCTSTR psz, const std::set<CString> &sps, std::vector<CString> &strs)
	{
		CString str(psz);
		int end(0), prev(0);
		for (int i(0); i < str.GetLength(); ++i)
		{
			if (IsHit(psz, sps, i, end))
			{
				strs.push_back(str.Mid(prev, i - prev));
				prev = end;
				i = end;
				continue;
			}
		}

		strs.push_back(std::wstring(str).substr(end).c_str());

		return (int)strs.size();
	}

	bool getHoleElev(LPCTSTR psz, double &dElev_mm, int &start, int &end)
	{
		std::wstring str(psz);
		size_t idx(str.find(ELE_FLAG));
		if (idx == -1)
			return false;

		start = idx + CString(ELE_FLAG).GetLength();
		str = str.substr(start);
		if (CoreTools::IsMeterUnitForHoleElevDim())
		{
			str = str.substr(0, str.size() - 1);
			dElev_mm = TypeConvert::s2f(str.c_str());
			dElev_mm *= 1000;
		}
		else
		{
			str = str.substr(0, str.size() - 2);
			dElev_mm = TypeConvert::s2f(str.c_str());
		}
		end = start + str.size();
		return true;
	}

	bool getPipeElev(LPCTSTR pszSrc, LPCTSTR pszTxt, double &dEle_mm, int &start, int &end)
	{
		CString sSrc(pszSrc), sElev;
		std::set<CString> sps;
		std::vector<CString> ss;
		int idxElev(0);
		if (sSrc.Find(ELE_FLAG) != -1)
		{
			collectSplite(sSrc, sps);
			idxElev = getIndexByFilter(sSrc, ELE_FLAG, sps);
			SplitString(pszTxt, sps, ss);
			if (idxElev < ss.size())
				sElev = ss[idxElev];
		}
		else
			return false;

		std::wstring wTxt(pszTxt);
		start = wTxt.find(sElev);

		std::wstring s(sElev);
		size_t idx(s.find(_T("\\")));
		if (idx != -1)
		{
			sElev = s.substr(idx + 7).c_str();
			start += 7;
		}
		end = start + sElev.GetLength();

		dEle_mm = TypeConvert::s2f(sElev);

		if (CoreTools::IsMeterUnitForPipeElevDim())
			dEle_mm *= 1000;

		return true;
	}

	CString makeNewString(LPCTSTR psz
		, const int &start
		, const int &end
		, const double &dElve_mm
		, const bool bPipeElev)
	{
		std::wstring ws(psz);
		std::wstring s1 = ws.substr(0, start);
		std::wstring s2 = ws.substr(end);

		bool bMeter(false);
		int nPrec(0);
		if (bPipeElev)
		{
			bMeter = CoreTools::IsMeterUnitForPipeElevDim();
			nPrec = CoreTools::getPrecForPipeElevDim();
		}
		else
		{
			bMeter = CoreTools::IsMeterUnitForHoleElevDim();
			nPrec = CoreTools::getPrecForHoleElevDim();
		}

		double d(dElve_mm);
		if (bMeter)
			d *= .001;

		CString format(_T(""));
		format.Format(_T("%s%%.%df%s"), s1.c_str(), nPrec, s2.c_str());

		CString s;
		s.Format(format, d);

		return s;
	}
}

bool AecDbEwPipeDim::GetElevation(double &dEle_mm)
{
	if (!HasElevation()) return false;

	CString sUp, sDw;
	if (!m_arsUps.IsEmpty())
		sUp = m_arsUps[0];
	if (!m_arsDowns.IsEmpty())
		sDw = m_arsDowns[0];

	int start, end;
	CString sElev;

	if (isHoleElevDim(this))
	{
		if (sUp.Find(ELE_FLAG) != -1)
		{
			getHoleElev(sUp, dEle_mm, start, end);
		}

		if (sDw.Find(ELE_FLAG) != -1)
		{
			getHoleElev(sDw, dEle_mm, start, end);
		}
	}
	else if (isPipeElevDim(this))
	{
		if (m_sUpScr.Find(ELE_FLAG) != -1)
		{
			getPipeElev(m_sUpScr, sUp, dEle_mm, start, end);
		}

		if (m_sDownScr.Find(ELE_FLAG) != -1)
		{
			getPipeElev(m_sDownScr, sDw, dEle_mm, start, end);
		}
	}

	sElev.Format(_T("%.2f"), dEle_mm);
	dEle_mm = TypeConvert::s2f(sElev);

	return true;
}

bool AecDbEwPipeDim::HasElevation()
{
	CString sUp, sDw;
	if (!m_arsUps.IsEmpty())
		sUp = m_arsUps[0];
	if (!m_arsDowns.IsEmpty())
		sDw = m_arsDowns[0];

	if (m_sUpScr.Find(ELE_FLAG) != -1)
		return true;

	if (m_sDownScr.Find(ELE_FLAG) != -1)
		return true;

	if (sUp.Find(ELE_FLAG) != -1)
		return true;

	if (sDw.Find(ELE_FLAG) != -1)
		return true;

	return false;
}

void AecDbEwPipeDim::ModifyElevation(const double &dDelta_m)
{
	AssertWriteEnabled();

	CString sUp, sDw;
	if (!m_arsUps.IsEmpty())
		sUp = m_arsUps[0];
	if (!m_arsDowns.IsEmpty())
		sDw = m_arsDowns[0];

	double dNew(dDelta_m * 1000), dOld;
	int start, end;
	if (isHoleElevDim(this))
	{
		if (sUp.Find(ELE_FLAG) != -1)
		{
			getHoleElev(sUp, dOld, start, end);
			dNew += dOld;
			sUp = makeNewString(sUp, start, end, dNew, false);
			if (!m_arsUps.IsEmpty())
				m_arsUps[0] = sUp;
		}

		if (sDw.Find(ELE_FLAG) != -1)
		{
			getHoleElev(sDw, dOld, start, end);
			dNew += dOld;
			sDw = makeNewString(sDw, start, end, dNew, false);
			if (!m_arsDowns.IsEmpty())
				m_arsDowns[0] = sDw;
		}
	}
	else if (isPipeElevDim(this))
	{
		if (m_sUpScr.Find(ELE_FLAG) != -1)
		{
			getPipeElev(m_sUpScr, sUp, dOld, start, end);
			dNew += dOld;
			sUp = makeNewString(sUp, start, end, dNew, true);
			if (!m_arsUps.IsEmpty())
				m_arsUps[0] = sUp;
		}

		if (m_sDownScr.Find(ELE_FLAG) != -1)
		{
			getPipeElev(m_sDownScr, sDw, dOld, start, end);
			dNew += dOld;
			sDw = makeNewString(sDw, start, end, dNew, true);
			if (!m_arsDowns.IsEmpty())
				m_arsDowns[0] = sDw;
		}
	}

	return;
}

int AecDbEwPipeDim::GetDraw2dables(Adesk::UInt16 nDrawStyle, AcDbVoidPtrArray &arEntPtrs) const
{
	assertReadEnabled();

	AcDbEntity *pEnt = NULL, *pEntT = NULL;
	const AcDbVoidPtrArray &ar2D = Get2DBuffer();
	for (int i = 0; i < ar2D.length(); i++)
	{
		pEnt = (AcDbEntity *)ar2D.at(i);
		pEntT = (AcDbEntity *)pEnt->clone();

		pEntT->setLayer(pEnt->layer());

		arEntPtrs.append(pEntT);
	}
	return arEntPtrs.length();
}

void AecDbEwPipeDim::saveAs(AcGiWorldDraw *pWd, AcDb::SaveType saveType)
{
	AcGiRegenType rtype = pWd->regenType();
	if (rtype == kAcGiSaveWorldDrawForProxy)
	{
		drawProxyEntity(&Get2DBuffer(), pWd);
	}
	else
	{
		AcDbEntity::saveAs(pWd, saveType);
	}
}


const AecDbObjXDataMap* AecDbEwPipeDim::GetSpecialtyData() const
{ 
	assertReadEnabled();
	return &m_mapSpecXData; 
	
}
AecDbObjXDataMap* AecDbEwPipeDim::GetSpecialtyData(AcDb::OpenMode bMode)
{
	if (bMode == AcDb::kForWrite)
	{
		if (!isWriteEnabled())
		{
			upgradeOpen();
		}
		assertWriteEnabled();
	}
	else
	{
		assertReadEnabled();
	}
	return &m_mapSpecXData;
}

bool AecDbEwPipeDim::SetCustomNoR(const double &v)
{
	AssertWriteEnabled();
	return m_mapSpecXData.SetAt(_Custom_No_R_, v) == 1 ? true : false;
}

double AecDbEwPipeDim::GetCustomNoR() const
{
	assertReadEnabled();
	double v;
	m_mapSpecXData.GetAt(_Custom_No_R_, v);
	return v;
}