#include "stdafx.h"
#include "PushProperty.h"
#include "AecDbDimension.h"
#include "AecDbDimension_old.h"
#include "AecDbText.h"
#include "globalFunc.h"
#include "AcDbObjectPtr.h"
#include "superlist.h"
#include "gecurveinline.h"
#include "ADSgepointdir2d.h"
#include "SortedVertexList.h"
#include "PushMemVar.h"
#include "DimTextPos.h"
#include "DimTextContent.h"

extern AcDbObjectId InitDimStyle(TDimStyle ds);

#pragma region XDimAutoAdjust
class XDimAutoAdjust
{
public:
	XDimAutoAdjust() {}

protected:
	typedef struct dimTextInfo
	{
		// 文字测量值
		double	dDimText;
		// Y方向文字位置，0外偏；1、2、3...原位、上调；-1、-2、-3...下调
		int		nYLoc;
		// X方向文字包围盒位置，全部投影到尺寸标注中的GetDimCurve上
		double	dSLoc;
		double	dELoc;
		// 文字包围框的X值大小
		double	dX;
	}SDimInfo;

	typedef struct rowInfo
	{
		// 当前排号，1、2、3...原位、上调；-1、-2、-3...下调
		int		nY;
		// 当前排号下，最后一个编号
		int		nIndex;
	}SRow;

public:
	// 设置标注的基本通用信息
	void	SetDimParam(GeCurveSegment seg, AcDbObjectId idStyle, double dHeight, double dLayoutRotation);

	// 向数组中添加标注信息段
	void	AppendDim(const TCHAR* pszDimText, const TCHAR* pszText, ADSGePoint3d pt);

	// 进行自动调整
	void	AutoAdjust(BOOL bUp, BOOL bAllowExt);

	// 获得某一段最后Y方向的偏移位置
	int		GetYLoc(int nIndex) const;
	// 获得文字包围盒的X方向大小
	double	GetXDist(int nIndex) const;

	//默认是一个文字宽度1.0
	void	SetDispSnap(double dScale = 1.0);

protected:
	// 单独处理第1段和最后一段的外偏情况
	void	DealFirstAndLastDim(BOOL bAllowExt);
	int 	RecursionUpDownAdjust(int nIndex, BOOL bUp, BOOL bAllowExt);

	void	GetDimPathDist(ADSGePoint3d pt, ADSGePointDir2d &ptDir) const;
	double	ChangeToNormalViewAngle(double dAngWcs) const;

	int		GetRowMaxIndex(int nY) const;
	void	AppendRow(int nY, int nIndexNum);

protected:
	// 将每一个尺寸标注对象拆分保存成一个一个SDimInfo
	CArray<SDimInfo, SDimInfo&>	m_arDimInfo;
	// 将每排的情况列到一个数组中
	CArray<SRow, SRow&>			m_arRows;

private:
	GeCurveSegment	m_segDim;
	AcDbObjectId	m_idTextStyle;
	double			m_dTextHeight;
	double			m_dLayoutRotation;
	double			m_d_DIST_SNAP;//判断文字重合间隙 
};

void XDimAutoAdjust::SetDimParam(GeCurveSegment seg, AcDbObjectId idStyle, double dHeight, double dLayoutRotation)
{
	m_segDim = seg;
	m_idTextStyle = idStyle;
	m_dTextHeight = dHeight;
	m_dLayoutRotation = dLayoutRotation;
}

void XDimAutoAdjust::SetDispSnap(double dSnap)
{
	AecXDbText text;
	text.SetText(_T("5"));
	text.SetStyleId(m_idTextStyle);
	text.SetHeight(m_dTextHeight, FALSE);
	text.SetAlignment(AcGiDraw::kBottomLeft);

	ADSGePoint3d ptTextExt = text.GetExtents(); // 文字轮廓
	m_d_DIST_SNAP = ptTextExt.x * dSnap;
}

int XDimAutoAdjust::GetYLoc(int nIndex) const
{
	return m_arDimInfo[nIndex].nYLoc;
}

double XDimAutoAdjust::GetXDist(int nIndex) const
{
	return m_arDimInfo[nIndex].dX;
}

void XDimAutoAdjust::AppendDim(const TCHAR* pszDimText, const TCHAR* pszText, ADSGePoint3d pt)
{
	SDimInfo dim;
	dim.nYLoc = 1;
	dim.dDimText = _tstof(pszDimText);

	ADSGePointDir2d ptDir;
	GetDimPathDist(pt, ptDir);

	AecXDbText text;
	text.SetText(pszText);
	text.SetStyleId(m_idTextStyle);
	text.SetHeight(m_dTextHeight, FALSE);
	text.SetAlignment(AcGiDraw::kBottomLeft);

	ADSGePoint3d ptTextExt = text.GetExtents(), // 文字轮廓
		pt1, pt2;
	double dTextRot = ChangeToNormalViewAngle(ptDir.nDirection);	// 文字角度
	ads_polar(pt, dTextRot, ptTextExt.x / 2, pt1);
	ads_polar(pt1, dTextRot + PI, ptTextExt.x, pt2);

	double dDist1 = m_segDim.PathDistance(pt1, 1), // 都是相对m_segDim的起点的
		dDist2 = m_segDim.PathDistance(pt2, 1);
	dim.dSLoc = (dDist1 > dDist2 + g_Option::instance()._DIST_SNAP) ? dDist2 : dDist1; // 较小的作为起点
	dim.dELoc = (dDist1 > dDist2 + g_Option::instance()._DIST_SNAP) ? dDist1 : dDist2; // 较大的作为终点
	dim.dX = ptTextExt.x;

	m_arDimInfo.Add(dim);
}

int XDimAutoAdjust::GetRowMaxIndex(int nY) const
{
	int nRows = (int)m_arRows.GetSize();
	for (int i = 0; i < nRows; i++)
	{
		if (m_arRows[i].nY == nY)
			return m_arRows[i].nIndex;
	}
	return -1;
}

void XDimAutoAdjust::AppendRow(int nY, int nIndexNum)
{
	int nRows = (int)m_arRows.GetSize();
	for (int i = 0; i < nRows; i++)
	{
		if (m_arRows[i].nY == nY)
		{
			m_arRows[i].nIndex = nIndexNum;
			return;
		}
	}

	SRow row;
	row.nIndex = nIndexNum;
	row.nY = nY;
	m_arRows.Add(row);
}

int XDimAutoAdjust::RecursionUpDownAdjust(int nIndex, BOOL bUp, BOOL bAllowExt)
{
	int nCurY = m_arDimInfo[nIndex].nYLoc,
		nMax(0), nPrev(0), nNextY(0);
	while (1) // 将nIndex从1排开始，一排一排比较后，上移或者下移，尝试确定位置
	{
		nMax = GetRowMaxIndex(nCurY); // 得到“当前排”最大的一个索引号
		nPrev = (nMax == -1) ? (nIndex - 1) : nMax;

		if (nPrev < 0 || nPrev == nIndex || m_arDimInfo[nPrev].nYLoc != nCurY)
		{
			AppendRow(nCurY, nIndex);
			return -1; // 没有引起其他段变化
		}

		if (nPrev > nIndex)
			break;

		if (m_arDimInfo[nIndex].dSLoc < m_arDimInfo[nPrev].dELoc + m_d_DIST_SNAP) // 有重合，要调整文字
		{
			nNextY = bUp ? (nCurY + 1) : (nCurY - 1);
			nNextY = (nNextY == 0) ? -1 : nNextY;

			if (m_arDimInfo[nIndex].dDimText > m_arDimInfo[nPrev].dDimText + m_d_DIST_SNAP) // 当前数字大于前一个数字
			{
				if (nIndex == 0 && bAllowExt) // 允许外偏
					break;

				m_arDimInfo[nPrev].nYLoc = nNextY;
				AppendRow(nCurY, nIndex);
				break;
			}
			else // 当前数字小于、等于前一个数字
			{
				if (nPrev == 0 && bAllowExt) // 允许外偏
				{
					AppendRow(nCurY, nIndex);
					break;
				}

				m_arDimInfo[nIndex].nYLoc = nNextY;
				nCurY = nNextY;
				continue;
			}
		}
		else
		{
			AppendRow(nCurY, nIndex);
			return -1;
		}
	}
	return nPrev;
}

void XDimAutoAdjust::AutoAdjust(BOOL bUp, BOOL bAllowExt)
{
	int nSize = (int)m_arDimInfo.GetSize(),
		nCur(0), nMax(0), nPrev(0), nInd(0), nCurY(0), nNextY(0), i(0);

	int nUpY = 2, nDownY = -1;
	nNextY = bUp ? nUpY : nDownY;
	int nBackNextY = bUp ? nDownY : nUpY;

	for (nCur = 2; nCur < nSize - 1; nCur++)
	{
		double dtttt = m_arDimInfo[nCur].dDimText;
		double ddist = m_arDimInfo[nCur].dX;

		nCurY = m_arDimInfo[nCur].nYLoc;

		for (i = nCur - 1; i > 0; i--)
		{
			if (m_arDimInfo[nCur].nYLoc == m_arDimInfo[i].nYLoc)
			{
				nPrev = i;
				break;
			}
		}
		double ds = m_arDimInfo[nCur].dSLoc;
		double de = m_arDimInfo[nPrev].dELoc;
		if (m_arDimInfo[nCur].dSLoc < m_arDimInfo[nPrev].dELoc + m_d_DIST_SNAP) // 有重合，要调整文字
		{

			if (m_arDimInfo[nCur + 1].dSLoc < m_arDimInfo[nCur].dELoc + m_d_DIST_SNAP)
			{//当前与前一个和后一个都重叠


				if (nCur == nPrev + 1)
				{
					m_arDimInfo[nCur].nYLoc = nNextY;
				}
				else
				{
					m_arDimInfo[nCur].nYLoc = nBackNextY;
				}
				continue;
			}
			if (m_arDimInfo[nCur].dDimText > m_arDimInfo[nPrev].dDimText + m_d_DIST_SNAP) // 当前数字大于前一个数字
			{
				if (nCur == nPrev + 1)
				{//相邻的两个文字作比较
					m_arDimInfo[nPrev].nYLoc = nNextY;
					if (m_arDimInfo[nPrev - 1].nYLoc == nNextY)
					{//前一个文字上移时，先检查前一个的前一个是否也上移了。
						if (m_arDimInfo[nPrev].dSLoc < m_arDimInfo[nPrev - 1].dELoc + m_d_DIST_SNAP)
						{
							//文字有交叉,直接放到对面位置上
							m_arDimInfo[nPrev].nYLoc = nBackNextY;
						}
					}
				}
				else
				{//非相邻做比较，说明相邻的已经move过位置了
					m_arDimInfo[nPrev].nYLoc = nBackNextY;
				}

			}
			else // 当前数字小于、等于前一个数字
			{
				if (nCur == nPrev + 1)
				{
					m_arDimInfo[nCur].nYLoc = nNextY;
					if (m_arDimInfo[nPrev].nYLoc == nNextY)
					{
						if (m_arDimInfo[nCur].dSLoc < m_arDimInfo[nPrev].dELoc + m_d_DIST_SNAP)
						{
							//文字有交叉,直接放到对面位置上
							m_arDimInfo[nCur].nYLoc = nBackNextY;
						}
					}
				}
				else
				{
					m_arDimInfo[nCur].nYLoc = nBackNextY;
				}
			}
		}
	}

	DealFirstAndLastDim(bAllowExt);
}

// 单独处理第1段和最后一段的外偏情况
void XDimAutoAdjust::DealFirstAndLastDim(BOOL bAllowExt)
{
	if (!bAllowExt) // 如果允许外偏，还要额外判断一下，是否查过了尺寸界线
	{
		return;
	}

	double ddd = m_arDimInfo[0].dSLoc;
	double dsss = m_arDimInfo[0].dDimText;

	if (m_arDimInfo[0].dSLoc < 1)
	{
		m_arDimInfo[0].nYLoc = 0;
	}

	int nSize = (int)m_arDimInfo.GetSize();
	if (nSize > 1) // 有1段以上
	{
		if (m_arDimInfo[1].dSLoc < m_arDimInfo[0].dELoc)
		{//如果第二个与第一个重合，则优先考虑侧移第一个
			if (m_arDimInfo[1].nYLoc == m_arDimInfo[0].nYLoc)
			{
				m_arDimInfo[0].nYLoc = 0;
			}

		}

		double ddde = m_arDimInfo[nSize - 1].dELoc;
		double ddds = m_arDimInfo[nSize - 1].dSLoc;
		double dsss = m_arDimInfo[nSize - 1].dDimText;
		double dssss = m_segDim.GetLength();
		if (m_arDimInfo[nSize - 1].dELoc > m_segDim.GetLength())
		{
			m_arDimInfo[nSize - 1].nYLoc = 0;
		}
		if (m_arDimInfo[nSize - 1].dSLoc < m_arDimInfo[nSize - 2].dELoc)
		{//如果最后一个与倒数第二个重合，则优先考虑侧移最后一个
			if (m_arDimInfo[nSize - 1].nYLoc == m_arDimInfo[nSize - 2].nYLoc)
			{
				m_arDimInfo[nSize - 1].nYLoc = 0;
			}

		}

	}
}

double XDimAutoAdjust::ChangeToNormalViewAngle(double dAngWcs) const
{
	double dAng = GlobalFunc::AngleRangeTo2PI(dAngWcs - m_dLayoutRotation),
		dSnap = 1.0E-1,
		dAng1 = GlobalFunc::AngleRangeTo2PI(dAng);//double dSnap = 1.0E-9, 9.0beta1 
	if (GlobalFunc::GreatThan(dAng1, PI / 2.0, dSnap) && GlobalFunc::LessThan(dAng1, PI, dSnap))
	{
		dAng1 += PI;
	}
	else if (GlobalFunc::GreatEqual(dAng1, PI, dSnap) && GlobalFunc::LessEqual(dAng1, PI * 1.5, dSnap))
	{
		dAng1 -= PI;
	}
	dAng = dAng1;
	dAng = GlobalFunc::AngleRangeTo2PI(m_dLayoutRotation + dAng);
	return dAng;
}

void XDimAutoAdjust::GetDimPathDist(ADSGePoint3d pt, ADSGePointDir2d &ptDir) const
{
	double dPathDist = m_segDim.PathDistance(pt);
	m_segDim.Polar(dPathDist, ptDir);
}

#pragma endregion

#pragma region AecDbDimension
/////////////////////////////////////////////////////////////
// 新尺寸对象类
/////////////////////////////////////////////////////////////
//TArch7-1,
const Adesk::UInt8 AecDbDimension::g_nVersion = 1;


ACRX_DXF_DEFINE_MEMBERS(AecDbDimension, AecXDbCurveBaseEx, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
	1, AEC_CHICUNBIAOZHU, "AEC_CHICUNBIAOZHU|缺乏上华解释器, 请下载上华软件|网址: www.shanghuasoft.com");

IMPLEMENT_EDITFUNC(AecDbDimension);

AecDbDimension::AecDbDimension()
{
	m_nRotation = 0; //旋转角度
	m_nDist2DimLine = 0; //定位点到尺寸线的距离, 可以为负值
	m_nDimRadius = 0; //夹角,可以为负
	m_nObjRadius = 0;
	m_nDimFlag = g_Option::instance().g_bDynDim ? DF_ASSOCIATE : 0;
}


AecDbDimension::~AecDbDimension()
{
}

BOOL AecDbDimension::IsValid() const
{
	//BOOL bRet = TDbCurveEntity::IsValid();
	//if (!bRet)
	//	return bRet;

	BOOL bRet = m_lstSegment.Length() >= 1;
	return bRet;
}

BOOL AecDbDimension::IsValidSegment(double nVal, BOOL bDist) const
{
	double nPrec = IsAngular() ? g_DimOption::instance()._angSnap : g_Option::instance()._DIST_SNAP;
	if (IsAngular() && bDist) {
		ASSERT(m_nDimRadius > g_Option::instance()._DIST_SNAP);
		nVal = nVal / m_nDimRadius;
	}
	return (nVal > nPrec);
}

void AecDbDimension::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
{
	AssertWriteEnabled();
	double nOldScale = GetPScale();
	double nDimDist = GetDist2DimLine(FALSE);
	AecXDbCurveBaseEx::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
	AecDbDimension *pSrc = AecDbDimension::cast(pSrcEntity);
	if (pSrc) {
		if (database() == NULL ||
			pSrcEntity->database() == NULL ||
			database() == pSrcEntity->database())//add by whl on 060317
		{
			m_idDimStyle = pSrc->m_idDimStyle; //尺寸标注类型
		}
		UseDimStyleScale(pSrc->IsUseDimStyleScale());
	}
	double nNewScale = GetPScale();
	if (fabs(nNewScale - nOldScale) > 1.0E-3 && IsAngular()) {
		SetDist2DimLine(nDimDist, FALSE);
	}
}
//Acad::ErrorStatus
//AecDbDimension::subGetClassID(CLSID* pClsid) const
//{
//	*pClsid = CLSID_ComDimension;
//	return Acad::eOk;
//}

namespace
{
	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(AcDbDimension::desc()))
			{
				int a = 0;
			}
			pWd->subEntityTraits().setColor(pEnt->colorIndex());
			pWd->subEntityTraits().setLayer(pEnt->layerId());
			pEnt->worldDraw(pWd);
		}
		pWd->subEntityTraits().setColor(clr);
		pWd->subEntityTraits().setLayer(layerID);
	}
}

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

	Acad::ErrorStatus es = AecXDbCurveBaseEx::dwgInFields(pFiler);
	if (es != Acad::eOk) return es;
	Adesk::UInt8  nVer;
	pFiler->readItem(&nVer);
	if (nVer > g_nVersion) {// Version is too new
		return Acad::eMakeMeProxy;
	}

	pFiler->readItem((AcGePoint3d *)&m_ptLocation); //定位点--即不动点
	m_ptLocation.z = 0; //必须是二维
	pFiler->readItem(&m_nRotation); //旋转角度
	pFiler->readItem(&m_nDist2DimLine); //定位点到尺寸线的距离, 可以为负值
	pFiler->readItem(&m_idDimStyle); //尺寸标注类型
	m_lstSegment.Reset();
	Adesk::UInt16 nSeg = 0;
	pFiler->readItem(&nSeg);
	for (Adesk::UInt16 i = 0; i < nSeg; i++) {
		double nVal = 0;
		pFiler->readItem(&nVal);
		m_lstSegment.Append(new double(nVal));
	}

	pFiler->readItem(&m_nDimFlag);


	m_lstTextPos.Reset();
	if (m_nDimFlag & DF_POSITION) {
		m_lstTextPos.Reset();
		Adesk::UInt16 nTextSeg = 0;
		pFiler->readItem(&nTextSeg);
		for (i = 0; i < nTextSeg; i++) {
			AcGePoint2d ptPos;
			Adesk::UInt16 nIndex;
			pFiler->readItem(&nIndex);
			pFiler->readItem(&ptPos);
			m_lstTextPos.Append(new DimTextPos(nIndex, ADSGePoint3d(ptPos[0], ptPos[1])));
		}
	}

	m_lstTextContent.Reset();
	if (m_nDimFlag & DF_TEXT) {
		Adesk::UInt16 nTextSeg = 0;
		pFiler->readItem(&nTextSeg);
		for (i = 0; i < nTextSeg; i++) {
			TCString sText;
			Adesk::UInt16 nIndex;
			pFiler->readItem(&nIndex);
			GlobalFunc::ReadString(pFiler, sText);
			m_lstTextContent.Append(new DimTextContent(nIndex, sText));
		}
	}
	if (m_nDimFlag & DF_BIND)
		pFiler->readItem(&m_idBind);

	if (IsAngular()) {
		pFiler->readItem(&m_nDimRadius);
		pFiler->readItem(&m_nObjRadius);
	}

	m_lstOffset.Reset();
	if (m_nDimFlag & DF_ASSOCIATE)
	{
		Adesk::UInt16 nSeg = 0;
		pFiler->readItem(&nSeg);
		for (Adesk::UInt16 i = 0; i < nSeg; i++)
		{
			double nVal = 0;
			pFiler->readItem(&nVal);
			m_lstOffset.Append(new double(nVal));
		}
	}
	return pFiler->filerStatus();
}

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

	pFiler->writeItem(g_nVersion);

	pFiler->writeItem((const AcGePoint3d &)m_ptLocation); //定位点--即不动点
	pFiler->writeItem(m_nRotation); //旋转角度
	pFiler->writeItem(m_nDist2DimLine); //定位点到尺寸线的距离, 可以为负值
	pFiler->writeItem(m_idDimStyle); //尺寸标注类型
	Adesk::UInt16 nSeg = m_lstSegment.Length();
	pFiler->writeItem(nSeg);
	for (Adesk::UInt16 i = 0; i < nSeg; i++) {
		double nVal = m_lstSegment[i];
		pFiler->writeItem(nVal);
	}

	pFiler->writeItem(m_nDimFlag);
	if (m_nDimFlag & DF_POSITION) {
		Adesk::UInt16 nTextSeg = m_lstTextPos.Length();
		pFiler->writeItem(nTextSeg);
		for (i = 0; i < nTextSeg; i++) {
			const DimTextPos &pTextPos = m_lstTextPos[i];
			pFiler->writeItem(pTextPos.nIndex);
			pFiler->writeItem((const AcGePoint2d &)pTextPos.ptPos);
		}
	}
	if (m_nDimFlag & DF_TEXT) {
		Adesk::UInt16 nTextSeg = m_lstTextContent.Length();
		pFiler->writeItem(nTextSeg);
		for (i = 0; i < nTextSeg; i++) {
			const DimTextContent &text = m_lstTextContent[i];
			pFiler->writeItem(text.nIndex);
			pFiler->writeString(text.sText);
		}
	}
	if (IsBind()) {
		pFiler->writeItem(m_idBind);
	}

	if (IsAngular()) {
		pFiler->writeItem(m_nDimRadius); //夹角,可以为负
		pFiler->writeItem(m_nObjRadius);
	}

	if (IsAssociate())
	{
		Adesk::UInt16 nSeg = m_lstOffset.Length();
		pFiler->writeItem(nSeg);
		for (Adesk::UInt16 i = 0; i < nSeg; i++)
		{
			double nVal = m_lstOffset[i];
			pFiler->writeItem(nVal);
		}
	}

	return pFiler->filerStatus();
}

