#include "stdafx.h"
#include "windef.h"
#include "dbmatch.h"
#include <vector>
#include "acgiutil.h"
#include "dbcfilrs.h"
#include "actrans.h"
#include "RBGroups.h"
#include "FindParser.h"
#include "AcEdInputPointMonitorEx.h"
#include "xtext.h"
#include "AecDbText.h"
#include "SubText.h"
#include "DListStack.h"
#include "adsgepoint3d.h"
#include "AcDbObjectPtr.h"
#include "ADSGePointDir2d.h"
#include "AecDbDimension.h"
#include "AecDbDimension_old.h"
#include "AecDbRadiusDim.h"
#include "PickEntSet.h"
#include "GeCurveInline.h"
#include "AecDbSymbArrow.h"
#include "AecDbSymbElevation.h"
#include "AecDbSymbSection.h"
#include "AecDbSymbNorthThumb.h"
#include "AecDbSymbDrawingIndex.h"
#include "AecDbDrawingName.h"


//extern GEOAPI int XGetCorner(const XPoint &ptCorn1, const TCHAR *pszMsg, XPoint &ptCorn2);

// add by xly On 110107 引入设置实体的图层并将实体添加到图纸中
// 
//wlw add 130529 作为两点标注时门窗的高亮使用
static EntitySet entShow;
static CString entFilter = _T("");

extern AcDbObjectId InitDimStyle(TDimStyle ds);

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

	BOOL GetEntFromPt(const AcGePoint3d& pt, LPCTSTR sDxfName, EntitySet& ent)
	{
		RBList tgMask(RTDXF0, sDxfName, NULL);
		PickEntSet ssEnts(SS_FREE);
		ADSGePoint3d pt1, pt2;
		pt1[X] = pt.x;
		pt1[Y] = pt.y;
		pt1[Z] = pt.z;
		pt1 = GlobalFunc::Wcs2Ucs(pt1);
		pt2 = pt1;
		//得到拾取框大小
		double dAperture = 50.0;//GetPickBoxWcs();
		pt1[X] -= dAperture;
		pt1[Y] += dAperture;
		pt2[X] += dAperture;
		pt2[Y] -= dAperture;
		AcDbObjectId id = AcDbObjectId::kNull;
		if (ssEnts.Get(_T("C"), pt1, pt2, tgMask) == RTNORM)
		{
			ent = ssEnts[0L];
			return TRUE;
		}
		return FALSE;
	}
}
//TUTIL_IMPEXP void SetHandCursorSelectType(LPCTSTR pszType);
//TUTIL_IMPEXP void SetHandCursorGlobalFunc::SelectEntity(EntitySet & ent);
//TUTIL_IMPEXP BOOL MouseMoveMonitorByHandCursor(MSG* msg) ;
//TUTIL_IMPEXP void StartChangeCursor();
//TUTIL_IMPEXP void EndChangeCursor();

int GetFullOsMode(int nFlagsAdd)
{
    int nOsMode=0;
    xg_getvar(_T("OSMODE"), &nOsMode);
    nOsMode &= ~0x4000;
    nOsMode |= nFlagsAdd;
    return nOsMode;
}

//数据结构，辅助计算角度标注起点和终点
typedef struct CptData
{
	AcGePoint2d ptCenter;

	AcGePoint2d ptTem;
}PTDATA,*pPTDATA;


//双层JIG通用
class TMulDimEntity : public AcDbEntity
{
public:
	TMulDimEntity() {}
	virtual ~TMulDimEntity() {}

	AecDbDimension *m_pDrawEnt;	//临时实体, 
	AecDbDimension *m_pDrawEntAll; //临时实体, 
	int m_iFlag;
	virtual Adesk::Boolean subWorldDraw(AcGiWorldDraw* mode)
	{
		assertReadEnabled();
			AcGiViewDraw dc(mode, NULL);

		m_pDrawEnt->Draw2d(dc);
		if (m_iFlag == 2 && m_pDrawEntAll != NULL)
		{
			m_pDrawEntAll->Draw2d(dc);
		}
		return Adesk::kTrue;
	}

};

//双层JIG通用
class TMulDimEntity1 : public AcDbEntity
{
public:
	TMulDimEntity1() {}
	virtual ~TMulDimEntity1() {}

	AecDbDimension *m_pDrawEnt;	//临时实体, 
	AecDbDimension *m_pDrawEnt2; //临时实体, 
	virtual Adesk::Boolean subWorldDraw(AcGiWorldDraw* mode)
	{
		assertReadEnabled();
		AcGiViewDraw dc(mode, NULL);

		m_pDrawEnt->Draw2d(dc);
		m_pDrawEnt2->Draw2d(dc);
		return Adesk::kTrue;
	}

};

//双层标注动态效果类 add by wlw on 2012/12/12
class TDimDoubleJig:public AcEdJig
{
public:
	TDimDoubleJig(AecDbDimension * pdim, AecDbDimension * pdim2)
	{
		m_pDim.m_pDrawEnt = pdim;
		m_pDim.m_pDrawEnt2 = pdim2;
	}
	~TDimDoubleJig() {}
	AcEdJig::DragStatus doIt();
	virtual AcEdJig::DragStatus sampler();
	virtual Adesk::Boolean update();
	virtual AcDbEntity* entity() const;

public:
	AcGePoint3d m_ptDim;
	TMulDimEntity1 m_pDim;//标注
};

AcEdJig::DragStatus TDimDoubleJig::doIt()
{
	return drag();
}
AcEdJig::DragStatus TDimDoubleJig::sampler()
{
	setUserInputControls((UserInputControls)(AcEdJig::kAccept3dCoordinates|
		AcEdJig::kNullResponseAccepted));

	ADSGePoint3d ptCursor;
	DragStatus stat = acquirePoint(ptCursor);
	if(stat == AcEdJig::kNormal) 
	{
		if (ptCursor.Distance2d(m_ptDim) > g_Option::instance()._DIST_SNAP)
			m_ptDim = ptCursor;
		else 
			stat = AcEdJig::kNoChange;
	}
	return stat;
}

Adesk::Boolean TDimDoubleJig::update()
{
	XPoint ptOnSeg;
	GeCurveSegment seg;
	seg = m_pDim.m_pDrawEnt->GetDimCurve();
	if(seg.ProjectToMe(m_ptDim, ptOnSeg) == RTNORM) 
	{
		double nDistMove = ptOnSeg.Distance2d(m_ptDim);
		int nSideLoc = seg.OnWhichSide(m_pDim.m_pDrawEnt->GetLocation());
		int nSide = seg.OnWhichSide(m_ptDim);
		double nDist2Dim = m_pDim.m_pDrawEnt->GetDist2DimLine(FALSE);
		double nFactor = nDist2Dim/fabs(nDist2Dim);
		if(fabs(nDist2Dim) > 1.0E-6) 
		{
			if(nSide != nSideLoc) 
			{
				nDistMove *= nFactor;
			}
			else
			{
				nDistMove *= -nFactor;
			}
		} 
		else 
		{
			if(nSideLoc == OFFSET_LEFT) 
				nDistMove *= -1;
		}
		nDist2Dim += nDistMove;
		m_pDim.m_pDrawEnt->SetDist2DimLine(nDist2Dim, FALSE);
		if(nDist2Dim >= 0)
			nDist2Dim -= 1000;
		else 
			nDist2Dim += 1000;
		m_pDim.m_pDrawEnt2->SetDist2DimLine(nDist2Dim, FALSE);	

	}
	return Adesk::kTrue;
}
AcDbEntity* TDimDoubleJig::entity() const
{
	return (AcDbEntity*)&m_pDim;
}

//角度标注动态效果类 add by lxb on 2011/11/24
class TDimAngleJig:public AcEdJig
{
public:
	TDimAngleJig(AecDbDimension *pDim,
		AcGeLine2d &line1, AcGeLine2d &line2, XPoint &pt,
		TCHAR *pszPrompt, TCHAR *pszKeyword=NULL);

	~TDimAngleJig();
	AcEdJig::DragStatus doIt();

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

	static int QsortFun(const void *p1,const void *p2);//交点排序函数

private:
	AecDbDimension *m_pDim;//标注

	TCHAR *m_pszPrompt;   //提示语 
	TCHAR *m_pszKeyword;  //关键字
	AcGePoint3d m_ptLast; //记录鼠标上次位置
	AcGePoint3d m_ptCur;  //记录鼠标当前位置
	AcGeLine2d m_line1;   //成角直线1
	AcGeLine2d m_line2;   //成角直线2
	XPoint m_ptCen;       //成角顶点

};

TDimAngleJig::TDimAngleJig(AecDbDimension *pDim, 
						   AcGeLine2d &line1, AcGeLine2d &line2, XPoint &pt , 
						   TCHAR *pszPrompt, TCHAR *pszKeyword):
m_pDim(pDim),
m_line1(line1),m_line2(line2),m_ptCen(pt),
m_pszPrompt(pszPrompt),m_pszKeyword(pszKeyword)
{
}

TDimAngleJig::~TDimAngleJig()
{
}

AcEdJig::DragStatus TDimAngleJig::doIt()
{
	setDispPrompt(m_pszPrompt);
	AcEdJig::DragStatus status =AcEdJig::kNull;
	try 
	{
		status = drag();
	} 
	catch(...)
	{
		status = AcEdJig::kCancel;
	}
	return status;
}

AcEdJig::DragStatus TDimAngleJig::sampler()
{
	setUserInputControls((UserInputControls)(AcEdJig::kAccept3dCoordinates|
		AcEdJig::kNullResponseAccepted));

	AcEdJig::DragStatus status =AcEdJig::kCancel;

	status = acquirePoint(m_ptCur);

	if (status == AcEdJig::kNormal)
	{
		if (m_ptCur.isEqualTo(m_ptLast))
		{
			return AcEdJig::kNoChange;
		}
	}
	m_ptLast = m_ptCur;

	return status;
}

int TDimAngleJig::QsortFun(const void *p1,const void *p2)
{
	double dangle1 = ads_angle(asDblArray(((pPTDATA)p1)->ptCenter),asDblArray(((pPTDATA)p1)->ptTem));
	double dangle2 = ads_angle(asDblArray(((pPTDATA)p2)->ptCenter),asDblArray(((pPTDATA)p2)->ptTem)) ;
	return( dangle1 > dangle2);
}

Adesk::Boolean TDimAngleJig::update()
{
	double dRadiu = m_ptCen.Distance(m_ptCur);
	if (dRadiu < 5.0)
	{
		return Adesk::kFalse;
	}

	//构造圆
	AcGeCircArc2d circle(m_ptCen,dRadiu);

	//求圆与直线交点
	int iCount = 0;
	AcGePoint2d pt[4];
	circle.intersectWith(m_line1,iCount,pt[0],pt[1]);
	circle.intersectWith(m_line2,iCount,pt[2],pt[3]);

	//点队列
	CArray<PTDATA,PTDATA> arr;
	for (int i=0;i<4;i++)
	{
		PTDATA temp;
		temp.ptCenter = m_ptCen;
		temp.ptTem = pt[i];
		arr.Add(temp);
	}

	PTDATA temp;
	temp.ptCenter = m_ptCen;
	temp.ptTem = AcGePoint2d(m_ptCur.x,m_ptCur.y);
	arr.Add(temp);

	//队列排序(升序)
	qsort(&arr[0],arr.GetSize(),sizeof(PTDATA&),QsortFun);

	//取标注起点和终点
	XPoint qt1(arr[0].ptTem),qt2(arr[1].ptTem);

	int iPos = 1; 
	for (int j=0;j<arr.GetSize();j++)
	{
		if (arr[j].ptTem.isEqualTo(AcGePoint2d(m_ptCur.x,m_ptCur.y)))
		{
			iPos = j;
			break;
		}
	}
	if (iPos == arr.GetSize()-1)
	{
		qt1 = arr[iPos-1].ptTem;
		qt2 = arr[0].ptTem;
	}
	else if (iPos == 0)
	{
		qt1 = arr[arr.GetSize()-1].ptTem;
		qt2 = arr[1].ptTem;
	}
	else
	{
		qt1 = arr[iPos-1].ptTem;
		qt2 = arr[iPos+1].ptTem;
	}

	//初始化
	m_pDim->RemoveSegment(m_pDim->GetSegmentNum()-1);

	//更新标注属性
	XPoint ptLoc;
	ads_polar(qt1, ads_angle(m_ptCen, qt1), 
		2.0*GlobalFunc::DocGetPScale(),
		ptLoc);
	m_pDim->SetLocation(ptLoc);
	m_pDim->SetDimRadius(m_ptCen.Distance2d(qt1));
	m_pDim->SetRotation(CT_std_angle(ads_angle(m_ptCen, qt1)+PI/2));
	m_pDim->SetObjRadius(m_ptCen.Distance2d(qt1)+2.0*GlobalFunc::DocGetPScale());

	XArc ar(m_ptCen, m_ptCen.Distance2d(qt1),
		ads_angle(m_ptCen, qt1),
		ads_angle(m_ptCen, qt2));

	if(m_pDim->IsValidSegment(ar.GetLength()))
	{
		m_pDim->AppendSegment(ar.GetLength());
	}

	return Adesk::kTrue;
}

AcDbEntity * TDimAngleJig::entity() const
{
	return(m_pDim);
}

// 拖曳显示点
class TDimensionEdJig : public AcEdJig
{
public:
    TDimensionEdJig(AecDbDimension *pDim, const TCHAR *pszPrompt, const TCHAR *pszKeyword=NULL);
    ~TDimensionEdJig();
    int doIt();
    virtual DragStatus sampler();
    virtual Adesk::Boolean update();
    virtual AcDbEntity* entity() const;
    void Swap();

    int GetRetCode(int *kwordId=NULL) const;
    int m_nRetCode; //返回码
    const TCHAR *m_pszPrompt; //提示信息
	const TCHAR *m_pszKeyword; //关键字
	AecDbDimension *m_pDrawEnt; //临时实体, 
    AecDbDimension *m_pTemp; //临时实体, 用于m_nFlag==3

	GeArc			m_ObjarDim;// 被标注对象
	BOOL			m_bKeyword;//是否按下关键字，玄长标注用

    XPoint m_ptDim;
    int m_nFlag; //0--尺寸方向, 1--尺寸线位置, 2--第二个标注点, 3--其它标注点

	//add by whl on 03/08/08
	DListStack<XPoint> ptStack;//标注点栈
	void Step();//当前点入栈
	void Undo();//撤消
	XPoint GetLastPoint();
	bool CanUndo();//是否可撤消
	//add by lgy 20120315 设置弧长标注标记
	void SetIsArcDim();

	BOOL m_bInView;	//add by lgy 20120503	保存标注是否是在视口中绘制
	int m_nPortNum;	//视口编号
	PickEntSet m_entSet;//add by lgy 20120507 保存所有视口对象
	AcDbObjectId m_idDimNew;//新标注样式ID
	AcDbObjectId m_idDimOld;//老标注样式ID
	BOOL m_bSaveStyle;		//保存是不是设置新样式
protected:
	void FindAndRemoveSeg(XPoint pt);//由一标注点找出对应段并且正确去除之

private:
	//add by lxb on 2011/11/22
	AcEdInputPointMonitorEx  m_cMonitor;//监视器
	bool m_bIsArcDim;	//add by lgy 20120315	弧长标注标记
};


//add by lgy 20120509	判断点在不在实体上
//pt:模型空间中的点
//返回值:如果pt在当前图纸中的莫个实体上，返回TRUE,否则返回FALSE
BOOL GetIsOnEntity(XPoint pt)
{
	BOOL bOn = FALSE;		//用来保存点是否在实体上
	Acad::ErrorStatus es = Acad::eOk;
	AcDbBlockTable *pTable = NULL;
	es = acdbHostApplicationServices()->workingDatabase()->getSymbolTable(pTable, AcDb::kForRead);
	if (es != Acad::eOk)
	{
		return bOn;
	}

	AcDbBlockTableRecord *pBlockTableRecord = NULL;
	es = pTable->getAt(ACDB_MODEL_SPACE, pBlockTableRecord, AcDb::kForRead);
	if (es != Acad::eOk)
	{
		pTable->close();
		return bOn;
	}

	AcDbBlockTableRecordIterator *pBlockIterator = NULL;
	if (Acad::eOk == pBlockTableRecord->newIterator(pBlockIterator))
	{
		AcDbEntity *pEnt = NULL;
		for (pBlockIterator->start(); !pBlockIterator->done(); pBlockIterator->step())
		{
			if (Acad::eOk == pBlockIterator->getEntity(pEnt, AcDb::kForRead))
			{
				PickEntSet entSet(SS_FREE);
				entSet += pEnt->id();
				if (entSet.Length() == 0)
				{
					continue;
				}
				Entity ent = entSet[0L];
				XPoly2D poly(ent);

				for (int i = 0; i < poly.TotalSegments(); i++)
				{
					GeCurveSegment cvSeg;
					poly.Nth(i, cvSeg);
					double dDistance = cvSeg.GetDist2Me(pt);
					if (cvSeg.GetLength() > 0)	
					{
						//转换点时由于从图纸空间转换到模型空间中时转换误差较大
						//设置为50的另外一个原因是对象捕捉的距离
						if (fabs(dDistance) < 50)		
						{
							bOn = TRUE;
							break;
						}
					}
				}

				/*if (pEnt->isKindOf(TDbCurveEntity::desc())|| pEnt->isKindOf(AcDbEntity::desc()))*/
				/*if (pEnt->isKindOf(TDbOpening::desc()))
				{
					AcDbVoidPtrArray dbArray;
					pEnt->explode(dbArray);
					int n = dbArray.length();
					for (int i = 0; i < dbArray.length(); i++)
					{
						AcDbLine *pLine = AcDbLine::cast((AcDbEntity *)dbArray[i]);
						if (pLine != NULL)
						{
							GeCurveSegment seg(pLine->startPoint(), pLine->endPoint(), 0);
							double dDist = fabs(seg.GetDist2Me(pt));
							if (fabs(seg.GetDist2Me(pt))< 100)	//上华对象炸开后可能引起的误差值会更大些
							{
								bOn = TRUE;
								break;
							}
						}

						AcDbBlockTableRecord *pBlock = AcDbBlockTableRecord::cast((AcDbObject*)dbArray[i]);
						if (pBlock != NULL)
						{
							acutPrintf(_T("aa"));
						}
						AcDbArc *pArc = AcDbArc::cast((AcDbEntity*)dbArray[i]);
						if (pArc != NULL)
						{
							XPoint ptCenter = pArc->center();
							XArc arc(ptCenter, pArc->radius(), pArc->startAngle(), pArc->endAngle());
							GeCurveSegment segArc;
							segArc = arc;
							double dDist = fabs(segArc.GetDist2Me(pt));
							if (fabs(segArc.GetDist2Me(pt))< 100)
							{
								bOn = TRUE;
								break;
							}
						}
					}
				}*/

				pEnt->close();
				if (bOn)	//点在实体上
				{
					break;
				}
			}
		}
		delete pBlockIterator;
		pBlockIterator = NULL;
	}
	pTable->close();
	pBlockTableRecord->close();
	return bOn;
}

//add by lgy 20120509	以下函数目的是为了获得点在的视口编号和视口比例
//pt:图纸空间中点取的点
//dScale:对应视口的比例
//entSet:当前图纸所有视口对象
//返回值:视口编号 如果为0表示没有点中视口
int GetPtOnWhichPort(XPoint pt, double &dScale,BOOL &bOnEnt, PickEntSet entSet)
{
	for(long i = 0; i < entSet.Length(); i++)
	{
		Entity ent = entSet[i];
		OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbViewport, pViewPort);
		if (pViewPort == NULL)
		{
			continue;
		}

		double dWidth = pViewPort->width();
		double dHeight = pViewPort->height();
		XPoint ptCenter = pViewPort->centerPoint();

		XPoly2D poly;
		XRectAngle	rect(ptCenter, dWidth, dHeight);
		rect.AsPoly2D(poly);
		poly.SetClosed();
		poly.SetElevation(0.0);
		if ((pt&poly) == PR_INSIDE)		//在视口内
		{
			dScale = pViewPort->customScale();

			XPoint ptPortCenter = pViewPort->viewCenter();
			XPoint ptCenter = pViewPort->centerPoint();
			double dAngle = ads_angle(ptCenter, pt);		//点取的点跟视口中心点的角度
			double dDistance = ptCenter.Distance2d(pt);
			XPoint ptView2Mod;
			ads_polar(ptPortCenter, dAngle, dDistance/dScale, ptView2Mod);
			bOnEnt = GetIsOnEntity(ptView2Mod);					//判断点是否在实体上

			return pViewPort->number();
		}
		OPENOBJ_END();
	}
	return 0;
}

