// TDbPipeMultDim.cpp: implementation of the TDbPipeMultDim class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "TDbPipeMultDim.h"
#include "dbtext.h"
#include "DbPipe.h"
#include "pipetools.h"

extern void FullExplode(const AcDbEntity *pEnt, AcDbVoidPtrArray &entitySet);
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
BOOL StringAnalysis(const TCHAR *src, XString &sPrefix, int *num, int *numWidth)
{
	ASSERT(src && num && numWidth);
	int nLen=(int)_tcslen(src);
	if(!nLen)
		return FALSE;
	int iNumPos=nLen;
	for(int iPos=nLen-1; iPos>=0; iPos--) {
		if(!_istdigit(src[iPos]))
			break;
		else iNumPos=iPos;
	}
	if(iNumPos==nLen) {
		*numWidth=0; //No digit
	} else {
		if(iNumPos>0) {
			XString sTemp;
			sTemp=src;
			StrCpy(sTemp, src, src+iNumPos);
			sPrefix=sTemp;
		} else {
			sPrefix=_T("");
		}
		if(iNumPos==nLen-1) {
			*numWidth=-1;
		} else {
			if(src[iNumPos]==_T('0')) {
				*numWidth=nLen-(int)_tcslen(sPrefix);
			} else {
				*numWidth=-1;
			}
		}
		*num=_ttoi(src+iNumPos);
	}
	return TRUE;
}

////////////////////////////////////////////////////////
// 多线标注
// g_nVersion = 1 THvac6, g_nVersion = 2 THvac7, THvac8(B1), g_nVersion = 3 THvac8
// const Adesk::UInt8 TDbPipeMultDim::g_nVersion = 2; // ywb 2009-6-4
const Adesk::UInt8 TDbPipeMultDim::g_nVersion = 2;

#define MPIPE_DIM_TYPE	_T("MPipeDimType")		// 标注类型 0：默认 1：左侧
#define MPIPE_DIM_BULGE	_T("MPipeDimBulge")		// 多管标注 弧度

ACRX_DXF_DEFINE_MEMBERS(ATSPipeMultDim, ATSSymbWithText, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,  
						1, ATS_PIPEMULTDIM, "ATS_PIPEMULTDIM图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");

IMPLEMENT_TENTBASE(TDbPipeMultDim);


TDbPipeMultDim::TDbPipeMultDim()
{
	m_nTextHeight=3.5;
	m_iDimType = 0;
	//m_iDimStyle = 2;
}


TDbPipeMultDim::~TDbPipeMultDim()
{
}

BOOL TDbPipeMultDim::IsValid() const
{
	BOOL bRet=TDbSymbWithText::IsValid();
	if(!bRet)
		return bRet;
	//  bRet=(!!m_sText);
	return bRet;
}


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


// 提供对格式刷的支持
void TDbPipeMultDim::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
{
	assertWriteEnabled();
	TDbSymbWithText::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
	TDbPipeMultDim *pSrc=TDbPipeMultDim::cast(pSrcEntity);
	if(pSrc) {
		m_nTextBaseLen=pSrc->m_nTextBaseLen; //左右由正负控制
	}
}


// 从DWG读入数据:
Acad::ErrorStatus TDbPipeMultDim::dwgInFields (AcDbDwgFiler* pFiler)
{
	assertWriteEnabled();

	Acad::ErrorStatus es = TDbSymbWithText::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;
	}
	////////////////////////////////
	// 读入附件的ID
	m_lstPipe.Reset();
	Adesk::UInt8 nCount=0;
	pFiler->readItem(&nCount);
	for(Adesk::UInt8 i=0; i<nCount; i++) {
		AcDbSoftPointerId id; // Debug Test Only
		pFiler->readItem(&id);
		m_lstPipe.Append(new AcDbSoftPointerId(id));
	}

	pFiler->readItem(&m_nTextBaseLen); 
	pFiler->readItem((AcGePoint2d *)&m_ptStart);
	pFiler->readItem((AcGePoint2d *)&m_ptTurn);
	if(nVer > 1){
		pFiler->readItem(&m_iDimType);
		ReadString(pFiler,m_sSpare);
	}
	// 	if (nVer > 2)
	// 		pFiler->readItem(&m_iDimStyle);

	return pFiler->filerStatus();
}

Acad::ErrorStatus TDbPipeMultDim::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	assertReadEnabled();
	Acad::ErrorStatus es = TDbSymbWithText::dwgOutFields(pFiler);
	if(es != Acad::eOk) return es;
	if(g_nSaveTArchVer==6)
		pFiler->writeItem((Adesk::UInt8)1);
	else if (g_nSaveTArchVer == 7)
		pFiler->writeItem((Adesk::UInt8)2);
	else
		pFiler->writeItem(g_nVersion);

	// 写出附件的ID
	Adesk::UInt8 nCount=(Adesk::UInt8)m_lstPipe.Length();
	pFiler->writeItem(nCount);
	for(Adesk::UInt8 i=0; i<nCount; i++) {
		pFiler->writeItem(m_lstPipe[i]);
	}

	pFiler->writeItem(m_nTextBaseLen); 
	pFiler->writeItem((const AcGePoint2d &)m_ptStart);
	pFiler->writeItem((const AcGePoint2d &)m_ptTurn);
	if(g_nSaveTArchVer>6){
	//  cet 2016.7.19 modify 9.0之前编号样式打开崩溃，改为管径样式
	//	pFiler->writeItem(m_iDimType);
		Adesk::UInt16 nDimType = m_iDimType;
		if (g_nSaveTArchVer < 9 && m_iDimType == 1) 
		{
			nDimType = 0;
		}
		pFiler->writeItem(nDimType);
		pFiler->writeItem((const TCHAR *)m_sSpare);
	}

	// 	if (g_nSaveTArchVer > 7)
	// 		pFiler->writeItem(m_iDimStyle);

	return pFiler->filerStatus();
}

Acad::ErrorStatus TDbPipeMultDim::dxfInFields (AcDbDxfFiler* pFiler)
{
	assertWriteEnabled();

	double n = m_nTextHeight;
	Acad::ErrorStatus es =  TDbSymbWithText::dxfInFields(pFiler);
	if(es!=Acad::eOk)
		return pFiler->filerStatus();
	if (!pFiler->atSubclassData(_T("TDbPipeMultDim"))) {
		return Acad::eBadDxfSequence;
	}

	int fieldsFlags=0;
	resbuf rb;
	XPoint pt1, pt2;
	double nBaseLen;
	XString sText;
	while ((es == Acad::eOk)
		&& ((es = pFiler->readResBuf(&rb)) == Acad::eOk))
	{
		switch (rb.restype) {
		case AcDb::kDxfXCoord:
			pt1=rb.resval.rpoint;
			break;
		case AcDb::kDxfXCoord+1:
			pt2=rb.resval.rpoint;
			break;
		case AcDb::kDxfText:
			sText=rb.resval.rstring;
			free(rb.resval.rstring);
			break;
		case AcDb::kDxfReal+1:
			nBaseLen=rb.resval.rreal;
			break;		
		default:
			// An unrecognized group. Push it back so that
			// the subclass can read it again.
			pFiler->pushBackItem();
			es = Acad::eEndOfFile;
			break;
		}
	}
	if (es != Acad::eEndOfFile)
		return Acad::eInvalidResBuf;

	m_ptStart=pt1;
	m_ptTurn=pt2;
	if(fabs(m_nTextHeight - n) > 0.01)//如果是修改了字高，还需要调整文字下面的线长
		m_nTextBaseLen = GetDefaultTextBaseLen()*1.5;
	else
		m_nTextBaseLen=nBaseLen;
	return pFiler->filerStatus();
}

Acad::ErrorStatus TDbPipeMultDim::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	assertReadEnabled();
	Acad::ErrorStatus es=TDbSymbWithText::dxfOutFields(pFiler);
	assert(es == Acad::eOk);
	es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbPipeMultDim"));
	assert(es == Acad::eOk);
	pFiler->writePoint2d(AcDb::kDxfXCoord, m_ptStart.AsAcGePoint2d());
	pFiler->writePoint2d(AcDb::kDxfXCoord+1, m_ptTurn.AsAcGePoint2d());
	pFiler->writeDouble(AcDb::kDxfReal+1, m_nTextBaseLen);
	return es;
}