Acad::ErrorStatus AecDbDimension::dxfInFields(AcDbDxfFiler* pFiler)
{
	AssertWriteEnabled();

	Acad::ErrorStatus es = AecXDbCurveBaseEx::dxfInFields(pFiler);
	if (es != Acad::eOk)
		return es;

	if (!pFiler->atSubclassData(_T("AecDbDimension"))) {
		return Acad::eBadDxfSequence;
	}

	return pFiler->filerStatus();

	// 不读入任何数据
}

Acad::ErrorStatus AecDbDimension::dxfOutFields(AcDbDxfFiler* pFiler) const
{
	assertReadEnabled();
	Acad::ErrorStatus es = AecXDbCurveBaseEx::dxfOutFields(pFiler);
	assert(es == Acad::eOk);

	es = pFiler->writeItem(AcDb::kDxfSubclass, _T("AecDbDimension"));
	assert(es == Acad::eOk);


	return es;
}



// -----------------------------------------------------------------------

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

	switch (osnapMode) {
	case AcDb::kOsModeNode:
	case AcDb::kOsModeIns: {
		double nOffDist = m_nDist2DimLine * GetPScale();
		GeCurveSegment cv = GetDimCurve();
		GeCurveSegment cvFix = cv.Offset(nOffDist, LS_FINITE);
		GePoly2D poly;
		GetPolySegOnDimLine(poly);

		if (osnapMode == AcDb::kOsModeNode) {
			int nVertNum = poly.Length();
			for (int i = 0; i < nVertNum; i++) {
				ADSGePoint3d ptFix;
				cvFix.ProjectToMe(*poly[i], ptFix);
				snapPoints.append(*poly[i]);
				snapPoints.append(ptFix);
			}
		}
		else {
			int nSeg = poly.TotalSegments();
			for (int i = 0; i < nSeg; i++) {
				ADSGePoint3d ptText = GetTextPos(i);
				snapPoints.append(ptText);
			}
		}
	}
						 break;
	default: {
		//PushMemVar<BOOL> vTemp(g_bExplAcadDim, FALSE);
		AecXDbCurveBaseEx::subGetOsnapPoints(osnapMode
			, gsSelectionMark
			, pickPoint
			, lastPoint
			, viewXform
			, snapPoints
			, geomIds);
	}
		   return Acad::eOk;
	}

	return es;
}

// Overriden functions for edit
// to do:
// 允许通过夹点改变边界
Acad::ErrorStatus AecDbDimension::subGetGripPoints(AcGePoint3dArray&  gripPoints,
	AcDbIntArray&  osnapModes,
	AcDbIntArray&  geomIds) const
{
	assertReadEnabled();
	double nOffDist = m_nDist2DimLine * GetPScale();
	GeCurveSegment cv = GetDimCurve();
	GeCurveSegment cvFix = cv.Offset(nOffDist, LS_FINITE);
	GeCurveSegment cvObj;
	if (IsAngular()) {
		double nDist2Obj = cv.GetArc().GetRadius() - m_nObjRadius;
		cvObj = cv.Offset(-nDist2Obj, LS_FINITE);
	}
	GePoly2D poly;
	GetPolySegOnDimLine(poly);

	int nVertNum = poly.Length();
	gripPoints.append(*poly.Head()); //0
	gripPoints.append(*poly.Tail()); //1

	for (int i = 0; i < nVertNum; i++)
	{
		ADSGePoint3d ptFix;
		if (IsAngular() && (IsDimChord() || IsDimArcLen()))
			cvObj.ProjectToMe(*poly[i], ptFix);
		else cvFix.ProjectToMe(*poly[i], ptFix);
		gripPoints.append(ptFix);
	}


	int nSeg = poly.TotalSegments();
	BOOL bIsDef = false;
	for (i = 0; i < nSeg; i++)
	{
		ADSGePoint3d ptText = GetTextPos(i);
		gripPoints.append(ptText);
	}


	if (IsAngular() && (IsDimChord() || IsDimArcLen()))
		gripPoints.append(m_ptLocation);
	else if (!IsAngular() && IsAssociate())
	{
		GeCurveSegment curve = GetDimCurve();
		if (m_nDist2DimLine > 0)
			curve = curve.Offset((m_nDist2DimLine + GetMaxScope()) * GetPScale(), 0);
		else
			curve = curve.Offset((m_nDist2DimLine - GetMaxScope()) * GetPScale(), 0);

		gripPoints.append(curve.StartPoint());
		gripPoints.append(curve.MidPoint());
		gripPoints.append(curve.EndPoint());
	}
	return Acad::eOk;
}

Acad::ErrorStatus AecDbDimension::subGetGripPoints(AcDbGripDataPtrArray & grips, const double curViewUnitSize, const int gripSize, const AcGeVector3d & curViewDir, const int bitflags) const
{
	return Acad::eNotImplementedYet;
}

// stretch points is diffrent from grep points, with no midpoint included
Acad::ErrorStatus  AecDbDimension::subGetStretchPoints(AcGePoint3dArray & stretchPoints) const
{
	assertReadEnabled();
	AcDbIntArray  osnapModes;
	AcDbIntArray  geomIds;

	return subGetGripPoints(stretchPoints, osnapModes, geomIds);
}


void AecDbDimension::UnionScale(double nScale)
{
	AssertWriteEnabled();
	AcGeMatrix3d mat;
	mat.setToScaling(nScale);
	m_ptLocation.TransformBy(mat);
	for (int i = 0; i < m_lstTextPos.Length(); i++)
		m_lstTextPos[i]->ptPos.TransformBy(mat);

	for (i = 0; i < m_lstSegment.Length(); i++)
		(*m_lstSegment[i]) *= nScale;
	m_nDimRadius *= nScale;
	m_nObjRadius *= nScale;
	for (i = 0; i < m_lstOffset.Length(); i++)
		(*m_lstOffset[i]) *= nScale;
}
// Active when being rotated, scaled, moved, etc.
// Scale is disabled here
Acad::ErrorStatus AecDbDimension::subTransformBy(const AcGeMatrix3d& xform)
{
	AssertWriteEnabled();
	AecXDbCurveBaseEx::subTransformBy(xform);
	ads_matrix mat;
	GlobalFunc::AsAdsMatrix(xform, mat);
	for (int i = 0; i < m_lstTextPos.Length(); i++) {
		m_lstTextPos[i]->ptPos.TransformBy(mat);
	}

	if (IsAngular()) {
		GeCurveSegment cv = GetDimCurve();
		cv.TransformBy(mat);
		m_nRotation = cv.IDirection(0);
		ads_polar(cv.StartPoint(), m_nRotation - PI / 2, GetDist2DimLine(FALSE), m_ptLocation);
		if (GlobalFunc::IsMirrorMatrix(mat)) {
			m_lstTextPos.Reverse();
			m_lstTextContent.Reverse();
			m_lstSegment.Reverse();
		}
	}
	else {
		m_ptLocation.TransformBy(mat);
		m_ptLocation.z = 0;
		Vector3D vt(cos(m_nRotation), sin(m_nRotation));
		((AcGeVector3d &)vt).transformBy(xform);
		m_nRotation = ads_angle(ADSGePoint3d(), vt);

		if (GlobalFunc::IsMirrorMatrix(mat)) {
			m_nDist2DimLine = -m_nDist2DimLine;
		}
	}

	return Acad::eOk;
}

//设置尺寸线位置
BOOL AecDbDimension::SetDimLinePos(ADSGePoint3d pt)
{
	AssertWriteEnabled();
	BOOL bRet = FALSE;
	GeCurveSegment seg = GetDimCurve();
	ADSGePoint3d ptOnSeg;
	if (seg.ProjectToMe(pt, ptOnSeg) == RTNORM) {
		double nDistMove = pt.Distance2d(ptOnSeg);
		int nSideLoc = seg.OnWhichSide(GetLocation());
		int nSide = seg.OnWhichSide(pt);
		double nDist2Dim = GetDist2DimLine(FALSE);

		if (fabs(nDist2Dim) > 1.0E-6) {
			double nFactor = nDist2Dim / fabs(nDist2Dim);
			if (nSide != nSideLoc)
				nDistMove *= nFactor;
			else
				nDistMove *= -nFactor;
		}
		else {
			if (nSideLoc = OFFSET_LEFT) nDistMove = -nDistMove;
		}
		if (IsAngular()) {
			nDist2Dim += nDistMove;
			double nDistRad = GetDimRadius();
			nDistRad -= nDistMove;
			if (nDistRad > g_Option::instance()._DIST_SNAP) {
				SetDimRadius(nDistRad);
				SetDist2DimLine(nDist2Dim, FALSE);
			}
		}
		else {
			nDist2Dim += nDistMove;
			SetDist2DimLine(nDist2Dim, FALSE);
		}
		bRet = TRUE;
	}

	return bRet;
}

//设置标注固定线位置
BOOL AecDbDimension::SetFixLinePos(ADSGePoint3d pt)
{
	AssertWriteEnabled();

	GeCurveSegment seg = GetDimCurve();
	double nOffDist = m_nDist2DimLine * GetPScale();
	GeCurveSegment cvFix = seg.Offset(nOffDist, LS_FINITE);
	double nDist = cvFix.GetDist2Me(pt);

	GeCurveSegment cvNewFix = cvFix.Offset(nDist, LS_FINITE);
	if (!cvNewFix)
		return FALSE;
	ADSGePoint3d ptNew = cvNewFix.NearPoint(m_ptLocation);

	m_nDist2DimLine = (nOffDist + nDist) / GetPScale();
	m_ptLocation = ptNew;
	return TRUE;

}

// 功能: 夹点操作, 还没有完全考虑圆弧类型
Acad::ErrorStatus AecDbDimension::MoveGripPointsAt1(
	const AcDbIntArray& indices,
	const AcGeVector3d& offset)
{
	AssertWriteEnabled();
	AcGePoint3dArray gripPoints;
	AcDbIntArray ar;
	subGetGripPoints(gripPoints, ar, ar);
	AcGeVector3d vtLocal(offset[0], offset[1], 0.0);
	for (int i = 0; i < indices.length(); i++) {
		int idx = indices[i];
		gripPoints[idx] += vtLocal;
	}

	int nVertNum = m_lstSegment.Length() + 1;
	GeCurveSegment cv = GetDimCurve();
	cv.SetPoints(ADSGePoint3d(gripPoints[0]), ADSGePoint3d(gripPoints[1]));
	ADSGePoint3d ptS, ptE;
	ADSGePoint3d ptS1 = gripPoints[2], ptE1 = gripPoints[2 + nVertNum - 1];
	if (cv.ProjectToMe(ptS1, ptS) == RTNORM &&
		cv.ProjectToMe(ptE1, ptE) == RTNORM)
		cv.SetPoints(ptS, ptE);

	if (cv.GetLength() < g_Option::instance()._DIST_SNAP)
		return Acad::eInvalidInput;
	SortedVertexList lstVert(cv);
	for (i = 1; i < nVertNum - 1; i++) {
		ADSGePoint3d ptFix = gripPoints[2 + i];
		ADSGePoint3d ptOnDim;
		if (cv.ProjectToMe(ptFix, ptOnDim) == RTNORM) {
			lstVert.Insert(ptOnDim);
		}
	}
	GePoly2D poly;
	lstVert.AsPoly2D(poly);

	m_lstSegment.Reset();
	int nSeg = poly.TotalSegments();
	for (i = 0; i < nSeg; i++) {
		GeCurveSegment seg;
		poly.Nth(i, seg);
		double nVal = seg.GetLength();
		if (IsValidSegment(nVal))
			AppendSegment(nVal);
	}

	if (IsAngular() && (IsDimChord() || IsDimArcLen())) {
		m_nObjRadius = cv.GetArc().GetCenterPt().Distance2d(gripPoints[2]);
		// Location???
		GeLine ln(cv.StartPoint(), cv.IDirection(0) + PI / 2);
		ADSGePoint3d ptNewLoc = m_ptLocation + ADSGePoint3d(offset[0], offset[1]);
		ptNewLoc.Project(&ln, m_ptLocation);
		m_ptLocation.z = 0;
	}
	else SetLocation(gripPoints[2]);

	SetRotation(cv.IDirection(0));
	double nDist2DimLine = m_ptLocation.Distance2d(cv.StartPoint());
	int nSide = cv.OnWhichSide(m_ptLocation);
	SetDist2DimLine(nSide == OFFSET_RIGHT ? nDist2DimLine : -nDist2DimLine, FALSE);


	if (nSeg == nVertNum - 1) { //区间数目没有变化
		for (i = 0; i < nSeg; i++) {
			int nGripIndex = i + nVertNum + 2;
			if (indices.contains(nGripIndex) && m_lstTextPos.FindNode(&i, DimTextPos::CompareByIndexForFind))
				SetTextPos(i, gripPoints[nGripIndex]);
		}
	}
	else {
		m_lstTextPos.Reset();
		m_lstTextContent.Reset();
	}
	AutoSetFlag();

	return Acad::eOk;
}


// 功能: 夹点操作
// Modify on 2002/8/8 解决调用getGripPoints效率很低
Acad::ErrorStatus AecDbDimension::subMoveGripPointsAt(
	const AcDbIntArray& indices,
	const AcGeVector3d& offset)
{
	if (indices.length() > 1)
		return MoveGripPointsAt1(indices, offset);

	AssertWriteEnabled();

	ADSGePoint3d vtOffset = *(ADSGePoint3d *)&offset;
	vtOffset.z = 0;
	GePoly2D poly, polyNew;
	GetPolySegOnDimLine(poly);
	polyNew = poly;
	GeCurveSegment cv = GetDimCurve();
	double nOffDist = m_nDist2DimLine * GetPScale();
	GeCurveSegment cvFix = cv.Offset(nOffDist, LS_FINITE);
	GeCurveSegment cvObj;
	if (IsAngular())
	{
		double nDist2Obj = cv.GetArc().GetRadius() - m_nObjRadius;
		cvObj = cv.Offset(-nDist2Obj, LS_FINITE);
	}

	for (int i = 0; i < indices.length(); i++)
	{
		int idx = indices[i];
		if (idx <= 1)
		{ //改变尺寸线位置
			ADSGePoint3d ptVert = idx == 0 ? *poly.Head() : *poly.Tail();
			double nExtDir = idx == 0 ? cv.IDirection(0) : cv.IDirection(1);
			GeLine lnExt(ptVert, nExtDir + PI / 2);
			ADSGePoint3d ptOnExt = ptVert + vtOffset;
			ADSGePoint3d(ptOnExt).Project(&lnExt, ptOnExt);

			int nSide = cv.OnWhichSide(ptOnExt);
			double nDistMove = ptVert.Distance2d(ptOnExt);

			double nOldDist2DimLine = m_nDist2DimLine, nOldDimRadius = m_nDimRadius;
			int nSideLoc = cv.OnWhichSide(m_ptLocation);
			if (fabs(m_nDist2DimLine) > g_Option::instance()._DIST_SNAP / GetPScale())
			{
				double nFactor = m_nDist2DimLine / fabs(m_nDist2DimLine);
				if (nSide != nSideLoc)
					m_nDist2DimLine += nFactor * nDistMove / GetPScale();
				else
					m_nDist2DimLine -= nFactor * nDistMove / GetPScale();
			}
			else
			{
				if (nSideLoc == OFFSET_LEFT)
					m_nDist2DimLine = -nDistMove / GetPScale();
			}
			if (IsAngular())
			{
				if (nSide == OFFSET_RIGHT)
					m_nDimRadius += nDistMove;
				else
					m_nDimRadius -= nDistMove;
				if (m_nDimRadius < g_Option::instance()._DIST_SNAP)
				{
					m_nDist2DimLine = nOldDist2DimLine;
					m_nDimRadius = nOldDimRadius;
				}
			}
		}
		else if (idx < poly.Length() + 2)
		{ //改变定位点或区间
			int ndx = idx - 2;
			ADSGePoint3d ptGrip, ptGrip0;
			if (IsAngular() && (IsDimChord() || IsDimArcLen()))
				cvObj.ProjectToMe(*poly[ndx], ptGrip);
			else
				cvFix.ProjectToMe(*poly[ndx], ptGrip);

			int vtIdx = idx - 2;
			ptGrip0 = ptGrip;
			ptGrip += vtOffset;
			if (!g_Option::instance().g_bStetchEntity && GetCtrlToggle())
			{
				if (!AddSegment(ptGrip) && GetSegmentNum() > 1)
					FindAndRemoveSegment(ptGrip0);
			}
			else
			{
				ADSGePoint3d ptOnDim;
				BOOL bGreatPrev = FALSE, bLessNext = FALSE;
				if (cv.ProjectToMe(ptGrip, ptOnDim) == RTNORM)
				{
					if (vtIdx > 0)
					{
						double nPathDist = cv.PathDistance(ptOnDim); //小于0时,为圆弧标注
						if (IsAngular() && nPathDist < -g_Option::instance()._DIST_SNAP)
						{
							if (vtIdx == polyNew.Length() - 1)
								nPathDist = cv.GetArc().GeCircle::GetLength() + nPathDist;
						}
						double nPathDistPrev = cv.PathDistance(*polyNew[vtIdx - 1]);
						bGreatPrev = (nPathDist - nPathDistPrev) > -g_Option::instance()._DIST_SNAP;
					}
					else
						bGreatPrev = TRUE;
					if (vtIdx < polyNew.Length() - 1)
						bLessNext = (cv.PathDistance(ptOnDim) - cv.PathDistance(*polyNew[vtIdx + 1])) < g_Option::instance()._DIST_SNAP;
					else bLessNext = TRUE;
					if (bGreatPrev && bLessNext)
					{
						if (vtIdx == 0)
						{
							GeCurveSegment seg;
							polyNew.Nth(0, seg);
							seg.SetPoints(ptOnDim, seg.EndPoint());
							if (IsAngular() && (IsDimChord() || IsDimArcLen()))
							{
								GeArc ar = seg.GetArc();
								GeCircle cir(ar.GetCenterPt(), ads_distance(ar.GetCenterPt(), m_ptLocation));
								ADSGePoint3d ptabc = m_ptLocation + vtOffset;
								ptabc.Project(&cir, m_ptLocation);
								m_nObjRadius = cir.GetCenterPt().Distance2d(ptGrip);
							}
							else
								m_ptLocation += vtOffset;

							if (IsValidSegment(seg.GetLength()))
							{
								m_nRotation = seg.IDirection(0);
								SetSegment(0, seg.GetLength());
								double nFactor = cv.OnWhichSide(m_ptLocation) == OFFSET_LEFT ? -1.0 : 1.0;
								if (!(IsAngular() && (IsDimChord() || IsDimArcLen())))
									SetDist2DimLine(m_ptLocation.Distance2d(ptOnDim) * nFactor, FALSE);
							}
							else
							{
								if (m_lstSegment.Length() > 1)
								{
									RemoveSegment(0);
									polyNew.Nth(1, seg);
									m_nRotation = seg.IDirection(0);
									double nFactor = cv.OnWhichSide(m_ptLocation) == OFFSET_LEFT ? -1.0 : 1.0;
									if (!(IsAngular() && (IsDimChord() || IsDimArcLen())))
										SetDist2DimLine(m_ptLocation.Distance2d(ptOnDim) * nFactor, FALSE);
								}
							}
						}
						else
						{
							BOOL bLast = (vtIdx == polyNew.Length() - 1);
							GeCurveSegment seg, segPrev;
							if (!bLast) polyNew.Nth(vtIdx, seg);
							polyNew.Nth(vtIdx - 1, segPrev);
							if (!bLast)
								ASSERT(IsValidSegment(seg.GetLength()));
							ASSERT(IsValidSegment(segPrev.GetLength()));
							if (!bLast) seg.SetPoints(ptOnDim, ADSGePoint3d(seg.EndPoint()));
							segPrev.SetPoints(ADSGePoint3d(segPrev.StartPoint()), ptOnDim);
							if (!bLast)
							{
								if (!IsValidSegment(seg.GetLength()))
									RemoveSegment(vtIdx);
								else
									SetSegment(vtIdx, seg.GetLength());
							}
							else
							{
								double nFactor = cv.OnWhichSide(ptGrip) == OFFSET_LEFT ? -1.0 : 1.0;
								if (!(IsAngular() && (IsDimChord() || IsDimArcLen())))
									SetDist2DimLine(ptGrip.Distance2d(ptOnDim) * nFactor, FALSE);
								ads_polar(cv.StartPoint(), m_nRotation - PI / 2, GetDist2DimLine(FALSE), m_ptLocation);
								if (IsAngular() && (IsDimChord() || IsDimArcLen()))
								{
									//改标注半径
									GeArc arDim = cv.GetArc();
									arDim.SetRadius(m_nObjRadius);
									GeCurveSegment cvObj;
									cvObj = arDim;
									ADSGePoint3d ptGrip = cvObj.EndPoint();
									ptGrip += vtOffset;
									m_nObjRadius = ptGrip.Distance2d(arDim.GetCenterPt());
								}
							}
							if (!IsValidSegment(segPrev.GetLength()))
							{
								if (m_lstSegment.Length() > 1)
									RemoveSegment(vtIdx - 1);
							}
							else
								SetSegment(vtIdx - 1, segPrev.GetLength());
						}
					}
				}
			}
		}
		else
		{
			int nSeg = idx - poly.Length() - 2;
			if (nSeg < poly.TotalSegments())
			{
				ADSGePoint3d ptText = GetTextPos(nSeg);
				ptText += vtOffset;
				SetTextPos(nSeg, ptText);
			}
			else
			{
				if (IsAngular() && (IsDimChord() || IsDimArcLen()))
				{
					GeLine ln(cv.StartPoint(), cv.IDirection(0) + PI / 2);
					ADSGePoint3d ptNewLoc = m_ptLocation + vtOffset;
					ptNewLoc.Project(&ln, m_ptLocation);
					int nSide = cv.OnWhichSide(ptNewLoc);
					double nFactor = cv.OnWhichSide(ptNewLoc) == OFFSET_LEFT ? -1.0 : 1.0;
					SetDist2DimLine(ptNewLoc.Distance2d(cv.StartPoint()) * nFactor, FALSE);
				}
				else if (!IsAngular() && IsAssociate())
				{
					ADSGePoint3d ptEnd;
					ads_polar(m_ptLocation, m_nRotation, 1, ptEnd);
					GeCurveSegment curve(m_ptLocation, ptEnd, 0);

					ADSGePoint3d ptVert, pt;
					AcGePoint3dArray grips;
					AcDbIntArray osnapModes, geomIds;
					subGetGripPoints(grips, osnapModes, geomIds);
					pt = grips[indices[0]];
					pt += vtOffset;

					if (curve.ProjectToMe(pt, ptVert) == RTNORM)
					{
						double dist = ptVert.Distance2d(pt);
						double nValue = dist / GetPScale();
						if (nValue < 0.1)
							return Acad::eInvalidInput;

						if (m_lstOffset.Length() < 1)
							m_lstOffset.Append(new double(nValue));
						else
							*m_lstOffset[0] = nValue;
					}
				}
			}
		}
	}
	//RemoveZeroSegment(); //把长度为0的区间移除
	AutoSetFlag();
	Acad::ErrorStatus es = Acad::eOk;
	return es;
}