//add by lgy 20120315	设置弧长标记
void TDimensionEdJig::SetIsArcDim()
{
	m_bIsArcDim = true;
}

//add by whl on 03/08/08
void TDimensionEdJig::FindAndRemoveSeg(XPoint pt)
{
    GeCurveSegment seg=m_pDrawEnt->GetDimCurve();
	XPoint ptOnSeg;
    seg.ProjectToMe(pt, ptOnSeg);
	double value=seg.StartPoint().Distance2d(ptOnSeg);
	long i=-1;
	if(value>g_Option::instance()._DIST_SNAP)
	{
		double curValue=0;
		for(i=0;i<m_pDrawEnt->GetSegmentNum();i++)
		{
			curValue+=m_pDrawEnt->GetSegment(i);
			if(fabs(curValue-value)<g_Option::instance()._DIST_SNAP)
				break;
		}
	}
	if(i>=m_pDrawEnt->GetSegmentNum())
		return;//useful

	if(i>=0)
	{
		double temp=m_pDrawEnt->GetSegment(i);
		if(i<(m_pDrawEnt->GetSegmentNum()-1))//是中间段
			m_pDrawEnt->SetSegment(i+1,temp+m_pDrawEnt->GetSegment(i+1));//后一段合并之
		m_pDrawEnt->RemoveSegment(i);
	}
	else//第一个标注段的起点（不一定是DimContinue中提示的第一点）特殊处理
	{
		double temp=m_pDrawEnt->GetSegment(0);
		m_pDrawEnt->RemoveSegment(0);
		XVector3D vt=seg.EndPoint()-seg.StartPoint();
		vt.Scale(temp/vt.Length());
		m_pDrawEnt->SetLocation(m_pDrawEnt->GetLocation()+vt);
	}
}
void TDimensionEdJig::Step()
{
	ptStack.Push(m_ptDim);
}
bool TDimensionEdJig::CanUndo()
{
	return ptStack.GetDepth()>1;
}
void TDimensionEdJig::Undo()
{
	XPoint pt;
	ptStack.GetTopData(pt);
	ptStack.GoBack();
	if(CanUndo())
		m_pDrawEnt->FindAndRemoveSegment(pt);
}
XPoint TDimensionEdJig::GetLastPoint()
{
	XPoint pt;
	ptStack.GetTopData(pt);
	return pt;
}
//end 

void TDimensionEdJig::Swap()
{
    if(m_pTemp) {
        AcDbDeepCloneFiler filer;
        if(m_pTemp->dwgOut(&filer)==Acad::eOk) {
            filer.seek(0L,0);
            VERIFY(m_pDrawEnt->dwgIn(&filer)==Acad::eOk);
        }
        ASSERT(m_pTemp && m_pTemp->IsValid());
    } else {
        m_pTemp = (AecDbDimension *)m_pDrawEnt->clone();
        ASSERT(m_pTemp && m_pTemp->IsValid());
    }
}

// 转换成ARX代码
int TDimensionEdJig::GetRetCode(int *kwordId) const
{
	int ret = m_nRetCode;
	if (ret == AcEdJig::kCancel)
		ret = RTCAN;
    else if(ret == AcEdJig::kNull)
        ret = RTNONE;
	else if (ret <= 0) 
		ret = RTNORM;
	else {
		if(kwordId) *kwordId = ret;
		ret = RTKWORD;
	}
    return ret;
}


TDimensionEdJig::TDimensionEdJig(AecDbDimension *pDim, const TCHAR *pszPrompt, const TCHAR *pszKeyword)
:m_pDrawEnt(pDim), m_pszPrompt(pszPrompt),  m_pszKeyword(pszKeyword), m_nRetCode(0),m_cMonitor(curDoc())
{
    m_pTemp=NULL;
    m_nFlag=0;
    m_ptDim=pDim->GetLocation();
	//add by lgy 20120315	弧长标注标记
	m_bIsArcDim = false;	//false为不是弧长标注

	m_bInView = FALSE;	//add by lgy 20120503	保存标注是否是在视口中绘制
	m_nPortNum = 0;		//add by lgy 20120509	默认视口为0
	m_bSaveStyle = FALSE;//add by lgy 20120519	默认不保存标注样式
	m_bKeyword = FALSE;
}


TDimensionEdJig::~TDimensionEdJig()
{
    if(m_pTemp)
        delete m_pTemp;
}

// 开始执行拖动
int TDimensionEdJig::doIt()
{
    setDispPrompt(m_pszPrompt);
        try 
		{
			if (m_nFlag == 1)
			{
				if (m_pDrawEnt->IsDimChord() && m_pDrawEnt->IsAngular())
				{//玄长jig

					GeCurveSegment seg=m_pDrawEnt->GetDimCurve();
					ADSGePoint3d pt1,pt2,ptc;
					ptc = seg.MidPoint();
					pt1 = seg.GetStartPoint();
					pt2 = seg.GetEndPoint();
 
 					while(m_pDrawEnt->GetSegmentNum() > 0)
 						m_pDrawEnt->RemoveSegment(0);

					m_pDrawEnt->SetObjRadius(0);
					m_pDrawEnt->SetDimRadius(0);

					m_pDrawEnt->SetAngular(FALSE);
					m_pDrawEnt->SetDimChord(FALSE);

					m_pDrawEnt->AppendSegment(pt1.Distance2d(pt2));		
					m_pDrawEnt->AddSegment(pt1);

					m_pDrawEnt->SetLocation(pt1);
					m_pDrawEnt->SetFixLinePos(pt1);
					GeCurveSegment seg1(pt1,pt2,0);
					double nDirection=seg1.Direction(ptc);
					m_pDrawEnt->SetRotation(nDirection);
				}
			}
            m_nRetCode = drag();
        } 
		catch(...)
		{
            m_nRetCode=AcEdJig::kCancel;
        }
     return GetRetCode();
}

// 反馈
AcEdJig::DragStatus TDimensionEdJig::sampler()
{
	DragStatus stat;

    setUserInputControls((UserInputControls)
        (AcEdJig::kAccept3dCoordinates|AcEdJig::kNullResponseAccepted));

	if (m_pszKeyword) setKeywordList(m_pszKeyword);
    XPoint ptTemp;
    if(m_nFlag==0) 
	{	
		stat=acquirePoint(ptTemp, m_pDrawEnt->GetLocation().AsAcGePoint3d());
	}
	else  if((m_nFlag == 1) || (m_nFlag == 2) || (m_nFlag == 5)) 
	{
		ADSGePoint3d ptCur;
		GlobalFunc::GetWcsCursor(ptCur);
		ptCur.z = 0;
		//辅助计算直线wlw mod 20150518 辅助线需要清零z，否则引线会飞
		XPoint pt1(ptStack[0]),pt2(ptStack[1]);
		pt1.z = 0.0;
		pt2.z = 0.0;
		XLine line1(pt1,pt2);
		ads_real rAng = line1.Direction();
		XPoint pt;
		ads_polar(ptCur, rAng + 0.5 * PI, 100.0, pt);
		XLine line2(ptCur, pt);

		//获取基点
		ads_point ptIntersection;
		line1.Intersection(&line2,ptIntersection);
		AcGePoint3d ptBase = asPnt3d(ptIntersection);

		if (!m_bIsArcDim)
		{
			stat = acquirePoint(ptTemp,ptBase);
		}
		else
		{
			stat = acquirePoint(ptTemp);
		}
	}
    else if(m_nFlag==3) 
	{
		//modidfied by whl on 03/08/08
		XPoint ptLast=GetLastPoint();
        stat=acquirePoint(ptTemp, ptLast);
    } 
	else if(m_nFlag==4)
	{
        XPoint ptLast;
        xg_getvar(_T("LASTPOINT"), ptLast);
        ptLast = GlobalFunc::Ucs2Wcs(ptLast);
        stat=acquirePoint(ptTemp, ptLast);
	}

    if(stat == AcEdJig::kNormal) 
	{
        if (ptTemp.Distance2d(m_ptDim)>g_Option::instance()._DIST_SNAP) 
		{
            double nDist=m_ptDim.Distance2d(ptTemp);
            m_ptDim=ptTemp;
        }  
		else
		{
            return AcEdJig::kNoChange;
		}
    }
 
	return stat;
}

// 更新实体数据
Adesk::Boolean TDimensionEdJig::update()
{
    if(m_nFlag==0) 
	{
        m_pDrawEnt->SetRotation(ads_angle(m_ptDim, m_pDrawEnt->GetLocation())+PI);
        double nVal=m_ptDim.Distance2d(m_pDrawEnt->GetLocation());
		//modify by lgy 20120503 如果标注在图纸空间中的视口中
        //if(m_pDrawEnt->IsValidSegment(nVal))
        //    m_pDrawEnt->SetSegment(0, nVal);
		if(m_pDrawEnt->IsValidSegment(nVal))
		{
			m_pDrawEnt->SetSegment(0, nVal);

			if (m_bInView)
			{
				double dScale = 1.0;
				BOOL bFit = FALSE;
				int nNum = GetPtOnWhichPort(m_ptDim, dScale, bFit, m_entSet);
				if (nNum == m_nPortNum || !bFit)
				{
					m_pDrawEnt->SetStyleId(m_idDimNew);
					m_bSaveStyle = TRUE;
				}
				else
				{
					m_pDrawEnt->SetStyleId(m_idDimOld);
					m_bSaveStyle = FALSE;
				}

			}
		}
    }
	else if(m_nFlag==1) 
	{
        GeCurveSegment seg=m_pDrawEnt->GetDimCurve();
        XPoint ptOnSeg;
        if(seg.ProjectToMe(m_ptDim, ptOnSeg)==RTNORM) 
		{
            double nDistMove=m_ptDim.Distance2d(ptOnSeg);
            int nSideLoc=seg.OnWhichSide(m_pDrawEnt->GetLocation());
            int nSide=seg.OnWhichSide(m_ptDim);
            double nDist2Dim = m_pDrawEnt->GetDist2DimLine(FALSE);
            
            if(fabs(nDist2Dim) > 1.0E-6) 
			{
                double nFactor=nDist2Dim/fabs(nDist2Dim);
                if(nSide!=nSideLoc) 
                    nDistMove *= nFactor;
                else 
                    nDistMove *= -nFactor;
            } 
			else 
			{
                if(nSideLoc == OFFSET_LEFT)
					nDistMove = -nDistMove;
            }
            if(m_pDrawEnt->IsAngular()) 
			{ //弧墙有错，不知道原因
                nDist2Dim += nDistMove; 
                double nDistRad= m_pDrawEnt->GetDimRadius();
                    //seg.GetArc().center.Distance(m_ptDim); 
                nDistRad -= nDistMove;
                if(nDistRad>g_Option::instance()._DIST_SNAP) 
				{
                    m_pDrawEnt->SetDimRadius(nDistRad);
                    m_pDrawEnt->SetDist2DimLine(nDist2Dim, FALSE);
                }
            } 
			else
			{
                nDist2Dim += nDistMove; 
                m_pDrawEnt->SetDist2DimLine(nDist2Dim, FALSE);
            }

        }
    } 
	else if(m_nFlag==2)
	{ //修改标注位置
        AcDbIntArray indices;
        indices.append(3);
        AcGePoint3dArray ptArray;
        m_pDrawEnt->getStretchPoints(ptArray);
        ASSERT(ptArray.length()>3);
        AcGeVector3d vtOffset=m_ptDim.AsAcGePoint3d()-ptArray[3];
        m_pDrawEnt->moveGripPointsAt(indices, vtOffset);
    } 
	else if(m_nFlag==3) 
	{//modified by whl on 03/08/08
        ASSERT(m_pTemp);
        GlobalFunc::CopyObject(*m_pDrawEnt, *m_pTemp);
		if(CanUndo())
		{
			if(!m_pTemp->AddSegment(m_ptDim))
				return Adesk::kFalse;
		}
		else
		{
			m_pTemp->SetRotation(ads_angle(m_ptDim, m_pTemp->GetLocation())+PI);
			double nVal=m_ptDim.Distance2d(m_pTemp->GetLocation());
			if(m_pTemp->IsValidSegment(nVal))
				m_pTemp->SetSegment(0, nVal);
		}
        ASSERT(m_pTemp && m_pTemp->IsValid());
    } 
	else if(m_nFlag==4) 
	{
        ASSERT(m_pTemp);
        GlobalFunc::CopyObject(*m_pDrawEnt, *m_pTemp);
		m_pTemp->AddSegment(m_ptDim);
	}
	else if(m_nFlag==5) 
	{
		double dr = m_pDrawEnt->GetObjRadius();
		ADSGePoint3d pt1,pt2;
		m_ObjarDim.GetStartPoint(pt1);
		m_ObjarDim.GetEndPoint(pt2);
		double dDist2d = m_ptDim.Distance2d(m_ObjarDim.GetCenterPt());
		GeCurveSegment ln1(m_ObjarDim.GetCenterPt(), m_ptDim,0), ln2(pt1,pt2,0);
		ln2.SetLineFlag(LS_FINITE);
		ln1.SetLineFlag(LS_FINITE);
		int nptins = ln1.Intersection(ln2,pt1,pt2);
		m_pDrawEnt->SetStyleId(InitDimStyle(DS_ANGLE));
		if (dDist2d < dr)
		{//圆内
			if (nptins > 0)
			{//玄长
				m_pDrawEnt->SetStyleId(InitDimStyle(DS_LINEAR));
				m_pDrawEnt->SetAngular(TRUE);
				m_pDrawEnt->SetDimArcLen(FALSE);
				m_pDrawEnt->SetDimChord(TRUE);
				m_pDrawEnt->SetDist2DimLine(0.0);
				m_pDrawEnt->SetDimRadius(m_ObjarDim.GetRadius()/*-6*GlobalFunc::DocGetPScale()*/);
			}
			else
			{//角度
				m_pDrawEnt->SetAngular(TRUE);
				m_pDrawEnt->SetDimArcLen(FALSE);
				m_pDrawEnt->SetDimChord(FALSE);
				m_pDrawEnt->SetDist2DimLine(10);
				m_pDrawEnt->SetDimRadius(m_ObjarDim.GetRadius()-10*GlobalFunc::DocGetPScale());
			}

		}
		else
		{
			if (nptins > 0)
			{//弧长
				m_pDrawEnt->SetAngular(TRUE);
				m_pDrawEnt->SetDimArcLen(TRUE);
				m_pDrawEnt->SetDimChord(FALSE);
				m_pDrawEnt->SetDist2DimLine(-6);
				m_pDrawEnt->SetDimRadius(m_ObjarDim.GetRadius()+6.0*GlobalFunc::DocGetPScale());
			}
			else
			{//角度
				m_pDrawEnt->SetAngular(TRUE);
				m_pDrawEnt->SetDimArcLen(FALSE);
				m_pDrawEnt->SetDimChord(FALSE);
				m_pDrawEnt->SetDist2DimLine(10);
				m_pDrawEnt->SetDimRadius(m_ObjarDim.GetRadius()-10*GlobalFunc::DocGetPScale());

			}
		}
	} 
    ASSERT(m_pDrawEnt && m_pDrawEnt->IsValid());
	return Adesk::kTrue;
}

AcDbEntity* TDimensionEdJig::entity() const
{
    if((m_nFlag==3 || m_nFlag==4) && m_pTemp)
        return m_pTemp;
    else
	    return m_pDrawEnt;
}

double XYDistance(XPoint pt1,XPoint pt2)
{
	double XDis=pt1.x-pt2.x;
	double YDis=pt1.y-pt2.y;
	return sqrt(XDis*XDis+YDis*YDis);
}

struct EntAng
{
	Entity ent;
	double angle;
};

void ArrangeEnt(BOOL bIncrease)
{
	
}

// 把pDim2合并到pDim1去
int MergeDim(AecDbDimension *pDim1, AecDbDimension *pDim2)
{
    if(!IsSameDrt(pDim1->GetRotation(), pDim2->GetRotation(), g_DimOption::instance()._angSnap)) {
        g_Option::instance().adsout << _T("\n方向不平齐!");
        return RTERROR;
    } else if(pDim1->IsAngular()!=pDim2->IsAngular()) {
        g_Option::instance().adsout << _T("\n类型不匹配!");
        return RTERROR;
    } else if(!!pDim1->GetBindId() || !!pDim2->GetBindId()) {
        g_Option::instance().adsout << _T("\n尺寸对象已经绑定在其他对象上!");
        return RTERROR;
    }

    if(pDim1->MergeDim(pDim2))
        return RTNORM;
    g_Option::instance().adsout << _T("\n不能合并!");
    return RTERROR;
}
// Add by lcf on 2005/05/26
BOOL MergeDimFromTo(AecDbDimension *pTo, const AecDbDimension *pFrom)
{
    XPoly2D poly;
    pFrom->GetPolySegOnDimLine(poly);
 	GeCurveSegment cv = pTo->GetDimCurve();
   if(!pTo->IsUseDefaultText() || !pFrom->IsUseDefaultText()) 
	{
		for(int i=0; i<poly.Length(); i++) 
		{
			XPoint ptVert;
			if(cv.ProjectToMe(*poly[i], ptVert) != RTNORM)
				continue;
			if((ptVert & cv) != 4)
			{
				g_Option::instance().adsout << _T("\n尺寸文字被更改过, 并且尺寸线重叠, 不能连接尺寸!");
				return FALSE;
			}
	   }
	}

	int nSeg = pTo->GetSegmentNum();
    for(int i=0; i<poly.Length(); i++) 
	{
		XPoint ptVert;
		if(cv.ProjectToMe(*poly[i], ptVert) != RTNORM)
			continue;
		pTo->AddSegment(ptVert);
	}
 	cv = pTo->GetDimCurve();

	int nTo = pTo->GetSegmentNum();
	int nFrom = pFrom->GetSegmentNum();
	
	XPoint ptSta, ptEnd;
	cv.ProjectToMe(*poly.Head(), ptSta);
	cv.ProjectToMe(*poly.Tail(), ptEnd);

	int nFlag = 0;
	if(ptSta.Distance2d(cv.StartPoint()) < 1E-6)
	{
		nFlag = 0;
	}
	else if(ptSta.Distance2d(cv.EndPoint()) < 1E-6)
	{
		nFlag = 1;
	}
	else if(ptEnd.Distance2d(cv.StartPoint()) < 1E-6)
	{
		nFlag = 2;
	}
	else if(ptEnd.Distance2d(cv.EndPoint()) < 1E-6)
	{
		nFlag = 3;
	}
	else
	{
		// sg modify 120615，解决在中间部分的尺寸标注如果文字不在默认位置，连接尺寸后，文字不在默认位置的问题
		// return TRUE;
		for (i=0; i<nFrom; i++) 
		{
			XPoint ptVert;
			if (cv.ProjectToMe(*poly[i], ptVert) != RTNORM)
				continue;

			BOOL bIsDefText = TRUE;
			XString szText = pFrom->GetText(i, &bIsDefText);
			BOOL bIsDefPos = TRUE;
			XPoint ptPos = pFrom->GetTextPos(i, &bIsDefPos);
			if (bIsDefText && bIsDefPos)
				continue;

			XPoint ptNew = ptPos;
			ptNew += ptVert - *poly[i];

			int nPos = pTo->HitTestOnDimSeg(ptNew);
			if (nPos==-1 || nPos>nTo)
				continue;

			double dCur = pFrom->GetSegment(i),
				dProject = pTo->GetSegment(nPos);
			if (fabs(dCur-dProject) > g_Option::instance()._DIST_SNAP) // 中间部分的外偏情况，不处理
				continue;

			if (!bIsDefText)
				pTo->SetTextContent(nPos, szText);

			if (!bIsDefPos)
			{
				if (_tcscmp(szText, pTo->GetText(nPos)) == 0)
					pTo->SetTextPos(nPos, ptNew);
			}
		}
		return  TRUE;
	}

	for(i=0; i<nFrom; i++) 
	{
		XPoint ptVert;
		if(cv.ProjectToMe(*poly[i], ptVert) != RTNORM)
		{
			continue;
		}

		BOOL bIsDefText = TRUE;
		XString szText = pFrom->GetText(i, &bIsDefText);
		BOOL bIsDefPos = TRUE;
		XPoint ptPos = pFrom->GetTextPos(i, &bIsDefPos);
		if(bIsDefText && bIsDefPos)
		{
			continue;
		}

		int nPos;
		if(nFlag == 0)
		{
			nPos = i;
		}
		else if(nFlag == 1)
		{
			nPos = nTo - i - 1;
		}
		else if(nFlag == 2)
		{
			nPos = nFrom - i - 1;
		}
		else if(nFlag == 3)
		{
			nPos = nTo - nFrom + i;
		}

		if(!bIsDefText)
			pTo->SetTextContent(nPos, szText);

		if(!bIsDefPos)
		{
			if(_tcscmp(szText, pTo->GetText(nPos)) == 0)
			{
				ptPos += ptVert - *poly[i];
				pTo->SetTextPos(nPos, ptPos);
			}
		}
	}
	return TRUE;
}

