#include "stdafx.h"
#include "TAPI.h"
#include "TelDef.h"
#include "XBlock.h"
#include "wire.h"
//#include <arxtools.h>
#include <dbrect.h>
#include <actrans.h>

Entity GetWireByPoint(XPoint pt)
{
    PickSet ss(SS_FREE);
    RBList rbMask = ads_buildlist(RTDXF0, _T("ARC,LINE"), 8, GetLayerNames(_T("导线")), NULL);
    GetPointPickSet(pt, ss, rbMask, 1);
    int len = ss.Length();
    if(ss.Length() != 1)
        return Entity();
    else
        return ss[0L];
}

Entity GetPWireByPoint(XPoint pt)
{
    PickSet ss(SS_FREE);
    RBList rbMask = ads_buildlist( -4, _T("<or"),
        -4, _T("<and"), RTDXF0, _T("LWPOLYLINE"), 8, GetLayerNames(_T("导线")), -4, _T("and>"),  
        -4, _T("<and"), RTDXF0, _T("LINE"), 8, GetLayerNames(_T("导线")), -4, _T("and>"),  
        -4, _T("<and"), RTDXF0, _T("ARC"), 8, GetLayerNames(_T("导线")), -4, _T("and>"),  
        -4, _T("or>"), NULL);
	XPoint ptUcs = Wcs2Ucs(pt);
    GetPointPickSet(ptUcs, ss, rbMask, 30);
    int len = ss.Length();
    if(ss.Length() != 1)
        return Entity();
    else
        return ss[0L];
}


resbuf *GetWireMask()//注意RB没有释放，需要调用者自己释放
{
	resbuf *rbRet = ads_buildlist(RTDXF0, _T("ARC,LINE"), 8, GetLayerNames(_T("导线")), NULL);
	return rbRet;
}

resbuf *GetThickWireMask()//注意RB没有释放，需要调用者自己释放
{
	resbuf *rbRet = ads_buildlist(RTDXF0, _T("LWPOLYLINE"), 8, GetLayerNames(_T("导线")), NULL);
	return rbRet;
}


void  GetBlkExplodeCurves(AcDbEntity *pEnt, AcArray<XCurveSegment, AcArrayObjectCopyReallocator<XCurveSegment> > &arCurves)
{
	if(pEnt == NULL)
		return;
	AcDbVoidPtrArray arEnts;
	pEnt->explode(arEnts);
	for (int j = 0; j < arEnts.length(); ++j)
	{
		AcDbEntity *pEnt = (AcDbEntity*)arEnts[j];
		AcDbLine *pLine = NULL;
		AcDbPolyline *pPLine = NULL;
		AcDbArc *pArc = NULL;
		AcDbCircle *pCir = NULL;
		AcDbBlockReference *pBlock = NULL;
		XCurveSegment seg;
		if(pLine = AcDbLine::cast(pEnt)){
			XLine line(XPoint(pLine->startPoint()), XPoint(pLine->endPoint()));
			seg = line;
			arCurves.append(seg);
		}
		else if(pArc = AcDbArc::cast(pEnt)){
			AcGePoint3d ptStart, ptEnd;
			pArc->getStartPoint(ptStart);
			pArc->getEndPoint(ptEnd);
			double dAng(0), dLen(0);
			pArc->getDistAtPoint(ptEnd, dLen);
			dAng = dLen / pArc->radius();
			XArc arc(XPoint(ptStart), XPoint(ptEnd), dAng);
			seg = arc;
			arCurves.append(seg);
		}
		else if(pCir = AcDbCircle::cast(pEnt)){
			AcGePoint3d ptCen = pCir->center();
			XCircle cir(XPoint(ptCen), pCir->radius());
			seg = cir;
			arCurves.append(seg);
		}
		else if(pPLine = AcDbPolyline::cast(pEnt)){
			XPoly2D poly;
			PolyConvert(*pPLine, poly);
			for(int n=0; n<poly.TotalSegments(); n++) {
				XCurveSegment seg;
				poly.Nth(n, seg);
				arCurves.append(seg);
			}					
		}
		else if(pBlock = AcDbBlockReference::cast(pEnt)){
			GetBlkExplodeCurves(pEnt, arCurves);
		}
	}
	ReleaseEntSet(arEnts);
}


//判断一个线段是否接在一组线段上
BOOL IsSegLinkSegs(XCurveSegment segMain, AcArray<XCurveSegment, AcArrayObjectCopyReallocator<XCurveSegment> > &arSegs, XPoint &ptConnect)
{
	BOOL bRet = FALSE;
	XPoint ptStart, ptEnd;
	ptStart = segMain.StartPoint();
	ptEnd = segMain.EndPoint();
	XPoint pt1,pt2;
	
	//找到管线与实体交点，并判断交点是否在实体表面
	for (int i = 0; i < arSegs.length(); ++i)
	{
		XCurveSegment seg = arSegs[i];
 
		if (seg.Intersection(segMain, pt1, pt2) > 0)
		{
			if (pt1.Distance2d(ptStart) < 1E-3)
			{
				bRet = TRUE;
				ptConnect = ptStart;
				break;
			}
			else if (pt1.Distance2d(ptEnd) < 1E-3)
			{
				bRet = TRUE;
				ptConnect = ptEnd;
				break;
			}
		}
		else if(seg.Is(CURVE_LINE))//如果没有交点（平行），但导线的端点在线段上，也算连接
		{
			XLine line = seg.GetLine();
			int ret1 = ptStart&line;
			if(ret1 == PR_ONPT1 || ret1 == PR_ONPT2 || ret1 == PR_INSIDE)
			{
				bRet = TRUE;
				ptConnect = ptStart;
				break;
			}
			int ret2 = ptEnd&line;
			if(ret2 == PR_ONPT1 || ret2 == PR_ONPT2 || ret2 == PR_INSIDE)
			{
				bRet = TRUE;
				ptConnect = ptEnd;
				break;
			}

		}
	}
	
	return bRet;
}

//判断一根导线是否接在一个设备上
BOOL IsWireInEnt(Entity ent, Entity entEq, XPoint &ptConnect)
{
	BOOL bTrue = FALSE;
	AcArray<XCurveSegment, AcArrayObjectCopyReallocator<XCurveSegment> > arSegs;

	AcDbObjectId eId1;
	AcDbEntity *pEnt1 = NULL;
	acdbGetObjectId(eId1, entEq);
	acdbOpenObject(pEnt1, eId1, AcDb::kForRead);
	GetBlkExplodeCurves(pEnt1, arSegs);
	pEnt1->close();
	
	if(ent.Is(_T("LINE")) || ent.Is(_T("ARC")))
	{
		XCurveSegment segMain(ent);
		bTrue = IsSegLinkSegs(segMain, arSegs, ptConnect);
	}
	else if(ent.Is(_T("LWPOLYLINE")))
	{
		//对于pline，把首尾2根线段取出来，和arSegs判断是否连接
		XPoly2D poly(ent);
		XCurveSegment seg;
		poly.Nth(0, seg);
		bTrue = IsSegLinkSegs(seg, arSegs, ptConnect);
		if(!bTrue && poly.TotalSegments() > 1)
		{
			int num = poly.TotalSegments();
			poly.Nth(num-1, seg);
			bTrue = IsSegLinkSegs(seg, arSegs, ptConnect);
		}
	}		
	return bTrue;
}

//老函数暂时取消，因为在弧线不圆的情况下，SS.GET是得不到正确结果的 sr 091109
BOOL IsWireInEnt2(Entity ent, Entity entEq, XPoint &ptConnect)
{
	RBList rbMask = ads_buildlist(RTDXF0, _T("INSERT"), NULL);
	
	XPoint ptStart, ptEnd;
	GetWire2Point(ent, ptStart, ptEnd);
	PickSet ss(SS_FREE);
	XPoint ptTemp1, ptTemp2;
	ptTemp1.x = ptStart.x - MM;
	ptTemp1.y = ptStart.y + MM;
	ptTemp2.x = ptStart.x + MM;
	ptTemp2.y = ptStart.y - MM;
	XPoint ptUcs1, ptUcs2;
	XLine line(ptTemp1, ptTemp2);
	line.Make();

	ptUcs1 = Wcs2Ucs(ptTemp1);
	ptUcs2 = Wcs2Ucs(ptTemp2);
	XRectAngle rect(ptUcs1, ptUcs2);
	struct resbuf *list = ads_buildlist(  RTPOINT, &rect.GetLowLeft(), RTPOINT, &rect.GetLowRight(),
		RTPOINT, &rect.GetUpRight(), RTPOINT, &rect.GetUpLeft(),
		RTPOINT, &rect.GetLowLeft(), NULL);
    //2009-11-9 沈睿 把c选改为cp选， 在某些图上，明明没有接触， 程序也选到了
	ss.Get(_T("CP"), list, NULL, rbMask);//	ss.Get(_T("C"), ptUcs1, ptUcs2, rbMask);
	ads_relrb(list);
	ptConnect = ptStart;
	long len = ss.Length();
	for(long i=0;i<len;i++)
	{
		Entity entTemp = ss[i];
		if(entTemp == entEq)
		{
			return TRUE;
		}
	}
	ptConnect = ptEnd;
	ptTemp1.x = ptEnd.x - MM;
	ptTemp1.y = ptEnd.y + MM;
	ptTemp2.x = ptEnd.x + MM;
	ptTemp2.y = ptEnd.y - MM;
	XLine line2(ptTemp1, ptTemp2);
	line2.Make();
	
	PickSet ss2(SS_FREE);
	ptUcs1 = Wcs2Ucs(ptTemp1);
	ptUcs2 = Wcs2Ucs(ptTemp2);
	XRectAngle rect2(ptUcs1, ptUcs2);
	struct resbuf *list2 = ads_buildlist(  RTPOINT, &rect2.GetLowLeft(), RTPOINT, &rect2.GetLowRight(),
		RTPOINT, &rect2.GetUpRight(), RTPOINT, &rect2.GetUpLeft(),
		RTPOINT, &rect2.GetLowLeft(), NULL);
	ss2.Get(_T("CP"), list2, NULL, rbMask);//	ss2.Get(_T("C"), ptUcs1, ptUcs2, rbMask);
	ads_relrb(list2);
	len = ss2.Length();
	for(i=0;i<len;i++)
	{
		Entity entTemp = ss2[i];
		if(entTemp == entEq)
		{
			return TRUE;
		}
	}
	return FALSE;
}

//得到图块所引出的所有的导线
BOOL GetAllWireInEq(PickSet &ssSel, Entity entEq, BOOL bIsTouch, RBList &rbMask)  
{
	ads_point lowPt, upPt;
	entEq.GetExtend(lowPt, upPt);
	XRectAngle box(lowPt, upPt);
	XPoly2D poly2d(1);
	box.AsPoly2D(poly2d);
	poly2d.TransUCS(Groups(0), Groups(1));
	RBList rbFence=poly2d.Fence();
	ssSel.Get(_T("F"), rbFence, NULL, rbMask);
	ssSel -= entEq;
	XPoint ptConnect;
	long ssLen = ssSel.Length();
	for(long i=0;i<ssLen;i++){
		Entity entTemp = ssSel[i];
		if(!IsWireInEnt(entTemp, entEq, ptConnect) && bIsTouch){
			ssSel -= entTemp;
			i--;
			ssLen--;
		}
		if(IsWireInEnt(entTemp, entEq, ptConnect) && !bIsTouch){
			ssSel -= entTemp;
			i--;
			ssLen--;
		}
	}
	return TRUE;
}


void GetAllEqByWire(Entity entwire, Entity &ent1, Entity &ent2)
{
    Entity entEq;
	PickSet ssStart(SS_FREE);
	PickSet ssEnd(SS_FREE);
    RBList rbMask(RTDXF0, _T("INSERT"), 8, GetLayerNames(_T("设备")), NULL);
	XPoint ptStart, ptEnd, ptConnect;
	GetWire2Point(entwire, ptStart, ptEnd);
	
	XPoint ptTemp1, ptTemp2;
	ptTemp1.x = ptStart.x - MM*20;
	ptTemp1.y = ptStart.y + MM*20;
	ptTemp2.x = ptStart.x + MM*20;
	ptTemp2.y = ptStart.y - MM*20;
	ssStart.Get(_T("C"), ptTemp1, ptTemp2, rbMask);
	int lenS = ssStart.Length();
	if(ssStart.Length() > 0)
	{
		int idx = 0;
		Entity entTmp;
		for(long i=0;i<lenS;i++){
			Entity entEq = ssStart[i];
			if(IsWireInEnt(entwire, entEq, ptConnect))
			{
				idx++;
				entTmp = entEq;
			}
		}
		if(idx == 1)
			ent1 = entTmp;
	}


	ptTemp1.x = ptEnd.x - MM*20;
	ptTemp1.y = ptEnd.y + MM*20;
	ptTemp2.x = ptEnd.x + MM*20;
	ptTemp2.y = ptEnd.y - MM*20;
	ssEnd.Get(_T("C"), ptTemp1, ptTemp2, rbMask);
	int lenE = ssEnd.Length();
	if(ssEnd.Length() > 0)
	{
		int idx = 0;
		Entity entTmp;
		for(long i=0;i<lenE;i++){
			Entity entEq = ssEnd[i];
			if(IsWireInEnt(entwire, entEq, ptConnect))
			{
				idx++;
				entTmp = entEq;
			}
		}
		if(idx == 1)
			ent2 = entTmp;
	}
	
	return;
}

//得到图块所引出的所有的导线, 及接线点
BOOL GetAllWireInEq(PickSet &ssSel, Entity entEq, XPointList &lstPt, RBList &rbMask)  
{
	XPoint lowPt, upPt;
 	entEq.GetExtend(lowPt, upPt);
	lowPt.x = lowPt.x - MM/2;
	lowPt.y = lowPt.y - MM/2;
	upPt.x = upPt.x + MM/2;
	upPt.y = upPt.y + MM/2;
	XRectAngle box(lowPt, upPt);
 
	XPoly2D poly2d(1);
	box.AsPoly2D(poly2d);
	poly2d.TransUCS(Groups(0), Groups(1));
	RBList rbFence=poly2d.Fence();
	PickSet ssTmp(SS_FREE);
	ssTmp.Get(_T("F"), rbFence, NULL, rbMask);
	ssTmp -= entEq;
	XPoint ptConnect;
	long ssLen = ssTmp.Length();
	for(long i=0;i<ssLen;i++){
		Entity entTemp = ssTmp[i];
		if(IsWireInEnt(entTemp, entEq, ptConnect))
		{
			ssSel += entTemp;
			XPoint *ptNew = new XPoint();
			*ptNew = ptConnect;
			lstPt.Append(ptNew);
		}
	}
	return TRUE;
}