// 功能: 夹点操作
Acad::ErrorStatus AecDbDimension::subMoveStretchPointsAt(
	const AcDbIntArray& indices,
	const AcGeVector3d& offset)
{
	int nCount = indices.length();
	PushMemVar<BOOL> vTemp(g_Option::instance().g_bStetchEntity, TRUE);
	return subMoveGripPointsAt(indices, offset);
}

// 取得夹点说明
Acad::ErrorStatus AecDbDimension::GetGripText(int i, CString &cs) const
{
	Acad::ErrorStatus es = Acad::eOk;
	GePoly2D poly;
	GetPolySegOnDimLine(poly);

	if (i <= 1)
		cs = _T("移动尺寸线");
	else if (i < poly.Length() + 2)
	{
		if (!GetCtrlToggle())
		{
			if (i == 2 || i == poly.Length() + 1)
			{
				if (IsAngular() && (IsDimChord() || IsDimArcLen()))
					cs = _T("更改标注半径和开间(Ctrl-增补合并尺寸开间)");
				else
					cs = _T("移动定位点和更改开间(Ctrl-增补合并尺寸开间)");
			}
			else
				cs = _T("更改合并尺寸开间(Ctrl-增补合并尺寸开间)");
		}
		else
		{
			if (i == 2 || i == poly.Length() + 1)
			{
				if (IsAngular() && (IsDimChord() || IsDimArcLen()))
					cs = _T("增补合并尺寸开间(Ctrl-更改标注半径和开间)");
				else
					cs = _T("增补合并尺寸开间(Ctrl-移动定位点和更改开间)");
			}
			else
				cs = _T("增补合并尺寸开间(Ctrl-更改合并尺寸开间)");
		}
	}
	else
	{
		int iVert = i - 2 - poly.Length();
		if (iVert < poly.TotalSegments())
			cs = _T("移动尺寸文本");
		else
		{
			if (IsAngular() && (IsDimChord() || IsDimArcLen()))
				cs = _T("改尺寸界线");
			else if (!IsAngular() && IsAssociate())
			{
				cs = _T("改尺寸关联范围");
			}
		}
	}

	return es;
}

int AecDbDimension::ConvertText(TConvertTextPtr ptr, void *pData)
{
	AssertWriteEnabled();
	int nLen = m_lstTextContent.Length();
	int nCode = RTNONE;
	for (int i = 0; i < nLen; i++) {
		DimTextContent *pContent = m_lstTextContent[i];
		TCString sText;
		int nRet = ptr(pContent->sText, sText, pData);
		if (nRet == RTERROR)
			nCode = nRet;
		else if (nRet == RTNORM)
			pContent->sText = sText;
	}
	return nCode;
}


// 返回发现的位置，同时posStart往前移动(以便继续找下一个使用),
TextPosition
AecDbDimension::FindSubText(const TCHAR *sSubText, TextPosition &posStart, TextRange *pRange) const
{
	assertReadEnabled();
	TextPosition pos;
	if (!sSubText || !sSubText[0])
		return pos;

	AcDbObjectId idTextStyle;
	double dimtxt = 3.0;
	OPENOBJ_BEGIN(m_idDimStyle, AcDb::kForRead, AcDbDimStyleTableRecord, pStyle);
	if (pStyle) {
		idTextStyle = pStyle->dimtxsty();
		dimtxt = pStyle->dimtxt();
	}
	OPENOBJ_END();
	if (!idTextStyle)
		return pos;

	int nLen = GetSegmentNum(); //m_lstTextContent.Length();
	int nCode = RTNONE;
	TextPosition posNext = posStart;
	for (int i = posStart.m_nCookies; i < nLen; i++) {
		//DimTextContent content=m_lstTextContent[i];
		TCString sTextDim = GetText(i);
		AecXDbText dimText;
		dimText.SetPScale(GetPScale());
		dimText.setPropertiesFrom(this);
		dimText.SetAlignment(AcGiDraw::kMiddleCenter);
		dimText.SetHeight(dimtxt);
		dimText.SetStyleId(idTextStyle);
		dimText.SetText(sTextDim);
		dimText.SetLocation(GetTextPos(i));
		posNext.m_nCookies = i;

		TextPosition posRet = dimText.FindSubText(sSubText, posNext, pRange);
		if (!posRet) {
			posNext.m_nTextPos = 0;
		}
		else {
			posStart = posNext;
			if (!posStart && (int)posStart.m_nCookies < nLen - 1) {
				posStart.m_nCookies++;
				posStart.m_nTextPos = 0;
			}
			posRet.m_nCookies = i;
			return posRet;
		}
	}
	return pos;
}

// 返回下一次查找的开始位置
TextPosition
AecDbDimension::ReplaceSubText(const TextPosition &posRep, const TCHAR *sRepText, TextRange *pRange)
{
	AssertWriteEnabled();
	TextPosition pos;
	pos.m_nBufLen = _tcslen(sRepText);
	pos.m_nCookies = posRep.m_nCookies;
	if (!posRep || (int)posRep.m_nCookies >= GetSegmentNum())
		return pos;

	AcDbObjectId idTextStyle;
	double dimtxt = 3.0;
	OPENOBJ_BEGIN(m_idDimStyle, AcDb::kForRead, AcDbDimStyleTableRecord, pStyle);
	if (pStyle) {
		idTextStyle = pStyle->dimtxsty();
		dimtxt = pStyle->dimtxt();
	}
	OPENOBJ_END();
	if (!idTextStyle)
		return pos;

	//DimTextContent *pContent=m_lstTextContent[posRep.m_nCookies];
	TCString sTextDim = GetText(posRep.m_nCookies);
	AecXDbText dimText;
	dimText.SetPScale(GetPScale());
	dimText.setPropertiesFrom(this);
	dimText.SetAlignment(AcGiDraw::kMiddleCenter);
	dimText.SetHeight(dimtxt);
	dimText.SetStyleId(idTextStyle);
	dimText.SetText(sTextDim);
	dimText.SetLocation(GetTextPos(posRep.m_nCookies));

	TextPosition posRet = dimText.ReplaceSubText(posRep, sRepText, pRange);
	SetTextContent(posRep.m_nCookies, dimText.GetText());
	if (!posRet) {
		if ((int)posRet.m_nCookies < GetSegmentNum() - 1) {
			posRet.m_nCookies = posRep.m_nCookies + 1;
			posRet.m_nTextPos = 0;
		}
	}
	return posRet;
}

