#include "StdAfx.h"
#include "LeaderTextDlg.h"
#include "TLeaderAddOtherPtJig.h"
#include "LeaderEdjig.h"

#include "AcEdInputPointMonitorEx.h"

// 获得端点在pt点的管子
bool GetPipe(XPoint &pt, PickSet &ss)
{
	const double dDist = 1;
	AcGePoint3d ptGeLB ,ptGeLT, ptGeRB, ptGeRT;
	AcGeVector3d vtX = AcGeVector3d::kXAxis;
	AcGeVector3d vtY = AcGeVector3d::kYAxis;
	ptGeLB = pt - vtX * dDist / 2;
	ptGeLB = ptGeLB - vtY * dDist / 2;
	ptGeLT = ptGeLB + vtY * dDist;
	ptGeRB = ptGeLB + vtX * dDist;
	ptGeRT = ptGeRB + vtY * dDist;
	
	PickSet ssSel(SS_FREE);
	RBList rbFilter(RTDXF0, _T("ATS_PIPE"), NULL);

	TADSGePoint3d _pt1 = Wcs2Ucs(ptGeLB)
		, _pt2 = Wcs2Ucs(ptGeLT)
		, _pt3 = Wcs2Ucs(ptGeRT)
		, _pt4 = Wcs2Ucs(ptGeRB);
	RBList rbPt = acutBuildList(RTPOINT,&_pt1,RTPOINT,&_pt2,RTPOINT,&_pt3, RTPOINT,&_pt4,NULL); 
	acedSSGet(_T("CP"),rbPt,NULL,rbFilter,ssSel);
	
	PickSet ss2(SS_FREE);
	double dDistToPt = 0.0;
	XPoint ptOnPipe;
	for (long i = 0; i < ssSel.Length(); i++)
	{
		OPENOBJ_BEGIN(ssSel[i], AcDb::kForRead, TDbPipe, pPipe);
		if (pPipe != NULL)
		{
			pPipe->getClosestPointTo(pt, ptOnPipe);
			dDistToPt = pt.Distance2d(ptOnPipe);
			if (dDistToPt < 1e-3)
			{
				ss2 += ssSel[i];
			}
		}
		OPENOBJ_END();
	}
	
	ss += ss2;
	if (ss.Length() >0 )
	{
		return true;
	}
	return false;
}

void LeaderTextDim()
{
	CTemporaryResourceOverride vTemp;
	CLeaderTextDlg *pDlg = NULL;
	AcDbObjectId idTextStyle = InitTextStyle(TS_DIM);
	if (!idTextStyle)
		return;
	pDlg->g_sFontStyle = (const TCHAR *)GetSymbolName(idTextStyle);

	if (pDlg == NULL)
	{
		pDlg = new CLeaderTextDlg;
		pDlg->Create(IDD_LEADER_TEXT);
	}
	pDlg->ShowWindow(SW_SHOW);
	acedGetAcadDwgView()->SetFocus();

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

	XPoint ptFirst;
	TDbSymbMultiLeader::TArrowStyle ar = TDbSymbMultiLeader::kNone;
	while(ads_getpoint(NULL, _T("\n请给出标注第一点<退出>: "), ptFirst) == RTNORM)
	{
		PickSet ssAll(SS_FREE);
		XPoint ptPiont = Ucs2Wcs(ptFirst);
		if(GetPipe(ptPiont, ssAll))//搜索第一点附近的管线
		{
			Entity entPipe;
			TCHAR szLayer[256];
			entPipe = ssAll[0L];
			entPipe.GetData(8, szLayer);
			pDlg->m_sLayer = szLayer;
			pDlg->SetCmbSysStyle();
			pDlg->OnSysStyleSet();
		}
		
		pDlg->UpdateData();
		XPointList lstVertexes;
		lstVertexes.Append(new XPoint(Ucs2Wcs(ptFirst)));
		ent.SetLeaderVertexes(lstVertexes);
		pDlg->DlgToObj(&ent);
		pDlg->m_bPost = TRUE;

		TLeaderEdJig jig(&ent);
		jig.SetOperCode(TLeaderEdJig::kLeader);
		
		int nRet = RTNORM;
		while(1)
		{
			if(!pDlg->IsWindowVisible())
			{
				pDlg->DestroyWindow();
				delete pDlg;
				return;
			}
			jig.SetPrompt(_T("\n输入引线位置或 [更改箭头型式(A)]<退出>: "));
			jig.SetKeyword(_T("` A"));
			jig.setUserInputControls(AcEdJig::kNullResponseAccepted);

			int kwd(0);
			nRet = jig.DoIt(&kwd);

			if (nRet == RTNORM)
				break;
			else if (nRet == RTKWORD)
			{
				if (kwd == 0)
				{
					if (pDlg->m_bGetText)
					{
						pDlg->GetPickText();
						pDlg->m_bGetText = FALSE;
					}
					pDlg->DlgToObj(&ent);
				}
				if (kwd != 0)
				{
					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);
				}
			} 
		}

		jig.SetKeyword(_T("`"));
		jig.SetOperCode(TLeaderEdJig::kTextLine);
		
		while(1)
		{
			if(!pDlg->IsWindowVisible())
			{
				pDlg->DestroyWindow();
				delete pDlg;
				return;
			}

			jig.SetPrompt(_T("\n点取文字基线位置<退出>: "));
			nRet = jig.DoIt();

			if (nRet == RTNORM)
				break;
			else if (nRet == RTKWORD)
			{
				if (pDlg->m_bPost)
				{
					if (pDlg->m_bGetText)
					{
						pDlg->GetPickText();
						pDlg->m_bGetText = FALSE;
					}
					pDlg->DlgToObj(&ent);
				}
			}
		}

		AcDbObjectId newId = ((TDbEntity *)ent.clone())->AddToCSpace(Adesk::kTrue);

		OPENOBJ_BEGIN(newId, AcDb::kForWrite, TDbSymbMultiLeader, pLeader);
		pLeader->setLayer(InitLayer(pDlg->m_sDimLayer));//设置标注图层
		OPENOBJ_END();

		if (pDlg->g_bLeadLine) //引出多线
		{
			OPENOBJ_BEGIN(newId, AcDb::kForRead, TDbSymbMultiLeader, pLeader);

			if (pLeader != NULL)
			{
				XPoint ptBase = pLeader->GetLeaderPoint();
				while (1)
				{
					XPoint ptAdd;
					TLeaderAddOtherPtJig jig2(&*pDlg, Ucs2Wcs(ptFirst), ptBase);
					jig2.SetPrompt(_T("\n输入其他的标注点<结束>: "));
					jig2.SetKeyword(_T("`"));

					nRet = jig2.DoIt();

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

					if (nRet == RTNORM)
					{
						ptAdd = jig2.GetPickPoint();
						
						XPointList pts;
						pLeader->GetLeaderVertexes(pts);
						pts.Append(new XPoint(ptAdd));
						
						if (pLeader->upgradeOpen() == Acad::eOk)
						{
							pLeader->SetLeaderVertexes(pts);
							pLeader->downgradeOpen();
						}
					}
					else if (nRet == RTNONE)
					{
						break;
					}
				}
			}
		OPENOBJ_END();
		}
		pDlg->AddToRecent();
		pDlg->m_bPost = FALSE;
	}
	pDlg->DestroyWindow();
	delete pDlg;
}


