#include "stdafx.h"
#include "StdArx.h"
#include "THImpHvacEquipment.h"
#include "TDbInterfaceRecord.h"
#include "TDbXDataMap.h"
#include "TDbInterfaceMsgWrite.h"
#include "math.h"
#include "dbxutil.h"
#include "dbelipse.h"
#include "TDbEquWorldDraw.h"

using namespace TDb;

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


THImpHvacEquipment::THImpHvacEquipment()
{
// 	m_pOutLine = NULL;
}

THImpHvacEquipment::~THImpHvacEquipment()
{
// 	if(NULL != m_pOutLine)
// 		delete m_pOutLine;
}

BOOL THImpHvacEquipment::GetInterfaceSizeData(int nIndex, TInterface& pipeInterface) const
{
	ASSERT(NULL != m_pXDataMap);
	
	// 获取尺寸
	double dWidth = 0.0, dThick = 0.0;

	// 设置接口数据
	pipeInterface.SetSize(dWidth, dThick);
	
	return TRUE;
}

BOOL THImpHvacEquipment::GetInterface(int nIndex,TInterface& pipeInterface) const
{
	if (NULL == m_pXDataMap)
		return FALSE;
	AcGePoint3d pt;
	AcGeVector3d vt;
	CString sName;
	double dw,dt;
	AcDbObjectId id;

	GetInterFaceLocal(nIndex, pt);
	GetInterFaceLocal(nIndex, vt);
	GetInterFaceLocal(nIndex, sName);
	GetInterFaceLocal(nIndex, dw, dt);
	CString sID;
	sID.Format(_T("%s%d"), KEY_IDCNT_, nIndex + 1);

	// change by hh 2013-9-12 逻辑错误？
	/*if (m_pXDataMap->GetAt(sID, id) && MakesureInterfaceValidate(id, pt, vt, pipeInterface))
	{
		return TRUE;
	}

	pipeInterface.SetSize(dw,dt);
	pipeInterface.SetOutDir(vt);
	pipeInterface.SetOwnerId(m_pOwnerEnt->objectId());
	pipeInterface.SetPosition(pt);
	pipeInterface.SetDescr(sName);*/
	if(m_pXDataMap->GetAt(sID, id))
	{
		MakesureInterfaceValidate(id, pt, vt, pipeInterface);
	}

	pipeInterface.SetSize(dw,dt);
	pipeInterface.SetOutDir(vt);
	pipeInterface.SetOwnerId(m_pOwnerEnt->objectId());
	pipeInterface.SetPosition(pt);
	pipeInterface.SetDescr(sName);

	return TRUE;
}

BOOL THImpHvacEquipment::GetInterface(const AcGePoint3d& ptCon,TInterface& pipeInterface) const
{
	if (NULL == m_pXDataMap)
		return FALSE;

	int nIndex(-1);
	if(GetIFIndexFormPt(nIndex,ptCon))
		return GetInterface(nIndex,pipeInterface);
	return FALSE;
}

BOOL THImpHvacEquipment::HasInterface(const AcGePoint3d& ptCon,const AcGeVector3d& vtDir)
{
	if (NULL == m_pXDataMap)
		return FALSE;
	
	// 获取各点位置
	int nIndex(-1);
	AcGeVector3d vtIf;
	if(GetIFIndexFormPt(nIndex,ptCon))
	{
		GetInterFaceLocal(nIndex,vtIf);
		return (vtDir.isParallelTo(vtIf));
	}
	return FALSE;
}

int	 THImpHvacEquipment::GetInterfaceCount() const
{
	if (NULL == m_pXDataMap)
		return 0;
	int iIfNum(0);
	m_pXDataMap->GetAt(HEQU_InterfaceNum, iIfNum);
	return iIfNum;
}

BOOL THImpHvacEquipment::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;
	CString sName = pEnt->isA()->name();// == _T("TDbPipe");	
	// 检查对象类型，是否是暖通管件
	if (!(pEnt->isKindOf(TDbHvacDuct::desc()) || pEnt->isKindOf(TDbHvacFitting::desc())
		|| pEnt->isKindOf(TDbHvacEquipment::desc())
		|| 0 == sName.Compare(_T("TDbPipe")))) // 允许水管接口
	{
		pEnt->close();
		return FALSE;
	}
	
	// 获取各点位置
	int nIndex(-1);
	if(GetIFIndexFormPt(nIndex,ptConnect))
	{
		CString sID;
		sID.Format(_T("%s%d"), KEY_IDCNT_, nIndex + 1);
		
		// 基类指针
		TDbInterfacesObj* pInterfaceObj = TDbInterfacesObj::cast(pEnt);
		ASSERT(NULL != pInterfaceObj);
		m_pXDataMap->SetAt(sID, idConnect);
		pEnt->close();
		return TRUE;
	}
	pEnt->close();
	return FALSE;
}

BOOL THImpHvacEquipment::RemoveInterfaceRelation(const AcGePoint3d& ptConnect,const AcDbObjectId& idConnect)
{
	if (NULL == m_pXDataMap)
		return FALSE;
	
	// 浅层次删除; 命名字典中的关系,需要外面移除关系,只移除内部关系

	AcDbObjectId id;
	int nIndex(-1);
	if(GetIFIndexFormPt(nIndex,ptConnect))
	{
		CString sID;
		sID.Format(_T("%s%d"),KEY_IDCNT_,nIndex + 1);
		m_pXDataMap->SetAt(sID, AcDbObjectId::kNull);
		return TRUE;
	}

	return FALSE;
}

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

BOOL THImpHvacEquipment::OnMoveGripPointMsgNotify( const TInterfaceModifyMsg& iModiMsg, 
												  TInterfaceModifyMsgs& iModiMsgs )
{
	if (!TAuxTools::IsAutoWorkOffset())
		return FALSE;
	
	ASSERT(NULL != m_pXDataMap);
	
	AcDbObjectId id = iModiMsg.GetMsgOperateOn();
	AcDbObjectId idOwner = m_pOwnerEnt->objectId();
	if (id != idOwner) // 消息发送目标正确
		return FALSE;
	
	AcGeVector3d vtOffset = iModiMsg.GetMoveGripOffset();
	if (vtOffset.isZeroLength()) 
		return FALSE;
	
	BOOL bMsgTranslate = FALSE;
	
	int nPos = iModiMsg.GetGripPosition();
	if (nPos == eStart || nPos == eMid || nPos == eEnd || nPos == eBr1 || nPos == eBr2)
	{		
		AcGePoint3d ptCenter, ptText;
		m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
		m_pXDataMap->GetAt(HEQU_TextPoint, ptText);	
	
		ptCenter += vtOffset;	
		ptText += vtOffset;	
		
		m_pXDataMap->SetAt(HEQU_CenterPoint, ptCenter);
		m_pXDataMap->SetAt(HEQU_TextPoint, ptText);

		// 设备其他接口消息传递
		TInterface tIf;
		AcDbObjectId idT(AcDbObjectId::kNull);
		AcGePoint3d ptIf;
		AcGeVector3d vtIf;
		int i(0);
		for (i = 0; i < GetInterfaceCount(); i++)
		{
			tIf.Reset();
			if (!GetInterface(i, tIf))
				continue;

			ptIf = tIf.GetPosition();
			vtIf = tIf.GetOutDir();
			if (FindConnect(ptIf, vtIf, idOwner, idT)) 
			{
				if (vtOffset.isParallelTo(vtIf) || vtOffset.isPerpendicularTo(vtIf))
				{
					TInterfaceModifyMsg msg;
					msg.SetMsgPoint(ptIf);
					msg.SetMoveGripOffset(vtOffset);
					msg.SetMsgOperateOn(idT);
					msg.SetGripPosition(eStart);
					iModiMsgs.append(msg);
					bMsgTranslate = TRUE;
				}
			}
		}

		AcGeMatrix3d mtTrans;
		mtTrans.setToTranslation(vtOffset);
		SetInterFaceLocal(mtTrans);
		
		// 更新模型空间的扩展字典的注册的接口数据
		AcGeMatrix3d xform;
		xform.setToTranslation(vtOffset);
		UpdateInterfaceRec(m_pOwnerEnt->objectId(), xform);
	}
				
	return bMsgTranslate;	
}