// -----------------------------------------------------------------------
// Active when being rotated, scaled, moved, etc.
// Scale is disabled here
Acad::ErrorStatus 
TDbPipeMultDim::subTransformBy(const AcGeMatrix3d& xform)
{
	assertWriteEnabled();
	TDbEntity::subTransformBy(xform);
	ads_matrix mat;
	AsAdsMatrix(xform, mat);

	m_ptStart.TransformBy(mat);
	m_ptTurn.TransformBy(mat);
	if(xform.isUniScaledOrtho()) 
		m_nTextBaseLen *= xform(0,0);
	if(IsMirrorMatrix(xform)) { //设备镜像 sr add 2005/6/7
		XPoint ptOrg, ptX(1000, 0), ptY(0, 1000);
		ptOrg.TransformBy(xform);
		ptX.TransformBy(xform);
		ptY.TransformBy(xform);
		double nA1 = CT_std_angle(ads_angle(ptOrg, ptY));
		double nA2 = CT_std_angle(ads_angle(ptOrg, ptX));
		if(fabs(nA2 - PI) < _angSnap)//以Y轴镜像需要把标注翻转，而以X轴镜像则不需要
			m_nTextBaseLen = m_nTextBaseLen*(-1);
	}

	return Acad::eOk;
}


// Overriden functions for edit
Acad::ErrorStatus TDbPipeMultDim::subGetGripPoints(AcGePoint3dArray&  gripPoints,
												   AcDbIntArray&  osnapModes,
												   AcDbIntArray&  geomIds) const
{
	assertReadEnabled();
	return subGetStretchPoints(gripPoints);
}

// stretch points is diffrent from grep points, with no midpoint included
Acad::ErrorStatus  
TDbPipeMultDim::subGetStretchPoints(AcGePoint3dArray & gripPoints) const
{
	assertReadEnabled();
	gripPoints.append(m_ptStart);
	gripPoints.append(m_ptTurn);
	XPoint ptTemp;
	//modify yxx 2015-6-10 单管管径标注翻转
	// ads_polar(m_ptTurn, m_nLayoutRotation, GetTextBaseLen(FALSE), ptTemp); 
	int iLabelType = GetLabelType();
	if ( iLabelType == 1)
		ads_polar(m_ptTurn, m_nLayoutRotation-PI, GetTextBaseLen(FALSE), ptTemp);
	else
		ads_polar(m_ptTurn, m_nLayoutRotation, GetTextBaseLen(FALSE), ptTemp);
	//end yxx
	gripPoints.append(ptTemp);
	return Acad::eOk;
}

// 功能: 夹点操作
Acad::ErrorStatus TDbPipeMultDim::subMoveGripPointsAt(
	const AcDbIntArray& indices,
	const AcGeVector3d& offset)
{
	assertWriteEnabled();
	XPoint vtOffset(offset[0], offset[1]);
	for (int i = 0; i < indices.length(); i++) {
		int idx = indices[i];
		if(idx==0) { // Move vertex
			m_ptStart += vtOffset;
		} else if(idx==1) {
			m_ptTurn += vtOffset;
		} else if(idx==2) {
			XPoint ptTemp;
			//modify yxx 2015-6-10 单管管径标注翻转
			// ads_polar(m_ptTurn, m_nLayoutRotation, GetTextBaseLen(FALSE), ptTemp);
			int iLabelType = GetLabelType();
			if ( iLabelType == 1)
				ads_polar(m_ptTurn, m_nLayoutRotation - PI, GetTextBaseLen(FALSE), ptTemp);
			else
				ads_polar(m_ptTurn, m_nLayoutRotation, GetTextBaseLen(FALSE), ptTemp);
			//end
			XVector3D vt = ptTemp - m_ptTurn;
			vt.Normalize();
			//XVector3D vt(1.0, 0.0);
			double nVal = (vtOffset&vt);
			if(m_nTextBaseLen > 0)
				m_nTextBaseLen += nVal/GetPScale();
			else
				m_nTextBaseLen -= nVal/GetPScale();
		}
	}
	return Acad::eOk;
}


// 功能: 夹点操作
Acad::ErrorStatus TDbPipeMultDim::subMoveStretchPointsAt(
	const AcDbIntArray& indices,
	const AcGeVector3d& offset)
{
	assertWriteEnabled();
	return subMoveGripPointsAt(indices, offset);
}



// 取得夹点说明
Acad::ErrorStatus TDbPipeMultDim::GetGripText(int idx, CString &cs) const
{
	Acad::ErrorStatus es=Acad::eOk;
	if(idx==0)
		cs=_T("移动标注点");
	else if(idx==1)
		cs=_T("移动转折点");
	else
		cs=_T("拉伸文字线");

	return es;
}

void TDbPipeMultDim::Update()
{
	assertWriteEnabled();
	m_lstPipe.Reset();
	struct resbuf *pointlist;
	PickSet ss(SS_FREE);
	XPoint ptUcsS, ptUcsE;
	ptUcsS = Wcs2Ucs(m_ptStart);
	ptUcsE = Wcs2Ucs(m_ptTurn);

	pointlist = ads_buildlist(RTPOINT, &ptUcsS, RTPOINT, &ptUcsE, NULL); 
	ss.Get(_T("F"), pointlist, NULL, RBList(RTDXF0, _T("ATS_PIPE"), 0));
	ads_relrb(pointlist);
	if(ss.Length() < 1)
		return;
	for (long i=0;i<ss.Length(); i++){
		Entity ent = ss[i];
		AcDbObjectId id = NULL;
		acdbGetObjectId(id, ent);
		AddPipe(id);
	}        
}

