#include "stdafx.h"

//#include <DbObject.h>
//#include <arxtools.h>
#include <rxregsvc.h>
//#include <ImageDc.h>
#include <actrans.h>
//#include <dbwall.h>

#include <vector>
#include <algorithm>
#include <functional>
#include <dbxline.h>

#include "tapi.h"
#include "TelDef.h"
#include "XBlock.h"



 
#define TPI 6.283185307
#define  MINL  1.0E-6
#define  FEQU(a,b)  (fabs((a) - (b)) < MINL)
#define E6TOL 1.e-6



//CTemporaryResourceOverride

const char *GetRegLocation1()
{
#if (ADS>14)
	return "SoftWare\\Tangent\\Tel2k";
#else
	return "SoftWare\\Tangent\\Tel14";
#endif

}

// cet 2016.7.20 add 获得外部参照实体转换矩阵
AcGeMatrix3d GetExternalEntityTransform(Entity ent)
{
	AcDbObjectId idTemp;
	acdbGetObjectId(idTemp, ent.name);
	AcGeMatrix3d matRet = AcGeMatrix3d::kIdentity;
	AcDbBlockTable *pTbl = NULL;
	acdbCurDwg()->getBlockTable(pTbl, AcDb::kForRead);
	if (pTbl != NULL)
	{
		bool bFlag = false;
		AcDbBlockTableIterator *it = NULL;
		pTbl->newIterator(it);
		for (it->start(); !it->done() && !bFlag; it->step())
		{
			AcDbBlockTableRecord *pRcd = NULL;
			it->getRecord(pRcd, AcDb::kForRead);
			if (pRcd != NULL && pRcd->isFromExternalReference())
			{
				AcGeMatrix3d mat = AcGeMatrix3d::kIdentity;
				AcDbObjectIdArray arrId;
				pRcd->getBlockReferenceIds(arrId);
				if (arrId.length() != 1)
				{
					pRcd->close();
					continue;
				}
				AcDbBlockReference *pRef = NULL;
				acdbOpenObject(pRef, arrId[0], AcDb::kForRead);
				if (pRef != NULL)
				{
					mat = pRef->blockTransform();
					pRef->close();
				}
				else
				{
					pRcd->close();
					continue;
				}
				AcDbBlockTableRecordIterator *itRec = NULL;
				pRcd->newIterator(itRec);
				for (itRec->start(); !itRec->done() && !bFlag; itRec->step())
				{
					AcDbObjectId id;
					itRec->getEntityId(id);
					if (id = idTemp)
					{
						matRet = mat;
						bFlag = true;
						break;
					}
				}
				delete itRec;
			}
			pRcd->close();
		}
		delete it;
		pTbl->close();
	}
	return matRet;
}

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

int DragRotate(PickSet &ss, XPoint Pt, const TCHAR* szPmt)
{
	ss.Redraw(3);      // 将实体隐藏
//	DragPickSet ssDrag(Pt, ss);
	XPoint ptDrag;
	g_ptDragCenter = Pt;
	ads_initget(RSG_OTHER, NULL);
	int rc = ads_draggen(ss, szPmt, 0, DragRotationAction, ptDrag);
	if(rc==RTNORM) {
		ads_real nRot=CT_std_angle(ads_angle(Ucs2Wcs(g_ptDragCenter), Ucs2Wcs(ptDrag)))*180/PI;
		XPushVar<int> vOsMode(_T("OSMODE"), 0);
		return ads_command(RTSTR, _T(".ROTATE"), RTPICKS, (TLong_ptr *)ss, RTSTR, _T(""),
			 RT3DPOINT, &g_ptDragCenter, RTREAL, nRot, RTNONE);
	} 
	else if(rc==RTSTR) {
		TCHAR sInput[80]=_T("");
		ads_getinput(sInput);
		if(!sInput[0]) 
			return RTERROR;
		ads_real nRot=_tstof(sInput);
		if(fabs(nRot)<_angSnap)
			return RTERROR;
		XPushVar<int> vOsMode(_T("OSMODE"), 0);
		return ads_command(RTSTR, _T(".ROTATE"), RTPICKS, (TLong_ptr *)ss, RTSTR, _T(""),
			RT3DPOINT, &g_ptDragCenter, RTREAL, nRot, RTNONE);
	}
	else
		ss.Redraw(4);// 将实体恢复
	return RTNORM;
}

static int DragMoveAction(ads_point pt, ads_matrix mt)
{
   ads_real nRot=ads_angle(g_ptDragCenter, pt);
   Ucs2Wcs(g_ptDragCenter).GetMoveMatrix(pt, mt);
   return RTNORM;
}

int DragMove(PickSet &ss, XPoint Pt, const TCHAR* szPmt)
{
	ss.Redraw(2);      // 将实体隐藏
	XPoint ptDrag;
	g_ptDragCenter = Pt;
	ads_initget(RSG_OTHER, NULL);
	int rc = ads_draggen(ss, szPmt, 0, DragMoveAction, ptDrag);
	acedGetAcadDwgView()->RedrawWindow();
	if(rc==RTNORM) {
		XPushVar<int> vOsMode(_T("OSMODE"), 0);
		return ads_command(RTSTR, _T(".MOVE"), RTPICKS, (TLong_ptr *)ss, RTSTR, _T(""),
			 RT3DPOINT, &g_ptDragCenter, RT3DPOINT, &ptDrag, RTNONE);
	} 
	else
		ss.Redraw(4);// 将实体恢复
	return rc;
}



// 给定1点, 得到该点上的墙
Entity GetPtOnWall(XPoint pt)
{
 	RBList rbMask = ads_buildlist( -4, _T("<or"),
	   -4, _T("<and"), RTDXF0, _T("LINE"), 8, LAY_WALL, -4, _T("and>"),  
	   -4, _T("<and"), RTDXF0, _T("ARC"), 8, LAY_WALL, -4, _T("and>"),  
	   -4, _T("or>"), NULL);
 	PickSet ss(SS_FREE);
	XPoint ptTemp1, ptTemp2;
	ptTemp1.x = pt.x - 5;
	ptTemp1.y = pt.y + 5;
	ptTemp2.x = pt.x + 5;
	ptTemp2.y = pt.y - 5;
	ss.Get(_T("C"), ptTemp1, ptTemp2, rbMask);
	int len2 = ss.Length();
	if(ss.Length() != 1)
		return Entity();
	return ss[0L];
}

// 给定1点, 得到该点上的窗, 柱
Entity GetPtOnWindow(XPoint pt)
{
	RBList rbMask = ads_buildlist( -4, _T("<or"),
	   -4, _T("<and"), RTDXF0, _T("INSERT"), 8, LAY_WIN, -4, _T("and>"),  
	   -4, _T("<and"), RTDXF0, _T("INSERT"), 8, LAY_COLU, -4, _T("and>"),  
	   -4, _T("or>"), NULL);
 	PickSet ss(SS_FREE);
	XPoint ptTemp1, ptTemp2;
	ptTemp1.x = pt.x - 5;
	ptTemp1.y = pt.y + 5;
	ptTemp2.x = pt.x + 5;
	ptTemp2.y = pt.y - 5;
	ss.Get(_T("C"), ptTemp1, ptTemp2, rbMask);
	int len2 = ss.Length();
	if(ss.Length() != 1)
		return Entity();
	return ss[0L];
}

BOOL IsPtOnSegment(XPoint pt, XCurveSegment seg, double nSnap)
{
	if(seg.Is(CURVE_LINE)){
		XLine line(1);
		line = seg.GetLine();
		return IsPtOnLine(pt, line, nSnap);
	}
	else if(seg.Is(CURVE_ARC)){
		XArc arc = seg.GetArc();
		return IsPtOnArc(pt, arc, nSnap);
	}
	else if(seg.Is(CURVE_CIRCLE)){
		XCircle cir = seg.GetCircle();
		return IsPtOnCircle(pt, cir, nSnap);
	}
	else
		return FALSE;
}

BOOL IsPtOnLine(XPoint pt, XLine line, double nSnap)
{
	ads_real l1,l2,l12;
	double dd = pt.Distance(&line);
	if(fabs(pt.Distance(&line)) > nSnap) return FALSE;
	l1=ads_distance(pt, line.StartPoint());
	l2=ads_distance(pt, line.EndPoint());
	l12=line.GetLength();
	if(fabs(l1 + l2 - l12) <= nSnap) return TRUE;
	return FALSE;
}

BOOL IsPtOnCircle(XPoint pt, XCircle circle, double nSnap)
{
	double r=pt.Distance(circle.GetCenterPt()) - circle.GetRadius();
	if(fabs(r) < nSnap)
		return TRUE;
	else
		return FALSE;
}

BOOL IsPtOnArc(XPoint pt, XArc arc, double nSnap)
{
	double ang = ads_angle(arc.GetCenterPt(), pt);
	double rad = arc.GetRadius();
	double ff = ads_distance(arc.GetCenterPt(), pt);
	if(fabs(ads_distance(arc.GetCenterPt(), pt) - rad) > nSnap)
       return FALSE;
	if( arc.GetStarAngle() < arc.GetEndAngle() )  {
	  if(ang>arc.GetStarAngle() && ang<arc.GetEndAngle())  return TRUE;
	}
	else  {
	  if(ang>arc.GetStarAngle() || ang<arc.GetEndAngle())  return TRUE;
	}
	return FALSE;
}




//void MakeVisible(PickSet &ss, bool bTrue)
//{
//	long len=ss.Length();
//	for(long i=0;i<len;i++)		    {
//        Entity ent=ss[i];
//        OPENOBJ_BEGIN(ent, AcDb::kForWrite, AcDbEntity, pEnt);
//        if(pEnt) pEnt->setVisibility(bTrue? AcDb::kVisible : AcDb::kInvisible);
//        OPENOBJ_END();
//	}
//}






//***************************************************************
//                          arx  函数
//****************************************************************

BOOL IsLayerOn(const TCHAR*szLayerName)
{
// 判断图层是开是关
	AcDbLayerTable *pLayertable;
	AcDbLayerTableRecord *pLayerRec;
	acdbCurDwg()->getLayerTable(pLayertable, AcDb::kForRead);
	if(!pLayertable)
		return FALSE;
	if((pLayertable->getAt(szLayerName, pLayerRec, AcDb::kForRead)) == Acad::eOk)	{
		pLayertable->close();
		if (pLayerRec->isOff() == Adesk::kTrue){
			pLayerRec->close();
			return FALSE;
		}
		else{
			pLayerRec->close();
			return TRUE;
		}
		pLayerRec->close();
	}
	else
		pLayertable->close();
	return TRUE;
}

BOOL SetLayerOnOff(const TCHAR*szLayerName, BOOL bOpen)
{
	AcDbLayerTable *pLayertable = NULL;
	AcDbLayerTableRecord *pLayerRec = NULL;
	acdbCurDwg()->getLayerTable(pLayertable, AcDb::kForRead);
	if(!pLayertable)
		return FALSE;
 
	if((pLayertable->getAt(szLayerName, pLayerRec, AcDb::kForWrite)) == Acad::eOk)	{
		if(bOpen) 
			pLayerRec->setIsOff(Adesk::kFalse);  // 打开
		else
			pLayerRec->setIsOff(Adesk::kTrue);   // 关
		pLayerRec->close();
		pLayertable->close();
	}
	else
		pLayertable->close();
	return TRUE;
}
 


BOOL AddLayer(const TCHAR* szLayer, int iColor)
{
	BOOL bHasIt;
	AcDbLayerTable *pLayerTable;
	AcDbLayerTableRecord *pLayerTableRecord = new AcDbLayerTableRecord;
	AcCmColor color;
    color.setColorIndex(iColor);

	acdbCurDwg()->getLayerTable(pLayerTable, AcDb::kForWrite);
	bHasIt = pLayerTable->has(szLayer);
	if(!bHasIt){
		pLayerTableRecord->setName(szLayer);
		pLayerTableRecord->setColor(color);
		pLayerTable->add(pLayerTableRecord);
	}
	else{
		pLayerTable->getAt(szLayer, pLayerTableRecord, AcDb::kForWrite);
		pLayerTableRecord->setColor(color);
	}
	pLayerTable->close();
	pLayerTableRecord->close();
	return TRUE;
}


Acad::ErrorStatus PostToDb(AcDbEntity* ent, BOOL bClose)
{
	Adesk::Boolean flag;
	if(bClose)
		flag = Adesk::kTrue;
	else
		flag = Adesk::kFalse;
	AcDbObjectId objId = AddToCurrentSpace(ent, flag);
    return Acad::eOk;
}


BOOL  CreateTextStyle(const TCHAR*szTextStyle, const TCHAR*szEngShape, const TCHAR*szChnShape) 
{
	CString csTextStyle(szTextStyle), csEngShape(szEngShape), csChnShape(szChnShape);
    AcDbDatabase *pCurDwg=acdbCurDwg();
    AcDbTextStyleTable* pTT = NULL;
    VERIFY(pCurDwg->getTextStyleTable(pTT, AcDb::kForWrite) == Acad::eOk);
    AcDbTextStyleTableRecord* pTTR = new AcDbTextStyleTableRecord;
	if(pTTR->setName(csTextStyle) != Acad::eOk)	{
		AfxMessageBox(_T("文字样式名称不合法！请重新输入。"));
		delete pTTR;
		pTT->close();
		return FALSE;
	}
	if(csEngShape != _T(""))
		pTTR->setFileName((const TCHAR*)csEngShape);
	if(csChnShape != _T(""))
		pTTR->setBigFontFileName((const TCHAR*)csChnShape);
    else 
        pTTR->setBigFontFileName(NULL);
    if(pTT->add(pTTR) != Acad::eOk )	{
		pTT->close();
		delete pTTR;
		return FALSE;
	}
    pTT->close();
	pTTR->close();
	return TRUE;
}

BOOL ModifyTextStyle(const TCHAR*szTextStyle, const TCHAR*szEngShape, const TCHAR*szChnShape)
{
	CString csTextStyle(szTextStyle), csEngShape(szEngShape), csChnShape(szChnShape);
    AcDbTextStyleTableRecord *pRec=NULL;
    AcDbObjectId idTextStyle = GetTextStyleId(csTextStyle);
    if(!idTextStyle)	
		return FALSE;
	OPENOBJ_BEGIN(idTextStyle, AcDb::kForWrite, AcDbTextStyleTableRecord, pRec);
	if(csEngShape != _T(""))
		pRec->setFileName((const TCHAR*)csEngShape);
	if(csChnShape != _T(""))
		pRec->setBigFontFileName((const TCHAR*)csChnShape);
    else 
        pRec->setBigFontFileName(NULL);
	OPENOBJ_END();
	return TRUE;
}


  





int DoubleCmp(const double *i, const double *j)
{
	if(*i < *j)
		return -1;
	else if(*i > *j)
		return 1;
	else
		return 0;
}