// Command: 连接尺寸标注
// 不支持自调
void MergeDim()
{
	//Add by lxb on 2011/11/17
	//允许用户通过框选的方式，同时选中多道尺寸线与主尺寸连接
	//修改系统变量PICKADD
	XPushVar<int> pickmode(_T("PICKADD"), 1);

	//与主尺寸连接标注选择集
	PickEntSet ss(SS_FREE);
	RBList mask(RTDXF0, _T("DIMENSION,AEC_CHICUNBIAOZHU"), NULL);
	EntitySet entMaster;
	if (entMaster.FilterSelect(_T("\n选择主尺寸标注<退出>: "),mask) != RTNORM)
	{
		return;
	}
	entMaster.Redraw(3);


	GlobalFunc::DocGetPickFirst().Free();

	if(RTNORM != GlobalFunc::SelectEntities(_T("\n选择需要连接尺寸标注<退出>: "),ss, mask))
	{
		entMaster.Redraw(4);
		return;
	}
	ss -= entMaster;

	Entity entDim;
	if(entMaster.Is(_T("DIMENSION"))) 
	{
		if(!ConvertDim(entMaster, entDim)) 
		{
			g_Option::instance().adsout << _T("\n不能转化ACAD尺寸标注对象!");
			{
				return;
			}
		} 
		else if(!entDim.Is(_T("AEC_CHICUNBIAOZHU")))
		{
			g_Option::instance().adsout << _T("\n不是线性标注!");

			return;
		}
	} 
	else 
	{
		entDim = entMaster;
	}


	OPENOBJ_BEGIN(entDim, AcDb::kForRead, AecDbDimension, pMaster);
	if (!pMaster)
	{
		return;
	}
	//连接操作
	long nLen = ss.Length();
	for (long i = 0;i < nLen; i++)
	{
		Entity entDim;
		if(entMaster.Is(_T("DIMENSION"))) 
		{
			if(!ConvertDim(ss[i], entDim)) 
			{
				g_Option::instance().adsout << _T("\n不能转化ACAD尺寸标注对象!");
				{
					continue;;
				}
			} 
			else if(!entDim.Is(_T("AEC_CHICUNBIAOZHU")))
			{
				g_Option::instance().adsout << _T("\n不是线性标注!");

				continue;
			}
		} 
		else 
		{
			entDim = ss[i];
		}

		OPENOBJ_BEGIN(entDim, AcDb::kForWrite, AecDbDimension, pSlaver);
		if(pSlaver) 
		{
			if(pMaster->upgradeOpen()!=Acad::eOk)
			{
				g_Option::instance().adsout << _T("\n不能修改主尺寸!");
				continue;
			}
			if(pMaster->IsAngular()!=pSlaver->IsAngular()) 
			{
				g_Option::instance().adsout << _T("\n直线类型的尺寸不能和角度类型的尺寸进行连接!");
			}
			else 
			{
				BOOL bCanMerge=TRUE;
				if(!pMaster->IsAngular()) 
				{
					if(!IsSameDrt(pMaster->GetRotation(), pSlaver->GetRotation(), g_Option::instance()._DIST_SNAP))
					{
						g_Option::instance().adsout << _T("\n尺寸线的方向不平行, 无法连接!");
						bCanMerge=FALSE;
					}
				} 
				else 
				{
					XArc ar1=pMaster->GetDimCurve().GetArc();
					XArc ar2=pSlaver->GetDimCurve().GetArc();
					if(ar1.GetCenterPt().Distance2d(ar2.GetCenterPt())>g_Option::instance()._DIST_SNAP) 
					{
						g_Option::instance().adsout << _T("\n角度类型的尺寸圆心不一样, 无法连接!");
						bCanMerge=FALSE;
					}
				}
				if(bCanMerge) 
				{
					if(MergeDimFromTo(pMaster, pSlaver))
					{
						pSlaver->erase();
					}
				}  
			}
			pMaster->downgradeOpen();   
		}
		else 
		{
			g_Option::instance().adsout << _T("\n不能修改尺寸标注!");
		}
		OPENOBJ_END();
	}
	OPENOBJ_END();
}
// Command: 转化尺寸标注 (AcDbDimension -> AecDbDimension)
void ConvertDim()
{
    RBList mask(RTDXF0, _T("DIMENSION,AEC_CHICUNBIAOZHU"), NULL);
    PickEntSet ss(SS_FREE);
    if(GlobalFunc::SelectEntities(_T("\n请选择ACAD尺寸标注: "), ss, mask)==RTNORM) {
        PickEntSet ss1(SS_FREE|SS_CREATE);
        long lCount=ss.Length();
        for(long i=0; i<lCount; i++) {
            Entity ent=ss[i], _tmp;
			
            if(!ConvertDim(ent, _tmp))
                ss1 += ent;
        }
        long num=ss1.Length();
        if(num) {
            g_Option::instance().adsout << _T("\n有") << int(num) << _T("个对象不能被转化!");
            ss1.Redraw(3);
        } else {
            g_Option::instance().adsout << _T("\n全部选中的") << int(lCount) << _T("个对象成功的转化为上华尺寸标注!");
        }
    }
}
// Command: 切换角标
void TogDimAngular()
{
    RBList mask(RTDXF0, _T("AEC_CHICUNBIAOZHU"), NULL);
    PickEntSet ss(SS_FREE);
    if(GlobalFunc::SelectEntities(_T("\n请选择上华角度标注: "), ss, mask)==RTNORM) {
        long lCount=ss.Length();
        for(long i=0; i<lCount; i++) {
            Entity ent=ss[i];
            OPENOBJ_BEGIN(ent, AcDb::kForWrite, AecDbDimension, pDim);
            if(pDim && pDim->IsAngular()) {
                pDim->SwitchDimChord();
            }
            OPENOBJ_END();
        }
    }
}
// Command: 尺寸复位
void ResetDimP()
{
	// modify by xly on 100913 支持符号标注中：标高符号、箭头引注、剖面剖切和断面剖切四种文字复位，(20111222新加)指北针
    // RBList mask(RTDXF0, _T("AEC_CHICUNBIAOZHU,AEC_BANJINGBIAOZHU"), NULL);
	// RBList mask(RTDXF0, _T("AEC_CHICUNBIAOZHU,AEC_BANJINGBIAOZHU,ATS_ARROW,ATS_ELEVATION,AEC_POQIE,ATS_NORTHTHUMB"), NULL);
	// sg modify 120117，根据9.0的需求，增加了对索引图名对象的支持，主要是将圆圈外的文字还原
	RBList mask(RTDXF0, _T("AEC_CHICUNBIAOZHU,AEC_BANJINGBIAOZHU,ATS_ARROW,ATS_ELEVATION,AEC_POQIE,ATS_NORTHTHUMB,AEC_SUOYINTUMING"), NULL);
    PickEntSet ss(SS_FREE);

	// if(GlobalFunc::SelectEntities(_T("\n请选择上华尺寸标注: "), ss, mask)==RTNORM) {
	if(GlobalFunc::SelectEntities(_T("\n请选择需复位文字的对象: "), ss, mask)==RTNORM) 
	{
        long lCount=ss.Length();
        for(long i=0; i<lCount; i++) 
		{
            Entity ent=ss[i];

			// modify by xly 0n 100913 添加部分符号标注的文字复位
			/*OPENOBJ_BEGIN(ent, AcDb::kForWrite, AcDbEntity, pDim);
			AecDbDimension *pDim1=AecDbDimension::cast(pDim);
			AecXDbRadiusDim *pDim2=AecXDbRadiusDim::cast(pDim);
			if(pDim1)  
			pDim1->ResetTextPos();
			else if(pDim2)
			{
			pDim2->SetTextPos(pDim2->GetDefaultTextPos());
			}
			OPENOBJ_END();*/

			if (ent.Is(_T("AEC_CHICUNBIAOZHU")))		// 标注对象
			{	
				OPENOBJ_BEGIN(ent, AcDb::kForWrite, AecDbDimension, pDim);
				if (pDim != NULL)
				{
					pDim->ResetTextPos();
				}			
				OPENOBJ_END();
			}
			else if (ent.Is(_T("AEC_BANJINGBIAOZHU")))	// 半径标注对象
			{
				OPENOBJ_BEGIN(ent, AcDb::kForWrite, AecXDbRadiusDim, pDim);
				if (pDim != NULL)
				{
					pDim->SetTextPos(pDim->GetDefaultTextPos());
				}
				OPENOBJ_END();
			}
			else if (ent.Is(_T("AEC_JIANTOUYINZHU")))		// 箭头引注对象
			{
				OPENOBJ_BEGIN(ent, AcDb::kForWrite, AecXDbSymbArrow, pArrow);
				if (pArrow != NULL)
				{
					pArrow->SetTextLocation(pArrow->GetDefaultTextLocation());

					// 支持下标文字复位
					pArrow->SetText2Location(pArrow->GetDefaultText2Location());
				}
				OPENOBJ_END();
			}
			else if (ent.Is(_T("AEC_BIAOGAOBIAOZHU")))	// 标高标注对象
			{
				OPENOBJ_BEGIN(ent, AcDb::kForWrite, AecXDbSymbElevation, pEle);
				if (pEle != NULL)
				{
					pEle->SetTextPoint(pEle->GetDefaultTextLocation());

					// 支持相对标高，上下排列的文字复位
					pEle->SetLowTextPt(pEle->GetDefaultTextLocation2());
				}
				OPENOBJ_END();
			}
			else if (ent.Is(_T("AEC_POQIE")))// 剖面剖切，断面剖切对象
			{
				OPENOBJ_BEGIN(ent, AcDb::kForWrite, AecXDbSymbSection, pSection);
				if (pSection != NULL)
				{
					pSection->SetTextLocation(0,pSection->GetDefaultTextLocation(0));
					pSection->SetTextLocation(1,pSection->GetDefaultTextLocation(1));
					//add by lgy 20120528	为剖切图号设置文字位置
					pSection->SetIndexLocation(0, pSection->GetDefaultIndexLocation(0));
					pSection->SetIndexLocation(1, pSection->GetDefaultIndexLocation(1));
				}
				OPENOBJ_END();
			}
			else if (ent.Is(_T("AEC_ZHIBEIZHEN")))//指北针 add by lxb on 2011/12/22
			{
				OPENOBJ_BEGIN(ent, AcDb::kForWrite, AecXDbSymbNorthThumb, pNorthThumb);
				if (pNorthThumb != NULL)
				{
					pNorthThumb->SetTextPoint(pNorthThumb->GetDefaultTextLocation());
				}
				OPENOBJ_END();
			}
			else if (ent.Is(_T("AEC_SUOYINTUMING"))) // 索引图名，sg add 120117
			{
				OPENOBJ_BEGIN(ent, AcDb::kForWrite, AecXDbSymbDrawingIndex, pDrawingIndex);
				if (pDrawingIndex != NULL)
				{
					pDrawingIndex->SetScaleTextPt(pDrawingIndex->GetDefaultScaleTextLocation());
				}
				OPENOBJ_END();
			}
		}
    }
}
// Command: 尺寸复原
void ResetDimT()
{
    RBList mask(RTDXF0, _T("AEC_CHICUNBIAOZHU,AEC_BANJINGBIAOZHU"), NULL);
    PickEntSet ss(SS_FREE);
    if(GlobalFunc::SelectEntities(_T("\n请选择上华尺寸标注: "), ss, mask)==RTNORM) {
        long lCount=ss.Length();
        for(long i=0; i<lCount; i++) {
            Entity ent=ss[i];
            OPENOBJ_BEGIN(ent, AcDb::kForWrite, AcDbEntity, pDim);
            AecDbDimension *pDim1=AecDbDimension::cast(pDim);
            AecXDbRadiusDim *pDim2=AecXDbRadiusDim::cast(pDim);
            if(pDim1)  pDim1->ResetTextContent();
            else if(pDim2) pDim2->SetText(NULL);
            OPENOBJ_END();
        }
    }
}
// Command: 更改文字
void DimChText()
{
    RBList mask(RTDXF0, _T("DIMENSION,AEC_CHICUNBIAOZHU,AEC_BANJINGBIAOZHU"), NULL);
    Entity entMaster;
    XPoint ptPick;
    while(entMaster.FilterSelect(_T("\n请选择尺寸区间<退出>: "), mask, ptPick)==RTNORM) {
        Entity entDim;
        if(entMaster.Is(_T("DIMENSION"))) {
            if(!ConvertDim(entMaster, entDim)) {
                g_Option::instance().adsout << _T("\n不能转化ACAD尺寸标注对象!");
                return;
            } 
        } else {
            entDim=entMaster;
        }

        if(entDim.Is(_T("AEC_BANJINGBIAOZHU"))) {
            OPENOBJ_BEGIN(entDim, AcDb::kForRead, AecXDbRadiusDim, pDim);
            ASSERT(pDim);
            XString sText;
            XString sTemp=pDim->GetText();
            g_Option::instance().adsout << _T("\n输入标注文字<") << sTemp << _T(">: ");
            if(ads_getstring(1, _T(""), sText)==RTNORM) {
                if(pDim->upgradeOpen()==Acad::eOk) {
                    pDim->SetText(sText);
                    pDim->downgradeOpen();
                }
            }
            OPENOBJ_END();
        } else if(entDim.Is(_T("AEC_CHICUNBIAOZHU"))) {
            OPENOBJ_BEGIN(entDim, AcDb::kForRead, AecDbDimension, pDim);
            ASSERT(pDim);
            int nSeg=pDim->HitTestOnText(GlobalFunc::Ucs2Wcs(ptPick));
            if(nSeg<0) {
                g_Option::instance().adsout << _T("\n请正确点取在尺寸线上!");
            } else {
                XString sText;
                g_Option::instance().adsout << _T("\n输入标注文字<") << pDim->GetText(nSeg) << _T(">: ");
                if(ads_getstring(1, _T(""), sText)==RTNORM) {
                    if(pDim->upgradeOpen()==Acad::eOk) {
                        pDim->SetTextContent(nSeg, sText);
                        pDim->downgradeOpen();
                    }
                }
            }
            OPENOBJ_END();
        }
    }
}


//标注一根墙宽
//传入：ptLeft   左标注点
//      ptMid    中标注点
//      ptRight  右标注点
//      nDimAxis 轴线标志
//               = 1 标
//               = 0, 2 不标
//返回：成功, RTNORM; 出错, RTERROR
int DimOne(XPoint ptLeft, XPoint ptMid, XPoint ptRight, BOOL nDimAxis)
{
	if(ptMid.Distance2d(ptLeft)<g_Option::instance()._DIST_SNAP || ptMid.Distance2d(ptRight)<g_Option::instance()._DIST_SNAP) 
	{
		nDimAxis=FALSE;
	}
	AecDbDimension *pDim=new AecDbDimension;
	pDim->SetLayoutRotation(GlobalFunc::Ucs2Wcs(0));//add by whl on 060306
	pDim->SetLocation(ptLeft);
	pDim->SetRotation(ads_angle(ptLeft, ptRight));
	pDim->SetDist2DimLine(6.0, TRUE);
	pDim->AppendSegment(ptLeft.Distance2d(ptRight));
	AcDbObjectId idStyle=InitDimStyle(DS_LINEAR);
	pDim->SetStyleId(idStyle);


	AcGiTextStyle txtStyle;
	OPENOBJ_BEGIN(idStyle, AcDb::kForRead, AcDbDimStyleTableRecord, pStyle);
	ASSERT(pStyle);
	VERIFY(fromAcDbTextStyle(txtStyle, pStyle->dimtxsty())==Acad::eOk);
	int nRetFlag=txtStyle.loadStyleRec();
	txtStyle.setTextSize(pStyle->dimtxt()*pDim->GetPScale()*0.8);
	OPENOBJ_END();

	if(nDimAxis)    
	{
		pDim->AddSegment(ptMid);

		//add by lxb on 2011/11/18
		//针对基线在墙外时调整标注的显示位置
		XLine line(ptLeft, ptRight, LS_FINITE);
		ADSGePoint3d ptLRMid  = line.MidPoint();

		ads_real rHLeft =  ads_distance(ptLeft, ptMid)/2,  // ZJQ modify 2 to 4, so it is more close to wall
			rHRight = ads_distance(ptMid, ptRight)/2,
			// rALeft = ads_angle(ptMid, ptLeft),      //左标移动方向
			// rARight = ads_angle(ptMid, ptRight);    //右标移动方向
			rALeft = ads_angle(ptLRMid, ptLeft),       //左标移动方向
			rARight = ads_angle(ptLRMid, ptRight);     //右标移动方向
		AcGePoint2d ptExt=txtStyle.extents(pDim->GetText(0), Adesk::kFalse, -1, Adesk::kTrue);
		rHLeft += ptExt[0]/2 + 1.0*pDim->GetPScale();
		ptExt = txtStyle.extents(pDim->GetText(1),  Adesk::kFalse, -1, Adesk::kTrue);
		rHRight += ptExt[0]/2 + 1.0*pDim->GetPScale();
		XVector3D vtLeft(rHLeft*cos(rALeft), rHLeft*sin(rALeft));
		XVector3D vtRight(rHRight*cos(rARight), rHRight*sin(rARight));
		XPoint ptLText=pDim->GetTextPos(0);
		ptLText += vtLeft;
		XPoint ptRText=pDim->GetTextPos(1);
		ptRText += vtRight;
		pDim->SetTextPos(0, ptLText);
		pDim->SetTextPos(1, ptRText);
	}    
	else   
	{
		ads_real rHWidth = ads_distance(ptLeft, ptRight)/2, // ZJQ modify 2 to 4, so it is more close to wall
			rAngle = ads_angle(ptLeft, ptRight);       //移动方向
		AcGePoint2d ptExt=txtStyle.extents(pDim->GetText(0), Adesk::kTrue, -1, Adesk::kTrue);
		rHWidth += ptExt[0]/2 + 1.0*pDim->GetPScale();
		XVector3D vtMove(rHWidth*cos(rAngle), rHWidth*sin(rAngle));
		XPoint ptText=pDim->GetTextPos(0);
		ptText += vtMove;
		pDim->SetTextPos(0, ptText);
	}

	// sg add 120410，增加布局转角的设置，解决UCS下，文字方向错误的问题
	pDim->SetLayoutRotation(GlobalFunc::Ucs2Wcs(0.0));

	// modify by xly on 110107 支持图层切换
	//pDim->AddToMSpace(Adesk::kTrue);
	GlobalFunc::AddToSpace(Adesk::kTrue, pDim);
	return RTNORM;
}