Acad::ErrorStatus 
TDbPipeMultDim::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
	// cet 2016.10.17 add 图层关闭时，实体不显示，不进行绘制（打印时，也不会绘制）
	AcDbLayerTableRecordPointer player(this->layerId(), AcDb::kForRead);
	if (player.openStatus() == Acad::eOk && player->isOff())
	{
		return Acad::eOk;
	}
	double nShortLineLen = m_nTextHeight*GetPScale();
	assertReadEnabled();
	if(!IsValid())
		return Acad::eInvalidInput;
	XStringList lstTexts;
	GetTexts(lstTexts);

	dc << XLine(m_ptStart, m_ptTurn);
	// double nLineSpace = (DocGetText2Base()*2+m_nTextHeight)*GetPScale();
	double nLineSpace = (GetDimDist2Line()+m_nTextHeight)*GetPScale();

	ads_matrix matRot;
	m_ptStart.GetRotationMatrix(-m_nLayoutRotation, matRot);
	XPoint ptTurn=m_ptTurn.TransformAs(matRot);
	XPoint ptStart=m_ptStart.TransformAs(matRot);
	if(ptTurn.y > ptStart.y + 1.0E-3)
		lstTexts.Reverse();
	else
		nLineSpace = - nLineSpace;

	double nTextBaseLen=GetTextBaseLen(FALSE);
	// double nSpacer=DocGetText2Base()*GetPScale()/2;
	double nSpacer=GetDimDist2Line()*GetPScale()/4;

	XLine lineBase(m_ptStart, m_ptTurn, 1);
	lineBase.StartPoint().z = 0;
	lineBase.EndPoint().z = 0;
	XPoint ptInt;

	int iDimStyle = GetDimStyle();
	if(m_lstPipe.Length() > 1)
	{
		double dBulge = GetBulge();
		//绘制斜叉
		for(int i=0;i<m_lstPipe.Length();i++)
		{
			switch (iDimStyle)
			{
			case 1:		// 点样式
				{
					AcDbObjectId id = m_lstPipe[i];//const
					OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPipe, pPipe);
					if(pPipe && !pPipe->IsVertical())
					{
						//add by yxx  2015-6-12 多管标注
						if ( fabs(dBulge) > g_fZero )
						{
							XArc arc(pPipe->GetStartPoint(), pPipe->GetEndPoint(), dBulge);
							int ret = arc.Intersection(&lineBase, ptInt);
							if(!!ptInt && ret == 1)
							{
								AcGeVector3d vt = lineBase.Direction3d();
								vt.normalize();
								AcGePoint3d ptS = AcGePoint3d::kOrigin;
								ptS = ptInt + vt * GetPScale() / 100 * 20;
								AcGePoint3d ptE = AcGePoint3d::kOrigin;
								ptE = ptInt - vt * GetPScale() / 100 * 20;
								AcDbPolyline PLine;
								PLine.addVertexAt(0, AcGePoint2d(ptS.x, ptS.y), -1);
								PLine.addVertexAt(1, AcGePoint2d(ptE.x, ptE.y), -1);
								PLine.setConstantWidth(GetPScale() * 40 / 100);
								PLine.setClosed(Adesk::kTrue);
								dc.DrawEntity(PLine);
							}
							
						}//end yxx
						else
						{
							XLine line(pPipe->GetStartPoint(), pPipe->GetEndPoint(), 1);
							line.StartPoint().z = 0;
							line.EndPoint().z = 0;
							int ret = line.Intersection(&lineBase, ptInt);
							if(!!ptInt)
							{
								AcGeVector3d vt = line.Direction3d();
								vt.normalize();
								AcGePoint3d ptS = AcGePoint3d::kOrigin;
								ptS = ptInt + vt * GetPScale() / 100 * 20;
								AcGePoint3d ptE = AcGePoint3d::kOrigin;
								ptE = ptInt - vt * GetPScale() / 100 * 20;
								AcDbPolyline PLine;
								PLine.addVertexAt(0, AcGePoint2d(ptS.x, ptS.y), -1);
								PLine.addVertexAt(1, AcGePoint2d(ptE.x, ptE.y), -1);
								PLine.setConstantWidth(GetPScale() * 40 / 100);
								PLine.setClosed(Adesk::kTrue);
								dc.DrawEntity(PLine);
							}
						}
					}
					OPENOBJ_END();
				}
				break;
			case 2:		// 斜线样式
				{
					CString csText;
					AcDbObjectId id = m_lstPipe[i];//const
					OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPipe, pPipe);
					if(pPipe && !pPipe->IsVertical())
					{
						//add by yxx  2015-6-12 多管标注
						if ( fabs(dBulge) > g_fZero )
						{
							XArc arc(pPipe->GetStartPoint(), pPipe->GetEndPoint(), dBulge);
							int ret = arc.Intersection(&lineBase, ptInt);
							if(!!ptInt && ret == 1)
							{
								double nAngPipe = lineBase.Direction();
								double angTmp(0.0);
								angTmp = nAngPipe + PI/4;
								XPoint pt1, pt2;
								ads_polar(ptInt, angTmp, nShortLineLen/2, pt1);
								ads_polar(pt1, angTmp + PI, nShortLineLen, pt2);
								dc << XLine(pt1, pt2);
							}
						}//end yxx
						else
						{
							XLine line(pPipe->GetStartPoint(), pPipe->GetEndPoint(), 1);
							line.StartPoint().z = 0;
							line.EndPoint().z = 0;
							int ret = line.Intersection(&lineBase, ptInt);

							if(!!ptInt && ret == 1)
							{
								double nAngPipe = line.Direction();
								double nAngBase = lineBase.Direction();
								double ang = nAngPipe - nAngBase;
								if(ang < 0)
									ang += PI*2;
								if(ang > PI)
									ang -= PI;
								double angTmp(0.0);
								if(ang < (PI - 0.001) && ang < (PI/2 - 0.001))
									angTmp = nAngPipe + PI/4;
								else
									angTmp = nAngPipe + PI/4 + PI/2;
								XPoint pt1, pt2;
								ads_polar(ptInt, angTmp, nShortLineLen/2, pt1);
								ads_polar(pt1, angTmp + PI, nShortLineLen, pt2);
								dc << XLine(pt1, pt2);
							}
						}
					}
					OPENOBJ_END();
				}
				break;
			default:
				break;
			}
		}
	}

	CString strText; // cet 2011.4.25 add 保存标高标注信息
	double nDist2Turn=0.0;
	for(int i=0; i<lstTexts.Length(); i++) {
		// cet 2011.4.25 add 标高标注
		if (m_iDimType == 3)
		{
			if (!strText.IsEmpty())
			{
				strText = _T("\n") + strText;
			}
			else// zxl 2013.04.23 add 标高标注对齐
			{
				strText = _T(" ");
			}
			strText = lstTexts[i] + strText;
			continue;
		}

		double nAngleTurn = ads_angle(m_ptStart, m_ptTurn);
		double nPlus(0); //sr modify 2005-6-10
		if(fabs(m_nLayoutRotation) < 0.001){ 
			if(nAngleTurn > 0 && nAngleTurn < PI)
				nPlus = PI/2;
			else
				nPlus = -PI/2;
		}
		else if(fabs(m_nLayoutRotation - PI/2) < 0.001){
			if(nAngleTurn > (PI/2 - 0.001) && nAngleTurn < PI/2*3)
				nPlus = PI/2;
			else
				nPlus = -PI/2;
		}
		else if(m_nLayoutRotation < PI/2){
			if(nAngleTurn > (PI/2 - 0.001) && nAngleTurn < PI/2*3)
				nPlus = PI/2;
			else
				nPlus = -PI/2;
		}
		else if(m_nLayoutRotation > PI){
			if(nAngleTurn > 0 && nAngleTurn < PI)
				nPlus = PI/2;
			else
				nPlus = -PI/2;
		}

		XPoint ptTextBeg, ptTextEnd;
		ptTextBeg = m_ptTurn;
		ads_polar(XPoint(ptTextBeg), m_nLayoutRotation+nPlus, nDist2Turn, ptTextBeg);
		ptTextEnd=ptTextBeg;
		//modify yxx 2015-6-10 单管管径标注翻转
		//ads_polar(XPoint(ptTextEnd), m_nLayoutRotation, nTextBaseLen, ptTextEnd);
		int iLabelType = GetLabelType();
		if ( iLabelType == 1)
			ads_polar(XPoint(ptTextEnd), m_nLayoutRotation - PI, nTextBaseLen, ptTextEnd);
		else
			ads_polar(XPoint(ptTextEnd), m_nLayoutRotation, nTextBaseLen, ptTextEnd);
		//end  yxx
		if(i==lstTexts.Length()-1) {
			XPoint ptEnd;
			ads_polar(m_ptTurn, m_nLayoutRotation+nPlus, nDist2Turn, ptEnd);
			dc << XLine(m_ptTurn, ptEnd);
		}

		TDbMText text;
		text.setPropertiesFrom(this);
		CString sText;
		if(nPlus > 0)
			sText = lstTexts[i];
		else
			sText = lstTexts[lstTexts.Length()-i-1];
		//      cet 2014.5.23 del 由于一些特殊字符如"▽",无法正确显示，需特殊处理
		// 		int nIndex = sText.Find(_T("▽"), 0);
		// 		CString sBefore, sEnd;
		// 		if (nIndex >= 0)
		// 		{
		// 			sBefore = sText.Left(nIndex);
		// 			int nSize = 2;
		// #if (ADS != 15)
		// 			nSize = 1;
		// #endif
		// 			sEnd = sText.Right(sText.GetLength() - nIndex - nSize);
		// 			sText = sBefore + _T("    ") + sEnd;
		// 		}

		text.SetText(sText);
		text.SetStyleId(m_idTextStyle);
		if(!!m_idTextLayer)
			text.setColorIndex(GetTextColor());
		//	text.setLayer(m_idTextLayer);
		text.SetHeight(m_nTextHeight);
		XPoint ptText=ptTextEnd;
		XPoint ptTempEnd=ptTextEnd.TransformAs(matRot);
		XPoint ptTempBeg=ptTextBeg.TransformAs(matRot);
		XExplodeDraw::TextAlignment align;

		int nAlignType = GetDimAlignType();
		if(ptTempEnd.x>ptTempBeg.x) {
			// ads_polar(ptTextBeg, m_nLayoutRotation, 4*nSpacer, ptText); zxl 2013.01.21 modify
			if (nAlignType == 0)// 左对齐时
			{
				ads_polar(ptTextBeg, m_nLayoutRotation, nSpacer, ptText);
			}
			else
			{
				ads_polar(ptTextBeg, m_nLayoutRotation, 0, ptText);
			}
		}
		((TDbMText &)text).SetPageWidth(max(max(fabs(nTextBaseLen), fabs(nLineSpace)), GetDefaultTextBaseLen() * GetPScale()), FALSE);
		((TDbMText &)text).SetLineSpace(nSpacer, FALSE);
		ads_polar(XPoint(ptText), m_nLayoutRotation+PI/2, nSpacer, ptText);
		//         if(ptTempEnd.x>ptTempBeg.x) 
		//             align = XExplodeDraw::kRight; //XExplodeDraw::kBottomRight;
		//         else
		//             align = XExplodeDraw::kLeft; //XExplodeDraw::kBottomLeft;

		if (nAlignType == 0)
		{
			align = XExplodeDraw::kLeft;
		}
		else if (nAlignType == 1)
		{
			align = XExplodeDraw::kCenter;
		}
		else
		{
			align = XExplodeDraw::kRight;
		}
		//      cet 2014.5.15 modify 当nPlus < 0时，计算间距错误
		// 		XVector3D vtExt = text.GetExtents();
		// 		nDist2Turn += vtExt.y + nSpacer*4.0;
		XVector3D vtExt;
		if (nPlus < 0)
		{
			if (lstTexts.Length() - i - 2 >= 0)
			{
				CString sText1 = lstTexts[lstTexts.Length() - i - 2];
				text.SetText(sText1);
			}
			vtExt = text.GetExtents();
			nDist2Turn += vtExt.y + nSpacer*4.0;
			text.SetText(sText);
			vtExt = text.GetExtents();
		}
		else
		{
			vtExt = text.GetExtents();
			nDist2Turn += vtExt.y + nSpacer*4.0;
		}

		XPoint ptLoc = ptText;
		ads_polar(XPoint(ptLoc), m_nLayoutRotation+PI/2, m_nTextHeight * GetPScale() + nSpacer, ptLoc);
		ads_polar(XPoint(ptText), m_nLayoutRotation+PI/2, vtExt.y+nSpacer, ptText);
		if(m_nTextBaseLen < 0){ //使左侧的文字离边界200
			//ads_polar(ptText, m_nLayoutRotation, 200, ptText);
			//text.SetAlignment(align);
		}
		// text.setLayer(m_idTextLayer);
		text.setColorIndex(GetTextColor());
		text.SetAlignment(align);
		text.SetLocation(ptText);
		// 绘制特殊字符
		bool bFlag = false;
		if (IsIncludeSpeicalChar(sText))
		{
//          cet 2017.9.11 modify 重新实现绘制包含特殊符号的字符串
//			// 绘制特殊字符
//			DrawSpecialCharForDnElevationType(dc, sText, ptTextBeg, ptTextEnd, ptLoc, text.GetLineSpace());
// 			// 替换特殊字符
// 			ReplaceSpecialChar(sText);
// 			text.SetText(sText);
			bFlag = true;
			DrawSpecialCharForDnElevationType(dc, sText, ptTextBeg, ptTextEnd, ptText, text.GetLineSpace());
		}
		if (!bFlag)
		{
			TPushProperty vProp(&text, dc);
			if(dc.IsFullExplode())
				text.ExplodeOrDraw2d(dc);
			else
				dc.DrawEntity(text);
		}

		dc << XLine(ptTextBeg, ptTextEnd);
	}

	// cet 2011.4.25 add
	if (!strText.IsEmpty())
	{
		XPoint ptTemp;
		ads_polar(XPoint(m_ptTurn), m_nLayoutRotation, nTextBaseLen, ptTemp);
		dc << XLine(m_ptTurn, ptTemp);
		AcGeVector3d vtOffset;
		double dVtAngle = ads_angle(Wcs2Ucs(m_ptStart), Wcs2Ucs(m_ptTurn));
		// zxl modify 2013.04.22
		// 		if (dVtAngle > 0 && dVtAngle < PI + g_fZero)
		// 		{
		// 			vtOffset = AcGeVector3d(0, 1, 0);
		// 		}
		// 		else 
		// 		{
		// 			vtOffset = AcGeVector3d(0, -1, 0);
		// 		}
		if (nTextBaseLen > 0.0)
		{
			if (dVtAngle > 0 && dVtAngle < PI + g_fZero)
			{
				vtOffset = AcGeVector3d(0, 1, 0);
			}
			else 
			{
				vtOffset = AcGeVector3d(0, -1, 0);
			}
		}
		else
		{
			if (dVtAngle > 0 && dVtAngle < PI + g_fZero)
			{
				vtOffset = AcGeVector3d(-1, 1, 0);
			}
			else 
			{
				vtOffset = AcGeVector3d(-1, -1, 0);
			}
		}
		vtOffset = Ucs2Wcs(vtOffset, TRUE);

		TDbSymbElevation text;
		text.setPropertiesFrom(this);  // cet 2011.12.19 add 标注文字大小随对象比例变化
		ads_polar(XPoint(m_ptTurn), m_nLayoutRotation, nTextBaseLen * 0.5, ptTemp);
		text.SetLocation(ptTemp);
		text.SetText(strText);
		text.SetBaseLine(FALSE);
		text.setColorIndex(GetTextColor());
		text.SetLeader(FALSE);
		text.SetTextHeight(m_nTextHeight);
		text.SetTextStyleId(m_idTextStyle);
		text.SetLayoutRotation(Ucs2Wcs(0.0));
		if (m_nTextBaseLen < 0.0)
		{
			text.SetAtLineSide(FALSE);
		}
		else
		{
			text.SetAtLineSide(TRUE);
		}

		AcDbIntArray indices;
		indices.append(1);
		if (vtOffset.length() > _DIST_SNAP*10)
		{
			vtOffset.normalize();
			double dScale = (2*DocGetEleTriangleSize() + 0.5) * GetPScale();
			vtOffset *= dScale;
			text.moveGripPointsAt(indices, vtOffset);
		}

		double dAngle = ads_angle(Wcs2Ucs(m_ptTurn), Wcs2Ucs(ptTemp));
		// zxl 2013.04.22 add
		if (m_nTextBaseLen < 0.0)
		{
			dAngle += PI;
		}
		text.SetLayoutRotation(Ucs2Wcs(dAngle));
		// 设置标高标注文字基线长度
		text.SetTextBaseLen(GetDefaultTextBaseLen());
		// 绘制特殊字符
		if (IsIncludeSpeicalChar(strText))
		{
//          cet 2017.9.11 modify 重新实现绘制特殊符号的字符串
// 			// 绘制特殊字符
// 			DrawSpecialCharForElevationType(dc, strText, m_ptTurn, ptTemp, text.GetTextPoint(), text.GetText2BaseRatio(FALSE, TRUE));
//  		// 替换特殊字符
//  		ReplaceSpecialChar(strText);
//  		text.SetText(strText);
			text.SetText(strText);
			DrawSpecialCharForElevationType(dc, text);
			return Acad::eOk;
		}

		if(dc.IsFullExplode())
		{
			text.ExplodeOrDraw2d(dc);
		}
		else
		{
			dc.DrawEntity(text);
		}
	}

	return Acad::eOk;
}



