#include "stdafx.h"
#include "resource.h"
#include "DimAxisLabelDlg.h"
#include "axisdim.h"
#include "geassign.h"
#include "TDragPickEntSet.h"
#include <afxtempl.h>
#include "EdJigEx.h"
//#include "AxisNoParser.h"

#include "ManualDimAxisDlg.h"
// 逐点轴标命令中，多轴号不连续文字部分的文字高度
#define AXISTEXT_HEIGHT 5.5

extern GEOAPI int GetClipBoundary(XPoly2D &poly2d);
// extern GEOAPI int XGetCorner(const XPoint &ptCorn1, const TCHAR *pszMsg, XPoint &ptCorn2);
static XPoint g_ptDragCenter;
static ads_real g_nOldRadius;
static ads_real g_nOldAngle = 0.0;

int ComputDist(AcGePoint3d ptStart1,AcGePoint3d ptEnd1,AcGePoint3d ptStart2,AcGePoint3d ptEnd2,BOOL bDim=FALSE);
void AlignAxis(PickSet ss);
void AlignLine(PickSet ss,Entity ent);
// BOOL RemoveDupLine(PickSet ss,BOOL bDim=FALSE);

class TAxisLabelEdJig : public TSymbEdJig
{
public:
    TAxisLabelEdJig(TDbAxisLabelSet *);
    virtual int DoIt(int *pKeyIndex=NULL);
    DragStatus GetPoint(XPoint &pt);

protected:
    virtual Adesk::Boolean update();
    virtual AcDbEntity* entity() const;

private:
	// I/O
	TDbAxisLabelSet *m_pDrawEnt;
};

TAxisLabelEdJig::TAxisLabelEdJig(TDbAxisLabelSet *pElev)
{
    m_pDrawEnt=pElev;
}

AcEdJig::DragStatus TAxisLabelEdJig::GetPoint(XPoint &pt)
{
    XCurveSegment seg=m_pDrawEnt->GetAxis(0);
    XPoint ptBase=seg.StartPoint();
	
	return acquirePoint(pt, ptBase);
}

// 开始执行拖动
int TAxisLabelEdJig::DoIt(int *keyIndex)
{
    XCurveSegment seg=m_pDrawEnt->GetAxis(0);
    ads_polar(seg.StartPoint(), seg.IDirection(0)+PI, seg.GetLength(), m_ptResult);
    int nRet = TSymbEdJig::DoIt(keyIndex);
	
	return nRet;
}

// 更新实体数据
Adesk::Boolean TAxisLabelEdJig::update()
{
    XDirectionCurve cv=m_pDrawEnt->GetOrthoCurve(0);
    XCurveSegment segFirst=m_pDrawEnt->GetAxis(0);
    double nSide=cv.OnWhichSide(m_ptResult);
    if (nSide == cv.OnWhichSide(segFirst.EndPoint()))
	{
        double nDir=segFirst.IDirection(0);
        ads_polar(segFirst.StartPoint(), nDir+PI, 100.0, segFirst.EndPoint());
        m_pDrawEnt->SetFirstSegment(segFirst);
        m_pDrawEnt->NegateParams();
    }
    m_pDrawEnt->SetLeaderLen(0, m_ptResult.Distance2d(segFirst.StartPoint()), FALSE);
	m_pDrawEnt->SetLeaderLen(1, m_ptResult.Distance2d(segFirst.StartPoint()), FALSE);
	
	return Adesk::kTrue;
}

AcDbEntity* TAxisLabelEdJig::entity() const
{
    return (AcDbEntity *)m_pDrawEnt;
}

static int DragArcOrCircle(ads_point pt, ads_matrix mt)
{
	assert(g_nOldRadius>1.0E-9);
	ads_real nScale = ads_distance(Ucs2Wcs(g_ptDragCenter), Ucs2Wcs(pt))/g_nOldRadius;
	Ucs2Wcs(g_ptDragCenter).GetScaleMatrix(nScale, mt);
	
	return RTNORM;
}

static int DragRotationAction(ads_point pt, ads_matrix mt)
{
	ads_real nRot=CT_std_angle(ads_angle(Ucs2Wcs(g_ptDragCenter), Ucs2Wcs(pt))-g_nOldAngle);
	Ucs2Wcs(g_ptDragCenter).GetRotationMatrix(nRot, mt);
	
	return RTNORM;
}



// [2010-4-20 wubo] 设置所有的轴标实体为显示隐藏
// 成功返回true，否则返回false
bool SetShowHiddenAxisLable(bool bShow)
{
	TPickEntSet ssAxisLabelSet(SS_FREE);
	if (ssAxisLabelSet.Get(_T("A"), NULL, NULL, TRBList(RTDXF0, _T("ATS_AXIS_LABEL"), NULL)) == RTNORM)
	{
		long lLength = ssAxisLabelSet.Length();
		for (long i = 0; i < lLength; i++)
		{
			OPENOBJ_BEGIN(ssAxisLabelSet[i], AcDb::kForWrite, TDbAxisLabelSet, pAxisLabelSet);
			if (pAxisLabelSet == NULL)
			{
				continue;
			}
			pAxisLabelSet->SetShowHide(bShow);
			OPENOBJ_END();
		}

		return true;
	}
	else
	{
		return false;
	}
}

// ptPick--UCS
int DragRadius(const Entity &e, const TCHAR *pszPrompt, const XPoint &ptPick)
{
	Entity ent=e;
	ent.GetData(10, &g_ptDragCenter);
	ent.GetData(40, &g_nOldRadius);
	g_ptDragCenter=Wcs2Ucs(g_ptDragCenter);
	XPoint ptLow=ptPick-XPoint(_DIST_SNAP, _DIST_SNAP);
	XPoint ptUp=ptPick+XPoint(_DIST_SNAP, _DIST_SNAP);
	AssureOnScreen(ptLow, ptUp);
	
	TDragPickEntSet ssDrag(ptPick, SS_FREE);
	ssDrag += ent;
	XPoint ptDrag=ptPick;
	ads_initget(RSG_OTHER, NULL);
	int rc = ads_draggen(ssDrag,  pszPrompt, 0,
						DragArcOrCircle,
						ptDrag);
	if (rc == RTNORM)
	{
		ads_real nRadius=ads_distance(g_ptDragCenter, ptDrag);
		ent.SetData(40, nRadius);
		
		return ent.Modify();
	}
	else if (rc == RTSTR)
	{
		TCHAR sInput[80]=_T("");
		ads_getinput(sInput);
		if (!sInput[0]) 
		{
			return RTERROR;
		}
		ads_real nRadius=_tstof(sInput);
		if (nRadius<1.0E-9)
		{
			return RTERROR;
		}
		ent.SetData(40, nRadius);
		
		return ent.Modify();
	}
	
	return RTERROR;
}

// 适合于Z轴方向==WCS Z轴的UCS
// ptBase--UCS
// ptPick0--UCS
int DragRotation(const Entity &e, const TCHAR *pszPrompt, const XPoint &ptBase, const XPoint &ptPick0)
{
	Entity ent=e;
	g_ptDragCenter = ptBase;
	g_nOldAngle = ads_angle(Ucs2Wcs(ptBase), Ucs2Wcs(ptPick0));
	
	XPoint ptLow=ptBase-XPoint(_DIST_SNAP, _DIST_SNAP);
	XPoint ptUp=ptBase+XPoint(_DIST_SNAP, _DIST_SNAP);
	AssureOnScreen(ptLow, ptUp);
	
	TDragPickEntSet ssDrag(ptBase, SS_FREE);
	ssDrag += ent;
	XPoint ptDrag=ptPick0;
	ads_initget(RSG_OTHER, NULL);
	int rc = ads_draggen(ssDrag,  pszPrompt, 0,
						 DragRotationAction,
						 ptDrag);
	if (rc == RTNORM)
	{
		ads_real nRot=CT_std_angle(ads_angle(Ucs2Wcs(g_ptDragCenter), Ucs2Wcs(ptDrag))-g_nOldAngle)*180/PI;
		XPushVar<int> vOsMode(_T("OSMODE"), 0);
	  // Zyu modify on 100726，支持64位
	  //return SHads_command(RTSTR, _T(".ROTATE"), RTPICKS, (long *)ssDrag, RTSTR, _T(""),
		 // RT3DPOINT, &g_ptDragCenter, RTREAL, nRot, RTNONE);
      return SHads_command(RTSTR, _T(".ROTATE"), RTPICKS, (TLong_ptr *)ssDrag, RTSTR, _T(""),
         RT3DPOINT, &g_ptDragCenter, RTREAL, nRot, RTNONE);
	}
	else if (rc == RTSTR)
	{
		TCHAR sInput[80]=_T("");
		ads_getinput(sInput);
		if (!sInput[0])
		{
			return RTERROR;
		}
		ads_real nRot=_tstof(sInput);
		if (fabs(nRot)<_angSnap)
		{
			return RTERROR;
		}
		XPushVar<int> vOsMode(_T("OSMODE"), 0);
	  // Zyu modify on 100726，支持64位
      //return SHads_command(RTSTR, _T(".ROTATE"), RTPICKS, (long *)ssDrag, RTSTR, _T(""),
      //   RT3DPOINT, &g_ptDragCenter, RTREAL, nRot, RTNONE);
	  return SHads_command(RTSTR, _T(".ROTATE"), RTPICKS, (TLong_ptr *)ssDrag, RTSTR, _T(""),
		  RT3DPOINT, &g_ptDragCenter, RTREAL, nRot, RTNONE);
	}
	
	return RTERROR;
}



/////////////////////////////////////////////
// 通过一线裁剪轴网，命令：TrimOneSideLine
void TrimOneSideLine()
{
	// 设置捕捉模式为nea
	XPushVar<int> vOsMode(_T("OSMODE"), 512);
	//xg_setvar(_T("OSMODE"), 512);
	
	// 取得裁剪线起点或裁减线上一点
	XPoint ptStart, ptEnd, ptSide;
	if (ads_getpoint(NULL, _T("\n请输入裁剪线的起点或选择一裁剪线:"), ptStart) != RTNORM)
	{
		return;
	}
	
	// 关闭捕捉模式
	xg_setvar(_T("OSMODE"), 0);
	
	// 检查是否选择了直线或多义线段
	Entity entTrim;
    ads_matrix xformres;
	struct resbuf *refstkres;
	BOOL bSelectedLine = FALSE;
	if (ads_nentselp(NULL, entTrim, ptStart, TRUE, xformres, &refstkres) == RTNORM)
	{
		RBList rb(refstkres);
		OPENOBJ_BEGIN(entTrim, AcDb::kForRead, AcDbCurve, pLine);
		if (pLine != NULL)
		{
			ASSERT(pLine->isKindOf(AcDbCurve::desc()));
			if (pLine->isKindOf(AcDbLine::desc()))
			{
				// 取得直线起点和终点
				bSelectedLine = TRUE;
				ptStart = ((AcDbLine*)pLine)->startPoint();
				ptEnd = ((AcDbLine*)pLine)->endPoint();
			}
			else if (pLine->isKindOf(AcDbPolyline::desc()))
			{
				// 取得所选的多义线段起点和终点
				XPoint pt;
				double dParam;
				pt=Ucs2Wcs(ptStart);
				//acdbUcs2Wcs(ptStart, pt, Adesk::kFalse);
				if (((AcDbPolyline*)pLine)->getParamAtPoint(pt, dParam) == Acad::eOk)
				{
					bSelectedLine = TRUE;
					dParam = int(dParam);
					((AcDbPolyline*)pLine)->getPointAtParam(dParam, ptStart);
					((AcDbPolyline*)pLine)->getPointAtParam(dParam + 1.0, ptEnd);
				}
			}
		}
		OPENOBJ_END();
	}
	
	// 如果没有选择直线，则提示选择裁剪线终点
	if (!bSelectedLine)
	{
		if (ads_getpoint(ptStart, _T("\n请输入裁剪线的终点:"), ptEnd) != RTNORM)
		{
			return;
		}
		ptStart=Ucs2Wcs(ptStart);
		ptEnd=Ucs2Wcs(ptEnd);
	}
	
	// 取得裁减方向
	ads_grdraw(ptStart, ptEnd, -1, 1);
	if (ads_getpoint(NULL, _T("\n请输入一点以确定裁剪的是哪一边:"), ptSide) != RTNORM)
	{
		SHads_command(RTSTR, _T("REDRAW"), RTNONE);

		return;
	}
	ptSide=Ucs2Wcs(ptSide);
	SHads_command(RTSTR, _T("REDRAW"), RTNONE);
	
	// 取得所有轴网
	PickSet ss(SS_FREE);
	RBList mask(RTDXF0, _T("LINE"), 8, LAY_AXIS, NULL);
	if (ss.Get(_T("X"), NULL, NULL, mask) != RTNORM)
	{
		return;
	}
	
	// 生成运算对象
	AcGeVector3d vec1, vec2;
	AcDbLine TrimLine(ptStart, ptEnd);
	AcDbLine SideLine(ptSide, asPnt3d(ptSide) + (asPnt3d(ptEnd) - asPnt3d(ptStart)));
	
	// 裁剪与裁剪线相交的轴网
	long lCount = ss.Length();
	for (long l = 0; l < lCount; l++)
	{
		// 取得并打开轴线实体
		Entity ent = ss[l];
		OPENOBJ_BEGIN(ent, AcDb::kForWrite, AcDbLine, pLine);
		if (pLine == NULL)
		{
			continue;
		}
		ASSERT(pLine->isKindOf(AcDbLine::desc()));
		
		// 求得与裁剪线的交点
		AcGePoint3dArray arptInt1, arptInt2;
		if (TrimLine.intersectWith(pLine, AcDb::kOnBothOperands, arptInt1) != Acad::eOk
			|| arptInt1.length() <= 0)
		{
			continue;
		}
		if (SideLine.intersectWith(pLine, AcDb::kExtendBoth, arptInt2) != Acad::eOk
			|| arptInt2.length() <= 0)
		{
			continue;
		}
		
		// 修改轴线的裁剪端顶点到交点
		if ((arptInt2[0] - arptInt1[0]).isCodirectionalTo(pLine->endPoint() - arptInt1[0]))
		{
			pLine->setEndPoint(arptInt1[0]);
		}
		else
		{
			pLine->setStartPoint(arptInt1[0]);
		}
		
		OPENOBJ_END();
	}
}



////////////////////////////////////////////////
// 命令: 轴线多边形裁剪
// 条件: 必须在WCS下
void ClipAxis()
{
	XPoly2D poly2d(1);
    const TCHAR *szPrompts[2]={_T("\n矩形的第一个角点或 [多边形裁剪(P)/轴线取齐(F)]<退出>:"),
							   _T("\n多边形的第一点<退出>:")};
    const TCHAR *szKeywords=_T("P F");
    int nClipType=0;
	
    XPoint ptStart;
    //while (1) 
	{
        adsout << szPrompts[0];
        int nCode;
        INITGET_BEG(0, szKeywords);
        nCode=ads_getpoint(NULL, _T(""), ptStart);
        INITGET_END();
        if (nCode == RTKWORD)
		{
			XString sKey;
			ads_getinput(sKey);
			if (sKey[0] == _T('P'))
			{
				if (ads_getpoint(NULL, szPrompts[1], ptStart)!=RTNORM)
				{
					return;
				}
				nClipType=1;
			}
			else
			{
				nClipType=2;
			}
        }
		else if (nCode!=RTNORM)
		{
            return;
        }
    }
	
    if (nClipType == 0)
	{
        XPoint ptOther;
        int nCode=XGetCorner(ptStart, _T("\n另一个角点<退出>:"), ptOther);
        if (nCode!=RTNORM)
		{
            return;
		}
        XRectAngle rect(ptStart, ptOther);
        rect.AsPoly2D(poly2d);
    }
	else if (nClipType == 1)
	{
        XPoint pt2;
        XScreenDc dc;
        dc.m_nDrawMode=1;
        DStack<XPoint> aStack;
        aStack.Push(new XPoint(ptStart));
        while (1)
		{
            XPoint &ptFrom=*aStack.Top();
            if (aStack.Length()>=3)
			{
                adsout << _T("\n下一点或 [回退(U)]<封闭>: ");
			}
            else
			{
				adsout << _T("\n下一点或 [回退(U)]<退出>: ");
			}
            int rc;
            INITGET_BEG(0, _T("U"));
            rc=ads_getpoint(ptFrom, _T(""), pt2);
            INITGET_END();
            if (rc == RTCAN)
			{
                aStack.Reset();

                return;
            }
			else if (rc == RTKWORD)
			{
                if (*aStack.Top() != ptStart)	// Not on first state
				{
					XPoint *pPt2 = aStack.Pop();
					XPoint *pPt1 = aStack.Top();
					dc.SetColor(-1);
					dc << XLine(*pPt1, *pPt2);
					delete pPt2;
                }
            }
			else
			{
                if (rc == RTNONE)
				{
                    if (aStack.Length()<3)
					{
                        return;
					}
                    else
					{
                        pt2=ptStart;
					}
                }
				XLine ln(*aStack.Top(), pt2);
				if (ln.GetLength()>_DIST_SNAP)
				{
                    dc.SetColor(7);
                    dc << ln;
                    if (!(rc == RTNONE))
					{
						aStack.Push(new XPoint(pt2));
					}
                    else
					{
						break;
					}
				}
            }
        }
        poly2d.Reset();
        XPoint *ptCur=NULL;
        while ((ptCur=aStack.Pop())!=NULL)
		{
			poly2d.AppendNode(*ptCur);
			delete ptCur;
        }
        poly2d.Compress();
        if (!poly2d || poly2d.Length()<3) 
		{
            return;
		}
    }
	else
	{
		TrimOneSideLine();

		return;
	}
	
	XPoly poly1;
	poly2d.MapToPolygon(poly1);
	RBList mask=ads_buildlist(RTDXF0, _T("LINE,ARC,CIRCLE"), 8, LAY_AXIS, NULL);
	PickSet ss(SS_FREE), ssIn(SS_FREE|SS_CREATE), ssOut(SS_FREE|SS_CREATE);
	if (ss.Get(_T("CP"), RBList(poly1.Fence()), NULL, mask)!=RTNORM)
	{
		return ;
	}
	
    // UCS to WCS
	poly2d.TransUCS(Groups(1), Groups(0));
	if (PolyClip(ss, poly2d, ssIn, ssOut) == RTNORM)
	{
		ssIn.Erase();
		//ads_redraw(NULL,0);
	}
	poly2d.TransUCS(Groups(0), Groups(1));
	XScreenDc dc;
	dc.m_nDrawMode=1;
	dc << poly2d;
}



///////////////////////////////////////////
// 命令: 矩形裁剪
// 条件: 必须在WCS下
void RClipA()
{
	//AsureWCS();
	XPoint ptCorner1, ptCorner2;
	if (XGetPoint(NULL, _T("\n第一个角点"), ptCorner1)!=RTNORM)
	{
		return ;
	}
	if (XGetCorner(ptCorner1, _T("\n另一个角点<退出>:"), ptCorner2)!=RTNORM)
	{
		return ;
	}
	if (ptCorner1 == ptCorner2)
	{
		return ;
	}

	XRectAngle box(ptCorner1, ptCorner2);
	XPoly2D poly(1);
	poly.AppendNode(box.lowLeft);
	poly.AppendNode(XPoint(box.upRight.x, box.lowLeft.y, box.lowLeft.z));
	poly.AppendNode(box.upRight);
	poly.AppendNode(XPoint(box.lowLeft.x, box.upRight.y, box.lowLeft.z));
	
	RBList mask=ads_buildlist(RTDXF0, _T("LINE,ARC,CIRCLE"), 8, LAY_AXIS, NULL);
	PickSet ss(SS_FREE), ssIn(SS_FREE|SS_CREATE), ssOut(SS_FREE|SS_CREATE);
	if (ss.Get(_T("C"), ptCorner1, ptCorner2, mask)!=RTNORM)
	{
		return;
	}
	
	if (PolyClip(ss, poly, ssIn, ssOut) == RTNORM)
	{
		ssIn.Erase();
		ads_redraw(NULL,0);
		XScreenDc dc;
		dc.m_nDrawMode = 1;
		dc << box;
	}

	return ;
}

// add by xlc on 070730
// 判断两条直线端点的最远距离
int ComputDist(AcGePoint3d ptStart1,	// [in]line1起点
			   AcGePoint3d ptEnd1,		// [in]line1终点
			   AcGePoint3d ptStart2,	// [in]line2起点
			   AcGePoint3d ptEnd2,		// [in]line2终点
			   BOOL bDim)				// [in]是否标注（轴网标注时轴线没有搭在一起时不合并）
{
	double ss = ptStart1.distanceTo(ptStart2);
	double se = ptStart1.distanceTo(ptEnd2);
	double es = ptEnd1.distanceTo(ptStart2);
	double ee = ptEnd1.distanceTo(ptEnd2);

	// modify by xlc on 090511  两点轴标时不合并不相交的轴线 
	XLine line1(XPoint(ptStart1),XPoint(ptEnd1),LS_FINITE),
		line2(XPoint(ptStart2),XPoint(ptEnd2),LS_FINITE);

	if ((ss - se > 1.0E-6) && (ss - ee > 1.0E-6) && (ss - es > 1.0E-6)
		|| (es < 1.0E-6 && se < 1.0E-6))
	{
		if (bDim &&
			(line1.HitTest2d(line2.EndPoint())>5 &&
			line2.HitTest2d(line1.EndPoint())>5))
		{
			return -1;
		}

		return 0;
	}
	else if ((se - ss > 1.0E-6) && (se - ee > 1.0E-6) && (se - es > 1.0E-6)
		|| (ss < 1.0E-6 && ee < 1.0E-6))
	{
		if (bDim &&
			(line1.HitTest2d(line2.StartPoint())>5 &&
			line2.HitTest2d (line1.EndPoint())>5))
		{
			return -1;
		}

		return 1;
	}
	else if ((es - se > 1.0E-6) && (es - ee > 1.0E-6) && (es - ss > 1.0E-6))
	{
		if (bDim && 
			(line1.HitTest2d(line2.EndPoint())>5 && 
			line2.HitTest2d (line1.StartPoint())>5))
		{
			return -1;
		}

		return 2;
	}
	else if ((ee - se > 1.0E-6) && (ee - ss > 1.0E-6) && (ee - es > 1.0E-6))
	{
		if (bDim && 
			(line1.HitTest2d(line2.StartPoint())>5 && 
			line2.HitTest2d (line1.StartPoint())>5))
		{
			return -1;
		}

		return 3;
	}

	return -1;
}

// Zyu add on 100610, 计算两条圆弧合并后的起始角度和结束角度，返回值代表是否可以合并圆弧
bool MergeArc(double &dStartAngle1,	// [in, out] 合并圆弧的起始角度
			  double &dEndAngle1,	// [in, out] 合并圆弧的结束角度
			  double dStartAngle2,	// [in] 被合并圆弧的起始角度
			  double dEndAngle2,	// [in] 被合并圆弧的结束角度
			  BOOL bDim = FALSE)	// [in] 是否标注（轴网标注时轴线没有搭在一起时不合并）
{
	TGGeSector sec1(dStartAngle1, dEndAngle1);	// 合并圆弧对应的扇形
	TGGeSector sec2(dStartAngle2, dEndAngle2);	// 被合并圆弧对应的扇形

	// 如果两个圆弧有重合的部分
	if (sec1.AngleFlag(dStartAngle2) || sec1.AngleFlag(dEndAngle2) ||
		sec2.AngleFlag(dStartAngle1) || sec2.AngleFlag(dEndAngle1))
	{
		// 判断一平面向量是否在扇形区内
		if (sec2.AngleFlag(dStartAngle1))
		{
			dStartAngle1 = dStartAngle2;
		}

		if (sec2.AngleFlag(dEndAngle1))
		{
			dEndAngle1 = dEndAngle2;
		}
		return true;
	}

	return false;
}

// sg delete 100720，增加了圆、弧等功能的支持，变成了新的里TchDupAxis的函数
/*
// 消除重线
BOOL RemoveDupLine(PickSet ss, BOOL bDim)
{
	if (ss.Length() < 2)
	{
		return FALSE;
	}

	long n = 0;
	do
	{
		Entity ent = ss[n];
		XDbObject obj(ent, AcDb::kForRead);
		if (!obj)
			continue;

		AcDbLine *pLine = AcDbLine::cast(obj.m_pObject);
		if (pLine != NULL) // 直线
		{
			XLine line;
			line.StartPoint() = XPoint(pLine->startPoint().x, pLine->startPoint().y, pLine->startPoint().z);
			line.EndPoint() =  XPoint(pLine->endPoint().x, pLine->endPoint().y, pLine->endPoint().z);
			AcGeVector3d vect = pLine->endPoint() - pLine->startPoint();

			for (long i=n+1; i<ss.Length(); i++)
			{
				Entity en = ss[i];
				XDbObject objNew(en, AcDb::kForRead);
				if (!objNew)
					continue;

				AcDbLine *pLineNew = AcDbLine::cast(objNew.m_pObject);
				if (pLineNew != NULL)
				{
					XLine lineNew;
					lineNew.StartPoint() =
						XPoint(pLineNew->startPoint().x, pLineNew->startPoint().y, pLineNew->startPoint().z);
					lineNew.EndPoint() =
						XPoint(pLineNew->endPoint().x, pLineNew->endPoint().y, pLineNew->endPoint().z);
					AcGeVector3d vectNew = pLineNew->endPoint() - pLineNew->startPoint();

					if (vect.isParallelTo(vectNew))	// 平行
					{
						int nn = (lineNew.StartPoint())&(line);
						if (nn != PR_OUTSIDE)		// 共线
						{
							int nRet = ComputDist(pLine->startPoint(), pLine->endPoint(),
								pLineNew->startPoint(), pLineNew->endPoint(), bDim);
							if (nRet != -1)			// 可以合并
							{
								pLine->upgradeOpen();
								if (nRet == 0)		// ss
								{
									pLine->setEndPoint(pLineNew->startPoint());
								}
								else if (nRet == 1)	// se
								{
									pLine->setEndPoint(pLineNew->endPoint());
								}
								else if (nRet == 2)	// es
								{
									pLine->setStartPoint(pLineNew->startPoint());
								}
								else				// ee
								{
									pLine->setStartPoint(pLineNew->endPoint());
								}
								pLine->downgradeOpen();

								pLineNew->upgradeOpen();
								pLineNew->erase();
								pLineNew->close();
								ss -= en;
							}
							else // 不可以合并
							{
								pLineNew->close();
							}
						}
						else // 不共线
						{
							pLineNew->close();
						}
					}
					else // 不平行
					{
						pLineNew->close();
					}
				}
			}
			pLine->close();
		}
		n++;
	} while (n<ss.Length() - 1);

	return TRUE;
}
*/
// 重合轴网
namespace TchDupAxis
{
	// 判断两直线是否重合
	bool IsDupLine(AcDbLine *pLine1, AcDbLine *pLine2, bool bDim = false);
	// 判断两弧线是否重合
	bool IsDupArc(AcDbArc *pArc1, AcDbArc *pArc2, bool bDim = false);
	// 判断两圆是否重合
	bool IsDupCircle(AcDbCircle *pCircle1, AcDbCircle *pCircle2, bool bDim = false);

	// 消除重线
	bool RemoveDupLine(PickSet &ssLine, bool bDim = false);
	// 消除重弧线
	bool RemoveDupArc(PickSet &ssArc, bool bDim = false);
	// 消除重圆
	bool RemoveDupCircle(PickSet &ssCircle, bool bDim = false);

	// 消除重合轴网
	bool RemoveDupAxis(PickSet ss, bool bDim = false);
};

