//以下关于对话框，jig的所有类的声明和实现均被lgy注释任务需求如下
//（1）将EditSymbolAnnotate.cpp文件中所有的JIG类，放到SymbolAnnotateJig.h、SymbolAnnotateJig.cpp文件中；
//（2）将EditSymbolAnnotate.cpp文件中的2个与标高标注有关系的类，放到ElevDlg.h、ElevDlg.cpp文件中；
#include "stdafx.h"
#include "DbSymbolAnnotate.h"
#include "ArrowDlg1.h"
#include "ArrowTextDlg.h"
#include "ComposingDlg.h"
//#include "LeaderTextDlg.h"
//#include "IndexDimDlg.h"
//#include "coorddlg.h"
#include "rxregsvc.h"
#include "singleRowText.h"
#include "DrawingIndexDlg.h"

//add by lgy 20120109	
#include "SymbolAnnotateJig.h"
//add by lgy 20120319	剖面断面对话框类
#include "SectionDlg.h"
#include "EditSectionDlg.h"
#include "BatchDimDlg.h"
#include "CloudLineDlg.h"
#include "TDbAreaRedLine.h"

// sg add 090512，设置折断线两端伸出连接区间的距离
extern TARCH_IMPEXP double g_dRuptureLenLimit; // 折断线连接区间长度界限值
extern TARCH_IMPEXP double g_dMoreRuptureLimit; // 大于界限值时，出头距离
extern TARCH_IMPEXP double g_dLessRuptureLimit; // 小于界限值时，出头距离

// add by xly on 100915 设置符号标注的图层切换属性
extern TARCH_IMPEXP BOOL g_bTextDefaultLayer;
extern int g_iPrecision;

namespace
{
	AcGePoint3d TranslatePtFromRedline(const AcGePoint3d &pt)
	{
		AcGePoint3d ptLoc(pt);
		TPickEntSet set;
		set.Get(_T("X"), NULL, NULL, RBList(RTDXF0, _T("ATS_AREAREDLINE"), NULL));
		if (set.Length() > 0)
		{
			OPENOBJ_BEGIN(set[0L], AcDb::kForRead, TDbAreaRedLine, predline)
				predline->CalcUcsPtByWcsPt(ptLoc);
			OPENOBJ_END()
		}
		else
		{
			acutPrintf(_T("\n未找到场地红线实体。"));
		}
		return ptLoc;
	}
}

// add by wlw 13.05.07 编辑符号标注实体弹出新对话框
int EditNewDlg(AcDbObjectId id, CString sCmd) 
{  
	if (g_nProductId == kTARCH ||
		g_nProductId == kTELEC ||
		g_nProductId == kTWT ||
		g_nProductId == kTHVAC)//axc alter 2015-09-06电气,暖通专业双击图名标注实体弹出新的对话框
	{
// 		CRegProperty reg(GetRegLocation(), _T("License"));
// 		reg.SetTopRootKey(HKEY_LOCAL_MACHINE);
// 		int iValue(0);
// 		reg.GetValue(_T("t20"), iValue);

// 		if (!iValue)
// 			return RTERROR; //wlw 2014版使用
		OPENOBJ_BEGIN(id, AcDb::kForRead, TDbInSight, pInsi)
		{
			if (!pInsi)
				return RTERROR;
		}
		OPENOBJ_END()
	}

	//wlw mod 新建筑双击出新对话框 2013.5.7
	struct resbuf rbUr;
	rbUr.restype = RTSTR;
	rbUr.resval.rstring = _tcsdup(_T("EditObj"));
	rbUr.rbnext = NULL;
	acedSetVar(_T("USERS3"), &rbUr);

	acedPostCommand(sCmd);
	return RTNORM;
}

// add by xly 0n 100915 设置实体的图层并将实体添加到图纸中
AcDbObjectId AddToSpace(Adesk::Boolean bClosed, TDbEntity *pEntSymb) 
{  
	const TCHAR *pszLayer = pEntSymb->GetDefaultLayer(); 

	// 设置在默认图层
	if(pszLayer && g_bTextDefaultLayer) 
	{ 
		AcDbObjectId idLayer = InitLayer(pszLayer, TRUE);

		// modify by xly on 101028 没有作用可以删除，添加一个ID是否可用的判断
		//SetLayer(pszLayer); 
		//pEntSymb->setLayer(pszLayer);
		if (idLayer.isValid())
		{
			pEntSymb->setLayer(pszLayer);
		}
	}

	return AddToCurrentSpace(pEntSymb, bClosed, Adesk::kTrue); 
} 

void TrimTail(CString &str)  // MTextEdit 回车时产生 13 和 \n  将 13 截除
{
	if(str.IsEmpty())
		return;
	int len = str.GetLength();
	TCHAR strtemp[2048]=_T("");
	int j = 0;
	for(int i = 0; i < len; i ++)
	{
		if(str[i] != 13)	{
			strtemp[j] = str[i];
			j++;
		}
	}
	strtemp[j] = _T('\0');
	str = strtemp;
}

inline XPoint GetCursorPoint()
{
    CPoint ptCursor;
    XPoint ptLoc;
    if(GetCursorPos(&ptCursor)) {
        acedGetAcadDwgView()->ScreenToClient(&ptCursor);
        acedCoordFromPixelToWorld(ptCursor, ptLoc);
        ptLoc=Wcs2Ucs(ptLoc);
    }
    return ptLoc;
}

// Modify by lcf on 2005/06/23
// 作法标注
int EditComposing(AcDbObjectId id)
{
	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbSymbComposing, pComposing);
	if (pComposing == NULL)
		return RTERROR;

#if (ADS>16)
	//wlw mod 新建筑双击出新对话框 2013.5.7
	if(EditNewDlg(id,_T("TGComposing\n")) > 0)
		return TRUE;
#endif

	BOOL bOldIsSide = pComposing->IsSideText(); // 记录旧位置，sg add 081007

	CComposingDlg dlg(acedGetAcadFrame());
	dlg.Obj2Dlg(pComposing);
	{
		CTemporaryResourceOverride vTemp;
		if (dlg.DoModal() != IDOK)
			return RTNORM;
	}
	if (pComposing->upgradeOpen() == Acad::eOk)
	{
		double dNewLineLen = pComposing->GetTextBaseLen(TRUE), // sg modify 081112
			dPageWidth = pComposing->GetPageWidth(TRUE);

		dlg.Dlg2Obj(pComposing);

		BOOL bNewIsSide = pComposing->IsSideText(); // 记录新位置，sg add 081007
		if (bOldIsSide && !bNewIsSide) // “文字在线端”改为“文字在线上”
		{
			double dDist2Line = pComposing->GetDist2Line(TRUE, TRUE);
			dNewLineLen = dPageWidth + 2*dDist2Line;  // 新线长=页宽+起始距线距离
			pComposing->SetPageWidth(dPageWidth, TRUE);
		}
		else if (!bOldIsSide && bNewIsSide) // “文字在线上”改为“文字在线端”
		{
			dNewLineLen = pComposing->GetTextHeight(); // 新线长=字高
			double dOldLineLen = pComposing->GetTextBaseLen(TRUE);
			dNewLineLen *= dOldLineLen/fabs(dOldLineLen);
		}
		pComposing->SetTextBaseLen(dNewLineLen, TRUE);
		pComposing->SetAlignBySymbol(); // 设置对齐方式，sg add 081104
		pComposing->downgradeOpen();
	}

	OPENOBJ_END();
	return RTNORM;
}

// add by xly on 101227 对象编辑时增加其他夹点的操作
void AddOtherPoint(TDbSymbComposing *pComposing)
{
	AcGePoint3d ptDim = pComposing->GetStartPoint(),
		ptBase = pComposing->GetTurnPoint();
	while(1)
	{
		// jig
		// modify by xly on 110314 支持用户坐标系
		//TComposingAddOtherPtJig jig2(Ucs2Wcs(ptDim),ptBase);
		TComposingAddOtherPtJig jig2(ptDim, ptBase);
		jig2.SetPrompt(_T("\n请点取要增加的标注点<退出>:"));
		jig2.SetKeyword(_T("`"));

		int nRet = jig2.DoIt();
		if (nRet == RTNORM)
		{
			// 将其他标注点添加到实体中
			XPoint ptNew = jig2.GetPickPoint();
			AcGePoint3d ptS = pComposing->GetStartPoint(),
				ptTurn = pComposing->GetTurnPoint();

			// 引线长度
			double dLineLen = ptS.distanceTo(ptTurn);

			// 新进入点的长度
			double dNewLineLen = ptNew.Distance(ptTurn);

			if(pComposing->upgradeOpen() == Acad::eOk)
			{
				// 新进入点的长度大于引线长度，更新m_ptStart
				if (dLineLen<dNewLineLen)
				{
					pComposing->SetStartPoint(ptNew);
					pComposing->AddDotLoc(ptS);
				}
				else
				{
					pComposing->AddDotLoc(ptNew);
				}
				pComposing->downgradeOpen();
			}
		}
		else
		{
			pComposing->downgradeOpen();
			break;
		}
	}	

}

// Modify by lcf on 2005/06/23
void SymbComposing()
{
	// sg modify 120106，给“TS_SYMBOL”独立出来一个文字样式
	// AcDbObjectId idTextStyle = InitTextStyle(TS_DIM);
	AcDbObjectId idTextStyle = InitTextStyle(TS_SYMBOL);
	if (!idTextStyle)
		return;

	CComposingDlg dlg(acedGetAcadFrame());
	//注释 by lgy 20120111	文字样式具有记忆功能
	//dlg.m_strFontStyle = (const TCHAR *)GetSymbolName(idTextStyle);
	{
		CTemporaryResourceOverride vTemp;
		if (!dlg.Create(dlg.IDD, acedGetAcadFrame()))
			return;
	}
	dlg.ShowWindow(SW_SHOW);
	acedGetAcadDwgView()->SetFocus();

	TDbSymbComposing ent;
	// delete by xly on 100915 实体图层设置放在AddToSpace中
	//ent.setLayer(ent.GetDefaultLayer());
	ent.SetLayoutRotation(Ucs2Wcs(0.0));
	ent.SetTextLayerId(InitLayer(LAY_TEXT, TRUE));
	// ent.SetTextBaseLen(ent.GetDefaultTextBaseLen());
	ent.SetTextBaseLen(30); // modified by whl on 060210

	// delete by xly on 100917 不干涉用户捕捉
	//XPushVar<int> vOrthoMode(_T("ORTHOMODE"), 1); // sg add 080918，强制打开正交
	XPoint ptDim;
	while(ads_getpoint(NULL, _T("\n请给出标注第一点<退出>: "), ptDim)==RTNORM)
	{
		ptDim = Ucs2Wcs(ptDim);
		ent.SetStartPoint(ptDim);
		ent.SetTurnPoint(ptDim);
		dlg.Dlg2Obj(&ent);
		dlg.m_bPost = TRUE;

		// add by xly on 100916 有原点时，第一部操作结束，圆点标签不可用
		if (dlg.m_bHasCirPoint)
		{		
			dlg.SetLableEnable(!dlg.m_bHasCirPoint);
		}

		TComposingEdJig jig(&ent);
		jig.SetKeyword(_T("`"));

		// modify by xly on 100916 根据8.5需求更改提示语
		//jig.SetPrompt(_T("\n请给出标注第二点<退出>:"));
		jig.SetPrompt(_T("\n请给出文字基线位置<退出>:"));
		jig.SetOperCode(TComposingEdJig::kTurnPoint);
		while(1)
		{
			int nRet1 = jig.DoIt();
			if (nRet1 == RTNORM)
				break;
			else if (nRet1 == RTKWORD)
			{
				if (dlg.m_nOperCode == 0)
					dlg.GetTextHeight();
				else if (dlg.m_nOperCode == 1)
					dlg.GetPickText();
				dlg.Dlg2Obj(&ent);
			}
			else
			{
				if (::IsWindow(dlg.m_hWnd))
					dlg.DestroyWindow();
				return;
			}
		}
		
		// modify by xly on 100916 根据8.5需求更改提示语
		//jig.SetPrompt(_T("\n请给出文字线方向和长度<退出>:"));
		jig.SetPrompt(_T("\n请给出文字基线方向和长度<退出>:"));
		jig.SetOperCode(TComposingEdJig::kTextLine);
		while(1)
		{
			int nRet2 = jig.DoIt();
			if (nRet2 == RTNORM)
				break;
			else if (nRet2 == RTKWORD)
			{
				if (dlg.m_nOperCode == 0)
					dlg.GetTextHeight();
				else if (dlg.m_nOperCode == 1)
					dlg.GetPickText();
				dlg.Dlg2Obj(&ent);
			}
			else
			{
				if (::IsWindow(dlg.m_hWnd))
					dlg.DestroyWindow();
				return;
			}
		}
		// modify by xly on 100915  实体是否设置在默认层
		//((TDbEntity *)ent.clone())->AddToCSpace(Adesk::kTrue);
		AcDbObjectId newId = AddToSpace(Adesk::kTrue,(TDbSymbComposing *)ent.clone());

		// add by xly 0n 100916 如果有圆点标注
		/////////////////////////////////////Start/////////////////////////////////////////
		if (!dlg.m_bHasCirPoint)
		{
			continue;
		}

		// 打开已经存在的做法标注
		OPENOBJ_BEGIN(newId, AcDb::kForRead, TDbSymbComposing, pComposing);
		if (pComposing != NULL)
		{
			AcGePoint3d ptBase = pComposing->GetTurnPoint();

			// 反复提示“请输入其他标注点<结束>”添加标注点
			while(1)
			{
				// add by xly on 101221 及时更新对象数据
				if (pComposing->upgradeOpen() == Acad::eOk)
				{
					dlg.Dlg2Obj(pComposing);
					pComposing->downgradeOpen();
				}
				
				// jig
				// modify by xly on 110314 支持用户坐标系
				//TComposingAddOtherPtJig jig2(Ucs2Wcs(ptDim),ptBase);
				TComposingAddOtherPtJig jig2(ptDim, ptBase);
				jig2.SetPrompt(_T("\n请输入其他标注点<结束>:"));
				jig2.SetKeyword(_T("`"));

				XPoint ptNew;
				int nRet = jig2.DoIt();
				if (nRet == RTNORM)
				{
					// 将其他标注点添加到实体中
					ptNew = jig2.GetPickPoint();
					AcGePoint3d ptS = pComposing->GetStartPoint(),
						ptTurn = pComposing->GetTurnPoint();
					
					// 引线长度
					double dLineLen = ptS.distanceTo(ptTurn);

					// 新进入点的长度
					double dNewLineLen = ptNew.Distance(ptTurn);
					
					if (pComposing->upgradeOpen() == Acad::eOk)
					{
						// 新进入点的长度大于引线长度，更新m_ptStart
						if (dLineLen<dNewLineLen)
						{
							pComposing->SetStartPoint(ptNew);
							pComposing->AddDotLoc(ptS);
						}
						else
						{
							pComposing->AddDotLoc(ptNew);
						}	
						pComposing->downgradeOpen();
					}
				}
				else if (nRet == RTKWORD)
				{
					if (dlg.m_nOperCode == 0)
						dlg.GetTextHeight();
					else if (dlg.m_nOperCode == 1)
						dlg.GetPickText();
					dlg.Dlg2Obj(&ent);
				}
				else if (nRet == RTNONE)
				{
					break;
				}
				else
				{
					if (::IsWindow(dlg.m_hWnd))
					{
						dlg.DestroyWindow();
					}
					return;
				}

			}
		}
		OPENOBJ_END();
		/////////////////////////////////////End/////////////////////////////////////////

		if (!dlg.m_bContinue)
			break;
		dlg.m_bPost = FALSE;

		// add by xly on 100916 恢复对话框标签显示
		dlg.SetLableEnable(TRUE);
	}
    if (::IsWindow(dlg.m_hWnd))
        dlg.DestroyWindow();
}

// 计算单行文字的长度，
// sText,文字； styleId：文字样式； dHei：字高； iWider：多计算几个字符的宽度（原始长度太小）
double CalcTextLen(const CString &sText, const AcDbObjectId &styleId, double dHei, int iWider)
{
	return TDbSymbIndexPointer::CalcTextLen(sText, styleId, dHei, iWider);
}

// 计算多行文字的长度
// sText：计算长度的字符串，
// styleId：字型
// dHei：字高
// dWid：行宽
// iWider：增加几个字符的宽度
double CalcMTextLen(const CString &sText, const AcDbObjectId &styleId, double dHei, double dWid, int iWider)
{
	if (sText.IsEmpty())
		return 0.0;

	TDbMText text;
	text.SetHeight(dHei);
	text.SetStyleId(styleId);
	text.SetPageWidth(dWid);
	text.SetText(sText);
	text.SetAlignment(TGGiExplodeDrawBase::kLeft);
	text.SetLocation(XPoint());

	XPoint ptMin, ptMax;
	text.GetExtents2d(ptMin, ptMax);
	double dLen = (ptMax.x - ptMin.x);

	CString sOneWider = _T("1"); // 测试一个字符的宽度
	text.SetText(sOneWider);
	text.GetExtents2d(ptMin, ptMax);
	double dOneLen = (ptMax.x - ptMin.x);
	XPoint ext = text.GetExtents();

	return dLen + iWider * dOneLen;
}

 XPoint pptfirst_; // [11/12/2007 nsh]
 double sAngle_;

void AddCutLineForIndexPointer(TDbSymbIndexPointer *pText)
{
	ASSERT(pText != NULL);
	ASSERT(!pText->IsIndexPointer());

	TDbSymbIndexPointer *pEntClone = (TDbSymbIndexPointer *)pText->clone();
	if (pText->upgradeOpen()==Acad::eOk) 
	{
		pText->setVisibility(AcDb::kInvisible);
		pText->downgradeOpen();
		acedGetAcadDwgView()->Invalidate();
		acedGetAcadDwgView()->UpdateWindow();
	}
	TIndexPointerEdJig jig(pEntClone);
	jig.SetKeyword(_T("`")); // 对话框中取字高、词
	jig.InitCutLine();

	jig.SetPrompt(_T("\n请给出其它剖切线位置<退出>: "));
	jig.SetOperCode(TIndexPointerEdJig::kMoreCuts);

	BOOL bAdd = FALSE;
	while (1)
	{
		int nRet = jig.DoIt();
		if (nRet == RTNORM)
		{// 继续添加剖切线
			continue;
		}
		else if (nRet == RTCAN)
		{ // 退出
			break;
		}
		else
		{ // 结束添加剖切线，
			bAdd = TRUE;
			break;
		}
	}

	if (pText->upgradeOpen() == Acad::eOk)
	{
		if (bAdd) 
		{
			CArray<XLine, XLine&> arCutLine;
			pEntClone->GetCutLineAll(arCutLine);
			arCutLine.RemoveAt(0);
			pText->SetCutLine(arCutLine);
		}

		delete pEntClone;
		pEntClone = NULL;
		pText->setVisibility(AcDb::kVisible);
		pText->downgradeOpen();
	}
}

// Modify by lcf on 2005/06/24
int EditIndexPointer(AcDbObjectId id)
{
	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbSymbIndexPointer, pIndex);
	if (!pIndex)
		return RTERROR;
#if (ADS>16)
	//wlw mod 新建筑双击出新对话框 2013.5.7
	if(EditNewDlg(id,_T("TGIndexPtr\n")) > 0)
		return TRUE;
#endif

	CEditIndexDimDlg dlg(acedGetAcadFrame());
	dlg.Obj2Dlg(pIndex);
	dlg.AttachObject(pIndex);

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

	if (pIndex->upgradeOpen()==Acad::eOk) 
	{
		dlg.Dlg2Obj(pIndex);
		dlg.AdjustExtentProp();
		pIndex->downgradeOpen();
	}
	OPENOBJ_END();
	return RTNORM;
}


