1301 lines
29 KiB
C++
1301 lines
29 KiB
C++
#include "stdafx.h"
|
|
#include "AecDbBossHolder.h"
|
|
#include "MFCDbDwgFiler.h"
|
|
#include "AecDbEwPipe.h"
|
|
#include "dbgrip.h"
|
|
#include "AecGripCback.h"
|
|
#include "AcGiViewDraw.h"
|
|
#include "ImpMD5.h"
|
|
|
|
extern AcDbRegion* CreatePolygonRegionOnly(AcGePoint3d* pPoints,int nSize);
|
|
extern AcDbPolyline* FormatPolyline(AcGePoint3d* ppPts,int nCount);
|
|
extern AcGePoint3d MidPoint(const AcGePoint3d& pt1,const AcGePoint3d& pt2);
|
|
extern BOOL DLLIMPEXP GetDimGripOff();
|
|
extern void DLLIMPEXP OrthoProjected3DSolid(AcDb3dSolid* pSolidClone,const AcGePlane& plan,AcGeMatrix3d& xformPlanToWorld,AcDbVoidPtrArray& arEntPtrs);
|
|
extern CString IDCreate();
|
|
Adesk::UInt32 AecDbBossHolder::kCurrentVersionNumber = 1;
|
|
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;
|
|
|
|
ACRX_DXF_DEFINE_MEMBERS (AecDbBossHolder, AecDbEntityBase,
|
|
AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
|
AcDbProxyEntity::kNoOperation | AcDbProxyEntity::kDisableProxyWarning,
|
|
AEC_DBBOSSHOLDER,
|
|
"AecDbBossHolder"
|
|
"|Product Desc: shanghua earthworm app obj"
|
|
"|Company: shanghua inc"
|
|
"|WEB Address: www.shanghuasoft.com")
|
|
|
|
|
|
AecDbBossHolder::AecDbBossHolder(void)
|
|
{
|
|
m_pGripAppData = new AecGripData[GRIP_MAXNUM];
|
|
m_mapSpecXData.SetAt(KEY_NAME,_T("支墩"));
|
|
}
|
|
|
|
AecDbBossHolder::~AecDbBossHolder(void)
|
|
{
|
|
delete [] m_pGripAppData;
|
|
deleteContainerOfStd(m_solids);
|
|
deleteContainerOfStd(m_pipes);
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBossHolder::SetPosition(const AcGePoint3d& ptPos,const AcGeVector3d& vtL)
|
|
{
|
|
AssertWriteEnabled();
|
|
m_mapSpecXData.SetAt(KEY_POS,ptPos);
|
|
m_mapSpecXData.SetAt(PIPE_DIR,vtL);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
AcGePoint3d AecDbBossHolder::GetPosition(AcGeVector3d& vtL) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcGePoint3d pt;
|
|
m_mapSpecXData.GetAt(KEY_POS,pt);
|
|
m_mapSpecXData.GetAt(PIPE_DIR,vtL);
|
|
return pt;
|
|
}
|
|
|
|
/*
|
|
type struct XBossHolder
|
|
{
|
|
int nType;
|
|
|
|
//墩
|
|
double W;//墩宽或角钢宽
|
|
double t;//角钢厚度t 墩厚度
|
|
double L;//长
|
|
|
|
//角钢
|
|
int N;
|
|
double V;//垂直层间距
|
|
double H;//支撑高度 > nLay * V
|
|
|
|
// 材质
|
|
TCHAR szMat[MAX_PATH];
|
|
|
|
// 用途
|
|
TCHAR szNo[MAX_PATH];
|
|
|
|
}XBossHolder;
|
|
*/
|
|
|
|
void AecDbBossHolder::SetHolder(const XBossHolder& data)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
m_mapSpecXData.SetAt(KEY_TYPE,data.nType);
|
|
m_mapSpecXData.SetAt(KEY_W,data.W);//A
|
|
m_mapSpecXData.SetAt(KEY_B, data.B);//A
|
|
m_mapSpecXData.SetAt(KEY_C, data.C);//A
|
|
m_mapSpecXData.SetAt(KEY_L,data.L);
|
|
m_mapSpecXData.SetAt(KEY_N,data.N);
|
|
m_mapSpecXData.SetAt(KEY_V,data.V);
|
|
m_mapSpecXData.SetAt(KEY_VS,data.szVs);
|
|
m_mapSpecXData.SetAt(KEY_T,data.t);//d
|
|
m_mapSpecXData.SetAt(KEY_H,data.H);
|
|
m_mapSpecXData.SetAt(KEY_MATERIAL,data.szMat);
|
|
m_mapSpecXData.SetAt(KEY_NO,data.szNo);
|
|
}
|
|
|
|
bool AecDbBossHolder::GetHolder(XBossHolder& data) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
memset(&data,0,sizeof(XBossHolder));
|
|
|
|
m_mapSpecXData.GetAt(KEY_TYPE,data.nType);
|
|
m_mapSpecXData.GetAt(KEY_W,data.W);
|
|
m_mapSpecXData.GetAt(KEY_B, data.B);//A
|
|
m_mapSpecXData.GetAt(KEY_C, data.C);//A
|
|
m_mapSpecXData.GetAt(KEY_L,data.L);
|
|
m_mapSpecXData.GetAt(KEY_N,data.N);
|
|
m_mapSpecXData.GetAt(KEY_V,data.V);
|
|
m_mapSpecXData.GetAt(KEY_T,data.t);
|
|
m_mapSpecXData.GetAt(KEY_H,data.H);
|
|
|
|
CString sTemp;
|
|
m_mapSpecXData.GetAt(KEY_MATERIAL,sTemp);
|
|
_tcscpy(data.szMat,(LPCTSTR)sTemp);
|
|
|
|
sTemp = _T("");
|
|
m_mapSpecXData.GetAt(KEY_VS,sTemp);
|
|
_tcscpy(data.szVs,(LPCTSTR)sTemp);
|
|
|
|
sTemp = _T("");
|
|
m_mapSpecXData.GetAt(KEY_NO,sTemp);
|
|
_tcscpy(data.szNo,(LPCTSTR)sTemp);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool AecDbBossHolder::GetASteelLength(ASteel& aSteel) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
XBossHolder holder;
|
|
memset(&holder, 0, sizeof(XBossHolder));
|
|
GetHolder(holder);
|
|
|
|
memset(&aSteel, 0, sizeof(ASteel));
|
|
|
|
if (holder.nType == 1)
|
|
{
|
|
aSteel.W = holder.W;
|
|
aSteel.t = holder.t;
|
|
aSteel.L = holder.N * holder.L;
|
|
aSteel.L += 2.0 * holder.H;
|
|
aSteel.L += 2.0 * 4.0 * holder.W;//固定地面
|
|
|
|
_tcscpy(aSteel.szMat,holder.szMat);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBossHolder::dwgInFields(AcDbDwgFiler* pFiler)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
//----- Read parent class information first.
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
if ( !pFiler->isKindOf(CMFCDbDwgFiler::desc()))
|
|
{
|
|
es = AecDbEntityBase::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 > AecDbBossHolder::kCurrentVersionNumber )
|
|
return (Acad::eMakeMeProxy);
|
|
|
|
m_mapSpecXData.dwgInFields(pFiler);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBossHolder::dwgOutFields(AcDbDwgFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
//----- Save parent class information first.
|
|
Acad::ErrorStatus es = Acad::eOk;
|
|
if ( !pFiler->isKindOf(CMFCDbDwgFiler::desc()))
|
|
{
|
|
es = AecDbEntityBase::dwgOutFields (pFiler) ;
|
|
if ( es != Acad::eOk )
|
|
return (es) ;
|
|
}
|
|
|
|
//----- Object version number needs to be saved first
|
|
if ( (es =pFiler->writeUInt32 (AecDbBossHolder::kCurrentVersionNumber)) != Acad::eOk )
|
|
return (es) ;
|
|
|
|
m_mapSpecXData.dwgOutFields(pFiler);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBossHolder::dxfInFields(AcDbDxfFiler* pFiler)
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBossHolder::dxfOutFields(AcDbDxfFiler* pFiler) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
void AecDbBossHolder::subList() const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AecDbEntityBase::subList();
|
|
acutPrintf(_T("\n属性数据:"));
|
|
m_mapSpecXData.List();
|
|
acutPrintf(_T("\n"));
|
|
}
|
|
|
|
bool AecDbBossHolder::GetBimInfoTip(CString& sInfoTip) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
CString sField,sFmt;
|
|
|
|
XBossHolder bossholder;
|
|
memset(&bossholder,0,sizeof(XBossHolder));
|
|
|
|
GetHolder(bossholder);
|
|
|
|
if (bossholder.nType == 0)
|
|
{
|
|
sField = _T("支撑:\n");
|
|
sInfoTip += sField;
|
|
|
|
MAKEFIELD(_T("支架长"),_T("%d"),(int)(bossholder.L + 0.5),sInfoTip);
|
|
MAKEFIELD(_T("支架高"),_T("%d"),(int)(bossholder.H + 0.5),sInfoTip);
|
|
|
|
MAKEFIELD(_T("角钢宽"),_T("%d"),(int)(bossholder.W + 0.5),sInfoTip);
|
|
MAKEFIELD(_T("角钢厚"),_T("%.1f"),(int)(bossholder.t + 0.5),sInfoTip);
|
|
|
|
MAKEFIELD(_T("层数"),_T("%d"),bossholder.N,sInfoTip);
|
|
MAKEFIELD(_T("间距"),_T("%.1f"),bossholder.V,sInfoTip);
|
|
|
|
AcGePoint3d pt;
|
|
m_mapSpecXData.GetAt(KEY_POS,pt);
|
|
MAKEFIELD(_T("顶部标高"),_T("%.1f"),pt.z,sInfoTip);
|
|
|
|
MAKEFIELD(_T("编号"),_T("%s"),bossholder.szNo,sInfoTip);
|
|
}
|
|
else
|
|
{
|
|
sField = _T("支墩:\n");
|
|
sInfoTip += sField;
|
|
|
|
MAKEFIELD(_T("支墩长"),_T("%d"),(int)(bossholder.L + 0.5),sInfoTip);
|
|
|
|
MAKEFIELD(_T("支墩宽"),_T("%d"),(int)(bossholder.W + 0.5),sInfoTip);
|
|
|
|
MAKEFIELD(_T("支墩高"),_T("%d"),(int)(bossholder.H + 0.5),sInfoTip);
|
|
|
|
AcGePoint3d pt;
|
|
m_mapSpecXData.GetAt(KEY_POS,pt);
|
|
MAKEFIELD(_T("顶部标高"),_T("%.1f"),pt.z,sInfoTip);
|
|
|
|
MAKEFIELD(_T("编号"),_T("%s"),bossholder.szNo,sInfoTip);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBossHolder::copyFrom(const AcRxObject* pSrc)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
AecDbBossHolder* pFit = AecDbBossHolder::cast(pSrc);
|
|
if (pFit != NULL)
|
|
{
|
|
m_mapSpecXData.Empty();
|
|
m_mapSpecXData.CopyFrom(&pFit->m_mapSpecXData);
|
|
|
|
//发送提资需要相同的ID
|
|
Adesk::Int16 nVal = acdbCurDwg()->useri4();
|
|
if (nVal != KEY_NOPROTECT)
|
|
{
|
|
int nVt = 0;
|
|
CString sID = IDCreate();
|
|
if (m_mapSpecXData.HasKey(KEY_NO, nVt))
|
|
m_mapSpecXData.SetAt(KEY_NO, sID);
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBossHolder::subTransformBy(const AcGeMatrix3d& xform)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
AcGePoint3d pt;
|
|
AcGeVector3d vtL;
|
|
|
|
m_mapSpecXData.GetAt(KEY_POS,pt);
|
|
m_mapSpecXData.GetAt(PIPE_DIR,vtL);
|
|
|
|
pt.transformBy(xform);
|
|
vtL.transformBy(xform);
|
|
|
|
m_mapSpecXData.SetAt(KEY_POS,pt);
|
|
m_mapSpecXData.SetAt(PIPE_DIR,vtL);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBossHolder::subGetGripPoints(AcDbGripDataPtrArray& grips,
|
|
const double curViewUnitSize,
|
|
const int gripSize,
|
|
const AcGeVector3d& curViewDir,
|
|
const int bitflags) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
AcGePoint3d pt;
|
|
AcGeVector3d vtL;
|
|
m_mapSpecXData.GetAt(KEY_POS,pt);
|
|
m_mapSpecXData.GetAt(PIPE_DIR,vtL);
|
|
|
|
XBossHolder holder;
|
|
memset(&holder, 0, sizeof(XBossHolder));
|
|
GetHolder(holder);
|
|
|
|
vtL.normalize();
|
|
|
|
//Y
|
|
AcGeVector3d vtV = vtL;
|
|
vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
|
|
|
|
//位置点
|
|
int i = 0;
|
|
AcDbGripData* pGripData = new AcDbGripData;
|
|
memset(&m_pGripAppData[i],0,sizeof(AecGripData));
|
|
m_pGripAppData[i].nIndex = i;
|
|
m_pGripAppData[i].ePos = eStart;
|
|
m_pGripAppData[i].nColor = kBlue;
|
|
m_pGripAppData[i].ptGrip = pt;
|
|
_tcscpy(m_pGripAppData[i].szTip,_T("位置夹点"));
|
|
m_pGripAppData[i].pOwner = (AcDbEntity*)this;
|
|
m_pGripAppData[i].idHost = objectId();
|
|
|
|
pGripData->setGripPoint(pt);
|
|
pGripData->setAppData((void*)&m_pGripAppData[i]);
|
|
pGripData->setWorldDraw(AecGripCback::WorldDrawfunc);
|
|
pGripData->setToolTipFunc(AecGripCback::GripToolTipFunc);
|
|
grips.append(pGripData);
|
|
|
|
AcGePoint3d ptT;
|
|
if (holder.nType == 0)//墩
|
|
{
|
|
ptT = pt + vtL * holder.L;//长度夹点
|
|
|
|
i++;
|
|
pGripData = new AcDbGripData;
|
|
memset(&m_pGripAppData[i],0,sizeof(AecGripData));
|
|
m_pGripAppData[i].nIndex = i;
|
|
m_pGripAppData[i].ePos = eStart;
|
|
m_pGripAppData[i].ptGrip = ptT;
|
|
m_pGripAppData[i].nColor = kBlue;
|
|
_tcscpy(m_pGripAppData[i].szTip,_T("长度夹点"));
|
|
m_pGripAppData[i].pOwner = (AcDbEntity*)this;
|
|
m_pGripAppData[i].idHost = objectId();
|
|
|
|
pGripData->setGripPoint(ptT);
|
|
pGripData->setAppData((void*)&m_pGripAppData[i]);
|
|
pGripData->setWorldDraw(AecGripCback::WorldDrawfunc);
|
|
pGripData->setToolTipFunc(AecGripCback::GripToolTipFunc);
|
|
grips.append(pGripData);
|
|
|
|
i++;
|
|
ptT = pt + vtV * 0.5 * holder.W;//宽度夹点
|
|
pGripData = new AcDbGripData;
|
|
memset(&m_pGripAppData[i],0,sizeof(AecGripData));
|
|
m_pGripAppData[i].nIndex = i;
|
|
m_pGripAppData[i].ePos = eStart;
|
|
m_pGripAppData[i].nColor = kBlue;
|
|
m_pGripAppData[i].ptGrip = ptT;
|
|
_tcscpy(m_pGripAppData[i].szTip,_T("宽度夹点"));
|
|
m_pGripAppData[i].pOwner = (AcDbEntity*)this;
|
|
m_pGripAppData[i].idHost = objectId();
|
|
|
|
pGripData->setGripPoint(ptT);
|
|
pGripData->setAppData((void*)&m_pGripAppData[i]);
|
|
pGripData->setWorldDraw(AecGripCback::WorldDrawfunc);
|
|
pGripData->setToolTipFunc(AecGripCback::GripToolTipFunc);
|
|
grips.append(pGripData);
|
|
}
|
|
else//支撑
|
|
{
|
|
ptT = pt + vtV * 0.5 * holder.L;//长度夹点
|
|
|
|
i++;
|
|
pGripData = new AcDbGripData;
|
|
memset(&m_pGripAppData[i],0,sizeof(AecGripData));
|
|
m_pGripAppData[i].nIndex = i;
|
|
m_pGripAppData[i].ePos = eStart;
|
|
m_pGripAppData[i].nColor = kBlue;
|
|
m_pGripAppData[i].ptGrip = ptT;
|
|
_tcscpy(m_pGripAppData[i].szTip,_T("长度夹点"));
|
|
m_pGripAppData[i].pOwner = (AcDbEntity*)this;
|
|
m_pGripAppData[i].idHost = objectId();
|
|
|
|
pGripData->setGripPoint(ptT);
|
|
pGripData->setAppData((void*)&m_pGripAppData[i]);
|
|
pGripData->setWorldDraw(AecGripCback::WorldDrawfunc);
|
|
pGripData->setToolTipFunc(AecGripCback::GripToolTipFunc);
|
|
grips.append(pGripData);
|
|
}
|
|
|
|
//动态标注
|
|
//直线,半径 标注风格
|
|
if (!grips.isEmpty())
|
|
{
|
|
SubAddDimPoints(grips,curViewDir);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBossHolder::SubAddDimPoints(AcDbGripDataPtrArray& grips,const AcGeVector3d& curViewDir) const
|
|
{
|
|
if (GetDimGripOff())
|
|
return Acad::eOk;
|
|
|
|
AcGePoint3d pt;
|
|
AcGeVector3d vtL;
|
|
m_mapSpecXData.GetAt(KEY_POS,pt);
|
|
m_mapSpecXData.GetAt(PIPE_DIR,vtL);
|
|
|
|
XBossHolder holder;
|
|
memset(&holder, 0, sizeof(XBossHolder));
|
|
GetHolder(holder);
|
|
|
|
vtL.normalize();
|
|
|
|
//Y
|
|
AcGeVector3d vtV = vtL;
|
|
vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
|
|
|
|
vtL *= holder.L;
|
|
vtV *= holder.W;
|
|
|
|
AcGePoint3d ptGe[2],ptMid;
|
|
AcGeVector3d vtDirX = vtL;
|
|
|
|
if (holder.nType == 0)
|
|
{
|
|
ptGe[0] = pt;
|
|
ptGe[1] = pt + vtL;
|
|
ptGe[0] -= 0.5 * vtV;
|
|
ptGe[1] -= 0.5 * vtV;
|
|
|
|
vtL.normalize();
|
|
vtV.normalize();
|
|
|
|
//L
|
|
ptMid = MidPoint(ptGe[0],ptGe[1]);
|
|
vtDirX = vtV;
|
|
vtDirX.normalize();
|
|
ptMid -= vtV * 10.0 * 100.0;//标注文字位置
|
|
AddDimPoints(grips,curViewDir,ptGe[0],ptGe[1],ptMid,0);
|
|
|
|
//W
|
|
ptGe[0] = pt + 0.5 * vtV * holder.W;
|
|
ptGe[1] = pt - 0.5 * vtV * holder.W;
|
|
vtL.normalize();
|
|
ptGe[0] -= vtL * 10.0;
|
|
ptGe[1] -= vtL * 10.0;
|
|
|
|
ptMid = MidPoint(ptGe[0],ptGe[1]);
|
|
ptMid -= vtL * 10.0 * 100.0;//标注文字位置
|
|
AddDimPoints(grips,curViewDir,ptGe[0],ptGe[1],ptMid,0);
|
|
|
|
//高
|
|
ptGe[1] = ptGe[0];
|
|
ptGe[1].z -= holder.H;
|
|
ptMid = MidPoint(ptGe[0],ptGe[1]);
|
|
ptMid -= vtL * 10.0 * 100.0;//标注文字位置
|
|
AddDimPoints(grips,curViewDir,ptGe[0],ptGe[1],ptMid,0);
|
|
}
|
|
else
|
|
{
|
|
vtL.normalize();
|
|
vtV.normalize();
|
|
|
|
ptGe[0] = pt + vtV * 0.5 * holder.L;//长度夹点
|
|
ptGe[1] = ptGe[0] - vtV * holder.L;
|
|
|
|
ptGe[0] -= vtL * 10.0;
|
|
ptGe[1] -= vtL * 10.0;
|
|
|
|
ptMid = MidPoint(ptGe[0],ptGe[1]);
|
|
ptMid -= vtL * 10.0 * 100.0;//标注文字位置
|
|
AddDimPoints(grips,curViewDir,ptGe[0],ptGe[1],ptMid,0);
|
|
|
|
ptGe[1] = ptGe[0];
|
|
ptGe[1].z -= holder.H;
|
|
ptMid = MidPoint(ptGe[0],ptGe[1]);
|
|
ptMid -= vtL * 10.0 * 100.0;//标注文字位置
|
|
AddDimPoints(grips,curViewDir,ptGe[0],ptGe[1],ptMid,0);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBossHolder::AddDimPoints(AcDbGripDataPtrArray& grips,const AcGeVector3d& curViewDir,
|
|
const AcGePoint3d& ptSta,const AcGePoint3d& ptEnd,
|
|
const AcGePoint3d& ptMid,int nDimType,double dVal/* = -1.0*/,double dt) const
|
|
{
|
|
int i = grips.length();
|
|
EPosition ePos = eDim0;
|
|
memset(&m_pGripAppData[i],0,sizeof(AecGripData));
|
|
m_pGripAppData[i].nIndex = i;
|
|
m_pGripAppData[i].ePos = ePos;
|
|
m_pGripAppData[i].nColor = kGreen;
|
|
m_pGripAppData[i].ptGrip = ptMid;
|
|
m_pGripAppData[i].ptDim[0] = ptSta;
|
|
m_pGripAppData[i].ptDim[1] = ptEnd;
|
|
m_pGripAppData[i].nDimType = nDimType;
|
|
|
|
if (dVal > 1.e-3)
|
|
{
|
|
if (nDimType == 1)
|
|
{
|
|
_stprintf(m_pGripAppData[i].szTip,_T("R%.1f"),dVal);
|
|
}
|
|
else if (nDimType == 2)//@100 标注
|
|
{
|
|
_stprintf(m_pGripAppData[i].szTip,_T("Ø%.1f"),dVal);
|
|
}
|
|
else if (nDimType == 3)//角度标注
|
|
{
|
|
_stprintf(m_pGripAppData[i].szTip,_T("%.1f°"),dVal);
|
|
}
|
|
else if (nDimType == 4)//@107x3.5
|
|
{
|
|
_stprintf(m_pGripAppData[i].szTip,_T("Ø%.1fx%.1f"),dVal,dt);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_tcscpy(m_pGripAppData[i].szTip,_T(" "));
|
|
}
|
|
_tcscpy(m_pGripAppData[i].szID,_T(" "));
|
|
m_pGripAppData[i].pOwner = (AcDbEntity*)this;
|
|
|
|
AcDbGripData* pGripData = new AcDbGripData;
|
|
pGripData->setGripPoint(ptMid);
|
|
pGripData->setAppData((void*)&m_pGripAppData[i]);
|
|
pGripData->setWorldDraw(AecGripCback::WorldDrawfunc);
|
|
pGripData->setToolTipFunc(AecGripCback::GripToolTipFunc);
|
|
grips.append(pGripData);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBossHolder::subGetStretchPoints(AcGePoint3dArray& stretchPoints) const
|
|
{
|
|
AcGePoint3d pt;
|
|
AcGeVector3d vtL;
|
|
m_mapSpecXData.GetAt(KEY_POS,pt);
|
|
m_mapSpecXData.GetAt(PIPE_DIR,vtL);
|
|
|
|
XBossHolder holder;
|
|
memset(&holder, 0, sizeof(XBossHolder));
|
|
GetHolder(holder);
|
|
|
|
vtL.normalize();
|
|
|
|
//Y
|
|
AcGeVector3d vtV = vtL;
|
|
vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
|
|
|
|
//位置点
|
|
stretchPoints.append(pt);
|
|
|
|
AcGePoint3d ptT;
|
|
if (holder.nType == 0)//墩
|
|
{
|
|
ptT = pt + vtL * holder.L;//长度夹点
|
|
stretchPoints.append(ptT);
|
|
|
|
ptT = pt + vtV * 0.5 * holder.W;//宽度夹点
|
|
stretchPoints.append(ptT);
|
|
}
|
|
else//支撑
|
|
{
|
|
ptT = pt + vtV * holder.L;//长度夹点
|
|
stretchPoints.append(ptT);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBossHolder::subMoveGripPointsAt(const AcDbVoidPtrArray& appData, const AcGeVector3d& offset, const int bitflags)
|
|
{
|
|
AssertWriteEnabled();
|
|
|
|
AecGripData* pAppData = NULL;
|
|
AcDbIntArray arIndex;
|
|
|
|
if ( !appData.isEmpty() )
|
|
{
|
|
pAppData = (AecGripData*)appData.first();
|
|
arIndex.append(pAppData->nIndex);
|
|
}
|
|
else
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
AcGePoint3d pt,pt2;
|
|
AcGeVector3d vtL;
|
|
m_mapSpecXData.GetAt(KEY_POS,pt);
|
|
m_mapSpecXData.GetAt(PIPE_DIR,vtL);
|
|
|
|
AcGeVector3d vtV = vtL;
|
|
vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
|
|
vtL.normalize();
|
|
vtV.normalize();
|
|
|
|
int nGripIndex = arIndex.first();
|
|
|
|
XBossHolder holder;
|
|
memset(&holder, 0, sizeof(XBossHolder));
|
|
GetHolder(holder);
|
|
|
|
if (holder.nType == 0)//墩
|
|
{
|
|
if (nGripIndex == 0)
|
|
{
|
|
pt += offset;
|
|
m_mapSpecXData.SetAt(KEY_POS,pt);
|
|
}
|
|
else if (nGripIndex == 1)//长度
|
|
{
|
|
pt2 = pt + vtL * holder.L;
|
|
pt2 += offset;
|
|
holder.L = pt2.distanceTo(pt);
|
|
m_mapSpecXData.SetAt(KEY_L,holder.L);
|
|
}
|
|
else if (nGripIndex == 2)//宽度
|
|
{
|
|
pt2 = pt + vtV * 0.5 * holder.W;
|
|
pt2 += offset;
|
|
holder.W = 2.0 * pt2.distanceTo(pt);
|
|
m_mapSpecXData.SetAt(KEY_W,holder.W);
|
|
}
|
|
}
|
|
else//支撑
|
|
{
|
|
if (nGripIndex == 0)
|
|
{
|
|
pt += offset;
|
|
m_mapSpecXData.SetAt(KEY_POS,pt);
|
|
}
|
|
else if (nGripIndex == 1)//长度
|
|
{
|
|
pt2 = pt + vtL * holder.L;
|
|
pt2 += offset;
|
|
holder.L = pt2.distanceTo(pt);
|
|
m_mapSpecXData.SetAt(KEY_L,holder.L);
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBossHolder::subMoveStretchPointsAt(const AcDbIntArray& indices,const AcGeVector3d& offset)
|
|
{
|
|
if (indices.isEmpty())
|
|
return Acad::eOk;
|
|
|
|
AssertWriteEnabled();
|
|
|
|
AcGeMatrix3d xformM;
|
|
xformM.setToTranslation(offset);
|
|
|
|
AcGePoint3d pt,pt2;
|
|
AcGeVector3d vtL;
|
|
m_mapSpecXData.GetAt(KEY_POS,pt);
|
|
m_mapSpecXData.GetAt(PIPE_DIR,vtL);
|
|
|
|
AcGeVector3d vtV = vtL;
|
|
vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
|
|
vtL.normalize();
|
|
vtV.normalize();
|
|
|
|
if (indices.find(0) != -1)//位置移动
|
|
{
|
|
pt += offset;
|
|
m_mapSpecXData.SetAt(KEY_POS,pt);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
XBossHolder holder;
|
|
memset(&holder, 0, sizeof(XBossHolder));
|
|
GetHolder(holder);
|
|
|
|
if (indices.find(1) != -1)
|
|
{
|
|
pt2 = pt + vtL * holder.L;
|
|
pt2 += offset;
|
|
holder.L = pt2.distanceTo(pt);
|
|
m_mapSpecXData.SetAt(KEY_L,holder.L);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
if (indices.find(2) != -1)
|
|
{
|
|
pt2 = pt + vtV * 0.5 * holder.W;
|
|
pt2 += offset;
|
|
holder.W = 2.0 * pt2.distanceTo(pt);
|
|
m_mapSpecXData.SetAt(KEY_W,holder.W);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
void AecDbBossHolder::GetGripText(int nPos, CString& sText)
|
|
{
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBossHolder::Draw2d(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
//管线系统屏蔽掉
|
|
if ( dc.IsDragging() )
|
|
{
|
|
//return Acad::eOk;
|
|
}
|
|
|
|
//图层
|
|
AcDbObjectId idLay = dc.GetLayerId();
|
|
dc.SetLayer(layerId());
|
|
//dc.SetSelectionMarker(1);
|
|
|
|
int nCrBk = dc.GetColor();
|
|
int nColor = nCrBk;
|
|
if ( m_mapSpecXData.GetAt(_T("COLOR"),nColor) )
|
|
{
|
|
dc.SetColor(nColor);
|
|
}
|
|
|
|
if (Has2DBuffer())
|
|
{
|
|
AcDbEntity* pEnt = NULL;
|
|
const AcDbVoidPtrArray &ar2D = Get2DBuffer();
|
|
for (int i = 0;i < ar2D.length();i++)
|
|
{
|
|
pEnt = (AcDbEntity*)ar2D.at(i);
|
|
//pEnt->setColorIndex(nColor);
|
|
dc.DrawEntity(*pEnt);
|
|
}
|
|
|
|
dc.SetLayer(idLay);
|
|
dc.SetColor(nCrBk);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
XBossHolder holder;
|
|
memset(&holder, 0, sizeof(XBossHolder));
|
|
GetHolder(holder);
|
|
|
|
AcGePoint3d pt;
|
|
AcGeVector3d vtL;
|
|
m_mapSpecXData.GetAt(KEY_POS,pt);
|
|
pt.z = 0.0;
|
|
|
|
m_mapSpecXData.GetAt(PIPE_DIR,vtL);
|
|
|
|
pt.z = 0.0;//2D
|
|
vtL.z = 0.0;//2D
|
|
vtL.normalize();
|
|
AcGeVector3d vtV = vtL;
|
|
vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
|
|
|
|
// 0| |1
|
|
// | |
|
|
// | |
|
|
// | | w
|
|
// pt+ | |
|
|
// | |
|
|
// | |
|
|
// | |
|
|
// 3 |__| 2
|
|
// L
|
|
|
|
//
|
|
AcGePoint3d ptGe[5];
|
|
double dW = 0.0,dL = 0.0;
|
|
if ( holder.nType == 0) //墩
|
|
{
|
|
dL = holder.L;//墩长
|
|
dW = holder.W;//墩宽
|
|
pt -= vtL * 0.5 * dL;//中心
|
|
}
|
|
else//支撑
|
|
{
|
|
dL = holder.W;//角钢宽
|
|
dW = holder.L;//长度
|
|
}
|
|
|
|
|
|
ptGe[0] = pt;
|
|
ptGe[0] += vtV * 0.5 * dW;//中心布置
|
|
|
|
ptGe[1] = ptGe[0] + vtL * dL;
|
|
ptGe[2] = ptGe[1] - vtV * dW;
|
|
|
|
ptGe[3] = ptGe[0] - vtV * dW;
|
|
ptGe[4] = ptGe[0];
|
|
|
|
AcDbPolyline* pPl = FormatPolyline(ptGe,5);
|
|
if (pPl != NULL)
|
|
{
|
|
pPl->setLayer(idLay);
|
|
dc.DrawEntity(pPl);
|
|
Add2DBuffer(pPl);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus AecDbBossHolder::Draw3d(AcGiDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
//管线系统屏蔽掉
|
|
if ( dc.IsDragging() )
|
|
{
|
|
//return Acad::eOk;
|
|
}
|
|
|
|
//图层
|
|
AcDbObjectId idLay = dc.GetLayerId();
|
|
dc.SetLayer(layerId());
|
|
|
|
int nCrBk = dc.GetColor();
|
|
int nColor = nCrBk;
|
|
if ( m_mapSpecXData.GetAt(_T("COLOR"),nColor) )
|
|
{
|
|
dc.SetColor(nColor);
|
|
}
|
|
|
|
if (Has3DBuffer())
|
|
{
|
|
AcDbEntity* pEnt = NULL;
|
|
const AcDbVoidPtrArray &ar3D = Get3DBuffer();
|
|
for (int i = 0;i < ar3D.length();i++)
|
|
{
|
|
pEnt = (AcDbEntity*)ar3D.at(i);
|
|
dc.DrawEntity(*pEnt);
|
|
}
|
|
|
|
dc.SetLayer(idLay);
|
|
dc.SetColor(nCrBk);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
deleteContainerOfStd(m_solids);
|
|
deleteContainerOfStd(m_pipes);
|
|
|
|
XBossHolder holder;
|
|
memset(&holder, 0, sizeof(XBossHolder));
|
|
GetHolder(holder);
|
|
|
|
AcGePoint3d pt;
|
|
AcGeVector3d vtL;
|
|
m_mapSpecXData.GetAt(KEY_POS,pt);
|
|
m_mapSpecXData.GetAt(PIPE_DIR,vtL);
|
|
|
|
vtL.normalize();
|
|
AcGeVector3d vtV = vtL;
|
|
vtV.rotateBy(PI / 2.0,AcGeVector3d::kZAxis);
|
|
|
|
//pt 中含有顶标高
|
|
AcGePoint3d ptTo = pt;
|
|
AcGePoint3d ptFr;
|
|
AcGePoint3d ptGe[5];
|
|
|
|
double dW = 0.0,dL = 0.0,dH = 0.0,dt = 0.0;
|
|
if (holder.nType == 0)//墩
|
|
{
|
|
ptFr = ptTo;
|
|
ptFr.z -= holder.H;
|
|
|
|
dL = holder.L;//长度
|
|
dW = holder.W;//高度
|
|
|
|
double dAngle = AcGeVector3d::kXAxis.angleTo(vtL, AcGeVector3d::kZAxis);
|
|
|
|
AcDb3dSolid* pSolid = Create3dRod(ptFr, ptTo, dL, dW, 2, dAngle);
|
|
if (pSolid != NULL)
|
|
{
|
|
dc.DrawEntity(pSolid);
|
|
Add3DBuffer(pSolid);
|
|
}
|
|
}
|
|
else//支撑架
|
|
{
|
|
dL = holder.L;//长度
|
|
dH = holder.H;//高度
|
|
|
|
int nLay = holder.N;
|
|
|
|
ptFr = pt;//顶部
|
|
ptTo = pt;
|
|
|
|
ptFr += vtV * 0.5 * dL;
|
|
ptTo -= vtV * 0.5 * dL;
|
|
|
|
AcGePoint3d ptL[2];
|
|
ptL[0] = ptFr;
|
|
ptL[1] = ptTo;
|
|
|
|
CStringArray arInf;
|
|
if (_tcsclen(holder.szVs) > 0)
|
|
{
|
|
SplitStrintToArray(holder.szVs,arInf,_T(';'));
|
|
holder.N = arInf.GetSize();
|
|
}
|
|
|
|
//层水平
|
|
AcDb3dSolid* pSolid = NULL;
|
|
for (int i = 0;i <= holder.N;i++)
|
|
{
|
|
if (holder.nType == 2)
|
|
{
|
|
pSolid = Create3dRod(ptL[0], ptL[1], holder.W, holder.B, holder.C, holder.t, 2,-PI/2.0);
|
|
}
|
|
else
|
|
{
|
|
pSolid = Create3dRod(ptL[0], ptL[1], holder.W, holder.t, 1);
|
|
}
|
|
|
|
if (pSolid != NULL)
|
|
{
|
|
dc.DrawEntity(pSolid);
|
|
Add3DBuffer(pSolid);
|
|
}
|
|
|
|
//标准层,最后一层画完,退出
|
|
if (i == (holder.N - 1) && arInf.GetSize() == 0)
|
|
{
|
|
break;
|
|
}
|
|
else if (i == holder.N && arInf.GetSize() > 0)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (arInf.GetSize() > 0)
|
|
{
|
|
ptL[0].z -= _ttof(arInf.GetAt(i));
|
|
ptL[1].z -= _ttof(arInf.GetAt(i));
|
|
}
|
|
else
|
|
{
|
|
ptL[0].z -= holder.V;
|
|
ptL[1].z -= holder.V;
|
|
}
|
|
}
|
|
|
|
ptFr -= 0.5 * holder.W * vtV;
|
|
ptFr -= 0.5 * holder.W * vtL;
|
|
|
|
//Fr侧
|
|
ptL[0] = ptFr;
|
|
ptL[1] = ptFr;
|
|
ptL[0] += 0.5 * holder.W * vtL;
|
|
ptL[1] += 0.5 * holder.W * vtL;
|
|
ptL[0] += 0.5 * holder.W * vtV;
|
|
ptL[1] += 0.5 * holder.W * vtV;
|
|
|
|
ptL[1].z -= dH;
|
|
|
|
if (holder.nType == 2)
|
|
{
|
|
pSolid = Create3dRod(ptL[0], ptL[1], holder.W,holder.B,holder.C,holder.t, 1,PI/2.0);
|
|
}
|
|
else
|
|
{
|
|
pSolid = Create3dRod(ptL[0], ptL[1], holder.W, holder.t, 1);
|
|
}
|
|
|
|
if (pSolid != NULL)
|
|
{
|
|
dc.DrawEntity(pSolid);
|
|
Add3DBuffer(pSolid);
|
|
}
|
|
|
|
//底部固定
|
|
ptGe[0] = ptL[1];
|
|
ptGe[0] -= 2.0 * holder.W * vtL;//两倍宽度长
|
|
ptGe[1] = ptL[1];
|
|
ptGe[1] += 2.0 * holder.W * vtL;//两倍宽度长
|
|
ptGe[0] -= 0.5 * holder.W * vtV;
|
|
ptGe[1] -= 0.5 * holder.W * vtV;
|
|
|
|
pSolid = Create3dRod(ptGe[0], ptGe[1], holder.W, holder.t, 2);
|
|
if (pSolid != NULL)
|
|
{
|
|
dc.DrawEntity(pSolid);
|
|
Add3DBuffer(pSolid);
|
|
}
|
|
|
|
//To侧
|
|
ptTo += 0.5 * holder.W * vtV;
|
|
ptTo -= 0.5 * holder.W * vtL;
|
|
|
|
ptL[0] = ptTo;
|
|
ptL[1] = ptTo;
|
|
ptL[0] += 0.5 * holder.W * vtL;
|
|
ptL[1] += 0.5 * holder.W * vtL;
|
|
ptL[0] += 0.5 * holder.W * vtV;
|
|
ptL[1] += 0.5 * holder.W * vtV;
|
|
|
|
ptL[1].z -= dH;
|
|
if (holder.nType == 2)
|
|
{
|
|
pSolid = Create3dRod(ptL[1], ptL[0], holder.W, holder.B, holder.C, holder.t, 1, -PI / 2.0);
|
|
}
|
|
else
|
|
{
|
|
pSolid = Create3dRod(ptL[1], ptL[0], holder.W, holder.t, 1);
|
|
}
|
|
if (pSolid != NULL)
|
|
{
|
|
dc.DrawEntity(pSolid);
|
|
Add3DBuffer(pSolid);
|
|
}
|
|
|
|
//底部固定
|
|
ptGe[0] = ptL[1];
|
|
ptGe[0] -= 2.0 * holder.W * vtL;//两倍宽度长
|
|
ptGe[1] = ptL[1];
|
|
ptGe[1] += 2.0 * holder.W * vtL;//两倍宽度长
|
|
ptGe[0] -= 0.5 * holder.W * vtV;
|
|
ptGe[1] -= 0.5 * holder.W * vtV;
|
|
|
|
pSolid = Create3dRod(ptGe[0], ptGe[1], holder.W, holder.t, 2);
|
|
if (pSolid != NULL)
|
|
{
|
|
dc.DrawEntity(pSolid);
|
|
Add3DBuffer(pSolid);
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
AecDbObjXDataMap* AecDbBossHolder::GetSpecialtyData(AcDb::OpenMode bMode/* = AcDb::kForWrite*/)
|
|
{
|
|
switch(bMode)
|
|
{
|
|
case AcDb::kForRead:
|
|
{
|
|
assertReadEnabled();
|
|
break;
|
|
}
|
|
case AcDb::kForWrite:
|
|
{
|
|
if (!isWriteEnabled())
|
|
{
|
|
upgradeOpen();
|
|
}
|
|
assertWriteEnabled();
|
|
break;
|
|
}
|
|
case AcDb::kForNotify:
|
|
{
|
|
assertReadEnabled();
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return &m_mapSpecXData;
|
|
}
|
|
|
|
const AecDbObjXDataMap* AecDbBossHolder::GetSpecialtyData() const
|
|
{
|
|
assertReadEnabled();
|
|
return &m_mapSpecXData;
|
|
}
|
|
|
|
AcDb3dSolid *AecDbBossHolder::Create3dRod(const AcGePoint3d &ptFr, const AcGePoint3d &ptTo, double dA, double dB, double dC, double dD, int nShape, double dRegRoate) const
|
|
{
|
|
AcDb3dSolid *pPipe = NULL;
|
|
AcGiViewDraw dcTmp(NULL, NULL);
|
|
|
|
AcGePoint3d ptGe[9], ptGeT;
|
|
ptGeT.set(0, 0, 0);
|
|
|
|
|
|
ptGe[0] = ptGeT + 0.5 * dA * AcGeVector3d::kYAxis;
|
|
ptGe[1] = ptGe[0] + dB * AcGeVector3d::kXAxis;
|
|
ptGe[2] = ptGe[1] - dC * AcGeVector3d::kYAxis;
|
|
ptGe[3] = ptGe[2] - (dB - dD)*AcGeVector3d::kXAxis;
|
|
ptGe[4] = ptGe[3] - (dA - 2.0*dC) * AcGeVector3d::kYAxis;
|
|
ptGe[5] = ptGe[4] + (dB - dD) * AcGeVector3d::kXAxis;
|
|
ptGe[6] = ptGe[5] - dC * AcGeVector3d::kYAxis;
|
|
ptGe[7] = ptGe[6] - dB * AcGeVector3d::kXAxis;
|
|
ptGe[8] = ptGe[0];
|
|
|
|
AcDbRegion *pReg = CreatePolygonRegionOnly(ptGe, 9);
|
|
if (pReg != NULL)
|
|
{
|
|
AecDbEwPipe pipe;
|
|
pipe.SetSection(pReg, AcGePoint3d::kOrigin);
|
|
pipe.SetSectionRotation(dRegRoate);
|
|
pipe.SetStartPoint(ptFr);
|
|
pipe.SetEndPoint(ptTo);
|
|
m_pipes.push_back((AecDbEwPipe *)pipe.clone());
|
|
|
|
pipe.Draw3d(dcTmp);
|
|
pPipe = pipe.GetCreatPipe3dSolid();
|
|
}
|
|
return pPipe;
|
|
}
|
|
|
|
AcDb3dSolid* AecDbBossHolder::Create3dRod(const AcGePoint3d& ptFr,const AcGePoint3d& ptTo,double dL1,double dt,int nShape,double dRegRoate) const
|
|
{
|
|
AcDb3dSolid* pPipe = NULL;
|
|
AcGiViewDraw dcTmp(NULL,NULL);
|
|
if (nShape == 0)//圆杆
|
|
{
|
|
AecDbEwPipe pipe;
|
|
pipe.SetSection(dL1,0.0);
|
|
pipe.SetStartPoint(ptFr);
|
|
pipe.SetEndPoint(ptTo);
|
|
|
|
m_pipes.push_back((AecDbEwPipe*)pipe.clone());
|
|
|
|
pipe.Draw3d(dcTmp);
|
|
pPipe = pipe.GetCreatPipe3dSolid();
|
|
}
|
|
else if(nShape == 1)//角钢
|
|
{
|
|
AecDbEwPipe pipe;
|
|
pipe.SetSection3(dL1,dt);
|
|
pipe.SetSectionRotation(dRegRoate);
|
|
pipe.SetStartPoint(ptFr);
|
|
pipe.SetEndPoint(ptTo);
|
|
m_pipes.push_back((AecDbEwPipe*)pipe.clone());
|
|
|
|
pipe.Draw3d(dcTmp);
|
|
pPipe = pipe.GetCreatPipe3dSolid();
|
|
}
|
|
else if (nShape == 2)//矩形
|
|
{
|
|
AecDbEwPipe pipe;
|
|
pipe.SetSection(dL1,dt,0.0);
|
|
pipe.SetSectionRotation(dRegRoate);
|
|
pipe.SetStartPoint(ptFr);
|
|
pipe.SetEndPoint(ptTo);
|
|
m_pipes.push_back((AecDbEwPipe*)pipe.clone());
|
|
|
|
pipe.Draw3d(dcTmp);
|
|
pPipe = pipe.GetCreatPipe3dSolid();
|
|
}
|
|
return pPipe;
|
|
}
|
|
|
|
int AecDbBossHolder::GetSectionDraw(const AcGePoint3d& ptFr,const AcGePoint3d& ptTo,const AcGeVector3d& vtViewDir,const AcGeVector3d& vtTo, AcDbVoidPtrArray& arRegPtrs) const
|
|
{
|
|
AcGeVector3d vtLn = ptTo - ptFr;
|
|
AcGeVector3d vtNorm = vtLn.crossProduct(vtViewDir);
|
|
|
|
AcGePlane plan;
|
|
plan.set(ptFr,vtNorm);
|
|
|
|
AcGeMatrix3d xform;
|
|
xform.setToPlaneToWorld(plan);
|
|
xform.invert();
|
|
|
|
if (Get3DBuffer().length() == 0)
|
|
{
|
|
AcGiViewDraw dc(NULL,NULL);
|
|
Draw3d(dc);
|
|
}
|
|
|
|
AcDbEntity* pEnt = NULL;
|
|
AcDb3dSolid* pSolid = NULL;
|
|
|
|
const AcDbVoidPtrArray &ar3D = Get3DBuffer();
|
|
for (int i = 0;i < ar3D.length();i++)
|
|
{
|
|
pEnt = (AcDbEntity*)ar3D.at(i);
|
|
|
|
pSolid = AcDb3dSolid::cast(pEnt);
|
|
if (pSolid != NULL)
|
|
{
|
|
//投影法
|
|
OrthoProjected3DSolid(pSolid,plan,xform,arRegPtrs);
|
|
}
|
|
}
|
|
return arRegPtrs.length();
|
|
}
|
|
|
|
CString AecDbBossHolder::getUniqueName() const
|
|
{
|
|
XBossHolder holder;
|
|
::memset(&holder, 0, sizeof(XBossHolder));
|
|
GetHolder(holder);
|
|
|
|
::memset(holder.szNo, 0, MAX_PATH * sizeof(TCHAR));
|
|
::memset(holder.szMat, 0, MAX_PATH * sizeof(TCHAR));
|
|
|
|
return ImpMD5(&holder, sizeof(XBossHolder)).toString16W().c_str();
|
|
}
|
|
|
|
SHJson::WValue &AecDbBossHolder::ToJson(bool bExprotGeo) const
|
|
{
|
|
using namespace SHJson;
|
|
assertReadEnabled();
|
|
|
|
WValue &v = AecDbEntityBase::ToJson(bExprotGeo);
|
|
|
|
if (bExprotGeo)
|
|
{
|
|
AecDbBossHolder *pNew = (AecDbBossHolder*)clone();
|
|
pNew->SetPosition(AcGePoint3d::kOrigin, AcGeVector3d::kXAxis);
|
|
pNew->Clean3DBuffer();
|
|
AcGiViewDraw dc;
|
|
pNew->Draw3d(dc);
|
|
|
|
WValue ar;
|
|
ar.SetArray();
|
|
|
|
for (size_t i(0); i < pNew->m_solids.size(); ++i)
|
|
{
|
|
AcDbX3dSolid *pSolid(pNew->m_solids[i]);
|
|
if (!pSolid) continue;
|
|
WValue &x = pSolid->ToJson();
|
|
pushBack(ar, x);
|
|
}
|
|
if (!pNew->m_solids.empty())
|
|
addMember(v, _T("__solids__"), ar);
|
|
|
|
ar.SetArray();
|
|
for (size_t i(0); i < pNew->m_pipes.size(); ++i)
|
|
{
|
|
AecDbEwPipeBase *pPipe(pNew->m_pipes[i]);
|
|
if (!pPipe) continue;
|
|
WValue &x = pPipe->ToJson();
|
|
pushBack(ar, x);
|
|
}
|
|
if (!pNew->m_pipes.empty())
|
|
addMember(v, _T("__pipes__"), ar);
|
|
|
|
DELETE_PTR(pNew);
|
|
}
|
|
|
|
XBossHolder hanger;
|
|
::memset(&hanger, 0, sizeof(XBossHolder));
|
|
GetHolder(hanger);
|
|
|
|
/*typedef struct XBossHolder {
|
|
int nType;
|
|
double W;//墩宽或角钢宽
|
|
double t;//角钢厚度t 墩厚度
|
|
double L;//长
|
|
int N;
|
|
double V;//垂直层间距
|
|
TCHAR szVs[MAX_PATH];//不等层的间距集合;隔开
|
|
double H;//支撑高度 > nLay * V
|
|
TCHAR szMat[MAX_PATH];
|
|
TCHAR szNo[MAX_PATH]; }XBossHolder;*/
|
|
|
|
WValue data;
|
|
addMember(data, _T("__nType__"), hanger.nType);
|
|
addMember(data, _T("__W__"), hanger.W);
|
|
addMember(data, _T("__t__"), hanger.t);
|
|
addMember(data, _T("__L__"), hanger.L);
|
|
addMember(data, _T("__N__"), hanger.N);
|
|
addMember(data, _T("__V__"), hanger.V);
|
|
addMember(data, _T("__H__"), hanger.H);
|
|
addMember(data, _T("__szVs__"), hanger.szVs);
|
|
addMember(data, _T("__szMat__"), hanger.szMat);
|
|
addMember(data, _T("__szNo__"), hanger.szNo);
|
|
addMember(v, _T("_bosshangerData_"), data);
|
|
|
|
return v;
|
|
}
|