// 判断两直线是否重合
bool TchDupAxis::IsDupLine(AcDbLine *pLine1, AcDbLine *pLine2, bool bDim)
{
	if (pLine1==NULL || pLine2==NULL)
	{
		return false;
	}

	// 后续可增加首先对图层、线型等的过滤

	AcGeVector3d vect1 = pLine1->endPoint() - pLine1->startPoint();
	AcGeVector3d vect2 = pLine2->endPoint() - pLine2->startPoint();
	if (vect1.isParallelTo(vect2) != Adesk::kTrue) // 不平行
	{
		return false;
	}

	// 问题描述：1.重合的轴线数量≥3个时，不能完全消重。2.合并的轴线不是最大长度，
	//			完全重合的两条轴线不能合并。
	// 解决方法：1.在选择集ss里删除实体en时，对应的下标计数器i也要减1，保证
	//			遍历时不会漏掉任何一个实体。2.废弃原有算法。新算法是将被合并的直线端点投影到
	//			原直线上，如果投影点在直线的延长线上，则设置为端点。
	// 修改人，修改时间：Zyu modify on 100612.
	TGGeCurveSegment cvSegLine1;	// 原来的线段
	cvSegLine1.StartPoint() = XPoint(pLine1->startPoint().x, pLine1->startPoint().y, pLine1->startPoint().z);
	cvSegLine1.EndPoint() =  XPoint(pLine1->endPoint().x, pLine1->endPoint().y, pLine1->endPoint().z);
	cvSegLine1.SetLineFlag(LS_FINITE);

	TGGeCurveSegment cvSegLine2;	// 被合并的线段
	cvSegLine2.StartPoint() = XPoint(pLine2->startPoint().x, pLine2->startPoint().y, pLine2->startPoint().z);
	cvSegLine2.EndPoint() = XPoint(pLine2->endPoint().x, pLine2->endPoint().y, pLine2->endPoint().z);
	cvSegLine2.SetLineFlag(LS_FINITE);

	int nRet = (cvSegLine2.StartPoint())&(cvSegLine1);
	if (nRet == PR_OUTSIDE) // 不共线
	{
		return false;
	}

	TADSGePoint3d ptResStart;		// 被合并线段起点投影点
	TADSGePoint3d ptResEnd;			// 被合并线段终点投影点
	bool bExtendStart = false;		// 被合并线段起点投影在原线段的延长线上
	bool bExtendEnd = false;		// 被合并线段终点投影在原线段的延长线上
	bool bMerge = true;				// 是否合并两条线段

	// 求被合并线段的开始点在原线段上的投影点
	if (RTNORM == cvSegLine1.ProjectToMe(cvSegLine2.StartPoint(), ptResStart))
	{
		bExtendStart = (PR_EXTEND == (ptResStart & cvSegLine1));
	}

	// 求被合并线段的结束点在原线段上的投影点
	if (RTNORM == cvSegLine1.ProjectToMe(cvSegLine2.EndPoint(), ptResEnd))
	{
		bExtendEnd = (PR_EXTEND == (ptResEnd & cvSegLine1));
	}

	// 求line上与投影点最近的端点
	AcGePoint3d ptNearStart = asPnt3d(cvSegLine1.NearPoint(asDblArray((AcGePoint3d)ptResStart)));
	AcGePoint3d ptNearEnd = asPnt3d(cvSegLine1.NearPoint(asDblArray((AcGePoint3d)ptResEnd)));

	// 当进行轴网标注时轴线没有搭在一起时不合并
	if (bDim && bExtendStart && bExtendEnd)
	{
		// 当两个投影点在与line的最近点是同一个点时，说明两轴线没有搭在一起，不合并
		bMerge = !ptNearStart.isEqualTo(ptNearEnd);
	}

	if (!bMerge)
	{
		return false;
	}

	// 如果投影点在原直线的延长线上
	if (pLine1->upgradeOpen() == Acad::eOk)
	{
		if (bExtendStart)
		{
			// 将离投影点更近的端点延长到投影点
			if (ptNearStart.isEqualTo(cvSegLine1.GetStartPoint()))
			{
				pLine1->setStartPoint(ptResStart);
				cvSegLine1.SetStartPoint(ptResStart);
			}
			else
			{
				pLine1->setEndPoint(ptResStart);
				cvSegLine1.SetEndPoint(ptResStart);
			}
		}

		bExtendEnd = (PR_EXTEND == (ptResEnd & cvSegLine1));
		if (bExtendEnd)
		{
			ptNearEnd = asPnt3d(cvSegLine1.NearPoint(asDblArray((AcGePoint3d)ptResEnd)));
			// 将离投影点更近的端点延长到投影点
			if (ptNearEnd.isEqualTo(cvSegLine1.GetEndPoint()))
			{
				pLine1->setEndPoint(ptResEnd);
				cvSegLine1.SetEndPoint(ptResEnd);
			}
			else
			{
				pLine1->setStartPoint(ptResEnd);
				cvSegLine1.SetStartPoint(ptResEnd);
			}
		}
		pLine1->downgradeOpen();
	}
	return true;
}

// 判断两弧线是否重合
bool TchDupAxis::IsDupArc(AcDbArc *pArc1, AcDbArc *pArc2, bool bDim)
{
	if (pArc1==NULL || pArc2==NULL)
	{
		return false;
	}

	// 判断条件：两条弧圆心和半径都相同
	if (pArc1->center().isEqualTo(pArc2->center()) &&
		fabs(pArc1->radius() - pArc2->radius()) < _DIST_SNAP)
	{
		double dStartAngle = pArc1->startAngle(),
			dEndAngle = pArc1->endAngle();
		if (!MergeArc(dStartAngle, dEndAngle, pArc2->startAngle(), pArc2->endAngle(), bDim))
		{
			return false;
		}

		if (pArc1->upgradeOpen() == Acad::eOk)
		{
			pArc1->setStartAngle(dStartAngle);
			pArc1->setEndAngle(dEndAngle);
			pArc1->downgradeOpen();
		}

		return true;
	}

	return false;
}

// 判断两圆是否重合
bool TchDupAxis::IsDupCircle(AcDbCircle *pCircle1, AcDbCircle *pCircle2, bool bDim)
{
	if (pCircle1==NULL || pCircle2==NULL)
	{
		return false;
	}

	if (pCircle1->center().isEqualTo(pCircle2->center()) &&
		fabs(pCircle1->radius() - pCircle2->radius()) < _DIST_SNAP)
	{
		return true;
	}

	return false;
}

// 消除重线
bool TchDupAxis::RemoveDupLine(PickSet &ssLine, bool bDim)
{
	long lLength = ssLine.Length();
	for (long i=0; i<lLength-1; i++)
	{
		Entity ent1 = ssLine[i];
		OPENOBJ_BEGIN(ent1, AcDb::kForRead, AcDbLine, pLine1);
		if (pLine1 == NULL)
			continue;
			
		for (long j=i+1; j<lLength; j++) // 与选择集里的第n个以后的实体，做重合检查
		{
			Entity ent2 = ssLine[j];
			OPENOBJ_BEGIN(ent2, AcDb::kForRead, AcDbLine, pLine2);
			if (pLine2 == NULL)
				continue;

			// 判断是否是重复的直线
			if (!TchDupAxis::IsDupLine(pLine1, pLine2, bDim)) // 不重合
				continue;
			
			if (pLine2->upgradeOpen() == Acad::eOk) // 重合
			{
				pLine2->erase(); // 删除
				pLine2->downgradeOpen();
			}
			OPENOBJ_END();

			ssLine -= ent2;
			j--; // 下标减1，保证选择集里遍历时不会漏掉任何一个实体
			lLength--;
		}
		OPENOBJ_END();
	}
	return true;
}

// 消除重弧线
bool TchDupAxis::RemoveDupArc(PickSet &ssArc, bool bDim)
{
	long lLength = ssArc.Length();
	for (long i=0; i<lLength-1; i++)
	{
		Entity ent1 = ssArc[i];
		OPENOBJ_BEGIN(ent1, AcDb::kForRead, AcDbArc, pArc1);
		if (pArc1 == NULL)
			continue;
			
		for (long j=i+1; j<lLength; j++) // 与选择集里的第n个以后的实体，做重合检查
		{
			Entity ent2 = ssArc[j];
			OPENOBJ_BEGIN(ent2, AcDb::kForRead, AcDbArc, pArc2);
			if (pArc2 == NULL)
				continue;

			// 判断是否是重复的直线
			if (!TchDupAxis::IsDupArc(pArc1, pArc2, bDim)) // 不重合
				continue;

			if (pArc2->upgradeOpen() == Acad::eOk) // 重合
			{
				pArc2->erase(); // 删除
				pArc2->downgradeOpen();
			}
			OPENOBJ_END();

			ssArc -= ent2;
			j--;
			lLength--;
		}
		OPENOBJ_END();
	}
	return true;
}

// 消除重圆
bool TchDupAxis::RemoveDupCircle(PickSet &ssCircle, bool bDim)
{
	long lLength = ssCircle.Length();
	for (long i=0; i<lLength-1; i++)
	{
		Entity ent1 = ssCircle[i];
		OPENOBJ_BEGIN(ent1, AcDb::kForRead, AcDbCircle, pCircle1);
		if (pCircle1 == NULL)
			continue;
			
		for (long j=i+1; j<lLength; j++) // 与选择集里的第n个以后的实体，做重合检查
		{
			Entity ent2 = ssCircle[j];
			OPENOBJ_BEGIN(ent2, AcDb::kForRead, AcDbCircle, pCircle2);
			if (pCircle2 == NULL)
				continue;

			// 判断是否是重复的直线
			if (!TchDupAxis::IsDupCircle(pCircle1, pCircle2, bDim)) // 不重合
				continue;

			if (pCircle2->upgradeOpen() == Acad::eOk) // 重合
			{
				pCircle2->erase(); // 删除
				pCircle2->downgradeOpen();
			}
			OPENOBJ_END();

			ssCircle -= ent2;
			j--;
			lLength--;
		}
		OPENOBJ_END();
	}
	return true;
}

// 消除重合轴网
bool TchDupAxis::RemoveDupAxis(PickSet ss, bool bDim)
{
	if (ss.Length() < 2)
	{
		return false; // 选择集内对象不足两个，不需要消重
	}

	PickSet ssLine(SS_FREE);
	ssLine += ss;
	ssLine.BaseFilter(RBList(RTDXF0, _T("LINE"), NULL)); // 只保留直线
	if (ssLine.Length() > 0)
	{
		ss -= ssLine;

		TchDupAxis::RemoveDupLine(ssLine, bDim); // 处理直线和直线相交的情况
		ss += ssLine;
	}

	PickSet ssArc(SS_FREE);
	ssArc += ss;
	ssArc.BaseFilter(RBList(RTDXF0, _T("ARC"), NULL)); // 只保留弧线
	if (ssArc.Length() > 0)
	{
		ss -= ssArc;

		TchDupAxis::RemoveDupArc(ssArc, bDim); // 处理弧线和弧线相交的情况
		ss += ssArc;
	}


	PickSet ssCircle(SS_FREE);
	ssCircle += ss;
	ssCircle.BaseFilter(RBList(RTDXF0, _T("CIRCLE"), NULL)); // 只保留圆
	if (ssCircle.Length() > 0)
	{
		ss -= ssCircle;

		TchDupAxis::RemoveDupCircle(ssCircle, bDim); // 处理圆和圆相交的情况
		ss += ssCircle;
	}
	return true;
}


/////////////////////////////////////////////
// modified by cwk 
// 命令：两点轴标
void DimAxisBy2Curve()
{
	XAxisDimSet::g_AntiClockWise = TRUE;	// 默认逆时针方向
	InitLayer(LAY_DIMAX, TRUE);
	
	// [2010-4-7 wubo] 重复语句。与函数开头重复。
	// XAxisDimSet::g_AntiClockWise = 1;	// 默认逆时针方向
	Entity entFirst, entFinal;
	XPoint ptPick1, ptPick2;
	TCHAR  szLabStart[80] = _T("");	// 起始轴号    
	double nAxisDirection = 0.0;
	
	CTemporaryResourceOverride vTemp;
	CAxisDim *pDlg = new CAxisDim(acedGetAcadFrame());
	pDlg->m_csLabel = szLabStart;
	pDlg->m_Flag = 0;
	pDlg->Create(CAxisDim::IDD,acedGetAcadFrame());
	acedGetAcadFrame()->SetFocus();

	RBList mask(RTDXF0, _T("LINE,ARC,CIRCLE"), 8, LAY_AXIS, NULL);	// 8为AcDb::kDxfLayerName
	while (pDlg != NULL)
	{
		// 清空上次标注值，不过不知道为什么这样做
		pDlg->m_csLabel = _T("");
		pDlg->UpdateData(FALSE);

		if (SelectEntity1(_T("\n请选择起始轴线<退出>:"), entFirst, ptPick1, mask) != RTNORM)
		{
			if (pDlg != NULL)
			{
				pDlg->DestroyWindow();
				delete pDlg;
				pDlg = NULL;
			}
			return ;
		}

		XCurveSegment curveFirst(entFirst);
		if (!curveFirst.Is(CURVE_CIRCLE))
		{
			nAxisDirection = curveFirst.IDirection(0);
			if (nAxisDirection<PI/4 || nAxisDirection>1.75*PI ||
				(nAxisDirection>0.75*PI && nAxisDirection<1.25*PI))
			{
				_tcscpy(szLabStart, _T("A"));
				
			}
			else
			{
				_tcscpy(szLabStart, _T("1"));
			}
			
			if (!pDlg->m_csLabel.IsEmpty())
			{
				_tcscpy(szLabStart, pDlg->m_csLabel);
			}
			else
			{
				TCHAR cTemp[256];
				_tcscpy(cTemp,szLabStart);
				pDlg->m_csLabel = cTemp;
				pDlg->UpdateData(FALSE);
			}
		}
		else
		{
			pDlg->DestroyWindow();
			delete pDlg;
			pDlg = NULL;
			// return;
		}

		if (entFinal.FilterSelect1(GetPickBoxWcs()/2, _T("\n请选择终止轴线<退出>:"), mask, ptPick2) != RTNORM)
		{
			if (pDlg != NULL)
			{
				pDlg->DestroyWindow();
				delete pDlg;
				pDlg = NULL;
			}
			return;
		}
		
		if (entFirst == entFinal)
		{
			if (pDlg != NULL)
			{
				pDlg->DestroyWindow();
				delete pDlg;
				pDlg = NULL;
			}
			return;
		}
		
		ptPick1 = Ucs2Wcs(ptPick1);
		ptPick2 = Ucs2Wcs(ptPick2);
		
		XCurveSegment curveFinal(entFinal);
		if (curveFirst.GetCurveType() != curveFinal.GetCurveType())
		{
			if (pDlg != NULL)
			{
				pDlg->DestroyWindow();
				delete pDlg;
				pDlg = NULL;
			}
			return;
		}
		
		BOOL bRadian = FALSE,
			bCirAngular = FALSE;
		XPoint ptAxisNetCen;
		if (curveFirst.Is(CURVE_LINE) &&
			(!CT_IsSameDrt(curveFirst.IDirection(0), curveFinal.IDirection(0), _angSnap) ||
			(curveFirst.StartPoint()&curveFinal) != PR_OUTSIDE)) 
		{
			PickSet ssTemp(SS_FREE);
			TADSGePoint3d pt1(Wcs2Ucs(curveFirst.StartPoint())),
				pt2(Wcs2Ucs(curveFirst.EndPoint()));
			RBList rbFence = ads_buildlist(RT3DPOINT, &pt1, 
				RT3DPOINT, &pt2, NULL);
			bCirAngular = (ssTemp.Get(_T("F"), rbFence, NULL, 
				RBList(RTDXF0, _T("CIRCLE"), 8, LAY_AXIS, NULL)) == RTNORM);

			bRadian = TRUE;
			if ((curveFirst.StartPoint()&curveFinal)!=PR_OUTSIDE) 
			{
				ptAxisNetCen = curveFirst.StartPoint()+curveFirst.EndPoint()
					+curveFinal.StartPoint()+curveFinal.EndPoint();
				ptAxisNetCen /= 4.0;
			}
			else 
			{
				XLine ln1 = curveFirst.GetLine();
				XLine ln2 = curveFinal.GetLine();
				ln1.SetLineFlag(LS_INFINITE);
				ln2.SetLineFlag(LS_INFINITE);
				ln1.Intersection(&ln2, ptAxisNetCen);
			}

			int nAnswer = YesNoQuestion(_T("\n是否为按逆时针方向排序编号"));
			if (nAnswer == RTCAN) 
			{
				if (pDlg != NULL)
				{
					pDlg->DestroyWindow();
					delete pDlg;
					pDlg = NULL;
				}
				
				return;
			}

			if (nAnswer == Q_NO) 
			{
				XAxisDimSet::g_AntiClockWise = FALSE;
			}
			else 
			{
				XAxisDimSet::g_AntiClockWise = TRUE;
			}
		}

		XAxisPickSet ssAxis(SS_FREE); 
		if (bRadian && !XAxisDimSet::g_AntiClockWise)
		{
			ssAxis.GetFrom2Curve(curveFinal, curveFirst);  
		}
		else
		{
			ssAxis.GetFrom2Curve(curveFirst, curveFinal);
		}

		// Zyu add on 100617，将原选择集内的对象，绘制为高亮显示
		ssAxis.Redraw(3);
		
		// 增加对辅助轴线的判断，即允许用户自行指定不进行标注的轴线
		PickSet ssCancel(SS_FREE);
		ssCancel += ssAxis;

		// add by xly on 110304 清空pickfirt选择集
		ads_name ssPickFirst;	// 定义一个ads_name变量
		if (acedSSAdd(NULL, NULL, ssPickFirst) == RTNORM)	// 构造一个空选择集
		{
			acedSSSetFirst(ssPickFirst, NULL);		// 将空选择集赋给PICKFIRST
		}

		const TCHAR *szTempPrompts[2]={ _T("\n请选择不需要标注的轴线:"), _T("") };
		while(ssCancel.Get(_T(":S:$"), szTempPrompts, NULL, mask) == RTNORM)
		{
			// 首先将不需要标注的轴线，取消高亮
			ssCancel.Redraw(4);

			// 去掉用户指定的不进行标注的轴线
			ssAxis -= ssCancel;
		}

		// modify by xly on 100812 如果只剩一个轴网被选中，退出命令时选中轴网不能回复原始状态
		//if (!ssAxis)
		if (!ssAxis || ssAxis.Length()<2)
		{
			// 取消轴网的高亮状态
			ssAxis.Redraw(4);
			adsout << _T("\n不能找到轴网!");
			if (pDlg != NULL)
			{
				pDlg->DestroyWindow();
				delete pDlg;
				pDlg = NULL;
			}
		
			return ;
		}
		
		// modify by xlc on 090225 解决圆弧轴网径线消重合并的问题
		// if (!RemoveDupLine(ssAxis))		//add by xlc on 070806 消除重线
		//		return;
		// if (!bRadian)
		// {

		// 消除重线
//		if (!RemoveDupLine(ssAxis,TRUE))
		
		// modify by xly on 100812 修改 命令行多出“Dangerous TPickEntSet = !”的提示
		PickSet ssAxisNew(SS_CREATE);
		ssAxisNew += ssAxis;
		//if (!TchDupAxis::RemoveDupAxis(ssAxis,TRUE))
		if (!TchDupAxis::RemoveDupAxis(ssAxisNew,TRUE))
		{
			// sg add 100609，增加消除重现不成功时，销毁对话框
			if (pDlg != NULL)
			{
				pDlg->DestroyWindow();
				delete pDlg;
				pDlg = NULL;
			}

			return;
		}

		ssAxis.Free();
		ssAxis += ssAxisNew;
		ssAxisNew.Free();
		// }
		
		// 似乎没有用处，可删除
		ssAxis.Redraw(3);

		XPoint ptAxisEnd = curveFirst.NearPoint(ptPick1);
		XCurveSegment cvSortBase; // 排序的基线
		
		if (!bRadian) 
		{
			if (curveFirst.Is(CURVE_CIRCLE)) 
			{
				Entity entBase;
				if (entBase.FilterSelect(_T("\n请选择圆形轴网的横(径)线:"), RBList(RTDXF0, _T("LINE"), 8, LAY_AXIS, NULL))!=RTNORM)
				{
					ssAxis.Redraw(4);
					if (pDlg != NULL)
					{
						pDlg->DestroyWindow();
						delete pDlg;
						pDlg = NULL;
					}
		
					return;
				}
				cvSortBase = XCurveSegment(entBase);
			}
			else 
			{
				double nDist2Me = curveFirst.GetDist2Me(curveFinal.StartPoint());
				cvSortBase.StartPoint() = curveFirst.StartPoint();
				ads_polar(curveFirst.StartPoint(), curveFirst.IDirection(0)-PI/2.0, nDist2Me, cvSortBase.EndPoint());
				cvSortBase.SetBulge(0.0);
				// cvSortBase.Make();
			}
		} 
		else if (bCirAngular) 
		{ 
			// 圆形轴网角度标注
			cvSortBase = XCircle(ptAxisNetCen, ptAxisNetCen.Distance2d(curveFirst.FarPoint(ptAxisNetCen)));
		}  
		else 
		{
			double nAng1 = ads_angle(ptAxisNetCen, curveFirst.FarPoint(ptAxisNetCen));
			double nAng2 = ads_angle(ptAxisNetCen, curveFinal.FarPoint(ptAxisNetCen));
			if (XAxisDimSet::g_AntiClockWise == FALSE)
			{
				Exchange(nAng1, nAng2);
			}
			cvSortBase = XArc(ptAxisNetCen, ptAxisNetCen.Distance2d(curveFirst.FarPoint(ptAxisNetCen)),
							  nAng1, nAng2);
		}
		
		// Add on 2002/6/14, 解决圆形轴网起始轴角度不是最小时无法标注的问题
		double nVal = XAxisDimSet::g_nAngleBegin;
		if (cvSortBase.Is(CURVE_CIRCLE)) 
		{
			nVal = ads_angle(ptAxisNetCen, curveFirst.FarPoint(ptAxisNetCen));
		}

		XPushMemVar<double> vTemp1(XAxisDimSet::g_nAngleBegin, nVal);
		if (curveFirst.Is(CURVE_CIRCLE)) 
		{
			XLine lnBase = cvSortBase.GetLine();
			lnBase.SetLineFlag(LS_FINITE);
			XPoint ptInt;
			if (!curveFirst.Intersection(lnBase, ptInt, XPoint()))
			{
				if (pDlg != NULL)
				{
					pDlg->DestroyWindow();
					delete pDlg;
					pDlg = NULL;
				}

				return;
			}

			nAxisDirection = ads_angle(curveFirst.GetCircle().GetCenterPt(), ptInt)+PI/2.0;
			if (nAxisDirection<PI/4 || nAxisDirection>1.75*PI ||
				(nAxisDirection>0.75*PI && nAxisDirection<1.25*PI))
			{
				_tcscpy(szLabStart, _T("A"));
			}
			else
			{
				_tcscpy(szLabStart, _T("1"));
			}
		} 
		
		// 建立排序的轴网单侧
		XAxisDimSet dimSet(&cvSortBase);
		long ssLen = ssAxis.Length();
		for (long i=0; i<ssLen; i++) 
		{
			Entity ent = ssAxis[i];
			dimSet.Append(new XCurveSegment(ent));
		}
		dimSet.QuickSort(XAxisDimSet::SortFunc);
		
		if (!(*dimSet.Head() == curveFirst)) 
		{
			if (cvSortBase.Is(CURVE_CIRCLE)) 
			{
				adsout << _T("\n发现不能正确分析的轴网!");
				if (pDlg != NULL)
				{
					pDlg->DestroyWindow();
					delete pDlg;
					pDlg = NULL;
				}

				return;
			}
			
			if (*dimSet.Tail() == curveFirst)
			{
				dimSet.Reverse();
				XAxisDimSet::g_AntiClockWise = FALSE;  
			} 
			else 
			{
				adsout << _T("\n所选择的不是起始轴线!");
				if (pDlg != NULL)
				{
					pDlg->DestroyWindow();
					delete pDlg;
					pDlg = NULL;
				}

				return;
			}
		}
		
		AcDbObjectId idDimStyle = InitDimStyle(bRadian ? DS_ANGLE : DS_LINEAR);

		TDbAxisLabelSet *pAxisDim = new TDbAxisLabelSet;
		pAxisDim->SetTextStyleId(InitTextStyle(TS_AXIS));
		pAxisDim->ConvertFrom(dimSet);
		pAxisDim->SetChangePreNum(1 == pDlg->m_iRule); // 设置轴号规则（变前项或者变后项），Zyu add on 100618

		double nOldLen = pAxisDim->GetLeaderLen(0, TRUE);
		if (pAxisDim->IsArcAxisNet() && pAxisDim->IsArcAxis()) 
		{ 
			pAxisDim->SetLeaderLen(0, nOldLen+10.0, TRUE); //圆弧轴网的进深标注, 引线需要加长
			pAxisDim->SetLeaderLen(1, nOldLen+10.0, TRUE); //圆弧轴网的进深标注, 引线需要加长
		}
		
		int nLabelFlag = 0, nDimFlag = 0;
		AcDbObjectId idPrevLink;
		if (curveFirst.Is(CURVE_CIRCLE)) 
		{
			XString szBackup;
			szBackup = szLabStart;
			adsout << _T("\n请输入起始轴号(.空号)<") << szLabStart << _T(">: ");
			if (ads_getstring(0, _T(""), szLabStart) == RTNORM) 
			{
				if (_tcscmp(szLabStart, _T(".")) == 0)
				{
					_tcscpy(szLabStart, _T(""));
				}
				else if (!szLabStart[0])
				{
					_tcscpy(szLabStart, szBackup);
				}
			} 
			else 
			{
				if (pDlg != NULL)
				{
					pDlg->DestroyWindow();
					delete pDlg;
					pDlg = NULL;
				}

				return;
			}
		} 
		else 
		{  
			if (pDlg->m_bPrevLink) 
			{
				/* Entity entPrev;
				ads_sssetfirst(NULL, NULL);
				if (entPrev.FilterSelect(_T("\n点取前接轴号<退出>:"), RBList(RTDXF0, _T("ATS_AXIS_LABEL"),NULL))!=RTNORM) 
				{
				if (pDlg != NULL)
				{
				pDlg->DestroyWindow();
				delete pDlg;
				pDlg = NULL;
				}
				return;
				}
				acdbGetObjectId(idPrevLink, entPrev);*/

				//add by cwk on 070123
				PickSet ss(SS_FREE);
				XLine xLineTemp = curveFirst;
				xLineTemp.StartPoint() = Wcs2Ucs(xLineTemp.StartPoint());
				xLineTemp.EndPoint() = Wcs2Ucs(xLineTemp.EndPoint());

				RBList rbFence = ads_buildlist(RT3DPOINT, &xLineTemp.StartPoint(), RT3DPOINT, &xLineTemp.EndPoint(), NULL);
				ss.Get(_T("F"),rbFence, NULL, RBList(RTDXF0, _T("ATS_AXIS_LABEL"), NULL));
				if (ss.Length() > 0)
				{
					Entity entPrev = ss[0L];
					acdbGetObjectId(idPrevLink, entPrev);
				}
				else
				{
					// add by xly on 101029 解决公共轴线选则失败时恢复亮显
					ssAxis.Redraw(4);
					acutPrintf(_T("\n没有找到前接轴号!"));
					continue;
				}
			}
			else
			{
				//modified by whl on 070511,保留空号功能
				//if (!pDlg->m_csLabel.IsEmpty())
				//{
				// _tcscpy(szLabStart, pDlg->m_csLabel);
				//}
				_tcscpy(szLabStart, pDlg->m_csLabel);				
			}

			nLabelFlag = pDlg->m_Flag;
			nDimFlag = pDlg->m_Flag;
			/*if (pDlg != NULL)
			{
			pDlg->DestroyWindow();
			delete pDlg;
			pDlg = NULL;
		}*/
		}

		if (!idPrevLink)
		{
			pAxisDim->SortAxisLabel(szLabStart);
		}
		
		AcDbObjectId idDimLay = InitLayer(LAY_DIMAX, TRUE);
		AcDbObjectId idTextLay = InitLayer(LAY_AXIS_TEXT, TRUE);

		List<TDbDimension2*> lstNewDim;
		if (curveFirst.Is(CURVE_CIRCLE)) 
		{
			pAxisDim->HideSide(1);

			TAxisLabelEdJig jig(pAxisDim);
			jig.SetPrompt(_T("\n请输入标注位置<退出>:"));
			if (jig.DoIt()!=RTNORM)
			{
				delete pAxisDim;
				return;
			}

			if (pAxisDim->GetAxisNum()>1) 
			{
				TDbDimension2 *pDim1 = new TDbDimension2;
				TDbDimension2 *pDim2 = new TDbDimension2;
				pDim1->SetLayoutRotation(Ucs2Wcs(0));//add by whl on 070306
				pDim2->SetLayoutRotation(Ucs2Wcs(0));//add by whl on 070306				
				pDim1->SetStyleId(idDimStyle);
				pDim2->SetStyleId(idDimStyle);

				if (pAxisDim->GetDimension(0, *pDim1, *pDim2))
				{
					pDim1->setLayer(idDimLay);
					pDim2->setLayer(idDimLay);
					lstNewDim<<pDim1<<pDim2;
				} 
				else
				{
					delete pDim1;
					delete pDim2;
				}
			} 
		} 
		else  
		{
			int nSidePick = pAxisDim->OnWhichSide(ptPick1);
			if (nLabelFlag != 2) 
			{
				if (nLabelFlag == 0)
					pAxisDim->HideSide(1-nSidePick);
				else
					pAxisDim->HideSide(nSidePick);
			}

			//Modify on 2002/2/22 by ZJQ, 解决弧线标注的半径未能设置在相关的轴线的半径
			// 增加扇形的标注半径
			XAxisPickSet ssOpp(SS_FREE);
			double nRadMin = 0.0,
				nRadMax = 0.0;
			if (bRadian)
			{
				nRadMin = nRadMax = cvSortBase.GetArc().GetRadius();
				ssOpp.GetFromOppsite(curveFirst, FILT_CIRARC_ONLY);

				long lNum = ssOpp.Length();
				for (long idx=0L; idx<lNum; idx++)
				{
					Entity ent = ssOpp[idx];
					XCurveSegment segTemp(ent);
					if (segTemp.Is(CURVE_ARC)) 
					{
						if (idx == 0) 
						{
							nRadMin = nRadMax = segTemp.GetArc().GetRadius();
						} 
						else 
						{
							nRadMax = max(nRadMax, segTemp.GetArc().GetRadius());
							nRadMin = min(nRadMin, segTemp.GetArc().GetRadius());
						}
					} 
					else if (segTemp.Is(CURVE_CIRCLE)) 
					{
						if (idx == 0) 
						{
							nRadMin = nRadMax = segTemp.GetCircle().GetRadius();
						}
						else
						{
							nRadMax = max(nRadMax, segTemp.GetCircle().GetRadius());
							nRadMin = min(nRadMin, segTemp.GetCircle().GetRadius());
						}
					}
				}
			}

			// End
			if (pAxisDim->GetAxisNum() > 1)
			{
				for (int nSide=0; nSide<2; nSide++) 
				{
					if (nDimFlag == 0 && nSide != nSidePick)
					{
						continue;
					}
					else if (nDimFlag == 1 && nSide == nSidePick)
					{
						continue;
					}

					TDbDimension2 *pDim1 = new TDbDimension2;
					TDbDimension2 *pDim2 = new TDbDimension2;
					pDim1->SetLayoutRotation(Ucs2Wcs(0)); // add by whl on 070306
					pDim2->SetLayoutRotation(Ucs2Wcs(0)); // add by whl on 070306
					
					pDim1->SetStyleId(idDimStyle);
					pDim2->SetStyleId(idDimStyle);

					// Zyu modify on 100618，根据“尺寸标注对侧”选项设置尺寸的位置
					int iMarkSide = pDlg->m_bOtherSide? !nSide : nSide;
					// if(pAxisDim->GetDimension(nSide, *pDim1, *pDim2)) 
					if (pAxisDim->GetDimension(iMarkSide, *pDim1, *pDim2)) 
					{
						// Modify on 2002/2/22 by ZJQ, 解决弧线标注的半径未能设置在相关的轴线的半径
						if (bRadian) 
						{
							// Zyu modify on 100618
							// 弧线轴网的开间标注
							// pDim1->SetObjRadius(nSide ? nRadMax : nRadMin);
							// pDim2->SetObjRadius(nSide ? nRadMax : nRadMin);
							pDim1->SetObjRadius(iMarkSide ? nRadMax : nRadMin);
							pDim2->SetObjRadius(iMarkSide ? nRadMax : nRadMin);
						}
						// End

						pDim1->setLayer(idDimLay);
						pDim2->setLayer(idDimLay);
						lstNewDim<<pDim1<<pDim2;
					} 
					else 
					{
						delete pDim1;
						delete pDim2;
					}
				}
			} 
		}

		if (pAxisDim->IsValid()) 
		{
			pAxisDim->SetTextLayerId(idTextLay);
			pAxisDim->SetLayoutRotation(Ucs2Wcs(0.0));//modified by whl
			pAxisDim->AddToMSpace(Adesk::kFalse);
			if (!!idPrevLink)
			{
				pAxisDim->SetPrevLink(idPrevLink);
			}
			pAxisDim->close();
		} 
		else if (pAxisDim != NULL)
		{
			delete pAxisDim;
		}

		//尺寸最后画
		for (lstNewDim.MoveToFirst();!lstNewDim.IsOut();lstNewDim.MoveToNext())
		{
			AddToModelSpace(lstNewDim.GetCurData(),Adesk::kTrue);
		}
		ssAxis.Redraw(4);
	}

	if (pDlg != NULL)
	{
		pDlg->DestroyWindow();
		delete pDlg;
		pDlg = NULL;
	}
}

