#include "stdafx.h"
#include "StdArx.h"
#include "THImpHvacAirlets.h"

#include "TDbInterfaceRecord.h"
#include "TDbXDataMap.h"
#include "TDbInterfaceMsgWrite.h"
#include "math.h"
#include "dbxutil.h"

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


using namespace TDb;

THImpHvacAirlets::THImpHvacAirlets()
{
}

THImpHvacAirlets::~THImpHvacAirlets()
{
}

BOOL THImpHvacAirlets::GetInterfaceSizeData(int nIndex, TInterface& pipeInterface) const
{
	ASSERT(NULL != m_pXDataMap);
	
	// 获取截面类型
	TDb::HvacSectType eSectType = TDb::eRectangular;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
	
	// 获取尺寸
	double dWidth = 0.0, dThick = 0.0;
	m_pXDataMap->GetAt(HALT_Width, dWidth);
	m_pXDataMap->GetAt(HALT_Length, dThick);
	dWidth = fabs(dWidth);
	
	// 设置接口数据
	pipeInterface.SetType(eSectType);
	pipeInterface.SetSize(dWidth, dThick);
	
	return TRUE;
}

BOOL THImpHvacAirlets::GetInterface(int nIndex,TInterface& pipeInterface) const
{
	if (NULL == m_pXDataMap)
		return FALSE;
	
	// 获取各点位置
	AcGePoint3d ptIf = GetIfPoint();
	AcGeVector3d vtNor;
	m_pXDataMap->GetAt(HVAC_Normal, vtNor);

	AcDbObjectId id;
	switch(nIndex)
	{
	case 0:
		// 如果起始接口和第一个管件连接
		if (m_pXDataMap->GetAt(KEY_IDCNT1, id) && MakesureInterfaceValidate(id, ptIf, vtNor, pipeInterface))
		{
			GetInterfaceSizeData(0, pipeInterface);
			return TRUE;
		}
		// 没有管件连接
		pipeInterface.SetOutDir(vtNor);
		pipeInterface.SetOwnerId(m_pOwnerEnt->objectId());
		pipeInterface.SetPosition(ptIf);
		GetInterfaceSizeData(0, pipeInterface);
		return TRUE;
	}
	return FALSE;
}

BOOL THImpHvacAirlets::GetInterface(const AcGePoint3d& ptCon,TInterface& pipeInterface) const
{
	if (NULL == m_pXDataMap)
		return FALSE;
	
	// 获取各点位置
	AcGePoint3d ptIf = GetIfPoint();
	AcGeVector3d vtNor;
	m_pXDataMap->GetAt(HVAC_Normal, vtNor);
		
	// 计算测试点到始末点的距离
	double dDist1 = ptCon.distanceTo(ptIf);
	AcDbObjectId id;
	
	// 位于起始点
	if (dDist1 < 1.e-3)
	{
		// 如果起始接口和第一个管件连接
		if (m_pXDataMap->GetAt(KEY_IDCNT1, id) && MakesureInterfaceValidate(id, ptIf, vtNor, pipeInterface))
		{
			GetInterfaceSizeData(0, pipeInterface);
			return TRUE;
		}
		// 没有管件连接
		pipeInterface.SetOutDir(vtNor);
		pipeInterface.SetOwnerId(m_pOwnerEnt->objectId());
		pipeInterface.SetPosition(ptIf);
		GetInterfaceSizeData(0, pipeInterface);
		return TRUE;
	}
	return FALSE;
}

BOOL THImpHvacAirlets::HasInterface(const AcGePoint3d& ptCon,const AcGeVector3d& vtDir)
{
	if (NULL == m_pXDataMap)
		return FALSE;
	
	// 获取各点位置
	AcGePoint3d ptStart = GetIfPoint();
	AcGeVector3d vtNor;
	m_pXDataMap->GetAt(HVAC_Normal, vtNor);
	
	// 计算测试点到始末点的距离
	double dDist1 = ptCon.distanceTo(ptStart);
	
	// 位于起始点
	if (dDist1 < 1.e-3)
		return (vtDir.isParallelTo(vtNor));

	return FALSE;
}

int	 THImpHvacAirlets::GetInterfaceCount() const
{
	return 1;
}

BOOL THImpHvacAirlets::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;
	}
	
	// 获取各点位置
	AcGePoint3d ptStart = GetIfPoint();
	AcGeVector3d vtNor;
	m_pXDataMap->GetAt(HVAC_Normal, vtNor);
	
	// 计算测试点到始末点的距离
	double dDist1 = ptConnect.distanceTo(ptStart);
	
	// 基类指针
	TDbInterfacesObj* pInterfaceObj = TDbInterfacesObj::cast(pEnt);
	ASSERT(NULL != pInterfaceObj);
	
	// 位于起始点
	if (dDist1 < 1.e-3 && pInterfaceObj->HasInterface(ptStart, vtNor))
	{
		m_pXDataMap->SetAt(KEY_IDCNT1, idConnect);
		pEnt->close();
		return TRUE;
	}
	pEnt->close();
	return FALSE;
}

BOOL THImpHvacAirlets::RemoveInterfaceRelation(const AcGePoint3d& ptConnect,const AcDbObjectId& idConnect)
{
	if (NULL == m_pXDataMap)
		return FALSE;
	
	// 浅层次删除; 命名字典中的关系,需要外面移除关系,只移除内部关系
	AcDbObjectId id;
	m_pXDataMap->GetAt(KEY_IDCNT1, id);
	if (id == idConnect)
	{
		m_pXDataMap->SetAt(KEY_IDCNT1, AcDbObjectId::kNull);
		return TRUE;
	}
	return FALSE;
}

BOOL THImpHvacAirlets::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 THImpHvacAirlets::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)
	{		
		AcGePoint3d ptCenter;
		m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
		ptCenter += vtOffset;	
		m_pXDataMap->SetAt(HALT_CenterPoint, ptCenter);
				
		// 更新模型空间的扩展字典的注册的接口数据
		AcGeMatrix3d xform;
		xform.setToTranslation(vtOffset);
		UpdateInterfaceRec(m_pOwnerEnt->objectId(), xform);
	}
				
	return bMsgTranslate;		
}

BOOL THImpHvacAirlets::MakeCurves(TComplexCurve& cplCurve) const
{
	return TRUE;
}

BOOL THImpHvacAirlets::GetCurvesInSide(TComplexCurve& compCurve) const
{
	return FALSE;
}

