#include "stdafx.h"
#include "actrans.h"


#include "PipeWireMonitor.h"
#include "DbPipe.h"
#include "SearchPipeSys.h"
//#include "DbObject.h"
#include <DbSpace.h>
#include "DbEquipment.h"
#include "DbWell.h"
//#include "tdoclock.h"
#include "DbFloorRect.h"
#include "DbVPipeDim.h"
#include "DbPool.h"
#include "DbFloorPipe.h"
#include "ClipData.h" //剪切板
#include "DbWellDim.h"
#include <algorithm>
#include "PipeSystemProcessor.h"
#include "DbPipeFitting.h"

#if ADS > 15
TLayerPane		g_LayerPane; //2011-10-11 sr add
#endif

// sg add
#include "DbDuct.h" 
#include "TDbDuctNode.h"
#include "DbDoubleLinePipeReducer.h"

#define WM_TCH_DOC_CHANGED  (WM_USER+0x0201)
Adesk::Boolean acedPostCommand(const TCHAR * );


int g_nCmdReactor=CMD_UNKNOWN;//命令状态
BOOL g_bIsStartMatchProp = FALSE;

extern BOOL g_bIsCustomizeVer;
extern CString g_sCurrentCmd;  // cet 2012.11.16 add  保存命令处理时启动的命令，以便更新双线水管fitting
extern double g_dPointToOriginLimitDist;

// NO MSG is required
//extern TARCH_IMPEXP BOOL g_bMonitorDbAction; 
//static BOOL g_bMonitorDbAction=TRUE;
static TPipeAppDocGlobals *g_pTPipeAppDocGlobals=NULL; 

/*  说明:
   本文件定义Reactor来监测管线的变动,最终的动作在命令结束时发生
   TPipeCmdReactor  命令监测
   TPipeDbReactor  数据库监测
																
   要使用这两个类,必须在Arx程序入口出注册他们(用Attach)
   在DWG结束时要Detach后者,在ARX程序退出时要Detach两者
*/

#define OBJ_DELETE 0x01
#define OBJ_APPEND 0x02
#define OBJ_CHANGE 0x04

namespace
{
	// 更新TDbPsConfig到新数据库 cet 2014.12.15 add
	void UpdatePsConfig(AcDbDatabase *pDb)
	{
		// 设置TDbPsConfig到新数据库
		TDbPsConfig *pCloneConfig = NULL;
		TDbPsConfig *pConfig = GetDwgPsGlobal(AcDb::kForRead);
		if (pConfig != NULL)
		{
			pCloneConfig = (TDbPsConfig*)pConfig->clone();
			pConfig->close();
		}
		if (pCloneConfig == NULL)
		{
			return;
		}	

		Acad::ErrorStatus es=Acad::eOk;
		AcDbDictionary* pRootDict=NULL;
		es=pDb->getNamedObjectsDictionary(pRootDict,AcDb::kForRead);
		assert(es==Acad::eOk);

		AcDbObject* pObj;
		es=pRootDict->getAt(g_sDbPsConfig,pObj,AcDb::kForRead);
		if (es==Acad::eOk) 
		{
			pObj->close();
		} 
		else  //当前数据库未初始化全局变量
		{
			if (pRootDict->upgradeOpen() == Acad::eOk) 
			{
				pRootDict->assertWriteEnabled();
				AcDbObjectId idConfig;
				es = pRootDict->setAt(g_sDbPsConfig,pCloneConfig,idConfig);
				if (es == Acad::eOk)
				{
					pCloneConfig->close();
				}
				else
				{
					delete pCloneConfig;
				}
				pCloneConfig = NULL;
				pRootDict->downgradeOpen();
			}
		}
		delete pCloneConfig;
		pRootDict->close();	
	}
	// 将当前数据库中的TDbPsConfig值存入新数据库中 cet2014.12.15 add
	void InitConfigToNewDatabase(AcDbDatabase *pDb)
	{
		// 更新TDbPsConfig到新数据库
		UpdatePsConfig(pDb);
	}
	// cet 2016.7.12 add 管道连接件图层随管道图层
	void UpdatePipeFittingLayer(const AcDbDatabase* dwg, const AcDbObject* dbObj)
	{
		if (dwg != acdbCurDwg() || !dbObj->isKindOf(TDbPipe::desc()))
		{
			return;
		}
		TDbPipe *pPipe = TDbPipe::cast(dbObj);
		for (int i = 0; i < 2; ++i)
		{
			AcDbObjectId id = pPipe->GetNode(i);
			if (!id.isValid())
			{
				continue;
			}
			TDbPipeFitting *pFitting = NULL;
			acdbOpenObject(pFitting, id, AcDb::kForRead);
			if (pFitting != NULL)
			{
				if ((pFitting->layerId() != pPipe->layerId() || 
					pFitting->color() != pPipe->color()) &&
					pFitting->upgradeOpen() == Acad::eOk)
				{
					pFitting->setLayer(pPipe->layerId());
					pFitting->setColor(pPipe->color());
					pFitting->downgradeOpen();
				}
				pFitting->close();
			}
		}
	}
	// 管道求交 cet 2017.12.13 add
	int IntersectionForDbPipePrototype(const TDbPipePrototype *pChangedPipe,const TDbPipePrototype *pPipe, XPoint &ptPipe1, XPoint &ptPipe2)
	{
		// 管道距离原点过远计算可能失败，移动到原点附近计算
		AcGeVector3d vtMove = pPipe->StartPoint();
		if (fabs(vtMove.x) > g_dPointToOriginLimitDist || 
			fabs(vtMove.y) > g_dPointToOriginLimitDist || 
			fabs(vtMove.z) > g_dPointToOriginLimitDist)
		{
			TDbPipePrototype *pPipe1 = (TDbPipePrototype*)pChangedPipe->clone();
			TDbPipePrototype *pPipe2 = (TDbPipePrototype*)pPipe->clone();
			if (pPipe1 != NULL && pPipe2 != NULL)
			{
				pPipe1->ResetAllShip(); // 清除关联关系，否则有时克隆出来的管道等执行transformBy
				pPipe2->ResetAllShip(); // 时，会同时修改原管道关联的对象（如fitting），导致管道等绘制错误
				AcGeMatrix3d mat;
				mat.setToTranslation(vtMove * -1);
				pPipe1->transformBy(mat);
				pPipe2->transformBy(mat);
				int nRet = pPipe1->Intersection(*pPipe2, ptPipe1, ptPipe2);
				if (nRet > 0) // 有交点
				{
					ptPipe1.TransformBy(mat.inverse()); // 第一个交点
					if (nRet > 1) // 第二个交点
					{
						ptPipe2.TransformBy(mat.inverse());
					}
				}
				return nRet;
			}
		}
		return pChangedPipe->Intersection(*pPipe, ptPipe1, ptPipe2);
	}
}

Acad::ErrorStatus GetSafeSelection(PickSet &ss,const XPoint &ptLow,
			const XPoint &ptUp, const AcRxClass *pClass, BOOL bCrossing=TRUE);

BOOL GetPSEntFormBlock(DList<AcDbObjectId> &lstPSEnt,
	const XRectAngle& rectBound,const AcRxClass *pClass)
{
	lstPSEnt.Reset();
	if(pClass==NULL)	return FALSE;
	XDbBlockTableRec objMSpace;
	if(!objMSpace)		return FALSE;

	XPoint ptExtents(1000,1000,0);//加速设备GetExtents
	AcDbBlockTableRecordIterator* pBlockIterator=NULL;
	Acad::ErrorStatus es=objMSpace.m_pBlockTableRec->newIterator(pBlockIterator);
	ASSERT(es==Acad::eOk && pBlockIterator!=NULL);

	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->isKindOf(pClass)||pEntity->visibility()==AcDb::kInvisible)
			continue;

		AcDbObjectId id=pEntity->objectId();
		if(pEntity->isKindOf(TDbPipePrototype::desc())) {//管线(for getGeomExtents 不准确)
			TDbPipePrototype *pPipe=(TDbPipePrototype *)pEntity;
			if(pPipe!=NULL) {
				XPoint ptMin,ptMax;
				if(pPipe->GetExtend(ptMin,ptMax)) {
					if(ExtendInBox02d(ptMin,ptMax,rectBound)) {
						lstPSEnt.Append(new AcDbObjectId(id));
					}
				}
			}
		}
		else if(pEntity->isKindOf(TDbPipeNode::desc())) { //节点
			TDbPipeNode *pNode=(TDbPipeNode *)pEntity;
			if(pNode!=NULL) {
				if(pNode->IsVisible()) { //可见节点
					if(pNode->IsDrawBlock()) {
						XPoint ptLocation=pNode->GetLocation();
						XPoint ptMin=ptLocation-ptExtents;
						XPoint ptMax=ptLocation+ptExtents;
						if(!ExtendInBox02d(ptMin,ptMax,rectBound))
							continue;
					}
					XPoint ptMin,ptMax;
					if(pNode->GetExtents(ptMin,ptMax)==Acad::eOk) {
						if(ExtendInBox02d(ptMin,ptMax,rectBound)) {
							lstPSEnt.Append(new AcDbObjectId(id));
						}
					}
				} else { //不可见节点
					XPoint ptLocation = pNode->GetLocation();
					if(PointInBox02d(ptLocation,rectBound)) {
						lstPSEnt.Append(new AcDbObjectId(id));
					}
				}
			}
		}
		else if(pEntity->isKindOf(TDbPipeAttachment::desc())) { // 管线附件
			TDbPipeAttachment *pAttach=(TDbPipeAttachment *)pEntity;
			if(pAttach!=NULL) {
				if(pAttach->IsDrawBlock()) {
					XPoint ptLocation=pAttach->GetLocation();
					XPoint ptMin=ptLocation-ptExtents;
					XPoint ptMax=ptLocation+ptExtents;
					if(!ExtendInBox02d(ptMin,ptMax,rectBound))
						continue;
				}				
				XPoint ptMin,ptMax;
				if(pAttach->GetExtents(ptMin,ptMax)==Acad::eOk) {
					if(ExtendInBox02d(ptMin,ptMax,rectBound)) {
						lstPSEnt.Append(new AcDbObjectId(id));
					}
				}
			}
		} 
		else if(pEntity->isKindOf(TDbEntity::desc())) { // 其他上华实体
			TDbEntity *pTEnt=(TDbEntity *)pEntity;
			if(pTEnt!=NULL) {
				XPoint ptMin,ptMax;
				if(pTEnt->GetExtents(ptMin,ptMax)==Acad::eOk) {
					if(ExtendInBox02d(ptMin,ptMax,rectBound)) {
						lstPSEnt.Append(new AcDbObjectId(id));
					}
				}
			}
		} 
		else { // 其他的非上华实体
			AcDbExtents ext;
			if(pEntity->getGeomExtents(ext)==Acad::eOk) {
				XPoint ptMin=ext.minPoint(), ptMax=ext.maxPoint();
				if(ExtendInBox02d(ptMin,ptMax,rectBound)) {
					lstPSEnt.Append(new AcDbObjectId(id));
				}
			}
		}
	}

	delete pBlockIterator;
	return TRUE;
}
/*
int GetPickFirst_New(PickSet &gSet, PickSet &pSet)
{
    resbuf *gset=NULL, *pset=NULL;
    int nRet=ads_ssgetfirst(&gset, &pset);
    if(gset) {
        if(gset->restype==RTPICKS) {
            PickSet ss0(0);
            ss0 = gset->resval.rlname;
            gSet += ss0;
            ss0.Free();
        }
        ads_relrb(gset);
    }
    if(pset) {
        if(pset->restype==RTPICKS) {
            PickSet ss0(0);
            ss0 = pset->resval.rlname;
            pSet += ss0;
            ss0.Free();
        }
        ads_relrb(pset);
    }
    return nRet;
}

*/

///////////////////////////////////////////////////////////////////
// 文档反应器
void TPipeDocReactor::documentToBeActivated(AcApDocument *pDoc) 
{ 
    ::PostMessage(NULL, WM_TCH_DOC_CHANGED, 0, 0);
    g_pTPipeAppDocGlobals->InitDocGlobals(pDoc); 

#if (ADS>15)
	if (g_bIsCustomizeVer)
	{
		g_LayerPane.Update();
	}
#endif
	
} 

void TPipeDocReactor::documentCreated(AcApDocument *pDoc) 
{ 
    g_pTPipeAppDocGlobals->InitDocGlobals(pDoc); 
} 

void TPipeDocReactor::documentToBeDestroyed(AcApDocument *pDoc) 
{ 
    g_pTPipeAppDocGlobals->RemoveDocGlobals(pDoc); 
} 
// 文档反应器结束
///////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////
// 输入反应器
void TPipeInputReactor::endEntsel(Acad::PromptStatus returnStatus,
                                  AcDbObjectId& entPicked,
                                  AcGePoint3d& pickPoint,
                                  const TCHAR* pKeyword)
{
    if(!g_bIsStartMatchProp)
        return;
    OPENOBJ_BEGIN(entPicked, AcDb::kForRead, TDbPipe, pPipe);
    if(!pPipe){
        OPENOBJ_BEGIN(entPicked, AcDb::kForRead, TDbEquipment, pEquip);
        if(!pEquip){
            g_bIsStartMatchProp = FALSE;
            return;
        }
        OPENOBJ_END();
    }
    OPENOBJ_END();
    
    TPipePerDocData *pData = GetCurPipeDocData();
    ASSERT(pData);
    if(pData) {
        pData->m_idMatchRes = entPicked;
    }
}
// 输入反应器结束
///////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////
// TPipePerDocData
TPipePerDocData::TPipePerDocData(AcApDocument *pDoc) 
:m_rectSysUpdate(XPoint(),XPoint()),m_rectAttachUpdate(XPoint(),XPoint()),
m_bWork(TRUE),m_nOptimize(500)
{ 
    m_pDoc = pDoc; 
    m_pDbReactor=NULL;
    m_pInputReactor = NULL;
    m_idMatchRes = NULL;
} 

TPipePerDocData::~TPipePerDocData()
{
    ASSERT(m_pDbReactor==NULL);
    ASSERT(m_pInputReactor==NULL);
}

void TPipePerDocData::ResetDocCmdGlobals()
{
     m_lstUpdate.Reset();
	 m_rectSysUpdate.lowLeft=m_rectSysUpdate.upRight=XPoint();
	 m_rectAttachUpdate.lowLeft=m_rectAttachUpdate.upRight=XPoint();
	 m_lstChangedNode.Reset();
     m_idMatchRes = NULL;
     m_lstMatchEntity.Reset();
//     m_lstWellArea.Reset();


	 m_setEntIds.clear();  // cet 2013.1.11 add
}

int TPipePerDocData::GetChangedNum() const
{
	int nChangedNum=m_lstChangedNode.Length();
	for(int i=0; i<m_lstUpdate.Length(); i++) {
		const UpdateInfo &info=m_lstUpdate[i];
		nChangedNum += info.lstAttachPipe.Length();
	}
	return nChangedNum;
}

TPipePerDocData::UpdateInfo *
TPipePerDocData::FindUpdateInfo(TPipeSys::SysType st)
{
	for(int i=0; i<m_lstUpdate.Length(); i++) {
		UpdateInfo *info=m_lstUpdate[i];
//		cet 2015.7.3 modify 不再按管线系统分类处理管线
// 		if(info->sysType==st)
// 			return info;
		return info;
	}
	return NULL;
}

BOOL TPipePerDocData::
GetNodeFromBlock(DList<TNodeLocation> &lstNode,const XRectAngle &rect) const
{
	if(IsRectEmpty(rect)) return TRUE;
	XDbBlockTableRec objMSpace;
	if(!objMSpace) return FALSE;

	lstNode.Reset();
	XPoint ptExtents(1000,1000,0);//加速设备GetExtents
	XPoint ptSnap(PS_SNAP,PS_SNAP);
	XRectAngle rectBound(rect.lowLeft-ptSnap,rect.upRight+ptSnap);

	AcDbBlockTableRecordIterator* pBlockIterator=NULL;
	Acad::ErrorStatus es=objMSpace.m_pBlockTableRec->newIterator(pBlockIterator);
	ASSERT(es==Acad::eOk && pBlockIterator!=NULL);

	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->isKindOf(TDbPipeNode::desc())||pEntity->visibility()==AcDb::kInvisible)
			continue;

		TDbPipeNode *pNode=(TDbPipeNode *)pEntity;
		if(pNode!=NULL) {
			XPoint ptLocation=pNode->GetLocation();
			if(pNode->IsVisible()) { //可见节点
				if(pNode->IsDrawBlock()) {
					XPoint ptMin;
					XPoint ptMax;
					//2009-8-11 谢真修改以下10行：对于大的化粪池ptExtents(1000,1000,0)太小无法InBox
					TDbPool *pPool = TDbPool::cast(pNode);
					TDbDoubleLinePipeReducer *pDLpipeReducer = TDbDoubleLinePipeReducer::cast(pNode);
					if (pPool != NULL)
					{
						double dPoolLen = pPool->GetPoolLength();
						double dPoolWidth = pPool->GetPoolWidth();
						double dLen = pow(dPoolLen*dPoolLen + dPoolWidth*dPoolWidth,0.5);//double dLen = pow(dPoolLen*dPoolLen + dPoolWidth*dPoolWidth,0.5) + 100;
						XPoint ptPool(dLen/2.0, dLen/2.0, 0.0); //sr 范围缩小（原先对角线2倍+100为边的正方形） XPoint ptPool(dLen, dLen, 0.0); 2011-11-10
						ptMin=ptLocation-ptPool;
						ptMax=ptLocation+ptPool;
					}
					else if (pDLpipeReducer != NULL) // cet 2010.3.5 add
					{
						AcDbExtents extends;
						pDLpipeReducer->getGeomExtents(extends);
						AcGePoint3d ptTmp(100, 100, 0.0);
						ptMin = extends.minPoint() - ptTmp;
						ptMax = extends.maxPoint() + ptTmp;
					}
					else
					{
						ptMin=ptLocation-ptExtents;
						ptMax=ptLocation+ptExtents;
					}
					/////////////////////////
					if(!ExtendInBox02d(ptMin,ptMax,rectBound))
						continue;
					else
					{
						lstNode.Append(new TNodeLocation(pNode->objectId(),ptLocation));
						continue;//SR ADD 2011-11-10  发现图块设备（化粪池）最大包围盒与rectBound有交集，把设备加入lstNode中
					}
				}
				XPoint ptMin,ptMax;
				if(pNode->GetExtents(ptMin,ptMax)==Acad::eOk) {
					if(ExtendInBox02d(ptMin,ptMax,rectBound)) {
						lstNode.Append(new TNodeLocation(pNode->objectId(),ptLocation));
					}
				} else { // for上华插件
					lstNode.Append(new TNodeLocation(pNode->objectId(),ptLocation));
				}
			} else { //不可见节点
				if(PointInBox02d(ptLocation,rectBound)) {
					lstNode.Append(new TNodeLocation(pNode->objectId(),ptLocation));
				}
			}
		}
	}

	delete pBlockIterator;
	return TRUE;
}

