//	add by xlc on 071114 消重图元
#include "stdafx.h"
#include "resource.h"
#include "adui.h"
#include "acui.h"
#include "actrans.h"


// extern GEOAPI int Intersect(const XPoly2D &poly1, const XPoly2D &poly2, DList<XPoly2D> &lstDest);
// extern GEOAPI int HandleCurveDup(PickSet &ss);
extern TARCH_IMPEXP BOOL g_bCheckWallDup3D;
extern TARCH_IMPEXP BOOL g_bAutoCheckWall;


// 添加标记
void ErrorPosition1(const XPoint &ptLowLeft, const XPoint &ptUpRight, const TCHAR *pszMsg)
{
	TDbPromptMark *pEntMsg=new TDbPromptMark(ptLowLeft, ptUpRight, pszMsg);
	double nW=pEntMsg->GetSizeX(), nH=pEntMsg->GetSizeY();

	{
		///////////////////////////////////////////////////////
		// 判断是否已经有相同的符号存在
		XDbBlockTableRec objMSpace;
		ASSERT(!!objMSpace);
		AcDbBlockTableRecordIterator* pBlockIterator=NULL;
		Acad::ErrorStatus es = objMSpace.m_pBlockTableRec->newIterator(pBlockIterator);
		ASSERT(es==Acad::eOk && pBlockIterator!=NULL);
		BOOL bExist=FALSE;
		for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) {
			AcDbEntity *pEntity=NULL;
			es = pBlockIterator->getEntity(pEntity, AcDb::kForRead);
			if (es!=Acad::eOk) continue;
			ASSERT(pEntity);

			XDbObject vTemp(pEntity);
			//不处理不可见的实体
			if (pEntity->visibility() == AcDb::kInvisible) {
				continue;
			}
			TDbPromptMark *pMsg=TDbPromptMark::cast(pEntity);
			if (pMsg && pEntMsg->CompareTo(*pMsg)==0) {
				bExist=TRUE;
				break;
			}
		}
		delete pBlockIterator;
		if (bExist) {
			delete pEntMsg;
			return;
		}
	}

	if (nW>1.0E-6 && nH>1.0E-6) {
		nW *= 1.5;
		nH *= 1.5;
		XRectAngle rect2(pEntMsg->GetLocation(), nW, nH);
		XPoint ptLow=rect2.GetLowLeft(), ptUp=rect2.GetUpRight();
		pEntMsg->SetTextStyle(InitTextStyle(TS_STANDARD));
		pEntMsg->AddToMSpace(Adesk::kTrue);
	} else {
		delete pEntMsg;
	}
}

// 是否墙体相交，考虑柱子的影响
bool IsWallIntersect(Entity en,Entity ent)
{
	XPoly2D poly1,poly2;									// 墙体截面
	AcDbObjectId idS1,idE1,idS2,idE2;
	OPENOBJ_BEGIN(en,AcDb::kForRead,TDbWall,pWall);
	if (pWall)
	{
		pWall->GetOutlinePoly(0,poly1,TRUE);
		idS1 = pWall->GetStartColumnId();
		idE1 = pWall->GetEndColumnId();
	}
	OPENOBJ_END();
	OPENOBJ_BEGIN(ent,AcDb::kForRead,TDbWall,pWall);
	if (pWall)
	{
		pWall->GetOutlinePoly(0,poly2,TRUE);
		idS2 = pWall->GetStartColumnId();
		idE2 = pWall->GetEndColumnId();
	}
	OPENOBJ_END();

	AcDbObjectId idColS,idColE;
	if ((idS1 == idE2 || idS1 == idS2) && idS1 != AcDbObjectId::kNull)
	{
		idColS = idS1;
	}
	if ((idE1 == idE2 || idE1 == idS2) && idE1 != AcDbObjectId::kNull)
	{
		idColE = idE1;
	}
	XPoly2D colPolyS,colPolyE;
	if (idColS != AcDbObjectId::kNull)
	{
		OPENOBJ_BEGIN(idColS, AcDb::kForRead, TDbColumn, pCol);
		if (pCol)
		{
			pCol->GetOutline(colPolyS);
		}
		OPENOBJ_END();
	}
	if (idColE != AcDbObjectId::kNull)
	{
		OPENOBJ_BEGIN(idColE, AcDb::kForRead, TDbColumn, pCol);
		if (pCol)
		{
			pCol->GetOutline(colPolyS);
		}
		OPENOBJ_END();
	}

	DList<XPoly2D> lstDest;
	if (TchSubExport::Intersect(poly1,poly2,lstDest) == RTNORM)
	{
		if (lstDest.Length()!= 0)		// 有交点
		{
			double area=0.0;			// 相交区域面积
			for(int i=0;i<lstDest.Length();i++)
			{
				area += fabs(lstDest[i]->PathArea());
			}
			if (area > _DIST_SNAP*_DIST_SNAP)//相交精度控制
			{
				if (idColS == AcDbObjectId::kNull&&idColE == AcDbObjectId::kNull)//无柱子
				{
					return true;
				}

				for(int i=0;i<lstDest.Length();i++)
				{
					XPoly2D poly = *lstDest[i];
					for(long j=0;j<poly.Length();j++)
					{
						XPoint pt=*poly[j];
						int count=0;
						if (colPolyS.Length()>0)
						{
							if ((pt&colPolyS)==PR_OUTSIDE)//点不在柱内
							{
								count = 1;
							}
						}
						
						if (colPolyE.Length()>0)
						{
							if ((pt&colPolyE)==PR_OUTSIDE)//点不在柱内
							{
								count = 1;
							}
							else
							{
								if (count == 1)
								{
									count = 2;			//点在另外柱子里
								}
							}
						}
					
						if (count == 1)				//柱子外有交点
						{
							return true;
						}
						else if (count == 0)			//柱子外无交点
						{
							continue;
						}
						else						//柱子外有交点，且交点在另外柱子里
						{
							DList<XPoly2D> lstOutSide1, lstOutSide2;
							DList<XPoly2D> polyClip;
							polyClip.Append(&colPolyS);
							polyClip.Append(&colPolyE);
							DList<XPoly2D> poly2d1,poly2d2;
							poly2d1.Append(&poly1);
							poly2d2.Append(&poly2);
							
							Subtract(poly2d1, polyClip, lstOutSide1);
							Subtract(poly2d2, polyClip, lstOutSide2);
						
							DList<XPoly2D> result;
							for(int k=0;k<lstOutSide1.Length();k++)
							{
								for(int l=0;l<lstOutSide2.Length();l++)
								{
									if (TchSubExport::Intersect(*lstOutSide1[k],*lstOutSide2[l],result) == RTNORM)
									{
										if (result.Length()!= 0)		// 有交点
										{
											return true;
										}
									}	
								}
							}
						}
					}
				}
				return false;
			}
		}
	}
	return false;
}

// Zyu add on 100708
// 比较多段线的指定结点与给定点否相同
bool IsVertexEqual(const TGGePoly3D &poly, const AcGePoint3d &ptCmp, int iIndex)
{
	int iNumVerts = poly.Length();
	// 下标大于等于多段线的节点数，无法比较
	if (iIndex >= iNumVerts)
	{
		return false;
	}

	TGGeCurveSegment curveSeg;	// 多段线的一段
	AcGeLine3d lineFirst;		// 之前的直线
	AcGeLine3d lineSecond;		// 当前的直线
	AcGePoint3d ptVertex;		// 多段线的结点
	AcGeVector3d vtDirection;	// 方向矢量
	AcGeTol tol;				// 误差精度

	tol.setEqualPoint(_DIST_SNAP);
	tol.setEqualVector(_DIST_SNAP);
	ptVertex = poly.GetPointListAt(iIndex).AsAcGePoint3d();
	vtDirection = AcGeVector3d::kXAxis;

	// 得到之前的直线
	// 如果多段线是闭合的，或者下标不为0，则可以直接得到之前的弧段
	if (poly.m_nFlag || iIndex != 0)
	{
		poly.Nth((iIndex - 1 + iNumVerts) % iNumVerts, curveSeg);
		vtDirection.rotateBy(curveSeg.Direction(curveSeg.EndPoint()), AcGeVector3d::kZAxis);
	}
	// 否则利用当前的弧段取得直线的方向
	else
	{
		poly.Nth(iIndex, curveSeg);
		vtDirection.rotateBy(curveSeg.Direction(curveSeg.StartPoint()) + PI / 2, AcGeVector3d::kZAxis);
	}
	lineFirst.set(ptVertex + vtDirection, ptVertex - vtDirection);

	vtDirection = AcGeVector3d::kXAxis;

	// 得到当前的直线
	// 如果多段线是闭合的，或者下标不是最后一个结点，则可以直接得到当前的弧段
	if (poly.m_nFlag || iIndex + 1 != iNumVerts)
	{
		poly.Nth(iIndex, curveSeg);
		vtDirection.rotateBy(curveSeg.Direction(curveSeg.StartPoint()), AcGeVector3d::kZAxis);
		// 如果平行，取垂直方向
		if (vtDirection.isParallelTo(lineFirst.direction(), tol))
		{
			vtDirection.rotateBy(PI / 2, AcGeVector3d::kXAxis);
		}
	}
	// 否则利用之前直线的垂线方向得到当前直线的方向
	else
	{
		vtDirection.rotateBy(lineFirst.direction().angleTo(AcGeVector3d::kXAxis) + PI / 2, AcGeVector3d::kZAxis);
	}
	lineSecond.set(ptVertex + vtDirection, ptVertex - vtDirection);

	// 判断距离关系
	return !(lineFirst.distanceTo(ptCmp) > _DIST_SNAP 
		|| lineSecond.distanceTo(ptCmp) > _DIST_SNAP);
}

// Zyu add on 100708
// 调整多段线，将首尾点相同的多段线调整为闭合，同时保证闭合的多段线方向都是逆时针
void AdjustPoly(TGGePoly3D &poly)
{
	int iLen = poly.Length();
	if (iLen < 2)
	{
		return;
	}

	AcGePoint3d ptStart = poly.GetPointListAt(0)->AsAcGePoint3d();
	AcGePoint3d ptEnd = poly.GetPointListAt(iLen - 1)->AsAcGePoint3d();

	// 设置误差范围
	AcGeTol tol;
	tol.setEqualPoint(_DIST_SNAP);
	tol.setEqualVector(_DIST_SNAP);

	// 调整闭合方式
	if (ptStart.isEqualTo(ptEnd, tol))
	{
		poly.m_nFlag = 1;
		poly.RemoveNode(iLen - 1);
	}

	// 压缩
	poly.Compress(true);

	// 调整方向
	if (poly.m_nFlag && (poly.PathArea() > 0))
	{
		poly.Reverse();
	}
}

enum TYPE
{
	kNull = -1,		//不处理		
	kOther = 0,		//线，弧，圆
	kText = 1,		//文本
	kBlock = 2,		//图块
	kWall = 3,		//墙
	kColumn = 4,	//柱子
	kOpenning = 5,	//门窗
	kTSpace = 6,		//房间
	// Zyu add on 100702，添加新的处理类型
	kTLine = 7,		// 线
	kPoly = 8,		// 多段线
	kArc = 9,		// 圆弧
};


class TEntity
{
public:
	TEntity(){};
	TEntity(Entity en)
	{
		m_nType = kNull;
		AcDbObjectId objId;
		Acad::ErrorStatus es = acdbGetObjectId(objId, en);
		if (es != Acad::eOk)
			return;
		
		AcDbObject* obj=NULL;
		es = acdbOpenObject(obj, objId, AcDb::kForRead);
		if (es != Acad::eOk)
			return;

		CString strClassName = obj->isA()->name();
		obj->close();
		// Zyu modify on 100702
		// 对实体的分类做进一步的划分
		// Begin
		//if((_tcsicmp(strClassName,_T("AcDbLine")) == 0)
		//	||(_tcsicmp(strClassName,_T("AcDbArc")) == 0)
		//	||(_tcsicmp(strClassName,_T("AcDbCircle")) == 0))	//直线，弧，圆
		//{
		//	m_nType = kOther;
		//}
		if (_tcsicmp(strClassName,_T("AcDbLine")) == 0)
		{
			m_nType = kTLine;
		}
		else if ((_tcsicmp(strClassName,_T("AcDbArc")) == 0)
				||(_tcsicmp(strClassName,_T("AcDbCircle")) == 0))
		{
			m_nType = kArc;
		}
		else if (_tcsicmp(strClassName,_T("AcDbPolyLine")) == 0
				|| _tcsicmp(strClassName,_T("AcDb2dPolyLine")) == 0)	// 支持2维多段线，Zyu add on 101206
		{
			m_nType = kPoly;
		}
		// End
		else if (_tcsicmp(strClassName,_T("TDbWall")) == 0
			||_tcsicmp(strClassName,_T("TDbCurtainWall")) == 0)	//墙体和幕墙
		{
			m_nType = kWall;
		}
		else if (_tcsicmp(strClassName,_T("TDbColumn")) == 0)	//柱子
		{
			m_nType = kColumn;
		}
		else if (_tcsicmp(strClassName,_T("TDbOpening")) == 0
			||_tcsicmp(strClassName,_T("TDbGroupOpening")) == 0)//门窗，组合门窗
		{
			m_nType = kOpenning;
		}
		else if (_tcsicmp(strClassName,_T("TDbSpace")) == 0)		//房间
		{
			m_nType = kTSpace;
		}
		else if ((_tcsicmp(strClassName,_T("TDbText")) == 0)
			||(_tcsicmp(strClassName,_T("TDbMText")) == 0)
			||(_tcsicmp(strClassName,_T("AcDbText")) == 0)
			||(_tcsicmp(strClassName,_T("AcDbMText")) == 0))	//文本
		{
			m_nType = kText;
		}
		else if ((_tcsicmp(strClassName,_T("TDbBlockInsert")) == 0)
			||(_tcsicmp(strClassName,_T("AcDbBlockReference")) == 0))//图块
		{
			m_nType = kBlock;
		}
		else
		{
			return;
		}
		
		m_eName = en;
		
		//获得2D下的包围盒
		int nOldMode=DocGetDrawMode();
		DocSetDrawMode(DRAW_2D);
		ads_point ptLow,ptUp;
		en.GetExtend(ptLow,ptUp);
		DocSetDrawMode(nOldMode);
		ptLow[2]=ptUp[2]=0;
		m_ptMin = ptLow;
		m_ptMax = ptUp;
	}
	
	int m_nType;
	Entity m_eName;
	XPoint m_ptMin,m_ptMax;

	bool operator >(const TEntity& ent)const
	{
		if (m_nType == ent.m_nType)
		{
			if (m_ptMin == ent.m_ptMin)
			{
				if (m_ptMax == ent.m_ptMax)
				{
					return false;
				}
				return m_ptMax > ent.m_ptMax;
			}
			return m_ptMin > ent.m_ptMin;
		}
		 
		return m_nType > ent.m_nType;
	}

	bool operator <(const TEntity& ent)const{return ent>(*this);}
	bool operator==(const TEntity& ent)
	{
		if ((m_nType == ent.m_nType))
		{
			switch(m_nType)
			{
			case kText:
				return CompareText(ent); 
				break;
			case kBlock:
				return CompareBlock(ent);
				break;
			case kWall:
				return CompareWall(ent); 
				break;
			case kColumn:
				return CompareColumn(ent);
				break;
			case kOpenning:
				return CompareOpening(ent);
				break;
			case kTSpace:
				return CompareSpace(ent);
				break;
			// Zyu add on 100702，比较多段线
			case kPoly:
				return ComparePoly(ent);
				break;
			}
			return true;
		}

		return false;
	}

	//两段XPoly2D线是否相交
	bool IsIntersect(XPoly2D &poly1,XPoly2D &poly2)
	{
		DList<XPoly2D> lstDest;
		if (TchSubExport::Intersect(poly1,poly2,lstDest) == RTNORM)
		{
			if (lstDest.Length()!= 0)		// 有交点
			{
				double area=0.0;			// 相交区域面积
				for(int i=0;i<lstDest.Length();i++)
				{
					area += fabs(lstDest[i]->PathArea());
				}
				if (area > _DIST_SNAP*_DIST_SNAP)//相交精度控制
				{
					return true;
				}
			}
		}

		return false;
	}

	//由点ptMin,ptMax构成的XPoly2D和由点ptMin2,ptMax2构成的XPoly2D是否相交
	bool IsIntersect(XPoint ptMin,XPoint ptMax,XPoint ptMin2,XPoint ptMax2)
	{
		XPoly2D poly1(1),poly2(1);
		poly1.AppendNode(ptMin);
		poly1.AppendNode(XPoint(ptMin[0],ptMax[1]));
		poly1.AppendNode(ptMax);
		poly1.AppendNode(XPoint(ptMax[0],ptMin[1]));

		poly2.AppendNode(ptMin2);
		poly2.AppendNode(XPoint(ptMin2[0],ptMax2[1]));
		poly2.AppendNode(ptMax2);
		poly2.AppendNode(XPoint(ptMax2[0],ptMin2[1]));
	
		return IsIntersect(poly1,poly2);
	}