BOOL THImpHvacEquipment::GetBlockComplexCurve(TComplexCurve& curve) const
{
	// 拖动时不调用此函数
	if(((TDbHvacEquipment*)m_pOwnerEnt)->IsDragging())
		return FALSE;

	// 取得图块ID
	AcDbObjectId idBlock;
	m_pXDataMap->GetAt(HEQU_PartCenter, idBlock);

	// 取得图块变换矩阵
	AcGeMatrix3d mat;
	if(!GetEquTransMatrix(idBlock, mat))
		return FALSE;

	TDbEquWorldDraw wDraw;
	wDraw.SetComplexCurvePtr(&curve);
	wDraw.SetTransMatrix(mat);

	// 取得图块中的所有图元
	OPENOBJ_BEGIN(idBlock, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
	if(NULL != pBlock)
	{
		AcDbBlockTableRecordIterator* pIt = NULL;
		if(Acad::eOk != pBlock->newIterator(pIt))
			return FALSE;

		AcDbEntity* pEnt = NULL;
		CString sClassName;
		for(pIt->start(); !pIt->done(); pIt->step())
		{
			pEnt = NULL;
			Acad::ErrorStatus es = pIt->getEntity(pEnt, AcDb::kForRead);
			if(NULL != pEnt)
			{
				// change by hh 2012-06-25 不能支持的实体 放入到TDbEquWorldDraw中统一处理
				if(3 != pEnt->colorIndex())
					wDraw.VirtualWordDraw(pEnt);
				// 跳过一些wDraw不能支持的实体
				/*sClassName = pEnt->isA()->name();
				if(pEnt->isKindOf(AcDbBlockReference::desc())
					|| pEnt->isKindOf(AcDbAttributeDefinition::desc())
					|| pEnt->isKindOf(AcDbFace::desc())
					|| pEnt->isKindOf(AcDbSolid::desc()))
				{
					;
				}
				else
				{
					// if(!IsInterfaceLine(pEnt, &mat)) 效率太低 暂使用颜色进行判断
					// 忽略接口线,接口线的颜色索引为3
					if(3 != pEnt->colorIndex())
						pEnt->worldDraw(&wDraw);
				}*/
				// change end
				pEnt->close();
			}
		}
		delete pIt;
	}
	OPENOBJ_END();

	return TRUE;
}

// 函数说明: 函数用来找到 图块中无法提取上华图元的实体(例如,文字,AcDbSolid等),也可以获得图块中可以提取图元的实体指针数组
void THImpHvacEquipment::GetEntFromBlock(AcDbBlockReference* pBlockRef, AcDbVoidPtrArray& arVoidPtr, BOOL bFlag) const
{
	// 取得图块中的所有无法提取图元的实体指针
	AcDbVoidPtrArray arBlockEntPtr;
	if (Acad::eOk != pBlockRef->explode(arBlockEntPtr))
		return;

	AcDbEntity* pBlockEnt = NULL;
	int nLen = arBlockEntPtr.length();
	for(int i = 0; i < nLen; i++)                   // 遍历块中实体
	{
		pBlockEnt = NULL;
		pBlockEnt = (AcDbEntity*)arBlockEntPtr.at(i);
		if (NULL != pBlockEnt)
		{
			if (pBlockEnt->isKindOf(AcDbBlockReference::desc()))        // 块里面还是块,递归遍历
			{
				GetEntFromBlock((AcDbBlockReference*)pBlockEnt, arVoidPtr, bFlag);
			}
			else
			{
				if (pBlockEnt->isKindOf(AcDbLine::desc())               // 块中实体支持提取上华图元   
					|| pBlockEnt->isKindOf(AcDbPolyline::desc())
					|| pBlockEnt->isKindOf(AcDbArc::desc())
					|| pBlockEnt->isKindOf(AcDbEllipse::desc())
					|| pBlockEnt->isKindOf(AcDbCircle::desc()))
				{
					if (!bFlag)
						arVoidPtr.append(pBlockEnt);
					else
						delete pBlockEnt;
				}
				else
				{
					if (bFlag)
						arVoidPtr.append(pBlockEnt);                    // 块中实体不支持提取上华图元,需要单独绘制
					else
						delete pBlockEnt;
				}
			}
		}
	}
	pBlockRef->close();
}

void THImpHvacEquipment::DrawNotSupplyBlock(AcDbObjectId idBlock, XExplodeDraw& mode) const
{
	// 拖动时不调用此函数
	if(((TDbHvacEquipment*)m_pOwnerEnt)->IsDragging())
		return ;

	AcDbVoidPtrArray arNotSupplyEntPtr;
	AcDbEntity* pEnt = NULL;
	// add begin
	AcGePoint3d ptCenter;
	m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
	AcDbBlockReference *pBlockRef = new AcDbBlockReference(ptCenter, idBlock);
	{
		ASSERT(NULL != m_pXDataMap);
		AcGeVector3d vtMain, vtScale, vtNor;
		double dLength(1.0);
		double dWidth(1.0);
		double dThick(1.0);
		AcGePoint3d ptCenter;
		m_pXDataMap->GetAt(HVAC_Normal, vtNor);
		m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
		m_pXDataMap->GetAt(HEQU_Length, dLength);
		m_pXDataMap->GetAt(HEQU_Width, dWidth);
		m_pXDataMap->GetAt(HEQU_Thick, dThick);
		m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
		m_pXDataMap->GetAt(HEQU_Scale, vtScale);
		if (dThick < 1)
		{
			dThick = 1;
		}

		double dAngle(0.0);

		dLength *= vtScale.x;
		dWidth *= vtScale.y;
		dThick *= vtScale.z;
		dAngle = AcGeVector3d::kXAxis.angleTo(vtMain,vtNor);
		//如果没有高度值，则高度比例置为1
		if (vtScale.z == 1)
		{
			dThick = 1;
		}

		AcGeScale3d scale(dLength, dWidth, dThick);
		XPoint xpoint = ptCenter;
		pBlockRef->setScaleFactors(scale);
		pBlockRef->setRotation(dAngle);
	}
	GetEntFromBlock(pBlockRef, arNotSupplyEntPtr, TRUE);
	int iLen = arNotSupplyEntPtr.length();
	for( int i=0; i<iLen; ++i )
	{
		pEnt = (AcDbEntity*)arNotSupplyEntPtr[i];
		if( pEnt->isKindOf(AcDbText::desc()) )
		{
			AcDbText *pText = AcDbText::cast(pEnt);
			mode.DrawEntity(*pText);
		}
		else if( pEnt->isKindOf(TDbText::desc()) )
		{
			TDbText *pText = TDbText::cast(pEnt);
			mode.DrawEntity(*pText);
		}
	}
	delete pBlockRef;
	// add end by cq 150810 解决图块中不能识别文字的情况
	if (m_arUserBlk.length() == 0)// 用户自定义设备图块中,包含自定义块数组为空的时候,遍历一次.
	{
		OPENOBJ_BEGIN(idBlock, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
		if(NULL != pBlock)
		{
			AcDbBlockTableRecordIterator* pIt = NULL;
			if(Acad::eOk != pBlock->newIterator(pIt))
				return ;

			AcDbBlockReference* pTempBlkRef = NULL;
			AcDbObjectId idBlkInBlk = AcDbObjectId::kNull;
			for(pIt->start(); !pIt->done(); pIt->step())
			{
				pEnt = NULL;
				pIt->getEntity(pEnt, AcDb::kForRead);
				if(NULL != pEnt)
				{
					if(pEnt->isKindOf(AcDbBlockReference::desc()))
					{
						// 对块中实体分类,找到用户自定义的块,这些块中可能有上华不支持提取图元的实体,所以单独绘制整个块
						pTempBlkRef = (AcDbBlockReference*)pEnt;
						idBlkInBlk = AcDbObjectId::kNull;
						idBlkInBlk = pTempBlkRef->objectId();
						if (!idBlkInBlk.isNull() && (Adesk::kTrue != m_arUserBlk.contains(idBlkInBlk)))
							((THImpHvacEquipment*)this)->m_arUserBlk.append(idBlkInBlk);
					}
					pEnt->close();
				}
			}
			delete pIt;
		}
		OPENOBJ_END();
	}

	// 得到设备相对于原始图块的变换矩阵,用于对块参照进行插入点变换.
	AcGeMatrix3d matBlk;
	if (!GetEquTransMatrix(idBlock, matBlk))
		return ;

	AcGeMatrix3d mat;//设备图块中用户自定义块,相对于,设备图块的对象坐标系OCS变换矩阵
	AcGeScale3d GeScale;
	double dAng(0.0);
	XPoint ptPos;
	int nUserBlkNum = m_arUserBlk.length();
	for(int i = 0; i < nUserBlkNum; i++)
	{
		OPENOBJ_BEGIN(m_arUserBlk[i], AcDb::kForRead, AcDbBlockReference, pBlkRef);
		if (NULL != pBlkRef)
		{
			// 得到自定义块参照相对于设备图块的OCS变换矩阵
			mat = pBlkRef->blockTransform();
			// 由矩阵获得缩放比例
			GeScale = mat.scale();

			// 得到块的插入点,并转化为设备图块上的点
			ptPos = pBlkRef->position();
			ptPos.TransformBy(matBlk);

			// 块参照旋转角度
			dAng = pBlkRef->rotation();

			// 块参照的块表记录
			AcDbObjectId idBlk = pBlkRef->blockTableRecord();
			OPENOBJ_BEGIN(idBlk, AcDb::kForRead, AcDbBlockTableRecord, pBlkRec);
			if (NULL != pBlkRec)
 			    mode.DrawBlock(*pBlkRec, ptPos, GeScale, -dAng, TRUE);
			OPENOBJ_END();
		}
		OPENOBJ_END();
	}
}

BOOL THImpHvacEquipment::IsInterfaceLine(AcDbEntity* pEnt, AcGeMatrix3d* pMat) const
{
	if(NULL == pEnt)
		return FALSE;

	AcDbLine* pLine = AcDbLine::cast(pEnt);
	if(NULL == pLine)
		return FALSE;

	AcGePoint3d ptIf;
	AcGePoint3d ptS = pLine->startPoint();
	AcGePoint3d ptE = pLine->endPoint();
	if(NULL != pMat)
	{
		ptS.transformBy(*pMat);
		ptE.transformBy(*pMat);
	}
	ptS.z = ptE.z = 0;

	AcGeTol tol;
	tol.setEqualPoint(2);
	TInterface intf;
	int nIfCount = GetInterfaceCount();
	for(int i = 0; i < nIfCount; i++)
	{
		GetInterface(i, intf);
		ptIf = intf.GetPosition();
		ptIf.z = 0;
		if(ptIf.isEqualTo(ptS, tol) || ptIf.isEqualTo(ptE, tol))
		{
			return TRUE;
		}
	}
	return FALSE;
}

BOOL THImpHvacEquipment::MakeCurves(TComplexCurve& cplCurve) const
{
	return GetBlockComplexCurve(cplCurve);

// 	AcGePoint3dArray arPts;
// 	GetBoxPts(arPts);
// 
// 	TDb::TCurveElement el;
// 	memset(&el,0,sizeof(TDb::TCurveElement));
// 
// 	el.ptGe[0] = arPts[1]; 
// 	el.ptGe[1] = arPts[2];
// 	el.ptGe[2] = arPts[2];
// 	cplCurve.append(el);
// 	el.ptGe[0] = arPts[3]; 
// 	el.ptGe[1] = arPts[4];
// 	el.ptGe[2] = arPts[4];
// 	cplCurve.append(el);
// 	el.ptGe[0] = arPts[1]; 
// 	el.ptGe[1] = arPts[4];
// 	el.ptGe[2] = arPts[4];
// 	cplCurve.append(el);
// 	el.ptGe[0] = arPts[2]; 
// 	el.ptGe[1] = arPts[3];
// 	el.ptGe[2] = arPts[3];
// 	cplCurve.append(el);
// 	return TRUE;
}

BOOL THImpHvacEquipment::GetCurvesInSide(TComplexCurve& compCurve) const
{
	return GetBlockComplexCurve(compCurve);
}

AcDbPolyline* THImpHvacEquipment::MakePolyCurve() const
{
	// change by hh 2011-10-10 取得设备的实际外轮廓
//	if(NULL != m_pOutLine)
//		return (AcDbPolyline*)m_pOutLine->clone();

	// 拖动时不调用此函数
	if(((TDbHvacEquipment*)m_pOwnerEnt)->IsDragging())
		return FALSE;

	// 取得图块ID
	AcDbObjectId idBlock;
	m_pXDataMap->GetAt(HEQU_PartCenter, idBlock);

	// 取得图块变换矩阵
	AcGeMatrix3d mat;
	if(!GetEquTransMatrix(idBlock, mat))
		return FALSE;

	TDPtrList<TGGeCurveSegment> segComs;
	TDbEquWorldDraw wDraw;
	wDraw.SetCurveSegmentPtr(&segComs);
	wDraw.SetTransMatrix(mat);

	// 取得图块中的所有图元
	CString sClassName;
	OPENOBJ_BEGIN(idBlock, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
	if(NULL != pBlock)
	{
		AcDbBlockTableRecordIterator* pIt = NULL;
		if(Acad::eOk != pBlock->newIterator(pIt))
			return FALSE;

		AcDbEntity* pEnt = NULL;
		for(pIt->start(); !pIt->done(); pIt->step())
		{
			pIt->getEntity(pEnt, AcDb::kForRead);
			if(NULL != pEnt)
			{
				// 跳过一些wDraw不能支持的实体
				if(3 != pEnt->colorIndex())
					wDraw.VirtualWordDraw(pEnt);
				/*sClassName = pEnt->isA()->name();
				if(pEnt->isKindOf(AcDbBlockReference::desc())
					|| pEnt->isKindOf(AcDbAttributeDefinition::desc())
					|| pEnt->isKindOf(AcDbFace::desc())
					|| pEnt->isKindOf(AcDbSolid::desc()))
				{
					;
				}
				else
				{
					// 忽略接口线,接口线的颜色索引为3
					if(3 != pEnt->colorIndex())
						pEnt->worldDraw(&wDraw);
				}*/
				pEnt->close();
			}
		}
		delete pIt;
	}
	OPENOBJ_END();

	TGGePoly2D poly2D;
	if(!GetExternalBoundaryFromCurves(segComs, poly2D))
		return NULL;

	// const函数 强制转换
	AcDbPolyline* pOutLine = new AcDbPolyline;
	PolyConvert(poly2D, *pOutLine);
	return pOutLine;
//	((THImpHvacEquipment*)this)->m_pOutLine = new AcDbPolyline;
//	PolyConvert(poly2D, *m_pOutLine);

//	return (AcDbPolyline*)m_pOutLine->clone();

//                 
//              
//  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), dPlusEdge(50.0);
	AcDbDatabase* pDb = acdbCurDwg();
	AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
	m_pXDataMap->GetAt(HVAC_Normal, vtNor);
	m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
	m_pXDataMap->GetAt(HEQU_Length, dLength);		
	m_pXDataMap->GetAt(HEQU_Width, dWidth);		
	m_pXDataMap->GetAt(HEQU_Thick, dThick);		
	
	// 避免有重复点造成无效的多段线，R16平台下崩溃
	if (dLength < 1)
		dLength = 1.0;
	if (dWidth < 1)
		dWidth = 1.0;
	if (dThick < 1)
		dThick = 1.0;

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

	pt1 = ptCenter + vtMainv * dWidth * 0.5;
	pt2 = ptCenter - vtMainv * dWidth * 0.5;
	pt1 = pt1 - vtMain * dLength *0.5;
	pt3 = pt1 + vtMain * dLength;
	pt2 = pt2 - vtMain * dLength *0.5;
	pt4 = pt2 + vtMain * dLength;
	ptU1 = pt1 + vtNor * dThick;
	ptU2 = pt2 + vtNor * dThick;
	ptU3 = pt3 + vtNor * dThick;
	ptU4 = pt4 + vtNor * dThick;
	AcGePoint3dArray arpts;

	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);
	}
	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);
	}
	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;
	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 THImpHvacEquipment::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);		
	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 THImpHvacEquipment::GetKindName(CString& sName)
{
	sName = _T("ATS_DBHEQUIPMENT");
}

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

