#include "StdAfx.h"
#include "StdArx.h"
#include "THImpHvacEGroup.h"
#include "TAuxTools.h"
#include "TDbInterfaceMsgWrite.h"
using namespace TDb;

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif



THImpHvacEGroup::THImpHvacEGroup()
{
	// 初始化子箱体功能指针
	m_pHvacEquipment = NULL;
	m_pHvacEquipment = new TDbHvacEquipment;
}

THImpHvacEGroup::~THImpHvacEGroup()
{
	// 销毁子箱体功能指针
	if (NULL != m_pHvacEquipment)
		delete m_pHvacEquipment;
}


BOOL THImpHvacEGroup::OPMInfo( LPCTSTR pszName, TDb::OPMInfo* pInfo )
{
	ASSERT(NULL != pszName && NULL != pInfo && NULL != m_pXDataMap);

	// 暖通基本参数设置
	if (0 == _tcsicmp(pszName, KEY_RUNTIME))
	{
		pInfo->bVisible = TRUE;
		pInfo->bEditable = FALSE;

		// 提供数据列表和对应关系
		if (NULL != pInfo->parsValues && NULL != pInfo->parlValues)
		{
			pInfo->parsValues->Add(_T("空气机组"));
			pInfo->parlValues->Add(TDb::eAirHanding);
		}

		return TRUE;
	}

	if (0 == _tcsicmp(pszName, HAHG_BasePoint))
	{
		pInfo->bVisible = TRUE;
		pInfo->bEditable = TRUE;

		// 整体移动
		if (NULL != pInfo->pXData && 0 != pInfo->pXData->nVt)
		{
			// 改变顶点变换行为
			AcGePoint3d pt;
			m_pXDataMap->GetAt(HAHG_BasePoint, pt);
			AcGeVector3d offset = asPnt3d(pInfo->pXData->dVal) - pt;
			
			AcGeMatrix3d mat;
			mat.setToTranslation(offset);
			transformBy(mat);
			pInfo->pXData->nVt = 0;	// 设置处理完成标识
		}

		return TRUE;
	}
	
	// 多联机样式 为了注册列表名，保证其他管件能用到此参数
	if (0 == _tcsicmp(pszName, HVRV_IType))
	{
		pInfo->bVisible = FALSE;
		pInfo->bEditable = FALSE;

		// 提供数据列表和对应关系
		if (NULL != pInfo->parsValues && NULL != pInfo->parlValues)
		{
  			pInfo->parlValues->Add(0);
			pInfo->parsValues->Add(_T("室内机"));
  			pInfo->parlValues->Add(1);
			pInfo->parsValues->Add(_T("室外机"));
		}

		return TRUE;
	}

	return FALSE;
}

void THImpHvacEGroup::MakeBoxCurve(TComplexCurve &cplCurve, AcGePoint3dArray &arPts) const
{
	TDb::TCurveElement el;
	memset(&el,0,sizeof(TDb::TCurveElement));
				
	el.ptGe[0] = arPts[1]; 
	el.ptGe[1] = arPts[2];
	el.ptGe[2] = arPts[2];
	cplCurve.append(el);
	el.ptGe[0] = arPts[3]; 
	el.ptGe[1] = arPts[4];
	el.ptGe[2] = arPts[4];
	cplCurve.append(el);
	el.ptGe[0] = arPts[1]; 
	el.ptGe[1] = arPts[4];
	el.ptGe[2] = arPts[4];
	cplCurve.append(el);
	el.ptGe[0] = arPts[2]; 
	el.ptGe[1] = arPts[3];
	el.ptGe[2] = arPts[3];
	cplCurve.append(el);
}

void THImpHvacEGroup::MakeDiagramCurve(XExplodeDraw &mode) const
{
	// 获取子箱体个数
	int iNum = 0;
	m_pXDataMap->GetAt(HAHG_SegmentsNum, iNum);

	// 获取机组的关键参数，以便判断要绘制俯视图或是侧视图
	BOOL bHasPlanform = FALSE;
	m_pXDataMap->GetAt(HAHG_Planform, bHasPlanform);

	// 机组的基点及矢量
	AcGeVector3d vtRot;
	m_pXDataMap->GetAt(HAHG_RotDir, vtRot);
	AcGePoint3d ptBase;
	m_pXDataMap->GetAt(HAHG_BasePoint, ptBase);

	// 逐个箱体绘制
	for (int i = 0; i < iNum; i++)
	{
		// 获取子箱体数据
		TDbXDataMap xSegMap;
		if (m_pXDataMap->GetAt(HAHG_SegmentData, i, xSegMap))
		{
			// 如果为侧视图，需将数据虚拟到俯视平面
			if (!bHasPlanform)
			{
				AcGePoint3d ptCen;
				xSegMap.GetAt(HEQU_CenterPoint, ptCen);
				ptCen.rotateBy(-PI * 0.5, vtRot, ptBase);
				xSegMap.SetAt(HEQU_CenterPoint, ptCen);
			}

			// 获取外框关键点
			AcGePoint3dArray arPts;
			GetBoxPts(arPts, &xSegMap);

			// 获取外框线段
 			TComplexCurve cplCurve;
 			MakeBoxCurve(cplCurve, arPts);
			
			// 绘制外框
 			TDbExtentsEdge edage;
			edage.SetEdage(cplCurve);
			AcDbObjectId idReal = ((TDbInterfacesObj*)m_pOwnerEnt)->layerId();
			AcDbObjectId idDash = ((TDbInterfacesObj*)m_pOwnerEnt)->DashLayer();
			AcDbObjectId idCent = ((TDbInterfacesObj*)m_pOwnerEnt)->CenterLayer();
 			edage.ExplodeOrDraw2d(mode,idReal,idDash,idCent);			
		} 
	}
}

void THImpHvacEGroup::GetBoxPts(AcGePoint3dArray &arPts, TDbXDataMap *pMap, double dOffset, BOOL bNor) const
{
	ASSERT(NULL != pMap);
	
	// 获取子箱体的关键数据
	AcGePoint3d ptStart, ptEnd, ptCenter;
	AcGeVector3d vtMain, vtNor, vtMainv;
	double dLength(50.0), dWidth(50.0), dThick(50.0);
	BOOL bIsConverse = FALSE;
	BOOL bHasPlanform = FALSE;
	pMap->GetAt(HVAC_Normal, vtNor);
	pMap->GetAt(HEQU_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HAHG_MainDir, vtMain);
	pMap->GetAt(HEQU_Length, dLength);		
	pMap->GetAt(HEQU_Width, dWidth);
	pMap->GetAt(HEQU_Thick, dThick);	
	pMap->GetAt(HEQU_IsConverse, bIsConverse);
	m_pXDataMap->GetAt(HAHG_Planform, bHasPlanform);

	// 俯视图与侧视图子箱体绘制时 使用的宽、厚不同
	if (!bHasPlanform)	
		dWidth = dThick;

	// 准备数据
	vtMainv = vtMain;
	vtMainv.rotateBy(PI * 0.5, vtNor);
	vtMain.normalize();
	vtMainv.normalize();		
	dLength *= 1000.0;
	dWidth *= 1000.0;

	// 计算外框关键点
	// 0
	arPts.append(ptCenter);
	AcGePoint3d pt;
	pt = ptCenter - vtMain * dLength * 0.5;
	pt = pt + vtMainv * dWidth * 0.5;
	// 1
	arPts.append(pt);
	// 2
	arPts.append(arPts[1] + vtMain * dLength);
	// 3
	arPts.append(arPts[2] - vtMainv * dWidth);
	// 4
	arPts.append(arPts[1] - vtMainv * dWidth);

	// 如果是底层箱体被遮挡，则调整外框的关键点
	if (!bNor)
	{
		arPts[2] = arPts[2] + dOffset * vtMain;
		arPts[3] = arPts[3] + dOffset * vtMain;
	}
}

BOOL THImpHvacEGroup::GetSubText(CString &sText, CStringArray &arText) const
{
	// vc2005之前的版本，含有非汉字字符不予处理
	INT_PTR iLen = sText.GetLength();
	int iVer(2);

#if (ADS > 16)
	iVer = 1;
#endif

	if (iLen % iVer != 0)
		return FALSE;

	// 截取单个汉字
	for (int i = 0; i < iLen; i += iVer)
	{
		CString str = sText.Mid(i, iVer);
		arText.Add(str);		
	}
	
	// 调整原文字格式
	sText = _T("");
	iLen = arText.GetSize();
	for (i = 0; i < iLen; i++)	
		sText += arText.GetAt(i) + _T("\r\n");		

	return TRUE;
}

double THImpHvacEGroup::GetTotalThick() const
{
	int iCount = 0;
	m_pXDataMap->GetAt(HAHG_SegmentsNum, iCount);
	double dMax(0.0);
	for (int i = 0; i < iCount; i++)
	{
		TDbXDataMap xSegMap;
		if (m_pXDataMap->GetAt(HAHG_SegmentData, i, xSegMap))
		{
			double dThick(0.0);
			xSegMap.GetAt(HEQU_Width, dThick);
			if (dThick > dMax)
				dMax = dThick;
		}
	}

	return dMax;
}

double THImpHvacEGroup::GetTotalWidth() const
{
	BOOL bIsHorizonal = FALSE;
	m_pXDataMap->GetAt(HAHG_IsHorizontal, bIsHorizonal);
	int iSegNum(0);
	m_pXDataMap->GetAt(HAHG_SegmentsNum, iSegNum);
	double dWid(0.0);
	if (bIsHorizonal)
	{		
		for (int i = 0; i < iSegNum; i++)
		{
			TDbXDataMap xSegMap;
			if (m_pXDataMap->GetAt(HAHG_SegmentData, iSegNum - 1, xSegMap))
			{
				double dSegLen(0.0);
				xSegMap.GetAt(HEQU_Thick, dSegLen);
				if (dSegLen > dWid)
					dWid = dSegLen;
			}
		}		
	}
	else
	{
		int iInflexion(0);
		m_pXDataMap->GetAt(HAHG_Inflexion, iInflexion);

		for (int j = iInflexion; j < iInflexion + 2; j ++)
		{
			TDbXDataMap xSegMap;
			if (m_pXDataMap->GetAt(HAHG_SegmentData, j, xSegMap))
			{
				double dSegLen(0.0);
				xSegMap.GetAt(HEQU_Thick, dSegLen);
				dWid += dSegLen;
			}
		}		
	}

	return dWid;
}

void THImpHvacEGroup::list() const
{
	if (m_pXDataMap == NULL)
		return;
	
	BOOL bIsHorizonal = FALSE;
	m_pXDataMap->GetAt(HAHG_IsHorizontal, bIsHorizonal);
	AcGePoint3d ptBase = AcGePoint3d::kOrigin;
	m_pXDataMap->GetAt(HAHG_BasePoint, ptBase);
	BOOL bRight = TRUE;
	m_pXDataMap->GetAt(HAHG_IsRight, bRight);

	acutPrintf(_T("\t\t\t\t\t\t\t\t%s"), _T("空气机组"));
	acutPrintf(_T("\n\t\t\t\t\t机组总长: %.0fmm"), GetTotalLen() * 1000.0);
	acutPrintf(_T("\n\t\t\t\t\t宽度: %.0fmm"), GetTotalThick() * 1000.0);
	acutPrintf(_T("\n\t\t\t\t\t高度: %.0fmm"), GetTotalWidth() * 1000.0);
	acutPrintf(_T("\n\t\t\t\t\t底座标高: %.2fm"), ptBase.z / 1000.0);
	acutPrintf(_T("\n\t\t\t\t\t组合方式: %s"), bIsHorizonal ? _T("卧式") : _T("立式"));
	acutPrintf(_T("\n\t\t\t\t\t气流方向: %s"), bRight ? _T("由左向右") : _T("由右向左"));	
}

TDbMText* THImpHvacEGroup::CreateMText(TDbXDataMap *pMap) const
{
	// 子箱体的名称
	CString sText(_T(""));
	pMap->GetAt(HEQU_SEquipType, sText);

	// 文字基点及方向
	AcGePoint3d ptBase = AcGePoint3d::kOrigin;
	pMap->GetAt(HEQU_CenterPoint, ptBase);
	AcGeVector3d vtMain = AcGeVector3d::kIdentity;
	m_pXDataMap->GetAt(HAHG_TextDir, vtMain);	

	
	// 拆分文字（用于竖向显示文字）
	CStringArray arText;
	if(!GetSubText(sText, arText))
		return NULL;

	// 没有要显示的文字 退出
	INT_PTR iSize = arText.GetSize();
	if (iSize == 0)
		return NULL;

	double dTextHeigh = 3.0;
	// 调整文字基点
	AcGeVector3d vtMainV = vtMain;
	vtMainV.rotateBy(PI * 0.5, TAuxTools::GetUcsZvt());
	vtMainV.normalize();
//	ptBase = ptBase + vtMainV * (double)iSize * 150;
	ptBase = ptBase + vtMainV * (double)iSize * dTextHeigh * 0.5 * DocGetPScale();
	
	// 创建并设置文字实体
	AcDbObjectId idStyle(AcDbObjectId::kNull);
	m_pXDataMap->GetAt(HDIM_DimTextId, idStyle);
	TDbMText *pMText = NULL;
	pMText = new TDbMText;
	pMText->setPropertiesFrom(m_pOwnerEnt);
	pMText->SetText(sText);
	pMText->SetLocation(ptBase);
	pMText->SetRotation(AcGeVector3d::kXAxis.angleTo(vtMain, AcGeVector3d::kZAxis));//TAuxTools::GetUcsXvt().angleTo(vtMain, TAuxTools::GetUcsZvt())
	pMText->setLayer(m_pOwnerEnt->layerId());
	pMText->SetHeight(dTextHeigh);	
	
	pMText->SetStyleId(idStyle);	
	pMText->SetAlignment(XExplodeDraw::kCenter);

	return pMText;	
}

void THImpHvacEGroup::MakeDiagramText(XExplodeDraw &mode) const
{
	// 子箱体个数
	int iNum = 0;
	m_pXDataMap->GetAt(HAHG_SegmentsNum, iNum);
	
	// 获取文字绘制的关键数据
	BOOL bHasPlanform = FALSE;
	m_pXDataMap->GetAt(HAHG_Planform, bHasPlanform);
	AcGeVector3d vtRot;
	m_pXDataMap->GetAt(HAHG_RotDir, vtRot);
	AcGePoint3d ptBase;
	m_pXDataMap->GetAt(HAHG_BasePoint, ptBase);
	
	// 逐个绘制文字
	for (int i = 0; i < iNum; i++)
	{
		TDbXDataMap xSegMap;
		if (m_pXDataMap->GetAt(HAHG_SegmentData, i, xSegMap))
		{
			// 如果为侧视图，需将数据变换后再绘制
			if (!bHasPlanform)
			{
				AcGePoint3d ptCen;
				xSegMap.GetAt(HEQU_CenterPoint, ptCen);
				ptCen.rotateBy(-PI * 0.5, vtRot, ptBase);
				xSegMap.SetAt(HEQU_CenterPoint, ptCen);
			}
			
			// 创建文字实体
			TDbMText *pMText = NULL;
			pMText = CreateMText(&xSegMap);
			if (NULL != pMText)
			{
				if (mode.IsFullExplode())				
					pMText->ExplodeOrDraw2d(mode);
				else
					mode.DrawEntity(*pMText);

				delete pMText;		
			}
		} 
	}
}