	//是否在控制精度范围内存在相同点
	bool IsPointEqual(AcGePoint3d ptStart1,AcGePoint3d ptEnd1,AcGePoint3d ptStart2,AcGePoint3d ptEnd2)
	{
		ptStart1.z=0;
		ptEnd1.z=0;
		ptStart2.z=0;
		ptEnd2.z=0;
		if ((ptStart1.distanceTo(ptStart2)<g_nDistPrec)
			||(ptStart1.distanceTo(ptEnd2)<g_nDistPrec)
			||(ptEnd1.distanceTo(ptStart2)<g_nDistPrec)
			||(ptEnd1.distanceTo(ptEnd2)<g_nDistPrec)
			)
		{
			return true;
		}
		return false;
	}

	// 比较墙体是否相交
	bool CompareWall(TEntity ent)
	{
		bool bIntersect=IsIntersect(m_ptMin,m_ptMax,ent.m_ptMin,ent.m_ptMax);
		if (!bIntersect)
		{
			AcDbCurve *pCurve1=NULL,*pCurve2=NULL;					// 墙体的基线
			XPoly2D poly1(1),poly2(1);									// 墙体截面
			BOOL bIsArc1,bIsArc2;									//是否弧墙
			int count=0;
			XPoint ptCenter1,ptCenter2;
			AcGeVector3d vect1,vect2;
			XPoint ptStart1,ptStart2,ptEnd1,ptEnd2;

			OPENOBJ_BEGIN(m_eName,AcDb::kForRead,TDbWall,pWall);
			if (pWall)
			{
				ptStart1=pWall->StartPoint();
				ptEnd1=pWall->EndPoint();
				bIsArc1 = pWall->Is(CURVE_ARC);
				if (bIsArc1)
				{
					ptCenter1=pWall->GetArc().GetCenterPt();
				}
				else
				{
					vect1=pWall->Direction3d();
				}
			}
			OPENOBJ_END();
			OPENOBJ_BEGIN(ent.m_eName,AcDb::kForRead,TDbWall,pWall);
			if (pWall)
			{
				ptStart2=pWall->StartPoint();
				ptEnd2=pWall->EndPoint();

				bIsArc2 = pWall->Is(CURVE_ARC);
				if (bIsArc2)
				{
					ptCenter2=pWall->GetArc().GetCenterPt();
				}
				else
				{
					vect2=pWall->GetLine().Direction3d();
				}
			}
			OPENOBJ_END();
			
			BOOL bParallel=FALSE;
			if (!bIsArc1&&!bIsArc2)
			{
				if (vect1.isParallelTo(vect2))
					bParallel=TRUE;
			}
			else if (bIsArc1&&bIsArc2)
			{
				if (ptCenter1.Distance2d(ptCenter2)<_DIST_SNAP)
					bParallel=TRUE;
			}
			if (bParallel)
			{
				XLine line1(ptStart1,ptEnd1,LS_FINITE),line2(ptStart2,ptEnd2,LS_FINITE);
				ads_point pts;
				int num=line1.Intersection(&line2,pts);

				//modify by xlc on 090206 消除弧墙有唯一顶点相同时的影响
// 				if (num!=NULL)//弧墙基线有重合
// 				{
// 					return true;
// 				}
// 				else
// 				{
// 					int a=line1.HitTest2d(ptStart2),
// 						b=line1.HitTest2d(ptEnd2),
// 						c=line2.HitTest2d(ptStart1),
// 						d=line2.HitTest2d(ptEnd2);
// 
// 					if (line1.HitTest2d(ptStart2)==5
// 						||line1.HitTest2d(ptEnd2)==5
// 						||line2.HitTest2d(ptStart1)==5
// 						||line2.HitTest2d(ptEnd1)==5)//基线有部分重合
// 						return true;
// 					else if ((line1.HitTest2d(ptStart2)==3&&line1.HitTest2d(ptEnd2)==4)
// 						||(line1.HitTest2d(ptStart2)==4&&line1.HitTest2d(ptEnd2)==3))//完全重合
// 					{
// 						return true;
// 					}
// 				}

				if ((line1.HitTest2d(XPoint(ptStart2))==3&&line1.HitTest2d(XPoint(ptEnd2))==4)
					||(line1.HitTest2d(XPoint(ptStart2))==4&&line1.HitTest2d(XPoint(ptEnd2))==3))//完全重合
				{
					return true;
				}
				else if (line1.HitTest2d(XPoint(ptStart2))==3
					||line1.HitTest2d(XPoint(ptEnd2))==4
					||line1.HitTest2d(XPoint(ptStart2))==4
					||line1.HitTest2d(XPoint(ptEnd2))==3)				//基线有唯一一个相同顶点
				{
					return false;
				}
				else if (line1.HitTest2d(XPoint(ptStart2))==5
					||line1.HitTest2d(XPoint(ptEnd2))==5
					||line2.HitTest2d(XPoint(ptStart1))==5
					||line2.HitTest2d(XPoint(ptEnd1))==5)//基线有部分重合
					return true;
				else if (num!=NULL)//弧墙基线有重合
				{
					return true;
				}
			}
		}
		//if (IsIntersect(m_ptMin,m_ptMax,ent.m_ptMin,ent.m_ptMax))	// 两段墙包围盒是否相交
		if (bIntersect)
		{
			AcDbCurve *pCurve1=NULL,*pCurve2=NULL;					// 墙体的基线
 			XPoly2D poly1,poly2;									// 墙体截面
			double elev1(0),elev2(0),height1(0),height2(0);			// 墙体标高,高度
			AcGePoint3d ptStart1,ptEnd1,ptStart2,ptEnd2;			// 墙体起始点
			BOOL bIsArc1,bIsArc2;									//是否弧墙
			XPoint ptCenter1,ptCenter2;
			AcGeVector3d vect1,vect2;
			AcDbObjectId idS1,idE1,idS2,idE2;
			OPENOBJ_BEGIN(m_eName,AcDb::kForRead,TDbWall,pWall);
 			if (pWall)
 			{
 				pWall->GetOutlinePoly(0,poly1,TRUE);
				elev1 = pWall->GetElevation();
				height1=pWall->GetHeight();
				pCurve1=pWall->GetAcDbCurve(0);
				pWall->getStartPoint(ptStart1);
				pWall->getEndPoint(ptEnd1);
				bIsArc1 = pWall->Is(CURVE_ARC);
				if (bIsArc1)
				{
					ptCenter1=pWall->GetArc().GetCenterPt();
				}
				else
				{
					vect1=pWall->Direction3d();
				}
 			}
 			OPENOBJ_END();
			OPENOBJ_BEGIN(ent.m_eName,AcDb::kForRead,TDbWall,pWall);
			if (pWall)
			{
				pWall->GetOutlinePoly(0,poly2,TRUE);
				elev2 = pWall->GetElevation();
				height2=pWall->GetHeight();
				pCurve2=pWall->GetAcDbCurve(0);
				pWall->getStartPoint(ptStart2);
				pWall->getEndPoint(ptEnd2);
				bIsArc2 = pWall->Is(CURVE_ARC);
				if (bIsArc2)
				{
					ptCenter2=pWall->GetArc().GetCenterPt();
				}
				else
				{
					vect2=pWall->Direction3d();
				}
			}
			OPENOBJ_END();

			BOOL flag=FALSE;		//基线是否相交标志
			if (pCurve1 && pCurve2)
			{
				AcGePoint3dArray points;
				pCurve1->intersectWith(pCurve2,AcDb::kOnBothOperands,AcGePlane(AcGePoint3d(0,0,0),AcGeVector3d::kZAxis),points);
				if (points.length() == 1)
				{
					flag=TRUE;
				}
			}
			if (pCurve1)
			{
				delete pCurve1;
			}

			if (pCurve2)
			{
				delete pCurve2;
			}
		
			if (IsIntersect(poly1,poly2))			//墙体截面是否相交
			{
				if (flag && IsPointEqual(ptStart1,ptEnd1,ptStart2,ptEnd2))
					return false;
				
				//add by xlc on 090424
				else
				{
					XLine line1((XPoint)ptStart1,(XPoint)ptEnd1,LS_FINITE),line2((XPoint)ptStart2,(XPoint)ptEnd2,LS_FINITE);
					ads_point pts;
					int num=line1.Intersection(&line2,pts);

					if ((line1.HitTest2d(XPoint(ptStart2))==3&&line1.HitTest2d(XPoint(ptEnd2))==4)
						||(line1.HitTest2d(XPoint(ptStart2))==4&&line1.HitTest2d(XPoint(ptEnd2))==3))//完全重合
					{
						return true;
					}
					else if ((line1.HitTest2d(XPoint(ptStart2))==3
						||line1.HitTest2d(XPoint(ptEnd2))==4
						||line1.HitTest2d(XPoint(ptStart2))==4
						||line1.HitTest2d(XPoint(ptEnd2))==3)
						&&(!(line1.HitTest2d(XPoint(ptStart2))==5
						||line1.HitTest2d(XPoint(ptEnd2))==5
						||line2.HitTest2d(XPoint(ptStart1))==5
						||line2.HitTest2d(XPoint(ptEnd1))==5)))				//基线有唯一一个相同顶点
					{
						return false;
					}
				}

				BOOL bIntersect=FALSE;				// 是否立面上有相交
				if (g_bCheckWallDup3D)				// 检查三维重叠
				{
					// 考虑标高
					if (elev1<elev2)
					{
						if (elev1+height1>elev2)		// 存在重叠
						{
							bIntersect=TRUE;
						}
					}
					else if (elev1>elev2)
					{
						if (elev1<elev2+height2)		// 存在重叠
						{
							bIntersect=TRUE;
						}
					}
					else
					{
						bIntersect=TRUE;
					}
				}
				else
				{
					bIntersect=TRUE;
				}
				if (bIntersect)
				{
					return (IsWallIntersect(m_eName,ent.m_eName));
					/*return true;
					AcDbObjectId idColS,idColE;
					if ((idS1 == idE2 || idS1 == idS2) && idS1 != AcDbObjectId::kNull)
					{
						idColS = idS1;
					}
					if ((idE1 == idE2 || idE1 == idS2) && idE1 != AcDbObjectId::kNull)
					{
						idColE = idE1;
					}
					XPoly2D colPolyS,colPolyE;
					if (idColS != AcDbObjectId::kNull)
					{
						OPENOBJ_BEGIN(idColS, AcDb::kForRead, TDbColumn, pCol);
						if (pCol)
						{
							pCol->GetOutline(colPolyS);
						}
						OPENOBJ_END();
					}
					if (idColE != AcDbObjectId::kNull)
					{
						OPENOBJ_BEGIN(idColE, AcDb::kForRead, TDbColumn, pCol);
						if (pCol)
						{
							pCol->GetOutline(colPolyS);
						}
						OPENOBJ_END();
					}

					DList<XPoly2D> lstDest;
					if (Intersect(poly1,poly2,lstDest) == RTNORM)
					{
						if (lstDest.Length()!= 0)		// 有交点
						{
							double area=0.0;			// 相交区域面积
							for(int i=0;i<lstDest.Length();i++)
							{
								area += fabs(lstDest[i]->PathArea());
							}
							if (area > _DIST_SNAP*_DIST_SNAP)//相交精度控制
							{
								return true;
							}
						}
					}

					return true;*/
				}
			}
			else
			{
				BOOL bParallel=FALSE;
				if (!bIsArc1&&!bIsArc2)
				{
					if (vect1.isParallelTo(vect2))
						bParallel=TRUE;
				}
				else if (bIsArc1&&bIsArc2)
				{
					if (ptCenter1.Distance2d(ptCenter2)<_DIST_SNAP)
						bParallel=TRUE;
				}
				if (bParallel)
				{
					XLine line1(XPoint(ptStart1.x,ptStart1.y,ptStart1.z),XPoint(ptEnd1.x,ptEnd1.y,ptEnd1.z),LS_FINITE);
					XLine line2(XPoint(ptStart2.x,ptStart2.y,ptStart2.z),XPoint(ptEnd2.x,ptEnd2.y,ptEnd2.z),LS_FINITE);
					ads_point pts;
					int num=line1.Intersection(&line2,pts);

					//modify by xlc on 090120 消除弧墙有唯一顶点相同时的影响
// 					if (num!=NULL)//弧墙基线有重合
// 					{
// 						return true;
// 					}
// 					else
// 					{
// 						if (line1.HitTest2d(XPoint(ptStart2))==5
// 							||line1.HitTest2d(XPoint(ptEnd2))==5
// 							||line2.HitTest2d(XPoint(ptStart1))==5
// 							||line2.HitTest2d(XPoint(ptEnd1))==5)//基线有部分重合
// 							return true;
// 						else if ((line1.HitTest2d(XPoint(ptStart2))==3&&line1.HitTest2d(XPoint(ptEnd2))==4)
// 							||(line1.HitTest2d(XPoint(ptStart2))==4&&line1.HitTest2d(XPoint(ptEnd2))==3))//完全重合
// 						{
// 							return true;
//						}
//					}
					if ((line1.HitTest2d(XPoint(ptStart2))==3&&line1.HitTest2d(XPoint(ptEnd2))==4)
						||(line1.HitTest2d(XPoint(ptStart2))==4&&line1.HitTest2d(XPoint(ptEnd2))==3))//完全重合
					{
						return true;
					}
					else if (line1.HitTest2d(XPoint(ptStart2))==3
						||line1.HitTest2d(XPoint(ptEnd2))==4
						||line1.HitTest2d(XPoint(ptStart2))==4
						||line1.HitTest2d(XPoint(ptEnd2))==3)				//基线有唯一一个相同顶点
					{
						return false;
					}
					else if (line1.HitTest2d(XPoint(ptStart2))==5
						||line1.HitTest2d(XPoint(ptEnd2))==5
						||line2.HitTest2d(XPoint(ptStart1))==5
						||line2.HitTest2d(XPoint(ptEnd1))==5)//基线有部分重合
						return true;
					else if (num!=NULL)//弧墙基线有重合
					{
						return true;
					}

				}
			}
 		}
		return false;
	}

	// 比较文本是否重合
	bool CompareText(const TEntity &ent)
	{
		if (m_ptMin == ent.m_ptMin)
		{
			if (m_ptMax == ent.m_ptMax)
			{
				CString strText=GetTextContent(m_eName),
					strTextEnt=GetTextContent(ent.m_eName);
				//if (_tcsicmp(strText,strTextEnt) == 0)
				if (strText==strTextEnt)
				{
					return true;
				}
			}
		}
		return false;
	}

	// 获得文本内容
	CString GetTextContent(Entity en)
	{
		CString strText(_T(""));
		OPENOBJ_BEGIN(en, AcDb::kForRead, AcDbEntity, pText);
		if (pText)
		{
			if (pText->isKindOf(AcDbText::desc()))
			{
				TCHAR	*str=((AcDbText *)pText)->textString();
				strText.Format(_T("%s"),((AcDbText *)pText)->textString());
				free(str);
			}
			else if (pText->isKindOf(AcDbMText::desc()))
			{
				TCHAR	*str=((AcDbMText *)pText)->contents();
				strText.Format(_T("%s"),str);
				free(str);
			}
			else
				strText.Format(_T("%s"),((TDbText *)pText)->GetText());
		}
		OPENOBJ_END();	

		return strText;
	}

	// 比较图块是否重合
	bool CompareBlock(TEntity ent)
	{
		if (m_ptMin == ent.m_ptMin)
		{
			if (m_ptMax == ent.m_ptMax)
			{
				CString strName=GetBlockName(m_eName),
					strNameEnt=GetBlockName(ent.m_eName);
				if (strName.CompareNoCase(strNameEnt) == 0)
				{
					return true;
				}
			}
		}
		return false;
	}

	// 获得图块名
	CString GetBlockName(Entity ent)
	{
		CString strText(_T(""));
		OPENOBJ_BEGIN(ent,AcDb::kForRead,AcDbBlockTableRecord,pBlkTblRec);
		if (pBlkTblRec)               	
		{								
			TCHAR *pchName=NULL;						// 块名
			pBlkTblRec->getName(pchName);	            // 得到块名								
			strText.Format(_T("%s"),pchName);
			acutDelString(pchName);
		}			
		OPENOBJ_END();						
		return strText;
	}
	
	int SpaceAreaCmpType(TDbSpace::AreaType areaType)
	{
		switch (areaType)
		{
		case TDbSpace::kTotalArea:
			return 1;
		case TDbSpace::kHouseArea:
		case TDbSpace::kShareArea:
			return 2;
		case TDbSpace::kUseArea:
		case TDbSpace::kHoleArea:
		case TDbSpace::kBalconyArea:
			return 3;
		default:
			return 0;
		}
	}

	inline bool FindType(TDbSpace::AreaType *type, TDbSpace::AreaType areaType, int nLen)
	{
		for (int i = 0; i < nLen; i++)
		{
			if (areaType == type[i])
				return true;
		}
		return false;
	}

	bool SpaceAreaCmpType(TDbSpace::AreaType areaType1, TDbSpace::AreaType areaType2)
	{
		// 组织了三个集合，如果两个类型（可能相同）属于同一个集合，则两个类型需要判断重合
		static TDbSpace::AreaType aryTotalSpace[] = {TDbSpace::kTotalArea};
		static TDbSpace::AreaType aryHouseSpace[] = {TDbSpace::kHouseArea, TDbSpace::kShareArea};
		static TDbSpace::AreaType aryOthers[] = {TDbSpace::kShareArea, TDbSpace::kUseArea,
				TDbSpace::kHoleArea, TDbSpace::kBalconyArea};

#define _FINDTYPE(arySpace, ntype) \
FindType(arySpace, ntype, sizeof(arySpace)/sizeof(TDbSpace::AreaType))
		return (_FINDTYPE(aryTotalSpace, areaType1) && _FINDTYPE(aryTotalSpace, areaType2))
			|| (_FINDTYPE(aryHouseSpace, areaType1) && _FINDTYPE(aryHouseSpace, areaType2))
			|| (_FINDTYPE(aryOthers, areaType1) && _FINDTYPE(aryOthers, areaType2));

#undef _FINDTYPE
	}