AcDbPolyline* THImpHvacAirlets::MakePolyCurve() const
{
	//                 
	//                                      1
	//  1 ┃━━━━━┃ 3	            /-------\
	//    ┃	      ┃               /	     \
	//    ┃    0     ┃            3 |    0      | 4
	//    ┃	      ┃	           \         /
	//  2 ┃━━━━━┃ 4	            \_______/
	//                                      2
	//
	// 获取各点位置
	AcGePoint3d pt1, pt2, pt3, pt4, ptCenter;
	AcGePoint3d ptU1, ptU2, ptU3, ptU4;
	AcGeVector3d vtMain, vtNor, vtMainv;
	double dLength(50.0), dThick(50.0), dWidth(50.0);
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
	int nIsSide(0);
	TDb::HvacSectType eSectType = TDb::eRectangular;
	m_pXDataMap->GetAt(HVAC_SectType,(int&)eSectType);
	m_pXDataMap->GetAt(HVAC_Normal, vtNor);
	m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
	m_pXDataMap->GetAt(HEQU_Length, dLength);		
	m_pXDataMap->GetAt(HEQU_Width, dWidth);		
	m_pXDataMap->GetAt(HALT_IsSide, nIsSide);		
	m_pXDataMap->GetAt(HALT_Thick, dThick);	

	if (dLength < 1)
		dLength = 1.0;
	if (dWidth < 1)
		dWidth = 1.0;
	if (dThick < 1)
		dThick = 1.0;

	AcDbPolyline* pPolyLine = NULL;
	//方口
	if (eSectType == TDb::eRectangular)
	{
		AcGePoint3dArray arpts;
		//侧风口标高在中心线上
		if (nIsSide == 1)
		{
			vtMainv = vtNor;
			vtMainv.rotateBy(PI * 0.5, vtMain);
			vtNor.normalize();
			vtMainv.normalize();
			pt1 = ptCenter + vtMainv * dWidth * 0.5;
			pt2 = ptCenter - vtMainv * dWidth * 0.5;
			pt3 = pt1 + vtNor * dThick;
			pt4 = pt2 + vtNor * dThick;

			ptU1 = pt1 + vtMain * dLength * 0.5;
			ptU2 = pt2 + vtMain * dLength * 0.5;
			ptU3 = pt3 + vtMain * dLength * 0.5;
			ptU4 = pt4 + vtMain * dLength * 0.5;
			pt1 = pt1 - vtMain * dLength * 0.5;
			pt2 = pt2 - vtMain * dLength * 0.5;
			pt3 = pt3 - vtMain * dLength * 0.5;
			pt4 = pt4 - vtMain * dLength * 0.5;
			if (vtMain.angleTo(pDb->ucsxdir()) < PI * 0.25 || vtMain.angleTo(-pDb->ucsxdir()) < PI * 0.25)
			{
				ptU2.z = pt2.z = ptU1.z = pt1.z = ptCenter.z;
				arpts.append(ptU2);
				arpts.append(pt2);
				arpts.append(pt1);
				arpts.append(ptU1);
			}
			else if (vtMain.angleTo(pDb->ucsydir()) < PI * 0.25 || vtMain.angleTo(-pDb->ucsydir()) < PI * 0.25)
			{
				ptU1.z = pt1.z = ptU3.z = pt3.z = ptCenter.z;
				arpts.append(ptU1);
				arpts.append(pt1);
				arpts.append(pt3);
				arpts.append(ptU3);
			}
			else
			{
				arpts.append(pt1);
				arpts.append(pt2);
				arpts.append(pt4);
				arpts.append(pt3);
			}
		}
		//散流器标高在底部
		else
		{
			vtMainv = vtMain;
			vtMainv.rotateBy(PI * 0.5, vtNor);
			vtMain.normalize();
			vtMainv.normalize();
			pt1 = ptCenter + vtMainv * dWidth * 0.5;
			pt2 = ptCenter - vtMainv * dWidth * 0.5;
			pt1 = pt1 - vtMain * dLength *0.5;
			pt3 = pt1 + vtMain * dLength;
			pt2 = pt2 - vtMain * dLength *0.5;
			pt4 = pt2 + vtMain * dLength;
			ptU1 = pt1 + vtNor * dThick;
			ptU2 = pt2 + vtNor * dThick;
			ptU3 = pt3 + vtNor * dThick;
			ptU4 = pt4 + vtNor * dThick;
			if (vtNor.angleTo(pDb->ucsxdir()) < PI * 0.25 || vtNor.angleTo(-pDb->ucsxdir()) < PI * 0.25)
			{
				ptU2.z = pt2.z = ptU1.z = pt1.z = ptCenter.z;
				arpts.append(ptU2);
				arpts.append(pt2);
				arpts.append(pt1);
				arpts.append(ptU1);
			}
			else if (vtNor.angleTo(pDb->ucsydir()) < PI * 0.25 || vtNor.angleTo(-pDb->ucsydir()) < PI * 0.25)
			{
				ptU1.z = pt1.z = ptU3.z = pt3.z = ptCenter.z;
				arpts.append(ptU1);
				arpts.append(pt1);
				arpts.append(pt3);
				arpts.append(ptU3);
			}
			else
			{
				arpts.append(pt1);
				arpts.append(pt2);
				arpts.append(pt4);
				arpts.append(pt3);
			}
		}			
		
		AcGePlane plan(arpts[0], arpts[1], arpts[2]);
		AcGePoint3d ptOrth = AcGePoint3d::kOrigin.orthoProject(plan);
		plan.set(ptOrth, vtZAxis);
		
		double dEl = ptOrth.asVector().length();
		if (!ptOrth.asVector().isCodirectionalTo(plan.normal()))
		{
			dEl *= -1.0;
		}
		pPolyLine = new AcDbPolyline;
		pPolyLine->addVertexAt(0,arpts[0].convert2d(plan));
		pPolyLine->addVertexAt(1,arpts[1].convert2d(plan));
		pPolyLine->addVertexAt(2,arpts[2].convert2d(plan));
		pPolyLine->addVertexAt(3,arpts[3].convert2d(plan));	
		pPolyLine->setClosed(Adesk::kTrue);
		pPolyLine->setElevation(dEl);
		pPolyLine->setNormal(plan.normal());
	}
	//圆口
	else
	{
		//侧风口
		if (nIsSide == 1)
		{
			pPolyLine = new AcDbPolyline;
			if(vtMain.angleTo(pDb->ucsxdir()) < PI*0.25 || vtMain.angleTo(-pDb->ucsxdir()) < PI*0.25)
			{				
				TAuxTools::GetEllipseFromCircle(ptCenter, dLength, vtNor, vtZAxis,*pPolyLine);				
			}
			else if(vtMain.angleTo(pDb->ucsydir()) < PI*0.25 || vtMain.angleTo(-pDb->ucsydir()) < PI*0.25)
			{
				vtMainv = vtMain;
				vtMainv.rotateBy(PI * 0.5, vtNor);
				vtMain.normalize();
				vtMainv.normalize();
				pt1 = ptCenter + vtMain * dLength * 0.5;
				pt2 = ptCenter - vtMain * dLength * 0.5;
				pt3 = pt1 + vtNor * dThick;
				pt4 = pt2 + vtNor * dThick;
				AcGePlane plan(pt1, pt2, pt3);
				AcGePoint3d ptOrth = AcGePoint3d::kOrigin.orthoProject(plan);
				plan.set(ptOrth, vtZAxis);
				
				double dEl = ptOrth.asVector().length();
				if (!ptOrth.asVector().isCodirectionalTo(plan.normal()))
				{
					dEl *= -1.0;
				}
				pPolyLine->addVertexAt(0, pt1.convert2d(plan));
				pPolyLine->addVertexAt(1, pt2.convert2d(plan));
				pPolyLine->addVertexAt(2, pt4.convert2d(plan));
				pPolyLine->addVertexAt(3, pt3.convert2d(plan));
				pPolyLine->setClosed(Adesk::kTrue);
				pPolyLine->setElevation(dEl);
				pPolyLine->setNormal(plan.normal());				
			}
			else
			{
				vtMainv = vtNor;
				vtMainv.rotateBy(PI * 0.5, vtMain);
				vtMain.normalize();
				vtMainv.normalize();
				pt1 = ptCenter + vtMainv * dLength * 0.5;
				pt2 = ptCenter - vtMainv * dLength * 0.5;
				pt3 = pt1 + vtNor * dThick;
				pt4 = pt2 + vtNor * dThick;
				AcGePlane plan(pt1, pt2, pt3);
				AcGePoint3d ptOrth = AcGePoint3d::kOrigin.orthoProject(plan);
				plan.set(ptOrth, vtZAxis);
				
				double dEl = ptOrth.asVector().length();
				if (!ptOrth.asVector().isCodirectionalTo(plan.normal()))
				{
					dEl *= -1.0;
				}
				pPolyLine->addVertexAt(0, pt1.convert2d(plan));
				pPolyLine->addVertexAt(1, pt2.convert2d(plan));
				pPolyLine->addVertexAt(2, pt4.convert2d(plan));
				pPolyLine->addVertexAt(3, pt3.convert2d(plan));
				pPolyLine->setClosed(Adesk::kTrue);
				pPolyLine->setElevation(dEl);
				pPolyLine->setNormal(plan.normal());
			}
		}
		else
		{
			vtMainv = vtMain;
			vtMainv.rotateBy(PI * 0.5, vtNor);
			vtMain.normalize();
			vtMainv.normalize();
			pt1 = ptCenter + vtMainv * dLength * 0.5;
			pt2 = ptCenter - vtMainv * dLength * 0.5;
			pt3 = ptCenter - vtMain * dLength * 0.5;
			pt4 = ptCenter + vtMain * dLength * 0.5;
			pt1.z = pt2.z = pt3.z = pt4.z = ptCenter.z;

			if (vtNor.angleTo(vtZAxis) < PI * 0.25 || vtNor.angleTo(-vtZAxis) < PI * 0.25)
			{
				AcGePlane plan(pt1, pt2, pt3);
				AcGePoint3d ptOrth = AcGePoint3d::kOrigin.orthoProject(plan);
				plan.set(ptOrth, vtZAxis);			
				double dEl = ptOrth.asVector().length();
				if (ptOrth.asVector().angleTo(plan.normal()) > PI*0.5)
					dEl *= -1.0;

				pPolyLine = new AcDbPolyline;
				pPolyLine->addVertexAt(0, pt1.convert2d(plan),1.0);
				pPolyLine->addVertexAt(1, pt2.convert2d(plan),1.0);
				pPolyLine->setClosed(Adesk::kTrue);
				pPolyLine->setElevation(dEl);
				pPolyLine->setNormal(plan.normal());
			}
			else if (vtNor.angleTo(pDb->ucsxdir()) < PI*0.25 || vtNor.angleTo(-pDb->ucsxdir()) < PI*0.25)
			{
				pt3 = pt1 + vtNor * dThick;
				pt4 = pt2 + vtNor * dThick;
				AcGePlane plan(pt1, pt2, pt3);
				AcGePoint3d ptOrth = AcGePoint3d::kOrigin.orthoProject(plan);
				plan.set(ptOrth, vtZAxis);
				double dEl = ptOrth.asVector().length();
				if (ptOrth.asVector().angleTo(plan.normal()) > PI*0.5)
					dEl *= -1.0;

				pPolyLine = new AcDbPolyline;
				pPolyLine->addVertexAt(0, pt1.convert2d(plan));
				pPolyLine->addVertexAt(1, pt2.convert2d(plan));
				pPolyLine->addVertexAt(2, pt4.convert2d(plan));
				pPolyLine->addVertexAt(3, pt3.convert2d(plan));
				pPolyLine->setClosed(Adesk::kTrue);
				pPolyLine->setElevation(dEl);
				pPolyLine->setNormal(plan.normal());
			}
			else if (vtNor.angleTo(pDb->ucsydir()) < PI * 0.25 || vtNor.angleTo(-pDb->ucsydir()) < PI * 0.25)
			{
				pt1 = pt3 + vtNor * dThick;
				pt2 = pt4 + vtNor * dThick;

				AcGePlane plan(pt1, pt2, pt3);
				AcGePoint3d ptOrth = AcGePoint3d::kOrigin.orthoProject(plan);
				plan.set(ptOrth, vtZAxis);
				double dEl = ptOrth.asVector().length();
				if (ptOrth.asVector().angleTo(plan.normal()) > PI*0.5)
					dEl *= -1.0;
				
				pPolyLine = new AcDbPolyline;
				pPolyLine->addVertexAt(0, pt1.convert2d(plan));
				pPolyLine->addVertexAt(1, pt2.convert2d(plan));
				pPolyLine->addVertexAt(2, pt4.convert2d(plan));
				pPolyLine->addVertexAt(3, pt3.convert2d(plan));
				pPolyLine->setClosed(Adesk::kTrue);
				pPolyLine->setElevation(dEl);
				pPolyLine->setNormal(plan.normal());
			}
		}
	}
	
	return pPolyLine;
}