//得到设备块上的接线点, 如果是圆设备,返回圆心和半径
BOOL GetEquipPoint(Entity entBlk, XPointList &lstPt, double &nRadius)
{
	if(!entBlk)
		return FALSE;
	BOOL bIsCircle = FALSE;
	AcGePoint3d ptCen;
	XBlock myBlock(entBlk);
	if(!myBlock.m_bInitSuccess)
		return FALSE;
	nRadius = -1;
	AcDbBlockTableRecordIterator *pIterator;
	pIterator = myBlock.GetIterator();
	for(pIterator->start(); !pIterator->done(); pIterator->step()){
		AcDbEntity *pEnt;
		pIterator->getEntity(pEnt, AcDb::kForRead);
		AcDbBlockReference *pBlk = NULL;
		AcDbCircle  *pCir = NULL;
		AcDbPoint *pPoint = NULL;
		if(pBlk = AcDbBlockReference::cast(pEnt)){
			AcGePoint3d ptIns = pBlk->position();
			ptIns = ptIns.transformBy(myBlock.GetMatrix3d());
			lstPt.NewAppend(ptIns);
		}
		else if(pPoint = AcDbPoint::cast(pEnt)){
			AcGePoint3d ptIns = pPoint->position();
			ptIns = ptIns.transformBy(myBlock.GetMatrix3d());
			lstPt.NewAppend(ptIns);
		}
		else if(pCir = AcDbCircle::cast(pEnt)){
			double jj = pCir->radius();
			if(((pCir->radius() > 0.3) && (pCir->radius() > nRadius)) || ((pCir->radius() > 0.3) && (nRadius < 0))){
				nRadius = pCir->radius();
				ptCen = pCir->center();
				ptCen = ptCen.transformBy(myBlock.GetMatrix3d());
			}
		}
		pEnt->close();
	}
	if(nRadius > 0){
		bIsCircle = TRUE;
		lstPt.Reset();
		lstPt.NewAppend(ptCen);
	}
	return bIsCircle;
}

//李盛达 2013-12-31 重新写
BOOL DrawPLineWireBy2Equip(Entity oldent, Entity ent1, Entity ent2)
{
	BOOL bRet(FALSE);
	CWire wire1(oldent);
	CString csLayer = wire1.GetWireLayer();
	CString csLineType = wire1.GetLineType();
	double nLineThick = wire1.GetLineThick();
	CString csName = ReadXdata(oldent, _T("linenum"));
	CString csType = ReadXdata(oldent, _T("ltype"));
	CString csRadius = ReadXdata(oldent, _T("ldm"));
	CString csMode = ReadXdata(oldent, _T("lmeth"));
	CString csPlace = ReadXdata(oldent, _T("linst"));
	CString csArea = ReadXdata(oldent, _T("lnoar"));
	CString csNorm = ReadXdata(oldent, _T("lnorm"));

	XPoint ptCen1, ptCen2;
	XPointList lst111, lst222;
	BOOL flag1(FALSE), flag2(FALSE), bIsLamp1(FALSE), bIsLamp2(FALSE);
	double nRadius1(0.0), nRadius2(0.0);
	CString csAttribText1 = GetAttrib(ent1, _T("A"));
	CString csAttribText2 = GetAttrib(ent2, _T("A"));

	//    if(csAttribText1.Find(_T("荧光灯")) > -1 && csAttribText2.Find(_T("荧光灯")) < 0){
	//        ent1.GetData(10, ptCen1);
	//        bIsLamp1 = TRUE;
	//    }
	//    else if(csAttribText2.Find(_T("荧光灯")) > -1 && csAttribText1.Find(_T("荧光灯")) < 0){
	//        bIsLamp2 = TRUE;
	//        ent2.GetData(10, ptCen2);
	//    }

	flag1 = GetEquipPoint(ent1, lst111, nRadius1);
	flag2 = GetEquipPoint(ent2, lst222, nRadius2);
	//2008-4-9 sr 增加以下40行. 解决,开关连接荧光灯的时候, 希望连接在荧光灯的中间, 而不是根据就近原则连接到荧光灯的边上
	//if(csAttribText1.Find(_T("开关")) > -1 && csAttribText2.Find(_T("荧光灯")) > -1){
	//	XPointList lstPtTrue;
	//	double dLampAng(0);
	//	ent2.GetData(50, &dLampAng);
	//	XPoint ptLampTmp, ptLampIns;
	//	ent2.GetData(10, ptLampIns);
	//	ads_polar(ptLampIns, dLampAng, 50, ptLampTmp);
	//	// 得到荧光灯图块的向量
	//	AcGeVector3d vt1 = ptLampTmp - ptLampIns;

	//	int len2 = lst222.Length();
	//	for(int m=0;m<len2;m++){
	//		XPoint pt1 = *lst222[m];
	//		AcGeVector3d vt2 = pt1 - ptLampIns;
	//		if(vt1.isParallelTo(vt2)!=Adesk::kTrue){
	//			lstPtTrue.NewAppend(pt1);
	//		}
	//	}
	//	lst222.Reset();
	//	lst222 = lstPtTrue;
	//}
	//else if(csAttribText2.Find(_T("开关")) > -1 && csAttribText1.Find(_T("荧光灯")) > -1){
	//	XPointList lstPtTrue;
	//	double dLampAng(0);
	//	ent1.GetData(50, &dLampAng);
	//	XPoint ptLampTmp, ptLampIns;
	//	ent1.GetData(10, ptLampIns);
	//	ads_polar(ptLampIns, dLampAng, 50, ptLampTmp);
	//	// 得到荧光灯图块的向量
	//	AcGeVector3d vt1 = ptLampTmp - ptLampIns;

	//	int len2 = lst111.Length();
	//	for(int m=0;m<len2;m++){
	//		XPoint pt1 = *lst111[m];
	//		AcGeVector3d vt2 = pt1 - ptLampIns;
	//		if(vt1.isParallelTo(vt2)!=Adesk::kTrue){
	//			lstPtTrue.NewAppend(pt1);
	//		}
	//	}
	//	lst111.Reset();
	//	lst111 = lstPtTrue;
	//}

	//lsd add 2013-12-30
	//开关连灯的时候如果开关在灯两端垂直延长线内，连中点，否则取最近点
	//如果是开关连灯，求出灯的两端点备用并设置标记值
	XPoint ptLampIns,ptS,ptE;//中点，起始接线点
	double dMaxDist = 0.0;
	Entity entLamp;
	XPointList lstPts;
	if(csAttribText2.Find(_T("开关")) > -1 && csAttribText1.Find(_T("荧光灯")) > -1)
	{
		bIsLamp1 = TRUE;
		entLamp = ent1;
		lstPts = lst111;
	}
	else if(csAttribText1.Find(_T("开关")) > -1 && csAttribText2.Find(_T("荧光灯")) > -1)
	{
		bIsLamp2 = TRUE;
		entLamp = ent2;
		lstPts = lst222;
	}
	if(bIsLamp1 || bIsLamp2)
	{
		double dLampAng(0);
		entLamp.GetData(50, &dLampAng);
		XPoint ptLampTmp;
		entLamp.GetData(10, ptLampIns);
		ads_polar(ptLampIns, dLampAng, 50, ptLampTmp);
		// 得到荧光灯图块的向量
		AcGeVector3d vt1 = ptLampTmp - ptLampIns;
		//求得灯的两端接线点(按图块向量上的最远点算)
		int iLen = lstPts.Length();
		for(int k = 0;k < iLen;k++)
		{
			XPoint pt1 = *lstPts[k];
			if(AcGeVector3d(pt1 - ptLampIns).isParallelTo(vt1) != Adesk::kTrue)
				continue;
			for(int kk = k;kk < iLen;kk++)
			{
				XPoint pt2 = *lstPts[kk];
				if(AcGeVector3d(pt2 - ptLampIns).isParallelTo(vt1) != Adesk::kTrue)
					continue;
				if(dMaxDist < pt1.Distance2d(pt2))
				{
					dMaxDist = pt1.Distance2d(pt2);
					ptS = pt1;
					ptE = pt2;
				}
			}
		}
	}
	AcDbLine lineLamp(ptS,ptE);//灯管中线
	//add end
	

	double xscale;
	ent1.GetData(41, &xscale);
	nRadius1 *= fabs(xscale);
	ent2.GetData(41, &xscale);
	nRadius2 *= fabs(xscale);

	int len1 = lst111.Length();
	int len2 = lst222.Length();
	double nMinDist = -1;
	//lsd modified 2013-12-30
	for(int i=0;i<len1;i++){
		XPoint pti = *lst111[i];
		//if(bIsLamp1)
		//	pti = ptCen1;
		for(int j=0;j<len2;j++){
			XPoint ptj = *lst222[j];
			//if(bIsLamp2)
			//	ptj = ptCen2;

			if(bIsLamp1)
			{
				AcGePoint3d ptOnLine;
				lineLamp.getClosestPointTo(ptj,ptOnLine);
				if(!ptOnLine.isEqualTo(ptS, g_globalTol) && !ptOnLine.isEqualTo(ptE, g_globalTol))
					pti = ptLampIns;
			}
			if(bIsLamp2)
			{
				AcGePoint3d ptOnLine;
				lineLamp.getClosestPointTo(pti,ptOnLine);
				if(!ptOnLine.isEqualTo(ptS, g_globalTol) && !ptOnLine.isEqualTo(ptE, g_globalTol))
					ptj = ptLampIns;
			}
			// modifiy end
			
			if((nMinDist > 0 && pti.Distance(ptj) < nMinDist) || (nMinDist < 0)){
				nMinDist = pti.Distance(ptj);   //找最近连接点
				ptCen2 = ptj;
				ptCen1 = pti;
				double angle = ads_angle(ptCen1, ptCen2);
				if(flag1){    //如果是圆块,  找延长线为圆心的点
					ads_polar(ptCen1, angle, nRadius1, ptCen1);
				}
				angle = ads_angle(ptCen2, ptCen1);
				if(flag2){
					ads_polar(ptCen2, angle, nRadius2, ptCen2);
				}
			}
		}
	}
	if(!!ptCen1 && !!ptCen2){
		CWire::DrawLineWire(ptCen1, ptCen2, csLayer, csLineType, nLineThick);
		Entity ent;
		ent.GetLast();
		WriteXdata(ent, _T("linenum"), (const TCHAR*)csName);
		WriteXdata(ent, _T("ltype"), csType);		 //导线型号
		WriteXdata(ent, _T("ldm"), csRadius);		 //穿管直径
		WriteXdata(ent, _T("lmeth"), csMode);		 //配线方式
		WriteXdata(ent, _T("linst"), csPlace);	     //敷设部位
		WriteXdata(ent, _T("lnoar"), csArea);		 //规格
		WriteXdata(ent, _T("lnorm"), csNorm);		 //
		bRet = TRUE;
	}
	return bRet;
}

