envi-code/SourceCode/Code2026/tg_shs/shs_pipebase/THImpHvacValve.cpp

#include "stdafx.h"
#include "StdArx.h"
#include "THImpHvacValve.h"

#include "TDbInterfaceRecord.h"
#include "TDbXDataMap.h"
#include "TDbInterfaceMsgWrite.h"
#include "math.h"
#include "dbxutil.h"
#include "dbText.h"
#include "dbhatch.h"
#include "TDbEquWorldDraw.h"


using namespace TDb;

static const Adesk::UInt16 kColorByLayer   = 256;

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

#define HVAC_VALVEBLOCKCEN_UP		_T("Cent_UP")		// 阀芯块名(上) add by hh 2011-08-08 多叶阀使用
#define HVAC_VALVEBLOCKCEN_DN		_T("Cent_DN")		// 阀芯块名(下) add by hh 2011-08-08 多叶阀使用
#define HVAC_VALVEBLOCKCEN			_T("Cent")			// 阀芯块名
#define HVAC_VALVEBLOCKHAN			_T("Hand")			// 阀手柄块名
#define HVAC_VALVEBLOCKMIS			_T("Body")			// 其它非等比
#define FIXED_SILENCER_EXTEND       150  // 固定消声器出头量 150mm

THImpHvacValve::THImpHvacValve()
{
}

THImpHvacValve::~THImpHvacValve()
{
}

BOOL THImpHvacValve::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) ? HVLV_Diameter : HVLV_Width);
		pszThickKey = HVLV_Thick;
		break;
	case 1:
		pszWidthKey = ((TDb::eCircular == eSectType) ? HVLV_Diameter : HVLV_Width);
		pszThickKey = HVLV_Thick;
		break;
	default:
		return FALSE;
	}
	
	// 获取尺寸
	double dWidth = 0.0, dThick = 0.0;
	m_pXDataMap->GetAt(pszWidthKey, dWidth);
	m_pXDataMap->GetAt(pszThickKey, dThick);
	dWidth *= 1000;
	
	// 设置接口数据
	pipeInterface.SetType(eSectType);
	pipeInterface.SetSize(dWidth, dThick);
	
	return TRUE;
}