// add by cwk on 060706
extern BOOL g_bIndexDimFixAngle;
extern CString g_sIndexDimFixAngle;
// Modify by lcf on 2005/06/24
void SymbIndexPointer()
{
	AcDbObjectId idTextStyle = InitTextStyle(TS_LABEL); // 圆圈文字样式
	// sg modify 120106，给“TS_DRAWINGNAME”独立出来一个文字样式
	// AcDbObjectId idDimStyle = InitTextStyle(TS_DIM); // 标注文字样式
	AcDbObjectId idDimStyle = InitTextStyle(TS_SYMBOL); // 线上文字样式
	if (!idTextStyle)
		return;

	CIndexDimDlg dlg(FALSE, acedGetAcadFrame());
	//注释 by lgy 20120111	命令启动要求记录上次命令设置的文字样式
	//dlg.m_strFontStyle = (const TCHAR *)GetSymbolName(idTextStyle);
	//dlg.m_strDimStyle = (LPCTSTR)GetSymbolName(idDimStyle); // lgh add 20101216 ，标注文字样式
	{
		CTemporaryResourceOverride vTemp;
		if (!dlg.Create(dlg.IDD, acedGetAcadFrame()))
			return;
	}
	dlg.ShowWindow(SW_SHOW);
	acedGetAcadDwgView()->SetFocus();

	TDbSymbIndexPointer ent; // 索引符号
	
	// delete by xly on 100915 实体图层设置放在AddToSpace中
	//ent.setLayer(ent.GetDefaultLayer());
	ent.SetLayoutRotation(Ucs2Wcs(0.0));
	ent.SetTextLayerId(InitLayer(LAY_TEXT, TRUE));
	ent.SetTextBaseLen(ent.GetDefaultTextBaseLen()); // 默认为6.0*出图比例

	XPoint ptDim;
	while (ads_getpoint(NULL, _T("\n请给出索引节点的位置<退出>: "), ptDim) == RTNORM)
	{
		pptfirst_ = ptDim; // [11/12/2007 nsh]，固定角度使用
		ptDim = Ucs2Wcs(ptDim);
		ent.SetStartPoint(ptDim); // 起点
		ent.ClearCutLine();
		ent.ClearAddedPoint();
		dlg.UpdateVisible(FALSE); // 索引符号类型，不可改
		dlg.Dlg2Obj(&ent);
		dlg.m_bPost = TRUE;
		dlg.SetSectRunView(FALSE);

		TIndexPointerEdJig jig(&ent);
		jig.AttachDlg(&dlg);
		jig.SetKeyword(_T("`")); // 屏幕取字高、词
		int nRet = RTNORM;
		if (ent.IsIndexPointer()) // 指向索引
		{
			if (!dlg.m_bAddIndex) // sg modify 090429，支持钩选不添加索引范围
				ent.SetSourceExtent(0.0);
			else
			{
				dlg.SetSourceExtentVisible(FALSE); // sg add 090416，是否添加索引范围，不可改
				jig.SetPrompt(_T("\n请给出索引节点的范围<0.0>: "));
				jig.SetOperCode(TIndexPointerEdJig::kSourceExtent);
				while(1)
				{
					nRet = jig.DoIt();
					if (nRet == RTNONE)
					{
						ent.SetSourceExtent(0.0);
						break;
					}
					else if (nRet == RTNORM)
						break;
					else if (nRet == RTKWORD)
					{
						if (dlg.m_nOperCode == 0) // 屏幕拾取字高
							dlg.GetTextHeight();
						else if (dlg.m_nOperCode == 1)
							dlg.GetPickText(); // 屏幕拾取文字
						dlg.Dlg2Obj(&ent);
					}
					else
					{
						if (::IsWindow(dlg.m_hWnd))
							dlg.DestroyWindow();
						return;
					}
				}
			}
		}
		else // 剖切索引
			ent.SetSourceExtent(TDbSymbIndexPointer::GetDefaultCutLineLen());
		dlg.SetSourceExtentVisible(FALSE); // sg add 090416，是否添加索引范围，不可改

		// 把这两个数据初始一下。
		if (dlg.m_bAddTurn && !ent.IsIndexPointer())
		{ 
			ent.SetAddedPoint(ent.GetStartPoint());
		}
			
		ent.SetTurnPoint(ent.GetStartPoint());

		if (dlg.m_bAddTurn && !ent.IsIndexPointer())
		{ //剖切索引，并且需要绘制两个转折点
			jig.SetPrompt(_T("\n请给出转折点位置<退出>:"));
			jig.SetOperCode(TIndexPointerEdJig::kAddedTurn);

			while (1)
			{
				nRet = jig.DoIt();
				if (nRet == RTNORM)
				{
					break;
				}
				else if (nRet == RTKWORD)
				{
					if (dlg.m_nOperCode == 0) // 屏幕拾取字高
						dlg.GetTextHeight();
					else if (dlg.m_nOperCode == 1)
						dlg.GetPickText(); // 屏幕拾取文字
					dlg.Dlg2Obj(&ent);
				}
				else
				{
					if (::IsWindow(dlg.m_hWnd))
						dlg.DestroyWindow();
					return;
				}
			}

		}

		jig.SetPrompt(_T("\n请给出转折点位置<退出>:"));
		jig.SetOperCode(TIndexPointerEdJig::kTurnPoint);
		while(1)
		{
			if (!dlg.m_bFixAngle) // 不固定角度
			{
				jig.m_bFixAngle = FALSE;
			}
			else // 固定角度
			{
				jig.m_bFixAngle = TRUE;
				jig.m_dFixAngle = _tstof(LPCTSTR(dlg.m_sFixAngle));
				sAngle_ = _tstof(LPCTSTR(dlg.m_sFixAngle)); // [11/12/2007 nsh]
			}
			
			nRet = jig.DoIt();
			if (nRet == RTNORM)
			{
				break;
			}
			else if (nRet == RTKWORD)
			{
				if (dlg.m_nOperCode == 0) // 屏幕拾取字高
					dlg.GetTextHeight();
				else if (dlg.m_nOperCode == 1) // 屏幕拾取文字
					dlg.GetPickText();
				dlg.Dlg2Obj(&ent);
			}
			else
			{
				if (::IsWindow(dlg.m_hWnd))
					dlg.DestroyWindow();
				return;
			}
		}

		jig.SetPrompt(_T("\n请给出文字索引号位置<退出>:"));
		jig.SetOperCode(TIndexPointerEdJig::kTextBasePoint);
		while (1)
		{
			nRet = jig.DoIt();
			if (nRet == RTNORM)
			{
				if(!ent.IsIndexPointer()) 
				{
					jig.SetPrompt(_T("\n请给出剖视方向<当前>:"));
					jig.SetOperCode(TIndexPointerEdJig::kViewDirection);
					while(1)
					{
						int nRet1 = jig.DoIt();
						if(nRet1 == RTNORM)
							break;
						else if(nRet1 == RTNONE)
						{
							dlg.Dlg2Obj(&ent);
							break;
						}
						else if(nRet1 == RTKWORD)
						{
							if(dlg.m_nOperCode == 0)
								dlg.GetTextHeight();
							else if(dlg.m_nOperCode == 1)
								dlg.GetPickText();
							dlg.Dlg2Obj(&ent);
						}
						else
						{
							if(::IsWindow(dlg.m_hWnd))
								dlg.DestroyWindow();
							return;
						}
					}
					if(nRet!=RTNORM && nRet!=RTNONE)
						return;
				}
				break;
			}
			else if (nRet == RTKWORD)
			{
				if (dlg.m_nOperCode == 0) // 屏幕拾取字高
					dlg.GetTextHeight();
				else if (dlg.m_nOperCode == 1) // 屏幕拾取文字
					dlg.GetPickText();
				dlg.Dlg2Obj(&ent);
			}
			else
			{
				if (::IsWindow(dlg.m_hWnd))
					dlg.DestroyWindow();
				return;
			}
		}

		// lgh add 101217，设置多个剖切线位置
		if (!ent.IsIndexPointer() && dlg.m_bMoreCut)
		{ // 多个剖切线
			jig.SetPrompt(_T("\n请给出其它剖切线位置: "));
			jig.SetOperCode(TIndexPointerEdJig::kMoreCuts);

			while (1)
			{
				nRet = jig.DoIt();
				if (nRet == RTNORM)
				{// 继续添加剖切线
					// continue	
				}
				else if (nRet == RTCAN)
				{ // 退出
					if (::IsWindow(dlg.m_hWnd))
						dlg.DestroyWindow();
					return;
				}
				else if (nRet == RTKWORD)
				{
					if (dlg.m_nOperCode == 0) // 屏幕拾取字高
						dlg.GetTextHeight();
					else if (dlg.m_nOperCode == 1)
						dlg.GetPickText(); // 屏幕拾取文字
					dlg.Dlg2Obj(&ent);
				}

				else
				{ // 结束添加剖切线，
					break;
				}
			}
		}

		dlg.UpdateData();
		
		// modify by xly on 100915  实体是否设置在默认层
		//((TDbEntity *)ent.clone())->AddToCSpace(Adesk::kTrue);
		AddToSpace(Adesk::kTrue, (TDbSymbIndexPointer *)ent.clone());
		dlg.AddToRecent();

		if (!dlg.m_bContinue) // 是否连续标注
			break;
		dlg.UpdateVisible(TRUE);
		dlg.SetSectRunView(TRUE);// lgh add 101223, 设置剖切对话框窗口
		dlg.SetSourceExtentVisible(TRUE); // sg add 090416，是否添加索引范围，可见
		dlg.m_bPost = FALSE;
	}

	if (::IsWindow(dlg.m_hWnd))
	{
		g_sIndexDimFixAngle = dlg.m_sFixAngle;
		g_bIndexDimFixAngle = dlg.m_bFixAngle;
		dlg.DestroyWindow();
	}
}

void SymbIndex()
{
	//add by lxb on 2011/12/21
	CTemporaryResourceOverride vTemp;
	//非模式对话框
	AcDbObjectId idText = InitTextStyle(TS_LABEL);
	// sg modify 120106，给“TS_INDEXSCALE”独立出来一个文字样式，传给索引图面外的文字
	AcDbObjectId idScaleStyle = InitTextStyle(TS_INDEXSCALE);

	CDrawingIndexDlg dlg ;
	if(!dlg.Create(dlg.IDD,acedGetAcadFrame()))
	{
		return;
	}
	dlg.ShowWindow(SW_SHOW);

	bool bExit = false;

	while (TRUE)
	{
		acedGetAcadDwgView()->SetFocus();

		TDbSymbDrawingIndex *pIndex = new TDbSymbDrawingIndex;
		pIndex->SetLayoutRotation(Ucs2Wcs(0.0)); 
		pIndex->SetTextLayerId(InitLayer(LAY_TEXT, TRUE));

		//JIG
		TDrawingIndexEdJig jig(pIndex,(LPTSTR)_T("\n请点取标注位置<退出>: "),(LPTSTR)_T("`"));
		while (TRUE)
		{
			//获取对话框数据
			dlg.Dlg2Obj(pIndex);
			
			int istat = jig.doIt();
			if(istat == AcEdJig::kNormal)
			{
				AcDbObjectId id = AddToSpace(Adesk::kTrue, pIndex);
				break;
			}
			else if (istat == AcEdJig::kKW1)//PostCommand(_T("` ")
			{
				if (dlg.IsOpTextHeight())
				{
					dlg.TextHight();
				}
			}
			else//PostCommand(_T(" ")或其他退出操作
			{
				bExit = true;
				break;
			}
		}//end of Jig
		if (bExit)
		{
			if (pIndex)
			{
				delete pIndex;
			}
			break;
		}
	}//end of true

	if (::IsWindow(dlg.m_hWnd))
	{
		dlg.DestroyWindow();
	}
 
	/*
	static XString sDrawingLabel(_T("-")),
		sIndexLabel(_T("1"));
	static int nScaleNum = 100; // sg add 081218
	adsout << _T("\n请输入被索引的图号(-表示在本图内) <") << sDrawingLabel << _T(">: ");

	XString sText1, sText2,
		sText3; // sg add 081218
	if (ads_getstring(0,  _T(""), sText1) != RTNORM)
		return;

	adsout << _T("\n请输入索引编号 <") << sIndexLabel << _T(">: ");
	if (ads_getstring(1, _T(""), sText2) != RTNORM)
		return;
	
	adsout << _T("\n请输入比例(-表示不绘制) 1:<") << XString(_T("%d"), nScaleNum) << _T(">:");
	if (ads_getstring(2, _T(""), sText3) != RTNORM) // sg add 081218
		return;

//	XPoint ptLoc;
//	if (ads_getpoint(NULL, _T("\n标注位置<退出>:"), ptLoc) != RTNORM)
//		return;
//	ptLoc = Ucs2Wcs(ptLoc);
    
	if (!!sText1)
		sDrawingLabel = sText1;
	if (!!sText2)
		sIndexLabel = sText2;
	BOOL bDrawScale = _tcscmp(sText3, _T("-"))!=0; // sg add 081218，是否绘制
	if (!!sText3 && bDrawScale) // 有具体的数值
	{
		nScaleNum = _ttoi(sText3);
	}

	TDbSymbDrawingIndex *pIndex = new TDbSymbDrawingIndex;
	if (_tcscmp(sDrawingLabel, _T("-")) != 0)
		pIndex->SetDrawingLabel(sDrawingLabel);

	pIndex->SetIndexLabel(sIndexLabel);
	XPoint ptLoc = GetCursorPoint();
	pIndex->SetCenter(Ucs2Wcs(ptLoc));
	pIndex->SetTextStyleId(InitTextStyle(TS_LABEL));
//	pIndex->SetTextRotation(Ucs2Wcs(0.0)); // old
	pIndex->SetLayoutRotation(Ucs2Wcs(0.0)); // modified by whl
	pIndex->SetTextLayerId(InitLayer(LAY_TEXT, TRUE));
	pIndex->SetDrawScale(bDrawScale); // sg add 081218，设置是否绘制比例
	pIndex->SetScaleStyleId(InitTextStyle(TS_LABEL));
	pIndex->SetScaleTextHeight(3.5);
	CString csScale;
	csScale.Format(_T("1:%d"), nScaleNum);
	pIndex->SetScaleText(csScale);

	// modify by xly on 100915  实体是否设置在默认层
	//AcDbObjectId idLast = pIndex->AddToCSpace(Adesk::kTrue);
	AcDbObjectId idLast = AddToSpace(Adesk::kTrue, pIndex);

	ASSERT(!!idLast);
	OPENOBJ_BEGIN(idLast, AcDb::kForRead, AcDbEntity, pEnt);
	if (pEnt != NULL)
		pEnt->draw();
	OPENOBJ_END();

	PickSet ss(SS_FREE);
	ss += idLast;

	ss.Redraw(2);
	int nRet = DragMovePickSet(ss, _T("\n请点取标注位置<退出>: "), ptLoc, XPoint());
	ss.Redraw(1);
	if (nRet != RTNORM)
	{
//		if (DragPickSet(ss, ptLoc)!=RTNORM)
//			ss.Redraw(1);
		ss.Delete();
	}
	*/
}


int EditSymbIndex(AcDbObjectId id)
{
	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbSymbDrawingIndex, pIndex);
	if (pIndex == NULL)
	{
		return RTERROR;
	}
#if (ADS>16)
	//wlw mod 新建筑双击出新对话框 2013.5.7
	if(EditNewDlg(id,_T("TGIndexDim\n")) > 0)
		return TRUE;
#endif

	//模态对话框 add by lxb on 2011/12/21
	CDrawingIndexDlg dlg(acedGetAcadFrame());
	dlg.Obj2Dlg(pIndex);
	if (dlg.DoModal() == IDOK)
	{
		if (pIndex->upgradeOpen() == Acad::eOk)
		{
			double dTextHight = 0;
			BOOL bDrawScale = false;
			XString sDrawingLabel(_T("")),sIndexLabel(_T("")),sTextStyle(_T("")),sScaleText(_T(""));

			//add by lgy 20120111	添加比例文字样式
			XString sScaleStyle(_T(""));

			dTextHight = dlg.GetTextHight();
			bDrawScale = dlg.IsDrawScale();
			sDrawingLabel = dlg.GetDrawingLabel();
			sIndexLabel = dlg.GetIndexLabel();
			sTextStyle = dlg.GetTextStyle();

			//add by lgy 20120111	获得比例文字样式字符串
			sScaleStyle = dlg.GetScaleStyle();

			sScaleText = dlg.GetScaleText();

			AcDbObjectId idTextStyle = InitTextStyle(sTextStyle);

			//add by lgy 20120111	获得比例文字样式字符串
			AcDbObjectId idScaleStyle = InitTextStyle(sScaleStyle);

			//修改属性
			if ((sDrawingLabel == _T("-")))
			{
				sDrawingLabel = _T("");
			}
			pIndex->SetDrawingLabel(sDrawingLabel);     //图号
			pIndex->SetIndexLabel(sIndexLabel);         //编号
			pIndex->SetTextStyleId(idTextStyle);        //文字样式

			//modify by lgy 20120111	设置比例文字样式
			//pIndex->SetScaleStyleId(idTextStyle);
			pIndex->SetScaleStyleId(idScaleStyle);

			pIndex->SetScaleTextHeight(dTextHight);     //字高 
			pIndex->SetDrawScale(bDrawScale);           //是否画比例
			pIndex->SetScaleText(sScaleText);           //比例内容

			pIndex->downgradeOpen();
		}
	}
	OPENOBJ_END();

	return RTNORM;
	/*
	if (!id)
		return RTERROR;

	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbSymbDrawingIndex, pIndex);
	if (pIndex == NULL)
		return RTERROR;
	
	XString sDrawingLabel, sIndexLabel;
	sDrawingLabel = pIndex->GetDrawingLabel();
	sIndexLabel = pIndex->GetIndexLabel();
	
	if (!sDrawingLabel) // sg add 090511，保证提示和绘制时候一致
		sDrawingLabel = _T("-");
	adsout << _T("\n请输入被索引的图号(-表示在本图内) <") << sDrawingLabel << _T(">: ");

	XString sText1, sText2;
	if (ads_getstring(0,  _T(""), sText1) != RTNORM)
		return RTNORM;
	if (!!sText1)
		sDrawingLabel = sText1;
	
	adsout << _T("\n请输入索引编号 <") << sIndexLabel << _T(">: ");
	if (ads_getstring(1, _T(""), sText2) != RTNORM)
		return RTNORM;
	if (!!sText2)
		sIndexLabel = sText2;

	XString sScale; // sg add 090105，增加修改比例的功能
	sScale = pIndex->GetScaleText();
	int nNumber(0);
	BOOL bNum = pIndex->IsDrawScale(); // sg modify 090421，对输入的比例内容进行解析
	if (bNum)
	{
		CString csTmp = sScale;
		int nFind = csTmp.Find(_T("1:"), 0);
		if (nFind < 0)
			bNum = FALSE;
		else
		{
			int nNum = csTmp.GetLength() - (nFind + 2);
			csTmp = csTmp.Right(nNum);
			nNumber = _ttoi(csTmp);
			
			nNum = csTmp.GetLength();
			for (int i=0; i<nNum; i++)
			{
				if (_istdigit(csTmp[i])) // 数字
					continue;
				bNum = FALSE;
				break;
			}
		}
	}

	if (!bNum)
		adsout << _T("\n请输入比例(-表示不绘制) <") << sScale << _T(">: ");
	else
		adsout << _T("\n请输入比例(-表示不绘制) 1:<") << XString(_T("%d"), nNumber) << _T(">:");

	BOOL bDrawScale = TRUE;
	if (ads_getstring(2, _T(""), sText1) != RTNORM)
		return RTNORM;
	if (!!sText1 && _tcscmp(sText1, _T("-"))!=0)
	{
		if (!bNum) // 全部输入
			sScale = sText1;
		else
		{
			bNum = TRUE;
			CString csTmp = sText1;
			int nNum = csTmp.GetLength();
			for (int i=0; i<nNum; i++)
			{
				if (_istdigit(csTmp[i])) // 数字
					continue;
				bNum = FALSE;
				break;
			}

			if (bNum) // 新输入也全是数字
			{
				nNumber = _ttoi(sText1);
				sScale = XString(_T("1:%d"), nNumber);
			}
			else
				sScale = sText1;
		}
	}
	else if (!!sText1) // == "-"
		bDrawScale = FALSE;
	
	if (pIndex->upgradeOpen() == Acad::eOk)
	{
		if (_tcscmp(sDrawingLabel, _T("-")) != 0)
			pIndex->SetDrawingLabel(sDrawingLabel);
		else
			pIndex->SetDrawingLabel(_T(""));
		pIndex->SetIndexLabel(sIndexLabel);
		pIndex->SetDrawScale(bDrawScale);
		pIndex->SetScaleText(sScale);
		pIndex->downgradeOpen();
	}
	OPENOBJ_END();
	return RTNORM;
	*/
}
///////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////
// 对话框向导--对话1激活绘制pline
// 绘制箭头
int EditArrow(AcDbObjectId id) // 编辑
{
	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbSymbArrow, pArrow);
	if (!pArrow)
		return RTERROR;

#if (ADS>16)
	//wlw mod 新建筑双击出新对话框 2013.5.7
	if(EditNewDlg(id,_T("TGArrow\n")) > 0)
		return TRUE;
#endif

	CArrowTextDlg dlg(acedGetAcadFrame());
	dlg.Obj2Dlg(pArrow);
	{
		CTemporaryResourceOverride vTemp;
		if (dlg.DoModal() != IDOK)
			return RTNORM;
	}

	if (pArrow->upgradeOpen() == Acad::eOk)
	{
		dlg.Dlg2Obj(pArrow);
		pArrow->downgradeOpen();
	}
	OPENOBJ_END();
	return RTNORM;
}