// 工具条升级标准
bool UpdateText(CString &sCmd)
{
	if (sCmd.Compare(_T("T88")) == 0)// twt
	{
		sCmd = _T("T98");
	}
	else if (sCmd.Compare(_T("T86")) == 0) // tch
	{
		sCmd = _T("T96");	
	}
	else if (sCmd.Compare(_T("T83")) == 0)// th
	{
		sCmd = _T("T93");
	}
	else if (sCmd.Compare(_T("t88")) == 0)// twt
	{
		sCmd = _T("t98");
	}
	else if (sCmd.Compare(_T("t86")) == 0) // tch
	{
		sCmd = _T("t96");
	}
	else if (sCmd.Compare(_T("t83")) == 0)// th
	{
		sCmd = _T("t93");
	}
	else
	{
		return false;
	}
	return true;
}

// 升级acad.pgp文件
void UpdateAcad()
{
	XString fullFile, fullFile2;
	if(!FindFile(_T("acad.pgp"), fullFile))
	{
        AfxMessageBox(_T("acad.pgp文件错误！"));
        return;
    }

	FILE *pFile = fopen(_AS(fullFile), "r");
	CString sOldText = fullFile.cs();
	int n = sOldText.ReverseFind('\\');
	CString sText = sOldText.Left(n + 1);
	fullFile2 = sText + _T("acadCopy.pgp");

	FILE *pFileCopy = fopen(_AS(fullFile2), "w");
	
    if(!pFile || !pFileCopy)
	{
        return;
	}
	while(!feof(pFile)) 
	{
        char sBuf[256]="";
        fgets(sBuf, 255, pFile);
        CString csTmp = sBuf;
        csTmp.TrimRight();
		int iIndex = csTmp.Find(_T("_"));
        if(iIndex > 0)
		{
            CString sCmdLeft = csTmp.Left(iIndex);
			CString sCmdRight = csTmp.Right(csTmp.GetLength() - iIndex);
			CString sCmd = sCmdLeft.Right(3);
			UpdateText(sCmd);
			sCmdLeft = sCmdLeft.Left(sCmdLeft.GetLength() - 3);
			csTmp = sCmdLeft + sCmd + sCmdRight;
		}
		csTmp +=_T("\n");
		fputs(_AS(csTmp), pFileCopy);
    }
	fclose(pFile);
	fclose(pFileCopy);

	remove(_AS(fullFile));
	rename(_AS(fullFile2), _AS(fullFile));
}