	// 比较房间是否重叠
	bool CompareSpace(TEntity ent)
	{
		//add by xlc on 090526
		BOOL bSpace=FALSE;			//是否房间类型
		// Zyu add on 100707
		TDbSpace::AreaType spaceType = TDbSpace::kOther;	// 房间类型

		XPoly2D poly1,poly2;
		OPENOBJ_BEGIN(m_eName,AcDb::kForRead,TDbSpace,pSpace);
		if (pSpace)
		{
			AcGeVector3d normal;
			pSpace->GetPathPoly(poly1,normal);
			
			// Zyu modify on 100707
			// Begin
			//add by xlc on 090526
			//if(!(pSpace->m_nType==TDbSpace::kHouseArea
			//	||pSpace->m_nType==TDbSpace::kTotalArea)
			//	)
			//{
			//	bSpace=TRUE;
			//}
			bSpace = TRUE;
			// 记录房间类型
			spaceType = pSpace->m_nType;
			// End
		}
		OPENOBJ_END();
		OPENOBJ_BEGIN(ent.m_eName,AcDb::kForRead,TDbSpace,pSpace);
		if (pSpace)
		{
			AcGeVector3d normal;
			pSpace->GetPathPoly(poly2,normal);

			// 修改描述：添加对套内与套内，套内与公摊，建筑轮廓与建筑轮廓这几种房间类型之间的消重
			// Zyu modify on 100707
			// Begin
			//add by xlc on 090526
			//if(bSpace
			//	&&(pSpace->m_nType==TDbSpace::kHouseArea
			//		||pSpace->m_nType==TDbSpace::kTotalArea)
			//	)
			//{
			//	bSpace=FALSE;
			//}
			if (bSpace)
			{
//				bSpace = (SpaceAreaCmpType(spaceType) == SpaceAreaCmpType(pSpace->m_nType));
				bSpace = SpaceAreaCmpType(spaceType, pSpace->m_nType);

// 				switch (spaceType)
// 				{
// 				case TDbSpace::kHouseArea: // 套内与套内，套内与公摊
// 					{
// 						if (TDbSpace::kHouseArea != pSpace->m_nType
// 							&& TDbSpace::kShareArea != pSpace->m_nType)
// 						{
// 							bSpace = FALSE;
// 						}
// 					}
// 					break;
// 				case TDbSpace::kShareArea: // 公摊与套内
// 					{
// 						if (TDbSpace::kHouseArea != pSpace->m_nType)
// 						{
// 							bSpace = FALSE;
// 						}
// 					}
// 					break;
// 				case TDbSpace::kTotalArea: // 建筑轮廓与建筑轮廓
// 					{
// 						if (TDbSpace::kTotalArea != pSpace->m_nType)
// 						{
// 							bSpace = FALSE;
// 						}
// 					}
// 					break;
// 				}
			}
			// End
		}
		OPENOBJ_END();

		if (bSpace)
			return IsIntersect(poly1,poly2);
		else
			return false;
	}

	// 比较柱子是否重叠
	bool CompareColumn(TEntity ent)
	{
		if (IsIntersect(m_ptMin,m_ptMax,ent.m_ptMin,ent.m_ptMax))
		{
			XPoly2D poly1,poly2;
			OPENOBJ_BEGIN(m_eName,AcDb::kForRead,TDbColumn,pColumn);
			if (pColumn)
			{
				pColumn->GetOutline(poly1);
			}
			OPENOBJ_END();
			OPENOBJ_BEGIN(ent.m_eName,AcDb::kForRead,TDbColumn,pColumn);
			if (pColumn)
			{
				pColumn->GetOutline(poly2);
			}
			OPENOBJ_END();

			return IsIntersect(poly1,poly2);
		}
		return false;
	}

	// 比较门窗是否重叠
	bool CompareOpening(TEntity ent)
	{
		if (IsIntersect(m_ptMin,m_ptMax,ent.m_ptMin,ent.m_ptMax))
		{
			XPoly2D poly1,poly2;
			double elev1(0),elev2(0),height1(0),height2(0);
			OPENOBJ_BEGIN(m_eName,AcDb::kForRead,TDbOpening,pOpening);
			if (pOpening)
			{
				pOpening->GetOutlinePoly(0,poly1);
				elev1 = pOpening->GetSill();
				height1=pOpening->GetHeight();
			}
			OPENOBJ_END();
			OPENOBJ_BEGIN(ent.m_eName,AcDb::kForRead,TDbOpening,pOpening1);
			if (pOpening1)
			{
				pOpening1->GetOutlinePoly(0,poly2);
				elev2 = pOpening1->GetSill();
				height2=pOpening1->GetHeight();
			}
			OPENOBJ_END();

			// 问题描述：无法消除有重叠的弧窗，因为GetOutlinePoly()函数获得的多段线是非闭合的，
			// 在TchSubExport::Intersect()中无法对这样的多段线进行处理
			// 修改描述：强制多段线闭合
			// 修改人，修改时间：Zyu modify on 100707
			poly1.m_nFlag = poly2.m_nFlag = 1;

			if (IsIntersect(poly1,poly2))
			{
				// 考虑高窗
				if (elev1<elev2)
				{
					if (elev1+height1>elev2)
					{
						return true;
					}
				}
				else if (elev1>elev2)
				{
					if (elev1<elev2+height2)
					{
						return true;
					}
				}
				else
				{
					return true;
				}
			}
			return false;
		}
		return false;
	}

	// Zyu add on 101206
	// 获得多段线的全局线宽
	bool GetPLineWidth(TEntitySet &ent, double &dWidth) const
	{
		// 轻量多段线
		if (ent.Is(_T("LWPOLYLINE")))
		{
			return (ent.GetData(43, &dWidth) == RTNORM);
		}
		// 二维多段线
		else if (ent.Is(_T("POLYLINE")))
		{
			// 二维多段线的所有节点的始末线宽均为相同的值时，认为具有全局线宽
			OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDb2dPolyline, pEnt);
			if (NULL == pEnt)
			{
				return false;
			}
			AcDbObjectIterator *pIter = pEnt->vertexIterator();
			bool bFlag = true;
			for (pIter->start(); !pIter->done(); pIter->step())
			{
				OPENOBJ_BEGIN(pIter->objectId(), AcDb::kForRead, AcDb2dVertex, pVertex);
				if (NULL == pVertex)
				{
					delete pIter;
					return false;
				}

				if (bFlag)
				{
					dWidth = pVertex->startWidth();
					bFlag = false;
				}

				if (fabs(dWidth - pVertex->startWidth()) > _DIST_SNAP
					|| fabs(dWidth - pVertex->endWidth()) > _DIST_SNAP)
				{
					delete pIter;
					return false;
				}

				OPENOBJ_END();
			}

			delete pIter;

			OPENOBJ_END();
			return true;
		}
		else
		{
			return false;
		}
	}
	// Zyu add on 100702
	// 比较多段线是否重合
	bool ComparePoly(TEntity ent)
	{
		// 保证是同类型的比较
		if (ent.m_nType != kPoly || m_nType != kPoly)
		{
			return false;
		}

		// 保证只比较全局线宽相同的多段线
		double dWidth = 0.0;
		double dWidthCmp = 0.0;
		if (!GetPLineWidth(m_eName, dWidth)
			|| !GetPLineWidth(ent.m_eName, dWidthCmp))
		{
			return false;
		}
		if (fabs(dWidthCmp - dWidth) > _DIST_SNAP)
		{
			return false;
		}

		TGGePoly3D poly(m_eName);			// 原多段线
		TGGePoly3D polyCmp(ent.m_eName);	// 用于比较的多段线
		AcGePoint3d ptCmp;

		// 调整多段线
		AdjustPoly(poly);
		AdjustPoly(polyCmp);

		int iNumVerts = poly.Length();
		// 两条多段线的节点数不同，或者节点数小于1个，或者闭合类型不一致，认为不相同
		if (iNumVerts != polyCmp.Length()
			|| iNumVerts < 1
			|| poly.m_nFlag != polyCmp.m_nFlag)
		{
			return false;
		}

		int iStart = 0;		// 记录polyCmp里与line起点相同的点的坐标
		double dBulge = 0;
		double dBulgeCmp = 0;

		for (int i = 0; i < iNumVerts; i++)
		{
			dBulge = poly.GetBulge(i);
			dBulgeCmp = polyCmp.GetBulge((i + iStart) % iNumVerts);
			ptCmp = polyCmp.GetPointListAt((i + iStart) % iNumVerts)->AsAcGePoint3d();

			// 比较节点以及凸度是否相同
			if (!IsVertexEqual(poly, ptCmp, i)
				|| ((i + 1 != iNumVerts) && (fabs(dBulge - dBulgeCmp) > _angSnap)))
			{
				// 如果是比较起点，可能多段线的起点不一致，但仍然重合，做进一步判断
				if (0 == i)
				{
					// 对于闭合多段线，找到对应的起点
					if (poly.m_nFlag)
					{
						iStart = -1;
						for (int j = 0; j < iNumVerts; j++)
						{
							ptCmp = polyCmp.GetPointListAt(j)->AsAcGePoint3d();
							dBulgeCmp = polyCmp.GetBulge(j);
							if (IsVertexEqual(poly, ptCmp, i)
								&& (fabs(dBulge - dBulgeCmp) < _angSnap))
							{
								iStart = j;
								break;
							}
						}

						// 找不到对应起点，认为不相同
						if (-1 == iStart)
						{
							return false;
						}
					}
					// 对于非闭合多段线，进行反转
					else
					{
						polyCmp.Reverse();
						ptCmp = polyCmp.GetPointListAt(i)->AsAcGePoint3d();
						dBulgeCmp = polyCmp.GetBulge(i);

						if (!IsVertexEqual(poly, ptCmp, i)
							|| (fabs(dBulge - dBulgeCmp) > _angSnap))
						{
							return false;
						}
					}
				}
				else
				{
					return false;
				}
			}
		}

		return true;
	}
};


//add by xlc on 081230
BOOL IsWallEqual(Entity ent1,Entity ent2)
{
	AcGePoint3d ptStart1,ptEnd1,ptStart2,ptEnd2;			// 墙体起始点
	double dLWidth1,dRWidth1,dLWidth2,dRWidth2;
	OPENOBJ_BEGIN(ent1,AcDb::kForRead,TDbWall,pWall);
	if (pWall)
	{
		pWall->getStartPoint(ptStart1);
		pWall->getEndPoint(ptEnd1);
		dLWidth1=pWall->GetWidth(0);
		dRWidth1=pWall->GetWidth(1);
	}
	OPENOBJ_END();
	OPENOBJ_BEGIN(ent2,AcDb::kForRead,TDbWall,pWall);
	if (pWall)
	{
		pWall->getStartPoint(ptStart2);
		pWall->getEndPoint(ptEnd2);
		dLWidth2=pWall->GetWidth(0);
		dRWidth2=pWall->GetWidth(1);
	}
	OPENOBJ_END();

	if (ptStart1.distanceTo(ptStart2)<_DIST_SNAP
		&&ptEnd1.distanceTo(ptEnd2)<_DIST_SNAP
		&&fabs(dLWidth1-dLWidth2)<_DIST_SNAP
		&&fabs(dRWidth1-dRWidth2)<_DIST_SNAP)
	{
		return TRUE;
	}
	return FALSE;
}
BOOL IsColumnEqual(Entity ent1,Entity ent2)
{
	XPoly2D poly1,poly2;
	OPENOBJ_BEGIN(ent1,AcDb::kForRead,TDbColumn,pEnt);
	if (pEnt)
	{
		pEnt->GetOutline(poly1);
	}
	OPENOBJ_END();
	OPENOBJ_BEGIN(ent2,AcDb::kForRead,TDbColumn,pEnt);
	if (pEnt)
	{
		pEnt->GetOutline(poly2);
	}
	OPENOBJ_END();

	if (poly1.Length()>2
		&&poly2.Length()>2)
	{
		double area1=poly1.PathArea(),area2=poly2.PathArea();
		double area=0;
		DList<XPoly2D> lstPoly2D;
		TchSubExport::Union(poly1, poly2, lstPoly2D); // 求并集
		if (lstPoly2D.Length() > 0)
		{
			area=lstPoly2D[0]->PathArea();
		}

		if (fabs(fabs(area1)+fabs(area2)-fabs(area)*2)<_DIST_SNAP*_DIST_SNAP)
		{
			return TRUE;
		}
	}
	return FALSE;
}

BOOL IsSpaceEqual(Entity ent1,Entity ent2)
{
	XPoly2D poly1,poly2;
	OPENOBJ_BEGIN(ent1,AcDb::kForRead,TDbSpace,pEnt);
	if (pEnt)
	{
		AcGeVector3d normal;
		pEnt->GetPathPoly(poly1,normal);
	}
	OPENOBJ_END();
	OPENOBJ_BEGIN(ent2,AcDb::kForRead,TDbSpace,pEnt);
	if (pEnt)
	{
		AcGeVector3d normal;
		pEnt->GetPathPoly(poly2,normal);
	}
	OPENOBJ_END();

	if (poly1.Length()>2
		&&poly2.Length()>2)
	{
		double area1=poly1.PathArea(),area2=poly2.PathArea();
		double area=0;
		DList<XPoly2D> lstPoly2D;
		TchSubExport::Union(poly1, poly2, lstPoly2D); // 求并集
		if (lstPoly2D.Length() > 0)
		{
			area=lstPoly2D[0]->PathArea();
		}

		if (fabs(fabs(area1)+fabs(area2)-fabs(area)*2)<_DIST_SNAP*_DIST_SNAP)
		{
			return TRUE;
		}
	}
	return FALSE;
}

class TGroup
{
public:
	TGroup (){}
	TGroup (const int nType):m_nType(nType){}
	
	int m_nType;
	Entity m_eEnt1;
	Entity m_eEnt2;
};
class CRemoveDupDlg : public CModelessDialog
{
public:
	CRemoveDupDlg(CWnd* pParent = NULL);   // standard constructor
	//{{AFX_DATA(CRemoveDupDlg)
	enum { IDD = IDD_DIALOG_REMOVEDUP };
	int		m_iFindRange;
	CProgressCtrl	m_ctrlProgress;
	//}}AFX_DATA

	static BOOL bLine;			//是否检查直线
	static BOOL bArc;				//是否检查圆弧
	static BOOL bText;			//是否检查文本
	static BOOL bBlock;			//是否检查图块
	static BOOL bWall;			//是否检查墙体
	static BOOL bCol;				//是否检查柱子
	static BOOL bOpening;			//是否检查门窗
	static BOOL bSpace;			//是否检查房间
	// Zyu add on 100701，添加新的控件关联变量
	static BOOL bPoly;			// 是否检查多段线
	static BOOL bLineLayer;		// 是否只检查同层直线
	static BOOL bPolyLayer;		// 是否只检查同层多段线
	static BOOL bArcLayer;		// 是否只检查同层圆弧
	//{{AFX_VIRTUAL(CRemoveDupDlg)
public:
	virtual BOOL PreTranslateMessage(MSG* pMsg);
protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
	//}}AFX_VIRTUAL

protected:
	// Generated message map functions
	//{{AFX_MSG(CRemoveDupDlg)
	afx_msg void OnButtonBegin();
	afx_msg void OnButtonSelect();
	virtual BOOL OnInitDialog();
	afx_msg void OnSelchangeComboFindrange();
	afx_msg void OnDestroy();
	virtual void OnOK();

	afx_msg void OnBnClickedCheckLine();
	afx_msg void OnBnClickedCheckPline();
	afx_msg void OnBnClickedCheckArc();
	afx_msg void OnBnClickedBtnSelectall();
	afx_msg void OnBnClickedBtnRemoveall();
	afx_msg void OnBnClickedCheckLinelayer();
	afx_msg void OnBnClickedCheckPlinelayer();
	afx_msg void OnBnClickedCheckArclayer();
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()

private:
	void HideDialog(BOOL bFlag);
	CString GetEntType();

public:
	CToolTipCtrl m_wndToolTip;
	PickSet m_ssEnt;


	CArray<TEntity,TEntity> m_textArray;		//文本数组
	CArray<TEntity,TEntity> m_blockArray;		//图块数组
	CArray<TEntity,TEntity> m_wallArray;		//墙体数组
	CArray<TEntity,TEntity> m_spaceArray;		//房间数组
	CArray<TEntity,TEntity> m_openArray;		//门窗数组
	CArray<TEntity,TEntity> m_columnArray;		//柱子数组

	CArray<TGroup,TGroup> m_wallGroup;			//墙体组数组
	CArray<TGroup,TGroup> m_openGroup;			//门窗组数组
	CArray<TGroup,TGroup> m_colGroup;			//柱子组数组
	CArray<TGroup,TGroup> m_spaceGroup;			//房间组数组
};

