#include "stdafx.h"
#include "StdArx.h"
#include "AecDbEwFitting.h"
#include "AecDbEwEquipment.h"
#include "AecPipeLineModify.h"
#include "AecPipeLine.h"
#include "AecPipeSupport.h"
#include "EquipManaDlg.h"
#include "EquipmentLibraryDlg.h"
#include "PipelineTools.h"

#ifndef DXF_PIPE_ONLY
#define DXF_PIPE_ONLY _T("AEC_EWPIPE")
#endif

#ifndef VALVE_FOLDER
#define VALVE_FOLDER _T("阀")
#endif

extern Acad::ErrorStatus AddToModelSpace(AcDbEntity* pEnt, AcDbDatabase* pDb/* = NULL*/, bool bClose/* = true*/);

AecPipeLineModify::AecPipeLineModify(void)
{
	m_pADOServer = NULL;
	m_bTeeStop = FALSE;
	m_bUpdateMat = FALSE;
	m_bCrossStop = FALSE;
	memset(&m_paramOld,0,sizeof(WPipe::PipeParam));
}

AecPipeLineModify::~AecPipeLineModify(void)
{

}

void AecPipeLineModify::SetADOServer(CUIISQLiteServer* pADOServer)
{
	m_pADOServer = pADOServer;
}

void AecPipeLineModify::SetPipeParamOld(const WPipe::PipeParam* pPipeParam)
{
	if (pPipeParam != NULL)
	{
		memcpy(&m_paramOld,pPipeParam,sizeof(WPipe::PipeParam));
	}
}

void AecPipeLineModify::SetPipeNetIds(AcDbObjectIdArray& arNetIds)
{
	m_arNetIds.append(arNetIds);
}

CPoint AecPipeLineModify::PickAssocEqu(AcArray<AecInterface>& arInfs,AcDbObjectIdArray& arEquIds,AcArray<AcDbObjectIdInf>& arAssEquIds)
{
	AcDbObjectId id;
	AcDbEntity* pEnt = NULL;
	AcDbObjectIdInf idInf;
	idInf.pNext = NULL;
	CPoint ptIndex(-1,-1);

	int nFindEqu = -1;
	for (int j = 0;j < arEquIds.length();j++)
	{
		id = arEquIds.at(j);

		if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForRead))
		{
			AecDbEwEquipment* pEqu = AecDbEwEquipment::cast(pEnt);
			if (pEqu != NULL)
			{
				AecMInterfaces* pMInfNew = static_cast<AecMInterfaces*>(pEqu);

				for (int i = 0;i < arInfs.length();i++)
				{
					AecInterface& inf = arInfs.at(i);

					AecInterface infHit;
					if (pMInfNew->GetInterface(inf.ptPos,infHit))
					{
						if (pMInfNew->GetInterfaceCount() == 2)//只能支持两个接口的阀门
						{
							AecInterface inf0,inf1;
							pMInfNew->GetInterface(0,inf0);
							pMInfNew->GetInterface(1,inf1);

							if (inf0.ptPos.distanceTo(infHit.ptPos) < 1.e-2)
							{
								idInf.id = id;
								idInf.infFr = inf1;
								nFindEqu = 0;
								ptIndex.x = 0;
								ptIndex.y = i;
							}
							else
							{
								idInf.id = id;
								idInf.infFr = inf0;
								nFindEqu = 1;

								ptIndex.x = 1;
								ptIndex.y = i;
							}

							arAssEquIds.append(idInf);
							arEquIds.removeAt(j);
							j -= 1;
						}
					}
				}
				pEnt->close();
			}
		}

		if (nFindEqu != -1) break;
	}
	return ptIndex;
}

CPoint AecPipeLineModify::PickAssocFlange(AcArray<AecInterface>& arInfs,AcDbObjectIdArray& arFitIds,int iPos,AcArray<AcDbObjectIdInf>& arAssFlgs)
{
	AcDbObjectId id;
	AcDbEntity* pEnt = NULL;
	AcDbObjectIdInf idInf;
	idInf.pNext = NULL;

	CPoint ptIndex(-1,-1);
	int nFindFlange = -1;
	for (int j = 0;j < arFitIds.length();j++)
	{
		if (j == iPos)
			continue;

		id = arFitIds.at(j);

		if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForRead))
		{
			AecDbEwFitting* pFit = AecDbEwFitting::cast(pEnt);
			if (pFit != NULL)
			{
				int nType = 0;
				pFit->GetSpecialtyData()->GetAt(KEY_RUNTIME,nType);
				EFittingType eType = (EFittingType)nType;

				if (eType == eFlange)
				{
					AecMInterfaces* pMInfNew = static_cast<AecMInterfaces*>(pFit);

					for (int i = 0;i < arInfs.length();i++)
					{
						AecInterface& inf = arInfs.at(i);

						AecInterface infHit;
						if (pMInfNew->GetInterface(inf.ptPos,infHit))
						{
							AecInterface inf0,inf1;
							pMInfNew->GetInterface(0,inf0);
							pMInfNew->GetInterface(1,inf1);

							if (inf0.ptPos.distanceTo(infHit.ptPos) < 1.e-2)
							{
								idInf.id = id;
								idInf.infFr = inf1;
								nFindFlange = 0;
								ptIndex.x = 0;
								ptIndex.y = i;
							}
							else
							{
								idInf.id = id;
								idInf.infFr = inf0;
								nFindFlange = 1;

								ptIndex.x = 1;
								ptIndex.y = i;
							}
							arAssFlgs.append(idInf);
						}
					}
				}
				pEnt->close();
			}
		}

		if (nFindFlange != -1) break;
	}
	return ptIndex;
}

bool AecPipeLineModify::ModifyPipeLineParamSys(AcDbObjectIdArray& arIds, WPipe::PipeParam &paramNew)
{
	/*
	* 不建议修改管线的材质，金属管,塑料管,衬塑管,水泥管等... 的管件的尺寸不一样
	* 画法不一样，导致管子需要重新切割长度. 
	* 同样的金属材质的管线 由于国标 A B S 系列不同，管件的尺寸也不同，
	* 画法不一样，导致管子需要重新切割长度. ！！！！！！！！！！！！！！！！！！!
	*/

	AcDbObjectId id1;
	AcDbEntity *pEnt = NULL;

	for (int i = 0; i < arIds.length(); i++)
	{
		id1 = arIds.at(i);

		if (Acad::eOk == acdbOpenAcDbEntity(pEnt, id1, AcDb::kForWrite))
		{
			AecDbEwFitting *pFit = AecDbEwFitting::cast(pEnt);
			if (pFit != NULL)
			{
				pFit->SetAt(PIPE_SYS, paramNew.szSys);
			}

			AecDbEwPipe *pPipe = AecDbEwPipe::cast(pEnt);
			if (pPipe != NULL)
			{
				pPipe->SetAt(PIPE_SYS, paramNew.szSys);
			}

			AecDbEwEquipment *pEqu = AecDbEwEquipment::cast(pEnt);
			if (pEqu != NULL)
			{
				pEqu->SetAt(PIPE_SYS, paramNew.szSys);
			}

			pEnt->close();
		}
	}
	return true;
}

bool AecPipeLineModify::ModifyPipeLineParam(AcDbObjectIdArray& arPipeIds,AcDbObjectIdArray& arFitIds,AcDbObjectIdArray& arEquIds,WPipe::PipeParam& paramNew,BOOL bUpdateMat)
{
	if (m_pADOServer == NULL)
		return false;

	m_bUpdateMat = bUpdateMat;
	if (m_bUpdateMat)
	{
		ModifyPipeLineParamSys(arPipeIds, paramNew);
		ModifyPipeLineParamSys(arFitIds, paramNew);
		ModifyPipeLineParamSys(arEquIds, paramNew);
	}

	//1.先优先统一改管子的尺寸
	ModifyPipeOnParam(arPipeIds,paramNew);
	m_arPipeIds.append(arPipeIds);

	AcDbObjectIdArray arFlangIds;
	AcArray<AcDbObjectIdInf> arAssFlgs,arAssEquIds;

	//2.先修改定位管件,定位管件的位置为绝对位置
	//弯头,三通,四通,Wye,Lateral
	//修改后导致接口位置改变,影响连接件
	AcDbEntity* pEnt = NULL;
	AcDbObjectId id1;
	for (int i = 0;i < arFitIds.length();i++)
	{
		id1 = arFitIds.at(i);
		if (Acad::eOk == acdbOpenAcDbEntity(pEnt,id1,AcDb::kForRead))
		{
			AecDbEwFitting* pFit = AecDbEwFitting::cast(pEnt);
			if (pFit != NULL)
			{
				int nType = 0;
				pFit->GetSpecialtyData()->GetAt(KEY_RUNTIME,nType);
				EFittingType eType = (EFittingType)nType;

				AcArray<AecInterface> arInfs;
				pFit->GetInterface(arInfs);

				switch(eType)
				{
				case eElbow:
				case eTee:
				case eWye:
				case eLateral:
				case eCross:
				case eReduce:
					{
						//按阀门接口找出接口接的阀门
						CPoint ptnPos1 = PickAssocEqu(arInfs,arEquIds,arAssEquIds);

						//按照接口找出接口的法兰
						CPoint ptnPos2 = PickAssocFlange(arInfs,arFitIds,i,arAssFlgs);

						//改完Fit后，按接口对应改对接的管子或管件
						if ( ModifyFitting(pFit,paramNew) )
						{
							AecMInterfaces* pMInfNew = static_cast<AecMInterfaces*>(pFit);
							AecInterface infNew;
							if (ptnPos1.x != -1)
							{
								pMInfNew->GetInterface(ptnPos1.y,infNew);
								if (!arAssEquIds.isEmpty())
								{
									arAssEquIds.first().vtMove = infNew.ptPos - arInfs.at(ptnPos1.y).ptPos;
								}
							}

							if (ptnPos2.x != -1)
							{
								pMInfNew->GetInterface(ptnPos2.y,infNew);
								if (!arAssFlgs.isEmpty())
								{
									arAssFlgs.first().vtMove = infNew.ptPos - arInfs.at(ptnPos2.y).ptPos;
								}
							}

							//按照接口路线修改
							//一直到管子停止;
							m_arNetIds.remove(id1);//修改一个移除当前Fit
							pFit->LockInf(-1);

							if ( !ModifyByInfAssoc(arInfs,pMInfNew,paramNew) )
							{
								pEnt->close();
								return false;
							}
						}
						break;
					}
				case eWcap:
					{
						if ( ModifyFitting(pFit,paramNew) )
						{
						}
						pFit->LockInf(-1);
						break;
					}
				case eFlxJoin:
					{
						if (ModifyFitting(pFit, paramNew))
						{
						}
						pFit->LockInf(-1);
						break;
					}
				case eFlange:
					{
						arFlangIds.append(id1);
						break;
					}
				case eThrough://直通 PVC
				case eUJoin://活接 PVC
				case eRJoin://缩接 PVC 伸缩节
				case eOJoin://外螺纹接头
				case eIJoin://内螺纹接头
				{
					if (ModifyFitting(pFit, paramNew))
					{
					}
					pFit->LockInf(-1);
					break;
				}
				default:
					break;
				}
			}
			pEnt->close();
		}
	}

	if ( fabs(m_paramOld.m_dDN - paramNew.m_dDN) > 1.0 ||
		 fabs(m_paramOld.m_dRRatio - paramNew.m_dRRatio) > 0.3)
	{
		//从某一个设备开始 建立方向串 法兰管线
		if (!arAssEquIds.isEmpty())
		{
			MakeEquListStartByEqu(arAssEquIds,arEquIds);
		}

		//从某一个法兰开始 建立方向串 法兰管线
		if (!arAssFlgs.isEmpty())
		{
			MakeEquListStartByFlang(arAssFlgs,arEquIds,arFlangIds);
		}

		//4.arEquIds 余下孤立的阀门建立方向串
		AcArray<AcDbObjectIdInf> arIdInf;
		MakeEquListTheRest(arEquIds,arFlangIds,arIdInf);

		arIdInf.append(arAssEquIds);
		arIdInf.append(arAssFlgs);

		AcGePoint3d ptE;
		AcDbObjectIdInf* pNext = NULL;

		//测试
#ifdef _DEBUG
		for (int k = 0;k < arIdInf.length();k++)
		{
			AcDbObjectIdInf& idInf = arIdInf.at(k);
			pNext = &idInf;
			int nColor = 1;

			while(pNext != NULL)
			{
				AcDbCircle* pCir = new AcDbCircle;
				pCir->setCenter(pNext->infFr.ptPos);
				pCir->setRadius(10.0);
				pCir->setColorIndex(nColor);
				AddToModelSpace(pCir,NULL,true);

				AcDbLine* pLn = new AcDbLine;
				pLn->setStartPoint(pNext->infFr.ptPos);

				pNext->infFr.vtDir.normalize();
				ptE = pNext->infFr.ptPos + 5.0 * pNext->infFr.vtDir;
				pLn->setEndPoint(ptE);
				pLn->setColorIndex(nColor);
				AddToModelSpace(pLn,NULL,true);

				nColor++;
				pNext = pNext->pNext;
			}
		}
#endif
		//修改方向串中的阀门 [已经排序]
		ModifyEquAlongList(arIdInf,paramNew);

		//Free
		AcDbObjectIdInf *pLast = NULL;
		for (int k = 0;k < arIdInf.length();k++)
		{
			AcDbObjectIdInf& idInf = arIdInf.at(k);
			pNext = idInf.pNext;
			int nColor = 1;

			while(pNext != NULL)
			{
				pLast = pNext;
				pNext = pNext->pNext;
				delete pLast;
			}
		}
	}
	return true;
}

