#include "stdafx.h"
#include "TchKernalGlobalFunc.h"

static double g_nDist2Dim2 = 15.0;
static double g_nDist2Dim1 = 7.0;


extern int g_nHideAxisLabelColor;
//extern TARCH_IMPEXP XString GetSymbolName(AcDbObjectId idSymbolRec);
extern double g_dAxisLabelDia;	// sg add 090512，轴圈直径

/////////////////////////////////////////////////////////////
// 轴网标注类
/////////////////////////////////////////////////////////////
// 1－TArch5；2－TArch6Beta1；3－TArch6Beta2；4-TArch7、TArch8；5-TArch9
//const Adesk::UInt8 TDbAxisLabelSet::g_nVersion = 4;
const Adesk::UInt8 TDbAxisLabelSet::g_nVersion = 5;


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


IMPLEMENT_TENTBASE(TDbAxisLabelSet);

TDbAxisLabelSet::TDbAxisLabelSet()
{
    m_nFlag=0;
    m_nLeaderLen1=m_nLeaderLen2=40.0;
//	m_nCirRadius=4.0; // 详图可为5.0
    m_nCirRadius = g_dAxisLabelDia*0.5; // sg modify 090512，调用全局设置
    m_nDist2Center=0.0;
	m_colorText=7;
	m_bShowHide=FALSE;

	m_bStretchPt = false; // sg add 100518，增加用来区分Grip和Stretch点的变量，不存盘，默认为否

	// add by lgy 20120209，9.0添加的标记，默认为显示轴圈内的文字
	SetAllAxisTextHide(FALSE);;
}

BOOL TDbAxisLabelSet::IsValid() const
{
    BOOL bRet=TDbEntity::IsValid();
    if (!bRet)
        return bRet;
    bRet=(m_lstAxis.Length()>=1);
    return bRet;
}

Acad::ErrorStatus 
TDbAxisLabelSet::audit(AcDbAuditInfo* pAuditInfo)
{
    Acad::ErrorStatus es = Acad::eOk;
	// sg add 090806，解决高版本下修复02图纸，对象丢失的问题
	es = TDbEntity::audit(pAuditInfo);
	if (es != Acad::eOk)
		return es;

    if (m_lstAxis.Length()==0)
	{
        pAuditInfo->errorsFound(1);
        if (pAuditInfo->fixErrors() == Adesk::kTrue)
		{
            pAuditInfo->printError(_T("轴号"), _T("数目"), _T("要大于0"), _T(""));
            m_lstAxis.Append(new TAxisInfo());
            pAuditInfo->errorsFixed(1);
            es = Acad::eFixedAllErrors;
        }
		else
		{
            es = Acad::eLeftErrorsUnfixed;
        }
    }
	else
	{
        //int idx=0;
        int len=m_lstAxis.Length()-1;
        for (int i=0; i<len; i++)
		{
            TAxisInfo *pInfo=m_lstAxis[i];
            if (fabs(pInfo->m_nPara2Next)<1.0E-3)
			{
                if (pAuditInfo->fixErrors() == Adesk::kTrue)
				{
                    pAuditInfo->errorsFound(1);
                    pAuditInfo->printError(_T("轴号"), _T("距离"), _T("不能为0"), _T(""));
                    m_lstAxis.Remove();
                    i--;
                    len--;
                    pAuditInfo->errorsFixed(1);
                    es = Acad::eFixedAllErrors;
                }
				else
				{
                    es = Acad::eLeftErrorsUnfixed;
                }
            }
        }
    }
    return es;
}


// 提供对格式刷的支持
void TDbAxisLabelSet::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
{
    assertWriteEnabled();
    TDbEntity::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
    TDbAxisLabelSet *pSrc=TDbAxisLabelSet::cast(pSrcEntity);
    if (pSrc)
	{
		if (database()==NULL||
		   pSrcEntity->database()==NULL||
		   database()==pSrcEntity->database())//add by whl on 060317
		{
			m_idTextStyle=pSrc->m_idTextStyle;
			m_idTextLayer=pSrc->m_idTextLayer;
		}

        m_nCirRadius=pSrc->m_nCirRadius;
		m_colorText=pSrc->m_colorText;
    }
}

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



// 从DWG读入数据:
Acad::ErrorStatus TDbAxisLabelSet::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;
	}

	if (nVer<3)
	{
		Adesk::UInt8 nTemp=0;
		pFiler->readItem(&nTemp);
		m_nFlag=nTemp;
	}
	else
		pFiler->readItem(&m_nFlag);
	pFiler->readItem(&m_idTextStyle);
	pFiler->readItem((AcGePoint2d *)&m_segFirst.StartPoint());
	pFiler->readItem((AcGePoint2d *)&m_segFirst.EndPoint());

	double dBulge = 0;
	pFiler->readItem(&dBulge);
	m_segFirst.SetBulge(dBulge);

	m_lstAxis.Reset();
	Adesk::UInt8 num=0;
	pFiler->readItem(&num);
	for (Adesk::UInt8 i=0; i<num; i++)
	{
		TAxisInfo *pAxis=new TAxisInfo;
		if (nVer<3)
		{
			Adesk::UInt8 nTemp=0;
			pFiler->readItem(&nTemp);
			pAxis->m_nFlag=nTemp;
		}
		else
		{
			pFiler->readItem(&pAxis->m_nFlag);
		}

		ReadString(pFiler, pAxis->m_sText);
		pFiler->readItem(&pAxis->m_nPara2Next);

		if (nVer>=3) 
		{
			if (pAxis->m_nFlag&AXF_SIDE1_LEAD)
				pFiler->readItem(&pAxis->m_nLeadLen1);
			if (pAxis->m_nFlag&AXF_SIDE2_LEAD)
				pFiler->readItem(&pAxis->m_nLeadLen2);
		}

		if (nVer > 4) // add by lgy 20120216，9.0添加保存单根轴线位置点到默认位置的距离
		{
			if (pAxis->m_nFlag&AXF_SIDE1_LEADPOS)
				pFiler->readItem(&pAxis->m_dLeadPos1);
			if (pAxis->m_nFlag&AXF_SIDE2_LEADPOS)
				pFiler->readItem(&pAxis->m_dLeadPos2);
		}

		m_lstAxis.Append(pAxis);
	}

	pFiler->readItem(&m_nDist2Center);
	pFiler->readItem(&m_nLeaderLen1);
	if (nVer>2) 
		pFiler->readItem(&m_nLeaderLen2);
	else
		m_nLeaderLen2=m_nLeaderLen1;

	pFiler->readItem(&m_nCirRadius);

	if (nVer>1)
	{
		pFiler->readItem(&m_idTextLayer);
	}
	else // TArch5 update
	{
		if (database()==acdbCurDwg())
		{
			m_idTextLayer = InitLayer(LAY_AXIS_TEXT, FALSE);
		}
		else
		{
			m_idTextLayer = GetLayerIdFromString(LAY_AXIS_TEXT, database());
		}
	}

	if (nVer>3)
		pFiler->readItem(&m_colorText);

	// add by lgy 20120209，TArch9中新添属性控制实体是否隐藏
	if (nVer > 4)
		pFiler->readItem(&m_nFlag2);

	return pFiler->filerStatus();
}

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

	if (g_nSaveTArchVer==5) 
	{
		pFiler->writeItem((Adesk::UInt8)1);
		pFiler->writeItem((Adesk::UInt8)m_nFlag);
	} 
	else 
	{
		if (g_nSaveTArchVer==6)
			pFiler->writeItem((Adesk::UInt8)3);
		// add by lgy 20120209，TArch9中新添属性控制实体是否隐藏
		else if (g_nSaveTArchVer==7 || g_nSaveTArchVer==8)
			pFiler->writeItem((Adesk::UInt8)4);
		else
			pFiler->writeItem(g_nVersion);
		pFiler->writeItem(m_nFlag);
	}

	pFiler->writeItem(m_idTextStyle);

	pFiler->writeItem((const AcGePoint2d &)m_segFirst.StartPoint());
	pFiler->writeItem((const AcGePoint2d &)m_segFirst.EndPoint());
	pFiler->writeItem(m_segFirst.GetBulge());

	Adesk::UInt8 num=m_lstAxis.Length();
	pFiler->writeItem(num);
	for (Adesk::UInt8 i=0; i<num; i++)
	{
		//LH 2013-4-16 修改原因在于执行"图纸剪切"命令时,有崩溃现象出现。原因是const TAxisInfo &axis = m_lstAxis[i];赋值失败，
		//赋值失败是因为TDPtrList内部m_CurrteIndex已经到了链表末端，所以失败，添加下行代码，使其内部CurrteIndex发生变化，从而
		//保证赋值正确。
		const_cast<TDbAxisLabelSet*>(this)->m_lstAxis.MoveToHead();
		const TAxisInfo &axis=m_lstAxis[i];
		if (g_nSaveTArchVer==5)
			pFiler->writeItem((Adesk::UInt8)axis.m_nFlag);
		else
			pFiler->writeItem(axis.m_nFlag);

		pFiler->writeString(axis.m_sText);
		pFiler->writeItem(axis.m_nPara2Next);

		if (g_nSaveTArchVer!=5)
		{
			if (axis.m_nFlag&AXF_SIDE1_LEAD)
				pFiler->writeItem(axis.m_nLeadLen1);
			if (axis.m_nFlag&AXF_SIDE2_LEAD)
				pFiler->writeItem(axis.m_nLeadLen2);
		}
		
		if (g_nSaveTArchVer > 8) // add by lgy 20120216，9.0添加单根轴线相对参考位置距离
		{
			if (axis.m_nFlag&AXF_SIDE1_LEADPOS)
			{
				pFiler->writeItem(axis.m_dLeadPos1);
			}
			if (axis.m_nFlag&AXF_SIDE2_LEADPOS)
			{
				pFiler->writeItem(axis.m_dLeadPos2);
			}
		}
	}

	pFiler->writeItem(m_nDist2Center);
	pFiler->writeItem(m_nLeaderLen1);
	if (g_nSaveTArchVer!=5)
		pFiler->writeItem(m_nLeaderLen2);
	pFiler->writeItem(m_nCirRadius);

	// TArch6
	if (g_nSaveTArchVer>5)
		pFiler->writeItem(m_idTextLayer);

	if (g_nSaveTArchVer>6)
		pFiler->writeItem(m_colorText);

	// add by lgy 20120209，TArch9中新添属性控制实体是否隐藏
	if (g_nSaveTArchVer > 8)
		pFiler->writeItem(m_nFlag2);

	return pFiler->filerStatus();
}

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

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

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

	int fieldsFlags=0;
	resbuf rb;
	XString sName, sTextLayer;
	double r1, r2;
    while ((es == Acad::eOk)
        && ((es = pFiler->readResBuf(&rb)) == Acad::eOk))    {
        switch (rb.restype) {
		case AcDb::kDxfTextStyleName:
			sName=rb.resval.rstring;
			fieldsFlags |= 0x01;
			free(rb.resval.rstring);
			break;
        case AcDb::kDxfReal:
			r1=rb.resval.rreal;
			fieldsFlags |= 0x02;
            break;    
        case AcDb::kDxfReal+1:
            r2 = rb.resval.rreal;
			fieldsFlags |= 0x04;
            break;    
		case 410:
			sTextLayer=rb.resval.rstring;
			fieldsFlags |= 0x08;
			free(rb.resval.rstring);
			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;

	AcDbObjectId id;
	if (fieldsFlags&0x01)
		id=TchExport::GetTextStyleId(sName,database());
	if (!id) {
		XString sTextStyle;
		xg_getvar(_T("TEXTSTYLE"), sTextStyle);
		id=TchExport::GetTextStyleId(sTextStyle,database());
	}
	m_idTextStyle=id;
	if (fieldsFlags&0x02)
		m_nLeaderLen1=m_nLeaderLen2=r1;
	if (fieldsFlags&0x04)
		m_nCirRadius=r2/2;
	if (fieldsFlags&0x08)
		m_idTextLayer=TchExport::GetLayerIdFromString(sTextLayer, database());

    return pFiler->filerStatus();
}

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

    es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbAxisLabelSet"));
    assert(es == Acad::eOk);
   
	XString sName=GetSymbolName(m_idTextStyle);
    pFiler->writeString(AcDb::kDxfTextStyleName, sName);
	pFiler->writeDouble(AcDb::kDxfReal, m_nLeaderLen1);
	pFiler->writeDouble(AcDb::kDxfReal+1, m_nCirRadius*2);

	pFiler->writeString(410, (const TCHAR *)LayerId2String(m_idTextLayer));
    return pFiler->filerStatus();
}

// 绊定的实体发生变化
void TDbAxisLabelSet::modified(const AcDbObject* pDbObj)
{
    if (!isWriteEnabled() && isNotifyEnabled() && IsValid())
	{
        TDbAxisLabelSet *pMaster = TDbAxisLabelSet::cast(pDbObj);
        if (pMaster && pMaster->IsValid())
		{
            const TCHAR *pszLabel=pMaster->GetLabel(pMaster->GetAxisNum()-1);
            const TCHAR *szLabel=GetLabel(0);
            if (_tcscmp(pszLabel, szLabel)!=0)
			{
                Adesk::Boolean wasWritable;
                VERIFY(upgradeFromNotify(wasWritable)==Acad::eOk);
                assertWriteEnabled();
                SetLabel(0, pszLabel, TRUE);
                VERIFY(downgradeToNotify(wasWritable)==Acad::eOk);
            }
        }
    }
}


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

// Overriden functions for edit
// to do:
// 允许通过夹点改变边界
Acad::ErrorStatus TDbAxisLabelSet::subGetGripPoints(AcGePoint3dArray&  gripPoints,
                                             AcDbIntArray&  osnapModes,
                                             AcDbIntArray&  geomIds) const
{
	assertReadEnabled();
//	XPoint ptLead[2];
//	ads_polar(m_segFirst.StartPoint(), m_segFirst.IDirection(0)+PI, GetLeaderLen(FALSE), ptLead[0]);
//	ads_polar(m_segFirst.EndPoint(), m_segFirst.IDirection(1)+PI, GetLeaderLen(FALSE), ptLead[1]);

	for (int nSide=0; nSide<2; nSide++)
	{
		int nTestBit = nSide ? ANF_HIDESIDE2 : ANF_HIDESIDE1;
		if (m_nFlag&nTestBit)
			continue;

		double nDefLeadLen = GetLeaderLen(nSide, FALSE);

		int nTestBit1 = nSide ? AXF_NOSIDE2 : AXF_NOSIDE1;
		int nTestBit2 = nSide ? AXF_SIDE2_LEAD : AXF_SIDE1_LEAD;
		// gripPoints.append(ptLead[nSide]);

		// 标注整侧中是否有一个轴号是显示的
		bool bHasOneAxisShow(false);

		for (int i=0; i<m_lstAxis.Length(); i++)
		{
			//LH 2013-4-16 修改原因在于执行"图纸剪切"命令时,有崩溃现象出现。原因是const TAxisInfo &axis = m_lstAxis[i];赋值失败，
			//赋值失败是因为TDPtrList内部m_CurrteIndex已经到了链表末端，所以失败，添加下行代码，使其内部CurrteIndex发生变化，从而
			//保证赋值正确。
			const_cast<TDbAxisLabelSet*>(this)->m_lstAxis.MoveToHead();

			const TAxisInfo &axis = m_lstAxis[i];
			if (axis.m_nFlag&nTestBit1)
				continue;

			bHasOneAxisShow = true; // 整侧有轴号是显示的

			XCurveSegment segAxis = GetAxis(i);
			XPoint ptVert = nSide ? segAxis.EndPoint() : segAxis.StartPoint();
			gripPoints.append(ptVert); // 轴号横纵移动

			XPoint ptLabelCen = GetLabelCenter(i, nSide);
			if (!m_bStretchPt) // sg add 100518，用来区分Grip和Stretch点，根据8.5需求，拉伸操作屏蔽掉“轴号偏移”点
			{
				gripPoints.append(ptLabelCen); // 轴号偏移
			}

			double nLeadLen = nDefLeadLen;
			if (axis.m_nFlag&nTestBit2)
			{
				nLeadLen = (nSide? axis.m_nLeadLen2 : axis.m_nLeadLen1);
				nLeadLen *= GetPScale();
			}

			double dDir = segAxis.IDirection(nSide);
			if (segAxis.GetLength() < _DIST_SNAP) // sg add 120704，解决单个轴号2点重合的时候，会出现方向错误的问题
				dDir = m_segFirst.IDirection(nSide);

			XPoint ptLead;
			//ads_polar(ptVert, segAxis.IDirection(nSide)+PI, nLeadLen, ptLead);
			ads_polar(ptVert, dDir+PI, nLeadLen, ptLead);
			gripPoints.append(ptLead); // 改单轴引线长度
		}

		if (bHasOneAxisShow && !m_bStretchPt) // add by lgy 20120214，为轴号对象添加两个夹点， 拖拽时统一改变引线长度
		{
			double nLeadLen = nDefLeadLen;

			//LH 2013-4-16 修改原因在于执行"图纸剪切"命令时,有崩溃现象出现。原因是const TAxisInfo &axis = m_lstAxis[i];赋值失败，
			//赋值失败是因为TDPtrList内部m_CurrteIndex已经到了链表末端，所以失败，添加下行代码，使其内部CurrteIndex发生变化，从而
			//保证赋值正确。
			const_cast<TDbAxisLabelSet*>(this)->m_lstAxis.MoveToHead();

			const TAxisInfo &axis = m_lstAxis[0];
			if (axis.m_nFlag&nTestBit2)
			{
				nLeadLen = (nSide? axis.m_nLeadLen2 : axis.m_nLeadLen1);
				nLeadLen *= GetPScale();
			}

			double dPara2Next = axis.m_nPara2Next,
				dSymb = fabs(dPara2Next)<1.0E-3?1:fabs(dPara2Next)/dPara2Next;
			if (IsArcAxisNet() && !IsArcAxis()) // 圆弧轴网中的角度标注
			{
				dSymb = (nSide==0) ? dSymb : -dSymb;
			}


			XCurveSegment segAxis = GetAxis(0),
				segOffset = segAxis.Offset(-4*GetPScale()*dSymb, LS_FINITE); // 夹点默认距离为400

			XPoint ptVert = nSide ? segOffset.EndPoint() : segOffset.StartPoint();
			ads_polar(ptVert, segOffset.IDirection(nSide)+PI, nLeadLen, ptVert);
			gripPoints.append(ptVert); // 改单侧引线长度
		}
	}

	return Acad::eOk;
}

// stretch points is diffrent from grep points, with no midpoint included
Acad::ErrorStatus  
TDbAxisLabelSet::subGetStretchPoints(AcGePoint3dArray & stretchPoints) const
{
	assertReadEnabled();
	TDbAxisLabelSet *pNewSet = (TDbAxisLabelSet*)clone();
	for (long i=0;i<GetAxisNum();i++)
	{
		pNewSet->SetAxisVisSides(i,3); // 全部显示
	}

	// sg add 100518，用来区分Grip和Stretch点，根据8.5需求，拉伸操作屏蔽掉“轴号偏移”点
	pNewSet->m_bStretchPt = true;

	AcDbIntArray ar;
	Acad::ErrorStatus es = pNewSet->getGripPoints(stretchPoints, ar, ar);
	delete pNewSet;
	return es;
}


// Active when being rotated, scaled, moved, etc.
// Scale is disabled here
Acad::ErrorStatus TDbAxisLabelSet::subTransformBy(const AcGeMatrix3d& xform)
{
    assertWriteEnabled();
	TDbEntity::subTransformBy(xform);
    ads_matrix mat;
    AsAdsMatrix(xform, mat);
    m_segFirst.TransformBy(mat);
    if (IsMirrorMatrix(mat))
	{
        NegateParams();
	}
    return Acad::eOk;
}


