#include "stdafx.h"
#include "StdArx.h"
#include "THImpHvacFan.h"

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

using namespace TDb;

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



THImpHvacFan::THImpHvacFan()
{
}

THImpHvacFan::~THImpHvacFan()
{
}

BOOL THImpHvacFan::GetInterfaceSizeData(int nIndex, TInterface& pipeInterface) const
{
	ASSERT(NULL != m_pXDataMap);
	
	// 获取截面类型
	TDb::HvacSectType eSectType = TDb::eRectangular;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
	
	// 获取接口截面、宽度、厚度数据key值
	LPCTSTR pszWidthKey, pszThickKey;
	switch (nIndex)
	{
	case 0:
		pszWidthKey = ((TDb::eCircular == eSectType) ? HFAN_Diameter : HFAN_Width);
		pszThickKey = HFAN_Length;
		break;
	case 1:
		pszWidthKey = ((TDb::eCircular == eSectType) ? HFAN_Diameter : HFAN_Width);
		pszThickKey = HFAN_Length;
		break;
	default:
		return FALSE;
	}
	
	// 获取尺寸
	double dWidth = 0.0, dThick = 0.0;
	m_pXDataMap->GetAt(pszWidthKey, dWidth);
	m_pXDataMap->GetAt(pszThickKey, dThick);
	
	// 设置接口数据
	pipeInterface.SetType(eSectType);
	pipeInterface.SetSize(dWidth, dThick);
	
	return TRUE;
}

BOOL THImpHvacFan::GetInterface(int nIndex,TInterface& pipeInterface) const
{
	if (NULL == m_pXDataMap)
		return FALSE;
	
	// 获取各点位置
	AcGePoint3d ptStart, ptCorner, ptEnd;
	m_pXDataMap->GetAt(HFAN_CenterPoint, ptCorner);
	ptStart = GetStartPt();
	ptEnd = GetEndPt();
		
	// 求两端方向
	AcGeVector3d vtStart, vtEnd;
	vtStart = ptStart - ptCorner;
	vtEnd = ptEnd - ptCorner;
	
	AcDbObjectId id;
	switch(nIndex)
	{
	case 0:
		// 如果起始接口和第一个管件连接
		if (m_pXDataMap->GetAt(KEY_IDCNT1, id) && MakesureInterfaceValidate(id, ptStart, vtStart, pipeInterface))
		{
			GetInterfaceSizeData(0,pipeInterface);
			return TRUE;
		}
		// 如果起始接口和第二个管件连接
		if (m_pXDataMap->GetAt(KEY_IDCNT2, id) && MakesureInterfaceValidate(id, ptStart, vtStart, pipeInterface))
		{
			GetInterfaceSizeData(0,pipeInterface);
			return TRUE;
		}
		// 没有管件连接
		pipeInterface.SetOutDir(vtStart);
		pipeInterface.SetOwnerId(m_pOwnerEnt->objectId());
		pipeInterface.SetPosition(ptStart);
		GetInterfaceSizeData(0,pipeInterface);
		return TRUE;
	case 1:
		// 如果末尾接口和第一个管件连接
		if (m_pXDataMap->GetAt(KEY_IDCNT1, id) && MakesureInterfaceValidate(id, ptEnd, vtEnd, pipeInterface))
		{
			GetInterfaceSizeData(1,pipeInterface);
			return TRUE;
		}
		// 如果末尾接口和第二个管件连接
		if (m_pXDataMap->GetAt(KEY_IDCNT2, id) && MakesureInterfaceValidate(id, ptEnd, vtEnd, pipeInterface))
		{
			GetInterfaceSizeData(1,pipeInterface);
			return TRUE;
		}
		// 没有管件连接
		pipeInterface.SetOutDir(vtEnd);
		pipeInterface.SetOwnerId(m_pOwnerEnt->objectId());
		pipeInterface.SetPosition(ptEnd);
		GetInterfaceSizeData(1,pipeInterface);
		return TRUE;
	}
	
	return FALSE;
}

BOOL THImpHvacFan::GetInterface(const AcGePoint3d& ptCon,TInterface& pipeInterface) const
{
	if (NULL == m_pXDataMap)
		return FALSE;
	
	// 获取各点位置
	AcGePoint3d ptStart, ptCorner, ptEnd;
	m_pXDataMap->GetAt(HFAN_CenterPoint, ptCorner);
	ptStart = GetStartPt();
	ptEnd = GetEndPt();
	
	// 求两端方向
	AcGeVector3d vtStart, vtEnd;
	vtStart = ptStart - ptCorner;
	vtEnd = ptEnd - ptCorner;
	
	// 计算测试点到始末点的距离
	double dDist1 = ptCon.distanceTo(ptStart);
	double dDist2 = ptCon.distanceTo(ptEnd);
	AcDbObjectId id;
	
	// 位于起始点
	if (dDist1 < 1.e-3)
	{
		// 如果起始接口和第一个管件连接
		if (m_pXDataMap->GetAt(KEY_IDCNT1, id) && MakesureInterfaceValidate(id, ptStart, vtStart, pipeInterface))
		{
			GetInterfaceSizeData(0,pipeInterface);
			return TRUE;
		}
		// 如果起始接口和第二个管件连接
		if (m_pXDataMap->GetAt(KEY_IDCNT2, id) && MakesureInterfaceValidate(id, ptStart, vtStart, pipeInterface))
		{
			GetInterfaceSizeData(0,pipeInterface);
			return TRUE;
		}
		// 没有管件连接
		pipeInterface.SetOutDir(vtStart);
		pipeInterface.SetOwnerId(m_pOwnerEnt->objectId());
		pipeInterface.SetPosition(ptStart);
		GetInterfaceSizeData(0,pipeInterface);
		return TRUE;
	}
	
	// 位于末尾点
	if (dDist2 < 1.e-3)
	{
		// 如果末尾接口和第一个管件连接
		if (m_pXDataMap->GetAt(KEY_IDCNT1, id) && MakesureInterfaceValidate(id, ptEnd, vtEnd, pipeInterface))
		{
			GetInterfaceSizeData(1,pipeInterface);
			return TRUE;
		}
		// 如果末尾接口和第二个管件连接
		if (m_pXDataMap->GetAt(KEY_IDCNT2, id) && MakesureInterfaceValidate(id, ptEnd, vtEnd, pipeInterface))
		{
			GetInterfaceSizeData(1,pipeInterface);
			return TRUE;
		}
		// 没有管件连接
		pipeInterface.SetOutDir(vtEnd);
		pipeInterface.SetOwnerId(m_pOwnerEnt->objectId());
		pipeInterface.SetPosition(ptEnd);
		GetInterfaceSizeData(1,pipeInterface);
		return TRUE;
	}
	return FALSE;
}