BOOL CRemoveDupDlg::bLine		= TRUE;
BOOL CRemoveDupDlg::bArc		= TRUE;
BOOL CRemoveDupDlg::bText		= TRUE;
BOOL CRemoveDupDlg::bBlock		= TRUE;
BOOL CRemoveDupDlg::bWall		= TRUE;
BOOL CRemoveDupDlg::bCol		= TRUE;
BOOL CRemoveDupDlg::bOpening	= TRUE;
BOOL CRemoveDupDlg::bSpace		= TRUE;
BOOL CRemoveDupDlg::bPoly		= TRUE;
BOOL CRemoveDupDlg::bLineLayer	= FALSE;
BOOL CRemoveDupDlg::bPolyLayer	= FALSE;
BOOL CRemoveDupDlg::bArcLayer	= FALSE;

CRemoveDupDlg::CRemoveDupDlg(CWnd* pParent /*=NULL*/)
: CModelessDialog(CRemoveDupDlg::IDD, pParent), m_ssEnt(SS_FREE)
{
	//{{AFX_DATA_INIT(CRemoveDupDlg)
	m_iFindRange = 1;

	m_textArray.RemoveAll();
	m_blockArray.RemoveAll();
	m_wallArray.RemoveAll();
	m_spaceArray.RemoveAll();
	m_openArray.RemoveAll();
	m_columnArray.RemoveAll();

	//}}AFX_DATA_INIT
}


void CRemoveDupDlg::DoDataExchange(CDataExchange* pDX)
{
	CModelessDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CRemoveDupDlg)
	DDX_CBIndex(pDX, IDC_COMBO_SEARCH, m_iFindRange);
	DDX_Check(pDX, IDC_CHECK_LINE, bLine);
	DDX_Check(pDX, IDC_CHECK_ARC, bArc);
	DDX_Check(pDX, IDC_CHECK_TEXT, bText);
	DDX_Check(pDX, IDC_CHECK_BLOCK, bBlock);
	DDX_Check(pDX, IDC_CHECK_WALL, bWall);
	DDX_Check(pDX, IDC_CHECK_COL, bCol);
	DDX_Check(pDX, IDC_CHECK_OPENING, bOpening);
	DDX_Check(pDX, IDC_CHECK_SPACE, bSpace);
	DDX_Check(pDX, IDC_CHECK_PLINE, bPoly);
	DDX_Check(pDX, IDC_CHECK_LINELAYER, bLineLayer);
	DDX_Check(pDX, IDC_CHECK_PLINELAYER, bPolyLayer);
	DDX_Check(pDX, IDC_CHECK_ARCLAYER, bArcLayer);
	DDX_Control(pDX, IDC_PROGRESS_CHECK, m_ctrlProgress);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CRemoveDupDlg, CModelessDialog)
	//{{AFX_MSG_MAP(CRemoveDupDlg)
	ON_BN_CLICKED(IDC_BUTTON_BEGIN, OnButtonBegin)
	ON_BN_CLICKED(IDC_BUTTON_PICK, OnButtonSelect)
	ON_CBN_SELCHANGE(IDC_COMBO_SEARCH, OnSelchangeComboFindrange)
	ON_WM_DESTROY()
	ON_BN_CLICKED(IDC_CHECK_LINE, OnBnClickedCheckLine)
	ON_BN_CLICKED(IDC_CHECK_PLINE, OnBnClickedCheckPline)
	ON_BN_CLICKED(IDC_CHECK_ARC, OnBnClickedCheckArc)
	ON_BN_CLICKED(IDC_BTN_SELECTALL, OnBnClickedBtnSelectall)
	ON_BN_CLICKED(IDC_BTN_REMOVEALL, OnBnClickedBtnRemoveall)
	ON_BN_CLICKED(IDC_CHECK_LINELAYER, OnBnClickedCheckLinelayer)
	ON_BN_CLICKED(IDC_CHECK_PLINELAYER, OnBnClickedCheckPlinelayer)
	ON_BN_CLICKED(IDC_CHECK_ARCLAYER, OnBnClickedCheckArclayer)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

void CRemoveDupDlg::OnBnClickedCheckLine()
{
	UpdateData(true);
	GetDlgItem(IDC_CHECK_LINELAYER)->EnableWindow(bLine);
}

void CRemoveDupDlg::OnBnClickedCheckPline()
{
	UpdateData(true);
	GetDlgItem(IDC_CHECK_PLINELAYER)->EnableWindow(bPoly);
}

void CRemoveDupDlg::OnBnClickedCheckArc()
{
	UpdateData(true);
	GetDlgItem(IDC_CHECK_ARCLAYER)->EnableWindow(bArc);
}

void CRemoveDupDlg::OnBnClickedBtnSelectall()
{
	UpdateData(TRUE);

	bLine	= TRUE;
	bPoly	= TRUE;
	bArc	= TRUE;
	bBlock	= TRUE;
	bText	= TRUE;
	bWall	= TRUE;
	bCol	= TRUE;
	bOpening = TRUE;
	bSpace	= TRUE;

	UpdateData(FALSE);

	GetDlgItem(IDC_CHECK_LINELAYER)->EnableWindow();
	GetDlgItem(IDC_CHECK_PLINELAYER)->EnableWindow();
	GetDlgItem(IDC_CHECK_ARCLAYER)->EnableWindow();
}

void CRemoveDupDlg::OnBnClickedBtnRemoveall()
{
	UpdateData(TRUE);

	bLine	= FALSE;
	bPoly	= FALSE;
	bArc	= FALSE;
	bBlock	= FALSE;
	bText	= FALSE;
	bWall	= FALSE;
	bCol	= FALSE;
	bOpening = FALSE;
	bSpace	= FALSE;

	UpdateData(FALSE);

	GetDlgItem(IDC_CHECK_LINELAYER)->EnableWindow(FALSE);
	GetDlgItem(IDC_CHECK_PLINELAYER)->EnableWindow(FALSE);
	GetDlgItem(IDC_CHECK_ARCLAYER)->EnableWindow(FALSE);
}

// Zyu add on 100702
// 消除重合的多段线
int HandlePLineDup(TPickEntSet &ss)
{
	long lLength = ss.Length();
	for (long i = 0; i < lLength; i++)
	{
		TEntity ent(ss[i]);
		// 只对多段线进行处理
		if (ent.m_nType != kPoly)
		{
			continue;
		}

		for (long j = i + 1; j < lLength; j++)
		{
			TEntity entCmp(ss[j]);
			if (ent == entCmp)
			{
				OPENOBJ_BEGIN(entCmp.m_eName, AcDb::kForWrite, AcDbEntity, pEnt);
				if(pEnt)
				{
					pEnt->erase();
					ss -= ss[j];
					j--;
				}
				OPENOBJ_END();
			}
		}
	}

	return RTNORM;
}
  
// Zyu add on 100702
// 消除同图层上的重元（直线、多段线和弧）
int HandleCurveDupSameLayer(TPickEntSet &ss)
{
	int iRetCode = RTNORM;
	TPickEntSet ssKeep(SS_FREE);
	ssKeep += ss;

	ss.Free();
	// 取出选择集中的第一个实体，搜索选择集中与该实体类型和图层相同的所有实体
	while (ssKeep.Length() != 0 && RTNORM == iRetCode)
	{
		// 备份选择集
		TPickEntSet ssTemp(SS_FREE);
		ssTemp += ssKeep;

		// 获得一个实体的属性
		TEntitySet ent = ssTemp[(long)0];
		TCHAR szType[256]=_T("");
		TCHAR szLayer[256]=_T("");
		ent.GetData(0, szType);
		ent.GetData(8, szLayer);

		// 过滤
		ssTemp.BaseFilter(TRBList(ads_buildlist(RTDXF0, szType, 8, szLayer, NULL)));
		ssTemp += ent; 

		ssKeep -= ssTemp;
		// 消除重元
		if (_tcsicmp(szType,_T("LWPOLYLINE")) == 0)
		{
			iRetCode = HandlePLineDup(ssTemp);
		}
		else
		{
			iRetCode = HandleCurveDup(ssTemp);
		}

		ss += ssTemp; 
	}

	return iRetCode;
}
//开始检查
void CRemoveDupDlg::OnButtonBegin() 
{
	if (GetEntType() == _T(""))
	{
		MessageBox(_T("未检查到匹配的重合对象！"));
		return;
	}

	if (m_iFindRange == 1)
	{
		UpdateData();
		CString strType = GetEntType();
		RBList entList(RTDXF0, strType, NULL);
		m_ssEnt.Free();
		if ( m_ssEnt.Get(_T("X"), NULL, NULL, entList ) != RTNORM)
		{
			MessageBox(_T("检查失败!"));
			CModelessDialog::OnOK();
			return;
		}
	}
	if (m_ssEnt.Length() < 1)
	{
		MessageBox(_T("没有检查到对象!"));
		CModelessDialog::OnOK();
		return;
	}

	m_textArray.RemoveAll();
	m_blockArray.RemoveAll();
	m_wallArray.RemoveAll();
	m_spaceArray.RemoveAll();
	m_openArray.RemoveAll();
	m_columnArray.RemoveAll();
	long lCount=m_ssEnt.Length();
	
	// Zyu modify on 100702
	// 对分类进行进一步的划分
	//PickSet ssOther(SS_FREE);
	TPickEntSet ssLine(SS_FREE);	// 直线的选择集
	TPickEntSet ssArc(SS_FREE);		// 圆弧的选择集
	TPickEntSet ssPoly(SS_FREE);	// 多段线的选择集

	for(long i=0L;i<lCount; i++)		//分类
	{
		TEntity ent(m_ssEnt[i]);
		switch(ent.m_nType)
		{
		case kOther:
			// Zyu modify on 100702
			//ssOther += m_ssEnt[i];
			break;
		// Zyu add on 100702，添加对新类型的判断
		// Begin
		case kTLine:
			ssLine += m_ssEnt[i];
			break;
		case kArc:
			ssArc += m_ssEnt[i];
			break;
		case kPoly:
			ssPoly += m_ssEnt[i];
			break;
		// End
		case kText:
			m_textArray.Add(ent);
			break;
		case kBlock:
			m_blockArray.Add(ent);
			break;
		case kWall:
			m_wallArray.Add(ent);
			break;
		case kColumn:
			m_columnArray.Add(ent);
			break;
		case kOpenning:
			m_openArray.Add(ent);
			break;
		case kTSpace:
			m_spaceArray.Add(ent);
			break;
		default:;
		}
	}
	m_ssEnt.Free();//return;

	// Zyu add on 101112，适当放大比较的精度
	TPushMemVar<ads_real> varDistSnap(_DIST_SNAP, _DIST_SNAP * 1.1);
	TPushMemVar<ads_real> varAngSnap(_angSnap, _angSnap * 1.1);

	// Zyu modify on 100702
	// 对直线和圆弧分开处理，同时添加对同图层消重的支持
	// Begin
	//处理线，弧
	//if (bLine || bArc)
	//{
	//	HandleCurveDup(ssOther);
	//	XString strPrompt(_T("\n"));
	//	if(bLine&&bArc)
	//	{
	//		adsout<<_T("\n直线,圆弧已处理完毕!");
	//	}
	//	else if(bLine)
	//	{
	//		adsout<<_T("\n直线已处理完毕!");
	//	}
	//	else
	//	{
	//		adsout<<_T("\n圆弧已处理完毕!");
	//	}
	//}
	CString sPrompt = _T("\n消除");
	if (bLine)
	{
		long lLineNum = ssLine.Length();
		if (bLineLayer)
		{
			// 消除同图层上的重合直线
			HandleCurveDupSameLayer(ssLine);
		}
		else
		{
			// 消除重元
			HandleCurveDup(ssLine);
		}
		CString sTemp;
		sTemp.Format(_T("%d个重合直线,"), lLineNum - ssLine.Length());
		sPrompt += sTemp;
	}
	if (bArc)
	{
		long lArcNum = ssArc.Length();
		if (bArcLayer)
		{
			// 消除同图层上的重合圆弧
			HandleCurveDupSameLayer(ssArc);
		}
		else
		{
			// 消除重元
			HandleCurveDup(ssArc);
		}

		CString sTemp;
		sTemp.Format(_T("%d个重合圆弧,"), lArcNum - ssArc.Length());
		sPrompt += sTemp;
	}

	// 添加对多段线的消重
	if (bPoly)
	{
		long lPlineNum = ssPoly.Length();
		if (bPolyLayer)
		{
			HandleCurveDupSameLayer(ssPoly);
		}
		else
		{
			HandlePLineDup(ssPoly);
		}

		CString sTemp;
		sTemp.Format(_T("%d个重合多段线,"), lPlineNum - ssPoly.Length());
		sPrompt += sTemp;
	}

	// 输出处理结果提示
	if (bLine || bPoly || bArc)
	{
		sPrompt.TrimRight(_T(','));
		sPrompt += _T('!');
		adsout << (LPCTSTR)sPrompt;
	}
	// End

	int nCount=0;
	//处理文本
	if (bText)
	{
		nCount=0;
		for(i=0;i<m_textArray.GetSize();i++)
		{
			for(int j=i+1;j<m_textArray.GetSize();j++)
			{
				if (m_textArray[i] == m_textArray[j])
				{
					OPENOBJ_BEGIN(m_textArray[j].m_eName,AcDb::kForWrite,AcDbEntity,pEnt);
					if (pEnt)
					{
						pEnt->erase();
						m_textArray.RemoveAt(j);
						j--;
						nCount++;
					}
					OPENOBJ_END();
				}
			}
		}

		if (nCount==0)
		{
			adsout<<_T("\n没有发现重合的文本对象!");
		}
		else
		{
			adsout<<_T("\n删除")<<nCount<<_T("个文本对象!");
		}
	}

	//处理图块
	if (bBlock)
	{	
		nCount=0;
		for(i=0;i<m_blockArray.GetSize();i++)
		{
			for(int j=i+1;j<m_blockArray.GetSize();j++)
			{
				if (m_blockArray[i] == m_blockArray[j])
				{
					OPENOBJ_BEGIN(m_blockArray[j].m_eName,AcDb::kForWrite,AcDbEntity,pEnt);
					if (pEnt)
					{
						pEnt->erase();
						m_blockArray.RemoveAt(j);
						j--;
						nCount++;
					}
					OPENOBJ_END();
				}
			}
		}
		if (nCount==0)
		{
			adsout<<_T("\n没有发现重合的图块!");
		}
		else
		{
			adsout<<_T("\n删除")<<nCount<<_T("个图块!");
		}
	}

	// Zyu modify on 100723，消除64位编译警告
	//int count=m_wallArray.GetSize()+m_columnArray.GetSize()+m_openArray.GetSize()+m_spaceArray.GetSize();
	int count=(int)(m_wallArray.GetSize()+m_columnArray.GetSize()+m_openArray.GetSize()+m_spaceArray.GetSize());
	m_ctrlProgress.SetRange( 1, count );
	//处理墙
	if (bWall)
	{
		for(i=0;i<m_wallArray.GetSize();i++)
		{
			m_ctrlProgress.SetPos( i );
			for(int j=i+1;j<m_wallArray.GetSize();j++)
			{
				if (m_wallArray[i] == m_wallArray[j])
				{
					TGroup group(m_wallArray[i].m_nType);
					group.m_eEnt1 = m_wallArray[i].m_eName;
					group.m_eEnt2 = m_wallArray[j].m_eName;
					m_wallGroup.Add(group);
				}
			}
		}
	}
	
	//处理柱子
	if (bCol)
	{
		for(i=0;i<m_columnArray.GetSize();i++)
		{
			// Zyu modify on 100723，消除64位编译警告
			//m_ctrlProgress.SetPos( m_wallArray.GetSize()+i );
			m_ctrlProgress.SetPos( (int)m_wallArray.GetSize()+i );
			for(int j=i+1;j<m_columnArray.GetSize();j++)
			{
				if (m_columnArray[i] == m_columnArray[j])
				{
					TGroup group(m_columnArray[i].m_nType);
					group.m_eEnt1 = m_columnArray[i].m_eName;
					group.m_eEnt2 = m_columnArray[j].m_eName;
					m_colGroup.Add(group);
				}
			}
		}
	}

	//处理门窗
	if (bOpening)
	{
		for(i=0;i<m_openArray.GetSize();i++)
		{
			// Zyu modify on 100723，消除64位编译警告
			//m_ctrlProgress.SetPos( m_wallArray.GetSize()+m_columnArray.GetSize()+i );
			m_ctrlProgress.SetPos((int)(m_wallArray.GetSize()+m_columnArray.GetSize()+i));
			for(int j=i+1;j<m_openArray.GetSize();j++)
			{
				if (m_openArray[i] == m_openArray[j])
				{
					TGroup group(m_openArray[i].m_nType);
					group.m_eEnt1 = m_openArray[i].m_eName;
					group.m_eEnt2 = m_openArray[j].m_eName;
					m_openGroup.Add(group);
				}
			}
		}
	}

	//处理房间
	if (bSpace)
	{
		for(i=0;i<m_spaceArray.GetSize();i++)
		{
			// Zyu modify on 100723，消除64位编译警告
			//m_ctrlProgress.SetPos(m_wallArray.GetSize()+m_columnArray.GetSize()+m_openArray.GetSize()+ i );
			m_ctrlProgress.SetPos((int)(m_wallArray.GetSize()+m_columnArray.GetSize()+m_openArray.GetSize()+ i));
			for(int j=i+1;j<m_spaceArray.GetSize();j++)
			{
				if (m_spaceArray[i] == m_spaceArray[j])
				{
					TGroup group(m_spaceArray[i].m_nType);
					group.m_eEnt1 = m_spaceArray[i].m_eName;
					group.m_eEnt2 = m_spaceArray[j].m_eName;
					m_spaceGroup.Add(group);
				}
			}
		}
	}

	// Zyu modify on 100723，消除64位编译警告
	//int num=m_wallGroup.GetSize()+m_openGroup.GetSize()+m_spaceGroup.GetSize()+m_colGroup.GetSize();
	int num = (int)(m_wallGroup.GetSize()+m_openGroup.GetSize()+m_spaceGroup.GetSize()+m_colGroup.GetSize());
	if (num < 1)
	{
		if (bWall ||bOpening||bCol||bSpace)
		{
			adsout << _T("\n没有检查到重合的");
			if (bWall)
			{
				adsout << _T("墙体"); 
			}
			if (bOpening)
			{
				if (bWall)
				{
					adsout << _T(","); 
				}
				adsout << _T("门窗"); 
			}
			if (bCol)
			{
				if (bWall ||bOpening)
				{
					adsout << _T(","); 
				}
				adsout << _T("柱子"); 
			}
			if (bSpace)
			{
				if (bWall ||bOpening||bCol)
				{
					adsout << _T(","); 
				}
				adsout << _T("房间"); 
			}

			adsout << _T("!"); 
		}
		else
		{
			adsout<<_T("\n检查完毕!");
		}
		
		OnOK();
		return;
	}

	OnOK();
}

