#include "stdafx.h"
#include "StdArx.h"
#include "AecMInterfaces.h"
#include "AecDbHvacFitting.h"
#include "AecDbEwEquipment.h"
#include "AecPipeLineModify.h"
#include "AecDbDuctLine.h"
#include "coretools.h"

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

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

extern double GetElbowLx(AecHvac::DuctParam *pParam);
extern double GetElbowL(AecHvac::DuctParam *pParam);

AecPipeLineModify::AecPipeLineModify(void)
{
	m_bTeeStop = FALSE;
	m_bUpdateMat = FALSE;
	m_bCrossStop = FALSE;
	m_bElLock = false;
	memset(&m_paramOld,0,sizeof(AecHvac::DuctParam));
}

AecPipeLineModify::~AecPipeLineModify(void)
{

}

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

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;
}

bool AecPipeLineModify::ModifyPipeLineParam(AcDbObjectIdArray& arPipeIds,AcDbObjectIdArray& arFitIds,AcDbObjectIdArray& arEquIds, AecHvac::DuctParam& paramNew,BOOL bUpdateMat)
{
	m_bUpdateMat = bUpdateMat;

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

	AcArray<AcDbObjectIdInf> arAssFlgs,arAssEquIds;

	//2.先修改定位管件,定位管件的位置为绝对位置
	//弯头,三通,四通,乙字弯
	//修改后导致接口位置改变,影响连接件
	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))
		{
			AecDbHvacFitting * pFit = AecDbHvacFitting::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 eReduce:
				case eCross:
				case eOffset:
					{
						//按阀门接口找出接口接的阀门
						CPoint ptnPos1 = PickAssocEqu(arInfs,arEquIds,arAssEquIds);

						//改完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;
								}
							}

							//按照接口路线修改
							//一直到管子停止;
							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;
					}
				default:
					break;
				}
			}
			pEnt->close();
		}
	}

	if ( fabs(m_paramOld.dSize[0] - paramNew.dSize[0]) > 1.e-1 ||
		 fabs(m_paramOld.dSize[1] - paramNew.dSize[1]) > 1.e-1 ||
		 fabs(m_paramOld.m_dRatio - paramNew.m_dRatio) > 1.e-1 )
	{
		//从某一个设备开始 建立方向串
		if (!arAssEquIds.isEmpty())
		{
			MakeEquListStartByEqus(arAssEquIds,arEquIds);
		}

		//4.arEquIds 余下孤立的阀门建立方向串
		AcArray<AcDbObjectIdInf> arIdInf;
		AcDbObjectIdArray arFlangIds;
		MakeEquListTheRest(arEquIds,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);
				CoreTools::AddToModelSpace(pCir,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);
				CoreTools::AddToModelSpace(pLn,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))
		{
			AecDbHvacDuct * pPipe = AecDbHvacDuct::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 AecHvac::DuctParam & 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;
				}
			}

			pEnt->close();
		}

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


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

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

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

		if ( Acad::eOk == 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;
				}
			}

			pEnt->close();
		}
	}
}

//弯头等fit直接接设备，法兰管线才有
void AecPipeLineModify::MakeEquListStartByEqus(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::MakeEquListStartByFlgs(AcArray<AcDbObjectIdInf>& arAssFlgs,AcDbObjectIdArray& arEquIds)
{
	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();
				}
			}

			if (!bFindEqu )
				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;
					}
				}
			}

			AecDbHvacFitting * pFit = AecDbHvacFitting::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,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);
					MakeEquListStartByFlgs(arIdInf0,arEquIds);

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

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

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

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

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