BOOL THImpHvacAirlets::MakePolyCurveFaces(AcDbVoidPtrArray& arFaces)
{
	return FALSE;
}

void THImpHvacAirlets::GetKindName(CString& sName)
{
	sName = _T("TCH_HAIRLETS");
}

BOOL THImpHvacAirlets::GetGeomExtentsEdge(TComplexCurve& crLoop)
{
	return FALSE;
}

TDb::Position THImpHvacAirlets::ExplainGripIndex(int nIndex) const
{
	switch(nIndex)
	{
	case 0:
		{
			return TDb::eMid;
			break;
		}
	case 1:
		{
			return TDb::eCommand0;
			break;
		}
	default:
		break;
	}
	return TDb::eMid;
}

Acad::ErrorStatus THImpHvacAirlets::GetGripText(int i, CString &cs) const
{
	switch(i)
	{
	case 0:
		{
			cs = _T("移动");
			break;
		}
	case 1:
		{
			cs = _T("风管接口");		//启动绘制命令，2010-06-02，wyd
			break;
		}
	}
	return Acad::eOk;
}

void THImpHvacAirlets::GetTips(CMapStringToString& mapLable2Tip) const
{
}

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

	AcGePoint3d ptCenter;
	AcDbObjectId idCen,id3D;
	m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HALT_PartCenter, idCen);
	m_pXDataMap->GetAt(HALT_Part3D, id3D);
	InserBlockCen(mode, ptCenter, id3D);
	if (id3D == idCen)
	{
		Draw3dBox(mode);
	}
	return Acad::eOk;
}

AcGeVector3d THImpHvacAirlets::GetNormal() const
{
	ASSERT(NULL != m_pXDataMap);
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZ = pDb->ucsxdir().crossProduct(pDb->ucsydir());
	return vtZ.normalize();
}

AcGePoint3d THImpHvacAirlets::GetStartPt() const
{
	ASSERT(NULL != m_pXDataMap);
	// 获取各点位置
	AcGePoint3d ptCenter;
	AcGeVector3d vtMain;
	double dLength(50.0);
	m_pXDataMap->GetAt(HALT_MainDir, vtMain);
	m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HALT_Length, dLength);		
	vtMain.normalize();
	return ptCenter - vtMain * dLength * 0.5;
}

AcGePoint3d THImpHvacAirlets::GetEndPt() const
{
	ASSERT(NULL != m_pXDataMap);
	// 获取各点位置
	AcGePoint3d ptCenter;
	AcGeVector3d vtMain;
	double dLength(50.0);
	m_pXDataMap->GetAt(HALT_MainDir, vtMain);
	m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HALT_Length, dLength);		
	vtMain.normalize();
	return ptCenter + vtMain * dLength * 0.5;
}

AcGePoint3d THImpHvacAirlets::GetHandPt() const
{
	ASSERT(NULL != m_pXDataMap);
	// 获取各点位置
	AcGePoint3d ptCenter;
	AcGeVector3d vtMain;
	double dWidth(50.0);
	m_pXDataMap->GetAt(HALT_MainDir, vtMain);
	m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HALT_Width, dWidth);
	vtMain.rotateBy(PI * 0.5,GetNormal());
	vtMain.normalize();
	return ptCenter + vtMain * dWidth * 0.5;
}

Acad::ErrorStatus THImpHvacAirlets::ExplodeOrDraw2d(XExplodeDraw &mode) const
{
	if (m_pXDataMap == NULL)
	{
		return Acad::eNotImplementedYet;
	}
	
	AcGePoint3d ptCenter;
	AcDbObjectId idCen;
	m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HALT_PartCenter, idCen);
	InserBlockCen(mode, ptCenter, idCen);	
	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacAirlets::InserBlockCen(XExplodeDraw &mode, AcGePoint3d ptCenter, AcDbObjectId idBlock) const
{
	ASSERT(NULL != m_pXDataMap);
	AcGeVector3d vtMain, vtScale, vtNor;
	double dLength(1.0);
	double dWidth(1.0);
	double dThick(1.0);
	m_pXDataMap->GetAt(HVAC_Normal, vtNor);
	m_pXDataMap->GetAt(HALT_Length, dLength);
	m_pXDataMap->GetAt(HALT_Width, dWidth);
	m_pXDataMap->GetAt(HALT_Thick, dThick);
	m_pXDataMap->GetAt(HALT_MainDir, vtMain);
	m_pXDataMap->GetAt(HALT_Scale, vtScale);

	double dAngle(0.0);
	//侧风口
	if (vtNor.isPerpendicularTo(GetNormal()))
	{
		double dscale = vtScale.x;
		dLength *= dscale;
		dWidth *= vtScale.y;
		dThick *= vtScale.z;
		dAngle = AcGeVector3d::kXAxis.angleTo(vtNor,GetNormal());
	}
	else
	{
		dLength *= vtScale.x;
		dWidth *= vtScale.y;
		dThick *= vtScale.z;
		dAngle = AcGeVector3d::kXAxis.angleTo(vtMain,GetNormal());
	}

	AcGeScale3d scale(dLength, dWidth, 1);

	// change by hh 2011-05-31 兼容8.2版以前的风口
	// add by hh 2011-01-05 侧风口定义变更：
	//     与X轴平行的边为高，与Y轴平行的边为长，与Z轴平行的边为宽
	// if(vtNor.isPerpendicularTo(GetNormal()))
	//	scale.set(dThick, dLength, 1);
	// add end
	CString sVersion;
	if(!m_pXDataMap->GetAt(HVAC_EntVersion, sVersion))
	{
		// 8.2版风口转换为8.5版
		m_pXDataMap->SetAt(HVAC_EntVersion, THVAC_EQU_VERSION_CURRENT);
		sVersion = THVAC_EQU_VERSION_CURRENT;
		if(vtNor.isPerpendicularTo(GetNormal()))
		{
			double dThickRev = dLength / vtScale.z;
			m_pXDataMap->SetAt(HALT_Thick, dThickRev);
			dThick = dThickRev * vtScale.z;
		}
	}
	// 侧风口与X轴平行的边为高，与Y轴平行的边为宽，与Z轴平行的边为长
	if(vtNor.isPerpendicularTo(GetNormal()))
		scale.set(dThick, dWidth, 1);

	AcDbObject * pObj;
	XPoint xpoint = ptCenter;
	if (acdbOpenObject(pObj, idBlock, AcDb::kForRead)!=Acad::eOk) return Acad::eNotImplementedYet;
	AcDbBlockTableRecord * pBlock = AcDbBlockTableRecord::cast(pObj);
	if (pBlock == NULL)
	{
		pObj->close();
		return Acad::eNotImplementedYet;
	}
	mode.DrawBlock(*pBlock, xpoint, scale, dAngle, TRUE);
	pObj->close();

	return Acad::eOk;
}