Adesk::UInt32
AecDbDimension::subSetAttributes(AcGiDrawableTraits * traits)
{
	Adesk::UInt32 nRet = AecXDbCurveBaseEx::subSetAttributes(traits);
	//if(g_nAcadVer<15.0001)
	//    nRet |= kDrawableIsCompoundObject;
	return nRet;
}
SubText* AecDbDimension::GetSubText(long iText)const
{
	PushMemVar<BOOL> bExpl(g_Option::instance().g_bSelfDrawDim, TRUE);
	SubText*pSubText = AecXDbCurveBaseEx::GetSubText(iText);
	if (pSubText != NULL)
		pSubText->SetMenuType(6);
	return pSubText;
}
SubText* AecDbDimension::HitTestText(ADSGePoint3d pt)const
{
	PushMemVar<BOOL> bExpl(g_Option::instance().g_bSelfDrawDim, TRUE);
	SubText*pSubText = AecXDbCurveBaseEx::HitTestText(pt);
	if (pSubText != NULL)
		pSubText->SetMenuType(6);
	return pSubText;
}
Acad::ErrorStatus AecDbDimension::GetExtents2d(ADSGePoint3d &ptLow, ADSGePoint3d &ptUp) const
{
	AcDbExtents ext;
	Acad::ErrorStatus es = getGeomExtents(ext);
	ptLow = ext.minPoint();
	ptUp = ext.maxPoint();
	return es;
}
Acad::ErrorStatus AecDbDimension::Draw2d(AcGiDraw &dc) const
{
	assertReadEnabled();

	//if (Has2DBuffer() && !dc.IsDragging())
	if (Has2DBuffer() && !m_bInJig)
	{
		dc.SetColor(colorIndex());
		dc.SetLayer(layerId());
		BaseEx::_Draw2DBuffers(dc, true);
		//Draw2DBuffers(dc);
		return Acad::eOk;
	}

	BOOL bIsDefText;
	// modify by xlc on 101209 效率低，减少执行次数，解决多视口图纸切换运行慢的问题
	GePoly2D poly;
	GetPolySegOnDimLine(poly);

	// 绘制标注点，不打印
	//if (_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor()) == 0 && !dc.IsPlotGeneration())
	if (true)
	{
		AcGePoint3dArray gripPoints;
		double nOffDist = m_nDist2DimLine * GetPScale();
		GeCurveSegment cv = GetDimCurve();
		GeCurveSegment cvFix = cv.Offset(nOffDist, LS_FINITE);
		GeCurveSegment cvObj;
		if (IsAngular())
		{
			double nDist2Obj = cv.GetArc().GetRadius() - m_nObjRadius;
			cvObj = cv.Offset(-nDist2Obj, LS_FINITE);
		}

		// modify by xlc on 101209 移到外边了
		//GePoly2D poly;
		//GetPolySegOnDimLine(poly);

		int nVertNum = poly.Length();
		for (int i = 0; i < nVertNum; i++)
		{
			ADSGePoint3d ptFix;
			if (IsAngular() && (IsDimChord() || IsDimArcLen()))
				cvObj.ProjectToMe(*poly[i], ptFix);
			else cvFix.ProjectToMe(*poly[i], ptFix);
			DrawLine(dc, ptFix, ptFix);
			//dc << GeLine(ptFix, ptFix);
		}
	}

	// modified by whl on 060223
	// BOOL bCheckDim=GlobalFunc::DocGetCheckDim();
	BOOL bCheckDim = GlobalFunc::DocGetCheckDim() && !g_Option::instance().g_bExplodeSubText;

	double nPScale = GetPScale();
	if (!IsValid())
		return Acad::eInvalidInput;

	int nColorOld = dc.GetColor();
	double nOffDist = m_nDist2DimLine * GetPScale();
	//BOOL bDraw = (_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor()) == 0 || g_Option::instance().g_bSelfDrawDim);
	BOOL bDraw = TRUE;
	BOOL bQuickMode = (bDraw && !ownerId() && m_lstSegment.Length() >= g_Option::instance().g_nDimNumGripTip);
	if (g_Option::instance().g_bDisableQuickMode)
		bQuickMode = FALSE;

	// modify by xlc on 101209 提前了
//   GePoly2D poly;
//	 GetPolySegOnDimLine(poly);

	BOOL bAngular = IsAngular();
	BOOL bSelfDraw = (g_Option::instance().g_bOsnapExpl || bDraw ||  //g_bExpOtherDb ||
		(IsAngular() && (IsDimChord() || IsDimArcLen()))
		);
	if (bSelfDraw || bCheckDim)
	{
		//dc.SetAlignment(XExplodeDraw::kMiddleCenter);

		TCString sDimPrefix, sDimSuffix;
		double dimgap = 0, dimtxt = 0, dimexe = 0, dimexo = 0;
		double dimscale = 1.0, dimasz = 1.0, dimdle = 0.0;
		int dimclre = 0, dimclrd = 0, dimclrt = 0;
		int dimdec = 0, dimadec = 0;
		double nArrowThick = 6.0 * nPScale;
		double dimlfac = 1.0; // 标注显示的单位换算系数
		AcDbObjectId dimblk;
		AcDbObjectId idTextStyle;
		// sg add 20120413，增加对“标注文字从默认位置（由标注样式定义的位置）移动时标注文字的位置”设置的支持
		int nDimTextMovePos = 2;

		OPENOBJ_BEGIN(m_idDimStyle, AcDb::kForRead, AcDbDimStyleTableRecord, pDimStyle);
		if (pDimStyle != NULL)
		{
			dimdec = pDimStyle->dimdec();
			dimadec = pDimStyle->dimadec();
			dimgap = pDimStyle->dimgap();
			dimtxt = pDimStyle->dimtxt();
			dimblk = pDimStyle->dimblk();
			dimlfac = pDimStyle->dimlfac();
			dimscale = nPScale; //pDimStyle->dimscale();
			dimdle = pDimStyle->dimdle();
			dimasz = pDimStyle->dimasz();
			idTextStyle = pDimStyle->dimtxsty();
			dimexe = pDimStyle->dimexe();
			dimexo = pDimStyle->dimexo();
			dimclre = pDimStyle->dimclre().colorIndex();
			dimclrd = pDimStyle->dimclrd().colorIndex();
			dimclrt = pDimStyle->dimclrt().colorIndex();

			// sg add 20120413，增加对“标注文字从默认位置（由标注样式定义的位置）移动时标注文字的位置”设置的支持
			nDimTextMovePos = pDimStyle->dimtmove();

			const TCHAR *dimpost = pDimStyle->dimpost();
			const TCHAR *pStr = NULL;
			if (dimpost)
				pStr = _tcsstr(dimpost, _T("<>"));
			if (pStr)
			{
				GlobalFunc::StrCpy(sDimPrefix, dimpost, pStr);
				GlobalFunc::StrCpy(sDimSuffix, pStr + 2, NULL);
			}
			else if (dimpost)
			{
				_tcscpy(sDimSuffix, dimpost);
			}
		}
		else
		{
			return Acad::eInvalidInput;
		}
		OPENOBJ_END();

		GeCurveSegment cv = GetDimCurve();
		BOOL bDimArcLen = (IsAngular() && IsDimArcLen());
		if (bDimArcLen) // 弧长标注
		{
			int numSeg = poly.TotalSegments();
			for (int i = 0; i < numSeg; i++)
			{
				GeCurveSegment segDim, segFix, segObj;
				poly.Nth(i, segDim);

				segFix = segDim.Offset(OFFSET_LEFT, -GetDist2DimLine(FALSE), LS_FINITE);
				double nOffDist0 = segDim.GetArc().GetRadius() - m_nObjRadius;
				segObj = segDim.Offset(OFFSET_LEFT, nOffDist0, LS_FINITE);

				ADSGePoint3d ptAr1, ptAr2; // 弧长两端的标注点
				double nChorldDir = segObj.GeLine::Direction();
				GeLine ln1(segObj.GetStartPoint(), nChorldDir + PI / 2.0),
					ln2(segObj.GetEndPoint(), nChorldDir + PI / 2.0);
				ADSGePoint3d ptInt[2];
				segDim.SetLineFlag(LS_INFINITE);
				ln1.SetLineFlag(LS_INFINITE);

				int nIntNum = segDim.Intersection(ln1, ptInt[0], ptInt[1]);
				if (nIntNum == 0)
					continue;
				else if (nIntNum == 1)
					ptAr1 = ptInt[0];
				else
					ptAr1 = GeLine(ptInt[0], ptInt[1]).NearPoint(segDim.StartPoint());

				nIntNum = segDim.Intersection(ln2, ptInt[0], ptInt[1]);
				if (nIntNum == 0)
					continue;
				else if (nIntNum == 1)
					ptAr2 = ptInt[0];
				else
					ptAr2 = GeLine(ptInt[0], ptInt[1]).NearPoint(segDim.StartPoint());

				// sg add 120412，根据9.0需求，增加设置弧长标注样式的设置
				int nDimType = GlobalFunc::DocGetArcLenDimType();
				if (nDimType == 1) // 旧样式才修改标注样式点 
				{
					segDim.SetPoints(ptAr1, ptAr2);
				}

				// 绘制尺寸线
				if (dimclrd)
					dc.SetColor(dimclrd);
				DrawSegment(dc, segDim);
				//dc << segDim;

				// 绘制尺寸界线
				if (dimclre)
					dc.SetColor(dimclre);
				if (bQuickMode)
					;
				else if (!g_Option::instance().g_bOsnapExpl)
				{
					if (!dimblk)  // 尺寸箭头
					{
						// sg modify 120412，解决“实心闭合”样式，不支持设置“箭头大小”的问题
						double dXSize = 1.0 * dimscale * dimasz,
							dYSize = 0.33 * dimscale * dimasz;

						int nDealOldDimArrowSize = GlobalFunc::DocGetDealOldDimArrowSize();
						if (nDealOldDimArrowSize == 0 && fabs(dimasz - 1.0) < 1.0E-3) // 旧版本的“实心闭合”样式
						{
							dXSize *= 2;
							dYSize *= 2;
						}

						ADSGePointDir2d pt1, pt2;
						//segDim.Polar(2.0*dimscale, pt1);
						//segDim.Polar(2.0*dimscale, pt2, FALSE);
						segDim.Polar(dXSize, pt1);
						segDim.Polar(dXSize, pt2, FALSE);

						AcDbPolyline plArrow1;
						plArrow1.setPropertiesFrom(this);
						plArrow1.addVertexAt(0, segDim.StartPoint());
						//plArrow1.setWidthsAt(0, 0.0, 0.66*dimscale);
						plArrow1.setWidthsAt(0, 0.0, dYSize);
						plArrow1.addVertexAt(1, pt1);
						//plArrow1.setWidthsAt(1, 0.66*dimscale, 0.0);
						plArrow1.setWidthsAt(1, dYSize, 0.0);
						DrawPline(dc, plArrow1);
						//dc.Polyline(plArrow1);

						AcDbPolyline plArrow2;
						plArrow2.setPropertiesFrom(this);
						plArrow2.addVertexAt(0, pt2);
						//plArrow2.setWidthsAt(0, dYSize, 0.0);
						plArrow2.setWidthsAt(0, dYSize, 0.0);
						plArrow2.addVertexAt(1, segDim.EndPoint());
						plArrow2.setWidthsAt(1, 0.0, 0.0);
						DrawPline(dc, plArrow2);
						//dc.Polyline(plArrow2);
					}
					else
					{
						// 打印时，不能使用新方法
						//BOOL bNewMethod = (g_nAcadVer > 15.0001 && g_bMakeBlock);

						// sg add 091105，强制打印时，不使用新方法
						//if (_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor()) == 0 && dc.IsPlotGeneration())
						//	bNewMethod = FALSE;
						AcGeScale3d scale(dimscale * dimasz, dimscale * dimasz, dimscale * dimasz);
						DrawBlock(dc, dimblk, segDim.EndPoint(), scale, segDim.IDirection(1) + PI);
						DrawBlock(dc, dimblk, segDim.StartPoint(), scale, segDim.IDirection(0));

						//OPENOBJ_BEGIN(dimblk, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
						//if (pBlock)
						//{
						//	dc.DrawBlock(*pBlock, segDim.EndPoint(), AcGeScale3d(dimscale * dimasz, dimscale * dimasz, dimscale * dimasz),
						//		segDim.IDirection(1) + PI, bNewMethod);
						//	dc.DrawBlock(*pBlock, segDim.StartPoint(), AcGeScale3d(dimscale * dimasz, dimscale * dimasz, dimscale * dimasz),
						//		segDim.IDirection(0), bNewMethod);
						//}
						//OPENOBJ_END();
					}
				}

				// 尺寸界限
				ADSGePoint3d pt1, pt2;
				double nFactor = fabs(nOffDist) > g_Option::instance()._DIST_SNAP ? nOffDist / fabs(nOffDist) : 1.0;
				// sg add 120412，根据9.0需求，增加设置弧长标注样式的设置
				if (nDimType == 0) // 新样式 
				{
					double dStartDir = ads_angle(segDim.StartPoint(), segObj.StartPoint());
					ads_polar(segDim.StartPoint(), dStartDir, fabs(nOffDist) - dimexo * dimscale, pt1);
					ads_polar(segDim.StartPoint(), dStartDir, -dimexe * dimscale, pt2);
				}
				else // 旧样式
				{
					ads_polar(segDim.StartPoint(), nChorldDir - nFactor * PI / 2, fabs(nOffDist) - dimexo * dimscale, pt1);
					ads_polar(segDim.StartPoint(), nChorldDir + nFactor * PI / 2, dimexe * dimscale, pt2);
				}
				DrawLine(dc, pt1, pt2);
				//dc << GeLine(pt1, pt2);

				// sg add 120412，根据9.0需求，增加设置弧长标注样式的设置
				if (nDimType == 0) // 新样式 
				{
					double dEndDir = ads_angle(segDim.EndPoint(), segObj.EndPoint());
					ads_polar(segDim.EndPoint(), dEndDir, fabs(nOffDist) - dimexo * dimscale, pt1);
					ads_polar(segDim.EndPoint(), dEndDir, -dimexe * dimscale, pt2);
				}
				else // 旧样式
				{
					ads_polar(segDim.EndPoint(), nChorldDir - nFactor * PI / 2, fabs(nOffDist) - dimexo * dimscale, pt1);
					ads_polar(segDim.EndPoint(), nChorldDir + nFactor * PI / 2, dimexe * dimscale, pt2);
				}
				DrawLine(dc, pt1, pt2);
				//dc << GeLine(pt1, pt2);
				dc.SetColor(nColorOld);

				// 尺寸文字
				if (bQuickMode)
					;
				else if (!g_Option::instance().g_bOsnapExpl)
				{
					AecXDbText dimText;
					dimText.SetPScale(GetPScale());
					dimText.setPropertiesFrom(this);
					dimText.SetAlignment(AcGiDraw::kMiddleCenter);
					dimText.SetHeight(dimtxt);
					dimText.SetStyleId(idTextStyle);
					dimText.setColorIndex(dimclrt);

					int numSeg = poly.TotalSegments();
					BOOL bIsDefPos = TRUE;

					// modify by xlc on 101209 解决速度慢问题
					//ADSGePoint3d ptText=GetTextPos(i, &bIsDefPos);
					ADSGePoint3d ptText = GetTextPos(i, poly, &bIsDefPos);
					ADSGePoint3d ptTemp;
					ADSGePointDir2d ptTempDir;
					cv.ProjectToMe(ptText, ptTemp);
					double nDist = cv.PathDistance(ptTemp);
					cv.Polar(nDist, ptTempDir);

					// sg modify 120410，使用新增加的接口，代替基类中的NormalViewAngle函数，主要解决精确度是1度的问题
					// double nTextRot=NormalViewAngle(ptTempDir.nDirection);
					double nTextRot = ChangeToNormalViewAngle(ptTempDir.nDirection);

					bIsDefText = TRUE;

					// modify by xlc on 101209 解决速度慢问题
					//TCString sText0=GetText(i, &bIsDefText);
					TCString sText0 = GetText(i, poly, &bIsDefText);

					TCString sText;
					if (bIsDefText)
						sText << sDimPrefix << sText0 << sDimSuffix;
					else
						sText << sText0;
					dimText.SetRotation(Wcs2Layout(nTextRot));
					dimText.SetLocation(ptText);
					if (bSelfDraw)
					{
						PushProperty vProp(&dimText, dc);
						dimText.SetText(sText);
						DrawBaseEx(dc, dimText);
						//if (dc.IsFullExplode())
						//	dimText.ExplodeOrDraw2d(dc);
						//else
						//	dc.DrawEntity(dimText);

						ADSGePoint3d ext = dimText.GetExtents();
						ADSGePoint3d ptMid, ptS, ptE;
						ads_polar(ptText, nTextRot + PI / 2, ext.y, ptMid);
						ads_polar(ptText, nTextRot - PI, ext.x / 2, ptS);
						ads_polar(ptText, nTextRot, ext.x / 2, ptE);
						ads_polar(ADSGePoint3d(ptS), nTextRot + PI / 2, ext.y / 2, ptS);
						ads_polar(ADSGePoint3d(ptE), nTextRot + PI / 2, ext.y / 2, ptE);
						DrawArc(dc, ptS, ptMid, ptE, dimText.colorIndex());
						//dc << GeArc(ptS, ptMid, ptE);
					}

					// sg add 120413，增加文字不在默认位置时候的引线
					if (nDimTextMovePos != 2 && !bIsDefPos) // 在线旁和有引线，暂时都用通一种表示方法
					{
						cv.ProjectToMe(ptText, ptTemp);
						double dDistance = ptText.Distance2d(ptTemp),
							dMixLeaderDis = nPScale * (dimgap + dimtxt * 0.5 + dimexe);
						if (dDistance > dMixLeaderDis + g_Option::instance()._DIST_SNAP)
						{
							if (dimclrd) // 使用尺寸线的颜色
								dc.SetColor(dimclrd);

							ADSGePoint3d ptLeader1 = segDim.MidPoint(),		// 引线起点
								ptLeaderS, ptLeaderE;				// 引线文字基线两个端点
							// sg modify 120706，解决有布局转角的尺寸标注的文字引线角度不正确的问题
							//double dLineDir = Wcs2Layout(nTextRot); // 引线文字基线方向
							double dLineDir = nTextRot; // 引线文字基线方向
							ads_polar(ptText, dLineDir - PI / 2, nPScale * (dimgap + dimtxt * 0.5), ptLeaderS);
							ads_polar(ptText, dLineDir - PI / 2, nPScale * (dimgap + dimtxt * 0.5), ptLeaderE);

							ADSGePoint3d ptExt = dimText.GetExtents();

							double dTextXLen = ptExt.x;
							dTextXLen *= 0.6; // 1.2*0.5，引线长默认是文字的1.2倍吧
							ads_polar(ptLeaderS, dLineDir, -dTextXLen, ptLeaderS);
							ads_polar(ptLeaderE, dLineDir, dTextXLen, ptLeaderE);

							ADSGePoint3d ptLeader2 = GeLine(ptLeaderS, ptLeaderE).NearPoint(ptLeader1);
							DrawLine(dc, ptLeader1, ptLeader2);
							DrawLine(dc, ptLeaderS, ptLeaderE);
							//dc << GeLine(ptLeader1, ptLeader2);
							//dc << GeLine(ptLeaderS, ptLeaderE);
						}
					}

					if (bCheckDim && !bIsDefText)
					{
						TCString sCheckText(256);
						// modify by xlc on 101209 解决速度慢问题
						// sCheckText << _T("(") << sDimPrefix << GetDefaultText(i) << sDimSuffix << _T(")");
						sCheckText << _T("(") << sDimPrefix << GetDefaultText(i, poly) << sDimSuffix << _T(")");

						ADSGePoint3d ptCheckText;
						if (bIsDefPos)
						{
							ADSGePoint3d ptOnSeg;
							if (segDim.ProjectToMe(ptText, ptOnSeg) == RTNORM)
							{
								ptOnSeg.Mirror(ptText, ptCheckText);
							}
						}
						else
						{
							int nSideText = segDim.OnWhichSide(ptText);
							if (nSideText == OFFSET_RIGHT)
								ads_polar(ptText, ptTempDir.nDirection - PI / 2, nPScale * (dimgap + dimtxt), ptCheckText);
							else
								ads_polar(ptText, ptTempDir.nDirection + PI / 2, nPScale * (dimgap + dimtxt), ptCheckText);
						}
						dimText.setColorIndex(1);
						dimText.SetLocation(ptCheckText);
						dimText.SetText(sCheckText);
						{
							PushProperty vProp(&dimText, dc);
							DrawBaseEx(dc, dimText);
							//if (dc.IsFullExplode())
							//	dimText.ExplodeOrDraw2d(dc);
							//else
							//	dc.DrawEntity(dimText);
						}
						dimText.setColorIndex(dimclrt);
					} // bCheckDim
					dc.SetColor(nColorOld);
				} // g_bExplOsnap
			} // End for
		}
		else if (IsAngular() && IsDimChord()) // 弦长标注
		{
			PushMemVar<BOOL> tVar1(g_Option::instance().g_bDisableQuickMode, TRUE);
			int numSeg = poly.TotalSegments();
			for (int i = 0; i < numSeg; i++)
			{
				GeCurveSegment segDim, segFix, segObj;
				poly.Nth(i, segDim);
				segFix = segDim.Offset(OFFSET_LEFT, -GetDist2DimLine(FALSE), LS_FINITE);
				double nOffDist0 = segDim.GetArc().GetRadius() - m_nObjRadius;
				segObj = segDim.Offset(OFFSET_LEFT, nOffDist0, LS_FINITE);
				double nRot = segObj.GeLine::Direction();
				ADSGePoint3d ptFix;
				double nObj2Fix = segFix.GetArc().GetRadius() - segObj.GetArc().GetRadius();
				ads_polar(segObj.StartPoint(), nRot - PI / 2, nObj2Fix, ptFix);

				AecDbDimension objDim;
				objDim.m_bInJig = this->m_bInJig;
				objDim.setPropertiesFrom(this);
				objDim.SetLocation(ptFix);
				objDim.SetRotation(nRot);
				objDim.SetDist2DimLine(GetDist2DimLine());
				objDim.AppendSegment(segObj.GetArc().ChordLength());
				objDim.SetStyleId(GetStyleId());

				DimTextPos *pNode1 = ((AecDbDimension *)this)->m_lstTextPos.FindNode(&i, DimTextPos::CompareByIndexForFind);
				if (pNode1)
					objDim.SetTextPos(0, pNode1->ptPos);

				DimTextContent *pNode = ((AecDbDimension *)this)->m_lstTextContent.FindNode(&i, DimTextContent::CompareByIndexForFind);
				if (pNode)
					objDim.SetTextContent(0, pNode->sText);
				DrawBaseEx(dc, objDim);
				//objDim.ExplodeOrDraw2d(dc);
			}
		}
		else // 直线标注或角度标注
		{
			if (bSelfDraw)
			{
				if (dimclrd) // 尺寸线颜色
					dc.SetColor(dimclrd);

				if (IsAngular())
					DrawPoly2D(dc, poly);
				//dc << poly;
				else
				{
					ADSGePoint3d ptStart, ptEnd;
					ads_polar(*poly[0], m_nRotation + PI, dimdle * dimscale, ptStart);
					DrawLine(dc, ptStart, *poly[0]);
					//dc << GeLine(ptStart, *poly[0]);

					ads_polar(*poly[poly.Length() - 1], m_nRotation, dimdle * dimscale, ptEnd);
					DrawLine(dc, *poly[poly.Length() - 1], ptEnd);
					//dc << GeLine(*poly[poly.Length() - 1], ptEnd);

					DrawPoly2D(dc, poly);
					//dc << poly;
				}
				// dc << cv;

				if (dimclre) // 尺寸界线颜色
					dc.SetColor(dimclre);

				int numVert = poly.Length();
				for (int i = 0; i < numVert; i++)
				{
					ADSGePoint3d ptVert = *poly[i];
					double nPathDist = cv.PathDistance(ptVert);
					ADSGePointDir2d ptVertDir;
					cv.Polar(nPathDist, ptVertDir);

					if (bQuickMode)
						;
					else if (!g_Option::instance().g_bOsnapExpl)
					{
						if (!dimblk) // 尺寸箭头，对AutoDesk强烈抗议，为什么只有“实心闭合”不是块呢
						{
							// sg modify 120412，解决“实心闭合”样式，不支持设置“箭头大小”的问题
							double dXSize = 1.0 * dimscale * dimasz,
								dYSize = 0.33 * dimscale * dimasz;

							int nDealOldDimArrowSize = GlobalFunc::DocGetDealOldDimArrowSize();
							if (nDealOldDimArrowSize == 0 && fabs(dimasz - 1.0) < 1.0E-3) // 旧版本的“实心闭合”样式
							{
								dXSize *= 2;
								dYSize *= 2;
							}

							ADSGePointDir2d pt1, pt2;
							//cv.Polar(nPathDist+2.0*dimscale, pt1);
							//cv.Polar(nPathDist-2.0*dimscale, pt2);
							cv.Polar(nPathDist + dXSize, pt1);
							cv.Polar(nPathDist - dXSize, pt2);

							AcDbPolyline plArrow;
							plArrow.setPropertiesFrom(this);
							int iVert = 0;
							if (i > 0)
							{
								plArrow.addVertexAt(iVert, pt2);
								//plArrow.setWidthsAt(iVert, 0.66*dimscale, 0.0);
								plArrow.setWidthsAt(iVert, dYSize, 0.0);
								iVert++;
							}

							plArrow.addVertexAt(iVert, ptVert);
							//plArrow.setWidthsAt(iVert, 0.0, 0.66*dimscale);
							plArrow.setWidthsAt(iVert, 0.0, dYSize);
							iVert++;

							if (i < numVert - 1)
							{
								plArrow.addVertexAt(iVert, pt1);
								iVert++;
							}
							DrawPline(dc, plArrow);
							//dc.Polyline(plArrow);
						}
						else
						{
							// 打印时，不能使用新方法
							//BOOL bNewMethod = (g_nAcadVer > 15.0001 && g_bMakeBlock);

							//// sg add 091105，强制打印时，不使用新方法
							//if (_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor()) == 0 && dc.IsPlotGeneration())
							//	bNewMethod = FALSE;
							AcGeScale3d scale(dimscale * dimasz, dimscale * dimasz, dimscale * dimasz);
							DrawBlock(dc, dimblk, ptVert, scale, ChangeToNormalViewAngle(ptVertDir.nDirection));

							//OPENOBJ_BEGIN(dimblk, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
							//if (pBlock)
							//{
							//	// sg modify 120410，使用新增加的接口，代替基类中的NormalViewAngle函数，主要解决精确度是1度的问题
							//	//dc.DrawBlock(*pBlock, ptVert, AcGeScale3d(dimscale*dimasz, dimscale*dimasz, dimscale*dimasz), 
							//	//    NormalViewAngle(ptVertDir.nDirection), bNewMethod);
							//	dc.DrawBlock(*pBlock, ptVert, AcGeScale3d(dimscale * dimasz, dimscale * dimasz, dimscale * dimasz),
							//		ChangeToNormalViewAngle(ptVertDir.nDirection), bNewMethod);
							//}
							//OPENOBJ_END();
						}
					}

					// 尺寸界限
					ADSGePoint3d pt1, pt2;
					double nFactor = fabs(nOffDist) > g_Option::instance()._DIST_SNAP ? nOffDist / fabs(nOffDist) : 1.0;
					ads_polar(ptVert, ptVertDir.nDirection - nFactor * PI / 2, fabs(nOffDist) - dimexo * dimscale, pt1);
					ads_polar(ptVert, ptVertDir.nDirection + nFactor * PI / 2, dimexe * dimscale, pt2);

					DrawLine(dc, pt1, pt2);
					//dc << GeLine(pt1, pt2);
				}
			}

			dc.SetColor(nColorOld);
			if (bQuickMode)
				;
			else if (!g_Option::instance().g_bOsnapExpl)
			{
				AecXDbText dimText;
				dimText.SetPScale(GetPScale());
				dimText.setPropertiesFrom(this);
				dimText.SetAlignment(AcGiDraw::kMiddleCenter);
				dimText.SetHeight(dimtxt);
				dimText.SetStyleId(idTextStyle);
				dimText.setColorIndex(dimclrt); // 文字颜色
				int numSeg = poly.TotalSegments();
				for (int i = 0; i < numSeg; i++)
				{
					GeCurveSegment seg;
					poly.Nth(i, seg);

					BOOL bIsDefPos = TRUE;
					// modify by xlc on 101209 解决速度慢问题
					// ADSGePoint3d ptText=GetTextPos(i, &bIsDefPos);
					ADSGePoint3d ptText = GetTextPos(i, poly, &bIsDefPos);

					ADSGePoint3d ptTemp;
					ADSGePointDir2d ptTempDir;
					cv.ProjectToMe(ptText, ptTemp);
					double nDist = cv.PathDistance(ptTemp);
					cv.Polar(nDist, ptTempDir);

					// sg modify 120410，使用新增加的接口，代替基类中的NormalViewAngle函数，主要解决精确度是1度的问题
					// double nTextRot=NormalViewAngle(ptTempDir.nDirection);
					double nTextRot = ChangeToNormalViewAngle(ptTempDir.nDirection);

					BOOL bIsDefText = TRUE;
					// modify by xlc on 101209 解决速度慢问题
					//TCString sText0=GetText(i, &bIsDefText);
					TCString sText0 = GetText(i, poly, &bIsDefText);
					TCString sText;
					if (bIsDefText && !IsAngular())
						sText << sDimPrefix << sText0 << sDimSuffix;
					else
						sText << sText0;

					dimText.SetText(sText);
					dimText.SetRotation(Wcs2Layout(nTextRot));

					ADSGePoint3d ptLeader1 = seg.MidPoint(), ptLeader2;	// 引线起点				
					ADSGePoint3d ptDimPos = ptText, ptLeaderS, ptLeaderE;

					// sg add 120413，增加文字不在默认位置时候的引线
					if (nDimTextMovePos != 2 && !bIsDefPos) // 在线旁和有引线，暂时都用通一种表示方法
					{
						ADSGePoint3d ptExt = dimText.GetExtents();
						double ddimgap = nPScale * (dimgap + dimtxt * 0.5);

						cv.ProjectToMe(ptDimPos, ptTemp);
						double dDistance = ptDimPos.Distance2d(ptTemp);
						double dMixLeaderDis = ddimgap + nPScale * dimexe;
						if (dDistance + g_Option::instance()._DIST_SNAP > dMixLeaderDis)
						{
							ads_polar(ptDimPos, nTextRot + PI / 2, ddimgap, ptDimPos);
							ADSGePoint3d ptDim1, ptDim2;
							ads_polar(ptDimPos, nTextRot, -ptExt.x * 0.5, ptDim1);
							ads_polar(ptDimPos, nTextRot, ptExt.x * 0.5, ptDim2);

							double dAngle = acutAngle(seg.StartPoint(), seg.EndPoint());
							AcGeVector3d vtSeg = seg.StartPoint() - seg.EndPoint();
							if (dAngle > PI / 2 && dAngle <= PI)
							{
								vtSeg *= -1;
							}
							if (dAngle > PI && dAngle <= 1.5 * PI)
							{
								vtSeg *= -1;
							}
							ADSGePoint3d ptOnline;
							seg.ProjectToMe(ptText, ptOnline);

							AcGeVector3d vtTxt = ptOnline - ptLeader1;

							if (vtTxt.isCodirectionalTo(vtSeg))
							{
								ads_polar(ptDimPos, nTextRot, -ptExt.x * 0.5, ptDimPos);
							}
							else
							{
								ads_polar(ptDimPos, nTextRot, ptExt.x * 0.5, ptDimPos);
							}

							//ptDimPos = GeLine(ptDim1, ptDim2).NearPoint(ptText);
							//ads_polar(ptDimPos, nTextRot, ptExt.x * 0.5, ptText);
							//ptText = ptDimPos;

							// sg modify 120706，解决有布局转角的尺寸标注的文字引线角度不正确的问题
							//double dLineDir = Wcs2Layout(nTextRot); // 引线文字基线方向
							double dLineDir = nTextRot; // 引线文字基线方向
							ads_polar(ptDimPos, dLineDir - PI / 2, ddimgap, ptLeaderS);
							ptLeaderE = ptLeaderS;

							double dTextXLen = ptExt.x;
							dTextXLen *= 0.6; // 1.2*0.5，引线长默认是文字的1.2倍吧
							ads_polar(ptLeaderS, dLineDir, -dTextXLen, ptLeaderS);
							ads_polar(ptLeaderE, dLineDir, dTextXLen, ptLeaderE);

							ptLeader2 = GeLine(ptLeaderS, ptLeaderE).NearPoint(ptLeader1);

							// wlw add 12.9.7角度引线的修改
							if (IsAngular())
							{
								dimText.SetRotation(0.0);
								AcGeCircArc3d cir(seg.StartPoint(), seg.MidPoint(), seg.EndPoint());
								vtSeg = acdbCurDwg()->ucsxdir();
								if (cir.center().distanceTo(ptText.AsAcGePoint3d()) > cir.radius())
								{
									vtSeg *= -1;
								}
								ptLeaderE = ptText + vtSeg * (ptExt.x * 0.5 + dimgap * nPScale);
								ptLeaderS = ptLeaderE + vtSeg * nPScale;
								ptDimPos = ptText;
								ptLeader2 = ptLeaderS;
							}

							DrawLine(dc, ptLeader1, ptLeader2);
							DrawLine(dc, ptLeaderS, ptLeaderE);

							//dc << GeLine(ptLeader1, ptLeader2);
							//dc << GeLine(ptLeaderS, ptLeaderE);
						}
					}
					dimText.SetLocation(ptDimPos);

					if (bSelfDraw)
					{
						PushProperty vProp(&dimText, dc);
						DrawBaseEx(dc, dimText);
						//if (dc.IsFullExplode())
						//	dimText.ExplodeOrDraw2d(dc);
						//else
						//	dc.DrawEntity(dimText);
					}


					if (bCheckDim && !bIsDefText) // 尺寸检查
					{
						TCString sCheckText(256);
						sCheckText << _T("(");
						if (!IsAngular())
							sCheckText << sDimPrefix;

						// modify by xlc on 101209 解决速度慢问题
						// sCheckText << GetDefaultText(i);
						sCheckText << GetDefaultText(i, poly);

						if (!IsAngular())
							sCheckText << sDimSuffix;
						sCheckText << _T(")");

						ADSGePoint3d ptCheckText;
						if (bIsDefPos)
						{
							ADSGePoint3d ptOnSeg;
							if (seg.ProjectToMe(ptText, ptOnSeg) == RTNORM)
							{
								ptOnSeg.Mirror(ptText, ptCheckText);
							}
						}
						else
						{
							int nSideText = seg.OnWhichSide(ptText);
							if (nSideText == OFFSET_RIGHT)
								ads_polar(ptText, ptTempDir.nDirection - PI / 2, nPScale * (dimgap + dimtxt), ptCheckText);
							else
								ads_polar(ptText, ptTempDir.nDirection + PI / 2, nPScale * (dimgap + dimtxt), ptCheckText);
						}

						dimText.setColorIndex(1);
						dimText.SetLocation(ptCheckText);
						dimText.SetText(sCheckText);
						{
							PushProperty vProp(&dimText, dc);
							DrawBaseEx(dc, dimText);
							//if (dc.IsFullExplode())
							//	dimText.ExplodeOrDraw2d(dc);
							//else
							//	dc.DrawEntity(dimText);
						}
						dimText.setColorIndex(dimclrt);
					} // bCheckDim && !bIsDefText
				} // for

				dc.SetColor(nColorOld);
			} // !g_Option::instance().g_bOsnapExpl
		} // 直线标注或角度标注
	} // bSelfDraw || bCheckDim

	if (!bSelfDraw)
	{
		//BOOL bDraw = (_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor()) == 0);
		//BOOL bExplode = (_tcscmp(dc.Desc(), XExplodeStream::Descriptor()) == 0);

		double dTxtHeight = 0.0, dtxtw = 0.0;
		double dPScale = GetPScale();

		AcDbObjectId idDimStyle = GlobalFunc::DimStyleTch2Acad(m_idDimStyle, dPScale, IsAngular(), database(), dTxtHeight);

		int nSeg = poly.TotalSegments();
		for (int i = 0; i < nSeg; i++)
		{
			GeCurveSegment seg;
			poly.Nth(i, seg);
			ASSERT(!!seg);

			GeCurveSegment segOnFix = seg.Offset(OFFSET_RIGHT, nOffDist, LS_FINITE);
			AcDbDimension *pDim = NULL;
			ADSGePoint3d ptText = seg.MidPoint();

			if (!bAngular)
			{
				ADSGePoint3d pt1 = segOnFix.StartPoint(),
					pt2 = segOnFix.EndPoint();
				// sg modify 120410，使用新增加的接口，代替基类中的NormalViewAngle函数，主要解决精确度是1度的问题
				// double nAng = NormalViewAngle(ads_angle(pt1, pt2));
				double nAng = ChangeToNormalViewAngle(ads_angle(pt1, pt2));
				if (!IsExactSameDrt(nAng, ads_angle(pt1, pt2), g_DimOption::instance()._angSnap))
					GlobalFunc::Exchange(pt1, pt2);
				pDim = new AcDbAlignedDimension(pt1, pt2, ptText);
			}
			else
			{
				ADSGePoint3d ptCen = seg.GetArc().GetCenterPt();
				pDim = new AcDb3PointAngularDimension(ptCen, segOnFix.StartPoint(), segOnFix.EndPoint(), ptText);
			}
			bool bModifyGap = false; // 标记是否需要单独修改“文字偏移”
			DimTextPos *pNode = ((AecDbDimension *)this)->m_lstTextPos.FindNode(&i, DimTextPos::CompareByIndexForFind);
			if (pNode)
			{
				// sg add 120718，用来标记是否是角度标注，并且带引线的样式，文字不在默认位置，此情况下，导出的时候需要特殊处理布局转角
				int nDimTextMovePos(2);
				double dimgap(0),
					dimtxt(0),
					dimexe(0);
				AcDbObjectId idTextStyle;
				TCString sDimPrefix, sDimSuffix;
				OPENOBJ_BEGIN(m_idDimStyle, AcDb::kForRead, AcDbDimStyleTableRecord, pDimStyle);
				if (pDimStyle != NULL)
				{
					nDimTextMovePos = pDimStyle->dimtmove();
					dimgap = pDimStyle->dimgap();
					dimtxt = pDimStyle->dimtxt();
					dimexe = pDimStyle->dimexe();
					idTextStyle = pDimStyle->dimtxsty();

					const TCHAR *dimpost = pDimStyle->dimpost();
					const TCHAR *pStr = NULL;
					if (dimpost)
						pStr = _tcsstr(dimpost, _T("<>"));
					if (pStr)
					{
						GlobalFunc::StrCpy(sDimPrefix, dimpost, pStr);
						GlobalFunc::StrCpy(sDimSuffix, pStr + 2, NULL);
					}
					else if (dimpost)
					{
						_tcscpy(sDimSuffix, dimpost);
					}
				}
				OPENOBJ_END();

				/*wlw 12.9.7
				ADSGePoint3d ptDimPos = pNode->ptPos,
					ptTempPos;
				GeCurveSegment cvDim = GetDimCurve();
				cvDim.ProjectToMe(pNode->ptPos, ptTempPos);

				ADSGePointDir2d ptTempDir;
				double dDistNonDefPt = cvDim.PathDistance(ptTempPos);
				cvDim.Polar(dDistNonDefPt, ptTempDir);

				double dTextRot = ChangeToNormalViewAngle(ptTempDir.nDirection);

				if (!bAngular && nDimTextMovePos!=2)
				{
					double dDistance = ptDimPos.Distance2d(ptTempPos),
						dMixLeaderDis = nPScale*(dimgap + dimtxt*0.5 + dimexe);
					ads_polar(ptDimPos, dTextRot-PI/2, nPScale*(dimgap + dimtxt*0.5), ptDimPos);

					if (dDistance > dMixLeaderDis + g_Option::instance()._DIST_SNAP) // 有引线
					{
						AecXDbText dimText;
						dimText.setPropertiesFrom(this);
						dimText.SetAlignment(XExplodeDraw::kMiddleCenter);
						dimText.SetHeight(dimtxt);
						dimText.SetStyleId(idTextStyle);
						dimText.SetRotation(Wcs2Layout(dTextRot));
						dimText.SetLocation(pNode->ptPos);

						BOOL bIsDefText = TRUE;
						TCString sText0 = GetText(i, poly, &bIsDefText),
							sText;
						if (bIsDefText && !IsAngular())
							sText << sDimPrefix << sText0 << sDimSuffix;
						else
							sText << sText0;
						dimText.SetText(sText);

						ADSGePoint3d ptExt = dimText.GetExtents();

						ADSGePoint3d ptDim1, ptDim2;
						ads_polar(ptDimPos, dTextRot, -ptExt.x*0.5, ptDim1);
						ads_polar(ptDimPos, dTextRot, ptExt.x*0.5, ptDim2);
						ptDimPos = GeLine(ptDim1, ptDim2).NearPoint(ptText);
					}
				}
				if (bAngular && nDimTextMovePos!=2)
				{
					//pDim->setTextRotation(dTextRot);
				}
				*/
				ADSGePoint3d ptDimPos = pNode->ptPos, ptTempPos;
				ADSGePointDir2d ptTempDir;
				GeCurveSegment cvDim = GetDimCurve();
				cvDim.ProjectToMe(pNode->ptPos, ptTempPos);
				double dDistNonDefPt = cvDim.PathDistance(ptTempPos);
				cvDim.Polar(dDistNonDefPt, ptTempDir);
				double dTextRot = ChangeToNormalViewAngle(ptTempDir.nDirection);

				pDim->setTextPosition(pNode->ptPos);
				if (nDimTextMovePos == 1)
				{
					//wlw add 12.09.17带引线的标注，如果小于cad引线范围内，人为修改文字位置，否则导t3文字移位
					double ddimgapX = nPScale * (dimgap + dimtxt * 0.5);
					if (ptDimPos.Distance2d(ptTempPos) + g_Option::instance()._DIST_SNAP < ddimgapX + nPScale * dimexe)
					{
						ads_polar(ptDimPos, dTextRot - PI / 2, ddimgapX, ptDimPos);
						pDim->setTextPosition(ptDimPos);
					}
				}

				pDim->useSetTextPosition();

			}
			// sg modify 120315，解决如果单独设置过天正的布局转角，图形导出T3或者炸开后，文字位置错误的问题
			// 主要是CAD的对象没有布局转角的概念，需要额外处理一下
			else if (fabs(m_nLayoutRotation) > g_DimOption::instance()._angSnap)
			{
				ADSGePoint3d ptDefText = GetDefaultTextPos(i, poly);
				pDim->setTextPosition(ptDefText); // 固定文字位置
				pDim->useSetTextPosition();

				double dTextAngle = ads_angle(ptText, ptDefText); // 重新计算标注的角度，0位置表示的是与Y轴正向间的夹角
				dTextAngle -= PI / 2;
				pDim->setTextRotation(dTextAngle);

				// 需要单独修改扩展数据来设置对象内的“文字偏移”
				bModifyGap = true;
			}

			//	DimTextContent *pNode1 = ((AecDbDimension *)this)->m_lstTextContent.FindNode(&i, DimTextContent::CompareByIndexForFind);
			TCString sTextdim = GetText(i, poly, &bIsDefText);
			//wlw mod 130929导出T3保持文字不变
			if (bIsDefText)
			{
				pDim->setDimensionText(_T(""));
			}
			else
			{
				pDim->setDimensionText(sTextdim);
			}
			pDim->setDimensionStyle(idDimStyle);
			pDim->setDimstyleData(idDimStyle);
			pDim->setPropertiesFrom(this);
#if (ARX != 17)
			if (bModifyGap) // 标记为真的适合，表示需要单独修改“文字偏移”量，天正的尺寸标注对象，不支持遮挡效果，所以直接设置为0即可
			{
				pDim->setDimgap(0);
			}
#endif
			//((XExplodeStream &)dc).Append(pDim, FALSE);
		}
	}
	dc.SetColor(nColorOld);
	return Acad::eOk;
}

