gjm/envi-code
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
44197f41afeed8275fd094f7ab5fba74516ec8f0
envi-code/SourceCode/Code2026/tg_shs/shs_kernal/dbCrossStair.cpp
T
gjm 345044cb46 初始化提交
2026-09-28 15:28:50 +08:00

3000 lines
71 KiB
C++
Raw Blame History

#include "stdafx.h"
#include "TDbColumn.h"
////////////////////////////////////////////////////////////////////////////
// ver: 0-TArch8
const Adesk::UInt8 TDbCrossStair::g_nVersion = 0;
ACRX_DXF_DEFINE_MEMBERS(ATSCrossStair, ATSPolyPathEnt, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
1, ATS_CROSSSTAIR, "ATS_CROSSSTAIR图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
IMPLEMENT_TENTBASE(TDbCrossStair);
TDbCrossStair::TDbCrossStair()
{
m_nStepHeight=_AS_SYS_UNIT(220.0); //踏步高
m_nStepWidth=_AS_SYS_UNIT(300); //踏步宽
m_nStairWidth=_AS_SYS_UNIT(1200); //梯段段宽
m_nSlabSize=_AS_SYS_UNIT(1200); //休息平台左上尺寸
m_nSlabSizeUR=_AS_SYS_UNIT(1200); //休息平台右上尺寸
m_nSlabSizeLR=_AS_SYS_UNIT(1200); //休息平台右下尺寸
m_nRotation=0.0; //旋转角度
m_nStepNum=1; //梯段步数
m_nSpaceWidth=_AS_SYS_UNIT(3600.0); //楼梯间尺寸
m_nRailHeight=_AS_SYS_UNIT(900);
m_nStairFlag=1; //楼层标记
m_nStartSide=OFFSET_LEFT; //左边起步
m_nSideFlag=0; //
m_nRailWidth=_AS_SYS_UNIT(60.0); //扶手宽度
m_nRailDist=m_nStepWidth*0.5; //层与层连接处扶手伸出距离
m_dSectRotation=PI/6.0; //剖断线旋转角度
m_nFlagEx=0;
m_nBeamHeight=_AS_SYS_UNIT(200); //边梁高，坡道专用
m_nBeamThick=_AS_SYS_UNIT(120); //边梁厚度
m_nSlabThick=_AS_SYS_UNIT(120); //板厚或梁厚
m_nViewCtrl=0; //自动确定
m_nFlagEx |= SFEX_SECTPOS;
m_dTextHeight=3.5;
}
TDbCrossStair::~TDbCrossStair()
{
}
BOOL TDbCrossStair::IsValid() const
{
BOOL bRet=TDbEntity::IsValid();
if(!bRet)
return bRet;
bRet=(m_nStepHeight>_DIST_SNAP && //踏步高
m_nStepWidth>_DIST_SNAP && //踏步宽
m_nStairWidth>_DIST_SNAP && //梯段段宽
m_dTextHeight>0&& //字高
m_nStepNum>1 && //梯段步数
m_nSpaceWidth-2*m_nStairWidth>-_DIST_SNAP && //楼梯间尺寸
m_nRailHeight>_DIST_SNAP && //扶手高
m_nRailWidth>_DIST_SNAP && //扶手宽
GreatEqual(m_nRailDistToSide,-(m_nSpaceWidth*0.5-m_nStairWidth)) && //扶手距边
GreatEqual(m_nBeamHeight, 0.0) &&//边梁高
GreatEqual(m_nBeamThick, 0.0) &&//边梁厚
GreatEqual(m_nSlabThick, 0.0) &&//休息台厚
m_nStairWidth>m_nRailWidth+m_nRailDistToSide); //扶手高度
return bRet;
}
// 提供对格式刷的支持
void TDbCrossStair::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
{
assertWriteEnabled();
TDbPolyPathEnt::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
TDbCrossStair *pSrc=TDbCrossStair::cast(pSrcEntity);
if(pSrc) {
m_nStepHeight=pSrc->m_nStepHeight;
m_nStepWidth=pSrc->m_nStepWidth;
m_nStairWidth=pSrc->m_nStairWidth;
m_nSlabSize=pSrc->m_nSlabSize;
m_nSlabSizeUR=pSrc->m_nSlabSizeUR;
m_nSlabSizeLR=pSrc->m_nSlabSizeLR;
m_nStepNum=pSrc->m_nStepNum;
m_nSpaceWidth=pSrc->m_nSpaceWidth;
m_dTextHeight=pSrc->m_dTextHeight;
m_nRailHeight=pSrc->m_nRailHeight;
m_nRailWidth=pSrc->m_nRailWidth;
m_nRailDistToSide=pSrc->m_nRailDistToSide;
m_nStairFlag=pSrc->m_nStairFlag;
m_nStartSide=pSrc->m_nStartSide;
m_nSideFlag=pSrc->m_nSideFlag;
m_nRailDist=pSrc->m_nRailDist;
m_dSectRotation=pSrc->m_dSectRotation;
m_nSectStepNum=pSrc->m_nSectStepNum;
m_nFlagEx=pSrc->m_nFlagEx;
m_nBeamHeight=pSrc->m_nBeamHeight; //边梁高，坡道专用
m_nBeamThick=pSrc->m_nBeamThick; //边梁厚度
m_nSlabThick=pSrc->m_nSlabThick; //板厚或梁厚
//add by xlc on 090426箭头文字
SetTextUp(pSrc->GetTextUp());
SetTextDown(pSrc->GetTextDown());
if(database()==NULL||
pSrcEntity->database()==NULL||
database()==pSrcEntity->database())
{
m_idLayerHand3d=pSrc->m_idLayerHand3d;
m_idLayerStep3d=pSrc->m_idLayerStep3d;
m_idLayerBeam3d=pSrc->m_idLayerBeam3d;
m_idLayerRail3d=pSrc->m_idLayerRail3d;
m_idLayerArrow=pSrc->m_idLayerArrow;
m_idLayerText=pSrc->m_idLayerText;
m_idTextStyle=pSrc->m_idTextStyle;
}
m_nViewCtrl=pSrc->m_nViewCtrl;
}
}
Acad::ErrorStatus
TDbCrossStair::subGetClassID(CLSID* pClsid) const
{
return Acad::eOk;
}
// 从DWG读入数据:
Acad::ErrorStatus
TDbCrossStair::dwgInFields (AcDbDwgFiler* pFiler)
{
assertWriteEnabled();
Acad::ErrorStatus es = TDbPolyPathEnt::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((AcGePoint3d *)&m_ptLocation);
pFiler->readItem(&m_nRotation); //旋转角度
pFiler->readItem(&m_nStepHeight); //踏步高
pFiler->readItem(&m_nStepWidth); //踏步宽
pFiler->readItem(&m_nStairWidth); //梯段段宽
pFiler->readItem(&m_nSlabSize); //休息平台左上尺寸
pFiler->readItem(&m_nSlabSizeUR); //休息平台右上尺寸
pFiler->readItem(&m_nSlabSizeLR); //休息平台右下尺寸
pFiler->readItem(&m_nStepNum); //楼梯步数
pFiler->readItem(&m_nSpaceWidth); //楼梯间尺寸
pFiler->readItem(&m_nRailHeight); //扶手高
pFiler->readItem(&m_nStairFlag); //楼层标记
pFiler->readItem(&m_nStartSide); //起步的一侧
pFiler->readItem(&m_nSideFlag); //首层有地下室或顶层有出屋面时的梯段标志: 0--无, 1--左侧, 2--右侧
pFiler->readItem(&m_nRailWidth); //扶手宽
pFiler->readItem(&m_nRailDistToSide); //扶手距离边
pFiler->readItem(&m_nRailDist); //扶手伸出距离
pFiler->readItem(&m_nSectStepNum); //剖断步数
pFiler->readItem(&m_dSectRotation); //剖断转角
pFiler->readItem(&m_dTextHeight); //字高
pFiler->readItem(&m_nFlagEx);
pFiler->readItem(&m_nBeamHeight);
pFiler->readItem(&m_nBeamThick);
pFiler->readItem(&m_nSlabThick);
pFiler->readItem(&m_idLayerHand3d);
pFiler->readItem(&m_idLayerStep3d);
pFiler->readItem(&m_idLayerBeam3d);
pFiler->readItem(&m_idLayerRail3d);
pFiler->readItem(&m_idLayerText);
pFiler->readItem(&m_idTextStyle);
pFiler->readItem(&m_idLayerArrow);
pFiler->readItem(&m_nViewCtrl);
return pFiler->filerStatus();
}
Acad::ErrorStatus
TDbCrossStair::dwgOutFields(AcDbDwgFiler* pFiler) const
{
assertReadEnabled();
Acad::ErrorStatus es = TDbPolyPathEnt::dwgOutFields(pFiler);
if(es != Acad::eOk) return es;
pFiler->writeItem(g_nVersion);
pFiler->writeItem((AcGePoint3d &)m_ptLocation);
pFiler->writeItem(m_nRotation); //旋转角度
pFiler->writeItem(m_nStepHeight); //踏步高
pFiler->writeItem(m_nStepWidth); //踏步宽
pFiler->writeItem(m_nStairWidth); //梯段段宽
pFiler->writeItem(m_nSlabSize); //休息平台左上尺寸
pFiler->writeItem(m_nSlabSizeUR); //休息平台右上尺寸
pFiler->writeItem(m_nSlabSizeLR); //休息平台右下尺寸
pFiler->writeItem(m_nStepNum); //楼梯步数
pFiler->writeItem(m_nSpaceWidth); //楼梯间宽度
pFiler->writeItem(m_nRailHeight); //扶手高度
pFiler->writeItem(m_nStairFlag); //楼层标记
pFiler->writeItem(m_nStartSide); //起步的一侧
pFiler->writeItem(m_nSideFlag); //首层有地下室或顶层有出屋面时的梯段标志: 0--无, 1--左侧, 2--右侧
pFiler->writeItem(m_nRailWidth); //扶手宽
pFiler->writeItem(m_nRailDistToSide); //扶手距离边
pFiler->writeItem(m_nRailDist); //扶手伸出距离
pFiler->writeItem(m_nSectStepNum); //剖断步数
pFiler->writeItem(m_dSectRotation); //剖断转角
pFiler->writeItem(m_dTextHeight); //字高
pFiler->writeItem(m_nFlagEx);
pFiler->writeItem(m_nBeamHeight);
pFiler->writeItem(m_nBeamThick);
pFiler->writeItem(m_nSlabThick);
pFiler->writeItem(m_idLayerHand3d);
pFiler->writeItem(m_idLayerStep3d);
pFiler->writeItem(m_idLayerBeam3d);
pFiler->writeItem(m_idLayerRail3d);
pFiler->writeItem(m_idLayerText);
pFiler->writeItem(m_idTextStyle);
pFiler->writeItem(m_idLayerArrow);
pFiler->writeItem(m_nViewCtrl);
return pFiler->filerStatus();
}
Acad::ErrorStatus
TDbCrossStair::dxfInFields (AcDbDxfFiler* pFiler)
{
assertWriteEnabled();
Acad::ErrorStatus es = TDbPolyPathEnt::dxfInFields(pFiler);
if(es!=Acad::eOk)
return es;
if (!pFiler->atSubclassData(_T("TDbCrossStair"))) {
return Acad::eBadDxfSequence;
}
Adesk::Int32 fieldsFlags=0;
resbuf rb;
double r1, r2, r3, r4, r5, r6, r7, r8, r9;
int i1, i2, i3, i4, i5;
XPoint pt;
while ((es == Acad::eOk)
&& ((es = pFiler->readResBuf(&rb)) == Acad::eOk)) {
switch (rb.restype) {
case AcDb::kDxfXCoord:
pt=rb.resval.rpoint;
fieldsFlags |= 0x01;
break;
case AcDb::kDxfReal:
r1=rb.resval.rreal;
fieldsFlags |= 0x02;
break;
case AcDb::kDxfReal+1:
r2=rb.resval.rreal;
fieldsFlags |= 0x04;
break;
case AcDb::kDxfReal+2:
r3=rb.resval.rreal;
fieldsFlags |= 0x08;
break;
case AcDb::kDxfReal+3:
r4=rb.resval.rreal;
fieldsFlags |= 0x10;
break;
case AcDb::kDxfReal+4:
r5=rb.resval.rreal;
fieldsFlags |= 0x20;
break;
case AcDb::kDxfReal+5:
r6=rb.resval.rreal;
fieldsFlags |= 0x40;
break;
case AcDb::kDxfReal+6:
r7=rb.resval.rreal;
fieldsFlags |= 0x80;
break;
case AcDb::kDxfReal+7:
r8=rb.resval.rreal;
fieldsFlags |= 0x100;
break;
case AcDb::kDxfReal+8:
m_dTextHeight=rb.resval.rreal;
break;
case AcDb::kDxfReal+9:
m_nSlabSizeUR=rb.resval.rreal;
break;
case AcDb::kDxfReal+12:
m_nSlabSizeLR=rb.resval.rreal;
break;
case AcDb::kDxfReal+13:
m_dSectRotation=rb.resval.rreal;
break;
case AcDb::kDxfReal+11:
m_nRailDist=rb.resval.rreal;
break;
case AcDb::kDxfAngle:
r9 = rb.resval.rreal;
fieldsFlags |= 0x200;
break;
case AcDb::kDxfInt16:
i1=rb.resval.rint;
fieldsFlags |= 0x400;
break;
case AcDb::kDxfInt16+1:
i2=rb.resval.rint;
fieldsFlags |= 0x800;
break;
case AcDb::kDxfInt16+2:
i3=rb.resval.rint;
fieldsFlags |= 0x1000;
break;
case AcDb::kDxfInt16+3:
i4=rb.resval.rint;
fieldsFlags |= 0x400;
break;
case AcDb::kDxfInt16+4:
i5=rb.resval.rint;
fieldsFlags |= 0x400;
break;
case 75:
m_nViewCtrl=(Adesk::UInt8)rb.resval.rint;
break;
case 76:
m_nSectStepNum=(int)rb.resval.rint;
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=GetLayerIdFromString(rb.resval.rstring, database());
free(rb.resval.rstring);
break;
case 413:
m_idLayerBeam3d=GetLayerIdFromString(rb.resval.rstring, database());
free(rb.resval.rstring);
break;
case 414:
m_idLayerHand3d=GetLayerIdFromString(rb.resval.rstring, database());
free(rb.resval.rstring);
break;
case 415:
m_idLayerRail3d=GetLayerIdFromString(rb.resval.rstring, database());
free(rb.resval.rstring);
break;
case 416:
m_idLayerText=GetLayerIdFromString(rb.resval.rstring, database());
free(rb.resval.rstring);
break;
case 417:
m_idTextStyle=GetLayerIdFromString(rb.resval.rstring, database());
free(rb.resval.rstring);
break;
case 418:
m_idLayerArrow=GetLayerIdFromString(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)
return Acad::eInvalidResBuf;
if (!(fieldsFlags&0x01)) {
pFiler->setError(Acad::eMissingDxfField, _T("\nMissing DXF group code: 10"));
return Acad::eMissingDxfField;
}
if (!(fieldsFlags&0x02)) {
pFiler->setError(Acad::eMissingDxfField, _T("\nMissing DXF group code: 40"));
return Acad::eMissingDxfField;
}
if (!(fieldsFlags&0x04)) {
pFiler->setError(Acad::eMissingDxfField, _T("\nMissing DXF group code: 41"));
return Acad::eMissingDxfField;
}
if (!(fieldsFlags&0x08)) {
pFiler->setError(Acad::eMissingDxfField, _T("\nMissing DXF group code: 42"));
return Acad::eMissingDxfField;
}
if (!(fieldsFlags&0x10)) {
pFiler->setError(Acad::eMissingDxfField, _T("\nMissing DXF group code: 43"));
return Acad::eMissingDxfField;
}
if (!(fieldsFlags&0x20)) {
pFiler->setError(Acad::eMissingDxfField, _T("\nMissing DXF group code: 44"));
return Acad::eMissingDxfField;
}
if (!(fieldsFlags&0x800)) {
pFiler->setError(Acad::eMissingDxfField, _T("\nMissing DXF group code: 71"));
return Acad::eMissingDxfField;
}
if (!(fieldsFlags&0x1000)) {
pFiler->setError(Acad::eMissingDxfField, _T("\nMissing DXF group code: 72"));
return Acad::eMissingDxfField;
}
m_ptLocation=pt;
SetStepHeight(r1);
SetSpaceWidth(r2);
SetSlabSize(r3);
SetStepWidth(r4);
SetStairWidth(r5);
if(fieldsFlags&0x40)
SetRailHeight(r6);
if(fieldsFlags&0x80)
SetRailWidth(r7);
if(fieldsFlags&0x100)
SetRailDistToSide(r8);
if(fieldsFlags&0x200)
SetRotation(r9);
if(fieldsFlags&0x400)
SetStairFlag(i1);
SetStepNum(i2);
m_nStartSide=i4;
m_nSideFlag=i5;
return pFiler->filerStatus();
}
Acad::ErrorStatus
TDbCrossStair::dxfOutFields(AcDbDxfFiler* pFiler) const
{
assertReadEnabled();
Acad::ErrorStatus es;
es = TDbPolyPathEnt::dxfOutFields(pFiler);
assert(es == Acad::eOk);
es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbCrossStair"));
assert(es == Acad::eOk);
pFiler->writePoint3d(AcDb::kDxfXCoord, m_ptLocation);
pFiler->writeDouble(AcDb::kDxfReal, GetStepHeight());
pFiler->writeDouble(AcDb::kDxfReal+1, GetSpaceWidth());
pFiler->writeDouble(AcDb::kDxfReal+2, GetSlabSize());
pFiler->writeDouble(AcDb::kDxfReal+3, GetStepWidth());
pFiler->writeDouble(AcDb::kDxfReal+4, GetStairWidth());
pFiler->writeDouble(AcDb::kDxfReal+5, GetRailHeight());
pFiler->writeDouble(AcDb::kDxfReal+6, GetRailWidth());
pFiler->writeDouble(AcDb::kDxfReal+7, GetRailDistToSide());
pFiler->writeDouble(AcDb::kDxfReal+8, GetTextHeight());
pFiler->writeDouble(AcDb::kDxfReal+9, GetSlabSizeUR());
pFiler->writeDouble(AcDb::kDxfReal+11, GetRailDist());
pFiler->writeDouble(AcDb::kDxfReal+12, GetSlabSizeLR());
pFiler->writeDouble(AcDb::kDxfReal+13, GetSectRotation());
pFiler->writeDouble(AcDb::kDxfAngle, GetRotation());
pFiler->writeInt16(AcDb::kDxfInt16, GetStairFlag());
pFiler->writeInt16(AcDb::kDxfInt16+1, GetStepNum());
pFiler->writeInt16(AcDb::kDxfInt16+3, m_nStartSide);
pFiler->writeInt16(AcDb::kDxfInt16+4, m_nSideFlag);
pFiler->writeInt16(AcDb::kDxfInt16+5, m_nViewCtrl);
pFiler->writeInt16(AcDb::kDxfInt16+6, m_nSectStepNum);
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));
pFiler->writeString(416, (const TCHAR *)LayerId2String(m_idLayerText));
pFiler->writeString(417, (const TCHAR *)LayerId2String(m_idTextStyle));
pFiler->writeString(418, (const TCHAR *)LayerId2String(m_idLayerArrow));
return pFiler->filerStatus();
}
Acad::ErrorStatus
TDbCrossStair::subGetGripPoints(AcGePoint3dArray& gripPoints,
AcDbIntArray& osnapModes,
AcDbIntArray& geomIds) const
{
assertReadEnabled();
XPoint ptUpLeft=GetUpLeft2d(), ptUpRight=GetUpRight2d();
// 0,1,2,3--移动
gripPoints.append(ptUpLeft);
gripPoints.append(ptUpRight);
XPoint ptLeft, ptRight;
double nDist=GetSlabSizeUR()+GetSlabSizeLR()+(m_nStepNum-1)*m_nStepWidth;
ads_polar(ptUpLeft, m_nRotation-PI/2.0, nDist, ptLeft);
ads_polar(ptUpRight, m_nRotation-PI/2.0, nDist, ptRight);
gripPoints.append(ptLeft);
gripPoints.append(ptRight);
// 4,5--楼梯间
ads_polar(ptUpLeft, m_nRotation-PI/2.0, nDist*0.5, ptLeft);
ads_polar(ptUpRight, m_nRotation-PI/2.0, nDist*0.5, ptRight);
gripPoints.append(ptLeft);
gripPoints.append(ptRight);
// 6,7--楼梯边梯宽度
XPoint ptLeft1, ptRight1;
ads_polar(ptLeft, m_nRotation, GetStairWidth(), ptLeft1);
ads_polar(ptRight, m_nRotation+PI, GetStairWidth(), ptRight1);
ads_polar(ptRight1, m_nRotation+PI*0.5, m_nStepWidth, ptRight1);
gripPoints.append(ptLeft1);
gripPoints.append(ptRight1);
double dStairWidth=0.0; //井宽
dStairWidth = GetSpaceWidth() - GetStairWidth()*2.0;
if(dStairWidth < _DIST_SNAP)
{
dStairWidth=0.0;
}
// 8,9,10,11--梯段位置
XPoint ptSlabLeft, ptSlabRight;
ads_polar(ptUpLeft, m_nRotation-PI/2.0, GetSlabSize(), ptSlabLeft);
gripPoints.append(ptSlabLeft);
ads_polar(ptSlabLeft, m_nRotation-PI/2.0, (m_nStepNum-1)*m_nStepWidth, ptSlabLeft);
gripPoints.append(ptSlabLeft);
ads_polar(ptUpRight, m_nRotation-PI/2.0, GetSlabSizeUR(), ptSlabRight);
gripPoints.append(ptSlabRight);
ads_polar(ptSlabRight, m_nRotation-PI/2.0, (m_nStepNum-1)*m_nStepWidth, ptSlabRight);
gripPoints.append(ptSlabRight);
// 12,13--休息平台
Midpoint(ptUpLeft,ptUpRight,ptSlabLeft);
gripPoints.append(ptSlabLeft);
ads_polar(ptSlabLeft, m_nRotation-PI/2.0, (m_nStepNum-1)*m_nStepWidth+m_nSlabSizeUR+m_nSlabSizeLR, ptSlabLeft);
gripPoints.append(ptSlabLeft);
//14,15--扶手伸出距离
{
XPoint ptTmp;
ads_polar(ptUpLeft, m_nRotation-PI/2, m_nSlabSize-m_nRailDist, ptTmp);
ads_polar(ptTmp, m_nRotation, m_nStairWidth-m_nRailDistToSide-m_nRailWidth*0.5, ptTmp);
gripPoints.append(ptTmp);
double dLen=(m_nStepNum-1)*m_nStepWidth;
ads_polar(ptUpLeft, m_nRotation-PI/2, m_nSlabSizeUR+m_nRailDist+dLen, ptTmp);
ads_polar(ptTmp, m_nRotation, m_nStairWidth+dStairWidth+m_nRailDistToSide+m_nRailWidth*0.5, ptTmp);
gripPoints.append(ptTmp);
}
//16,21--剖切位置 17,18,19,20--剖切线角度
{
XPoint ptLeft, ptRight,ptLeft2, ptRight2;
double lSectPos,rSectPos;
if(CalSectPos(lSectPos,rSectPos,ptLeft,ptRight,ptLeft2, ptRight2))
{
if(!(m_nStairFlag == SF_TOP && m_nSideFlag == 2))
{
XPoint ptMid;
Midpoint(ptLeft,ptRight,ptMid);
gripPoints.append(ptMid);
gripPoints.append(ptLeft);
gripPoints.append(ptRight);
}
if(!(m_nStairFlag == SF_TOP && m_nSideFlag == 1))
{
XPoint ptMid;
Midpoint(ptLeft2,ptRight2,ptMid);
gripPoints.append(ptMid);
gripPoints.append(ptLeft2);
gripPoints.append(ptRight2);
}
}
}
return Acad::eOk;
}
Acad::ErrorStatus
TDbCrossStair::subGetStretchPoints(AcGePoint3dArray & stretchPoints) const
{
assertReadEnabled();
XPoint ptUpLeft=GetUpLeft2d();
stretchPoints.append(ptUpLeft);
return Acad::eOk;
}
Acad::ErrorStatus
TDbCrossStair::GetGripText(int i, CString &cs) const
{
switch(i) {
case 0:
case 1:
case 2:
case 3:
cs=_T("移动楼梯");
break;
case 4:
case 5:
cs=_T("改楼梯间宽度");
break;
case 6:
case 7:
cs=_T("改梯段宽度");
break;
case 8:
case 9:
case 10:
case 11:
cs=_T("调整梯段位置");
break;
case 12:
case 13:
cs=_T("改平台宽");
break;
case 14:
case 15:
cs=_T("改扶手伸出距离");
break;
case 16:
cs=_T("移动剖切位置");
break;
case 17:
case 18:
cs=_T("移动剖切角度");
break;
case 19:
cs=_T("移动剖切位置");
break;
case 20:
case 21:
cs=_T("移动剖切角度");
break;
default:
break;
}
return Acad::eOk;
}
Acad::ErrorStatus
TDbCrossStair::subTransformBy(const AcGeMatrix3d& xform)
{
assertWriteEnabled();
TDbEntity::subTransformBy(xform);
XPoint ptX, ptY;
ads_polar(m_ptLocation, m_nRotation, GetSpaceWidth(), ptX);
ads_polar(m_ptLocation, m_nRotation+PI/2.0, 1000.0, ptY);
((AcGePoint3d &)ptX).transformBy(xform);
((AcGePoint3d &)ptY).transformBy(xform);
((AcGePoint3d &)m_ptLocation).transformBy(xform);
double nAng = CT_std_angle(ads_angle(m_ptLocation, ptY)-
ads_angle(m_ptLocation, ptX));
if(fabs(nAng-PI*1.5)<_angSnap)
{
TchPrivate::Exchange(m_ptLocation, ptX);
m_dSectRotation=-m_dSectRotation;
m_nStartSide = !m_nStartSide;
double nSlabSize=GetSlabSize();
m_nSlabSize = GetSlabSizeUR();
m_nSlabSizeUR=nSlabSize;
if(m_nSideFlag==1)
{
m_nSideFlag=2;
}
else if (m_nSideFlag==2)
{
m_nSideFlag=1;
}
}
m_nRotation = ads_angle(m_ptLocation, ptX);
return Acad::eOk;
}
Acad::ErrorStatus
TDbCrossStair::subMoveGripPointsAt(const AcDbIntArray& indices,
const AcGeVector3d& offset)
{
assertWriteEnabled();
XPoint vtOffset=*(XPoint *)&offset;
vtOffset.z = 0;
double dLength=m_nSlabSizeUR+m_nSlabSizeLR;
double nVtRot=CT_std_angle(ads_angle(XPoint(), vtOffset)-m_nRotation);
double nIncWidth=ads_distance(XPoint(), vtOffset) * cos(nVtRot);
double nIncLen=ads_distance(XPoint(), vtOffset) * sin(nVtRot);
int nLen=indices.length();
for (int i = 0; i < nLen; i++) {
int idx = indices[i];
switch(idx) {
case 0:
case 1:
case 2:
case 3: //移动楼梯
if(nLen==1) {
m_ptLocation += vtOffset;
}
break;
case 4: //改楼梯间宽度
if(m_nSpaceWidth-nIncWidth-2*m_nStairWidth>_DIST_SNAP)
{
m_nSpaceWidth -= nIncWidth;
ads_polar(XPoint(m_ptLocation), m_nRotation, nIncWidth, m_ptLocation);
}
else
{
ads_polar(XPoint(m_ptLocation), m_nRotation, m_nSpaceWidth-m_nStairWidth*2, m_ptLocation);
m_nSpaceWidth = m_nStairWidth*2;
}
break;
case 5: //改楼梯间宽度
if(m_nSpaceWidth+nIncWidth-2*m_nStairWidth>_DIST_SNAP)
m_nSpaceWidth += nIncWidth;
else
m_nSpaceWidth = m_nStairWidth*2;
break;
case 6: //改边梯段宽度
if(m_nStairWidth+nIncWidth > _DIST_SNAP && -1.0E-6<m_nSpaceWidth-2*(m_nStairWidth+nIncWidth))
m_nStairWidth += nIncWidth;
break;
case 7: //改边梯段宽度
if(m_nStairWidth-nIncWidth > _DIST_SNAP && -1.0E-6<m_nSpaceWidth-2*(m_nStairWidth-nIncWidth))
m_nStairWidth -= nIncWidth;
break;
case 8: //改休息平台尺寸
case 9: //左梯段位置
{
double size=dLength-m_nSlabSize;
if(m_nSlabSize-nIncLen>_DIST_SNAP&&m_nSlabSize-nIncLen<dLength)
m_nSlabSize -= nIncLen;
else if(m_nSlabSize-nIncLen<_DIST_SNAP)
m_nSlabSize = 0;
else if(m_nSlabSize-nIncLen>dLength)
m_nSlabSize = dLength;
}
break;
case 10:
case 11: //调整右梯段位置
{
if(m_nSlabSizeUR-nIncLen>_DIST_SNAP&&m_nSlabSizeUR-nIncLen<dLength)
{
m_nSlabSizeUR -= nIncLen;
m_nSlabSizeLR += nIncLen;
}
else if(m_nSlabSizeUR-nIncLen<_DIST_SNAP)
{
m_nSlabSizeUR = 0;
m_nSlabSizeLR = dLength;
}
else if(m_nSlabSizeUR-nIncLen>dLength)
{
m_nSlabSizeUR = dLength;
m_nSlabSizeLR = 0;
}
}
break;
case 12: //改休息台外侧尺寸
{
double size=m_nSlabSize<m_nSlabSizeUR?m_nSlabSize:m_nSlabSizeUR;
if(size+nIncLen>_DIST_SNAP)
{
m_nSlabSize += nIncLen;
m_nSlabSizeUR += nIncLen;
ads_polar(XPoint(m_ptLocation), m_nRotation+PI*0.5, nIncLen, m_ptLocation);
}
else
{
m_nSlabSize -= size;
m_nSlabSizeUR -= size;
ads_polar(XPoint(m_ptLocation), m_nRotation-PI*0.5, size, m_ptLocation);
}
}
break;
case 13: //改休息台外侧尺寸
{
double nSlabSizeLL=dLength-m_nSlabSizeLR;
double size=nSlabSizeLL<m_nSlabSizeLR?nSlabSizeLL:m_nSlabSizeLR;
if(size-nIncLen>_DIST_SNAP)
{
m_nSlabSizeLR -= nIncLen;
}
else
{
m_nSlabSizeLR -= size;
}
}
break;
case 14: //扶手伸出距离
if(m_nRailDist+nIncLen>_DIST_SNAP-(m_nStepNum-1)*m_nStepWidth*0.5)
m_nRailDist += nIncLen;
break;
case 15:
if(m_nRailDist-nIncLen>_DIST_SNAP-(m_nStepNum-1)*m_nStepWidth*0.5)
m_nRailDist -= nIncLen;
break;
case 16:
case 17:
case 18:
case 19:
case 20:
case 21: //剖切位置
{
double lSectPos,rSectPos;
XPoint ptLeft2d,ptRight2d,ptLeft2, ptRight2;
double angle=m_dSectRotation;
if(CalSectPos(lSectPos,rSectPos,ptLeft2d,ptRight2d,ptLeft2, ptRight2))
{
XPoint ptMid;
if(!(m_nStairFlag == SF_TOP && m_nSideFlag == 2))
{
if(idx==16 ||idx==17 ||idx==18)
{
Midpoint(ptLeft2d,ptRight2d,ptMid);
}
else
{
Midpoint(ptLeft2,ptRight2,ptMid);
ptLeft2d=ptLeft2;
ptRight2d=ptRight2;
}
}
else
{
if(m_nStairFlag == SF_TOP && m_nSideFlag == 2)
{
Midpoint(ptLeft2,ptRight2,ptMid);
ptLeft2d=ptLeft2;
ptRight2d=ptRight2;
}
}
if(idx==16||idx==19)
{
XPoint ptHit2d;
ptHit2d=ptMid;
ptHit2d += vtOffset;
int nPosHit=HitSectPosByPoint2d(ptHit2d);
if(nPosHit!=-1)
{
m_nSectStepNum = nPosHit;
}
}
else
{
XPoint ptTmp;
ads_polar(ptMid, m_nRotation, m_nStairWidth, ptTmp);
AcGeVector3d vectFrom,vectTo;
vectFrom=ptMid-ptTmp;
if(idx==17||idx==20)
{
ptTmp=ptLeft2d+vtOffset;
vectTo=ptMid-ptTmp;
}
else
{
ptTmp=ptRight2d+vtOffset;
vectTo=ptTmp-ptMid;
}
angle=vectFrom.angleTo(vectTo,AcGeVector3d::kZAxis);
SetSectRotation(angle);
}
}
break;
}
default:
break;
}
}
return Acad::eOk;
//return TDbEntity::moveGripPointsAt(indices, offset);
}
Acad::ErrorStatus
TDbCrossStair::subMoveStretchPointsAt(const AcDbIntArray& indices,
const AcGeVector3d& offset)
{
assertWriteEnabled();
if(indices.length()) {
AcGeMatrix3d mat;
mat.setToTranslation(offset);
subTransformBy(mat);
}
return Acad::eOk;
}
const TCHAR *
TDbCrossStair::GetDefaultLayer() const
{
return LAY_STAIR;
}
void
TDbCrossStair::GetTips(DList<TObjInfoUnit> &lstInfo) const
{
lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("剪刀楼梯")));
lstInfo.Append(new TObjInfoUnit(_T("楼梯步数"), XString(_T("%d"), int(GetStepNum()))));
lstInfo.Append(new TObjInfoUnit(_T("踏步高"), Dist2Str(GetStepHeight())));
lstInfo.Append(new TObjInfoUnit(_T("踏步宽"), Dist2Str(GetStepWidth())));
lstInfo.Append(new TObjInfoUnit(_T("楼梯高"), Dist2Str(GetStepHeight()*GetStepNum())));
lstInfo.Append(new TObjInfoUnit(_T("梯段宽"), Dist2Str(GetStairWidth())));
lstInfo.Append(new TObjInfoUnit(_T("梯间宽"), Dist2Str(GetSpaceWidth())));
lstInfo.Append(new TObjInfoUnit(_T("扶手宽"), Dist2Str(GetRailWidth())));
lstInfo.Append(new TObjInfoUnit(_T("扶手边距"), Dist2Str(GetRailDistToSide())));
lstInfo.Append(new TObjInfoUnit(_T("平台宽"), Dist2Str(GetSlabSize())));
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("楼层标记"), pszFloor));
lstInfo.Append(new TObjInfoUnit(_T("上楼位置"), m_nStartSide? _T("右边") : _T("左边")));
}
Acad::ErrorStatus
TDbCrossStair::ExplodeTo(TDbLineStair &stair1, //[in/out]左梯段
TDbLineStair &stair2, //[in/out]右梯段
TDbSlab &slab, //[in/out]休息平台
TDbSlab &slab2, //[in/out]休息平台
TDbHandRail &rail, //[in/out]左扶手
TDbHandRail &rail2, //[in/out]右扶手
TDbHandRail* pRailOut1, //[out]边跑左梯段外侧扶手
TDbHandRail*pRailOut2 //[out]边跑右梯段外侧扶手
) const
{
assertReadEnabled();
XPoint ptUpLeft=GetUpLeft2d(),
ptUpRight=GetUpRight2d();
XPoint ptLowLeft, ptLowRight; //休息平台板的顶点
double nLen1=(m_nStepNum-1)*m_nStepWidth;
ads_polar(ptUpLeft, m_nRotation-PI/2.0, m_nSlabSize, ptLowLeft);
ads_polar(ptUpRight, m_nRotation-PI/2.0, m_nSlabSizeUR, ptLowRight);
//设置梯段宽度
stair1.SetStairWidth(m_nStairWidth);
stair2.SetStairWidth(m_nStairWidth);
//设置踏步高度
stair1.SetStepHeight(m_nStepHeight);
stair2.SetStepHeight(m_nStepHeight);
//设置踏步宽度
stair1.SetStepWidth(m_nStepWidth);
stair2.SetStepWidth(m_nStepWidth);
//设置踏步数
stair1.SetStepNum(m_nStepNum);
stair2.SetStepNum(m_nStepNum);
//设置踏步旋转角度
if(m_nStartSide == OFFSET_LEFT)
{
stair1.SetRotation(m_nRotation);
stair2.SetRotation(m_nRotation+PI);
}
else
{
stair1.SetRotation(m_nRotation+PI);
stair2.SetRotation(m_nRotation);
}
//计算梯段位置
XPoint ptLoc1, ptLoc2;
if(m_nStartSide==OFFSET_LEFT) //左边上楼
{
ads_polar(ptLowLeft, m_nRotation-PI/2, nLen1, ptLoc1);
ptLoc2=ptLowRight;
}
else //右边上楼
{
ads_polar(ptLowLeft, m_nRotation, m_nStairWidth, ptLoc1);
XPoint ptTmp;
ads_polar(ptLowRight, m_nRotation+PI, m_nStairWidth, ptTmp);
ads_polar(ptTmp, m_nRotation-PI/2, nLen1, ptLoc2);
}
ptLoc1.z=ptLoc2.z=GetElevation();
//设置梯段位置
stair1.SetLocation(ptLoc1);
stair2.SetLocation(ptLoc2);
//设置梯段标记
stair1.Set3DFlag(SF_HAS3D);
stair2.Set3DFlag(SF_HAS3D);
if(m_nStairFlag==SF_FIRST) //首层
{
if(m_nSideFlag == 0) //无地下室
{
stair1.Set2DFlag(SF_1SECT);
stair2.Set2DFlag(SF_1SECT);
}
else if (m_nSideFlag == 1) //左侧下行
{
stair1.Set2DFlag(SF_2SECT);
stair2.Set2DFlag(SF_1SECT);
}
else //右侧下行
{
stair1.Set2DFlag(SF_1SECT);
stair2.Set2DFlag(SF_2SECT);
}
}
else if(m_nStairFlag==SF_MIDDLE) //中间层
{
stair1.Set2DFlag(SF_2SECT);
stair2.Set2DFlag(SF_2SECT);
}
else //顶层
{
if(m_nSideFlag == 0) //无出屋顶
{
stair1.Set2DFlag(SF_NOSECT);
stair2.Set2DFlag(SF_NOSECT);
}
else if (m_nSideFlag == 1) //左侧上行
{
stair1.Set2DFlag(SF_2SECT);
stair2.Set2DFlag(SF_NOSECT);
}
else //右侧上行
{
stair1.Set2DFlag(SF_NOSECT);
stair2.Set2DFlag(SF_2SECT);
}
}
// 设置边梁属性
/*for(int nSide=0; nSide<2; nSide++)
{
stair1.SetSideBeam(nSide, HasSideBeam(nSide));
stair2.SetSideBeam(nSide, HasSideBeam(nSide));
}*/
if(m_nStartSide==OFFSET_LEFT)
{
stair1.SetSideBeam(0, IsOutSideBeam());
stair2.SetSideBeam(0, IsOutSideBeam());
stair1.SetSideBeam(1, IsInSideBeam());
stair2.SetSideBeam(1, IsInSideBeam());
}
else
{
stair1.SetSideBeam(1, IsOutSideBeam());
stair2.SetSideBeam(1, IsOutSideBeam());
stair1.SetSideBeam(0, IsInSideBeam());
stair2.SetSideBeam(0, IsInSideBeam());
}
/////////////////////////////////////////////////////////////////
//扶手, 考虑了详图画法
double nDistToSide=(GetSpaceWidth()-2*GetStairWidth())<_DIST_SNAP*2 ?
_AS_SYS_UNIT(0) : m_nRailDistToSide;
nDistToSide += m_nRailWidth/2;
double dStairWidth=0.0; //井宽
dStairWidth = (m_nSpaceWidth - m_nStairWidth*2.0);
if(dStairWidth < _DIST_SNAP)
{
dStairWidth=0.0;
}
XPoly2D polyRail,polyRail2,polyRail2D; //左右内侧扶手
XPoint ptStart,ptStart2;
{
int nSide = 0; //左右扶手
double dist = nDistToSide;
if(m_nStartSide==OFFSET_LEFT)
{
nSide = 1;
dist = -nDistToSide;
}
XLine line1=stair1.GetSideCurve2d(nSide).Offset(dist,0);
GetRailPoly(line1,stair1.GetRotation(),stair1.GetStairHeight(),polyRail,m_nStairFlag==SF_TOP);
XLine line2=stair2.GetSideCurve2d(nSide).Offset(dist,0);
GetRailPoly(line2,stair2.GetRotation(),stair2.GetStairHeight(),polyRail2,m_nStairFlag==SF_TOP);
}
polyRail.SetFlag(0);
polyRail2.SetFlag(0);
rail.SetHas2D(TRUE);
rail.SetHas3D(TRUE);
rail2.SetHas2D(TRUE);
rail2.SetHas3D(TRUE);
rail.SetPathPoly(polyRail,GetNormal().AsAcGeVector3d());
rail.SetWidth(m_nRailWidth);
rail.SetHeight(m_nRailHeight);
rail.SetStyle(TDbHandRail::RS_RAIL1);
rail2.SetPathPoly(polyRail2,GetNormal().AsAcGeVector3d());
rail2.SetWidth(m_nRailWidth);
rail2.SetHeight(m_nRailHeight);
rail2.SetStyle(TDbHandRail::RS_RAIL1);
//外侧扶手
double nDist=m_nStartSide==OFFSET_LEFT?nDistToSide:-nDistToSide;
if(pRailOut1!=0) //左边梯外侧扶手
{
XPoly2D poly;
XLine line=stair1.GetSideCurve2d(m_nStartSide==OFFSET_LEFT?0:1).Offset(nDist,0);
GetRailPoly(line,stair1.GetRotation(),stair1.GetStairHeight(),poly);
if(m_nStairFlag == SF_TOP && m_nSideFlag != 1)
{
//处理扶手端点
XPoint ptA;
ptA = *poly.Head();
ads_polar(ptA, stair1.GetRotation()+PI/2, m_nRailWidth*0.5, ptA);
*poly.Head() = ptA;
}
pRailOut1->SetPathPoly(poly,GetNormal().AsAcGeVector3d());
pRailOut1->SetWidth(m_nRailWidth);
pRailOut1->SetHeight(m_nRailHeight);
pRailOut1->SetStyle(TDbHandRail::RS_RAIL1);
}
if(pRailOut2!=0) //右边梯外侧扶手
{
XLine line=stair2.GetSideCurve2d(m_nStartSide==OFFSET_LEFT?0:1).Offset(nDist,0);
XPoly2D poly;
GetRailPoly(line,stair2.GetRotation(),stair2.GetStairHeight(),poly);
if(m_nStairFlag == SF_TOP && m_nSideFlag != 2)
{
//处理扶手端点
XPoint ptA;
ptA = *poly.Head();
ads_polar(ptA, stair2.GetRotation()+PI/2, m_nRailWidth*0.5, ptA);
*poly.Head() = ptA;
}
pRailOut2->SetPathPoly(poly,GetNormal().AsAcGeVector3d());
pRailOut2->SetWidth(m_nRailWidth);
pRailOut2->SetHeight(m_nRailHeight);
pRailOut2->SetStyle(TDbHandRail::RS_RAIL1);
}
//休息平台
//if(m_nSlabSize>_DIST_SNAP)
{
XPoint pt;
XPoly2D polySlab(1),polySlab2(1);
polySlab.AppendNode(ptUpRight);
polySlab.AppendNode(ptUpLeft);
polySlab.AppendNode(ptLowLeft);
if(m_nSlabSize<m_nSlabSizeUR)
{
ads_polar(ptLowLeft, m_nRotation, m_nSpaceWidth-m_nStairWidth, pt);
polySlab.AppendNode(pt);
ads_polar(pt, m_nRotation-PI/2, m_nSlabSizeUR-m_nSlabSize, pt);
polySlab.AppendNode(pt);
}
else
{
if(m_nSlabSize-m_nSlabSizeUR>_DIST_SNAP)
{
ads_polar(ptLowLeft, m_nRotation, m_nStairWidth, pt);
polySlab.AppendNode(pt);
ads_polar(pt, m_nRotation+PI/2, m_nSlabSize-m_nSlabSizeUR, pt);
polySlab.AppendNode(pt);
}
}
polySlab.AppendNode(ptLowRight);
if(polySlab.PathArea()>0)
polySlab.Reverse();
slab.SetOutline(polySlab);
//add by xlc on 090219
slab.SetElevation(GetElevation());
slab.SetThickness(-m_nSlabThick);
ads_polar(ptLowRight, m_nRotation-PI/2, stair1.GetStairLength(), pt);
polySlab2.AppendNode(pt);
ads_polar(pt, m_nRotation-PI/2, m_nSlabSizeLR, pt);
polySlab2.AppendNode(pt);
ads_polar(pt, m_nRotation+PI, m_nSpaceWidth, pt);
polySlab2.AppendNode(pt);
double nSlabSizeLL=m_nSlabSizeUR+m_nSlabSizeLR-m_nSlabSize;
ads_polar(pt, m_nRotation+PI/2, nSlabSizeLL, pt);
polySlab2.AppendNode(pt);
if(m_nSlabSizeLR<nSlabSizeLL)
{
ads_polar(pt, m_nRotation, m_nStairWidth, pt);
polySlab2.AppendNode(pt);
ads_polar(pt, m_nRotation-PI/2, nSlabSizeLL-m_nSlabSizeLR, pt);
polySlab2.AppendNode(pt);
}
else
{
if(m_nSlabSizeLR-nSlabSizeLL>_DIST_SNAP)
{
ads_polar(pt, m_nRotation, m_nSpaceWidth-m_nStairWidth, pt);
polySlab2.AppendNode(pt);
ads_polar(pt, m_nRotation+PI/2, m_nSlabSizeLR-nSlabSizeLL, pt);
polySlab2.AppendNode(pt);
}
}
if(polySlab2.PathArea()>0)
polySlab2.Reverse();
slab2.SetOutline(polySlab2);
//add by xlc on 090219
slab2.SetElevation(GetElevation());
slab2.SetThickness(-m_nSlabThick);
}
stair1.setPropertiesFrom(this);
stair2.setPropertiesFrom(this);
stair1.SetBeamHeight(GetBeamHeight());
stair2.SetBeamHeight(GetBeamHeight());
stair1.SetBeamThick(GetBeamThick());
stair2.SetBeamThick(GetBeamThick());
slab.setPropertiesFrom(this);
slab2.setPropertiesFrom(this);
rail.setPropertiesFrom(this);
rail2.setPropertiesFrom(this);
if(pRailOut1!=NULL)
pRailOut1->setPropertiesFrom(this);
if(pRailOut2!=NULL)
pRailOut2->setPropertiesFrom(this);
if(m_idLayerStep3d.isValid())
{
slab.setLayer(m_idLayerStep3d);
slab2.setLayer(m_idLayerStep3d);
stair1.SetLayerStep3d(m_idLayerStep3d);
stair2.SetLayerStep3d(m_idLayerStep3d);
}
if(m_idLayerBeam3d.isValid())
{
stair1.SetLayerBeam3d(m_idLayerBeam3d);
stair2.SetLayerBeam3d(m_idLayerBeam3d);
}
if(m_idLayerHand3d.isValid())
{
rail.setLayer(m_idLayerHand3d);
rail2.setLayer(m_idLayerHand3d);
if(pRailOut1!=NULL)
pRailOut1->setLayer(m_idLayerHand3d);
if(pRailOut2!=NULL)
pRailOut2->setLayer(m_idLayerHand3d);
}
return Acad::eOk;
}
void TDbCrossStair::GetRailPoly(XLine line, //[in]梯段线
double direct, //[in]梯段法向
double height, //[in]梯段高
XPoly2D &poly, //[in/out]扶手线
BOOL bTop //[in]是否顶层扶手线
)const
{
XPoint ptStart;
if(m_nRailDist > m_nStepWidth*0.5+_DIST_SNAP)
{
if(bTop)
{
ptStart=line.StartPoint();
ptStart.z=m_ptLocation.z+m_nStepHeight*0.5;
poly.AppendNode(ptStart); //扶手下伸出点
}
else
{
ads_polar(line.StartPoint(), direct-PI/2, m_nRailDist, ptStart);
ptStart.z=m_ptLocation.z;
poly.AppendNode(ptStart); //扶手下伸出点
ads_polar(line.StartPoint(), direct-PI/2, m_nStepWidth*0.5, ptStart);
ptStart.z=m_ptLocation.z;
poly.AppendNode(ptStart); //扶手折点
}
ads_polar(line.EndPoint(), direct+PI/2, m_nStepWidth*0.5, ptStart);
ptStart.z=m_ptLocation.z+height;
poly.AppendNode(ptStart); //扶手折点
ads_polar(ptStart, direct+PI/2, m_nRailDist-m_nStepWidth*0.5, ptStart);
poly.AppendNode(ptStart); //扶手上伸出点
}
else
{
if(bTop&&(m_nRailDist>0))
{
ptStart=line.StartPoint();
ptStart.z=m_ptLocation.z+m_nStepHeight*0.5;
poly.AppendNode(ptStart); //扶手下伸出点
}
else
{
ads_polar(line.StartPoint(), direct-PI/2, m_nRailDist, ptStart);
ptStart.z=m_ptLocation.z+fabs(m_nRailDist)/line.GetLength()*(height-m_nStepHeight)+m_nStepHeight*0.5;
poly.AppendNode(ptStart); //扶手回缩点
}
ads_polar(line.EndPoint(), direct+PI/2, m_nRailDist, ptStart);
ptStart.z=m_ptLocation.z+height+m_nRailDist/line.GetLength()*(height-m_nStepHeight)-m_nStepHeight*0.5;
poly.AppendNode(ptStart); //扶手回缩点
}
}
void TDbCrossStair::GetDefaultArrow(TDbLineStair &stair1,TDbLineStair &stair2,
TDbSymbArrow*pArrowUp1,TDbSymbArrow*pArrowUp2,
TDbSymbArrow*pArrowDown1,TDbSymbArrow*pArrowDown2)const
{
assertReadEnabled();
int nSectStepNum=m_nSectStepNum; //剖断步数
if(nSectStepNum < 0) //负数调整为正的
{
nSectStepNum=m_nSectStepNum+m_nStepNum+1;
}
if(nSectStepNum==m_nStepNum)
{
nSectStepNum--;
}
XPoint pt1,pt2,pt3,pt4,pt5,pt6,pt7,pt8,pt;
/*----------点相对位置示意----------------------
__________________
*pt4 | *pt5
| |
| |
*pt3 | *pt6
*pt2 | *pt7
| |
| |
*pt1 | *pt8
------------------------------------------------*/
ads_polar(stair1.GetLocation(),stair1.GetRotation(),stair1.GetStairWidth()/2,pt);
if(m_nStartSide==OFFSET_LEFT) //左边起步
{
ads_polar(pt,stair1.GetRotation()+PI/2,m_nStepWidth*(nSectStepNum-1),pt2);
ads_polar(pt,stair1.GetRotation()+PI/2,m_nStepWidth*nSectStepNum,pt3);
ads_polar(stair2.GetLocation(),stair2.GetRotation(),stair2.GetStairWidth()*0.5,pt);
ads_polar(pt,stair2.GetRotation()+PI/2,m_nStepWidth*(nSectStepNum-1),pt6);
ads_polar(pt,stair2.GetRotation()+PI/2,m_nStepWidth*nSectStepNum,pt7);
}
else //右边起步
{
ads_polar(pt,stair1.GetRotation()+PI/2,m_nStepWidth*(nSectStepNum-1),pt3);
ads_polar(pt,stair1.GetRotation()+PI/2,m_nStepWidth*nSectStepNum,pt2);
ads_polar(stair2.GetLocation(),stair2.GetRotation(),stair2.GetStairWidth()*0.5,pt);
ads_polar(pt,stair2.GetRotation()+PI/2,m_nStepWidth*(nSectStepNum-1),pt7);
ads_polar(pt,stair2.GetRotation()+PI/2,m_nStepWidth*nSectStepNum,pt6);
}
ads_polar(GetUpLeft2d(),GetRotation(),m_nStairWidth*0.5,pt);
ads_polar(pt,GetRotation()-PI/2,GetSlabSize()-m_nStepWidth*0.5,pt4);
ads_polar(pt4,GetRotation()-PI/2,stair1.GetStairLength()+m_nStepWidth,pt1);
ads_polar(GetUpRight2d(),GetRotation()+PI,m_nStairWidth*0.5,pt);
ads_polar(pt,GetRotation()-PI/2,GetSlabSizeUR()-m_nStepWidth*0.5,pt5);
ads_polar(pt5,GetRotation()-PI/2,stair1.GetStairLength()+m_nStepWidth,pt8);
if(m_nStairFlag != SF_TOP) //首层和中间层
{
XPoly2D poly;
if(m_nStartSide==OFFSET_LEFT) //左边起步
{
poly.AppendNode(pt1);
poly.AppendNode(pt2);
XPoly2D poly2;
poly2.AppendNode(pt5);
poly2.AppendNode(pt6);
poly2.SetElevation(GetElevation());
pArrowUp2->SetPoly2D(poly2);
if(m_nStairFlag == SF_FIRST && m_nSideFlag == 1) //首层左边有下行梯段
{
XPoly2D poly3;
poly3.AppendNode(pt4);
poly3.AppendNode(pt3);
poly3.SetElevation(GetElevation());
pArrowDown2->SetPoly2D(poly3);
}
else if(m_nStairFlag == SF_FIRST && m_nSideFlag == 2)//首层右边有下行梯段
{
XPoly2D poly3;
poly3.AppendNode(pt8);
poly3.AppendNode(pt7);
poly3.SetElevation(GetElevation());
pArrowDown2->SetPoly2D(poly3);
}
else if(m_nStairFlag == SF_MIDDLE)
{
XPoly2D poly3;
poly3.AppendNode(pt4);
poly3.AppendNode(pt3);
poly3.SetElevation(GetElevation());
pArrowDown1->SetPoly2D(poly3);
XPoly2D poly4;
poly4.AppendNode(pt8);
poly4.AppendNode(pt7);
poly4.SetElevation(GetElevation());
pArrowDown2->SetPoly2D(poly4);
}
}
else //右边起步
{
poly.AppendNode(pt8);
poly.AppendNode(pt7);
XPoly2D poly2;
poly2.AppendNode(pt4);
poly2.AppendNode(pt3);
poly2.SetElevation(GetElevation());
pArrowUp2->SetPoly2D(poly2);
if(m_nStairFlag == SF_FIRST && m_nSideFlag == 1) //首层左边有下行梯段
{
XPoly2D poly3;
poly3.AppendNode(pt1);
poly3.AppendNode(pt2);
poly3.SetElevation(GetElevation());
pArrowDown2->SetPoly2D(poly3);
}
else if(m_nStairFlag == SF_FIRST && m_nSideFlag == 2)//首层右边有下行梯段
{
XPoly2D poly3;
poly3.AppendNode(pt5);
poly3.AppendNode(pt6);
poly3.SetElevation(GetElevation());
pArrowDown2->SetPoly2D(poly3);
}
else if(m_nStairFlag == SF_MIDDLE)
{
XPoly2D poly3;
poly3.AppendNode(pt1);
poly3.AppendNode(pt2);
poly3.SetElevation(GetElevation());
pArrowDown1->SetPoly2D(poly3);
XPoly2D poly4;
poly4.AppendNode(pt5);
poly4.AppendNode(pt6);
poly4.SetElevation(GetElevation());
pArrowDown2->SetPoly2D(poly4);
}
}
poly.SetElevation(GetElevation());
pArrowUp1->SetPoly2D(poly);
}
else //顶层
{
XPoly2D poly1;
XPoly2D poly2;
if(m_nStartSide==OFFSET_LEFT) //左边起步
{
if(m_nSideFlag == 0) //无出屋顶
{
poly1.AppendNode(pt4);
XPoint tmp;
ads_polar(pt4,GetRotation()-PI/2,stair1.GetStairLength()-m_nStepWidth*0.5,tmp);
poly1.AppendNode(tmp);
poly2.AppendNode(pt8);
ads_polar(pt8,GetRotation()+PI/2,stair1.GetStairLength()-m_nStepWidth*0.5,tmp);
poly2.AppendNode(tmp);
}
else if(m_nSideFlag == 1) //左边有出屋顶
{
poly1.AppendNode(pt4);
poly1.AppendNode(pt3);
poly2.AppendNode(pt8);
XPoint tmp;
ads_polar(pt8,GetRotation()+PI/2,stair1.GetStairLength()-m_nStepWidth*0.5,tmp);
poly2.AppendNode(tmp);
XPoly2D poly3;
poly3.AppendNode(pt1);
poly3.AppendNode(pt2);
poly3.SetElevation(GetElevation());
pArrowUp1->SetPoly2D(poly3);
}
else //右边有出屋顶
{
poly1.AppendNode(pt4);
XPoint tmp;
ads_polar(pt4,GetRotation()-PI/2,stair1.GetStairLength()-m_nStepWidth*0.5,tmp);
poly1.AppendNode(tmp);
poly2.AppendNode(pt8);
poly2.AppendNode(pt7);
XPoly2D poly3;
poly3.AppendNode(pt5);
poly3.AppendNode(pt6);
poly3.SetElevation(GetElevation());
pArrowUp1->SetPoly2D(poly3);
}
}
else //右边起步
{
if(m_nSideFlag == 0) //无出屋顶
{
poly1.AppendNode(pt1);
XPoint tmp;
ads_polar(pt1,GetRotation()+PI/2,stair1.GetStairLength()-m_nStepWidth*0.5,tmp);
poly1.AppendNode(tmp);
poly2.AppendNode(pt5);
ads_polar(pt5,GetRotation()-PI/2,stair1.GetStairLength()-m_nStepWidth*0.5,tmp);
poly2.AppendNode(tmp);
}
else if(m_nSideFlag == 1) //左边有出屋顶
{
poly1.AppendNode(pt1);
poly1.AppendNode(pt2);
poly2.AppendNode(pt5);
XPoint tmp;
ads_polar(pt5,GetRotation()-PI/2,stair1.GetStairLength()-m_nStepWidth*0.5,tmp);
poly2.AppendNode(tmp);
XPoly2D poly3;
poly3.AppendNode(pt4);
poly3.AppendNode(pt3);
poly3.SetElevation(GetElevation());
pArrowUp1->SetPoly2D(poly3);
}
else //右边有出屋顶
{
poly1.AppendNode(pt1);
XPoint tmp;
ads_polar(pt1,GetRotation()+PI/2,stair1.GetStairLength()-m_nStepWidth*0.5,tmp);
poly1.AppendNode(tmp);
poly2.AppendNode(pt5);
poly2.AppendNode(pt6);
XPoly2D poly3;
poly3.AppendNode(pt8);
poly3.AppendNode(pt7);
poly3.SetElevation(GetElevation());
pArrowUp1->SetPoly2D(poly3);
}
}
poly1.SetElevation(GetElevation());
poly2.SetElevation(GetElevation());
pArrowDown1->SetPoly2D(poly1);
pArrowDown2->SetPoly2D(poly2);
}
{
pArrowUp1->setPropertiesFrom(this);
//add by xlc on 090212
pArrowUp1->SetTextHeight(m_dTextHeight);
//modify by xlc on 090205
pArrowUp1->SetLayoutRotation(GetLayoutRotation());
//modify by xlc on 090426
//pArrowUp1->SetText(_T("上"));
pArrowUp1->SetText(GetTextUp());
pArrowUp1->SetTextAlign(TDbSymbArrow::kAtSide);
pArrowUp1->SetTextLocation(pArrowUp1->GetDefaultTextLocation());
pArrowUp1->SetTextLayerId(m_idLayerText);
pArrowUp1->SetTextStyleId(m_idTextStyle);
pArrowUp2->setPropertiesFrom(this);
//add by xlc on 090212
pArrowUp2->SetTextHeight(m_dTextHeight);
pArrowUp2->SetLayoutRotation(GetLayoutRotation());
//modify by xlc on 090426
//pArrowUp2->SetText(_T("上"));
pArrowUp2->SetText(GetTextUp());
pArrowUp2->SetTextAlign(TDbSymbArrow::kAtSide);
pArrowUp2->SetTextLocation(pArrowUp2->GetDefaultTextLocation());
pArrowUp2->SetTextLayerId(m_idLayerText);
pArrowUp2->SetTextStyleId(m_idTextStyle);
pArrowDown1->setPropertiesFrom(this);
//add by xlc on 090212
pArrowDown1->SetTextHeight(m_dTextHeight);
pArrowDown1->SetLayoutRotation(GetLayoutRotation());
//modify by xlc on 090426
//pArrowDown1->SetText(_T("下"));
pArrowDown1->SetText(GetTextDown());
pArrowDown1->SetTextAlign(TDbSymbArrow::kAtSide);
pArrowDown1->SetTextLocation(pArrowDown1->GetDefaultTextLocation());
pArrowDown1->SetTextLayerId(m_idLayerText);
pArrowDown1->SetTextStyleId(m_idTextStyle);
pArrowDown2->setPropertiesFrom(this);
//add by xlc on 090212
pArrowDown2->SetTextHeight(m_dTextHeight);
pArrowDown2->SetLayoutRotation(GetLayoutRotation());
//modify by xlc on 090426
//pArrowDown2->SetText(_T("下"));
pArrowDown2->SetText(GetTextDown());
pArrowDown2->SetTextAlign(TDbSymbArrow::kAtSide);
pArrowDown2->SetTextLocation(pArrowDown2->GetDefaultTextLocation());
pArrowDown2->SetTextLayerId(m_idLayerText);
pArrowDown2->SetTextStyleId(m_idTextStyle);
if(m_idLayerArrow.isValid())
{
pArrowUp1->setLayer(m_idLayerArrow);
pArrowUp2->setLayer(m_idLayerArrow);
pArrowDown1->setLayer(m_idLayerArrow);
pArrowDown2->setLayer(m_idLayerArrow);
}
}
}
//add by xlc on 090123 获得梯段扶手线的位置
void TDbCrossStair::GetRailPolyFromStair(TDbLineStair &stair, //[in]操作梯段
double dOffset, //[in]偏移距离
double dDistS, //[in]起始端伸出距离
double dDistE, //[in]终端伸出距离
BOOL bRight, //[in]扶手侧
XPoly2D &poly //[out]扶手线
)const
{
poly.Reset();
XLine line=stair.GetSideCurve2d(bRight).Offset(dOffset,0);
XPoint pt=line.StartPoint();
pt.z=stair.GetElevation()+0.5*m_nStepHeight;
if(dDistS<-0.5*m_nStepWidth+_DIST_SNAP)
{
int num=(int)fabs((dDistS-0.5*m_nStepWidth)/m_nStepWidth);
ads_polar(pt, stair.GetRotation()+PI/2,m_nStepWidth*num, pt);
pt.z+=m_nStepHeight*num;
}
poly.AppendNode(pt);
pt=line.EndPoint();
pt.z=stair.GetElevation()+stair.GetStairHeight()-0.5*m_nStepHeight;
if(dDistE<-0.5*m_nStepWidth+_DIST_SNAP)
{
int num=(int)fabs((dDistE-0.5*m_nStepWidth)/m_nStepWidth);
ads_polar(pt, stair.GetRotation()-PI/2,m_nStepWidth*num, pt);
pt.z-=m_nStepHeight*num;
}
poly.AppendNode(pt);
}
void TDbCrossStair::DrawRail(XPoly2D polyPath,double nStepWidth,XExplodeDraw &dc) const
{
double nTotalDist=polyPath.Distance2d();
int nRailNum=AS_INT(nTotalDist/nStepWidth);
if(nRailNum<1)
nRailNum=1;
double nStepW=nTotalDist/nRailNum;
double nRailHeight=m_nRailHeight-_AS_SYS_UNIT(20);
if(m_nRailDistToSide < -_DIST_SNAP)//扶手偏移距离为负时栏杆增加一个踏步高
nRailHeight += m_nStepHeight;
for(int iRail=0; iRail<nRailNum; iRail++)
{
double nDist=nStepW/2.0 + iRail*nStepW;
XPoint pt;
double nDir=0.0;
polyPath.Polar2d(nDist, pt, &nDir);
XRectAngle box(pt, _AS_SYS_UNIT(40), _AS_SYS_UNIT(40));
XPoly2D poly2d;
box.AsPoly2D(poly2d);
if(m_nRailDistToSide < -_DIST_SNAP)//扶手偏移距离为负时栏杆增加一个踏步高
{
for(int i = 0; i < poly2d.Length(); i++)
{
poly2d[i]->z -= m_nStepHeight;
}
}
dc.DrawMesh(poly2d, XVector3D(0,0,nRailHeight));
}
}
Acad::ErrorStatus
TDbCrossStair::ExplodeOrDraw3d(XExplodeDraw &dc) const
{
if(m_nViewCtrl==1)
return Acad::eOk; //三维被禁止
if (m_nStepNum<2)
{
return Acad::eOk;
}
assertReadEnabled();
TDbLineStair stair1, stair2;
TDbSlab slab,slab2;
TDbHandRail rail, rail2,railOut1,railOut2;
ExplodeTo(stair1, stair2, slab, slab2,rail, rail2,&railOut1,&railOut2);
{
//左边梯段
if(m_nStairFlag == SF_FIRST
||m_nStairFlag == SF_MIDDLE
||(m_nStairFlag == SF_TOP && m_nSideFlag == 1))
{
TPushProperty vProp(&stair1, dc);
if(dc.IsFullExplode())
stair1.ExplodeOrDraw3d(dc);
else
dc.DrawEntity(stair1);
}
//右边梯段
if(m_nStairFlag == SF_FIRST
||m_nStairFlag == SF_MIDDLE
||(m_nStairFlag == SF_TOP && m_nSideFlag == 2))
{
TPushProperty vProp(&stair2, dc);
if(dc.IsFullExplode())
stair2.ExplodeOrDraw3d(dc);
else
dc.DrawEntity(stair2);
}
//休息平台
double nSlabSizeLL=m_nSlabSizeUR+m_nSlabSizeLR-m_nSlabSize;
if((m_nSlabSize>_DIST_SNAP||m_nSlabSizeUR>_DIST_SNAP||m_nSlabSizeLR>_DIST_SNAP||nSlabSizeLL>_DIST_SNAP )
&& !(m_nStairFlag == SF_TOP && m_nSideFlag == 0))
{
TPushProperty vProp(&slab, dc);
if(dc.IsFullExplode())
{
if(m_nStairFlag == SF_FIRST
||m_nStairFlag == SF_MIDDLE
||(m_nStairFlag == SF_TOP
&& ((m_nSideFlag == 2 && m_nStartSide == OFFSET_LEFT)
||(m_nSideFlag == 1 && m_nStartSide == OFFSET_RIGHT))))
{
slab.ExplodeOrDraw3d(dc);
}
if(m_nStairFlag == SF_FIRST
||m_nStairFlag == SF_MIDDLE
||(m_nStairFlag == SF_TOP
&& ((m_nSideFlag == 1 && m_nStartSide == OFFSET_LEFT)
||(m_nSideFlag == 2 && m_nStartSide == OFFSET_RIGHT))))
{
slab2.ExplodeOrDraw3d(dc);
}
}
else
{
if(m_nStairFlag == SF_FIRST
||m_nStairFlag == SF_MIDDLE
||(m_nStairFlag == SF_TOP
&& ((m_nSideFlag == 2 && m_nStartSide == OFFSET_LEFT)
||(m_nSideFlag == 1 && m_nStartSide == OFFSET_RIGHT))))
{
dc.DrawEntity(slab);
}
if(m_nStairFlag == SF_FIRST
||m_nStairFlag == SF_MIDDLE
||(m_nStairFlag == SF_TOP
&& ((m_nSideFlag == 1 && m_nStartSide == OFFSET_LEFT)
||(m_nSideFlag == 2 && m_nStartSide == OFFSET_RIGHT))))
{
dc.DrawEntity(slab2);
}
}
}
//add by xlc on 090123
double nDistToSide=(GetSpaceWidth()-2*GetStairWidth())<_DIST_SNAP*2 ?
_AS_SYS_UNIT(0) : m_nRailDistToSide;
nDistToSide += m_nRailWidth/2;
if(!(m_nStairFlag == SF_TOP && m_nSideFlag == 0))
{
//外侧扶手
if(IsOutRail())
{
if(dc.IsFullExplode())
{
if(m_nStairFlag == SF_FIRST
||m_nStairFlag == SF_MIDDLE
||(m_nStairFlag == SF_TOP && m_nSideFlag == 1))
{
railOut1.ExplodeOrDraw3d(dc);
}
if(m_nStairFlag == SF_FIRST
||m_nStairFlag == SF_MIDDLE
||(m_nStairFlag == SF_TOP && m_nSideFlag == 2))
{
railOut2.ExplodeOrDraw3d(dc);
}
}
else
{
if(m_nStairFlag == SF_FIRST
||m_nStairFlag == SF_MIDDLE
||(m_nStairFlag == SF_TOP && m_nSideFlag == 1))
{
dc.DrawEntity(railOut1);
}
if(m_nStairFlag == SF_FIRST
||m_nStairFlag == SF_MIDDLE
||(m_nStairFlag == SF_TOP && m_nSideFlag == 2))
{
dc.DrawEntity(railOut2);
}
}
// 外侧栏杆
if(IsAutoOutRail())
{
dc.SetColorLayer(colorIndex(), m_idLayerRail3d);
if(m_nStairFlag == SF_FIRST
||m_nStairFlag == SF_MIDDLE
||(m_nStairFlag == SF_TOP && m_nSideFlag == 1))
{
XPoly2D polyPath=railOut1.GetOutline();
//add by xlc on 090123 修改栏杆画法，只在踏步中间画
GetRailPolyFromStair(stair1,m_nStartSide==OFFSET_LEFT?nDistToSide:-nDistToSide,m_nRailDist,m_nRailDist,m_nStartSide,polyPath);
DrawRail(polyPath,m_nStepWidth,dc);
}
if(m_nStairFlag == SF_FIRST
||m_nStairFlag == SF_MIDDLE
||(m_nStairFlag == SF_TOP && m_nSideFlag == 2))
{
XPoly2D polyPath=railOut2.GetOutline();
//add by xlc on 090123 修改栏杆画法，只在踏步中间画
GetRailPolyFromStair(stair2,m_nStartSide==OFFSET_LEFT?nDistToSide:-nDistToSide,m_nRailDist,m_nRailDist,m_nStartSide,polyPath);
DrawRail(polyPath,m_nStepWidth,dc);
}
}
}
}
if(IsInRail())
{
extern BOOL g_bInElevProcess;
if(m_nStairFlag == SF_FIRST
||m_nStairFlag == SF_MIDDLE
||(m_nStairFlag == SF_TOP && m_nSideFlag == 1))
{
//内侧扶手
TPushProperty vProp(&rail, dc);
if(g_bInElevProcess)
{
XPoly2D polyPath;
AcGeVector3d normal;
rail.GetPathPoly(polyPath,normal);
for(int mm=0; mm<polyPath.TotalSegments(); mm++) {
XDirectionCurve cv;
polyPath.Nth(mm, cv);
if(fabs(cv.StartPoint().z-cv.EndPoint().z)>_DIST_SNAP) {
XPoly2D poly3d(0);
poly3d.AppendNode(cv.StartPoint(), cv.GetBulge());
poly3d.AppendNode(cv.EndPoint());
rail.SetPathPoly(poly3d,normal);
if(dc.IsFullExplode())
rail.ExplodeOrDraw3d(dc);
else
dc.DrawEntity(rail);
}
}
rail.SetPathPoly(polyPath,normal);
}
else
{
if(dc.IsFullExplode())
rail.ExplodeOrDraw3d(dc);
else
dc.DrawEntity(rail);
}
// 内侧栏杆
if(IsAutoRail())
{
dc.SetColorLayer(colorIndex(), m_idLayerRail3d);
XPoly2D polyPath=rail.GetOutline();
//add by xlc on 090123 修改栏杆画法，只在踏步中间画
GetRailPolyFromStair(stair1,m_nStartSide==OFFSET_LEFT?-nDistToSide:nDistToSide,m_nRailDist,m_nRailDist,!m_nStartSide,polyPath);
DrawRail(polyPath,m_nStepWidth,dc);
}
}
if(m_nStairFlag == SF_FIRST
||m_nStairFlag == SF_MIDDLE
||(m_nStairFlag == SF_TOP && m_nSideFlag == 2))
{
//内侧扶手
TPushProperty vProp2(&rail2, dc);
if(g_bInElevProcess)
{
XPoly2D polyPath;
AcGeVector3d normal;
rail2.GetPathPoly(polyPath,normal);
for(int mm=0; mm<polyPath.TotalSegments(); mm++)
{
XDirectionCurve cv;
polyPath.Nth(mm, cv);
if(fabs(cv.StartPoint().z-cv.EndPoint().z)>_DIST_SNAP)
{
XPoly2D poly3d(0);
poly3d.AppendNode(cv.StartPoint(), cv.GetBulge());
poly3d.AppendNode(cv.EndPoint());
rail2.SetPathPoly(poly3d,normal);
if(dc.IsFullExplode())
rail2.ExplodeOrDraw3d(dc);
else
dc.DrawEntity(rail2);
}
}
rail2.SetPathPoly(polyPath,normal);
}
else
{
if(dc.IsFullExplode())
rail2.ExplodeOrDraw3d(dc);
else
dc.DrawEntity(rail2);
}
// 内侧栏杆
if(IsAutoRail())
{
dc.SetColorLayer(colorIndex(), m_idLayerRail3d);
XPoly2D polyPath=rail2.GetOutline();
//add by xlc on 090123 修改栏杆画法，只在踏步中间画
GetRailPolyFromStair(stair2,m_nStartSide==OFFSET_LEFT?-nDistToSide:nDistToSide,m_nRailDist,m_nRailDist,!m_nStartSide,polyPath);
DrawRail(polyPath,m_nStepWidth,dc);
}
}
}
/*else
{
if(m_nSideFlag == 0)
{
TPushProperty vProp(&railTop, dc);
if(dc.IsFullExplode())
{
railTop.ExplodeOrDraw3d(dc);
railTop2.ExplodeOrDraw3d(dc);
}
else
{
dc.DrawEntity(railTop);
dc.DrawEntity(railTop2);
}
}
// 顶层栏杆
if(IsAutoRail())
{
dc.SetColorLayer(colorIndex(), m_idLayerRail3d);
XPoly2D polyPath=railTop.GetOutline();
DrawRail(polyPath,m_nStepWidth,dc);
polyPath=railTop2.GetOutline();
DrawRail(polyPath,m_nStepWidth,dc);
}
}*/
}
return Acad::eOk;
}
bool TDbCrossStair::IsClipMe(const TEntityBase* pEnt)const
{
if(TDbEntity::IsClipMe(pEnt))
return true;
if(pEnt->GetMe()->isKindOf(TDbColumn::desc()))
return true;
return false;
}
Acad::ErrorStatus
TDbCrossStair::ExplodeOrDraw2d(XExplodeDraw &dc) const
{
if(m_nViewCtrl==2)
return Acad::eOk; //二维被禁止
if (m_nStepNum<2)
{
return Acad::eOk;
}
assertReadEnabled();
CString s1=dc.Desc(),s2=XAcGiViewDraw::Descriptor();
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);
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
{
TDbLineStair stair1, stair2;
TDbSlab slab,slab2;
TDbHandRail rail,rail2,railOut1,railOut2;
ExplodeTo(stair1, stair2, slab, slab2, rail,rail2,&railOut1,&railOut2);
TDbSymbArrow pArrowUp1,pArrowUp2,pArrowDown1,pArrowDown2;
if(IsArrow()) //画箭头
{
GetDefaultArrow(stair1,stair2,&pArrowUp1,&pArrowUp2,&pArrowDown1,&pArrowDown2);
if(dc.IsFullExplode())
{
TPushProperty vProp(&pArrowUp1, dc);
pArrowUp1.ExplodeOrDraw2d(dc);
pArrowDown1.ExplodeOrDraw2d(dc);
pArrowUp2.ExplodeOrDraw2d(dc);
pArrowDown2.ExplodeOrDraw2d(dc);
}
else
{
dc.DrawEntity(pArrowUp1);
dc.DrawEntity(pArrowUp2);
dc.DrawEntity(pArrowDown1);
dc.DrawEntity(pArrowDown2);
}
}
if(IsInRail()) //内侧扶手
{
stair1.AddTempRail(&rail);
stair2.AddTempRail(&rail2);
}
if(IsOutRail()) //外侧扶手
{
stair1.AddTempRail(&railOut1);
railOut1.SetTempStair(&stair1);
stair2.AddTempRail(&railOut2);
railOut2.SetTempStair(&stair2);
}
XPoint ptSectLeft2d, ptSectRight2d;
double lSectPos,rSectPos;
XPoint ptLeft2d,ptRight2d,ptLeft2, ptRight2;
if(CalSectPos(lSectPos,rSectPos,ptLeft2d,ptRight2d,ptLeft2, ptRight2))
{
if(!(m_nStairFlag==SF_TOP&&m_nSideFlag==2))
{
stair1.SetSectionPos(0, lSectPos);
stair1.SetSectionPos(1, rSectPos);
}
if(!(m_nStairFlag==SF_TOP&&m_nSideFlag==1))
{
stair2.SetSectionPos(0, lSectPos);
stair2.SetSectionPos(1, rSectPos);
}
}
else
{
stair1.Set2DFlag(SF_NOSECT);
stair2.Set2DFlag(SF_NOSECT);
}
//显示梯段
if(dc.IsFullExplode())
{
stair1.ExplodeOrDraw2d(dc);
stair2.ExplodeOrDraw2d(dc);
}
else
{
dc.DrawEntity(stair1);
dc.DrawEntity(stair2);
}
// 设置内侧扶手
if(IsInRail())
{
rail.SetTempStair(&stair1);
rail.setPropertiesFrom(this);
rail2.SetTempStair(&stair2);
rail2.setPropertiesFrom(this);
// 内侧扶手
if(dc.IsFullExplode())
{
rail.ExplodeOrDraw2d(dc);
rail2.ExplodeOrDraw2d(dc);
}
else
{
dc.DrawEntity(rail);
dc.DrawEntity(rail2);
}
}
//外侧扶手
if(IsOutRail())
{
railOut1.setPropertiesFrom(this);
railOut2.setPropertiesFrom(this);
if(dc.IsFullExplode())
{
railOut1.ExplodeOrDraw2d(dc);
railOut2.ExplodeOrDraw2d(dc);
}
else
{
dc.DrawEntity(railOut1);
dc.DrawEntity(railOut2);
}
}
//楼板线
/*{
if(m_nStairFlag == SF_FIRST)
{
XPoint pt1,pt2,pt3,pt4;
ads_polar(GetUpLeft2d(),m_nRotation,m_nStairWidth,pt1);
ads_polar(pt1,m_nRotation-PI/2,m_nSlabSize-m_nRailDist,pt1);
ads_polar(pt1,m_nRotation-PI/2,stair1.GetStairLength()+m_nRailDist*2,pt2);
ads_polar(GetUpRight2d(),m_nRotation+PI,m_nStairWidth,pt3);
ads_polar(pt3,m_nRotation-PI/2,m_nSlabSize-m_nRailDist,pt3);
ads_polar(pt3,m_nRotation-PI/2,stair1.GetStairLength()+m_nRailDist*2,pt4);
dc<<XLine(pt1,pt2);
dc<<XLine(pt1,pt2) <<XLine(pt1,pt3)<<XLine(pt3,pt4)<<XLine(pt4,pt2);
}
}*/
}
return Acad::eOk;
}
BOOL TDbCrossStair::CalSectPos(double &lSectPos,double &rSectPos,XPoint &ptLeft2d,XPoint &ptRight2d,XPoint &ptLeft2d2,XPoint &ptRight2d2)const
{
if(m_nStairFlag == SF_TOP && m_nSideFlag == 0)
return FALSE;
if (m_nStepNum<2)
{
return FALSE;
}
TDbLineStair stair1, stair2;
TDbSlab slab,slab2;
TDbHandRail rail,rail2;
ExplodeTo(stair1, stair2, slab, slab2, rail,rail2);
XDirectionCurve cvLeft1,cvRight1;
double width=0; //剖断楼梯宽
double len=0; //剖断位置距楼梯起始点的距离
double length=0; //剖切梯段楼梯总长
int nSectStepNum=m_nSectStepNum; //剖断步数
if(nSectStepNum < 0) //负数调整为正的
{
nSectStepNum=m_nSectStepNum+m_nStepNum+1;
}
if(nSectStepNum==m_nStepNum)
{
nSectStepNum--;
}
len=(nSectStepNum-0.5)*m_nStepWidth;
if(nSectStepNum > 0 && nSectStepNum<m_nStepNum)
{
cvLeft1=stair1.GetSideCurve2d(0);
cvRight1=stair1.GetSideCurve2d(1);
width=stair1.GetStairWidth()*0.5;
length=stair1.GetStairLength();
}
else
{
return FALSE;
}
double dLen=0; //投影长
if(fabs(cos(m_dSectRotation))>_DIST_SNAP)
{
dLen=width*tan(m_dSectRotation);
}
else
{
return FALSE;
}
if((len+fabs(dLen)+m_nStepWidth/3.0 )>length
||(len-fabs(dLen)-m_nStepWidth/3.0 )<_DIST_SNAP) //剖断线转角过大，不能与梯段两边都相交
{
double dist=(len<length-len)?len:length-len;
dist -= m_nStepWidth/2;
if(tan(m_dSectRotation)>_DIST_SNAP)
{
dLen=dist;
}
else
{
dLen=-dist;
}
}
double nStairHeight1=GetStepNum()*GetStepHeight(); //梯高
lSectPos=(len-dLen)/length;
rSectPos=(len+dLen)/length;
XPointDir2d pt;
cvLeft1.Polar(len-dLen, pt);
ptLeft2d=pt;
cvRight1.Polar(len+dLen, pt);
ptRight2d=pt;
XDirectionCurve cvLeft2,cvRight2;
cvLeft2=stair2.GetSideCurve2d(0);
cvRight2=stair2.GetSideCurve2d(1);
cvLeft2.Polar(len-dLen, pt);
ptLeft2d2=pt;
cvRight2.Polar(len+dLen, pt);
ptRight2d2=pt;
return TRUE;
}
// 由平面二维点推算剖切步数
int TDbCrossStair::HitSectPosByPoint2d(XPoint ptHit2d) const
{
if (m_nStepNum<2)
{
return 0;
}
TDbLineStair stair1, stair2;
TDbSlab slab,slab2;
TDbHandRail rail, rail2;
ExplodeTo(stair1, stair2, slab, slab2, rail, rail2);
XDirectionCurve cvLeft1=stair1.GetSideCurve2d(0);
XDirectionCurve cvRight1=stair1.GetSideCurve2d(1);
XPoly2D poly1(1);
poly1.AppendNode(cvLeft1.StartPoint());
poly1.AppendNode(cvRight1.StartPoint());
poly1.AppendNode(cvRight1.EndPoint());
poly1.AppendNode(cvLeft1.EndPoint());
ptHit2d.z=0;
int nPosHit=-1;
if((ptHit2d&poly1)!=PR_OUTSIDE)
{
if(!(m_nStairFlag==SF_TOP&&m_nSideFlag==2))
{
XPoint ptPrj;
cvLeft1.ProjectToMe(ptHit2d, ptPrj);
nPosHit=(int)(ptPrj.Distance2d(cvLeft1.StartPoint())/m_nStepWidth);
nPosHit += 1;
}
}
else
{
XDirectionCurve cvLeft2=stair2.GetSideCurve2d(0);
XDirectionCurve cvRight2=stair2.GetSideCurve2d(1);
XPoly2D poly2(1);
poly2.AppendNode(cvLeft2.StartPoint());
poly2.AppendNode(cvRight2.StartPoint());
poly2.AppendNode(cvRight2.EndPoint());
poly2.AppendNode(cvLeft2.EndPoint());
if((ptHit2d&poly2)!=PR_OUTSIDE)
{
if(!(m_nStairFlag==SF_TOP&&m_nSideFlag==1))
{
XPoint ptPrj;
cvLeft2.ProjectToMe(ptHit2d, ptPrj);
nPosHit=(int)(ptPrj.Distance2d(cvLeft2.StartPoint())/m_nStepWidth);
nPosHit += 1;
}
}
}
return nPosHit;
}
double
TDbCrossStair::GetTextHeight()const
{
assertReadEnabled();
return m_dTextHeight;
}
void
TDbCrossStair::SetTextHeight(double h)
{
assertWriteEnabled();
m_dTextHeight=h;
}
Adesk::UInt8
TDbCrossStair::GetStepNum() const
{
assertReadEnabled();
return m_nStepNum;
}
double
TDbCrossStair::GetStepHeight() const
{
assertReadEnabled();
return m_nStepHeight;
}
void
TDbCrossStair::SetStepNum(Adesk::UInt8 n)
{
assertWriteEnabled();
m_nStepNum=n;
}
double
TDbCrossStair::GetSlabSize() const
{
assertReadEnabled();
return m_nSlabSize;
}
double
TDbCrossStair::GetSlabSizeUR() const
{
assertReadEnabled();
return m_nSlabSizeUR;
}
double
TDbCrossStair::GetSlabSizeLR() const
{
assertReadEnabled();
return m_nSlabSizeLR;
}
double
TDbCrossStair::GetRailHeight() const
{
assertReadEnabled();
return m_nRailHeight;
}
double
TDbCrossStair::GetRailWidth() const
{
assertReadEnabled();
return m_nRailWidth;
}
double
TDbCrossStair::GetRailDistToSide() const
{
assertReadEnabled();
return m_nRailDistToSide;
}
double
TDbCrossStair::GetRailDist() const
{
assertReadEnabled();
return m_nRailDist;
}
double
TDbCrossStair::GetSpaceWidth() const
{
assertReadEnabled();
return m_nSpaceWidth;
}
double
TDbCrossStair::GetStairWidth() const
{
assertReadEnabled();
return m_nStairWidth;
}
double
TDbCrossStair::GetStepWidth() const
{
assertReadEnabled();
return m_nStepWidth;
}
Adesk::UInt8
TDbCrossStair::GetStairFlag() const
{
assertReadEnabled();
return m_nStairFlag;
}
int
TDbCrossStair::GetSectStepNum()const
{
assertReadEnabled();
return m_nSectStepNum;
}
double
TDbCrossStair::GetElevation() const
{
assertReadEnabled();
return m_ptLocation.z;
}
XPoint
TDbCrossStair::GetLocation() const
{
assertReadEnabled();
return m_ptLocation;
}
double
TDbCrossStair::GetRotation() const
{
assertReadEnabled();
return m_nRotation;
}
int
TDbCrossStair::GetStartSide() const
{
assertReadEnabled();
return m_nStartSide;
}
int
TDbCrossStair::GetSideFlag() const
{
assertReadEnabled();
return m_nSideFlag;
}
XPoint
TDbCrossStair::GetUpRight2d() const
{
assertReadEnabled();
XPoint pt=GetUpLeft2d();
ads_polar(XPoint(pt), m_nRotation, m_nSpaceWidth, pt);
return pt;
}
XPoint
TDbCrossStair::GetUpLeft2d() const
{
assertReadEnabled();
XPoint pt=m_ptLocation;
pt.z=0;
return pt;
}
void
TDbCrossStair::SetSlabSize(double s)
{
assertWriteEnabled();
m_nSlabSize=s;
}
void
TDbCrossStair::SetSlabSizeUR(double s)
{
assertWriteEnabled();
m_nSlabSizeUR=s;
}
void
TDbCrossStair::SetSlabSizeLR(double s)
{
assertWriteEnabled();
m_nSlabSizeLR=s;
}
void
TDbCrossStair::SetRailHeight(double l)
{
assertWriteEnabled();
m_nRailHeight=l;
}
void
TDbCrossStair::SetRailWidth(double w)
{
assertWriteEnabled();
m_nRailWidth=w;
}
void
TDbCrossStair::SetRailDistToSide(double l)
{
assertWriteEnabled();
m_nRailDistToSide=l;
}
void
TDbCrossStair::SetRailDist(double l)
{
assertWriteEnabled();
m_nRailDist=l;
}
void
TDbCrossStair::SetStairFlag(Adesk::UInt8 flag)
{
assertWriteEnabled();
m_nStairFlag=flag;
}
void
TDbCrossStair::SetSpaceWidth(double w)
{
assertWriteEnabled();
m_nSpaceWidth=w;
}
void
TDbCrossStair::SetStepWidth(double w)
{
assertWriteEnabled();
m_nStepWidth=w;
}
void
TDbCrossStair::SetStairWidth(double w)
{
assertWriteEnabled();
m_nStairWidth=w;
}
void
TDbCrossStair::SetElevation(double elev)
{
assertWriteEnabled();
m_ptLocation.z = elev;
}
void
TDbCrossStair::SetLocation(const XPoint &pt)
{
assertWriteEnabled();
m_ptLocation = pt;
}
void
TDbCrossStair::SetRotation(double rot)
{
assertWriteEnabled();
m_nRotation=rot;
}
void
TDbCrossStair::SetStartSide(int nSide)
{
assertWriteEnabled();
m_nStartSide=nSide;
}
void
TDbCrossStair::SetSideFlag(Adesk::UInt8 flag)
{
assertWriteEnabled();
m_nSideFlag=flag;
}
void
TDbCrossStair::SetStepHeight(double h)
{
assertWriteEnabled();
m_nStepHeight=h;
}
void TDbCrossStair::SetArrow(BOOL bTrue)
{
assertWriteEnabled();
if(bTrue)
m_nFlagEx|=SFEX_ARROW;
else
m_nFlagEx&=~SFEX_ARROW;
}
BOOL TDbCrossStair::IsArrow() const
{
return ((m_nFlagEx&SFEX_ARROW)!=0);
}
BOOL TDbCrossStair::IsAutoOutRail() const
{
return ((m_nFlagEx&SFEX_AUTOOUTRAIL)!=0);
}
BOOL TDbCrossStair::IsAutoRail() const
{
return ((m_nFlagEx&SFEX_AUTORAIL)!=0);
}
BOOL TDbCrossStair::IsOutRail()const
{
return (m_nFlagEx&SFEX_OUTRAIL)!=0;
}
void TDbCrossStair::SetOutRail(BOOL bTrue)
{
assertWriteEnabled();
if(bTrue)
m_nFlagEx|=SFEX_OUTRAIL;
else
m_nFlagEx&=~SFEX_OUTRAIL;
}
BOOL TDbCrossStair::IsInRail()const
{
return (m_nFlagEx&SFEX_INRAIL)!=0;
}
void TDbCrossStair::SetInRail(BOOL bTrue)
{
assertWriteEnabled();
if(bTrue)
m_nFlagEx|=SFEX_INRAIL;
else
m_nFlagEx&=~SFEX_INRAIL;
}
BOOL TDbCrossStair::IsArcPlatform() const
{
return ((m_nFlagEx&SFEX_ARCPLAT)!=0);
}
BOOL TDbCrossStair::HasSideBeam(int nSide) const
{
int nBitFlag=nSide? SFEX_RBEAM : SFEX_LBEAM;
return ((m_nFlagEx&nBitFlag)!=0);
}
BOOL TDbCrossStair::IsAscent() const
{
return ((m_nFlagEx&SFEX_ASCENT)!=0);
}
BOOL TDbCrossStair::IsOnGround() const
{
return ((m_nFlagEx&SFEX_GROUND)!=0);
}
BOOL TDbCrossStair::HasSlant() const
{
return ((m_nFlagEx&SFEX_SLANT)!=0);
}
void TDbCrossStair::SetAutoOutRail(BOOL bTrue)
{
assertWriteEnabled();
if(bTrue)
m_nFlagEx |= SFEX_AUTOOUTRAIL;
else
m_nFlagEx &= ~SFEX_AUTOOUTRAIL;
}
void TDbCrossStair::SetAutoRail(BOOL bTrue)
{
assertWriteEnabled();
if(bTrue)
m_nFlagEx |= SFEX_AUTORAIL;
else
m_nFlagEx &= ~SFEX_AUTORAIL;
}
void TDbCrossStair::SetAscent(BOOL bTrue)
{
assertWriteEnabled();
if(bTrue)
m_nFlagEx |= SFEX_ASCENT;
else
m_nFlagEx &= ~SFEX_ASCENT;
}
void TDbCrossStair::SetOnGround(BOOL bTrue)
{
assertWriteEnabled();
if(bTrue)
m_nFlagEx |= SFEX_GROUND;
else
m_nFlagEx &= ~SFEX_GROUND;
}
void TDbCrossStair::SetSlant(BOOL bTrue)
{
assertWriteEnabled();
if(bTrue)
m_nFlagEx |= SFEX_SLANT;
else
m_nFlagEx &= ~SFEX_SLANT;
}
void TDbCrossStair::SetArcPlatform(BOOL bTrue)
{
assertWriteEnabled();
if(bTrue)
m_nFlagEx |= SFEX_ARCPLAT;
else
m_nFlagEx &= ~SFEX_ARCPLAT;
}
void TDbCrossStair::SetSideBeam(int nSide, BOOL bTrue)
{
assertWriteEnabled();
int nBitFlag=nSide? SFEX_RBEAM : SFEX_LBEAM;
if(bTrue)
m_nFlagEx |= nBitFlag;
else
m_nFlagEx &= ~nBitFlag;
}
double TDbCrossStair::GetBeamHeight() const
{
return m_nBeamHeight;
}
double TDbCrossStair::GetBeamThick() const
{
return m_nBeamThick;
}
double TDbCrossStair::GetSlabThick() const
{
return m_nSlabThick;
}
AcDbObjectId TDbCrossStair::GetLayerBeam3d() const
{
return m_idLayerBeam3d;
}
AcDbObjectId TDbCrossStair::GetLayerStep3d() const
{
return m_idLayerStep3d;
}
AcDbObjectId TDbCrossStair::GetLayerHand3d() const
{
return m_idLayerHand3d;
}
AcDbObjectId TDbCrossStair::GetLayerRail3d() const
{
return m_idLayerRail3d;
}
AcDbObjectId TDbCrossStair::GetLayerText() const
{
return m_idLayerText;
}
AcDbObjectId TDbCrossStair::GetTextStyle() const
{
return m_idTextStyle;
}
AcDbObjectId TDbCrossStair::GetLayerArrow() const
{
return m_idLayerArrow;
}
void TDbCrossStair::SetBeamHeight(double val)
{
assertWriteEnabled();
m_nBeamHeight = val;
}
void TDbCrossStair::SetSlabThick(double val)
{
assertWriteEnabled();
m_nSlabThick=val;
}
void TDbCrossStair::SetBeamThick(double val)
{
assertWriteEnabled();
m_nBeamThick=val;
}
void TDbCrossStair::SetLayerBeam3d(AcDbObjectId idLayer)
{
assertWriteEnabled();
m_idLayerBeam3d=idLayer;
}
void TDbCrossStair::SetLayerStep3d(AcDbObjectId idLayer)
{
assertWriteEnabled();
m_idLayerStep3d=idLayer;
}
void TDbCrossStair::SetLayerHand3d(AcDbObjectId idLayer)
{
assertWriteEnabled();
m_idLayerHand3d=idLayer;
}
void TDbCrossStair::SetLayerRail3d(AcDbObjectId idLayer)
{
assertWriteEnabled();
m_idLayerRail3d=idLayer;
}
void TDbCrossStair::SetLayerText(AcDbObjectId idLayer)
{
assertWriteEnabled();
m_idLayerText=idLayer;
}
void TDbCrossStair::SetTextStyle(AcDbObjectId idStyle)
{
assertWriteEnabled();
m_idTextStyle=idStyle;
}
void TDbCrossStair::SetLayerArrow(AcDbObjectId idLayer)
{
assertWriteEnabled();
m_idLayerArrow=idLayer;
}
void TDbCrossStair::SetSectStepNum(int n)
{
assertWriteEnabled();
m_nSectStepNum=n;
}
double TDbCrossStair::GetSectRotation()const
{
return m_dSectRotation;
}
void TDbCrossStair::SetSectRotation(double r)
{
assertWriteEnabled();
m_dSectRotation=r;
}
//add by xlc 090426，箭头文字，动态数据
CString TDbCrossStair::GetTextUp() const
{
assertReadEnabled();
CString sVal(_T("上"));
const TEntityFields &fd = GetFields();
fd.GFD(_T("上楼箭头文字"), sVal);
return sVal;
}
void TDbCrossStair::SetTextUp(const TCHAR *sVal)
{
assertWriteEnabled();
TEntityFields &fd = Fields();
fd.SFD(_T("上楼箭头文字"), sVal);
}
CString TDbCrossStair::GetTextDown() const
{
assertReadEnabled();
CString sVal(_T("下"));
const TEntityFields &fd = GetFields();
fd.GFD(_T("下楼箭头文字"), sVal);
return sVal;
}
void TDbCrossStair::SetTextDown(const TCHAR *sVal)
{
assertWriteEnabled();
TEntityFields &fd = Fields();
fd.SFD(_T("下楼箭头文字"), sVal);
}
// sg add 101115，支持统一标高
bool TDbCrossStair::UnifyElevation(double dElevation)
{
assertWriteEnabled();
SetElevation(dElevation);
return true;
}
// cet 2013.9.5 add
CString TDbCrossStair::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 InitDbCrossStair(BOOL bTrue)
{
if(bTrue)
{
TDbCrossStair::rxInit();
acrxBuildClassHierarchy();
TDbCrossStair::InitMatchProtocol(TRUE);
}
else
{
TDbCrossStair::InitMatchProtocol(FALSE);
deleteAcRxClass(TDbCrossStair::desc());
}
}
Reference in new issue View Git Blame Copy Permalink