TDb::Position THImpHvacEquipment::ExplainGripIndex(int nIndex) const
{	
	if(nIndex == 0)
	{
		return TDb::eMid;
	}
	else
	{
		if (nIndex <= GetInterfaceCount())
			return TDb::eCommand0;

		if (nIndex > GetInterfaceCount() + 4)
			return TDb::eStart;
	}

	return TDb::eMid;
}

Acad::ErrorStatus THImpHvacEquipment::GetGripText(int i, CString &cs) const
{
	if (i == 0)
	{
		cs = _T("改变位置");
	}
	else
	{
		if (i <= GetInterfaceCount())
			GetInterFaceLocal(i - 1,cs);
		else if (i > GetInterfaceCount() + 4)
			cs = _T("改变文字位置");
		else
			cs = _T("改变位置");
	}
	return Acad::eOk;
}

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

Acad::ErrorStatus THImpHvacEquipment::ExplodeOrDraw3d(XExplodeDraw &mode) const
{
	ASSERT(NULL != m_pXDataMap);
	AcDbObjectId idBlock,idBlock3D;

	m_pXDataMap->GetAt(HEQU_PartCenter, idBlock);
	m_pXDataMap->GetAt(HEQU_Part3D, idBlock3D);
	double dThick(1.0);
	m_pXDataMap->GetAt(HEQU_Thick, dThick);
	if (dThick < 1.e-3 || idBlock3D == AcDbObjectId::kNull)
	{
		idBlock3D = idBlock;
	}

	InserBlockCen(mode, idBlock3D);

	return Acad::eOk;
}

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

// AecObjectEditMethod THImpHvacEquipment::GetEditMethod() const
// {
// 	ASSERT(NULL != m_pXDataMap);
// 	ObjectKind eKind;
// 	m_pXDataMap->GetAt(KEY_RUNTIME, (int &)eKind);
// 
// 	return TImpSpecEquipment::GetEditMethod();
// }