const TCHAR *AecDbDimension::GetDefaultLayer() const
{
	extern TCHAR* LAY_DIM;
	return LAY_DIM;
}

DrawModeType AecDbDimension::GetDrawType() const
{
	return k2DOnly;
}

/* * * * * * * * * * 取 动 态 属 性 显 示 数 据 的 函 数 * * * * * * * * * */
void AecDbDimension::GetTips(PtrList<ObjInfoUnit> &lstInfo) const
{
	lstInfo.Append(new ObjInfoUnit(_T("对象类型"), _T("连续标注")));
	const TCHAR *pSubType;
	if (!IsAngular()) pSubType = _T("线性标注");
	else if (IsDimChord()) pSubType = _T("弦长标注");
	else if (IsDimArcLen()) pSubType = _T("弧长标注");
	else pSubType = _T("角度标注");
	lstInfo.Append(new ObjInfoUnit(_T("子类型"), pSubType));
	lstInfo.Append(new ObjInfoUnit(_T("标注样式"), GlobalFunc::GetSymbolName(m_idDimStyle)));
	TCString sDist;
	GlobalFunc::ftoa(fabs(m_nDist2DimLine), 1, sDist);
	sDist << _T("P");
	lstInfo.Append(new ObjInfoUnit(_T("尺寸线偏移"), sDist));
	if (!IsAngular()) {
		lstInfo.Append(new ObjInfoUnit(_T("旋转角度"), GlobalFunc::Angle2Str(m_nRotation * 180 / PI)));
	}
	else if (IsDimChord() || IsDimArcLen()) {
		lstInfo.Append(new ObjInfoUnit(_T("所注半径"), GlobalFunc::Dist2Str(m_nObjRadius)));
	}
}

//尺寸文字位置的自动调整
// 返回最后一个的调整结果
// 0--缺省, 1--上调, 2--下调, 3--侧调
// nFromUp--开始调整的状态,bAllowExt--是否允许外调,bAutoReset--无需调整的是否自动复位
int AecDbDimension::AdjustDim(BOOL bFromUp, BOOL bAllowExt, BOOL bAutoReset)
{
	AssertWriteEnabled();
	if (!IsValid())
		return 0;

	double nPScale = GetPScale();

	double dimgap = 0,
		dimtxt = 0,
		dimexe = 0,
		dimexo = 0;
	double dimscale = 1.0,
		dimasz = 1.0;
	int dimdec = 0, dimadec = 0, nDimTextMovePos;
	double dimlfac = 1.0;
	double nArrowThick = 6.0 * nPScale;

	AcDbObjectId dimblk;
	AcDbObjectId dimtxsty;
	OPENOBJ_BEGIN(m_idDimStyle, AcDb::kForRead, AcDbDimStyleTableRecord, pDimStyle);
	if (!pDimStyle)
		return 0;

	dimlfac = pDimStyle->dimlfac();		// 比例因子
	dimdec = pDimStyle->dimdec();		// 线型标注显示的小数位数（精度）
	dimadec = pDimStyle->dimadec();		// 角度标注显示的小数位数（精度）
	dimgap = pDimStyle->dimgap();		// 从尺寸线偏移
	dimtxt = pDimStyle->dimtxt();		// 指定标注文字的高
	dimblk = pDimStyle->dimblk();		// 箭头块名称
	//dimscale = pDimStyle->dimscale();
	dimscale = nPScale;					// 全局比例因子
	dimasz = pDimStyle->dimasz();		// 箭头大小
	dimtxsty = pDimStyle->dimtxsty();	// 文字样式
	dimexe = pDimStyle->dimexe();		// 尺寸界线上超尺寸线的距离
	dimexo = pDimStyle->dimexo();		// 尺寸界线偏离原点的距离

	// wlw add 20120913，增加对“标注文字从默认位置（由标注样式定义的位置）移动时标注文字的位置”设置的支持,引线
	nDimTextMovePos = pDimStyle->dimtmove();
	OPENOBJ_END();

	if (!dimtxsty)
		return 0;

	int nRetCode = 0;
	if (bAutoReset)
		m_lstTextPos.Reset();

	GeCurveSegment cv = GetDimCurve();
	GePoly2D poly;
	GetPolySegOnDimLine(poly);

	if (IsAngular() && IsDimChord()) //弦长标注
	{
		int numSeg = poly.TotalSegments();
		int nCode = 0;
		for (int i = 0; i < numSeg; i++)
		{
			if (!bAutoReset && m_lstTextPos.FindNode(&i, DimTextPos::CompareByIndexForFind))
				continue;

			GeCurveSegment segDim, segFix, segObj;
			poly.Nth(i, segDim);
			segFix = segDim.Offset(OFFSET_LEFT, -GetDist2DimLine(FALSE), LS_FINITE);
			double nOffDist = segDim.GetArc().GetRadius() - m_nObjRadius;
			segObj = segDim.Offset(OFFSET_LEFT, nOffDist, LS_FINITE);
			double nRot = segObj.GeLine::Direction();
			ADSGePoint3d ptFix;
			double nObj2Fix = segFix.GetArc().GetRadius() - segObj.GetArc().GetRadius();
			ads_polar(segObj.StartPoint(), nRot - PI / 2, nObj2Fix, ptFix);
			AecDbDimension objDim;
			objDim.setPropertiesFrom(this);
			objDim.SetLocation(ptFix);
			objDim.SetRotation(nRot);
			objDim.SetDist2DimLine(GetDist2DimLine());
			objDim.AppendSegment(segObj.GetArc().ChordLength());
			objDim.SetStyleId(GetStyleId());
			DimTextContent *pNode = ((AecDbDimension *)this)->m_lstTextContent.FindNode(&i, DimTextContent::CompareByIndexForFind);
			if (pNode) objDim.SetTextContent(0, pNode->sText);

			BOOL bUpAdj = bFromUp;
			if (!nCode)
				nCode = objDim.AdjustDim(bUpAdj, (i == 0 || i == numSeg));
			BOOL bDef = TRUE;
			ADSGePoint3d ptTextPos = objDim.GetTextPos(0, &bDef);
			if (!bDef)
				SetTextPos(i, ptTextPos);
		}
	}
	else // 直线标注或角度标注
	{
		double dTextHeight = dimtxt * dimscale, // 文字字高
			dTextRot(0.0);

		XDimAutoAdjust dimAdjust;
		dimAdjust.SetDimParam(cv, dimtxsty, dTextHeight, m_nLayoutRotation);
		//wlw add 120912设置文字间隙
		dimAdjust.SetDispSnap(0.6);

		int nSegNums = poly.TotalSegments(),
			nCur(0);
		for (nCur = 0; nCur < nSegNums; nCur++)
		{
			ADSGePoint3d ptText = GetDefaultTextPos(nCur);		// 文字默认位置点
			TCString sDefaultText = GetDefaultText(nCur),	// 文字默认内容
				sText = GetText(nCur);						// 文字实际注写的内容
			dimAdjust.AppendDim(sDefaultText, sText, ptText);
		}

		dimAdjust.AutoAdjust(bFromUp, bAllowExt);	// 处理自动调整的情况

		ADSGePoint3d ptTextPos;
		ADSGePointDir2d ptVertDir;
		for (nCur = 0; nCur < nSegNums; nCur++)
		{
			if (!bAutoReset && m_lstTextPos.FindNode(&nCur, DimTextPos::CompareByIndexForFind)) // 不允许尺寸自调
				continue;

			int nLoc = dimAdjust.GetYLoc(nCur);
			if (nLoc == 1)
				continue;

			if (nLoc == 0) // 外偏
			{
				cv.Polar(-(dimAdjust.GetXDist(nCur) / 2 + dimgap * nPScale), ptVertDir, nCur == 0);
				dTextRot = ChangeToNormalViewAngle(ptVertDir.nDirection) + PI / 2;
				ads_polar(ptVertDir, dTextRot, (dimgap + dimtxt * 0.5) * nPScale, ptTextPos);
				SetTextPos(nCur, ptTextPos);
				continue;
			}

			GeCurveSegment seg;
			poly.Nth(nCur, seg);

			seg.Polar(seg.GetLength() / 2, ptVertDir);
			dTextRot = ChangeToNormalViewAngle(ptVertDir.nDirection);

			double dDimLen = dimgap + dimtxt / 2 + (dimtxt + dimgap / 2) * (abs(nLoc) - 1);
			if (nDimTextMovePos == 1)
			{//带引线//wlw mod 12.09.15
				dDimLen = dimgap + dimexe + dimtxt / 2;
			}
			if (nLoc > 1)	// 尺寸线方向上调 wlw add 120918向下调一点，避开上面的尺寸线(dDimLen - 0.5)
			{
				ads_polar(ptVertDir, dTextRot + PI / 2, (dDimLen - 0.5) * nPScale, ptTextPos);
			}
			else
			{// 尺寸线方向下调
				ads_polar(ptVertDir, dTextRot - PI / 2, dDimLen * nPScale, ptTextPos);
			}

			SetTextPos(nCur, ptTextPos);
		}
	}
	return nRetCode;
}

//取得尺寸线
GeCurveSegment
AecDbDimension::GetDimCurve() const
{
	assertReadEnabled();
	//ASSERT(IsValid());
	ADSGePoint3d ptStart, ptEnd;
	double nDist = m_nDist2DimLine * GetPScale();
	ads_polar(m_ptLocation, m_nRotation + PI / 2, nDist, ptStart);
	double nSweepAngle = 0.0;
	if (IsAngular()) {
		ADSGePoint3d ptCen;
		ads_polar(ptStart, m_nRotation + PI / 2, m_nDimRadius, ptCen);
		nSweepAngle = GetTotalSegValue();
		if (fabs(nSweepAngle - 2.0 * PI) < g_DimOption::instance()._angSnap)
			nSweepAngle -= 2.0 * g_DimOption::instance()._angSnap;

		//add by whl on 060110
		if (fabs(nSweepAngle) < 1E-6)
			nSweepAngle = PI;

		double nEndAng = ads_angle(ptCen, ptStart) + nSweepAngle;
		ads_polar(ptCen, nEndAng, m_nDimRadius, ptEnd);
	}
	else {
		double nTotalDist = GetTotalSegValue();

		//add by whl on 060110
		if (fabs(nTotalDist) < 1E-6)
			nTotalDist = 1;

		ads_polar(ptStart, m_nRotation, nTotalDist, ptEnd);
	}
	return GeCurveSegment(ptStart, ptEnd, nSweepAngle);
}