// 功能: 夹点操作
Acad::ErrorStatus TDbAxisLabelSet::subMoveGripPointsAt(
    const AcDbIntArray& indices,
    const AcGeVector3d& offset)
{
	assertWriteEnabled();
	XPoint vtOffset(offset[0], offset[1]);

	AcDbIntArray axisArray;

	int nIndice = indices.length();
	for (int k = 0; k < nIndice; k++)
	{
		int idx = indices[k]; // 取得夹点编号

		int iVert = 0;
		for (int nSide=0; nSide<2; nSide++)
		{
			int nTestBit=nSide? ANF_HIDESIDE2 : ANF_HIDESIDE1;
			if (m_nFlag&nTestBit)
				continue;

			int nTestBit1=nSide? AXF_NOSIDE2 : AXF_NOSIDE1;
			int nTestBit2=nSide? AXF_SIDE2_LEAD : AXF_SIDE1_LEAD;
			/*
            if (idx==iVert && nIndice==1) { //移动引线长度, 只有夹点个数为1时
                double nDir=m_segFirst.IDirection(nSide)+PI;
                XVector3D vt(cos(nDir), sin(nDir));
                m_nLeaderLen += (vtOffset&vt)/GetPScale();
                break;
            }*/
            //iVert++;

			BOOL bBreak = FALSE;

			// 标注整侧中是否有一个轴号是显示的
			bool bHasOneAxisShow(false);

			int num = m_lstAxis.Length();
			for (int i=0; i<num; i++)
			{
				TAxisInfo & axis=*m_lstAxis[i];
				if (axis.m_nFlag&nTestBit1)
					continue;

				bHasOneAxisShow = true; // 整侧有轴号是显示的

				XCurveSegment segAxis=GetAxis(i);
				XPoint ptVert=nSide? segAxis.EndPoint() : segAxis.StartPoint();
				if (idx == iVert)
				{
					if (axisArray.contains(i))
					{
						bBreak=TRUE;
						break;
					}
					axisArray.append(i);

					if (IsArcAxisNet() && !IsArcAxis()) // 圆弧轴网角度（直线类型）标注
					{
						XPoint ptCen=GetArcNetCenter();
						XPoint ptDest=ptVert + vtOffset;
						double nAng=ads_angle(ptCen, ptDest);
						if (i==0) //不能在第二根轴线和最后一根轴线之间
						{
							if (num>=3) 
							{
								XCurveSegment segSec=GetAxis(1);
								XCurveSegment segFinal=GetAxis(num-1);
								XSector sector=(m_nFlag&ANF_CLOCKWISE)? 
									XSector(segFinal.IDirection(0), segSec.IDirection(0)) :
								XSector(segSec.IDirection(0), segFinal.IDirection(0));

								int nAngFlag=sector.AngleFlag(nAng);
								if ((nAngFlag==1 && !(m_nFlag&ANF_CLOCKWISE)) ||
									(nAngFlag==2 && (m_nFlag&ANF_CLOCKWISE)))
								{
									// modify by lgy 20120220，9.0中单轴移动跟别的轴号重合时弹出BUG
									// m_lstAxis.Remove(i);
									if (!GetCtrlToggle()) // 轴号横纵移动
									{
										m_lstAxis.Remove(i);
									}
								}

								if (nAngFlag==0)
								{
									axis.m_nPara2Next = (m_nFlag&ANF_CLOCKWISE)?
										-CT_std_angle(nAng-segSec.IDirection(0)) :
									CT_std_angle(segSec.IDirection(0)-nAng);
								}
							}
							else if (num==2) 
							{
								double nAngNext=ads_angle(ptCen, ptVert)+axis.m_nPara2Next;
								axis.m_nPara2Next = (m_nFlag&ANF_CLOCKWISE)?
									-CT_std_angle(nAng-nAngNext) :
								CT_std_angle(nAngNext-nAng);
								if (fabs(axis.m_nPara2Next)<_angSnap)
								{
									// modify by lgy 20120220，9.0中单轴移动跟别的轴号重合时弹出BUG
									// m_lstAxis.Remove(i);
									if (!GetCtrlToggle()) // 轴号横纵移动
									{
										m_lstAxis.Remove(i);
									}
								}
							}
							
							if (nSide==0) //移动轴线
							{
								// modify by lgy 20120217，单轴纵横移动和单侧纵横移动功能分开
								//double nDist2Cen=m_segFirst.EndPoint().Distance2d(ptCen);
								//m_segFirst.StartPoint() += vtOffset;
								//ads_polar(ptCen, nAng, nDist2Cen, m_segFirst.EndPoint());
								if (!GetCtrlToggle())	//轴号横纵移动
								{
									double nDist2Cen=m_segFirst.EndPoint().Distance2d(ptCen);
									m_segFirst.StartPoint() += vtOffset;
									ads_polar(ptCen, nAng, nDist2Cen, m_segFirst.EndPoint());
								}
								else	//单轴横纵移动
								{
									//单轴移动时不应该改变m_segFirst的位置，通过一个临时变量计算出
									//移动轴号后轴号距离默认位置点的距离
									XCurveSegment segPitch = m_segFirst;
									double dDist = m_segFirst.GetStartPoint().Distance2d(ptCen);
									double dDistEnd = m_segFirst.GetEndPoint().Distance2d(ptCen);
									ads_polar(ptCen, nAng, dDist, m_segFirst.StartPoint());
									ads_polar(ptCen, nAng, dDistEnd, m_segFirst.EndPoint());
									double nMoveDist1=ptDest.Distance2d(m_segFirst.EndPoint());
									axis.m_nFlag|=AXF_SIDE2_LEADPOS;
									axis.m_dLeadPos2=nMoveDist1;
								}
							}
							else 
							{
								//modify by lgy 20120217	单轴纵横移动和单侧纵横移动功能分开
								//double nDist2Cen=m_segFirst.StartPoint().Distance2d(ptCen);
								//m_segFirst.EndPoint() += vtOffset;
								//ads_polar(ptCen, nAng, nDist2Cen, m_segFirst.StartPoint());
								if (!GetCtrlToggle())	//轴号横纵移动
								{
									double nDist2Cen=m_segFirst.StartPoint().Distance2d(ptCen);
									m_segFirst.EndPoint() += vtOffset;
									ads_polar(ptCen, nAng, nDist2Cen, m_segFirst.StartPoint());
								}
								else					//单轴横纵移动
								{
									//单轴移动时不应该改变m_segFirst的位置，通过一个临时变量计算出
									//移动轴号后轴号距离默认位置点的距离
									XCurveSegment segPitch = m_segFirst;
									double dDist = m_segFirst.GetStartPoint().Distance2d(ptCen);
									double dDistEnd = m_segFirst.GetEndPoint().Distance2d(ptCen);
									ads_polar(ptCen, nAng, dDist, m_segFirst.StartPoint());
									ads_polar(ptCen, nAng, dDistEnd, m_segFirst.EndPoint());
									dDist = ptDest.Distance2d(ptCen);
									dDistEnd = m_segFirst.EndPoint().Distance2d(ptCen);
									double nMoveDist1 = dDist - dDistEnd;
									axis.m_nFlag|=AXF_SIDE2_LEADPOS;
									axis.m_dLeadPos2=nMoveDist1;
								}
							}
						}
						else if (i==num-1) //不能在第1根轴线和倒数第2根轴线之间
						{
							BOOL bMove=FALSE;
							if (num>=3) 
							{
								XCurveSegment segFirst=GetAxis(0);
								XCurveSegment segSec=GetAxis(num-2);
								XSector sector=(m_nFlag&ANF_CLOCKWISE)? 
									XSector(segSec.IDirection(0), segFirst.IDirection(0)) :
								XSector(segFirst.IDirection(0), segSec.IDirection(0));
								TAxisInfo &axisPrev=*m_lstAxis[num-2];
								int nAngFlag=sector.AngleFlag(nAng);
								if ((nAngFlag==1 && (m_nFlag&ANF_CLOCKWISE)) ||
									(nAngFlag==2 && !(m_nFlag&ANF_CLOCKWISE)))
								{
									// modify by lgy 20120220，9.0轴号重合出现bug问题	
									// m_lstAxis.Remove(i);
									if (!GetCtrlToggle())
									{
										m_lstAxis.Remove(i);
									}
									bMove=TRUE;
								}
								if (nAngFlag==0)
								{
									axisPrev.m_nPara2Next = (m_nFlag&ANF_CLOCKWISE)?
										-CT_std_angle(segSec.IDirection(0)-nAng) :
									CT_std_angle(nAng-segSec.IDirection(0));
									bMove=TRUE;
								}
							}
							else if (num==2)
							{
								TAxisInfo &axisPrev=*m_lstAxis[num-2];
								XCurveSegment segPrev=GetAxis(num-1);
								axisPrev.m_nPara2Next = (m_nFlag&ANF_CLOCKWISE)?
									-CT_std_angle(segPrev.IDirection(0)-nAng) :
								CT_std_angle(nAng-segPrev.IDirection(0));
								if (fabs(axisPrev.m_nPara2Next)<_angSnap)
								{
									// modify by lgy 20120220，9.0轴号重合出现bug问题	
									// m_lstAxis.Remove(i);
									if (!GetCtrlToggle())
									{
										m_lstAxis.Remove(i);
									}
									bMove=TRUE;
								}
							}

							if (nSide==1&&bMove) // add by xlc on 090209，移动轴号
							{
								//modify by lgy 20120220	9.0需求需要将单轴纵横移动和轴号横纵移动分开
								//double nDist2Cen=ptDest.Distance2d(ptCen);
								//double nAng1=ads_angle(ptCen, m_segFirst.StartPoint());
								//ads_polar(ptCen, nAng1, nDist2Cen, m_segFirst.EndPoint());
								if (!GetCtrlToggle())		//轴号横纵移动
								{
									double nDist2Cen=ptDest.Distance2d(ptCen);
									double nAng1=ads_angle(ptCen, m_segFirst.StartPoint());
									ads_polar(ptCen, nAng1, nDist2Cen, m_segFirst.EndPoint());
								}
								else						//单轴横纵移动
								{
									//单轴移动时借助m_segFirst的终点到圆心的距离和偏移点到圆心之间的距离
									//的差计算单根轴号到默认位置的距离
									double dDist = m_segFirst.GetEndPoint().Distance2d(ptCen);
									double dDist2Cen=ptDest.Distance2d(ptCen);
									double nMoveDist1 = dDist2Cen - dDist;
									axis.m_nFlag|=AXF_SIDE2_LEADPOS;
									axis.m_dLeadPos2=nMoveDist1;
								}
							}						
						}
						else //必须在前后两根轴线之间
						{
							XCurveSegment segPrev=GetAxis(i-1);
							XCurveSegment segNext=GetAxis(i+1);
							TAxisInfo &axisPrev=*m_lstAxis[i-1];
							XSector sector=(m_nFlag&ANF_CLOCKWISE)? 
								XSector(segNext.IDirection(0), segPrev.IDirection(0)) :
							XSector(segPrev.IDirection(0), segNext.IDirection(0));
							int nAngFlag=sector.AngleFlag(nAng);

							BOOL bMove=FALSE;
							if (nAngFlag!=0)
							{
								axis.m_nPara2Next = (m_nFlag&ANF_CLOCKWISE)?
									-CT_std_angle(nAng-segNext.IDirection(0)) :
								CT_std_angle(segNext.IDirection(0)-nAng);
								axisPrev.m_nPara2Next = (m_nFlag&ANF_CLOCKWISE)?
									-CT_std_angle(segPrev.IDirection(0)-nAng) :
								CT_std_angle(nAng-segPrev.IDirection(0));
								if (fabs(axis.m_nPara2Next)<_angSnap)
								{
									//modify by lgy 20120220	9.0如果单轴移动和别的轴号重合，则弹出BUG
									//m_lstAxis.Remove(i);
									if (!GetCtrlToggle())
									{
										m_lstAxis.Remove(i);
									}
								}
								else if (fabs(axisPrev.m_nPara2Next)<_angSnap) 
								{
									axisPrev.m_nPara2Next += axis.m_nPara2Next;
									//modify by lgy 20120220	9.0如果单轴移动和别的轴号重合，则弹出BUG
									//m_lstAxis.Remove(i);
									if (!GetCtrlToggle())
									{
										m_lstAxis.Remove(i);
									}
								}
								bMove=TRUE;
							}

							if (nSide==1&&bMove) // add by xlc on 090209，移动轴号
							{
								// modify by lgy 20120220，9.0需求需要将单轴纵横移动和轴号横纵移动分开
								//double nDist2Cen=ptDest.Distance2d(ptCen);
								//double nAng1=ads_angle(ptCen, m_segFirst.StartPoint());
								//ads_polar(ptCen, nAng1, nDist2Cen, m_segFirst.EndPoint());
								if (!GetCtrlToggle())		//轴号横纵移动
								{
									double nDist2Cen=ptDest.Distance2d(ptCen);
									double nAng1=ads_angle(ptCen, m_segFirst.StartPoint());
									ads_polar(ptCen, nAng1, nDist2Cen, m_segFirst.EndPoint());
								}
								else						//单轴横纵移动
								{
									//单轴移动时借助m_segFirst的终点到圆心的距离和偏移点到圆心之间的距离
									//的差计算单根轴号到默认位置的距离
									double dDist = m_segFirst.GetEndPoint().Distance2d(ptCen);
									double dDist2Cen=ptDest.Distance2d(ptCen);
									double nMoveDist1 = dDist2Cen - dDist;
									axis.m_nFlag|=AXF_SIDE2_LEADPOS;
									axis.m_dLeadPos2=nMoveDist1;
								}
							}
						}

						// sg add 120704，如果是轴号横纵移动，需要清空单独位置的标记，所有轴号的单轴相对默认点距离不起作用
						if (!GetCtrlToggle())
						{
							int nTestBitTmp = nSide ? AXF_SIDE2_LEADPOS : AXF_SIDE1_LEADPOS;
							for (int kk = 0; kk < m_lstAxis.Length(); kk++)
							{
								TAxisInfo & rAxis = *m_lstAxis[kk];
								rAxis.m_nFlag &= ~nTestBitTmp;
							}
						}
					}
					else // 直线轴网标注，圆弧轴网中的进深（弧线类型）标注
					{
						double nDir = (nSide==0 ? segAxis.IDirection(0) : (segAxis.IDirection(1)+PI))-PI/2.0;
						XVector3D vt(cos(nDir), sin(nDir));
						double nMoveDist=(vtOffset&vt); // 横向移动向量
						double nNewPara=axis.m_nPara2Next - nMoveDist;

						if (i==0) // 第一根
						{ 
							if (fabs(nNewPara)<_DIST_SNAP) // 重合就删除
							{
								if (num>1)
								{
									// modify by lgy 20120220，9.0如果单轴移动和别的轴号重合，则弹出BUG
									// m_lstAxis.Remove(i);
									if (!GetCtrlToggle())
									{
										m_lstAxis.Remove(i);
									}
								}
							}
							else
							{
								if (nNewPara*axis.m_nPara2Next<1.0E-3)//不能变正负
								{
									bBreak=TRUE;
									break;
								}
								axis.m_nPara2Next = nNewPara;
							}
							if (IsArcAxis())//圆弧轴线的情况
							{ 
								XPoint ptNew=ptVert+vtOffset;
								XArc ar=m_segFirst.GetArc();
								ar.SetRadius(ar.GetCenterPt().Distance2d(ptNew));
								if (nSide==0)
								{
									ar.SetStarAngle(ads_angle(ar.GetCenterPt(), ptNew));
								}
								else
								{
									ar.SetEndAngle(ads_angle(ar.GetCenterPt(), ptNew));
								}
								m_segFirst=ar;
							} 
							else // 直线轴网标注
							{
								vt.Scale(nMoveDist);
								m_segFirst.StartPoint() += vt;
								m_segFirst.EndPoint() += vt;
							}
						}
						else if (i==num-1) // 最后一根
						{
							TAxisInfo &axisPrev=*m_lstAxis[i-1];
							double nPrevPara=axisPrev.m_nPara2Next+nMoveDist;
							if (fabs(nPrevPara)<_DIST_SNAP)
							{
								// modify by lgy 20120220，9.0如果单轴移动和别的轴号重合，则弹出BUG
								// m_lstAxis.Remove(i);
								if (!GetCtrlToggle())
								{
									m_lstAxis.Remove(i);
								}
							}
							else  if (nPrevPara*axisPrev.m_nPara2Next<1.0E-3)
							{
								bBreak=TRUE;
								break;
							}
							axisPrev.m_nPara2Next = nPrevPara;
						}
						else // 中间的轴线
						{
							if (fabs(nNewPara)<_DIST_SNAP)
								;
							else if (nNewPara*axis.m_nPara2Next<1.0E-3)  //不能变正负
							{
								bBreak=TRUE;
								break;
							}

							TAxisInfo &axisPrev=*m_lstAxis[i-1];
							double nPrevPara=axisPrev.m_nPara2Next+nMoveDist;
							if (fabs(nPrevPara)<_DIST_SNAP)
								;
							else if (nPrevPara*axisPrev.m_nPara2Next<1.0E-3)
							{
								bBreak=TRUE;
								break;
							}
							axis.m_nPara2Next = nNewPara;
							axisPrev.m_nPara2Next = nPrevPara;

							if (fabs(axis.m_nPara2Next)<_DIST_SNAP)
							{
								// modify by lgy 20120220，9.0如果单轴移动和别的轴号重合，则弹出BUG
								// m_lstAxis.Remove(i);
								if (!GetCtrlToggle())
								{
									m_lstAxis.Remove(i);
								}
							}
							else if (fabs(axisPrev.m_nPara2Next)<_DIST_SNAP)
							{
								axisPrev.m_nPara2Next += axis.m_nPara2Next;
								// modify by lgy 20120220，9.0如果单轴移动和别的轴号重合，则弹出BUG
								// m_lstAxis.Remove(i);
								if (!GetCtrlToggle())
								{
									m_lstAxis.Remove(i);
								}
							}
						}

						if (!IsArcAxis()) // 圆弧轴网，还要处理纵向移动
						{
							XVector3D vt1(cos(nDir+PI/2), sin(nDir+PI/2));
							double nMoveDist1=(vtOffset&vt1);
							vt1.Scale(nMoveDist1); //纵向移动向量

							// modify by lgy 20120215，9.0轴号横纵移动和单轴横纵移动公用一个夹点两个功能
							if (nSide==0)
							{
								// m_segFirst.StartPoint() += vt1;
								if (!GetCtrlToggle()) // 轴号横纵移动
								{
									m_segFirst.StartPoint() += vt1;
									for (int j = 0; j < m_lstAxis.Length(); j++)
									{
										TAxisInfo &rAxis=*m_lstAxis[j];
										rAxis.m_nFlag &= ~AXF_SIDE1_LEADPOS;
									}
								}
								else // 单轴横纵移动
								{
									axis.m_dLeadPos1+=nMoveDist1;
									if (axis.m_dLeadPos1 < m_segFirst.GetLength() + _DIST_SNAP)
										axis.m_nFlag |= AXF_SIDE1_LEADPOS;
									else // sg modify 120705，如果超过了对侧引线长度，则恢复数据到认为没有单独移动的状态
									{
										axis.m_dLeadPos1 = 0;
										axis.m_nFlag &= ~AXF_SIDE1_LEADPOS;
									}
								}
							}
							else
							{
								//m_segFirst.EndPoint() += vt1;
								if (!GetCtrlToggle()) // 轴号横纵移动
								{
									m_segFirst.EndPoint() += vt1;
									for (int j = 0; j < m_lstAxis.Length(); j++)
									{
										TAxisInfo &rAxis=*m_lstAxis[j];
										rAxis.m_nFlag &= ~AXF_SIDE2_LEADPOS;
									}
								}
								else // 单轴横纵移动
								{
									XVector3D vt1(cos(nDir-PI/2), sin(nDir-PI/2));
									double nMoveDist2=(vtOffset&vt1);
									axis.m_dLeadPos2+=nMoveDist2;
									if (axis.m_dLeadPos2 < m_segFirst.GetLength() + _DIST_SNAP)
										axis.m_nFlag|=AXF_SIDE2_LEADPOS;
									else // sg modify 120705，如果超过了对侧引线长度，则恢复数据到认为没有单独移动的状态
									{
										axis.m_dLeadPos2 = 0;
										axis.m_nFlag &= ~AXF_SIDE2_LEADPOS;
									}
								}
							}
						}
					}
					
					bBreak=TRUE;
					break;
				}
				iVert++;


				if (idx==iVert && nIndice==1) //轴号偏移, 当只有一个夹点激活
				{ 
					XPoint ptLabel=GetLabelCenter(i, nSide);
					ptLabel += vtOffset;
					double nDir=segAxis.IDirection(nSide);
					XPoint ptVert=nSide? segAxis.EndPoint() : segAxis.StartPoint();
					XCurveSegment ln;
					ln=XLine(ptVert, nDir);
					double nDist=ln.GetDist2Me(ptLabel);
					double nExt=m_nCirRadius*GetPScale();
					int nTestBit1=nSide? AXF_SIDE2_LEFT : AXF_SIDE1_LEFT;
					int nTestBit2=nSide? AXF_SIDE2_RIGHT : AXF_SIDE1_RIGHT;
					if (fabs(nDist)<nExt)
					{
						axis.m_nFlag &= ~nTestBit1;
						axis.m_nFlag &= ~nTestBit2;
					}
					else if (nDist>0.0)
					{
						axis.m_nFlag |= nTestBit2;
						axis.m_nFlag &= ~nTestBit1;
					}
					else
					{
						axis.m_nFlag |= nTestBit1;
						axis.m_nFlag &= ~nTestBit2;
					}
					bBreak=TRUE;
					break;
				}
				iVert++;


				if (idx==iVert && nIndice==1) // 引线更改, 当只有一个夹点激活
				{ 
					double nDir=segAxis.IDirection(nSide)+PI;
					XVector3D vt(cos(nDir), sin(nDir));
					double nIncLead=(vtOffset&vt)/GetPScale(); // 引线长度变化

					// modify by lgy 20120214，9.0中全体引线同步改变长度由专门夹点控制
					//if (i==0) //全体引线同步改长度
					//{
					//	if (nSide==0)
					//		m_nLeaderLen1 += nIncLead;
					//	else
					//		m_nLeaderLen2 += nIncLead;
					//	for (int kk=0; kk<m_lstAxis.Length(); kk++)
					//	{
					//		TAxisInfo & rAxis=*m_lstAxis[kk];
					//		rAxis.m_nFlag &= ~nTestBit2;
					//	}
					//} 
					//else
					//{
					if (axis.m_nFlag&nTestBit2)
					{
						if (nSide==0)
							axis.m_nLeadLen1 += nIncLead;
						else
							axis.m_nLeadLen2 += nIncLead;
					} 
					else
					{
						if (nSide==0)
							axis.m_nLeadLen1 = m_nLeaderLen1+nIncLead;
						else
							axis.m_nLeadLen2 = m_nLeaderLen2+nIncLead;
						axis.m_nFlag |= nTestBit2;
					}
					//}
					bBreak=TRUE;
					break;
				}
				iVert++;
            } // for i

			if (bBreak)
				break;

			if (bHasOneAxisShow && !bBreak) // add by lgy 20120214，为轴号对象添加两个夹点， 拖拽时统一改变引线长度
			{
				if (idx == iVert) // 拖动第0侧改单侧引线长度夹点
				{
					XCurveSegment segAxis = GetAxis(0);
					double nDir=segAxis.IDirection(nSide)+PI;
					XVector3D vt(cos(nDir), sin(nDir));
					double nIncLead=(vtOffset&vt)/GetPScale(); //引线长度变化

					if (nSide == 0)
						m_nLeaderLen1 += nIncLead;
					else
						m_nLeaderLen2 += nIncLead;

					for (int j=0; j<m_lstAxis.Length(); j++) 
					{
						TAxisInfo &rAxis=*m_lstAxis[j];
						rAxis.m_nFlag &= ~nTestBit2;
					}
				}
				iVert++;
			}
		} // for side
	} // for k

	return Acad::eOk;
}