BOOL TPipePerDocData::GetEntRectFromBlock(DList<TEntRect> &lstEntRect,
		const AcRxClass *pClass,const XRectAngle &rect) const
{
	if(pClass==NULL) return FALSE;
	if(IsRectEmpty(rect)) return TRUE;
	
	XDbBlockTableRec objMSpace;
	if(!objMSpace)	
		return FALSE;

	lstEntRect.Reset();
	XPoint ptExtents(1000,1000,0);//加速设备GetExtents
	XPoint ptSnap(PS_SNAP,PS_SNAP);
	XRectAngle rectBound(rect.lowLeft-ptSnap,rect.upRight+ptSnap);

	AcDbBlockTableRecordIterator* pBlockIterator=NULL;
	Acad::ErrorStatus es=objMSpace.m_pBlockTableRec->newIterator(pBlockIterator);
	ASSERT(es==Acad::eOk && pBlockIterator!=NULL);

	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->isKindOf(pClass)||pEntity->visibility()==AcDb::kInvisible)
			continue;

		AcDbObjectId id=pEntity->objectId();
		if(pEntity->isKindOf(TDbPipePrototype::desc())) {//管线(for getGeomExtents 不准确)
			TDbPipePrototype *pPipe=(TDbPipePrototype *)pEntity;
			if(pPipe!=NULL) {
				XPoint ptMin,ptMax;
				if(pPipe->GetExtend(ptMin,ptMax)) {
					if(ExtendInBox02d(ptMin,ptMax,rectBound)) {
						lstEntRect.Append(new TEntRect(id,ptMin,ptMax));
					}
				}
			}
		}
		else if(pEntity->isKindOf(TDbPipeNode::desc())) { //节点
			TDbPipeNode *pNode=(TDbPipeNode *)pEntity;
			if(pNode!=NULL) {
				if(pNode->IsVisible()) { //可见节点
					if(pNode->IsDrawBlock()) {
						XPoint ptLocation=pNode->GetLocation();
						XPoint ptMin=ptLocation-ptExtents;
						XPoint ptMax=ptLocation+ptExtents;
						if(!ExtendInBox02d(ptMin,ptMax,rectBound))
							continue;
					}
					XPoint ptMin,ptMax;
					if(pNode->GetExtents(ptMin,ptMax)==Acad::eOk) {
						if(ExtendInBox02d(ptMin,ptMax,rectBound)) {
							lstEntRect.Append(new TEntRect(id,ptMin,ptMax));
						}
					}
				} else { //不可见节点
					XPoint ptLocation = pNode->GetLocation();
					if(PointInBox02d(ptLocation,rectBound)) {
						lstEntRect.Append(new TEntRect(id,ptLocation,ptLocation));
					}
				}
			}
		}
		else if(pEntity->isKindOf(TDbPipeAttachment::desc())) { // 管线附件
			TDbPipeAttachment *pAttach=(TDbPipeAttachment *)pEntity;
			if(pAttach!=NULL) {
				if(pAttach->IsDrawBlock()) {
					XPoint ptLocation=pAttach->GetLocation();
					XPoint ptMin=ptLocation-ptExtents;
					XPoint ptMax=ptLocation+ptExtents;
					if(!ExtendInBox02d(ptMin,ptMax,rectBound))
						continue;
				}				
				XPoint ptMin,ptMax;
				if(pAttach->GetExtents(ptMin,ptMax)==Acad::eOk) {
					if(ExtendInBox02d(ptMin,ptMax,rectBound)) {
						lstEntRect.Append(new TEntRect(id,ptMin,ptMax));
					}
				}
			}
		} 
		else if(pEntity->isKindOf(TDbEntity::desc())) { // 其他上华实体
			TDbEntity *pTEnt=(TDbEntity *)pEntity;
			if(pTEnt!=NULL) {
				XPoint ptMin,ptMax;
				if(pTEnt->GetExtents(ptMin,ptMax)==Acad::eOk) {
					if(ExtendInBox02d(ptMin,ptMax,rectBound)) {
						lstEntRect.Append(new TEntRect(id,ptMin,ptMax));
					}
				}
			}
		} 
		else { // 其他的非上华实体
			AcDbExtents ext;
			if(pEntity->getGeomExtents(ext)==Acad::eOk) {
				XPoint ptMin=ext.minPoint(), ptMax=ext.maxPoint();
				if(ExtendInBox02d(ptMin,ptMax,rectBound)) {
					lstEntRect.Append(new TEntRect(id,ptMin,ptMax));
				}
			}
		}
	}

	delete pBlockIterator;
	return TRUE;
}

// 查找并增加包含pNode的管段的需要更新的信息
BOOL TPipePerDocData::
UpdatePipeInfos(const TDbPipeNode *pChangedNode,const TDbPipePrototype *pPipe)
{
    XPoint ptLocation=pChangedNode->GetLocation();
    int nFlag = ptLocation&(*pPipe);
    if(nFlag==PR_INSIDE || nFlag==PR_ONPT1 || nFlag==PR_ONPT2) {
        if(pChangedNode->HasNodeLocation()) {
            UpdateInfo *info=NewAppendUpdateInfo(pPipe->GetSysType());
            ASSERT(info!=NULL);
            info->AddPipe(pPipe->objectId());
            info->lstVertice.NewAppend(ptLocation);
        }
        return TRUE;
    }
	return FALSE;
}


//这里判断是否生成四通，还是置上置下
BOOL TPipePerDocData::UpdatePipeInfos(const TDbPipePrototype *pChangedPipe,const TDbPipePrototype *pPipe)
{
	TPipeSys::SysType sysType;
//  cet 2015.7.8 modify 按管线系统索引区分管线类型
// 	if(pPipe->GetHideLevel()!=pChangedPipe->GetHideLevel()	|| (sysType=pPipe->GetSysType())!=pChangedPipe->GetSysType())
// 		return FALSE;
	sysType=pPipe->GetSysType();
	if(pPipe->GetHideLevel()!=pChangedPipe->GetHideLevel()	|| PipeSystemProcessor::GetSysIndex(pChangedPipe) != PipeSystemProcessor::GetSysIndex(pPipe))
	{
		return FALSE;
	}
	XPoint pt1,pt2;
//  cet 2017.8.12.13 modify 管道距离原点过远时，计算可能失败，先优化计算方式
//	if(pChangedPipe->Intersection(*pPipe,pt1,pt2)) {
	int nRet = IntersectionForDbPipePrototype(pChangedPipe, pPipe, pt1, pt2);
	if (nRet > 0) // 交点个数大于0
	{
		UpdateInfo *info=NULL;						
		if(nRet > 0 && !(pPipe->IsVertex(pt1) && pChangedPipe->IsVertex(pt1))) { // 第一个交点
			if(info==NULL) {
				info=NewAppendUpdateInfo(sysType);
				ASSERT(info!=NULL);
			}
			info->AddBreakPoint(pt1,1);
		}
		if(nRet > 1 && !(pPipe->IsVertex(pt2) && pChangedPipe->IsVertex(pt2))) { // 第二个交点
			if(info==NULL) {
				info=NewAppendUpdateInfo(sysType);
				ASSERT(info!=NULL);
			}
			info->AddBreakPoint(pt2,1);
		}
		if(info!=NULL) {
			info->AddPipe(pPipe->objectId());
			return TRUE;
		}
	}
	else{
		//sr add 2004/10/20 XLine 不支持3维求交，立管与支管相交时，无法生成4通，现在改为AcDbLine，但只处理直线管线
		if(pChangedPipe->IsVertical()){
			XLine l1 = pChangedPipe->GetLine();
			XLine l2 = pPipe->GetLine();
			AcDbLine line1((AcGePoint3d)l1.StartPoint(), (AcGePoint3d)l1.EndPoint());
			AcDbLine line2((AcGePoint3d)l2.StartPoint(), (AcGePoint3d)l2.EndPoint());
            
            AcGePoint3dArray arPoint;
			int hit = line1.intersectWith(&line2, AcDb::kOnBothOperands, arPoint);
            if(arPoint.length() == 1)
                pt1 = arPoint[0];
			UpdateInfo *info=NULL;						
			if(!(pPipe->IsVertex(pt1) && pChangedPipe->IsVertex(pt1))) {
				if(info==NULL) {
					info=NewAppendUpdateInfo(sysType);
					ASSERT(info!=NULL);
				}
				info->AddBreakPoint(pt1,1);
			}
			if(info!=NULL) {
				info->AddPipe(pPipe->objectId());
				return TRUE;
			}
		}
		//////////////////////////////////////////////////////////////////////////
	}
	return FALSE;
}

// 0、如果lstVertice存在不再加
// 1、如果lstVertice存在删除，加在lstNeedBreak
void TPipePerDocData::UpdateInfo::
AddBreakPoint(const XPoint &ptBreak,int nStytle)
{
	int nCount=lstVertice.Length();
	if(nStytle==0) {
		for(int k=0; k<nCount; k++) {
			if(*lstVertice[k]==ptBreak) {
				return;
			}
		}
	}
	else if(nStytle==1) {
		for(int k=0; k<nCount; k++) {
			if(*lstVertice[k]==ptBreak) {
				lstVertice.Remove();
				break;
			}
		}
		lstNeedBreak.NewAppend(ptBreak);
	}
}

// 查找并增加在管段上的节点的需要更新的信息
void TPipePerDocData::
UpdateNodeInfos(const TDbPipePrototype *pChangedPipe,const TDbPipeNode *pNode)
{
	XPoint ptLocation=pNode->GetLocation();
	int nFlag = ptLocation&(*pChangedPipe);
	if(nFlag==PR_INSIDE) {
		int nFaceNum=pNode->GetInterfaceNum();
		for(int n=0; n<nFaceNum; n++) {
			const TPipeInterface &iFace=pNode->GetInterface(n);
			UpdateInfo *info=NewAppendUpdateInfo(iFace.m_sysType);
			if(iFace.m_faceType==TPipeInterface::kNodeLocation) {
				info->lstVertice.NewAppend(ptLocation);
			} 
		}
		
		// 孤立的非自动生成的节点
		if(nFaceNum<=0 && !pNode->IsAutoLiving()) {
			UpdateInfo *info=NewAppendUpdateInfo(pChangedPipe->GetSysType());
			ASSERT(info!=NULL);
			info->AddBreakPoint(ptLocation,1);
		}
	}
}

// 深层次的搜寻管线和管段
void TPipePerDocData::DoDeepSearch(const DList<TEntRect> &lstPipe,
								   const DList<TNodeLocation> &lstNode,
								   XRectAngle &rectUpdate)
{
	// 变化的管线
	for(int n=0; n<m_lstUpdate.Length(); n++) {
		UpdateInfo *info=m_lstUpdate[n];
		for(int i=0; i<info->lstChangedPipe.Length(); i++) {
			TEntRect &pipeChanged = *info->lstChangedPipe[i];
			OPENOBJ_BEGIN(pipeChanged.id,AcDb::kForRead,TDbPipePrototype,pChangedPipe);
			if(pChangedPipe!=NULL)
			{
				// 管线
				for(int k=0; k<lstPipe.Length(); k++) {
					const TEntRect &kPipe=lstPipe[k];
					if(pipeChanged.Intersect(kPipe) && pipeChanged.id!=kPipe.id) {
						OPENOBJ_BEGIN(kPipe.id,AcDb::kForRead,TDbPipePrototype,pPipe);
						if(pPipe!=NULL)
							if(UpdatePipeInfos(pChangedPipe,pPipe)) {
								const XRectAngle &rect=kPipe.rect;//更新变化区域
								UpdateRect(rect.lowLeft,rect.upRight,rectUpdate);
							}
						OPENOBJ_END();
					}
				}
				// 节点
				for(k=0; k<lstNode.Length(); k++) {
					const TNodeLocation &kNode=lstNode[k];
					if(kNode.Intersect(pipeChanged)) {
						OPENOBJ_BEGIN(kNode.id,AcDb::kForRead,TDbPipeNode,pNode);
						if(pNode!=NULL)
							UpdateNodeInfos(pChangedPipe,pNode);
						OPENOBJ_END();
					}
				}
			}
			OPENOBJ_END();
		}
	}

	// 变化的节点
	for(int i=0; i<m_lstChangedNode.Length(); i++) {
		TNodeLocation &nodeChanged=*m_lstChangedNode[i];
		OPENOBJ_BEGIN(nodeChanged.id,AcDb::kForRead,TDbPipeNode,pChangedNode);
		if(pChangedNode!=NULL) {
			for(int k=0; k<lstPipe.Length(); k++) {
				const TEntRect &kPipe=lstPipe[k];
				if(nodeChanged.Intersect(kPipe)) {
					OPENOBJ_BEGIN(kPipe.id,AcDb::kForRead,TDbPipePrototype,pPipe);
					if(pPipe!=NULL)
						if(UpdatePipeInfos(pChangedNode,pPipe)) {
							const XRectAngle &rect=kPipe.rect;//更新变化区域
							UpdateRect(rect.lowLeft,rect.upRight,rectUpdate);
							UpdateInfo *info=NewAppendUpdateInfo(pPipe->GetSysType());
							ASSERT(info!=NULL);
							info->lstVertice.NewAppend(nodeChanged.ptLocation);
						}						
					OPENOBJ_END();
				}
			}
		}
		OPENOBJ_END();
	}

	// 释放
	m_lstChangedNode.Reset();
	for(i=0; i<m_lstUpdate.Length(); i++) {
		m_lstUpdate[i]->lstChangedPipe.Reset();
	}
	rectUpdate.SetElevation(0);
}