void AecPipeLineModify::ModifyPipeOnNewInf(AecInterface& infOld,AecInterface& infTo)
{
	AcGePoint3d ptS,ptE;
	bool bSet = false;

	AcDbEntity* pEnt = NULL;
	for (int i = 0;i < m_arPipeIds.length();i++)
	{
		if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,m_arPipeIds.at(i),AcDb::kForRead))
		{
			AecDbEwPipe* pPipe = AecDbEwPipe::cast(pEnt);
			if (pPipe != NULL)
			{
				ptS = pPipe->StartPoint();
				ptE = pPipe->EndPoint();

				if (ptS.distanceTo(infOld.ptPos) < 1.e-2)
				{
					pPipe->upgradeOpen();
					pPipe->SetStartPoint(infTo.ptPos);
					pPipe->downgradeOpen();
					bSet = true;
				}

				if (ptE.distanceTo(infOld.ptPos) < 1.e-2)
				{
					pPipe->upgradeOpen();
					pPipe->SetEndPoint(infTo.ptPos);
					pPipe->downgradeOpen();
					bSet = true;
				}
			}
			pEnt->close();

			if (bSet)
				break;
		}
	}
}

void AecPipeLineModify::ModifyEquAlongList(AecInterface& infOld,AecInterface& infNewTo,AcDbObjectIdInf* pNext,const WPipe::PipeParam& paramNew)
{
	AcDbEntity* pEnt = NULL;
	AcDbObjectIdInf* pLast = pNext;

	AecInterface infFr,infTo;
	AcGePoint3d ptS;
	AcGeVector3d vtDir,vtTmp;
	Acad::ErrorStatus es;

	while(pNext != NULL)
	{
		if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEnt,pNext->id,AcDb::kForWrite)))
		{
			AecDbEwEquipment* pEqu = AecDbEwEquipment::cast(pEnt);
			if (pEqu != NULL)
			{
				AecDbEwEquipment* pNewEqu = CreateNewValve(pEqu,paramNew);
				if (pNewEqu != NULL)
				{
					pNewEqu->GetInsert(ptS,vtDir);

					//新阀门的接口位置必须和原有的对应
					AcArray<AecInterface> arNewInfs;

					AecInterface infNew0,infNew1;
					pNewEqu->GetInterface(0,infNew0);
					pNewEqu->GetInterface(1,infNew1);

					if (infNew0.vtDir.isCodirectionalTo(infNewTo.vtDir))//和上次同向
					{
						//1为连接位置
						pEqu->GetInterface(0,infOld);

						vtTmp = infNewTo.ptPos - infNew1.ptPos;
						ptS += vtTmp;

						pNewEqu->SetInsert(ptS);

						pNewEqu->GetInterface(0,infNewTo);//新的旧接口

						infTo = infNewTo;
					}
					else if(infNew1.vtDir.isCodirectionalTo(infNewTo.vtDir))//和上次同向
					{
						//0为连接位置
						pEqu->GetInterface(1,infOld);

						vtTmp = infNewTo.ptPos - infNew0.ptPos;
						ptS += vtTmp;

						pNewEqu->SetInsert(ptS);

						pNewEqu->GetInterface(1,infNewTo);//新的旧接口

						infTo = infNewTo;
					}
					
					//替换
					pEqu->copyFrom(pNewEqu);
					delete pNewEqu;
				}
			}

			AecDbEwFitting* pFit = AecDbEwFitting::cast(pEnt);
			if (pFit != NULL)
			{
				AecDbEwFitting* pFlang = CreateNewFlang(pFit,paramNew);
				if (pFlang != NULL)
				{
					int nType = 0;
					pFit->GetSpecialtyData()->GetAt(KEY_RUNTIME,nType);
					EFittingType eType = (EFittingType)nType;

					if (eType == eFlange)//是法兰
					{
						AecDbEwFitting* pFlang = CreateNewFlang(pFit,paramNew);
						if (pFlang != NULL)
						{
							AecInterface infNew0,infNew1,infNew;
							pFlang->GetInterface(0,infNew0);
							pFlang->GetInterface(1,infNew1);

							pFlang->GetSpecialtyData()->GetAt(KEY_START,ptS);

							if (infNew0.vtDir.isCodirectionalTo(infNewTo.vtDir))
							{
								//1 为连接位置
								pFit->GetInterface(0,infOld);//旧的连接下一个位置

								vtTmp = infNewTo.ptPos - infNew1.ptPos;
								ptS += vtTmp;

								pFlang->GetSpecialtyData()->SetAt(KEY_START,ptS);

								pFlang->GetInterface(0,infNewTo);//新的旧接口
								infTo = infNewTo;
							}
							else if(infNew1.vtDir.isCodirectionalTo(infNewTo.vtDir))//和上次同向
							{
								//0 为连接位置
								pFit->GetInterface(1,infOld);

								vtTmp = infNewTo.ptPos - infNew0.ptPos;
								ptS += vtTmp;

								pFlang->GetSpecialtyData()->SetAt(KEY_START,ptS);

								pFlang->GetInterface(1,infNewTo);//新的旧接口
								infTo = infNewTo;
							}

							//替换
							pFit->copyFrom(pFlang);
							delete pFlang;

							m_arNetIds.remove(pNext->id);
						}
					}
				}
			}
			pEnt->close();
		}

		pLast = pNext;
		pNext = pNext->pNext;
	}


	//可能更改两侧的管子
	if (pLast != NULL)
	{
		ModifyPipeOnNewInf(infOld,infTo);
	}
}

//沿着list修改阀门
void AecPipeLineModify::ModifyEquAlongList(AcArray<AcDbObjectIdInf>& arAssEquIds,const WPipe::PipeParam& paramNew)
{
	//链的开头记录要整体移动
	AcDbEntity* pEnt = NULL;
	AcGeMatrix3d xMove;
	AcGeVector3d vtDir,vtTmp;
	AcGePoint3d ptS;
	AecInterface infPipe,infTo,infPipeOther,infPipeOtherTo;
	Acad::ErrorStatus es;

	for (int i = 0;i < arAssEquIds.length();i++)
	{
		AcDbObjectIdInf& idInf = arAssEquIds.at(i);
		xMove.setToTranslation(idInf.vtMove);

		if ( Acad::eOk == (es = acdbOpenAcDbEntity(pEnt,idInf.id,AcDb::kForWrite)))
		{
			AecDbEwEquipment* pEqu = AecDbEwEquipment::cast(pEnt);
			if (pEqu != NULL)
			{
				AecDbEwEquipment* pNewEqu = CreateNewValve(pEqu,paramNew);
				if (pNewEqu != NULL)
				{
					pNewEqu->GetInsert(ptS,vtDir);
					ptS += idInf.vtMove;

					//新阀门的接口位置必须和原有的对应
					AecInterface infNew0,infNew1;
					pNewEqu->GetInterface(0,infNew0);
					pNewEqu->GetInterface(1,infNew1);

					//idInf.infFr为链表开头的设备接口
					int nOldTo = -1,nOldOther = -1;
					if (infNew0.vtDir.isCodirectionalTo(idInf.infFr.vtDir))
					{
						vtTmp = infNew0.ptPos - idInf.infFr.ptPos;
						ptS += vtTmp;
						pNewEqu->SetInsert(ptS);
						pNewEqu->GetInterface(0,infTo);
						nOldTo = 0;
						nOldOther = 1;
					}
					else if(infNew1.vtDir.isCodirectionalTo(idInf.infFr.vtDir))
					{
						vtTmp = infNew1.ptPos - idInf.infFr.ptPos;
						ptS += vtTmp;
						pNewEqu->SetInsert(ptS);
						pNewEqu->GetInterface(1,infTo);
						nOldTo = 1;
						nOldOther = 0;
					}

					pEqu->GetInterface(nOldTo,infPipe);
					pEqu->GetInterface(nOldOther,infPipeOther);

					ModifyEquAlongList(idInf.infFr,infTo,idInf.pNext,paramNew);

					//然后替换当前pEqu;
					pEqu->copyFrom(pNewEqu);

					pEqu->GetInterface(nOldTo,infTo);
					pEqu->GetInterface(nOldOther,infPipeOtherTo);

					//可能更改两侧的管子,法兰管的情况下
					ModifyPipeOnNewInf(infPipe,infTo);

					ModifyPipeOnNewInf(infPipeOther,infPipeOtherTo);

					delete pNewEqu;
				}
			}

			AecDbEwFitting* pFit = AecDbEwFitting::cast(pEnt);
			if (pFit != NULL)
			{
				int nType = 0;
				pFit->GetSpecialtyData()->GetAt(KEY_RUNTIME,nType);
				EFittingType eType = (EFittingType)nType;

				if (eType == eFlange)//是法兰
				{
					AecDbEwFitting* pFlang = CreateNewFlang(pFit,paramNew);
					if (pFlang != NULL)
					{
						AecInterface infNew0,infNew1,infNew;
						pFlang->GetInterface(0,infNew0);
						pFlang->GetInterface(1,infNew1);

						//idInf.infFr为链表开头的Fit接口
						int nOldTo = -1,nOldOther = -1;
						if (infNew0.vtDir.isCodirectionalTo(idInf.infFr.vtDir))
						{
							infNew = infNew0;
							nOldTo = 0;
							nOldOther = 1;
						}
						else
						{
							infNew = infNew1;
							nOldTo = 1;
							nOldOther = 0;
						}

						pFit->GetInterface(nOldTo,infPipe);
						pFit->GetInterface(nOldOther,infPipeOther);

						pFlang->GetSpecialtyData()->GetAt(KEY_START,ptS);

						//移动插入点
						vtDir = infNew.ptPos - idInf.infFr.ptPos;
						ptS += vtDir;
						ptS += idInf.vtMove;

						pFlang->GetSpecialtyData()->SetAt(KEY_START,ptS);

						pFlang->GetInterface(nOldTo,infTo);
						pFlang->GetInterface(nOldOther,infPipeOtherTo);

						ModifyEquAlongList(idInf.infFr,infTo,idInf.pNext,paramNew);

						//修改完法兰及连续
						pFit->upgradeOpen();
						pFit->copyFrom(pFlang);
						pFit->downgradeOpen();

						//可能更改两侧的管子
						ModifyPipeOnNewInf(infPipeOther,infPipeOtherTo);

						delete pFlang;
						m_arNetIds.remove(idInf.id);
					}
				}
			}
			pEnt->close();
		}
	}
}