//选择图元
void CRemoveDupDlg::OnButtonSelect() 
{
	UpdateData(TRUE);
	HideDialog(TRUE);

	const TCHAR *szPrompt[2]={_T("请选择需要消重图元的区域的范围:"), _T("移除物体")};
//	RBList entList(RTDXF0, GetEntType(), NULL);
	RBList entList; // 
	m_ssEnt.Free();//_T("请选择需要消重图元的区域的范围:")
	if (m_ssEnt.Get(_T(":$"),szPrompt , NULL, entList) == RTNORM)
	{
		m_iFindRange = 0;
	}
	HideDialog(FALSE);
	UpdateData(FALSE);
}

CString CRemoveDupDlg::GetEntType()
{
	UpdateData(TRUE);
	// Zyu modify on 100701
	// 添加多段线的选项
	//CString strLine(_T("LINE,")),strArc(_T("ARC,CIRCLE,")),
	CString strLine(_T("LINE,")),strPLine(_T("LWPOLYLINE,POLYLINE,")),strArc(_T("ARC,CIRCLE,")),
		strBlock(_T("INSERT,TCH_BLOCK_INSERT,TCH_MVINSERT,")),
		strWall(_T("TCH_WALL,TCH_CURTAIN_WALL,")),strSpace(_T("TCH_SPACE,")),
		strColumn(_T("TCH_COLUMN,")),strOpening(_T("TCH_OPENING,")),
		strText(_T("TCH_TEXT,TCH_MTEXT,TEXT,MTEXT,"));
	CString strType;
	if (bLine)
		strType += strLine;
	// Zyu add on 100701
	// 添加多段线的选项
	if(bPoly)
		strType += strPLine;
	if (bArc)
		strType += strArc;
	if (bBlock)
		strType += strBlock;
	if (bText)
		strType += strText;
	if (bWall)
		strType += strWall;
	if (bCol)
		strType += strColumn;
	if (bOpening)
		strType += strOpening;
	if (bSpace)
		strType += strSpace;

	return strType;
}

BOOL CRemoveDupDlg::OnInitDialog() 
{
	CModelessDialog::OnInitDialog();

	// Zyu modify on 100701
	// 取消加载“选择对象”按钮的位图
	/*
	//加载“选择对象”按钮的位图
	CBitmap  bitmap;
	bitmap.LoadBitmap(IDB_BITMAP_SELECT);
	CButton *pButton = (CButton *)GetDlgItem(IDC_BUTTON_PICK);
	pButton->SetBitmap((HBITMAP)bitmap);
	bitmap.Detach();
	*/
	CButton *pButton = (CButton *)GetDlgItem(IDC_BUTTON_PICK);

	// Zyu add on 100702，设置初始状态
	GetDlgItem(IDC_CHECK_LINELAYER)->EnableWindow(bLine);
	GetDlgItem(IDC_CHECK_PLINELAYER)->EnableWindow(bPoly);
	GetDlgItem(IDC_CHECK_ARCLAYER)->EnableWindow(bArc);
	OnBnClickedCheckLinelayer();
	OnBnClickedCheckPlinelayer();
	OnBnClickedCheckArclayer();

	m_ctrlProgress.SetRange( 0, 100 );
	m_ctrlProgress.SetPos(0);
	if (!m_wndToolTip.Create(pButton))
	{
		return FALSE;
	}
	m_wndToolTip.AddTool(pButton, _T("选取对象"));

	UpdateData(FALSE);
	return TRUE;  
}

//选择了查找范围后，重新构造图元选择集
void CRemoveDupDlg::OnSelchangeComboFindrange() 
{
	UpdateData(TRUE);
	if ( m_iFindRange == 0 )	
	{
		//modify by xlc on 090313 R17平台崩溃
#if ADS<17
		OnButtonSelect();
#endif
	}
}


//隐藏或者显示对话框
void CRemoveDupDlg::HideDialog(BOOL bFlag)
{
	if (bFlag) {
		GetParent()->EnableWindow(TRUE);
		GetParent()->SetFocus();
		GetParent()->SetActiveWindow();
		ShowWindow(SW_HIDE);
		GetParent()->RedrawWindow();
	}
	else {
		GetParent()->EnableWindow(FALSE);
		EnableWindow(TRUE);
		SetActiveWindow();
		ShowWindow(SW_SHOW);
		GetParent()->EnableWindow(TRUE);
	}
}

BOOL CRemoveDupDlg::PreTranslateMessage(MSG* pMsg) 
{
	m_wndToolTip.RelayEvent(pMsg);
	return CModelessDialog::PreTranslateMessage(pMsg);
}

void CRemoveDupDlg::OnDestroy() 
{
	m_wndToolTip.DestroyWindow();

	CModelessDialog::OnDestroy();
}


void CRemoveDupDlg::OnOK() 
{
	CModelessDialog::OnOK();
}

class CRemoveDupPromptDlg : public CModelessDialog
{
public:
	CRemoveDupPromptDlg(CWnd* pParent = NULL);   // standard constructor
	//{{AFX_DATA(CRemoveDupPromptDlg)
	enum { IDD = IDD_DIALOG_REMOVEDUP_PROM };
	int m_nWall;					//墙体组数目
	int	m_nOpen;					//门窗组数目
	int	m_nCol;						//柱子组数目
	int	m_nSpace;					//房间组数目
	CString m_strWall;				//墙体提示
	CString m_strOpen;				//门窗提示
	CString m_strCol;				//柱子提示
	CString m_strSpace;				//房间提示
	//}}AFX_DATA
	
	static BOOL bAutoZoom;

	void ShowButton(BOOL bShow);
	void EnableButton(BOOL bEnable,BOOL bDelEnable);
	//{{AFX_VIRTUAL(CRemoveDupPromptDlg)

protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
	//}}AFX_VIRTUAL

protected:
	// Generated message map functions
	//{{AFX_MSG(CRemoveDupPromptDlg)
	virtual BOOL OnInitDialog();
	afx_msg void OnButtonPre();
	afx_msg void OnButtonNext();
	afx_msg void OnButtonSwitch();
	afx_msg void OnButtonMark();
	afx_msg void OnButtonDelRed();
	afx_msg void OnButtonDelYellow();
	afx_msg void OnButtonBreak();
	afx_msg void OnClose();
	afx_msg void OnButtonZoom();
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()

private:
	int m_nCurPos;
};

BOOL CRemoveDupPromptDlg::bAutoZoom=TRUE;
void CRemoveDupPromptDlg::DoDataExchange(CDataExchange* pDX)
{
	CModelessDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CRemoveDupPromptDlg)
	DDX_Text(pDX, IDC_EDIT_WALL, m_nWall);
	DDX_Text(pDX, IDC_EDIT_OPEN, m_nOpen);
	DDX_Text(pDX, IDC_EDIT_COL, m_nCol);
	DDX_Text(pDX, IDC_EDIT_SPACE, m_nSpace);
	DDX_Text(pDX, IDC_STATIC_WALL, m_strWall);
	DDX_Text(pDX, IDC_STATIC_OPEN, m_strOpen);
	DDX_Text(pDX, IDC_STATIC_COL, m_strCol);
	DDX_Text(pDX, IDC_STATIC_SPACE, m_strSpace);

	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CRemoveDupPromptDlg, CModelessDialog)
	//{{AFX_MSG_MAP(CRemoveDupPromptDlg)

	ON_BN_CLICKED(IDC_BUTTON_PRE, OnButtonPre)
	ON_BN_CLICKED(IDC_BUTTON_CHG, OnButtonSwitch)
	ON_BN_CLICKED(IDC_BUTTON_NEXT, OnButtonNext)
	ON_BN_CLICKED(IDC_BUTTON_MARK, OnButtonMark)
	ON_BN_CLICKED(IDC_BUTTON_DELR, OnButtonDelRed)
	ON_BN_CLICKED(IDC_BUTTON_DELY, OnButtonDelYellow)
	ON_BN_CLICKED(IDC_BUTTON_BREAK, OnButtonBreak)
	ON_BN_CLICKED(IDC_BUTTON_ZOOM, OnButtonZoom)
	ON_WM_CLOSE()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


CRemoveDupPromptDlg::CRemoveDupPromptDlg(CWnd* pParent /*=NULL*/)
: CModelessDialog(CRemoveDupPromptDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CRemoveDupPromptDlg)
	m_nCurPos = 0;
	m_nWall	  = 0;
	m_nOpen	  = 0;
	m_nCol	  = 0;
	m_nSpace  = 0;

	m_strWall = _T("");
	m_strOpen = _T("");
	m_strCol  = _T("");
	m_strSpace= _T("");

	//}}AFX_DATA_INIT
}

BOOL CRemoveDupPromptDlg::OnInitDialog() 
{
	CModelessDialog::OnInitDialog();
	if (bAutoZoom)
	{
		GetDlgItem(IDC_BUTTON_ZOOM)->SetWindowText(_T("关闭缩放"));
	}
	else
	{
		GetDlgItem(IDC_BUTTON_ZOOM)->SetWindowText(_T("自动缩放"));
	}	
	return TRUE;  
}

// 关闭
void CRemoveDupPromptDlg::OnClose() 
{
	CModelessDialog::OnClose();
	acedPostCommand(_T("\n"));
}

//向上
void CRemoveDupPromptDlg::OnButtonPre()
{
	acedPostCommand(_T("W "));
}

//向下
void CRemoveDupPromptDlg::OnButtonNext()
{
	acedPostCommand(_T("Q "));	
}
void CRemoveDupPromptDlg::OnButtonSwitch()
{
	acedPostCommand(_T("Z "));
}
// 添加标记
void CRemoveDupPromptDlg::OnButtonMark()
{
	acedPostCommand(_T("A "));
}
// 删除红色
void CRemoveDupPromptDlg::OnButtonDelYellow()
{
	acedPostCommand(_T("E "));
}
// 删除红色
void CRemoveDupPromptDlg::OnButtonDelRed()
{
	acedPostCommand(_T("R "));
}
// 打断
void CRemoveDupPromptDlg::OnButtonBreak()
{
	acedPostCommand(_T("S "));
}
// 显示按钮
void CRemoveDupPromptDlg::ShowButton(BOOL bShow)
{
	GetDlgItem(IDC_BUTTON_BREAK)->EnableWindow(bShow);
}
// 自动缩放
void CRemoveDupPromptDlg::OnButtonZoom()
{
	bAutoZoom = !bAutoZoom;
	if (bAutoZoom)
	{
		GetDlgItem(IDC_BUTTON_ZOOM)->SetWindowText(_T("关闭缩放"));
	}
	else
	{
		GetDlgItem(IDC_BUTTON_ZOOM)->SetWindowText(_T("自动缩放"));
	}	
}

void CRemoveDupDlg::OnBnClickedCheckLinelayer()
{
	UpdateData(TRUE);

	if (bLineLayer)
	{
		SetDlgItemText(IDC_CHECK_LINELAYER, _T("√同图层"));
	}
	else
	{
		SetDlgItemText(IDC_CHECK_LINELAYER, _T("×同图层"));
	}
}

void CRemoveDupDlg::OnBnClickedCheckPlinelayer()
{
	UpdateData(TRUE);

	if (bPolyLayer)
	{
		SetDlgItemText(IDC_CHECK_PLINELAYER, _T("√同图层"));
	}
	else
	{
		SetDlgItemText(IDC_CHECK_PLINELAYER, _T("×同图层"));
	}
}

void CRemoveDupDlg::OnBnClickedCheckArclayer()
{
	UpdateData(TRUE);

	if (bArcLayer)
	{
		SetDlgItemText(IDC_CHECK_ARCLAYER, _T("√同图层"));
	}
	else
	{
		SetDlgItemText(IDC_CHECK_ARCLAYER, _T("×同图层"));
	}
}

// add by xlc on 080814
// 禁用按钮
void CRemoveDupPromptDlg::EnableButton(BOOL bEnable,BOOL bDelEnable)
{
	//GetDlgItem(IDC_BUTTON_BREAK)->EnableWindow(bEnable&&bDelEnable);
	GetDlgItem(IDC_BUTTON_CHG)->EnableWindow(bEnable&&bDelEnable);
	GetDlgItem(IDC_BUTTON_DELR)->EnableWindow(bEnable&&bDelEnable);
	GetDlgItem(IDC_BUTTON_DELY)->EnableWindow(bEnable&&bDelEnable);
	GetDlgItem(IDC_BUTTON_MARK)->EnableWindow(bDelEnable);
	if (bEnable)
		GetDlgItem(IDC_BUTTON_MARK)->SetWindowText(_T("添加标记"));
	else
		GetDlgItem(IDC_BUTTON_MARK)->SetWindowText(_T("撤销标记"));
}


PickSet g_ssShow;					//添加的显示对象
CArray<TGroup,TGroup> g_wallGroup;	//墙体组数组
CArray<TGroup,TGroup> g_openGroup;	//门窗组数组
CArray<TGroup,TGroup> g_colGroup;	//柱子组数组
CArray<TGroup,TGroup> g_spaceGroup;	//房间组数组
// Zyu add on 101222，记录删除过的实体数量
int g_nWallDup(0);		// 删除的墙体的数量
int g_nOpenDup(0);		// 删除的门窗的数量
int g_nColDup(0);		// 删除的柱子的数量
int g_nSpaceDup(0);		// 删除的房间的数量

int nOldColorIndex1(256),nOldColorIndex2(256);//修改前对象的颜色

void ShowCurGroup(TGroup &curGroup,BOOL bRed,BOOL bAutoZoom);
void MakePoly(XPoly2D &poly,BOOL bRed,TGroup &curGroup);


// 释放资源
void Release()
{
	g_ssShow.Erase();
	g_ssShow.Free();
	g_wallGroup.RemoveAll();
	g_openGroup.RemoveAll();
	g_colGroup.RemoveAll();
	g_spaceGroup.RemoveAll();
}
// 切换显示
void SwitchEntColor(TGroup &curGroup,	//[in]当前组
					BOOL bRed,			//[in]是否切换
					BOOL bAutoZoom		//[in]是否自动缩放
			  )
{
	ShowCurGroup(curGroup,bRed,bAutoZoom);
}
// 添加标记
void AddMark(int nCurPos,		//[in]当前位置
			 TGroup &curGroup	//[in]当前组
			 )
{
	if (nCurPos < 0)
		return;

	CString msg;
	if (curGroup.m_nType == kWall)
	{
		msg = _T("重叠的墙体");
	}
	else if (curGroup.m_nType == kColumn)
	{
		msg = _T("重叠的柱子");
	}
	else if (curGroup.m_nType == kOpenning)
	{
		msg = _T("重叠的门窗");
	}
	else if (curGroup.m_nType == kTSpace)
	{
		msg = _T("重叠的房间");
	}
	else
	{
		return;
	}

	//二维平面下的包围盒
	int nOldMode=DocGetDrawMode();
	DocSetDrawMode(DRAW_2D);
	XPoint ptLow,ptUp;
 	PickSet ss(SS_FREE);
 	ss += curGroup.m_eEnt1;
 	ss += curGroup.m_eEnt2;
	ss.GetExtend(ptLow,ptUp);
	DocSetDrawMode(nOldMode);

	ErrorPosition1(ptLow,ptUp,msg);			//添加标记
}
// 获得组内实体的颜色
void GetGroupEntColor(TGroup group,			//[in]当前组
					  int &nColorIndex1,	//[out]第一个实体颜色
					  int &nColorIndex2		//[out]第二个实体颜色
					  )
{
	OPENOBJ_BEGIN(group.m_eEnt1, AcDb::kForRead, AcDbEntity, pEnt);
	if (pEnt) 
	{
		nColorIndex1 = pEnt->colorIndex();

	}
	OPENOBJ_END();
	OPENOBJ_BEGIN(group.m_eEnt2, AcDb::kForRead, AcDbEntity, pEnt);
	if (pEnt) 
	{
		nColorIndex2 = pEnt->colorIndex();

	}
	OPENOBJ_END();
}
// 设置组内实体的颜色
void SetGroupEntColor(TGroup group,			//[in]当前组
					  int nColorIndex1,		//[in]第一个实体颜色
					  int nColorIndex2		//[in]第二个实体颜色
					  )
{
	OPENOBJ_BEGIN(group.m_eEnt1, AcDb::kForWrite, AcDbEntity, pEnt);
	if (pEnt) 
	{
		pEnt->setColorIndex(nColorIndex1);
	}
	OPENOBJ_END();
	OPENOBJ_BEGIN(group.m_eEnt2, AcDb::kForWrite, AcDbEntity, pEnt);
	if (pEnt) 
	{
		pEnt->setColorIndex(nColorIndex2);
	}
	OPENOBJ_END();
	
	//刷新
	//acedRedraw(NULL,1);
	actrTransactionManager->flushGraphics();
	acedUpdateDisplay();
}

