511 lines
11 KiB
C++
511 lines
11 KiB
C++
#include "StdAfx.h"
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
const Adesk::UInt8 TDbEquipmentBox::g_nVersion = 0; // 可能需要与TDbOpening::g_nVersion关联
|
|
|
|
ACRX_DXF_DEFINE_MEMBERS(ATSEquipmentBox, ATSOpening, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
|
1, ATS_EquipmentBox, "ATS_EquipmentBox图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
|
|
|
|
IMPLEMENT_TENTBASE(TDbEquipmentBox);
|
|
|
|
TDbEquipmentBox::TDbEquipmentBox()
|
|
{
|
|
m_dBreadth = 200;
|
|
SetKind(TOpeningData::OP_EQUIPBOX);
|
|
}
|
|
|
|
TDbEquipmentBox::~TDbEquipmentBox()
|
|
{
|
|
}
|
|
|
|
BOOL TDbEquipmentBox::IsValid() const
|
|
{
|
|
BOOL bRet = TDbOpening::IsValid();
|
|
if (!bRet)
|
|
return bRet;
|
|
|
|
bRet = (m_dBreadth>_DIST_SNAP);
|
|
return bRet;
|
|
}
|
|
|
|
void TDbEquipmentBox::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbOpening::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
|
|
|
|
TDbEquipmentBox *pSrc = TDbEquipmentBox::cast(pSrcEntity);
|
|
if (pSrc != NULL)
|
|
{
|
|
m_dBreadth = pSrc->m_dBreadth;
|
|
}
|
|
}
|
|
|
|
|
|
Acad::ErrorStatus TDbEquipmentBox::dwgInFields(AcDbDwgFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
Acad::ErrorStatus es = TDbOpening::dwgInFields(pFiler);
|
|
if (es != Acad::eOk)
|
|
return es;
|
|
|
|
Adesk::UInt8 nVer;
|
|
pFiler->readItem(&nVer);
|
|
if (nVer > g_nVersion)
|
|
return Acad::eMakeMeProxy;
|
|
|
|
pFiler->readItem(&m_dBreadth);
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbEquipmentBox::dwgOutFields(AcDbDwgFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es = TDbOpening::dwgOutFields(pFiler);
|
|
if (es != Acad::eOk)
|
|
return es;
|
|
|
|
pFiler->writeItem(g_nVersion);
|
|
|
|
pFiler->writeItem(m_dBreadth);
|
|
|
|
return es;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbEquipmentBox::dxfInFields(AcDbDxfFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
Acad::ErrorStatus es = TDbOpening::dxfInFields(pFiler);
|
|
if (es != Acad::eOk)
|
|
return es;
|
|
|
|
if (!pFiler->atSubclassData(_T("TDbEquipmentBox")))
|
|
{
|
|
return Acad::eBadDxfSequence;
|
|
}
|
|
|
|
{
|
|
resbuf rb;
|
|
double dW(0.0);
|
|
|
|
while ((es == Acad::eOk) && ((es = pFiler->readResBuf(&rb)) == Acad::eOk))
|
|
{
|
|
switch (rb.restype)
|
|
{
|
|
case AcDb::kDxfReal + 7:
|
|
dW = rb.resval.rreal;
|
|
break;
|
|
default:
|
|
pFiler->pushBackItem();
|
|
break;
|
|
}
|
|
}
|
|
|
|
m_dBreadth = dW;
|
|
}
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbEquipmentBox::dxfOutFields(AcDbDxfFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es = TDbOpening::dxfOutFields(pFiler);
|
|
assert(es == Acad::eOk);
|
|
|
|
es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbEquipmentBox"));
|
|
assert(es == Acad::eOk);
|
|
|
|
pFiler->writeDouble(AcDb::kDxfReal+7, m_dBreadth);
|
|
return es;
|
|
}
|
|
|
|
|
|
Acad::ErrorStatus TDbEquipmentBox::GetGripText(int i, CString &cs) const
|
|
{
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
switch(i)
|
|
{
|
|
case 0:
|
|
cs = _T("移动设备箱");
|
|
break;
|
|
default:
|
|
es = Acad::eInvalidInput;
|
|
}
|
|
return es;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbEquipmentBox::subGetGripPoints(AcGePoint3dArray& gripPoints,
|
|
AcDbIntArray& osnapModes, AcDbIntArray& geomIds) const
|
|
{
|
|
gripPoints.append(m_ptLocation);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbEquipmentBox::subMoveGripPointsAt(const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
XPoint vtOffset = *(XPoint *)&offset;
|
|
vtOffset.z = 0;
|
|
|
|
double dSill = m_ptLocation.z;
|
|
|
|
for (int i=0; i<indices.length(); i++)
|
|
{
|
|
int idx = indices[i];
|
|
if (idx == 0) // 移动位置
|
|
{
|
|
XVector3D vt = vtOffset;
|
|
|
|
if (g_bModelNumber && IsLinear()) // 模数开关
|
|
{
|
|
ASSERT(g_nWinStep > 1.0E-3);
|
|
|
|
double nLen = vt.Length();
|
|
vt /= nLen;
|
|
nLen = AS_INT(nLen/g_nWinStep) * g_nWinStep;
|
|
vt *= nLen;
|
|
}
|
|
|
|
m_ptLocation += vt;
|
|
m_ptLocation.z = dSill; // 不改变设备箱底高
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
#if ADS>15
|
|
void TDbEquipmentBox::CreateGrip()
|
|
{
|
|
TDbEntity::CreateGrip();
|
|
|
|
XCurveSegment curve;
|
|
if (GetCenterCurve(curve) && curve.Is(CURVE_LINE))
|
|
{
|
|
GetGrip(0)->AppendDim(new TDbGripDistDim(AcDbDimData::kDimDeltaLength, false));
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbEquipmentBox::EntityToDim(long iGrip, long iDim, const AcDbEntity* pEnt0)
|
|
{
|
|
XCurveSegment wall;
|
|
if (!GetCenterCurve(wall)) // 中线
|
|
return Acad::eInvalidInput;
|
|
|
|
TDbGripDim *pDim = GetGripDim(iGrip, iDim);
|
|
if (pDim == NULL)
|
|
return Acad::eInvalidInput;
|
|
|
|
TDbEquipmentBox *pEnt = TDbEquipmentBox::cast(pEnt0);
|
|
if (pEnt == NULL)
|
|
pEnt = this;
|
|
|
|
switch(iGrip)
|
|
{
|
|
case 0: // 位置夹点
|
|
switch(iDim)
|
|
{
|
|
case 0: // 位置偏移
|
|
{
|
|
TDbGripDistDim *pDistDim = (TDbGripDistDim*)pDim;
|
|
|
|
XPoint pt;
|
|
wall.ProjectToMe(pEnt->GetLocation(), pt);
|
|
|
|
pDistDim->SetData(pt.AsAcGePoint3d(), pDim->GripPoint(), 800);
|
|
}
|
|
break;
|
|
default:
|
|
return Acad::eNotImplementedYet;
|
|
}
|
|
break;
|
|
default:
|
|
return Acad::eNotImplementedYet;
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbEquipmentBox::DimToEntity(long iGrip, long iDim, double newValue, const AcGeVector3d& offset)
|
|
{
|
|
assertWriteEnabled();
|
|
AcGePoint3d ptNew = GetGripPoint(iGrip) + offset;
|
|
|
|
XCurveSegment wall;
|
|
GetCenterCurve(wall);
|
|
XPoint vt = wall.EndPoint() - wall.StartPoint();
|
|
vt.Normalize();
|
|
|
|
switch(iGrip)
|
|
{
|
|
case 0: // 位置夹点
|
|
switch(iDim)
|
|
{
|
|
case 0: // 位置偏移
|
|
{
|
|
if (vt.AsAcGeVector3d().dotProduct(offset) > 0)
|
|
vt *= newValue;
|
|
else
|
|
vt *= -newValue;
|
|
m_ptLocation += vt;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
#endif
|
|
|
|
|
|
Acad::ErrorStatus TDbEquipmentBox::subTransformBy(const AcGeMatrix3d& xform)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbOpening::subTransformBy(xform);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
|
|
Acad::ErrorStatus TDbEquipmentBox::GetInsert2DScale(double *pScaleX, double *pScaleY) const
|
|
{
|
|
assertReadEnabled();
|
|
double dScaleX = m_nWidth,
|
|
dScaleY = m_dBreadth;
|
|
|
|
if (m_nQuadrant == 1)
|
|
dScaleX = -dScaleX;
|
|
else if (m_nQuadrant == 2)
|
|
{
|
|
dScaleX = -dScaleX;
|
|
dScaleY = -dScaleY;
|
|
}
|
|
else if (m_nQuadrant == 3)
|
|
dScaleY = -dScaleY;
|
|
|
|
*pScaleX = dScaleX;
|
|
*pScaleY = dScaleY;
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbEquipmentBox::ExplodeOrDraw2d(XExplodeDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
if (!IsValid() || !m_nIdStyle2d.isValid())
|
|
return Acad::eNotApplicable;
|
|
|
|
double nScaleX, nScaleY;
|
|
GetInsert2DScale(&nScaleX, &nScaleY); // 取墙的宽度作为门窗厚度
|
|
|
|
XPoint ptInsert = m_ptLocation;
|
|
if (GetBreakWall() && !!m_nIdOfWall) // 约定插入点在墙线的形心线上
|
|
{
|
|
double dWallWidth(0.0);
|
|
OPENOBJ_BEGIN(m_nIdOfWall, AcDb::kForRead, TDbWall, pWall);
|
|
if (pWall)
|
|
{
|
|
dWallWidth = pWall->GetWidth(4);
|
|
dWallWidth *= 0.5;
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
ads_polar(m_ptLocation, m_nRotation+PI/2, dWallWidth-m_nThickness+0.5*m_dBreadth, ptInsert);
|
|
}
|
|
ptInsert.z = 0.0;
|
|
|
|
BOOL bToTch3 = (_tcscmp(dc.Desc(), XExplodeStream::Descriptor())==0 &&
|
|
m_lstClipId.Length()==0 && dc.IsExportTch4() && m_nIdStyle2d.isValid());
|
|
if (bToTch3) // 导出T3
|
|
{
|
|
AcDbBlockReference *pInsert = new AcDbBlockReference(ptInsert, m_nIdStyle2d);
|
|
pInsert->setPropertiesFrom(this);
|
|
pInsert->setRotation(m_nRotation);
|
|
|
|
BOOL bReg = FALSE;
|
|
AcDbDatabase *pDb = database();
|
|
AcDbRegAppTable *pAppTab = NULL;
|
|
if (pDb)
|
|
pDb->getSymbolTable(pAppTab, AcDb::kForRead);
|
|
if (pAppTab)
|
|
{
|
|
bReg = pAppTab->has(_T("WTHICK"));
|
|
pAppTab->close();
|
|
}
|
|
|
|
double nWallWidth = GetWallThickness(TRUE);
|
|
if (pDb==acdbCurDwg() && bReg)
|
|
{
|
|
pInsert->setScaleFactors(AcGeScale3d(nScaleX, nScaleY, nScaleX));
|
|
resbuf *xdata = ads_buildlist(1001, _T("WTHICK"), 1040, m_dBreadth, NULL);
|
|
pInsert->setXData(xdata);
|
|
ads_relrb(xdata);
|
|
}
|
|
else
|
|
pInsert->setScaleFactors(AcGeScale3d(nScaleX, nScaleY, m_dBreadth));
|
|
((XExplodeStream &)dc).Append(pInsert, FALSE);
|
|
}
|
|
else // 显示图块
|
|
{
|
|
BOOL bMakeBlock = g_bMakeBlock;
|
|
if (_tcsicmp(dc.Desc(), XAcGiViewDraw::Descriptor()) == 0)
|
|
{
|
|
if (dc.IsPlotGeneration()) // 强制打印时，不使用新方法
|
|
bMakeBlock = FALSE;
|
|
else
|
|
bMakeBlock = (g_nAcadVer>15.0001);
|
|
}
|
|
|
|
dc << XBlockRef(m_nIdStyle2d, ptInsert, AcGeScale3d(nScaleX, nScaleY, nScaleX), m_nRotation, bMakeBlock);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbEquipmentBox::GetInsert3DScale(double *pScaleX, double *pScaleY, double *pScaleZ) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
double dScaleX, dScaleY, dScaleZ;
|
|
if (!(!m_nIdStyle3d)) // Use 3dStyle
|
|
{
|
|
XPoint origenalSize;
|
|
if (!GetOriginal3DSize(m_nIdStyle3d, origenalSize))
|
|
return Acad::eInvalidInput;
|
|
|
|
dScaleX = origenalSize.x>_DIST_SNAP ? (m_nWidth/origenalSize.x) : 1.0;
|
|
dScaleY = origenalSize.y>_DIST_SNAP ? (m_dBreadth/origenalSize.y) : 1.0;
|
|
dScaleZ = origenalSize.z>_DIST_SNAP ? (m_nHeight/origenalSize.z) : 1.0;
|
|
}
|
|
else // Use 2d Extrude
|
|
{
|
|
XDbObject objBlock(m_nIdStyle2d, AcDb::kForRead);
|
|
if(!objBlock)
|
|
return Acad::eInvalidInput;
|
|
|
|
AcDbBlockTableRecord *pBlock = AcDbBlockTableRecord::cast(objBlock.m_pObject);
|
|
dScaleY = m_dBreadth;
|
|
dScaleX = m_nWidth;
|
|
dScaleZ = 1.0;
|
|
}
|
|
|
|
// 镜像情况
|
|
if (m_nQuadrant == 1)
|
|
dScaleX = -dScaleX;
|
|
else if (m_nQuadrant == 2)
|
|
{
|
|
dScaleX = -dScaleX;
|
|
dScaleY = -dScaleY;
|
|
}
|
|
else if (m_nQuadrant == 3)
|
|
dScaleY = -dScaleY;
|
|
|
|
*pScaleX = dScaleX;
|
|
*pScaleY = dScaleY;
|
|
*pScaleZ = dScaleZ;
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbEquipmentBox::ExplodeOrDraw3d(XExplodeDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
if (!IsValid())
|
|
return Acad::eNotApplicable;
|
|
|
|
OPENOBJ_BEGIN(m_nIdOfWall, AcDb::kForRead, TDbWall, pWall);
|
|
if (pWall)
|
|
{
|
|
if (!g_bIntWall3DVisible && !pWall->IsExternal(OFFSET_LEFT) && !pWall->IsExternal(OFFSET_RIGHT))
|
|
return Acad::eOk; // 关闭内墙显示
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
double dScaleX, dScaleY, dScaleZ;
|
|
Acad::ErrorStatus es = Acad::eCannotExplodeEntity;
|
|
if (GetInsert3DScale(&dScaleX, &dScaleY, &dScaleZ) != Acad::eOk)
|
|
return es;
|
|
|
|
XPoint ptInsert = m_ptLocation;
|
|
if (!(!m_nIdStyle3d)) // 显示真三维
|
|
{
|
|
dc << XBlockRef(m_nIdStyle3d, ptInsert, AcGeScale3d(dScaleX, dScaleY, dScaleZ), m_nRotation, g_bMakeBlock);
|
|
}
|
|
else if(!!m_nIdStyle2d)
|
|
{
|
|
dc << XBlockRef(m_nIdStyle2d, ptInsert, AcGeScale3d(dScaleX, dScaleY, m_nHeight), m_nRotation, g_bMakeBlock);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
|
|
const TCHAR* TDbEquipmentBox::GetKindString() const
|
|
{
|
|
return _T("设备箱");
|
|
}
|
|
|
|
|
|
void TDbEquipmentBox::MirrorSelf(BOOL bLeftRight)
|
|
{
|
|
assertWriteEnabled();
|
|
int nQua = m_nQuadrant;
|
|
switch(nQua)
|
|
{
|
|
case 0:
|
|
nQua = bLeftRight ? 1 : 3;
|
|
break;
|
|
case 1:
|
|
nQua = bLeftRight ? 0 : 2;
|
|
break;
|
|
case 2:
|
|
nQua = bLeftRight ? 3 : 1;
|
|
break;
|
|
case 3:
|
|
nQua = bLeftRight ? 2 : 0;
|
|
break;
|
|
}
|
|
|
|
m_nQuadrant = nQua;
|
|
}
|
|
|
|
|
|
// 设置设备箱的宽度
|
|
void TDbEquipmentBox::SetBreadth(double dBreadth)
|
|
{
|
|
assertWriteEnabled();
|
|
m_dBreadth = dBreadth;
|
|
}
|
|
|
|
double TDbEquipmentBox::GetBreadth() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_dBreadth;
|
|
}
|
|
|
|
// 设置是否打断墙体
|
|
void TDbEquipmentBox::SetBreakWall(BOOL bBreak)
|
|
{
|
|
assertWriteEnabled();
|
|
SetLoneOpening(bBreak);
|
|
}
|
|
|
|
BOOL TDbEquipmentBox::GetBreakWall() const
|
|
{
|
|
assertReadEnabled();
|
|
return IsLoneOpening();
|
|
}
|
|
|
|
|
|
|
|
void InitDbEquipmentBox(BOOL bTrue)
|
|
{
|
|
if(bTrue)
|
|
{
|
|
TDbEquipmentBox::rxInit();
|
|
acrxBuildClassHierarchy();
|
|
TDbEquipmentBox::InitMatchProtocol(TRUE);
|
|
}
|
|
else
|
|
{
|
|
TDbEquipmentBox::InitMatchProtocol(FALSE);
|
|
deleteAcRxClass(TDbEquipmentBox::desc());
|
|
}
|
|
} |