BOOL THImpHvacValve::GetInterface(int nIndex,TInterface& pipeInterface) const
{
	if (NULL == m_pXDataMap)
		return FALSE;
	
	// 获取各点位置
	AcGePoint3d ptStart, ptCorner, ptEnd;
	m_pXDataMap->GetAt(HVLV_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 THImpHvacValve::GetInterface(const AcGePoint3d& ptCon,TInterface& pipeInterface) const
{
	if (NULL == m_pXDataMap)
		return FALSE;
	
	// 获取各点位置
	AcGePoint3d ptStart, ptCorner, ptEnd;
	m_pXDataMap->GetAt(HVLV_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.6e-1)			//将接口判断连接精度由1.e-3改为2.e-1
	{
		// 如果起始接口和第一个管件连接
		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.6e-1)			//将接口判断连接精度由1.e-3改为2.e-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 THImpHvacValve::HasInterface(const AcGePoint3d& ptCon,const AcGeVector3d& vtDir)
{
	if (NULL == m_pXDataMap)
		return FALSE;
	
	// 获取各点位置
	AcGePoint3d ptStart, ptCorner, ptEnd;
	m_pXDataMap->GetAt(HVLV_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	 THImpHvacValve::GetInterfaceCount() const
{
	return 2;
}

BOOL THImpHvacValve::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(HVLV_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 THImpHvacValve::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 THImpHvacValve::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;
	case TDb::eTransformBy:
		// 对象移动消息处理
		bMsgTranslate =	OnTransformMsgNotify(iModiMsg, iModiMsgs);
		break;
	case TDb::eSize:
		// 尺寸调整消息处理
		bMsgTranslate = OnSizeMsgNotify(iModiMsg, iModiMsgs);
		break;
	default:
		return bMsgTranslate;
	}

	// 记录修改标识
	if (m_pOwnerEnt != NULL)
		m_pOwnerEnt->recordGraphicsModified();

	return bMsgTranslate;
}

BOOL THImpHvacValve::OnMoveGripPointMsgNotify( const TInterfaceModifyMsg& iModiMsg, 
											  TInterfaceModifyMsgs& iModiMsgs )
{
	if (!TAuxTools::IsAutoWorkOffset())
		return FALSE;

	ASSERT(NULL != m_pXDataMap);
	
	AcDbObjectId id = iModiMsg.GetMsgOperateOn();
	if (id != m_pOwnerEnt->objectId()) // 消息发送目标正确
		return FALSE;
	
	AcGeVector3d vtOffset = iModiMsg.GetMoveGripOffset();
	if (vtOffset.isZeroLength()) 
		return FALSE;
	
	BOOL bMsgTranslate = FALSE;
	AcGePoint3d ptCenter;
	m_pXDataMap->GetAt(HVLV_CenterPoint, ptCenter);
	AcGePoint3d ptGeStart = GetStartPt();
	AcGePoint3d ptGeEnd = GetEndPt();
	

	int nPos = iModiMsg.GetGripPosition();
	if (nPos == eStart || nPos == eMid || nPos == eEnd || nPos == eBr1 || nPos == eBr2)
	{
		AcGeVector3d vtSta, vtEnd;
		m_pXDataMap->GetAt(HVLV_MainDir, vtEnd);
		vtSta = -vtEnd;
		
		ptCenter += vtOffset;	
		AcGePoint3d ptDim, ptLable;
		m_pXDataMap->GetAt(HVLV_DimPoint, ptDim);
		m_pXDataMap->GetAt(HVLV_LabelPoint, ptLable);
	
		AcGeMatrix3d mtTrans;
		mtTrans.setTranslation(vtOffset);
		ptDim.transformBy(mtTrans);
		ptLable.transformBy(mtTrans);

		m_pXDataMap->SetAt(HVLV_CenterPoint, ptCenter);
		m_pXDataMap->SetAt(HVLV_DimPoint, ptDim);
		m_pXDataMap->SetAt(HVLV_LabelPoint, ptLable);
				
		// 构造接口消息传递 开始端检查
		AcDbObjectId idT;
		if (FindConnect(ptGeStart, vtSta, m_pOwnerEnt->objectId(), idT)) // sta 点的接口
		{
			TInterfaceModifyMsg msg;
			msg.SetMsgPoint(ptGeStart);
			msg.SetMoveGripOffset(vtOffset);
			msg.SetMsgOperateOn(idT);
			msg.SetGripPosition(eStart);
			iModiMsgs.append(msg);
			bMsgTranslate = TRUE;
		}
		
		// 构造接口消息传递 末端检查
		if (FindConnect(ptGeEnd, vtEnd, m_pOwnerEnt->objectId(), idT)) // end 点的接口
		{
			TInterfaceModifyMsg msg;
			msg.SetMsgPoint(ptGeEnd);
			msg.SetMoveGripOffset(vtOffset);
			msg.SetMsgOperateOn(idT);
			msg.SetGripPosition(eEnd);
			iModiMsgs.append(msg);
			bMsgTranslate = TRUE;
		}
			
		// 更新模型空间的扩展字典的注册的接口数据
		AcGeMatrix3d xform;
		xform.setToTranslation(vtOffset);
		UpdateInterfaceRec(m_pOwnerEnt->objectId(), xform);
	}
				
	return bMsgTranslate;	
}

BOOL THImpHvacValve::OnTransformMsgNotify( const TInterfaceModifyMsg& iModiMsg, 
										  TInterfaceModifyMsgs& iModiMsgs )
{
	if (!TAuxTools::IsAutoWorkOffset())
		return FALSE;

	ASSERT(NULL != m_pXDataMap);

	BOOL bMsgTranslate = FALSE;

	AcDbObjectId id = iModiMsg.GetMsgOperateOn();
	if (id != m_pOwnerEnt->objectId()) // 消息发送目标正确
		return FALSE;
	
	AcGeMatrix3d mtTrans = iModiMsg.GetTransform();
	AcGeVector3d vtSta, vtEnd;
	AcGePoint3d ptStart, ptEnd, ptCenter, ptLable, ptDim;
	m_pXDataMap->GetAt(HVLV_MainDir, vtEnd);
	vtSta = -vtEnd;

	m_pXDataMap->GetAt(HVLV_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HVLV_DimPoint, ptDim);
	m_pXDataMap->GetAt(HVLV_LabelPoint, ptLable);
	ptStart	 = GetStartPt();
	ptEnd = GetEndPt();
	
	ptCenter.transformBy(mtTrans);
	ptDim.transformBy(mtTrans);
	ptLable.transformBy(mtTrans);
	m_pXDataMap->SetAt(HVLV_CenterPoint, ptCenter);
	m_pXDataMap->SetAt(HVLV_DimPoint, ptDim);
	m_pXDataMap->SetAt(HVLV_LabelPoint, ptLable);
		
	// 构造接口消息传递 开始端检查
	AcDbObjectId idT;
	if (FindConnect(ptStart, vtSta, m_pOwnerEnt->objectId(), idT)) // sta 点的接口
	{
		TInterfaceModifyMsg msg;
		msg.SetMsgPoint(ptStart);
		msg.SetTransform(mtTrans);
		msg.SetMsgOperateOn(idT);
		iModiMsgs.append(msg);
		bMsgTranslate = TRUE;
	}
	
	// 构造接口消息传递 末端检查
	if (FindConnect(ptEnd, vtEnd, m_pOwnerEnt->objectId(), idT)) // end 点的接口
	{
		TInterfaceModifyMsg msg;
		msg.SetMsgPoint(ptEnd);
		msg.SetTransform(mtTrans);
		msg.SetMsgOperateOn(idT);
		iModiMsgs.append(msg);
		bMsgTranslate = TRUE;
	}
	
	// 更新模型空间的扩展字典的注册的接口数据
	UpdateInterfaceRec(m_pOwnerEnt->objectId(), mtTrans);
	
	return bMsgTranslate;	
}

BOOL THImpHvacValve::OnSizeMsgNotify( const TInterfaceModifyMsg& iModiMsg, 
									 TInterfaceModifyMsgs& iModiMsgs )
{
	ASSERT(NULL != m_pXDataMap);

	// 尺寸
	double dLength(0.0), dNewWidth(0.0), dNewThick(0.0);
	m_pXDataMap->GetAt(HVLV_Length, dLength);
	iModiMsg.GetSize(dNewWidth, dNewThick);
	dLength *= 500;

	// change by hh 2011-01-28 消声器固定出头150mm 消声器接口边与风管还无法做到保持吻合，暂不用（mcl,2011.3.16)
	dNewWidth /= 1000;
// 	CString szName;
// 	m_pXDataMap->GetAt(HVLV_SEquipName, szName);
// 	if(-1 != szName.Find(_T("消声器")))
// 	{
// 		// 计算新的图块宽度比例
// 		double dBlkWidth = GetBlkOldWidth();
// 		dNewWidth = (dNewWidth + 2 * FIXED_SILENCER_EXTEND) / dBlkWidth;
// 	}
// 	else
// 	{
// 		dNewWidth /= 1000;
// 	}

	// 原始点及主向量
	AcGePoint3d ptOrigCenter, ptOrigStart, ptOrigEnd, ptOrigLable;
	m_pXDataMap->GetAt(HVLV_CenterPoint, ptOrigCenter);
	m_pXDataMap->GetAt(HVLV_LabelPoint, ptOrigLable);
	AcGeVector3d vtMain(AcGeVector3d::kXAxis);
	m_pXDataMap->GetAt(HVLV_MainDir, vtMain);
	vtMain.normalize();
	ptOrigStart = ptOrigCenter - vtMain * dLength * 0.5;
	ptOrigEnd = ptOrigStart + vtMain * dLength;

	// 求新点
	AcGeVector3d vtOff = iModiMsg.GetMoveGripOffset();
	AcGePoint3d ptNewStart = ptOrigStart + vtOff;
	AcGePoint3d ptNewEnd = ptOrigEnd + vtOff;
	AcGePoint3d ptNewCenter = ptOrigCenter + vtOff;
	AcGePoint3d ptNewLable = ptOrigLable + vtOff;
	m_pXDataMap->SetAt(HVLV_Width, dNewWidth);
	m_pXDataMap->SetAt(HVLV_Thick, dNewThick);
	m_pXDataMap->SetAt(HVLV_CenterPoint, ptNewCenter);
	m_pXDataMap->SetAt(HVLV_LabelPoint, ptNewLable);

	// 消息传递	
	AcDbObjectId idFind;
	if (FindConnect(ptOrigStart, vtMain, m_pOwnerEnt->objectId(), idFind)) // sta 点的接口
	{
		TInterfaceModifyMsg iMsg = iModiMsg;
		iMsg.SetMsgOperateOn(idFind);
		iMsg.SetMsgPoint(ptOrigStart);
		iModiMsgs.append(iMsg);
	}

	if (FindConnect(ptOrigEnd, vtMain, m_pOwnerEnt->objectId(), idFind)) // End 点的接口
	{
		TInterfaceModifyMsg iMsg = iModiMsg;
		iMsg.SetMsgOperateOn(idFind);
		iMsg.SetMsgPoint(ptOrigEnd);
		iModiMsgs.append(iMsg);
	}

	((TDbInterfacesObj*)m_pOwnerEnt)->UpdateInterfaceRec(ptOrigStart, ptNewStart);
	((TDbInterfacesObj*)m_pOwnerEnt)->UpdateInterfaceRec(ptOrigEnd, ptNewEnd);

	return TRUE;
}

BOOL THImpHvacValve::MakeCurves(TComplexCurve& cplCurve) const
{
	if (NULL == m_pXDataMap)
		return FALSE;
	int nIsBreakPipe(0);
	int nHasEndLine(1);
	int nIsDuctCap(0);
	m_pXDataMap->GetAt(HVLV_IsBreakPipe, nIsBreakPipe);
	m_pXDataMap->GetAt(HVLV_HasEndLine, nHasEndLine);
	//是否是管帽
	m_pXDataMap->GetAt(HVLV_IsDuctCap, nIsDuctCap);
	if (nIsDuctCap == 2)
		return FALSE;
	AcGePoint3dArray arPts;
	GetBoxPts(arPts);
	double dEdgeWidth = GetEdgeLineWidth();
	AcDbObjectId idEdgeLayer(NULL);
	m_pXDataMap->GetAt(HVLV_DuctLayer, idEdgeLayer);
	TDb::TCurveElement el;
	memset(&el,0,sizeof(TDb::TCurveElement));

	//风管上下边线
	if (nIsBreakPipe == 1)
	{
		el.idSubLay = idEdgeLayer;
		el.dWidth = dEdgeWidth;
		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);
	}
	//风阀端线如果插在风管上与风管端线相同
	if (nHasEndLine == 1)
	{
		AcDbObjectId idSideLayer(AcDbObjectId::kNull);
		m_pXDataMap->GetAt(HVAC_EndLayer, idSideLayer);
		if (idSideLayer != AcDbObjectId::kNull)
		{
			double dEndLineWidth = GetEndLineWidth();
			el.idSubLay = idSideLayer;
			el.dWidth = dEndLineWidth;
			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;
}

BOOL THImpHvacValve::GetCurvesInSide(TComplexCurve& compCurve) const
{
	// 取得普通方式绘制的所有实体
	AcDbVoidPtrArray arFirst, arSecond;
	XExplodeStream dc(arFirst);

	AcDbObjectId id3D;
	AcGePoint3d ptCenter;
	m_pXDataMap->GetAt(HVLV_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(/*HVLV_Part3D*/HVLV_PartCenter, id3D);
	AcDbObjectIdArray arobjs;
	ExplodeBlock(dc, id3D, ptCenter, arobjs);

	// 取得轮廓线条
	TComplexCurve curExclude;
	MakeCurves(curExclude);

	// 创建一个临时的WorldDraw 以接受图元信息
	TDbEquWorldDraw wDraw;
	wDraw.SetComplexCurvePtr(&compCurve);
	wDraw.SetExcluding(curExclude);
	// 图块数据转换为图元信息
	AcDbEntity *pEnt = NULL;
	AcDbEntity *pEnt2 = NULL, *pEnt3 = NULL;
	AcDbBlockReference* pRef = NULL;
	int iLen, iLen1;
	for (int i = 0; i < arFirst.length(); ++i)
	{
		pEnt = (AcDbEntity*)arFirst[i];
		if (NULL == pEnt)
			continue;
		if(pEnt->isKindOf(AcDbBlockReference::desc()))
		{
			pRef = (AcDbBlockReference*)pEnt;
			pRef->explode(arSecond);
			iLen = arSecond.length();
			for(int j = 0; j < iLen; j++)
			{
				pEnt2 = (AcDbEntity*)arSecond[j];
				if(NULL == pEnt2)
					continue;
#if ADS > 19
				AcDbVoidPtrArray arThird;
				if (pEnt2->isKindOf(AcDbHatch::desc()))
				{
					AcDbHatch *pHatch = (AcDbHatch*)pEnt2;
					pHatch->explode(arThird);
					iLen1 = arThird.length();
					for(int k = 0; k < iLen1; ++k)
					{
						pEnt3 = (AcDbEntity*)arThird[k];
						pEnt3->worldDraw(&wDraw);
					}
				}
				else
				{
					wDraw.VirtualWordDraw(pEnt2);
				}
#else
				wDraw.VirtualWordDraw(pEnt2);
#endif
				// 排除点
				/*if (pEnt2->isKindOf(AcDbPoint::desc()))
					continue;
				if(!pEnt2->isKindOf(AcDbText::desc()))
					pEnt2->worldDraw(&wDraw);*/
				delete pEnt2;
			}
			arSecond.setLogicalLength(0);
		}
		else
		{
			wDraw.VirtualWordDraw(pEnt);
			// pEnt->worldDraw(&wDraw);
		}
		delete pEnt;
	}

	return TRUE;
}

AcDbPolyline* THImpHvacValve::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), dThick(50.0), dWidth(50.0);
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
	m_pXDataMap->GetAt(HVAC_Normal, vtNor);
	m_pXDataMap->GetAt(HVLV_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HVLV_MainDir, vtMain);
	m_pXDataMap->GetAt(HVLV_Length, dLength);		
	m_pXDataMap->GetAt(HVLV_Width, dWidth);		
	m_pXDataMap->GetAt(HVLV_Thick, dThick);	
	
	//是否是管帽
	int nIsDuctCap(0);
	m_pXDataMap->GetAt(HVLV_IsDuctCap, nIsDuctCap);
	if (nIsDuctCap == 2)
		return NULL;

	dLength *= 500;
	dWidth *= 1000;

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

	HvacSectType eSect = eRectangular;
	m_pXDataMap->GetAt(HVAC_SectType, (int&)eSect);
	if (eSect == eCircular)
		dThick = dWidth;

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

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

	pt3 = pt1 + vtMain * dLength;
	pt4 = pt2 + vtMain * dLength;
	ptU1 = pt1 + vtNor * dThick;
	ptU2 = pt2 + vtNor * dThick;
	ptU3 = pt3 + vtNor * dThick;
	ptU4 = pt4 + vtNor * dThick;
	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);
// 
// 		if (eSect == eCircular)
// 			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);

		if (eSect == eCircular)
			bCircle = TRUE;
	}
	else
	{
		if (vtNor.angleTo(vtZAxis) < PI*0.25 || vtNor.angleTo(-vtZAxis) < PI*0.25)	// 常规俯视图
		{
			// add by zh 2013-6-6 常规俯视图标高修改一致 解决无法兰风管移动阀门不联动
			pt1.z = pt2.z = pt4.z = pt3.z = ptCenter.z;
			//
			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 THImpHvacValve::MakePolyCurveFaces(AcDbVoidPtrArray& arFaces)
{
	//                 
	//              
	//  1 ┃━━━━━┃ 3	
	//    ┃	      ┃	
	//    ┃    0     ┃
	//    ┃	      ┃	
	//  2 ┃━━━━━┃ 4	
	//                          
	//
	// 获取各点位置
	AcGePoint3d pt1, pt2, pt3, pt4, ptCenter;
	AcGeVector3d vtMain, vtNor, vtMainv;
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
	double dLength(50.0), dThick(50.0), dWidth(50.0), dPlusEdge(50.0);
	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);	
	dLength *= 500;
	dWidth *= 1000;

	//是否是管帽
	int nIsDuctCap(0);
	m_pXDataMap->GetAt(HVLV_IsDuctCap, nIsDuctCap);
	if (nIsDuctCap == 2)
		return FALSE;

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

	if (IsParallelToX())
	{
		dLength = dThick;
	}
	else if (IsParallelToY())
	{
		dWidth = dThick;
	}

	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;
	AcDbFace * pFace = new AcDbFace;
	pFace->setVertexAt(0,pt1);
	pFace->setVertexAt(1,pt2);
	pFace->setVertexAt(2,pt4);
	pFace->setVertexAt(3,pt3);
	arFaces.append(pFace);

	return arFaces.length() > 0;
}

void THImpHvacValve::GetKindName(CString& sName)
{
	sName = _T("TCH_HVALVE");
}

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

TDb::Position THImpHvacValve::ExplainGripIndex(int nIndex) const
{
	switch(nIndex)
	{
	case 0:
		{
			return TDb::eStart;
			break;
		}
	case 1:
		{
			return TDb::eEnd;
			break;
		}
	case 2:
		{
			return TDb::eMid;
			break;
		}
	case 3:
		{
			return TDb::eCommand0;
			break;
		}
	case 4:
		{
			return TDb::eCommand1;
			break;
		}
	case 5:
		{
			return TDb::eAdjust0;
			break;
		}
	case 6:
		{
			CString sLabel, sDim;
			m_pXDataMap->GetAt(HVLV_LabelText, sLabel);
			m_pXDataMap->GetAt(HVLV_DimText, sDim);
			if (sLabel.IsEmpty())
			{
				if(sDim.IsEmpty())
					return TDb::eDim0;
				else
					return TDb::eDim2;
			}
			return TDb::eDim1;
			break;
		}
	case 7:
		{
			CString sLabel, sDim;
			m_pXDataMap->GetAt(HVLV_LabelText, sLabel);
			m_pXDataMap->GetAt(HVLV_DimText, sDim);
			if(sDim.IsEmpty())
			{
				return TDb::eDim0;
			}
			else if(!sLabel.IsEmpty())
			{
				return TDb::eDim2;
			}
			return TDb::eDim0;
			break;
		}
	case 8:
		{
			// add by hh 2013-8-29 使用Dim0作为阀门代号点
			return TDb::eDim0;
			break;
		}
	default:
		break;
	}
	return TDb::eMid;
}

Acad::ErrorStatus THImpHvacValve::GetGripText(int i, CString &cs) const
{
	switch(i)
	{
	case 0:
	case 1:
	case 2:
		{
			cs = _T("移动");
			break;
		}
	case 3:
	case 4:
		{
			//TDb::eCommand0;
			cs = _T("启动绘制命令");
			break;
		}
	case 5:
		{
			cs = _T("改变方向");
			break;
		}
	case 6:
	case 7:
	case 8:
		{
			cs = _T("移动文字");
			break;
		}
	default:
		break;
	}
	return Acad::eOk;
}

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

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

	AcDbObjectId idCen,id3D;
	AcGePoint3d ptCenter;
	int nIsDuctCap(0);
	m_pXDataMap->GetAt(HVLV_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HVLV_PartCenter, idCen);
	m_pXDataMap->GetAt(HVLV_Part3D, id3D);
	m_pXDataMap->GetAt(HVLV_IsDuctCap, nIsDuctCap);
	AcDbObjectIdArray arobjs;
	ExplodeBlock(mode,id3D,ptCenter,arobjs,1);
	if (id3D == idCen && nIsDuctCap == 0)
	{
		TDb::HvacSectType eSectType = TDb::eRectangular;
		m_pXDataMap->GetAt(HVAC_SectType,(int&)eSectType);
		double dThick(0.0);
		m_pXDataMap->GetAt(HVLV_Thick, dThick);
		AcGeVector3d vtNor = GetNormal();
		//方截面
		if (eSectType == TDb::eRectangular)
		{
			AcGePoint3dArray arPts,arptSides;
			GetBoxPts(arPts);
			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());

			arptSides.setLogicalLength(0);
			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[2] - vtNor * dThick * 0.5);
			mode.DrawMesh(2, 2, arptSides.asArrayPtr());
			arptSides.setLogicalLength(0);
			arptSides.append(arPts[4] + vtNor * dThick * 0.5);
			arptSides.append(arPts[4] - 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());
			arptSides.setLogicalLength(0);
			arptSides.append(arPts[1] - vtNor * dThick * 0.5);
			arptSides.append(arPts[2] - vtNor * dThick * 0.5);
			arptSides.append(arPts[4] - vtNor * dThick * 0.5);
			arptSides.append(arPts[3] - vtNor * dThick * 0.5);
			mode.DrawMesh(2, 2, arptSides.asArrayPtr());
			ptCenter = ptCenter + vtNor * (dThick * 0.5 + 10);
		}
		//圆
		else
		{
			double dMinDiffAng = PI/12;
			GetGlobalContext()->GetAt(KEY_MINDIFFANG,dMinDiffAng);
			int nSect = int(PI * 2 / dMinDiffAng) + 1;
			AcGePoint3dArray arptSides,arptSidesD;
			AcGePoint3d pt;
			double dDiameter(50.0);
			double dLength(50.0);
			AcGeVector3d vtMain;
			m_pXDataMap->GetAt(HVLV_Diameter, dDiameter);
			m_pXDataMap->GetAt(HVLV_Length, dLength);

			//BEGIN=================================================
			if (dLength < 2.e-4)
			{
				dLength = 2.e-4;
			}
			//END===================================================

			m_pXDataMap->GetAt(HVLV_MainDir, vtMain);
			dLength *= 500;
			dDiameter *= 1000;
			vtMain.normalize();
			AcGePoint3d ptC;
			ptC = ptCenter + vtMain * dLength * 0.5;
			pt = ptC + vtNor * dDiameter * 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 * dDiameter * 0.5;
			for (i = 0; i < nSect; i++)
			{
				arptSides.append(pt);	
				pt.rotateBy(dMinDiffAng, vtMain, ptC);
			}

			mode.DrawMesh(2, nSect, arptSides.asArrayPtr());
		}
	}
	return Acad::eOk;
}

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

AcGePoint3d THImpHvacValve::GetStartPt() const
{
	ASSERT(NULL != m_pXDataMap);
	// 获取各点位置
	AcGePoint3d ptCenter;
	AcGeVector3d vtMain;
	double dLength(50.0),dOLength(500.0);
	m_pXDataMap->GetAt(HVLV_MainDir, vtMain);
	m_pXDataMap->GetAt(HVLV_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HVLV_Length, dLength);

	//BEGIN=========================================
	if (dLength < 2.e-4)
	{
		dLength = 2.e-4;
	}
	//END===========================================

	vtMain.normalize();

	dOLength = GetBlkOldLength();
	dLength *= dOLength;
	return ptCenter - vtMain * dLength * 0.5;
}

AcGePoint3d THImpHvacValve::GetEndPt() const
{
	ASSERT(NULL != m_pXDataMap);
	// 获取各点位置
	AcGePoint3d ptCenter;
	AcGeVector3d vtMain;
	double dLength(50.0),dOLength(500.0);
	AcDbObjectId id = AcDbObjectId::kNull;
	m_pXDataMap->GetAt(HVLV_MainDir, vtMain);
	m_pXDataMap->GetAt(HVLV_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HVLV_Length, dLength);

	//BEGIN=========================================
	if (dLength < 2.e-4)
	{
		dLength = 2.e-4;
	}
	//END===========================================

	vtMain.normalize();

	dOLength = GetBlkOldLength();

	dLength *= dOLength;
	return ptCenter + vtMain * dLength * 0.5;
}

AcGePoint3d THImpHvacValve::GetHandPt() const
{
	ASSERT(NULL != m_pXDataMap);
	// 获取各点位置
	AcGePoint3d ptCenter;
	AcGeVector3d vtMain;
	double dWidth(50.0);
	double dLength(50.0);
	int nType(1);
	int bMirror(0);
	m_pXDataMap->GetAt(HVLV_MainDir, vtMain);
	m_pXDataMap->GetAt(HVLV_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HVLV_Width, dWidth);
	m_pXDataMap->GetAt(HVLV_Length, dLength);
	m_pXDataMap->GetAt(HVLV_IsMirror, bMirror);
	if (nType == 1)
	{
		AcGePoint3d pt;
		vtMain.normalize();
		if (bMirror == 0)
		{
			pt = ptCenter + vtMain * dLength * 0.5;
		}
		else
		{
			pt = ptCenter - vtMain * dLength * 0.5;
		}
		vtMain.rotateBy(PI * 0.5,GetNormal());
		vtMain.normalize();
		pt = pt + vtMain * dWidth * 0.35;
		return pt;
	}
	vtMain.rotateBy(PI * 0.5,GetNormal());
	vtMain.normalize();
	return ptCenter + vtMain * dWidth * 0.5;
}

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

Acad::ErrorStatus THImpHvacValve::ExplodeOrDraw2d(XExplodeDraw &mode) const
{
	if (m_pXDataMap == NULL)
	{
		return Acad::eNotImplementedYet;
	}
	AcGePoint3d ptCenter;
	m_pXDataMap->GetAt(HVLV_CenterPoint, ptCenter);
	AcDbObjectId idCen;
	m_pXDataMap->GetAt(HVLV_PartCenter, idCen);
	int iSectType = -1;
	m_pXDataMap->GetAt(HVAC_SectType, iSectType);
	if (iSectType == TDb::eCircular)
	{
		double dTmp = 0.0;
		m_pXDataMap->GetAt(HVLV_Width, dTmp);
		m_pXDataMap->SetAt(HVLV_Thick, dTmp);
		m_pXDataMap->SetAt(HVLV_Diameter, dTmp);
	}
	DrawText(mode);
	TArchPerDocData *pDocData = GetCurDocData();
	if (NULL != pDocData)
	{
		XString &sCmd = pDocData->m_sCurCommand;
		//if (mode.IsFullExplode() || 0 == _tcsicmp(sCmd, _T("explode")))
		if (XExplodeStream::m_bExportTch4 || 0 == _tcsicmp(sCmd, _T("explode")))
		{// add by cq 2017-08-07 导出T3和炸开时 尽量少绘制实体 不走GetCurvesInSide绘制
			AcDbObjectIdArray arobjs;
			ExplodeBlock(mode,idCen,ptCenter,arobjs);
			return Acad::eNotImplementedYet;
		}
	}
	return Acad::eOk;
}
//kyf add判断是否是消声器
BOOL THImpHvacValve::IsSilencer(AcDbObjectId idBlock) const
{
	AcDbObject* pBlockEnt = NULL;
	if(Acad::eOk != acdbOpenObject(pBlockEnt, idBlock, AcDb::kForRead))
		return FALSE;
	AcDbBlockTableRecord * pBlockTableRecord = AcDbBlockTableRecord::cast(pBlockEnt);
	if(NULL == pBlockTableRecord)
	{
		pBlockEnt->close();
		return FALSE;
	}
	pBlockEnt->close();
	LPTSTR pszName = NULL;
	pBlockTableRecord->getName(pszName);
	if(NULL == pszName)
		return FALSE;

	CString sName = pszName;
	int nIndex = sName.ReverseFind(_T('$'));
	sName = sName.Mid(nIndex + 1);

	return (0 == sName.CompareNoCase(_T("00000599"))
		|| 0 == sName.CompareNoCase(_T("00000600"))
		|| 0 == sName.CompareNoCase(_T("00000606")));
}
// kyf add 
// 处理消声器超出风管边线的尺寸
Acad::ErrorStatus THImpHvacValve::ExplodeBlockSilen(XExplodeDraw &mode, AcDbObjectId idBlock,
												 AcGePoint3d ptBase, AcDbObjectIdArray& arObjs, int nType) const
{
	if (nType == 0)
	{
		AcDbObject *pBlockEnt;
		if (Acad::eOk != acdbOpenObject(pBlockEnt, idBlock, AcDb::kForRead))
			return Acad::eNotImplementedYet;
		AcDbBlockTableRecord * pBlockTableRecord = AcDbBlockTableRecord::cast(pBlockEnt);
		if (pBlockTableRecord == NULL)
		{
			pBlockEnt->close();
			return Acad::eNotImplementedYet;
		}

		AcDbBlockTableRecordIterator* pIT;
		if (Acad::eOk != pBlockTableRecord->newIterator( pIT ))
		{
			pBlockTableRecord->close();
			return Acad::eNotImplementedYet;
		}
		pBlockTableRecord->close();
		AcDbEntity* pEnt = NULL;
		AcDbObjectId idValve;
		AcGePoint3d ptHand, ptCen, ptBlockbase;
		AcDbBlockTableRecord *pBlockCen = NULL;   // cent
		AcDbBlockTableRecord *pBlockMis = NULL;   // body
		double dLineLen = 500.0;
		BOOL bValve(FALSE);
		//找到块中的阀芯
		for ( ; !pIT->done(); pIT->step()) 
		{
			if (Acad::eOk == pIT->getEntity(pEnt, AcDb::kForRead)) 
			{
				AcDbBlockReference* pblcRfr = NULL;
				pblcRfr = AcDbBlockReference::cast(pEnt);
				if (pblcRfr != NULL)
				{
					idValve = pblcRfr->blockTableRecord();
					if (acdbOpenObject(pBlockTableRecord, idValve, AcDb::kForRead) == Acad::eOk)
					{
						LPCTSTR pBlockName = NULL;
						pBlockTableRecord->getName(pBlockName);
						CString sBlockName = pBlockName;

						// 图块名类似于 00000606Cent_UP / 00000606Cent
						if(-1 != sBlockName.Find(_T('_')))
							sBlockName = sBlockName.Right(7);
						else
							sBlockName = sBlockName.Right(4);

						// cent
						if (!sBlockName.CompareNoCase(HVAC_VALVEBLOCKCEN))
						{
							pBlockCen = pBlockTableRecord;
							ptCen = pblcRfr->position();
							bValve = TRUE;
							AcDbExtents ext;
							ext.addBlockExt(pBlockCen);
							dLineLen = ext.maxPoint().y - ext.minPoint().y;
						}
						// body
						if (!sBlockName.CompareNoCase(HVAC_VALVEBLOCKMIS))
						{
							pBlockMis = pBlockTableRecord;
							ptBlockbase = pblcRfr->position();
							bValve = TRUE;
						}
						pBlockTableRecord->close();
					}
				}
				pEnt->close();
			}
		}
		delete pIT;
		//阀芯不存在则返回
		if(NULL == pBlockCen)
		{
			return Acad::eNotImplementedYet;
		}
		if (bValve)
		{
			ASSERT(NULL != m_pXDataMap);
			double dLength(50.0);
			double dWidth(50.0);
			AcGeVector3d vtMain;
			AcGeVector3d vtMainv;
			m_pXDataMap->GetAt(HVLV_Length, dLength);
			if (dLength < 2.e-4)
				dLength = 2.e-4;
			m_pXDataMap->GetAt(HVLV_Width, dWidth);
			m_pXDataMap->GetAt(HVLV_MainDir, vtMain);
			int bMirror(0);
			m_pXDataMap->GetAt(HVLV_IsMirror, bMirror);
			double dAngle = AcGeVector3d::kXAxis.angleTo(vtMain,GetNormal());
			if (!(GetNormal().isParallelTo(AcGeVector3d::kZAxis)) && !(GetNormal().isPerpendicularTo(AcGeVector3d::kZAxis)))
				dAngle = AcGeVector3d::kXAxis.angleTo(vtMain.orthoProject(AcGeVector3d::kZAxis), AcGeVector3d::kZAxis);
			vtMainv = vtMain;
			vtMainv.rotateBy(PI * 0.5, GetNormal());
			vtMainv.normalize();
			double dSize = 100.0;
			m_pXDataMap->GetAt(HVLV_SilAddLen, dSize);
			// 计算阀门实际高度
			double dRealHeight = 1000 * dWidth;
			//等比缩放按照最小的比例来缩放
			double dScale = dLength;
			if (dLength > dWidth)
				dScale = dWidth;
			double dScaler = dRealHeight + dSize * 2;
			dScaler /= dLineLen;
			//AcGeScale3d scale(dLength, dScaler , 1);
			AcGeScale3d scale(dLength, dScaler , -1);// modify by cq 2016-06-29 多页阀门绘制与预览相反
			AcGeScale3d scale1(dLength, dWidth, 1);
			AcGeMatrix3d mat;
			AcGePoint3d ptC,ptH;
			ptC = ptBase;
			// change by zh 2013-5-13
			//if (1 == bMirror)
			//	scale[0] *= -1;
			int nReverseX(0), nReverseY(0);
			m_pXDataMap->GetAt(HVLV_IsReverseX, nReverseX);
			m_pXDataMap->GetAt(HVLV_IsReverseY, nReverseY);
			if ((1 == bMirror) ^ (1 == nReverseX) ^ (nReverseY == 1))
				scale[0] *= -1;
			//
			//阀芯
			if (pBlockCen != NULL)
				mode.DrawBlock(*pBlockCen, ptC, scale, dAngle, TRUE);
			//其它非等比缩放的
			if (pBlockMis != NULL)
			{
				//if (1 == bMirror) // change by zh 2013-5-13
				if ((1 == bMirror) ^ (1 == nReverseX) ^ (nReverseY == 1))
				{
					scale1.set(-dLength, dWidth, 1);
				}
				DelLabelText(pBlockMis);
				mode.DrawBlock(*pBlockMis, ptBase, scale1, dAngle, TRUE);
			}

		}
	}
	return Acad::eOk;
}
Acad::ErrorStatus THImpHvacValve::ExplodeBlock(XExplodeDraw &mode, AcDbObjectId idBlock, AcGePoint3d ptBase, AcDbObjectIdArray& arObjs, int nType) const
{
	// add by hh 2011-08-08 处理多叶阀等动态增减叶片数量的阀门
	if(IsMultibladeValve(idBlock))
	{
		Acad::ErrorStatus es = ExplodeBlockEx(mode, idBlock, ptBase, arObjs, nType);
		if(Acad::eOk == es) // 绘制成功时，直接返回，否则仍调用普通阀门的绘制
			return es;
	}
	// add end

	// add by kyf 绘制消声器
	if (IsSilencer(idBlock))
	{
		Acad::ErrorStatus es = ExplodeBlockSilen(mode, idBlock, ptBase, arObjs, nType);
		if (Acad::eOk == es)// 绘制成功时，直接返回
			return es;
	}
	// add end

	if (nType == 0)
	{
		AcDbObject *pBlockEnt;
		if (acdbOpenObject(pBlockEnt, idBlock, AcDb::kForRead) != Acad::eOk)
			return Acad::eNotImplementedYet;
		AcDbBlockTableRecord * pBlockTableRecord = AcDbBlockTableRecord::cast(pBlockEnt);
		if (pBlockTableRecord == NULL)
		{
			pBlockEnt->close();
			return Acad::eNotImplementedYet;
		}
		pBlockEnt->close();
		AcDbBlockTableRecordIterator* pIT;
		if (Acad::eOk != pBlockTableRecord->newIterator( pIT ))
		{
			pBlockTableRecord->close();
			return Acad::eNotImplementedYet;
		}
		pBlockTableRecord->close();

		AcDbEntity* pEnt = NULL;
		AcDbObjectId idValve;
		AcGePoint3d ptHand, ptCen, ptBlockbase;
		AcDbBlockTableRecord *pBlockCen = NULL;
		AcDbBlockTableRecord *pBlockHan = NULL;
		AcDbBlockTableRecord *pBlockMis = NULL;
		BOOL bValve(FALSE);
		//找到块中的阀芯等引用
		for ( ; !pIT->done(); pIT->step()) 
		{
			if (Acad::eOk == pIT->getEntity(pEnt, AcDb::kForRead)) 
			{
				AcDbBlockReference* pblcRfr = NULL;
				pblcRfr = AcDbBlockReference::cast(pEnt);
				if (pblcRfr != NULL)
				{
					idValve = pblcRfr->blockTableRecord();
					if (acdbOpenObject(pBlockTableRecord, idValve, AcDb::kForRead) == Acad::eOk)
					{
						LPCTSTR pBlockName = NULL;
						pBlockTableRecord->getName(pBlockName);
						CString sBlockName;
						sBlockName = pBlockName;
						sBlockName = sBlockName.Right(4);
						//阀芯
						if (!sBlockName.CompareNoCase(HVAC_VALVEBLOCKCEN))
						{
							pBlockCen = pBlockTableRecord;
							ptCen = pblcRfr->position();
							bValve = TRUE;
						}
						//手柄
						if (!sBlockName.CompareNoCase(HVAC_VALVEBLOCKHAN))
						{
							pBlockHan = pBlockTableRecord;
							ptHand = pblcRfr->position();
							bValve = TRUE;
						}
						//其它非等比
						if (!sBlockName.CompareNoCase(HVAC_VALVEBLOCKMIS))
						{
							pBlockMis = pBlockTableRecord;
							ptBlockbase = pblcRfr->position();
							bValve = TRUE;
						}
						pBlockTableRecord->close();
					}
				}
				pEnt->close();
			}
		}
		delete pIT;
		if (bValve)
		{
			ASSERT(NULL != m_pXDataMap);
			double dLength(50.0);
			double dWidth(50.0);
			AcGeVector3d vtMain;
			AcGeVector3d vtMainv;
			m_pXDataMap->GetAt(HVLV_Length, dLength);

			//BEGIN=================================================
			if (dLength < 2.e-4)
			{
				dLength = 2.e-4;
			}
			//END===================================================

			m_pXDataMap->GetAt(HVLV_Width, dWidth);
			m_pXDataMap->GetAt(HVLV_MainDir, vtMain);
			int bMirror(0);
			m_pXDataMap->GetAt(HVLV_IsMirror, bMirror);
			
			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);

			vtMainv = vtMain;
			vtMainv.rotateBy(PI * 0.5, GetNormal());
			vtMainv.normalize();
	//		dLength *= 2.0;
			double dScale = dLength;
			double dOff = dLength - dWidth;
			//等比缩放按照最小的比例来缩放
			if (dLength > dWidth)
			{
				dScale = dWidth;
			}

			AcGeScale3d	scale(dScale, dScale, 1);
			AcGeScale3d	scale1(dLength, dWidth, 1);
			AcGeMatrix3d mat;
			AcGePoint3d ptC,ptH;
			ptC = ptBase;
			// change by zh 2013-5-13
			//if (1 == bMirror)
			//{
			//	scale.set(-dScale, dScale, 1);
			//}
			int nReverseX(0), nReverseY(0);
			m_pXDataMap->GetAt(HVLV_IsReverseX, nReverseX);
			m_pXDataMap->GetAt(HVLV_IsReverseY, nReverseY);
			if ((1 == bMirror) ^ (1 == nReverseX) ^ (nReverseY == 1))
				scale.set(-dScale, dScale, 1);
			//
			//阀芯
			if (pBlockCen != NULL)
				mode.DrawBlock(*pBlockCen, ptC, scale, dAngle, TRUE);
			//其它非等比缩放的
			if (pBlockMis != NULL)
			{
				//if (1 == bMirror) // change by zh 2013-5-13
				if ((1 == bMirror) ^ (1 == nReverseX) ^ (nReverseY == 1))
				{
					scale1.set(-dLength, dWidth, 1);
				}
				DelLabelText(pBlockMis);
				mode.DrawBlock(*pBlockMis, ptBase, scale1, dAngle, TRUE);
			}
			//手柄
			if (pBlockHan != NULL)
			{
				AcGeVector3d vt;
				if (dLength > dWidth)
				{
					dOff = fabs(dOff) * 0.25 * 500;//由于Length乘2，所以这里应该除2
					if(fabs(ptHand.x) < 1.e-3)
						dOff = 0;
					else if (ptHand.x < -1.e-3)
						dOff *= -1;
					vt.set(dOff,0,0);
				}
				else
				{
					dOff = fabs(dOff) * 0.5 * 1000;//正常
					if(fabs(ptHand.y) < 1.e-3)
						dOff = 0;
					else if (ptHand.y < -1.e-3)
						dOff *= -1;
					vt.set(0,dOff,0);
				}

				ptHand.set(ptHand.x - ptBlockbase.x, ptHand.y - ptBlockbase.y,0);
				ptHand *= dScale;

				ptHand += vt;
				ptHand += ptBase.asVector();
				
				mat.setToRotation(dAngle, GetNormal(), ptBase);
				ptHand.transformBy(mat);
				
				if (bMirror == 1)
				{
					AcGeLine3d line(ptBase,ptBase + vtMainv * 10);
					mat.setToMirroring(line);
					ptHand.transformBy(mat);
				}
				mode.DrawBlock(*pBlockHan, ptHand, scale, dAngle, TRUE);
			}
		}
		else
		{
			AcDbObject * pObj;
			XPoint xpoint = ptBase;
			if (acdbOpenObject(pObj, idBlock, AcDb::kForRead) != Acad::eOk)
				return Acad::eNotImplementedYet;
			AcDbBlockTableRecord * pBlock = AcDbBlockTableRecord::cast(pObj);
			if (pBlock == NULL)
			{
				pObj->close();
				return Acad::eNotImplementedYet;
			}
			AcGeScale3d	scale(1, 1, 1);
			ASSERT(NULL != m_pXDataMap);
			double dLength(50.0);
			double dWidth(50.0);
			double dThick(1.0);
			AcGeVector3d vtMain;
			int nMir(0),nIsDuctCap(0);
			m_pXDataMap->GetAt(HVLV_Length, dLength);
			m_pXDataMap->GetAt(HVLV_Width, dWidth);
			m_pXDataMap->GetAt(HVLV_Thick, dThick);
			m_pXDataMap->GetAt(HVLV_MainDir, vtMain);
			m_pXDataMap->GetAt(HVLV_IsMirror, nMir);
			m_pXDataMap->GetAt(HVLV_IsDuctCap, nIsDuctCap);
			scale.set(dLength, dWidth, 1);
			// change by zh 2013-5-13
			//if (nMir == 1)
			//{
			//	scale.set(-dLength, dWidth, 1);
			//}
			int nReverseX(0), nReverseY(0);
			m_pXDataMap->GetAt(HVLV_IsReverseX, nReverseX);
			m_pXDataMap->GetAt(HVLV_IsReverseY, nReverseY);
			if ((1 == nMir) ^ (1 == nReverseX) ^ (nReverseY == 1))
				scale.set(-dLength, dWidth, 1);
			//
			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);

			if (nIsDuctCap == 2)
			{
				AcDbBlockReference blkRef;	
				blkRef.setBlockTableRecord(idBlock);
				XPoint ptIns, ptCen;
				double dSizeX(0), dSizeY(0), dSizeZ(0), dRot(0);
				GetBlockRefSizeInfo(&blkRef, ptIns, &dRot, ptCen, &dSizeX, &dSizeY, &dSizeZ);
				if (dThick < 1)
					dThick = 1;
				if (dSizeZ < 1)
				{
					dSizeZ = dThick;
				}
				scale.set(dLength / 500, dLength / 500, dThick / dSizeZ);
			}
			mode.DrawBlock(*pBlock, xpoint, scale, dAngle, TRUE);
			pObj->close();
		}
	}
	else
	{
		AcDbObject * pObj;
		XPoint xpoint = ptBase;
		if (acdbOpenObject(pObj, idBlock, AcDb::kForRead) != Acad::eOk)
			return Acad::eNotImplementedYet;
		AcDbBlockTableRecord * pBlock = AcDbBlockTableRecord::cast(pObj);
		if (pBlock == NULL)
		{
			pObj->close();
			return Acad::eNotImplementedYet;
		}
		AcGeScale3d	scale(1, 1, 1);
		ASSERT(NULL != m_pXDataMap);
		double dLength(50.0);
		double dWidth(50.0);
		double dThick(1.0);
		AcGeVector3d vtMain;
		int nMir(0),nIsDuctCap(0);
		m_pXDataMap->GetAt(HVLV_Length, dLength);

		//BEGIN=================================================
		if (dLength < 2.e-4)
		{
			dLength = 2.e-4;
		}
		//END===================================================

		m_pXDataMap->GetAt(HVLV_Width, dWidth);
		m_pXDataMap->GetAt(HVLV_Thick, dThick);
		m_pXDataMap->GetAt(HVLV_MainDir, vtMain);
		m_pXDataMap->GetAt(HVLV_IsMirror, nMir);
		m_pXDataMap->GetAt(HVLV_IsDuctCap, nIsDuctCap);
		scale.set(dLength, dWidth, 1);
		// change by zh 2013-5-13
		//if (nMir == 1)
		//{
		//	scale.set(-dLength, dWidth, 1);
		//}
		int nReverseX(0), nReverseY(0);
		m_pXDataMap->GetAt(HVLV_IsReverseX, nReverseX);
		m_pXDataMap->GetAt(HVLV_IsReverseY, nReverseY);
		if ((1 == nMir) ^ (1 == nReverseX) ^ (nReverseY == 1))
			scale.set(-dLength, dWidth, 1);
		//
		double dAngle = AcGeVector3d::kXAxis.angleTo(vtMain,GetNormal());
		// 倾斜布置阀门，主向量须向XY平面投影,计算出来的图块旋转角度才会准确
		if (!(GetNormal().isParallelTo(AcGeVector3d::kZAxis)) && !(GetNormal().isPerpendicularTo(AcGeVector3d::kZAxis)))
			dAngle = AcGeVector3d::kXAxis.angleTo(vtMain.orthoProject(AcGeVector3d::kZAxis),GetNormal());

		if (nIsDuctCap == 2)
		{
			AcDbBlockReference blkRef;	
			blkRef.setBlockTableRecord(idBlock);
			XPoint ptIns, ptCen;
			double dSizeX(0), dSizeY(0), dSizeZ(0), dRot(0);
			GetBlockRefSizeInfo(&blkRef, ptIns, &dRot, ptCen, &dSizeX, &dSizeY, &dSizeZ);
			if (dThick < 1)
				dThick = 1;
			if (dSizeZ < 1)
			{
				dSizeZ = dThick;
			}
			scale.set(dLength / 500, dLength / 500, dThick / dSizeZ);
		}
		mode.DrawBlock(*pBlock, xpoint, scale, dAngle, TRUE);
		pObj->close();
	}

	return Acad::eOk;
}

