gjm/envi-code
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c7102cfe254439e5b0eeadf38973c9bb1d034532
envi-code/SourceCode/Code2026/tg_shs/shs_pipebase/THImpHvacBroSymbol.cpp
T
gjm 345044cb46 初始化提交
2026-09-28 15:28:50 +08:00

1193 lines
28 KiB
C++
Raw Blame History

#include "stdafx.h"
#include "StdArx.h"
#include "THImpHvacBroSymbol.h"
#include "TDbInterfaceRecord.h"
#include "TDbXDataMap.h"
#include "TDbInterfaceMsgWrite.h"
#include "math.h"
#include "dbxutil.h"
#include "dbsymutl.h"
using namespace TDb;
THImpHvacBroSymbol::THImpHvacBroSymbol()
{
}
THImpHvacBroSymbol::~THImpHvacBroSymbol()
{
}
Acad::ErrorStatus THImpHvacBroSymbol::getClassID(CLSID* pClsid) const
{
// #if (ADS < 16)
// // {C7DFDF6A-A5F2-4add-ADCC-7AC0675AB6E5}
// CLSID CLSID_PipeBaseEntity = {0xC7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xE5 }};
// #endif
//
// #if (ADS == 16)
// // {C7DFDF6A-A5F2-4add-ADCC-7AC0675AB6E5}
// CLSID CLSID_PipeBaseEntity = {0xC7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xE6 }};
// #endif
//
// #if (ADS == 17)
// // {C7DFDF6A-A5F2-4add-ADCC-7AC0675AB6E7}
// CLSID CLSID_PipeBaseEntity = {0xC7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xE7 }};
// #endif
//
// #if (ADS == 18)
// CLSID CLSID_PipeBaseEntity = {0xD7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xE8 }};
// #endif
//
// #if (ADS == 19)
// CLSID CLSID_PipeBaseEntity = {0xD7DFDF6B, 0xA5F2, 0x4ADE, { 0xAD, 0xCC, 0x7A, 0xC0, 0x67, 0x5A, 0xB6, 0xE8 }};
// #endif
return Acad::eOk;
}
BOOL THImpHvacBroSymbol::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::eBroSymbol);
}
// 全局属性，需要特殊处理数据获取和设置
if (NULL != pInfo->pXData)
{
// 获取数据
if (0 == pInfo->pXData->nVt)
{
pInfo->pXData->nVt = TXINT;
pInfo->pXData->nVal = TDb::eBroSymbol;
}
// 设置数据
else
{
pInfo->pXData->nVt = 0; // 设置处理完成标识
}
}
return TRUE;
}
if (0 == _tcsicmp(pszName, HVAC_SectType))
{
pInfo->bVisible = TRUE;
pInfo->bEditable = TRUE;
// 提供数据列表和对应关系
if (NULL != pInfo->parsValues && NULL != pInfo->parlValues)
{
pInfo->parsValues->Add(_T("矩形"));
pInfo->parlValues->Add(TDb::eRectangular);
pInfo->parsValues->Add(_T("圆形"));
pInfo->parlValues->Add(TDb::eCircular);
}
return TRUE;
}
if (0 == _tcsicmp(pszName, HVAC_HasBaseLine))
{
pInfo->bVisible = FALSE;
pInfo->bEditable = TRUE;
// 提供数据列表和对应关系
if (NULL != pInfo->parsValues && NULL != pInfo->parlValues)
{
pInfo->parsValues->Add(_T("隐藏"));
pInfo->parlValues->Add(0);
pInfo->parsValues->Add(_T("显示"));
pInfo->parlValues->Add(1);
}
return TRUE;
}
if (0 == _tcsicmp(pszName, HVAC_IsSingleLine))
{
pInfo->bVisible = TRUE;
pInfo->bEditable = TRUE;
// 提供数据列表和对应关系
if (NULL != pInfo->parsValues && NULL != pInfo->parlValues)
{
pInfo->parsValues->Add(_T("双线"));
pInfo->parlValues->Add(0);
pInfo->parsValues->Add(_T("单线"));
pInfo->parlValues->Add(1);
}
TAuxTools::SetAndUpdateCover((TDbInterfacesObj*)m_pOwnerEnt, pszName, pInfo);
return TRUE;
}
// 获得单线状态，当状态为单线时不显示
BOOL bSingleLine = FALSE;
m_pXDataMap->GetAt(HVAC_IsSingleLine, bSingleLine);
return FALSE;
}
void THImpHvacBroSymbol::GetTips(CMapStringToString& mapLable2Tip) const
{
}
void THImpHvacBroSymbol::list() const
{
ASSERT(NULL != m_pXDataMap);
// 管件类型
acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t\t\t 暖通：断管符号"));
// 截面类型
HvacSectType eSectType = eRectangular;
m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
switch (eSectType)
{
case TDb::eRectangular: acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t\t\t 截面：矩形")); break;
case TDb::eCircular: acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t\t\t 截面：圆形")); break;
case TDb::eOblate: acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t\t\t 截面：扁圆形")); break;
}
// 外围宽
double dSkirtSize = 0.0;
m_pXDataMap->GetAt(HBSM_SkirtSize, dSkirtSize);
// add by zh 2013-5-20 根据出图比例计算出头长度
double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
if (dPScale < 1.e-3) dPScale = 1.0;
dSkirtSize *= dPScale/100;
//
acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t出头量：%.2f"), dSkirtSize);
// 圆型截面显示直径
if (TDb::eCircular == eSectType)
{
double dDiameter = 0.0;
m_pXDataMap->GetAt(HBSM_Diameter, dDiameter);
acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t直径：%.2f"), dDiameter);
}
// 非圆型截面显示宽度和厚度
else
{
double dWidth = 0.0, dThick = 0.0;
m_pXDataMap->GetAt(HBSM_Width, dWidth);
m_pXDataMap->GetAt(HBSM_Thick, dThick);
acutPrintf(_T("\n\t\t\t\t\t\t\t\t\t宽度：%.2f\t 厚度：%.2f"), dWidth, dThick);
}
// 插入点
AcGePoint3d pt;
m_pXDataMap->GetAt(HBSM_InsertPoint, pt);
acutPrintf(_T("\n\t\t\t\t\t\t\t\t自 点，X=%.4f\t Y=%.4f\t Z=%.4f"), pt.x, pt.y, pt.z);
}
BOOL THImpHvacBroSymbol::IsSingleLine() const
{
ASSERT(NULL != m_pXDataMap);
BOOL bSingleLine = FALSE;
m_pXDataMap->GetAt(HVAC_IsSingleLine, (int&)bSingleLine);
return bSingleLine;
}
void THImpHvacBroSymbol::GetKindName(CString& sName)
{
sName = _T("TCH_HBROSYMBOL");
}
int THImpHvacBroSymbol::GetInterfaceCount() const
{
// 返回接口个数
return 1;
}
BOOL THImpHvacBroSymbol::GetInterfaceSizeData(int nIndex, TInterface& pipeInterface) const
{
ASSERT(NULL != m_pXDataMap);
// 获取截面类型
TDb::HvacSectType eSectType = TDb::eRectangular;
m_pXDataMap->GetAt(HVAC_SectType, (int&)eSectType);
// 获取接口截面、宽度、厚度数据key值
LPCTSTR pszWidthKey, pszThickKey;
switch (nIndex)
{
case 0:
pszWidthKey = ((TDb::eCircular == eSectType) ? HBSM_Diameter : HBSM_Width);
pszThickKey = HBSM_Thick;
break;
default:
return FALSE;
}
// 获取尺寸
double dWidth = 0.0, dThick = 0.0;
m_pXDataMap->GetAt(pszWidthKey, dWidth);
m_pXDataMap->GetAt(pszThickKey, dThick);
// 设置接口数据
pipeInterface.SetType(eSectType);
pipeInterface.SetSize(dWidth, dThick);
return TRUE;
}
BOOL THImpHvacBroSymbol::GetInterface(int nIndex, TInterface& pipeInterface) const
{
if (NULL == m_pXDataMap)
return FALSE;
// 获取变径各点位置
AcGePoint3d ptInsert;
AcGeVector3d vtDir;
m_pXDataMap->GetAt(HBSM_InsertPoint, ptInsert);
m_pXDataMap->GetAt(HBSM_Dir, vtDir);
AcDbObjectId id;
switch(nIndex)
{
case 0:
// 如果起始接口和第一个管件连接
if (m_pXDataMap->GetAt(KEY_IDCNT1, id) && MakesureInterfaceValidate(id, ptInsert, vtDir, pipeInterface))
{
GetInterfaceSizeData(nIndex, pipeInterface);
return TRUE;
}
// 没有管件连接
pipeInterface.SetOutDir(vtDir);
pipeInterface.SetOwnerId(m_pOwnerEnt->objectId());
pipeInterface.SetPosition(ptInsert);
GetInterfaceSizeData(nIndex, pipeInterface);
return TRUE;
}
return FALSE;
}
BOOL THImpHvacBroSymbol::GetInterface(const AcGePoint3d& ptConnect,TInterface& pipeInterface) const
{
if (NULL == m_pXDataMap)
return FALSE;
// 获取变径各点位置
AcGePoint3d ptInsert;
AcGeVector3d vtDir;
m_pXDataMap->GetAt(HBSM_InsertPoint, ptInsert);
m_pXDataMap->GetAt(HBSM_Dir, vtDir);
// 计算测试点到始末点的距离
double dDist = ptConnect.distanceTo(ptInsert);
AcDbObjectId id;
// 位于起始点
if (dDist < 1.e-3)
{
// 如果起始接口和第一个管件连接
if (m_pXDataMap->GetAt(KEY_IDCNT1, id) && MakesureInterfaceValidate(id, ptInsert, vtDir, pipeInterface))
{
GetInterfaceSizeData(0, pipeInterface);
return TRUE;
}
// 没有管件连接
pipeInterface.SetOutDir(vtDir);
pipeInterface.SetOwnerId(m_pOwnerEnt->objectId());
pipeInterface.SetPosition(ptInsert);
GetInterfaceSizeData(0, pipeInterface);
return TRUE;
}
return FALSE;
}
BOOL THImpHvacBroSymbol::HasInterface(const AcGePoint3d& ptConnect,const AcGeVector3d& vtDir)
{
if (NULL == m_pXDataMap)
return FALSE;
// 获取变径各点位置
AcGePoint3d ptInsert;
AcGeVector3d vtMainDir;
m_pXDataMap->GetAt(HBSM_InsertPoint, ptInsert);
m_pXDataMap->GetAt(HBSM_Dir, vtMainDir);
// 计算测试点到始末点的距离
double dDist = ptConnect.distanceTo(ptInsert);
// 位于起始点
if (dDist < 1.e-3)
return (vtDir.isParallelTo(vtMainDir));
return FALSE;
}
BOOL THImpHvacBroSymbol::SetInterfaceRelation(const AcGePoint3d& ptConnect,const AcDbObjectId& idConnect)
{
if (NULL == m_pXDataMap)
return FALSE;
if ( !idConnect.isValid() )
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 ptInsert;
AcGeVector3d vtDir;
m_pXDataMap->GetAt(HBSM_InsertPoint, ptInsert);
m_pXDataMap->GetAt(HBSM_Dir, vtDir);
// 计算测试点到始末点的距离
double dDist = ptConnect.distanceTo(ptInsert);
// 基类指针
TDbInterfacesObj* pInterfaceObj = TDbInterfacesObj::cast(pEnt);
ASSERT(NULL != pInterfaceObj);
// 位于起始点
if (dDist < 1.e-3 && pInterfaceObj->HasInterface(ptInsert, vtDir))
{
m_pXDataMap->SetAt(KEY_IDCNT1, idConnect);
pEnt->close();
return TRUE;
}
pEnt->close();
return FALSE;
}
BOOL THImpHvacBroSymbol::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 THImpHvacBroSymbol::NotifyInterfaceToModify(const TInterfaceModifyMsg& iModiMsg,TInterfaceModifyMsgs& iModiMsgs)
{
if (NULL == m_pXDataMap)
return FALSE;
// 获得消息传递设置, 确定是否传递消息
CString sDispatch = _T("0");
GetGlobalContext(KEY_DISPATCHMSG, sDispatch);
BOOL bDispatch = (_ttoi(sDispatch) != 0);
BOOL bMsgTranslate = FALSE;
// 获得消息类型, 根据消息类型处理
TDb::InterfaceOper eOper = iModiMsg.GetInterfaceOper();
switch (eOper)
{
case TDb::eMoveGripPoint:
// 夹点移动消息处理
bMsgTranslate = OnMoveGripPointMsgNotify(iModiMsg, iModiMsgs);
break;
case TDb::eTransformBy:
// 对象移动消息处理
bMsgTranslate = OnTransformMsgNotify(iModiMsg, iModiMsgs);
break;
case TDb::eSize:
// 尺寸调整消息处理
bMsgTranslate = OnSizeMsgNotify(iModiMsg, iModiMsgs);
break;
default:
return bMsgTranslate;
}
// 记录修改标识
if (m_pOwnerEnt != NULL)
m_pOwnerEnt->recordGraphicsModified();
return bMsgTranslate;
}
Acad::ErrorStatus THImpHvacBroSymbol::ExplodeOrDraw2d(XExplodeDraw &mode) const
{
if (m_pXDataMap == NULL)
{
return Acad::eNotImplementedYet;
}
TComplexCurve cplCurve;
MakeCurves(cplCurve);
TDbExtentsEdge edage;
edage.SetEdage(cplCurve);
BOOL bWeight = FALSE;
// m_pXDataMap->GetAt(KEY_EDAGEWEIGHT,bWeight);
AcDbObjectId idReal = ((TDbInterfacesObj*)m_pOwnerEnt)->layerId();
AcDbObjectId idDash = ((TDbInterfacesObj*)m_pOwnerEnt)->DashLayer();
AcDbObjectId idCent = ((TDbInterfacesObj*)m_pOwnerEnt)->CenterLayer();
edage.ExplodeOrDraw2d(mode,idReal,idDash,idCent,NULL,bWeight,FALSE);
return Acad::eOk;
}
BOOL THImpHvacBroSymbol::MakeCurves(TComplexCurve& cplCurve) const
{
if (NULL == m_pXDataMap)
return FALSE;
else
{
return MakeBroSymbol2D(cplCurve);
}
return FALSE;
}
Acad::ErrorStatus THImpHvacBroSymbol::transformBy(const AcGeMatrix3d& xform)
{
if (NULL == m_pXDataMap)
return Acad::eNotApplicable;
// 取得位置点
AcGePoint3d ptIns;
m_pXDataMap->GetAt(HBSM_InsertPoint, ptIns);
// 变换位置
ptIns.transformBy(xform);
// 更新点
m_pXDataMap->SetAt(HBSM_InsertPoint, ptIns);
// 设置尺寸
double dScale = xform.scale();
double dWidth(0.0), dThick(0.0), dSkitSize(0.0);
m_pXDataMap->GetAt(HBSM_SkirtSize, dSkitSize);
// add by zh 2013-5-20 根据出图比例计算出头长度
// double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
// if (dPScale < 1.e-3) dPScale = 1.0;
// dSkitSize *= dPScale/100;
//
m_pXDataMap->GetAt(HBSM_Width, dWidth);
m_pXDataMap->GetAt(HBSM_Thick, dThick);
dWidth *= dScale;
dThick *= dScale;
dSkitSize *= dScale;
m_pXDataMap->SetAt(HBSM_SkirtSize, dSkitSize);
m_pXDataMap->SetAt(HBSM_Width, dWidth);
m_pXDataMap->SetAt(HBSM_Thick, dThick);
// 传递消息及更新接口记录
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.SetMsgValidate(TRUE);
iMsg.SetTransform(xform);
iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());
iMsg.SetInterfaceOper(TDb::eAutoWorkOn);
TDbInterfaceMsgWrite msgWrite;
msgWrite.WriteInterfaceMsg(iMsg);
//更新接口记录接口信息
UpdateInterfaceRec(m_pOwnerEnt->objectId(), xform);
}
}
return Acad::eOk;
}
TDb::Position THImpHvacBroSymbol::ExplainGripIndex(int nIndex) const
{
TDb::Position ePos = TDb::eStart;
switch(nIndex)
{
case 0:
ePos = TDb::eMid;
}
return ePos;
}
Acad::ErrorStatus THImpHvacBroSymbol::getStretchPoints(AcGePoint3dArray& stretchPoints) const
{
if (NULL == m_pXDataMap)
return Acad::eNotApplicable;
// 取得位置点
AcGePoint3d ptIns;
m_pXDataMap->GetAt(HBSM_InsertPoint, ptIns);
stretchPoints.append(ptIns);
return Acad::eOk;
}
Acad::ErrorStatus THImpHvacBroSymbol::getGripPoints(AcGePoint3dArray& gripPoints,
AcDbIntArray& osnapModes,
AcDbIntArray& geomIds) const
{
if (NULL == m_pXDataMap)
return Acad::eNotApplicable;
//取得位置点
AcGePoint3d ptIns;
m_pXDataMap->GetAt(HBSM_InsertPoint, ptIns);
// 增加夹点
gripPoints.append(ptIns);
return Acad::eOk;
}
Acad::ErrorStatus THImpHvacBroSymbol::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;
HvacDuctType eType = eStraight;
m_pXDataMap->GetAt(HDCT_Type, (int&)eType);
AcGePoint3dArray arPts;
AcDbPolyline poly;
if (eType == eStraight)
{
if (GetSectInsertPt(arPts, poly))
{
if (poly.numVerts() > 0)
{
poly.getOsnapPoints(osnapMode,gsSelectionMark,pickPoint,lastPoint,viewXform,
snapPoints,geomIds);
}
}
}
else if (eType == eSoft)
{
if (GetCirInsertPt(arPts))
;
else
return Acad::eNotImplementedYet;
}
return Acad::eOk;
}
Acad::ErrorStatus THImpHvacBroSymbol::moveStretchPointsAt(const AcDbIntArray& indices,
const AcGeVector3d& offset)
{
if (indices.length() < 2)
return Acad::eNotImplementedYet;
AcGePoint3d ptIns;
m_pXDataMap->GetAt(HBSM_InsertPoint, ptIns);
ptIns += offset;
m_pXDataMap->SetAt(HBSM_InsertPoint, ptIns);
if (m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
{
//更新自身模型空间的扩展字典的接口信息
UpdateInterfaceRec(m_pOwnerEnt->objectId(), offset);
return Acad::eOk;
}
return Acad::eNotImplementedYet;
}
Acad::ErrorStatus THImpHvacBroSymbol::moveGripPointsAt(const AcDbIntArray& indices,
const AcGeVector3d& offset)
{
return OnCHorEqualRMoveGripPointsAt(indices,offset);
}
Acad::ErrorStatus THImpHvacBroSymbol::OnCHorEqualRMoveGripPointsAt(const AcDbIntArray& indices,const AcGeVector3d& offset)
{
ASSERT(NULL != m_pXDataMap);
// 如果有多个点，则去除命令点后，有多个点时作为移动，单个点时使用该点类型
TDb::Position ePos;
if (indices.length() == 1)
{
// 单个夹点
ePos = ExplainGripIndex(indices[0]);
}
else
{
// 多个夹点
int iCount = 0;
TDb::Position eTemp;
int iPos = indices.length();
while ((--iPos) >= 0 && iCount < 2)
{
eTemp = ExplainGripIndex(indices[iPos]);
switch (eTemp)
{
case TDb::eMid:
ePos = eTemp;
iCount++;
break;
}
}
// 多个命令夹点不处理
if (iCount == 0)
return Acad::eOk;
// 多个非命令夹点，移动整体
if (iCount > 1)
{
// 法兰夹点只是移动操作，移动最后一个夹点
}
}
// 取得位置点
AcGePoint3d ptIns;
m_pXDataMap->GetAt(HBSM_InsertPoint, ptIns);
switch(ePos)
{
case TDb::eMid:
MoveGripRandom(ePos, offset);
//更新自身模型空间的扩展字典的接口信息
UpdateInterfaceRec(m_pOwnerEnt->objectId(), offset);
break;
default:
break;
}
return Acad::eOk;
}
// 拖拽管件，支持转向等操作
Acad::ErrorStatus THImpHvacBroSymbol::MoveGripRandom(TDb::Position ePos, const AcGeVector3d& offset )
{
AcGePoint3d ptDrag;
if (ePos == eMid)
m_pXDataMap->GetAt(HBSM_InsertPoint, ptDrag);
TInterfaceModifyMsg iMsg;
iMsg.SetMsgPoint(ptDrag);
iMsg.SetGripPosition(ePos);
iMsg.SetMoveGripOffset(offset);
iMsg.SetMsgValidate(TRUE);
iMsg.SetInterfaceOper(eNewCommand);
iMsg.SetPreviewObjToCreate(eBroSymbol, 0);
// 写入接口更改消息
AcDbSoftPointerId idOwner;
m_pXDataMap->GetAt(KEY_THISID, idOwner);
iMsg.SetMsgOperateOn(idOwner);
TDbInterfaceMsgWrite msgWrite;
msgWrite.WriteInterfaceMsg(iMsg);
// 发送消息
acedPostCommand(_T("\33"));
acedPostCommand(_T("znyd\n"));
return Acad::eOk;
}
BOOL THImpHvacBroSymbol::OnMoveGripPointMsgNotify(const TInterfaceModifyMsg& iModiMsg, TInterfaceModifyMsgs& iModiMsgs)
{
if (!TAuxTools::IsAutoWorkOffset())
return FALSE;
ASSERT(NULL != m_pXDataMap);
BOOL bMsgTranslate = FALSE;
AcDbObjectId id = iModiMsg.GetMsgOperateOn();
if (id != m_pOwnerEnt->objectId()) // 消息发送目标正确
return FALSE;
AcGeVector3d vtOffset = iModiMsg.GetMoveGripOffset();
if (vtOffset.isZeroLength())
return FALSE;
AcGePoint3d ptIns;
m_pXDataMap->GetAt(HBSM_InsertPoint,ptIns);
AcGePoint3d ptGeInsOld = ptIns;
AcGeVector3d vtDir;
m_pXDataMap->GetAt(HBSM_Dir, vtDir);
int nPos = iModiMsg.GetGripPosition();
if (nPos == eStart || nPos == eMid || nPos == eEnd || nPos == eBr1 || nPos == eBr2)
{
ptIns += vtOffset;
m_pXDataMap->SetAt(HBSM_InsertPoint,ptIns);
// 构造接口消息传递 开始端检查
AcDbObjectId idT;
if (FindConnect(ptGeInsOld,vtDir,m_pOwnerEnt->objectId(),idT)) // sta 点的接口
{
TInterfaceModifyMsg msg;
msg.SetMsgPoint(ptGeInsOld);
msg.SetMoveGripOffset(vtOffset);
msg.SetMsgOperateOn(idT);
msg.SetGripPosition(eStart);
iModiMsgs.append(msg);
bMsgTranslate = TRUE;
}
// 更新模型空间的扩展字典的注册的接口数据
AcGeMatrix3d xform;
xform.setToTranslation(vtOffset);
UpdateInterfaceRec(m_pOwnerEnt->objectId(), xform);
}
return bMsgTranslate;
}
BOOL THImpHvacBroSymbol::OnTransformMsgNotify(const TInterfaceModifyMsg& iModiMsg, TInterfaceModifyMsgs& iModiMsgs)
{
if (!TAuxTools::IsAutoWorkOffset())
return FALSE;
ASSERT(NULL != m_pXDataMap);
BOOL bMsgTranslate = FALSE;
AcDbObjectId id = iModiMsg.GetMsgOperateOn();
if (id != m_pOwnerEnt->objectId()) // 消息发送目标正确
return FALSE;
AcGeMatrix3d mtTrans = iModiMsg.GetTransform();
AcGePoint3d ptIns;
AcGeVector3d vtDir;
m_pXDataMap->GetAt(HBSM_InsertPoint,ptIns);
m_pXDataMap->GetAt(HBSM_Dir,vtDir);
AcGePoint3d ptInsOld = ptIns;
ptIns.transformBy(mtTrans);
m_pXDataMap->SetAt(HBSM_InsertPoint,ptIns);
// 构造接口消息传递 开始端检查
AcDbObjectId idT;
if (FindConnect(ptInsOld, vtDir, m_pOwnerEnt->objectId(), idT)) // sta 点的接口
{
TInterfaceModifyMsg msg;
msg.SetMsgPoint(ptInsOld);
msg.SetTransform(mtTrans);
msg.SetMsgOperateOn(idT);
iModiMsgs.append(msg);
bMsgTranslate = TRUE;
}
// 更新模型空间的扩展字典的注册的接口数据
UpdateInterfaceRec(m_pOwnerEnt->objectId(), mtTrans);
return bMsgTranslate;
return FALSE;
}
BOOL THImpHvacBroSymbol::OnSizeMsgNotify(const TInterfaceModifyMsg& iModiMsg, TInterfaceModifyMsgs& iModiMsgs)
{
ASSERT(NULL != m_pXDataMap);
AcGePoint3d ptOrigIns;
AcGeVector3d vtDir;
m_pXDataMap->GetAt(HBSM_InsertPoint, ptOrigIns);
m_pXDataMap->GetAt(HBSM_Dir,vtDir);
// 设置各接口新尺寸
HvacSectType eSect = TDb::eRectangular;
m_pXDataMap->GetAt(HVAC_SectType, (int&)eSect);
double dNewWidth, dNewHeigh(0.0);
if (eSect == TDb::eRectangular)
{
AcGeVector3d vtNormal = normal();
AcGeVector3d vtWidthDir, vtHeighDir;
iModiMsg.GetSizeDir(vtWidthDir, vtHeighDir);
// 判断是否是空间连接或导致宽高互换
if (vtHeighDir.isParallelTo(vtNormal))
iModiMsg.GetSize(dNewWidth, dNewHeigh);
else
iModiMsg.GetSize(dNewHeigh, dNewWidth);
}
else if (eSect == TDb::eCircular)
{
iModiMsg.GetSize(dNewWidth, dNewHeigh);
dNewHeigh = dNewWidth;
}
AcGeVector3d vtOff = iModiMsg.GetMoveGripOffset();
AcGePoint3d ptNewIns = ptOrigIns+ vtOff;
m_pXDataMap->SetAt(HBSM_Width, dNewWidth);
m_pXDataMap->SetAt(HBSM_Thick, dNewHeigh);
m_pXDataMap->SetAt(HBSM_InsertPoint, ptNewIns);
vtDir.transformBy(vtOff);
// 消息传递
AcGeVector3d vtLine = vtDir.transformBy(vtOff);
AcDbObjectId idFind;
if (FindConnect(ptOrigIns, -vtLine, m_pOwnerEnt->objectId(), idFind)) // sta 点的接口
{
TInterfaceModifyMsg iMsg = iModiMsg;
iMsg.SetMsgOperateOn(idFind);
iMsg.SetMsgPoint(ptOrigIns);
iModiMsgs.append(iMsg);
}
if (!ptOrigIns.isEqualTo(ptNewIns, g_globalTol))
((TDbInterfacesObj*)m_pOwnerEnt)->UpdateInterfaceRec(ptOrigIns, ptNewIns);
return TRUE;
}
int THImpHvacBroSymbol::AutoAppendPt(TComplexCurve &cplCurve, TCurveElement &cplEle,
AcGePoint3d &ptS, AcGePoint3d &ptMid, AcGePoint3d &ptE) const
{
cplEle.ptGe[0] = ptS;
cplEle.ptGe[1] = ptMid;
cplEle.ptGe[2] = ptE;
return cplCurve.append(cplEle);
}
BOOL THImpHvacBroSymbol::MakeBroSymbol2D(TComplexCurve& cplCurve) const
{
AcGePoint3dArray arPts;
int iSectType = 2;
AcGePoint3d ptBase;
m_pXDataMap->GetAt(HBSM_InsertPoint, ptBase);
m_pXDataMap->GetAt(HVAC_SectType, iSectType);
// 计算方向向量
AcGeVector3d vtNormal = AcGeVector3d::kIdentity;
AcGeVector3d vtDir = AcGeVector3d::kIdentity;
m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
m_pXDataMap->GetAt(HBSM_Dir, vtDir);
vtDir = vtDir.normalize();
vtDir.rotateBy(PI / 2.0, vtNormal);
double dWidth = 0.0, dDiameter = 0.0;
m_pXDataMap->GetAt(HBSM_Width, dWidth);
m_pXDataMap->GetAt(HBSM_Diameter, dDiameter);
AcGePoint3d ptS, ptE;
if (TDb::eRectangular == iSectType)
{
ptS = ptBase + vtDir*(dWidth/2);
ptE = ptBase - vtDir*(dWidth/2);
}
else if (TDb::eCircular == iSectType)
{
ptS = ptBase + vtDir*(dDiameter/2);
ptE = ptBase - vtDir*(dDiameter/2);
}
// 添加边
TDb::TCurveElement el;
memset(&el, 0, sizeof(TDb::TCurveElement));
double dEdgeWidth = GetEdgeLineWidth();
el.dWidth = dEdgeWidth;
AcDbPolyline poly;
if (!IsSingleLine())
{
if (TDb::eRectangular == iSectType)
{
if (GetSectInsertPt(arPts, poly))
{
for(int i = 0; i < arPts.length() - 1; i++)
{
AutoAppendPt(cplCurve, el, arPts[i], arPts[i+1], arPts[i+1]);
el.ptGe[0] = arPts[i];
el.ptGe[1] = arPts[i+1];
el.ptGe[2] = el.ptGe[1];
}
}
}
else if (TDb::eCircular == iSectType)
{
if (GetCirInsertPt(arPts))
{
if (arPts.length() == 6)
{
AutoAppendPt(cplCurve, el, arPts[1], arPts[3], arPts[0]);
AutoAppendPt(cplCurve, el, arPts[0], arPts[4], arPts[2]);
AutoAppendPt(cplCurve, el, arPts[2], arPts[5], arPts[0]);
}
}
}
}
else
{
el.ptGe[0] = ptS;
el.ptGe[1] = ptE;
el.ptGe[2] = ptE;
cplCurve.append(el);
}
return cplCurve.length() > 0;
}
double THImpHvacBroSymbol::GetEdgeLineWidth() const
{
BOOL bShow(FALSE);
GetGlobalContext(HVAC_SHOWWIDTH, bShow);
// add by hh 2011-01-05 从图纸中读取加粗标识 避免全局参数对不同的图纸间的影响
TAuxTools::GetTHvacDataFromDwg(HVAC_SHOWWIDTH, bShow);
if (!bShow)
return 0.0;
ASSERT(NULL != m_pXDataMap);
double dWidth(0.0);
m_pXDataMap->GetAt(HVAC_EdgeWidth, dWidth);
return dWidth;
}
BOOL THImpHvacBroSymbol::GetSectInsertPt(AcGePoint3dArray &arPts, AcDbPolyline &Poly) const
{
// 获取绘图数据
AcGePoint3d ptBase;
m_pXDataMap->GetAt(HBSM_InsertPoint, ptBase);
// 计算方向向量
AcGeVector3d vtNormal = AcGeVector3d::kIdentity;
AcGeVector3d vtDir = AcGeVector3d::kIdentity;
AcGeVector3d vtMainV = AcGeVector3d::kIdentity;
m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
m_pXDataMap->GetAt(HBSM_Dir, vtDir);
int nType(0);
m_pXDataMap->GetAt(HBSM_Type, nType);
vtDir = vtDir.normalize();
vtMainV = vtDir;
vtMainV.rotateBy(PI / 2.0, vtNormal);
double dSkirtSize = 0.0;
m_pXDataMap->GetAt(HBSM_SkirtSize, dSkirtSize);
// add by zh 2013-5-20 根据出图比例计算出头长度
double dPScale = ((TDbInterfacesObj*)m_pOwnerEnt)->GetPrintScale();
if (dPScale < 1.e-3) dPScale = 1.0;
dSkirtSize *= dPScale/100;
//
double dWidth = 0.0;
m_pXDataMap->GetAt(HBSM_Width, dWidth);
AcGePoint3d ptTemp;
if (nType == 0)
{
ptTemp = ptBase - vtMainV * (dWidth/2 + dSkirtSize);
arPts.append(ptTemp);
ptTemp = ptBase - vtMainV * (dWidth/8);
arPts.append(ptTemp);
ptTemp = ptTemp - vtDir*(dWidth/8);
arPts.append(ptTemp);
ptTemp = ptTemp + vtDir*(dWidth/4) + vtMainV*(dWidth/4);
arPts.append(ptTemp);
ptTemp = ptBase + vtMainV * (dWidth/8);
arPts.append(ptTemp);
ptTemp = ptBase + vtMainV * (dWidth/2 + dSkirtSize);
arPts.append(ptTemp);
}
else if (nType == 1)
{
ptTemp = ptBase - vtMainV * (dWidth/2 + dSkirtSize);
arPts.append(ptTemp);
ptTemp = ptBase - vtMainV * (dWidth/8);
arPts.append(ptTemp);
ptTemp = ptBase - vtMainV * (dWidth/16) - vtDir*(dWidth/8);
arPts.append(ptTemp);
ptTemp = ptTemp + vtDir*(dWidth/4) + vtMainV*(dWidth/8);
arPts.append(ptTemp);
ptTemp = ptBase + vtMainV * (dWidth/8);
arPts.append(ptTemp);
ptTemp = ptBase + vtMainV * (dWidth/2 + dSkirtSize);
arPts.append(ptTemp);
}
else if (nType == 2)
{
ptTemp = ptBase - vtMainV * (dWidth/2 + dSkirtSize);
arPts.append(ptTemp);
ptTemp = ptBase - vtMainV * (dWidth/8);
arPts.append(ptTemp);
ptTemp = ptBase - vtDir*(dWidth/8);
arPts.append(ptTemp);
ptTemp = ptBase + vtDir*(dWidth/8);
arPts.append(ptTemp);
ptTemp = ptBase + vtMainV * (dWidth/8);
arPts.append(ptTemp);
ptTemp = ptBase + vtMainV * (dWidth/2 + dSkirtSize);
arPts.append(ptTemp);
}
return arPts.length() > 0;
}
BOOL THImpHvacBroSymbol::GetCirInsertPt(AcGePoint3dArray &arPts) const
{
// 获取绘图数据
AcGePoint3d ptBase;
m_pXDataMap->GetAt(HBSM_InsertPoint, ptBase);
// 计算方向向量
AcGeVector3d vtNormal = AcGeVector3d::kIdentity;
AcGeVector3d vtDir = AcGeVector3d::kIdentity;
AcGeVector3d vtMainV = AcGeVector3d::kIdentity;
m_pXDataMap->GetAt(KEY_NORMAL, vtNormal);
m_pXDataMap->GetAt(HBSM_Dir, vtDir);
vtDir = vtDir.normalize();
vtMainV = vtDir;
vtMainV.rotateBy(PI / 2.0, vtNormal);
double dA = 53.13*PI/180;
double dDiameter = 0.0;
m_pXDataMap->GetAt(HBSM_Diameter, dDiameter);
double dDis = dDiameter/(4*sin(dA)) - dDiameter/(4*tan(dA));
arPts.append(ptBase);
AcGePoint3d ptTemp;
ptTemp = ptBase - vtMainV*(dDiameter/2);
arPts.append(ptTemp);
ptTemp = ptBase + vtMainV*(dDiameter/2);
arPts.append(ptTemp);
ptTemp = ptBase - vtMainV*(dDiameter/4);
ptTemp = ptTemp - vtDir*dDis;
arPts.append(ptTemp);
ptTemp = ptBase + vtMainV*(dDiameter/4);
ptTemp = ptTemp + vtDir*dDis;
arPts.append(ptTemp);
ptTemp = ptTemp - vtDir*dDis*2;
arPts.append(ptTemp);
return arPts.length() > 0;
}
// 注意：pXMap == NULL表示不想得到返回值，只是判断数据是否合理
// 先取出m_pXDataMap中数据进行判断是否合理，返回判断结果
// 如果pXMap不为NULL，则将有效参数填入pXMap
BOOL THImpHvacBroSymbol::IsValid(TDbXDataMap* pXMap)
{
if (NULL == m_pXDataMap)
return FALSE;
AcGePoint3d ptIns;
m_pXDataMap->GetAt(HBSM_InsertPoint, ptIns);
return TRUE;
}
void THImpHvacBroSymbol::OnSubErase( Adesk::Boolean erasing )
{
if (erasing == Adesk::kTrue && m_pOwnerEnt != NULL && m_pOwnerEnt->objectId().isValid())
{
// 如果实体不是在当前模型空间中,不做写消息,更新接口处理
AcDbDatabase* pDb = m_pOwnerEnt->database();
if (pDb == NULL)
pDb = acdbCurDwg();
AcDbObjectId idModel;
AcDbBlockTable* pTable = NULL;
pDb->getBlockTable(pTable, AcDb::kForRead);
if (pTable != NULL)
{
pTable->getAt(ACDB_MODEL_SPACE, idModel);
pTable->close();
}
// 如果实体不是在当前模型空间中,不做写消息,更新接口处理
if (TAuxTools::IsAutoWorkConnect() && idModel == m_pOwnerEnt->blockId())
{
// 写入接口更改消息
TInterfaceModifyMsg iMsg;
iMsg.SetMsgValidate(TRUE);
iMsg.SetMsgOperateOn(m_pOwnerEnt->objectId());
iMsg.SetInterfaceOper(TDb::eAutoWorkOn);
TDbInterfaceMsgWrite msgWrite;
msgWrite.WriteInterfaceMsg(iMsg);
}
}
}
LRESULT THImpHvacBroSymbol::UserCall( long i, LPVOID pData )
{
ASSERT(NULL != m_pXDataMap);
m_pXDataMap->SetAt(KEY_IDCNT1, NULL);
return 1l;
}
Reference in new issue View Git Blame Copy Permalink