#include"TGAs.h"
// 升级tchdata.dbf文件
void UpdateTchData()
{
	CodeBase db;
    XString fullFile;
    if(!FindFile(_T("tchdata.dbf"), fullFile))
	{
        AfxMessageBox(_T("tchdata.dbf文件错误！"));
        return;
    }
    XDbfTable *pTable = db.Open(fullFile);
    if(!pTable) 
	{
        return;
	}
	
	CString sCmd, sCmdNew;
    for(pTable->MoveFirst();!pTable->IsEOF();pTable->MoveNext())
	{
		GET_FIELD(pTable, _T("Engcmd"), sCmd);
		int nIndex = sCmd.Find(_T("_"));
        if(nIndex > 0)
		{
			CString sCmdLeft = sCmd.Left(nIndex);
			sCmdLeft.TrimLeft();
			CString sCmdRight = sCmd.Right(sCmd.GetLength() - nIndex);
			if (!UpdateText(sCmdLeft))
			{
				continue;
			}
			sCmdNew = sCmdLeft + sCmdRight;
			SET_FIELD(pTable, _T("Engcmd"), (const TCHAR*)sCmdNew);
		}
	}
}
// 工具条升级
void UpdateToolBar()
{
	UpdateTchData();
	UpdateAcad();
}


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

// 拖曳显示点
class TDimensionEdJig : public AcEdJig
{
public:
    TDimensionEdJig(TDbDimension2 *pDim, const TCHAR *pszPrompt, const TCHAR *pszKeyword=NULL);
    ~TDimensionEdJig();
    int doIt();
    virtual DragStatus sampler();
    virtual Adesk::Boolean update();
    virtual AcDbEntity* entity() const;
    void Swap();
	
    int GetRetCode(int *kwordId=NULL) const;
    int m_nRetCode; //返回码
    const TCHAR *m_pszPrompt; //提示信息
	const TCHAR *m_pszKeyword; //关键字
	TDbDimension2 *m_pDrawEnt; //临时实体, 
    TDbDimension2 *m_pTemp; //临时实体, 用于m_nFlag==3
	
    XPoint m_ptDim;
    int m_nFlag; //0--尺寸方向, 1--尺寸线位置, 2--第二个标注点, 3--其它标注点
	
	//add by whl on 03/08/08
	DListStack<XPoint> ptStack;//标注点栈
	void Step();//当前点入栈
	void Undo();//撤消
	XPoint GetLastPoint();
	bool CanUndo();//是否可撤消
	//add by lgy 20120315 设置弧长标注标记
	void SetIsArcDim();
	
	BOOL m_bInView;	//add by lgy 20120503	保存标注是否是在视口中绘制
	int m_nPortNum;	//视口编号
	AcDbObjectIdArray m_aryViewPorts; // add by lgy 20120507 保存所有视口对象
	AcDbObjectId m_idDimNew;//新标注样式ID
	AcDbObjectId m_idDimOld;//老标注样式ID
	BOOL m_bSaveStyle;		//保存是不是设置新样式
protected:
	void FindAndRemoveSeg(XPoint pt);//由一标注点找出对应段并且正确去除之
	
private:
	//add by lxb on 2011/11/22
	AcEdInputPointMonitorEx  m_cMonitor;//监视器
	bool m_bIsArcDim;	//add by lgy 20120315	弧长标注标记
};

void GetDimLayByPipeSys(const CString &sLayer, CString &sDimLayer)
{
	if (sLayer == LAY_PIPE_FEED || sLayer == LAY_PIPE_FEED2 || sLayer == LAY_PIPE_FEED3)
	{
		sDimLayer = LAY_DIM_FEED;
	}
	else if (sLayer == LAY_PIPE_HEADFEED || sLayer == LAY_PIPE_HEADFEED2 || sLayer == LAY_PIPE_HEADFEED3)
	{
		sDimLayer = LAY_DIM_HEADFEED;
	}
	else if(sLayer == LAY_PIPE_HEADBACK || sLayer == LAY_PIPE_HEADBACK2 || sLayer == LAY_PIPE_HEADBACK3)
	{
		sDimLayer = LAY_DIM_HEADBACK;
	}
	else if(sLayer == LAY_PIPE_DIRT)
	{
		sDimLayer = LAY_DIM_DIRT;
	}
	else if(sLayer == LAY_PIPE_USELESS)
	{
		sDimLayer = LAY_DIM_USELESS;
	}
	else if(sLayer == LAY_PIPE_RAIN)
	{
		sDimLayer = LAY_DIM_RAIN;
	}
	else if(sLayer == LAY_PIPE_USED || sLayer == LAY_PIPE_USED2 || sLayer == LAY_PIPE_USED3)
	{
		sDimLayer = LAY_DIM_USED;
	}
	else if(sLayer == LAY_PIPE_FIRE || sLayer == LAY_PIPE_FIRE2 || sLayer == LAY_PIPE_FIRE3)
	{
		sDimLayer = LAY_DIM_HYDRANT;
	}
	else if(sLayer == LAY_PIPE_SPRINKLE || sLayer == LAY_PIPE_SPRINKLE2 || sLayer == LAY_PIPE_SPRINKLE3)
	{
		sDimLayer = LAY_DIM_SPRINKLE;
	}
	else if(sLayer == LAY_PIPE_COAGULATE)
	{
		sDimLayer = LAY_DIM_COAGULATE;
	}
	else if(sLayer == LAY_PIPE_DRINK)
	{
		sDimLayer = LAY_DIM_DRINK;
	}
	else if(sLayer == LAY_PIPE_PRESSDIRT)
	{
		sDimLayer = LAY_DIM_PRESSDIRT;
	}
	else if(sLayer == LAY_PIPE_PRESSUSELESS)
	{
		sDimLayer = LAY_DIM_PRESSUSELESS;
	}
	else if(sLayer == LAY_PIPE_PRESSRAIN)
	{
		sDimLayer = LAY_DIM_PRESSRAIN;
	}
	else if(sLayer == LAY_PIPE_USER1)
	{
		sDimLayer = LAY_DIM_USER1;
	}
	else if(sLayer == LAY_PIPE_USER2)
	{
		sDimLayer = LAY_DIM_USER2;
	}
	else if (sLayer == LAY_PIPE_USER3)
	{
		sDimLayer = LAY_DIM_USER3;
	}
	else if (sLayer == LAY_PIPE_USER4)
	{
		sDimLayer = LAY_DIM_USER4;
	}
	else if (sLayer == LAY_PIPE_USER5)
	{
		sDimLayer = LAY_DIM_USER5;
	}
	else if (sLayer == LAY_PIPE_USER6)
	{
		sDimLayer = LAY_DIM_USER6;
	}
	else if (sLayer == LAY_PIPE_USER7)
	{
		sDimLayer = LAY_DIM_USER7;
	}
	else if (sLayer == LAY_PIPE_USER8)
	{
		sDimLayer = LAY_DIM_USER8;
	}
	else if(sLayer == LAY_PIPE_OTHER)
	{
		sDimLayer = LAY_DIM_OTHER;
	}
}