// Modify by lcf on 2005/06/24
void SymbArrow()
{
	// sg modify 120106，给“TS_SYMBOL”独立出来一个文字样式
	//AcDbObjectId idTextStyle = InitTextStyle(TS_DIM);
	AcDbObjectId idTextStyle = InitTextStyle(TS_SYMBOL);
	if (!idTextStyle)
		return;

	CArrowTextDlg dlg(acedGetAcadFrame());
	//modify by lgy 20120206		要求文字样式要有记忆功能
	//dlg.m_strFontStyle = (const TCHAR *)GetSymbolName(idTextStyle);
	if (dlg.m_strFontStyle == _T(""))
	{
		dlg.m_strFontStyle = (const TCHAR *)GetSymbolName(idTextStyle);
	}

	{
		CTemporaryResourceOverride vTemp;
		if (!dlg.Create(dlg.IDD, acedGetAcadFrame()))
			return;
	}
	dlg.ShowWindow(SW_SHOW);
	acedGetAcadDwgView()->SetFocus();

	TDbSymbArrow ent;

	// delete by xly on 100915 实体图层设置放在AddToSpace中
	//ent.setLayer(ent.GetDefaultLayer());

	ent.SetLayoutRotation(Ucs2Wcs(0.0));
	ent.SetTextLayerId(InitLayer(LAY_TEXT, TRUE));

	while(1)
	{
		int nRet;
		XPoint ptStart;
		XPoly2D poly2d;
		INITGET_BEG(0, _T("P R"));
		nRet = ads_getpoint(NULL, _T("\n箭头起点或 [点取图中曲线(P)/点取参考点(R)]<退出>: "), ptStart);
		INITGET_END();
		if (nRet == RTKWORD)
		{
			XString sKeyword;
			VERIFY(ads_getinput(sKeyword)==RTNORM);
			if (sKeyword[0] == _T('R'))
			{
				XPoint ptRef;
				if (ads_getpoint(NULL, _T("\n输入参考点<退出>:"), ptRef)!=RTNORM)
					break;
				if (ads_getpoint(ptRef, _T("\n曲线起点<退出>:"), ptStart)!=RTNORM)
					break;
				ptStart = Ucs2Wcs(ptStart);
				poly2d.InsertNodeAt(0, ptStart);
			}
			else
			{
				int nCode;
				Entity ent;
				RBList mask(RTDXF0, _T("POLYLINE,LWPOLYLINE,LINE,ARC"), NULL);
				while(1)
				{
					nCode = ent.FilterSelect(_T("\n选择一曲线(LINE/ARC/PLINE):"), mask);
					if (nCode != RTNORM)
						break;

					if (ent.Is(_T("LINE")) || ent.Is(_T("ARC")))
					{
						XCurveSegment cv(ent);
						poly2d.Reset();
						cv.AsPoly2D(poly2d);
					}
					else
					{
						XPoly2D poly(ent);
						if (!!poly)
							poly2d = poly;
						else
						{
							adsout << _T("\n无效的选择!");
							continue;
						}
					}
					break;
				}

				if (nCode == RTNORM)
				{
				}
 				else if (nCode == RTNONE)
					continue;
				else
					break;
			}
		}
		else if (nRet == RTNORM)
		{
			ptStart = Ucs2Wcs(ptStart);
			poly2d.InsertNodeAt(0, ptStart);
		}
		else
			break;

		poly2d.Reverse();
		ent.SetPoly2D(poly2d);
		ent.SetTextLocation(ent.GetDefaultTextLocation());
		ent.SetText2Location(ent.GetDefaultText2Location()); // sg add 090106
		ent.SetText(_T("")); // add by [1/11/2008 nsh]
		// dlg.Dlg2Obj(&ent); // [12/28/2007 nsh]
		// sg modify 090225，不知道NSH当时为什么删除
		// 恢复的目的是为了解决：首次设置后，无法预览箭头大小、字高等信息
		dlg.Dlg2Obj(&ent);
		dlg.m_bPost = TRUE;

		TArrowEdJig jig(&ent);
		jig.SetKeyword(_T("` A U"));
		jig.SetOperCode(TArrowEdJig::kLinePoint);
		jig.SetPrompt(_T("\n直段下一点或 [弧段(A)/回退(U)]<结束>:"));
		while(1)
		{
			int nKeyIndex;
			int nRet = jig.DoIt(&nKeyIndex);
			if (nRet == RTNORM)
			{
				ent.GetPoly2D(poly2d);
				if (jig.GetOperCode() == TArrowEdJig::kArcPoint)
				{
					TArrowEdJig jig1(&ent);
					jig1.SetOperCode(TArrowEdJig::kArcMidPoint);
					jig1.SetPrompt(_T("\n点取弧上一点或 [输入半径(R)]:"));
					jig1.SetKeyword(_T("` R"));
					int nKeyIdx;
					while(1)
					{
						int nRetCode1 = jig1.DoIt(&nKeyIdx);
						if (nRetCode1 == RTNORM)
						{
							ent.GetPoly2D(poly2d);
							break;
						}
						else if (nRetCode1 == RTKWORD)
						{
							if (nKeyIdx == 0)
							{
								if (dlg.m_nOperCode == 0)
									dlg.GetTextHeight();
								else if (dlg.m_nOperCode == 1)
									dlg.GetPickText();
								dlg.Dlg2Obj(&ent);
							}
							else
							{
								TArrowEdJig jig2(&ent);
								jig2.SetOperCode(TArrowEdJig::kArcRadius);
								jig2.SetPrompt(_T("\n输入半径(光标位置确定弧的方向):"));
								jig2.SetKeyword(_T("`"));
								while(1)
								{
									int nRetCode2 = jig2.DoIt();
									if (nRetCode2 == RTNORM)
									{
										ent.GetPoly2D(poly2d);
										break;
									}
									else if (nRetCode2 == RTKWORD)
									{
										if (dlg.m_nOperCode == 0)
											dlg.GetTextHeight();
										else if (dlg.m_nOperCode == 1)
											dlg.GetPickText();
										dlg.Dlg2Obj(&ent);
									}
									else
									{
										if (::IsWindow(dlg.m_hWnd))
											dlg.DestroyWindow();
										return;
									}
								}
								break;
							}
						}
						else
						{
							if (::IsWindow(dlg.m_hWnd))
								dlg.DestroyWindow();
							return;
						}
					}
				}
				jig.SetPrompt(_T("\n直段下一点或 [弧段(A)/回退(U)]<结束>: "));
				jig.SetOperCode(TArrowEdJig::kLinePoint);
				jig.SetKeyword(_T("` A U"));
			}
			else if (nRet == RTKWORD)
			{
				if (jig.GetOperCode() == TArrowEdJig::kLinePoint) 
				{
					if (nKeyIndex == 0)
					{
						if (dlg.m_nOperCode == 0)
							dlg.GetTextHeight();
						else if (dlg.m_nOperCode == 1)
							dlg.GetPickText();
						dlg.Dlg2Obj(&ent);
					}
					else if (nKeyIndex == 1)
					{
						jig.SetOperCode(TArrowEdJig::kArcPoint);
						jig.SetPrompt(_T("\n弧段下一点或 [直段(L)/回退(U)]<结束>: "));
						jig.SetKeyword(_T("` L U"));
					}
					else if (nKeyIndex == 2)
					{
						int nLen = poly2d.Length();
						if (nLen > 1)
						{
							poly2d.Remove(0);
							poly2d.RemoveBugle(0);
						}
					}
				}
				else if (jig.GetOperCode() == TArrowEdJig::kArcPoint)
				{
					if (nKeyIndex == 0)
					{
						if (dlg.m_nOperCode == 0)
							dlg.GetTextHeight();
						else if (dlg.m_nOperCode == 1)
							dlg.GetPickText();
						dlg.Dlg2Obj(&ent);
					}
					else if (nKeyIndex == 1)
					{
						jig.SetOperCode(TArrowEdJig::kLinePoint);
						jig.SetPrompt(_T("\n直段下一点或 [弧段(A)/回退(U)]<结束>: "));
						jig.SetKeyword(_T("` A U"));
					}
					else if (nKeyIndex == 2)
					{
						int nLen = poly2d.Length();
						if (nLen > 1)
						{
							poly2d.Remove(0);
							poly2d.RemoveBugle(0);
						}
					}
				}
				ent.SetPoly2D(poly2d);
				ent.SetTextLocation(ent.GetDefaultTextLocation());
				ent.SetText2Location(ent.GetDefaultText2Location()); // sg add 090106
			}
			else if (nRet == RTNONE)
			{
				ent.SetPoly2D(poly2d);
				ent.SetTextLocation(ent.GetDefaultTextLocation());
				ent.SetText2Location(ent.GetDefaultText2Location()); // sg add 090106
				dlg.Dlg2Obj(&ent);// add by nsh 20071228
				break;
			}
			else
			{
				if (::IsWindow(dlg.m_hWnd))
					dlg.DestroyWindow();
				return;
			}
		}

		// modify by xly on 100915  实体是否设置在默认层
		//((TDbEntity *)ent.clone())->AddToCSpace(Adesk::kTrue);
		AddToSpace(Adesk::kTrue,(TDbSymbWithText*)ent.clone());

		dlg.AddToRecent();
		if (!dlg.m_bContinue)
			break;
		dlg.m_bPost = FALSE;
	}

	if (::IsWindow(dlg.m_hWnd))
		dlg.DestroyWindow();
}

//Command: 绘制一条剖线
void  SymbSectionArg(BOOL bViewLine)
{
	XString sName;
	//add by lgy 20120319 9.0需求将剖面剖切，剖面转折正交剖切，剖面非转折正交剖切，断面剖切
	//修改为对话框选取功能
	//int rc=ads_getstring(0, _T("\n请输入剖切编号<1>:"), sName);

	AcDbObjectId id = InitTextStyle(TS_SECTION);
	AcDbObjectId id1 = InitTextStyle(TS_INDEXSCALE);

	CSectionDlg dlg;
	{
		CAcModuleResourceOverride vTemp;
		if (!dlg.Create(CSectionDlg::IDD , acedGetAcadFrame()))
		{
			return;
		}
		
		dlg.m_bModeless = TRUE;
	}
	acedGetAcadDwgView()->SetFocus();
	dlg.ShowWindow(SW_SHOW);

	//add by lgy 20120411	添加while循环实现通过对话框切换命令
	while (TRUE)
	{
		sName = dlg.GetSectionNum();
		if(!_tcscmp(sName,_T("")))
		{
			_tcscpy(sName,_T("1"));
		}
    XPoint ptFirst;
		//modify by lgy 20120412	要判断是否应该退出命令
		//if(ads_getpoint(NULL,_T("\n点取第一个剖切点<退出>: "),ptFirst)!=RTNORM)
		//	return;
		int iRet = 0;
		iRet = ads_getpoint(NULL,_T("\n点取第一个剖切点<退出>: "),ptFirst);
		if ((iRet == RTCAN && !dlg.GetIsChangeType()) || iRet == RTNONE)
		{
			dlg.DestroyWindow();
			return;
		}
		dlg.SetIsChangeType(FALSE);
		if (iRet != RTNORM)
		{
			continue;
		}
    ptFirst=Ucs2Wcs(ptFirst);
    XPoly2D poly(0);
    poly.AppendNode(ptFirst);
    poly.AppendNode(ptFirst);

    TDbSymbSection ent;
	ent.SetText(sName);
	//ent.SetTextRotation(Ucs2Wcs(0.0));old
	ent.SetLayoutRotation(Ucs2Wcs(0.0));//modified by whl

	// delete by xly on 100915 实体图层设置放在AddToSpace中
    //ent.setLayer(ent.GetDefaultLayer());
	// sg modify 120106，给“TS_SECTION”独立出来一个文字样式
    // ent.SetTextStyleId(InitTextStyle(TS_LABEL));
    ent.SetTextStyleId(InitTextStyle(TS_SECTION));
	ent.SetTextLayerId(InitLayer(LAY_TEXT, FALSE));
	ent.SetViewLine(bViewLine);
    ent.SetPoly2D(poly);

		//modify by lgy 20120320	对话框中要判断是点取的是那种方式绘制剖面剖切
		ent.SetTextHeight(dlg.GetNumHeight());
		ent.SetText(dlg.GetSectionNum());
		AcDbObjectId idScaleStyle = InitTextStyle(dlg.GetNumStyle());
		ent.SetTextStyleId(idScaleStyle);
		if (dlg.GetIsShowDrawText())
		{
			if (dlg.GetLocal() == 0)	//两端显示
			{
				ent.SetIsHasIndexS(TRUE);
				ent.SetIsHasIndexE(TRUE);
			}
			else if (dlg.GetLocal() == 1)//始端显示
			{
				ent.SetIsHasIndexS(TRUE);
				ent.SetIsHasIndexE(FALSE);
			}
			else if (dlg.GetLocal() == 2)//末端显示
			{
				ent.SetIsHasIndexS(FALSE);
				ent.SetIsHasIndexE(TRUE);
			}

			if (!dlg.GetDirect())
			{
				ent.SetDimDirection(0);	//剖切方向
			}
			else
			{
				ent.SetDimDirection(1);	//剖视方向
			}

			ent.SetDrawingIndex(dlg.GetDrawNum());
			ent.SetIndexHeight(dlg.GetDrawHeight());
			ent.SetIndexStyleId(InitTextStyle(dlg.GetDrawingStyle()));
		}
		else		//不显示文字时，默认仍要有文字样式
		{
			ent.SetDrawingIndex(_T("1"));	//如果不显示文字，为标注设置默认文字为1
			ent.SetIndexStyleId(id1);
			ent.SetIndexHeight(3.5);
		}

		int nMode = dlg.GetSectionMode();
		if (nMode == 4)
		{
			ent.SetViewLine(FALSE);
		}
		TSectionEdJig jig(&ent);
		jig.SetPrompt(_T("\n点取第二个剖切点<退出>:"));
		jig.SetOperCode(TSectionEdJig::kSectPoint);
		//modify by lgy 20120412	判断是否真需要返回
		//if(jig.DoIt()!=RTNORM)
		//return;
		jig.SetJigMode(nMode);
		jig.SetJigDlg(&dlg);
		iRet = jig.DoIt();
		if ((iRet == RTCAN && !dlg.GetIsChangeType()) || iRet == RTNONE)
		{
			dlg.DestroyWindow();
			return;
		}
		dlg.SetIsChangeType(FALSE);
		if (iRet != RTNORM)
		{
			continue;
		}

		int nRet;
		//modify by lgy 20120320	对话框中要判断是点取的是那种方式绘制剖面剖切
		//if(bViewLine) 
		if(bViewLine&&(nMode == 2 || nMode == 3))
		{
			XPushVar<int> orthomode(_T("ORTHOMODE"), 0);
			jig.SetPrompt(_T("\n点取下一个剖切点<结束>:"));
			jig.SetOperCode(TSectionEdJig::kSectPointOther);
			while((nRet=jig.DoIt())==RTNORM);

			if(nRet==RTNONE)            //by fxj
			{
				if(jig.GetiFlag2()==0)
				{
					XPoly2D poly;
					ent.GetPoly2D(poly);
					poly.RemoveNode(poly.Length()-1);
					if (nMode != 3)
					{
						poly.RemoveNode(poly.Length()-1);
					}
					ent.SetPoly2D(poly);
				}
			}
			else
				//modify by lgy 20120412	判断是否真需要返回
				//return;
			{
				continue;
			}

		}
		jig.SetPrompt(_T("\n点取剖视方向<当前>:"));
		jig.SetOperCode(TSectionEdJig::kViewDirection);
		nRet=jig.DoIt();
		if((nRet==RTNORM || nRet==RTNONE) && ent.IsValid()) {
			ent.SetTextLocation(0, ent.GetDefaultTextLocation(0));
			ent.SetTextLocation(1, ent.GetDefaultTextLocation(1));

			// modify by xly on 100915  实体是否设置在默认层
			//((TDbEntity *)ent.clone())->AddToCSpace(Adesk::kTrue); 
			AddToSpace(Adesk::kTrue, (TDbSymbSection *)ent.clone()); 
		}
	}
}

// Command: 剖面剖切
void  SymbSection()
{
   SymbSectionArg(TRUE);
}
//add by lgy 20120322 编辑剖面剖切
int EditSymbSection(AcDbObjectId id)
{
	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbSymbSection, pSection);
	if (!pSection)
	{
		return RTERROR;
	}
#if (ADS>16)
	//wlw mod 新建筑双击出新对话框 2013.5.7
	if(EditNewDlg(id,_T("TGSection\n")) > 0)
		return TRUE;
#endif

	CTemporaryResourceOverride vTemp;
	CEditSectionDlg dlg(acedGetAcadFrame());
	
	//add by lgy 20120525	将实体参数传给对话框
	dlg.Obj2Dlg(pSection);
	
	INT_PTR nResult = dlg.DoModal();
	if (nResult == IDOK)
	{
		if (pSection->upgradeOpen() == Acad::eOk)
		{
			dlg.Dlg2Obj(pSection);
			pSection->downgradeOpen();
		}
	}
	else
	{
		pSection->close();
		return RTCAN;
	}
	OPENOBJ_END();
	return RTNORM;
}

// Command: 剖断剖切
void  SymbSection1()
{
	SymbSectionArg(FALSE);
}
//add by yyc 增加指北针上华图层
#include "msxml6.tlh"
#define TARCH_INSTALL_DIRECTORY_INCLUDE_SYS _T("\\SYS\\")
#define TARCH_LAYER_GROUP_FILE_NAME_XML _T("LayerGroup.XML")
void AddLayerToFile()
{
	char* old_locale = _strdup(setlocale(LC_CTYPE, NULL));
	setlocale(LC_CTYPE, "chs");//设定<ctpye.h>中字符处理方式

	::CoInitialize(NULL);
	MSXML2::IXMLDOMDocumentPtr pDoc;
	HRESULT hr = pDoc.CreateInstance(__uuidof(MSXML2::DOMDocument60));
	if (!SUCCEEDED(hr))
	{
		CString str(_T("无法创建DOMDocument对象，请检查是否安装了MS XML Parser 运行库!"));
		AfxMessageBox(str);
		//GlwLayerWarnMessageBox WndDlgLayerNotDeleteWarn(str, acedGetAcadFrame());
		//WndDlgLayerNotDeleteWarn.DoModal(WS_POPUP | WS_CAPTION 
		//	| WS_SYSMENU, NULL, acedGetAcadFrame());
		return;
	}
	CString InstallDirectory = g_sDwbPath;
	CString sLayerGrpXml = InstallDirectory.Left(InstallDirectory.GetLength() - 5) + TARCH_INSTALL_DIRECTORY_INCLUDE_SYS + TARCH_LAYER_GROUP_FILE_NAME_XML;
	
	CFileFind finder;
	BOOL bIsExist = finder.FindFile(sLayerGrpXml); //查看安装路径下的图层标准文件是否存在
	if (!bIsExist)
	{
		CString str = sLayerGrpXml;
		str += _T("文件不存在");
		AfxMessageBox(str);
		return;
	}
	/*
	<LayerGroup>
	<Sort name="0"></Sort>
	<Group name="平面" sKeyWord="轴线*柱子*墙线*幕墙*矮墙*隔墙*门窗*门*防火门*防火卷帘*楼梯*栏杆*扶手*电梯*阳台*地面*停车位*道路*树木*道路中线*屋顶*面层*梁*雨水管线*洁具*卫生隔断"></Group>
	<Group name="立面" sKeyWord="立线*立窗*立块*立梯*立雨水管*层线"></Group>
	<Group name="剖面" sKeyWord="剖线*剖窗*剖块*剖梯*剖面面层"></Group>
	<Group name="注释" sKeyWord="公文*表格*公标*坐标*索引符号*引出标注*图名标注*云线*标高*轴标*轴文*建筑面积*公摊面积*洞口面积*阳台面积*套内面积*防火门标注*窗名*公框*房间*房间填充*公填*指北针"></Group>
	<Group name="其他" sKeyWord="相机*日影*日窗*建筑*公窗"></Group>
	</LayerGroup>
	*/
	pDoc->load(_bstr_t(sLayerGrpXml));// 加载文件   
	MSXML2::IXMLDOMNodePtr  pNode;

	MSXML2::IXMLDOMElementPtr pRootNode = pDoc->documentElement;
	MSXML2::IXMLDOMNodeListPtr pNodes = pRootNode->selectNodes(_T("//Group"));// "表示在任意一层查找   

	long size = pNodes->length;
	for (int J = 0; J < size; J++)
	{
		MSXML2::IXMLDOMNodePtr ppNode = pNodes->item[J];
		MSXML2::IXMLDOMNamedNodeMapPtr attri;
		ppNode->get_attributes(&attri);
		long mCount = attri->Getlength();
		MSXML2::IXMLDOMNodePtr pName = attri->getQualifiedItem(_T("name"), "");
		CString strs((LPCTSTR)(pName->Gettext()));
		if (strs == _T("注释"))
		{
			MSXML2::IXMLDOMNodePtr pKeyword = attri->getQualifiedItem(_T("sKeyWord"), "");
			CString strKey((LPCTSTR)(pKeyword->Gettext()));
			if (strKey.Find(_T("指北针")) == -1)
			{
				strKey += _T("*指北针");
				pKeyword->text = _bstr_t(strKey);
				pKeyword->PutnodeTypedValue(_variant_t(strKey));
				pDoc->save(_bstr_t(sLayerGrpXml));
			}
		}
	}
	::CoUninitialize();

	setlocale(LC_CTYPE, old_locale);
	free(old_locale);//还原区域设定

	CString csSysPath = g_sDwbPath;
	csSysPath = csSysPath.Left(csSysPath.GetLength() - 5) + _T("\\sys\\");
	csSysPath += _T("TArch.lay");
	CString str;
	CStdioFile file;
	file.Open(csSysPath, CFile::modeReadWrite);
	BOOL ret = FALSE;
	while (file.ReadString(str))
	{
		if (str.Find(_T("指北针")) != -1)
			ret = TRUE;
	}
	if (!ret)
	{
		file.SeekToEnd();
		file.WriteString(_T("\n指北针 DIM_SYMB 3 CONTINUOUS 指北针"));
	}
	file.Close();

	CStdioFile file2;
	csSysPath = g_sDwbPath;
	csSysPath = csSysPath.Left(csSysPath.GetLength() - 5) + _T("\\sys\\");
	csSysPath += _T("LAYERDEF.DAT");
	file2.Open(csSysPath, CFile::modeReadWrite);
	ret = FALSE;
	while (file2.ReadString(str))
	{
		if (str.Find(_T("指北针")) != -1)
			ret = TRUE;
	}
	if (!ret)
	{
		file2.SeekToEnd();
		file2.WriteString(_T("\n指北针 DIM_SYMB 3 CONTINUOUS 指北针"));
	}
	file2.Close();
}
// 应当允许直接给角度
void SymbNorthThumb()
{
	//AddLayerToFile();
	acDocManager->disableDocumentActivation();
    //XPoint ptStart;
    //if(ads_getpoint(NULL, _T("\n指北针位置<退出>:"), ptStart)!=RTNORM)
    //    return;
    //ptStart = Ucs2Wcs(ptStart);
    TDbSymbNorthThumb ent;
	ent.SetLayoutRotation(Ucs2Wcs(0.0));
    //pEnt->SetCenter(ptStart);

	// delete by xly on 100915 实体图层设置放在AddToSpace中
    //ent.setLayer(ent.GetDefaultLayer());
    TNorthThumbEdJig jig(&ent);
    jig.SetPrompt(_T("\n指北针位置<退出>:"));
    jig.SetOperCode(TNorthThumbEdJig::kCenter);
    if(jig.DoIt()!=RTNORM)
	{
		acDocManager->enableDocumentActivation();
		return;
	}
    jig.SetPrompt(_T("\n指北针方向<90.0>:"));
    jig.SetOperCode(TNorthThumbEdJig::kDirection);
    if(jig.DoIt()==RTNORM) {
		// modify by xly on 100915  实体是否设置在默认层
        //((TDbEntity *)ent.clone())->AddToCSpace(Adesk::kTrue); 
		AddToSpace(Adesk::kTrue,(TDbEntity *)ent.clone());

	/*	XPoint pt=ent.GetCenter();
		double nRot=ent.GetRotation();
		XPoint ptText;
		ads_polar(pt, nRot, ent.GetRadius(FALSE)+5.0*ent.GetPScale(), ptText);
		TDbText *pText=new TDbText;
		pText->SetHeight(5.0);
		pText->SetLocation(ptText);
		pText->SetText(_T("北"));
		pText->SetRotation(Ucs2Wcs(0.0));//modified by whl
		pText->SetStyleId(InitTextStyle(TS_DIM));
		pText->SetAlignment(XExplodeDraw::kMiddleCenter);
*/
		// modify by xly on 100915  实体是否设置在默认层
		//pText->AddToCSpace(Adesk::kTrue);
//		AddToSpace(Adesk::kTrue, pText);
    }
	acDocManager->enableDocumentActivation();
}

void SymbSymmetry()
{
	TDbConfig *pConfig=GetDwgGlobal(AcDb::kForWrite);
	if(pConfig)
		pConfig->close();

    XPoint ptStart;
    if(XGetPoint(NULL, _T("\n起点"), ptStart)!=RTNORM)
        return;
    ptStart = Ucs2Wcs(ptStart);
    TDbSymbSymmetry *pEnt=new TDbSymbSymmetry;
    pEnt->SetStartPoint(ptStart);

	// delete by xly on 100915 实体图层设置放在AddToSpace中
    //pEnt->setLayer(pEnt->GetDefaultLayer());

    TSymmetryEdJig jig(pEnt);
    jig.SetPrompt(_T("\n终点<退出>:"));
    if(jig.DoIt()==RTNORM) 
	{
		// modify by xly on 100915  实体是否设置在默认层
        //pEnt->AddToCSpace(Adesk::kTrue); 
		AddToSpace(Adesk::kTrue, pEnt);
    } 
	else
	{
        delete pEnt;
    }
}

 XPoint pptfirst;

////////////////////////////////////////////////////////////////////////////////////////////////////
// modify by lcf 2004/08/13
int EditLeader(AcDbObjectId id)
{
	//wlw mod 新建筑双击出新对话框 2013.5.7
	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbSymbMultiLeader, pLeader);
	if (!pLeader)
		return RTERROR;
	OPENOBJ_END()
#if (ADS>16)
	if(EditNewDlg(id,_T("TGLeader\n")) > 0)
		return TRUE;