void TPipePerDocData::ObjectChanged(const AcDbObject *dbObj, int nChangeFlag)
{
	if(!m_bWork) return;

    if(g_bIsStartMatchProp && nChangeFlag&OBJ_CHANGE){
        BOOL bIsPipe = FALSE;
        BOOL bIsEquip = FALSE;
        OPENOBJ_BEGIN(m_idMatchRes, AcDb::kForRead, TDbPipe, pPipe);
        if(pPipe){
            bIsPipe = TRUE;
        }
        OPENOBJ_END();
        OPENOBJ_BEGIN(m_idMatchRes, AcDb::kForRead, TDbEquipment, pEquip);
        if(pEquip){
            bIsEquip = TRUE;
        }
        OPENOBJ_END();
        if(bIsPipe){
            if(dbObj->isKindOf(AcDbLine::desc()) || dbObj->isKindOf(AcDbArc::desc()) || dbObj->isKindOf(AcDbPolyline::desc()) || dbObj->isKindOf(AcDbCircle::desc())) {
                m_lstMatchEntity.Append(new AcDbObjectId(dbObj->objectId()));
            }
        }
        else if(bIsEquip){
            if(dbObj->isKindOf(AcDbBlockReference::desc())) {
                m_lstMatchEntity.Append(new AcDbObjectId(dbObj->objectId()));
            }
        }
    }


	if(dbObj->isKindOf(TDbPipeNode::desc()) && !dbObj->isKindOf(TDbDuctNode::desc())) { //节点变化
        TDbPipeNode *pNode=(TDbPipeNode *)dbObj;
		XPoint pt1, pt2;
		if(pNode->GetExtents(pt1,pt2)==Acad::eOk && !(pt1==XPoint()&&pt2==XPoint())) {
			UpdateRect(pt1,pt2,m_rectSysUpdate);
			// cet 2013.1.11 add 黏贴时记录更新区域时，使用的实体
			if(IsUpdateSysRect(g_sCurCommand))
			{
				m_setEntIds.insert(dbObj->objectId());
			}
			int nFaceNum=pNode->GetInterfaceNum();
			XPoint ptLocation=pNode->GetLocation();
			for(int n=0; n<nFaceNum; n++) {
				const TPipeInterface& iFace=pNode->GetInterface(n);
				UpdateInfo *info=NewAppendUpdateInfo(iFace.m_sysType);
				ASSERT(info!=NULL);
				if(iFace.m_faceType==TPipeInterface::kNodeLocation) {
					info->lstVertice.NewAppend(ptLocation);
				} 
			}
			if(nChangeFlag&OBJ_CHANGE && m_lstChangedNode.Length()<m_nOptimize) {
				AcDbObjectId id = pNode->objectId();
				if(!m_lstChangedNode.FindNode(&id, TNodeLocation::CompareObjectId))
					m_lstChangedNode.Append(new TNodeLocation(id,ptLocation));
			}
		}
		// cet 2018.7.4 add 更新管道遮挡(通过工具条下方的比例修改井的比例时，管道遮挡需要更新否则遮挡会出错)
		if (nChangeFlag&OBJ_CHANGE)
		{
			m_bWork = FALSE; // 避免修改是调用ObjectChanged
			int nFaceNum = pNode->GetInterfaceNum();
			for(int i = 0; i < nFaceNum; ++i) 
			{
				const TPipeInterface &iFace=pNode->GetInterface(i);
				OPENOBJ_BEGIN(iFace.m_idPipe, AcDb::kForWrite, TDbPipePrototype, pPipe);
				if(pPipe != NULL)
				{
					// 有时打开管道连接的节点会失败，可传入pNode解决
					pPipe->ResetDrawSpeed(pNode);
				}
				OPENOBJ_END();
			}
			m_bWork = TRUE;
		}
	} else if(dbObj->isKindOf(TDbPipePrototype::desc()) && !dbObj->isKindOf(TDbDuct::desc())) {
	 
        TDbPipePrototype *pWire=(TDbPipePrototype *)dbObj;
		XPoint pt1, pt2;
		if(pWire->GetExtend(pt1,pt2)) {
			UpdateInfo *info=NewAppendUpdateInfo(pWire->GetSysType());
			ASSERT(info!=NULL);
			AcDbObjectId id=dbObj->objectId();
			if(nChangeFlag&OBJ_CHANGE) {//修改管线
				info->AddPipe(id);
			}
		 	if(g_nCmdReactor!=CMD_ATTACHCHANGE){
				UpdateRect(pt1,pt2,m_rectSysUpdate);
				// cet 2013.1.11 add 黏贴时记录更新区域时，使用的实体
				if(IsUpdateSysRect(g_sCurCommand))
				{
					m_setEntIds.insert(dbObj->objectId());
				}

				info->lstVertice.NewAppend(pWire->StartPoint());
				info->lstVertice.NewAppend(pWire->EndPoint());
				if(pWire->m_ptOldStart!=pWire->m_ptOldEnd) {
					info->lstVertice.NewAppend(pWire->m_ptOldStart);
					info->lstVertice.NewAppend(pWire->m_ptOldEnd);

					XPoint ptMin = Min(pWire->m_ptOldStart, pWire->m_ptOldEnd);
					XPoint ptMax = Max(pWire->m_ptOldStart, pWire->m_ptOldEnd);
					if(pWire->IsVertical()) {
						XExtent ex=pWire->GetOldExtent();
						ptMin -= ex;
						ptMax += ex;
					}
					m_rectSysUpdate.lowLeft = Min(ptMin, m_rectSysUpdate.lowLeft);
					m_rectSysUpdate.upRight = Max(ptMax, m_rectSysUpdate.upRight);
				}
				if(nChangeFlag&OBJ_CHANGE && info->lstChangedPipe.Length()<m_nOptimize) {// 管线变化不是由于附件引起的
					if(!info->lstChangedPipe.FindNode(&id,TEntRect::CompareObjectId)) {
						info->lstChangedPipe.Append(new TEntRect(id,pt1,pt2)); //真正变化的管线
					}
				}
			}
		}
	} else if(dbObj->isKindOf(TDbPipeAttachment::desc()))  {
		if(nChangeFlag&OBJ_CHANGE) {
			TDbPipeAttachment *pAttach=(TDbPipeAttachment *)dbObj;
			UpdateInfo *info=NewAppendUpdateInfo(pAttach->GetSysType());
			ASSERT(info!=NULL);
			AcDbObjectId id=dbObj->objectId();
			if(!info->lstAttachment.FindNode(&id, CompareObjectId)) {
				info->lstAttachment.Append(new AcDbObjectId(id));
			}
			XPoint ptLocation=pAttach->GetLocation();
			UpdateRect(ptLocation,ptLocation,m_rectAttachUpdate);
			// cet 2013.1.11 add 黏贴时记录更新区域时，使用的实体
			if(IsUpdateSysRect(g_sCurCommand))
			{
				m_setEntIds.insert(dbObj->objectId());
			}
		}
	}
}

extern AOLAPI Acad::ErrorStatus GetEntFromBlockByClass(DList<AcDbObjectId> &lstObjects,
                    AcRxClass *pClass, int CmpMethod, const TCHAR *pszBlk);

BOOL GetBlkRecordMidPt(const TCHAR* szBlkName, double nScale, double nScaleY, XPoint &pt, double nInsBlkRotate)
{
    AcDbBlockReference *pBlkRef = new AcDbBlockReference();
    AcDbBlockTable* pBlockTable = NULL;
    AcDbObjectId recordId = NULL;
    acdbCurDwg()->getBlockTable(pBlockTable, AcDb::kForRead);
#if ADS > 24
    if(Acad::eOk != pBlockTable->getAt(szBlkName, recordId))
#else
    if(Acad::eOk != pBlockTable->getAt(szBlkName, recordId, AcDb::kForRead))
#endif
        return FALSE;
    pBlockTable->close();
    pBlkRef->setBlockTableRecord(recordId);
    pBlkRef->setPosition(pt);
    pBlkRef->setRotation(nInsBlkRotate);
    pBlkRef->setScaleFactors(AcGeScale3d(nScale, nScaleY, 1));
    AcDbExtents extents;
    pBlkRef->getGeomExtents(extents);
    AcGePoint3d pMax = extents.maxPoint();
    AcGePoint3d pMin = extents.minPoint();
    XPoint ptCen;
    ptCen[0] = (pMax[0] + pMin[0]) / 2;
    ptCen[1] = (pMax[1] + pMin[1]) / 2;
    ptCen[2] = 0;
    
    AcGeMatrix3d mat;
    mat.setToTranslation(AcGeVector3d(ptCen[0] - pt[0], ptCen[1] - pt[1], 0));
    pt.TransformBy(mat);
    delete pBlkRef;
    return TRUE;
}

// 把圆 和 多线段 分解成为 直线和弧线 zxl 2012.10.30 add
void TPipePerDocData::GetMinEntity(std::vector<AcDbObjectId> &vecIds)
{
	int len = m_lstMatchEntity.Length();
    PickSet ss(SS_FREE);
    for(int i=0;i<len;i++)
	{
        AcDbObjectId id = *m_lstMatchEntity[i];
        ads_name entTag;
        acdbGetAdsName(entTag, id);
        Entity tgent = entTag;
        if(tgent.Is(_T("LINE")))
		{
			vecIds.push_back(id);
        }
        else if(tgent.Is(_T("ARC")))
		{
			vecIds.push_back(id);
        }
        else if(tgent.Is(_T("CIRCLE")))
		{
			vecIds.push_back(id);
			XCircle cir(entTag);
			XPoint ptCen = cir.GetCenterPt();
			OPENOBJ_BEGIN(m_idMatchRes, AcDb::kForRead, TDbPipe, pPipe);
            if(pPipe && pPipe->IsVertical())
			{
				XPoint ptS = ptCen;
				XPoint ptE = ptCen;
				ptS.z = pPipe->StartPoint().z;
				ptE.z = pPipe->EndPoint().z;
				AcDbLine *pLine = new AcDbLine;
				pLine->setStartPoint(ptS);
				pLine->setEndPoint(ptE);
				AcDbObjectId idC = AddToCurrentSpace(pLine, Adesk::kTrue);
				vecIds.push_back(idC);
            }
			else
			{
				continue;
			}
            OPENOBJ_END();
		}
        else if(tgent.Is(_T("LWPOLYLINE")))
		{
			XPoly2D poly(entTag);
			ss += id;
			int len = poly.Length();
			for(int m=0;m<len-1;m++)
			{
				XCurveSegment seg;
				poly.Nth(m, seg);
				if(seg.Is(CURVE_ARC))
				{
					AcDbArc *pArc = new AcDbArc;
					XArc arc = seg.GetArc();
					pArc->setStartAngle(arc.GetStarAngle());
					pArc->setEndAngle(arc.GetEndAngle());
					pArc->setCenter(arc.GetCenterPt());
					pArc->setRadius(arc.GetRadius());
					AcDbObjectId idC = AddToCurrentSpace(pArc, Adesk::kTrue);
					vecIds.push_back(idC);
				}
				else
				{
					AcDbLine *pLine = new AcDbLine;
					pLine->setEndPoint(seg.EndPoint());
					pLine->setStartPoint(seg.StartPoint());
					AcDbObjectId idL = AddToCurrentSpace(pLine, Adesk::kTrue);
					vecIds.push_back(idL);
				}
			}
		}
	}
	ss.Erase();
}

// 对点按照x轴大小排序 zxl 2012.10.30 add
bool SortByX(const AcGePoint3d &pt1, const AcGePoint3d &pt2)
{
	if (pt1.x > pt2.x)
	{
		return true;
	}
	return false;
}
// 对点按照y轴大小排序 zxl 2012.10.30 add
bool SortByY(const AcGePoint3d &pt1, const AcGePoint3d &pt2)
{
	if (pt1.y > pt2.y)
	{
		return true;
	}
	return false;
}

// 对弧线上的点 按照其到起点的距离排序 zxl 2012.10.30 add
void ModifyPtsArry(const AcGePoint3dArray &arryPts, AcDbArc &arc1, std::vector<AcGePoint3d> &vecPts)
{
	std::map<double, AcGePoint3d> mapPt;
	double dLen = 0.0;
	for (int i = 0; i < arryPts.length(); i++)
	{
		arc1.getDistAtPoint(arryPts[i], dLen);
		mapPt.insert(std::make_pair(dLen, arryPts[i]));
	}

	std::map<double, AcGePoint3d>::iterator itMap;
	for (itMap = mapPt.begin(); itMap !=mapPt.end(); itMap++)
	{
		vecPts.push_back(itMap->second);
	}
}

// 去掉容器中重复的点 zxl 2012.10.30 add
void CheckPtInVec(std::vector<AcGePoint3d> &vecPts)
{
	std::vector<AcGePoint3d>::iterator it;
	std::vector<AcGePoint3d>::iterator itOther;
	AcGePoint3d ptNow, ptOther;
	for (it = vecPts.begin(); it != vecPts.end();)
	{
		ptNow = *it;
		itOther = it;
		itOther++;
		for (;itOther != vecPts.end(); itOther++)
		{
			ptOther = *itOther;
			if (ptNow.distanceTo(ptOther) < 0.001)
			{
				it = vecPts.erase(it);
				break;
			}
		}
		if (itOther == vecPts.end())
		{
			it++;
		}
	}
}

// 根据各个 直线和弧线 的交点， 重新构造 直线和弧线 zxl 2012.10.30 add
void TPipePerDocData::GetIntsectEntity(const std::vector<AcDbObjectId> &vecIds, std::map<AcDbObjectId, std::vector<AcGePoint3d> > &mapEnt)
{
	std::vector<AcDbObjectId>::const_iterator it;
	std::vector<AcDbObjectId>::const_iterator itSec;
	bool bIsNearXaxis = true;
	for (it = vecIds.begin(); it!= vecIds.end(); it++)
	{
		std::vector<AcGePoint3d> vecPts;
		AcDbObjectId id = *it;
        ads_name entTag;
        acdbGetAdsName(entTag, id);
        Entity tgent = entTag;
        if(tgent.Is(_T("LINE")))
		{
			XLine line(entTag, 1);
			vecPts.push_back(line.GetStartPoint());
			vecPts.push_back(line.GetEndPoint());
			AcGeVector3d vt = line.GetStartPoint() - line.GetEndPoint();
			double dAng2Xaxis = vt.angleTo(AcGeVector3d::kXAxis);
			if (dAng2Xaxis <0)
			{
				dAng2Xaxis += PI*2;
			}
			if ((dAng2Xaxis >= PI/4 && dAng2Xaxis <= 3*PI/4) || (dAng2Xaxis >= 5*PI/4 && dAng2Xaxis <= 7*PI/4))
			{
				bIsNearXaxis = false;
			}
			else
			{
				bIsNearXaxis = true;
			}
			AcGePoint3dArray arryPts;
			for (itSec = vecIds.begin(); itSec != vecIds.end(); itSec++)
			{
				AcDbObjectId idSec = *itSec;
				if (id == idSec)
				{
					continue;
				}
				ads_name entTagSec;
				acdbGetAdsName(entTagSec, idSec);
				Entity tgentSec = entTagSec;
				arryPts.setLogicalLength(0);
				if(tgentSec.Is(_T("LINE")))
				{
					XLine lineSec(entTagSec, 1);
					AcDbLine l1(line.GetStartPoint(), line.GetEndPoint());
					AcDbLine l2(lineSec.GetStartPoint(), lineSec.GetEndPoint());
					Acad::ErrorStatus es = l1.intersectWith(&l2, AcDb::kOnBothOperands, arryPts);	
				}
				else if(tgentSec.Is(_T("ARC")))
				{
					AcDbLine l1(line.GetStartPoint(), line.GetEndPoint());
					XArc arc(entTagSec);
					AcDbArc arc1;
					arc1.setStartAngle(arc.GetStarAngle());
					arc1.setEndAngle(arc.GetEndAngle());
					arc1.setCenter(arc.GetCenterPt());
					arc1.setRadius(arc.GetRadius());
					l1.intersectWith(&arc1,AcDb::kOnBothOperands, arryPts);
				}

				for (int i = 0; i< arryPts.length(); i++)
				{
					vecPts.push_back(arryPts[i]);
				}
			}
			if (bIsNearXaxis)
			{
				std::sort(vecPts.begin(), vecPts.end(), SortByX);
			}
			else
			{
				std::sort(vecPts.begin(), vecPts.end(), SortByY);
			}
		}
		else if(tgent.Is(_T("ARC")))
		{
			XArc arc(entTag);
			XPoint ptS, ptE;
			arc.GetStartPoint(ptS);
			arc.GetEndPoint(ptE);
			vecPts.push_back(ptS);
			AcDbArc arc1;
			arc1.setStartAngle(arc.GetStarAngle());
			arc1.setEndAngle(arc.GetEndAngle());
			arc1.setCenter(arc.GetCenterPt());
			arc1.setRadius(arc.GetRadius());

			AcGePoint3dArray arryPts, arryAllPts;
			for (itSec = vecIds.begin(); itSec != vecIds.end(); itSec++)
			{
				AcDbObjectId idSec = *itSec;
				if (id == idSec)
				{
					continue;
				}
				ads_name entTagSec;
				acdbGetAdsName(entTagSec, idSec);
				Entity tgentSec = entTagSec;
				arryPts.setLogicalLength(0);
				if(tgentSec.Is(_T("LINE")))
				{
					XLine lineSec(entTagSec, 1);
					AcDbLine l2(lineSec.GetStartPoint(), lineSec.GetEndPoint());
					Acad::ErrorStatus es = arc1.intersectWith(&l2, AcDb::kOnBothOperands, arryPts);	
				}
				else if(tgentSec.Is(_T("ARC")))
				{
					XArc arc11(entTagSec);
					AcDbArc arc12;
					arc12.setStartAngle(arc11.GetStarAngle());
					arc12.setEndAngle(arc11.GetEndAngle());
					arc12.setCenter(arc11.GetCenterPt());
					arc12.setRadius(arc11.GetRadius());
					Acad::ErrorStatus es = arc1.intersectWith(&arc12, AcDb::kOnBothOperands, arryPts);
				}
				
				for (int i = 0; i < arryPts.length(); i++)
				{
					arryAllPts.append(arryPts[i]);
				}
			}
			ModifyPtsArry(arryAllPts, arc1, vecPts);
			vecPts.push_back(ptE);
		}
		CheckPtInVec(vecPts);
		mapEnt.insert(std::make_pair(id, vecPts));
	}
}

// 根据交点重新定义匹配实体 zxl 2012.10.29 add
void TPipePerDocData::ModifyMatchEntity(std::map<AcDbObjectId, std::vector<AcGePoint3d> > &mapEnt)
{
	std::vector<AcDbObjectId> vecIds;
	GetMinEntity(vecIds);
	GetIntsectEntity(vecIds, mapEnt);
}