/////////////////////////////////////////////////////////////////
// Command: 打断尺寸
void DimBreak()
{
    RBList mask(RTDXF0, _T("AEC_CHICUNBIAOZHU"), NULL);
    Entity ent;
    XPoint ptPick;
    if(GlobalFunc::SelectEntity(_T("\n请在要打断的一侧点取尺寸线<退出>: "), ent, ptPick, mask)==RTNORM) 
	{
        ptPick=GlobalFunc::Ucs2Wcs(ptPick);
        OPENOBJ_BEGIN(ent, AcDb::kForWrite, AecDbDimension, pDim);
        if(pDim) 
		{
            if(pDim->IsBind()) 
			{
                g_Option::instance().adsout << _T("\n此尺寸标注绑定在其他对象上, 因此不能编辑!");
                return;
            }
            int nSeg = pDim->HitTestOnDimSeg(ptPick);
			if(nSeg < 0||nSeg>=pDim->GetSegmentNum()) 
                return;

            XPoly2D poly;
            pDim->GetPolySegOnDimLine(poly);
          
            XDirectionCurve seg;
            poly.Nth(nSeg, seg);
            XPoint ptLoc;
            double nDist1 = ads_distance(seg.StartPoint(), ptPick);
            double nDist2 = ads_distance(seg.EndPoint(), ptPick);
            if(nDist1>nDist2)
                nSeg++;

			if(nSeg<0||nSeg>=pDim->GetSegmentNum())
				return;
            poly.Nth(nSeg, seg);

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

            AecDbDimension *pDimNew=(AecDbDimension *)pDim->clone(); 
            for(int i=0; i<nSeg; i++)
                pDimNew->RemoveSegment(0);
            pDimNew->SetLocation(ptLoc);
            pDimNew->SetRotation(nRot);
            GlobalFunc::AddToCurrentSpace(pDimNew, Adesk::kTrue);
            int nTotalSeg=poly.TotalSegments();
            for(i=nSeg; i<nTotalSeg; i++) 
                pDim->RemoveSegment(nSeg);
            
        }            
        OPENOBJ_END();
    }
}

/////////////////////////////////////////////////////////////////
// Command: 取消尺寸区间
void RemoveDimSeg()
{
	// 解决选中标注后，运行“取消标注”命令，当删除最后一个标注崩溃的问题
	ads_name name = {0, 0};
	acedSSSetFirst(name, NULL);
	// end

	PickEntSet sets(SS_FREE);
	RBList mask(RTDXF0, _T("AEC_CHICUNBIAOZHU"), NULL);
	Entity ent;
	XPoint ptPick;

	while(1)
	{
		int iRet;
		CHookMsg hookmsg;
		INITGET_BEG(0,_T("A"))
		iRet = GlobalFunc::SelectEntity(_T("\n选择待删除尺寸的区间线或尺寸文字[整体删除(A)]<退出>: "), ent, ptPick, mask);
		INITGET_END()
		if (iRet == RTERROR)
		{
			if (hookmsg.GetValue() == 0)
				continue;
			else
				return;
		}
		if (iRet == RTCAN)
			return;	
		if (iRet == RTKWORD)
		{
			TCHAR buf[256];
			acedGetInput(buf);
			if(buf[0] == _T('A') || buf[0] == _T('a'))
			{
				RBList rb(RTDXF0, _T("AEC_CHICUNBIAOZHU"));
				if (GlobalFunc::SelectEntities(_T("\n选择待删除的所有尺寸对象<退出>:"), sets, rb) != RTNORM)
					return;
				sets.Erase();
				return;
			}
		}
		ptPick = GlobalFunc::Ucs2Wcs(ptPick);
		OPENOBJ_BEGIN(ent, AcDb::kForWrite, AecDbDimension, pDim);
		if (pDim)
		{
			if (pDim->IsBind())
			{
				g_Option::instance().adsout << _T("\n此尺寸标注绑定在其他对象上, 因此不能编辑!");
				return;
			}
			int nSeg = -1;
			SubText* psubtext = pDim->HitTestText(ptPick);
			if (psubtext == NULL)
			{
				nSeg = pDim->HitTestOnDimSeg(ptPick);
			}
			else
			{
				nSeg = psubtext->GetIndex();
				delete psubtext;
				psubtext = NULL;
			}

			if (nSeg >= 0)
			{
				XPoly2D poly;
				pDim->GetPolySegOnDimLine(poly);
				int n = poly.TotalSegments();
				ASSERT(nSeg < poly.TotalSegments());
				if (nSeg == poly.TotalSegments() - 1)
				{
					pDim->RemoveSegment(nSeg);
					if (!pDim->IsValid())
						pDim->erase();
				}
				else if (nSeg == 0)
				{
					XDirectionCurve seg;
					poly.Nth(1, seg);
					double nDist2DimLine = pDim->GetDist2DimLine(FALSE);
					double nRot = seg.IDirection(0);
					XPoint ptLoc;
					ads_polar(seg.StartPoint(), nRot - PI / 2.0, nDist2DimLine, ptLoc);
					pDim->RemoveSegment(nSeg);
					pDim->SetLocation(ptLoc);
					pDim->SetRotation(nRot);
				}
				else
				{
					AecDbDimension *pDimNew = (AecDbDimension *)pDim->clone();
					XDirectionCurve seg;
					poly.Nth(nSeg + 1, seg);
					double nRot = seg.IDirection(0);
					XPoint ptLoc;
					ads_polar(seg.StartPoint(), nRot - PI / 2.0, pDimNew->GetDist2DimLine(FALSE), ptLoc);
					for (int i = 0; i <= nSeg; i++)
						pDimNew->RemoveSegment(0);
					pDimNew->SetLocation(ptLoc);
					pDimNew->SetRotation(nRot);
					GlobalFunc::AddToCurrentSpace(pDimNew, Adesk::kTrue);
					int nTotalSeg = poly.TotalSegments();
					for (i = nSeg; i < nTotalSeg; i++)
						pDim->RemoveSegment(nSeg);
				}
			}
		}
		OPENOBJ_END();
	}
}
void DimTextMirror()
{
    RBList mask(RTDXF0, _T("AEC_CHICUNBIAOZHU"), NULL);
    Entity ent;
    XPoint ptPick;
    if(GlobalFunc::SelectEntity(_T("\n请选择上华尺寸标注<退出>: "), ent, ptPick, mask)==RTNORM) {
        ptPick=GlobalFunc::Ucs2Wcs(ptPick);
        OPENOBJ_BEGIN(ent, AcDb::kForWrite, AecDbDimension, pDim);
        if(pDim) {
            int nSeg=pDim->HitTestOnText(ptPick);
            if(nSeg>=0) {
                XPoly2D poly;
                pDim->GetPolySegOnDimLine(poly);
                ASSERT(nSeg<poly.TotalSegments());
                XPoint ptText=pDim->GetTextPos(nSeg);
                GeCurveSegment seg;
                poly.Nth(nSeg, seg);
                XPoint ptOnSeg;
                if(pDim->IsAngular() && pDim->IsDimChord())
                    seg=XLine(seg.StartPoint(), seg.EndPoint());
                if(seg.ProjectToMe(ptText, ptOnSeg)==RTNORM) {
                    XPoint ptTextNew;
                    ptOnSeg.Mirror(ptText, ptTextNew);
                    pDim->SetTextPos(nSeg, ptTextNew);
                }
            }
        }
        OPENOBJ_END();
    }
}

// Command: 裁剪延伸
// 支持尺寸自调
void DimTrimOrExt()
{
	//wlw mod 2013.5.29 先选尺寸线后裁剪
    Entity entDim;
    RBList mask(RTDXF0, _T("AEC_CHICUNBIAOZHU,DIMENSION"), NULL);
    XPoint ptPick;
    if(entDim.FilterSelect(_T("\n要裁剪或延伸的尺寸线<退出>: "), mask, ptPick) != RTNORM) 
	{
		return;
	}
    if(entDim.Is(_T("DIMENSION")))
	{
        Entity entNew;
        if(!ConvertDim(entDim, entNew))
		{
            g_Option::instance().adsout << _T("\n不能转化ACAD尺寸标注对象!");
            return;
        } 
		else if(!entDim.Is(_T("AEC_CHICUNBIAOZHU"))) 
		{
            g_Option::instance().adsout << _T("\n不是线性标注!");
            return;
        }
        entDim=entNew;
    }
    ptPick=GlobalFunc::Ucs2Wcs(ptPick);

	OPENOBJ_BEGIN(entDim, AcDb::kForRead, AecDbDimension, pDim1);
	if(pDim1 !=NULL && pDim1->IsBind()) 
	{
		g_Option::instance().adsout << _T("\n尺寸对象已经绑定在其他对象上,不能进行编辑!");
		return;
	}
	else
	{
		pDim1->getClosestPointTo(ptPick,ptPick);
	}
	OPENOBJ_END()

	entDim.Redraw(3);

	XPoint ptBase;
	ptPick=GlobalFunc::Wcs2Ucs(ptPick);

	if(acedGetPoint(ptPick, _T("\n请给出裁剪延伸的基准点"), ptBase) != RTNORM)
	{
		entDim.Redraw(4);
		return;
	}
	entDim.Redraw(4);
    OPENOBJ_BEGIN(entDim, AcDb::kForWrite, AecDbDimension, pDim);
    if(pDim->IsBind()) 
	{
        g_Option::instance().adsout << _T("\n尺寸对象已经绑定在其他对象上,不能进行编辑!");
        return;
    }
	ptBase=GlobalFunc::Ucs2Wcs(ptBase);
    GeCurveSegment seg=pDim->GetDimCurve();
    XPoint ptBaseOnSeg;
    VERIFY(seg.ProjectToMe(ptBase, ptBaseOnSeg)==RTNORM);
    if((ptBaseOnSeg&seg)!=PR_INSIDE)
	{
        if(pDim->AddSegment(ptBaseOnSeg))
		{
            AcGePoint3dArray ptArray;
            pDim->getStretchPoints(ptArray);
            AcDbIntArray indices;
            if(ptBaseOnSeg.Distance2d(seg.StartPoint())<ptBaseOnSeg.Distance2d(seg.EndPoint())) 
			{
                AcGeVector3d vtOffset=ptArray[2]-ptArray[2+1];
                indices.append(3);
                pDim->moveGripPointsAt(indices, vtOffset);
            } 
			else
			{
                int numSeg=pDim->GetSegmentNum();
                AcGeVector3d vtOffset=ptArray[2+numSeg]-ptArray[2+numSeg-1];
                indices.append(2+numSeg-1);
                pDim->moveGripPointsAt(indices, vtOffset);
            }
			if(g_Option::instance().g_nDimAdjust)
				pDim->AdjustDim(g_Option::instance().g_nDimAdjust!=2, TRUE, FALSE);
        }
    } 
	else 
	{
		pDim->getClosestPointTo(ptBase, ptBase);
		AcGePoint3dArray points;
		AcDbVoidPtrArray curveSegments;
		points.append(ptBase);
		if (pDim->getSplitCurves(points, curveSegments) != Acad::eOk)
		{
			return;
		}

		if (curveSegments.length() == 2)
		{
			pDim->erase();
			
			AecDbDimension *pDim1 = (AecDbDimension*)curveSegments[0];
			AecDbDimension *pDim2 = (AecDbDimension*)curveSegments[1];

			if (pDim1->GetTotalSegValue() > pDim2->GetTotalSegValue() )
			{
				GlobalFunc::AddToModelSpace((AcDbEntity*)curveSegments[0]);
				delete pDim2;
			}
			else
			{
				GlobalFunc::AddToModelSpace((AcDbEntity*)curveSegments[1]);
				delete pDim1;
			}
			return;
		}
    }
    OPENOBJ_END()
}

int CmpPoint(const XPoint *pt1, const XPoint *pt2)
{
	if(pt1->z < pt2->z)
		return -1;
	else
		return 1;
}
// add by lcf 2004/08/11
class TDimTwoPointArg
{
public:
	DListStack<XPoint> m_ptStack;
	void AddDim(AcDbObjectId idDim, XPoint ptNew);
	void RemoveDim(AcDbObjectId idDim, XPoint ptOld);
	void Step(XPoint ptNew);
	BOOL CanUndo();
	void Undo(AcDbObjectId idDim);
	XPoint GetLastPoint();
};

void TDimTwoPointArg::AddDim(AcDbObjectId idDim, XPoint ptNew)
{
	ptNew = GlobalFunc::Ucs2Wcs(ptNew);
	OPENOBJ_BEGIN(idDim, AcDb::kForWrite, AecDbDimension, pDimNew);
	ASSERT(pDimNew);
	pDimNew->AddSegment(ptNew);
	if(g_Option::instance().g_nDimAdjust) 
		pDimNew->AdjustDim(g_Option::instance().g_nDimAdjust!=2);
	OPENOBJ_END();
}

void TDimTwoPointArg::RemoveDim(AcDbObjectId idDim, XPoint ptOld)
{
	ptOld = GlobalFunc::Ucs2Wcs(ptOld);
	OPENOBJ_BEGIN(idDim, AcDb::kForWrite, AecDbDimension, pDimNew);
	ASSERT(pDimNew);
	pDimNew->FindAndRemoveSegment(ptOld);
	if(g_Option::instance().g_nDimAdjust) pDimNew->AdjustDim(g_Option::instance().g_nDimAdjust!=2);
	OPENOBJ_END();
}
void TDimTwoPointArg::Step(XPoint ptNew)
{
	m_ptStack.Push(ptNew);
}

BOOL TDimTwoPointArg::CanUndo()
{
	return m_ptStack.GetDepth() > 0;
}

void TDimTwoPointArg::Undo(AcDbObjectId idDim)
{
	XPoint pt;
	m_ptStack.GetTopData(pt);
	if(CanUndo())
		RemoveDim(idDim, pt);
	m_ptStack.GoBack();
}

XPoint TDimTwoPointArg::GetLastPoint()
{
	XPoint pt;
	m_ptStack.GetTopData(pt);
	return pt;
}

//wlw 121017 显示两点标注后的jig效果，实现距离墙远近不同标注内容
class T2PtDimensionJig : public AcEdJig
{
public:
	T2PtDimensionJig(AecDbDimension *pDim, const GeCurveSegment& wall,const ADSGePointList& lstPts,
		const ADSGePointList& lstPts1,const ADSGePointList& lstPts2);
	AcEdJig::DragStatus doIt();
	virtual DragStatus sampler();
	virtual Adesk::Boolean update();
	virtual AcDbEntity* entity() const;
	AecDbDimension *m_pDrawEnt;  
	AcGePoint3d m_ptDim;		
	int m_bFlag;				//判断近端还是远端
	BOOL m_bAppend;				//用来决定远近端变换的
	GeCurveSegment m_segwall;	//用来判断远近端的参考墙基线
	ADSGePointList m_lstPts;	//所有墙的投影点
	ADSGePointList m_lstPts1;	//近端门窗的投影点
	ADSGePointList m_lstPts2;	//远端门窗的投影点
};

T2PtDimensionJig::T2PtDimensionJig(AecDbDimension *pDim, const GeCurveSegment& wall,const ADSGePointList& lstPts,
								   const ADSGePointList& lstPts1,const ADSGePointList& lstPts2)
{
	m_pDrawEnt = pDim;
	m_bFlag = 1;
	m_bAppend = FALSE;
	m_segwall = wall;
	m_lstPts.copyFrom(lstPts);
	m_lstPts1.copyFrom(lstPts1);
	m_lstPts2.copyFrom(lstPts2);

	int nLen = m_lstPts.Length();
	for(int n = 0; n < nLen; n++) 
	{
		m_pDrawEnt->AddSegment(*m_lstPts[n]);
	}
	//初始值为墙近端的门窗标注
	nLen = m_lstPts1.Length();
	for(n = 0; n < nLen; n++) 
	{
		m_pDrawEnt->AddSegment(*m_lstPts1[n]);
	}
	m_pDrawEnt->SetFixLinePos(m_segwall.StartPoint());

}

AcEdJig::DragStatus T2PtDimensionJig::doIt()
{
	setDispPrompt(_T("\n选择标注位置点"));
	return drag();
}

AcEdJig::DragStatus T2PtDimensionJig::sampler()
{
	setUserInputControls((UserInputControls)
		(AcEdJig::kAccept3dCoordinates | AcEdJig::kNullResponseAccepted));

	XPoint ptCursor;
	DragStatus stat = acquirePoint(ptCursor);
	if(stat == AcEdJig::kNormal) 
	{
		if (ptCursor.Distance2d(m_ptDim) > g_Option::instance()._DIST_SNAP)
			m_ptDim = ptCursor;
		else 
			stat = AcEdJig::kNoChange;
	}
	return stat;
}

Adesk::Boolean T2PtDimensionJig::update()
{
	using namespace GlobalFunc;
	ADSGePoint3d ptProj;
	m_segwall.ProjectToMe(m_ptDim, ptProj);
	int nLen = 0;
	int nNum = 0, n = 0;
	ADSGePoint3d ptSide,ptSide1;
	if (m_bFlag == 1)
	{//当前标注在近端
		if (ptProj.Distance2d(m_segwall.StartPoint()) > ptProj.Distance2d(m_segwall.EndPoint()))
		{
			m_bFlag = 2;
			m_bAppend = TRUE;
		}
	}
	else if (m_bFlag == 2)
	{//当前标注在远端
		if (ptProj.Distance2d(m_segwall.StartPoint()) < ptProj.Distance2d(m_segwall.EndPoint()))
		{
			m_bFlag = 1;
			m_bAppend = TRUE;
		}
	}

	if (m_bAppend)
	{
		m_bAppend = FALSE;
		double dr = m_segwall.Direction(m_ptDim);
		int ncount = m_pDrawEnt->GetSegmentNum();
		while(m_pDrawEnt->GetSegmentNum() > 0)
			m_pDrawEnt->RemoveSegment(0);

		m_pDrawEnt->SetLocation(*m_lstPts[0]);

		nLen = m_lstPts.Length();
		for(n = 0; n < nLen; n++) 
		{
			m_pDrawEnt->AddSegment(*m_lstPts[n]);
		}
		if (m_bFlag == 2)
		{
			nLen = m_lstPts2.Length();
			ptSide = m_segwall.EndPoint();
			for(n = 0; n < nLen; n++) 
			{
				m_pDrawEnt->AddSegment(*m_lstPts2[n]);
			}
		}
		else if (m_bFlag == 1)
		{
			nLen = m_lstPts1.Length();
			ptSide = m_segwall.StartPoint();
			for(n = 0; n < nLen; n++) 
			{
				m_pDrawEnt->AddSegment(*m_lstPts1[n]);
			}
		}
		ADSGePoint3d ptEnd=*m_lstPts[m_lstPts.Length()-1],ptStart=*m_lstPts[0];
		XVector3D vt=ptEnd-ptStart;
		XVector3D vtSeg(m_segwall.EndPoint().x-m_segwall.StartPoint().x,m_segwall.EndPoint().y-m_segwall.StartPoint().y);
		if((vt*vtSeg).z<0)
			dr+=PI/2;
		else 
			dr-=PI/2;
		m_pDrawEnt->SetFixLinePos(ptSide);
	}

	GeCurveSegment seg = m_pDrawEnt->GetDimCurve();
	seg.ProjectToMe(m_ptDim, ptProj);
	double nDistMove = ptProj.Distance2d(m_ptDim);
	int nSideLoc=seg.OnWhichSide(m_pDrawEnt->GetLocation());
	int nSide=seg.OnWhichSide(m_ptDim);
	double nDist2Dim = m_pDrawEnt->GetDist2DimLine(FALSE);

	if(fabs(nDist2Dim) > 1.0E-6) 
	{
		double nFactor=nDist2Dim/fabs(nDist2Dim);
		if(nSide!=nSideLoc) 
			nDistMove *= nFactor;
		else 
			nDistMove *= -nFactor;
	} 
	else 
	{
		if(nSideLoc == OFFSET_LEFT)
			nDistMove = -nDistMove;
	}
	if(m_pDrawEnt->IsAngular()) 
	{ //弧墙有错，不知道原因
		nDist2Dim += nDistMove; 
		double nDistRad= m_pDrawEnt->GetDimRadius();
		//seg.GetArc().center.Distance(m_ptDim); 
		nDistRad -= nDistMove;
		if(nDistRad>g_Option::instance()._DIST_SNAP) 
		{
			m_pDrawEnt->SetDimRadius(nDistRad);
			m_pDrawEnt->SetDist2DimLine(nDist2Dim, FALSE);
		}
	} 
	else
	{
		nDist2Dim += nDistMove; 
		m_pDrawEnt->SetDist2DimLine(nDist2Dim, FALSE);
	}
	return Adesk::kTrue;
}

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

