#include "stdafx.h"

extern AcDbObjectId DimStyleAcad2Tch(AcDbObjectId idAcad, double &nScale);
extern AcDbObjectId DimStyleTch2Acad(AcDbObjectId idTch, double nScale, BOOL bAngular, AcDbDatabase *pDb, double dTxtHeight);
//extern BOOL g_bMakeBlock;
extern XPoint GetTextExtend(AcDbObjectId idTextStyle, const TCHAR *pszText, double nHeight, BOOL penups);
//extern XString GetSymbolName(AcDbObjectId idSymbolRec);
//extern double g_nAcadVer;

static BOOL g_bDisableQuickMode=FALSE;
// 不能重载cloneMeForDragging

//问题：由于不断的读取dimstyle导致显示速度很慢

int TDimTextPos::CompareByIndexForFind(const TDimTextPos * p1, const void *p2)
{
    int idx=*(const int *)p2;
    return (p1->nIndex!=idx);
}

int TDimTextContent::CompareByIndexForFind(const TDimTextContent * p1, const void *p2)
{
    int idx=*(const int *)p2;
    return (p1->nIndex!=idx);
}


/////////////////////////////////////////////////////////////
// 尺寸对象类
/////////////////////////////////////////////////////////////
const Adesk::UInt8 TDbDimension::g_nVersion = 3;


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

IMPLEMENT_TENTBASE(TDbDimension);

//BOOL TDbDimension::g_bExplAcadDim=TRUE;

TDbDimension::TDbDimension()
{
    m_nRotation=0; //旋转角度
    m_nDist2DimLine=0; //定位点到尺寸线的距离, 可以为负值
    m_nDimRadius=0; //夹角,可以为负
    m_nObjRadius=0;
}


TDbDimension::~TDbDimension()
{
}

BOOL TDbDimension::IsValid() const
{
    BOOL bRet=TDbEntity::IsValid();
    if(!bRet)
        return bRet;

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

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

void TDbDimension::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
{
    assertWriteEnabled();
	double nOldScale=GetPScale();
	double nDimDist=GetDist2DimLine(FALSE);
    TDbEntity::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
    TDbDimension *pSrc=TDbDimension::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);
	}
}





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

   Acad::ErrorStatus es = TDbEntity::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); //定位点到尺寸线的距离, 可以为负值
    if(nVer<2)
        pFiler->readItem(&m_nDimRadius); //夹角,可以为负
    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));
    }

    if(nVer>1) {
        pFiler->readItem(&m_nDimFlag);
    } else m_nDimFlag=0;

    m_lstTextPos.Reset();
    if(nVer==1 || (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 TDimTextPos(nIndex, XPoint(ptPos[0], ptPos[1])));
        }
    }

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

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

   es=pFiler->filerStatus();
   return es;
}

Acad::ErrorStatus TDbDimension::dwgOutFields(AcDbDwgFiler* pFiler) const
{
   assertReadEnabled();
   Acad::ErrorStatus es = TDbEntity::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 TDimTextPos &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 TDimTextContent &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);
    }
    return pFiler->filerStatus();
}

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

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

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

    return pFiler->filerStatus();

   // 不读入任何数据
}

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

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

   
   return es;
}

 

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

Acad::ErrorStatus
TDbDimension::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();
        XCurveSegment cv=GetDimCurve();
        XCurveSegment cvFix=cv.Offset(nOffDist, LS_FINITE);
        XPoly2D poly;
        GetPolySegOnDimLine(poly);

        if(osnapMode==AcDb::kOsModeNode) {
            int nVertNum=poly.Length();
            for(int i=0; i<nVertNum; i++) {
                XPoint 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++) {
                XPoint ptText = GetTextPos(i);
                snapPoints.append(ptText);
            }
        }
                                  }
        break;
    default: {
        //XPushMemVar<BOOL> vTemp(g_bExplAcadDim, FALSE);
        TDbEntity::subGetOsnapPoints(osnapMode, gsSelectionMark, pickPoint,
                              lastPoint, viewXform, snapPoints,
                              geomIds);
             }
        return Acad::eOk;
    }

    return es;
}

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

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

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


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

    if(IsAngular() && (IsDimChord() || IsDimArcLen())) 
        gripPoints.append(m_ptLocation);
    return Acad::eOk;
}

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

    return subGetGripPoints(stretchPoints, osnapModes, geomIds);
}



// Active when being rotated, scaled, moved, etc.
// Scale is disabled here
Acad::ErrorStatus TDbDimension::subTransformBy(const AcGeMatrix3d& xform)
{
    assertWriteEnabled();
	TDbEntity::subTransformBy(xform);
    ads_matrix mat;
    AsAdsMatrix(xform, mat);
    for(int i=0; i<m_lstTextPos.Length(); i++) {
        m_lstTextPos[i]->ptPos.TransformBy(mat);
    }

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

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

    return Acad::eOk;
}

//设置尺寸线位置
BOOL TDbDimension::SetDimLinePos(XPoint pt)
{
	assertWriteEnabled();
	BOOL bRet=FALSE;
        XCurveSegment seg=GetDimCurve();
        XPoint 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>_DIST_SNAP) {
                    SetDimRadius(nDistRad);
                    SetDist2DimLine(nDist2Dim, FALSE);
                }
            } else {
                nDist2Dim += nDistMove; 
                SetDist2DimLine(nDist2Dim, FALSE);
            }
			bRet=TRUE;
        }

		return bRet;
}

//设置标注固定线位置
BOOL TDbDimension::SetFixLinePos(XPoint pt)
{
	assertWriteEnabled();

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

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

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

}

// 功能: 夹点操作, 还没有完全考虑圆弧类型
Acad::ErrorStatus TDbDimension::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;
    XCurveSegment cv=GetDimCurve();
    cv.SetPoints(XPoint(gripPoints[0]), XPoint(gripPoints[1]));
    XPoint ptS, ptE;
    XPoint 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()<_DIST_SNAP)
        return Acad::eInvalidInput;
    XSortedVertexList lstVert(cv);
    for(i=1; i<nVertNum-1; i++) {
        XPoint ptFix=gripPoints[2+i];
        XPoint ptOnDim;
        if(cv.ProjectToMe(ptFix, ptOnDim)==RTNORM) {
            lstVert.Insert(ptOnDim);
        }
    }
    XPoly2D poly;
    lstVert.AsPoly2D(poly);

    m_lstSegment.Reset();
    int nSeg=poly.TotalSegments();
    for(i=0; i<nSeg; i++) {
        XCurveSegment 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???
        XLine ln(cv.StartPoint(), cv.IDirection(0)+PI/2);
        XPoint ptNewLoc=m_ptLocation + XPoint(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, TDimTextPos::CompareByIndexForFind))
                SetTextPos(i, gripPoints[nGripIndex]);
        }
    } else {
        m_lstTextPos.Reset();
        m_lstTextContent.Reset();
    }
    AutoSetFlag();
    return Acad::eOk;
}


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

    assertWriteEnabled();

    XPoint vtOffset=*(XPoint *)&offset;
    vtOffset.z=0;
    XPoly2D poly, polyNew;
    GetPolySegOnDimLine(poly);
    polyNew=poly;
    XCurveSegment cv=GetDimCurve();
    double nOffDist=m_nDist2DimLine*GetPScale();
    XCurveSegment cvFix=cv.Offset(nOffDist, LS_FINITE);
    XCurveSegment 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) 
		{ //改变尺寸线位置
            XPoint ptVert=idx==0? *poly.Head() : *poly.Tail();
            double nExtDir=idx==0? cv.IDirection(0) : cv.IDirection(1);
            XLine lnExt(ptVert, nExtDir+PI/2);
            XPoint ptOnExt=ptVert + vtOffset;
            XPoint(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)>_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<_DIST_SNAP) 
				{
                    m_nDist2DimLine=nOldDist2DimLine;
                    m_nDimRadius=nOldDimRadius;
                } 
            }
        } 
		else if(idx<poly.Length()+2) 
		{ //改变定位点或区间
			int ndx=idx-2;
			XPoint 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_bStetchEntity&&GetCtrlToggle())
			{
				if(!AddSegment(ptGrip)&&GetSegmentNum()>1)
					FindAndRemoveSegment(ptGrip0);
			}
			else
			{
				XPoint ptOnDim;
				BOOL bGreatPrev=FALSE, bLessNext=FALSE;
				if(cv.ProjectToMe(ptGrip, ptOnDim)==RTNORM) 
				{
					if(vtIdx>0)
					{
						double nPathDist=cv.PathDistance(ptOnDim); //小于0时,为圆弧标注
						if(IsAngular() && nPathDist<-_DIST_SNAP) 
						{
							if(vtIdx==polyNew.Length()-1)
								nPathDist=cv.GetArc().XCircle::GetLength()+nPathDist;
						}
						double nPathDistPrev=cv.PathDistance(*polyNew[vtIdx-1]);
						bGreatPrev = (nPathDist-nPathDistPrev)>-_DIST_SNAP;
					} 
					else 
						bGreatPrev=TRUE;
					if(vtIdx<polyNew.Length()-1) 
						bLessNext = (cv.PathDistance(ptOnDim)-cv.PathDistance(*polyNew[vtIdx+1]))<_DIST_SNAP;
					else bLessNext=TRUE;
					if(bGreatPrev && bLessNext) 
					{
						if(vtIdx==0) 
						{
							XCurveSegment seg;
							polyNew.Nth(0, seg);
							seg.SetPoints(ptOnDim, seg.EndPoint());
							if(IsAngular() && (IsDimChord() || IsDimArcLen()))
							{
								XArc ar=seg.GetArc();
								XCircle cir(ar.GetCenterPt(), ads_distance(ar.GetCenterPt(), m_ptLocation));
								XPoint 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);
							XCurveSegment 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, XPoint(seg.EndPoint()));
							segPrev.SetPoints(XPoint(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())) 
								{
									//改标注半径
									XArc arDim=cv.GetArc();
									arDim.SetRadius(m_nObjRadius);
									XCurveSegment cvObj;
									cvObj=arDim;
									XPoint 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()) 
			{
                XPoint ptText = GetTextPos(nSeg);
                ptText += vtOffset;
                SetTextPos(nSeg, ptText);
            }
			else 
			{
                ASSERT(IsAngular() && (IsDimChord() || IsDimArcLen()));
                XLine ln(cv.StartPoint(), cv.IDirection(0)+PI/2);
                XPoint 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);
            }
        }
    }
    //RemoveZeroSegment(); //把长度为0的区间移除
    AutoSetFlag();
    Acad::ErrorStatus es = Acad::eOk;
    return es;
}


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

// 取得夹点说明
Acad::ErrorStatus TDbDimension::GetGripText(int i, CString &cs) const
{
    Acad::ErrorStatus es=Acad::eOk;
    XPoly2D 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("改尺寸界线");
    }

    return es;
}

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