//////////////////////////////////////////////////////////
//    
//    
//  1 ┏━━━━━┓ 2	
//    ┃	      ┃	
//    ┃          ┃
//    ┃	0     ┃	
//    ┃          ┃ 	
//  4 ┗━━━━━┛3
//              
//
BOOL THImpHvacAirlets::GetBoxPts(AcGePoint3dArray &arPts) const
{
	// 获取各点位置
	AcGePoint3d ptStart, ptEnd, ptCenter;
	AcGeVector3d vtMain, vtNor, vtMainv;
	double dLength(50.0), dThick(50.0), dWidth(50.0);
	m_pXDataMap->GetAt(HVAC_Normal, vtNor);
	m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HALT_MainDir, vtMain);
	m_pXDataMap->GetAt(HALT_Length, dLength);		
	m_pXDataMap->GetAt(HALT_Width, dWidth);		
	m_pXDataMap->GetAt(HALT_Thick,	dThick);
	vtMainv = vtMain;
	vtMainv.rotateBy(PI * 0.5, vtNor);
	vtMain.normalize();
	vtMainv.normalize();
	//0
	arPts.append(ptCenter);
	AcGePoint3d pt;
	pt = ptCenter - vtMain * dWidth * 0.5;
	pt = pt + vtMainv * dThick * 0.5;
	//1
	arPts.append(pt);
	//2
	arPts.append(arPts[1] + vtMain * dWidth);
	//3
	arPts.append(arPts[2] - vtMainv * dThick);
	//4
	arPts.append(arPts[1] - vtMainv * dThick);
	return TRUE;
}

void THImpHvacAirlets::list() const
{
	if (m_pXDataMap != NULL)
	{
		
		AcGePoint3d ptCenter;
		AcGeVector3d vtMain;
		CString sType,sName;
		double dLength(50.0), dThick(50.0), dWidth(50.0), dPlusEdge(50.0);
		double dairload(0);
		m_pXDataMap->GetAt(HALT_SEquipType, sType);
		m_pXDataMap->GetAt(HALT_SEquipName, sName);
		m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
		m_pXDataMap->GetAt(HALT_MainDir, vtMain);
		m_pXDataMap->GetAt(HALT_Length, dLength);		
		m_pXDataMap->GetAt(HALT_Width, dWidth);		
		m_pXDataMap->GetAt(HALT_Thick,	dThick);
		m_pXDataMap->GetAt(HVAC_AirLoad, dairload);		
		dWidth = fabs(dWidth);
		
		acutPrintf(_T("\n\t\t\t\t\t\t\t\t%s"),sType);
		acutPrintf(_T("\n\t\t\t\t\t型号: %s"),sName);
		acutPrintf(_T("\n\t\t\t\t\t风口风量(m^3/h): %.0f"),dairload);
		acutPrintf(_T("\n\t\t\t\t\t长度: %.0fmm"),dLength);
		acutPrintf(_T("\n\t\t\t\t\t宽度: %.0fmm"),dWidth);
		acutPrintf(_T("\n\t\t\t\t\t高度: %.0fmm"),dThick);
		acutPrintf(_T("\n\t\t\t\t\t标高: %.0fm"),ptCenter.z * 0.001);
	}
}