//wlw 130529 显示两点标注后的双线标注jig效果，实现距离墙远近不同标注内容
class T2PtDimensionJig2 : public AcEdJig
{
public:
	T2PtDimensionJig2(AecDbDimension *pDim, const GeCurveSegment& wall,const ADSGePointList& lstPts,
					const ADSGePointList& lstPts1,const ADSGePointList& lstPts2, AecDbDimension *pDim2);
	AcEdJig::DragStatus doIt();
	virtual DragStatus sampler();
	virtual Adesk::Boolean update();
	virtual AcDbEntity* entity() const;
	//AecDbDimension *m_pDrawEnt;  
	AcGePoint3d m_ptDim;		
	int m_bFlag;				//判断近端还是远端
	BOOL m_bAppend;				//用来决定远近端变换的
	GeCurveSegment m_segwall;	//用来判断远近端的参考墙基线
	ADSGePointList m_lstPts;	//所有墙的投影点
	ADSGePointList m_lstPts1;	//近端门窗的投影点
	ADSGePointList m_lstPts2;	//远端门窗的投影点

	TMulDimEntity1 m_pDim;//标注

};

T2PtDimensionJig2::T2PtDimensionJig2(AecDbDimension *pDim, const GeCurveSegment& wall,const ADSGePointList& lstPts,
								 const ADSGePointList& lstPts1,const ADSGePointList& lstPts2,AecDbDimension *pDim2)
{
	m_pDim.m_pDrawEnt = pDim;
	m_pDim.m_pDrawEnt2 = pDim2;
	m_bFlag = 1;
	m_bAppend = FALSE;
	m_segwall = wall;
	m_lstPts.copyFrom(lstPts);
	m_lstPts1.copyFrom(lstPts1);
	m_lstPts2.copyFrom(lstPts2);

	int nLen = m_lstPts.Length();
	for(int n = 0; n < nLen; n++) 
	{
		m_pDim.m_pDrawEnt->AddSegment(*m_lstPts[n]);
	}
	//初始值为墙近端的门窗标注
	nLen = m_lstPts1.Length();
	for(n = 0; n < nLen; n++) 
	{
		m_pDim.m_pDrawEnt->AddSegment(*m_lstPts1[n]);
	}
	m_pDim.m_pDrawEnt->SetFixLinePos(m_segwall.StartPoint());

	AcGePoint3d pts,pte;
	m_pDim.m_pDrawEnt->getStartPoint(pts);
	m_pDim.m_pDrawEnt->getEndPoint(pte);

	m_pDim.m_pDrawEnt2->SetLocation(pts);

	m_pDim.m_pDrawEnt2->AddSegment(pts);
	m_pDim.m_pDrawEnt2->AppendSegment(pte.distanceTo(pts));

	m_pDim.m_pDrawEnt2->SetFixLinePos(m_segwall.StartPoint());


}

AcEdJig::DragStatus T2PtDimensionJig2::doIt()
{
	setDispPrompt(_T("\n选择标注位置点"));
	return drag();
}

AcEdJig::DragStatus T2PtDimensionJig2::sampler()
{
	setUserInputControls((UserInputControls)
		(AcEdJig::kAccept3dCoordinates | AcEdJig::kNullResponseAccepted));

	XPoint ptCursor;
	DragStatus stat = acquirePoint(ptCursor);
	if(stat == AcEdJig::kNormal) 
	{
		if (ptCursor.Distance2d(m_ptDim) > g_Option::instance()._DIST_SNAP)
			m_ptDim = ptCursor;
		else 
			stat = AcEdJig::kNoChange;
	}
	return stat;
}

Adesk::Boolean T2PtDimensionJig2::update()
{
	using namespace GlobalFunc;
	ADSGePoint3d ptProj;
	m_segwall.ProjectToMe(m_ptDim, ptProj);
	int nLen = 0;
	int nNum = 0, n = 0;
	ADSGePoint3d ptSide,ptSide1;
	if (m_bFlag == 1)
	{//当前标注在近端
		if (ptProj.Distance2d(m_segwall.StartPoint()) > ptProj.Distance2d(m_segwall.EndPoint()))
		{
			m_bFlag = 2;
			m_bAppend = TRUE;
		}
	}
	else if (m_bFlag == 2)
	{//当前标注在远端
		if (ptProj.Distance2d(m_segwall.StartPoint()) < ptProj.Distance2d(m_segwall.EndPoint()))
		{
			m_bFlag = 1;
			m_bAppend = TRUE;
		}
	}

	if (m_bAppend)
	{
		m_bAppend = FALSE;
		double dr = m_segwall.Direction(m_ptDim);
		int ncount = m_pDim.m_pDrawEnt->GetSegmentNum();
		while(m_pDim.m_pDrawEnt->GetSegmentNum() > 0)
			m_pDim.m_pDrawEnt->RemoveSegment(0);

		while(m_pDim.m_pDrawEnt2->GetSegmentNum() > 0)
			m_pDim.m_pDrawEnt2->RemoveSegment(0);

		m_pDim.m_pDrawEnt->SetLocation(*m_lstPts[0]);

		nLen = m_lstPts.Length();
		for(n = 0; n < nLen; n++) 
		{
			m_pDim.m_pDrawEnt->AddSegment(*m_lstPts[n]);
		}
		if (m_bFlag == 2)
		{
			nLen = m_lstPts2.Length();
			ptSide = m_segwall.EndPoint();
			for(n = 0; n < nLen; n++) 
			{
				m_pDim.m_pDrawEnt->AddSegment(*m_lstPts2[n]);
			}
		}
		else if (m_bFlag == 1)
		{
			nLen = m_lstPts1.Length();
			ptSide = m_segwall.StartPoint();
			for(n = 0; n < nLen; n++) 
			{
				m_pDim.m_pDrawEnt->AddSegment(*m_lstPts1[n]);
			}
		}
		ADSGePoint3d ptEnd=*m_lstPts[m_lstPts.Length()-1],ptStart=*m_lstPts[0];
		XVector3D vt=ptEnd-ptStart;
		XVector3D vtSeg(m_segwall.EndPoint().x-m_segwall.StartPoint().x,m_segwall.EndPoint().y-m_segwall.StartPoint().y);
		if((vt*vtSeg).z<0)
			dr+=PI/2;
		else 
			dr-=PI/2;

 		m_pDim.m_pDrawEnt->SetFixLinePos(ptSide);

		m_pDim.m_pDrawEnt->getStartPoint(ptStart);
		m_pDim.m_pDrawEnt->getEndPoint(ptEnd);
		m_pDim.m_pDrawEnt2->SetLocation(ptStart);
		m_pDim.m_pDrawEnt2->AddSegment(ptStart);
		m_pDim.m_pDrawEnt2->AppendSegment(ptEnd.Distance2d(ptStart));
		m_pDim.m_pDrawEnt2->SetFixLinePos(ptSide);

	}

	XPoint ptOnSeg;
	GeCurveSegment seg;
	seg = m_pDim.m_pDrawEnt->GetDimCurve();
	if(seg.ProjectToMe(m_ptDim, ptOnSeg) == RTNORM) 
	{
		double nDistMove = ptOnSeg.Distance2d(m_ptDim);
		int nSideLoc = seg.OnWhichSide(m_pDim.m_pDrawEnt->GetLocation());
		int nSide = seg.OnWhichSide(m_ptDim);
		double nDist2Dim = m_pDim.m_pDrawEnt->GetDist2DimLine(FALSE);
		double nFactor = nDist2Dim/fabs(nDist2Dim);
		if(fabs(nDist2Dim) > 1.0E-6) 
		{
			if(nSide != nSideLoc) 
			{
				nDistMove *= nFactor;
			}
			else
			{
				nDistMove *= -nFactor;
			}
		} 
		else 
		{
			if(nSideLoc == OFFSET_LEFT) 
				nDistMove *= -1;
		}
		nDist2Dim += nDistMove;
		m_pDim.m_pDrawEnt->SetDist2DimLine(nDist2Dim, FALSE);
		double ddis = m_pDim.m_pDrawEnt->GetPScale() * 8;
		if(nDist2Dim >= 0)
			nDist2Dim += ddis;
		else 
			nDist2Dim -= ddis;
		m_pDim.m_pDrawEnt2->SetDist2DimLine(nDist2Dim, FALSE);	

	}
	return Adesk::kTrue;
}

AcDbEntity* T2PtDimensionJig2::entity() const
{
	return (AcDbEntity*)&m_pDim;
}

class TLeaderJig : public AcEdJig
{
public:
	TLeaderJig(AcGePoint3d pt)
	{

		m_pEnt = new AcDbLine;
		m_pt = pt;
		m_pEnt->setStartPoint(m_pt);
	}
	~TLeaderJig(){delete m_pEnt;}
	int doIt()
	{
		setDispPrompt(_T("\n选择标注位置点"));
		return drag();
	}
	virtual DragStatus sampler()
	{
		setSpecialCursorType(AcEdJig::kNoSpecialCursor);
		setUserInputControls((UserInputControls)
			(AcEdJig::kAccept3dCoordinates | AcEdJig::kNullResponseAccepted));

		AcGePoint3d ptCursor;
		return acquirePoint(ptCursor, m_pt);
	}

	virtual Adesk::Boolean update(){return Adesk::kTrue;}
	virtual AcDbEntity* entity() const{return (AcDbEntity*)m_pEnt;}
protected:
	AcGePoint3d m_pt;
	AcGePoint3d m_ptE;
	AcDbLine *m_pEnt;
};

Adesk::Boolean isParallelToEnt(EntitySet ent1,EntitySet ent2)
{
	AcGeTol tol;
	tol.setEqualPoint(0.1);
	tol.setEqualVector(0.1);
	AcGePoint3d pt1s,pt1e,pt2s,pt2e;
	OPENOBJ_BEGIN(ent1, AcDb::kForRead, AcDbCurve, pent1)
		if (pent1 != NULL)
		{
			pent1->getEndPoint(pt1e);
			pent1->getStartPoint(pt1s);
		}
	OPENOBJ_END()

	OPENOBJ_BEGIN(ent2, AcDb::kForRead, AcDbCurve, pent2)
	if (pent2 != NULL)
	{
		pent2->getEndPoint(pt2e);
		pent2->getStartPoint(pt2s);
	}
	OPENOBJ_END()

	AcGeVector3d vt1 = pt1s - pt1e,vt2 = pt2s - pt2e;
	return vt1.isParallelTo(vt2, tol);
}

// Command: 尺寸自调
void DimAdjust()
{
    RBList mask(RTDXF0, _T("AEC_CHICUNBIAOZHU"), NULL);
	PickEntSet ss(SS_FREE);
    if(GlobalFunc::SelectEntities(_T("\n请选择上华尺寸标注: "), ss, mask)==RTNORM) {
		long lCount=ss.Length();
		for(long i=0L; i<lCount; i++) {
			Entity ent=ss[i];
			OPENOBJ_BEGIN(ent, AcDb::kForWrite, AecDbDimension, pDim);
			if(pDim) {
				pDim->ResetTextPos();
				pDim->AdjustDim(g_Option::instance().g_nDimAdjust!=2, TRUE);
			}
			OPENOBJ_END();
		}
    }
}

void BreakDim()
{
	//wlw mod 2013.5.29 引线位置太乱
    RBList mask(RTDXF0, _T("DIMENSION,AEC_CHICUNBIAOZHU"), NULL);
    Entity entMaster;
	ADSGePoint3d ptPick;
    if(GlobalFunc::SelectEntity(_T("\n请选择尺寸标注<退出>: "), entMaster, mask) != RTNORM)
        return;

	Entity entDim;
    if(entMaster.Is(_T("DIMENSION"))) {
        if(!ConvertDim(entMaster, entDim)) {
            g_Option::instance().adsout << _T("\n不能转化ACAD尺寸标注对象!");
            return;
        }  else if(!entDim.Is(_T("AEC_CHICUNBIAOZHU"))) {
            g_Option::instance().adsout << _T("\n不是线性标注!");
            return;
        }
    } else {
        entDim=entMaster;
    }
	
    OPENOBJ_BEGIN(entDim, AcDb::kForRead, AecDbDimension, pDim);
	if(pDim!=NULL)
	{
		XPoint ptBase;
		int nSeg = pDim->HitTestOnText(ptPick);
		GePoly2D poly;
		pDim->GetPolySegOnDimLine(poly);
		int nCount = poly.Length();
		ptBase = *poly[nSeg];
 		int nRet;
		XPoint ptAdd;
		XString szPrompt;
		XPointList lstAddPoint, lstBasePoint;
		lstBasePoint.Append(new XPoint(ptBase));
		while(1)
		{
			pDim->GetPolySegOnDimLine(poly);
			int nCount = poly.Length();
			int nLen = lstAddPoint.Length();
			if(nLen == 0)
				_stprintf(szPrompt, _T("\n点取待增补的标注点的位置或 [参考点(R)]<退出>:"));
			else
				_stprintf(szPrompt, _T("\n点取待增补的标注点的位置或 [参考点(R)/撤消上一标注点(U)]<退出>:"));

			INITGET_BEG(0, _T("U R"));
			nRet = acedGetPoint(ptBase, szPrompt, ptAdd);
			INITGET_END();
			if(nRet == RTNORM)
			{
				ptAdd = GlobalFunc::Ucs2Wcs(ptAdd);
				ptBase = ptAdd;
				if(pDim->upgradeOpen() == Acad::eOk) 
				{
					if(!pDim->AddSegment(ptAdd))
						g_Option::instance().adsout << _T("\n点取位置不合适!");
					else
					{
						lstAddPoint.Append(new XPoint(ptAdd));
						lstBasePoint.Append(new XPoint(ptBase));
						if(g_Option::instance().g_nDimAdjust)//add by whl on 050530
							pDim->AdjustDim(g_Option::instance().g_nDimAdjust!=2);
					}
					pDim->downgradeOpen();
				}
				GeCurveSegment seg(*poly[0],*poly[nCount-1],0);
				seg.ProjectToMe(ptBase,ptBase);
			}
			else if(nRet == RTKWORD)
			{
				XString sKey;
				acedGetInput(sKey);
				if(sKey[0] == _T('R'))
					acedGetPoint(NULL, _T("\n参考点:"), ptBase);
				else if(sKey[0] == _T('U'))
				{
					if(pDim->upgradeOpen() == Acad::eOk) 
					{
						if(nLen > 0)
						{
							ptAdd = *lstAddPoint.Tail();
							lstAddPoint.Remove(nLen-1);
							pDim->HitTestOnPoint(ptAdd);
							pDim->FindAndRemoveSegment(ptAdd);
							lstBasePoint.Remove(nLen);
							ptBase = *lstBasePoint.Tail();
						}
						pDim->downgradeOpen();
					}
				}
			}
			else
				break;
		}
	}
    OPENOBJ_END()
}

int EditDim(AcDbObjectId id)
{
    OPENOBJ_BEGIN(id, AcDb::kForRead, AecDbDimension, pDim);
	if(pDim!=NULL)
	{
		XPoint ptBase=GlobalFunc::Wcs2Ucs(pDim->GetLocation());
 		int nRet;
		XPoint ptAdd;
		XString szPrompt;
		XPointList lstAddPoint, lstBasePoint;
		lstBasePoint.Append(new XPoint(ptBase));
		while(1)
		{
			int nLen = lstAddPoint.Length();
			if(nLen == 0)
				_stprintf(szPrompt, _T("\n点取待增补的标注点的位置或 [参考点(R)]<退出>:"));
			else
				_stprintf(szPrompt, _T("\n点取待增补的标注点的位置或 [参考点(R)/撤消上一标注点(U)]<退出>:"));

			INITGET_BEG(0, _T("U R"));
			nRet = acedGetPoint(ptBase, szPrompt, ptAdd);
			INITGET_END();
			if(nRet == RTNORM)
			{
				ptBase = ptAdd;
				ptAdd = GlobalFunc::Ucs2Wcs(ptAdd);
				if(pDim->upgradeOpen() == Acad::eOk) 
				{
					if(!pDim->AddSegment(ptAdd))
						g_Option::instance().adsout << _T("\n点取位置不合适!");
					else
					{
						lstAddPoint.Append(new XPoint(ptAdd));
						lstBasePoint.Append(new XPoint(ptBase));
						if(g_Option::instance().g_nDimAdjust)//add by whl on 050530
							pDim->AdjustDim(g_Option::instance().g_nDimAdjust!=2);
					}
					pDim->downgradeOpen();
				}
			}
			else if(nRet == RTKWORD)
			{
				XString sKey;
				acedGetInput(sKey);
				if(sKey[0] == _T('R'))
					acedGetPoint(NULL, _T("\n参考点:"), ptBase);
				else if(sKey[0] == _T('U'))
				{
					if(pDim->upgradeOpen() == Acad::eOk) 
					{
						if(nLen > 0)
						{
							ptAdd = *lstAddPoint.Tail();
							lstAddPoint.Remove(nLen-1);
							pDim->HitTestOnPoint(ptAdd);
							pDim->FindAndRemoveSegment(ptAdd);
							lstBasePoint.Remove(nLen);
							ptBase = *lstBasePoint.Tail();
						}
						pDim->downgradeOpen();
					}
				}
			}
			else
				break;
		}
	}
    OPENOBJ_END();
	return RTNORM;
}
// Command: 合并尺寸
// create by lcf 2004/10/25
class TEntityPoint
{
public:
	Entity ent;
	XPoint ptPick;
};