void AecDbDimension::GetPolySegOnDimLine(GePoly2D &poly) const
{
	assertReadEnabled();

	GeCurveSegment cv = GetDimCurve();
	SortedVertexList lstVert(cv);
	int nSeg = m_lstSegment.Length();
	double nDist = 0.0;
	for (int i = 0; i < nSeg - 1; i++) {
		ADSGePointDir2d ptVert;
		double nVal = GetSegment(i);
		nDist += nVal;
		cv.Polar(nDist, ptVert);
		lstVert.Insert(ptVert);
	}

	lstVert.AsPoly2D(poly);
}
AcDbCurve* AecDbDimension::GetBaseCurve()const
{
	assertReadEnabled();
	GePoly2D poly;
	GetPolySegOnDimLine(poly);
	return poly.AsAcDbCurve();
}
Acad::ErrorStatus AecDbDimension::SetBaseCurve(AcDbCurve*pCurve)
{
	AssertWriteEnabled();

	GePoly2D poly;
	if (poly.SetAcDbCurve(pCurve) && poly.Length() > 1)
	{
		ADSGePoint3d ptFirst = *poly.Head(), ptLast = *poly.Tail();
		GeCurveSegment cvOld = GetDimCurve();
		GePoly2D polyOld;
		GetPolySegOnDimLine(polyOld);
		bool bChangeFirst = ptFirst != cvOld.StartPoint();
		bool bChangeLast = ptLast != cvOld.EndPoint();
		if (bChangeFirst && bChangeLast)//首尾都变
		{
			m_lstSegment.Reset();
			for (long i = 1; i < poly.Length(); i++)
				m_lstSegment.Append(new double(poly[i]->Distance2d(*poly[i - 1])));

			GeCurveSegment cv;
			poly.Nth(0, cv);
			cv = cv.Offset(m_nDist2DimLine * GetPScale(), 1);
			m_ptLocation = cv.StartPoint();

			m_lstTextPos.Reset();
			m_lstTextContent.Reset();
		}
		else if (bChangeFirst)//首变
		{
			FindAndRemoveSegment(cvOld.StartPoint());
			double dist = cvOld.PathDistance(ptFirst, FALSE);
			for (long i = 1; i < polyOld.Length(); i++)
			{
				if ((cvOld.PathDistance(*polyOld[i], FALSE) - dist) > g_Option::instance()._DIST_SNAP)//在新起点之前
					FindAndRemoveSegment(*polyOld[i]);
				else
					break;
			}
			AddSegment(ptFirst);
		}
		else if (bChangeLast)//尾变
		{
			FindAndRemoveSegment(cvOld.EndPoint());
			double dist = cvOld.PathDistance(ptLast, TRUE);
			for (long i = polyOld.Length() - 2; i >= 0; i--)
			{
				if ((cvOld.PathDistance(*polyOld[i], TRUE) - dist) > g_Option::instance()._DIST_SNAP)//在新终点之后
					FindAndRemoveSegment(*polyOld[i]);
				else
					break;
			}
			AddSegment(ptLast);
		}

		return Acad::eOk;
	}
	else
		return Acad::eInvalidInput;
}
int AecDbDimension::HitTestOnDimSeg(ADSGePoint3d pt) const
{
	GeCurveSegment cv = GetDimCurve();
	ADSGePoint3d ptOnDim;
	if (cv.ProjectToMe(pt, ptOnDim) != RTNORM)
		return -1;
	GePoly2D poly;
	GetPolySegOnDimLine(poly);
	int nSeg = poly.TotalSegments();
	for (int i = 0; i < nSeg; i++) {
		GeCurveSegment seg;
		poly.Nth(i, seg);
		if ((ptOnDim & seg) == PR_INSIDE)
			return i;
	}
	return -1;
}

int AecDbDimension::HitTestOnText(ADSGePoint3d pt) const
{
	int nSeg = m_lstSegment.Length();
	int nRet = -1;
	double nDistMin = 0.0;
	for (int i = 0; i < nSeg; i++) {
		ADSGePoint3d ptPos = GetTextPos(i);
		if (nRet < 0) {
			nRet = i;
			nDistMin = ptPos.Distance2d(pt);
		}
		else {
			double nDist = ptPos.Distance2d(pt);;
			if (nDist < nDistMin) {
				nDistMin = nDist;
				nRet = i;
			}
		}
	}
	return nRet;
}
//add by whl　on 041020
//返回节点索引，输入为近似节点，输出为准确节点，以系统拾取框大小为距离精度。
int AecDbDimension::HitTestOnPoint(ADSGePoint3d&pt)const
{
	GeCurveSegment cv = GetDimCurve();
	ADSGePoint3d ptOnDim;
	if (cv.ProjectToMe(pt, ptOnDim) != RTNORM)
		return -1;
	double nMaxDist = GlobalFunc::GetApertureWcs() / 2;
	GePoly2D poly;
	GetPolySegOnDimLine(poly);
	for (long i = 0; i < poly.Length(); i++)
		if (ptOnDim.Distance2d(*poly[i]) <= nMaxDist)
		{
			pt = *poly[i];
			return i;
		}
	return -1;
}

// 角度－弦长－弧长
void AecDbDimension::SwitchDimChord()
{
	if (!IsAngular())
		return;
	BOOL bChord = IsDimChord();
	BOOL bArcLen = IsDimArcLen();
	if (!bChord && !bArcLen) { //角度
		GeCurveSegment cv = GetDimCurve();
		GeArc arDim = cv.GetArc();
		double nObjRadius = GetObjRadius();
		if (arDim.GetRadius() < nObjRadius) { //自动反向
			double nDiff = nObjRadius - arDim.GetRadius();
			arDim.SetRadius(arDim.GetRadius() + 2 * nDiff);
			SetDimRadius(arDim.GetRadius());
			cv = arDim;
			arDim.SetRadius(nObjRadius);

			GeCurveSegment segObj;
			segObj = arDim;
			ADSGePoint3d ptNewLoc;
			segObj.StartPoint().Mirror(GetLocation(), ptNewLoc);
			double nDist = ptNewLoc.Distance2d(cv.StartPoint());
			int nSide = cv.OnWhichSide(ptNewLoc);
			if (nSide == OFFSET_LEFT)
				nDist = -nDist;
			SetDist2DimLine(nDist, FALSE);
			SetLocation(ptNewLoc);
			for (int i = 0; i < m_lstTextPos.Length(); i++) {
				DimTextPos *pText = m_lstTextPos[i];
				ADSGePoint3d ptOnObj;
				segObj.ProjectToMe(pText->ptPos, ptOnObj);
				ptOnObj.Mirror(ADSGePoint3d(pText->ptPos), pText->ptPos);
			}
		}
		SetStyleId(InitDimStyle(DS_LINEAR));
		SetDimChord(TRUE);
		SetDimArcLen(FALSE);
	}
	else if (bChord) {
		SetStyleId(InitDimStyle(DS_ANGLE));
		SetDimChord(FALSE);
		SetDimArcLen(TRUE);
	}
	else {
		SetStyleId(InitDimStyle(DS_ANGLE));
		SetDimChord(FALSE);
		SetDimArcLen(FALSE);
	}


}

void AecDbDimension::RemoveZeroSegment()
{
	AssertWriteEnabled();
	int nSeg = m_lstSegment.Length();
	double nPrec = IsAngular() ? g_DimOption::instance()._angSnap : g_Option::instance()._DIST_SNAP;
	for (int i = 0; i < nSeg; i++) {
		if (*m_lstSegment[i] < nPrec) {
			RemoveSegment(i);
			i--;
			nSeg--;
		}
	}
}

void AecDbDimension::RemoveSegment(int iSeg)
{
	AssertWriteEnabled();
	int nSeg = m_lstSegment.Length();
	ASSERT(iSeg >= 0 && iSeg < nSeg);
	m_lstSegment.Remove(iSeg);

	if (m_lstTextPos.FindNode(&iSeg, DimTextPos::CompareByIndexForFind))
		m_lstTextPos.Remove();
	int nTextSeg = m_lstTextPos.Length();
	for (int i = 0; i < nTextSeg; i++) {
		DimTextPos *pNode = m_lstTextPos[i];
		if (pNode->nIndex > iSeg)
			pNode->nIndex--;
	}

	if (m_lstTextContent.FindNode(&iSeg, DimTextContent::CompareByIndexForFind))
		m_lstTextContent.Remove();
	nTextSeg = m_lstTextContent.Length();
	for (i = 0; i < nTextSeg; i++) {
		DimTextContent *pNode = m_lstTextContent[i];
		if (pNode->nIndex > iSeg)
			pNode->nIndex--;
	}

	AutoSetFlag();
}

void
AecDbDimension::InsertSegmentAt(int n, double nVal, BOOL bDist)
{
	AssertWriteEnabled();
	ASSERT(IsValidSegment(nVal, bDist));
	if (n >= 0 && n < m_lstSegment.Length()) {
		if (IsAngular() && bDist)
			nVal = nVal / m_nDimRadius;
		m_lstSegment[n];
		m_lstSegment.Insert(new double(nVal));
		int nTextSeg = m_lstTextPos.Length();
		for (int i = 0; i < nTextSeg; i++) {
			DimTextPos *pNode = m_lstTextPos[i];
			if (pNode->nIndex >= n)
				pNode->nIndex++;
		}

		nTextSeg = m_lstTextContent.Length();
		for (i = 0; i < nTextSeg; i++) {
			DimTextContent *pNode = m_lstTextContent[i];
			if (pNode->nIndex >= n)
				pNode->nIndex++;
		}

	}
	else if (n >= m_lstSegment.Length()) {
		AppendSegment(nVal, bDist);
	}

	AutoSetFlag();
}

void
AecDbDimension::SetSegment(int n, double nVal, BOOL bDist)
{
	AssertWriteEnabled();
	ASSERT(IsValidSegment(nVal, bDist));
	if (n >= 0 && n < m_lstSegment.Length()) {
		if (IsAngular() && bDist)
			nVal = nVal / m_nDimRadius;
		*m_lstSegment[n] = nVal;
	}
}


// 在指定的位置加入一区间
BOOL AecDbDimension::AddSegment(ADSGePoint3d ptAdd)
{
	AssertWriteEnabled();
	GeCurveSegment cv = GetDimCurve();
	ADSGePoint3d ptOnDim;
	if (cv.ProjectToMe(ptAdd, ptOnDim) != RTNORM)
		return FALSE;
	int nPrFlag = (ptOnDim & cv);
	if (nPrFlag == PR_ONPT1 && nPrFlag == PR_ONPT2)
		return FALSE;

	BOOL bRet = FALSE;
	if (nPrFlag == PR_INSIDE) {
		if (GetSegmentNum() > 0)
		{
			GePoly2D poly;
			GetPolySegOnDimLine(poly);
			int nSeg = poly.TotalSegments();
			for (int n = 0; n < nSeg; n++) {
				GeCurveSegment seg;
				poly.Nth(n, seg);
				if ((ptOnDim & seg) == PR_INSIDE) {
					double nVal = fabs(seg.PathDistance(ptOnDim));
					double nVal1 = fabs(seg.PathDistance(ptOnDim, FALSE)); //距离终点的距离
					if (IsValidSegment(nVal) && IsValidSegment(nVal1)) {
						DimTextPos *pNode = m_lstTextPos.FindNode(&n, DimTextPos::CompareByIndexForFind);
						if (pNode) m_lstTextPos.Remove();
						SetSegment(n, nVal1);
						InsertSegmentAt(n, nVal);
						bRet = TRUE;
					}
					break;
				}
			}
		}
		else
		{
			double nVal = fabs(cv.PathDistance(ptOnDim, TRUE));
			if (IsValidSegment(nVal)) {
				AppendSegment(nVal);
				bRet = TRUE;
			}
		}
	}
	else if (ptOnDim.Distance2d(cv.EndPoint()) < ptOnDim.Distance2d(cv.StartPoint())) {
		if (GetSegmentNum() > 0)
		{
			double nVal = fabs(cv.PathDistance(ptOnDim, FALSE));
			if (IsValidSegment(nVal)) {
				AppendSegment(nVal);
				bRet = TRUE;
			}
		}
		else
		{
			double nVal = fabs(cv.PathDistance(ptOnDim, TRUE));
			if (IsValidSegment(nVal)) {
				AppendSegment(nVal);
				bRet = TRUE;
			}
		}
	}
	else {
		double nVal = fabs(cv.PathDistance(ptOnDim, TRUE));
		if (IsValidSegment(nVal)) {
			cv.SetPoints(ptOnDim, ADSGePoint3d(cv.EndPoint()));
			InsertSegmentAt(0, nVal);
			m_nRotation = cv.IDirection(0);
			ads_polar(cv.StartPoint(), m_nRotation - PI / 2, m_nDist2DimLine * GetPScale(), m_ptLocation);
			bRet = TRUE;
		}
	}

	if (bRet)
		AutoSetFlag();
	return bRet;
}
//add by whl on 040810
BOOL AecDbDimension::FindAndRemoveSegment(ADSGePoint3d pt)
{
	if (GetSegmentNum() < 1)
		return FALSE;

	GeCurveSegment seg = GetDimCurve();
	ADSGePoint3d ptOnSeg;
	seg.ProjectToMe(pt, ptOnSeg);
	double value = seg.PathDistance(ptOnSeg);
	long i = -1;
	if (value > g_Option::instance()._DIST_SNAP)
	{
		double curValue = 0;
		for (i = 0; i < GetSegmentNum(); i++)
		{
			curValue += GetSegment(i);
			if (fabs(curValue - value) < g_Option::instance()._DIST_SNAP)
				break;
		}
	}
	if (i >= GetSegmentNum())
		return FALSE;//useful

	if (i >= 0)
	{
		double temp = GetSegment(i);
		if (i < GetSegmentNum() - 1)//是中间段
			SetSegment(i + 1, temp + GetSegment(i + 1));//后一段合并之
		RemoveSegment(i);
	}
	else//第一个标注段的起点特殊处理,弧段不对!
	{
		double temp = GetSegment(0);
		RemoveSegment(0);
		Vector3D vt = seg.EndPoint() - seg.StartPoint();
		vt.Scale(temp / vt.Length());
		SetLocation(GetLocation() + vt);
	}
	return TRUE;
}
BOOL AecDbDimension::FindPoint(ADSGePoint3d pt)const
{
	GeCurveSegment cv = GetDimCurve();
	ADSGePoint3d ptOnDim;
	if (cv.ProjectToMe(pt, ptOnDim) != RTNORM)
		return FALSE;

	double nMaxDist = 1E-3;
	GePoly2D poly;
	GetPolySegOnDimLine(poly);
	for (long i = 0; i < poly.Length(); i++)
	{
		double nDist = ptOnDim.Distance2d(*poly[i]);
		if (nDist <= nMaxDist)
			return TRUE;
	}

	return FALSE;
}
double AecDbDimension::GetMaxScope()const
{
	if (m_lstOffset.Length() > 0)
		return m_lstOffset[0];
	else
		return 20;
}
BOOL AecDbDimension::UpdateFrom(ADSGePoint3d ptNew0, ADSGePoint3d ptNew1, ADSGePoint3d ptOld0, ADSGePoint3d ptOld1, bool bErased)
{
	ptNew0.z = 0;
	ptNew1.z = 0;
	ptOld0.z = 0;
	ptOld1.z = 0;
	AcGeVector2d vtDim(cos(m_nRotation), sin(m_nRotation));
	AcGeVector2d vtNew(ptNew1.x - ptNew0.x, ptNew1.y - ptNew0.y);
	AcGeVector2d vtOld(ptOld1.x - ptOld0.x, ptOld1.y - ptOld0.y);
	vtNew.normalize();
	vtOld.normalize();

	if (vtNew.isZeroLength() || vtOld.isZeroLength())
		return FALSE;
	if (!vtOld.isParallelTo(vtDim) || !vtNew.isParallelTo(vtDim))
		return FALSE;

	if (!FindPoint(ptOld0) || !FindPoint(ptOld1))
		return FALSE;

	GeCurveSegment curve1 = GetDimCurve();
	GeCurveSegment curve2;
	if (m_nDist2DimLine > 0)
		curve2 = curve1.Offset((m_nDist2DimLine + GetMaxScope()) * GetPScale(), 0);
	else
		curve2 = curve1.Offset((m_nDist2DimLine - GetMaxScope()) * GetPScale(), 0);
	GePoly2D poly(1);
	poly.AppendNode(curve1.StartPoint());
	poly.AppendNode(curve1.EndPoint());
	poly.AppendNode(curve2.EndPoint());
	poly.AppendNode(curve2.StartPoint());
	if ((ptOld0 & poly) == PR_OUTSIDE ||
		(ptOld1 & poly) == PR_OUTSIDE)
		return FALSE;

	if (upgradeOpen() != Acad::eOk)
		return FALSE;

	if (bErased)
	{
		FindAndRemoveSegment(ptOld0);
		FindAndRemoveSegment(ptOld1);
	}
	else
	{
		long oldSegNum = GetSegmentNum();

		if (ptOld0 != ptNew0 && ptOld0 != ptNew1)
			FindAndRemoveSegment(ptOld0);

		if (ptOld1 != ptNew0 && ptOld1 != ptNew1)
			FindAndRemoveSegment(ptOld1);

		if (GetSegmentNum() < oldSegNum)
		{
			if (GetSegmentNum() > 0)
			{
				AddSegment(ptNew0);
				AddSegment(ptNew1);
			}
			else
			{
				ADSGePoint3d ptLocation0 = m_ptLocation;
				AddSegment(ptNew0);
				AddSegment(ptNew1);
				if (GetSegmentNum() > oldSegNum)
					FindAndRemoveSegment(ptLocation0);
			}
		}
	}
	return TRUE;
}
BOOL AecDbDimension::MergeDim(const AecDbDimension *pDim)
{
	AssertWriteEnabled();
	if (!IsUseDefaultText())
		return FALSE;

	GeCurveSegment cv = GetDimCurve();
	SortedVertexList lstVert(cv);
	int nSeg = m_lstSegment.Length();
	double nDist = 0.0;
	for (int i = 0; i < nSeg - 1; i++) {
		ADSGePointDir2d ptVert;
		double nVal = GetSegment(i);
		nDist += nVal;
		cv.Polar(nDist, ptVert);
		lstVert.Insert(ptVert);
	}

	GePoly2D poly;
	pDim->GetPolySegOnDimLine(poly);
	for (i = 0; i < poly.Length(); i++) {
		ADSGePoint3d ptVert;
		if (cv.ProjectToMe(*poly[i], ptVert) == RTNORM)
			lstVert.Insert(ptVert, TRUE);
	}

	m_lstTextPos.Reset();
	m_lstSegment.Reset();
	GePoly2D polyNew;
	lstVert.AsPoly2D(polyNew);
	nSeg = polyNew.TotalSegments();
	for (i = 0; i < nSeg; i++) {
		GeCurveSegment seg;
		polyNew.Nth(i, seg);
		double nVal = seg.GetLength();
		ASSERT(nVal > g_Option::instance()._DIST_SNAP);
		if (IsValidSegment(nVal))
			AppendSegment(nVal);
		if (i == 0) {
			m_nRotation = seg.IDirection(0);
			ads_polar(seg.StartPoint(), m_nRotation - PI / 2, m_nDist2DimLine * GetPScale(), m_ptLocation);
		}
	}
	AutoSetFlag();
	return TRUE;
}