int DoubleCmp2(const double *i, const double *j)
{
	if(*i > *j)
		return -1;
	else if(*i < *j)
		return 1;
	else
		return 0;
}



//读扩展数据
CString ReadXdata(Entity ent, const TCHAR*szName)
{
	AcDbObjectId eId;
	AcDbEntity *pEnt = NULL;
	acdbGetObjectId(eId, ent);
	acdbOpenObject(pEnt, eId, AcDb::kForRead);
	if(!pEnt)
		return _T("");
    resbuf  *pRb = pEnt->xData(szName);

	CString csRet;
    if (pRb != NULL)   	{  
		resbuf  *pTemp = pRb; 
		if (pTemp->rbnext != NULL)	{
			pTemp = pTemp->rbnext;
			if (pTemp->restype == 1000)	
				csRet = pTemp->resval.rstring;	
		}
	}	
	ads_relrb(pRb);
	pEnt->close();
	return csRet;
}

//写扩展数据
BOOL WriteXdata(Entity ent, const TCHAR*szName, const TCHAR*szValue)
{
	AcDbObjectId eId;
	AcDbEntity *pEnt = NULL;
	acdbGetObjectId(eId, ent);
	if(!XSymbolTable(_T("APPID"), szName))
		ads_regapp(szName);
	acdbOpenObject(pEnt, eId, AcDb::kForWrite);
	if(!pEnt)
		return FALSE;
	resbuf *pXData = ads_buildlist(1001, szName, 1000, szValue, NULL);
	pEnt->setXData(pXData);
	ads_relrb(pXData);
	pEnt->close();
	return TRUE;
}


double GetLineAngle(Entity ent)
{
	double ang;
	if(ent.Is(_T("LINE"))){
		Callme();
		return -1;
	}
	XPoint pt1, pt2;
	GetWire2Point(ent, pt1, pt2);
	ang = ads_angle(pt1, pt2);
	return ang;
}

 
//注意，调用者自己考虑len比例的问题
void GetPointPickSet(XPoint pt, PickSet &ss, RBList &rbMask, int len)//注意：pt是UCS点
{
	double dLen = len;
//	if(DocGetMeterUnitDraw())
//		dLen = dLen / 100.0;
	XPoint ptTemp1, ptTemp2;
	ptTemp1.x = pt.x - dLen;
	ptTemp1.y = pt.y + dLen;
	ptTemp2.x = pt.x + dLen;
	ptTemp2.y = pt.y - dLen;
    //sr add 2006-4-28 支持三维上插入阀门
    ptTemp1.z = pt.z;
    ptTemp2.z = pt.z;
    
	XLine line(ptTemp1, ptTemp2, 1);
//	line.Make();
	ss.Get(_T("C"), ptTemp1, ptTemp2, rbMask);
    
	long len1 = ss.Length();
	for(long i=0;i<len1;i++){
		Entity ent = ss[i];
	}

}

BOOL IsPointLinkNull(XPoint pt)
{
	PickSet ss(SS_FREE);
	GetPointPickSet(pt, ss);
	long len = ss.Length();
	if(ss.Length() > 1)
		return FALSE;
	else
		return TRUE;
}

void Get2PtFLinePick(PickSet &ss, XPoint ptStart, XPoint ptEnd, RBList &rbMask, int n)
{
	XPoint p1, p2, p3, p4;
	double angle = ads_angle(ptStart, ptEnd);
	ads_polar(ptStart, (angle + PI/2), n, p1);    // p1
	ads_polar(ptStart, (angle - PI/2), n, p2);    // p2
	ads_polar(ptEnd, (angle + PI/2), n, p3);      // p3
	ads_polar(ptEnd, (angle - PI/2), n, p4);      // p4
	struct resbuf *list = ads_buildlist(  RTPOINT, &p1, RTPOINT, &p2, 
								RTPOINT, &p4, RTPOINT, &p3,
								RTPOINT, &p1, NULL); 
	ss.Get(_T("F"), list, NULL, rbMask);
	ads_relrb(list);
}

//mode == 0  居中对齐，两端留一定距离
//mode == 1  两端对齐
//将一段线均分N个点
void GetPointList(XCurveSegment seg, int iNum, XPointList &lstPt, int mode)
{
	double dDist2Wall(0);
	if(mode == 0)
		dDist2Wall = 0.5;
	else if(mode == 1)
		dDist2Wall = 0;
	else if(mode == 2)
		dDist2Wall = 0.25;

	double dDistEven(0);
	dDistEven = seg.GetLength() / (2*dDist2Wall+iNum-1);
	AcGePoint3d ptTmp;
	AcDbCurve *pCurve = seg.AsAcDbCurve();
	if(seg.Is(CURVE_CIRCLE)){
		XCircle ar = seg.GetCircle();
		pCurve = new AcDbCircle(ar.GetCenterPt(), AcGeVector3d(0,0,1), ar.GetRadius());
	}
	if(pCurve == NULL)
		return;
	int n = 0;
	while(n < iNum){
		//mod liaoy 避免出现除以0的导致dDistEven无效
		double dDist = 0;
		if(mode == 1 && iNum == 1)
			dDist = seg.GetLength() / 2;
		else
			dDist = dDist2Wall*dDistEven+n*dDistEven;
		//double dDist = dDist2Wall*dDistEven+n*dDistEven;
		//mod end
		pCurve->getPointAtDist(dDist, ptTmp);
		lstPt.NewAppend(ptTmp);
		n++;
	}
	delete pCurve;
	return;
}
//将一段线以间距nDist均分N个点 
void GetPointList(XCurveSegment seg, double dDist, XPointList &lstPt)
{
	double dLen = seg.GetLength();
	AcGePoint3d ptTmp;
	AcDbCurve *pCurve = seg.AsAcDbCurve();
	if(seg.Is(CURVE_CIRCLE)){
		XCircle ar = seg.GetCircle();
		pCurve = new AcDbCircle(ar.GetCenterPt(), AcGeVector3d(0,0,1), ar.GetRadius());
	}
	if(pCurve == NULL)
		return;
	if(dDist < 0){//反向
		dDist = fabs(dDist);
		double dAllDist = 1;
		int n = 0;
		while(dAllDist > 0){
			dAllDist = dLen - n*dDist;
			pCurve->getPointAtDist(dAllDist, ptTmp);
			lstPt.NewAppend(ptTmp);
			n++;
		}
	}
	else{          //正向
		double dAllDist = 0;
		int n = 0;
		while(dLen > dAllDist){
			dAllDist = n*dDist;
			pCurve->getPointAtDist(dAllDist, ptTmp);
			lstPt.NewAppend(ptTmp);
			n++;
		}
	}
	delete pCurve;
	return;
}

double GetArcLenByChord(XArc &arc, double nChord)
{
    double nRadius = arc.GetRadius();
    double nTmp = nChord / (2.0*nRadius);
    nTmp = asin(nTmp) * 2.0 * nRadius;
    return nTmp;
}


//将一段线均分N个点, 但间距是50倍数（喷淋系统）
void GetPointList(XCurveSegment seg, int iNum, XPointList &lstPt, double nShortDist, double nDist2Wall)
{
    if(seg.Is(CURVE_LINE)){
        XLine line = seg.GetLine();
        double angLine = ads_angle(line.StartPoint(), line.EndPoint());
        double distLine = line.GetLength() / iNum / 2;
        if(distLine < nShortDist && nShortDist > 0)
            distLine = nShortDist;
        double nTmp1 = distLine / 100;
        double nTmp2 = distLine - ((int)nTmp1)*100;
        double nTmp3 = nTmp2 / 25 + 0.5;
        int iTmp1 = (int)nTmp3;
        distLine = (int)nTmp1 * 100 + iTmp1 * 25;
        int n = 1;
        XPoint ptTemp;
        double nFisrtDist = (line.GetLength() - distLine * (iNum-1) * 2) / 2;
        while(nFisrtDist > nDist2Wall){
            distLine += 25;
            nFisrtDist = nFisrtDist - iNum*25;
        }
		
        nTmp1 = nFisrtDist / 100;
        nTmp2 = nFisrtDist - ((int)nTmp1)*100;
        nTmp3 = nTmp2 / 50 + 0.5;
        iTmp1 = (int)nTmp3;
        nFisrtDist = (int)nTmp1 * 100 + iTmp1 * 50;
        ads_polar(line.StartPoint(), angLine, nFisrtDist, ptTemp);
        lstPt.NewAppend(ptTemp);
        
        while(n < iNum){
            ads_polar(line.StartPoint(), angLine, (2*n)*distLine + nFisrtDist, ptTemp);
            lstPt.NewAppend(ptTemp);
            n++;
        }
    }
    else if(seg.Is(CURVE_ARC)){
        XArc arc = seg.GetArc();
        nShortDist = nShortDist*2;
        XPoint ptStart, ptEnd;
		arc.GetStartPoint(ptStart);
		arc.GetEndPoint(ptEnd);
      //  arc.GetPoints(ptStart, ptEnd);
        double distLine = arc.GetLength() / iNum;
        double nTmp1 = distLine / 100;
        double nTmp2 = distLine - ((int)nTmp1)*100;
        double nTmp3 = nTmp2 / 50 + 0.5;
        int iTmp1 = (int)nTmp3;
        distLine = (int)nTmp1 * 100 + iTmp1 * 50;
		
        int n = 1;
        XPoint ptTemp;
        double nFisrtDist = (arc.GetLength() - distLine * (iNum-1)) / 2;
        while(nFisrtDist > nDist2Wall){
            distLine += 50;
            nFisrtDist = nFisrtDist - iNum*25;
        }
        
        nTmp1 = nFisrtDist / 100;
        nTmp2 = nFisrtDist - ((int)nTmp1)*100;
        nTmp3 = nTmp2 / 50 + 0.5;
        iTmp1 = (int)nTmp3;
        nFisrtDist = (int)nTmp1 * 100 + iTmp1 * 50;
		
        nFisrtDist = GetArcLenByChord(arc, nFisrtDist);
        AcDbArc *pArc=new AcDbArc;
        pArc->setCenter(arc.GetCenterPt());
        pArc->setRadius(arc.GetRadius());
        pArc->setStartAngle(arc.GetStarAngle());
        pArc->setEndAngle(arc.GetEndAngle());
        pArc->getPointAtDist(nFisrtDist, ptTemp);
        lstPt.NewAppend(ptTemp);
	 
        distLine = GetArcLenByChord(arc, distLine);
		if(distLine > 0.001){
			while(distLine > 0.001 && n < iNum){
				pArc->getPointAtDist(n*distLine + nFisrtDist, ptTemp);
				lstPt.NewAppend(ptTemp);
				n++;
			}
		}
        delete pArc;
		
    }
}


BOOL Is2LineOnLine(XLine line1, XLine line2)
{
	XPoint ptStart, ptEnd;
	ptStart = line1.StartPoint();
	ptEnd = line1.EndPoint();
	double len1 = fabs(ptStart.Distance(&line2));
	double len2 = fabs(ptEnd.Distance(&line2));
	if(fabs(ptStart.Distance(&line2)) < 2.0 && fabs(ptEnd.Distance(&line2)) < 2.0)
		return TRUE;
	else
		return FALSE;

}

BOOL Is2ArcOnArc(XArc arc1, XArc arc2)
{
	XPoint ptCen1, ptCen2;	
	ptCen1 = arc1.GetCenterPt();
	ptCen2 = arc2.GetCenterPt();
	double nRadius1, nRadius2;
	nRadius1 = arc1.GetRadius();
	nRadius2 = arc2.GetRadius();
	if(ptCen1 == ptCen2 && (fabs(nRadius1 - nRadius2) < 0.1))
		return TRUE;
	else
		return FALSE;
}

void GetLineMax2Pt(XPoint pt1, XPoint pt2, XPoint &pt3, XPoint &pt4)
{
	XLine l1(pt1, pt3, LS_FINITE);
	XLine l2(pt2, pt3, LS_FINITE);
	XLine l3(pt1, pt4, LS_FINITE);
	XLine l4(pt2, pt4, LS_FINITE);
	double nMaxLen = 0.0;
	XPoint ptStart, ptEnd;
	nMaxLen = l1.GetLength() > nMaxLen ? l1.GetLength() : nMaxLen;
	nMaxLen = l2.GetLength() > nMaxLen ? l2.GetLength() : nMaxLen;
	nMaxLen = l3.GetLength() > nMaxLen ? l3.GetLength() : nMaxLen;
	nMaxLen = l4.GetLength() > nMaxLen ? l4.GetLength() : nMaxLen;
	if(nMaxLen == l1.GetLength()){
		pt3 = l1.StartPoint();
		pt4 = l1.EndPoint();
		return;
	}
	if(nMaxLen == l2.GetLength()){
		pt3 = l2.StartPoint();
		pt4 = l2.EndPoint();
		return;
	}
	if(nMaxLen == l3.GetLength()){
		pt3 = l3.StartPoint();
		pt4 = l3.EndPoint();
		return;
	}
	if(nMaxLen == l4.GetLength()){
		pt3 = l4.StartPoint();
		pt4 = l4.EndPoint();
		return;
	}
}



void DrawSlide(const TCHAR*szPath, CWnd* pWnd)
{
 	CImageDC img;
	CDC *pDC = pWnd->GetDC();
    CRect rc;
    pWnd->GetClientRect(&rc);
    img.InitDC(pDC, rc, GetAcadBackColor());
	img.PaintSlide(szPath); 
    img.SetDC(NULL);
    pWnd->ReleaseDC(pDC);
}

void DrawSlide(const TCHAR*szPath, CDC* pDC, CRect rc)
{
 	CImageDC img;
    img.InitDC(pDC, rc, GetAcadBackColor());
	img.PaintSlide(szPath);  
    img.SetDC(NULL);
}
 
XCurveSegment GetSegByPt(XPoly2D poly, XPoint pt, double &dAngle)
{
	XCurveSegment seg;
	int m = poly.HitTestOnCurve(pt);
	if(m > 0)
		m = m - 2;
	else if(m < 0)
		m = abs(m) -1;
	else if(m == 0)
		return XCurveSegment();
	if(m < 0)
		m = 0;
	poly.Nth(m, seg);

	if(seg.Is(CURVE_LINE))
		dAngle= seg.GetLine().Direction();
	else if(seg.Is(CURVE_ARC)){
		XPoint ptCenter;
		seg.GetArc().Center(ptCenter);
		dAngle = ads_angle(ptCenter, pt) + PI/2;
	}

	return seg;
}


XArc GetArcByCir(XPoint ptCen, double nRadius, XPoint ptStart, XPoint ptEnd, BOOL bIsLongArc = TRUE)
{
	double startAngle = ads_angle(ptCen, ptStart);
	double endAngle = ads_angle(ptCen, ptEnd);
	XArc arc1(ptCen, nRadius, startAngle, endAngle);
	XArc arc2(ptCen, nRadius, endAngle, startAngle);
	if(bIsLongArc){
		if(arc1.GetLength() > arc2.GetLength())
			return arc1;
		else
			return arc2;
	}
	else{
		if(arc1.GetLength() > arc2.GetLength())
			return arc2;
		else
			return arc1;
	}
}