// 判断是否多叶阀
BOOL THImpHvacValve::IsMultibladeValve(AcDbObjectId idBlock) const
{
	AcDbObject* pBlockEnt = NULL;
	if(Acad::eOk != acdbOpenObject(pBlockEnt, idBlock, AcDb::kForRead))
		return FALSE;

	AcDbBlockTableRecord * pBlockTableRecord = AcDbBlockTableRecord::cast(pBlockEnt);
	if(NULL == pBlockTableRecord)
	{
		pBlockEnt->close();
		return FALSE;
	}
	pBlockEnt->close();

	LPTSTR pszName = NULL;
	pBlockTableRecord->getName(pszName);
	if(NULL == pszName)
		return FALSE;

	CString sName = pszName;
	int nIndex = sName.ReverseFind(_T('$'));
	sName = sName.Mid(nIndex + 1);

	return (0 == sName.CompareNoCase(_T("00000556"))
		|| 0 == sName.CompareNoCase(_T("00000557"))
		|| 0 == sName.CompareNoCase(_T("00000558"))
		|| 0 == sName.CompareNoCase(_T("00000561"))
		|| 0 == sName.CompareNoCase(_T("00000562"))
		|| 0 == sName.CompareNoCase(_T("00000563")));
}

// 处理多叶阀等动态增减叶片数量的阀门
Acad::ErrorStatus THImpHvacValve::ExplodeBlockEx(XExplodeDraw &mode, AcDbObjectId idBlock,
												 AcGePoint3d ptBase, AcDbObjectIdArray& arObjs, int nType) const
{
	if (nType == 0)
	{
		AcDbObject *pBlockEnt;
		if (acdbOpenObject(pBlockEnt, idBlock, AcDb::kForRead) != Acad::eOk)
			return Acad::eNotImplementedYet;
		AcDbBlockTableRecord * pBlockTableRecord = AcDbBlockTableRecord::cast(pBlockEnt);
		if (pBlockTableRecord == NULL)
		{
			pBlockEnt->close();
			return Acad::eNotImplementedYet;
		}
		pBlockEnt->close();

		AcDbBlockTableRecordIterator* pIT;
		if (Acad::eOk != pBlockTableRecord->newIterator( pIT ))
		{
			pBlockTableRecord->close();
			return Acad::eNotImplementedYet;
		}
		pBlockTableRecord->close();

		AcDbEntity* pEnt = NULL;
		AcDbObjectId idValve;
		AcGePoint3d ptHand, ptCen, ptCenUp, ptCenDn, ptBlockbase;
		AcDbBlockTableRecord *pBlockCen = NULL;   // 阀芯
		AcDbBlockTableRecord *pBlockCenUp = NULL; // 阀芯(上)
		AcDbBlockTableRecord *pBlockCenDn = NULL; // 阀芯(下)
		AcDbBlockTableRecord *pBlockHan = NULL;   // 手柄
		AcDbBlockTableRecord *pBlockMis = NULL;   // 其他
		double dLineLen = 500;
		BOOL bValve(FALSE);
		//找到块中的阀芯等引用
		for ( ; !pIT->done(); pIT->step()) 
		{
			if (Acad::eOk == pIT->getEntity(pEnt, AcDb::kForRead)) 
			{
				AcDbBlockReference* pblcRfr = NULL;
				pblcRfr = AcDbBlockReference::cast(pEnt);
				if (pblcRfr != NULL)
				{
					idValve = pblcRfr->blockTableRecord();
					if (acdbOpenObject(pBlockTableRecord, idValve, AcDb::kForRead) == Acad::eOk)
					{
						LPCTSTR pBlockName = NULL;
						pBlockTableRecord->getName(pBlockName);
						CString sBlockName = pBlockName;
						if(-1 != sBlockName.Find(_T('_')))
							sBlockName = sBlockName.Right(7);
						else
							sBlockName = sBlockName.Right(4);
						// 阀芯
						if (!sBlockName.CompareNoCase(HVAC_VALVEBLOCKCEN))
						{
							pBlockCen = pBlockTableRecord;
							ptCen = pblcRfr->position();
							bValve = TRUE;
							AcDbExtents ext;
							ext.addBlockExt(pBlockCen);
							dLineLen = ext.maxPoint().y - ext.minPoint().y;
						}
						// 阀芯(上)
						if (!sBlockName.CompareNoCase(HVAC_VALVEBLOCKCEN_UP))
						{
							pBlockCenUp = pBlockTableRecord;
							ptCenUp = pblcRfr->position();
							bValve = TRUE;
						}
						// 阀芯(下)
						if (!sBlockName.CompareNoCase(HVAC_VALVEBLOCKCEN_DN))
						{
							pBlockCenDn = pBlockTableRecord;
							ptCenDn = pblcRfr->position();
							bValve = TRUE;
						}
						// 手柄
						if (!sBlockName.CompareNoCase(HVAC_VALVEBLOCKHAN))
						{
							pBlockHan = pBlockTableRecord;
							ptHand = pblcRfr->position();
							bValve = TRUE;
						}
						// 其它非等比
						if (!sBlockName.CompareNoCase(HVAC_VALVEBLOCKMIS))
						{
							pBlockMis = pBlockTableRecord;
							ptBlockbase = pblcRfr->position();
							bValve = TRUE;
						}
						pBlockTableRecord->close();
					}
				}
				pEnt->close();
			}
		}
		delete pIT;

		// 上下阀芯同时存在时，才进行绘制
		if(NULL == pBlockCenDn || NULL == pBlockCenUp)
		{
			return Acad::eNotImplementedYet;
		}

		if (bValve)
		{
			ASSERT(NULL != m_pXDataMap);
			double dLength(50.0);
			double dWidth(50.0);
			AcGeVector3d vtMain;
			AcGeVector3d vtMainv;
			m_pXDataMap->GetAt(HVLV_Length, dLength);

			if (dLength < 2.e-4)
				dLength = 2.e-4;

			m_pXDataMap->GetAt(HVLV_Width, dWidth);
			m_pXDataMap->GetAt(HVLV_MainDir, vtMain);
			int bMirror(0);
			m_pXDataMap->GetAt(HVLV_IsMirror, bMirror);
			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);
			}
			vtMainv = vtMain;
			vtMainv.rotateBy(PI * 0.5, GetNormal());
			vtMainv.normalize();
			double dScale = dLength;
			double dOff = dLength - dWidth;
			//等比缩放按照最小的比例来缩放
			if (dLength > dWidth)
				dScale = dWidth;

			//AcGeScale3d scale(-dScale, dScale, 1);
			AcGeScale3d scale(-dScale, dScale, 1); // cq 2016-06-14 绘制与实际相反
			AcGeScale3d scale1(dLength, dWidth, 1);
			AcGeMatrix3d mat;
			AcGePoint3d ptC,ptH;
			ptC = ptBase;
			// change by zh 2013-5-13
			//if (1 == bMirror)
			//	scale.set(-dScale, dScale, 1);
			int nReverseX(0), nReverseY(0);
			m_pXDataMap->GetAt(HVLV_IsReverseX, nReverseX);
			m_pXDataMap->GetAt(HVLV_IsReverseY, nReverseY);
			// modify begin
// 			if ((1 == bMirror) ^ (1 == nReverseX) ^ (nReverseY == 1))
// 				scale.set(-dScale, dScale, 1);
			if (1 == bMirror)
				scale[0] *= (-1);
			if (1 == nReverseX)
				scale[0] *= (-1);
			// modify end by cq 2016-06-14 绘制与实际相反
			//阀芯
			double dCenLen = ptCenUp.distanceTo(ptCenDn);
			double dCenLenHalf = dCenLen / 2.0;
			if(1 > dWidth)
				dCenLenHalf *= dWidth;
			ptCenUp = ptC + vtMainv * dCenLenHalf;
			ptCenDn = ptC - vtMainv * dCenLenHalf;

			// 计算阀门实际高度
			double dRealHeight = 1000 * dWidth;

			// 计算能够绘制的阀芯数量
			// change by hh 2012-07-23 高度增加0.5 避免因误差造成数量变化
			// int nNum = (int)(dRealHeight / dCenLen);
			int nNum = (int)((dRealHeight + 0.5) / dCenLen);
// 			if(0 >= nNum)
// 				nNum = 1; // 最少绘制一个
// 
// 			// 计算阀芯的插入点
// 			AcGePoint3d ptFirst = ptC + vtMainv * (dCenLen * nNum / 2 - dCenLen / 2);
// 			AcGePoint3d ptIns = ptFirst;
// 			for(int k = 0; k < nNum; k++)
// 			{
// 				ptIns = ptFirst - vtMainv * (dCenLen * k);
// 				if(k % 2)
// 					mode.DrawBlock(*pBlockCenUp, ptIns, scale, dAngle, TRUE);
// 				else
// 					mode.DrawBlock(*pBlockCenDn, ptIns, scale, dAngle, TRUE);
// 			}
			// 计算阀芯的插入点
			AcGePoint3d ptFirst = ptC + vtMainv * (dCenLen * nNum / 2 - dCenLen / 2);
			AcGePoint3d ptIns = ptFirst;

			if(1 >= nNum)
			{
				// 最少绘制2个
				mode.DrawBlock(*pBlockCenUp, ptCenUp, scale, dAngle, TRUE);
				mode.DrawBlock(*pBlockCenDn, ptCenDn, scale, dAngle, TRUE);
				ptFirst = ptCenUp;
				ptIns = ptCenDn;
			}
			else
			{
				for(int k = 0; k < nNum; k++)
				{
					ptIns = ptFirst - vtMainv * (dCenLen * k);
					if(k % 2)
						mode.DrawBlock(*pBlockCenUp, ptIns, scale, dAngle, TRUE);
					else
						mode.DrawBlock(*pBlockCenDn, ptIns, scale, dAngle, TRUE);
				}
			}

			// 绘制中心直线
			if(NULL != pBlockCen)
			{
				AcGeScale3d scTemp = scale;
				scTemp[Y]= ptFirst.distanceTo(ptIns) / dLineLen;
				mode.DrawBlock(*pBlockCen, ptC, scTemp, dAngle, TRUE);
			}

			//其它非等比缩放的
			if (pBlockMis != NULL)
			{
				//if (1 == bMirror) // change by zh 2013-5-13
				if ((1 == bMirror) ^ (1 == nReverseX) ^ (nReverseY == 1))
				{
					scale1.set(-dLength, dWidth, 1);
				}
				DelLabelText(pBlockMis);
				mode.DrawBlock(*pBlockMis, ptBase, scale1, dAngle, TRUE);
			}
			//手柄
			if (pBlockHan != NULL)
			{
				AcGeVector3d vt;
				if (dLength > dWidth)
				{
					dOff = fabs(dOff) * 0.25 * 500;//由于Length乘2，所以这里应该除2
					if(fabs(ptHand.x) < 1.e-3)
						dOff = 0;
					else if (ptHand.x < -1.e-3)
						dOff *= -1;
					vt.set(dOff,0,0);
				}
				else
				{
					dOff = fabs(dOff) * 0.5 * 1000;//正常
					if(fabs(ptHand.y) < 1.e-3)
						dOff = 0;
					else if (ptHand.y < -1.e-3)
						dOff *= -1;
					vt.set(0,dOff,0);
				}

				ptHand.set(ptHand.x - ptBlockbase.x, ptHand.y - ptBlockbase.y,0);
				ptHand *= dScale;

				ptHand += vt;
				ptHand += ptBase.asVector();

				mat.setToRotation(dAngle, GetNormal(), ptBase);
				ptHand.transformBy(mat);

				if (bMirror == 1)
				{
					AcGeLine3d line(ptBase,ptBase + vtMainv * 10);
					mat.setToMirroring(line);
					ptHand.transformBy(mat);
				}
				mode.DrawBlock(*pBlockHan, ptHand, scale, dAngle, TRUE);
			}
		}
		else
		{
			AcDbObject * pObj;
			XPoint xpoint = ptBase;
			if (acdbOpenObject(pObj, idBlock, AcDb::kForRead) != Acad::eOk)
				return Acad::eNotImplementedYet;
			AcDbBlockTableRecord * pBlock = AcDbBlockTableRecord::cast(pObj);
			if (pBlock == NULL)
			{
				pObj->close();
				return Acad::eNotImplementedYet;
			}
			AcGeScale3d	scale(1, 1, 1);
			ASSERT(NULL != m_pXDataMap);
			double dLength(50.0);
			double dWidth(50.0);
			double dThick(1.0);
			AcGeVector3d vtMain;
			int nMir(0),nIsDuctCap(0);
			m_pXDataMap->GetAt(HVLV_Length, dLength);
			m_pXDataMap->GetAt(HVLV_Width, dWidth);
			m_pXDataMap->GetAt(HVLV_Thick, dThick);
			m_pXDataMap->GetAt(HVLV_MainDir, vtMain);
			m_pXDataMap->GetAt(HVLV_IsMirror, nMir);
			m_pXDataMap->GetAt(HVLV_IsDuctCap, nIsDuctCap);
			scale.set(dLength, dWidth, 1);

			// change by zh 2013-5-13
			//if (nMir == 1)
			//{
			//	scale.set(-dLength, dWidth, 1);
			//}
			int nReverseX(0), nReverseY(0);
			m_pXDataMap->GetAt(HVLV_IsReverseX, nReverseX);
			m_pXDataMap->GetAt(HVLV_IsReverseY, nReverseY);
			if ((1 == nMir) ^ (1 == nReverseX) ^ (nReverseY == 1))
				scale.set(-dLength, dWidth, 1);
			//
			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);

			if (nIsDuctCap == 2)
			{
				AcDbBlockReference blkRef;	
				blkRef.setBlockTableRecord(idBlock);
				XPoint ptIns, ptCen;
				double dSizeX(0), dSizeY(0), dSizeZ(0), dRot(0);
				GetBlockRefSizeInfo(&blkRef, ptIns, &dRot, ptCen, &dSizeX, &dSizeY, &dSizeZ);
				if (dThick < 1)
					dThick = 1;
				if (dSizeZ < 1)
				{
					dSizeZ = dThick;
				}
				scale.set(dLength / 500, dLength / 500, dThick / dSizeZ);
			}
			mode.DrawBlock(*pBlock, xpoint, scale, dAngle, TRUE);
			pObj->close();
		}
	}
	else
	{
		AcDbObject * pObj;
		XPoint xpoint = ptBase;
		if (acdbOpenObject(pObj, idBlock, AcDb::kForRead) != Acad::eOk)
			return Acad::eNotImplementedYet;
		AcDbBlockTableRecord * pBlock = AcDbBlockTableRecord::cast(pObj);
		if (pBlock == NULL)
		{
			pObj->close();
			return Acad::eNotImplementedYet;
		}
		AcGeScale3d	scale(1, 1, 1);
		ASSERT(NULL != m_pXDataMap);
		double dLength(50.0);
		double dWidth(50.0);
		double dThick(1.0);
		AcGeVector3d vtMain;
		int nMir(0),nIsDuctCap(0);
		m_pXDataMap->GetAt(HVLV_Length, dLength);

		if (dLength < 2.e-4)
		{
			dLength = 2.e-4;
		}

		m_pXDataMap->GetAt(HVLV_Width, dWidth);
		m_pXDataMap->GetAt(HVLV_Thick, dThick);
		m_pXDataMap->GetAt(HVLV_MainDir, vtMain);
		m_pXDataMap->GetAt(HVLV_IsMirror, nMir);
		m_pXDataMap->GetAt(HVLV_IsDuctCap, nIsDuctCap);
		scale.set(dLength, dWidth, 1);
		// change by zh 2013-5-13
		//if (nMir == 1)
		//{
		//	scale.set(-dLength, dWidth, 1);
		//}
		int nReverseX(0), nReverseY(0);
		m_pXDataMap->GetAt(HVLV_IsReverseX, nReverseX);
		m_pXDataMap->GetAt(HVLV_IsReverseY, nReverseY);
		if ((1 == nMir) ^ (1 == nReverseX) ^ (nReverseY == 1))
			scale.set(-dLength, dWidth, 1);
		//
		
		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);

		if (nIsDuctCap == 2)
		{
			AcDbBlockReference blkRef;	
			blkRef.setBlockTableRecord(idBlock);
			XPoint ptIns, ptCen;
			double dSizeX(0), dSizeY(0), dSizeZ(0), dRot(0);
			GetBlockRefSizeInfo(&blkRef, ptIns, &dRot, ptCen, &dSizeX, &dSizeY, &dSizeZ);
			if (dThick < 1)
				dThick = 1;
			if (dSizeZ < 1)
			{
				dSizeZ = dThick;
			}
			scale.set(dLength / 500, dLength / 500, dThick / dSizeZ);
		}
		mode.DrawBlock(*pBlock, xpoint, scale, dAngle, TRUE);
		pObj->close();
	}

	return Acad::eOk;
}