//读扩展数据
CString ReadXdata(Entity ent, const TCHAR*szName)
{
	AcDbObjectId eId;
	AcDbEntity *pEnt = NULL;
	acdbGetObjectId(eId, ent);
	acdbOpenObject(pEnt, eId, AcDb::kForRead);
	if(!pEnt)
		return _T("");
	resbuf  *pRb = pEnt->xData(szName);

	CString csRet;
	if (pRb != NULL)   	{  
		resbuf  *pTemp = pRb; 
		if (pTemp->rbnext != NULL)	{
			pTemp = pTemp->rbnext;
			if (pTemp->restype == 1000)	
				csRet = pTemp->resval.rstring;	
		}
	}	
	ads_relrb(pRb);
	pEnt->close();
	return csRet;
}

//读扩展数据 cet 2014.6.4 add 
CString ReadXdata(const AcDbEntity*pEnt, const TCHAR*szName)
{
	if(!pEnt)
		return _T("");
	resbuf  *pRb = pEnt->xData(szName);

	CString csRet;
	if (pRb != NULL)   	{  
		resbuf  *pTemp = pRb; 
		if (pTemp->rbnext != NULL)	{
			pTemp = pTemp->rbnext;
			if (pTemp->restype == 1000)	
				csRet = pTemp->resval.rstring;	
		}
	}	
	ads_relrb(pRb);
	return csRet;
}

// cet 2014.6.18 add  是否存在扩展数据
bool IncludeXdate(const AcDbEntity*pEnt, const TCHAR*szName)
{
	if(!pEnt)
		return false;
	resbuf  *pRb = pEnt->xData(szName);
	CString csRet;
	if (pRb == NULL)   
	{  
		return false;
	}	
	ads_relrb(pRb);
	return true;
}

extern CString g_csPipeDim[35];