// curve--第一根轴线
// cvSortBase--用来排序的正交线
// ssAxis--待标注的轴线
// ptPick--点取位置
// bRadian--是否为角度标注
void DimAxisLabel(const XCurveSegment &curve, XCurveSegment &cvSortBase, 
				  PickSet &ssAxis, XPoint ptPick, BOOL bRadian)
{
	TCHAR szLabStart[80]=_T("1");
	double nAxisDirection=0.0;
	if (curve.Is(CURVE_CIRCLE))
	{
		XLine lnBase=cvSortBase.GetLine();
		lnBase.SetLineFlag(LS_FINITE);
		XPoint ptInt;
		if (!curve.Intersection(lnBase, ptInt, XPoint()))
		{
			return;
		}
		nAxisDirection=ads_angle(curve.GetCircle().GetCenterPt(), ptInt)+PI/2.0;
	}
	else
	{
		nAxisDirection= curve.IDirection(0);
	}

	if (nAxisDirection<PI/4 || nAxisDirection>1.75*PI ||
		(nAxisDirection>0.75*PI && nAxisDirection<1.25*PI))
	{
		_tcscpy(szLabStart, _T("A"));
	}

	// 建立排序的轴网单侧
	XAxisDimSet dimSet(&cvSortBase);
	long ssLen=ssAxis.Length();
	for (long i=0; i<ssLen; i++)
	{
		Entity ent=ssAxis[i];
		dimSet.Append(new XCurveSegment(ent));
	}
	dimSet.QuickSort(XAxisDimSet::SortFunc);

	if (!(*dimSet.Head() == curve))
	{
		if (cvSortBase.Is(CURVE_CIRCLE))
		{
			adsout << _T("\n发现不能正确分析的轴网!");
			return;
		}

		if (*dimSet.Tail() == curve)
		{
			dimSet.Reverse();
			XAxisDimSet::g_AntiClockWise=FALSE;  
		}
		else
		{
			adsout << _T("\n所选择的不是起始轴线!");
			return;
		}
	}

	AcDbObjectId idDimStyle=InitDimStyle(bRadian? DS_ANGLE : DS_LINEAR);
	TDbAxisLabelSet *pAxisDim=new TDbAxisLabelSet;
	pAxisDim->SetTextStyleId(InitTextStyle(TS_AXIS));
	pAxisDim->ConvertFrom(dimSet);
	double nOldLen=pAxisDim->GetLeaderLen(0, TRUE);
	if (pAxisDim->IsArcAxisNet() && pAxisDim->IsArcAxis())
	{ 
		pAxisDim->SetLeaderLen(0, nOldLen+10.0, TRUE); //圆弧轴网的进深标注, 引线需要加长
		pAxisDim->SetLeaderLen(1, nOldLen+10.0, TRUE); //圆弧轴网的进深标注, 引线需要加长
	}

	int nLabelFlag=0, nDimFlag=0;
	AcDbObjectId idPrevLink;
	if (curve.Is(CURVE_CIRCLE))
	{
		XString szBackup;
		szBackup=szLabStart;
		adsout << _T("\n请输入起始轴号(.空号)<") << szLabStart << _T(">: ");
		if (ads_getstring(0, _T(""), szLabStart) == RTNORM)
		{
			if (_tcscmp(szLabStart, _T(".")) == 0)
			{
				_tcscpy(szLabStart, _T(""));
			}
			else if (!szLabStart[0])
			{
				_tcscpy(szLabStart, szBackup);
			}
		}
		else
		{
			return;
		}		
	}
	else
	{
		CDimAxisLabelDlg dlg(acedGetAcadFrame());
		dlg.m_bPrevLink=FALSE;
		dlg.m_csLabel=szLabStart;
		if (bRadian)
		{
			int nSide=pAxisDim->OnWhichSide(ptPick);
			dlg.m_dimFlag=nSide? 1 : 0;
			dlg.m_labelFlag=nSide? 0 : 1;
		}
		else
		{
			//modified by whl
			//dlg.m_dimFlag=0;
			//dlg.m_labelFlag=0;
			dlg.m_dimFlag=2;
			dlg.m_labelFlag=2;
		}

		{
			CTemporaryResourceOverride vTemp;
			if (dlg.DoModal()!=IDOK)
			{
				delete pAxisDim;
				return;
			}
		}

		if (dlg.m_bPrevLink)
		{
			Entity entPrev;
			ads_sssetfirst(NULL, NULL);
			if (entPrev.FilterSelect(_T("\n点取前接轴号<退出>:"), RBList(RTDXF0, _T("ATS_AXIS_LABEL"),NULL))!=RTNORM) 
			{
				return;
			}
			acdbGetObjectId(idPrevLink, entPrev);
		}
		else 
		{
			_tcscpy(szLabStart, dlg.m_csLabel);
		}
		nLabelFlag=dlg.m_labelFlag;
		nDimFlag=dlg.m_dimFlag;
	}

	if (!idPrevLink)
	{
		pAxisDim->SortAxisLabel(szLabStart);
	}

	AcDbObjectId idDimLay=InitLayer(LAY_DIMAX, TRUE);
	AcDbObjectId idTextLay=InitLayer(LAY_AXIS_TEXT, TRUE);
	if (curve.Is(CURVE_CIRCLE))
	{
		pAxisDim->HideSide(1);
		TAxisLabelEdJig jig(pAxisDim);
		jig.SetPrompt(_T("\n请输入标注位置<退出>:"));
		if (jig.DoIt()!=RTNORM)
		{
			delete pAxisDim;

			return;
		}
		if (pAxisDim->GetAxisNum()>1)
		{
			TDbDimension2 *pDim1=new TDbDimension2;
			TDbDimension2 *pDim2=new TDbDimension2;
			pDim1->SetLayoutRotation(Ucs2Wcs(0));//add by whl on 070306
			pDim2->SetLayoutRotation(Ucs2Wcs(0));//add by whl on 070306
			pDim1->SetStyleId(idDimStyle);
			pDim2->SetStyleId(idDimStyle);
			if (pAxisDim->GetDimension(0, *pDim1, *pDim2))
			{
				pDim1->setLayer(idDimLay);
				pDim2->setLayer(idDimLay);
				AddToModelSpace(pDim1,Adesk::kTrue);
				AddToModelSpace(pDim2,Adesk::kTrue);

			}
			else
			{
				delete pDim1;
				delete pDim2;
			}
		} 
	}
	else
	{
		int nSidePick=pAxisDim->OnWhichSide(ptPick);
		if (nLabelFlag!=2)
		{
			if (nLabelFlag == 0)
			{
				pAxisDim->HideSide(1-nSidePick);
			}
			else
			{
				pAxisDim->HideSide(nSidePick);
			}
		}

		//Modify on 2002/2/22 by ZJQ, 解决弧线标注的半径未能设置在相关的轴线的半径
		// 增加扇形的标注半径
		XAxisPickSet ssOpp(SS_FREE);
		double nRadMin=0.0, nRadMax=0.0;
		if (bRadian)
		{
			nRadMin=nRadMax=cvSortBase.GetArc().GetRadius();
			ssOpp.GetFromOppsite(curve, FILT_CIRARC_ONLY);
			long lNum=ssOpp.Length();
			for (long idx=0L; idx<lNum; idx++)
			{
				Entity ent=ssOpp[idx];
				XCurveSegment segTemp(ent);
				if (segTemp.Is(CURVE_ARC))
				{
					if (idx == 0)
					{
						nRadMin=nRadMax=segTemp.GetArc().GetRadius();
					}
					else
					{
						nRadMax=max(nRadMax, segTemp.GetArc().GetRadius());
						nRadMin=min(nRadMin, segTemp.GetArc().GetRadius());
					}
				}
				else if (segTemp.Is(CURVE_CIRCLE))
				{
					if (idx == 0)
					{
						nRadMin=nRadMax=segTemp.GetCircle().GetRadius();
					}
					else
					{
						nRadMax=max(nRadMax, segTemp.GetCircle().GetRadius());
						nRadMin=min(nRadMin, segTemp.GetCircle().GetRadius());
					}
				}
			}
		}
		// End

		if (pAxisDim->GetAxisNum()>1)
		{
			for (int nSide=0; nSide<2; nSide++)
			{
				if (nDimFlag == 0 && nSide!=nSidePick)
				{
					continue;
				}
				else if (nDimFlag == 1 && nSide == nSidePick)
				{
					continue;
				}
				TDbDimension2 *pDim1=new TDbDimension2;
				TDbDimension2 *pDim2=new TDbDimension2;
				pDim1->SetLayoutRotation(Ucs2Wcs(0));//add by whl on 070306
				pDim2->SetLayoutRotation(Ucs2Wcs(0));//add by whl on 070306
				pDim1->SetStyleId(idDimStyle);
				pDim2->SetStyleId(idDimStyle);
				if (pAxisDim->GetDimension(nSide, *pDim1, *pDim2))
				{
					// Modify on 2002/2/22 by ZJQ, 解决弧线标注的半径未能设置在相关的轴线的半径
					if (bRadian)
					{
						//弧线轴网的开间标注
						pDim1->SetObjRadius(nSide? nRadMax : nRadMin);
						pDim2->SetObjRadius(nSide? nRadMax : nRadMin);
					} // End

					pDim1->setLayer(idDimLay);
					pDim2->setLayer(idDimLay);
					AddToModelSpace(pDim1,Adesk::kTrue);
					AddToModelSpace(pDim2,Adesk::kTrue);
				} 
				else 
				{
					delete pDim1;
					delete pDim2;
				}
			}
		}
	}
	if (pAxisDim->IsValid())
	{
		pAxisDim->SetTextLayerId(idTextLay);
		pAxisDim->SetLayoutRotation(Ucs2Wcs(0.0));//modified by whl
		pAxisDim->AddToMSpace(Adesk::kFalse);
		if (!!idPrevLink)
		{
			pAxisDim->SetPrevLink(idPrevLink);
		}
		pAxisDim->close();
	}
	else
	{
		delete pAxisDim;
	}
}

void DimAxisBy2Curve0()
{
    XAxisDimSet::g_AntiClockWise=TRUE;
	InitLayer(LAY_DIMAX, TRUE);
	
	XAxisDimSet::g_AntiClockWise = 1; //默认逆时针方向
	Entity entFirst, entFinal;
	XPoint ptPick1, ptPick2;
	
	RBList mask(RTDXF0, _T("LINE,ARC,CIRCLE"), 8, LAY_AXIS, NULL);
	if (SelectEntity1(_T("\n请选择起始轴线<退出>:"), entFirst, ptPick1, mask)!=RTNORM)
	{
		return;
	}
	if (entFinal.FilterSelect1(GetPickBoxWcs()/2, _T("\n请选择终止轴线<退出>:"), mask, ptPick2)!=RTNORM)
	{
		return;
	}
	if (entFirst == entFinal)
	{
		return;
	}
	ptPick1=Ucs2Wcs(ptPick1);
	ptPick2=Ucs2Wcs(ptPick2);
	
	XCurveSegment curveFirst(entFirst);
	XCurveSegment curveFinal(entFinal);
	if (curveFirst.GetCurveType()!=curveFinal.GetCurveType())
	{
		return;
	}
	
	BOOL bRadian=FALSE, bCirAngular=FALSE;
	XPoint ptAxisNetCen;
	if (curveFirst.Is(CURVE_LINE)
		&& (!CT_IsSameDrt(curveFirst.IDirection(0),  curveFinal.IDirection(0), _angSnap)
			|| (curveFirst.StartPoint()&curveFinal)!=PR_OUTSIDE))
	{
		PickSet ssTemp(SS_FREE);
		
			TADSGePoint3d pt1(Wcs2Ucs(curveFirst.StartPoint())),
				pt2(Wcs2Ucs(curveFirst.EndPoint()));

		RBList rbFence=ads_buildlist(RT3DPOINT, &pt1, 
									 RT3DPOINT, &pt2, NULL);
		bCirAngular=(ssTemp.Get(_T("F"), rbFence, NULL, 
					 RBList(RTDXF0, _T("CIRCLE"), 8, LAY_AXIS, NULL)) == RTNORM);
		bRadian=TRUE;
		if ((curveFirst.StartPoint()&curveFinal)!=PR_OUTSIDE)
		{
            ptAxisNetCen = curveFirst.StartPoint() + curveFirst.EndPoint()
			               + curveFinal.StartPoint() + curveFinal.EndPoint();
            ptAxisNetCen /= 4.0;
		}
		else
		{
			XLine ln1=curveFirst.GetLine();
			XLine ln2=curveFinal.GetLine();
			ln1.SetLineFlag(LS_INFINITE);
			ln2.SetLineFlag(LS_INFINITE);
			ln1.Intersection(&ln2, ptAxisNetCen);
		}
		int nAnswer=YesNoQuestion(_T("\n是否为按逆时针方向排序编号"));
		if (nAnswer == RTCAN) 
		{
			return;
		}
		if (nAnswer == Q_NO)
		{
			XAxisDimSet::g_AntiClockWise=FALSE;
		}
		else
		{
			XAxisDimSet::g_AntiClockWise=TRUE;
		}
	}
	XAxisPickSet ssAxis(SS_FREE); 
	if (bRadian && !XAxisDimSet::g_AntiClockWise)
	{
		ssAxis.GetFrom2Curve(curveFinal, curveFirst);  
	}
	else
	{
		ssAxis.GetFrom2Curve(curveFirst, curveFinal);
	}
	
	if (!ssAxis)
	{
		adsout << _T("\n不能找到轴网!");
		return ;
	}
	
	ssAxis.Redraw(3);
	
    XPoint ptAxisEnd=curveFirst.NearPoint(ptPick1);
    XCurveSegment cvSortBase; //排序的基线
	
    if (!bRadian)
	{
        if (curveFirst.Is(CURVE_CIRCLE))
		{
            Entity entBase;
            if (entBase.FilterSelect(_T("\n请选择圆形轴网的横(径)线:"), RBList(RTDXF0, _T("LINE"), 8, LAY_AXIS, NULL)) != RTNORM)
			{
                ssAxis.Redraw(4);

                return;
            }
            cvSortBase = XCurveSegment(entBase);
        }
		else
		{
            double nDist2Me=curveFirst.GetDist2Me(curveFinal.StartPoint());
            cvSortBase.StartPoint()=curveFirst.StartPoint();
            ads_polar(curveFirst.StartPoint(), curveFirst.IDirection(0)-PI/2.0, nDist2Me, cvSortBase.EndPoint());
            cvSortBase.SetBulge(0.0);
            //cvSortBase.Make();
        }
    }
	else if (bCirAngular)
	{ 
		//圆形轴网角度标注
        cvSortBase=XCircle(ptAxisNetCen, ptAxisNetCen.Distance2d(curveFirst.FarPoint(ptAxisNetCen)));
    }
	else
	{
        double nAng1=ads_angle(ptAxisNetCen, curveFirst.FarPoint(ptAxisNetCen));
        double nAng2=ads_angle(ptAxisNetCen, curveFinal.FarPoint(ptAxisNetCen));
        if (XAxisDimSet::g_AntiClockWise == FALSE)
		{
            Exchange(nAng1, nAng2);
		}
        cvSortBase = XArc(ptAxisNetCen, ptAxisNetCen.Distance2d(curveFirst.FarPoint(ptAxisNetCen)),
						  nAng1, nAng2);
    }
	
	// Add on 2002/6/14, 解决圆形轴网起始轴角度不是最小时无法标注的问题
	double nVal=XAxisDimSet::g_nAngleBegin;
	if (cvSortBase.Is(CURVE_CIRCLE))
	{
		nVal=ads_angle(ptAxisNetCen, curveFirst.FarPoint(ptAxisNetCen));
	}
	XPushMemVar<double> vTemp1(XAxisDimSet::g_nAngleBegin, nVal);
	
    DimAxisLabel(curveFirst, cvSortBase, ssAxis, ptPick1, bRadian);
    ssAxis.Redraw(4);
}

void AutoLabelAxisArg(BOOL bRadian)
{
    XAxisDimSet::g_AntiClockWise=TRUE;
	InitLayer(LAY_DIMAX, TRUE);
	
	XAxisDimSet::g_AntiClockWise = 1; //默认逆时针方向
	Entity entFirst;
	XPoint ptPick;
	
	const TCHAR *pszDxf=bRadian? _T("LINE") : _T("LINE,ARC,CIRCLE");
	RBList mask(RTDXF0, pszDxf, 8, LAY_AXIS, NULL);
	if (SelectEntity((bRadian?
					_T("\n请选择起始轴线(弧线轴网的径线)<退出>:")
					: _T("\n请选择起始轴线(直线轴网的轴线或弧线轴网的弧线)<退出>"))
					, entFirst, ptPick, mask)!=RTNORM)
	{
		return ;
	}
	ptPick=Ucs2Wcs(ptPick);
	
	XCurveSegment curve(entFirst);
	int nFiltFlag=0;
	if (bRadian)
	{
		nFiltFlag |= FILT_RADIATE_LINE;
	}
	else if (curve.Is(CURVE_LINE))
	{
		nFiltFlag |= FILT_LINE_ONLY;
	}
	else
	{
		nFiltFlag |= FILT_CIRARC_ONLY;
	}
	XAxisPickSet ssAxis(entFirst, nFiltFlag);
	if (!ssAxis)
	{
		adsout << _T("\n不能找到轴网!");
		return ;
	}
		
	//另外正交方向的一组轴线
	XAxisPickSet &ssOppsite = *ssAxis.GetOppsite();
	if (!ssOppsite)
	{
		adsout << _T("\n不能找到轴网!");
		
		return ;
	}
	
	XPoint ptAxisEnd=curve.NearPoint(ptPick);
	XCurveSegment cvSortBase; //排序的基线
	XPoint ptAxisNetCen;
	
    Entity entSortBase;
    if (!GetClosestAxis(ssOppsite, curve.Is(CURVE_CIRCLE)? ptPick : ptAxisEnd, entSortBase))
	{
        adsout << _T("\n找不到最近的另一侧轴线!");

		return ;
    }
	
    cvSortBase = XCurveSegment(entSortBase); 
    if (!cvSortBase)
	{
        adsout << _T("\n不能取得排序轴线!");

		return ;
    }
	
	
	if (ssAxis.IsArcAxis() && curve.Is(CURVE_LINE))
	{
		//弧形轴网开间
		if (cvSortBase.Is(CURVE_ARC))
		{
			ptAxisNetCen=cvSortBase.GetArc().GetCenterPt();
		} 
		else if (cvSortBase.Is(CURVE_CIRCLE))
		{
			//标注圆形轴网的开间
			ptAxisNetCen=cvSortBase.GetCircle().GetCenterPt();
			XAxisDimSet::g_nAngleBegin=ads_angle(ptAxisNetCen, curve.FarPoint(ptAxisNetCen));
			int nAnswer=YesNoQuestion(_T("\n是否为按逆时针方向排序编号"));
			if (nAnswer == RTCAN) 
			{
				return;
			}
			if (nAnswer == Q_NO)
			{
				XAxisDimSet::g_AntiClockWise=FALSE;
			}
		}
	} 
	
	if (!curve.Is(CURVE_CIRCLE))
	{
		// 把cvSortBase偏移到 ptAxisEnd
		int nOffSide=cvSortBase.OnWhichSide(ptAxisEnd);
		XPoint ptPrjToSortBase;
		//不是标注弧形轴网的进深
		if (curve.Is(CURVE_LINE)	&& cvSortBase.ProjectToMe(ptAxisEnd, ptPrjToSortBase) == RTNORM) 
		{
			cvSortBase = cvSortBase.Offset(nOffSide, ptAxisEnd.Distance(ptPrjToSortBase), LS_FINITE);
		}
	}
	
	ssAxis.Redraw(3);
	DimAxisLabel(curve, cvSortBase, ssAxis, ptPick, bRadian);
	ssAxis.Redraw(4);
}


/////////////////////////////////////////////
// 命令：轴网标注(矩形轴网和圆弧轴网的弧线)
void AutoLabelAxis()
{
    AutoLabelAxisArg(FALSE);
}



/////////////////////////////////////////////
// 命令：角注轴网(圆弧轴网的径线)
void AutoLabelAxisAngle()
{
    AutoLabelAxisArg(TRUE);
}

static XPoint g_ptRef;
static int CompareDimDist(const Entity *p1, const Entity *p2)
{
	double nDist1=0.0, nDist2=0.0;
	Entity en1=*p1;
	OPENOBJ_BEGIN(en1, AcDb::kForRead, TDbDimension2, pDim1);
	if (pDim1)
	{
		XCurveSegment cvDim=pDim1->GetDimCurve();
		cvDim.SetLineFlag(LS_INFINITE);
		XPoint ptPrj;
		cvDim.ProjectToMe(g_ptRef, ptPrj);
		nDist1=ptPrj.Distance2d(g_ptRef);
	}
	OPENOBJ_END();
	Entity en2=*p2;
	OPENOBJ_BEGIN(en2, AcDb::kForRead, TDbDimension2, pDim2);
	if (pDim2)
	{
		XCurveSegment cvDim=pDim2->GetDimCurve();
		cvDim.SetLineFlag(LS_INFINITE);
		XPoint ptPrj;
		cvDim.ProjectToMe(g_ptRef, ptPrj);
		nDist2=ptPrj.Distance2d(g_ptRef);
	}
	OPENOBJ_END();
	if (nDist1<nDist2)
	{
		return -1;
	}
	
	return 1;
}