void THImpHvacEGroup::DrawBox(XExplodeDraw &mode, TDbXDataMap *pMap, double dOffset /* = 0.0 */, BOOL bNor /* = TRUE */) const
{
	// 首先绘制文字
	TDbMText *pMText = NULL;
	pMText = CreateMText(pMap);	
	if (NULL == pMText)
		return;

	//if (mode.IsFullExplode())				
		pMText->ExplodeOrDraw2d(mode);
	//else
	//	mode.DrawEntity(*pMText);
	delete pMText;

	// 获取子箱体外框关键点
	AcGePoint3dArray arPts;
	GetBoxPts(arPts, pMap, dOffset, bNor);
	
	// 获取子箱体外框线段数据
 	TComplexCurve cplCurve;
	MakeBoxCurve(cplCurve, arPts);
			
	// 绘制子箱体外框
	TDbExtentsEdge edage;
	edage.SetEdage(cplCurve);
	AcDbObjectId idReal = ((TDbInterfacesObj*)m_pOwnerEnt)->layerId();
	AcDbObjectId idDash = ((TDbInterfacesObj*)m_pOwnerEnt)->DashLayer();
	AcDbObjectId idCent = ((TDbInterfacesObj*)m_pOwnerEnt)->CenterLayer();			
	edage.ExplodeOrDraw2d(mode,idReal,idDash,idCent);

}

void THImpHvacEGroup::MakePlanform2D(XExplodeDraw &mode) const
{
	// 获取子箱体个数
	int iNum = 0;
	m_pXDataMap->GetAt(HAHG_SegmentsNum, iNum);
	if (iNum == 0)
		return;
	
	// 是否卧式
	BOOL bIsHorizontal = FALSE;
	m_pXDataMap->GetAt(HAHG_IsHorizontal, bIsHorizontal);
	
	// 卧式组合
	if (bIsHorizontal) 
	{
		MakeDiagramCurve(mode);
		MakeDiagramText(mode);
	}
	else 
	{
		// 拐点
		int iIdx = -1;
		m_pXDataMap->GetAt(HAHG_Inflexion, iIdx);

		// 拐点为最后一个子箱体时
		if (iIdx + 1 == iNum)
		{
			MakeDiagramCurve(mode);
			MakeDiagramText(mode);
		}
		else if (iIdx + 1 < iNum) 
		{
			// 记录顶层投影平面
			AcGePoint3d ptBaseAbove = AcGePoint3d::kOrigin;
			GetEquBasePoint(iNum - 1, ptBaseAbove);
			AcGePlane planAbove(ptBaseAbove, TAuxTools::GetUcsZvt());

			// 先绘制顶层箱体，并记录顶层总长度
			double dLenAbove = 0.0;
			for (int i = iIdx + 1; i < iNum; i++)
			{
				TDbXDataMap xSegMap;
				if (m_pXDataMap->GetAt(HAHG_SegmentData, i, xSegMap))
				{
					double dLen = 0.0;
					xSegMap.GetAt(HEQU_Length, dLen);
					dLenAbove += dLen * 1000.0;
					
					DrawBox(mode, &xSegMap);
				}
			}

			// 获得箱体总长
			double dTotalLen = GetTotalLen() * 1000.0;
			double dOverLen = dTotalLen - dLenAbove;

			// 绘制底层未遮挡的箱体
			if (dOverLen > 0.0)
			{
				for (int j = 0; j <= iIdx; j++)
				{
					TDbXDataMap xSegMap;
					if (m_pXDataMap->GetAt(HAHG_SegmentData, j, xSegMap))
					{
						// 获得箱体长度，投影中心点到顶层平面
						double dLen = 0.0;
						xSegMap.GetAt(HEQU_Length, dLen);
						AcGePoint3d ptTemp = AcGePoint3d::kOrigin;
						xSegMap.GetAt(HEQU_CenterPoint, ptTemp);
						ptTemp = ptTemp.orthoProject(planAbove);
						xSegMap.SetAt(HEQU_CenterPoint, ptTemp);
						
						dOverLen -= dLen * 1000.0;
						if (dOverLen > 0.0)
							DrawBox(mode, &xSegMap);
						else
						{
							DrawBox(mode, &xSegMap, dOverLen, FALSE);
							break;
						}						
					}
				}
			}
		}
	}

	//在jig时画接口线
	if(((TDbHvacEquipment*)m_pOwnerEnt)->IsDragging())
	{
		double dL(100.0);
		AcGeVector3d vtInter,vtScale;
		AcGePoint3d ptInter, ptend;
		XLine xline;
	
		TDbXDataMap xSegMap;
		int iNum = 0;
		m_pXDataMap->GetAt(HAHG_InterfaceNum, iNum);
		for (int j = 0; j < iNum; j++)
		{
			if (m_pXDataMap->GetAt(HAHG_InterfaceData, j, xSegMap))
			{
				if (xSegMap.GetAt(HEQUIF_Point, ptInter))
				{
					xSegMap.GetAt(HEQUIF_Vector, vtInter);
					vtInter.normalize();
					ptend = ptInter + vtInter * dL;  
					xline.SetPoints(ptInter, ptend);
					mode.SetColor(3);
					mode.DrawLine(xline);
				}
			}
		}
	}
}

double THImpHvacEGroup::GetTotalLen() const
{
	// 获取计算所用的关键数据
	double dTotalLen = 0.0;
	int iNum = 0;
	m_pXDataMap->GetAt(HAHG_SegmentsNum, iNum);
	if (iNum == 0)
		return dTotalLen;
	
	BOOL bIsHorizontal = FALSE;
	m_pXDataMap->GetAt(HAHG_IsHorizontal, bIsHorizontal);
	int iIdx = -1;
	m_pXDataMap->GetAt(HAHG_Inflexion, iIdx);

	if (iIdx == -1)
		bIsHorizontal = TRUE;

	// 如果为立式，那么箱体总长计算到拐点为止
	int iCount = -1;
	if (bIsHorizontal)
		iCount = iNum;
	else
		iCount = iIdx + 1;

	// 计算总长
	for (int i = 0; i < iCount; i++)
	{
		TDbXDataMap xSegMap;
		if (m_pXDataMap->GetAt(HAHG_SegmentData, i, xSegMap))
		{
			double dLen = 0.0;
			xSegMap.GetAt(HEQU_Length, dLen);
			dTotalLen += dLen;
		}
	}

	return dTotalLen;
}

BOOL THImpHvacEGroup::GetEquBasePoint(int iIndex, AcGePoint3d &ptBase) const
{
	BOOL bSuc = FALSE;

	TDbXDataMap xSegMap;
	if (m_pXDataMap->GetAt(HAHG_SegmentData, iIndex, xSegMap))
		if (xSegMap.GetAt(HEQU_CenterPoint, ptBase))
			bSuc = TRUE;
	
	return bSuc;
}

Acad::ErrorStatus THImpHvacEGroup::ExplodeOrDraw2d(XExplodeDraw &mode) const
{
	ASSERT(NULL != m_pXDataMap && NULL != m_pHvacEquipment);

	int iNum = 0;
	m_pXDataMap->GetAt(HAHG_SegmentsNum, iNum);
	BOOL bHasPlanform = FALSE;
	m_pXDataMap->GetAt(HAHG_Planform, bHasPlanform);

	// 绘制俯视图
	if (bHasPlanform)
	{
		MakePlanform2D(mode);
	}
	else
	{
		// 绘制箱体部分	
		BOOL bDiagram = FALSE;
		m_pXDataMap->GetAt(HAHG_Diagram, bDiagram);
		AcGeVector3d vtRot;
		m_pXDataMap->GetAt(HAHG_RotDir, vtRot);
		AcGePoint3d ptBase;
		m_pXDataMap->GetAt(HAHG_BasePoint, ptBase);

		// 详图
		if (!bDiagram)
		{
			for (int i = 0; i < iNum; i++)
			{
				TDbXDataMap xSegMap;
				if (m_pXDataMap->GetAt(HAHG_SegmentData, i, xSegMap))
				{
					double dLen(0.0);					
					xSegMap.GetAt(HEQU_Length, dLen);
					xSegMap.SetAt(HEQU_Length, dLen * 2.0);
					AcGePoint3d ptCen;
					xSegMap.GetAt(HEQU_CenterPoint, ptCen);
					ptCen.rotateBy(-PI * 0.5, vtRot, ptBase);
					xSegMap.SetAt(HEQU_CenterPoint, ptCen);
					
					BOOL bIsConverse = FALSE;
					xSegMap.GetAt(HEQU_IsConverse, bIsConverse);
					AcGeMatrix3d matMirror;
					if (bIsConverse)
					{
						AcGeVector3d vtDir, vtNor;
						xSegMap.GetAt(HEQU_MainDir, vtDir);
						vtDir.normalize();
						xSegMap.GetAt(HVAC_Normal, vtNor);
						vtNor.normalize();
						AcGePlane plane(ptCen, vtNor, vtNor.crossProduct(vtDir));
						matMirror.setToMirroring(plane);
					}

					double dWid(0.0), dThick(0.0);
					xSegMap.GetAt(HEQU_Width, dWid);
					xSegMap.GetAt(HEQU_Thick, dThick);
					xSegMap.SetAt(HEQU_Thick, dWid);
					xSegMap.SetAt(HEQU_Width, dThick);
					
					AcDbObjectId id2D = AcDbObjectId::kNull;
					if (GetSeg2DId(i, id2D))
					{
						xSegMap.SetAt(HEQU_PartCenter, id2D);
						m_pHvacEquipment->GetSpecialtyData()->CopyFrom(&xSegMap);
											
						m_pHvacEquipment->ReCreateByXDataMap();
						if (bIsConverse)
							//change by zh 2013-5-23 解决空气机组Move出错问题
							//Acad::ErrorStatus eSee = m_pHvacEquipment->transformBy(matMirror);
							Acad::ErrorStatus eSee = m_pHvacEquipment->TransformBy(matMirror);
						m_pHvacEquipment->ExplodeOrDraw2d(mode);
					}
					
				} 
			}
		}
		else// 简图
		{
			MakeDiagramCurve(mode); //绘制边框
			MakeDiagramText(mode); //绘制文字
		}
	}

	BOOL bHasText = FALSE;
	m_pXDataMap->GetAt(HAHG_HasText, bHasText);

	// 绘制模版文字,放在命令端单独绘制成为多行文字
	if (bHasText)
	{
		MakeTemplateText(mode);
	}

	return Acad::eOk;	
}

BOOL THImpHvacEGroup::GetSeg2DId(int iIdx, AcDbObjectId &id) const
{
	CString sKey;
	sKey.Format(_T("%d"), iIdx);
	if (m_pXDataMap->GetAt(sKey, id))
		return TRUE;

	return FALSE;
}

void THImpHvacEGroup::MakeTemplateText(XExplodeDraw &mode) const
{
	// 得到模板文字
	int iNum = 0;
	m_pXDataMap->GetAt(HAHG_TextNum, iNum);
	if (iNum == 0)
		return;

	
	CString sText(_T(""));
	for (int i = 0; i < iNum; i++)
	{
		CString sTmp(_T(""));
		m_pXDataMap->GetAt(HAHG_Text, i, sTmp);
		sText += sTmp;
	}	

	if (!sText.IsEmpty())
	{
		// 模板文字的基点及矢量
		AcGePoint3d ptBase;
		m_pXDataMap->GetAt(HAHG_TextPoint, ptBase);
		AcGeVector3d vtDir;
		m_pXDataMap->GetAt(HAHG_TextDir, vtDir);

		// 创建及设置模板文字实体
		TDbMText *pMText = NULL;
		pMText = new TDbMText;
		pMText->SetText(sText);
		pMText->SetLocation(ptBase);
		pMText->SetRotation(AcGeVector3d::kXAxis.angleTo(vtDir, AcGeVector3d::kZAxis));
		pMText->setLayer(m_pOwnerEnt->layerId());
		pMText->SetHeight(3.0);	
		
		AcDbObjectId idStyle(AcDbObjectId::kNull);
		m_pXDataMap->GetAt(HDIM_DimTextId, idStyle);
		pMText->SetStyleId(idStyle);	
//		pMText->SetStyleId(GetTextStyleId(_T("_TCH_DIM")));	
		
		pMText->SetAlignment(XExplodeDraw::kLeft);
		pMText->setPropertiesFrom(m_pOwnerEnt);

		// 绘制文字
		if (mode.IsFullExplode())				
			pMText->ExplodeOrDraw2d(mode);
		else
			mode.DrawEntity(*pMText);
		delete pMText;
	}
}