CString PlusString(const TCHAR* szRes, int step, BOOL bIsPlus)
{
    if(_tcsicmp(szRes, _T("")) == 0)
        return CString();
    XString xsText;
    int num, numWith;
    StringAnalysis(szRes, xsText, &num, &numWith);
    CString csRes = szRes;
	CString csRet = csRes;
    
    if(numWith != 0){
        if(bIsPlus)
            num += step;
        else if(num > 1)
            num -= step;
        if(num < 0)
            num = 0;
        if(numWith == -1)
            csRet.Format(_T("%s%d"), xsText, num);
        else{ //需要补0
            XString sText;
            sText << xsText;
            TCHAR szNext[256]=_T("");
            _itot(num, szNext, 10);
            if(numWith > 0) {
                int iZeroNum = numWith - (int)_tcslen(szNext);
                for(int kk=0; kk<iZeroNum; kk++)
                    sText << _T("0");
            }
            sText << szNext;
            csRet = (const TCHAR*)sText;
        }
    }
  
    if(csRet != csRes)
        return csRet;

	CString csChinaDigit[] = {_T("一"),_T("二"),_T("三"),_T("四"),_T("五"),_T("六"),_T("七"),_T("八"),_T("九"),_T("十"),};
	CString csChinaDigit2[] = {_T("零"),_T("贰"),_T("叁"),_T("肆"),_T("伍"),_T("陆"),_T("柒"),_T("捌"),_T("玖"),_T("拾"),};
	CString cs12Digit[] = {_T("Ⅰ"),_T("Ⅱ"),_T("Ⅲ"),_T("Ⅳ"),_T("Ⅴ"),_T("Ⅵ"),_T("Ⅶ"),_T("Ⅷ"),_T("Ⅸ"),_T("Ⅹ"),_T("Ⅺ"),_T("Ⅻ")};
	CString csLetter[] = {_T("a"),_T("b"),_T("c"),_T("d"),_T("e"),_T("f"),_T("g"),_T("h"),_T("i"),_T("j"),_T("k"),_T("l"),_T("m"),_T("n"),_T("o"),_T("p"),_T("q"),_T("r"),_T("s"),_T("t"),_T("u"),_T("v"),_T("w"),_T("x"),_T("y"),_T("z")};
	CString csLetter2[] = {_T("A"),_T("B"),_T("C"),_T("D"),_T("E"),_T("F"),_T("G"),_T("H"),_T("I"),_T("J"),_T("K"),_T("L"),_T("M"),_T("N"),_T("O"),_T("P"),_T("Q"),_T("R"),_T("S"),_T("T"),_T("U"),_T("V"),_T("W"),_T("X"),_T("Y"),_T("Z")};

    CString csRightTmp2, csLeftTmp2;
    int len = csRes.GetLength();
    int iIdx(0);

	TCHAR cUnit = csRes[len-1];
	BYTE byte = (BYTE)cUnit;
	CString csUnit = cUnit;

#if (ADS<17)
	if(IsDBCSLeadByte(byte)){//如果是半个汉字，就再读下1个字符
		TCHAR cUnit2 = csRes[len-2];
		csUnit.Format(_T("%c%c"),cUnit2, cUnit);
	}
#endif

	csRightTmp2 = csUnit;
 

    /////////////////////////////////////////////////////////////////////////
//对后面特殊字符进行递增

	int iLen = 1;

#if (ADS<17)
	iLen = 2;
#endif

    for(int m=0;m<10;m++){
		if(csRightTmp2 == csChinaDigit[m]){
			
			CString csLeftTmp = csRes.Left(len - iLen);
			if(bIsPlus)
				iIdx = m + step;
			else
				iIdx = m - step;
			iIdx = (iIdx+10) % 10;
			csRightTmp2 = csChinaDigit[iIdx];
			csRet.Format(_T("%s%s"), csLeftTmp, csRightTmp2);
			return csRet;
		}
	}

	for(m=0;m<10;m++){
		if(csRightTmp2 == csChinaDigit2[m]){
			CString csLeftTmp = csRes.Left(len - iLen);
			if(bIsPlus)
				iIdx = m + step;
			else
				iIdx = m - step;
			iIdx = (iIdx+10) % 10;
			csRightTmp2 = csChinaDigit2[iIdx];
			csRet.Format(_T("%s%s"), csLeftTmp, csRightTmp2);
			return csRet;
		}
	}
	for(m=0;m<12;m++){
		if(csRightTmp2 == cs12Digit[m]){
			CString csLeftTmp = csRes.Left(len - iLen);
			if(bIsPlus)
				iIdx = m + step;
			else
				iIdx = m - step;
			iIdx = (iIdx+12) % 12;
			csRightTmp2 = cs12Digit[iIdx];
			csRet.Format(_T("%s%s"), csLeftTmp, csRightTmp2);
			return csRet;
		}
	}
	for(m=0;m<26;m++){
		csRightTmp2 = csRes.Right(1);
		if(csRightTmp2 == csLetter[m]){
			CString csLeftTmp = csRes.Left(len - 1);
			if(bIsPlus)
				iIdx = m + step;
			else
				iIdx = m - step;
			iIdx = (iIdx+26) % 26;
			csRightTmp2 = csLetter[iIdx];
			csRet.Format(_T("%s%s"), csLeftTmp, csRightTmp2);
			return csRet;
		}
	}
	for(m=0;m<26;m++){
		csRightTmp2 = csRes.Right(1);
		if(csRightTmp2 == csLetter2[m]){
			CString csLeftTmp = csRes.Left(len - 1);
			if(bIsPlus)
				iIdx = m + step;
			else
				iIdx = m - step;
			iIdx = (iIdx+26) % 26;
			csRightTmp2 = csLetter2[iIdx];
			csRet.Format(_T("%s%s"), csLeftTmp, csRightTmp2);
			return csRet;
		}
	}



/////////////////////////////////////////////////////////////////////////
//对前面特殊字符进行递增
	for(m=0;m<10;m++){
		if(csLeftTmp2 == csChinaDigit[m]){
			CString csRightTmp = csRes.Right(len - 2);
			if(bIsPlus)
				iIdx = m + step;
			else
				iIdx = m - step;
			iIdx = (iIdx+10) % 10;
			csLeftTmp2 = csChinaDigit[iIdx];
			csRet.Format(_T("%s%s"), csLeftTmp2, csRightTmp);
			return csRet;
		}
	}
	for(m=0;m<10;m++){
		if(csLeftTmp2 == csChinaDigit2[m]){
			CString csRightTmp = csRes.Right(len - 2);
			if(bIsPlus)
				iIdx = m + step;
			else
				iIdx = m - step;
			iIdx = (iIdx+10) % 10;
			csLeftTmp2 = csChinaDigit2[iIdx];
			csRet.Format(_T("%s%s"), csLeftTmp2, csRightTmp);
			return csRet;
		}
	}

	for(m=0;m<12;m++){
		if(csLeftTmp2 == cs12Digit[m]){
			CString csRightTmp = csRes.Right(len - 2);
			if(bIsPlus)
				iIdx = m + step;
			else
				iIdx = m - step;
			iIdx = (iIdx+12) % 12;
			csLeftTmp2 = cs12Digit[iIdx];
			csRet.Format(_T("%s%s"), csLeftTmp2, csRightTmp);
			return csRet;
		}
	}

	for(m=0;m<26;m++){
		csLeftTmp2 = csRes.Left(1);
		if(csLeftTmp2 == csLetter[m]){
			CString csRightTmp = csRes.Right(len - 1);
			if(bIsPlus)
				iIdx = m + step;
			else
				iIdx = m - step;
			iIdx = (iIdx+26) % 26;
			csLeftTmp2 = csLetter[iIdx];
			csRet.Format(_T("%s%s"), csLeftTmp2, csRightTmp);
			return csRet;
		}
	}
	for(m=0;m<26;m++){
		csLeftTmp2 = csRes.Left(1);
		if(csLeftTmp2 == csLetter2[m]){
			CString csRightTmp = csRes.Right(len - 1);
			if(bIsPlus)
				iIdx = m + step;
			else
				iIdx = m - step;
			iIdx = (iIdx+26) % 26;
			csLeftTmp2 = csLetter2[iIdx];
			csRet.Format(_T("%s%s"), csLeftTmp2, csRightTmp);
			return csRet;
		}
	}
	return csRet;
}









CString PlusString2(const TCHAR* szRes, int step, BOOL bIsPlus)//给MYSPIN用，他不需要对前面递增递减
{
    CString csRes = szRes;
	int len = csRes.GetLength();
	int iIdx(0);
	CString csRet = csRes;
	CString csRightTmp = csRes.Right(2);
	CString csChinaDigit[] = {_T("一"),_T("二"),_T("三"),_T("四"),_T("五"),_T("六"),_T("七"),_T("八"),_T("九"),_T("十"),};
	CString csChinaDigit2[] = {_T("零"),_T("贰"),_T("叁"),_T("肆"),_T("伍"),_T("陆"),_T("柒"),_T("捌"),_T("玖"),_T("拾"),};
	CString cs12Digit[] = {_T("Ⅰ"),_T("Ⅱ"),_T("Ⅲ"),_T("Ⅳ"),_T("Ⅴ"),_T("Ⅵ"),_T("Ⅶ"),_T("Ⅷ"),_T("Ⅸ"),_T("Ⅹ"),_T("Ⅺ"),_T("Ⅻ")};
	CString csLetter[] = {_T("a"),_T("b"),_T("c"),_T("d"),_T("e"),_T("f"),_T("g"),_T("h"),_T("i"),_T("j"),_T("k"),_T("l"),_T("m"),_T("n"),_T("o"),_T("p"),_T("q"),_T("r"),_T("s"),_T("t"),_T("u"),_T("v"),_T("w"),_T("x"),_T("y"),_T("z")};
	CString csLetter2[] = {_T("A"),_T("B"),_T("C"),_T("D"),_T("E"),_T("F"),_T("G"),_T("H"),_T("I"),_T("J"),_T("K"),_T("L"),_T("M"),_T("N"),_T("O"),_T("P"),_T("Q"),_T("R"),_T("S"),_T("T"),_T("U"),_T("V"),_T("W"),_T("X"),_T("Y"),_T("Z")};
	for(int m=0;m<10;m++){
		if(csRightTmp == csChinaDigit[m]){
			CString csLeftTmp = csRes.Left(len - 2);
			if(bIsPlus)
				iIdx = m + step;
			else
				iIdx = m - step;
			iIdx = (iIdx+10) % 10;
			csRightTmp = csChinaDigit[iIdx];
			csRet.Format(_T("%s%s"), csLeftTmp, csRightTmp);
			return csRet;
		}
	}
	for(m=0;m<10;m++){
		if(csRightTmp == csChinaDigit2[m]){
			CString csLeftTmp = csRes.Left(len - 2);
			if(bIsPlus)
				iIdx = m + step;
			else
				iIdx = m - step;
			iIdx = (iIdx+10) % 10;
			csRightTmp = csChinaDigit2[iIdx];
			csRet.Format(_T("%s%s"), csLeftTmp, csRightTmp);
			return csRet;
		}
	}
	for(m=0;m<12;m++){
		if(csRightTmp == cs12Digit[m]){
			CString csLeftTmp = csRes.Left(len - 2);
			if(bIsPlus)
				iIdx = m + step;
			else
				iIdx = m - step;
			iIdx = (iIdx+12) % 12;
			csRightTmp = cs12Digit[iIdx];
			csRet.Format(_T("%s%s"), csLeftTmp, csRightTmp);
			return csRet;
		}
	}
	for(m=0;m<26;m++){
		csRightTmp = csRes.Right(1);
		if(csRightTmp == csLetter[m]){
			CString csLeftTmp = csRes.Left(len - 1);
			if(bIsPlus)
				iIdx = m + step;
			else
				iIdx = m - step;
			iIdx = (iIdx+26) % 26;
			csRightTmp = csLetter[iIdx];
			csRet.Format(_T("%s%s"), csLeftTmp, csRightTmp);
			return csRet;
		}
	}
	for(m=0;m<26;m++){
		csRightTmp = csRes.Right(1);
		if(csRightTmp == csLetter2[m]){
			CString csLeftTmp = csRes.Left(len - 1);
			if(bIsPlus)
				iIdx = m + step;
			else
				iIdx = m - step;
			iIdx = (iIdx+26) % 26;
			csRightTmp = csLetter2[iIdx];
			csRet.Format(_T("%s%s"), csLeftTmp, csRightTmp);
			return csRet;
		}
	}

	for(int i=1;i<=len;i++){
		CString csRight = csRes.Right(i);
		if(i == 1){
			TCHAR c = csRight[0];
			if(!_istdigit(c))
				break;
		}
		BOOL bIsAllZ = TRUE;
		int lenRight = csRight.GetLength();
		for(int j=0;j<lenRight;j++){
			CString csTmp = csRight[j];
			if(csTmp != _T("0")){
				bIsAllZ = FALSE;
				break;
			}
		}
		if(bIsAllZ)
			continue;
		CString csLeft = csRes.Left(len - i);
		int val = _ttoi(csRight);
		if(val <= 0) // SR MODIFY if(val == 0)  
			break;
	 
		if(bIsPlus){
			val += step;
			if(val < 1)
				val = 1;
		}
		else{
			val -= step;
			if(val < 1)
				val = 1;
		}
		csRet.Format(_T("%s%d"), csLeft, val);
	}

	return csRet;
}

void SplitBlkStr(const TCHAR *szInput, CString &csTK, CString &csRecord)
{
//	CString csInput = szInput;
//	int idx = csInput.Find(_T('$'));
//	if(idx > 0)
//	{
//		CString csTmp;
//		csTmp = csInput.Right(csInput.GetLength() - idx);
//		SplitBlkStr(csTmp, csTK, csRecord);
//		return;
//	}//以上几句 沈睿 2011-6-24加，有的图块名是有前缀的。一般都是从$开头

	int len = (int)_tcslen(szInput);
	TCHAR szTemp[256]=_T("");
	int j =0;
	BOOL bfisrt = TRUE;
	szTemp[0] = _T('\0');
	for(int i=0; i<=len; i++)
	{
		if(szInput[i] != _T('\0') && szInput[i] != _T('$'))
			szTemp[j] = szInput[i];
		else	{
			szTemp[j] = _T('\0');
			if(szTemp[0] != _T('\0') && bfisrt){
				csTK = szTemp;
				bfisrt = FALSE;
			}
			else if(szTemp[0] != _T('\0') && !bfisrt){
				csRecord = szTemp;
			}
			j =-1;
		}
		j++;	
	}

}