//////////////////////////////////
// bRadian: 0--直线轴号; 1--角度轴号
void InsAxisArg(BOOL bRadian)
{
	Entity entRefAxis;
	RBList mask(RTDXF0, _T("LINE,ARC,CIRCLE"), 8, LAY_AXIS, NULL);
	XPoint ptPick;
	if (SelectEntity((bRadian ? _T("\n选择参考轴线(弧线轴网的径线)<退出>:") 
					: _T("\n选择参考轴线(直线轴网的轴线或弧线轴网的弧线)<退出>:"))
					, entRefAxis, ptPick, mask) != RTNORM)
	{
		return;
	}

	ptPick=Ucs2Wcs(ptPick);
	int nAnswer=YesNoQuestion(_T("\n新增轴线是否为附加轴线"), Q_NO);
	if (nAnswer == RTCAN)
	{
		return ;
	}
	
	XCurveSegment cv(entRefAxis);
	XCurveSegment curve=cv;
	
	int nFiltFlag=0;
	if (bRadian)
	{
		nFiltFlag |= FILT_RADIATE_LINE;
	}
	else if (curve.Is(CURVE_LINE))
	{
		nFiltFlag |= FILT_LINE_ONLY;
	}
	else
	{
		nFiltFlag |= FILT_CIRARC_ONLY;
	}
	
	XAxisPickSet ssAxis(entRefAxis, nFiltFlag);
	if (!ssAxis)
	{
		adsout << _T("\n请正确选择!");

		return;
	}
	VERIFY(curve.ProjectToMe(XPoint(ptPick), ptPick) == RTNORM);
	XPoint ptAxisEnd=curve.NearPoint(ptPick);
	
	// 取得标志
	XAxisPickSet &ssOpp = *ssAxis.GetOppsite();
	
	// 矩形轴网或没有信息的轴线
	if (!ssAxis.IsArcAxis())
	{ 
		XPoint ptBase;
		cv.ProjectToMe(ptPick, ptBase);
		XPoint ptSide;
		ads_real nOffset;
		if (ads_getpoint(Wcs2Ucs(ptPick), _T("\n偏移方向<退出>: "), ptSide)!=RTNORM)
		{
			return;
		}
		ptSide=Ucs2Wcs(ptSide);
		ads_initget(RSG_NONEG|RSG_NOZERO, NULL);
		if (ads_getdist(Wcs2Ucs(ptPick), _T("\n距参考轴线的距离<退出>: "), &nOffset)!=RTNORM)
		{
			return;
		}
		int nSide=cv.OnWhichSide(ptSide);
		XCurveSegment cvNew = cv.Offset(nSide, nOffset, LS_FINITE);
		if (!cvNew)
		{
			return;
		}
		else
		{
			cvNew.MakeEntity(entRefAxis);
		}
	}
	else
	{
		if (cv.Is(CURVE_LINE))
		{
			XPoint ptRotBase; //弧网圆心
			if (!ssOpp) ptRotBase=cv.StartPoint();
			else
			{
				Entity entOneAxis=ssOpp[0L];
				assert(!entOneAxis.Is(_T("LINE")));
				XCircle cirOrArc(entOneAxis);
				ptRotBase = cirOrArc.GetCenterPt();
			}
			if (cv.GetLine().MakeEntity(&entRefAxis) == RTNORM)
			{
				Entity entNew;
				entNew.GetLast();
				XPoint ptPick0;
				cv.ProjectToMe(ptPick, ptPick0);
				if (DragRotation(entNew, _T("\n输入转角<退出>:"), Wcs2Ucs(ptRotBase), Wcs2Ucs(ptPick0))!=RTNORM)
				{
					entNew.Delete();
					return ;
				}
			}
		}
		else 
		{
			if (cv.MakeEntity(entRefAxis) == RTNORM)
			{
				Entity entNew;
				entNew.GetLast();
				if (DragRadius(entNew, _T("\n输入半径<退出>:"), Wcs2Ucs(ptPick))!=RTNORM)
				{
					entNew.Delete();
					return ;
				}
			}
		}
	}
	
    //修改标记
	Entity entNewAxis;
	entNewAxis.GetLast();
	
	XCurveSegment segNew(entNewAxis);
	PickSet ssLabelSet(SS_FREE);
	PickSet ssOnStart(SS_FREE);
	double nOffset=GetPickBoxWcs();
	XPoint ptOffset(nOffset, nOffset);
	XPoint pt1=cv.StartPoint()+ptOffset;
	XPoint pt2=cv.StartPoint() - ptOffset;
	if (ssOnStart.Get(_T("C"), pt1,  pt2, RBList(RTDXF0, _T("ATS_AXIS_LABEL"), NULL)) == RTNORM)
	{
		if (ssOnStart.Length() == 1)
		{
			Entity entLabelSet=ssOnStart[0L];
			ssLabelSet += entLabelSet;
		}
	} 
	
	pt1=cv.EndPoint()+ptOffset;
	pt2=cv.EndPoint() - ptOffset;
	if (ssOnStart.Get(_T("C"), pt1,  pt2, RBList(RTDXF0, _T("ATS_AXIS_LABEL"), NULL)) == RTNORM)
	{
		if (ssOnStart.Length() == 1)
		{
			Entity entLabelSet=ssOnStart[0L];
			ssLabelSet += entLabelSet;
		}
	}
	
	if (!ssLabelSet)
	{
		return;
	}
	PickSet ssDim1(SS_FREE), ssDim2(SS_FREE);
	RBList rbDimMask(RTDXF0, _T("ATS_DIMENSION2"), NULL);
	long num=ssLabelSet.Length();
	double nPrec=GetPickBoxWcs();
	BOOL bGetDim1=FALSE, bGetDim2=FALSE;
	for (long i=0; i<num; i++)
	{
		Entity entLabelSet=ssLabelSet[i];
		AcDbVoidPtrArray entSet;
		XExplodeStream dc(entSet);
		OPENOBJ_BEGIN(entLabelSet, AcDb::kForWrite, TDbAxisLabelSet, pSet);
		pSet->ExplodeOrDraw2d(dc);
		pSet->AddAxis(segNew, nAnswer == Q_YES, NULL);
		OPENOBJ_END();
		int nCount=entSet.length();
		for (int n=0; n<nCount; n++)
		{
			AcDbEntity *pEnt=(AcDbEntity *)entSet[n];
			if (pEnt->isA() == AcDbLine::desc())
			{
				XPoint pt1, pt2;
				AcDbLine *pLine=AcDbLine::cast(pEnt);
				pLine->getStartPoint(pt1);
				pLine->getEndPoint(pt2);
				if (pt1.Distance2d(cv.StartPoint())<nPrec || pt2.Distance2d(cv.StartPoint())<nPrec)
				{
					AssureOnScreen(pt1, pt2);
					bGetDim1=TRUE;
					RBList rbFence=ads_buildlist(RT3DPOINT, &pt1, RT3DPOINT, &pt2, NULL);
					ssDim1.Get(_T("F"), rbFence, NULL, rbDimMask);
				} 
				else if (pt1.Distance2d(cv.EndPoint())<nPrec || pt2.Distance2d(cv.EndPoint())<nPrec)
				{
					AssureOnScreen(pt1, pt2);
					bGetDim2=TRUE;
					RBList rbFence=ads_buildlist(RT3DPOINT, &pt1, RT3DPOINT, &pt2, NULL);
					ssDim2.Get(_T("F"), rbFence, NULL, rbDimMask);
				}
			}
		}
		ReleaseEntSet(entSet);
	}
	if (bGetDim1 && !!ssDim1)
	{
		DList<Entity> lstDim1;
		long lDim1=ssDim1.Length();
		for (long idx=0L; idx<lDim1; idx++)
		{
			Entity *pEnt=new Entity;
			*pEnt=ssDim1[idx];
			lstDim1.Append(pEnt);
		}
		g_ptRef=cv.StartPoint();
		lstDim1.QuickSort(CompareDimDist);
		if (lDim1 == 2)
		{
			Entity entDim=*lstDim1[0];
			OPENOBJ_BEGIN(entDim, AcDb::kForWrite, TDbDimension2, pDim1);
			if (pDim1)
			{
				pDim1->AddSegment(segNew.StartPoint());
			}
			OPENOBJ_END();
		}
		else if (lDim1>2)
		{
			for (int j=0; j<2; j++)
			{
				Entity entDim=*lstDim1[j];
				OPENOBJ_BEGIN(entDim, AcDb::kForWrite, TDbDimension2, pDim1);
				if (pDim1)
				{
					pDim1->AddSegment(segNew.StartPoint());
				}
				OPENOBJ_END();
			}
		}
	}
	if (bGetDim2 && !!ssDim2)
	{
		DList<Entity> lstDim2;
		long lDim2=ssDim2.Length();
		for (long idx=0L; idx<lDim2; idx++)
		{
			Entity *pEnt=new Entity;
			*pEnt=ssDim2[idx];
			lstDim2.Append(pEnt);
		}
		g_ptRef=cv.EndPoint();
		lstDim2.QuickSort(CompareDimDist);
		if (lDim2 == 2)
		{
			Entity entDim=*lstDim2[0];
			OPENOBJ_BEGIN(entDim, AcDb::kForWrite, TDbDimension2, pDim2);
			if (pDim2)
			{
				pDim2->AddSegment(segNew.EndPoint());
			}
			OPENOBJ_END();
		}
		else if (lDim2>2)
		{
			for (int j=0; j<2; j++)
			{
				Entity entDim=*lstDim2[j];
				OPENOBJ_BEGIN(entDim, AcDb::kForWrite, TDbDimension2, pDim2);
				if (pDim2)
				{
					pDim2->AddSegment(segNew.EndPoint());
				}
				OPENOBJ_END();
			}
		}
	}
}



/////////////////////////////////////////////
// 命令：添加轴线
void InsAxis()
{

	Entity entRefAxis;
	RBList mask(RTDXF0, _T("LINE,ARC,CIRCLE"), 8, LAY_AXIS, NULL);
	XPoint ptPick;
	if (SelectEntity(_T("\n选择参考轴线 <退出>:") ,entRefAxis, ptPick, mask)!=RTNORM)
	{
		return;
	}

	int old(0);
	TGGetVar(_T("ORTHOMODE"), &old);

do //	add by gjm 2014/05/12
{
	ptPick=Ucs2Wcs(ptPick);
	XCurveSegment cv(entRefAxis);
	XCurveSegment curve=cv;
	
	XAxisPickSet *pAxisSS=NULL;
	DList<XAxisPickSet> lstAxisSS;//用于自动delete
	if (curve.Is(CURVE_LINE))
	{
		TGSetVar(_T("ORTHOMODE"), 1);
		pAxisSS=new XAxisPickSet(entRefAxis,FILT_RADIATE_LINE);
		lstAxisSS.Append(pAxisSS);
		if (!(*pAxisSS)) 
		{
			pAxisSS=new XAxisPickSet(entRefAxis,FILT_LINE_ONLY);
			lstAxisSS.Append(pAxisSS);
			if (!(*pAxisSS))
			{
				adsout << _T("\n请正确选择!");
				break;
			}
		}
	}
	else //弧线
	{
		pAxisSS = new XAxisPickSet(entRefAxis,FILT_CIRARC_ONLY);
		lstAxisSS.Append(pAxisSS);
		if (!(*pAxisSS))
		{
			adsout << _T("\n请正确选择!");
			break;
		}
	}
	
	XAxisPickSet &ssAxis=*pAxisSS;
	
	int nAnswer=YesNoQuestion(_T("\n新增轴线是否为附加轴线"), Q_NO);
	if (nAnswer == RTCAN)
	{
		break;
	}
	
	VERIFY(curve.ProjectToMe(XPoint(ptPick), ptPick) == RTNORM);
	XPoint ptAxisEnd=curve.NearPoint(ptPick);
	
	// 取得标志
	XAxisPickSet &ssOpp = *ssAxis.GetOppsite();
	
	//add by lgy 20120208	是否重排标注
	BOOL bAuto = TRUE;
	if (!ssAxis.IsArcAxis())
	{ // 矩形轴网或没有信息的轴线
		//XPoint ptBase;
		//cv.ProjectToMe(ptPick, ptBase);
		//add by lgy 20120208	是否重排标注根据用户输入
		int nAuto = YesNoQuestion(_T("\n是否重排轴号"), Q_YES);
		if (nAuto == RTCAN)
		{
			break;
		}
		bAuto = (nAuto == Q_YES);
		XPoint ptSide;
		ads_real nOffset;
		//modify by lgy 20120208	新的需求不需要偏移方向而是通过据参考轴线的距离而获得方向
		//if (ads_getpoint(Wcs2Ucs(ptPick), _T("\n偏移方向<退出>: "), ptSide)!=RTNORM)
		//{
		//	return;
		//}
		if (ads_getpoint(Wcs2Ucs(ptPick), _T("\n距参考轴线的距离<退出>: "), ptSide)!=RTNORM)
		{
			break;
		}
		ptSide=Ucs2Wcs(ptSide);
		ads_initget(RSG_NONEG|RSG_NOZERO, NULL);
		//modify by lgy 20120208	新的需求不需要偏移方向而是通过据参考轴线的距离而获得方向
		//if (ads_getdist(Wcs2Ucs(ptPick), _T("\n距参考轴线的距离<退出>: "), &nOffset)!=RTNORM)
		//{
		//	return;
		//}
		nOffset = cv.GetDist2Me(ptSide);
		nOffset = fabs(nOffset);

		int nSide=cv.OnWhichSide(ptSide);
		XCurveSegment cvNew = cv.Offset(nSide, nOffset, LS_FINITE);
		if (!cvNew)
		{
			break;
		}
		else
		{
			cvNew.MakeEntity(entRefAxis);
		}
	}
	else
	{
		// add by lgy 20120208，是否重排标注根据用户输入
		int nAuto = YesNoQuestion(_T("\n是否重排轴号"), Q_YES);
		if (nAuto == RTCAN)
		{
			break;
		}
		bAuto = (nAuto == Q_YES);

		if (cv.Is(CURVE_LINE))
		{
			XPoint ptRotBase; //弧网圆心
			if (!ssOpp)
				ptRotBase=cv.StartPoint();
			else
			{
				Entity entOneAxis=ssOpp[0L];
				assert(!entOneAxis.Is(_T("LINE")));
				XCircle cirOrArc(entOneAxis);
				ptRotBase = cirOrArc.GetCenterPt();
			}

			if (cv.GetLine().MakeEntity(&entRefAxis) == RTNORM)
			{
				Entity entNew;
				entNew.GetLast();
				XPoint ptPick0;
				cv.ProjectToMe(ptPick, ptPick0);
				if (DragRotation(entNew, _T("\n输入转角<退出>:"), Wcs2Ucs(ptRotBase), Wcs2Ucs(ptPick0))!=RTNORM)
				{
					entNew.Delete();
					break;
				}
			}
		}
		else
		{
			if (cv.MakeEntity(entRefAxis) == RTNORM)
			{
				Entity entNew;
				entNew.GetLast();
				if (DragRadius(entNew, _T("\n输入半径<退出>:"), Wcs2Ucs(ptPick))!=RTNORM)
				{
					entNew.Delete();
					break;
				}
			}
		}
	}
	
	// 修改标记
	Entity entNewAxis;
	entNewAxis.GetLast();
	
	XCurveSegment segNew(entNewAxis);
	PickSet ssLabelSet(SS_FREE);
	PickSet ssOnStart(SS_FREE);
	double nOffset=GetPickBoxWcs();
	XPoint ptOffset(nOffset, nOffset);
	XPoint pt1=cv.StartPoint()+ptOffset;
	XPoint pt2=cv.StartPoint() - ptOffset;
	if (ssOnStart.Get(_T("C"), pt1,  pt2, RBList(RTDXF0, _T("ATS_AXIS_LABEL"), NULL)) == RTNORM)
	{
		if (ssOnStart.Length() == 1)
		{
			Entity entLabelSet=ssOnStart[0L];
			ssLabelSet += entLabelSet;
		}
	} 
	
	pt1=cv.EndPoint()+ptOffset;
	pt2=cv.EndPoint() - ptOffset;
	if (ssOnStart.Get(_T("C"), pt1,  pt2, RBList(RTDXF0, _T("ATS_AXIS_LABEL"), NULL)) == RTNORM)
	{
		if (ssOnStart.Length() == 1)
		{
			Entity entLabelSet=ssOnStart[0L];
			ssLabelSet += entLabelSet;
		}
	}
	
	if (!ssLabelSet)
	{
		break;
	}
	PickSet ssDim1(SS_FREE), ssDim2(SS_FREE);
	RBList rbDimMask(RTDXF0, _T("ATS_DIMENSION2"), NULL);
	long num=ssLabelSet.Length();
	double nPrec=GetPickBoxWcs();
	BOOL bGetDim1=FALSE, bGetDim2=FALSE;
	for (long i=0; i<num; i++)
	{
		Entity entLabelSet=ssLabelSet[i];
		AcDbVoidPtrArray entSet;
		XExplodeStream dc(entSet);
		OPENOBJ_BEGIN(entLabelSet, AcDb::kForWrite, TDbAxisLabelSet, pSet);
		pSet->ExplodeOrDraw2d(dc);
		//modify by lgy 20120208	添加轴线时是否标注重排根据参数
		//pSet->AddAxis(segNew, nAnswer == Q_YES, NULL);
		pSet->AddAxis(segNew, nAnswer == Q_YES, NULL, bAuto);
		OPENOBJ_END();
		int nCount=entSet.length();
		for (int n=0; n<nCount; n++)
		{
			AcDbEntity *pEnt=(AcDbEntity *)entSet[n];
			if (pEnt->isA() == AcDbLine::desc())
			{
				XPoint pt1, pt2;
				AcDbLine *pLine=AcDbLine::cast(pEnt);
				pLine->getStartPoint(pt1);
				pLine->getEndPoint(pt2);
				if (pt1.Distance2d(cv.StartPoint())<nPrec || pt2.Distance2d(cv.StartPoint())<nPrec)
				{
					AssureOnScreen(pt1, pt2);
					bGetDim1=TRUE;
					RBList rbFence=ads_buildlist(RT3DPOINT, &pt1, RT3DPOINT, &pt2, NULL);
					ssDim1.Get(_T("F"), rbFence, NULL, rbDimMask);
				}
				else if (pt1.Distance2d(cv.EndPoint())<nPrec || pt2.Distance2d(cv.EndPoint())<nPrec)
				{
					AssureOnScreen(pt1, pt2);
					bGetDim2=TRUE;
					RBList rbFence=ads_buildlist(RT3DPOINT, &pt1, RT3DPOINT, &pt2, NULL);
					ssDim2.Get(_T("F"), rbFence, NULL, rbDimMask);
				}
			}
		}
		ReleaseEntSet(entSet);
	}
	if (bGetDim1 && !!ssDim1)
	{
		DList<Entity> lstDim1;
		long lDim1=ssDim1.Length();
		for (long idx=0L; idx<lDim1; idx++)
		{
			Entity *pEnt=new Entity;
			*pEnt=ssDim1[idx];
			lstDim1.Append(pEnt);
		}
		g_ptRef=cv.StartPoint();
		lstDim1.QuickSort(CompareDimDist);
		if (lDim1 == 2)
		{
			Entity entDim=*lstDim1[0];
			OPENOBJ_BEGIN(entDim, AcDb::kForWrite, TDbDimension2, pDim1);
			if (pDim1)
			{
				pDim1->AddSegment(segNew.StartPoint());
			}
			OPENOBJ_END();
		}
		else if (lDim1>2)
		{
			for (int j=0; j<2; j++)
			{
				Entity entDim=*lstDim1[j];
				OPENOBJ_BEGIN(entDim, AcDb::kForWrite, TDbDimension2, pDim1);
				if (pDim1)
				{
					pDim1->AddSegment(segNew.StartPoint());
				}
				OPENOBJ_END();
			}
		}
	}
	if (bGetDim2 && !!ssDim2)
	{
		DList<Entity> lstDim2;
		long lDim2=ssDim2.Length();
		for (long idx=0L; idx<lDim2; idx++)
		{
			Entity *pEnt=new Entity;
			*pEnt=ssDim2[idx];
			lstDim2.Append(pEnt);
		}
		g_ptRef=cv.EndPoint();
		lstDim2.QuickSort(CompareDimDist);
		if (lDim2 == 2)
		{
			Entity entDim=*lstDim2[0];
			OPENOBJ_BEGIN(entDim, AcDb::kForWrite, TDbDimension2, pDim2);
			if (pDim2)
			{
				pDim2->AddSegment(segNew.EndPoint());
			}
			OPENOBJ_END();
		} 
		else if (lDim2>2)
		{
			for (int j=0; j<2; j++)
			{
				Entity entDim=*lstDim2[j];
				OPENOBJ_BEGIN(entDim, AcDb::kForWrite, TDbDimension2, pDim2);
				if (pDim2)
				{
					pDim2->AddSegment(segNew.EndPoint());
				}
				OPENOBJ_END();
			}
		}
	}

} while (false);

	TGSetVar(_T("ORTHOMODE"), old);
}

void ExtendToBound(XLine *pLine,DList<XLine> &BoundLine)
{
	pLine->SetLineFlag(LS_INFINITE);//把线的长度改为无限
	ads_point pt;
	XPoint startPt,endPt;
	int interNum=0;
	for (int i=0;i<4;i++)
	{
		XLine bLine=*BoundLine[i];
		if (pLine->Intersection (&bLine,pt))//如果有交点
		{
			if (interNum == 0) 
			{
				startPt=pt;
				interNum=1;
			}
			else 
			{
				endPt=pt;
				interNum=2;
				break;
			}
		}
	}
	if (interNum == 2)//如果有两个交点
	{
		pLine->StartPoint() =startPt;
		pLine->EndPoint() =endPt;
	}
	else
	{
		ads_printf(_T("\n计算有误!"));
	}
	pLine->SetLineFlag(LS_FINITE);//变回有限长度;
}
//画轴网
void DrawAxisNet(DList<XLine> &lstLine,DList<XArc> &lstArc,DList<XCircle> &lstCircle)
{
	int len,i,len1,j;
	XLine *pLine=NULL;
	XWcsStream dc;
	dc.sLayer=LAY_AXIS;
	ads_real angle;
	//开始画矩形轴网
	len=lstLine.Length();
	for (i=0;i<len;i++)
	{
		pLine=lstLine[i];
		angle=pLine->Direction ();
		if (fabs(angle)<0.0001 || fabs(angle-PI)<0.0001 || fabs(angle-2*PI)<0.0001)//如果大致在水平方向,属于进深
		{
			dc<<*pLine;
		}
	}
	for (i=0;i<len;i++)
	{
		pLine=lstLine[i];
		angle=pLine->Direction ();
		if (fabs(angle-PI/2)<0.0001 || fabs(angle-3*PI/2)<0.0001)//如果大致在垂直方向,属于开间
		{
			dc<<*pLine;
		}
	}
	
	for (i=0;i<len;i++)
	{
		pLine=lstLine[i];
		angle=pLine->Direction ();
		if (fabs(angle)>=0.0001 && fabs(angle-PI/2)>=0.0001 && fabs(angle-PI)>=0.0001 
			&& fabs(angle-PI*3/2)>=0.0001 && fabs(angle-PI*2)>=0.0001)
		{
			dc<<*pLine;
		}
	}
	
	//画弧形轴网:必须考虑不同圆心有不同标注
	len=lstArc.Length();
	DList<XPoint> bakofcenter;
	for (i = 0; i < len; i++)//以下的处理是对于同一个圆心的圆弧轴网要求包含的弧度一致(整齐化)
	{
		XArc *pArc=NULL,*pArc1=NULL;
		XPoint center,center1;
		pArc=lstArc[i];
		pArc->Center(center);
		if (i == 0)//第一个:直接加入到使用过的圆心链表
		{
			bakofcenter.Append(new XPoint(center));
		}
		else//其余:检查是否已经使用过
		{
			BOOL isUsedCenter=FALSE;
			len1=bakofcenter.Length();
			for (j=0;j<len1;j++)
			{
				XPoint bak=*bakofcenter[j];
				if (bak == center)
				{
					isUsedCenter=TRUE;
					break;
				}
			}
			if (isUsedCenter)//如果已经使用过,看下一个;
			{
				continue;
			}
			else//否则把这个没有用过的圆心加入到链表中
			{
				bakofcenter.Append(new XPoint(center));
			}
		}	
		dc<<*pArc;
		for (j=i+1;j<len;j++)//此循环得到最大范围的起始终止角度
		{
			pArc1=lstArc[j];
			pArc1->Center(center1);
			if (center == center1)
			{
				dc<<*pArc1;
			}
		}
	}
	//画圆轴网:也必须考虑不同圆心有不同标注
	bakofcenter.Reset();
	len=lstCircle.Length();
	for (i=0;i<len;i++)//以下的处理是对于同一个圆心的圆弧轴网要求包含的弧度一致(整齐化)
	{
		XCircle *pCircle=NULL,*pCircle1=NULL;
		XPoint center,center1;
		pCircle=lstCircle[i];
		pCircle->Center(center);
		if (i == 0)//第一个:直接加入到使用过的圆心链表
		{
			bakofcenter.Append(new XPoint(center));
		}
		else//其余:检查是否已经使用过
		{
			BOOL isUsedCenter=FALSE;
			len1=bakofcenter.Length();
			for (j=0;j<len1;j++)
			{
				XPoint bak=*bakofcenter[j];
				if (bak == center)
				{
					isUsedCenter=TRUE;
					break;
				}
			}
			if (isUsedCenter)//如果已经使用过,看下一个;
			{
				continue;
			}
			else//否则把这个没有用过的圆心加入到链表中
			{
				bakofcenter.Append(new XPoint(center));
			}
		}
		
		dc<<*pCircle;
		for (j=i+1;j<len;j++)
		{
			pCircle1=lstCircle[i];
			dc<<*pCircle1;
		}
	}
}

//考虑弧线墙以及圆墙?以成员bulge为准,如果它为2PI那么是圆,起点终点是直径的端点
//如果是0,就是直线?如果为一个正数,是一段弧,该弧如何计算?
//如果存在一个微小的角度该如何处理?弧段不能拉通到边界上又该如何?
void GenerateAxisNet(PickSet &Set,DList<XLine> &BoundLine,ads_real precision,ads_real anglespace)
{
	long len,i,len1,j;
	Entity ent;
	XPoint Startpt,Endpt,pt;
	ads_real angle,angle1;
	DList<XLine> lstLine;
	DList<XArc>  lstArc;
	DList<XCircle> lstCircle;
	
	len=Set.Length ();
	for (i=0;i<len;i++)
	{
		ent=Set[i];
        OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbWall, pWall);
		if (!pWall || !pWall->IsValid())
		{
			continue;
		}
		
		//bulge=pWall->bulge ;
        if (pWall->Is(CURVE_LINE))
		{
			//直线
			XLine ln=pWall->GetLine();
			ln.SetElevation (0.0);
			ExtendToBound(&ln,BoundLine);	
			len1=lstLine.Length();
			angle=ln.Direction();
			BOOL canAdd=TRUE;
			for (j=0;j<len1;j++)
			{
				XLine *pLine1=lstLine[j];
				angle1=pLine1->Direction ();
				if (ln.Intersection (pLine1,pt) == 0)//如果没有交点,平行;考虑精度和拉通
				{
					//只比较两对距离因为延长到边界函数中已经调整了起始终止点.
					if (	ads_distance(ln.StartPoint() ,pLine1->StartPoint() )<precision &&
						ads_distance(ln.EndPoint() ,pLine1->EndPoint() )<precision)
					{
						canAdd=FALSE;//有可能平行,也有可能不平行也不相交所以判断两个端点的距离 
						break;
					}
				}
			}
			if (canAdd) //如果不重合,加入到链表;
			{
				lstLine.Append(new XLine(ln));
			}
        }
		else //如果是圆弧:仅仅拉通它.不再要求到达边界
		{
			XArc ar=pWall->GetArc ();
			TADSGePoint3d ptTemp = ar.GetCenterPt();
			ptTemp.z = 0.0;
			ar.SetCenterPt(ptTemp);
			XPoint center,center1;
			len1=lstArc.Length();
			ar.Center(center);
			BOOL canAdd=TRUE;
			for (j=0;j<len1;j++)
			{
				XArc *pArc1=lstArc[j];
				pArc1->Center(center1);
                if (center == center1)
				{// 如果是同一个圆心
					if (fabs(ar.GetRadius()-pArc1->GetRadius())<precision/2)//如果半径相差在精度的一半以内,认为两段弧需要合并
					{
						if (ar.GetStarAngle() <pArc1->GetStarAngle() )//把起始和终止角度进行合并
						{
							pArc1->SetStarAngle(ar.GetStarAngle());
						}
						if (ar.GetEndAngle() >pArc1->GetEndAngle() )
						{
							pArc1->SetEndAngle(ar.GetEndAngle());
						}
						canAdd=FALSE;
						break;
					}
				}
			}
			if (canAdd)	//如果不重合,加入到链表;
			{
				lstArc.Append(new XArc(ar));
			}
		}
		OPENOBJ_END();
    }
	len=lstArc.Length();
	DList<XPoint> bakofcenter;
	for (i=0;i<len;i++)	//以下的处理是对于同一个圆心的圆弧轴网要求包含的弧度一致(整齐化)
	{
		XArc	*pArc=NULL,*pArc1=NULL;
		XPoint center,center1;
		ads_real minStartAngle,maxEndAngle;
		pArc=lstArc[i];
		pArc->Center(center);
		if (i == 0)	//第一个:直接加入到使用过的圆心链表
		{
			bakofcenter.Append(new XPoint(center));
		}
		else	//其余:检查是否已经使用过
		{
			BOOL isUsedCenter=FALSE;
			len1=bakofcenter.Length();
			for (j=0;j<len1;j++)
			{
				XPoint bak=*bakofcenter[j];
				if (bak == center)
				{
					isUsedCenter=TRUE;
					break;
				}
			}
			if (isUsedCenter)//如果已经使用过,看下一个;
			{
				continue;
			}
			else//否则把这个没有用过的圆心加入到链表中
			{
				bakofcenter.Append(new XPoint(center));
			}
		}
		minStartAngle=pArc->GetStarAngle();
		maxEndAngle=pArc->GetEndAngle();
		if (minStartAngle>maxEndAngle)//如果起始角大于终止角,看是否是要建立起始角大于终止角的弧形轴网
		{
			if (MessageBox(NULL,_T("\n发现起始角大于终止角的弧段.要建立起始角大于终止角的弧形轴网吗?"),_T("请您确定"),MB_YESNO) == IDYES)
			{
				for (j=i+1;j<len;j++)//此循环得到最大范围的起始终止角度
				{
					pArc1=lstArc[j];
					pArc1->Center(center1);
					if (center == center1)
					{
						if (minStartAngle>pArc1->GetStarAngle())
						{
							minStartAngle=pArc1->GetStarAngle();
						}
						if (maxEndAngle<pArc1->GetEndAngle())
						{
							maxEndAngle=pArc1->GetEndAngle();
						}
					}
				}
				minStartAngle-=anglespace;//减少/增加规定的弧度.都可调
				maxEndAngle+=anglespace;//
				for (j=i;j<len;j++)//此循环把最大范围的起始终止角度赋给各个同圆心的弧墙
				{
					pArc1=lstArc[j];
					pArc1->Center(center1);
					if (center == center1)
					{
						if (pArc1->GetStarAngle()<pArc1->GetEndAngle())
						{
							ads_printf(_T("\n存在起始角(约为%d度)小于终止角(约%d度)的弧段,系统不能对其拉通和齐整,忽略之..."),(int)(pArc1->GetStarAngle()*180/PI),(int)(pArc1->GetEndAngle()*180/PI));
							pArc1->SetStarAngle(pArc1->GetStarAngle() - anglespace);
							pArc1->SetEndAngle(pArc1->GetEndAngle() + anglespace);
						}
						else
						{
							pArc1->SetStarAngle(minStartAngle);
							pArc1->SetEndAngle(maxEndAngle);
						}
					}
				}
				continue;
			}
		}
		//建立起始角小于终止角的弧形轴网
		for (j=i+1;j<len;j++)//此循环得到最大范围的起始终止角度
		{
			pArc1=lstArc[j];
			pArc1->Center(center1);
			if (center == center1)
			{
				if (minStartAngle>pArc1->GetStarAngle())
				{
					minStartAngle=pArc1->GetStarAngle();
				}
				if (maxEndAngle<pArc1->GetEndAngle())
				{
					maxEndAngle=pArc1->GetEndAngle();
				}
			}
		}
		minStartAngle-=anglespace;//减少/增加规定的弧度.都可调
		maxEndAngle+=anglespace;//
		for (j=i;j<len;j++)//此循环把最大范围的起始终止角度赋给各个同圆心的弧墙
		{
			pArc1=lstArc[j];
			pArc1->Center(center1);
			if (center == center1)
			{
				if (pArc1->GetStarAngle()>pArc1->GetEndAngle())
				{
					ads_printf(_T("\n存在起始角(约为%d度)大于终止角(约%d度)的弧段,系统不能对其拉通和齐整,忽略之..."),(int)(pArc1->GetStarAngle()*180/PI),(int)(pArc1->GetEndAngle()*180/PI));
					pArc1->SetStarAngle(pArc1->GetStarAngle() - anglespace);
					pArc1->SetEndAngle(pArc1->GetEndAngle() + anglespace);
				}
				else
				{
					pArc1->SetStarAngle(minStartAngle);
					pArc1->SetEndAngle(maxEndAngle);
				}
			}
		}
	}
	DrawAxisNet(lstLine,lstArc,lstCircle);
}