//弯头等fit直接接设备，法兰管线才有
void AecPipeLineModify::MakeEquListStartByEqu(AcArray<AcDbObjectIdInf>& arAssEquIds,AcDbObjectIdArray& arEquIds)
{
	AcDbEntity* pEnt = NULL;

	for (int i = 0;i < arAssEquIds.length();i++)
	{
		AcDbObjectIdInf& idInf = arAssEquIds.at(i);
		AcDbObjectIdInf* pLast = &idInf;

		for (int j = 0;j < arEquIds.length();j++)
		{
			if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,arEquIds.at(j),AcDb::kForRead))
			{
				AecDbEwEquipment* pEqu = AecDbEwEquipment::cast(pEnt);
				if (pEqu != NULL)
				{
					AecMInterfaces* pMInfNew = static_cast<AecMInterfaces*>(pEqu);

					AecInterface infHit;
					if (pMInfNew->GetInterface(idInf.infFr.ptPos,infHit))
					{
						if (pMInfNew->GetInterfaceCount() == 2)//只能支持两个接口的阀门
						{
							AecInterface inf0,inf1;
							pMInfNew->GetInterface(0,inf0);
							pMInfNew->GetInterface(1,inf1);

							AcDbObjectIdInf* pIdInfThis = new AcDbObjectIdInf;
							pIdInfThis->pNext = NULL;
							pIdInfThis->vtMove.set(0,0,0);

							if (inf0.ptPos.distanceTo(infHit.ptPos) < 1.e-2)
							{
								pIdInfThis->id = arEquIds.at(j);
								pIdInfThis->infFr = inf1;
							}
							else
							{
								pIdInfThis->id = arEquIds.at(j);
								pIdInfThis->infFr = inf0;
							}

							pLast->pNext = pIdInfThis;
							pLast = pIdInfThis;
							
							arEquIds.removeAt(j);
							j -= 1;
						}
					}
				}
				pEnt->close();
			}
		}
	}
}

//法兰开始的焊接阀门-法兰-阀门... 阀门含有法兰
void AecPipeLineModify::MakeEquListStartByFlang(AcArray<AcDbObjectIdInf>& arAssFlgs,AcDbObjectIdArray& arEquIds,AcDbObjectIdArray& arFlangIds)
{
	AcDbEntity* pEnt = NULL;

	for (int i = 0;i < arAssFlgs.length();i++)
	{
		AcDbObjectIdInf* pLast = &arAssFlgs[i];

		//先设备
		bool bFindEqu = false;
		bool bFindFit = false;
		while(true)
		{

			bFindEqu = false;
			for (int j = 0;j < arEquIds.length();j++)
			{
				if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,arEquIds.at(j),AcDb::kForRead))
				{
					AecDbEwEquipment* pEqu = AecDbEwEquipment::cast(pEnt);
					if (pEqu != NULL)
					{
						AecMInterfaces* pMInfNew = static_cast<AecMInterfaces*>(pEqu);

						AecInterface infHit;
						if (pMInfNew->GetInterface(pLast->infFr.ptPos,infHit))
						{
							if (pMInfNew->GetInterfaceCount() == 2)//只能支持两个接口的阀门
							{
								AecInterface inf0,inf1;
								pMInfNew->GetInterface(0,inf0);
								pMInfNew->GetInterface(1,inf1);

								AcDbObjectIdInf* pIdInfThis = new AcDbObjectIdInf;
								pIdInfThis->pNext = NULL;
								pIdInfThis->vtMove.set(0,0,0);

								if (inf0.ptPos.distanceTo(infHit.ptPos) < 1.e-2)
								{
									pIdInfThis->id = arEquIds.at(j);
									pIdInfThis->infFr = inf1;
								}
								else
								{
									pIdInfThis->id = arEquIds.at(j);
									pIdInfThis->infFr = inf0;
								}

								pLast->pNext = pIdInfThis;
								pLast = pIdInfThis;

								arEquIds.removeAt(j);
								j -= 1;
								bFindEqu = true;
								pEnt->close();
								break;
							}
						}
					}
					pEnt->close();
				}
			}

			//然后再法兰
			bFindFit = false;
			for (int n = 0;n < arFlangIds.length();n++)
			{
				if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,arFlangIds.at(n),AcDb::kForRead))
				{
					AecDbEwFitting* pFit = AecDbEwFitting::cast(pEnt);
					if (pFit != NULL)
					{
						AecMInterfaces* pMInfNew = static_cast<AecMInterfaces*>(pFit);

						AecInterface infHit;
						if (pMInfNew->GetInterface(pLast->infFr.ptPos,infHit))
						{
							if (pMInfNew->GetInterfaceCount() == 2)//只能支持两个接口的阀门
							{
								AecInterface inf0,inf1;
								pMInfNew->GetInterface(0,inf0);
								pMInfNew->GetInterface(1,inf1);

								AcDbObjectIdInf* pIdInfThis = new AcDbObjectIdInf;
								pIdInfThis->pNext = NULL;
								pIdInfThis->vtMove.set(0,0,0);

								if (inf0.ptPos.distanceTo(infHit.ptPos) < 1.e-2)
								{
									pIdInfThis->id = arFlangIds.at(n);
									pIdInfThis->infFr = inf1;
								}
								else
								{
									pIdInfThis->id = arFlangIds.at(n);
									pIdInfThis->infFr = inf0;
								}

								pLast->pNext = pIdInfThis;
								pLast = pIdInfThis;

								arFlangIds.removeAt(n);
								n -= 1;
								bFindFit = true;
							}
						}
					}
					pEnt->close();
				}
			}

			if (!bFindEqu && !bFindFit)
				break;
		}
	}
}

AcDbObjectIdInf* ReverIdInf(AcDbObjectIdInf& idInf0)
{
	AcArray<AcDbObjectIdInf*> arInfPtrs;

	AcDbObjectIdInf* pNext = idInf0.pNext;
	while(pNext != NULL)
	{
		arInfPtrs.append(pNext);
		pNext = pNext->pNext;
	}
	arInfPtrs.reverse();

	AcDbObjectIdInf* pLast = NULL,*pHead = NULL;
	
	for (int i = 0;i < arInfPtrs.length();i++)
	{
		pNext = arInfPtrs.at(i);

		if (pLast != NULL)
		{
			pLast->pNext = pNext;
			pLast = pNext;
		}
		else
		{
			pLast = pNext;
			pHead = pLast;
			pLast->pNext = NULL;
		}
	}


	AcDbObjectIdInf* pLastBk = pLast;
	if (pLast != NULL)
	{
		pLast->pNext = NULL;

		pNext = new AcDbObjectIdInf;
		pNext->id = idInf0.id;
		pNext->infFr = idInf0.infFr;
		pNext->vtMove = idInf0.vtMove;
		pNext->pNext = NULL;
		pLast->pNext = pNext;
		pLast = pNext;
	}

	//Head由 idInf0代替
	if (pHead != NULL)
	{
		idInf0.id = pHead->id;
		idInf0.infFr = pHead->infFr;
		idInf0.pNext = pHead->pNext;
		delete pHead;
	}

	//TAIL 
	return pLast;
}

void ReverIdInfInf(AcDbObjectIdInf* pNext)
{
	AecInterface inf0,inf1;
	AcDbEntity* pEnt = NULL;
	while(pNext != NULL)
	{
		if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,pNext->id,AcDb::kForRead))
		{
			AecDbEwEquipment* pEqu = AecDbEwEquipment::cast(pEnt);
			if (pEqu != NULL)
			{
				AecMInterfaces* pMInfNew = static_cast<AecMInterfaces*>(pEqu);
				if (pMInfNew->GetInterfaceCount() == 2)
				{
					pMInfNew->GetInterface(0,inf0);
					pMInfNew->GetInterface(1,inf1);

					if (inf0.vtDir.isCodirectionalTo(pNext->infFr.vtDir))
					{
						pNext->infFr = inf1;
					}
					else if (inf1.vtDir.isCodirectionalTo(pNext->infFr.vtDir))
					{
						pNext->infFr = inf0;
					}
				}
			}

			AecDbEwFitting* pFit = AecDbEwFitting::cast(pEnt);
			if (pFit != NULL)
			{
				AecMInterfaces* pMInfNew = static_cast<AecMInterfaces*>(pFit);
				if (pMInfNew->GetInterfaceCount() == 2)
				{
					pMInfNew->GetInterface(0,inf0);
					pMInfNew->GetInterface(1,inf1);

					if (inf0.vtDir.isCodirectionalTo(pNext->infFr.vtDir))
					{
						pNext->infFr = inf1;
					}
					else if (inf1.vtDir.isCodirectionalTo(pNext->infFr.vtDir))
					{
						pNext->infFr = inf0;
					}
				}
			}
			pEnt->close();
		}
		pNext = pNext->pNext;
	}
}