XCurveSegment GetBlkPickSeg(Entity entBlk, XPoint ptPick)
{	
	double xscale;
	entBlk.GetData(41, &xscale);
	xscale = fabs(xscale);
	XBlock myBlock(entBlk);
	if(!myBlock.m_bInitSuccess)
		return XCurveSegment();
	AcDbBlockTableRecordIterator *pIterator;
	pIterator = myBlock.GetIterator();
	for(pIterator->start(); !pIterator->done(); pIterator->step()){
		AcDbEntity *pEnt;
		pIterator->getEntity(pEnt, AcDb::kForRead);
		AcDbCircle *pCir = NULL;
 		AcDbLine  *pLine = NULL;
		AcDbPolyline *pPoly = NULL;
 		AcDbArc  *pArc = NULL;
        AcDbSolid *pSolid = NULL;
     
 		TDbWall  *pWall = NULL;
		XCurveSegment seg;
		if(pCir = AcDbCircle::cast(pEnt)){
			AcGePoint3d ptIns = pCir->center();
			ptIns = ptIns.transformBy(myBlock.GetMatrix3d());
			XCircle cir(asDblArray(ptIns), pCir->radius()*xscale);
			seg = cir;
			if(IsPtOnCircle(ptPick, cir, 25)){
				pEnt->close();
				return seg;
			}
		}
		else if(pSolid = AcDbSolid::cast(pEnt)){
            AcGePoint3d p1, p2, p3, p4;
            pSolid->getPointAt(0, p1);
            pSolid->getPointAt(1, p2);
            pSolid->getPointAt(2, p3);
            pSolid->getPointAt(3, p4);
            p1 = p1.transformBy(myBlock.GetMatrix3d());
            p2 = p2.transformBy(myBlock.GetMatrix3d());
            p3 = p3.transformBy(myBlock.GetMatrix3d());
            p4 = p4.transformBy(myBlock.GetMatrix3d());
            XLine l1(asDblArray(p1), asDblArray(p2), 1);
            XLine l2(asDblArray(p2), asDblArray(p4), 1);
            XLine l3(asDblArray(p3), asDblArray(p4), 1);
            XLine l4(asDblArray(p3), asDblArray(p1), 1);
            if(IsPtOnLine(ptPick, l1, 25)){
                pEnt->close();
                seg = l1;
                return seg;
            }
            if(IsPtOnLine(ptPick, l2, 25)){
                pEnt->close();
                seg = l2;
                return seg;
            }
            if(IsPtOnLine(ptPick, l3, 25)){
                pEnt->close();
                seg = l3;
                return seg;
            }
            if(IsPtOnLine(ptPick, l4, 25)){
                pEnt->close();
                seg = l4;
                return seg;
            }
       }
        else if(pPoly = AcDbPolyline::cast(pEnt)){
			XPoly2D poly;
			PolyConvert(*pPoly, poly);
			poly.TransformBy(myBlock.GetMatrix3d());
			double n;
			seg = GetSegByPt(poly, ptPick, n);
			if(!!seg)
				return seg;
		}
		else if(pLine = AcDbLine::cast(pEnt)){
			AcGePoint3d ptStart = pLine->startPoint();
			ptStart = ptStart.transformBy(myBlock.GetMatrix3d());
			AcGePoint3d ptEnd = pLine->endPoint();
			ptEnd = ptEnd.transformBy(myBlock.GetMatrix3d());
			XLine line(asDblArray(ptStart), asDblArray(ptEnd), 1);
			seg = line;
			if(IsPtOnLine(ptPick, line, 25)){
				pEnt->close();
				return seg;
			}
		}
		else if(pArc = AcDbArc::cast(pEnt)){
			AcGePoint3d ptIns = pArc->center();
			ptIns = ptIns.transformBy(myBlock.GetMatrix3d());
			XArc arc(asDblArray(ptIns), pArc->radius()*xscale, pArc->startAngle(), pArc->endAngle());
			seg = arc;
			if(IsPtOnArc(ptPick, arc, 25)){
				pEnt->close();
				return seg;
			}
		}
		else if(pWall = TDbWall::cast(pEnt)){   //特别支持5。0墙体
			XCurveSegment lCurve, rCurve;
			pWall->GetSideCurve(lCurve, rCurve);
			if(lCurve.Is(CURVE_LINE)){
				AcGePoint3d ptStart = lCurve.StartPoint();
				ptStart = ptStart.transformBy(myBlock.GetMatrix3d());
				AcGePoint3d ptEnd = lCurve.EndPoint();
				ptEnd = ptEnd.transformBy(myBlock.GetMatrix3d());
				XLine line(asDblArray(ptStart), asDblArray(ptEnd), 1);
				seg = line;
				if(IsPtOnLine(ptPick, line, 25)){
					pEnt->close();
					return seg;
				}
			}
			if(rCurve.Is(CURVE_LINE)){
				AcGePoint3d ptStart = rCurve.StartPoint();
				ptStart = ptStart.transformBy(myBlock.GetMatrix3d());
				AcGePoint3d ptEnd = rCurve.EndPoint();
				ptEnd = ptEnd.transformBy(myBlock.GetMatrix3d());
				XLine line(asDblArray(ptStart), asDblArray(ptEnd), 1);
				seg = line;
				if(IsPtOnLine(ptPick, line, 25)){
					pEnt->close();
					return seg;
				}
			}
			if(lCurve.Is(CURVE_ARC)){
				XArc arcTmp = lCurve.GetArc();
				AcGePoint3d ptIns = arcTmp.GetCenterPt();
				ptIns = ptIns.transformBy(myBlock.GetMatrix3d());
				XArc arc(asDblArray(ptIns), arcTmp.GetRadius()*xscale, arcTmp.GetStarAngle(), arcTmp.GetEndAngle());
				seg = arc;
				if(IsPtOnArc(ptPick, arc, 25)){
					pEnt->close();
					return seg;
				}
			}
			if(rCurve.Is(CURVE_ARC)){
				XArc arcTmp = rCurve.GetArc();
				AcGePoint3d ptIns = arcTmp.GetCenterPt();
				ptIns = ptIns.transformBy(myBlock.GetMatrix3d());
				XArc arc(asDblArray(ptIns), arcTmp.GetRadius()*xscale, arcTmp.GetStarAngle(), arcTmp.GetEndAngle());
				seg = arc;
				if(IsPtOnArc(ptPick, arc, 25)){
					pEnt->close();
					return seg;
				}
			}
		}
 		pEnt->close();
	}
	return XCurveSegment();
}
 
BOOL SetLayerLocked(const TCHAR* szLayerName, BOOL bLock)
{
	AcDbLayerTable *pLayertable = NULL;
	AcDbLayerTableRecord *pLayerRec = NULL;
	acdbCurDwg()->getLayerTable(pLayertable, AcDb::kForRead);
	if(!pLayertable)
		return FALSE;
 
	if((pLayertable->getAt(szLayerName, pLayerRec, AcDb::kForWrite)) == Acad::eOk)	{
		if(bLock) 
			pLayerRec->setIsLocked(true);  // 打开
		else
			pLayerRec->setIsLocked(false);   // 关
		pLayerRec->close();
		pLayertable->close();
	}
	else
		pLayertable->close();
	return TRUE;
}

BOOL SetLayer0UnLocked()
{
	AcDbLayerTable *pLayertable = NULL;
	AcDbLayerTableRecord *pLayerRec = NULL;
	acdbCurDwg()->getLayerTable(pLayertable, AcDb::kForRead);
	if(!pLayertable)
		return FALSE;
 
	if((pLayertable->getAt(_T("0"), pLayerRec, AcDb::kForRead)) == Acad::eOk)	{
		if(pLayerRec->isLocked() && pLayerRec->upgradeOpen()==Acad::eOk) {
			pLayerRec->setIsLocked(false);   // 关
			pLayerRec->downgradeOpen();    
		}
		pLayerRec->close();
	}
	pLayertable->close();
	return TRUE;
}

void SetBlkAttrText(Entity entBlk, const TCHAR*szText, const TCHAR*szTag, double nHeight, BOOL bVisible, BOOL bDown)
{
	SetLayer0UnLocked();
	AcDbBlockReference *pBlockRef = NULL;// 定义块表指针
	AcDbObjectId eId;
	acdbGetObjectId(eId, entBlk);
	acdbOpenObject(pBlockRef, eId, AcDb::kForRead);
	if(!pBlockRef)
		return;
	AcDbObjectIterator *pIterator;
	pIterator = pBlockRef -> attributeIterator();
	for (pIterator -> start(); !pIterator -> done(); pIterator -> step())
	{
		//遍历块中实体
		AcDbObjectId att_id;
		att_id = pIterator -> objectId();
		AcDbEntity *pEnt;
		AcDbAttribute *pAtt;
		acdbOpenAcDbEntity(pEnt, att_id, AcDb::kForWrite);			
		pAtt = AcDbAttribute::cast(pEnt);			
		if(pAtt != NULL)
		{
			TCHAR *cname = pAtt->tag();//得到标记
			if(_tcsicmp(cname, szTag) == 0){
				if(!bVisible)
					pAtt->setInvisible(Adesk::kTrue);
				else{
					pAtt->setTextString(szText);
					pAtt->setHeight(nHeight*DocGetPScale());
					pAtt->setInvisible(Adesk::kFalse);
					if(bDown){
						pAtt->setHorizontalMode(AcDb::kTextLeft);
						pAtt->setVerticalMode(AcDb::kTextTop);
					}
				}
			}
			delete[] cname;
		}
		pEnt->close();
	}
	delete pIterator;
	pBlockRef->close();
}

int GetLayerColorByDwg(const TCHAR*szLayer)
{
	int iRet = -1;
	AcDbObjectId idLayer = GetLayerIdFromString(szLayer);
	OPENOBJ_BEGIN(idLayer, AcDb::kForRead, AcDbLayerTableRecord, pLayer);
    if(pLayer) {
		AcCmColor color = pLayer->color();
		iRet = color.colorIndex();
    }
    OPENOBJ_END();
	return iRet;
}



void FilletEntity(Entity ent1, Entity ent2, double nRad)
{
    XPushVar<int> FilletRad(_T("FilletRad"), (int)nRad);
    XLine l1(ent1, 1);
    XLine l2(ent2, 1);
    XPoint ptMid1, ptMid2;
    l1.MidPoint(ptMid1);
    l2.MidPoint(ptMid2);
    ptMid1 = Wcs2Ucs(ptMid1);
    ptMid2 = Wcs2Ucs(ptMid2);
    
    ads_command(RTSTR,_T("FILLET"), 
        RTLB,RTENAME,(TLong_ptr *)ent1, RT3DPOINT, &ptMid1, RTLE,
        RTLB,RTENAME,(TLong_ptr *)ent2, RT3DPOINT, &ptMid2, RTLE, RTNONE);
}


// 2008-6-27 sr 改采用acedNEntSelP的方法，支持嵌套参考
XCurveSegment GetBlkPickSegment(Entity entBlk, XPoint ptPick)
{
	XCurveSegment seg;
	ads_name ename;
	ads_matrix adsmat;
	struct resbuf *insStack;
	
	if (acedNEntSelP(NULL, ename, ptPick, TRUE,
		adsmat, &insStack) != RTNORM)
	{
		ads_printf(_T("\nFailure in ads_nentselp"));
		return seg;
	}
	ads_relrb(insStack);
	Entity entTemp = ename;
	if(entTemp.Is(_T("LINE")) || entTemp.Is(_T("ARC"))){
		XCurveSegment seg1(entTemp);
		seg1.TransformBy(adsmat);
		seg = seg1;
	}
	else if(entTemp.Is(_T("LWPOLYLINE"))){
		double dAngle;
		XPoly2D poly(entTemp);
		poly.TransformBy(AsAcGeMatrix3d(adsmat));
		//poly.Make();
		seg = GetSegByPt(poly, ptPick, dAngle);
	}
	else if(entTemp.Is(_T("ATS_WALL"))){
		OPENOBJ_BEGIN(entTemp, AcDb::kForRead, TDbWall, pWall);
		XCurveSegment lCurve, rCurve;
		XPoint ptNew1, ptNew2;
		if(pWall) {
			pWall->GetSideCurve(lCurve, rCurve);
			lCurve.TransformBy(adsmat);
			rCurve.TransformBy(adsmat);
			seg = lCurve;
		}
		OPENOBJ_END();
	}
	else{
		OPENOBJ_BEGIN(ename, AcDb::kForRead, AcDbEntity, pEnt);
		if(pEnt != NULL){
			ads_printf(_T("\n无法识别： %s"), pEnt->isA()->name());
		}
		OPENOBJ_END();
	}
	
	
	return seg;
	
}


