2390 lines
65 KiB
C++
2390 lines
65 KiB
C++
#include "stdafx.h"
|
|
#include "TDbColumn.h"
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// TArch6新增2;TArch7,3,TArch8,4
|
|
const Adesk::UInt8 TDbMultiStair::g_nVersion = 4;
|
|
|
|
ACRX_DXF_DEFINE_MEMBERS(ATSMultiStair, ATSEntity, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
|
1, ATS_MULTISTAIR, "ATS_MULTISTAIR图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
|
|
|
|
IMPLEMENT_TENTBASE(TDbMultiStair);
|
|
|
|
TDbMultiStair::TDbMultiStair()
|
|
{
|
|
m_nFlagEx=0;
|
|
m_nStairFlag=1; //楼层标记
|
|
|
|
m_nStepHeight=_AS_SYS_UNIT(150.0); //踏步高
|
|
m_nStepWidth=_AS_SYS_UNIT(300); //踏步宽
|
|
m_nStairWidth=_AS_SYS_UNIT(1200); //梯段宽
|
|
m_nStairHeight=_AS_SYS_UNIT(3000.0); //楼梯总高
|
|
m_nElevation=0.0; //标高
|
|
m_nSlabThick=_AS_SYS_UNIT(120); //休息平台尺寸
|
|
m_nBeamThick=_AS_SYS_UNIT(120); //梁厚
|
|
m_nBeamHeight=_AS_SYS_UNIT(200); //边梁高（坡道）
|
|
|
|
m_nRailHeight=_AS_SYS_UNIT(900);
|
|
m_nRailWidth=_AS_SYS_UNIT(60.0); //扶手宽度
|
|
m_nRailDistToSide=0.0; //扶手距离边
|
|
|
|
m_nPathSide = OFFSET_LEFT;
|
|
m_lSectPos=m_rSectPos=0.0;
|
|
|
|
m_nViewCtrl=0; //自动确定
|
|
|
|
m_iActiveStep=-1;
|
|
|
|
//add by xlc on 080718 Tarch8
|
|
m_nRailDistEnd=0; //终端扶手伸出距离
|
|
m_nRailDist=0; //起始端扶手伸出距离
|
|
m_dSectElev=_AS_SYS_UNIT(800); //剖切高度
|
|
m_dSectRotation=PI/6; //剖断线旋转角度
|
|
m_dTextHeight=3.5; //字高
|
|
SetLayerText(InitLayer(LAY_TEXT));
|
|
SetTextStyle(InitTextStyle(TS_DIM));
|
|
SetLayerArrow(InitLayer(LAY_OTHER_DIM));
|
|
SetArrow(TRUE);
|
|
SetManualSectPos(TRUE);
|
|
}
|
|
|
|
|
|
TDbMultiStair::~TDbMultiStair()
|
|
{
|
|
}
|
|
|
|
BOOL TDbMultiStair::IsValid() const
|
|
{
|
|
BOOL bRet=TDbEntity::IsValid();
|
|
if(!bRet)
|
|
return bRet;
|
|
|
|
bRet=(m_polySide2d.Length()>0 && m_polySide2d.GetFlag()==0 &&
|
|
// (m_polySide2d.Length()%2==0) && //基数
|
|
m_nStairHeight>_DIST_SNAP &&
|
|
m_nStepHeight>_DIST_SNAP && //踏步高
|
|
m_nStepWidth>_DIST_SNAP && //踏步宽
|
|
m_nStairWidth>_DIST_SNAP && //梯段宽
|
|
m_nSlabThick>_DIST_SNAP &&
|
|
m_nRailHeight>_DIST_SNAP &&
|
|
m_nRailWidth>_DIST_SNAP &&
|
|
GreatEqual(m_nBeamHeight, 0.0) &&
|
|
GreatEqual(m_nBeamThick, 0.0) &&
|
|
GreatEqual(m_nSlabThick, 0.0) &&
|
|
m_nStairFlag<3 &&
|
|
m_nRailDistToSide>-1.0E-6 &&
|
|
m_nStairWidth>m_nRailWidth+m_nRailDistToSide);
|
|
return bRet;
|
|
}
|
|
|
|
// 提供对格式刷的支持
|
|
void TDbMultiStair::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbEntity::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
|
|
TDbMultiStair *pSrc=TDbMultiStair::cast(pSrcEntity);
|
|
if(pSrc) {
|
|
m_nFlagEx = pSrc->m_nFlagEx;
|
|
m_nStairFlag=pSrc->m_nStairFlag;
|
|
m_nStairWidth = pSrc->m_nStairWidth;
|
|
m_nStairHeight=pSrc->m_nStairHeight;
|
|
m_nStepWidth = pSrc->m_nStepWidth;
|
|
m_nStepHeight = pSrc->m_nStepHeight;
|
|
m_nRailHeight = pSrc->m_nRailHeight; //扶手高度
|
|
m_nRailWidth = pSrc->m_nRailWidth; //扶手宽度
|
|
m_nRailDistToSide = pSrc->m_nRailDistToSide; //扶手距离边
|
|
m_nSlabThick = pSrc->m_nSlabThick; //平台厚度
|
|
m_nBeamHeight = pSrc->m_nBeamHeight; //边梁高度
|
|
m_nBeamThick = pSrc->m_nBeamThick; //边梁厚度
|
|
|
|
//add by xlc on 090426箭头文字
|
|
SetTextUp(pSrc->GetTextUp());
|
|
SetTextDown(pSrc->GetTextDown());
|
|
|
|
if(database()==NULL||
|
|
pSrcEntity->database()==NULL||
|
|
database()==pSrcEntity->database())//add by whl on 060317
|
|
{
|
|
m_idLayerStep3d = pSrc->m_idLayerStep3d;
|
|
m_idLayerHand3d = pSrc->m_idLayerHand3d;
|
|
m_idLayerRail3d = pSrc->m_idLayerRail3d;
|
|
m_idLayerBeam3d = pSrc->m_idLayerBeam3d;
|
|
|
|
//add by xlc on 080718
|
|
//Tarch8 member
|
|
m_idLayerText=pSrc->m_idLayerText;
|
|
m_idLayerArrow=pSrc->m_idLayerArrow;
|
|
m_idTextStyle=pSrc->m_idTextStyle;
|
|
}
|
|
m_lSectPos = pSrc->m_lSectPos;
|
|
m_rSectPos = pSrc->m_rSectPos;
|
|
m_nViewCtrl=pSrc->m_nViewCtrl;
|
|
|
|
//add by xlc on 080718
|
|
//Tarch8 member
|
|
m_nRailDistEnd=pSrc->m_nRailDistEnd; //终端扶手伸出距离
|
|
m_nRailDist=pSrc->m_nRailDist; //起始端扶手伸出距离
|
|
m_dSectElev=pSrc->m_dSectElev; //剖切高度
|
|
m_dSectRotation=pSrc->m_dSectRotation; //剖断线旋转角度
|
|
m_dTextHeight=pSrc->m_dTextHeight; //字高
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbMultiStair::subGetClassID(CLSID* pClsid) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
|
|
// 从DWG读入数据:
|
|
Acad::ErrorStatus
|
|
TDbMultiStair::dwgInFields (AcDbDwgFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
Acad::ErrorStatus es = TDbEntity::dwgInFields(pFiler);
|
|
if(es != Acad::eOk) return es;
|
|
Adesk::UInt8 nVer;
|
|
pFiler->readItem(&nVer);
|
|
if(nVer>g_nVersion) {// Version is too new
|
|
return Acad::eMakeMeProxy;
|
|
}
|
|
|
|
pFiler->readItem(&m_nFlagEx);
|
|
pFiler->readItem(&m_nStairFlag);
|
|
pFiler->readItem(&m_nPathSide);
|
|
m_polySide2d.Reset();
|
|
Adesk::UInt8 nCount=0;
|
|
pFiler->readItem(&nCount);
|
|
for(Adesk::UInt8 i=0; i<nCount; i++) {
|
|
AcGePoint2d pt2d;
|
|
pFiler->readItem(&pt2d);
|
|
XPoint pt(pt2d);
|
|
m_polySide2d.AppendNode(pt);
|
|
}
|
|
|
|
pFiler->readItem(&m_nElevation); //标高
|
|
pFiler->readItem(&m_nStairWidth);
|
|
pFiler->readItem(&m_nStairHeight); //楼梯高
|
|
pFiler->readItem(&m_nStepWidth);
|
|
pFiler->readItem(&m_nStepHeight); //踏步高
|
|
pFiler->readItem(&m_nRailHeight);
|
|
pFiler->readItem(&m_nRailWidth);
|
|
pFiler->readItem(&m_nRailDistToSide);
|
|
pFiler->readItem(&m_nSlabThick);
|
|
pFiler->readItem(&m_nBeamHeight);
|
|
pFiler->readItem(&m_nBeamThick);
|
|
|
|
pFiler->readItem(&m_idLayerStep3d);
|
|
pFiler->readItem(&m_idLayerHand3d);
|
|
pFiler->readItem(&m_idLayerRail3d);
|
|
pFiler->readItem(&m_idLayerBeam3d);
|
|
|
|
if(IsManualSectPos()) {
|
|
pFiler->readItem(&m_lSectPos);
|
|
pFiler->readItem(&m_rSectPos);
|
|
} else {
|
|
m_lSectPos=m_rSectPos=0.0;
|
|
}
|
|
|
|
//add by xlc on 080721 剖切线从低版本到高版本
|
|
if(nVer<4)
|
|
{
|
|
XPoint ptSectLeft2d,ptSectRight2d;
|
|
int nHitLeft=HitTestSectPos(0, ptSectLeft2d),
|
|
nHitRight=HitTestSectPos(1, ptSectRight2d);
|
|
if(nHitLeft == nHitRight && nHitLeft != 0)
|
|
{
|
|
DList<TDbEntity> lstComponents;
|
|
ExplodeTo(lstComponents);
|
|
DStack<TDbStair> stairs;
|
|
for(int i=0; i<lstComponents.Length(); i++) {
|
|
TDbEntity *pEnt=lstComponents[i];
|
|
if(pEnt->isKindOf(TDbStair::desc()))
|
|
stairs.Append((TDbStair *)pEnt);
|
|
}
|
|
double rotation=0;
|
|
XPoint ptLowLeft2d,ptLowRight2d;
|
|
if(nHitLeft<stairs.Length()+1&&nHitLeft>0)
|
|
{
|
|
ptLowLeft2d=stairs[nHitLeft-1]->GetLowLeft2d();
|
|
ptLowRight2d=stairs[nHitLeft-1]->GetLowRight2d();
|
|
rotation=ads_angle(ptLowLeft2d,ptLowRight2d);
|
|
}
|
|
if(!IsManualSectPos())
|
|
{
|
|
if(nHitLeft<stairs.Length()+1&&nHitLeft>0)
|
|
m_dSectElev=0.5*stairs[nHitLeft-1]->GetStairHeight();
|
|
}
|
|
else
|
|
{
|
|
if(nHitLeft<stairs.Length()+1&&nHitLeft>0)
|
|
{
|
|
double length=(ptSectLeft2d.Distance2d(stairs[nHitLeft-1]->GetLowLeft2d())
|
|
+ptSectRight2d.Distance2d(stairs[nHitLeft-1]->GetLowRight2d()))*0.5;
|
|
int stepNum=stairs[nHitLeft-1]->GetStepNum();
|
|
double stepWidth=((TDbLineStair*)stairs[nHitLeft-1])->GetStepWidth();
|
|
double stairLength=stepWidth*(stepNum-(IsAscent()?0:1));
|
|
if(length>0&&length<stairLength)
|
|
{
|
|
m_dSectElev = length*stairs[nHitLeft-1]->GetStairHeight()/(stairLength+(IsAscent()?0:stepWidth));
|
|
}
|
|
for(int i=0;i<nHitLeft-1;i++)
|
|
{
|
|
m_dSectElev += stairs[i]->GetStairHeight();
|
|
}
|
|
}
|
|
}
|
|
|
|
m_dSectRotation=CT_std_angle(ads_angle(ptSectRight2d, ptSectLeft2d)-rotation);
|
|
SetArrow(FALSE);
|
|
}
|
|
}
|
|
|
|
if(nVer>1)
|
|
pFiler->readItem(&m_nViewCtrl);
|
|
else
|
|
m_nViewCtrl=0; //自动确定
|
|
|
|
if(nVer>2)
|
|
{
|
|
int num;
|
|
pFiler->readItem(&num);//这个值无用,永远是0!
|
|
}
|
|
|
|
m_lstSegType.Reset();
|
|
if(nVer>3)//TArch8
|
|
{
|
|
Adesk::Int32 num;
|
|
pFiler->readItem(&num);
|
|
for(long i=0;i<num;i++)
|
|
{
|
|
Adesk::UInt8 *pType=new Adesk::UInt8;
|
|
pFiler->readItem(pType);
|
|
m_lstSegType.Append(pType);
|
|
}
|
|
|
|
//add by xlc on 080718
|
|
pFiler->readItem(&m_nRailDistEnd); //终端扶手伸出距离
|
|
pFiler->readItem(&m_nRailDist); //起始端扶手伸出距离
|
|
pFiler->readItem(&m_dSectElev); //剖切高度
|
|
pFiler->readItem(&m_dSectRotation); //剖断转角
|
|
pFiler->readItem(&m_dTextHeight); //字高
|
|
pFiler->readItem(&m_idLayerText);
|
|
pFiler->readItem(&m_idTextStyle);
|
|
pFiler->readItem(&m_idLayerArrow);
|
|
}
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbMultiStair::dwgOutFields(AcDbDwgFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es = TDbEntity::dwgOutFields(pFiler);
|
|
if(es != Acad::eOk) return es;
|
|
|
|
if(g_nSaveTArchVer<7)
|
|
pFiler->writeItem((Adesk::UInt8)2);
|
|
else if(g_nSaveTArchVer==7)
|
|
pFiler->writeItem((Adesk::UInt8)3);
|
|
else
|
|
pFiler->writeItem(g_nVersion);
|
|
|
|
Adesk::UInt32 nFlagEx=m_nFlagEx;
|
|
if(g_nSaveTArchVer<8)
|
|
{
|
|
nFlagEx |= SFEX_SECTPOS;
|
|
}
|
|
pFiler->writeItem(nFlagEx);
|
|
pFiler->writeItem(m_nStairFlag);
|
|
pFiler->writeItem(m_nPathSide);
|
|
|
|
|
|
Adesk::UInt8 nCount=m_polySide2d.Length();
|
|
pFiler->writeItem(nCount);
|
|
for(Adesk::UInt8 i=0; i<nCount; i++) {
|
|
XPoint pt=m_polySide2d[i];
|
|
pFiler->writeItem((AcGePoint2d &)pt);
|
|
}
|
|
pFiler->writeItem(m_nElevation);
|
|
pFiler->writeItem(m_nStairWidth);
|
|
pFiler->writeItem(m_nStairHeight);
|
|
pFiler->writeItem(m_nStepWidth);
|
|
pFiler->writeItem(m_nStepHeight);
|
|
pFiler->writeItem(m_nRailHeight);
|
|
pFiler->writeItem(m_nRailWidth);
|
|
pFiler->writeItem(m_nRailDistToSide);
|
|
|
|
pFiler->writeItem(m_nSlabThick); //休息平台尺寸
|
|
pFiler->writeItem(m_nBeamHeight);
|
|
pFiler->writeItem(m_nBeamThick);
|
|
|
|
pFiler->writeItem(m_idLayerStep3d);
|
|
pFiler->writeItem(m_idLayerHand3d);
|
|
pFiler->writeItem(m_idLayerRail3d);
|
|
pFiler->writeItem(m_idLayerBeam3d);
|
|
if(IsManualSectPos())
|
|
{
|
|
DStack<TDbStair> stairs;
|
|
DList<TDbEntity> lstComponents;
|
|
ExplodeTo(lstComponents);
|
|
for(int i=0; i<lstComponents.Length(); i++)
|
|
{
|
|
TDbEntity *pEnt=lstComponents[i];
|
|
if(pEnt->isKindOf(TDbStair::desc()))
|
|
stairs.Append((TDbStair *)pEnt);
|
|
}
|
|
|
|
double lSectPos,rSectPos;
|
|
XPoint ptLeft2d,ptRight2d;
|
|
BOOL bSect=CalSectPos(stairs,lSectPos,rSectPos,ptLeft2d,ptRight2d);
|
|
if(bSect)
|
|
{
|
|
XPoly2D lPoly, rPoly;
|
|
GetSidePoly2d(0, lPoly);
|
|
GetSidePoly2d(1, rPoly);
|
|
lSectPos=lPoly.PathDistance2d(ptLeft2d);
|
|
rSectPos=rPoly.PathDistance2d(ptRight2d);
|
|
}
|
|
else
|
|
{
|
|
lSectPos=m_lSectPos;
|
|
rSectPos=m_rSectPos;
|
|
}
|
|
pFiler->writeItem(lSectPos);
|
|
pFiler->writeItem(rSectPos);
|
|
}
|
|
pFiler->writeItem(m_nViewCtrl);
|
|
|
|
if(g_nSaveTArchVer>6)
|
|
{
|
|
int num=0;
|
|
pFiler->writeItem(num);//这是个无用值！
|
|
}
|
|
|
|
if(g_nSaveTArchVer>7)
|
|
{
|
|
pFiler->writeItem((Adesk::Int32)m_lstSegType.Length());
|
|
for(long i=0;i<m_lstSegType.Length();i++)
|
|
pFiler->writeItem(m_lstSegType[i]);
|
|
|
|
//add by xlc on 080718
|
|
pFiler->writeItem(m_nRailDistEnd); //终端扶手伸出距离
|
|
pFiler->writeItem(m_nRailDist); //起始端扶手伸出距离
|
|
pFiler->writeItem(m_dSectElev); //剖切高度
|
|
pFiler->writeItem(m_dSectRotation); //剖断转角
|
|
pFiler->writeItem(m_dTextHeight); //字高
|
|
pFiler->writeItem(m_idLayerText);
|
|
pFiler->writeItem(m_idTextStyle);
|
|
pFiler->writeItem(m_idLayerArrow);
|
|
}
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
|
|
Acad::ErrorStatus
|
|
TDbMultiStair::dxfInFields (AcDbDxfFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
Acad::ErrorStatus es = TDbEntity::dxfInFields(pFiler);
|
|
if(es!=Acad::eOk)
|
|
return es;
|
|
|
|
if (!pFiler->atSubclassData(_T("TDbMultiStair"))) {
|
|
return Acad::eBadDxfSequence;
|
|
}
|
|
TDbMultiStair *pBakClone=(TDbMultiStair *)clone();
|
|
resbuf rb;
|
|
m_polySide2d.Reset();
|
|
bool bStairHeight=false;
|
|
while ((es == Acad::eOk)
|
|
&& ((es = pFiler->readResBuf(&rb)) == Acad::eOk)) {
|
|
switch (rb.restype) {
|
|
case AcDb::kDxfInt16:
|
|
m_nStairFlag=(Adesk::UInt8)rb.resval.rint;
|
|
break;
|
|
case AcDb::kDxfInt16+1:
|
|
m_nPathSide=(Adesk::UInt8)rb.resval.rint;
|
|
break;
|
|
case 75:
|
|
m_nViewCtrl=(Adesk::UInt8)rb.resval.rint;
|
|
break;
|
|
case 48:
|
|
m_nElevation = rb.resval.rreal;
|
|
break;
|
|
case 49:
|
|
m_nStairHeight=rb.resval.rreal;
|
|
bStairHeight=true;
|
|
break;
|
|
case 10:
|
|
m_polySide2d.AppendNode(XPoint(rb.resval.rpoint));
|
|
break;
|
|
case 40:
|
|
m_nStepHeight=rb.resval.rreal;
|
|
break;
|
|
case 41:
|
|
m_lSectPos=rb.resval.rreal;
|
|
break;
|
|
case 42:
|
|
m_rSectPos=rb.resval.rreal;
|
|
break;
|
|
case 43:
|
|
m_nStepWidth=rb.resval.rreal;
|
|
break;
|
|
case 44:
|
|
m_nStairWidth=rb.resval.rreal;
|
|
break;
|
|
case 90:
|
|
m_nFlagEx=rb.resval.rlong;
|
|
break;
|
|
case 145:
|
|
m_nBeamHeight=rb.resval.rreal;
|
|
break;
|
|
case 146:
|
|
m_nBeamThick=rb.resval.rreal;
|
|
break;
|
|
case 147:
|
|
m_nSlabThick=rb.resval.rreal;
|
|
break;
|
|
case 412:
|
|
m_idLayerStep3d=LayerString2Id(rb.resval.rstring, database());
|
|
free(rb.resval.rstring);
|
|
break;
|
|
case 413:
|
|
m_idLayerBeam3d=LayerString2Id(rb.resval.rstring, database());
|
|
free(rb.resval.rstring);
|
|
break;
|
|
case 414:
|
|
m_idLayerHand3d=LayerString2Id(rb.resval.rstring, database());
|
|
free(rb.resval.rstring);
|
|
break;
|
|
case 415:
|
|
m_idLayerRail3d=LayerString2Id(rb.resval.rstring, database());
|
|
free(rb.resval.rstring);
|
|
break;
|
|
//fall through intentional
|
|
default:
|
|
// An unrecognized group. Push it back so that
|
|
// the subclass can read it again.
|
|
pFiler->pushBackItem();
|
|
es = Acad::eEndOfFile;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// At this point the es variable must contain eEndOfFile
|
|
// - either from readResBuf() or from pushback. If not,
|
|
// it indicates that an error happened and we should
|
|
// return immediately.
|
|
//
|
|
if (es != Acad::eEndOfFile || m_polySide2d.Length()<2) {
|
|
CopyObject(*pBakClone, *this);
|
|
delete pBakClone;
|
|
return Acad::eInvalidResBuf;
|
|
}
|
|
delete pBakClone;
|
|
if(!bStairHeight)
|
|
m_nStairHeight=DocGetLHeight();
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbMultiStair::dxfOutFields(AcDbDxfFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es;
|
|
|
|
es = TDbEntity::dxfOutFields(pFiler);
|
|
assert(es == Acad::eOk);
|
|
|
|
es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbMultiStair"));
|
|
assert(es == Acad::eOk);
|
|
pFiler->writeInt16(AcDb::kDxfInt16, (Adesk::UInt16)m_nStairFlag);
|
|
pFiler->writeInt16(AcDb::kDxfInt16+1, (Adesk::UInt16)m_nPathSide);
|
|
pFiler->writeInt16(75, (Adesk::UInt16)m_nViewCtrl);
|
|
pFiler->writeDouble(48, m_nElevation);
|
|
pFiler->writeDouble(49, m_nStairHeight);
|
|
for(int n=0; n<m_polySide2d.Length(); n++)
|
|
pFiler->writePoint2d(10, m_polySide2d[n]);
|
|
|
|
pFiler->writeDouble(40, m_nStepHeight);
|
|
pFiler->writeDouble(41, m_lSectPos);
|
|
pFiler->writeDouble(42, m_rSectPos);
|
|
pFiler->writeDouble(43, m_nStepWidth);
|
|
pFiler->writeDouble(44, m_nStairWidth);
|
|
pFiler->writeInt32(90, m_nFlagEx);
|
|
pFiler->writeDouble(145, m_nBeamHeight);
|
|
pFiler->writeDouble(146,m_nBeamThick);
|
|
pFiler->writeDouble(147,m_nSlabThick);
|
|
pFiler->writeString(412, (const TCHAR*)LayerId2String(m_idLayerStep3d));
|
|
pFiler->writeString(413, (const TCHAR*)LayerId2String(m_idLayerBeam3d));
|
|
pFiler->writeString(414, (const TCHAR*)LayerId2String(m_idLayerHand3d));
|
|
pFiler->writeString(415, (const TCHAR*)LayerId2String(m_idLayerRail3d));
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
Adesk::UInt8 TDbMultiStair::GetSegType(long i)const
|
|
{
|
|
if(m_lstSegType.Length()==0)
|
|
return (Adesk::UInt8)(i%2);
|
|
else if(i<m_lstSegType.Length())
|
|
return m_lstSegType[i];
|
|
else
|
|
{
|
|
Adesk::UInt8 lastType=m_lstSegType[m_lstSegType.Length()-1];
|
|
if(((i-m_lstSegType.Length()+1)%2)==0)
|
|
return lastType;
|
|
else
|
|
return 1-lastType;
|
|
}
|
|
}
|
|
void TDbMultiStair::SetSegType(long i,Adesk::UInt8 type)
|
|
{
|
|
assertWriteEnabled();
|
|
if(i<m_lstSegType.Length())
|
|
*m_lstSegType[i]=type;
|
|
else
|
|
{
|
|
for(long n=m_lstSegType.Length();n<i;n++)
|
|
m_lstSegType.Append(new Adesk::UInt8(GetSegType(n)));
|
|
|
|
m_lstSegType.Append(new Adesk::UInt8(type));
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbMultiStair::subGetGripPoints(AcGePoint3dArray& gripPoints,
|
|
AcDbIntArray& osnapModes,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
assertReadEnabled();
|
|
for(int i=0; i<m_polySide2d.Length(); i++) {
|
|
XPoint pt=m_polySide2d[i];
|
|
gripPoints.append(pt);
|
|
}
|
|
//if(IsManualSectPos())
|
|
//modify by xlc on 080718
|
|
/*{
|
|
XPoint ptLeft, ptRight;
|
|
int nHit1=HitTestSectPos(0, ptLeft);
|
|
int nHit2=HitTestSectPos(1, ptRight);
|
|
if(nHit1 && nHit2) {
|
|
gripPoints.append(ptLeft);
|
|
gripPoints.append(ptRight);
|
|
}
|
|
}*/
|
|
DList<TDbEntity> lstComponents;
|
|
ExplodeTo(lstComponents);
|
|
DStack<TDbStair> stairs;
|
|
for(i=0; i<lstComponents.Length(); i++)
|
|
{
|
|
TDbEntity *pEnt=lstComponents[i];
|
|
if(pEnt->isKindOf(TDbStair::desc()))
|
|
stairs.Append((TDbStair *)pEnt);
|
|
}
|
|
|
|
//add by xlc on 090427
|
|
if(stairs.Length()<1)
|
|
return Acad::eOk;
|
|
|
|
TDbStair *pStair = stairs[0];
|
|
XPoint ptUpLeft2d,ptUpRight2d,ptLowLeft2d,ptLowRight2d;
|
|
ptUpLeft2d=pStair->GetUpLeft2d();
|
|
ptUpRight2d=pStair->GetUpRight2d();
|
|
ptLowLeft2d=pStair->GetLowLeft2d();
|
|
ptLowRight2d=pStair->GetLowRight2d();
|
|
|
|
double dir=ads_angle(ptLowLeft2d,ptLowRight2d);
|
|
// 起始端扶手伸出距离
|
|
XPoint ptTmp;
|
|
ads_polar(ptLowLeft2d, dir, GetRailDistToSide()+GetRailWidth()*0.5, ptTmp);
|
|
ads_polar(ptTmp, dir-PI*0.5, GetRailDist(), ptTmp);
|
|
gripPoints.append(ptTmp);
|
|
ads_polar(ptLowRight2d, dir+PI, GetRailDistToSide()+GetRailWidth()*0.5, ptTmp);
|
|
ads_polar(ptTmp, dir-PI*0.5, GetRailDist(), ptTmp);
|
|
gripPoints.append(ptTmp);
|
|
|
|
|
|
TDbStair *pStairE = stairs[stairs.Length()-1];
|
|
ptUpLeft2d=pStairE->GetUpLeft2d();
|
|
ptUpRight2d=pStairE->GetUpRight2d();
|
|
ptLowLeft2d=pStairE->GetLowLeft2d();
|
|
ptLowRight2d=pStairE->GetLowRight2d();
|
|
|
|
dir=ads_angle(ptLowLeft2d,ptLowRight2d);
|
|
|
|
// 终端扶手伸出距离
|
|
ads_polar(ptUpLeft2d, dir, GetRailDistToSide()+GetRailWidth()*0.5, ptTmp);
|
|
ads_polar(ptTmp, dir+PI*0.5, GetRailDistEnd(), ptTmp);
|
|
gripPoints.append(ptTmp);
|
|
ads_polar(ptUpRight2d, dir+PI, GetRailDistToSide()+GetRailWidth()*0.5, ptTmp);
|
|
ads_polar(ptTmp, dir+PI*0.5, GetRailDistEnd(), ptTmp);
|
|
gripPoints.append(ptTmp);
|
|
|
|
double lSectPos,rSectPos;
|
|
XPoint ptLeft2d,ptRight2d;
|
|
BOOL bSect=CalSectPos(stairs,lSectPos,rSectPos,ptLeft2d,ptRight2d);
|
|
if(bSect)
|
|
{
|
|
gripPoints.append(ptLeft2d);
|
|
gripPoints.append(ptRight2d);
|
|
XPoint ptMid;
|
|
Midpoint(ptLeft2d,ptRight2d,ptMid);
|
|
gripPoints.append(ptMid);
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbMultiStair::subGetStretchPoints(AcGePoint3dArray & stretchPoints) const
|
|
{
|
|
assertReadEnabled();
|
|
for(int i=0; i<m_polySide2d.Length(); i++) {
|
|
XPoint pt=m_polySide2d[i];
|
|
stretchPoints.append(pt);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbMultiStair::GetGripText(int i, CString &cs) const
|
|
{
|
|
int idx=(i-m_polySide2d.Length());
|
|
if(idx==0||idx==1)
|
|
{
|
|
cs=_T("首梯段扶手伸出距离");
|
|
}
|
|
else if(idx==2||idx==3)
|
|
{
|
|
cs=_T("尾梯段扶手伸出距离");
|
|
}
|
|
else if(idx==4||idx==5)
|
|
{
|
|
cs=_T("移动剖切线角度");
|
|
}
|
|
else if(idx==6)
|
|
{
|
|
cs= _T("移动剖切位置");
|
|
}
|
|
else
|
|
{
|
|
cs.Format(_T("移动第%d个顶点"), i);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
|
|
Acad::ErrorStatus
|
|
TDbMultiStair::subTransformBy(const AcGeMatrix3d& xform)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbEntity::subTransformBy(xform);
|
|
if(!IsValid())
|
|
return Acad::eInvalidInput;
|
|
|
|
double nOldZ=m_polySide2d[0]->z;
|
|
m_polySide2d.TransformBy(xform);
|
|
double nNewZ=m_polySide2d[0]->z;
|
|
m_nElevation += (nNewZ-nOldZ);
|
|
m_polySide2d.SetElevation(0.0);
|
|
if(IsMirrorMatrix(xform)) {
|
|
m_nPathSide = 1-m_nPathSide;
|
|
BOOL bRail1=HasHandRail(0);
|
|
BOOL bRail2=HasHandRail(1);
|
|
SetHandRail(0, bRail2);
|
|
SetHandRail(1, bRail1);
|
|
BOOL bBeam1=HasSideBeam(0);
|
|
BOOL bBeam2=HasSideBeam(1);
|
|
SetSideBeam(0, bBeam2);
|
|
SetSideBeam(1, bBeam1);
|
|
BOOL bWall1=IsAlongWall(0);
|
|
BOOL bWall2=IsAlongWall(1);
|
|
SetAlongWall(0, bWall2);
|
|
SetAlongWall(1, bWall1);
|
|
|
|
TchPrivate::Exchange(m_lSectPos,m_rSectPos);//add by whl on 070416
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbMultiStair::subMoveGripPointsAt(const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
assertWriteEnabled();
|
|
XPoint vtOffset=*(XPoint *)&offset;
|
|
vtOffset.z = 0;
|
|
|
|
for(int i=0; i<indices.length(); i++) {
|
|
int idx=indices[i];
|
|
if(idx<m_polySide2d.Length())
|
|
{
|
|
//modify by xlc on 080722 不让夹点拖到一起
|
|
// *m_polySide2d[idx] += vtOffset;
|
|
XPoint pt=*m_polySide2d[idx];
|
|
pt += vtOffset;
|
|
if(idx>0&&idx<m_polySide2d.Length()-1)
|
|
{
|
|
if(pt.Distance2d(*m_polySide2d[idx-1])>_DIST_SNAP
|
|
&&pt.Distance2d(*m_polySide2d[idx+1])>_DIST_SNAP)
|
|
{
|
|
*m_polySide2d[idx] += vtOffset;
|
|
}
|
|
}
|
|
else if(idx==0)
|
|
{
|
|
if(pt.Distance2d(*m_polySide2d[idx+1])>_DIST_SNAP)
|
|
{
|
|
*m_polySide2d[idx] += vtOffset;
|
|
}
|
|
}
|
|
else if(idx==m_polySide2d.Length()-1)
|
|
{
|
|
if(pt.Distance2d(*m_polySide2d[idx-1])>_DIST_SNAP)
|
|
{
|
|
*m_polySide2d[idx] += vtOffset;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
idx -= m_polySide2d.Length();
|
|
|
|
DList<TDbEntity> lstComponents;
|
|
ExplodeTo(lstComponents);
|
|
DStack<TDbStair> stairs;
|
|
for(int i=0; i<lstComponents.Length(); i++)
|
|
{
|
|
TDbEntity *pEnt=lstComponents[i];
|
|
if(pEnt->isKindOf(TDbStair::desc()))
|
|
stairs.Append((TDbStair *)pEnt);
|
|
}
|
|
if(idx==0||idx==1)
|
|
{
|
|
TDbLineStair *pStair=(TDbLineStair *)stairs[0];
|
|
double dRotation=pStair->GetRotation();
|
|
double nVtRot=CT_std_angle(ads_angle(XPoint(), vtOffset)-dRotation);
|
|
double nIncWidth=ads_distance(XPoint(), vtOffset) * cos(nVtRot);
|
|
double nIncLen=ads_distance(XPoint(), vtOffset) * sin(nVtRot);
|
|
|
|
if(m_nRailDist-nIncLen>-0.5*pStair->GetStairLength()-_DIST_SNAP)
|
|
{
|
|
m_nRailDist -= nIncLen;
|
|
}
|
|
}
|
|
else if(idx==2|| idx==3)
|
|
{
|
|
TDbLineStair *pStair=(TDbLineStair *)stairs[stairs.Length()-1];
|
|
double dRotation=pStair->GetRotation();
|
|
double nVtRot=CT_std_angle(ads_angle(XPoint(), vtOffset)-dRotation);
|
|
double nIncWidth=ads_distance(XPoint(), vtOffset) * cos(nVtRot);
|
|
double nIncLen=ads_distance(XPoint(), vtOffset) * sin(nVtRot);
|
|
|
|
if(m_nRailDistEnd+nIncLen>-0.5*pStair->GetStairLength()-_DIST_SNAP)
|
|
{
|
|
m_nRailDistEnd += nIncLen;
|
|
}
|
|
}
|
|
else if(idx==4 || idx==5 || idx == 6)
|
|
{
|
|
//modify by xlc on 080718
|
|
/*XPoint ptHit2d;
|
|
XPoly2D poly2d;
|
|
GetSidePoly2d(idx, poly2d);
|
|
if(HitTestSectPos(idx, ptHit2d)) {
|
|
if(!IsManualSectPos())
|
|
{
|
|
SetManualSectPos(TRUE);
|
|
SetDefaultSectPos();
|
|
}
|
|
ptHit2d += vtOffset;
|
|
AcDbPolyline pline;
|
|
PolyConvert(poly2d, pline);
|
|
XPoint ptNear=ptHit2d;
|
|
pline.getClosestPointTo(ptNear, ptHit2d);
|
|
double val=poly2d.PathDistance2d(ptHit2d);
|
|
if(idx==0)
|
|
m_lSectPos=val;
|
|
else
|
|
m_rSectPos=val;
|
|
}*/
|
|
|
|
double lSectPos,rSectPos;
|
|
XPoint ptLeft2d,ptRight2d;
|
|
double angle=m_dSectRotation;
|
|
BOOL bSect=CalSectPos(stairs,lSectPos,rSectPos,ptLeft2d,ptRight2d);
|
|
int nSectStair=GetSectStairPos(stairs);
|
|
if(bSect)
|
|
{
|
|
XPoint ptMid;
|
|
Midpoint(ptLeft2d,ptRight2d,ptMid);
|
|
if(idx==6)
|
|
{
|
|
XPoint ptHit2d;
|
|
ptHit2d=ptMid;
|
|
ptHit2d += vtOffset;
|
|
double elev=HitElevationByPoint2d(stairs,ptHit2d);
|
|
if(elev>_DIST_SNAP)
|
|
m_dSectElev=elev;
|
|
}
|
|
else
|
|
{
|
|
XPoint ptTmp;
|
|
TDbLineStair *pStair=(TDbLineStair *)stairs[nSectStair];
|
|
ads_polar(ptMid, pStair->GetRotation(), pStair->GetStairWidth(), ptTmp);
|
|
AcGeVector3d vectFrom,vectTo;
|
|
vectFrom=ptMid-ptTmp;
|
|
if(idx%2==0)
|
|
{
|
|
ptTmp=ptLeft2d+vtOffset;
|
|
vectTo=ptTmp-ptMid;
|
|
}
|
|
else
|
|
{
|
|
ptTmp=ptRight2d+vtOffset;
|
|
vectTo=ptMid-ptTmp;
|
|
}
|
|
angle=vectFrom.angleTo(vectTo,AcGeVector3d::kZAxis);
|
|
SetSectRotation(angle);
|
|
}
|
|
CalSectPos(stairs,m_lSectPos,m_rSectPos,ptLeft2d,ptRight2d);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbMultiStair::subMoveStretchPointsAt(const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
return subMoveGripPointsAt(indices, offset);
|
|
}
|
|
|
|
const TCHAR *
|
|
TDbMultiStair::GetDefaultLayer() const
|
|
{
|
|
return LAY_STAIR;
|
|
}
|
|
|
|
void
|
|
TDbMultiStair::GetTips(DList<TObjInfoUnit> &lstInfo) const
|
|
{
|
|
lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("多跑楼梯")));
|
|
//lstInfo.Append(new TObjInfoUnit(_T("总步数"), XString(_T("%d"), int(GetTotalStepNum()))));
|
|
lstInfo.Append(new TObjInfoUnit(_T("踏步高"), Dist2Str(GetStepHeight())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("楼梯高"), Dist2Str(GetStairHeight())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("边梁宽"), Dist2Str(GetBeamThick())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("板厚"), Dist2Str(GetSlabThick())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("扶手宽"), Dist2Str(GetRailWidth())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("扶手边距"), Dist2Str(GetRailDistToSide())));
|
|
|
|
lstInfo.Append(new TObjInfoUnit(_T("首梯段扶手距离"), Dist2Str(GetRailDist())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("尾梯段扶手距离"), Dist2Str(GetRailDistEnd())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("剖切高度"), Dist2Str(GetSectElev())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("低标高"), Dist2Str(GetElevation())));
|
|
|
|
const TCHAR *pszFloor=_T("首层");
|
|
if(m_nStairFlag==1)
|
|
pszFloor=_T("中间层");
|
|
else if(m_nStairFlag==2)
|
|
pszFloor=_T("顶层");
|
|
lstInfo.Append(new TObjInfoUnit(_T("基线位置"), m_nPathSide? _T("右边") : _T("左边")));
|
|
lstInfo.Append(new TObjInfoUnit(_T("左边梁"), HasSideBeam(OFFSET_LEFT)? _T("有") : _T("无")));
|
|
lstInfo.Append(new TObjInfoUnit(_T("右边梁"), HasSideBeam(OFFSET_RIGHT)? _T("有") : _T("无")));
|
|
}
|
|
|
|
// sg add 101115，支持统一标高
|
|
bool TDbMultiStair::UnifyElevation(double dElevation)
|
|
{
|
|
assertWriteEnabled();
|
|
SetElevation(dElevation);
|
|
return true;
|
|
}
|
|
|
|
|
|
// lstComponents－梯段、平台、扶手
|
|
Acad::ErrorStatus
|
|
TDbMultiStair::ExplodeTo(DList<TDbEntity> &lstComponents) const
|
|
{
|
|
assertReadEnabled();
|
|
if(!IsValid())
|
|
return Acad::eInvalidInput;
|
|
|
|
int nStairIdx=0;
|
|
double nStepHeight=GetStepHeight();
|
|
int numVerts=m_polySide2d.Length();
|
|
XPoly2D polyLeft, polyRight;
|
|
if(m_nPathSide)
|
|
{
|
|
polyRight=m_polySide2d;
|
|
polyRight.QuickOffset(-m_nStairWidth, polyLeft);
|
|
}
|
|
else
|
|
{
|
|
polyLeft=m_polySide2d;
|
|
polyLeft.QuickOffset(m_nStairWidth, polyRight);
|
|
}
|
|
|
|
//add by xlc on 090427 拖动夹点后自相交时崩溃
|
|
if(polyLeft.Length()!=polyRight.Length())
|
|
return Acad::eInvalidInput;
|
|
|
|
BOOL bLeftWall=IsAlongWall(0); //是否左边靠墙
|
|
BOOL bRightWall=IsAlongWall(1); //是否右边靠墙
|
|
double nSegHeight=m_nStairHeight;
|
|
BOOL bStairSeg=TRUE;
|
|
double nElev=m_nElevation;
|
|
XLine lnPrevTop; //上一个梯段的末尾
|
|
XPoly2D lPolySide, rPolySide;
|
|
|
|
//add by xlc on 080718
|
|
XPoly2D polyArrowDown,polyArrowUp;//箭头线
|
|
double dHeight=0; //起始高度
|
|
BOOL bEnd=FALSE; //是否结束上楼箭头
|
|
if(m_nStairFlag==SF_TOP)
|
|
bEnd=TRUE;
|
|
double dStepHeight=nStepHeight,dStepWidth=GetStepWidth();
|
|
|
|
for(int i=0; i<numVerts-1; i++)
|
|
{
|
|
bStairSeg=GetSegType(i)==0;
|
|
|
|
XLine lCurrent(*polyLeft[i], *polyLeft[i+1], LS_INFINITE);
|
|
XLine rCurrent(*polyRight[i], *polyRight[i+1], LS_INFINITE);
|
|
XLine lNext, lPrev, rNext, rPrev;
|
|
BOOL bNext=(i+2<numVerts);
|
|
BOOL bPrev=(i>0);
|
|
if(bNext)
|
|
{
|
|
lNext.StartPoint()=*polyLeft[i+1];
|
|
lNext.EndPoint()=*polyLeft[i+2];
|
|
rNext.StartPoint()=*polyRight[i+1];
|
|
rNext.EndPoint()=*polyRight[i+2];
|
|
}
|
|
if(bPrev)
|
|
{
|
|
lPrev.StartPoint()=*polyLeft[i-1];
|
|
lPrev.EndPoint()=*polyLeft[i];
|
|
rPrev.StartPoint()=*polyRight[i-1];
|
|
rPrev.EndPoint()=*polyRight[i];
|
|
}
|
|
|
|
if(bStairSeg)
|
|
{ //梯段
|
|
XPoint pt1, pt2;
|
|
rCurrent.StartPoint().Project(&lCurrent, pt1);
|
|
rCurrent.EndPoint().Project(&lCurrent, pt2);
|
|
XLine lnLeftSeg;
|
|
if((pt1&lCurrent)!=PR_INSIDE)
|
|
lnLeftSeg.StartPoint()=lCurrent.StartPoint();
|
|
else
|
|
lnLeftSeg.StartPoint()=pt1;
|
|
if((pt2&lCurrent)!=PR_INSIDE)
|
|
lnLeftSeg.EndPoint()=lCurrent.EndPoint();
|
|
else
|
|
lnLeftSeg.EndPoint()=pt2;
|
|
if(!CT_IsExactSameDrt(lCurrent.Direction(), lnLeftSeg.Direction(), _angSnap))
|
|
return Acad::eInvalidInput;
|
|
TDbLineStair *pStair=new TDbLineStair;
|
|
pStair->setPropertiesFrom(this);
|
|
pStair->SetLocation(lnLeftSeg.StartPoint());
|
|
pStair->SetElevation(nElev);
|
|
pStair->SetStepHeight(m_nStepHeight);
|
|
pStair->SetStepWidth(m_nStepWidth);
|
|
pStair->SetAscent(IsAscent());
|
|
pStair->SetAlongWall(0, bLeftWall);
|
|
pStair->SetAlongWall(1, bRightWall);
|
|
double nLeftLen=lnLeftSeg.GetLength();
|
|
int nStepNum=TNumeric(nLeftLen/m_nStepWidth).AsInt();
|
|
if(!IsAscent()) nStepNum++;
|
|
if(nStepNum*m_nStepHeight>nSegHeight+_DIST_SNAP)
|
|
{//基线太长了
|
|
nStepNum = AS_INT(nSegHeight/m_nStepHeight); //按照四舍五入
|
|
pStair->SetStepHeight(nSegHeight/nStepNum);
|
|
}
|
|
nSegHeight -= nStepNum*pStair->GetStepHeight();
|
|
if(nSegHeight<2*m_nStepHeight)
|
|
{
|
|
pStair->SetStepHeight((nSegHeight+nStepNum*m_nStepHeight)/nStepNum);
|
|
nSegHeight=0.0;
|
|
}
|
|
pStair->SetStepNum(nStepNum);
|
|
pStair->SetRotation(CT_std_angle(lnLeftSeg.Direction()-PI/2));
|
|
pStair->SetStairWidth(m_nStairWidth);
|
|
pStair->SetBeamHeight(GetBeamHeight());
|
|
pStair->SetBeamThick(GetBeamThick());
|
|
pStair->SetSlabThick(GetSlabThick());
|
|
pStair->SetOnGround(IsOnGround());
|
|
pStair->SetSlant(HasSlant());
|
|
pStair->SetSideBeam(0, HasSideBeam(0));
|
|
pStair->SetSideBeam(1, HasSideBeam(1));
|
|
pStair->Set2DFlag(SF_NOSECT);
|
|
|
|
//add by xlc on 080718
|
|
if(IsArrow())
|
|
{
|
|
XPoint ptStartMid;
|
|
ads_polar(pStair->GetLocation(),pStair->GetRotation(),pStair->GetStairWidth()*0.5,ptStartMid);
|
|
ptStartMid.z=0;
|
|
|
|
XPoint ptStart;
|
|
if(!bPrev)//首梯段
|
|
{
|
|
if(m_nStairFlag==SF_TOP)
|
|
{
|
|
ads_polar(ptStartMid,pStair->GetRotation()+PI*0.5,pStair->GetStepWidth(),ptStart);
|
|
polyArrowDown.AppendNode(ptStart);
|
|
}
|
|
else
|
|
{
|
|
ads_polar(ptStartMid,pStair->GetRotation()-PI*0.5,pStair->GetStepWidth()*0.5,ptStart);
|
|
polyArrowUp.AppendNode(ptStart);
|
|
}
|
|
}
|
|
if(m_nStairFlag!=SF_TOP)
|
|
{
|
|
double dSectElev=GetSectElev();
|
|
if(IsAscent()&&fabs(dSectElev-dHeight)<0.2*pStair->GetStepHeight())
|
|
{
|
|
if(dSectElev-dHeight>_DIST_SNAP)
|
|
{
|
|
dSectElev=dHeight+0.3*pStair->GetStepHeight();
|
|
}
|
|
else
|
|
{
|
|
dSectElev=dHeight-0.3*pStair->GetStepHeight();
|
|
}
|
|
}
|
|
if(!bEnd&&dSectElev>dHeight&&dSectElev<dHeight+pStair->GetStairHeight()) //剖切当前梯段
|
|
{
|
|
bEnd=TRUE;
|
|
if(m_nStairFlag==SF_FIRST)
|
|
pStair->Set2DFlag(SF_1SECT);
|
|
else
|
|
pStair->Set2DFlag(SF_2SECT);
|
|
|
|
double dist=(dSectElev-dHeight)*pStair->GetStairLength()/pStair->GetStairHeight();//剖切位置到当前梯段顶点的距离
|
|
if(!IsAscent())
|
|
{
|
|
dist=(dSectElev-dHeight)*(pStair->GetStepWidth())/pStair->GetStepHeight();
|
|
if(dist>pStair->GetStairLength())
|
|
{
|
|
dist -= pStair->GetStepWidth();
|
|
}
|
|
}
|
|
|
|
ads_polar(ptStartMid,pStair->GetRotation()+PI*0.5,dist-pStair->GetStepWidth()*0.5,ptStart);
|
|
polyArrowUp.AppendNode(ptStart);
|
|
|
|
ads_polar(ptStartMid,pStair->GetRotation()+PI*0.5,dist+pStair->GetStepWidth()*0.5,ptStart);
|
|
polyArrowDown.AppendNode(ptStart);
|
|
}
|
|
else if(GetSectElev()>dHeight+pStair->GetStairHeight())
|
|
{
|
|
dHeight+=pStair->GetStairHeight();
|
|
}
|
|
}
|
|
if(!bNext
|
|
||nSegHeight<_DIST_SNAP //add by xlc on 090428梯段结束时路径还有边未结束
|
|
)//末梯段
|
|
{
|
|
ads_polar(ptStartMid,pStair->GetRotation()+PI*0.5,pStair->GetStairLength()+pStair->GetStepWidth()*0.5,ptStart);
|
|
polyArrowDown.AppendNode(ptStart);
|
|
}
|
|
}
|
|
dStepWidth=pStair->GetStepWidth();
|
|
dStepHeight=pStair->GetStepHeight();
|
|
|
|
if(m_nStairFlag==SF_TOP)
|
|
pStair->SetHas3D(FALSE);
|
|
|
|
// 设置图层
|
|
pStair->SetLayerBeam3d(m_idLayerBeam3d);
|
|
pStair->SetLayerStep3d(m_idLayerStep3d);
|
|
|
|
lstComponents.Append(pStair);
|
|
lnPrevTop.StartPoint() = pStair->GetUpLeft2d();
|
|
lnPrevTop.EndPoint() = pStair->GetUpRight2d();
|
|
|
|
// 设置扶手路径，拐角处
|
|
if(HasHandRail(OFFSET_LEFT))
|
|
{
|
|
XPoint qt1=pStair->GetLowLeft2d();
|
|
XPoint qt2=pStair->GetUpLeft2d();
|
|
qt1.z=qt2.z=nElev;
|
|
qt2.z += pStair->GetStairHeight();
|
|
if(!lPolySide.Tail() || lPolySide.Tail()->Distance2d(qt1)>_DIST_SNAP)
|
|
lPolySide.AppendNode(qt1);
|
|
lPolySide.AppendNode(qt2);
|
|
}
|
|
if(HasHandRail(OFFSET_RIGHT))
|
|
{
|
|
XPoint qt1=pStair->GetLowRight2d();
|
|
XPoint qt2=pStair->GetUpRight2d();
|
|
qt1.z=qt2.z=nElev;
|
|
qt2.z += pStair->GetStairHeight();
|
|
if(!rPolySide.Tail() || rPolySide.Tail()->Distance2d(qt1)>_DIST_SNAP)
|
|
rPolySide.AppendNode(qt1);
|
|
rPolySide.AppendNode(qt2);
|
|
}
|
|
|
|
nElev += pStair->GetStairHeight();
|
|
if(nSegHeight<_DIST_SNAP)
|
|
break;
|
|
}
|
|
else
|
|
{ //平台
|
|
if(!bPrev || !bNext)//平台不能在首尾
|
|
return Acad::eInvalidInput;
|
|
|
|
XPoint pt1, pt2;
|
|
rNext.StartPoint().Project(&lNext, pt1);
|
|
rNext.EndPoint().Project(&lNext, pt2);
|
|
XLine lnLeftNext;
|
|
if((pt1&lNext)!=PR_INSIDE)
|
|
lnLeftNext.StartPoint()=lNext.StartPoint();
|
|
else
|
|
lnLeftNext.StartPoint()=pt1;
|
|
if((pt2&lNext)!=PR_INSIDE)
|
|
lnLeftNext.EndPoint()=lNext.EndPoint();
|
|
else
|
|
lnLeftNext.EndPoint()=pt2;
|
|
if(!CT_IsExactSameDrt(lNext.Direction(), lnLeftNext.Direction(), _angSnap))
|
|
return Acad::eInvalidInput;
|
|
|
|
XLine lnRightNext=lnLeftNext.Offset(m_nStairWidth);
|
|
|
|
XPoly2D poly2d(1);
|
|
XPoint ptStartMid,ptEndMid;
|
|
if(GetSegType(i-1)==0&&GetSegType(i+1)==0)//前后都是梯段
|
|
{
|
|
poly2d.AppendNode(lnPrevTop.StartPoint());
|
|
poly2d.AppendNode(lnPrevTop.EndPoint());
|
|
poly2d.AppendNode(rCurrent.StartPoint());
|
|
poly2d.AppendNode(rCurrent.EndPoint());
|
|
poly2d.AppendNode(lnRightNext.StartPoint());
|
|
poly2d.AppendNode(lnLeftNext.StartPoint());
|
|
poly2d.AppendNode(lCurrent.EndPoint());
|
|
poly2d.AppendNode(lCurrent.StartPoint());
|
|
|
|
ptStartMid = lnPrevTop.MidPoint();
|
|
Midpoint(lnRightNext.StartPoint(),lnLeftNext.StartPoint(),ptEndMid);
|
|
}
|
|
else if(GetSegType(i-1)==0)//前面梯段后面平台
|
|
{
|
|
poly2d.AppendNode(lnPrevTop.StartPoint());
|
|
poly2d.AppendNode(lnPrevTop.EndPoint());
|
|
poly2d.AppendNode(rCurrent.StartPoint());
|
|
poly2d.AppendNode(rCurrent.EndPoint());
|
|
poly2d.AppendNode(lCurrent.EndPoint());
|
|
poly2d.AppendNode(lCurrent.StartPoint());
|
|
|
|
ptStartMid = lnPrevTop.MidPoint();
|
|
Midpoint(rCurrent.EndPoint(),lCurrent.EndPoint(),ptEndMid);
|
|
}
|
|
else if(GetSegType(i-1)==1&&GetSegType(i+1)==0)//前面平台后面梯段
|
|
{
|
|
poly2d.AppendNode(rCurrent.StartPoint());
|
|
poly2d.AppendNode(rCurrent.EndPoint());
|
|
poly2d.AppendNode(lnRightNext.StartPoint());
|
|
poly2d.AppendNode(lnLeftNext.StartPoint());
|
|
poly2d.AppendNode(lCurrent.EndPoint());
|
|
poly2d.AppendNode(lCurrent.StartPoint());
|
|
|
|
Midpoint(rCurrent.StartPoint(),lCurrent.StartPoint(),ptStartMid);
|
|
Midpoint(lnRightNext.StartPoint(),lnLeftNext.StartPoint(),ptEndMid);
|
|
}
|
|
else//前后都平台
|
|
{
|
|
poly2d.AppendNode(rCurrent.StartPoint());
|
|
poly2d.AppendNode(rCurrent.EndPoint());
|
|
poly2d.AppendNode(lCurrent.EndPoint());
|
|
poly2d.AppendNode(lCurrent.StartPoint());
|
|
|
|
Midpoint(rCurrent.StartPoint(),lCurrent.StartPoint(),ptStartMid);
|
|
Midpoint(rCurrent.EndPoint(),lCurrent.EndPoint(),ptEndMid);
|
|
}
|
|
|
|
//add by xlc on 080718
|
|
if(IsArrow())
|
|
{
|
|
int bAddInt=FALSE; //添加折点
|
|
XPoint ptInt1,ptInt2; //平台转折点
|
|
if(!(GetSegType(i-1)==1&&GetSegType(i+1)==1))//前后都是平台除外
|
|
{
|
|
Midpoint(lCurrent.StartPoint(),rCurrent.StartPoint(),ptInt1);
|
|
Midpoint(lCurrent.EndPoint(),rCurrent.EndPoint(),ptInt2);
|
|
bAddInt=TRUE;
|
|
}
|
|
if(bEnd)
|
|
{
|
|
polyArrowDown.AppendNode(ptStartMid);
|
|
if(bAddInt)
|
|
{
|
|
polyArrowDown.AppendNode(ptInt1);
|
|
polyArrowDown.AppendNode(ptInt2);
|
|
}
|
|
polyArrowDown.AppendNode(ptEndMid);
|
|
}
|
|
else
|
|
{
|
|
polyArrowUp.AppendNode(ptStartMid);
|
|
if(bAddInt)
|
|
{
|
|
polyArrowUp.AppendNode(ptInt1);
|
|
polyArrowUp.AppendNode(ptInt2);
|
|
}
|
|
polyArrowUp.AppendNode(ptEndMid);
|
|
}
|
|
}
|
|
|
|
poly2d.Compress(false);
|
|
if(poly2d.PathArea()<-_DIST_SNAP*_DIST_SNAP)
|
|
{
|
|
TDbSlab *pSlab = new TDbSlab;
|
|
pSlab->setPropertiesFrom(this);
|
|
pSlab->SetOutline(poly2d);
|
|
pSlab->SetElevation(nElev);
|
|
if(IsAscent()&&IsOnGround())
|
|
pSlab->SetThickness(m_nElevation-nElev);
|
|
else
|
|
pSlab->SetThickness(-m_nSlabThick);
|
|
pSlab->setLayer(m_idLayerStep3d);
|
|
|
|
int nTest=poly2d.HitTestOnCurve(ptStartMid);
|
|
if(nTest<0)
|
|
{
|
|
int nEdgeIndex=abs(nTest)-1;
|
|
pSlab->SetVisibilityAt(nEdgeIndex, FALSE);
|
|
}
|
|
nTest=poly2d.HitTestOnCurve(ptEndMid);
|
|
if(nTest<0)
|
|
{
|
|
int nEdgeIndex=abs(nTest)-1;
|
|
pSlab->SetVisibilityAt(nEdgeIndex, FALSE);
|
|
}
|
|
|
|
if(bLeftWall)
|
|
{ //左边不可见
|
|
XPoint ptTest1, ptTest2, ptTest3;
|
|
ptTest1 = lCurrent.MidPoint();
|
|
Midpoint(lCurrent.EndPoint(), lnLeftNext.StartPoint(), ptTest2);
|
|
Midpoint(lCurrent.StartPoint(), lnPrevTop.StartPoint(), ptTest3);
|
|
int nTest1=poly2d.HitTestOnCurve(ptTest1);
|
|
int nTest2=poly2d.HitTestOnCurve(ptTest2);
|
|
int nTest3=poly2d.HitTestOnCurve(ptTest3);
|
|
if(nTest1<0)
|
|
{
|
|
int nEdgeIndex=abs(nTest1)-1;
|
|
pSlab->SetVisibilityAt(nEdgeIndex, FALSE);
|
|
}
|
|
if(nTest2<0 && nTest2!=nTest1)
|
|
{
|
|
int nEdgeIndex=abs(nTest2)-1;
|
|
pSlab->SetVisibilityAt(nEdgeIndex, FALSE);
|
|
}
|
|
if(nTest3<0 && nTest3!=nTest1 && nTest3!=nTest2)
|
|
{
|
|
int nEdgeIndex=abs(nTest3)-1;
|
|
pSlab->SetVisibilityAt(nEdgeIndex, FALSE);
|
|
}
|
|
}
|
|
if(bRightWall)
|
|
{
|
|
XPoint ptTest1, ptTest2, ptTest3;
|
|
ptTest1 = rCurrent.MidPoint();
|
|
Midpoint(rCurrent.EndPoint(), lnRightNext.StartPoint(), ptTest2);
|
|
Midpoint(rCurrent.StartPoint(), lnPrevTop.EndPoint(), ptTest3);
|
|
int nTest1=poly2d.HitTestOnCurve(ptTest1);
|
|
int nTest2=poly2d.HitTestOnCurve(ptTest2);
|
|
int nTest3=poly2d.HitTestOnCurve(ptTest3);
|
|
if(nTest1<0)
|
|
{
|
|
int nEdgeIndex=abs(nTest1)-1;
|
|
pSlab->SetVisibilityAt(nEdgeIndex, FALSE);
|
|
}
|
|
if(nTest2<0 && nTest2!=nTest1)
|
|
{
|
|
int nEdgeIndex=abs(nTest2)-1;
|
|
pSlab->SetVisibilityAt(nEdgeIndex, FALSE);
|
|
}
|
|
if(nTest3<0 && nTest3!=nTest1 && nTest3!=nTest2)
|
|
{
|
|
int nEdgeIndex=abs(nTest3)-1;
|
|
pSlab->SetVisibilityAt(nEdgeIndex, FALSE);
|
|
}
|
|
}
|
|
lstComponents.Append(pSlab);
|
|
}
|
|
if(lnPrevTop.StartPoint().Distance2d(lCurrent.StartPoint())>_DIST_SNAP)
|
|
lPolySide.AppendNode(XPoint(lCurrent.StartPoint().x, lCurrent.StartPoint().y, nElev));
|
|
if(lnLeftNext.StartPoint().Distance(lCurrent.EndPoint())>_DIST_SNAP)
|
|
lPolySide.AppendNode(XPoint(lCurrent.EndPoint().x, lCurrent.EndPoint().y, nElev));
|
|
if(lnPrevTop.EndPoint().Distance2d(rCurrent.StartPoint())>_DIST_SNAP)
|
|
rPolySide.AppendNode(XPoint(rCurrent.StartPoint().x, rCurrent.StartPoint().y, nElev));
|
|
if(lnRightNext.StartPoint().Distance2d(rCurrent.EndPoint())>_DIST_SNAP)
|
|
rPolySide.AppendNode(XPoint(rCurrent.EndPoint().x, rCurrent.EndPoint().y, nElev));
|
|
}
|
|
}
|
|
|
|
double width=dStepWidth*0.5,height=dStepHeight*0.5;
|
|
if(IsAscent())
|
|
{
|
|
width=0;
|
|
height=0;
|
|
}
|
|
|
|
double elevS=0,elevE=0; //扶手伸出产生的高差
|
|
elevS=m_nRailDist*dStepHeight/dStepWidth;
|
|
elevE=m_nRailDistEnd*dStepHeight/dStepWidth;
|
|
|
|
|
|
if(HasHandRail(OFFSET_LEFT))
|
|
{
|
|
lPolySide.Compress(false);
|
|
XPoly2D polyPath0(lPolySide), polyPath;
|
|
polyPath0.SetElevation(0.0);
|
|
|
|
//modified by whl on 090326
|
|
if(polyPath0.QuickOffset(m_nRailDistToSide+m_nRailWidth/2, polyPath)==RTNORM&&
|
|
polyPath.Length()==lPolySide.Length()&&polyPath.Length()>1)
|
|
{
|
|
for(int kk=0; kk<polyPath.Length(); kk++)
|
|
polyPath[kk]->z = lPolySide[kk]->z;
|
|
|
|
// add by xlc on 080721 扶手伸出距离
|
|
double dir=ads_angle(*polyPath[1],*polyPath[0]);
|
|
XPoint ptA=*polyPath[0],ptB;
|
|
if(m_nRailDist>width+_DIST_SNAP)
|
|
{
|
|
ads_polar(ptA, dir, width, ptB);
|
|
*polyPath.Head() = ptB;
|
|
ads_polar(ptB, dir, m_nRailDist-width, ptB);
|
|
polyPath.InsertNodeAt(0,ptB);
|
|
}
|
|
else
|
|
{
|
|
ads_polar(ptA, dir, m_nRailDist, ptB);
|
|
ptB.z=GetElevation()+height-elevS;
|
|
*polyPath.Head() = ptB;
|
|
}
|
|
dir=ads_angle(*polyPath[polyPath.Length()-2],*polyPath[polyPath.Length()-1]);
|
|
ptA=*polyPath.Tail();
|
|
if(m_nRailDistEnd>width+_DIST_SNAP)
|
|
{
|
|
ads_polar(ptA, dir, width, ptB);
|
|
*polyPath.Tail() = ptB;
|
|
ads_polar(ptB, dir, m_nRailDistEnd-width, ptB);
|
|
polyPath.AppendNode(ptB);
|
|
}
|
|
else
|
|
{
|
|
ads_polar(ptA, dir, m_nRailDistEnd, ptB);
|
|
ptB.z=ptA.z-height+elevE;
|
|
*polyPath.Tail() = ptB;
|
|
}
|
|
|
|
TDbHandRail *pHand=new TDbHandRail;
|
|
pHand->setPropertiesFrom(this);
|
|
pHand->SetOutline(polyPath);
|
|
pHand->setLayer(m_idLayerHand3d);
|
|
pHand->SetHeight(m_nRailHeight);
|
|
pHand->SetWidth(m_nRailWidth);
|
|
if(m_nStairFlag==SF_TOP)
|
|
pHand->SetHas3D(FALSE);
|
|
lstComponents.Append(pHand);
|
|
}
|
|
}
|
|
|
|
if(HasHandRail(OFFSET_RIGHT))
|
|
{
|
|
rPolySide.Compress(false);
|
|
XPoly2D polyPath, polyPath0(rPolySide);
|
|
polyPath0.SetElevation(0.0);
|
|
|
|
//modified by whl on 090326
|
|
if(polyPath0.QuickOffset(-m_nRailDistToSide-m_nRailWidth/2, polyPath)==RTNORM&&
|
|
polyPath.Length()==rPolySide.Length()&&polyPath.Length()>1)
|
|
{
|
|
for(int kk=0; kk<polyPath.Length(); kk++)
|
|
polyPath[kk]->z = rPolySide[kk]->z;
|
|
|
|
// add by xlc on 080721 扶手伸出距离
|
|
double dir=ads_angle(*polyPath[1],*polyPath[0]);
|
|
XPoint ptA=*polyPath[0],ptB;
|
|
if(m_nRailDist>width+_DIST_SNAP)
|
|
{
|
|
ads_polar(ptA, dir, width, ptB);
|
|
*polyPath.Head() = ptB;
|
|
ads_polar(ptB, dir, m_nRailDist-width, ptB);
|
|
polyPath.InsertNodeAt(0,ptB);
|
|
}
|
|
else
|
|
{
|
|
ads_polar(ptA, dir, m_nRailDist, ptB);
|
|
ptB.z=GetElevation()+height-elevS;
|
|
*polyPath.Head() = ptB;
|
|
}
|
|
dir=ads_angle(*polyPath[polyPath.Length()-2],*polyPath[polyPath.Length()-1]);
|
|
ptA=*polyPath.Tail();
|
|
if(m_nRailDistEnd>width+_DIST_SNAP)
|
|
{
|
|
ads_polar(ptA, dir, width, ptB);
|
|
*polyPath.Tail() = ptB;
|
|
ads_polar(ptB, dir, m_nRailDistEnd-width, ptB);
|
|
polyPath.AppendNode(ptB);
|
|
}
|
|
else
|
|
{
|
|
ads_polar(ptA, dir, m_nRailDistEnd, ptB);
|
|
ptB.z=ptA.z-height+elevE;
|
|
*polyPath.Tail() = ptB;
|
|
}
|
|
|
|
TDbHandRail *pHand=new TDbHandRail;
|
|
pHand->setPropertiesFrom(this);
|
|
pHand->SetOutline(polyPath);
|
|
pHand->setLayer(m_idLayerHand3d);
|
|
pHand->SetHeight(m_nRailHeight);
|
|
pHand->SetWidth(m_nRailWidth);
|
|
if(m_nStairFlag==SF_TOP)
|
|
pHand->SetHas3D(FALSE);
|
|
lstComponents.Append(pHand);
|
|
}
|
|
}
|
|
|
|
//add by xlc on 080718
|
|
if(IsArrow())
|
|
{
|
|
if(m_nStairFlag!=SF_TOP)
|
|
{
|
|
polyArrowUp.Compress();
|
|
if(polyArrowUp.Length()>1)
|
|
{
|
|
TDbSymbArrow *pArrowUp=new TDbSymbArrow;
|
|
pArrowUp->SetPoly2D(polyArrowUp);
|
|
pArrowUp->setPropertiesFrom(this);
|
|
|
|
//add by xlc on 090212
|
|
pArrowUp->SetTextHeight(m_dTextHeight);
|
|
|
|
//modify by xlc on 090205
|
|
pArrowUp->SetLayoutRotation(GetLayoutRotation());
|
|
|
|
//modify by xlc on 090426
|
|
//pArrowUp->SetText(_T("上"));
|
|
pArrowUp->SetText(GetTextUp());
|
|
|
|
pArrowUp->SetTextAlign(TDbSymbArrow::kAtSide);
|
|
pArrowUp->SetTextLocation(pArrowUp->GetDefaultTextLocation());
|
|
pArrowUp->SetTextLayerId(m_idLayerText);
|
|
pArrowUp->SetTextStyleId(m_idTextStyle);
|
|
if(m_idLayerArrow.isValid())
|
|
{
|
|
pArrowUp->setLayer(m_idLayerArrow);
|
|
}
|
|
lstComponents.Append(pArrowUp);
|
|
}
|
|
}
|
|
if(m_nStairFlag!=SF_FIRST)
|
|
{
|
|
polyArrowDown.Reverse();
|
|
polyArrowDown.Compress();
|
|
if(polyArrowDown.Length()>1)
|
|
{
|
|
TDbSymbArrow *pArrowDown=new TDbSymbArrow;
|
|
pArrowDown->SetPoly2D(polyArrowDown);
|
|
pArrowDown->setPropertiesFrom(this);
|
|
|
|
//add by xlc on 090212
|
|
pArrowDown->SetTextHeight(m_dTextHeight);
|
|
|
|
pArrowDown->SetLayoutRotation(GetLayoutRotation());
|
|
|
|
//modify by xlc on 090426
|
|
//pArrowDown->SetText(_T("下"));
|
|
pArrowDown->SetText(GetTextDown());
|
|
|
|
pArrowDown->SetTextAlign(TDbSymbArrow::kAtSide);
|
|
pArrowDown->SetTextLocation(pArrowDown->GetDefaultTextLocation());
|
|
pArrowDown->SetTextLayerId(m_idLayerText);
|
|
pArrowDown->SetTextStyleId(m_idTextStyle);
|
|
if(m_idLayerArrow.isValid())
|
|
{
|
|
pArrowDown->setLayer(m_idLayerArrow);
|
|
}
|
|
lstComponents.Append(pArrowDown);
|
|
}
|
|
}
|
|
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
void TDbMultiStair::SwapPolySide()
|
|
{
|
|
assertWriteEnabled();
|
|
XPoly2D poly;
|
|
GetSidePoly2d(1-m_nPathSide,poly);
|
|
m_nPathSide=1-m_nPathSide;
|
|
m_polySide2d=poly;
|
|
}
|
|
Acad::ErrorStatus
|
|
TDbMultiStair::ExplodeOrDraw3d(XExplodeDraw &dc) const
|
|
{
|
|
if(m_nViewCtrl==1)
|
|
return Acad::eOk; //三维被禁止
|
|
|
|
assertReadEnabled();
|
|
if(m_nStairFlag==SF_TOP)
|
|
return Acad::eOk; // nothing is drawn
|
|
|
|
DList<TDbEntity> lstComponents;
|
|
Acad::ErrorStatus es = ExplodeTo(lstComponents);
|
|
for(int i=0; i<lstComponents.Length(); i++) {
|
|
TDbEntity *pEnt=lstComponents[i];
|
|
TPushProperty vProp(pEnt, dc);
|
|
if(dc.IsFullExplode()) {
|
|
pEnt->ExplodeOrDraw3d(dc);
|
|
} else {
|
|
dc.DrawEntity(*pEnt);
|
|
}
|
|
if(IsAscent()&&IsOnGround() && pEnt->isKindOf(TDbStair::desc())) { //补充一平台到底部
|
|
TDbStair *pStair=TDbStair::cast(pEnt);
|
|
ASSERT(pStair);
|
|
double nTopElev=pStair->GetElevation();
|
|
double nBotElev=GetElevation();
|
|
XPoint pt[4];
|
|
pt[0]=pStair->GetLowLeft2d();
|
|
pt[1]=pStair->GetLowRight2d();
|
|
pt[2]=pStair->GetUpRight2d();
|
|
pt[3]=pStair->GetUpLeft2d();
|
|
XPoly2D polyOutline(1);
|
|
for(int k=0; k<4; k++)
|
|
polyOutline.AppendNode(pt[k]);
|
|
TDbSlab slab;
|
|
slab.setPropertiesFrom(this);
|
|
slab.SetOutline(polyOutline);
|
|
slab.SetElevation(nBotElev);
|
|
slab.SetThickness(nTopElev-nBotElev);
|
|
TPushProperty vProp(&slab, dc);
|
|
|
|
if(dc.IsFullExplode()) {
|
|
slab.ExplodeOrDraw3d(dc);
|
|
} else {
|
|
dc.DrawEntity(slab);
|
|
}
|
|
}
|
|
if(IsAutoRail() && pEnt->isKindOf(TDbHandRail::desc())) {
|
|
dc.SetColorLayer(colorIndex(), m_idLayerRail3d);
|
|
TDbHandRail *pRail=TDbHandRail::cast(pEnt);
|
|
XPoly2D polyPath=pRail->GetOutline();
|
|
double nTotalDist=polyPath.Distance2d();
|
|
int nRailNum=AS_INT(nTotalDist/(IsAscent()? _AS_SYS_UNIT(300.0) : m_nStepWidth));
|
|
if(nRailNum<1)
|
|
nRailNum=1;
|
|
double nStepW=nTotalDist/nRailNum;
|
|
for(int iRail=1; iRail<=nRailNum; iRail++) {
|
|
double nDist=iRail*nStepW;
|
|
XPoint pt;
|
|
double nDir=0.0;
|
|
polyPath.Polar2d(nDist-nStepW/2, pt, &nDir);
|
|
XRectAngle box(pt, _AS_SYS_UNIT(40), _AS_SYS_UNIT(40));
|
|
XPoly2D poly2d;
|
|
box.AsPoly2D(poly2d);
|
|
dc.DrawMesh(poly2d, XVector3D(0,0,m_nRailHeight-_AS_SYS_UNIT(20)));
|
|
}
|
|
}
|
|
}
|
|
|
|
return es;
|
|
}
|
|
|
|
bool TDbMultiStair::IsClipMe(const TEntityBase* pEnt)const
|
|
{
|
|
if(TDbEntity::IsClipMe(pEnt))
|
|
return true;
|
|
|
|
if(pEnt->GetMe()->isKindOf(TDbColumn::desc()))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
Acad::ErrorStatus
|
|
TDbMultiStair::ExplodeOrDraw2d(XExplodeDraw &dc) const
|
|
{
|
|
if(m_nViewCtrl==2)
|
|
return Acad::eOk; //二维被禁止
|
|
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es=Acad::eOk;
|
|
if(_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0 ||
|
|
g_bOsnapExpl) {
|
|
XPushMemVar<BOOL> bExpl(g_bOsnapExpl, FALSE);
|
|
XPushMemVar<BOOL> bFull(XExplodeStream::m_bFullExplode, TRUE);
|
|
AcDbVoidPtrArray entSet;
|
|
XExplodeStream dcExp(entSet);
|
|
dcExp.SetPropertiesFrom(this); //add by whl on 060404
|
|
es = ExplodeOrDraw2d(dcExp);
|
|
INT_PTR nQuickMarker=GetQuickMarker();
|
|
int nGsMarker=1;
|
|
int nCount=entSet.length();
|
|
for(int i=0; i<nCount; i++) {
|
|
AcDbEntity *pEnt=(AcDbEntity *)entSet[i];
|
|
dc.SetSelectionMarker(nGsMarker);
|
|
nGsMarker++;
|
|
if(nQuickMarker && (nGsMarker-1)!=nQuickMarker) //用于捕捉时加速
|
|
continue;
|
|
|
|
dc.DrawEntity(*pEnt);
|
|
if(nQuickMarker && (nGsMarker-1)==nQuickMarker)
|
|
break;
|
|
}
|
|
ReleaseEntSet(entSet);
|
|
} else {
|
|
DList<TDbEntity> lstComponents;
|
|
es = ExplodeTo(lstComponents);
|
|
DStack<TDbHandRail> hands;
|
|
DStack<TDbStair> stairs;
|
|
DStack<TDbSlab> slabs;
|
|
DStack<TDbSymbArrow> symbArrows;
|
|
for(int i=0; i<lstComponents.Length(); i++) {
|
|
TDbEntity *pEnt=lstComponents[i];
|
|
if(pEnt->isKindOf(TDbHandRail::desc()))
|
|
hands.Append((TDbHandRail *)pEnt);
|
|
else if(pEnt->isKindOf(TDbStair::desc()))
|
|
stairs.Append((TDbStair *)pEnt);
|
|
else if(pEnt->isKindOf(TDbSlab::desc()))
|
|
slabs.Append((TDbSlab *)pEnt);
|
|
|
|
//add by xlc on 080718
|
|
else if(pEnt->isKindOf(TDbSymbArrow::desc()))
|
|
symbArrows.Append((TDbSymbArrow*)pEnt);
|
|
}
|
|
|
|
int nHit=0;
|
|
// XPoint ptHitLeft2d, ptHitRight2d;
|
|
// if(IsManualSectPos()) {
|
|
// int nHitLeft=HitTestSectPos(0, stairs, ptHitLeft2d);
|
|
// int nHitRight=HitTestSectPos(1, stairs, ptHitRight2d);
|
|
// if(nHitLeft==nHitRight && nHitLeft>0)
|
|
// nHit=nHitLeft;
|
|
// }
|
|
|
|
//add by xlc on 080718
|
|
if(IsArrow())
|
|
{
|
|
for(int i=0;i<symbArrows.Length();i++)
|
|
{
|
|
TDbSymbArrow *pSymbArrow=symbArrows[i];
|
|
if(dc.IsFullExplode())
|
|
{
|
|
TPushProperty vProp(pSymbArrow, dc);
|
|
pSymbArrow->ExplodeOrDraw2d(dc);
|
|
}
|
|
else
|
|
dc.DrawEntity(*pSymbArrow);
|
|
}
|
|
}
|
|
|
|
//add by xlc on 080718
|
|
double lSectPos,rSectPos;
|
|
XPoint ptLeft2d,ptRight2d;
|
|
BOOL bSect=CalSectPos(stairs,lSectPos,rSectPos,ptLeft2d,ptRight2d);
|
|
int nSectStair=GetSectStairPos(stairs);
|
|
|
|
TDbStair *pStair1=stairs.Head();
|
|
|
|
//del by xlc on 080718
|
|
/*if(pStair1 && !database()) { //绘制箭头
|
|
pStair1->SetArrow(TRUE);
|
|
}*/
|
|
|
|
if(m_nStairFlag==SF_FIRST && pStair1)
|
|
{ //首层，只绘制第一个梯段和扶手。如果定义剖切位置，则由剖切位置决定
|
|
|
|
// modified by xlc on 080718
|
|
/*if(nHit)
|
|
pStair1=stairs[nHit-1];
|
|
pStair1->Set2DFlag(SF_1SECT);
|
|
if(nHit) {
|
|
XDirectionCurve lCurve=pStair1->GetSideCurve2d(0);
|
|
XDirectionCurve rCurve=pStair1->GetSideCurve2d(1);
|
|
pStair1->SetSectionPos(0, lCurve.PathDistance(ptHitLeft2d)/lCurve.Length());
|
|
pStair1->SetSectionPos(1, rCurve.PathDistance(ptHitRight2d)/rCurve.Length());
|
|
}*/
|
|
if(bSect && nSectStair>=0)
|
|
{
|
|
pStair1=stairs[nSectStair];
|
|
pStair1->SetSectionPos(0, lSectPos);
|
|
pStair1->SetSectionPos(1, rSectPos);
|
|
pStair1->Set2DFlag(SF_1SECT);
|
|
nHit=nSectStair+1;
|
|
}
|
|
|
|
for(int k=0; k<hands.Length(); k++) {
|
|
TDbHandRail *pHand=hands[k];
|
|
pHand->setPropertiesFrom(this);
|
|
pHand->SetTempStair(pStair1);
|
|
pStair1->AddTempRail(pHand);
|
|
if(dc.IsFullExplode())
|
|
pHand->ExplodeOrDraw2d(dc);
|
|
else
|
|
dc.DrawEntity(*pHand);
|
|
}
|
|
|
|
if(nHit)
|
|
{
|
|
for(int iii=0; iii<nHit; iii++)
|
|
{
|
|
TDbStair *pStair=stairs[iii];
|
|
if(iii!=nHit) { //加入相关扶手信息, nHit已经加入过
|
|
for(int kk=0; kk<hands.Length(); kk++)
|
|
pStair->AddTempRail(hands[kk]);
|
|
}
|
|
if(dc.IsFullExplode())
|
|
pStair->ExplodeOrDraw2d(dc);
|
|
else
|
|
dc.DrawEntity(*pStair);
|
|
}
|
|
int slabNum=0,stairNum=nHit;
|
|
for(i=0;i<m_lstSegType.Length(),stairNum>0;i++)
|
|
{
|
|
if(GetSegType(i)==0)
|
|
{
|
|
stairNum--;
|
|
}
|
|
else
|
|
{
|
|
slabNum++;
|
|
}
|
|
}
|
|
// 绘制平台
|
|
for(iii=0; iii<slabNum; iii++)
|
|
{
|
|
if(iii<slabs.Length())
|
|
{
|
|
TDbSlab *pSlab=slabs[iii];
|
|
for(int kk=0; kk<hands.Length(); kk++)
|
|
pSlab->AddTempRail(hands[kk]);
|
|
if(dc.IsFullExplode())
|
|
pSlab->ExplodeOrDraw2d(dc);
|
|
else
|
|
dc.DrawEntity(*pSlab);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(dc.IsFullExplode())
|
|
pStair1->ExplodeOrDraw2d(dc);
|
|
else
|
|
dc.DrawEntity(*pStair1);
|
|
}
|
|
}
|
|
else if(pStair1)
|
|
{ // 中间层或顶层
|
|
|
|
//modified by xlc on 080718
|
|
/*if(nHit)
|
|
{
|
|
pStair1=stairs[nHit-1];
|
|
XDirectionCurve lCurve=pStair1->GetSideCurve2d(0);
|
|
XDirectionCurve rCurve=pStair1->GetSideCurve2d(1);
|
|
double nRatio1=lCurve.PathDistance(ptHitLeft2d)/lCurve.Length(),
|
|
nRatio2=rCurve.PathDistance(ptHitRight2d)/rCurve.Length();
|
|
pStair1->SetSectionPos(0, nRatio1);
|
|
pStair1->SetSectionPos(1, nRatio2);
|
|
}
|
|
if(m_nStairFlag==SF_MIDDLE)
|
|
pStair1->Set2DFlag(SF_2SECT);*/
|
|
if(bSect && m_nStairFlag!=SF_TOP && nSectStair>=0)
|
|
{
|
|
pStair1=stairs[nSectStair];
|
|
pStair1->SetSectionPos(0, lSectPos);
|
|
pStair1->SetSectionPos(1, rSectPos);
|
|
pStair1->Set2DFlag(SF_2SECT);
|
|
if(m_nStairFlag==SF_TOP)
|
|
{
|
|
nHit=0;
|
|
}
|
|
else
|
|
{
|
|
nHit=nSectStair+1;
|
|
}
|
|
}
|
|
|
|
for(int k=0; k<hands.Length(); k++)
|
|
{
|
|
TDbHandRail *pHand=hands[k];
|
|
pHand->setPropertiesFrom(this);
|
|
if(m_nStairFlag==SF_MIDDLE)
|
|
pHand->SetTempStair(pStair1);
|
|
for(int kk=0; kk<stairs.Length(); kk++)
|
|
stairs[kk]->AddTempRail(pHand);
|
|
for(kk=0; kk<slabs.Length(); kk++)
|
|
slabs[kk]->AddTempRail(pHand);
|
|
if(dc.IsFullExplode())
|
|
pHand->ExplodeOrDraw2d(dc);
|
|
else
|
|
dc.DrawEntity(*pHand);
|
|
}
|
|
|
|
int count=0;
|
|
for(k=0; k<stairs.Length(); k++)
|
|
{
|
|
if(dc.IsFullExplode())
|
|
stairs[k]->ExplodeOrDraw2d(dc);
|
|
else
|
|
dc.DrawEntity(*stairs[k]);
|
|
|
|
//为JIG服务
|
|
count+=stairs[k]->GetStepNum();
|
|
if((m_iActiveStep==0&&k==stairs.Length()-1)||//最后一个梯段
|
|
(m_iActiveStep==1&&k==stairs.Length()-2))//倒数第二个梯段
|
|
{
|
|
TDbLineStair*pStair=(TDbLineStair*)stairs[k];
|
|
TDbText *pText=new TDbText;
|
|
pStair->setPropertiesFrom(this);
|
|
pText->SetHeight(GetStepWidth(),FALSE);
|
|
if(k>0)
|
|
pText->SetText(XString(_T("%d,%d/%d"),(int)pStair->GetStepNum(),count,(int)GetTotalStepNum()));
|
|
else
|
|
pText->SetText(XString(_T("%d/%d"),count,(int)GetTotalStepNum()));
|
|
pText->SetStyleId(InitTextStyle(TS_DIM));
|
|
pText->SetLayoutRotation(pStair->GetRotation());
|
|
XPoint ptMid;
|
|
Midpoint(pStair->GetUpLeft2d(),pStair->GetUpRight2d(),ptMid);
|
|
pText->SetAlignment(XExplodeDraw::kBottomCenter);
|
|
pText->SetLocation(ptMid);
|
|
dc.DrawEntity(*pText);
|
|
delete pText;
|
|
}
|
|
}
|
|
for(k=0; k<slabs.Length(); k++)
|
|
{
|
|
slabs[k]->setPropertiesFrom(this);
|
|
if(dc.IsFullExplode())
|
|
slabs[k]->ExplodeOrDraw2d(dc);
|
|
else
|
|
dc.DrawEntity(*slabs[k]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return es;
|
|
}
|
|
|
|
Adesk::UInt8 TDbMultiStair::GetTotalStepNum() const
|
|
{
|
|
double nHeight=GetStairHeight();
|
|
double nStepHeight=GetStepHeight();
|
|
int nStepNum=AS_INT(nHeight/nStepHeight);
|
|
return (Adesk::UInt8)nStepNum;
|
|
}
|
|
|
|
//看剖切位置命中的目标，ptHit为剖切位置，返回值：0－没有命中，否则为命中的第n个梯段
|
|
int TDbMultiStair::HitTestSectPos(int nSide, const DList<TDbStair> &stairs, XPoint &ptHit2d) const
|
|
{
|
|
XPoly2D polySide;
|
|
GetSidePoly2d(nSide, polySide);
|
|
double nPathDist=nSide? m_rSectPos : m_lSectPos;
|
|
if(nPathDist<0.0 || nPathDist>polySide.Distance2d())
|
|
return 0;
|
|
polySide.Polar2d(nPathDist, ptHit2d);
|
|
ptHit2d.z=0;
|
|
|
|
for(int i=0; i<stairs.Length(); i++) {
|
|
const TDbStair &rStair=stairs[i];
|
|
XDirectionCurve cv=rStair.GetSideCurve2d(nSide);
|
|
|
|
if((ptHit2d&cv.GetCurve())==PR_INSIDE)
|
|
return (i+1);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//看剖切位置命中的目标，ptHit为剖切位置，返回值：0－没有命中，否则为命中的第n个梯段
|
|
int TDbMultiStair::HitTestSectPos(int nSide, XPoint &ptHit2d) const
|
|
{
|
|
XPoly2D polySide;
|
|
GetSidePoly2d(nSide, polySide);
|
|
double nPathDist=nSide? m_rSectPos : m_lSectPos;
|
|
|
|
if(!IsManualSectPos())
|
|
{
|
|
DList<TDbEntity> lstComponents;
|
|
ExplodeTo(lstComponents);
|
|
DStack<TDbStair> stairs;
|
|
for(int i=0; i<lstComponents.Length(); i++) {
|
|
TDbEntity *pEnt=lstComponents[i];
|
|
if(pEnt->isKindOf(TDbStair::desc()))
|
|
stairs.Append((TDbStair *)pEnt);
|
|
}
|
|
TDbStair *pStair=stairs.Head();
|
|
|
|
//add by xlc on 090518 打开旧图时崩溃
|
|
if (pStair==NULL)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if(m_nStairFlag==SF_FIRST)
|
|
pStair->Set2DFlag(SF_1SECT);
|
|
else if(m_nStairFlag==SF_MIDDLE)
|
|
pStair->Set2DFlag(SF_2SECT);
|
|
double lRatio=pStair->GetSectionPos(0);
|
|
double rRatio=pStair->GetSectionPos(1);
|
|
XDirectionCurve lCurve=pStair->GetSideCurve2d(0),
|
|
rCurve=pStair->GetSideCurve2d(1);
|
|
XPointDir2d ptLeft, ptRight;
|
|
lCurve.Polar(lRatio*lCurve.GetLength(), ptLeft);
|
|
rCurve.Polar(rRatio*rCurve.GetLength(), ptRight);
|
|
|
|
|
|
XPoly2D lPoly, rPoly;
|
|
GetSidePoly2d(0, lPoly);
|
|
GetSidePoly2d(1, rPoly);
|
|
|
|
nPathDist = nSide?rPoly.PathDistance2d(ptRight):lPoly.PathDistance2d(ptLeft);
|
|
}
|
|
|
|
if(nPathDist<0.0 || nPathDist>polySide.Distance2d())
|
|
return 0;
|
|
polySide.Polar2d(nPathDist, ptHit2d);
|
|
ptHit2d.z=0;
|
|
|
|
DList<TDbEntity> lstComponents;
|
|
ExplodeTo(lstComponents);
|
|
DStack<TDbStair> stairs;
|
|
for(int i=0; i<lstComponents.Length(); i++) {
|
|
TDbEntity *pEnt=lstComponents[i];
|
|
if(pEnt->isKindOf(TDbStair::desc()))
|
|
stairs.Append((TDbStair *)pEnt);
|
|
}
|
|
|
|
for(i=0; i<stairs.Length(); i++) {
|
|
TDbStair *pStair=stairs[i];
|
|
XDirectionCurve cv=pStair->GetSideCurve2d(nSide);
|
|
|
|
if((ptHit2d&cv.GetCurve())==PR_INSIDE)
|
|
return (i+1);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void TDbMultiStair::GetSidePoly2d(int nSide, XPoly2D &polySide) const
|
|
{
|
|
if(nSide==0) {
|
|
if(m_nPathSide) {
|
|
m_polySide2d.QuickOffset(-m_nStairWidth, polySide);
|
|
} else {
|
|
polySide=m_polySide2d;
|
|
}
|
|
} else {
|
|
if(m_nPathSide) {
|
|
polySide=m_polySide2d;
|
|
} else {
|
|
m_polySide2d.QuickOffset(m_nStairWidth, polySide);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 设置缺省的剖切位置
|
|
void TDbMultiStair::SetDefaultSectPos()
|
|
{
|
|
assertWriteEnabled();
|
|
DList<TDbEntity> lstComponents;
|
|
ExplodeTo(lstComponents);
|
|
DStack<TDbStair> stairs;
|
|
for(int i=0; i<lstComponents.Length(); i++) {
|
|
TDbEntity *pEnt=lstComponents[i];
|
|
if(pEnt->isKindOf(TDbStair::desc()))
|
|
stairs.Append((TDbStair *)pEnt);
|
|
}
|
|
TDbStair *pStair=stairs.Head();
|
|
|
|
//add by xlc on 090518 打开旧图时崩溃
|
|
if (pStair==NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(m_nStairFlag==SF_FIRST)
|
|
pStair->Set2DFlag(SF_1SECT);
|
|
else if(m_nStairFlag==SF_MIDDLE)
|
|
pStair->Set2DFlag(SF_2SECT);
|
|
double lRatio=pStair->GetSectionPos(0);
|
|
double rRatio=pStair->GetSectionPos(1);
|
|
XDirectionCurve lCurve=pStair->GetSideCurve2d(0),
|
|
rCurve=pStair->GetSideCurve2d(1);
|
|
XPointDir2d ptLeft, ptRight;
|
|
lCurve.Polar(lRatio*lCurve.GetLength(), ptLeft);
|
|
rCurve.Polar(rRatio*rCurve.GetLength(), ptRight);
|
|
|
|
|
|
XPoly2D lPoly, rPoly;
|
|
GetSidePoly2d(0, lPoly);
|
|
GetSidePoly2d(1, rPoly);
|
|
|
|
m_lSectPos = lPoly.PathDistance2d(ptLeft);
|
|
m_rSectPos = rPoly.PathDistance2d(ptRight);
|
|
}
|
|
//add by xlc on 080718
|
|
//计算剖切高度和剖切点
|
|
BOOL TDbMultiStair::CalSectPos(const DList<TDbStair> &stairs,double &lSectPos,double &rSectPos,XPoint &ptLeft2d,XPoint &ptRight2d)const
|
|
{
|
|
if(m_nStairFlag==SF_TOP)
|
|
return FALSE;
|
|
|
|
int nSectStair=GetSectStairPos(stairs);
|
|
if(nSectStair == -1) //剖断位置不正确
|
|
return FALSE;
|
|
|
|
if(nSectStair>=stairs.Length())
|
|
return FALSE;
|
|
|
|
const TDbStair &pStair=stairs[nSectStair];
|
|
XDirectionCurve cvLeft,cvRight;
|
|
cvLeft=pStair.GetSideCurve2d(0);
|
|
cvRight=pStair.GetSideCurve2d(1);
|
|
double height=0;
|
|
for(int i=0;i<nSectStair;i++)
|
|
{
|
|
height+=stairs[i].GetStairHeight();
|
|
}
|
|
double dStairLength=cvLeft.StartPoint().Distance2d(cvLeft.EndPoint());
|
|
double len=(GetSectElev()-height)*dStairLength/pStair.GetStairHeight();//剖切位置点
|
|
double nStepWidth=dStairLength/pStair.GetStepNum();
|
|
|
|
if(!IsAscent())
|
|
{
|
|
nStepWidth=dStairLength/(pStair.GetStepNum()-1);
|
|
double nStepHeight=pStair.GetStepHeight();
|
|
len=(GetSectElev()-height)*nStepWidth/nStepHeight;
|
|
if(len>dStairLength)
|
|
{
|
|
len -= nStepWidth;
|
|
}
|
|
}
|
|
double width=cvLeft.StartPoint().Distance2d(cvRight.StartPoint())*0.5;
|
|
double dLen=0; //投影长
|
|
if(fabs(cos(m_dSectRotation))>_DIST_SNAP)
|
|
{
|
|
dLen=width*tan(m_dSectRotation);
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if((len+fabs(dLen)+nStepWidth/3.0 )>dStairLength
|
|
||(len-fabs(dLen)-nStepWidth/3.0 )<_DIST_SNAP) //剖断线转角过大，不能与梯段两边都相交
|
|
{
|
|
double dist=(len<dStairLength-len)?len:dStairLength-len;
|
|
dist -= nStepWidth/2;
|
|
|
|
if(tan(m_dSectRotation)>_DIST_SNAP)
|
|
{
|
|
dLen=dist;
|
|
}
|
|
else
|
|
{
|
|
dLen=-dist;
|
|
}
|
|
}
|
|
|
|
lSectPos=(len-dLen)/dStairLength;
|
|
rSectPos=(len+dLen)/dStairLength;
|
|
|
|
XPointDir2d pt;
|
|
cvLeft.Polar(len-dLen, pt);
|
|
ptLeft2d=pt;
|
|
cvRight.Polar(len+dLen, pt);
|
|
ptRight2d=pt;
|
|
|
|
return TRUE;
|
|
}
|
|
int TDbMultiStair::GetSectStairPos(const DList<TDbStair> &stairs)const//剖切梯段
|
|
{
|
|
if(GetSectElev()<_DIST_SNAP||GetSectElev()>GetStairHeight()-_DIST_SNAP)
|
|
return -1;
|
|
int nSectStair=-1;
|
|
double height=0;
|
|
for(int i=0; i<stairs.Length();i++)
|
|
{
|
|
double dSectElev=GetSectElev();
|
|
if(IsAscent()&&fabs(dSectElev-height)<0.2*stairs[i].GetStepHeight())
|
|
{
|
|
if(dSectElev-height>_DIST_SNAP)
|
|
{
|
|
dSectElev=height+0.3*stairs[i].GetStepHeight();
|
|
}
|
|
else
|
|
{
|
|
dSectElev=height-0.3*stairs[i].GetStepHeight();
|
|
}
|
|
}
|
|
if(dSectElev>height&&dSectElev<height+stairs[i].GetStairHeight()+_DIST_SNAP)
|
|
{
|
|
nSectStair=i;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
height+=stairs[i].GetStairHeight();
|
|
}
|
|
}
|
|
|
|
return nSectStair;
|
|
}
|
|
// 由平面二维点推算命中的相对高度
|
|
double TDbMultiStair::HitElevationByPoint2d(const DList<TDbStair> &stairs,XPoint ptHit2d) const
|
|
{
|
|
BOOL bHit=FALSE;
|
|
double nElevHit=0.0;
|
|
for(int i=0;i<stairs.Length();i++)
|
|
{
|
|
XDirectionCurve cvLeft1=stairs[i].GetSideCurve2d(0);
|
|
XDirectionCurve cvRight1=stairs[i].GetSideCurve2d(1);
|
|
XPoly2D poly1(1);
|
|
poly1.AppendNode(cvLeft1.StartPoint());
|
|
poly1.AppendNode(cvRight1.StartPoint());
|
|
poly1.AppendNode(cvRight1.EndPoint());
|
|
poly1.AppendNode(cvLeft1.EndPoint());
|
|
|
|
if((ptHit2d&poly1)!=PR_OUTSIDE)
|
|
{
|
|
XPoint ptPrj;
|
|
cvLeft1.ProjectToMe(ptHit2d, ptPrj);
|
|
if(IsAscent())
|
|
nElevHit+=ptPrj.Distance2d(cvLeft1.StartPoint())/cvLeft1.GetLength()*stairs[i].GetStairHeight();
|
|
else
|
|
{
|
|
double h=ptPrj.Distance2d(cvLeft1.StartPoint())/cvLeft1.GetLength()*stairs[i].GetStairHeight();
|
|
double height=stairs[i].GetStepHeight();
|
|
double num=stairs[i].GetStepNum();
|
|
for(int k=0;k<num;k++)
|
|
{
|
|
if(h>height*k&&h<height*(k+1)+_DIST_SNAP)
|
|
{
|
|
nElevHit+=height*(k+0.5);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
bHit=TRUE;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
nElevHit += stairs[i].GetStairHeight();
|
|
}
|
|
}
|
|
if(bHit)
|
|
return nElevHit;
|
|
else
|
|
return 0;
|
|
}
|
|
//add by xlc on 080722
|
|
Acad::ErrorStatus TDbMultiStair::DownGradeSave(int nDrawMode, AcDbVoidPtrArray &entSet, BOOL *bErase)
|
|
{
|
|
Acad::ErrorStatus es=Acad::eOk;
|
|
|
|
//modify by xlc on 090213
|
|
// if((g_nSaveTArchVer<8&&g_nVersion>3)) //8.0添加扶手伸出距离，剖切高度
|
|
// {
|
|
// explode(entSet);
|
|
// if(bErase)
|
|
// *bErase=TRUE;
|
|
// }
|
|
// else
|
|
// es=TDbEntity::DownGradeSave(nDrawMode,entSet,bErase);
|
|
if(g_nSaveTArchVer<8&&g_nSaveTArchVer>5) //8.0添加扶手伸出距离，剖切高度
|
|
{
|
|
BOOL bFlag=FALSE;
|
|
for(long i=0;i<m_lstSegType.Length();i++)
|
|
{
|
|
int type=*m_lstSegType[i];
|
|
if(!((i%2==0&&type==0)
|
|
||(i%2==1&&type==1)))
|
|
{
|
|
bFlag=TRUE;
|
|
break;
|
|
}
|
|
}
|
|
if(bFlag)
|
|
{
|
|
subExplode(entSet);
|
|
if(bErase)
|
|
*bErase=TRUE;
|
|
return es;
|
|
}
|
|
else
|
|
{
|
|
TDbMultiStair *pNewSet=NULL;
|
|
{
|
|
XPushMemVar<int> vTemp(g_nSaveTArchVer,_TCH_VERSION);//add by whl on 090325，解决8导出7崩溃问题
|
|
pNewSet=(TDbMultiStair*)clone();
|
|
}
|
|
pNewSet->SetManualSectPos(TRUE);
|
|
pNewSet->SetArrow(FALSE);
|
|
|
|
//modify by xlc on 090618 解决梯段错误不显示时导出T6，04平台下打开崩溃的问题
|
|
//entSet.append(pNewSet);
|
|
DList<TDbEntity> lstComponents;
|
|
ExplodeTo(lstComponents);
|
|
if(lstComponents.Length()>0)
|
|
entSet.append(pNewSet);
|
|
else
|
|
delete pNewSet;
|
|
|
|
if(IsArrow())
|
|
{
|
|
//DList<TDbEntity> lstComponents;
|
|
//ExplodeTo(lstComponents);
|
|
for(int i=0; i<lstComponents.Length(); i++)
|
|
{
|
|
TDbEntity *pEnt=lstComponents[i];
|
|
if(pEnt->isKindOf(TDbSymbArrow::desc()))
|
|
{
|
|
XPushMemVar<int> vTemp(g_nSaveTArchVer,_TCH_VERSION);//add by xlc on 090427，解决8导出7崩溃问题
|
|
entSet.append((TDbSymbArrow*)pEnt->clone());
|
|
}
|
|
}
|
|
}
|
|
|
|
if(bErase)
|
|
*bErase=TRUE;
|
|
return es;
|
|
}
|
|
}
|
|
|
|
es=TDbEntity::DownGradeSave(nDrawMode,entSet,bErase);
|
|
return es;
|
|
}
|
|
double TDbMultiStair::GetSectStepNum() const
|
|
{
|
|
assertReadEnabled();
|
|
double nStepNum=m_dSectElev/GetStepHeight();
|
|
|
|
return nStepNum+0.5;
|
|
}
|
|
|
|
void TDbMultiStair::SetSectStepNum(double d)
|
|
{
|
|
assertWriteEnabled();
|
|
double nSectStepNum=(int)(GetTotalStepNum()/2);
|
|
if(d>0&&d<GetTotalStepNum())
|
|
{
|
|
nSectStepNum=d;
|
|
}
|
|
m_dSectElev=(nSectStepNum-0.5)*m_nStepHeight;
|
|
}
|
|
|
|
//add by xlc 090426，箭头文字，动态数据
|
|
CString TDbMultiStair::GetTextUp() const
|
|
{
|
|
assertReadEnabled();
|
|
CString sVal(_T("上"));
|
|
const TEntityFields &fd = GetFields();
|
|
fd.GFD(_T("上楼箭头文字"), sVal);
|
|
return sVal;
|
|
}
|
|
|
|
void TDbMultiStair::SetTextUp(const TCHAR *sVal)
|
|
{
|
|
assertWriteEnabled();
|
|
TEntityFields &fd = Fields();
|
|
fd.SFD(_T("上楼箭头文字"), sVal);
|
|
}
|
|
CString TDbMultiStair::GetTextDown() const
|
|
{
|
|
assertReadEnabled();
|
|
CString sVal(_T("下"));
|
|
const TEntityFields &fd = GetFields();
|
|
fd.GFD(_T("下楼箭头文字"), sVal);
|
|
return sVal;
|
|
}
|
|
|
|
void TDbMultiStair::SetTextDown(const TCHAR *sVal)
|
|
{
|
|
assertWriteEnabled();
|
|
TEntityFields &fd = Fields();
|
|
fd.SFD(_T("下楼箭头文字"), sVal);
|
|
}
|
|
|
|
// cet 2013.9.6 add
|
|
CString TDbMultiStair::GetXml(const AcGeMatrix3d& mat) const
|
|
{
|
|
CString sXml;
|
|
AcDbVoidPtrArray arrEnts;
|
|
explode(arrEnts);
|
|
int nSize = arrEnts.length();
|
|
for (int i = 0; i < nSize; ++i)
|
|
{
|
|
AcDbEntity *pEnt = (AcDbEntity*)arrEnts[i];
|
|
if (pEnt == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
TDbLineStair *pLineStair = TDbLineStair::cast(pEnt);
|
|
if (pLineStair != NULL)
|
|
{
|
|
sXml += pLineStair->GetXml(mat);
|
|
continue;
|
|
}
|
|
|
|
TDbSlab *pSlab = TDbSlab::cast(pEnt);
|
|
if (pSlab != NULL)
|
|
{
|
|
sXml += pSlab->GetXml(mat);
|
|
}
|
|
}
|
|
ReleaseEntSet(arrEnts);
|
|
return sXml;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void InitDbStair(BOOL bTrue)
|
|
{
|
|
if(bTrue) {
|
|
TDbStair::rxInit();
|
|
TDbLineStair::rxInit();
|
|
TDbArcStair::rxInit();
|
|
TDbCurveStair::rxInit();
|
|
TDbRectStair::rxInit();
|
|
TDbMultiStair::rxInit();
|
|
acrxBuildClassHierarchy();
|
|
TDbLineStair::InitMatchProtocol(TRUE);
|
|
TDbArcStair::InitMatchProtocol(TRUE);
|
|
TDbCurveStair::InitMatchProtocol(TRUE);
|
|
TDbRectStair::InitMatchProtocol(TRUE);
|
|
TDbMultiStair::InitMatchProtocol(TRUE);
|
|
} else {
|
|
TDbLineStair::InitMatchProtocol(FALSE);
|
|
TDbArcStair::InitMatchProtocol(FALSE);
|
|
TDbCurveStair::InitMatchProtocol(FALSE);
|
|
TDbRectStair::InitMatchProtocol(FALSE);
|
|
TDbMultiStair::InitMatchProtocol(FALSE);
|
|
|
|
deleteAcRxClass(TDbMultiStair::desc());
|
|
deleteAcRxClass(TDbRectStair::desc());
|
|
deleteAcRxClass(TDbCurveStair::desc());
|
|
deleteAcRxClass(TDbLineStair::desc());
|
|
deleteAcRxClass(TDbArcStair::desc());
|
|
deleteAcRxClass(TDbStair::desc());
|
|
}
|
|
}
|
|
|
|
|