//可以框选合并尺寸wlw130929mod
void ConbineDim()
{
    XPushVar<int> vOsMode(_T("OSMODE"), 0);
	Entity ent;
	XPoint ptPick;
	RBList mask(RTDXF0, _T("AEC_CHICUNBIAOZHU"), NULL);
	int nRet;
	DList<TEntityPoint> lstEntPt;
	while(1)
	{
		int nLen = lstEntPt.Length();
		XPoint ptStart, ptEnd;
		Entity ent;
		if(nLen == 0)
			nRet = acedGetPoint(NULL, _T("\n请框选合并区间中的尺寸界线箭头<退出>: "), ptStart);
		else
		{
			INITGET_BEG(0, _T("U"));
			nRet = acedGetPoint(NULL, _T("\n请框选合并区间中的尺寸界线箭头或 [撤消(U)]<退出>: "), ptStart);
			INITGET_END();
		}

		if(nRet == RTNORM)
		{
			if(GlobalFunc::GetCornerPoint(ptStart,NULL, ptEnd) != RTNORM)
				continue;

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

			RBList rbRegion = poly.Polygon();
			PickSet ss(SS_FREE);
			if(ss.Get(_T("CP"), rbRegion, NULL, mask) != RTNORM)
				continue;

			poly.TransUCS(RBGroups(1), RBGroups(0));

			long num = ss.Length();
			for(long i=0;i<num;i++)
			{
				ent = ss[i];

				OPENOBJ_BEGIN(ent, AcDb::kForWrite, AecDbDimension, pDim);
				if(pDim) 
				{
					if(pDim->IsBind()) 
					{
						g_Option::instance().adsout << _T("\n此尺寸标注绑定在其他对象上, 因此不能编辑!");
						return;
					}

					XPoly2D polyLimit;
					pDim->GetPolySegOnDimLine(polyLimit);

					for(int j = 1; j < polyLimit.Length() - 1; j++)
					{
						ptPick = *polyLimit[j];
						int rtInside = ptPick & poly;
						if(rtInside != PR_OUTSIDE)
						{
							TEntityPoint *pEntPt = new TEntityPoint;
							pEntPt->ent = ent;
							pEntPt->ptPick = ptPick;
							lstEntPt.Append(pEntPt);
							pDim->FindAndRemoveSegment(ptPick);
						}
					}
				}            
				OPENOBJ_END();
			}
		}
		else if(nRet == RTKWORD)
		{
			TEntityPoint *pEntPt = lstEntPt.Tail();
			if(pEntPt == NULL)
			{
				acutPrintf(_T("\n不能撤销!"));
				continue;
			}

			ent = pEntPt->ent;
			ptPick = pEntPt->ptPick;
			lstEntPt.Remove(nLen-1);

			OPENOBJ_BEGIN(ent, AcDb::kForWrite, AecDbDimension, pDim);
			if(pDim) 
			{
				if(pDim->IsBind()) 
				{
					g_Option::instance().adsout << _T("\n此尺寸标注绑定在其他对象上, 因此不能编辑!");
					return;
				}
				pDim->AddSegment(ptPick);
			}            
			OPENOBJ_END();
		}
		else
			break;
	}
}
//拆分区间WLW ADD 13.06.07 仅仅限于一个区间内的自由拆分
void DivideDimSeg()
{
	AcAxDocLock doclock;
	EntitySet ent1;
	XPoint ptPick;
	PickEntSet setshow(SS_FREE);
	AcDbObjectId idshow;
	RBList mask(RTDXF0, _T("AEC_CHICUNBIAOZHU"), NULL);
	if (GlobalFunc::SelectEntity(_T("\n选择待拆分的尺寸区间<退出>: "), ent1, ptPick, mask) != RTNORM) 
	{
		return;
	}
	GePoly2D polyLimit2(1);
	OPENOBJ_BEGIN(ent1, AcDb::kForRead, AecDbDimension, pDim);
	if(pDim == NULL)
	{
		return;
	}
	if(pDim->IsBind())
	{
		g_Option::instance().adsout << _T("\n此尺寸标注绑定在其他对象上, 因此不能编辑!");
		return;
	}

	ptPick = GlobalFunc::Ucs2Wcs(ptPick);
	XPoint ptBase;
	int nSeg = -1;
	SubText* psubtext = pDim->HitTestText(ptPick);
	if (psubtext == NULL)
	{
		nSeg = pDim->HitTestOnDimSeg(ptPick);
	}
	else
	{
		nSeg = psubtext->GetIndex();
		delete psubtext;
		psubtext = NULL;
	}

	GePoly2D poly;
	pDim->GetPolySegOnDimLine(poly);

	AcDbLine *pln = new AcDbLine(*poly[nSeg],*poly[nSeg+1]);
	pln->setColorIndex(1);
	idshow = GlobalFunc::AddToModelSpace(pln);
	GeCurveSegment segFirst(*poly[nSeg],*poly[nSeg+1],0);

	int nCount = poly.Length();
	ptBase = *poly[nSeg];
	int nRet;
	XPoint ptAdd;
	XString szPrompt;
	XPointList lstAddPoint, lstBasePoint;
	lstBasePoint.Append(new XPoint(ptBase));
	while(1)
	{
		pDim->GetPolySegOnDimLine(poly);
		int nCount = poly.Length();
		int nLen = lstAddPoint.Length();
		GeCurveSegment seg(*poly[0],*poly[nCount-1],0);
		if(nLen == 0)
			_stprintf(szPrompt, _T("\n点取待增补的标注点的位置<退出>:"));
		else
			_stprintf(szPrompt, _T("\n点取待增补的标注点的位置或[撤消(U)]<退出>:"));

		INITGET_BEG(0, _T("U"));
		ptBase = GlobalFunc::Wcs2Ucs(ptBase);
		nRet = acedGetPoint(ptBase, szPrompt, ptAdd);
		INITGET_END();
		if(nRet == RTNORM)
		{
			ptAdd = GlobalFunc::Ucs2Wcs(ptAdd);

			segFirst.ProjectToMe(ptAdd,ptAdd);
			if ((ptAdd & segFirst) != PR_INSIDE)
			{
				g_Option::instance().adsout << _T("\n请点取区域内部!");
				continue;
			}
			ptBase = ptAdd;
			if(pDim->upgradeOpen() == Acad::eOk) 
			{
				if(!pDim->AddSegment(ptAdd))
					g_Option::instance().adsout << _T("\n点取位置不合适!");
				else
				{
					lstAddPoint.Append(new XPoint(ptAdd));
					lstBasePoint.Append(new XPoint(ptBase));
					if(g_Option::instance().g_nDimAdjust)//add by whl on 050530
						pDim->AdjustDim(g_Option::instance().g_nDimAdjust!=2);
				}
				pDim->downgradeOpen();
			}
			GeCurveSegment seg(*poly[0],*poly[nCount-1],0);
			seg.ProjectToMe(ptBase,ptBase);
		}
		else if(nRet == RTKWORD)
		{
			XString sKey;
			acedGetInput(sKey);
			if(sKey[0] == _T('U'))
			{
				if(pDim->upgradeOpen() == Acad::eOk) 
				{
					if(nLen > 0)
					{
						ptAdd = *lstAddPoint.Tail();
						lstAddPoint.Remove(nLen-1);
						pDim->HitTestOnPoint(ptAdd);
						pDim->FindAndRemoveSegment(ptAdd);
						lstBasePoint.Remove(nLen);
						ptBase = *lstBasePoint.Tail();
						if(g_Option::instance().g_nDimAdjust)//add by whl on 050530
							pDim->AdjustDim(g_Option::instance().g_nDimAdjust!=2);
						seg.ProjectToMe(ptBase,ptBase);
					}
					pDim->downgradeOpen();
				}
			}
		}
		else
			break;
	}
    OPENOBJ_END()
		OPENOBJ_BEGIN(idshow, AcDb::kForWrite, AcDbEntity, pent)
		if (pent)
		{
			pent->erase();
		}
		OPENOBJ_END()
}
// Command: 快速标注
// Create By LCF 2004/10/27
/////////////////////////////////////////////////////
int CmpPointByX(const XPoint *pt1, const XPoint *pt2)
{
	if(pt1->x< pt2->x)
		return -1;
	else
		return 1;
}

int CmpPointByY(const XPoint *pt1, const XPoint *pt2)
{
	if(pt1->y < pt2->y)
		return -1;
	else
		return 1;
}

////////////////////////////////////////////////////
class TQuickDimensionJig : public AcEdJig
{
public:
	TQuickDimensionJig();
	virtual ~TQuickDimensionJig();
	int doIt();
	virtual DragStatus sampler();
	virtual Adesk::Boolean update();
	virtual AcDbEntity *entity() const;

	const TCHAR *m_pszKeyword; //关键字
// 	AecDbDimension *m_pDrawEnt; //临时实体, 
// 	AecDbDimension *m_pDrawEntALL;
	AecDbDimension *m_pDrawEntX; //临时实体, 
	AecDbDimension *m_pDrawEntY; //临时实体, 
	double m_dFactor;
	int m_iFlag;
	XPoint m_ptDim;
	XPoint m_lowPt, m_upPt;
	void SetKeyword(const TCHAR *pszKeyword);
	void SetExtents(XPoint lowPt, XPoint upPt);
	void SetMidPoints(AcGePoint3dArray &dimPoints);
	void SetDimType(int iFlag);
	void AddToDataBase();
	TMulDimEntity m_dimbEntity;
};

TQuickDimensionJig::TQuickDimensionJig()
{
	m_pszKeyword = NULL;
	m_pDrawEntX = NULL;
	m_pDrawEntY = NULL;
	m_dimbEntity.m_iFlag = m_iFlag;
	m_dFactor = 0.0;
	m_dimbEntity.m_pDrawEntAll = NULL;
	m_dimbEntity.m_pDrawEnt = new AecDbDimension;
}

TQuickDimensionJig::~TQuickDimensionJig()
{
	if(m_pDrawEntX != NULL)
		delete m_pDrawEntX;
	if(m_pDrawEntY != NULL)
		delete m_pDrawEntY;
}

void TQuickDimensionJig::SetKeyword(const TCHAR *pszKeyword)
{
	m_pszKeyword = pszKeyword;
}

void TQuickDimensionJig::SetDimType(int iFlag)
{
	m_iFlag = iFlag;
	m_dimbEntity.m_iFlag = m_iFlag;
	if (m_iFlag == 2 && m_dimbEntity.m_pDrawEntAll == NULL)
	{
		m_dimbEntity.m_pDrawEntAll = new AecDbDimension;
	}
}

void TQuickDimensionJig::SetExtents(XPoint lowPt, XPoint upPt)
{
	extern TCHAR* LAY_DIM;
	m_lowPt = GlobalFunc::Wcs2Ucs(lowPt);
	m_upPt = GlobalFunc::Wcs2Ucs(upPt);

	if(m_pDrawEntX != NULL)
	{
		delete m_pDrawEntX;
		m_pDrawEntX = NULL;
	}
	m_pDrawEntX = new AecDbDimension;
	m_pDrawEntX->SetLayoutRotation(GlobalFunc::Ucs2Wcs(0));//add by whl on 060306
	m_pDrawEntX->SetDist2DimLine(6.0);
	m_pDrawEntX->SetLocation(lowPt);
	m_pDrawEntX->SetRotation(GlobalFunc::Ucs2Wcs(0.0));
	double dValX = m_upPt.x - m_lowPt.x;
	if(fabs(dValX) > 1E-3)
		m_pDrawEntX->AppendSegment(dValX);

	AcDbObjectId idStyle = InitDimStyle(DS_LINEAR);
	m_pDrawEntX->SetStyleId(idStyle);
	m_pDrawEntX->setLayer(LAY_DIM);
	
	if(m_pDrawEntY != NULL)
	{
		delete m_pDrawEntY;
		m_pDrawEntY = NULL;
	}
	m_pDrawEntY = new AecDbDimension;
	m_pDrawEntY->SetLayoutRotation(GlobalFunc::Ucs2Wcs(0));//add by whl on 060306
	m_pDrawEntY->SetDist2DimLine(6.0);
	m_pDrawEntY->SetLocation(lowPt);
	m_pDrawEntY->SetRotation(PI/2 + GlobalFunc::Ucs2Wcs(0.0));
	double dValY = m_upPt.y - m_lowPt.y;
	if(fabs(dValY) > 1E-3)
		m_pDrawEntY->AppendSegment(dValY);

	m_pDrawEntY->SetStyleId(InitDimStyle(DS_LINEAR));
	m_pDrawEntY->setLayer(LAY_DIM);

	double dTexth = 3.5;
	OPENOBJ_BEGIN(idStyle, AcDb::kForRead, AcDbDimStyleTableRecord, pDimStyle);
	ASSERT(pDimStyle);
	dTexth = pDimStyle->dimtxt() * pDimStyle->dimscale();
	OPENOBJ_END();
	m_dFactor = 2 * dTexth * GlobalFunc::DocGetPScale();
	m_dimbEntity.m_pDrawEnt->SetStyleId(idStyle);
	if (m_iFlag == 2 && m_dimbEntity.m_pDrawEntAll != NULL)
	{
		m_dimbEntity.m_pDrawEntAll->SetStyleId(idStyle);
	}

}

void TQuickDimensionJig::SetMidPoints(AcGePoint3dArray &dimPoints)
{
	if(m_iFlag == 0)
		return;

	long i;
	XPointList lstPointsX, lstPointsY;
	for(i=0; i<dimPoints.length(); i++)
	{
		XPoint ptDim = dimPoints[i];
		lstPointsX.Append(new XPoint(ptDim));
		lstPointsY.Append(new XPoint(ptDim));
	}
	lstPointsX.QuickSort(CmpPointByX);
	lstPointsY.QuickSort(CmpPointByY);

	if(m_pDrawEntX->GetSegmentNum() > 0)
	{
		for(i=0; i<lstPointsX.Length(); i++)
			m_pDrawEntX->AddSegment(*lstPointsX[i]);
	}
	if(m_pDrawEntY->GetSegmentNum() > 0)
	{
		for(i=0; i<lstPointsY.Length(); i++)
			m_pDrawEntY->AddSegment(*lstPointsY[i]);
	}
	m_pDrawEntX->RemoveZeroSegment();
	m_pDrawEntY->RemoveZeroSegment();
}

void TQuickDimensionJig::AddToDataBase()
{
	if(m_iFlag == 2 && m_dimbEntity.m_pDrawEntAll != NULL)
	{
		if(g_Option::instance().g_nDimAdjust)
			m_dimbEntity.m_pDrawEntAll->AdjustDim(g_Option::instance().g_nDimAdjust!=2);

		// sg add 120410，增加布局转角的设置，解决UCS下，文字方向错误的问题
		m_dimbEntity.m_pDrawEntAll->SetLayoutRotation(GlobalFunc::Ucs2Wcs(0.0));
		GlobalFunc::AddToSpace(Adesk::kTrue, m_dimbEntity.m_pDrawEntAll);
	}

	//add by whl on 060119
	if(g_Option::instance().g_nDimAdjust)
		m_dimbEntity.m_pDrawEnt->AdjustDim(g_Option::instance().g_nDimAdjust!=2);

	// sg add 120410，增加布局转角的设置，解决UCS下，文字方向错误的问题
	m_dimbEntity.m_pDrawEnt->SetLayoutRotation(GlobalFunc::Ucs2Wcs(0.0));

	// modify by xly on 110107 支持图层切换
	//m_dimbEntity.m_pDrawEnt->AddToCSpace(Adesk::kTrue);
	GlobalFunc::AddToSpace(Adesk::kTrue, m_dimbEntity.m_pDrawEnt);
}

int TQuickDimensionJig::doIt()
{
	int ret;
    try 
	{
		ret = drag();
	}
	catch(...) 
	{
        ret = AcEdJig::kCancel;
	}

	if (ret == AcEdJig::kCancel)
		ret = RTCAN;
    else if(ret == AcEdJig::kNull)
        ret = RTNONE;
	else if (ret <= 0) 
		ret = RTNORM;
	else
		ret = RTKWORD;

	return ret;
}

AcEdJig::DragStatus TQuickDimensionJig::sampler()
{
    setUserInputControls((UserInputControls)
        (AcEdJig::kAccept3dCoordinates | AcEdJig::kNullResponseAccepted));
	if (m_pszKeyword) 
		setKeywordList(m_pszKeyword);

    XPoint ptCursor;
    DragStatus stat = acquirePoint(ptCursor);
	ptCursor = ptCursor;
    if(stat == AcEdJig::kNormal) 
	{
        if (ptCursor.Distance2d(m_ptDim) > g_Option::instance()._DIST_SNAP)
            m_ptDim = ptCursor;
		else 
            stat = AcEdJig::kNoChange;
    }
	return stat;
}

// 更新实体数据
//modified by whl on 050811
Adesk::Boolean TQuickDimensionJig::update()
{
	double nDist2Dim = 0.0;
	BOOL b2 = FALSE;
	while(m_dimbEntity.m_pDrawEnt->GetSegmentNum()>0)
		m_dimbEntity.m_pDrawEnt->RemoveSegment(0);
	if (m_iFlag == 2 && m_dimbEntity.m_pDrawEntAll != NULL)
	{
		b2 = TRUE;
 		while(m_dimbEntity.m_pDrawEntAll->GetSegmentNum() > 0)
 				m_dimbEntity.m_pDrawEntAll->RemoveSegment(0);
	}



	XPoint ptLoc(m_lowPt);
	XPoint ptDim = GlobalFunc::Wcs2Ucs(m_ptDim);
	double dangle;
	if(ptDim.y < m_upPt.y && ptDim.y > m_lowPt.y && (ptDim.x < m_lowPt.x || ptDim.x > m_upPt.x))
	{
		if(m_pDrawEntY->GetSegmentNum() > 0)
		{
			//m_dimbEntity.m_pDrawEnt->copyFrom(m_pDrawEntY);
			for(long i=0;i<m_pDrawEntY->GetSegmentNum();i++)
				m_dimbEntity.m_pDrawEnt->AppendSegment(m_pDrawEntY->GetSegment(i));

			dangle = PI/2 + GlobalFunc::Ucs2Wcs(0.0);
			m_dimbEntity.m_pDrawEnt->SetRotation(dangle);

			if (b2)
			{
				double dValY = m_upPt.y - m_lowPt.y;
				if(fabs(dValY) > 1E-3)
					m_dimbEntity.m_pDrawEntAll->AppendSegment(dValY);
				m_dimbEntity.m_pDrawEntAll->SetRotation(dangle);
			}
			if(ptDim.x < (m_lowPt.x + m_upPt.x) * 0.5)
				ptLoc.x = m_lowPt.x;
			else
				ptLoc.x = m_upPt.x;
		}
	}
	else
	{
		if(m_pDrawEntX->GetSegmentNum() > 0)
		{
			//m_dimbEntity.m_pDrawEnt->copyFrom(m_pDrawEntX);
			for(long i=0;i<m_pDrawEntX->GetSegmentNum();i++)
				m_dimbEntity.m_pDrawEnt->AppendSegment(m_pDrawEntX->GetSegment(i));
			m_dimbEntity.m_pDrawEnt->SetRotation(GlobalFunc::Ucs2Wcs(0.0));

			if (b2)
			{
				double dValX = m_upPt.x - m_lowPt.x;
				if(fabs(dValX) > 1E-3)
					m_dimbEntity.m_pDrawEntAll->AppendSegment(dValX);
				m_dimbEntity.m_pDrawEntAll->SetRotation(GlobalFunc::Ucs2Wcs(0.0));
			}

			if(ptDim.y < (m_lowPt.y + m_upPt.y) * 0.5)
			{
				ptLoc.y = m_lowPt.y;
			}
			else
			{

				ptLoc.y = m_upPt.y;
			}
		}
	}
	m_dimbEntity.m_pDrawEnt->SetLocation(GlobalFunc::Ucs2Wcs(ptLoc));
	if (b2)
		m_dimbEntity.m_pDrawEntAll->SetLocation(GlobalFunc::Ucs2Wcs(ptLoc));

	XPoint ptOnSeg;
    GeCurveSegment seg;
	seg = m_dimbEntity.m_pDrawEnt->GetDimCurve();
	if (b2)
		seg = m_dimbEntity.m_pDrawEntAll->GetDimCurve();
    if(seg.ProjectToMe(m_ptDim, ptOnSeg) == RTNORM) 
	{
        double nDistMove = m_ptDim.Distance2d(ptOnSeg);
        int nSideLoc = seg.OnWhichSide(m_dimbEntity.m_pDrawEnt->GetLocation());
		int nSide = seg.OnWhichSide(m_ptDim);
		nDist2Dim = m_dimbEntity.m_pDrawEnt->GetDist2DimLine(FALSE);
		if (b2)
		{
			nSideLoc = seg.OnWhichSide(m_dimbEntity.m_pDrawEntAll->GetLocation());
			nDist2Dim = m_dimbEntity.m_pDrawEntAll->GetDist2DimLine(FALSE);
		}
		double nFactor = nDist2Dim/fabs(nDist2Dim);
        if(fabs(nDist2Dim) > 1.0E-6) 
		{
            if(nSide != nSideLoc) 
			{
                nDistMove *= nFactor;
			}
            else
			{
                nDistMove *= -nFactor;
			}
        } 
		else 
		{
            if(nSideLoc == OFFSET_LEFT) 
				nDistMove *= -1;
        }
		nDist2Dim += nDistMove;
		if (b2)
		{
			m_dimbEntity.m_pDrawEntAll->SetDist2DimLine(nDist2Dim, FALSE);

			if(nDist2Dim >= 0)
				nDist2Dim -= m_dFactor;
			else 
				nDist2Dim += m_dFactor;
			m_dimbEntity.m_pDrawEnt->SetDist2DimLine(nDist2Dim, FALSE);	
		}
		else
			m_dimbEntity.m_pDrawEnt->SetDist2DimLine(nDist2Dim, FALSE);	

	}
	ASSERT(m_dimbEntity.m_pDrawEnt && m_dimbEntity.m_pDrawEnt->IsValid());
	return Adesk::kTrue;
}

AcDbEntity* TQuickDimensionJig::entity() const
{
	return (AcDbEntity*)&m_dimbEntity;
}