/*
XCurveSegment GetBlkPickSegment(Entity entBlk, XPoint ptPick)
{	
    //第一步，得到块参考矩阵
    AcDbBlockReference *pBlkRef = NULL;
    AcDbObjectId id = NULL;
    acdbGetObjectId(id, entBlk);
    acdbOpenObject(pBlkRef, id, AcDb::kForRead);
    if(!pBlkRef)
        return XCurveSegment();
    AcGeMatrix3d mat = pBlkRef->blockTransform();
    if(pBlkRef)
        pBlkRef->close();

    double xscale;
    entBlk.GetData(41, &xscale);
    xscale = fabs(xscale);

    //第二步，得到块记录遍历器
    TCHAR szBlkName[256];
    entBlk.GetData(2, szBlkName);
    AcDbBlockTable* pBlockTable = NULL;
    AcDbBlockTableRecord *pRecord = NULL; 
    acdbCurDwg()->getBlockTable(pBlockTable, AcDb::kForRead);
    if(Acad::eOk != pBlockTable->getAt(szBlkName, pRecord, AcDb::kForRead))
        return XCurveSegment();
    pBlockTable->close();
    if(pRecord->isFromExternalReference() == true){
        XPoint ptOrigin = pRecord->origin();
        AcGeMatrix3d mat2;
        mat2.setToTranslation(AcGeVector3d(-ptOrigin[0], -ptOrigin[1], -ptOrigin[2]));
        mat *= mat2;
    }

	AcDbBlockTableRecordIterator *pIterator = NULL;
	pRecord->newIterator(pIterator);
    if(pRecord)
        pRecord->close();
 
	for(pIterator->start(); !pIterator->done(); pIterator->step()){
		AcDbEntity *pEnt;
		pIterator->getEntity(pEnt, AcDb::kForRead);
		AcDbCircle *pCir = NULL;
 		AcDbLine  *pLine = NULL;
		AcDbPolyline *pPoly = NULL;
 		AcDbArc  *pArc = NULL;
        AcDbSolid *pSolid = NULL;
 		TDbWall  *pWall = NULL;
		XCurveSegment seg;
		if(pCir = AcDbCircle::cast(pEnt)){
			AcGePoint3d ptIns = pCir->center();
			ptIns = ptIns.transformBy(mat);
			XCircle cir(asDblArray(ptIns), pCir->radius()*xscale);
			seg = cir;
			if(IsPtOnCircle(ptPick, cir, 500/20)){
				pEnt->close();
				return seg;
			}
		}
        else if(pSolid = AcDbSolid::cast(pEnt)){
            AcGePoint3d p1, p2, p3, p4;
            pSolid->getPointAt(0, p1);
            pSolid->getPointAt(1, p2);
            pSolid->getPointAt(2, p3);
            pSolid->getPointAt(3, p4);
            p1 = p1.transformBy(mat);
            p2 = p2.transformBy(mat);
            p3 = p3.transformBy(mat);
            p4 = p4.transformBy(mat);
            XLine l1(asDblArray(p1), asDblArray(p2), 1);
            XLine l2(asDblArray(p2), asDblArray(p4), 1);
            XLine l3(asDblArray(p3), asDblArray(p4), 1);
            XLine l4(asDblArray(p3), asDblArray(p1), 1);
            if(IsPtOnLine(ptPick, l1, 25)){
                pEnt->close();
                seg = l1;
                return seg;
            }
            if(IsPtOnLine(ptPick, l2, 25)){
                pEnt->close();
                seg = l2;
                return seg;
            }
            if(IsPtOnLine(ptPick, l3, 25)){
                pEnt->close();
                seg = l3;
                return seg;
            }
            if(IsPtOnLine(ptPick, l4, 25)){
                pEnt->close();
                seg = l4;
                return seg;
            }
        }
		else if(pPoly = AcDbPolyline::cast(pEnt)){
			XPoly2D poly;
			PolyConvert(*pPoly, poly);
			poly.TransformBy(mat);
			double n;
			seg = GetSegByPt(poly, ptPick, n);
			if(!!seg)
				return seg;
		}
		else if(pLine = AcDbLine::cast(pEnt)){
			AcGePoint3d ptStart = pLine->StartPoint()();
			ptStart = ptStart.transformBy(mat);
			AcGePoint3d ptEnd = pLine->EndPoint()();
			ptEnd = ptEnd.transformBy(mat);
			XLine line(asDblArray(ptStart), asDblArray(ptEnd), 1);
			seg = line;
			if(IsPtOnLine(ptPick, line, 500/20)){
				pEnt->close();
				return seg;
			}
		}
		else if(pArc = AcDbArc::cast(pEnt)){
			AcGePoint3d ptIns = pArc->center();
			ptIns = ptIns.transformBy(mat);
			XArc arc(asDblArray(ptIns), pArc->radius()*xscale, pArc->startAngle(), pArc->endAngle());
			seg = arc;
			if(IsPtOnArc(ptPick, arc, 500/20)){
				pEnt->close();
				return seg;
			}
		}
		else if(pWall = TDbWall::cast(pEnt)){   //特别支持5。0墙体
			XCurveSegment lCurve, rCurve;
			pWall->GetSideCurve(lCurve, rCurve);
			if(lCurve.Is(CURVE_LINE)){
				AcGePoint3d ptStart = lCurve.StartPoint();
				ptStart = ptStart.transformBy(mat);
				AcGePoint3d ptEnd = lCurve.EndPoint();
				ptEnd = ptEnd.transformBy(mat);
				XLine line(asDblArray(ptStart), asDblArray(ptEnd), 1);
				seg = line;
				if(IsPtOnLine(ptPick, line, 500/20)){
					pEnt->close();
					return seg;
				}
			}
			if(rCurve.Is(CURVE_LINE)){
				AcGePoint3d ptStart = rCurve.StartPoint();
				ptStart = ptStart.transformBy(mat);
				AcGePoint3d ptEnd = rCurve.EndPoint();
				ptEnd = ptEnd.transformBy(mat);
				XLine line(asDblArray(ptStart), asDblArray(ptEnd), 1);
				seg = line;
				if(IsPtOnLine(ptPick, line, 500/20)){
					pEnt->close();
					return seg;
				}
			}
			if(lCurve.Is(CURVE_ARC)){
				XArc arcTmp = lCurve.GetArc();
				AcGePoint3d ptIns = arcTmp.center;
				ptIns = ptIns.transformBy(mat);
				XArc arc(asDblArray(ptIns), arcTmp.radius*xscale, arcTmp.startAngle, arcTmp.endAngle);
				seg = arc;
				if(IsPtOnArc(ptPick, arc, 500/20)){
					pEnt->close();
					return seg;
				}
			}
			if(rCurve.Is(CURVE_ARC)){
				XArc arcTmp = rCurve.GetArc();
				AcGePoint3d ptIns = arcTmp.center;
				ptIns = ptIns.transformBy(mat);
				XArc arc(asDblArray(ptIns), arcTmp.radius*xscale, arcTmp.startAngle, arcTmp.endAngle);
				seg = arc;
				if(IsPtOnArc(ptPick, arc, 500/20)){
					pEnt->close();
					return seg;
				}
			}
		}
 		pEnt->close();
	}
    if(pIterator)
        delete pIterator;
    
	return XCurveSegment();
}
*/


int get_line_angle(ads_real& line_angle)//得到直线的角度
{
    int iLineType = 0;
    RBList rbMask = ads_buildlist( -4, _T("<or"),
        -4, _T("<and"), RTDXF0, _T("LINE"), 8, _T("*"), -4, _T("and>"),  
        -4, _T("<and"), RTDXF0, _T("LWPOLYLINE"), 8, _T("*"), -4, _T("and>"),  
        -4, _T("<and"), RTDXF0, _T("INSERT"), 8, _T("*"), -4, _T("and>"),  
        -4, _T("<and"), RTDXF0, _T("ATS_WALL"), -4, _T("and>"),  
        -4, _T("or>"), NULL);	
    XPoint ptPick;
    Entity entWall;
	if(SelectEntity1(_T("\n从当前图中选取行向线<不选取>:"), entWall, ptPick, rbMask) != RTNORM)
        return RTNORM;
    XCurveSegment lCurve, rCurve, SelCurve;
    BOOL bIsLeft = TRUE;
   	if(entWall.Is(_T("INSERT"))){
        SelCurve = GetBlkPickSegment(entWall, ptPick);
        if(!SelCurve)
            return 0;
        iLineType = 0;
    }
	else if(entWall.Is(_T("LWPOLYLINE"))){
		double dAngle;
		XPoint ptWcs = Ucs2Wcs(ptPick);
		SelCurve = GetSegByPt(XPoly2D(entWall), ptWcs, dAngle);
		if(!SelCurve)
			return 0;
		iLineType = 0;
	}
    else if(entWall.Is(_T("ATS_WALL"))){
        OPENOBJ_BEGIN(entWall, AcDb::kForRead, TDbWall, pWall);
        XPoint ptNew1, ptNew2;
        if(pWall) {
            pWall->GetSideCurve(lCurve, rCurve);
            lCurve.ProjectToMe(ptPick, ptNew1);
            rCurve.ProjectToMe(ptPick, ptNew2);
            if(ads_distance(ptPick, ptNew1) < ads_distance(ptPick, ptNew2)){
                SelCurve = lCurve;
                bIsLeft = TRUE;
            }
            else{
                SelCurve = rCurve;
                bIsLeft = FALSE;
            }
        }
        OPENOBJ_END();
    }
    else
        iLineType = 1;

    
    if(!SelCurve.Is(CURVE_LINE))
        return RTCAN;
    if(iLineType == 0){
        XLine line = SelCurve.GetLine();
        //得到直线的角度
        line_angle=ads_angle(line.StartPoint(),line.EndPoint());
        if(line_angle > PI)
            line_angle = line_angle - PI;
    }
    else if(iLineType == 1){
        XPoint ptStart, ptEnd;
        entWall.GetData(10, ptStart);
        entWall.GetData(11, ptEnd);
        line_angle=ads_angle(ptStart, ptEnd);
        if(line_angle > PI)
            line_angle = line_angle - PI;
    }
    return RTNORM;
}



AcDbObjectId InitDoteLayer(const TCHAR* szLay)
{
    AcDbObjectId  idLay=GetLayerIdFromString(szLay);
    if(!!idLay)
        return idLay;
    
    AcDbObjectId id = InitLayer(szLay);
    AddLineType(_T("CENTER2"));
    AcDbLinetypeTable *pLinetypeTbl;
    AcDbObjectId ltId;
    Acad::ErrorStatus es = acdbCurDwg()->getLinetypeTable(pLinetypeTbl, AcDb::kForRead);
    if(es != Acad::eOk) {
        return NULL;
    }
    if((pLinetypeTbl->getAt(_T("CENTER2"), ltId)) != Acad::eOk){
        pLinetypeTbl->close();
        return NULL;
    }
    pLinetypeTbl->close();
    
    OPENOBJ_BEGIN(id, AcDb::kForWrite, AcDbLayerTableRecord, pRec);
    if(pRec){
        pRec->setLinetypeObjectId(ltId);
    }
    OPENOBJ_END();
    return id;
}

AcDbObjectId InitGridLayer(const TCHAR* szLay)
{
    AcDbObjectId  idLay=GetLayerIdFromString(szLay);
    if(!!idLay)
        return idLay;
    AcDbObjectId id = InitLayer(szLay);
    AddLineType(_T("DOT"));
    AcDbLinetypeTable *pLinetypeTbl;
    AcDbObjectId ltId;
    Acad::ErrorStatus es = acdbCurDwg()->getLinetypeTable(pLinetypeTbl, AcDb::kForRead);
    if(es != Acad::eOk) {
        return NULL;
    }
    if((pLinetypeTbl->getAt(_T("DOT"), ltId)) != Acad::eOk){
        pLinetypeTbl->close();
        return NULL;
    }
    pLinetypeTbl->close();
    
    OPENOBJ_BEGIN(id, AcDb::kForWrite, AcDbLayerTableRecord, pRec);
    if(pRec){
        pRec->setLinetypeObjectId(ltId);
    }
    OPENOBJ_END();
    return id;
}

AcDbObjectId InitDashLayer(const TCHAR* szLay)
{
    AcDbObjectId  idLay=GetLayerIdFromString(szLay);
    if(!!idLay)
        return idLay;
    
    AcDbObjectId id = InitLayer(szLay);
    AddLineType(_T("DASH"));
    AcDbLinetypeTable *pLinetypeTbl;
    AcDbObjectId ltId;
    Acad::ErrorStatus es = acdbCurDwg()->getLinetypeTable(pLinetypeTbl, AcDb::kForRead);
    if(es != Acad::eOk) {
        return NULL;
    }
    if((pLinetypeTbl->getAt(_T("DASH"), ltId)) != Acad::eOk){
        pLinetypeTbl->close();
        return NULL;
    }
    pLinetypeTbl->close();
    
    OPENOBJ_BEGIN(id, AcDb::kForWrite, AcDbLayerTableRecord, pRec);
    if(pRec){
        pRec->setLinetypeObjectId(ltId);
    }
    OPENOBJ_END();
    return id;
}



///////////////////////////////////////////////////////////////////////////////////////////////////////////////
//以下是李夫银的AcGePoint3dArray排序函数
typedef struct PtOnCrItem
{
    AcGePoint3d m_ptGeOld;
    AcGePoint3d m_ptGeOn;
    AcDbCurve * m_pCurve;
    AcDbObjectId m_ID;
} PTONCRITEM,* PPTONCRITEM;

//回调函数
static bool GreaterCoord(PTONCRITEM item1,PTONCRITEM item2)
{
    AcDbCurve * pCurve = item1.m_pCurve;
    AcGePoint3d ptGe1 = item1.m_ptGeOn;
    AcGePoint3d ptGe2 = item2.m_ptGeOn;
    
    double dDis1 = 0.0,dDis2 = 0.0;
    pCurve->getParamAtPoint(ptGe1,dDis1);
    pCurve->getParamAtPoint(ptGe2,dDis2);
    
    if(dDis1 - dDis2 > 0.000001)
    {
        return false;//up sort
    }
    return true;//down sort
}


void SortPoints(AcGePoint3dArray& points, AcDbCurve * pCurve, BOOL bModifyArray)
{
    PTONCRITEM ptOnCrItem;
    typedef std::vector<PTONCRITEM> PtOnCrItemVector;
    
  //  PtOnCrItemVector::_Tptr p_ptr = (PTONCRITEM *)0;
//    PtOnCrItemVector::_Ctptr p_cptr = (const PTONCRITEM *)0;
    PtOnCrItemVector::reference p_ref = ptOnCrItem;
    PtOnCrItemVector::const_reference p_cref = (const PTONCRITEM&) ptOnCrItem;
    PtOnCrItemVector::value_type * p_val = (PTONCRITEM *)0;
    PtOnCrItemVector::size_type * p_size = (size_t *)0;
    PtOnCrItemVector::difference_type * p_diff = (ptrdiff_t *)0;
    
    PtOnCrItemVector vectorItems;
    ptOnCrItem.m_pCurve = pCurve;
    
    AcGePoint3d ptGeT;
    int nLength = points.length();
    for(int i = 0;i < nLength;i++)
    {
        ptGeT = points.at(i);
        ptOnCrItem.m_ptGeOld = ptGeT;
        pCurve->getClosestPointTo(ptGeT,ptGeT);
        ptOnCrItem.m_ptGeOn = ptGeT;
        vectorItems.push_back(ptOnCrItem);
    }
    
    PtOnCrItemVector::iterator itHead = vectorItems.begin();
    PtOnCrItemVector::iterator itTail = vectorItems.end();
    std::sort(itHead,itTail,GreaterCoord);
    
    itHead = vectorItems.begin();
    itTail = vectorItems.end();
    
    points.removeSubArray(0,nLength - 1);
    AcGePoint3d ptGe;
    
    for(;itHead != itTail;++itHead)
    {
		if(bModifyArray)
			ptGe = (*itHead).m_ptGeOn;
		else
			ptGe = (*itHead).m_ptGeOld;
        points.append(ptGe);
    }
}