// 返回发现的位置，同时posStart往前移动(以便继续找下一个使用),
TTextPosition  
TDbDimension::FindSubText(const TCHAR *sSubText, TTextPosition &posStart, TTextRange *pRange) const
{
	assertReadEnabled();
	TTextPosition 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;
	TTextPosition posNext=posStart;
    for(int i=posStart.m_nCookies; i<nLen; i++) {
        //TDimTextContent content=m_lstTextContent[i];
		XString sTextDim=GetText(i);
        TDbText dimText;
        dimText.setPropertiesFrom(this);
        dimText.SetAlignment(XExplodeDraw::kMiddleCenter);
        dimText.SetHeight(dimtxt);
        dimText.SetStyleId(idTextStyle);
		dimText.SetText(sTextDim);
		dimText.SetLocation(GetTextPos(i));
		posNext.m_nCookies=i;

		TTextPosition 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;
}

// 返回下一次查找的开始位置
TTextPosition  
TDbDimension::ReplaceSubText(const TTextPosition &posRep, const TCHAR *sRepText, TTextRange *pRange)
{
	assertWriteEnabled();
	TTextPosition 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;

    //TDimTextContent *pContent=m_lstTextContent[posRep.m_nCookies];
	XString sTextDim=GetText(posRep.m_nCookies);
    TDbText dimText;
    dimText.setPropertiesFrom(this);
    dimText.SetAlignment(XExplodeDraw::kMiddleCenter);
    dimText.SetHeight(dimtxt);
    dimText.SetStyleId(idTextStyle);
	dimText.SetText(sTextDim);
	dimText.SetLocation(GetTextPos(posRep.m_nCookies));

	TTextPosition 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 
TDbDimension::subSetAttributes(AcGiDrawableTraits * traits)
{
    Adesk::UInt32 nRet=TDbEntity::subSetAttributes(traits);
    //if(g_nAcadVer<15.0001)
    //    nRet |= kDrawableIsCompoundObject;
    return nRet;
}
static BOOL g_bSelfDrawDim=FALSE;
TSubText* TDbDimension::GetSubText(long iText)const
{
	XPushMemVar<BOOL> bExpl(g_bSelfDrawDim, TRUE);
	TSubText*pSubText=TDbEntity::GetSubText(iText);
	if(pSubText!=NULL)
		pSubText->SetMenuType(6);
	return pSubText;
}
TSubText* TDbDimension::HitTestText(XPoint pt)const
{
	XPushMemVar<BOOL> bExpl(g_bSelfDrawDim, TRUE);
	TSubText*pSubText=TDbEntity::HitTestText(pt);
	if(pSubText!=NULL)
		pSubText->SetMenuType(6);
	return pSubText;
}
Acad::ErrorStatus TDbDimension::GetExtents2d(XPoint &ptLow, XPoint &ptUp) const
{
	AcDbExtents ext;
	Acad::ErrorStatus es=getGeomExtents(ext);
	ptLow=ext.minPoint();
	ptUp=ext.maxPoint();
	return es;
}
Acad::ErrorStatus 
TDbDimension::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
    assertReadEnabled();

	//if(_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0&&!dc.IsPlotGeneration())
	//{
	//	AcGePoint3dArray gripPoints;
	//	double nOffDist=m_nDist2DimLine*GetPScale();
	//	XCurveSegment cv=GetDimCurve();
	//	XCurveSegment cvFix=cv.Offset(nOffDist, LS_FINITE);
	//	XCurveSegment cvObj;
	//	if(IsAngular()) {
	//		double nDist2Obj=cv.GetArc().radius-m_nObjRadius;
	//		cvObj=cv.Offset(-nDist2Obj, LS_FINITE);
	//	}
	//	XPoly2D poly;
	//	GetPolySegOnDimLine(poly);

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

	//modified by whl on 060223
    //BOOL bCheckDim=DocGetCheckDim();
    BOOL bCheckDim=DocGetCheckDim()&&!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_bSelfDrawDim);
	BOOL bQuickMode=(bDraw && !ownerId() && m_lstSegment.Length()>=g_nDimNumGripTip);
	if(g_bDisableQuickMode)
		bQuickMode=FALSE;
    XPoly2D poly;
	GetPolySegOnDimLine(poly);

    
    BOOL bAngular=IsAngular();
    BOOL bSelfDraw=(g_bOsnapExpl || bDraw ||  //g_bExpOtherDb ||
        (IsAngular() && (IsDimChord() || IsDimArcLen()))
        );
    if(bSelfDraw || bCheckDim) {
        dc.SetAlignment(XExplodeDraw::kMiddleCenter);
		XString 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;
        OPENOBJ_BEGIN(m_idDimStyle, AcDb::kForRead, AcDbDimStyleTableRecord, pDimStyle);
        if(pDimStyle) {
            dimdec=pDimStyle->dimdec();
            dimadec=pDimStyle->dimadec();
            dimgap=pDimStyle->dimgap();
            dimtxt=pDimStyle->dimtxt();
            dimblk=pDimStyle->dimblk();
            dimlfac=pDimStyle->dimlfac();
            dimscale=nPScale; 
			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();
			const TCHAR *dimpost=pDimStyle->dimpost();
			const TCHAR *pStr=NULL;
			if(dimpost)
				pStr=_tcsstr(dimpost, _T("<>"));
			if(pStr) {
				StrCpy(sDimPrefix, dimpost, pStr);
				StrCpy(sDimSuffix, pStr+2, NULL);
			} else if(dimpost) {
				_tcscpy(sDimSuffix, dimpost);
			}
        } else {
            return Acad::eInvalidInput;
        }
        OPENOBJ_END();

        XCurveSegment cv=GetDimCurve(); 
        BOOL bDimArcLen=(IsAngular() && IsDimArcLen());
        if(bDimArcLen) { //弧长标注
            int numSeg=poly.TotalSegments();
            for(int i=0; i<numSeg; i++) {
                XCurveSegment 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);
                XPoint ptAr1, ptAr2;
                double nChorldDir=segObj.XLine::Direction();
                XLine ln1(segObj.StartPoint(), nChorldDir+PI/2.0), 
                    ln2(segObj.EndPoint(), nChorldDir+PI/2.0);
                XPoint 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=XLine(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=XLine(ptInt[0], ptInt[1]).NearPoint(segDim.StartPoint());

                segDim.SetPoints(ptAr1, ptAr2);

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

                // 绘制尺寸界线
                if(dimclre) dc.SetColor(dimclre);
				if(bQuickMode) ;
                else if(!g_bOsnapExpl) {  //尺寸箭头
                    if(!dimblk) {
                        XPointDir2d pt1, pt2; 
                        segDim.Polar(2.0*dimscale, pt1);
                        segDim.Polar(2.0*dimscale, pt2, FALSE);
                        AcDbPolyline plArrow1;
                        plArrow1.setPropertiesFrom(this);
                        plArrow1.addVertexAt(0, segDim.StartPoint());
                        plArrow1.setWidthsAt(0, 0.0, 0.66*dimscale);
                        plArrow1.addVertexAt(1, pt1);
                        plArrow1.setWidthsAt(1, 0.66*dimscale, 0.0);
                        dc.Polyline(plArrow1);

                        AcDbPolyline plArrow2;
                        plArrow2.setPropertiesFrom(this);
                        plArrow2.addVertexAt(0, pt2);
                        plArrow2.setWidthsAt(0, 0.66*dimscale, 0.0);
                        plArrow2.addVertexAt(1, segDim.EndPoint());
                        plArrow2.setWidthsAt(1, 0.0, 0.0);
                        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;

						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();
                    }
                }
				

                // 尺寸界限
                XPoint pt1, pt2;
                double nFactor=fabs(nOffDist)>_DIST_SNAP? nOffDist/fabs(nOffDist) : 1.0;
                ads_polar(segDim.StartPoint(), nChorldDir-nFactor*PI/2, fabs(nOffDist)-dimexo*dimscale, pt1);
                ads_polar(segDim.StartPoint(), nChorldDir+nFactor*PI/2, dimexe*dimscale, pt2);
                dc << XLine(pt1, pt2);
                ads_polar(segDim.EndPoint(), nChorldDir-nFactor*PI/2, fabs(nOffDist)-dimexo*dimscale, pt1);
                ads_polar(segDim.EndPoint(), nChorldDir+nFactor*PI/2, dimexe*dimscale, pt2);
                dc << XLine(pt1, pt2);
                dc.SetColor(nColorOld);

                // 尺寸文字
				if(bQuickMode) ;
                else if(!g_bOsnapExpl) {
                    TDbText dimText;
                    dimText.setPropertiesFrom(this);
                    dimText.SetAlignment(XExplodeDraw::kMiddleCenter);
                    dimText.SetHeight(dimtxt);
                    dimText.SetStyleId(idTextStyle);
                    dimText.setColorIndex(dimclrt);

                    int numSeg=poly.TotalSegments();
                    BOOL bIsDefPos=TRUE;
                    XPoint ptText=GetTextPos(i, &bIsDefPos);
                    XPoint ptTemp;
                    XPointDir2d ptTempDir;
                    cv.ProjectToMe(ptText, ptTemp);
                    double nDist=cv.PathDistance(ptTemp);
                    cv.Polar(nDist, ptTempDir);
                    double nTextRot=NormalViewAngle(ptTempDir.nDirection);

                    BOOL bIsDefText=TRUE;
                    XString sText0=GetText(i, &bIsDefText);
					XString sText;
					if(bIsDefText) 
						sText << sDimPrefix << sText0 << sDimSuffix;
					else
						sText << sText0;
                    dimText.SetRotation(Wcs2Layout(nTextRot));
                    dimText.SetLocation(ptText);
                    if(bSelfDraw) {
						TPushProperty vProp(&dimText, dc);

                        dimText.SetText(sText);
						if(dc.IsFullExplode()) 
							dimText.ExplodeOrDraw2d(dc);
						else
							dc.DrawEntity(dimText);
                        XPoint ext=dimText.GetExtents();
                        XPoint 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(XPoint(ptS), nTextRot+PI/2, ext.y/2, ptS);
                        ads_polar(XPoint(ptE), nTextRot+PI/2, ext.y/2, ptE);
                        dc << XArc(ptS, ptMid, ptE);
                    }

                    if(bCheckDim && !bIsDefText) {
                        XString sCheckText(256);
                        sCheckText << _T("(") << sDimPrefix << GetDefaultText(i) << sDimSuffix << _T(")");
                        XPoint ptCheckText;
                        if(bIsDefPos) {
                            XPoint 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);
						{
						TPushProperty vProp(&dimText, dc);
						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()) { //弦长标注
			XPushMemVar<BOOL> tVar1(g_bDisableQuickMode, TRUE);
            int numSeg=poly.TotalSegments();
            for(int i=0; i<numSeg; i++) {
                XCurveSegment 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.XLine::Direction();
                XPoint ptFix;
                double nObj2Fix=segFix.GetArc().GetRadius()-segObj.GetArc().GetRadius();
                ads_polar(segObj.StartPoint(), nRot-PI/2, nObj2Fix, ptFix);
                TDbDimension objDim;
                objDim.setPropertiesFrom(this);
                objDim.SetLocation(ptFix);
                objDim.SetRotation(nRot);
                objDim.SetDist2DimLine(GetDist2DimLine());
                objDim.AppendSegment(segObj.GetArc().ChordLength());
                objDim.SetStyleId(GetStyleId());
                TDimTextPos *pNode1=((TDbDimension *)this)->m_lstTextPos.FindNode(&i, TDimTextPos::CompareByIndexForFind);
                if(pNode1) objDim.SetTextPos(0, pNode1->ptPos);
                TDimTextContent *pNode=((TDbDimension *)this)->m_lstTextContent.FindNode(&i, TDimTextContent::CompareByIndexForFind);
                if(pNode) objDim.SetTextContent(0, pNode->sText);
                objDim.ExplodeOrDraw2d(dc);
            }
        } else 
		{ //直线标注或角度标注
            if(bSelfDraw) 
			{
                if(dimclrd) dc.SetColor(dimclrd);
				if(IsAngular())
					dc << poly;
				else//使用的是样式比例
				{
					XPoint ptStart,ptEnd;
					ads_polar(*poly[0],m_nRotation+PI,dimdle*dimscale,ptStart);
					dc<<XLine(ptStart,*poly[0]);
					ads_polar(*poly[poly.Length()-1],m_nRotation,dimdle*dimscale,ptEnd);
					dc<<XLine(*poly[poly.Length()-1],ptEnd);
					dc<<poly;
				}
				//dc << cv;

                if(dimclre) dc.SetColor(dimclre);
                int numVert=poly.Length();
                for(int i=0; i<numVert; i++) 
				{
                    XPoint ptVert=*poly[i];
                    double nPathDist=cv.PathDistance(ptVert);
                    XPointDir2d ptVertDir;
                    cv.Polar(nPathDist, ptVertDir);
					if(bQuickMode) ;
                    else if(!g_bOsnapExpl) 
					{ 
                        //尺寸箭头
                        if(!dimblk) 
						{
                            XPointDir2d pt1, pt2; 
                            cv.Polar(nPathDist+2.0*dimscale, pt1);
                            cv.Polar(nPathDist-2.0*dimscale, pt2);
                            AcDbPolyline plArrow;
                            plArrow.setPropertiesFrom(this);
                            int iVert=0;
                            if(i>0) 
							{
                                plArrow.addVertexAt(iVert, pt2);
                                plArrow.setWidthsAt(iVert, 0.66*dimscale, 0.0);
                                iVert++;
                            }
                            plArrow.addVertexAt(iVert, ptVert);
                            plArrow.setWidthsAt(iVert, 0.0, 0.66*dimscale);
                            iVert++;
                            if(i<numVert-1) 
							{
                                plArrow.addVertexAt(iVert, pt1);
                                iVert++;
                            }
                            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;

							OPENOBJ_BEGIN(dimblk, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
                            if(pBlock) 
							{
                                dc.DrawBlock(*pBlock, ptVert, AcGeScale3d(dimscale*dimasz, dimscale*dimasz, dimscale*dimasz), 
                                    NormalViewAngle(ptVertDir.nDirection), bNewMethod);
                            }
                            OPENOBJ_END();
                        }
                    }

                    // 尺寸界限
                    XPoint pt1, pt2;
                    double nFactor=fabs(nOffDist)>_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);
					
					dc<<XLine(pt1,pt2);
                }
            }

            dc.SetColor(nColorOld);
			if(bQuickMode) ;
            else if(!g_bOsnapExpl) 
			{
                TDbText dimText;
                dimText.setPropertiesFrom(this);
                dimText.SetAlignment(XExplodeDraw::kMiddleCenter);
                dimText.SetHeight(dimtxt);
                dimText.SetStyleId(idTextStyle);
                dimText.setColorIndex(dimclrt);
                int numSeg=poly.TotalSegments();
                for(int i=0; i<numSeg; i++) 
				{
                    XCurveSegment seg;
                    poly.Nth(i, seg);
                    BOOL bIsDefPos=TRUE;
                    XPoint ptText=GetTextPos(i, &bIsDefPos);
                    XPoint ptTemp;
                    XPointDir2d ptTempDir;
                    cv.ProjectToMe(ptText, ptTemp);
                    double nDist=cv.PathDistance(ptTemp);
                    cv.Polar(nDist, ptTempDir);
                    double nTextRot=NormalViewAngle(ptTempDir.nDirection);

                    BOOL bIsDefText=TRUE;
                    XString sText0=GetText(i, &bIsDefText);
					XString sText;
					if(bIsDefText && !IsAngular()) 
						sText << sDimPrefix << sText0 << sDimSuffix;
					else
						sText << sText0;

                    dimText.SetRotation(Wcs2Layout(nTextRot));
                    dimText.SetLocation(ptText);
                    if(bSelfDraw) {
						TPushProperty vProp(&dimText, dc);
                        dimText.SetText(sText);
						if(dc.IsFullExplode()) 
							dimText.ExplodeOrDraw2d(dc);
						else
							dc.DrawEntity(dimText);
                    }

                    if(bCheckDim && !bIsDefText) {
                        XString sCheckText(256);
                        sCheckText << _T("(");
						if(!IsAngular())
							sCheckText << sDimPrefix;
						sCheckText << GetDefaultText(i);
						if(!IsAngular())
							sCheckText << sDimSuffix;
						sCheckText << _T(")");
                        XPoint ptCheckText;
                        if(bIsDefPos) {
                            XPoint 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);
						{
						TPushProperty vProp(&dimText, dc);
						if(dc.IsFullExplode()) 
							dimText.ExplodeOrDraw2d(dc);
						else
							dc.DrawEntity(dimText);
						}
                        dimText.setColorIndex(dimclrt);
                    } // bCheckDim
                }
                dc.SetColor(nColorOld);
            } // g_bExplOsnap
        }
    }

    if(!bSelfDraw) {
        BOOL bDraw=(_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0);
        BOOL bExplode=(_tcscmp(dc.Desc(), XExplodeStream::Descriptor())==0);
        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(!bAngular) {
                XPoint pt1=segOnFix.StartPoint(), pt2=segOnFix.EndPoint();
                double nAng=NormalViewAngle(ads_angle(pt1, pt2));
                if(!CT_IsExactSameDrt(nAng, ads_angle(pt1, pt2), _angSnap))
                    TchPrivate::Exchange(pt1, pt2);
     	        pDim = new AcDbAlignedDimension(pt1, pt2, ptText);
            } else {
                XPoint ptCen=seg.GetArc().GetCenterPt();
                pDim = new AcDb3PointAngularDimension(ptCen, segOnFix.StartPoint(), segOnFix.EndPoint(), ptText);
            }
            TDimTextPos *pNode=((TDbDimension *)this)->m_lstTextPos.FindNode(&i, TDimTextPos::CompareByIndexForFind);
            if(pNode) {
                pDim->setTextPosition(pNode->ptPos);
                pDim->useSetTextPosition();
            }
            TDimTextContent *pNode1=((TDbDimension *)this)->m_lstTextContent.FindNode(&i, TDimTextContent::CompareByIndexForFind);
            if(pNode1) pDim->setDimensionText(pNode1->sText);
			AcDbObjectId idDimStyle=DimStyleTch2Acad(m_idDimStyle, GetPScale(), IsAngular(), database(), 0.0);
			pDim->setDimensionStyle(idDimStyle);
			pDim->setDimstyleData(idDimStyle);
            pDim->setPropertiesFrom(this);
            ((XExplodeStream &)dc).Append(pDim, FALSE);
        }
    }
    dc.SetColor(nColorOld);
    return Acad::eOk;
}



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

TEntityBase::DrawType 
TDbDimension::GetDrawType() const
{
    return TEntityBase::k2DOnly;
}

/* * * * * * * * * * 取 动 态 属 性 显 示 数 据 的 函 数 * * * * * * * * * */
void TDbDimension::GetTips(DList<TObjInfoUnit> &lstInfo) const
{
   lstInfo.Append(new TObjInfoUnit(_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 TObjInfoUnit(_T("子类型"), pSubType));
   lstInfo.Append(new TObjInfoUnit(_T("标注样式"), GetSymbolName(m_idDimStyle)));
   XString sDist;
   ftoa(fabs(m_nDist2DimLine), 1, sDist);
   sDist << _T("P");
   lstInfo.Append(new TObjInfoUnit(_T("尺寸线偏移"), sDist));
   if(!IsAngular()) {
       lstInfo.Append(new TObjInfoUnit(_T("旋转角度"), Angle2Str(m_nRotation*180/PI)));
   } else if(IsDimChord() || IsDimArcLen()) {
       lstInfo.Append(new TObjInfoUnit(_T("所注半径"), Dist2Str(m_nObjRadius)));
   }
}


//尺寸文字位置的自动调整
// 返回最后一个的调整结果
// 0--缺省, 1--上调, 2--下调, 3--侧调
// nFromUp--开始调整的状态,bAllowExt--是否允许外调,bAutoReset--无需调整的是否自动复位
int TDbDimension::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;
    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();
    OPENOBJ_END();
    if(!dimtxsty)
        return 0;

    int nRetCode=0;
    if(bAutoReset)
        m_lstTextPos.Reset();
    XCurveSegment cv=GetDimCurve(); 
    XPoly2D 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, TDimTextPos::CompareByIndexForFind))
                continue;

            XCurveSegment 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.XLine::Direction();
            XPoint ptFix;
            double nObj2Fix=segFix.GetArc().GetRadius()-segObj.GetArc().GetRadius();
            ads_polar(segObj.StartPoint(), nRot-PI/2, nObj2Fix, ptFix);
            TDbDimension objDim;
            objDim.setPropertiesFrom(this);
            objDim.SetLocation(ptFix);
            objDim.SetRotation(nRot);
            objDim.SetDist2DimLine(GetDist2DimLine());
            objDim.AppendSegment(segObj.GetArc().ChordLength());
            objDim.SetStyleId(GetStyleId());
            TDimTextContent *pNode=((TDbDimension *)this)->m_lstTextContent.FindNode(&i, TDimTextContent::CompareByIndexForFind);
            if(pNode) objDim.SetTextContent(0, pNode->sText);

            BOOL bUpAdj=bFromUp;
            if(!nCode)
                nCode=objDim.AdjustDim(bUpAdj, (i==0 || i==numSeg));
            BOOL bDef=TRUE;
            XPoint ptTextPos=objDim.GetTextPos(0, &bDef);
            if(!bDef)
                SetTextPos(i, ptTextPos);
        }
    } else { //直线标注或角度标注
        double nOffDist=m_nDist2DimLine*GetPScale();
        int numVert=poly.Length();
        DList<XLine> lstLineSet;
        for(int i=0; i<numVert; i++) {
            XPoint ptVert=*poly[i];
            double nPathDist=cv.PathDistance(ptVert);
            XPointDir2d ptVertDir;
            cv.Polar(nPathDist, ptVertDir);

            // 尺寸界限
            XPoint pt1, pt2;
            double nFactor=fabs(nOffDist)>_DIST_SNAP? nOffDist/fabs(nOffDist) : 1.0;
            ads_polar(ptVert, ptVertDir.nDirection-nFactor*PI/2, dimexe*dimscale/*fabs(nOffDist)-dimexo*dimscale*/, pt1);
            ads_polar(ptVert, ptVertDir.nDirection+nFactor*PI/2, dimexe*dimscale, pt2);
            lstLineSet.Append(new XLine(pt1, pt2));
        }


        double nTextHeight=dimtxt*dimscale;
        int numSeg=poly.TotalSegments();

        // 0--缺省, 1--上调, 2--下调, 3--外调
        TCHAR *pPosTable=new TCHAR [numSeg];
        for(i=0; i<numSeg; i++) {
            pPosTable[i]=0;
            if(!bAutoReset && m_lstTextPos.FindNode(&i, TDimTextPos::CompareByIndexForFind))
                continue;
            XCurveSegment seg;
            poly.Nth(i, seg);

            XPoint ptText=GetDefaultTextPos(i);
            XPoint ptTemp;
            XPointDir2d ptTempDir;
            cv.ProjectToMe(ptText, ptTemp);
            double nDist=cv.PathDistance(ptTemp);
            cv.Polar(nDist, ptTempDir);
            double nTextRot=NormalViewAngle(ptTempDir.nDirection);
            XString sText=GetText(i);
            TDbText text;
            text.setPropertiesFrom(this);
            text.SetText(sText);
            text.SetStyleId(dimtxsty);
            text.SetHeight(nTextHeight, FALSE);

            XPoint ptExt=text.GetExtents();
			//ptExt.y *= nEn2Ch;
            

            XLine lnUp, lnDown;
            XPoint ptMidRight;
            ads_polar(ptText, nTextRot, ptExt.x/2, ptMidRight);
            XPoint ptVert;
            ads_polar(ptMidRight, nTextRot+PI/2, ptExt.y/2, ptVert);
            lnUp.StartPoint()=ptVert;
            ads_polar(XPoint(ptVert), nTextRot+PI, ptExt.x, ptVert);
            lnUp.EndPoint()=ptVert;

            ads_polar(XPoint(ptVert), nTextRot-PI/2, ptExt.y, ptVert);
            lnDown.StartPoint()=ptVert;
            ads_polar(XPoint(ptVert), nTextRot, ptExt.x, ptVert);
            lnDown.EndPoint()=ptVert;

            XLine *ln1=lstLineSet[i];
            ln1->SetLineFlag(LS_FINITE);
            lnUp.SetLineFlag(LS_FINITE);
			lnDown.SetLineFlag(LS_FINITE);
            if(lnUp.Intersection(ln1, XPoint()) || lnDown.Intersection(ln1, XPoint())) {
                // 需要自调
                if(bAllowExt && (i==0 || i==numSeg-1)) { //侧调
                    XPointDir2d ptPosExt;
                    cv.Polar(-(ptExt.x/2+dimgap*nPScale), ptPosExt, i==0);
                    double nDirNext=NormalViewAngle(ptPosExt.nDirection)+PI/2;
                    XPoint ptTextPos;
                    ads_polar(ptPosExt, nDirNext, (dimgap+dimtxt*0.7)*nPScale, ptTextPos);
                    SetTextPos(i, ptTextPos);
                    pPosTable[i]=3;
                } else {
                    BOOL bPrevAdj=FALSE;
                    if(i>0 && pPosTable[i-1]!=0)
                        bPrevAdj=TRUE;
                    if(bPrevAdj) {
                        pPosTable[i]=0;
                    } else {
                        BOOL bUpAdj=bFromUp;
                        XPoint ptTextPos;
                        //double nFactor=fabs(nOffDist)>_DIST_SNAP? nOffDist/fabs(nOffDist) : 1.0;
                        XPointDir2d ptVertDir;
                        seg.Polar(seg.GetLength()/2, ptVertDir);
                        double nUpDir=NormalViewAngle(ptVertDir.nDirection);
                        if(bUpAdj) { //尺寸线方向外
                            ads_polar(ptVertDir, nUpDir+PI/2, 
							    (dimgap*2+dimtxt*1.5*0.7)*nPScale, ptTextPos);
                            pPosTable[i]=1;
                        } else {
                            ads_polar(ptVertDir, nUpDir-PI/2, 
							    (dimgap+dimtxt*0.5)*nPScale, ptTextPos);
                            pPosTable[i]=2;
                        }
                        SetTextPos(i, ptTextPos);
                    } 
                } 
            } else {
                pPosTable[i]=0;
            }
        }
        nRetCode=pPosTable[numSeg-1];
    }
    return nRetCode;
}