//add by lgy 20120509	判断点在不在实体上
//pt:模型空间中的点
//返回值:如果pt在当前图纸中的莫个实体上，返回TRUE,否则返回FALSE
BOOL GetIsOnEntity(XPoint pt)
{
	BOOL bOn = FALSE; // 用来保存点是否在实体上

	AcDbBlockTable *pTable = NULL;
	Acad::ErrorStatus es = acdbHostApplicationServices()->workingDatabase()->getSymbolTable(pTable, AcDb::kForRead);
	if (es != Acad::eOk)
	{
		return bOn;
	}

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

	AcDbBlockTableRecordIterator *pBlockIterator = NULL;
	if (Acad::eOk == pBlockTableRecord->newIterator(pBlockIterator))
	{
		AcDbEntity *pEnt = NULL;
		for (pBlockIterator->start(); !pBlockIterator->done(); pBlockIterator->step())
		{
			if (Acad::eOk == pBlockIterator->getEntity(pEnt, AcDb::kForRead))
			{
				XPoly2D polyEnt;

				if (pEnt->isKindOf(TDbCurveEntity::desc())) // 大部分上华对象
				{
					TDbCurveEntity *pTgCurveEntity = (TDbCurveEntity*)pEnt;
					pTgCurveEntity->GetClipBoundary(polyEnt);
				}
				else if (pEnt->isKindOf(TDbEntity::desc())) // 大部分上华对象
				{
					TDbCurveEntity *pTgEntity = (TDbCurveEntity*)pEnt;
					pTgEntity->GetClipBoundary(polyEnt);
				}
				else // CAD对象
				{
					PickSet entTempSet(SS_FREE);
					entTempSet += pEnt->objectId();
					if (entTempSet.Length() == 0)
					{
						continue;
					}

					XPoly2D polyTemp(entTempSet[0L]);
					polyEnt = polyTemp;
				}

				int nSegs = polyEnt.TotalSegments();
				for (int k=0; k<nSegs; k++)
				{
					XCurveSegment cvSeg;
					polyEnt.Nth(k, cvSeg);

					XPoint ptProject;
					cvSeg.ProjectToMe(pt, ptProject);

					double d2PtDistance = ptProject.Distance2d(pt);
					if (d2PtDistance < 10 + _DIST_SNAP)
					{
						bOn = TRUE;
						break;
					}
				}

				pEnt->close();
				if (bOn) // 点在实体上
				{
					break;
				}
			}
		}

		delete pBlockIterator;
		pBlockIterator = NULL;
	}

	pTable->close();
	pBlockTableRecord->close();
	return bOn;
}