//(通用布线) 画直导线时, 得到最佳两点
BOOL DrawPLineWireBy2Equip_OLD(Entity oldent, Entity ent1, Entity ent2)
{
    BOOL bRet(FALSE);
    CWire wire1(oldent);
    CString csLayer = wire1.GetWireLayer();
    CString csLineType = wire1.GetLineType();
    double nLineThick = wire1.GetLineThick();
    CString csName = ReadXdata(oldent, _T("linenum"));
    CString csType = ReadXdata(oldent, _T("ltype"));
    CString csRadius = ReadXdata(oldent, _T("ldm"));
    CString csMode = ReadXdata(oldent, _T("lmeth"));
    CString csPlace = ReadXdata(oldent, _T("linst"));
    CString csArea = ReadXdata(oldent, _T("lnoar"));
    CString csNorm = ReadXdata(oldent, _T("lnorm"));
    
    XPoint ptCen1, ptCen2;
    XPointList lst111, lst222;
    BOOL flag1(FALSE), flag2(FALSE), bIsLamp1(FALSE), bIsLamp2(FALSE);
    double nRadius1(0.0), nRadius2(0.0);
    CString csAttribText1 = GetAttrib(ent1, _T("A"));
    CString csAttribText2 = GetAttrib(ent2, _T("A"));

//    if(csAttribText1.Find(_T("荧光灯")) > -1 && csAttribText2.Find(_T("荧光灯")) < 0){
//        ent1.GetData(10, ptCen1);
//        bIsLamp1 = TRUE;
//    }
//    else if(csAttribText2.Find(_T("荧光灯")) > -1 && csAttribText1.Find(_T("荧光灯")) < 0){
//        bIsLamp2 = TRUE;
//        ent2.GetData(10, ptCen2);
//    }
    
	flag1 = GetEquipPoint(ent1, lst111, nRadius1);
	flag2 = GetEquipPoint(ent2, lst222, nRadius2);
	//2008-4-9 sr 增加以下40行. 解决,开关连接荧光灯的时候, 希望连接在荧光灯的中间, 而不是根据就近原则连接到荧光灯的边上
    if(csAttribText1.Find(_T("开关")) > -1 && csAttribText2.Find(_T("荧光灯")) > -1){
        XPointList lstPtTrue;
		double dLampAng(0);
		ent2.GetData(50, &dLampAng);
		XPoint ptLampTmp, ptLampIns;
		ent2.GetData(10, ptLampIns);
		ads_polar(ptLampIns, dLampAng, 50, ptLampTmp);
		// 得到荧光灯图块的向量
		AcGeVector3d vt1 = ptLampTmp - ptLampIns;
		
		int len2 = lst222.Length();
		for(int m=0;m<len2;m++){
			XPoint pt1 = *lst222[m];
			AcGeVector3d vt2 = pt1 - ptLampIns;
			if(vt1.isParallelTo(vt2)!=Adesk::kTrue){
				lstPtTrue.NewAppend(pt1);
			}
		}
		lst222.Reset();
		lst222 = lstPtTrue;
	}
	else if(csAttribText2.Find(_T("开关")) > -1 && csAttribText1.Find(_T("荧光灯")) > -1){
        XPointList lstPtTrue;
		double dLampAng(0);
		ent1.GetData(50, &dLampAng);
		XPoint ptLampTmp, ptLampIns;
		ent1.GetData(10, ptLampIns);
		ads_polar(ptLampIns, dLampAng, 50, ptLampTmp);
		// 得到荧光灯图块的向量
		AcGeVector3d vt1 = ptLampTmp - ptLampIns;
		
		int len2 = lst111.Length();
		for(int m=0;m<len2;m++){
			XPoint pt1 = *lst111[m];
			AcGeVector3d vt2 = pt1 - ptLampIns;
			if(vt1.isParallelTo(vt2)!=Adesk::kTrue){
				lstPtTrue.NewAppend(pt1);
			}
		}
		lst111.Reset();
		lst111 = lstPtTrue;
	}
 

    double xscale;
    ent1.GetData(41, &xscale);
    nRadius1 *= fabs(xscale);
    ent2.GetData(41, &xscale);
    nRadius2 *= fabs(xscale);
    
    int len1 = lst111.Length();
    int len2 = lst222.Length();
    double nMinDist = -1;
    for(int i=0;i<len1;i++){
        XPoint pti = *lst111[i];
        if(bIsLamp1)
            pti = ptCen1;
        for(int j=0;j<len2;j++){
            XPoint ptj = *lst222[j];
            if(bIsLamp2)
                ptj = ptCen2;
            if((nMinDist > 0 && pti.Distance(ptj) < nMinDist) || (nMinDist < 0)){
                nMinDist = pti.Distance(ptj);   //找最近连接点
                ptCen2 = ptj;
                ptCen1 = pti;
                double angle = ads_angle(ptCen1, ptCen2);
                if(flag1){    //如果是圆块,  找延长线为圆心的点
                    ads_polar(ptCen1, angle, nRadius1, ptCen1);
                }
                angle = ads_angle(ptCen2, ptCen1);
                if(flag2){
                    ads_polar(ptCen2, angle, nRadius2, ptCen2);
                }
            }
        }
    }
    if(!!ptCen1 && !!ptCen2){
        CWire::DrawLineWire(ptCen1, ptCen2, csLayer, csLineType, nLineThick);
        Entity ent;
        ent.GetLast();
        WriteXdata(ent, _T("linenum"), (const TCHAR*)csName);
        WriteXdata(ent, _T("ltype"), csType);		 //导线型号
        WriteXdata(ent, _T("ldm"), csRadius);		 //穿管直径
        WriteXdata(ent, _T("lmeth"), csMode);		 //配线方式
        WriteXdata(ent, _T("linst"), csPlace);	     //敷设部位
        WriteXdata(ent, _T("lnoar"), csArea);		 //规格
        WriteXdata(ent, _T("lnorm"), csNorm);		 //
        bRet = TRUE;
    }
    return bRet;
}

void GetBlkBreakPtByPoly(XCircle cir, Entity entBreak, XPoint &ptBr1, XPoint &ptBr2)
{
    XPoint ptFirst, ptEnd;
    BOOL bFlag = FALSE;
    
    if(entBreak.Is(_T("LINE"))){
        XCurveSegment seg(entBreak);
        ptFirst = seg.StartPoint();
        ptEnd = seg.EndPoint();
        
        XPoint ptInters, ptInters2, ptBreak1, ptBreak2;
        int ret;
        if(seg.Is(CURVE_LINE))
		{
			XLine lineTmp = seg.GetLine();
            ret = cir.Intersection(&lineTmp, ptInters, ptInters2);
		}
        else if(seg.Is(CURVE_ARC))
		{
			XArc arcTmp = seg.GetArc();
            ret = cir.Intersection(&arcTmp, ptInters, ptInters2);
		}
        if(ret == 2){
            ptBr1 = ptInters;
            ptBr2 = ptInters2;
            return;
        }
        if(ret == 1){
            if(bFlag)
                ptBr2 = ptInters;
            else{
                ptBr1 = ptInters;
                bFlag = TRUE;
            }
        }
        if(!!ptBr1 && !!ptBr2)
            return;
    }
    else{
        XPoly2D xpoly(entBreak);
        ptFirst = *xpoly[0];
        ptEnd = *xpoly[xpoly.Length()-1];
        for(int n=0; n<xpoly.TotalSegments(); n++) {
            XCurveSegment seg;
            xpoly.Nth(n, seg);
            XPoint ptInters, ptInters2, ptBreak1, ptBreak2;
            int ret;
            if(seg.Is(CURVE_LINE))
			{
				XLine lineTmp = seg.GetLine();
                ret = cir.Intersection(&lineTmp, ptInters, ptInters2);
			}
            else if(seg.Is(CURVE_ARC))
			{
				XArc arcTmp = seg.GetArc();
                ret = cir.Intersection(&arcTmp,ptInters, ptInters2);
			}
            if(ret == 2){
                ptBr1 = ptInters;
                ptBr2 = ptInters2;
                return;
            }
            if(ret == 1){
                if(bFlag)
                    ptBr2 = ptInters;
                else{
                    ptBr1 = ptInters;
                    bFlag = TRUE;
                }
            }
            if(!!ptBr1 && !!ptBr2)
                return;
        }
    }
    if(ads_distance(cir.GetCenterPt(), ptEnd) < ads_distance(cir.GetCenterPt(), ptFirst))
        ptBr2 = ptEnd;
    else
        ptBr2 = ptFirst;
    
}


double GetWireWidth(Entity ent)
{
    double nLineThick(0);
    if(ent.Is(_T("LWPOLYLINE"))){
        ent.GetData(40, &nLineThick);
    }
    else if(ent.Is(_T("ATS_RECT"))){
        OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbRect, pEnt);
        if(pEnt){
            double x = pEnt->GetSizeX();
            double y = pEnt->GetSizeY();
            nLineThick = x < y ? x : y;
        }
        OPENOBJ_END();
    }
    return nLineThick;
}

Entity GetCulBreakPWire(PickSet &ssAllBreak, PickSet &ssff)
{
    for(long m=0;m<ssAllBreak.Length();m++){
        for(long n=0;n<ssff.Length();n++){
            if(ssAllBreak[m] == ssff[n]){
                return ssAllBreak[m];
            }
        }
    }
    return Entity();
}

void GetMWire2Line(Entity ent, XLine &line1, XLine &line2)
{
    if(!ent.Is(_T("ATS_RECT")))
        return;
    OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbRect, pEnt);
    if(pEnt){
        double x = pEnt->GetSizeX();
        double y = pEnt->GetSizeY();
        double width = x < y ? x : y;
        double ang = pEnt->GetRotation();
        if(ang >= PI)
            ang -= PI;
        XPoint pt1, pt2, pt3, pt4;
        if(pEnt->GetRotation() >= PI){
            pt1 = pEnt->GetUpLeft();
            pt2 = pEnt->GetUpRight();
            pt3 = pEnt->GetLowLeft();
            pt4 = pEnt->GetLowRight();
        }
        else{
            pt1 = pEnt->GetLowLeft();
            pt2 = pEnt->GetLowRight();
            pt3 = pEnt->GetUpLeft();
            pt4 = pEnt->GetUpRight();
        }
        XLine line3(pt1, pt2, 1);
        line1 = line3;
        XLine line4(pt3, pt4, 1);
        line2 = line4;
    }
    OPENOBJ_END();
    
}

void BreakMWire(Entity entSel, XPoint ptPick, XPoint ptPick2)
{
    XPoint ptCen, ptCen1, ptCen2, ptInter1, ptInter2, ptInter3, ptInter4, ptLowLeft, ptLowRight, ptUpRight, ptUpLeft;
    XLine line3(1), line4(1);
    GetMWire2Line(entSel, line3, line4);
    double width(0), length(0), ang(0);
    OPENOBJ_BEGIN(entSel, AcDb::kForWrite, TDbRect, pEnt);
    if(pEnt){
        ptUpLeft = pEnt->GetUpLeft();
        ptCen = pEnt->GetCenter();
        double x = pEnt->GetSizeX();
        double y = pEnt->GetSizeY();
        width = x < y ? x : y;
        ang = pEnt->GetRotation();
        if(ang >= PI){
            ang -= PI;
        }
        XPoint ptTmp1, ptTmp2;
        ads_polar(ptPick, ang-PI/2, width, ptTmp1);
        ads_polar(ptPick, ang+PI/2, width, ptTmp2);
        XLine line1(ptTmp1, ptTmp2, 1);
        ads_polar(ptPick2, ang-PI/2, width*2, ptTmp1);
        ads_polar(ptPick2, ang+PI/2, width*2, ptTmp2);
        XLine line2(ptTmp1, ptTmp2, 1);
        line3.Intersection(&line1, ptInter1);
        line3.Intersection(&line2, ptInter2);
        line4.Intersection(&line1, ptInter3);
        line4.Intersection(&line2, ptInter4);
        double n1 = ads_distance(ptInter1, ptUpLeft);
        double n2 = ads_distance(ptInter2, ptUpLeft);
        double n3 = ads_distance(ptInter1, ptInter2);
        double nX = n1 < n2 ? n1 : n2;
        ads_polar(ptCen, ang+PI, (x-nX)/2, ptCen1);
        pEnt->SetSizeX(nX);
        pEnt->SetCenter(ptCen1);
        length = x - nX - n3;
        ads_polar(ptCen, ang, x/2-length/2, ptCen2);
    }
    OPENOBJ_END();
    if(length > 0 && width > 0 && !!ptCen2){
        TDbRect *pRect = new TDbRect;
        pRect->setLayer(LAY_WIRE_BUS);
        pRect->SetSizeX(length);
        pRect->SetRotation(ang);
        pRect->SetSizeY(width);
        pRect->SetCenter(ptCen2) ;
        pRect->AddToCSpace(Adesk::kTrue);
    }
}


void DoBreakPLineOld(Entity ent, DList<CBreakPtList> &lstPt)
{
    int len = lstPt.Length();
    
    if(len < 1)
        return;
    PickSet ssAllBreak(SS_FREE);
    ssAllBreak += ent;
    double m = GetWireWidth(ent);
    RBList rbMask = ads_buildlist( -4, _T("<or"),
        -4, _T("<and"), RTDXF0, _T("LWPOLYLINE"), 8, GetLayerNames(_T("导线")), -4, _T("and>"),  
        -4, _T("<and"), RTDXF0, _T("LINE"), 8, GetLayerNames(_T("导线")), -4, _T("and>"),  
        -4, _T("<and"), RTDXF0, _T("ARC"), 8, GetLayerNames(_T("导线")), -4, _T("and>"),  
        -4, _T("<and"), RTDXF0, _T("ATS_RECT"), 8, LAY_WIRE_BUS, -4, _T("and>"),  
        -4, _T("or>"), NULL);
    
    for(int i=0;i<len;i++){
        XPoint ptBreak1, ptBreak2;
        ptBreak1 = lstPt[i]->m_ptFirst;
        ptBreak2 = lstPt[i]->m_ptEnd;
        Entity entSel;
        PickSet ssff(SS_FREE);
        GetPointPickSet(ptBreak1, ssff, rbMask, (int)m);
        long ff = ssff.Length();
        entSel = GetCulBreakPWire(ssAllBreak, ssff);
        if(!entSel){
            continue;
        }
        if(entSel.Is(_T("LWPOLYLINE"))){
            ads_command(RTSTR, _T(".BREAK"), RTLB, RTENAME, (TLong_ptr*)entSel, RT3DPOINT, &ptBreak1, RTLE, RTSTR, _T("F"), RT3DPOINT, &ptBreak1, RT3DPOINT, &ptBreak2, RTNONE);
        }
        if(entSel.Is(_T("LINE"))){
            ads_command(RTSTR, _T(".BREAK"), RTLB, RTENAME, (TLong_ptr*)entSel, RT3DPOINT, &ptBreak1, RTLE, RTSTR, _T("F"), RT3DPOINT, &ptBreak1, RT3DPOINT, &ptBreak2, RTNONE);
        }
        if(entSel.Is(_T("ARC"))){
            ads_command(RTSTR, _T(".BREAK"), RTLB, RTENAME, (TLong_ptr*)entSel, RT3DPOINT, &ptBreak1, RTLE, RTSTR, _T("F"), RT3DPOINT, &ptBreak1, RT3DPOINT, &ptBreak2, RTNONE);
        }
        else if(_T("ATS_RECT")){
            BreakMWire(entSel, ptBreak1, ptBreak2);
            ads_command(RTSTR, _T("REDRAW"), RTNONE);
        }
        Entity entTmp;
        entTmp.GetLast();
        ssAllBreak += entTmp;
    }
}

bool PtIsOnLine(const XPoint &pt1, const XPoint &pt2, DList<CBreakPtList> &lstPt)
{
	int nLen = lstPt.Length();
	XPoint ptFirst, ptSecond;
	double dDist = 0.001;
	for(int i = 0; i < nLen; ++i)
	{
		ptFirst = lstPt[i]->m_ptFirst;
		ptSecond = lstPt[i]->m_ptEnd;
		if (((ptFirst.Distance(pt1) < dDist) && (ptSecond.Distance(pt2) < dDist)) || ((ptFirst.Distance(pt2) < dDist) && (ptSecond.Distance(pt1) < dDist)))
		{
			return true;
		}
	}
	return false;
}


// 打断点组
struct SBreakPts
{
	SBreakPts(XPoint pS, double dS, XPoint pE, double dE)
		:ptS(pS), dDistS(dS), ptE(pE), dDistE(dE)
	{}
	XPoint ptS, ptE;
	double dDistS, dDistE;
};