#endif
	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbSymbMultiLeader, pLeader);
	if (!pLeader)
		return RTERROR;

	CEditLeaderDlg dlg(acedGetAcadFrame());
	dlg.Obj2Dlg(pLeader);

	CTemporaryResourceOverride vTemp;
	INT_PTR nResult = dlg.DoModal();
	if (nResult == IDOK)
	{
		if (pLeader->upgradeOpen() == Acad::eOk)
		{
			dlg.Dlg2Obj(pLeader);
			pLeader->downgradeOpen();
		}
	}
	else if (nResult == 1000)
	{
		int nRet = RTNORM;
		while (nRet == RTNORM)
		{
			XPointList lstPts; // sg add 090330，为调用JIG类做准备
			pLeader->GetLeaderVertexes(lstPts);
			AcGePoint3d ptBase = pLeader->GetLeaderPoint().AsAcGePoint3d(),
				ptVertexes1;
			if (lstPts.Length() > 0)
				ptVertexes1 = lstPts[0]->AsAcGePoint3d();

			XPoint ptAdd;
			// sg modify 090330，改为JIG类
//			nRet = ads_getpoint(Wcs2Ucs(pLeader->GetLeaderPoint()), _T("\n请点取要增加的标注点<退出>: "), ptAdd);
			TLeaderAddOtherPtJig jig(dlg.m_bAllPtsOnLine, pLeader->GetLeaderDirection(), ptBase,pLeader->GetTextRotation(),pLeader->IsLeaderParall());
			jig.SetPrompt(_T("\n请点取要增加的标注点<退出>: "));
			nRet = jig.DoIt();
			if (nRet == RTNORM)
			{
//				ptAdd = Ucs2Wcs(ptAdd); // sg modify 090330
				ptAdd = jig.GetPickPoint();
				if (pLeader->upgradeOpen() == Acad::eOk)
				{
					XPointList pts;
					pLeader->GetLeaderVertexes(pts);
					pts.Append(new XPoint(ptAdd));
					// pLeader->SetLeaderVertexes(pts); // sg modify 120104，根据修接口修改函数，这种情况下，不需要修改点m_ptLeaderDirection
					pLeader->SetLeaderVertexes(pts, FALSE);
					dlg.Dlg2Obj(pLeader); // sg add 090220，解决了需求平台275
					pLeader->downgradeOpen();
				}
			}
		}
	}
	else
	{
		pLeader->close();
		return RTCAN;
	}
	OPENOBJ_END();
	return RTNORM;
}

//add by cwk 060706
extern CString g_sLeadFixAngle;
extern BOOL g_bLeadFixAngle;
// Modify by lcf on 2005/06/24
void SymbLeader()
{
	BOOL bSideText = FALSE;

	CLeaderDlg dlg(FALSE, acedGetAcadFrame());
	// sg modify 120106，给“TS_SYMBOL”独立出来一个文字样式
	//AcDbObjectId idTextStyle = InitTextStyle(TS_DIM);
	AcDbObjectId idTextStyle = InitTextStyle(TS_SYMBOL);
	if (!idTextStyle)
		return;
	//modify by lgy 20120206	要求记录上次退出命令时设置的文字样式,切换图纸时原本没有的样式时初始化样式
	//dlg.m_strFontStyle = (const TCHAR *)GetSymbolName(idTextStyle);
	if (dlg.m_strFontStyle == _T(""))
	{
		dlg.m_strFontStyle = (const TCHAR *)GetSymbolName(idTextStyle);
	}

	{
		CTemporaryResourceOverride vTemp;
		if (!dlg.Create(dlg.IDD, acedGetAcadFrame()))
			return;
	}
	dlg.ShowWindow(SW_SHOW);
	acedGetAcadDwgView()->SetFocus();

	TDbSymbMultiLeader ent;

	// delete by xly on 100915 实体图层设置放在AddToSpace中
	//ent.setLayer(ent.GetDefaultLayer());
	ent.SetLayoutRotation(Ucs2Wcs(0.0));
	ent.SetTextLayerId(InitLayer(LAY_TEXT, TRUE));
	ent.SetTextBaseLen(ent.GetDefaultTextBaseLen());
	ent.SetSideText(bSideText);

	XPoint ptFirst, ptLeader;
	TDbSymbMultiLeader::TArrowStyle ar = TDbSymbMultiLeader::kNone;
	while(ads_getpoint(NULL, _T("\n请给出标注第一点<退出>: "), ptFirst) == RTNORM)
	{
		pptfirst = ptFirst; // [10/18/2007 nsh]
		XPointList lstVertexes;
		lstVertexes.Append(new XPoint(Ucs2Wcs(ptFirst)));
		ent.SetLeaderVertexes(lstVertexes);
		dlg.Dlg2Obj(&ent);
		dlg.m_bPost = TRUE;
		
		sAngle = ::_tstof(dlg.m_sFixAngle); //  [10/18/2007 nsh]
		TLeaderEdJig jig(&ent);
		//add by lgy 20120206	固定角度修改后不起作用
		jig.SetDlg(&dlg);

		jig.SetOperCode(TLeaderEdJig::kLeader);
		jig.SetPrompt(_T("\n输入引线位置或 [更改箭头型式(A)]<退出>: "));
		jig.SetKeyword(_T("` A"));
		jig.setUserInputControls(AcEdJig::kNullResponseAccepted);

		int nRet = RTNORM;
		while(1)
		{
			if (!dlg.m_bFixAngle)
			{
				jig.m_bFixAngle = FALSE;
			}
			else
			{
				jig.m_bFixAngle = TRUE;
				jig.m_dFixAngle = _tstof(LPCTSTR(dlg.m_sFixAngle));
				sAngle = _tstof(LPCTSTR(dlg.m_sFixAngle)); // [10/18/2007 nsh]
			}

			int kwd(0);
			nRet = jig.DoIt(&kwd);
			if (nRet == RTNORM)
				break;
			else if (nRet == RTKWORD)
			{
				if (kwd == 0)
				{
					if (dlg.m_nOperCode == 0)
						dlg.GetTextHeight();
					else if (dlg.m_nOperCode == 1)
						dlg.GetPickText();
					dlg.Dlg2Obj(&ent);
				}
				else
				{
					if (ar == TDbSymbMultiLeader::kNone)
						ar = TDbSymbMultiLeader::kDote;
					else if (ar == TDbSymbMultiLeader::kDote)
						ar = TDbSymbMultiLeader::kArrow;
					else if (ar == TDbSymbMultiLeader::kArrow)
						ar = TDbSymbMultiLeader::kCrossing;
					else
						ar = TDbSymbMultiLeader::kNone;
					ent.SetArrow(ar);
				}
			} 
			else
			{
				if (::IsWindow(dlg.m_hWnd))
					dlg.DestroyWindow();
				return;
			}
		}
		
		jig.SetKeyword(_T("`"));
		jig.SetOperCode(TLeaderEdJig::kTextLine);
		jig.SetPrompt(_T("\n点取文字基线位置<退出>: "));
		while(1)
		{
			nRet = jig.DoIt();
			if (nRet == RTNORM)
				break;
			else if (nRet == RTKWORD)
			{
				if (dlg.m_nOperCode == 0)
					dlg.GetTextHeight();
				else if (dlg.m_nOperCode == 1)
					dlg.GetPickText();
				dlg.Dlg2Obj(&ent);
			}
			else
			{
				if (::IsWindow(dlg.m_hWnd))
					dlg.DestroyWindow();
				return;
			}
		}

		// modify by xly on 100915  实体是否设置在默认层
		//AcDbObjectId newId = ((TDbEntity *)ent.clone())->AddToCSpace(Adesk::kTrue);
		AcDbObjectId newId = AddToSpace(Adesk::kTrue, (TDbSymbMultiLeader *)ent.clone());

		XPushVar<int> orthomode(_T("ORTHOMODE"), 0);
//		jig.SetOperCode(TLeaderEdJig::kVertex); // sg delete 090320，防止闪烁问题
//		jig.SetPrompt(_T("\n输入其他的标注点<结束>: "));

		// sg modify 090320
		OPENOBJ_BEGIN(newId, AcDb::kForRead, TDbSymbMultiLeader, pLeader);
		if (pLeader != NULL)
		{
			XPoint ptBase = pLeader->GetLeaderPoint();
			while (1)
			{
//				nRet = jig.DoIt(); // sg delete 090320，防止闪烁问题
				XPoint ptAdd;
				// sg delete 090330，还原为JIG算法，解决与正交的矛盾问题
//				nRet = ads_getpoint(Wcs2Ucs(ptBase), _T("\n输入其他的标注点<结束>: "), ptAdd);

				// sg modify 120612，接口使用错误，布局转角的接口是GetLayoutRotation
				// TLeaderAddOtherPtJig jig2(&dlg, Ucs2Wcs(ptFirst), ptBase, pLeader->GetTextRotation());
				TLeaderAddOtherPtJig jig2(&dlg, Ucs2Wcs(ptFirst), ptBase, pLeader->GetLayoutRotation());
				jig2.SetPrompt(_T("\n输入其他的标注点<结束>: "));
				jig2.SetKeyword(_T("`"));
				nRet = jig2.DoIt();
				if (nRet == RTNORM)
				{
					//复选框置灰
					dlg.SetCheckBoxStatus(FALSE);
					
//					ptAdd = Ucs2Wcs(ptAdd);
					ptAdd = jig2.GetPickPoint();
					
					XPointList pts;
					pLeader->GetLeaderVertexes(pts);
					pts.Append(new XPoint(ptAdd));
					
					if (pLeader->upgradeOpen() == Acad::eOk)
					{
						//add by lgy 20120206	引线平行在点取引线点的时候不好使
						dlg.Dlg2Obj(pLeader);

						// pLeader->SetLeaderVertexes(pts); // sg modify 120104，根据修接口修改函数，这种情况下，不需要修改点m_ptLeaderDirection
						pLeader->SetLeaderVertexes(pts, FALSE);
						pLeader->downgradeOpen();
					}
				}
				else if (nRet == RTKWORD)
				{
					if (dlg.m_nOperCode == 0)
						dlg.GetTextHeight();
					else if (dlg.m_nOperCode == 1)
						dlg.GetPickText();
					dlg.Dlg2Obj(&ent);
				}
				else if (nRet == RTNONE)
				{
					break;
				}
				else
				{
					if (::IsWindow(dlg.m_hWnd))
					{
						// sg add 090324，记忆是否启用“固定角度”，以及“固定角度”值
						g_sLeadFixAngle = dlg.m_sFixAngle;
						g_bLeadFixAngle = dlg.m_bFixAngle;
						dlg.DestroyWindow();
					}
					return;
				}
			}

			//复选框还原
			dlg.SetCheckBoxStatus();
		}
		OPENOBJ_END();

		dlg.AddToRecent();
		if (!dlg.m_bContinue)
			break;
		dlg.m_bPost = FALSE;
	}

	if (::IsWindow(dlg.m_hWnd))
	{
		g_sLeadFixAngle = dlg.m_sFixAngle;
		g_bLeadFixAngle = dlg.m_bFixAngle;
		dlg.DestroyWindow();
	}
}

// sg add 090407，用于处理TMutiElevGrid表格的排序问题
static int CompareWDGridRow(const WDGridRow &row1, const WDGridRow &row2)
{
	// 注：以下的强制转化的方法不可取，但此处没有别的方法可以实现
	WDGridRow &temp1 = (WDGridRow&)row1;
	WDGridRow &temp2 = (WDGridRow&)row2;
	TString csText1, csText2;
	csText1 = temp1[0l].GetText();
	csText2 = temp2[0l].GetText();

	double dElev1 = _tstof(csText1),
		dElev2 = _tstof(csText2);
	if (fabs(dElev1 - dElev2) < 1.0E-5)
		return 0;
	if (dElev1 > dElev2 + 1.0E-5)
		return -1;
	return 1;
}

/////////////////////////////////////////////////////////
int EditSymbElevation(AcDbObjectId id)
{
	// sg modify 090305，对象编辑时应该只读打开。防止屏幕拾取“字高”时，鼠标经过写打开的对象，出现崩溃问题
	//	OPENOBJ_BEGIN(id, AcDb::kForWrite, TDbSymbElevation, pElev);
	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbSymbElevation, pElev);
	if (pElev != NULL)
	{

		CString sElv = pElev->GetText();

#if (ADS>16)
		//wlw mod 新建筑双击出新对话框 2013.5.7
		if (sElv.Find(_T("$")) > 0)
		{
			//多层
			if (!pElev->IsFilled()
				&& !pElev->IsDote()
				&& !pElev->IsHollowTriangle()
				&& !pElev->HasBaseLine()
				&& !pElev->HasLeader())
			{
				if(EditNewDlg(id,_T("TGMulitElev\n")) > 0)
					return TRUE;
			}
		}
		else
		{
			//wlw mod 标高还是用老对话框14.7.28
			//if(EditNewDlg(id,_T("TGElevation\n")) > 0)
			//	return TRUE;
		}
#endif

		CElevDlg dlg(pElev);
		CTemporaryResourceOverride vTemp;
		dlg.DoModal();
	}
	OPENOBJ_END();
	return RTNORM;
}

// modify by zkm
AcDbObjectId SymbElev()
{
	BOOL bOrderCon = FALSE;
	AcDbObjectId idRet;
	DList<AcDbObjectId> lstElevId;
	// 获得前次绘制的最后一个点，并获得数据
	GetEntFromBlockByDxf(lstElevId, _T("ATS_ELEVATION"));
	AcDbObjectId *pLast = lstElevId.Tail();
	XPoint ptLast;
	double *pLastLoc = NULL;
	double nLastElev = 0.0;
	if (pLast)
	{
		OPENOBJ_BEGIN(*pLast, AcDb::kForRead, TDbSymbElevation, pLastElev);
		if (pLastElev)
		{
			ptLast = pLastElev->GetLocation();
			nLastElev = _tstof(pLastElev->GetText());
			pLastLoc = &ptLast.x;
			bOrderCon = TRUE;
		}
		OPENOBJ_END();
	}

	XPoint ptLoc;
	// 建立标注实体
	TDbSymbElevation *pElev = new TDbSymbElevation;
	pElev->SetTextStyleId(GetTextStyleId(_T("STANDARD")));//20160920 wlw 防止出现字体形文件错误
	pElev->SetLocation(ptLoc);
	pElev->SetBaseLine(g_bHasBase);
	pElev->SetLeader(g_bHasLeader);
	pElev->SetBaseLen(g_nBaseLen);
	pElev->SetLeaderLen(g_nLeaderLen);
	// sg delete 090209，文字样式的处理，放在SymbElev2函数中
//	pElev->SetTextStyleId(InitTextStyle(TS_DIM));
	pElev->SetTextHeight(g_dTextHeight); // sg add 090212，增加文字高度设置
	pElev->SetTextLayerId(InitLayer(LAY_TEXT, TRUE));
	pElev->SetTextBaseLen(pElev->GetDefaultTextBaseLen());

	// delete by xly on 100915 设实体图层放在AddToSpace函数中
	//pElev->setLayer(pElev->GetDefaultLayer());
	pElev->SetLayoutRotation(Ucs2Wcs(0.0)); // modified by whl
	// sg modify 090212，增加文字齐线端、是否规范样式，是否加括号的设置
	pElev->SetParentheses(g_bParentheses);
	pElev->SetAtLineSide(g_bElevSideText);
	pElev->SetStandard(g_bStandard);
	CElevDlg::g_pElevDlg->SetEntPoint(pElev);

	// 获得精度
	const TCHAR *szFormat1;
	switch(g_iPrecision) {
	case 0:
		pElev->SetPrec2(TRUE);
		szFormat1 = _T("%.2f");
		break;
	case 1:
		pElev->SetPrec2(FALSE);
		szFormat1 = _T("%.3f");
		break;
	default:
		break;
	}

	// 点取标注点或参考点
	TElevEdJig jig(pElev);
	jig.m_ptBase = ptLast;
	jig.m_fBaseElev = nLastElev;
	if (!bOrderCon)
		CElevDlg::g_pElevDlg->m_bOrderTou = TRUE;
	else
		jig.m_dPointX = Wcs2Ucs(ptLast).x;

	CString ss;
	int nIdx = 0;
	CTemporaryResourceOverride vTemp(acedGetAcadResourceInstance());
	while(1)
	{
		jig.SetOperCode(TElevEdJig::kMove);
		jig.SetPrompt(_T("\n请点取标高点或 [参考标高(R)]<退出>:"));
//		jig.SetKeyword(_T("R")); // sg modify 090217，增加了从屏幕拾取“字高”功能
		jig.SetKeyword(_T("` R"));

		int nRetCode = jig.DoIt(&nIdx);
		if (CElevDlg::g_pElevDlg != NULL)
			CElevDlg::g_pElevDlg->m_bOrderTou = FALSE;
		if (nRetCode==RTNORM && nRetCode!=RTKWORD)
		{
			pElev->SetLocation(jig.GetDragPoint());
			break;
		}		
		else if (nRetCode == RTKWORD)
		{
			if (nIdx == 0) // sg add 090217
			{
				CElevDlg::g_pElevDlg->GetTextHeight();
				CElevDlg::g_pElevDlg->UpdataEnt();
				continue;
			}

			Entity entRef;
			if (entRef.FilterSelect(_T("\n点取参考标高<退出>: "), RBList(RTDXF0, _T("ATS_ELEVATION"), NULL))==RTNORM) 
			{
				OPENOBJ_BEGIN(entRef, AcDb::kForRead, TDbSymbElevation, pLastElev);
				if (pLastElev) 
				{
					ptLoc = pLastElev->GetLocation();
					ss = pLastElev->GetText();
					jig.m_ptBase = ptLoc;
					jig.m_fBaseElev = _tstof(ss);
					pElev->SetText(ss);
					pElev->SetLocation(ptLoc);
					jig.m_dPointX = Wcs2Ucs(ptLoc).x;
				}
				OPENOBJ_END();
				continue;
			}
		} 
		else
		{
			delete pElev;
			pElev = NULL;
			return NULL;
		}
	}

	// 对实体进行拖动循环
	while(1)
	{
		// sg modify 120608，对话框类和这些全局静态成员移植到ElevDlg.h类中，要求全部使用CElevDlg::g_pElevDlg->UpdataEnt();来更新对象数据
		//pElev->SetBaseLine(g_bHasBase);
		//pElev->SetLeader(g_bHasLeader);
		//pElev->SetFilled(g_bHatch);
		//pElev->SetBaseLine(g_bHasBase);
		//pElev->SetLeader(g_bHasLeader);
		//pElev->SetDote(g_bDote); // sg add 090209，增加圆点样式
		//// sg add 090212，增加文字齐线端、是否规范样式，是否加括号的设置
		//pElev->SetParentheses(g_bParentheses);
		//pElev->SetAtLineSide(g_bElevSideText);
		//pElev->SetStandard(g_bStandard);

		int nRet;
		if (CElevDlg::g_pElevDlg != NULL)
		{
			// sg add 120608，对话框类和这些全局静态成员移植到ElevDlg.h类中，要求全部使用CElevDlg::g_pElevDlg->UpdataEnt();来更新对象数据
			CElevDlg::g_pElevDlg->UpdataEnt();
			CElevDlg::g_pElevDlg->SetGridEnableWrite(TRUE);
			CElevDlg::g_pElevDlg->m_bUpdateText = TRUE;
		}
		acedGetAcadDwgView()->SetFocus();

		jig.SetOperCode(TElevEdJig::kDirection);
		jig.SetPrompt(_T("\n请点取标高方向<退出>:"));
//		jig.SetKeyword(_T("")); // sg modify 090217，增加了从屏幕拾取“字高”功能
//		nRet = jig.DoIt();
//		if (nRet != RTNORM)
		jig.SetKeyword(_T("`"));
		nRet = jig.DoIt(&nIdx);
		if (nRet!=RTNORM && nRet!=RTKWORD)
		{
			delete pElev;
			return NULL;
		}
		else if (nRet == RTKWORD) // sg add 090217
		{
			CElevDlg::g_pElevDlg->GetTextHeight();
			CElevDlg::g_pElevDlg->UpdataEnt();
			continue;
		}

		if (CElevDlg::g_pElevDlg != NULL)
		{
			CElevDlg::g_pElevDlg->m_bUpdateText = FALSE;
			// if (!g_bHightWrite) // sg add 120609，不能直接使用静态变量
			if (!CElevDlg::g_pElevDlg->IsHightWrite())
				CElevDlg::g_pElevDlg->SetGridEnableWrite(FALSE);
		}

		// if (g_bHasBase) // sg add 120609，不能直接使用静态变量
		if (CElevDlg::g_pElevDlg!=NULL && CElevDlg::g_pElevDlg->IsHasBase())
		{
			while (1) // sg modify 090217，增加了从屏幕拾取“字高”功能
			{
				if (CElevDlg::g_pElevDlg != NULL)
					CElevDlg::g_pElevDlg->m_bHatchTou = TRUE; // 此时填充、圆点按钮不可用
				jig.SetOperCode(TElevEdJig::kBaseLine);
				jig.SetPrompt(_T("\n点取基线位置<退出>:"));
// 				jig.SetKeyword(_T(""));
// 				nRet = jig.DoIt();
				jig.SetKeyword(_T("`"));
				nRet = jig.DoIt(&nIdx);
				if (CElevDlg::g_pElevDlg != NULL)
					CElevDlg::g_pElevDlg->m_bHatchTou = FALSE;
// 				if (nRet != RTNORM)
				if (nRet!=RTNORM && nRet!=RTKWORD)
				{
					delete pElev;
					return NULL;
				}
				else if (nRet == RTKWORD) // sg add 090217
				{
					CElevDlg::g_pElevDlg->GetTextHeight();
					CElevDlg::g_pElevDlg->UpdataEnt();
					continue;
				}
				break;
			}
		}

		//if (g_bHasLeader) // sg add 120609，不能直接使用静态变量
		if (CElevDlg::g_pElevDlg!=NULL && CElevDlg::g_pElevDlg->IsHasLeader())
		{
			while (1) // sg modify 090217，增加了从屏幕拾取“字高”功能
			{
				if (CElevDlg::g_pElevDlg != NULL)
					CElevDlg::g_pElevDlg->m_bHatchTou = TRUE; // 此时填充按钮不可用
				jig.SetOperCode(TElevEdJig::kLeader);
				jig.SetPrompt(_T("\n点取引线位置<退出>:"));
//				jig.SetKeyword(_T(""));
//				nRet = jig.DoIt();
				jig.SetKeyword(_T("`"));
				nRet = jig.DoIt(&nIdx);
				if (CElevDlg::g_pElevDlg != NULL)
					CElevDlg::g_pElevDlg->m_bHatchTou = FALSE;
//				if (nRet != RTNORM)
				if (nRet!=RTNORM && nRet!=RTKWORD)
				{
					delete pElev;
					return NULL;
				}
				else if (nRet == RTKWORD) // sg add 090217
				{
					CElevDlg::g_pElevDlg->GetTextHeight();
					CElevDlg::g_pElevDlg->UpdataEnt();
					continue;
				}
				break;
			}
		}
		break;
	}

	//g_nLeaderLen = pElev->GetLeaderLen(); // sg add 120609，不能直接使用静态变量
	//g_nBaseLen = pElev->GetBaseLen();
	if (CElevDlg::g_pElevDlg != NULL)
	{
		CElevDlg::g_pElevDlg->SetLeaderLen(pElev->GetLeaderLen());
		CElevDlg::g_pElevDlg->SetBaseLen(pElev->GetBaseLen());

		CElevDlg::g_pElevDlg->UpdateEntText();
		CElevDlg::g_pElevDlg->UpDateGridToStar();

		// modify by xly on 100915 设置实体是否添加在默认图层
		//idRet = pElev->AddToCSpace(Adesk::kTrue);
		idRet = AddToSpace(Adesk::kTrue, pElev);
	}
	else
		delete pElev;
	return idRet;
}