bool AecPipeLineModify::ModifyFitting(AecDbHvacFitting* pFitting,const AecHvac::DuctParam & paramNew)
{
	bool bSuccesed = false;
	AecHvac::DuctParam* pParam = (AecHvac::DuctParam *)&paramNew;
	
	AecDbObjXDataMap* pXDataMap = pFitting->GetSpecialtyData();

	if (m_bUpdateMat)
	{
		pXDataMap->SetAt(PIPE_MATERIAL,pParam->szMat);
		pXDataMap->SetAt(PIPE_SYS, pParam->szSys);

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

	int nType = 0,nLocked = -1;
	pXDataMap->GetAt(KEY_RUNTIME,nType);
	EFittingType eType = (EFittingType)nType;

	//如果DN不变,仅仅改外径和壁厚
	AecHvac::DuctParam paramOld;
	pFitting->GetDuctParam(paramOld);

	if ( fabs(paramOld.dSize[0] - pParam->dSize[0]) < 1.e-2 &&
		 fabs(paramOld.dSize[1] - pParam->dSize[1]) > 1.e-2)
	{
		pXDataMap->SetAt(PIPE_THICK,pParam->dSize[2]);

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

	double dLx = GetElbowLx(pParam);
	double dL = GetElbowL(pParam);

	AcGeVector3d vtMaj;
	AcGeVector3d vtMin;
	AcGePoint3d ptStart, ptMid, ptEnd;
	CString sKey;
	//弯头,三通,四通,变径
	switch( eType )
	{
	case eElbow:
		{
			AecInterface inf0;
			AecInterface inf1;
			pFitting->GetInterface(0, inf0);
			pFitting->GetInterface(1, inf1);

			pXDataMap->GetAt(HELB_StartPoint, ptStart);
			pXDataMap->GetAt(HELB_CornerPoint, ptMid);
			pXDataMap->GetAt(HELB_EndPoint, ptEnd);

			vtMaj = ptStart - ptMid; vtMaj.normalize();
			vtMin = ptEnd - ptMid; vtMin.normalize();

			ptStart = ptMid + vtMaj * dL;
			ptEnd = ptMid + vtMin * dL;

			pXDataMap->SetAt(HELB_Thick, pParam->dSize[1]);
			pXDataMap->SetAt(HELB_EndThick, pParam->dSize[1]);

			pXDataMap->SetAt(HELB_StartWidth, pParam->dSize[0]);
			pXDataMap->SetAt(HELB_EndWidth, pParam->dSize[0]);

			pXDataMap->SetAt(KEY_SIZE1, pParam->dSize[0]); //L
			pXDataMap->SetAt(KEY_SIZE2, pParam->dSize[1]); //w

			pXDataMap->SetAt(HELB_Diameter, pParam->dSize[0]);
			pXDataMap->SetAt(HELB_EndDiameter, pParam->dSize[0]);

			pXDataMap->SetAt(HELB_StartPoint, ptStart);
			pXDataMap->SetAt(HELB_EndPoint, ptEnd);

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

			//记录修改后
			AecInterface inf11, inf00;
			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;
			break;
		}
	case eTee:
		{
			if (m_bTeeStop) //三通分支管径不改尺寸; 主接口可修改.分支锁定
			{
TeeStop:
				nLocked = -1;
				for(int k = 0;k < 3;k++)
				{
					sKey.Format(_T("LK_%d"),k);
					if ( pXDataMap->GetAt(sKey,nLocked) )
					{
						if (nLocked > -1)
						{
							break;
						}
					}
				}

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

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

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

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

					pXDataMap->GetAt(HTEE_EndDir, vtMaj);
					pXDataMap->GetAt(HTEE_BranchDir, vtMin);
					vtMaj.normalize(); vtMin.normalize();

					int nSectType = 0;
					ESection eType;
					pXDataMap->GetAt(KEY_SECSHAPE, nSectType);
					eType = (ESection)nSectType;

					//如果是矩形 立放置
					if (vtMin.isParallelTo(AcGeVector3d::kZAxis) ||
						vtMaj.isParallelTo(AcGeVector3d::kZAxis))
					{
						if (eType == eRect)
						{
							pXDataMap->SetAt(HTEE_StartWidth, pParam->dSize[1]);
							pXDataMap->SetAt(HTEE_EndWidth, pParam->dSize[1]);
							//pXDataMap->SetAt(HTEE_BranchWidth, m_pPipeParam->dSize[1]);

							pXDataMap->SetAt(HTEE_Thick, pParam->dSize[0]);
							pXDataMap->SetAt(HTEE_EndThick, pParam->dSize[0]);
							//pXDataMap->SetAt(HTEE_BranchThick, m_pPipeParam->dSize[0]);
						}
						else
						{
							pXDataMap->SetAt(HTEE_StartWidth, pParam->dSize[0]);
							pXDataMap->SetAt(HTEE_EndWidth, pParam->dSize[0]);
							//pXDataMap->SetAt(HTEE_BranchWidth, m_pPipeParam->dSize[0]);

							pXDataMap->SetAt(HTEE_Thick, pParam->dSize[1]);
							pXDataMap->SetAt(HTEE_EndThick, pParam->dSize[1]);
							//pXDataMap->SetAt(HTEE_BranchThick, m_pPipeParam->dSize[1]);
						}
					}
					else
					{
						pXDataMap->SetAt(HTEE_StartWidth, pParam->dSize[0]);
						pXDataMap->SetAt(HTEE_EndWidth, pParam->dSize[0]);
						//pXDataMap->SetAt(HTEE_BranchWidth, pParam->dSize[0]);
						pXDataMap->SetAt(KEY_SIZE1, pParam->dSize[0]); //L
						pXDataMap->SetAt(KEY_SIZE2, pParam->dSize[1]); //w

						pXDataMap->SetAt(HTEE_Thick, pParam->dSize[1]);
						pXDataMap->SetAt(HTEE_EndThick, pParam->dSize[1]);
						//pXDataMap->SetAt(HTEE_BranchThick, pParam->dSize[1]);
					}

					pXDataMap->GetAt(HTEE_StartPoint, ptStart);
					pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
					Midpoint(ptStart, ptEnd, ptMid);

					ptStart = ptMid - vtMaj * dL;
					ptEnd = ptMid + vtMaj * dL;

					pXDataMap->SetAt(HTEE_StartPoint, ptStart);
					pXDataMap->SetAt(HTEE_EndPoint, ptEnd);

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

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

					AecInterfaceFrTo infFt;

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

					infFt.infFr = inf1;
					infFt.infTo = inf11;
					m_arFrTo.append(infFt);

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

					AecInterface inf11, inf00;
					pFitting->GetInterface(2, inf00);

					int nSectType = 0;
					ESection eType;
					pXDataMap->GetAt(KEY_SECSHAPE, nSectType);
					eType = (ESection)nSectType;

					//如果是矩形 立放置
					if (vtMin.isParallelTo(AcGeVector3d::kZAxis) ||
						vtMaj.isParallelTo(AcGeVector3d::kZAxis))
					{
						if (eType == eRect)
						{
							pXDataMap->SetAt(HTEE_BranchWidth, pParam->dSize[1]);
							pXDataMap->SetAt(HTEE_BranchThick, pParam->dSize[0]);
						}
						else
						{
							pXDataMap->SetAt(HTEE_BranchWidth, pParam->dSize[0]);
							pXDataMap->SetAt(HTEE_BranchThick, pParam->dSize[1]);
						}
					}
					else
					{
						pXDataMap->SetAt(HTEE_BranchWidth, pParam->dSize[0]);
						pXDataMap->SetAt(HTEE_BranchThick, pParam->dSize[1]);
					}

					pXDataMap->GetAt(HTEE_StartPoint, ptStart);
					pXDataMap->GetAt(HTEE_EndPoint, ptEnd);

					Midpoint(ptStart, ptEnd, ptMid);

					ptStart = ptMid - vtMaj * dL;
					ptEnd = ptMid + vtMaj * dL;

					pXDataMap->SetAt(HTEE_StartPoint, ptStart);
					pXDataMap->SetAt(HTEE_EndPoint, ptEnd);

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

					AecInterfaceFrTo infFt;

					infFt.infFr = inf00;
					infFt.infTo = inf11;
					m_arFrTo.append(infFt);

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

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

				int nSectType = 0;
				ESection eType;
				pXDataMap->GetAt(KEY_SECSHAPE, nSectType);
				eType = (ESection)nSectType;

				//原来的主接口
				AecInterface inf0;
				AecInterface inf1;
				AecInterface inf2;
				pFitting->GetInterface(0, inf0);
				pFitting->GetInterface(1, inf1);
				pFitting->GetInterface(2, inf2);

				pFitting->SetDuctParam(paramNew);

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

				pXDataMap->GetAt(HTEE_EndDir, vtMaj);
				pXDataMap->GetAt(HTEE_BranchDir, vtMin);
				vtMaj.normalize(); vtMin.normalize();

				//如果是矩形 立放置
				if (vtMin.isParallelTo(AcGeVector3d::kZAxis) ||
					vtMaj.isParallelTo(AcGeVector3d::kZAxis))
				{
					if (eType == eRect)
					{
						pXDataMap->SetAt(HTEE_StartWidth, pParam->dSize[1]);
						pXDataMap->SetAt(HTEE_EndWidth, pParam->dSize[1]);

						pXDataMap->SetAt(HTEE_BranchWidth, pParam->dSize[1]);

						pXDataMap->SetAt(KEY_SIZE1, pParam->dSize[1]); //L
						pXDataMap->SetAt(KEY_SIZE2, pParam->dSize[0]); //w

						pXDataMap->SetAt(HTEE_Thick, pParam->dSize[0]);
						pXDataMap->SetAt(HTEE_EndThick, pParam->dSize[0]);

						pXDataMap->SetAt(HTEE_BranchThick, pParam->dSize[0]);
					}
					else
					{
						pXDataMap->SetAt(HTEE_StartWidth, pParam->dSize[0]);
						pXDataMap->SetAt(HTEE_EndWidth, pParam->dSize[0]);

						pXDataMap->SetAt(HTEE_BranchWidth, pParam->dSize[0]);

						pXDataMap->SetAt(KEY_SIZE1, pParam->dSize[0]); //L
						pXDataMap->SetAt(KEY_SIZE2, pParam->dSize[1]); //w

						pXDataMap->SetAt(HTEE_Thick, pParam->dSize[1]);
						pXDataMap->SetAt(HTEE_EndThick, pParam->dSize[1]);

						pXDataMap->SetAt(HTEE_BranchThick, pParam->dSize[1]);
					}
				}
				else
				{
					pXDataMap->SetAt(HTEE_StartWidth, pParam->dSize[0]);
					pXDataMap->SetAt(HTEE_EndWidth, pParam->dSize[0]);

					pXDataMap->SetAt(HTEE_BranchWidth, pParam->dSize[0]);

					pXDataMap->SetAt(KEY_SIZE1, pParam->dSize[0]); //L
					pXDataMap->SetAt(KEY_SIZE2, pParam->dSize[1]); //w

					pXDataMap->SetAt(HTEE_Thick, pParam->dSize[1]);
					pXDataMap->SetAt(HTEE_EndThick, pParam->dSize[1]);

					pXDataMap->SetAt(HTEE_BranchThick, pParam->dSize[1]);
				}

				pXDataMap->GetAt(HTEE_StartPoint, ptStart);
				pXDataMap->GetAt(HTEE_EndPoint, ptEnd);
				Midpoint(ptStart, ptEnd, ptMid);

				ptStart = ptMid - vtMaj * dL;
				ptEnd = ptMid + vtMaj * dL;

				pXDataMap->SetAt(HTEE_StartPoint, ptStart);
				pXDataMap->SetAt(HTEE_EndPoint, ptEnd);

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

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

				AecInterfaceFrTo infFt;

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

				infFt.infFr = inf1;
				infFt.infTo = inf11;
				m_arFrTo.append(infFt);

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

				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(HCRS_EndWidth,dTDN);

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

					//记录分支前
					//原来的主接口
					AecInterface inf0;
					AecInterface inf1;
					AecInterface inf2;
					AecInterface inf3;

					pFitting->GetInterface(0, inf0);
					pFitting->GetInterface(1, inf1);
					pFitting->GetInterface(2, inf2);
					pFitting->GetInterface(3, inf3);

					pXDataMap->GetAt(HCRS_StartDir, vtMaj);
					pXDataMap->GetAt(HCRS_BranchDir1, vtMin);

					vtMaj.normalize(); vtMin.normalize();

					int nSectType = 0;
					ESection eType;
					pXDataMap->GetAt(KEY_SECSHAPE, nSectType);
					eType = (ESection)nSectType;

					if (vtMaj.isParallelTo(AcGeVector3d::kZAxis) ||
						vtMin.isParallelTo(AcGeVector3d::kZAxis))
					{
						//如果是矩形
						if (pParam->eType == eRect)
						{
							pXDataMap->SetAt(HCRS_StartWidth, pParam->dSize[1]);
							pXDataMap->SetAt(HCRS_Thick, pParam->dSize[0]);
							pXDataMap->SetAt(HCRS_EndWidth, pParam->dSize[1]);
							pXDataMap->SetAt(KEY_SIZE1, pParam->dSize[0]); //L
							pXDataMap->SetAt(KEY_SIZE2, pParam->dSize[1]); //w
						}
						else
						{
							pXDataMap->SetAt(HCRS_StartWidth, pParam->dSize[0]);
							pXDataMap->SetAt(HCRS_Thick, pParam->dSize[1]);
							pXDataMap->SetAt(HCRS_EndWidth, pParam->dSize[0]);
							pXDataMap->SetAt(KEY_SIZE1, pParam->dSize[0]); //L
							pXDataMap->SetAt(KEY_SIZE2, pParam->dSize[1]); //w
						}
					}
					else
					{
						pXDataMap->SetAt(HCRS_StartWidth, pParam->dSize[0]);
						pXDataMap->SetAt(HCRS_Thick, pParam->dSize[1]);
						pXDataMap->SetAt(HCRS_EndWidth, pParam->dSize[0]);
						pXDataMap->SetAt(KEY_SIZE1, pParam->dSize[0]); //L
						pXDataMap->SetAt(KEY_SIZE2, pParam->dSize[1]); //w
					}

					ptStart = ptMid + vtMaj * dL;
					ptEnd = ptMid + vtMin * dL;
				
					pXDataMap->SetAt(HCRS_StartPoint, ptStart);
					pXDataMap->SetAt(HCRS_EndPoint, ptEnd);

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

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

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

					infFt.infFr = inf1;
					infFt.infTo = inf11;
					m_arFrTo.append(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(HCRS_Branch1Width,dTDN);

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

					AcGePoint3d ptMid;
					pXDataMap->GetAt(KEY_MID, ptMid);

					double dL = GetElbowL(pParam);

					int nSectType = 0;
					ESection eType;
					pXDataMap->GetAt(KEY_SECSHAPE, nSectType);
					eType = (ESection)nSectType;

					//记录分支前
					AecInterface inf0;
					AecInterface inf1;
					AecInterface inf2;
					AecInterface inf3;

					pFitting->GetInterface(0, inf0);
					pFitting->GetInterface(1, inf1);
					pFitting->GetInterface(2, inf2);
					pFitting->GetInterface(3, inf3);


					AcGeVector3d vtBra1, vtBr2, vtMaj;
					pXDataMap->GetAt(HCRS_BranchDir1, vtBra1);
					pXDataMap->GetAt(HCRS_BranchDir2, vtBr2);
					pXDataMap->GetAt(HCRS_StartDir, vtMaj);

					vtBra1.normalize(); vtBr2.normalize();

					if (vtMaj.isParallelTo(AcGeVector3d::kZAxis) ||
						vtBra1.isParallelTo(AcGeVector3d::kZAxis))
					{
						if (pParam->eType == eRect)
						{
							pXDataMap->SetAt(HCRS_Branch1Width, pParam->dSize[1]);
							pXDataMap->SetAt(HCRS_Branch1Thick, pParam->dSize[0]);

							pXDataMap->SetAt(HCRS_Branch2Width, pParam->dSize[1]);
							pXDataMap->SetAt(HCRS_Branch2Thick, pParam->dSize[0]);
						}
						else
						{
							pXDataMap->SetAt(HCRS_Branch1Width, pParam->dSize[0]);
							pXDataMap->SetAt(HCRS_Branch1Thick, pParam->dSize[1]);

							pXDataMap->SetAt(HCRS_Branch2Width, pParam->dSize[0]);
							pXDataMap->SetAt(HCRS_Branch2Thick, pParam->dSize[1]);
						}
					}
					else
					{
						pXDataMap->SetAt(HCRS_Branch1Width, pParam->dSize[0]);
						pXDataMap->SetAt(HCRS_Branch1Thick, pParam->dSize[1]);

						pXDataMap->SetAt(HCRS_Branch2Width, pParam->dSize[0]);
						pXDataMap->SetAt(HCRS_Branch2Thick, pParam->dSize[1]);
					}

					AcGePoint3d ptBra1 = ptMid + vtBra1 * dL;
					AcGePoint3d ptBra2 = ptMid + vtBr2 * dL;

					pXDataMap->SetAt(HCRS_BranchPoint1, ptBra1);
					pXDataMap->SetAt(HCRS_BranchPoint2, ptBra2);

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

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

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

					infFt.infFr = inf1;
					infFt.infTo = inf11;
					m_arFrTo.append(infFt);

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

					infFt.infFr = inf3;
					infFt.infTo = inf33;
					m_arFrTo.append(infFt);
				}
				bSuccesed = true;
			}
			else//全改,统一DN
			{
				double dDN = 0.0,dTDN = 0.0;
				pXDataMap->GetAt(HCRS_StartWidth,dDN);
				pXDataMap->GetAt(HCRS_Branch1Width,dTDN);

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

				//记录分支前
				AecInterface inf0;
				AecInterface inf1;
				AecInterface inf2;
				AecInterface inf3;

				pFitting->GetInterface(0, inf0);
				pFitting->GetInterface(1, inf1);
				pFitting->GetInterface(2, inf2);
				pFitting->GetInterface(3, inf3);

				AcGePoint3d ptMid;
				pXDataMap->GetAt(KEY_MID, ptMid);
				double dL = GetElbowL(pParam);

				AcGeVector3d vtStart, vtEnd;
				pXDataMap->GetAt(HCRS_StartDir, vtStart);
				pXDataMap->GetAt(HCRS_EndDir, vtEnd);
				vtStart.normalize(); vtEnd.normalize();

				int nSectType = 0;
				ESection eType;
				pXDataMap->GetAt(KEY_SECSHAPE, nSectType);
				eType = (ESection)nSectType;

				ptStart = ptMid + vtStart * dL;
				ptEnd = ptMid + vtEnd * dL;

				AcGeVector3d vtBra1, vtBr2;
				pXDataMap->GetAt(HCRS_BranchDir1, vtBra1);
				pXDataMap->GetAt(HCRS_BranchDir2, vtBr2);
				vtBra1.normalize(); vtBr2.normalize();

				AcGePoint3d ptBra1 = ptMid + vtBra1 * dL;
				AcGePoint3d ptBra2 = ptMid + vtBr2 * dL;

				pXDataMap->SetAt(HCRS_StartPoint, ptStart);
				pXDataMap->SetAt(HCRS_EndPoint, ptEnd);
				pXDataMap->SetAt(HCRS_BranchPoint1, ptBra1);
				pXDataMap->SetAt(HCRS_BranchPoint2, ptBra2);


				if (vtBra1.isParallelTo(AcGeVector3d::kZAxis) ||
					vtStart.isParallelTo(AcGeVector3d::kZAxis))
				{
					//如果是矩形
					if (pParam->eType == eRect)
					{
						pXDataMap->SetAt(HCRS_StartWidth, pParam->dSize[1]);
						pXDataMap->SetAt(HCRS_EndWidth, pParam->dSize[1]);
						pXDataMap->SetAt(HCRS_Thick, pParam->dSize[0]);

						pXDataMap->SetAt(HCRS_Branch1Width, pParam->dSize[1]);
						pXDataMap->SetAt(HCRS_Branch1Thick, pParam->dSize[0]);

						pXDataMap->SetAt(HCRS_Branch2Width, pParam->dSize[1]);
						pXDataMap->SetAt(HCRS_Branch2Thick, pParam->dSize[0]);
					}
					else
					{
						pXDataMap->SetAt(HCRS_StartWidth, pParam->dSize[0]);
						pXDataMap->SetAt(HCRS_Thick, pParam->dSize[1]);
						pXDataMap->SetAt(HCRS_EndWidth, pParam->dSize[0]);

						pXDataMap->SetAt(HCRS_Branch1Width, pParam->dSize[0]);
						pXDataMap->SetAt(HCRS_Branch1Thick, pParam->dSize[1]);

						pXDataMap->SetAt(HCRS_Branch2Width, pParam->dSize[0]);
						pXDataMap->SetAt(HCRS_Branch2Thick, pParam->dSize[1]);
					}
				}
				else
				{
					pXDataMap->SetAt(HCRS_StartWidth, pParam->dSize[0]);
					pXDataMap->SetAt(HCRS_EndWidth, pParam->dSize[0]);
					pXDataMap->SetAt(HCRS_Thick, pParam->dSize[1]);

					pXDataMap->SetAt(HCRS_Branch1Width, pParam->dSize[0]);
					pXDataMap->SetAt(HCRS_Branch1Thick, pParam->dSize[1]);

					pXDataMap->SetAt(HCRS_Branch2Width, pParam->dSize[0]);
					pXDataMap->SetAt(HCRS_Branch2Thick, pParam->dSize[1]);

					pXDataMap->SetAt(KEY_SIZE1, pParam->dSize[0]); //L
					pXDataMap->SetAt(KEY_SIZE2, pParam->dSize[1]); //w
				}

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

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

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

				infFt.infFr = inf1;
				infFt.infTo = inf11;
				m_arFrTo.append(infFt);

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

				infFt.infFr = inf3;
				infFt.infTo = inf33;
				m_arFrTo.append(infFt);

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

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

			//主管改，不改分支
			if ( fabs(m_paramOld.dSize[0] - dDN) < 1.e-2)//
			{
				if ( fabs( pParam->dSize[0] - dDN ) < 1.e-2)
				{
					acutPrintf(_T("\n分支管径等于主管径!修改管径取消!"));
					return false;
				}

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

				ESection eStartSectType = eRect;
				pXDataMap->GetAt(HRED_StartSectType, (int &)eStartSectType);

				if (eStartSectType == eRect)
				{
					pXDataMap->SetAt(HRED_StartWidth, pParam->dSize[0]);
					pXDataMap->SetAt(HRED_StartThick, pParam->dSize[1]);
					pXDataMap->SetAt(KEY_SIZE1, pParam->dSize[0]); //L
					pXDataMap->SetAt(KEY_SIZE2, pParam->dSize[1]); //w
				}
				else
				{
					pXDataMap->SetAt(HRED_StartWidth, pParam->dSize[0]);
					//pXDataMap->SetAt(HRED_StartThick, pParam->dSize[1]);
					pXDataMap->SetAt(KEY_SIZE1, pParam->dSize[0]); //L
					pXDataMap->SetAt(KEY_SIZE2, pParam->dSize[1]); //0
				}

				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);
			}
			else//主管不改，改分支
			{
				if ( fabs( pParam->dSize[0] - dTDN ) < 1.e-2)
				{
					acutPrintf(_T("\n分支管径等于主管径!修改管径取消!"));
					return false;
				}


				ESection eEndSectType = eRect;
				pXDataMap->GetAt(HRED_EndSectType, (int &)eEndSectType);

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

				if (eEndSectType == eRect)
				{
					pXDataMap->SetAt(HRED_EndWidth, pParam->dSize[0]);
					pXDataMap->SetAt(HRED_EndThick, pParam->dSize[1]);
				}
				else
				{
					pXDataMap->SetAt(HRED_EndWidth, pParam->dSize[0]);
					//pXDataMap->SetAt(HRED_EndThick, pParam->dSize[1]);
				}

				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;

			break;
		}
	case eOffset:
		{
			//eArcuateLink	= 1,	// 双弧
			//eLinearLink = 2,		// 角接
			//eObliqueLink = 3,		// 斜接
			//共同数据

			AecInterface inf0;
			AecInterface inf1;
			pFitting->GetInterface(0, inf0);
			pFitting->GetInterface(1, inf1);

			AecHvac::HvacOffsetType  eOffsetType = AecHvac::eArcuateLink;
			pXDataMap->GetAt(HOFF_Type, (int&)eOffsetType);

			if (eOffsetType == 1 || eOffsetType == 2)
			{
				pXDataMap->SetAt(HOFF_Thick, paramNew.dSize[0]);
				pXDataMap->SetAt(HOFF_StartWidth, paramNew.dSize[1]);
				pXDataMap->SetAt(HOFF_EndWidth, paramNew.dSize[1]);
			}
			else
			{
				//其他走弯头+直管组合
			}
			
			pFitting->ReCreateDraw2d();
			pFitting->ReCreateDraw3d();

			//记录修改后
			AecInterface inf11, inf00;
			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;

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

bool AecPipeLineModify::ModifyByInfAssoc(const AcArray<AecInterface>& arFitEquOldInfs,AecMInterfaces* pFitEquMInfNew,const AecHvac::DuctParam & 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))
		{
			AecDbHvacDuct * pPipe = AecDbHvacDuct::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 无效，导致回溯
						/*AecDbHvacFitting* pFit = AecDbHvacFitting::cast(pEnt);
						if (pFit != NULL)
						{
						}*/

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

AecDbEwEquipment* AecPipeLineModify::getEquiment(bool bByDB
	, const double &dDN
	, LPCTSTR pszPN
	, bool &bHasFangle
	, AecEqui::ValveType val
	, LPCTSTR psz/* = NULL*/
	, LPCTSTR pszFolder/* = NULL*/)
{
	if (bByDB)
	{
		if (!psz || !pszFolder) return NULL;

		/*AecDbEwEquipment *pEqu = CEquipmentLibraryDlg::getEquipment(CString(pszFolder) + _T("\\") + psz, dDN);
		if (pEqu)
		{
			AecDbObjXDataMap *pXMap = pEqu->GetSpecialtyData(AcDb::kForWrite);
			if (pXMap)
			{
				pXMap->SetAt(PIPE_VALVE, val);
				pXMap->SetAt(KEY_SUBRUNTIME, eValve);
				pXMap->SetAt(KEY_VLV2D, TRUE);
			}
			return pEqu;
		}*/
		return NULL;
	}
	return NULL;
}

typedef AcArray<AcGeMatrix3d> AcGeMatrix3dArray;
AecDbEwEquipment* AecPipeLineModify::CreateNewValve(AecDbEwEquipment* pEqu,const AecHvac::DuctParam & paramNew)
{
	if (pEqu != NULL)
	{
		



	}
	return NULL;
}

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

				//覆盖为新的参数
				AecHvac::DuctParam *pParam = &param;
				double dElOld = param.m_dEl;

				memcpy(pParam, &paramNew, sizeof(AecHvac::DuctParam));
				if (m_bElLock)
				{
					pParam->m_dEl = dElOld;
				}

				if (m_bUpdateMat)
				{
					_tcscpy(pParam->szMat,paramNew.szMat);
					_tcscpy(pParam->szSys, paramNew.szSys);
					
					//设置图层
					AecDbDuctLine::SetPipeLayer(pPipe, paramNew.szSys);
				}

				pPipe->SetDuctParam(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))
			{
				AecDbHvacDuct* pPipe = AecDbHvacDuct::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;
}