void THImpHvacValve::DrawText(XExplodeDraw &mode) const
{
	ASSERT(NULL != m_pXDataMap);
	double dLength(50.0);
	double dWidth(50.0),dTextHeight(100.0),dangle(0.0);
	AcGeVector3d vtMain;
	int nMir(0);
	CString sLabel,sDim,sCode;
	AcGePoint3d ptCenter;
	AcDbObjectId idDimLayer,idDimStyle;
	m_pXDataMap->GetAt(HVLV_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HVLV_Length, dLength);
	m_pXDataMap->GetAt(HVLV_Width, dWidth);
	m_pXDataMap->GetAt(HVLV_MainDir, vtMain);
	m_pXDataMap->GetAt(HVLV_IsMirror, nMir);
	m_pXDataMap->GetAt(HVLV_LabelText, sLabel);
	m_pXDataMap->GetAt(HVLV_DimText, sDim);
	m_pXDataMap->GetAt(HVLV_CodeText, sCode);
	m_pXDataMap->GetAt(HDIM_DimLayer, idDimLayer);
	m_pXDataMap->GetAt(HDIM_DimTextId, idDimStyle);
	m_pXDataMap->GetAt(HDIM_DimTextHeigh, dTextHeight);
	m_pXDataMap->GetAt(HDIM_DimTextAngle, dangle);
	
	int nColorIndexOld = mode.GetColor();
	mode.SetColor(kColorByLayer);
	if (!sLabel.IsEmpty())
	{
		TDbText* pText = new TDbText;
		AcGePoint3d ptLabel;
		m_pXDataMap->GetAt(HVLV_LabelPoint, ptLabel);
		pText->SetText(sLabel);
		pText->setLayer(idDimLayer);
		//	pText->setColorIndex(255);
		pText->SetStyleId(idDimStyle);
		pText->SetHeight(dTextHeight);
		pText->SetLocation(ptLabel);
		pText->SetRotation(dangle);
		pText->SetAlignment(XExplodeDraw::kMiddleCenter);
		pText->setPropertiesFrom(m_pOwnerEnt);
		pText->ExplodeOrDraw2d(mode);
		delete pText;
		
// 		mode.SetAlignment(XExplodeDraw::kMiddleCenter);
// 		mode.SetLocation(ptLabel);
// 		mode.SetHeight(dTextHeight);
// 		mode.SetStyle(idDimStyle);
// 		mode.SetLayer(idDimLayer);
// 		mode.SetRotation(dangle);
// 		mode.DrawText(sLabel);
	}
	if (!sDim.IsEmpty())
	{
		TDbText* pTextDim = new TDbText;
		AcGePoint3d ptDim;
		m_pXDataMap->GetAt(HVLV_DimPoint, ptDim);
		pTextDim->SetText(sDim);
		pTextDim->setLayer(idDimLayer);
		//	pTextDim->setColorIndex(255);
		pTextDim->SetStyleId(idDimStyle);
		pTextDim->SetHeight(dTextHeight);
		pTextDim->SetLocation(ptDim);
		pTextDim->SetRotation(dangle);
		pTextDim->SetAlignment(XExplodeDraw::kMiddleCenter);
		pTextDim->setPropertiesFrom(m_pOwnerEnt);
		pTextDim->ExplodeOrDraw2d(mode);
		delete pTextDim;

// 		AcGePoint3d ptDim;
// 		m_pXDataMap->GetAt(HVLV_DimPoint, ptDim);
// 		mode.SetAlignment(XExplodeDraw::kMiddleCenter);
// 		mode.SetLocation(ptDim);
// 		mode.SetHeight(dTextHeight);
// 		mode.SetStyle(idDimStyle);
// 		mode.SetLayer(idDimLayer);
// 		mode.SetRotation(dangle);
// 		mode.DrawText(sDim);
	}
	// add by hh 2013-08-29 阀门代号
	if(!sCode.IsEmpty())
	{
		TDbText* pTextDim = new TDbText;
		AcGePoint3d ptCode;
		m_pXDataMap->GetAt(HVLV_CodePoint, ptCode);
		pTextDim->SetText(sCode);
		pTextDim->setLayer(idDimLayer);
		pTextDim->SetStyleId(idDimStyle);
		pTextDim->SetHeight(dTextHeight);
		pTextDim->SetLocation(ptCode);
		pTextDim->SetRotation(dangle);
		pTextDim->SetAlignment(XExplodeDraw::kMiddleCenter);
		pTextDim->setPropertiesFrom(m_pOwnerEnt);
		pTextDim->ExplodeOrDraw2d(mode);
		delete pTextDim;
	}
	mode.SetColor(nColorIndexOld);
}