// 已知管线图层名称，返回管线类别INDEX cet 2016.6.7 del 不再直接使用图层宏
// int GetPipeLayerIdxByName(const TCHAR* szLayer)
// {
// 	CString csLayer;
// 	csLayer = (const TCHAR*)szLayer;
// 
// 	int ret = 0;
// 	if(csLayer == LAY_PIPE_FEED || csLayer == LAY_VPIPE_FEED)
// 		ret = 0;
// 	else if(csLayer == LAY_PIPE_HEADFEED || csLayer == LAY_VPIPE_HEADFEED)
// 		ret = 1;
// 	else if(csLayer == LAY_PIPE_HEADBACK || csLayer == LAY_VPIPE_HEADBACK)
// 		ret = 2;
// 	else if(csLayer == LAY_PIPE_DIRT || csLayer == LAY_VPIPE_DIRT)
// 		ret = 3;
// 	else if(csLayer == LAY_PIPE_USELESS || csLayer == LAY_VPIPE_USELESS)
// 		ret = 4;
// 	else if(csLayer == LAY_PIPE_RAIN || csLayer == LAY_VPIPE_RAIN)
// 		ret = 5;
// 	else if(csLayer == LAY_PIPE_USED || csLayer == LAY_VPIPE_USED)
// 		ret = 6;
// 	else if(csLayer == LAY_PIPE_FIRE || csLayer == LAY_VPIPE_FIRE)
// 		ret = 7;
// 	else if(csLayer == LAY_PIPE_SPRINKLE || csLayer == LAY_VPIPE_SPRINKLE)
// 		ret = 8;
// 	else if(csLayer == LAY_PIPE_COAGULATE || csLayer == LAY_VPIPE_COAGULATE)
// 		ret = 9;
// 	else if(csLayer == LAY_PIPE_DRINK || csLayer == LAY_VPIPE_DRINK)
// 		ret = 10;
// 	else if(csLayer == LAY_PIPE_PRESSDIRT || csLayer == LAY_VPIPE_PRESSDIRT)
// 		ret = 11;
// 	else if(csLayer == LAY_PIPE_PRESSUSELESS || csLayer == LAY_VPIPE_PRESSUSELESS)
// 		ret = 12;
// 	else if(csLayer == LAY_PIPE_PRESSRAIN || csLayer == LAY_VPIPE_PRESSRAIN)
// 		ret = 13;
// 	else if(csLayer == LAY_PIPE_OTHER || csLayer == LAY_VPIPE_OTHER)
// 		ret = 14;
// 	else if(csLayer == LAY_PIPE_USER1 || csLayer == LAY_VPIPE_USER1)
// 		ret = 15;
// 	else if(csLayer == LAY_PIPE_USER2 || csLayer == LAY_VPIPE_USER2)
// 		ret = 16;
// 	else if(csLayer == LAY_PIPE_FEED2 || csLayer == LAY_VPIPE_FEED2)
// 		ret = 17;
// 	else if(csLayer == LAY_PIPE_FEED3 || csLayer == LAY_VPIPE_FEED3)
// 		ret = 18;
// 	else if(csLayer == LAY_PIPE_HEADFEED2 || csLayer == LAY_VPIPE_HEADFEED2)
// 		ret = 19;
// 	else if(csLayer == LAY_PIPE_HEADFEED3 || csLayer == LAY_VPIPE_HEADFEED3)
// 		ret = 20;
// 	else if(csLayer == LAY_PIPE_HEADBACK2 || csLayer == LAY_VPIPE_HEADBACK2)
// 		ret = 21;
// 	else if(csLayer == LAY_PIPE_HEADBACK3 || csLayer == LAY_VPIPE_HEADBACK3)
// 		ret = 22;
// 	else if(csLayer == LAY_PIPE_FIRE2 || csLayer == LAY_VPIPE_FIRE2)
// 		ret = 23;
// 	else if(csLayer == LAY_PIPE_FIRE3 || csLayer == LAY_VPIPE_FIRE3)
// 		ret = 24;
// 	else if(csLayer == LAY_PIPE_SPRINKLE2 || csLayer == LAY_VPIPE_SPRINKLE2)
// 		ret = 25;
// 	else if(csLayer == LAY_PIPE_SPRINKLE3 || csLayer == LAY_VPIPE_SPRINKLE3)
// 		ret = 26;
// 	else if(csLayer == LAY_PIPE_USED2 || csLayer == LAY_VPIPE_USED2)
// 		ret = 27;
// 	else if(csLayer == LAY_PIPE_USED3 || csLayer == LAY_VPIPE_USED3)
// 		ret = 28;
// 	else if (csLayer == LAY_PIPE_USER3 || csLayer == LAY_VPIPE_USER3) // cet 2012.2.7 add user3-user8
// 		ret = 29;
// 	else if (csLayer == LAY_PIPE_USER4 || csLayer == LAY_VPIPE_USER4) 
// 		ret = 30;
// 	else if (csLayer == LAY_PIPE_USER5 || csLayer == LAY_VPIPE_USER5) 
// 		ret = 31;
// 	else if (csLayer == LAY_PIPE_USER6 || csLayer == LAY_VPIPE_USER6) 
// 		ret = 32;
// 	else if (csLayer == LAY_PIPE_USER7 || csLayer == LAY_VPIPE_USER7) 
// 		ret = 33;
// 	else if (csLayer == LAY_PIPE_USER8 || csLayer == LAY_VPIPE_USER8) 
// 		ret = 34;
// 	else
// 		ret = -1;
// 	return ret;
// }

int GetPipeLayerIdxBySys(TPipeSys::SysType sys)
{
	int ret = 0;
	if(sys == TPipeSys::kFeedWater)
		ret = 0;
	else if(sys == TPipeSys::kHeatFeedWater)
		ret = 1;
	else if(sys == TPipeSys::kHeatBackWater)
		ret = 2;
	else if(sys == TPipeSys::kDirtWater)
		ret = 3;
	else if(sys == TPipeSys::kUselessWater)
		ret = 4;
	else if(sys == TPipeSys::kRainWater)
		ret = 5;
	else if(sys == TPipeSys::kUsedWater)
		ret = 6;
	else if(sys == TPipeSys::kFireFighting)
		ret = 7;
	else if(sys == TPipeSys::kSprinkle)
		ret = 8;
	else if(sys == TPipeSys::kCoagulate)
		ret = 9;
	else if(sys == TPipeSys::kDrink)
		ret = 10;
	else if(sys == TPipeSys::kPressDirt)
		ret = 11;
	else if(sys == TPipeSys::kPressUseless)
		ret = 12;
	else if(sys == TPipeSys::kPressRain)
		ret = 13;
	else if(sys == TPipeSys::kOther)
		ret = 14;
	else if(sys == TPipeSys::kCivilFeed)
		ret = 15;
	else if(sys == TPipeSys::kCycleFeed)
		ret = 16;
	else if(sys == TPipeSys::kFeedWater2)
		ret = 17;
	else if(sys == TPipeSys::kFeedWater3)
		ret = 18;
	else if(sys == TPipeSys::kHeatFeedWater2)
		ret = 19;
	else if(sys == TPipeSys::kHeatFeedWater3)
		ret = 20;
	else if(sys == TPipeSys::kHeatBackWater2)
		ret = 21;
	else if(sys == TPipeSys::kHeatBackWater3)
		ret = 22;
	else if(sys == TPipeSys::kFireFighting2)
		ret = 23;
	else if(sys == TPipeSys::kFireFighting3)
		ret = 24;
	else if(sys == TPipeSys::kSprinkle2)
		ret = 25;
	else if(sys == TPipeSys::kSprinkle3)
		ret = 26;
	else if(sys == TPipeSys::kUsedWater2)
		ret = 27;
	else if(sys == TPipeSys::kUsedWater3)
		ret = 28;
	else if (sys == TPipeSys::kUser3)
		ret = 29;
	else if (sys == TPipeSys::kUser4) 
		ret = 30;
	else if (sys == TPipeSys::kUser5) 
		ret = 31;
	else if (sys == TPipeSys::kUser6) 
		ret = 32;
	else if (sys == TPipeSys::kUser7) 
		ret = 33;
	else if (sys == TPipeSys::kUser8) 
		ret = 34;
	else
		ret = -1;
	return ret;
}

extern CString I2Str(double i);