void AecPipeLineModify::MakeEquListTheRest(AcDbObjectIdArray& arEquIds,AcDbObjectIdArray& arFlangIds,AcArray<AcDbObjectIdInf>& arIdInf)
{
	//先设备
	AcDbEntity* pEnt = NULL;
	AcDbObjectId id;
	
	while( !arEquIds.isEmpty())
	{
		id = arEquIds.first();
		arEquIds.removeFirst();

		if (Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForRead))
		{
			AecDbEwEquipment* pEqu = AecDbEwEquipment::cast(pEnt);
			if (pEqu != NULL)
			{
				AecMInterfaces* pMInfNew = static_cast<AecMInterfaces*>(pEqu);
				if (pMInfNew->GetInterfaceCount() == 2)
				{
					AecInterface inf0,inf1;
					pMInfNew->GetInterface(0,inf0);
					pMInfNew->GetInterface(1,inf1);

					AcDbObjectIdInf idInf0;
					idInf0.pNext = NULL;
					idInf0.id = id;
					idInf0.infFr = inf0;
					idInf0.vtMove.set(0,0,0);

					//向左
					AcArray<AcDbObjectIdInf> arIdInf0;
					arIdInf0.append(idInf0);
					MakeEquListStartByFlang(arIdInf0,arEquIds,arFlangIds);

					//向右
					AcDbObjectIdInf idInf1;
					idInf1.pNext = NULL;
					idInf1.id = id;
					idInf1.infFr = inf1;
					idInf0.vtMove.set(0,0,0);

					AcArray<AcDbObjectIdInf> arIdInf1;
					arIdInf1.append(idInf1);
					MakeEquListStartByFlang(arIdInf1,arEquIds,arFlangIds);

					//左右合成生成一条链
					AcDbObjectIdInf* pTail = ReverIdInf(arIdInf0.first());
					if (pTail != NULL)
					{
						//arIdInf0取右侧接口
						AcDbObjectIdInf* pNext = &arIdInf0.first();
						ReverIdInfInf(pNext);

						pTail->pNext = arIdInf1.first().pNext;

						//添加一条链
						arIdInf.append(arIdInf0.first());
					}
					else
					{
						//...
						//添加一条链
						arIdInf.append(arIdInf1.first());
					}
				}
			}
			pEnt->close();
		}
	}
}