//格式刷
void TPipePerDocData::DoMatchPipe()
{
    if(!g_bIsStartMatchProp)
        return;
	
	std::map<AcDbObjectId, std::vector<AcGePoint3d> > mapEnt;
	ModifyMatchEntity(mapEnt);
	std::map<AcDbObjectId, std::vector<AcGePoint3d> >::iterator itMap;

    int len = m_lstMatchEntity.Length();
    if(len < 1 || m_idMatchRes == NULL)
        return;
    PickSet ss(SS_FREE);
	// 格式刷支持各个直线弧线 多线段 相交时生成多通 的处理 zxl 2012.10.30 modify
    //for(int i=0;i<len;i++){
		//AcDbObjectId id = *m_lstMatchEntity[i];
	for (itMap = mapEnt.begin(); itMap != mapEnt.end(); itMap++)
	{
		AcDbObjectId id = itMap->first;

        ads_name entTag;
        acdbGetAdsName(entTag, id);
        Entity tgent = entTag; 
        if(tgent.Is(_T("LINE"))){
            XLine line(entTag, 1);
            ss += id;
			std::vector<AcGePoint3d>::iterator itPt;
			itPt = itMap->second.begin(); 
			AcGePoint3d ptS = *itPt++;
			AcGePoint3d ptE;
			while (itPt != itMap->second.end())
			{
				ptE = *itPt++;
				OPENOBJ_BEGIN(m_idMatchRes, AcDb::kForRead, TDbPipe, pPipe);
				if(pPipe)
				{
					TDbPipe *pNewPipe = (TDbPipe *)pPipe->clone();
					pNewPipe->SetEndPoint(ptS);
					pNewPipe->SetStartPoint(ptE);
					pNewPipe->ResetAllShip();
					AddToCurrentSpace(pNewPipe, Adesk::kTrue);
				}
				OPENOBJ_END();
				ptS = ptE;
			}
        }
        else if(tgent.Is(_T("ARC"))){
//弧线重新处理 zxl 2012.10.30 modify
//             XArc arc(entTag);
//             ss += id;
//             XPoint ptArcS, ptArcE;
// // 			arc.GetStartPoint(ptArcS);
// // 			arc.GetEndPoint(ptArcE);
//           //  arc.GetPoints(ptArcS, ptArcE);
//             OPENOBJ_BEGIN(m_idMatchRes, AcDb::kForRead, TDbPipe, pPipe);
//             if(pPipe){
//                 TDbPipe *pNewPipe = (TDbPipe *)pPipe->clone();
//                 pNewPipe->SetPoints(ptArcS, ptArcE, arc.Bulge());
//                 pNewPipe->ResetAllShip();
//                 AddToCurrentSpace(pNewPipe, Adesk::kTrue);
//             }
//             OPENOBJ_END();

			XArc arc(entTag);
			AcGePoint3d ptCen = arc.GetCenterPt();
            ss += id;
			std::vector<AcGePoint3d>::iterator itPt;
			itPt = itMap->second.begin(); 
			XPoint ptS = *itPt++, ptE;
			XPoint ptEnd;
			arc.GetEndPoint(ptEnd);

			AcDbArc arc2;
			double dLenArc = 0.0, dLenOld = 0.0;
			arc2.setStartAngle(arc.GetStarAngle());
			arc2.setEndAngle(arc.GetEndAngle());
			arc2.setCenter(arc.GetCenterPt());
			arc2.setRadius(arc.GetRadius());
			arc2.getDistAtPoint(ptEnd, dLenArc);

			while (itPt != itMap->second.end())
			{
				ptE = *itPt++;
				double dMidLen = 0.0;
				arc2.getDistAtPoint(ptE, dMidLen);
				dMidLen -= dLenOld;
				dLenOld += dMidLen;
				OPENOBJ_BEGIN(m_idMatchRes, AcDb::kForRead, TDbPipe, pPipe);
				if(pPipe)
				{
					TDbPipe *pNewPipe = (TDbPipe *)pPipe->clone();
					pNewPipe->SetPoints(ptS, ptE, arc.Bulge() * dMidLen / dLenArc);
					pNewPipe->ResetAllShip();
					AddToCurrentSpace(pNewPipe, Adesk::kTrue);
				}
				OPENOBJ_END();
				ptS = ptE;
			}
        }
        else if(tgent.Is(_T("CIRCLE"))){
			XCircle cir(entTag);
			XPoint ptCen = cir.GetCenterPt();
			double dRadius = cir.GetRadius();
            OPENOBJ_BEGIN(m_idMatchRes, AcDb::kForRead, TDbPipe, pPipe);
            if(pPipe && pPipe->IsVertical()){
				ss += id;
                TDbPipe *pNewPipe = (TDbPipe *)pPipe->clone();
				XPoint ptS = ptCen;
				XPoint ptE = ptCen;
				ptS.z = pPipe->StartPoint().z;
				ptE.z = pPipe->EndPoint().z;
                pNewPipe->SetEndPoint(ptE);
                pNewPipe->SetStartPoint(ptS);
				pNewPipe->SetRadius(dRadius / pPipe->GetPScale());
                pNewPipe->ResetAllShip();
                AddToCurrentSpace(pNewPipe, Adesk::kTrue);
            }
            OPENOBJ_END();
		}
		//多线段 分解为 单个直线 弧线 进行处理 zxl 2012.10.30 del
//         else if(tgent.Is(_T("LWPOLYLINE"))){
// 			XPoly2D poly(entTag);
// 			ss += id;
// 			int len = poly.Length();
// 			for(int m=0;m<len-1;m++){
// 				XCurveSegment seg;
// 				poly.Nth(m, seg);
// 				OPENOBJ_BEGIN(m_idMatchRes, AcDb::kForRead, TDbPipe, pPipe);
// 				if(pPipe){
// 					TDbPipe *pNewPipe = (TDbPipe *)pPipe->clone();
// 					if(seg.Is(CURVE_ARC)){
// 						XArc arc = seg.GetArc();
// 						XPoint ptArcS, ptArcE;
// 						arc.GetStartPoint(ptArcS);
// 						arc.GetEndPoint(ptArcE);
// 					//	arc.GetPoints(ptArcS, ptArcE);
// 						pNewPipe->SetPoints(ptArcS, ptArcE, arc.Bulge());
// 					}
// 					else{
// 						pNewPipe->SetEndPoint(seg.EndPoint());
// 						pNewPipe->SetStartPoint(seg.StartPoint());
// 					}
// 					pNewPipe->ResetAllShip();
// 					AddToCurrentSpace(pNewPipe, Adesk::kTrue);
// 				}
// 				OPENOBJ_END();
// 			}
// 		}
        else if(tgent.Is(_T("INSERT"))){ // 将普通图块刷成上华设备,如果刷源插入点和接线点不一致,刷目标也这么处理
            TCHAR szBlkName[256];
            tgent.GetData(2, szBlkName);
            XPoint ptIns;
            double nAng(0),nScale(0),nScaleY(0);
            tgent.GetData(50, &nAng);
            tgent.GetData(10, ptIns);
            tgent.GetData(41, &nScale);
            tgent.GetData(42, &nScaleY);
            AcDbObjectId idBlk = GetBlockIdFromString(szBlkName);
            XPoint ptMid = ptIns;
            GetBlkRecordMidPt(szBlkName, nScale, nScaleY, ptMid, nAng);
            OPENOBJ_BEGIN(m_idMatchRes, AcDb::kForRead, TDbWell, pWell);
            if(pWell){
                ss += id;
                AcDbObjectId id2 = pWell->GetBlock2d();
                CString csBlkName2 = GetSymbolName(id2).cs();
                XPoint ptIns2 = pWell->GetLocation();
                XPoint ptMid2 = ptIns2;
                GetBlkRecordMidPt(csBlkName2, 1, 1, ptMid2, 0);
                TDbWell *pNewEq = (TDbWell *)pWell->clone();
                pNewEq->SetBlock2d(idBlk);
                pNewEq->SetBlock3d(NULL);
                pNewEq->SetScale(fabs(nScale) / 100);
                if(nScale < 0)
                    pNewEq->MirrorByY(TRUE);
                if(nScaleY < 0)
                    pNewEq->MirrorByX(TRUE);
                pNewEq->SetAngle(nAng);
                pNewEq->SetInsert(ptIns);
                if(ptIns2 == ptMid2)
                    pNewEq->SetLocation(ptIns);
                else
                    pNewEq->SetLocation(ptMid);
                pNewEq->SetLabelLocation(XPoint());
                pNewEq->EnableDrawLabel(TRUE, 1.5);
                AddToCurrentSpace(pNewEq, Adesk::kTrue);
                continue;
            }
            OPENOBJ_END();
            OPENOBJ_BEGIN(m_idMatchRes, AcDb::kForRead, TDbEquipment, pEquip);
            if(pEquip){
                ss += id;
                AcDbObjectId id2 = pEquip->GetBlock2d();
                CString csBlkName2 = GetSymbolName(id2).cs();
                XPoint ptIns2 = pEquip->GetLocation();
                XPoint ptMid2 = ptIns2;
                GetBlkRecordMidPt(csBlkName2, 1, 1, ptMid2, 0);
                TDbEquipment *pNewEq = (TDbEquipment *)pEquip->clone();
                pNewEq->SetBlock2d(idBlk);
                pNewEq->SetBlock3d(NULL);
                pNewEq->SetScale(fabs(nScale) / pEquip->GetPScale() * 100);
                if(nScale < 0)
                    pNewEq->MirrorByY(TRUE);
                if(nScaleY < 0)
                    pNewEq->MirrorByX(TRUE);
                pNewEq->SetAngle(nAng);
                pNewEq->SetInsert(ptIns);
                if(ptIns2 == ptMid2)
                    pNewEq->SetLocation(ptIns);
                else
                    pNewEq->SetLocation(ptMid);
                AddToCurrentSpace(pNewEq, Adesk::kTrue);
            }
            OPENOBJ_END();
        }
    }
    ss.Erase();
}
GEOAPI double g_nAcadVer;


Acad::ErrorStatus AssureInCurrentView_New(const XPoint &ptLow, const XPoint &ptUp)
{
    XPoint lowCorner, upCorner;
    AT_ScrCorner(lowCorner, upCorner);
    XPoint pt1=ptLow, pt2=ptUp;
    pt1.z=pt2.z=lowCorner.z;
    XPoint ptMin=Min(pt1, lowCorner), ptMax=Max(pt2, upCorner);
    Acad::ErrorStatus es=Acad::eNotApplicable;
    if(ptMin!=lowCorner || ptMax!=upCorner)  
	{ //点不在屏幕当前视图之内
		
		//2004下UCS, AssureInCurrentView运行特别慢 2009-8-12 sr
		BOOL bIsUcs = FALSE;
		XPoint ptUcsLow = Wcs2Ucs(ptLow);
		XPoint ptUcsUp = Wcs2Ucs(ptUp);
		if(ptUcsLow != ptLow && ptUcsUp != ptUp)
			bIsUcs = TRUE;
		
		if(bIsUcs)
			SHads_command(RTSTR, _T("ZOOM"), RTSTR, _T("W"), RT3DPOINT, &ptUcsLow, RT3DPOINT, &ptUcsUp, RTNONE);
		else
			AssureInCurrentView(ptLow, ptUp);
		
        
    }
    return es;
}

extern BOOL WriteXdata(AcDbEntity *pEnt, const TCHAR*szName, const TCHAR*szValue);

//优化SUBCLOSE, 将可能产生subClose无限调用的功能，转移到命令反应器执行
void TPipePerDocData::ResetCloseEntity()
{
	int len = m_lstCloseEntity.Length();
    if(len < 1)
        return;
    PickSet ss(SS_FREE);
    for(int i=0;i<len;i++)
	{
        AcDbObjectId id = *m_lstCloseEntity[i];
		// cet 2014.8.5 add 判断id有效性，避免崩溃发生（2014.8.5 jzh反馈图崩溃）
		if (!id.isValid() || id.isErased())
		{
			continue;
		}
		ads_name entTag;
        acdbGetAdsName(entTag, id);
        Entity tgent = entTag; 
        if(tgent.Is(_T("ATS_VPIPEDIM"))) // 移动立管标注后，重新绑定立管
		{
			XPoint ptStart, ptTurn, ptPipeStart;
			CString sFloorNum,sNum;
			CString sMarkText; // cet 2014.6.20 add 代号信息
			AcDbObjectId idPipe = NULL;
			OPENOBJ_BEGIN(tgent, AcDb::kForRead, TDbVPipeDim, pDim);
			if(pDim) 
			{
				ptStart = pDim->GetStartPt();
				ptTurn = pDim->GetTurnPt();
				pDim->GetNullIdFloorNum(sFloorNum);
				pDim->GetNullIdNum(sNum);
				pDim->GetDimTypeText(sMarkText); // cet 2014.6.20 add 代号信息
				idPipe = pDim->GetVPipeId();
			}
			OPENOBJ_END();
			OPENOBJ_BEGIN(idPipe, AcDb::kForRead, TDbPipe, pPipe);
			if(pPipe && pPipe->IsVertical()) 
			{
				ptPipeStart = pPipe->StartPoint();
				ptPipeStart.z = 0;
			}
			OPENOBJ_END();
			if(ptPipeStart != ptStart || idPipe == NULL)//如果发现立管标注所绑定的管线位置发生变化，则进行重新绑定
			{
				ptStart = Wcs2Ucs(ptStart);
				ptTurn = Wcs2Ucs(ptTurn);

				RBList rbMak(RTDXF0, _T("ATS_PIPE"),NULL);
				PickSet ssSel(SS_FREE);
				XPoint ptTmp = ptStart;
				AcGeVector3d vt(ptTurn-ptStart);
				vt.normalize();
				vt *= 200;
				ptTmp += vt;
				struct resbuf *pointlist = ads_buildlist(RTPOINT, &ptStart, RTPOINT, &ptTmp, NULL); 
				AssureInCurrentView_New(Ucs2Wcs(ptStart), Ucs2Wcs(ptTmp));
				ssSel.Get(_T("F"),pointlist,NULL,rbMak);
				ads_relrb(pointlist);
				
				AcGePoint3d ptST;
				AcDbObjectId idVPipe;
				AcDbObjectId id;
				for (long i = 0; i < ssSel.Length(); ++i)
				{
					OPENOBJ_BEGIN(ssSel[i], AcDb::kForRead, TDbPipe, pPipe);
					if(pPipe && pPipe->IsVertical()) 
					{
						XPoint ptS = pPipe->StartPoint();
						ptS.z = 0;
//						cet 2016.12.8 modify 两点比较有时误差稍大
// 						if(ptS != Ucs2Wcs(ptStart)) //ssSel.Length()=1才对，偶尔会碰到其他立管，应该过滤一下
// 							continue;
						if(ptS.Distance2d(Ucs2Wcs(ptStart)) > 0.001)
						{
							continue;
						}
						id = pPipe->objectId();	
						// cet 2014.6.20 add 将标注中的代号信息赋予管线
						if (pPipe->upgradeOpen() == Acad::eOk)
						{
							WriteXdata(pPipe, _T("PIPE-MARK"), sMarkText);
							pPipe->downgradeOpen();
						}
					}
					OPENOBJ_END();

					OPENOBJ_BEGIN(tgent, AcDb::kForWrite, TDbVPipeDim, pDim);
					if(pDim) 
					{
						pDim->SetVPipeId(id);
						pDim->SetDimVPipeNum(sNum, id);
						pDim->SetVPipeFloorNum(sFloorNum, id);
					}
					OPENOBJ_END();
				}
				if(ssSel.Length() < 1)
				{
					OPENOBJ_BEGIN(tgent, AcDb::kForWrite, TDbVPipeDim, pDim);
					if(pDim) 
					{
						pDim->SetVPipeId(NULL);
					}
					OPENOBJ_END();
				}
				
			}



		}
		else if(tgent.Is(_T("ATS_PIPE"))) //修改管线标高，更新前后立管标高
		{
			OPENOBJ_BEGIN(tgent, AcDb::kForRead, TDbPipe, pPipeMain);
			if(pPipeMain) 
			{
				for(int i=0; i<2; i++) {

					AcDbObjectId idNode=pPipeMain->GetNode(i);
					OPENOBJ_BEGIN(idNode,AcDb::kForRead,TDbPipeNode,pNode);
					if(pNode!=NULL) { // 节点
						if(!pNode->IsAutoLiving()) // 需自动生成的节点
							continue;
						
						int nPipeNum=pNode->GetInterfaceNum();
						if(nPipeNum > 2)//sr add 2004/9/15 当一根立管上有接2根不等高支管，当把底管标高升高超过高管，立管会出错
							continue;
					 
						int nVerNum=pNode->GetVerPipeNum();
						if(nVerNum == 0)
							continue;
						if(nPipeNum-nVerNum > 1)
							continue;
						
						for(int j=0; j<nPipeNum; j++) { // 接口
							const AcDbObjectId &idPipe=pNode->GetIPipe(j);
							if(idPipe != pPipeMain->objectId()) {
								
								OPENOBJ_BEGIN(idPipe,AcDb::kForRead,TDbPipePrototype,pPipe);
								if(pPipe != NULL) {
									if(pPipe->IsVertical()) { //立管
										
										//立管两端都连接管线
										if(!pPipe->IsBothPipesOk())
											continue;
										
										//sr modify 2004/10/19  如果立管有一端接2根以上管线
										for(int m=0; m<2; m++) {
											AcDbObjectId idNodeTmp=pPipe->GetNode(m);
											if(idNodeTmp == idNode)
												continue;
											OPENOBJ_BEGIN(idNodeTmp,AcDb::kForRead,TDbPipeNode,pNodeTmp);
											if(pNodeTmp!=NULL) { // 节点
												int nPipeNumTmp = pNodeTmp->GetInterfaceNum();
												if(nPipeNumTmp > 2){
													XPoint ptNode1 = pNode->GetLocation();
													XPoint ptNode2 = pNodeTmp->GetLocation();
													XVector3D vec1 = ptNode1 - ptNode2;
													ptNode1.z = pPipeMain->StartPoint().z;
													XVector3D vec2 = ptNode1 - ptNode2;
													vec1.Normalize();
													vec2.Normalize();
													//当前要联动的立管，另一端接2根以上管线，如果修改之后方向与之前一致，允许修改；否则不允许修改
													if(vec1 != vec2)
														return;
												}
											}
											OPENOBJ_END();
										}
										// sr modify 2004/10/19 //////////////////////////////////////////////////////////////////////////////
										
										
										
										// 改变立管的标高
										XPoint &ptStart = pPipe->StartPoint();
										XPoint &ptEnd = pPipe->EndPoint();
										const XPoint &ptNode = pNode->GetILocation(j);
										
										// 改变立管的标高
										XPoint &ptThisSide = (i==0) ? pPipeMain->StartPoint() : pPipeMain->EndPoint();
										if(ptNode==ptStart) {
											if(pPipe->upgradeOpen()==Acad::eOk) {
												pPipe->assertWriteEnabled();
												ptStart.z = ptThisSide.z;
												pPipe->downgradeOpen();
											}
										}
										else if(ptNode==ptEnd) {
											if(pPipe->upgradeOpen()==Acad::eOk) {
												pPipe->assertWriteEnabled();
												ptEnd.z = ptThisSide.z;
												pPipe->downgradeOpen();
											}
										}
									}
								}
								OPENOBJ_END();
							}
						}
					}
					OPENOBJ_END();
				}
			}
			OPENOBJ_END();
			
		}
	}
	
	m_lstCloseEntity.Reset();
}
   