void AdjustBreakPt(Entity ent, DList<CBreakPtList> &lstPt)
{
	int nLen = lstPt.Length();
	if (nLen < 1)
		return;
	int i = 0; 
	int j = 0;
	
	std::vector<SBreakPts> vecPts;
	
	AcGePoint3d ptS, ptE, ptTemp;
	double dDistS = 0.0, dDistE = 0.0, dTemp = 0.0;
	BOOL bSerch = FALSE;
	BOOL bStartIn = FALSE;
	BOOL bEndIn = FALSE;
	XPoly2D polyMain(ent);
	OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbCurve, pCurve);
	if (pCurve != NULL)
	{
		for(i = 0; i < nLen; ++i)
		{
			ptS = lstPt[i]->m_ptFirst;
			ptE = lstPt[i]->m_ptEnd;
			
			//modify liaoy 2016-7-11 lstPt全部为wcs坐标，无需再转换
			//add liaoy 2015-12-30
			//UCS2WCS(ptS);
			//UCS2WCS(ptE);
			//add end
			//modify end
			//axc add 2016-12-05 保证点落在导线上
			AcGePoint3d ptSTemp,ptETemp;
			pCurve->getClosestPointTo(ptS,ptSTemp);
			pCurve->getClosestPointTo(ptE,ptETemp);
			if (ptSTemp.distanceTo(ptS) < 1E-3 &&
				ptETemp.distanceTo(ptE) < 1E-3)
			{
				ptS = ptSTemp;
				ptE = ptETemp;
			}

			if (pCurve->getDistAtPoint(ptS, dDistS) == Acad::eOk && 
				pCurve->getDistAtPoint(ptE, dDistE) == Acad::eOk)
			{
				if (dDistS > dDistE)
				{
					dTemp = dDistS;
					dDistS = dDistE;
					dDistE = dTemp;
					
					ptTemp = ptS;
					ptS = ptE;
					ptE = ptTemp;
				}
				int nCurLen = vecPts.size();
				bSerch = FALSE;
				for (j = 0; j < nCurLen; j++)
				{
					bStartIn = dDistS >= vecPts[j].dDistS && dDistS <= vecPts[j].dDistE;
					bEndIn = dDistE >= vecPts[j].dDistS && dDistE <= vecPts[j].dDistE;
					bSerch = bStartIn || bEndIn;
					if (bStartIn && !bEndIn)
					{
						vecPts[j].dDistE = dDistE;
						vecPts[j].ptE = ptE;
						break;
					}
					else if (!bStartIn && bEndIn)
					{
						vecPts[j].dDistS = dDistS;
						vecPts[j].ptS = ptS;
						break;
					}
				}
				if (FALSE == bSerch)
					vecPts.push_back(SBreakPts(ptS, dDistS, ptE, dDistE));
			}
		}
	}
	OPENOBJ_END();
	
	lstPt.Reset();
	nLen = vecPts.size();
	for (i = 0; i < nLen; i++)
	{
		lstPt.Append(new CBreakPtList(vecPts[i].ptS, vecPts[i].ptE));
	}
}




// add by sps 2013.4.18 
// 功能：对打断点组交叉的状况 做出融合
void AdjustBreakPt_old(Entity ent, DList<CBreakPtList> &lstPt)
{
	int nLen = lstPt.Length();
	if (nLen < 1)
		return;
	int i = 0; 
	int j = 0;

	std::vector<SBreakPts> vecPts;

	AcGePoint3d ptS, ptE, ptTemp;
	double dDistS = 0.0, dDistE = 0.0, dTemp = 0.0;
	BOOL bSerch = FALSE;
	BOOL bStartIn = FALSE;
	BOOL bEndIn = FALSE;
	OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbCurve, pCurve);
	if (pCurve != NULL)
	{
		for(i = 0; i < nLen; ++i)
		{
			ptS = lstPt[i]->m_ptFirst;
			ptE = lstPt[i]->m_ptEnd;
			if (pCurve->getDistAtPoint(ptS, dDistS) == Acad::eOk && 
				pCurve->getDistAtPoint(ptE, dDistE) == Acad::eOk)
			{
				if (dDistS > dDistE)
				{
					dTemp = dDistS;
					dDistS = dDistE;
					dDistE = dTemp;

					ptTemp = ptS;
					ptS = ptE;
					ptE = ptTemp;
				}
				int nCurLen = vecPts.size();
				bSerch = FALSE;
				for (j = 0; j < nCurLen; j++)
				{
					bStartIn = dDistS >= vecPts[j].dDistS && dDistS <= vecPts[j].dDistE;
					bEndIn = dDistE >= vecPts[j].dDistS && dDistE <= vecPts[j].dDistE;
					bSerch = bStartIn || bEndIn;
					if (bStartIn && !bEndIn)
					{
						vecPts[j].dDistE = dDistE;
						vecPts[j].ptE = ptE;
						break;
					}
					else if (!bStartIn && bEndIn)
					{
						vecPts[j].dDistS = dDistS;
						vecPts[j].ptS = ptS;
						break;
					}
				}
				if (FALSE == bSerch)
					vecPts.push_back(SBreakPts(ptS, dDistS, ptE, dDistE));
			}
		}
	}
	OPENOBJ_END();

	lstPt.Reset();
	nLen = vecPts.size();
	for (i = 0; i < nLen; i++)
	{
		lstPt.Append(new CBreakPtList(vecPts[i].ptS, vecPts[i].ptE));
	}
}

void DoBreakPLine(Entity ent, DList<CBreakPtList> &lstPt)
{
	AdjustBreakPt(ent, lstPt); 

	int nLen = lstPt.Length();
	if (nLen < 1)
	{
		return;
	}

	bool bFlag = false;
    OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbCurve, pCurve);
	if (pCurve != NULL)
	{
		// 对打断点排序
		AcGePoint3d ptFirst, ptSecond;
		std::multimap<double, AcGePoint3d> mapPts;
		for(int i = 0; i < nLen; ++i)
		{
			ptFirst = lstPt[i]->m_ptFirst;
			ptSecond = lstPt[i]->m_ptEnd;
			double dDist1 = 0.0, dDist2 = 0.0;
			if (pCurve->getDistAtPoint(ptFirst, dDist1) != Acad::eOk || pCurve->getDistAtPoint(ptSecond, dDist2) != Acad::eOk)
			{
				return;
			}
			mapPts.insert(std::make_pair(dDist1, ptFirst));
			mapPts.insert(std::make_pair(dDist2, ptSecond));
		}
		AcGePoint3dArray arrBreakPt;
		std::multimap<double, AcGePoint3d>::iterator it, itEnd = mapPts.end();
		for (it = mapPts.begin(); it != itEnd; ++it)
		{
			arrBreakPt.append(it->second);
		}

		AcDbVoidPtrArray arrPtr;
		if (pCurve->getSplitCurves(arrBreakPt, arrPtr) == Acad::eOk)
		{
			int nSize = arrPtr.length();
			AcDbCurve *pCve = NULL;
			AcGePoint2d pt;
			AcGePoint3d ptS, ptE;
			for (int j = 0; j < nSize; ++j)
			{
				pCve = (AcDbCurve*)arrPtr[j];
				if (pCve == NULL)
				{
					delete arrPtr[j];
					continue;
				}

				pCve->getStartPoint(ptS);
				pCve->getEndPoint(ptE);
				if (!PtIsOnLine(XPoint(ptS), XPoint(ptE), lstPt)) // 两点不在分割点集中
				{
					AcDbCurve *pCurveNew = (AcDbCurve*)pCurve->clone();
					AcDbLine *pLine = AcDbLine::cast(pCurveNew);
					AcDbArc *pArc = AcDbArc::cast(pCurveNew);
					AcDbPolyline *pPLine = AcDbPolyline::cast(pCurveNew);
					if (pLine != NULL)
					{
						pLine->setStartPoint(ptS);
						pLine->setEndPoint(ptE);
					}
					else if (pArc != NULL)
					{
						AcDbArc *pArc2 = (AcDbArc*)pCve;
						if (pArc2 == NULL)
						{
							delete pCve;
							delete pCurveNew;
							continue;
						}
						pArc->setStartAngle(pArc2->startAngle());
						pArc->setEndAngle(pArc2->endAngle());
						pArc->setCenter(pArc2->center());
						pArc->setRadius(pArc2->radius());
					}
					else if (pPLine != NULL)
					{
						int nNum = pPLine->numVerts();
						while(nNum > 0)
						{
							pPLine->removeVertexAt(nNum - 1);
							--nNum;
						}
						int nLineLen = pPLine->numVerts();

						AcDbPolyline *pTemp = (AcDbPolyline*)pCve;
						if (pTemp == NULL)
						{
							delete pCve;
							delete pCurveNew;
							continue;
						}
						nNum = pTemp->numVerts();
						double dBulge = 0.0, dWidthS = 0.0, dWidthE = 0.0;
						for (int k = 0; k < nNum; ++k)
						{
							pTemp->getPointAt(k, pt);
							pTemp->getBulgeAt(k, dBulge);
							pTemp->getWidthsAt(k, dWidthS, dWidthE);
							if (k == 0 && nLineLen == 1) // 最后一点无法删除
							{
								pPLine->setPointAt(k, pt);
								pPLine->setBulgeAt(k, dBulge);
								pPLine->setWidthsAt(k, dWidthS, dWidthE);
							} 
							else
							{
								pPLine->addVertexAt(k, pt, dBulge, dWidthS, dWidthE);
							}
						}
					} 
					else
					{
						delete pCve;
						delete pCurveNew;
						continue; 
					}
					AddToCurrentSpace(pCurveNew, Adesk::kTrue);
					bFlag = true;
				}
				delete pCve;
			}
		}
	}
	OPENOBJ_END();

	if (bFlag)
	{
		ent.Erase();
	}
}

//////////////////////////////////////////////////////////////////////////
//add liaoy 170725
XCurveSegment GetBlkSel(AcDbEntity *pEnt, XPoint ptPick,const double& xscale = 1,const AcGeMatrix3d& mat = AcGeMatrix3d::kIdentity)
{
	XCurveSegment seg;
	const double dTol = g_nEqBlkLength/20;
	if (!pEnt)
		return seg;
	AcDbCircle *pCir = NULL;
	AcDbPolyline *pPoly = NULL;
	AcDbLine  *pLine = NULL;
	AcDbArc  *pArc = NULL;
	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, dTol))
		{
			return seg;
		}
	}
	else if(pPoly = AcDbPolyline::cast(pEnt))
	{
		/*
		XPoly2D poly;
		PolyConvert(*pPoly, poly);
		poly.TransformBy(mat);//多段线TransformBy时若为非均匀缩放矩阵或非正交矩阵则不一定成功
		double n;
		seg = GetSegByPt(poly, ptPick, n);
		if(!!seg)
			return seg;
		*/
		AcGePoint3d ptS,ptE;
		double dBulge(0);
		int nNumVer = pPoly->numVerts();
		for (int m = 0;m < nNumVer;m++)
		{
			if (m == nNumVer - 1 && !pPoly->isClosed())
				break;
			if ( Acad::eOk == pPoly->getPointAt(m,ptS)						&& 
				 Acad::eOk == pPoly->getPointAt( (m + 1) % nNumVer,ptE)	&&
				 Acad::eOk == pPoly->getBulgeAt(m,dBulge))
			{
				ptS = ptS.transformBy(mat);
				ptE = ptE.transformBy(mat);
				if (fabs(dBulge) <= TOL)//直线
				{
					XLine line(asDblArray(ptS), asDblArray(ptE), LS_FINITE);
					seg = line;
					if(IsPtOnLine(ptPick, line, dTol))
					{
						return seg;
					}
				}
				else//弧线
				{
					XArc arc(asDblArray(ptS), asDblArray(ptE), atan(dBulge) * 4);
					seg = arc;
					if(IsPtOnArc(ptPick, arc, dTol))
					{
						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, dTol))
		{
			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, dTol))
		{
			return seg;
		}
	}
	return XCurveSegment();
}

//广度优先获取块实体和Matrix,外部不能释放arpNewSet
BOOL GetWidthBlkEntity(AcDbBlockReference* pRef,AcArray<AcArray<std::pair<AcDbEntity*,AcGeMatrix3d>>>& arpNewSet)
{
	if(!pRef)
		return FALSE;
	AcDbBlockTableRecordIterator *pIterator = NULL;
	OPENOBJ_BEGIN(pRef->blockTableRecord(), AcDb::kForRead, AcDbBlockTableRecord , pRec);
	if(pRec)
		pRec->newIterator(pIterator);
	OPENOBJ_END();
	AcArray<std::pair<AcDbEntity*,AcGeMatrix3d>> entSet;
	AcGeMatrix3d mat = pRef->blockTransform();
	if (pIterator)
	{
		for(pIterator->start(); !pIterator->done(); pIterator->step())
		{
			AcDbEntity *pEnt = NULL;
			pIterator->getEntity(pEnt, AcDb::kForRead);
			if(pEnt)
			{
				entSet.append(std::make_pair(pEnt,mat));
				pEnt->close();
			}
		}
		delete pIterator;
		pIterator = NULL;
	}
	if (entSet.length() <= 0)
		return FALSE;
	arpNewSet.append(entSet);
	while(TRUE)
	{
		int nLayerSize = arpNewSet.length();
		if (nLayerSize <= 0)
			break;
		int nLastLayerSize = arpNewSet[nLayerSize - 1].length();
		if (nLastLayerSize <= 0)
			break;
		entSet.removeAll();
		for(int n=0; n<nLastLayerSize; n++) 
		{
			AcDbEntity *pNewEnt=(arpNewSet[nLayerSize - 1][n]).first;
			AcGeMatrix3d matNew = (arpNewSet[nLayerSize - 1][n]).second;
			if(pNewEnt == NULL)
				continue;
			AcDbBlockReference* pRefNew = AcDbBlockReference::cast(pNewEnt);
			if (pRefNew)
			{
				pIterator = NULL;
				OPENOBJ_BEGIN(pRefNew->blockTableRecord(), AcDb::kForRead, AcDbBlockTableRecord , pRecNew);
				if(pRecNew)
					pRecNew->newIterator(pIterator);
				OPENOBJ_END();
				if (pIterator)
				{
					mat = pRefNew->blockTransform();
					for(pIterator->start(); !pIterator->done(); pIterator->step())
					{
						AcDbEntity *pEnt = NULL;
						pIterator->getEntity(pEnt, AcDb::kForRead);
						if(pEnt)
						{
							entSet.append(std::make_pair(pEnt,matNew * mat));
							pEnt->close();
						}
					}
					delete pIterator;
					pIterator = NULL;
				}
			}
		}
		if (entSet.length() <= 0)
			break;
		arpNewSet.append(entSet);
	}
	return TRUE;
}