//取得尺寸线
XCurveSegment 
TDbDimension::GetDimCurve() const
{
    assertReadEnabled();
    ASSERT(IsValid());
    XPoint ptStart, ptEnd;
    double nDist=m_nDist2DimLine*GetPScale();
    ads_polar(m_ptLocation, m_nRotation+PI/2, nDist, ptStart);
    double nSweepAngle=0.0;
    if(IsAngular()) {
        XPoint ptCen;
        ads_polar(ptStart, m_nRotation+PI/2, m_nDimRadius, ptCen);
        nSweepAngle=GetTotalSegValue();
        if(fabs(nSweepAngle-2.0*PI)<_angSnap)
            nSweepAngle -= 2.0*_angSnap;
        double nEndAng=ads_angle(ptCen, ptStart)+nSweepAngle;
        ads_polar(ptCen, nEndAng, m_nDimRadius, ptEnd);
    } else {
        double nTotalDist=GetTotalSegValue();
        ads_polar(ptStart, m_nRotation, nTotalDist, ptEnd);
    }
    return XCurveSegment(ptStart, ptEnd, nSweepAngle);
}

void TDbDimension::GetPolySegOnDimLine(XPoly2D &poly) const
{
    assertReadEnabled();

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

    lstVert.AsPoly2D(poly);
}

int TDbDimension::HitTestOnDimSeg(XPoint pt) const
{
    XCurveSegment cv=GetDimCurve();
    XPoint ptOnDim;
    if(cv.ProjectToMe(pt, ptOnDim)!=RTNORM)
        return -1;
    XPoly2D poly;
    GetPolySegOnDimLine(poly);
    int nSeg=poly.TotalSegments();
    for(int i=0; i<nSeg; i++) {
        XCurveSegment seg;
        poly.Nth(i, seg);
        if((ptOnDim&seg)==PR_INSIDE)
            return i;
    }
    return -1;
}