Acad::ErrorStatus THImpHvacAirlets::transformBy(const AcGeMatrix3d& xform)
{
	if (NULL == m_pXDataMap)
		return Acad::eNotApplicable;
	
	// 取得位置点
	AcGePoint3d ptCenter;
	AcGeVector3d vtMain,vtAirWay,vtNor;
	m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HALT_MainDir, vtMain);
	m_pXDataMap->GetAt(HALT_AirWay, vtAirWay);
	m_pXDataMap->GetAt(HVAC_Normal, vtNor);
	AcGeVector3d vtPrep(vtNor.crossProduct(vtMain));
	
	// 变换位置
	ptCenter.transformBy(xform);
	vtMain.transformBy(xform);
	vtAirWay.transformBy(xform);
	vtNor.transformBy(xform);
	vtPrep.transformBy(xform);
	// 同向是旋转，不变号，反向是镜像，变号。
	int iSign = ((vtPrep.isCodirectionalTo(vtNor.crossProduct(vtMain))) ? 1 : -1);
	// 对风口做镜像操作的时候,为保证风口的宽仍保持正值,修改图块比例Lixl add 2012-3-26
	if (iSign == -1)
	{
		AcGeVector3d vtScale;
		m_pXDataMap->GetAt(HALT_Scale, vtScale);
		vtScale.y = -fabs(vtScale.y);
		m_pXDataMap->SetAt(HALT_Scale, vtScale);
	}

	// 更新点
	m_pXDataMap->SetAt(HALT_CenterPoint, ptCenter);
	m_pXDataMap->SetAt(HALT_MainDir, vtMain);
	m_pXDataMap->SetAt(HALT_AirWay, vtAirWay);
	m_pXDataMap->SetAt(HVAC_Normal, vtNor);

	double dscale = xform.scale();
	double dLength(1.0);
	double dWidth(1.0);
	double dThick(1.0);
	m_pXDataMap->GetAt(HALT_Length, dLength);
	m_pXDataMap->GetAt(HALT_Width, dWidth);
	// 更新
	m_pXDataMap->SetAt(HALT_Length, dLength * dscale);
	m_pXDataMap->SetAt(HALT_Width, dWidth * dscale/* * iSign*/);
	
	// 传递消息及更新接口记录
	if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
	{
		// 如果实体不是在当前模型空间中,不做写消息,更新接口处理
		AcDbDatabase* pDb = m_pOwnerEnt->database();
		if (pDb == NULL) pDb = acdbCurDwg();
		
		AcDbObjectId idModel;
		AcDbBlockTable* pTable = NULL;
		pDb->getBlockTable(pTable, AcDb::kForRead);
		if (pTable != NULL)
		{
			pTable->getAt(ACDB_MODEL_SPACE, idModel);
			pTable->close();
		}
		
		// 如果实体不是在当前模型空间中,不做写消息,更新接口处理
		if (idModel == m_pOwnerEnt->blockId())
		{
			// 写入接口更改消息
// 			TInterfaceModifyMsg iMsg;
// 			iMsg.SetInterfaceOper(TDb::eTransformBy);
// 			iMsg.SetMsgValidate(TRUE);
// 			iMsg.SetTransform(xform);
// 			iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());
// 			
// 			TDbInterfaceMsgWrite msgWrite;
// 			msgWrite.WriteInterfaceMsg(iMsg);
			
			//更新接口记录接口信息
			UpdateInterfaceRec(m_pOwnerEnt->objectId(), xform);
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacAirlets::getStretchPoints(AcGePoint3dArray& stretchPoints) const
{
	if (NULL == m_pXDataMap)
		return Acad::eNotApplicable;
	
	// 取得位置点
	AcGePoint3d ptCenter;
	m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
	
	stretchPoints.append(ptCenter);
	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacAirlets::moveStretchPointsAt(const AcDbIntArray& indices,
														  const AcGeVector3d& offset)
{
	return moveGripPointsAt(indices,offset);
}

Acad::ErrorStatus THImpHvacAirlets::moveGripPointsAt(const AcDbIntArray& indices,
                                   const AcGeVector3d& offset)
{
	ASSERT(NULL != m_pXDataMap);
	int nSize = indices.length();
	if (nSize > 0)
	{

		// 取得位置点
		AcGePoint3d ptCenter;
		m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
		AcGeVector3d vtMain,vtMainv;
		m_pXDataMap->GetAt(HALT_MainDir, vtMain);
		double dThick;
		m_pXDataMap->GetAt(HALT_Thick, dThick);
		// 选择多个夹点,以first为准
		int nIndex = indices.first();
		TDb::Position ePos = ExplainGripIndex(nIndex);
		switch(ePos)
		{
		case TDb::eMid:
			{
				TDb::InterfaceOper eOper = TDb::eMoveGripPoint;
				AcGeVector3d vtMove = offset;
				
				ptCenter += vtMove;
				
				m_pXDataMap->SetAt(HALT_CenterPoint, ptCenter);

// 				if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
// 				{
// 					// 写入接口更改消息
// 					TInterfaceModifyMsg iMsg;
// 					iMsg.SetMsgPoint(ptCenter);//new pos
// 					iMsg.SetGripPosition(TDb::eMid);
// 					iMsg.SetMoveGripOffset(vtMove);
// 					if (eOper == TDb::eTransformBy)
// 						iMsg.SetTransform(vtMove);
// 					iMsg.SetMsgValidate(TRUE);
// 					iMsg.SetInterfaceOper(eOper);
// 					iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());
// 					TDbInterfaceMsgWrite msgWrite;
// 					msgWrite.WriteInterfaceMsg(iMsg);
// 					
// 					//更新接口记录接口信息
// 					AcGeMatrix3d xform;
// 					xform.setToTranslation(vtMove);
// 					UpdateInterfaceRec(m_pOwnerEnt->objectId(),xform);
// 				}
				break;
			}
		case TDb::eCommand0:
			{
				// 获得夹点命令
				CString sCmdStr;
				GetGlobalContext()->GetAt(KEY_HVACGRIPCMD, sCmdStr);
				if (sCmdStr.IsEmpty())
					return Acad::eNotApplicable;
				AcGePoint3d ptCom = ptCenter;
				// 写入接口更改消息
				TInterfaceModifyMsg iMsg;
				iMsg.SetMsgPoint(ptCom);//new pos
				iMsg.SetGripPosition(TDb::eCommand0);
				iMsg.SetMoveGripOffset(offset);
				iMsg.SetMsgValidate(TRUE);
				iMsg.SetInterfaceOper(TDb::eNewCommand);
				iMsg.SetPreviewObjToCreate(TDb::eAirlets, 0);
				
				AcDbSoftPointerId idOwner;
				m_pXDataMap->GetAt(KEY_THISID,idOwner);
				iMsg.SetMsgOperateOn(idOwner);
				TDbInterfaceMsgWrite msgWrite;
				msgWrite.WriteInterfaceMsg(iMsg);
				
				// 发送消息
				acedPostCommand(_T("\33"));
				acedPostCommand(sCmdStr + _T("\n"));
				break;
			}
		default:
			break;
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacAirlets::intersectWith(const AcDbEntity* pEnt,
                                AcDb::Intersect intType,
                                const AcGePlane& projPlane,
                                AcGePoint3dArray& points,
                                INT_PTR thisGsMarker,
                                INT_PTR otherGsMarker) const
{

	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacAirlets::intersectWith(const AcDbEntity* pEnt,
                                AcDb::Intersect intType,
                                AcGePoint3dArray& points,
                                INT_PTR thisGsMarker,
                                INT_PTR otherGsMarker) const
{
	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacAirlets::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(HALT_CenterPoint, ptCenter);

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

	// delete by hh 2011-07-12 捕捉算法改进
	/*BOOL bIsSide = FALSE; // 是否侧风口
	m_pXDataMap->GetAt(HALT_IsSide, bIsSide);
	int nType = 0; // 风口截面类型
	m_pXDataMap->GetAt(HVAC_SectType, nType);

	AcDbPolyline* pPolyLine = MakePolyCurve();
	if (NULL == pPolyLine)
		return Acad::eOk;

	snapPoints.append(ptCenter);
	if(eRectangular == (HvacSectType)nType) // 方形
	{
		AcDbVoidPtrArray arrLine;
		pPolyLine->explode(arrLine);
		for(int i = 0; i < arrLine.length(); i++)
		{
			AcDbObject* pObj = (AcDbObject*)arrLine[i];
			if(NULL == pObj)
				continue;

			AcDbCurve* pCurve = AcDbCurve::cast(pObj);
			if(NULL != pCurve)
			{
				pCurve->getOsnapPoints(osnapMode, gsSelectionMark, pickPoint, 
					lastPoint, viewXform, snapPoints, geomIds);
				delete pObj;
			}
		}
	}
	else // 圆形/椭圆形
	{
		pPolyLine->getOsnapPoints(osnapMode, gsSelectionMark, pickPoint, 
			lastPoint, viewXform, snapPoints, geomIds);
	}
	delete pPolyLine;*/

	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacAirlets::getGripPoints(AcGePoint3dArray& gripPoints,
                                AcDbIntArray& osnapModes,
                                AcDbIntArray& geomIds) const
{
	if (NULL == m_pXDataMap)
		return Acad::eNotApplicable;
	// 取得位置点
	AcGeVector3d vtMain,vtNor;
	AcGePoint3d ptCenter;
	double dLength;
 	double dThick;
	double dWidth;
	m_pXDataMap->GetAt(HVAC_Normal, vtNor);
	m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HALT_MainDir, vtMain);
	m_pXDataMap->GetAt(HALT_Length, dLength);
	m_pXDataMap->GetAt(HALT_Width, dWidth);
 	m_pXDataMap->GetAt(HALT_Thick, dThick);
	//移动夹点
	gripPoints.append(ptCenter); //STA

	AcDbObjectId id3d;
	m_pXDataMap->GetAt(HALT_Part3D, id3d);

	//增加命令夹点
	AcGePoint3d ptGeCmd1;	//按 10 个像素点
//	double dCmd = PixelToWcs(10);
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
	if (vtNor.isPerpendicularTo(vtZAxis))
	{
		vtMain = vtNor;
	}
	AcGeVector3d vtMainv = vtMain;
	vtMainv.rotateBy(PI * 0.5, GetNormal());
	vtMainv.normalize();
	vtMain.normalize();
	if (IsHorzAlignment())
	{
		//BEGIN=====================================================
		AcGeVector3d vtScale;
		m_pXDataMap->GetAt(HALT_Scale, vtScale);
		if (vtScale.x < 0)
		{
			ptGeCmd1 = ptCenter + vtMain * dLength * -0.5;
		} 
		else
		{
			ptGeCmd1 = ptCenter + vtMain * dLength * 0.5;
		}
		
		if (vtScale.y < 0)
		{
			ptGeCmd1 = ptGeCmd1 + vtMainv * dWidth * -0.5;
		} 
		else
		{
			ptGeCmd1 = ptGeCmd1 + vtMainv * dWidth * 0.5;
		}
		//修改时间：2010-05-25
		//修改人  ：王亚东
		//修改原因：修复BUG2591，支持翻转时夹点的旋转
		//END======================================================
	}
	else
	{
		ptGeCmd1 = ptCenter + GetNormal() * dThick;
	}
	gripPoints.append(ptGeCmd1); //cmd
	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacAirlets::getGeomExtents(AcDbExtents& extents) const
{
	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacAirlets::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;
}

Acad::ErrorStatus THImpHvacAirlets::explode(AcDbVoidPtrArray& entitySet) const
{
	return Acad::eOk;
}

//////////////////////////////////////////////////////////
//    
//    
//  1 ┏━━━━━┓ 2	
//    ┃	      ┃	
//    ┃          ┃
//    ┃	0     ┃	
//    ┃          ┃ 	
//  4 ┗━━━━━┛3
//              
//
BOOL THImpHvacAirlets::Draw3dBox(XExplodeDraw &mode) const
{
	TDb::HvacSectType eSectType = TDb::eRectangular;
	m_pXDataMap->GetAt(HVAC_SectType,(int&)eSectType);

	AcGePoint3d  ptCenter;
	AcGePoint3dArray arPts;
	AcGeVector3d vtMain, vtNor, vtMainv, vtz = GetNormal();
	double dLength(50.0), dThick(50.0), dWidth(50.0);
	m_pXDataMap->GetAt(HVAC_Normal, vtNor);
	m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HALT_MainDir, vtMain);
	m_pXDataMap->GetAt(HALT_Length, dLength);		
	m_pXDataMap->GetAt(HALT_Width, dWidth);		
	m_pXDataMap->GetAt(HALT_Thick,	dThick);

	vtMainv = vtMain;
	vtMainv.rotateBy(PI * 0.5, vtz);
	vtMain.normalize();
	vtMainv.normalize();
	AcGePoint3d pt;
	
	//方截面
	if (eSectType == TDb::eRectangular)
	{
		//侧风口
		if (vtNor.isPerpendicularTo(vtz))
		{
			vtMainv = vtNor;
			vtMainv.rotateBy(PI * 0.5, vtz);
			vtMain.normalize();
			vtMainv.normalize();
			vtNor.normalize();

			//0
			arPts.append(ptCenter);

			pt = ptCenter + vtMainv * dWidth * 0.5;
			pt = pt - vtMain * dLength * 0.5;
			//1
			arPts.append(pt);
			//2
			arPts.append(arPts[1] + vtNor * dThick);
			//3
			arPts.append(arPts[2] - vtMainv * dWidth);
			//4
			arPts.append(arPts[1] - vtMainv * dWidth);
			dThick = dLength;
			// change by hh 2011-01-05 3D视图下 长和宽定义交换
			/*pt = ptCenter + vtMainv * dLength * 0.5;
			pt = pt - vtMain * dWidth * 0.5;
			arPts.append(pt);
			arPts.append(arPts[1] + vtNor * dThick);
			arPts.append(arPts[2] - vtMainv * dLength);
			arPts.append(arPts[1] - vtMainv * dLength);
			dThick = dWidth;*/
		}
		else
		{
			//0
			arPts.append(ptCenter);
			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);
		}
		AcGePoint3dArray arptSides;
		arptSides.append(arPts[1] + vtz * dThick );
		arptSides.append(arPts[4] + vtz * dThick );
		arptSides.append(arPts[4]);
		arptSides.append(arPts[1]);
		arptSides.append(arPts[1] + vtz * dThick );
		
		arptSides.append(arPts[2] + vtz * dThick );
		arptSides.append(arPts[3] + vtz * dThick );
		arptSides.append(arPts[3]);
		arptSides.append(arPts[2]);
		arptSides.append(arPts[2] + vtz * dThick );
		mode.DrawMesh(2, 5, arptSides.asArrayPtr());
		
		arptSides.setLogicalLength(0);
		arptSides.append(arPts[1] + vtz * dThick);
		arptSides.append(arPts[1] );
		arptSides.append(arPts[4] + vtz * dThick);
		arptSides.append(arPts[4]);
		mode.DrawMesh(2, 2, arptSides.asArrayPtr());
		arptSides.setLogicalLength(0);
		arptSides.append(arPts[2] + vtz * dThick);
		arptSides.append(arPts[2]);
		arptSides.append(arPts[3] + vtz * dThick);
		arptSides.append(arPts[3]);
		mode.DrawMesh(2, 2, arptSides.asArrayPtr());
	}
	//圆
	else
	{
		double dMinDiffAng = PI/12;
		GetGlobalContext()->GetAt(KEY_MINDIFFANG,dMinDiffAng);
		int nSect = int(PI * 2 / dMinDiffAng) + 1;
		AcGePoint3dArray arptSides,arptSidesD;
		AcGePoint3d pt;
		AcGePoint3d ptC;
		//侧风口
		if (vtNor.isPerpendicularTo(vtz))
		{
// 			ptC = ptCenter;
// 			pt = ptCenter + vtMainv * dLength * 0.5;
// 			for (int i = 0; i < nSect; i++)
// 			{
// 				arptSides.append(pt);	
// 				pt.rotateBy(dMinDiffAng, vtNor, ptC);
// 			}
			ptC = ptCenter;
			pt = ptC + vtMainv * dLength * 0.5;
			for (int i = 0; i < nSect; i++)
			{
				arptSides.append(pt);	
				pt.rotateBy(dMinDiffAng, vtNor, ptC);
			}
			ptCenter += vtNor * dThick;
		}
		else
		{
			ptC = ptCenter;
			pt = ptC + vtMainv * dLength * 0.5;
			for (int i = 0; i < nSect; i++)
			{
				arptSides.append(pt);	
				pt.rotateBy(dMinDiffAng, vtNor, ptC);
			}
			ptCenter +=  vtNor * dThick;
// 			ptC = ptCenter + vtNor * dThick;
// 			pt = ptC + vtMainv * dLength * 0.5;
// 			for (i = 0; i < nSect; i++)
// 			{
// 				arptSides.append(pt);	
// 				pt.rotateBy(dMinDiffAng, vtNor, ptC);
// 			}
		}
//		mode.DrawMesh(2, nSect, arptSides.asArrayPtr());
		XPoly2D xploy2d;
		XPoint xpt;
		XVector3D xvt = ptCenter - ptC;
		for (int i = 0; i < nSect; i++)
		{
			xpt = arptSides[i];
			xploy2d.AppendNode(xpt);
		}
		mode.DrawBody(xploy2d,xvt);
// 		AcDbFace *pface = new AcDbFace;
// 		AcDbFace *pface1 = new AcDbFace;
// 		for (int i = 0; i < nSect - 1; i++)
// 		{
// 			pface->setVertexAt(0, ptCenter);
// 			pface->setVertexAt(1, arptSides[i]);
// 			pface->setVertexAt(2, arptSides[i + 1]);
// 			pface->setVertexAt(3, ptCenter);
// 			X3DFace x3dface(*pface);
// 			mode.DrawFace(x3dface);
// 
// 			pface1->setVertexAt(0, ptC);
// 			pface1->setVertexAt(1, arptSides[nSect + i]);
// 			pface1->setVertexAt(2, arptSides[nSect + i + 1]);
// 			pface1->setVertexAt(3, ptC);
// 			X3DFace x3dface1(*pface1);
// 			mode.DrawFace(x3dface1);
// 		}
	}
	return TRUE;
}
BOOL THImpHvacAirlets::IsHorzAlignment() const
{
	// 取得位置点
	AcGeVector3d vtMain;
	AcGePoint3d ptCenter;
	m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HALT_MainDir, vtMain);
	AcGeVector3d vtCross = GetNormal();
	
	// 获得UCS坐标Z向量
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
	AcGeVector3d vtXAxis(pDb->ucsxdir());
	AcGeVector3d vtYAxis(pDb->ucsydir());
	
	if (vtCross.isParallelTo(vtZAxis))
	{
		BOOL BBB = TRUE;
	}

	if (vtCross.isParallelTo(vtXAxis))
	{
		BOOL BBB = TRUE;
	}

	if (vtCross.isParallelTo(vtYAxis))
	{
		BOOL BBB = TRUE;
	}
	return vtCross.isParallelTo(vtZAxis);
}

BOOL THImpHvacAirlets::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::eAirlets);
		}
		return TRUE;
	}

	if (0 == _tcsicmp(pszName, KEY_Name))
	{
		pInfo->bVisible = TRUE;
		pInfo->bEditable = FALSE;
		return TRUE;
	}

	if (0 == _tcsicmp(pszName, KEY_Model))
	{
		pInfo->bVisible = TRUE;
		pInfo->bEditable = TRUE;
		return TRUE;
	}
	
	if (0 == _tcsicmp(pszName, KEY_AirLoad))
	{
		pInfo->bVisible = TRUE;
		pInfo->bEditable = TRUE;
		return TRUE;
	}

	if (0 == _tcsicmp(pszName, KEY_StartPoint))
	{
		pInfo->bVisible = TRUE;
		pInfo->bEditable = TRUE;
		// 整体移动
		if (NULL != pInfo->pXData && 0 != pInfo->pXData->nVt)
		{
			// 改变顶点变换行为
			AcGePoint3d pt;
			m_pXDataMap->GetAt(KEY_StartPoint, pt);
			AcGeVector3d offset = asPnt3d(pInfo->pXData->dVal) - pt;
			
			AcGeMatrix3d mat;
			mat.setToTranslation(offset);
			transformBy(mat);
			pInfo->pXData->nVt = 0;	// 设置处理完成标识
			//TAuxTools::SetAndUpdateCover((TDbInterfacesObj*)m_pOwnerEnt, pszName, pInfo);
		}
		return TRUE;
	}

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

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

		//BEGIN===================================================
		if (NULL != pInfo->pXData)
		{
			if (0 == pInfo->pXData->nVt)			//显示数据
			{
				if (m_pXDataMap->GetAt(HALT_Width, *pInfo->pXData))				//风口宽度值为负值时，只显示正值
				{
					pInfo->pXData->dVal[0] = fabs(pInfo->pXData->dVal[0]);
				}
			} 
			else									//设置数据
			{
				double dAltWidth = 0.0;
				if (m_pXDataMap->GetAt(HALT_Width, dAltWidth)  && dAltWidth < 0.0)				//原风口宽度值为负值时，设置为负值
				{
					dAltWidth = pInfo->pXData->dVal[0];
					m_pXDataMap->SetAt(HALT_Width, -fabs(dAltWidth));
				}
				else																			//原风口宽度值为正值时，设置为正值
				{
					dAltWidth = pInfo->pXData->dVal[0];
					m_pXDataMap->SetAt(HALT_Width, fabs(dAltWidth));
				}
				pInfo->pXData->nVt = 0;															// 设置处理完成标识
			}
		}
		//修改时间：2010-01-27
		//修改人  ：王亚东
		//修改原因：修正风口镜像后宽度显示负值的错误
		//END=====================================================

		return TRUE;
	}

	if (0 == _tcsicmp(pszName, KEY_Thick))
	{
		pInfo->bVisible = TRUE;
		pInfo->bEditable = TRUE;
		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;
}

int THImpHvacAirlets::GetXBaseShell(TXShell& xShell)
{
	int nRet = 0;
	if (NULL == m_pXDataMap)
	{
		return 0;
	}
	
	HvacSectType eSectType;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
	if (TDb::eRectangular == eSectType)
	{
		// 获得参数
		double dWidth = 0.0;
		m_pXDataMap->GetAt(HALT_Width, dWidth);
		double dThick = 0.0;
		m_pXDataMap->GetAt(HALT_Length, dThick);
		double dLength = 0.0;
		m_pXDataMap->GetAt(HALT_Thick, dLength);
		AcGeVector3d vtNormal;
		m_pXDataMap->GetAt(HALT_MainDir, vtNormal);
		vtNormal.normalize();
		AcGePoint3d ptStart;
		m_pXDataMap->GetAt(HALT_CenterPoint, ptStart);
		AcGeVector3d vtMain;
		m_pXDataMap->GetAt(HVAC_Normal, vtMain);
		vtMain.normalize();
		AcGePoint3d ptEnd = ptStart + vtMain * dLength;
		
		// 构造碰撞实体
		TAuxTools::BuildRectDuct(ptStart, ptEnd, vtNormal, dWidth, dThick, dWidth, dThick, xShell);

		nRet = 1;
	}
	else if (TDb::eCircular == eSectType)
	{
		// 获得参数
		double dDiameter = 0.0;
		m_pXDataMap->GetAt(HALT_Diameter, dDiameter);
		double dLength = 0.0;
		m_pXDataMap->GetAt(HALT_Thick, dLength);
		AcGeVector3d vtNormal;
		m_pXDataMap->GetAt(HALT_MainDir, vtNormal);
		vtNormal.normalize();
		AcGePoint3d ptStart;
		m_pXDataMap->GetAt(HALT_CenterPoint, ptStart);
		AcGeVector3d vtMain;
		m_pXDataMap->GetAt(HVAC_Normal, vtMain);
		vtMain.normalize();
		AcGePoint3d ptEnd = ptStart + vtMain * dLength;
		
		// 构造碰撞实体
		TAuxTools::BuildCirDuct(ptStart, ptEnd, dDiameter, dDiameter, xShell);

		nRet = 1;
	}
	else
	{
		// 不做处理
		;
	}
	
	return nRet;
}

int THImpHvacAirlets::GetBodyBox( AcDbExtents& ext ) const
{
	if (NULL == m_pXDataMap)
	{
		return 0;
	}
	
	// 获得参数
	double dWidth = 0.0;
	m_pXDataMap->GetAt(HALT_Width, dWidth);
	double dHalfWidth = dWidth / 2.0;
	double dLength = 0.0;
	m_pXDataMap->GetAt(HALT_Thick ,dLength);
	double dThick = 0.0;
	m_pXDataMap->GetAt(HALT_Length, dThick);
	double dHalfThick = dThick / 2.0;
	HvacSectType eSectType;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
	if (TDb::eCircular == eSectType)
	{
		// 处理圆管数据
		dHalfThick = dHalfWidth;
	}
	AcGeVector3d vtNormal;
	m_pXDataMap->GetAt(HALT_MainDir, vtNormal);
	vtNormal.normalize();
	AcGePoint3d ptStart;
	m_pXDataMap->GetAt(HALT_CenterPoint, ptStart);
	AcGeVector3d vtMain;
	m_pXDataMap->GetAt(HVAC_Normal, vtMain);
	AcGePoint3d ptEnd = ptStart + vtMain * dLength;
	AcGeVector3d vtSide = ptEnd - ptStart;
	vtSide.rotateBy(PI / 2.0, vtNormal);
	vtSide.normalize();
	
	// 计算端点
	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;
}
AcGePoint3d THImpHvacAirlets::GetIfPoint() const
{
	AcGePoint3d ptIf;
	m_pXDataMap->GetAt(HALT_CenterPoint, ptIf);

	// 上下送风时，接口位置调整至上面，适应大多数情况，跟风管连接完好
	BOOL bIsSide(TRUE);
	m_pXDataMap->GetAt(HALT_IsSide, bIsSide);
	if (!bIsSide)
	{
		AcGeVector3d vtNor;
		double dHeigh(0.0);
		m_pXDataMap->GetAt(HVAC_Normal, vtNor);
		m_pXDataMap->GetAt(HALT_Thick, dHeigh);
		ptIf += vtNor.normalize() * dHeigh;
	}

	return ptIf;
}

// 导出XML
CString THImpHvacAirlets::GetXml(const AcGeMatrix3d& mat) const
{
	if (NULL == m_pXDataMap || NULL == m_pOwnerEnt)
		return _T("");

	int nValue(0);
	double dValue(0.0);
	int nPtPreci = 6; // 位置精度
	int nWhPreci = 0; // 宽度、高度精度

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

	// 获得设备转换矩阵Lixl add 2012-2-1
	// 插入点
	XPoint ptLocation;
	m_pXDataMap->GetAt(HALT_CenterPoint, pt);
	ptLocation = pt;
	// 主方向
	XVector3D vtDirection(0,0,1);
	m_pXDataMap->GetAt(HALT_MainDir, vt);
	vtDirection = vt;
	// 图块比例
	m_pXDataMap->GetAt(HALT_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();
	}
	XPoint ptLoc=Wcs2Ecs(ptLocation, vtNormal);
	double nRotEcs = ads_angle(XPoint(),vtDirection); //计算ECS下的转角
	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);

	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("设备类型"));
		m_pXDataMap->GetAt(HALT_SEquipType, csText);
		xmlTree.SetItemText(posItemEquipType, csText);
	}

	POSITION posItemEquipName = xmlTree.Insert(_T("EquipName"), posRoot, posItemEquipType);
	{ 
		xmlTree.SetAttribute(posItemEquipName, _T("name"), _T("设备名称"));
		xmlTree.SetAttribute(posItemEquipName, _T("comment"), _T("对应图库中的风口名称"));
		m_pXDataMap->GetAt(HALT_SEquipName, csText);
		xmlTree.SetItemText(posItemEquipName, csText);
	}

	POSITION posItemNorDir = xmlTree.Insert(_T("NormalDir"),posRoot, posItemEquipName);
	{
		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 posItemCentPt = xmlTree.Insert(_T("CenterPoint"), posRoot, posItemNorDir);
	{ 
		xmlTree.SetAttribute(posItemCentPt, _T("name"), _T("中心点"));
		xmlTree.SetAttribute(posItemCentPt, _T("comment"), _T("布置点"));
		m_pXDataMap->GetAt(HALT_CenterPoint, pt);
		pt.transformBy(mat);
		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(posItemCentPt, csText);
	}

	POSITION posItemMainDir = xmlTree.Insert(_T("MainDir"), posRoot, posItemCentPt);
	{ 
		xmlTree.SetAttribute(posItemMainDir, _T("name"), _T("主矢量"));
		xmlTree.SetAttribute(posItemMainDir, _T("comment"), _T("布置角度"));
		m_pXDataMap->GetAt(HALT_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 posItemPart2D = xmlTree.Insert(_T("Part2D"), posRoot, posItemMainDir);
	{ 
		// mod by wc 13-12-16 //
		// 将保存id改为保存名称
		xmlTree.SetAttribute(posItemPart2D, _T("name"), _T("2D块名称"));
		xmlTree.SetAttribute(posItemPart2D, _T("comment"), _T("平面图块"));
		m_pXDataMap->GetAt(HALT_PartCenter, id);
		// mod by wc 13-12-16 //
		csText = TAuxTools::GetBlkNameById(id);
		//csText.Format(_T("%d"), id.asOldId());
		// end //
		xmlTree.SetItemText(posItemPart2D, csText);
	}

	POSITION posItemPart3D = xmlTree.Insert(_T("Part3D"), posRoot, posItemPart2D);
	{ 
		// mod by wc 13-12-16 //
		// 将保存id改为保存名称
		id.setNull();
		xmlTree.SetAttribute(posItemPart3D, _T("name"), _T("3D块名称"));
		xmlTree.SetAttribute(posItemPart3D, _T("comment"), _T("三维图块"));
		m_pXDataMap->GetAt(HALT_Part3D, id);
		csText = TAuxTools::GetBlkNameById(id);
		//csText.Format(_T("%d"), id.asOldId());
		// end //
		xmlTree.SetItemText(posItemPart3D, csText);
	}

	// add by wc 13-12-16 //

	POSITION posItemPartSys = xmlTree.Insert(_T("PartSys"), posRoot, posItemPart3D);
	{ 
		xmlTree.SetAttribute(posItemPartSys, _T("name"), _T("系统块名称"));
		xmlTree.SetAttribute(posItemPartSys, _T("comment"), _T("系统图块"));
		m_pXDataMap->GetAt(HALT_PartSys, id);
		csText = TAuxTools::GetBlkNameById(id);
		xmlTree.SetItemText(posItemPartSys, csText);
	}
	// end //

	// mod by wc //
	// 原因：插入了一个节点，因此Insert函数第3个参数需要变成新插入节点的POSITION
	POSITION posItemLength = xmlTree.Insert(_T("Length"), posRoot, posItemPartSys);
	{ 
		xmlTree.SetAttribute(posItemLength, _T("name"), _T("长度"));
		xmlTree.SetAttribute(posItemLength, _T("comment"), _T("风口长度"));
		m_pXDataMap->GetAt(HALT_Length, dValue);
		TAuxTools::DoubleToString(dValue, nWhPreci, csText);
		xmlTree.SetItemText(posItemLength, csText);
	}

	POSITION posItemWidth = xmlTree.Insert(_T("Width"), posRoot, posItemLength);
	{ 
		xmlTree.SetAttribute(posItemWidth, _T("name"), _T("宽度"));
		xmlTree.SetAttribute(posItemWidth, _T("comment"), _T("风口宽度"));
		m_pXDataMap->GetAt(HALT_Width, dValue);
		TAuxTools::DoubleToString(dValue, nWhPreci, csText);
		xmlTree.SetItemText(posItemWidth, csText);
	}

	POSITION posItemThick = xmlTree.Insert(_T("Thick"), posRoot, posItemWidth);
	{ 
		xmlTree.SetAttribute(posItemThick, _T("name"), _T("厚度"));
		xmlTree.SetAttribute(posItemThick, _T("comment"), _T("风口高度"));
		m_pXDataMap->GetAt(HALT_Thick, dValue);
		TAuxTools::DoubleToString(dValue, nWhPreci, csText);
		xmlTree.SetItemText(posItemThick, csText);
	}

	POSITION posItemScale = xmlTree.Insert(_T("Scale"), posRoot, posItemThick);
	{ 
		xmlTree.SetAttribute(posItemScale, _T("name"), _T("图块比例"));
		xmlTree.SetAttribute(posItemScale, _T("comment"), _T("图块比例"));
		m_pXDataMap->GetAt(HALT_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(posItemScale, csText);
	}

	POSITION posItemMat= xmlTree.Insert(_T("Matrix3d"), posRoot, posItemScale);
	{
		xmlTree.SetAttribute(posItemMat, _T("name"), _T("矩阵"));
		xmlTree.SetAttribute(posItemMat, _T("comment"), _T("图块转换矩阵"));
		xmlTree.SetItemText(posItemMat, sMat);
	}
	// add by wc 13-12-12
	// begin
	POSITION posItemAirWay = xmlTree.Insert(_T("AirWayDir"), posRoot, posItemMat);
	{
		xmlTree.SetAttribute(posItemAirWay, _T("name"), _T("接口方向"));
		xmlTree.SetAttribute(posItemAirWay, _T("comment"), _T("风口接口方向向量"));
		if (m_pXDataMap->GetAt(HALT_AirWay, 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);
		}
		else
		{
			csText.Format(_T("读取风口向量错误"));
		}
		xmlTree.SetItemText(posItemAirWay, csText);
	}

	POSITION posItemForm = xmlTree.Insert(_T("Form"), posRoot, posItemAirWay);
	{
		xmlTree.SetAttribute(posItemForm, _T("name"), _T("结构形式"));
		xmlTree.SetAttribute(posItemForm, _T("comment"), _T("明暗装等"));
		if (!m_pXDataMap->GetAt(HEQU_Form, csText))
		{
			csText.Empty();
		}
		xmlTree.SetItemText(posItemForm, csText);
	}

	POSITION posItemInterNum = xmlTree.Insert(_T("InterfaceNum"), posRoot, posItemForm);
	{
		xmlTree.SetAttribute(posItemInterNum, _T("name"), _T("接口数量"));
		xmlTree.SetAttribute(posItemInterNum, _T("comment"), _T("接口数量"));
		nValue = GetInterfaceCount();
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemInterNum, csText);
	}

	POSITION posItemSysName = xmlTree.Insert(_T("SysName"), posRoot, posItemInterNum);
	{
		xmlTree.SetAttribute(posItemSysName, _T("name"), _T("系统名称"));
		xmlTree.SetAttribute(posItemSysName, _T("comment"), _T("回风、送风等"));
		m_pXDataMap->GetAt(HVAC_System, csText);
		xmlTree.SetItemText(posItemSysName, csText);
	}

	POSITION posItemIsConverse = xmlTree.Insert(_T("IsConverse"), posRoot, posItemSysName);
	{
		xmlTree.SetAttribute(posItemIsConverse, _T("name"), _T("是否反向"));
		xmlTree.SetAttribute(posItemIsConverse, _T("comment"), _T("0/不是、1/是"));
		if (!m_pXDataMap->GetAt(HEQU_IsConverse, nValue))
		{
			nValue = 0;
		}
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemIsConverse, csText);
	}

	POSITION posItemHasText = xmlTree.Insert(_T("HasText"), posRoot, posItemIsConverse);
	{
		xmlTree.SetAttribute(posItemHasText, _T("name"), _T("是否有文字"));
		xmlTree.SetAttribute(posItemHasText, _T("comment"), _T("0/不是、1/是"));
		if (!m_pXDataMap->GetAt(HEQU_HasText, nValue))
		{
			nValue = 0;
		}
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemHasText, csText);
	}

	POSITION posItemTextPoint = xmlTree.Insert(_T("TextPoint"), posRoot, posItemHasText);
	{
		xmlTree.SetAttribute(posItemTextPoint, _T("name"), _T("文字基点"));
		xmlTree.SetAttribute(posItemTextPoint, _T("comment"), _T("文字基点"));
		if (m_pXDataMap->GetAt(HEQU_TextPoint, 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);
		}
		else
		{
			csText.Format(_T("文字基点读取失败"));
		}
		xmlTree.SetItemText(posItemTextPoint, csText);
	}

	POSITION posItemTextShade = xmlTree.Insert(_T("TextShadeBg"), posRoot, posItemTextPoint);
	{
		xmlTree.SetAttribute(posItemTextShade, _T("name"), _T("遮蔽背景"));
		xmlTree.SetAttribute(posItemTextShade, _T("comment"), _T("文字是否遮蔽背景0/不是、1/是"));
		if (!m_pXDataMap->GetAt(HEQU_TextShadeBg, nValue))
		{
			nValue = 0;
		}
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemTextShade, csText);
	}

	POSITION posItemTextLoc = xmlTree.Insert(_T("TextLoc"), posRoot, posItemTextShade);
	{
		xmlTree.SetAttribute(posItemTextLoc, _T("name"), _T("标注文字位置"));
		xmlTree.SetAttribute(posItemTextLoc, _T("comment"), _T("标注文字的位置：enum HvacEquipDimLoc"));
		if (!m_pXDataMap->GetAt(HEQU_TextLoc, nValue))
		{
			nValue = 0;
		}
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemTextLoc, csText);
	}

	POSITION posItemKind = xmlTree.Insert(_T("Kind"), posRoot, posItemTextLoc);
	{
		xmlTree.SetAttribute(posItemKind, _T("name"), _T("设备种类"));
		xmlTree.SetAttribute(posItemKind, _T("comment"), _T("1/采暖设备、2/空调设备"));
		if (!m_pXDataMap->GetAt(HEQU_Kind, nValue))
		{
			nValue = 1;
		}
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemKind, csText);
	}

	POSITION posItemReversalX = xmlTree.Insert(_T("ReversalX"), posRoot, posItemKind);
	{
		xmlTree.SetAttribute(posItemReversalX, _T("name"), _T("是否左右旋转"));
		xmlTree.SetAttribute(posItemReversalX, _T("comment"), _T("0/不是、1/是"));
		if (!m_pXDataMap->GetAt(HEQU_ReversalX, nValue))
		{
			nValue = 0;
		}
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemReversalX, csText);
	}

	POSITION posItemReversalY = xmlTree.Insert(_T("ReversalY"), posRoot, posItemReversalX);
	{
		xmlTree.SetAttribute(posItemReversalY, _T("name"), _T("是否上下旋转"));
		xmlTree.SetAttribute(posItemReversalY, _T("comment"), _T("0/不是、1/是"));
		if (!m_pXDataMap->GetAt(HEQU_ReversalY, nValue))
		{
			nValue = 0;
		}
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemReversalY, csText);
	}

	POSITION posItemAirLoad = xmlTree.Insert(_T("AirLoad"), posRoot, posItemReversalY);
	{
		xmlTree.SetAttribute(posItemAirLoad, _T("name"), _T("风口风量"));
		xmlTree.SetAttribute(posItemAirLoad, _T("comment"), _T("风口风量"));
		if (!m_pXDataMap->GetAt(HVAC_AirLoad, dValue))
		{
			dValue = 0.0;
		}
		csText.Format(_T("%f"), dValue);
		xmlTree.SetItemText(posItemAirLoad, csText);
	}

	POSITION posItemIsSide = xmlTree.Insert(_T("IsSide"), posRoot, posItemAirLoad);
	{
		xmlTree.SetAttribute(posItemIsSide, _T("name"), _T("是否侧风口"));
		xmlTree.SetAttribute(posItemIsSide, _T("comment"), _T("0/不是、1/是"));
		if (!m_pXDataMap->GetAt(HALT_IsSide, nValue))
		{
			nValue = 0;
		}
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemIsSide, csText);
	}

	POSITION posItemAreaRatio = xmlTree.Insert(_T("AreaRatio"), posRoot, posItemIsSide);
	{
		xmlTree.SetAttribute(posItemAreaRatio, _T("name"), _T("喉口面积系数"));
		xmlTree.SetAttribute(posItemAreaRatio, _T("comment"), _T("喉口面积系数"));
		if (!m_pXDataMap->GetAt(HALT_AreaRatio, dValue))
		{
			dValue = 0.0;
		}
		csText.Format(_T("%f"), dValue);
		xmlTree.SetItemText(posItemAreaRatio, csText);
	}

	POSITION posItemSectType = xmlTree.Insert(_T("SectType"), posRoot, posItemAreaRatio);
	{ 
		xmlTree.SetAttribute(posItemSectType, _T("name"), _T("截面类型"));
		xmlTree.SetAttribute(posItemSectType, _T("comment"), _T("0/矩形、1/圆形、2/扁圆"));
		if (!m_pXDataMap->GetAt(HVAC_SectType, nValue))
		{
			nValue = 0;
		}
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemSectType, csText);
	}
	// end //

	CString csXml = xmlTree.GetXml();

	return csXml;
}

Acad::ErrorStatus THImpHvacAirlets::ExplodeOrDrawBlock2d( XExplodeDraw &mode ) const
{
	return ExplodeOrDraw2d(mode);
}