void TDbPipeMultDim::GetTexts(XStringList &lstTexts) const
{ 
	int len = m_lstPipe.Length();

	// 是否全为立管 cet 2012.10.12 add
	bool bAllPipe = true;
	for (int j = 0; j < len; j++)
	{
		OPENOBJ_BEGIN(m_lstPipe[j], AcDb::kForRead, TDbPipe, pPipe);
		if (pPipe != NULL)
		{
			if (!pPipe->IsVertical())
			{
				bAllPipe = false;
				break;
			}
		}
		OPENOBJ_END();
	}

	for(int i=0;i<len;i++){
		CString csText = _T("");
		CString csSerial;
		CString csFloorNum;  // cet 2012.10.12 add 楼号
		CString csMark;		 // cet 2014.6.12 add 代号
		AcDbObjectId id = m_lstPipe[i];//const
		ads_name ent;
		acdbGetAdsName(ent, id);
		if(m_iDimType == 1){
			csSerial = ReadXdata(ent, _T("PIPE-SERIAL"));
			csFloorNum = ReadXdata(ent, _T("BUILDING-SERIAL")); // cet 2012.10.12 add
		}
		// cet 2014.6.12 add 编号标注用到的代号
		if (m_iDimType == 1)
		{
			csMark = ReadXdata(ent, _T("PIPE-MARK"));
		}

		OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPipe, pPipe);
		if(pPipe){
			// TPipeSys::SysType sys = pPipe->GetSysType();
			CString csLable = pPipe->GetLabel();
//			CString csLay = pPipe->GetLayer();
			// csText.Format(_T("%s%.0f"), csLable, pPipe->GetDnDiameter());
			if(m_iDimType == 1) // 编号标注
			{
				// cet 2014.6.12 modify 标注文字按编号样式显示
				if (IsUseNewSerialNumberDimType()) // 新编号
				{
					int nType = GetSerialNumberDimType();
					switch(nType)
					{
					case 0: // A-JL-1
						{
							if (csFloorNum.IsEmpty())
							{
								csText.Format(_T("%s-%s"), csMark, csSerial);
							} 
							else
							{
								csText.Format(_T("%s-%s-%s"), csFloorNum, csMark, csSerial);
							}
							break;
						}
					case 1: // JL-A-1
						{
							if (csFloorNum.IsEmpty())
							{
								csText.Format(_T("%s-%s"), csMark, csSerial);
							} 
							else
							{
								csText.Format(_T("%s-%s-%s"), csMark, csFloorNum, csSerial);
							}
							break;
						}
					case 2: // JL-A1
						{
							csText.Format(_T("%s-%s%s"), csMark, csFloorNum, csSerial);
							break;
						}
					case 3: // AJL-1
						{
							csText.Format(_T("%s%s-%s"), csFloorNum, csMark, csSerial);
							break;
						}
					case 4: // JLA-1
						{
							csText.Format(_T("%s%s-%s"), csMark, csFloorNum, csSerial);
							break;
						}
					}
				} 
				else // 老编号
				{
			//		int nIndex = GetPipeLayerIdxByName(csLay);
					int nIndex = GetPipeLayerIdxBySys(pPipe->GetSysType());
					CString sPipeAbbreviation;
					if (nIndex != -1)
					{
						sPipeAbbreviation = g_csPipeDim[nIndex];
					}
					csText = sPipeAbbreviation + _T("L-") + csSerial;
					// 全是立管时添楼号 cet 2012.10.12 add
					if (bAllPipe)
					{
						csText = csFloorNum + (csFloorNum.IsEmpty() ? _T("") : _T("-"))+ csText;
					}
				}
			}
			else if (m_iDimType == 3) // cet 2011.4.25 add 标高标注
			{
				XLine lineBase(m_ptStart, m_ptTurn, 1);
				lineBase.StartPoint().z = 0;
				lineBase.EndPoint().z = 0;
				XPoint ptInt;

				XPoint ptS = pPipe->GetStartPoint(), ptE = pPipe->GetEndPoint();
				XLine line(ptS, ptE, 1);
				line.StartPoint().z = 0;
				line.EndPoint().z = 0;
				int ret = line.Intersection(&lineBase, ptInt); // 管线与标注线交点
				if(!ptInt)
				{
					continue;
				}

				line.StartPoint().z = ptS.z;
				line.EndPoint().z = ptE.z;
				pPipe->getClosestPointTo(ptInt, AcGeVector3d::kZAxis, ptInt); // 交点到管线中心线的z轴投影
				double dEle = ptInt.z;
				if(!DocGetMeterUnitDraw())
				{	
					dEle *= 0.001;
				}
				csText.Format(_T("%.3f"), dEle);
				// cet 2014.5.13 add 添加前缀
				CString sPrefix = GetPipePrefix();
				if (fabs(dEle) < 0.001)
				{
					csText.Insert(0, _T("±"));
				} 
				else if (dEle > 0.001 && sPrefix.Find(_T("▽")) == -1 && !sPrefix.IsEmpty())
				{
					sPrefix += _T("+");
				}
				csText = sPrefix + csText;
			}
			else if (m_iDimType == 4) // cet 2012.6.28 add 管径标高样式
			{
				csText = pPipe->GetLabelText();
				if (!pPipe->IsVertical())
				{
					XLine lineBase(m_ptStart, m_ptTurn, 1);
					lineBase.StartPoint().z = 0;
					lineBase.EndPoint().z = 0;
					XPoint ptInt;
					XPoint ptS = pPipe->GetStartPoint(), ptE = pPipe->GetEndPoint();
					XLine line(ptS, ptE, 1);
					line.StartPoint().z = 0;
					line.EndPoint().z = 0;
					int ret = line.Intersection(&lineBase, ptInt); // 管线与标注线交点
					if(!ptInt)
					{
						continue;
					}

					line.StartPoint().z = ptS.z;
					line.EndPoint().z = ptE.z;
					pPipe->getClosestPointTo(ptInt, AcGeVector3d::kZAxis, ptInt); // 交点到管线中心线的z轴投影
					double dEle = ptInt.z;
					if(!DocGetMeterUnitDraw())
					{	
						dEle *= 0.001;
					}

					CString csTmp;
					csTmp.Format(_T("%.3f"), dEle);
					// zxl 2013.01.24 add
					CString sText = GetPipePrefix();
					if (dEle == 0.0)
					{
						sText += _T("±");
					}
					else if (dEle > 0.0 && sText.Find(_T("▽")) < 0)
					{
						if (!sText.IsEmpty())
						{
							sText += _T("+");
						}
						else
						{
							sText += _T("  ");
						}
					}
					csTmp= sText + csTmp;
					csText += _T(" ") + csTmp;
				}
			}
			else if (m_iDimType == 5) // 管代号-管径标注 zxl 2013.02.21 add
			{
				// cet 2014.6.12 modify 代号保存在管线上
				if (IncludeXdate(pPipe, _T("PIPE-MARK-DN"))) 
				{
					csText = ReadXdata(pPipe, _T("PIPE-MARK-DN"));
				} 
				else
				{
					csText = GetOnePipeLabel(i);
				}
				if (!csText.IsEmpty())
				{
					csText += _T("-");
				}
				csText += pPipe->GetLabelText();
			}
			else{
				csText = pPipe->GetLabelText();
				//  CString csGradient = I2Str(pPipe->GetPipeGradient()*1000);
				//  csText.Format(_T("%s%.0f i=%s L=%.2f"), csLable, pPipe->GetDnDiameter(), csGradient, pPipe->Length()/1000);
			}
			lstTexts.Append(tstrnew((const TCHAR*)csText));
		}
		OPENOBJ_END();        
	}
	lstTexts.Reverse();
}
// 获取管代号 zxl 2013.01.22 add
CString TDbPipeMultDim::GetOnePipeLabel(const int i) const
{
	CString csText = GetPipeLabel();
	int nNum = i;
	while(nNum >= 0)
	{
		int nIndex = csText.Find(_T(","));
		if (nIndex > 0 && nNum == 0)
		{
			csText = csText.Left(nIndex);
			break;
		}
		else
		{
			csText = csText.Right(csText.GetLength() - nIndex - 1);
		}
		nNum--;
	}
	return csText;
}

XPoint TDbPipeMultDim::GetStartPoint() const
{
	return m_ptStart;
}

XPoint TDbPipeMultDim::GetTurnPoint() const
{
	return m_ptTurn;
}

XPoint TDbPipeMultDim::GetEndPoint() const
{
	// double nLineSpace = (DocGetText2Base() * 2+ m_nTextHeight)*GetPScale();
	double nLineSpace = (GetDimDist2Line() + m_nTextHeight)*GetPScale();

	XStringList lstTexts;
	GetTexts(lstTexts);
	double nDist2End=(lstTexts.Length()-1)*nLineSpace;
	XPoint ptEnd;
	ads_polar(m_ptTurn, m_nLayoutRotation+PI/2.0, nDist2End, ptEnd);
	return ptEnd;
}

double TDbPipeMultDim::GetTextBaseLen(BOOL bAsPaperUnit) const
{
	double nVal=m_nTextBaseLen;
	if(!bAsPaperUnit)
		nVal *= GetPScale();
	return nVal;
}