// 功能: 夹点操作
Acad::ErrorStatus TDbAxisLabelSet::subMoveStretchPointsAt(
    const AcDbIntArray& indices,
    const AcGeVector3d& offset)
{
	assertWriteEnabled();
	XPoint vtOffset(offset[0], offset[1]);

	DualList<int> indices1;
	for (long i=0; i<indices.length(); i++)
	{
		indices1[i] = indices[i];
	}
	
	{
		// 夹点顺序必须根据offset的方向。保证m_nPara2Next>0的情况更多，拉伸更自由
		XPoint vt1 = m_segFirst.EndPoint() - m_segFirst.StartPoint();
		XPoint vt2(offset.x,offset.y);
		indices1.Arrange((vt1*vt2).z > 0);
	}

	AcDbIntArray indices2; // 重新排序后的夹点编号数组
	for (i=0; i<indices1.GetLength(); i++)
	{
		indices2.append(indices1[i]);
	}


	AcDbIntArray oldVisSide; // 保存旧轴号显示或隐藏状态
	for (i=0; i<GetAxisNum(); i++)
	{
		oldVisSide.append(GetAxisVisSides(i));
		SetAxisVisSides(i,3); // 临时两侧显示隐藏轴号
	}


	// sg add 100519，解决整体拉伸时的MOVE操作
	int nIndice = indices2.length(),		// 当前选中的夹点总数
		nLstLength = m_lstAxis.Length();	// 全部夹点数量
	if (!(m_nFlag&ANF_HIDESIDE2))
	{
		nLstLength *= 2; // 拉伸操作时，每侧，每个轴号线上2个夹点
	}
	if (!(m_nFlag&ANF_HIDESIDE1))
	{
		nLstLength *= 2;
	}

	bool bIsSameSide(false); // add by xly on 110504 判断是否整侧的拉伸
	if (nIndice == (nLstLength/2))
	{
		int nStepNums(0);
		for (int i=0; i<nIndice; i++)
		{
			if (i+1 < nIndice)
			{
				int nStep = indices2[i] - indices2[i+1];
				if (nStep==1|| nStep==-1)
				{
					nStepNums++;
					continue;
				}
				else
				{
					nStepNums=0;
					break;
				}
			}
		}

		// sg modify 110517，增加判断，支持单轴标注（只标注一侧，总共2个夹点，只选中1个做延长引线）
		// if (nStepNums==(nIndice-1))
		if (nIndice!=1 && nStepNums==(nIndice-1))
		{
			bIsSameSide =true;
		}
	}


	if (nLstLength == nIndice) // 所有的夹点都被选中，整体拉伸
	{
		m_segFirst.StartPoint() += vtOffset;
		m_segFirst.EndPoint() += vtOffset;
	}
	else // 部分夹点被选中，相当于调用moveGripPointAt
	{
		AcDbIntArray axisArray;
		for (int k = 0; k < nIndice; k++)
		{
			int idx = indices2[k]; // 夹点编号

			int iVert = 0;
			for (int nSide=0; nSide<2; nSide++)
			{
				int nTestBit = nSide ? ANF_HIDESIDE2 : ANF_HIDESIDE1;
				if (m_nFlag&nTestBit)
					continue;

				int nTestBit1 = nSide ? AXF_NOSIDE2 : AXF_NOSIDE1;			// 标记是否不标注
				int nTestBit2 = nSide ? AXF_SIDE2_LEAD : AXF_SIDE1_LEAD;	// 标记是否有独自引线
/*
				if (idx==iVert && nIndice==1) // 移动引线长度, 只有夹点个数为1时
				{
					double nDir=m_segFirst.IDirection(nSide)+PI;
					XVector3D vt(cos(nDir), sin(nDir));
					m_nLeaderLen += (vtOffset&vt)/GetPScale();
					break;
				}
				iVert++;
*/

				BOOL bBreak = FALSE; // 标记是否退出nSide循环，进入下一个夹点操作
				int num = m_lstAxis.Length();
				for (int i=0; i<num; i++)
				{
					TAxisInfo &axis = *m_lstAxis[i];
					if (axis.m_nFlag&nTestBit1) // 不标注
						continue;

					XCurveSegment segAxis = GetAxis(i);
					XPoint ptVert = nSide ? segAxis.EndPoint() : segAxis.StartPoint();
					if (idx == iVert) // 轴号横纵移动点
					{
						if (axisArray.contains(i))
						{
							bBreak = TRUE;
							break;
						}
						axisArray.append(i);

						if (IsArcAxisNet() && !IsArcAxis()) // 圆弧轴网角度标注
						{
							XPoint ptCen = GetArcNetCenter();
							XPoint ptDest = ptVert + vtOffset;
							double nAng = ads_angle(ptCen, ptDest);
							if (i == 0) // 不能在第二根轴线和最后一根轴线之间
							{
								if (num >= 3)
								{
									XCurveSegment segSec = GetAxis(1);
									XCurveSegment segFinal = GetAxis(num-1);
									XSector sector=(m_nFlag&ANF_CLOCKWISE) ? 
										XSector(segFinal.IDirection(0), segSec.IDirection(0)) :
										XSector(segSec.IDirection(0), segFinal.IDirection(0));
									
									int nAngFlag = sector.AngleFlag(nAng);
									// delete by lgy 20120220，9.0拉伸时重合后CAD弹出bug
									//if ((nAngFlag==1 && !(m_nFlag&ANF_CLOCKWISE)) ||
									//	(nAngFlag==2 && (m_nFlag&ANF_CLOCKWISE)))
									//	m_lstAxis.Remove(i);

									if (nAngFlag == 0)
									{
										axis.m_nPara2Next = (m_nFlag&ANF_CLOCKWISE)?
											-CT_std_angle(nAng-segSec.IDirection(0)) :
											CT_std_angle(segSec.IDirection(0)-nAng);
									}
								}
								else if (num == 2)
								{
									double nAngNext = ads_angle(ptCen, ptVert)+axis.m_nPara2Next;
									axis.m_nPara2Next = (m_nFlag&ANF_CLOCKWISE) ?
										-CT_std_angle(nAng-nAngNext) :
										CT_std_angle(nAngNext-nAng);
									// delete by lgy 20120220，9.0拉伸时重合后CAD弹出bug
									//if (fabs(axis.m_nPara2Next) < _angSnap)
									//	m_lstAxis.Remove(i);
								}

								// 移动轴线
								if (nSide == 0)
								{
									double nDist2Cen = m_segFirst.EndPoint().Distance2d(ptCen);
									m_segFirst.StartPoint() += vtOffset;
									ads_polar(ptCen, nAng, nDist2Cen, m_segFirst.EndPoint());
								}
								else
								{
									// modify by lgy 20120220，拖拽时只移动单根轴线位置
									//double nDist2Cen = m_segFirst.StartPoint().Distance2d(ptCen);
									//m_segFirst.EndPoint() += vtOffset;
									//ads_polar(ptCen, nAng, nDist2Cen, m_segFirst.StartPoint());
									// 通过偏移角度确定m_segFirst的位置，同时由m_segFirst的终点位置到
									// 圆心的距离和偏移点距离圆心的距离的差来确定轴号距默认位置距离
									double dDist = m_segFirst.GetStartPoint().Distance2d(ptCen);
									double dDistEnd = m_segFirst.GetEndPoint().Distance2d(ptCen);
									ads_polar(ptCen, nAng, dDist, m_segFirst.StartPoint());
									ads_polar(ptCen, nAng, dDistEnd, m_segFirst.EndPoint());
									dDist = ptDest.Distance2d(ptCen);
									dDistEnd = m_segFirst.EndPoint().Distance2d(ptCen);
									double nMoveDist1 = dDist - dDistEnd;
									axis.m_nFlag|=AXF_SIDE2_LEADPOS;
									axis.m_dLeadPos2=nMoveDist1;
								}
							}
							else if (i==num-1) //不能在第1根轴线和倒数第2根轴线之间
							{
								if (num>=3)
								{
									XCurveSegment segFirst=GetAxis(0);
									XCurveSegment segSec=GetAxis(num-2);
									XSector sector=(m_nFlag&ANF_CLOCKWISE)? 
										XSector(segSec.IDirection(0), segFirst.IDirection(0)) :
										XSector(segFirst.IDirection(0), segSec.IDirection(0));
								
									TAxisInfo &axisPrev = *m_lstAxis[num-2];
									int nAngFlag = sector.AngleFlag(nAng);
									// delete by lgy 20120220，9.0拉伸时重合后CAD弹出bug
									//if ((nAngFlag==1 && (m_nFlag&ANF_CLOCKWISE)) ||
									//	(nAngFlag==2 && !(m_nFlag&ANF_CLOCKWISE)))
									//	m_lstAxis.Remove(i);
									if (nAngFlag == 0)
									{
										axisPrev.m_nPara2Next = (m_nFlag&ANF_CLOCKWISE)?
											-CT_std_angle(segSec.IDirection(0)-nAng) :
											CT_std_angle(nAng-segSec.IDirection(0));
									}
								}
								else if (num==2)
								{
									TAxisInfo &axisPrev = *m_lstAxis[num-2];
									XCurveSegment segPrev = GetAxis(num-1);
									axisPrev.m_nPara2Next = (m_nFlag&ANF_CLOCKWISE) ?
										-CT_std_angle(segPrev.IDirection(0)-nAng) :
										CT_std_angle(nAng-segPrev.IDirection(0));
									// delete by lgy 20120220，9.0拉伸时重合后CAD弹出bug
									//if (fabs(axisPrev.m_nPara2Next) < _angSnap)
									//	m_lstAxis.Remove(i);
								}

								// add by lgy 20120220，9.0拖拽选中一点时只移动单根轴号
								if (nSide == 1)
								{
									double dDist = m_segFirst.GetEndPoint().Distance2d(ptCen);
									double dDist2Cen=ptDest.Distance2d(ptCen);
									double nMoveDist1 = dDist2Cen - dDist;
									axis.m_nFlag|=AXF_SIDE2_LEADPOS;
									axis.m_dLeadPos2=nMoveDist1;
								}
							}
							else // 必须在前后两根轴线之间
							{
								XCurveSegment segPrev = GetAxis(i-1);
								XCurveSegment segNext = GetAxis(i+1);
								TAxisInfo &axisPrev = *m_lstAxis[i-1];
								XSector sector = (m_nFlag&ANF_CLOCKWISE) ? 
									XSector(segNext.IDirection(0), segPrev.IDirection(0)) :
									XSector(segPrev.IDirection(0), segNext.IDirection(0));
								
								int nAngFlag = sector.AngleFlag(nAng);
								if (nAngFlag != 0)
								{
									axis.m_nPara2Next = (m_nFlag&ANF_CLOCKWISE) ?
										-CT_std_angle(nAng-segNext.IDirection(0)) :
										CT_std_angle(segNext.IDirection(0)-nAng);
									axisPrev.m_nPara2Next = (m_nFlag&ANF_CLOCKWISE) ?
										-CT_std_angle(segPrev.IDirection(0)-nAng) :
										CT_std_angle(nAng-segPrev.IDirection(0));
									if (fabs(axis.m_nPara2Next) < _angSnap)
										// delete by lgy 20120220，9.0拉伸时重合后CAD弹出bug
										//m_lstAxis.Remove(i);
										;
									else if (fabs(axisPrev.m_nPara2Next) < _angSnap)
									{
										axisPrev.m_nPara2Next += axis.m_nPara2Next;
										// delete by lgy 20120220，9.0拉伸时重合后CAD弹出bug
										//m_lstAxis.Remove(i);
									}
								}

								// add by lgy 20120220，9.0拖拽选中一点时只移动单根轴号
								if (nSide == 1)
								{
									double dDist = m_segFirst.GetEndPoint().Distance2d(ptCen);
									double dDist2Cen=ptDest.Distance2d(ptCen);
									double nMoveDist1 = dDist2Cen - dDist;
									axis.m_nFlag|=AXF_SIDE2_LEADPOS;
									axis.m_dLeadPos2=nMoveDist1;
								}
							}
						}
						else // 直线轴网标注
						{
							double nDir = (nSide==0 ? segAxis.IDirection(0) : (segAxis.IDirection(1)+PI))-PI/2.0;
							XVector3D vt(cos(nDir), sin(nDir));
							double nMoveDist = (vtOffset&vt);
							double nNewPara = axis.m_nPara2Next - nMoveDist;
							if (i == 0)
							{ 
								if (fabs(nNewPara) < _DIST_SNAP) 
								{
									// delete by lgy 20120220，9.0拉伸时重合后CAD弹出bug
									//if (num > 1)
									//	m_lstAxis.Remove(i);
								}
								else
								{
									if (nNewPara*axis.m_nPara2Next < 1.0E-3) // 不能变正负
									{
										bBreak = TRUE;
										break;
									}
									axis.m_nPara2Next = nNewPara;
								}

								if (IsArcAxis()) // 圆弧轴线的情况
								{
									XPoint ptNew = ptVert+vtOffset;
									XArc ar = m_segFirst.GetArc();
									ar.SetRadius(ar.GetCenterPt().Distance2d(ptNew));
									if (nSide == 0)
									{
										ar.SetStarAngle(ads_angle(ar.GetCenterPt(), ptNew));
									}
									else
									{
										ar.SetEndAngle(ads_angle(ar.GetCenterPt(), ptNew));
									}
									m_segFirst = ar;
								}
								else // 直线轴网标注的情况
								{
									// modify by lgy 20120217，9.0需求要求拉伸选中轴号/单轴横纵偏移时位置改变
									//XVector3D vt1(cos(nDir+PI/2), sin(nDir+PI/2));
									//double nMoveDist1 = (vtOffset&vt1);
									//vt1.Scale(nMoveDist1); // 纵移
									//if (nSide == 0)
									//	m_segFirst.StartPoint() += vt1;
									//else
									//	m_segFirst.EndPoint() += vt1;
									if (nSide == 0)
									{
										XVector3D vt1(cos(nDir+PI/2), sin(nDir+PI/2));
										double nMoveDist1 = (vtOffset&vt1);
										vt1.Scale(nMoveDist1); // 纵移
										axis.m_dLeadPos1+=nMoveDist1;
										axis.m_nFlag|=AXF_SIDE1_LEADPOS; 
									}
									else
									{
										XVector3D vt2(cos(nDir-PI/2), sin(nDir-PI/2));
										double nMoveDist2 = (vtOffset&vt2);
										axis.m_dLeadPos2+=nMoveDist2;
										axis.m_nFlag|=AXF_SIDE2_LEADPOS;
									}
									vt.Scale(nMoveDist);

									// 横移
									m_segFirst.StartPoint() += vt;
									m_segFirst.EndPoint() += vt;
								}
							}
							else if (i == num-1)
							{
								TAxisInfo &axisPrev = *m_lstAxis[i-1];
								double nPrevPara = axisPrev.m_nPara2Next+nMoveDist;
								if (fabs(nPrevPara) < _DIST_SNAP)
								{
									// delete by lgy 20120220，9.0拉伸时重合后CAD弹出bug
									//m_lstAxis.Remove(i);
									;
								}
								else if (nPrevPara*axisPrev.m_nPara2Next < 1.0E-3)
								{
									bBreak = TRUE;
									break;
								}
								axisPrev.m_nPara2Next = nPrevPara;

								// add by lgy 20120217，9.0需求要求拉伸选中轴号/单轴横纵偏移时位置改变	
								if (nSide == 0)
								{
									XVector3D vt1(cos(nDir+PI/2), sin(nDir+PI/2));
									double nMoveDist1 = (vtOffset&vt1);
									axis.m_dLeadPos1+=nMoveDist1;
									axis.m_nFlag|=AXF_SIDE1_LEADPOS;
								}
								else
								{
									XVector3D vt2(cos(nDir-PI/2), sin(nDir-PI/2));
									double nMoveDist2 = (vtOffset&vt2);
									axis.m_dLeadPos2+=nMoveDist2;
									axis.m_nFlag|=AXF_SIDE2_LEADPOS;
								}
							}
							else
							{
								if (fabs(nNewPara) < _DIST_SNAP)
									;
								else if (nNewPara*axis.m_nPara2Next < 1.0E-3) // 不能变正负
								{
									bBreak=TRUE;
									break;
								}

								TAxisInfo &axisPrev=*m_lstAxis[i-1];
								double nPrevPara=axisPrev.m_nPara2Next+nMoveDist;
								if (fabs(nPrevPara)<_DIST_SNAP)
									;
								else if (nPrevPara*axisPrev.m_nPara2Next<1.0E-3)
								{
									bBreak = TRUE;
									break;
								}
								axis.m_nPara2Next = nNewPara;
								axisPrev.m_nPara2Next = nPrevPara;

								if (fabs(axis.m_nPara2Next) < _DIST_SNAP)
									// delete by lgy 20120220，9.0拉伸时重合后CAD弹出bug
									//m_lstAxis.Remove(i);
									;
								else if (fabs(axisPrev.m_nPara2Next) < _DIST_SNAP)
								{
									axisPrev.m_nPara2Next += axis.m_nPara2Next;
									// delete by lgy 20120220，9.0拉伸时重合后CAD弹出bug
									//m_lstAxis.Remove(i);
								}

								// add by lgy 20120217，9.0需求要求拉伸选中轴号/单轴横纵偏移时位置改变
								if (nSide == 0)
								{
									XVector3D vt1(cos(nDir+PI/2), sin(nDir+PI/2));
									double nMoveDist1 = (vtOffset&vt1);
									axis.m_dLeadPos1+=nMoveDist1;
									axis.m_nFlag|=AXF_SIDE1_LEADPOS;
								}
								else
								{
									XVector3D vt1(cos(nDir-PI/2), sin(nDir-PI/2));
									double nMoveDist2 = (vtOffset&vt1);
									axis.m_dLeadPos2+=nMoveDist2;
									axis.m_nFlag|=AXF_SIDE2_LEADPOS;
								}
							}
						}
						bBreak = TRUE;
						break;
					}
					iVert++;

					// sg delete 100518，根据8.5需求，拉伸操作屏蔽掉“轴号偏移”点
/*
					if (idx==iVert && nIndice==1) // 轴号偏移, 当只有一个夹点激活
					{
						XPoint ptLabel = GetLabelCenter(i, nSide);
						ptLabel += vtOffset;
						double nDir = segAxis.IDirection(nSide);
						XPoint ptVert = nSide? segAxis.EndPoint() : segAxis.StartPoint();
						XCurveSegment ln;
						ln = XLine(ptVert, nDir);
						double nDist = ln.GetDist2Me(ptLabel);
						double nExt = m_nCirRadius*GetPScale();

						int nTestBit1 = nSide ? AXF_SIDE2_LEFT : AXF_SIDE1_LEFT;
						int nTestBit2 = nSide ? AXF_SIDE2_RIGHT : AXF_SIDE1_RIGHT;
						if (fabs(nDist) < nExt)
						{
							axis.m_nFlag &= ~nTestBit1;
							axis.m_nFlag &= ~nTestBit2;
						}
						else if (nDist > 0.0)
						{
							axis.m_nFlag |= nTestBit2;
							axis.m_nFlag &= ~nTestBit1;
						}
						else
						{
							axis.m_nFlag |= nTestBit1;
							axis.m_nFlag &= ~nTestBit2;
						}

						bBreak = TRUE;
						break;
					}
					iVert++;
*/

					// sg modify 100518，根据8.5需求，拉伸操作支持屏蔽掉“轴号偏移”点
//					if (idx==iVert && nIndice==1) // 引线更改, 当只有一个夹点激活
					// modify by xly on 110504 判断是否整侧的拉伸增加了if (!bIsSameSide)的判断
					if (!bIsSameSide)
					{
						if (idx == iVert) // 引线更改
						{
							double nDir = segAxis.IDirection(nSide) + PI;
							XVector3D vt(cos(nDir), sin(nDir));
							double nIncLead = (vtOffset&vt)/GetPScale(); // 引线长度变化
							// delete by lgy 20120220，9.0中首个轴号得引线长度不用跟别的轴号操作一样
							//if (i == 0) // 全体引线同步改长度
							//{
							//	// sg add 100518，标记是否有其他夹点操作存在，根据此值对，首个轴号的“引线长度”执行不同操作
							//	for (int kk=1; kk<m_lstAxis.Length(); kk++)
							//	{
							//		TAxisInfo &rAxis = *m_lstAxis[kk];
							//		if (rAxis.m_nFlag&nTestBit2)
							//			;
							//		else
							//		{
							//			if (nSide == 0)
							//				rAxis.m_nLeadLen1 = m_nLeaderLen1;
							//			else
							//				rAxis.m_nLeadLen2 = m_nLeaderLen2;
							//			rAxis.m_nFlag |= nTestBit2;
							//		}
							//	}

							//	if (nSide == 0)
							//		m_nLeaderLen1 += nIncLead;
							//	else
							//		m_nLeaderLen2 += nIncLead;

							//	// sg modify 100518，标记是否有其他夹点操作存在，根据此值对，首个轴号的“引线长度”执行不同操作
							//	/*
							//	for (int kk=0; kk<m_lstAxis.Length(); kk++)
							//	{
							//	TAxisInfo &rAxis = *m_lstAxis[kk];
							//	rAxis.m_nFlag &= ~nTestBit2;
							//	}
							//	*/
							//}
							//else
							//{
							if (axis.m_nFlag&nTestBit2)
							{
								// modify by lgy 20120312，如果选中了轴号横纵移动\单轴横纵移动点
								//if (nSide == 0)
								//	axis.m_nLeadLen1 += nIncLead;
								//else
								//	axis.m_nLeadLen2 += nIncLead;
								if (k+1 < nIndice)	
								{
									//如果该处理的夹点为引线长度夹点，但是该轴的纵横移动夹点不被选中
									//如果该夹点与选中的它的下一个夹点的编号差值为1或者-1则认为同一根轴号选中了
									//纵横移动夹点
									if (indices2[k] - indices2[k+1] != 1 && indices2[k] - indices2[k+1] != -1)
									{
										if (nSide == 0)
										{
											if (m_nLeaderLen1 != 0)
											{
												axis.m_nLeadLen1 += nIncLead;
											}
										}
										else
										{
											if (m_nLeaderLen2 != 0)
											{
												axis.m_nLeadLen2 += nIncLead;
											}
										}
										axis.m_nFlag |= nTestBit2;
									}
								}

								if (k == nIndice-1)
								{
									//最后一个夹点如果是引线长度夹点
									if (indices2[k] - indices2[k-1] != 1 && indices2[k] - indices2[k-1] != -1)
									{
										if (nSide == 0)
										{
											if (m_nLeaderLen1 != 0)
											{
												axis.m_nLeadLen1 += nIncLead;
											}
										}
										else
										{
											if (m_nLeaderLen2 != 0)
											{
												axis.m_nLeadLen2 += nIncLead;
											}
										}
										axis.m_nFlag |= nTestBit2;
									}
								}
							}
							else
							{
								// modify by lgy 20120312，如果选中了轴号横纵移动\单轴横纵移动点
								// 即使选中单轴引线长度夹点仍然只实现横纵移动，不改变引线长度
								//if (nSide == 0)
								//	axis.m_nLeadLen1 = m_nLeaderLen1+nIncLead;
								//else
								//	axis.m_nLeadLen2 = m_nLeaderLen2+nIncLead;
								//axis.m_nFlag |= nTestBit2;
								if (k+1 < nIndice)
								{
									//如果该处理的夹点为引线长度夹点，但是该轴的纵横移动夹点不被选中
									//如果该夹点与选中的它的下一个夹点的编号差值为1或者-1则认为同一根轴号选中了
									//纵横移动夹点
									if (indices2[k] - indices2[k+1] != 1 && indices2[k] - indices2[k+1] != -1)
									{
										int inum = indices2[k];

										if (nSide == 0)
										{
											if (m_nLeaderLen1 != 0)	//第一侧引线长度不为0
											{
												axis.m_nLeadLen1 = m_nLeaderLen1 + nIncLead;
											}
										}
										else
										{
											if (m_nLeaderLen2 != 0)	//第二侧引线长度不为0
											{
												axis.m_nLeadLen2 = m_nLeaderLen2 + nIncLead;
											}
										}
										axis.m_nFlag |= nTestBit2;
									}
								}

								if (k == nIndice-1)
								{
									//最后一个夹点如果是引线长度夹点
									if (indices2[k] - indices2[k-1] != 1 && indices2[k] - indices2[k-1] != -1)
									{
										if (nSide == 0)
										{
											if (m_nLeaderLen1 != 0)	//如果第一侧引线长度不为0
											{
												axis.m_nLeadLen1 = m_nLeaderLen1+nIncLead;
											}
										}
										else
										{
											if (m_nLeaderLen2 != 0)//第二侧引线长度不为0
											{
												axis.m_nLeadLen2 = m_nLeaderLen2+nIncLead;
											}
										}
										axis.m_nFlag |= nTestBit2;
									}
								}
							}
							//}
							bBreak = TRUE;
							break;
						}
					
					}
						iVert++;
				} // for i
				
				if (bBreak)
					break;
			} // for side
		} // for k
	}

	for (i=0; i<GetAxisNum(); i++)
	{
		SetAxisVisSides(i, oldVisSide[i]); // 恢复轴号显示或隐藏状态
	}
	return Acad::eOk;
}

// 取得夹点说明
Acad::ErrorStatus TDbAxisLabelSet::GetGripText(int idx, CString &cs) const
{
	Acad::ErrorStatus es = Acad::eOk;
	int iVert = 0;
	for (int nSide=0; nSide<2; nSide++)
	{
		int nTestBit = nSide? ANF_HIDESIDE2 : ANF_HIDESIDE1;
		if (m_nFlag&nTestBit)
			continue;

		int nTestBit1 = nSide? AXF_NOSIDE2 : AXF_NOSIDE1;
		//if (idx==iVert) {
		//    cs=_T("改变引线长度");
		//    return es;
		//}
		//iVert++;

		// 标注整侧中是否有一个轴号是显示的
		bool bHasOneAxisShow(false);

		int num = m_lstAxis.Length();

		for (int i=0; i<num; i++)
		{
			//LH 2013-4-16 修改原因在于执行"图纸剪切"命令时,有崩溃现象出现。原因是const TAxisInfo &axis = m_lstAxis[i];赋值失败，
			//赋值失败是因为TDPtrList内部m_CurrteIndex已经到了链表末端，所以失败，添加下行代码，使其内部CurrteIndex发生变化，从而
			//保证赋值正确。
			const_cast<TDbAxisLabelSet*>(this)->m_lstAxis.MoveToHead();

			const TAxisInfo &axis = m_lstAxis[i];
			if (axis.m_nFlag&nTestBit1)
				continue;

			bHasOneAxisShow = true; // 整侧有轴号是显示的

			XCurveSegment segAxis = GetAxis(i);
			XPoint ptVert = nSide ? segAxis.EndPoint() : segAxis.StartPoint();
			if (idx == iVert)
			{
				// modify by lgy 20120215	根据9.0需求，增加夹点功能，默认为轴号横纵移动
				// if (i==0 || !IsArcAxis())
				if (!IsArcAxis())
					// cs = _T("轴号横纵移动");
					cs = GetCtrlToggle()?_T("单轴横纵移动(Ctrl-轴号横纵移动)"):_T("轴号横纵移动(Ctrl-单轴横纵移动)");
				else if (i == 0)
					cs = _T("轴号横纵移动");
				else
					cs = _T("轴号横移");
				return es;
			}
			iVert++;

			if (idx == iVert)
			{
				cs = _T("轴号偏移");
				return es;
			}
			iVert++;

			if (idx == iVert)
			{
				// modify by lgy 20120214，9.0需求需要单侧引线长度为新添加夹点控制
				// cs = (i ? _T("改单轴引线长度") : _T("改单侧引线长度"));
				cs =  _T("改单轴引线长度");
				return es;
			}
			iVert++;
		}

		if (bHasOneAxisShow) // add by lgy 20120214，为轴号对象添加两个夹点， 拖拽时统一改变引线长度
		{
			if (idx == iVert)
			{
				cs =  _T("改单侧引线长度");
				return es;
			}
			iVert++;
		}
	}

	return Acad::eInvalidInput;
}


AcDbBlockReference *
TDbAxisLabelSet::AsAxisO(const TDbSymbDrawingIndex &axo, const TCHAR *pszText) const
{
	AcDbDatabase *pDb = database();
	if (!pDb)
		return NULL;
	AcDbObjectId idBlock = InitBlock(_T("_AXISO"), pDb);
	if (!idBlock.isValid())
		return NULL;
    AcDbBlockReference *pBlk=new AcDbBlockReference(axo.GetCenter().AsAcGePoint3d(),idBlock);
    pBlk->setPropertiesFrom(&axo);
    double nSize=axo.GetRadius(FALSE)*2;
    pBlk->setScaleFactors(AcGeScale3d(nSize, nSize, nSize));
    XPoint pt1, pt2;
    double nHeight=axo.GetTextParam1(pt1, pt2);

    AcDbVoidPtrArray entSet;
    XExplodeStream dc(entSet);
    dc.SetAutoProp(FALSE);
    dc.SetStyle(axo.GetTextStyleId());
    dc.DrawTextFit(pszText? pszText : _T(""), pt1, pt2, nHeight);
    if (entSet.length()==1) 
	{   
        AcDbText *pText=AcDbText::cast((AcDbEntity *)entSet[0]);
        if (pText)
		{
	        AcDbAttribute *attr = new AcDbAttribute;
            attr->setPropertiesFrom(&axo);
            attr->setLayer(axo.GetTextLayerId());
            attr->setHeight(pText->height());
            if (pszText)
	            attr->setTextString(pszText);
			
			//modified by whl on 060218
			//attr->setRotation(axo.GetTextRotation());
			attr->setRotation(pText->rotation());

	        attr->setHorizontalMode(pText->horizontalMode());
	        attr->setVerticalMode(pText->verticalMode());
	        attr->setAlignmentPoint(pText->alignmentPoint());
	        attr->setTextStyle(pText->textStyle());
	        attr->setWidthFactor(pText->widthFactor());
	        attr->setPosition(pText->position());
	        attr->setTag(_T("A"));
            pBlk->appendAttribute(attr);
			attr->close();
        }
    }

	ReleaseEntSet(entSet);//add by whl on 060218

	return pBlk;
}

long TDbAxisLabelSet::GetSubTextNum()const
{
	long count=0;
    for (int i=0; i<m_lstAxis.Length(); i++) 
	{
		//LH 2013-4-16 修改原因在于执行"图纸剪切"命令时,有崩溃现象出现。原因是const TAxisInfo &axis = m_lstAxis[i];赋值失败，
		//赋值失败是因为TDPtrList内部m_CurrteIndex已经到了链表末端，所以失败，添加下行代码，使其内部CurrteIndex发生变化，从而
		//保证赋值正确。
		const_cast<TDbAxisLabelSet*>(this)->m_lstAxis.MoveToHead();
		const TAxisInfo &axis=m_lstAxis[i];
        if (i==0 && (m_nFlag&ANF_PREVLINK))
            continue;

		if (!(m_nFlag&ANF_HIDESIDE1)) 
            if (!(axis.m_nFlag&AXF_NOSIDE1))
                count++;
		if (!(m_nFlag&ANF_HIDESIDE2)) 
            if (!(axis.m_nFlag&AXF_NOSIDE2))
                count++;
    }
	return count;
}
TSubText* TDbAxisLabelSet::GetSubText(long iText)const
{
	XPushMemVar<BOOL> vTemp(g_bExplodeSubText,TRUE);

	AcDbVoidPtrArray allEnt;
	XExplodeStream dc(allEnt);
	dc.SetPropertiesFrom(this);//add by whl on 060404
	ExplodeOrDraw2d(dc);
	int count=0;
	TSubText*pSubText=NULL;
	for (long i=0;i<allEnt.length();i++)
	{
		AcDbEntity *pEnt=(AcDbEntity*)allEnt[i];
		if (pEnt!=NULL&&pEnt->isKindOf(TDbSymbDrawingIndex::desc()))
		{
			if (iText==count)
			{
				TDbSymbDrawingIndex* pLabel=TDbSymbDrawingIndex::cast(pEnt);
				pSubText=pLabel->GetSubText(0);
				if (pSubText!=NULL)
				{
					pSubText->SetObjectId(objectId());
					pSubText->SetIndex(iText);
					CString s2=pLabel->GetDrawingLabel();
					if (s2!=_T(""))
					{
						CString s1=pLabel->GetIndexLabel();
						pSubText->SetText(s1+_T("/")+s2);
					}
				}
				break;
			}

			count++;
		}
	}
	ReleaseEntSet(allEnt);
	if (pSubText!=NULL)
		pSubText->SetMenuType(2);
	return pSubText;
}

TSubText* TDbAxisLabelSet::HitTestText(XPoint pt)const
{
	XPushMemVar<BOOL> vTemp(g_bExplodeSubText,TRUE);

	AcDbVoidPtrArray allEnt;
	XExplodeStream dc(allEnt);
	dc.SetPropertiesFrom(this);//add by whl on 060404
	ExplodeOrDraw2d(dc);
	int count=0;
	TSubText*pSubText=NULL;
	for (long i=0;i<allEnt.length();i++)
	{
		AcDbEntity *pEnt=(AcDbEntity*)allEnt[i];
		if (pEnt!=NULL&&pEnt->isKindOf(TDbSymbDrawingIndex::desc()))
		{
			TDbSymbDrawingIndex* pLabel=TDbSymbDrawingIndex::cast(pEnt);

			pSubText=pLabel->HitTestText(pt);
			if (pSubText!=NULL)
			{
				pSubText->SetObjectId(objectId());
				pSubText->SetIndex(count);
				CString s2=pLabel->GetDrawingLabel();
				if (s2!=_T(""))
				{
					CString s1=pLabel->GetIndexLabel();
					pSubText->SetText(s1+_T("/")+s2);
				}
				break;
			}
			count++;
		}
	}
	ReleaseEntSet(allEnt);
	if (pSubText!=NULL)
		pSubText->SetMenuType(2);
	return pSubText;
}

void TDbAxisLabelSet::SetSubText(long iText,CString sText)
{
	BOOL bSort=FALSE,bReverse;
	if (sText.GetLength()>1)
	{
		if (sText.GetAt(sText.GetLength()-1)==_T('<'))//正排
		{
			bSort=TRUE;
			bReverse=FALSE;
			sText=sText.Left(sText.GetLength()-1);
		}
		else if (sText.GetAt(0)==_T('>'))//倒排
		{
			bSort=TRUE;
			bReverse=TRUE;
			sText=sText.Right(sText.GetLength()-1);
		}
	}
	
	int count=0;
    for (int i=0; i<m_lstAxis.Length(); i++) 
	{
        TAxisInfo &axis=*m_lstAxis[i];
        if (i==0 && (m_nFlag&ANF_PREVLINK))
            continue;

		if (!(m_nFlag&ANF_HIDESIDE1)) 
            if (!(axis.m_nFlag&AXF_NOSIDE1))
			{
				if (count==iText)
				{
					SetLabel(i,sText,bSort,bReverse);
					break;
				}

				count++;
			}

		if (!(m_nFlag&ANF_HIDESIDE2)) 
            if (!(axis.m_nFlag&AXF_NOSIDE2))
			{
				if (count==iText)
				{
					SetLabel(i,sText,bSort,bReverse);
					break;
				}

				count++;
			}
    }
}

// sg add 120214，根据9.0的新需求，修改轴号对象，支持导出
Acad::ErrorStatus TDbAxisLabelSet::DownGradeSave(int nDrawMode, AcDbVoidPtrArray &entSet,
												 BOOL *bErase)
{
	Acad::ErrorStatus es = Acad::eOk;

	// 导出T5-T8格式，需要做特殊处理
	if (g_nSaveTArchVer > 3 && g_nSaveTArchVer < 9)
	{
		if (IsHideAllAxisText()) // 隐藏轴号的情况
		{
			XExplodeStream dc(entSet);
			if (!OnExplodeOrDraw(dc))
				return Acad::eOk;

			dc.SetPropertiesFrom(this);
			TDbAxisLabelSet *pAxisLabel = NULL; // 轴网标注
			{
				XPushMemVar<int> vTemp(g_nSaveTArchVer, _TCH_VERSION);
				pAxisLabel = (TDbAxisLabelSet*)clone();
			}

			int nAxisNum = pAxisLabel->m_lstAxis.Length();
			for (int i=0; i<nAxisNum; i++) 
			{
				TAxisInfo &axis = *pAxisLabel->m_lstAxis[i];
				axis.m_sText = _T("");
			}
			dc.DrawEntity(*pAxisLabel);

			if (bErase)
				*bErase = TRUE;
			return es;
		}

		// 判断单根引线的端头是否单独修改过
		{
			bool bModify = false;
			int nAxisNum = m_lstAxis.Length();
			for (int i=0; i<nAxisNum; i++) 
			{
				TAxisInfo &axis = *m_lstAxis[i];
				if (axis.m_nFlag&AXF_SIDE1_LEADPOS || axis.m_nFlag&AXF_SIDE2_LEADPOS)
				{
					bModify = true;
					break;
				}
			}

			if (bModify) // 炸散
			{
				XPushMemVar<BOOL> vTemp(XExplodeStream::m_bFullExplode, TRUE); // 完全分解
				XPushMemVar<BOOL> vTemp2(XExplodeStream::m_bExportTch4, TRUE); // 保证炸开的图层正确，临时设置为全部炸开
				XExplodeStream dc(entSet);
				if (!OnExplodeOrDraw(dc)) // 解决导出后，无遮挡关系的BUG，必须有
					return Acad::eOk;

				dc.SetPropertiesFrom(this);
				if (nDrawMode == DRAW_2D)
					es = ExplodeOrDraw2d(dc);
				else
					es = ExplodeOrDraw3d(dc);

				if (bErase)
					*bErase = TRUE;
				return es;
			}
		}
	}

	es = TDbEntity::DownGradeSave(nDrawMode, entSet, bErase);
	return es;
}