void THImpHvacEGroup::MakeSideViewDim(XExplodeDraw &mode) const
{
	int iNum = 0;
	m_pXDataMap->GetAt(HAHG_SegmentsNum, iNum);
	if (iNum <= 0)
		return;

	BOOL bIsHorizontal = FALSE;
	m_pXDataMap->GetAt(HAHG_IsHorizontal, bIsHorizontal);
	int iIdx = -1;
	m_pXDataMap->GetAt(HAHG_Inflexion, iIdx);

	bIsHorizontal = TRUE;// test

	AcDbVoidPtrArray arDimEnt;
	AcGePoint3dArray arPts;

	// 只有一个箱体时
	if (iNum == 1)
	{
		TDbXDataMap xSegMap;
		if (m_pXDataMap->GetAt(HAHG_SegmentData, 0, xSegMap))
		{
			GetBoxPts(arPts, &xSegMap);
			
			arDimEnt.append(CreateDimension(arPts[4], arPts[3], arPts[5]));
			arDimEnt.append(CreateDimension(arPts[2], arPts[3], arPts[7]));
		}
	}
	else // 多个箱体时
	{
		if (bIsHorizontal)// 卧式
		{
			AcGePoint3d ptS, ptE, ptE1;
			for (int i = 0; i < iNum; i++)
			{
				TDbXDataMap xSegMap;
				if (m_pXDataMap->GetAt(HAHG_SegmentData, i, xSegMap))
				{
					arPts.setLogicalLength(0);
					GetBoxPts(arPts, &xSegMap);

					// 为子箱体下侧添加标注
					arDimEnt.append(CreateDimension(arPts[3], arPts[4], arPts[5]));

					// 记录第一个子箱体的标注关键点
					if (i == 0)
					{
						ptS = arPts[4];
						ptE1 = arPts[6];
					}

					// 记录最后一个子箱体的标注关键点，并为子箱体右侧添加标注
					if (i == iNum - 1)
					{
						ptE = arPts[3];
						arDimEnt.append(CreateDimension(arPts[2], arPts[3], arPts[7]));
					}
				}				
			}

			// 为机组下侧添加总长标注
			arDimEnt.append(CreateDimension(ptS, ptE, ptE1));
		}
		else // 立式
		{
			int iIdx = -1;
			m_pXDataMap->GetAt(HAHG_Inflexion, iIdx);

			// 立式中拐点在最后的
			if (iIdx == iNum - 1) 
			{
				AcGePoint3d ptS, ptE, ptE1;
				for (int i = 0; i < iNum; i++)
				{
					TDbXDataMap xSegMap;
					if (m_pXDataMap->GetAt(HAHG_SegmentData, i, xSegMap))
					{
						arPts.setLogicalLength(0);
						GetBoxPts(arPts, &xSegMap);
						arDimEnt.append(CreateDimension(arPts[3], arPts[4], arPts[5]));
						if (i == 0)
						{
							ptS = arPts[4];
							ptE1 = arPts[6];
						}
						
						if (i == iNum - 1)
						{
							ptE = arPts[3];
							arDimEnt.append(CreateDimension(arPts[2], arPts[3], arPts[7]));
						}
					}				
				}
				arDimEnt.append(CreateDimension(ptS, ptE, ptE1));
			}
			else
			{
				if (iIdx == 0) // 立式特殊情况
				{
					AcGePoint3d ptS, ptE, ptE1;
					TDbXDataMap xSegMap;
					
					// 为第一个子箱体添加下侧与右侧的标注，并记录右侧的标注关键点
					if (m_pXDataMap->GetAt(HAHG_SegmentData, 0, xSegMap))
					{
						GetBoxPts(arPts, &xSegMap);
						arDimEnt.append(CreateDimension(arPts[4], arPts[3], arPts[5]));
						arDimEnt.append(CreateDimension(arPts[2], arPts[3], arPts[7]));
						ptS = arPts[3];
						ptE1 = arPts[8];
					}
					
					// 为第二个子箱体添加右侧标注，并为机组添加右侧总长
					arPts.setLogicalLength(0);
					if (m_pXDataMap->GetAt(HAHG_SegmentData, 1, xSegMap))
					{
						GetBoxPts(arPts, &xSegMap);
						arDimEnt.append(CreateDimension(arPts[2], arPts[3], arPts[7]));
						ptE = arPts[2];
						arDimEnt.append(CreateDimension(ptS, ptE, ptE1));
					}
				}				
				else // 正常情况
				{
					AcGePoint3d ptS, ptE, ptE1;
					AcGePoint3d ptSV, ptEV, ptE1V;

					for (int i = 0; i < iIdx + 2; i++)
					{
						TDbXDataMap xSegMap;
						if (m_pXDataMap->GetAt(HAHG_SegmentData, i, xSegMap))
						{
							arPts.setLogicalLength(0);
							GetBoxPts(arPts, &xSegMap);
							
							// 记录第一个子箱体的标注关键点
							if (i == 0)
							{
								ptS = arPts[4];
								ptE1 = arPts[6];
							}

							// 为拐点之前的子箱体添加下侧的标注
							if (i < iIdx)
								arDimEnt.append(CreateDimension(arPts[4], arPts[3], arPts[5]));

							// 为拐点子箱体添加下侧及右侧标注，并记录标注关键点
							if (i == iIdx)
							{
								arDimEnt.append(CreateDimension(arPts[4], arPts[3], arPts[5]));
								arDimEnt.append(CreateDimension(arPts[2], arPts[3], arPts[7]));
								ptE = arPts[3];
								ptSV = arPts[3];
								ptE1V = arPts[8];
							}

							// 为拐点之后第一个子箱体添加右侧标注， 并记录标注关键点
							if (i == iIdx + 1)
							{
								arDimEnt.append(CreateDimension(arPts[2], arPts[3], arPts[7]));
								ptEV = arPts[2];
							}
						}
					}

					// 为机组添加下侧及右侧的总长标注
					arDimEnt.append(CreateDimension(ptS, ptE, ptE1));
					arDimEnt.append(CreateDimension(ptSV, ptEV, ptE1V));
				}
			}			
		}
	}
	
	// 逐个绘制标注
	AcDbObjectId idOldLayer = mode.GetLayerId();	
	for (int j = 0; j < arDimEnt.length(); j++)
	{
		// 临时添加标注到模型空间
 		AcDbEntity *pEnt = NULL;
 		pEnt = (AcDbEntity*)arDimEnt.at(j);		
		AcDbObjectId idTmp = AddToModelSpace(pEnt, Adesk::kTrue);

		// 打开标注实体
		OPENOBJ_BEGIN(idTmp, AcDb::kForWrite, AcDbAlignedDimension, pTmpDim);
		if (pTmpDim == NULL)
			return;

		// 置为删除状态
		pTmpDim->erase();

		// 炸开标注实体进行绘制（由于02平台下的XExplodeDraw::DrawEntity()绘制标注时有问题）
  		AcDbVoidPtrArray arTmp;
		Acad::ErrorStatus es = pTmpDim->explode(arTmp);

		// 逐个绘制炸开的元素
 		for(int i = 0; i < arTmp.length(); i++)
 		{
			// 如果是AcDbMText类型的，继续将其炸开（理由同上）
 			AcDbEntity *pTmpEnt = (AcDbEntity*)arTmp.at(i);
			CString str = pTmpEnt->isA()->name();
			if (str == _T("AcDbMText"))
			{
				AcDbVoidPtrArray arMText;
				pTmpEnt->explode(arMText);
				for (int k = 0; k < arMText.length(); k++)
				{
					AcDbText *pttE = (AcDbText*)arMText.at(k);
					mode.DrawEntity(*pttE);
					delete pttE;
				}
			}
			// 其他正常绘制
			else			
				mode.DrawEntity(*pTmpEnt);					
			
 			delete pTmpEnt;
 		}
		OPENOBJ_END();
	}
	mode.SetLayer(idOldLayer);

}

AcDbAlignedDimension* THImpHvacEGroup::CreateDimension(AcGePoint3d xLinePt1, AcGePoint3d xLinePt2, AcGePoint3d dimLinePt) const
{	
	// 创建标注实体
	AcDbAlignedDimension *pDim = NULL;
	pDim = new AcDbAlignedDimension(xLinePt1, xLinePt2, dimLinePt);
	pDim->setDatabaseDefaults(acdbCurDwg());
	pDim->setDimtxt(2.0);
	
	return pDim;
}