bool AecPipeLineModify::ModifyFitting(AecDbEwFitting* pFitting,const WPipe::PipeParam& paramNew)
{
	bool bSuccesed = false;
	WPipe::PipeParam* pParam = (WPipe::PipeParam*)&paramNew;
	
	AecDbObjXDataMap* pXDataMap = pFitting->GetSpecialtyData();

	if (m_bUpdateMat)
	{
		pXDataMap->SetAt(PIPE_MATERIAL,pParam->szMertial);
		pXDataMap->SetAt(PIPE_MATERIALFT,pParam->szMertialFit);
		pXDataMap->SetAt(PIPE_SYS, pParam->szSys);
		pXDataMap->SetAt(PIPE_COLOR, pParam->m_nPipeColor);

		//设置图层
		TDbPipeLine::SetFittingLayer(pFitting, pParam->szSys);
	}

	//标准和外径系列
	pXDataMap->SetAt(PIPE_ODSN, pParam->szODSn);
	pXDataMap->SetAt(PIPE_SHTNO,pParam->szStdNo);

	CString sODNo = pParam->szODSn;
	bool bIsPvc = TDbPipeLine::IsPlasticsMat(pParam, sODNo);
	
	int nType = 0,nLocked = -1;
	pXDataMap->GetAt(KEY_RUNTIME,nType);
	EFittingType eType = (EFittingType)nType;

	//如果DN不变,仅仅改外径和壁厚
	double dDNOld = 0.0;
	pXDataMap->GetAt(PIPE_DN,dDNOld);

	if ( fabs(dDNOld - pParam->m_dDN) < 1.e-2 )
	{
		pXDataMap->SetAt(PIPE_OD,pParam->m_dOD);
		pXDataMap->SetAt(PIPE_THICK,pParam->m_dThick);

		//如果曲率半径改变
		double dOldRatio = 2.0;
		pXDataMap->GetAt(PIPE_RATIO,dOldRatio);
		if ( fabs(dOldRatio - pParam->m_dRRatio) > 1.e-2)
		{
			if (eType != eElbow)//不是弯头
			{
				pXDataMap->SetAt(PIPE_RATIO,pParam->m_dRRatio);
				return true;
			}
			else
			{
				//进行到弯头修改
			}
		}
		else//曲率半径不变
		{
			return true;
		}
	}

	int nConnectType = 0;
	pXDataMap->GetAt(PIPE_CONNECT,nConnectType);

	double dPre = 1.6;
	pXDataMap->GetAt(PIPE_PRESSURE, dPre);

	CString sProject;
	pXDataMap->GetAt(DOC_PROJECT, sProject);

	CString sLevel;
	pXDataMap->GetAt(PIPE_LEVEL, sLevel);

	CString sKey;

	//弯头,三通,四通,变径
	switch( eType )
	{
	case eElbow:
		{
			if (nConnectType > 0)
			{
				double dFD = 0.0,dFL = 0.0;
				TDbPipeSupport::QueryInfFDFL(m_pADOServer,eElbow,pParam->m_nConnectType,pParam->m_dDN,dFD,dFL, sODNo, sProject, sLevel);

				pParam->m_dInterfaceD = dFD;
				pParam->m_dInterfaceL = dFL;

				if (pParam->m_nConnectType == 3)
				{
					//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
					double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
					TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject,sLevel,sODNo);
					pParam->m_dWh = dWh;
					pParam->m_dWn = dN;
				}
			}

			TDbPipeLine pLn(NULL);
			pLn.SetPipeParam(pParam);
			pLn.SetInitDataMapPartFrom(pXDataMap);
			pLn.FillConfigXDataMap(pXDataMap,pParam);

			pXDataMap->SetAt(PIPE_WH,pParam->m_dWh);
			pXDataMap->SetAt(PIPE_WN,pParam->m_dWn);
			pXDataMap->SetAt(PIPE_RATIO,pParam->m_dRRatio);
			pXDataMap->SetAt(PIPE_THICK,pParam->m_dThick);

			//结构长度
			double dL = 0.0;
			if (!bIsPvc)
			{
				pXDataMap->SetAt(KEY_RadRatio, pParam->m_nRadioOn);
				TDbPipeSupport::QueryElbowL(m_pADOServer, pParam->m_dDN, dL, pParam->m_dRRatio, pParam->m_nConnectType, pParam->szLevel, pParam->szODSn, pXDataMap);
				pXDataMap->SetAt(KEY_Length, dL);
			}
			else
			{
				TDbPipeSupport::QueryPVCElbow(m_pADOServer, pParam->m_dDN, pXDataMap, sODNo);
			}

			pFitting->ReCreateDraw2d();
			pFitting->ReCreateDraw3d();

			bSuccesed = true;
			break;
		}
	case eTee:
		{
			if (m_bTeeStop) //三通分支管径不改尺寸; 主接口可修改.分支锁定
			{
TeeStop:
				double dTDN = 0.0;
				pXDataMap->GetAt(PIPE_TDN,dTDN);

				double dDN = 0.0;
				pXDataMap->GetAt(PIPE_DN,dDN);

				nLocked = -1;
				for(int k = 0;k < 3;k++)
				{
					sKey.Format(_T("LK_%d"),k);
					if ( pXDataMap->GetAt(sKey,nLocked) )
					{
						if (nLocked > -1)
						{
							break;
						}
					}
				}

				if (nLocked == 2)//分支锁定,改主管
				{
					if ( ( dTDN - pParam->m_dDN ) > 1.e-2)
					{
						acutPrintf(_T("\n三通分支管径大于主管径!修改管径失败!"));
						return false;
					}

					//主接口可修改.分支锁定
					//原来的主接口
					AecInterface inf2;
					pFitting->GetInterface(2,inf2);

					if (nConnectType > 0)
					{
						double dFD = 0.0,dFL = 0.0;
						double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
						TDbPipeSupport::QueryInfFDFL(m_pADOServer,eTee,nConnectType,pParam->m_dDN,dFD,dFL, sODNo,sProject,sLevel);

						pXDataMap->SetAt(PIPE_INTERFACED,dFD);
						pXDataMap->SetAt(PIPE_INTERFACEL,dFL);

						if ( nConnectType == 3)
						{
							//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
							TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);
							pXDataMap->SetAt(PIPE_WH,dThk);
							pXDataMap->SetAt(PIPE_WN,dN);
						}
					}

					double dL = 0.0,dS = 0.0;
					if ( TDbPipeSupport::QueryTeeData(m_pADOServer,pParam->m_dDN,dTDN,dL,dS, sODNo, sProject, sLevel) )
					{
						double dInterfaceL = 0.0;
						pXDataMap->GetAt(PIPE_INTERFACEL,dInterfaceL);
						if (dInterfaceL > 1.e-3)//法兰管
						{
							dL += dInterfaceL;
							dS += dInterfaceL;
						}

						if ( nConnectType == 3)//法兰连接
						{
							//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
							double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
							TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);

							dL -= dInterfaceL;
							dS -= dInterfaceL;

							//颈法兰焊接方式
							if (sODNo.CompareNoCase( _T("S")) != 0 &&
								sODNo.CompareNoCase(_T("GSF")) != 0)
							{
								dL += dThk;
								dS += dThk;
							}
						}
					}

					pXDataMap->SetAt(PIPE_DN,pParam->m_dDN);
					pXDataMap->SetAt(PIPE_OD,pParam->m_dOD);

					pXDataMap->SetAt(PIPE_THICK,pParam->m_dThick);

					pXDataMap->SetAt(KEY_L,dL * 2);
					pXDataMap->SetAt(KEY_T,dS);

					pFitting->ReCreateDraw2d();
					pFitting->ReCreateDraw3d();

					//记录更改调整,后面调整管线或阀门
					AecInterface inf22;
					pFitting->GetInterface(2,inf22);

					AecInterfaceFrTo infFrTo;
					infFrTo.infFr = inf2;
					infFrTo.infTo = inf22;
					m_arFrTo.append(infFrTo);
				}
				else //主管锁定,改分支
				{
					if ( ( pParam->m_dDN - dDN) > 1.e-2)
					{
						acutPrintf(_T("\n三通分支管径大于主管径!修改管径失败!"));
						return false;
					}

					if (nConnectType > 0)
					{
						double dFD = 0.0,dFL = 0.0;
						double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
						TDbPipeSupport::QueryInfFDFL(m_pADOServer,eTee,nConnectType,pParam->m_dDN,dFD,dFL, sODNo, sProject, sLevel);

						pXDataMap->SetAt(PIPE_INTERFACED2,dFD);
						pXDataMap->SetAt(PIPE_INTERFACEL2,dFL);

						if ( nConnectType == 3)
						{
							//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
							TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);
							pXDataMap->SetAt(PIPE_WH2,dThk);
							pXDataMap->SetAt(PIPE_WN2,dN);
						}
					}

					double dL = 0.0,dS = 0.0;
					if ( TDbPipeSupport::QueryTeeData(m_pADOServer,dDN,pParam->m_dDN,dL,dS, sODNo, sProject, sLevel) )
					{
						double dInterfaceL = 0.0;
						pXDataMap->GetAt(PIPE_INTERFACEL,dInterfaceL);
						if (dInterfaceL > 1.e-3)//法兰管
						{
							dL += dInterfaceL;
							dS += dInterfaceL;
						}

						if ( nConnectType == 3)//法兰连接
						{
							//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
							double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
							TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);

							dL -= dInterfaceL;
							dS -= dInterfaceL;

							//颈法兰焊接方式
							if (sODNo.CompareNoCase(_T("S")) != 0 &&
								sODNo.CompareNoCase(_T("GSF")) != 0)
							{
								dL += dThk;
								dS += dThk;
							}
						}
					}

					pXDataMap->SetAt(PIPE_TDN,pParam->m_dDN);
					pXDataMap->SetAt(PIPE_TOD,pParam->m_dOD);
					pXDataMap->SetAt(PIPE_THICK,pParam->m_dThick);

					pXDataMap->SetAt(KEY_L,dL * 2);
					pXDataMap->SetAt(KEY_T,dS);

					pFitting->ReCreateDraw2d();
					pFitting->ReCreateDraw3d();
				}
				bSuccesed = true;
			}
			else//全改,统一DN
			{
				double dDN = 0.0,dTDN = 0.0;
				pXDataMap->GetAt(PIPE_DN,dDN);
				pXDataMap->GetAt(PIPE_TDN,dTDN);

				if ( fabs(dTDN - dDN) > 1.e-2)
				{
					goto TeeStop;
					break;
				}

				if (nConnectType > 0)
				{
					double dFD = 0.0,dFL = 0.0;
					double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
					TDbPipeSupport::QueryInfFDFL(m_pADOServer,eTee,nConnectType,pParam->m_dDN,dFD,dFL, sODNo, sProject, sLevel);

					pXDataMap->SetAt(PIPE_INTERFACED2,dFD);
					pXDataMap->SetAt(PIPE_INTERFACEL2,dFL);
					pXDataMap->SetAt(PIPE_INTERFACED,dFD);
					pXDataMap->SetAt(PIPE_INTERFACEL,dFL);

					if ( nConnectType == 3)
					{
						//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
						TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);
						pXDataMap->SetAt(PIPE_WH2,dThk);
						pXDataMap->SetAt(PIPE_WN2,dN);
						pXDataMap->SetAt(PIPE_WH,dThk);
						pXDataMap->SetAt(PIPE_WN,dN);
					}
				}

				double dL = 0.0,dS = 0.0;
				if ( TDbPipeSupport::QueryTeeData(m_pADOServer,pParam->m_dDN,pParam->m_dDN,dL,dS, sODNo, sProject, sLevel) )
				{
					double dInterfaceL = 0.0;
					pXDataMap->GetAt(PIPE_INTERFACEL,dInterfaceL);
					if (dInterfaceL > 1.e-3)//法兰管
					{
						dL += dInterfaceL;
						dS += dInterfaceL;
					}

					if ( nConnectType == 3)//法兰连接
					{
						//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
						double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
						TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);

						dL -= dInterfaceL;
						dS -= dInterfaceL;

						//颈法兰焊接方式
						if (sODNo.CompareNoCase(_T("S")) != 0 &&
							sODNo.CompareNoCase(_T("GSF")) != 0)
						{
							dL += dThk;
							dS += dThk;
						}

					}
				}

				pXDataMap->SetAt(PIPE_DN,pParam->m_dDN);
				pXDataMap->SetAt(PIPE_OD,pParam->m_dOD);

				pXDataMap->SetAt(PIPE_TDN,pParam->m_dDN);
				pXDataMap->SetAt(PIPE_TOD,pParam->m_dOD);

				pXDataMap->SetAt(PIPE_THICK,pParam->m_dThick);

				pXDataMap->SetAt(KEY_L,dL * 2);
				pXDataMap->SetAt(KEY_T,dS);

				pFitting->ReCreateDraw2d();
				pFitting->ReCreateDraw3d();

				bSuccesed = true;
			}
			break;
		}
	case eCross:
		{
			if (m_bCrossStop)//四通分支管径不改尺寸
			{
CrossStop:
				nLocked = -1;
				for(int k = 0;k < 4;k++)
				{
					sKey.Format(_T("LK_%d"),k);
					if ( pXDataMap->GetAt(sKey,nLocked) )
					{
						if (nLocked > -1)
						{
							break;
						}
					}
				}

				if (nLocked > 1)//分支锁定,改主管
				{
					double dTDN = 0.0;
					pXDataMap->GetAt(PIPE_TDN,dTDN);

					double dDN = 0.0;
					pXDataMap->GetAt(PIPE_DN,dDN);

					if (nConnectType > 0)
					{
						double dFD = 0.0,dFL = 0.0;
						TDbPipeSupport::QueryInfFDFL(m_pADOServer,eCross,pParam->m_nConnectType,pParam->m_dDN,dFD,dFL, sODNo, sProject, sLevel);

						pXDataMap->SetAt(PIPE_INTERFACED,dFD);
						pXDataMap->SetAt(PIPE_INTERFACEL,dFL);

						if (nConnectType == 3)
						{
							//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
							double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
							TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);

							pXDataMap->SetAt(PIPE_WH,dThk);
							pXDataMap->SetAt(PIPE_WN,dN);
						}
					}

					double dL = 0.0,dB = 0.0;
					if ( TDbPipeSupport::QueryCrossData(m_pADOServer,pParam->m_dDN,pParam->m_dDN,dL,dB, sODNo, sProject, sLevel) )
					{
						double dInterfaceL = 0.0;
						pXDataMap->GetAt(PIPE_INTERFACEL,dInterfaceL);

						if (dInterfaceL > 1.e-3)//法兰管
						{
							dL += dInterfaceL;
							dB += dInterfaceL;
						}

						if ( nConnectType == 3)//法兰连接
						{
							//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
							double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
							TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);

							dL -= dInterfaceL;
							dB -= dInterfaceL;

							//颈法兰焊接方式
							if (sODNo.CompareNoCase(_T("S")) != 0 &&
								sODNo.CompareNoCase(_T("GSF")) != 0)
							{
								dL += dThk;
								dB += dThk;
							}

						}
					}

					//记录分支前
					AecInterface inf2,inf3;
					pFitting->GetInterface(2,inf2);
					pFitting->GetInterface(3,inf3);

					pXDataMap->SetAt(PIPE_DN,pParam->m_dDN);
					pXDataMap->SetAt(PIPE_OD,pParam->m_dOD);

					pXDataMap->SetAt(PIPE_THICK,pParam->m_dThick);

					pXDataMap->SetAt(KEY_L,dL * 2);
					pXDataMap->SetAt(KEY_T,dB * 2);

					pFitting->ReCreateDraw2d();
					pFitting->ReCreateDraw3d();

					//记录分支后
					AecInterface inf22,inf33;
					pFitting->GetInterface(2,inf22);
					pFitting->GetInterface(3,inf33);

					AecInterfaceFrTo infFt;
					infFt.infFr = inf2;
					infFt.infTo = inf22;
					m_arFrTo.append(infFt);

					infFt.infFr = inf3;
					infFt.infTo = inf33;
					m_arFrTo.append(infFt);
				}
				else//主管锁定,改分支
				{
					double dTDN = 0.0;
					pXDataMap->GetAt(PIPE_TDN,dTDN);

					double dDN = 0.0;
					pXDataMap->GetAt(PIPE_DN,dDN);

					if (nConnectType > 0)
					{
						double dFD = 0.0,dFL = 0.0;
						TDbPipeSupport::QueryInfFDFL(m_pADOServer,eCross,pParam->m_nConnectType,dDN,dFD,dFL, sODNo, sProject, sLevel);

						pXDataMap->SetAt(PIPE_INTERFACED2,dFD);
						pXDataMap->SetAt(PIPE_INTERFACEL2,dFL);

						if (nConnectType == 3)
						{
							//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
							double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
							TDbPipeSupport::QueryFlangData(m_pADOServer,dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);

							pXDataMap->SetAt(PIPE_WH2,dThk);
							pXDataMap->SetAt(PIPE_WN2,dN);
						}
					}

					double dL = 0.0,dB = 0.0;
					if ( TDbPipeSupport::QueryCrossData(m_pADOServer,dDN,pParam->m_dDN,dL,dB, sODNo, sProject, sLevel) )
					{
						double dInterfaceL = 0.0;
						pXDataMap->GetAt(PIPE_INTERFACEL,dInterfaceL);

						if (dInterfaceL > 1.e-3)//法兰管
						{
							dL += dInterfaceL;
							dB += dInterfaceL;
						}

						if ( nConnectType == 3)//法兰连接
						{
							//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
							double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
							TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);

							dL -= dInterfaceL;
							dB -= dInterfaceL;

							//颈法兰焊接方式
							if (sODNo.CompareNoCase(_T("S")) != 0 &&
								sODNo.CompareNoCase(_T("GSF")) != 0)
							{
								dL += dThk;
								dB += dThk;
							}

						}
					}

					//记录主管前
					AecInterface inf0,inf1;
					pFitting->GetInterface(0,inf0);
					pFitting->GetInterface(1,inf1);

					pXDataMap->SetAt(PIPE_TDN,pParam->m_dDN);
					pXDataMap->SetAt(PIPE_TOD,pParam->m_dOD);

					pXDataMap->SetAt(PIPE_THICK,pParam->m_dThick);

					pXDataMap->SetAt(KEY_L,dL * 2);
					pXDataMap->SetAt(KEY_T,dB * 2);

					pFitting->ReCreateDraw2d();
					pFitting->ReCreateDraw3d();

					//记录主管后
					AecInterface inf00,inf11;
					pFitting->GetInterface(0,inf00);
					pFitting->GetInterface(1,inf11);

					AecInterfaceFrTo infFt;
					infFt.infFr = inf0;
					infFt.infTo = inf00;
					m_arFrTo.append(infFt);

					infFt.infFr = inf1;
					infFt.infTo = inf11;
					m_arFrTo.append(infFt);
				}
				bSuccesed = true;
			}
			else//全改,统一DN
			{
				double dDN = 0.0,dTDN = 0.0;
				pXDataMap->GetAt(PIPE_DN,dDN);
				pXDataMap->GetAt(PIPE_TDN,dTDN);

				if ( fabs(dTDN - dDN) > 1.e-2)
				{
					goto CrossStop;
					break;
				}

				if (nConnectType > 0)
				{
					double dFD = 0.0,dFL = 0.0;
					TDbPipeSupport::QueryInfFDFL(m_pADOServer,eCross,pParam->m_nConnectType,pParam->m_dDN,dFD,dFL, sODNo, sProject, sLevel);

					pXDataMap->SetAt(PIPE_INTERFACED,dFD);
					pXDataMap->SetAt(PIPE_INTERFACEL,dFL);

					pXDataMap->SetAt(PIPE_INTERFACED2,dFD);
					pXDataMap->SetAt(PIPE_INTERFACEL2,dFL);

					if (nConnectType == 3)
					{
						//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
						double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
						TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);

						pXDataMap->SetAt(PIPE_WH,dThk);
						pXDataMap->SetAt(PIPE_WN,dN);
						pXDataMap->SetAt(PIPE_WH2,dThk);
						pXDataMap->SetAt(PIPE_WN2,dN);
					}
				}

				double dL = 0.0,dB = 0.0;
				if ( TDbPipeSupport::QueryCrossData(m_pADOServer,pParam->m_dDN,pParam->m_dDN,dL,dB, sODNo, sProject, sLevel) )
				{
					double dInterfaceL = 0.0;
					pXDataMap->GetAt(PIPE_INTERFACEL,dInterfaceL);

					if (dInterfaceL > 1.e-3)//法兰管
					{
						dL += dInterfaceL;
						dB += dInterfaceL;
					}

					if ( nConnectType == 3)//法兰连接
					{
						//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
						double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
						TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);

						dL -= dInterfaceL;
						dB -= dInterfaceL;

						//颈法兰焊接方式
						if (sODNo.CompareNoCase(_T("S")) != 0 &&
							sODNo.CompareNoCase(_T("GSF")) != 0)
						{
							dL += dThk;
							dB += dThk;
						}

					}
				}

				pXDataMap->SetAt(PIPE_DN,pParam->m_dDN);
				pXDataMap->SetAt(PIPE_OD,pParam->m_dOD);

				pXDataMap->SetAt(PIPE_TDN,pParam->m_dDN);
				pXDataMap->SetAt(PIPE_TOD,pParam->m_dOD);

				pXDataMap->SetAt(PIPE_THICK,pParam->m_dThick);

				pXDataMap->SetAt(KEY_L,dL * 2);
				pXDataMap->SetAt(KEY_T,dB * 2);

				pFitting->ReCreateDraw2d();
				pFitting->ReCreateDraw3d();

				bSuccesed = true;
			}
			break;
		}
	case eWye://对于 Wye 的三个接口尺寸一样
		{
			double dDN = 0.0,dTDN = 0.0;
			pXDataMap->GetAt(PIPE_DN,dDN);
			pXDataMap->GetAt(PIPE_TDN,dTDN);

			if ( nConnectType > 0)
			{
				double dFD = 0.0,dFL = 0.0;
				TDbPipeSupport::QueryInfFDFL(m_pADOServer,eWye, nConnectType,pParam->m_dDN,dFD,dFL, sODNo, sProject, sLevel);

				pXDataMap->SetAt(PIPE_INTERFACED,dFD);
				pXDataMap->SetAt(PIPE_INTERFACEL,dFL);

				pXDataMap->SetAt(PIPE_INTERFACED2,dFD);
				pXDataMap->SetAt(PIPE_INTERFACEL2,dFL);

				if ( nConnectType == 3)
				{
					//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
					double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
					TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);
					pXDataMap->SetAt(PIPE_WH2,dThk);
					pXDataMap->SetAt(PIPE_WN2,dN);
					pXDataMap->SetAt(PIPE_WH,dThk);
					pXDataMap->SetAt(PIPE_WN,dN);
				}
			}

			int nType = 0;
			double dM = 0.0, dB = 0.0, dInsL = 0.0, dInfD = 0.0;
			TDbPipeSupport::QueryWYeData(m_pADOServer, (int)(pParam->m_dDN + 0.5), dM, dB, dInsL, dInfD, 0, sProject, sLevel);

			double dInterfaceL = 0.0;
			pXDataMap->GetAt(PIPE_INTERFACEL,dInterfaceL);

			if (dInterfaceL > 1.e-3)
			{
				dM += dInterfaceL;
				dB += dInterfaceL;
			}

			if ( nConnectType == 3)//法兰连接
			{
				//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
				double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
				TDbPipeSupport::QueryFlangData(m_pADOServer, (int)(pParam->m_dDN + 0.5),1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);

				//颈法兰焊接方式
				if (sODNo.CompareNoCase(_T("S")) != 0 &&
					sODNo.CompareNoCase(_T("GSF")) != 0)
				{
					dB += (dThk - dWh);
					dM += (dThk - dWh);
				}

			}

			pXDataMap->SetAt(PIPE_DN,pParam->m_dDN);
			pXDataMap->SetAt(PIPE_OD,pParam->m_dOD);

			pXDataMap->SetAt(PIPE_TDN,pParam->m_dDN);
			pXDataMap->SetAt(PIPE_TOD,pParam->m_dOD);

			pXDataMap->SetAt(PIPE_THICK,pParam->m_dThick);

			pXDataMap->SetAt(PIPE_M,dM);
			pXDataMap->SetAt(PIPE_B,dB);

			pFitting->ReCreateDraw2d();
			pFitting->ReCreateDraw3d();

			bSuccesed = true;

			break;
		}
	case eLateral: //对于Lateral ,三个接口全改
		{
			if ( nConnectType > 0)
			{
				double dDN = 0.0,dTDN = 0.0;
				pXDataMap->GetAt(PIPE_DN,dDN);
				pXDataMap->GetAt(PIPE_TDN,dTDN);

				double dFD = 0.0,dFL = 0.0;
				TDbPipeSupport::QueryInfFDFL(m_pADOServer,eLateral, nConnectType,pParam->m_dDN,dFD,dFL, sODNo, sProject, sLevel);

				pXDataMap->SetAt(PIPE_INTERFACED,dFD);
				pXDataMap->SetAt(PIPE_INTERFACEL,dFL);
				pXDataMap->SetAt(PIPE_INTERFACED2,dFD);
				pXDataMap->SetAt(PIPE_INTERFACEL2,dFL);

				if ( nConnectType == 3)
				{
					//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
					double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
					TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);
					pXDataMap->SetAt(PIPE_WH2,dThk);
					pXDataMap->SetAt(PIPE_WN2,dN);
					pXDataMap->SetAt(PIPE_WH,dThk);
					pXDataMap->SetAt(PIPE_WN,dN);
				}
			}

			double dE = 0.0, dM = 0.0, dB = 0.0, dInsL = 0.0, dInfD = 0.0;
			TDbPipeSupport::QueryLateralData(m_pADOServer, (int)(pParam->m_dDN+0.5), dE, dM, dB, dInsL, dInfD, 0, sProject, sLevel);

			double dInterfaceL = 0.0;
			pXDataMap->GetAt(PIPE_INTERFACEL,dInterfaceL);

			if ( dInterfaceL > 1.e-3)
			{
				dE += dInterfaceL;
				dM += dInterfaceL;
				dB += dInterfaceL;
			}

			if ( nConnectType == 3)//法兰连接
			{
				//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
				double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
				TDbPipeSupport::QueryFlangData(m_pADOServer,(int)(pParam->m_dDN+0.5),1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);

				//颈法兰焊接方式
				if (sODNo.CompareNoCase(_T("S")) != 0 &&
					sODNo.CompareNoCase(_T("GSF")) != 0)
				{
					dE += (dThk - dWh);
					dB += (dThk - dWh);
					dM += (dThk - dWh);
				}

			}

			pXDataMap->SetAt(PIPE_DN,pParam->m_dDN);
			pXDataMap->SetAt(PIPE_OD,pParam->m_dOD);
			pXDataMap->SetAt(PIPE_TDN,pParam->m_dDN);
			pXDataMap->SetAt(PIPE_TOD,pParam->m_dOD);
			pXDataMap->SetAt(PIPE_THICK,pParam->m_dThick);

			pXDataMap->SetAt(PIPE_E,dE);
			pXDataMap->SetAt(PIPE_M,dM);
			pXDataMap->SetAt(PIPE_B,dB);

			pFitting->ReCreateDraw2d();
			pFitting->ReCreateDraw3d();

			bSuccesed = true;
			
			break;
		}
	case eReduce:
		{
			double dL = 0.0;
			pXDataMap->GetAt(KEY_Length,dL);

			double dD = 0.0;
			pXDataMap->GetAt(PIPE_D,dD);

			double dDN = 0.0;
			pXDataMap->GetAt(PIPE_DN,dDN);

			double dTDN = 0.0;
			pXDataMap->GetAt(PIPE_EDN,dTDN);

			//判断修改端
			if ( fabs(m_paramOld.m_dDN - dDN) < 1.e-2)//
			{
				if ( fabs( pParam->m_dDN - dDN ) < 1.e-2)
				{
					acutPrintf(_T("\n分支管径等于主管径!修改管径取消!"));
					return false;
				}

				//改主管,分支不变
				if ( nConnectType > 0)//
				{
					double dFD = 0.0,dFL = 0.0;
					TDbPipeSupport::QueryInfFDFL(m_pADOServer,eReduce, nConnectType,pParam->m_dDN,dFD,dFL, sODNo, sProject, sLevel);
					pXDataMap->SetAt(PIPE_INTERFACED2,dFD);
					pXDataMap->SetAt(PIPE_INTERFACEL2,dFL);
				}

				//长度单独设置
				if (!TDbPipeSupport::QueryReduceData(m_pADOServer, nConnectType,(int)pParam->m_dDN, (int)dTDN, dL,pXDataMap,sODNo))
				{
					acutPrintf(_T("\n没有查到%d到%d的变径长度!变径变更失败!"), (int)pParam->m_dDN, (int)dTDN);
					return false;
				}

				pParam->m_dInterfaceL3 = dL;

				//记录修改前
				AecInterface inf1;
				pFitting->GetInterface(1,inf1);

				pXDataMap->SetAt(KEY_Length,dL);
				pXDataMap->SetAt(PIPE_INTERFACEL3,dL);
				pXDataMap->SetAt(PIPE_DN,pParam->m_dDN);
				pXDataMap->SetAt(PIPE_OD,pParam->m_dOD);
				pXDataMap->SetAt(PIPE_D,pParam->m_dDN);

				AcGeVector3d vtDir;
				pXDataMap->GetAt(KEY_MAJBR,vtDir);
				AcGePoint3d ptSta;
				pXDataMap->GetAt(KEY_START,ptSta);

				vtDir.normalize();
				AcGePoint3d ptEnd = ptSta + pParam->m_dInterfaceL3 * vtDir;
				if ( nConnectType == 3)//法兰连接
				{
					//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
					double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
					TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD,dWh,dThk,dN);

					double dWD2 = 0.0,dWh2 = 0.0,dThk2 = 0.0,dN2 = 0.0;
					TDbPipeSupport::QueryFlangData(m_pADOServer,dTDN,1.0,dWD2,dWh2,dThk2,dN2);

					//颈法兰焊接方式
					if (sODNo.CompareNoCase(_T("S")) != 0 &&
						sODNo.CompareNoCase(_T("GSF")) != 0)
					{
						ptEnd += (dThk2 + dThk) * vtDir;
					}

					pXDataMap->SetAt(PIPE_WN2,dN);
					pXDataMap->SetAt(PIPE_WH2,dThk);
				}

				//是否偏移
				double dOffset = (pParam->m_dDN - dTDN) / 2.0;

				AcGeVector3d vtOffset;
				pXDataMap->GetAt(KEY_OFFSET,vtOffset);

				vtOffset.normalize();
				vtOffset *= dOffset;

				ptEnd += vtOffset;
				pXDataMap->SetAt(KEY_END,ptEnd);

				pFitting->ReCreateDraw2d();
				pFitting->ReCreateDraw3d();

				//记录修改后
				AecInterface inf11;
				pFitting->GetInterface(1,inf11);

				AecInterfaceFrTo infFt;
				infFt.infFr = inf1;
				infFt.infTo = inf11;
				m_arFrTo.append(infFt);
			}
			else//主管不改，改分支
			{
				if ( fabs( pParam->m_dDN - dTDN ) < 1.e-2)
				{
					acutPrintf(_T("\n分支管径等于主管径!修改管径取消!"));
					return false;
				}

				if ( nConnectType > 0)//
				{
					double dFD = 0.0,dFL = 0.0;
					TDbPipeSupport::QueryInfFDFL(m_pADOServer,eReduce, nConnectType,pParam->m_dDN,dFD,dFL, sProject, sLevel);
					pXDataMap->SetAt(PIPE_INTERFACED,dFD);
					pXDataMap->SetAt(PIPE_INTERFACEL,dFL);
				}

				//长度单独设置
				if (!TDbPipeSupport::QueryReduceData(m_pADOServer, nConnectType, dDN, (int)pParam->m_dDN, dL, pXDataMap,sODNo))
				{
					acutPrintf(_T("\n没有查到%d到%d的变径长度!变径变更失败!"), (int)pParam->m_dDN, (int)dTDN);
					return false;
				}
				
				double dLx = 0, dSx = 0;
				pXDataMap->GetAt(_T("H2"), dLx);
				pXDataMap->GetAt(_T("H1"), dSx);
				pParam->m_dInterfaceL3 = dL;

				pXDataMap->SetAt(KEY_Length,dL);
				pXDataMap->SetAt(PIPE_EDN,pParam->m_dDN);
				pXDataMap->SetAt(PIPE_EOD,pParam->m_dOD);

				AcGeVector3d vtDir;
				pXDataMap->GetAt(KEY_MAJBR,vtDir);

				AcGePoint3d ptSta;
				pXDataMap->GetAt(KEY_START,ptSta);

				vtDir.normalize();

				AcGePoint3d ptEnd = ptSta + (pParam->m_dInterfaceL3 + dLx + dSx) * vtDir;
				if ( nConnectType == 3)//法兰连接
				{
					//[法兰外径],[法兰厚度],[法兰高度],[法兰颈]
					double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
					TDbPipeSupport::QueryFlangData(m_pADOServer,dDN,1.0,dWD,dWh,dThk,dN, sProject, sLevel,sODNo);

					double dWD2 = 0.0,dWh2 = 0.0,dThk2 = 0.0,dN2 = 0.0;
					TDbPipeSupport::QueryFlangData(m_pADOServer,pParam->m_dDN,1.0,dWD2,dWh2,dThk2,dN2, sProject, sLevel,sODNo);

					//颈法兰焊接方式
					//ptSta += dWh * vtDir;
					if (sODNo.CompareNoCase(_T("S")) != 0 &&
						sODNo.CompareNoCase(_T("GSF")) != 0)
					{
						ptEnd += (dThk2 + dThk) * vtDir;
					}
					
					pXDataMap->SetAt(PIPE_WN,dN2);
					pXDataMap->SetAt(PIPE_WH,dThk2);
				}

				//是否偏移
				
				double dOffset = (dDN - pParam->m_dDN) / 2.0;

				AcGeVector3d vtOffset;
				pXDataMap->GetAt(KEY_OFFSET,vtOffset);

				vtOffset.normalize();
				vtOffset *= dOffset;

				ptEnd += vtOffset;
				pXDataMap->SetAt(KEY_END,ptEnd);

				pFitting->ReCreateDraw2d();
				pFitting->ReCreateDraw3d();
			}

			bSuccesed = true;

			break;
		}
	case eWcap:
		{
			//全改
			double dL = 0.0;
			TDbPipeSupport::QueryCapData(m_pADOServer, pParam->m_dDN, dL,sODNo);

			pXDataMap->SetAt(PIPE_DN,pParam->m_dDN);
			pXDataMap->SetAt(PIPE_OD,pParam->m_dOD);
			pXDataMap->SetAt(PIPE_TDN,pParam->m_dDN);
			pXDataMap->SetAt(PIPE_TOD,pParam->m_dOD);
			pXDataMap->SetAt(PIPE_THICK,pParam->m_dThick);
			pXDataMap->SetAt(KEY_L,dL);

			pFitting->ReCreateDraw2d();
			pFitting->ReCreateDraw3d();

			bSuccesed = true;

			break;
		}
	case eFlxJoin:
		{
			TDbPipeSupport::QueryFlxJoinData(m_pADOServer, pParam->m_dDN, dPre, pXDataMap);

			pFitting->ReCreateDraw2d();
			pFitting->ReCreateDraw3d();

			bSuccesed = true;
			break;
		}
	case eThrough://直通 PVC
	case eUJoin://活接 PVC
	case eRJoin://缩接 PVC 伸缩节
	case eOJoin://外螺纹接头
	case eIJoin://内螺纹接头
	{
		//全改
		TDbPipeSupport::QueryPVCSpecFit(m_pADOServer, pParam->m_dDN, sODNo, eType, pXDataMap);

		pXDataMap->SetAt(PIPE_DN, pParam->m_dDN);
		pXDataMap->SetAt(PIPE_OD, pParam->m_dOD);
		pXDataMap->SetAt(PIPE_TDN, pParam->m_dDN);
		pXDataMap->SetAt(PIPE_TOD, pParam->m_dOD);
		pXDataMap->SetAt(PIPE_THICK, pParam->m_dThick);

		pFitting->ReCreateDraw2d();
		pFitting->ReCreateDraw3d();

		bSuccesed = true;

		break;
	}
	default:
		break;
	}
	return bSuccesed;
}