Acad::ErrorStatus 
TDbAxisLabelSet::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
	extern BOOL g_bDrawAxisLabel;
	
	assertReadEnabled();
	INT_PTR nQuickMarker = GetQuickMarker(); // 加速捕捉
	int nAxisNum = m_lstAxis.Length();
	
	double nPara2First = 0.0;
	BOOL bLine = m_segFirst.Is(CURVE_LINE);
	XPoint ptCen;
	if ((m_nFlag&ANF_CIRARC) && bLine) // 圆弧轴网中的角度标注
	{
		ads_polar(m_segFirst.StartPoint(), m_segFirst.IDirection(0)+PI, m_nDist2Center, ptCen);
	}
	
    double nCirRad = m_nCirRadius*GetPScale();

    int nGsMarker = 1; 
    double nDefLeaderLen1 = m_nLeaderLen1*GetPScale();
	double nDefLeaderLen2 = m_nLeaderLen2*GetPScale();


    for (int i=0; i<nAxisNum; i++) 
	{
 		//LH 2013-4-16 修改原因在于执行"图纸剪切"命令时,有崩溃现象出现。原因是const TAxisInfo &axis = m_lstAxis[i];赋值失败，
		//赋值失败是因为TDPtrList内部m_CurrteIndex已经到了链表末端，所以失败，添加下行代码，使其内部CurrteIndex发生变化，从而
		//保证赋值正确。
		const_cast<TDbAxisLabelSet*>(this)->m_lstAxis.MoveToHead();

        const TAxisInfo &axis = m_lstAxis[i];
        if (i==0 && (m_nFlag&ANF_PREVLINK))
		{
            nPara2First += axis.m_nPara2Next;
            continue;
        }

        XCurveSegment segAxis;
        if ((m_nFlag&ANF_CIRARC) && bLine) // 圆弧轴网中的角度标注
		{
            XPoint pt1, pt2;
            double nDir = m_segFirst.IDirection(0)+nPara2First;
            ads_polar(ptCen, nDir, m_nDist2Center, pt1);
            ads_polar(ptCen, nDir, m_nDist2Center+m_segFirst.GetLength(), pt2);
            segAxis = XLine(pt1, pt2);
        }
		else
		{
            segAxis = m_segFirst.Offset(nPara2First, LS_FINITE);
        }

		// modify by lgy 20120215，如果轴线端点不在默认位置，则重新计算
		if (axis.m_nFlag&AXF_SIDE1_LEADPOS || axis.m_nFlag&AXF_SIDE2_LEADPOS)
			segAxis = GetAxis(i);

        dc.SetSelectionMarker(nGsMarker);
        nGsMarker++;
        if (nQuickMarker && (nGsMarker-1)!=nQuickMarker) // 用于捕捉时加速
		{
		}
		else if (!(m_nFlag&ANF_HIDESIDE1)) // 标注起始侧
		{
            if (!(axis.m_nFlag&AXF_NOSIDE1)) // 标注当前轴号
			{
				double nLeaderLen = nDefLeaderLen1;
				if (axis.m_nFlag&AXF_SIDE1_LEAD)
					nLeaderLen = axis.m_nLeadLen1*GetPScale();

				XPoint ptLeader1;
                double nDir = segAxis.IDirection(0);
				if (segAxis.GetLength() < _DIST_SNAP) // sg add 120704，解决单个轴号2点重合的时候，会出现方向错误的问题
					nDir = m_segFirst.IDirection(0);
                ads_polar(segAxis.StartPoint(), nDir+PI, nLeaderLen, ptLeader1);

				// sg add 100721，当图形导出为T3时，判断长度是否为0，如果为0，不绘制
				if (dc.IsExportTch4())
				{
					if (fabs(nLeaderLen) < _DIST_SNAP)
						;
					else
						dc << XLine(segAxis.StartPoint(), ptLeader1);
				}
				else
					dc << XLine(segAxis.StartPoint(), ptLeader1);

                XPushMemVar<BOOL> vTemp0(g_bDrawAxisLabel, TRUE);
                XPoint ptCir;
                ads_polar(ptLeader1, nDir+PI, nCirRad, ptCir);

                TDbSymbDrawingIndex ent;
                ent.setPropertiesFrom(this);
				ent.SetSymbText(FALSE); // sg add 090720，8.0临时解决图层问题
                ent.SetLineWidth(0.0);
				ent.SetTextRatio(DocGetAxisLabelTextRatio()); // sg add 090512，设置文字字高系数
                ent.SetTextStyleId(m_idTextStyle);
				ent.SetTextLayerId(m_idTextLayer);
				int nOldStyle = GetCircleTextStyle(); // sg add 110210，增加是否使用旧圆圈文字样式
				ent.SetOldStyle(nOldStyle);

				// add by lgy 20120209，判断是否隐藏文字
				if(!IsHideAllAxisText())
				{
					ent.SetIndexLabel(axis.m_sText);
				}

				const TCHAR *pSep=_tcschr(axis.m_sText, _T('/'));
                if (pSep && !_tcschr(axis.m_sText, _T('-')))
				{
                    XString s1, s2;
					StrCpy(s2, axis.m_sText, pSep);
					StrCpy(s1, pSep+1, NULL);

					// add by lgy 20120209，判断是否隐藏文字
					if(!IsHideAllAxisText())
					{
						ent.SetIndexLabel(s2);
						ent.SetDrawingLabel(s1);
					}
                }
                ent.SetRadius(m_nCirRadius);

                if ((axis.m_nFlag&AXF_SIDE1_LEFT) || (axis.m_nFlag&AXF_SIDE1_RIGHT))
				{
                    double nDirCen = nDir + ((axis.m_nFlag&AXF_SIDE1_LEFT)? PI*0.75 : -PI*0.75);
                    ads_polar(ptLeader1, nDirCen, sqrt(2.0)*m_nCirRadius*GetPScale(), ptCir);
                    XPoint ptTemp;
                    ads_polar(ptCir, nDirCen+PI, m_nCirRadius*GetPScale(), ptTemp);
					
					// modify by xly on 110306 引线长度为0是不绘制偏移后的尾巴
					//dc << XLine(ptTemp, ptLeader1);
					if (m_nLeaderLen1>_DIST_SNAP)
					{ 
						dc << XLine(ptTemp, ptLeader1);
					}
                  
                } 
                ent.SetCenter(ptCir);

				TPushProperty vProp(&ent, dc);
                if (!g_bOsnapExpl && _tcscmp(dc.Desc(), XExplodeStream::Descriptor())==0 )
				{                
                    if (dc.IsFullExplode())
					{
                        double nSize=m_nCirRadius*GetPScale()*2;
                        if (dc.IsExportTch4())
						{
							// sg modify 120705，解决隐藏轴号，导出T3后的显示问题
                            //AcDbBlockReference *pAxis=AsAxisO(ent, axis.m_sText);
                            AcDbBlockReference *pAxis = NULL;
							if (!IsHideAllAxisText())
								pAxis = AsAxisO(ent, axis.m_sText);
							else
								pAxis = AsAxisO(ent, _T(""));
							
                            if (pAxis)
                                ((XExplodeStream &)dc).Append(pAxis, FALSE);
                        }
						else
                            ent.ExplodeOrDraw2d(dc);
                    }
					else
					{
                        dc.DrawEntity(ent);
                    }
                }
				else
				{
                   ent.ExplodeOrDraw2d(dc);                    
                }
            }
			else if (m_bShowHide) // 需要虚显当前轴号
			{
				AcDbObjectId idLine=dc.GetLineTypeId();
				dc.SetLineType(InitLineType(_T("DASH"),database()));
				int oldColor=dc.GetColor();
				dc.SetColor(g_nHideAxisLabelColor);

				double nLeaderLen=nDefLeaderLen1;
				if (axis.m_nFlag&AXF_SIDE1_LEAD)
					nLeaderLen=axis.m_nLeadLen1*GetPScale();
                XPoint ptLeader1;
                double nDir=segAxis.IDirection(0);
				if (segAxis.GetLength() < _DIST_SNAP) // sg add 120704，解决单个轴号2点重合的时候，会出现方向错误的问题
					nDir = m_segFirst.IDirection(0);
                ads_polar(segAxis.StartPoint(), nDir+PI, nLeaderLen, ptLeader1);
                dc << XLine(segAxis.StartPoint(), ptLeader1);

                XPushMemVar<BOOL> vTemp0(g_bDrawAxisLabel, TRUE);
                XPoint ptCir;
                ads_polar(ptLeader1, nDir+PI, nCirRad, ptCir);

                TDbSymbDrawingIndex ent;
				ent.SetSymbText(FALSE); // sg add 090720，8.0临时解决图层问题
                ent.SetLineWidth(0.0);
				ent.SetTextRatio(DocGetAxisLabelTextRatio()); // sg add 090512，设置文字字高系数
                ent.SetTextStyleId(m_idTextStyle);
				ent.SetTextLayerId(m_idTextLayer);
				int nOldStyle = GetCircleTextStyle(); // sg add 110210，增加是否使用旧圆圈文字样式
				ent.SetOldStyle(nOldStyle);

				// add by lgy 20120209，判断是否隐藏文字
				if(!IsHideAllAxisText())
				{
					ent.SetIndexLabel(axis.m_sText);
				}

				const TCHAR *pSep=_tcschr(axis.m_sText, _T('/'));
                if (pSep && !_tcschr(axis.m_sText, _T('-')))
				{
                    XString s1, s2;
					StrCpy(s2, axis.m_sText, pSep);
					StrCpy(s1, pSep+1, NULL);
					// add by lgy 20120209，判断是否隐藏文字
					if(!IsHideAllAxisText())
					{
						ent.SetIndexLabel(s2);
						ent.SetDrawingLabel(s1);
					}
				}
                ent.SetRadius(m_nCirRadius);

                if ((axis.m_nFlag&AXF_SIDE1_LEFT) || (axis.m_nFlag&AXF_SIDE1_RIGHT))
				{
                    double nDirCen = nDir + ((axis.m_nFlag&AXF_SIDE1_LEFT)? PI*0.75 : -PI*0.75);
                    ads_polar(ptLeader1, nDirCen, sqrt(2.0)*m_nCirRadius*GetPScale(), ptCir);
                    XPoint ptTemp;
                    ads_polar(ptCir, nDirCen+PI, m_nCirRadius*GetPScale(), ptTemp);
                    
					// modify by xly on 110306 引线长度为0是不绘制偏移后的尾巴
					//dc << XLine(ptTemp, ptLeader1);
					if (m_nLeaderLen1>_DIST_SNAP)
					{ 
						dc << XLine(ptTemp, ptLeader1);
					}
                } 
                ent.SetCenter(ptCir);
                ent.ExplodeOrDraw2d(dc);     

				dc.SetColor(oldColor);
				dc.SetLineType(idLine);
			}
        }
		else if (m_bShowHide) // 不标注起始侧，需要虚显当前轴号
		{
			AcDbObjectId idLine=dc.GetLineTypeId();
			dc.SetLineType(InitLineType(_T("DASH"),database()));
			int oldColor=dc.GetColor();
			dc.SetColor(g_nHideAxisLabelColor);

			double nLeaderLen=nDefLeaderLen1;
			if (axis.m_nFlag&AXF_SIDE1_LEAD)
				nLeaderLen=axis.m_nLeadLen1*GetPScale();

			XPoint ptLeader1;
			double nDir=segAxis.IDirection(0);
			if (segAxis.GetLength() < _DIST_SNAP) // sg add 120704，解决单个轴号2点重合的时候，会出现方向错误的问题
				nDir = m_segFirst.IDirection(0);
			ads_polar(segAxis.StartPoint(), nDir+PI, nLeaderLen, ptLeader1);
			dc << XLine(segAxis.StartPoint(), ptLeader1);

			XPushMemVar<BOOL> vTemp0(g_bDrawAxisLabel, TRUE);
			XPoint ptCir;
			ads_polar(ptLeader1, nDir+PI, nCirRad, ptCir);

			TDbSymbDrawingIndex ent;
			ent.SetSymbText(FALSE); // 8.0临时解决图层问题
			ent.SetLineWidth(0.0);
			ent.SetTextRatio(DocGetAxisLabelTextRatio()); // 设置文字字高系数
			ent.SetTextStyleId(m_idTextStyle);
			ent.SetTextLayerId(m_idTextLayer);
			int nOldStyle = GetCircleTextStyle(); // 增加是否使用旧圆圈文字样式
			ent.SetOldStyle(nOldStyle);
			
			if (!IsHideAllAxisText()) // 判断文字是否隐藏
				ent.SetIndexLabel(axis.m_sText);

			const TCHAR *pSep=_tcschr(axis.m_sText, _T('/'));
			if (pSep && !_tcschr(axis.m_sText, _T('-')))
			{
				XString s1, s2;
				StrCpy(s2, axis.m_sText, pSep);
				StrCpy(s1, pSep+1, NULL);
				if (!IsHideAllAxisText()) // 判断文字是否隐藏
				{
					ent.SetIndexLabel(s2);
					ent.SetDrawingLabel(s1);
				}
			}
			ent.SetRadius(m_nCirRadius);

			if ((axis.m_nFlag&AXF_SIDE1_LEFT) || (axis.m_nFlag&AXF_SIDE1_RIGHT))
			{
				double nDirCen = nDir + ((axis.m_nFlag&AXF_SIDE1_LEFT)? PI*0.75 : -PI*0.75);
				ads_polar(ptLeader1, nDirCen, sqrt(2.0)*m_nCirRadius*GetPScale(), ptCir);
				XPoint ptTemp;
				ads_polar(ptCir, nDirCen+PI, m_nCirRadius*GetPScale(), ptTemp);
				
				if (m_nLeaderLen1>_DIST_SNAP) // 引线长度为0是不绘制偏移后的尾巴
				{ 
					dc << XLine(ptTemp, ptLeader1);
				}
			} 
			ent.SetCenter(ptCir);
			ent.ExplodeOrDraw2d(dc);

			dc.SetColor(oldColor);
			dc.SetLineType(idLine);
		}


        dc.SetSelectionMarker(nGsMarker);
        nGsMarker++;
        if (nQuickMarker && (nGsMarker-1)!=nQuickMarker) // 用于捕捉时加速
		{
		}
		else if (!(m_nFlag&ANF_HIDESIDE2)) // 标注末侧
		{
            if (!(axis.m_nFlag&AXF_NOSIDE2))
			{
				double nLeaderLen=nDefLeaderLen2;
				if (axis.m_nFlag&AXF_SIDE2_LEAD)
					nLeaderLen = axis.m_nLeadLen2*GetPScale();
                XPoint ptLeader1;
                double nDir=segAxis.IDirection(1);
				if (segAxis.GetLength() < _DIST_SNAP) // sg add 120704，解决单个轴号2点重合的时候，会出现方向错误的问题
					nDir = m_segFirst.IDirection(1);
                ads_polar(segAxis.EndPoint(), nDir+PI, nLeaderLen, ptLeader1);
                dc << XLine(segAxis.EndPoint(), ptLeader1);

                XPushMemVar<BOOL> vTemp0(g_bDrawAxisLabel, TRUE);
                XPoint ptCir;
                ads_polar(ptLeader1, nDir+PI, nCirRad, ptCir);

                TDbSymbDrawingIndex ent;
                ent.setPropertiesFrom(this);
				ent.SetSymbText(FALSE); // sg add 090720，8.0临时解决图层问题
                ent.SetLineWidth(0.0);
				ent.SetTextRatio(DocGetAxisLabelTextRatio()); // sg add 090512，设置文字字高系数
                ent.SetTextStyleId(m_idTextStyle);
				ent.SetTextLayerId(m_idTextLayer);
				int nOldStyle = GetCircleTextStyle(); // sg add 110210，增加是否使用旧圆圈文字样式
				ent.SetOldStyle(nOldStyle);

				// add by lgy 20120209，判断是否隐藏文字
				if(!IsHideAllAxisText())
				{
					ent.SetIndexLabel(axis.m_sText);
				}

				const TCHAR *pSep=_tcschr(axis.m_sText, _T('/'));
				if (pSep && !_tcschr(axis.m_sText, _T('-')))
				{
					XString s1, s2;
					StrCpy(s2, axis.m_sText, pSep);
					StrCpy(s1, pSep+1, NULL);
					// add by lgy 20120209，判断是否隐藏文字
					if(!IsHideAllAxisText())
					{
						ent.SetIndexLabel(s2);
						ent.SetDrawingLabel(s1);
					}
				}
				ent.SetRadius(m_nCirRadius);

                if ((axis.m_nFlag&AXF_SIDE2_LEFT) || (axis.m_nFlag&AXF_SIDE2_RIGHT))
				{
                    double nDirCen = nDir + ((axis.m_nFlag&AXF_SIDE2_LEFT)? PI*0.75 : -PI*0.75);
                    ads_polar(ptLeader1, nDirCen, sqrt(2.0)*m_nCirRadius*GetPScale(), ptCir);
                    XPoint ptTemp;
                    ads_polar(ptCir, nDirCen+PI, m_nCirRadius*GetPScale(), ptTemp);

					// modify by xly on 110306 引线长度为0是不绘制偏移后的尾巴
					//  dc << XLine(ptTemp, ptLeader1);
					if (m_nLeaderLen1>_DIST_SNAP)
					{ 
						dc << XLine(ptTemp, ptLeader1);
					}
             
                } 
                ent.SetCenter(ptCir);

                TPushProperty vProp(&ent, dc);
                if (!g_bOsnapExpl && _tcscmp(dc.Desc(), XExplodeStream::Descriptor())==0)
				{
                    if (dc.IsFullExplode())
					{
                        double nSize=m_nCirRadius*GetPScale()*2;
                        if (dc.IsExportTch4())
						{
							// sg modify 120705，解决隐藏轴号，导出T3后的显示问题
                            //AcDbBlockReference *pAxis=AsAxisO(ent, axis.m_sText);
                            AcDbBlockReference *pAxis = NULL;
							if (!IsHideAllAxisText())
								pAxis = AsAxisO(ent, axis.m_sText);
							else
								pAxis = AsAxisO(ent, _T(""));

							if (pAxis)
                                ((XExplodeStream &)dc).Append(pAxis, FALSE);
                        }
						else
                            ent.ExplodeOrDraw2d(dc);
                    }
					else 
					{
						dc.DrawEntity(ent);    
					}
				}
				else
				{
					ent.ExplodeOrDraw2d(dc);
				}
			}
			else if (m_bShowHide)
			{
				AcDbObjectId idLine=dc.GetLineTypeId();
				dc.SetLineType(InitLineType(_T("DASH"),database()));
				int oldColor=dc.GetColor();
				dc.SetColor(g_nHideAxisLabelColor);

				double nLeaderLen=nDefLeaderLen2;
				if (axis.m_nFlag&AXF_SIDE2_LEAD)
					nLeaderLen = axis.m_nLeadLen2*GetPScale();
                XPoint ptLeader1;
                double nDir=segAxis.IDirection(1);
				if (segAxis.GetLength() < _DIST_SNAP) // sg add 120704，解决单个轴号2点重合的时候，会出现方向错误的问题
					nDir = m_segFirst.IDirection(1);
                ads_polar(segAxis.EndPoint(), nDir+PI, nLeaderLen, ptLeader1);
                dc << XLine(segAxis.EndPoint(), ptLeader1);

                XPushMemVar<BOOL> vTemp0(g_bDrawAxisLabel, TRUE);
                XPoint ptCir;
                ads_polar(ptLeader1, nDir+PI, nCirRad, ptCir);

                TDbSymbDrawingIndex ent;
				ent.SetSymbText(FALSE); // sg add 090720，8.0临时解决图层问题
                ent.SetLineWidth(0.0);
				ent.SetTextRatio(DocGetAxisLabelTextRatio()); // sg add 090512，设置文字字高系数
                ent.SetTextStyleId(m_idTextStyle);
				ent.SetTextLayerId(m_idTextLayer);
				int nOldStyle = GetCircleTextStyle(); // sg add 110210，增加是否使用旧圆圈文字样式
				ent.SetOldStyle(nOldStyle);

 				// add by lgy 20120209，判断是否隐藏文字
				if(!IsHideAllAxisText())
				{
					ent.SetIndexLabel(axis.m_sText);
				}

				const TCHAR *pSep=_tcschr(axis.m_sText, _T('/'));
				if (pSep && !_tcschr(axis.m_sText, _T('-'))) 
				{
					XString s1, s2;
					StrCpy(s2, axis.m_sText, pSep);
					StrCpy(s1, pSep+1, NULL);
					// add by lgy 20120209，判断是否隐藏文字
					if(!IsHideAllAxisText())
					{
						ent.SetIndexLabel(s2);
						ent.SetDrawingLabel(s1);
					}
				}
				ent.SetRadius(m_nCirRadius);

                if ((axis.m_nFlag&AXF_SIDE2_LEFT) || (axis.m_nFlag&AXF_SIDE2_RIGHT))
				{
                    double nDirCen = nDir + ((axis.m_nFlag&AXF_SIDE2_LEFT)? PI*0.75 : -PI*0.75);
                    ads_polar(ptLeader1, nDirCen, sqrt(2.0)*m_nCirRadius*GetPScale(), ptCir);
                    XPoint ptTemp;
                    ads_polar(ptCir, nDirCen+PI, m_nCirRadius*GetPScale(), ptTemp);
                    
					// modify by xly on 110306 引线长度为0是不绘制偏移后的尾巴
					// dc << XLine(ptTemp, ptLeader1);
					if (m_nLeaderLen1>_DIST_SNAP)
					{ 
						dc << XLine(ptTemp, ptLeader1);
					}

                } 
                ent.SetCenter(ptCir);
                ent.ExplodeOrDraw2d(dc);

				dc.SetColor(oldColor);
				dc.SetLineType(idLine);
			}
        }
		else if (m_bShowHide) // 不标注起始侧，需要虚显当前轴号
		{
			AcDbObjectId idLine=dc.GetLineTypeId();
			dc.SetLineType(InitLineType(_T("DASH"),database()));
			int oldColor=dc.GetColor();
			dc.SetColor(g_nHideAxisLabelColor);

			double nLeaderLen=nDefLeaderLen2;
			if (axis.m_nFlag&AXF_SIDE2_LEAD)
				nLeaderLen = axis.m_nLeadLen2*GetPScale();
			XPoint ptLeader1;
			double nDir=segAxis.IDirection(1);
			if (segAxis.GetLength() < _DIST_SNAP) // sg add 120704，解决单个轴号2点重合的时候，会出现方向错误的问题
				nDir = m_segFirst.IDirection(1);
			ads_polar(segAxis.EndPoint(), nDir+PI, nLeaderLen, ptLeader1);
			dc << XLine(segAxis.EndPoint(), ptLeader1);

			XPushMemVar<BOOL> vTemp0(g_bDrawAxisLabel, TRUE);
			XPoint ptCir;
			ads_polar(ptLeader1, nDir+PI, nCirRad, ptCir);

			TDbSymbDrawingIndex ent;
			ent.SetSymbText(FALSE); // sg add 090720，8.0临时解决图层问题
			ent.SetLineWidth(0.0);
			ent.SetTextRatio(DocGetAxisLabelTextRatio()); // sg add 090512，设置文字字高系数
			ent.SetTextStyleId(m_idTextStyle);
			ent.SetTextLayerId(m_idTextLayer);
			int nOldStyle = GetCircleTextStyle(); // sg add 110210，增加是否使用旧圆圈文字样式
			ent.SetOldStyle(nOldStyle);

			// add by lgy 20120209，判断是否隐藏文字
			if(!IsHideAllAxisText())
			{
				ent.SetIndexLabel(axis.m_sText);
			}

			const TCHAR *pSep=_tcschr(axis.m_sText, _T('/'));
			if (pSep && !_tcschr(axis.m_sText, _T('-'))) 
			{
				XString s1, s2;
				StrCpy(s2, axis.m_sText, pSep);
				StrCpy(s1, pSep+1, NULL);
				// add by lgy 20120209，判断是否隐藏文字
				if(!IsHideAllAxisText())
				{
					ent.SetIndexLabel(s2);
					ent.SetDrawingLabel(s1);
				}
			}
			ent.SetRadius(m_nCirRadius);

			if ((axis.m_nFlag&AXF_SIDE2_LEFT) || (axis.m_nFlag&AXF_SIDE2_RIGHT))
			{
				double nDirCen = nDir + ((axis.m_nFlag&AXF_SIDE2_LEFT)? PI*0.75 : -PI*0.75);
				ads_polar(ptLeader1, nDirCen, sqrt(2.0)*m_nCirRadius*GetPScale(), ptCir);
				XPoint ptTemp;
				ads_polar(ptCir, nDirCen+PI, m_nCirRadius*GetPScale(), ptTemp);

				// modify by xly on 110306 引线长度为0是不绘制偏移后的尾巴
				// dc << XLine(ptTemp, ptLeader1);
				if (m_nLeaderLen1>_DIST_SNAP)
				{ 
					dc << XLine(ptTemp, ptLeader1);
				}

			} 
			ent.SetCenter(ptCir);
			ent.ExplodeOrDraw2d(dc);

			dc.SetColor(oldColor);
			dc.SetLineType(idLine);
		}

        nPara2First += axis.m_nPara2Next;
    }
    return Acad::eOk;
}


/* * * * * * * * * * 取 动 态 属 性 显 示 数 据 的 函 数 * * * * * * * * * */
void TDbAxisLabelSet::GetTips(DList<TObjInfoUnit> &lstInfo) const
{
   lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("轴网标注")));
   XString sName=GetSymbolName(m_idTextStyle);
   lstInfo.Append(new TObjInfoUnit(_T("文字样式"), sName));
   const TCHAR *szDisp=NULL;
   if (m_nFlag&ANF_HIDESIDE1) szDisp=_T("终止侧");
   else if (m_nFlag&ANF_HIDESIDE2) szDisp=_T("起始侧");
   else szDisp=_T("双侧");
   lstInfo.Append(new TObjInfoUnit(_T("标注侧"), szDisp));
   lstInfo.Append(new TObjInfoUnit(_T("起始轴号"), GetLabel(0)));
   lstInfo.Append(new TObjInfoUnit(_T("轴号数目"), XString(_T("%d"), GetAxisNum())));
   lstInfo.Append(new TObjInfoUnit(_T("轴圈半径"), XString(_T("%.1fP"), GetCirRadius())));
}

// Properties
TEntityBase::DrawType 
TDbAxisLabelSet::GetDrawType() const
{
    return TEntityBase::k2DOnly;
}

const TCHAR *TDbAxisLabelSet::GetDefaultLayer() const
{
    return LAY_DIMAX;
}