void TPipePerDocData::ApplyUpdates()
{
	if(!m_bWork)
		m_lstCloseEntity.Reset();

    if(!m_bWork || !g_bDwgBegin || !acdbCurDwg()) 
		return;
    ResetCloseEntity();

	// cet 2015.7.3 add 初始化管线系统索引初始值
	PipeSystemProcessor::InitSysInedex();

	// cet 2013.1.10 add 黏贴时重新计算更新区域
	CalcUpdateSysRect();

	XPushMemVar<BOOL> vAction(g_bMonitorDbAction, FALSE);
	XPushMemVar<int> vReactor(g_nCmdReactor,CMD_UPDATE);
	m_rectAttachUpdate.SetElevation(0);
	m_rectSysUpdate.SetElevation(0);

	BOOL bUpdateSys = !IsRectEmpty(m_rectSysUpdate);
	DList<TEntRect>  lstUpdatePipe;// 更新区域(扩大了搜索范围)内的管线
	
	if(bUpdateSys) {// 更新管线与管线、管线与节点的关系
		UpdateSystem(lstUpdatePipe);
	}
	
	// 重新验证管线与所属的附件的关系
	BOOL bLess=ExtendInBox2d(m_rectAttachUpdate.lowLeft,m_rectAttachUpdate.upRight,m_rectSysUpdate);
	if(bLess)	m_rectAttachUpdate=m_rectSysUpdate;
	if(!bUpdateSys || !bLess)
		ValidateAttachships();
	else 
		ValidateAttachships(&lstUpdatePipe);

	ResetDocCmdGlobals();
}

// 更新管线系统管线与节点关系（同时更新pipe和rect）
void TPipePerDocData::UpdateSystem(DList<TEntRect> &lstUpdatePipe)
{
	XRectAngle rectUpdate=m_rectSysUpdate;//需要重新验证遮挡关系的区域
	GetEntRectFromBlock(lstUpdatePipe,TDbPipePrototype::desc(),m_rectSysUpdate);

	BOOL bOptimize = GetChangedNum()>m_nOptimize;	//是否优化
	DList<TNodeLocation> lstUpdateNode;// 更新区域(扩大了搜索范围)内的节点
	if(!bOptimize) {
		GetNodeFromBlock(lstUpdateNode,m_rectSysUpdate);		
		DoDeepSearch(lstUpdatePipe,lstUpdateNode,rectUpdate);

	}
   
	// 更新管线与管线、管线与节点的关系
	for(int i=0; i<m_lstUpdate.Length(); i++) {// Update Corners
        UpdateInfo *info=m_lstUpdate[i];
		if(info->NeedUpdateSys()) {
			//if(i>0 || (i==0&&bOptimize)) { // 节点更新
				GetNodeFromBlock(lstUpdateNode,m_rectSysUpdate);
		//	}
			ModifyPipeAtCorner(info,lstUpdatePipe,lstUpdateNode,bOptimize);
		}
	}

	// 处理更新后的管线和节点的管线关系
	GetEntRectFromBlock(lstUpdatePipe,TDbPipePrototype::desc(),rectUpdate);
	ValidateHideships(lstUpdatePipe,rectUpdate);
	UpdatePoolAngle(lstUpdatePipe); // cet 2016.4.27 add 更新化粪池角度
	UpdatePipePoints(lstUpdatePipe);// cet 2016.4.26 add 更新管道端点，以便与端点处的化粪池等相连
	UpdateWellInfo(lstUpdatePipe);  // cet 2016.9.6 add 更新井数据
	ResetDrawSpeed(lstUpdatePipe);//如果涉及到非管线和节点时，应考虑放到适当的位置
}

// 重新验证管线与所属的附件的关系
void TPipePerDocData::ValidateAttachships(const DList<TEntRect>* pPipes) const
{
	// 一、更新管线：验证管线与附件的配属关系
	for(int n=0; n<m_lstUpdate.Length(); n++) {
		const UpdateInfo& info=m_lstUpdate[n];
		for(int i=0; i<info.lstAttachPipe.Length(); i++) {
			const AcDbObjectId &id = info.lstAttachPipe[i];
			OPENOBJ_BEGIN(id, AcDb::kForWrite, TDbPipePrototype, pPipe);
			if(pPipe)
				pPipe->ValidateAttachship();   
			OPENOBJ_END();
		}
	}

	// 二、更新附件：验证管线和附件的配属关系
	// 1、验证原有的管线和附件的配属关系
	DList<AcDbObjectId> lstAttachment;
	for(n=0; n<m_lstUpdate.Length(); n++) {
		const UpdateInfo& info=m_lstUpdate[n];
		for(int i=0; i<info.lstAttachment.Length(); i++) {
			const AcDbObjectId &id = info.lstAttachment[i];
			OPENOBJ_BEGIN(id,AcDb::kForWrite,TDbPipeAttachment,pAttach);
			if(pAttach!=NULL) {
				if(!pAttach->ValidateAttachship()) {
					lstAttachment.Append(new AcDbObjectId(pAttach->objectId()));
				}
			}
			OPENOBJ_END();
		}
	}
	// 2、验证还没有配属的附件与管线的关系
	int nAttach=lstAttachment.Length();
	if(nAttach>0) {
		// 加速：边框相交才验证管线和附件的关系
		DList<TEntRect> lstAttachPipe;//附件变化区域的管线
		BOOL bReConstruct = pPipes==NULL;
		if(bReConstruct) {
			GetEntRectFromBlock(lstAttachPipe,TDbPipePrototype::desc(),m_rectAttachUpdate);
		}
	//	DList<TEntRect> &lstUpdatePipe = bReConstruct ? lstAttachPipe : * pPipes;	// sr removed 2006-7-3
		DList<TEntRect> &lstUpdatePipe = bReConstruct ? lstAttachPipe : *((DList<TEntRect>*)pPipes);	
		

		int nPipe=lstUpdatePipe.Length();//管线数
		double dExtents=_distSnap*500;//简化处理不是采用GetExtents
		XPoint ptExtents(dExtents,dExtents,0);

		for(int i=0; i<nAttach; i++) {
			OPENOBJ_BEGIN(*lstAttachment[i],AcDb::kForWrite,TDbPipeAttachment,pAttach);
			if(pAttach!=NULL) {
				XPoint ptLocation=pAttach->GetLocation();
				XRectAngle rcAttach(ptLocation-ptExtents,ptLocation+ptExtents);
				for(int j=0; j<nPipe; j++) {
					TEntRect &pipeRect=*lstUpdatePipe[j];
					if(pipeRect.Intersect(rcAttach)) {
						pAttach->ValidateAttachship(pipeRect.id);
					}
				}
			}
			OPENOBJ_END();
		}
	}
	/*for(n=0; n<m_lstUpdate.Length(); n++) {
		UpdateInfo *info=m_lstUpdate[n];
        DStack<AcDbObjectId> lstPipe;
		for(int i=0; i<lstUpdatePipe.Length(); i++) {
			AcDbObjectId *pId=lstUpdatePipe[i];
			OPENOBJ_BEGIN(*pId, AcDb::kForRead, TDbPipePrototype, pPipe);
			if(pPipe!=NULL) {
				if(pPipe->GetSysType()==info->sysType)
					lstPipe.Append(pId);
			}
			OPENOBJ_END();
		}
		for(i=0; i<info->lstAttachment.Length(); i++) {
			AcDbObjectId &id = *info->lstAttachment[i];
			OPENOBJ_BEGIN(id, AcDb::kForWrite, TDbPipeAttachment, pAttach);
			if(pAttach!=NULL) {
				//pAttach->ValidateAttachship(lstPipe);//管线和附件的配属关系
				if(pAttach->IsCheckSysType())
					pAttach->ValidateAttachship(lstPipe);
				else
					pAttach->ValidateAttachship(lstUpdatePipe);
			}
			OPENOBJ_END();
		}
	}*/
}

// 重新初始化显示加速，目前只有管线二维加速（目前只有节点和管线有关）
void TPipePerDocData::ResetDrawSpeed(const DList<TEntRect> &lstPipe) const
{
	int nCount = lstPipe.Length();
	for(int i=0; i<nCount; i++) {
		OPENOBJ_BEGIN(lstPipe[i].id,AcDb::kForWrite,TDbPipePrototype,pPipe);
		if(pPipe!=NULL) {
			pPipe->ResetDrawSpeed();
		}
		OPENOBJ_END();
	}
}

// 重新验证调整遮挡关系
void TPipePerDocData::
ValidateHideships(const DList<TEntRect> &lstPipe,const XRectAngle &rectUpdate) const
{
//	rectUpdate.Make();
	DList<TEntRect> lstPipe0;
	int nCount = lstPipe.Length();
	for(int i=0; i<nCount; i++) {
		const TEntRect& pipeRect=lstPipe[i];
		OPENOBJ_BEGIN(pipeRect.id,AcDb::kForWrite,TDbPipePrototype,pPipe);
		if(pPipe!=NULL) {
			if(!pPipe->IsVertical()/* && pPipe->Is(CURVE_LINE)*/) {
				lstPipe0.Append(new TEntRect(pipeRect));
				if(pipeRect.InBox(rectUpdate))
					pPipe->RemoveHidePipes();// 区域内删除所有的遮挡关系，重新建立
				else 
					pPipe->RemoveHidePipes(&rectUpdate);// 仅删除区域内的遮挡关系
			} else {
				pPipe->RemoveHidePipes();
			}
		}
		OPENOBJ_END();
	}

	// 确定区域内管线的相互遮挡关系
	nCount = lstPipe0.Length();
	for(i=0; i<nCount; i++) {
		TEntRect& iPipe=*lstPipe0[i];
		OPENOBJ_BEGIN(iPipe.id,AcDb::kForWrite,TDbPipePrototype,pPipe);
		if(pPipe!=NULL) {
			for(int j=i+1; j<nCount; j++) {
				TEntRect& jPipe=*lstPipe0[j];
				if(iPipe.Intersect(jPipe))
					pPipe->ValidateHideship(jPipe.id);
			}
		}
		OPENOBJ_END();
	}
}

void TPipePerDocData::AttachReactor()
{
    ASSERT(m_pDoc);
    if(!m_pDbReactor) {
        AcDbDatabase *pDb=m_pDoc->database();
        ASSERT(pDb!=NULL);
        m_pDbReactor=new TPipeDbReactor;
        pDb->addReactor(m_pDbReactor);
    }  
    if(!m_pInputReactor) {
        m_pInputReactor = new TPipeInputReactor;
        m_pDoc->inputPointManager()->addInputContextReactor(m_pInputReactor);
    }    
}

void TPipePerDocData::DetachReactor()
{
    ASSERT(m_pDoc);
    AcDbDatabase *pDb=m_pDoc->database();
    if(!pDb) return;
    if(m_pDbReactor) {
        pDb->removeReactor(m_pDbReactor);
        delete m_pDbReactor;
        m_pDbReactor=NULL;
    }
    if(m_pInputReactor) {
        m_pDoc->inputPointManager()->removeInputContextReactor(m_pInputReactor);
        delete m_pInputReactor;
        m_pInputReactor=NULL;
    }
}

int TPipePerDocData::CompareForFind(const TPipePerDocData *pDoc1, const void *pDoc2)
{
	ASSERT(pDoc1 && pDoc2);
	if(pDoc1->m_pDoc==pDoc2)
		return 0;
	return 1;
}
// End TPipePerDocData
/////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////
// TPipeAppDocGlobals
TPipeAppDocGlobals::TPipeAppDocGlobals() 
{ 
    m_pDocReactor = new TPipeDocReactor(); 
    acDocManager->addReactor(m_pDocReactor); 
} 

void TPipeAppDocGlobals::InitDocGlobals(AcApDocument *pDoc) 
{
#if ADS > 19
	if (NULL == pDoc) return ; // 2016-6-20 cq pDoc为NULL会弹出断言 CAD2016平台关闭最后一个文档 默认激活一个 NULL 文档 没有意义 (Autodesk内部没有处理)
#endif
    ASSERT(pDoc);
    TPipePerDocData *pData=g_pTPipeAppDocGlobals->FindNode(pDoc, TPipePerDocData::CompareForFind);
    if(!pData)
        g_pTPipeAppDocGlobals->Append(new TPipePerDocData(pDoc));
} 

void TPipeAppDocGlobals::RemoveDocGlobals(AcApDocument *pDoc) 
{
    ASSERT(pDoc);
    TPipePerDocData *pData=g_pTPipeAppDocGlobals->FindNode(pDoc, TPipePerDocData::CompareForFind);
    if(pData) {
        pData->DetachReactor();
        g_pTPipeAppDocGlobals->Remove();
    }
} 

void TPipeAppDocGlobals::OnUnloadApp() 
{ 
    if(m_pDocReactor) {
        acDocManager->removeReactor(m_pDocReactor); 
        delete m_pDocReactor; 
        m_pDocReactor=NULL;
    }
} 

void InitAppDocGlobals(BOOL bTrue)
{
	if(bTrue) {
		ASSERT(g_pTPipeAppDocGlobals==NULL);
        g_pTPipeAppDocGlobals = new TPipeAppDocGlobals(); 
        g_pTPipeAppDocGlobals->InitDocGlobals(curDoc()); 
	} else {
		ASSERT(g_pTPipeAppDocGlobals!=NULL);
        g_pTPipeAppDocGlobals->OnUnloadApp(); 
        delete g_pTPipeAppDocGlobals; 
        g_pTPipeAppDocGlobals = NULL; 
	}
}

//////////////////////////////////////
// 取得当前文档的全局变量
TPipePerDocData * GetCurPipeDocData()
{
    if(!g_pTPipeAppDocGlobals)
        return NULL;
    TPipePerDocData *pData=g_pTPipeAppDocGlobals->FindNode(curDoc(), TPipePerDocData::CompareForFind);
    //ASSERT(pData);
    return pData;
}

/********************* XDbWallCmdReacotor ******************************/
// Global definition
TPipeCmdReactor * TPipeCmdReactor::g_pCmdReactor=NULL;

TPipeCmdReactor::TPipeCmdReactor()
{
   ASSERT(g_pCmdReactor==NULL);
   g_pCmdReactor=this;
}

TPipeCmdReactor::~TPipeCmdReactor()
{
}

// 建立命令的监测
void TPipeCmdReactor::Attach()
{ 
	if(!g_pCmdReactor)
		acedEditor->addReactor(new TPipeCmdReactor()); 
}

// 除去命令的监测
void TPipeCmdReactor::Detach()
{
   if(g_pCmdReactor) {
      acedEditor->removeReactor(g_pCmdReactor);
      delete g_pCmdReactor; 
      g_pCmdReactor=NULL;
   }
}

void TPipeCmdReactor::ResetAll()
{
    TPipePerDocData *pData = GetCurPipeDocData();
    //ASSERT(pData);
	if(pData) {
        pData->ResetDocCmdGlobals();
		pData->EnableWork(TRUE);
	}
}

void TPipeCmdReactor::lispWillStart(const TCHAR * firstLine)
{
    if(_tcsicmp(firstLine, _T("!")) == 0)
        return;
    ASSERT(firstLine && _tcslen(firstLine)>=3);
    XString sLispExpr;
    sLispExpr=firstLine;
    _tcsupr(sLispExpr);
	if(sLispExpr[1]==_T('C') && sLispExpr[2]==_T(':')) {
       TCHAR &cLast=sLispExpr[sLispExpr.Length()-1]; // remove right ')'
       cLast=EOS;
       BeginUserCommand(&sLispExpr[3], FALSE);
    } else {
        //BeginUserCommand(NULL, FALSE);
    }
}

void TPipeCmdReactor::lispEnded() 
{
	// 适当的放掉一些命令，如改变比例，可以提速
	//...
    XString sCmdNames;
    VERIFY(xg_getvar(_T("CMDNAMES"), sCmdNames)==RTNORM);
    if(!sCmdNames) {
	    EndUserCommand(NULL, FALSE);
	}
}

// 双击监测 zxl 2013.12.12 add
void TPipeCmdReactor::beginDoubleClick(const AcGePoint3d& clickPoint)
{
	RBList rbMask(RTDXF0, _T("ATS_SPACE"), NULL);
	PickSet ss(SS_FREE);
	ss.Get(_T("X"), NULL, NULL, rbMask);
	ss.Redraw(4);
	
	AcEditorReactor::beginDoubleClick(clickPoint);
}

void TPipeCmdReactor::endWblock( AcDbDatabase* pTo )
{
	AcEditorReactor::endWblock(pTo);
	// 执行wblock命令时无法自动将TDbPsConfig存在新数据库中
	// 通过以下函数实现此操作，以保证线宽等设置在新数据
	// 库中仍然有效 cet 2014.12.11 add
	InitConfigToNewDatabase(pTo);
}


//得到本图图块记录列表
void GetCurBlkRecList(XStringList &lstBlk)
{
	AcDbBlockTable* pBlockTable = NULL;
	acdbCurDwg()->getBlockTable(pBlockTable, AcDb::kForRead);
	AcDbBlockTableIterator* pBlockIterator=NULL;
	Acad::ErrorStatus es = pBlockTable->newIterator(pBlockIterator);
	ASSERT(es==Acad::eOk && pBlockIterator!=NULL);
	for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
	{
		AcDbBlockTableRecord *pRec=NULL;
		if(pBlockIterator->getRecord(pRec, AcDb::kForRead)==Acad::eOk && pRec) 
		{
			TCHAR *str = NULL;
			pRec->getName(str);
			CString csRecordName = str;

			if(csRecordName.Find(_T("*")) < 0 && csRecordName != _T("_ArchTick"))
			{
				lstBlk.Append(tstrnew(csRecordName));
			}
			delete str;
			pRec->close();
		}
	}	
	delete pBlockIterator;
	pBlockTable->close();			
}