AecDbEwFitting* AecPipeLineModify::CreateNewFlang(AecDbEwFitting* pFitFr,const WPipe::PipeParam& paramNew)
{
	AecDbEwFitting* pFlange = new AecDbEwFitting;
	AecDbObjXDataMap* pXDataMapF = pFlange->GetSpecialtyData();

	pFlange->copyFrom(pFitFr);

	double dPre = 1.0;

	WPipe::PipeParam* pParam = (WPipe::PipeParam*)&paramNew;
	CString sODNo = _T("A");
	bool bIsPvc = TDbPipeLine::IsPlasticsMat(pParam, sODNo);

	CString sPre;
	pFitFr->GetSpecialtyData()->GetAt(PIPE_PRESSURE,sPre);
	dPre = _ttof(sPre);

	CString sProject;
	pFitFr->GetSpecialtyData()->GetAt(DOC_PROJECT, sProject);

	CString sLevel;
	pFitFr->GetSpecialtyData()->GetAt(PIPE_LEVEL, sLevel);

	//[法兰外径],[法兰厚度],[法兰高度]
	double dWD = 0.0,dWh = 0.0,dThk = 0.0,dN = 0.0;
	TDbPipeSupport::QueryFlangData(m_pADOServer,paramNew.m_dDN,dPre,dWD,dWh,dThk,dN, sProject, sLevel, sODNo);
	
	pXDataMapF->SetAt(PIPE_DN,paramNew.m_dDN);
	pXDataMapF->SetAt(PIPE_N,dN);
	pXDataMapF->SetAt(PIPE_OD,paramNew.m_dOD);
	pXDataMapF->SetAt(PIPE_WD,dWD);	//发兰盘外径
	pXDataMapF->SetAt(PIPE_WTHICK,dWh);	//大盘面厚度
	//pXDataMapF->SetAt(PIPE_THICK,dThk);//总厚
	pXDataMapF->SetAt(PIPE_THICK, dWh); // 管线上的法兰不画法兰颈

	return pFlange;
}