BOOL THImpHvacFan::HasInterface(const AcGePoint3d& ptCon,const AcGeVector3d& vtDir)
{
	if (NULL == m_pXDataMap)
		return FALSE;
	
	// 获取各点位置
	AcGePoint3d ptStart, ptCorner, ptEnd;
	m_pXDataMap->GetAt(HFAN_CenterPoint, ptCorner);
	ptStart = GetStartPt();
	ptEnd = GetEndPt();
	
	// 求两端方向
	AcGeVector3d vtStart, vtEnd;
	vtStart = ptStart - ptCorner;
	vtEnd = ptEnd - ptCorner;
	
	// 计算测试点到始末点的距离
	double dDist1 = ptCon.distanceTo(ptStart);
	double dDist2 = ptCon.distanceTo(ptEnd);
	
	// 位于起始点
	if (dDist1 < 1.e-3)
		return (vtDir.isParallelTo(vtStart));
	
	// 位于末尾点
	if (dDist2 < 1.e-3)
		return (vtDir.isParallelTo(vtEnd));
	
	return FALSE;
}

int	 THImpHvacFan::GetInterfaceCount() const
{
	return 2;
}

BOOL THImpHvacFan::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, ptCorner, ptEnd;
	m_pXDataMap->GetAt(HFAN_CenterPoint, ptCorner);
	ptStart = GetStartPt();
	ptEnd = GetEndPt();
	
	// 求两端方向
	AcGeVector3d vtStart, vtEnd;
	vtStart = ptStart - ptCorner;
	vtEnd = ptEnd - ptCorner;
	
	// 计算测试点到始末点的距离
	double dDist1 = ptConnect.distanceTo(ptStart);
	double dDist2 = ptConnect.distanceTo(ptEnd);
	
	// 基类指针
	TDbInterfacesObj* pInterfaceObj = TDbInterfacesObj::cast(pEnt);
	ASSERT(NULL != pInterfaceObj);
	
	// 位于起始点
	if (dDist1 < 1.e-3 && pInterfaceObj->HasInterface(ptStart, vtStart))
	{
		m_pXDataMap->SetAt(KEY_IDCNT1, idConnect);
		pEnt->close();
		return TRUE;
	}
	
	// 位于末尾点
	if (dDist2 < 1.e-3 && pInterfaceObj->HasInterface(ptEnd, vtEnd))
	{
		m_pXDataMap->SetAt(KEY_IDCNT2, idConnect);
		pEnt->close();
		return TRUE;
	}
	
	pEnt->close();
	return FALSE;
}

BOOL THImpHvacFan::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;
	}
	
	m_pXDataMap->GetAt(KEY_IDCNT2, id);
	if (id == idConnect)
	{
		m_pXDataMap->SetAt(KEY_IDCNT2, AcDbObjectId::kNull);
		return TRUE;
	}
	return FALSE;
}

BOOL THImpHvacFan::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 THImpHvacFan::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;
				}
			}
		}

		AcGePoint3d ptCenter;
		m_pXDataMap->GetAt(HFAN_CenterPoint, ptCenter);
		ptCenter += vtOffset;	
		m_pXDataMap->SetAt(HEQU_CenterPoint, ptCenter);
		
		// 更新模型空间的扩展字典的注册的接口数据
		AcGeMatrix3d xform;
		xform.setToTranslation(vtOffset);
		UpdateInterfaceRec(m_pOwnerEnt->objectId(), xform);
	}
				
	return bMsgTranslate;		
}

double THImpHvacFan::GetEdgeLineWidth() const
{
	BOOL bShow(FALSE);
	GetGlobalContext(HVAC_SHOWWIDTH, bShow);
	// 从图纸中读取加粗标识 避免全局参数对不同的图纸间的影响
	TAuxTools::GetTHvacDataFromDwg(HVAC_SHOWWIDTH, bShow);

	if (!bShow)
		return 0.0;

	ASSERT(NULL != m_pXDataMap);
	double dWidth(0.0);
	m_pXDataMap->GetAt(HFAN_EdgeWidth, dWidth);

	return dWidth;
}

BOOL THImpHvacFan::MakeCurves(TComplexCurve& cplCurve) const
{
	ASSERT(NULL != m_pXDataMap);
	BOOL bHEdgeWeight(FALSE);
	m_pXDataMap->GetAt(HFAN_EdgeWeight, bHEdgeWeight);
	if (bHEdgeWeight)
	{
		AcGePoint3dArray arPts;
		if (!GetBoxPts(arPts))
			return FALSE;

		TDb::TCurveElement el;
		memset(&el,0,sizeof(TDb::TCurveElement));
		el.bHided = FALSE;
		el.dWidth = 0.0;
		el.gsMark = 0;
		el.dWidth = GetEdgeLineWidth();
		AcDbObjectId idEdgeLine;
		m_pXDataMap->GetAt(HFAN_EdgeLayer, idEdgeLine);
		el.idSubLay = idEdgeLine;
		
		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);

		return TRUE;
	}
	
	return FALSE;
}

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