Acad::ErrorStatus THImpHvacEGroup::ExplodeOrDraw3d(XExplodeDraw &mode) const
{
	ASSERT(NULL != m_pXDataMap && NULL != m_pHvacEquipment);

	BOOL bIsPreviewing = FALSE;	
	m_pXDataMap->GetAt(HAHG_IsPreviewing, bIsPreviewing);
	if (bIsPreviewing)
	{
		ExplodeOrDraw2d(mode);
		return Acad::eOk;
	}
	
	BOOL bIsPlanform = TRUE;
	m_pXDataMap->GetAt(HAHG_Planform, bIsPlanform);
	if (!bIsPlanform)
		return Acad::eNotApplicable;

	int iNum = 0;
	m_pXDataMap->GetAt(HAHG_SegmentsNum, iNum);	

	if (iNum == 0)
		return Acad::eNotApplicable;

	// 逐个绘制子箱体部分
	AcGeVector3d vtMain;
	m_pXDataMap->GetAt(HAHG_MainDir, vtMain);
	for (int i = 0; i < iNum; i++)
	{
		TDbXDataMap xSegMap;
		if (m_pXDataMap->GetAt(HAHG_SegmentData, i, xSegMap))
		{
			// 绘制详图
			double dLen(0.0);			
			xSegMap.GetAt(HEQU_Length, dLen);
			xSegMap.SetAt(HEQU_Length, dLen * 2.0);				
			double dWid = 0.0;
			xSegMap.GetAt(HEQU_Thick, dWid);
			dWid *= 1000.0;
			AcGeVector3d vtNor = TAuxTools::GetUcsZvt();
			vtNor.normalize();
			AcGePoint3d ptBase = AcGePoint3d::kOrigin;
			xSegMap.GetAt(HEQU_CenterPoint, ptBase);
			AcGePoint3d ptBaseNew = ptBase - vtNor * dWid * 0.5;
			xSegMap.SetAt(HEQU_CenterPoint, ptBaseNew);
			AcDbObjectId id2D = AcDbObjectId::kNull;

			BOOL bIsConverse = FALSE;
			xSegMap.GetAt(HEQU_IsConverse, bIsConverse);
			AcGeMatrix3d matMirror;
			if (bIsConverse)
			{
				AcGeVector3d vtDir;
				xSegMap.GetAt(HEQU_MainDir, vtDir);
				vtDir.normalize();
				AcGePoint3d ptTmp = ptBaseNew + vtDir * 100.0;
				
				AcGeLine3d lineMirror(ptBaseNew, ptTmp);
				matMirror.setToMirroring(lineMirror);
			}

			if (GetSeg2DId(i, id2D))
			{
				xSegMap.SetAt(HEQU_PartCenter, id2D);
				m_pHvacEquipment->GetSpecialtyData()->CopyFrom(&xSegMap);
				m_pHvacEquipment->ReCreateByXDataMap();
				if (bIsConverse)
					m_pHvacEquipment->transformBy(matMirror);
				m_pHvacEquipment->ExplodeOrDraw3d(mode);
			}
			
			xSegMap.GetAt(HEQU_Length, dLen);
			xSegMap.SetAt(HEQU_Length, dLen * 0.5);
			
			// 绘制3D边框
			AcGePoint3dArray arPts;
			xSegMap.SetAt(HEQU_CenterPoint, ptBase);
			GetBoxPts(arPts, &xSegMap);			
			AcGePoint3dArray arPtSides;
			arPtSides.append(arPts[3] + vtNor * dWid * 0.5);
			arPtSides.append(arPts[4] + vtNor * dWid * 0.5);
			arPtSides.append(arPts[4] - vtNor * dWid * 0.5);
			arPtSides.append(arPts[3] - vtNor * dWid * 0.5);
			arPtSides.append(arPts[3] + vtNor * dWid * 0.5);
			arPtSides.append(arPts[2] + vtNor * dWid * 0.5);
			arPtSides.append(arPts[1] + vtNor * dWid * 0.5);
			arPtSides.append(arPts[1] - vtNor * dWid * 0.5);
			arPtSides.append(arPts[2] - vtNor * dWid * 0.5);
			arPtSides.append(arPts[2] + vtNor * dWid * 0.5);
			mode.DrawMesh(2, 5, arPtSides.asArrayPtr());
		}		
	}
//	标注原因：暂时决定不再显示底座 by lz
// 	AcGePoint3d ptBase = AcGePoint3d::kOrigin;
// 	m_pXDataMap->GetAt(HAHG_BasePoint, ptBase);
// 	if (ptBase.z > 0.000001)
// 	{
// 		
// 		AcGePoint3dArray arPtSides;
// 		arPtSides.append(ptBase);
// 		AcGeVector3d vtDir, vtNor, vtVDir;
// 		m_pXDataMap->GetAt(HAHG_MainDir, vtDir);
// 		m_pXDataMap->GetAt(HVAC_Normal, vtNor);
// 		vtVDir = vtDir.crossProduct(vtNor);	
// 		vtDir.normalize();
// 		vtVDir.normalize();
// 		vtNor.normalize();
// 		double dLen = GetTotalLen();
// 		double dThick = GetTotalThick();
// 		BOOL bRight = FALSE;
// 		m_pXDataMap->GetAt(HAHG_IsRight, bRight);
// 		if (bRight)
// 		{
// 			arPtSides.append(ptBase - vtVDir * dThick * 1000);
// 			arPtSides.append(ptBase - vtVDir * dThick * 1000 + vtDir * dLen * 1000);
// 			arPtSides.append(ptBase + vtDir * dLen * 1000);
// 			arPtSides.append(ptBase);
// 		}
// 		else
// 		{
// 			arPtSides.append(ptBase + vtVDir * dThick * 1000);
// 			arPtSides.append(ptBase + vtVDir * dThick * 1000 - vtDir * dLen * 1000);
// 			arPtSides.append(ptBase - vtDir * dLen * 1000);
// 			arPtSides.append(ptBase);
// 		}
// 		
// 		arPtSides.append(arPtSides.at(0) - vtNor * ptBase.z);
// 		arPtSides.append(arPtSides.at(1) - vtNor * ptBase.z);
// 		arPtSides.append(arPtSides.at(2) - vtNor * ptBase.z);
// 		arPtSides.append(arPtSides.at(3) - vtNor * ptBase.z);
// 		arPtSides.append(arPtSides.at(4) - vtNor * ptBase.z);
// 		mode.DrawMesh(2, 5, arPtSides.asArrayPtr());
// 	}

	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacEGroup::transformBy(const AcGeMatrix3d& xform)
{
	ASSERT(NULL != m_pXDataMap && NULL != m_pHvacEquipment);

	int iNum = 0;
	m_pXDataMap->GetAt(HAHG_SegmentsNum, iNum);

	// 箱体部分
	for (int i = 0; i < iNum; i++)
	{
		TDbXDataMap xSegMap;
		if (m_pXDataMap->GetAt(HAHG_SegmentData, i, xSegMap))
		{
			AcGePoint3d ptCenter;
			AcGeVector3d vtMainDir;
			xSegMap.GetAt(HEQU_CenterPoint, ptCenter);
			xSegMap.GetAt(HEQU_MainDir, vtMainDir);
			// add by zh 2013-5-24 镜像处理
			/*AcGeVector3d vtNor, vtScale;
			double dL(1.0),dW(1.0),dT(1.0); 
			xSegMap.GetAt(HEQU_Length, dL);
			xSegMap.GetAt(HEQU_Width, dW);
			xSegMap.GetAt(HEQU_Thick, dT);
			xSegMap.GetAt(HEQU_Scale, vtScale);
			xSegMap.GetAt(HVAC_Normal, vtNor);

			AcGeVector3d vtPrep(vtNor.crossProduct(vtMainDir));

			// 变换位置
			ptCenter.transformBy(xform);
			vtMainDir.transformBy(xform);
			vtNor.transformBy(xform);
			vtPrep.transformBy(xform);
			// 同向是旋转，不变号，反向是镜像，变号。
			int iSign = ((vtPrep.isCodirectionalTo(vtNor.crossProduct(vtMainDir))) ? 1 : -1);
			vtScale.y *= iSign;
			double dscale = xform.scale();
			vtScale *= dscale;
			// 更新点
			xSegMap.SetAt(HVAC_Normal, vtNor);
			xSegMap.SetAt(HEQU_Length, dL * dscale);
			xSegMap.SetAt(HEQU_Width, dW * dscale);
			xSegMap.SetAt(HEQU_Thick, dT * dscale);
			xSegMap.SetAt(HEQU_Scale, vtScale);
			*/
			//m_pHvacEquipment->GetSpecialtyData()->CopyFrom(&xSegMap);
			//m_pHvacEquipment->ReCreateByXDataMap();
			//m_pHvacEquipment->transformBy(xform);
			ptCenter.transformBy(xform);
			vtMainDir.transformBy(xform);
			xSegMap.SetAt(HEQU_CenterPoint, ptCenter);
			xSegMap.SetAt(HEQU_MainDir, vtMainDir);
			//xSegMap.CopyFrom(m_pHvacEquipment->GetSpecialtyData());
			//xSegMap.RemoveAt(HEQU_TextPoint);			
			m_pXDataMap->SetAt(HAHG_SegmentData, i, xSegMap);
		}		
	}
	
	// 接口数据
	AcGeVector3d vtDir = AcGeVector3d::kIdentity;
	AcGePoint3d ptBase = AcGePoint3d::kOrigin;
	int iIFCount = GetInterfaceCount();
	for (int j = 0; j < iIFCount; j++)
	{
		TDbXDataMap xIFData;
		if (m_pXDataMap->GetAt(HAHG_InterfaceData, j, xIFData))
		{
			xIFData.GetAt(HEQUIF_Point, ptBase);
			ptBase.transformBy(xform);
			BOOL bLook = xIFData.SetAt(HEQUIF_Point, ptBase);

			xIFData.GetAt(HEQUIF_Vector, vtDir);
			vtDir.transformBy(xform);
			xIFData.SetAt(HEQUIF_Vector, vtDir);

			m_pXDataMap->SetAt(HAHG_InterfaceData, j, xIFData);
		}
	}

	// 基点	
	m_pXDataMap->GetAt(HAHG_BasePoint, ptBase);
	ptBase.transformBy(xform);
	m_pXDataMap->SetAt(HAHG_BasePoint, ptBase);

	// 文字基点
	m_pXDataMap->GetAt(HAHG_TextPoint, ptBase);
	ptBase.transformBy(xform);
	m_pXDataMap->SetAt(HAHG_TextPoint, ptBase);
	
	// 矢量方向
	m_pXDataMap->GetAt(HAHG_MainDir, vtDir);
	vtDir.transformBy(xform);
	m_pXDataMap->SetAt(HAHG_MainDir, vtDir);
	
	// 文字方向
    m_pXDataMap->GetAt(HAHG_TextDir, vtDir);
    vtDir.transformBy(xform);
	m_pXDataMap->SetAt(HAHG_TextDir, vtDir);
    
	// 侧视图求点用的旋转轴
	m_pXDataMap->GetAt(HAHG_RotDir, vtDir);
	vtDir.transformBy(xform);
	m_pXDataMap->SetAt(HAHG_RotDir, vtDir);
	

	return Acad::eOk;
}

TDb::Position THImpHvacEGroup::ExplainGripIndex(int nIndex) const
{
	if (nIndex > 1)
		return TDb::eCommand0;

	return TDb::eMid;

//	模版文字单独布置为多行文字
// 	BOOL bHasText = FALSE;
// 	m_pXDataMap->GetAt(HAHG_HasText, bHasText);
// 	int iSt = 0;
// 	if (bHasText)
// 		iSt = 1;
// 
// 	// 接口夹点
// 	if(nIndex > iSt)	
// 		return TDb::eCommand0;	
// 	else	
// 		// 实体移动夹点
// 		if (nIndex == 0)
// 			return TDb::eMid;
// 		// 模板文字移动夹点
// 		else
// 			return TDb::eStart;
}

Acad::ErrorStatus THImpHvacEGroup::GetGripText(int i, CString &cs) const
{	
// 文字不在实体中绘制了	
// 	BOOL bHasText = FALSE;
// 	m_pXDataMap->GetAt(HAHG_HasText, bHasText);
// 
// 	int iSt = 0;
// 	if (bHasText)
// 		iSt = 1;

	int iSt = 1;
	// 获取子箱体的接口夹点描述文字
	if (i > iSt)
	{
		int iIndex = i - iSt - 1;
		TDbXDataMap xIFData;
		if (m_pXDataMap->GetAt(HAHG_InterfaceData, iIndex, xIFData))		
			xIFData.GetAt(HEQUIF_Name, cs);		
	}
	else
	{
		// 机组及模板文字的夹点描述文字
//		if (i == 0)
			cs = _T("改变位置");
//		if (i == 1)
//			cs = _T("文字移动");
	}

	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacEGroup::moveGripPointsAt(const AcDbIntArray& indices,
                                   const AcGeVector3d& offset)
{
	ASSERT(NULL != m_pXDataMap);
	
	int iLen = indices.length();	
	if (iLen > 0)
	{
		//取第一个选中的夹点
		int iIdx = indices.first();
		TDb::Position ePos = ExplainGripIndex(iIdx);
		AcGeMatrix3d xform;
		xform.setToTranslation(offset);

		switch (ePos)
		{
		// 实体移动夹点
		case TDb::eMid:
			{				
				transformBy(xform);
				AcGePoint3d ptBase = AcGePoint3d::kOrigin;
				m_pXDataMap->GetAt(HAHG_BasePoint, ptBase);
				if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
				{
					if (TAuxTools::IsEquipAutoMove(this, offset))
					{
						// 写入接口更改消息
						TInterfaceModifyMsg iMsg;
						iMsg.SetMsgPoint(ptBase);//new pos
						iMsg.SetGripPosition(TDb::eMid);
						iMsg.SetMoveGripOffset(offset);
						iMsg.SetMsgValidate(TRUE);
						iMsg.SetInterfaceOper(TDb::eMoveGripPoint);
						iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());
						TDbInterfaceMsgWrite msgWrite;
						msgWrite.WriteInterfaceMsg(iMsg);
					}
								
					//更新接口记录接口信息
					UpdateInterfaceRec(m_pOwnerEnt->objectId(),xform);
				}

				break;
			}
		// 文字移动夹点
		case TDb::eStart:
			{
				AcGePoint3d ptTextBase = AcGePoint3d::kOrigin;
				m_pXDataMap->GetAt(HAHG_TextPoint, ptTextBase);
				ptTextBase.transformBy(xform);
				m_pXDataMap->SetAt(HAHG_TextPoint, ptTextBase);
				
				break;
			}
		// 接口夹点
		case TDb::eCommand0:
			{				
				CString sCmd;
				int iType = -1;
// 				BOOL bHasText = FALSE;	// 目前文字放到了外面
// 				m_pXDataMap->GetAt(HAHG_HasText, bHasText);
// 				
// 				int iSt = 1;
// 				if (bHasText)
// 					iSt = 2;

 				int iSt = 2;
				iType = GetCmdType(iIdx - iSt);

				AcGePoint3d ptCom = AcGePoint3d::kOrigin;
				if (!GetIFPoint(iIdx - iSt, ptCom))
					return Acad::eNotApplicable;

				switch (iType)
				{
				case 0:
					GetGlobalContext()->GetAt(KEY_HVACCOLDGRIPCMD, sCmd);
					break;
				case 1:
				case 2:
					GetGlobalContext()->GetAt(KEY_HVACGRIPCMD, sCmd);
					break;
				case 3:
					GetGlobalContext()->GetAt(KEY_HVACHEATGRIPCMD, sCmd);
					break;
				case 4:
					GetGlobalContext()->GetAt(KEY_HVACMEDIAGRIPCMD, sCmd);
					break;
				case 5:
					GetGlobalContext()->GetAt(KEY_HVACFJSQGRIPCMD, sCmd);
					break;
				}

				if (sCmd.IsEmpty())
					return Acad::eNotApplicable;

				TInterfaceModifyMsg iMsg;
				iMsg.SetMsgPoint(ptCom);
				iMsg.SetGripPosition(ePos);
				iMsg.SetMoveGripOffset(offset);
				iMsg.SetMsgValidate(TRUE);
				iMsg.SetInterfaceOper(TDb::eNewCommand);
				iMsg.SetPreviewObjToCreate(TDb::eAirHanding, 0);

				AcDbSoftPointerId idOwner;
				m_pXDataMap->GetAt(KEY_THISID, idOwner);
				iMsg.SetMsgOperateOn(idOwner);
				TDbInterfaceMsgWrite msgWrite;
				msgWrite.WriteInterfaceMsg(iMsg);

				acedPostCommand(_T("\33"));
				acedPostCommand(sCmd + _T("\n"));
				
				break;
			}
		default:
			break;
		}
	}

	return Acad::eOk;
}

int THImpHvacEGroup::GetCmdType(int iIdx) const
{
	// 得到对应的子箱体索引
	int iCmd = -1;

	// 得到子箱体中对应索引的接口命令类型
	TDbXDataMap xIFData;
	if (m_pXDataMap->GetAt(HAHG_InterfaceData, iIdx, xIFData))
		xIFData.GetAt(HEQUIF_Type, iCmd);
	
	return iCmd;
}

int THImpHvacEGroup::ConvertToEquIndex(int &iIdx) const
{	
	// 转换机组接口索引为：子箱体接口索引，子箱体索引
	int iSegNum(0);
	m_pXDataMap->GetAt(HAHG_SegmentsNum, iSegNum);
	
	iIdx = iIdx + 1;
	for (int i = 0; i < iSegNum; i++)
	{
		TDbXDataMap xSegMap;
		if (m_pXDataMap->GetAt(HAHG_SegmentData, i, xSegMap))
		{
			int iTmp = 0;
			xSegMap.GetAt(HEQU_InterfaceNum, iTmp);

			if (iIdx > iTmp)
				iIdx -= iTmp;
			else
			{
				iIdx -= 1;
				return i;
			}
		}
	}

	return 0;
}

BOOL THImpHvacEGroup::SetInterfaceRelation(const AcGePoint3d& ptConnect,const AcDbObjectId& idConnect)
{
	if (NULL == m_pXDataMap)
		return FALSE;
	
	// 打开对象
	AcDbEntity* pEnt;
	if (Acad::eOk != acdbOpenObject(pEnt, idConnect, AcDb::kForRead))
		return FALSE;

	// 检查对象类型，是否是暖通管件
	if (!(pEnt->isKindOf(TDbHvacDuct::desc()) || pEnt->isKindOf(TDbHvacFitting::desc())
		|| pEnt->isKindOf(TDbHvacEquipment::desc())))
	{
		pEnt->close();
		return FALSE;
	}
	
	// 获取各点位置
	int nIndex(-1);
	if(GetIFIndexFormPt(nIndex,ptConnect))
	{
		CString sID;
		sID.Format(_T("%s%d"), KEY_IDCNT_, nIndex);
		
		// 基类指针
		TDbInterfacesObj* pInterfaceObj = TDbInterfacesObj::cast(pEnt);
		ASSERT(NULL != pInterfaceObj);
		m_pXDataMap->SetAt(sID, idConnect);
		pEnt->close();
		return TRUE;
	}

	pEnt->close();
	return FALSE;
}

BOOL THImpHvacEGroup::RemoveInterfaceRelation(const AcGePoint3d& ptConnect,const AcDbObjectId& idConnect)
{
	if (NULL == m_pXDataMap)
		return FALSE;
	
	AcDbObjectId id;
	int nIndex(-1);
	if(GetIFIndexFormPt(nIndex,ptConnect))
	{
		CString sID;
		sID.Format(_T("%s%d"),KEY_IDCNT_, nIndex);
		m_pXDataMap->SetAt(sID, AcDbObjectId::kNull);
		return TRUE;
	}
	
	return FALSE;
}

BOOL THImpHvacEGroup::GetIFPoint(int iIdx, AcGePoint3d &pt) const
{
	// 得到索引对应的接口的位置点
	TDbXDataMap xIFData;
	if (m_pXDataMap->GetAt(HAHG_InterfaceData, iIdx, xIFData))
	{
		xIFData.GetAt(HEQUIF_Point, pt);
		return TRUE;		
	}

	pt = AcGePoint3d::kOrigin;
	return FALSE;
}

BOOL THImpHvacEGroup::GetInterface(int nIndex,TInterface& pipeInterface) const
{
	if (NULL == m_pXDataMap)
		return FALSE;

	TDbXDataMap xIFData;
	if (m_pXDataMap->GetAt(HAHG_InterfaceData, nIndex, xIFData))
	{
		AcGePoint3d pt;
		AcGeVector3d vt;
		CString sName;
		double dw,dt;
		AcDbObjectId id;
//		TDbXDataMap xIFData;
		
		xIFData.GetAt(HEQUIF_Point, pt);
		xIFData.GetAt(HEQUIF_Vector, vt);
		xIFData.GetAt(HEQUIF_Name, sName);
		xIFData.GetAt(HEQUIF_Width, dw);
		xIFData.GetAt(HEQUIF_Height, dt);
		
		CString sID;
		sID.Format(_T("%s%d"), KEY_IDCNT_, nIndex);
		if (m_pXDataMap->GetAt(sID, id) && MakesureInterfaceValidate(id, pt, vt, pipeInterface))			
			return TRUE;
		
		pipeInterface.SetSize(dw,dt);
		pipeInterface.SetOutDir(vt);
		pipeInterface.SetOwnerId(m_pOwnerEnt->objectId());
		pipeInterface.SetPosition(pt);
		pipeInterface.SetDescr(sName);		
	}

	return TRUE;
}

BOOL THImpHvacEGroup::GetIFIndexFormPt(int &nIndex, const AcGePoint3d &pt) const
{
	int iIFNum = GetInterfaceCount();
	for (int i = 0; i < iIFNum; i++)
	{
		TDbXDataMap xIFData;
		if (m_pXDataMap->GetAt(HAHG_InterfaceData, i, xIFData))
		{
			AcGePoint3d ptPos;
			xIFData.GetAt(HEQUIF_Point, ptPos);
			if (pt.isEqualTo(ptPos, g_globalTol))
			{
				nIndex = i;
				return TRUE;
			}
		}
	}

	return FALSE;	
}

BOOL THImpHvacEGroup::GetInterface(const AcGePoint3d& ptCon,TInterface& pipeInterface) const
{
	if (NULL == m_pXDataMap)
		return FALSE;
	
	int nIndex(-1);
	if(GetIFIndexFormPt(nIndex,ptCon))
		return GetInterface(nIndex,pipeInterface);
	
	return FALSE;
}

BOOL THImpHvacEGroup::GetInterFaceLocal(int nIndex, AcGeVector3d &vt) const
{
	if (NULL == m_pXDataMap)
		return FALSE;

	TDbXDataMap xdatamap;
	if(m_pXDataMap->GetAt(HAHG_InterfaceData, nIndex, xdatamap))
		return xdatamap.GetAt(HEQUIF_Vector, vt);

	return FALSE;
}

BOOL THImpHvacEGroup::HasInterface(const AcGePoint3d& ptCon,const AcGeVector3d& vtDir)
{
	if (NULL == m_pXDataMap)
		return FALSE;

	// 获取各点位置
 	int nIndex(-1);
 	AcGeVector3d vtIf;
 	if(GetIFIndexFormPt(nIndex,ptCon))
 	{
 		GetInterFaceLocal(nIndex,vtIf);
 		return (vtDir.isParallelTo(vtIf));
 	}

	return FALSE;
}

int	 THImpHvacEGroup::GetInterfaceCount() const
{
	if (NULL == m_pXDataMap)
		return 0;
	
	int iIfNum(0);
	m_pXDataMap->GetAt(HAHG_InterfaceNum, iIfNum);
// 	int iSegNum(0);
// 	m_pXDataMap->GetAt(HAHG_SegmentsNum, iSegNum);
// 	
// 	for (int i = 0; i < iSegNum; i++)
// 	{
// 		TDbXDataMap xSegMap;
// 		if (m_pXDataMap->GetAt(HAHG_SegmentData, i, xSegMap))
// 		{
// 			int iTmp(0);
// 			xSegMap.GetAt(HEQU_InterfaceNum, iTmp);
// 			iIfNum += iTmp;
// 		}
// 	}
	
	return iIfNum;
}

void THImpHvacEGroup::GetKindName(CString& sName)
{
	sName = _T("ATS_DBHEQUIPMENT");
}

Acad::ErrorStatus THImpHvacEGroup::getOsnapPoints(AcDb::OsnapMode osnapMode,
													 INT_PTR gsSelectionMark,
													 const AcGePoint3d& pickPoint,
													 const AcGePoint3d& lastPoint,
													 const AcGeMatrix3d& viewXform,
													 AcGePoint3dArray& snapPoints,
													 AcDbIntArray& geomIds) const
{
	if (NULL == m_pXDataMap)
		return Acad::eNotApplicable;

	AcGePoint3d ptCenter;
	m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
	AcGePoint3dArray arpts;
	
	// 根据捕捉模式处理
	switch(osnapMode)
	{
	case AcDb::kOsModeEnd:
		GetConerOsnapPt(arpts);
		snapPoints.append(arpts);
		break;
	case AcDb::kOsModeMid:
		snapPoints.append(ptCenter);
		break;
	case AcDb::kOsModeCen:
		break;
	case AcDb::kOsModePerp:
		break;
	case AcDb::kOsModeNear:
		break;
	}
	// add by hh 2011-07-12 支持任意位置捕捉
	TImpSpecEquipment::getOsnapPoints(osnapMode, gsSelectionMark, pickPoint, lastPoint,
		viewXform, snapPoints, geomIds);

	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacEGroup::getGripPoints(AcGePoint3dArray& gripPoints,
													AcDbIntArray& osnapModes,
													AcDbIntArray& geomIds) const
{
	ASSERT(NULL != m_pXDataMap && NULL != m_pHvacEquipment);
	
	int iNum = 0;
	m_pXDataMap->GetAt(HAHG_SegmentsNum, iNum);
	BOOL bHasPlanform = FALSE;
	m_pXDataMap->GetAt(HAHG_Planform, bHasPlanform);
	AcGeVector3d vtRot;
	m_pXDataMap->GetAt(HAHG_RotDir, vtRot);
	AcGePoint3d ptBase;
	m_pXDataMap->GetAt(HAHG_BasePoint, ptBase);
	
	// 机组移动夹点
	gripPoints.append(ptBase);

	GetOtherCtrlGrip(gripPoints);
	
// 	BOOL bHasText = FALSE;
// 	m_pXDataMap->GetAt(HAHG_HasText, bHasText);
// 	if (bHasText)
// 	{
// 		AcGePoint3d ptTextBase;
// 		m_pXDataMap->GetAt(HAHG_TextPoint, ptTextBase);
// 
// 		// 模板文字移动夹点
// 		gripPoints.append(ptTextBase);
// 	}	
	
	if (!bHasPlanform)
		return Acad::eOk;

	// 接口夹点
	int iIFCount = GetInterfaceCount();
	for (int i = 0; i < iIFCount; i++)
	{
		TDbXDataMap xIfData;
		if (m_pXDataMap->GetAt(HAHG_InterfaceData, i, xIfData))
		{
			AcGePoint3d ptPos;
			xIfData.GetAt(HEQUIF_Point, ptPos);
			gripPoints.append(ptPos);			
		}
	}

	return Acad::eOk;	
}

Acad::ErrorStatus THImpHvacEGroup::getClassID(CLSID* pClsid) const
{
// #if (ADS < 16)
// 	// {C7DFDF6A-A5F2-4add-ADCC-7AC0675AB6E8}
// 	CLSID CLSID_PipeBaseEntity = {0xC7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xE8 }};
// #endif
// 	
// #if (ADS == 16)
// 	// {C7DFDF6A-A5F2-4add-ADCC-7AC0675AB6E9}
// 	CLSID CLSID_PipeBaseEntity = {0xC7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xE9 }};
// #endif
// 	
// #if (ADS == 17)
// 	// {C7DFDF6A-A5F2-4add-ADCC-7AC0675AB6EA}
// 	CLSID CLSID_PipeBaseEntity = {0xC7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xEA }};
// #endif
// 
// #if (ADS == 18)
// 	CLSID CLSID_PipeBaseEntity = {0xD7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xEB }};
// #endif
// 	
// #if (ADS == 19)
// 	CLSID CLSID_PipeBaseEntity = {0xD7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xEB }};
// #endif

	return Acad::eOk;
}

int THImpHvacEGroup::GetXBaseShell(TXShell& xShell)
{
	int nRet = 0;
	if (NULL == m_pXDataMap)
	{
		return 0;
	}

	int iSegNum = 0;
	m_pXDataMap->GetAt(HAHG_SegmentsNum, iSegNum);
	if (iSegNum <= 0)
	{
		return 0;
	}
	int iInflexion = 0;
	m_pXDataMap->GetAt(HAHG_Inflexion, iInflexion);
	if (iInflexion > -1 && iSegNum - 1 > iInflexion)
	{
		// 构造下部碰撞体
		AcGeVector3d vtNormal;
		m_pXDataMap->GetAt(HVAC_Normal, vtNormal);
		vtNormal.normalize();
		AcGeVector3d vtMain;
		m_pXDataMap->GetAt(HAHG_MainDir, vtMain);
		vtMain.normalize();
		AcGeVector3d vtSide = vtMain;
		vtSide.rotateBy(PI / 2.0, vtNormal);
		vtSide.normalize();
		TDbXDataMap mapSeg;
		double dTmpLen = 0.0, dTmpWid = 0.0, dTmpThi = 0.0;
		double dLength = 0.0, dWidth = 0.0, dThick = 0.0;
		for (int i = 0; i <= iInflexion; ++i)
		{
			m_pXDataMap->GetAt(HAHG_SegmentData, i, mapSeg);
			mapSeg.GetAt(HEQU_Length, dTmpLen);
			dLength += dTmpLen;
			mapSeg.GetAt(HEQU_Width, dTmpWid);
			if (dTmpWid > dWidth)
			{
				dWidth = dTmpWid;
			}
			mapSeg.GetAt(HEQU_Thick, dTmpThi);
			if (dTmpThi > dThick)
			{
				dThick = dTmpThi;
			}
		}
		dLength *= 1000.0;
		dWidth *= 1000.0;
		dThick *= 1000.0;
		m_pXDataMap->GetAt(HAHG_SegmentData, 0, mapSeg);
		AcGePoint3d ptStart;
		mapSeg.GetAt(HEQU_CenterPoint, ptStart);
		double dThick0 = 0.0;
		mapSeg.GetAt(HEQU_Thick, dThick0);
		dThick0 *= 1000.0;
		ptStart += vtNormal * dThick / 2.0 -vtNormal * dThick0 / 2.0;
		double dLength0 = 0.0;
		mapSeg.GetAt(HEQU_Length, dLength0);
		dLength0 *= 1000.0;
		ptStart -= vtMain * dLength0 / 2.0;
		AcGePoint3d ptEnd = ptStart + vtMain * dLength;
		TAuxTools::BuildRectDuct(ptStart, ptEnd, vtNormal, dWidth, dThick, dWidth, dThick, xShell);

		// 构造上部碰撞体
		dLength = 0.0;
		dWidth = 0.0;
		dThick = 0.0;
		for (int j = iInflexion + 1; j < iSegNum; ++j)
		{
			m_pXDataMap->GetAt(HAHG_SegmentData, j, mapSeg);
			mapSeg.GetAt(HEQU_Length, dTmpLen);
			dLength += dTmpLen;
			mapSeg.GetAt(HEQU_Width, dTmpWid);
			if (dTmpWid > dWidth)
			{
				dWidth = dTmpWid;
			}
			mapSeg.GetAt(HEQU_Thick, dTmpThi);
			if (dTmpThi > dThick)
			{
				dThick = dTmpThi;
			}
		}
		dLength *= 1000.0;
		dWidth *= 1000.0;
		dThick *= 1000.0;
		m_pXDataMap->GetAt(HAHG_SegmentData, iInflexion + 1, mapSeg);
		mapSeg.GetAt(HEQU_CenterPoint, ptStart);
		mapSeg.GetAt(HEQU_Thick, dThick0);
		dThick0 *= 1000.0;
		ptStart += vtNormal * dThick / 2.0 -vtNormal * dThick0 / 2.0;
		mapSeg.GetAt(HEQU_Length, dLength0);
		dLength0 *= 1000.0;
		ptStart += vtMain * dLength0 / 2.0;
		ptEnd = ptStart - vtMain * dLength;
		TAuxTools::BuildRectDuct(ptStart, ptEnd, vtNormal, dWidth, dThick, dWidth, dThick, xShell);

		nRet = 1;
	}
	else
	{
		// 计算参数
		AcGeVector3d vtNormal;
		m_pXDataMap->GetAt(HVAC_Normal, vtNormal);
		vtNormal.normalize();
		AcGeVector3d vtMain;
		m_pXDataMap->GetAt(HAHG_MainDir, vtMain);
		vtMain.normalize();
		AcGeVector3d vtSide = vtMain;
		vtSide.rotateBy(PI / 2.0, vtNormal);
		vtSide.normalize();
		TDbXDataMap mapSeg;
		double dTmpLen = 0.0, dTmpWid = 0.0, dTmpThi = 0.0;
		double dLength = 0.0, dWidth = 0.0, dThick = 0.0;
		for (int i = 0; i < iSegNum; ++i)
		{
			m_pXDataMap->GetAt(HAHG_SegmentData, i, mapSeg);
			mapSeg.GetAt(HEQU_Length, dTmpLen);
			dLength += dTmpLen;
			mapSeg.GetAt(HEQU_Width, dTmpWid);
			if (dTmpWid > dWidth)
			{
				dWidth = dTmpWid;
			}
			mapSeg.GetAt(HEQU_Thick, dTmpThi);
			if (dTmpThi > dThick)
			{
				dThick = dTmpThi;
			}
		}
		dLength *= 1000.0;
		dWidth *= 1000.0;
		dThick *= 1000.0;
		m_pXDataMap->GetAt(HAHG_SegmentData, 0, mapSeg);
		AcGePoint3d ptStart;
		mapSeg.GetAt(HEQU_CenterPoint, ptStart);
		double dThick0 = 0.0;
		mapSeg.GetAt(HEQU_Thick, dThick0);
		dThick0 *= 1000.0;
		ptStart += vtNormal * dThick / 2.0 -vtNormal * dThick0 / 2.0;
		double dLength0 = 0.0;
		mapSeg.GetAt(HEQU_Length, dLength0);
		dLength0 *= 1000.0;
		ptStart -= vtMain * dLength0 / 2.0;
		AcGePoint3d ptEnd = ptStart + vtMain * dLength;

		// 构造碰撞实体
		TAuxTools::BuildRectDuct(ptStart, ptEnd, vtNormal, dWidth, dThick, dWidth, dThick, xShell);

		nRet = 1;
	}

	return nRet;
}


BOOL THImpHvacEGroup::NotifyInterfaceToModify( const TInterfaceModifyMsg& iModiMsg,
											  TInterfaceModifyMsgs& iModiMsgs )
{
	if (NULL == m_pXDataMap)
		return FALSE;
	
	// 获得消息传递设置, 确定是否传递消息
	CString sDispatch = _T("0");
	GetGlobalContext(KEY_DISPATCHMSG, sDispatch);
	BOOL bDispatch = (_ttoi(sDispatch) != 0);
	
	BOOL bMsgTranslate = FALSE;
	// 获得消息类型, 根据消息类型处理
	TDb::InterfaceOper eOper = iModiMsg.GetInterfaceOper();
	switch (eOper)
	{
	case TDb::eMoveGripPoint:
		// 夹点移动消息处理
		bMsgTranslate =	OnMoveGripPointMsgNotify(iModiMsg, iModiMsgs);
		break;
	default:
		return bMsgTranslate;
	}
	
	// 记录修改标识
	if (m_pOwnerEnt != NULL)
		m_pOwnerEnt->recordGraphicsModified();
	
	return bMsgTranslate;	
}

BOOL THImpHvacEGroup::OnMoveGripPointMsgNotify( const TInterfaceModifyMsg& iModiMsg, 
											   TInterfaceModifyMsgs& iModiMsgs )
{
	if (!TAuxTools::IsAutoWorkOffset())
		return FALSE;
	
	ASSERT(NULL != m_pXDataMap);
	
	AcDbObjectId id = iModiMsg.GetMsgOperateOn();
	AcDbObjectId idOwner = m_pOwnerEnt->objectId();
	if (id != idOwner) // 消息发送目标正确
		return FALSE;
	
	AcGeVector3d vtOffset = iModiMsg.GetMoveGripOffset();
	if (vtOffset.isZeroLength()) 
		return FALSE;

	BOOL bMsgTranslate = FALSE;
	
	int nPos = iModiMsg.GetGripPosition();
	if (nPos == eStart || nPos == eMid || nPos == eEnd || nPos == eBr1 || nPos == eBr2)
	{				
		// 设备接口消息传递
		TInterface tIf;
		AcDbObjectId idT(AcDbObjectId::kNull);
		AcGePoint3d ptIf;
		AcGeVector3d vtIf;
		int i(0);
		for (i = 0; i < GetInterfaceCount(); i++)
		{
			tIf.Reset();
			if (!GetInterface(i, tIf))
				continue;
			
			ptIf = tIf.GetPosition();
			vtIf = tIf.GetOutDir();
			if (FindConnect(ptIf, vtIf, idOwner, idT)) 
			{
				if (vtOffset.isParallelTo(vtIf) || vtOffset.isPerpendicularTo(vtIf))
				{
					TInterfaceModifyMsg msg;
					msg.SetMsgPoint(ptIf);
					msg.SetMoveGripOffset(vtOffset);
					msg.SetMsgOperateOn(idT);
					msg.SetGripPosition(eStart);
					iModiMsgs.append(msg);
					bMsgTranslate = TRUE;
				}
			}
		}

		AcGeMatrix3d xform;
		xform.setTranslation(vtOffset);
		
		int iNum = 0;
		m_pXDataMap->GetAt(HAHG_SegmentsNum, iNum);
		
		// 箱体部分
		for (i = 0; i < iNum; i++)
		{
			TDbXDataMap xSegMap;
			if (m_pXDataMap->GetAt(HAHG_SegmentData, i, xSegMap))
			{
				AcGePoint3d ptCenter;
				xSegMap.GetAt(HEQU_CenterPoint, ptCenter);
				
				ptCenter.transformBy(xform);
				xSegMap.SetAt(HEQU_CenterPoint, ptCenter);
				m_pXDataMap->SetAt(HAHG_SegmentData, i, xSegMap);
			}		
		}
		
		// 接口数据
		AcGePoint3d ptBase = AcGePoint3d::kOrigin;
		int iIFCount = GetInterfaceCount();
		for (i = 0; i < iIFCount; i++)
		{
			TDbXDataMap xIFData;
			if (m_pXDataMap->GetAt(HAHG_InterfaceData, i, xIFData))
			{
				xIFData.GetAt(HEQUIF_Point, ptBase);
				ptBase.transformBy(xform);
				xIFData.SetAt(HEQUIF_Point, ptBase);
				
				m_pXDataMap->SetAt(HAHG_InterfaceData, i, xIFData);
			}
		}
		
		// 基点	
		m_pXDataMap->GetAt(HAHG_BasePoint, ptBase);
		ptBase.transformBy(xform);
		m_pXDataMap->SetAt(HAHG_BasePoint, ptBase);
		
		// 文字基点
		m_pXDataMap->GetAt(HAHG_TextPoint, ptBase);
		ptBase.transformBy(xform);
		m_pXDataMap->SetAt(HAHG_TextPoint, ptBase);
		
		
		// 更新模型空间的扩展字典的注册的接口数据
		UpdateInterfaceRec(m_pOwnerEnt->objectId(), xform);
	}
				
	return bMsgTranslate;	
}

int THImpHvacEGroup::GetBodyBox( AcDbExtents& ext ) const
{
	if (NULL == m_pXDataMap)
	{
		return 0;
	}

	// 获得参数
	int iSegNum = 0;
	m_pXDataMap->GetAt(HAHG_SegmentsNum, iSegNum);
	if (iSegNum <= 0)
	{
		return 0;
	}
	int iInflexion = 0;
	m_pXDataMap->GetAt(HAHG_Inflexion, iInflexion);
	if (iInflexion > -1 && iSegNum - 1 > iInflexion)
	{
		// 计算参数
		AcGeVector3d vtNormal;
		m_pXDataMap->GetAt(HVAC_Normal, vtNormal);
		vtNormal.normalize();
		AcGeVector3d vtMain;
		m_pXDataMap->GetAt(HAHG_MainDir, vtMain);
		vtMain.normalize();
		AcGeVector3d vtSide = vtMain;
		vtSide.rotateBy(PI / 2.0, vtNormal);
		vtSide.normalize();
		TDbXDataMap mapSeg;
		double dTmpLen = 0.0, dTmpWid = 0.0, dTmpThi = 0.0;
		double dLowLength = 0.0, dWidth = 0.0, dLowThick = 0.0;
		for (int i = 0; i <= iInflexion; ++i)
		{
			m_pXDataMap->GetAt(HAHG_SegmentData, i, mapSeg);
			mapSeg.GetAt(HEQU_Length, dTmpLen);
			dLowLength += dTmpLen;
			mapSeg.GetAt(HEQU_Width, dTmpWid);
			if (dTmpWid > dWidth)
			{
				dWidth = dTmpWid;
			}
			mapSeg.GetAt(HEQU_Thick, dTmpThi);
			if (dTmpThi > dLowThick)
			{
				dLowThick = dTmpThi;
			}
		}
		double dHiLength = 0.0, dHiThick = 0.0;
		for (int j = iInflexion + 1; j < iSegNum; ++j)
		{
			m_pXDataMap->GetAt(HAHG_SegmentData, j, mapSeg);
			mapSeg.GetAt(HEQU_Length, dTmpLen);
			dHiLength += dTmpLen;
			mapSeg.GetAt(HEQU_Width, dTmpWid);
			if (dTmpWid > dWidth)
			{
				dWidth = dTmpWid;
			}
			mapSeg.GetAt(HEQU_Thick, dTmpThi);
			if (dTmpThi > dHiThick)
			{
				dHiThick = dTmpThi;
			}
		}
		double dLength = max(dLowLength, dHiLength);
		m_pXDataMap->GetAt(HAHG_SegmentData, iInflexion, mapSeg);
		double dInflexionThick = 0.0;
		mapSeg.GetAt(HEQU_Thick, dInflexionThick);
		double dThick = max(dLowThick, dHiThick + dInflexionThick);
		dLength *= 1000.0;
		dWidth *= 1000.0;
		dThick *= 1000.0;
		m_pXDataMap->GetAt(HAHG_SegmentData, 0, mapSeg);
		AcGePoint3d ptStart;
		mapSeg.GetAt(HEQU_CenterPoint, ptStart);
		double dThick0 = 0.0;
		mapSeg.GetAt(HEQU_Thick, dThick0);
		dThick0 *= 1000.0;
		ptStart += vtNormal * dThick / 2.0 -vtNormal * dThick0 / 2.0;
		double dLength0 = 0.0;
		mapSeg.GetAt(HEQU_Length, dLength0);
		dLength0 *= 1000.0;
		ptStart -= vtMain * dLength0 / 2.0;
		AcGePoint3d ptEnd = ptStart + vtMain * dLength;
		double dHalfWidth = dWidth / 2.0;
		double dHalfThick = dThick / 2.0;

		// 计算端点
		AcGePoint3dArray arpt;
		arpt.append(ptStart + vtSide * dHalfWidth + vtNormal * dHalfThick);
		arpt.append(ptStart + vtSide * dHalfWidth - vtNormal * dHalfThick);
		arpt.append(ptStart - vtSide * dHalfWidth - vtNormal * dHalfThick);
		arpt.append(ptStart - vtSide * dHalfWidth + vtNormal * dHalfThick);
		arpt.append(ptEnd + vtSide * dHalfWidth + vtNormal * dHalfThick);
		arpt.append(ptEnd + vtSide * dHalfWidth - vtNormal * dHalfThick);
		arpt.append(ptEnd - vtSide * dHalfWidth - vtNormal * dHalfThick);
		arpt.append(ptEnd - vtSide * dHalfWidth + vtNormal * dHalfThick);
		
		// 构造最小包含体
		TAuxTools::BuildMinRectangle(arpt, ext);
	}
	else
	{
		// 计算参数
		AcGeVector3d vtNormal;
		m_pXDataMap->GetAt(HVAC_Normal, vtNormal);
		vtNormal.normalize();
		AcGeVector3d vtMain;
		m_pXDataMap->GetAt(HAHG_MainDir, vtMain);
		vtMain.normalize();
		AcGeVector3d vtSide = vtMain;
		vtSide.rotateBy(PI / 2.0, vtNormal);
		vtSide.normalize();
		TDbXDataMap mapSeg;
		double dTmpLen = 0.0, dTmpWid = 0.0, dTmpThi = 0.0;
		double dLength = 0.0, dWidth = 0.0, dThick = 0.0;
		for (int i = 0; i < iSegNum; ++i)
		{
			m_pXDataMap->GetAt(HAHG_SegmentData, i, mapSeg);
			mapSeg.GetAt(HEQU_Length, dTmpLen);
			dLength += dTmpLen;
			mapSeg.GetAt(HEQU_Width, dTmpWid);
			if (dTmpWid > dWidth)
			{
				dWidth = dTmpWid;
			}
			mapSeg.GetAt(HEQU_Thick, dTmpThi);
			if (dTmpThi > dThick)
			{
				dThick = dTmpThi;
			}
		}
		dLength *= 1000.0;
		dWidth *= 1000.0;
		dThick *= 1000.0;
		m_pXDataMap->GetAt(HAHG_SegmentData, 0, mapSeg);
		AcGePoint3d ptStart;
		mapSeg.GetAt(HEQU_CenterPoint, ptStart);
		double dThick0 = 0.0;
		mapSeg.GetAt(HEQU_Thick, dThick0);
		dThick0 *= 1000.0;
		ptStart += vtNormal * dThick / 2.0 -vtNormal * dThick0 / 2.0;
		double dLength0 = 0.0;
		mapSeg.GetAt(HEQU_Length, dLength0);
		dLength0 *= 1000.0;
		ptStart -= vtMain * dLength0 / 2.0;
		AcGePoint3d ptEnd = ptStart + vtMain * dLength;
		double dHalfWidth = dWidth / 2.0;
		double dHalfThick = dThick / 2.0;
		
		// 计算端点
		AcGePoint3dArray arpt;
		arpt.append(ptStart + vtSide * dHalfWidth + vtNormal * dHalfThick);
		arpt.append(ptStart + vtSide * dHalfWidth - vtNormal * dHalfThick);
		arpt.append(ptStart - vtSide * dHalfWidth - vtNormal * dHalfThick);
		arpt.append(ptStart - vtSide * dHalfWidth + vtNormal * dHalfThick);
		arpt.append(ptEnd + vtSide * dHalfWidth + vtNormal * dHalfThick);
		arpt.append(ptEnd + vtSide * dHalfWidth - vtNormal * dHalfThick);
		arpt.append(ptEnd - vtSide * dHalfWidth - vtNormal * dHalfThick);
		arpt.append(ptEnd - vtSide * dHalfWidth + vtNormal * dHalfThick);
		
		// 构造最小包含体
		TAuxTools::BuildMinRectangle(arpt, ext);
	}

	return 1;
}

// void THImpHvacEGroup::SetSubText( long i,CString sText )
// {
// 	int nNum = 0;
// 	m_pXDataMap->GetAt(HAHG_SegmentsNum, nNum);
// 	if (i < 0 || i > nNum)
// 		return;
// 
// 	BOOL bHasText = FALSE;
// 	m_pXDataMap->GetAt(HAHG_HasText, bHasText);
// 	if (bHasText)
// 	{
// 		CString csTempText;
// 		m_pXDataMap->GetAt(HAHG_Text, csTempText);
// 		if (csTempText.IsEmpty())
// 		{
// 			bHasText = FALSE;
// 		}
// 	}
// 
// 	BOOL bEditTemp(FALSE);
// 	if (i == nNum - 1 && bHasText)	// 编辑模版文字
// 	{
// 		m_pXDataMap->SetAt(HAHG_Text, sText);
// 	}
// 	else
// 	{
// 		TDbXDataMap xSegMap;
// 		if (m_pXDataMap->GetAt(HAHG_SegmentData, i, xSegMap))
// 		{
// 			xSegMap.SetAt(HEQU_SEquipType, sText);
// 			m_pXDataMap->SetAt(HAHG_SegmentData, i, xSegMap)
// 		}
// 	}
// }

void THImpHvacEGroup::GetOtherCtrlGrip(AcGePoint3dArray &arrPt ) const
{
	if (NULL == m_pXDataMap)
		return;

	AcGeVector3d vtMainDir;
	BOOL bIsRightDir(FALSE);
	m_pXDataMap->GetAt(HAHG_MainDir, vtMainDir);
	m_pXDataMap->GetAt(HAHG_IsRight, bIsRightDir);
	if (!bIsRightDir)
		vtMainDir *= -1;

	AcGePoint3d ptBase, ptRightDw;
	m_pXDataMap->GetAt(HAHG_BasePoint, ptBase);
	double dLen = GetTotalLen() * 1000;

	ptRightDw = ptBase + vtMainDir * dLen;

	arrPt.append(ptRightDw);
}

// 导出XML
// CString THImpHvacEGroup::GetXml() const
// {
// 	if (NULL == m_pXDataMap || NULL == m_pOwnerEnt)
// 		return _T("");
// 
// 	int nValue(0);
// 	double dValue(0.0);
// 	int nPtPreci = 6; // 位置精度
// 	int nWhPreci = 0; // 宽度、高度精度
// 	int nSegNum = 0; // 箱体段个数
// 
// 	TXmlTree xmlTree;
// 	CString csText;
// 	CString csX, csY, csZ;
// 	AcGePoint3d pt;
// 	AcGeVector3d vt;
// 	AcDbObjectId id;
// 	POSITION posRoot = xmlTree.Insert(_T("ATS_DBHEQUIPMENT"), NULL, NULL);
// 	{
// 		xmlTree.SetAttribute(posRoot, _T("name"), _T("空气机组"));
// 		xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称"));
// 	}
// 
// 	POSITION posItemEquipType = xmlTree.Insert(_T("EquipType"), posRoot, NULL);
// 	{ 
// 		xmlTree.SetAttribute(posItemEquipType, _T("name"), _T("设备类型"));
// 		xmlTree.SetAttribute(posItemEquipType, _T("comment"), _T("设备类型"));
// 		csText = _T("空气机组");
// 		xmlTree.SetItemText(posItemEquipType, csText);
// 	}
// 
// 	POSITION posItemSegNum = xmlTree.Insert(_T("SegmentsNum"), posRoot, posItemEquipType);
// 	{ 
// 		xmlTree.SetAttribute(posItemSegNum, _T("name"), _T("箱体段个数"));
// 		xmlTree.SetAttribute(posItemSegNum, _T("comment"), _T("箱体段个数"));
// 		m_pXDataMap->GetAt(HAHG_SegmentsNum, nValue);
// 		nSegNum = nValue; // 保存箱体段个数
// 		csText.Format(_T("%d"), nValue);
// 		xmlTree.SetItemText(posItemSegNum, csText);
// 	}
// 
// 	POSITION posItemInflex = xmlTree.Insert(_T("Inflexion"), posRoot, posItemSegNum);
// 	{ 
// 		xmlTree.SetAttribute(posItemInflex, _T("name"), _T("拐点索引"));
// 		xmlTree.SetAttribute(posItemInflex, _T("comment"), _T("立式机组拐弯处的箱体段索引"));
// 		m_pXDataMap->GetAt(HAHG_Inflexion, nValue);
// 		csText.Format(_T("%d"), nValue);
// 		xmlTree.SetItemText(posItemInflex, csText);
// 	}
// 
// 	POSITION posItemPlanForm = xmlTree.Insert(_T("IsPlanForm"), posRoot, posItemInflex);
// 	{ 
// 		xmlTree.SetAttribute(posItemPlanForm, _T("name"), _T("是否绘制俯视图"));
// 		xmlTree.SetAttribute(posItemPlanForm, _T("comment"), _T("俯视图有对应三维0:没有,1:有"));
// 		m_pXDataMap->GetAt(HAHG_Planform, nValue);
// 		csText.Format(_T("%d"), nValue);
// 		xmlTree.SetItemText(posItemPlanForm, csText);
// 	}
// 
// 	POSITION posItemBsPt = xmlTree.Insert(_T("BasePoint"), posRoot, posItemPlanForm);
// 	{ 
// 		xmlTree.SetAttribute(posItemBsPt, _T("name"), _T("侧视图基点"));
// 		xmlTree.SetAttribute(posItemBsPt, _T("comment"), _T("侧视图基点"));
// 		m_pXDataMap->GetAt(HAHG_BasePoint, pt);
// 		TAuxTools::DoubleToString(pt.x, nPtPreci, csX);
// 		TAuxTools::DoubleToString(pt.y, nPtPreci, csY);
// 		TAuxTools::DoubleToString(pt.z, nPtPreci, csZ);
// 		csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
// 		xmlTree.SetItemText(posItemBsPt, csText);
// 	}
// 
// 	POSITION posItemHorz = xmlTree.Insert(_T("IsHorizontal"), posRoot, posItemBsPt);
// 	{ 
// 		xmlTree.SetAttribute(posItemHorz, _T("name"), _T("是否卧式摆放"));
// 		xmlTree.SetAttribute(posItemHorz, _T("comment"), _T("组合方式0:否,1:是"));
// 		m_pXDataMap->GetAt(HAHG_IsHorizontal, nValue);
// 		csText.Format(_T("%d"), nValue);
// 		xmlTree.SetItemText(posItemHorz, csText);
// 	}
// 
// 	POSITION posItemPrvMode = xmlTree.Insert(_T("IsPreviewMode"), posRoot, posItemHorz);
// 	{ 
// 		xmlTree.SetAttribute(posItemPrvMode, _T("name"), _T("是否预览模式"));
// 		xmlTree.SetAttribute(posItemPrvMode, _T("comment"), _T("预览模式按二维绘制图块0:否,1:是"));
// 		m_pXDataMap->GetAt(HAHG_IsPreviewing, nValue);
// 		csText.Format(_T("%d"), nValue);
// 		xmlTree.SetItemText(posItemPrvMode, csText);
// 	}
// 
// 	POSITION posItemNorDir = xmlTree.Insert(_T("NormalDir"),posRoot, posItemPrvMode);
// 	{
// 		xmlTree.SetAttribute(posItemNorDir, _T("name"), _T("法向量"));
// 		m_pXDataMap->GetAt(HVAC_Normal, vt);
// 		TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
// 		TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
// 		TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
// 		csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
// 		xmlTree.SetItemText(posItemNorDir, csText);
// 	}
// 
// 	POSITION posItemMainDir = xmlTree.Insert(_T("MainDir"), posRoot, posItemNorDir);
// 	{ 
// 		xmlTree.SetAttribute(posItemMainDir, _T("name"), _T("主方向"));
// 		xmlTree.SetAttribute(posItemMainDir, _T("comment"), _T("设备默认的方向"));
// 		m_pXDataMap->GetAt(HAHG_MainDir, vt);
// 		TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
// 		TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
// 		TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
// 		csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
// 		xmlTree.SetItemText(posItemMainDir, csText);
// 	}
// 
// 	POSITION posItemRotDir = xmlTree.Insert(_T("RotDir"), posRoot, posItemPrvMode);
// 	{ 
// 		xmlTree.SetAttribute(posItemRotDir, _T("name"), _T("旋转轴方向"));
// 		xmlTree.SetAttribute(posItemRotDir, _T("comment"), _T("旋转角度"));
// 		m_pXDataMap->GetAt(HAHG_RotDir, vt);
// 		TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
// 		TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
// 		TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
// 		csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
// 		xmlTree.SetItemText(posItemRotDir, csText);
// 	}
// 
// 	POSITION posNext = posItemRotDir;
// 	for(int i = 0; i < nSegNum; i++)
// 	{
// 		TDbXDataMap mapSegment;
// 		m_pXDataMap->GetAt(HAHG_SegmentData, i, mapSegment);
// 
// 		POSITION posSubItemSegName = xmlTree.Insert(_T("SegmentName"), posRoot, posNext);
// 		{ 
// 			xmlTree.SetAttribute(posSubItemSegName, _T("name"), _T("箱体名称"));
// 			xmlTree.SetAttribute(posSubItemSegName, _T("comment"), _T("对应图库中的箱体段名称"));
// 			mapSegment.GetAt(HEQU_SEquipType, csText);
// 			xmlTree.SetItemText(posSubItemSegName, csText);
// 		}
// 
// 		POSITION posSubItemNorDir = xmlTree.Insert(_T("NormalDir"),posRoot, posSubItemSegName);
// 		{
// 			xmlTree.SetAttribute(posSubItemNorDir, _T("name"), _T("法向量"));
// 			mapSegment.GetAt(HVAC_Normal, vt);
// 			TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
// 			TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
// 			TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
// 			csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
// 			xmlTree.SetItemText(posSubItemNorDir, csText);
// 		}
// 
// 		POSITION posSubItemCentPt = xmlTree.Insert(_T("CenterPoint"), posRoot, posSubItemNorDir);
// 		{ 
// 			xmlTree.SetAttribute(posSubItemCentPt, _T("name"), _T("中心点"));
// 			xmlTree.SetAttribute(posSubItemCentPt, _T("comment"), _T("布置点"));
// 			mapSegment.GetAt(HEQU_CenterPoint, pt);
// 			TAuxTools::DoubleToString(pt.x, nPtPreci, csX);
// 			TAuxTools::DoubleToString(pt.y, nPtPreci, csY);
// 			TAuxTools::DoubleToString(pt.z, nPtPreci, csZ);
// 			csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
// 			xmlTree.SetItemText(posSubItemCentPt, csText);
// 		}
// 
// 		POSITION posSubItemMainDir = xmlTree.Insert(_T("MainDir"), posRoot, posSubItemCentPt);
// 		{ 
// 			xmlTree.SetAttribute(posSubItemMainDir, _T("name"), _T("主矢量"));
// 			xmlTree.SetAttribute(posSubItemMainDir, _T("comment"), _T("布置角度"));
// 			mapSegment.GetAt(HEQU_MainDir, pt);
// 			TAuxTools::DoubleToString(pt.x, nPtPreci, csX);
// 			TAuxTools::DoubleToString(pt.y, nPtPreci, csY);
// 			TAuxTools::DoubleToString(pt.z, nPtPreci, csZ);
// 			csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
// 			xmlTree.SetItemText(posSubItemMainDir, csText);
// 		}
// 
// 		CString sIDKey;
// 		sIDKey.Format(_T("%d"), i);
// 		POSITION posSubItemPart2D = xmlTree.Insert(_T("Part2D"), posRoot, posSubItemMainDir);
// 		{ 
// 			xmlTree.SetAttribute(posSubItemPart2D, _T("name"), _T("2D块ID"));
// 			xmlTree.SetAttribute(posSubItemPart2D, _T("comment"), _T("平面图块"));
// 			m_pXDataMap->GetAt(sIDKey, id);
// 			csText.Format(_T("%d"), id.asOldId());
// 			xmlTree.SetItemText(posSubItemPart2D, csText);
// 		}
// 
// 		POSITION posSubItemPart3D = xmlTree.Insert(_T("Part3D"), posRoot, posSubItemPart2D);
// 		{
// 			xmlTree.SetAttribute(posSubItemPart3D, _T("name"), _T("3D块ID"));
// 			xmlTree.SetAttribute(posSubItemPart3D, _T("comment"), _T("三维图块"));
// 			//m_pXDataMap->GetAt(sIDKey, id);
// 			//csText.Format(_T("%d"), id.asOldId());
// 			xmlTree.SetItemText(posSubItemPart3D, csText);
// 		}
// 
// 		POSITION posSubItemMirror = xmlTree.Insert(_T("IsMirror"), posRoot, posSubItemPart3D);
// 		{
// 			xmlTree.SetAttribute(posSubItemMirror, _T("name"), _T("是否镜像"));
// 			xmlTree.SetAttribute(posSubItemMirror, _T("comment"), _T("用于辅助绘制0:否,1:是"));
// 			mapSegment.GetAt(HEQU_IsConverse, nValue);
// 			csText.Format(_T("%d"), nValue);
// 			xmlTree.SetItemText(posSubItemMirror, csText);
// 		}
// 
// 		POSITION posSubItemLength = xmlTree.Insert(_T("Length"), posRoot, posSubItemMirror);
// 		{
// 			xmlTree.SetAttribute(posSubItemLength, _T("name"), _T("长度"));
// 			xmlTree.SetAttribute(posSubItemLength, _T("comment"), _T("设备长度"));
// 			mapSegment.GetAt(HEQU_Length, dValue);
// 			TAuxTools::DoubleToString(dValue * 1000, nWhPreci, csText);
// 			xmlTree.SetItemText(posSubItemLength, csText);
// 		}
// 
// 		POSITION posSubItemWidth = xmlTree.Insert(_T("Width"), posRoot, posSubItemLength);
// 		{
// 			xmlTree.SetAttribute(posSubItemWidth, _T("name"), _T("宽度"));
// 			xmlTree.SetAttribute(posSubItemWidth, _T("comment"), _T("设备宽度"));
// 			mapSegment.GetAt(HEQU_Width, dValue);
// 			TAuxTools::DoubleToString(dValue * 1000, nWhPreci, csText);
// 			xmlTree.SetItemText(posSubItemWidth, csText);
// 		}
// 
// 		POSITION posSubItemThick = xmlTree.Insert(_T("Thick"), posRoot, posSubItemWidth);
// 		{
// 			xmlTree.SetAttribute(posSubItemThick, _T("name"), _T("厚度"));
// 			xmlTree.SetAttribute(posSubItemThick, _T("comment"), _T("设备高度"));
// 			mapSegment.GetAt(HEQU_Thick, dValue);
// 			TAuxTools::DoubleToString(dValue * 1000, nWhPreci, csText);
// 			xmlTree.SetItemText(posSubItemThick, csText);
// 		}
// 
// 		POSITION posSubItemScale = xmlTree.Insert(_T("Scale"), posRoot, posSubItemThick);
// 		{ 
// 			xmlTree.SetAttribute(posSubItemScale, _T("name"), _T("图块比例"));
// 			xmlTree.SetAttribute(posSubItemScale, _T("comment"), _T("图块比例"));
// 			mapSegment.GetAt(HEQU_Scale, vt);
// 			TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
// 			TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
// 			TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
// 			csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
// 			xmlTree.SetItemText(posSubItemScale, csText);
// 		}
// 		posNext = posSubItemScale;
// 	}
// 
// 	CString csXml = xmlTree.GetXml();
// 
// 	return csXml;
// }

CString THImpHvacEGroup::GetXml(const AcGeMatrix3d& mat) const
{
	if (NULL == m_pXDataMap || NULL == m_pOwnerEnt)
		return _T("");

	int i(0);
	int nValue(0);
	double dValue(0.0);
	int nPtPreci = 6; // 位置精度
	int nWhPreci = 0; // 宽度、高度精度
	int nSegNum = 0; // 箱体段个数

	TXmlTree xmlTree;
	CString csText;
	CString csX, csY, csZ;
	AcGePoint3d pt;
	AcGeVector3d vt;
	AcDbObjectId id;

	// deleted by wc 13-12-30 运行下方代码会崩溃
	//***************** begin *************** 
	// 获得设备转换矩阵Lixl add 2012-2-1
	// 插入点
	//XPoint ptLocation;
	//m_pXDataMap->GetAt(HEQUIF_Point, pt);
	//ptLocation = pt;
	//// 主方向
	//XVector3D vtDirection(0,0,1);
	//m_pXDataMap->GetAt(HAHG_MainDir, vt);
	//vtDirection = vt;
	//// 图块比例
	//m_pXDataMap->GetAt(HEQU_Scale, vt);
	//AcGeScale3d scale3d(vt.x, vt.y, vt.z);
	//XVector3D vtNormal(0,0,1);
	////非水平面，计算法向
	//if(fabs(vtDirection.z) > 1.0E-6)
	//{ 
	//	vtNormal = XVector3D(1,0,0)*vtDirection;
	//	vtNormal.Normalize();
	//}
	////计算ECS下的转角
	//XPoint ptLoc=Wcs2Ecs(ptLocation, vtNormal);
	//double nRotEcs = ads_angle(XPoint(),vtDirection);
	//m_pXDataMap->GetAt(HALT_Part3D, id);
	//AcDbBlockReference block(ptLoc, id);
	//block.setRotation(nRotEcs);
	//block.setScaleFactors(scale3d);
	//AcGeMatrix3d mat1 = block.blockTransform();
	//mat1 *= mat;
	//CString sMat;
	//TAuxTools::Matrix3D2String(mat1, sMat);
	//************* end *********************

	POSITION posRoot = xmlTree.Insert(_T("ATS_DBHEQUIPMENT"), NULL, NULL);
	{
		xmlTree.SetAttribute(posRoot, _T("name"), _T("空气机组"));
		xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称"));
	}

	POSITION posItemEquipType = xmlTree.Insert(_T("EquipType"), posRoot, NULL);
	{ 
		xmlTree.SetAttribute(posItemEquipType, _T("name"), _T("设备类型"));
		xmlTree.SetAttribute(posItemEquipType, _T("comment"), _T("设备类型"));
		csText = _T("空气机组");
		xmlTree.SetItemText(posItemEquipType, csText);
	}

	POSITION posItemSegNum = xmlTree.Insert(_T("SegmentsNum"), posRoot, posItemEquipType);
	{ 
		xmlTree.SetAttribute(posItemSegNum, _T("name"), _T("箱体段个数"));
		xmlTree.SetAttribute(posItemSegNum, _T("comment"), _T("箱体段个数"));
		m_pXDataMap->GetAt(HAHG_SegmentsNum, nValue);
		nSegNum = nValue; // 保存箱体段个数
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemSegNum, csText);
	}

	POSITION posItemInflex = xmlTree.Insert(_T("Inflexion"), posRoot, posItemSegNum);
	{ 
		xmlTree.SetAttribute(posItemInflex, _T("name"), _T("拐点索引"));
		xmlTree.SetAttribute(posItemInflex, _T("comment"), _T("立式机组拐弯处的箱体段索引"));
		m_pXDataMap->GetAt(HAHG_Inflexion, nValue);
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemInflex, csText);
	}

	POSITION posItemPlanForm = xmlTree.Insert(_T("IsPlanForm"), posRoot, posItemInflex);
	{ 
		xmlTree.SetAttribute(posItemPlanForm, _T("name"), _T("是否绘制俯视图"));
		xmlTree.SetAttribute(posItemPlanForm, _T("comment"), _T("俯视图有对应三维0:没有,1:有"));
		m_pXDataMap->GetAt(HAHG_Planform, nValue);
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemPlanForm, csText);
	}

	POSITION posItemBsPt = xmlTree.Insert(_T("BasePoint"), posRoot, posItemPlanForm);
	{ 
		xmlTree.SetAttribute(posItemBsPt, _T("name"), _T("侧视图基点"));
		xmlTree.SetAttribute(posItemBsPt, _T("comment"), _T("侧视图基点"));
		m_pXDataMap->GetAt(HAHG_BasePoint, pt);
		TAuxTools::DoubleToString(pt.x, nPtPreci, csX);
		TAuxTools::DoubleToString(pt.y, nPtPreci, csY);
		TAuxTools::DoubleToString(pt.z, nPtPreci, csZ);
		csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
		xmlTree.SetItemText(posItemBsPt, csText);
	}

	POSITION posItemHorz = xmlTree.Insert(_T("IsHorizontal"), posRoot, posItemBsPt);
	{ 
		xmlTree.SetAttribute(posItemHorz, _T("name"), _T("是否卧式摆放"));
		xmlTree.SetAttribute(posItemHorz, _T("comment"), _T("组合方式0:否,1:是"));
		m_pXDataMap->GetAt(HAHG_IsHorizontal, nValue);
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemHorz, csText);
	}

	POSITION posItemPrvMode = xmlTree.Insert(_T("IsPreviewMode"), posRoot, posItemHorz);
	{ 
		xmlTree.SetAttribute(posItemPrvMode, _T("name"), _T("是否预览模式"));
		xmlTree.SetAttribute(posItemPrvMode, _T("comment"), _T("预览模式按二维绘制图块0:否,1:是"));
		m_pXDataMap->GetAt(HAHG_IsPreviewing, nValue);
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemPrvMode, csText);
	}

	POSITION posItemNorDir = xmlTree.Insert(_T("NormalDir"),posRoot, posItemPrvMode);
	{
		xmlTree.SetAttribute(posItemNorDir, _T("name"), _T("法向量"));
		m_pXDataMap->GetAt(HVAC_Normal, vt);
		TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
		TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
		TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
		csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
		xmlTree.SetItemText(posItemNorDir, csText);
	}

	POSITION posItemMainDir = xmlTree.Insert(_T("MainDir"), posRoot, posItemNorDir);
	{ 
		xmlTree.SetAttribute(posItemMainDir, _T("name"), _T("主方向"));
		xmlTree.SetAttribute(posItemMainDir, _T("comment"), _T("设备默认的方向"));
		m_pXDataMap->GetAt(HAHG_MainDir, vt);
		TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
		TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
		TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
		csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
		xmlTree.SetItemText(posItemMainDir, csText);
	}

	POSITION posItemRotDir = xmlTree.Insert(_T("RotDir"), posRoot, posItemPrvMode);
	{ 
		xmlTree.SetAttribute(posItemRotDir, _T("name"), _T("旋转轴方向"));
		xmlTree.SetAttribute(posItemRotDir, _T("comment"), _T("旋转角度"));
		m_pXDataMap->GetAt(HAHG_RotDir, vt);
		TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
		TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
		TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
		csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
		xmlTree.SetItemText(posItemRotDir, csText);
	}

	POSITION posNext = posItemRotDir;
	for(i = 0; i < nSegNum; i++)
	{
		TDbXDataMap mapSegment;
		m_pXDataMap->GetAt(HAHG_SegmentData, i, mapSegment);

		// add by wc 13-12-27 
		// 将各箱体段设为posSubItemSegments的子节点
		POSITION posSubItemSegments = xmlTree.Insert(_T("Segments"), posRoot, posNext);
		{ 
			xmlTree.SetAttribute(posSubItemSegments, _T("name"), _T("箱体段"));
			xmlTree.SetAttribute(posSubItemSegments, _T("comment"), _T("箱体段各参数"));
		}

		POSITION posSubItemSegName = xmlTree.Insert(_T("SegmentName"), posSubItemSegments, NULL);
		{ 
			xmlTree.SetAttribute(posSubItemSegName, _T("name"), _T("箱体名称"));
			xmlTree.SetAttribute(posSubItemSegName, _T("comment"), _T("对应图库中的箱体段名称"));
			mapSegment.GetAt(HEQU_SEquipType, csText);
			xmlTree.SetItemText(posSubItemSegName, csText);
		}

		POSITION posSubItemNorDir = xmlTree.Insert(_T("NormalDir"),posSubItemSegments, posSubItemSegName);
		{
			xmlTree.SetAttribute(posSubItemNorDir, _T("name"), _T("法向量"));
			mapSegment.GetAt(HVAC_Normal, vt);
			TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
			TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
			TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
			csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
			xmlTree.SetItemText(posSubItemNorDir, csText);
		}

		POSITION posSubItemCentPt = xmlTree.Insert(_T("CenterPoint"), posSubItemSegments, posSubItemNorDir);
		{ 
			xmlTree.SetAttribute(posSubItemCentPt, _T("name"), _T("中心点"));
			xmlTree.SetAttribute(posSubItemCentPt, _T("comment"), _T("布置点"));
			mapSegment.GetAt(HEQU_CenterPoint, pt);
			TAuxTools::DoubleToString(pt.x, nPtPreci, csX);
			TAuxTools::DoubleToString(pt.y, nPtPreci, csY);
			TAuxTools::DoubleToString(pt.z, nPtPreci, csZ);
			csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
			xmlTree.SetItemText(posSubItemCentPt, csText);
		}

		// mod by wc 13-12-30 将pt改为vt
		POSITION posSubItemMainDir = xmlTree.Insert(_T("MainDir"), posSubItemSegments, posSubItemCentPt);
		{ 
			xmlTree.SetAttribute(posSubItemMainDir, _T("name"), _T("主矢量"));
			xmlTree.SetAttribute(posSubItemMainDir, _T("comment"), _T("布置角度"));
			mapSegment.GetAt(HEQU_MainDir, vt);
			TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
			TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
			TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
			csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
			xmlTree.SetItemText(posSubItemMainDir, csText);
		}

		CString sIDKey;
		sIDKey.Format(_T("%d"), i);
		// begin mod by wc 13-12-27	将保存图块id改为保存图块名称。因为IsMirror另有参数，将IsMirror改为IsConverse
		POSITION posSubItemBlk = xmlTree.Insert(_T("Block"), posSubItemSegments, posSubItemMainDir);
		{ 
			xmlTree.SetAttribute(posSubItemBlk, _T("name"), _T("图块块名称"));
			xmlTree.SetAttribute(posSubItemBlk, _T("comment"), _T("平面图块"));
			if (!m_pXDataMap->GetAt(sIDKey, id))
				csText.Empty();
			else
				csText = TAuxTools::GetBlkNameById(id);
			xmlTree.SetItemText(posSubItemBlk, csText);
 		}

		// deleted by wc 13-12-30 和上面的一样，显得多余
// 		POSITION posSubItemPart3D = xmlTree.Insert(_T("Part3D"), posSubItemSegments, posSubItemPart2D);
// 		{
// 			xmlTree.SetAttribute(posSubItemPart3D, _T("name"), _T("3D块名称"));
// 			xmlTree.SetAttribute(posSubItemPart3D, _T("comment"), _T("三维图块"));
// 			//m_pXDataMap->GetAt(sIDKey, id);
// 			//csText.Format(_T("%d"), id.asOldId());
// 			if (!m_pXDataMap->GetAt(sIDKey, id))
// 				csText.Empty();
// 			else
// 				csText = TAuxTools::GetBlkNameById(id);
// 			xmlTree.SetItemText(posSubItemPart3D, csText);
// 		}

		POSITION posSubItemConverse = xmlTree.Insert(_T("IsConverse"), posSubItemSegments, posSubItemBlk);
		{
			xmlTree.SetAttribute(posSubItemConverse, _T("name"), _T("是否镜像"));
			xmlTree.SetAttribute(posSubItemConverse, _T("comment"), _T("用于辅助绘制0:否,1:是"));
			mapSegment.GetAt(HEQU_IsConverse, nValue);
			csText.Format(_T("%d"), nValue);
			xmlTree.SetItemText(posSubItemConverse, csText);
		}
		// end

		POSITION posSubItemLength = xmlTree.Insert(_T("Length"), posSubItemSegments, posSubItemConverse);
		{
			xmlTree.SetAttribute(posSubItemLength, _T("name"), _T("长度"));
			xmlTree.SetAttribute(posSubItemLength, _T("comment"), _T("设备长度"));
			mapSegment.GetAt(HEQU_Length, dValue);
			TAuxTools::DoubleToString(dValue * 1000, nWhPreci, csText);
			xmlTree.SetItemText(posSubItemLength, csText);
		}

		POSITION posSubItemWidth = xmlTree.Insert(_T("Width"), posSubItemSegments, posSubItemLength);
		{
			xmlTree.SetAttribute(posSubItemWidth, _T("name"), _T("宽度"));
			xmlTree.SetAttribute(posSubItemWidth, _T("comment"), _T("设备宽度"));
			mapSegment.GetAt(HEQU_Width, dValue);
			TAuxTools::DoubleToString(dValue * 1000, nWhPreci, csText);
			xmlTree.SetItemText(posSubItemWidth, csText);
		}

		POSITION posSubItemThick = xmlTree.Insert(_T("Thick"), posSubItemSegments, posSubItemWidth);
		{
			xmlTree.SetAttribute(posSubItemThick, _T("name"), _T("厚度"));
			xmlTree.SetAttribute(posSubItemThick, _T("comment"), _T("设备高度"));
			mapSegment.GetAt(HEQU_Thick, dValue);
			TAuxTools::DoubleToString(dValue * 1000, nWhPreci, csText);
			xmlTree.SetItemText(posSubItemThick, csText);
		}

		POSITION posSubItemScale = xmlTree.Insert(_T("Scale"), posSubItemSegments, posSubItemThick);
		{ 
			xmlTree.SetAttribute(posSubItemScale, _T("name"), _T("图块比例"));
			xmlTree.SetAttribute(posSubItemScale, _T("comment"), _T("图块比例"));
			mapSegment.GetAt(HEQU_Scale, vt);
			TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
			TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
			TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
			csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
			xmlTree.SetItemText(posSubItemScale, csText);
		}
// 		POSITION posItemMat= xmlTree.Insert(_T("Matrix3d"), posRoot, posSubItemScale);
// 		{
// 			xmlTree.SetAttribute(posItemMat, _T("name"), _T("矩阵"));
// 			xmlTree.SetAttribute(posItemMat, _T("comment"), _T("图块转换矩阵"));
// 			xmlTree.SetItemText(posItemMat, sMat);
		// 		}
		// 将各箱体段设为posSubItemSegments的子节点
		posNext = posSubItemSegments;
	}

	// *************** begin *******************
	// add by wc 13-12-30
	// 添加接口信息
	int iInterface = 0;
	m_pXDataMap->GetAt(HAHG_InterfaceNum, iInterface);
	for (i = 0; i < iInterface; i++)
	{
		TDbXDataMap mapInterface;
		POSITION posSubItemInterface = xmlTree.Insert(_T("Segments"), posRoot, posNext);
		{ 
			xmlTree.SetAttribute(posSubItemInterface, _T("name"), _T("接口"));
			xmlTree.SetAttribute(posSubItemInterface, _T("comment"), _T("接口各参数"));
		}

		POSITION posSubItemIFNumber = xmlTree.Insert(_T("IFNumber"), posSubItemInterface, NULL);
		{ 
			xmlTree.SetAttribute(posSubItemIFNumber, _T("name"), _T("序号"));
			xmlTree.SetAttribute(posSubItemIFNumber, _T("comment"), _T("接口序号"));
			mapInterface.GetAt(HEQUIF_Number, nValue);
			csText.Format(_T("%d"), nValue);
			xmlTree.SetItemText(posSubItemIFNumber, csText);
		}

		POSITION posSubItemIFName = xmlTree.Insert(_T("IFName"), posSubItemInterface, posSubItemIFNumber);
		{ 
			xmlTree.SetAttribute(posSubItemIFName, _T("name"), _T("名称"));
			xmlTree.SetAttribute(posSubItemIFName, _T("comment"), _T("接口名称"));
			mapInterface.GetAt(HEQUIF_Name, csText);
			xmlTree.SetItemText(posSubItemIFName, csText);
		}

		POSITION posSubItemIFType = xmlTree.Insert(_T("IFType"), posSubItemInterface, posSubItemIFName);
		{ 
			xmlTree.SetAttribute(posSubItemIFType, _T("name"), _T("类型"));
			xmlTree.SetAttribute(posSubItemIFType, _T("comment"), _T("接口类型"));
			mapInterface.GetAt(HEQUIF_Type, nValue);
			csText.Format(_T("%d"), nValue);
			xmlTree.SetItemText(posSubItemIFType, csText);
		}

		POSITION posSubItemIFPoint = xmlTree.Insert(_T("IFPoint"), posSubItemInterface, posSubItemIFName);
		{ 
			xmlTree.SetAttribute(posSubItemIFPoint, _T("name"), _T("位置"));
			xmlTree.SetAttribute(posSubItemIFPoint, _T("comment"), _T("接口位置"));
			mapInterface.GetAt(HEQUIF_Vector, pt);
			TAuxTools::DoubleToString(pt.x, nPtPreci, csX);
			TAuxTools::DoubleToString(pt.y, nPtPreci, csY);
			TAuxTools::DoubleToString(pt.z, nPtPreci, csZ);
			csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
			xmlTree.SetItemText(posSubItemIFPoint, csText);
		}

		POSITION posSubItemIFVector = xmlTree.Insert(_T("Scale"), posSubItemInterface, posSubItemIFPoint);
		{ 
			xmlTree.SetAttribute(posSubItemIFVector, _T("name"), _T("方向"));
			xmlTree.SetAttribute(posSubItemIFVector, _T("comment"), _T("接口方向"));
			mapInterface.GetAt(HEQUIF_Vector, vt);
			TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
			TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
			TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
			csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
			xmlTree.SetItemText(posSubItemIFVector, csText);
		}

		POSITION posSubItemIFWidth = xmlTree.Insert(_T("Width"), posSubItemInterface, posSubItemIFVector);
		{
			xmlTree.SetAttribute(posSubItemIFWidth, _T("name"), _T("宽度"));
			xmlTree.SetAttribute(posSubItemIFWidth, _T("comment"), _T("设备宽度"));
			mapInterface.GetAt(HEQU_Width, dValue);
			TAuxTools::DoubleToString(dValue * 1000, nWhPreci, csText);
			xmlTree.SetItemText(posSubItemIFWidth, csText);
		}

		POSITION posSubItemThick = xmlTree.Insert(_T("Thick"), posSubItemInterface, posSubItemIFWidth);
		{
			xmlTree.SetAttribute(posSubItemThick, _T("name"), _T("厚度"));
			xmlTree.SetAttribute(posSubItemThick, _T("comment"), _T("设备高度"));
			mapInterface.GetAt(HEQU_Thick, dValue);
			TAuxTools::DoubleToString(dValue * 1000, nWhPreci, csText);
			xmlTree.SetItemText(posSubItemThick, csText);
		}
	}


	// *************** end *********************

	CString csXml = xmlTree.GetXml();

	return csXml;
}

void THImpHvacEGroup::GetConerOsnapPt( AcGePoint3dArray &arrPt ) const
{
	AcDbExtents ext;
	GetBodyBox(ext);

	AcGePoint3d ptLeftUp, ptLeftDw, ptRightUp, ptRightDw;
	ptLeftDw = ext.minPoint();
	ptRightUp = ext.maxPoint();
	AcGeVector3d vtUcsY = TAuxTools::GetUcsYvt();
	AcGeVector3d vtUcsZ = TAuxTools::GetUcsZvt();
	AcGeVector3d vtSub = (ptRightUp - ptLeftDw).orthoProject(vtUcsZ);
	AcGeVector3d vtXSub = vtSub.orthoProject(vtUcsY);

	ptRightDw = ptLeftDw + vtXSub;
	ptLeftUp = ptRightUp - vtXSub;
	arrPt.append(ptLeftDw);
	arrPt.append(ptRightDw);

	BOOL bHasPlanform = FALSE;
	m_pXDataMap->GetAt(HAHG_Planform, bHasPlanform);
	if (bHasPlanform)	// 立面图时，GetBodyBox（）有待完善，上面两个点不准
	{
		arrPt.append(ptRightUp);
		arrPt.append(ptLeftUp);
	}
}