void DoClipboardRenameBlk()
{
	if (OpenClipboard(NULL))
	{
		
		UINT nStart = 0;
		TCHAR szName[256];
		while(TRUE)
		{
			nStart  = EnumClipboardFormats(nStart);
			if (nStart == 0)
				break;
			
			GetClipboardFormatName(nStart,szName,256);

			CString csAcadFormat;
			#if (ADS==18)
				csAcadFormat = _T("AutoCAD.r18");
			#elif (ADS==17)
				csAcadFormat = _T("AutoCAD.r17");
			#elif (ADS==16)
				csAcadFormat = _T("AutoCAD.r16");
			#elif (ADS==15)
				csAcadFormat = _T("AutoCAD.r15");
			#endif
			
			
			if (_tcscmp(szName, csAcadFormat) == 0)//其他16,17,18 ...
			{

				AcApDocument *pDoc=curDoc();
				CString csCurFile = pDoc->fileName();
					
				HANDLE hClipboardData = GetClipboardData(nStart);
				ClipboardInfo *pchData = (ClipboardInfo*)GlobalLock(hClipboardData);
				CString csTempFile = pchData->szTempFile;
				CString csSourceFile = pchData->szSourceFile;
				if(csCurFile == csSourceFile || csTempFile == _T("") || csSourceFile == _T("")) //本图内复制
					break;
				CString csFileName = GetFileName(XString(csSourceFile));
			 
				int idx2 = csFileName.Find(_T("."));
				if(idx2 > -1)
				{//发现了，都去掉.后缀
					csFileName = csFileName.Left(idx2);
				}
				
				
				AcDbDatabase dwgDb(false, true);
#if ADS > 20
				if(dwgDb.readDwgFile((const TCHAR*)csTempFile, AcDbDatabase::OpenMode::kForReadAndAllShare, false)!=Acad::eOk)
					break;
#else
				if (dwgDb.readDwgFile((const TCHAR*)csTempFile, _SH_DENYNO, false) != Acad::eOk)
					break;
#endif
				// modify by cq 2017-01-04 支持CAD2017
				XStringList lstBlkRec;
				GetCurBlkRecList(lstBlkRec);
				AcDbBlockTable *pBlockTable = NULL;
				Acad::ErrorStatus es = dwgDb.getBlockTable(pBlockTable, AcDb::kForRead);
				if(!pBlockTable)
					break;
				ASSERT(es==Acad::eOk);
				AcDbBlockTableIterator* pBlockIterator=NULL;
				es = pBlockTable->newIterator(pBlockIterator);
				ASSERT(es==Acad::eOk && pBlockIterator!=NULL);
				for (pBlockIterator->start();  !pBlockIterator->done();   pBlockIterator->step()) 
				{
					AcDbBlockTableRecord *pRec=NULL;
					if(pBlockIterator->getRecord(pRec, AcDb::kForWrite)==Acad::eOk && pRec) 
					{
						TCHAR *str = NULL;
						pRec->getName(str);
						CString csRecordName = str;
						delete str;
						if(csRecordName.Find(_T("*")) < 0 && csRecordName.Find(_T("_")) < 0 && csRecordName.Find(_T("-")) < 0 && csRecordName.Find(_T("$")) < 0 )//2011-6-24 sr 忽略上华$图块
						{
							if(lstBlkRec.Index(csRecordName) > -1)
							{
								TCHAR chText[256];
								CString csTmp;
								csTmp.Format(_T("\n发现【%s】同名图块，是否忽略？[全部忽略(1)/本块忽略(2)/图块改名(3)]<全部忽略>: "), csRecordName);
								ads_getstring(NULL, csTmp, chText);
								if(_tcsicmp(chText, _T("1")) == 0 || _tcsicmp(chText, _T("")) == 0)
								{
									pRec->close();
									break;
								}
								if(_tcsicmp(chText, _T("3")) == 0)
								{
									CString csNewBlkName = csFileName + _T("-") + csRecordName;
									pRec->setName(csNewBlkName);
								}
							}
						}
						pRec->close();
					}
				}	
				delete pBlockIterator;
				pBlockTable->close();
				dwgDb.saveAs(csTempFile);
				break;
			}
		}
		CloseClipboard();
	}
}

#ifdef RECORD_CMD_TIME
extern void RecordCmdTime(const CString &sCmd); // cet 2012.4.23 add 统计命令执行次数
#endif

// 命令开始时初始化  2011-5-9 sr 增加复制粘贴重名块的问题
void TPipeCmdReactor::commandWillStart(const TCHAR * cmdStr)
{
	#ifdef RECORD_CMD_TIME
	RecordCmdTime(cmdStr); // cet 2012.4.23 add 统计命令执行次数
	#endif
    int nCmdActive=0;
    xg_getvar(_T("CMDACTIVE"), &nCmdActive);
    if(nCmdActive==1) {
        BeginUserCommand(cmdStr, TRUE);
        if(_tcsicmp(cmdStr, _T("matchprop"))==0)  { 
            g_bIsStartMatchProp = FALSE;
            long len = g_ssPickFirst.Length();
            if(len == 1){
                Entity ent = g_ssPickFirst[0L];
                if(ent.Is(_T("ATS_PIPE")) || ent.Is(_T("ATS_EQUIPMENT")) || ent.Is(_T("ATS_WELL"))){
					g_bIsStartMatchProp = TRUE;
					AcDbObjectId id;
					acdbGetObjectId(id, ent);
					TPipePerDocData *pData = GetCurPipeDocData();
					if(pData) 
						pData->m_idMatchRes = id;
                }
            }
            else
                g_bIsStartMatchProp = TRUE;
        }
		else if(_tcsicmp(cmdStr, _T("PASTECLIP"))==0 &&  g_nProductId == 14) // 粘贴  只有给排水软件有效
		{
			DoClipboardRenameBlk();
		}
    }
}
  
PickSet & DocGetPickGrip2()
{
    TPipePerDocData *p=GetCurPipeDocData();
    ASSERT(p); 
	PickSet ee;
    if(p!=NULL)
        return p->m_ssPickGrip;
    else
        return ee;
}

 
void TPipeCmdReactor::pickfirstModified()
{
	int cvport=0;
    xg_getvar(_T("CVPORT"), &cvport);
	if(cvport==1) //图纸空间，运行此函数会崩溃 070117 SR
        return;
	XString sCmdName;
	xg_getvar(_T("CMDNAMES"), sCmdName);
	if( _tcsicmp(sCmdName, _T("COPYCLIP"))==0) //这个命令受影响，取消检测
		return;
	if( _tcsicmp(sCmdName, _T("ARRAY"))==0 ||
		_tcsicmp(sCmdName, _T("ARRAY-ARRAY"))==0) //这个命令受影响，取消检测
		return;
	
 //   if(!g_bSPipeFDir)
   //     return; 
	//2009-2-29 沈睿增加楼层框
	// 2010-11-19，mcl 增加地热盘管
    RBList mask(RTDXF0, _T("ATS_PIPE,ATS_FLOORRECT,ATS_FLOORPIPE"), NULL);
    RBList mask2(RTDXF0, _T("ATS_FLOORPIPE, ATS_FLOORRECT"), NULL);

    PickSet &ssGrip=DocGetPickGrip2();
    PickSet ssTemp(SS_FREE);
    ssTemp += ssGrip;

    if(g_bSPipeFDir)
	    ssTemp.BaseFilter(mask); //上次加亮的管线
	else
	    ssTemp.BaseFilter(mask2); //上次加亮的管线

    ssGrip.Free();
    long lenff1 = ssTemp.Length();
    
    PickSet ss(SS_FREE);    //本图加亮的全部对象
    if(ss.Get(_T("I"))==RTNORM) {
		long lenSS = ss.Length();

        ss.BaseFilter(mask);
        ssGrip += ss;      //保存加亮纪录
        PickSet ssInc(SS_FREE), ssDec(SS_FREE);
        ssInc += ss;
        ssInc -= ssTemp;   //获得新增加加亮的房间
        ssDec += ssTemp;
        ssDec -= ss;       //获得取消加亮的房间

        long len1 = ssDec.Length();
        long len2 = ssInc.Length();
        
        TDocAutoLock vLock; 
        for(long i=0L; i<len1; i++) {
            Entity ent=ssDec[i];
			if(ent.Is(_T("ATS_PIPE")))
			{
				OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbPipe, pPipe);
				if(pPipe){
					pPipe->SetHighlight(FALSE);
				}
				OPENOBJ_END();
			}
			else if(ent.Is(_T("ATS_FLOORRECT")))
			{
				OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbFloorRect, pPipe);
				if(pPipe){
					pPipe->SetShow(FALSE);
				}
				OPENOBJ_END();
			}
			else if(ent.Is(_T("ATS_FLOORPIPE")))	// mcl add 2010.11.19,地热选中时显示出口箭头
			{
				OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbFloorPipe, pFPipe);
				if(pFPipe){
					pFPipe->SetHighlight(FALSE);
				}
				OPENOBJ_END();
			}						
         }
        
		for(i=0L; i<len2; i++) {
            Entity ent=ssInc[i];
			if(ent.Is(_T("ATS_PIPE")))
			{
				OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbPipe, pPipe);
				if(pPipe){
					pPipe->SetHighlight(TRUE);
				}
				OPENOBJ_END();
			}
			else if(ent.Is(_T("ATS_FLOORRECT")))
			{
				OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbFloorRect, pPipe);
				if(pPipe){
					pPipe->SetShow(TRUE);
				}
				OPENOBJ_END();
			}
			else if(ent.Is(_T("ATS_FLOORPIPE")))	// mcl add 2010.11.19,地热选中时显示出口箭头
			{
				OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbFloorPipe, pFPipe);
				if(pFPipe){
					pFPipe->SetHighlight(TRUE);
				}
				OPENOBJ_END();
			}						
        }
    }
    else{
        TDocAutoLock vLock; 
        for(long i=0L; i<ssTemp.Length(); i++) {
            Entity ent=ssTemp[i];
			if(ent.Is(_T("ATS_PIPE")))
			{
				OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbPipe, pPipe);
				if(pPipe){
					pPipe->SetHighlight(FALSE);
				}
				OPENOBJ_END();
			}
			else if(ent.Is(_T("ATS_FLOORRECT")))
			{
				OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbFloorRect, pPipe);
				if(pPipe){
					pPipe->SetShow(FALSE);
				}
				OPENOBJ_END();
			}
			else if(ent.Is(_T("ATS_FLOORPIPE")))	// mcl add 2010.11.19,地热选中时显示出口箭头
			{
				OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbFloorPipe, pFPipe);
				if(pFPipe){
					pFPipe->SetHighlight(FALSE);
				}
				OPENOBJ_END();
			}			
        }
    }
    
    return;
}
 
    
void TPipeCmdReactor::commandCancelled(const TCHAR * cmdStr)
{
	TPipePerDocData *pCurDocData=GetCurPipeDocData();
    ASSERT(pCurDocData!=NULL);

	if (NULL != pCurDocData)	// mcl add 2010.07.13
		pCurDocData->ResetCloseEntity();
}

void TPipeCmdReactor::commandFailed(const TCHAR * cmdStr)
{
}


// ACAD Bug: 当命令结束时还有没有close的实体, 因此可能需要强制close
// to do: 如何判断一个用户命令的真正结束
void TPipeCmdReactor::commandEnded(const TCHAR *cmdStr)
{
    int nCmdActive;
    xg_getvar(_T("CMDACTIVE"), &nCmdActive);
   // ASSERT(GetCurPipeDocData());
    if(nCmdActive==1) 
	{
        if(_tcsicmp(cmdStr, _T("xsbg"))==0 || _tcsicmp(cmdStr, _T("gxcx"))==0 || _tcsicmp(cmdStr, _T("options"))==0 || //给排水
			_tcsicmp(cmdStr, _T("QUIT"))==0 || _tcsicmp(cmdStr, _T("END"))==0 ||
            _tcsicmp(cmdStr, _T("OPEN"))==0 || _tcsicmp(cmdStr, _T("NEW"))==0 ||
            _tcsicmp(cmdStr, _T("SHADE"))==0 || _tcsicmp(cmdStr, _T("RENDER"))==0 ||
            _tcsicmp(cmdStr, _T("REDRAW"))==0 || _tcsicmp(cmdStr, _T("REGEN"))==0 ||
         //   _tcsstr(cmdStr, _T("TCHSCALE"))|| //_tcsstr(cmdStr, _T("UpdateAllLinkage")) ||  sr removed  2005-4-12 设备比例随出图比例，如果修改比例，遮挡关系必须重新计算
            _tcsicmp(cmdStr, _T("UNDO"))==0 || _tcsicmp(cmdStr, _T("REDO"))==0 || 
            _tcsicmp(cmdStr, _T("U"))==0 || _tcsicmp(cmdStr, _T("AUDIT"))==0 || 
            _tcsicmp(cmdStr, _T("CHPROPERTIES"))==0 || _tcsicmp(cmdStr, _T("INSERT"))==0 
			)  
		{ 
             
        } else {
            EndUserCommand(cmdStr, TRUE);
        }
	}
}

/////////////////////////////////////////////
// 开始用户的命令, 包括ARX和ADS
void TPipeCmdReactor::BeginUserCommand(const TCHAR *pszCmd, BOOL bIsArxCommand)
{
    ResetAll();
}

 


/////////////////////////////////////////////
// 结束用户的命令, 包括ARX和ADS
void TPipeCmdReactor::EndUserCommand(const TCHAR *szCmd, BOOL bIsArxCommand)
{
	XPushMemVar<BOOL> vMonitor(g_bMonitorDbAction, FALSE);
    XString sCmdNames(256);
    if(szCmd)
        sCmdNames=szCmd;

    if(_tcsicmp(sCmdNames, _T("INSERT"))!=0 && 
		_tcsicmp(sCmdNames, _T("QSAVE"))!=0 && 
		_tcsicmp(sCmdNames, _T("PREVIEW"))!=0 && 
		_tcsicmp(sCmdNames, _T("PLOT"))!=0 && 
		_tcsicmp(sCmdNames, _T("SAVE"))!=0 && 
		_tcsicmp(sCmdNames, _T("SAVEAS"))!=0 && g_bDwgBegin) { //制止对INSERT命令进行处理
        BOOL bSpeedUp=FALSE;
		TPipePerDocData *pCurDocData=GetCurPipeDocData();
        ASSERT(pCurDocData!=NULL);

		if (NULL != pCurDocData)	// mcl add judge 2010.07.13
		{
			g_sCurrentCmd = sCmdNames; // cet 2012.11.16 add 保存命令名
			// 有待修改 ...
			int nChanged = pCurDocData->GetChangedNum();
			BOOL bSpeedNum = nChanged>pCurDocData->GetOptimize() && nChanged>200;
			BOOL bSpeedCmd = _tcsicmp(sCmdNames, _T("MOVE"))==0
				|| _tcsicmp(sCmdNames, _T("ROTATE"))==0
				|| _tcsicmp(sCmdNames, _T("COPYCLIP"))==0
				|| _tcsicmp(sCmdNames, _T("COPY"))==0
				|| _tcsicmp(sCmdNames, _T("ARRAY"))==0
				|| _tcsicmp(sCmdNames, _T("MIRROR"))==0
				|| _tcsicmp(sCmdNames, _T("PASTECLIP"))==0;
			if(bSpeedNum && bSpeedCmd) {
				// 部分平台该提示出现乱码
				//int nAnswer=AfxMessageBox(_T("有大量的对象进行操作, 您是否在进行整体操作?\nYes: 整体操作则无需处理构件关系\nNo: 局部操作则需要处理构件关系,需要一定的等待时间."), MB_YESNO);

				int nAnswer=AfxMessageBox(_T("有大量的对象进行操作, 您是否在进行整体操作?\r\nYes: 整体操作则无需处理构件关系\r\nNo: 局部操作则需要处理构件关系,需要一定的等待时间."), MB_YESNO);
				bSpeedUp=(nAnswer==IDYES);
			}
			if(_tcsicmp(sCmdNames, _T("matchprop"))==0)  {   //格式刷
				pCurDocData->DoMatchPipe();
				g_bIsStartMatchProp = FALSE;
			}

			if(!bSpeedUp && sCmdNames != _T("HLMJ")) {//ZXL 2014.02.12 MODIFY HLMJ命令不需要更新管线操作
				pCurDocData->ApplyUpdates();
			} else {
				actrTransactionManager->queueForGraphicsFlush(); //flushGraphics();
			}

			g_sCurrentCmd.Empty(); // cet 2012.11.16 add 清除命令名
		}
    }
    ResetAll();
}
// End TPipeCmdReactor
/////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////
//TPipeDbReactor
//处理发生变化的实体(Modified, Erased, Appended)
void TPipeDbReactor::ObjectChanged(const AcDbObject *dbObj, int nChgFlag)
{
	XString sCmdNames;
	xg_getvar(_T("CMDNAMES"), sCmdNames);
    if(	_tcsicmp(sCmdNames, _T("QSAVE"))==0 ||
		_tcsicmp(sCmdNames, _T("SAVE"))==0 ||
		_tcsicmp(sCmdNames, _T("SAVEAS"))==0 ||
		_tcsicmp(sCmdNames, _T("PLOT"))==0 ||
		_tcsicmp(sCmdNames, _T("PREVIEW"))==0)
		return;
	
	TPipePerDocData *pData = GetCurPipeDocData();
	ASSERT(pData);
	if(pData) {
		pData->ObjectChanged(dbObj, nChgFlag);
//		cet 2014.7.4 del 有时会造成其他不必要错误的发生
//		(如 矩形布置 关闭喷淋图层再打开喷淋图层会导致喷头无故删除)
//		// zxl 2013.12.20 add 特性表或cad中修改出图比例时，更新设备和管的遮挡关系
// 		if (dbObj->isKindOf(TDbEquipment::desc()) && sCmdNames == _T(""))
// 		{
// 			pData->ApplyUpdates();
// 		}
	}
}

// 当实体从当前DWG中删除时的处理
void TPipeDbReactor::objectErased(const AcDbDatabase* dwg,
    const AcDbObject* dbObj, Adesk::Boolean pErased)
{
   if(!g_bMonitorDbAction || !g_bDwgBegin)
       return;
    if(dwg==acdbCurDwg()) {
          ObjectChanged(dbObj, pErased==Adesk::kTrue? OBJ_DELETE:OBJ_APPEND);
   }
}

#if(ADS>15)

CString GetLayerChnName(const TCHAR *szLayer)
{
	CString csRet = szLayer;
	XString fullFile;
	if(FindFile(_T("layerdef.dat"), fullFile)) {
		FILE *fp=fopen(_AS(fullFile), "r");
		if(!fp)
			return csRet;
		while(!feof(fp)) {
			char sBuf[256]="";
			TCHAR cName[256]=_T(""), eName[256]=_T("");
			fgets(sBuf, 255, fp);
			if(sBuf[0]) {
                CT_strnth(TString(sBuf), 1, cName);
                CT_strnth(TString(sBuf), 2, eName);
			}
			if(_tcscmp(szLayer, eName) == 0){
				csRet = cName;
				fclose(fp);
				return csRet;	
			}
		}
		fclose(fp);
	}	
	return csRet;	
}