// 显示当前组
void ShowCurGroup(TGroup &curGroup,		//[in]当前组
				  BOOL bChange,			//[in]是否切换显示
				  BOOL bAutoZoom		//[in]是否自动缩放
				  )
{
	XPoly2D poly1,poly2;
	int count=0;
	switch(curGroup.m_nType)
	{
	case kWall:
		{
			OPENOBJ_BEGIN(curGroup.m_eEnt1 ,AcDb::kForRead,TDbWall,pEnt);
			if (pEnt)
			{
				pEnt->GetOutlinePoly(0,poly1,TRUE);
				count++;
			}
			OPENOBJ_END();
			OPENOBJ_BEGIN(curGroup.m_eEnt2,AcDb::kForRead,TDbWall,pEnt);
			if (pEnt)
			{
				pEnt->GetOutlinePoly(0,poly2,TRUE);
				count++;
			}
			OPENOBJ_END();
		}
		break;
	case kColumn:
		{
			OPENOBJ_BEGIN(curGroup.m_eEnt1,AcDb::kForRead,TDbColumn,pEnt);
			if (pEnt)
			{
				pEnt->GetOutline(poly1);
				count++;
			}
			OPENOBJ_END();
			OPENOBJ_BEGIN(curGroup.m_eEnt2,AcDb::kForRead,TDbColumn,pEnt);
			if (pEnt)
			{
				pEnt->GetOutline(poly2);
				count++;
			}
			OPENOBJ_END();
		}
		break;
	case kOpenning:
		{
			OPENOBJ_BEGIN(curGroup.m_eEnt1,AcDb::kForRead,TDbOpening,pEnt);
			if (pEnt)
			{
				pEnt->GetOutlinePoly(0,poly1);
				// 问题描述：GetOutlinePoly()函数获得的弧墙的包围盒多段线是非闭合的
				// 修改描述：强制多段线闭合
				// 修改人，修改时间：Zyu modify on 100707
				poly1.m_nFlag = 1;

				count++;
			}
			OPENOBJ_END();
			OPENOBJ_BEGIN(curGroup.m_eEnt2,AcDb::kForRead,TDbOpening,pEnt);
			if (pEnt)
			{
				pEnt->GetOutlinePoly(0,poly2);
				// 修改人，修改时间：Zyu modify on 100707
				poly2.m_nFlag = 1;

				count++;
			}
			OPENOBJ_END();
		}
		break;
	case kTSpace:
		{
			OPENOBJ_BEGIN(curGroup.m_eEnt1,AcDb::kForRead,TDbSpace,pEnt);
			if (pEnt)
			{
				AcGeVector3d normal;
				pEnt->GetPathPoly(poly1,normal);
				count++;
			}
			OPENOBJ_END();
			OPENOBJ_BEGIN(curGroup.m_eEnt2,AcDb::kForRead,TDbSpace,pEnt);
			if (pEnt)
			{
				AcGeVector3d normal;
				pEnt->GetPathPoly(poly2,normal);
				count++;
			}
			OPENOBJ_END();
		}
		break;
	default:;
	}

	if (count==2)
	{
		if (bAutoZoom)		//自动缩放
		{
			int nOldMode=DocGetDrawMode();
			DocSetDrawMode(DRAW_2D);

			XPoint ptLow,ptUp;
			if (curGroup.m_nType == kTSpace)
			{
				poly1.GetExtend(ptLow,ptUp);
				XPoly2D poly;
				poly.AppendNode(ptLow);
				poly.AppendNode(ptUp);
				poly2.GetExtend(ptLow,ptUp);
				poly.AppendNode(ptLow);
				poly.AppendNode(ptUp);
				poly.GetExtend(ptLow,ptUp);
			}
			else
			{
				PickSet ss(SS_FREE);
				ss += curGroup.m_eEnt1;
				ss += curGroup.m_eEnt2;
				ss.GetExtend(ptLow,ptUp);
			}
			XVector3D vect = ptUp-ptLow;
			ptLow[0] = ptLow[0]-vect[0]*0.5;
			ptLow[1] = ptLow[1]-vect[1]*0.5;
			ptUp[0]=ptUp[0]+vect[0]*0.5;
			ptUp[1]=ptUp[1]+vect[1]*0.5;
			arxZoom(ptLow,ptUp);

			DocSetDrawMode(nOldMode);
		}
	
		g_ssShow.Erase();
		g_ssShow.Free();
		g_ssShow.IncludeBegin();
		
		double width(20.0);
		XPoly2D poly2D1(1),poly2D2(1);
		poly1.Offset(width,poly2D1);
		poly2.Offset(-width,poly2D2);
		if (bChange)
		{
			SetGroupEntColor(curGroup,1,2);
			MakePoly(poly2D1,TRUE,curGroup);
			MakePoly(poly2D2,FALSE,curGroup);
		}
		else
		{
			SetGroupEntColor(curGroup,2,1);
			MakePoly(poly2D2,TRUE,curGroup);
			MakePoly(poly2D1,FALSE,curGroup);
		}

		g_ssShow.IncludeEnd();

	}
}
//画线
void MakePoly(XPoly2D &poly,		//[in]显示对象
			  BOOL bRed,			//[in]是否红色
			  TGroup &curGroup		//[in]当前组
			  )
{
	double width(40.0);
	int colorIndex=2;
	if (bRed)
	{
		colorIndex = 1;
	}

	AcDbCurve *pCurve=poly.AsAcDbCurve();
	((AcDbPolyline*)pCurve)->setConstantWidth(width);

	pCurve->setColorIndex(colorIndex);		//设置颜色


	AddToModelSpace(pCurve, Adesk::kTrue);
	
	//del by xlc on 090527 房间填充不易观察
	//if (curGroup.m_nType == kTSpace)
	//{
	//	XPoly2D poly1(poly);
	//	AcDbHatch *pHatch = NewHatchFromPoly2D(poly1,_T("SOLID"),0.1);
	//	if (pHatch)
	//	{
	//		pHatch->setColorIndex(colorIndex);
	//		AddToModelSpace(pHatch, Adesk::kTrue);
	//	}
	//}
}
//获得当前组
void GetCurGroup( int nCurPos,			//[in]当前位置
				 TGroup &curGroup		//[out]当前组
				 )
{
	// Zyu modify on 100722，支持64位
	//int nWall(0),nOpening(0),nColumn(0),nSpace(0);
	INT_PTR nWall(0),nOpening(0),nColumn(0),nSpace(0);

	nWall = g_wallGroup.GetSize();
	nOpening = g_openGroup.GetSize();
	nColumn = g_colGroup.GetSize();
	nSpace = g_spaceGroup.GetSize();

	curGroup.m_nType = -1;
	
	if (nWall > 0 && (nWall > nCurPos))
	{
		curGroup.m_nType = g_wallGroup[nCurPos].m_nType;
		curGroup.m_eEnt1 = g_wallGroup[nCurPos].m_eEnt1;
		curGroup.m_eEnt2 = g_wallGroup[nCurPos].m_eEnt2;
	}
	else if (nOpening > 0 && ((nOpening+nWall)  > nCurPos))
	{
		curGroup.m_nType =g_openGroup[nCurPos-nWall].m_nType;
		curGroup.m_eEnt1 = g_openGroup[nCurPos-nWall].m_eEnt1;
		curGroup.m_eEnt2 = g_openGroup[nCurPos-nWall].m_eEnt2;
	}
	else if (nColumn > 0 && ((nColumn +nOpening+nWall)  > nCurPos))
	{
		curGroup.m_nType =g_colGroup[nCurPos-nWall-nOpening].m_nType;
		curGroup.m_eEnt1 = g_colGroup[nCurPos-nWall-nOpening].m_eEnt1;
		curGroup.m_eEnt2 = g_colGroup[nCurPos-nWall-nOpening].m_eEnt2;
	}
	else if (nSpace > 0 && ((nSpace + nColumn +nOpening+nWall)  > nCurPos))
	{
		curGroup.m_nType =g_spaceGroup[nCurPos-nWall-nOpening-nColumn].m_nType;
		curGroup.m_eEnt1 = g_spaceGroup[nCurPos-nWall-nOpening-nColumn].m_eEnt1;
		curGroup.m_eEnt2 = g_spaceGroup[nCurPos-nWall-nOpening-nColumn].m_eEnt2;
	}
}
//向上
void ShowPre(int &nCurPos,			//[in/out]当前位置
			 TGroup &curGroup,		//[in/out]当前组
			 BOOL bChange,			//[in]是否切换
			 BOOL bAutoZoom			//[in]是否自动缩放
			 )
{
	// Zyu modify on 100722，支持64位
	//int nWall(0),nOpening(0),nColumn(0),nSpace(0);
	INT_PTR nWall(0),nOpening(0),nColumn(0),nSpace(0);

	nWall = g_wallGroup.GetSize();
	nOpening = g_openGroup.GetSize();
	nColumn = g_colGroup.GetSize();
	nSpace = g_spaceGroup.GetSize();

	// Zyu modify on 100722，支持64位
	//int num=nWall+nOpening+nColumn+nSpace;
	INT_PTR num=nWall+nOpening+nColumn+nSpace;
	if ( num > 0 && nCurPos < num && nCurPos > 0)
	{
		nCurPos--;
	}
	else if ( num > 0 && nCurPos == 0)
	{
		// Zyu modify on 100723，消除64位编译警告
		//nCurPos = num-1;
		nCurPos = (int)num-1;
	}
	else
	{
		return;
	}
	SetGroupEntColor(curGroup,nOldColorIndex1,nOldColorIndex2);
	GetCurGroup(nCurPos,curGroup);
	if (curGroup.m_nType != kNull)
	{
		GetGroupEntColor(curGroup,nOldColorIndex1,nOldColorIndex2);
	}
	ShowCurGroup(curGroup,bChange,bAutoZoom);
}



//向下
void ShowNext(int &nCurPos,			//[in/out]当前位置
			  TGroup &curGroup,		//[in/out]当前组
			  BOOL bChange,			//[in]是否切换
			  BOOL bAutoZoom		//[in]是否自动缩放
			  )
{
	// Zyu modify on 100722，支持64位
	//int nWall(0),nOpening(0),nColumn(0),nSpace(0);
	INT_PTR nWall(0),nOpening(0),nColumn(0),nSpace(0);

	nWall = g_wallGroup.GetSize();
	nOpening = g_openGroup.GetSize();
	nColumn = g_colGroup.GetSize();
	nSpace = g_spaceGroup.GetSize();

	// Zyu modify on 100722，支持64位
	//int num=nWall+nOpening+nColumn+nSpace;
	INT_PTR num=nWall+nOpening+nColumn+nSpace;
	if ( num > 0 && nCurPos < num)
	{
		if (nCurPos == num-1)
		{
			nCurPos=0;
		}
		else
		{
			nCurPos++;
		}
	}
	else
	{
		return;
	}

	SetGroupEntColor(curGroup,nOldColorIndex1,nOldColorIndex2);
	GetCurGroup(nCurPos,curGroup);
	if (curGroup.m_nType != kNull)
	{
		GetGroupEntColor(curGroup,nOldColorIndex1,nOldColorIndex2);
	}
	ShowCurGroup(curGroup,bChange,bAutoZoom);
}
// 判断墙是否平行
BOOL IsWallParalle(Entity ent1,		//[in]实体１
				   Entity ent2		//[in]实体２
				   )
{
	AcGeVector3d dir1,dir2;
	BOOL bArcWall1=FALSE,bArcWall2=FALSE;
	XPoint ptCen1,ptCen2;
	OPENOBJ_BEGIN(ent1, AcDb::kForRead, TDbWall, pWall);
	if (pWall) 
	{
		bArcWall1=pWall->Is(CURVE_ARC);
		dir1 = pWall->Direction3d();
		ptCen1 = pWall->GetArc().GetCenterPt();
	}
	else
		return FALSE;
	OPENOBJ_END();

	OPENOBJ_BEGIN(ent2, AcDb::kForRead, TDbWall, pWall);
	if (pWall) 
	{
		bArcWall2=pWall->Is(CURVE_ARC);
		dir2 = pWall->Direction3d();
		ptCen2 = pWall->GetArc().GetCenterPt();
	}
	else
		return FALSE;
	OPENOBJ_END();

	if (!bArcWall1 && !bArcWall2)
	{
		return dir1.isParallelTo(dir2);
	}
	else if (bArcWall1 && bArcWall2)
	{
		return (ptCen1.AsAcGePoint3d()).isEqualTo(ptCen2.AsAcGePoint3d());
	}
	else
	{
		return FALSE;
	}

	return FALSE;
}

//删除对象
void DeleteEnt(int &nCurPos,		//[in/out]当前位置
			   BOOL bFirst,			//[in]是否第一个对象
			   TGroup curGroup		//[in]当前组
			   )
{
	int type = curGroup.m_nType;

	Entity ent;
	if (bFirst)
	{
		ent = curGroup.m_eEnt1;
	}
	else
	{
		ent = curGroup.m_eEnt2;
	}

	switch(type)
	{
	case kWall:
		{
			for(int i=0;i<g_wallGroup.GetSize();)
			{
				if (g_wallGroup.GetAt(i).m_eEnt1 == ent
				||g_wallGroup.GetAt(i).m_eEnt2 == ent)
				{
					g_wallGroup.RemoveAt(i);
					if (i < nCurPos)
					{
						nCurPos--;
					}
					continue;
				}
				i++;
			}
			// Zyu add on 101222，计数增加
			g_nWallDup++;
		}
		break;
	case kOpenning:
		{
			// Zyu modify on 100722，支持64位
			//int num = g_wallGroup.GetSize();
			INT_PTR num = g_wallGroup.GetSize();
			for(int i=0;i<g_openGroup.GetSize();)
			{
				if (g_openGroup.ElementAt(i).m_eEnt1 == ent
				||g_openGroup.ElementAt(i).m_eEnt2 == ent)
				{
					g_openGroup.RemoveAt(i);
					if (i+num < nCurPos)
					{
						nCurPos--;
					}
					continue;
				}
				i++;
			}
			// Zyu add on 101222，计数增加
			g_nOpenDup++;
		}
		
		break;
	case kColumn:
		{
			// Zyu modify on 100722，支持64位
			//int num = g_wallGroup.GetSize()+g_openGroup.GetSize();
			INT_PTR num = g_wallGroup.GetSize()+g_openGroup.GetSize();
			for(int i=0;i<g_colGroup.GetSize();)
			{
				if (g_colGroup.ElementAt(i).m_eEnt1 == ent
				||g_colGroup.ElementAt(i).m_eEnt2 == ent)
				{
					g_colGroup.RemoveAt(i);
					if (i+num < nCurPos)
					{
						nCurPos--;
					}

					continue;
				}
				i++;
			}
			// Zyu add on 101222，计数增加
			g_nColDup++;
		}
		break;
	case kTSpace:
		{
			// Zyu modify on 100722，支持64位
			//int num = g_wallGroup.GetSize()+g_openGroup.GetSize()+g_colGroup.GetSize();
			INT_PTR num = g_wallGroup.GetSize()+g_openGroup.GetSize()+g_colGroup.GetSize();
			for(int i=0;i<g_spaceGroup.GetSize();)
			{
				if (g_spaceGroup.ElementAt(i).m_eEnt1 == ent
				||g_spaceGroup.ElementAt(i).m_eEnt2 == ent)
				{
					g_spaceGroup.RemoveAt(i);
					if (i+num < nCurPos)
					{
						nCurPos--;
					}

					continue;
				}
				i++;
			}
			// Zyu add on 101222，计数增加
			g_nSpaceDup++;
		}
		break;
	default:;
	}
	
	BOOL bSLink=FALSE,bELink=FALSE;
	ads_name eLeftS,eRightS,eRightE,eLeftE;
	AcDbObjectId idLeftS,idRightS,idLeftE,idRightE;
	if (type != kWall)
	{
		OPENOBJ_BEGIN(ent,AcDb::kForRead,AcDbEntity,pEnt);
		if (pEnt)
		{
			pEnt->upgradeOpen();
			pEnt->erase();
		}
		OPENOBJ_END();
	}
	else
	{
		OPENOBJ_BEGIN(ent,AcDb::kForRead,TDbWall,pEnt);
		if (pEnt)
		{
			idLeftS = pEnt->GetLeftStart(FALSE);
			idRightS = pEnt->GetRightStart(FALSE);
			idLeftE = pEnt->GetLeftEnd(FALSE);
			idRightE = pEnt->GetRightEnd(FALSE);
		
			pEnt->upgradeOpen();
			pEnt->erase();
		}
		OPENOBJ_END();
	}
	
	//是否存在可能减少墙体的邻接墙
	if (type == kWall)
	{
		if (idLeftS!=AcDbObjectId::kNull && idRightS!=AcDbObjectId::kNull)
		{

			if (acdbGetAdsName(eLeftS,idLeftS)==Acad::eOk)
			{
				if (acdbGetAdsName(eRightS,idRightS)==Acad::eOk)
				{
					bSLink=TRUE;
				}

			}

		}
		if (idLeftE!=AcDbObjectId::kNull && idRightE!=AcDbObjectId::kNull)
		{
			if (acdbGetAdsName(eLeftE,idLeftE)==Acad::eOk)
			{
				if (acdbGetAdsName(eRightE,idRightE)==Acad::eOk)
				{
					bELink=TRUE;
				}

			}

		}
		if (bSLink)
		{
			bSLink=IsWallParalle(eLeftS,eRightS);
		}
		if (bELink)
		{
			bELink=IsWallParalle(eLeftE,eRightE);
		}
	}

	//处理墙体删除后，相邻墙体减少的情况  
	if (type == kWall)
	{

		TArchCmdReactor::UpdateCorners();
		TArchCmdReactor::ResetAll();
		if (bSLink)		//起点处有邻接墙
		{
			TEntity els(eLeftS),ers(eRightS);

			if ((els.m_nType!=kWall&&ers.m_nType==kWall)
				||(els.m_nType==kWall&&ers.m_nType!=kWall))
			{
				Entity find,replace;
				if (els.m_nType!=kWall&&ers.m_nType==kWall)
				{
					find = eLeftS;
					replace=eRightS;
				}
				else if (els.m_nType==kWall&&ers.m_nType!=kWall)
				{
					find = eRightS;
					replace=eLeftS;
				}
				for(int i=0;i<g_wallGroup.GetSize();i++)
				{
					if (g_wallGroup.ElementAt(i).m_eEnt1 == find)
					{
						g_wallGroup.ElementAt(i).m_eEnt1 = replace;
					}
					else if (g_wallGroup.ElementAt(i).m_eEnt2 == find)
					{
						g_wallGroup.ElementAt(i).m_eEnt2 = replace;
					}
			
				}
			}
		}

		if (bELink)		//终点处有邻接墙
		{
			TEntity ele(eLeftE),ere(eRightE);

			if ((ele.m_nType!=kWall&&ere.m_nType==kWall)
				||(ele.m_nType==kWall&&ere.m_nType!=kWall))
			{
				Entity find,replace;
				if (ele.m_nType!=kWall&&ere.m_nType==kWall)
				{
					find = eLeftE;
					replace=eRightE;
				}
				else if (ele.m_nType==kWall&&ere.m_nType!=kWall)
				{
					find = eRightE;
					replace=eLeftE;
				}
				for(int i=0;i<g_wallGroup.GetSize();i++)
				{
					if (g_wallGroup.ElementAt(i).m_eEnt1 == find)
					{
						g_wallGroup.ElementAt(i).m_eEnt1 == replace;
					}
					else if (g_wallGroup.ElementAt(i).m_eEnt2 == find)
					{
						g_wallGroup.ElementAt(i).m_eEnt2 == replace;
					}

				}
			}
		}
	}

	//确定当前位置
	// Zyu modify on 100722，支持64位
	//int num=g_wallGroup.GetSize()+g_openGroup.GetSize()+g_spaceGroup.GetSize()+g_colGroup.GetSize();
	INT_PTR num=g_wallGroup.GetSize()+g_openGroup.GetSize()+g_spaceGroup.GetSize()+g_colGroup.GetSize();
	if (num==0)
	{
		nCurPos = -1;
	}
	else if (nCurPos == num)
	{
		nCurPos = 0;
	}
	//刷新
	actrTransactionManager->flushGraphics();
	acedUpdateDisplay();
}