void DeleteRepeateWall(AcDbObjectIdArray * pIDWalls)
{
	AcDbObjectIdArray idWalls;
	AcDbObjectIdArray idErases;
	AcDbObjectId id1,id2;
	AcDbEntity * pEnt1 = NULL;
	AcDbEntity * pEnt2 = NULL;
	double dDis1 = 0.0,dDis2 = 0.0;
	int nLen = pIDWalls->length();
	for(int i = 0;i < nLen;i++)
	{
		id1 = pIDWalls->at(i);
		if (Acad::eOk == acdbOpenAcDbEntity(pEnt1,id1,AcDb::kForRead))
		{
			for(int j = 0;j < nLen;j++)
			{
				id2 = pIDWalls->at(j);
				if (id1 != id2)
				{
					if (Acad::eOk == acdbOpenAcDbEntity(pEnt2,id2,AcDb::kForRead))
					{
						if (pEnt1->isKindOf(pEnt2->desc()))
						{
							AcDbLine * pLine1 = AcDbLine::cast(pEnt1);
							AcDbLine * pLine2 = AcDbLine::cast(pEnt2);
							if (pLine1 != NULL && pLine2 != NULL)
							{
								AcGePoint3d ptGeSta1 = pLine1->startPoint();
								AcGePoint3d ptGeEnd1 = pLine1->endPoint();
								AcGePoint3d ptGeSta2 = pLine2->startPoint();
								AcGePoint3d ptGeEnd2 = pLine2->endPoint();
								AcGeVector3d vc1 = ptGeEnd1 - ptGeSta1;
								AcGeVector3d vc2 = ptGeEnd2 - ptGeSta2;
								if (vc1.isParallelTo(vc2))
								{
									AcDbXline xline;
									xline.setUnitDir(vc1);
									xline.setBasePoint(ptGeEnd1);
									AcGePoint3d ptGe;
									xline.getClosestPointTo(ptGeEnd2,ptGe);
									double dDis1 = ptGe.distanceTo(ptGeEnd2);
									if (dDis1 < E6TOL)
									{
										dDis1 = ptGeEnd1.distanceTo(ptGeSta1);
										dDis2 = ptGeEnd2.distanceTo(ptGeSta2);
										AcGePoint3dArray ptS;
										ptS.append(ptGeSta1);
										ptS.append(ptGeEnd1);
										ptS.append(ptGeSta2);
										ptS.append(ptGeEnd2);
										SortPoints(ptS,&xline,TRUE);
										double dDis3 = ptS.first().distanceTo(ptS.last());
										if (dDis1 + dDis2 - dDis3 > E6TOL)
										{
											if (dDis1 - dDis2 < E6TOL)
											{
												pLine1->upgradeOpen();
												pLine1->erase();
												pLine1->downgradeOpen();
												idErases.append(id1);
											}
											else
											{
												pLine2->upgradeOpen();
												pLine2->erase();
												pLine2->downgradeOpen();
												idErases.append(id2);
											}
										}
									}
								}
							}
                            AcDbBlockReference * pBlk1 = AcDbBlockReference::cast(pEnt1);
                            AcDbBlockReference * pBlk2 = AcDbBlockReference::cast(pEnt2);
                            if (pBlk1 != NULL && pBlk2 != NULL)
                            {
                                AcGePoint3d ptLoc1 = pBlk1->position();
                                AcGePoint3d ptLoc2 = pBlk2->position();
                                AcDbObjectId id1 = pBlk1->blockTableRecord();
                                AcDbObjectId id2 = pBlk2->blockTableRecord();
                                double dDis1 = ptLoc1.distanceTo(ptLoc2);
                                if (dDis1 < E6TOL)
                                {
                                    pBlk1->upgradeOpen();
                                    pBlk1->erase();
                                    pBlk1->downgradeOpen();
                                    idErases.append(id1);
                                }
                            }                                
						}
						pEnt2->close();
					}
				}
			}
			pEnt1->close();
		}
	}

	nLen = idErases.length();
	for(i = 0;i < nLen;i++)
	{
		pIDWalls->remove(idErases.at(i));
	}
}
 
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                  OFFSET  2008-1-28 沈睿
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//已知1线段，和偏移距离，和线上1点， 返回偏移后的线段
// 注意：调用者自己必须释放返回的AcDbCurve
AcDbCurve* GetOffsetCurve(AcDbCurve *pCurve, double dOffsetDist, XPoint ptPick)
{
	if(pCurve == NULL)
		return NULL;
	//先OFFSET一根曲线过来
	AcDbVoidPtrArray arCurves;
	pCurve->getOffsetCurves(dOffsetDist, arCurves);
	int len = arCurves.length();
	if(arCurves.length() > 0){
		AcDbCurve *pCurve2;
		pCurve2 = (AcDbCurve *)arCurves.first();
		XPoint ptOnCurve;
		pCurve2->getClosestPointTo(ptPick, ptOnCurve);
		double dDist = ads_distance(ptPick, ptOnCurve);
		 
		long lNum=arCurves.length();
		for(long j=1L; j<lNum; j++) { //必须全部释放
			AcDbEntity *pEnt=(AcDbEntity *)arCurves[j];
			delete pEnt;
		}
		
		if(dDist < 0.001)//通过偏移距离的正负可以得到2根线段，ptPick在哪上就返回哪根
			return pCurve2;
		else{
			delete pCurve2;
			AcDbVoidPtrArray arCurves2;
			pCurve->getOffsetCurves(-dOffsetDist, arCurves2);
			if(arCurves2.length() > 0){
				AcDbCurve *pCurve3;
				pCurve3 = (AcDbCurve *)arCurves2.first();
				long lNum2=arCurves2.length();
				for(j=1L; j<lNum2; j++) {//必须全部释放
					AcDbEntity *pEnt2=(AcDbEntity *)arCurves2[j];
					delete pEnt2;
				}
				
				return pCurve3;
			}
		}
	}
	return NULL;
}


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                  沿线得到PLINE   2008-1-28 沈睿
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////

typedef struct {
	XPoint pt;
	double dBulge;
}XLinePointAndBulge;

void MakeSimplePloyLine(XCurveSegment seg1, XCurveSegment seg2, XPoint ptPick, XPoint ptPick2,XLinePointAndBulge &linePt1,XLinePointAndBulge &linePt2,XLinePointAndBulge &linePt3,XPoint ptTurn)
{
	//判断选中的实体是圆弧还是线
	if(seg1.GetCurveType() == CURVE_LINE && seg2.GetCurveType() == CURVE_LINE){
		
		linePt1.pt = ptPick;
		linePt2.pt = ptTurn;
		linePt3.pt = ptPick2;
		
		linePt1.dBulge = 0;
		linePt2.dBulge = 0;
		linePt3.dBulge = 0;
	}
	else if(seg1.GetCurveType() == CURVE_LINE && seg2.GetCurveType() == CURVE_ARC){
		XArc arc = seg2.GetArc();
		AcGeVector3d vt1(ptPick2-arc.GetCenterPt());
		AcGeVector3d vt2(ptTurn-arc.GetCenterPt());
		double dAngle = vt1.angleTo(vt2);
		double dBulge = tan(0.25 * dAngle);
		// 要确定Bulge的正，负。 如果ptTurn点是弧起点，Bulge为正
		XPoint ptS, ptE;
		arc.GetStartPoint(ptS);
		arc.GetEndPoint(ptE);
		
	//	arc.GetPoints(ptS, ptE);
		if(ptTurn == ptS)
			dBulge = fabs(dBulge);
		else
			dBulge = -fabs(dBulge);
		
		linePt1.pt = ptPick;
		linePt2.pt = ptTurn;
		linePt3.pt = ptPick2;
		
		linePt1.dBulge = 0;
		linePt2.dBulge = dBulge;
		linePt3.dBulge = 0;
	}
	else if(seg2.GetCurveType() == CURVE_LINE && seg1.GetCurveType() == CURVE_ARC){
		XArc arc = seg1.GetArc();
		AcGeVector3d vt1(ptTurn-arc.GetCenterPt());
		AcGeVector3d vt2(ptPick-arc.GetCenterPt());
		double dAngle = vt1.angleTo(vt2);
		double dBulge = tan(0.25 * dAngle);
		XPoint ptS, ptE;
		arc.GetStartPoint(ptS);
		arc.GetEndPoint(ptE);
		
	//	arc.GetPoints(ptS, ptE);
		if(ptTurn == ptS)
			dBulge = -fabs(dBulge);
		else
			dBulge = fabs(dBulge);
		
		linePt1.pt = ptPick;
		linePt2.pt = ptTurn;
		linePt3.pt = ptPick2;
		
		linePt1.dBulge = dBulge;
		linePt2.dBulge = 0;
		linePt3.dBulge = 0;
	}
	else if(seg1.GetCurveType() == CURVE_ARC && seg2.GetCurveType() == CURVE_ARC){
		XArc arc = seg1.GetArc();
		AcGeVector3d vt1(ptTurn-arc.GetCenterPt());
		AcGeVector3d vt2(ptPick-arc.GetCenterPt());
		double dAngle1 = vt1.angleTo(vt2);
		double dBulge1 = tan(0.25 * dAngle1);
		XPoint ptS, ptE;
		arc.GetStartPoint(ptS);
		arc.GetEndPoint(ptE);
		
	//	arc.GetPoints(ptS, ptE);
		if(ptTurn == ptS)
			dBulge1 = -fabs(dBulge1);
		else
			dBulge1 = fabs(dBulge1);
		
		XArc arc2 = seg2.GetArc();
		AcGeVector3d vt3(ptPick2-arc2.GetCenterPt());
		AcGeVector3d vt4(ptTurn-arc2.GetCenterPt());
		double dAngle2 = vt3.angleTo(vt4);
		double dBulge2 = tan(0.25 * dAngle2);
		arc2.GetStartPoint(ptS);
		arc2.GetEndPoint(ptE);
		//arc2.GetPoints(ptS, ptE);
		if(ptTurn == ptS)
			dBulge2 = fabs(dBulge2);
		else
			dBulge2 = -fabs(dBulge2);
		
		linePt1.pt = ptPick;
		linePt2.pt = ptTurn;
		linePt3.pt = ptPick2;
		
		linePt1.dBulge = dBulge1;
		linePt2.dBulge = dBulge2;
		linePt3.dBulge = 0;
	}
}

// 保存PLOYLINE的3点(临时起点 转折点 临时终点)
// 输入ent ent2  ptPick ptPick2
// 输出  linePt1 linePt2 linePt3
// 注意： ent ent2 只能是LINE 或者 ARC
void MakeSimplePloyLine(Entity ent, Entity ent2, XPoint ptPick, XPoint ptPick2,XLinePointAndBulge &linePt1,XLinePointAndBulge &linePt2,XLinePointAndBulge &linePt3,XPoint ptTurn)
{
	XCurveSegment seg1(ent);
	XCurveSegment seg2(ent2);
	MakeSimplePloyLine(seg1, seg2, ptPick, ptPick2, linePt1, linePt2, linePt3, ptTurn);
}

#if ADS <= 17
	struct  CurveNode
	{
		XCurveSegment seg;
		Entity ent;
		AcGeMatrix3d mat;
	};
#endif