bool SetLayerLockedTel(const CString& sLayerName, bool bLock)
{
	XStringList lstLayerName;
	lstLayerName.Append(tstrnew(sLayerName));
	return SetLayerLockedTel(lstLayerName,bLock);
}

bool SetLayerLockedTel(XStringList& lstLayerName, bool bLock)
{
	//
	AcDbLayerTable *pLayertable = NULL;
	Acad::ErrorStatus es = acdbCurDwg()->getLayerTable(pLayertable, AcDb::kForRead);
	if (pLayertable)
	{
		AcAxDocLock docLock(acdbCurDwg());
		for(int i = 0;i < lstLayerName.Length();i++)
		{
			CString sCurLayerName = lstLayerName[i];
			AcDbLayerTableRecord *pLayerRec = NULL;
			es = pLayertable->getAt(sCurLayerName, pLayerRec, AcDb::kForWrite);
			if (pLayerRec)
			{
				if (bLock != pLayerRec->isLocked())
				{
					pLayerRec->setIsLocked(bLock);
				}
				pLayerRec->close();
			}
		}
		pLayertable->close();
		return true;
	}
	return false;
	//
	//ads_command(RTSTR, _T("-layer"), RTSTR, bLock ? _T("LO") : _T("U"), RTSTR,_T("layer1,layer2,...") , RTSTR, _T(""), RTNONE);
	//上述方法也能锁定/解锁图层,并更新淡显效果,无需re;但对图层名带'#'的不能锁定/解锁
	/*
	XStringList lstNeedDeal;
	AcDbLayerTable *pLayertable = NULL;
	Acad::ErrorStatus es = acdbCurDwg()->getLayerTable(pLayertable, AcDb::kForRead);
	if (pLayertable)
	{
		AcAxDocLock docLock(acdbCurDwg());
		for(int i = 0;i < lstLayerName.Length();i++)
		{
			CString sCurLayerName = lstLayerName[i];
			AcDbLayerTableRecord *pLayerRec = NULL;
			es = pLayertable->getAt(sCurLayerName, pLayerRec, AcDb::kForRead);
			if (pLayerRec)
			{
				if (lstNeedDeal.Index(sCurLayerName) < 0 && bLock != pLayerRec->isLocked())
				{
					lstNeedDeal.Append(tstrnew(sCurLayerName));
				}
				pLayerRec->close();
			}
		}
		pLayertable->close();
	}
	bool bRet = false;
	int nLength = lstNeedDeal.Length();
	if (nLength > 0)
	{
		CString csAll = lstNeedDeal[0];
		for (int i=1; i<nLength; i++)
		{
			csAll += _T(",");
			csAll += lstNeedDeal[i];
		}
		if (!csAll.IsEmpty())
		{
			ads_command(RTSTR, _T("-layer"), RTSTR, bLock ? _T("LO") : _T("U"), RTSTR, csAll, RTSTR, _T(""), RTNONE);
			bRet = true;
		}
	}
	return bRet;
	*/
}
//更新淡显效果
void UpdateLayerLockFade(BOOL bRegen)
{
	ads_command(RTSTR, _T("-layer"),RTSTR, _T(""), RTNONE);
	if (bRegen)
		ads_command(RTSTR, _T("regen"), RTNONE);
	else
		adsout << _T("需要手工REGEN才能更新锁定图层透明效果\n");
}
//////////////////////////////////////////////////////////////////////////
XCurveSegment GetBlkSel(Entity entBlk, XPoint ptPick)
{	
    double xscale;
    entBlk.GetData(41, &xscale);
    
    XBlock myBlock(entBlk);
    if(!myBlock.m_bInitSuccess)
        return XCurveSegment();
	//mod liaoy 170712修改为广度优先循环查找方法
	/*
	AcGeMatrix3d mat = myBlock.GetMatrix3d();
    AcDbBlockTableRecordIterator *pIterator = NULL;
    pIterator = myBlock.GetIterator();
	if (pIterator)
	{
		for(pIterator->start(); !pIterator->done(); pIterator->step())
		{
			AcDbEntity *pEnt = NULL;
			pIterator->getEntity(pEnt, AcDb::kForRead);
			if (pEnt)
			{
				XCurveSegment seg = GetBlkSel(pEnt,ptPick,xscale,mat);
				pEnt->close();
				if (!!seg)
					return seg;
			}
		}
	}
	*/
	//mod liaoy 170712
	/*修改为GetBlkSel()方法
    AcDbCircle *pCir = NULL;
    AcDbPolyline *pPoly = NULL;
    AcDbLine  *pLine = NULL;
    AcDbArc  *pArc = 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, g_nEqBlkLength/20)){
            pEnt->close();
            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, g_nEqBlkLength/20)){
            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, g_nEqBlkLength/20)){
            pEnt->close();
            return seg;
        }
    }
    pEnt->close();
	*/
	//若没找到,则可能存在块嵌套,广度优先再次寻找
	XCurveSegment seg;
	BOOL bFind = FALSE;
	AcArray<AcArray<std::pair<AcDbEntity*,AcGeMatrix3d>>> arpNewSet;
	GetWidthBlkEntity(myBlock.GetBlockReference(),arpNewSet);
	for (int i = 0;i < arpNewSet.length();i++)
	{
		for (int j = 0;j < arpNewSet[i].length();j++)
		{
			AcDbEntity *pEnt = arpNewSet[i][j].first;
			AcGeMatrix3d matCur = arpNewSet[i][j].second;
			if (pEnt)
			{
				seg = GetBlkSel(pEnt,ptPick,xscale,matCur);
				if (!!seg)
				{
					bFind = TRUE;
					break;
				}
			}
		}
		if(bFind)
			break;
	}
	return seg;
	//return RTNORM;
	//mod end
}

Entity GetNearestEnt(PickSet &ssSel, XPoint pt)
{
    double nDist = -1;
    Entity entRet;
    long len = ssSel.Length();
    for(long i=0;i<len;i++){
        Entity ent = ssSel[i];
        XPoint ptIns;
        ent.GetData(10, ptIns);
        if(nDist < 0 || nDist > ads_distance(ptIns, pt)){
            entRet = ent;
            nDist = ads_distance(ptIns, pt);
        }
    }
    return entRet;
}

BOOL IsBlkLight(Entity ent)
{
    if(ReadXdata(ent, _T("light")) == _T("T"))
        return TRUE;
    else
        return FALSE;
}

BOOL IsBlkPowerEquip(Entity ent)
{
    if(ReadXdata(ent, _T("powerequip")) == _T("T"))
        return TRUE;
    else
        return FALSE;
}

BOOL IsBlkWeakEquip(Entity ent)
{
    if(ReadXdata(ent, _T("weakequip")) == _T("T"))
        return TRUE;
    else
        return FALSE;
}

BOOL IsBlkFireEquip(Entity ent)
{
    if(ReadXdata(ent, _T("fireequip")) == _T("T"))
        return TRUE;
    else
        return FALSE;
}


BOOL IsBlkSwitch(Entity ent)
{
    if(ReadXdata(ent, _T("switch")) == _T("T"))
        return TRUE;
    else
        return FALSE;
}

BOOL IsBlkSwitchBoard(Entity ent)
{
    if(ReadXdata(ent, _T("switchboard")) == _T("T"))
        return TRUE;
    else
        return FALSE;
}

BOOL IsBlkSocket(Entity ent)
{
    if(ReadXdata(ent, _T("socket")) == _T("T"))
        return TRUE;
    else
        return FALSE;
}

BOOL IsWireCable(Entity ent)
{
    if(ReadXdata(ent, _T("cable")) == _T("T"))
        return TRUE;
    else
        return FALSE;
}





void GetWire2Point(Entity ent, XPoint &ptStart, XPoint &ptEnd)
{
    if(ent.Is(_T("LINE"))){
        ent.GetData(10, ptStart);
        ent.GetData(11, ptEnd);
    }
    else if(ent.Is(_T("ARC"))){
        XPoint ptCen;
        double nRadius, rStart, rEnd;
        ent.GetData(10, ptCen);
        ent.GetData(40, &nRadius);
        ent.GetData(50, &rStart);
        ent.GetData(51, &rEnd);
        ads_polar(ptCen, rStart, nRadius, ptStart);
        ads_polar(ptCen, rEnd, nRadius, ptEnd);
    }
    else{
        XPoly2D poly(ent);
        ptStart = *poly[0];
        int len = poly.Length();
        ptEnd = *poly[len-1];
    }
    return;
}


Entity DrawLineWire(XPoint pt1, XPoint pt2, const TCHAR* szLayer)
{
    PickSet ss(SS_FREE);
    XLine line(pt1, pt2, 1);
    RBList rbMask = ads_buildlist(RTDXF0, _T("LINE"), 8, GetLayerNames(_T("导线")), NULL);
    BOOL flag = FALSE;
    GetPointPickSet(pt1, ss, rbMask);
    for(long i=0;i<ss.Length();i++){
        Entity ent = ss[i];
        XLine lineEnt(ent, 1);
        double ang1 = ads_angle(pt1, pt2);
        double ang2 = ads_angle(lineEnt.StartPoint(), lineEnt.EndPoint());
        if(fabs(ang1 - ang2) < 0.01 || fabs(fabs(ang1 - ang2) - PI) < 0.01){
            int ret1 = pt1&lineEnt;
            int ret2 = pt2&lineEnt;
            if((ret1 == PR_INSIDE || ret1 == PR_ONPT1 || ret1 == PR_ONPT2) 
                && (ret2 == PR_INSIDE || ret2 == PR_ONPT1 || ret2 == PR_ONPT2))
                flag = TRUE;
        }
    }
    if(!flag){
        InitLayer(szLayer);
        XPushVarStr clayer(_T("LAYER"), szLayer);
        line.Make();
        Entity ent;
        ent.GetLast();
        return ent;
    }
    return Entity();
}

void DrawPWire(XPoly2D poly, const TCHAR* szLayer)
{
    InitLayer(szLayer);
    XPushVarStr clayer(_T("CLAYER"), szLayer);
    AcDbPolyline *pLine = new AcDbPolyline;
    PolyConvert(poly, *pLine);
    PostToDb(pLine);
    pLine->close();
}




// pt3           1           pt1
//  |-----------------------|
//  | 2                   4 |
//  |-----------------------|
// pt2           3           pt4

void GetBlkBreakPt(Entity entBlk, Entity entBreak, double nBreLen, XPoint &ptBr1, XPoint &ptBr2)
{
    XPoint ptStart, ptEnd;
    GetWire2Point(entBreak, ptStart, ptEnd);
    XPoint ptMax, ptMin, pt1, pt2, pt3, pt4;
    
    entBlk.GetExtend(ptMax, ptMin);
    ptMax.z = 0; ptMin.z = 0;
    ads_polar(ptMax, (PI * 0.25), nBreLen / 2, pt1);
    ads_polar(ptMin, (PI * 1.25), nBreLen / 2, pt2);
    XRectAngle rect(pt1, pt2);
    if(entBreak.Is(_T("LINE"))){
        XLine l(ptStart, ptEnd, LS_FINITE);
        int ret = rect.Intersection(l,ptBr1, ptBr2);
        if(ret == 2 || ret == 0)
            return;
        if(ptStart.x > rect.lowLeft.x && ptStart.x < rect.upRight.x
            && ptStart.y > rect.lowLeft.y && ptStart.y < rect.upRight.y )
            ptBr2 = ptStart;
        else
            ptBr2 = ptEnd;
        
    }
    else if(entBreak.Is(_T("ARC"))){
        XArc xarc(entBreak);
        
        pt3.x = pt2.x;
        pt3.y = pt1.y;
        pt4.x = pt1.x;
        pt4.y = pt2.y;
        
        XLine l1(pt1, pt3, LS_FINITE);
        XLine l2(pt3, pt2, LS_FINITE);
        XLine l3(pt2, pt4, LS_FINITE);
        XLine l4(pt4, pt1, LS_FINITE);
        if(xarc.Intersection(&l1, ptBr1, ptBr2) == 1){
            if(xarc.Intersection(&l2, ptBr2, ptBr1) == 1)
                return;
            if(xarc.Intersection(&l3, ptBr2, ptBr1) == 1)
                return;
            if(xarc.Intersection(&l4, ptBr2, ptBr1) == 1)
                return;
        }
        if(xarc.Intersection(&l2, ptBr1, ptBr2) == 1){
            if(xarc.Intersection(&l1, ptBr2, ptBr1) == 1)
                return;
            if(xarc.Intersection(&l3, ptBr2, ptBr1) == 1)
                return;
            if(xarc.Intersection(&l4, ptBr2, ptBr1) == 1)
                return;
        }
        if(xarc.Intersection(&l3, ptBr1, ptBr2) == 1){
            if(xarc.Intersection(&l1, ptBr2, ptBr1) == 1)
                return;
            if(xarc.Intersection(&l2, ptBr2, ptBr1) == 1)
                return;
            if(xarc.Intersection(&l4, ptBr2, ptBr1) == 1)
                return;
        }
        if(xarc.Intersection(&l4, ptBr1, ptBr2) == 1){
            if(xarc.Intersection(&l1, ptBr2, ptBr1) == 1)
                return;
            if(xarc.Intersection(&l2, ptBr2, ptBr1) == 1)
                return;
            if(xarc.Intersection(&l3, ptBr2, ptBr1) == 1)
                return;
        }
        if(ptStart.x > rect.lowLeft.x && ptStart.x < rect.upRight.x
            && ptStart.y > rect.lowLeft.y && ptStart.y < rect.upRight.y )
            ptBr2 = ptStart;
        else
            ptBr2 = ptEnd;
        
    }
}