// Command: 单注标高
void SymbElev1()
{
	DList<AcDbObjectId> lstElevId;
	GetEntFromBlockByDxf(lstElevId, _T("ATS_ELEVATION"));

	AcDbObjectId *pLast = lstElevId.Tail();
	XPoint ptLast;
	double *pLastLoc = NULL;
	double nLastElev = 0.0;
	if (pLast)
	{
		OPENOBJ_BEGIN(*pLast, AcDb::kForRead, TDbSymbElevation, pLastElev);
		if (pLastElev)
		{
			ptLast = pLastElev->GetLocation();
			nLastElev = _tstof(pLastElev->GetText());
			pLastLoc = &ptLast.x;
		}
		OPENOBJ_END();
	}

	XPoint ptLoc;
	while(1)
	{
		int nRetCode;
		INITGET_BEG(0, _T("R"));
		nRetCode = ads_getpoint(pLastLoc? (double *)Wcs2Ucs(pLastLoc) : NULL, 
			_T("\n请点取标高点或 [参考标高(R)]<退出>:"), ptLoc);
		INITGET_END();

		if (nRetCode == RTNORM)
			break;
		else if (nRetCode == RTKWORD)
		{
			Entity entRef;
			if (entRef.FilterSelect(_T("\n点取参考标高<退出>: "), RBList(RTDXF0, _T("ATS_ELEVATION"), NULL))==RTNORM)
			{
				OPENOBJ_BEGIN(entRef, AcDb::kForRead, TDbSymbElevation, pLastElev);
				if (pLastElev)
				{
					ptLast = pLastElev->GetLocation();
					nLastElev = _tstof(pLastElev->GetText());
					pLastLoc = &ptLast.x;
				}
				OPENOBJ_END();
			}
		}
		else
			return;
    }

    ptLoc = Ucs2Wcs(ptLoc);
    const TCHAR *szFormat1 = DocGetPrec2()? _T("%.2f") : _T("%.3f");
    XString sText(szFormat1, nLastElev+_AS_METER(ptLoc.y-ptLast.y)), sText1;

	TDbSymbElevation *pElev = new TDbSymbElevation;
	pElev->SetLocation(ptLoc);
	pElev->SetText(sText);
	pElev->SetFilled(g_bHatch);
	pElev->SetBaseLine(g_bHasBase);
	pElev->SetLeader(g_bHasLeader);
	pElev->SetBaseLen(g_nBaseLen);
	pElev->SetLeaderLen(g_nLeaderLen);
	// sg modify 120106，给“TS_SYMBOL”独立出来一个文字样式
	// pElev->SetTextStyleId(InitTextStyle(TS_DIM));
	pElev->SetTextStyleId(InitTextStyle(TS_SYMBOL));
	pElev->SetTextBaseLen(pElev->GetDefaultTextBaseLen());
	pElev->setLayer(pElev->GetDefaultLayer());
//	pElev->SetTextRotation(Ucs2Wcs(0.0)); // old
	pElev->SetLayoutRotation(Ucs2Wcs(0.0)); // modified by whl
	pElev->SetTextLayerId(InitLayer(LAY_TEXT, TRUE));

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

	// sg add 120608，原来的g_bHasLeader、g_bHasBase变量已经移走，不能直接使用，新增变量专门用于单注标高
	static BOOL s_bHasBase = FALSE;
	static BOOL s_bHasLeader = FALSE;

	const TCHAR *pKeyword = _T("B L");
	TElevEdJig jig(pElev);
	while(1)
	{
		int nIdx = 0;
		//adsout << _T("\n标高设置：基线") << (g_bHasBase? _T("开") : _T("关"))
		//	<< _T("; 引线") << (g_bHasLeader? _T("开") : _T("关"));
		adsout << _T("\n标高设置：基线") << (s_bHasBase? _T("开") : _T("关"))
			<< _T("; 引线") << (s_bHasLeader? _T("开") : _T("关"));
		const TCHAR *pszPrompt = _T("\n请点取标高方向或 [基线(B)/引线(L)]<当前>:");
		jig.SetOperCode(TElevEdJig::kDirection);
		jig.SetPrompt(pszPrompt);
		jig.SetKeyword(pKeyword);
		int nRet = jig.DoIt(&nIdx);
		if (nRet == RTKWORD)
		{
			if (nIdx == 0)
			{
				//g_bHasBase = !g_bHasBase;
				//pElev->SetBaseLine(g_bHasBase);
				s_bHasBase = !s_bHasBase;
				pElev->SetBaseLine(s_bHasBase);
				if (pElev->HasBaseLine())
				{
					jig.SetOperCode(TElevEdJig::kBaseLine);
					jig.SetPrompt(_T("\n点取基线位置<退出>:"));
					jig.SetKeyword(_T(""));
					nRet = jig.DoIt();
				}
				else
					nRet = RTNORM;
			}
			else
			{
				//g_bHasLeader = !g_bHasLeader;
				//pElev->SetLeader(g_bHasLeader);
				s_bHasLeader = !s_bHasLeader;
				pElev->SetLeader(s_bHasLeader);
				if (pElev->HasLeader())
				{
					jig.SetOperCode(TElevEdJig::kLeader);
					jig.SetPrompt(_T("\n点取引线位置<退出>:"));
					jig.SetKeyword(_T(""));
					nRet = jig.DoIt();
				}
				else
					nRet = RTNORM;
			}
		}
		else if (nRet==RTNORM || nRet==RTNONE)
		{
			nRet = RTNORM;
			break;
		}

		if (nRet != RTNORM)
		{
			delete pElev;
			return;
		}
	}

	//g_nLeaderLen = pElev->GetLeaderLen();
	//g_nBaseLen = pElev->GetBaseLen();
	pElev->AddToCSpace(Adesk::kTrue);
}

// modify by zkm
void SymbElev2()
{
	// sg modify 120106，给“TS_SYMBOL”独立出来一个文字样式
	// sg add 090309，首先初始化“_TCH_DIM”文字样式，与其他标注样式一致
	// AcDbObjectId idTextStyle = InitTextStyle(TS_DIM);
	AcDbObjectId idTextStyle = InitTextStyle(TS_SYMBOL);
	if (!idTextStyle)
		return;

	CTemporaryResourceOverride vTemp;
	CMDIFrameWnd* pParent = (CMDIFrameWnd*)acedGetAcadFrame();
	if (CElevDlg::g_pElevDlg != NULL)
	{
		CElevDlg::g_pElevDlg->DestroyWindow();
		CElevDlg::g_pElevDlg = NULL;
	}

	if (!CElevDlg::g_pElevDlg)
		CElevDlg::g_pElevDlg = new CElevDlg(pParent);
	//注释 by lgy 20120111	文字样式必须有记忆功能
	// sg add 090309，标高标注，默认绘制文字样式为“_TCH_DIM”
	//CElevDlg::g_pElevDlg->m_csFontStyle = (const TCHAR*)GetSymbolName(idTextStyle);
	
	CElevDlg::g_pElevDlg->Create(IDD_ELEV, (CWnd*)pParent);
	CElevDlg::g_pElevDlg->ShowWindow(SW_SHOW);

	BOOL bContinue = TRUE;
	acedGetAcadDwgView()->SetFocus();

	TDbSymbElevation *pLastElev = NULL;
	while (CElevDlg::g_pElevDlg!=NULL &&
		   CElevDlg::g_pElevDlg->GetSafeHwnd()!=NULL)
	{
		if (!bContinue)
			break;

		AcDbObjectId idRet = SymbElev();
		if (!idRet)
		{
			bContinue = FALSE;
			break;
		}

		XPoint ptLast;
		double nLastElev;
		OPENOBJ_BEGIN(idRet, AcDb::kForRead, TDbSymbElevation, pLastElev);
		ASSERT(pLastElev);
		ptLast = pLastElev->GetLocation();
		nLastElev = _tstof(pLastElev->GetText());
		OPENOBJ_END();

		if (!g_bContinue)
			break;

		XPoint ptLoc;
		CTemporaryResourceOverride vTemp(acedGetAcadResourceInstance());
		while(1)
		{
			int nIdx = 0;
			ptLoc = Ucs2Wcs(ptLoc);
			nLastElev = nLastElev + _AS_METER(ptLoc.y - ptLast.y); // [12/4/2007 nsh]
			OPENOBJ_BEGIN(idRet, AcDb::kForRead, TDbSymbElevation, pLastElev);
			ASSERT(pLastElev);

			TDbSymbElevation *pNewElev = (TDbSymbElevation *)pLastElev->clone();
			ASSERT(pNewElev);
			XPoint pt = pNewElev->GetLocation();
			CElevDlg::g_pElevDlg->SetEntPoint(pNewElev);

			TElevEdJig jig(pNewElev);
			jig.m_ptBase = pt;
			jig.m_fBaseElev = _tstof(pLastElev->GetText());
			pt = Wcs2Ucs(pt);
			jig.m_dPointX = pt.x;
			jig.SetOperCode(TElevEdJig::kMove);
			jig.SetPrompt(_T("\n下一点或 [第一点(F)]<退出>:"));
//			jig.SetKeyword(_T("F")); // sg modify 090305，解决从标第二个符号起，无法点取字高
			jig.SetKeyword(_T("` F"));
			int nRet = jig.DoIt(&nIdx);
			if (nRet == RTKWORD)
			{
				if (nIdx == 0) // sg add 090305，解决从标第二个符号起，无法点取字高
				{
					CElevDlg::g_pElevDlg->GetTextHeight();
					CElevDlg::g_pElevDlg->UpdataEnt();
					continue;
				}
				delete pNewElev;
				break;
			}
			if (nRet != RTNORM)
			{
				delete pNewElev;
				bContinue = FALSE;
				break;
			}

			pNewElev->SetLayoutRotation(Ucs2Wcs(0.0)); // add by whl
			pNewElev->SetText(XString(_T("%f"), nLastElev));
			if (CElevDlg::g_pElevDlg != NULL)
			{
				CElevDlg::g_pElevDlg->UpdateEntText();
				CElevDlg::g_pElevDlg->UpDateGridToStar(); // sg add 090331
			}

			// modify by xly on 100915 设置实体是否添加在默认图层
			//idRet = pNewElev->AddToCSpace(Adesk::kTrue);
			idRet = AddToSpace(Adesk::kTrue, pNewElev);

			OPENOBJ_END();
			
			ptLast = ptLoc;
			if (!g_bContinue)
			{
				bContinue = FALSE;
				break;
			}
		}
	}

	if (CElevDlg::g_pElevDlg != NULL)
	{
		CElevDlg::g_pElevDlg->DestroyWindow();
		CElevDlg::g_pElevDlg = NULL;
	}
}

void SymbElev3()//总图标高
{
	AcDbObjectId idTextStyle = InitTextStyle(TS_SYMBOL);
	if (!idTextStyle)
		return;

	CTemporaryResourceOverride vTemp;
	CMDIFrameWnd* pParent = (CMDIFrameWnd*)acedGetAcadFrame();
	if (CElevDlg::g_pElevDlg != NULL)
	{
		CElevDlg::g_pElevDlg->DestroyWindow();
		CElevDlg::g_pElevDlg = NULL;
	}

	if (!CElevDlg::g_pElevDlg)
		CElevDlg::g_pElevDlg = new CElevDlg(pParent);
	CElevDlg::g_pElevDlg->SetSitePlanDlg(TRUE);//总图标高
	//注释 by lgy 20120111	文字样式必须有记忆功能
	// sg add 090309，标高标注，默认绘制文字样式为“_TCH_DIM”
	//CElevDlg::g_pElevDlg->m_csFontStyle = (const TCHAR*)GetSymbolName(idTextStyle);

	CElevDlg::g_pElevDlg->Create(IDD_ELEV, (CWnd*)pParent);
	CElevDlg::g_pElevDlg->ShowWindow(SW_SHOW);

	BOOL bContinue = TRUE;
	acedGetAcadDwgView()->SetFocus();

	TDbSymbElevation *pLastElev = NULL;
	while (CElevDlg::g_pElevDlg!=NULL &&
		CElevDlg::g_pElevDlg->GetSafeHwnd()!=NULL)
	{
		if (!bContinue)
			break;

		AcDbObjectId idRet = SymbElev();
		if (!idRet)
		{
			bContinue = FALSE;
			break;
		}

		XPoint ptLast;
		double nLastElev;
		OPENOBJ_BEGIN(idRet, AcDb::kForRead, TDbSymbElevation, pLastElev);
		ASSERT(pLastElev);
		ptLast = pLastElev->GetLocation();
		nLastElev = _tstof(pLastElev->GetText());
		OPENOBJ_END();

		if (!g_bContinue)
			break;

		XPoint ptLoc;
		CTemporaryResourceOverride vTemp(acedGetAcadResourceInstance());
		while(1)
		{
			int nIdx = 0;
			ptLoc = Ucs2Wcs(ptLoc);
			nLastElev = nLastElev + _AS_METER(ptLoc.y - ptLast.y); // [12/4/2007 nsh]
			OPENOBJ_BEGIN(idRet, AcDb::kForRead, TDbSymbElevation, pLastElev);
			ASSERT(pLastElev);

			TDbSymbElevation *pNewElev = (TDbSymbElevation *)pLastElev->clone();
			ASSERT(pNewElev);
			XPoint pt = pNewElev->GetLocation();
			CElevDlg::g_pElevDlg->SetEntPoint(pNewElev);

			TElevEdJig jig(pNewElev);
			jig.m_ptBase = pt;
			jig.m_fBaseElev = _tstof(pLastElev->GetText());
			pt = Wcs2Ucs(pt);
			jig.m_dPointX = pt.x;
			jig.SetOperCode(TElevEdJig::kMove);
			jig.SetPrompt(_T("\n下一点或 [第一点(F)]<退出>:"));
			//			jig.SetKeyword(_T("F")); // sg modify 090305，解决从标第二个符号起，无法点取字高
			jig.SetKeyword(_T("` F"));
			int nRet = jig.DoIt(&nIdx);
			if (nRet == RTKWORD)
			{
				if (nIdx == 0) // sg add 090305，解决从标第二个符号起，无法点取字高
				{
					CElevDlg::g_pElevDlg->GetTextHeight();
					CElevDlg::g_pElevDlg->UpdataEnt();
					continue;
				}
				delete pNewElev;
				break;
			}
			if (nRet != RTNORM)
			{
				delete pNewElev;
				bContinue = FALSE;
				break;
			}

			pNewElev->SetLayoutRotation(Ucs2Wcs(0.0)); // add by whl
			pNewElev->SetText(XString(_T("%f"), nLastElev));
			if (CElevDlg::g_pElevDlg != NULL)
			{
				CElevDlg::g_pElevDlg->UpdateEntText();
				CElevDlg::g_pElevDlg->UpDateGridToStar(); // sg add 090331
			}

			// modify by xly on 100915 设置实体是否添加在默认图层
			//idRet = pNewElev->AddToCSpace(Adesk::kTrue);
			idRet = AddToSpace(Adesk::kTrue, pNewElev);

			OPENOBJ_END();

			ptLast = ptLoc;
			if (!g_bContinue)
			{
				bContinue = FALSE;
				break;
			}
		}
	}

	if (CElevDlg::g_pElevDlg != NULL)
	{
		CElevDlg::g_pElevDlg->DestroyWindow();
		CElevDlg::g_pElevDlg = NULL;
	}
};

bool UpdateText(TDbSymbElevation* pElev, double dRefElev, TADSGePoint3d ptRefElev, CString& sText);
// add by cwk on 060530
void CheckElev()
{
	PickSet ss(SS_FREE), ssError(SS_FREE);
	RBList mask(RTDXF0, _T("ATS_ELEVATION"), NULL);	
	
	Entity Ent;
	BOOL bRefEnt=FALSE;
	Adesk::UInt16 oldColor=0;
	XPoint ptPick;
	int nRet=RTNORM;
	XString sKeyword;
	INITGET_BEG(0, _T("T"));
	nRet = SelectEntity(_T("\n选择参考标高或 [参考当前用户坐标系(T)]<退出>"),Ent,ptPick,mask);
	INITGET_END();

	XPoint ptRefElev;
	double nRefElev;

	if (nRet == RTNORM) 
	{
		OPENOBJ_BEGIN(Ent, AcDb::kForRead, TDbSymbElevation, pRefElev);
		ASSERT(pRefElev);
		ptRefElev = Wcs2Ucs(pRefElev->GetLocation());
		nRefElev=_tstof(pRefElev->GetText());
		OPENOBJ_END();
		ss-=Ent;//add by whl
		
		OPENOBJ_BEGIN(Ent,AcDb::kForWrite,AcDbEntity,pEnt)
		if(pEnt!=NULL)
		{
			bRefEnt=TRUE;
			oldColor=pEnt->colorIndex();
			pEnt->setColorIndex(2);
		}
		OPENOBJ_END()
	}
	else if(nRet == RTKWORD)
	{
		ptRefElev.x = 0.0;
		ptRefElev.y = 0.0;
		ptRefElev.z = 0.0;
		nRefElev = 0.0;
	}
	else
		return;

	if(SelectEntities(_T("\n选择待检查的标高标注:"), ss, mask) != RTNORM)
	{
		if(bRefEnt)
		{
			OPENOBJ_BEGIN(Ent,AcDb::kForWrite,AcDbEntity,pEnt)
			if(pEnt!=NULL)
				pEnt->setColorIndex(oldColor);
			OPENOBJ_END()
		}
		return;
	}
	

	long i;
	int iRight = 0;
	for(i = 0L;i < ss.Length();i++)
	{
		XPoint ptElev;
		double nElev;
		Entity TempEnt = ss[i];

		OPENOBJ_BEGIN(TempEnt, AcDb::kForRead, TDbSymbElevation, pElev);
		ASSERT(pElev);
		ptElev = Wcs2Ucs(pElev->GetLocation());
		nElev=_tstof(pElev->GetText());
		OPENOBJ_END();

		// sg modify 091112，算法错误，若参考标高为负值，则判断结果错误
/*
		double temp = _AS_METER(fabs(ptRefElev.y - ptElev.y));//  [12/4/2007 nsh]
		double tempElev = fabs(nRefElev - nElev);
		if (fabs(temp - tempElev) < 1e-3)
*/
		double dTemp = _AS_METER(ptRefElev.y - ptElev.y);	// 坐标差
		double dTempElev = nRefElev - dTemp;				// 参照参考坐标后，应该标注的标高
		if (fabs(dTempElev - nElev) < 1E-3)					// 参考标高与真实标高比较
		{
			iRight ++;
		}
		else
		{
			ssError += TempEnt;
		}
	}
	
	int nError = ssError.Length();
	if (nError == 0)
	{
		adsout << _T("\n选中的标高") << ss.Length() << _T("个，全部正确!");
		if (bRefEnt)
		{
			OPENOBJ_BEGIN(Ent,AcDb::kForWrite,AcDbEntity,pEnt)
			if (pEnt != NULL)
				pEnt->setColorIndex(oldColor);
			OPENOBJ_END()
		}
		return;
	}
	adsout << _T("\n选中的标高") << ss.Length() << _T("个，其中") << nError << _T("个有错!");

	long nCurIndex=0L;
	while(1) 
	{
		if(ssError.Length() == 0)
		{
			if(bRefEnt)
			{
				OPENOBJ_BEGIN(Ent,AcDb::kForWrite,AcDbEntity,pEnt)
				if(pEnt!=NULL)
					pEnt->setColorIndex(oldColor);
				OPENOBJ_END()
			}
			return;
		}
		else if(nCurIndex<0||nCurIndex>=ssError.Length())
		{
			nCurIndex = 0;
		}
		Entity ent = ssError[nCurIndex];
		XPoint ptLow, ptUp;	
		if (ent.GetExtend(ptLow, ptUp) == RTNORM)
		{//临时生成一个红色小框

			AssureInCurrentView(ptLow, ptUp);
			XScreenDc dc(1,1);
			XRectAngle rec(ptLow, ptUp);
			XPoly2D poly2d, polyOffset;
			rec.AsPoly2D(poly2d);
			poly2d.Offset((ptUp.x-ptLow.x)/10.0, polyOffset);
			polyOffset.TransUCS(Groups(0), Groups(1));
			dc << polyOffset;
		}

		OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbSymbElevation, pElev);
		if(pElev) 
		{
			XPoint ptElev;
			ptElev = Wcs2Ucs(pElev->GetLocation());
			
			double temp = nRefElev + _AS_METER(ptElev.y - ptRefElev.y);//  [12/4/2007 nsh]
			//modify by zyc 120712 _T(")或 [纠正标高(C)/下一个(F)/退出(X)]<全部纠正>:");
			adsout << _T("\n第") << nError << _T("/") << nCurIndex + 1 << _T("个错误的标注，正确标注(") 
				<< XString(_T("%.3f"), temp)
				<< _T(")或 [全部纠正(A)/纠正标高(C)/纠正位置(D)/退出(X)]<下一个>:");
		}
		OPENOBJ_END();
		     
		int nRet=RTNORM;
		XString sKeyword;
		// modify by zyc 120712 增加纠正位置关键字D
		//INITGET_BEG(0, _T("C F X"));
		INITGET_BEG(0, _T("A C D X"));
		nRet=ads_getkword(_T(""), sKeyword);
		INITGET_END();
		ads_redraw(NULL, 1);
		if(nRet == RTCAN)
			break;

		// modify by zyc 120712 默认操作改为下一个
		if(nRet == RTNONE) 
		{
			nCurIndex++;
		} 
		else if (nRet == RTNORM) 
		{
			if (sKeyword[0]==_T('C')) 
			{
				OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbSymbElevation, pElev);
				if (pElev) 
				{
					// modify by zyc 20120712 解决 标高检查有文字说明时和多层标高时bug
					//XPoint ptElev;
					//ptElev = Wcs2Ucs(pElev->GetLocation());
					//double temp = nRefElev + _AS_METER(ptElev.y - ptRefElev.y);//  [12/4/2007 nsh]
					CString sText;
					UpdateText(pElev, nRefElev, ptRefElev, sText);
					if(pElev->upgradeOpen()==Acad::eOk)
					{
						//pElev->SetText(XString(_T("%.3f"), temp));
						pElev->SetText(sText);
					}
				}
				OPENOBJ_END();
				ssError -= ent;
				nError--;
				nCurIndex++;
			} 
			else if (sKeyword[0]==_T('A'))
			{
				long idx = 0L;
				for( ; idx <= ssError.Length(); idx++) 
				{
					Entity ent = ssError[idx];
					OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbSymbElevation, pElev);
					if(pElev) 
					{
						// modify by zyc 20120712 解决 检查带有说明文字的标高对象时，纠正后的标高丢失说明文字
						//                            不能纠正多层标高，对多层标高执行操作后，多层标高变成了单层标高
						//XPoint ptElev;
						//ptElev = Wcs2Ucs(pElev->GetLocation());
						//double temp = nRefElev + _AS_METER(ptElev.y - ptRefElev.y);//  [12/4/2007 nsh]
						CString sText;
						UpdateText(pElev, nRefElev, ptRefElev, sText);
						if(pElev->upgradeOpen()==Acad::eOk)
						{
							//pElev->SetText(XString(_T("%.3f"), temp));
							pElev->SetText(sText);
						}
					}
					OPENOBJ_END();
				}
				break;
			}
			// add by zyc 120712 增加纠正位置功能
			else if (sKeyword[0] == _T('D'))
			{
				long idx = 0L;
				for( ; idx <= ssError.Length(); idx++) 
				{
					Entity ent = ssError[idx];
					OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbSymbElevation, pElev);
					if(pElev) 
					{
						// 获取文本中的标高数据
						double dElev = _tstof(pElev->GetText());

						// 获取标高位置
						TADSGePoint3d ptLocation = pElev->GetLocation();
						ptLocation = Wcs2Ucs(ptLocation);

						// 更新标高位置
						ptLocation.y = _AS_SYS_UNIT((dElev - nRefElev + _AS_METER(ptRefElev.y)) * 1000.0f);
						ptLocation = Ucs2Wcs(ptLocation);

						// 设置标高位置
						pElev->SetLocation(ptLocation);
					}
					OPENOBJ_END();
				}
				break;
			}
			else 
			{
				break;
			}
		}
	}

	if (bRefEnt)
	{
		OPENOBJ_BEGIN(Ent, AcDb::kForWrite, AcDbEntity, pEnt)
		if (pEnt != NULL)
			pEnt->setColorIndex(oldColor);
		OPENOBJ_END()
	}
}