BOOL AecDbDimension::ConvertFrom(const AcDbDimension *pDim)
{
	AssertWriteEnabled();

	double nScale = 100.0;
	AcDbObjectId idStyle = GlobalFunc::DimStyleAcad2Tch(pDim->dimensionStyle(), nScale);
	SetPScale(nScale);
	//double val;
	//VERIFY(pDim->measurement(val)==Acad::eOk);
	TCString sText;
	sText = pDim->dimensionText();
	double dotVec = pDim->normal().dotProduct(AcGeVector3d(0, 0, 1));
	if (fabs(dotVec - 1.0) > 1.0E-6 || !idStyle)
		return FALSE;

	setPropertiesFrom(pDim);
	m_idDimStyle = idStyle;
	m_lstTextPos.Reset();
	if (!pDim->isUsingDefaultTextPosition()) {
		m_lstTextPos.Append(new DimTextPos(0, ADSGePoint3d(pDim->textPosition())));
	}
	m_lstTextContent.Reset();
	if (!!sText)
		m_lstTextContent.Append(new DimTextContent(0, sText));


	BOOL bRet = FALSE;
	if (pDim->isKindOf(AcDb2LineAngularDimension::desc()) ||
		pDim->isKindOf(AcDb3PointAngularDimension::desc())) {
		AcDb3PointAngularDimension *pDim1 = AcDb3PointAngularDimension::cast(pDim);
		AcDb2LineAngularDimension *pDim2 = AcDb2LineAngularDimension::cast(pDim);
		ADSGePoint3d pt1, pt2, ptDim, ptCen;
		if (pDim1) {
			pt1 = pDim1->xLine1Point();
			pt2 = pDim1->xLine2Point();
			ptDim = pDim1->arcPoint();
			ptCen = pDim1->centerPoint();
		}
		else {
			pt1 = pDim2->xLine1Start();
			pt2 = pDim2->xLine2Start();
			ptDim = pDim2->arcPoint();
			ADSGePoint3d qt1 = pDim2->xLine1End(),
				qt2 = pDim2->xLine2End();
			GeLine _l(pt2, qt2);
			GeLine(pt1, qt1).Intersection(&_l, ptCen);
		}
		m_nDimRadius = ptCen.Distance2d(ptDim);
		SetAngular(TRUE);
		SetDimChord(FALSE);
		m_ptLocation = pt1;
		m_ptLocation.z = 0;
		m_nRotation = ads_angle(ptCen, pt1) + PI / 2;
		GeArc arDim(ptCen, m_nDimRadius, ads_angle(ptCen, pt1), ads_angle(ptCen, pt2));
		GeCurveSegment segDim;
		segDim = arDim;
		//ADSGePoint3d ptOnDim1;
		//pt1.Project(arDim, ptOnDim1);
		double nDist2DimLine = fabs(m_nDimRadius - ptCen.Distance2d(pt1));
		int nSide = segDim.OnWhichSide(m_ptLocation);
		if (nSide == OFFSET_LEFT)
			nDist2DimLine = -nDist2DimLine;
		m_nObjRadius = m_nDimRadius + nDist2DimLine;
		SetDist2DimLine(nDist2DimLine, FALSE);
		m_lstSegment.Reset();
		if (IsValidSegment(arDim.Bulge(), FALSE)) {
			AppendSegment(arDim.Bulge(), FALSE);
			bRet = TRUE;
		}
	}
	else if (pDim->isKindOf(AcDbAlignedDimension::desc()) ||
		pDim->isKindOf(AcDbRotatedDimension::desc())) {
		AcDbAlignedDimension *pDim1 = AcDbAlignedDimension::cast(pDim);
		AcDbRotatedDimension *pDim2 = AcDbRotatedDimension::cast(pDim);
		ASSERT(pDim1 || pDim2);
		ADSGePoint3d pt1, pt2, ptDim;
		if (pDim1) {
			pt1 = pDim1->xLine1Point();
			pt2 = pDim1->xLine2Point();
			ptDim = pDim1->dimLinePoint();
		}
		else {
			pt1 = pDim2->xLine1Point();
			pt2 = pDim2->xLine2Point();
			ptDim = pDim2->dimLinePoint();
			if (!IsSameDrt(ads_angle(pt1, pt2), pDim2->rotation(), g_DimOption::instance()._angSnap))
				return FALSE;
		}
		m_nDimRadius = m_nObjRadius = 0;
		SetAngular(FALSE);
		SetDimChord(FALSE);
		m_ptLocation = pt1;
		m_ptLocation.z = 0;
		m_nRotation = ads_angle(pt1, pt2);
		ADSGePoint3d ptOnDim1, ptOnDim2;
		GeLine ll(ptDim, m_nRotation);
		pt1.Project(&ll, ptOnDim1);
		pt2.Project(&ll, ptOnDim2);
		int nSide = GeLine(ptDim, m_nRotation).OnWhichSide(m_ptLocation);
		m_nDist2DimLine = pt1.Distance2d(ptOnDim1) / GetPScale();
		if (nSide == OFFSET_LEFT)
			m_nDist2DimLine = -m_nDist2DimLine;
		m_lstSegment.Reset();
		double nVal = ptOnDim1.Distance2d(ptOnDim2);
		if (IsValidSegment(nVal)) {
			AppendSegment(nVal);
			bRet = TRUE;
		}
	}
	if (bRet)
		AutoSetFlag();
	return bRet;
}

BOOL AecDbDimension::ConvertFrom(const AecXDbDimension_Old *pDim)
{
	AssertWriteEnabled();
	AecDbDimension::CopyPropertiesFrom((AcDbEntity*)pDim, 0xFFFFFFFF);
	m_ptLocation = pDim->m_ptLocation;
	m_nRotation = pDim->m_nRotation;
	m_nDist2DimLine = pDim->m_nDist2DimLine;
	m_nDimRadius = pDim->m_nDimRadius;
	m_nObjRadius = pDim->m_nObjRadius;
	m_idDimStyle = pDim->m_idDimStyle;
	m_lstSegment.Reset();
	for (long i = 0; i < pDim->m_lstSegment.Length(); i++)
		m_lstSegment.Append(new double(pDim->m_lstSegment[i]));

	m_lstTextPos.Reset();
	for (i = 0; i < pDim->m_lstTextPos.Length(); i++)
	{
		DimTextPos *pNew = new DimTextPos;
		pNew->nIndex = pDim->m_lstTextPos[i].nIndex;
		pNew->ptPos = pDim->m_lstTextPos[i].ptPos;
		m_lstTextPos.Append(pNew);
	}

	m_nDimFlag = pDim->m_nDimFlag;

	m_lstTextContent.Reset();
	for (i = 0; i < pDim->m_lstTextContent.Length(); i++)
	{
		DimTextContent *pNew = new DimTextContent;
		pNew->nIndex = pDim->m_lstTextContent[i].nIndex;
		pNew->sText = pDim->m_lstTextContent[i].sText;
		m_lstTextContent.Append(pNew);
	}
	return TRUE;
}
//Acad::ErrorStatus AecDbDimension::DownGradeSave(int nDrawMode, AcDbVoidPtrArray &entSet, BOOL *bErase)
//{
//	Acad::ErrorStatus es = Acad::eOk;
//	if (g_nSaveTArchVer >= GetFirstVersion())
//	{
//		if (bErase)
//			*bErase = FALSE;
//	}
//	else if (IsValid())
//	{
//		AecXDbDimension_Old* pDim = new AecXDbDimension_Old;
//		pDim->CopyPropertiesFrom(this, 0xFFFFFFFF);
//
//		pDim->m_ptLocation = m_ptLocation;
//		pDim->m_nRotation = m_nRotation;
//		pDim->m_nDist2DimLine = m_nDist2DimLine;
//		pDim->m_nDimRadius = m_nDimRadius;
//		pDim->m_nObjRadius = m_nObjRadius;
//		pDim->m_idDimStyle = m_idDimStyle;
//
//		pDim->m_lstSegment.Reset();
//		for (long i = 0; i < m_lstSegment.Length(); i++)
//			pDim->m_lstSegment.Append(new double(*m_lstSegment[i]));
//
//		pDim->m_lstTextPos.Reset();
//		for (i = 0; i < m_lstTextPos.Length(); i++)
//		{
//			DimTextPos *pNew = new DimTextPos;
//			pNew->nIndex = m_lstTextPos[i]->nIndex;
//			pNew->ptPos = m_lstTextPos[i]->ptPos;
//			pDim->m_lstTextPos.Append(pNew);
//		}
//
//		pDim->m_nDimFlag = m_nDimFlag;
//
//		pDim->m_lstTextContent.Reset();
//		for (i = 0; i < m_lstTextContent.Length(); i++)
//		{
//			DimTextContent *pNew = new DimTextContent;
//			pNew->nIndex = m_lstTextContent[i]->nIndex;
//			pNew->sText = m_lstTextContent[i]->sText;
//			pDim->m_lstTextContent.Append(pNew);
//		}
//
//		entSet.append(pDim);
//		if (bErase)
//			*bErase = TRUE;
//	}
//	return es;
//}

// Properties

double AecDbDimension::GetSegment(int n, BOOL bDist) const
{
	ASSERT(n >= 0 && n < m_lstSegment.Length());
	double nVal = m_lstSegment[n];
	if (IsAngular() && bDist) {
		ASSERT(m_nDimRadius > g_Option::instance()._DIST_SNAP);
		nVal *= m_nDimRadius;
	}
	return nVal;
}

double
AecDbDimension::GetTotalSegValue() const
{
	double nVal = 0.0;
	int nCount = m_lstSegment.Length();
	for (int i = 0; i < nCount; i++)
		nVal += m_lstSegment[i];
	return nVal;
}

BOOL
AecDbDimension::IsAngular() const
{
	return ((m_nDimFlag & DF_ANGULAR) != 0);
	//return (m_nDimRadius>g_DimOption::instance()._angSnap);
}
BOOL
AecDbDimension::IsAssociate() const
{
	return ((m_nDimFlag & DF_ASSOCIATE) != 0);
}
void
AecDbDimension::SetAssociate(BOOL bTrue)
{
	AssertWriteEnabled();
	if (bTrue)
		m_nDimFlag |= DF_ASSOCIATE;
	else
		m_nDimFlag &= ~DF_ASSOCIATE;
}

int AecDbDimension::GetSegmentNum() const
{
	return m_lstSegment.Length();
}

double
AecDbDimension::GetObjRadius() const
{
	return m_nObjRadius;
}

BOOL
AecDbDimension::IsDimChord() const
{
	return ((m_nDimFlag & DF_CHORD));
}

BOOL
AecDbDimension::IsDimArcLen() const
{
	return ((m_nDimFlag & DF_ARCLEN));
}

ADSGePoint3d
AecDbDimension::GetLocation() const
{
	return m_ptLocation;
}

double
AecDbDimension::GetRotation() const
{
	return m_nRotation;
}

double
AecDbDimension::GetDist2DimLine(BOOL bAsPaperUnit) const
{
	double val = m_nDist2DimLine;
	if (!bAsPaperUnit)
		val *= GetPScale();
	return val;
}

double
AecDbDimension::GetDimRadius() const
{
	return m_nDimRadius;
}

AcDbObjectId
AecDbDimension::GetStyleId() const
{
	return m_idDimStyle;
}


// Modify on 2002/02/05, 考虑dimlfac进行单位换算
TCString
AecDbDimension::GetDefaultText(int nIndex) const
{
	ASSERT(nIndex < m_lstSegment.Length() && nIndex >= 0);
	GePoly2D poly;
	GetPolySegOnDimLine(poly);
	GeCurveSegment seg;
	poly.Nth(nIndex, seg);

	int dimdec, dimadec;
	double dimlfac = 1.0;
	int dimaunit = 0;
	int dimzin = 0;
	int dimazin = 0;
	double dimrnd = 0;
	OPENOBJ_BEGIN(m_idDimStyle, AcDb::kForRead, AcDbDimStyleTableRecord, pDimStyle);
	ASSERT(pDimStyle);
	dimdec = pDimStyle->dimdec();
	dimadec = pDimStyle->dimadec();
	dimlfac = pDimStyle->dimlfac();
	dimaunit = pDimStyle->dimaunit();
	dimzin = pDimStyle->dimzin();
	dimazin = pDimStyle->dimazin();
	dimrnd = pDimStyle->dimrnd();
	if (dimaunit > 1)
		dimaunit = 1;
	OPENOBJ_END();

	TCString sText;
	if (IsAngular())
	{
		if (IsDimChord())
		{
			ASSERT(0); //永远也不会执行这儿
			GlobalFunc::ftoa(seg.GeLine::GetLength() * dimlfac, dimdec, sText);
		}
		else if (IsDimArcLen())
		{
			GeArc ar = seg.GetArc();
			ar.SetRadius(m_nObjRadius);
			GlobalFunc::ftoa(ar.GetLength() * dimlfac, dimdec, sText);
		}
		else
		{
			TCString sTemp;
			ads_angtos(fabs(seg.GetBulge()), dimaunit, dimadec, sTemp);
			const TCHAR *pd = _tcschr(sTemp, _T('d'));
			if (pd) {
				GlobalFunc::StrCpy(sText, sTemp, pd);
				sText << _T("%%d");
				sText << (pd + 1);
			}
			else if (dimaunit == 0) {
				if (dimazin & 0x02)
					GlobalFunc::DelSuffixZero(sTemp);
				sText << sTemp << _T("%%d");
			}
			else {
				sText << sTemp;
			}
		}
	}
	else
	{
		TCString sDimrnd;
		GlobalFunc::ftoa(seg.GetLength() * dimlfac, dimdec, sText);
		//////// 处理 标注样式中舍入的问题zzg 090515
		double dTemLen(0), dTemrnd(0);
		GlobalFunc::ftoa(dimrnd, dimdec, sDimrnd);
		dTemLen = _tstof(sText);
		dTemrnd = _tstof(sDimrnd);
		if (!GlobalFunc::Equal(dTemrnd, 0, 0.00000001))
		{
			double dT = dTemLen / dTemrnd;
			TCString sT;
			GlobalFunc::ftoa(dT, 0, sT);
			dT = _tstof(sT);
			int nt = (int)dT;
			double dDimNum = dTemrnd * nt;
			GlobalFunc::ftoa(dDimNum, dimdec, sText);
		}
		//////zzg090515//////////////
		if ((dimzin & 0x08) != 0) {
			GlobalFunc::DelSuffixZero(sText);
		}
	}
	return sText;
}

TCString
AecDbDimension::GetText(int nIndex, BOOL *bIsDefault) const
{
	TCString sText;
	DimTextContent *pNode = ((AecDbDimension *)this)->m_lstTextContent.FindNode(&nIndex, DimTextContent::CompareByIndexForFind);
	if (pNode) {
		sText = pNode->sText;
		if (bIsDefault) *bIsDefault = FALSE;
	}
	else {
		if (bIsDefault) *bIsDefault = TRUE;
		sText = GetDefaultText(nIndex);
	}
	return sText;
}

ADSGePoint3d
AecDbDimension::GetTextPos(int nIndex, BOOL *bIsDefault) const
{
	ASSERT(nIndex < m_lstSegment.Length() && nIndex >= 0);
	DimTextPos *pNode = ((AecDbDimension *)this)->m_lstTextPos.FindNode(&nIndex, DimTextPos::CompareByIndexForFind);
	if (pNode) {
		if (bIsDefault) *bIsDefault = FALSE;
		return pNode->ptPos;
	}

	if (bIsDefault)
		*bIsDefault = TRUE;
	ADSGePoint3d ptText = GetDefaultTextPos(nIndex);
	return ptText;
}

ADSGePoint3d
AecDbDimension::GetDefaultTextPos(int nIndex) const
{
	ASSERT(nIndex < m_lstSegment.Length() && nIndex >= 0);
	GePoly2D poly;
	GetPolySegOnDimLine(poly);
	double nOffDist = m_nDist2DimLine * GetPScale();

	BOOL bAngular = IsAngular();
	int nSeg = poly.TotalSegments();
	GeCurveSegment seg;
	poly.Nth(nIndex, seg);
	ASSERT(!!seg);
	ADSGePointDir2d ptTextPos;
	seg.Polar(seg.GetLength() / 2.0, ptTextPos);
	ADSGePoint3d ptText = ptTextPos;
	double nDist2Dim = 0.0;
	OPENOBJ_BEGIN(m_idDimStyle, AcDb::kForRead, AcDbDimStyleTableRecord, pDimStyle);
	if (pDimStyle)
		nDist2Dim = (pDimStyle->dimgap() + pDimStyle->dimtxt() / 2) * GetPScale(); //pDimStyle->dimscale();
	else
		nDist2Dim = 3.0 * GetPScale();
	OPENOBJ_END();
	ADSGePoint3d ptBase;
	if (IsAngular() && IsDimChord()) {
		Midpoint(seg.StartPoint(), seg.EndPoint(), ptBase);
	}
	else {
		ptBase = ptTextPos;
	}
	// sg modify 120410，使用新增加的接口，代替基类中的NormalViewAngle函数，主要解决精确度是1度的问题
	// ads_polar(ptBase, NormalViewAngle(ptTextPos.nDirection)+PI/2.0, nDist2Dim, ptText);
	ads_polar(ptBase, ChangeToNormalViewAngle(ptTextPos.nDirection) + PI / 2.0, nDist2Dim, ptText);
	return ptText;
}

//add by xlc on 101209 解决多视口图纸切换速度慢的问题
TCString
AecDbDimension::GetDefaultText(int nIndex, GePoly2D poly) const
{
	ASSERT(nIndex < m_lstSegment.Length() && nIndex >= 0);
	//	GePoly2D poly;
	//	GetPolySegOnDimLine(poly);
	GeCurveSegment seg;
	poly.Nth(nIndex, seg);

	int dimdec, dimadec;
	double dimlfac = 1.0;
	int dimaunit = 0;
	int dimzin = 0;
	int dimazin = 0;
	double dimrnd = 0;
	OPENOBJ_BEGIN(m_idDimStyle, AcDb::kForRead, AcDbDimStyleTableRecord, pDimStyle);
	ASSERT(pDimStyle);
	dimdec = pDimStyle->dimdec();
	dimadec = pDimStyle->dimadec();
	dimlfac = pDimStyle->dimlfac();
	dimaunit = pDimStyle->dimaunit();
	dimzin = pDimStyle->dimzin();
	dimazin = pDimStyle->dimazin();
	dimrnd = pDimStyle->dimrnd();
	if (dimaunit > 1)
		dimaunit = 1;
	OPENOBJ_END();

	TCString sText;
	if (IsAngular())
	{
		if (IsDimChord())
		{
			ASSERT(0); //永远也不会执行这儿
			GlobalFunc::ftoa(seg.GeLine::GetLength() * dimlfac, dimdec, sText);
		}
		else if (IsDimArcLen())
		{
			GeArc ar = seg.GetArc();
			ar.SetRadius(m_nObjRadius);
			GlobalFunc::ftoa(ar.GetLength() * dimlfac, dimdec, sText);
		}
		else
		{
			TCString sTemp;
			ads_angtos(fabs(seg.GetBulge()), dimaunit, dimadec, sTemp);
			const TCHAR *pd = _tcschr(sTemp, _T('d'));
			if (pd) {
				GlobalFunc::StrCpy(sText, sTemp, pd);
				sText << _T("%%d");
				sText << (pd + 1);
			}
			else if (dimaunit == 0) {
				if (dimazin & 0x02)
					GlobalFunc::DelSuffixZero(sTemp);
				sText << sTemp << _T("%%d");
			}
			else {
				sText << sTemp;
			}
		}
	}
	else
	{
		TCString sDimrnd;
		GlobalFunc::ftoa(seg.GetLength() * dimlfac, dimdec, sText);
		//////// 处理 标注样式中舍入的问题zzg 090515
		double dTemLen(0), dTemrnd(0);
		GlobalFunc::ftoa(dimrnd, dimdec, sDimrnd);
		dTemLen = _tstof(sText);
		dTemrnd = _tstof(sDimrnd);
		if (!GlobalFunc::Equal(dTemrnd, 0, 0.00000001))
		{
			double dT = dTemLen / dTemrnd;
			TCString sT;
			GlobalFunc::ftoa(dT, 0, sT);
			dT = _tstof(sT);
			int nt = (int)dT;
			double dDimNum = dTemrnd * nt;
			GlobalFunc::ftoa(dDimNum, dimdec, sText);
		}
		//////zzg090515//////////////
		if ((dimzin & 0x08) != 0) {
			GlobalFunc::DelSuffixZero(sText);
		}
	}
	return sText;
}

TCString
AecDbDimension::GetText(int nIndex, GePoly2D poly, BOOL *bIsDefault) const
{
	TCString sText;
	DimTextContent *pNode = ((AecDbDimension *)this)->m_lstTextContent.FindNode(&nIndex, DimTextContent::CompareByIndexForFind);
	if (pNode) {
		sText = pNode->sText;
		if (bIsDefault) *bIsDefault = FALSE;
	}
	else {
		if (bIsDefault) *bIsDefault = TRUE;
		sText = GetDefaultText(nIndex, poly);
	}
	return sText;
}

ADSGePoint3d
AecDbDimension::GetTextPos(int nIndex, GePoly2D poly, BOOL *bIsDefault) const
{
	ASSERT(nIndex < m_lstSegment.Length() && nIndex >= 0);
	DimTextPos *pNode = ((AecDbDimension *)this)->m_lstTextPos.FindNode(&nIndex, DimTextPos::CompareByIndexForFind);
	if (pNode) {
		if (bIsDefault) *bIsDefault = FALSE;
		return pNode->ptPos;
	}

	if (bIsDefault)
		*bIsDefault = TRUE;
	ADSGePoint3d ptText = GetDefaultTextPos(nIndex, poly);
	return ptText;
}