extern TARCH_IMPEXP double g_dBaseDist;

void GetConfig(ads_real &space,ads_real &precision,ads_real &anglespace)
{
	//modified by whl on 070202
	//space=2000;
	space=g_dBaseDist;

	precision=100;
	anglespace=0.1;
}



/////////////////////////////////////////////
// 命令：墙生轴网
void Wall2Axis()
{
    InitLayer(LAY_AXIS, TRUE);
	PickSet Set(SS_FREE), Set1(SS_FREE);
	ads_real x,y,space=0,precision=0,anglespace=0;
	XPoint cen,pt1,pt2,pt3,pt4;
	DList<XLine> BoundLine;//边界线的集合
	
	if (SelectEntities(_T("\n请选取要从中生成轴网的墙体:"), Set, 
						RBList(RTDXF0, _T("ATS_WALL,ATS_CURTAIN_WALL"), NULL))!=RTNORM) 
	{
        return;
	}
	//if (FilterWall(Set)==FALSE) 	return RTERROR;
	GetConfig(space,precision,anglespace);
	Set.GetExtend(cen,&x,&y);
	x=x/2+space;//加上一个边距
	y=y/2+space;//加上一个边距
	pt1[X]=cen[X]+x;
	pt1[Y]=cen[Y]+y;
	pt2[X]=cen[X]+x;
	pt2[Y]=cen[Y]-y;
	BoundLine.Append (new XLine(pt1,pt2,LS_FINITE));//有限的线长度以及边界
	pt3[X]=cen[X]-x;
	pt3[Y]=cen[Y]-y;
	BoundLine.Append (new XLine(pt2,pt3,LS_FINITE));
	pt4[X]=cen[X]-x;
	pt4[Y]=cen[Y]+y;
	BoundLine.Append (new XLine(pt3,pt4,LS_FINITE));
	BoundLine.Append (new XLine(pt4,pt1,LS_FINITE));
	GenerateAxisNet(Set,BoundLine,precision,anglespace);
}

int EditAxisNet(AcDbObjectId id)
{
    OPENOBJ_BEGIN(id, AcDb::kForRead, TDbAxisLabelSet, pNet);
    if (!pNet)
	{
        return RTERROR;
	}
	
    if (pNet->upgradeOpen()!=Acad::eOk)
	{
		return RTERROR;	
	}
	pNet->SetShowHide(TRUE);
    pNet->downgradeOpen();
	
    while (1)
	{
		const TCHAR *szPrompt1=_T("\n选择 [变标注侧(M)/单轴变标注侧(S)/添补轴号(A)/删除轴号(D)/单轴变号(N)/重排轴号(R)/轴圈半径(Z)]<退出>:");
        XString sKeyword;
        int nRet=0;
        INITGET_BEG(0, _T("S M A D R N Z"));
        nRet=ads_getkword(szPrompt1, sKeyword);
        INITGET_END();
		
        if (nRet!=RTNORM)
		{
            break;
		}
        if (sKeyword[0] == _T('M'))
		{
            if (pNet->upgradeOpen()!=Acad::eOk)
			{
                return RTERROR;
			}
            pNet->assertWriteEnabled();
            int nVisSides=pNet->GetVisSides();
            nVisSides ++;
            if (nVisSides>3)
			{
                nVisSides=1;
			}
            pNet->SetVisSides(nVisSides);
            pNet->downgradeOpen();
        }
		else if (sKeyword[0] == _T('S'))
		{
            XPoint ptPick;
            while (ads_getpoint(NULL, _T("\n在需要改变标注侧的轴号附近取一点:"), ptPick) == RTNORM)
			{
                ptPick=Ucs2Wcs(ptPick);
				//int nIdx=pNet->HitTestOnLabel(ptPick);modified by whl on 041117
                int nIdx=pNet->HitTestOnLabel0(ptPick);//不忽略隐藏轴号
                if (nIdx>=0)
				{
                    int nVisSides=pNet->GetAxisVisSides(nIdx);
					if (pNet->upgradeOpen()!=Acad::eOk)
					{
						return RTERROR;	
					}
                    pNet->assertWriteEnabled();
                    nVisSides ++;
                    if (nVisSides>3)
					{
						nVisSides=0;
					}
                    pNet->SetAxisVisSides(nIdx, nVisSides);
                    pNet->downgradeOpen();
                }
            }
        }
		else if (sKeyword[0] == _T('D'))
		{
            XPoint ptPick;
            if (XGetPoint(NULL, _T("\n在需要删除的轴号附近取一点"), ptPick) == RTNORM)
			{
                ptPick=Ucs2Wcs(ptPick);
                int nAns=YesNoQuestion(_T("\n是否重排轴号"));
                if (nAns!=RTCAN)
				{
                    if (pNet->upgradeOpen()!=Acad::eOk)
					{
                        return RTERROR;
					}
                    int idx=pNet->HitTestOnAxis(ptPick);
                    if (idx>=0)
					{
						pNet->RemoveLabel(idx, nAns==Q_YES);
					}
                    pNet->downgradeOpen();
                }
            }
        }
		else if (sKeyword[0] == _T('A'))
		{
			XPoint ptAdd;
			if (XGetPoint(NULL, _T("\n请点取新轴号的位置"), ptAdd) == RTNORM)
			{
				ptAdd = Ucs2Wcs(ptAdd);
				TCHAR szLab[64]=_T("");
				const TCHAR *pszLab=NULL;
				if (!pNet->IsSortAuto())
				{
					if (ads_getstring(0, _T("\n新增轴号<空号>:"),  szLab) == RTCAN)
					{
						continue;
					}
					pszLab=szLab;
				}
				
				int nAns=YesNoQuestion(_T("\n新增轴号是否双侧标注"));
				if (nAns == RTCAN)
				{
					continue;
				}
				int nAxisFlag=0;
				if (nAns == Q_NO)
				{
					nAxisFlag = (pNet->OnWhichSide(ptAdd) == 0)? AXF_NOSIDE2 : AXF_NOSIDE1;
				}
				
				if (!pszLab)
				{
					int nAns1=YesNoQuestion(_T("\n新增轴号是否为附加轴号"), Q_NO);
					if (nAns1 == RTCAN)
					{
						continue;
					}
					if (nAns1 == Q_YES)
					{
						nAxisFlag |= AXF_ATTACH;
					}
				}
				else
				{
					if (_tcschr(pszLab, _T('/')))
					{
						nAxisFlag |= AXF_ATTACH;
					}
				}
				if (pNet->upgradeOpen() == Acad::eOk)
				{
					pNet->AddLabel(ptAdd, nAxisFlag, pszLab);
					pNet->downgradeOpen();
				}
			}
        }
		else if (sKeyword[0] == _T('N') || sKeyword[0] == _T('R'))
		{
			XPoint ptPick;
			if (ads_getpoint(NULL, _T("\n请在要更改的轴号附近取一点:"), ptPick) == RTNORM)
			{
				ptPick=Ucs2Wcs(ptPick);
				int nIdx=pNet->HitTestOnLabel(ptPick);
				if (nIdx>=0)
				{
					const TCHAR *pszOld=pNet->GetLabel(nIdx);
					TCHAR szOld[80]=_T("");
					_tcscpy(szOld, pszOld);
					adsout << _T("\n请输入新的轴号(.空号)<") << szOld << _T(">: ");
					if (ads_getstring(0, _T(""), szOld) == RTNORM)
					{
                        if (_tcscmp(szOld, _T(".")) == 0)
						{
                            _tcscpy(szOld, _T(""));
						}
                        else if (!szOld[0])
						{
                            _tcscpy(szOld, pszOld);
						}
                        if (pNet->upgradeOpen() == Acad::eOk)
						{
                            pNet->SetLabel(nIdx, szOld, sKeyword[0]==_T('R'));
                            pNet->downgradeOpen();
                        }
					}
				}
			} 
        }
		else if (sKeyword[0] == _T('Z'))
		{
			double nRad=pNet->GetCirRadius();
			if (GetReal(_T("\n轴圈在纸面上的半径"), nRad, RSG_NONEG|RSG_NOZERO) == RTNORM)
			{
				if (pNet->upgradeOpen() == Acad::eOk)
				{
					pNet->SetCirRadius(nRad);
					pNet->downgradeOpen();
				}
			}
        }
    }
	
    if (pNet->upgradeOpen()!=Acad::eOk)
	{
		return RTERROR;	
	}
    pNet->SetShowHide(FALSE);
	
    OPENOBJ_END();
    return RTNORM;
}



/////////////////////////////////////////////
// 命令：添补轴号
void AddAxisLabel()
{
	// sg add 100521，进入命令后，临时显示全部隐藏轴号
	SetShowHiddenAxisLable(true);

	Entity ent;
	XPoint ptPick;
	RBList mask(RTDXF0, _T("ATS_AXIS_LABEL"), NULL);
	if (SelectEntity(_T("\n请选择轴号对象<退出>: "), ent, ptPick, mask) != RTNORM)
	{
		// sg add 100521，退出命令时，恢复隐藏
		SetShowHiddenAxisLable(false);
		return;
	}
	ptPick = Ucs2Wcs(ptPick);

	OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbAxisLabelSet, pSet);
	if (!pSet)
	{
		// sg add 100521，退出命令时，恢复隐藏
		SetShowHiddenAxisLable(false);
		return;
	}

	int idx = pSet->HitTestOnAxis(ptPick);
	if (idx < 0)
	{
		// sg add 100521，退出命令时，恢复隐藏
		pSet->close();
		SetShowHiddenAxisLable(false);
		return;
	}

	XCurveSegment segRef = pSet->GetAxis(idx);
	XPoint ptNear = segRef.NearPoint(ptPick);
	XPoint ptAdd;
	if (XGetPoint(Wcs2Ucs(ptNear), _T("\n请点取新轴号的位置"), ptAdd)!=RTNORM)
	{
		// sg add 100521，退出命令时，恢复隐藏
		pSet->close();
		SetShowHiddenAxisLable(false);
		return;
	}	
	ptAdd = Ucs2Wcs(ptAdd);

	TCHAR szLab[64] = _T("");
	const TCHAR *pszLab = NULL;
	if (!pSet->IsSortAuto())
	{
		if (ads_getstring(0, _T("\n新增轴号<空号>:"), szLab) == RTCAN)
		{
			// sg add 100521，退出命令时，恢复隐藏
			pSet->close();
			SetShowHiddenAxisLable(false);
			return;
		}
		pszLab = szLab;
	}
	
	int nAns = YesNoQuestion(_T("\n新增轴号是否双侧标注"));
	if (nAns == RTCAN)
	{
		// sg add 100521，退出命令时，恢复隐藏
		pSet->close();
		SetShowHiddenAxisLable(false);
		return;
	}

	int nAxisFlag = 0;
	if (nAns == Q_NO)
	{
		nAxisFlag = (pSet->OnWhichSide(ptAdd) == 0) ? AXF_NOSIDE2 : AXF_NOSIDE1;
	}
	
	if (!pszLab)
	{
		int nAns1 = YesNoQuestion(_T("\n新增轴号是否为附加轴号"), Q_NO);
		if (nAns1 == RTCAN)
		{
			// sg add 100521，退出命令时，恢复隐藏
			pSet->close();
			SetShowHiddenAxisLable(false);
			return;
		}

		if (nAns1 == Q_YES)
		{
			nAxisFlag |= AXF_ATTACH;
		}
	} 
	else 
	{
		if (_tcschr(pszLab, _T('/')))
		{
			nAxisFlag |= AXF_ATTACH;
		}
	}
	
	//add by lgy 20120208	添加提示是否需要重排号
	int iAns = YesNoQuestion(_T("\n是否重排轴号"), Q_YES);
	if (iAns == RTCAN)
	{
		SetShowHiddenAxisLable(false);
		pSet->close();
		return;
	}
	bool bSortLabel = (iAns==Q_YES);
	if (pSet->upgradeOpen() == Acad::eOk)
	{
		//modify by lgy 20120208	增加是否需要重排号
		//pSet->AddLabel(ptAdd, nAxisFlag, pszLab);
		pSet->AddLabel(ptAdd, nAxisFlag, pszLab, bSortLabel);
		pSet->downgradeOpen();
	}	
	OPENOBJ_END();

	// sg add 100521，退出命令时，恢复隐藏
	SetShowHiddenAxisLable(false);
}


/////////////////////////////////////////////
// Command: 添加轴号
//void DelAxisLabel()
//{
//   Entity ent;
//   XPoint ptPick;
//   if (SelectEntity(_T("\n请选择轴号对象<退出>: "), ent, ptPick, RBList(RTDXF0, _T("ATS_AXIS_LABEL"),NULL))!=RTNORM)
//       return;
//   int nAns=YesNoQuestion(_T("\n是否重排轴号"), Q_YES);
//   if (nAns==RTCAN)
//       return;
//   BOOL bSortLabel=(nAns==Q_YES);
//   ptPick=Ucs2Wcs(ptPick);
//   OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbAxisLabelSet, pSet);
//   if (!pSet)
//       return;
//   int idx=pSet->HitTestOnAxis(ptPick);
//   if (idx<0)
//       return;
//   pSet->RemoveLabel(idx, bSortLabel);
//   OPENOBJ_END();
//}

// Modify By LCF 2004/07/08
// 需要删除轴号的轴标实体
class TAxisLabelSet
{
public:
	DualList<long> m_lstIndex;	// 所有将要删除的轴号的索引
	AcDbObjectId m_iId;			// 轴号实体
	TDbAxisLabelSet *pEnt;

public:
	bool AppendIndexDel(int i)
	{
		long oldLen=m_lstIndex.GetLength();
		m_lstIndex.FindOrAddTail(i);
		return oldLen<m_lstIndex.GetLength();
	}

	//ok,如果已经存在不添加
	void RemoveLabel(bool bSort)
	{
		m_lstIndex.Arrange(false);

		// modify by xly on 110306 修改删除附加轴号是首根轴号的错误
		/*acdbOpenObject(pEnt,m_iId,AcDb::kForWrite);
		for (m_lstIndex.MoveToFirst();!m_lstIndex.IsOut();m_lstIndex.MoveToNext())
		{
			pEnt->RemoveLabel(m_lstIndex.GetCurData(),bSort);
		}
		pEnt->close();*/
		if (Acad::eOk==acdbOpenObject(pEnt,m_iId,AcDb::kForWrite))
		{
			for (m_lstIndex.MoveToFirst();!m_lstIndex.IsOut();m_lstIndex.MoveToNext())
			{
				pEnt->RemoveLabel(m_lstIndex.GetCurData(),bSort);
				if (bSort)// 删除重排后主轴号之前的错误部分处理
				{
					int nPosMajar(-1);
					int i=0;
					for (i=0;i<pEnt->GetAxisNum(); i++)
					{
						CString csLable = pEnt->GetLabel(i);
						int iIndex = csLable.Find(_T("/"));
						if (iIndex<0)
						{
							nPosMajar = i;
							break;
						}
					}
					if (nPosMajar>0)
					{
						int nTemp = nPosMajar;
						CString csLable = pEnt->GetLabel(nPosMajar);
						bool bFenQu = (csLable.Find(_T("-"))>-1);
						if (bFenQu)// 主轴号是分区轴号
						{
							csLable.Insert((csLable.Find(_T("-"))+1),_T('0'));
						}
						for (i=0; i<nPosMajar;i++)
						{
							CString csFir = _T("");
							if (bFenQu)// 主轴号是分区轴号
							{
								csFir.Format(_T("%d/"),nTemp);
							}
							else
							{
								csFir.Format(_T("%d/0"),nTemp);
							}

							csFir += csLable;
							pEnt->SetLabel(i,csFir,FALSE);
							nTemp--;
						}
					}
				}

			}
			pEnt->close();
		}
		
	}
	
	bool operator ==(const TAxisLabelSet&aSet){return m_iId==aSet.m_iId;}//ok
	bool operator >(const TAxisLabelSet&){return false;}
	bool operator <(const TAxisLabelSet&){return false;}
};

// 需要删除轴号的所有轴标实体
class TAllAxis:public PDList<TAxisLabelSet>
{
public:
	long Find(AcDbObjectId id)//搜索id对应的轴标项，返回其索引,如果不存在则先建立一个id代表的新项。
	{
		for (MoveToFirst();!IsOut();MoveToNext())
		{
			if (GetCurData()->m_iId == id)//找到
			{
				return GetCur();
			}
		}
		TAxisLabelSet *pAxis=new TAxisLabelSet;
		pAxis->m_iId=id;
		AddTail(pAxis);//没有找到就添加
		
		return GetLastIndex();
	}

	void RemoveLabel(bool bSort)
	{
		for (MoveToFirst();!IsOut();MoveToNext())
		{
			GetCurData()->RemoveLabel(bSort);
		}
	}
};

// [2010-4-20 wubo] 根据两个角点得到一个poly。从DelAxisLabel()中提取函数。
TGGePoly2D GetExtentPolyByTwoCorner(const TADSGePoint3d &ptStart, const TADSGePoint3d &ptEnd )
{
	TADSGePoint3d ptLowLeft, ptLowRight, ptUpRight, ptUpLeft;
	if (ptStart.x > ptEnd.x)
	{
		ptLowLeft.x = ptEnd.x;
		ptUpLeft.x = ptEnd.x;
		ptLowRight.x = ptStart.x;
		ptUpRight.x = ptStart.x;
	}
	else
	{
		ptLowLeft.x = ptStart.x;
		ptUpLeft.x = ptStart.x;
		ptLowRight.x = ptEnd.x;
		ptUpRight.x = ptEnd.x;
	}

	if (ptStart.y > ptEnd.y)
	{
		ptLowLeft.y = ptEnd.y;
		ptLowRight.y = ptEnd.y;
		ptUpLeft.y = ptStart.y;
		ptUpRight.y = ptStart.y;
	}
	else
	{
		ptLowLeft.y = ptStart.y;
		ptLowRight.y = ptStart.y;
		ptUpLeft.y = ptEnd.y;
		ptUpRight.y = ptEnd.y;
	}

	TGGePoly2D poly(1);
	poly.AppendNode(ptLowLeft);
	poly.AppendNode(ptLowRight);
	poly.AppendNode(ptUpRight);
	poly.AppendNode(ptUpLeft);
	return poly;
}

// add by xly on 110306 将选择集中的轴号虚显
void SetVisulShow(PickSet ssMouseSel, TGGePoly2D extentPoly, PickSet& ssLabel)
{
	long l = 0,
		lSelLength = ssMouseSel.Length(); // 选择集的长度

	for (l = 0; l<lSelLength; l++)
	{
		Entity ent = ssMouseSel[l];
		// modify by xly on 110503 以安全的方式打开
		//OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbAxisLabelSet, pSet);
		OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbAxisLabelSet, pSet);
		if (pSet == NULL)
		{
			continue;
		}

		// 克隆实体
		TDbAxisLabelSet *pNewAxis = (TDbAxisLabelSet *)pSet->clone();

		int nSide = pNewAxis->GetVisSides(),
			nTmpIndex = 0;

		// 对框选中的轴圈操作时，遍历实体，寻找框选到的轴号
		int iNum = 0,
			iAxisNumLength = pNewAxis->GetAxisNum();
		AcDbIntArray aryAxisInSel;

		if (nSide == 1 || nSide == 3) // 只标第0侧，或双侧标注
		{
			TADSGePoint3d ptLabelCenter;
			for (iNum = 0; iNum < iAxisNumLength; iNum++)
			{
				ptLabelCenter = pNewAxis->GetLabelCenter(iNum, 0);
				if ((ptLabelCenter&extentPoly) != PR_OUTSIDE) // 在框选范围外
				{
					if (!aryAxisInSel.find(iNum, nTmpIndex)) // 找不到就添加
					{
						aryAxisInSel.append(iNum);
					}
				}
			}
		}

		if (nSide == 2 || nSide == 3) // 只标第1侧，或双侧标注
		{
			TADSGePoint3d ptLabelCenter;
			for (iNum = 0; iNum < iAxisNumLength; iNum++)
			{
				ptLabelCenter = pNewAxis->GetLabelCenter(iNum, 1);
				if ((ptLabelCenter&extentPoly) != PR_OUTSIDE) // 在框选范围内
				{
					if (!aryAxisInSel.find(iNum, nTmpIndex)) // 找不到就添加
					{
						aryAxisInSel.append(iNum);
					}
				}
			}
		}

		int nTemp = 0;
		for (iNum = 0; iNum < iAxisNumLength; iNum++)
		{
			if (!aryAxisInSel.find(nTemp, nTmpIndex)) // 找不到，表示被选中，不删除
			{
				pNewAxis->RemoveLabel(iNum, FALSE);
				iAxisNumLength--;
				iNum--;
			}
			nTemp++;
		}
		ssLabel += pNewAxis->AddToMSpace(Adesk::kFalse);
		// modify by xly on 110503 以安全的方式打开,增加一个成功的判断
		if (pNewAxis->downgradeOpen()==Acad::eOk)
		{
			pNewAxis->highlight();	
		}
		pNewAxis->close();
		OPENOBJ_END();
	}
}

/////////////////////////////////////////////
// 命令：删除轴号
void DelAxisLabel()
{
	// sg add 100521，进入命令后，临时显示全部隐藏轴号
	SetShowHiddenAxisLable(true);

	XPushVar<int> osmode(_T("OSMODE"), 0);
	
	TAllAxis allEnt; // 所有相关轴标实体

	// modify by xly on 110306 保存框选到的的轴号
	//PickSet ssLabel(SS_FREE);
	PickSet ssLabel(SS_CREATE);
	while (1)
	{
		XPoint ptStart, ptEnd;
		Entity ent;
		int ret = acedGetPoint(NULL, _T("\n请框选轴号对象<退出>:"), ptStart);
		if (ret == RTCAN)
		{
			ssLabel.Erase();

			// sg add 100521，退出命令时，恢复隐藏
			SetShowHiddenAxisLable(false);
			return;
		}

		if (ret != RTNORM)
		{
			break; 
		}
		
		if (XGetCorner(ptStart, NULL, ptEnd) != RTNORM)
		{
			continue;
		}
		
		// [2010-4-20 wubo] 提取了公共函数GetExtentPolyByTwoCorner
		//XPoint ptLowLeft, ptLowRight, ptUpRight, ptUpLeft;
		//if (ptStart.x > ptEnd.x)
		//{
		//	ptLowLeft.x = ptEnd.x;
		//	ptUpLeft.x = ptEnd.x;
		//	ptLowRight.x = ptStart.x;
		//	ptUpRight.x = ptStart.x;
		//}
		//else
		//{
		//	ptLowLeft.x = ptStart.x;
		//	ptUpLeft.x = ptStart.x;
		//	ptLowRight.x = ptEnd.x;
		//	ptUpRight.x = ptEnd.x;
		//}
		//if (ptStart.y > ptEnd.y)
		//{
		//	ptLowLeft.y = ptEnd.y;
		//	ptLowRight.y = ptEnd.y;
		//	ptUpLeft.y = ptStart.y;
		//	ptUpRight.y = ptStart.y;
		//}
		//else
		//{
		//	ptLowLeft.y = ptStart.y;
		//	ptLowRight.y = ptStart.y;
		//	ptUpLeft.y = ptEnd.y;
		//	ptUpRight.y = ptEnd.y;
		//}
		//
		//XPoly2D poly(1);
		//poly.AppendNode(ptLowLeft);
		//poly.AppendNode(ptLowRight);
		//poly.AppendNode(ptUpRight);
		//poly.AppendNode(ptUpLeft);

		XPoly2D poly = GetExtentPolyByTwoCorner(ptStart, ptEnd);
		
		RBList rbRegion = poly.Polygon();
		PickSet ss(SS_FREE);
		if (ss.Get(_T("CP"), rbRegion, NULL, RBList(RTDXF0, _T("ATS_AXIS_LABEL"), NULL)) != RTNORM)
		{
			continue;
		}
		
		poly.TransUCS(Groups(1), Groups(0));
		
		long num = ss.Length();
		for (long i=0; i<num; i++)
		{
			Entity ent = ss[i];
			OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbAxisLabelSet, pSet);
			if (pSet == NULL) // add by lcf on 050224
			{
				continue;
			}

			// add by xly on 100810 解决删除轴号时，不能删除隐藏轴号
			// 判断框选的范围内是否有隐藏轴号
			for(int k = 0; k<pSet->GetAxisNum();k++)
			{
				// 获得标注的信息
				XCurveSegment seg = pSet->GetAxis(k);

				// 判断在框选的范围内标注是否有隐藏
				XPoint ptCentre = pSet->GetLabelCenter(k,0);
				int iIsIn = ptCentre & poly;
				if (iIsIn != PR_OUTSIDE) // 0侧
				{
					pSet->HideAxisLabel(k,0,FALSE);
				}

				ptCentre = pSet->GetLabelCenter(k,1);
				iIsIn = ptCentre & poly;
				if (iIsIn != PR_OUTSIDE)// 1侧
				{
					pSet->HideAxisLabel(k,1,FALSE);
				}
			}

			AcDbObjectId eId = pSet->objectId();
			allEnt.Find(eId);
			
			TAxisLabelSet *pLabelSet = allEnt.GetCurData();
			AcDbVoidPtrArray entSet;
			pSet->Explode(entSet);

			long nLen = entSet.length();
			for (long index=nLen-1; index>=0; index--)
			{
				AcDbEntity *pEnt = (AcDbEntity*)entSet[index];
				if (!pEnt->isKindOf(TDbSymbDrawingIndex::desc()))
				{
					delete pEnt;
					entSet.removeAt(index);
				}
			}
			
			for (long j=0; j<entSet.length(); j++)
			{
				TDbSymbDrawingIndex *pIndex = (TDbSymbDrawingIndex*)entSet[j];
				XPoint ptCen = pIndex->GetCenter();
				int rtInSide = ptCen & poly;
				if (rtInSide != PR_OUTSIDE)
				{
					//modified by whl on 060107
					//int idx = pSet->HitTestOnAxis(ptCen);
					int idx = pSet->HitTestOnLabel(ptCen);
					
					if (idx >= 0 && pLabelSet->AppendIndexDel(idx))
					{
						int iSide = pSet->GetAxisVisSides(idx);
						if (iSide == 3)
						{
							XPoint ptStaCen, ptEndCen;
							ptStaCen = pSet->GetLabelCenter(idx, 0);
							ptEndCen = pSet->GetLabelCenter(idx, 1);
							
							for (long k=0; k<entSet.length(); k++)
							{
								TDbSymbDrawingIndex *pSideIndex = (TDbSymbDrawingIndex*)entSet[k];
								XPoint ptSideCen = pSideIndex->GetCenter();
								double dSta = ptSideCen.Distance2d(ptStaCen);
								double dEnd = ptSideCen.Distance2d(ptEndCen);
								if (dSta < 1.0E-6 || dEnd < 1.0E-6)
								{
									// delete by xly on 110306 设置框选的轴号的虚显不用此函数
									/*TDbSymbDrawingIndex *pHightlight = (TDbSymbDrawingIndex*)pSideIndex->clone();
									ssLabel += pHightlight->AddToMSpace(Adesk::kFalse);
									pHightlight->downgradeOpen();
									pHightlight->highlight();
									pHightlight->close();*/
								}
							}
						}
						else
						{
							// delete by xly on 110306 设置框选的轴号的虚显不用此函数
							/*TDbSymbDrawingIndex *pHightlight = (TDbSymbDrawingIndex*)pIndex->clone();
							ssLabel+=pHightlight->AddToMSpace(Adesk::kFalse);
							pHightlight->downgradeOpen();
							pHightlight->highlight();
							pHightlight->close();*/
						}
					}
				}
			}
			ReleaseEntSet(entSet);
			OPENOBJ_END();
		}
		// add by xly on 110306 设置轴号的虚显
		PickSet ssTemp(SS_CREATE);
		ssTemp += ss;
		SetVisulShow(ssTemp, poly, ssLabel);
		ssTemp.Free();
		continue;
	}

	long nlight = ssLabel.Length();
	if (nlight <= 0) 
	{
		// sg add 100521，退出命令时，恢复隐藏
		SetShowHiddenAxisLable(false);
		return;
	}

	int nAns = YesNoQuestion(_T("\n是否重排轴号"), Q_YES);
	// modify by xly on 110503 重复框选同一个轴标出现错误，提到下面调用
	//ssLabel.Erase();
	if (nAns == RTCAN)
	{
		// add by xly on 110503 取消时清除轴号
		ssLabel.Erase();

		// sg add 100521，退出命令时，恢复隐藏
		SetShowHiddenAxisLable(false);
		return;
	}

	bool bSortLabel = (nAns==Q_YES);
	allEnt.RemoveLabel(bSortLabel);

	ssLabel.Erase();
	// sg add 100521，退出命令时，恢复隐藏
	SetShowHiddenAxisLable(false);
}