AcDbPolyline* THImpHvacFan::MakePolyCurve() const
{
//                 
//              
//  1 ┃━━━━━┃ 3	
//    ┃	      ┃	
//    ┃    0     ┃
//    ┃	      ┃	
//  2 ┃━━━━━┃ 4	
//                          
//
	// 获取各点位置
	AcDbPolyline* pPolyLine = NULL;
	AcGePoint3d pt1, pt2, pt3, pt4, ptCenter;
	AcGePoint3d ptU1, ptU2, ptU3, ptU4;
	AcGeVector3d vtMain, vtNor, vtMainv;
	double dLength(50.0), dDia(50.0);
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
	m_pXDataMap->GetAt(HVAC_Normal, vtNor);
	m_pXDataMap->GetAt(HFAN_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HFAN_MainDir, vtMain);
	m_pXDataMap->GetAt(HFAN_Length, dLength);		
	m_pXDataMap->GetAt(HFAN_Diameter, dDia);		

	if (dLength < 1)
		dLength = 1.0;
	if (dDia < 1)
		dDia = 1.0;

	vtMainv = vtMain;
	vtMainv.rotateBy(PI * 0.5, vtNor);
	vtMain.normalize();
	vtMainv.normalize();

	pt1 = ptCenter + vtMainv * dDia * 0.5;
	pt1 = pt1 - vtMain * dLength *0.5;
	pt1 = pt1 - vtNor * dDia *0.5;
	pt2 = ptCenter - vtMainv * dDia * 0.5;
	pt2 = pt2 - vtMain * dLength *0.5;
	pt2 = pt2 - vtNor * dDia *0.5;

	pt3 = pt1 + vtMain * dLength;
	pt4 = pt2 + vtMain * dLength;
	ptU1 = pt1 + vtNor * dDia;
	ptU2 = pt2 + vtNor * dDia;
	ptU3 = pt3 + vtNor * dDia;
	ptU4 = pt4 + vtNor * dDia;
	AcGePoint3dArray arpts;
	BOOL bCircle(FALSE);
	
//	mcl changed by below 2010.07.28.纠正对于，俯视跟前后视图的错误判断
// 	if (vtNor.angleTo(vtZAxis) < PI*0.25 || vtNor.angleTo(-vtZAxis) < PI*0.25)
// 	{
// 		arpts.append(pt1);
// 		arpts.append(pt2);
// 		arpts.append(pt4);
// 		arpts.append(pt3);
// 	}
// 	else 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);
// 		bCircle = TRUE;
// 	}
// 	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);
// 	}
	
	if (vtMain.angleTo(vtZAxis) < PI*0.25 || vtMain.angleTo(vtZAxis) > PI*0.75)	// 竖向，圆形
	{
		ptU2.z = pt2.z = ptU1.z = pt1.z = ptCenter.z;
		arpts.append(ptU2);
		arpts.append(pt2);
		arpts.append(pt1);
		arpts.append(ptU1);
		bCircle = TRUE;
	}
	else																		
	{
	 	if (vtNor.angleTo(vtZAxis) < PI*0.25 || vtNor.angleTo(-vtZAxis) < PI*0.25)	// 常规俯视图
	 	{
	 		arpts.append(pt1);
	 		arpts.append(pt2);
	 		arpts.append(pt4);
	 		arpts.append(pt3);
	 	}
	 	else																		// 前后侧视图
	 	{
	 		ptU1.z = pt1.z = ptU3.z = pt3.z = ptCenter.z;
	 		arpts.append(ptU1);
	 		arpts.append(pt1);
	 		arpts.append(pt3);
	 		arpts.append(ptU3);
	 	}
	}

	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().angleTo(plan.normal()) > PI*0.5)
		dEl *= -1.0;

	pPolyLine = new AcDbPolyline;
	if (bCircle)
	{
		AcGePoint3d ptC1(TAuxTools::Mid(arpts[0], arpts[1]));
		AcGePoint3d ptC2(TAuxTools::Mid(arpts[2], arpts[3]));
		pPolyLine->addVertexAt(0, ptC1.convert2d(plan), 1);
		pPolyLine->addVertexAt(1, ptC2.convert2d(plan), 1);
	}
	else
	{
		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());

	return pPolyLine;}

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

void THImpHvacFan::GetKindName(CString& sName)
{
	sName = _T("TCH_HFAN");
}

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

TDb::Position THImpHvacFan::ExplainGripIndex(int nIndex) const
{
	switch(nIndex)
	{
	case 0:
		{
			return TDb::eInf1;
			break;
		}
	case 1:
		{
			return TDb::eInf2;
			break;
		}
	case 2:
		{
			return TDb::eCommand0;
			break;
		}
	case 3:
		{
			return TDb::eCommand1;
			break;
		}
	case 4:
		{
			return TDb::eAdjust0;
			break;
		}
	default:
		break;
	}
	return TDb::eInf1;
}

Acad::ErrorStatus THImpHvacFan::GetGripText(int i, CString &cs) const
{
	switch(i)
	{
	case 0:
	case 1:
		{
			cs = _T("移动");
			break;
		}
	case 2:
	case 3:
		{
			cs = _T("启动绘制命令");
			break;
		}
	case 4:
		{
			cs = _T("改变方向");
			break;
		}
	}
	return Acad::eOk;
}

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

Acad::ErrorStatus THImpHvacFan::ExplodeOrDraw3d(XExplodeDraw &mode) const
{
	ASSERT(NULL != m_pXDataMap);
	AcGePoint3d ptCenter;
	AcDbObjectId idCen;
	m_pXDataMap->GetAt(HFAN_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HFAN_Part3D, idCen);
	ExplodeOrDraw2d(mode);
	Draw3dBox(mode);
	return Acad::eOk;
}

AcGeVector3d THImpHvacFan::GetNormal() const
{
	ASSERT(NULL != m_pXDataMap);
	AcGeVector3d vtNor;
	m_pXDataMap->GetAt(HVAC_Normal, vtNor);
	return vtNor.normalize();
}

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

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

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

AcGePoint3d THImpHvacFan::GetLabelPt() const
{
	ASSERT(NULL != m_pXDataMap);
	// 获取各点位置
	AcGePoint3d ptCenter;
	double dLength;
	AcGeVector3d vtMain;
	m_pXDataMap->GetAt(HFAN_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HFAN_Length, dLength);
	m_pXDataMap->GetAt(HFAN_MainDir, vtMain);
	ptCenter += vtMain * (dLength * 0.5 + 150);
	return ptCenter;
}

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

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