Acad::ErrorStatus THImpHvacEquipment::ExplodeOrDrawBlock2d(XExplodeDraw &mode) const
{
	AcDbObjectId idBlock;
	m_pXDataMap->GetAt(HEQU_PartCenter, idBlock);
	if (idBlock.isValid())
		InserBlockCen(mode, idBlock);

	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacEquipment::ExplodeOrDraw2d(XExplodeDraw &mode) const
{
	if (m_pXDataMap == NULL)
	{
		return Acad::eNotImplementedYet;
	}

	BOOL bDragging = ((TDbHvacEquipment*)m_pOwnerEnt)->IsDragging();

	//在jig时画接口线
	if(bDragging)
	{
		TDb::ObjectKind eKind(TDb::eCabletry);
		m_pXDataMap->GetAt(KEY_RUNTIME, (int&)eKind);
		if (TDb::eAirHanding != eKind)	// 空气机组在自身里实现
		{
			AcGeVector3d vtInter,vtScale;
			double dL(98.0),dLength(0.0);
			TDbXDataMap xdatamap;
			int iIfNum(0);
			AcGePoint3d ptInter, ptend;
			XPoint pt1,pt2;
			m_pXDataMap->GetAt(HEQU_InterfaceNum, iIfNum);
			m_pXDataMap->GetAt(HEQU_Scale, vtScale);
			m_pXDataMap->GetAt(HEQU_Length, dLength);
			XLine xline;
			for (int i = 0; i < iIfNum; i++)
			{
				xdatamap.Empty();
				m_pXDataMap->GetAt(HEQU_Interface, i, xdatamap);
				if (xdatamap.GetAt(HEQUIF_Point, ptInter))
				{
					xdatamap.GetAt(HEQUIF_Vector, vtInter);
					vtInter.normalize();
					ptend = ptInter + vtInter * vtScale.x * dL * dLength;  
					pt1 = ptInter;
					pt2 = ptend;
					xline.SetPoints(pt1, pt2);
					mode.SetColor(3);
					mode.DrawLine(xline);
				}
			}			
		}
	}

	// JIG拖动时,2维图形按整体块绘制
	// 非JIG时,2维图形按线段一条条绘制,图块中有些无法绘制的块,在这里添加Lixl add 2012-5-21
	AcDbObjectId idBlock2d;
	m_pXDataMap->GetAt(HEQU_PartCenter, idBlock2d);
	if (idBlock2d.isValid())
	{
		TArchPerDocData *pDocData = GetCurDocData();
		if (NULL != pDocData && FALSE)
		{
			XString &sCmd = pDocData->m_sCurCommand;
			if (XExplodeStream::m_bExportTch4 || 0 == _tcsicmp(sCmd, _T("explode")) )
			{ // add by cq 2017-08-07 设备炸开的时候 以图块绘制
				InserBlockCen(mode, idBlock2d);
				return Acad::eNotImplementedYet;
			}
		}
		if (bDragging)
			InserBlockCen(mode, idBlock2d);
		else
			DrawNotSupplyBlock(idBlock2d, mode);
	}
	// delete by cq 2016-09-05 把文字绘制挪到ExplodeOrDrawText2d里面 保证文字遮挡生效TFS15714
	/*BOOL bHasName = FALSE;
	m_pXDataMap->GetAt(HEQU_HasText, bHasName);

	if (bHasName)
	{
		CString sType(_T(""));
		m_pXDataMap->GetAt(HEQU_SEquipName, sType);
		AcGePoint3d ptInst = AcGePoint3d::kOrigin;
		m_pXDataMap->GetAt(HEQU_TextPoint, ptInst);
		AcGeVector3d vtMain = AcGeVector3d::kXAxis;
		m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
		double dTextHeight = 3;
		m_pXDataMap->GetAt(KEY_TextHeight, dTextHeight);
		AcDbObjectId idLayer = AcDbObjectId::kNull;
		m_pXDataMap->GetAt(KEY_EndLayer, idLayer);

		// add by hh 2011-05-11 调整文字方向 避免出现颠倒的情况
		double dAng = TAuxTools::GetUcsXvt().angleTo(vtMain, TAuxTools::GetUcsZvt());
		if (dAng > PI / 2 && dAng <= PI + PI / 2){
			vtMain.negate();
		}

		TDbText *pText = new TDbText;
		// add by hh 2011-01-06 文字比例随图块 避免通过“定义视口”转换到布局空间后文字变小
		pText->setPropertiesFrom(m_pOwnerEnt);
		// add end
		pText->SetText(sType);

		//		AcDbObjectId idStyle = GetTextStyleId(_T("_TCH_DIM")); 在此使用GetTextStyleId()会获取失败
		AcDbObjectId idStyle = AcDbObjectId::kNull;
		m_pXDataMap->GetAt(HDIM_DimTextId, idStyle);
		pText->SetStyleId(idStyle);

		pText->SetHeight(dTextHeight);
		pText->SetLocation(ptInst);
		pText->SetRotation(AcGeVector3d::kXAxis.angleTo(vtMain, AcGeVector3d::kZAxis));
		pText->SetAlignment(XExplodeDraw::kMiddleCenter);
		pText->setLayer(idLayer);//InitLayer(_T("TA-构件标注"))

		BOOL bMask(FALSE);
		m_pXDataMap->GetAt(HEQU_TextShadeBg, bMask);
		pText->SetMaskFlag(bMask);

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

		//		mode.DrawEntity(*pText);
		delete pText;
	}*/
	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacEquipment::ExplodeOrDrawText2d(XExplodeDraw &mode) const
{
	BOOL bHasName = FALSE;
	m_pXDataMap->GetAt(HEQU_HasText, bHasName);

	if (bHasName)
	{
		CString sType(_T(""));
		m_pXDataMap->GetAt(HEQU_SEquipName, sType);
		AcGePoint3d ptInst = AcGePoint3d::kOrigin;
		m_pXDataMap->GetAt(HEQU_TextPoint, ptInst);
		AcGeVector3d vtMain = AcGeVector3d::kXAxis;
		m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
		double dTextHeight = 3;
		m_pXDataMap->GetAt(KEY_TextHeight, dTextHeight);
		AcDbObjectId idLayer = AcDbObjectId::kNull;
		m_pXDataMap->GetAt(KEY_EndLayer, idLayer);

		// add by hh 2011-05-11 调整文字方向 避免出现颠倒的情况
		double dAng = TAuxTools::GetUcsXvt().angleTo(vtMain, TAuxTools::GetUcsZvt());
		if (dAng > PI / 2 && dAng <= PI + PI / 2){
			vtMain.negate();
		}

		TDbText *pText = new TDbText;
		// add by hh 2011-01-06 文字比例随图块 避免通过“定义视口”转换到布局空间后文字变小
		pText->setPropertiesFrom(m_pOwnerEnt);
		// add end
		pText->SetText(sType);

		//		AcDbObjectId idStyle = GetTextStyleId(_T("_TCH_DIM")); 在此使用GetTextStyleId()会获取失败
		AcDbObjectId idStyle = AcDbObjectId::kNull;
		m_pXDataMap->GetAt(HDIM_DimTextId, idStyle);
		pText->SetStyleId(idStyle);

		pText->SetHeight(dTextHeight);
		pText->SetLocation(ptInst);
		pText->SetRotation(AcGeVector3d::kXAxis.angleTo(vtMain, AcGeVector3d::kZAxis));
		pText->SetAlignment(XExplodeDraw::kMiddleCenter);
		pText->setLayer(idLayer);//InitLayer(_T("TA-构件标注"))

		BOOL bMask(FALSE);
		m_pXDataMap->GetAt(HEQU_TextShadeBg, bMask);
		pText->SetMaskFlag(bMask);

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

		//		mode.DrawEntity(*pText);
		delete pText;
	}
	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacEquipment::InserBlockCen(XExplodeDraw &mode, AcDbObjectId idBlock) const
{
	ASSERT(NULL != m_pXDataMap);
	AcGeVector3d vtMain, vtScale, vtNor;
	double dLength(1.0);
	double dWidth(1.0);
	double dThick(1.0);
	AcGePoint3d ptCenter;
	m_pXDataMap->GetAt(HVAC_Normal, vtNor);
	m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HEQU_Length, dLength);
	m_pXDataMap->GetAt(HEQU_Width, dWidth);
	m_pXDataMap->GetAt(HEQU_Thick, dThick);
	m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
	m_pXDataMap->GetAt(HEQU_Scale, vtScale);
	if (dThick < 1)
	{
		dThick = 1;
	}
	
	double dAngle(0.0);

	dLength *= vtScale.x;
	dWidth *= vtScale.y;
	dThick *= vtScale.z;
	dAngle = AcGeVector3d::kXAxis.angleTo(vtMain,vtNor);
	//如果没有高度值，则高度比例置为1
	if (vtScale.z == 1)
	{
		dThick = 1;
	}
	
	AcGeScale3d scale(dLength, dWidth, dThick);
	AcDbObject *pObj;
	XPoint xpoint = ptCenter;
	if (acdbOpenObject(pObj, idBlock, AcDb::kForRead) != Acad::eOk)
		return Acad::eNotImplementedYet;
	AcDbBlockTableRecord *pBlock = AcDbBlockTableRecord::cast(pObj);
	if (pBlock == NULL)
	{
		pObj->close();
		return Acad::eNotImplementedYet;
	}
	mode.DrawBlock(*pBlock, xpoint, scale, dAngle, TRUE);
	pObj->close();
	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacEquipment::InserBlockHand(XExplodeDraw &mode) const
{
	
	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacEquipment::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 THImpHvacEquipment::GetBoxPts(AcGePoint3dArray &arPts) const
{
	// 获取各点位置
	AcGePoint3d ptStart, ptEnd, ptCenter;
	AcGeVector3d vtMain, vtNor, vtMainv;
	double dLength(50.0), dThick(50.0), dWidth(50.0), dPlusEdge(50.0);
	m_pXDataMap->GetAt(HVAC_Normal, vtNor);
	m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
	m_pXDataMap->GetAt(HEQU_Length, dLength);		
	m_pXDataMap->GetAt(HEQU_Width, dWidth);		
	m_pXDataMap->GetAt(HEQU_Thick,	dThick);
	vtMainv = vtMain;
	vtMainv.rotateBy(PI * 0.5, vtNor);
	vtMain.normalize();
	vtMainv.normalize();
	dPlusEdge = dWidth * 0.1;
	//0
	arPts.append(ptCenter);
	AcGePoint3d pt;
	pt = ptCenter - vtMain * dLength * 0.5;
	pt = pt + vtMainv * dWidth * 0.5;
	//1
	arPts.append(pt);
	//2
	arPts.append(arPts[1] + vtMain * dLength);
	//3
	arPts.append(arPts[2] - vtMainv * dWidth);
	//4
	arPts.append(arPts[1] - vtMainv * dWidth);
	return TRUE;
}

void THImpHvacEquipment::list() const
{
	if (m_pXDataMap != NULL)
	{
		AcGePoint3d ptCenter;
		AcGeVector3d vtMain;
		CString sType,sName,sParma;
		double dLength(50.0), dThick(50.0), dWidth(50.0), dPlusEdge(50.0);
		double daircap(0),drefri(0),dheatcap(0),dwtrRes(0);
		TDbXDataMap mapparam;
		m_pXDataMap->GetAt(HEQU_SEquipType, sType);
		m_pXDataMap->GetAt(HEQU_SEquipName, sName);
		m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
		m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
		m_pXDataMap->GetAt(HEQU_Length, dLength);		
		m_pXDataMap->GetAt(HEQU_Width, dWidth);		
		m_pXDataMap->GetAt(HEQU_Thick,	dThick);
		
		acutPrintf(_T("\t\t\t\t\t\t\t\t%s"),sType);
		acutPrintf(_T("\n\t\t\t\t\t型号: %s"),sName);
		//读出所有参数信息
		m_pXDataMap->GetAt(HEQU_Parameter,0,mapparam);
		TDbXDataMap::It it;
		TXData xdata;
		for(it = mapparam.Begin();it != mapparam.End();)
		{
			m_pXDataMap->GetAt(it->first, sParma);
			mapparam.GetNext(it,xdata);
			acutPrintf(_T("\n\t\t\t\t\t%s%s"),xdata.pszVal,sParma);
		}
		//几何参数信息
		acutPrintf(_T("\n\t\t\t\t\t长度: %.0fmm"),fabs(dLength));
		acutPrintf(_T("\n\t\t\t\t\t宽度: %.0fmm"),fabs(dWidth));
		acutPrintf(_T("\n\t\t\t\t\t高度: %.0fmm"),fabs(dThick));
		acutPrintf(_T("\n\t\t\t\t\t标高: %.0fm"),ptCenter.z * 0.001);
		int icount(0);
		m_pXDataMap->GetAt(HEQU_InterfaceNum, icount);
		if (icount < 1)
		{
			acutPrintf(_T("\n\t\t\t\t\t接口:无"));
		}
		else
		{
			CString sIFName;
			AcGeVector3d vt;
			AcGePoint3d pt;
			TDbXDataMap xdatamap;
			double dw(0),dh(0),dangle(0);
			for (int i = 0; i < icount; i++)
			{
				xdatamap.Empty();
				m_pXDataMap->GetAt(HEQU_Interface, i, xdatamap);
				xdatamap.GetAt(HEQUIF_Name, sIFName);
				xdatamap.GetAt(HEQUIF_Point, pt);
				xdatamap.GetAt(HEQUIF_Vector, vt);
				xdatamap.GetAt(HEQUIF_Width, dw);
				xdatamap.GetAt(HEQUIF_Height, dh);
				dangle = vt.angleTo(AcGeVector3d::kXAxis,AcGeVector3d::kZAxis) * 180 / PI;
				acutPrintf(_T("\n\t\t\t\t\t接口: %d"),i);
				acutPrintf(_T("\n\t\t\t\t\t接口名称: %s"),sIFName);
				acutPrintf(_T("\n\t\t\t\t\t接口位置: (%.0f,%.0f,%.0f)"),pt.x,pt.y,pt.z);
				acutPrintf(_T("\n\t\t\t\t\t接口方向: %.0f度"), dangle);
				if (dh < 0)
				{
					acutPrintf(_T("\n\t\t\t\t\t接口直径: %.0fmm"), dw);
				}
				else
				{
					acutPrintf(_T("\n\t\t\t\t\t接口宽度: %.0fmm"), dw);
					acutPrintf(_T("\n\t\t\t\t\t接口长度: %.0fmm"), dh);
				}
			}
		}
	}
}

Acad::ErrorStatus THImpHvacEquipment::transformBy(const AcGeMatrix3d& xform)
{
	if (NULL == m_pXDataMap)
		return Acad::eNotApplicable;
	// 取得位置点
	AcGePoint3d ptCenter, ptText;
	AcGeVector3d vtMain,vtNor;
	double dL(1.0),dW(1.0),dT(1.0);
	m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HEQU_TextPoint, ptText);
	m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
	m_pXDataMap->GetAt(HEQU_Length, dL);
	m_pXDataMap->GetAt(HEQU_Width, dW);
	m_pXDataMap->GetAt(HEQU_Thick, dT);
	m_pXDataMap->GetAt(HVAC_Normal, vtNor);

	AcGeVector3d vtPrep(vtNor.crossProduct(vtMain));

// 	AcGeVector3d vtSz(dL,dW,dT);
// 	vtSz.transformBy(xform);

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

	vtMain.transformBy(xform);
	vtPrep.transformBy(xform);

	// 同向是旋转，不变号，反向是镜像，变号。
	int iSign = ((vtPrep.isCodirectionalTo(vtNor.crossProduct(vtMain))) ? 1 : -1);
	// 对设备做镜像操作的时候,为保证风口的宽仍保持正值,修改图块比例Lixl add 2012-3-26
	if (iSign == -1)
	{
		AcGeVector3d vtScale;
		m_pXDataMap->GetAt(HEQU_Scale, vtScale);
		// change by zh 2012-11-7 去掉绝对值以防止连续镜像出错
		//vtScale.y = -fabs(vtScale.y);
		vtScale.y = -(vtScale.y);
		m_pXDataMap->SetAt(HEQU_Scale, vtScale);
	}

	SetInterFaceLocal(xform);
	double dscale = xform.scale();
	
	// 更新点
	m_pXDataMap->SetAt(HVAC_Normal, vtNor);
	m_pXDataMap->SetAt(HEQU_CenterPoint, ptCenter);
	m_pXDataMap->SetAt(HEQU_TextPoint, ptText);
	m_pXDataMap->SetAt(HEQU_MainDir, vtMain);
	m_pXDataMap->SetAt(HEQU_Length, dL * dscale);
	m_pXDataMap->SetAt(HEQU_Width, dW * dscale/* * iSign*/);
	m_pXDataMap->SetAt(HEQU_Thick, dT * dscale);
	
	// 传递消息
	if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
	{
		// 如果实体不是在当前模型空间中,不做写消息,更新接口处理
		AcDbDatabase* pDb = m_pOwnerEnt->database();
		if (pDb == NULL) pDb = acdbCurDwg();
		
		AcDbObjectId idModel;
		AcDbBlockTable* pTable = NULL;
		pDb->getBlockTable(pTable, AcDb::kForRead);
		if (pTable != NULL)
		{
			pTable->getAt(ACDB_MODEL_SPACE, idModel);
			pTable->close();
		}
		
		// 如果实体不是在当前模型空间中,不做写消息,更新接口处理
		if (idModel == m_pOwnerEnt->blockId())
		{
			// 写入接口更改消息
			TInterfaceModifyMsg iMsg;
			iMsg.SetInterfaceOper(TDb::eTransformBy);
			iMsg.SetMsgValidate(TRUE);
			iMsg.SetTransform(xform);
			iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());
			
			TDbInterfaceMsgWrite msgWrite;
			msgWrite.WriteInterfaceMsg(iMsg);

			//更新接口记录接口信息
			UpdateInterfaceRec(m_pOwnerEnt->objectId(), xform);
		}	
	}
	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacEquipment::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 THImpHvacEquipment::moveStretchPointsAt(const AcDbIntArray& indices,
													  const AcGeVector3d& offset)
{
	return moveGripPointsAt(indices,offset);
}

Acad::ErrorStatus THImpHvacEquipment::moveGripPointsAt(const AcDbIntArray& indices,
                                   const AcGeVector3d& offset)
{
	ASSERT(NULL != m_pXDataMap);
	
	int nSize = indices.length();
	if (nSize > 0)
	{
		// 取得位置点
		AcGePoint3d ptCenter;
		m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
		AcGeVector3d vtMain,vtMainv;
		m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
		// 选择多个夹点,以first为准
		int nIndex = indices.first();
		TDb::Position ePos = ExplainGripIndex(nIndex);
		switch(ePos)
		{
		case TDb::eMid:
			{
				TDb::InterfaceOper eOper = TDb::eMoveGripPoint;
				AcGeVector3d vtMove = offset;
				
				ptCenter += vtMove;
				m_pXDataMap->SetAt(HEQU_CenterPoint, ptCenter);

				//更改接口位置
				AcGeMatrix3d maxvt;
				maxvt.setToTranslation(vtMove);
				SetInterFaceLocal(maxvt);

				if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
				{
					if (TAuxTools::IsEquipAutoMove(this, vtMove))
					{
						// 写入接口更改消息
						TInterfaceModifyMsg iMsg;
						iMsg.SetMsgPoint(ptCenter);//new pos
						iMsg.SetGripPosition(TDb::eMid);
						iMsg.SetMoveGripOffset(vtMove);
						if (eOper == TDb::eTransformBy)
							iMsg.SetTransform(vtMove);
						iMsg.SetMsgValidate(TRUE);
						iMsg.SetInterfaceOper(eOper);
						iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());
						TDbInterfaceMsgWrite msgWrite;
						msgWrite.WriteInterfaceMsg(iMsg);
					}
					
					//更新接口记录接口信息
					AcGeMatrix3d xform;
					xform.setToTranslation(vtMove);
					UpdateInterfaceRec(m_pOwnerEnt->objectId(),xform);
				}
				break;
			}
		case TDb::eCommand0:
			{
				nIndex -= 1;
				AcGePoint3d ptCom;
				GetInterFaceLocal(nIndex, ptCom);
				if (GetKeyState(VK_MENU) < 0)
				{
					TDbXDataMap xdatamap;
					m_pXDataMap->GetAt(HEQU_Interface, nIndex, xdatamap);
					ptCom += offset;
					xdatamap.SetAt(HEQUIF_Point, ptCom);
					m_pXDataMap->SetAt(HEQU_Interface, nIndex, xdatamap);
					//GetInterfaceFromXdata(nIndex, offset);
					break;
				}
				// 获得夹点命令
				else
				{
					CString sCmdStr;
					int nType(0);
					GetInterFaceLocal(nIndex, nType);
					switch(nType)
					{
					case 0:
						GetGlobalContext()->GetAt(KEY_HVACCOLDGRIPCMD, sCmdStr);
						break;
					case 1:
					case 2:
						GetGlobalContext()->GetAt(KEY_HVACGRIPCMD, sCmdStr);
						break;
					case 3:
						GetGlobalContext()->GetAt(KEY_HVACHEATGRIPCMD, sCmdStr);
						break;
					case 4:
						GetGlobalContext()->GetAt(KEY_HVACMEDIAGRIPCMD, sCmdStr);
						break;
					case 5:
						GetGlobalContext()->GetAt(KEY_HVACFJSQGRIPCMD, sCmdStr);
						break;
					}
					if (sCmdStr.IsEmpty())
						return Acad::eNotApplicable;
					TInterface pipeInterface;			
					GetInterface(ptCom, pipeInterface );

					double dw,dh;
					GetInterFaceLocal(nIndex, dw,dh);
					// 写入接口更改消息
					TInterfaceModifyMsg iMsg;
					iMsg.SetMsgPoint(ptCom);//new pos
					iMsg.SetGripPosition(ePos);
					iMsg.SetMoveGripOffset(offset);
					iMsg.SetMsgValidate(TRUE);
					iMsg.SetInterfaceOper(TDb::eNewCommand);
					iMsg.SetPreviewObjToCreate(TDb::eEquipment, 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::eStart:
			{
				AcGePoint3d ptText;
				m_pXDataMap->GetAt(HEQU_TextPoint, ptText);
				ptText += offset;
				m_pXDataMap->SetAt(HEQU_TextPoint, ptText);
				break;
			}
		default:
			break;
		}
	}
	return Acad::eOk;
}

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

	return Acad::eOk;
}

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

Acad::ErrorStatus THImpHvacEquipment::getOsnapPoints(AcDb::OsnapMode osnapMode,
                                 INT_PTR gsSelectionMark,
                                 const AcGePoint3d& pickPoint,
                                 const AcGePoint3d& lastPoint,
                                 const AcGeMatrix3d& viewXform,
                                 AcGePoint3dArray& snapPoints,
                                 AcDbIntArray& geomIds) const
{
	if (NULL == m_pXDataMap)
		return Acad::eNotApplicable;
	AcGePoint3d ptCenter;
	m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
	AcGePoint3dArray arpts;
	
	// 根据捕捉模式处理
	switch(osnapMode)
	{
	case AcDb::kOsModeEnd:
		GetInterFaceLocal(arpts);
		GetFourConer(arpts);
		snapPoints.append(arpts);
		break;
	case AcDb::kOsModeMid:
		snapPoints.append(ptCenter);
		break;
	case AcDb::kOsModeCen:
		break;
	case AcDb::kOsModePerp:
		break;
	case AcDb::kOsModeNear:
		break;
	}
	// add by hh 2011-07-12 支持任意位置捕捉
	TImpSpecEquipment::getOsnapPoints(osnapMode, gsSelectionMark, pickPoint, lastPoint,
		viewXform, snapPoints, geomIds);

	return Acad::eOk;
}

Acad::ErrorStatus THImpHvacEquipment::getGripPoints(AcGePoint3dArray& gripPoints,
                                AcDbIntArray& osnapModes,
                                AcDbIntArray& geomIds) const
{
	if (NULL == m_pXDataMap)
		return Acad::eNotApplicable;

	// 取得位置点
	AcGePoint3d ptCenter;
	m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
	
	gripPoints.append(ptCenter);	 // 中心点

	AcGePoint3dArray arpts;
	if (GetInterFaceLocal(arpts))
	{
		for (int i = 0; i < arpts.length(); i++)
		{
			gripPoints.append(arpts[i]);
		}
	}
	GetFourConer(gripPoints);// 四角点

	BOOL bHasText = FALSE;
	m_pXDataMap->GetAt(HEQU_HasText, bHasText);
	if (bHasText)
	{
		m_pXDataMap->GetAt(HEQU_TextPoint, ptCenter);
		gripPoints.append(ptCenter);
	}
	
	return Acad::eOk;
}

BOOL THImpHvacEquipment::GetInterFaceLocal(AcGePoint3dArray& arpts) const
{
	if (NULL == m_pXDataMap)
		return FALSE;
	arpts.setLogicalLength(0);
	TDbXDataMap xdatamap;
	int iIfNum(0);
	AcGePoint3d ptInter;
	arpts.setLogicalLength(0);
	m_pXDataMap->GetAt(HEQU_InterfaceNum, iIfNum);
	for (int i = 0; i < iIfNum; i++)
	{
		xdatamap.Empty();
		m_pXDataMap->GetAt(HEQU_Interface, i, xdatamap);
		if (xdatamap.GetAt(HEQUIF_Point, ptInter))
			arpts.append(ptInter);
	}
	return arpts.length() > 0;
}

BOOL THImpHvacEquipment::SetInterFaceLocal(const AcGeMatrix3d& xform) const
{
	if (NULL == m_pXDataMap)
		return FALSE;
	int icount(0);
	m_pXDataMap->GetAt(HEQU_InterfaceNum, icount);
	TDbXDataMap xdatamap;

	CString sName;
	AcGeVector3d vt;
	AcGePoint3d pt;
	for (int i = 0; i < icount; i++)
	{
		xdatamap.Empty();
		m_pXDataMap->GetAt(HEQU_Interface, i, xdatamap);
		xdatamap.GetAt(HEQUIF_Point, pt);
		xdatamap.GetAt(HEQUIF_Vector, vt);
		pt.transformBy(xform);
		vt.transformBy(xform);
		xdatamap.SetAt(HEQUIF_Point, pt);
		xdatamap.SetAt(HEQUIF_Vector, vt);
		m_pXDataMap->SetAt(HEQU_Interface, i, xdatamap);
	}
	return TRUE;
}

BOOL THImpHvacEquipment::SetInterFaceLocal(const AcGeScale3d& scale3d) const
{
	if (NULL == m_pXDataMap)
		return FALSE;
	int icount(0);
	m_pXDataMap->GetAt(HEQU_InterfaceNum, icount);
	
	TDbXDataMap xdatamap;
	CString sName;
	AcGeVector3d vt;
	AcGePoint3d pt;
	for (int i = 0; i < icount; i++)
	{
		xdatamap.Empty();
		m_pXDataMap->GetAt(HEQU_Interface, i, xdatamap);
		xdatamap.GetAt(HEQUIF_Point, pt);
		xdatamap.GetAt(HEQUIF_Vector, vt);
		pt.x *= scale3d.sy;
		pt.y *= scale3d.sx;
		pt.z *= scale3d.sz;
		vt.x *= scale3d.sy;
		vt.y *= scale3d.sx;
		vt.z *= scale3d.sz;
		vt.normalize();
		xdatamap.SetAt(HEQUIF_Point, pt);
		xdatamap.SetAt(HEQUIF_Vector, vt);
		m_pXDataMap->SetAt(HEQU_Interface, i, xdatamap);
	}
	return TRUE;
}

BOOL THImpHvacEquipment::GetInterFaceLocal(int nIndex, AcGePoint3d &pt) const
{
	if (NULL == m_pXDataMap)
		return FALSE;
	TDbXDataMap xdatamap;
	if(m_pXDataMap->GetAt(HEQU_Interface, nIndex, xdatamap))
		return	xdatamap.GetAt(HEQUIF_Point, pt);
	return FALSE;
}

BOOL THImpHvacEquipment::GetInterFaceLocal(int nIndex, int &nType) const
{
	if (NULL == m_pXDataMap)
		return FALSE;
	TDbXDataMap xdatamap;
	if(m_pXDataMap->GetAt(HEQU_Interface, nIndex, xdatamap))
		return xdatamap.GetAt(HEQUIF_Type, nType);
	return FALSE;
}

BOOL THImpHvacEquipment::GetInterFaceLocal(int nIndex, AcGeVector3d &vt) const
{
	if (NULL == m_pXDataMap)
		return FALSE;
	TDbXDataMap xdatamap;
	if(m_pXDataMap->GetAt(HEQU_Interface, nIndex, xdatamap))
		return xdatamap.GetAt(HEQUIF_Vector, vt);
	return FALSE;
}

BOOL THImpHvacEquipment::GetInterFaceLocal(int nIndex, CString &sName) const
{
	if (NULL == m_pXDataMap)
		return FALSE;
	TDbXDataMap xdatamap;
	if(m_pXDataMap->GetAt(HEQU_Interface, nIndex, xdatamap))
	    return xdatamap.GetAt(HEQUIF_Name, sName);
	return FALSE;
}

BOOL THImpHvacEquipment::GetInterFaceLocal(int nIndex, double &dWidth, double &dHeight) const
{
	if (NULL == m_pXDataMap)
		return FALSE;
	TDbXDataMap xdatamap;
	double nw(0.0), nh(0.0);
	if(m_pXDataMap->GetAt(HEQU_Interface, nIndex, xdatamap))
	{
		xdatamap.GetAt(HEQUIF_Width, nw);
		xdatamap.GetAt(HEQUIF_Height, nh);
		dWidth = nw;
		dHeight = nh;
		return TRUE;
	}
	return FALSE;
}

BOOL THImpHvacEquipment::GetIFIndexFormPt(int &nIndex, const AcGePoint3d &pt) const
{
	if (NULL == m_pXDataMap)
		return FALSE;
	TDbXDataMap xdatamap;
	int iIfNum(0);
	m_pXDataMap->GetAt(HEQU_InterfaceNum, iIfNum);
	AcGePoint3d ptIF;
	for (int i = 0; i < iIfNum; i++)
	{
		xdatamap.Empty();
		m_pXDataMap->GetAt(HEQU_Interface, i, xdatamap);
		xdatamap.GetAt(HEQUIF_Point, ptIF);
		if(ptIF.distanceTo(pt) < 3.e-1)				//将接口判断连接精度由1.e-3改为3.e-1
		{
			//第一接口为设备位置点，所以需要+1
			nIndex = i;
			return TRUE;
		}
	}
	nIndex = -1;
	return FALSE;
}

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

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

BOOL THImpHvacEquipment::OPMInfo(LPCTSTR pszName, TDb::OPMInfo* pInfo)
{
	ASSERT(NULL != pszName && NULL != pInfo && NULL != m_pXDataMap);
	// 暖通基本参数设置
	if (0 == _tcsicmp(pszName, KEY_RUNTIME))
	{
		pInfo->bVisible = TRUE;
		pInfo->bEditable = FALSE;

		// 提供数据列表和对应关系
		if (NULL != pInfo->parsValues && NULL != pInfo->parlValues)
		{
			pInfo->parsValues->Add(_T("阀门"));
			pInfo->parlValues->Add(TDb::eValve);
			pInfo->parsValues->Add(_T("设备"));
			pInfo->parlValues->Add(TDb::eEquipment);
			pInfo->parsValues->Add(_T("风口"));
			pInfo->parlValues->Add(TDb::eAirlets);
			pInfo->parsValues->Add(_T("风机"));
			pInfo->parlValues->Add(TDb::eFan);
		}

		return TRUE;
	}

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

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

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

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

		return TRUE;
	}

	if (0 == _tcsicmp(pszName, KEY_Length))
	{
		pInfo->bVisible = TRUE;
		pInfo->bEditable = TRUE;
		// 替代属性，需要特殊处理数据获取和设置
		if (NULL != pInfo->pXData)
		{
			// 获取数据
			if (0 == pInfo->pXData->nVt)
			{
				m_pXDataMap->GetAt(KEY_Length, *pInfo->pXData);
			}
			// 设置数据
			else
			{
				double dLength(1.0);
				m_pXDataMap->GetAt(KEY_Length, dLength);
				AcGePoint3d pt;
				m_pXDataMap->GetAt(KEY_StartPoint, pt);

				if (fabs(dLength) < 1e-6)
				{
					m_pXDataMap->SetAt(KEY_Length, pInfo->pXData->dVal[0]);
					return TRUE;	
				}

				double dtmpVal = pInfo->pXData->dVal[0];
				if (fabs(dtmpVal) < 1e-6)
				{
					return FALSE;
				}

				AcGeMatrix3d mat;
				mat.setToScaling(pInfo->pXData->dVal[0] / dLength, pt);
				transformBy(mat);
				pInfo->pXData->nVt = 0;	// 设置处理完成标识
			}
		}

		return TRUE;
	}

	if (0 == _tcsicmp(pszName, KEY_Width))
	{
		pInfo->bVisible = TRUE;
		pInfo->bEditable = TRUE;
		// 替代属性，需要特殊处理数据获取和设置
		if (NULL != pInfo->pXData)
		{
			// 获取数据
			if (0 == pInfo->pXData->nVt)
			{
				m_pXDataMap->GetAt(KEY_Width, *pInfo->pXData);
				pInfo->pXData->dVal[0] = fabs(pInfo->pXData->dVal[0]);
			}
			// 设置数据
			else
			{
				double dLength(1.0);
				m_pXDataMap->GetAt(KEY_Width, dLength);
				AcGePoint3d pt;
				m_pXDataMap->GetAt(KEY_StartPoint, pt);
				
				if (fabs(dLength) < 1e-6)
				{
					m_pXDataMap->SetAt(KEY_Width, pInfo->pXData->dVal[0]);
					return TRUE;	
				}
				double dtmpVal = pInfo->pXData->dVal[0];
				if (fabs(dtmpVal) < 1e-6)
				{
					return FALSE;
				}

				AcGeMatrix3d mat;
				mat.setToScaling(fabs(pInfo->pXData->dVal[0] / dLength), pt);
				transformBy(mat);
				pInfo->pXData->nVt = 0;	// 设置处理完成标识
			}
		}
		
		return TRUE;
	}

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

		if (NULL != pInfo->pXData)
		{
			// 获取数据
			if (0 == pInfo->pXData->nVt)
			{
				m_pXDataMap->GetAt(KEY_TextHeight, *pInfo->pXData);
			}
			// 设置数据
			else
			{
				m_pXDataMap->SetAt(KEY_TextHeight, pInfo->pXData->dVal[0]);
				pInfo->pXData->nVt = 0;	// 设置处理完成标识
			}
		}

		return TRUE;
	}

	if (0 == _tcsicmp(pszName, KEY_Thick))
	{
		pInfo->bVisible = TRUE;
		pInfo->bEditable = TRUE;
		// 替代属性，需要特殊处理数据获取和设置
		if (NULL != pInfo->pXData)
		{
			// 获取数据
			if (0 == pInfo->pXData->nVt)
			{
				m_pXDataMap->GetAt(KEY_Thick, *pInfo->pXData);
			}
			// 设置数据
			else
			{
				double dLength(1.0);
				m_pXDataMap->GetAt(KEY_Thick, dLength);
				AcGePoint3d pt;
				m_pXDataMap->GetAt(KEY_StartPoint, pt);
				
				if (fabs(dLength) < 1e-6)
				{					
					m_pXDataMap->SetAt(KEY_Thick, pInfo->pXData->dVal[0]);
					return TRUE;					
				}
				double dtmpVal = pInfo->pXData->dVal[0];
				if (fabs(dtmpVal) < 1e-6)
				{
					return FALSE;
				}

				AcGeMatrix3d mat;
				mat.setToScaling(pInfo->pXData->dVal[0] / dLength, pt);
				transformBy(mat);
				pInfo->pXData->nVt = 0;	// 设置处理完成标识
			}
		}
		
		return TRUE;
	}

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

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

		return TRUE;
	}

	return FALSE;
}


BOOL THImpHvacEquipment::GetInterfaceFromXdata(const int& nIndex, const AcGeVector3d& vtOff) const
{
	ASSERT(NULL != m_pXDataMap);

	AcDbObjectId id2d(AcDbObjectId::kNull);
	AcGeVector3d Scale3d;
	m_pXDataMap->GetAt(HEQU_PartCenter,id2d);
	m_pXDataMap->GetAt(HEQU_Scale,Scale3d);
	AcDbBlockTableRecord *pObj;
	if (acdbOpenObject(pObj, id2d, AcDb::kForRead)!=Acad::eOk)
	{
		AfxMessageBox(_T("打开图形失败！"));
		return FALSE;
	}
	if (pObj == NULL)
		return FALSE;
	AcDbBlockTableRecordIterator* pIT = NULL;
	pObj->newIterator(pIT);
	AcDbEntity* pEnt = NULL;
	resbuf *pXData = NULL;
	for (pIT->start(); !pIT->done(); pIT->step())
	{
		pIT->getEntity(pEnt, AcDb::kForRead);
		if (NULL == pEnt)
			return FALSE;
		pXData = pEnt->xData(_T("THLAYEQUIP_IF"));
		if (pXData != NULL)
			break;
	}
	pObj->close();
	delete pIT;
	if (pEnt != NULL)
		pEnt->close();
	AcGePoint3d pt;
	int nIfNum(0);
	if (pXData != NULL)
	{
		resbuf* pRb = pXData;
		pRb = pRb->rbnext;
		if (NULL != pRb && pRb->restype == 1070 )
			nIfNum = pRb->resval.rint;
		for (int i = 0; i < nIfNum; i++)
		{
			pRb = pRb->rbnext;
			pRb = pRb->rbnext;
			if (NULL != pRb && pRb->restype == 1011 )
			{
				pt[0] = pRb->resval.rpoint[0];
				pt[1] = pRb->resval.rpoint[1];
				pt[2] = 0;
			}
			pRb = pRb->rbnext;
			if (i == nIndex - 1)
				break;
		}
		acutRelRb(pXData);
	}
	OPENOBJ_BEGIN(id2d,AcDb::kForWrite,AcDbBlockTableRecord,pblk);
	if (pblk == NULL)
		return FALSE;
	pblk->newIterator(pIT);
	pEnt = NULL;
	for (; !pIT->done(); pIT->step())
	{
		pIT->getEntity(pEnt, AcDb::kForWrite);
		if (pEnt == NULL)
		{
			continue;
		}
		AcDbLine *pLine = AcDbLine::cast(pEnt);
		if (pLine == NULL)
		{
			pEnt->close();
			continue;
		}
		else
		{
			int nCor = pLine->colorIndex();
			double ddis = pLine->startPoint().distanceTo(pLine->endPoint());
			double ddisStr = pLine->startPoint().distanceTo(pt);
			double ddisEnd = pLine->endPoint().distanceTo(pt);
			//颜色是3长度是98
			if (nCor == 3 && fabs(ddis - 98) < 1.e-3)
			{
				if (ddisStr < 1 || ddisEnd < 1)
				{
					AcGeMatrix3d mtx;
					Scale3d.x *= vtOff.x;
					Scale3d.y *= vtOff.y;
					Scale3d.z = 0;
					mtx.setTranslation(Scale3d);
					pLine->transformBy(mtx);
					pEnt->close();
					return TRUE;
				}
			}
			pEnt->close();
			continue;
		}
	}
	OPENOBJ_END();
	return FALSE;	
}

int THImpHvacEquipment::GetXBaseShell(TXShell& xShell)
{
	if (NULL == m_pXDataMap)
	{
		return 0;
	}
	
	// 获得参数
	double dWidth = 0.0;
	m_pXDataMap->GetAt(HEQU_Width, dWidth);
	double dThick = 0.0;
	m_pXDataMap->GetAt(HEQU_Length, dThick);
	double dLength = 0.0;
	m_pXDataMap->GetAt(HEQU_Thick, dLength);
	AcGeVector3d vtNormal;
	m_pXDataMap->GetAt(HEQU_MainDir, vtNormal);
	vtNormal.normalize();
	AcGeVector3d vt;
	m_pXDataMap->GetAt(HVAC_Normal, vt);
	vt.normalize();
	AcGePoint3d ptStart;
	m_pXDataMap->GetAt(HEQU_CenterPoint, ptStart);
	AcGePoint3d ptEnd = ptStart + vt * dLength;
	
	// 构造碰撞实体
	TAuxTools::BuildRectDuct(ptStart, ptEnd, vtNormal, dWidth, dThick, dWidth, dThick, xShell);
	
	return 1;
}

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

	// 获得参数
	double dWidth = 0.0;
	m_pXDataMap->GetAt(HEQU_Width, dWidth);
	double dHalfWidth = dWidth / 2.0;
	double dThick = 0.0;
	m_pXDataMap->GetAt(HEQU_Length, dThick);
	double dHalfThick = dThick / 2.0;
	double dLength = 0.0;
	m_pXDataMap->GetAt(HEQU_Thick, dLength);
	AcGeVector3d vtNormal;
	m_pXDataMap->GetAt(HEQU_MainDir, vtNormal);
	vtNormal.normalize();
	AcGeVector3d vt;
	m_pXDataMap->GetAt(HVAC_Normal, vt);
	vt.normalize();
	AcGePoint3d ptStart;
	m_pXDataMap->GetAt(HEQU_CenterPoint, ptStart);
	AcGePoint3d ptEnd = ptStart + vt * dLength;
	AcGeVector3d vtSide = vt;
	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;
}