//更新对话框
void Update(CRemoveDupPromptDlg &dlg,	//[in]对话框对象
			int nCurPos					//[in]当前位置
			)
{
	int nWall(0),nOpening(0),nColumn(0),nSpace(0);

	// Zyu modify on 100723，消除64位编译警告
	//nWall = g_wallGroup.GetSize();
	//nOpening = g_openGroup.GetSize();
	//nColumn = g_colGroup.GetSize();
	//nSpace = g_spaceGroup.GetSize(); 
	nWall = (int)g_wallGroup.GetSize();
	nOpening = (int)g_openGroup.GetSize();
	nColumn = (int)g_colGroup.GetSize();
	nSpace = (int)g_spaceGroup.GetSize(); 
	
	dlg.m_nWall = nWall;
	dlg.m_nOpen = nOpening;
	dlg.m_nCol  = nColumn;
	dlg.m_nSpace= nSpace;

	dlg.m_strWall = _T("");
	dlg.m_strOpen = _T("");
	dlg.m_strCol = _T("");
	dlg.m_strSpace = _T("");

	if (nCurPos < nWall)
	{
		dlg.m_strWall.Format(_T("当前正在处理第　%d   处"),nCurPos+1);
	}
	else if (nCurPos < nWall+nOpening)
	{
		dlg.m_strOpen.Format(_T("当前正在处理第　%d   处"),nCurPos-nWall+1);
	}
	else if (nCurPos < nWall+nOpening+nColumn)
	{
		dlg.m_strCol.Format(_T("当前正在处理第　%d   处"),nCurPos-nWall-nOpening+1);
	}
	else if (nCurPos < nWall+nOpening+nColumn+nSpace)
	{
		dlg.m_strSpace.Format(_T("当前正在处理第　%d   处"),nCurPos-nWall-nOpening-nColumn+1);
	}
	dlg.UpdateData(FALSE);
}
// 修墙角
BOOL BreakWall(TGroup curGroup,		//[in]当前组
			   PickSet &ssAdd		//[in/out]新增加对象集
			   )
{
	PickSet ssWalls(SS_FREE);

	ssWalls += curGroup.m_eEnt1;
	ssWalls += curGroup.m_eEnt2;

	int nOldMode=DocGetDrawMode();
	DocSetDrawMode(DRAW_2D);
	XPoint pt1,pt2;
	ssWalls.GetExtend(pt1,pt2);
	DocSetDrawMode(nOldMode);

	XPoint ptMid;
	Midpoint(pt1, pt2, ptMid);
	ptMid=Ucs2Wcs(ptMid);

	long lCount=ssWalls.Length();
	if (lCount==2) 
	{
		XCurveSegment seg[2];
		for(long i=0L; i<2L; i++)
		{
			Entity ent=ssWalls[i];
			OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbWall, pWall);
			if (pWall) 
			{
				pWall->assertWriteEnabled();
				seg[i]=*pWall;
			}
			else
				return FALSE;
			OPENOBJ_END();
			
		}
		// [2010-3-16 9:22 wubo] 移植到新Geo库
		// seg[0].flag=seg[1].flag=LS_FINITE;
		seg[0].SetLineFlag(LS_FINITE);
		seg[1].SetLineFlag(LS_FINITE);
		XPoint ptInter[2], ptInt;
		int nIntNum=seg[0].Intersection(seg[1], ptInter[0], ptInter[1]);
		if (nIntNum==0)
		{
			seg[0].SetLineFlag(LS_INFINITE);
			seg[1].SetLineFlag(LS_INFINITE);
			XPoint ptInter1[2], ptInt1;
			int nIntNum1=seg[0].Intersection(seg[1], ptInter1[0], ptInter1[1]);
			if (nIntNum1 != 0)
			{
				if (nIntNum1==1)
				{
					ptInt=ptInter1[0];
				}
				else
				{
					ptInt=XLine(ptInter1[0], ptInter1[1]).NearPoint(ptMid);
				}
				seg[0].SetLineFlag(LS_FINITE);
				seg[1].SetLineFlag(LS_FINITE);
				for(long i=0L; i<2L; i++)
				{
					int nRet=seg[i].HitTest2d(ptInt);
					if (nRet == 6)			//起始端延长线
					{
						Entity ent=ssWalls[i];
						OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbWall, pWall);
						if (pWall) 
						{
							pWall->assertWriteEnabled();
							pWall->SetPoints(ptInt,seg[i].EndPoint());
						}
						OPENOBJ_END();
					}
					else if (nRet == 7)		//终端延长线
					{
						Entity ent=ssWalls[i];
						OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbWall, pWall);
						if (pWall) 
						{
							pWall->assertWriteEnabled();
							pWall->SetPoints(seg[i].StartPoint(),ptInt);
						}
						OPENOBJ_END();
					}
				}
			}
			else
				return FALSE;
		}
		else 
		{
			if (nIntNum==1) 
				ptInt=ptInter[0];
			else 
				ptInt=XLine(ptInter[0], ptInter[1]).NearPoint(ptMid);
		}

		for(i=0L; i<lCount; i++) 
		{
			Entity ent=ssWalls[i];
			OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbWall, pWall);
			if (pWall) 
			{
				pWall->assertWriteEnabled();
				if (i==0)
				{
					pWall->setColorIndex(nOldColorIndex1);
				}
				else
				{
					pWall->setColorIndex(nOldColorIndex2);
				}
				AcDbObjectId id=AcDbObjectId::kNull;
				pWall->BreakAt(ptInt, id);

				if (id != AcDbObjectId::kNull)
				{
					ads_name en;
					if (acdbGetAdsName(en,id)==Acad::eOk)
					{
						Entity e=en;
						ssAdd += e; 
					}

				}
			}
			OPENOBJ_END();
		}
	}

	TArchCmdReactor::UpdateCorners();
	TArchCmdReactor::ResetAll();
	
	return TRUE;
}
// 修墙角
void BreakWall(int &nCurPos,		//[in/out]当前位置
			   TGroup curGroup		//[in]当前组
			   )
{
	PickSet ssAdd(SS_FREE);

	if (BreakWall(curGroup,ssAdd))
	{
		CArray<TGroup,TGroup> wallGroup;
		g_wallGroup.RemoveAt(nCurPos);
		for(int i=0;i<g_wallGroup.GetSize();i++)
		{
			if (g_wallGroup.GetAt(i).m_eEnt1 == curGroup.m_eEnt1 
				||g_wallGroup.GetAt(i).m_eEnt1 == curGroup.m_eEnt2)
			{
				TEntity ent(g_wallGroup.GetAt(i).m_eEnt2);
				TEntity ent1(curGroup.m_eEnt1),ent2(curGroup.m_eEnt2);
				if (ent == ent1)
				{
					TGroup group(kWall);
					group.m_eEnt1 = ent.m_eName;
					group.m_eEnt2 = ent1.m_eName;
					wallGroup.Add(group);
				}
				if (ent == ent2)
				{
					TGroup group(kWall);
					group.m_eEnt1 = ent.m_eName;
					group.m_eEnt2 = ent2.m_eName;
					wallGroup.Add(group);
				}
				for(long j=0;j<ssAdd.Length();j++)
				{
					TEntity en(ssAdd[j]);
					if (ent == en)
					{
						TGroup group(kWall);
						group.m_eEnt1 = ent.m_eName;
						group.m_eEnt2 = en.m_eName;
						wallGroup.Add(group);
					}

				}
			}
			else if (g_wallGroup.GetAt(i).m_eEnt2 == curGroup.m_eEnt1
				||g_wallGroup.GetAt(i).m_eEnt2 == curGroup.m_eEnt2)
			{
				TEntity ent(g_wallGroup.GetAt(i).m_eEnt1);
				TEntity ent1(curGroup.m_eEnt1),ent2(curGroup.m_eEnt2);
				if (ent == ent1)
				{
					TGroup group(kWall);
					group.m_eEnt1 = ent.m_eName;
					group.m_eEnt2 = ent1.m_eName;
					wallGroup.Add(group);
				}
				if (ent == ent2)
				{
					TGroup group(kWall);
					group.m_eEnt1 = ent.m_eName;
					group.m_eEnt2 = ent2.m_eName;
					wallGroup.Add(group);
				}
				for(long j=0;j<ssAdd.Length();j++)
				{
					TEntity en(ssAdd[j]);
					if (ent == en)
					{
						TGroup group(kWall);
						group.m_eEnt1 = ent.m_eName;
						group.m_eEnt2 = en.m_eName;
						wallGroup.Add(group);
					}

				}
			}
			else
			{
				wallGroup.Add(g_wallGroup.GetAt(i));
			}
		}

		if (wallGroup.GetSize()>0)
		{
			g_wallGroup.RemoveAll();
			g_wallGroup.Append(wallGroup);
			if (g_wallGroup.GetSize() == nCurPos && nCurPos != 0)
			{
				nCurPos--;
			}
		}
	}
	else
	{
		if (g_wallGroup.GetSize()>nCurPos)
		{
			g_wallGroup.RemoveAt(nCurPos);
			// Zyu modify on 100722，支持64位
			//int num=g_wallGroup.GetSize()+g_openGroup.GetSize()+g_spaceGroup.GetSize()+g_colGroup.GetSize();
			INT_PTR num=g_wallGroup.GetSize()+g_openGroup.GetSize()+g_spaceGroup.GetSize()+g_colGroup.GetSize();
			if(nCurPos == g_wallGroup.GetSize() && nCurPos == num)
			{
				nCurPos--;
			}
		}
	}
	//刷新
	actrTransactionManager->flushGraphics();
	acedUpdateDisplay();
}

//去除当前组
void RemoveCurGroup( int nCurPos,		//[in]当前位置
				 TGroup &curGroup		//[in]当前组
				 )
{
	// Zyu modify on 100722，支持64位
	//int nWall(0),nOpening(0),nColumn(0),nSpace(0);
	INT_PTR nWall(0),nOpening(0),nColumn(0),nSpace(0);

	nWall = g_wallGroup.GetSize();
	nOpening = g_openGroup.GetSize();
	nColumn = g_colGroup.GetSize();
	nSpace = g_spaceGroup.GetSize();


	if (nWall > 0 && (nWall > nCurPos))
	{
		g_wallGroup.RemoveAt(nCurPos);
	}
	else if (nOpening > 0 && ((nOpening+nWall)  > nCurPos))
	{
		g_openGroup.RemoveAt(nCurPos-nWall);
	}
	else if (nColumn > 0 && ((nColumn +nOpening+nWall)  > nCurPos))
	{
		g_colGroup.RemoveAt(nCurPos-nWall-nOpening);
	}
	else if (nSpace > 0 && ((nSpace + nColumn +nOpening+nWall)  > nCurPos))
	{
		g_spaceGroup.RemoveAt(nCurPos-nWall-nOpening-nColumn);
	}
}

//add by xlc on 080814
//更新当前组
BOOL UpdateCurGroup( int nCurPos,		//[in]当前位置
					BOOL bChange,			//[in]是否切换显示
					BOOL bAutoZoom,		//[in]是否自动缩放
					TGroup &curGroup		//[in]当前组
					)
{
	// Zyu modify on 100722，支持64位
	//int num=g_wallGroup.GetSize()+g_openGroup.GetSize()+g_spaceGroup.GetSize()+g_colGroup.GetSize();
	INT_PTR num=g_wallGroup.GetSize()+g_openGroup.GetSize()+g_spaceGroup.GetSize()+g_colGroup.GetSize();
	if (nCurPos < 0 || num == 0 || nCurPos == num)
	{
		//adsout<<_T("\n处理完毕!");
		return FALSE;
	}
	SetGroupEntColor(curGroup,nOldColorIndex1,nOldColorIndex2);
	GetCurGroup(nCurPos,curGroup);
	if (curGroup.m_nType!=kNull)
	{
		GetGroupEntColor(curGroup,nOldColorIndex1,nOldColorIndex2);
	}
	//ShowCurGroup(curGroup,bChange,bAutoZoom);
	return TRUE;
}