/* * * * * * * * * * 取 动 态 属 性 显 示 数 据 的 函 数 * * * * * * * * * */
void TDbPipeMultDim::GetTips(DList<TObjInfoUnit> &lstInfo) const
{
	lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("多管标注")));
	XStringList lstTexts;
	GetTexts(lstTexts);
	for(int i=0; i<lstTexts.Length(); i++) 
		lstInfo.Append(new TObjInfoUnit(XString(_T("文字%d"), i), lstTexts[i]));

	lstInfo.Append(new TObjInfoUnit(_T("文字高度"), XString(_T("%.1fP"), m_nTextHeight)));
	XString sTextStyle=GetSymbolName(m_idTextStyle);
	lstInfo.Append(new TObjInfoUnit(_T("文字样式"), sTextStyle));
}

double TDbPipeMultDim::GetMinTextBaseLen(BOOL bAsPaperUnit) const
{
	TDbText text;
	text.setPropertiesFrom(this);
	text.SetHeight(m_nTextHeight);
	text.SetStyleId(m_idTextStyle);
	double nVal=0.0;
	XStringList lstTexts;
	GetTexts(lstTexts);
	for(int i=0; i<lstTexts.Length(); i++) {
		// cet 2014.5.13 modify 为保证计算的字符串长度与绘制的文字长度保持一致，统一处理
		// 并更正多行文字时计算的长度值
		CString sText = lstTexts[i];
		ReplaceSpecialChar(sText);
		if (sText.Find(_T('\n')) != -1)
		{
			std::vector<CString> vecText;
			int nIndex = sText.Find(_T('\n'));
			while(nIndex != -1)
			{
				vecText.push_back(sText.Left(nIndex));
				if (sText.GetLength() - 1 == nIndex)
				{
					break;
				}
				sText = sText.Right(sText.GetLength() - nIndex - 1);
				nIndex = sText.Find(_T('\n'));
			}

			if (!sText.IsEmpty())
			{
				vecText.push_back(sText);
			}

			int nSize = (int)vecText.size();
			for (int j = 0; j < nSize; ++j)
			{
				text.SetText(vecText[j]);
				XPoint ptExt=text.GetExtents();
				nVal=max(nVal, ptExt.x);
			}	
			continue;
		}	
		text.SetText(sText);
		XPoint ptExt=text.GetExtents();
		nVal=max(nVal, ptExt.x);
	}
	// nVal += DocGetText2Base()*GetPScale()*2;
	nVal += GetDimDist2Line()*GetPScale() / 4;
	if(bAsPaperUnit)
		nVal /= GetPScale();
	return nVal;
}

double TDbPipeMultDim::GetDefaultTextBaseLen(BOOL bAsPaperUnit) const
{
	double nVal=6.0;
	if(!bAsPaperUnit)
		nVal *= GetPScale();
	//    if(!m_bSideText)
	nVal=max(nVal, GetMinTextBaseLen(bAsPaperUnit));
	return nVal;
}



void TDbPipeMultDim::SetStartPoint(XPoint pt)
{
	assertWriteEnabled();
	m_ptStart=pt;
}

void TDbPipeMultDim::SetTurnPoint(XPoint pt)
{
	assertWriteEnabled();
	m_ptTurn = pt;
}

void TDbPipeMultDim::SetTextBaseLen(double val, BOOL bAsPaperUnit)
{
	assertWriteEnabled();
	m_nTextBaseLen=val;
	if(!bAsPaperUnit)
		m_nTextBaseLen /= GetPScale();
}



void TDbPipeMultDim::AddPipe(AcDbObjectId id)
{
	assertWriteEnabled();
	BOOL bFind = m_lstPipe.FindNode(&id, CompareObjectId)!=NULL;
	if(!bFind)
		m_lstPipe.Append(new AcDbSoftPointerId(id));
}

void TDbPipeMultDim::GetPipes(DList<AcDbObjectId>& lstPipe) const
{
	int nCount = m_lstPipe.Length();
	for(int i=0; i<nCount; i++) {
		lstPipe.Append(new AcDbObjectId(m_lstPipe[i]));
	}
}

void TDbPipeMultDim::SetPipes(DList<AcDbObjectId> &lstPipe)
{
	m_lstPipe.Reset();
	int nCount = lstPipe.Length();
	for(int i=0; i<nCount; i++) {
		AcDbObjectId id = *lstPipe[i];
		m_lstPipe.Append(new AcDbSoftPointerId(id));
	}
}

void TDbPipeMultDim::ReplaceSpecialChar( CString &sText ) const
{
	CString sReplaceString = GetReplaceSpecialCharString(_T("▽"));
	sText.Replace(_T("▽"), sReplaceString);
}

void TDbPipeMultDim::GetSpecialCharIndexs( const CString &sText, std::map<int, CString> &mapIndex ) const
{
	int nIndex = sText.Find(_T("▽"), 0); 
	while(nIndex != -1)
	{
		mapIndex.insert(std::make_pair(nIndex, _T("▽")));
		if (nIndex == sText.GetLength() - 1)
		{
			break;
		}
		nIndex = sText.Find(_T("▽"), nIndex + 1);
	}
}