// add by zyc 20120712 标高检查更新文本
struct SData
{
	CString sElev;
	CString sExplain;
};
bool UpdateText(TDbSymbElevation* pElev, double dRefElev, TADSGePoint3d ptRefElev, CString& sText)
{
	// 获取标高文本
	TCHAR* lpszText = const_cast<TCHAR*>(pElev->GetText());

	// 分析提取文本
	CArray<SData, SData&> arParse;
	CString sElev, sExplain;
	TCHAR* pPos = lpszText;
	bool bIsElev = true;   // 是标高数据还是说明
	while (1)
	{
		if (*pPos == '&')
		{
			bIsElev = false;
			pPos++;
			continue;
		}
		if (*pPos == '$' || *pPos == '\0')
		{
			SData data;
			data.sElev    = sElev;
			data.sExplain = sExplain;
			arParse.Add(data);
			if (*pPos == '\0')
			{
				break;
			}
			sElev.Empty();
			sExplain.Empty();
			bIsElev = true;
			pPos++;
			continue;
		}

		if (bIsElev)
		{
			sElev += *pPos;
		}
		else
		{
			sExplain += *pPos;
		}
		pPos++;
	}

	// 获取层高
	double dHeight = 0; // 层高值
	if (arParse.GetSize() > 1)
	{
		// 如果是多层标高，获取层之间的高度
		double dElev1, dElev2;
		// 第一个层高
		dElev1 = _tstof(arParse[1].sElev);
		// 第二个层高
		dElev2 = _tstof(arParse[0].sElev);
		dHeight = dElev1 - dElev2;
	}

	// 更新标高数据
	int i = 0;
	for (i=0; i<arParse.GetSize(); i++)
	{
		if (i == 0)
		{
			TADSGePoint3d ptElev = Wcs2Ucs(pElev->GetLocation());
			double temp = dRefElev + _AS_METER(ptElev.y - ptRefElev.y);
			sElev.Format(_T("%.3f"), temp);
			arParse[i].sElev = sElev;
		}
		else
		{
			double temp = _tstof(arParse[i-1].sElev) + dHeight;
			sElev.Format(_T("%.3f"), temp);
			arParse[i].sElev = sElev;
		}
	}

	// 重新生成字符串
	for (i=0; i<arParse.GetSize(); i++)
	{
		sText += arParse[i].sElev;
		if (!arParse[i].sExplain.IsEmpty())
		{
			sText += '&';
			sText += arParse[i].sExplain;
		}
		if (i != arParse.GetSize()-1)
		{
			sText += '$';
		}
	}

	return true;
}

// Command：绘制折断线，6.5的命令
void RuptureLine()
{
	static bool bExt = true;
	XPoint pt1, pt2;
	if (ads_getpoint(NULL, _T("\n点取折断线起点<退出>: "), pt1) != RTNORM)
        return;

	static int nRupNum = 1;
	int nRetCode;
LAB_REPEAT:
	adsout << _T("\n点取折断线终点或 [折断数目,当前=") 
		<< nRupNum << _T("(N)/自动外延,当前=") << (bExt? _T("开") :  _T("关") ) <<_T("(O)]<退出>: ");
	INITGET_BEG(0, _T("N O"))
	nRetCode = ads_getpoint(pt1, _T(""), pt2);
	INITGET_END();
	if (nRetCode == RTKWORD)
	{
		XString sKeyInp;
		ads_getinput(sKeyInp);
		if (sKeyInp[0] == _T('N'))
		{
			adsout << _T("\n折断数目<") << nRupNum << _T(">:");
			ads_initget(RSG_NOZERO|RSG_NONEG, NULL);
			if (ads_getint(_T(""), &nRupNum) == RTCAN)
				return;
		}
		else
		{
			bExt = !bExt;
		}
		goto LAB_REPEAT;
	}
	else if (nRetCode == RTNORM)
	{
		TDbSymbRupture *pRupture = new TDbSymbRupture;
		pt1 = Ucs2Wcs(pt1);
		pt2 = Ucs2Wcs(pt2);
		XPoint ptA = pt1,
			ptB = pt2;
		if (bExt)
		{
			// sg add 090512，设置折断线两端伸出连接区间的距离
//			ads_polar(pt1, ads_angle(pt2, pt1), 3.0*DocGetPScale(), ptA);
//			ads_polar(pt2, ads_angle(pt1, pt2), 3.0*DocGetPScale(), ptB);
			double dDist = pt1.Distance(pt2);
			if (dDist > g_dRuptureLenLimit - _DIST_SNAP) // 大于界限值时
			{
				ads_polar(pt1, ads_angle(pt2, pt1), g_dMoreRuptureLimit*DocGetPScale(), ptA);
				ads_polar(pt2, ads_angle(pt1, pt2), g_dMoreRuptureLimit*DocGetPScale(), ptB);
			}
			else // 小于界限值时
			{
				ads_polar(pt1, ads_angle(pt2, pt1), g_dLessRuptureLimit*DocGetPScale(), ptA);
				ads_polar(pt2, ads_angle(pt1, pt2), g_dLessRuptureLimit*DocGetPScale(), ptB);
			}
		}
		pRupture->SetStartPoint(ptA);
		pRupture->SetEndPoint(ptB);

		pRupture->SetRuptureNum(nRupNum);
		pRupture->AddToCSpace(Adesk::kTrue);
    }
}

extern TARCH_IMPEXP BOOL g_bABCoord; //AB标注还是XY标注
extern TARCH_IMPEXP int g_nCoordPrec;
extern TARCH_IMPEXP int g_nCoordArrowStyle;


//add by lgy 20120331	9.0中添加批量标注，标注中需要检查文字碰撞，如果碰撞按一定方法避让
//避让中返回参数引线长度和角度
bool BlenchText(AcDbObjectId &id)
{
	//先将坐标标注炸开取得文字的外包装框
	XPoint ptMin, ptMax;
	OPENOBJ_BEGIN(id, AcDb::kForRead, AcDbEntity, pEnt);
	if (!pEnt)
	{
		return false;
	}
	AcDbVoidPtrArray dbArray;
	pEnt->explode(dbArray);

	int nCount=dbArray.length();
	for (int n=0; n<nCount; n++)
	{
		TDbText *pEnt=TDbText::cast((AcDbEntity *)dbArray[n]);
		if (!pEnt)
		{
			continue;
		}

		//获得坐标标注的上下文字外包框，然后合并成一个大的外包装框
		XPoint ptMinTemp, ptMaxTemp;
		pEnt->GetExtents2d(ptMinTemp, ptMaxTemp);
		if (ptMaxTemp.y > ptMax.y)
		{
			ptMax = ptMaxTemp;
		}
		if (ptMinTemp.y < ptMin.y || ptMin == XPoint(0,0,0))
		{
			ptMin = ptMinTemp;
		}
	}
	OPENOBJ_END();

	//获得外包框内的实体
	RBList mask(RTDXF0, _T("ATS_COORD"), NULL);
	PickSet entSet(SS_FREE);

	if (GetSafeSelection(entSet, 1, ptMin, ptMax, _T("ATS_COORD")) != Acad::eOk)
	{
		return true;
	}
	entSet -= id;		//去掉当前实体

	XPoly2D poly;		//文字避让的外包装框
	poly.AppendNode(ptMax);
	poly.AppendNode(XPoint(ptMin.x, ptMax.y, 0));
	poly.AppendNode(ptMin);
	poly.AppendNode(XPoint(ptMax.x, ptMin.y, 0));
	poly.SetClosed();

	//循环判断是否有文字位置重合或者需要避让
	for (long j = 0; j < entSet.Length(); j++)
	{
		Entity ent = entSet[j];
		OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbEntity, pEnt);
		if (!pEnt)
		{
			return true;
		}
		AcDbVoidPtrArray dbArray;
		pEnt->explode(dbArray);

		int nCount=dbArray.length();
		for (int n=0; n<nCount; n++)
		{
			TDbText *pEnt=TDbText::cast((AcDbEntity *)dbArray[n]);
			if (!pEnt)
			{
				continue;
			}

			//获得重合文字的外包装框
			pEnt->GetExtents2d(ptMin, ptMax);
			XPoly2D polyText;
			polyText.AppendNode(ptMax);
			polyText.AppendNode(XPoint(ptMin.x, ptMax.y, 0));
			polyText.AppendNode(ptMin);
			polyText.AppendNode(XPoint(ptMax.x, ptMin.y, 0));
			polyText.SetClosed();

			//判断是否相交，如果相交说明还需要避让
			DList<XPoly2D> lstPoly;
			TchSubExport::Union(polyText, poly, lstPoly);
			if (lstPoly.Length() != 0)
			{
				return false;
			}
		}
		OPENOBJ_END();
	}
	return true;
}

//add by lgy 20120331	为了判断标注的位置是否正确
bool ResetCoordDim(AcDbObjectId &id)
{
	while(TRUE)
	{
		if (BlenchText(id))
		{
			return true;
		}

		OPENOBJ_BEGIN(id, AcDb::kForWrite, TDbSymbCoord, pCoord);
		if (!pCoord)
		{
			return true;
		}
		//角度增加pi/4
		double dAng = ads_angle(pCoord->GetLocation(), pCoord->GetTurnPoint());
		XPoint ptValue;
		ptValue = pCoord->GetLocation();
		double dLengh = ptValue.Distance2d(pCoord->GetTurnPoint());
		dAng += PI/4;
		if (fabs(dAng - PI/4) < PI/50)	//避让角度还没有转一圈
		{
			dLengh += 6*DocGetPScale();
		}
		ads_polar(ptValue, dAng, dLengh, ptValue);
		Adesk::UInt8 nQuent = 1;
		if (dAng >= PI/2 && dAng < PI)
		{
			nQuent = 1;
		}
		else if (dAng >= PI && dAng < 3*PI/2)
		{
			nQuent = 2;
		}
		else if (dAng >= 3*PI/2 && 2*PI >= dAng)
		{
			nQuent = 3;
		}
		pCoord->SetQuadrant(nQuent);
		pCoord->SetTurnPoint(ptValue);
		OPENOBJ_END();
	}	
}

// add by lgy 20120330，9.0要求添加批量标注
// 根据返回值确定结束本函数后，改如何处理
// mat和bUcsPoint的参数，主要用于接收“设置”传来的结果，也许有人先设置，再批量标注
int BatchDim(CBatchDimDlg &dlg, ads_matrix mat)
{
	BOOL bIsWcs = IsWCS();

	while(TRUE)
	{
		PickSet entSet;
		RBList maskList(RTDXF0, _T("LINE,ARC,CIRCLE,LWPOLYLINE,POINT,ATS_ELEVATION"), NULL);
		TCHAR szKey[132] = _T("SQ");
		TCHAR key;

		int nRet = SelectEnts(_T("\n请选择需标注坐标的对象或 [设置(S)\\单点标注(Q)]<退出>:"), _T("\n请选择需标注坐标的对象: "),
			maskList, entSet, szKey, key);
		if (nRet == RTKWORD)
		{
			if (key == _T('S') || key == _T('s')) // 设置
			{
				double nNorthAngle = PI/2;
				PickSet ssNorth(SS_FREE);
				if (ssNorth.Get(_T("X"), NULL, NULL, RBList(RTDXF0, _T("ATS_NORTHTHUMB"), 67, 0, NULL)) == RTNORM) // 模型空间指北针
				{
					Entity ent0 = ssNorth[0L];
					ent0.GetData(50, &nNorthAngle);
				}

				CCoordDlg dlg(IDD_COORD);
				dlg.m_fAngle = nNorthAngle*180/PI;
				{
					CTemporaryResourceOverride vTemp;
					if (dlg.DoModal() != IDOK)
					{
						continue;
					}
				}
				nNorthAngle = dlg.m_fAngle*PI/180;

				XPoint().GetRotationMatrix(-nNorthAngle+PI/2.0, mat);

				if (CCoordDlg::s_iUnitType == 0)
				{
					adsout<<_T("\n当前绘图单位:mm;标注单位:M;");
				}
				else
				{
					adsout<<_T("\n当前绘图单位:M;标注单位:M;");
				}

				if (CCoordDlg::IsWcsPoint())
				{
					adsout<<_T("以世界坐标取值;北向角度")<<dlg.m_fAngle<<_T("度");
				}
				else if (CCoordDlg::IsUcsPoint())
				{
					adsout<<_T("以用户坐标取值");
				}
				else if (CCoordDlg::IsRedLinePoint())
				{
					adsout<<_T("以场地坐标取值");
				}
			}
			else
			{
				return nRet; // 返回调用处，重新循环
			}
		}
		else if (nRet != RTNORM)
		{
			if (dlg.m_bPost) // 拾取实体
			{
				dlg.SelectEntInDraw();
				dlg.OnClickSelectInDraw();
				continue;
			}

			return nRet; // 返回调用处，结束命令
		}

		entSet.Redraw(4); // UnHighLight

		// 分类存储，减少后续循环和判断的次数
		PickSet plineSet(SS_FREE), lineSet(SS_FREE), arcSet(SS_FREE), circleSet(SS_FREE), ptSet(SS_FREE), elevSet(SS_FREE);
		{
			if (dlg.GetIsAppointLayer()) // 若勾选了图层过滤，只保留指定图层上的对象
			{
				CString strLayerName = dlg.GetStrLayerName();
				strLayerName.Replace(_T("&"), _T(","));
				strLayerName.TrimLeft(_T(","));
				strLayerName.TrimRight(_T(","));

				entSet.BaseFilter(RBList(RTDXF0, _T("*"), 8, (const TCHAR*)strLayerName, NULL));
			}

			plineSet += entSet;		// PLINE
			plineSet.BaseFilter(RBList(RTDXF0, _T("LWPOLYLINE"), NULL));
			entSet -= plineSet;

			lineSet += entSet;		// LINE
			lineSet.BaseFilter(RBList(RTDXF0, _T("LINE"), NULL));
			entSet -= lineSet;

			circleSet += entSet;	// CIRCLE
			circleSet.BaseFilter(RBList(RTDXF0, _T("CIRCLE"), NULL));
			entSet -= circleSet;

			arcSet += entSet;		// ARC
			arcSet.BaseFilter(RBList(RTDXF0, _T("ARC"), NULL));
			entSet -= arcSet;

			ptSet += entSet;		// POINT
			ptSet.BaseFilter(RBList(RTDXF0, _T("POINT"), NULL));
			entSet -= ptSet;

			elevSet = entSet;		// 标高标注
		}

		XPointList lstPts;
		DList<XCurveSegment> listCvSegment;
		{
			if (dlg.GetIsPolyVertex()) // 获得所有多段线的端点
			{
				long lLength = plineSet.Length();
				for (long l=0; l<lLength; l++)
				{
					XPoly2D poly(plineSet[l]);
					int nPtNums = poly.Length();
					for (int k=0; k<nPtNums; k++)
						lstPts.NewAppend(poly.GetPointListAt(k)->AsAcGePoint3d());
				}
			}

			if (dlg.GetIsPoint()) // 获得所有点
			{
				long lLength = ptSet.Length();
				for (long l=0; l<lLength; l++)
				{
					OPENOBJ_BEGIN(ptSet[l], AcDb::kForRead, AcDbPoint, pPoint);
					if (pPoint != NULL)
					{
						lstPts.NewAppend(pPoint->position());
					}
					OPENOBJ_END();
				}
			}

			if (dlg.GetIsLineVertex()) // 获得所有直线、弧线端点
			{
				long lLength = lineSet.Length(),
					l(0);
				for (l=0; l<lLength; l++)
				{
					OPENOBJ_BEGIN(lineSet[l], AcDb::kForRead, AcDbLine, pLine);
					if (pLine != NULL)
					{
						lstPts.NewAppend(pLine->startPoint());
						lstPts.NewAppend(pLine->endPoint());
						listCvSegment.Append(new XCurveSegment(pLine->startPoint(), pLine->endPoint(), 0));
					}
					OPENOBJ_END();
				}

				lLength = arcSet.Length();
				for (l=0; l<lLength; l++)
				{
					XCurveSegment arc(arcSet[l]);
					lstPts.NewAppend(arc.StartPoint());
					lstPts.NewAppend(arc.EndPoint());
					listCvSegment.Append(new XCurveSegment(arc));
				}
			}

			if (dlg.GetIsElevLoc()) // 获得所有标高符号的插入点
			{
				long lLength = elevSet.Length();
				for (long l=0; l<lLength; l++)
				{
					OPENOBJ_BEGIN(elevSet[l], AcDb::kForRead, TDbSymbElevation, pElevation);
					if (pElevation != NULL)
					{
						lstPts.NewAppend(pElevation->GetLocation());
					}
					OPENOBJ_END();
				}
			}

			if (dlg.GetIsCirclePt()) // 获得所有圆心点
			{
				long lLength = circleSet.Length(),
					l(0);
				for (l=0; l<lLength; l++)
				{
					OPENOBJ_BEGIN(circleSet[l], AcDb::kForRead, AcDbCircle, pCircle);
					if (pCircle != NULL)
					{
						lstPts.NewAppend(pCircle->center()); // 圆
					}
					OPENOBJ_END();
				}

				lLength = arcSet.Length();
				for (l=0; l<lLength; l++)
				{
					OPENOBJ_BEGIN(arcSet[l], AcDb::kForRead, AcDbArc, pArc);
					if (pArc != NULL)
					{
						lstPts.NewAppend(pArc->center()); // 弧线
					}
					OPENOBJ_END();
				}

				lLength = plineSet.Length();
				for (l=0; l<lLength; l++)
				{
					XPoly2D poly(plineSet[l]);

					int nSegNums = poly.TotalSegments();
					for (int k=0; k<nSegNums; k++)
					{
						XCurveSegment seg;
						poly.Nth(k, seg);
						listCvSegment.Append(new XCurveSegment(seg));

						if (seg.Is(CURVE_ARC))
						{
							XArc arc = seg.GetArc();
							lstPts.NewAppend(arc.GetCenterPt()); // 多段线中的弧段
						}
					}
				}
			}

			if (dlg.GetIsIntersectPt()) // 标注交点
			{
				if (!dlg.GetIsLineVertex()) // 不需要标注直线、弧线端点的时候
				{
					long lLength = lineSet.Length(),
						l(0);
					for (l=0; l<lLength; l++)
					{
						OPENOBJ_BEGIN(lineSet[l], AcDb::kForRead, AcDbLine, pLine);
						if (pLine != NULL)
						{
							listCvSegment.Append(new XCurveSegment(pLine->startPoint(), pLine->endPoint(), 0));
						}
						OPENOBJ_END();
					}

					lLength = arcSet.Length();
					for (l=0; l<lLength; l++)
					{
						XCurveSegment arc(arcSet[l]);
						listCvSegment.Append(new XCurveSegment(arc));
					}
				}

				long lLength = circleSet.Length(),
					l(0);
				for (l=0; l<lLength; l++)
				{
					XCurveSegment circle(circleSet[l]);
					listCvSegment.Append(new XCurveSegment(circle));
				}

				if (!dlg.GetIsCirclePt()) // 不需要标注圆心的时候
				{
					lLength = plineSet.Length();
					for (l=0; l<lLength; l++)
					{
						XPoly2D poly(plineSet[l]);

						int nSegNums = poly.TotalSegments();
						for (int k=0; k<nSegNums; k++)
						{
							XCurveSegment seg;
							poly.Nth(k, seg);
							listCvSegment.Append(new XCurveSegment(seg));
						}
					}
				}

				int nSegments = listCvSegment.Length();
				for (int m=0; m<nSegments; m++)
				{
					XCurveSegment segThis = *listCvSegment[m];
					for (int n = m+1; n < listCvSegment.Length(); n++)
					{
						XCurveSegment segOther = *listCvSegment[n];

						XPoint ptInter[2];
						int nIntNum = segThis.Intersection(segOther, ptInter[0], ptInter[1]);
						switch (nIntNum)
						{
						case 1:
							lstPts.NewAppend(ptInter[0]);
							break;
						case 2:
							lstPts.NewAppend(ptInter[0]);
							lstPts.NewAppend(ptInter[1]);
							break;
						case 0:
							break;
						}
					}
				}
			}
		}

		{
			int nPts = lstPts.Length();
			for (int j=0; j<nPts; j++)
			{
				XPoint ptDim = *lstPts[j],
					ptValue = ptDim;

				if (CCoordDlg::IsUcsPoint())
					ptValue = Wcs2Ucs(ptValue);
				else if (CCoordDlg::IsWcsPoint())
					ptValue.TransformBy(mat);
				else if (CCoordDlg::IsRedLinePoint())
					ptValue = TranslatePtFromRedline(ptValue);

				double dX(0), dY(0);
				if (CCoordDlg::s_iUnitType == 0) // mm-M
				{
					dX = _AS_METER(ptValue.y);
					dY = _AS_METER(ptValue.x);
				}
				else // M-M
				{
					dX = ptValue.y;
					dY = ptValue.x;
				}

				if (fabs(dX) < 1E-6)
					dX = 0;
				if (fabs(dY) < 1E-6)
					dY = 0;

				TDbSymbCoord *pCoord = new TDbSymbCoord;
				pCoord->SetTextStyleId(InitTextStyle(TS_SYMBOL));
				pCoord->SetTextLayerId(InitLayer(LAY_TEXT, TRUE));
				pCoord->SetLayoutRotation(Ucs2Wcs(0.0));
				pCoord->SetAB(g_bABCoord);
				pCoord->SetStyle((TDbSymbMultiLeader::TArrowStyle)g_nCoordArrowStyle);
				pCoord->SetPrecNum(g_nCoordPrec);
				if (CCoordDlg::IsUcsPoint())
					pCoord->setColorIndex(4);
				else if (CCoordDlg::IsWcsPoint())
					pCoord->setColorIndex(3);
				else if (CCoordDlg::IsRedLinePoint())
					pCoord->setColorIndex(2);

				pCoord->SetLocation(ptDim);
				pCoord->SetValue(XPoint(dY, dX));

				ads_polar(ptDim, Ucs2Wcs(0.0)+PI/4, 6*DocGetPScale(), ptDim);
				pCoord->SetTurnPoint(ptDim);

				AddToSpace(Adesk::kTrue, pCoord);
			}
		}
	}
	return RTNORM;
}