void THImpHvacValve::DelLabelText(AcDbBlockTableRecord *pBlockMis) const
{
	AcDbBlockTableRecordIterator* pIT;
	CString sLabel;
	AcDbEntity *pEnt;
// 	m_pXDataMap->GetAt(HVLV_LabelText, sLabel);
// 	//看是否有标签
// 	if (!sLabel.IsEmpty())
// 	{
		if (Acad::eOk != pBlockMis->newIterator(pIT))
		{
			return;
		}
		//找到块中的文本等引用
		for ( ; !pIT->done(); pIT->step()) 
		{
			if (Acad::eOk == pIT->getEntity(pEnt, AcDb::kForRead)) 
			{
				AcDbText *pText;
				pText = AcDbText::cast(pEnt);
				if (pText != NULL)
				{
					if(Acad::eOk == pEnt->upgradeOpen())
					{
						pEnt->setVisibility(AcDb::kInvisible);
						pEnt->downgradeOpen();
//						pEnt->close();
					}
//					delete pIT;
//					return;
					pEnt->close();
					break;
				}
				pEnt->close();
			}
		}
		delete pIT;
	//}

}

Acad::ErrorStatus THImpHvacValve::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 THImpHvacValve::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), dOLength(500.0);
	AcDbObjectId id = AcDbObjectId::kNull;
	m_pXDataMap->GetAt(HVAC_Normal, vtNor);
	m_pXDataMap->GetAt(HVLV_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HVLV_MainDir, vtMain);
	m_pXDataMap->GetAt(HVLV_Length, dLength);		
	m_pXDataMap->GetAt(HVLV_Width, dWidth);		
	m_pXDataMap->GetAt(HVLV_Thick,	dThick);

	dOLength = GetBlkOldLength();

	dLength *= dOLength;
	dWidth *= 1000;
	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 THImpHvacValve::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);
		int nSectType(0);
		m_pXDataMap->GetAt(HVLV_SEquipType, sType);
		m_pXDataMap->GetAt(HVLV_SEquipName, sName);
		m_pXDataMap->GetAt(KEY_SectType, (int&)nSectType);
		m_pXDataMap->GetAt(HVLV_CenterPoint, ptCenter);
		m_pXDataMap->GetAt(HVLV_MainDir, vtMain);
		m_pXDataMap->GetAt(HVLV_Length, dLength);		
		m_pXDataMap->GetAt(HVLV_Width, dWidth);		
		m_pXDataMap->GetAt(HVLV_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);
		if (nSectType == 0)
		{
			acutPrintf(_T("\n\t\t\t\t\t长度: %.0fmm"),dLength * 500);
			acutPrintf(_T("\n\t\t\t\t\t宽度: %.0fmm"),dWidth * 1000);
			acutPrintf(_T("\n\t\t\t\t\t高度: %.0fmm"),dThick);
			acutPrintf(_T("\n\t\t\t\t\t标高: %.0fm"),ptCenter.z * 0.001);
		}
		else
		{
			acutPrintf(_T("\n\t\t\t\t\t长度: %.0fmm"),dLength * 500);
			acutPrintf(_T("\n\t\t\t\t\t直径: %.0fmm"),dWidth * 1000);
			acutPrintf(_T("\n\t\t\t\t\t标高: %.0fm"),ptCenter.z * 0.001);
		}
	}
}

Acad::ErrorStatus THImpHvacValve::transformBy(const AcGeMatrix3d& xform)
{
	if (NULL == m_pXDataMap)
		return Acad::eNotApplicable;

	AcGeVector3d vtOff = xform.translation();
	BOOL bMoveInDuct = IsMovedWithInDuct(vtOff);
	
	// 取得位置点
	AcGePoint3d ptCenter,ptLabel,ptDim,ptCode;
	AcGeVector3d vtMain,vtRotate,vtNor;
	double dL(1.0),dW(1.0),dT(1.0),dRotate(0.0);
	m_pXDataMap->GetAt(HVLV_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HVLV_MainDir, vtMain);
	m_pXDataMap->GetAt(HVLV_Length, dL);
	m_pXDataMap->GetAt(HVLV_Width, dW);
	m_pXDataMap->GetAt(HVLV_Thick, dT);
	m_pXDataMap->GetAt(HVLV_LabelPoint, ptLabel);
	m_pXDataMap->GetAt(HVLV_DimPoint, ptDim);
	m_pXDataMap->GetAt(HVLV_CodePoint, ptCode);
	m_pXDataMap->GetAt(HDIM_DimTextAngle, dRotate);
	m_pXDataMap->GetAt(HVAC_Normal, vtNor);
	vtRotate = vtMain;
	AcGeVector3d vtPrep(vtNor.crossProduct(vtMain));
	AcGePoint3d ptOrigCenter = ptCenter;

	// 变换位置
	ptCenter.transformBy(xform);
	vtMain.transformBy(xform);
	vtNor.transformBy(xform);

	ptLabel.transformBy(xform);
	ptDim.transformBy(xform);
	ptCode.transformBy(xform);
	double dscale = xform.scale();

	vtPrep.transformBy(xform);
	// 同向是旋转，不变号，反向是镜像，变号。
	int iSign = ((vtPrep.isCodirectionalTo(vtNor.crossProduct(vtMain))) ? 1 : -1);
	if (iSign < 0)
	{
		//m_pXDataMap->SetAt(HVLV_IsMirror, 1);
		// add by zh 2013-5-13 保证镜像正确
		int bMirror(0);
		m_pXDataMap->GetAt(HVLV_IsMirror, bMirror);
		if(bMirror == 0)
			m_pXDataMap->SetAt(HVLV_IsMirror, 1);
		else if(bMirror == 1)
			m_pXDataMap->SetAt(HVLV_IsMirror, 0);
	}
	else
	{
		dRotate += vtMain.angleTo(vtRotate,-AcGeVector3d::kZAxis);
	}
	vtMain *= iSign;


	// 更新点
	m_pXDataMap->SetAt(HVAC_Normal, vtNor);
	m_pXDataMap->SetAt(HVLV_CenterPoint, ptCenter);
	m_pXDataMap->SetAt(HVLV_MainDir, vtMain);
	m_pXDataMap->SetAt(HVLV_Length, dL * dscale);
	m_pXDataMap->SetAt(HVLV_Width, dW * dscale);
	m_pXDataMap->SetAt(HVLV_Thick, dT * dscale);
	m_pXDataMap->SetAt(HVLV_LabelPoint, ptLabel);
	m_pXDataMap->SetAt(HVLV_DimPoint, ptDim);
	m_pXDataMap->SetAt(HVLV_CodePoint, ptCode);
	m_pXDataMap->SetAt(HDIM_DimTextAngle, dRotate);

	// 传递消息

	BOOL bClone(FALSE);
	m_pXDataMap->GetAt(KEY_DEEPCLONEFLAG, bClone);
	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())
		{
			BOOL bAutoCon(FALSE);
			GetGlobalContext(HVAC_AUTOCONNECT, bAutoCon);
			if (bAutoCon)
			{
				TInterfaceModifyMsg iMsg;
				TDbInterfaceMsgWrite msgWrite;
//				if (bMoveInDuct)
//				{
					// 写入接口更改消息
					iMsg.SetMsgValidate(TRUE);
					iMsg.SetTransform(xform);
					iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());
					msgWrite.WriteInterfaceMsg(iMsg);
//				}
				
				if (!bMoveInDuct && TAuxTools::IsAutoWorkConnect())
				{
					// 写入自动融合或断开新管 更改消息
					iMsg.SetMsgValidate(TRUE);
					iMsg.SetMsgPoint(ptOrigCenter);
					iMsg.SetTransform(xform);
					iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());
					iMsg.SetInterfaceOper(TDb::eAutoWorkOn);
					msgWrite.WriteInterfaceMsg(iMsg);			
				}
			}
			
			//更新接口记录接口信息
			UpdateInterfaceRec(m_pOwnerEnt->objectId(), xform);
		}
	}
	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacValve::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 THImpHvacValve::moveStretchPointsAt(const AcDbIntArray& indices,
														  const AcGeVector3d& offset)
{
	if (indices.length() < 1)
		return Acad::eNotImplementedYet;

	AcGePoint3d ptCenter, ptLabel, ptDim;
	m_pXDataMap->GetAt(HVLV_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HVLV_LabelPoint, ptLabel);
	m_pXDataMap->GetAt(HVLV_DimPoint, ptDim);
	ptCenter += offset;
	ptLabel += offset;
	ptDim += offset;
	m_pXDataMap->SetAt(HVLV_CenterPoint, ptCenter);
	m_pXDataMap->SetAt(HVLV_LabelPoint, ptLabel);
	m_pXDataMap->SetAt(HVLV_DimPoint, ptDim);

	if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
	{
		UpdateInterfaceRec(m_pOwnerEnt->objectId(), offset);
		return Acad::eOk;
	}

	return Acad::eNotImplementedYet;
}