XPoint ChangePtFromUCSToWCS(XPoint pt, XPoint ptOrg, XVector3D vtX, XVector3D vtY)
{
	AcGePoint2d ptOrigin(ptOrg.x, ptOrg.y),
		ptResult = pt.AsAcGePoint2d();
	AcGeVector2d xAxis(vtX.x, vtX.y),
		yAxis(vtY.x, vtY.y);

	AcGeMatrix2d mat2d;
	mat2d = mat2d.alignCoordSys(AcGePoint2d(0, 0), AcGeVector2d(1, 0), AcGeVector2d(0, 1), ptOrigin, xAxis, yAxis);

	ptResult.transformBy(mat2d);
	return XPoint(ptResult.x, ptResult.y);
}

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

		int nNumber = pViewPort->number();
		if (nNumber == 1)
			continue;

		double dWidth = pViewPort->width(),
			dHeight = pViewPort->height(),
			dTwist = pViewPort->twistAngle();
		dScale = pViewPort->customScale();

		XPoint ptMSCenter = pViewPort->viewCenter(),
			ptPSCenter = pViewPort->centerPoint();

		AcGePoint3d ptVPOrg;
		AcGeVector3d vtVPX, vtVPY;
		pViewPort->getUcs(ptVPOrg, vtVPX, vtVPY);

		XPoly2D poly;
		if (!pViewPort->isNonRectClipOn())
		{
			XRectAngle rect(ptPSCenter, dWidth, dHeight);
			rect.AsPoly2D(poly);
		}
		else
		{
			AcDbObjectId idPLine = pViewPort->nonRectClipEntityId();
			OPENOBJ_BEGIN(idPLine, AcDb::kForRead, AcDbPolyline, pPLine);
			if (pPLine == NULL)
			{
				continue;
			}

			PolyConvert(*pPLine, poly);
			OPENOBJ_END();
		}
		poly.SetClosed();
		poly.SetElevation(0.0);

		if ((pt&poly) == PR_INSIDE)		// 在视口内
		{
			if (!pViewPort->isOn())
				continue;

			XPoint ptView, ptView2MS;
			double dAngle = ads_angle(ptPSCenter, pt),	// 点取的点跟视口中心点的角度
				dDistance = ptPSCenter.Distance2d(pt);
			ads_polar(ptMSCenter, dAngle, dDistance/dScale, ptView);

			if (fabs(dTwist) > _angSnap)
				ptView2MS = ChangePtFromUCSToWCS(ptView, XPoint(ptVPOrg), XVector3D(vtVPX), XVector3D(vtVPY));
			else
				ptView2MS = ptView;

			bOnEnt = GetIsOnEntity(ptView2MS);	// 判断点是否在实体上

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

	return 0;
}

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

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

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

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

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


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

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

	m_aryViewPorts.setLogicalLength(0);
}

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

// 开始执行拖动
int TDimensionEdJig::doIt()
{
    setDispPrompt(m_pszPrompt);
        try 
		{
            m_nRetCode = drag();
        } 
		catch(...)
		{
            m_nRetCode=AcEdJig::kCancel;
        }
     return GetRetCode();
}

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

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

	if (m_pszKeyword) setKeywordList(m_pszKeyword);
    XPoint ptTemp;
    if(m_nFlag==0) 
	{	
		stat=acquirePoint(ptTemp, m_pDrawEnt->GetLocation().AsAcGePoint3d());
	}
	else  if((m_nFlag == 1) || (m_nFlag == 2)) 
	{
		//add by lxb on 2011/11/22
		//获取当前光标坐标
		// sg modify 120706，不知道为什么在64位下，用m_cMonitor.GetCursorPos()得到的鼠标当前位置点，始终是原点，换一种方法实现
		TADSGePoint3d ptCur;
#ifndef _WIN64
		ptCur = m_cMonitor.GetCursorPos();
#else
		GetWcsCursor(ptCur);
#endif
		
		//辅助计算直线
		XLine line1(ptStack[0],ptStack[1]);
		ads_real rAng = line1.Direction();
		XPoint pt;
		ads_polar(ptCur, rAng + 0.5 * PI, 100.0, pt);
		XLine line2(ptCur, pt);

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

		//modify by lgy 20120314	弧长标注中开始选中标注弧长时jig显示出一条多余的线
		//stat = acquirePoint(ptTemp,ptBase);
		if (!m_bIsArcDim)
		{
			stat = acquirePoint(ptTemp,ptBase);
		}
		else
		{
			stat = acquirePoint(ptTemp);
		}
	}
    else if(m_nFlag==3) 
	{
		//modidfied by whl on 03/08/08
		XPoint ptLast=GetLastPoint();
        stat=acquirePoint(ptTemp, ptLast);
    } 
	else if(m_nFlag==4)
	{
        XPoint ptLast;
        xg_getvar(_T("LASTPOINT"), ptLast);
        ptLast = Ucs2Wcs(ptLast);
        stat=acquirePoint(ptTemp, ptLast);
	}

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

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

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

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

        }
    } 
	else if(m_nFlag==2)
	{ //修改标注位置
        AcDbIntArray indices;
        indices.append(3);
        AcGePoint3dArray ptArray;
        m_pDrawEnt->getStretchPoints(ptArray);
        ASSERT(ptArray.length()>3);
        AcGeVector3d vtOffset=m_ptDim.AsAcGePoint3d()-ptArray[3];
        m_pDrawEnt->moveGripPointsAt(indices, vtOffset);
    } 
	else if(m_nFlag==3) 
	{//modified by whl on 03/08/08
        ASSERT(m_pTemp);
        CopyObject(*m_pDrawEnt, *m_pTemp);
		if(CanUndo())
		{
			if(!m_pTemp->AddSegment(m_ptDim))
				return Adesk::kFalse;
		}
		else
		{
			m_pTemp->SetRotation(ads_angle(m_ptDim, m_pTemp->GetLocation())+PI);
			double nVal=m_ptDim.Distance2d(m_pTemp->GetLocation());
			if(m_pTemp->IsValidSegment(nVal))
				m_pTemp->SetSegment(0, nVal);
		}
        ASSERT(m_pTemp && m_pTemp->IsValid());
    } 
	else if(m_nFlag==4) 
	{
        ASSERT(m_pTemp);
        CopyObject(*m_pDrawEnt, *m_pTemp);
		m_pTemp->AddSegment(m_ptDim);
	}
    ASSERT(m_pDrawEnt && m_pDrawEnt->IsValid());
	return Adesk::kTrue;
}

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