// 取得设备相对于原始图块的变换矩阵
BOOL THImpHvacEquipment::GetEquTransMatrix(const AcDbObjectId& idBlock, AcGeMatrix3d& mat) const
{
	if(NULL == m_pXDataMap)
		return FALSE;
	if(idBlock.isNull())
		return FALSE;

	AcGeVector3d vtMain, vtScale, vtNor;
	double dLength = 1;
	double dWidth = 1;
	double dThick = 1;
	AcGePoint3d ptCenter;
	m_pXDataMap->GetAt(HVAC_Normal, vtNor);
	m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HEQU_Length, dLength);
	m_pXDataMap->GetAt(HEQU_Width, dWidth);
	m_pXDataMap->GetAt(HEQU_Thick, dThick);
	m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
	m_pXDataMap->GetAt(HEQU_Scale, vtScale);
	if (dThick < 1)
		dThick = 1;

	// 计算图块比例
	dLength *= vtScale.x;
	dWidth *= vtScale.y;
	dThick *= vtScale.z;

	//如果没有高度值，则高度比例置为1
	if (vtScale.z == 1)
		dThick = 1;
	AcGeScale3d scale(dLength, dWidth, dThick);

	// 取得图块变换矩阵
	AcDbBlockReference refBlock(ptCenter, idBlock);
	refBlock.setScaleFactors(scale);
	refBlock.setRotation(AcGeVector3d::kXAxis.angleTo(vtMain, vtNor));
	mat = refBlock.blockTransform();

	return TRUE;
}