Acad::ErrorStatus THImpHvacValve::moveGripPointsAt(const AcDbIntArray& indices,
                                   const AcGeVector3d& offset)
{
	ASSERT(NULL != m_pXDataMap);
	int nSize = indices.length();
	if (nSize > 0)
	{
		// 取得位置点
		AcGePoint3d ptCenter;
		m_pXDataMap->GetAt(HVLV_CenterPoint, ptCenter);
		AcGeVector3d vtMain;
		m_pXDataMap->GetAt(HVLV_MainDir, vtMain);
		AcGePoint3d ptLabel;
		m_pXDataMap->GetAt(HVLV_LabelPoint, ptLabel);
		AcGePoint3d ptDim;
		m_pXDataMap->GetAt(HVLV_DimPoint, ptDim);
		AcGePoint3d ptCode;
		m_pXDataMap->GetAt(HVLV_CodePoint, ptCode);
		// 选择多个夹点,以first为准
		int nIndex = indices.first();
		TDb::Position ePos = ExplainGripIndex(nIndex);
		switch(ePos)
		{
		case TDb::eStart:
		case TDb::eEnd:
		case TDb::eMid:
			{
				BOOL bMovedInDuct = IsMovedWithInDuct(offset);	// 移动是否在风管范围内
				AcGeVector3d vtMove = offset;
				ptCenter += vtMove;
				m_pXDataMap->SetAt(HVLV_CenterPoint, ptCenter);
				
				ptLabel += vtMove;
				m_pXDataMap->SetAt(HVLV_LabelPoint, ptLabel);
				ptDim += vtMove;
				m_pXDataMap->SetAt(HVLV_DimPoint, ptDim);
				ptCode += vtMove;
				m_pXDataMap->SetAt(HVLV_CodePoint, ptCode);

				if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
				{	
					BOOL bAutoCon(FALSE);
					GetGlobalContext(HVAC_AUTOCONNECT, bAutoCon);
					if (bAutoCon)
					{
						TInterfaceModifyMsg iMsg;
						TDbInterfaceMsgWrite msgWrite;
						if (bMovedInDuct)
						{
							// 写入接口更改消息
							iMsg.SetMsgPoint(ptCenter);//new pos
							iMsg.SetGripPosition(ePos);
							iMsg.SetMoveGripOffset(vtMove);
							iMsg.SetMsgValidate(TRUE);
							iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());
							msgWrite.WriteInterfaceMsg(iMsg);
						}
						else if (TAuxTools::IsAutoWorkConnect())
						{
							// 写入自动融合或断开新管 更改消息
							iMsg.SetMsgValidate(TRUE);
							iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());
							iMsg.SetTransform(offset);
							AcGeMatrix3d mat;
							mat.setTranslation(offset);
							iMsg.SetTransform(mat);
							iMsg.SetInterfaceOper(TDb::eAutoWorkOn);
							msgWrite.WriteInterfaceMsg(iMsg);			
						}
					}

					//更新接口记录接口信息
					UpdateInterfaceRec(m_pOwnerEnt->objectId(), vtMove);
				}

				break;
			}
		case TDb::eCommand0:
		case TDb::eCommand1:
			{
				// 获得夹点命令
				CString sCmdStr;
				GetGlobalContext()->GetAt(KEY_HVACGRIPCMD, sCmdStr);
				if (sCmdStr.IsEmpty())
					return Acad::eNotApplicable;
				AcGePoint3d ptCom;
				if (ePos == TDb::eCommand0)
				{
					ptCom = GetStartPt();
				}
				else
				{
					ptCom = GetEndPt();
				}
				// 写入接口更改消息
				TInterfaceModifyMsg iMsg;
				iMsg.SetMsgPoint(ptCom);//new pos
				iMsg.SetGripPosition(ePos);
				iMsg.SetMoveGripOffset(offset);
				iMsg.SetMsgValidate(TRUE);
				iMsg.SetInterfaceOper(TDb::eNewCommand);
				iMsg.SetPreviewObjToCreate(TDb::eValve, 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::eAdjust0:
			{
				AcDbIntArray OsnapMode;
				AcDbIntArray GeomId;
				AcGePoint3dArray arPts;				
				getGripPoints(arPts, OsnapMode, GeomId);
				AcGePoint3d ptAdust = arPts[5];
 				ptAdust += offset;

 				//判断方向点移动到哪个象限
				int nPos = 0;
				nPos = TAuxTools::Getquadrant(ptCenter, ptAdust, vtMain);
				switch(nPos)
				{
				case 1:
					m_pXDataMap->SetAt(HVLV_IsMirror, 0);
					break;
				case 2:
					m_pXDataMap->SetAt(HVLV_IsMirror, 1);
					break;
				case 3:
					{
						vtMain *= -1;
						m_pXDataMap->SetAt(HVLV_MainDir,vtMain);
						m_pXDataMap->SetAt(HVLV_IsMirror, 0);
					}
				    break;
				case 4:
					{
						vtMain *= -1;
						m_pXDataMap->SetAt(HVLV_MainDir,vtMain);
						m_pXDataMap->SetAt(HVLV_IsMirror, 1);
					}
				    break;
				}
				// add by hh 2011-04-07 调整接口 避免阀门换向后接口关系丢失
				if(3 == nPos || 4 == nPos)
				{
					AcDbObjectId id1, id2;
					m_pXDataMap->GetAt(KEY_IDCNT1, id1);
					m_pXDataMap->GetAt(KEY_IDCNT2, id2);
					m_pXDataMap->SetAt(KEY_IDCNT1, id2);
					m_pXDataMap->SetAt(KEY_IDCNT2, id1);
				}

				break;
			}
		case TDb::eDim0:
			{
				TDb::InterfaceOper eOper = TDb::eMoveGripPoint;
				ptCode += offset;
				m_pXDataMap->SetAt(HVLV_CodePoint, ptCode);
				break;
			}
		case TDb::eDim1:
			{
				TDb::InterfaceOper eOper = TDb::eMoveGripPoint;
				ptLabel += offset;
				m_pXDataMap->SetAt(HVLV_LabelPoint, ptLabel);
				break;
			}
		case TDb::eDim2:
			{
				TDb::InterfaceOper eOper = TDb::eMoveGripPoint;
				ptDim += offset;
				m_pXDataMap->SetAt(HVLV_DimPoint, ptDim);
				break;
			}

		default:
			break;
		}
	}
	return Acad::eOk;
}

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

	return Acad::eOk;
}

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

Acad::ErrorStatus THImpHvacValve::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(HVLV_CenterPoint, ptCenter);
	
	// 根据捕捉模式处理
	switch(osnapMode)
	{
	case AcDb::kOsModeEnd:
		snapPoints.append(GetStartPt());
		snapPoints.append(GetEndPt());
		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);

	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacValve::getGripPoints(AcGePoint3dArray& gripPoints,
                                AcDbIntArray& osnapModes,
                                AcDbIntArray& geomIds) const
{
	if (NULL == m_pXDataMap)
		return Acad::eNotApplicable;
	double dPlusEdge = 50.0, dOLength(500.0);
	// 取得位置点
	AcGeVector3d vtMain;
	AcGePoint3d ptCenter;
	double dL(1.0);
	double dW(1.0);
	int nIsDuctCap(0);
	m_pXDataMap->GetAt(HVLV_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HVLV_MainDir, vtMain);
	m_pXDataMap->GetAt(HVLV_Length, dL);
	m_pXDataMap->GetAt(HVLV_Width, dW);
	m_pXDataMap->GetAt(HVLV_IsDuctCap, nIsDuctCap);
	if (nIsDuctCap == 2)
	{
		gripPoints.append(ptCenter); //MID
		return Acad::eOk;
	}

	dOLength = GetBlkOldLength();
	dL *= dOLength;
	dW *= 1000;
	//3个移动夹点
	gripPoints.append(GetStartPt()); //STA
	gripPoints.append(GetEndPt()); //END
	gripPoints.append(ptCenter); //MID
	
	AcGePoint3d ptGeCmd1,ptGeCmd2;	
	AcGeVector3d vtMainv = vtMain;
	vtMainv.rotateBy(PI * 0.5, GetNormal());
	vtMain.normalize();
	vtMainv.normalize();

	//增加2个命令夹点
	gripPoints.append(GetStartPt() - vtMain * g_dCmdOff); //STA
	gripPoints.append(GetEndPt() + vtMain * g_dCmdOff); //END

	//添加方向夹点
	int bMirror = 0;
	int bRotate = 0;
	m_pXDataMap->GetAt(HVLV_IsMirror, bMirror);
	ptGeCmd1 = ptCenter + vtMain * dL * 0.5;
	ptGeCmd1 = ptGeCmd1 + vtMainv * dW * 0.5;
	if (bMirror == 1)
	{
		ptGeCmd1 = ptCenter - vtMain * dL * 0.5;
		ptGeCmd1 = ptGeCmd1 + vtMainv * dW * 0.5;
		//ptGeCmd1.rotateBy(PI * 0.5, GetNormal(), ptCenter);
	}
	gripPoints.append(ptGeCmd1); 
	//label点
	AcGePoint3d ptLabel;
	CString sLabel;
	m_pXDataMap->GetAt(HVLV_LabelText, sLabel);
	if (!sLabel.IsEmpty())
	{
		m_pXDataMap->GetAt(HVLV_LabelPoint, ptLabel);
		gripPoints.append(ptLabel);
	}
	//标注点
	AcGePoint3d ptDim;
	CString sDim;
	m_pXDataMap->GetAt(HVLV_DimText, sDim);
	if (!sDim.IsEmpty())
	{
		m_pXDataMap->GetAt(HVLV_DimPoint, ptDim);
		gripPoints.append(ptDim);
	}
	//代号点
	AcGePoint3d ptCode;
	CString sCode;
	m_pXDataMap->GetAt(HVLV_CodeText, sCode);
	if (!sCode.IsEmpty())
	{
		m_pXDataMap->GetAt(HVLV_CodePoint, ptCode);
		gripPoints.append(ptCode);
	}

	return Acad::eOk;
}

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

Acad::ErrorStatus THImpHvacValve::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 THImpHvacValve::explode(AcDbVoidPtrArray& entitySet) const
{
	return Acad::eOk;
}

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

	if (!bShow)
		return 0.0;
	
	ASSERT(NULL != m_pXDataMap);
	double dWidth(0.0);
	m_pXDataMap->GetAt(HVAC_EdgeWidth, dWidth);
	
	return dWidth;
}

BOOL THImpHvacValve::OPMInfo(LPCTSTR pszName, TDb::OPMInfo* pInfo)
{
	ASSERT(NULL != pszName && NULL != pInfo && NULL != m_pXDataMap);
	int nIsCap(0);
	m_pXDataMap->GetAt(HVLV_IsDuctCap, nIsCap);
	// 暖通基本参数设置
	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::eValve);
		}

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

		return TRUE;
	}

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

	if (0 == _tcsicmp(pszName, KEY_Model))
	{
		pInfo->bVisible = TRUE;
		pInfo->bEditable = TRUE;
		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;
		// 替代属性，需要特殊处理数据获取和设置
		if (NULL != pInfo->pXData)
		{
			// 获取数据
			if (0 == pInfo->pXData->nVt)
			{
				m_pXDataMap->GetAt(KEY_Length, *pInfo->pXData);
				if(!nIsCap)
					pInfo->pXData->dVal[0] *= 500.0;
			}
			// 设置数据
			else
			{
				//pInfo->pXData->nVt = 0;
			}
		}
		return TRUE;
	}

	if (0 == _tcsicmp(pszName, KEY_Width))
	{
		HvacSectType eSectType = eRectangular;
		m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
		if (TDb::eCircular == eSectType)
		{
			pInfo->bVisible = FALSE;
			pInfo->bEditable = FALSE;
		}
		else
		{
			pInfo->bVisible = TRUE;
			pInfo->bEditable = FALSE;
			// 替代属性，需要特殊处理数据获取和设置
			if (NULL != pInfo->pXData)
			{
				// 获取数据
				if (0 == pInfo->pXData->nVt)
				{
					m_pXDataMap->GetAt(KEY_Width, *pInfo->pXData);
					if(!nIsCap)
						pInfo->pXData->dVal[0] *= 1000.0;
				}
				// 设置数据
				else
				{
					//pInfo->pXData->nVt = 0;
				}
			}
		}
		
		return TRUE;
	}

// 	if (0 == _tcsicmp(pszName, KEY_Diameter))
// 	{
// 		int iSectType = -1;
// 		m_pXDataMap->GetAt(HVAC_SectType, iSectType);
// 		if (iSectType == 1)
// 		{
// 			pInfo->bVisible = TRUE;
// 			pInfo->bEditable = FALSE;
// 
// 			if (NULL != pInfo->pXData)
// 			{
// 				// 获取数据
// 				if (0 == pInfo->pXData->nVt)
// 				{
// 					m_pXDataMap->GetAt(KEY_Diameter, *pInfo->pXData);
// 					if(!nIsCap)
// 						pInfo->pXData->dVal[0] *= 1000.0;
// 				}
// 				// 设置数据
// 				else
// 				{
// 					//pInfo->pXData->nVt = 0;
// 				}
// 			}
// 			
// 		}
// 		return TRUE;
// 	}

	if (0 == _tcsicmp(pszName, KEY_Thick))
	{
		int iSectType = -1;
		m_pXDataMap->GetAt(HVAC_SectType, iSectType);
		if (iSectType != 1)
		{
			pInfo->bVisible = TRUE;
			pInfo->bEditable = FALSE;

			//BEGIN==============================================
			if (NULL != pInfo->pXData)
			{
				// 获取数据
				if (0 == pInfo->pXData->nVt)
				{
					m_pXDataMap->GetAt(KEY_Thick, *pInfo->pXData);
					//if(!nIsCap)
					//	pInfo->pXData->dVal[0] *= 1000.0;
				}
			}
			//修改时间：2010-05-18
			//修改人  ：王亚东
			//修改原因：显示厚度值
			//END===============================================
		}	
		return TRUE;
	}