BOOL TDbAxisLabelSet::IsSortAuto() const
{
    return ((m_nFlag&ANF_NOSORT)==0);
}

//圆弧轴网的标注(包括径向和周向)
BOOL TDbAxisLabelSet::IsArcAxisNet() const
{
    return ((m_nFlag&ANF_CIRARC)!=0);
}

//是否标注弧轴线
BOOL TDbAxisLabelSet::IsArcAxis() const 
{
    return (m_segFirst.Is(CURVE_ARC));
}

AcDbObjectId 
TDbAxisLabelSet::GetTextStyleId() const
{
    return m_idTextStyle;
}

AcDbObjectId 
TDbAxisLabelSet::GetTextLayerId() const
{
    return m_idTextLayer;
}

int TDbAxisLabelSet::GetAxisNum() const
{
    return m_lstAxis.Length();
}

double TDbAxisLabelSet::GetLeaderLen(int nSide, BOOL bAsPaperUnit) const
{
    double val=nSide? m_nLeaderLen2 : m_nLeaderLen1;
    if (!bAsPaperUnit)
        val *= GetPScale();
    return val;
}

XPoint TDbAxisLabelSet::GetArcNetCenter() const
{
    ASSERT(IsArcAxisNet() && !IsArcAxis());
    XPoint ptCen;
    ads_polar(m_segFirst.StartPoint(), m_segFirst.IDirection(0)+PI, m_nDist2Center, ptCen);
    return ptCen;
}

// 得到标号的圆心
XPoint TDbAxisLabelSet::GetLabelCenter(int iAxis, int nSide) const
{
	XCurveSegment segAxis=GetAxis(iAxis);
	//LH 2013-4-16 修改原因在于执行"图纸剪切"命令时,有崩溃现象出现。原因是const TAxisInfo &axis = m_lstAxis[i];赋值失败，
	//赋值失败是因为TDPtrList内部m_CurrteIndex已经到了链表末端，所以失败，添加下行代码，使其内部CurrteIndex发生变化，从而
	//保证赋值正确。
	const_cast<TDbAxisLabelSet*>(this)->m_lstAxis.MoveToHead();

	const TAxisInfo &axis=m_lstAxis[iAxis];
	double nLeadLen=GetLeaderLen(nSide, FALSE);
	int iTestBit=nSide? AXF_SIDE2_LEAD : AXF_SIDE1_LEAD;
	if (axis.m_nFlag&iTestBit)
		nLeadLen = (nSide? axis.m_nLeadLen2 : axis.m_nLeadLen1)*GetPScale();

	XPoint ptLeader1;
	double nDir=segAxis.IDirection(nSide);
	if (segAxis.GetLength() < _DIST_SNAP) // sg add 120704，解决单个轴号2点重合的时候，会出现方向错误的问题
		nDir = m_segFirst.IDirection(nSide);
	XPoint ptBase=nSide? segAxis.EndPoint() : segAxis.StartPoint();
	ads_polar(ptBase, nDir+PI, nLeadLen, ptLeader1);
	XPoint ptCir;
	int nTestBit1=nSide? AXF_SIDE2_LEFT : AXF_SIDE1_LEFT;
	int nTestBit2=nSide? AXF_SIDE2_RIGHT : AXF_SIDE1_RIGHT;
	if ((axis.m_nFlag&nTestBit1) || (axis.m_nFlag&nTestBit2)) {
		double nDirCen = nDir + ((axis.m_nFlag&nTestBit1)? PI*0.75 : -PI*0.75);
		ads_polar(ptLeader1, nDirCen, sqrt(2.0)*m_nCirRadius*GetPScale(), ptCir);
	} else {
		ads_polar(ptLeader1, nDir+PI, m_nCirRadius*GetPScale(), ptCir);
	}
	return ptCir;
}

const TCHAR * TDbAxisLabelSet::GetLabel(int iAxis) const
{
    if (iAxis<0 || iAxis>=m_lstAxis.Length())
        return NULL;

	//LH 2013-4-16 修改原因在于执行"图纸剪切"命令时,有崩溃现象出现。原因是const TAxisInfo &axis = m_lstAxis[i];赋值失败，
	//赋值失败是因为TDPtrList内部m_CurrteIndex已经到了链表末端，所以失败，添加下行代码，使其内部CurrteIndex发生变化，从而
	//保证赋值正确。
	const_cast<TDbAxisLabelSet*>(this)->m_lstAxis.MoveToHead();

    const TAxisInfo &axis=m_lstAxis[iAxis];
    return (const TCHAR *)axis.m_sText;
}

double TDbAxisLabelSet::GetCirRadius(BOOL bAsPaperUnit) const //PS
{
    double val=m_nCirRadius;
    if (!bAsPaperUnit)
        val *= GetPScale();
    return val;
}

void TDbAxisLabelSet::SetSortAuto(BOOL bTrue)
{
    assertWriteEnabled();
    if (bTrue)
        m_nFlag &= ~ANF_NOSORT;
    else
        m_nFlag |= ANF_NOSORT;
}

void TDbAxisLabelSet::SetFirstSegment(XCurveSegment seg)
{
    assertWriteEnabled();
    m_segFirst=seg;
}

void TDbAxisLabelSet::SetTextStyleId(AcDbObjectId id)
{
    assertWriteEnabled();
    m_idTextStyle=id;
}

void TDbAxisLabelSet::SetTextLayerId(AcDbObjectId id)
{
    assertWriteEnabled();
    m_idTextLayer=id;
}

void TDbAxisLabelSet::SetLeaderLen(int nSide, double val, BOOL bAsPaperUnit)
{
    assertWriteEnabled();
    if (!bAsPaperUnit)
        val /= GetPScale();

    if (nSide)
		m_nLeaderLen2=val;
	else
		m_nLeaderLen1=val;
}

// sg add 110607，专门提供给“一轴多号”命令使用，用于修改各个引线长度
void TDbAxisLabelSet::SetLeaderLenOneByOne(int nSide, double val, BOOL bAsPaperUnit)
{
	assertWriteEnabled();
	if (!bAsPaperUnit)
		val /= GetPScale();

	int num = m_lstAxis.Length();
	for (int i=0; i<num; i++)
	{
		TAxisInfo &axis = *m_lstAxis[i];

		if (nSide)
			axis.m_nLeadLen2 = val;
		else
			axis.m_nLeadLen1 = val;
	}
}

void TDbAxisLabelSet::AddLeaderLenOneByOne(int nSide, double val, BOOL bAsPaperUnit)
{
	assertWriteEnabled();
	if (!bAsPaperUnit)
		val /= GetPScale();

	int num = m_lstAxis.Length();
	for (int i=0; i<num; i++)
	{
		TAxisInfo &axis = *m_lstAxis[i];

		if (nSide)
			axis.m_nLeadLen2 += val;
		else
			axis.m_nLeadLen1 += val;
	}
}

void TDbAxisLabelSet::SetCirRadius(double val, BOOL bAsPaperUnit)
{
    assertWriteEnabled();
    m_nCirRadius=val;
    if (!bAsPaperUnit)
        m_nCirRadius /= GetPScale();
}

void TDbAxisLabelSet::HideSide(int nSide, BOOL bTrue)
{
    assertWriteEnabled();
    int nTestBit=nSide? ANF_HIDESIDE2 : ANF_HIDESIDE1;
    if (bTrue)
        m_nFlag |= nTestBit;
    else
        m_nFlag &= ~nTestBit;
}

void TDbAxisLabelSet::HideAxisLabel(int idx, int nSide, BOOL bTrue)
{
    assertWriteEnabled();
    if (idx>=0 && idx<m_lstAxis.Length()) {
        TAxisInfo *pAxis=m_lstAxis[idx];
        int nTestBit=nSide? AXF_NOSIDE2 : AXF_NOSIDE1;
        if (bTrue)
            pAxis->m_nFlag |= nTestBit;
        else
            pAxis->m_nFlag &= ~nTestBit;
    }
}

// 取得轴线
XCurveSegment TDbAxisLabelSet::GetAxis(int idx) const
{
	int nAxisNum=m_lstAxis.Length();
	ASSERT(idx>=0 && idx<nAxisNum);

	double nPara2First=0.0;
	BOOL bLine=m_segFirst.Is(CURVE_LINE);
	XPoint ptCen;
	if ((m_nFlag&ANF_CIRARC) && bLine) // 圆弧轴网中的进深标注
	{
		ads_polar(m_segFirst.StartPoint(), m_segFirst.IDirection(0)+PI, m_nDist2Center, ptCen);
	}

	//double nLeaderLen=m_nLeaderLen*GetPScale();
	double nCirRad=m_nCirRadius*GetPScale();

	for (int i=0; i<idx; i++)
	{
		//LH 2013-4-16 修改原因在于执行"图纸剪切"命令时,有崩溃现象出现。原因是const TAxisInfo &axis = m_lstAxis[i];赋值失败，
		//赋值失败是因为TDPtrList内部m_CurrteIndex已经到了链表末端，所以失败，添加下行代码，使其内部CurrteIndex发生变化，从而
		//保证赋值正确。
		const_cast<TDbAxisLabelSet*>(this)->m_lstAxis.MoveToHead();
		const TAxisInfo &axis=m_lstAxis[i];
		nPara2First += axis.m_nPara2Next;
	}

	XCurveSegment segAxis;
	if ((m_nFlag&ANF_CIRARC) && bLine) // 圆弧轴网中的进深标注
	{
		XPoint pt1, pt2;
		double nDir=m_segFirst.IDirection(0)+nPara2First;
		ads_polar(ptCen, nDir, m_nDist2Center, pt1);
		ads_polar(ptCen, nDir, m_nDist2Center+m_segFirst.GetLength(), pt2);

		//LH 2013-4-16 修改原因在于执行"图纸剪切"命令时,有崩溃现象出现。原因是const TAxisInfo &axis = m_lstAxis[i];赋值失败，
		//赋值失败是因为TDPtrList内部m_CurrteIndex已经到了链表末端，所以失败，添加下行代码，使其内部CurrteIndex发生变化，从而
		//保证赋值正确。
		const_cast<TDbAxisLabelSet*>(this)->m_lstAxis.MoveToHead();

		// add by lgy 20120217	9.0弧线轴网标注单侧和单轴改变功能分开
		const TAxisInfo &axis=m_lstAxis[idx];
		if (axis.m_nFlag&AXF_SIDE1_LEADPOS)
		{
			ads_polar(ptCen, nDir, m_nDist2Center+axis.m_dLeadPos1, pt1);
		}
		if (axis.m_nFlag&AXF_SIDE2_LEADPOS)
		{
			ads_polar(ptCen, nDir, m_nDist2Center+m_segFirst.GetLength()+axis.m_dLeadPos2, pt2);
		}

		segAxis = XLine(pt1, pt2);
	}
	else
	{
		segAxis = m_segFirst.Offset(nPara2First, LS_FINITE);

		//LH 2013-4-16 修改原因在于执行"图纸剪切"命令时,有崩溃现象出现。原因是const TAxisInfo &axis = m_lstAxis[i];赋值失败，
		//赋值失败是因为TDPtrList内部m_CurrteIndex已经到了链表末端，所以失败，添加下行代码，使其内部CurrteIndex发生变化，从而
		//保证赋值正确。
		const_cast<TDbAxisLabelSet*>(this)->m_lstAxis.MoveToHead();

		// add by lgy 20120215，9.0添加改单轴引线长度和单侧引线长度
		XPoint pt;
		const TAxisInfo &axis = m_lstAxis[idx];
		if (axis.m_nFlag&AXF_SIDE1_LEADPOS)
		{
			// 偏移点没有超过对侧默认位置，点在线上距离为正，在线外距离为负
			if (axis.m_dLeadPos1 < m_segFirst.GetLength() + _DIST_SNAP)
			{
				ads_polar(segAxis.StartPoint(), segAxis.IDirection(0), axis.m_dLeadPos1, pt);
				segAxis.SetStartPoint(pt);
			}
		}
		if (axis.m_nFlag&AXF_SIDE2_LEADPOS)
		{
			// 偏移点没有超过对侧默认位置，点在线上距离为正，在线外距离为负
			if (axis.m_dLeadPos2 < m_segFirst.GetLength() + _DIST_SNAP)
			{
				ads_polar(segAxis.EndPoint(), segAxis.IDirection(1), axis.m_dLeadPos2, pt);
				segAxis.SetEndPoint(pt);
			}
		}
	}
	return segAxis;
}

//0--起始端, 1--末端
int TDbAxisLabelSet::OnWhichSide(XPoint pt) const
{
    return (m_segFirst.EndPoint().Distance2d(pt) < m_segFirst.StartPoint().Distance2d(pt));
}

int TDbAxisLabelSet::GetVisSides() const
{
    int nFlag=3;
    if ((m_nFlag&ANF_HIDESIDE1))
        nFlag -= 1;
    if ((m_nFlag&ANF_HIDESIDE2))
        nFlag -= 2;
    return nFlag;
}

int TDbAxisLabelSet::GetAxisVisSides(int idx) const
{
    if (idx<0 || idx>=m_lstAxis.Length())
        return 0;
    const TAxisInfo &rAxis=m_lstAxis[idx];
    int nFlag=3;
    if ((rAxis.m_nFlag&AXF_NOSIDE1))
        nFlag -= 1;
    if ((rAxis.m_nFlag&AXF_NOSIDE2))
        nFlag -= 2;
    return nFlag;
}

void TDbAxisLabelSet::SetVisSides(int nSides)
{
    assertWriteEnabled();
    HideSide(0, (nSides&0x01)==0);
    HideSide(1, (nSides&0x02)==0);
}

void TDbAxisLabelSet::SetAxisVisSides(int idx, int nSides)
{
    assertWriteEnabled();
    HideAxisLabel(idx, 0, (nSides&0x01)==0);
    HideAxisLabel(idx, 1, (nSides&0x02)==0);
}

// 取得正交的曲线, nSide: 0-起始侧, 1-终止侧
// bForceOpen--强制开启(忽略圆形轴网的最后一开间)
XDirectionCurve 
TDbAxisLabelSet::GetOrthoCurve(int nSide, int bForceOpen) const
{
    ASSERT(m_lstAxis.Length()>0);

    XDirectionCurve cvRet;
    if (m_lstAxis.Length()==1) {
        (XCurveSegment &)cvRet=XLine(nSide? m_segFirst.EndPoint() : m_segFirst.StartPoint(), m_segFirst.IDirection(0)+PI/2);
    }
    BOOL bLine=m_segFirst.Is(CURVE_LINE);
    XCurveSegment segFinal=GetAxis(m_lstAxis.Length()-1);

    if ((m_nFlag&ANF_CIRARC) && bLine) {
        if ((m_nFlag&ANF_CLOSE) && !bForceOpen) {
            XPoint ptCen=GetArcNetCenter();
            if (nSide==0) 
                (XCurveSegment &)cvRet = XCircle(ptCen, ptCen.Distance2d(m_segFirst.StartPoint()));
            else
                (XCurveSegment &)cvRet = XCircle(ptCen, ptCen.Distance2d(m_segFirst.EndPoint()));
        } else {
            double nAngStart=m_segFirst.IDirection(0);
            double nAngEnd=segFinal.IDirection(0);
            double nSweep=(m_nFlag&ANF_CLOCKWISE)? 
                -CT_std_angle(nAngStart-nAngEnd) : CT_std_angle(nAngEnd-nAngStart);
            if (nSide==0)
                cvRet=XDirectionCurve(m_segFirst.StartPoint(), segFinal.StartPoint(), nSweep);
            else
                cvRet=XDirectionCurve(m_segFirst.EndPoint(), segFinal.EndPoint(), nSweep);
        }
    } else {
        if (nSide==0)
            (XCurveSegment &)cvRet=XLine(m_segFirst.StartPoint(), segFinal.StartPoint());
        else
            (XCurveSegment &)cvRet=XLine(m_segFirst.EndPoint(), segFinal.EndPoint());
    }
    return cvRet;
}


// 反序
// Modify on 2002/8/7，轴号外偏也反序
void TDbAxisLabelSet::NegateParams()
{
    assertWriteEnabled();
    int nAxisNum=m_lstAxis.Length();
    for (int i=0; i<nAxisNum; i++) {
        m_lstAxis[i]->m_nPara2Next *= -1.0;
		Adesk::UInt16 nFlag=m_lstAxis[i]->m_nFlag;
		Adesk::UInt16 nFlag0=nFlag;
		if (nFlag0&AXF_SIDE1_LEFT) {
			nFlag &= ~AXF_SIDE1_LEFT;
			nFlag |= AXF_SIDE1_RIGHT;
		} else if (nFlag0&AXF_SIDE1_RIGHT) {
			nFlag &= ~AXF_SIDE1_RIGHT;
			nFlag |= AXF_SIDE1_LEFT;
		}
		if (nFlag0&AXF_SIDE2_LEFT) {
			nFlag &= ~AXF_SIDE2_LEFT;
			nFlag |= AXF_SIDE2_RIGHT;
		} else if (nFlag0&AXF_SIDE2_RIGHT) {
			nFlag &= ~AXF_SIDE2_RIGHT;
			nFlag |= AXF_SIDE2_LEFT;
		}
        m_lstAxis[i]->m_nFlag=nFlag;
    }
}

// 对轴号进行命中测试
int TDbAxisLabelSet::HitTestOnLabel(XPoint ptPick, int *pSide) const
{
    int nIdx=-1;
    int nSide=0;
    double nDist=0.0;
    int nAxisNum=m_lstAxis.Length();
    for (int i=0; i<nAxisNum; i++) {
		int iVis=GetAxisVisSides(i);//add by whl on 040918
        for (int n=0; n<2; n++) {

			//add by whl on 040918,过滤不显示轴号
			if (iVis==0)
				continue;
			if (n==0&&iVis==2)
				continue;
			if (n==1&&iVis==1)
				continue;

            XPoint ptLabel=GetLabelCenter(i, n);
            if (nIdx==-1) {
                nIdx=i;
                nDist=ptLabel.Distance2d(ptPick);
                nSide=n;
            } else {
                double nDist1=ptLabel.Distance2d(ptPick);
                if (nDist1<nDist) {
                    nIdx=i;
                    nSide=n;
                    nDist=nDist1;
                }
            }
        }
    }
    if (pSide) *pSide=nSide;
    return nIdx;
}

// 对轴号进行命中测试,不忽略隐藏轴号
int TDbAxisLabelSet::HitTestOnLabel0(XPoint ptPick, int *pSide) const
{
    int nIdx=-1;
    int nSide=0;
    double nDist=0.0;
    int nAxisNum=m_lstAxis.Length();
    for (int i=0; i<nAxisNum; i++) {
        for (int n=0; n<2; n++) {
            XPoint ptLabel=GetLabelCenter(i, n);
            if (nIdx==-1) {
                nIdx=i;
                nDist=ptLabel.Distance2d(ptPick);
                nSide=n;
            } else {
                double nDist1=ptLabel.Distance2d(ptPick);
                if (nDist1<nDist) {
                    nIdx=i;
                    nSide=n;
                    nDist=nDist1;
                }
            }
        }
    }
    if (pSide) *pSide=nSide;
    return nIdx;
}

// tol=_DIST_SNAP, return index; >=0, hit ok
int TDbAxisLabelSet::HitLabel(const XCurveSegment &seg, XString &sLab) const
{
	int nAxisNum=m_lstAxis.Length();
	for (int i=0; i<nAxisNum; i++) {
		XCurveSegment segAxis=GetAxis(i);
		if (fabs(segAxis.GetDist2Me(seg.StartPoint()))<_DIST_SNAP &&
			fabs(segAxis.GetDist2Me(seg.EndPoint()))<_DIST_SNAP) {
			sLab=GetLabel(i);
			return i;
		}
	}
	return -1;
}

// 对轴线进行命中测试
int TDbAxisLabelSet::HitTestOnAxis(XPoint ptPick, int *pSide) const
{
    int nIdx=-1;
    int nSide=0;
    double nDist=0.0;
    int nAxisNum=m_lstAxis.Length();
    for (int i=0; i<nAxisNum; i++) {
            XCurveSegment segAxis=GetAxis(i);
            double nDist1=segAxis.StartPoint().Distance2d(ptPick);
            double nDist2=segAxis.EndPoint().Distance2d(ptPick);
            if (nIdx==-1) {
                nIdx=i;
                nDist=min(nDist1, nDist2);
                if (nDist1<nDist2)
                    nSide=0;
                else
                    nSide=1;
            } else {
                if (nDist1<nDist) {
                    nIdx=i;
                    nSide=0;
                    nDist=nDist1;
                }
                if (nDist2<nDist) {
                    nIdx=i;
                    nSide=1;
                    nDist=nDist2;
                }
            }
    }
    if (pSide) *pSide=nSide;
    return nIdx;
}


// 推导标注内容
void TDbAxisLabelSet::SetLabel(int nIdx, const TCHAR *pszText, BOOL bSort, BOOL bReverse)
{
	assertWriteEnabled();
	ASSERT(nIdx>=0 && nIdx<m_lstAxis.Length());
	if (bSort)
	{
		XString sCur;
		sCur = pszText;

		if (!bReverse) // 正排
		{
			int nAxisNum = m_lstAxis.Length();
			for (int i=nIdx; i<nAxisNum; i++) 
			{
				TAxisInfo &axis = *m_lstAxis[i];
				axis.m_sText = sCur;

				// sg modify 100530，给推导类传值，确定是否变前项，处理字母组合
//				XAxisNoParser parser(axis.m_sText);
				XAxisNoParser parser(axis.m_sText, IsChangePreNum());
				if (_tcschr(axis.m_sText, _T('/')))
					axis.m_nFlag |= AXF_ATTACH;
				else
					axis.m_nFlag &= ~AXF_ATTACH;

				BOOL bAttach = FALSE;
				if (i < nAxisNum-1)
					bAttach = ((m_lstAxis[i+1]->m_nFlag&AXF_ATTACH)!=0);
				parser.GetNext(sCur, !bAttach);
			}
		}
		else // 倒排
		{
			for (int i=nIdx; i>=0; i--) 
			{
				TAxisInfo &axis = *m_lstAxis[i];
				axis.m_sText = sCur;

				// sg modify 100530，给推导类传值，确定是否变前项，处理字母组合
//				XAxisNoParser parser(axis.m_sText);
				XAxisNoParser parser(axis.m_sText, IsChangePreNum());
				if (_tcschr(axis.m_sText, _T('/')))
					axis.m_nFlag |= AXF_ATTACH;
				else
					axis.m_nFlag &= ~AXF_ATTACH;

				BOOL bAttach = FALSE;
				if (i > 0)
					bAttach = ((m_lstAxis[i-1]->m_nFlag&AXF_ATTACH)!=0);

				// sg add 100531，判断是否是首个主轴号之前的附加轴号
				if (i > 0 && (m_lstAxis[i-1]->m_nFlag&AXF_PREFIRSE_ATTACH)!=0) // 1之前的轴号
				{
					parser.GetPre(sCur, !bAttach);
				}
				else // 1之后的轴号
				{
					parser.GetNext(sCur, !bAttach);
				}
			}
		}
	}
	else 
	{
		TAxisInfo &axis = *m_lstAxis[nIdx];
		//modify by lgy 20120209，会导致显示乱码
		//axis.m_sText = pszText; 
		XString strTemp = pszText;
		axis.m_sText = strTemp;

		if (_tcschr(pszText, _T('/')))
			axis.m_nFlag |= AXF_ATTACH;
		else
			axis.m_nFlag &= ~AXF_ATTACH;
	}
}

void TDbAxisLabelSet::SortAxisLabel(const TCHAR *szFirst)
{
	assertWriteEnabled();
	XString sCur;
	sCur = szFirst;
	
	// sg add 100530，获取对象内是否变前项的设置，传递给XAxisNoParser类，处理字母组合
	BOOL bPreNum = IsChangePreNum();
	
	int nAxisNum = m_lstAxis.Length();
	for (int i=0; i<nAxisNum; i++)
	{
		TAxisInfo &axis = *m_lstAxis[i];
		axis.m_sText = sCur;
		// sg modify 100530，获取对象内是否变前项的设置，传递给XAxisNoParser类，处理字母组合
//		XAxisNoParser(axis.m_sText).GetNext(sCur, !(axis.m_nFlag&AXF_ATTACH));
		XAxisNoParser(axis.m_sText, bPreNum).GetNext(sCur, !(axis.m_nFlag&AXF_ATTACH));
	}
}

// 删除标号
BOOL TDbAxisLabelSet::RemoveLabel(int idx, BOOL bSortLabel)
{
    assertWriteEnabled();
    if (m_lstAxis.Length()==1 && idx==0)
	{
        erase();
        return TRUE;
    }

    if (m_lstAxis.Length()<=1 || idx<0 || idx>=m_lstAxis.Length())
        return FALSE;

    int num=m_lstAxis.Length();
    if (idx==0) 
	{
		XString sFirst=m_lstAxis[0]->m_sText;
        m_segFirst=GetAxis(idx+1);
        m_lstAxis.Remove(idx);

		//add by whl
		if (bSortLabel&&m_lstAxis.Length()>0)
			SetLabel(0,sFirst,TRUE);
    }
	else if (idx==num-1)
	{
        m_lstAxis.Remove(idx);
        m_lstAxis.Tail()->m_nPara2Next=0.0;
    }
	else
	{
        m_lstAxis[idx-1]->m_nPara2Next += m_lstAxis[idx]->m_nPara2Next;
        m_lstAxis.Remove(idx);
        if (bSortLabel)
            SetLabel(idx-1, m_lstAxis[idx-1]->m_sText, TRUE);
    }
    return TRUE;
}

BOOL TDbAxisLabelSet::AddLabel(XPoint ptAdd, int nAxisFlag, const TCHAR *pszLab, BOOL bSort)
{
	assertWriteEnabled();
	if (m_lstAxis.Length() == 0)
		return FALSE;

	XCurveSegment seg;
	if (IsArcAxisNet() && !IsArcAxis()) // 弧线轴网
	{
		if (m_lstAxis.Length() < 2)
			return FALSE;

		XPoint ptCen = GetArcNetCenter();
		// Radiale line
		seg = XLine(ptCen, ptAdd);
	}
	else // Line
	{
		double nDist = m_segFirst.GetDist2Me(ptAdd); // 获得偏移距离
		if (fabs(nDist) < _DIST_SNAP)
			return FALSE;

		seg = m_segFirst.Offset(nDist, LS_FINITE);
	}

	//modify by lgy 20120208	是否要重排需要根据参数而定
	//return AddAxis(seg, nAxisFlag, pszLab);
	return AddAxis(seg, nAxisFlag, pszLab, bSort);
}

