2394 lines
53 KiB
C++
2394 lines
53 KiB
C++
#include "stdafx.h"
|
|
#include "AecDbECableTray.h"
|
|
#include "dbgrip.h"
|
|
#include "AecGripCback.h"
|
|
#include "KTCADUtilityEx.h"
|
|
#include "AecDbWall.h"
|
|
#include "AecDbSlab.h"
|
|
#include "KTSetting.h"
|
|
#include "AcGiViewDraw.h"
|
|
#include "AecDb3dRoadAxisLine.h"
|
|
#include "AecDbHolder.h"
|
|
|
|
extern double PixelToWcs(int nPixel);
|
|
extern BOOL Is2DView();
|
|
extern AcGeVector3d GetUcsZvt();
|
|
extern void PushGripMessage(GripMessage&);
|
|
|
|
static const Adesk::UInt16 kColorByBlock = 0;
|
|
static const Adesk::UInt16 kRed = 1;
|
|
static const Adesk::UInt16 kYellow = 2;
|
|
static const Adesk::UInt16 kGreen = 3;
|
|
static const Adesk::UInt16 kCyan = 4;
|
|
static const Adesk::UInt16 kBlue = 5;
|
|
static const Adesk::UInt16 kMagenta = 6;
|
|
static const Adesk::UInt16 kWhite = 7;
|
|
static const Adesk::UInt16 kColorByLayer = 256;
|
|
|
|
#ifndef GRIPPT_RESP_FROM_EWFIT
|
|
#define GRIPPT_RESP_FROM_EWFIT 1394
|
|
#endif
|
|
|
|
static AcGePoint3d Mid(const AcGePoint3d& ptGe1,const AcGePoint3d& ptGe2)
|
|
{
|
|
return AcGePoint3d( (ptGe1.x + ptGe2.x) / 2.0,
|
|
(ptGe1.y + ptGe2.y) / 2.0,
|
|
(ptGe1.z + ptGe2.z) / 2.0);
|
|
}
|
|
|
|
static void FreeBuffer(int n,AcDbVoidPtrArray& arEntPtrs)
|
|
{
|
|
AcDbEntity* pEnt = NULL;
|
|
while(arEntPtrs.length() > n )
|
|
{
|
|
pEnt = (AcDbEntity*)arEntPtrs.last();
|
|
if (pEnt != NULL)
|
|
{
|
|
pEnt->erase();
|
|
pEnt->close();
|
|
arEntPtrs.removeLast();
|
|
DELETE_PTR(pEnt);
|
|
}
|
|
}
|
|
}
|
|
|
|
DLLIMPEXP AcDb3dPolyline *Format3dPolyline(const AcGePoint3dArray &arPts);
|
|
DLLIMPEXP AcDbPolyline *Format3dPolyline(const AcGePoint3d *pptGe, int nPoints, const AcGeVector3d &vtNorm);
|
|
DLLIMPEXP AcDbCurve *GetMinOffsetCurve(AcDbCurve *pPl, double dOff);
|
|
|
|
Adesk::UInt32 AecDbECableTray::kCurrentVersionNumber = 1;
|
|
|
|
ACRX_DXF_DEFINE_MEMBERS (AecDbECableTray, AecDbEwPipeBase,
|
|
AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
|
AcDbProxyEntity::kNoOperation | AcDbProxyEntity::kDisableProxyWarning,
|
|
AEC_DBCABTRY,
|
|
"AecDbECableTray"
|
|
"|Product Desc: shanghua earthworm app obj"
|
|
"|Company: shanghua inc"
|
|
"|WEB Address: www.shanghuasoft.com")
|
|
|
|
|
|
AecDbECableTray::AecDbECableTray(void)
|
|
{
|
|
}
|
|
|
|
AecDbECableTray::~AecDbECableTray(void)
|
|
{
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbECableTray::SetStartPoint(const AcGePoint3d& ptSta)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
if (m_pBaseCurve == NULL)
|
|
m_pBaseCurve = new AcDbLine;
|
|
|
|
AcDbLine* pLine = AcDbLine::cast(m_pBaseCurve);
|
|
if (pLine != NULL)
|
|
{
|
|
pLine->setStartPoint(ptSta);
|
|
return Acad::eOk;
|
|
}
|
|
return Acad::eInvalidInput;
|
|
}
|
|
|
|
AcGePoint3d AecDbECableTray::StartPoint() const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcGePoint3d ptSta;
|
|
getStartPoint(ptSta);
|
|
|
|
return ptSta;
|
|
}
|
|
|
|
// 设置端点 如果是LINE管子
|
|
Acad::ErrorStatus AecDbECableTray::SetEndPoint(const AcGePoint3d& ptEnd)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
if (m_pBaseCurve == NULL)
|
|
m_pBaseCurve = new AcDbLine;
|
|
|
|
AcDbLine* pLine = AcDbLine::cast(m_pBaseCurve);
|
|
if (pLine != NULL)
|
|
{
|
|
pLine->setEndPoint(ptEnd);
|
|
return Acad::eOk;
|
|
}
|
|
return Acad::eInvalidInput;
|
|
}
|
|
|
|
AcGePoint3d AecDbECableTray::EndPoint() const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcGePoint3d ptSta;
|
|
getEndPoint(ptSta);
|
|
|
|
return ptSta;
|
|
}
|
|
|
|
bool AecDbECableTray::SetDuctParam(const AecHvac::DuctParam* pData)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
if (pData == NULL)
|
|
return false;
|
|
|
|
m_mapSpecXData.SetAt(KEY_APP, pData->m_app);
|
|
if (pData->m_app == WPipe::eTrench)
|
|
{
|
|
m_mapSpecXData.SetAt(KEY_HIDESTART, 1);
|
|
m_mapSpecXData.SetAt(KEY_HIDEEND, 1);
|
|
m_mapSpecXData.SetAt(PIPE_DRAWDIR, WPipe::eID);
|
|
|
|
m_mapSpecXData.SetAt(PIPE_OD, pData->dSize[0] + 2.0 * pData->dSize[2]);
|
|
m_mapSpecXData.SetAt(PIPE_THICK, pData->dSize[2]);
|
|
}
|
|
|
|
if (pData->m_app == WPipe::eBridge)
|
|
{
|
|
double dL0 = 0, dW0 = 0;
|
|
m_mapSpecXData.GetAt(KEY_SIZE1, dL0);
|
|
m_mapSpecXData.GetAt(KEY_SIZE2, dW0);
|
|
|
|
double dUse1 = 0, dUse2 = 0;
|
|
m_mapSpecXData.GetAt(KEY_FILLUSED, dUse1);//0.55
|
|
m_mapSpecXData.GetAt(KEY_FILLUSED, dUse2);//0.45
|
|
|
|
BOOL bSpart = 0;
|
|
m_mapSpecXData.GetAt(KEY_SPART, bSpart);
|
|
|
|
if (dUse1 > 1.e-3 && !bSpart)//有填充率
|
|
{
|
|
double dAreaUsedOld = dUse1 * dL0 * dW0;
|
|
double dAreaNewSet = dAreaUsedOld / (pData->dSize[0] * pData->dSize[1]);
|
|
m_mapSpecXData.SetAt(KEY_FILLUSED, dAreaNewSet);//0.55
|
|
}
|
|
else if (dUse1 > 1.e-3 && dUse2 > 1.e-3 && bSpart)
|
|
{
|
|
double dAreaUsedOld = dUse1 * dL0 * dW0 * 0.5;
|
|
double dAreaNewSet = dAreaUsedOld / (pData->dSize[0] * pData->dSize[1] * 0.5);
|
|
m_mapSpecXData.SetAt(KEY_FILLUSED, dAreaNewSet);//0.55
|
|
|
|
dAreaUsedOld = dUse2 * dL0 * dW0 * 0.5;
|
|
dAreaNewSet = dAreaUsedOld / (pData->dSize[0] * pData->dSize[1] * 0.5);
|
|
m_mapSpecXData.SetAt(KEY_FILLUSED, dAreaNewSet);//0.45
|
|
}
|
|
}
|
|
|
|
m_mapSpecXData.SetAt(KEY_MATERIAL,pData->szMat);
|
|
m_mapSpecXData.SetAt(KEY_FACTORY,pData->szFat);
|
|
m_mapSpecXData.SetAt(KEY_RRATIO,pData->m_dRatio);
|
|
m_mapSpecXData.SetAt(KEY_FULLPER,pData->m_dFullPer);
|
|
m_mapSpecXData.SetAt(KEY_FULLPER2, pData->m_dFullPer2);
|
|
m_mapSpecXData.SetAt(KEY_WELLW, pData->dSize[4]);
|
|
m_mapSpecXData.SetAt(KEY_SN,pData->szNo);
|
|
m_mapSpecXData.SetAt(KEY_TYPE,pData->szType);
|
|
m_mapSpecXData.SetAt(KEY_EXT,pData->szExt);
|
|
m_mapSpecXData.SetAt(PIPE_SYS,pData->szSys);
|
|
m_mapSpecXData.SetAt(KEY_COVER,pData->m_bCover);
|
|
m_mapSpecXData.SetAt(KEY_SPART,pData->m_bSpart);
|
|
m_mapSpecXData.SetAt(KEY_SYSSPLT, pData->m_nSysSplit);
|
|
m_mapSpecXData.SetAt(KEY_CENNODRAW,pData->m_bCenDraw ? 0 : 1);//中心线
|
|
m_mapSpecXData.SetAt(KEY_REM,pData->szRem);
|
|
m_mapSpecXData.SetAt(KEY_SECSHAPE,(int)pData->eType);
|
|
|
|
//设置标高
|
|
//如果是水平管子
|
|
AcGePoint3d ptS = StartPoint();
|
|
AcGePoint3d ptE = EndPoint();
|
|
AcGeVector3d vt = ptE - ptS;
|
|
AcGeLine3d ln(ptS,vt);
|
|
if (ln.isParallelTo(AcGePlane::kXYPlane))
|
|
{
|
|
SetElevation(pData->m_dEl);
|
|
}
|
|
|
|
bool bSetSect = false;
|
|
double dL = 0.0,dW = 0.0,dt = 0.0;
|
|
double dD = 0.0;
|
|
switch(pData->eType)
|
|
{
|
|
case eRect:
|
|
{
|
|
dL = pData->dSize[0];
|
|
dW = pData->dSize[1];
|
|
dt = pData->dSize[2];
|
|
|
|
if (dL > 1.e-6 && dW > 1.e-6 && dt > 1.e-6)
|
|
{
|
|
if (pData->m_bCover)
|
|
{
|
|
SetSection(dL,dW,dt);
|
|
}
|
|
else
|
|
{
|
|
//如果是立管,还要调成封闭
|
|
SetSection1(dL,dW,dt,true);
|
|
m_mapSpecXData.SetAt(KEY_SECSHAPE,(int)pData->eType);
|
|
|
|
m_mapSpecXData.SetAt(KEY_SIZE1,dL);
|
|
m_mapSpecXData.SetAt(KEY_SIZE2,dW);
|
|
m_mapSpecXData.SetAt(PIPE_THICK,dt);
|
|
}
|
|
bSetSect = true;
|
|
}
|
|
break;
|
|
}
|
|
case eCircle:
|
|
{
|
|
dD = pData->dSize[0];
|
|
dt = pData->dSize[2];
|
|
|
|
if (dD > 1.e-6 && dt > 1.e-6)
|
|
{
|
|
SetSection(dD,dt);
|
|
bSetSect = true;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
//保存预留数据 电缆沟等用
|
|
CString sKey;
|
|
for (int i = 5; i < 33; i++)//
|
|
{
|
|
sKey.Format(_T("%s_%d"), KEY_SIZE, i);
|
|
m_mapSpecXData.SetAt(sKey, pData->dSize[i]);
|
|
}
|
|
|
|
return bSetSect;
|
|
}
|
|
|
|
void AecDbECableTray::SetElevation(double dEl)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
AcDbLine* pLine = AcDbLine::cast(m_pBaseCurve);
|
|
if (pLine != NULL)
|
|
{
|
|
AcGePoint3d ptSta = pLine->startPoint();
|
|
AcGePoint3d ptEnd = pLine->endPoint();
|
|
|
|
if (fabs(ptSta.z - ptEnd.z) < 1.e-2)
|
|
{
|
|
ptSta.z = dEl;ptEnd.z = dEl;
|
|
pLine->setStartPoint(ptSta);
|
|
pLine->setEndPoint(ptEnd);
|
|
}
|
|
}
|
|
}
|
|
|
|
void AecDbECableTray::GetDuctParam(AecHvac::DuctParam& data) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
memset(&data,0,sizeof(AecHvac::DuctParam));
|
|
|
|
int nType = 0;
|
|
m_mapSpecXData.GetAt(KEY_SECSHAPE,nType);
|
|
|
|
int nCenNDraw = 0;
|
|
ESection eType = (ESection)nType;
|
|
data.eType = eType;
|
|
|
|
data.m_app = WPipe::eBridge;
|
|
int nApp = 7;
|
|
m_mapSpecXData.GetAt(KEY_APP, nApp);
|
|
data.m_app = WPipe::EApp(nApp);
|
|
if (nApp == 0)
|
|
data.m_app = WPipe::eBridge;
|
|
|
|
switch(eType)
|
|
{
|
|
case eRect:
|
|
{
|
|
m_mapSpecXData.GetAt(KEY_SIZE1,data.dSize[0]); //L
|
|
m_mapSpecXData.GetAt(KEY_SIZE2,data.dSize[1]); //w
|
|
m_mapSpecXData.GetAt(PIPE_THICK,data.dSize[2]);//t
|
|
m_mapSpecXData.GetAt(KEY_CENNODRAW,nCenNDraw);//中心线
|
|
data.m_bCenDraw = nCenNDraw ? 0 : 1;
|
|
break;
|
|
}
|
|
case eCircle:
|
|
{
|
|
m_mapSpecXData.GetAt(KEY_SIZE1,data.dSize[0]); //D
|
|
data.dSize[1] = 0.0;
|
|
m_mapSpecXData.GetAt(PIPE_THICK,data.dSize[2]);//t
|
|
m_mapSpecXData.GetAt(KEY_CENNODRAW,nCenNDraw);//中心线
|
|
data.m_bCenDraw = nCenNDraw ? 0 : 1;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
//假设是平行XY
|
|
data.m_dEl = StartPoint().z;
|
|
|
|
data.m_nAlign = 1;//居中
|
|
m_mapSpecXData.GetAt(KEY_WELLW, data.dSize[4]);
|
|
m_mapSpecXData.GetAt(KEY_NORMAL,data.m_vtNrom);
|
|
m_mapSpecXData.GetAt(KEY_RRATIO,data.m_dRatio);
|
|
|
|
m_mapSpecXData.GetAt(KEY_FULLPER,data.m_dFullPer);
|
|
data.m_dFillUsed = 0;
|
|
m_mapSpecXData.GetAt(KEY_FILLUSED, data.m_dFillUsed);
|
|
|
|
m_mapSpecXData.GetAt(KEY_FULLPER2, data.m_dFullPer2);
|
|
data.m_dFillUsed2 = 0;
|
|
m_mapSpecXData.GetAt(KEY_FILLUSED2, data.m_dFillUsed2);
|
|
|
|
CString sTemp = _T("");
|
|
m_mapSpecXData.GetAt(KEY_SN,sTemp);
|
|
_tcscpy(data.szNo,(LPCTSTR)sTemp);
|
|
|
|
sTemp = _T("");
|
|
m_mapSpecXData.GetAt(KEY_TYPE,sTemp);
|
|
_tcscpy(data.szType,(LPCTSTR)sTemp);
|
|
|
|
sTemp = _T("");
|
|
m_mapSpecXData.GetAt(KEY_EXT,sTemp);
|
|
_tcscpy(data.szExt,(LPCTSTR)sTemp);
|
|
|
|
sTemp = _T("");
|
|
m_mapSpecXData.GetAt(PIPE_SYS,sTemp);
|
|
_tcscpy(data.szSys,(LPCTSTR)sTemp);
|
|
|
|
m_mapSpecXData.GetAt(KEY_COVER,data.m_bCover);
|
|
m_mapSpecXData.GetAt(KEY_SPART,data.m_bSpart);
|
|
m_mapSpecXData.GetAt(KEY_SYSSPLT,data.m_nSysSplit);
|
|
//...
|
|
m_mapSpecXData.GetAt(KEY_MATERIAL,sTemp);
|
|
_tcscpy(data.szMat,(LPCTSTR)sTemp);
|
|
|
|
m_mapSpecXData.GetAt(KEY_FACTORY,sTemp);
|
|
_tcscpy(data.szFat,(LPCTSTR)sTemp);
|
|
|
|
m_mapSpecXData.GetAt(KEY_REM,sTemp);
|
|
_tcscpy(data.szRem,(LPCTSTR)sTemp);
|
|
|
|
//提取预留数据 电缆沟等用
|
|
CString sKey;
|
|
for (int i = 5; i < 33; i++)//
|
|
{
|
|
sKey.Format(_T("%s_%d"), KEY_SIZE, i);
|
|
m_mapSpecXData.GetAt(sKey, data.dSize[i]);
|
|
}
|
|
}
|
|
|
|
bool AecDbECableTray::GetDlgData(DlgData &data) const
|
|
{
|
|
memset(&data, 0, sizeof(DlgData));
|
|
|
|
int nApp = 0;
|
|
if (!m_mapSpecXData.GetAt(KEY_APP, nApp))
|
|
return false;
|
|
|
|
if ((WPipe::EApp)nApp != WPipe::eTrench)
|
|
return false;
|
|
|
|
AecHvac::DuctParam param;
|
|
memset(¶m, 0, sizeof(AecHvac::DuctParam));
|
|
GetDuctParam(param);
|
|
data.m_bHasCover = param.m_bCover;
|
|
data.m_dW = param.dSize[4];
|
|
data.m_dH = param.dSize[5];
|
|
data.m_dt = param.dSize[6];
|
|
data.m_db = param.dSize[7];
|
|
data.m_dd = param.dSize[8];
|
|
data.m_dh2 = param.dSize[9];
|
|
data.m_dk = param.dSize[10];
|
|
data.m_dTopEl = param.dSize[11];
|
|
data.m_dRatio = param.m_dRatio;
|
|
_tcscpy(data.m_sGKind, param.szType);
|
|
_tcscpy(data.m_szNo, param.szNo);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool AecDbECableTray::SetXHolder(EAlign kPos, XHolder &xH)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
switch (kPos)
|
|
{
|
|
case kLeft:
|
|
{
|
|
m_mapSpecXData.SetAt(KEY_LEFT, &xH, sizeof(XHolder));
|
|
break;
|
|
}
|
|
case kRight:
|
|
{
|
|
m_mapSpecXData.SetAt(KEY_RIGHT, &xH, sizeof(XHolder));
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool AecDbECableTray::GetXHolder(EAlign kPos, XHolder &xH) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
int nSize1 = sizeof(XHolder);
|
|
int nSize2 = 0;
|
|
XHolder *pHolder = NULL;
|
|
|
|
switch (kPos)
|
|
{
|
|
case kLeft:
|
|
{
|
|
if (!m_mapSpecXData.GetAt(KEY_LEFT, (void *&)pHolder, nSize2))
|
|
return false;
|
|
|
|
if (pHolder->N <= 0) return false;
|
|
|
|
if (nSize2 == nSize1 && pHolder != NULL)
|
|
{
|
|
memcpy(&xH, pHolder, nSize1);
|
|
delete pHolder;
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
case kRight:
|
|
{
|
|
if (!m_mapSpecXData.GetAt(KEY_RIGHT, (void *&)pHolder, nSize2))
|
|
return false;
|
|
|
|
if (pHolder->N <= 0) return false;
|
|
|
|
if (nSize2 == nSize1 && pHolder != NULL)
|
|
{
|
|
memcpy(&xH, pHolder, nSize1);
|
|
delete pHolder;
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
AcGeVector3d AecDbECableTray::GetNormal() const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcGeVector3d vtNorm(0,0,1);
|
|
m_mapSpecXData.GetAt(KEY_NORMAL,vtNorm);
|
|
|
|
return vtNorm;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbECableTray::dwgInFields(AcDbDwgFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
//----- Read parent class information first.
|
|
Acad::ErrorStatus es = AecDbEwPipeBase::dwgInFields (pFiler) ;
|
|
if ( es != Acad::eOk )
|
|
return (es) ;
|
|
|
|
//----- Object version number needs to be read first
|
|
Adesk::UInt32 version =0 ;
|
|
if ( (es =pFiler->readUInt32 (&version)) != Acad::eOk )
|
|
return (es) ;
|
|
|
|
if ( version > AecDbECableTray::kCurrentVersionNumber )
|
|
return (Acad::eMakeMeProxy);
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbECableTray::dwgOutFields(AcDbDwgFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
//----- Save parent class information first.
|
|
Acad::ErrorStatus es = AecDbEwPipeBase::dwgOutFields (pFiler) ;
|
|
if ( es != Acad::eOk )
|
|
return (es) ;
|
|
|
|
//----- Object version number needs to be saved first
|
|
if ( (es =pFiler->writeUInt32 (AecDbECableTray::kCurrentVersionNumber)) != Acad::eOk )
|
|
return (es) ;
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbECableTray::dxfInFields(AcDbDxfFiler* pFiler)
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbECableTray::dxfOutFields(AcDbDxfFiler* pFiler) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
#if ARX>16
|
|
|
|
void AecDbECableTray::subList() const
|
|
{
|
|
assertReadEnabled();
|
|
AecDbEwPipeBase::subList();
|
|
|
|
acutPrintf(_T("\n桥架:"));
|
|
|
|
AcArray<AecInterface> arInf;
|
|
GetInterface(arInf);
|
|
|
|
for (int i = 0; i < arInf.length(); i++)
|
|
{
|
|
AecInterface &inf = arInf.at(i);
|
|
acutPrintf(_T("\nInf%d : pt = (%.3f,%.3f,%.3f) size = %.3f,%.3f"), i + 1, inf.ptPos.x, inf.ptPos.y, inf.ptPos.z, inf.dSize1, inf.dSize2);
|
|
}
|
|
|
|
acutPrintf(_T("\n属性数据:"));
|
|
m_mapSpecXData.List();
|
|
acutPrintf(_T("\n"));
|
|
}
|
|
|
|
bool AecDbECableTray::GetBimInfoTip(CString& sInfoTip) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AecHvac::DuctParam data;
|
|
memset(&data,0,sizeof(AecHvac::DuctParam));
|
|
|
|
GetDuctParam(data);
|
|
|
|
CString sField,sFmt;
|
|
sField = _T("桥架:\n");
|
|
sInfoTip += sField;
|
|
|
|
MAKEFIELD(_T("类型"),_T("%s"),data.szType,sInfoTip);
|
|
|
|
MAKEFIELD(_T("宽度"),_T("%d"),(int)(data.dSize[0]+0.5),sInfoTip);
|
|
MAKEFIELD(_T("高度"),_T("%d"),(int)(data.dSize[1]+0.5),sInfoTip);
|
|
|
|
MAKEFIELD(_T("板材厚度"),_T("%.1f"),data.dSize[2],sInfoTip);
|
|
|
|
MAKEFIELD(_T("底标高"),_T("%.1f"),data.m_dEl,sInfoTip);
|
|
|
|
MAKEFIELD(_T("系统"),_T("%s"),data.szSys,sInfoTip);
|
|
|
|
MAKEFIELD(_T("材料"),_T("%s"),data.szMat,sInfoTip);
|
|
|
|
MAKEFIELD(_T("厂家"),_T("%s"),data.szFat,sInfoTip);
|
|
|
|
MAKEFIELD(_T("编号"),_T("%s"),data.szNo,sInfoTip);
|
|
|
|
return true;
|
|
}
|
|
|
|
#ifndef EL_SYS
|
|
#define HIGH_V _T("高压")
|
|
#define LOW_V _T("低压")
|
|
#define KVV _T("控制")
|
|
#define MSGV _T("通讯")
|
|
#define MSGV2 _T("信号")
|
|
#define MSGV3 _T("仪表")
|
|
#endif
|
|
bool IsSameAsSysUse(LPCTSTR pszSys1, LPCTSTR pszSysD)
|
|
{
|
|
CString sSys1 = pszSys1;
|
|
CString sSysD = pszSysD;
|
|
//sSysPt
|
|
//控制和通讯(<450-750v);仪表(24v);动力低压(0.6-1kv);动力高压[3-110kv);
|
|
|
|
//syscab 含有如下
|
|
/*
|
|
#define HIGH_V _T("高压")
|
|
#define LOW_V _T("低压")
|
|
#define KVV _T("控制")
|
|
#define MSGV _T("通讯")
|
|
#define MSGV2 _T("信号")
|
|
#define MSGV3 _T("仪表")
|
|
*/
|
|
|
|
//sSysPt 和 sSysCab 都含有上述define 是，为系统匹配
|
|
|
|
CStringList arSHv, arSLv;
|
|
CStringList arKMSG;
|
|
|
|
arSHv.AddTail(HIGH_V);
|
|
arSLv.AddTail(LOW_V);
|
|
|
|
arKMSG.AddTail(KVV); arKMSG.AddTail(MSGV); arKMSG.AddTail(MSGV2); arKMSG.AddTail(MSGV3);
|
|
|
|
//高压是否相同
|
|
CString sCmn;
|
|
bool bThis = false, bThat = false;
|
|
for (POSITION ps = arSHv.GetHeadPosition(); ps != NULL;)
|
|
{
|
|
sCmn = arSHv.GetNext(ps);
|
|
if (sSys1.Find(sCmn) != -1)
|
|
bThis = true;
|
|
|
|
if (sSysD.Find(sCmn) != -1)
|
|
bThat = true;
|
|
}
|
|
|
|
if (bThis && bThat)
|
|
return true;
|
|
|
|
//低压是否相同
|
|
bThis = false, bThat = false;
|
|
for (POSITION ps = arSLv.GetHeadPosition(); ps != NULL;)
|
|
{
|
|
sCmn = arSLv.GetNext(ps);
|
|
if (sSys1.Find(sCmn) != -1)
|
|
bThis = true;
|
|
|
|
if (sSysD.Find(sCmn) != -1)
|
|
bThat = true;
|
|
}
|
|
if (bThis && bThat)
|
|
return true;
|
|
|
|
//控制通讯
|
|
bThis = false, bThat = false;
|
|
for (POSITION ps = arKMSG.GetHeadPosition(); ps != NULL;)
|
|
{
|
|
sCmn = arKMSG.GetNext(ps);
|
|
if (sSys1.Find(sCmn) != -1)
|
|
bThis = true;
|
|
|
|
if (sSysD.Find(sCmn) != -1)
|
|
bThat = true;
|
|
}
|
|
|
|
if (bThis && bThat)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
//设置 加 减 填充率
|
|
bool AecDbECableTray::SendUserData(struct resbuf *pRb)
|
|
{
|
|
//解析 是 int-sys-double
|
|
if (pRb != NULL)
|
|
{
|
|
CString sSys;
|
|
double dD = 0;
|
|
int nAddOrSub = 1;
|
|
|
|
struct resbuf *pRb1 = pRb->rbnext;
|
|
struct resbuf *pRb2 = NULL;
|
|
if (pRb1 != NULL)
|
|
{
|
|
pRb2 = pRb1->rbnext;
|
|
}
|
|
|
|
bool bYs = false;
|
|
if (pRb1 != NULL && pRb2 != NULL)
|
|
{
|
|
if (pRb->restype == AcDb::kDxfXdInteger16)
|
|
{
|
|
nAddOrSub = pRb->resval.rint ? -1 : 1;
|
|
bYs = true;
|
|
}
|
|
else
|
|
{
|
|
bYs = false;
|
|
}
|
|
|
|
if (pRb1->restype == kDxfXdAsciiString)
|
|
{
|
|
sSys = pRb1->resval.rstring;
|
|
bYs = true;
|
|
}
|
|
else
|
|
{
|
|
bYs = false;
|
|
}
|
|
|
|
if (pRb2->restype == AcDb::kDxfReal)
|
|
{
|
|
dD = pRb2->resval.rreal;
|
|
bYs = true;
|
|
}
|
|
else
|
|
{
|
|
bYs = false;
|
|
}
|
|
|
|
if (bYs)
|
|
{
|
|
double dFillUsed = 0.0, dThisUsed = 0;
|
|
CString sSys2, sSysData = sSys;
|
|
double dSCab = 0.25 * PI * dD * dD;
|
|
|
|
struct resbuf rb;
|
|
acedGetVar(_T("INSUNITS"), &rb);
|
|
if (rb.resval.rint == AcDb::kUnitsMeters)
|
|
{
|
|
dSCab *= 1.e-6;
|
|
}
|
|
|
|
AecDbObjXDataMap *pDataMap = GetSpecialtyData(AcDb::kForWrite);
|
|
|
|
DlgData dlgData;
|
|
if (!GetDlgData(dlgData))
|
|
{
|
|
AecHvac::DuctParam param;
|
|
GetDuctParam(param);
|
|
|
|
if (param.m_bSpart)//有隔板
|
|
{
|
|
//隔板系统分类
|
|
//param.m_nSysSplit;
|
|
//判断
|
|
CString sSyss = param.szSys;
|
|
sSyss.TrimRight();
|
|
int nPos = sSyss.Find(_T('|'), 0);
|
|
if (nPos != -1)
|
|
{
|
|
sSys = sSyss.Mid(0, nPos);
|
|
if (nPos < sSyss.GetLength() - 1)
|
|
{
|
|
sSys2 = sSyss.Mid(nPos + 1);
|
|
}
|
|
|
|
if (IsSameAsSysUse(sSys, sSysData))
|
|
//if (sSysData.Find(sSys) != -1)//走左侧层
|
|
{
|
|
//...
|
|
dFillUsed = 0.0;
|
|
pDataMap->GetAt(KEY_FILLUSED, dFillUsed);//0.65
|
|
|
|
//面积 / 总面积 = 0.15
|
|
dThisUsed = dSCab;
|
|
dThisUsed /= (param.dSize[4]) * param.dSize[1];
|
|
|
|
//ext.累加 0.45 + 0.15
|
|
dFillUsed += dThisUsed * nAddOrSub;
|
|
pDataMap->SetAt(KEY_FILLUSED, dFillUsed);
|
|
}
|
|
//else if (sSysData.Find(sSys2) != -1)//走右侧层
|
|
else if (IsSameAsSysUse(sSys2, sSysData))
|
|
{
|
|
//...
|
|
dFillUsed = 0.0;
|
|
pDataMap->GetAt(KEY_FILLUSED2, dFillUsed);
|
|
|
|
//ext.面积 / 总面积 = 0.15
|
|
dThisUsed = dSCab;
|
|
dThisUsed /= (param.dSize[0] - param.dSize[4]) * param.dSize[1];
|
|
|
|
//ext.累加 0.45 + 0.15
|
|
dFillUsed += dThisUsed * nAddOrSub;
|
|
pDataMap->SetAt(KEY_FILLUSED2, dFillUsed);
|
|
}
|
|
else//都没有找到,走单层
|
|
{
|
|
//...
|
|
dFillUsed = 0.0;
|
|
pDataMap->GetAt(KEY_FILLUSED, dFillUsed);
|
|
|
|
//ext.面积 / 总面积 = 0.15
|
|
dThisUsed = dSCab;
|
|
dThisUsed /= param.dSize[0] * param.dSize[1];
|
|
|
|
//ext.累加 0.45 + 0.15
|
|
dFillUsed += dThisUsed * nAddOrSub;
|
|
pDataMap->SetAt(KEY_FILLUSED, dFillUsed);
|
|
}
|
|
}
|
|
else//有隔板,没有分层系统,走单层
|
|
{
|
|
dFillUsed = 0.0;
|
|
pDataMap->GetAt(KEY_FILLUSED, dFillUsed);
|
|
|
|
//ext.面积 / 总面积 = 0.15
|
|
dThisUsed = dSCab;
|
|
dThisUsed /= param.dSize[0] * param.dSize[1];
|
|
|
|
//ext.面积 / 总面积 = 0.15
|
|
dFillUsed += dThisUsed * nAddOrSub;
|
|
pDataMap->SetAt(KEY_FILLUSED, dFillUsed);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dFillUsed = 0.0;
|
|
pDataMap->GetAt(KEY_FILLUSED, dFillUsed);
|
|
|
|
//ext.面积 / 总面积 = 0.15
|
|
dThisUsed = dSCab;
|
|
dThisUsed /= param.dSize[0] * param.dSize[1];
|
|
|
|
//ext.面积 / 总面积 = 0.15
|
|
dFillUsed += dThisUsed * nAddOrSub;
|
|
pDataMap->SetAt(KEY_FILLUSED, dFillUsed);
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
EPosition AecDbECableTray::ExplainGripIndex(int nIndex) const
|
|
{
|
|
EPosition ePos = eStart;
|
|
switch(nIndex)
|
|
{
|
|
case 0:
|
|
{
|
|
ePos = eStart;
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
ePos = eMid;
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
ePos = eEnd;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
ePos = (EPosition)(eCommand0 + nIndex - 3);
|
|
break;
|
|
}
|
|
}
|
|
return ePos;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbECableTray::ImpGetGripPonts(AcGePoint3dArray& gripPoints,const int bitflags) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
const int nStbitflags = GRIPPT_RESP_FROM_EWFIT;
|
|
if (m_pBaseCurve != NULL)
|
|
{
|
|
AcGePoint3d ptSta,ptEnd;
|
|
m_pBaseCurve->getStartPoint(ptSta);
|
|
m_pBaseCurve->getEndPoint(ptEnd);
|
|
|
|
double dSta = 0.0,dEnd = 0.0;
|
|
m_pBaseCurve->getStartParam(dSta);
|
|
m_pBaseCurve->getEndParam(dEnd);
|
|
|
|
AcGeVector3d vtDir = ptEnd - ptSta;
|
|
vtDir.normalize();
|
|
|
|
AcGePoint3d ptMid;
|
|
m_pBaseCurve->getPointAtParam((dSta + dEnd) / 2.0,ptMid);
|
|
|
|
gripPoints.append(ptSta);
|
|
gripPoints.append(ptMid);
|
|
gripPoints.append(ptEnd);
|
|
|
|
if (bitflags == nStbitflags)
|
|
return Acad::eOk;
|
|
|
|
AcGeVector3d vtPerv = vtDir.perpVector();
|
|
AcGeVector3d vtNorm = vtDir.crossProduct(vtPerv);
|
|
vtNorm.normalize();
|
|
|
|
AcGePoint3d ptGe[4];
|
|
AcGeVector3d vtLine = ptEnd - ptSta;
|
|
vtLine.normalize();
|
|
|
|
AcGeVector3d vtVer = vtLine;
|
|
vtVer.normalize();
|
|
vtVer.rotateBy(PI / 2.0,vtNorm);
|
|
|
|
//增加三个命令夹点
|
|
AcGePoint3d ptCmd[3]; //Cmd 0,1
|
|
vtLine.normalize();
|
|
|
|
//按 15 个像素点
|
|
double dCmd = PixelToWcs(15);
|
|
|
|
if (vtLine.isParallelTo(AcGeVector3d::kZAxis))//立管
|
|
{
|
|
vtLine = AcGeVector3d::kXAxis;
|
|
|
|
ptCmd[0] = ptSta - dCmd * vtLine;
|
|
ptCmd[1] = ptEnd + dCmd * vtLine;
|
|
ptCmd[2] = ptMid + dCmd * AcGeVector3d::kYAxis;
|
|
}
|
|
else
|
|
{
|
|
ptCmd[0] = ptSta - dCmd * vtLine;
|
|
ptCmd[1] = ptEnd + dCmd * vtLine;
|
|
ptCmd[2] = ptMid + dCmd * vtVer;
|
|
}
|
|
|
|
gripPoints.append(ptCmd[0]);
|
|
gripPoints.append(ptCmd[1]);
|
|
gripPoints.append(ptCmd[2]);
|
|
|
|
//后面的是断管符号
|
|
//断管符号
|
|
AcGePoint3d ptGeBK,ptGeT;
|
|
CString sIndex;
|
|
for(int i = 0;i < PIPE_BROKENNUM;i++)
|
|
{
|
|
sIndex.Format(_T("BKOP%d"),i);
|
|
if (m_mapSpecXData.GetAt(sIndex,ptGeBK))
|
|
{
|
|
//开始
|
|
ptGeT = ptSta + vtDir * ptGeBK.x;
|
|
gripPoints.append(ptGeT);
|
|
|
|
//中间
|
|
ptGeT += vtDir * ptGeBK.y * 0.5;
|
|
gripPoints.append(ptGeT);
|
|
|
|
//结束
|
|
ptGeT += vtDir * ptGeBK.y * 0.5;
|
|
gripPoints.append(ptGeT);
|
|
}
|
|
}
|
|
|
|
//用户接口
|
|
for (int i = 0;i < m_arUserInfs.length();i++)
|
|
{
|
|
const AecUserInterface &infu = m_arUserInfs.at(i);
|
|
if (infu.nPoints == 2)
|
|
{
|
|
gripPoints.append(infu.ptGe[0] + infu.vtDir);
|
|
}
|
|
else if (infu.nPoints == 4)//目前只支持矩形
|
|
{
|
|
gripPoints.append( Mid(infu.ptGe[0], infu.ptGe[2]) + infu.vtDir);
|
|
}
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbECableTray::subGetGripPoints(AcDbGripDataPtrArray& grips,
|
|
const double curViewUnitSize,
|
|
const int gripSize,
|
|
const AcGeVector3d& curViewDir,
|
|
const int bitflags) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
if (m_pBaseCurve != NULL)
|
|
{
|
|
AcGePoint3dArray gripPoints;
|
|
ImpGetGripPonts(gripPoints,bitflags);
|
|
|
|
int nColor = kWhite;
|
|
AcDbGripData* pGripData = NULL;
|
|
if ( bitflags >= 1394)
|
|
{
|
|
memset(&m_pGripAppData[0],0,sizeof(AecGripData));
|
|
m_pGripAppData[0].nIndex = 0;
|
|
m_pGripAppData[0].ePos = eFlag;
|
|
m_pGripAppData[0].nColor = nColor;
|
|
m_pGripAppData[0].ptGrip = gripPoints.at(0);
|
|
m_pGripAppData[0].pOwner = (AcDbEntity*)this;
|
|
|
|
pGripData = new AcDbGripData;
|
|
pGripData->setGripPoint(gripPoints.at(0));
|
|
pGripData->setAppData((void*)&m_pGripAppData[0]);
|
|
pGripData->setWorldDraw(AecGripCback::WorldDrawfunc);
|
|
pGripData->setToolTipFunc(AecGripCback::GripToolTipFunc);
|
|
_tcscpy(m_pGripAppData[0].szTip,_T("点击定位造族<桥架>记录"));
|
|
_tcscpy(m_pGripAppData[0].szID,m_sGUID);
|
|
grips.append(pGripData);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
CString sCmd = _T("EW_HZFG");//绘制管道
|
|
EPosition ePos;
|
|
for (int i = 0;i < GRIP_MAXNUM && i < gripPoints.length();i++)
|
|
{
|
|
ePos = ExplainGripIndex(i);
|
|
if (ePos >= eCommand0 && ePos <= eCommand19)
|
|
{
|
|
memset(&m_pGripAppData[i],0,sizeof(AecGripData));
|
|
m_pGripAppData[i].nIndex = i;
|
|
m_pGripAppData[i].ePos = ePos;
|
|
m_pGripAppData[i].nColor = nColor;
|
|
m_pGripAppData[i].ptGrip = gripPoints.at(i);
|
|
_tcscpy(m_pGripAppData[i].szTip,sCmd);
|
|
_tcscpy(m_pGripAppData[i].szID,m_sGUID);
|
|
m_pGripAppData[i].pOwner = (AcDbEntity*)this;
|
|
m_pGripAppData[i].idHost = this->objectId();
|
|
|
|
pGripData = new AcDbGripData;
|
|
pGripData->setGripPoint(gripPoints.at(i));
|
|
pGripData->setAppData((void*)&m_pGripAppData[i]);
|
|
pGripData->setWorldDraw(AecGripCback::WorldDrawfunc);
|
|
pGripData->setToolTipFunc(AecGripCback::GripToolTipFunc);
|
|
}
|
|
else
|
|
{
|
|
memset(&m_pGripAppData[i],0,sizeof(AecGripData));
|
|
m_pGripAppData[i].nIndex = i;
|
|
m_pGripAppData[i].ePos = ePos;
|
|
m_pGripAppData[i].nColor = nColor;
|
|
m_pGripAppData[i].ptGrip = gripPoints.at(i);
|
|
_tcscpy(m_pGripAppData[i].szTip,_T("桥架拉伸夹点"));
|
|
_tcscpy(m_pGripAppData[i].szID,m_sGUID);
|
|
m_pGripAppData[i].pOwner = (AcDbEntity*)this;
|
|
m_pGripAppData[i].idHost = this->objectId();
|
|
|
|
pGripData = new AcDbGripData;
|
|
pGripData->setGripPoint(gripPoints.at(i));
|
|
pGripData->setAppData((void*)&m_pGripAppData[i]);
|
|
pGripData->setWorldDraw(AecGripCback::WorldDrawfunc);
|
|
pGripData->setToolTipFunc(AecGripCback::GripToolTipFunc);
|
|
}
|
|
grips.append(pGripData);
|
|
}
|
|
|
|
//调用基类加入单击修改
|
|
SubAddHitEditGrip(grips);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbECableTray::subMoveGripPointsAt(const AcDbVoidPtrArray& gripAppData, const AcGeVector3d& offset, const int bitflags)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
AecGripData* pAppData = NULL;
|
|
AcDbIntArray arIndex;
|
|
|
|
if (HitOnGripEdit(gripAppData))
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
if ( !gripAppData.isEmpty() )
|
|
{
|
|
pAppData = (AecGripData*)gripAppData.first();
|
|
arIndex.append(pAppData->nIndex);
|
|
}
|
|
else
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
int nGripIndex = arIndex.first();
|
|
EPosition ePos = ExplainGripIndex(nGripIndex);
|
|
|
|
bool bMsgSendToAllInfs = false;
|
|
AcGeVector3d vtOffset = offset;
|
|
if(Is2DView())//如果是2D视图
|
|
{
|
|
//投影到XY
|
|
vtOffset = offset.orthoProject(GetUcsZvt());
|
|
|
|
AcDbLine* pLn = AcDbLine::cast(m_pBaseCurve);
|
|
if (pLn != NULL)
|
|
{
|
|
//小于10度的按照投影处理
|
|
//在夹角小于10度，认为是橡皮筋拉伸
|
|
AcGeVector3d vtLn = pLn->endPoint() - pLn->startPoint();
|
|
if (ePos == eStart || ePos == eEnd)
|
|
{
|
|
double dAngle = vtOffset.angleTo(vtLn);
|
|
dAngle *= 180.0 / PI;
|
|
//acutPrintf(_T("\nAngle = %g"),dAngle);
|
|
if ( ( (dAngle - 10.0 ) < 1.e-6 ) ||
|
|
( (180.0 - dAngle - 10.0 ) < 1.e-6) )
|
|
{
|
|
//认为是橡皮筋拉伸
|
|
AcGeVector3d vtNorm = vtLn;
|
|
vtNorm.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
|
|
|
|
AcGeVector3d vtOffsetOnLn = vtOffset.orthoProject(vtNorm);
|
|
vtOffsetOnLn.normalize();
|
|
vtOffsetOnLn *= vtOffset.length();
|
|
vtOffset = vtOffsetOnLn;
|
|
|
|
//仅仅本端口
|
|
bMsgSendToAllInfs = false;
|
|
}
|
|
else
|
|
{
|
|
bMsgSendToAllInfs = true;
|
|
}
|
|
}
|
|
else if (ePos == eMid)
|
|
{
|
|
AcGeVector3d vtNorm = vtLn;
|
|
vtLn.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
|
|
|
|
double dAngle = vtOffset.angleTo(vtLn);
|
|
dAngle *= 180.0 / PI;
|
|
|
|
//acutPrintf(_T("\nAngle = %g"),dAngle);
|
|
if ( ( (dAngle - 10.0 ) < 1.e-6 ) ||
|
|
( (180.0 - dAngle - 10.0 ) < 1.e-6) )
|
|
{
|
|
//认为是橡皮筋拉伸
|
|
AcGeVector3d vtOffsetOnLn = vtOffset.orthoProject(vtNorm);
|
|
vtOffsetOnLn.normalize();
|
|
vtOffsetOnLn *= vtOffset.length();
|
|
vtOffset = vtOffsetOnLn;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
AcGeMatrix3d xformM;
|
|
xformM.setToTranslation(vtOffset);
|
|
|
|
AcGePoint3dArray arBkPts;
|
|
GetBrokenOpenPnts(arBkPts);
|
|
int nBrok = arBkPts.length();
|
|
if (nGripIndex > 5 && nGripIndex < 5 + nBrok) //断管符号移动
|
|
{
|
|
nGripIndex -= 6;
|
|
return moveGripBrokenOpen(nGripIndex,offset);
|
|
}
|
|
|
|
GripMessage msg;
|
|
memset(&msg,0,sizeof(GripMessage));
|
|
//reset
|
|
msg.nSegindex = -1;
|
|
msg.nType = -1;
|
|
msg.idHost.setNull();
|
|
msg.pParam = 0;
|
|
msg.nData = -1;
|
|
_tcscpy(msg.szLockId, _T("0"));//锁定id,如果有
|
|
msg.fData = 0;
|
|
msg.nSegindex = 0;
|
|
msg.nSubSegIndex = 0;
|
|
msg.vtOffset.set(0,0,0);
|
|
msg.ptGrip.set(0,0,0);
|
|
|
|
AecInterface inf;
|
|
switch (ePos)
|
|
{
|
|
case eStart:
|
|
{
|
|
TransformAssocInf(0,xformM);
|
|
|
|
msg.nType = ePos;
|
|
msg.nData = bMsgSendToAllInfs ? -1 : 0;//控制消息源
|
|
msg.idHost = pAppData->idHost;
|
|
msg.vtOffset = vtOffset;
|
|
|
|
PushGripMessage(msg);
|
|
|
|
break;
|
|
}
|
|
case eEnd:
|
|
{
|
|
TransformAssocInf(1,xformM);
|
|
|
|
msg.nType = ePos;
|
|
msg.nData = bMsgSendToAllInfs ? -1 : 1;//控制消息源
|
|
msg.idHost = pAppData->idHost;
|
|
msg.vtOffset = vtOffset;
|
|
|
|
PushGripMessage(msg);
|
|
|
|
break;
|
|
}
|
|
case eMid:
|
|
{
|
|
TransformBy(xformM);
|
|
|
|
msg.nType = ePos;
|
|
msg.nData = -1;
|
|
msg.idHost = pAppData->idHost;
|
|
msg.vtOffset = vtOffset;
|
|
|
|
PushGripMessage(msg);
|
|
|
|
break;
|
|
}
|
|
case eCommand0:
|
|
{
|
|
msg.nType = eCommand0;
|
|
msg.nData = 0;
|
|
GetInterface(msg.nData,inf);
|
|
msg.ptGrip = inf.ptPos;
|
|
msg.idHost = pAppData->idHost;
|
|
msg.vtOffset = vtOffset;
|
|
|
|
PushGripMessage(msg);
|
|
|
|
CString sCmd = GetGripCmd();
|
|
if (!sCmd.IsEmpty())
|
|
{
|
|
acedPostCommand(_T("\x03"));
|
|
sCmd += _T("\n");
|
|
acedPostCommand(sCmd);
|
|
}
|
|
break;
|
|
}
|
|
case eCommand1:
|
|
{
|
|
msg.nType = eCommand1;
|
|
msg.nData = 1;
|
|
GetInterface(msg.nData,inf);
|
|
msg.ptGrip = inf.ptPos;
|
|
msg.idHost = pAppData->idHost;
|
|
msg.vtOffset = vtOffset;
|
|
|
|
PushGripMessage(msg);
|
|
|
|
CString sCmd = GetGripCmd();
|
|
if (!sCmd.IsEmpty())
|
|
{
|
|
acedPostCommand(_T("\x03"));
|
|
sCmd += _T("\n");
|
|
acedPostCommand(sCmd);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
msg.nType = eCommand0;
|
|
msg.nData = 0;//按0接口
|
|
msg.ptGrip = pAppData->ptGrip;
|
|
msg.idHost = pAppData->idHost;
|
|
msg.vtOffset = vtOffset;
|
|
|
|
PushGripMessage(msg);
|
|
|
|
CString sCmd = GetGripCmd();
|
|
if (!sCmd.IsEmpty())
|
|
{
|
|
acedPostCommand(_T("\x03"));
|
|
sCmd += _T("\n");
|
|
acedPostCommand(sCmd);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbECableTray::moveGripBrokenOpen(int nBrokenGrip,const AcGeVector3d& offset)
|
|
{
|
|
AssertWriteEnabled();
|
|
AcGePoint3d ptSta = StartPoint();
|
|
AcGePoint3d ptEnd = EndPoint();
|
|
AcDbLine ln(ptSta,ptEnd);
|
|
|
|
AcGeVector3d vtDir = ptEnd - ptSta;
|
|
vtDir.normalize();
|
|
|
|
int nBrokenindex = nBrokenGrip / 3;
|
|
int nBrokenHit = nBrokenGrip % 3;
|
|
|
|
//断管符号
|
|
double dLen;
|
|
AcGePoint3d ptGeT,ptGeBK,ptGe1,ptGe2,ptGe3;
|
|
AcGePoint3dArray arPoints;
|
|
CString sIndex;
|
|
|
|
for(int i = 0;i < PIPE_BROKENNUM;i++)
|
|
{
|
|
sIndex.Format(_T("BKOP%d"),i);
|
|
if (m_mapSpecXData.GetAt(sIndex,ptGeBK))
|
|
{
|
|
if (nBrokenindex == i)
|
|
{
|
|
//开始
|
|
ptGe1 = ptSta + vtDir * ptGeBK.x;
|
|
|
|
//中间
|
|
ptGe2 = ptGe1 + vtDir * ptGeBK.y * 0.5;
|
|
|
|
//结束
|
|
ptGe3 = ptGe2 + vtDir * ptGeBK.y * 0.5;
|
|
|
|
switch(nBrokenHit)
|
|
{
|
|
case 0: //改长度和断开长度
|
|
{
|
|
ptGe1 += offset;
|
|
ln.getClosestPointTo(ptGe1,ptGe1);
|
|
|
|
ptGeBK.x = ptGe1.distanceTo(ptSta);
|
|
if (ptGeBK.x - ptSta.distanceTo(ptEnd) > 1.e-10)
|
|
{
|
|
//超出算删除
|
|
m_mapSpecXData.RemoveAt(sIndex);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
ptGeBK.y = ptGe3.distanceTo(ptGe1);
|
|
m_mapSpecXData.SetAt(sIndex,ptGeBK);
|
|
|
|
break;
|
|
}
|
|
case 1: // 改长度
|
|
{
|
|
ptGe1 += offset;
|
|
ln.getClosestPointTo(ptGe1,ptGe1);
|
|
|
|
dLen = ptGe3.distanceTo(ptSta);
|
|
if (dLen - ptSta.distanceTo(ptEnd) > 1.e-10)
|
|
{
|
|
//超出算删除
|
|
m_mapSpecXData.RemoveAt(sIndex);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
ptGeBK.x = ptGe1.distanceTo(ptSta);
|
|
m_mapSpecXData.SetAt(sIndex,ptGeBK);
|
|
break;
|
|
}
|
|
case 2://改断开长度
|
|
{
|
|
ptGe3 += offset;
|
|
ln.getClosestPointTo(ptGe3,ptGe3);
|
|
|
|
dLen = ptGe3.distanceTo(ptSta);
|
|
if (dLen - ptSta.distanceTo(ptEnd) > 1.e-10)
|
|
{
|
|
//超出算删除
|
|
m_mapSpecXData.RemoveAt(sIndex);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
dLen = ptGe3.distanceTo(ptGe1);
|
|
ptGeBK.y = dLen;
|
|
m_mapSpecXData.SetAt(sIndex,ptGeBK);
|
|
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
void AecDbECableTray::GetGripText(int nPos, CString& sText)
|
|
{
|
|
sText = _T("夹点");
|
|
}
|
|
|
|
#endif
|
|
|
|
Acad::ErrorStatus AecDbECableTray::ShowUsedFill(AcGiDraw &dc) const
|
|
{
|
|
//显示已用填充率
|
|
struct resbuf rb;
|
|
rb.resval.rint = 0;
|
|
acedGetVar(_T("useri3"), &rb);
|
|
if (rb.resval.rint == 1395)
|
|
{
|
|
CString sFill, sFill2, sText;
|
|
//显示填充率
|
|
double dFillUsed1 = 0.0;
|
|
m_mapSpecXData.GetAt(KEY_FILLUSED, dFillUsed1);//0.65
|
|
if (dFillUsed1 > 0.001)
|
|
{
|
|
sFill.Format(_T("已用填充率=%d%%"), (int)(dFillUsed1 * 100));
|
|
}
|
|
|
|
double dFillUsed2 = 0.0;
|
|
m_mapSpecXData.GetAt(KEY_FILLUSED2, dFillUsed2);
|
|
if (dFillUsed2 > 0.001)
|
|
{
|
|
sFill2.Format(_T("已用填充率2=%d%%"), (int)(dFillUsed2 * 100));
|
|
}
|
|
sText = sFill + sFill2;
|
|
if (!sText.IsEmpty())
|
|
{
|
|
AcGePoint3d pt1 = StartPoint();
|
|
AcGePoint3d pt2 = EndPoint();
|
|
AcGePoint3d pt3;
|
|
Midpoint(pt1, pt2, pt3);
|
|
double dH = 2.5;
|
|
m_mapSpecXData.GetAt(KEY_SIZE1, dH);
|
|
dH *= 0.25;
|
|
dc.DrawTextFit(sText, pt3, pt2, dH, _T("Standard"));
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
BOOL DLLIMPEXP GetDocScale(double &dPScale);
|
|
Acad::ErrorStatus AecDbECableTray::Draw2d(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus es = AecDbEwPipeBase::Draw2d(dc);
|
|
|
|
ShowUsedFill(dc);
|
|
|
|
return es;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbECableTray::DrawUserInf(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcGePoint3d ptGe[16], ptGe1, ptGe2, ptS, ptE;
|
|
for (int i = 0; i < m_arUserInfs.length(); i++)
|
|
{
|
|
const AecUserInterface &inf = m_arUserInfs.at(i);
|
|
|
|
if (inf.nPoints == 2)
|
|
{
|
|
AcDbCircle *pCir = new AcDbCircle;
|
|
pCir->setCenter(inf.ptGe[0]);
|
|
pCir->setNormal(inf.vtDir);
|
|
pCir->setRadius(inf.ptGe[1].distanceTo(inf.ptGe[0]));
|
|
pCir->setLayer(layerId());
|
|
|
|
if (inf.vtDir.isParallelTo(AcGeVector3d::kZAxis))
|
|
{
|
|
dc.DrawEntity(pCir);
|
|
Add2DBuffer(pCir);
|
|
}
|
|
else
|
|
{
|
|
AcDbCurve *pCurve = NULL;
|
|
pCir->getOrthoProjectedCurve(AcGePlane::kXYPlane, pCurve);
|
|
if (pCurve != NULL)
|
|
{
|
|
dc.DrawEntity(pCurve);
|
|
Add2DBuffer(pCurve);
|
|
|
|
pCurve->getStartPoint(ptS);
|
|
pCurve->getEndPoint(ptE);
|
|
|
|
AcDbLine *pLn = NULL;
|
|
|
|
ptGe1 = ptS + inf.vtDir;
|
|
pLn = new AcDbLine(ptS, ptGe1);
|
|
pLn->setLayer(layerId());
|
|
dc.DrawEntity(pLn);
|
|
Add2DBuffer(pLn);
|
|
|
|
ptGe2 = ptE + inf.vtDir;
|
|
pLn = new AcDbLine(ptE, ptGe2);
|
|
pLn->setLayer(layerId());
|
|
dc.DrawEntity(pLn);
|
|
Add2DBuffer(pLn);
|
|
|
|
pLn = new AcDbLine(ptGe1, ptGe2);
|
|
pLn->setLayer(layerId());
|
|
dc.DrawEntity(pLn);
|
|
Add2DBuffer(pLn);
|
|
}
|
|
delete pCir;
|
|
}
|
|
}
|
|
else if (inf.nPoints > 2)
|
|
{
|
|
//投影到XY
|
|
AcGePoint3dArray arPts, arPts2;
|
|
for (int j = 0; j < inf.nPoints; j++)
|
|
{
|
|
ptGe[j] = inf.ptGe[j].orthoProject(AcGePlane::kXYPlane);
|
|
if (arPts.find(ptGe[j]) == -1)
|
|
arPts.append(ptGe[j]);
|
|
}
|
|
|
|
AcDbLine *pLn = NULL;
|
|
if (!inf.vtDir.isParallelTo(AcGeVector3d::kZAxis))
|
|
{
|
|
for (int j = 0; j < arPts.length(); j++)
|
|
{
|
|
ptGe2 = arPts.at(j) + inf.vtDir;
|
|
arPts2.append(ptGe2);
|
|
pLn = new AcDbLine(arPts.at(j), ptGe2);
|
|
pLn->setLayer(layerId());
|
|
dc.DrawEntity(pLn);
|
|
Add2DBuffer(pLn);
|
|
}
|
|
|
|
for (int j = 0; j < arPts2.length() - 1; j++)
|
|
{
|
|
pLn = new AcDbLine(arPts2.at(j), arPts2.at(j + 1));
|
|
pLn->setLayer(layerId());
|
|
dc.DrawEntity(pLn);
|
|
Add2DBuffer(pLn);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
arPts.removeAll();
|
|
for (int j = 0; j < inf.nPoints; j++)
|
|
{
|
|
ptGe[j] = inf.ptGe[j].orthoProject(AcGePlane::kXYPlane);
|
|
|
|
if (arPts.length() > 0)
|
|
{
|
|
pLn = new AcDbLine(arPts.last(), ptGe[j]);
|
|
pLn->setLayer(layerId());
|
|
dc.DrawEntity(pLn);
|
|
Add2DBuffer(pLn);
|
|
}
|
|
arPts.append(ptGe[j]);
|
|
|
|
if (j == inf.nPoints - 1)
|
|
{
|
|
pLn = new AcDbLine(arPts.first(), ptGe[j]);
|
|
pLn->setLayer(layerId());
|
|
dc.DrawEntity(pLn);
|
|
Add2DBuffer(pLn);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbECableTray::Draw3d(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
int nApp = WPipe::eBridge;
|
|
m_mapSpecXData.GetAt(KEY_APP, nApp);
|
|
WPipe::EApp eApp = (WPipe::EApp)nApp;
|
|
|
|
switch (eApp)
|
|
{
|
|
case WPipe::eBridge:
|
|
{
|
|
DrawBridge(dc);
|
|
break;
|
|
}
|
|
case WPipe::eTrench:
|
|
{
|
|
DrawTrech3D(dc);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
AcDbRegion *CreateRegion(const AcGePoint3d* pptGe,int nPoints, const AcGeVector3d& vtNorm,double dt)
|
|
{
|
|
AcDbVoidPtrArray arOutPl, arRegOuts;
|
|
AcDbVoidPtrArray arInPl, arRegIns;
|
|
|
|
if (nPoints == 2)
|
|
{
|
|
double dR = pptGe[1].distanceTo(pptGe[0]);
|
|
|
|
AcDbCircle *pCirIn = new AcDbCircle;
|
|
pCirIn->setCenter(pptGe[0]);
|
|
pCirIn->setNormal(vtNorm);
|
|
pCirIn->setRadius(dR);
|
|
|
|
AcDbCircle *pCirOut = new AcDbCircle;
|
|
pCirOut->setCenter(pptGe[0]);
|
|
pCirOut->setNormal(vtNorm);
|
|
pCirOut->setRadius(dR + dt);
|
|
|
|
arOutPl.append(pCirOut);
|
|
AcDbRegion::createFromCurves(arOutPl, arRegOuts);
|
|
|
|
arInPl.append(pCirIn);
|
|
AcDbRegion::createFromCurves(arInPl, arRegIns);
|
|
|
|
delete pCirOut;
|
|
delete pCirIn;
|
|
}
|
|
else if (nPoints >= 3)
|
|
{
|
|
AcDbPolyline *pPl = Format3dPolyline(pptGe, nPoints, vtNorm);
|
|
|
|
AcDbPolyline *pPlIn = NULL;
|
|
if (pPl != NULL && dt > 1.e-1)
|
|
{
|
|
pPl->setClosed(Adesk::kTrue);
|
|
pPlIn = (AcDbPolyline *)GetMinOffsetCurve(pPl, dt);
|
|
if (pPlIn != NULL)
|
|
{
|
|
arOutPl.append(pPl);
|
|
AcDbRegion::createFromCurves(arOutPl, arRegOuts);
|
|
|
|
arInPl.append(pPlIn);
|
|
AcDbRegion::createFromCurves(arInPl, arRegIns);
|
|
|
|
delete pPlIn;
|
|
delete pPl;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pPl->setClosed(Adesk::kTrue);
|
|
|
|
arOutPl.append(pPl);
|
|
AcDbRegion::createFromCurves(arOutPl, arRegOuts);
|
|
}
|
|
}
|
|
|
|
if (!arRegOuts.isEmpty() && !arRegIns.isEmpty())
|
|
{
|
|
AcDbRegion *pRegOut = (AcDbRegion *)arRegOuts.first();
|
|
AcDbRegion *pRegIn = (AcDbRegion *)arRegIns.first();
|
|
|
|
if (pRegOut != NULL && pRegIn != NULL)
|
|
{
|
|
if (Acad::eOk == pRegOut->booleanOper(AcDb::kBoolSubtract, pRegIn))
|
|
{
|
|
return pRegOut;
|
|
}
|
|
}
|
|
}
|
|
else if (!arRegOuts.isEmpty())
|
|
{
|
|
AcDbRegion *pRegOut = (AcDbRegion *)arRegOuts.first();
|
|
return pRegOut;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbECableTray::DrawUserInf3d(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcCmTransparency tr = transparency();
|
|
|
|
double dt = 0.0;
|
|
m_mapSpecXData.GetAt(PIPE_THICK, dt);
|
|
|
|
AcDbLine lnPath;
|
|
AcDbRegion *pRegion = NULL;
|
|
for (int i = 0; i < m_arUserInfs.length(); i++)
|
|
{
|
|
const AecUserInterface &inf = m_arUserInfs.at(i);
|
|
|
|
lnPath.setStartPoint(inf.ptGe[0]);
|
|
lnPath.setEndPoint(inf.ptGe[0] + inf.vtDir);
|
|
|
|
AecDbX3dPart part;
|
|
if (inf.nPoints >= 3) //多边形
|
|
{
|
|
pRegion = CreateRegion(inf.ptGe,inf.nPoints,inf.vtDir,dt);
|
|
if (pRegion != NULL)
|
|
{
|
|
AcDbX3dSolid *pX3dSolidTop = new AcDbX3dSolid;
|
|
pX3dSolidTop->CreateExtrude(pRegion, lnPath);
|
|
part.AddX3dSolid(pX3dSolidTop);
|
|
}
|
|
}
|
|
else if (inf.nPoints == 2)//圆
|
|
{
|
|
pRegion = CreateRegion(inf.ptGe,inf.nPoints,inf.vtDir,dt);
|
|
if (pRegion != NULL)
|
|
{
|
|
AcDbX3dSolid *pX3dSolidTop = new AcDbX3dSolid;
|
|
pX3dSolidTop->CreateExtrude(pRegion, lnPath);
|
|
part.AddX3dSolid(pX3dSolidTop);
|
|
}
|
|
}
|
|
|
|
part.Create();
|
|
AcDb3dSolid *pSolid = part.CreateDraw3dSolid();
|
|
if (pSolid != NULL)
|
|
{
|
|
pSolid->setTransparency(tr);
|
|
dc.DrawEntity(pSolid);
|
|
Add3DBuffer(pSolid);
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbECableTray::DrawBridge(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
Acad::ErrorStatus es = AecDbEwPipeBase::Draw3d(dc);
|
|
|
|
FreeBuffer(0, m_arDrawBuffer3d2);
|
|
|
|
AcGePoint3d ptSta = StartPoint();
|
|
AcGePoint3d ptEnd = EndPoint();
|
|
|
|
AcGeVector3d vtDir = EndPoint() - StartPoint();
|
|
vtDir.normalize();
|
|
|
|
Adesk::Int16 nCr = dc.GetColor();
|
|
|
|
if (IsActive())
|
|
{
|
|
AcDbEntity *p3dEnt = NULL;
|
|
double dOD = 0.0;
|
|
if (m_mapSpecXData.GetAt(KEY_SIZE1, dOD))
|
|
{
|
|
dc.SetColor(kMagenta);
|
|
p3dEnt = dc.DrawPipe(ptSta, ptEnd, 0.5 * dOD, 0.0);
|
|
if (p3dEnt != NULL)
|
|
{
|
|
DrawSubAxis(dc, p3dEnt);
|
|
m_arDrawBuffer3d2.append(p3dEnt);
|
|
}
|
|
}
|
|
}
|
|
|
|
AcGePoint3d ptGeFr, ptGeTo;
|
|
if (m_bShowFlowDir)//流向
|
|
{
|
|
dc.SetColor(kMagenta);//kMagenta
|
|
|
|
vtDir.normalize();
|
|
vtDir *= PixelToWcs(30);
|
|
|
|
//clinder
|
|
ptGeFr = Mid(ptSta, ptEnd);
|
|
ptGeTo = ptGeFr + vtDir;
|
|
|
|
double dDn = 0.0;
|
|
m_mapSpecXData.GetAt(KEY_SIZE1, dDn);
|
|
|
|
ptGeFr.z += 1.1 * dDn;
|
|
ptGeTo.z += 1.1 * dDn;
|
|
AcDbEntity *p3d = dc.DrawCone(ptGeFr, PixelToWcs(1), ptGeTo, PixelToWcs(1));
|
|
if (p3d != NULL)
|
|
{
|
|
m_arDrawBuffer3d2.append(p3d);
|
|
}
|
|
|
|
//arrow
|
|
ptGeFr = ptGeTo;
|
|
vtDir.normalize();
|
|
ptGeTo += vtDir * PixelToWcs(15);
|
|
p3d = dc.DrawCone(ptGeFr, PixelToWcs(5), ptGeTo, 1.e-3);
|
|
if (p3d != NULL)
|
|
{
|
|
m_arDrawBuffer3d2.append(p3d);
|
|
}
|
|
}
|
|
dc.SetColor(nCr);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
bool FormatRect(AcGePoint3d *pptGe, double dw, double dt)
|
|
{
|
|
pptGe[0].set(0, 0, 0);
|
|
pptGe[0].x -= dw;
|
|
pptGe[0].y += 0.5 * dt;
|
|
|
|
pptGe[1] = pptGe[0];
|
|
pptGe[1].x += dw;
|
|
|
|
pptGe[2] = pptGe[1];
|
|
pptGe[2].y -= dt;
|
|
|
|
pptGe[3] = pptGe[0];
|
|
pptGe[3].y -= dt;
|
|
|
|
pptGe[4] = pptGe[0];
|
|
|
|
return true;
|
|
}
|
|
|
|
extern AcDbRegion *CreatePolygonRegionOnly(AcGePoint3d *pPoints, int nSize);
|
|
bool AecDbECableTray::GetDlgRegionData(DlgData &data, AcArray<RegionAndEl> &arRegEl) const
|
|
{
|
|
AcDbRegion *pRegion = NULL;
|
|
|
|
//原始位置为原点
|
|
//底板
|
|
AcDbVoidPtrArray arLnPtrs;
|
|
RegionAndEl rel;
|
|
rel.pReg = NULL;
|
|
_tcscpy(rel.m_szMat, _T("混凝土"));
|
|
|
|
AcGePoint3d ptGe[5];
|
|
|
|
FormatRect(ptGe, data.m_dd, data.m_db);
|
|
|
|
pRegion = CreatePolygonRegionOnly(ptGe, 5);
|
|
if (pRegion == NULL)
|
|
{
|
|
return false;
|
|
}
|
|
rel.m_dZ = data.m_dTopEl;
|
|
rel.m_dZ -= data.m_dk;
|
|
rel.m_dZ -= data.m_dH;
|
|
rel.m_dZ -= 0.5 * data.m_db;
|
|
rel.pReg = pRegion;
|
|
rel.nType = 1;//板
|
|
rel.m_dX = 0.0;//偏移
|
|
rel.dSize[0] = data.m_dd;
|
|
rel.dSize[1] = data.m_db;
|
|
rel.dSize[2] = 0.0;
|
|
arRegEl.append(rel);
|
|
|
|
//侧面墙体
|
|
FormatRect(ptGe, data.m_dt, (data.m_dH - data.m_dh2));
|
|
pRegion = CreatePolygonRegionOnly(ptGe, 5);
|
|
if (pRegion == NULL)
|
|
{
|
|
return false;
|
|
}
|
|
_tcscpy(rel.m_szMat, _T("砌砖墙体"));
|
|
rel.m_dZ = data.m_dTopEl;
|
|
rel.m_dZ -= data.m_dk;
|
|
rel.m_dZ -= data.m_dh2;
|
|
rel.m_dZ -= 0.5 * (data.m_dH - data.m_dh2);
|
|
rel.m_dX = 0.0;
|
|
rel.m_dX -= 0.5 * data.m_dW;
|
|
rel.m_dX -= 0.5 * data.m_dt;
|
|
rel.pReg = pRegion;
|
|
rel.nType = 2;//墙
|
|
|
|
rel.dSize[0] = data.m_dt;
|
|
rel.dSize[1] = (data.m_dH - data.m_dh2);
|
|
rel.dSize[2] = 0.0;
|
|
|
|
arRegEl.append(rel);
|
|
|
|
//侧面墙体2
|
|
rel.m_dX += (data.m_dW + data.m_dt);
|
|
rel.pReg = (AcDbRegion *)pRegion->clone();
|
|
arRegEl.append(rel);
|
|
|
|
//压顶
|
|
FormatRect(ptGe, data.m_dt, data.m_dh2);
|
|
pRegion = CreatePolygonRegionOnly(ptGe, 5);
|
|
if (pRegion == NULL)
|
|
{
|
|
return false;
|
|
}
|
|
_tcscpy(rel.m_szMat, _T("混凝土"));
|
|
rel.m_dZ = data.m_dTopEl;
|
|
rel.m_dZ -= data.m_dk;
|
|
rel.m_dZ -= 0.5 * data.m_dh2;
|
|
rel.pReg = pRegion;
|
|
rel.nType = 2;
|
|
rel.m_dX = 0.0;
|
|
rel.m_dX -= 0.5 * data.m_dW;
|
|
rel.m_dX -= 0.5 * data.m_dt;
|
|
|
|
rel.dSize[0] = data.m_dt;
|
|
rel.dSize[1] = data.m_dh2;
|
|
rel.dSize[2] = 0.0;
|
|
|
|
arRegEl.append(rel);
|
|
|
|
rel.m_dX += (data.m_dW + data.m_dt);
|
|
rel.pReg = (AcDbRegion *)pRegion->clone();
|
|
arRegEl.append(rel);
|
|
|
|
//盖板
|
|
if (data.m_bHasCover)
|
|
{
|
|
FormatRect(ptGe, data.m_dW + 2.0 * data.m_dt, data.m_dk);
|
|
pRegion = CreatePolygonRegionOnly(ptGe, 5);
|
|
if (pRegion == NULL)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
_tcscpy(rel.m_szMat, _T("钢筋混凝土盖板"));
|
|
rel.m_dZ = data.m_dTopEl;
|
|
rel.m_dZ -= 0.5 * data.m_dk;
|
|
rel.m_dX = 0.0;
|
|
rel.nType = 1;// 板
|
|
rel.pReg = pRegion;
|
|
|
|
rel.dSize[0] = data.m_dW + 2.0 * data.m_dt;
|
|
rel.dSize[1] = data.m_dk;
|
|
rel.dSize[2] = 0.0;
|
|
|
|
arRegEl.append(rel);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbECableTray::DrawTrech3D(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcCmTransparency tr = transparency();
|
|
AcCmTransparency oldTr = dc.SetTransparency(tr);
|
|
|
|
////管线系统屏蔽掉
|
|
if (dc.IsDragging())
|
|
{
|
|
//return Acad::eOk;
|
|
}
|
|
|
|
if (m_pBaseCurve == NULL)
|
|
return Acad::eInvalidInput;
|
|
|
|
//图层
|
|
AcDbObjectId idLay = dc.GetLayerId();
|
|
dc.SetLayer(layerId());
|
|
|
|
int nCrBk = dc.GetColor();
|
|
|
|
DrawInfArrow(dc);
|
|
|
|
int nColor = nCrBk;
|
|
if (m_mapSpecXData.GetAt(_T("COLOR"), nColor))
|
|
{
|
|
dc.SetColor(nColor);
|
|
}
|
|
|
|
int nSegIndex = m_nInfActive / 2;
|
|
if (m_nInfActive < 0)
|
|
nSegIndex = -1;
|
|
|
|
if (IsActive())
|
|
{
|
|
nColor = kMagenta;
|
|
m_mapSpecXData.GetAt(KEY_ACTIVECR, nColor);
|
|
dc.SetColor(nColor);
|
|
}
|
|
|
|
//AcDb3dSolid
|
|
if (Has3DBuffer())
|
|
{
|
|
AcDbEntity *pEnt = NULL;
|
|
const AcDbVoidPtrArray &ar3D = Get3DBuffer();
|
|
for (int i = 0; i < ar3D.length(); i++)
|
|
{
|
|
pEnt = (AcDbEntity *)ar3D.at(i);
|
|
if (nSegIndex == i)//线缆段
|
|
{
|
|
pEnt->setColorIndex(kMagenta);
|
|
}
|
|
else
|
|
{
|
|
if (IsActive())
|
|
{
|
|
BackupColorIndex(pEnt);
|
|
pEnt->setColorIndex(nColor);
|
|
}
|
|
else
|
|
{
|
|
SetBackupColorIndex(pEnt);
|
|
}
|
|
}
|
|
dc.DrawEntity(*pEnt);
|
|
}
|
|
|
|
dc.SetLayer(idLay);
|
|
dc.SetColor(nCrBk);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
DlgData data;
|
|
memset(&data, 0, sizeof(DlgData));
|
|
|
|
if (!GetDlgData(data))
|
|
return Acad::eOk;
|
|
|
|
AcArray<RegionAndEl> arRegEl;
|
|
GetDlgRegionData(data, arRegEl);
|
|
|
|
AcDbObjectId idLayerWall = KTSetting::InitLayer(_T("LAY_WALL"), true);
|
|
AcDbObjectId idLayerSlab = KTSetting::InitLayer(_T("LAY_SLAB"), true);
|
|
|
|
AecDb3dRoadAxisLine roadAx;
|
|
roadAx.AppendCurveSeg(m_pBaseCurve);
|
|
AecDb3dRoadAxisLine *pRoad = &roadAx;
|
|
|
|
for (int i = 0; i < arRegEl.length(); i++)
|
|
{
|
|
RegionAndEl &rel = arRegEl.at(i);
|
|
|
|
if (rel.nType == 2)// 墙体
|
|
{
|
|
AcDbPolyline *pPl = pRoad->ConvertTo2dPline();
|
|
if (pPl != NULL)
|
|
{
|
|
AcDbVoidPtrArray arOff;
|
|
pPl->getOffsetCurves(rel.m_dX, arOff);
|
|
if (!arOff.isEmpty())
|
|
{
|
|
AcDbCurve *pPlCrv = (AcDbCurve *)arOff.first();
|
|
|
|
AcDbVoidPtrArray arCurPtrs;
|
|
pPlCrv->explode(arCurPtrs);
|
|
|
|
//去处0长度线
|
|
double dEnd = 0.0, dEndL = 0.0;
|
|
AcDbCurve *pCurveT = NULL;
|
|
for (int n = 0; n < arCurPtrs.length(); n++)
|
|
{
|
|
pCurveT = (AcDbCurve *)arCurPtrs.at(n);
|
|
pCurveT->getEndParam(dEnd);
|
|
pCurveT->getDistAtParam(dEnd, dEndL);
|
|
if (dEndL < 1.e-2)
|
|
{
|
|
arCurPtrs.removeAt(n);
|
|
n -= 1;
|
|
delete pCurveT;
|
|
}
|
|
}
|
|
|
|
//创建墙体
|
|
CString sSubNo;
|
|
AecDbXWall *pWall = NULL;
|
|
for (int ii = 0; ii < arCurPtrs.length(); ii++)
|
|
{
|
|
sSubNo.Format(_T("WALL-%d"), ii + 1);
|
|
|
|
pCurveT = (AcDbCurve *)arCurPtrs.at(ii);
|
|
|
|
pWall = new AecDbXWall;
|
|
pWall->SetBaseCurve(pCurveT);
|
|
pWall->GetSpecialtyData()->SetAt(KEY_NO, sSubNo);
|
|
pWall->GetSpecialtyData()->SetAt(KEY_MATERIAL, rel.m_szMat);
|
|
pWall->GetSpecialtyData()->SetAt(KEY_3DSHOW, 0);
|
|
|
|
pWall->SetWallData(rel.dSize[0], rel.dSize[1], rel.m_dZ - 0.5 * rel.dSize[1], kMid);
|
|
pWall->setLayer(idLayerWall);
|
|
pWall->Draw3d(dc);
|
|
|
|
dc.Add3dBuffer(pWall->Get3DBuffer());
|
|
pWall->Clean3DBufferNoDel();
|
|
delete pWall;
|
|
}
|
|
}
|
|
|
|
delete pPl;
|
|
}
|
|
}
|
|
else if (rel.nType == 1)//板
|
|
{
|
|
AcDbPolyline *pPl = pRoad->ConvertTo2dPline();
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setElevation(rel.m_dZ);
|
|
|
|
CString sNo;
|
|
sNo.Format(_T("板_%d"), i);
|
|
|
|
AecDbXSlab *pSlab = new AecDbXSlab;
|
|
pSlab->SetSection(rel.dSize[0], rel.dSize[1], 0.0);
|
|
pSlab->setLayer(idLayerSlab);
|
|
pSlab->SetBaseCurve(pPl);
|
|
pSlab->GetSpecialtyData()->SetAt(KEY_2DSTYLE, 2);
|
|
|
|
pSlab->GetSpecialtyData()->SetAt(KEY_MATERIAL, rel.m_szMat);
|
|
pSlab->GetSpecialtyData()->SetAt(KEY_NO, sNo);
|
|
pSlab->SetHatch(_T("AR-CONC"), 0.0, 1.0);
|
|
|
|
pSlab->Draw3d(dc);
|
|
|
|
dc.Add3dBuffer(pSlab->Get3DBuffer());
|
|
pSlab->Clean3DBufferNoDel();
|
|
delete pSlab;
|
|
|
|
delete pPl;
|
|
}
|
|
}
|
|
else //其他
|
|
{
|
|
//...
|
|
}
|
|
|
|
//释放截面
|
|
if (rel.pReg != NULL)
|
|
delete rel.pReg;
|
|
rel.pReg = NULL;
|
|
}
|
|
|
|
//然后绘制支吊架
|
|
bool bSucess(false);
|
|
XHolder lH;
|
|
memset(&lH, 0, sizeof(XHolder));
|
|
bSucess = GetXHolder(kLeft,lH);
|
|
|
|
AcGeVector3d vtDir, vtL,vtR;
|
|
AcDbLine *pLnBase = AcDbLine::cast(m_pBaseCurve);
|
|
if (pLnBase != NULL)
|
|
{
|
|
vtDir = pLnBase->endPoint() - pLnBase->startPoint();
|
|
vtDir.normalize();
|
|
|
|
vtL = vtDir;
|
|
vtL.rotateBy(-PI / 2.0, AcGeVector3d::kZAxis);
|
|
|
|
vtR = vtDir;
|
|
vtR.rotateBy(PI / 2.0, AcGeVector3d::kZAxis);
|
|
}
|
|
|
|
if (bSucess && lH.N > 0 && pLnBase != NULL)
|
|
{
|
|
AcGePoint3d ptL = StartPoint();
|
|
ptL += vtDir * 5.0 * lH.W;
|
|
|
|
ptL.z += (data.m_dH + data.m_db + data.m_dk) * 0.5;//到顶
|
|
ptL.z -= (data.m_dk + data.m_dH);//到内底
|
|
ptL += vtR * 0.5 * data.m_dW;
|
|
ptL.z += lH.nDists[0];//第一行底
|
|
|
|
AecDbHolder lHolder;
|
|
lHolder.SetPosition(ptL,vtL);
|
|
lHolder.SetHolder(lH);
|
|
|
|
lHolder.Draw3d(dc);
|
|
dc.Add3dBuffer(lHolder.Get3DBuffer());
|
|
lHolder.Clean3DBufferNoDel();
|
|
}
|
|
|
|
XHolder rH;
|
|
memset(&rH, 0, sizeof(XHolder));
|
|
bSucess = GetXHolder(kRight, rH);
|
|
if (bSucess && lH.N > 0 && pLnBase != NULL)
|
|
{
|
|
AcGePoint3d ptR = StartPoint();
|
|
ptR += vtDir * 5.0 * lH.W;
|
|
|
|
ptR.z += (data.m_dH + data.m_db + data.m_dk) * 0.5;//到顶
|
|
ptR.z -= (data.m_dk + data.m_dH);//到内底
|
|
ptR += vtL * 0.5 * data.m_dW;
|
|
ptR.z += lH.nDists[0];//第一行底
|
|
|
|
AecDbHolder rHolder;
|
|
rHolder.SetPosition(ptR, vtR);
|
|
rHolder.SetHolder(rH);
|
|
|
|
rHolder.Draw3d(dc);
|
|
dc.Add3dBuffer(rHolder.Get3DBuffer());
|
|
rHolder.Clean3DBufferNoDel();
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
bool AecDbECableTray::TransformAssocInf(int nInf,const AcGeMatrix3d& xform)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
AcArray<AecInterface> arInf;
|
|
GetInterface(arInf);
|
|
|
|
if (nInf > -1 && nInf < arInf.length() )
|
|
{
|
|
AecInterface& inf = arInf.at(nInf);
|
|
|
|
AcGePoint3d ptGe = inf.ptPos;
|
|
ptGe.transformBy(xform);
|
|
|
|
AcDbLine* pLine = AcDbLine::cast(m_pBaseCurve);
|
|
if (pLine != NULL)//直管
|
|
{
|
|
AcGePoint3d ptSta,ptEnd;
|
|
ptSta = pLine->startPoint();
|
|
ptEnd = pLine->endPoint();
|
|
AcGeVector3d vtL = ptEnd - ptSta;
|
|
|
|
if (inf.ptPos.distanceTo(ptSta) < 1.e-1)
|
|
{
|
|
pLine->setStartPoint(ptGe);//新位置z
|
|
|
|
AcGeVector3d vtL2 = ptEnd - ptGe;
|
|
if (!vtL2.isParallelTo(vtL))
|
|
{
|
|
ptEnd.transformBy(xform);
|
|
pLine->setEndPoint(ptEnd);
|
|
return true;//继续发消息
|
|
}
|
|
return false;//不再继续发消息
|
|
}
|
|
|
|
if (inf.ptPos.distanceTo(ptEnd) < 1.e-1)
|
|
{
|
|
pLine->setEndPoint(ptGe);//新位置
|
|
|
|
AcGeVector3d vtL2 = ptGe - ptSta;
|
|
if (!vtL.isParallelTo(vtL2))
|
|
{
|
|
ptSta.transformBy(xform);
|
|
pLine->setStartPoint(ptSta);
|
|
return true;//继续发消息
|
|
}
|
|
return false;//不再继续发消息
|
|
}
|
|
}
|
|
|
|
AcDbArc* pArc = AcDbArc::cast(m_pBaseCurve);//弧管
|
|
if (pArc != NULL)
|
|
{
|
|
AcGePoint3d ptSta,ptEnd,ptMid;
|
|
pArc->getStartPoint(ptSta);
|
|
pArc->getEndPoint(ptEnd);
|
|
|
|
double dSta = 0.0,dEnd = 0.0;
|
|
pArc->getStartParam(dSta);
|
|
pArc->getEndParam(dEnd);
|
|
double dMid = (dSta + dEnd) / 2.0;
|
|
pArc->getPointAtParam(dMid,ptMid);
|
|
|
|
if (inf.ptPos.distanceTo(ptSta) < 1.e-1)
|
|
{
|
|
AcDbArc* pArc2 = KTCADUtilityEx::FormatArc(ptGe,ptMid,ptEnd);
|
|
if (pArc2 != NULL)
|
|
{
|
|
pArc->setStartAngle(pArc2->startAngle());
|
|
pArc->setEndAngle(pArc2->endAngle());
|
|
pArc->setCenter(pArc2->center());
|
|
pArc->setRadius(pArc2->radius());
|
|
DELETE_PTR(pArc2);
|
|
}
|
|
return false;//不在继续发消息
|
|
}
|
|
|
|
if (inf.ptPos.distanceTo(ptEnd) < 1.e-1)
|
|
{
|
|
AcDbArc* pArc2 = KTCADUtilityEx::FormatArc(ptSta,ptMid,ptGe);
|
|
if (pArc2 != NULL)
|
|
{
|
|
pArc->setStartAngle(pArc2->startAngle());
|
|
pArc->setEndAngle(pArc2->endAngle());
|
|
pArc->setCenter(pArc2->center());
|
|
pArc->setRadius(pArc2->radius());
|
|
DELETE_PTR(pArc2);
|
|
}
|
|
return false;//不在继续发消息
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
LPCTSTR AecDbECableTray::GetGripCmd() const
|
|
{
|
|
assertReadEnabled();
|
|
return _T("EL_cabtryadd");
|
|
}
|
|
|
|
bool AecDbECableTray::GetSectionDraw(AcGePlane& plan,const AcGeVector3d& vtTo,AcDbVoidPtrArray& arRegionPtrs) const
|
|
{
|
|
AcGeMatrix3d xform;
|
|
xform.setToPlaneToWorld(plan);
|
|
xform.invert();
|
|
|
|
AcDbVoidPtrArray arSubPtrs;
|
|
AecDbECableTray* pFit = (AecDbECableTray *)clone();
|
|
if (pFit != NULL)
|
|
{
|
|
pFit->transformBy(xform);
|
|
|
|
AcGiViewDraw dc(NULL, NULL);
|
|
pFit->Draw2d(dc);
|
|
|
|
pFit->GetDraw2dables(0,arSubPtrs);
|
|
|
|
arRegionPtrs.append(arSubPtrs);
|
|
delete pFit;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
SHJson::WValue &AecDbECableTray::ToJson(bool bExprotGeo) const
|
|
{
|
|
assertReadEnabled();
|
|
return AecDbEwPipeBase::ToJson(bExprotGeo);
|
|
}
|
|
|
|
bool AecDbECableTray::ByJson(const SHJson::WValue &v)
|
|
{
|
|
AssertWriteEnabled();
|
|
return AecDbEwPipeBase::ByJson(v);
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbECableTray::DrawFlangInf3d(AcGiDraw &dc) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbECableTray::DrawFlangInf3d(AcGiDraw &dc,const AcGePoint3d& ptPos,const AcGeVector3d& vtInf) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbECableTray::DrawFlangInf2d(AcGiDraw &dc) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbECableTray::DrawFlangInf2d(AcGiDraw &dc,const AcGePoint3d& ptPos,const AcGeVector3d& vtInf) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbECableTray::CheckBrokenOpen()
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
int AecDbECableTray::ComparedTo(AecDbCurveBase* pCurOther) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AecDbECableTray* pPipeOther = AecDbECableTray::cast(pCurOther);
|
|
if (pPipeOther != NULL)
|
|
{
|
|
AecHvac::DuctParam dpThis;
|
|
GetDuctParam(dpThis);
|
|
|
|
AecHvac::DuctParam dpThat;
|
|
pPipeOther->GetDuctParam(dpThat);
|
|
|
|
if (dpThis.eType != dpThat.eType)
|
|
return 1;
|
|
|
|
if ( fabs(dpThis.dSize[0] - dpThat.dSize[0]) > 0.1)
|
|
return 1;
|
|
|
|
if ( fabs(dpThis.dSize[1] - dpThat.dSize[1]) > 0.1)
|
|
return 1;
|
|
|
|
if ( fabs(dpThis.dSize[2] - dpThat.dSize[2]) > 0.1)
|
|
return 1;
|
|
|
|
if ( fabs(dpThis.m_dEl - dpThat.m_dEl) > 0.1)
|
|
return 1;
|
|
|
|
AcGePoint3d ptSta,ptEnd;
|
|
getStartPoint(ptSta);
|
|
getEndPoint(ptEnd);
|
|
|
|
AcGePoint3d ptSta2,ptEnd2;
|
|
pPipeOther->getStartPoint(ptSta2);
|
|
pPipeOther->getEndPoint(ptEnd2);
|
|
|
|
if (ptSta.distanceTo(ptSta2) > 2.0)//误差2毫米
|
|
return 1;
|
|
|
|
if (ptEnd.distanceTo(ptEnd2) > 2.0)//误差2毫米
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#include "hlrcutoption.h"
|
|
void AecDbECableTray::ProcessHlrResult(const AcArray<AcDbEntity *> &ar, const std::map<AcDbEntity *, AcArray<AcDbEntity *>> &preAr, AcArray<AcDbEntity *> &output) const
|
|
{
|
|
double dW;
|
|
HlrCutOption::ProcessHlrResult(this
|
|
, HlrCutOption::getHlrLW_ElecSys(dW)
|
|
, dW
|
|
, FALSE
|
|
, ar
|
|
, preAr
|
|
, output);
|
|
} |