//BEGIN===============================================================
	if (0 == _tcsicmp(pszName, KEY_Diameter))
	{
		// 获得截面，当截面为圆型时显示并可改
		HvacSectType eSectType = eRectangular;
		m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
		pInfo->bVisible = (TDb::eCircular == eSectType);
		pInfo->bEditable = FALSE;
		
		// 替代属性，需要特殊处理数据获取和设置
		if (NULL != pInfo->pXData)
		{
			// 获取数据
			if (0 == pInfo->pXData->nVt)
			{
				m_pXDataMap->GetAt(KEY_Width, *pInfo->pXData);
				if(!nIsCap)
					pInfo->pXData->dVal[0] *= 1000.0;
			}
		}
		return TRUE;
	}
//修改时间：2010-05-18
//修改人  ：王亚东
//修改原因：显示直径值
//END=================================================================

	if(!nIsCap)
	{
//		mcl commented.2010.04326.技术支持提出去掉，改参数已不用
// 		if (0 == _tcsicmp(pszName, KEY_DimText))
// 		{
// 			pInfo->bVisible = TRUE;
// 			pInfo->bEditable = TRUE;
// 			return TRUE;
// 		}

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

	return FALSE;
}

//修改标注
void THImpHvacValve::SetSubText(long i,CString sText)
{
	// change by hh 2014-1-7
	// 当文字出现中英文混排时，底层绘制会出现多个文字实体
	// 导致文字索引混乱，为避免出现文字修改出错的情况，先取出原
	// 文字进行判断。此方法无法解决多个文字内容相同的情况，
	// 要完全解决此问题，必须修改更底层的处理机制。
	TSubText* pSubTxt = ((TDbInterfacesObj*)m_pOwnerEnt)->GetSubText(i);
	if(NULL != pSubTxt)
	{
		CString sOldTxt = pSubTxt->GetText();
		CString sLabel, sDim, sCode;
		m_pXDataMap->GetAt(HVLV_LabelText, sLabel);
		m_pXDataMap->GetAt(HVLV_DimText, sDim);
		m_pXDataMap->GetAt(HVLV_CodeText, sCode);

		if(sOldTxt == sLabel)
			m_pXDataMap->SetAt(HVLV_LabelText, sText);
		else if(sOldTxt == sDim)
			m_pXDataMap->SetAt(HVLV_DimText, sText);
		else if(sOldTxt == sCode)
			m_pXDataMap->SetAt(HVLV_CodeText, sText);
		else
		{
			if(-1 != sLabel.Find(sOldTxt))
				m_pXDataMap->SetAt(HVLV_LabelText, sText);
			else if(-1 != sDim.Find(sOldTxt))
				m_pXDataMap->SetAt(HVLV_DimText, sText);
			else if(-1 != sCode.Find(sOldTxt))
				m_pXDataMap->SetAt(HVLV_CodeText, sText);
		}

		m_pOwnerEnt->recordGraphicsModified();
	}

	/*if (i == 0)
	{
		CString sLabel;
		m_pXDataMap->GetAt(HVLV_LabelText, sLabel);
		if (sLabel.IsEmpty())
		{
			m_pXDataMap->SetAt(HVLV_DimText, sText);
		}
		else
		{
			m_pXDataMap->SetAt(HVLV_LabelText, sText);
		}
	}
	else
	{
		m_pXDataMap->SetAt(HVLV_DimText, sText);
	}
	m_pOwnerEnt->recordGraphicsModified();*/
}

//得到风阀图块的长度，为V7版本的消声器使用。
double THImpHvacValve::GetBlkOldLength() const
{
	double dOLength(500.0);
	AcDbObjectId id = AcDbObjectId::kNull;
	m_pXDataMap->GetAt(HVLV_PartCenter, id);

	AcDbExtents ext;
	OPENOBJ_BEGIN(id,AcDb::kForRead,AcDbBlockTableRecord,pBTR);
	if (pBTR != NULL)
	{
		ext.addBlockExt(pBTR);
		dOLength = ext.maxPoint().x - ext.minPoint().x;
		//过滤带label的风阀
		if (dOLength < 2000.0)
		{
			dOLength = 500.0;
		}
	}
	OPENOBJ_END();
	return dOLength;
}

// 得到风阀图块的宽度 add by hh 2011-01-28
double THImpHvacValve::GetBlkOldWidth() const
{
	if(NULL == m_pXDataMap)
		return 1000;

	double dWidth = 1000;
	AcDbObjectId id = AcDbObjectId::kNull;
	m_pXDataMap->GetAt(HVLV_PartCenter, id);
	AcDbExtents ext;
	OPENOBJ_BEGIN(id, AcDb::kForRead, AcDbBlockTableRecord, pBTR);
	if (pBTR != NULL)
	{
		ext.addBlockExt(pBTR);
		dWidth = ext.maxPoint().y - ext.minPoint().y;
	}
	OPENOBJ_END();
	return dWidth;
}

double THImpHvacValve::GetEndLineWidth() const
{
	BOOL bShow(FALSE);
	GetGlobalContext(HVAC_SHOWWIDTH, bShow);
	// add by hh 2011-01-05 从图纸中读取加粗标识 避免全局参数对不同的图纸间的影响
	TAuxTools::GetTHvacDataFromDwg(HVAC_SHOWWIDTH, bShow);

	if (!bShow)
		return 0.0;

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

	return dWidth;
}

void THImpHvacValve::OnSubErase( Adesk::Boolean erasing )
{
	if (erasing == Adesk::kTrue && 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 (TAuxTools::IsAutoWorkConnect() && idModel == m_pOwnerEnt->blockId())
		{
			// 写入接口更改消息
			TInterfaceModifyMsg iMsg;
			iMsg.SetMsgValidate(TRUE);
			iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());
			iMsg.SetInterfaceOper(TDb::eAutoWorkOn);
			
			TDbInterfaceMsgWrite msgWrite;
			msgWrite.WriteInterfaceMsg(iMsg);			
		}
	}	
}

BOOL THImpHvacValve::IsMovedWithInDuct( const AcGeVector3d &vtOffset )
{
	ASSERT(NULL != m_pXDataMap);
	
	AcDbObjectId idStaCon(AcDbObjectId::kNull), idEndCon(AcDbObjectId::kNull);
	if (!GetConnectDuct(idStaCon, idEndCon))
		return FALSE;
	
	// 先找出最远的两个点
	BOOL bStaDuct(FALSE);
	AcGePoint3d ptMin(AcGePoint3d::kOrigin), ptMax(AcGePoint3d::kOrigin);
	OPENOBJ_BEGIN(idStaCon, AcDb::kForRead, TDbInterfacesObj, pObj);
	if (NULL != pObj)
	{
		ObjectKind eKind(eCabletry);
		TDbXDataMap* pObjMap = pObj->GetSpecialtyDataReadOnly();
		if (NULL != pObjMap)
			pObjMap->GetAt(KEY_RUNTIME, (int&)eKind);

		if (eKind == ePipe)
		{
			TDbHvacDuct* pDuct = TDbHvacDuct::cast(pObj);
			if (NULL != pDuct)
			{
				ptMin = pDuct->StartPoint();
				ptMax = pDuct->EndPoint();
				bStaDuct = TRUE;
			}
		}
	}
	OPENOBJ_END();

	OPENOBJ_BEGIN(idEndCon, AcDb::kForRead, TDbInterfacesObj, pObj);
	if (NULL != pObj)
	{
		ObjectKind eKind(eCabletry);
		TDbXDataMap* pObjMap = pObj->GetSpecialtyDataReadOnly();
		if (NULL != pObjMap)
			pObjMap->GetAt(KEY_RUNTIME, (int&)eKind);
		
		if (eKind == ePipe)
		{
			TDbHvacDuct* pDuct = TDbHvacDuct::cast(pObj);
			if (NULL != pDuct)
			{
				if (bStaDuct)
				{
					AcGePoint3d ptStart = pDuct->StartPoint();
					AcGePoint3d ptEnd = pDuct->EndPoint();
					double dDistSta = ptStart.distanceTo(ptMax);
					double dDistEnd = ptEnd.distanceTo(ptMax);
					AcGePoint3d ptNewMax = dDistEnd > dDistSta ? ptEnd:ptStart;
					
					dDistSta = ptMin.distanceTo(ptStart);
					dDistEnd = ptMax.distanceTo(ptStart);
					AcGePoint3d ptNewMin = dDistEnd > dDistSta ? ptMax:ptMin;

					ptMin = ptNewMin;
					ptMax = ptNewMax;
				}
				else
				{
					ptMin = pDuct->StartPoint();
					ptMax = pDuct->EndPoint();
				}
			}
		}
	}
	OPENOBJ_END();

	if (ptMin.isEqualTo(ptMax, g_globalTol))	// 异常
		return FALSE;

	AcGePoint3d ptCenter;
	m_pXDataMap->GetAt(HVLV_CenterPoint, ptCenter);
	AcGePoint3d ptNewCenter = ptCenter + vtOffset;
	AcDbLine lineHelp(ptMin, ptMax);
	double dTemp(0.0);
	if (lineHelp.getParamAtPoint(ptNewCenter, dTemp) == Acad::eOk)
	{
		// add by zh 2013-8-20 有一段未连接，返回FALSE
		if (idStaCon == AcDbObjectId::kNull || idEndCon == AcDbObjectId::kNull)
			return FALSE;
		//
		// 距离管两端，不能小于半个阀门加法兰的宽度，否则算移出
		double dDistMin = ptNewCenter.distanceTo(ptMin);
		double dDistMax = ptNewCenter.distanceTo(ptMax);
		double dValveLen(0.0), dScale(1.0);
		m_pXDataMap->GetAt(HVLV_Length, dValveLen);
		dValveLen *= 500 * 0.5;
		dValveLen += 50.0;	// 加上法兰宽度
		if (dDistMin > dValveLen && dDistMax > dValveLen)
			return TRUE;
	}

	return FALSE;
	
}

BOOL THImpHvacValve::GetConnectDuct( AcDbObjectId &idSta, AcDbObjectId &idEnd )
{
	BOOL bFindOne(FALSE);
	TInterface tIfSta, tIfEnd;
	GetInterface(0, tIfSta);
	GetInterface(1, tIfEnd);
	AcDbObjectId idStaCon = tIfSta.GetConnectObject();
	AcDbObjectId idEndCon = tIfEnd.GetConnectObject();

	// 首端
	OPENOBJ_BEGIN(idStaCon, AcDb::kForRead, TDbInterfacesObj, pObj);
	if (NULL != pObj)
	{
		ObjectKind eKind(eCabletry);
		TDbXDataMap* pObjMap = pObj->GetSpecialtyDataReadOnly();
		if (NULL != pObjMap)
			pObjMap->GetAt(KEY_RUNTIME, (int&)eKind);
		
		if (eKind == ePipe)
		{
			idSta = idStaCon;
			bFindOne = TRUE;
		}
		else if (eKind == eFlange)	// 从法兰找另一端风管
		{
			TInterface tIfSta, tIfEnd;
			pObj->GetInterface(0, tIfSta);
			pObj->GetInterface(1, tIfEnd);
			AcDbObjectId idStaCon = tIfSta.GetConnectObject();
			AcDbObjectId idEndCon = tIfEnd.GetConnectObject();
			AcDbObjectId idFind = idStaCon;
			if (idStaCon == m_pOwnerEnt->objectId())
				idFind = idEndCon;
			
			TDbInterfacesObj* pNextObj = NULL;
			OPENOBJ_BEGIN(idFind, AcDb::kForRead, TDbInterfacesObj, pNextObj);
			if (NULL != pNextObj)
			{
				ObjectKind eKind(ePipe);
				TDbXDataMap* pNextMap = pNextObj->GetSpecialtyDataReadOnly();
				if (NULL != pNextMap)
				{
					pNextMap->GetAt(KEY_RUNTIME, (int&)eKind);
					if (eKind == ePipe)
					{
						idSta = idFind;
						bFindOne = TRUE;
					}
				}
			}
			OPENOBJ_END();
		}
	}
	OPENOBJ_END();
		
	// 末端
	OPENOBJ_BEGIN(idEndCon, AcDb::kForRead, TDbInterfacesObj, pObj);
	if (NULL != pObj)
	{
		ObjectKind eKind(eCabletry);
		TDbXDataMap* pObjMap = pObj->GetSpecialtyDataReadOnly();
		if (NULL != pObjMap)
			pObjMap->GetAt(KEY_RUNTIME, (int&)eKind);
		
		if (eKind == ePipe)
		{
			idEnd = idEndCon;
			bFindOne = TRUE;
		}
		else if (eKind == eFlange)
		{
			TInterface tIfSta, tIfEnd;
			pObj->GetInterface(0, tIfSta);
			pObj->GetInterface(1, tIfEnd);
			AcDbObjectId idStaCon = tIfSta.GetConnectObject();
			AcDbObjectId idEndCon = tIfEnd.GetConnectObject();
			AcDbObjectId idFind = idStaCon;
			if (idStaCon == m_pOwnerEnt->objectId())
				idFind = idEndCon;
			
			TDbInterfacesObj* pNextObj = NULL;
			OPENOBJ_BEGIN(idFind, AcDb::kForRead, TDbInterfacesObj, pNextObj);
			if (NULL != pNextObj)
			{
				ObjectKind eKind(ePipe);
				TDbXDataMap* pNextMap = pNextObj->GetSpecialtyDataReadOnly();
				if (NULL != pNextMap)
				{
					pNextMap->GetAt(KEY_RUNTIME, (int&)eKind);
					if (eKind == ePipe)
					{
						idEnd = idFind;
						bFindOne = TRUE;
					}
				}
			}
			OPENOBJ_END();
		}
	}
	OPENOBJ_END();

	return bFindOne;
}

LRESULT THImpHvacValve::UserCall( long i,LPVOID pData )
{
	ASSERT(NULL != m_pXDataMap);
	
	m_pXDataMap->SetAt(KEY_IDCNT1, NULL);
	m_pXDataMap->SetAt(KEY_IDCNT2, NULL);

	return 1l;	
}

int THImpHvacValve::GetXBaseShell(TXShell& xShell)
{
	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(HVLV_Width, dWidth);
		dWidth *= 1000.0;
		double dThick = 0.0;
		m_pXDataMap->GetAt(HVLV_Thick, dThick);
		AcGeVector3d vtNormal;
		m_pXDataMap->GetAt(HVAC_Normal, vtNormal);
		vtNormal.normalize();
		AcGePoint3d ptStart = GetStartPt();
		AcGePoint3d ptEnd = GetEndPt();
		
		// 构造碰撞实体
		TAuxTools::BuildRectDuct(ptStart, ptEnd, vtNormal, dWidth, dThick, dWidth, dThick, xShell);
	}
	else if (TDb::eCircular == eSectType)
	{
		// 获得参数
		double dDiameter = 0.0;
		m_pXDataMap->GetAt(HVLV_Diameter, dDiameter);
		dDiameter *= 1000.0;
		AcGePoint3d ptStart = GetStartPt();
		AcGePoint3d ptEnd = GetEndPt();
		
		// 构造碰撞实体
		TAuxTools::BuildCirDuct(ptStart, ptEnd, dDiameter, dDiameter, xShell);
	}
	else
	{
		// 不做处理
		;
	}
	
	return 1;
}