/////////////////////////////////////////////
// sg add 100530，判断是否需要在“重排轴号”命令中，提示用户选择“变前项”、“变后项”
bool IsPromptChangeNoRule(const TCHAR *pszText)
{
	int nLength = (int)_tcslen(pszText);
	if (nLength < 2) // 单个字母或者为空，不需要提示选择排序原则
	{
		return false;
	}

	if (IsDigital(pszText)) // 全部是数字，也不需要提示选择排序原则
	{
		return false;
	}

	const TCHAR *pSep = _tcschr(pszText, _T('/'));
	if (pSep != NULL) // 附加轴号，也不需要提示选择排序原则
	{
		return false;
	}

	return true; // 字母数字组合
}

// 命令: 重排轴号
void ChAxisLabel1()
{
	XPoint ptPick;
	Entity entAxisNo;
	RBList mask(RTDXF0, _T("ATS_AXIS_LABEL"), NULL);
	if (SelectEntity(_T("\n请选择需重排的第一根轴号<退出>: "), entAxisNo,  ptPick, mask) == RTNORM)
	{
		ptPick = Ucs2Wcs(ptPick); // Add on 2001/11/29 by ZJQ

		OPENOBJ_BEGIN(entAxisNo, AcDb::kForRead, TDbAxisLabelSet, pLabel);
		int nIdx = pLabel->HitTestOnLabel(ptPick);
		if (nIdx >= 0)
		{
			const TCHAR *pszOld = pLabel->GetLabel(nIdx);

			TCHAR szOld[80] = _T("");
			_tcscpy(szOld, pszOld);
			adsout << _T("\n请输入新的轴号(.空号)<") << szOld << _T(">: ");

			if (ads_getstring(0, _T(""), szOld) == RTNORM)
			{
                if (_tcscmp(szOld, _T(".")) == 0)
				{
                    _tcscpy(szOld, _T(""));
				}
                else if (!szOld[0])
				{
                    _tcscpy(szOld, pszOld);
				}

				// sg add 100530，根据8.5的需求，增加了“变前项”、“变后项”的设置
				// 需要给出提示“请输入轴号规则”的提示
				bool bPrompt = ::IsPromptChangeNoRule(szOld);

				BOOL bChangePreNo = pLabel->IsChangePreNum(); // 当前规则
				if (bPrompt)
				{
					TCHAR szSortRule[10] = _T("");
					if (bChangePreNo) // 变前项
					{
						_tcscpy(szSortRule, _T("F"));
					}
					else // 变后项
					{
						_tcscpy(szSortRule, _T("B"));
					}
					adsout << _T("\n请输入轴号规则[变后项(B)/变前项(F)]<") << szSortRule << _T(">: ");
					
					int nRet = ads_getstring(0, _T(""), szSortRule);
					if (nRet == RTNORM)
					{
						if (szSortRule[0])
						{
							bChangePreNo = _tcscmp(szSortRule, _T("F"))==0 || _tcscmp(szSortRule, _T("f"))==0;
						}
					}
					else // 其他
					{
						return;
					}
				}

                if (pLabel->upgradeOpen() == Acad::eOk)
				{
					// sg add 100530，将用户设置的“变前项”、“变后项”的值，传递给对象
					if (bPrompt)
					{
						pLabel->SetChangePreNum(bChangePreNo);
					}

                    pLabel->SetLabel(nIdx, szOld, TRUE);
                    pLabel->downgradeOpen();
                }
			}
		}
		OPENOBJ_END();
	}
}


/////////////////////////////////////////////
// 命令：修改轴号
void ChAxisLabel2()
{
	XPoint ptPick;
	Entity entAxisNo;
	RBList mask(RTDXF0, _T("ATS_AXIS_LABEL"), NULL);
	while (SelectEntity(_T("\n请选择轴号<退出>: "), entAxisNo, ptPick, mask) == RTNORM)
	{
		ptPick = Ucs2Wcs(ptPick); // Add on 2001/11/29 by ZJQ

		OPENOBJ_BEGIN(entAxisNo, AcDb::kForRead, TDbAxisLabelSet, pLabel);
		int nIdx = pLabel->HitTestOnLabel(ptPick);
		if (nIdx >= 0)
		{
			const TCHAR *pszOld = pLabel->GetLabel(nIdx);
			TCHAR szOld[80] = _T("");
			_tcscpy(szOld, pszOld);
			adsout << _T("\n请输入新的轴号(.空号)<") << szOld << _T(">: ");

			if (ads_getstring(0, _T(""), szOld) == RTNORM)
			{
                if (_tcscmp(szOld, _T(".")) == 0)
				{
                    _tcscpy(szOld, _T(""));
				}
                else if (!szOld[0])
				{
                    _tcscpy(szOld, pszOld);
				}

                if (pLabel->upgradeOpen() == Acad::eOk)
				{
                    pLabel->SetLabel(nIdx, szOld, FALSE);
                    pLabel->downgradeOpen();
                }
			}
		}
		OPENOBJ_END();
	}
}



/////////////////////////////////////////
// 必须在WCS下
// modify by xly 1005010，完成8.5的新需求，整体修该命令
/*
void ManualDimAxis()
{
   InitLayer(LAY_DIMAX, TRUE);
   RBList mask(RTDXF0, _T("LINE,ARC"), 8, LAY_AXIS, NULL);
   XPoint ptPick;
   while (1) {
       Entity entFirstAxis;
       { 
           XPushVar<int> osmode(_T("OSMODE"), OS_END|OS_NEA);
           if (SelectEntity1(_T("\n点取待标注的轴线<退出>:"), entFirstAxis, ptPick, mask)!=RTNORM)
               return;
           ptPick=Ucs2Wcs(ptPick); // Add on 2001/11/29 by ZJQ
       }
       XCurveSegment curve(entFirstAxis);
       BOOL bOnStart=ptPick.Distance2d(curve.StartPoint())<ptPick.Distance2d(curve.EndPoint());
       XPoint ptAxisEnd = curve.NearPoint(ptPick);
       XPoint ptAxisEnd1;
       double nAxisDirection=curve.IDirection(bOnStart? 0: 1);
       ads_polar(ptAxisEnd, nAxisDirection, curve.GetLength(), ptAxisEnd1);

       TCHAR szLabel[256]=_T("");
       if (ads_getstring(0, _T("\n请输入轴号<空号>:"), szLabel)==RTCAN)
          return;

       TDbAxisLabelSet *pAxisDim=new TDbAxisLabelSet;
       pAxisDim->SetTextStyleId(InitTextStyle(TS_AXIS));
	   pAxisDim->SetTextLayerId(InitLayer(LAY_AXIS_TEXT, FALSE));
       pAxisDim->AddAxis(XCurveSegment(ptAxisEnd, ptAxisEnd1, 0.0, LS_FINITE), FALSE, szLabel);
       ASSERT(pAxisDim->IsValid());
        pAxisDim->SetSortAuto(FALSE);
        pAxisDim->HideSide(1);
		pAxisDim->SetLayoutRotation(Ucs2Wcs(0));
        pAxisDim->AddToMSpace(Adesk::kTrue);
   }
}
*/


/////////////////////////////////////////////
// 命令：逐点标注(逐点轴标)
void ManualDimAxis()
{
	// 初始化图层
	InitLayer(LAY_DIMAX, TRUE);
	
	// 初始化对话框
	CManualDimAxisDlg dlg(acedGetAcadFrame());
	{
		CAcModuleResourceOverride vTemp;
		if (!dlg.Create(CManualDimAxisDlg::IDD, acedGetAcadFrame()))
		{
			return;
		}
	}
	dlg.ShowWindow(SW_SHOW);
	acedGetAcadDwgView()->SetFocus();

	XPoint ptPick;
	Entity entFirstAxis;
	CString csLabel = _T("");
	RBList mask(RTDXF0, _T("LINE,ARC"), 8, LAY_AXIS, NULL);
	
	// 当前UCS
	double dUcsAngle = Ucs2Wcs(0.0);
	AcGeVector3d vtCurXAxis(cos(dUcsAngle), sin(dUcsAngle), 0); // 当前坐标系下的X轴

	while (1) 
	{
		{
			XPushVar<int> osmode(_T("OSMODE"), OS_END|OS_NEA);
			if (SelectEntity1(_T("\n点取待标注的轴线<退出>:"), entFirstAxis, ptPick, mask) != RTNORM)
			{
				// add by xly on 101029 释放对话框资源，解决运行命令后CAD中的打开、新建、图纸切换不可用
				if (IsWindow(dlg.m_hWnd))
				{
					dlg.DestroyWindow();
				}	
				return;
			}

			ptPick = Ucs2Wcs(ptPick);
		}

		XCurveSegment curve(entFirstAxis);
		bool bOnStart = ptPick.Distance2d(curve.StartPoint())<ptPick.Distance2d(curve.EndPoint());

		// 获取轴线中，离拾取点较近的一侧
		XPoint ptAxisNear = curve.NearPoint(ptPick),
			ptAxisFar;
		double nAxisDirection = curve.IDirection(bOnStart ? 0 : 1);
		ads_polar(ptAxisNear, nAxisDirection, curve.GetLength(), ptAxisFar);

		// 对话框的选择项目
		int iSelected = dlg.m_iWhichSlected;
		int iTxtOrGraph = dlg.m_iTxtorGrap;
		BOOL bIsContinue = dlg.m_bButCon;

		// 获得多轴，不连续图形的所有值
		CStringArray aryAxisLable;
		dlg.GetAllAxis(aryAxisLable);

		// 获得起、止位置的内容
		CString csStartAxis = _T(""),
			csEnfAxis = _T("");
		dlg.GetStartAndEndAxis(csStartAxis, csEnfAxis);

		// 根据对话框的选项设置第一个轴圈内容
		if (bIsContinue && iSelected == 1)	// 多轴，连续
		{
			csLabel = csStartAxis;
		}
		else if (iTxtOrGraph == 1 && iSelected == 1)	// 多轴，图形
		{
			csLabel = aryAxisLable.GetAt(0);
		}
		else // 单轴，多轴、文字
		{
			csLabel = dlg.GetFirstAxis();
		}

		// add by xly  100813 修改轴标引线长度的变量
		// 设置轴标的引线长度
		double dLeaderLen = dlg.GetLeaderLen();
		dLeaderLen = dLeaderLen * DocGetPScale();

		// 绘制第一个轴圈
        TDbAxisLabelSet *pAxisDim = new TDbAxisLabelSet;
        pAxisDim->SetTextStyleId(InitTextStyle(TS_AXIS));
	    pAxisDim->SetTextLayerId(InitLayer(LAY_AXIS_TEXT, FALSE));
        pAxisDim->AddAxis(XCurveSegment(ptAxisNear, ptAxisFar, 0.0, LS_FINITE), 0, csLabel);

        ASSERT(pAxisDim->IsValid());
        pAxisDim->SetSortAuto(FALSE);
        pAxisDim->HideSide(1);
	    pAxisDim->SetLayoutRotation(dUcsAngle);
		
		// add by xly  100813 修改轴标引线长度的变量
		pAxisDim->SetLeaderLen(0,dLeaderLen, FALSE);

		pAxisDim->AddToMSpace(Adesk::kTrue);
		
		if (iSelected == 0)	// 单轴只有一个轴圈
		{
			continue;
		}

		// modify by xly  100813 预留可以修改轴标引线长度的变量
		// 引线默认长度
		//pAxisDim->GetLeaderLen((pAxisDim->GetVisSides()), FALSE);
		double dLenLeader = dLeaderLen;

		// 图形类多轴号
		if (!bIsContinue && iTxtOrGraph == 1)
		{
			AcGePoint3d ptPos, ptFar;

			// 将获得的csArry数组的1到iLen-1个字符串做成轴标
			int nLength = (int)aryAxisLable.GetSize();
			for (int i = 1; i < nLength; i++)
			{
				// 获得引线长度
				dLenLeader = dLenLeader + pAxisDim->GetCirRadius(FALSE) * 2;
				ads_polar(ptAxisNear, nAxisDirection + PI, dLenLeader , asDblArray(ptPos));
				ads_polar(ptAxisFar, nAxisDirection, dLenLeader , asDblArray(ptFar));


				// 声明轴标对象，设置相关内容
				TDbAxisLabelSet *pNewAxisDim = new TDbAxisLabelSet;
				pNewAxisDim->SetTextStyleId(InitTextStyle(TS_AXIS));
				pNewAxisDim->SetTextLayerId(InitLayer(LAY_AXIS_TEXT, FALSE));
				pNewAxisDim->AddAxis(XCurveSegment(ptPos, ptFar, 0.0, LS_FINITE), 0, aryAxisLable.GetAt(i));

				// 将新生成的多轴号，引线长度设置为0
				pNewAxisDim->SetLeaderLen(0, 0.0, TRUE);
				pNewAxisDim->SetLeaderLen(1, 0.0, TRUE);
				ASSERT(pNewAxisDim->IsValid());

				pNewAxisDim->SetSortAuto(FALSE);
				pNewAxisDim->HideSide(1);
				pNewAxisDim->SetLayoutRotation(dUcsAngle);
				pNewAxisDim->AddToMSpace(Adesk::kTrue);
			}

			continue;
		}

		double dRadCir = pAxisDim->GetCirRadius(FALSE),		// 轴圈半径
			dTextHeight = AXISTEXT_HEIGHT * DocGetPScale(),	// 默认字高
			dAngleVet = 0.0;
		dTextHeight = dRadCir*5.5/4;

		CString csTextHeight;
		csTextHeight.Format(_T("%.1f"), dTextHeight);
		dTextHeight = _tstof(csTextHeight);

		// 获得第一轴圈的中心点半径
		AcGePoint3d ptTextPos,
			ptCenter = pAxisDim->GetLabelCenter(0, pAxisDim->GetAxisVisSides(pAxisDim->GetVisSides()));
		// modify by xly on 110410 修改文字的对齐方式
		// 单行文字对齐方式
		//XExplodeDraw::TextAlignment nAlign = XExplodeDraw::kBottomLeft;
		XExplodeDraw::TextAlignment nAlign = XExplodeDraw::kMiddleLeft;

		{
			// 轴网所在位置的判断
			AcGeVector3d ver = ptCenter - ptAxisNear.AsAcGePoint3d();
			dAngleVet = vtCurXAxis.angleTo(ver, AcGeVector3d::kZAxis);

			if (dAngleVet > PI * 0.5 + _angSnap && dAngleVet < PI + _angSnap)
			{
				acutPolar(asDblArray(ptCenter), dUcsAngle+PI, dRadCir * 1.2, asDblArray(ptTextPos));
				//nAlign = XExplodeDraw::kBottomRight;
				nAlign = XExplodeDraw::kMiddleRight;
			}
			else
			{
				acutPolar(asDblArray(ptCenter), dUcsAngle, dRadCir * 1.2, asDblArray(ptTextPos));
			}
			// delete by xly on 110410 修改文字的对齐方式
			//acutPolar(asDblArray(ptTextPos), dUcsAngle-PI/2, dTextHeight * 0.5, asDblArray(ptTextPos));
		}


		if (bIsContinue)	// 多轴,连续第一轴圈后的内容
		{
			if (csEnfAxis.IsEmpty())
			{
				continue;
			}

			// “～”文本的绘制
			TDbText *pText = new TDbText();
			pText->SetStyleId(InitTextStyle(TS_AXIS));
			pText->SetHeight(dTextHeight, FALSE);
			pText->SetText(_T("～"));
			pText->SetAlignment(nAlign);
			pText->SetLocation(ptTextPos);

			// 获得文字的外包围框大小
			XPoint ptMax, ptMin;
			pText->SetLayoutRotation(0);
			pText->GetExtents2d(ptMin, ptMax);
			pText->SetLayoutRotation(dUcsAngle);
			
			// modify by xly on 110316 设置文字的图层在轴号的文字图层
			//pText->AddToMSpace(Adesk::kTrue);
			AcDbObjectId id = pText->AddToMSpace(Adesk::kTrue);
			if (Acad::eOk ==acdbOpenObject(pText, id,AcDb::kForWrite))
			{
				pText->setLayer(InitLayer(LAY_AXIS_TEXT, FALSE));
				pText->close();
			}
			

			// 文字宽度
			double dTextWidth = ptMax.x - ptMin.x;

			// 终止轴线
			AcGePoint3d ptNearAxisPos ,ptFarAxisPos;
			ads_polar(asDblArray(ptCenter), nAxisDirection, dRadCir, asDblArray(ptNearAxisPos));
			if (dAngleVet > PI * 0.5 + _angSnap && dAngleVet < PI + _angSnap)
			{
				ads_polar(asDblArray(ptNearAxisPos), dUcsAngle-PI, dRadCir*2.4+dTextWidth, asDblArray(ptNearAxisPos));
			}
			else
			{
				ads_polar(asDblArray(ptNearAxisPos), dUcsAngle, dRadCir*2.4+dTextWidth, asDblArray(ptNearAxisPos));
			}
			ads_polar(asDblArray(ptNearAxisPos), nAxisDirection, curve.GetLength()+2*dLenLeader, asDblArray(ptFarAxisPos));

			// 声明轴标对象，设置相关内容
			TDbAxisLabelSet *pNewAxisDim = new TDbAxisLabelSet;
			pNewAxisDim->SetTextStyleId(InitTextStyle(TS_AXIS));
			pNewAxisDim->SetTextLayerId(InitLayer(LAY_AXIS_TEXT, FALSE));
			pNewAxisDim->SetLayoutRotation(dUcsAngle);
			pNewAxisDim->AddAxis(XCurveSegment(ptNearAxisPos, ptFarAxisPos, 0.0, LS_FINITE), FALSE, csEnfAxis);

			pNewAxisDim->SetLeaderLen(0, 0.0, TRUE);
			pNewAxisDim->SetLeaderLen(1, 0.0, TRUE);
			ASSERT(pNewAxisDim->IsValid());
			pNewAxisDim->SetSortAuto(FALSE);
			pNewAxisDim->HideSide(1);
			pNewAxisDim->AddToMSpace(Adesk::kTrue);

			continue;
		}

		// 文字类多轴号
		CString csNextText = dlg.GetOtherAxis();
		if (csNextText.IsEmpty()) // 文字部分为空
		{
			continue;
		}

		TDbText *pText = new TDbText();
		pText->SetStyleId(InitTextStyle(TS_AXIS));
		pText->SetHeight(dTextHeight, FALSE);
		pText->SetLayoutRotation(dUcsAngle);
		pText->SetText(csNextText);
		pText->SetAlignment(nAlign);
		pText->SetLocation(ptTextPos);

		pText->setLayer(InitLayer(_T("0")));

		// modify by xly on 110316 设置文字的图层在轴号的文字图层
		//pText->AddToMSpace(Adesk::kTrue);
		AcDbObjectId id = pText->AddToMSpace(Adesk::kTrue);
		if (Acad::eOk ==acdbOpenObject(pText, id,AcDb::kForWrite))
		{
			pText->setLayer(InitLayer(LAY_AXIS_TEXT, FALSE));
			pText->close();
		}
	}
}


///////////////////////////////////////////////////////////////////////////////////
// 手动标注
#if 0
/////////////////////////////////////////////////////////
// Command: 驱动轴网
void DriveAxis()
{
    PickSet ss(SS_FREE);
    adsout << _T("\n请选择参加驱动的轴网及相关的对象!");
    if (ss.Get()!=RTNORM)
	{
        return;
	}
    
    Entity entDim;
    XPoint ptPick;
    RBList mask(RTDXF0, _T("DIMENSION"), NULL), maskAxisNo(RTDXF0, _T("INSERT"), 2, _T("_AXISO*"), NULL);
    int nRetCode=entDim.FilterSelect(_T("\n请选择第二道尺寸(点取驱动的一侧): "), mask, ptPick);
    if (nRetCode!=RTNORM) return;
    do
	{
        if (nRetCode!=RTNORM && nRetCode!=RTKWORD)
		{
            break;
		}
        if (nRetCode == RTKWORD)
		{
            SHads_command(RTSTR, _T(".UNDO"), RTSTR, _T("BACK"), RTNONE);
            continue;
        }
		
        int nDimType;
        entDim.GetData(70, &nDimType);
        ASSERT(ADS>12);
        nDimType &= ~(32+128);
        if (nDimType!=0 && nDimType!=1 && nDimType!=5)
		{ 
            adsout << _T("\n请正确选择标注类型!");
            continue;
        }
		
        XPoint ptLimStart, ptLimEnd, ptTextBaseline, ptArcCen;
        if (nDimType == 5)
		{
            entDim.GetData(15, &ptArcCen);
		}
		
        entDim.GetData(13, &ptLimStart); 
        entDim.GetData(14, &ptLimEnd);
        entDim.GetData(10, &ptTextBaseline);
        double nDimDirection=0.0;
        if (nDimType == 0)  //Rotate,Horizontal,Vertical
		{
			entDim.GetData(50, &nDimDirection);
        }
		else if (nDimType == 1)
		{
			nDimDirection = ads_angle(ptLimStart, ptLimEnd);
        }
		
        XCurveSegment cvTextBase;
        int nRetCode=0;
        AcGeMatrix3d mat;
        XVector3D vtMove;
        if (nDimType == 5)
		{
            cvTextBase=XArc(ptArcCen, ads_distance(ptArcCen, ptTextBaseline),
							ads_angle(ptArcCen, ptLimStart), ads_angle(ptArcCen, ptLimEnd));
            XString sTextDim;
            entDim.GetData(1, (TCHAR *)sTextDim);
            if (!sTextDim)
			{
                double nAngle=cvTextBase.bulge*180/PI;
                nRetCode=GetReal(_T("\n输入新的夹角"), nAngle, RSG_NONEG|RSG_NOZERO);
                if (nRetCode == RTNORM)
				{
                    double nRot=nAngle*PI/180-cvTextBase.bulge;
                    mat.setToRotation(nRot, AcGeVector3d(0,0,1), ptArcCen);
                }
            } 
			else 
			{
                adsout << _T("\n只能对角度标注进行驱动,不能对弧长标注进行驱动!");
                continue;
            }
        } 
		else 
		{
            cvTextBase=XLine(ptTextBaseline, nDimDirection);
            XPoint ptLimS, ptLimE;
            cvTextBase.ProjectToMe(ptLimStart, ptLimS);
            cvTextBase.ProjectToMe(ptLimEnd, ptLimE);
            cvTextBase.SetPoints(ptLimS, ptLimE);
			
            XPoint ptBase = cvTextBase.FarPoint(ptPick);
            XPoint ptDrive = cvTextBase.NearPoint(ptPick);
            double nNewDist=cvTextBase.Length();
            nRetCode = XGetDist(ptBase, _T("\n请输入新的距离"), nNewDist, RSG_NONEG);
			
            XPoint ptDest;
            ads_polar(ptBase, ads_angle(ptBase, ptDrive), nNewDist, ptDest);
            vtMove = ptDest - ptDrive; //移动的位移
            AcGeVector3d vtOffset(vtMove.x, vtMove.y, vtMove.z);
            mat.setToTranslation(vtOffset);
        }
		
        if (nRetCode == RTCAN) 
		{
            break;
		}
        if (nRetCode == RTNORM) 
		{
            SHads_command(RTSTR, _T(".UNDO"), RTSTR, _T("MARK"), RTNONE); // Make a undo mark
            XPoint ptBase = cvTextBase.FarPoint(ptPick);
            XPoint ptDrive = cvTextBase.NearPoint(ptPick);
            XLine lnDivider(ptDrive, cvTextBase.Direction(ptDrive)+PI/2.0);
            int nDrvSide=1-lnDivider.OnWhichSide(ptBase);
            long lCount=ss.Length();
            PickSet ssTransformed(SS_FREE|SS_CREATE);
            for (long lIndex=0L; lIndex<lCount; lIndex++)
			{
                Entity ent=ss[lIndex];
                if (ent.In(ssTransformed))
				{
                    continue;
				}
                BOOL bAxisNo=ent.MatchBase(maskAxisNo);
                XDbObject obj(ent, AcDb::kForWrite);
                if (!obj) continue;
                AcDbEntity &dbEnt=obj;
                if (bAxisNo)	// 轴号
				{ 
                    AcDbBlockReference *pBlock=AcDbBlockReference::cast(obj.m_pObject);
                    ASSERT(pBlock);
                    XPoint ptInsert=pBlock->position();
                    XPoint ptPrj;
                    ptInsert.Project(lnDivider, ptPrj);
                    if (ptInsert.Distance2d(ptPrj)<_DIST_SNAP || lnDivider.OnWhichSide(ptInsert) == nDrvSide)
					{
                        pBlock->transformBy(mat);
                    }
                    continue;
                }
				else if (dbEnt.isKindOf(TDbWall::desc()))
				{
                    TDbWall *pWall=TDbWall::cast(obj.m_pObject);
                    int nPrFlag1=pWall->startPoint&lnDivider;
                    int nPrFlag2=pWall->endPoint&lnDivider;
                    BOOL bTransForm=FALSE;
                    if (nPrFlag1!=PR_OUTSIDE && nPrFlag2!=PR_OUTSIDE) 
					{
                        bTransForm=TRUE;
					}
                    else if (nPrFlag1 == PR_OUTSIDE && nPrFlag2 == PR_OUTSIDE
							&& lnDivider.OnWhichSide(pWall->startPoint) == nDrvSide)
					{
                        bTransForm=TRUE;
					}
                    if (bTransForm)
					{
                        DStack<TDbOpening> lstOpening;
                        pWall->GetOpenings(lstOpening, AcDb::kForWrite, FALSE);
                        for (int k=0; k<lstOpening.Length(); k++)
						{
                            TDbOpening *pOp=lstOpening[k];
                            Entity entOp;
                            VERIFY(acdbGetAdsName(entOp.name, pOp->objectId()) == Acad::eOk);
                            if (!entOp.In(ssTransformed))
							{
                                pOp->transformBy(mat);
                                ssTransformed += entOp;
                            }
                            pOp->close();				
                        }
                        pWall->transformBy(mat);
                        continue;
                    } 
                    /*
                    TDbOpening *pWin=TDbOpening::cast(obj.m_pObject);
                    ASSERT(pWin);
                    XPoint ptInsert=pWin->GetLocation();
                    XPoint ptPrj;
                    ptInsert.Project(lnDivider, ptPrj);
                    if (ptInsert.Distance2d(ptPrj)<_DIST_SNAP ||
					CT_IsExactSameDrt(ads_angle(ptBase, ptDrive), ads_angle(ptPrj, ptInsert), _angSnap)) {
					pWin->transformBy(mat);
				}*/
                }
				else if (dbEnt.isKindOf(TDbColumn::desc()))
				{
                    TDbColumn *pColu=TDbColumn::cast(obj.m_pObject);
                    ASSERT(pColu);
                    XPoly2D polyOutline=pColu->GetOutlinePoly();
                    polyOutline.SetElevation(lnDivider.StartPoint().z);
                    BOOL bIntsect=FALSE;
                    for (int n=0; n<polyOutline.TotalSegments();n++)
					{
                        XCurveSegment seg;
                        polyOutline.Nth(n, seg);
                        seg.flag=LS_FINITE;
                        if (seg.Intersection(lnDivider, XPoint(), XPoint()))
						{
                            bIntsect=TRUE;
                            break;
                        }
                    }
                    BOOL bDrive=bIntsect;
                    if (!bIntsect)
					{
                        XPoint ptCen, ptPrj;
                        polyOutline.Center(ptCen);
                        ptCen.Project(lnDivider, ptPrj);
                        bDrive=CT_IsExactSameDrt(ads_angle(ptBase, ptDrive), ads_angle(ptPrj, ptCen), _angSnap); 
                    }
                    if (bDrive)
					{
                        pColu->transformBy(mat);
                        continue;
                    }
                } 
				
                AcGePoint3dArray ptStretchArray;
                Acad::ErrorStatus es = dbEnt.getStretchPoints(ptStretchArray);
                if (es == Acad::eOk)
				{
                    long nLenOfArray=ptStretchArray.length();
                    AcDbIntArray indices;
                    for (long i=0L; i<nLenOfArray; i++)
					{
                        XPoint ptStretch = ptStretchArray[i];
                        XPoint ptPrj;
                        ptStretch.Project(lnDivider, ptPrj);
                        if (ads_distance(ptStretch, ptPrj)<_DIST_SNAP || lnDivider.OnWhichSide(ptStretch) == nDrvSide)
						{
                            if (nDimType == 5)
							{
                                AcDbIntArray indices0;
                                indices0.append(i);
                                XPoint ptDest=ptStretch;
                                ((AcGePoint3d &)ptDest).transformBy(mat);
                                XVector3D vtOff=ptDest-ptStretch;
                                dbEnt.moveStretchPointsAt(indices0,vtOff);
                            }
							else
							{
                                indices.append(i);
							}
                        }
                    }
                    if (nDimType!=5)
					{
                        dbEnt.moveStretchPointsAt(indices,vtMove);
					}
                }
            }
        }
    }
	while (ads_initget(0, _T("U"))
		&& (nRetCode=entDim.FilterSelect(_T("\n回退(U)/请选择第二道尺寸标注(点取驱动的一侧): "), mask, ptPick)));
}

