1193 lines
29 KiB
C++
1193 lines
29 KiB
C++
#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;
|
|
}
|