// 增加一轴号
BOOL TDbAxisLabelSet::AddAxis(XCurveSegment seg, int nAxisFlag, const TCHAR *pszLab, BOOL bSort)
{
	assertWriteEnabled();
	int num = m_lstAxis.Length();
	if (num == 0)
	{
		m_segFirst = seg;

		TAxisInfo *axisNew = new TAxisInfo;
		axisNew->m_nFlag = nAxisFlag;
		if (pszLab)
			axisNew->m_sText = pszLab;
		m_lstAxis.Append(axisNew);
		return TRUE;
	}

	if (m_segFirst.GetCurveType() != seg.GetCurveType())
		return FALSE;

	if (num == 1)
	{
		if (m_segFirst.Is(CURVE_LINE))
		{
			XLine lnFirst = m_segFirst.GetLine();
			XLine lnSec = seg.GetLine();
			lnFirst.SetLineFlag(LS_INFINITE);
			lnSec.SetLineFlag(LS_INFINITE);

			XPoint ptCen;
			TAxisInfo *axisNew = new TAxisInfo;
			axisNew->m_nFlag |= nAxisFlag;
			if (pszLab)
				axisNew->m_sText=pszLab;

			if (lnFirst.Intersection(&lnSec, ptCen)) // 弧形轴网开间
			{
				if (ptCen.Distance2d(m_segFirst.StartPoint()) > ptCen.Distance2d(m_segFirst.EndPoint()))
					m_segFirst.Reverse();

				m_nDist2Center = ptCen.Distance2d(m_segFirst.StartPoint());
				m_nFlag |= ANF_CIRARC;
				double nPara =
					CT_std_angle(ads_angle(ptCen, seg.FarPoint(ptCen)) - ads_angle(ptCen, m_segFirst.EndPoint()));
				m_lstAxis.Head()->m_nPara2Next = (m_nFlag&ANF_CLOCKWISE)? (nPara-2*PI) : nPara;
			}
			else
			{
				m_lstAxis.Head()->m_nPara2Next = m_segFirst.GetDist2Me(seg.MidPoint());
			}
			m_lstAxis.Append(axisNew);

			if (!pszLab)
			{
				//modify by lgy 20120208	是否需要重排视情况而定
				//SetLabel(0, GetLabel(0), TRUE);
				SetLabel(0, GetLabel(0), bSort);
			}
		}
		else
		{
			ASSERT(m_segFirst.Is(CURVE_ARC));
			XArc arc1 = m_segFirst.GetArc();
			XArc arc2 = seg.GetArc();
			if (arc1.GetCenterPt().Distance2d(arc2.GetCenterPt()) > _DIST_SNAP)
				return FALSE;

			double nPara = arc2.GetRadius() - arc1.GetRadius();
			if (fabs(nPara) < _DIST_SNAP)
				return FALSE;

			TAxisInfo *axisNew = new TAxisInfo;
			m_lstAxis.Head()->m_nPara2Next = nPara;
			m_lstAxis.Append(axisNew);
			if (pszLab)
				axisNew->m_sText = pszLab;
			else
			{
				//modify by lgy 20120208	是否需要重排视情况而定
				//SetLabel(0, GetLabel(0), TRUE);
				SetLabel(0, GetLabel(0), bSort);
			}
		}
		return TRUE;
	}

	XCurveSegment segStart = GetOrthoCurve(0).GetCurve(),
		segEnd = GetOrthoCurve(1).GetCurve();
	int nSide1 = segStart.OnWhichSide(m_segFirst.EndPoint());
	int nSide2 = segEnd.OnWhichSide(m_segFirst.StartPoint());
	segStart = segStart.Offset(nSide1, 2.0*GetPScale(), LS_FINITE);
	segEnd = segEnd.Offset(nSide2, 2.0*GetPScale(), LS_FINITE);

	double nDir = m_segFirst.IDirection(0);
	for (int i=0; i<num-1; i++)
	{
		TAxisInfo &axis = *m_lstAxis[i];
		TAxisInfo &axisNext = *m_lstAxis[i+1];
		XCurveSegment segAxis = GetAxis(i);
		XCurveSegment segNext = GetAxis(i+1);
		
		if (IsArcAxisNet() && !IsArcAxis()) // 圆弧轴网角度标注
		{
			XPoint ptCen = GetArcNetCenter();
			if ((ptCen&seg)==PR_OUTSIDE || !seg.Is(CURVE_LINE))
				return FALSE;
			
			double nAng=  seg.IDirection(0);
			XSector sector = (m_nFlag&ANF_CLOCKWISE) ? XSector(segNext.IDirection(0), segAxis.IDirection(0))
				: XSector(segAxis.IDirection(0), segNext.IDirection(0));
			if (sector.AngleFlag(nAng) == 3)
			{
				axis.m_nPara2Next = (m_nFlag&ANF_CLOCKWISE)?-CT_std_angle(segAxis.IDirection(0)-nAng)
					:CT_std_angle(nAng-segAxis.IDirection(0));

				TAxisInfo *axisNew = new TAxisInfo;
				axisNew->m_nPara2Next = (m_nFlag&ANF_CLOCKWISE)?-CT_std_angle(nAng-segNext.IDirection(0))
					:CT_std_angle(segNext.IDirection(0)-nAng);
				
				axisNew->m_nFlag = nAxisFlag;
				if (!CT_IsExactSameDrt(seg.IDirection(0), ads_angle(ptCen, seg.MidPoint()), _angSnap))
					TchPrivate::Exchange(seg.StartPoint(), seg.EndPoint());
				if (segStart.OnWhichSide(seg.StartPoint())==nSide1)
					axisNew->m_nFlag |= AXF_NOSIDE1;
				if (segEnd.OnWhichSide(seg.EndPoint())==nSide2) 
					axisNew->m_nFlag |= AXF_NOSIDE2;
				m_lstAxis[i+1];
				m_lstAxis.Insert(axisNew);
				
				if (pszLab)
					axisNew->m_sText = pszLab;
				else
				{
					//modify by lgy 20120208	是否自动重排根据程序而定
					//SetLabel(i, axis.m_sText, TRUE);
					if (bSort)
					{
						SetLabel(i, axis.m_sText, TRUE);
					}
					else
					{
						XAxisNoParser parser(axis.m_sText, IsChangePreNum());
						XString strNextNum;
						BOOL bFlag = (nAxisFlag&AXF_ATTACH);
						parser.GetNext(strNextNum, !bFlag);
						SetLabel(i+1, strNextNum, FALSE);
					}
				}
				return TRUE;
			}
		}
		else
		{
			double nDist1 = segAxis.GetDist2Me(seg.StartPoint());
			double nDist2 = segNext.GetDist2Me(seg.StartPoint());
			double nTestVal = nDist1 * nDist2;
			if (fabs(nTestVal) < 1.0-3)
				return FALSE;
			
			if (nTestVal < -1.0E-3)
			{
				BOOL bAdd = FALSE;
				if (IsArcAxis()) //圆弧轴线的情况
				{
					if (segAxis.GetArc().GetCenterPt()==seg.GetArc().GetCenterPt() &&
						segAxis.GetArc().AngleFlag(seg.GetArc().MidAngle())>0) 
						bAdd = TRUE;
				}
				else
				{
					if (CT_IsSameDrt(segAxis.IDirection(0), seg.IDirection(0), _angSnap)) 
						bAdd=TRUE;
				}

				if (bAdd)
				{
					axis.m_nPara2Next = nDist1;

					TAxisInfo *axisNew = new TAxisInfo;
					axisNew->m_nPara2Next = -nDist2;
					axisNew->m_nFlag = nAxisFlag;
					if (!CT_IsExactSameDrt(seg.IDirection(0), nDir, _angSnap))
						TchPrivate::Exchange(seg.StartPoint(), seg.EndPoint());
					if (segStart.OnWhichSide(seg.StartPoint()) == nSide1) 
						axisNew->m_nFlag |= AXF_NOSIDE1;
					if (segEnd.OnWhichSide(seg.EndPoint()) == nSide2) 
						axisNew->m_nFlag |= AXF_NOSIDE2;
					m_lstAxis[i+1];
					m_lstAxis.Insert(axisNew);

					if (pszLab)
						axisNew->m_sText = pszLab;
					else
					{
						// sg modify 100531，根据8.5需求，在主轴号（只处理单个字母和单个数字）之前的附加轴号，默认标注内容不为空
//						SetLabel(i, axis.m_sText, TRUE);
						if ((nAxisFlag&AXF_ATTACH)!=0 && (axis.m_nFlag&AXF_PREFIRSE_ATTACH)!=0)
						{
							axisNew->m_nFlag |= AXF_PREFIRSE_ATTACH; // 首个主轴号之前的附加轴号
							
							
							//modify by lgy 20120208	是否需要排序根据参数确定
							//SetLabel(i+2, axisNext.m_sText, TRUE, TRUE); // 逆向排序
							if (bSort)
							{
								SetLabel(i+2, axisNext.m_sText, TRUE, TRUE); // 逆向排序
							}
							else 
							{
								XString strNext = axisNext.m_sText, strNextNum;
								XAxisNoParser parser(strNext, IsChangePreNum());
								BOOL bFlag = (nAxisFlag&AXF_ATTACH);
								parser.GetPre(strNextNum, !bFlag); // 推导前一轴号内容
								SetLabel(i+1, strNextNum, FALSE, TRUE); // 逆向排序
							}
						}
						else
						{
							//add by lgy 20120208	是否自动排序根据程序需要
							//SetLabel(i, axis.m_sText, TRUE);
							if (bSort)
							{
								SetLabel(i, axis.m_sText, TRUE);
							}
							else 
							{
								XAxisNoParser parser(axis.m_sText, IsChangePreNum());
								XString strNextNum;
								BOOL bFlag = (nAxisFlag&AXF_ATTACH);
								parser.GetNext(strNextNum, !bFlag);
								SetLabel(i+1, strNextNum, FALSE);
							}	
						}
					}
					return TRUE;
				}
			}
		}
	}
	
	BOOL bRet = FALSE;
	// 加在第1根之前或最后一根之后
	BOOL bInc = (m_lstAxis[0]->m_nPara2Next > _DIST_SNAP);
	if (IsArcAxisNet() && !IsArcAxis())
	{
		// not Finished yet
	}
	else
	{
		XPoint ptMid = seg.MidPoint();
		double nPara1 = m_segFirst.GetDist2Me(ptMid);
		double nPara2 = GetAxis(num-1).GetDist2Me(ptMid);
		if (fabs(nPara1)<_DIST_SNAP || fabs(nPara2)<_DIST_SNAP)
			return FALSE;

		if ((bInc && nPara1<-_DIST_SNAP) || (!bInc && nPara1>_DIST_SNAP)) // 加在第一根之前
		{
			m_segFirst = seg;
			m_lstAxis[0];

			TAxisInfo *newAxis = new TAxisInfo;
			newAxis->m_nPara2Next = -nPara1;
			newAxis->m_nFlag = nAxisFlag;

			// sg modify 100531，根据8.5需求，在主轴号（只处理单个字母和单个数字）之前的附加轴号，默认标注内容不为空
			BOOL bMajor = FALSE; // 标记是否需要重排，以及标记是否是主轴号
			if (pszLab)
				newAxis->m_sText = pszLab;
			else
			{
				// 获取当前首个轴号的标注内容
				const TCHAR *szLab = (const TCHAR *)(m_lstAxis.Head()->m_sText);

				XAxisNoParser parser(szLab, IsChangePreNum());
				bMajor = ((nAxisFlag&AXF_ATTACH)==0);
				parser.GetPre(newAxis->m_sText, bMajor); // 推导前一轴号内容

				if (newAxis->m_sText.Length() == 0) // 若推导出的内容为空，则无需重新排列
				{
					bMajor = FALSE;
				}
				else if (!bMajor) // 首个主轴号之前的附加轴号
				{
					newAxis->m_nFlag |= AXF_PREFIRSE_ATTACH;
				}
			}
			m_lstAxis.Insert(newAxis);

			if (bMajor) // 推导出的内容不为空时，新增轴号若为主轴号，则重新排列
			{
				//add by lgy 20120208	是否需要重新排列根据参数确定
				//SetLabel(0, newAxis->m_sText, TRUE);
				SetLabel(0, newAxis->m_sText, bSort);
			}
			bRet = TRUE;
		}
		else if ((bInc && nPara2>_DIST_SNAP) || (!bInc && nPara2<-_DIST_SNAP)) // 加在最后一根之后
		{
			m_lstAxis.Tail()->m_nPara2Next = nPara2;
			const TCHAR *szLab = (const TCHAR *)(m_lstAxis.Tail()->m_sText);

			TAxisInfo *newAxis = new TAxisInfo;
			//add by lgy 20120209，在最后添加轴线时自动重排时对附加轴线不好使
			newAxis->m_nFlag =nAxisFlag;

			m_lstAxis.Append(newAxis);

			if (pszLab)
				newAxis->m_sText = pszLab;
			else
			{
				//modify by lgy 20120208	是否需要重新排列根据参数确定
				//SetLabel(num-1, szLab, TRUE);
				if (bSort)
				{
					SetLabel(num-1, szLab, TRUE);
				}
				else
				{
					XString strNext = szLab, strNextNum;
					XAxisNoParser parser(strNext, IsChangePreNum());
					BOOL bFlag = (nAxisFlag&AXF_ATTACH);
					parser.GetNext(strNextNum, !bFlag);
					SetLabel(num, strNextNum, FALSE);
				}
			}
			bRet = TRUE;
		}
	}
	return bRet;
}


static BOOL HandleAxisCircle(XCurveSegment &segCur, XCurveSegment segBase)
{
	if (segCur.Is(CURVE_CIRCLE)) { //把圆轴网转化为直线轴网
		XLine lnBase=segBase.GetLine();
		lnBase.SetLineFlag(LS_FINITE);
		XPoint ptInt;
		if (!segCur.Intersection(lnBase, ptInt, XPoint()))
			return FALSE;
		XCircle cir=segCur.GetCircle();
		XPoint pt1=ptInt;
		XPoint pt2;
		ads_polar(pt1, ads_angle(cir.GetCenterPt(), pt1)+PI/2.0, 100.0, pt2);
		segCur=XLine(ptInt, pt2);
	}
	return TRUE;
}

Acad::ErrorStatus 
TDbAxisLabelSet::SetPrevLink(AcDbObjectId id)
{
    assertWriteEnabled();
    AcDbObjectId idThis=objectId();
    if (!idThis || !IsValid())
        return Acad::eInvalidInput;
    OPENOBJ_BEGIN(id, AcDb::kForWrite, TDbAxisLabelSet, pPrev);
    if (!pPrev)
        return Acad::eInvalidInput;
    if (!pPrev->IsValid())
        return Acad::eInvalidInput;

    const TCHAR *pszLabel=pPrev->GetLabel(pPrev->GetAxisNum()-1);
    SetLabel(0, pszLabel, TRUE);
    m_nFlag |= ANF_PREVLINK;
    TAxisInfo *pInfo=m_lstAxis[0];
    pInfo->m_nFlag &= ~AXF_NOSIDE1;
    pInfo->m_nFlag &= ~AXF_NOSIDE2;
    pPrev->addPersistentReactor(idThis);  
    OPENOBJ_END();
    return Acad::eOk;
}

void TDbAxisLabelSet::SetFirstAxis(XCurveSegment seg)
{
    assertWriteEnabled();
    m_segFirst=seg;
}

// 平行轴线的方向有可能是相反的，手工绘制轴线时候
BOOL TDbAxisLabelSet::ConvertFrom(const XAxisDimSet &dimSet)
{
    assertWriteEnabled();
    //BOOL bValid=IsValid(); //修改还是新建

    m_lstAxis.Reset();
    m_nFlag=0;

    int nLen=dimSet.Length();
    XCurveSegment segBase=(*dimSet.pSortBase);
    XPoint ptCen;
    for (int i=0; i<nLen; i++) {
        XCurveSegment segCur=dimSet[i];
        if (!HandleAxisCircle(segCur, segBase))
            return FALSE;
        TAxisInfo *pAxis=new TAxisInfo;
        if (i==0) {
            m_segFirst=segCur;
            if (!segBase.Is(CURVE_LINE)) { //圆弧轴网开间方向
                m_nFlag |= ANF_CIRARC;
                if (segBase.Is(CURVE_CIRCLE)) {
                    m_nFlag |= ANF_CLOSE;
                    ptCen=segBase.GetCircle().GetCenterPt();
                } else
                    ptCen=segBase.GetArc().GetCenterPt();
                ASSERT(m_segFirst.Is(CURVE_LINE));
                if (ptCen.Distance2d(m_segFirst.StartPoint())>ptCen.Distance2d(m_segFirst.EndPoint()))
                    TchPrivate::Exchange(m_segFirst.StartPoint(), m_segFirst.EndPoint());
				m_nDist2Center=ptCen.Distance2d(m_segFirst.StartPoint());
                //m_nFlag |= ANF_HIDESIDE1;
                if (!XAxisDimSet::g_AntiClockWise)
                    m_nFlag |= ANF_CLOCKWISE;
            }
            if (!m_segFirst.Is(CURVE_LINE))
                m_nFlag |= ANF_CIRARC;
        }  

        if (i==nLen-1) {
            pAxis->m_nPara2Next=0.0;
        } else {
            XCurveSegment segNext=dimSet[i+1];
            if (!HandleAxisCircle(segNext, segBase))
                return FALSE;
            if (segCur.Is(CURVE_LINE)) {
                ASSERT(segNext.Is(CURVE_LINE) && dimSet.pSortBase);

                if (!(m_nFlag&ANF_CIRARC)) {
                    XPoint ptMid=segNext.MidPoint();
                    if (i>0 && !CT_IsExactSameDrt(segCur.IDirection(0), m_segFirst.IDirection(0), _angSnap))
                        TchPrivate::Exchange(segCur.StartPoint(), segCur.EndPoint());
                    pAxis->m_nPara2Next=segCur.GetDist2Me(ptMid);
                } else {
                    if (ptCen.Distance2d(segCur.StartPoint())>ptCen.Distance2d(segCur.EndPoint()))
                        TchPrivate::Exchange(segCur.StartPoint(), segCur.EndPoint());
                    if (ptCen.Distance2d(segNext.StartPoint())>ptCen.Distance2d(segNext.EndPoint()))
                        TchPrivate::Exchange(segNext.StartPoint(), segNext.EndPoint());

                    if (m_nFlag&ANF_CLOCKWISE)
                        pAxis->m_nPara2Next=-CT_std_angle(segCur.IDirection(0)-segNext.IDirection(0));  
                    else
                        pAxis->m_nPara2Next=CT_std_angle(segNext.IDirection(0)-segCur.IDirection(0));  
                }
            } else {
                XPoint ptMid=segNext.MidPoint();
                pAxis->m_nPara2Next=segCur.GetDist2Me(ptMid);
            }
        }
        m_lstAxis.Append(pAxis);
    }

    XCurveSegment segStart=GetOrthoCurve(0).GetCurve(),
        segEnd=GetOrthoCurve(1).GetCurve();
    int nSide1=segStart.OnWhichSide(m_segFirst.EndPoint());
    int nSide2=segEnd.OnWhichSide(m_segFirst.StartPoint());
    segStart = segStart.Offset(nSide1, 2.0*GetPScale(), LS_FINITE);
    segEnd = segEnd.Offset(nSide2, 2.0*GetPScale(), LS_FINITE);
    double nDir=m_segFirst.IDirection(0);
    if (!IsArcAxisNet() && !IsArcAxis()) {
        for (i=0; i<nLen; i++) {
            XCurveSegment segCur=dimSet[i];
            if (!HandleAxisCircle(segCur, segBase))
                return FALSE;
            if (!CT_IsExactSameDrt(segCur.IDirection(0), nDir, _angSnap))
                TchPrivate::Exchange(segCur.StartPoint(), segCur.EndPoint());
            TAxisInfo *pAxis=m_lstAxis[i];
            if (segStart.OnWhichSide(segCur.StartPoint())==nSide1) {
                pAxis->m_nFlag |= AXF_NOSIDE1;
            }
            if (segEnd.OnWhichSide(segCur.EndPoint())==nSide2) {
                pAxis->m_nFlag |= AXF_NOSIDE2;
            }
        }
    }
    return TRUE;
}

// add by xly on 110314 支持交叉轴网可以标注
// 平行轴线的方向有可能是相反的，手工绘制轴线时候
BOOL TDbAxisLabelSet::ConvertFrom(const XAxisDimSet &dimSet,bool bIsCross)
{
	assertWriteEnabled();
	//BOOL bValid=IsValid(); //修改还是新建

	m_lstAxis.Reset();
	m_nFlag=0;

	int nLen=dimSet.Length();
	XCurveSegment segBase=(*dimSet.pSortBase);
	XPoint ptCen;
	for (int i=0; i<nLen; i++) {
		XCurveSegment segCur=dimSet[i];
		if (!HandleAxisCircle(segCur, segBase))
			return FALSE;
		TAxisInfo *pAxis=new TAxisInfo;
		if (i==0) {
			m_segFirst=segCur;
			if (!segBase.Is(CURVE_LINE)) { //圆弧轴网开间方向
				m_nFlag |= ANF_CIRARC;
				if (segBase.Is(CURVE_CIRCLE)) {
					m_nFlag |= ANF_CLOSE;
					ptCen=segBase.GetCircle().GetCenterPt();
				} else
					ptCen=segBase.GetArc().GetCenterPt();
				ASSERT(m_segFirst.Is(CURVE_LINE));
				if (ptCen.Distance2d(m_segFirst.StartPoint())>ptCen.Distance2d(m_segFirst.EndPoint()))
					TchPrivate::Exchange(m_segFirst.StartPoint(), m_segFirst.EndPoint());
				// modify by xly on 110314 支持交叉轴网可以标注
				// m_nDist2Center=ptCen.Distance2d(m_segFirst.StartPoint());
				if (bIsCross)
				{
					m_nDist2Center = -ptCen.Distance2d(m_segFirst.StartPoint());
				}
				else
				{
					m_nDist2Center=ptCen.Distance2d(m_segFirst.StartPoint());
				}
				//m_nFlag |= ANF_HIDESIDE1;
				if (!XAxisDimSet::g_AntiClockWise)
					m_nFlag |= ANF_CLOCKWISE;
			}
			if (!m_segFirst.Is(CURVE_LINE))
				m_nFlag |= ANF_CIRARC;
		}  

		if (i==nLen-1) {
			pAxis->m_nPara2Next=0.0;
		} else {
			XCurveSegment segNext=dimSet[i+1];
			if (!HandleAxisCircle(segNext, segBase))
				return FALSE;
			if (segCur.Is(CURVE_LINE)) {
				ASSERT(segNext.Is(CURVE_LINE) && dimSet.pSortBase);

				if (!(m_nFlag&ANF_CIRARC)) {
					XPoint ptMid=segNext.MidPoint();
					if (i>0 && !CT_IsExactSameDrt(segCur.IDirection(0), m_segFirst.IDirection(0), _angSnap))
						TchPrivate::Exchange(segCur.StartPoint(), segCur.EndPoint());
					pAxis->m_nPara2Next=segCur.GetDist2Me(ptMid);
				} else {
					if (ptCen.Distance2d(segCur.StartPoint())>ptCen.Distance2d(segCur.EndPoint()))
						TchPrivate::Exchange(segCur.StartPoint(), segCur.EndPoint());
					if (ptCen.Distance2d(segNext.StartPoint())>ptCen.Distance2d(segNext.EndPoint()))
						TchPrivate::Exchange(segNext.StartPoint(), segNext.EndPoint());

					if (m_nFlag&ANF_CLOCKWISE)
						pAxis->m_nPara2Next=-CT_std_angle(segCur.IDirection(0)-segNext.IDirection(0));  
					else
						pAxis->m_nPara2Next=CT_std_angle(segNext.IDirection(0)-segCur.IDirection(0));  
				}
			} else {
				XPoint ptMid=segNext.MidPoint();
				pAxis->m_nPara2Next=segCur.GetDist2Me(ptMid);
			}
		}
		m_lstAxis.Append(pAxis);
	}

	XCurveSegment segStart=GetOrthoCurve(0).GetCurve(),
		segEnd=GetOrthoCurve(1).GetCurve();
	int nSide1=segStart.OnWhichSide(m_segFirst.EndPoint());
	int nSide2=segEnd.OnWhichSide(m_segFirst.StartPoint());
	segStart = segStart.Offset(nSide1, 2.0*GetPScale(), LS_FINITE);
	segEnd = segEnd.Offset(nSide2, 2.0*GetPScale(), LS_FINITE);
	double nDir=m_segFirst.IDirection(0);
	if (!IsArcAxisNet() && !IsArcAxis()) {
		for (i=0; i<nLen; i++) {
			XCurveSegment segCur=dimSet[i];
			if (!HandleAxisCircle(segCur, segBase))
				return FALSE;
			if (!CT_IsExactSameDrt(segCur.IDirection(0), nDir, _angSnap))
				TchPrivate::Exchange(segCur.StartPoint(), segCur.EndPoint());
			TAxisInfo *pAxis=m_lstAxis[i];
			if (segStart.OnWhichSide(segCur.StartPoint())==nSide1) {
				pAxis->m_nFlag |= AXF_NOSIDE1;
			}
			if (segEnd.OnWhichSide(segCur.EndPoint())==nSide2) {
				pAxis->m_nFlag |= AXF_NOSIDE2;
			}
		}
	}
	return TRUE;
}