// 按尺寸获取四角点，增加控制夹点用于捕捉定位，不会清空原arrPt
void THImpHvacEquipment::GetFourConer( AcGePoint3dArray &arrPt ) const
{
	if (NULL == m_pXDataMap)
		return;

	AcGePoint3d ptCenter;
	AcGeVector3d vtMain, vtPerl, vtNormal;
	double dLen(1.0), dWidth(1.0);
	m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
	m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
	m_pXDataMap->GetAt(HVAC_Normal, vtNormal);
	vtPerl = vtMain.crossProduct(vtNormal);

	m_pXDataMap->GetAt(HEQU_Width, dWidth);
	m_pXDataMap->GetAt(HEQU_Length, dLen);

	AcGePoint3d ptLeftUp = ptCenter - vtMain*dLen*0.5 - vtPerl*dWidth*0.5;
	AcGePoint3d ptLeftDw = ptLeftUp + vtPerl*dWidth;
	AcGePoint3d ptRightDw = ptLeftDw + vtMain*dLen;
	AcGePoint3d ptRightUp = ptRightDw - vtPerl*dWidth;
	arrPt.append(ptLeftUp);
	arrPt.append(ptLeftDw);
	arrPt.append(ptRightDw);
	arrPt.append(ptRightUp);
}

// 导出XML
// CString THImpHvacEquipment::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(HEQU_SEquipType, csText);
// 		xmlTree.SetItemText(posItemEquipType, csText);
// 	}
// 
// 	POSITION posItemEquipFct = xmlTree.Insert(_T("Equip_Factory"), posRoot, posItemEquipType);
// 	{ 
// 		xmlTree.SetAttribute(posItemEquipFct, _T("name"), _T("设备厂商"));
// 		xmlTree.SetAttribute(posItemEquipFct, _T("comment"), _T("所属厂商名称"));
// 		m_pXDataMap->GetAt(HEQU_SFactory, csText);
// 		xmlTree.SetItemText(posItemEquipFct, csText);
// 	}
// 
// 	POSITION posItemEquipForm = xmlTree.Insert(_T("Equip_Form"), posRoot, posItemEquipFct);
// 	{ 
// 		xmlTree.SetAttribute(posItemEquipForm, _T("name"), _T("结构形式"));
// 		xmlTree.SetAttribute(posItemEquipForm, _T("comment"), _T("明暗装等"));
// 		m_pXDataMap->GetAt(HEQU_Form, csText);
// 		xmlTree.SetItemText(posItemEquipForm, csText);
// 	}
// 
// 	POSITION posItemEquipMode = xmlTree.Insert(_T("Equip_Mode"), posRoot, posItemEquipForm);
// 	{ 
// 		xmlTree.SetAttribute(posItemEquipMode, _T("name"), _T("型号"));
// 		xmlTree.SetAttribute(posItemEquipMode, _T("comment"), _T("设备具体型号"));
// 		m_pXDataMap->GetAt(HEQU_SEquipName, csText);
// 		xmlTree.SetItemText(posItemEquipMode, csText);
// 	}
// 
// 	POSITION posItemEquipName = xmlTree.Insert(_T("EquipName"), posRoot, posItemEquipMode);
// 	{ 
// 		xmlTree.SetAttribute(posItemEquipName, _T("name"), _T("名称"));
// 		xmlTree.SetAttribute(posItemEquipName, _T("comment"), _T("对应图库中的风机名称"));
// 		m_pXDataMap->GetAt(HEQU_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(HEQU_CenterPoint, pt);
// 		TAuxTools::DoubleToString(pt.x, nPtPreci, csX);
// 		TAuxTools::DoubleToString(pt.y, nPtPreci, csY);
// 		TAuxTools::DoubleToString(pt.z, nPtPreci, csZ);
// 		csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
// 		xmlTree.SetItemText(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(HEQU_MainDir, vt);
// 		TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
// 		TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
// 		TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
// 		csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
// 		xmlTree.SetItemText(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(HEQU_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(HEQU_Part3D, id);
// 		csText.Format(_T("%d"), id.asOldId());
// 		xmlTree.SetItemText(posItemPart3D, csText);
// 	}
// 
// 	POSITION posItemMirror = xmlTree.Insert(_T("IsMirror"), posRoot, posItemPart3D);
// 	{ 
// 		xmlTree.SetAttribute(posItemMirror, _T("name"), _T("是否镜像"));
// 		xmlTree.SetAttribute(posItemMirror, _T("comment"), _T("用于辅助绘制0:否,1:是"));
// 		m_pXDataMap->GetAt(HEQU_IsConverse, nValue);
// 		csText.Format(_T("%d"), nValue);
// 		xmlTree.SetItemText(posItemMirror, csText);
// 	}
// 
// 	POSITION posItemLength = xmlTree.Insert(_T("Length"), posRoot, posItemMirror);
// 	{ 
// 		xmlTree.SetAttribute(posItemLength, _T("name"), _T("长度"));
// 		xmlTree.SetAttribute(posItemLength, _T("comment"), _T("设备长度"));
// 		m_pXDataMap->GetAt(HEQU_Length, dValue);
// 		TAuxTools::DoubleToString(dValue, nWhPreci, csText);
// 		xmlTree.SetItemText(posItemLength, csText);
// 	}
// 
// 	POSITION posItemWidth = xmlTree.Insert(_T("Width"), posRoot, posItemLength);
// 	{ 
// 		xmlTree.SetAttribute(posItemWidth, _T("name"), _T("宽度"));
// 		xmlTree.SetAttribute(posItemWidth, _T("comment"), _T("设备宽度"));
// 		m_pXDataMap->GetAt(HEQU_Width, dValue);
// 		TAuxTools::DoubleToString(dValue, nWhPreci, csText);
// 		xmlTree.SetItemText(posItemWidth, csText);
// 	}
// 
// 	POSITION posItemThick = xmlTree.Insert(_T("Thick"), posRoot, posItemWidth);
// 	{ 
// 		xmlTree.SetAttribute(posItemThick, _T("name"), _T("厚度"));
// 		xmlTree.SetAttribute(posItemThick, _T("comment"), _T("设备高度"));
// 		m_pXDataMap->GetAt(HEQU_Thick, dValue);
// 		TAuxTools::DoubleToString(dValue, nWhPreci, csText);
// 		xmlTree.SetItemText(posItemThick, csText);
// 	}
// 
// 	POSITION posItemScale = xmlTree.Insert(_T("Scale"), posRoot, posItemThick);
// 	{ 
// 		xmlTree.SetAttribute(posItemScale, _T("name"), _T("图块比例"));
// 		xmlTree.SetAttribute(posItemScale, _T("comment"), _T("图块比例"));
// 		m_pXDataMap->GetAt(HEQU_Scale, vt);
// 		TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
// 		TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
// 		TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
// 		csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
// 		xmlTree.SetItemText(posItemScale, csText);
// 	}
// 
// 	CString csXml = xmlTree.GetXml();
// 
// 	return csXml;
// }

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

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

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

	// 获得设备转换矩阵Lixl add 2012-2-1
	// 插入点
	XPoint ptLocation;
	m_pXDataMap->GetAt(HEQU_CenterPoint, pt);
	ptLocation = pt;
	// 主方向
	XVector3D vtDirection(0,0,1);
	m_pXDataMap->GetAt(HEQU_MainDir, vt);
	vtDirection = vt;
	// 图块比例
	AcGeVector3d vtScale;
	double dLength(1.0);
	double dWidth(1.0); 
	double dThick(1.0);
	m_pXDataMap->GetAt(HEQU_Length, dLength);
	m_pXDataMap->GetAt(HEQU_Width, dWidth);
	m_pXDataMap->GetAt(HEQU_Thick, dThick);
	m_pXDataMap->GetAt(HEQU_Scale, vtScale);
	if (dThick < 1)
	{
		dThick = 1;
	}
	
	dLength *= vtScale.x;
	dWidth *= vtScale.y;
	dThick *= vtScale.z;
	//如果没有高度值，则高度比例置为1
	if (vtScale.z == 1)
	{
		dThick = 1;
	}
	AcGeScale3d scale3d(dLength, dWidth, dThick);
	
	//非水平面，计算法向
	XVector3D vtNormal(0,0,1);
	if(fabs(vtDirection.z) > 1.0E-6)
	{ 
		vtNormal = XVector3D(1,0,0)*vtDirection;
		vtNormal.Normalize();
	}
	//计算ECS下的转角
	XPoint ptLoc=Wcs2Ecs(ptLocation, vtNormal);
	double nRotEcs = ads_angle(XPoint(),vtDirection);
	m_pXDataMap->GetAt(HEQU_Part3D, id);
	AcDbBlockReference block(ptLoc, id);
	block.setRotation(nRotEcs);
	block.setScaleFactors(scale3d);
	AcGeMatrix3d mat1 = block.blockTransform();
	mat1 = mat * mat1;
	CString sMat;
	TAuxTools::Matrix3D2String(mat1, sMat);

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

	POSITION posItemEquipType = xmlTree.Insert(_T("EquipType"), posRoot, NULL);
	{ 
		xmlTree.SetAttribute(posItemEquipType, _T("name"), _T("设备类型"));
		xmlTree.SetAttribute(posItemEquipType, _T("comment"), _T("设备类型"));
		m_pXDataMap->GetAt(HEQU_SEquipType, csText);
		xmlTree.SetItemText(posItemEquipType, csText);
	}

	POSITION posItemEquipFct = xmlTree.Insert(_T("Equip_Factory"), posRoot, posItemEquipType);
	{ 
		xmlTree.SetAttribute(posItemEquipFct, _T("name"), _T("设备厂商"));
		xmlTree.SetAttribute(posItemEquipFct, _T("comment"), _T("所属厂商名称"));
		m_pXDataMap->GetAt(HEQU_SFactory, csText);
		xmlTree.SetItemText(posItemEquipFct, csText);
	}

	POSITION posItemEquipForm = xmlTree.Insert(_T("Equip_Form"), posRoot, posItemEquipFct);
	{ 
		xmlTree.SetAttribute(posItemEquipForm, _T("name"), _T("结构形式"));
		xmlTree.SetAttribute(posItemEquipForm, _T("comment"), _T("明暗装等"));
		m_pXDataMap->GetAt(HEQU_Form, csText);
		xmlTree.SetItemText(posItemEquipForm, csText);
	}

	POSITION posItemEquipMode = xmlTree.Insert(_T("Equip_Mode"), posRoot, posItemEquipForm);
	{ 
		xmlTree.SetAttribute(posItemEquipMode, _T("name"), _T("型号"));
		xmlTree.SetAttribute(posItemEquipMode, _T("comment"), _T("设备具体型号"));
		m_pXDataMap->GetAt(HEQU_SEquipName, csText);
		xmlTree.SetItemText(posItemEquipMode, csText);
	}

	POSITION posItemNorDir = xmlTree.Insert(_T("NormalDir"),posRoot, posItemEquipMode);
	{
		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(HEQU_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(HEQU_MainDir, vt);
		TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
		TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
		TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
		csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
		xmlTree.SetItemText(posItemMainDir, csText);
	}

	// begin ////
	// mod by wc 13-12-25
	// 原因：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-25 系统图块//
	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);
	}