void TDbPipeMultDim::DrawSpecialCharForDnElevationType(XExplodeDraw &dc, const CString &sText, XPoint ptTempBeg, XPoint ptTempEnd, XPoint ptLoc, double dLineSpace) const
{
	// 支持多行文字
	std::vector<CString> vecText;
	int nLineIndex = sText.Find(_T('\n'), 0);
	if (nLineIndex == -1)
	{
		vecText.push_back(sText);
	} 
	else
	{
		CString sTemp = sText;
		while(nLineIndex != -1)
		{
			vecText.push_back(sTemp.Left(nLineIndex));
			if (sTemp.GetLength() - 1 == nLineIndex)
			{
				break;;
			}
			sTemp = sTemp.Right(sTemp.GetLength() - nLineIndex - 1);
			nLineIndex = sTemp.Find(_T('\n'), 0);
		}

		if (!sTemp.IsEmpty())
		{
			vecText.push_back(sTemp);
		}
	}
	// 绘制特殊字符
	TDbText textTemp;
	textTemp.setPropertiesFrom(this);
	textTemp.setColorIndex(GetTextColor());
	textTemp.SetStyleId(m_idTextStyle);
	textTemp.SetHeight(m_nTextHeight);
	textTemp.SetAlignment(XExplodeDraw::kTopLeft);
	// 文字间距
	textTemp.SetText(_T("EE"));
	double dDist1 = textTemp.GetExtents().x;
	textTemp.SetText(_T("E"));
	double dDist2 = textTemp.GetExtents().x;
	double dDist = dDist1 - dDist2 * 2;
	// 对齐方式
	std::map<int, CString> mapIndex;
	std::map<int, CString>::const_iterator itBegin, itEnd, itTemp;
	std::vector<CString>::reverse_iterator itTextBegin, itTextEnd = vecText.rend();
	AcGeVector3d vtDir = ptTempEnd - ptTempBeg;
	if (m_nTextBaseLen < 0)
	{
		vtDir *= -1;
	}
	vtDir.normalize();
	AcGeVector3d vtDir2 = vtDir;
	vtDir2.rotateBy(PI * 0.5, AcGeVector3d::kZAxis);
	int nLineNum = 0;
	for (itTextBegin = vecText.rbegin(); itTextBegin != itTextEnd; ++itTextBegin)
	{
		++nLineNum;
		// 获得特殊字符位置
		CString sTextTemp = *itTextBegin;
		mapIndex.clear();
		GetSpecialCharIndexs(sTextTemp, mapIndex);
		if (mapIndex.empty())
		{
			textTemp.SetText(sTextTemp);
			TPushProperty vProp(&textTemp, dc);
			if(dc.IsFullExplode())
				textTemp.ExplodeOrDraw2d(dc);
			else
				dc.DrawEntity(textTemp);
			continue;
		}
		// 替换特殊字符
		ReplaceSpecialChar(sTextTemp);
		// 绘制非特殊字符 
		int nPreIndex = -1, nIndex = 0;
		double dPreLen = 0.0;
		std::map<int, double> mapDist; // 特殊符号前字符长度
		XPoint pt = ptLoc + vtDir2 * (m_nTextHeight * GetPScale() + dLineSpace) * (nLineNum - 1);
		textTemp.SetText(sTextTemp);
		double dTextzLen = textTemp.GetExtents().x;
		int nAlignType = GetDimAlignType();
		if (nAlignType == 1) // 居中
		{
			double dLen = ptTempBeg.Distance(ptTempEnd) - dTextzLen;
			pt += vtDir * dLen * 0.5;
		}
		else if (nAlignType == 2)// 右对齐
		{
			double dLen = ptTempBeg.Distance(ptTempEnd) - dTextzLen;
			pt += vtDir * dLen;
		}
		bool bFlag = true;
		for (itBegin = mapIndex.begin(), itEnd = mapIndex.end(); itBegin != itEnd; ++itBegin)
		{
			nIndex = itBegin->first;
			// 绘制非特殊符号字符串
			if (nIndex > nPreIndex && nIndex != 0)
			{
END:
				CString sTemp = sTextTemp.Left(nIndex);
				if (nPreIndex > -1)
				{
					sTemp = sTemp.Right(bFlag ? nIndex + 1 - nPreIndex - 1 : nIndex - nPreIndex - 1);
				}
				textTemp.SetLocation(pt + vtDir * dPreLen);
				textTemp.SetText(sTemp);
				TPushProperty vProp(&textTemp, dc);
				if(dc.IsFullExplode())
					textTemp.ExplodeOrDraw2d(dc);
				else
					dc.DrawEntity(textTemp);
			}
			// 记录特殊符号位置
			if (bFlag)
			{
				textTemp.SetLocation(AcGePoint3d::kOrigin);
				textTemp.SetText(sTextTemp.Left(nIndex + 1));
				mapDist[nIndex] = textTemp.GetExtents().x + dDist;
				dPreLen = mapDist[nIndex];
				nPreIndex = nIndex;
				itTemp = itBegin;
				++itTemp;
				// 末尾字符串
				if (itTemp == itEnd && nIndex < sTextTemp.GetLength() - 1)
				{
					nIndex = sTextTemp.GetLength();
					bFlag = false;
					goto END;
				}
			}
		}
		// 绘制特殊符号
		Adesk::UInt16 color = dc.GetColor();
		dc.SetColor(GetTextColor());
		for (itBegin = mapIndex.begin(), itEnd = mapIndex.end(); itBegin != itEnd; ++itBegin)
		{
			double dLen = mapDist[itBegin->first];
			if (itBegin->second == _T("▽")) // 绘制倒三角
			{
				CString sTemp = GetReplaceSpecialCharString(_T("▽"));
				textTemp.SetLocation(AcGePoint3d::kOrigin);
				textTemp.SetText(sTemp);
				textTemp.SetAlignment(XExplodeDraw::kCenter);
				double dWidth = textTemp.GetExtents().x;
				double dHeight = textTemp.GetExtents().y;
				double dPreLen = mapDist[itBegin->first];
				if (itBegin->first == 0) // 首字符
				{
					dPreLen = 0.0;
				}
				else // 其他位置
				{
					dPreLen -= (dWidth + dDist);
				}
				XPoint ptLeft = pt + vtDir * dPreLen;
				XPoint ptRight = ptLeft + vtDir * dWidth;
				XPoint ptBottom = pt + vtDir * (dPreLen + dWidth * 0.5) - vtDir2 * dHeight;
				AcDbExtents ext;
				if (textTemp.getGeomExtents(ext) == Acad::eOk)
				{
					ptLeft -= vtDir2 * (dHeight - (ext.maxPoint().y - ext.minPoint().y ));
					ptRight -= vtDir2 * (dHeight - (ext.maxPoint().y - ext.minPoint().y ));
				}
				dc << XLine(ptLeft, ptRight);
				dc << XLine(ptLeft, ptBottom);
				dc << XLine(ptRight, ptBottom);
			}
		}
		dc.SetColor(color);
	}
}

CString TDbPipeMultDim::GetReplaceSpecialCharString( const CString &sSpeicalChar ) const
{
	CString sText;
	if (sSpeicalChar == _T("▽"))
	{
		sText = _T("W");
	}
	return sText;
}

void TDbPipeMultDim::DrawSpecialCharForElevationType( XExplodeDraw &dc, TDbSymbElevation &text) const
{
	CString sText = text.GetText();
	ReplaceSpecialChar(sText);
	text.SetText(sText);
	AcDbVoidPtrArray arr;
	FullExplode(&text, arr);
	int nCount = arr.length();
	CString sReplaceString = GetReplaceSpecialCharString(_T("▽"));
	for (int i = 0; i < nCount; ++i)
	{
		AcDbEntity *pEntity = (AcDbEntity *)arr[i];
		if (pEntity == NULL)
		{
			continue;
		}
		if (pEntity->isKindOf(AcDbText::desc())) // 文字
		{
			AcDbText *pText = (AcDbText*)pEntity;
			TCHAR *pszText = pText->textString(); 
			sText = pszText;
			delete pszText;
			if (sText == sReplaceString) // 绘制特殊符号
			{
				double dAngle = pText->rotation();
				pText->setRotation(0.0);
				AcDbExtents ext;
				if (pText->getGeomExtents(ext) == Acad::eOk)
				{
					double dWidth = ext.maxPoint().x - ext.minPoint().x;
					double dHeight = ext.maxPoint().y - ext.minPoint().y;
					AcGePoint3d pt = pText->position();
					AcGeVector3d vtX = AcGeVector3d::kXAxis;
					vtX = Ucs2Wcs(vtX, TRUE);
					vtX.rotateBy(dAngle, AcGeVector3d::kZAxis);
					XPoint pt1 = pt + vtX * dWidth * 0.5;
					XPoint pt2 = pt;
					XPoint pt3 = pt2 + vtX * dWidth;
					vtX.rotateBy(PI / 2, AcGeVector3d::kZAxis);
					pt2 += vtX * dHeight;
					pt3 += vtX * dHeight;
					Adesk::UInt16 color = dc.GetColor();
					dc.SetColor(GetTextColor());
					dc << XLine(pt1, pt2);
					dc << XLine(pt1, pt3);
					dc << XLine(pt2, pt3);
					dc.SetColor(color);
				}
			}
			else // 直接绘制文字
			{
				dc.DrawEntity(*pEntity);
			}
		}
		else // 直线
		{
			pEntity->setColorIndex(dc.GetColor());
			dc.DrawEntity(*pEntity);
		}
	}
	ReleaseEntSet(arr);
}

bool TDbPipeMultDim::IsIncludeSpeicalChar( const CString &sText ) const
{
	return sText.Find(_T("▽")) != -1;
}

void TDbPipeMultDim::SetSerialNumberDimType( int nType )
{
	assertWriteEnabled();
	TEntityFields &fd = Fields();
	fd.SFD(_T("SerialNumberDimType"), (Adesk::Int8)nType);
}

int TDbPipeMultDim::GetSerialNumberDimType() const
{
	const TEntityFields &fd = GetFields();
	Adesk::Int8 nType = -1;
	fd.GFD(_T("SerialNumberDimType"), nType);
	return (int)nType;
}

bool TDbPipeMultDim::IsUseNewSerialNumberDimType() const
{
	const TEntityFields &fd = GetFields();
	Adesk::Int8 nType = -1;
	return fd.GFD(_T("SerialNumberDimType"), nType);
}
void TDbPipeMultDim::SetLabelType(int iType)
{
	assertWriteEnabled();
	TEntityFields &fd = Fields();
	fd.SFD(MPIPE_DIM_TYPE, iType);
}
int TDbPipeMultDim::GetLabelType() const
{
	assertReadEnabled();
	const TEntityFields &fd = GetFields();
	int iDimType;
	if( !fd.GFD(MPIPE_DIM_TYPE, iDimType) )
	{
		iDimType = 0;
	}
	return iDimType;
}
void TDbPipeMultDim::SetBulge(double dBulge)
{
	assertWriteEnabled();
	TEntityFields &fd = Fields();
	fd.SFD(MPIPE_DIM_BULGE, dBulge);
}
double TDbPipeMultDim::GetBulge() const
{
	assertReadEnabled();
	const TEntityFields &fd = GetFields();
	double dBulge;
	if( !fd.GFD(MPIPE_DIM_BULGE, dBulge) )
	{
		dBulge = .0;
	}
	return dBulge;
}
//////////////////////////////////////////////////////////////////////////

void InitDbPieMultDim(BOOL bTrue)
{
	if(bTrue) {
		TDbPipeMultDim::rxInit();
		TDbPipeMultDim::InitMatchProtocol(TRUE);
	} else {
		TDbPipeMultDim::InitMatchProtocol(FALSE);
		deleteAcRxClass(TDbPipeMultDim::desc());
	}
}