// 标注1和2道尺寸线
BOOL TDbAxisLabelSet::GetDimension(int nSide, TDbDimension2 &dim1, TDbDimension2 &dim2) const
{
    int nAxisNum=m_lstAxis.Length();
    if (nAxisNum<2)
        return FALSE;
    XCurveSegment cvBase=GetOrthoCurve(nSide, TRUE).GetCurve();
    //cvBase.Make();
    XPoint ptLoc1, ptLoc2;
    BOOL bValid1=dim1.IsValid(); //修改或创建
    BOOL bValid2=dim2.IsValid();
    if (bValid1 && (dim1.GetLocation()&m_segFirst)!=PR_OUTSIDE) 
        ptLoc1=dim1.GetLocation();
    else  {
        if (m_nFlag&ANF_CLOSE) { //圆形轴网
            ptLoc1=cvBase.EndPoint();
        } else {
            ptLoc1=cvBase.StartPoint();
        }
    }
    if (bValid2 && (dim2.GetLocation()&m_segFirst)!=PR_OUTSIDE)
        ptLoc2=dim2.GetLocation();
    else
        ptLoc2=cvBase.StartPoint();

    int nSegNum1=dim1.GetSegmentNum();
    for (int i=0; i<nSegNum1; i++)
        dim1.RemoveSegment(0);

    int nSegNum2=dim2.GetSegmentNum();
    for (i=0; i<nSegNum2; i++)
        dim2.RemoveSegment(0);


    dim1.SetLocation(ptLoc1);
    dim2.SetLocation(ptLoc2);
    
    if (m_nFlag&ANF_CLOSE)
        dim1.SetRotation(cvBase.IDirection(1)+PI);
    else
        dim1.SetRotation(cvBase.IDirection(0));
    dim2.SetRotation(cvBase.IDirection(0));
    BOOL bAngular=(IsArcAxisNet() && !IsArcAxis());
    dim1.SetAngular(bAngular);
    dim2.SetAngular(bAngular);

    BOOL bRevSeq=FALSE; //是否反序1/2/3道尺寸线
    if (bAngular) {
        double nFactor=nSide==0? 1.0 : -1.0;
        double nRad=cvBase.GetArc().GetRadius();
        if (nRad<_DIST_SNAP*2)
            return FALSE;
        dim1.SetObjRadius(nRad);
        dim2.SetObjRadius(nRad);
        double nDimRad1=nRad-nFactor*(GetLeaderLen(nSide, TRUE)-g_nDist2Dim1)*GetPScale();
        if (nDimRad1<_DIST_SNAP) 
            bRevSeq=TRUE;
        if (bRevSeq)
            nDimRad1=(g_nDist2Dim1+3.0)*GetPScale();
        double nDimRad2=nRad-nFactor*(GetLeaderLen(nSide, TRUE)-g_nDist2Dim2)*GetPScale();
        if (bRevSeq)
            nDimRad2=(g_nDist2Dim2+3.0)*GetPScale();
        if (m_nFlag&ANF_CLOSE)
            dim1.SetDimRadius(nDimRad2);
        else
            dim1.SetDimRadius(nDimRad1);
        dim2.SetDimRadius(nDimRad2);
    }
    if (bRevSeq) {
        XPoint ptCen=GetArcNetCenter();
        //XPoint ptLoc;
        ads_polar(ptCen, ads_angle(ptCen, ptLoc1), 3.0*GetPScale(), ptLoc1);
        ads_polar(ptCen, ads_angle(ptCen, ptLoc2), 3.0*GetPScale(), ptLoc2);
        dim1.SetLocation(ptLoc1);
        dim2.SetLocation(ptLoc2);
    }

    if (!bValid1 ) { //Set Dist2Dim
        if (!(m_nFlag&ANF_CLOSE)) {
            XPoint ptDimLine;
            if (nSide==0)
                ads_polar(m_segFirst.StartPoint(), m_segFirst.IDirection(0)+PI, 
                (GetLeaderLen(nSide, TRUE)-g_nDist2Dim1)*GetPScale(), ptDimLine);
            else
                ads_polar(m_segFirst.EndPoint(), m_segFirst.IDirection(1)+PI, 
                (GetLeaderLen(nSide, TRUE)-g_nDist2Dim1)*GetPScale(), ptDimLine);
            int nOnSide=cvBase.OnWhichSide(ptDimLine);
            double nDist2DimLine=(nOnSide==OFFSET_LEFT)? (GetLeaderLen(nSide, TRUE)-g_nDist2Dim1) : -(GetLeaderLen(nSide, TRUE)-g_nDist2Dim1);
			//adsout << _T("\nDist=") << nDist2DimLine << _T("\nSideFlag=") << nOnSide;
			//ptDimLine.Make();
            if (!bRevSeq) dim1.SetDist2DimLine(nDist2DimLine);
            else dim1.SetDist2DimLine(-g_nDist2Dim1);
        } else {
        }
    }
    if (!bValid2) { //Set Dist2Dim
        XPoint ptDimLine;
        if (nSide==0)
            ads_polar(m_segFirst.StartPoint(), m_segFirst.IDirection(0)+PI, 
            (GetLeaderLen(nSide, TRUE)-g_nDist2Dim2)*GetPScale(), ptDimLine);
        else
            ads_polar(m_segFirst.EndPoint(), m_segFirst.IDirection(1)+PI, 
            (GetLeaderLen(nSide, TRUE)-g_nDist2Dim2)*GetPScale(), ptDimLine);
        int nOnSide=cvBase.OnWhichSide(ptDimLine);
        double nDist2DimLine=(nOnSide==OFFSET_LEFT)? (GetLeaderLen(nSide, TRUE)-g_nDist2Dim2) : -(GetLeaderLen(nSide, TRUE)-g_nDist2Dim2);
        if (!bRevSeq) dim2.SetDist2DimLine(nDist2DimLine);
        else dim2.SetDist2DimLine(-g_nDist2Dim2);
        if ((m_nFlag&ANF_CLOSE)) {//此时是并列关系
            if (!bRevSeq) dim1.SetDist2DimLine(nDist2DimLine);
            else dim1.SetDist2DimLine(-g_nDist2Dim2);
        }
    }

    if (!bAngular) {
        dim2.AppendSegment(cvBase.GetLength());
        dim1.AppendSegment(cvBase.GetLength());
    } else {
        if (!(m_nFlag&ANF_CLOSE)) {
            dim2.AppendSegment(cvBase.GetArc().Bulge(), FALSE);
            dim1.AppendSegment(cvBase.GetArc().Bulge(), FALSE);
        } else {
            double nAng2=cvBase.GetArc().Bulge();
            double nAng1=2.0*PI-nAng2;
            dim2.AppendSegment(nAng2, FALSE);
            dim1.AppendSegment(nAng1, FALSE);
        }
    }
    
    int nTestBit=nSide? AXF_NOSIDE2 : AXF_NOSIDE1;
    for (int n=1; n<nAxisNum-1; n++) {
        const TAxisInfo &axisInfo=m_lstAxis[n];
        if (axisInfo.m_nFlag&nTestBit)
            continue;
        XCurveSegment axis=GetAxis(n);
        if (nSide==0)
            dim2.AddSegment(axis.StartPoint());
        else
            dim2.AddSegment(axis.EndPoint());
    }
    return TRUE;
}

void TDbAxisLabelSet::ReverseOrder()
{
	assertWriteEnabled();
	int num = m_lstAxis.Length();
	XCurveSegment segFirst = GetAxis(num - 1);

	XString sLab;
	sLab = GetLabel(0);

	m_lstAxis.Reverse();
	for (int i=0; i<num-1; i++)
	{
		m_lstAxis[i]->m_nPara2Next = - m_lstAxis[i+1]->m_nPara2Next;
	}
	m_lstAxis[num-1]->m_nPara2Next = 0.0;
	m_segFirst = segFirst;

	SetLabel(0, sLab, TRUE);
}

BOOL TDbAxisLabelSet::GetText(int iText,TDbText&text)const
{
	if ((iText<0) || (iText>=GetSubTextNum()))
		return FALSE;

	XPushMemVar<BOOL> vTemp(g_bExplodeSubText,TRUE);

	AcDbVoidPtrArray allEnt;
	XExplodeStream dc(allEnt);
	dc.SetPropertiesFrom(this);
	ExplodeOrDraw2d(dc);
	int count=0;
	TSubText*pSubText=NULL;
	BOOL bRet=FALSE;
	
	long k=0;				//轴线循环
	BOOL bFlagFirst=TRUE;	//两侧轴标时是否首次执行
	for (long i=0;i<allEnt.length();i++)
	{
		AcDbEntity *pEnt=(AcDbEntity*)allEnt[i];
		if (pEnt!=NULL&&pEnt->isKindOf(TDbSymbDrawingIndex::desc()))
		{
			//modify by xlc on 090622  解决查找替换时两侧轴号执行两遍替换的问题
			if (k<m_lstAxis.Length())
			{
				//LH 2013-4-16 修改原因在于执行"图纸剪切"命令时,有崩溃现象出现。原因是const TAxisInfo &axis = m_lstAxis[i];赋值失败，
				//赋值失败是因为TDPtrList内部m_CurrteIndex已经到了链表末端，所以失败，添加下行代码，使其内部CurrteIndex发生变化，从而
				//保证赋值正确。
				const_cast<TDbAxisLabelSet*>(this)->m_lstAxis.MoveToHead();

				const TAxisInfo &axis=m_lstAxis[k];
				if (k==0 && (m_nFlag&ANF_PREVLINK))
				{
					bFlagFirst=TRUE;
					k++;
				}
				else
				{
					if ((!(m_nFlag&ANF_HIDESIDE1)) 
						&&(!(axis.m_nFlag&AXF_NOSIDE1))
						&&(!(m_nFlag&ANF_HIDESIDE2)) 
						&&(!(axis.m_nFlag&AXF_NOSIDE2))
						)
					{
						if (bFlagFirst)
						{
							bFlagFirst=FALSE;
						}
						else
						{
							bFlagFirst=TRUE;
							k++;
							continue;
						}
					}
					else
					{
						bFlagFirst=TRUE;
						k++;
					}
				}
			}
	
			if (iText==count)
			{
				TDbSymbDrawingIndex* pLabel=TDbSymbDrawingIndex::cast(pEnt);
				pSubText=pLabel->GetSubText(0);
				extern BOOL g_bDrawAxisLabel;
				XPushMemVar<BOOL> vTemp0(g_bDrawAxisLabel, TRUE);
				pLabel->GetText(0,text);
				if (pSubText!=NULL)
				{
					CString s2=pLabel->GetDrawingLabel();
					if (s2!=_T(""))
					{
						CString s1=pLabel->GetIndexLabel();
						text.SetText(s1+_T("/")+s2);
					}
				}
				bRet=TRUE;
				break;
			}

			count++;
		}
	}
	ReleaseEntSet(allEnt);
	return bRet;
}

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

	AcDbObjectId idTextStyle=m_idTextStyle;
	if (!idTextStyle)
		return pos;

	int nLen=GetSubTextNum();
	int nCode=RTNONE;
	TTextPosition posNext=posStart;
	while(1)
	{
		TDbText axisText;
		if (!GetText(posNext.m_nCookies, axisText))
			break;

		TTextPosition posRet=axisText.FindSubText(sSubText, posNext, pRange);
		if (!posRet)
		{
			posNext.m_nCookies++;
			posNext.m_nTextPos=0;
		} 
		else 
		{
			posStart = posNext;
			if (!posStart)
			{
				posStart.m_nCookies++;
				posStart.m_nTextPos = 0;
			}
			posRet.m_nCookies = posNext.m_nCookies;
			pos = posRet;
			break;
		}
	}
	return pos;
}

// 返回下一次查找的开始位置
TTextPosition  
TDbAxisLabelSet::ReplaceSubText(const TTextPosition &posRep, const TCHAR *sRepText, TTextRange *pRange)
{
	assertWriteEnabled();
	TTextPosition posNext;
	TDbText text;
	if (!GetText(posRep.m_nCookies, text))
		return posNext;
	posNext = text.ReplaceSubText(posRep, sRepText, pRange);

	int cookies = posRep.m_nCookies;
	CString strText=text.GetText();
//	SetSubText(cookies,strText);
	BOOL bSort=FALSE,bReverse;
	if (strText.GetLength()>1)
	{
		if (strText.GetAt(strText.GetLength()-1)==_T('<'))//正排
		{
			bSort=TRUE;
			bReverse=FALSE;
			strText=strText.Left(strText.GetLength()-1);
		}
		else if (strText.GetAt(0)==_T('>'))//倒排
		{
			bSort=TRUE;
			bReverse=TRUE;
			strText=strText.Right(strText.GetLength()-1);
		}
	}
	SetLabel(cookies,strText,bSort,bReverse);

	if (!posNext)
	{
		if (posNext.m_nCookies < (Adesk::UInt32)(GetSubTextNum()-1))
		{
			posNext.m_nCookies = posRep.m_nCookies+1;
			posNext.m_nTextPos = 0;
		}
	}
	return posNext;
}

// sg add 100530，根据8.5需求，在对象中，保存“是否是变前项”的动态数据
void TDbAxisLabelSet::SetChangePreNum(BOOL bTrue)
{
	assertWriteEnabled();
	TEntityFields &fd = Fields();
	fd.SFD(_T("变前项排列编号"), bTrue);
}

BOOL TDbAxisLabelSet::IsChangePreNum() const
{
	assertReadEnabled();
	BOOL bPreNum = FALSE;
	const TEntityFields &fd = GetFields();
	fd.GFD(_T("变前项排列编号"), bPreNum);
	return bPreNum;
}

// sg add 090723，支持使用新、旧圆圈文字样式，动态数据
void TDbAxisLabelSet::SetCircleTextStyle(int nStyle)
{
	assertWriteEnabled();
	Adesk::UInt8 nValue = nStyle;
	TEntityFields &fd = Fields();
	fd.SFD(_T("圆圈文字样式"), nValue);
}

int TDbAxisLabelSet::GetCircleTextStyle() const
{
	assertReadEnabled();
	Adesk::UInt8 nValue = 2;
	const TEntityFields &fd = GetFields();
	fd.GFD(_T("圆圈文字样式"), nValue);
	return nValue;
}

//add by lgy 20120209	轴号文字是否隐藏设置
void TDbAxisLabelSet::SetAllAxisTextHide(BOOL bTrue)
{
	assertWriteEnabled();
	if (bTrue)
	{
		m_nFlag2 &= ~ANF_HIDE_AXISTEXT;
	}
	else
	{
		m_nFlag2 |= ANF_HIDE_AXISTEXT;
	}
}

//add by lgy 20120209	返回轴号文字是否隐藏
BOOL TDbAxisLabelSet::IsHideAllAxisText() const
{
	return ((m_nFlag2&ANF_HIDE_AXISTEXT)==0);
}

// sg add 101116，支持统一标高
bool TDbAxisLabelSet::UnifyElevation(double dElevation)
{
    assertWriteEnabled();
	m_segFirst.SetElevation(dElevation);
	return true;
}

// add by xly on 110315 获得轴标nSides侧是否被隐藏
int TDbAxisLabelSet::GetHideSide()
{
	assertReadEnabled();
	/*int nTestBit=nSide? ANF_HIDESIDE2 : ANF_HIDESIDE1;
	if (bTrue)
		 nTestBit;
	else
		m_nFlag &= ~nTestBit;*/
	if (m_nFlag&ANF_HIDESIDE2)
	{
		return ANF_HIDESIDE2;
	}
	else if (m_nFlag&ANF_HIDESIDE1)
	{
		return ANF_HIDESIDE1;
	}
	return 0;
}

// sg add 110614，设置某轴号为主轴号前的附加轴号
void TDbAxisLabelSet::SetPreFirstAttachLabel(int nIdx, BOOL bAttach)
{
	int nLength = m_lstAxis.Length();
	if (nIdx<0 || nIdx>=nLength)
	{
		return;
	}

	TAxisInfo &axis = *m_lstAxis[nIdx];
	if (bAttach)
	{
		axis.m_nFlag |= AXF_PREFIRSE_ATTACH;
	}
	else
	{
		axis.m_nFlag &= ~AXF_PREFIRSE_ATTACH;
	}
}

CString TDbAxisLabelSet::GetXml(const AcGeMatrix3d& mat) const
{
	TXmlTree xmlTree;
	POSITION posRoot = xmlTree.Insert(_T("ATS_AXIS_LABEL"), NULL, NULL);
	{
		xmlTree.SetAttribute(posRoot, _T("name"), _T("轴号"));
		xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称"));
	}

	CString strText,strText1,sTmp1, sTmp2;
	POSITION posItem1 = xmlTree.Insert(_T("Object_ID"), posRoot, NULL);
	{
		xmlTree.SetAttribute(posItem1, _T("name"), _T("对象编号"));
		xmlTree.SetAttribute(posItem1, _T("comment"), _T("当前对象的句柄"));
		strText.Format(_T("%ld"), objectId());
		xmlTree.SetItemText(posItem1, strText);
	}

	strText = _T("");

	for (int i = 0; i < m_lstAxis.Length(); i++)
	{
		//LH 2013-4-16 修改原因在于执行"图纸剪切"命令时,有崩溃现象出现。原因是const TAxisInfo &axis = m_lstAxis[i];赋值失败，
		//赋值失败是因为TDPtrList内部m_CurrteIndex已经到了链表末端，所以失败，添加下行代码，使其内部CurrteIndex发生变化，从而
		//保证赋值正确。
		const_cast<TDbAxisLabelSet*>(this)->m_lstAxis.MoveToHead();

		const TAxisInfo &axis = m_lstAxis[i];
		sTmp1 = axis.m_sText;

		if (fabs(axis.m_nPara2Next) < 2*PI)
		{
			sTmp2.Format(_T("%f"), axis.m_nPara2Next);
		}
		else
		{
			sTmp2.Format(_T("%.0f"), axis.m_nPara2Next);
		}

		if (i == 0)
		{
			strText += sTmp1;
			strText1 += sTmp2;
		}
		else
		{
			strText += (_T(",") + sTmp1);
			strText1 += (_T(",") + sTmp2);
		}
	}

	strText.TrimRight(_T(","));
	strText1.TrimRight(_T(","));
	posItem1 = xmlTree.Insert(_T("AXLabel_ID"), posRoot, NULL);
	{
		xmlTree.SetAttribute(posItem1, _T("name"), _T("轴号序列"));
		xmlTree.SetAttribute(posItem1, _T("comment"), _T("考虑某一侧可隐藏"));
		xmlTree.SetItemText(posItem1, strText);		
	}

	posItem1 = xmlTree.Insert(_T("AXLabel_Rad"), posRoot, NULL);
	{
		xmlTree.SetAttribute(posItem1, _T("name"), _T("轴号号圈半径"));
		strText.Format(_T("%f"),m_nCirRadius*GetPScale());
		xmlTree.SetItemText(posItem1, strText);		
	}

	posItem1 = xmlTree.Insert(_T("AXLabel_Bay"), posRoot, NULL);
	{
		xmlTree.SetAttribute(posItem1, _T("name"), _T("开间进深序列"));
		xmlTree.SetItemText(posItem1, strText1);		
	}

	posItem1 = xmlTree.Insert(_T("AXBase"), posRoot, NULL);
	{
		xmlTree.SetAttribute(posItem1, _T("name"), _T("轴号定位参数"));
	}

	POSITION posItem2 = xmlTree.Insert(_T("Point_1"), posItem1, NULL);
	{
		xmlTree.SetAttribute(posItem2, _T("name"), _T("第一点"));

		// sg modify 120117，对点进行坐标变换
		TADSGePoint3d ptTransformBy = m_segFirst.StartPoint();
		ptTransformBy.TransformBy(mat);
		// strText.Format(_T("%f,%f,%f"), m_segFirst.StartPoint().x, m_segFirst.StartPoint().y, m_segFirst.StartPoint().z);
		strText.Format(_T("%f,%f,%f"), ptTransformBy.x, ptTransformBy.y, ptTransformBy.z);
		xmlTree.SetItemText(posItem2, strText);		

	}

	posItem2 = xmlTree.Insert(_T("Line_length1"), posItem1, NULL);
	{
		xmlTree.SetAttribute(posItem2, _T("name"), _T("轴号引线长1"));
		strText.Format(_T("%.0f"), m_nLeaderLen1*GetPScale());
		xmlTree.SetItemText(posItem2, strText);		
	}

	posItem2 = xmlTree.Insert(_T("Point_2"), posItem1, NULL);
	{
		xmlTree.SetAttribute(posItem2, _T("name"), _T("第二点"));
		// sg modify 120117，对点进行坐标变换
		TADSGePoint3d ptTransformBy = m_segFirst.EndPoint();
		ptTransformBy.TransformBy(mat);
		// strText.Format(_T("%f,%f,%f"), m_segFirst.EndPoint().x, m_segFirst.EndPoint().y, m_segFirst.EndPoint().z);
		strText.Format(_T("%f,%f,%f"), ptTransformBy.x, ptTransformBy.y, ptTransformBy.z);
		xmlTree.SetItemText(posItem2, strText);		
	}
	posItem2 = xmlTree.Insert(_T("Line_length2"), posItem1, NULL);
	{
		xmlTree.SetAttribute(posItem2, _T("name"), _T("轴号引线长2"));
		strText.Format(_T("%.0f"), m_nLeaderLen2*GetPScale());
		xmlTree.SetItemText(posItem2, strText);		
	}

	posItem2 = xmlTree.Insert(_T("Cen_angle"), posItem1, NULL);
	{
		xmlTree.SetAttribute(posItem2, _T("name"), _T("圆心角"));
		xmlTree.SetAttribute(posItem2, _T("comment"), _T("圆心角非0识别为环向轴网柄"));
		strText.Format(_T("%f"), m_segFirst.m_dBulge);
		xmlTree.SetItemText(posItem2, strText);		
	}

	posItem2 = xmlTree.Insert(_T("Hide_ID"), posItem1, NULL);
	{
		xmlTree.SetAttribute(posItem2, _T("name"), _T("轴号隐藏侧"));
		xmlTree.SetAttribute(posItem2, _T("comment"), _T("不隐藏0本侧隐藏4对侧隐藏8"));

		strText.Format(_T("%d"), 0);
		if (m_nFlag & ANF_HIDESIDE1)
		{
			strText.Format(_T("%d"), 4);
		}
		if (m_nFlag & ANF_HIDESIDE2)
		{
			strText.Format(_T("%d"), 8);
		}
		xmlTree.SetItemText(posItem2, strText);		
	}

	CString strBase = TEntityBase::GetXml(mat);
	CString strXml = xmlTree.GetXml();
	int nIndex = strXml.Find(_T("<Object_ID"));
	strXml.Insert(nIndex, strBase);

	return strXml;
}

void InitDbAxisLabelSet(BOOL bTrue)
{
    if (bTrue) {
        TDbAxisLabelSet::rxInit();
        acrxBuildClassHierarchy();
        TDbAxisLabelSet::InitMatchProtocol(TRUE);
    } else {
        TDbAxisLabelSet::InitMatchProtocol(FALSE);
        deleteAcRxClass(TDbAxisLabelSet::desc());
    }
}








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

///////////////////////////////////////////////////////////////////
// 找离ptAxisEnd最近的轴线
BOOL GetClosestAxis(PickSet &ssJs, const XPoint &ptAxisEnd, Entity &eAxis)
{
     double nMinDist=0.0;
     BOOL bFind=FALSE;
     XPoint ptCen;
     long nLeng=ssJs.Length();
     for (long i=0; i<nLeng; i++) {
        Entity ent=ssJs[i];
        XCurveSegment seg(ent);
        XPoint ptPrj;
        if (seg.ProjectToMe(ptAxisEnd, ptPrj)==RTNORM) {
            int nPrFlag=(ptPrj&seg);
            if (nPrFlag==PR_INSIDE || nPrFlag==PR_ONPT1 || nPrFlag==PR_ONPT2) {
                double nDist=ptAxisEnd.Distance(ptPrj);
                if (!bFind || nDist<nMinDist) {
                    nMinDist=nDist;
                    eAxis=ent;
                    bFind=TRUE;
                } 
            }
        }
     }
     return bFind;
}


ads_real GetAxisArcRadius(PickSet &ssJs, const XPoint &ptAxisEnd)
{
    double nRad=0.0;
    Entity eAxis;
    if (GetClosestAxis(ssJs, ptAxisEnd, eAxis)) {
        XCurveSegment cv(eAxis);
        if (cv.Is(CURVE_ARC))
            nRad=cv.GetArc().GetRadius();
        else if (cv.Is(CURVE_CIRCLE))
            nRad=cv.GetCircle().GetRadius();
    }
    return nRad;
}




// 由一侧过滤条件获得另一正交侧轴线的过滤条件
int GetOrthoFlag(int nFilterFlag)
{
    int nFlag2=0;
    if (nFilterFlag&FILT_RADIATE_LINE)
        nFlag2 |= FILT_CIRARC_ONLY;
    else if (nFilterFlag&FILT_CIRARC_ONLY)
        nFlag2 |= FILT_RADIATE_LINE;
    else if (nFilterFlag&FILT_LINE_ONLY)
        nFlag2 |= FILT_LINE_ONLY;
    return nFlag2;
}

BOOL TestOrthoAxis(const XCurveSegment &cvThisSide, const XCurveSegment &cvOtherSide,
                     int nFilterFlag)
{
     if ((nFilterFlag&FILT_RADIATE_LINE)) {
         if (!cvThisSide.Is(CURVE_LINE) || (!cvOtherSide.Is(CURVE_ARC) && !cvOtherSide.Is(CURVE_CIRCLE)))
            return FALSE; //只允许线 & 圆弧
         else if ((cvOtherSide.Is(CURVE_ARC) && (cvOtherSide.GetArc().GetCenterPt()&cvThisSide)==PR_OUTSIDE) ||
                (cvOtherSide.Is(CURVE_CIRCLE) && (cvOtherSide.GetCircle().GetCenterPt()&cvThisSide)==PR_OUTSIDE))
             return FALSE; //不正交
     }
     if ((nFilterFlag&FILT_LINE_ONLY)) {
         if (!cvThisSide.Is(CURVE_LINE) || !cvOtherSide.Is(CURVE_LINE))
            return FALSE; //只允许线
     }
     if ((nFilterFlag&FILT_CIRARC_ONLY)) {
         if ((!cvThisSide.Is(CURVE_ARC) && !cvThisSide.Is(CURVE_CIRCLE)) || !cvOtherSide.Is(CURVE_LINE))
            return FALSE; //只允许圆弧 & 线
         else if ((cvThisSide.Is(CURVE_ARC) && (cvThisSide.GetArc().GetCenterPt()&cvOtherSide)==PR_OUTSIDE) ||
             (cvThisSide.Is(CURVE_CIRCLE) && (cvThisSide.GetCircle().GetCenterPt()&cvOtherSide)==PR_OUTSIDE))
             return FALSE;
     }
     return TRUE;
}

/****************************************************************/
// XAxisPickSet
/*
XAxisPickSet::XAxisPickSet(const Entity &entFirst)
:PickSet(SS_FREE)
{
    m_pOppsite = new XAxisPickSet(SS_FREE);

    XAxisPickSet &ss=*m_pOppsite;
    ss.GetFromOppsite(entFirst);
    if (!!ss) {
        XCurveSegment cv(entFirst, LS_FINITE);
        Entity ent;
        if (!GetClosestAxis(ss, cv.StartPoint(), ent))
            ent=ss[0L];
        GetFromOppsite(ent);
    }
}
*/

XAxisPickSet::XAxisPickSet(const Entity &entFirst, int nFilterFlag)
:PickSet(SS_FREE), m_pOppsite(NULL)
{
    if (GetFromSameSide(entFirst, nFilterFlag)) {
        m_pOppsite = new XAxisPickSet(SS_FREE);
        XAxisPickSet &ss=*m_pOppsite;
        ss.GetFromOppsite(entFirst, GetOrthoFlag(nFilterFlag));
    }
}


XAxisPickSet::~XAxisPickSet()
{
    if (m_pOppsite)
        delete m_pOppsite;
}