// Add By lcf on 2005/03/21
// 等分标注
void AverageDim()
{
    Entity ent;
    XPoint ptPick;
    RBList rbMask(RTDXF0, _T("DIMENSION,AEC_CHICUNBIAOZHU"), NULL);
    while(ent.FilterSelect(_T("\n请选择需要等分的尺寸区间<退出>: "), rbMask, ptPick) == RTNORM) 
	{
        Entity entDim;
        if(ent.Is(_T("DIMENSION"))) 
		{
            if(!ConvertDim(ent, entDim)) 
			{
                acutPrintf(_T("\n不能转化ACAD尺寸标注对象!"));
                break;
            } 
        } 
		else 
            entDim = ent;

        OPENOBJ_BEGIN(entDim, AcDb::kForRead, AecDbDimension, pDim);
        ASSERT(pDim);
		int nSeg = pDim->HitTestOnDimSeg(GlobalFunc::Ucs2Wcs(ptPick));
        if(nSeg < 0) 
            acutPrintf(_T("\n请正确选取尺寸区间!"));
        else 
		{
			int nAverage;
			if(acedGetInt(_T("\n输入等分数<退出>:"), &nAverage) != RTNORM)
				return;

            if(pDim->upgradeOpen()==Acad::eOk) 
			{
				XPoly2D poly;
				pDim->GetPolySegOnDimLine(poly);
				ASSERT(nSeg < poly.TotalSegments());
				GeCurveSegment seg;
				poly.Nth(nSeg, seg);
				for(int i=0; i<nAverage; i++)
				{
					XPointDir2d ptIn;
					seg.Polar(seg.GetLength() * (i+1)/nAverage, ptIn);
					pDim->AddSegment(ptIn);
					if(g_Option::instance().g_nDimAdjust) 
						pDim->AdjustDim(g_Option::instance().g_nDimAdjust!=2);
				}
                pDim->downgradeOpen();
            }
        }
        OPENOBJ_END();
    }
}
//add by cwk on 060914
void DivideDim()
{
	PickEntSet setshow(SS_FREE);
	EntitySet ent;
    XPoint ptPick;
    RBList rbMask(RTDXF0, _T("DIMENSION,AEC_CHICUNBIAOZHU"), NULL);
    while(ent.FilterSelect(_T("\n请选择需要等分的尺寸区间<退出>: "), rbMask, ptPick) == RTNORM) 
	{
        Entity entDim;
        if(ent.Is(_T("DIMENSION")))
		{
            if(!ConvertDim(ent, entDim)) 
			{
                acutPrintf(_T("\n不能转化ACAD尺寸标注对象!"));
                break;
            } 
        } 
		else 
            entDim = ent;
        OPENOBJ_BEGIN(entDim, AcDb::kForRead, AecDbDimension, pDim);
		if(pDim==NULL)
			break;
        ASSERT(pDim);

		ptPick = GlobalFunc::Ucs2Wcs(ptPick);
		int nSeg = -1;
		SubText* psubtext = pDim->HitTestText(ptPick);
		if (psubtext == NULL)
		{
			nSeg = pDim->HitTestOnDimSeg(ptPick);
		}
		else
		{
			nSeg = psubtext->GetIndex();
			delete psubtext;
			psubtext = NULL;
		}

        if(nSeg < 0) 
            acutPrintf(_T("\n请正确选取尺寸区间!"));
        else 
		{
			GePoly2D poly;
			pDim->GetPolySegOnDimLine(poly);
			if (poly.Length() > nSeg)
			{
				AcDbLine *pln = new AcDbLine(*poly[nSeg],*poly[nSeg+1]);

				pln->setColorIndex(1);
				setshow += GlobalFunc::AddToModelSpace(pln);
			}
			int nAverage;
			//moidfy by xlc on 070815 等分数不能为0
			//if(acedGetInt(_T("\n输入等分数<退出>:"), &nAverage) != RTNORM)
			//	return;
			while(TRUE)
			{
				if(acedGetInt(_T("\n输入等分数<退出>:"), &nAverage) != RTNORM)
				{
					setshow.Erase();
					return;
				}

				if(abs(nAverage) < 1.0e-6)
				{
					acutPrintf(_T("\n等分数不能为0!"));
					continue;
				}
				break;
			}

            if(pDim->upgradeOpen()==Acad::eOk) 
			{
				XString xstr = pDim->GetText(nSeg);
				CString str = (LPCTSTR)xstr;
				if (str.ReverseFind(_T('=')) >= 0)
				{
					int i = str.Find(_T('=')) + 1;
					TCHAR *sText = new TCHAR[str.GetLength()];
					int j = 0;
					do 
					{
						sText[j] = str.GetAt(i);
						j++;
						i++;
					} while(i < str.GetLength());
					sText[j] = _T('\0');
					str = sText;
					xstr = str;
				}
				CString s;
				if (str.Find(_T('.')) < 0)
				{
					int i = _ttoi(LPCTSTR(str));
					int j;
					double m;					
					if (i % nAverage == 0)
					{
						j = i /nAverage;
						s.Format(_T("%d"),j);
					}
					else
					{
						//modified by yujie
						//m = (double)i / (double)nAverage;
				        m = i / (double)nAverage;
						s.Format(_T("%.1f"),m);
						if (s[s.GetLength() - 1] == _T('0'))
							s.Delete(s.GetLength() - 1);
						if (s[s.GetLength() - 1] == _T('.')) //add by yujie
							s.Delete(s.GetLength() - 1);
					}
				}
				else
				{
					double d = _tstof(LPCTSTR(str));
					double m = d / nAverage;
					s.Format(_T("%.1f"),m);
					if (s[s.GetLength() - 1] == _T('0'))
							s.Delete(s.GetLength() - 1);
					if (s[s.GetLength() - 1] == _T('.'))  //add by yujie
							s.Delete(s.GetLength() - 1);
				}
				
				str = s;
				str += _T('X');
				s.Format(_T("%d"),nAverage);
				str += s;
				str += _T('=');
				str += xstr;
				pDim->SetTextContent(nSeg,LPCTSTR(str));
				pDim->downgradeOpen();
            }
        }
        OPENOBJ_END()
		setshow.Erase();

    }
}
// Add By lcf on 2005/03/23
// 对齐标注
void ArrangeDim()
{
	//  [12/19/2007 nsh]
	//----------begin--------------
	BOOL bChoose=TRUE;//选择的标注是直线标注或是圆弧标注 TRUE为直线标注，FALSE为圆弧标注 
	XPoint CenterPoint;
	int WhichSide;
	double dRadius;
	//-----------end---------------
    Entity entFirst;
    RBList rbMask(RTDXF0, _T("DIMENSION,AEC_CHICUNBIAOZHU"), NULL);
	if(GlobalFunc::SelectEntity(_T("\n选择参考标注<退出>: "), entFirst, rbMask) != RTNORM)
		return;

    Entity entDim;
    if(entFirst.Is(_T("DIMENSION"))) 
	{
        if(!ConvertDim(entFirst, entDim)) 
		{
            acutPrintf(_T("\n不能转化ACAD尺寸标注对象!"));
            return;
        } 
    } 
	else 
        entDim = entFirst;

	double dRotFirst, dDist;
	AcDbObjectId objid;
	GeCurveSegment seg;
	AecDbDimension *pClone = NULL;
    OPENOBJ_BEGIN(entDim, AcDb::kForRead, AecDbDimension, pFirst);
    ASSERT(pFirst);
		//  [12/14/2007 nsh]
		//-----------------------begin-----------------------
		if(pFirst->IsAngular())
		{//选择的是圆弧标注
			bChoose =FALSE;
			dDist =pFirst->GetDist2DimLine();
			dRadius =pFirst->GetDimRadius();
			GeCurveSegment se=pFirst->GetDimCurve();
			XArc xa=se.GetArc();
			WhichSide =se.OnWhichSide(pFirst->GetLocation());
			CenterPoint=xa.GetCenterPt();
		}
		//-------------------------end-----------------------
		else
		{//选择的是直线标注
			bChoose =TRUE;
			dRotFirst = pFirst->GetRotation();
			dDist = pFirst->GetDist2DimLine();
			seg = pFirst->GetDimCurve();
			seg = seg.Offset(dDist * GlobalFunc::DocGetPScale(), 1);
			pClone = (AecDbDimension *)pFirst->clone();
			if(pClone == NULL)
				return;
		}
	OPENOBJ_END();
	
	PickEntSet ss(SS_FREE);
	const TCHAR *szPrompts[2]={_T("\n选择其它标注<退出>: "), _T("") };
	if(ss.Get(_T(":$"), szPrompts, NULL, rbMask) != RTNORM)
	{
		delete pClone;
		return;
	}

	if(bChoose)
	{//选择的为直线标注
		for(long i=0; i<ss.Length(); i++)
		{
			Entity entOther = ss[i];

			Entity entDimOther;
			if(entOther.Is(_T("DIMENSION"))) 
			{
				if(!ConvertDim(entOther, entDimOther)) 
					continue;
			} 
			else 
				entDimOther = entOther;

			OPENOBJ_BEGIN(entDimOther, AcDb::kForRead, AecDbDimension, pOther);
			ASSERT(pOther);
			if(pOther->IsAngular())
				continue;

			double dRot = CT_std_angle(dRotFirst) - CT_std_angle(pOther->GetRotation());
			dRot = fabs(dRot);
			if(dRot > 1E-6 && fabs(dRot - PI) > 1E-6)
				continue;

			XPoint ptRes;
			seg.ProjectToMe(pOther->GetLocation(), ptRes);
			if(pOther->upgradeOpen()==Acad::eOk)
			{
				// add by xly on 110107 支持图层切换,记录其他对象的图层
				CString csLayer = pOther->layer();
				pOther->CopyPropertiesFrom(pClone, AcDbMatchProperties::kSetAllFlagsOn);
				pOther->setLayer(csLayer);
				pOther->SetDist2DimLine((dRot < 1E-6) ? dDist : -dDist);
				pOther->SetLocation(ptRes);
				if(g_Option::instance().g_nDimAdjust) 
					pOther->AdjustDim(g_Option::instance().g_nDimAdjust!=2);
				pOther->downgradeOpen();
			}
			OPENOBJ_END();
		}
	}
	//  [12/19/2007 nsh]
	//--------------------------begin------------------------------
	else
	{//选择的圆弧标注
		for(long i=0; i<ss.Length(); i++)
		{
			Entity entOther = ss[i];

			Entity entDimOther;
			if(entOther.Is(_T("DIMENSION"))) 
			{
				if(!ConvertDim(entOther, entDimOther)) 
					continue;
			} 
			else 
				entDimOther = entOther;

			OPENOBJ_BEGIN(entDimOther, AcDb::kForWrite, AecDbDimension, pOther);
			ASSERT(pOther);
			if(!pOther->IsAngular())
				continue;
			GeCurveSegment seg=pOther->GetDimCurve();
			XArc xarc=seg.GetArc();
			int temp=seg.OnWhichSide(pOther->GetLocation());
			if(xarc.GetCenterPt()!=CenterPoint || seg.OnWhichSide(pOther->GetLocation())!=WhichSide)
				continue;
			AcDbObjectId oID=pOther->GetStyleId();
				if(oID==InitDimStyle(DS_ANGLE))
				{//角度标注的情况下
					double ddd=8.0*GlobalFunc::DocGetPScale();
					GeCurveSegment cv =pOther->GetDimCurve();
					if(!cv.Is(CURVE_LINE))
					{
						XArc arc=cv.GetArc();
						arc.GetCenterPt();
						XPoint ptStart;
						pOther->getStartPoint(ptStart);
						ads_polar(arc.GetCenterPt(),ads_angle(arc.GetCenterPt(),ptStart),dRadius+dDist*GlobalFunc::DocGetPScale(),ptStart);
						pOther->SetLocation(ptStart);
						pOther->SetDimRadius(dRadius);
						pOther->SetDist2DimLine(dDist);
					}
				}
				else
				{//弧长标注的情况
					pOther->SetDimRadius(dRadius);
					pOther->SetDist2DimLine(dDist);
				}		
			OPENOBJ_END();
		}
	}
	//--------------------------end---------------------------------
	delete pClone;
}

// add by xly on 101115 在FindAndReplaceDlg中已经去掉了这个函数，所以添加
//extern TARCH_IMPEXP BOOL g_bTextStyleEx;
TextPosition  FindEntText1(Entity ent, const TCHAR *sSubText, TextPosition &posStart, TextRange *pRange)
{
	TextPosition posFind;
	if(!sSubText || !sSubText[0])
		return posFind;

	// sg add 110504，解决查找时，可能受“全字匹配”影响的问题，临时去掉全字匹配的设置
	DWORD dwMaskOld = g_FindParser.GetFindOption(),
		dwMaskNew = dwMaskOld;
	dwMaskNew = dwMaskNew & ~FP_WHOLE_WORD;
	g_FindParser.SetFindOption(dwMaskNew);

	OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbEntity, pEnt);
	if(pEnt->isKindOf(AecXDbEntityBaseEx::desc()))
	{
		AecXDbEntityBaseEx *pText= AecXDbEntityBaseEx::cast(pEnt);
		if (pText)
			posFind = pText->FindSubText(sSubText, posStart, pRange);
	}
	else if(pEnt->isKindOf(AcDbText::desc())) 
	{
		GlobalFunc::PushMemVar<BOOL> vTemp(g_Option::instance().g_bTextStyleEx, FALSE);
		AecXDbText text;
		AcDbText *pText=AcDbText::cast(pEnt);
		if(text.ConvertFrom(pText)) 
		{
			posFind = text.FindSubText(sSubText, posStart, pRange);
		}
	}
	OPENOBJ_END();

	// sg add 110504，解决查找时，可能受“全字匹配”影响的问题，恢复默认
	g_FindParser.SetFindOption(dwMaskOld);

	return posFind;
}

// add by xly on 100927 为选择到的字符绘制红色外包盒；poly选择到的字符的外包盒的pline线
void GrdrawPoly(XPoly2D &poly) 
{
	int len = poly.Length();
	for(int i=0;i<len;i++)
	{
		GeCurveSegment seg;
		poly.Nth(i, seg);
		XPoint ptS, ptE;
		ads_grdraw(seg.StartPoint(), seg.EndPoint(), 1, 0);
	}
}

// add by xly on 100927 红色框选选择到的字符,同时将为字符串csText分为两部分;
// 说明：csText:待选字符串；entSel：选择集；ptPickWcs：点选的位置；csLeft：选择到的字符的左部(包含选择到的字符)；
// csRight：选择到的字符的右部(不包含选择到的字符)；
void HightShow(CString csText, EntitySet entSel, XPoint ptPickWcs,CString &csLeft, CString &csRight)
{
	// 获得字符串中每个字符的信息
	int len = csText.GetLength();	
	TextPosition pos;

	for(int i=0;i<len;i++)
	{
		CString csUnit;	
#if (ARX < 17)
		int unicode = (int)csText.GetAt(i);
		if((unicode <='9' && unicode >= '0') || (unicode <= 'z' && unicode >= 'a') || (unicode <= 'Z' && unicode >= 'A'))
		{
			TCHAR cUnit = csText[i];
			BYTE byte = (BYTE)cUnit;
			csUnit = cUnit;
		}
		else 
		{
			csUnit = csText.Mid(i,2);
			i++;
		}
#else
		TCHAR cUnit = csText[i];
		BYTE byte = (BYTE)cUnit;
		csUnit = cUnit;
#endif
	
		// 查找字符的位置
		TextRange range;
		TextPosition posFind = FindEntText1(entSel, csUnit, pos, &range);
		
		// 反复查找csUnit字符的位置
		while(!!posFind)
		{
			// 获得字符的外包盒
			XPoint ptMin, ptMax;
			if(range.GetExtend(ptMin, ptMax))			
			{
				int ll = range.m_lstRanges.Length();
				for(int n=0; n<ll; n++)				
				{
					XPoly2D poly = *range.m_lstRanges[n];
					poly.SetElevation(0.0);
				
					// 根据用户的拾取点判断本个字符是不是宣道的字符
					int ret = ptPickWcs&poly;		
					if(ret == PR_INSIDE)// 点选位置在字符的范围内
					{	
						csLeft = csText.Left(pos.m_nTextPos);
						csRight = csText.Right(len - pos.m_nTextPos);
						// add by xly on 101115 选择到的文字为上标或者下标文字时调整返回的左右字符串
						if (csLeft.GetLength()>0)
						{
							if (csLeft.Right(1)==_T('^'))
							{
								csLeft = csText.Left(pos.m_nTextPos+2);
								csRight = csText.Right(len - pos.m_nTextPos-2);
							}
							if (csLeft.Right(2)==_T("^C"))
							{
								csLeft = csText.Left(pos.m_nTextPos+1);
								csRight = csText.Right(len - pos.m_nTextPos-1);
							}
						}
						poly.TransUCS(RBGroups(0), RBGroups(1));
						// 为选择到的字符绘制红色外包盒
						GrdrawPoly(poly);  
						return;
					}
				}
			}
			posFind = FindEntText1(entSel, csUnit, pos, &range);
		}
		TextPosition posTemp;
		pos = posTemp;
	}
}

// add by xly on 101209 捕获用户输入的取消、右键、回车、点取左键
// 捕获键盘输入关键字的动作
static int s_nInputRet;// 键盘输入的返回结果
static POINT s_ptInPut;// 记录拖拽选择集是点取的位置
#if ARX > 22
static bool InputKeyWord(MSG* msg)
#else
static BOOL InputKeyWord(MSG* msg)
#endif
{
	BOOL bRet = FALSE;
	if (!acdbCurDwg())
	{
		return bRet;
	}
	// 没有关键字输入的时候支持判断结果
	switch(msg->message)
	{
	case WM_KEYDOWN: // 键盘输入关键字
		{
			if (msg->wParam==VK_RETURN || msg->wParam==VK_ESCAPE) // 键盘输入回车
			{
				s_nInputRet = RTNONE;
			}
		}
		break;
	case WM_RBUTTONDOWN: // 鼠标右键
		{			
			s_nInputRet = RTNONE;
		}
		break;
	case WM_LBUTTONDOWN :// 捕获move操作最后的点取位置
		{
			s_ptInPut = msg->pt;
		}
	default:
		break;
	}
	return bRet;	
}