// delete by wc 13-12-20 跟别的参数重复了
// 	POSITION posItemMirror = xmlTree.Insert(_T("IsMirror"), posRoot, posItemPart3D);
// 	{ 
// 		xmlTree.SetAttribute(posItemMirror, _T("name"), _T("是否镜像"));
// 		xmlTree.SetAttribute(posItemMirror, _T("comment"), _T("用于辅助绘制0:否,1:是"));
// 		m_pXDataMap->GetAt(HEQU_IsConverse, nValue);
// 		csText.Format(_T("%d"), nValue);
// 		xmlTree.SetItemText(posItemMirror, csText);
// 	}

	POSITION posItemLength = xmlTree.Insert(_T("Length"), posRoot, posItemPartSys);
	{ 
		xmlTree.SetAttribute(posItemLength, _T("name"), _T("长度"));
		xmlTree.SetAttribute(posItemLength, _T("comment"), _T("设备长度"));
		m_pXDataMap->GetAt(HEQU_Length, dValue);
		TAuxTools::DoubleToString(dValue, nWhPreci, csText);
		xmlTree.SetItemText(posItemLength, csText);
	}

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

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

	POSITION posItemScale = xmlTree.Insert(_T("Scale"), posRoot, posItemThick);
	{ 
		xmlTree.SetAttribute(posItemScale, _T("name"), _T("图块比例"));
		xmlTree.SetAttribute(posItemScale, _T("comment"), _T("图块比例"));
		m_pXDataMap->GetAt(HEQU_Scale, vt);
		TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
		TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
		TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
		csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
		xmlTree.SetItemText(posItemScale, csText);
	}

	POSITION posItemMat= xmlTree.Insert(_T("Matrix3d"), posRoot, posItemScale);
	{
		xmlTree.SetAttribute(posItemMat, _T("name"), _T("矩阵"));
		xmlTree.SetAttribute(posItemMat, _T("comment"), _T("图块转换矩阵"));
		xmlTree.SetItemText(posItemMat, sMat);
	}