// 生成POLYLINE
// 输入 ent ent2 ptPick ptPick2 ptFrom  选中的实体和选中的两点 以及寻找的初始点
// 输出 pLine 生成所需要的PLINE线, pline是由调用者new出来的
// 注意： ent ent2 只能是LINE 或者 ARC
BOOL MakeRightPloyLine(AcDbPolyline *pLine,Entity ent, Entity ent2, XPoint ptPick, XPoint ptPick2,XPoint ptFrom)
{
	XCurveSegment seg(ent);
	XCurveSegment seg2(ent2);
	// cet 2016.7.20 add 支持外部参照
	AcGeMatrix3d mat1 = GetExternalEntityTransform(ent);
	AcGeMatrix3d mat2 = GetExternalEntityTransform(ent2);
	ads_matrix matTemp;
	memcpy(matTemp, &mat1, sizeof(AcGeMatrix3d));
	seg.TransformBy(matTemp);
	memcpy(matTemp, &mat2, sizeof(AcGeMatrix3d));
	seg2.TransformBy(matTemp);
	XLinePointAndBulge linePt1,linePt2,linePt3;//画PLINE线经过的3点
	//存放点的容器
	std::vector<XLinePointAndBulge> vecPt;
	typedef std::vector<XLinePointAndBulge>::iterator iter;
	
	
	XPoint ptTemp1,ptTemp2;//取两点十字集范围内实体的两个点	
	XPoint ptPLineStart, ptPLineEnd, ptPLineTurn;//相邻线的起点 拐点 终点
	ptPLineStart = ptPick;
	Entity entFirst = ent, entNext; //相邻两个实体
	//不断的循环查找下一相邻实体
	//seg变化 seg2不变化
	ptPLineTurn = ptFrom;
	// cet 2016.7.20 add 支持外部参照
#if ADS > 17
	struct  CurveNode
	{
		XCurveSegment seg;
		Entity ent;
		AcGeMatrix3d mat;
	};
#endif
	std::vector<CurveNode> vecCurve;
	AcDbBlockTable *pTbl = NULL;
	acdbCurDwg()->getBlockTable(pTbl, AcDb::kForRead);
	if (pTbl != NULL)
	{
		AcDbBlockTableIterator *it = NULL;
		pTbl->newIterator(it);
		for (it->start(); !it->done(); it->step())
		{
			AcDbBlockTableRecord *pRcd = NULL;
			it->getRecord(pRcd, AcDb::kForRead);
			if (pRcd != NULL && pRcd->isFromExternalReference())
			{
				AcGeMatrix3d mat = AcGeMatrix3d::kIdentity;
				AcDbObjectIdArray arrId;
				pRcd->getBlockReferenceIds(arrId);
				if (arrId.length() != 1)
				{
					pRcd->close();
					continue;
				}
				AcDbBlockReference *pRef = NULL;
				acdbOpenObject(pRef, arrId[0], AcDb::kForRead);
				if (pRef != NULL)
				{
					mat = pRef->blockTransform();
					pRef->close();
				}
				else
				{
					pRcd->close();
					continue;
				}
				ads_matrix matTemp;
				memcpy(matTemp, &mat, sizeof(AcGeMatrix3d));
				AcDbBlockTableRecordIterator *itRec = NULL;
				pRcd->newIterator(itRec);
				for (itRec->start(); !itRec->done(); itRec->step())
				{
					AcDbEntity *pEnt = NULL;
					itRec->getEntity(pEnt, AcDb::kForRead);
					if (pEnt != NULL)
					{
						if (pEnt->isKindOf(AcDbLine::desc()))
						{
							AcDbLine *pLine = (AcDbLine*)pEnt;
							AcGePoint3d pt1, pt2;
							pLine->getStartPoint(pt1);
							pLine->getEndPoint(pt2);
							XCurveSegment seg;
							seg.SetLine(pt1, pt2);
							seg.TransformBy(matTemp);
							ads_name name;
							acdbGetAdsName(name, pEnt->objectId());
							CurveNode node;
							node.seg = seg;
							node.ent = Entity(name);
							node.mat = mat;
							vecCurve.push_back(node);
						}
						else if (pEnt->isKindOf(AcDbArc::desc()))
						{
							AcDbArc *pArc = (AcDbArc*)pEnt;
							XArc arc(XPoint(pArc->center()), pArc->radius(), pArc->startAngle(), pArc->endAngle());
							arc.TransformBy(matTemp);
							ads_name name;
							acdbGetAdsName(name, pEnt->objectId());
							CurveNode node;
							node.seg = arc;
							node.ent = Entity(name);
							node.mat = mat;
							vecCurve.push_back(node);
						}
					}
					pEnt->close();
				}
				delete itRec;
			}
			pRcd->close();
		}
		delete it;
		// 模型空间中的墙体
		AcDbBlockTableRecord *pRcd = NULL;
		pTbl->getAt(ACDB_MODEL_SPACE, pRcd, AcDb::kForRead);
		if (pTbl != NULL)
		{
			AcGeMatrix3d mat = AcGeMatrix3d::kIdentity;
			ads_matrix matTemp;
			memcpy(matTemp, &mat, sizeof(AcGeMatrix3d));
			AcDbBlockTableRecordIterator *itRec = NULL;
			pRcd->newIterator(itRec);
			for (itRec->start(); !itRec->done(); itRec->step())
			{
				AcDbEntity *pEnt = NULL;
				itRec->getEntity(pEnt, AcDb::kForRead);
				if (pEnt != NULL)
				{
					if (pEnt->isKindOf(AcDbLine::desc()))
					{
						AcDbLine *pLine = (AcDbLine*)pEnt;
						AcGePoint3d pt1, pt2;
						pLine->getStartPoint(pt1);
						pLine->getEndPoint(pt2);
						XCurveSegment seg;
						seg.SetLine(pt1, pt2);
						seg.TransformBy(matTemp);
						ads_name name;
						acdbGetAdsName(name, pEnt->objectId());
						CurveNode node;
						node.seg = seg;
						node.ent = Entity(name);
						node.mat = mat;
						vecCurve.push_back(node);
					}
					else if (pEnt->isKindOf(AcDbArc::desc()))
					{
						AcDbArc *pArc = (AcDbArc*)pEnt;
						XArc arc(XPoint(pArc->center()), pArc->radius(), pArc->startAngle(), pArc->endAngle());
						arc.TransformBy(matTemp);
						ads_name name;
						acdbGetAdsName(name, pEnt->objectId());
						CurveNode node;
						node.seg = arc;
						node.ent = Entity(name);
						node.mat = mat;
						vecCurve.push_back(node);
					}
				}
				pEnt->close();
			}
			delete itRec;
			pRcd->close();
		}
		pTbl->close();
	}
	//两个实体相邻则退出
	while(seg.EndPoint().Distance(seg2.StartPoint()) > 0.001 && seg.StartPoint().Distance(seg2.EndPoint()) > 0.001
		&& seg.EndPoint().Distance(seg2.EndPoint()) > 0.001 && seg.StartPoint().Distance(seg2.StartPoint()) > 0.001)
	{
//      cet 2016.7.20 modify 支持外部参照			
// 		ptTemp1 = ptPLineTurn;
// 		ptTemp2 = ptPLineTurn;
// 		ptTemp1.x += 2;
// 		ptTemp1.y += 2;
// 		ptTemp2.x -= 2;
// 		ptTemp2.y -= 2;	
// 		AssureInCurrentView(ptTemp1, ptTemp2);
// 		PickSet ssPoint(SS_FREE);
// 		ssPoint.Get(_T("C"),ptTemp1,ptTemp2, RBList(RTDXF0, _T("LINE,ARC"),  NULL));
		PickSet ssPoint(SS_FREE);
		for (int i = 0; i < vecCurve.size(); ++i)
		{
			XCurveSegment &segTmp = vecCurve[i].seg;
			XPoint pt;
			ptPLineTurn.Project(&segTmp, pt);
			if (pt.Distance2d(ptPLineTurn) < 0.001)
			{
				ssPoint += vecCurve[i].ent;
			}
		}
		ssPoint -= entFirst;
		if(ssPoint.Length() != 1)
			return FALSE;
		entNext = ssPoint[0L];

//		if(ssPoint.Length() != 2)
//			return FALSE;
//		//去掉旧的实体 entNext 是循环的下1段线
//		Entity entPointTemp1, entPointTemp2;
//		entPointTemp1 = ssPoint[0L];
//		entPointTemp2 = ssPoint[1L];
//		
//		if(entPointTemp1 == entFirst)
//			entNext = entPointTemp2;
//		else if(entPointTemp2 == entFirst)
//			entNext = entPointTemp1;
		
		XCurveSegment segNext(entNext);
		// cet 2016.7.20 add 支持外部参照
		AcGeMatrix3d mat = AcGeMatrix3d::kIdentity;
		for (int i = 0; i < vecCurve.size(); ++i)
		{
			if (vecCurve[i].ent == entNext)
			{
				mat = vecCurve[i].mat;
				break;
			}
		}
		ads_matrix matTemp;
		memcpy(matTemp, &mat, sizeof(AcGeMatrix3d));
		segNext.TransformBy(matTemp);
		seg = segNext; //下一个 
		
		if(segNext.StartPoint() == seg.StartPoint() || segNext.StartPoint() == seg.EndPoint())
			ptPLineEnd = segNext.EndPoint();
		else if(segNext.EndPoint() == seg.StartPoint() || segNext.EndPoint() == seg.EndPoint())
			ptPLineEnd = segNext.StartPoint();
		else
			return FALSE;//确保前后2段线一定首尾相连
		
		MakeSimplePloyLine(entFirst,entNext,ptPLineStart,ptPLineEnd,linePt1,linePt2,linePt3,ptPLineTurn);
		
		//取下1段PLINE的拐点
		if (segNext.StartPoint() != ptPLineTurn)
			ptPLineTurn = segNext.StartPoint();
		else
			ptPLineTurn = segNext.EndPoint();
		
		entFirst = entNext;
		ptPLineStart = ptPLineEnd;
		
		if (entFirst == ent)//找到自己则退出
			return FALSE;
		
		vecPt.push_back(linePt1);
		vecPt.push_back(linePt2);
		vecPt.push_back(linePt3);
	}
	MakeSimplePloyLine(entFirst,ent2,ptPLineStart,ptPick2,linePt1,linePt2,linePt3,ptPLineTurn);
	vecPt.push_back(linePt1);
	vecPt.push_back(linePt2);
	vecPt.push_back(linePt3);
	
	//生成PLINE线
	for (int it = 0; it < vecPt.size(); ++it)
	{
		pLine->addVertexAt(it,vecPt[it].pt,vecPt[it].dBulge);
	}
	return TRUE;
}

// 已知一个曲线，并知道曲线上2点，求这2点围成的中间曲线
// 注意：返回的曲线必须调用者自己释放
AcDbCurve* GetCurveBy2Pt(AcDbCurve *pCurve, XPoint ptOnCurve1, XPoint ptOnCurve2)
{
	AcDbVoidPtrArray arSeg;//裁剪后的曲线段
	AcGePoint3dArray arPoint(2);//裁剪的点
	double dDist1, dDist2;
	pCurve->getDistAtPoint(ptOnCurve1, dDist1);
	pCurve->getDistAtPoint(ptOnCurve2, dDist2);
	if(dDist1 < dDist2){
		arPoint.append(ptOnCurve1);
		arPoint.append(ptOnCurve2);
	}
	else{
		arPoint.append(ptOnCurve2);
		arPoint.append(ptOnCurve1);
	}
	
	pCurve->getSplitCurves(arPoint,arSeg);//剪切PLINE线
	int nLen = arSeg.length();
//  cet 2014.12.1 modify 当点在曲线起始点时结果错误
// 	if(nLen != 3)
// 	{
// 		ReleaseEntSet(arSeg);
// 		return NULL;	
// 	}
// 	AcDbCurve *pCurveRet = NULL;
// 	for (int i = 0; i < nLen; ++i)
// 	{
// 		AcDbCurve *pCurve3 = (AcDbCurve*)arSeg[i];
// 		if (pCurve3 != NULL)
// 		{
// 			if(i == 1)
// 				pCurveRet = pCurve3;
// 			else
// 				delete pCurve3;
// 		}
// 	}
	AcGePoint3d ptS, ptE;
	AcDbCurve *pCurveRet = NULL;
	for (int i = 0; i < nLen; ++i)
	{
		AcDbCurve *pCurve3 = (AcDbCurve*)arSeg[i];
		if (pCurve3 != NULL)
		{
			pCurve3->getStartPoint(ptS);
			pCurve3->getEndPoint(ptE);
			if (ptS.distanceTo(ptOnCurve1) < 0.001 && ptE.distanceTo(ptOnCurve2) < 0.001
				|| ptS.distanceTo(ptOnCurve2) < 0.001 && ptE.distanceTo(ptOnCurve1) < 0.001)
			{
				arSeg.removeAt(i);
				pCurveRet = pCurve3;
				break;
			}
		}
	}
	ReleaseEntSet(arSeg);
	return pCurveRet;
}

//已知一个曲线XCurveSegment，以及曲线上2点，返回这2点连成的AcDbPolyline
void GetPLineBySeg(AcDbPolyline *pLine, XCurveSegment seg, XPoint ptPick, XPoint ptPick2) 
{
	if(seg.Is(CURVE_LINE)){
		pLine->addVertexAt(0, ptPick);
		pLine->addVertexAt(1, ptPick2);
	}
	else if(seg.Is(CURVE_ARC)){
		//圆弧
		XArc arc = seg.GetArc();
		AcGeVector3d vt1(ptPick2-arc.GetCenterPt());
		AcGeVector3d vt2(ptPick-arc.GetCenterPt());
		double dAngle = vt1.angleTo(vt2);
		double dBulge = tan(0.25 * dAngle);
		// 要确定Bulge的正，负。 如果PLINE起点离弧起点近，Bulge为正
		AcDbCurve *pCurve = seg.AsAcDbCurve();
		double dDist1(0), dDist2(0);
		pCurve->getDistAtPoint(ptPick, dDist1);
		pCurve->getDistAtPoint(ptPick2, dDist2);
		if(dDist1 < dDist2)
			dBulge = fabs(dBulge);
		else
			dBulge = -fabs(dBulge);

		delete pCurve;
		pLine->addVertexAt(0, ptPick, dBulge);
		pLine->addVertexAt(1, ptPick2);
	}
}

//通过在墙上两点得到PLINE线
BOOL MakePolyLineByWall(AcDbPolyline *pLine,Entity ent, Entity ent2, XPoint ptPick, XPoint ptPick2)
{
	XCurveSegment lCurve, rCurve,firstSeg,secondSeg;
	BOOL bIsLeft = TRUE;
	XPoint ptTurn;
	//得到墙实体1
	OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbWall, pWall);
	XPoint ptNew1, ptNew2;
	if(pWall) {
		pWall->GetSideCurve(lCurve, rCurve);
		lCurve.ProjectToMe(ptPick, ptNew1);
		rCurve.ProjectToMe(ptPick, ptNew2);
		if(ads_distance(ptPick, ptNew1) < ads_distance(ptPick, ptNew2)){
			firstSeg = lCurve;
			bIsLeft = TRUE;
			ptPick = ptNew1;
		}
		else{
			firstSeg = rCurve;
			bIsLeft = FALSE;
			ptPick = ptNew2;
		}
	}
	OPENOBJ_END();
	
	XPoint ptNew3, ptNew4;
	//得到墙实体2
	OPENOBJ_BEGIN(ent2, AcDb::kForRead, TDbWall, pWall2);
	if(pWall2)
	{
		pWall2->GetSideCurve(lCurve, rCurve);
		lCurve.ProjectToMe(ptPick2, ptNew3);
		rCurve.ProjectToMe(ptPick2, ptNew4);
		
		//找到相临的CURVE
		if(firstSeg.StartPoint() == lCurve.StartPoint() || firstSeg.StartPoint() == lCurve.EndPoint()||firstSeg.EndPoint() == lCurve.StartPoint() || firstSeg.EndPoint() == lCurve.EndPoint())
		{
			ptPick2 = ptNew3;
			secondSeg = lCurve;
		}
		else
		{
			ptPick2 = ptNew4;
			secondSeg = rCurve;
		}
		
	}
	OPENOBJ_END();
	
	//得到拐点
	if(firstSeg.StartPoint() == secondSeg.StartPoint() || firstSeg.StartPoint() == secondSeg.EndPoint())
		ptTurn = firstSeg.StartPoint();
	else if(firstSeg.EndPoint() == secondSeg.StartPoint() || firstSeg.EndPoint() == secondSeg.EndPoint())
		ptTurn = firstSeg.EndPoint();
	else
		return FALSE;
	
	XLinePointAndBulge linePoint1,linePoint2,linePoint3;
	//得到构成PLINE线的3点
	MakeSimplePloyLine(firstSeg,secondSeg,ptPick,ptPick2,linePoint1,linePoint2,linePoint3,ptTurn);
	
	if (pLine != NULL)
	{
		pLine->addVertexAt(0,linePoint1.pt,linePoint1.dBulge);
		pLine->addVertexAt(1,linePoint2.pt,linePoint2.dBulge);
		pLine->addVertexAt(2,linePoint3.pt,linePoint3.dBulge);
		AssureInCurrentView(ptPick2, ptPick2);
	}
	
	return TRUE;
}