BOOL IsBusLine(Entity ent)     //是否是干线？
{
    if(!ent.Is(_T("LINE")))
        return FALSE;
    AcDbObjectId eId;
    AcDbEntity *pEnt;
    acdbGetObjectId(eId, ent);
    acdbOpenObject(pEnt, eId, AcDb::kForRead);
    resbuf *pxData = pEnt->xData(XD_BUSDATA);
    if(pxData){
        ads_relrb(pxData);
        pEnt->close();
        return TRUE;
    }
    pEnt->close();
    return FALSE;
    
}




BOOL IsBraLine(Entity ent)     //是否是干线？
{
    if(!ent.Is(_T("LWPOLYLINE")) && !ent.Is(_T("LINE")))
        return FALSE;
    
    AcDbObjectId eId;
    AcDbEntity *pEnt;
    acdbGetObjectId(eId, ent);
    acdbOpenObject(pEnt, eId, AcDb::kForRead);
    resbuf *pxData = pEnt->xData(XD_BRADATA);
    if(pxData){
        ads_relrb(pxData);
        pEnt->close();
        return TRUE;
    }
    pEnt->close();
    return FALSE;
    
}

void ChangeColor(Entity ent)
{
    int col=1;
    ent.GetData(62, &col);
    ent.SetData(62, 3);
    ent.Modify();
}

void Join2PLine(AcDbObjectId id, LPCTSTR lpLayName)
{
    XPoint ptStart, ptEnd;
    AcDbPolyline *pll;
    acdbOpenObject(pll, id, AcDb::kForRead);
    if(!pll)
        return;
    pll->getStartPoint(ptStart);
    pll->getEndPoint(ptEnd);
    pll->close();
    
    PickSet ssAllPoly(SS_FREE);
    ssAllPoly += id;
    
    RBList rbMask(RTDXF0, _T("LWPOLYLINE"), 8, lpLayName, NULL);
    PickSet ssPoly(SS_FREE);
    XPoint ptTemp1, ptTemp2;
    ptTemp1.x = ptStart.x - MM;
    ptTemp1.y = ptStart.y + MM;
    ptTemp2.x = ptStart.x + MM;
    ptTemp2.y = ptStart.y - MM;
    ssPoly.Get(_T("C"), ptTemp1, ptTemp2, rbMask);
    ssAllPoly += ssPoly;
    ssPoly.Free();
    ptTemp1.x = ptEnd.x - MM;
    ptTemp1.y = ptEnd.y + MM;
    ptTemp2.x = ptEnd.x + MM;
    ptTemp2.y = ptEnd.y - MM;
    ssPoly.Get(_T("C"), ptTemp1, ptTemp2, rbMask);
    
    ssAllPoly += ssPoly;
    ads_name entName;
    int k = ssAllPoly.Length();
    acdbGetAdsName(entName, id);
    Entity entPoly(entName);	
    PickSet ssTmp(SS_FREE);
    ssTmp += ssAllPoly;
    ssTmp -= entPoly;
    long len = ssTmp.Length();
    ChangeColor(entPoly); 
    
    if(len < 1)
        return;
    ads_command(RTSTR, _T(".PEDIT"), RTENAME, (TLong_ptr*)ssAllPoly[0L], RTSTR, _T("J"), RTPICKS, (TLong_ptr *)ssAllPoly, RTSTR, _T(""), RTSTR, _T(""), RTNONE);
    entPoly.GetLast();
    
}

void DrawArcPoly(XArc arc, const TCHAR* szLayer)
{
    
    XCurveSegment seg;
    seg = arc;
    XPoly2D poly2d;
    seg.AsPoly2D(poly2d);
    InitLayer(szLayer);
    XPushVarStr clayer(_T("CLAYER"), szLayer);
    AcDbPolyline *pline = new AcDbPolyline;
    PolyConvert(poly2d, *pline);
    PostToDb(pline);
    pline->close();
    Join2PLine(pline->objectId(), szLayer);
}



BOOL LstDemoDisplayPoint(XPointList &lstPtIn, XPointList &lstPtOut, double dAngle)
{
    int itype;
    double dAng, dOAng, dDis;
    XPoint ptStart, ptEnd, ptTurn, ptstart, ptend;
    XPointList lstStart, lstEnd;
    int iNum = lstPtIn.Length();
    ptstart = *lstPtIn[0];
    ptend = *lstPtIn[iNum - 1];
    if(dAngle < 0){
        XLine line(ptstart, ptend, 1);
        dAngle = line.Direction();
    }
    BOOL bFisrt = TRUE;
    while(1){
        struct resbuf pointbuf;
        int iRet = ads_grread(5, &itype, &pointbuf);//得到动态点pointbuf
        ads_point_set(pointbuf.resval.rpoint, ptEnd);//ptTurn动态点,也就是引出支线的结束点
		ptEnd = Ucs2Wcs(ptEnd);
        if(itype != 5 && bFisrt)
            continue;
        ads_redraw(NULL, 1);                       //不画线演示
        if(itype == 11 || itype == 2)    // 11右键取消 2:空格，回车
            return FALSE;
        else if(itype == 5){
            lstStart.Reset();
            lstEnd.Reset();
            bFisrt = FALSE;
            for(int i=0; i<iNum; i++){
                ptTurn = *lstPtIn[i];//ptTurn引出线起点
                dOAng = ads_angle(ptTurn, ptEnd) - dAngle;
                dDis = fabs(ads_distance(ptTurn, ptEnd)*sin(dOAng));
                //指出标注的引出方向
                if(dOAng < 0)
                    dOAng += 2*PI;
                if(dOAng>=PI && dOAng<2*PI)
                    dAng = dAngle - PI/2;
                else if(dOAng>=0 && dOAng<PI)
                    dAng = dAngle + PI/2;
                
                ads_polar(ptTurn, dAng, dDis, ptEnd);
                ads_grdraw(Wcs2Ucs(ptTurn), Wcs2Ucs(ptEnd), -1, 0);    //演示
            }
        }
        else{
            bFisrt = FALSE;
            for(int i=0; i<iNum; i++){
                ptTurn = *lstPtIn[i];//ptTurn引出线起点
                dOAng = ads_angle(ptTurn, ptEnd) - dAngle;
                dDis = fabs(ads_distance(ptTurn, ptEnd)*sin(dOAng));
                
                //指出标注的引出方向
                if(dOAng < 0)
                    dOAng += 2*PI;
                if(dOAng>=PI && dOAng<2*PI)
                    dAng = dAngle - PI/2;
                else if(dOAng>=0 && dOAng<PI)
                    dAng = dAngle + PI/2;
                
                ads_polar(ptTurn, dAng, dDis, ptEnd);
                lstPtOut.NewAppend(ptEnd);
            }
            return TRUE;
        }
    }
    return FALSE;
}

//加粗元件中的PLINE
void ThickBlkPLine(Entity entBlk, double dWidth)
{
    if(dWidth < 0)
        dWidth = 0.35;
    
    TCHAR szBlkName[256];
    entBlk.GetData(2, szBlkName);
    AcDbBlockTableRecord *pRecord = NULL; 
    AcDbBlockTable* pBlockTable = NULL;
    acdbCurDwg()->getBlockTable(pBlockTable, AcDb::kForRead);
    if(!pBlockTable)
        return;
    if(Acad::eOk != pBlockTable->getAt(szBlkName, pRecord, AcDb::kForRead)){
        pBlockTable->close();
        return;
    }
    pBlockTable->close();
    if(!pRecord)
        return;
    
    AcDbBlockTableRecordIterator *pIterator;
    pRecord->newIterator(pIterator);
    pRecord->close();
    if(!pIterator)
        return;
    for(pIterator->start(); !pIterator->done(); pIterator->step()){
        AcDbEntity *pEnt = NULL;
        pIterator->getEntity(pEnt, AcDb::kForWrite);
        if(pEnt){
            AcDbPolyline *pll = NULL;
            if(pll = AcDbPolyline::cast(pEnt)){
                pll->setConstantWidth(dWidth*DocGetPScale()/1500);
            }
            pEnt->close();
        }
    }
    delete pIterator;
    
    VERIFY(entBlk.GetData(2, szBlkName)==RTNORM);
    
}


//加粗元件中的PLINE
void ThickBlkPLine(const TCHAR* szBlkName)
{
    double dWidth = g_dSysLineWidth;
    
	AcDbBlockTableRecord *pRecord = NULL; 
	AcDbBlockTable* pBlockTable = NULL;
	acdbCurDwg()->getBlockTable(pBlockTable, AcDb::kForRead);
	if(!pBlockTable)
		return;
	if(Acad::eOk != pBlockTable->getAt(szBlkName, pRecord, AcDb::kForRead)){
		pBlockTable->close();
		return;
	}
	pBlockTable->close();
	if(!pRecord)
		return;

	AcDbBlockTableRecordIterator *pIterator;
	pRecord->newIterator(pIterator);
	pRecord->close();
	if(!pIterator)
		return;
	for(pIterator->start(); !pIterator->done(); pIterator->step()){
		AcDbEntity *pEnt = NULL;
		pIterator->getEntity(pEnt, AcDb::kForWrite);
		if(pEnt){
			AcDbPolyline *pll = NULL;
			if(pll = AcDbPolyline::cast(pEnt)){
				pll->setConstantWidth(g_dSysLineWidth*DocGetPScale()/1500);
			}
			pEnt->close();
		}
	}
	delete pIterator;
    
}

//////////////////////////////////////////////////////////////////////////////////////////////////////
//                                         绘制导线
//////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL IsExistLayer(const TCHAR* szLayer)
{
    BOOL bHasIt;
    AcDbLayerTable *pLayerTable = NULL;
    acdbCurDwg()->getLayerTable(pLayerTable, AcDb::kForRead);
    bHasIt = pLayerTable->has(szLayer);
    pLayerTable->close();
    return bHasIt;
}

void DrawSysWire(XPoint ptStart, XPoint ptEnd, BOOL bBusLine)
{
	double dWidth(0);
	if(bBusLine)
		dWidth = g_dBusLineWidth;
	else
		dWidth = g_dSysLineWidth;

	CString csLay;
	if(bBusLine)
		csLay = LAY_WIRE_BUS;
	else
		csLay = LAY_WIRE_SYSTEM;
	InitLayer(csLay);
	XPushVarStr clayer(_T("CLAYER"), csLay);
 
    AcDbObjectId id = NULL;
    if(dWidth < 0.001){
        AcDbLine *pline = new AcDbLine;
        pline->setStartPoint(ptStart);
        pline->setEndPoint(ptEnd);
        PostToDb(pline);
        pline->close();
    }
    else{
        AcDbPolyline *pline = new AcDbPolyline;
        pline->addVertexAt(0, ptStart);
        pline->addVertexAt(1, ptEnd);
        pline->setConstantWidth(dWidth*DocGetPScale());
        PostToDb(pline);
        pline->close();
        id = pline->objectId();
    }
}

 
void DrawPLineWire(XPoly2D &xpoly, int iLayerIndex, BOOL bJoin)
{
    CString csLay = GetWireLayer(iLayerIndex);
    if(!IsExistLayer(csLay)){
        InitLayer(csLay);
        SetLayerLineType(csLay, g_csLineType[iLayerIndex]);
    }
    else
		InitLayer(csLay);

	XPushVarStr clayer(_T("CLAYER"), GetWireLayer(iLayerIndex));
	double dWidth = g_nWireWidth[iLayerIndex];
    AcDbObjectId id = NULL;
	
	AcDbPolyline *pline = new AcDbPolyline;
	PolyConvert(xpoly, *pline);
	pline->setConstantWidth(dWidth*DocGetPScale());
	pline->setLinetype(GetPipeWireLayLineType(GetWireLayer(iLayerIndex)));
	PostToDb(pline);
	pline->close();
	id = pline->objectId();
	int index = iLayerIndex;
	if(index == 4)                 //应急
		index = 0;
	else if(index > 4 && index < 9)//消防
		index = 2;
	else if(index > 8)             //弱电
		index = 3;
	
	if(index >= 0 && index < 4){
		Entity ent;
		ent.GetLast();
		WriteXdata(ent, _T("linenum"), (const TCHAR*)g_csWireLoop[index]);		 //回路编号//add liaoy 2016-9-23
		WriteXdata(ent, _T("ltype"), (const TCHAR*)g_csWireDimType[index]);		 //导线型号
		WriteXdata(ent, _T("ldm"), (const TCHAR*)g_csWireDimRadius[index]);		 //穿管直径
		WriteXdata(ent, _T("lmeth"), (const TCHAR*)g_csWireDimMode[index]);		 //配线方式
		WriteXdata(ent, _T("linst"), (const TCHAR*)g_csWireDimPlace[index]);	 //敷设部位
		WriteXdata(ent, _T("lnoar"), (const TCHAR*)g_csWireDimArea[index]);		 //规格
		WriteXdata(ent, _T("lnorm"), (const TCHAR*)Itoa(g_iWireDimNorm[index]));  //普通、阻燃、耐火
	}
	if(bJoin && dWidth > 0.001)
		Join2PLine(id, GetWireLayer(iLayerIndex));
	
}