// add by xly on 100915 设置符号标注的图层切换属性
extern TARCH_IMPEXP BOOL g_bTextDefaultLayer;
// add by xly 0n 100915 设置实体的图层并将实体添加到图纸中
AcDbObjectId AddToSpace(Adesk::Boolean bClosed, TDbEntity *pEntSymb, CString &sDimLayer) 
{  
	const TCHAR *pszLayer = pEntSymb->GetDefaultLayer(); 
	
	// 设置在默认图层
	if(pszLayer && g_bTextDefaultLayer) 
	{ 
		AcDbObjectId idLayer = InitLayer(pszLayer, TRUE);
		InitLayer(sDimLayer, TRUE);
		
		// modify by xly on 101028 没有作用可以删除，添加一个ID是否可用的判断
		//SetLayer(pszLayer); 
		//pEntSymb->setLayer(pszLayer);
		if (!sDimLayer.IsEmpty())
		{
			pEntSymb->setLayer(sDimLayer);
		}
		else if (idLayer.isValid())
		{
			pEntSymb->setLayer(pszLayer);
		}
	}
	
	return AddToCurrentSpace(pEntSymb, bClosed, Adesk::kTrue); 
}

// Command: 逐点标注
// 支持尺寸自调
//////////////////////////////////////////////////////////////////////////
//modified by cwk on 060914
void DimContinue()
{
	// add by lgy 20120507，保存当前空间是模型空间还是图纸空间
	// 0：图纸空间；1：模型空间
	int iTitleMode = 0;
	if (xg_getvar(_T("TILEMODE"), &iTitleMode) != RTNORM)
	{
		return;
	}

	BOOL b = FALSE;
    InitLayer(LAY_DIM, TRUE);
    TDbDimension2 dim;
    XPoint ptStart;
	XPointList lstAddPoint;	//wcs
	XPointList lstBasePoint;//ucs

    XPushVar<int> osmode(_T("OSMODE"), GetFullOsMode(OS_INT|OS_END));

    if (XGetPoint(NULL, _T("\n起点"), ptStart)==RTNORM)
	{
        XPushVar<int> osmode1(_T("OSMODE"), GetFullOsMode(OS_PER|OS_INT|OS_END));
		lstBasePoint.Append(new XPoint(ptStart));
        ptStart=Ucs2Wcs(ptStart);

		CString sDimLayer;
		PickSet ss(SS_FREE);
		if (GetPipe(ptStart, ss))
		{
			Entity entPipe = ss[0l];
			TCHAR szLayer[256];
			entPipe.GetData(8, szLayer);
			CString sLayer = szLayer;
			GetDimLayByPipeSys(sLayer, sDimLayer);

		}
    
		TDbDimension2 *pDim = &dim;
		// add by cwk on 060915
		if (pDim->GetSegmentNum() >= 1) 
		{
			pDim->RemoveSegment(1);
		}

		// modify by xly on 110107 支持图层切换
        // pDim->setLayer(LAY_DIM);
        pDim->SetDist2DimLine(6.0);
        pDim->SetLocation(ptStart);
        pDim->AppendSegment(2.0*_DIST_SNAP);
		// modify by lgy 20120507 保存标注样式id，以用来在视口空间中是否需要转换
        // pDim->SetStyleId(InitDimStyle(DS_LINEAR));
		AcDbObjectId idDimStyle = InitDimStyle(DS_LINEAR);
		pDim->SetStyleId(idDimStyle);

		// sg add 120410，增加布局转角的设置，解决UCS下，文字方向错误的问题
		pDim->SetLayoutRotation(Ucs2Wcs(0.0));
  
		TDimensionEdJig jig(pDim, _T("\n第二点<退出>: "));
		
		//add by lgy 20120507	如果当前是图纸空间
		BOOL bExist = FALSE;		//如果添加的新的标注样式已经存在，默认不添加不存在
		if (iTitleMode == 0)		//当前空间是图纸空间
		{
			AcDbObjectIdArray aryViewPorts;
			{
				AcDbObjectId spaceId = acdbCurDwg()->currentSpaceId();
				OPENOBJ_BEGIN(spaceId, AcDb::kForRead, AcDbBlockTableRecord, pPaperSpace);
				if (pPaperSpace != NULL)
				{
					AcDbBlockTableRecordIterator *pRecIter = NULL;
					if (pPaperSpace->newIterator(pRecIter)==Acad::eOk && pRecIter!=NULL)
					{
						for (pRecIter->start(); !pRecIter->done(); pRecIter->step())
						{
							AcDbEntity *pEntity = NULL;
							if (pRecIter->getEntity(pEntity, AcDb::kForRead)==Acad::eOk && pEntity!=NULL) 
							{
								if (pEntity->isKindOf(AcDbViewport::desc()))
									aryViewPorts.append(pEntity->objectId());

								pEntity->close();
							}
						}
						delete pRecIter;
					}
					pPaperSpace->close();
				}
				OPENOBJ_END();
			}

			double dScale = 1.0;
			BOOL bOnEnt = FALSE;
			int nNum = GetPtOnWhichPort(ptStart, dScale, bOnEnt, aryViewPorts);	//得到视口编号和视口比例
			
			if (nNum > 1 && bOnEnt)		//不是最外层的大视口
			{
				jig.m_bInView = TRUE;
				jig.m_aryViewPorts.append(aryViewPorts);
				jig.m_nPortNum = nNum;
				jig.m_idDimOld = idDimStyle;

				//获得原来标注样式在标注样式表中的名字
				CString strName;
				AcDbDimStyleTableRecord *pNewDimStyle = NULL;
				OPENOBJ_BEGIN(idDimStyle, AcDb::kForRead, AcDbDimStyleTableRecord, pDimStyle);
				if (pDimStyle != NULL)
				{
					const TCHAR *pName = NULL;
					pDimStyle->getName(pName);
					strName = pName;
					strName.Format(_T("%s_%.0f"), strName, 1/dScale);
					pNewDimStyle = (AcDbDimStyleTableRecord*)pDimStyle->clone();
				}
				OPENOBJ_END();

 				AcDbDimStyleTable *pDimStyleTbl = NULL;
				Acad::ErrorStatus es = Acad::eOk;
				es = acdbHostApplicationServices()->workingDatabase()->getDimStyleTable(pDimStyleTbl, AcDb::kForWrite);
				if (es != Acad::eOk)
				{
					delete pNewDimStyle;
					pNewDimStyle = NULL;
					return;
				}

				AcDbObjectId id;
				if (!pDimStyleTbl->has(strName))
				{
					if (pNewDimStyle != NULL)
					{
						pNewDimStyle->setName(strName);
						pNewDimStyle->setDimlfac(1/dScale);

						pDimStyleTbl->add(id, pNewDimStyle);
						pDim->SetStyleId(id);
						jig.m_idDimNew = id;
						pNewDimStyle->close();
					}
				}
				else
				{
					if (pNewDimStyle != NULL)
					{
						delete pNewDimStyle;
						pNewDimStyle = NULL;
					}
					pDimStyleTbl->getAt(strName, id);
					pDim->SetStyleId(id);
					jig.m_idDimNew = id;
					bExist = TRUE;
				}
				pDimStyleTbl->close();
			}
		}

		jig.Step();//add by whl
        jig.m_nFlag=0;
        jig.doIt();
		//modify by lgy 20120510 逐点标注jig时如果退出了命令需要删除添加的标注样式
        //if(jig.GetRetCode()!=RTNORM)
         //   return;
		if (jig.GetRetCode() != RTNORM)
		{
			if (!bExist)
			{
				OPENOBJ_BEGIN(jig.m_idDimNew, AcDb::kForWrite, AcDbDimStyleTableRecord, pRecord);
				if (pRecord)
				{
					pRecord->erase();
				}
				OPENOBJ_END();
			}
			return;
		}

        if(!pDim->IsValid())
		{
            adsout << _T("请正确点取!");
            return;
        }

		//add by lgy 20120509	如果标注样式没有考虑视口，需要将之前添加到标注样式表中的
		//标注样式删除掉
		if (!jig.m_bSaveStyle && !bExist)
		{
			OPENOBJ_BEGIN(jig.m_idDimNew, AcDb::kForWrite, AcDbDimStyleTableRecord, pRecord);
			if (pRecord)
			{
				pRecord->erase();
			}
			OPENOBJ_END();
		}
        /*
        static int nAnswer=Q_NO;
        nAnswer=YesNoQuestion(_T("\n是否同时作为标注点"), nAnswer);
        if(nAnswer==RTCAN)
            return;
        */
        XPoint ptSec=jig.m_ptDim;
		XPoint ptAdd;
		XPoint ptBase;

		ptAdd = ptSec;
		lstAddPoint.Append(new XPoint(ptAdd));
		ptBase = Wcs2Ucs(ptAdd);
		lstBasePoint.Append(new XPoint(ptAdd));
LAB_REINPUT:
		jig.m_pszPrompt=_T("\n请点取尺寸线位置或 [更正尺寸线方向(D)]<退出>: ");
		jig.Step();//add by whl
        jig.m_nFlag=1;
        jig.m_pszKeyword=_T("D");
        int nKeywordIndex=0;
        INITGET_BEG(-1, _T("D"));
        jig.doIt();
        INITGET_END();
        int nRetCode=jig.GetRetCode();
        //modify by lgy 20120510 
		//if(nRetCode==RTCAN)
        //    return;
		if (nRetCode == RTCAN)
		{
			if (!bExist)
			{
				OPENOBJ_BEGIN(jig.m_idDimNew, AcDb::kForWrite, AcDbDimStyleTableRecord, pRecord);
				if (pRecord)
				{
					pRecord->erase();
				}
				OPENOBJ_END();
			}
			return;
		}

        else if(nRetCode==RTKWORD) 
		{
            Entity entDir;
            double nDirection=0.0;
			if(entDir.FilterSelect(_T("\n选择墙或线确定尺寸方向<退出>:"), 
                RBList(RTDXF0, _T("LINE,ATS_WALL,ATS_CURTAIN_WALL"), NULL), XPoint())==RTNORM) 
			{
                if(entDir.Is(_T("LINE")))
				{
                    XLine ln(entDir);
                    nDirection=ln.Direction();
                } 
				else 
				{
                    OPENOBJ_BEGIN(entDir, AcDb::kForRead, TDbWall, pWall);
                    if(pWall)
                        nDirection=pWall->XLine::Direction();
                    OPENOBJ_END();
                }
            } 
			else 
                return;
 
            XVector3D vt=ptSec-ptStart;
            double nVal = (vt&XVector3D(cos(nDirection), sin(nDirection)));
            pDim->SetRotation(nDirection);
            pDim->SetSegment(0, nVal);
            goto LAB_REINPUT;
        }
 LAB_RE:
// 		GEOAPI BOOL g_szArxContext;
// 		if(!g_szArxContext)
// 			return;
		AcDbObjectId m_id;
		if(pDim->IsValid() && jig.GetRetCode()!=RTCAN) 
		{
            TDbDimension2 *pDimNew = (TDbDimension2 *)pDim->clone();
            ASSERT(pDimNew);
            if(g_nDimAdjust) pDimNew->AdjustDim(g_nDimAdjust!=2);

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

			// modify by xly on 110107 支持图层切换
            //m_id = pDimNew->AddToCSpace(Adesk::kTrue);
			m_id = AddToSpace(Adesk::kTrue, (TDbEntity*)pDimNew, sDimLayer);
        }
		TDbDimension2 *pDimTemp;
		acdbOpenObject(pDimTemp,m_id,AcDb::kForRead);
		int nRet;	
		XString szPrompt;
		while(1)
		{
			int nLen = lstAddPoint.Length();
			_stprintf(szPrompt, _T("\n请输入其他标注点或 [撤消上一标注点(U)]<结束>: "));

			INITGET_BEG(0, _T("U R"));
			nRet = acedGetPoint(ptBase, szPrompt, ptAdd);
			INITGET_END();
			if(nRet == RTNORM)
			{
				ptBase = ptAdd;
				ptAdd = Ucs2Wcs(ptAdd);
				if(pDimTemp->upgradeOpen() == Acad::eOk) 
				{
					if(!pDimTemp->AddSegment(ptAdd))
						adsout << _T("\n点取位置不合适!");
					else
					{
						lstAddPoint.Append(new XPoint(ptAdd));
						lstBasePoint.Append(new XPoint(ptBase));
						if(g_nDimAdjust)//add by whl on 050530
							pDimTemp->AdjustDim(g_nDimAdjust!=2);
					}

					pDimTemp->downgradeOpen();
				}
			}
			else if(nRet == RTKWORD)
			{
				XString sKey;
				acedGetInput(sKey);
				if(sKey[0] == _T('R'))
					acedGetPoint(NULL, _T("\n参考点:"), ptBase);
				else if(sKey[0] == _T('U'))
				{
					if(pDimTemp->upgradeOpen() == Acad::eOk) 
					{
						if(nLen > 0)
						{
							ptAdd = *lstAddPoint.Tail();
							lstAddPoint.Remove(nLen-1);
							pDimTemp->HitTestOnPoint(ptAdd);
							pDimTemp->FindAndRemoveSegment(ptAdd);
							lstBasePoint.Remove(nLen);
							ptBase = *lstBasePoint.Tail();
							if(g_nDimAdjust)//add by whl on 050530
								pDimTemp->AdjustDim(g_nDimAdjust!=2);

						}
						pDimTemp->downgradeOpen();
					}
				}
				if (lstAddPoint.Length() <= 0)
				{
					b = FALSE;
					if(pDimTemp->upgradeOpen() == Acad::eOk) 
					{
						pDimTemp->erase();
					}
					jig.m_pszKeyword=NULL;
					BOOL bFirst=TRUE;
					jig.m_nFlag=3;
					jig.m_pTemp=(TDbDimension2 *)pDim->clone();
					jig.Undo();	//add by cwk on 060918
					jig.m_pszKeyword=_T("U");
					jig.m_pszPrompt = _T("\n请输入第二标注点<结束>: ");
					int nRet=jig.doIt();
					if(nRet==RTNORM)
					{
						jig.Swap();
						jig.Step();
						ptAdd = jig.m_ptDim;
						lstAddPoint.Append(new XPoint(ptAdd));
						ptBase = Wcs2Ucs(ptAdd);
						lstBasePoint.Append(new XPoint(ptBase));
						if(g_nDimAdjust)//add by whl on 050530
							pDimTemp->AdjustDim(g_nDimAdjust!=2);
					}
					else
						break;
					goto  LAB_RE;					
				}
			}
			else if (nRet == RTCAN)
			{	
				if(pDimTemp->upgradeOpen() == Acad::eOk) 
				{
					pDimTemp->erase();
					pDimTemp->downgradeOpen();
				}
				return;
			}
			else
				break;
		}
		pDimTemp->close();
	}
}