ADSGePoint3d
AecDbDimension::GetDefaultTextPos(int nIndex, GePoly2D poly) const
{
	ASSERT(nIndex < m_lstSegment.Length() && nIndex >= 0);
	//	GePoly2D poly;
	//	GetPolySegOnDimLine(poly);
	double nOffDist = m_nDist2DimLine * GetPScale();

	BOOL bAngular = IsAngular();
	int nSeg = poly.TotalSegments();
	GeCurveSegment seg;
	poly.Nth(nIndex, seg);
	ASSERT(!!seg);
	ADSGePointDir2d ptTextPos;
	seg.Polar(seg.GetLength() / 2.0, ptTextPos);
	ADSGePoint3d ptText = ptTextPos;
	double nDist2Dim = 0.0;
	OPENOBJ_BEGIN(m_idDimStyle, AcDb::kForRead, AcDbDimStyleTableRecord, pDimStyle);
	if (pDimStyle)
		nDist2Dim = (pDimStyle->dimgap() + pDimStyle->dimtxt() / 2) * GetPScale(); //pDimStyle->dimscale();
	else
		nDist2Dim = 3.0 * GetPScale();
	OPENOBJ_END();
	ADSGePoint3d ptBase;
	if (IsAngular() && IsDimChord()) {
		Midpoint(seg.StartPoint(), seg.EndPoint(), ptBase);
	}
	else {
		ptBase = ptTextPos;
	}

	// sg modify 120410，使用新增加的接口，代替基类中的NormalViewAngle函数，主要解决精确度是1度的问题
	//ads_polar(ptBase, NormalViewAngle(ptTextPos.nDirection)+PI/2.0, nDist2Dim, ptText);
	ads_polar(ptBase, ChangeToNormalViewAngle(ptTextPos.nDirection) + PI / 2.0, nDist2Dim, ptText);
	return ptText;
}

// sg add 120410，增加一个新的接口，代替基类中的NormalViewAngle函数，主要解决TchPrivate::ChangeAngleTo1_4精确度是1度的问题
// 在布局时正常观察的WCS角度
double AecDbDimension::ChangeToNormalViewAngle(double nAngWcs) const
{
	double dAng = Wcs2Layout(nAngWcs);
	// 下面这段代码，用于替换TchPrivate::ChangeAngleTo1_4里的精确度，其实功能是一样的
	{
		double dSnap = 1.0E-3,
			dAng1 = GlobalFunc::AngleRangeTo2PI(dAng); //double dSnap = 1.0E-9, 9.0beta1 

		if (GlobalFunc::GreatThan(dAng1, PI / 2.0, dSnap) && GlobalFunc::LessThan(dAng1, PI, dSnap))
		{
			dAng1 += PI;
		}
		else if (GlobalFunc::GreatEqual(dAng1, PI, dSnap) && GlobalFunc::LessEqual(dAng1, PI * 1.5, dSnap))
		{
			dAng1 -= PI;
		}

		dAng = dAng1;
	}

	dAng = GlobalFunc::AngleRangeTo2PI(m_nLayoutRotation + dAng);
	return dAng;
}

AcDbObjectId
AecDbDimension::GetBindId() const
{
	return m_idBind;
}


void
AecDbDimension::SetLocation(ADSGePoint3d pt)
{
	AssertWriteEnabled();
	m_ptLocation = pt;
	m_ptLocation.z = 0;
}

void
AecDbDimension::SetRotation(double nAng)
{
	AssertWriteEnabled();
	m_nRotation = nAng;
}

void
AecDbDimension::SetDist2DimLine(double nVal, BOOL bAsPaperUnit)
{
	AssertWriteEnabled();
	m_nDist2DimLine = nVal;
	if (!bAsPaperUnit)
		m_nDist2DimLine /= GetPScale();
}


void
AecDbDimension::SetAngular(BOOL bTrue)
{
	AssertWriteEnabled();
	if (bTrue) m_nDimFlag |= DF_ANGULAR;
	else m_nDimFlag &= ~DF_ANGULAR;
}

void
AecDbDimension::SetDimChord(BOOL bTrue)
{
	AssertWriteEnabled();
	if (bTrue) m_nDimFlag |= DF_CHORD;
	else m_nDimFlag &= ~DF_CHORD;
}

void
AecDbDimension::SetDimArcLen(BOOL bTrue)
{
	AssertWriteEnabled();
	if (bTrue) m_nDimFlag |= DF_ARCLEN;
	else m_nDimFlag &= ~DF_ARCLEN;
}

void
AecDbDimension::SetObjRadius(double nVal)
{
	AssertWriteEnabled();
	m_nObjRadius = nVal;
}


void
AecDbDimension::SetDimRadius(double nAng)
{
	AssertWriteEnabled();
	m_nDimRadius = nAng;
}

void
AecDbDimension::SetStyleId(AcDbObjectId idStyle)
{
	AssertWriteEnabled();
	m_idDimStyle = idStyle;
}

void AecDbDimension::SetTextPos(int nIndex, ADSGePoint3d ptPos)
{
	AssertWriteEnabled();
	ASSERT(nIndex < m_lstSegment.Length() && nIndex >= 0);
	DimTextPos *pNode = m_lstTextPos.FindNode(&nIndex, DimTextPos::CompareByIndexForFind);
	if (!pNode) {
		ADSGePoint3d ptOld = GetTextPos(nIndex);
		if (ptOld.Distance2d(ptPos) > g_Option::instance()._DIST_SNAP)
			m_lstTextPos.Append(new DimTextPos(nIndex, ptPos));
	}
	else {
		int nPos = m_lstTextPos.CurPosition();
		ADSGePoint3d ptDefault = GetDefaultTextPos(nIndex);
		if (ptDefault.Distance2d(ptPos) < g_Option::instance()._DIST_SNAP)
			m_lstTextPos.Remove(nPos);
		else
			m_lstTextPos[nPos]->ptPos = ptPos;
	}
	AutoSetFlag();
}

void AecDbDimension::SetTextContent(int n, const TCHAR *pszChar)
{
	AssertWriteEnabled();
	ASSERT(n < m_lstSegment.Length() && n >= 0);

	//wlw add 13.06.22 增加对等式的智能判断
	TCString scharok = pszChar;
	double dDis = GetSegment(n);
	double dPrec = 1E-4;
	CString sExpression(pszChar);
	CString sLeft1, sLeft2, sRight;
	int nstar = sExpression.Find(_T("X"));
	int nstar1 = sExpression.Find(_T("="));
	if (nstar < 0)
	{
		nstar = sExpression.Find(_T("x"));
	}
	if (nstar > 0 && nstar1 > 0)
	{

		sLeft1 = sExpression.Left(nstar);
		sLeft2 = sExpression.Mid(nstar + 1, nstar1 - nstar - 1);
		sRight = sExpression.Right(sExpression.GetLength() - nstar1 - 1);
		double dRight = _tstof(sRight);
		//看看哪些数字改变过
		CString sOld = (LPCTSTR)GetText(n);
		CString soldLeft1, soldLeft2, soldRight;
		nstar = sOld.Find(_T("X"));
		nstar1 = sOld.Find(_T("="));
		if (nstar < 0)
		{
			nstar = sOld.Find(_T("x"));
		}
		if (nstar > 0 && nstar1 > 0)
		{
			soldLeft1 = sOld.Left(nstar);
			soldLeft2 = sOld.Mid(nstar + 1, nstar1 - nstar - 1);
			soldRight = sOld.Right(sOld.GetLength() - nstar1 - 1);
			double d1, d2;
			double doldRight = _tstof(soldRight);
			d1 = _tstof(sLeft2);
			d2 = _tstof(soldLeft2);

			if (RealEqual(dRight, doldRight, dPrec))
			{//总长度没变，改前面任意一个
				if (d1 < 1E-10)
				{
					return;
				}
				if (RealEqual(d1, d2, dPrec))
				{//第二个数没变,按照第一数进行计算
					d1 = _tstof(sLeft1);
					if (d1 < 1E-10)
						return;
					d2 = doldRight / d1;
				}
				else
				{//第二个数变,按照第二数进行计算
					d2 = _tstof(sLeft2);
					if (d2 < 1E-10)
						return;
					d1 = doldRight / d2;
				}

			}
			else
			{//总长度变化了，按照乘数不变的原则改第一个数
				d2 = _tstof(sLeft2);
				if (d2 < 1E-10)
				{
					return;
				}
				d1 = dRight / d2;
			}

			int nd1 = d1;
			int nd2 = d2;
			if (d2 != nd2)
			{
				if (d1 != nd1)
				{
					sExpression.Format(_T("%.1fX%.1f=%.0f"), d1, d2, dRight);
				}
				else
				{
					sExpression.Format(_T("%.0fX%.1f=%.0f"), d1, d2, dRight);
				}
			}
			else
			{
				if (d1 != nd1)
				{
					sExpression.Format(_T("%.1fX%.0f=%.0f"), d1, d2, dRight);
				}
				else
				{
					sExpression.Format(_T("%.0fX%.0f=%.0f"), d1, d2, dRight);
				}
			}
		}
	}
	scharok = sExpression;


	DimTextContent *pNode = m_lstTextContent.FindNode(&n, DimTextContent::CompareByIndexForFind);
	if (!pNode) {
		if (pszChar && pszChar[0])
			m_lstTextContent.Append(new DimTextContent(n, scharok));
	}
	else {
		if (!pszChar || !pszChar[0])
			m_lstTextContent.Remove();
		else
			pNode->sText = scharok;
	}
	AutoSetFlag();
}

void AecDbDimension::SetBindId(AcDbObjectId id)
{
	AssertWriteEnabled();
	m_idBind = id;
	AutoSetFlag();
}

void
AecDbDimension::AppendSegment(double nVal, BOOL bDist)
{
	AssertWriteEnabled();
	ASSERT(IsValidSegment(nVal, bDist));
	if (IsAngular() && bDist)
		nVal = nVal / m_nDimRadius;
	m_lstSegment.Append(new double(nVal));
}

void
AecDbDimension::ResetTextPos()
{
	AssertWriteEnabled();
	m_lstTextPos.Reset();
	AutoSetFlag();
}

void
AecDbDimension::ResetTextContent()
{
	AssertWriteEnabled();
	m_lstTextContent.Reset();
	AutoSetFlag();
}


BOOL
AecDbDimension::IsTextMoved() const
{
	return ((m_nDimFlag & DF_POSITION) != 0 && m_lstTextPos.Length());
}

BOOL
AecDbDimension::IsUseDefaultText() const
{
	return ((m_nDimFlag & DF_TEXT) == 0 || m_lstTextContent.Length() == 0);
}

BOOL
AecDbDimension::IsBind() const
{
	return ((m_nDimFlag & DF_BIND) != 0 && !!m_idBind);
}

BOOL
AecDbDimension::IsUseDimStyleScale() const
{
	return ((m_nDimFlag & DF_DSSCALE) != 0);
}

void
AecDbDimension::UseDimStyleScale(BOOL bTrue)
{
	AssertWriteEnabled();
	if (bTrue)
		m_nDimFlag |= DF_DSSCALE;
	else
		m_nDimFlag &= ~DF_DSSCALE;
}

void AecDbDimension::AutoSetFlag()
{
	AssertWriteEnabled();
	if (!!m_idBind)
		m_nDimFlag |= DF_BIND;
	else
		m_nDimFlag &= ~DF_BIND;

	if (m_lstTextPos.Length())
		m_nDimFlag |= DF_POSITION;
	else
		m_nDimFlag &= ~DF_POSITION;

	if (m_lstTextContent.Length())
		m_nDimFlag |= DF_TEXT;
	else
		m_nDimFlag &= ~DF_TEXT;

}

// sg add 101116，支持统一标高
bool AecDbDimension::UnifyElevation(double dElevation)
{
	AssertWriteEnabled();
	m_ptLocation.z = dElevation;

	for (int i = 0; i < m_lstTextPos.Length(); i++)
	{
		m_lstTextPos[i]->ptPos.z = dElevation;
	}

	return true;
}

Acad::ErrorStatus AecDbDimension::getSplitCurves(const AcGeDoubleArray& params,
	AcDbVoidPtrArray& curveSegments) const
{
	assertReadEnabled();
	if (IsAngular() || IsDimArcLen())
	{
		AcGePoint3dArray points;
		for (int i = 0; i < params.length(); i++)
		{
			AcGePoint3d pt;

			getPointAtParam(params[i], pt);
			points.append(pt);

		}

		return getSplitCurves(points, curveSegments);
	}
	else
	{
		return AecXDbCurveBaseEx::getSplitCurves(params, curveSegments);
	}
}
Acad::ErrorStatus AecDbDimension::getSplitCurves(const AcGePoint3dArray& points,
	AcDbVoidPtrArray& curveSegments) const
{
	assertReadEnabled();
	if (IsAngular() || IsDimArcLen())
	{
		int nlen = points.length();
		ADSGePoint3d ptOnDim;
		ADSGePoint3d ptPick, ptPick2;
		AecDbDimension *pDimClone = (AecDbDimension *)clone();
		getClosestPointTo(points[0], ptPick);
		pDimClone->AddSegment(ptPick);
		if (nlen > 1)
		{
			getClosestPointTo(points[1], ptPick2);
			pDimClone->AddSegment(ptPick2);
		}

		GePoly2D poly;
		pDimClone->GetPolySegOnDimLine(poly);
		int nSeg = -1;
		int nSeg2 = -1;
		for (int i = 0; i < poly.TotalSegments(); i++)
		{
			GeCurveSegment seg;
			poly.Nth(i, seg);
			if ((ptPick & seg) == PR_ONPT1 || (ptPick & seg) == PR_ONPT2)
			{
				nSeg = i;
				break;
			}
		}
		if (nlen > 1)
		{
			for (i = 0; i < poly.TotalSegments(); i++)
			{
				GeCurveSegment seg;
				poly.Nth(i, seg);
				if ((ptPick2 & seg) == PR_ONPT1 || (ptPick2 & seg) == PR_ONPT2)
				{
					nSeg2 = i;
					break;
				}
			}

			int nTmp;
			if (nSeg > nSeg2)
			{
				nTmp = nSeg;
				nSeg = nSeg2;
				nSeg2 = nTmp;
			}
		}


		GeDirectionCurve seg;
		ADSGePoint3d ptLoc;
		AecDbDimension *pDimNew2 = (AecDbDimension *)pDimClone->clone();
		int nTotalSeg = poly.TotalSegments();
		int nSeg1 = nSeg + 1;

		for (i = nSeg1; i < nTotalSeg; i++)
			pDimNew2->RemoveSegment(nSeg1);
		curveSegments.append(pDimNew2);


		if (nlen > 1)
		{
			AecDbDimension *pDimNew3 = (AecDbDimension *)pDimClone->clone();
			curveSegments.append(pDimNew3);
			poly.Nth(nSeg2 + 1, seg);
		}
		else
		{
			poly.Nth(nSeg1, seg);
		}

		double nRot = seg.IDirection(0);
		ads_polar(seg.StartPoint(), nRot - PI / 2.0, pDimClone->GetDist2DimLine(FALSE), ptLoc);

		AecDbDimension *pDimNew = (AecDbDimension *)pDimClone->clone();
		if (nlen > 1)
		{
			for (i = 0; i < nSeg2 + 1; i++)
				pDimNew->RemoveSegment(0);
		}
		else
		{
			for (i = 0; i < nSeg1; i++)
				pDimNew->RemoveSegment(0);
		}

		pDimNew->SetLocation(ptLoc);
		pDimNew->SetRotation(nRot);
		curveSegments.append(pDimNew);

		delete pDimClone;
		return Acad::eOk;

	}
	else
	{
		return AecXDbCurveBaseEx::getSplitCurves(points, curveSegments);
	}
}

Acad::ErrorStatus AecDbDimension::subExplode(AcDbVoidPtrArray &entitySet) const
{
	double dTxtHeight = 0.0, dtxtw = 0.0;
	double dPScale = GetPScale();

	AcDbObjectId idDimStyle = GlobalFunc::DimStyleTch2Acad(m_idDimStyle, dPScale, IsAngular(), database(), dTxtHeight);

	double nOffDist = m_nDist2DimLine*GetPScale();
	BOOL bIsDefText(FALSE);

	XPoly2D poly;
	GetPolySegOnDimLine(poly);

	int nSeg = poly.TotalSegments();
	for (int i = 0; i<nSeg; i++)
	{
		XCurveSegment seg;
		poly.Nth(i, seg);
		ASSERT(!!seg);

		XCurveSegment segOnFix = seg.Offset(OFFSET_RIGHT, nOffDist, LS_FINITE);
		AcDbDimension *pDim = NULL;
		XPoint ptText = seg.MidPoint();

		if (!IsAngular())
		{
			XPoint pt1 = segOnFix.StartPoint(),
				pt2 = segOnFix.EndPoint();
			// sg modify 120410，使用新增加的接口，代替基类中的NormalViewAngle函数，主要解决精确度是1度的问题
			// double nAng = NormalViewAngle(ads_angle(pt1, pt2));
			double nAng = ChangeToNormalViewAngle(ads_angle(pt1, pt2));
			if (!IsExactSameDrt(nAng, ads_angle(pt1, pt2), g_DimOption::instance()._angSnap))
				GlobalFunc::Exchange(pt1, pt2);
			pDim = new AcDbAlignedDimension(pt1, pt2, ptText);
		}
		else
		{
			XPoint ptCen = seg.GetArc().GetCenterPt();
			pDim = new AcDb3PointAngularDimension(ptCen, segOnFix.StartPoint(), segOnFix.EndPoint(), ptText);
		}
		bool bModifyGap = false; // 标记是否需要单独修改“文字偏移”
		DimTextPos *pNode = ((AecDbDimension *)this)->m_lstTextPos.FindNode(&i, DimTextPos::CompareByIndexForFind);
		if (pNode)
		{
			// sg add 120718，用来标记是否是角度标注，并且带引线的样式，文字不在默认位置，此情况下，导出的时候需要特殊处理布局转角
			int nDimTextMovePos(2);
			double dimgap(0),
				dimtxt(0),
				dimexe(0);
			AcDbObjectId idTextStyle;
			XString sDimPrefix, sDimSuffix;
			OPENOBJ_BEGIN(m_idDimStyle, AcDb::kForRead, AcDbDimStyleTableRecord, pDimStyle);
			if (pDimStyle != NULL)
			{
				nDimTextMovePos = pDimStyle->dimtmove();
				dimgap = pDimStyle->dimgap();
				dimtxt = pDimStyle->dimtxt();
				dimexe = pDimStyle->dimexe();
				idTextStyle = pDimStyle->dimtxsty();

				const TCHAR *dimpost = pDimStyle->dimpost();
				const TCHAR *pStr = NULL;
				if (dimpost)
					pStr = _tcsstr(dimpost, _T("<>"));
				if (pStr)
				{
					GlobalFunc::StrCpy(sDimPrefix, dimpost, pStr);
					GlobalFunc::StrCpy(sDimSuffix, pStr+2, NULL);
				}
				else if (dimpost)
				{
					_tcscpy(sDimSuffix, dimpost);
				}
			}
			OPENOBJ_END();

			XPoint ptDimPos = pNode->ptPos, ptTempPos;
			XPointDir2d ptTempDir;
			XCurveSegment cvDim = GetDimCurve();
			cvDim.ProjectToMe(pNode->ptPos, ptTempPos);
			double dDistNonDefPt = cvDim.PathDistance(ptTempPos);
			cvDim.Polar(dDistNonDefPt, ptTempDir);
			double dTextRot = ChangeToNormalViewAngle(ptTempDir.nDirection);

			pDim->setTextPosition(pNode->ptPos);
			if (nDimTextMovePos == 1)
			{
				//wlw add 12.09.17带引线的标注，如果小于cad引线范围内，人为修改文字位置，否则导t3文字移位
				double ddimgapX = dPScale*(dimgap + dimtxt*0.5);
				if (ptDimPos.Distance2d(ptTempPos) + g_Option::instance()._DIST_SNAP < ddimgapX + dPScale * dimexe)
				{
					ads_polar(ptDimPos, dTextRot-PI/2, ddimgapX, ptDimPos);
					pDim->setTextPosition(ptDimPos);
				}
			}

			pDim->useSetTextPosition();

		}
		// sg modify 120315，解决如果单独设置过天正的布局转角，图形导出T3或者炸开后，文字位置错误的问题
		// 主要是CAD的对象没有布局转角的概念，需要额外处理一下
		else if (fabs(m_nLayoutRotation) > g_DimOption::instance()._angSnap)
		{
			XPoint ptDefText = GetDefaultTextPos(i, poly);
			pDim->setTextPosition(ptDefText); // 固定文字位置
			pDim->useSetTextPosition();

			double dTextAngle = ads_angle(ptText, ptDefText); // 重新计算标注的角度，0位置表示的是与Y轴正向间的夹角
			dTextAngle -= PI/2;
			pDim->setTextRotation(dTextAngle);

			// 需要单独修改扩展数据来设置对象内的“文字偏移”
			bModifyGap = true;
		}

		//	TDimTextContent *pNode1 = ((TDbDimension2 *)this)->m_lstTextContent.FindNode(&i, TDimTextContent::CompareByIndexForFind);
		XString sTextdim = GetText(i, poly, &bIsDefText);
		//wlw mod 130929导出T3保持文字不变
		if (bIsDefText)
		{
			pDim->setDimensionText(_T(""));
		}
		else
		{
			pDim->setDimensionText(sTextdim);
		}
		pDim->setDimensionStyle(idDimStyle);
		pDim->setDimstyleData(idDimStyle);
		pDim->setPropertiesFrom(this);
	#if (ADS != 17)
		if (bModifyGap) // 标记为真的适合，表示需要单独修改“文字偏移”量，天正的尺寸标注对象，不支持遮挡效果，所以直接设置为0即可
		{
			pDim->setDimgap(0);
		}
	#endif
		entitySet.append(pDim);
	}
	return Acad::eOk;
}

#pragma endregion