// 主函数
// 已知2根相邻的线段，给定2个点，返回一个POLYLINE
// 注意：调用者必须自己delete PLINE
AcDbPolyline* GetNextPloyLine(Entity ent, Entity ent2, XPoint ptPick, XPoint ptPick2)
{
	XPoint ptTurn;
	XCurveSegment seg(ent);
	XCurveSegment seg2(ent2);
	// cet 2016.7.20 add 支持外部参照
	AcGeMatrix3d mat1 = GetExternalEntityTransform(ent);
	AcGeMatrix3d mat2 = GetExternalEntityTransform(ent2);
	ads_matrix matTemp;
	memcpy(matTemp, &mat1, sizeof(AcGeMatrix3d));
	seg.TransformBy(matTemp);
	memcpy(matTemp, &mat2, sizeof(AcGeMatrix3d));
	seg2.TransformBy(matTemp);
	//如果是相邻或同一线段求得转折点 
	if(seg.StartPoint() == seg2.StartPoint() || seg.StartPoint() == seg2.EndPoint())
		ptTurn = seg.StartPoint();
	else if(seg.EndPoint() == seg2.StartPoint() || seg.EndPoint() == seg2.EndPoint())
		ptTurn = seg.EndPoint();
	
	AcDbPolyline *pLine = new AcDbPolyline;
	
	if(ent == ent2)
	{ // 如果用户点在本线段
		if(ent.Is(_T("LINE")) || ent.Is(_T("ARC")))
		{
			GetPLineBySeg(pLine, seg, ptPick, ptPick2);
		}
		else if (ent.Is(_T("ATS_WALL")))
		{
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbWall, pWall);
			if(pWall){
				XCurveSegment lCurve, rCurve, seg;
				XPoint ptNew1, ptNew2;
				pWall->GetSideCurve(lCurve, rCurve);
				// cet 2016.7.20 add 支持外部参照
				ads_matrix matTemp;
				memcpy(matTemp, &mat1, sizeof(AcGeMatrix3d));
				lCurve.TransformBy(matTemp);
				rCurve.TransformBy(matTemp);
				lCurve.ProjectToMe(ptPick, ptNew1);
				rCurve.ProjectToMe(ptPick, ptNew2);
				if(ads_distance(ptPick, ptNew1) < ads_distance(ptPick, ptNew2))
					seg = lCurve;
				else
					seg = rCurve;
				GetPLineBySeg(pLine, seg, ptPick, ptPick2);
			}
			OPENOBJ_END();
		}
		else if (ent.Is(_T("LWPOLYLINE")))
		{
			delete pLine;
			AcDbPolyline *pLine2 = NULL;
			OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbPolyline, pCurve);
			if(pCurve)
			{
				AcDbCurve *pNewCurve = (AcDbCurve*)pCurve->clone();
				pNewCurve->transformBy(mat1);
				AcDbCurve *pCurve3 = GetCurveBy2Pt(pNewCurve, ptPick, ptPick2);
				if(pCurve3 != NULL)
					pLine2 = AcDbPolyline::cast(pCurve3);
				if(pLine2 == NULL)
					delete pCurve3;
				delete pNewCurve;
			}
			OPENOBJ_END();
			AssureInCurrentView(ptPick2, ptPick2);
			return pLine2;
		}
		else {
			delete pLine;
			return NULL;
		}
	}
	else{  // 如果用户点在不同并且不相邻线段
		//不支持2个相邻的线段，有1个是PLINE
		if (ent.Is(_T("LWPOLYLINE")) || ent2.Is(_T("LWPOLYLINE"))){
			delete pLine;
			return NULL;
		}
		if (ptTurn != seg.StartPoint() && ptTurn != seg.EndPoint())
		{
			//如果是封闭曲线则不画
			BOOL bTrue1 = MakeRightPloyLine(pLine,ent,ent2,ptPick,ptPick2,seg.StartPoint());
			BOOL bTrue2 = MakeRightPloyLine(pLine,ent,ent2,ptPick,ptPick2,seg.EndPoint());
			
			if (bTrue1 && bTrue2)
			{
				adsout << _T("所选线段在封闭的环中\n");
				delete pLine;
				return NULL;
			}
			if (!bTrue1 && !bTrue2)
			{
				delete pLine;
				
				XPoint ptInter1,ptInter2;
				if (seg.Intersection(seg2,ptInter1,ptInter2) != 1)
				{
					adsout << _T("所选线段与当前线段没有相连\n");
					return NULL;
				}
				else
				{
					//实体相邻且只有一个交点
					pLine = new AcDbPolyline;
					XLinePointAndBulge linePoint1,linePoint2,linePoint3;
					//通过给定的实体和点得到构成PLINE线的3点
					//ent ent2 ptPick ptPick2 为选中的实体和点  ptInter1 为两实体交点
					MakeSimplePloyLine(ent,ent2,ptPick,ptPick2,linePoint1,linePoint2,linePoint3,ptInter1);

					if (pLine != NULL)
					{
						pLine->addVertexAt(0,linePoint1.pt,linePoint1.dBulge);
						pLine->addVertexAt(1,linePoint2.pt,linePoint2.dBulge);
						pLine->addVertexAt(2,linePoint3.pt,linePoint3.dBulge);
						AssureInCurrentView(ptPick2, ptPick2);
					}

					return pLine;
				}
			}

		}
		else
		{
			if (ent.Is(_T("ATS_WALL")) && ent2.Is(_T("ATS_WALL")))
			{
				
				if(!MakePolyLineByWall(pLine,ent,ent2,ptPick,ptPick2)){
					delete pLine;
					return NULL;
				}
				return pLine;	
			}
			else
			{
				BOOL bTrue3 = MakeRightPloyLine(pLine,ent,ent2,ptPick,ptPick2,ptTurn);
				if (!bTrue3)
				{
					delete pLine;
					return NULL;
				}
				
			}
		}
		
	}
	AssureInCurrentView(ptPick2, ptPick2);
	return pLine;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//   2008-2-25 谢真
/////////////////////////////////////////////////////////////////////////////////////////////////////////


//通过选中的一点和选中的实体生成PLINE线
BOOL  GetOneSidePolyLine(Entity ent,XPoint ptPick,AcDbPolyline *pPolyLine,std::vector<XLinePointAndBulge> &vecPt,BOOL bFirst,BOOL &bHasNext)
{
	if (pPolyLine == NULL)
		return FALSE;

	bHasNext = TRUE;
	BOOL bClosed = TRUE; //判断是否是闭合的
	BOOL bFirstExt = TRUE; //是否是起点

	XCurveSegment seg(ent); 
	XPoint ptTemp1,ptTemp2;//取两点十字集范围内实体的两个点
	XPoint ptFirst,ptNext,ptEnd,ptTurn;
	Entity entPointTemp1, entPointTemp2,entNext,entFirst;
	
	ptNext = ptPick;
	ptTurn = ptPick;
	entFirst = ent;
	if (ptPick == seg.StartPoint())
		ptEnd = seg.EndPoint();
	else
		ptEnd = seg.StartPoint();
	ptFirst = ptEnd;
	
	AcDbObjectIdArray arIDFirst,arIDNext;
	AcDbObjectId idTemp;
	XLinePointAndBulge linePoint1,linePoint2,linePoint3;
	while (ptNext != ptEnd)//不断寻找下一段
	{
		ptTemp1 = ptTurn;
		ptTemp2 = ptTurn;
		ptTemp1.x += 2;
		ptTemp1.y += 2;
		ptTemp2.x -= 2;
		ptTemp2.y -= 2;
		
		AssureInCurrentView(ptTemp1, ptTemp2);
		PickSet ssPoint(SS_FREE);
		ssPoint.Get(_T("C"),ptTemp1,ptTemp2, RBList(RTDXF0, _T("LINE,ARC"),  NULL));
		if(ssPoint.Length() != 2)
		{
			bClosed = FALSE;
			
			if (bFirstExt)
				bHasNext = FALSE;
			break;
		}
		
		entPointTemp1 = ssPoint[0L];
		entPointTemp2 = ssPoint[1L];
		
		//得到相邻下一段实体
		if(entPointTemp1 == entFirst)
			entNext = entPointTemp2;
		else if(entPointTemp2 == entFirst)
			entNext = entPointTemp1;
		
		XCurveSegment segNext(entNext);
		if (segNext.StartPoint() == ptNext)
			ptNext = segNext.EndPoint();
		else if (segNext.EndPoint() == ptNext)
			ptNext = segNext.StartPoint();
		else
		{
			bClosed = FALSE;
			break;
		}
		
		if (bFirst)
		{
			//第一次寻找则存放实体
			acdbGetObjectId(idTemp,entFirst.name);
			arIDFirst.append(idTemp);
			acdbGetObjectId(idTemp,entNext.name);
			arIDNext.append(idTemp);
		}
		else
		{
			//第二次则得到寻找的所有点
			MakeSimplePloyLine(entFirst,entNext,ptFirst,ptNext,linePoint1,linePoint2,linePoint3,ptTurn);
			if (bFirstExt)
			{
				vecPt.push_back(linePoint1);
				bFirstExt = FALSE;
			}
			//存放拐点
			vecPt.push_back(linePoint2);
		}
		
		entFirst = entNext;
		ptFirst = ptTurn;
		ptTurn = ptNext;
	}
	
	if (bFirst)
	{
		// 第一次执行 则将实体排序
		int nSize = arIDFirst.length();
		ads_name adTempName;
		Entity ent1,ent2;
		XPoint ptPick1,ptPick2,ptTurn;
		for (int i = nSize-1; i >= 0; --i)
		{
			acdbGetAdsName(adTempName,arIDFirst[i]);
			ent2 = adTempName;
			acdbGetAdsName(adTempName,arIDNext[i]);
			ent1 = adTempName;
			
			XCurveSegment seg(ent1);
			XCurveSegment seg2(ent2);
			//如果是相邻或同一线段求得转折点 
			if(seg.StartPoint() == seg2.StartPoint() || seg.StartPoint() == seg2.EndPoint())
			{
				ptTurn = seg.StartPoint();
				ptPick1 = seg.EndPoint();
				if (ptTurn == seg2.StartPoint())
					ptPick2 = seg2.EndPoint();
				else
					ptPick2 = seg2.StartPoint();
			}
			else if(seg.EndPoint() == seg2.StartPoint() || seg.EndPoint() == seg2.EndPoint())
			{
				ptTurn = seg.EndPoint();
				ptPick1 = seg.StartPoint();
				if (ptTurn == seg2.StartPoint())
					ptPick2 = seg2.EndPoint();
				else
					ptPick2 = seg2.StartPoint();
			}
			else
				return FALSE;
			MakeSimplePloyLine(ent1,ent2,ptPick1,ptPick2,linePoint1,linePoint2,linePoint3,ptTurn);
			
			//存放起点
			if (bFirstExt)
			{
				vecPt.push_back(linePoint1);
				bFirstExt = FALSE;
			}		
			//存放拐点
			vecPt.push_back(linePoint2);
		}
	}
	else
	{
		//存放终点
		if (bHasNext)
			vecPt.push_back(linePoint3);
	}
	
	//封闭的则需加入起点
	if (bClosed)
		vecPt.push_back(vecPt[0]);
	return bClosed;
}

// 主函数
// 已知1段LINE或ARC, 返回它所连接所有的线段所组成的PLINE，可能是封闭，也可能不封闭。
// 所有线段必须首尾相连，且不分叉
// 传入：ent 所选取的LINE或ARC 返回：pPolyLine 
// 注意：PLINE指针由调用者自己在外面分配空间
 
void GetLoopPLineBySeg(Entity ent, AcDbPolyline *pPolyLine)
{
	if (pPolyLine == NULL)
		return;
	std::vector<XLinePointAndBulge> vecPt;
	typedef std::vector<XLinePointAndBulge>::iterator iter;
	XCurveSegment seg(ent);
	BOOL bHasNext1,bHasNext2;
	if (!GetOneSidePolyLine(ent,seg.StartPoint(),pPolyLine,vecPt,TRUE,bHasNext1))//不是闭合的则需找另外一个方向
	{
		GetOneSidePolyLine(ent,seg.EndPoint(),pPolyLine,vecPt,FALSE,bHasNext2);
		if (!bHasNext1 && !bHasNext2)//实体不连续
		{
			if (ent.Is(_T("LINE")))
			{
				pPolyLine->addVertexAt(0, seg.StartPoint());
				pPolyLine->addVertexAt(1, seg.EndPoint());
			}
			else
			{
				//圆弧
				XArc arc(ent);
				AcGeVector3d vt1(seg.EndPoint()-arc.GetCenterPt());
				AcGeVector3d vt2(seg.StartPoint()-arc.GetCenterPt());
				double dAngle = vt1.angleTo(vt2);
				double dBulge = tan(0.25 * dAngle);
				// 要确定Bulge的正，负。 如果PLINE起点离弧起点近，Bulge为正
				OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbCurve, pCurve);
				if(pCurve)
				{
					double dDist1(0), dDist2(0);
					pCurve->getDistAtPoint(seg.StartPoint(), dDist1);
					pCurve->getDistAtPoint(seg.EndPoint(), dDist2);
					if(dDist1 < dDist2)
						dBulge = fabs(dBulge);
					else
						dBulge = -fabs(dBulge);
				}
				OPENOBJ_END();
				pPolyLine->addVertexAt(0, seg.StartPoint(), dBulge);
				pPolyLine->addVertexAt(1, seg.EndPoint());
			}
		}
	}
	
	//生成PLINE线
	for (int it = 0; it < vecPt.size(); ++it)
	{
		pPolyLine->addVertexAt(it,vecPt[it].pt,vecPt[it].dBulge);
	}
}

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

// 获得当前视口的左下角点右上角点 (UCS点)
void GetCurrentViewExtent(XPoint &ptMin, XPoint &ptMax)
{
	struct resbuf rb = {NULL, RT3DPOINT, 0};
	acedGetVar(_T("VIEWCTR"), &rb);
	AcGePoint3d ptView = asPnt3d(rb.resval.rpoint);
	acedGetVar(_T("SCREENSIZE"), &rb);
	AcGePoint3d ptSize = asPnt3d(rb.resval.rpoint);
	double dXSize = ptSize.x;
	double dYSize = ptSize.y;
	dXSize = PixelToWcs(dXSize);
	dYSize = PixelToWcs(dYSize);
	ptMin.x = ptView.x - dXSize / 2;
	ptMin.y = ptView.y - dYSize / 2;
	ptMin.z = ptView.z;
	ptMax.x = ptView.x + dXSize / 2;
	ptMax.y = ptView.y + dYSize / 2;
	ptMax.z = ptView.z;
}

// 根据wcs下外包框的左下角点和右上角点,求得ucs下次外包框的左下角点和右上角点(返回值为ucs点)
void GetUcsExtent(const XPoint &ptLow, const XPoint &ptUp, XPoint &ptNewLow, XPoint &ptNewUp)
{
	XPoint pt1;    // wcs下外包框的左上点
	XPoint pt2;    // wcs下外包框的右下点
	pt1.x = ptLow.x;
	pt1.y = ptUp.y;
	pt1.z = ptLow.z;
	pt2.x = ptUp.x;
	pt2.y = ptLow.y;
	pt2.z = ptLow.z;
	
	AcDbExtents ext;
	ext.addPoint(Wcs2Ucs(pt1));
	ext.addPoint(Wcs2Ucs(pt2));
	ext.addPoint(Wcs2Ucs(ptLow));
	ext.addPoint(Wcs2Ucs(ptUp));
	ptNewLow = ext.minPoint();
	ptNewUp = ext.maxPoint();
}

Acad::ErrorStatus AssureInCurrentView_New(const XPoint &ptLow, const XPoint &ptUp)
{
	// 当前视口的左下角点右上角点
    XPoint lowCorner, upCorner;
	GetCurrentViewExtent(lowCorner, upCorner);
	
	// 根据ptLow, ptUp获得ucs下外包框的左下角点和右上角点
	XPoint ptUcsLow, ptUcsUp;
	GetUcsExtent(ptLow, ptUp, ptUcsLow, ptUcsUp);
	ptUcsLow.z = ptUcsUp.z = lowCorner.z;
	
	// 求最大值点，最小值点
    XPoint ptMin = Min(ptUcsLow, lowCorner);
	XPoint ptMax = Max(ptUcsUp, upCorner);
	
	if (ptMin != lowCorner || ptMax != upCorner)  //点不在屏幕当前视图之内
	{
		//2004下UCS, AssureInCurrentView运行特别慢 2009-8-12 sr
		BOOL bIsUcs = FALSE;
		XPoint ptUcsLow = Wcs2Ucs(ptLow);
		XPoint ptUcsUp = Wcs2Ucs(ptUp);
		if(ptUcsLow != ptLow && ptUcsUp != ptUp)
			bIsUcs = TRUE;
		double dd = g_nAcadVer;
		if(g_nAcadVer>15.1 && g_nAcadVer<16.01 && bIsUcs) // sr 2010-2-26 >15.0001 改为 >15.1 （ACAD2002是15.006）
			ads_command(RTSTR, _T("ZOOM"), RTSTR, _T("W"), RT3DPOINT, &ptUcsLow, RT3DPOINT, &ptUcsUp, RTNONE);
		else
			AssureInCurrentView(Ucs2Wcs(ptMin), Ucs2Wcs(ptMax));  
	}
	
    return Acad::eOk;
}