2122 lines
58 KiB
C++
2122 lines
58 KiB
C++
#include "stdafx.h"
|
||
#include "StdArx.h"
|
||
#include "THImpHvacAirlets.h"
|
||
|
||
#include "TDbInterfaceRecord.h"
|
||
#include "TDbXDataMap.h"
|
||
#include "TDbInterfaceMsgWrite.h"
|
||
#include "math.h"
|
||
#include "dbxutil.h"
|
||
|
||
#ifdef _DEBUG
|
||
#undef THIS_FILE
|
||
static char THIS_FILE[]=__FILE__;
|
||
#define new DEBUG_NEW
|
||
#endif
|
||
|
||
|
||
using namespace TDb;
|
||
|
||
THImpHvacAirlets::THImpHvacAirlets()
|
||
{
|
||
}
|
||
|
||
THImpHvacAirlets::~THImpHvacAirlets()
|
||
{
|
||
}
|
||
|
||
BOOL THImpHvacAirlets::GetInterfaceSizeData(int nIndex, TInterface& pipeInterface) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
// 获取截面类型
|
||
TDb::HvacSectType eSectType = TDb::eRectangular;
|
||
m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
|
||
|
||
// 获取尺寸
|
||
double dWidth = 0.0, dThick = 0.0;
|
||
m_pXDataMap->GetAt(HALT_Width, dWidth);
|
||
m_pXDataMap->GetAt(HALT_Length, dThick);
|
||
dWidth = fabs(dWidth);
|
||
|
||
// 设置接口数据
|
||
pipeInterface.SetType(eSectType);
|
||
pipeInterface.SetSize(dWidth, dThick);
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL THImpHvacAirlets::GetInterface(int nIndex,TInterface& pipeInterface) const
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return FALSE;
|
||
|
||
// 获取各点位置
|
||
AcGePoint3d ptIf = GetIfPoint();
|
||
AcGeVector3d vtNor;
|
||
m_pXDataMap->GetAt(HVAC_Normal, vtNor);
|
||
|
||
AcDbObjectId id;
|
||
switch(nIndex)
|
||
{
|
||
case 0:
|
||
// 如果起始接口和第一个管件连接
|
||
if (m_pXDataMap->GetAt(KEY_IDCNT1, id) && MakesureInterfaceValidate(id, ptIf, vtNor, pipeInterface))
|
||
{
|
||
GetInterfaceSizeData(0, pipeInterface);
|
||
return TRUE;
|
||
}
|
||
// 没有管件连接
|
||
pipeInterface.SetOutDir(vtNor);
|
||
pipeInterface.SetOwnerId(m_pOwnerEnt->objectId());
|
||
pipeInterface.SetPosition(ptIf);
|
||
GetInterfaceSizeData(0, pipeInterface);
|
||
return TRUE;
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
BOOL THImpHvacAirlets::GetInterface(const AcGePoint3d& ptCon,TInterface& pipeInterface) const
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return FALSE;
|
||
|
||
// 获取各点位置
|
||
AcGePoint3d ptIf = GetIfPoint();
|
||
AcGeVector3d vtNor;
|
||
m_pXDataMap->GetAt(HVAC_Normal, vtNor);
|
||
|
||
// 计算测试点到始末点的距离
|
||
double dDist1 = ptCon.distanceTo(ptIf);
|
||
AcDbObjectId id;
|
||
|
||
// 位于起始点
|
||
if (dDist1 < 1.e-3)
|
||
{
|
||
// 如果起始接口和第一个管件连接
|
||
if (m_pXDataMap->GetAt(KEY_IDCNT1, id) && MakesureInterfaceValidate(id, ptIf, vtNor, pipeInterface))
|
||
{
|
||
GetInterfaceSizeData(0, pipeInterface);
|
||
return TRUE;
|
||
}
|
||
// 没有管件连接
|
||
pipeInterface.SetOutDir(vtNor);
|
||
pipeInterface.SetOwnerId(m_pOwnerEnt->objectId());
|
||
pipeInterface.SetPosition(ptIf);
|
||
GetInterfaceSizeData(0, pipeInterface);
|
||
return TRUE;
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
BOOL THImpHvacAirlets::HasInterface(const AcGePoint3d& ptCon,const AcGeVector3d& vtDir)
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return FALSE;
|
||
|
||
// 获取各点位置
|
||
AcGePoint3d ptStart = GetIfPoint();
|
||
AcGeVector3d vtNor;
|
||
m_pXDataMap->GetAt(HVAC_Normal, vtNor);
|
||
|
||
// 计算测试点到始末点的距离
|
||
double dDist1 = ptCon.distanceTo(ptStart);
|
||
|
||
// 位于起始点
|
||
if (dDist1 < 1.e-3)
|
||
return (vtDir.isParallelTo(vtNor));
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
int THImpHvacAirlets::GetInterfaceCount() const
|
||
{
|
||
return 1;
|
||
}
|
||
|
||
BOOL THImpHvacAirlets::SetInterfaceRelation(const AcGePoint3d& ptConnect,const AcDbObjectId& idConnect)
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return FALSE;
|
||
|
||
// 打开对象
|
||
AcDbEntity* pEnt;
|
||
if (Acad::eOk != acdbOpenObject(pEnt, idConnect, AcDb::kForRead))
|
||
return FALSE;
|
||
|
||
// 检查对象类型，是否是暖通管件
|
||
if (!(pEnt->isKindOf(TDbHvacDuct::desc()) || pEnt->isKindOf(TDbHvacFitting::desc())
|
||
|| pEnt->isKindOf(TDbHvacEquipment::desc())))
|
||
{
|
||
pEnt->close();
|
||
return FALSE;
|
||
}
|
||
|
||
// 获取各点位置
|
||
AcGePoint3d ptStart = GetIfPoint();
|
||
AcGeVector3d vtNor;
|
||
m_pXDataMap->GetAt(HVAC_Normal, vtNor);
|
||
|
||
// 计算测试点到始末点的距离
|
||
double dDist1 = ptConnect.distanceTo(ptStart);
|
||
|
||
// 基类指针
|
||
TDbInterfacesObj* pInterfaceObj = TDbInterfacesObj::cast(pEnt);
|
||
ASSERT(NULL != pInterfaceObj);
|
||
|
||
// 位于起始点
|
||
if (dDist1 < 1.e-3 && pInterfaceObj->HasInterface(ptStart, vtNor))
|
||
{
|
||
m_pXDataMap->SetAt(KEY_IDCNT1, idConnect);
|
||
pEnt->close();
|
||
return TRUE;
|
||
}
|
||
pEnt->close();
|
||
return FALSE;
|
||
}
|
||
|
||
BOOL THImpHvacAirlets::RemoveInterfaceRelation(const AcGePoint3d& ptConnect,const AcDbObjectId& idConnect)
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return FALSE;
|
||
|
||
// 浅层次删除; 命名字典中的关系,需要外面移除关系,只移除内部关系
|
||
AcDbObjectId id;
|
||
m_pXDataMap->GetAt(KEY_IDCNT1, id);
|
||
if (id == idConnect)
|
||
{
|
||
m_pXDataMap->SetAt(KEY_IDCNT1, AcDbObjectId::kNull);
|
||
return TRUE;
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
BOOL THImpHvacAirlets::NotifyInterfaceToModify(const TInterfaceModifyMsg& iModiMsg,
|
||
TInterfaceModifyMsgs& iModiMsgs)
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return FALSE;
|
||
|
||
// 获得消息传递设置, 确定是否传递消息
|
||
CString sDispatch = _T("0");
|
||
GetGlobalContext(KEY_DISPATCHMSG, sDispatch);
|
||
BOOL bDispatch = (_ttoi(sDispatch) != 0);
|
||
|
||
BOOL bMsgTranslate = FALSE;
|
||
// 获得消息类型, 根据消息类型处理
|
||
TDb::InterfaceOper eOper = iModiMsg.GetInterfaceOper();
|
||
switch (eOper)
|
||
{
|
||
case TDb::eMoveGripPoint:
|
||
// 夹点移动消息处理
|
||
bMsgTranslate = OnMoveGripPointMsgNotify(iModiMsg, iModiMsgs);
|
||
break;
|
||
default:
|
||
return bMsgTranslate;
|
||
}
|
||
|
||
// 记录修改标识
|
||
if (m_pOwnerEnt != NULL)
|
||
m_pOwnerEnt->recordGraphicsModified();
|
||
|
||
return bMsgTranslate;
|
||
}
|
||
|
||
BOOL THImpHvacAirlets::OnMoveGripPointMsgNotify( const TInterfaceModifyMsg& iModiMsg,
|
||
TInterfaceModifyMsgs& iModiMsgs )
|
||
{
|
||
|
||
if (!TAuxTools::IsAutoWorkOffset())
|
||
return FALSE;
|
||
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
AcDbObjectId id = iModiMsg.GetMsgOperateOn();
|
||
AcDbObjectId idOwner = m_pOwnerEnt->objectId();
|
||
if (id != idOwner) // 消息发送目标正确
|
||
return FALSE;
|
||
|
||
AcGeVector3d vtOffset = iModiMsg.GetMoveGripOffset();
|
||
if (vtOffset.isZeroLength())
|
||
return FALSE;
|
||
|
||
BOOL bMsgTranslate = FALSE;
|
||
|
||
int nPos = iModiMsg.GetGripPosition();
|
||
if (nPos == eStart || nPos == eMid || nPos == eEnd || nPos == eBr1 || nPos == eBr2)
|
||
{
|
||
AcGePoint3d ptCenter;
|
||
m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
|
||
ptCenter += vtOffset;
|
||
m_pXDataMap->SetAt(HALT_CenterPoint, ptCenter);
|
||
|
||
// 更新模型空间的扩展字典的注册的接口数据
|
||
AcGeMatrix3d xform;
|
||
xform.setToTranslation(vtOffset);
|
||
UpdateInterfaceRec(m_pOwnerEnt->objectId(), xform);
|
||
}
|
||
|
||
return bMsgTranslate;
|
||
}
|
||
|
||
BOOL THImpHvacAirlets::MakeCurves(TComplexCurve& cplCurve) const
|
||
{
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL THImpHvacAirlets::GetCurvesInSide(TComplexCurve& compCurve) const
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
AcDbPolyline* THImpHvacAirlets::MakePolyCurve() const
|
||
{
|
||
//
|
||
// 1
|
||
// 1 ┃━━━━━┃ 3 /-------\
|
||
// ┃ ┃ / \
|
||
// ┃ 0 ┃ 3 | 0 | 4
|
||
// ┃ ┃ \ /
|
||
// 2 ┃━━━━━┃ 4 \_______/
|
||
// 2
|
||
//
|
||
// 获取各点位置
|
||
AcGePoint3d pt1, pt2, pt3, pt4, ptCenter;
|
||
AcGePoint3d ptU1, ptU2, ptU3, ptU4;
|
||
AcGeVector3d vtMain, vtNor, vtMainv;
|
||
double dLength(50.0), dThick(50.0), dWidth(50.0);
|
||
AcDbDatabase* pDb = acdbCurDwg();
|
||
AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
||
int nIsSide(0);
|
||
TDb::HvacSectType eSectType = TDb::eRectangular;
|
||
m_pXDataMap->GetAt(HVAC_SectType,(int&)eSectType);
|
||
m_pXDataMap->GetAt(HVAC_Normal, vtNor);
|
||
m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
|
||
m_pXDataMap->GetAt(HEQU_MainDir, vtMain);
|
||
m_pXDataMap->GetAt(HEQU_Length, dLength);
|
||
m_pXDataMap->GetAt(HEQU_Width, dWidth);
|
||
m_pXDataMap->GetAt(HALT_IsSide, nIsSide);
|
||
m_pXDataMap->GetAt(HALT_Thick, dThick);
|
||
|
||
if (dLength < 1)
|
||
dLength = 1.0;
|
||
if (dWidth < 1)
|
||
dWidth = 1.0;
|
||
if (dThick < 1)
|
||
dThick = 1.0;
|
||
|
||
AcDbPolyline* pPolyLine = NULL;
|
||
//方口
|
||
if (eSectType == TDb::eRectangular)
|
||
{
|
||
AcGePoint3dArray arpts;
|
||
//侧风口标高在中心线上
|
||
if (nIsSide == 1)
|
||
{
|
||
vtMainv = vtNor;
|
||
vtMainv.rotateBy(PI * 0.5, vtMain);
|
||
vtNor.normalize();
|
||
vtMainv.normalize();
|
||
pt1 = ptCenter + vtMainv * dWidth * 0.5;
|
||
pt2 = ptCenter - vtMainv * dWidth * 0.5;
|
||
pt3 = pt1 + vtNor * dThick;
|
||
pt4 = pt2 + vtNor * dThick;
|
||
|
||
ptU1 = pt1 + vtMain * dLength * 0.5;
|
||
ptU2 = pt2 + vtMain * dLength * 0.5;
|
||
ptU3 = pt3 + vtMain * dLength * 0.5;
|
||
ptU4 = pt4 + vtMain * dLength * 0.5;
|
||
pt1 = pt1 - vtMain * dLength * 0.5;
|
||
pt2 = pt2 - vtMain * dLength * 0.5;
|
||
pt3 = pt3 - vtMain * dLength * 0.5;
|
||
pt4 = pt4 - vtMain * dLength * 0.5;
|
||
if (vtMain.angleTo(pDb->ucsxdir()) < PI * 0.25 || vtMain.angleTo(-pDb->ucsxdir()) < PI * 0.25)
|
||
{
|
||
ptU2.z = pt2.z = ptU1.z = pt1.z = ptCenter.z;
|
||
arpts.append(ptU2);
|
||
arpts.append(pt2);
|
||
arpts.append(pt1);
|
||
arpts.append(ptU1);
|
||
}
|
||
else if (vtMain.angleTo(pDb->ucsydir()) < PI * 0.25 || vtMain.angleTo(-pDb->ucsydir()) < PI * 0.25)
|
||
{
|
||
ptU1.z = pt1.z = ptU3.z = pt3.z = ptCenter.z;
|
||
arpts.append(ptU1);
|
||
arpts.append(pt1);
|
||
arpts.append(pt3);
|
||
arpts.append(ptU3);
|
||
}
|
||
else
|
||
{
|
||
arpts.append(pt1);
|
||
arpts.append(pt2);
|
||
arpts.append(pt4);
|
||
arpts.append(pt3);
|
||
}
|
||
}
|
||
//散流器标高在底部
|
||
else
|
||
{
|
||
vtMainv = vtMain;
|
||
vtMainv.rotateBy(PI * 0.5, vtNor);
|
||
vtMain.normalize();
|
||
vtMainv.normalize();
|
||
pt1 = ptCenter + vtMainv * dWidth * 0.5;
|
||
pt2 = ptCenter - vtMainv * dWidth * 0.5;
|
||
pt1 = pt1 - vtMain * dLength *0.5;
|
||
pt3 = pt1 + vtMain * dLength;
|
||
pt2 = pt2 - vtMain * dLength *0.5;
|
||
pt4 = pt2 + vtMain * dLength;
|
||
ptU1 = pt1 + vtNor * dThick;
|
||
ptU2 = pt2 + vtNor * dThick;
|
||
ptU3 = pt3 + vtNor * dThick;
|
||
ptU4 = pt4 + vtNor * dThick;
|
||
if (vtNor.angleTo(pDb->ucsxdir()) < PI * 0.25 || vtNor.angleTo(-pDb->ucsxdir()) < PI * 0.25)
|
||
{
|
||
ptU2.z = pt2.z = ptU1.z = pt1.z = ptCenter.z;
|
||
arpts.append(ptU2);
|
||
arpts.append(pt2);
|
||
arpts.append(pt1);
|
||
arpts.append(ptU1);
|
||
}
|
||
else if (vtNor.angleTo(pDb->ucsydir()) < PI * 0.25 || vtNor.angleTo(-pDb->ucsydir()) < PI * 0.25)
|
||
{
|
||
ptU1.z = pt1.z = ptU3.z = pt3.z = ptCenter.z;
|
||
arpts.append(ptU1);
|
||
arpts.append(pt1);
|
||
arpts.append(pt3);
|
||
arpts.append(ptU3);
|
||
}
|
||
else
|
||
{
|
||
arpts.append(pt1);
|
||
arpts.append(pt2);
|
||
arpts.append(pt4);
|
||
arpts.append(pt3);
|
||
}
|
||
}
|
||
|
||
AcGePlane plan(arpts[0], arpts[1], arpts[2]);
|
||
AcGePoint3d ptOrth = AcGePoint3d::kOrigin.orthoProject(plan);
|
||
plan.set(ptOrth, vtZAxis);
|
||
|
||
double dEl = ptOrth.asVector().length();
|
||
if (!ptOrth.asVector().isCodirectionalTo(plan.normal()))
|
||
{
|
||
dEl *= -1.0;
|
||
}
|
||
pPolyLine = new AcDbPolyline;
|
||
pPolyLine->addVertexAt(0,arpts[0].convert2d(plan));
|
||
pPolyLine->addVertexAt(1,arpts[1].convert2d(plan));
|
||
pPolyLine->addVertexAt(2,arpts[2].convert2d(plan));
|
||
pPolyLine->addVertexAt(3,arpts[3].convert2d(plan));
|
||
pPolyLine->setClosed(Adesk::kTrue);
|
||
pPolyLine->setElevation(dEl);
|
||
pPolyLine->setNormal(plan.normal());
|
||
}
|
||
//圆口
|
||
else
|
||
{
|
||
//侧风口
|
||
if (nIsSide == 1)
|
||
{
|
||
pPolyLine = new AcDbPolyline;
|
||
if(vtMain.angleTo(pDb->ucsxdir()) < PI*0.25 || vtMain.angleTo(-pDb->ucsxdir()) < PI*0.25)
|
||
{
|
||
TAuxTools::GetEllipseFromCircle(ptCenter, dLength, vtNor, vtZAxis,*pPolyLine);
|
||
}
|
||
else if(vtMain.angleTo(pDb->ucsydir()) < PI*0.25 || vtMain.angleTo(-pDb->ucsydir()) < PI*0.25)
|
||
{
|
||
vtMainv = vtMain;
|
||
vtMainv.rotateBy(PI * 0.5, vtNor);
|
||
vtMain.normalize();
|
||
vtMainv.normalize();
|
||
pt1 = ptCenter + vtMain * dLength * 0.5;
|
||
pt2 = ptCenter - vtMain * dLength * 0.5;
|
||
pt3 = pt1 + vtNor * dThick;
|
||
pt4 = pt2 + vtNor * dThick;
|
||
AcGePlane plan(pt1, pt2, pt3);
|
||
AcGePoint3d ptOrth = AcGePoint3d::kOrigin.orthoProject(plan);
|
||
plan.set(ptOrth, vtZAxis);
|
||
|
||
double dEl = ptOrth.asVector().length();
|
||
if (!ptOrth.asVector().isCodirectionalTo(plan.normal()))
|
||
{
|
||
dEl *= -1.0;
|
||
}
|
||
pPolyLine->addVertexAt(0, pt1.convert2d(plan));
|
||
pPolyLine->addVertexAt(1, pt2.convert2d(plan));
|
||
pPolyLine->addVertexAt(2, pt4.convert2d(plan));
|
||
pPolyLine->addVertexAt(3, pt3.convert2d(plan));
|
||
pPolyLine->setClosed(Adesk::kTrue);
|
||
pPolyLine->setElevation(dEl);
|
||
pPolyLine->setNormal(plan.normal());
|
||
}
|
||
else
|
||
{
|
||
vtMainv = vtNor;
|
||
vtMainv.rotateBy(PI * 0.5, vtMain);
|
||
vtMain.normalize();
|
||
vtMainv.normalize();
|
||
pt1 = ptCenter + vtMainv * dLength * 0.5;
|
||
pt2 = ptCenter - vtMainv * dLength * 0.5;
|
||
pt3 = pt1 + vtNor * dThick;
|
||
pt4 = pt2 + vtNor * dThick;
|
||
AcGePlane plan(pt1, pt2, pt3);
|
||
AcGePoint3d ptOrth = AcGePoint3d::kOrigin.orthoProject(plan);
|
||
plan.set(ptOrth, vtZAxis);
|
||
|
||
double dEl = ptOrth.asVector().length();
|
||
if (!ptOrth.asVector().isCodirectionalTo(plan.normal()))
|
||
{
|
||
dEl *= -1.0;
|
||
}
|
||
pPolyLine->addVertexAt(0, pt1.convert2d(plan));
|
||
pPolyLine->addVertexAt(1, pt2.convert2d(plan));
|
||
pPolyLine->addVertexAt(2, pt4.convert2d(plan));
|
||
pPolyLine->addVertexAt(3, pt3.convert2d(plan));
|
||
pPolyLine->setClosed(Adesk::kTrue);
|
||
pPolyLine->setElevation(dEl);
|
||
pPolyLine->setNormal(plan.normal());
|
||
}
|
||
}
|
||
else
|
||
{
|
||
vtMainv = vtMain;
|
||
vtMainv.rotateBy(PI * 0.5, vtNor);
|
||
vtMain.normalize();
|
||
vtMainv.normalize();
|
||
pt1 = ptCenter + vtMainv * dLength * 0.5;
|
||
pt2 = ptCenter - vtMainv * dLength * 0.5;
|
||
pt3 = ptCenter - vtMain * dLength * 0.5;
|
||
pt4 = ptCenter + vtMain * dLength * 0.5;
|
||
pt1.z = pt2.z = pt3.z = pt4.z = ptCenter.z;
|
||
|
||
if (vtNor.angleTo(vtZAxis) < PI * 0.25 || vtNor.angleTo(-vtZAxis) < PI * 0.25)
|
||
{
|
||
AcGePlane plan(pt1, pt2, pt3);
|
||
AcGePoint3d ptOrth = AcGePoint3d::kOrigin.orthoProject(plan);
|
||
plan.set(ptOrth, vtZAxis);
|
||
double dEl = ptOrth.asVector().length();
|
||
if (ptOrth.asVector().angleTo(plan.normal()) > PI*0.5)
|
||
dEl *= -1.0;
|
||
|
||
pPolyLine = new AcDbPolyline;
|
||
pPolyLine->addVertexAt(0, pt1.convert2d(plan),1.0);
|
||
pPolyLine->addVertexAt(1, pt2.convert2d(plan),1.0);
|
||
pPolyLine->setClosed(Adesk::kTrue);
|
||
pPolyLine->setElevation(dEl);
|
||
pPolyLine->setNormal(plan.normal());
|
||
}
|
||
else if (vtNor.angleTo(pDb->ucsxdir()) < PI*0.25 || vtNor.angleTo(-pDb->ucsxdir()) < PI*0.25)
|
||
{
|
||
pt3 = pt1 + vtNor * dThick;
|
||
pt4 = pt2 + vtNor * dThick;
|
||
AcGePlane plan(pt1, pt2, pt3);
|
||
AcGePoint3d ptOrth = AcGePoint3d::kOrigin.orthoProject(plan);
|
||
plan.set(ptOrth, vtZAxis);
|
||
double dEl = ptOrth.asVector().length();
|
||
if (ptOrth.asVector().angleTo(plan.normal()) > PI*0.5)
|
||
dEl *= -1.0;
|
||
|
||
pPolyLine = new AcDbPolyline;
|
||
pPolyLine->addVertexAt(0, pt1.convert2d(plan));
|
||
pPolyLine->addVertexAt(1, pt2.convert2d(plan));
|
||
pPolyLine->addVertexAt(2, pt4.convert2d(plan));
|
||
pPolyLine->addVertexAt(3, pt3.convert2d(plan));
|
||
pPolyLine->setClosed(Adesk::kTrue);
|
||
pPolyLine->setElevation(dEl);
|
||
pPolyLine->setNormal(plan.normal());
|
||
}
|
||
else if (vtNor.angleTo(pDb->ucsydir()) < PI * 0.25 || vtNor.angleTo(-pDb->ucsydir()) < PI * 0.25)
|
||
{
|
||
pt1 = pt3 + vtNor * dThick;
|
||
pt2 = pt4 + vtNor * dThick;
|
||
|
||
AcGePlane plan(pt1, pt2, pt3);
|
||
AcGePoint3d ptOrth = AcGePoint3d::kOrigin.orthoProject(plan);
|
||
plan.set(ptOrth, vtZAxis);
|
||
double dEl = ptOrth.asVector().length();
|
||
if (ptOrth.asVector().angleTo(plan.normal()) > PI*0.5)
|
||
dEl *= -1.0;
|
||
|
||
pPolyLine = new AcDbPolyline;
|
||
pPolyLine->addVertexAt(0, pt1.convert2d(plan));
|
||
pPolyLine->addVertexAt(1, pt2.convert2d(plan));
|
||
pPolyLine->addVertexAt(2, pt4.convert2d(plan));
|
||
pPolyLine->addVertexAt(3, pt3.convert2d(plan));
|
||
pPolyLine->setClosed(Adesk::kTrue);
|
||
pPolyLine->setElevation(dEl);
|
||
pPolyLine->setNormal(plan.normal());
|
||
}
|
||
}
|
||
}
|
||
|
||
return pPolyLine;
|
||
}
|
||
|
||
BOOL THImpHvacAirlets::MakePolyCurveFaces(AcDbVoidPtrArray& arFaces)
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
void THImpHvacAirlets::GetKindName(CString& sName)
|
||
{
|
||
sName = _T("TCH_HAIRLETS");
|
||
}
|
||
|
||
BOOL THImpHvacAirlets::GetGeomExtentsEdge(TComplexCurve& crLoop)
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
TDb::Position THImpHvacAirlets::ExplainGripIndex(int nIndex) const
|
||
{
|
||
switch(nIndex)
|
||
{
|
||
case 0:
|
||
{
|
||
return TDb::eMid;
|
||
break;
|
||
}
|
||
case 1:
|
||
{
|
||
return TDb::eCommand0;
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
return TDb::eMid;
|
||
}
|
||
|
||
Acad::ErrorStatus THImpHvacAirlets::GetGripText(int i, CString &cs) const
|
||
{
|
||
switch(i)
|
||
{
|
||
case 0:
|
||
{
|
||
cs = _T("移动");
|
||
break;
|
||
}
|
||
case 1:
|
||
{
|
||
cs = _T("风管接口"); //启动绘制命令，2010-06-02，wyd
|
||
break;
|
||
}
|
||
}
|
||
return Acad::eOk;
|
||
}
|
||
|
||
void THImpHvacAirlets::GetTips(CMapStringToString& mapLable2Tip) const
|
||
{
|
||
}
|
||
|
||
Acad::ErrorStatus THImpHvacAirlets::ExplodeOrDraw3d(XExplodeDraw &mode) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
|
||
AcGePoint3d ptCenter;
|
||
AcDbObjectId idCen,id3D;
|
||
m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
|
||
m_pXDataMap->GetAt(HALT_PartCenter, idCen);
|
||
m_pXDataMap->GetAt(HALT_Part3D, id3D);
|
||
InserBlockCen(mode, ptCenter, id3D);
|
||
if (id3D == idCen)
|
||
{
|
||
Draw3dBox(mode);
|
||
}
|
||
return Acad::eOk;
|
||
}
|
||
|
||
AcGeVector3d THImpHvacAirlets::GetNormal() const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
AcDbDatabase* pDb = acdbCurDwg();
|
||
AcGeVector3d vtZ = pDb->ucsxdir().crossProduct(pDb->ucsydir());
|
||
return vtZ.normalize();
|
||
}
|
||
|
||
AcGePoint3d THImpHvacAirlets::GetStartPt() const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
// 获取各点位置
|
||
AcGePoint3d ptCenter;
|
||
AcGeVector3d vtMain;
|
||
double dLength(50.0);
|
||
m_pXDataMap->GetAt(HALT_MainDir, vtMain);
|
||
m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
|
||
m_pXDataMap->GetAt(HALT_Length, dLength);
|
||
vtMain.normalize();
|
||
return ptCenter - vtMain * dLength * 0.5;
|
||
}
|
||
|
||
AcGePoint3d THImpHvacAirlets::GetEndPt() const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
// 获取各点位置
|
||
AcGePoint3d ptCenter;
|
||
AcGeVector3d vtMain;
|
||
double dLength(50.0);
|
||
m_pXDataMap->GetAt(HALT_MainDir, vtMain);
|
||
m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
|
||
m_pXDataMap->GetAt(HALT_Length, dLength);
|
||
vtMain.normalize();
|
||
return ptCenter + vtMain * dLength * 0.5;
|
||
}
|
||
|
||
AcGePoint3d THImpHvacAirlets::GetHandPt() const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
// 获取各点位置
|
||
AcGePoint3d ptCenter;
|
||
AcGeVector3d vtMain;
|
||
double dWidth(50.0);
|
||
m_pXDataMap->GetAt(HALT_MainDir, vtMain);
|
||
m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
|
||
m_pXDataMap->GetAt(HALT_Width, dWidth);
|
||
vtMain.rotateBy(PI * 0.5,GetNormal());
|
||
vtMain.normalize();
|
||
return ptCenter + vtMain * dWidth * 0.5;
|
||
}
|
||
|
||
Acad::ErrorStatus THImpHvacAirlets::ExplodeOrDraw2d(XExplodeDraw &mode) const
|
||
{
|
||
if (m_pXDataMap == NULL)
|
||
{
|
||
return Acad::eNotImplementedYet;
|
||
}
|
||
|
||
AcGePoint3d ptCenter;
|
||
AcDbObjectId idCen;
|
||
m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
|
||
m_pXDataMap->GetAt(HALT_PartCenter, idCen);
|
||
InserBlockCen(mode, ptCenter, idCen);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus THImpHvacAirlets::InserBlockCen(XExplodeDraw &mode, AcGePoint3d ptCenter, AcDbObjectId idBlock) const
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
AcGeVector3d vtMain, vtScale, vtNor;
|
||
double dLength(1.0);
|
||
double dWidth(1.0);
|
||
double dThick(1.0);
|
||
m_pXDataMap->GetAt(HVAC_Normal, vtNor);
|
||
m_pXDataMap->GetAt(HALT_Length, dLength);
|
||
m_pXDataMap->GetAt(HALT_Width, dWidth);
|
||
m_pXDataMap->GetAt(HALT_Thick, dThick);
|
||
m_pXDataMap->GetAt(HALT_MainDir, vtMain);
|
||
m_pXDataMap->GetAt(HALT_Scale, vtScale);
|
||
|
||
double dAngle(0.0);
|
||
//侧风口
|
||
if (vtNor.isPerpendicularTo(GetNormal()))
|
||
{
|
||
double dscale = vtScale.x;
|
||
dLength *= dscale;
|
||
dWidth *= vtScale.y;
|
||
dThick *= vtScale.z;
|
||
dAngle = AcGeVector3d::kXAxis.angleTo(vtNor,GetNormal());
|
||
}
|
||
else
|
||
{
|
||
dLength *= vtScale.x;
|
||
dWidth *= vtScale.y;
|
||
dThick *= vtScale.z;
|
||
dAngle = AcGeVector3d::kXAxis.angleTo(vtMain,GetNormal());
|
||
}
|
||
|
||
AcGeScale3d scale(dLength, dWidth, 1);
|
||
|
||
// change by hh 2011-05-31 兼容8.2版以前的风口
|
||
// add by hh 2011-01-05 侧风口定义变更：
|
||
// 与X轴平行的边为高，与Y轴平行的边为长，与Z轴平行的边为宽
|
||
// if(vtNor.isPerpendicularTo(GetNormal()))
|
||
// scale.set(dThick, dLength, 1);
|
||
// add end
|
||
CString sVersion;
|
||
if(!m_pXDataMap->GetAt(HVAC_EntVersion, sVersion))
|
||
{
|
||
// 8.2版风口转换为8.5版
|
||
m_pXDataMap->SetAt(HVAC_EntVersion, THVAC_EQU_VERSION_CURRENT);
|
||
sVersion = THVAC_EQU_VERSION_CURRENT;
|
||
if(vtNor.isPerpendicularTo(GetNormal()))
|
||
{
|
||
double dThickRev = dLength / vtScale.z;
|
||
m_pXDataMap->SetAt(HALT_Thick, dThickRev);
|
||
dThick = dThickRev * vtScale.z;
|
||
}
|
||
}
|
||
// 侧风口与X轴平行的边为高，与Y轴平行的边为宽，与Z轴平行的边为长
|
||
if(vtNor.isPerpendicularTo(GetNormal()))
|
||
scale.set(dThick, dWidth, 1);
|
||
|
||
AcDbObject * pObj;
|
||
XPoint xpoint = ptCenter;
|
||
if (acdbOpenObject(pObj, idBlock, AcDb::kForRead)!=Acad::eOk) return Acad::eNotImplementedYet;
|
||
AcDbBlockTableRecord * pBlock = AcDbBlockTableRecord::cast(pObj);
|
||
if (pBlock == NULL)
|
||
{
|
||
pObj->close();
|
||
return Acad::eNotImplementedYet;
|
||
}
|
||
mode.DrawBlock(*pBlock, xpoint, scale, dAngle, TRUE);
|
||
pObj->close();
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////
|
||
//
|
||
//
|
||
// 1 ┏━━━━━┓ 2
|
||
// ┃ ┃
|
||
// ┃ ┃
|
||
// ┃ 0 ┃
|
||
// ┃ ┃
|
||
// 4 ┗━━━━━┛3
|
||
//
|
||
//
|
||
BOOL THImpHvacAirlets::GetBoxPts(AcGePoint3dArray &arPts) const
|
||
{
|
||
// 获取各点位置
|
||
AcGePoint3d ptStart, ptEnd, ptCenter;
|
||
AcGeVector3d vtMain, vtNor, vtMainv;
|
||
double dLength(50.0), dThick(50.0), dWidth(50.0);
|
||
m_pXDataMap->GetAt(HVAC_Normal, vtNor);
|
||
m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
|
||
m_pXDataMap->GetAt(HALT_MainDir, vtMain);
|
||
m_pXDataMap->GetAt(HALT_Length, dLength);
|
||
m_pXDataMap->GetAt(HALT_Width, dWidth);
|
||
m_pXDataMap->GetAt(HALT_Thick, dThick);
|
||
vtMainv = vtMain;
|
||
vtMainv.rotateBy(PI * 0.5, vtNor);
|
||
vtMain.normalize();
|
||
vtMainv.normalize();
|
||
//0
|
||
arPts.append(ptCenter);
|
||
AcGePoint3d pt;
|
||
pt = ptCenter - vtMain * dWidth * 0.5;
|
||
pt = pt + vtMainv * dThick * 0.5;
|
||
//1
|
||
arPts.append(pt);
|
||
//2
|
||
arPts.append(arPts[1] + vtMain * dWidth);
|
||
//3
|
||
arPts.append(arPts[2] - vtMainv * dThick);
|
||
//4
|
||
arPts.append(arPts[1] - vtMainv * dThick);
|
||
return TRUE;
|
||
}
|
||
|
||
void THImpHvacAirlets::list() const
|
||
{
|
||
if (m_pXDataMap != NULL)
|
||
{
|
||
|
||
AcGePoint3d ptCenter;
|
||
AcGeVector3d vtMain;
|
||
CString sType,sName;
|
||
double dLength(50.0), dThick(50.0), dWidth(50.0), dPlusEdge(50.0);
|
||
double dairload(0);
|
||
m_pXDataMap->GetAt(HALT_SEquipType, sType);
|
||
m_pXDataMap->GetAt(HALT_SEquipName, sName);
|
||
m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
|
||
m_pXDataMap->GetAt(HALT_MainDir, vtMain);
|
||
m_pXDataMap->GetAt(HALT_Length, dLength);
|
||
m_pXDataMap->GetAt(HALT_Width, dWidth);
|
||
m_pXDataMap->GetAt(HALT_Thick, dThick);
|
||
m_pXDataMap->GetAt(HVAC_AirLoad, dairload);
|
||
dWidth = fabs(dWidth);
|
||
|
||
acutPrintf(_T("\n\t\t\t\t\t\t\t\t%s"),sType);
|
||
acutPrintf(_T("\n\t\t\t\t\t型号: %s"),sName);
|
||
acutPrintf(_T("\n\t\t\t\t\t风口风量(m^3/h): %.0f"),dairload);
|
||
acutPrintf(_T("\n\t\t\t\t\t长度: %.0fmm"),dLength);
|
||
acutPrintf(_T("\n\t\t\t\t\t宽度: %.0fmm"),dWidth);
|
||
acutPrintf(_T("\n\t\t\t\t\t高度: %.0fmm"),dThick);
|
||
acutPrintf(_T("\n\t\t\t\t\t标高: %.0fm"),ptCenter.z * 0.001);
|
||
}
|
||
}
|
||
|
||
Acad::ErrorStatus THImpHvacAirlets::transformBy(const AcGeMatrix3d& xform)
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return Acad::eNotApplicable;
|
||
|
||
// 取得位置点
|
||
AcGePoint3d ptCenter;
|
||
AcGeVector3d vtMain,vtAirWay,vtNor;
|
||
m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
|
||
m_pXDataMap->GetAt(HALT_MainDir, vtMain);
|
||
m_pXDataMap->GetAt(HALT_AirWay, vtAirWay);
|
||
m_pXDataMap->GetAt(HVAC_Normal, vtNor);
|
||
AcGeVector3d vtPrep(vtNor.crossProduct(vtMain));
|
||
|
||
// 变换位置
|
||
ptCenter.transformBy(xform);
|
||
vtMain.transformBy(xform);
|
||
vtAirWay.transformBy(xform);
|
||
vtNor.transformBy(xform);
|
||
vtPrep.transformBy(xform);
|
||
// 同向是旋转，不变号，反向是镜像，变号。
|
||
int iSign = ((vtPrep.isCodirectionalTo(vtNor.crossProduct(vtMain))) ? 1 : -1);
|
||
// 对风口做镜像操作的时候,为保证风口的宽仍保持正值,修改图块比例Lixl add 2012-3-26
|
||
if (iSign == -1)
|
||
{
|
||
AcGeVector3d vtScale;
|
||
m_pXDataMap->GetAt(HALT_Scale, vtScale);
|
||
vtScale.y = -fabs(vtScale.y);
|
||
m_pXDataMap->SetAt(HALT_Scale, vtScale);
|
||
}
|
||
|
||
// 更新点
|
||
m_pXDataMap->SetAt(HALT_CenterPoint, ptCenter);
|
||
m_pXDataMap->SetAt(HALT_MainDir, vtMain);
|
||
m_pXDataMap->SetAt(HALT_AirWay, vtAirWay);
|
||
m_pXDataMap->SetAt(HVAC_Normal, vtNor);
|
||
|
||
double dscale = xform.scale();
|
||
double dLength(1.0);
|
||
double dWidth(1.0);
|
||
double dThick(1.0);
|
||
m_pXDataMap->GetAt(HALT_Length, dLength);
|
||
m_pXDataMap->GetAt(HALT_Width, dWidth);
|
||
// 更新
|
||
m_pXDataMap->SetAt(HALT_Length, dLength * dscale);
|
||
m_pXDataMap->SetAt(HALT_Width, dWidth * dscale/* * iSign*/);
|
||
|
||
// 传递消息及更新接口记录
|
||
if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
|
||
{
|
||
// 如果实体不是在当前模型空间中,不做写消息,更新接口处理
|
||
AcDbDatabase* pDb = m_pOwnerEnt->database();
|
||
if (pDb == NULL) pDb = acdbCurDwg();
|
||
|
||
AcDbObjectId idModel;
|
||
AcDbBlockTable* pTable = NULL;
|
||
pDb->getBlockTable(pTable, AcDb::kForRead);
|
||
if (pTable != NULL)
|
||
{
|
||
pTable->getAt(ACDB_MODEL_SPACE, idModel);
|
||
pTable->close();
|
||
}
|
||
|
||
// 如果实体不是在当前模型空间中,不做写消息,更新接口处理
|
||
if (idModel == m_pOwnerEnt->blockId())
|
||
{
|
||
// 写入接口更改消息
|
||
// TInterfaceModifyMsg iMsg;
|
||
// iMsg.SetInterfaceOper(TDb::eTransformBy);
|
||
// iMsg.SetMsgValidate(TRUE);
|
||
// iMsg.SetTransform(xform);
|
||
// iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());
|
||
//
|
||
// TDbInterfaceMsgWrite msgWrite;
|
||
// msgWrite.WriteInterfaceMsg(iMsg);
|
||
|
||
//更新接口记录接口信息
|
||
UpdateInterfaceRec(m_pOwnerEnt->objectId(), xform);
|
||
}
|
||
}
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus THImpHvacAirlets::getStretchPoints(AcGePoint3dArray& stretchPoints) const
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return Acad::eNotApplicable;
|
||
|
||
// 取得位置点
|
||
AcGePoint3d ptCenter;
|
||
m_pXDataMap->GetAt(HEQU_CenterPoint, ptCenter);
|
||
|
||
stretchPoints.append(ptCenter);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus THImpHvacAirlets::moveStretchPointsAt(const AcDbIntArray& indices,
|
||
const AcGeVector3d& offset)
|
||
{
|
||
return moveGripPointsAt(indices,offset);
|
||
}
|
||
|
||
Acad::ErrorStatus THImpHvacAirlets::moveGripPointsAt(const AcDbIntArray& indices,
|
||
const AcGeVector3d& offset)
|
||
{
|
||
ASSERT(NULL != m_pXDataMap);
|
||
int nSize = indices.length();
|
||
if (nSize > 0)
|
||
{
|
||
|
||
// 取得位置点
|
||
AcGePoint3d ptCenter;
|
||
m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
|
||
AcGeVector3d vtMain,vtMainv;
|
||
m_pXDataMap->GetAt(HALT_MainDir, vtMain);
|
||
double dThick;
|
||
m_pXDataMap->GetAt(HALT_Thick, dThick);
|
||
// 选择多个夹点,以first为准
|
||
int nIndex = indices.first();
|
||
TDb::Position ePos = ExplainGripIndex(nIndex);
|
||
switch(ePos)
|
||
{
|
||
case TDb::eMid:
|
||
{
|
||
TDb::InterfaceOper eOper = TDb::eMoveGripPoint;
|
||
AcGeVector3d vtMove = offset;
|
||
|
||
ptCenter += vtMove;
|
||
|
||
m_pXDataMap->SetAt(HALT_CenterPoint, ptCenter);
|
||
|
||
// if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
|
||
// {
|
||
// // 写入接口更改消息
|
||
// TInterfaceModifyMsg iMsg;
|
||
// iMsg.SetMsgPoint(ptCenter);//new pos
|
||
// iMsg.SetGripPosition(TDb::eMid);
|
||
// iMsg.SetMoveGripOffset(vtMove);
|
||
// if (eOper == TDb::eTransformBy)
|
||
// iMsg.SetTransform(vtMove);
|
||
// iMsg.SetMsgValidate(TRUE);
|
||
// iMsg.SetInterfaceOper(eOper);
|
||
// iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());
|
||
// TDbInterfaceMsgWrite msgWrite;
|
||
// msgWrite.WriteInterfaceMsg(iMsg);
|
||
//
|
||
// //更新接口记录接口信息
|
||
// AcGeMatrix3d xform;
|
||
// xform.setToTranslation(vtMove);
|
||
// UpdateInterfaceRec(m_pOwnerEnt->objectId(),xform);
|
||
// }
|
||
break;
|
||
}
|
||
case TDb::eCommand0:
|
||
{
|
||
// 获得夹点命令
|
||
CString sCmdStr;
|
||
GetGlobalContext()->GetAt(KEY_HVACGRIPCMD, sCmdStr);
|
||
if (sCmdStr.IsEmpty())
|
||
return Acad::eNotApplicable;
|
||
AcGePoint3d ptCom = ptCenter;
|
||
// 写入接口更改消息
|
||
TInterfaceModifyMsg iMsg;
|
||
iMsg.SetMsgPoint(ptCom);//new pos
|
||
iMsg.SetGripPosition(TDb::eCommand0);
|
||
iMsg.SetMoveGripOffset(offset);
|
||
iMsg.SetMsgValidate(TRUE);
|
||
iMsg.SetInterfaceOper(TDb::eNewCommand);
|
||
iMsg.SetPreviewObjToCreate(TDb::eAirlets, 0);
|
||
|
||
AcDbSoftPointerId idOwner;
|
||
m_pXDataMap->GetAt(KEY_THISID,idOwner);
|
||
iMsg.SetMsgOperateOn(idOwner);
|
||
TDbInterfaceMsgWrite msgWrite;
|
||
msgWrite.WriteInterfaceMsg(iMsg);
|
||
|
||
// 发送消息
|
||
acedPostCommand(_T("\33"));
|
||
acedPostCommand(sCmdStr + _T("\n"));
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus THImpHvacAirlets::intersectWith(const AcDbEntity* pEnt,
|
||
AcDb::Intersect intType,
|
||
const AcGePlane& projPlane,
|
||
AcGePoint3dArray& points,
|
||
INT_PTR thisGsMarker,
|
||
INT_PTR otherGsMarker) const
|
||
{
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus THImpHvacAirlets::intersectWith(const AcDbEntity* pEnt,
|
||
AcDb::Intersect intType,
|
||
AcGePoint3dArray& points,
|
||
INT_PTR thisGsMarker,
|
||
INT_PTR otherGsMarker) const
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus THImpHvacAirlets::getOsnapPoints(AcDb::OsnapMode osnapMode,
|
||
INT_PTR gsSelectionMark,
|
||
const AcGePoint3d& pickPoint,
|
||
const AcGePoint3d& lastPoint,
|
||
const AcGeMatrix3d& viewXform,
|
||
AcGePoint3dArray& snapPoints,
|
||
AcDbIntArray& geomIds) const
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return Acad::eNotApplicable;
|
||
AcGePoint3d ptCenter;
|
||
m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
|
||
|
||
// 根据捕捉模式处理
|
||
switch(osnapMode)
|
||
{
|
||
case AcDb::kOsModeEnd:
|
||
break;
|
||
case AcDb::kOsModeMid:
|
||
break;
|
||
case AcDb::kOsModeCen:
|
||
snapPoints.append(ptCenter);
|
||
break;
|
||
case AcDb::kOsModePerp:
|
||
break;
|
||
case AcDb::kOsModeNear:
|
||
break;
|
||
}
|
||
// add by hh 2011-07-12 支持任意位置捕捉
|
||
TImpSpecEquipment::getOsnapPoints(osnapMode, gsSelectionMark, pickPoint, lastPoint,
|
||
viewXform, snapPoints, geomIds);
|
||
|
||
// delete by hh 2011-07-12 捕捉算法改进
|
||
/*BOOL bIsSide = FALSE; // 是否侧风口
|
||
m_pXDataMap->GetAt(HALT_IsSide, bIsSide);
|
||
int nType = 0; // 风口截面类型
|
||
m_pXDataMap->GetAt(HVAC_SectType, nType);
|
||
|
||
AcDbPolyline* pPolyLine = MakePolyCurve();
|
||
if (NULL == pPolyLine)
|
||
return Acad::eOk;
|
||
|
||
snapPoints.append(ptCenter);
|
||
if(eRectangular == (HvacSectType)nType) // 方形
|
||
{
|
||
AcDbVoidPtrArray arrLine;
|
||
pPolyLine->explode(arrLine);
|
||
for(int i = 0; i < arrLine.length(); i++)
|
||
{
|
||
AcDbObject* pObj = (AcDbObject*)arrLine[i];
|
||
if(NULL == pObj)
|
||
continue;
|
||
|
||
AcDbCurve* pCurve = AcDbCurve::cast(pObj);
|
||
if(NULL != pCurve)
|
||
{
|
||
pCurve->getOsnapPoints(osnapMode, gsSelectionMark, pickPoint,
|
||
lastPoint, viewXform, snapPoints, geomIds);
|
||
delete pObj;
|
||
}
|
||
}
|
||
}
|
||
else // 圆形/椭圆形
|
||
{
|
||
pPolyLine->getOsnapPoints(osnapMode, gsSelectionMark, pickPoint,
|
||
lastPoint, viewXform, snapPoints, geomIds);
|
||
}
|
||
delete pPolyLine;*/
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus THImpHvacAirlets::getGripPoints(AcGePoint3dArray& gripPoints,
|
||
AcDbIntArray& osnapModes,
|
||
AcDbIntArray& geomIds) const
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
return Acad::eNotApplicable;
|
||
// 取得位置点
|
||
AcGeVector3d vtMain,vtNor;
|
||
AcGePoint3d ptCenter;
|
||
double dLength;
|
||
double dThick;
|
||
double dWidth;
|
||
m_pXDataMap->GetAt(HVAC_Normal, vtNor);
|
||
m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
|
||
m_pXDataMap->GetAt(HALT_MainDir, vtMain);
|
||
m_pXDataMap->GetAt(HALT_Length, dLength);
|
||
m_pXDataMap->GetAt(HALT_Width, dWidth);
|
||
m_pXDataMap->GetAt(HALT_Thick, dThick);
|
||
//移动夹点
|
||
gripPoints.append(ptCenter); //STA
|
||
|
||
AcDbObjectId id3d;
|
||
m_pXDataMap->GetAt(HALT_Part3D, id3d);
|
||
|
||
//增加命令夹点
|
||
AcGePoint3d ptGeCmd1; //按 10 个像素点
|
||
// double dCmd = PixelToWcs(10);
|
||
AcDbDatabase* pDb = acdbCurDwg();
|
||
AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
||
if (vtNor.isPerpendicularTo(vtZAxis))
|
||
{
|
||
vtMain = vtNor;
|
||
}
|
||
AcGeVector3d vtMainv = vtMain;
|
||
vtMainv.rotateBy(PI * 0.5, GetNormal());
|
||
vtMainv.normalize();
|
||
vtMain.normalize();
|
||
if (IsHorzAlignment())
|
||
{
|
||
//BEGIN=====================================================
|
||
AcGeVector3d vtScale;
|
||
m_pXDataMap->GetAt(HALT_Scale, vtScale);
|
||
if (vtScale.x < 0)
|
||
{
|
||
ptGeCmd1 = ptCenter + vtMain * dLength * -0.5;
|
||
}
|
||
else
|
||
{
|
||
ptGeCmd1 = ptCenter + vtMain * dLength * 0.5;
|
||
}
|
||
|
||
if (vtScale.y < 0)
|
||
{
|
||
ptGeCmd1 = ptGeCmd1 + vtMainv * dWidth * -0.5;
|
||
}
|
||
else
|
||
{
|
||
ptGeCmd1 = ptGeCmd1 + vtMainv * dWidth * 0.5;
|
||
}
|
||
//修改时间：2010-05-25
|
||
//修改人 ：王亚东
|
||
//修改原因：修复BUG2591，支持翻转时夹点的旋转
|
||
//END======================================================
|
||
}
|
||
else
|
||
{
|
||
ptGeCmd1 = ptCenter + GetNormal() * dThick;
|
||
}
|
||
gripPoints.append(ptGeCmd1); //cmd
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus THImpHvacAirlets::getGeomExtents(AcDbExtents& extents) const
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus THImpHvacAirlets::getClassID(CLSID* pClsid) const
|
||
{
|
||
// #if (ADS < 16)
|
||
// // {C7DFDF6A-A5F2-4add-ADCC-7AC0675AB6E8}
|
||
// CLSID CLSID_PipeBaseEntity = {0xC7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xE8 }};
|
||
// #endif
|
||
//
|
||
// #if (ADS == 16)
|
||
// // {C7DFDF6A-A5F2-4add-ADCC-7AC0675AB6E9}
|
||
// CLSID CLSID_PipeBaseEntity = {0xC7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xE9 }};
|
||
// #endif
|
||
//
|
||
// #if (ADS == 17)
|
||
// // {C7DFDF6A-A5F2-4add-ADCC-7AC0675AB6EA}
|
||
// CLSID CLSID_PipeBaseEntity = {0xC7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xEA }};
|
||
// #endif
|
||
//
|
||
// #if (ADS == 18)
|
||
// CLSID CLSID_PipeBaseEntity = {0xD7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xEB }};
|
||
// #endif
|
||
//
|
||
// #if (ADS == 19)
|
||
// CLSID CLSID_PipeBaseEntity = {0xD7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xEB }};
|
||
// #endif
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus THImpHvacAirlets::explode(AcDbVoidPtrArray& entitySet) const
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
|
||
//////////////////////////////////////////////////////////
|
||
//
|
||
//
|
||
// 1 ┏━━━━━┓ 2
|
||
// ┃ ┃
|
||
// ┃ ┃
|
||
// ┃ 0 ┃
|
||
// ┃ ┃
|
||
// 4 ┗━━━━━┛3
|
||
//
|
||
//
|
||
BOOL THImpHvacAirlets::Draw3dBox(XExplodeDraw &mode) const
|
||
{
|
||
TDb::HvacSectType eSectType = TDb::eRectangular;
|
||
m_pXDataMap->GetAt(HVAC_SectType,(int&)eSectType);
|
||
|
||
AcGePoint3d ptCenter;
|
||
AcGePoint3dArray arPts;
|
||
AcGeVector3d vtMain, vtNor, vtMainv, vtz = GetNormal();
|
||
double dLength(50.0), dThick(50.0), dWidth(50.0);
|
||
m_pXDataMap->GetAt(HVAC_Normal, vtNor);
|
||
m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
|
||
m_pXDataMap->GetAt(HALT_MainDir, vtMain);
|
||
m_pXDataMap->GetAt(HALT_Length, dLength);
|
||
m_pXDataMap->GetAt(HALT_Width, dWidth);
|
||
m_pXDataMap->GetAt(HALT_Thick, dThick);
|
||
|
||
vtMainv = vtMain;
|
||
vtMainv.rotateBy(PI * 0.5, vtz);
|
||
vtMain.normalize();
|
||
vtMainv.normalize();
|
||
AcGePoint3d pt;
|
||
|
||
//方截面
|
||
if (eSectType == TDb::eRectangular)
|
||
{
|
||
//侧风口
|
||
if (vtNor.isPerpendicularTo(vtz))
|
||
{
|
||
vtMainv = vtNor;
|
||
vtMainv.rotateBy(PI * 0.5, vtz);
|
||
vtMain.normalize();
|
||
vtMainv.normalize();
|
||
vtNor.normalize();
|
||
|
||
//0
|
||
arPts.append(ptCenter);
|
||
|
||
pt = ptCenter + vtMainv * dWidth * 0.5;
|
||
pt = pt - vtMain * dLength * 0.5;
|
||
//1
|
||
arPts.append(pt);
|
||
//2
|
||
arPts.append(arPts[1] + vtNor * dThick);
|
||
//3
|
||
arPts.append(arPts[2] - vtMainv * dWidth);
|
||
//4
|
||
arPts.append(arPts[1] - vtMainv * dWidth);
|
||
dThick = dLength;
|
||
// change by hh 2011-01-05 3D视图下 长和宽定义交换
|
||
/*pt = ptCenter + vtMainv * dLength * 0.5;
|
||
pt = pt - vtMain * dWidth * 0.5;
|
||
arPts.append(pt);
|
||
arPts.append(arPts[1] + vtNor * dThick);
|
||
arPts.append(arPts[2] - vtMainv * dLength);
|
||
arPts.append(arPts[1] - vtMainv * dLength);
|
||
dThick = dWidth;*/
|
||
}
|
||
else
|
||
{
|
||
//0
|
||
arPts.append(ptCenter);
|
||
pt = ptCenter - vtMain * dLength * 0.5;
|
||
pt = pt + vtMainv * dWidth * 0.5;
|
||
//1
|
||
arPts.append(pt);
|
||
//2
|
||
arPts.append(arPts[1] + vtMain * dLength);
|
||
//3
|
||
arPts.append(arPts[2] - vtMainv * dWidth);
|
||
//4
|
||
arPts.append(arPts[1] - vtMainv * dWidth);
|
||
}
|
||
AcGePoint3dArray arptSides;
|
||
arptSides.append(arPts[1] + vtz * dThick );
|
||
arptSides.append(arPts[4] + vtz * dThick );
|
||
arptSides.append(arPts[4]);
|
||
arptSides.append(arPts[1]);
|
||
arptSides.append(arPts[1] + vtz * dThick );
|
||
|
||
arptSides.append(arPts[2] + vtz * dThick );
|
||
arptSides.append(arPts[3] + vtz * dThick );
|
||
arptSides.append(arPts[3]);
|
||
arptSides.append(arPts[2]);
|
||
arptSides.append(arPts[2] + vtz * dThick );
|
||
mode.DrawMesh(2, 5, arptSides.asArrayPtr());
|
||
|
||
arptSides.setLogicalLength(0);
|
||
arptSides.append(arPts[1] + vtz * dThick);
|
||
arptSides.append(arPts[1] );
|
||
arptSides.append(arPts[4] + vtz * dThick);
|
||
arptSides.append(arPts[4]);
|
||
mode.DrawMesh(2, 2, arptSides.asArrayPtr());
|
||
arptSides.setLogicalLength(0);
|
||
arptSides.append(arPts[2] + vtz * dThick);
|
||
arptSides.append(arPts[2]);
|
||
arptSides.append(arPts[3] + vtz * dThick);
|
||
arptSides.append(arPts[3]);
|
||
mode.DrawMesh(2, 2, arptSides.asArrayPtr());
|
||
}
|
||
//圆
|
||
else
|
||
{
|
||
double dMinDiffAng = PI/12;
|
||
GetGlobalContext()->GetAt(KEY_MINDIFFANG,dMinDiffAng);
|
||
int nSect = int(PI * 2 / dMinDiffAng) + 1;
|
||
AcGePoint3dArray arptSides,arptSidesD;
|
||
AcGePoint3d pt;
|
||
AcGePoint3d ptC;
|
||
//侧风口
|
||
if (vtNor.isPerpendicularTo(vtz))
|
||
{
|
||
// ptC = ptCenter;
|
||
// pt = ptCenter + vtMainv * dLength * 0.5;
|
||
// for (int i = 0; i < nSect; i++)
|
||
// {
|
||
// arptSides.append(pt);
|
||
// pt.rotateBy(dMinDiffAng, vtNor, ptC);
|
||
// }
|
||
ptC = ptCenter;
|
||
pt = ptC + vtMainv * dLength * 0.5;
|
||
for (int i = 0; i < nSect; i++)
|
||
{
|
||
arptSides.append(pt);
|
||
pt.rotateBy(dMinDiffAng, vtNor, ptC);
|
||
}
|
||
ptCenter += vtNor * dThick;
|
||
}
|
||
else
|
||
{
|
||
ptC = ptCenter;
|
||
pt = ptC + vtMainv * dLength * 0.5;
|
||
for (int i = 0; i < nSect; i++)
|
||
{
|
||
arptSides.append(pt);
|
||
pt.rotateBy(dMinDiffAng, vtNor, ptC);
|
||
}
|
||
ptCenter += vtNor * dThick;
|
||
// ptC = ptCenter + vtNor * dThick;
|
||
// pt = ptC + vtMainv * dLength * 0.5;
|
||
// for (i = 0; i < nSect; i++)
|
||
// {
|
||
// arptSides.append(pt);
|
||
// pt.rotateBy(dMinDiffAng, vtNor, ptC);
|
||
// }
|
||
}
|
||
// mode.DrawMesh(2, nSect, arptSides.asArrayPtr());
|
||
XPoly2D xploy2d;
|
||
XPoint xpt;
|
||
XVector3D xvt = ptCenter - ptC;
|
||
for (int i = 0; i < nSect; i++)
|
||
{
|
||
xpt = arptSides[i];
|
||
xploy2d.AppendNode(xpt);
|
||
}
|
||
mode.DrawBody(xploy2d,xvt);
|
||
// AcDbFace *pface = new AcDbFace;
|
||
// AcDbFace *pface1 = new AcDbFace;
|
||
// for (int i = 0; i < nSect - 1; i++)
|
||
// {
|
||
// pface->setVertexAt(0, ptCenter);
|
||
// pface->setVertexAt(1, arptSides[i]);
|
||
// pface->setVertexAt(2, arptSides[i + 1]);
|
||
// pface->setVertexAt(3, ptCenter);
|
||
// X3DFace x3dface(*pface);
|
||
// mode.DrawFace(x3dface);
|
||
//
|
||
// pface1->setVertexAt(0, ptC);
|
||
// pface1->setVertexAt(1, arptSides[nSect + i]);
|
||
// pface1->setVertexAt(2, arptSides[nSect + i + 1]);
|
||
// pface1->setVertexAt(3, ptC);
|
||
// X3DFace x3dface1(*pface1);
|
||
// mode.DrawFace(x3dface1);
|
||
// }
|
||
}
|
||
return TRUE;
|
||
}
|
||
BOOL THImpHvacAirlets::IsHorzAlignment() const
|
||
{
|
||
// 取得位置点
|
||
AcGeVector3d vtMain;
|
||
AcGePoint3d ptCenter;
|
||
m_pXDataMap->GetAt(HALT_CenterPoint, ptCenter);
|
||
m_pXDataMap->GetAt(HALT_MainDir, vtMain);
|
||
AcGeVector3d vtCross = GetNormal();
|
||
|
||
// 获得UCS坐标Z向量
|
||
AcDbDatabase* pDb = acdbCurDwg();
|
||
AcGeVector3d vtZAxis(pDb->ucsxdir().crossProduct(pDb->ucsydir()));
|
||
AcGeVector3d vtXAxis(pDb->ucsxdir());
|
||
AcGeVector3d vtYAxis(pDb->ucsydir());
|
||
|
||
if (vtCross.isParallelTo(vtZAxis))
|
||
{
|
||
BOOL BBB = TRUE;
|
||
}
|
||
|
||
if (vtCross.isParallelTo(vtXAxis))
|
||
{
|
||
BOOL BBB = TRUE;
|
||
}
|
||
|
||
if (vtCross.isParallelTo(vtYAxis))
|
||
{
|
||
BOOL BBB = TRUE;
|
||
}
|
||
return vtCross.isParallelTo(vtZAxis);
|
||
}
|
||
|
||
BOOL THImpHvacAirlets::OPMInfo(LPCTSTR pszName, TDb::OPMInfo* pInfo)
|
||
{
|
||
ASSERT(NULL != pszName && NULL != pInfo && NULL != m_pXDataMap);
|
||
// 暖通基本参数设置
|
||
if (0 == _tcsicmp(pszName, KEY_RUNTIME))
|
||
{
|
||
pInfo->bVisible = TRUE;
|
||
pInfo->bEditable = FALSE;
|
||
|
||
// 提供数据列表和对应关系
|
||
if (NULL != pInfo->parsValues && NULL != pInfo->parlValues)
|
||
{
|
||
pInfo->parsValues->Add(_T("风口"));
|
||
pInfo->parlValues->Add(TDb::eAirlets);
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
if (0 == _tcsicmp(pszName, KEY_Name))
|
||
{
|
||
pInfo->bVisible = TRUE;
|
||
pInfo->bEditable = FALSE;
|
||
return TRUE;
|
||
}
|
||
|
||
if (0 == _tcsicmp(pszName, KEY_Model))
|
||
{
|
||
pInfo->bVisible = TRUE;
|
||
pInfo->bEditable = TRUE;
|
||
return TRUE;
|
||
}
|
||
|
||
if (0 == _tcsicmp(pszName, KEY_AirLoad))
|
||
{
|
||
pInfo->bVisible = TRUE;
|
||
pInfo->bEditable = TRUE;
|
||
return TRUE;
|
||
}
|
||
|
||
if (0 == _tcsicmp(pszName, KEY_StartPoint))
|
||
{
|
||
pInfo->bVisible = TRUE;
|
||
pInfo->bEditable = TRUE;
|
||
// 整体移动
|
||
if (NULL != pInfo->pXData && 0 != pInfo->pXData->nVt)
|
||
{
|
||
// 改变顶点变换行为
|
||
AcGePoint3d pt;
|
||
m_pXDataMap->GetAt(KEY_StartPoint, pt);
|
||
AcGeVector3d offset = asPnt3d(pInfo->pXData->dVal) - pt;
|
||
|
||
AcGeMatrix3d mat;
|
||
mat.setToTranslation(offset);
|
||
transformBy(mat);
|
||
pInfo->pXData->nVt = 0; // 设置处理完成标识
|
||
//TAuxTools::SetAndUpdateCover((TDbInterfacesObj*)m_pOwnerEnt, pszName, pInfo);
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
if (0 == _tcsicmp(pszName, KEY_Length))
|
||
{
|
||
pInfo->bVisible = TRUE;
|
||
pInfo->bEditable = TRUE;
|
||
return TRUE;
|
||
}
|
||
|
||
if (0 == _tcsicmp(pszName, KEY_Width))
|
||
{
|
||
pInfo->bVisible = TRUE;
|
||
pInfo->bEditable = TRUE;
|
||
|
||
//BEGIN===================================================
|
||
if (NULL != pInfo->pXData)
|
||
{
|
||
if (0 == pInfo->pXData->nVt) //显示数据
|
||
{
|
||
if (m_pXDataMap->GetAt(HALT_Width, *pInfo->pXData)) //风口宽度值为负值时，只显示正值
|
||
{
|
||
pInfo->pXData->dVal[0] = fabs(pInfo->pXData->dVal[0]);
|
||
}
|
||
}
|
||
else //设置数据
|
||
{
|
||
double dAltWidth = 0.0;
|
||
if (m_pXDataMap->GetAt(HALT_Width, dAltWidth) && dAltWidth < 0.0) //原风口宽度值为负值时，设置为负值
|
||
{
|
||
dAltWidth = pInfo->pXData->dVal[0];
|
||
m_pXDataMap->SetAt(HALT_Width, -fabs(dAltWidth));
|
||
}
|
||
else //原风口宽度值为正值时，设置为正值
|
||
{
|
||
dAltWidth = pInfo->pXData->dVal[0];
|
||
m_pXDataMap->SetAt(HALT_Width, fabs(dAltWidth));
|
||
}
|
||
pInfo->pXData->nVt = 0; // 设置处理完成标识
|
||
}
|
||
}
|
||
//修改时间：2010-01-27
|
||
//修改人 ：王亚东
|
||
//修改原因：修正风口镜像后宽度显示负值的错误
|
||
//END=====================================================
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
if (0 == _tcsicmp(pszName, KEY_Thick))
|
||
{
|
||
pInfo->bVisible = TRUE;
|
||
pInfo->bEditable = TRUE;
|
||
return TRUE;
|
||
}
|
||
|
||
// 多联机样式 为了注册列表名，保证其他管件能用到此参数
|
||
if (0 == _tcsicmp(pszName, HVRV_IType))
|
||
{
|
||
pInfo->bVisible = FALSE;
|
||
pInfo->bEditable = FALSE;
|
||
|
||
// 提供数据列表和对应关系
|
||
if (NULL != pInfo->parsValues && NULL != pInfo->parlValues)
|
||
{
|
||
pInfo->parlValues->Add(0);
|
||
pInfo->parsValues->Add(_T("室内机"));
|
||
pInfo->parlValues->Add(1);
|
||
pInfo->parsValues->Add(_T("室外机"));
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
int THImpHvacAirlets::GetXBaseShell(TXShell& xShell)
|
||
{
|
||
int nRet = 0;
|
||
if (NULL == m_pXDataMap)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
HvacSectType eSectType;
|
||
m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
|
||
if (TDb::eRectangular == eSectType)
|
||
{
|
||
// 获得参数
|
||
double dWidth = 0.0;
|
||
m_pXDataMap->GetAt(HALT_Width, dWidth);
|
||
double dThick = 0.0;
|
||
m_pXDataMap->GetAt(HALT_Length, dThick);
|
||
double dLength = 0.0;
|
||
m_pXDataMap->GetAt(HALT_Thick, dLength);
|
||
AcGeVector3d vtNormal;
|
||
m_pXDataMap->GetAt(HALT_MainDir, vtNormal);
|
||
vtNormal.normalize();
|
||
AcGePoint3d ptStart;
|
||
m_pXDataMap->GetAt(HALT_CenterPoint, ptStart);
|
||
AcGeVector3d vtMain;
|
||
m_pXDataMap->GetAt(HVAC_Normal, vtMain);
|
||
vtMain.normalize();
|
||
AcGePoint3d ptEnd = ptStart + vtMain * dLength;
|
||
|
||
// 构造碰撞实体
|
||
TAuxTools::BuildRectDuct(ptStart, ptEnd, vtNormal, dWidth, dThick, dWidth, dThick, xShell);
|
||
|
||
nRet = 1;
|
||
}
|
||
else if (TDb::eCircular == eSectType)
|
||
{
|
||
// 获得参数
|
||
double dDiameter = 0.0;
|
||
m_pXDataMap->GetAt(HALT_Diameter, dDiameter);
|
||
double dLength = 0.0;
|
||
m_pXDataMap->GetAt(HALT_Thick, dLength);
|
||
AcGeVector3d vtNormal;
|
||
m_pXDataMap->GetAt(HALT_MainDir, vtNormal);
|
||
vtNormal.normalize();
|
||
AcGePoint3d ptStart;
|
||
m_pXDataMap->GetAt(HALT_CenterPoint, ptStart);
|
||
AcGeVector3d vtMain;
|
||
m_pXDataMap->GetAt(HVAC_Normal, vtMain);
|
||
vtMain.normalize();
|
||
AcGePoint3d ptEnd = ptStart + vtMain * dLength;
|
||
|
||
// 构造碰撞实体
|
||
TAuxTools::BuildCirDuct(ptStart, ptEnd, dDiameter, dDiameter, xShell);
|
||
|
||
nRet = 1;
|
||
}
|
||
else
|
||
{
|
||
// 不做处理
|
||
;
|
||
}
|
||
|
||
return nRet;
|
||
}
|
||
|
||
int THImpHvacAirlets::GetBodyBox( AcDbExtents& ext ) const
|
||
{
|
||
if (NULL == m_pXDataMap)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
// 获得参数
|
||
double dWidth = 0.0;
|
||
m_pXDataMap->GetAt(HALT_Width, dWidth);
|
||
double dHalfWidth = dWidth / 2.0;
|
||
double dLength = 0.0;
|
||
m_pXDataMap->GetAt(HALT_Thick ,dLength);
|
||
double dThick = 0.0;
|
||
m_pXDataMap->GetAt(HALT_Length, dThick);
|
||
double dHalfThick = dThick / 2.0;
|
||
HvacSectType eSectType;
|
||
m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
|
||
if (TDb::eCircular == eSectType)
|
||
{
|
||
// 处理圆管数据
|
||
dHalfThick = dHalfWidth;
|
||
}
|
||
AcGeVector3d vtNormal;
|
||
m_pXDataMap->GetAt(HALT_MainDir, vtNormal);
|
||
vtNormal.normalize();
|
||
AcGePoint3d ptStart;
|
||
m_pXDataMap->GetAt(HALT_CenterPoint, ptStart);
|
||
AcGeVector3d vtMain;
|
||
m_pXDataMap->GetAt(HVAC_Normal, vtMain);
|
||
AcGePoint3d ptEnd = ptStart + vtMain * dLength;
|
||
AcGeVector3d vtSide = ptEnd - ptStart;
|
||
vtSide.rotateBy(PI / 2.0, vtNormal);
|
||
vtSide.normalize();
|
||
|
||
// 计算端点
|
||
AcGePoint3dArray arpt;
|
||
arpt.append(ptStart + vtSide * dHalfWidth + vtNormal * dHalfThick);
|
||
arpt.append(ptStart + vtSide * dHalfWidth - vtNormal * dHalfThick);
|
||
arpt.append(ptStart - vtSide * dHalfWidth - vtNormal * dHalfThick);
|
||
arpt.append(ptStart - vtSide * dHalfWidth + vtNormal * dHalfThick);
|
||
arpt.append(ptEnd + vtSide * dHalfWidth + vtNormal * dHalfThick);
|
||
arpt.append(ptEnd + vtSide * dHalfWidth - vtNormal * dHalfThick);
|
||
arpt.append(ptEnd - vtSide * dHalfWidth - vtNormal * dHalfThick);
|
||
arpt.append(ptEnd - vtSide * dHalfWidth + vtNormal * dHalfThick);
|
||
|
||
// 构造最小包含体
|
||
TAuxTools::BuildMinRectangle(arpt, ext);
|
||
|
||
return 1;
|
||
}
|
||
AcGePoint3d THImpHvacAirlets::GetIfPoint() const
|
||
{
|
||
AcGePoint3d ptIf;
|
||
m_pXDataMap->GetAt(HALT_CenterPoint, ptIf);
|
||
|
||
// 上下送风时，接口位置调整至上面，适应大多数情况，跟风管连接完好
|
||
BOOL bIsSide(TRUE);
|
||
m_pXDataMap->GetAt(HALT_IsSide, bIsSide);
|
||
if (!bIsSide)
|
||
{
|
||
AcGeVector3d vtNor;
|
||
double dHeigh(0.0);
|
||
m_pXDataMap->GetAt(HVAC_Normal, vtNor);
|
||
m_pXDataMap->GetAt(HALT_Thick, dHeigh);
|
||
ptIf += vtNor.normalize() * dHeigh;
|
||
}
|
||
|
||
return ptIf;
|
||
}
|
||
|
||
// 导出XML
|
||
CString THImpHvacAirlets::GetXml(const AcGeMatrix3d& mat) const
|
||
{
|
||
if (NULL == m_pXDataMap || NULL == m_pOwnerEnt)
|
||
return _T("");
|
||
|
||
int nValue(0);
|
||
double dValue(0.0);
|
||
int nPtPreci = 6; // 位置精度
|
||
int nWhPreci = 0; // 宽度、高度精度
|
||
|
||
TXmlTree xmlTree;
|
||
CString csText;
|
||
CString csX, csY, csZ;
|
||
AcGePoint3d pt;
|
||
AcGeVector3d vt;
|
||
AcDbObjectId id;
|
||
|
||
// 获得设备转换矩阵Lixl add 2012-2-1
|
||
// 插入点
|
||
XPoint ptLocation;
|
||
m_pXDataMap->GetAt(HALT_CenterPoint, pt);
|
||
ptLocation = pt;
|
||
// 主方向
|
||
XVector3D vtDirection(0,0,1);
|
||
m_pXDataMap->GetAt(HALT_MainDir, vt);
|
||
vtDirection = vt;
|
||
// 图块比例
|
||
m_pXDataMap->GetAt(HALT_Scale, vt);
|
||
AcGeScale3d scale3d(vt.x, vt.y, vt.z);
|
||
XVector3D vtNormal(0,0,1);
|
||
if(fabs(vtDirection.z) > 1.0E-6) //非水平面，计算法向
|
||
{
|
||
vtNormal = XVector3D(1,0,0)*vtDirection;
|
||
vtNormal.Normalize();
|
||
}
|
||
XPoint ptLoc=Wcs2Ecs(ptLocation, vtNormal);
|
||
double nRotEcs = ads_angle(XPoint(),vtDirection); //计算ECS下的转角
|
||
m_pXDataMap->GetAt(HALT_Part3D, id);
|
||
AcDbBlockReference block(ptLoc, id);
|
||
block.setRotation(nRotEcs);
|
||
block.setScaleFactors(scale3d);
|
||
AcGeMatrix3d mat1 = block.blockTransform();
|
||
mat1 *= mat;
|
||
CString sMat;
|
||
TAuxTools::Matrix3D2String(mat1, sMat);
|
||
|
||
POSITION posRoot = xmlTree.Insert(_T("ATS_DBHEQUIPMENT"), NULL, NULL);
|
||
{
|
||
xmlTree.SetAttribute(posRoot, _T("name"), _T("风口"));
|
||
xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称"));
|
||
}
|
||
|
||
POSITION posItemEquipType = xmlTree.Insert(_T("EquipType"), posRoot, NULL);
|
||
{
|
||
xmlTree.SetAttribute(posItemEquipType, _T("name"), _T("设备类型"));
|
||
xmlTree.SetAttribute(posItemEquipType, _T("comment"), _T("设备类型"));
|
||
m_pXDataMap->GetAt(HALT_SEquipType, csText);
|
||
xmlTree.SetItemText(posItemEquipType, csText);
|
||
}
|
||
|
||
POSITION posItemEquipName = xmlTree.Insert(_T("EquipName"), posRoot, posItemEquipType);
|
||
{
|
||
xmlTree.SetAttribute(posItemEquipName, _T("name"), _T("设备名称"));
|
||
xmlTree.SetAttribute(posItemEquipName, _T("comment"), _T("对应图库中的风口名称"));
|
||
m_pXDataMap->GetAt(HALT_SEquipName, csText);
|
||
xmlTree.SetItemText(posItemEquipName, csText);
|
||
}
|
||
|
||
POSITION posItemNorDir = xmlTree.Insert(_T("NormalDir"),posRoot, posItemEquipName);
|
||
{
|
||
xmlTree.SetAttribute(posItemNorDir, _T("name"), _T("法向量"));
|
||
m_pXDataMap->GetAt(HVAC_Normal, vt);
|
||
TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
|
||
TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
|
||
TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
|
||
csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
|
||
xmlTree.SetItemText(posItemNorDir, csText);
|
||
}
|
||
|
||
POSITION posItemCentPt = xmlTree.Insert(_T("CenterPoint"), posRoot, posItemNorDir);
|
||
{
|
||
xmlTree.SetAttribute(posItemCentPt, _T("name"), _T("中心点"));
|
||
xmlTree.SetAttribute(posItemCentPt, _T("comment"), _T("布置点"));
|
||
m_pXDataMap->GetAt(HALT_CenterPoint, pt);
|
||
pt.transformBy(mat);
|
||
TAuxTools::DoubleToString(pt.x, nPtPreci, csX);
|
||
TAuxTools::DoubleToString(pt.y, nPtPreci, csY);
|
||
TAuxTools::DoubleToString(pt.z, nPtPreci, csZ);
|
||
csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
|
||
xmlTree.SetItemText(posItemCentPt, csText);
|
||
}
|
||
|
||
POSITION posItemMainDir = xmlTree.Insert(_T("MainDir"), posRoot, posItemCentPt);
|
||
{
|
||
xmlTree.SetAttribute(posItemMainDir, _T("name"), _T("主矢量"));
|
||
xmlTree.SetAttribute(posItemMainDir, _T("comment"), _T("布置角度"));
|
||
m_pXDataMap->GetAt(HALT_MainDir, vt);
|
||
TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
|
||
TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
|
||
TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
|
||
csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
|
||
xmlTree.SetItemText(posItemMainDir, csText);
|
||
}
|
||
|
||
POSITION posItemPart2D = xmlTree.Insert(_T("Part2D"), posRoot, posItemMainDir);
|
||
{
|
||
// mod by wc 13-12-16 //
|
||
// 将保存id改为保存名称
|
||
xmlTree.SetAttribute(posItemPart2D, _T("name"), _T("2D块名称"));
|
||
xmlTree.SetAttribute(posItemPart2D, _T("comment"), _T("平面图块"));
|
||
m_pXDataMap->GetAt(HALT_PartCenter, id);
|
||
// mod by wc 13-12-16 //
|
||
csText = TAuxTools::GetBlkNameById(id);
|
||
//csText.Format(_T("%d"), id.asOldId());
|
||
// end //
|
||
xmlTree.SetItemText(posItemPart2D, csText);
|
||
}
|
||
|
||
POSITION posItemPart3D = xmlTree.Insert(_T("Part3D"), posRoot, posItemPart2D);
|
||
{
|
||
// mod by wc 13-12-16 //
|
||
// 将保存id改为保存名称
|
||
id.setNull();
|
||
xmlTree.SetAttribute(posItemPart3D, _T("name"), _T("3D块名称"));
|
||
xmlTree.SetAttribute(posItemPart3D, _T("comment"), _T("三维图块"));
|
||
m_pXDataMap->GetAt(HALT_Part3D, id);
|
||
csText = TAuxTools::GetBlkNameById(id);
|
||
//csText.Format(_T("%d"), id.asOldId());
|
||
// end //
|
||
xmlTree.SetItemText(posItemPart3D, csText);
|
||
}
|
||
|
||
// add by wc 13-12-16 //
|
||
|
||
POSITION posItemPartSys = xmlTree.Insert(_T("PartSys"), posRoot, posItemPart3D);
|
||
{
|
||
xmlTree.SetAttribute(posItemPartSys, _T("name"), _T("系统块名称"));
|
||
xmlTree.SetAttribute(posItemPartSys, _T("comment"), _T("系统图块"));
|
||
m_pXDataMap->GetAt(HALT_PartSys, id);
|
||
csText = TAuxTools::GetBlkNameById(id);
|
||
xmlTree.SetItemText(posItemPartSys, csText);
|
||
}
|
||
// end //
|
||
|
||
// mod by wc //
|
||
// 原因：插入了一个节点，因此Insert函数第3个参数需要变成新插入节点的POSITION
|
||
POSITION posItemLength = xmlTree.Insert(_T("Length"), posRoot, posItemPartSys);
|
||
{
|
||
xmlTree.SetAttribute(posItemLength, _T("name"), _T("长度"));
|
||
xmlTree.SetAttribute(posItemLength, _T("comment"), _T("风口长度"));
|
||
m_pXDataMap->GetAt(HALT_Length, dValue);
|
||
TAuxTools::DoubleToString(dValue, nWhPreci, csText);
|
||
xmlTree.SetItemText(posItemLength, csText);
|
||
}
|
||
|
||
POSITION posItemWidth = xmlTree.Insert(_T("Width"), posRoot, posItemLength);
|
||
{
|
||
xmlTree.SetAttribute(posItemWidth, _T("name"), _T("宽度"));
|
||
xmlTree.SetAttribute(posItemWidth, _T("comment"), _T("风口宽度"));
|
||
m_pXDataMap->GetAt(HALT_Width, dValue);
|
||
TAuxTools::DoubleToString(dValue, nWhPreci, csText);
|
||
xmlTree.SetItemText(posItemWidth, csText);
|
||
}
|
||
|
||
POSITION posItemThick = xmlTree.Insert(_T("Thick"), posRoot, posItemWidth);
|
||
{
|
||
xmlTree.SetAttribute(posItemThick, _T("name"), _T("厚度"));
|
||
xmlTree.SetAttribute(posItemThick, _T("comment"), _T("风口高度"));
|
||
m_pXDataMap->GetAt(HALT_Thick, dValue);
|
||
TAuxTools::DoubleToString(dValue, nWhPreci, csText);
|
||
xmlTree.SetItemText(posItemThick, csText);
|
||
}
|
||
|
||
POSITION posItemScale = xmlTree.Insert(_T("Scale"), posRoot, posItemThick);
|
||
{
|
||
xmlTree.SetAttribute(posItemScale, _T("name"), _T("图块比例"));
|
||
xmlTree.SetAttribute(posItemScale, _T("comment"), _T("图块比例"));
|
||
m_pXDataMap->GetAt(HALT_Scale, vt);
|
||
TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
|
||
TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
|
||
TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
|
||
csText.Format(_T("%s,%s,%s"), csX, csY, csZ);
|
||
xmlTree.SetItemText(posItemScale, csText);
|
||
}
|
||
|
||
POSITION posItemMat= xmlTree.Insert(_T("Matrix3d"), posRoot, posItemScale);
|
||
{
|
||
xmlTree.SetAttribute(posItemMat, _T("name"), _T("矩阵"));
|
||
xmlTree.SetAttribute(posItemMat, _T("comment"), _T("图块转换矩阵"));
|
||
xmlTree.SetItemText(posItemMat, sMat);
|
||
}
|
||
// add by wc 13-12-12
|
||
// begin
|
||
POSITION posItemAirWay = xmlTree.Insert(_T("AirWayDir"), posRoot, posItemMat);
|
||
{
|
||
xmlTree.SetAttribute(posItemAirWay, _T("name"), _T("接口方向"));
|
||
xmlTree.SetAttribute(posItemAirWay, _T("comment"), _T("风口接口方向向量"));
|
||
if (m_pXDataMap->GetAt(HALT_AirWay, vt))
|
||
{
|
||
TAuxTools::DoubleToString(vt.x, nPtPreci, csX);
|
||
TAuxTools::DoubleToString(vt.y, nPtPreci, csY);
|
||
TAuxTools::DoubleToString(vt.z, nPtPreci, csZ);
|
||
csText.Format(_T("%s, %s, %s"), csX, csY, csZ);
|
||
}
|
||
else
|
||
{
|
||
csText.Format(_T("读取风口向量错误"));
|
||
}
|
||
xmlTree.SetItemText(posItemAirWay, csText);
|
||
}
|
||
|
||
POSITION posItemForm = xmlTree.Insert(_T("Form"), posRoot, posItemAirWay);
|
||
{
|
||
xmlTree.SetAttribute(posItemForm, _T("name"), _T("结构形式"));
|
||
xmlTree.SetAttribute(posItemForm, _T("comment"), _T("明暗装等"));
|
||
if (!m_pXDataMap->GetAt(HEQU_Form, csText))
|
||
{
|
||
csText.Empty();
|
||
}
|
||
xmlTree.SetItemText(posItemForm, csText);
|
||
}
|
||
|
||
POSITION posItemInterNum = xmlTree.Insert(_T("InterfaceNum"), posRoot, posItemForm);
|
||
{
|
||
xmlTree.SetAttribute(posItemInterNum, _T("name"), _T("接口数量"));
|
||
xmlTree.SetAttribute(posItemInterNum, _T("comment"), _T("接口数量"));
|
||
nValue = GetInterfaceCount();
|
||
csText.Format(_T("%d"), nValue);
|
||
xmlTree.SetItemText(posItemInterNum, csText);
|
||
}
|
||
|
||
POSITION posItemSysName = xmlTree.Insert(_T("SysName"), posRoot, posItemInterNum);
|
||
{
|
||
xmlTree.SetAttribute(posItemSysName, _T("name"), _T("系统名称"));
|
||
xmlTree.SetAttribute(posItemSysName, _T("comment"), _T("回风、送风等"));
|
||
m_pXDataMap->GetAt(HVAC_System, csText);
|
||
xmlTree.SetItemText(posItemSysName, csText);
|
||
}
|
||
|
||
POSITION posItemIsConverse = xmlTree.Insert(_T("IsConverse"), posRoot, posItemSysName);
|
||
{
|
||
xmlTree.SetAttribute(posItemIsConverse, _T("name"), _T("是否反向"));
|
||
xmlTree.SetAttribute(posItemIsConverse, _T("comment"), _T("0/不是、1/是"));
|
||
if (!m_pXDataMap->GetAt(HEQU_IsConverse, nValue))
|
||
{
|
||
nValue = 0;
|
||
}
|
||
csText.Format(_T("%d"), nValue);
|
||
xmlTree.SetItemText(posItemIsConverse, csText);
|
||
}
|
||
|
||
POSITION posItemHasText = xmlTree.Insert(_T("HasText"), posRoot, posItemIsConverse);
|
||
{
|
||
xmlTree.SetAttribute(posItemHasText, _T("name"), _T("是否有文字"));
|
||
xmlTree.SetAttribute(posItemHasText, _T("comment"), _T("0/不是、1/是"));
|
||
if (!m_pXDataMap->GetAt(HEQU_HasText, nValue))
|
||
{
|
||
nValue = 0;
|
||
}
|
||
csText.Format(_T("%d"), nValue);
|
||
xmlTree.SetItemText(posItemHasText, csText);
|
||
}
|
||
|
||
POSITION posItemTextPoint = xmlTree.Insert(_T("TextPoint"), posRoot, posItemHasText);
|
||
{
|
||
xmlTree.SetAttribute(posItemTextPoint, _T("name"), _T("文字基点"));
|
||
xmlTree.SetAttribute(posItemTextPoint, _T("comment"), _T("文字基点"));
|
||
if (m_pXDataMap->GetAt(HEQU_TextPoint, pt))
|
||
{
|
||
TAuxTools::DoubleToString(pt.x, nPtPreci, csX);
|
||
TAuxTools::DoubleToString(pt.y, nPtPreci, csY);
|
||
TAuxTools::DoubleToString(pt.z, nPtPreci, csZ);
|
||
csText.Format(_T("%s, %s, %s"), csX, csY, csZ);
|
||
}
|
||
else
|
||
{
|
||
csText.Format(_T("文字基点读取失败"));
|
||
}
|
||
xmlTree.SetItemText(posItemTextPoint, csText);
|
||
}
|
||
|
||
POSITION posItemTextShade = xmlTree.Insert(_T("TextShadeBg"), posRoot, posItemTextPoint);
|
||
{
|
||
xmlTree.SetAttribute(posItemTextShade, _T("name"), _T("遮蔽背景"));
|
||
xmlTree.SetAttribute(posItemTextShade, _T("comment"), _T("文字是否遮蔽背景0/不是、1/是"));
|
||
if (!m_pXDataMap->GetAt(HEQU_TextShadeBg, nValue))
|
||
{
|
||
nValue = 0;
|
||
}
|
||
csText.Format(_T("%d"), nValue);
|
||
xmlTree.SetItemText(posItemTextShade, csText);
|
||
}
|
||
|
||
POSITION posItemTextLoc = xmlTree.Insert(_T("TextLoc"), posRoot, posItemTextShade);
|
||
{
|
||
xmlTree.SetAttribute(posItemTextLoc, _T("name"), _T("标注文字位置"));
|
||
xmlTree.SetAttribute(posItemTextLoc, _T("comment"), _T("标注文字的位置：enum HvacEquipDimLoc"));
|
||
if (!m_pXDataMap->GetAt(HEQU_TextLoc, nValue))
|
||
{
|
||
nValue = 0;
|
||
}
|
||
csText.Format(_T("%d"), nValue);
|
||
xmlTree.SetItemText(posItemTextLoc, csText);
|
||
}
|
||
|
||
POSITION posItemKind = xmlTree.Insert(_T("Kind"), posRoot, posItemTextLoc);
|
||
{
|
||
xmlTree.SetAttribute(posItemKind, _T("name"), _T("设备种类"));
|
||
xmlTree.SetAttribute(posItemKind, _T("comment"), _T("1/采暖设备、2/空调设备"));
|
||
if (!m_pXDataMap->GetAt(HEQU_Kind, nValue))
|
||
{
|
||
nValue = 1;
|
||
}
|
||
csText.Format(_T("%d"), nValue);
|
||
xmlTree.SetItemText(posItemKind, csText);
|
||
}
|
||
|
||
POSITION posItemReversalX = xmlTree.Insert(_T("ReversalX"), posRoot, posItemKind);
|
||
{
|
||
xmlTree.SetAttribute(posItemReversalX, _T("name"), _T("是否左右旋转"));
|
||
xmlTree.SetAttribute(posItemReversalX, _T("comment"), _T("0/不是、1/是"));
|
||
if (!m_pXDataMap->GetAt(HEQU_ReversalX, nValue))
|
||
{
|
||
nValue = 0;
|
||
}
|
||
csText.Format(_T("%d"), nValue);
|
||
xmlTree.SetItemText(posItemReversalX, csText);
|
||
}
|
||
|
||
POSITION posItemReversalY = xmlTree.Insert(_T("ReversalY"), posRoot, posItemReversalX);
|
||
{
|
||
xmlTree.SetAttribute(posItemReversalY, _T("name"), _T("是否上下旋转"));
|
||
xmlTree.SetAttribute(posItemReversalY, _T("comment"), _T("0/不是、1/是"));
|
||
if (!m_pXDataMap->GetAt(HEQU_ReversalY, nValue))
|
||
{
|
||
nValue = 0;
|
||
}
|
||
csText.Format(_T("%d"), nValue);
|
||
xmlTree.SetItemText(posItemReversalY, csText);
|
||
}
|
||
|
||
POSITION posItemAirLoad = xmlTree.Insert(_T("AirLoad"), posRoot, posItemReversalY);
|
||
{
|
||
xmlTree.SetAttribute(posItemAirLoad, _T("name"), _T("风口风量"));
|
||
xmlTree.SetAttribute(posItemAirLoad, _T("comment"), _T("风口风量"));
|
||
if (!m_pXDataMap->GetAt(HVAC_AirLoad, dValue))
|
||
{
|
||
dValue = 0.0;
|
||
}
|
||
csText.Format(_T("%f"), dValue);
|
||
xmlTree.SetItemText(posItemAirLoad, csText);
|
||
}
|
||
|
||
POSITION posItemIsSide = xmlTree.Insert(_T("IsSide"), posRoot, posItemAirLoad);
|
||
{
|
||
xmlTree.SetAttribute(posItemIsSide, _T("name"), _T("是否侧风口"));
|
||
xmlTree.SetAttribute(posItemIsSide, _T("comment"), _T("0/不是、1/是"));
|
||
if (!m_pXDataMap->GetAt(HALT_IsSide, nValue))
|
||
{
|
||
nValue = 0;
|
||
}
|
||
csText.Format(_T("%d"), nValue);
|
||
xmlTree.SetItemText(posItemIsSide, csText);
|
||
}
|
||
|
||
POSITION posItemAreaRatio = xmlTree.Insert(_T("AreaRatio"), posRoot, posItemIsSide);
|
||
{
|
||
xmlTree.SetAttribute(posItemAreaRatio, _T("name"), _T("喉口面积系数"));
|
||
xmlTree.SetAttribute(posItemAreaRatio, _T("comment"), _T("喉口面积系数"));
|
||
if (!m_pXDataMap->GetAt(HALT_AreaRatio, dValue))
|
||
{
|
||
dValue = 0.0;
|
||
}
|
||
csText.Format(_T("%f"), dValue);
|
||
xmlTree.SetItemText(posItemAreaRatio, csText);
|
||
}
|
||
|
||
POSITION posItemSectType = xmlTree.Insert(_T("SectType"), posRoot, posItemAreaRatio);
|
||
{
|
||
xmlTree.SetAttribute(posItemSectType, _T("name"), _T("截面类型"));
|
||
xmlTree.SetAttribute(posItemSectType, _T("comment"), _T("0/矩形、1/圆形、2/扁圆"));
|
||
if (!m_pXDataMap->GetAt(HVAC_SectType, nValue))
|
||
{
|
||
nValue = 0;
|
||
}
|
||
csText.Format(_T("%d"), nValue);
|
||
xmlTree.SetItemText(posItemSectType, csText);
|
||
}
|
||
// end //
|
||
|
||
CString csXml = xmlTree.GetXml();
|
||
|
||
return csXml;
|
||
}
|
||
|
||
Acad::ErrorStatus THImpHvacAirlets::ExplodeOrDrawBlock2d( XExplodeDraw &mode ) const
|
||
{
|
||
return ExplodeOrDraw2d(mode);
|
||
}
|