int TDbDimension::HitTestOnText(XPoint pt) const
{
    int nSeg=m_lstSegment.Length();
    int nRet=-1;
    double nDistMin=0.0;
    for(int i=0; i<nSeg; i++) {
        XPoint 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 TDbDimension::HitTestOnPoint(XPoint&pt)const
{
    XCurveSegment cv=GetDimCurve();
    XPoint ptOnDim;
    if(cv.ProjectToMe(pt, ptOnDim)!=RTNORM)
        return -1;
	double nMaxDist=GetApertureWcs()/2;
    XPoly2D 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 TDbDimension::SwitchDimChord()
{
    if(!IsAngular())  
        return;
    BOOL bChord=IsDimChord();
    BOOL bArcLen=IsDimArcLen();
    if(!bChord && !bArcLen) { //角度
        XCurveSegment cv=GetDimCurve();
        XArc 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);
            XCurveSegment segObj;
            segObj=arDim;
            XPoint 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++) {
                TDimTextPos *pText=m_lstTextPos[i];
                XPoint ptOnObj;
                segObj.ProjectToMe(pText->ptPos, ptOnObj);
                ptOnObj.Mirror(XPoint(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 TDbDimension::RemoveZeroSegment()
{
    assertWriteEnabled();
    int nSeg=m_lstSegment.Length();
    double nPrec=IsAngular()? _angSnap : _DIST_SNAP;
    for(int i=0; i<nSeg; i++) {
			if(*m_lstSegment[i]<nPrec) {
            RemoveSegment(i);
            i--;
            nSeg--;
        }
    }
}

void TDbDimension::RemoveSegment(int iSeg)
{
    assertWriteEnabled();
    int nSeg=m_lstSegment.Length();
    ASSERT(iSeg>=0 && iSeg<nSeg);
    m_lstSegment.Remove(iSeg);
    
    if(m_lstTextPos.FindNode(&iSeg, TDimTextPos::CompareByIndexForFind))
        m_lstTextPos.Remove();
    int nTextSeg=m_lstTextPos.Length();
    for(int i=0; i<nTextSeg; i++) {
        TDimTextPos *pNode=m_lstTextPos[i];
        if(pNode->nIndex>iSeg)
            pNode->nIndex--;
    }

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

    AutoSetFlag();
}

void 
TDbDimension::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++) {
            TDimTextPos *pNode=m_lstTextPos[i];
            if(pNode->nIndex>=n)
                pNode->nIndex++;
        }

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

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

    AutoSetFlag();
}

void 
TDbDimension::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 TDbDimension::AddSegment(XPoint ptAdd)
{
    assertWriteEnabled();
    XCurveSegment cv=GetDimCurve();
    XPoint 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) 
	{
        XPoly2D poly;
        GetPolySegOnDimLine(poly);
        int nSeg=poly.TotalSegments();
        for(int n=0; n<nSeg; n++) 
		{
            XCurveSegment 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)) 
				{
                    TDimTextPos *pNode=m_lstTextPos.FindNode(&n, TDimTextPos::CompareByIndexForFind);
                    if(pNode) m_lstTextPos.Remove();
                    SetSegment(n, nVal1);
                    InsertSegmentAt(n, nVal);
                    bRet=TRUE;
                }
                break;
            }
        }
    } 
	else if(ptOnDim.Distance2d(cv.EndPoint()) < ptOnDim.Distance2d(cv.StartPoint())) 
	{
        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)) 
		{
            cv.SetPoints(ptOnDim, XPoint(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 TDbDimension::FindAndRemoveSegment(XPoint pt)
{
    XCurveSegment seg=GetDimCurve();
	XPoint ptOnSeg;
    seg.ProjectToMe(pt, ptOnSeg);
	double value=seg.PathDistance(ptOnSeg);
	long i=-1;
	if(value>_DIST_SNAP)
	{
		double curValue=0;
		for(i=0;i<GetSegmentNum();i++)
		{
			curValue+=GetSegment(i);
			if(fabs(curValue-value)<_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);
		XVector3D vt=seg.EndPoint()-seg.StartPoint();
		vt.Scale(temp/vt.Length());
		SetLocation(GetLocation()+vt);
	}
	return TRUE;
}
BOOL TDbDimension::MergeDim(const TDbDimension *pDim)
{
    assertWriteEnabled();
    if(!IsUseDefaultText())
        return FALSE;

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

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

    m_lstTextPos.Reset();
    m_lstSegment.Reset();
    XPoly2D polyNew;
    lstVert.AsPoly2D(polyNew);
    nSeg=polyNew.TotalSegments();
    for(i=0; i<nSeg; i++) {
        XCurveSegment seg;
        polyNew.Nth(i, seg);
        double nVal=seg.GetLength();
        ASSERT(nVal>_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 TDbDimension::ConvertFrom(const AcDbDimension *pDim)
{
    assertWriteEnabled();

    double nScale=100.0;
    AcDbObjectId idStyle=DimStyleAcad2Tch(pDim->dimensionStyle(), nScale);
    SetPScale(nScale);
    //double val;
    //VERIFY(pDim->measurement(val)==Acad::eOk);
    XString 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 TDimTextPos(0, XPoint(pDim->textPosition())));
    }
    m_lstTextContent.Reset();
    if(!!sText) 
        m_lstTextContent.Append(new TDimTextContent(0, sText));


    BOOL bRet=FALSE;
    if(pDim->isKindOf(AcDb2LineAngularDimension::desc())||
       pDim->isKindOf(AcDb3PointAngularDimension::desc())) {
        AcDb3PointAngularDimension *pDim1=AcDb3PointAngularDimension::cast(pDim);
        AcDb2LineAngularDimension *pDim2=AcDb2LineAngularDimension::cast(pDim);
        XPoint 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();
            XPoint qt1=pDim2->xLine1End(),
                qt2=pDim2->xLine2End();
			XLine ll(pt2, qt2);
            XLine(pt1, qt1).Intersection(&ll, 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;
        XArc arDim(ptCen, m_nDimRadius, ads_angle(ptCen, pt1), ads_angle(ptCen, pt2));
        XCurveSegment segDim;
        segDim=arDim;
        //XPoint 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);
        XPoint 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(!CT_IsSameDrt(ads_angle(pt1, pt2), pDim2->rotation(), _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);
        XPoint ptOnDim1, ptOnDim2;
		XLine ll(ptDim, m_nRotation);
        pt1.Project(&ll, ptOnDim1);
        pt2.Project(&ll, ptOnDim2);
        int nSide=XLine(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;
}



// Properties

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

double
TDbDimension::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 
TDbDimension::IsAngular() const
{
    return ((m_nDimFlag&DF_ANGULAR)!=0);
    //return (m_nDimRadius>_angSnap);
}

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

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

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

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

XPoint 
TDbDimension::GetLocation() const
{
    return m_ptLocation;
}

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

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

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

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

static void DelSuffixZero(TCHAR *sText)
{
	if(!sText)
		return;
	size_t nLen=_tcslen(sText);
	TCHAR *pDot=_tcschr(sText, _T('.'));
	if(pDot) {
		for(size_t i=nLen-1; i>=0; i--) {
			if(sText[i]!=_T('0')) {
				if(sText[i]==_T('.'))
					sText[i]=0;
				break;
			} else {
				sText[i]=0;
			}
		}
	}
}

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

    int dimdec, dimadec;
    double dimlfac=1.0;
    int dimaunit=0;
	int dimzin=0;
	int dimazin=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();
    if(dimaunit>1)
        dimaunit=1;
    OPENOBJ_END();

    XString sText;
    if(IsAngular()) {
        if(IsDimChord()) {
            ASSERT(0); //永远也不会执行这儿
            ftoa(seg.XLine::GetLength()*dimlfac, dimdec, sText);
        } else if(IsDimArcLen()) {
            XArc ar=seg.GetArc();
            ar.SetRadius(m_nObjRadius);
            ftoa(ar.GetLength()*dimlfac, dimdec, sText);
        } else {
            XString sTemp;
            ads_angtos(fabs(seg.GetBulge()), dimaunit, dimadec, sTemp);
            const TCHAR *pd=_tcschr(sTemp, _T('d'));
            if(pd) {
                StrCpy(sText, sTemp, pd);
                sText << _T("%%d");
                sText << (pd+1);
            } else if(dimaunit==0) {
				if(dimazin&0x02)
					DelSuffixZero(sTemp);
                sText << sTemp << _T("%%d");
            }else {
                sText << sTemp;
            }
        }
    } else {
        ftoa(seg.GetLength()*dimlfac, dimdec, sText);
		if((dimzin&0x08)!=0) {
			DelSuffixZero(sText);
		}
    }
    return sText;
}

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

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

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

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

    BOOL bAngular=IsAngular();
    int nSeg=poly.TotalSegments();
    XCurveSegment seg;
    poly.Nth(nIndex, seg);
    ASSERT(!!seg);

    XPointDir2d ptTextPos;
    seg.Polar(seg.GetLength()/2.0, ptTextPos);
    XPoint 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();
    XPoint ptBase;
    if(IsAngular() && IsDimChord()) {
        Midpoint(seg.StartPoint(), seg.EndPoint(), ptBase);
    } else {
        ptBase=ptTextPos;
    }
    ads_polar(ptBase, NormalViewAngle(ptTextPos.nDirection)+PI/2.0, nDist2Dim, ptText);
    return ptText;
}


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


void 
TDbDimension::SetLocation(XPoint pt)
{
    assertWriteEnabled();
    m_ptLocation=pt;
	m_ptLocation.z=0;
}

void 
TDbDimension::SetRotation(double nAng)
{
    assertWriteEnabled();
    m_nRotation=nAng;
}

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


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

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

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

void 
TDbDimension::SetObjRadius(double nVal)
{
    assertWriteEnabled();
    m_nObjRadius = nVal;
}


void 
TDbDimension::SetDimRadius(double nAng)
{
    assertWriteEnabled();
    m_nDimRadius=nAng;
}

void 
TDbDimension::SetStyleId(AcDbObjectId idStyle)
{
    assertWriteEnabled();
    m_idDimStyle=idStyle;
}

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

void TDbDimension::SetTextContent(int n, const TCHAR *pszChar)
{
    assertWriteEnabled();
    ASSERT(n<m_lstSegment.Length() && n>=0);
    TDimTextContent *pNode=m_lstTextContent.FindNode(&n, TDimTextContent::CompareByIndexForFind);
    if(!pNode) {
        if(pszChar && pszChar[0])
            m_lstTextContent.Append(new TDimTextContent(n, pszChar));
    } else {
        if(!pszChar || !pszChar[0])
            m_lstTextContent.Remove();
        else
            pNode->sText=pszChar;
    }
    AutoSetFlag();
}

void TDbDimension::SetBindId(AcDbObjectId id)
{
    assertWriteEnabled();
    m_idBind=id;
    AutoSetFlag();
}

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

void 
TDbDimension::ResetTextPos()
{
    assertWriteEnabled();
    m_lstTextPos.Reset();
    AutoSetFlag();
}

void 
TDbDimension::ResetTextContent()
{
    assertWriteEnabled();
    m_lstTextContent.Reset();
    AutoSetFlag();
}


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

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

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

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

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

void TDbDimension::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;

}

/////////////////////////////////////////////////////////////
// 新尺寸对象类
/////////////////////////////////////////////////////////////
//TArch7-1,
const Adesk::UInt8 TDbDimension2::g_nVersion = 1;

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

IMPLEMENT_TENTBASE(TDbDimension2);

//BOOL TDbDimension2::g_bExplAcadDim=TRUE;

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


TDbDimension2::~TDbDimension2()
{
}

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

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

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

void TDbDimension2::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
{
    assertWriteEnabled();
	double nOldScale=GetPScale();
	double nDimDist=GetDist2DimLine(FALSE);
    TDbCurveEntity::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
    TDbDimension2 *pSrc=TDbDimension2::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
TDbDimension2::subGetClassID(CLSID* pClsid) const
{
    return Acad::eOk;
}



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

   Acad::ErrorStatus es = TDbCurveEntity::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 TDimTextPos(nIndex, XPoint(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++) {
            XString sText;
            Adesk::UInt16 nIndex;
            pFiler->readItem(&nIndex);
            ReadString(pFiler, sText);
            m_lstTextContent.Append(new TDimTextContent(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 TDbDimension2::dwgOutFields(AcDbDwgFiler* pFiler) const
{
   assertReadEnabled();
   Acad::ErrorStatus es = TDbCurveEntity::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 TDimTextPos &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 TDimTextContent &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 TDbDimension2::dxfInFields (AcDbDxfFiler* pFiler)
{
    assertWriteEnabled();

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

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

    return pFiler->filerStatus();

   // 不读入任何数据
}

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

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

   
   return es;
}

 

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

Acad::ErrorStatus
TDbDimension2::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();
        XCurveSegment cv=GetDimCurve();
        XCurveSegment cvFix=cv.Offset(nOffDist, LS_FINITE);
        XPoly2D poly;
        GetPolySegOnDimLine(poly);

        if(osnapMode==AcDb::kOsModeNode) {
            int nVertNum=poly.Length();
            for(int i=0; i<nVertNum; i++) {
                XPoint 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++) {
                XPoint ptText = GetTextPos(i);
                snapPoints.append(ptText);
            }
        }
                                  }
        break;
    default: {
        //XPushMemVar<BOOL> vTemp(g_bExplAcadDim, FALSE);
        TDbCurveEntity::subGetOsnapPoints(osnapMode, gsSelectionMark, pickPoint,
                              lastPoint, viewXform, snapPoints,
                              geomIds);
             }
        return Acad::eOk;
    }

    return es;
}

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

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

    for(int i=0; i<nVertNum; i++) 
	{
        XPoint 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++) 
	{
        XPoint ptText = GetTextPos(i);
        gripPoints.append(ptText);
    }


    if(IsAngular() && (IsDimChord() || IsDimArcLen())) 
        gripPoints.append(m_ptLocation);
	else if(!IsAngular()&&IsAssociate())
	{
		XCurveSegment 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;
}

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

    return subGetGripPoints(stretchPoints, osnapModes, geomIds);
}


void TDbDimension2::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 TDbDimension2::subTransformBy(const AcGeMatrix3d& xform)
{
    assertWriteEnabled();
	TDbCurveEntity::subTransformBy(xform);
    ads_matrix mat;
    AsAdsMatrix(xform, mat);
    for(int i=0; i<m_lstTextPos.Length(); i++) {
        m_lstTextPos[i]->ptPos.TransformBy(mat);
    }

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

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

    return Acad::eOk;
}

//设置尺寸线位置
BOOL TDbDimension2::SetDimLinePos(XPoint pt)
{
	assertWriteEnabled();
	BOOL bRet=FALSE;
        XCurveSegment seg=GetDimCurve();
        XPoint 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>_DIST_SNAP) {
                    SetDimRadius(nDistRad);
                    SetDist2DimLine(nDist2Dim, FALSE);
                }
            } else {
                nDist2Dim += nDistMove; 
                SetDist2DimLine(nDist2Dim, FALSE);
            }
			bRet=TRUE;
        }

		return bRet;
}

//设置标注固定线位置
BOOL TDbDimension2::SetFixLinePos(XPoint pt)
{
	assertWriteEnabled();

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

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

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

}

// 功能: 夹点操作, 还没有完全考虑圆弧类型
Acad::ErrorStatus TDbDimension2::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;
    XCurveSegment cv=GetDimCurve();
    cv.SetPoints(XPoint(gripPoints[0]), XPoint(gripPoints[1]));
    XPoint ptS, ptE;
    XPoint 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()<_DIST_SNAP)
        return Acad::eInvalidInput;
    XSortedVertexList lstVert(cv);
    for(i=1; i<nVertNum-1; i++) {
        XPoint ptFix=gripPoints[2+i];
        XPoint ptOnDim;
        if(cv.ProjectToMe(ptFix, ptOnDim)==RTNORM) {
            lstVert.Insert(ptOnDim);
        }
    }
    XPoly2D poly;
    lstVert.AsPoly2D(poly);

    m_lstSegment.Reset();
    int nSeg=poly.TotalSegments();
    for(i=0; i<nSeg; i++) {
        XCurveSegment 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???
        XLine ln(cv.StartPoint(), cv.IDirection(0)+PI/2);
        XPoint ptNewLoc=m_ptLocation + XPoint(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, TDimTextPos::CompareByIndexForFind))
                SetTextPos(i, gripPoints[nGripIndex]);
        }
    } else {
        m_lstTextPos.Reset();
        m_lstTextContent.Reset();
    }
    AutoSetFlag();

    return Acad::eOk;
}


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

    assertWriteEnabled();

    XPoint vtOffset=*(XPoint *)&offset;
    vtOffset.z=0;
    XPoly2D poly, polyNew;
    GetPolySegOnDimLine(poly);
    polyNew=poly;
    XCurveSegment cv=GetDimCurve();
    double nOffDist=m_nDist2DimLine*GetPScale();
    XCurveSegment cvFix=cv.Offset(nOffDist, LS_FINITE);
    XCurveSegment 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) 
		{ //改变尺寸线位置
            XPoint ptVert=idx==0? *poly.Head() : *poly.Tail();
            double nExtDir=idx==0? cv.IDirection(0) : cv.IDirection(1);
            XLine lnExt(ptVert, nExtDir+PI/2);
            XPoint ptOnExt=ptVert + vtOffset;
            XPoint(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)>_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<_DIST_SNAP) 
				{
                    m_nDist2DimLine=nOldDist2DimLine;
                    m_nDimRadius=nOldDimRadius;
                } 
            }
        } 
		else if(idx<poly.Length()+2) 
		{ //改变定位点或区间
			int ndx=idx-2;
			XPoint 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_bStetchEntity&&GetCtrlToggle())
			{
				if(!AddSegment(ptGrip)&&GetSegmentNum()>1)
					FindAndRemoveSegment(ptGrip0);
			}
			else
			{
				XPoint ptOnDim;
				BOOL bGreatPrev=FALSE, bLessNext=FALSE;
				if(cv.ProjectToMe(ptGrip, ptOnDim)==RTNORM) 
				{
					if(vtIdx>0)
					{
						double nPathDist=cv.PathDistance(ptOnDim); //小于0时,为圆弧标注
						if(IsAngular() && nPathDist<-_DIST_SNAP) 
						{
							if(vtIdx==polyNew.Length()-1)
								nPathDist=cv.GetArc().XCircle::GetLength()+nPathDist;
						}
						double nPathDistPrev=cv.PathDistance(*polyNew[vtIdx-1]);
						bGreatPrev = (nPathDist-nPathDistPrev)>-_DIST_SNAP;
					} 
					else 
						bGreatPrev=TRUE;
					if(vtIdx<polyNew.Length()-1) 
						bLessNext = (cv.PathDistance(ptOnDim)-cv.PathDistance(*polyNew[vtIdx+1]))<_DIST_SNAP;
					else bLessNext=TRUE;
					if(bGreatPrev && bLessNext) 
					{
						if(vtIdx==0) 
						{
							XCurveSegment seg;
							polyNew.Nth(0, seg);
							seg.SetPoints(ptOnDim, seg.EndPoint());
							if(IsAngular() && (IsDimChord() || IsDimArcLen()))
							{
								XArc ar=seg.GetArc();
								XCircle cir(ar.GetCenterPt(), ads_distance(ar.GetCenterPt(), m_ptLocation));
								XPoint 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);
							XCurveSegment 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, XPoint(seg.EndPoint()));
							segPrev.SetPoints(XPoint(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())) 
								{
									//改标注半径
									XArc arDim=cv.GetArc();
									arDim.SetRadius(m_nObjRadius);
									XCurveSegment cvObj;
									cvObj=arDim;
									XPoint 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()) 
			{
                XPoint ptText = GetTextPos(nSeg);
                ptText += vtOffset;
                SetTextPos(nSeg, ptText);
            }
			else 
			{
                if(IsAngular() && (IsDimChord() || IsDimArcLen()))
				{
					XLine ln(cv.StartPoint(), cv.IDirection(0)+PI/2);
					XPoint 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())
				{
					XPoint ptEnd;
					ads_polar(m_ptLocation,m_nRotation,1,ptEnd);
					XCurveSegment curve(m_ptLocation,ptEnd,0);

					XPoint 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 TDbDimension2::subMoveStretchPointsAt(
    const AcDbIntArray& indices,
    const AcGeVector3d& offset)
{
    int nCount=indices.length();
	XPushMemVar<BOOL> vTemp(g_bStetchEntity,TRUE);
    return subMoveGripPointsAt(indices, offset);
}

// 取得夹点说明
Acad::ErrorStatus TDbDimension2::GetGripText(int i, CString &cs) const
{
    Acad::ErrorStatus es=Acad::eOk;
    XPoly2D 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 TDbDimension2::ConvertText(TConvertTextPtr ptr, void *pData)
{
    assertWriteEnabled();
    int nLen=m_lstTextContent.Length();
    int nCode=RTNONE;
    for(int i=0; i<nLen; i++) {
        TDimTextContent *pContent=m_lstTextContent[i];
        XString sText;
        int nRet=ptr(pContent->sText, sText, pData);
        if(nRet==RTERROR)
            nCode=nRet;
        else if(nRet==RTNORM)
            pContent->sText=sText;
    }
     return nCode;
}


// 返回发现的位置，同时posStart往前移动(以便继续找下一个使用),
TTextPosition  
TDbDimension2::FindSubText(const TCHAR *sSubText, TTextPosition &posStart, TTextRange *pRange) const
{
	assertReadEnabled();
	TTextPosition 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;
	TTextPosition posNext=posStart;
    for(int i=posStart.m_nCookies; i<nLen; i++) {
        //TDimTextContent content=m_lstTextContent[i];
		XString sTextDim=GetText(i);
        TDbText dimText;
        dimText.setPropertiesFrom(this);
        dimText.SetAlignment(XExplodeDraw::kMiddleCenter);
        dimText.SetHeight(dimtxt);
        dimText.SetStyleId(idTextStyle);
		dimText.SetText(sTextDim);
		dimText.SetLocation(GetTextPos(i));
		posNext.m_nCookies=i;

		TTextPosition 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;
}

// 返回下一次查找的开始位置
TTextPosition  
TDbDimension2::ReplaceSubText(const TTextPosition &posRep, const TCHAR *sRepText, TTextRange *pRange)
{
	assertWriteEnabled();
	TTextPosition 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;

    //TDimTextContent *pContent=m_lstTextContent[posRep.m_nCookies];
	XString sTextDim=GetText(posRep.m_nCookies);
    TDbText dimText;
    dimText.setPropertiesFrom(this);
    dimText.SetAlignment(XExplodeDraw::kMiddleCenter);
    dimText.SetHeight(dimtxt);
    dimText.SetStyleId(idTextStyle);
	dimText.SetText(sTextDim);
	dimText.SetLocation(GetTextPos(posRep.m_nCookies));

	TTextPosition 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 
TDbDimension2::subSetAttributes(AcGiDrawableTraits * traits)
{
    Adesk::UInt32 nRet=TDbCurveEntity::subSetAttributes(traits);
    //if(g_nAcadVer<15.0001)
    //    nRet |= kDrawableIsCompoundObject;
    return nRet;
}
TSubText* TDbDimension2::GetSubText(long iText)const
{
	XPushMemVar<BOOL> bExpl(g_bSelfDrawDim, TRUE);
	TSubText*pSubText=TDbCurveEntity::GetSubText(iText);
	if(pSubText!=NULL)
		pSubText->SetMenuType(6);
	return pSubText;
}
TSubText* TDbDimension2::HitTestText(XPoint pt)const
{
	XPushMemVar<BOOL> bExpl(g_bSelfDrawDim, TRUE);
	TSubText*pSubText=TDbCurveEntity::HitTestText(pt);
	if(pSubText!=NULL)
		pSubText->SetMenuType(6);
	return pSubText;
}
Acad::ErrorStatus TDbDimension2::GetExtents2d(XPoint &ptLow, XPoint &ptUp) const
{
	AcDbExtents ext;
	Acad::ErrorStatus es=getGeomExtents(ext);
	ptLow=ext.minPoint();
	ptUp=ext.maxPoint();
	return es;
}
Acad::ErrorStatus 
TDbDimension2::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
	assertReadEnabled();
	BOOL bIsDefText;
	// modify by xlc on 101209 效率低，减少执行次数，解决多视口图纸切换运行慢的问题
	XPoly2D poly;
	GetPolySegOnDimLine(poly);

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

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

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

	// modified by whl on 060223
	// BOOL bCheckDim=DocGetCheckDim();
	BOOL bCheckDim=DocGetCheckDim()&&!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_bSelfDrawDim);
	BOOL bQuickMode=(bDraw && !ownerId() && m_lstSegment.Length()>=g_nDimNumGripTip);
	if (g_bDisableQuickMode)
		bQuickMode=FALSE;
	
	// modify by xlc on 101209 提前了
//   XPoly2D poly;
//	 GetPolySegOnDimLine(poly);
 
	BOOL bAngular=IsAngular();
	BOOL bSelfDraw=(g_bOsnapExpl || bDraw ||  //g_bExpOtherDb ||
		(IsAngular() && (IsDimChord() || IsDimArcLen()))
		);
    if (bSelfDraw || bCheckDim)
	{
		dc.SetAlignment(XExplodeDraw::kMiddleCenter);

		XString 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)
			{
				StrCpy(sDimPrefix, dimpost, pStr);
				StrCpy(sDimSuffix, pStr+2, NULL);
			}
			else if (dimpost)
			{
				_tcscpy(sDimSuffix, dimpost);
			}
		}
		else 
		{
			return Acad::eInvalidInput;
		}
		OPENOBJ_END();

        XCurveSegment cv = GetDimCurve(); 
        BOOL bDimArcLen = (IsAngular() && IsDimArcLen());
		if (bDimArcLen) // 弧长标注
		{
			int numSeg = poly.TotalSegments();
			for (int i=0; i<numSeg; i++)
			{
				XCurveSegment 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);

				XPoint ptAr1, ptAr2; // 弧长两端的标注点
				double nChorldDir = segObj.XLine::Direction();
				XLine ln1(segObj.GetStartPoint(), nChorldDir+PI/2.0), 
					ln2(segObj.GetEndPoint(), nChorldDir+PI/2.0);
				XPoint 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 = XLine(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 = XLine(ptInt[0], ptInt[1]).NearPoint(segDim.StartPoint());

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

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

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

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

						XPointDir2d 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);
						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);
						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;

						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();
					}
				}

				// 尺寸界限
				XPoint pt1, pt2;
				double nFactor = fabs(nOffDist)>_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);
				}
				dc << XLine(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);
				}
				dc << XLine(pt1, pt2);
				dc.SetColor(nColorOld);

				// 尺寸文字
				if (bQuickMode)
					;
				else if (!g_bOsnapExpl)
				{
					TDbText dimText;
					dimText.setPropertiesFrom(this);
					dimText.SetAlignment(XExplodeDraw::kMiddleCenter);
					dimText.SetHeight(dimtxt);
					dimText.SetStyleId(idTextStyle);
					dimText.setColorIndex(dimclrt);

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

					// modify by xlc on 101209 解决速度慢问题
					//XPoint ptText=GetTextPos(i, &bIsDefPos);
					XPoint ptText = GetTextPos(i, poly, &bIsDefPos);
					XPoint ptTemp;
					XPointDir2d 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 解决速度慢问题
					//XString sText0=GetText(i, &bIsDefText);
					XString sText0 = GetText(i, poly, &bIsDefText);

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

						XPoint ext = dimText.GetExtents();
						XPoint 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(XPoint(ptS), nTextRot+PI/2, ext.y/2, ptS);
						ads_polar(XPoint(ptE), nTextRot+PI/2, ext.y/2, ptE);
						dc << XArc(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 + _DIST_SNAP)
						{
							if (dimclrd) // 使用尺寸线的颜色
								dc.SetColor(dimclrd);

							XPoint 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);

							XPoint 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);

							XPoint ptLeader2 = XLine(ptLeaderS, ptLeaderE).NearPoint(ptLeader1);
							dc << XLine(ptLeader1, ptLeader2);
							dc << XLine(ptLeaderS, ptLeaderE);
						}
					}

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

						XPoint ptCheckText;
						if (bIsDefPos)
						{
							XPoint 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);
						{
							TPushProperty vProp(&dimText, dc);
							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()) // 弦长标注
		{
			XPushMemVar<BOOL> tVar1(g_bDisableQuickMode, TRUE);
			int numSeg = poly.TotalSegments();
			for (int i=0; i<numSeg; i++)
			{
				XCurveSegment 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.XLine::Direction();
				XPoint ptFix;
				double nObj2Fix=segFix.GetArc().GetRadius()-segObj.GetArc().GetRadius();
				ads_polar(segObj.StartPoint(), nRot-PI/2, nObj2Fix, ptFix);

				TDbDimension2 objDim;
				objDim.setPropertiesFrom(this);
				objDim.SetLocation(ptFix);
				objDim.SetRotation(nRot);
				objDim.SetDist2DimLine(GetDist2DimLine());
				objDim.AppendSegment(segObj.GetArc().ChordLength());
				objDim.SetStyleId(GetStyleId());

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

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

				if (IsAngular())
					dc << poly;
				else
				{
					XPoint ptStart,ptEnd;
					ads_polar(*poly[0],m_nRotation+PI,dimdle*dimscale,ptStart);
					dc << XLine(ptStart,*poly[0]);

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

					dc<<poly;
				}
				// dc << cv;

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

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

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

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

							XPointDir2d 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++;
                            }
                            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;

                            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();
                        }
                    }

                    // 尺寸界限
                    XPoint pt1, pt2;
                    double nFactor = fabs(nOffDist)>_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);
					
					dc<<XLine(pt1,pt2);
                }
            }

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

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

					XPoint ptTemp;
					XPointDir2d 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 解决速度慢问题
					//XString sText0=GetText(i, &bIsDefText);
					XString sText0 = GetText(i, poly, &bIsDefText);
					XString sText;
					if (bIsDefText && !IsAngular()) 
						sText << sDimPrefix << sText0 << sDimSuffix;
					else
						sText << sText0;

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

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

					// sg add 120413，增加文字不在默认位置时候的引线
					if (nDimTextMovePos!=2 && !bIsDefPos) // 在线旁和有引线，暂时都用通一种表示方法
					{
						XPoint 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 + _DIST_SNAP > dMixLeaderDis)
						{
							ads_polar(ptDimPos, nTextRot+PI/2,ddimgap, ptDimPos);
							XPoint 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;
							}
							XPoint 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 = XLine(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 = XLine(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;
							}

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

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


					if (bCheckDim && !bIsDefText) // 尺寸检查
					{
						XString 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(")");

						XPoint ptCheckText;
						if (bIsDefPos)
						{
							XPoint 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);
						{
							TPushProperty vProp(&dimText, dc);
							if (dc.IsFullExplode())
								dimText.ExplodeOrDraw2d(dc);
							else
								dc.DrawEntity(dimText);
						}
						dimText.setColorIndex(dimclrt);
					} // bCheckDim && !bIsDefText
				} // for

				dc.SetColor(nColorOld);
			} // !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 = DimStyleTch2Acad(m_idDimStyle, dPScale, IsAngular(), database(), dTxtHeight);	

		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 (!bAngular)
			{
				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 (!CT_IsExactSameDrt(nAng, ads_angle(pt1, pt2), _angSnap))
					TchPrivate::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; // 标记是否需要单独修改“文字偏移”
			TDimTextPos *pNode = ((TDbDimension2 *)this)->m_lstTextPos.FindNode(&i, TDimTextPos::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)
					{
						StrCpy(sDimPrefix, dimpost, pStr);
						StrCpy(sDimSuffix, pStr+2, NULL);
					}
					else if (dimpost)
					{
						_tcscpy(sDimSuffix, dimpost);
					}
				}
				OPENOBJ_END();

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

				XPointDir2d 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 + _DIST_SNAP) // 有引线
					{
						TDbText 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;
						XString sText0 = GetText(i, poly, &bIsDefText),
							sText;
						if (bIsDefText && !IsAngular()) 
							sText << sDimPrefix << sText0 << sDimSuffix;
						else
							sText << sText0;
						dimText.SetText(sText);

						XPoint ptExt = dimText.GetExtents();

						XPoint ptDim1, ptDim2;
						ads_polar(ptDimPos, dTextRot, -ptExt.x*0.5, ptDim1);
						ads_polar(ptDimPos, dTextRot, ptExt.x*0.5, ptDim2);
						ptDimPos = XLine(ptDim1, ptDim2).NearPoint(ptText);
					}
				}
				if (bAngular && nDimTextMovePos!=2)
				{
					//pDim->setTextRotation(dTextRot);
				}
				*/
				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 =  nPScale*(dimgap + dimtxt*0.5);
					if (ptDimPos.Distance2d(ptTempPos) + _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) > _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
			((XExplodeStream &)dc).Append(pDim, FALSE);
		}
	}
    dc.SetColor(nColorOld);
    return Acad::eOk;
}

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