// Command: 坐标标注
//----------------------------------------------------------------------------------------------------------------------------------
void SymbCoord()
{
	CCoordDlg::s_iUnitType = DocGetMeterUnitDraw();

	double nNorthAngle = PI/2; // 默认为90度
	PickSet ssNorth(SS_FREE);
	if (ssNorth.Get(_T("X"), NULL, NULL, RBList(RTDXF0, _T("ATS_NORTHTHUMB"), 67, 0, NULL))==RTNORM) // 模型空间指北针
	{
		Entity ent0 = ssNorth[0L];
		ent0.GetData(50, &nNorthAngle);
	}

	XPoint ptLoc, ptLastUcs;
	ads_matrix mat;
	XPoint().GetRotationMatrix(-nNorthAngle+PI/2.0, mat);

	if (CCoordDlg::s_iUnitType == 0)
		adsout<<_T("\n当前绘图单位:mm,标注单位:M;");
	else
		adsout<<_T("\n当前绘图单位:M,标注单位:M;");

	if (CCoordDlg::IsWcsPoint())
		adsout<<_T("以世界坐标取值;北向角度")<<Angle2Str(nNorthAngle*180/PI)<<_T("度");
	else if (CCoordDlg::IsUcsPoint())
		adsout<<_T("以用户坐标取值");
	else if (CCoordDlg::IsRedLinePoint())
		adsout<<_T("以场地坐标取值");

	bool bFirst = true;
	while(true)
	{
		if (bFirst)
		{
			if (CCoordDlg::m_bFixAngle)
			{
				dAngle = CCoordDlg::m_strAngle;
			}

			int nRet;
			//modify by lgy 20120330	9.0要求特征点批量标注功能
			//INITGET_BEG(0,_T("S"));
			//nRet=ads_getpoint(NULL, _T("\n请点取标注点或 [设置(S)]<退出>:"),ptLoc);
			//INITGET_END();
			INITGET_BEG(0, _T("S Q"));
			nRet = ads_getpoint(NULL, _T("\n请点取标注点或 [设置(S)\\批量标注(Q)]<退出>:"),ptLoc);
			INITGET_END();
			if (nRet == RTKWORD)
			{
				// modify by lgy 20120330，增加条件判断，是应为9.0中增加了批量标注
				TCHAR szKey[132];
				if (acedGetInput(szKey) != RTNORM)
				{
					continue;
				}

				if (szKey[0]==_T('S') || szKey[0]==_T('s')) // 设置
				{
					CCoordDlg dlg(IDD_COORD);
					dlg.m_fAngle = nNorthAngle*180/PI;
					//add tyj 20160901:添加精度设置，防止指北针设置角度与坐标标注显示的北向角度不一致的问题
					int luprec, auprec;
					VERIFY(xg_getvar(_T("LUPREC"), &luprec) == RTNORM &&
						xg_getvar(_T("AUPREC"), &auprec) == RTNORM);
					if(auprec == 0)//保留整数
					{
						dlg.m_fAngle = int(dlg.m_fAngle + 0.5);
					}
					else
					{
						double dPrecisionCompute = 1.0;//计算精度的辅助变量
						while(auprec != 0)
						{
							dPrecisionCompute = dPrecisionCompute * 10.0;
							auprec --;
						}
						dlg.m_fAngle = int((dlg.m_fAngle + 0.5/dPrecisionCompute) * dPrecisionCompute)/dPrecisionCompute;
					}

					{
						CTemporaryResourceOverride vTemp;
						if (dlg.DoModal() != IDOK)
							continue;
					}

					nNorthAngle = dlg.m_fAngle*PI/180;
					XPoint().GetRotationMatrix(-nNorthAngle+PI/2.0, mat);

					if (CCoordDlg::s_iUnitType == 0)
						adsout<<_T("\n当前绘图单位:mm;标注单位:M;");
					else
						adsout<<_T("\n当前绘图单位:M;标注单位:M;");

					if (CCoordDlg::IsWcsPoint())
						adsout<<_T("以世界坐标取值;北向角度")<<dlg.m_fAngle<<_T("度");
					else if (CCoordDlg::IsUcsPoint())
						adsout<<_T("以用户坐标取值");
					else if (CCoordDlg::IsRedLinePoint())
						adsout<<_T("以场地坐标取值");
					continue;
				}
				else if (szKey[0]==_T('Q') || szKey[0]==_T('q')) // 批量标注，add by lgy 20120330，9.0新增功能
				{
					CBatchDimDlg dlgDim;
					{
						CTemporaryResourceOverride vTemp;
						dlgDim.Create(dlgDim.IDD, acedGetAcadFrame());
					}
					dlgDim.ShowWindow(TRUE);

					int nRetBatchDim = BatchDim(dlgDim, mat);
					if (nRetBatchDim == RTKWORD) // 切换到单点标注
					{
						dlgDim.DestroyWindow(); // add by lgy 20120531，引起cad无法打开图纸，创建图纸
						continue;
					}
					else // 结束命令
					{
						dlgDim.DestroyWindow();
						return;
					}
				}
			}
			else if (nRet != RTNORM)
				return;
		}
		else
		{
			if (RTNORM != ads_getpoint(ptLastUcs, _T("\n请点取标注点<退出>:"), ptLoc))
				return;
		}

		//  [10/22/2007 nsh]
		// sg modify 120618，解决设置固定度角后，坐标文字位置不正确的问题
		XPoint saveFirstPoint;
		// savePoint = ptLoc; // 对保存第一点的初始化
		saveFirstPoint = ptLoc; // 对保存第一点的初始化
		//--end--
		bFirst = false;
		ptLastUcs = ptLoc;
		ptLoc = Ucs2Wcs(ptLoc);
		XPoint ptLocWcs = ptLoc;
	    
		if (CCoordDlg::IsUcsPoint())
			ptLoc = Wcs2Ucs(ptLoc);
		else if (CCoordDlg::IsWcsPoint())
			ptLoc.TransformBy(mat);
		else if (CCoordDlg::IsRedLinePoint())
			ptLoc = TranslatePtFromRedline(ptLoc);

		double x, y;
		if (CCoordDlg::s_iUnitType == 0) // mm-M
		{
			x = _AS_METER(ptLoc.y);
			y = _AS_METER(ptLoc.x);
		}
		else // M-M
		{
			x = ptLoc.y;
			y = ptLoc.x;
		}

		if (fabs(x) < 1E-6)
			x = 0;
		if (fabs(y) < 1E-6)
			y = 0;

		TDbSymbCoord *pCoord = new TDbSymbCoord;
		pCoord->SetLocation(ptLocWcs);
		pCoord->SetValue(XPoint(y, x));
		// sg modify 120106，给“TS_SYMBOL”独立出来一个文字样式
		// pCoord->SetTextStyleId(InitTextStyle(TS_DIM));
		pCoord->SetTextStyleId(InitTextStyle(TS_SYMBOL));

		// delete by xly on 100915 实体图层设置放在AddToSpace中
		// pCoord->setLayer(pElev->GetDefaultLayer());

		pCoord->SetAB(g_bABCoord);
		pCoord->SetStyle((TDbSymbMultiLeader::TArrowStyle)g_nCoordArrowStyle);
		pCoord->SetLayoutRotation(Ucs2Wcs(0.0));//modified by whl
		pCoord->SetTextLayerId(InitLayer(LAY_TEXT, TRUE));
		pCoord->SetPrecNum(g_nCoordPrec);
		if (CCoordDlg::IsUcsPoint())
			pCoord->setColorIndex(4); // 与WCS区别
		else if (CCoordDlg::IsWcsPoint())
			pCoord->setColorIndex(3);
		else if (CCoordDlg::IsRedLinePoint())
			pCoord->setColorIndex(2);

		TCoordEdJig jig(pCoord);
		// --------------------------------------------------- [10/22/2007 nsh]
		// 以下是判断是否是有固定角度的限制
		{
			// 给jig加固定角度
			if (CCoordDlg::m_bFixAngle)
			{
				jig.m_dFixAngle = ::_tstof(CCoordDlg::m_strAngle);
				// sg modify 120618，解决设置固定度角后，坐标文字位置不正确的问题
				jig.m_saveFirstPt = saveFirstPoint;
			}
		}
		// --end--
		jig.SetPrompt(_T("\n点取坐标标注方向<退出>:"));
		
		int nRet = jig.DoIt();
		// modify by xly on 100915  实体是否设置在默认层
		// if(nRet==RTNORM) 
		//	pCoord->AddToCSpace(Adesk::kTrue);
		if (nRet == RTNORM)
		{
			AddToSpace(Adesk::kTrue, pCoord);
		}
		else
			delete pCoord;
	}
}


// Command: 坐标检查
void CheckCoord()
{
	CCoordDlg::s_iUnitType=DocGetMeterUnitDraw();

	double nNorthAngle=PI/2;//默认为90度
	PickSet ssNorth(SS_FREE);
	if(ssNorth.Get(_T("X"), NULL, NULL, RBList(RTDXF0, _T("ATS_NORTHTHUMB"), 67, 0, NULL))==RTNORM) 
	{ //模型空间指北针
		Entity ent0=ssNorth[0L]; 
		ent0.GetData(50, &nNorthAngle);
	}

    XPoint ptLoc,ptLastUcs;
	CCoordDlg dlg(IDD_CHECK_COORD);
	dlg.m_fAngle=nNorthAngle*180/PI;
	{
		CTemporaryResourceOverride vTemp;
		if(dlg.DoModal()!=IDOK)
			return;
	}
	nNorthAngle=dlg.m_fAngle*PI/180;
	ads_matrix mat,mat1;
	XPoint().GetRotationMatrix(-nNorthAngle+PI/2.0, mat);
	XPoint().GetRotationMatrix(nNorthAngle-PI/2.0,mat1);
    PickSet ss(SS_FREE), ssError(SS_FREE);
    RBList mask(RTDXF0, _T("ATS_COORD"), NULL);	
    if(SelectEntities(_T("\n选择待检查的坐标:"), ss, mask)!=RTNORM)
		return;
    
    long lCount=ss.Length();
    for(long i=0L; i<lCount; i++)
	{
        Entity ent=ss[i];
        OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbSymbCoord, pCoord);
        if(pCoord) 
		{
			XPoint pt,val=pCoord->GetValue();
            pt=pCoord->GetLocation();
			if(CCoordDlg::IsUcsPoint())
				pt=Wcs2Ucs(pt);
			else if (CCoordDlg::IsWcsPoint())
				pt.TransformBy(mat);
			else if (CCoordDlg::IsRedLinePoint())
				pt = TranslatePtFromRedline(pt);

			if(CCoordDlg::s_iUnitType==0)//mm--M
				pt /= 1000;
			
			CString sPt,sVal;
			XString sFormat;
			sFormat<<XString(_T("%%.%dlf"),g_nCoordPrec)<<_T(",")<<XString(_T("%%.%dlf"),g_nCoordPrec);
			sPt.Format(sFormat,pt.x,pt.y);
			sVal.Format(sFormat,val.x,val.y);
			if(_tcscmp(sPt,sVal)!=0)
                ssError += ent;
        }
        OPENOBJ_END();
    }

    long lError=ssError.Length();
    if(lError==0)
	{
		adsout << _T("\n选中的坐标") << lCount << _T("个，全部正确!");
		return;
	}

    adsout << _T("\n选中的坐标") << lCount << _T("个，其中") << lError << _T("个有错!");
    long nCurIndex=0L;
    while(lError) 
	{
        if(nCurIndex==lError)
            nCurIndex=0;

        Entity ent = ssError[nCurIndex];
        XPoint ptLow, ptUp;
        VERIFY(ent.GetExtend(ptLow, ptUp)==RTNORM);
        AssureInCurrentView(ptLow, ptUp);
        XScreenDc dc(1, 1);
        XRectAngle rec(ptLow, ptUp);
        XPoly2D poly2d, polyOffset;
        rec.AsPoly2D(poly2d);
        poly2d.Offset((ptUp.x-ptLow.x)/10.0, polyOffset);
		polyOffset.TransUCS(Groups(0), Groups(1));
        dc << polyOffset; // UCS 下是否正确？

        XPoint pt;
		BOOL bIsAB=FALSE;
        OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbSymbCoord, pCoord);
        if(pCoord) 
		{
 			pt=pCoord->GetLocation();
			if(CCoordDlg::IsUcsPoint())
				pt=Wcs2Ucs(pt);
			else if (CCoordDlg::IsWcsPoint())
				pt.TransformBy(mat);
			else if (CCoordDlg::IsRedLinePoint())
				pt = TranslatePtFromRedline(pt);

			if(CCoordDlg::s_iUnitType==0)
				pt/=1000;
			bIsAB=pCoord->IsAB();
        }
        OPENOBJ_END();

		XString sCoordA(XString(_T("%%.%dlf"),g_nCoordPrec),pt.y);
		XString sCoordB(XString(_T("%%.%dlf"),g_nCoordPrec),pt.x);
        adsout << _T("\n第") << (nCurIndex+1) << _T("/") << lError << _T("个错误的坐标，正确标注(") 
			<< (bIsAB? _T("A=") : _T("X="))<< sCoordA 
			<< (bIsAB? _T(",B=") : _T(",Y=")) << sCoordB 
			<<  _T(")或 [全部纠正(A)/纠正坐标(C)/纠正位置(D)/退出(X)]<下一个>:");

        int nRet=RTNORM;
        XString sKeyword;
        INITGET_BEG(0, _T("A C D X"));
        nRet=ads_getkword(_T(""), sKeyword);
        INITGET_END();
        ads_redraw(NULL, 1);
        if(nRet==RTCAN)
            break;
        if(nRet==RTNONE) {
            nCurIndex++;
        } else if(nRet==RTNORM) {
            if(sKeyword[0]==_T('C')) {
                OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbSymbCoord, pCoord);
                if(pCoord) 
					pCoord->SetValue(pt);
                OPENOBJ_END();
                ssError -= ent;
                lError --;
            } else if(sKeyword[0]==_T('A')) {
                for(long idx=0L; idx<lError; idx++) {
                    Entity e=ssError[idx];
                    OPENOBJ_BEGIN(e, AcDb::kForWrite, TDbSymbCoord, pCoord);
                    if(pCoord) 
					{
						pt=pCoord->GetLocation();
						if(CCoordDlg::IsUcsPoint())
							pt=Wcs2Ucs(pt);
						else if (CCoordDlg::IsWcsPoint())
							pt.TransformBy(mat);
						else if (CCoordDlg::IsRedLinePoint())
							pt = TranslatePtFromRedline(pt);

						if(CCoordDlg::s_iUnitType==0)
							pt/=1000;
						pCoord->SetValue(pt);
                    }
                    OPENOBJ_END();
                }
                break;
			} else if(sKeyword[0]==_T('D')) {
                OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbSymbCoord, pCoord);
                if(pCoord) {
					pt=pCoord->GetValue();
					if(CCoordDlg::s_iUnitType==0)
						pt*=1000;
					if(CCoordDlg::IsUcsPoint())
						pt=Wcs2Ucs(pt);
					else if (CCoordDlg::IsWcsPoint())
						pt.TransformBy(mat1);
					else if (CCoordDlg::IsRedLinePoint())
						pt = TranslatePtFromRedline(pt);

					XPoint ptLoc=pCoord->GetLocation();
                    pCoord->SetLocation(pt);
					pCoord->SetTurnPoint(pCoord->GetTurnPoint() + pt - ptLoc);
                }
                OPENOBJ_END();
                ssError -= ent;
                lError --;
            } else {
                break;
            }
        }
    }
}

// command:编辑图名标注
// build by lcf 2004/12/01
int EditDrawingName(AcDbObjectId id)
{
	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbDrawingName, pDrawingName);
	if (!pDrawingName)
		return RTERROR;

#if (ADS>16)
	//wlw mod 新建筑双击出新对话框 2013.5.7
	if(EditNewDlg(id,_T("TGMapName\n")) > 0)
		return TRUE;
#endif

	CTemporaryResourceOverride vTemp;
	CDrawingNameDlg dlg(TRUE, acedGetAcadFrame());
	dlg.Obj2Dlg(pDrawingName);

	int nDrawMode = DocGetDrawMode();
	DocSetDrawMode(DRAW_2D);
	INT_PTR nRet = dlg.DoModal();
	if (nRet == IDOK)
	{
		if (pDrawingName->upgradeOpen() == Acad::eOk) 
		{
			dlg.Dlg2Obj(pDrawingName);
			pDrawingName->downgradeOpen();
		}
		DocSetDrawMode(nDrawMode); 
	}
	else
	{
		pDrawingName->close();
		DocSetDrawMode(nDrawMode); 
		return RTCAN;
	}
	OPENOBJ_END();
	return RTNORM;
}


// command 图名标注
// build by lcf 2004/12/01
void SymbDrawingName()
{
	// sg add 120706，9.0起图面标注给出一个独立的文字样式
	AcDbObjectId idTextStyle = InitTextStyle(TS_DRAWINGNAME);
	if (!idTextStyle)
		return;

	int nDrawMode = DocGetDrawMode();
	DocSetDrawMode(DRAW_2D);
	CDrawingNameDlg dlg(FALSE, acedGetAcadFrame());
	{
		CTemporaryResourceOverride vTemp;
		if(!dlg.Create(dlg.IDD, acedGetAcadFrame()))
		{
			DocSetDrawMode(nDrawMode);
			return;
		}
	}
	dlg.ShowWindow(SW_SHOW);

	while(1)
	{
		acedGetAcadDwgView()->SetFocus();
		TDbDrawingName *pEnt = new TDbDrawingName;
		dlg.Dlg2Obj(pEnt);
		dlg.m_bPost = TRUE;
		// sg modify 090320，8.0起，不再使用“文字转角”，转化为“布局转角”
//		pEnt->SetRotation(Ucs2Wcs(0.0));
		pEnt->SetLayoutRotation(Ucs2Wcs(0.0));

		// delete by xly on 100915 实体图层设置放在AddToSpace中
		//pEnt->setLayer(pEnt->GetDefaultLayer());
		if (g_bTextDefaultLayer)
		{
			pEnt->setLayer(pEnt->GetDefaultLayer());
		}

		TDrawingNameJig jig(pEnt);
		jig.SetKeyword(_T("`"));
		jig.SetPrompt(_T("\n请点取插入位置<退出>:"));
		int nRet = jig.start();
		if (nRet == RTNORM)
		{
			dlg.AddToRecent();
			if (!dlg.m_bContinue)
				break;
			dlg.m_bPost = FALSE;
		}
		else if (nRet == RTKWORD)
		{
			if (dlg.m_nOperCode == 0)
				dlg.GetTextHeight();
			else if (dlg.m_nOperCode == 1)
				dlg.GetPickText();
		}
		else
		{
			DocSetDrawMode(nDrawMode); // add by whl on 060225
			if (::IsWindow(dlg.m_hWnd))
				dlg.DestroyWindow();
			return;
		}
	}
	DocSetDrawMode(nDrawMode);

	if (::IsWindow(dlg.m_hWnd))
		dlg.DestroyWindow();
}

// add by zyc 20120425 TArrangeElev命令实现
// 函数声明
void DetectHasBaseLine(TPickEntSet& pickSet, BOOL& bHasBaseLine);
int  SelectElevs(TPickEntSet& pickSet, BOOL& bHasBaseLine);
int  GetLocationAlignPoint(TEntitySet* ref, /*参考标注*/
						   AcGePoint3d& pt, TPickEntSet* pickSet);
void AlignElevs(AcGePoint3d pt, TPickEntSet& pickSet);
int  GetBaseAlignPoint(AcGePoint3d& pt, TPickEntSet* pickSet);
void AlignSingleBaseLine(AcGePoint3d pt, TDbSymbElevation* pDim);
void AlignBaseLine(AcGePoint3d pt, CArray<TDbSymbElevation*, TDbSymbElevation*>& arElevs);
void AlignBaseLine(AcGePoint3d pt, TPickEntSet& pickSet);

// 命令入口
void ArrangeElev()
{
	// 清空初始选择集
	g_ssPickFirst.Free();

	BOOL bIsFree = TRUE; // 自由对齐
	TEntitySet pickEnt;
	TRBList mask = TRBList(RTDXF0, _T("ATS_ELEVATION"), NULL);
	int iRet;
	TPickEntSet pickSet;
	TCHAR cRet;
	// 切换参考对齐或自由对齐
	while (1)
	{
		if (bIsFree)
		{
			// modify by zyc 120611 命令提示
			// iRet = SelectEntities(_T("\n请选择需对齐的标高标注或[参考对齐(Q)]<退出>:"), 
			//	   pickSet, mask, _T("Q"), cRet);
			iRet = SelectEnts(_T("\n请选择需对齐的标高标注或[参考对齐(Q)]<退出>:"), 
				_T("\n请选择需对齐的标高标注:"),
				mask, pickSet, _T("Q"), cRet);
		}
		else
		{
			XPoint ptPick;
			INITGET_BEG(0, _T("Q"));
			iRet = SelectEntity(_T("\n请选择参考标高标注或[自由对齐(Q)]<退出>:"), 
				pickEnt, ptPick, mask);
			INITGET_END();
		}

		if (RTNORM != iRet)
		{
			if (RTKWORD == iRet)
			{
				bIsFree = bIsFree ? FALSE : TRUE;
				continue;
			}
			else
			{
				pickSet.Free();
				return;
			}
		}
		break;
	}

	AcGePoint3d  ptAlign;
	BOOL bHasBaseLine = FALSE;
	if (bIsFree)  
	{
		// 自由对齐
		// 指定标高对齐点
		DetectHasBaseLine(pickSet, bHasBaseLine);
		if (RTNORM == GetLocationAlignPoint(NULL, ptAlign, &pickSet))
		{
			// 对齐标高标注
			AlignElevs(ptAlign, pickSet);
		}
	}
	else
	{
		// 参考对齐
		// 选择需要对齐的标高标注
		iRet = SelectElevs(pickSet, bHasBaseLine);
		if (RTCAN == iRet)
		{
			pickSet.Free();
			return;
		}

		// 指定标高对齐点
		GetLocationAlignPoint(&pickEnt, ptAlign, &pickSet);

		// 对齐标高标注
		AlignElevs(ptAlign, pickSet);
	}

	if (bHasBaseLine)
	{
		// 指定基线对齐点
		if (RTNORM == GetBaseAlignPoint(ptAlign, &pickSet))
		{
			// 对齐基线
			AlignBaseLine(ptAlign, pickSet);
		}
	}

	pickSet.Free();
}

