1488 lines
35 KiB
C++
1488 lines
35 KiB
C++
//------------------------------------------------------------------------+
|
|
// Copyright (C), 1998-2012, Beijing Tangent Software Co. Ltd.
|
|
// = FileName : TDbStruBarBase类
|
|
// = Version : ver1.0
|
|
// = Author : zyc
|
|
// = CreateDate : 2012-11-02
|
|
// = Description: 条形基础平面图类定义
|
|
// = Maintainers:
|
|
//
|
|
//------------------------------------------------------------------------+
|
|
#include "stdafx.h"
|
|
#ifdef TASD
|
|
#include "TDbStruBarBase.h"
|
|
#include "TAsdKeyDefine.h"
|
|
#include "TConfigInfo.h"
|
|
#include "TBaseWallIntegrateTool.h"
|
|
|
|
extern void AddMsg(const TAssocMsg& assocMsg);
|
|
extern bool g_bModifyAgain;
|
|
|
|
const Adesk::UInt8 TDbStruBarBase::g_nVersion = 1;
|
|
ACRX_DXF_DEFINE_MEMBERS(ATSStruBarBase, ATSBaseWall, AcDb::kDHL_CURRENT,
|
|
AcDb::kMReleaseCurrent, 1, ATS_STRUBARBASE,
|
|
"ATS_STRUBARBASE图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
|
|
IMPLEMENT_TENTBASE(TDbStruBarBase);
|
|
|
|
TDbStruBarBase::TDbStruBarBase()
|
|
{
|
|
SetAt(KEY_WEIGHT, 1);
|
|
SetAt(KEY_H, 1000);
|
|
SetAt(KEY_BULGE, 0.0);
|
|
}
|
|
|
|
TDbStruBarBase::~TDbStruBarBase()
|
|
{
|
|
}
|
|
|
|
Acad::ErrorStatus TDbStruBarBase::dwgInFields (AcDbDwgFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
Acad::ErrorStatus es = TDbBaseWall::dwgInFields(pFiler);
|
|
if (es != Acad::eOk)
|
|
{
|
|
return es;
|
|
}
|
|
|
|
Adesk::UInt8 nVer;
|
|
pFiler->readItem(&nVer);
|
|
if (nVer > g_nVersion)
|
|
{
|
|
return Acad::eMakeMeProxy;
|
|
}
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbStruBarBase::dwgOutFields(AcDbDwgFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es = TDbBaseWall::dwgOutFields(pFiler);
|
|
if (es != Acad::eOk)
|
|
{
|
|
return es;
|
|
}
|
|
|
|
pFiler->writeItem(g_nVersion);
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbStruBarBase::subGetOsnapPoints(AcDb::OsnapMode osnapMode,
|
|
INT_PTR gsSelectionMark,
|
|
const AcGePoint3d& pickPoint,
|
|
const AcGePoint3d& lastPoint,
|
|
const AcGeMatrix3d& viewXform,
|
|
AcGePoint3dArray& snapPoints,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
assertReadEnabled();
|
|
return TDbBaseWall::subGetOsnapPoints(osnapMode, gsSelectionMark, pickPoint, lastPoint, viewXform, snapPoints, geomIds);
|
|
}
|
|
|
|
Acad::ErrorStatus TDbStruBarBase::subTransformBy(const AcGeMatrix3d& xform)
|
|
{
|
|
assertWriteEnabled();
|
|
Acad::ErrorStatus es = TDbBaseWall::subTransformBy(xform);
|
|
|
|
// 拖拽结束时发送消息
|
|
if (objectId() && g_bMonitorDbAction)
|
|
{
|
|
TAssocMsg msg;
|
|
msg.SetMethod(TAssocMsg::kTransform);
|
|
msg.SetMatrix(xform);
|
|
msg.SetAssocId(objectId());
|
|
|
|
AddMsg(msg);
|
|
}
|
|
return es;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbStruBarBase::subGetGripPoints(AcGePoint3dArray& gripPoints,
|
|
AcDbIntArray& osnapModes,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
assertReadEnabled();
|
|
AcGePoint3d ptStart, ptEnd, ptMid;
|
|
GetAt(KEY_START, ptStart);
|
|
GetAt(KEY_END, ptEnd);
|
|
|
|
double dBulge = 0.0;
|
|
GetAt(KEY_BULGE, dBulge);
|
|
if (fabs(dBulge) < g_fZero) // 直线
|
|
{
|
|
Midpoint(ptStart, ptEnd, ptMid);
|
|
}
|
|
else // 弧线
|
|
{
|
|
TGGeArc arc(ptStart, ptEnd, dBulge);
|
|
ptMid = arc.MidPoint().AsAcGePoint3d();
|
|
}
|
|
|
|
gripPoints.append(ptStart);
|
|
gripPoints.append(ptEnd);
|
|
gripPoints.append(ptMid);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbStruBarBase::subGetStretchPoints(AcGePoint3dArray& stretchPoints) const
|
|
{
|
|
assertReadEnabled();
|
|
AcDbIntArray osnapModes;
|
|
AcDbIntArray geomIds;
|
|
return subGetGripPoints(stretchPoints, osnapModes, geomIds);
|
|
}
|
|
|
|
// 独立移动
|
|
void TDbStruBarBase::SingleMove(const AcDbIntArray& indices, const AcGeVector3d& offset)
|
|
{
|
|
double dBulge = 0.0;
|
|
AcGePoint3d ptStart, ptEnd;
|
|
GetAt(KEY_START, ptStart);
|
|
GetAt(KEY_END, ptEnd);
|
|
GetAt(KEY_BULGE, dBulge);
|
|
|
|
int nIndex = indices[0];
|
|
AcGeVector3d vtOffset = offset;
|
|
vtOffset.z = 0;
|
|
switch (nIndex)
|
|
{
|
|
case 0: // 起点
|
|
ptStart += vtOffset;
|
|
SetAt(KEY_START, ptStart);
|
|
break;
|
|
case 1: // 终点
|
|
ptEnd += vtOffset;
|
|
SetAt(KEY_END, ptEnd);
|
|
break;
|
|
case 2: // 中点
|
|
default:
|
|
if (fabs(dBulge) < g_fZero) // 直线
|
|
{
|
|
ptStart += vtOffset;
|
|
ptEnd += vtOffset;
|
|
SetAt(KEY_START, ptStart);
|
|
SetAt(KEY_END, ptEnd);
|
|
}
|
|
else // 弧线
|
|
{
|
|
TADSGePoint3d ptMid;
|
|
TGGeArc arc(ptStart, ptEnd, dBulge);
|
|
ptMid = arc.MidPoint();
|
|
ptMid += vtOffset;
|
|
|
|
TGGeArc arcNew(ptStart, ptMid, ptEnd); // 移动后的新弧
|
|
TADSGePoint3d ptS, ptE;
|
|
arcNew.GetStartPoint(ptS);
|
|
arcNew.GetEndPoint(ptE);
|
|
SetAt(KEY_START, ptS.AsAcGePoint3d());
|
|
SetAt(KEY_END, ptE.AsAcGePoint3d());
|
|
SetAt(KEY_BULGE, (double)arcNew.Bulge());
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
// 关联移动
|
|
void TDbStruBarBase::AssociateMove(const AcDbIntArray& indices, const AcGeVector3d& offset)
|
|
{
|
|
double dBulge;
|
|
AcGePoint3d ptStart, ptEnd;
|
|
GetAt(KEY_START, ptStart);
|
|
GetAt(KEY_END, ptEnd);
|
|
GetAt(KEY_BULGE, dBulge);
|
|
|
|
// 是否是直线
|
|
bool bIsStraight = false;
|
|
if (fabs(dBulge) < g_fZero)
|
|
{
|
|
bIsStraight = true;
|
|
}
|
|
|
|
AcGeVector3d vtOffset = offset;
|
|
vtOffset.z = 0.0;
|
|
|
|
int nIndex = indices[0];
|
|
switch (nIndex)
|
|
{
|
|
case 0: // 起点
|
|
if (bIsStraight)
|
|
{
|
|
TGGeLine line(asDblArray(ptStart), asDblArray(ptEnd));
|
|
TADSGePoint3d ptMoved(ptStart);
|
|
ptMoved += vtOffset;
|
|
ptMoved.Project(&line, ptMoved);
|
|
SetAt(KEY_START, ptMoved.AsAcGePoint3d());
|
|
}
|
|
else
|
|
{
|
|
TADSGePoint3d ptMid;
|
|
TGGeArc arc(ptStart, ptEnd, dBulge);
|
|
ptMid = arc.MidPoint();
|
|
|
|
TADSGePoint3d ptCenter;
|
|
arc.Center(ptCenter);
|
|
TGGeCircle circle(ptCenter, arc.GetRadius());
|
|
|
|
ptStart += vtOffset;
|
|
TADSGePoint3d ptTemp;
|
|
TADSGePoint3d(ptStart).Project(&circle, ptTemp);
|
|
ptStart = ptTemp.AsAcGePoint3d();
|
|
arc.Set(ptStart, ptMid, ptEnd);
|
|
|
|
SetAt(KEY_START, ptStart);
|
|
SetAt(KEY_BULGE, arc.Bulge());
|
|
}
|
|
break;
|
|
case 1: // 终点
|
|
if (bIsStraight)
|
|
{
|
|
TGGeLine line(asDblArray(ptStart), asDblArray(ptEnd));
|
|
TADSGePoint3d ptMoved(ptEnd);
|
|
ptMoved += vtOffset;
|
|
ptMoved.Project(&line, ptMoved);
|
|
SetAt(KEY_END, ptMoved.AsAcGePoint3d());
|
|
}
|
|
else
|
|
{
|
|
TADSGePoint3d ptMid;
|
|
TGGeArc arc(ptStart, ptEnd, dBulge);
|
|
ptMid = arc.MidPoint();
|
|
|
|
TADSGePoint3d ptCenter;
|
|
arc.Center(ptCenter);
|
|
TGGeCircle circle(ptCenter, arc.GetRadius());
|
|
|
|
ptEnd += vtOffset;
|
|
TADSGePoint3d ptTemp;
|
|
TADSGePoint3d(ptEnd).Project(&circle, ptTemp);
|
|
ptEnd = ptTemp.AsAcGePoint3d();
|
|
arc.Set(ptStart, ptMid, ptEnd);
|
|
|
|
SetAt(KEY_END, ptEnd);
|
|
SetAt(KEY_BULGE, arc.Bulge());
|
|
}
|
|
break;
|
|
case 2: // 中点
|
|
default:
|
|
if (bIsStraight)
|
|
{
|
|
TGGeLine line(asDblArray(ptStart), asDblArray(ptEnd));
|
|
TADSGePoint3d pt = ptStart + vtOffset, pt2;
|
|
pt.Project(&line, pt2);
|
|
vtOffset = pt - pt2;
|
|
|
|
ptStart += vtOffset;
|
|
ptEnd += vtOffset;
|
|
SetAt(KEY_START, ptStart);
|
|
SetAt(KEY_END, ptEnd);
|
|
|
|
// 拖拽结束时发送消息
|
|
if (objectId())
|
|
{
|
|
TAssocMsg msg;
|
|
msg.SetMethod(TAssocMsg::kMovegrippoint);
|
|
msg.SetTarget(line.MidPoint());
|
|
msg.SetOffset(vtOffset);
|
|
msg.SetAssocId(objectId());
|
|
|
|
AddMsg(msg);
|
|
}
|
|
}
|
|
else //弧线 改变半径
|
|
{
|
|
TADSGePoint3d ptMid;
|
|
TGGeArc arc(ptStart, ptEnd, dBulge);
|
|
ptMid = arc.MidPoint();
|
|
TADSGePoint3d ptCenter;
|
|
arc.Center(ptCenter);
|
|
TGGeLine line(ptCenter, ptMid);
|
|
ptMid += vtOffset;
|
|
ptMid.Project(&line, ptMid);
|
|
if (ptMid.Distance(ptCenter) > _DIST_SNAP)
|
|
{
|
|
AcGeVector3d vt1 = ptStart - ptCenter.AsAcGePoint3d(), vt2 = ptEnd - ptCenter.AsAcGePoint3d();
|
|
double dAngle = vt1.angleTo(vt2, AcGeVector3d::kZAxis);
|
|
vt1 = ptMid - ptCenter;
|
|
ptStart = ptCenter + vt1.rotateBy(-dAngle * 0.5, AcGeVector3d::kZAxis);
|
|
ptEnd = ptCenter + vt1.rotateBy(dAngle, AcGeVector3d::kZAxis);
|
|
arc.Set(ptStart, ptMid, ptEnd);
|
|
SetAt(KEY_START, ptStart);
|
|
SetAt(KEY_END, ptEnd);
|
|
SetAt(KEY_BULGE, arc.Bulge());
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus TDbStruBarBase::subMoveGripPointsAt(const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
if (GetCtrlToggle())
|
|
{
|
|
SingleMove(indices, offset); // 单独移动
|
|
}
|
|
else
|
|
{
|
|
AssociateMove(indices, offset);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbStruBarBase::subMoveStretchPointsAt(const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
assertWriteEnabled();
|
|
return subMoveGripPointsAt(indices, offset);
|
|
}
|
|
|
|
Acad::ErrorStatus TDbStruBarBase::subGetClassID(CLSID* pClsid) const
|
|
{
|
|
#if (ADS >= 17)
|
|
assertReadEnabled();
|
|
#endif
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbStruBarBase::subDeepClone(AcDbObject* pOwner,
|
|
AcDbObject*& pClonedObject,
|
|
AcDbIdMapping& idMap,
|
|
Adesk::Boolean isPrimary) const
|
|
{
|
|
assertReadEnabled();
|
|
return TDbBaseWall::subDeepClone(pOwner, pClonedObject, idMap, isPrimary);
|
|
}
|
|
|
|
Acad::ErrorStatus TDbStruBarBase::subWblockClone(AcRxObject* pOwner,
|
|
AcDbObject*& pClonedObject,
|
|
AcDbIdMapping& idMap,
|
|
Adesk::Boolean isPrimary) const
|
|
{
|
|
assertReadEnabled();
|
|
return TDbBaseWall::subWblockClone(pOwner, pClonedObject, idMap, isPrimary);
|
|
}
|
|
|
|
Acad::ErrorStatus TDbStruBarBase::subIntersectWith(const AcDbEntity* ent,
|
|
AcDb::Intersect intType,
|
|
AcGePoint3dArray& points,
|
|
INT_PTR thisGsMarker,
|
|
INT_PTR otherGsMarker) const
|
|
{
|
|
assertReadEnabled();
|
|
return TDbBaseWall::subIntersectWith(ent, intType, points, thisGsMarker, otherGsMarker);
|
|
}
|
|
|
|
Acad::ErrorStatus TDbStruBarBase::subIntersectWith(const AcDbEntity* ent,
|
|
AcDb::Intersect intType,
|
|
const AcGePlane& projPlane,
|
|
AcGePoint3dArray& points,
|
|
INT_PTR thisGsMarker,
|
|
INT_PTR otherGsMarker) const
|
|
{
|
|
assertReadEnabled();
|
|
return TDbBaseWall::subIntersectWith(ent, intType, projPlane, points, thisGsMarker, otherGsMarker);
|
|
}
|
|
|
|
|
|
// TEntityBase
|
|
// 夹点提示
|
|
Acad::ErrorStatus TDbStruBarBase::GetGripText(int i, CString &cs) const
|
|
{
|
|
bool bIsArc = true;
|
|
double dBulge = 0.0;
|
|
GetAt(KEY_BULGE, dBulge);
|
|
if (fabs(dBulge) < g_fZero) // 直线
|
|
{
|
|
bIsArc = false;
|
|
}
|
|
|
|
Acad::ErrorStatus es=Acad::eOk;
|
|
if (GetCtrlToggle()) // 单独移动
|
|
{
|
|
switch(i)
|
|
{
|
|
case 0:
|
|
case 1:
|
|
cs=_T("改变位置");
|
|
break;
|
|
case 2:
|
|
if (bIsArc)
|
|
{
|
|
cs=_T("改变位置");
|
|
}
|
|
else
|
|
{
|
|
cs=_T("独立平行移动");
|
|
}
|
|
break;
|
|
default:
|
|
es=Acad::eInvalidInput;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch(i)
|
|
{
|
|
case 0:
|
|
case 1:
|
|
if (bIsArc)
|
|
{
|
|
cs=_T("沿弧伸缩");
|
|
}
|
|
else
|
|
{
|
|
cs=_T("沿条基方向拉伸缩短");
|
|
}
|
|
break;
|
|
case 2:
|
|
if (bIsArc)
|
|
{
|
|
cs=_T("改变半径");
|
|
}
|
|
else
|
|
{
|
|
cs=_T("关联平行移动");
|
|
}
|
|
break;
|
|
default:
|
|
es=Acad::eInvalidInput;
|
|
break;
|
|
}
|
|
}
|
|
return es;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbStruBarBase::ExplodeOrDraw3d(TGGiExplodeDrawBase &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// 基础平行时，获得封口线，poly的0索引点与左条形基础线起点或终点重合
|
|
void TDbStruBarBase::GetSideLine2d(bool bStart, const AcDbObjectId &idWall, const TBaseWallLine &wallLine, TGGeVisibilityPoly2D &poly) const
|
|
{
|
|
poly.Reset();
|
|
TDbStruBarBase *pWall = NULL;
|
|
acdbOpenObject(pWall, idWall, AcDb::kForRead);
|
|
if (pWall != NULL)
|
|
{
|
|
TBaseWallLine bwlThat;
|
|
pWall->GetThisBaseWallLine(bwlThat);
|
|
int nThatWeight = 0;
|
|
pWall->GetAt(KEY_WEIGHT, nThatWeight);
|
|
pWall->close();
|
|
|
|
// 判断基础融合方式
|
|
TADSGePoint3d ptThat1,ptThat2;
|
|
TBaseWallLine bwlThis;
|
|
GetThisBaseWallLine(bwlThis);
|
|
int nType = TBaseWallIntegrateTool::IsIntegrateAtTail(bwlThat, bwlThis);
|
|
if (nType == 1) // 起始端相交
|
|
{
|
|
TGGeVisibilityPoly2D leftThat = bwlThat.GetLeftLine();
|
|
TGGeVisibilityPoly2D rightThat = bwlThat.GetRightLine();
|
|
ptThat1 = *leftThat[0];
|
|
ptThat2 = *rightThat[0];
|
|
}
|
|
else if (nType == 2) // 终止端相交
|
|
{
|
|
TGGeVisibilityPoly2D leftThat = bwlThat.GetLeftLine();
|
|
TGGeVisibilityPoly2D rightThat = bwlThat.GetRightLine();
|
|
ptThat1 = *leftThat[leftThat.Length() - 1];
|
|
ptThat2 = *rightThat[leftThat.Length() - 1];
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!!ptThat1 && !!ptThat2)
|
|
{
|
|
TADSGePoint3d ptThis1,ptThis2;
|
|
TGGeVisibilityPoly2D leftThis = bwlThis.GetLeftLine();
|
|
TGGeVisibilityPoly2D rightThis = bwlThis.GetRightLine();
|
|
if (bStart)
|
|
{
|
|
ptThis1 = *leftThis[0];
|
|
ptThis2 = *rightThis[0];
|
|
}
|
|
else
|
|
{
|
|
ptThis1 = *leftThis[leftThis.Length() - 1];
|
|
ptThis2 = *rightThis[rightThis.Length() - 1];
|
|
}
|
|
|
|
AcGeVector3d vtThat = ptThat1 - ptThat2;
|
|
AcGeVector3d vtThis = ptThis1 - ptThis2;
|
|
int nThisWeight = 0;
|
|
GetAt(KEY_WEIGHT, nThisWeight);
|
|
if (vtThis.isParallelTo(vtThat)) // 端点连线平行
|
|
{
|
|
if (nThisWeight < nThatWeight) // 比较优先级
|
|
{
|
|
poly.AppendNode(ptThis1);
|
|
poly.AppendNode(ptThis2);
|
|
}
|
|
else
|
|
{
|
|
bool bSuperposition = (ptThat1.Distance(ptThis1) < _DIST_SNAP && ptThat2.Distance(ptThis2) < _DIST_SNAP)
|
|
|| (ptThat1.Distance(ptThis2) < _DIST_SNAP && ptThat2.Distance(ptThis1) < _DIST_SNAP); // 融合端点两两重合
|
|
if (!bSuperposition)
|
|
{
|
|
// 将that的融合端点投影到this融合端点连线的直线上
|
|
std::vector<TADSGePoint3d> vecPt;
|
|
vecPt.push_back(ptThis1);
|
|
vecPt.push_back(ptThis2);
|
|
TADSGePoint3d pt;
|
|
TGGeLine line(ptThis1, ptThis2);
|
|
ptThat1.Project(&line, pt);
|
|
vecPt.push_back(pt);
|
|
ptThat2.Project(&line, pt);
|
|
vecPt.push_back(pt);
|
|
|
|
// 求两点间的距离
|
|
std::map<double, std::vector<TADSGePoint3d> > mapData;
|
|
std::vector<TADSGePoint3d> vecTemp;
|
|
std::vector<TADSGePoint3d>::iterator it1, it2;
|
|
for (it1 = vecPt.begin(); it1 != vecPt.end(); it1++)
|
|
{
|
|
it2 = it1;
|
|
++it2;
|
|
for (; it2 != vecPt.end(); it2++)
|
|
{
|
|
vecTemp.clear();
|
|
vecTemp.push_back(*it1);
|
|
vecTemp.push_back(*it2);
|
|
mapData.insert(std::make_pair((*it1).Distance(*it2), vecTemp));
|
|
}
|
|
}
|
|
|
|
// 获取距离最远的点
|
|
std::map<double, std::vector<TADSGePoint3d> >::iterator it;
|
|
it = mapData.end();
|
|
--it;
|
|
vecTemp.clear();
|
|
vecTemp.push_back((*it).second[0]);
|
|
vecTemp.push_back((*it).second[1]);
|
|
|
|
// 从vecPt中删除最远的两点
|
|
for (it1 = vecTemp.begin(); it1 != vecTemp.end(); it1++)
|
|
{
|
|
for (it2 = vecPt.begin(); it2 != vecPt.end(); it2++)
|
|
{
|
|
if ((*it1).Distance(*it2) < _DIST_SNAP)
|
|
{
|
|
vecPt.erase(it2);
|
|
break;;
|
|
}
|
|
}
|
|
}
|
|
|
|
// this的融合端点是否与最远点重合
|
|
if (ptThis1.Distance(vecTemp[0]) < _DIST_SNAP || ptThis1.Distance(vecTemp[1]) < _DIST_SNAP)
|
|
{
|
|
double dDist1 = ptThis1.Distance(vecPt[0]);
|
|
double dDist2 = ptThis1.Distance(vecPt[1]);
|
|
if (dDist1 < dDist2)
|
|
{
|
|
poly.AppendNode(ptThis1);
|
|
poly.AppendNode(vecPt[0], 0.0, AcDb::kInvisible);
|
|
}
|
|
else
|
|
{
|
|
poly.AppendNode(ptThis1);
|
|
poly.AppendNode(vecPt[1], 0.0, AcDb::kInvisible);
|
|
}
|
|
}
|
|
|
|
if (ptThis2.Distance(vecTemp[0]) < _DIST_SNAP || ptThis2.Distance(vecTemp[1]) < _DIST_SNAP)
|
|
{
|
|
double dDist1 = ptThis2.Distance(vecPt[0]);
|
|
double dDist2 = ptThis2.Distance(vecPt[1]);
|
|
if (dDist1 < dDist2)
|
|
{
|
|
poly.AppendNode(vecPt[0]);
|
|
poly.AppendNode(ptThis2);
|
|
}
|
|
else
|
|
{
|
|
poly.AppendNode(vecPt[1]);
|
|
poly.AppendNode(ptThis2);
|
|
}
|
|
}
|
|
|
|
if (poly.Length() == 0)
|
|
{
|
|
poly.AppendNode(ptThis1, 0.0, AcDb::kInvisible);
|
|
poly.AppendNode(ptThis2, 0.0, AcDb::kInvisible);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (nThatWeight != nThisWeight) // 优先级不同
|
|
{
|
|
TGGeVisibilityPoly2D left = wallLine.GetLeftLine();
|
|
TGGeVisibilityPoly2D right = wallLine.GetRightLine();
|
|
if (bStart)
|
|
{
|
|
poly.AppendNode(*left[0]);
|
|
poly.AppendNode(*right[0]);
|
|
}
|
|
else
|
|
{
|
|
poly.AppendNode(*left[left.Length() - 1]);
|
|
poly.AppendNode(*right[right.Length() - 1]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 融合后生成的TGGeVisibilityPoly2D
|
|
void TDbStruBarBase::GetIntegratedPoly2d(TGGeVisibilityPoly2D &poly) const
|
|
{
|
|
// 双线绘制样式
|
|
TBaseWallLine bwlThis;
|
|
GetThisBaseWallLine(bwlThis);
|
|
|
|
// 融合基础
|
|
TDPtrList<TBaseWallLine> arBaseWallLinesS, arBaseWallLinesM, arBaseWallLinesE;
|
|
GetAssocBaseWallLine(arBaseWallLinesS, arBaseWallLinesM, arBaseWallLinesE);
|
|
// 起点融合
|
|
TBaseWallIntegrateTool::IntegrateAtTail(true, bwlThis, arBaseWallLinesS);
|
|
// 终点融合
|
|
TBaseWallIntegrateTool::IntegrateAtTail(false, bwlThis, arBaseWallLinesE);
|
|
// 基础内融合
|
|
int i;
|
|
for (i = 0; i < arBaseWallLinesM.Length(); i++)
|
|
{
|
|
TBaseWallIntegrateTool::Integrate(bwlThis,*arBaseWallLinesM[i]);
|
|
}
|
|
|
|
// 生成poly2d
|
|
// 添加左线
|
|
TGGeVisibilityPoly2D left, right;
|
|
left = bwlThis.GetLeftLine();
|
|
right = bwlThis.GetRightLine();
|
|
for (i = 0; i < left.Length(); i++)
|
|
{
|
|
poly.AppendNode(*left[i], *(left.m_ardbulges[i]), left.GetVisibleAt(i));
|
|
}
|
|
|
|
// 添加终点封口线
|
|
int nLen = arBaseWallLinesE.Length();
|
|
if (nLen == 0) // 终点封口
|
|
{
|
|
if (!(left.GetVisibleAt(left.Length() - 2) == AcDb::kInvisible && right.GetVisibleAt(right.Length() - 2) == AcDb::kInvisible))
|
|
{
|
|
poly.AppendNode(*left[left.Length() - 1]);
|
|
poly.AppendNode(*right[right.Length() - 1]);
|
|
}
|
|
}
|
|
else if (nLen == 1) // 处理终点处有一个融合基础时，基础端点两点连线平行的情况
|
|
{
|
|
AcDbObjectId id;
|
|
GetWallId(false, id);
|
|
TGGeVisibilityPoly2D polyNew;
|
|
GetSideLine2d(false, id, bwlThis, polyNew);
|
|
polyNew.Compress();
|
|
for (int i = 0; i < polyNew.Length(); i++)
|
|
{
|
|
poly.AppendNode(*polyNew[i], *(polyNew.m_ardbulges[i]), polyNew.GetVisibleAt(i));
|
|
}
|
|
|
|
if (polyNew.Length() == 0)
|
|
{
|
|
poly.InsertNodeAt(*left[left.Length() - 1], AcDb::kInvisible); // 改变点的可见性
|
|
}
|
|
}
|
|
else
|
|
{
|
|
poly.InsertNodeAt(*left[left.Length() - 1], AcDb::kInvisible); // 改变点的可见性
|
|
}
|
|
|
|
// 添加右线
|
|
right.Reverse();
|
|
for (i = 0; i < right.Length(); i++)
|
|
{
|
|
poly.AppendNode(*right[i], *(right.m_ardbulges[i]), right.GetVisibleAt(i));
|
|
}
|
|
|
|
// 添加起点封口线
|
|
nLen = arBaseWallLinesS.Length();
|
|
if (nLen == 0) // 起点封口
|
|
{
|
|
if (!(left.GetVisibleAt(0) == AcDb::kInvisible && right.GetVisibleAt(0) == AcDb::kInvisible))
|
|
{
|
|
poly.AppendNode(*right[right.Length() - 1]); // right 已逆转方向
|
|
poly.AppendNode(*left[0]);
|
|
}
|
|
}
|
|
else if (nLen == 1) // 处理起点处有一个融合基础时，基础端点两点连线平行的情况
|
|
{
|
|
AcDbObjectId id;
|
|
GetWallId(true, id);
|
|
TGGeVisibilityPoly2D polyNew;
|
|
GetSideLine2d(true, id, bwlThis, polyNew);
|
|
polyNew.Compress();
|
|
polyNew.Reverse();
|
|
for (int i = 0; i < polyNew.Length(); i++)
|
|
{
|
|
poly.AppendNode(*polyNew[i], *(polyNew.m_ardbulges[i]), polyNew.GetVisibleAt(i));
|
|
}
|
|
|
|
if (polyNew.Length() == 0)
|
|
{
|
|
poly.InsertNodeAt(*right[right.Length() - 1], AcDb::kInvisible); // 改变点的可见性
|
|
}
|
|
}
|
|
else
|
|
{
|
|
poly.InsertNodeAt(*right[right.Length() - 1], AcDb::kInvisible); // 改变点的可见性
|
|
}
|
|
|
|
poly.SetClosed();
|
|
}
|
|
|
|
// 绘制加粗的线
|
|
Acad::ErrorStatus TDbStruBarBase::DrawWeightLine2d(TGGiExplodeDrawBase &dc) const
|
|
{
|
|
// 获取融合后的poly2d
|
|
TGGeVisibilityPoly2D poly;
|
|
GetIntegratedPoly2d(poly);
|
|
poly.Compress();
|
|
|
|
DrawWeightLine2d(dc, poly, true);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbStruBarBase::DrawWeightLine2d(TGGiExplodeDrawBase &dc, TGGeVisibilityPoly2D &poly, bool bVal) const
|
|
{
|
|
int nNum = 1;
|
|
if (!bVal)
|
|
{
|
|
nNum = -1;
|
|
}
|
|
|
|
double dLineWidth = DocGetConWallLWeight()*GetPScale();
|
|
TGGePoly2D polyDest;
|
|
if (poly.PathArea() > 0) // 顺时针
|
|
{
|
|
poly.Offset(dLineWidth * nNum, polyDest);
|
|
}
|
|
else
|
|
{
|
|
poly.Offset(dLineWidth * (-1) * nNum, polyDest);
|
|
}
|
|
|
|
if (poly.Length() != polyDest.Length())
|
|
{
|
|
return Acad::eInvalidInput;
|
|
}
|
|
|
|
TGGePoly2D poly2dNew;
|
|
for (int i = 0; i < poly.Length() - 1; i++)
|
|
{
|
|
if (poly.GetVisibleAt(i) == AcDb::kInvisible)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
poly2dNew.Reset();
|
|
poly2dNew.AppendNode(*poly[i], *(poly.m_ardbulges[i]));
|
|
poly2dNew.AppendNode(*poly[i+1]);
|
|
poly2dNew.AppendNode(*polyDest[i+1], *(polyDest.m_ardbulges[i]) * (-1));
|
|
poly2dNew.AppendNode(*polyDest[i]);
|
|
poly2dNew.SetClosed();
|
|
dc << TGGeSolid(poly2dNew);
|
|
}
|
|
|
|
if (poly.GetVisibleAt(poly.Length() - 1) == AcDb::kVisible)
|
|
{
|
|
poly2dNew.Reset();
|
|
poly2dNew.AppendNode(*poly[poly.Length() - 1], *(poly.m_ardbulges[poly.Length() - 1]));
|
|
poly2dNew.AppendNode(*poly[0]);
|
|
poly2dNew.AppendNode(*polyDest[0], *(polyDest.m_ardbulges[polyDest.Length() - 1]) * (-1));
|
|
poly2dNew.AppendNode(*polyDest[polyDest.Length() - 1]);
|
|
poly2dNew.SetClosed();
|
|
dc << TGGeSolid(poly2dNew);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbStruBarBase::ExplodeOrDraw2d(TGGiExplodeDrawBase &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
// 加粗
|
|
if (DocGetIsLineWeight() && DocGetWallIsLW())
|
|
{
|
|
DrawWeightLine2d(dc);
|
|
}
|
|
|
|
// 绘制线
|
|
TBaseWallLine bwlThis;
|
|
GetThisBaseWallLine(bwlThis);
|
|
|
|
TDPtrList<TBaseWallLine> arBaseWallLinesStart, arBaseWallLinesMid, arBaseWallLinesEnd;
|
|
GetAssocBaseWallLine(arBaseWallLinesStart, arBaseWallLinesMid, arBaseWallLinesEnd);
|
|
|
|
TBaseWallIntegrateTool::IntegrateAtTail(true, bwlThis, arBaseWallLinesStart);
|
|
TBaseWallIntegrateTool::IntegrateAtTail(false, bwlThis, arBaseWallLinesEnd);
|
|
int i;
|
|
for (i=0; i<arBaseWallLinesMid.Length(); i++)
|
|
{
|
|
TBaseWallIntegrateTool::Integrate(bwlThis, *arBaseWallLinesMid[i]);
|
|
}
|
|
|
|
TGGeVisibilityPoly2D left, right;
|
|
left = bwlThis.GetLeftLine();
|
|
right = bwlThis.GetRightLine();
|
|
DrawBaseWall2d(dc, left, true);
|
|
DrawBaseWall2d(dc, right, false);
|
|
|
|
// 封闭基础端点处封口
|
|
int nLen = arBaseWallLinesStart.Length();
|
|
if (nLen == 0)
|
|
{
|
|
if (!(left.GetVisibleAt(0) == AcDb::kInvisible &&
|
|
right.GetVisibleAt(0) == AcDb::kInvisible))
|
|
{
|
|
dc << TGGeLine(*left[0], *right[0]);
|
|
}
|
|
}
|
|
else if (nLen == 1)
|
|
{
|
|
AcDbObjectId idWall;
|
|
GetWallId(true, idWall);
|
|
DrawSideLine2d(true, idWall, bwlThis, dc);
|
|
}
|
|
|
|
nLen = arBaseWallLinesEnd.Length();
|
|
if (nLen == 0)
|
|
{
|
|
if (!(left.GetVisibleAt(left.Length() - 2) == AcDb::kInvisible &&
|
|
right.GetVisibleAt(right.Length() - 2) == AcDb::kInvisible))
|
|
{
|
|
dc << TGGeLine(*left[left.Length() - 1], *right[right.Length() - 1]);
|
|
}
|
|
}
|
|
else if (nLen == 1)
|
|
{
|
|
AcDbObjectId idWall;
|
|
GetWallId(false, idWall);
|
|
DrawSideLine2d(false, idWall, bwlThis, dc);
|
|
}
|
|
|
|
// 编号
|
|
CString sNumber;
|
|
if (GetAt(KEY_CLAB, sNumber) && !sNumber.IsEmpty())
|
|
{
|
|
TDbText text;
|
|
double dTextHeight = 3.5; // 字高
|
|
double dAngle; // 文本旋转角度
|
|
TADSGePoint3d ptTextPos; // 文本位置
|
|
AcGePoint3d ptStart, ptEnd; // 条基起点和终点
|
|
double dWidth, dBulge; // 条基宽度, 条基的凸度
|
|
AcGeVector3d vtDir; // 文本偏移方向
|
|
AcGePoint3d ptMidPt; // 条基条基起点终点连线的中点
|
|
|
|
GetAt(KEY_START, ptStart);
|
|
GetAt(KEY_END, ptEnd);
|
|
GetAt(KEY_W, dWidth);
|
|
GetAt(KEY_BULGE, dBulge);
|
|
|
|
vtDir = ptEnd - ptStart;
|
|
if (Wcs2Ucs(ptStart) > Wcs2Ucs(ptEnd) + g_fZero)
|
|
{
|
|
vtDir = ptStart - ptEnd;
|
|
}
|
|
dAngle = TADSGePoint3d(vtDir).AsAcGeVector2d().angle(); // 文本的旋转角度
|
|
vtDir.rotateBy(PI / 2.0, AcGeVector3d(0, 0, 1)); // 文本的偏移方向
|
|
vtDir.normalize();
|
|
|
|
if (abs(dBulge) < g_fZero)
|
|
{
|
|
// 条基为直线
|
|
Midpoint(ptStart, ptEnd, ptMidPt);
|
|
}
|
|
else
|
|
{
|
|
// 条基为弧
|
|
TGGeArc arc(ptStart, ptEnd, dBulge);
|
|
ptMidPt = arc.MidPoint();
|
|
}
|
|
|
|
// 文本位置
|
|
ptTextPos = ptMidPt + vtDir * (dWidth / 2.0 + dTextHeight * DocGetPScale() / 3.0);
|
|
|
|
text.SetText(sNumber);
|
|
text.SetAlignment(TGGiExplodeDrawBase::kBottomCenter);
|
|
text.SetHeight(dTextHeight);
|
|
text.setPropertiesFrom(this);
|
|
text.SetRotation(dAngle);
|
|
text.SetStyleId(GetTextStyleId(_T("Standard")));
|
|
text.SetLocation(ptTextPos);
|
|
dc.DrawEntity(text);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// 绘制端点的封口线
|
|
Acad::ErrorStatus TDbStruBarBase::DrawSideLine2d(bool bStart, const AcDbObjectId &idWall, const TBaseWallLine &wallLine, TGGiExplodeDrawBase &dc) const
|
|
{
|
|
TDbStruBarBase *pWall = NULL;
|
|
acdbOpenObject(pWall, idWall, AcDb::kForRead);
|
|
if (pWall != NULL)
|
|
{
|
|
TBaseWallLine bwlThat;
|
|
pWall->GetThisBaseWallLine(bwlThat);
|
|
int nThatWeight = 0;
|
|
pWall->GetAt(KEY_WEIGHT, nThatWeight);
|
|
pWall->close();
|
|
|
|
// 判断基础线融合方式
|
|
TADSGePoint3d ptThat1,ptThat2;
|
|
TBaseWallLine bwlThis;
|
|
GetThisBaseWallLine(bwlThis);
|
|
int nType = TBaseWallIntegrateTool::IsIntegrateAtTail(bwlThat, bwlThis);
|
|
if (nType == 1) // 起始端相交
|
|
{
|
|
TGGeVisibilityPoly2D leftThat = bwlThat.GetLeftLine();
|
|
TGGeVisibilityPoly2D rightThat = bwlThat.GetRightLine();
|
|
ptThat1 = *leftThat[0];
|
|
ptThat2 = *rightThat[0];
|
|
}
|
|
else if (nType == 2) // 终止端相交
|
|
{
|
|
TGGeVisibilityPoly2D leftThat = bwlThat.GetLeftLine();
|
|
TGGeVisibilityPoly2D rightThat = bwlThat.GetRightLine();
|
|
ptThat1 = *leftThat[leftThat.Length() - 1];
|
|
ptThat2 = *rightThat[leftThat.Length() - 1];
|
|
}
|
|
else
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
if (!!ptThat1 && !!ptThat2)
|
|
{
|
|
TADSGePoint3d ptThis1,ptThis2;
|
|
TGGeVisibilityPoly2D leftThis = bwlThis.GetLeftLine();
|
|
TGGeVisibilityPoly2D rightThis = bwlThis.GetRightLine();
|
|
if (bStart)
|
|
{
|
|
ptThis1 = *leftThis[0];
|
|
ptThis2 = *rightThis[0];
|
|
}
|
|
else
|
|
{
|
|
ptThis1 = *leftThis[leftThis.Length() - 1];
|
|
ptThis2 = *rightThis[rightThis.Length() - 1];
|
|
}
|
|
|
|
AcGeVector3d vtThat = ptThat1 - ptThat2;
|
|
AcGeVector3d vtThis = ptThis1 - ptThis2;
|
|
int nThisWeight = 0;
|
|
GetAt(KEY_WEIGHT, nThisWeight);
|
|
if (vtThis.isParallelTo(vtThat)) // 端点连线平行
|
|
{
|
|
if (nThisWeight < nThatWeight) // 比较优先级
|
|
{
|
|
dc << TGGeLine(ptThis1, ptThis2);
|
|
}
|
|
else
|
|
{
|
|
bool bSuperposition = (ptThat1.Distance(ptThis1) < _DIST_SNAP && ptThat2.Distance(ptThis2) < _DIST_SNAP)
|
|
|| (ptThat1.Distance(ptThis2) < _DIST_SNAP && ptThat2.Distance(ptThis1) < _DIST_SNAP); // 融合端点两两重合
|
|
if (!bSuperposition)
|
|
{
|
|
// 将that的融合端点投影到this融合端点连线的直线上
|
|
std::vector<TADSGePoint3d> vecPt;
|
|
vecPt.push_back(ptThis1);
|
|
vecPt.push_back(ptThis2);
|
|
TADSGePoint3d pt;
|
|
TGGeLine line(ptThis1, ptThis2);
|
|
ptThat1.Project(&line, pt);
|
|
vecPt.push_back(pt);
|
|
ptThat2.Project(&line, pt);
|
|
vecPt.push_back(pt);
|
|
|
|
// 求两点间的距离
|
|
std::map<double, std::vector<TADSGePoint3d> > mapData;
|
|
std::vector<TADSGePoint3d> vecTemp;
|
|
std::vector<TADSGePoint3d>::iterator it1, it2;
|
|
for (it1 = vecPt.begin(); it1 != vecPt.end(); it1++)
|
|
{
|
|
it2 = it1;
|
|
++it2;
|
|
for (; it2 != vecPt.end(); it2++)
|
|
{
|
|
vecTemp.clear();
|
|
vecTemp.push_back(*it1);
|
|
vecTemp.push_back(*it2);
|
|
mapData.insert(std::make_pair((*it1).Distance(*it2), vecTemp));
|
|
}
|
|
}
|
|
|
|
// 获取距离最远的点
|
|
std::map<double, std::vector<TADSGePoint3d> >::iterator it;
|
|
it = mapData.end();
|
|
--it;
|
|
vecTemp.clear();
|
|
vecTemp.push_back((*it).second[0]);
|
|
vecTemp.push_back((*it).second[1]);
|
|
|
|
// 从vecPt中删除最远的两点
|
|
for (it1 = vecTemp.begin(); it1 != vecTemp.end(); it1++)
|
|
{
|
|
for (it2 = vecPt.begin(); it2 != vecPt.end(); it2++)
|
|
{
|
|
if ((*it1).Distance(*it2) < _DIST_SNAP)
|
|
{
|
|
vecPt.erase(it2);
|
|
break;;
|
|
}
|
|
}
|
|
}
|
|
|
|
// this的融合端点是否与最远点重合
|
|
if (ptThis1.Distance(vecTemp[0]) < _DIST_SNAP || ptThis1.Distance(vecTemp[1]) < _DIST_SNAP)
|
|
{
|
|
double dDist1 = ptThis1.Distance(vecPt[0]);
|
|
double dDist2 = ptThis1.Distance(vecPt[1]);
|
|
if (dDist1 < dDist2)
|
|
{
|
|
dc << TGGeLine(ptThis1, vecPt[0]);
|
|
}
|
|
else
|
|
{
|
|
dc << TGGeLine(ptThis1, vecPt[1]);
|
|
}
|
|
}
|
|
|
|
if (ptThis2.Distance(vecTemp[0]) < _DIST_SNAP || ptThis2.Distance(vecTemp[1]) < _DIST_SNAP)
|
|
{
|
|
double dDist1 = ptThis2.Distance(vecPt[0]);
|
|
double dDist2 = ptThis2.Distance(vecPt[1]);
|
|
if (dDist1 < dDist2)
|
|
{
|
|
dc << TGGeLine(ptThis2, vecPt[0]);
|
|
}
|
|
else
|
|
{
|
|
dc << TGGeLine(ptThis2, vecPt[1]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (nThatWeight != nThisWeight) // 优先级不同
|
|
{
|
|
TGGeVisibilityPoly2D left = wallLine.GetLeftLine();
|
|
TGGeVisibilityPoly2D right = wallLine.GetRightLine();
|
|
if (bStart)
|
|
{
|
|
dc << TGGeLine(*left[0], *right[0]);
|
|
}
|
|
else
|
|
{
|
|
dc << TGGeLine(*left[left.Length() - 1], *right[right.Length() - 1]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbStruBarBase::GetExtents2d(TADSGePoint3d &ptLow, TADSGePoint3d &ptUp) const
|
|
{
|
|
TGGePoly2D poly2d;
|
|
GetPoly2D(poly2d);
|
|
poly2d.GetExtend(ptLow, ptUp);
|
|
ptLow.z = 0.0;
|
|
ptUp.z = 0.0;
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbStruBarBase::GetExtents(TADSGePoint3d &ptLow, TADSGePoint3d &ptUp) const
|
|
{
|
|
GetExtents2d(ptLow, ptUp);
|
|
|
|
double dH = 0.0;
|
|
GetAt(KEY_H, dH);
|
|
|
|
AcGePoint3d ptStart;
|
|
GetAt(KEY_START, ptStart);
|
|
|
|
ptLow.z = ptStart.z - dH;
|
|
ptUp.z = ptStart.z;
|
|
return Acad::eOk;
|
|
}
|
|
|
|
//取动态属性显示数据
|
|
void TDbStruBarBase::GetTips(TDPtrList<TObjInfoUnit> &lstInfo) const
|
|
{
|
|
}
|
|
|
|
const TCHAR *TDbStruBarBase::GetDefaultLayer() const
|
|
{
|
|
return LAY_S_BASE_STRIP_LINE;
|
|
}
|
|
|
|
BOOL TDbStruBarBase::IsValid() const
|
|
{
|
|
assertReadEnabled();
|
|
AcGePoint3d ptStart, ptEnd;
|
|
double dBulge;
|
|
int iWeight;
|
|
double dWidth, dHeight;
|
|
if (GetAt(KEY_START, ptStart) &&
|
|
GetAt(KEY_END, ptEnd) &&
|
|
GetAt(KEY_BULGE, dBulge) &&
|
|
GetAt(KEY_WEIGHT, iWeight) &&
|
|
GetAt(KEY_W, dWidth) &&
|
|
GetAt(KEY_H, dHeight))
|
|
{
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
// 支持夹点ctrl功能切换
|
|
int TDbStruBarBase::GetCtrlToggleIndex()const
|
|
{
|
|
return 11;
|
|
}
|
|
|
|
void TDbStruBarBase::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbBaseWall::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
|
|
|
|
TDbStruBarBase* pEnt = TDbStruBarBase::cast(pSrcEntity);
|
|
if (pEnt != NULL)
|
|
{
|
|
AcGePoint3d ptStart, ptEnd;
|
|
double dBulge;
|
|
|
|
GetAt(KEY_START, ptStart);
|
|
GetAt(KEY_END, ptEnd);
|
|
GetAt(KEY_BULGE, dBulge);
|
|
|
|
GetSpecialtyData()->Empty();
|
|
*GetSpecialtyData() = *pEnt->GetSpecialtyData();
|
|
|
|
SetAt(KEY_START, ptStart);
|
|
SetAt(KEY_END, ptEnd);
|
|
SetAt(KEY_BULGE, dBulge);
|
|
}
|
|
}
|
|
|
|
TEntityBase::DrawType TDbStruBarBase::GetDrawType() const
|
|
{
|
|
assertReadEnabled();
|
|
return TEntityBase::k2DOnly;
|
|
}
|
|
|
|
bool TDbStruBarBase::GetStandardFaceBody(AcDbVoidPtrArray& arFacePtrs) const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool TDbStruBarBase::GetSafeProtectedSpace(AcDbVoidPtrArray& arFacePtrs) const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool TDbStruBarBase::GetSection(const AcDbFace &face,
|
|
const AcGeVector3d &vtPlaneSecDir,
|
|
std::vector<TObjSectionRecord> §ionRecords,
|
|
AcDbVoidPtrArray &arFillPtrs) const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
CString TDbStruBarBase::GetXml(const AcGeMatrix3d& mat) const
|
|
{
|
|
return _T("");
|
|
}
|
|
|
|
// 对象修改发出关联更改消息
|
|
void TDbStruBarBase::PostAssocMsg(TAssocMsg assocMsg)const
|
|
{
|
|
}
|
|
|
|
// 对象接收到更改消息
|
|
void TDbStruBarBase::ReceiveAssocMsg(TAssocMsg assocMsg)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbBaseWall::ReceiveAssocMsg(assocMsg);
|
|
}
|
|
|
|
// 建立关联关系
|
|
void TDbStruBarBase::MakeAssocRelation(AcDbObjectIdArray& ids)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
if(ids.length() < 1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
TPickEntSet ss(SS_FREE);
|
|
ads_name eName;
|
|
for (int i = 0; i < ids.length(); i++)
|
|
{
|
|
if (acdbGetAdsName(eName, ids[i]) == Acad::eOk)
|
|
{
|
|
ss += ids[i];
|
|
}
|
|
}
|
|
|
|
TGGePoly2D poly; //基础闭合平面
|
|
GetPoly2D(poly);
|
|
|
|
double dWidth = 0; //基础平面宽
|
|
GetTotalWidth(dWidth);
|
|
|
|
TGGeCurveSegment cvCL = GetCenterLine();
|
|
cvCL.SetLineFlag(LS_INFINITE);
|
|
|
|
double dElevS = cvCL.StartPoint().z;
|
|
double dElevE = cvCL.EndPoint().z;
|
|
bool bModFlg = false; //记录基础的中心线是否调整
|
|
double dGap(0);
|
|
AcDbObjectId idObj = AcDbObjectId::kNull;
|
|
|
|
TEntitySet ent;
|
|
for (long j = 0; j < ss.Length(); j++)
|
|
{
|
|
ent = ss[j];
|
|
if (ent.Is(_T("ATS_STRUBARBASE")))
|
|
{
|
|
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbStruBarBase, pEnt);
|
|
if (!pEnt)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
TGGePoly2D polyDest;
|
|
pEnt->GetPoly2D(polyDest);
|
|
|
|
double dWidthDest(0);
|
|
pEnt->GetTotalWidth(dWidthDest);
|
|
|
|
bool bRet = TBaseWallIntegrateTool::GetMinGap(poly, polyDest, dGap);
|
|
//间隙小于基础宽一半时，当作关联处理
|
|
if(bRet && (dGap < dWidth*0.5 || dGap < dWidthDest*0.5))
|
|
{
|
|
if (cvCL.Is(CURVE_LINE))
|
|
{
|
|
//建立关联时对基础的中心线进行校验，相交
|
|
TGGeCurveSegment cvCLDest = pEnt->GetCenterLine();
|
|
cvCLDest.SetLineFlag(LS_INFINITE);
|
|
|
|
TADSGePoint3d ptInter1,ptInter2;
|
|
int nNum = cvCL.Intersection(cvCLDest,ptInter1,ptInter2);
|
|
if (nNum != 0) // 有交点
|
|
{
|
|
//两个交点时取离cvCL中点近的
|
|
if (nNum == 2)
|
|
{
|
|
TADSGePoint3d ptMid = cvCL.MidPoint();
|
|
ptInter1 = TGGeLine(ptInter1, ptInter2).NearPoint(ptMid);
|
|
}
|
|
|
|
bool bModBreak = false;
|
|
int nHitFlag = cvCL.HitTest2d(ptInter1);
|
|
if (nHitFlag == 6) //起始侧延长线
|
|
{
|
|
bModFlg = true;
|
|
bModBreak = true;
|
|
cvCL.SetStartPoint(ptInter1);
|
|
}
|
|
else if (nHitFlag == 7) //终止侧延长线
|
|
{
|
|
bModFlg = true;
|
|
bModBreak = true;
|
|
cvCL.SetEndPoint(ptInter1);
|
|
}
|
|
|
|
//add by xlc on 120417 基础自动打断
|
|
if (g_bAutoBreak)
|
|
{
|
|
if (bModBreak)
|
|
{
|
|
Acad::ErrorStatus es = upgradeOpen();
|
|
if ((es == Acad::eOk || es == Acad::eWasOpenForWrite))
|
|
{
|
|
AcGePoint3d pt = cvCL.StartPoint();
|
|
pt.z = dElevS;
|
|
SetAt(KEY_START, pt);
|
|
|
|
pt = cvCL.EndPoint();
|
|
pt.z = dElevE;
|
|
SetAt(KEY_END, pt);
|
|
|
|
if (es == Acad::eOk)
|
|
{
|
|
downgradeOpen();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool bBreak = false;
|
|
if(nHitFlag == 5) //交点在线内时对自己进行打断
|
|
{
|
|
if(BreakAt(ptInter1,NULL))
|
|
{
|
|
bModFlg = false;
|
|
bBreak = true;
|
|
}
|
|
}
|
|
|
|
bool bModifyOld = g_bModifyAgain;
|
|
pEnt->BreakAt(ptInter1, NULL);
|
|
g_bModifyAgain = bModifyOld;
|
|
|
|
if (bBreak)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
idObj = pEnt->objectId();
|
|
}
|
|
else
|
|
{
|
|
continue;
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
if (!m_arAssocBWallIds.contains(idObj))
|
|
{
|
|
m_arAssocBWallIds.append(idObj);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 修改条形基础的端点
|
|
if (bModFlg)
|
|
{
|
|
Acad::ErrorStatus es = upgradeOpen();
|
|
if ((es == Acad::eOk || es == Acad::eWasOpenForWrite))
|
|
{
|
|
AcGePoint3d pt = cvCL.StartPoint();
|
|
pt.z = dElevS;
|
|
SetAt(KEY_START, pt);
|
|
|
|
pt = cvCL.EndPoint();
|
|
pt.z = dElevE;
|
|
SetAt(KEY_END, pt);
|
|
if (es == Acad::eOk)
|
|
{
|
|
downgradeOpen();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 移除关联关系
|
|
void TDbStruBarBase::RemoveAssocRelation(AcDbObjectId& id)
|
|
{
|
|
m_arAssocBWallIds.remove(id);
|
|
}
|
|
|
|
// 获得条形基础总宽度
|
|
void TDbStruBarBase::GetTotalWidth(double &dWidth)const
|
|
{
|
|
dWidth = 0;
|
|
GetAt(KEY_W, dWidth);
|
|
}
|
|
|
|
// 获得条形基础总高度
|
|
void TDbStruBarBase::GetTotalHeight(double &dHeight)const
|
|
{
|
|
dHeight = 0;
|
|
GetAt(KEY_H, dHeight);
|
|
}
|
|
|
|
// 基础外围poly2d
|
|
void TDbStruBarBase::GetPoly2D(TGGePoly2D &poly2d) const
|
|
{
|
|
TBaseWallLine wallLine;
|
|
GetThisBaseWallLine(wallLine);
|
|
TGGeVisibilityPoly2D left, right;
|
|
left = wallLine.GetLeftLine();
|
|
right = wallLine.GetRightLine();
|
|
|
|
AcDbPolyline* pLwPoly = new AcDbPolyline();
|
|
double dBuge = 0.0;
|
|
int nIndex = 0;
|
|
int i;
|
|
for (i = 0; i < left.Length(); i++)
|
|
{
|
|
dBuge = tan(*(left.m_ardbulges[i]) / 4.0);
|
|
pLwPoly->addVertexAt(nIndex, (*left[i]).AsAcGePoint2d(), dBuge);
|
|
++nIndex;
|
|
}
|
|
|
|
for (i=left.Length()-1; i >= 0; i--)
|
|
{
|
|
if (i > 0)
|
|
{
|
|
dBuge = tan(*(right.m_ardbulges[i-1]) / 4.0) * (-1);
|
|
}
|
|
else
|
|
{
|
|
dBuge = 0.0;
|
|
}
|
|
pLwPoly->addVertexAt(nIndex, (*right[i]).AsAcGePoint2d(), dBuge);
|
|
++nIndex;
|
|
}
|
|
|
|
pLwPoly->setClosed(Adesk::kTrue);
|
|
poly2d.SetAcDbCurve(pLwPoly);
|
|
delete pLwPoly;
|
|
}
|
|
|
|
BOOL TDbStruBarBase::CanMerge(AcDbObjectId idWall)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
int TDbStruBarBase::GetFirstVersion()const
|
|
{
|
|
return 10;
|
|
}
|
|
bool TDbStruBarBase::IsModelEntity() const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
void InitDbStruBarBase(BOOL bInit)
|
|
{
|
|
if (bInit)
|
|
{
|
|
TDbStruBarBase::rxInit();
|
|
acrxBuildClassHierarchy();
|
|
TDbStruBarBase::InitMatchProtocol(TRUE);
|
|
}
|
|
else
|
|
{
|
|
TDbStruBarBase::InitMatchProtocol(FALSE);
|
|
deleteAcRxClass(TDbStruBarBase::desc());
|
|
}
|
|
}
|
|
#endif |