Acad::ErrorStatus THImpHvacFan::InserBlockCen(XExplodeDraw &mode, AcGePoint3d ptCenter, AcDbObjectId idBlock) const
{
	ASSERT(NULL != m_pXDataMap);
	AcGeVector3d vtMain;
	double dLength(10.0);
	double dWidth(10.0);
	double dThick(10.0);
	m_pXDataMap->GetAt(HFAN_Length, dLength);
	m_pXDataMap->GetAt(HFAN_Width, dWidth);
	m_pXDataMap->GetAt(HFAN_Thick, dThick);
	m_pXDataMap->GetAt(HFAN_MainDir, vtMain);
	dLength *= 0.001;
	dWidth *= 0.001;

	double dAngle = AcGeVector3d::kXAxis.angleTo(vtMain,GetNormal());
	// LixlAdd倾斜布置阀门，主向量须向XY平面投影,计算出来的图块旋转角度才会准确
	if (!(GetNormal().isParallelTo(AcGeVector3d::kZAxis)) && !(GetNormal().isPerpendicularTo(AcGeVector3d::kZAxis)))
		dAngle = AcGeVector3d::kXAxis.angleTo(vtMain.orthoProject(AcGeVector3d::kZAxis), AcGeVector3d::kZAxis);

	AcGeScale3d scale(dLength, dWidth, dThick);
	int bMirror(0);
	m_pXDataMap->GetAt(HFAN_IsMirror, bMirror);
	if (bMirror == 1)
	{
		scale.set(-dLength, dWidth, dThick);
	}

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

Acad::ErrorStatus THImpHvacFan::InserBlockHand(XExplodeDraw &mode) const
{
	ASSERT(NULL != m_pXDataMap);
	
	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacFan::InserBlockCen(AcGePoint3d ptCenter,XExplodeDraw &mode) const
{
	ASSERT(NULL != m_pXDataMap);
	AcDbObjectId idCen;
	AcGeVector3d vtMain;
	double dLength(10.0);
	m_pXDataMap->GetAt(HFAN_Length, dLength);
	m_pXDataMap->GetAt(HFAN_MainDir, vtMain);
	m_pXDataMap->GetAt(HFAN_PartCenter, idCen);
	
//	double dAngle = AcGeVector3d::kXAxis.angleTo(vtMain,GetNormal());
	
	double dAngle = acutAngle(asDblArray(GetStartPt()), asDblArray(GetEndPt()));
	// LixlAdd倾斜布置阀门，主向量须向XY平面投影,计算出来的图块旋转角度才会准确
	if (!(GetNormal().isParallelTo(AcGeVector3d::kZAxis)) && !(GetNormal().isPerpendicularTo(AcGeVector3d::kZAxis)))
		dAngle = AcGeVector3d::kXAxis.angleTo(vtMain.orthoProject(AcGeVector3d::kZAxis), AcGeVector3d::kZAxis);

	AcGeScale3d scale(dLength,dLength,1);
	int bMirror(0);
	m_pXDataMap->GetAt(HFAN_IsMirror, bMirror);
	if (bMirror == 1)
	{
		scale.set(-dLength, dLength, 1);
	}	
	AcDbObject * pObj;
	XPoint xpoint = ptCenter;
	if (acdbOpenObject(pObj, idCen, 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 * 0.5,dAngle,TRUE);
	pObj->close();
	
	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacFan::Draw2dBox(XExplodeDraw &mode) const
{
	AcGeVector3d vtNor;
	m_pXDataMap->GetAt(HVAC_Normal, vtNor);
	AcGePoint3dArray arPts;
	GetBoxPts(arPts);
	double dEl;
	AcGePlane plane = TAuxTools::GetHidePlane(arPts[1],arPts[2],arPts[3],vtNor,dEl);
	AcDbPolyline polyLine;
	polyLine.addVertexAt(0,arPts[1].convert2d(plane));
	polyLine.addVertexAt(1,arPts[2].convert2d(plane));
	polyLine.addVertexAt(2,arPts[3].convert2d(plane));
	polyLine.addVertexAt(3,arPts[4].convert2d(plane));
	mode.Polyline(polyLine);
	return Acad::eOk;
}
//    5            6 
//    ┃          ┃
//  1 ┃━━━━━┃ 2	
//    ┃	      ┃	
//    ┃    0     ┃
//    ┃	      ┃	
//  4 ┃━━━━━┃ 3	
//    ┃          ┃
//    8            7
//
BOOL THImpHvacFan::GetBoxPts(AcGePoint3dArray &arPts) const
{
	// 获取各点位置
	AcGePoint3d ptStart, ptEnd, ptCenter;
	AcGeVector3d vtMain, vtNor, vtMainv;
	double dLength(50.0), dThick(50.0), dWidth(50.0), dPlusEdge(50.0);
	m_pXDataMap->GetAt(HVAC_Normal, vtNor);
	m_pXDataMap->GetAt(HFAN_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HFAN_MainDir, vtMain);
	m_pXDataMap->GetAt(HFAN_Length, dLength);		
	m_pXDataMap->GetAt(HFAN_Width, dWidth);		
	m_pXDataMap->GetAt(HFAN_Thick,	dThick);
	vtMainv = vtMain;
	vtMainv.rotateBy(PI * 0.5, vtNor);
	vtMain.normalize();
	vtMainv.normalize();
	dPlusEdge = dWidth * 0.1;
	//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);
	return TRUE;
}

void THImpHvacFan::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(HFAN_SEquipType, sType);
		m_pXDataMap->GetAt(HFAN_SEquipName, sName);
		m_pXDataMap->GetAt(HFAN_CenterPoint, ptCenter);
		m_pXDataMap->GetAt(HFAN_MainDir, vtMain);
		m_pXDataMap->GetAt(HFAN_Length, dLength);		
		m_pXDataMap->GetAt(HFAN_Width, dWidth);		
		m_pXDataMap->GetAt(HFAN_Thick,	dThick);
		
		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长度: %.0fmm"),dLength);
		acutPrintf(_T("\n\t\t\t\t\t直径: %.0fmm"),dWidth);
		acutPrintf(_T("\n\t\t\t\t\t标高: %.0fm"),ptCenter.z * 0.001);
	}
}

Acad::ErrorStatus THImpHvacFan::transformBy(const AcGeMatrix3d& xform)
{
	if (NULL == m_pXDataMap)
		return Acad::eNotApplicable;
	
	// 取得位置点
	AcGePoint3d ptCenter;
	AcGeVector3d vtMain, vtNormal;
	m_pXDataMap->GetAt(HFAN_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HFAN_MainDir, vtMain);
	m_pXDataMap->GetAt(HVAC_Normal, vtNormal);
	
	// 变换位置
	ptCenter.transformBy(xform);
	vtMain.transformBy(xform);
	vtNormal.transformBy(xform);
	
	// 更新点
	m_pXDataMap->SetAt(HFAN_CenterPoint, ptCenter);
	m_pXDataMap->SetAt(HFAN_MainDir, vtMain);
	m_pXDataMap->SetAt(HVAC_Normal, vtNormal);
	
	// 传递消息
	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 THImpHvacFan::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 THImpHvacFan::moveStretchPointsAt(const AcDbIntArray& indices,
														  const AcGeVector3d& offset)
{
	return moveGripPointsAt(indices,offset);
}

Acad::ErrorStatus THImpHvacFan::moveGripPointsAt(const AcDbIntArray& indices,
                                   const AcGeVector3d& offset)
{
	ASSERT(NULL != m_pXDataMap);
	int nSize = indices.length();
	if (nSize > 0)
	{
		// 取得位置点
		AcGePoint3d ptCenter;
		m_pXDataMap->GetAt(HFAN_CenterPoint, ptCenter);
		AcGeVector3d vtMain,vtMainv;
		m_pXDataMap->GetAt(HFAN_MainDir, vtMain);
		double dLength;
		m_pXDataMap->GetAt(HFAN_Length, dLength);
		// 选择多个夹点,以first为准
		int nIndex = indices.first();
		TDb::Position ePos = ExplainGripIndex(nIndex);
		switch(ePos)
		{
		case TDb::eInf1:
			{
				TDb::InterfaceOper eOper = TDb::eMoveGripPoint;
				AcGeVector3d vtMove = offset;
				AcGePoint3d ptStart = GetStartPt();
				ptStart += vtMove;
				
				ptCenter = ptStart + vtMain * dLength * 0.5;
				
				m_pXDataMap->SetAt(HFAN_CenterPoint, ptCenter);
				
				if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
				{
					if (TAuxTools::IsEquipAutoMove(this, vtMove))
					{
						// 写入接口更改消息
						TInterfaceModifyMsg iMsg;
						iMsg.SetMsgPoint(ptStart);//new pos
						iMsg.SetGripPosition(TDb::eStart);
						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::eInf2:
			{
				TDb::InterfaceOper eOper = TDb::eMoveGripPoint;
				AcGeVector3d vtMove = offset;
				AcGePoint3d ptEnd = GetEndPt();
				ptEnd += vtMove;
				
				ptCenter = ptEnd - vtMain * dLength * 0.5;
				
				m_pXDataMap->SetAt(HFAN_CenterPoint, ptCenter);

				if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
				{
					if (TAuxTools::IsEquipAutoMove(this, vtMove))
					{
						// 写入接口更改消息
						TInterfaceModifyMsg iMsg;
						iMsg.SetMsgPoint(ptEnd);//new pos
						iMsg.SetGripPosition(TDb::eEnd);
						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::eAdjust0:
			{
				AcDbIntArray OsnapMode;
				AcDbIntArray GeomId;
				AcGePoint3dArray arPts;				
				getGripPoints(arPts, OsnapMode, GeomId);
				AcGePoint3d ptAdust = arPts[4];

				AcGePoint3d ptInter;
				AcGeVector3d vtMove = offset;
				ptAdust += vtMove;
				AcGePoint3d pts = GetStartPt();
				AcGePoint3d pte = GetEndPt();

				//判断方向点移动到哪个象限
				int nPos = TAuxTools::Getquadrant(ptCenter, ptAdust, vtMain);
				switch(nPos)
				{
				case 1:
					m_pXDataMap->SetAt(HFAN_IsMirror, 0);
					break;
				case 2:
					m_pXDataMap->SetAt(HFAN_IsMirror, 1);
					break;
				case 3:
					{
						m_pXDataMap->SetAt(HFAN_IsMirror, 1);
					}
					break;
				case 4:
					{
						m_pXDataMap->SetAt(HFAN_IsMirror, 0);
					}
					break;
				}
				break;
			}
		case TDb::eCommand0:
			{
				// 获得夹点命令
				CString sCmdStr;
				GetGlobalContext()->GetAt(KEY_HVACGRIPCMD, sCmdStr);
				if (sCmdStr.IsEmpty())
					return Acad::eNotApplicable;
				// 写入接口更改消息
				TInterfaceModifyMsg iMsg;
				iMsg.SetMsgPoint(GetStartPt());//new pos
				iMsg.SetGripPosition(TDb::eCommand0);
				iMsg.SetMoveGripOffset(offset);
				iMsg.SetMsgValidate(TRUE);
				iMsg.SetInterfaceOper(TDb::eNewCommand);
				iMsg.SetPreviewObjToCreate(TDb::eFan, 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;
			}
		case TDb::eCommand1:
			{
				// 获得夹点命令
				CString sCmdStr;
				GetGlobalContext()->GetAt(KEY_HVACGRIPCMD, sCmdStr);
				if (sCmdStr.IsEmpty())
					return Acad::eNotApplicable;
				// 写入接口更改消息
				TInterfaceModifyMsg iMsg;
				iMsg.SetMsgPoint(GetEndPt());//new pos
				iMsg.SetGripPosition(TDb::eCommand1);
				iMsg.SetMoveGripOffset(offset);
				iMsg.SetMsgValidate(TRUE);
				iMsg.SetInterfaceOper(TDb::eNewCommand);
				iMsg.SetPreviewObjToCreate(TDb::eFan, 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 THImpHvacFan::intersectWith(const AcDbEntity* pEnt,
                                AcDb::Intersect intType,
                                const AcGePlane& projPlane,
                                AcGePoint3dArray& points,
                                INT_PTR thisGsMarker,
                                INT_PTR otherGsMarker) const
{

	return Acad::eOk;
}

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

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

	// 根据捕捉模式处理
	switch(osnapMode)
	{
	case AcDb::kOsModeEnd:
		snapPoints.append(GetStartPt());
		snapPoints.append(GetEndPt());
		break;
	case AcDb::kOsModeMid:
		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 THImpHvacFan::getGripPoints(AcGePoint3dArray& gripPoints,
                                AcDbIntArray& osnapModes,
                                AcDbIntArray& geomIds) const
{
	if (NULL == m_pXDataMap)
		return Acad::eNotApplicable;
	// 取得位置点
	AcGeVector3d vtMain;
	AcGePoint3d ptCenter;
	m_pXDataMap->GetAt(HFAN_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HFAN_MainDir, vtMain);
	vtMain.normalize();
	//2个移动夹点
	gripPoints.append(GetStartPt()); //STA
	gripPoints.append(GetEndPt()); //END
	
	//增加2个命令夹点
	AcGePoint3d ptGeCmd1,ptGeCmd2;	//按 10 个像素点
//	double dCmd = PixelToWcs(10);
	ptGeCmd1 = GetStartPt() - vtMain * g_dCmdOff;
	ptGeCmd2 = GetEndPt() + vtMain * g_dCmdOff;
	gripPoints.append(ptGeCmd1); 
	gripPoints.append(ptGeCmd2); 

	//增加一个方向点
	int nMir = 0;
	m_pXDataMap->GetAt(HFAN_IsMirror, nMir);
	double dLength;
	m_pXDataMap->GetAt(HFAN_Length, dLength);
	ptGeCmd1 = ptCenter + vtMain * dLength * 0.25;
	if (nMir == 1)
	{
		ptGeCmd1 = ptCenter - vtMain * dLength * 0.25;
	}
	gripPoints.append(ptGeCmd1); 

	return Acad::eOk;
}

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

Acad::ErrorStatus THImpHvacFan::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 THImpHvacFan::explode(AcDbVoidPtrArray& entitySet) const
{
	return Acad::eOk;
}
//////////////////////////////////////////////////////////
//    
//    
//  1 ┏━━━━━┓ 2	
//    ┃	      ┃	
//    ┃          ┃
//    ┃	0     ┃	
//    ┃          ┃ 	
//  4 ┗━━━━━┛3
//              
//
BOOL THImpHvacFan::Draw3dBox(XExplodeDraw &mode) const
{
	TDb::HvacSectType eSectType = TDb::eRectangular;
	m_pXDataMap->GetAt(HVAC_SectType,(int&)eSectType);
	
	AcGePoint3d  ptCenter;
	AcGePoint3dArray arPts;
	AcGeVector3d vtMain, vtNor, vtMainv;
	double dLength(50.0), dThick(50.0), dWidth(50.0);
	m_pXDataMap->GetAt(HVAC_Normal, vtNor);
	m_pXDataMap->GetAt(HFAN_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HFAN_MainDir, vtMain);
	m_pXDataMap->GetAt(HFAN_Length, dLength);		
	m_pXDataMap->GetAt(HFAN_Width, dWidth);		
	m_pXDataMap->GetAt(HFAN_Thick,	dThick);
	vtMainv = vtMain;
	vtMainv.rotateBy(PI * 0.5, vtNor);
	vtMain.normalize();
	vtMainv.normalize();
	//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 (eSectType == TDb::eRectangular)
	{
		AcGePoint3dArray arptSides;
		arptSides.append(arPts[1] + vtNor * dThick * 0.5);
		arptSides.append(arPts[4] + vtNor * dThick * 0.5);
		arptSides.append(arPts[4] - vtNor * dThick * 0.5);
		arptSides.append(arPts[1] - vtNor * dThick * 0.5);
		arptSides.append(arPts[1] + vtNor * dThick * 0.5);
		
		arptSides.append(arPts[2] + vtNor * dThick * 0.5);
		arptSides.append(arPts[3] + vtNor * dThick * 0.5);
		arptSides.append(arPts[3] - vtNor * dThick * 0.5);
		arptSides.append(arPts[2] - vtNor * dThick * 0.5);
		arptSides.append(arPts[2] + vtNor * dThick * 0.5);
		mode.DrawMesh(2, 5, arptSides.asArrayPtr());
		
		arptSides.setLogicalLength(0);
		arptSides.append(arPts[1] + vtNor * dThick * 0.5);
		arptSides.append(arPts[1] - vtNor * dThick * 0.5);
		arptSides.append(arPts[4] + vtNor * dThick * 0.5);
		arptSides.append(arPts[4] - vtNor * dThick * 0.5);
		mode.DrawMesh(2, 2, arptSides.asArrayPtr());
		arptSides.setLogicalLength(0);
		arptSides.append(arPts[2] + vtNor * dThick * 0.5);
		arptSides.append(arPts[2] - vtNor * dThick * 0.5);
		arptSides.append(arPts[3] + vtNor * dThick * 0.5);
		arptSides.append(arPts[3] - vtNor * dThick * 0.5);
		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;
		ptC = ptCenter + vtMain * dLength * 0.5;
		pt = ptC + vtNor * dWidth * 0.5;
		for (int i = 0; i < nSect; i++)
		{
			arptSides.append(pt);	
			pt.rotateBy(dMinDiffAng, vtMain, ptC);
		}
		ptC = ptCenter - vtMain * dLength * 0.5;
		pt = ptC + vtNor * dWidth * 0.5;
		for (i = 0; i < nSect; i++)
		{
			arptSides.append(pt);	
			pt.rotateBy(dMinDiffAng, vtMain, ptC);
		}
		mode.DrawMesh(2, nSect, arptSides.asArrayPtr());
	}
	return TRUE;
}

BOOL THImpHvacFan::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::eFan);
		}

		// 全局属性，需要特殊处理数据获取和设置
		if (NULL != pInfo->pXData)
		{
			// 获取数据
			if (0 == pInfo->pXData->nVt)
			{
				pInfo->pXData->nVt = TXINT;
				pInfo->pXData->nVal = TDb::eFan;
			}
			// 设置数据
			else
			{
				pInfo->pXData->nVt = 0;	// 设置处理完成标识
			}
		}

		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 = FALSE;
		return TRUE;
	}

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

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

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

	if (0 == _tcsicmp(pszName, KEY_Thick))
	{
		pInfo->bVisible = TRUE;
		pInfo->bEditable = FALSE;
		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 THImpHvacFan::GetXBaseShell(TXShell& xShell)
{
	if (NULL == m_pXDataMap)
	{
		return 0;
	}

	// 获得参数
	double dLength = 0.0;
	m_pXDataMap->GetAt(HFAN_Length, dLength);
	AcGePoint3d ptCenter;
	m_pXDataMap->GetAt(HFAN_CenterPoint, ptCenter);
	AcGeVector3d vtMain, vtNormal;
	m_pXDataMap->GetAt(HFAN_MainDir, vtMain);
	m_pXDataMap->GetAt(HVAC_Normal, vtNormal);
	vtMain.normalize();
	vtNormal.normalize();
	AcGePoint3d ptStart = ptCenter + vtMain * dLength / 2.0;
	AcGePoint3d ptEnd = ptCenter - vtMain * dLength / 2.0;

	HvacSectType eSect = TDb::eRectangular;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSect);
	if (eSect == eCircular)
	{
		double dDiameter = 0.0;
		m_pXDataMap->GetAt(HFAN_Diameter, dDiameter);
		
		// 构造碰撞实体
		TAuxTools::BuildCirDuct(ptStart, ptEnd, dDiameter, dDiameter, xShell);
	}
	else
	{
		double dThick(0.0), dWidth(0.0);
		m_pXDataMap->GetAt(HFLN_Thick, dThick);
		m_pXDataMap->GetAt(HFLN_Width, dWidth);
	
		// 构造碰撞实体
		TAuxTools::BuildRectDuct(ptStart, ptEnd, vtNormal, dWidth, dThick, dWidth, dThick, xShell);
	}
	
	return 1;
}

int THImpHvacFan::GetBodyBox( AcDbExtents& ext ) const
{
	if (NULL == m_pXDataMap)
	{
		return 0;
	}
	
	HvacSectType eSect = TDb::eRectangular;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSect);
	
	// 获得参数
	AcGeVector3d vtNormal;
	m_pXDataMap->GetAt(HVAC_Normal, vtNormal);
	vtNormal.normalize();
	AcGeVector3d vtMain;
	m_pXDataMap->GetAt(HFAN_MainDir, vtMain);
	vtMain.normalize();
	AcGeVector3d vtSide = vtMain;
	vtSide.rotateBy(PI / 2.0, vtNormal);
	vtSide.normalize();
	double dLength = 0.0;
	m_pXDataMap->GetAt(HFAN_Length, dLength);
	AcGePoint3d ptCenter;
	m_pXDataMap->GetAt(HFAN_CenterPoint, ptCenter);
	AcGePoint3d ptStart = ptCenter + vtMain * dLength / 2.0;
	AcGePoint3d ptEnd = ptCenter - vtMain * dLength / 2.0;

	if (eSect == eCircular)
	{
		double dDiameter = 0.0;
		m_pXDataMap->GetAt(HFAN_Diameter, dDiameter);
		double dRadius = dDiameter / 2.0;
		
		// 计算端点
		AcGePoint3dArray arpt;
		arpt.append(ptStart + vtSide * dRadius + vtNormal * dRadius);
		arpt.append(ptStart + vtSide * dRadius - vtNormal * dRadius);
		arpt.append(ptStart - vtSide * dRadius - vtNormal * dRadius);
		arpt.append(ptStart - vtSide * dRadius + vtNormal * dRadius);
		arpt.append(ptEnd + vtSide * dRadius + vtNormal * dRadius);
		arpt.append(ptEnd + vtSide * dRadius - vtNormal * dRadius);
		arpt.append(ptEnd - vtSide * dRadius - vtNormal * dRadius);
		arpt.append(ptEnd - vtSide * dRadius + vtNormal * dRadius);
		TAuxTools::BuildMinRectangle(arpt, ext);	// 构造最小包含体
	}
	else
	{
		double dThick(0.0), dWidth(0.0);
		m_pXDataMap->GetAt(HFLN_Thick, dThick);
		m_pXDataMap->GetAt(HFLN_Width, dWidth);
		dThick *= 0.5;
		dWidth *= 0.5;

		AcGePoint3dArray arpt;
		arpt.append(ptStart + vtSide*dWidth - vtNormal*dThick);
		arpt.append(ptStart + vtSide*dWidth + vtNormal*dThick);
		arpt.append(ptStart - vtSide*dWidth - vtNormal*dThick);
		arpt.append(ptStart - vtSide*dWidth + vtNormal*dThick);

		arpt.append(ptEnd + vtSide*dWidth - vtNormal*dThick);
		arpt.append(ptEnd + vtSide*dWidth + vtNormal*dThick);
		arpt.append(ptEnd - vtSide*dWidth - vtNormal*dThick);
		arpt.append(ptEnd - vtSide*dWidth + vtNormal*dThick);
		TAuxTools::BuildMinRectangle(arpt, ext);	// 构造最小包含体
	}
	
	return 1;
}

// 导出XML
// CString THImpHvacFan::GetXml() 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;
// 	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(HFAN_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(HFAN_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(HFAN_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(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(HFAN_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);
// 	{ 
// 		xmlTree.SetAttribute(posItemPart2D, _T("name"), _T("2D块ID"));
// 		xmlTree.SetAttribute(posItemPart2D, _T("comment"), _T("平面图块"));
// 		m_pXDataMap->GetAt(HFAN_PartCenter, id);
// 		csText.Format(_T("%d"), id.asOldId());
// 		xmlTree.SetItemText(posItemPart2D, csText);
// 	}
// 
// 	POSITION posItemPart3D = xmlTree.Insert(_T("Part3D"), posRoot, posItemPart2D);
// 	{ 
// 		xmlTree.SetAttribute(posItemPart3D, _T("name"), _T("3D块ID"));
// 		xmlTree.SetAttribute(posItemPart3D, _T("comment"), _T("三维图块"));
// 		m_pXDataMap->GetAt(HFAN_Part3D, id);
// 		csText.Format(_T("%d"), id.asOldId());
// 		xmlTree.SetItemText(posItemPart3D, csText);
// 	}
// 
// 	POSITION posItemMirror = xmlTree.Insert(_T("IsMirror"), posRoot, posItemPart3D);
// 	{ 
// 		xmlTree.SetAttribute(posItemMirror, _T("name"), _T("是否镜像"));
// 		xmlTree.SetAttribute(posItemMirror, _T("comment"), _T("用于辅助绘制0:否,1:是"));
// 		m_pXDataMap->GetAt(HFAN_IsMirror, nValue);
// 		csText.Format(_T("%d"), nValue);
// 		xmlTree.SetItemText(posItemMirror, csText);
// 	}
// 
// 	POSITION posItemLength = xmlTree.Insert(_T("Length"), posRoot, posItemMirror);
// 	{ 
// 		xmlTree.SetAttribute(posItemLength, _T("name"), _T("长度"));
// 		xmlTree.SetAttribute(posItemLength, _T("comment"), _T("风机长度"));
// 		m_pXDataMap->GetAt(HFAN_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(HFAN_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(HFAN_Thick, dValue);
// 		TAuxTools::DoubleToString(dValue, nWhPreci, csText);
// 		xmlTree.SetItemText(posItemThick, csText);
// 	}
// 
// 	CString csXml = xmlTree.GetXml();
// 
// 	return csXml;
// }

CString THImpHvacFan::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;
	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(HFAN_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(HFAN_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(HFAN_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(HFAN_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);
	}

	// begin ////
	// mod by wc 13-12-16
	// 原因：id值可能会变，需要保存图块名称

	POSITION posItemPart2D = xmlTree.Insert(_T("Part2D"), posRoot, posItemMainDir);
	{ 
		xmlTree.SetAttribute(posItemPart2D, _T("name"), _T("2D块名称"));
		xmlTree.SetAttribute(posItemPart2D, _T("comment"), _T("平面图块"));
		m_pXDataMap->GetAt(HFAN_PartCenter, id);
		csText = TAuxTools::GetBlkNameById(id);
		//csText.Format(_T("%d"), id.asOldId());
		xmlTree.SetItemText(posItemPart2D, csText);
	}

	POSITION posItemPart3D = xmlTree.Insert(_T("Part3D"), posRoot, posItemPart2D);
	{ 
		xmlTree.SetAttribute(posItemPart3D, _T("name"), _T("3D块名称"));
		xmlTree.SetAttribute(posItemPart3D, _T("comment"), _T("三维图块"));
		m_pXDataMap->GetAt(HFAN_Part3D, id);
		csText = TAuxTools::GetBlkNameById(id);
		//csText.Format(_T("%d"), id.asOldId());
		xmlTree.SetItemText(posItemPart3D, csText);
	}
	// end //

	// add by wc 13-12-17 系统图块//
	POSITION posItemPartSys = xmlTree.Insert(_T("PartSys"), posRoot, posItemPart3D);
	{ 
		xmlTree.SetAttribute(posItemPartSys, _T("name"), _T("系统块名称"));
		xmlTree.SetAttribute(posItemPartSys, _T("comment"), _T("三维图块"));
		m_pXDataMap->GetAt(HFAN_PartSys, id);
		csText = TAuxTools::GetBlkNameById(id);
		xmlTree.SetItemText(posItemPartSys, csText);
	}

	POSITION posItemMirror = xmlTree.Insert(_T("IsMirror"), posRoot, posItemPartSys);
	{ 
		xmlTree.SetAttribute(posItemMirror, _T("name"), _T("是否镜像"));
		xmlTree.SetAttribute(posItemMirror, _T("comment"), _T("用于辅助绘制0:否,1:是"));
		m_pXDataMap->GetAt(HFAN_IsMirror, nValue);
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemMirror, csText);
	}

	POSITION posItemLength = xmlTree.Insert(_T("Length"), posRoot, posItemMirror);
	{ 
		xmlTree.SetAttribute(posItemLength, _T("name"), _T("长度"));
		xmlTree.SetAttribute(posItemLength, _T("comment"), _T("风机长度"));
		m_pXDataMap->GetAt(HFAN_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(HFAN_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(HFAN_Thick, dValue);
		TAuxTools::DoubleToString(dValue, nWhPreci, csText);
		xmlTree.SetItemText(posItemThick, csText);
	}
	//add by wc 13-12-12

	POSITION posItemAirCap = xmlTree.Insert(_T("AirCap"), posRoot, posItemThick);
	{ 
		xmlTree.SetAttribute(posItemAirCap, _T("name"), _T("风量"));
		xmlTree.SetAttribute(posItemAirCap, _T("comment"), _T("风机风量"));
		if (!m_pXDataMap->GetAt(HFAN_AirCap, dValue))
		{
			dValue = 0.0;
		}
		TAuxTools::DoubleToString(dValue, nWhPreci, csText);
		xmlTree.SetItemText(posItemAirCap, csText);
	}

	POSITION posItemPress = xmlTree.Insert(_T("Press"), posRoot, posItemAirCap);
	{ 
		xmlTree.SetAttribute(posItemPress, _T("name"), _T("风机全压"));
		xmlTree.SetAttribute(posItemPress, _T("comment"), _T("风机全压"));
		if (!m_pXDataMap->GetAt(HFAN_Press, csText))
			csText.Empty();
		xmlTree.SetItemText(posItemPress, csText);
	}

	POSITION posItemPower = xmlTree.Insert(_T("Power"), posRoot, posItemAirCap);
	{ 
		xmlTree.SetAttribute(posItemPower, _T("name"), _T("风机功率"));
		xmlTree.SetAttribute(posItemPower, _T("comment"), _T("风机功率"));
		if (!m_pXDataMap->GetAt(HFAN_Power, csText))
			csText.Empty();
		xmlTree.SetItemText(posItemPower, csText);
	}

	POSITION posItemEdgeWeight = xmlTree.Insert(_T("EdgeWeight"), posRoot, posItemPower);
	{ 
		xmlTree.SetAttribute(posItemEdgeWeight, _T("name"), _T("边线加粗"));
		xmlTree.SetAttribute(posItemEdgeWeight, _T("comment"), _T("风机是否边线加粗0/否、1/是"));
		if (!m_pXDataMap->GetAt(HFAN_EdgeWeight, nValue))
			nValue = 0;
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemEdgeWeight, csText);
	}

	POSITION posItemEdgeWidth = xmlTree.Insert(_T("EdgeWidth"), posRoot, posItemEdgeWeight);
	{ 
		xmlTree.SetAttribute(posItemEdgeWidth, _T("name"), _T("加粗值"));
		xmlTree.SetAttribute(posItemEdgeWidth, _T("comment"), _T("风机边线加粗值"));
		if (!m_pXDataMap->GetAt(HFAN_EdgeWidth, dValue))
			dValue = 0.0;
		TAuxTools::DoubleToString(dValue, nWhPreci, csText);
		xmlTree.SetItemText(posItemEdgeWidth, csText);
	}

	POSITION posItemForm = xmlTree.Insert(_T("Form"), posRoot, posItemEdgeWidth);
	{
		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 posItemEdgeLayer = xmlTree.Insert(_T("EdgeLayer"), posRoot, posItemEdgeWidth);
// 	{ 
// 		id.setNull();
// 		xmlTree.SetAttribute(posItemEdgeLayer, _T("name"), _T("风机边线图层"));
// 		xmlTree.SetAttribute(posItemEdgeLayer, _T("comment"), _T("风机边线图层的名字"));
// 		if (!m_pXDataMap->GetAt(HFAN_EdgeLayer, id))
// 			csText.Empty();
// 		else
// 		{
// 			ACHAR* pChar = NULL;
// 			AcDbObject *pObj = NULL;
// 			if (Acad::eOk == acdbOpenObject(pObj, id, AcDb::kForRead))
// 			{		
// 				AcDbLayerTableRecord *pRec = AcDbLayerTableRecord::cast(pObj);
// 				if (pRec != NULL)
// 				{
// 					pRec->getName(pChar);
// 					csText.Format(_T("%s"), pChar);
// 					pRec->close();
// 				}
// 				pObj->close();
// 			}
// 		}
// 		xmlTree.SetItemText(posItemEdgeLayer, csText);
// 	}

	POSITION posItemSysName = xmlTree.Insert(_T("System"), posRoot, posItemForm);
	{
		xmlTree.SetAttribute(posItemSysName, _T("name"), _T("管线类型"));
		xmlTree.SetAttribute(posItemSysName, _T("comment"), _T("回风/送风/通风..."));
		m_pXDataMap->GetAt(HVAC_System, csText);
		xmlTree.SetItemText(posItemSysName, csText);
	}

	POSITION posItemHasText = xmlTree.Insert(_T("HasText"), posRoot, posItemSysName);
	{
		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 posItemReversalX = xmlTree.Insert(_T("ReversalX"), posRoot, posItemTextLoc);
	{
		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 posItemSectType = xmlTree.Insert(_T("SectType"), posRoot, posItemReversalY);
	{ 
		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);
	}


	CString csXml = xmlTree.GetXml();

	return csXml;
}