int THImpHvacValve::GetBodyBox( AcDbExtents& ext ) const
{
	if (NULL == m_pXDataMap)
	{
		return 0;
	}
	
	// 获得参数
	double dWidth = 0.0;
	m_pXDataMap->GetAt(HVLV_Width, dWidth);
	dWidth *= 1000.0;
	double dHalfWidth = dWidth / 2.0;
	double dThick = 0.0;
	m_pXDataMap->GetAt(HVLV_Thick, 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(HVAC_Normal, vtNormal);
	vtNormal.normalize();
	AcGePoint3d ptStart = GetStartPt();
	AcGePoint3d ptEnd = GetEndPt();
	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;
}

// 导出XML
// CString THImpHvacValve::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(HVLV_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(HVLV_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(HVLV_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(HVLV_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(HVLV_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(HVLV_Part3D, id);
// 		csText.Format(_T("%d"), id.asOldId());
// 		xmlTree.SetItemText(posItemPart3D, csText);
// 	}
// 
//  	POSITION posItemLength = xmlTree.Insert(_T("Length"), posRoot, posItemPart3D);
// 	{ 
// 		xmlTree.SetAttribute(posItemLength, _T("name"), _T("长度"));
// 		xmlTree.SetAttribute(posItemLength, _T("comment"), _T("阀门长度"));
// 		m_pXDataMap->GetAt(HVLV_Length, dValue);
// 		// change by hh 2011-01-10 阀门长度(比例)*图块长度
// 		// TAuxTools::DoubleToString(dValue, nWhPreci, csText);
// 		TAuxTools::DoubleToString(dValue * GetBlkOldLength(), 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(HVLV_Width, dValue);
// 		// change by hh 2011-01-10 阀门宽度(比例)*图块宽度
// 		// TAuxTools::DoubleToString(dValue, nWhPreci, csText);
// 		TAuxTools::DoubleToString(dValue * GetBlkOldWidth(), 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(HVLV_Thick, dValue);
// 		TAuxTools::DoubleToString(dValue, nWhPreci, csText);
// 		xmlTree.SetItemText(posItemThick, csText);
// 	}
// 
// 	POSITION posItemMirror = xmlTree.Insert(_T("IsMirror"), posRoot, posItemThick);
// 	{ 
// 		xmlTree.SetAttribute(posItemMirror, _T("name"), _T("是否镜像"));
// 		xmlTree.SetAttribute(posItemMirror, _T("comment"), _T("用于辅助绘制0:否,1:是"));
// 		m_pXDataMap->GetAt(HVLV_IsMirror, nValue);
// 		csText.Format(_T("%d"), nValue);
// 		xmlTree.SetItemText(posItemMirror, csText);
// 	}
// 
// 	POSITION posItemDuctCap = xmlTree.Insert(_T("IsDuctCap"), posRoot, posItemMirror);
// 	{ 
// 		xmlTree.SetAttribute(posItemDuctCap, _T("name"), _T("是否是风帽"));
// 		xmlTree.SetAttribute(posItemDuctCap, _T("comment"), _T("用于判断是否是风帽0:不是,1:是"));
// 		m_pXDataMap->GetAt(HVLV_IsDuctCap, nValue);
// 		csText.Format(_T("%d"), nValue);
// 		xmlTree.SetItemText(posItemDuctCap, csText);
// 	}
// 
// 	CString csXml = xmlTree.GetXml();
// 
// 	return csXml;
// }

CString THImpHvacValve::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(HVLV_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(HVLV_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(HVLV_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(HVLV_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-24
	// 原因：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(HVLV_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(HVLV_Part3D, id);
		csText = TAuxTools::GetBlkNameById(id);
		//csText.Format(_T("%d"), id.asOldId());
		xmlTree.SetItemText(posItemPart3D, csText);
	}
	// end //

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

	POSITION posItemLength = xmlTree.Insert(_T("Length"), posRoot, posItemPartSys);
	{ 
		xmlTree.SetAttribute(posItemLength, _T("name"), _T("长度"));
		xmlTree.SetAttribute(posItemLength, _T("comment"), _T("阀门长度"));
		m_pXDataMap->GetAt(HVLV_Length, dValue);
		// change by hh 2011-01-10 阀门长度(比例)*图块长度
		// TAuxTools::DoubleToString(dValue, nWhPreci, csText);
		TAuxTools::DoubleToString(dValue * GetBlkOldLength(), 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(HVLV_Width, dValue);
		// change by hh 2011-01-10 阀门宽度(比例)*图块宽度
		// TAuxTools::DoubleToString(dValue, nWhPreci, csText);
		TAuxTools::DoubleToString(dValue * GetBlkOldWidth(), 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("阀门高度"));
		// mod by wc 13-12-24
		if (!m_pXDataMap->GetAt(HVLV_Thick, dValue))
		{
			dValue = 0.0;
		}
		TAuxTools::DoubleToString(dValue, nWhPreci, csText);
		xmlTree.SetItemText(posItemThick, csText);
	}

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

	POSITION posItemDuctCap = xmlTree.Insert(_T("IsDuctCap"), posRoot, posItemMirror);
	{ 
		xmlTree.SetAttribute(posItemDuctCap, _T("name"), _T("是否是风帽"));
		xmlTree.SetAttribute(posItemDuctCap, _T("comment"), _T("用于判断是否是风帽0:不是,2:是"));
		m_pXDataMap->GetAt(HVLV_IsDuctCap, nValue);
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemDuctCap, csText);
	}
	//add by wc 13-12-12

	POSITION posItemIsBreakPipe = xmlTree.Insert(_T("IsBreakPipe"), posRoot, posItemDuctCap);
	{ 
		xmlTree.SetAttribute(posItemIsBreakPipe, _T("name"), _T("是否带边线"));
		xmlTree.SetAttribute(posItemIsBreakPipe, _T("comment"), _T("用于判断是否添加两条边线0:否,1:是"));
		if (!m_pXDataMap->GetAt(HVLV_IsBreakPipe, nValue))
			nValue = 0;
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemIsBreakPipe, csText);
	}

	POSITION posItemHasEndLine = xmlTree.Insert(_T("HasEndLine"), posRoot, posItemIsBreakPipe);
	{ 
		xmlTree.SetAttribute(posItemHasEndLine, _T("name"), _T("是否带端线"));
		xmlTree.SetAttribute(posItemHasEndLine, _T("comment"), _T("用于设置两个End端的线与风管一致0:否,1:是"));
		if (!m_pXDataMap->GetAt(HVLV_HasEndLine, nValue))
			nValue = 0;
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemHasEndLine, csText);
	}
// 
// 	POSITION posItemDuctLayer = xmlTree.Insert(_T("DuctLayer"), posRoot, posItemHasEndLine);
// 	{ 
// 		xmlTree.SetAttribute(posItemDuctLayer, _T("name"), _T("风管的图层"));
// 		xmlTree.SetAttribute(posItemDuctLayer, _T("comment"), _T("风管图层的名字"));
// 		if (!m_pXDataMap->GetAt(HVLV_DuctLayer, 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(posItemDuctLayer, csText);
// 	}

	POSITION posItemLablePoint = xmlTree.Insert(_T("LablePoint"), posRoot, posItemHasEndLine);
	{ 
		xmlTree.SetAttribute(posItemLablePoint, _T("name"), _T("标签点"));
		xmlTree.SetAttribute(posItemLablePoint, _T("comment"), _T("标签点"));
		if (!m_pXDataMap->GetAt(HVLV_LabelPoint, pt))
			csText.Empty();
		else
		{
			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(posItemLablePoint, csText);
	}

	POSITION posItemLableText = xmlTree.Insert(_T("LableText"), posRoot, posItemLablePoint);
	{ 
		xmlTree.SetAttribute(posItemLableText, _T("name"), _T("标签文字"));
		xmlTree.SetAttribute(posItemLableText, _T("comment"), _T("标签文字"));
		if (!m_pXDataMap->GetAt(HVLV_LabelText, csText))
			csText.Empty();
		xmlTree.SetItemText(posItemLableText, csText);
	}

	POSITION posItemDimPoint = xmlTree.Insert(_T("DimPoint"), posRoot, posItemLableText);
	{ 
		xmlTree.SetAttribute(posItemDimPoint, _T("name"), _T("标注点"));
		xmlTree.SetAttribute(posItemDimPoint, _T("comment"), _T("标注点"));
		if (!m_pXDataMap->GetAt(HVLV_DimPoint, pt))
			csText.Empty();
		else
		{
			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(posItemDimPoint, csText);
	}

	POSITION posItemDimText = xmlTree.Insert(_T("DimText"), posRoot, posItemDimPoint);
	{ 
		xmlTree.SetAttribute(posItemDimText, _T("name"), _T("标注文字"));
		xmlTree.SetAttribute(posItemDimText, _T("comment"), _T("标注文字"));
		if (!m_pXDataMap->GetAt(HVLV_DimText, csText))
			csText.Empty();
		xmlTree.SetItemText(posItemDimText, csText);
	}

	POSITION posItemSilAddLen = xmlTree.Insert(_T("SilAddLen"), posRoot, posItemDimText);
	{ 
		xmlTree.SetAttribute(posItemSilAddLen, _T("name"), _T("消声器出头长度"));
		xmlTree.SetAttribute(posItemSilAddLen, _T("comment"), _T("消声器出头长度"));
		m_pXDataMap->GetAt(HVLV_SilAddLen, dValue);
		TAuxTools::DoubleToString(dValue, nWhPreci, csText);
		xmlTree.SetItemText(posItemSilAddLen, csText);
	}

	POSITION posItemReversalX = xmlTree.Insert(_T("ReversalX"), posRoot, posItemSilAddLen);
	{
		xmlTree.SetAttribute(posItemReversalX, _T("name"), _T("是否左右旋转"));
		xmlTree.SetAttribute(posItemReversalX, _T("comment"), _T("0/不是、1/是"));
		if (!m_pXDataMap->GetAt(HVLV_IsReverseX, 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(HVLV_IsReverseY, nValue))
		{
			nValue = 0;
		}
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posItemReversalY, csText);
	}

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


	POSITION posItemSectType = xmlTree.Insert(_T("SectType"), posRoot, posSysName);
	{ 
		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);
	}

	POSITION posItemCodeText = xmlTree.Insert(_T("CodeText"), posRoot, posItemSectType);
	{ 
		xmlTree.SetAttribute(posItemCodeText, _T("name"), _T("阀门代号"));
		xmlTree.SetAttribute(posItemCodeText, _T("comment"), _T("阀门代号"));
		if (!m_pXDataMap->GetAt(HVLV_CodeText, csText))
			csText.Empty();
		xmlTree.SetItemText(posItemCodeText, csText);
	}

	POSITION posItemCodePoint = xmlTree.Insert(_T("CodePoint"), posRoot, posItemCodeText);
	{ 
		xmlTree.SetAttribute(posItemCodePoint, _T("name"), _T("代号点"));
		xmlTree.SetAttribute(posItemCodePoint, _T("comment"), _T("代号点"));
		if (!m_pXDataMap->GetAt(HVLV_CodePoint, pt))
			csText.Empty();
		else
		{
			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(posItemCodePoint, csText);
	}

	POSITION posItemMaterial = xmlTree.Insert(_T("Material"),posRoot, posItemCodePoint);
	{ 
		xmlTree.SetAttribute(posItemMaterial, _T("name"), _T("风管材料"));
		xmlTree.SetAttribute(posItemMaterial, _T("comment"), _T("风管使用的材料"));
		m_pXDataMap->GetAt(HVAC_Material, csText);
		xmlTree.SetItemText(posItemMaterial, csText);		
	}

	POSITION posIsEdgeWidth = xmlTree.Insert(_T("IsEdgeWidth"), posRoot, posItemMaterial);
	{
		xmlTree.SetAttribute(posIsEdgeWidth, _T("name"), _T("边线是否加粗"));
		xmlTree.SetAttribute(posIsEdgeWidth, _T("comment"), _T("0/不加粗, 1/加粗"));
		if (!m_pXDataMap->GetAt(HVAC_EdgeWeight, nValue))
			nValue = 0;
		csText.Format(_T("%d"), nValue);
		xmlTree.SetItemText(posIsEdgeWidth, csText);
	}

	POSITION posEdgeWidth = xmlTree.Insert(_T("EdgeWidth"), posRoot, posIsEdgeWidth);
	{
		xmlTree.SetAttribute(posEdgeWidth, _T("name"), _T("边线加粗量"));
		xmlTree.SetAttribute(posEdgeWidth, _T("comment"), _T("边线加粗的数值"));
		m_pXDataMap->GetAt(HVAC_EdgeWidth, dValue);
		csText.Format(_T("%f"), dValue);
		xmlTree.SetItemText(posEdgeWidth, csText);
	}

	POSITION posEndWidth = xmlTree.Insert(_T("EndWidth"), posRoot, posEdgeWidth);
	{
		xmlTree.SetAttribute(posEndWidth, _T("name"), _T("端线加粗量"));
		xmlTree.SetAttribute(posEndWidth, _T("comment"), _T("端线加粗的数值"));
		m_pXDataMap->GetAt(HVAC_EndWidth, dValue);
		csText.Format(_T("%f"), dValue);
		xmlTree.SetItemText(posEndWidth, csText);
	}

	CString csXml = xmlTree.GetXml();

	return csXml;
}

// add by hh 2014-08-06 支持设备与水管遮挡
Acad::ErrorStatus THImpHvacValve::GetClipBoundary(TGGePoly2D& poly)const
{
	AcDbPolyline* pLine = MakePolyCurve();
	if(NULL == pLine)
		return Acad::eNotImplementedYet;

	double dBrWidth = 0;
	if(!TAuxTools::GetTHvacDataFromDwg(HVAC_PIPEHIDEWIDTH, dBrWidth))
		GetGlobalContext()->GetAt(HVAC_PIPEHIDEWIDTH, dBrWidth);
	if(EQUAL_ZERO(dBrWidth))
	{
		PolyConvert(*pLine, poly);
	}
	else
	{
		AcDbVoidPtrArray arPLines;
		pLine->getOffsetCurves(dBrWidth, arPLines);
		if(0 == arPLines.length())
		{
			PolyConvert(*pLine, poly);
		}
		else
		{
			PolyConvert(*((AcDbPolyline*)arPLines[0]), poly);
			for(int i = 0; i < arPLines.length(); i++)
			{
				if(NULL != arPLines[i])
					delete (AcDbEntity*)arPLines[i];
			}
		}
	}
	delete pLine;

	return Acad::eOk;
}

bool THImpHvacValve::IsMeClip() const
{
	return true;
}

bool THImpHvacValve::IsClipMe(const TEntityBase* pEnt)const//ok是否被裁剪
{
	if(NULL == pEnt)
		return false;

	//add by dyw 20150409 当图纸复杂时，遮挡的更改影响水管的绘制速度，暂时屏蔽掉
	return false;
	//add end

	CString sClassName = pEnt->GetMe()->isA()->name();
	if(0 == sClassName.Compare(_T("TDbPipe")))  // 水管
	{
		TInterfaceModifyMsg iMsg;
		iMsg.SetInterfaceOper(TDb::eUpdateCover);
		iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());

		// 写入接口更改消息
		TDbInterfaceMsgWrite msgWrite;
		msgWrite.WriteInterfaceMsg(iMsg);

		return true;
	}
	return false;
}