// 在两条曲线间的一组平行线(圆、弧)
//    或在扇形区内的直线
BOOL XAxisPickSet::GetFrom2Curve(const XCurveSegment &segStart0, const XCurveSegment &segEnd0)
{
	XCurveSegment segStart = segStart0;
	XCurveSegment segEnd = segEnd0;

	if (segStart.GetCurveType() != segEnd.GetCurveType())
		return FALSE;

	XArc arSector;
	BOOL bSector = FALSE;
	const TCHAR *pszDxf = NULL;
	if (segStart.Is(CURVE_LINE))
	{
		pszDxf=_T("LINE");
		if (!CT_IsSameDrt(segStart.IDirection(0), segEnd.IDirection(0), _angSnap))
		{
			XPoint ptCen;
			XLine ln1=segStart.GetLine();
			XLine ln2=segEnd.GetLine();
			ln1.SetLineFlag(LS_INFINITE);
			ln2.SetLineFlag(LS_INFINITE);
			ln1.Intersection(&ln2, ptCen);

			arSector.SetStarAngle(ads_angle(ptCen, ((XCurveSegment &)segStart).FarPoint(ptCen)));
			arSector.SetEndAngle(ads_angle(ptCen, ((XCurveSegment &)segEnd).FarPoint(ptCen)));
			arSector.SetCenterPt(ptCen);
			arSector.SetRadius(ptCen.Distance2d(((XCurveSegment &)segStart).FarPoint(ptCen)));
			bSector=TRUE;

			if (!CT_IsExactSameDrt(ads_angle(ptCen, segStart.FarPoint(ptCen)), 
				segStart.IDirection(0), _angSnap))
				TchPrivate::Exchange(segStart.StartPoint(), segStart.EndPoint());
			if (!CT_IsExactSameDrt(ads_angle(ptCen, segEnd.FarPoint(ptCen)), segEnd.IDirection(0),
				_angSnap))
				TchPrivate::Exchange(segEnd.StartPoint(), segEnd.EndPoint());            
		}
		else if ((segStart.StartPoint()&segEnd)!=PR_OUTSIDE)
		{
			// 起始和终止的夹角为180度
			XPoint ptCen;
			ptCen = segStart.StartPoint()+segStart.EndPoint()+segEnd.StartPoint()+segEnd.EndPoint();
			ptCen /= 4.0;

			arSector.SetStarAngle(ads_angle(ptCen, ((XCurveSegment &)segStart).FarPoint(ptCen)));
			arSector.SetEndAngle(ads_angle(ptCen, ((XCurveSegment &)segEnd).FarPoint(ptCen)));
			arSector.SetCenterPt(ptCen);
			arSector.SetRadius(ptCen.Distance2d(((XCurveSegment &)segStart).FarPoint(ptCen)));
			bSector=TRUE;

			if (!CT_IsExactSameDrt(ads_angle(ptCen, segStart.FarPoint(ptCen)), 
				segStart.IDirection(0), _angSnap))
				TchPrivate::Exchange(segStart.StartPoint(), segStart.EndPoint());
			if (!CT_IsExactSameDrt(ads_angle(ptCen, segEnd.FarPoint(ptCen)), segEnd.IDirection(0),
				_angSnap))
				TchPrivate::Exchange(segEnd.StartPoint(), segEnd.EndPoint());        
		} 
		else 
		{
			if (!CT_IsExactSameDrt(segStart.IDirection(0), segEnd.IDirection(0), _angSnap))
				TchPrivate::Exchange(segEnd.StartPoint(), segEnd.EndPoint());
		}
	}
	else if (segStart.Is(CURVE_ARC))
	{
		pszDxf=_T("ARC");
		if (segStart.GetArc().GetCenterPt() == segEnd.GetArc().GetCenterPt() &&
			segStart.GetArc().AngleFlag(segEnd.GetArc().MidAngle())>0)
			;
		else
			return FALSE;
	} 
	else if (segStart.Is(CURVE_CIRCLE)) 
	{
		pszDxf = _T("CIRCLE");
		if (segStart.GetCircle().GetCenterPt() == segEnd.GetCircle().GetCenterPt()) 
			;
		else
			return FALSE;
	}  
	else
		return FALSE;


	RBList rbMask(RTDXF0, pszDxf, 8, LAY_AXIS, NULL);
	PickSet ss(SS_FREE);
	if (segStart.Is(CURVE_CIRCLE))
	{
		XPoint ptLowCorn[2], ptUpCorn[2];
		segStart.GetExtend(ptLowCorn[0], ptUpCorn[0]);
		segEnd.GetExtend(ptLowCorn[1], ptUpCorn[1]);
		XPoint ptMin=Min(Wcs2Ucs(ptLowCorn[0]), Wcs2Ucs(ptLowCorn[1]));
		XPoint ptMax=Max(Wcs2Ucs(ptUpCorn[0]), Wcs2Ucs(ptUpCorn[1]));
		double nDivation=GetPickBoxWcs();
		ptMin -= XPoint(nDivation,nDivation);
		ptMax += XPoint(nDivation,nDivation);

		//modified by whl on 060119
		//AssureOnScreen(ptMin, ptMax);
		XPoint ptMin1=Min(ptLowCorn[0], ptLowCorn[1]);
		XPoint ptMax1=Max(ptUpCorn[0],ptUpCorn[1]);
		AssureOnScreen(ptMin1, ptMax1);

		if (ss.Get(_T("C"), ptMin, ptMax, RBList(RTDXF0, pszDxf, 8, LAY_AXIS, NULL))!=RTNORM) 
			return FALSE;

	}
	else
	{
		XPoly2D polyCP(1), poly2d(1);
		if (bSector) 
		{
			double nRad=max(arSector.GetCenterPt().Distance2d(segStart.EndPoint()),
				arSector.GetCenterPt().Distance2d(segEnd.EndPoint()));
			arSector.SetRadius(nRad);

			XPoint ptS, ptE;
			//arSector.GetPoints(ptS, ptE);
			arSector.GetStartPoint(ptS);
			arSector.GetEndPoint(ptE);

			polyCP.AppendNode(arSector.GetCenterPt());
			polyCP.AppendNode(ptS, arSector.Bulge());
			polyCP.AppendNode(ptE);
		} 
		else 
		{
			polyCP.AppendNode(segStart.StartPoint(), segStart.GetBulge());
			polyCP.AppendNode(segStart.EndPoint());
			polyCP.AppendNode(segEnd.EndPoint(), -segEnd.GetBulge());
			polyCP.AppendNode(segEnd.StartPoint());
		}

		XPoint ptMin1,ptMax1;
		polyCP.GetExtend(ptMin1, ptMax1);

		polyCP.TransUCS(Groups(0), Groups(1));
		double nDivation = GetPickBoxWcs();
		if (polyCP.PathArea() > 0.0)
			nDivation = -nDivation;
		polyCP.QuickOffset(nDivation, poly2d);
		if (!poly2d)
			return FALSE;

		XPoint ptMin, ptMax;
		poly2d.GetExtend(ptMin, ptMax);

		// modified by whl on 060119
		// AssureOnScreen(ptMin, ptMax);
		AssureOnScreen(ptMin1, ptMax1);

		RBList rbPoly = poly2d.Polygon();
		// 通过CP搜索在起始和终止之间的轴线
		if (ss.Get(_T("CP"), rbPoly, NULL, RBList(RTDXF0, pszDxf, 8, LAY_AXIS, NULL))!=RTNORM) 
			return FALSE;
	}

	Free();  
	long lCount = ss.Length();
	for (long i=0; i<lCount; i++)
	{
		Entity ent = ss[i];
		XCurveSegment seg(ent);
		if (!seg)
			continue; //无效的曲线要排除, 2004/1/2

		double nDistFlag = segStart.GetDist2Me(seg.StartPoint())*segEnd.GetDist2Me(seg.StartPoint());
		// sg modify 100612，距离判断，使用高级选项中的距离精确度进行判断
//		BOOL bBetween = (nDistFlag < 1.0E-3);
		BOOL bBetween = (nDistFlag < _DIST_SNAP);
		if (bSector)
		{
			BOOL bCond1 = ((arSector.GetCenterPt()&seg)==PR_EXTEND);
			BOOL bCond2 = (arSector.AngleFlag(ads_angle(arSector.GetCenterPt(), seg.FarPoint(arSector.GetCenterPt())))!=0);
			bBetween = (bCond1 && bCond2 &&
				arSector.GetCenterPt().Distance2d(seg.MidPoint())<arSector.GetRadius()+_DIST_SNAP);
		}

		if (!bBetween)
		{
			//if (nDistFlag<1.0E-3) {
			//可能是重合轴线
			//}
			continue;
		}

		if (segStart.Is(CURVE_LINE))
		{
			if (bSector)
			{
				*this += ent;
			}
			else
			{
				if (CT_IsSameDrt(seg.IDirection(0), segStart.IDirection(0), _angSnap))
				{
					*this += ent;
				}
			}
		}
		else if (segStart.Is(CURVE_ARC)) 
		{
			if (seg.GetArc().GetCenterPt()==segStart.GetArc().GetCenterPt() &&
				segStart.GetArc().AngleFlag(seg.GetArc().MidAngle())>0)
				*this += ent;
		}
		else // Circle
		{
			if (seg.GetCircle().GetCenterPt()==segStart.GetCircle().GetCenterPt())
				*this += ent;
		}
	}

	return (Length()>0L);
}

// add by xly on 110314 设置交叉的轴网可以设置标注,segStart:起始轴线；segEnd：终止轴线；bIsCross轴线是否交叉
// 在两条曲线间的一组平行线(圆、弧)
//    或在扇形区内的直线
BOOL XAxisPickSet::GetFrom2Curve(const XCurveSegment &segStart0, const XCurveSegment &segEnd0, bool bIsCross)
{
	XCurveSegment segStart = segStart0;
	XCurveSegment segEnd = segEnd0;

	if (segStart.GetCurveType() != segEnd.GetCurveType())
		return FALSE;

	XArc arSector;
	BOOL bSector = FALSE;
	const TCHAR *pszDxf = NULL;
	if (segStart.Is(CURVE_LINE))
	{
		pszDxf=_T("LINE");
		if (!CT_IsSameDrt(segStart.IDirection(0), segEnd.IDirection(0), _angSnap))
		{
			XPoint ptCen;
			XLine ln1=segStart.GetLine();
			XLine ln2=segEnd.GetLine();
			ln1.SetLineFlag(LS_INFINITE);
			ln2.SetLineFlag(LS_INFINITE);
			ln1.Intersection(&ln2, ptCen);

			arSector.SetStarAngle(ads_angle(ptCen, ((XCurveSegment &)segStart).FarPoint(ptCen)));
			arSector.SetEndAngle(ads_angle(ptCen, ((XCurveSegment &)segEnd).FarPoint(ptCen)));
			arSector.SetCenterPt(ptCen);
			arSector.SetRadius(ptCen.Distance2d(((XCurveSegment &)segStart).FarPoint(ptCen)));
			bSector=TRUE;

			if (!CT_IsExactSameDrt(ads_angle(ptCen, segStart.FarPoint(ptCen)), 
				segStart.IDirection(0), _angSnap))
				TchPrivate::Exchange(segStart.StartPoint(), segStart.EndPoint());
			if (!CT_IsExactSameDrt(ads_angle(ptCen, segEnd.FarPoint(ptCen)), segEnd.IDirection(0),
				_angSnap))
				TchPrivate::Exchange(segEnd.StartPoint(), segEnd.EndPoint());            
		}
		else if ((segStart.StartPoint()&segEnd)!=PR_OUTSIDE)
		{
			// 起始和终止的夹角为180度
			XPoint ptCen;
			ptCen = segStart.StartPoint()+segStart.EndPoint()+segEnd.StartPoint()+segEnd.EndPoint();
			ptCen /= 4.0;

			arSector.SetStarAngle(ads_angle(ptCen, ((XCurveSegment &)segStart).FarPoint(ptCen)));
			arSector.SetEndAngle(ads_angle(ptCen, ((XCurveSegment &)segEnd).FarPoint(ptCen)));
			arSector.SetCenterPt(ptCen);
			arSector.SetRadius(ptCen.Distance2d(((XCurveSegment &)segStart).FarPoint(ptCen)));
			bSector=TRUE;

			if (!CT_IsExactSameDrt(ads_angle(ptCen, segStart.FarPoint(ptCen)), 
				segStart.IDirection(0), _angSnap))
				TchPrivate::Exchange(segStart.StartPoint(), segStart.EndPoint());
			if (!CT_IsExactSameDrt(ads_angle(ptCen, segEnd.FarPoint(ptCen)), segEnd.IDirection(0),
				_angSnap))
				TchPrivate::Exchange(segEnd.StartPoint(), segEnd.EndPoint());        
		} 
		else 
		{
			if (!CT_IsExactSameDrt(segStart.IDirection(0), segEnd.IDirection(0), _angSnap))
				TchPrivate::Exchange(segEnd.StartPoint(), segEnd.EndPoint());
		}
	}
	else if (segStart.Is(CURVE_ARC))
	{
		pszDxf=_T("ARC");
		if (segStart.GetArc().GetCenterPt() == segEnd.GetArc().GetCenterPt() &&
			segStart.GetArc().AngleFlag(segEnd.GetArc().MidAngle())>0)
			;
		else
			return FALSE;
	} 
	else if (segStart.Is(CURVE_CIRCLE)) 
	{
		pszDxf = _T("CIRCLE");
		if (segStart.GetCircle().GetCenterPt() == segEnd.GetCircle().GetCenterPt()) 
			;
		else
			return FALSE;
	}  
	else
		return FALSE;


	RBList rbMask(RTDXF0, pszDxf, 8, LAY_AXIS, NULL);
	PickSet ss(SS_FREE);
	if (segStart.Is(CURVE_CIRCLE))
	{
		XPoint ptLowCorn[2], ptUpCorn[2];
		segStart.GetExtend(ptLowCorn[0], ptUpCorn[0]);
		segEnd.GetExtend(ptLowCorn[1], ptUpCorn[1]);
		XPoint ptMin=Min(Wcs2Ucs(ptLowCorn[0]), Wcs2Ucs(ptLowCorn[1]));
		XPoint ptMax=Max(Wcs2Ucs(ptUpCorn[0]), Wcs2Ucs(ptUpCorn[1]));
		double nDivation=GetPickBoxWcs();
		ptMin -= XPoint(nDivation,nDivation);
		ptMax += XPoint(nDivation,nDivation);

		//modified by whl on 060119
		//AssureOnScreen(ptMin, ptMax);
		XPoint ptMin1=Min(ptLowCorn[0], ptLowCorn[1]);
		XPoint ptMax1=Max(ptUpCorn[0],ptUpCorn[1]);
		AssureOnScreen(ptMin1, ptMax1);

		if (ss.Get(_T("C"), ptMin, ptMax, RBList(RTDXF0, pszDxf, 8, LAY_AXIS, NULL))!=RTNORM) 
			return FALSE;

	}
	else
	{
		XPoly2D polyCP(1), poly2d(1);
		if (bSector) 
		{
			double nRad=max(arSector.GetCenterPt().Distance2d(segStart.EndPoint()),
				arSector.GetCenterPt().Distance2d(segEnd.EndPoint()));
			arSector.SetRadius(nRad);

			XPoint ptS, ptE;
			//arSector.GetPoints(ptS, ptE);
			arSector.GetStartPoint(ptS);
			arSector.GetEndPoint(ptE);

			polyCP.AppendNode(arSector.GetCenterPt());
			polyCP.AppendNode(ptS, arSector.Bulge());
			polyCP.AppendNode(ptE);
		} 
		else 
		{
			polyCP.AppendNode(segStart.StartPoint(), segStart.GetBulge());
			polyCP.AppendNode(segStart.EndPoint());
			polyCP.AppendNode(segEnd.EndPoint(), -segEnd.GetBulge());
			polyCP.AppendNode(segEnd.StartPoint());
		}

		XPoint ptMin1,ptMax1;
		polyCP.GetExtend(ptMin1, ptMax1);

		polyCP.TransUCS(Groups(0), Groups(1));
		double nDivation = GetPickBoxWcs();
		if (polyCP.PathArea() > 0.0)
			nDivation = -nDivation;
		polyCP.QuickOffset(nDivation, poly2d);
		if (!poly2d)
			return FALSE;

		XPoint ptMin, ptMax;
		poly2d.GetExtend(ptMin, ptMax);

		// modified by whl on 060119
		// AssureOnScreen(ptMin, ptMax);
		AssureOnScreen(ptMin1, ptMax1);

		RBList rbPoly = poly2d.Polygon();
		// 通过CP搜索在起始和终止之间的轴线
		if (ss.Get(_T("CP"), rbPoly, NULL, RBList(RTDXF0, pszDxf, 8, LAY_AXIS, NULL))!=RTNORM) 
			return FALSE;
	}

	Free();  
	long lCount = ss.Length();
	for (long i=0; i<lCount; i++)
	{
		Entity ent = ss[i];
		XCurveSegment seg(ent);
		if (!seg)
			continue; //无效的曲线要排除, 2004/1/2

		double nDistFlag = segStart.GetDist2Me(seg.StartPoint())*segEnd.GetDist2Me(seg.StartPoint());
		// sg modify 100612，距离判断，使用高级选项中的距离精确度进行判断
//		BOOL bBetween = (nDistFlag < 1.0E-3);
		BOOL bBetween = (nDistFlag < _DIST_SNAP);
		if (bSector)
		{
			BOOL bCond1 = ((arSector.GetCenterPt()&seg)==PR_EXTEND);
			BOOL bCond2 = (arSector.AngleFlag(ads_angle(arSector.GetCenterPt(), seg.FarPoint(arSector.GetCenterPt())))!=0);
			bBetween = (bCond1 && bCond2 &&
				arSector.GetCenterPt().Distance2d(seg.MidPoint())<arSector.GetRadius()+_DIST_SNAP);
		}
		if (!bIsCross)
		{
			if (!bBetween)
			{
				//if (nDistFlag<1.0E-3) {
				//可能是重合轴线
				//}
				continue;
			}
		}

		if (segStart.Is(CURVE_LINE))
		{
			if (bSector)
			{
				*this += ent;
			}
			else
			{
				if (CT_IsSameDrt(seg.IDirection(0), segStart.IDirection(0), _angSnap))
				{
					*this += ent;
				}
			}
		}
		else if (segStart.Is(CURVE_ARC)) 
		{
			if (seg.GetArc().GetCenterPt()==segStart.GetArc().GetCenterPt() &&
				segStart.GetArc().AngleFlag(seg.GetArc().MidAngle())>0)
				*this += ent;
		}
		else // Circle
		{
			if (seg.GetCircle().GetCenterPt()==segStart.GetCircle().GetCenterPt())
				*this += ent;
		}
	}

	return (Length()>0L);
}

// 由同侧的一根轴线(一般是第一根)取得平行或成扇形的曲线
BOOL
XAxisPickSet::GetFromSameSide(const Entity &entFirst, BOOL nFilterFlag)
{
    Free();
    XCurveSegment cvFirst(entFirst, LS_FINITE);
    PickSet ss(SS_FREE);
    PickSet ss1(SS_FREE|SS_CREATE); //左进深(假定entFirst为最左开间线)
    PickSet ss2(SS_FREE|SS_CREATE), ss3(SS_FREE|SS_CREATE); //下开间和上开间
    if (ss.Get(_T("X"), NULL, NULL, RBList(RTDXF0, _T("LINE,ARC,CIRCLE"), 8, LAY_AXIS, NULL))==RTNORM) {
      long len=ss.Length();
      int nFlagOther=GetOrthoFlag(nFilterFlag);
      for (long i=0; i<len; i++) {
         Entity ent=ss[i];
         XCurveSegment cv(ent, LS_FINITE);
		 if (!cv)
			 continue; //无效的曲线要排除, 2004/1/2
         if (!TestOrthoAxis(cv, cvFirst, nFlagOther))
             continue;
         if (cvFirst.Intersection(cv, XPoint(), XPoint())) {
             ss1 += ent;
         }
      }


      // 上开间
      Entity eNearStart;
      if (GetClosestAxis(ss1, cvFirst.StartPoint(), eNearStart)) { //最下进深线
          XCurveSegment cvSecond(eNearStart, LS_FINITE);
          for (long i=0; i<len; i++) {
             Entity ent=ss[i];
             XCurveSegment cv(ent, LS_FINITE);
             if (!TestOrthoAxis(cv, cvSecond, nFilterFlag))
                 continue;
             if (cvSecond.Intersection(cv, XPoint(), XPoint())) {
                 ss2 += ent;
             }
          }
      }

      // 下开间
      Entity eNearEnd;
      if (GetClosestAxis(ss1, cvFirst.EndPoint(), eNearEnd)) { //最上进深线
          XCurveSegment cvSecond(eNearEnd, LS_FINITE);
          for (long i=0; i<len; i++) {
             Entity ent=ss[i];
             XCurveSegment cv(ent, LS_FINITE);
             if (!TestOrthoAxis(cv, cvSecond, nFilterFlag))
                 continue;
             if (cvSecond.Intersection(cv, XPoint(), XPoint())) {
                 ss3 += ent;
             }
          }
      }

    }
    long nCount2=ss2.Length();
    long nCount3=ss3.Length();
    
    *this += ss2;
    *this += ss3;
    BOOL bInvalid=!(*this);
    return !bInvalid;
}


BOOL
XAxisPickSet::GetFromOppsite(const Entity &entFirst, int nFilterFlag)
{
    XCurveSegment cvFirst(entFirst, LS_FINITE);
    return GetFromOppsite(cvFirst, nFilterFlag);
}

BOOL
XAxisPickSet::GetFromOppsite(const XCurveSegment &entFirst, int nFilterFlag)
{
    Free();
    XCurveSegment cvFirst=entFirst;
    cvFirst.SetLineFlag(LS_FINITE);
    //XCurveSegment cvFirst(entFirst, LS_FINITE);
    PickSet ss(SS_FREE);
    PickSet ss1(SS_FREE|SS_CREATE), ss3(SS_FREE|SS_CREATE); //左进深和右进深(假定entFirst为最左开间线)
    if (ss.Get(_T("X"), NULL, NULL, RBList(RTDXF0, _T("LINE,ARC,CIRCLE"), 8, LAY_AXIS, NULL))==RTNORM) {
      long len=ss.Length();
      for (long i=0; i<len; i++) {
         Entity ent=ss[i];
         XCurveSegment cv(ent, LS_FINITE);
         if (!TestOrthoAxis(cv, cvFirst, nFilterFlag))
             continue;
         if (cvFirst.Intersection(cv, XPoint(), XPoint())) {
             ss1 += ent;
         }
      }

      Entity eNearStart;
      if (GetClosestAxis(ss1, cvFirst.StartPoint(), eNearStart)) { //最下进深线
          PickSet ss2(SS_FREE|SS_CREATE); //下开间
          XCurveSegment cvSecond(eNearStart, LS_FINITE);
          for (long i=0; i<len; i++) {
             Entity ent=ss[i];
             XCurveSegment cv(ent, LS_FINITE);
             if (!TestOrthoAxis(cvSecond, cv, nFilterFlag))
                 continue;
             if (cvSecond.Intersection(cv, XPoint(), XPoint())) {
                 ss2 += ent;
             }
          }

          Entity e2, e3;
          if (GetClosestAxis(ss2, cvSecond.StartPoint(), e2) &&
              GetClosestAxis(ss2, cvSecond.EndPoint(), e3)) {
              Entity e4; //最右开间线
              if (!(entFirst==e2)) e4=e2;
              else if (!(entFirst==e3)) e4=e3;
              if (!!e4) {
                  XCurveSegment cv4(e4, LS_FINITE);
                  // 右进深
                  for (long i=0; i<len; i++) {
                     Entity ent=ss[i];
                     XCurveSegment cv(ent, LS_FINITE);
                     if (!TestOrthoAxis(cv, cv4, nFilterFlag))
                         continue;
                     if (cv4.Intersection(cv, XPoint(), XPoint())) {
                         ss3 += ent;
                     }
                  }
              }
          }
      }
    }
    long nCount2=ss1.Length();
    long nCount3=ss3.Length();
    *this += ss1;
    *this += ss3;
    BOOL bInvalid=!(*this);
    return !bInvalid;
}

BOOL
XAxisPickSet::IsArcAxis()
{
    ASSERT(!!(*this));
    ASSERT(Length()>0);
    PickSet &ss0=*this;
    Entity ent = ss0[0L];
    if (ent.Is(_T("ARC")) || ent.Is(_T("CIRCLE")))
        return TRUE;
    if (m_pOppsite && m_pOppsite->Length()>0) {
        PickSet &ss1=*m_pOppsite;
        Entity ent1 = ss1[0L];
        if (ent1.Is(_T("ARC")) || ent1.Is(_T("CIRCLE")))
            return TRUE;
    }
    return FALSE;
}

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





TARCH_IMPEXP XCurveSegment * XAxisDimSet::pSortBase=NULL;
TARCH_IMPEXP BOOL XAxisDimSet::g_AntiClockWise=TRUE;
TARCH_IMPEXP double XAxisDimSet::g_nAngleBegin=0.0; //用于圆形轴网的开间标注, 起始轴线的角度

// Static function for comparation
// 如果基线为线, 则沿线方向排序, 关键点为线的起始点
// 如果基线为圆/弧, 则沿逆时针方向排序
int XAxisDimSet::SortFunc(const XCurveSegment *cv1, const XCurveSegment *cv2)
{
   ASSERT(pSortBase!=NULL);
   ads_real nDist1=0, nDist2=0;
   if (!pSortBase->Is(CURVE_CIRCLE)) {
      XCurveSegment ln = *pSortBase;
      ln.SetLineFlag(LS_FINITE);
      XPoint ptKey[2];
      for (int n=0; n<2; n++) {
         XPoint ptInt[2];
         XCurveSegment cv=n? *cv2:*cv1;
         cv.SetLineFlag(LS_INFINITE);
         int nIntNum=cv.Intersection(ln, ptInt[0], ptInt[1]);
         if (!nIntNum) return 0;
         else if (nIntNum==2) {
             XPoint ptNear[2];
             ptNear[0]=cv.NearPoint(ptInt[0]);
             ptNear[1]=cv.NearPoint(ptInt[1]);
             if (ptInt[0].Distance(ptNear[0]) < ptInt[1].Distance(ptNear[1]))
                 ptKey[n]=ptInt[0];
             else ptKey[n]=ptInt[1];
         } else ptKey[n]= ptInt[0];
      }
      nDist1=pSortBase->PathDistance(ptKey[0]);
      nDist2=pSortBase->PathDistance(ptKey[1]);
   } else {
      XPoint pt1, pt2;
      ASSERT(cv1->Is(CURVE_LINE) && cv2->Is(CURVE_LINE));
      XLine ln1=cv1->GetLine(), ln2=cv2->GetLine();
      ln1.SetLineFlag(LS_FINITE);
	  ln2.SetLineFlag(LS_FINITE);


     XCircle cir=pSortBase->GetCircle();
     if (!ln1.Intersection(&cir, pt1, XPoint()) ||
        !ln2.Intersection(&cir, pt2, XPoint()))
        return 0;
	 nDist1 = CT_std_angle(ads_angle(cir.GetCenterPt(), pt1)-g_nAngleBegin);
     nDist2 = CT_std_angle(ads_angle(cir.GetCenterPt(), pt2)-g_nAngleBegin);
     if (!g_AntiClockWise) {
         nDist1=CT_std_angle(2*PI-nDist1);
         nDist2=CT_std_angle(2*PI-nDist2);
     }
   }
   if (nDist1>nDist2) return 1;
   else if (nDist1<nDist2) return -1;
   return 0;
}



//////////////////////////////////////////////////////////////////////////////
// Private command: 轴号反转

int RevAxisLabel()
{
	Entity ent;
	if (SelectEntity(_T("\n选择轴号<退出>:"),ent,RBList(RTDXF0, _T("ATS_AXIS_LABEL"), NULL))!=RTNORM)
		return RTERROR;
	OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbAxisLabelSet, pLabel);
	if (pLabel)
		pLabel->ReverseOrder();
	OPENOBJ_END();
	return RTNORM;
}