TEntityBase::DrawType 
TDbDimension2::GetDrawType() const
{
    return TEntityBase::k2DOnly;
}

/* * * * * * * * * * 取 动 态 属 性 显 示 数 据 的 函 数 * * * * * * * * * */
void TDbDimension2::GetTips(DList<TObjInfoUnit> &lstInfo) const
{
   lstInfo.Append(new TObjInfoUnit(_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 TObjInfoUnit(_T("子类型"), pSubType));
   lstInfo.Append(new TObjInfoUnit(_T("标注样式"), GetSymbolName(m_idDimStyle)));
   XString sDist;
   ftoa(fabs(m_nDist2DimLine), 1, sDist);
   sDist << _T("P");
   lstInfo.Append(new TObjInfoUnit(_T("尺寸线偏移"), sDist));
   if(!IsAngular()) {
       lstInfo.Append(new TObjInfoUnit(_T("旋转角度"), Angle2Str(m_nRotation*180/PI)));
   } else if(IsDimChord() || IsDimArcLen()) {
       lstInfo.Append(new TObjInfoUnit(_T("所注半径"), Dist2Str(m_nObjRadius)));
   }
}





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(XCurveSegment seg, AcDbObjectId idStyle, double dHeight, double dLayoutRotation);

	// 向数组中添加标注信息段
	void	AppendDim(const TCHAR* pszDimText, const TCHAR* pszText, XPoint 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(XPoint pt, XPointDir2d &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:
	XCurveSegment	m_segDim;
	AcDbObjectId	m_idTextStyle;
	double			m_dTextHeight;
	double			m_dLayoutRotation;
	double			m_d_DIST_SNAP;//判断文字重合间隙 
};

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

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

	XPoint 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, XPoint pt)
{
	SDimInfo dim;
	dim.nYLoc = 1;
	dim.dDimText = _tstof(pszDimText);

	XPointDir2d ptDir;
	GetDimPathDist(pt, ptDir);

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

	XPoint 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 + _DIST_SNAP) ? dDist2 : dDist1; // 较小的作为起点
	dim.dELoc = (dDist1 > dDist2 + _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 = TchExport::AngleRangeTo2PI(dAngWcs - m_dLayoutRotation),
		dSnap = 1.0E-1,
		dAng1 = TchExport::AngleRangeTo2PI(dAng);//double dSnap = 1.0E-9, 9.0beta1 
	if (GreatThan(dAng1, PI/2.0, dSnap) && LessThan(dAng1, PI, dSnap))
	{
		dAng1 += PI;
	}
	else if (GreatEqual(dAng1, PI, dSnap) && LessEqual(dAng1, PI*1.5, dSnap))
	{
		dAng1 -= PI;
	}
	dAng = dAng1;
	dAng = TchExport::AngleRangeTo2PI(m_dLayoutRotation + dAng);
	return dAng;
}

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


//尺寸文字位置的自动调整
// 返回最后一个的调整结果
// 0--缺省, 1--上调, 2--下调, 3--侧调
// nFromUp--开始调整的状态,bAllowExt--是否允许外调,bAutoReset--无需调整的是否自动复位
int TDbDimension2::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();

	XCurveSegment cv = GetDimCurve(); 
	XPoly2D 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, TDimTextPos::CompareByIndexForFind))
				continue;

			XCurveSegment 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.XLine::Direction();
			XPoint ptFix;
			double nObj2Fix=segFix.GetArc().GetRadius()-segObj.GetArc().GetRadius();
			ads_polar(segObj.StartPoint(), nRot-PI/2, nObj2Fix, ptFix);
			TDbDimension2 objDim;
			objDim.setPropertiesFrom(this);
			objDim.SetLocation(ptFix);
			objDim.SetRotation(nRot);
			objDim.SetDist2DimLine(GetDist2DimLine());
			objDim.AppendSegment(segObj.GetArc().ChordLength());
			objDim.SetStyleId(GetStyleId());
			TDimTextContent *pNode=((TDbDimension2 *)this)->m_lstTextContent.FindNode(&i, TDimTextContent::CompareByIndexForFind);
			if(pNode) objDim.SetTextContent(0, pNode->sText);

			BOOL bUpAdj=bFromUp;
			if(!nCode)
				nCode=objDim.AdjustDim(bUpAdj, (i==0 || i==numSeg));
			BOOL bDef=TRUE;
			XPoint ptTextPos=objDim.GetTextPos(0, &bDef);
			if(!bDef)
				SetTextPos(i, ptTextPos);
		}
	} 
	//else // 直线标注或角度标注
	//{
	//	double nOffDist = m_nDist2DimLine*GetPScale();

	//	DList<XLine> lstLineSet;
	//	int numVert = poly.Length();
	//	for (int i=0; i<numVert; i++)
	//	{
	//		XPoint ptVert = *poly[i];
	//		double nPathDist = cv.PathDistance(ptVert);
	//		XPointDir2d ptVertDir;
	//		cv.Polar(nPathDist, ptVertDir);

	//		// 尺寸界限
	//		XPoint pt1, pt2;
	//		double nFactor = fabs(nOffDist)>_DIST_SNAP? nOffDist/fabs(nOffDist) : 1.0;
	//		ads_polar(ptVert, ptVertDir.nDirection-nFactor*PI/2, dimexe*dimscale/*fabs(nOffDist)-dimexo*dimscale*/, pt1);
	//		ads_polar(ptVert, ptVertDir.nDirection+nFactor*PI/2, dimexe*dimscale, pt2);
	//		lstLineSet.Append(new XLine(pt1, pt2));
	//	}

	//	double nTextHeight = dimtxt*dimscale;
	//	int numSeg = poly.TotalSegments();

	//	// 0--缺省, 1--上调, 2--下调, 3--外调
	//	TCHAR *pPosTable = new TCHAR [numSeg];
	//	for (i=0; i<numSeg; i++)
	//	{
	//		pPosTable[i] = 0;
	//		if (!bAutoReset && m_lstTextPos.FindNode(&i, TDimTextPos::CompareByIndexForFind))
	//			continue;

	//		XCurveSegment seg;
	//		poly.Nth(i, seg);

	//		XPoint ptText = GetDefaultTextPos(i);
	//		XPoint ptTemp;
	//		XPointDir2d 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);
	//		XString sText = GetText(i);

	//		TDbText text;
	//		text.setPropertiesFrom(this);
	//		text.SetText(sText);
	//		text.SetStyleId(dimtxsty);
	//		text.SetHeight(nTextHeight, FALSE);

	//		XPoint ptExt = text.GetExtents();
	//		//ptExt.y *= nEn2Ch;

	//		XLine lnUp, lnDown;
	//		XPoint ptMidRight;
	//		ads_polar(ptText, nTextRot, ptExt.x/2, ptMidRight);
	//		XPoint ptVert;
	//		ads_polar(ptMidRight, nTextRot+PI/2, ptExt.y/2, ptVert);
	//		lnUp.StartPoint() = ptVert;
	//		ads_polar(XPoint(ptVert), nTextRot+PI, ptExt.x, ptVert);
	//		lnUp.EndPoint() = ptVert;

	//		ads_polar(XPoint(ptVert), nTextRot-PI/2, ptExt.y, ptVert);
	//		lnDown.StartPoint() = ptVert;
	//		ads_polar(XPoint(ptVert), nTextRot, ptExt.x, ptVert);
	//		lnDown.EndPoint() = ptVert;

	//		XLine *ln1 = lstLineSet[i];
	//		ln1->SetLineFlag(LS_FINITE);
	//		lnUp.SetLineFlag(LS_FINITE);
	//		lnDown.SetLineFlag(LS_FINITE);
	//		if (lnUp.Intersection(ln1, XPoint()) || lnDown.Intersection(ln1, XPoint()))
	//		{
	//			// 需要自调
	//			if (bAllowExt && (i==0 || i==numSeg-1)) // 侧调
	//			{
	//				XPointDir2d ptPosExt;
	//				cv.Polar(-(ptExt.x/2+dimgap*nPScale), ptPosExt, i==0);

	//				// sg modify 120410，使用新增加的接口，代替基类中的NormalViewAngle函数，主要解决精确度是1度的问题
	//				// double nDirNext=NormalViewAngle(ptPosExt.nDirection)+PI/2;
	//				double nDirNext = ChangeToNormalViewAngle(ptPosExt.nDirection)+PI/2;
	//				XPoint ptTextPos;
	//				ads_polar(ptPosExt, nDirNext, (dimgap+dimtxt*0.7)*nPScale, ptTextPos);
	//				SetTextPos(i, ptTextPos);
	//				pPosTable[i] = 3;
	//			}
	//			else 
	//			{
	//				BOOL bPrevAdj = FALSE;
	//				if (i>0 && pPosTable[i-1]!=0)
	//					bPrevAdj = TRUE;
	//				if (bPrevAdj)
	//				{
	//					pPosTable[i] = 0;
	//				}
	//				else
	//				{
	//					BOOL bUpAdj = bFromUp;
	//					XPoint ptTextPos;
	//					//double nFactor = fabs(nOffDist)>_DIST_SNAP? nOffDist/fabs(nOffDist) : 1.0;
	//					XPointDir2d ptVertDir;
	//					seg.Polar(seg.GetLength()/2, ptVertDir);

	//					// sg modify 120410，使用新增加的接口，代替基类中的NormalViewAngle函数，主要解决精确度是1度的问题
	//					// double nUpDir = NormalViewAngle(ptVertDir.nDirection);
	//					double nUpDir = ChangeToNormalViewAngle(ptVertDir.nDirection);
	//					if(bUpAdj) // 尺寸线方向外
	//					{
	//						ads_polar(ptVertDir, nUpDir+PI/2, (dimgap*2+dimtxt*1.5*0.7)*nPScale, ptTextPos);
	//						pPosTable[i]=1;
	//					} 
	//					else
	//					{
	//						ads_polar(ptVertDir, nUpDir-PI/2, (dimgap+dimtxt*0.5)*nPScale, ptTextPos);
	//						pPosTable[i]=2;
	//					}
	//					SetTextPos(i, ptTextPos);
	//				} 
	//			} 
	//		} 
	//		else 
	//		{
	//			pPosTable[i] = 0;
	//		}
	//	}
	//	nRetCode = pPosTable[numSeg-1];
	//}
	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++)
		{
			XPoint ptText = GetDefaultTextPos(nCur);		// 文字默认位置点
			XString sDefaultText = GetDefaultText(nCur),	// 文字默认内容
				sText = GetText(nCur);						// 文字实际注写的内容
			dimAdjust.AppendDim(sDefaultText, sText, ptText);
		}

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

		XPoint ptTextPos;
		XPointDir2d ptVertDir;
		for (nCur=0; nCur<nSegNums; nCur++)
		{
			if (!bAutoReset && m_lstTextPos.FindNode(&nCur, TDimTextPos::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;
			}

			XCurveSegment 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;
}

//取得尺寸线
XCurveSegment 
TDbDimension2::GetDimCurve() const
{
    assertReadEnabled();
    //ASSERT(IsValid());
    XPoint ptStart, ptEnd;
    double nDist=m_nDist2DimLine*GetPScale();
    ads_polar(m_ptLocation, m_nRotation+PI/2, nDist, ptStart);
    double nSweepAngle=0.0;
    if(IsAngular()) {
        XPoint ptCen;
        ads_polar(ptStart, m_nRotation+PI/2, m_nDimRadius, ptCen);
        nSweepAngle=GetTotalSegValue();
        if(fabs(nSweepAngle-2.0*PI)<_angSnap)
            nSweepAngle -= 2.0*_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 XCurveSegment(ptStart, ptEnd, nSweepAngle);
}

void TDbDimension2::GetPolySegOnDimLine(XPoly2D &poly) const
{
    assertReadEnabled();

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

    lstVert.AsPoly2D(poly);
}
AcDbCurve* TDbDimension2::GetBaseCurve()const
{
	assertReadEnabled();
	XPoly2D poly;
	GetPolySegOnDimLine(poly);
	return poly.AsAcDbCurve();
}
Acad::ErrorStatus TDbDimension2::SetBaseCurve(AcDbCurve*pCurve)
{
	assertWriteEnabled();

	XPoly2D poly;
	if(poly.SetAcDbCurve(pCurve)&&poly.Length()>1)
	{
		XPoint ptFirst=*poly.Head(),ptLast=*poly.Tail();
		XCurveSegment cvOld=GetDimCurve();
		XPoly2D 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])));

			XCurveSegment 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)>_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)>_DIST_SNAP)//在新终点之后
					FindAndRemoveSegment(*polyOld[i]);
				else
					break;
			}
			AddSegment(ptLast);
		}

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