#endif

// add by xlc on 070730
// 线对齐
void AlignLine(PickSet ss,	//[in]需对齐的实体
			   Entity en)	//[in]对齐边界
{
	OPENOBJ_BEGIN(en, AcDb::kForRead, AcDbLine, pLine);
	if (pLine != NULL)
	{
		for (long i=0;i<ss.Length();i++)
		{
			AcGePoint3d ptTmp;
			Entity ent=ss[i];
			OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbLine, pLineNew);

			if (pLineNew)
			{
				AcGePoint3dArray ptInt;
				pLineNew->intersectWith(pLine,AcDb::kExtendThis,ptInt);
				if (ptInt.length()>0)//修改线端点
				{
					pLineNew->upgradeOpen();
					if (pLineNew->endPoint().distanceTo(ptInt[0])
						<= pLineNew->startPoint().distanceTo(ptInt[0]))
					{
						pLineNew->setEndPoint(ptInt[0]);
					}
					else
					{
						pLineNew->setStartPoint(ptInt[0]);
					}
				}
			}
			OPENOBJ_END();
		}
	}
	OPENOBJ_END();
}

// add by xlc on 070730
// 轴线对齐
// ss [in]要对齐的轴线
void AlignAxis(PickSet ss)
{
	if (ss.Length() <= 1)
	{
		return;
	}

	//轴线分组
	CArray<PickSet,PickSet> ssArray;
	PickSet ssTmp(SS_CREATE);
	ssTmp += ss[0L];
	ssArray.Add(ssTmp);

	for (long i = 1; i < ss.Length(); i++)
	{
		BOOL bFlag = FALSE;
		Entity ent=ss[i];
		OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbLine, pLineNew);
		if (pLineNew)
		{
			AcGeVector3d vect=pLineNew->endPoint()-pLineNew->startPoint();

			for (long j=0; j<ssArray.GetSize();j++)
			{
				PickSet eName(SS_FREE);
				eName += ssArray[j]; 

				long size=eName.Length();
				for (long k=0;k<size;k++)
				{
					Entity en = eName[k]; 
					OPENOBJ_BEGIN(en, AcDb::kForRead, AcDbLine, pLine);
					if (pLine)
					{
						AcGeVector3d dir=pLine->endPoint()-pLine->startPoint();
						if (dir.isParallelTo(vect))
						{
							ssArray[j] += ent;

							bFlag = TRUE;
							break;
						}
						else
						{
							if (j == ssArray.GetSize()-1)
							{
								PickSet sName(SS_CREATE);
								sName += ent;
								int aa=sName.Length();
								ssArray.Add(sName);

								bFlag = TRUE;
								break;
							}
						}
					}
					OPENOBJ_END();
				}
				if (bFlag)
				{
					break;
				}
			}
		}
		OPENOBJ_END();
	}

	//删除只有一条线的选择集
	for (i = 0;i < ssArray.GetSize();i++)
	{
		if (ssArray[i].Length() <= 1)
		{
			ssArray.RemoveAt(i);
			i--;
		}
	}

	//计算外包边界
	PickSet	delEnt(SS_FREE);			
	for (i = 0;i < ssArray.GetSize();i++)
	{
		int c=ssArray[i].Length();
		if (ssArray[i].Length() <= 1)
		{
			continue;
		}
		else
		{
			BOOL bFlag=FALSE;			//是否打开实体
			double rotAng=0.0;

			Entity ent=ssArray[i][0L];
			OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbLine, pLineNew);
			if (pLineNew)
			{
				AcGeVector3d vect=pLineNew->endPoint()-pLineNew->startPoint();
				rotAng = AcGeVector3d::kXAxis.angleTo(vect,AcGeVector3d::kZAxis);
				bFlag = TRUE;
			}
			OPENOBJ_END();

			if (bFlag)
			{
				ads_matrix mat,matInv;				
				XPoint().GetRotationMatrix(-rotAng,mat);
				AT_amatrix(mat,matInv);

				ssArray[i].Transform(mat);

				ads_point lowPt,upPt;
				ssArray[i]. GetExtend(lowPt, upPt);

				PickSet ssNew(SS_CREATE);
				ssNew.IncludeBegin();

				AcDbLine *line=new AcDbLine(asPnt3d(lowPt),AcGePoint3d(lowPt[0],upPt[1],lowPt[2]));
				if (line)
				{
					line->setColorIndex(6);
					AddToModelSpace(line,TRUE);
				}
				else
				{
					delete line;
				}
				AcDbLine *line2=new AcDbLine(asPnt3d(upPt),AcGePoint3d(upPt[0],lowPt[1],upPt[2]));
				if (line)
				{
					line2->setColorIndex(6);
					AddToModelSpace(line2,TRUE);
				}
				else
				{
					delete line2;
				}
				ssNew.IncludeEnd();
				ssArray[i].Transform(matInv);
				ssNew.Transform(matInv);
				delEnt += ssNew;
			}	
		}
	}

	//确定对齐边界
	for (i = 0;;i++)
	{
		Entity enSel;
		RBList rbMask2(RTDXF0, _T("LINE"), NULL);
		int stat = enSel.FilterSelect(_T("\n请选择对齐边界<退出>:"),rbMask2);
		if (stat == RTCAN || stat == RTERROR)
		{
			break;
		}
		else if (stat == RTNORM)
		{
			if (delEnt.IsInclude(enSel))
			{
				long j=0;
				for (;j<delEnt.Length();j++)
				{ 
					if (enSel == delEnt[j])
					{
						AlignLine(ssArray[j/2],enSel);
						break;
					}
				}

			}
		}
	}

	delEnt.Erase();
}



/////////////////////////////////////////////
// 命令：轴网合并
void MergeAxis()
{
	g_ssPickFirst.Free();

	PickSet ss(SS_CREATE);
	XString sLayer;
	sLayer<<_T("DOTE,")<<LAY_AXIS;
    
	RBList mask(RTDXF0, _T("LINE"), 8, (const TCHAR*)sLayer, NULL);
	int nRet = SelectEntities(_T("\n请选择需要合并对齐的轴线<退出>:"),ss,mask);
	if (nRet != RTNORM)
	{
		return;
	}
	
//	if (!RemoveDupLine(ss))
	if (!TchDupAxis::RemoveDupAxis(ss))
	{
		return;
	}
	
	PickSet ssEnt(SS_CREATE);
	ssEnt += ss;
	AlignAxis(ssEnt);
}


/*
// 对齐轴线
void AlignAxis()
{
XString sLayer;
sLayer<<_T("DOTE,")<<LAY_AXIS;
RBList mask(RTDXF0, _T("LINE"), 8, (const TCHAR*)sLayer, NULL);

  while (1)
  {
		PickSet ss(SS_FREE);	
		int nRet = SelectEntities(_T("\n选择要对齐的轴线<退出>:"),ss,mask);
		if (nRet == RTCAN||nRet == RTNONE||nRet == RTERROR)
		break;
		else if (nRet != RTNORM)
		continue;
		
		  if (ss.Length() < 1)
		  continue;
		  
			//确定对齐边界
			XPoint ptStart,ptEnd;
			while (1)
			{
			nRet = ads_getpoint(NULL, _T("\n请输入轴线对齐边界线起点<退出>:"), ptStart);
			if (nRet == RTCAN||nRet == RTNONE)
			return;
			else if (nRet != RTNORM)
			continue;
			else
			{
			while (1)
			{
			nRet = ads_getpoint(ptStart, _T("\n请输入轴线对齐边界线终点<退出>:"), ptEnd);
			if (nRet == RTCAN||nRet == RTNONE)
			return;
			else if (nRet != RTNORM)
			continue;
			else
			break;
			}
			break;
			}
			}
			
			  if (ptStart.Distance(ptEnd) < 1.0E-6)
			  {
			  adsout<<_T("\n无法进行操作!");
			  return;
			  }
			  
				AcGeVector3d vect=ptEnd.AsAcGePoint3d() - ptStart.AsAcGePoint3d();
				vect.normalize();
				
				  AcDbLine *pLine=new AcDbLine(ptStart.AsAcGePoint3d()+vect*100000.0,ptStart.AsAcGePoint3d()-vect*100000.0);
				  if (pLine)
				  {
				  AddToModelSpace(pLine,FALSE);
				  pLine->downgradeOpen();
				  
					for (long i=0;i<ss.Length();i++)
					{
					AcGePoint3d ptTmp;
					Entity ent=ss[i];
					OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbLine, pLineNew);
					
					  if (pLineNew)
					  {
					  AcGePoint3dArray ptInt;
					  pLineNew->intersectWith(pLine,AcDb::kExtendBoth,ptInt);
					  if (ptInt.length()>0)//修改线端点
					  {
					  pLineNew->upgradeOpen();
					  if (pLineNew->endPoint().distanceTo(ptInt[0])
					  <= pLineNew->startPoint().distanceTo(ptInt[0]))
					  {
					  pLineNew->setEndPoint(ptInt[0]);
					  }
					  else
					  {
					  pLineNew->setStartPoint(ptInt[0]);
					  }
					  }
					  }
					  OPENOBJ_END();
					  }
					  
						pLine->upgradeOpen();
						pLine->erase(TRUE);
						pLine->close();
						}
						else
						{
						delete pLine;
						}
						}
						}
*/

// 从当前图层标准文件LAYERDEF.DAT中，获取“轴线”图层名
CString GetAxisLayerName()
{
	// 当前图层标准文件名
	CString csFileName = _T("layerdef.dat");

	// Zyu modify on 100730，适应64位平台的文件夹名称变化
	// 完整路径
	//CString csFullPath = g_sAppPath;
	//csFullPath = csFullPath.Left(csFullPath.GetLength() - 7) + _T("\\sys\\") + csFileName;
	CString csFullPath = g_sDwbPath;
	csFullPath = csFullPath.Left(csFullPath.GetLength() - 5) + _T("\\sys\\") + csFileName;

	// “轴线”图层名
	CString csName;

	CStdioFile file;
	if (!file.Open(csFullPath, CFile::modeRead))
	{
		acutPrintf(CString(_T("\n打开文件 \"")) + csFullPath + _T("\" 失败!"));
		return csName;
	}

	CString sString;
	while (file.ReadString(sString)) // 逐行读取
	{
		TCHAR sKey[256] = _T("");
		TCHAR sName[256] = _T("");
		int nColor = 0;
		TCHAR sLineType[256] = _T("");
		TCHAR sNote[256] = _T("");
		_stscanf(sString, _T("%s%s%d%s%s"), sKey, sName, &nColor, sLineType, sNote);

		if (_tcscmp(sKey, _T("轴线")) != 0)
		{
			continue;
		}

		if (_tcscmp(sName, _T("")) == 0)
		{
			continue;
		}

		csName = sName; // 获取图层名称
		break;
    }

	file.Close();

	if (csName.IsEmpty())
	{
		acutPrintf(_T("\n获取轴线图层名称失败!"));
	}
	return csName;
}

// sg add 100511，增加对外部参照图纸的支持
void GetAllAxisLayerName(const CString &csLayerName, CStringArray &aryNames)
{
	aryNames.Add(csLayerName);	// 不存在外部参照图纸

	// 获取所有图层名称
	XSymbolList lstLayer(_T("LAYER"));

	// 注：CAD里的外部参照图层，固定使用“|”，暂时写死
	CString csFind = _T("|");
	csFind += csLayerName;

	// sg add 100811，追加需求，CAD里的外部参照图层，还有可能使用“$*$”符号
	CString csFind2 = _T("$");
	csFind2 += csLayerName;

	int nLength = lstLayer.Length();
	for (int i=0; i<nLength; i++)
	{
		CString csLayer = lstLayer[i];
		if (csLayer.Find(csFind, 0) > -1) // 判断是否存在外部参照图纸
		{
			aryNames.Add(csLayer);
			continue;
		}

		// sg add 100811，支持“$*$”类符号的外部参照图纸
		// 注：有可能出现“轴网|$0$DOTE”和“$0$DOTE”两类情况，因此，只需要判断“$DOTE”即可，但有误差
		if (csLayer.Find(csFind2, 0) > -1)
		{
			aryNames.Add(csLayer);
			continue;
		}
	}
}

/////////////////////////////////////////////
// sg add 091223，新增命令：轴改线型
void Axis2Dote()
{
	// 获取轴线图层名称
	CString csLayerName = GetAxisLayerName();
	if (csLayerName.IsEmpty())
	{
		return;
	}

	// 获取线型ID
	AcDbObjectId idDote = InitLineType(_T("DOTE")),
		idContinuous = InitLineType(_T("CONTINUOUS"));
	if (idDote.isNull() || !idDote.isValid() || idContinuous.isNull() || !idContinuous.isValid())
	{
		acutPrintf(_T("\n创建线型失败! 请确认Acad.lin中包含指定线型!"));
		return;
	}

	// 获得所有正确的图层名
	CStringArray aryLayers;
	GetAllAxisLayerName(csLayerName, aryLayers);

	bool bFlag	= true;	// 判断是否所有图层名都不包含	
	CStringArray aryDotes, aryContinuous;

	// 获取轴线图层ID
	// Zyu modify on 100726，去掉编译警告
	//int nLength = aryLayers.GetSize(),
	//	i(0);
	int nLength = (int)aryLayers.GetSize(),
		i(0);
	for (i=0; i<nLength; i++)
	{
		csLayerName = aryLayers.GetAt(i);

		AcDbObjectId idLayer = GetLayerIdFromString(csLayerName);
		if (idLayer.isNull() || !idLayer.isValid())
		{
			continue;
		}


		OPENOBJ_BEGIN(idLayer, AcDb::kForRead, AcDbLayerTableRecord, pLayer);
		if (pLayer == NULL)
		{
			continue;
		}
		// 获取当前线型名称
		AcDbObjectId idCurType = pLayer->linetypeObjectId();

		// modify by xly on 110303 获得线型的名称
		//if (idCurType == idDote)
		//{
		//	aryContinuous.Add(csLayerName); // 将变成CONTINUOUS线形
		//}
		//else
		//{
		//	aryDotes.Add(csLayerName); // 将变成DOTE线形
		//}	
		
		OPENOBJ_BEGIN(idCurType, AcDb::kForRead, AcDbLinetypeTableRecord, pLineType);
		if (pLineType)
		{
			const TCHAR* sLineType = NULL;
			pLineType->getName(sLineType);
			CString csName = sLineType;
			
			if (csName.Find(_T("DOTE"))>-1)
			{
				aryContinuous.Add(csLayerName); // 将变成CONTINUOUS线形
			}
			else
			{
				aryDotes.Add(csLayerName); // 将变成DOTE线形
			}
		}
		OPENOBJ_END();		

		bFlag = false;
		OPENOBJ_END();
	}

	if (bFlag)
	{
		acutPrintf(_T("\n请确认轴线层与当前图层标准一致!"));
		return;
	}

	// Zyu modify on 100726，强制转换，去除编译警告
	//nLength = aryContinuous.GetSize();
	nLength = (int)aryContinuous.GetSize();
	if (nLength > 0)
	{
		csLayerName = aryContinuous.GetAt(0);
		for (i=1; i<nLength; i++)
		{
			csLayerName += _T(",");
			csLayerName += aryContinuous.GetAt(i);
		}

		SHads_command(RTSTR, _T("-layer"), RTSTR, _T("l"), RTSTR, _T("CONTINUOUS"), RTSTR, csLayerName, RTSTR, _T(""), RTNONE);
	}

	// Zyu modify on 100726，强制转换，去除编译警告
	//nLength = aryDotes.GetSize();
	nLength = (int)aryDotes.GetSize();
	if (nLength > 0)
	{
		csLayerName = aryDotes.GetAt(0);
		for (i=1; i<nLength; i++)
		{
			csLayerName += _T(",");
			csLayerName += aryDotes.GetAt(i);
		}

		SHads_command(RTSTR, _T("-layer"), RTSTR, _T("l"), RTSTR, _T("DOTE"), RTSTR, csLayerName, RTSTR, _T(""), RTNONE);
	}
}



/////////////////////////////////////////////
// [2010-4-20 wubo] 新增命令：轴号隐现
void ShowAndHideAxisDim()
{
	static bool s_bHideAxisDim = true;		// 保存是否“隐藏轴号”
	static bool s_bSingleSideDim = true;	// 保存是否“单侧操作”

	// 所有的轴标集实体都显示隐藏的轴标
	SetShowHiddenAxisLable(true);

	TADSGePoint3d ptStart;
	TADSGePoint3d ptEnd;
	CString sPrompt;

	//add by lgy 20120214	9.0将所有隐藏的轴号都能通过轴号隐现显示出来
	BOOL bShow = TRUE;	//由整侧不显示改为整侧中每一个轴号都不显示

	while (true)
	{
		// 生成提示字符串，如：
		// 请选择需隐藏的轴号或 [显示轴号(F)/设为双侧操作(Q), 当前: 单侧隐藏] <退出>:
		sPrompt = _T("\n请选择需");
		sPrompt += s_bHideAxisDim ? _T("隐藏") : _T("显示");
		sPrompt += _T("的轴号或 [");
		sPrompt += s_bHideAxisDim ? _T("显示") : _T("隐藏");
		sPrompt += _T("轴号(F)/设为");
		sPrompt += s_bSingleSideDim ? _T("双侧") : _T("单侧");
		sPrompt += _T("操作(Q), 当前: ");
		sPrompt += s_bSingleSideDim ? _T("单侧"):  _T("双侧");
		sPrompt += s_bHideAxisDim ? _T("隐藏") : _T("显示");
		sPrompt += _T("] <退出>:");

		int iRet = 0;
		INITGET_BEG(0, _T("F Q"));
		iRet = acedGetPoint(NULL, sPrompt, ptStart);
		INITGET_END();
		if (iRet == RTKWORD)
		{
			TCHAR szKey[132];
			if (acedGetInput(szKey) != RTNORM)
			{
				continue;
			}
			
			if (szKey[0] == _T('F') || szKey[0] == _T('f'))
			{
				s_bHideAxisDim = !s_bHideAxisDim;
			}
			else if (szKey[0] == _T('Q') || szKey[0] == _T('q'))
			{
				s_bSingleSideDim = !s_bSingleSideDim;
			}

			continue;
		}
		else if (iRet == RTNORM)
		{
			if (GetCornerPoint(ptStart, NULL, ptEnd) != RTNORM)
			{
				continue;
			}

			// 选择框选范围中的TDbAxisLabelSet对象
			TGGePoly2D extentPoly = GetExtentPolyByTwoCorner(ptStart, ptEnd);
			TRBList rbRegion = extentPoly.Polygon();
			TPickEntSet ssAxisLable(SS_FREE);
			if (ssAxisLable.Get(_T("CP"), rbRegion, NULL, 
								TRBList(RTDXF0, _T("ATS_AXIS_LABEL"), NULL)) != RTNORM)
			{
				continue;
			}

			extentPoly.TransUCS(Groups(1), Groups(0));

			long num = ssAxisLable.Length();
			for (long i = 0; i < num; i++)
			{
				OPENOBJ_BEGIN(ssAxisLable[i], AcDb::kForWrite, TDbAxisLabelSet, pSet);
				if (pSet == NULL)
				{
					continue;
				}
	
				//add by lgy 20120214	9.0将所有隐藏的轴号都能通过轴号隐现显示出来
				int iSide = -1;
				if(pSet->GetHideSide() == ANF_HIDESIDE1)
				{
					iSide = 0;
				}
				else if (pSet->GetHideSide() == ANF_HIDESIDE2)
				{
					iSide = 1;
				}

				int iAxisCount = pSet->GetAxisNum();
				for (int j = 0; j < iAxisCount; j++)
				{
					for (int k = 0; k <= 1; k++)
					{
						// 对于框选范围中的每个TDbAxisLabelSet对象，
						// 判断其中的每个Label是否在框选范围内
						TADSGePoint3d ptLabelCenter = pSet->GetLabelCenter(j, k);
						int iRelativePosition = ptLabelCenter & extentPoly;
						// 如果Label在框选范围内，则进行相应的显示或隐藏操作
						if (iRelativePosition != PR_OUTSIDE)
						{
							//add by lgy 20120214	9.0将所有隐藏的轴号都能通过轴号隐现显示出来
							if ((iSide == k)&&!s_bHideAxisDim&&bShow)
							{
								pSet->HideSide(k, FALSE);
								for (int m = 0; m < iAxisCount; m++)
								{
									pSet->HideAxisLabel(m, k, TRUE);
								}
								bShow = FALSE;
							}

							// 单侧操作情况下，只设置本侧
							if (s_bSingleSideDim)
							{
								pSet->HideAxisLabel(j, k, s_bHideAxisDim);
							}
							// 双侧操作情况下，设置两侧
							else
							{
								pSet->HideAxisLabel(j, 0, s_bHideAxisDim);
								pSet->HideAxisLabel(j, 1, s_bHideAxisDim);
							}
						}
					}
				}
				OPENOBJ_END();
			}
		}
		else
		{
			break;
		}
	}

	// 所有的轴标集实体都不显示隐藏的轴标
	SetShowHiddenAxisLable(false);
}



// 判断轴号的主附
bool IsMajorNo(CString csLable)
{
	int iIndex = csLable.Find(_T("/"));
	if (iIndex>-1)
	{
		return true;
	}
	return false;
}

// add by xly on 10415 查找第一个非自己的主轴号
int FindMajor(TDbAxisLabelSet *pSet, int nIndex)
{
	int i =0;
	CString csLabel;
	int iLen = pSet->GetAxisNum();
	for (i = 0; i<iLen; i++)
	{
		csLabel = pSet->GetLabel(i);
		if (nIndex>-1)
		{
			if(!IsMajorNo(csLabel)&&i!=nIndex)
			{
				return i;
			}
		}
		else
		{
			if(!IsMajorNo(csLabel))
			{
				return i;
			}
		}
	}
	return -1;
}
// 查找轴网中第一个主轴号，返回主轴号的位置
int FindMajor(TDbAxisLabelSet *pSet)
{
	int i =0;
	CString csLabel;
	int iLen = pSet->GetAxisNum();
	for (i = 0; i<iLen; i++)
	{
		csLabel = pSet->GetLabel(i);
		if(!IsMajorNo(csLabel))
		{
			return i;
		}
	}
	return -1;
}