//删除墙的同时,删除墙上的门窗数组
void RemoveOpeningWithWall(Entity entWall)
{
	OPENOBJ_BEGIN(entWall,AcDb::kForRead,TDbWall,pWall);
	if (pWall)
	{
		const DList<AcDbSoftPointerId> &lstWin=pWall->GetOpeningIdList();
		// Zyu modify on 100722，支持64位
		//for(long i=g_openGroup.GetSize()-1;i>=0;i--)
		for (LONG_PTR i = g_openGroup.GetSize() - 1; i >= 0; i--)
		{
			Entity ent1=g_openGroup.GetAt(i).m_eEnt1,
				ent2=g_openGroup.GetAt(i).m_eEnt2;

			for(int n = 0;n < lstWin.Length();n++)
			{
				AcDbObjectId id = lstWin[n];
				ads_name eOpen;
				if (acdbGetAdsName(eOpen,id)==Acad::eOk)
				{
					if (eOpen==ent1
						||eOpen==ent2)
					{
						g_openGroup.RemoveAt(i);
					}
				}
			}
		}
	}
	OPENOBJ_END();
}
// 完全消重
BOOL RemoveAllDup(BOOL &bEnd,		//[in/out]是否结束完全消重
				   int &nCurPos,	//[in]当前位置
				  TGroup &curGroup	//[in]当前组
				  )
{
	if (bEnd)
		return FALSE;	
	
	SetGroupEntColor(curGroup,nOldColorIndex1,nOldColorIndex2);
	// Zyu modify on 100722，支持64位
	//for(long i=g_wallGroup.GetSize()-1;i>=0;i--)
	for(LONG_PTR i = g_wallGroup.GetSize() - 1; i >= 0; i--)
	{
		if (IsWallEqual(g_wallGroup.GetAt(i).m_eEnt1,g_wallGroup.GetAt(i).m_eEnt2))
		{
			Entity ent1=g_wallGroup.ElementAt(i).m_eEnt1,
				ent2=g_wallGroup.ElementAt(i).m_eEnt2;
			g_wallGroup.RemoveAt(i);
			// Zyu add on 101222，计数增加
			g_nWallDup++;
			RemoveOpeningWithWall(ent2);
			OPENOBJ_BEGIN(ent2,AcDb::kForRead,AcDbEntity,pEnt);
			if (pEnt)
			{
				pEnt->upgradeOpen();
				pEnt->erase();
			}
			OPENOBJ_END();
			// Zyu modify on 100722，支持64位
			//for(long n=g_wallGroup.GetSize()-1;n>=0;n--)
			for(LONG_PTR n = g_wallGroup.GetSize() - 1; n >= 0; n--)
			{
				if (g_wallGroup.GetAt(n).m_eEnt1==ent2
					||g_wallGroup.GetAt(n).m_eEnt2==ent2)
				{
					g_wallGroup.RemoveAt(n);
					if (n<i)
						i--;
				}
			}
		}
	}

	for(i=g_colGroup.GetSize()-1;i>=0;i--)
	{
		if (IsColumnEqual(g_colGroup.GetAt(i).m_eEnt1,g_colGroup.GetAt(i).m_eEnt2))
		{
			Entity ent1=g_colGroup.ElementAt(i).m_eEnt1,
				ent2=g_colGroup.ElementAt(i).m_eEnt2;
			g_colGroup.RemoveAt(i);
			// Zyu add on 101222，计数增加
			g_nColDup++;
			OPENOBJ_BEGIN(ent2,AcDb::kForRead,AcDbEntity,pEnt);
			if (pEnt)
			{
				pEnt->upgradeOpen();
				pEnt->erase();
			}
			OPENOBJ_END();
			// Zyu modify on 100722，支持64位
			//for(long n=g_colGroup.GetSize()-1;n>=0;n--)
			for (LONG_PTR n = g_colGroup.GetSize() - 1; n >= 0; n--)
			{
				if (g_colGroup.GetAt(n).m_eEnt1==ent2
					||g_colGroup.GetAt(n).m_eEnt2==ent2)
				{
					g_colGroup.RemoveAt(n);
					if (n<i)
						i--;
				}
			}
		}
	}
	for(i=g_spaceGroup.GetSize()-1;i>=0;i--)
	{
		if (IsSpaceEqual(g_spaceGroup.GetAt(i).m_eEnt1,g_spaceGroup.GetAt(i).m_eEnt2))
		{
			Entity ent1=g_spaceGroup.ElementAt(i).m_eEnt1,
				ent2=g_spaceGroup.ElementAt(i).m_eEnt2;
			g_spaceGroup.RemoveAt(i);
			// Zyu add on 101222，计数增加
			g_nSpaceDup++;
			OPENOBJ_BEGIN(ent2,AcDb::kForRead,AcDbEntity,pEnt);
			if (pEnt)
			{
				pEnt->upgradeOpen();
				pEnt->erase();
			}
			OPENOBJ_END();
			// Zyu modify on 100722，支持64位
			//for(long n=g_spaceGroup.GetSize()-1;n>=0;n--)
			for(LONG_PTR n = g_spaceGroup.GetSize() - 1; n >= 0; n--)
			{
				if (g_spaceGroup.GetAt(n).m_eEnt1==ent2
					||g_spaceGroup.GetAt(n).m_eEnt2==ent2)
				{
					g_spaceGroup.RemoveAt(n);
					if (n<i)
						i--;
				}
			}
		}
	}
	
	//刷新
	actrTransactionManager->flushGraphics();
	acedUpdateDisplay();

	if (g_wallGroup.GetSize()+g_openGroup.GetSize()+g_spaceGroup.GetSize()+g_colGroup.GetSize()>0)
	{
		nCurPos=0;
		GetCurGroup(nCurPos,curGroup);
		if (curGroup.m_nType != kNull)
		{
			GetGroupEntColor(curGroup,nOldColorIndex1,nOldColorIndex2);
		}
		bEnd=TRUE;
		return TRUE;
	}
	return TRUE;
}

void RemoveDupEnt()
{
	XPushMemVar<BOOL> vTemp(g_bAutoCheckWall,FALSE);

	// 判断当前是否为模型空间
	int iTileMode = 0;
	xg_getvar(_T("TILEMODE"), &iTileMode);
	if (iTileMode == 0)
	{
		adsout << _T("\n请切换到模型空间使用该命令!");
		return;
	}
	
	CRemoveDupDlg dlg;
	{
		CAcModuleResourceOverride vTemp;
		if (dlg.DoModal()!=IDOK)
		{
			return;
		}
	}
	
	g_wallGroup.Append(dlg.m_wallGroup);
	g_openGroup.Append(dlg.m_openGroup);
	g_colGroup.Append(dlg.m_colGroup);
	g_spaceGroup.Append(dlg.m_spaceGroup);
	// Zyu add on 101222，清零
	g_nWallDup = 0;
	g_nOpenDup = 0;
	g_nColDup = 0;
	g_nSpaceDup = 0;
	
	// Zyu modify on 100722，支持64位
	//int nCount=g_wallGroup.GetSize()+g_openGroup.GetSize()+g_spaceGroup.GetSize()+g_colGroup.GetSize();
	INT_PTR nCount=g_wallGroup.GetSize()+g_openGroup.GetSize()+g_spaceGroup.GetSize()+g_colGroup.GetSize();
	if (nCount <= 0 )
	{
		Release();
		return;
	}
	extern GEOAPI double g_nAcadVer;
	int nOldDynMode=0; 
	if (g_nAcadVer>16.19)		//2006以上动态输入
	{
		xg_getvar(_T("DYNMODE"), &nOldDynMode);
		xg_setvar(_T("DYNMODE"), 0);
	}

	CRemoveDupPromptDlg dlgPrompt;
	{
		CAcModuleResourceOverride vTemp;
		dlgPrompt.Create(IDD_DIALOG_REMOVEDUP_PROM,acedGetAcadFrame());
		dlgPrompt.ShowWindow(SW_SHOW);
	}

	BOOL bAddMark=FALSE;					//添加标记操作
	BOOL bDelOrBreak=FALSE;					//删除或打断
	int nCurPos=0;
	TGroup curGroup;
	BOOL bChange=FALSE;
	
	BOOL bEnd=FALSE;						//是否结束完全消重

	GetCurGroup(nCurPos,curGroup);
	if (curGroup.m_nType!=kNull)
	{
		GetGroupEntColor(curGroup,nOldColorIndex1,nOldColorIndex2);
	}
	ShowCurGroup(curGroup,bChange,dlgPrompt.bAutoZoom);
	Update(dlgPrompt,nCurPos);

	PickSet ssMark(SS_FREE);
	BOOL bCheckEnd=FALSE;
	while(true)
	{
		int nRet;
		BOOL bShow=FALSE;
		BOOL bUpdate=FALSE;
		if (curGroup.m_nType==kWall)
		{
			bShow=IsWallParalle(curGroup.m_eEnt1,curGroup.m_eEnt2);
			bShow=!bShow;
		}
		if (bShow&&(!(bAddMark||bDelOrBreak)))
		{
			dlgPrompt.ShowButton(TRUE);
		}
		else
		{
			dlgPrompt.ShowButton(FALSE);
		}
		dlgPrompt.EnableButton(!bAddMark,!bDelOrBreak);
		TCHAR buf[256];
		if (bAddMark)
		{
			INITGET_BEG(0, _T("Q W A"));
			nRet = acedGetKword(_T("\n选择操作[下一处(Q)/上一处(W)/撤销标记(A)]<退出>:"),buf);
			INITGET_END();
		}
		else if (bDelOrBreak)
		{
			INITGET_BEG(0, _T("Q W"));
			nRet = acedGetKword(_T("\n选择操作[下一处(Q)/上一处(W)]<退出>:"),buf);
			INITGET_END();
		}
		else
		{
			if (bShow)
			{
				INITGET_BEG(0, _T("Q W E R A Z S D"));
				nRet = acedGetKword(_T("\n选择操作[下一处(Q)/上一处(W)/删除黄色(E)/删除红色(R)/添加标记(A)/切换显示(Z)/修墙角(S)/完全消重(D)]<退出>:"),buf);
				INITGET_END();
			}
			else
			{
				INITGET_BEG(0, _T("Q W E R A Z D"));
				nRet = acedGetKword(_T("\n选择操作[下一处(Q)/上一处(W)/删除黄色(E)/删除红色(R)/添加标记(A)/切换显示(Z)/完全消重(D)]<退出>:"),buf);
				INITGET_END();
			}
		}

		if (nRet==RTCAN ||nRet == RTNONE)
			break;
		else if (nRet == RTNORM)
		{
			if (buf[0]==_T('Q'))							//下一个
			{
				//add by xlc on 080814
				if (bAddMark)
				{
					RemoveCurGroup( nCurPos,curGroup);
					// Zyu modify on 100722，支持64位
					//int num=g_wallGroup.GetSize()+g_openGroup.GetSize()+g_spaceGroup.GetSize()+g_colGroup.GetSize();
					INT_PTR num=g_wallGroup.GetSize()+g_openGroup.GetSize()+g_spaceGroup.GetSize()+g_colGroup.GetSize();
					if (nCurPos>0)
						nCurPos--;
					if (num == nCurPos)
					{
						nCurPos--;
					}
					if (!UpdateCurGroup(nCurPos,bChange,dlgPrompt.bAutoZoom,curGroup))
						break;
					ShowCurGroup(curGroup,bChange,dlgPrompt.bAutoZoom);
					Update(dlgPrompt,nCurPos);
				}
				else if (bDelOrBreak)
				{
					// Zyu modify on 100722，支持64位
					//int num=g_wallGroup.GetSize()+g_openGroup.GetSize()+g_spaceGroup.GetSize()+g_colGroup.GetSize();
					INT_PTR num=g_wallGroup.GetSize()+g_openGroup.GetSize()+g_spaceGroup.GetSize()+g_colGroup.GetSize();
					if (nCurPos < 0 || num == 0 || nCurPos == num)
					{
						adsout<<_T("\n处理完毕!");
						break;
					}
					ShowCurGroup(curGroup,bChange,dlgPrompt.bAutoZoom);
					Update(dlgPrompt,nCurPos);
					bDelOrBreak=FALSE;
					continue;
				}
				bAddMark=FALSE;

				ShowNext(nCurPos,curGroup,bChange,dlgPrompt.bAutoZoom);
				Update(dlgPrompt,nCurPos);
				continue;
			}
			else if (buf[0]==_T('W'))					//上一个
			{
				//add by xlc on 080814
				if (bAddMark)
				{
					RemoveCurGroup( nCurPos,curGroup);
					// Zyu modify on 100722，支持64位
					//int num=g_wallGroup.GetSize()+g_openGroup.GetSize()+g_spaceGroup.GetSize()+g_colGroup.GetSize();
					INT_PTR num=g_wallGroup.GetSize()+g_openGroup.GetSize()+g_spaceGroup.GetSize()+g_colGroup.GetSize();
					if (num == nCurPos)
					{
						nCurPos--;
					}
					if (!UpdateCurGroup(nCurPos,bChange,dlgPrompt.bAutoZoom,curGroup))
						break;
					ShowCurGroup(curGroup,bChange,dlgPrompt.bAutoZoom);
					Update(dlgPrompt,nCurPos);
				}
				else if (bDelOrBreak)
				{
					// Zyu modify on 100722，支持64位
					//int num=g_wallGroup.GetSize()+g_openGroup.GetSize()+g_spaceGroup.GetSize()+g_colGroup.GetSize();
					INT_PTR num=g_wallGroup.GetSize()+g_openGroup.GetSize()+g_spaceGroup.GetSize()+g_colGroup.GetSize();
					if (nCurPos < 0 || num == 0 || nCurPos == num)
					{
						adsout<<_T("\n处理完毕!");
						break;
					}
					ShowCurGroup(curGroup,bChange,dlgPrompt.bAutoZoom);
					Update(dlgPrompt,nCurPos);
				}
				bDelOrBreak=FALSE;
				bAddMark=FALSE;

				ShowPre(nCurPos,curGroup,bChange,dlgPrompt.bAutoZoom);
				Update(dlgPrompt,nCurPos);
				continue;
			}
			else if (buf[0]==_T('E'))					//删除黄色
			{
				DeleteEnt(nCurPos,!bChange,curGroup);	//删除实体和相关组
				g_ssShow.Erase();
				bUpdate=TRUE;
				bDelOrBreak=TRUE;
			}
			else if (buf[0]==_T('R'))					//删除红色
			{
				DeleteEnt(nCurPos,bChange,curGroup);	//删除实体和相关组
				g_ssShow.Erase();
				bUpdate=TRUE;
				bDelOrBreak=TRUE;
			}
			else if (buf[0]==_T('A'))					//添加标记
			{
				//modify by xlc on 080814
				if (!bAddMark)
				{
					ssMark.Free();
					ssMark.IncludeBegin();
					AddMark(nCurPos,curGroup);
					ssMark.IncludeEnd();
					bAddMark=TRUE;
				}
				else
				{
					ssMark.Erase();
					bAddMark=FALSE;
				}
				/*RemoveCurGroup( nCurPos,curGroup);
				int num=g_wallGroup.GetSize()+g_openGroup.GetSize()+g_spaceGroup.GetSize()+g_colGroup.GetSize();
				if (num == nCurPos)
				{
					nCurPos--;
				}
				bUpdate=TRUE;*/
			}
			else if (buf[0]==_T('Z'))					//切换显示
			{
				bChange = !bChange;
				SwitchEntColor(curGroup,bChange,dlgPrompt.bAutoZoom);
				continue;
			}
			else if (buf[0]==_T('S'))					//修墙角
			{
				BreakWall(nCurPos,curGroup);	
				g_ssShow.Erase();
				bUpdate=TRUE;
				bDelOrBreak=TRUE;
			}

			//add by xlc on 090105
			else if (buf[0]==_T('D'))
			{
				if (RemoveAllDup(bEnd,nCurPos,curGroup))
				{
					bUpdate=FALSE;
					// Zyu modify on 100722，支持64位
					//int num=g_wallGroup.GetSize()+g_openGroup.GetSize()+g_spaceGroup.GetSize()+g_colGroup.GetSize();
					INT_PTR num=g_wallGroup.GetSize()+g_openGroup.GetSize()+g_spaceGroup.GetSize()+g_colGroup.GetSize();
					if(nCurPos < 0 || num == 0 || nCurPos == num)
					{
						adsout << _T("\n完全消重处理完毕!");
						break;
					}
					Update(dlgPrompt,nCurPos);
					ShowCurGroup(curGroup,bChange,dlgPrompt.bAutoZoom);
				}
				adsout << _T("\n完全消重处理完毕!");
				break;
			}

			if (bUpdate)									//更新当前显示
			{
				//modify by xlc on 080814
				/*
				int num=g_wallGroup.GetSize()+g_openGroup.GetSize()+g_spaceGroup.GetSize()+g_colGroup.GetSize();
				if (nCurPos < 0 || num == 0 || nCurPos == num)
				{
					adsout<<_T("\n处理完毕!");
					break;
				}
				SetGroupEntColor(curGroup,nOldColorIndex1,nOldColorIndex2);
				GetCurGroup(nCurPos,curGroup);
				if (curGroup.m_nType!=kNull)
				{
					GetGroupEntColor(curGroup,nOldColorIndex1,nOldColorIndex2);
				}
				ShowCurGroup(curGroup,bChange,dlgPrompt.bAutoZoom);
				Update(dlgPrompt,nCurPos);*/
				//if (!UpdateCurGroup(nCurPos,bChange,dlgPrompt.bAutoZoom,curGroup))
				//	break;
				//Update(dlgPrompt,nCurPos);

				UpdateCurGroup(nCurPos,bChange,dlgPrompt.bAutoZoom,curGroup);
			}
		}
	}
	SetGroupEntColor(curGroup,nOldColorIndex1,nOldColorIndex2);
	
	// Zyu add on 101206，输出消重图元处理结果

	CString sPrompt = _T("\n消除");
	if (dlg.bWall)
	{
		CString sTemp;
		sTemp.Format(_T("%d个重合墙体,"), g_nWallDup);
		sPrompt += sTemp;
	}

	if (dlg.bOpening)
	{
		CString sTemp;
		sTemp.Format(_T("%d个重合门窗,"), g_nOpenDup);
		sPrompt += sTemp;
	}

	if (dlg.bCol)
	{
		CString sTemp;
		sTemp.Format(_T("%d个重合柱子,"), g_nColDup);
		sPrompt += sTemp;
	}

	if (dlg.bSpace)
	{
		CString sTemp;
		sTemp.Format(_T("%d个重合房间,"), g_nSpaceDup);
		sPrompt += sTemp;
	}

	sPrompt.TrimRight(_T(','));
	sPrompt += _T('!');
	adsout<<(LPCTSTR)sPrompt;

	Release();
	if (::IsWindow(dlgPrompt.m_hWnd))
		dlgPrompt.DestroyWindow();

	if (g_nAcadVer>16.19)		//2006以上动态输入
	{
		xg_setvar(_T("DYNMODE"), nOldDynMode);
	}

	TArchCmdReactor::UpdateCorners();
	TArchCmdReactor::ResetAll();
}