void DrawPLineWire(XPoint ptStart, XPoint ptEnd, int iLayerIndex, BOOL bJoin)
{
	CString csLay = GetWireLayer(iLayerIndex);
	if(!IsExistLayer(csLay)){
		InitLayer(csLay);
		SetLayerLineType(csLay, g_csLineType[iLayerIndex]);
	}
	else
		InitLayer(csLay);

	XPushVarStr clayer(_T("CLAYER"), GetWireLayer(iLayerIndex));
	double dWidth = g_nWireWidth[iLayerIndex];
	AcDbObjectId id = NULL;
	if(dWidth < 0.001){
		AcDbLine *pline = new AcDbLine;
		pline->setStartPoint(ptStart);
		pline->setEndPoint(ptEnd);
		pline->setLinetype(GetPipeWireLayLineType(GetWireLayer(iLayerIndex)));
		PostToDb(pline);
		pline->close();
	}
	else{
		AcDbPolyline *pline = new AcDbPolyline;
		pline->addVertexAt(0, ptStart);
		pline->addVertexAt(1, ptEnd);
		pline->setConstantWidth(dWidth*DocGetPScale());
		pline->setLinetype(GetPipeWireLayLineType(GetWireLayer(iLayerIndex)));
		pline->setElevation(ptStart.z);
		PostToDb(pline);
		pline->close();
		id = pline->objectId();
	}
	//modify liaoy 2016-2-25 
	//插座、电话等设备，用任意布置、矩形布置等自动生成对应导线时生成的导线 
	//与 【平面布线】所生成的导线的标注信息不统一
	int index = iLayerIndex;
	//if(index == 4)                 //应急
	//	index = 0;
	//else if(index > 4 && index < 9)//消防
	//	index = 2;
	//else if(index > 8)             //弱电
	//	index = 3;
	//if(index >= 0 && index < 4){
	//modify end
	if(index >= 0 && index < MAX_WIRE_LEN){
		Entity ent;
		ent.GetLast();
		WriteXdata(ent, _T("linenum"), (const TCHAR*)g_csWireLoop[index]);		 //回路编号//add liaoy 2016-9-23
		WriteXdata(ent, _T("ltype"), (const TCHAR*)g_csWireDimType[index]);		 //导线型号
		WriteXdata(ent, _T("ldm"), (const TCHAR*)g_csWireDimRadius[index]);		 //穿管直径
		WriteXdata(ent, _T("lmeth"), (const TCHAR*)g_csWireDimMode[index]);		 //配线方式
		WriteXdata(ent, _T("linst"), (const TCHAR*)g_csWireDimPlace[index]);	 //敷设部位
		WriteXdata(ent, _T("lnoar"), (const TCHAR*)g_csWireDimArea[index]);		 //规格
		WriteXdata(ent, _T("lnorm"), (const TCHAR*)Itoa(g_iWireDimNorm[index]));  //普通、阻燃、耐火
		WriteXdata(ent, _T("weakwirenum"),g_csWireLineNum[iLayerIndex]);	//弱电缆根数//add liaoy 2016-2-25 
	}

	if(bJoin && dWidth > 0.001)
		Join2PLine(id, GetWireLayer(iLayerIndex));
}

void DrawPArcWire(XPoint ptStart, XPoint ptMid, XPoint ptEnd, int iLayerIndex, BOOL bJoin)
{
    CString csLay = GetWireLayer(iLayerIndex);
    if(!IsExistLayer(csLay)){
        InitLayer(csLay);
        SetLayerLineType(csLay, g_csLineType[iLayerIndex]);
    }
    else
        InitLayer(csLay);
    
	XArc arc(ptStart, ptMid, ptEnd);
    XCurveSegment seg;
	seg = arc;
	XPoly2D poly2d;
    seg.AsPoly2D(poly2d);
 
	XPushVarStr clayer(_T("CLAYER"), GetWireLayer(iLayerIndex));
	double dWidth = g_nWireWidth[iLayerIndex];
    AcDbObjectId id = NULL;
    
    if(dWidth < 0.001){
        AcDbArc *pArc = new AcDbArc;
        XArc arc(ptStart, ptMid, ptEnd);
        pArc->setCenter(arc.GetCenterPt());
        pArc->setRadius(arc.GetRadius());
        pArc->setStartAngle(arc.GetStarAngle());
        pArc->setEndAngle(arc.GetEndAngle());
        pArc->setLinetype(GetPipeWireLayLineType(GetWireLayer(iLayerIndex)));
        PostToDb(pArc);
        pArc->close();
    }
    else{
	    AcDbPolyline *pline = new AcDbPolyline;
        PolyConvert(poly2d, *pline);
	    pline->setConstantWidth(dWidth*DocGetPScale());
        pline->setLinetype(GetPipeWireLayLineType(GetWireLayer(iLayerIndex)));
        PostToDb(pline);
        pline->close();
        id = pline->objectId();
    }
	//modify liaoy 2016-6-2 
	//插座、电话等设备，用任意布置、矩形布置等自动生成对应导线时生成的导线 
	//与 【平面布线】所生成的导线的标注信息不统一
	int index = iLayerIndex;
	//if(index == 4)                 //应急
	//	index = 0;
	//else if(index > 4 && index < 9)//消防
	//	index = 2;
	//else if(index > 8)             //弱电
	//	index = 3;
	//if(index >= 0 && index < 4){
	if(index >= 0 && index < MAX_WIRE_LEN){
	//modify end
		Entity ent;
		ent.GetLast();
		WriteXdata(ent, _T("ltype"), (const TCHAR*)g_csWireDimType[index]);		 //导线型号
		WriteXdata(ent, _T("ldm"), (const TCHAR*)g_csWireDimRadius[index]);		 //穿管直径
		WriteXdata(ent, _T("lmeth"), (const TCHAR*)g_csWireDimMode[index]);		 //配线方式
		WriteXdata(ent, _T("linst"), (const TCHAR*)g_csWireDimPlace[index]);	     //敷设部位
		WriteXdata(ent, _T("lnoar"), (const TCHAR*)g_csWireDimArea[index]);		 //规格
		WriteXdata(ent, _T("lnorm"), (const TCHAR*)Itoa(g_iWireDimNorm[index]));    //普通、阻燃、耐火
		WriteXdata(ent, _T("weakwirenum"),g_csWireLineNum[index]);	//弱电缆根数//add liaoy 2016-6-2 
	}
	if(bJoin && dWidth > 0.001)
		Join2PLine(id, GetWireLayer(iLayerIndex));
}

void DrawPArcWire(XArc arc, int iLayerIndex)
{
    CString csLay = GetWireLayer(iLayerIndex);
    if(!IsExistLayer(csLay)){
        InitLayer(csLay);
        SetLayerLineType(csLay, g_csLineType[iLayerIndex]);
    }
    else
        InitLayer(csLay);
    
    XCurveSegment seg;
	seg = arc;
	XPoly2D poly2d;
    seg.AsPoly2D(poly2d);
 
	XPushVarStr clayer(_T("CLAYER"), GetWireLayer(iLayerIndex));
	double dWidth = g_nWireWidth[iLayerIndex];
    AcDbObjectId id = NULL;
    if(dWidth < 0.001){
        AcDbArc *pArc = new AcDbArc;
        pArc->setCenter(arc.GetCenterPt());
        pArc->setRadius(arc.GetRadius());
        pArc->setStartAngle(arc.GetStarAngle());
        pArc->setEndAngle(arc.GetEndAngle());
        pArc->setLinetype(GetPipeWireLayLineType(GetWireLayer(iLayerIndex)));
        PostToDb(pArc);
        pArc->close();
    }
    else{
        AcDbPolyline *pline = new AcDbPolyline;
        PolyConvert(poly2d, *pline);
        pline->setConstantWidth(dWidth*DocGetPScale());
        pline->setLinetype(GetPipeWireLayLineType(GetWireLayer(iLayerIndex)));
        PostToDb(pline);
        pline->close();
        id = pline->objectId();
    }
	//modify liaoy 2016-6-2 
	//插座、电话等设备，用任意布置、矩形布置等自动生成对应导线时生成的导线 
	//与 【平面布线】所生成的导线的标注信息不统一
	int index = iLayerIndex;
	//if(index == 4)                 //应急
	//	index = 0;
	//else if(index > 4 && index < 9)//消防
	//	index = 2;
	//else if(index > 8)             //弱电
	//	index = 3;
	//if(index >= 0 && index < 4){
	if(index >= 0 && index < MAX_WIRE_LEN){
	//modify end
		Entity ent;
		ent.GetLast();
		WriteXdata(ent, _T("ltype"), (const TCHAR*)g_csWireDimType[index]);		 //导线型号
		WriteXdata(ent, _T("ldm"), (const TCHAR*)g_csWireDimRadius[index]);		 //穿管直径
		WriteXdata(ent, _T("lmeth"), (const TCHAR*)g_csWireDimMode[index]);		 //配线方式
		WriteXdata(ent, _T("linst"), (const TCHAR*)g_csWireDimPlace[index]);	 //敷设部位
		WriteXdata(ent, _T("lnoar"), (const TCHAR*)g_csWireDimArea[index]);		 //规格
		WriteXdata(ent, _T("lnorm"), (const TCHAR*)Itoa(g_iWireDimNorm[index])); //普通、阻燃、耐火
		WriteXdata(ent, _T("weakwirenum"),g_csWireLineNum[index]);	//弱电缆根数//add liaoy 2016-6-2 
	}
	if(g_bJoin2Wire && dWidth > 0.001)
		Join2PLine(id, GetWireLayer(iLayerIndex));
}

void DrawDivWire(XPoint ptStart, XPoint ptEnd, BOOL bIsBusWire, BOOL bNeed, BOOL bIsEmptyMWire)
{
	double dWidth(0);
	if(bIsBusWire)
		dWidth = g_dBusLineWidth;
	else
		dWidth = g_dSysLineWidth;
    int dist = g_nBlkLength / 2;
    double angle = ads_angle(ptStart, ptEnd);
    ads_point pt;
    pt[0] = ptStart.x;
    pt[1] = ptStart.y;
    pt[2] = ptStart.z;
    
    CString csDwb = g_csDwbPath + _T("TelecSys");
    XString xsTmp;
    if(LoadDwbBlock(csDwb, _T("00000007"), xsTmp) != RTNORM)       // _sgrid分隔    
        return;
    int n = 1;
    while(ads_distance(ptStart, ptEnd) >= ads_distance(ptStart, pt)){
        if(bNeed)
            InsertBlock((const TCHAR*)xsTmp, asPnt3d(pt), dist/5, dist/5, angle, LAY_TEL_GRID);
        ads_polar(ptStart, angle, dist*n, pt);
        n++;
    }
    dist = dist*(n-2);
    if(bIsEmptyMWire){
        InitLayer(LAY_WIRE_BUS);
        XLine line(ptStart, ptEnd, 1);
        double ang = line.Direction();
        if(ang >= PI)
            ang -= PI;
        XPoint ptcen;
        line.MidPoint(ptcen);
        TDbRect *pRect = new TDbRect;
        pRect->setLayer(LAY_WIRE_BUS);
        pRect->SetSizeX(line.GetLength());
        pRect->SetRotation(ang);
        pRect->SetSizeY(g_dBusLineWidth*DocGetPScale());
        pRect->SetCenter(ptcen) ;
        pRect->AddToCSpace(Adesk::kTrue);
        
    }
    else
        DrawSysWire(ptStart, ptEnd, bIsBusWire);
}

CString GetAttrib(Entity entTemp, const TCHAR*szTag, BOOL bIsVisable)
{
    
    CString csRet;
    AcDbBlockReference *pBlockRef = NULL;// 定义块表指针
    AcDbObjectId eId;
    acdbGetObjectId(eId, entTemp);
    acdbOpenObject(pBlockRef, eId, AcDb::kForRead);
    if(!pBlockRef)
        return CString();
    AcDbObjectIterator *pIterator;
    pIterator = pBlockRef->attributeIterator();
    AcDbEntity *pEnt;
    AcDbAttribute *pAtt;
    for (pIterator->start(); !pIterator->done(); pIterator->step())
    {
        //遍历块中实体
        AcDbObjectId att_id;
        att_id = pIterator->objectId();
        acdbOpenAcDbEntity(pEnt, att_id, AcDb::kForRead);			
        pAtt = AcDbAttribute::cast(pEnt);			
        if(pAtt != NULL)
        {
            TCHAR *cname = pAtt->tag();//得到标记
            if(_tcsicmp(cname, szTag) == 0) {
                if(pAtt->isInvisible() == Adesk::kFalse || bIsVisable){
                    TCHAR *cval = pAtt->textString();//得到值
                    csRet.Format(_T("%s"), cval);
                    delete[] cval;
                }
                pAtt->close();
                break;
            }
            delete[] cname;
        }
        pEnt->close();
    }
    
    delete pIterator;
    pBlockRef->close();
    return csRet;
}

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



void GetBlockCurves(Entity &ent, DList<XCurveSegment> &lstCurves)
{
	AcDbObjectId id;
	acdbGetObjectId(id, ent);

	//炸开图块
	AcDbVoidPtrArray arBlocks;
	AcDbBlockReference *pBlock = NULL;
	acdbOpenObject(pBlock, id, AcDb::kForRead);
	if (pBlock != NULL)
	{
		pBlock->explode(arBlocks);
		AcDbLine *pLine = NULL;
		AcDbArc *pArc = NULL;
		AcDbCircle *pCir = NULL;
		XCurveSegment seg;
		for (int i =0; i < arBlocks.length(); ++i)
		{
			AcDbEntity *pEnt = (AcDbEntity*)arBlocks[i];
			if (pEnt != NULL)
			{
				if(pLine = AcDbLine::cast(pEnt))
				{
					XLine line(XPoint(pLine->startPoint()), XPoint(pLine->endPoint()));
					seg = line;
					lstCurves.Append(new XCurveSegment(seg));
				}
				else if(pArc = AcDbArc::cast(pEnt))
				{
					AcGePoint3d ptStart, ptEnd;
					pArc->getStartPoint(ptStart);
					pArc->getEndPoint(ptEnd);
					double dAng(0), dLen(0);
					pArc->getDistAtPoint(ptEnd, dLen);
					dAng = dLen / pArc->radius();
					XArc arc(XPoint(ptStart), XPoint(ptEnd), dAng);
					seg = arc;
					lstCurves.Append(new XCurveSegment(seg));
				}
				else if(pCir = AcDbCircle::cast(pEnt))
				{
					AcGePoint3d ptCen = pCir->center();
					XCircle cir(XPoint(ptCen), pCir->radius());
					seg = cir;
					lstCurves.Append(new XCurveSegment(seg));
				}
			}
		}
		pBlock->close();
	}
	ReleaseEntSet(arBlocks);
}