/////////////////////////////////////////////
// 命令：主附转换
void ExchangeAxisNo()
{
	static bool s_bM2AAxisDim = true;		// 保存是否“主轴号变附加轴号”
	static bool s_bReAAxisDim = true;		// 保存是否“重排轴号”

	// sg add 100521，进入命令后，临时显示全部隐藏轴号
	SetShowHiddenAxisLable(true);

	int nRet = 0;
	CString csPrompt;
	TADSGePoint3d ptStart, ptEnd;

	while (true)
	{
		// 生成提示字符串
		// 请选择需主号变附的轴号或[附号变主(F)/设为不重排(Q), 当前: 重排]<退出>:
		csPrompt = _T("\n请选择需");
		csPrompt += s_bM2AAxisDim ? _T("主号变附") : _T("附号变主");
		csPrompt += _T("的轴号或 [");
		csPrompt += s_bM2AAxisDim ? _T("附号变主") : _T("主号变附");
		csPrompt += _T("(F)/设为");
		csPrompt += s_bReAAxisDim ? _T("不重排") : _T("重排");
		csPrompt += _T("(Q), 当前: ");
		csPrompt += s_bReAAxisDim ? _T("重排") : _T("不重排");
		csPrompt += _T("] <退出>:");

		INITGET_BEG(0, _T("F Q"));
		nRet = acedGetPoint(NULL, csPrompt, ptStart);
		INITGET_END();
		if (nRet == RTKWORD) // 出现关键字
		{
			TCHAR szKey[132];
			if (acedGetInput(szKey) != RTNORM)
			{
				continue;
			}

			if (szKey[0] == _T('F') || szKey[0] == _T('f')) // 是否“主轴号变附加轴号”
			{
				s_bM2AAxisDim = !s_bM2AAxisDim;
			}
			else if (szKey[0] == _T('Q') || szKey[0] == _T('q')) // 是否“重排轴号”
			{
				s_bReAAxisDim = !s_bReAAxisDim;
			}

			continue;
		}

		if (nRet != RTNORM) // 退出
		{
			break;
		}

		// 获得框选范围
		if (GetCornerPoint(ptStart, NULL, ptEnd) != RTNORM)
		{
			continue;
		}

		TGGePoly2D extentPoly = GetExtentPolyByTwoCorner(ptStart, ptEnd);
		TRBList rbRegion = extentPoly.Polygon();

		// 在框选范围中，过滤TDbAxisLabelSet对象
		TPickEntSet ssAxisLable(SS_FREE);
		if (ssAxisLable.Get(_T("CP"), rbRegion, NULL, TRBList(RTDXF0, _T("ATS_AXIS_LABEL"), NULL)) != RTNORM)
		{
			continue;
		}
		extentPoly.TransUCS(Groups(1), Groups(0));
		
		long lLabelsCount = ssAxisLable.Length();
		if (lLabelsCount < 1)
		{
			continue; // 框选范围内，没有TDbAxisLabelSet对象
		}

		// 对框选范围中的每个TDbAxisLabelSet对象，进行检查、判断，确定是否在框选范围内
		for (long l = 0; l < lLabelsCount; l++)
		{
			OPENOBJ_BEGIN(ssAxisLable[l], AcDb::kForRead, TDbAxisLabelSet, pSet);
			if (pSet == NULL)
			{
				continue;
			}
			
			int nSide = pSet->GetVisSides(); // 获取标注侧
			if (nSide == 0)
			{
				continue; // 双侧都不标注
			}

			int nIndex = 0,
				nTmpIndex = 0,
				nAxisCount = pSet->GetAxisNum();	// 轴号数量
			AcDbIntArray aryAxisInSel;				// 保存选择到、需要变化的轴号索引

			if (nSide == 1 || nSide == 3) // 只标第0侧，或双侧标注
			{
				TADSGePoint3d ptLabelCenter;
				for (nIndex = 0; nIndex < nAxisCount; nIndex++)
				{
					ptLabelCenter = pSet->GetLabelCenter(nIndex, 0);	// 获得标注点位置
					if ((ptLabelCenter&extentPoly) != PR_OUTSIDE)		// 判断Label点是否在框选范围内
					{
						if (!aryAxisInSel.find(nIndex, nTmpIndex))
						{
							aryAxisInSel.append(nIndex); // 找不到就添加
						}
					}
				}
			}

			if (nSide == 2 || nSide == 3) // 只标第1侧，或双侧标注
			{
				TADSGePoint3d ptLabelCenter;
				for (nIndex = 0; nIndex < nAxisCount; nIndex++)
				{
					ptLabelCenter = pSet->GetLabelCenter(nIndex, 1);	// 获得标注点位置
					if ((ptLabelCenter&extentPoly) != PR_OUTSIDE)		// 判断Label点是否在框选范围内
					{
						if (!aryAxisInSel.find(nIndex, nTmpIndex))
						{
							aryAxisInSel.append(nIndex); // 找不到就添加
						}
					}
				}
			}

			// 获取编号规则，变前项还是变后项
			BOOL bChangePre = pSet->IsChangePreNum();

			// modify by xly on 100816 解决选取第一个轴号为空时的错误处理，以及选择的第一个轴号是首个轴号时重排问题
			//int nSelLength = aryAxisInSel.length(); // 保存总共选择了多少个轴号
			//for (nIndex = 0; nIndex < nSelLength; nIndex++)
			//{
			//	nTmpIndex = aryAxisInSel[nIndex];
			//	
			//	if (nTmpIndex == 0) // 获取到的轴号为第1根轴号，则获取其后面的一位内容，进行推导
			//	{
			//		if (nAxisCount > 1) // 多轴号
			//		{
			//			
			//			CString csLable = pSet->GetLabel(1);

			//			// 调用tch_kernal导出的推导轴号类，获取正确的标注内容
			//			XString csNext;
			//			XAxisNoParser parser(csLable, bChangePre);
			//			parser.GetPre(csNext, !s_bM2AAxisDim);

			//			if (pSet->upgradeOpen() == Acad::eOk)
			//			{
			//				pSet->SetLabel(0, csNext, s_bReAAxisDim);
			//				pSet->downgradeOpen();
			//			}
			//			
			//		}
			//		else // 单轴号
			//		{
			//		}
			//	}
			//	else // 获取到的轴号不是第1根轴号，则获取前其前面的一位内容，进行推导
			//	{	
			//		 CString csLable = pSet->GetLabel(nTmpIndex - 1);

			//		// 调用tch_kernal导出的推导轴号类，获取正确的标注内容
			//		XString csNext;
			//		XAxisNoParser parser(csLable, bChangePre);
			//		parser.GetNext(csNext, !s_bM2AAxisDim);

			//		if (pSet->upgradeOpen() == Acad::eOk)
			//		{
			//			pSet->SetLabel(nTmpIndex, csNext, s_bReAAxisDim);
			//			pSet->downgradeOpen();
			//		}
			//	}
			//}

			
			int nSelLength = aryAxisInSel.length(); // 保存总共选择了多少个轴号
			if (nSelLength<1)
			{
				//return;
				continue;
			}
			
			CString csLable, csNextLable;// 定义标记首根轴号，下一根轴号
			bool bAxisStyle;			 // 定义标记轴号是否为分区轴号

			// 获得第一个选择到的轴标
			int iFirstNum = aryAxisInSel[0];

			// 选择到的第一个轴标是首个轴标
			if (iFirstNum<1)
			{
				// 查找主轴号
				nIndex = FindMajor(pSet);
				CString csLableFir = pSet->GetLabel(nIndex);

				// modi fy by xly on 110414 修改带有首个轴号的主附变化
				for (nIndex = 0; nIndex < nSelLength; nIndex++)
				{
					// 判断首跟轴号是否为空
					csLable = pSet->GetLabel(nIndex);
					if (csLable.IsEmpty())
					{
						continue;
					}

					// 判断首根是否是附加轴号
					bAxisStyle = IsMajorNo(csLable);
					if (bAxisStyle)// 首根轴号是附加轴号
					{
						if (s_bM2AAxisDim)// 主变附
						{
							// 框选轴号是附加轴号，做主附转换重排，调整附加轴号顺序
							if (s_bReAAxisDim)
							{
								int nPos = csLable.Find(_T('/'));
								CString csOld = csLable.Right(csLable.GetLength()-nPos);
								csNextLable.Format(_T("%d"),nSelLength-nIndex);
								csLable = csNextLable;
								csLable += csOld;

								if (pSet->upgradeOpen() == Acad::eOk)
								{
									pSet->SetLabel(nIndex, csLable, FALSE);
									pSet->downgradeOpen();
								}

							}
							
							continue;
						}

						XAxisNoParser::GetRegion(csNextLable);
					
						// 修改轴号
						int unicode = (int)csLable.GetAt(csLable.GetLength()-1);
						if (nIndex>0)
						{
							unicode++;
						}
						csLable.SetAt(csLable.GetLength()-1,(TCHAR)unicode);
						int nPos = csLable.Find(_T('/'));
						CString csNewLable = csLable.Right(csLable.GetLength()-nPos-1);
						csNewLable.Remove(_T('0'));
						csLable = csNewLable;
				
						if (pSet->upgradeOpen() == Acad::eOk)
						{
							pSet->SetLabel(nIndex, csLable, s_bReAAxisDim);
							// sg add 110614，由于底层限制，只能处理手工指定轴号为特殊的首个主轴号前的附加轴号
							pSet->SetPreFirstAttachLabel(nIndex, FALSE);
							pSet->downgradeOpen();
						}	

					}
					else// 轴号是主轴号
					{
						if (!s_bM2AAxisDim)// 附变主
						{
							continue;
						}

						// 主变附
						// 获得轴根轴的标号，判断是否有标号
						csLable = pSet->GetLabel(nIndex);
						if (csLable.IsEmpty())
						{
							continue;
						}	

						// 转化为符合的样式
						csNextLable = csLableFir;
						XAxisNoParser::GetRegion(csNextLable);

						CString csKvalue;
						if(s_bReAAxisDim)
						{
							csKvalue.Format(_T("%d"),nSelLength-nIndex);
							csLable = csKvalue;
							csLable += csNextLable;
						}
						else
						{
							csKvalue.Format(_T("%d/"),1);
							csLable = csKvalue;
							csLable += pSet->GetLabel(nIndex);
						}
		
						// 更新首个轴号的标号
						if (pSet->upgradeOpen() == Acad::eOk)
						{
							pSet->SetLabel(nIndex, csLable, s_bReAAxisDim);
							// sg add 110614，由于底层限制，只能处理手工指定轴号为特殊的首个主轴号前的附加轴号
							pSet->SetPreFirstAttachLabel(nIndex, TRUE);
							pSet->downgradeOpen();
						}
					}
				}
			}
			else// 选择到的第一个轴标不是首个轴标
			{
				for (nIndex = 0; nIndex < nSelLength; nIndex++)
				{
					// 框选到的轴号
					nTmpIndex = aryAxisInSel[nIndex];

					// 判断自己的前一个是否为空
					CString csPreSlef = pSet->GetLabel(nTmpIndex - 1);			
					if (csPreSlef.IsEmpty())
					{
						continue;
					}

					// 判断本身是否为空
					csLable = pSet->GetLabel(nTmpIndex);			
					if (csLable.IsEmpty())
					{
						continue;
					}
					
					// add by xly on 11007 增加变化判断
					if (IsMajorNo(csLable))// 附加轴号
					{
						if (s_bM2AAxisDim)// 主变附
						{
							continue;
						}
					}
					else// 主轴号
					{
						if (!s_bM2AAxisDim)// 附变主
						{
							continue;
						}
					}

					// 查找第一个主轴号的位置
					int iIndex = FindMajor(pSet);
					if (iIndex<0)// 不存在主轴号
					{
						continue;
					}

					// add by xly on 110307 框选轴号为第一个主轴号
					if (iIndex == nTmpIndex)
					{
						int nTrueFir = FindMajor(pSet,iIndex);
						if (nTrueFir<0)// 不存在主轴号
						{
							continue;
						}
						//bool bIsFenQu = XAxisNoParser::GetRegion(pSet->GetLabel(nTrueFir));
						// 更新首个轴号的标号
						if (pSet->upgradeOpen() == Acad::eOk)
						{
							// 重排时，更新主轴号前面的所有轴号
							if (s_bReAAxisDim)
							{
								int nPos = csPreSlef.Find(_T("/"));
								int nTemp = nTmpIndex+1;
								CString csTemp=_T("");
								CString csRight = csPreSlef.Right(csPreSlef.GetLength()-nPos);
								for (int i=0; i<nTmpIndex; i++)
								{
									csTemp.Format(_T("%d"),nTrueFir);
									csPreSlef = csTemp;
									csPreSlef += csRight;
									pSet->SetLabel(i,csPreSlef,FALSE);
									nTrueFir--;
								}
								csTemp.Format(_T("%d"),nTrueFir);
								csPreSlef = csTemp;
								csPreSlef += csRight;
							}
							else
							{
								csPreSlef =  pSet->GetLabel(nTmpIndex);
								CString csPre = _T("1/");
								csPre += csPreSlef;
								csPreSlef = csPre;
							}
							
							pSet->SetLabel(nTmpIndex, csPreSlef, s_bReAAxisDim);
							pSet->downgradeOpen();
						}
						continue;
					}

					// 获得第一个主轴号的轴标
					CString csMajorAxis = pSet->GetLabel(iIndex);	
					if (IsMajorNo(csPreSlef))// 判断前一个轴标是附加轴标
					{ 		
						CString csTemp;
						int iPos = csPreSlef.Find(_T("-"));
						if (XAxisNoParser::GetRegion(csMajorAxis))// 判断主轴标的样式，带分区
						{			
							if (iPos<0)// 前一个是不带分区的样式
							{
								// 将前一个轴标转化为符合的样式
								csTemp = csPreSlef.Left(csPreSlef.Find(_T("/")));
								csPreSlef = csTemp;
								csPreSlef += csMajorAxis;
							}
						}
						else// 主轴标不带分区
						{
							if (iPos>-1)// 前一个是带分区的样式
							{
								// 将前一个轴标转化为符合的样式
								csTemp = csPreSlef.Left(csPreSlef.Find(_T("-")));
								csPreSlef = csTemp;
							}
						}
					}
			
					// 调用tch_kernal导出的推导轴号类，获取正确的标注内容
					XString csNext;
					XAxisNoParser parser(csPreSlef, bChangePre);
					parser.GetNext(csNext, !s_bM2AAxisDim);
					if (pSet->upgradeOpen() == Acad::eOk)
					{
						pSet->SetLabel(nTmpIndex, csNext, s_bReAAxisDim);
						pSet->downgradeOpen();
					}
				}

			}
			OPENOBJ_END();
		}
	}

	// sg add 100521，退出命令时，恢复隐藏
	SetShowHiddenAxisLable(false);
}



/////////////////////////////////////////////
// 命令：一轴多号
// xly add 100520
void MutiAxisLabel()
{
	static bool		s_bSelectAllAxisDim = true;	// 保存是否“选中全部轴号”
	static short	s_nCloneRowNum = 1;			// 保存“复制行数”

	// add by xly on 100811 添加单、双侧创建多轴号
	static bool		s_bDoubleSide = true;		// 保存是否双侧创建多轴号

	XPushVar<int> osmode(_T("OSMODE"), 0);	// 进入命令后，临时关闭OSMODE
	SetShowHiddenAxisLable(true);			// 进入命令后，临时显示全部隐藏轴号

	int nRet(0);
	TADSGePoint3d  ptStart, ptEnd;	// 框选模式的两个点
	PickSet ssLabel(SS_FREE);		// 保存用户选中的轴号标注对象

	if (g_bIgnoreAttach)
	{
		acutPrintf(_T("\n当前: 忽略附加轴号。状态可在高级选项中修改。"));
	}
	else
	{
		acutPrintf(_T("\n当前: 不忽略附加轴号。状态可在高级选项中修改。"));
	}

	bool bFlag = true; // 标记是否需要关键字

	//	CString csPrompt = // 命令行提示
	//		s_bSelectAllAxisDim?_T("\n请选择已有轴号或[框选轴圈局部操作 (Q)] <退出>:"):_T("\n请选择已有轴号或[选中轴号整体操作 (Q)] <退出>:");
	// 命令行提示
	CString csPrompt;

	while (true)
	{
		// add by xly on 100811 添加单、双侧创建多轴号
		// 提示语的格式请选择已有轴号或[选中轴号整体操作（F）/单侧创建多号(Q)]<退出>:
		csPrompt  = _T("\n请选择已有轴号或["); // 命令行提示
		csPrompt += s_bSelectAllAxisDim?_T("框选轴圈局部操作(F)"):_T("选中轴号整体操作(F)");
		csPrompt += _T("/");
		csPrompt += s_bDoubleSide?_T("单侧创建多号(Q)"):_T("双侧创建多号(Q)");
		csPrompt += _T("]<退出>:");

		if (bFlag) // 需要提示关键字
		{
			INITGET_BEG(0, _T("F Q"));
			nRet = acedGetPoint(NULL, csPrompt, ptStart);
			INITGET_END();
		}
		else // 不需要提示关键字
		{
			// add by xly on 110316 设置提示
			csPrompt = _T("\n请选择已有轴号:");
			nRet = acedGetPoint(NULL, csPrompt, ptStart);
		}

		if (nRet == RTKWORD) // 关键字
		{
			TCHAR szKey[132];
			if (acedGetInput(szKey) != RTNORM)
			{
				continue;
			}

			// modify by xly on 100811 添加单、双侧创建多轴号
			//if (szKey[0] == _T('Q') || szKey[0] == _T('q'))
			//{
			//	s_bSelectAllAxisDim = !s_bSelectAllAxisDim;
			//	csPrompt = // 命令行提示
			//		s_bSelectAllAxisDim?_T("\n请选择已有轴号或[框选轴圈局部操作 (Q)] <退出>:"):_T("\n请选择已有轴号或[选中轴号整体操作 (Q)] <退出>:");
			//}

			if (szKey[0] == _T('F') || szKey[0] == _T('f'))// 框选还是整体
			{
				s_bSelectAllAxisDim = !s_bSelectAllAxisDim;
			}
			else if (szKey[0] == _T('Q') || szKey[0] == _T('q'))// 单侧还是双侧多轴号标注
			{
				s_bDoubleSide = !s_bDoubleSide;
			}
			continue;
		}

		if (nRet != RTNORM) // 退出或操作结束
		{
			break;
		}
		// 输入另一个点
		if (GetCornerPoint(ptStart, NULL, ptEnd) != RTNORM)
		{
			continue;
		}

		// 框选范围显示
		TGGePoly2D poly = GetExtentPolyByTwoCorner(ptStart, ptEnd);
		RBList rbRegion = poly.Polygon();

		// 框选模式选择集
		PickSet ssMouseSel(SS_FREE);
		if (ssMouseSel.Get(_T("CP"), rbRegion, NULL, RBList(RTDXF0, _T("ATS_AXIS_LABEL"), NULL)) != RTNORM)
		{
			continue;
		}
		poly.TransUCS(Groups(1), Groups(0));

		long l = 0,
			lSelLength = ssMouseSel.Length(); // 选择集的长度
		for (l = 0; l<lSelLength; l++)
		{
			Entity ent = ssMouseSel[l];
			OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbAxisLabelSet, pSet);
			if (pSet == NULL)
			{
				continue;
			}

			// 克隆实体
			TDbAxisLabelSet *pNewAxis = (TDbAxisLabelSet *)pSet->clone();

			int nSide = pNewAxis->GetVisSides(),
				nTmpIndex = 0;

			// 只对框选中的轴圈操作时，遍历实体，寻找框选到的轴号
			int iNum = 0,
				iAxisNumLength = pNewAxis->GetAxisNum();

			if (s_bSelectAllAxisDim) // 选中一个轴圈对整体操作
			{
				// add by xly on 100811 添加单、双侧创建多轴号
				if (!s_bDoubleSide)  // 单侧创建多轴号
				{
					// modify by xly on 110315 对每个轴圈的中心判断，以便准确查找
					//AcGePoint3d ptCen = pNewAxis->GetLabelCenter(0, 0);
					//if((ptCen&poly) != PR_OUTSIDE)// 选中0侧
					//{
					//	pNewAxis->HideSide(1,TRUE);
					//}
					//else						 // 选中1侧
					//{
					//	pNewAxis->HideSide(0,TRUE);
					//}
					bool bIsFir(false);
					for(iNum=0; iNum<iAxisNumLength; iNum++)
					{
						AcGePoint3d ptCen = pNewAxis->GetLabelCenter(iNum, 0);
						if((ptCen&poly) != PR_OUTSIDE)// 选中0侧
						{
							bIsFir = true;
							break;
						}
						
					}
					if (bIsFir)
					{
						pNewAxis->HideSide(1,TRUE);
					}
					else
					{
						pNewAxis->HideSide(0,TRUE);
					}
				}

				ssLabel += pNewAxis->AddToMSpace(Adesk::kFalse);
				pNewAxis->downgradeOpen();
				pNewAxis->highlight();
				pNewAxis->close();

				continue;
			}

			AcDbIntArray aryAxisInSel;

			if (nSide == 1 || nSide == 3) // 只标第0侧，或双侧标注
			{
				TADSGePoint3d ptLabelCenter;
				for (iNum = 0; iNum < iAxisNumLength; iNum++)
				{
					ptLabelCenter = pNewAxis->GetLabelCenter(iNum, 0);
					if ((ptLabelCenter&poly) != PR_OUTSIDE) // 在框选范围外
					{
						// add by xly on 100811 添加单、双侧创建多轴号
						if (!s_bDoubleSide)//  单侧创建多轴号
						{
							pNewAxis->HideSide(1,TRUE);
						}
						if (!aryAxisInSel.find(iNum, nTmpIndex)) // 找不到就添加
						{
							aryAxisInSel.append(iNum);
						}
					}
				}
			}

			if (nSide == 2 || nSide == 3) // 只标第1侧，或双侧标注
			{
				TADSGePoint3d ptLabelCenter;
				for (iNum = 0; iNum < iAxisNumLength; iNum++)
				{
					ptLabelCenter = pNewAxis->GetLabelCenter(iNum, 1);
					if ((ptLabelCenter&poly) != PR_OUTSIDE) // 在框选范围内
					{
						// add by xly on 100811 添加单、双侧创建多轴号
						if (!s_bDoubleSide)//  单侧创建多轴号
						{
							pNewAxis->HideSide(0,TRUE);
						}

						if (!aryAxisInSel.find(iNum, nTmpIndex)) // 找不到就添加
						{
							aryAxisInSel.append(iNum);
						}
					}
				}
			}

			int nTemp = 0;
			for (iNum = 0; iNum < iAxisNumLength; iNum++)
			{
				if (!aryAxisInSel.find(nTemp, nTmpIndex)) // 找不到，表示被选中，不删除
				{
					pNewAxis->RemoveLabel(iNum, FALSE);
					iAxisNumLength--;
					iNum--;
				}
				nTemp++;
			}
			ssLabel += pNewAxis->AddToMSpace(Adesk::kFalse);
			pNewAxis->downgradeOpen();
			pNewAxis->highlight();
			pNewAxis->close();
			OPENOBJ_END();
		}

		// delete by xly on 110316 提到前面设置
		//csPrompt = _T("\n请选择已有轴号:");
		bFlag = false;
	}

	long lNewAixLength = ssLabel.Length();
	if (lNewAixLength <= 0) // 没有选中的轴号，命令结束
	{
		SetShowHiddenAxisLable(false); // 退出命令时，恢复隐藏
		return;
	}

	// 等待用户输入复制排数
	int iNclone = s_nCloneRowNum;
	acedInitGet(RSG_NONEG + RSG_NOZERO, NULL); // 输入不允许0和负数

	csPrompt.Format(_T("\n请输入复制排数<%d>:"), s_nCloneRowNum);
	nRet = acedGetInt(csPrompt, &iNclone);	
	if (nRet == RTCAN)
	{
		ssLabel.Erase();
		SetShowHiddenAxisLable(false); // 退出命令时，恢复隐藏
		return;
	}
	s_nCloneRowNum = iNclone;


	// 创建新对象，并修改位置
	for (long l = 0; l<lNewAixLength; l++)
	{
		Entity ent = ssLabel[l];
		OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbAxisLabelSet, pAxisDim);
		if (pAxisDim == NULL)
		{
			continue;
		}

		int iAxisNumLength = pAxisDim->GetAxisNum();
		if (g_bIgnoreAttach) // 根据高级选项中的设置，确定是否忽略附加轴号
		{
			for (int i = 0; i < iAxisNumLength; i++)
			{
				CString csLabel = pAxisDim->GetLabel(i);
				const TCHAR *pSep = _tcschr(csLabel, _T('/'));
				if (pSep != NULL)
				{
					if (pAxisDim->upgradeOpen() == Acad::eOk)
					{
						pAxisDim->RemoveLabel(i, FALSE);
						i--;
						iAxisNumLength--;
						pAxisDim->downgradeOpen();
					}
				}
			}
		}

		if (iAxisNumLength < 1)
		{
			continue;
		}

		// 获取轴号标注位置
		XCurveSegment seg = pAxisDim->GetAxis(0);

		TADSGePoint3d ptSt = seg.GetStartPoint(),
			ptEn = seg.GetEndPoint();
		double dStartDirection = seg.IDirection(1),
			dEndDirection = seg.IDirection(0);

		// 获取标注半径、两侧引线长度
		double dRadCir = pAxisDim->GetCirRadius(FALSE),
			dStartLength = pAxisDim->GetLeaderLen(0, FALSE),
			dEndLength = pAxisDim->GetLeaderLen(1, FALSE);

		TADSGePoint3d ptNear, ptFar;

		// 生成多轴号的行数
		for (int j = 1; j<=s_nCloneRowNum; j++)
		{
			dStartLength += dRadCir * 2;
			dEndLength += dRadCir * 2;

			// 生成新轴标
			TDbAxisLabelSet *pAxisClon = (TDbAxisLabelSet *)pAxisDim->clone();


			// 获得一个轴网标注的信息，是否是圆弧轴网
			if(pAxisClon->IsArcAxisNet())
			{
				if (pAxisClon->IsArcAxis())	// 标注弧轴线
				{
					// 圆弧起始点的切线方向
					dStartDirection = seg.Direction(ptSt);
					dEndDirection = seg.Direction(ptEn);

					// 圆弧的bugle值
					double dBulge = seg.GetBulge();

					// 计算新圆弧的起始点
					acutPolar(ptSt, PI+(dStartDirection), dStartLength, ptNear);
					acutPolar(ptEn, (dEndDirection), dEndLength, ptFar);

					// 新圆弧的curve
					XCurveSegment segNewArc(ptNear,ptFar,dBulge,1);	

					pAxisClon->AddToMSpace(Adesk::kFalse);
					pAxisClon->SetFirstAxis(segNewArc);

					// 设置两册的引线长度都为0
					pAxisClon->SetLeaderLen(0, 0.0, TRUE);
					pAxisClon->SetLeaderLen(1, 0.0, TRUE);
					// sg modify 110607，根据测试反馈，如果存在拉伸情况，需要逐个修改每一个引线长度
					pAxisClon->SetLeaderLenOneByOne(0, 0, TRUE);
					pAxisClon->SetLeaderLenOneByOne(1, 0, TRUE);
					pAxisClon->close();

				}
				else						// 圆弧轴网在直线上的标注
				{
					int nSideHide(-1);
					// 只有一个的情况
					if (iAxisNumLength==1)
					{
						acutPolar(ptSt, dStartDirection, dStartLength, ptNear);
						acutPolar(ptEn, dEndDirection, dStartLength, ptFar);
						seg.SetPoints(ptNear, ptFar);

						nSideHide = pAxisDim->GetHideSide();
						if (nSideHide==4)
						{
							pAxisClon->HideSide(0,TRUE);
						}
						else if (nSideHide==8)
						{
							pAxisClon->HideSide(1,TRUE);
						}
						
						// 设置两册的引线长度都为0
						pAxisClon->SetLeaderLen(0, 0.0, TRUE);
						pAxisClon->SetLeaderLen(1, 0.0, TRUE);
						// sg modify 110607，根据测试反馈，如果存在拉伸情况，需要逐个修改每一个引线长度
						pAxisClon->SetLeaderLenOneByOne(0, 0, TRUE);
						pAxisClon->SetLeaderLenOneByOne(1, 0, TRUE);
						pAxisClon->SetFirstAxis(seg);
						pAxisClon->AddToMSpace(Adesk::kFalse);
			
						pAxisClon->close();	
					}
					else// 多于1个轴号的添加一轴多号
					{
						XCurveSegment cvSortBase; // 排序的基线

						// 保存起始轴线
						XCurveSegment curveFirst,curveFinal;
						// 获得起始轴线的信息
						int nIndex(0);
						for (int i=0;i<2;i++)
						{
							XCurveSegment segTemp = pAxisDim->GetAxis(nIndex);
							ptSt = segTemp.GetStartPoint();
							ptEn = segTemp.GetEndPoint();
							dStartDirection = segTemp.IDirection(1);
							dEndDirection = segTemp.IDirection(0);

							acutPolar(ptSt, dStartDirection, dStartLength, ptNear);
							acutPolar(ptEn, dEndDirection, dStartLength, ptFar);
							segTemp.SetPoints(ptNear, ptFar);
							nIndex = iAxisNumLength-1;
							if (i==0)
							{
								curveFirst = segTemp;
							}
							if (i==1)
							{
								curveFinal = segTemp;
							}
						}

						// 建立圆弧轴网中直线的圆弧
						XPoint ptAxisNetCen = pAxisDim->GetArcNetCenter();
						double nAng1 = ads_angle(ptAxisNetCen, curveFirst.FarPoint(ptAxisNetCen));
						double nAng2 = ads_angle(ptAxisNetCen, curveFinal.FarPoint(ptAxisNetCen));
						if (XAxisDimSet::g_AntiClockWise == FALSE)
						{
							Exchange(nAng1, nAng2);
						}
						cvSortBase = XArc(ptAxisNetCen, ptAxisNetCen.Distance2d(curveFirst.FarPoint(ptAxisNetCen)),
							nAng1, nAng2);

						// 建立排序的轴网单侧
						XAxisDimSet dimSet(&cvSortBase);
						for (i=0;i<iAxisNumLength;i++)
						{
							XCurveSegment segTemp = pAxisDim->GetAxis(i);
							ptSt = segTemp.GetStartPoint();
							ptEn = segTemp.GetEndPoint();
							dStartDirection = segTemp.IDirection(1);
							dEndDirection = segTemp.IDirection(0);

							acutPolar(ptSt, dStartDirection, dStartLength, ptNear);
							acutPolar(ptEn, dEndDirection, dEndLength, ptFar);
							segTemp.SetPoints(ptNear, ptFar);
							dimSet.Append(new XCurveSegment(segTemp));
						}
						dimSet.QuickSort(XAxisDimSet::SortFunc);

						// 创建新的轴标
						TDbAxisLabelSet *pAxisDim1 = new TDbAxisLabelSet;
						pAxisDim1->SetTextStyleId(InitTextStyle(TS_AXIS));
						pAxisDim1->SetTextLayerId(InitLayer(LAY_AXIS_TEXT, FALSE));
						pAxisDim1->ConvertFrom(dimSet,true);
						pAxisDim1->SetLayoutRotation(Ucs2Wcs(0.0));
						pAxisDim1->SetLeaderLen(0, 0.0, TRUE);
						pAxisDim1->SetLeaderLen(1, 0.0, TRUE);
						// sg modify 110607，根据测试反馈，如果存在拉伸情况，需要逐个修改每一个引线长度
						pAxisClon->SetLeaderLenOneByOne(0, 0, TRUE);
						pAxisClon->SetLeaderLenOneByOne(1, 0, TRUE);

						// 判断原有轴号的隐藏信息
						nSideHide = pAxisDim->GetHideSide();
						if (nSideHide==4)// 起始侧隐藏
						{
							pAxisDim1->HideSide(0,TRUE);
						}
						else if (nSideHide==8)// 终止侧隐藏
						{
							pAxisDim1->HideSide(1,TRUE);
						}

						
						pAxisDim1->SetLabel(0,pAxisDim->GetLabel(0),TRUE);
						
						// add by xly on 110418 解决一周多号顺时针排序不正确的问题
						if(XAxisDimSet::g_AntiClockWise==FALSE)
						{
							pAxisDim1->ReverseOrder();
						}
						pAxisDim1->AddToMSpace(Adesk::kTrue);
					}	
				}			
			}
			else						   // 直线轴网
			{	
				acutPolar(ptSt, dStartDirection, dStartLength, ptNear);
				acutPolar(ptEn, dEndDirection, dEndLength, ptFar);

				seg.SetPoints(ptNear, ptFar);

				pAxisClon->AddToMSpace(Adesk::kFalse);
				pAxisClon->SetFirstAxis(seg);

				// 设置两册的引线长度都为0
				pAxisClon->SetLeaderLen(0, 0.0, TRUE);
				pAxisClon->SetLeaderLen(1, 0.0, TRUE);
				// sg modify 110607，根据测试反馈，如果存在拉伸情况，需要逐个修改每一个引线长度
				pAxisClon->SetLeaderLenOneByOne(0, 0, TRUE);
				pAxisClon->SetLeaderLenOneByOne(1, 0, TRUE);

				pAxisClon->close();	
			}
		}
		OPENOBJ_END();
	}

	SetShowHiddenAxisLable(false); // 退出命令时，恢复隐藏
	ssLabel.Erase();
}


/////////////////////////////////////////////
// 命令：单根轴线
// sg add 110928，根据结构专业的需求，增加单根轴线的功能
void TAxislineCmd()
{
}