bool AecPipeLineModify::ModifyByInfAssoc(const AcArray<AecInterface>& arFitEquOldInfs,AecMInterfaces* pFitEquMInfNew,const WPipe::PipeParam& paramNew)
{
	//从 m_arNetIds 找
	//移除一个,去除一个
	//一直到inf锁定为止
	//arFitEquOldInfs 和 pFitEquMInfNew 一一对应
	
	AcArray<AecInterface> arNewInfs;
	pFitEquMInfNew->GetInterface(arNewInfs);

	AcDbEntity* pEnt = NULL;
	AecMInterfaces* pMInfMeetWith = NULL;

	for (int i = 0;i < m_arNetIds.length();i++)
	{
		pMInfMeetWith = NULL;
		if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,m_arNetIds.at(i),AcDb::kForRead))
		{
			AecDbEwPipe* pPipe = AecDbEwPipe::cast(pEnt);
			if (pPipe != NULL)
			{
				pMInfMeetWith = static_cast<AecMInterfaces*>(pPipe);
			}

			if (pMInfMeetWith != NULL)
			{
				AcGeVector3d vtDir,vtDir2;
				AcGePoint3d ptS,ptE,ptNew;
				AecInterface infOn,infNew;

				for (int j = 0;j < arFitEquOldInfs.length();j++)
				{
					const AecInterface& inf = arFitEquOldInfs.at(j);

					if (pMInfMeetWith->GetInterface(inf.ptPos,infOn))
					{
						//碰上此接口
						if (pPipe != NULL)
						{
							pPipe->upgradeOpen();

							//改管子的长度
							ptS = pPipe->StartPoint();
							ptE = pPipe->EndPoint();
							vtDir = ptE - ptS;

							if (ptS.distanceTo(infOn.ptPos) < 1.e-2)//误差0.01
							{
								pFitEquMInfNew->GetInterface(j,infNew);

								vtDir2 = ptE - infNew.ptPos;
								if (!vtDir2.isCodirectionalTo(vtDir))
								{
									pEnt->close();
									acutPrintf(_T("管线尺寸变更幅度过大!产生管线错位!变更失败!"));
									return false;
								}

								pPipe->SetStartPoint( infNew.ptPos );
							}

							if (ptE.distanceTo(infOn.ptPos) < 1.e-2)
							{
								pFitEquMInfNew->GetInterface(j,infNew);

								vtDir2 = infNew.ptPos - ptS;
								if ( !vtDir2.isCodirectionalTo(vtDir) )
								{
									pEnt->close();
									acutPrintf(_T("管线尺寸变更幅度过大!产生管线错位!变更失败!"));
									return false;
								}

								pPipe->SetEndPoint( infNew.ptPos );
							}

							pPipe->downgradeOpen();
						}

						//对fit 无效，导致回溯
						/*AecDbEwFitting* pFit = AecDbEwFitting::cast(pEnt);
						if (pFit != NULL)
						{
						}*/

						break;
					}
				}
			}
			pEnt->close();
		}
	}
	return true;
}