// 直线是否被曲线穿过（不包含直线端点）
bool IsLineThreadCurves(XLine &line, DList<XCurveSegment> &lstCurves)
{
	line.SetLineFlag(LS_FINITE);
	XPoint ptS = line.StartPoint();
	XPoint ptE = line.EndPoint();

	XPoint pt1, pt2;
	int nLen = lstCurves.Length();
	for (int i = 0; i < nLen; ++i)
	{
		XCurveSegment &seg = *lstCurves[i];
		seg.SetLineFlag(LS_FINITE);
		int nNum = seg.Intersection(line, pt1, pt2);
		if (nNum == 0)
		{
			continue;
		}

		// 两个交点，曲线穿过直线
		if (nNum == 2)
		{
			return true;
		}

		// 一个交点，交点不在直线端点时，穿过直线
		if (nNum == 1)
		{
			double dDist1 = ptS.Distance2d(pt1);
			double dDist2 = ptE.Distance2d(pt1);
			if (fabs(dDist1) > 0.001 && fabs(dDist2) > 0.001)
			{
				return true;
			}
		}

	}
	return false;
}

// 点是否在直线上
bool IsOnLine(XPoint &pt, XLine &line)
{
	XPoint ptS = line.StartPoint();
	XPoint ptE = line.EndPoint();
	double dLen = ptS.Distance(ptE);
	double dDist1 = ptS.Distance(pt);
	double dDist2 = ptE.Distance(pt);
	if (fabs(dDist2 + dDist1 - dLen) < 0.001)
	{
		return true;
	}
	return false;
}

// 直线是否与曲线共线
bool IsCollinear(XLine &line, DList<XCurveSegment> &lstCurves)
{
	XPoint ptS = line.StartPoint();
	XPoint ptE = line.EndPoint();
	AcGeVector3d vt = ptS - ptE;

	AcGeVector3d vtTemp;
	AcGeTol tol;
	tol.setEqualVector(0.001);
	XLine lineTemp;
	int nLen = lstCurves.Length();
	for (int i = 0; i < nLen; ++i)
	{
		XCurveSegment &seg = *lstCurves[i];
		if (!seg.Is(CURVE_LINE))
		{
			continue;
		}
		
		vtTemp = seg.StartPoint() - seg.EndPoint();
		if (!vtTemp.isParallelTo(vt, tol))
		{
			continue;
		}

		lineTemp.SetPoints(seg.StartPoint(), seg.EndPoint());
		if (IsOnLine(seg.StartPoint(), line) || IsOnLine(seg.EndPoint(), line)
			|| IsOnLine(ptS, lineTemp) || IsOnLine(ptE, lineTemp))
		{
			return true;
		}
	}
	return false;
}

// 直线是否平行x轴或y轴
bool IsParallelXorYAxis(XLine &line)
{
	AcGeVector3d vtLine = line.StartPoint() - line.EndPoint();
	vtLine.rotateBy(Wcs2Ucs(0.0), AcGeVector3d::kZAxis);
	vtLine.z = 0.0;
	AcGeTol tol;
	tol.setEqualVector(0.001);
	if (vtLine.isParallelTo(AcGeVector3d::kXAxis, tol) || vtLine.isParallelTo(AcGeVector3d::kYAxis, tol))
	{
		return true;
	}
	return false;
}

// 删除连接线中与图块直线重叠的部分以及圆内部分（假设直线重叠部分在起点位置）
void ModifyLinkPath(Entity &ent, XLine &line)
{
	// 获得图块中的曲线
	DList<XCurveSegment> lstCurves;
	GetBlockCurves(ent, lstCurves);

	AcGeVector3d vtLine = line.StartPoint() - line.EndPoint();
	vtLine.z = 0.0;
	AcGeTol tol;
	tol.setEqualVector(0.001);
	int nNum = 0;
	XPoint pt1, pt2;
	XCircle cir;
	line.SetLineFlag(LS_FINITE);
	int nLen = lstCurves.Length();
	AcGeVector3d vtTemp;
	for (int i = 0; i < nLen; ++i)
	{
		XCurveSegment &seg = *lstCurves[i];
		seg.SetLineFlag(LS_FINITE);
		if (seg.Is(CURVE_LINE)) // 直线
		{
			vtTemp = seg.StartPoint() - seg.EndPoint();
			vtTemp.z = 0.0;
			if (!vtTemp.isParallelTo(vtLine, tol))
			{
				continue;
			}
			
			// 如果line在seg内
			double dLen = seg.StartPoint().Distance2d(seg.EndPoint());
			double dDist1 = line.StartPoint().Distance2d(seg.StartPoint()) + line.StartPoint().Distance2d(seg.EndPoint());
			double dDist2 = line.EndPoint().Distance2d(seg.StartPoint()) + line.EndPoint().Distance2d(seg.EndPoint());
			if (fabs(dDist1 - dLen) < 0.001 && fabs(dDist2 - dLen) < 0.001)
			{
				pt1 = line.EndPoint();
				line.StartPoint() = pt1;
				break;
			}

			// line与seg部分重叠
			dLen = line.StartPoint().Distance2d(line.EndPoint());
			dDist1 = line.StartPoint().Distance2d(seg.StartPoint()) + line.EndPoint().Distance2d(seg.StartPoint());
			dDist2 = line.StartPoint().Distance2d(seg.EndPoint()) + line.EndPoint().Distance2d(seg.EndPoint());
			if (fabs(dLen - dDist1) > 0.001 && fabs(dLen - dDist2) > 0.001)
			{
				continue;
			}
			
			if (dDist1 < dDist2)
			{
				line.SetStartPoint(seg.StartPoint());
			}
			else
			{
				line.SetStartPoint(seg.EndPoint());
			}
		}
		else if (seg.Is(CURVE_CIRCLE)) // 园
		{
			nNum = seg.Intersection(line, pt1, pt2);
			if (nNum == 1)
			{
				line.SetStartPoint(pt1);
			}
		}
	}
}

void ModifyLinkPath(Entity &ent1, Entity &ent2, DList<XPoint> &lstPts)
{
	// 修剪连接线，删除重叠的部分和圆内部分
	XLine line;
	XPoint ptS, ptE, ptTemp;
	int nLen = lstPts.Length();
	if (nLen == 2)
	{
		line.SetStartPoint(*lstPts[0]);
		line.SetEndPoint(*lstPts[1]);
		ModifyLinkPath(ent1, line);
		
		line.SetStartPoint(*lstPts[1]);
		line.SetEndPoint(*lstPts[0]);
		ModifyLinkPath(ent2, line);
		
		*lstPts[0] = line.StartPoint();
		*lstPts[1] = line.EndPoint();
	}
	else
	{
		ptS = *lstPts[0];
		ptTemp = *lstPts[1];
		ptE = *lstPts[2];
		lstPts.Reset();

		XLine line1(ptS, ptTemp);
		ModifyLinkPath(ent1, line1);
		double dLen1 = line1.GetLength();
		if (dLen1 > 0.1)
		{
			lstPts.Append(new XPoint(line1.StartPoint()));
			lstPts.Append(new XPoint(line1.EndPoint()));
		}
		
		XLine line2(ptE, ptTemp);
		ModifyLinkPath(ent2, line2);
		if (line2.GetLength() > 0.1)
		{
			if (dLen1 < 0.1)
			{
				lstPts.Append(new XPoint(line2.EndPoint()));
			}
			lstPts.Append(new XPoint(line2.StartPoint()));
		}
	}
}

// 获得连接两设备图块的最佳垂直路径
// 2013-3-12 CET ADD 
void GetEquipLinkPath(Entity &ent1, Entity &ent2, const XPoint &ptPick, DList<XPoint> &lstPts)
{
	lstPts.Reset();
	// 获取连接点

	XPointList lstPt1, lstPt2;
	double dRadius1 = 0.0, dRadius2 = 0.0;
	GetEquipPoint(ent1, lstPt1, dRadius1);
	GetEquipPoint(ent2, lstPt2, dRadius2);
	
	if (lstPt1.Length() == 0 || lstPt2.Length() == 0)
	{
		return;
	}
	
	// 找出ent2中距离pt最近的点
	XPoint pt = ptPick;
	std::multimap<double, XPoint> mapDistPt;
	for (int i = 0; i < lstPt2.Length(); ++i)
	{
		double dDist = pt.Distance2d(*lstPt2[i]);
		mapDistPt.insert(std::make_pair(dDist, *lstPt2[i]));
	}
	pt = mapDistPt.begin()->second;
	
	// 获得图块中的曲线
	DList<XCurveSegment> lstCurves;
	GetBlockCurves(ent1, lstCurves);
	GetBlockCurves(ent2, lstCurves);
	
	// 根据距pt的远近对lst1排序
	mapDistPt.clear();
	for (i = 0; i < lstPt1.Length(); ++i)
	{
		double dDist = pt.Distance2d(*lstPt1[i]);
		mapDistPt.insert(std::make_pair(dDist, *lstPt1[i]));
	}
	
	// 找出pt与ent1上的点连线未被两图块穿过的直线
	XLine line, line1, line2;
	XPoint ptS, ptE, ptTemp;
	std::multimap<double, XPoint>::iterator it, itEnd = mapDistPt.end(); 
	for(it = mapDistPt.begin(); it != itEnd; ++it)
	{
		line.SetPoints(it->second, pt);
		// 直线与X轴或Y轴不平行
		if (!IsParallelXorYAxis(line))
		{
			ptS = line.StartPoint();
			ptE = line.EndPoint();
			ptS = Wcs2Ucs(ptS);
			ptE = Wcs2Ucs(ptE);
			ptTemp.x = ptS.x;
			ptTemp.y = ptE.y;
			ptTemp.z = ptE.z;
			ptTemp = Ucs2Wcs(ptTemp);

			XLine line1(ptS, ptTemp);
			XLine line2(ptE, ptTemp);
			if (!IsLineThreadCurves(line1, lstCurves) && !IsLineThreadCurves(line2, lstCurves))
			{
				ptS = Ucs2Wcs(ptS);
		    	ptE = Ucs2Wcs(ptE);

				lstPts.Append(new XPoint(ptS));
				lstPts.Append(new XPoint(ptTemp));
				lstPts.Append(new XPoint(ptE));
				break;
			}
			else 
			{
				ptTemp.x = ptE.x;
				ptTemp.y = ptS.y;	
				ptS = Ucs2Wcs(ptS);
			    ptE = Ucs2Wcs(ptE);
				ptTemp = Ucs2Wcs(ptTemp);

				line1.SetPoints(ptS, ptTemp);
				line2.SetPoints(ptE, ptTemp);
				if (!IsLineThreadCurves(line1, lstCurves) && !IsLineThreadCurves(line2, lstCurves))
				{
					lstPts.Append(new XPoint(ptS));
					lstPts.Append(new XPoint(ptTemp));
				    lstPts.Append(new XPoint(ptE));
					break;
				}
			}
		} 
		else if (!IsLineThreadCurves(line, lstCurves) || IsCollinear(line, lstCurves)) // 直线与X轴或Y轴平行并且未被曲线穿过或与曲线平行相交
		{
			lstPts.Append(new XPoint(line.StartPoint()));
			lstPts.Append(new XPoint(line.EndPoint()));
		}
	}

	// 已经找到连接线
	if (lstPts.Length() != 0) 
	{
		ModifyLinkPath(ent1, ent2, lstPts);
		return;
	}

	// 未找到连接线，直接找出两图块最近的两点连接
	std::multimap<double, std::pair<XPoint,XPoint> > mapPts;
	int nLen1 = lstPt1.Length();
	int nLen2 = lstPt2.Length();
	for (int k = 0; k < nLen1; ++k)
	{
		for (int j = 0; j < nLen2; ++j)
		{
			double dDist = (*lstPt1[k]).Distance2d(*lstPt2[j]);
			mapPts.insert(std::make_pair(dDist, std::make_pair(*lstPt1[k], *lstPt2[j])));
		}
	}
	
	std::multimap<double, std::pair<XPoint,XPoint> >::iterator itTemp = mapPts.begin();
	ptS = itTemp->second.first;
	ptE = itTemp->second.second;
	XLine lineTemp(ptS, ptE);
	if (!IsParallelXorYAxis(lineTemp))
	{
		ptS = Ucs2Wcs(ptS);
		ptE = Ucs2Wcs(ptE);
		ptTemp.x = ptS.x;
		ptTemp.y = ptE.y;
		ptTemp.z = ptE.z;
		ptS = Ucs2Wcs(ptS);
		ptE = Ucs2Wcs(ptE);
		ptTemp = Ucs2Wcs(ptTemp);

		lstPts.Append(new XPoint(ptS));
		lstPts.Append(new XPoint(ptTemp));
	    lstPts.Append(new XPoint(ptE));

		XLine line1(ptS, ptTemp);
		XLine line2(ptE, ptTemp);
	}
	else
	{
		lstPts.Append(new XPoint(ptS));
		lstPts.Append(new XPoint(ptE));
	}
	ModifyLinkPath(ent1, ent2, lstPts);
}

void testBlock()
{
	RBList rbMask(RTDXF0, _T("INSERT"), NULL);
	Entity ent1;
	XPoint pt1;
	if (SelectEntity1(_T("\n选择第一个图块："), ent1, pt1, rbMask) != RTNORM)
	{
		return;
	}

	Entity ent2;
	XPoint pt2;
	if (SelectEntity1(_T("\n选择第二个图块："), ent2, pt2, rbMask) != RTNORM)
	{
		return;
	}

	XPoint pt;
	if (acedGetPoint(NULL, _T("\n在第二个图块选择连接点"), pt) != RTNORM)
	{
		return;
	}

	DList<XPoint> lstPts;
	GetEquipLinkPath(ent1, ent2, pt, lstPts);

	int nLen = lstPts.Length();
	for (int i = 0; i < nLen - 1; ++i)
	{
		XLine line(*lstPts[i], *lstPts[i+1]);
		line.Make();
	}
}

void AdjustWndToViewport(CWnd* pWnd,int nXOff,int nYOff)
{
	if (pWnd != NULL)
	{
		CRect rect,rectWnd;
		acedGetAcadFrame()->GetWindowRect(rect);
		pWnd->GetWindowRect(&rectWnd);

		if (!PtInRect(rect, rectWnd.TopLeft()) &&
			!PtInRect(rect, rectWnd.BottomRight()))
		{
			int nX = rect.TopLeft().x + nXOff;
			int nY = rect.TopLeft().y = nYOff;
			pWnd->MoveWindow(nX,nY,rectWnd.Width(),rectWnd.Height());
		}
	}
}