void TLayerPane::Init(bool bTrue)
{
	AcApStatusBar *pBar = acedGetApplicationStatusBar();
	if (pBar)
	{
		if (bTrue)
		{
			pBar->RemoveDefaultPane(ACSBPANE_APP_MODEMACRO);
			pBar->Insert(1,this);
			SetStyle(ACSB_NORMAL);
			Update();
		} 
		else
		{
			pBar->Remove(this);
		}
	}
}

void TLayerPane::Update()
{
	XString xsLayName;
	xg_getvar(_T("CLAYER"), xsLayName);
	CString csText = GetLayerChnName((const TCHAR*)xsLayName);
	SetText((const TCHAR*)csText);
	acedGetApplicationStatusBar()->Update();
}

#endif // ADS>15

void TPipeDbReactor::headerSysVarChanged(const AcDbDatabase* db, const TCHAR* name,
										   Adesk::Boolean bSuccess)
{
    XString xsLayName;
	if(_tcsicmp(name, _T("CLAYER")) == 0 && g_bIsCustomizeVer)
	{
#if ADS>15
		xg_getvar(_T("CLAYER"), xsLayName);
		AcApStatusBar *pBar = acedGetApplicationStatusBar();
		if (pBar) 
		{
			AcPane *pPane = pBar->GetPane(1);
			if (pPane != NULL)
			{
				pPane->SetVisible(TRUE);
				CString csText = GetLayerChnName((const TCHAR*)xsLayName);
				pPane->SetText((const TCHAR*)csText);
				pBar->Update();
			}
		}
#endif 

	}
}


// 当实体添加到当前DWG时的处理函数
void TPipeDbReactor::objectAppended(const AcDbDatabase* dwg,  const AcDbObject* dbObj)
{
   //sr modify 如果格式刷刷出新管线，虽然g_bMonitorDbAction＝FALSE，也要执行下去 
   if((!g_bMonitorDbAction && !g_bIsStartMatchProp) || !g_bDwgBegin)
       return;
   if(dwg==acdbCurDwg()) {
       ObjectChanged(dbObj, OBJ_APPEND);
   }
}

// 当墙体修改时,接收消息
void TPipeDbReactor::objectModified(const AcDbDatabase* dwg, const AcDbObject* dbObj)
{
   if(!g_bMonitorDbAction || !g_bDwgBegin)
       return;
   UpdatePipeFittingLayer(dwg, dbObj); // cet 2016.7.12 管道连接件图层颜色随管道
   if(dwg==acdbCurDwg()) {
          ObjectChanged(dbObj, OBJ_CHANGE);
   }
}

// 建立墙体数据库的监测
void TPipeDbReactor::Attach()
{
    TPipePerDocData *pData=GetCurPipeDocData();
    if(pData)
        pData->AttachReactor();    
}

// 除去墙体数据库的监测
void TPipeDbReactor::Detach()
{
    TPipePerDocData *pData=GetCurPipeDocData();
    if(pData)
        pData->DetachReactor();
}

Acad::ErrorStatus 
GetSafeSelection(PickSet &ss, const XPoint &ptLow, const XPoint &ptUp,
				 const AcRxClass *pClass,BOOL bCrossing/*=TRUE*/)
{
    Acad::ErrorStatus esRet=Acad::eNotApplicable;
    XDbBlockTableRec objMSpace;
    if(!objMSpace)
        return esRet;

    /*XPoint ptMid;
    Midpoint(ptLow, ptUp, ptMid);*/
    XRectAngle rect(ptLow, ptUp);

    //CRect rect0(long(ptLow.x), long(ptLow.y), long(ptUp.x), long(ptUp.y));
    AcDbBlockTableRecordIterator* pBlockIterator=NULL;
    Acad::ErrorStatus es = objMSpace.m_pBlockTableRec->newIterator(pBlockIterator);
    ASSERT(es==Acad::eOk && pBlockIterator!=NULL);

    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;
		}
		//AcRxClass *pRxInfo=pEntity->isA();

		if(!pClass || pEntity->isKindOf(pClass)) {
			//用于加速目的，光标移动时自动捕捉时使用
			if(!bCrossing && pEntity->isKindOf(AcDbCurve::desc())) {
				AcDbCurve *pCurve=AcDbCurve::cast(pEntity);
				XPoint ptCurve,ptMid; 
				Midpoint(ptLow, ptUp, ptMid);
				if(pCurve->getClosestPointTo(ptMid, ptCurve)==Acad::eOk && 
					ptCurve.x>rect.lowLeft.x && ptCurve.x<rect.upRight.x &&
					ptCurve.y>rect.lowLeft.y && ptCurve.y<rect.upRight.y) {
					//(ptCloseToCurve&rect)==PR_INSIDE) {
					Entity ent;
					VERIFY(acdbGetAdsName(ent.name, pCurve->objectId())==Acad::eOk);
					ss += ent;
					esRet=Acad::eOk;
				}
			}
			else {
				BOOL bExtent = TRUE;
				if(pEntity->isKindOf(TDbPipeNode::desc())) {//增加对不可见的节点的处理
					TDbPipeNode *pNode=(TDbPipeNode *)pEntity;
					if(pNode!=NULL) {
						if(!(pNode->IsVisible())) {
							bExtent = FALSE;
							XPoint ptLocation = pNode->GetLocation();
							if(PointInBox02d(ptLocation,rect)) {
								Entity ent;
								if (acdbGetAdsName(ent.name, pEntity->objectId())==Acad::eOk) {
									ss += ent;
									esRet = Acad::eOk;
								}
							}
						}
					}
				}

				if(bExtent) {//可见节点或者管线
					AcDbExtents ext;
					if(pEntity->getGeomExtents(ext)==Acad::eOk) {
						XPoint ptExtMin=ext.minPoint(), ptExtMax=ext.maxPoint();
						ptExtMin.z=ptExtMax.z=0;
						if(ExtendInBox02d(ptExtMin,ptExtMax,rect)) {
							Entity ent;
							if (acdbGetAdsName(ent.name, pEntity->objectId())==Acad::eOk) {
								ss += ent;
								esRet = Acad::eOk;
							}
						}
					}
				}
			}
		}
	}
	delete pBlockIterator;
	return esRet;
}

// 求管线系统的外包
static int GetPSExtend(const PickSet &ss,XPoint &ptLow,XPoint &ptUp)
{
	int nRet=RTNORM;
	XPoint ptLowNode,ptUpNode;

	BOOL bHasInvNode=FALSE;
	PickSet ssOther(SS_FREE);

	long lCount=ss.Length();
	for(long i=0; i<lCount; i++) {
		Entity ent = ss[i];
		OPENOBJ_BEGIN(ent,AcDb::kForRead,AcDbEntity,pEntity);
		if(pEntity!=NULL && pEntity->visibility()!=AcDb::kInvisible) {
			if(pEntity->isKindOf(TDbPipeNode::desc())) {
				TDbPipeNode *pNode=(TDbPipeNode *)pEntity;
				if(pNode!=NULL) {
					if(!(pNode->IsVisible())) {
						XPoint ptLocation=pNode->GetLocation();
						if(!bHasInvNode) {
							ptLowNode = ptLocation;
							ptUpNode = ptLocation;
							bHasInvNode=TRUE;
						} else {
							ptLowNode = Min(ptLowNode,ptLocation);
							ptUpNode = Max(ptUpNode,ptLocation);
						}
						continue;
					}
				}
			}
			ssOther += ent;
		}
		OPENOBJ_END();
	}

	BOOL bOther=ssOther.Length()>0;
	if(bOther) {
		nRet = ssOther.GetExtend(ptLow,ptUp);
	}
	if (bHasInvNode) {
		if(bOther) {
			ptLow = Min(ptLow,ptLowNode);
			ptUp = Max(ptUp,ptUpNode);
		} else {
			ptLow = ptLowNode;
			ptUp = ptUpNode;
		}
	}
	return nRet;
}

// cet 2015.7.3 modify 重写函数自动生成的节点现在改为全部删除，再重新生成
// 要更新：
//   1. 发生变化的管线
//   2. 发生变化前关联的管线和节点
//   3. 发生变化后关联的管线和节点          
//       旧位置可能发生合并管段；新位置可能发生断开管段
//       旧位置要更新节点（包括删除隐式）；新位置要更新节点（包括新增隐式节点）
//   4. 发生变化的节点
//   5. 发生变化前关联的管线（解除关联）
//   6. 发生变化后关联的管线（新增关联）
// void TPipePerDocData::
// ModifyPipeAtCorner(const UpdateInfo *info,const DList<TEntRect> &lstPipe,
// 				   const DList<TNodeLocation>& lstNode,BOOL bOptimize)
// {
// 	if(info==NULL || (lstPipe.Length()<=0 && lstNode.Length()<=0))
// 		return;
// 
// 	XPointList lstCorners,lstNeedBreak;// 复制一份
// 	for(int idx=0; idx<info->lstVertice.Length(); idx++) {
// 		lstCorners.Append(new XPoint(info->lstVertice[idx]));
// 	}
// 	for(idx=0; idx<info->lstNeedBreak.Length(); idx++) {
// 		lstNeedBreak.Append(new XPoint(info->lstNeedBreak[idx]));
// 	}
// 
// 	PickSet ssDel(SS_FREE); //被合并的管线
// 	TSearchPipeSys aSearch(bOptimize);
// 	aSearch.InitStart(info->sysType,lstPipe,lstNode,lstNeedBreak);
// 	try {
// 		aSearch.MergePipes(lstCorners, ssDel); //先尽量合并管段, 只处理发生变化的位置
// 		aSearch.BreakPipes(lstCorners,TRUE); //在断点处打断管线
// 		aSearch.BreakPipes(lstNeedBreak,FALSE);
// 	} catch(...) {
// 		ssDel.Erase();
// 		adsout << /*UMSG*/ _T("\n出现了例外情况!");
// 		acedPostCommandPrompt();
// 		return;
// 	}
//     long lendel = ssDel.Length();
//     if(lendel == 0 && lstPipe.Length() == 2){
//         TEntRect kPipe1 = lstPipe[0];
//         TEntRect kPipe2 = lstPipe[1];
//         XPoint p1, p2, p3, p4;
//         TPipeSys::SysType sys1, sys2;
//         OPENOBJ_BEGIN(kPipe1.id,AcDb::kForRead,TDbPipePrototype,pPipe);
//         if(pPipe!=NULL){
//             p1 = pPipe->StartPoint();
//             p2 = pPipe->EndPoint();
//             sys1 = pPipe->GetSysType();
//         }
//         OPENOBJ_END();
//         OPENOBJ_BEGIN(kPipe2.id,AcDb::kForRead,TDbPipePrototype,pPipe);
//         if(pPipe!=NULL){
//             p3 = pPipe->StartPoint();
//             p4 = pPipe->EndPoint();
//             sys2 = pPipe->GetSysType();
//         }
//         OPENOBJ_END();
//         if(p1 == p3 && p2 == p4)    
//             ssDel +=kPipe2.id;
//     }
// 	////////////////////////////////////////////////////////////////////////////////
// 	//以下2009-4-10 sr 添加，处理立管标注更新绑定的问题. 当2立管合并后，立管标注所绑定的立管id有可能无效，需要重新绑定
// 	//2009-11-9 删除本段，安工提出p选的时候，总是会选中本图全部立管编号
// /*	if(aSearch.m_idMapMergeVPipe.GetCount() > 0)
// 	{
// 		RBList Mask(RTDXF0, _T("ATS_VPIPEDIM"), NULL);
// 		PickSet ssVPipeDim(SS_FREE);
// 		ssVPipeDim.Get(_T("X"), NULL, NULL, Mask);
// 		POSITION pos = aSearch.m_idMapMergeVPipe.GetStartPosition();
// 		while (pos != NULL)
// 		{
// 			AcDbObjectId idPipe2, idPipe1; //idPipe2被删除了，idPipe1保留了
// 			long lPipe2, lPipe1;
// 			aSearch.m_idMapMergeVPipe.GetNextAssoc(pos, lPipe2, lPipe1);
// 			idPipe2.setFromOldId(lPipe2);
// 			idPipe1.setFromOldId(lPipe1);
// 			for(long m=0;m<ssVPipeDim.Length();m++)
// 			{
// 				Entity entTmp = ssVPipeDim[m];
// 				OPENOBJ_BEGIN(entTmp,AcDb::kForRead,TDbVPipeDim,pDim);
// 				if(pDim!=NULL){
// 					AcDbObjectId idDim = pDim->GetVPipeId();
// 					//如果立管标注绑定立管ID刚好是要准备删除的立管
// 					if(idDim == idPipe2)
// 					{
// 						if (pDim->upgradeOpen() == Acad::eOk)
// 						{
// 							pDim->SetVPipeId(idPipe1);
// 							pDim->downgradeOpen();
// 						}
// 						break;
// 					}
// 				}
// 				OPENOBJ_END();
// 			}
// 		}
// 	}*/
// 	////////////////////////////////////////////////////////////////////////////////
// 	ssDel.Erase();
//  
// 	// 过滤出需要局部更新的范围
// 	XPoint ptSnap(PS_SNAP,PS_SNAP);
// 	XRectAngle box(m_rectSysUpdate.lowLeft-ptSnap,m_rectSysUpdate.upRight+ptSnap);
// 	aSearch.DelSoleNodeFromDb(info->sysType,&box); //移除孤独隐式节点 
// 	aSearch.AddAutoNodeToDb(&box); //新增加的隐式节点加入DWG
// 	aSearch.DelDupNodeFromDb(box);
// 	aSearch.DelDupPipeFromDb(box);
// 	//aSearch.MergePipes(lstCorners,ssDel);
// 	//ssDel.Erase();
//     
// 	aSearch.UpdateNodeLinkage(info->sysType, &box);
// 	aSearch.UpdatePipeLinkage(&box);
// 
// 	if(ssDel.Length()) {  //清除预先选中的物体，以避免崩溃的错误
// 		PickSet gSet(SS_FREE), pSet(SS_FREE);
// 		if(GetPickFirst(gSet, pSet)==RTNORM) {
// 			if(gSet.Length() || pSet.Length()) {
// 				acedPostCommand(_T("\33"));
// 			}
// 		}
// 	}
// }

// 要更新：
//   1. 发生变化的管线
//   2. 发生变化前关联的管线和节点
//   3. 发生变化后关联的管线和节点          
//       旧位置可能发生合并管段；新位置可能发生断开管段
//       旧位置要更新节点（包括删除隐式）；新位置要更新节点（包括新增隐式节点）
//   4. 发生变化的节点
//   5. 发生变化前关联的管线（解除关联）
//   6. 发生变化后关联的管线（新增关联）
void TPipePerDocData::
ModifyPipeAtCorner(const UpdateInfo *info,const DList<TEntRect> &lstPipe,
				   const DList<TNodeLocation>& lstNode,BOOL bOptimize)
{
	if(info==NULL || (lstPipe.Length()<=0 && lstNode.Length()<=0))
		return;

	XPointList lstCorners,lstNeedBreak;// 复制一份
	for(int idx=0; idx<info->lstVertice.Length(); idx++) {
		lstCorners.Append(new XPoint(info->lstVertice[idx]));
	}
	for(idx=0; idx<info->lstNeedBreak.Length(); idx++) {
		lstNeedBreak.Append(new XPoint(info->lstNeedBreak[idx]));
	}

	PickSet ssDel(SS_FREE); //被合并的管线
	TSearchPipeSys aSearch(bOptimize);
	aSearch.InitStart(info->sysType,lstPipe,lstNode,lstNeedBreak);
	// cet 2015.7.3 add 删除所有隐式节点
	XPoint ptSnap(PS_SNAP,PS_SNAP);
	XRectAngle box(m_rectSysUpdate.lowLeft-ptSnap,m_rectSysUpdate.upRight+ptSnap);
//	aSearch.DelAllNodeFromDb(&box);
	try {
		aSearch.MergePipes(lstCorners, ssDel, false); //先尽量合并管段, 只处理发生变化的位置
		aSearch.BreakPipes(lstCorners,TRUE); //在断点处打断管线
		aSearch.BreakPipes(lstNeedBreak,FALSE); 
		aSearch.MergePipes(lstCorners, ssDel, true); // 打断后，再次合并管道（第一次合并时，管道间存在重叠的管道为实现合并）
	} catch(...) {
		ssDel.Erase();
		adsout << /*UMSG*/ _T("\n出现了例外情况!");
		acedPostCommandPrompt();
		return;
	}
    long lendel = ssDel.Length();
    if(lendel == 0 && lstPipe.Length() == 2){
        TEntRect kPipe1 = lstPipe[0];
        TEntRect kPipe2 = lstPipe[1];
        XPoint p1, p2, p3, p4;
        TPipeSys::SysType sys1, sys2;
        OPENOBJ_BEGIN(kPipe1.id,AcDb::kForRead,TDbPipePrototype,pPipe);
        if(pPipe!=NULL){
            p1 = pPipe->StartPoint();
            p2 = pPipe->EndPoint();
            sys1 = pPipe->GetSysType();
        }
        OPENOBJ_END();
        OPENOBJ_BEGIN(kPipe2.id,AcDb::kForRead,TDbPipePrototype,pPipe);
        if(pPipe!=NULL){
            p3 = pPipe->StartPoint();
            p4 = pPipe->EndPoint();
            sys2 = pPipe->GetSysType();
        }
        OPENOBJ_END();
        if(p1 == p3 && p2 == p4)    
            ssDel +=kPipe2.id;
    }
//  cet 2016.10.17 modify 当前选择集只剔除需要删除的实体，否则一些命令如过滤选择等无法正常选中选择实体
//	acedSSSetFirst(NULL, NULL); // cet 2016.9.14 add 清除预先选中的物体，以避免删除实体时产生崩溃的错误
	if (ssDel.Length() > 0)
	{
		PickSet ss(SS_FREE), ss1(SS_FREE|SS_CREATE);
		resbuf *gset=NULL, *pset=NULL;
		if (ads_ssgetfirst(&gset, &pset)==RTNORM) 
		{
			if (gset != NULL) 
			{
				if (gset->restype == RTPICKS)
				{
					PickSet ss0(0);
					ss0 = gset->resval.rlname;
					ss += ss0;
					ss0.Free();
				}
				ads_relrb(gset);
			}
			if (pset != NULL) 
			{
				if (pset->restype == RTPICKS)
					ads_ssfree(pset->resval.rlname);
				ads_relrb(pset);
			}
		}
		ss -= ssDel;
		ads_sssetfirst(ss, ss1);
	}
	ssDel.Erase();
	aSearch.DelSoleNodeFromDb(info->sysType,&box); //移除孤独隐式节点 
	aSearch.AddAutoNodeToDb(&box);
	aSearch.DelDupNodeFromDb(box);
	aSearch.DelDupPipeFromDb(box);
    aSearch.UpdateNodeLinkage(info->sysType, &box);
    aSearch.UpdatePipeLinkage(&box);
	if(ssDel.Length()) {  //清除预先选中的物体，以避免崩溃的错误
		PickSet gSet(SS_FREE), pSet(SS_FREE);
		if(GetPickFirst(gSet, pSet)==RTNORM) {
			if(gSet.Length() || pSet.Length()) {
				acedPostCommand(_T("\33"));
			}
		}
	}
}