extern AecDbEwEquipment *startForPipeValve(LPCTSTR type
	, LPCTSTR title
	, const double &dn
	, const double &pn
	, bool &bHasFlange
	, const int &idx = 0
	, const AecDbObjXDataMap *pSrcData = NULL);

AecDbEwEquipment* AecPipeLineModify::getEquiment( AecDbEwEquipment *pOldEqu
	, const WPipe::PipeParam &paramNew
	, bool &bHasFangle
	, AecEqui::ValveType val
	, LPCTSTR psz/* = NULL*/
	, LPCTSTR pszFolder/* = NULL*/)
{
	if (!pOldEqu) return NULL;
	int bParaValve(false);
	pOldEqu->GetAt(_T("_parameter_equ_"), bParaValve);

	AecDbEwEquipment *pEqu(NULL);
	if (!bParaValve)
	{
		if (!psz || !pszFolder) return NULL;

		bool b2DFlagCheck(false);
		pEqu = CEquipmentLibraryDlg::selectCustomValve(
			psz
			, paramNew.m_dDN 
			, bHasFangle
			, true
			, bHasFangle
			, b2DFlagCheck);

		if (!pEqu) return NULL;
		pEqu->SetAt(PIPE_VALVE, val);
		pEqu->SetAt(KEY_SUBRUNTIME, eValve);
		pEqu->SetAt(KEY_VLV2D, TRUE);
		pEqu->SetAt(PIPE_LEVEL, paramNew.szLevel);
	}
	else	// 参数化
	{
		pEqu = startForPipeValve(psz
			, CString(_T("插入")) + psz
			, paramNew.m_dDN
			, paramNew.m_dPress
			, bHasFangle
			, 0
			, pOldEqu->GetSpecialtyData());
		if (pEqu)
		{
			pEqu->SetAt(PIPE_VALVE, val);
			pEqu->SetAt(KEY_SUBRUNTIME, eValve);
			pEqu->SetAt(KEY_VLV2D, TRUE);
		}
	}
	return pEqu;
}

extern int g_nVlvLen;
extern AecEqui::VlvType g_vlvType[];

typedef AcArray<AcGeMatrix3d> AcGeMatrix3dArray;
AecDbEwEquipment* AecPipeLineModify::CreateNewValve(AecDbEwEquipment* pEqu,const WPipe::PipeParam& paramNew)
{
	if (pEqu != NULL)
	{
		AcGePoint3d ptIns;
		AcGeVector3d vtDir;
		AecInterface infOld,infNew,infNew1;

		pEqu->GetInsert(ptIns,vtDir);

		pEqu->GetInterface(0,infOld);

		AcGeMatrix3dArray arMatrix;
		pEqu->GetAllAddTransforms(arMatrix);

		pEqu->SetDashLayer(PipelineTools::AecInitLayerEx(LAY_FITN_DASH, 8, _T("DASH"), NULL));
		pEqu->SetCenterLayer(PipelineTools::AecInitLayerEx(LAY_FITN_CENTER, 4, _T("Center2"), NULL));

		CString sName;
		int nVal = 0;
		pEqu->GetSpecialtyData()->GetAt(PIPE_VALVE, nVal);

		AecEqui::ValveType eVlvType = (AecEqui::ValveType)nVal;

		for (int i = 0; i < g_nVlvLen; i++)
		{
			if ( (int)g_vlvType[i].eType == nVal)
			{
				sName = g_vlvType[i].szNameCn;
				break;
			}
		}

		//通过sName,dNewDN查新的阀门
		if (m_pADOServer != NULL)
		{
			int bParaValve(false);
			pEqu->GetAt(_T("_parameter_equ_"), bParaValve);
			bool bHasFangle = false;
			AecDbEwEquipment* pEquNew = getEquiment(pEqu
				, paramNew
				, bHasFangle
				, eVlvType
				, sName
				, VALVE_FOLDER);

			if (pEquNew != NULL)
			{
				//立管是否转动方向
				pEquNew->SetVert(pEqu->IsVert());
				pEquNew->SetInsert(ptIns,vtDir);
				for (int i = 0;i < arMatrix.length();i++)
				{
					pEquNew->AddTransform(arMatrix.at(i));
				}

				pEquNew->GetInterface(0,infNew);

				//接口中心校正,并且必须是第一接口情况
				if (infOld.vtDir.isParallelTo(infNew.vtDir))
				{
					if (!infOld.vtDir.isCodirectionalTo(infNew.vtDir))
					{
						pEquNew->GetInterface(1,infNew);
					}
				}
				
//              此处不需要调整，在外部调用已经调整 2025-4-3
//				AcGeVector3d vt = infOld.ptPos - infNew.ptPos;
//				if (!vt.isZeroLength())
//				{
//					//平移等标高
//					AcGeMatrix3d xform;
//					xform.setToTranslation(vt);
//					pEquNew->AddTransform(vt);
//				}

				//验证测试
				pEquNew->GetInterface(0,infNew);
				pEquNew->GetInterface(1,infNew1);

				pEquNew->setLayer(pEqu->layerId());
				pEquNew->setLinetype(pEqu->linetypeId());

				AcDbObjectId idDsh;
				pEqu->GetDashLayer(idDsh);
				pEquNew->SetDashLayer(idDsh);

				AcDbObjectId idCen;
				pEqu->GetCenterLayer(idCen);
				pEquNew->SetCenterLayer(idCen);

				return pEquNew;
			}
		}
	}
	return NULL;
}

bool AecPipeLineModify::ModifyPipeOnParam(const AcDbObjectIdArray& arPipeIds,const WPipe::PipeParam& paramNew)
{
	AcDbEntity* pEnt = NULL;
	for(int i = 0;i < arPipeIds.length();i++)
	{
		if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,arPipeIds.at(i),AcDb::kForWrite))
		{
			AecDbEwPipe* pPipe = AecDbEwPipe::cast(pEnt);
			if (pPipe != NULL)
			{
				//公称 外径 壁厚 压了等级,曲率半径
				WPipe::PipeParam* pParam = pPipe->GetPipeParam();

				//覆盖为新的参数
				pParam->m_dDN = paramNew.m_dDN;
				pParam->m_dOD = paramNew.m_dOD;
				_tcscpy(pParam->szODSn, paramNew.szODSn);
				_tcscpy(pParam->szStdNo, paramNew.szStdNo);

				switch (pParam->m_eD)
				{
					case WPipe::eOD:
					{
						pParam->m_dD = paramNew.m_dOD;
						break;
					}
					case WPipe::eDN:
					{
						pParam->m_dD = paramNew.m_dDN;
						break;
					}
					case WPipe::eID:
					{
						pParam->m_dD = paramNew.m_dOD - 2.0 * paramNew.m_dThick;
						break;
					}
					default:
						break;
				}

				pParam->m_dThick = paramNew.m_dThick;
				_tcscpy(pParam->szLevel,paramNew.szLevel);
				pParam->m_dRRatio = paramNew.m_dRRatio;

				if (_tcslen(paramNew.szMertial) > 0)
					_tcscpy(pParam->szMertial, paramNew.szMertial);

				if (pParam->m_nConnectType == 3)
				{
					pParam->m_dInterfaceL = paramNew.m_dInterfaceL;
					pParam->m_dInterfaceD = paramNew.m_dInterfaceD;
				}

				if (m_bUpdateMat)
				{
					_tcscpy(pParam->szMertial,paramNew.szMertial);
					_tcscpy(pParam->szMertialFit,paramNew.szMertialFit);
					_tcscpy(pParam->szSys, paramNew.szSys);

					pPipe->GetSpecialtyData()->SetAt(PIPE_COLOR, paramNew.m_nPipeColor);
					
					//设置图层
					TDbPipeLine::SetPipeLayer(pPipe, paramNew.szSys);
				}

				pPipe->SetPipeParam(pParam);

				delete pParam;
			}
			pEnt->close();
		}
	}
	return true;
}

bool AecPipeLineModify::AddjustTInfAssoc()
{
	//主要是管子
	if (!m_arFrTo.isEmpty())
	{
		//选择管线,管件
		struct resbuf* pRb = acutBuildList(RTDXF0, DXF_PIPE_ONLY, 0);
	
		ads_name ss,ent;
		acedSSGet(_T("A"),NULL,NULL,pRb,ss);

		Adesk::Int32 nLen = 0;
		acedSSLength(ss,&nLen);

		AcGePoint3d ptS,ptE;

		AcDbObjectId id;
		AcDbEntity* pEnt = NULL;

		for (int i = 0;i < nLen;i++)
		{
			if (m_arFrTo.isEmpty())
			{
				break;
			}

			acedSSName(ss,i,ent);
			acdbGetObjectId(id,ent);

			if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForRead))
			{
				AecDbEwPipe* pPipe = AecDbEwPipe::cast(pEnt);
				if (pPipe != NULL)
				{
					ptS = pPipe->StartPoint();
					ptE = pPipe->EndPoint();

					for (int k = 0;k < m_arFrTo.length();k++)
					{
						AecInterfaceFrTo& infFrTo = m_arFrTo.at(k);
						if (infFrTo.infFr.ptPos.distanceTo(ptS) < 1.e-3 )
						{
							pPipe->upgradeOpen();
							pPipe->SetStartPoint(infFrTo.infTo.ptPos);
							pPipe->downgradeOpen();
							m_arFrTo.removeAt(k);
							k -= 1;
							break;
						}

						if (infFrTo.infFr.ptPos.distanceTo(ptE) < 1.e-3)
						{
							pPipe->upgradeOpen();
							pPipe->SetEndPoint(infFrTo.infTo.ptPos);
							pPipe->downgradeOpen();
							m_arFrTo.removeAt(k);
							k -= 1;
							break;
						}
					}
				}
				pEnt->close();
			}
		}

		acedSSFree(ss);
		acutRelRb(pRb);
	}
	return true;
}