/////////////////////////////////////////////////////////////////////
//                       递增文字命令接口
// add by xly on 100926
void PassTextCmd()
{
	Entity entSel;// 选择到的实体
	XPoint ptPick;// 点选位置
	CString csText, csLeft, csRight;// 拆分的文字，拆分为选中的字符左部分（包括选中的字符），拆分为选中的字符右部分
	XPoint ptPos; // 对象的基点
	PickEntSet ss(SS_FREE);

	// 标记点取的位置是在名字上
	bool bIsName = true;
	while(1)
	{
		// 定义选择集
		CString csPompt = _T("\n请选择要递增拷贝的文字(注：同时按CTRL键进行递减拷贝,仅对单个选中字符进行操作)<退出>:");
		RBList rb(RTDXF0, _T("AEC_POQIE,AEC_TUMINGBIAOZHU,AEC_DANHTEXT,TEXT,AEC_SUOYINTUMING"), NULL);
		if(GlobalFunc::SelectEntity(csPompt, entSel, ptPick, rb) != RTNORM)
			return;

		if (entSel.Is(_T("AEC_DANHTEXT"))|| entSel.Is(_T("TEXT")))// 上华单行文字、CAD文字对象
		{
			XText text(entSel);
			csText = text.m_csText;
			ptPos = text.m_ptInsert;
		}
		else if (entSel.Is(_T("AEC_SUOYINTUMING")))// 索引图名
		{
			OPENOBJ_BEGIN(entSel,AcDb::kForRead,AecXDbSymbDrawingIndex,pSymb);

			// 获得图名索引的中心
			ptPos = pSymb->GetCenter();
			if (ptPick.y>ptPos.y && ptPick.x<ptPos.x+pSymb->GetRadius(FALSE))// 点取位置在中心的上方
			{
				csText =pSymb->GetIndexLabel();
			}
			else if (ptPick.x<ptPos.x+pSymb->GetRadius(FALSE))// 点取位置在中心的下方
			{
				csText =pSymb->GetDrawingLabel();
				
				// 没有图号的情况
				if (csText.IsEmpty())
				{
					csText = pSymb->GetIndexLabel();
				}
			}
			else										  // 点取位置在圆形外部
			{
				csText = pSymb->GetScaleText();
			}
			OPENOBJ_END();
		}
		else if (entSel.Is(_T("AEC_POQIE")))// 剖面，断面剖切
		{
			OPENOBJ_BEGIN(entSel,AcDb::kForWrite,AecXDbSymbSection,pSymb);
			csText = pSymb->GetText();
			
			// 获得标注两端的文字
			XPoint pt1,pt2;
			pt1 = pSymb->GetDefaultTextLocation(0);
			pt2 = pSymb->GetDefaultTextLocation(1);

			if (ptPick.Distance(pt1)<ptPick.Distance(pt2))// 选择起始位置
			{
				pSymb->SetTextLocation(0,pt1);
				pSymb->SetTextLocation(1,pt2);
				ptPos = pt1;				
			}
			else										 // 选择终点位置
			{
				pSymb->SetTextLocation(0,pt2);
				pSymb->SetTextLocation(1,pt1);
				ptPos = pt2;
			}
			OPENOBJ_END();
		}
		else if (entSel.Is(_T("AEC_TUMINGBIAOZHU")))// 图名标注
		{
			OPENOBJ_BEGIN(entSel,AcDb::kForRead,AecXDbDrawingName,pSymb);
			ptPos = pSymb->GetMidLocation();

			if (pSymb->GetShowScale())// 显示比例
			{
				// 获得比例文字的位置
				XPoint ptScale = pSymb->GetScaleLocation();
				// 判断选中图名还是选中比例
				if (ptPick.x<ptScale.x)
				{
					csText = pSymb->GetNameText(); // 获得图名文字
					bIsName = true;
				}
				else
				{
					bIsName = false;
					csText = pSymb->GetScaleText();// 获得图名文字
				}
			}
			else					// 不显示比例
			{
				csText = pSymb->GetNameText();
			}
			OPENOBJ_END();
		}
		ss += entSel;
		
		XPoint ptPickWcs = GlobalFunc::Ucs2Wcs(ptPick);

		// 点选到的字符红色框选
		HightShow(csText, entSel, ptPickWcs, csLeft, csRight);
		if(csLeft != _T("") || csRight != _T(""))// 已经选择字符
			break;
	}

	// 定义基点，默认基点为对象的基点
	XPoint ptBase = ptPos;
	if(ads_getpoint(GlobalFunc::Wcs2Ucs(ptPos), _T("\n请指定基点:"), ptBase) == RTNORM)
	{ 
		// delete by xly on 110314 使用用户坐标系
		//ptBase = GlobalFunc::Ucs2Wcs(ptBase);
	}
	else // 取消操作
	{
		// add by xly on 101206 刷新屏幕
		acedRedraw(NULL,1);
		return;
	}

	// 生成递增文字
	while(1)
	{  
		// 计算所选的文字的递增文字，ctrl键控制增加或者减少
		// 注：int型数字最大值2,147,483,647 如果超过最大值将变为0
		SHORT nStateCtrl = GetKeyState(VK_CONTROL);
		BOOL bCtrl = (nStateCtrl&256)!=0;
		if(bCtrl)
			csLeft = GlobalFunc::PlusString(csLeft, 1, FALSE, true);
		else
			csLeft = GlobalFunc::PlusString(csLeft, 1, TRUE, true);
		csText = csLeft + csRight;

		// 复制选择集中的实体信息
		PickEntSet ss1(SS_FREE);
		ss1.IncludeBegin();
		{
			XPushVar<int> tVar(_T("OSMODE"), 0);
			SHads_command(RTSTR, _T("COPY"), RTPICKS, (TLong_ptr *)ss, RTSTR, _T(""),
				RTSTR, _T("0,0"), RTSTR, _T("0,0"), RTNONE);
		}
		ss1.IncludeEnd();
		int n = ss1.Length();
		if (ss1.Length()<1)
		{
			// 选择集为空的时候，将已经做过的字符串递增、减做相反的操作
			if(bCtrl)
				csLeft = GlobalFunc::PlusString(csLeft, 1, TRUE, true);
			else
				csLeft = GlobalFunc::PlusString(csLeft, 1, FALSE, true);
			continue;
		}
		
		// 修改生成递增后的文字
		if (entSel.Is(_T("AEC_DANHTEXT")))			// 上华单行文字
		{
			OPENOBJ_BEGIN(ss1[(long)0],AcDb::kForWrite,AecXDbText,pSymb);
			pSymb->SetText(csText);
			OPENOBJ_END();
		}
		else if (entSel.Is(_T("TEXT")))		   // CAD文字对象
		{
			OPENOBJ_BEGIN(ss1[(long)0],AcDb::kForWrite,AcDbText,pSymb);
			pSymb->setTextString(csText);
			OPENOBJ_END();
			
		}
		else if (entSel.Is(_T("AEC_SUOYINTUMING")))// 索引图名
		{
			OPENOBJ_BEGIN(ss1[(long)0],AcDb::kForWrite,AecXDbSymbDrawingIndex,pSymb);
			// 根据点取的位置的不同，设置相应的文字
			if (ptPick.y>ptPos.y && ptPick.x<ptPos.x +pSymb->GetRadius(FALSE))
			{
				pSymb->SetIndexLabel(csText);	// 索引编号
			}
			else if(ptPick.x<ptPos.x+pSymb->GetRadius(FALSE))
			{
				CString csDrawLable = pSymb->GetDrawingLabel();
				if (csDrawLable.IsEmpty())
				{
					pSymb->SetIndexLabel(csText);	// 索引编号
				}
				else
				{
					pSymb->SetDrawingLabel(csText); // 图名
				}
			}
			else
			{
				pSymb->SetScaleText(csText);	// 比例
			}
			OPENOBJ_END();
		}
		else if (entSel.Is(_T("AEC_POQIE")))// 剖面剖切
		{
			OPENOBJ_BEGIN(ss1[(long)0],AcDb::kForWrite,AecXDbSymbSection,pSymb);
			pSymb->SetText(csText);
			OPENOBJ_END();
		}
		else if (entSel.Is(_T("AEC_TUMINGBIAOZHU")))// 图名索引
		{
			OPENOBJ_BEGIN(ss1[(long)0], AcDb::kForWrite, AecXDbDrawingName, pEnt);
			if (pEnt->GetShowScale())// 显示比例
			{
				// 获得比例文字的位置
				XPoint ptScale = pEnt->GetScaleLocation();

				// 判断选中图名还是选中比例
				if (bIsName)
				{
					pEnt->SetNameText(csText);
				}
				else
				{
					pEnt->SetScaleText(csText);
				}
				
			}
			else // 不显示比例
			{
				pEnt->SetNameText(csText);
			}
			OPENOBJ_END();
		}
	
		// modify by xly on 101210 用move命令模拟jig效果
		//// 拖动文字的位置
		//if (DragMovePickSet(ss1, _T("\n请点取插入位置<退出>:"), ptBase, XPoint()) != RTNORM)
		//{
		//	// add by xly on 101206 刷新屏幕
		//	acedRedraw(NULL,1);
		//	ss1.Erase();
		//	return;
		//}
		
		// 钩子函数监视键盘中输入关键字
		s_nInputRet = 0;
		acedRegisterFilterWinMsg(InputKeyWord);

		acutPrintf( _T("\n请点取插入位置<退出>:"));
		ss1.Redraw(2);

		// lgh add.
		// old extents
		AcDbExtents oldExtens;
		OPENOBJ_BEGIN(ss1[(long)0], AcDb::kForRead, AcDbEntity, pEnt);
		if (pEnt != NULL)
			pEnt->getGeomExtents(oldExtens);
		OPENOBJ_END();

		// 移动实体，实现jig效果
		SHads_command(RTSTR, _T("MOVE"), RTPICKS, (TLong_ptr *)ss1, RTSTR, _T(""),
			RT3DPOINT, &ptBase,  RTSTR, _T("\\"), RTNONE);	
		if (s_nInputRet == RTNONE)// 按Esc 或者右键、回车退出
		{
			ss1.Erase();
			acedRedraw(NULL,1);
			return;
		}
	
		AcDbExtents newExtents;
		OPENOBJ_BEGIN(ss1[(long)0], AcDb::kForRead, AcDbEntity, pEnt);
		if (pEnt != NULL)
			pEnt->getGeomExtents(newExtents);
		OPENOBJ_END();

		AcGeVector3d vec(newExtents.minPoint() - oldExtens.minPoint());

		// lgh remmove, 2011-05017
// 		// 将屏幕坐标转化为CAD世界坐标
// 		XPoint ptLoc;
// 		CPoint ptTemp(s_ptInPut);
// 		acedGetAcadDwgView()->ScreenToClient(&ptTemp);
// 		acedCoordFromPixelToWorld(ptTemp, ptLoc);
// 
// 		// modify by xly on 110314 将DCS转化为用户坐标系
// 		// 更新基点和选择集
// 		//ptBase = ptLoc;
// 		struct resbuf fromrb, torb; 
// 		fromrb.restype = RTSHORT; 
// 		fromrb.resval.rint = 2; // DCS 
// 		torb.restype = RTSHORT; 
// 		torb.resval.rint = 1;	// UCS  
// 
// 		XPoint ptResult;
// 		acedTrans(ptLoc, &fromrb, &torb, FALSE, ptResult);

//		ptBase = ptResult;
		ptBase = (ptBase + vec);
		ss.Free();
		ss += ss1;

		// 释放函数
		acedRemoveFilterWinMsg(InputKeyWord);
	}

	// add by xly on 101206 刷新屏幕
	acedRedraw(NULL,1);
}

//add by lgy 20120201	循环提示输入其他标注点
BOOL InputOtherPt(AcDbObjectId idDim, TDimTwoPointArg &dim)
{
	XPoint ptOther, ptPosition;
	while(TRUE)
	{
		while(TRUE)
		{
			ptPosition = dim.GetLastPoint();
			if(XGetPoint(ptPosition, _T("\n请输入其他标注点"), ptOther)== RTNORM)
			{
				dim.Step(ptOther);
				dim.AddDim(idDim, ptOther);
				break;
			}
			else
			{
				return FALSE;
			}
		}

		ptPosition = dim.GetLastPoint();
		int nRet2;
		INITGET_BEG(0, _T("U R"));
		nRet2 = acedGetPoint(ptPosition, _T("\n请输入其他标注点或 [参考点(R)/撤消上一标注点(U)]<退出>:"), ptOther);
		INITGET_END();

		if (nRet2 == RTKWORD)
		{
			XString sKey;
			acedGetInput(sKey);
			if(sKey[0] == _T('R'))
				acedGetPoint(NULL, _T("\n参考点:"), ptPosition);
			else if(sKey[0] == _T('U'))
			{
				dim.Undo(idDim);
				if(dim.CanUndo())
					ptPosition = dim.GetLastPoint();
				else
					ptPosition = ptOther;
			}
		}
		else if(nRet2 == RTNORM)
		{
			ptPosition = ptOther;
			dim.Step(ptOther);
			dim.AddDim(idDim, ptOther);
		}
		else
			break;
	}
	return TRUE;
}

//add by lgy 20120202	获得poly中的第n条边上的起始点或终止点
XPoint GetPtOnPoly(XPoly2D poly, int n, BOOL bFalg)
{
	GeCurveSegment seg;
	poly.Nth(n, seg);
	if (bFalg)
	{
		return seg.EndPoint();
	}
	return seg.StartPoint();
}

//add by lgy 20120314	为楼梯标注写一jig预览效果
class StairDimJig : public AcEdJig
{
public:
	StairDimJig(AecDbDimension *pDim, XPoint pt);
	virtual ~StairDimJig();
	int doIt();
	virtual DragStatus sampler();
	virtual Adesk::Boolean update();
	virtual AcDbEntity *entity() const;
	XPoint GetDimLocalPt();				//返回jig最后获得的点的位置
	AecDbDimension *m_pDrawEnt;
	XPoint m_ptJig;
};

XPoint StairDimJig::GetDimLocalPt()
{
	return m_ptJig;
}

StairDimJig::StairDimJig(AecDbDimension *pDim, XPoint pt)
{
	m_pDrawEnt = pDim;
	m_ptJig = pt;
}

StairDimJig::~StairDimJig()
{
}

int StairDimJig::doIt()
{
	int ret;
	try 
	{
		ret = drag();
	}
	catch(...) 
	{
		ret = AcEdJig::kCancel;
	}

	if (ret == AcEdJig::kCancel)
	{
		ret = RTCAN;
	}
	else if(ret == AcEdJig::kNull)
	{
		ret = RTNONE;
	}
	else if (ret <= 0) 
	{
		ret = RTNORM;
	}
	else
	{
		ret = RTKWORD;
	}

	return ret;
}

AcEdJig::DragStatus StairDimJig::sampler()
{
	setUserInputControls((UserInputControls)
		(AcEdJig::kAccept3dCoordinates | AcEdJig::kNullResponseAccepted));

	XPoint ptCursor;
	DragStatus stat = acquirePoint(ptCursor);
	if(stat == AcEdJig::kNormal) 
	{
		if (ptCursor.Distance2d(m_ptJig) > g_Option::instance()._DIST_SNAP)
		{
			m_ptJig = ptCursor;
		}
		else 
		{
			stat = AcEdJig::kNoChange;
		}
	}
	return stat;
}

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

Adesk::Boolean StairDimJig::update()
{
	XPoint ptOnSeg;
	GeCurveSegment seg = m_pDrawEnt->GetDimCurve();
	if(seg.ProjectToMe(m_ptJig, ptOnSeg) == RTNORM) 
	{
		double nDistMove = m_ptJig.Distance2d(ptOnSeg);
		int nSideLoc = seg.OnWhichSide(m_pDrawEnt->GetLocation());
		int nSide = seg.OnWhichSide(m_ptJig);
		double nDist2Dim = m_pDrawEnt->GetDist2DimLine(FALSE);

		if(fabs(nDist2Dim) > 1.0E-6) 
		{
			double nFactor = nDist2Dim/fabs(nDist2Dim);
			if(nSide != nSideLoc) 
			{
				nDistMove *= nFactor;
			}
			else 
			{
				nDistMove *= -nFactor;
			}
		} 
		else 
		{
			if(nSideLoc == OFFSET_LEFT) 
			{
				nDistMove = -nDistMove;
			}
		}

		nDist2Dim += nDistMove; 
		m_pDrawEnt->SetDist2DimLine(nDist2Dim, FALSE);
		m_pDrawEnt->AdjustDim(0);
		m_pDrawEnt->SetStyleId(InitDimStyle(DS_LINEAR));
	}
	return Adesk::kTrue;
}


// add by zyc 20120423 TDimIsometry命令的实现
static double s_dIsometry = 800.0f;
struct SDim
{
	AcGeVector2d vtDirection;
	EntitySet es;
	double dDistance;  // 到参考标注的距离
};

// 根据在参考标注的哪一侧，将标注对象分为两组
void SplitDims(EntitySet setRef, const PickEntSet& pickSet, 
			   std::vector<SDim>& vtLeft, std::vector<SDim>& vtRight)
{
	// 获取参考标注所在直线的方向向量
	AcGeVector2d vtRefDir;
	AcGePoint3d  ptStart;
	AcGePoint3d  ptEnd;
	
	OPENOBJ_BEGIN(setRef, AcDb::kForRead, AecDbDimension, pDim);
	if (pDim)
	{
		pDim->getStartPoint(ptStart);
		pDim->getEndPoint(ptEnd);
		vtRefDir.set(ptStart.x-ptEnd.x, ptStart.y-ptEnd.y);
	}
	OPENOBJ_END();
	AcGeLine3d lineRef;
	lineRef.set(ptStart, ptEnd);

	// 与参考标注垂直的方向向量
	AcGeVector2d vtLeftDir, vtRightDir;
	vtLeftDir  = vtRefDir;
	vtLeftDir.rotateBy(PI/2.0f);
	vtLeftDir.normalize();
	vtRightDir = vtRefDir;
	vtRightDir.rotateBy(-PI/2.0f);
	vtRightDir.normalize();

	// 遍历选择集
	double dDistance;
	SDim sDim;
	// 设置误差范围
	AcGeTol tol;
	tol.setEqualPoint(g_Option::instance()._DIST_SNAP);
	tol.setEqualVector(g_Option::instance()._DIST_SNAP);
	for (int i=0; i<pickSet.Length(); i++)
	{
		OPENOBJ_BEGIN(pickSet[(long)i], AcDb::kForRead, AecDbDimension, pDim);
		if (pDim)
		{
			// 判断是否与参考标注平行
			AcGePoint3d ptStartTemp,ptEndTemp;
			pDim->getStartPoint(ptStartTemp);
			pDim->getEndPoint(ptEndTemp);
			AcGeVector2d vtDir;
			vtDir.set(ptStartTemp.x-ptEndTemp.x,
					  ptStartTemp.y-ptEndTemp.y);
			if (Adesk::kTrue != vtDir.isParallelTo(vtRefDir, tol) ||
				pickSet[(long)i] == setRef)
			{
				continue;
			}


			// 获取到参考标注的距离
			dDistance = lineRef.distanceTo(ptStartTemp);
			sDim.dDistance   = dDistance;
			sDim.es = pickSet[(long)i];
			if (dDistance-0 < g_Option::instance()._DIST_SNAP)
			{
				sDim.vtDirection = vtLeftDir;
				vtLeft.push_back(sDim);
				continue;
			}

			// 判断在参考标注的哪一边
			AcGeVector2d vtTemp;
			vtTemp.set(ptStartTemp.x-ptEnd.x, 
					   ptStartTemp.y-ptEnd.y);
			vtTemp.rotateBy(-vtRefDir.angle());
			if (vtTemp.angle() > PI)
			{
				sDim.vtDirection = vtRightDir;
				vtRight.push_back(sDim);
			}
			else
			{
				sDim.vtDirection = vtLeftDir;
				vtLeft.push_back(sDim);
			}
		}
		OPENOBJ_END();
	}
}

void AdjustDims(std::vector<SDim>& vtDims)
{
	AcGeMatrix3d matrix;
	AcGeVector3d vec;
	for (int i=0; i<(int)vtDims.size(); i++)
	{
		vec.set(vtDims[i].vtDirection.x, 
			    vtDims[i].vtDirection.y, 0);
		matrix.setToTranslation(vec * 
			(s_dIsometry*(i+1)-vtDims[i].dDistance));
		OPENOBJ_BEGIN(vtDims[i].es, AcDb::kForWrite, AecDbDimension, pDim);
		if (pDim)
		{
			// pDim->TransformBy(matrix);
			pDim->subTransformBy(matrix);
		}
		OPENOBJ_END();
	}
}

bool SortDims(const SDim& dim1, const SDim& dim2)
{
	return dim1.dDistance < dim2.dDistance;
}

void DimIsometry()
{
	// 清空初始选择集
	GlobalFunc::DocGetPickFirst().Free();

	// 选择参考标注
	EntitySet setRef;
	RBList mask = RBList(RTDXF0, _T("AEC_CHICUNBIAOZHU"), NULL);
	int iRet = GlobalFunc::SelectEntity(_T("\n请选择参考标注<退出>:"), setRef, mask);
	if (RTNORM != iRet)
	{
		return;
	}

	OPENOBJ_BEGIN(setRef, AcDb::kForRead, AecDbDimension, pDim);
	if (pDim)
	{
		if (pDim->IsAngular())
		{
			return;
		}
	}
	OPENOBJ_END();

	// 选择需要对齐的标注
	PickEntSet setNeedAlign;
	iRet = GlobalFunc::SelectEntities(_T("\n请选择其它标注:"), setNeedAlign, mask);
	if (RTNORM != iRet)
	{
		return;
	}

	// 将需要对齐的标注根据参考标注的两侧分为两组
	std::vector<SDim> vtLeft, vtRight;
	SplitDims(setRef, setNeedAlign, vtLeft, vtRight);
	setNeedAlign.Free();

	// 如果两组均为空,退出命令
	if (vtLeft.size() == 0 &&
		vtRight.size()== 0)
	{
		return;
	}

	// 提示输入间距
	CString sIsometry;
	sIsometry.Format(_T("%lf"), s_dIsometry);
	sIsometry.TrimRight('0');
	sIsometry.TrimRight('.');
	CString sPrompt;
	sPrompt.Format(_T("\n请输入尺寸线间距<%s>:"), (LPCTSTR)sIsometry);
	iRet = acedGetReal((LPCTSTR)sPrompt, &s_dIsometry);
	if (RTCAN == iRet)
	{
		return;
	}

	// 对两组分别进行排序（根据与参考标注的距离）
	sort(vtLeft.begin(), vtLeft.end(), SortDims);
	sort(vtRight.begin(), vtRight.end(), SortDims);

	// 对需要等距处理的标注进行相应的偏移
	AdjustDims(vtLeft);
	AdjustDims(vtRight);
}
// end of TDbDimIsometry