//2013-1-11 cet add 复制粘贴之前 重新计算更新RECT
void TPipePerDocData::CalcUpdateSysRect()
{
	if(IsUpdateSysRect(g_sCurrentCmd))
	{
		if (m_setEntIds.empty())
		{
			return;
		}

		// 获得当前模型空间的实体id
		std::set<AcDbObjectId> setModelSpaceIds;
		if (!GetEntIdsFromModelSpace(setModelSpaceIds))
		{
			return;
		}
		std::set<AcDbObjectId>::iterator itNoFind = setModelSpaceIds.end();
		// 清空更新区域
		m_rectSysUpdate.lowLeft = m_rectSysUpdate.upRight = XPoint();

		std::set<AcDbObjectId>::iterator it, itEnd = m_setEntIds.end();
		XPoint pt1, pt2, ptLocation;
		for (it = m_setEntIds.begin(); it != itEnd; ++it)
		{
			AcDbEntity *pEnt = NULL;
			acdbOpenObject(pEnt, *it, AcDb::kForRead);
			if (pEnt != NULL)
			{
				if (setModelSpaceIds.find(*it) == itNoFind)//CET 粘贴的时候在原点创建了实体，但不在模型空间中，因此将其过滤掉。
				{
					pEnt->close();
					continue;
				}

				if(pEnt->isKindOf(TDbPipeNode::desc()) && !pEnt->isKindOf(TDbDuctNode::desc())) //节点变化
				{ 
					TDbPipeNode *pNode=(TDbPipeNode *)pEnt;
					if(pNode->GetExtents(pt1, pt2) == Acad::eOk && !(pt1==XPoint() && pt2==XPoint())) 
					{
						UpdateRect(pt1, pt2, m_rectSysUpdate);
					}
				} 
				else if(pEnt->isKindOf(TDbPipePrototype::desc()) && !pEnt->isKindOf(TDbDuct::desc())) 
				{
					
					TDbPipePrototype *pWire=(TDbPipePrototype *)pEnt;
					if(pWire->GetExtend(pt1, pt2)) 
					{
						UpdateRect(pt1, pt2, m_rectSysUpdate);
					}
				}
				else if(pEnt->isKindOf(TDbPipeAttachment::desc())) 
				{
					TDbPipeAttachment *pAttach=(TDbPipeAttachment *)pEnt;
				    ptLocation = pAttach->GetLocation();
					UpdateRect(ptLocation, ptLocation, m_rectAttachUpdate);
				}
				pEnt->close();
			}
		}
	}
}

bool TPipePerDocData::GetEntIdsFromModelSpace( std::set<AcDbObjectId> &setEntIds )
{
	setEntIds.clear();
	AcDbBlockTableRecord *pRecord = NULL; 
    AcDbBlockTable* pBlockTable = NULL;
    acdbCurDwg()->getBlockTable(pBlockTable, AcDb::kForRead);
    if(pBlockTable == NULL)
        return false;
	
	if(Acad::eOk != pBlockTable->getAt(ACDB_MODEL_SPACE, pRecord, AcDb::kForRead))
	{
        pBlockTable->close();
        return false;
    }
	pBlockTable->close();
	
	AcDbBlockTableRecordIterator *pIterator = NULL;
    pRecord->newIterator(pIterator);
    pRecord->close();
	
    for(pIterator->start(); !pIterator->done(); pIterator->step())
	{
        AcDbEntity *pEnt = NULL;
        pIterator->getEntity(pEnt, AcDb::kForRead);
		if (pEnt != NULL)
		{
			setEntIds.insert(pEnt->objectId());
			pEnt->close();
		}
	}
	
	delete pIterator;
	return true;
}

bool TPipePerDocData::IsUpdateSysRect(const CString &sCmd)
{
	if (_tcscmp(sCmd, _T("PASTECLIP")) == 0 || _tcscmp(sCmd, _T("COPY")) == 0)
	{
		return true;
	}
	return false;
}

void TPipePerDocData::UpdatePipePoints(DList<TEntRect> &lstUpdatePipe)
{
	int nCount = lstUpdatePipe.Length();
	for(int i = 0; i < nCount; i++) 
	{
		OPENOBJ_BEGIN(lstUpdatePipe[i]->id,AcDb::kForRead,TDbPipePrototype,pPipe);
		if(pPipe!=NULL) 
		{
			if (pPipe->GetBulge() > 0.001 || pPipe->IsVertical()) // 不处理弧形管道、立管
			{
				continue;
			}
			UpdatePipeLink(pPipe, 0);
			UpdatePipeLink(pPipe, 1);
		}
		OPENOBJ_END();
	}
}

void TPipePerDocData::UpdatePipeLink(TDbPipePrototype *pPipe, int nPos)
{
	AcDbObjectId id = pPipe->GetNode(nPos);
	// 无效id
	if (!id.isValid() || id.isErased())
	{
		return;
	}
	// 处理管道与化粪池的连接
	TDbPool *pPool = NULL;
	acdbOpenObject(pPool, id, AcDb::kForRead);
	if (pPool != NULL)
	{
		// 管道端点与化粪池接口无误
		XPoint pt = nPos == 0 ? pPipe->StartPoint() : pPipe->EndPoint();
		int nNum = pPool->GetInterfaceNum();
		for (int i = 0; i < nNum; ++i)
		{
			if (pPool->GetInterface(i).m_idPipe == pPipe->id() &&
				pt.Distance2d(pPool->GetInterface(i).m_ptLocation) < 0.001
				&& pPool->GetLocation().Distance2d(pPool->GetInterface(i).m_ptLocation) > 0.001)
			{
				pPool->close();
				return;
			}
		}
		// 求化粪池与管道交点
		AcGePoint3d ptS = pPipe->StartPoint();
		AcGePoint3d ptE = pPipe->EndPoint();
		//AcDbLine line1 = AcDbLine(ptS, ptE);
		AcDbLine line1(ptS, ptE);
		// modify by cq 2017-01-04 支持CAD2017
		AcDbVoidPtrArray entSet;
		XExplodeStream dc(entSet);
		pPool->ExplodeOrDraw2d(dc);
		int nLen = entSet.length();
		AcGePoint3d pt1, pt2;
		XPoint ptNear;
		double dMinDist = -1;
		for(int n = 0; n < nLen; n++) 
		{
			AcDbEntity *pEnt=(AcDbEntity *)entSet[n];
			if (pEnt->isKindOf(AcDbBlockReference::desc()))
			{
				AcDbVoidPtrArray arrExplode;
				pEnt->explode(arrExplode);
				for (int i = 0; i < arrExplode.length(); ++i)
				{
					AcDbEntity *pTemp = (AcDbEntity*)arrExplode[i];
					if(pTemp->isKindOf(AcDbCurve::desc()))
					{
						AcDbCurve *pCurve = (AcDbCurve*)pTemp;
						AcGePoint3d pt;
						pCurve->getPointAtDist(0.0, pt);
						ptS.z = pt.z;
						ptE.z = pt.z;
						line1.setStartPoint(ptS);
						line1.setEndPoint(ptE);
						AcGePoint3dArray arrPoint;
						line1.intersectWith(pCurve, AcDb::kOnBothOperands, arrPoint);
						for (int j = 0; j < arrPoint.length(); ++j)
						{
							AcGePoint3d ptInt = arrPoint.at(j);
							// 取距离管道另一端最近的交点
							if (dMinDist < 0.0 || ptInt.distanceTo(nPos == 1 ? ptS : ptE) < dMinDist)
							{
								dMinDist = ptInt.distanceTo(nPos == 1 ? ptS : ptE);
								ptNear = ptInt;
							}
						}
					}
				}
				ReleaseEntSet(arrExplode);
			}
		}
		ReleaseEntSet(entSet);
		// 更改管道端点及化粪池接口信息
		if (dMinDist > 0.001)
		{
			XCurveSegment seg = pPipe->GetCurve();
			XPoint ptRet;
			seg.ProjectToMe(ptNear, ptRet);
			if (pPipe->upgradeOpen() == Acad::eOk)
			{
				if (nPos == 0)
				{
					pPipe->SetStartPoint(ptRet);
				}
				else
				{
					pPipe->SetEndPoint(ptRet);
				}
				pPipe->downgradeOpen();
			}
			if (pPool->upgradeOpen() == Acad::eOk)
			{
				bool bFlag = false;
				int nNum = pPool->GetInterfaceNum();
				// 更新接口位置
				for (int i = 0; i < nNum; ++i)
				{
					if (pPool->GetInterface(i).m_idPipe == pPipe->id())
					{
						pPool->SetILocation(i, ptNear);
						bFlag = true;
						break;
					}
				}
				// 添加接口
				if (!bFlag)
				{
					AcGeVector3d vtDir = pPipe->StartPoint() - pPipe->EndPoint();
					if (nPos == 0)
					{
						vtDir *= -1;
					}
					vtDir.normalize();
					// 优先使用无用接口
					bFlag = false;
					for (int i = 0; i < nNum; ++i)
					{
						AcDbObjectId idTemp = pPool->GetInterface(i).m_idPipe;
						if (!idTemp.isValid() || idTemp.isErased())
						{
							pPool->SetIPipe(i, pPipe->id());
							pPool->SetILocation(i, ptNear);
							pPool->SetIDirection(i, XVector3D(vtDir));
							bFlag = true;
							break;
						}
					}
					// 创建新接口
					if (!bFlag)
					{
						TPipeInterface iFace;
						iFace.m_sysType = pPipe->GetSysType();
						iFace.m_faceType = TPipeInterface::kNodeLocation;
						iFace.m_idPipe = pPipe->id();
						iFace.m_ptLocation = ptNear;
						CString sTip;
						sTip.Format(_T("%d"), nNum + 1);
						pPool->AddInterface(sTip, ptNear, XVector3D(vtDir));
					}
				}
				pPool->downgradeOpen();
			}
		}
		pPool->close();
	}
}

void TPipePerDocData::UpdatePoolAngle(TDbPool *pPool, AcDbObjectId id1, AcDbObjectId id2)
{
	// 两根管道方向
	AcGeVector3d vtDir1, vtDir2;
	TDbPipe *pPipe1 = NULL, *pPipe2 = NULL;
	acdbOpenObject(pPipe1, id1, AcDb::kForRead);
	if (pPipe1 != NULL)
	{
		vtDir1 = pPipe1->StartPoint() - pPipe1->EndPoint();
		pPipe1->close();
	}
	acdbOpenObject(pPipe2, id2, AcDb::kForRead);
	if (pPipe2 != NULL)
	{
		vtDir2 = pPipe2->StartPoint() - pPipe2->EndPoint();
		pPipe2->close();
	}
	// 管道不平行
	vtDir1.z = 0.0;
	vtDir2.z = 0.0;
	AcGeTol tol;
	tol.setEqualVector(0.001);
	if (!vtDir1.isParallelTo(vtDir2))
	{
		return;
	}
	// 管道是否与化粪池垂直
	double dAngle = pPool->GetAngle();
	AcGeVector3d vtPool = AcGeVector3d::kXAxis;
	vtPool.rotateBy(dAngle, AcGeVector3d::kZAxis);
	if (vtPool.isPerpendicularTo(vtDir1, tol) || vtPool.isParallelTo(vtDir1, tol)) // 垂直或平行
	{
		return;
	}
	// 调整化粪池角度，使其与管道垂直
	dAngle = AcGeVector3d::kXAxis.angleTo(vtDir1, AcGeVector3d::kZAxis);
	if (fabs(dAngle - 2 * PI) < 0.001)
	{
		dAngle = 0.0;
	}
	else if (dAngle > PI - 0.001)
	{
		dAngle -= PI;
	}
	if (pPool->upgradeOpen() == Acad::eOk)
	{
		pPool->SetAngle(dAngle);
		pPool->downgradeOpen();
	}
}

void TPipePerDocData::UpdatePoolAngle(DList<TEntRect> &lstUpdatePipe)
{
	// 获得化粪池池关联的管道
	std::map<AcDbObjectId, std::vector<AcDbObjectId> > mapPool;
	std::vector<AcDbObjectId> vecId, vecTempId;
	int nCount = lstUpdatePipe.Length();
	for(int i = 0; i < nCount; i++) 
	{
		OPENOBJ_BEGIN(lstUpdatePipe[i]->id,AcDb::kForRead,TDbPipePrototype,pPipe);
		if(pPipe!=NULL) 
		{
			if (pPipe->GetBulge() > 0.001 || pPipe->IsVertical()) // 不处理弧形管道、立管
			{
				continue;
			}
			vecId.clear();
			vecId.push_back(pPipe->GetNode(0));
			vecId.push_back(pPipe->GetNode(1));
			for (int j = 0; j < vecId.size(); ++j)
			{
				TDbPool *pPool = NULL;
				acdbOpenObject(pPool, vecId[j], AcDb::kForRead);
				if (pPool != NULL)
				{
					if (mapPool.count(pPool->id()) == 1)
					{
						mapPool[pPool->id()].push_back(pPipe->id());
					}
					else
					{
						vecTempId.clear();
						vecTempId.push_back(pPipe->id());
						mapPool.insert(std::make_pair(pPool->id(), vecTempId));
					}
					pPool->close();
				}
			}
		}
		OPENOBJ_END();
	}
	// 调整角度
	std::map<AcDbObjectId, std::vector<AcDbObjectId> >::iterator it, itEnd = mapPool.end();
	for (it = mapPool.begin(); it != itEnd; ++it)
	{
		if (it->second.size() != 2)
		{
			continue;
		}
		TDbPool *pPool = NULL;
		acdbOpenObject(pPool, it->first, AcDb::kForRead);
		if (pPool != NULL)
		{
			UpdatePoolAngle(pPool, it->second[0], it->second[1]);
			pPool->close();
		}
	}
}

void TPipePerDocData::UpdateWellInfo(DList<TEntRect> &lstUpdatePipe)
{
	bool bUpdate = false;
	int nCount = lstUpdatePipe.Length();
	for(int i = 0; i < nCount; i++) 
	{
		OPENOBJ_BEGIN(lstUpdatePipe[i]->id, AcDb::kForRead, TDbPipe, pPipe);
		if(pPipe!=NULL) 
		{
			for (int j = 0; j < 2; ++j)
			{
				OPENOBJ_BEGIN(pPipe->GetNode(j), AcDb::kForRead, TDbWell, pWell);
				if (pWell != NULL)
				{
					int nNum = pWell->GetInterfaceNum();
					for (int k = 0; k < nNum; ++k)
					{
						const TPipeInterface &face = pWell->GetInterface(k);
						CString sTemp = face.m_sSysLabel.cs();
						if (face.m_idPipe == lstUpdatePipe[i]->id && !sTemp.IsEmpty()) // 井连接着当前管道, 并且井中存在管道标高值
						{
							XPoint ptLoc = pWell->GetLocation();
							double dPipeEle = ptLoc.Distance2d(pPipe->StartPoint()) < ptLoc.Distance2d(pPipe->EndPoint()) ? pPipe->StartPoint().z : pPipe->EndPoint().z;
							if (DocGetCurMeterUnitDraw()) // 米单位
							{
								dPipeEle -= (pPipe->OuterDn() - pPipe->GetPipeThick() * 2) * 0.5 * 0.001;
							}
							else // 毫米单位
							{
								dPipeEle -= (pPipe->OuterDn() - pPipe->GetPipeThick() * 2) * 0.5;
								dPipeEle *= 0.001;
							}
							double dOldEle = _tstof(face.m_sSysLabel);
							if (fabs(dOldEle - dPipeEle) > 0.001 && pWell->upgradeOpen() == Acad::eOk) // 数据改变了，更新井数据
							{
								CString sText;
								sText.Format(_T("%.3ft"), dPipeEle);
								pWell->SetISysLabel(k, sText);
								pWell->downgradeOpen();
								bUpdate = true;
							}
							break;
						}
					}
				}
				OPENOBJ_END();
			}
		}
		OPENOBJ_END();
	}
	// 更新井标注
	if (bUpdate)
	{
		PickSet ssObj(SS_FREE);
		if(GetEntByDxf(ssObj, _T("ATS_WELLDIM"), 1) == Acad::eOk) 
		{
			UpdateGraphic(ssObj);
		}
		acedRedraw(NULL, 0);
	}
}