// delete by wc 13-12-25 上面已经加了
// 	POSITION posBlock = xmlTree.Insert(_T("Block"), posRoot, posItemMat);
// 	{
// 		xmlTree.SetAttribute(posBlock, _T("name"), _T("对应图块"));
// 		POSITION posBlock2d = xmlTree.Insert(_T("Block_2D"), posBlock, NULL);
// 		{
// 			xmlTree.SetAttribute(posBlock2d, _T("name"), _T("2D图块名"));
// 			xmlTree.SetAttribute(posBlock2d, _T("comment"), _T("平面图块"));
// 			m_pXDataMap->GetAt(HEQU_PartCenter, id);
// 			OPENOBJ_BEGIN(id, AcDb::kForRead, AcDbBlockTableRecord, pBlk);
// 			if(NULL != pBlk)
// 			{
// 				TCHAR* pName = NULL;
// 				if(Acad::eOk == pBlk->getName(pName))
// 				{
// 					xmlTree.SetItemText(posBlock2d, pName);
// 				}
// 			}
// 			OPENOBJ_END();
// 		}
// 		POSITION posBlock3d = xmlTree.Insert(_T("Block_3D"), posBlock, posBlock2d);
// 		{
// 			xmlTree.SetAttribute(posBlock3d, _T("name"), _T("3D图块名"));
// 			xmlTree.SetAttribute(posBlock3d, _T("comment"), _T("三维图块"));
// 			m_pXDataMap->GetAt(HEQU_Part3D, id);
// 			OPENOBJ_BEGIN(id, AcDb::kForRead, AcDbBlockTableRecord, pBlk);
// 			if(NULL != pBlk)
// 			{
// 				TCHAR* pName = NULL;
// 				if(Acad::eOk == pBlk->getName(pName))
// 				{
// 					xmlTree.SetItemText(posBlock3d, pName);
// 				}
// 			}
// 			OPENOBJ_END();
// 		}
// 	}

	POSITION posObjId = xmlTree.Insert(_T("Object_ID"), posRoot, posItemMat);
	{
		xmlTree.SetAttribute(posObjId, _T("name"),_T("ID"));
		xmlTree.SetAttribute(posObjId, _T("comment"),_T("设备ID"));

		csText.Format(_T("%ld"), 0x7FFFFFFF & m_pOwnerEnt->objectId().asOldId());
		xmlTree.SetItemText(posObjId, csText);
	}


//add by wc 13-12-12

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

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

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

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

	POSITION posItemTextPoint = xmlTree.Insert(_T("TextPoint"), posRoot, posItemHasText);
	{
		xmlTree.SetAttribute(posItemTextPoint, _T("name"), _T("文字基点"));
		xmlTree.SetAttribute(posItemTextPoint, _T("comment"), _T("文字基点"));
		if (m_pXDataMap->GetAt(HEQU_TextPoint, pt))
		{
			TAuxTools::DoubleToString(pt.x, nPtPreci, csX);
			TAuxTools::DoubleToString(pt.y, nPtPreci, csY);
			TAuxTools::DoubleToString(pt.z, nPtPreci, csZ);
			csText.Format(_T("%s, %s, %s"), csX, csY, csZ);
		}
		else
		{
			csText.Format(_T("文字基点读取失败"));
		}
		xmlTree.SetItemText(posItemTextPoint, csText);
	}

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

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

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

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

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

	CString csXml = xmlTree.GetXml();

	return csXml;
}

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

	PolyConvert(*pLine, poly);
	delete pLine;

	return Acad::eOk;
}

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

bool THImpHvacEquipment::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;
}