class CElevPickSet : public TDbEntity
{
public:
	CElevPickSet() {};
	virtual ~CElevPickSet()
	{
		for (int i=0; i<m_arElevs.GetSize(); i++)
		{
			if (m_arElevs[i])
				delete m_arElevs[i];
		}
	}
	virtual Acad::ErrorStatus ExplodeOrDraw2d(TGGiExplodeDrawBase &dc) const;

	void SetData(TPickEntSet* ppickSet);
	TDbSymbElevation* GetElementAt(int iPos) { return m_arElevs[iPos]; }
	TDbSymbElevation* operator [](int iPos) { return GetElementAt(iPos); }
	int GetSize() {return m_arElevs.GetSize(); }
	CArray<TDbSymbElevation*, TDbSymbElevation*>* GetArray() { return &m_arElevs; }

private:
	CArray<TDbSymbElevation*, TDbSymbElevation*> m_arElevs;
};

Acad::ErrorStatus CElevPickSet::ExplodeOrDraw2d(TGGiExplodeDrawBase &dc) const
{
	for (int i=0; i<m_arElevs.GetSize(); i++)
	{
		m_arElevs[i]->ExplodeOrDraw2d(dc);
	}
	return Acad::eOk;
}

void CElevPickSet::SetData(TPickEntSet* ppickSet)
{
	TDbSymbElevation* pElev;
	for (long i=0; i<ppickSet->Length(); i++)
	{
		OPENOBJ_BEGIN((*ppickSet)[(long)i], AcDb::kForRead, TDbSymbElevation, pDim);
		if (pDim)
		{
			pElev = (TDbSymbElevation*)pDim->clone();
			m_arElevs.Add(pElev);
		}
		OPENOBJ_END();
	}
}

class CElevationJig : public AcEdJig
{
public:
	CElevationJig(TPickEntSet* ppickSet) 
	{ 
		m_pickSet.SetData(ppickSet);
	}
	virtual ~CElevationJig() {}

	virtual AcDbEntity* entity() const { return (AcDbEntity*)&m_pickSet; }
	virtual AcEdJig::DragStatus sampler();
	virtual Adesk::Boolean update();

	AcEdJig::DragStatus doIt(BOOL bIsBaseLine);
	AcGePoint3d  m_ptAlign;
private:
	CElevPickSet m_pickSet;
	BOOL         m_bIsBaseLine;
};

AcEdJig::DragStatus CElevationJig::sampler()
{
	setUserInputControls(kNullResponseAccepted);
	AcEdJig::DragStatus ds;
	AcGePoint3d pt;
	ds = acquirePoint(pt);
	if (AcEdJig::kNormal != ds)
	{
		return ds;
	}
	if (m_ptAlign == pt)
	{
		return AcEdJig::kNoChange;
	}
	m_ptAlign = pt;
	return ds;
}

Adesk::Boolean CElevationJig::update()
{
	if (m_bIsBaseLine)
	{
		AlignBaseLine(m_ptAlign, *(m_pickSet.GetArray()));
	}
	else
	{
		AcGePoint3d ptLoc;
		for (int i=0; i<m_pickSet.GetSize(); i++)
		{
			ptLoc = m_pickSet[i]->GetLocation();
			ptLoc = Wcs2Ucs(ptLoc);
			ptLoc.x = Wcs2Ucs(m_ptAlign).x;
			m_pickSet[i]->SetLocation(Ucs2Wcs(ptLoc));
		}
	}
	return Adesk::kTrue;
}

AcEdJig::DragStatus CElevationJig::doIt(BOOL bIsBaseLine)
{
	m_bIsBaseLine = bIsBaseLine;
	CString sPrompt;
	if (bIsBaseLine)
	{
		sPrompt = _T("\n请点取标高基线对齐点<不变>:");
	}
	else
	{
		sPrompt = _T("\n请点取标高对齐点<不变>:");
	}
	setDispPrompt((LPCTSTR)sPrompt);
	return drag();
}

// 检测是否有含基线的标高
void DetectHasBaseLine(TPickEntSet& pickSet, BOOL& bHasBaseLine)
{
	for (long i=0; i<pickSet.Length(); i++)
	{
		OPENOBJ_BEGIN(pickSet[(long)i], AcDb::kForRead, TDbSymbElevation, pDim);
		if (pDim)
		{
			if (pDim->HasBaseLine())
			{
				bHasBaseLine = TRUE;
				break;
			}
		}
		OPENOBJ_END();
	}
}

// 选择需要对齐的标高标注
int SelectElevs(TPickEntSet& pickSet, BOOL& bHasBaseLine)
{
	TRBList mask = TRBList(RTDXF0, _T("ATS_ELEVATION"), NULL);
	int iRet = RTNORM;
	iRet = SelectEntities(_T("\n请选择需对齐的标高标注:"), pickSet, mask);
	if (RTCAN == iRet)
	{
		return iRet;
	}

	// 检测是否有含基线的标高
	DetectHasBaseLine(pickSet, bHasBaseLine);

	return RTNORM;
}

// 获取标高对齐点
int GetLocationAlignPoint(TEntitySet* ref, /*参考标注*/
						  AcGePoint3d& pt, TPickEntSet* pickSet)
{
	if (NULL != ref)
	{
		// 以参考标注为对齐点
		OPENOBJ_BEGIN(*ref, AcDb::kForRead, TDbSymbElevation, pDim);
		if (pDim)
		{
			pt = (AcGePoint3d)pDim->GetLocation();
		}
		OPENOBJ_END();
	}
	else
	{
		// 由用户指定对齐点
		CElevationJig jig(pickSet);
		if (AcEdJig::kNormal != jig.doIt(FALSE))
		{
			return RTNONE;
		}
		pt = jig.m_ptAlign;
	}
	return RTNORM;
}

// 对齐标高标注
void AlignElevs(AcGePoint3d pt, TPickEntSet& pickSet)
{
	TADSGePoint3d ptDim;
	TADSGePoint3d ptRef(pt);
	ptRef = Wcs2Ucs(ptRef);
	for (long i=0; i<pickSet.Length(); i++)
	{
		OPENOBJ_BEGIN(pickSet[(long)i], AcDb::kForWrite, TDbSymbElevation, pDim);
		if (pDim)
		{
			ptDim = pDim->GetLocation();
			ptDim = Wcs2Ucs(ptDim);
			ptDim.x = ptRef.x;
			ptDim = Ucs2Wcs(ptDim);
			pDim->SetLocation(ptDim);
		}
		OPENOBJ_END();
	}
}

// 获取基线对齐点
int GetBaseAlignPoint(AcGePoint3d& pt, TPickEntSet* pickSet)
{
	CElevationJig jig(pickSet);
	if (AcEdJig::kNormal != jig.doIt(TRUE))
	{
		return RTNONE;
	}
	pt = jig.m_ptAlign;
	return RTNORM;
}


// 对齐基线
void AlignBaseLine(AcGePoint3d pt, CArray<TDbSymbElevation*, TDbSymbElevation*>& arElevs)
{
	for (int i=0; i<arElevs.GetSize(); i++)
	{
		AlignSingleBaseLine(pt, arElevs[i]);
	}
}
void AlignBaseLine(AcGePoint3d pt, TPickEntSet& pickSet)
{

	for (long i=0; i<pickSet.Length(); i++)
	{
		OPENOBJ_BEGIN(pickSet[(long)i], AcDb::kForWrite, TDbSymbElevation, pDim);
		if (pDim)
		{
			AlignSingleBaseLine(pt, pDim);
		}
		OPENOBJ_END();
	}
}
void AlignSingleBaseLine(AcGePoint3d pt, TDbSymbElevation* pDim)
{
	AcGePoint3dArray arPts;
	AcGePoint3d ptDir;
	AcGePoint3d ptTextBase;
	AcGePoint3d ptLocation;
	AcGeVector3d vtDir;
	pt = Wcs2Ucs(pt);

	if (!pDim->HasBaseLine())
	{
		return;
	}

	pDim->subGetStretchPoints(arPts);

	// modify by zyc 120611 得到标高标注的平行于基线的方向，有引线和无引线分别处理
	// ptDir = arPts[1];
	if (pDim->HasLeader())
	{
		ptDir = arPts[4];
	}
	else
	{
		ptDir = arPts[1];
	}

	ptTextBase = arPts[2];
	ptLocation = pDim->GetLocation();
	ptLocation = Wcs2Ucs(ptLocation);
	ptDir      = Wcs2Ucs(ptDir);
	ptTextBase = Wcs2Ucs(ptTextBase);
	vtDir.set(ptTextBase.x-ptDir.x,
		ptTextBase.y-ptDir.y,
		ptTextBase.z-ptDir.z);
	double dAngle = vtDir.angleTo(AcGeVector3d(1, 0, 0));

	// 求出在标注所在的直线上，标注到对齐线的距离
	AcGeLine3d lineDim(ptDir, ptTextBase);
	AcGeLine3d lineAlign(pt, AcGeVector3d(0, 1, 0));
	AcGePoint3d ptIntersect;
	lineDim.set(ptLocation, lineDim.direction());
	if (Adesk::kTrue == lineAlign.intersectWith(lineDim, ptIntersect))
	{
		pDim->SetBaseLen(ptIntersect.distanceTo(ptLocation), FALSE);
	}

	if (!(dAngle < PI/2 && ptLocation.x > pt.x ||
		dAngle > PI/2 && ptLocation.x < pt.x))
	{
		// 改变标高标注的左右方向
		AcGeLine3d lineSymetry(Ucs2Wcs(ptLocation), 
			(AcGeVector3d)Ucs2Wcs(lineDim.direction().rotateBy(PI/2, AcGeVector3d(0, 0, 1)), 
			TRUE));
		AcGeMatrix3d matrix;
		matrix.setToMirroring(lineSymetry);
		pDim->transformBy(matrix);
	}
}
// end of TArrangeElev

//add by lgy 绘制云线
void DrawCloud()
{
	XPushVar<int> vOsMode(_T("OSMODE"), 0);

	InitTextStyle(TS_SECTION);
	AcDbObjectId idModi = InitLayer(LAY_MODI_DIM),
		idTextLayer = InitLayer(LAY_TEXT);
	OPENOBJ_BEGIN(idModi, AcDb::kForWrite, AcDbLayerTableRecord, pLayer);
	if (pLayer != NULL)
	{
		pLayer->setIsPlottable(false); // 设置图层不打印
	}
	OPENOBJ_END();
	
	CCloudLineDlg dlg;
	{
		CAcModuleResourceOverride vTemp;
		if (!dlg.Create(dlg.IDD, (CWnd*)acedGetAcadFrame()))
			return;
	}
	acedGetAcadDwgView()->SetFocus();
	dlg.ShowWindow(SW_SHOW);

	BOOL bHasModi(FALSE);
	XPoly2D polyModi;
	AcDbObjectId idEnt;

	while(TRUE)
	{
		dlg.SetIsChangeType(false);
		polyModi.Reset();
		bHasModi = FALSE;

		int iType = dlg.GetDrawLineStyle();
		if (iType == 0) // 圆形云线
		{
			XPoint ptCenter;
			if (acedGetPoint(NULL, _T("\n请指定圆形云线的圆心<退出>:"), ptCenter) != RTNORM)
			{
				if (!dlg.GetIsChangeType())
				{
					dlg.DestroyWindow();
					return;
				}
				continue;
			}

			static double dRadius = 0.0;
			static bool bFirstDrawCloud = true; // 是否第一次进入云线命令

			if (bFirstDrawCloud)
			{
				if (acedGetDist(ptCenter, _T("\n请指定圆形云线的半径<退出>:"), &dRadius) != RTNORM)
				{
					if (!dlg.GetIsChangeType())
					{
						dlg.DestroyWindow();
						return;
					}
					continue;
				}
				bFirstDrawCloud = false;
			}
			else
			{
				CString csTemp;
				csTemp.Format(_T("\n请指定圆形云线的半径<%.0f>:"), dRadius);

				int nRet = acedGetDist(ptCenter, csTemp, &dRadius);
				if (nRet!=RTNORM && nRet!=RTNONE)
				{
					if (!dlg.GetIsChangeType())
					{
						dlg.DestroyWindow();
						return;
					}
					continue;
				}

				if (fabs(dRadius) < 1.0E-3)
				{
					acutPrintf(_T("输入的半径不能为0!"));
					continue;
				}
			}
			ptCenter = Ucs2Wcs(ptCenter);

			// 生成路径线polyModi，必须是逆时针的
			XArc arc1(ptCenter, dRadius, 0, PI), // 逆弧
				arc2(ptCenter, dRadius, PI, 2*PI);
			XCurveSegment seg;
			seg = arc1;
			dlg.GetCloudLinePoly(seg, polyModi);
			seg = arc2;
			dlg.GetCloudLinePoly(seg, polyModi);
			polyModi.SetClosed();
		}
		else if (iType == 1) // 矩形云线
		{
			// sg modify 120612，如果是矩形云线，强制正交关闭
			XPushVar<int> orthomode(_T("ORTHOMODE"), 0);

			XPoint pt1, pt2;
			if (acedGetPoint(NULL, _T("\n请指定第一个角点<退出>:"), pt1) != RTNORM)
			{
				if (!dlg.GetIsChangeType())
				{
					dlg.DestroyWindow();
					return;
				}
				continue;
			}

			if (acedGetPoint(pt1, _T("\n请指定另一个角点<退出>:"), pt2) != RTNORM)
			{
				if (!dlg.GetIsChangeType())
				{
					dlg.DestroyWindow();
					return;
				}
				continue;
			}

			// 生成路径线polyModi，必须是逆时针的
			XPoly2D poly;
			XPoint pt3(pt2.x, pt1.y, 0),
				pt4(pt1.x, pt2.y, 0);
			poly.AppendNode(Ucs2Wcs(pt1));
			poly.AppendNode(Ucs2Wcs(pt3));
			poly.AppendNode(Ucs2Wcs(pt2));
			poly.AppendNode(Ucs2Wcs(pt4));
			poly.SetClosed();

			if (poly.PathArea() > 0)
				poly.Reverse();

			dlg.GetCloudLinePoly(poly, polyModi);
			polyModi.SetClosed();
		}
		else if (iType == 2)	//任意形状弧线
		{
			bHasModi = TRUE;

			XPoint ptFirst;
			if (acedGetPoint(NULL, _T("\n指定起点 <退出>:"), ptFirst) != RTNORM)
			{
				if (!dlg.GetIsChangeType())
				{
					dlg.DestroyWindow();
					return;
				}
				continue;
			}

			acutPrintf(_T("\n沿云线路径引导十字光标..."));

			double dMaxValue = dlg.GetMaxValue(),
				dMinValue = dlg.GetMinValue();

			TDbSymbModi *pEnt = new TDbSymbModi;
			pEnt->SetEndWidth(dlg.GetEndWidth());

			TCloudLineJig jig(pEnt, Ucs2Wcs(ptFirst), dMaxValue, dMinValue);
			int nKeyIndex(0),
				nRet = jig.DoIt(&nKeyIndex);
			if (nRet != RTNORM)
			{
				delete pEnt;
				if (!dlg.GetIsChangeType())
				{
					dlg.DestroyWindow();
					return;
				}
				continue;
			}

			pEnt->SetEndWidth(dlg.GetEndWidth());
			pEnt->SetArcAngle(0.5); // 弧线的凸度固定为0.5
			pEnt->SetLayoutRotation(Ucs2Wcs(0));
			pEnt->setLayer(idModi);
			idEnt = AddToCurrentSpace(pEnt, TRUE);
			acutPrintf(_T("\n修订云线完成"));
		}
		else if (iType == 3)	//指定对象
		{
			int iCursorType = g_nOsnapType;
			DocSetWallOsnapType(1);

			Entity ent;
			RBList mask(RTDXF0, _T("POLYLINE,LWPOLYLINE,CIRCLE"), NULL);
			if (ent.FilterSelect(_T("\n请选择要转换为云线的闭合对象<退出>:"), mask) != RTNORM)
			{
				if (!dlg.GetIsChangeType())
				{
					DocSetWallOsnapType(iCursorType);

					dlg.DestroyWindow();
					return;
				}
				continue;
			}
			DocSetWallOsnapType(iCursorType);

			if (ent.Is(_T("LWPOLYLINE")) || ent.Is(_T("POLYLINE")))
			{
				XPoly2D poly(ent);
				if (!poly.IsClosed())
				{
					acutPrintf(_T("无法将此对象转换为修订云线，请重新选择闭合对象！"));
					continue;
				}

				// 生成路径线polyModi，必须是逆时针的
				if (poly.PathArea() > 0)
					poly.Reverse();		

				dlg.GetCloudLinePoly(poly, polyModi);
				polyModi.SetClosed();

				ent.Erase();
			}
			else if (ent.Is(_T("CIRCLE")))
			{
				XCircle circle(ent);
				XPoint ptCenter = circle.GetCenterPt();
				double dDistance = circle.GetRadius();

				// 生成路径线polyModi，必须是逆时针的
				XArc arc1(ptCenter, dDistance, 0, PI),
					arc2(ptCenter, dDistance, PI, 2*PI);

				XCurveSegment seg;
				seg = arc1;
				dlg.GetCloudLinePoly(seg, polyModi);
				seg = arc2;
				dlg.GetCloudLinePoly(seg, polyModi);
				polyModi.SetClosed();

				ent.Erase();
			}
		}

		// 创建实体
		if (!bHasModi)
		{
			TDbSymbModi *pEnt = new TDbSymbModi;
			pEnt->SetModiPoly(polyModi);
			pEnt->SetEndWidth(dlg.GetEndWidth());
			pEnt->SetArcAngle(0.5); // 弧线的凸度固定为0.5
			pEnt->setLayer(idModi);
			pEnt->SetLayoutRotation(Ucs2Wcs(0));
			idEnt = AddToCurrentSpace(pEnt, TRUE);
		}

		// 处理版次文字
		CString csText;
		double dHeight(0.0);
		AcDbObjectId idTextStyle;
		BOOL bShowText(FALSE);
		dlg.GetTextParam(bShowText, csText, dHeight, idTextStyle);

		if (!bShowText)
		{
			OPENOBJ_BEGIN(idEnt, AcDb::kForWrite, TDbSymbModi, pModi);
			if (pModi != NULL)
			{
				pModi->SetIsShowEdition(FALSE);
				pModi->SetTextLayerId(idTextLayer); // 增加对文字通用图层的设置
				pModi->SetTextStyleId(idTextStyle);
				pModi->SetEditionText(csText);
				pModi->SetTextHeight(dHeight);
				pModi->SetEditLocal(pModi->GetDefaultTextLocation());
			}
			OPENOBJ_END();

			continue;
		}

		XPoint ptEditLocal;
		if (acedGetPoint(NULL, _T("\n请指定版次标志的位置<取消>:"), ptEditLocal) != RTNORM)
		{
			dlg.GetTextParam(bShowText, csText, dHeight, idTextStyle);

			OPENOBJ_BEGIN(idEnt, AcDb::kForWrite, TDbSymbModi, pModi);
			if (pModi != NULL)
			{
				pModi->SetIsShowEdition(FALSE);
				pModi->SetTextStyleId(idTextStyle);
				pModi->SetTextLayerId(idTextLayer); // 增加对文字通用图层的设置
				pModi->SetEditionText(csText);
				pModi->SetTextHeight(dHeight);
				pModi->SetEditLocal(pModi->GetDefaultTextLocation());
			}
			OPENOBJ_END();

			continue;
		}
		ptEditLocal = Ucs2Wcs(ptEditLocal);

		dlg.GetTextParam(bShowText, csText, dHeight, idTextStyle);

		OPENOBJ_BEGIN(idEnt, AcDb::kForWrite, TDbSymbModi, pModi);
		if (pModi != NULL)
		{
			pModi->SetTextStyleId(idTextStyle);
			pModi->SetIsShowEdition(bShowText);
			pModi->SetEditLocal(ptEditLocal);
			pModi->SetTextHeight(dHeight);
			pModi->SetEditionText(csText);
			pModi->SetTextLayerId(idTextLayer); // 增加对文字通用图层的设置
		}
		OPENOBJ_END();
	}
}

//add by lgy 20120418	编辑云线
int EditCloudLine(AcDbObjectId id)
{	//wlw mod 双击云线
	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbSymbModi, pModi)
	if (!pModi)
		return RTERROR;
	OPENOBJ_END()

#if (ADS>16)
	if(EditNewDlg(id,_T("TGRevCloud\n")) > 0)
		return TRUE;
#endif

	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbSymbModi, pModi);
	if (pModi == NULL)
	{
		return RTERROR;
	}

	XString strNewText;
	strNewText = pModi->GetEditionText();

	if (!strNewText) 
	{
		strNewText = _T("1");
	}
	adsout << _T("\n输入修改版次<") << strNewText << _T(">: ");

	XString sText1; // 输入新字符串
	if (ads_getstring(0,  _T(""), sText1) != RTNORM)
	{
		return RTNORM;
	}

	if (!!sText1)
	{
		strNewText = sText1;
	}

	if (pModi->upgradeOpen() == Acad::eOk)
	{
		CString strTemp;
		if (_tcscmp(sText1, _T("")) != 0)
		{
			strTemp = sText1;
			pModi->SetEditionText(strTemp);
		}
		else
		{
			strTemp = strNewText;
			pModi->SetEditionText(strTemp);
		}
		pModi->downgradeOpen();
	}
	OPENOBJ_END();
	return RTNORM;
}

//add by lgd 20130822	编辑内饰符号
int EditInSight(AcDbObjectId id)
{	
	OPENOBJ_BEGIN(id, AcDb::kForRead, TDbInSight, pModi)
		if (!pModi)
			return RTERROR;
	OPENOBJ_END()

	if(EditNewDlg(id,_T("TGInSight\n")) > 0)
		return TRUE;

	return RTNORM;
}