int TDbDimension2::HitTestOnText(XPoint pt) const
{
    int nSeg=m_lstSegment.Length();
    int nRet=-1;
    double nDistMin=0.0;
    for(int i=0; i<nSeg; i++) {
        XPoint 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 TDbDimension2::HitTestOnPoint(XPoint&pt)const
{
    XCurveSegment cv=GetDimCurve();
    XPoint ptOnDim;
    if(cv.ProjectToMe(pt, ptOnDim)!=RTNORM)
        return -1;
	double nMaxDist=GetApertureWcs()/2;
    XPoly2D 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 TDbDimension2::SwitchDimChord()
{
    if(!IsAngular())  
        return;
    BOOL bChord=IsDimChord();
    BOOL bArcLen=IsDimArcLen();
    if(!bChord && !bArcLen) { //角度
        XCurveSegment cv=GetDimCurve();
        XArc 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);

            XCurveSegment segObj;
            segObj=arDim;
            XPoint 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++) {
                TDimTextPos *pText=m_lstTextPos[i];
                XPoint ptOnObj;
                segObj.ProjectToMe(pText->ptPos, ptOnObj);
                ptOnObj.Mirror(XPoint(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 TDbDimension2::RemoveZeroSegment()
{
    assertWriteEnabled();
    int nSeg=m_lstSegment.Length();
    double nPrec=IsAngular()? _angSnap : _DIST_SNAP;
    for(int i=0; i<nSeg; i++) {
			if(*m_lstSegment[i]<nPrec) {
            RemoveSegment(i);
            i--;
            nSeg--;
        }
    }
}

void TDbDimension2::RemoveSegment(int iSeg)
{
    assertWriteEnabled();
    int nSeg=m_lstSegment.Length();
    ASSERT(iSeg>=0 && iSeg<nSeg);
    m_lstSegment.Remove(iSeg);
    
    if(m_lstTextPos.FindNode(&iSeg, TDimTextPos::CompareByIndexForFind))
        m_lstTextPos.Remove();
    int nTextSeg=m_lstTextPos.Length();
    for(int i=0; i<nTextSeg; i++) {
        TDimTextPos *pNode=m_lstTextPos[i];
        if(pNode->nIndex>iSeg)
            pNode->nIndex--;
    }

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

    AutoSetFlag();
}

void 
TDbDimension2::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++) {
            TDimTextPos *pNode=m_lstTextPos[i];
            if(pNode->nIndex>=n)
                pNode->nIndex++;
        }

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

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

    AutoSetFlag();
}

void 
TDbDimension2::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 TDbDimension2::AddSegment(XPoint ptAdd)
{
    assertWriteEnabled();
    XCurveSegment cv=GetDimCurve();
    XPoint 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)
		{
			XPoly2D poly;
			GetPolySegOnDimLine(poly);
			int nSeg=poly.TotalSegments();
			for(int n=0; n<nSeg; n++) {
				XCurveSegment 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)) {
						TDimTextPos *pNode=m_lstTextPos.FindNode(&n, TDimTextPos::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, XPoint(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 TDbDimension2::FindAndRemoveSegment(XPoint pt)
{
	if(GetSegmentNum()<1)
		return FALSE;

    XCurveSegment seg=GetDimCurve();
	XPoint ptOnSeg;
    seg.ProjectToMe(pt, ptOnSeg);
	double value=seg.PathDistance(ptOnSeg);
	long i=-1;
	if(value>_DIST_SNAP)
	{
		double curValue=0;
		for(i=0;i<GetSegmentNum();i++)
		{
			curValue+=GetSegment(i);
			if(fabs(curValue-value)<_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);
		XVector3D vt=seg.EndPoint()-seg.StartPoint();
		vt.Scale(temp/vt.Length());
		SetLocation(GetLocation()+vt);
	}
	return TRUE;
}
BOOL TDbDimension2::FindPoint(XPoint pt)const
{
    XCurveSegment cv=GetDimCurve();
    XPoint ptOnDim;
    if(cv.ProjectToMe(pt, ptOnDim)!=RTNORM)
        return FALSE;

	double nMaxDist=1E-3;
    XPoly2D 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 TDbDimension2::GetMaxScope()const
{
	if(m_lstOffset.Length()>0)
		return m_lstOffset[0];
	else
		return 20;
}
BOOL TDbDimension2::UpdateFrom(XPoint ptNew0,XPoint ptNew1,XPoint ptOld0,XPoint 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;
	
	XCurveSegment curve1=GetDimCurve();
	XCurveSegment curve2;
	if(m_nDist2DimLine>0)
		curve2=curve1.Offset((m_nDist2DimLine+GetMaxScope())*GetPScale(),0);
	else
		curve2=curve1.Offset((m_nDist2DimLine-GetMaxScope())*GetPScale(),0);
	XPoly2D 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
			{
				XPoint ptLocation0=m_ptLocation;
				AddSegment(ptNew0);
				AddSegment(ptNew1);
				if(GetSegmentNum()>oldSegNum)
					FindAndRemoveSegment(ptLocation0);
			}
		}
	}
	return TRUE;
}
BOOL TDbDimension2::MergeDim(const TDbDimension2 *pDim)
{
    assertWriteEnabled();
    if(!IsUseDefaultText())
        return FALSE;

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

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

    m_lstTextPos.Reset();
    m_lstSegment.Reset();
    XPoly2D polyNew;
    lstVert.AsPoly2D(polyNew);
    nSeg=polyNew.TotalSegments();
    for(i=0; i<nSeg; i++) {
        XCurveSegment seg;
        polyNew.Nth(i, seg);
        double nVal=seg.GetLength();
        ASSERT(nVal>_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 TDbDimension2::ConvertFrom(const AcDbDimension *pDim)
{
    assertWriteEnabled();

    double nScale=100.0;
    AcDbObjectId idStyle=DimStyleAcad2Tch(pDim->dimensionStyle(), nScale);
    SetPScale(nScale);
    //double val;
    //VERIFY(pDim->measurement(val)==Acad::eOk);
    XString 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 TDimTextPos(0, XPoint(pDim->textPosition())));
    }
    m_lstTextContent.Reset();
    if(!!sText) 
        m_lstTextContent.Append(new TDimTextContent(0, sText));


    BOOL bRet=FALSE;
    if(pDim->isKindOf(AcDb2LineAngularDimension::desc())||
       pDim->isKindOf(AcDb3PointAngularDimension::desc())) {
        AcDb3PointAngularDimension *pDim1=AcDb3PointAngularDimension::cast(pDim);
        AcDb2LineAngularDimension *pDim2=AcDb2LineAngularDimension::cast(pDim);
        XPoint 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();
            XPoint qt1=pDim2->xLine1End(),
                qt2=pDim2->xLine2End();
			XLine ll(pt2, qt2);
            XLine(pt1, qt1).Intersection(&ll, 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;
        XArc arDim(ptCen, m_nDimRadius, ads_angle(ptCen, pt1), ads_angle(ptCen, pt2));
        XCurveSegment segDim;
        segDim=arDim;
        //XPoint 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);
        XPoint 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(!CT_IsSameDrt(ads_angle(pt1, pt2), pDim2->rotation(), _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);
        XPoint ptOnDim1, ptOnDim2;
		XLine ll(ptDim, m_nRotation);
        pt1.Project(&ll, ptOnDim1);
        pt2.Project(&ll, ptOnDim2);
        int nSide=XLine(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 TDbDimension2::ConvertFrom(const TDbDimension *pDim)
{
	assertWriteEnabled();
	TDbDimension2::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++)
	{
		TDimTextPos *pNew=new TDimTextPos;
		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++)
	{
		TDimTextContent *pNew=new TDimTextContent;
		pNew->nIndex=pDim->m_lstTextContent[i].nIndex;
		pNew->sText=pDim->m_lstTextContent[i].sText;
		m_lstTextContent.Append(pNew);
	}
	return TRUE;
}
Acad::ErrorStatus TDbDimension2::DownGradeSave(int nDrawMode, AcDbVoidPtrArray &entSet, BOOL *bErase)
{
	Acad::ErrorStatus es=Acad::eOk;
	if(g_nSaveTArchVer>=GetFirstVersion())
	{
		if(bErase)
			*bErase=FALSE;
	}
	else if(IsValid())
	{
		TDbDimension* pDim=new TDbDimension;
		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++)
		{
			TDimTextPos *pNew=new TDimTextPos;
			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++)
		{
			TDimTextContent *pNew=new TDimTextContent;
			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 TDbDimension2::GetSegment(int n, BOOL bDist) const
{
    ASSERT(n>=0 && n<m_lstSegment.Length());
    double nVal=m_lstSegment[n];
    if(IsAngular() && bDist) {
        ASSERT(m_nDimRadius>_DIST_SNAP);
        nVal *= m_nDimRadius;
    }
    return nVal;
}

double
TDbDimension2::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 
TDbDimension2::IsAngular() const
{
    return ((m_nDimFlag&DF_ANGULAR)!=0);
    //return (m_nDimRadius>_angSnap);
}
BOOL 
TDbDimension2::IsAssociate() const
{
    return ((m_nDimFlag&DF_ASSOCIATE)!=0);
}
void 
TDbDimension2::SetAssociate(BOOL bTrue)
{
    assertWriteEnabled();
	if(bTrue) 
		m_nDimFlag |= DF_ASSOCIATE;
	else 
		m_nDimFlag &= ~DF_ASSOCIATE;
}

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

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

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

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

XPoint 
TDbDimension2::GetLocation() const
{
    return m_ptLocation;
}

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

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

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

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


// Modify on 2002/02/05, 考虑dimlfac进行单位换算
XString
TDbDimension2::GetDefaultText(int nIndex) const
{
    ASSERT(nIndex<m_lstSegment.Length() && nIndex>=0);   
    XPoly2D poly;
    GetPolySegOnDimLine(poly);
    XCurveSegment 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();

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

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

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

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

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

    BOOL bAngular=IsAngular();
    int nSeg=poly.TotalSegments();
    XCurveSegment seg;
    poly.Nth(nIndex, seg);
    ASSERT(!!seg);
    XPointDir2d ptTextPos;
    seg.Polar(seg.GetLength()/2.0, ptTextPos);
    XPoint 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();
    XPoint 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 解决多视口图纸切换速度慢的问题
XString
TDbDimension2::GetDefaultText(int nIndex, XPoly2D poly) const
{
	ASSERT(nIndex<m_lstSegment.Length() && nIndex>=0);   
	//	XPoly2D poly;
	//	GetPolySegOnDimLine(poly);
	XCurveSegment 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();

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

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

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

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

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

	BOOL bAngular=IsAngular();
	int nSeg=poly.TotalSegments();
	XCurveSegment seg;
	poly.Nth(nIndex, seg);
	ASSERT(!!seg);
	XPointDir2d ptTextPos;
	seg.Polar(seg.GetLength()/2.0, ptTextPos);
	XPoint 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();
	XPoint 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 TDbDimension2::ChangeToNormalViewAngle(double nAngWcs) const
{
	double dAng = Wcs2Layout(nAngWcs);
	// 下面这段代码，用于替换TchPrivate::ChangeAngleTo1_4里的精确度，其实功能是一样的
	{
		double dSnap = 1.0E-3,
			dAng1 = TchExport::AngleRangeTo2PI(dAng); //double dSnap = 1.0E-9, 9.0beta1 
		
		if (GreatThan(dAng1, PI/2.0, dSnap) && LessThan(dAng1, PI, dSnap))
		{
			dAng1 += PI;
		}
		else if (GreatEqual(dAng1, PI, dSnap) && LessEqual(dAng1, PI*1.5, dSnap))
		{
			dAng1 -= PI;
		}

		dAng = dAng1;
	}

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

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


void 
TDbDimension2::SetLocation(XPoint pt)
{
    assertWriteEnabled();
    m_ptLocation=pt;
	m_ptLocation.z=0;
}

void 
TDbDimension2::SetRotation(double nAng)
{
    assertWriteEnabled();
    m_nRotation=nAng;
}

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


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

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

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

void 
TDbDimension2::SetObjRadius(double nVal)
{
    assertWriteEnabled();
    m_nObjRadius = nVal;
}


void 
TDbDimension2::SetDimRadius(double nAng)
{
    assertWriteEnabled();
    m_nDimRadius=nAng;
}

void 
TDbDimension2::SetStyleId(AcDbObjectId idStyle)
{
    assertWriteEnabled();
	m_idDimStyle = idStyle;
}

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

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

	//wlw add 13.06.22 增加对等式的智能判断
	XString 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 = GetText(n).cs();
		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;


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

void TDbDimension2::SetBindId(AcDbObjectId id)
{
    assertWriteEnabled();
    m_idBind=id;
    AutoSetFlag();
}

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

void 
TDbDimension2::ResetTextPos()
{
    assertWriteEnabled();
    m_lstTextPos.Reset();
    AutoSetFlag();
}

void 
TDbDimension2::ResetTextContent()
{
    assertWriteEnabled();
    m_lstTextContent.Reset();
    AutoSetFlag();
}


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

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

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

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

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

void TDbDimension2::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 TDbDimension2::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 TDbDimension2::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 TDbCurveEntity::getSplitCurves(params,curveSegments);
	}
}
Acad::ErrorStatus TDbDimension2::getSplitCurves (const AcGePoint3dArray& points,
												 AcDbVoidPtrArray& curveSegments) const
{
	assertReadEnabled();
	if (IsAngular() || IsDimArcLen())
	{
		int nlen = points.length();
		XPoint ptOnDim;
		XPoint ptPick, ptPick2;
		TDbDimension2 *pDimClone = (TDbDimension2 *)clone(); 
		getClosestPointTo(points[0], ptPick);
		pDimClone->AddSegment(ptPick);
		if (nlen > 1)
		{
			getClosestPointTo(points[1], ptPick2);
			pDimClone->AddSegment(ptPick2);
		}

		XPoly2D poly;
		pDimClone->GetPolySegOnDimLine(poly);
		int nSeg= -1;
		int nSeg2= -1;
		for(int i=0; i<poly.TotalSegments(); i++) 
		{
			XCurveSegment 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++) 
			{
				XCurveSegment 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;
			}
		}


		XDirectionCurve seg;
		XPoint ptLoc;
		TDbDimension2 *pDimNew2=(TDbDimension2 *)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)
		{
			TDbDimension2 *pDimNew3=(TDbDimension2 *)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);

		TDbDimension2 *pDimNew=(TDbDimension2 *)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 TDbCurveEntity::getSplitCurves(points,curveSegments);
	}
}





///////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////
// 尺寸对象类
/////////////////////////////////////////////////////////////
const Adesk::UInt8 TDbRadiusDim::g_nVersion = 1;

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

IMPLEMENT_TENTBASE(TDbRadiusDim);


TDbRadiusDim::TDbRadiusDim()
{
    m_nDimFlag=0;
    m_nDimLen=26.0;
}


TDbRadiusDim::~TDbRadiusDim()
{
}

BOOL TDbRadiusDim::IsValid() const
{
    BOOL bRet=TDbEntity::IsValid();
    return bRet;
}

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

}

void TDbRadiusDim::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
{
    assertWriteEnabled();
    TDbEntity::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
    TDbRadiusDim *pSrc=TDbRadiusDim::cast(pSrcEntity);
    if(pSrc) {
		if(database()==NULL||
		   pSrcEntity->database()==NULL||
		   database()==pSrcEntity->database())//add by whl on 060317
		{
			m_idDimStyle=pSrc->m_idDimStyle; //尺寸标注类型
		}
    }
}


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

   Acad::ErrorStatus es = TDbEntity::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(&m_nDimFlag);
    pFiler->readItem(&m_idDimStyle);
    pFiler->readItem(&m_nDimLen);
    pFiler->readItem((AcGePoint3d *)&m_ptCenter); 
    pFiler->readItem((AcGePoint2d *)&m_ptOnArc); 
    m_sText=_T("");
    if(m_nDimFlag&DF_TEXT)
        ReadString(pFiler, m_sText);
    if(m_nDimFlag&DF_POSITION)
        pFiler->readItem((AcGePoint2d *)&m_ptText);
   return pFiler->filerStatus();
}

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

    pFiler->writeItem(g_nVersion);
    pFiler->writeItem(m_nDimFlag); 
    pFiler->writeItem(m_idDimStyle);
    pFiler->writeItem(m_nDimLen);
    pFiler->writeItem((const AcGePoint3d &)m_ptCenter); 
    pFiler->writeItem((const AcGePoint2d &)m_ptOnArc); 
    if(m_nDimFlag&DF_TEXT)
        pFiler->writeString(m_sText);
    if(m_nDimFlag&DF_POSITION)
        pFiler->writeItem((const AcGePoint2d &)m_ptText);
    return pFiler->filerStatus();
}

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

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

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

    XString sText, sName;
    double nDist;
	int nFlag;
	XPoint pt1, pt2, pt3;
    Adesk::UInt32 fieldsFlags = 0;
	resbuf rb;
    while ((es == Acad::eOk)
        && ((es = pFiler->readResBuf(&rb)) == Acad::eOk))    {
        switch (rb.restype) {
		case AcDb::kDxfInt16:
			nFlag=rb.resval.rint;
			fieldsFlags |= 0x01;
			break;
		case AcDb::kDxfXCoord:
			pt1=rb.resval.rpoint;
			fieldsFlags |= 0x02;
			break;
		case AcDb::kDxfXCoord+1:
			pt2=rb.resval.rpoint;
			fieldsFlags |= 0x04;
			break;
		case AcDb::kDxfXCoord+5:
			pt3=rb.resval.rpoint;
			fieldsFlags |= 0x08;
			break;
        case AcDb::kDxfText:
            fieldsFlags |= 0x10;
            sText = rb.resval.rstring;
            break;    
        case AcDb::kDxfDimStyleName:
            sName=rb.resval.rstring;
            fieldsFlags |= 0x20;
            break;
        case AcDb::kDxfReal:
            fieldsFlags |= 0x40;
            nDist = rb.resval.rreal;
            break;    
            //fall through intentional
        default:
            // An unrecognized group. Push it back so that
            // the subclass can read it again.
            pFiler->pushBackItem();
            es = Acad::eEndOfFile;
            break;
        }
    }

    // At this point the es variable must contain eEndOfFile
    // - either from readResBuf() or from pushback. If not,
    // it indicates that an error happened and we should
    // return immediately.
    //
    if (es != Acad::eEndOfFile)
        return Acad::eInvalidResBuf;

    if (!(fieldsFlags & 0x02)) {
        pFiler->setError(Acad::eMissingDxfField,
            _T("\nMissing DXF group code: 10"));
        return Acad::eMissingDxfField;
	}
    if (!(fieldsFlags & 0x04)) {
        pFiler->setError(Acad::eMissingDxfField,
            _T("\nMissing DXF group code: 11"));
        return Acad::eMissingDxfField;
	}
    if (!(fieldsFlags & 0x08)) {
        pFiler->setError(Acad::eMissingDxfField,
            _T("\nMissing DXF group code: 15"));
        return Acad::eMissingDxfField;
	}

    if(fieldsFlags&0x01)
		m_nDimFlag=nFlag;
	m_ptCenter=pt1;
	m_ptText=pt2;
	m_ptOnArc=pt3;

	if(fieldsFlags&0x10)
		m_sText=sText;
	AcDbObjectId id;
    if(fieldsFlags&0x20) {
		id=TchExport::GetDimStyleId(sName);
	}
	if(!id) {
		XString style;
		xg_getvar(_T("DIMSTYLE"), style);
		m_idDimStyle = TchExport::GetTextStyleId(style);
	} else
		m_idDimStyle=id;

	if(fieldsFlags&0x40)
		m_nDimLen=nDist;

    return pFiler->filerStatus();
}

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

   es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbRadiusDim"));
   assert(es == Acad::eOk);
   pFiler->writeInt16(AcDb::kDxfInt16, m_nDimFlag);
   pFiler->writePoint2d(AcDb::kDxfXCoord, m_ptCenter.AsAcGePoint2d());
   pFiler->writePoint2d(AcDb::kDxfXCoord+1, m_ptText.AsAcGePoint2d());
   pFiler->writePoint2d(AcDb::kDxfXCoord+5, m_ptOnArc.AsAcGePoint2d());
   pFiler->writeString(AcDb::kDxfText, (const TCHAR *)m_sText);
   XString sName=GetSymbolName(m_idDimStyle);
   pFiler->writeString(AcDb::kDxfDimStyleName, (const TCHAR *)sName); //3
   pFiler->writeDouble(AcDb::kDxfReal, m_nDimLen);
   return pFiler->filerStatus();
}



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

Acad::ErrorStatus
TDbRadiusDim::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:
        snapPoints.append(m_ptOnArc);
        break;
    case AcDb::kOsModeIns:      {
        XPoint ptText = GetTextPos();
        snapPoints.append(ptText);
                                }
        break;
    default: 
        es=TDbEntity::subGetOsnapPoints(osnapMode, gsSelectionMark, pickPoint,
                              lastPoint, viewXform, snapPoints,
                              geomIds);
    }

    return es;
}

// Overriden functions for edit
// to do:
// 允许通过夹点改变边界
Acad::ErrorStatus TDbRadiusDim::subGetGripPoints(AcGePoint3dArray&  gripPoints,
                                             AcDbIntArray&  osnapModes,
                                             AcDbIntArray&  geomIds) const
{
    assertReadEnabled();
    gripPoints.append(m_ptCenter); //0
    XPoint ptFix=GetDimStartPoint();
    gripPoints.append(ptFix); //1
    gripPoints.append(m_ptOnArc); //2
    XPoint ptText=GetTextPos(); //3
    gripPoints.append(ptText);
    return Acad::eOk;
}

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



// Active when being rotated, scaled, moved, etc.
// Scale is disabled here
Acad::ErrorStatus TDbRadiusDim::subTransformBy(const AcGeMatrix3d& xform)
{
    assertWriteEnabled();
	TDbEntity::subTransformBy(xform);
    ads_matrix mat;
    AsAdsMatrix(xform, mat);
    m_ptCenter.TransformBy(mat);
    m_ptOnArc.TransformBy(mat);
    BOOL bIsDefault=TRUE;
    XPoint ptText=GetTextPos(&bIsDefault);
    if(!bIsDefault) {
        ptText.TransformBy(mat);
        SetTextPos(ptText);
    }
    return Acad::eOk;
}



// 功能: 夹点操作
Acad::ErrorStatus TDbRadiusDim::subMoveGripPointsAt(
    const AcDbIntArray& indices,
    const AcGeVector3d& offset)
{
    assertWriteEnabled();
    if(offset.length()<_DIST_SNAP)
		return Acad::eOk;
    XPoint vtOffset(offset[0], offset[1]);
    AcGePoint3dArray ptArray;
    XPoint ptFix=GetDimStartPoint();
    for (int i = 0; i < indices.length(); i++) {
        int idx = indices[i];
        switch(idx) {
        case 0: 
            m_ptCenter += vtOffset;
            break;
        case 1:
            ptFix += vtOffset;
            break;
        case 2:
            m_ptOnArc += vtOffset;
            break;
        case 3: {
            XPoint ptText=GetTextPos();
            ptText += vtOffset;
            SetTextPos(ptText);
                }
            break;
        default:
            break;
        }
    }
    if(indices.contains(1)) {
        XLine ln(m_ptCenter, m_ptOnArc);
        XPoint ptOnLine;
        ptFix.Project(&ln, ptOnLine);
        double nDist=ptOnLine.Distance2d(m_ptOnArc);
        if((ptOnLine&ln)==PR_EXTEND && 
            ptOnLine.Distance2d(ln.EndPoint())<ptOnLine.Distance2d(ln.StartPoint())) {
            nDist = -nDist;
        }
        SetDimLen(nDist, FALSE);
    }
    return Acad::eOk;
}


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

// 取得夹点说明
Acad::ErrorStatus TDbRadiusDim::GetGripText(int i, CString &cs) const
{
    Acad::ErrorStatus es=Acad::eOk;
    switch(i) {
    case 0:
        cs=_T("移动圆心");
        break;
    case 1:
        cs=_T("移动引线位置");
        break;
    case 2:
        cs=_T("移动标注点");
        break;
    case 3:
        cs=_T("移动文字");
        break;
    default:
        es=Acad::eInvalidInput;
    }
    return es;
}

Acad::ErrorStatus 
TDbRadiusDim::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
    assertReadEnabled();

	//modified by whl on 060223
    //BOOL bCheckDim=DocGetCheckDim();
    BOOL bCheckDim=DocGetCheckDim()&&!g_bExplodeSubText;

    double nPScale=GetPScale();
    double nArrowLen=2.0;
    double nArrowWidth=0.66;
    double dimgap=0, dimtxt=0;
    double dimscale=1.0, dimasz=1.0;
    int dimclrd=0, dimclrt=0;
    int dimdec=0;
    double dimlfac=1.0; //单位换算系数；
	XString sDimPrefix, sDimSuffix;
    AcDbObjectId dimblk;
    AcDbObjectId dimtxsty;
    OPENOBJ_BEGIN(m_idDimStyle, AcDb::kForRead, AcDbDimStyleTableRecord, pDimStyle);
    if(pDimStyle) {
        dimdec=pDimStyle->dimdec();
        dimgap=pDimStyle->dimgap();
        dimtxt=pDimStyle->dimtxt();
        dimscale=GetPScale(); //pDimStyle->dimscale();
        dimasz=pDimStyle->dimasz();
        dimtxsty=pDimStyle->dimtxsty();
		dimblk=pDimStyle->dimblk();
        dimlfac=pDimStyle->dimlfac();
        //sTextStyle=GetSymbolName(dimtxsty);
        dimclrd=pDimStyle->dimclrd().colorIndex();
        dimclrt=pDimStyle->dimclrt().colorIndex();
			const TCHAR *dimpost=pDimStyle->dimpost();
			const TCHAR *pStr=NULL;
			if(dimpost)
				pStr=_tcsstr(dimpost, _T("<>"));
			if(pStr) {
				StrCpy(sDimPrefix, dimpost, pStr);
				StrCpy(sDimSuffix, pStr+2, NULL);
			} else if(dimpost) {
				_tcscpy(sDimSuffix, dimpost);
			}
    } else {
        return Acad::eInvalidInput;
    }
    OPENOBJ_END();

    int nOldColor=dc.GetColor();    
    AcDbPolyline pline;
    XPoint ptStart=GetDimStartPoint();
    XPoint ptEnd=GetDimEndPoint();

    if(!IsDiameter()) 
	{
        XPoint ptArrow;
        ads_polar(ptEnd, ads_angle(ptEnd, ptStart), nArrowLen*nPScale, ptArrow);
		pline.addVertexAt(0, ptStart);
        pline.addVertexAt(1, ptArrow);
        pline.addVertexAt(2, ptEnd);
		 /*pline.setWidthsAt(1, nArrowWidth*nPScale, 0.0);*/

		//TGGeCurveSegment(const TADSGePoint3d &spt, const TADSGePoint3d &ept, ads_real dAng, int flg = LS_FINITE);
		XCurveSegment segDim(ptStart, ptEnd, 0, LS_FINITE);
       
		//支持箭头的更改
		if (!dimblk)  // 尺寸箭头
		{
			// sg modify 120412，解决“实心闭合”样式，不支持设置“箭头大小”的问题
			double dXSize = 1.0*dimscale*dimasz,
				dYSize = 0.33*dimscale*dimasz;

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

			XPointDir2d pt1, pt2; 
			segDim.Polar(dXSize, pt1);
			segDim.Polar(dXSize, pt2, FALSE);

			AcDbPolyline plArrow2;
			plArrow2.setPropertiesFrom(this);
			plArrow2.addVertexAt(0, pt2);
			plArrow2.setWidthsAt(0, dYSize, 0.0);
			plArrow2.addVertexAt(1, segDim.EndPoint());
			plArrow2.setWidthsAt(1, 0.0, 0.0);
			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;

			OPENOBJ_BEGIN(dimblk, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
			if (pBlock)
			{
				dc.DrawBlock(*pBlock, ptEnd, AcGeScale3d(dimscale*dimasz, dimscale*dimasz, dimscale*dimasz), 
					segDim.IDirection(0), bNewMethod);
			OPENOBJ_END();
			}
		}
	}
	else 
	{
		//直径标注
		double nAng=ads_angle(m_ptOnArc, m_ptCenter);
		XPoint ptOnArc0, ptArrow0, ptArrow;
		ads_polar(m_ptCenter, nAng, GetRadius(), ptOnArc0);
		ads_polar(ptOnArc0, nAng+PI, nArrowLen*nPScale, ptArrow0);
		ads_polar(m_ptOnArc, nAng, nArrowLen*nPScale, ptArrow);

		pline.addVertexAt(0, ptOnArc0);
		//pline.addVertexAt(1, ptArrow0);
		//pline.addVertexAt(2, ptArrow);
		pline.addVertexAt(1, m_ptOnArc);
		//pline.setWidthsAt(0, 0.0, nArrowWidth*nPScale);
		//pline.setWidthsAt(2, nArrowWidth*nPScale, 0.0);
		if(m_nDimLen<0) { //外标注
		    XPoint ptStart=GetDimStartPoint();
		    pline.addVertexAt(2, ptStart);
		}

		XCurveSegment segDim(ptOnArc0, m_ptOnArc, 0, LS_FINITE);
		//支持箭头的更改
		if (!dimblk)  // 尺寸箭头
		{
			// sg modify 120412，解决“实心闭合”样式，不支持设置“箭头大小”的问题
			double dXSize = 1.0*dimscale*dimasz,
				dYSize = 0.33*dimscale*dimasz;

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

			XPointDir2d pt1, pt2; 
			segDim.Polar(dXSize, pt1);
			segDim.Polar(dXSize, pt2, FALSE);

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

			AcDbPolyline plArrow2;
			plArrow2.setPropertiesFrom(this);
			plArrow2.addVertexAt(0, pt2);
			plArrow2.setWidthsAt(0, dYSize, 0.0);
			plArrow2.addVertexAt(1, segDim.EndPoint());
			plArrow2.setWidthsAt(1, 0.0, 0.0);
			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;

			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();
		}
	}
    pline.setPropertiesFrom(this);
    if(dimclrd && dimclrd!=256)
        pline.setColorIndex(dimclrd);
    
    if(_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0) {
        XAcGiViewDraw &dcView=(XAcGiViewDraw &)dc;
        if(dcView.m_pWd) 
			pline.worldDraw(dcView.m_pWd);
        else 
			pline.viewportDraw(dcView.m_pVd);
    } else if(_tcscmp(dc.Desc(), XExplodeStream::Descriptor())==0) {
        ((XExplodeStream &)dc).Append((AcDbPolyline *)pline.clone());
    } else {
        if(dimclrd) dc.SetColor(dimclrd);
        XPoly2D poly;
        PolyConvert(pline, poly);
        dc << poly;
    }


    // 文字
    TDbText dimText;
    dimText.setPropertiesFrom(this);
    dimText.SetAlignment(XExplodeDraw::kMiddleCenter);
    dimText.SetHeight(dimtxt);
    dimText.SetStyleId(dimtxsty);
    if(dimclrt) dimText.setColorIndex(dimclrt);    

    BOOL bIsDefPos=TRUE;
    XPoint ptText=GetTextPos(&bIsDefPos);
    double nTextRot=NormalViewAngle(ads_angle(ptStart, ptEnd));
    BOOL bIsDefText=TRUE;
    XString sText0=GetText(&bIsDefText);
	XString sText;
	if(bIsDefText) {
		if(sDimPrefix[0]) {
			sText << sDimPrefix << &sText0[1] << sDimSuffix;
		} else {
			sText << sDimPrefix << sText0 << sDimSuffix;
		}
	} else {
		sText << sText0;
	}
	dimText.SetRotation(Wcs2Layout(nTextRot));
    dimText.SetLocation(ptText);
    dimText.SetAlignment(XExplodeDraw::kMiddleCenter);
    dimText.SetText(sText);
	{
	TPushProperty vProp(&dimText, dc);
    if(dc.IsFullExplode())
        dimText.ExplodeOrDraw2d(dc);
    else
        dc.DrawEntity(dimText);
	}

    XCurveSegment seg(ptStart, ptEnd, 0.0, LS_INFINITE);
    if(bCheckDim && !bIsDefText) {
        XString sCheckText(256);
		XString sDefText=GetDefaultText();
        sCheckText << _T("(");
		if(sDimPrefix[0]) {
			sCheckText << sDimPrefix << &sDefText[1];
		} else {
			sCheckText << sDefText;
		}
		sCheckText << sDimSuffix << _T(")");
        XPoint ptCheckText;
        if(bIsDefPos) {
            XPoint ptOnSeg;
            if(seg.ProjectToMe(ptText, ptOnSeg)==RTNORM) {
                ptOnSeg.Mirror(ptText, ptCheckText);
            }
        } else {
            int nSideText=seg.OnWhichSide(ptText);
            if(nSideText==OFFSET_RIGHT) 
                ads_polar(ptText, seg.XLine::Direction()-PI/2, nPScale*(dimgap+dimtxt), ptCheckText);
            else
                ads_polar(ptText, seg.XLine::Direction()+PI/2, nPScale*(dimgap+dimtxt), ptCheckText);
        }
        dimText.setColorIndex(1);
        dimText.SetLocation(ptCheckText);
        dimText.SetText(sCheckText);
		TPushProperty vProp(&dimText, dc);
        if(dc.IsFullExplode())
            dimText.ExplodeOrDraw2d(dc);
        else
            dc.DrawEntity(dimText);
    }
    dc.SetColor(nOldColor);
    return Acad::eOk;
}

int TDbRadiusDim::ConvertText(TConvertTextPtr ptr, void *pData)
{
    XString sText;
     int nRet=ptr(m_sText, sText, pData);
     if(nRet==RTNORM) {
         assertWriteEnabled();
         m_sText=sText;
     }
     return nRet;
}

void TDbRadiusDim::GetDimText(TDbText &dimText) const
{
    BOOL bIsDefText=TRUE;
    XString sText=GetText(&bIsDefText);
	TTextPosition pos;

	AcDbObjectId dimtxsty;
	double dimtxt=3.0;
	OPENOBJ_BEGIN(m_idDimStyle, AcDb::kForRead, AcDbDimStyleTableRecord, pDimStyle);
	if(pDimStyle) {
		dimtxsty=pDimStyle->dimtxsty();
		dimtxt=pDimStyle->dimtxt();
	}
	OPENOBJ_END();



    dimText.setPropertiesFrom(this);
    dimText.SetAlignment(XExplodeDraw::kMiddleCenter);
    dimText.SetHeight(dimtxt);
    dimText.SetStyleId(dimtxsty);

    XPoint ptText=GetTextPos();
    double nTextRot=NormalViewAngle(ads_angle(GetDimStartPoint(), GetDimEndPoint()));
	dimText.SetRotation(Wcs2Layout(nTextRot));
	dimText.SetLocation(ptText);
	dimText.SetAlignment(XExplodeDraw::kMiddleCenter);
	if(bIsDefText) 
        dimText.SetText(_T(""));
    else
	    dimText.SetText(sText);
}

// 返回发现的位置，同时posStart往前移动(以便继续找下一个使用),
TTextPosition  
TDbRadiusDim::FindSubText(const TCHAR *sSubText, TTextPosition &posStart, TTextRange *pRange) const
{
	assertReadEnabled();
    TDbText dimText;
	GetDimText(dimText);
	TTextPosition pos=dimText.FindSubText(sSubText, posStart, pRange);
	return pos;
}

// 返回下一次查找的开始位置
TTextPosition  
TDbRadiusDim::ReplaceSubText(const TTextPosition &posRep, const TCHAR *sRepText, TTextRange *pRange)
{
	assertWriteEnabled();
	TDbText dimText;
	GetDimText(dimText);
	TTextPosition pos=dimText.ReplaceSubText(posRep, sRepText, pRange);
    SetText(dimText.GetText());
	return pos;
}

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

TEntityBase::DrawType 
TDbRadiusDim::GetDrawType() const
{
    return TEntityBase::k2DOnly;
}

/* * * * * * * * * * 取 动 态 属 性 显 示 数 据 的 函 数 * * * * * * * * * */
void TDbRadiusDim::GetTips(DList<TObjInfoUnit> &lstInfo) const
{
    lstInfo.Append(new TObjInfoUnit(_T("对象类型"), IsDiameter()? _T("直径标注") : _T("半径标注")));
   lstInfo.Append(new TObjInfoUnit(_T("标注样式"), GetSymbolName(m_idDimStyle)));
   XString sDist;
   ftoa(fabs(m_nDimLen), 1, sDist);
   sDist << _T("P");
   lstInfo.Append(new TObjInfoUnit(_T("尺寸线长度"), sDist));
   lstInfo.Append(new TObjInfoUnit(_T("测量值"), GetDefaultText()));
   lstInfo.Append(new TObjInfoUnit(_T("替代文字"), m_sText));
}


// Helper Method
BOOL TDbRadiusDim::ConvertFrom(const AcDbRadialDimension  *pDim)
{
    assertWriteEnabled();

    AcDbObjectId idStyle=pDim->dimensionStyle();
    XString sText;
    sText=pDim->dimensionText();
    if(pDim->normal() != AcGeVector3d(0,0,1) || !idStyle)
        return FALSE;

    setPropertiesFrom(pDim);
    m_idDimStyle = idStyle;
    if(!pDim->isUsingDefaultTextPosition()) {
        m_ptText=pDim->textPosition();
        m_nDimFlag |= DF_POSITION;
    } else m_nDimFlag &= ~DF_POSITION;


    if(!!sText) {
        m_sText = sText;
        m_nDimFlag |= DF_TEXT;
    } else {
        m_nDimFlag &=~DF_TEXT;
    }

    m_ptCenter=pDim->center();
    m_ptOnArc=pDim->chordPoint();
    m_nDimLen=m_ptCenter.Distance2d(m_ptOnArc)/GetPScale();

    return TRUE;
}





// Properties
// Modified by ZJQ on 2003/01/23
//   支持直径标注
XPoint 
TDbRadiusDim::GetDimStartPoint() const
{
    XPoint ptStart;
    //if(IsDiameter()) 
    //    ads_polar(m_ptOnArc, ads_angle(m_ptOnArc, m_ptCenter), GetRadius()*2, ptStart);
    //else
        ads_polar(m_ptOnArc, ads_angle(m_ptOnArc, m_ptCenter), m_nDimLen*GetPScale(), ptStart);
    return ptStart;
}

XPoint 
TDbRadiusDim::GetDimEndPoint() const
{
    return m_ptOnArc;
}

XPoint 
TDbRadiusDim::GetDimCenter() const
{
    return m_ptCenter;
}

double 
TDbRadiusDim::GetDimLen(BOOL bAsPaperUnit) const
{
    double nVal=m_nDimLen;
    if(!bAsPaperUnit) nVal *= GetPScale();
    return nVal;
}

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

XPoint 
TDbRadiusDim::GetTextPos(BOOL *bIsDefault) const
{
    XPoint ptText;
    if(m_nDimFlag&DF_POSITION) {
        ptText=m_ptText;
        if(bIsDefault) *bIsDefault=FALSE;
    }  else {
        ptText=GetDefaultTextPos();
        if(bIsDefault) *bIsDefault=TRUE;
    }
    return ptText;
}

// Modify on 2003/01/23
//    支持直径标注
XPoint 
TDbRadiusDim::GetDefaultTextPos() const
{
    AcDbObjectId dimtxsty;
    double dimtxt=3.0;
    double dimgap=0.0;
    double dimlfac=1.0;
    OPENOBJ_BEGIN(m_idDimStyle, AcDb::kForRead, AcDbDimStyleTableRecord, pDimStyle);
    ASSERT(pDimStyle);
    dimtxt=pDimStyle->dimtxt();
    dimgap=pDimStyle->dimgap();
    dimtxsty=pDimStyle->dimtxsty();
    dimlfac=pDimStyle->dimlfac();
    OPENOBJ_END();

    double nScale=GetPScale();
    double nTextHeight=dimtxt*nScale;
    TDbText text;
    text.setPropertiesFrom(this);
    text.SetText(GetText());
    text.SetStyleId(dimtxsty);
    text.SetHeight(nTextHeight, FALSE);
    XPoint ptExt=text.GetExtents();

    XPoint ptText, ptTemp;
    
    if(!IsDiameter() || m_nDimLen<0) {
        XPoint ptStart=GetDimStartPoint();
        double nRot=ads_angle(ptStart, m_ptOnArc);
        ads_polar(ptStart, nRot, ptExt.x/2 + dimgap*nScale, ptTemp);
        ads_polar(ptTemp, NormalViewAngle(nRot)+PI/2, (dimgap+dimtxt/2)*nScale, ptText);
    } else {
        double nRot=ads_angle(m_ptCenter, m_ptOnArc);
        //ads_polar(m_ptCenter, nRot+PI, ptExt.x/2, ptTemp);
        ads_polar(m_ptCenter, NormalViewAngle(nRot)+PI/2, (dimgap+dimtxt/2)*nScale, ptText);
    }
    return ptText;
}

XString 
TDbRadiusDim::GetText(BOOL *bIsDefault) const
{
    XString sText;
    if(m_nDimFlag&DF_TEXT) {
        sText=m_sText;
        if(bIsDefault) *bIsDefault=FALSE;
    } else {
        sText=GetDefaultText();
        if(bIsDefault) *bIsDefault=TRUE;
    }
    return sText;
}

// Modify on 2002/02/05 by ZJQ
//   支持单位换算dimlfac
// Modify on 2003/01/23 by ZJQ
//   支持直径标注
XString 
TDbRadiusDim::GetDefaultText() const
{
    int dimdec=0;
    double dimlfac=1.0;
	double dimrnd =0;
    OPENOBJ_BEGIN(m_idDimStyle, AcDb::kForRead, AcDbDimStyleTableRecord, pDimStyle);
    ASSERT(pDimStyle);
    dimdec=pDimStyle->dimdec();
    dimlfac=pDimStyle->dimlfac();
	dimrnd = pDimStyle->dimrnd();
    OPENOBJ_END();
    XString sText, sTemp,sTemrnd;
	double dTemLen(0),dTemrnd(0);
	XString sDimrnd;
    if(IsDiameter()) 
	{
        ftoa(m_ptCenter.Distance2d(m_ptOnArc)*dimlfac*2, dimdec, sTemp);
		ftoa(dimrnd,dimdec,sDimrnd);
		dTemLen = _tstof(sTemp);
		dTemrnd = _tstof(sDimrnd);
		if (!Equal(dTemrnd,0,0.00000001))
		{
			double dT = dTemLen/dTemrnd;
			XString sT;
			ftoa(dT,0,sT);
			dT = _tstof(sT);
			int nt = (int)dT;
			double dDimNum = dTemrnd*nt;
			ftoa(dDimNum, dimdec, sTemp);
		}
		//////zzg090515//////////////
        sText << _T("%%c") << sTemp;
    } 
	else 
	{
        ftoa(m_ptCenter.Distance2d(m_ptOnArc)*dimlfac, dimdec, sTemp);
		ftoa(dimrnd,dimdec,sDimrnd);
		dTemLen = _tstof(sTemp);
		dTemrnd = _tstof(sDimrnd);
		if (!Equal(dTemrnd,0,0.00000001))
		{
			double dT = dTemLen/dTemrnd;
			XString sT;
			ftoa(dT,0,sT);
			dT = _tstof(sT);
			int nt = (int)dT;
			double dDimNum = dTemrnd*nt;
			ftoa(dDimNum, dimdec, sTemp);
		}
		//////zzg090515//////////////
        sText << _T("R") << sTemp;
    }
	//////// 处理 标注样式中舍入的问题zzg 090515
    return sText;
}

void 
TDbRadiusDim::SetDimEndPoint(XPoint ptEnd)
{
    assertWriteEnabled();
    m_ptOnArc=ptEnd;
}

void 
TDbRadiusDim::SetDimCenter(XPoint ptCen)
{
    assertWriteEnabled();
    m_ptCenter=ptCen;
}

void TDbRadiusDim::SetDimLen(double nLen, BOOL bAsPaperUnit)
{
    assertWriteEnabled();
    if(bAsPaperUnit) m_nDimLen=nLen;
    else m_nDimLen=nLen/GetPScale();
}

void TDbRadiusDim::SetStyleId(AcDbObjectId id)
{
    assertWriteEnabled();
    m_idDimStyle=id;
}

void TDbRadiusDim::SetTextPos(XPoint ptPos)
{
    assertWriteEnabled();
    XPoint ptDefault=GetDefaultTextPos();
    if(ptPos.Distance2d(ptDefault)<_DIST_SNAP) {
        m_nDimFlag &= ~DF_POSITION;
    } else {
        m_ptText=ptPos;
        m_nDimFlag |= DF_POSITION;
    }
}

void TDbRadiusDim::SetText(const TCHAR *pszText)
{
    assertWriteEnabled();
    if(!pszText) m_sText=_T("");
    else m_sText=pszText;
    if(!m_sText) {
        m_nDimFlag &= ~DF_TEXT;
    } else {
        m_nDimFlag |= DF_TEXT;
    }
}

void TDbRadiusDim::SetDiameter(BOOL bTrue)
{
    assertWriteEnabled();
    if(bTrue)
        m_nDimFlag |= DF_DIAMETER;
    else
        m_nDimFlag &= ~DF_DIAMETER;
}

BOOL TDbRadiusDim::IsDiameter() const
{
    return ((m_nDimFlag&DF_DIAMETER)!=0);
}

// sg add 101116，支持统一标高
bool TDbRadiusDim::UnifyElevation(double dElevation)
{
    assertWriteEnabled();
	m_ptCenter.z = dElevation;
	m_ptOnArc.z = dElevation;

	XPoint ptText = GetTextPos();
	ptText.z = dElevation;
	SetTextPos(ptText);
	return true;
}

// jsx add 160922,支持导低版本
Acad::ErrorStatus TDbRadiusDim::DownGradeSave(int nDrawMode, AcDbVoidPtrArray &entSet, BOOL *bErase)
{
	Acad::ErrorStatus es=Acad::eOk;

	if (g_nSaveTArchVer > 3 && g_nSaveTArchVer < 11)
	{
		AcDbObjectId dimblk;
		double dimasz = 2.0;
		OPENOBJ_BEGIN(m_idDimStyle, AcDb::kForRead, AcDbDimStyleTableRecord, pDimStyle);
		if(pDimStyle)
		{
			dimasz=pDimStyle->dimasz();
			dimblk=pDimStyle->dimblk();
		}
		OPENOBJ_END();

		//只要检测到半径\直径标注的箭头形式、箭头大小、后缀或文字翻转方向中任一个参数与程序的默认值不同，则在导出成T5-T20格式时，程序直接将其分解为CAD对象
		if (fabs(dimasz - 2.0) > 1E-6 || dimblk || GetLayoutRotation() != 0)
		{
			XExplodeStream dc(entSet);
			if (!OnExplodeOrDraw(dc))
				return es;

			dc.SetPropertiesFrom(this);
			if (nDrawMode == DRAW_2D)
				es = ExplodeOrDraw2d(dc);
			else
				es = ExplodeOrDraw3d(dc);
			if (bErase)
				*bErase = TRUE;
		}
	}
	return es;
}

void InitDbDimension(BOOL bTrue)
{
    if(bTrue) {
        TDbDimension::rxInit();
        TDbDimension2::rxInit();
        TDbRadiusDim::rxInit();
        acrxBuildClassHierarchy();
        TDbDimension::InitMatchProtocol(TRUE);
        TDbDimension2::InitMatchProtocol(TRUE);
        TDbRadiusDim::InitMatchProtocol(TRUE);
    } else {
        TDbDimension::InitMatchProtocol(FALSE);
        TDbDimension2::InitMatchProtocol(FALSE);
        TDbRadiusDim::InitMatchProtocol(FALSE);
        deleteAcRxClass(TDbRadiusDim::desc());
        deleteAcRxClass(TDbDimension2::desc());
        deleteAcRxClass(TDbDimension::desc());
    }
}



BOOL ConvertDim0(const Entity &dimAcDb, Entity &dimT)
{
    BOOL bRet=FALSE;
    OPENOBJ_BEGIN(dimAcDb.name, AcDb::kForWrite, AcDbDimension, pDimOld);
    if(!pDimOld)
        return FALSE;
    AcDbObjectId idMaster;
    if(pDimOld->isKindOf(AcDbRadialDimension::desc())) {
        TDbRadiusDim *pMaster=new TDbRadiusDim;
        if(!pMaster->ConvertFrom((AcDbRadialDimension *)pDimOld) || !pMaster->IsValid())
            delete pMaster;
        else {
            pDimOld->erase();
            idMaster=AddToModelSpace(pMaster, Adesk::kTrue);
            bRet=TRUE;
        }
    } else {
        TDbDimension *pMaster=new TDbDimension;
        if(!pMaster->ConvertFrom(pDimOld) || !pMaster->IsValid()) {
            delete pMaster;
        } else {
            pDimOld->erase();
            idMaster=AddToModelSpace(pMaster, Adesk::kTrue);
            bRet=TRUE;
        }
    }
    if(bRet==TRUE)
        VERIFY(acdbGetAdsName(dimT.name, idMaster)==Acad::eOk);
    OPENOBJ_END();
    return bRet;
}

BOOL ConvertDim(const Entity &dimAcDb, Entity &dimT)
{
    BOOL bRet=FALSE;
	OPENOBJ_BEGIN(dimAcDb.name, AcDb::kForWrite, AcDbEntity, pDimOld);
    if(!pDimOld)
        return FALSE;
    AcDbObjectId idMaster;
	if(pDimOld->isKindOf(AcDbDimension::desc()))
	{
		if(pDimOld->isKindOf(AcDbRadialDimension::desc())) {
			TDbRadiusDim *pMaster=new TDbRadiusDim;
			if(!pMaster->ConvertFrom((AcDbRadialDimension *)pDimOld) || !pMaster->IsValid())
				delete pMaster;
			else {
				pDimOld->erase();
				idMaster=AddToModelSpace(pMaster, Adesk::kTrue);
				bRet=TRUE;
			}
		} else {
			TDbDimension2 *pMaster=new TDbDimension2;
			if(!pMaster->ConvertFrom((AcDbDimension*)pDimOld) || !pMaster->IsValid()) {
				delete pMaster;
			} else {
				pDimOld->erase();
				idMaster=AddToModelSpace(pMaster, Adesk::kTrue);
				bRet=TRUE;
			}
		}
	}
	else if(pDimOld->isKindOf(TDbDimension::desc()))
	{
		TDbDimension2 *pMaster=new TDbDimension2;
		if(!pMaster->ConvertFrom((TDbDimension*)pDimOld) || !pMaster->IsValid()) {
			delete pMaster;
		} else {
			pDimOld->erase();
			idMaster=AddToModelSpace(pMaster, Adesk::kTrue);
			bRet=TRUE;
		}
	}
    if(bRet==TRUE)
        VERIFY(acdbGetAdsName(dimT.name, idMaster)==Acad::eOk);
    OPENOBJ_END();
    return bRet;
}

void ConvertDim6()
{
	PickSet ss(SS_FREE);
	ss.Get(_T("X"),NULL,NULL,RBList(RTDXF0,_T("ATS_DIMENSION"),NULL));
	long count=ss.Length();
	for(long i=0;i<count;i++)
	{
		AcDbObjectId nId;
		Entity ent=ss[i];
		if(acdbGetObjectId(nId, (TLong_ptr *)ent)==Acad::eOk) 
		{
			TDbDimension *pDim=NULL;
			acdbOpenObject(pDim, nId, AcDb::kForWrite);
			if(pDim!=NULL)
			{
				TDbDimension2 *pNewDim=new TDbDimension2;
				pNewDim->ConvertFrom(pDim);
				if(pDim->handOverTo(pNewDim)==Acad::eObjectToBeDeleted)
				{
					delete pDim;
					pNewDim->close();
				}
				else
				{
					delete pNewDim;
					pDim->close();
				}
			}
		}
	}
}