4414 lines
118 KiB
C++
4414 lines
118 KiB
C++
#include "stdafx.h"
|
|
#include "TDbColumn.h"
|
|
|
|
|
|
//ver: 0-TArch8
|
|
const Adesk::UInt8 TDbScissorsStair::g_nVersion = 0;
|
|
|
|
|
|
ACRX_DXF_DEFINE_MEMBERS(ATSScissorsStair, ATSPolyPathEnt, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
|
1, ATS_SCISSORSSTAIR, "ATS_SCISSORSSTAIR图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
|
|
|
|
IMPLEMENT_TENTBASE(TDbScissorsStair);
|
|
|
|
TDbScissorsStair::TDbScissorsStair()
|
|
{
|
|
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_nRotation=0.0; //旋转角度
|
|
m_nStepNum1=m_nStepNum2=0; //一二跑步数
|
|
m_nSpaceWidth=_AS_SYS_UNIT(3600.0); //楼梯间尺寸
|
|
m_nRailHeight=_AS_SYS_UNIT(900);
|
|
m_nStairFlag=1; //楼层标记
|
|
m_nStartSide=OFFSET_LEFT; //左梯起步
|
|
m_nAlignment=0; //踏步取齐: 0--齐休息平台, 1--齐中间, 2--齐楼板
|
|
|
|
m_nRailWidth=_AS_SYS_UNIT(60.0); //扶手宽度
|
|
m_nRailDistMid=m_nStepWidth*0.5; //层间转角处扶手伸出距离
|
|
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;
|
|
}
|
|
|
|
|
|
TDbScissorsStair::~TDbScissorsStair()
|
|
{
|
|
}
|
|
|
|
BOOL TDbScissorsStair::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_nStepNum1>1 && //一跑步数
|
|
m_nStepNum2>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 TDbScissorsStair::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbPolyPathEnt::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
|
|
TDbScissorsStair *pSrc=TDbScissorsStair::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_nStepNum1=pSrc->m_nStepNum1;
|
|
m_nStepNum2=pSrc->m_nStepNum2;
|
|
m_dTextHeight=pSrc->m_dTextHeight;
|
|
m_nSpaceWidth=pSrc->m_nSpaceWidth;
|
|
m_nRailHeight=pSrc->m_nRailHeight;
|
|
m_nRailWidth=pSrc->m_nRailWidth;
|
|
m_nRailDistToSide=pSrc->m_nRailDistToSide;
|
|
m_nStairFlag=pSrc->m_nStairFlag;
|
|
m_nAlignment=pSrc->m_nAlignment;
|
|
m_nRailDistMid=pSrc->m_nRailDistMid;
|
|
m_nRailDist=pSrc->m_nRailDist;
|
|
m_dSectRotation=pSrc->m_dSectRotation;
|
|
m_nSectStepNum=pSrc->m_nSectStepNum;
|
|
m_nStartSide=pSrc->m_nStartSide;
|
|
|
|
//add by xlc on 090426箭头文字
|
|
SetTextUp(pSrc->GetTextUp());
|
|
SetTextDown(pSrc->GetTextDown());
|
|
|
|
m_nFlagEx=pSrc->m_nFlagEx;
|
|
m_nBeamHeight=pSrc->m_nBeamHeight; //边梁高，坡道专用
|
|
m_nBeamThick=pSrc->m_nBeamThick; //边梁厚度
|
|
m_nSlabThick=pSrc->m_nSlabThick; //板厚或梁厚
|
|
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
|
|
TDbScissorsStair::subGetClassID(CLSID* pClsid) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// 从DWG读入数据:
|
|
Acad::ErrorStatus
|
|
TDbScissorsStair::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_nStepNum1); //一跑步数
|
|
pFiler->readItem(&m_nStepNum2); //二跑步数
|
|
pFiler->readItem(&m_nSpaceWidth); //楼梯间尺寸
|
|
pFiler->readItem(&m_nRailHeight); //扶手高
|
|
pFiler->readItem(&m_nStairFlag); //楼层标记
|
|
pFiler->readItem(&m_nStartSide); //起步的一侧
|
|
pFiler->readItem(&m_nAlignment); //踏步取齐: 0--齐休息平台, 1--齐中间, 2--齐楼板
|
|
|
|
pFiler->readItem(&m_nRailWidth); //扶手宽
|
|
pFiler->readItem(&m_nRailDistToSide); //扶手距离边
|
|
pFiler->readItem(&m_nRailDistMid); //层间转角处扶手伸出距离
|
|
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
|
|
TDbScissorsStair::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_nStepNum1); //一跑步数
|
|
pFiler->writeItem(m_nStepNum2); //二跑步数
|
|
pFiler->writeItem(m_nSpaceWidth); //楼梯间宽度
|
|
pFiler->writeItem(m_nRailHeight); //扶手高度
|
|
pFiler->writeItem(m_nStairFlag); //楼层标记
|
|
pFiler->writeItem(m_nStartSide); //起步的一侧
|
|
pFiler->writeItem(m_nAlignment); //踏步取齐: 0--齐休息平台, 1--齐中间, 2--齐楼板
|
|
|
|
pFiler->writeItem(m_nRailWidth); //扶手宽
|
|
pFiler->writeItem(m_nRailDistToSide); //扶手距离边
|
|
pFiler->writeItem(m_nRailDistMid); //层间转角处扶手伸出距离
|
|
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
|
|
TDbScissorsStair::dxfInFields (AcDbDxfFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
Acad::ErrorStatus es = TDbPolyPathEnt::dxfInFields(pFiler);
|
|
if(es!=Acad::eOk)
|
|
return es;
|
|
|
|
if (!pFiler->atSubclassData(_T("TDbScissorsStair"))) {
|
|
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_nRailDistMid=rb.resval.rreal;
|
|
break;
|
|
case AcDb::kDxfReal+11:
|
|
m_nRailDist=rb.resval.rreal;
|
|
break;
|
|
case AcDb::kDxfReal+12:
|
|
m_dSectRotation=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);
|
|
SetStepNum1(i2);
|
|
SetStepNum2(i3);
|
|
m_nStartSide=i4;
|
|
m_nAlignment=i5;
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbScissorsStair::dxfOutFields(AcDbDxfFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es;
|
|
|
|
es = TDbPolyPathEnt::dxfOutFields(pFiler);
|
|
assert(es == Acad::eOk);
|
|
|
|
es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbScissorsStair"));
|
|
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, GetRailDistMid());
|
|
pFiler->writeDouble(AcDb::kDxfReal+11, GetRailDist());
|
|
pFiler->writeDouble(AcDb::kDxfReal+12, GetSectRotation());
|
|
pFiler->writeDouble(AcDb::kDxfAngle, GetRotation());
|
|
pFiler->writeInt16(AcDb::kDxfInt16, GetStairFlag());
|
|
pFiler->writeInt16(AcDb::kDxfInt16+1, GetStepNum1());
|
|
pFiler->writeInt16(AcDb::kDxfInt16+2, GetStepNum2());
|
|
pFiler->writeInt16(AcDb::kDxfInt16+3, m_nStartSide);
|
|
pFiler->writeInt16(AcDb::kDxfInt16+4, m_nAlignment);
|
|
|
|
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
|
|
TDbScissorsStair::subGetGripPoints(AcGePoint3dArray& gripPoints,
|
|
AcDbIntArray& osnapModes,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
assertReadEnabled();
|
|
int nStepNum1=m_nStepNum1,nStepNum2=m_nStepNum2;
|
|
if(m_nStartSide!=OFFSET_LEFT)
|
|
{
|
|
nStepNum1=m_nStepNum2;
|
|
nStepNum2=m_nStepNum1;
|
|
}
|
|
|
|
XPoint ptMidLeft=GetMidLeft2d(), ptMidRight=GetMidRight2d();
|
|
// 0,1--移动
|
|
gripPoints.append(ptMidLeft);
|
|
gripPoints.append(ptMidRight);
|
|
|
|
// 2,3,4,5--楼梯间
|
|
XPoint ptLeft1, ptRight1,ptLeft2, ptRight2;
|
|
double nDist=GetSlabSize()/2+(nStepNum1-1)*m_nStepWidth/2.0;
|
|
ads_polar(ptMidLeft, m_nRotation-PI/2.0, nDist, ptLeft1);
|
|
ads_polar(ptMidRight, m_nRotation-PI/2.0, nDist, ptRight1);
|
|
ads_polar(ptMidLeft, m_nRotation+PI/2.0, nDist, ptLeft2);
|
|
ads_polar(ptMidRight, m_nRotation+PI/2.0, nDist, ptRight2);
|
|
gripPoints.append(ptLeft1);
|
|
gripPoints.append(ptRight1);
|
|
gripPoints.append(ptLeft2);
|
|
gripPoints.append(ptRight2);
|
|
|
|
// 6,7,8,9--楼梯宽度
|
|
ads_polar(ptLeft1, m_nRotation, GetStairWidth(), ptLeft1);
|
|
ads_polar(ptRight1, m_nRotation+PI, GetStairWidth(), ptRight1);
|
|
ads_polar(ptRight1, m_nRotation+PI*0.5, GetStepWidth(), ptRight1);
|
|
ads_polar(ptLeft2, m_nRotation, GetStairWidth(), ptLeft2);
|
|
ads_polar(ptLeft2, m_nRotation+PI*0.5, GetStepWidth(), ptLeft2);
|
|
ads_polar(ptRight2, m_nRotation+PI, GetStairWidth(), ptRight2);
|
|
gripPoints.append(ptLeft1);
|
|
gripPoints.append(ptRight1);
|
|
gripPoints.append(ptLeft2);
|
|
gripPoints.append(ptRight2);
|
|
|
|
double dStairWidth=0.0; //井宽
|
|
dStairWidth = GetSpaceWidth() - GetStairWidth()*2.0;
|
|
if(dStairWidth < _DIST_SNAP)
|
|
{
|
|
dStairWidth=0.0;
|
|
}
|
|
|
|
// 10,11,12,13--休息平台
|
|
ads_polar(ptMidLeft, m_nRotation-PI/2.0, GetSlabSize()/2, ptLeft1);
|
|
ads_polar(ptMidRight, m_nRotation-PI/2.0, GetSlabSize()/2, ptRight1);
|
|
ads_polar(ptMidLeft, m_nRotation+PI/2.0, GetSlabSize()/2, ptLeft2);
|
|
ads_polar(ptMidRight, m_nRotation+PI/2.0, GetSlabSize()/2, ptRight2);
|
|
gripPoints.append(ptLeft1);
|
|
gripPoints.append(ptRight1);
|
|
gripPoints.append(ptLeft2);
|
|
gripPoints.append(ptRight2);
|
|
|
|
{
|
|
XPoint ptTmp,ptMid;
|
|
//14,15--休息平台端扶手伸出距离
|
|
ads_polar(ptMidLeft, m_nRotation, m_nStairWidth+dStairWidth*0.5, ptMid);
|
|
ads_polar(ptMid, m_nRotation-PI/2, m_nSlabSize/2-m_nRailDistMid, ptTmp);
|
|
gripPoints.append(ptTmp);
|
|
ads_polar(ptMid, m_nRotation+PI/2, m_nSlabSize/2-m_nRailDistMid, ptTmp);
|
|
gripPoints.append(ptTmp);
|
|
|
|
double dLen=((nStepNum1>nStepNum2)?(nStepNum1-1):(nStepNum2-1))*m_nStepWidth;
|
|
//16,17--楼层连接段扶手伸出距离
|
|
ads_polar(ptMid, m_nRotation-PI/2, m_nSlabSize/2+m_nRailDist+dLen, ptTmp);
|
|
gripPoints.append(ptTmp);
|
|
ads_polar(ptMid, m_nRotation+PI/2, m_nSlabSize/2+m_nRailDist+dLen, ptTmp);
|
|
gripPoints.append(ptTmp);
|
|
}
|
|
|
|
{ //剖切线
|
|
double lSectPos(0),rSectPos(0);
|
|
if(CalSectPos(lSectPos,rSectPos,ptLeft1,ptRight1,ptLeft2, ptRight2))
|
|
{
|
|
XPoint ptMid;
|
|
Midpoint(ptLeft1,ptRight1,ptMid);
|
|
gripPoints.append(ptMid);
|
|
gripPoints.append(ptLeft1);
|
|
gripPoints.append(ptRight1);
|
|
gripPoints.append(ptLeft2);
|
|
gripPoints.append(ptRight2);
|
|
Midpoint(ptLeft2,ptRight2,ptMid);
|
|
gripPoints.append(ptMid);
|
|
}
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbScissorsStair::subGetStretchPoints(AcGePoint3dArray & stretchPoints) const
|
|
{
|
|
assertReadEnabled();
|
|
XPoint ptUpLeft=GetMidLeft2d();
|
|
stretchPoints.append(ptUpLeft);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbScissorsStair::GetGripText(int i, CString &cs) const
|
|
{
|
|
switch(i) {
|
|
case 0:
|
|
case 1:
|
|
cs=_T("移动楼梯");
|
|
break;
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
cs=_T("改楼梯间宽度");
|
|
break;
|
|
case 6:
|
|
case 7:
|
|
case 8:
|
|
case 9:
|
|
cs=_T("改梯段宽度");
|
|
break;
|
|
case 10:
|
|
case 11:
|
|
case 12:
|
|
case 13:
|
|
cs=_T("改平台宽");
|
|
break;
|
|
case 14:
|
|
case 15:
|
|
case 16:
|
|
case 17:
|
|
cs=_T("改扶手伸出距离");
|
|
break;
|
|
case 18:
|
|
case 23:
|
|
cs=_T("移动剖切位置");
|
|
break;
|
|
case 19:
|
|
case 20:
|
|
case 21:
|
|
case 22:
|
|
cs=_T("移动剖切角度");
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
|
|
Acad::ErrorStatus
|
|
TDbScissorsStair::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;
|
|
}
|
|
|
|
m_nRotation = ads_angle(m_ptLocation, ptX);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbScissorsStair::subMoveGripPointsAt(const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
assertWriteEnabled();
|
|
XPoint vtOffset=*(XPoint *)&offset;
|
|
vtOffset.z = 0;
|
|
|
|
int nStepNum1=m_nStepNum1,nStepNum2=m_nStepNum2;
|
|
if(m_nStartSide!=OFFSET_LEFT)
|
|
{
|
|
nStepNum1=m_nStepNum2;
|
|
nStepNum2=m_nStepNum1;
|
|
}
|
|
|
|
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: //移动楼梯
|
|
if(nLen==1) {
|
|
m_ptLocation += vtOffset;
|
|
}
|
|
break;
|
|
case 2:
|
|
case 4: //改楼梯间宽度
|
|
if(m_nSpaceWidth-nIncWidth-2*m_nStairWidth > -1.0E-6)
|
|
{
|
|
m_nSpaceWidth -= nIncWidth;
|
|
ads_polar(XPoint(m_ptLocation), m_nRotation, nIncWidth, m_ptLocation);
|
|
}
|
|
else
|
|
{
|
|
double width=m_nSpaceWidth-m_nStairWidth*2;
|
|
ads_polar(XPoint(m_ptLocation), m_nRotation, width, m_ptLocation);
|
|
m_nSpaceWidth = m_nStairWidth*2;
|
|
}
|
|
break;
|
|
case 3:
|
|
case 5: //改楼梯间宽度
|
|
if(m_nSpaceWidth+nIncWidth-2*m_nStairWidth > -1.0E-6)
|
|
m_nSpaceWidth += nIncWidth;
|
|
else
|
|
m_nSpaceWidth = m_nStairWidth*2;
|
|
break;
|
|
case 6:
|
|
case 8: //改边梯段宽度
|
|
if(m_nStairWidth+nIncWidth > _DIST_SNAP && -1.0E-6<m_nSpaceWidth-2*(m_nStairWidth+nIncWidth))
|
|
m_nStairWidth += nIncWidth;
|
|
break;
|
|
case 7:
|
|
case 9: //改边梯段宽度
|
|
if(m_nStairWidth-nIncWidth > _DIST_SNAP && -1.0E-6<m_nSpaceWidth-2*(m_nStairWidth-nIncWidth))
|
|
m_nStairWidth -= nIncWidth;
|
|
break;
|
|
case 10:
|
|
case 11: //改休息平台尺寸
|
|
if(m_nSlabSize-nIncLen*2>_DIST_SNAP)
|
|
m_nSlabSize -= nIncLen*2;
|
|
break;
|
|
case 12:
|
|
case 13: //改休息平台尺寸
|
|
if(m_nSlabSize+nIncLen*2>_DIST_SNAP)
|
|
m_nSlabSize += nIncLen*2;
|
|
break;
|
|
case 14: //扶手伸出距离
|
|
if(m_nRailDistMid+nIncLen>-_DIST_SNAP && m_nRailDistMid+nIncLen < m_nSlabSize/2)
|
|
m_nRailDistMid += nIncLen;
|
|
else if(m_nRailDistMid+nIncLen<_DIST_SNAP)
|
|
m_nRailDistMid = 0;
|
|
break;
|
|
case 15: //扶手伸出距离
|
|
if(m_nRailDistMid-nIncLen>-_DIST_SNAP && m_nRailDistMid-nIncLen < m_nSlabSize/2)
|
|
m_nRailDistMid -= nIncLen;
|
|
else if(m_nRailDistMid-nIncLen<_DIST_SNAP)
|
|
m_nRailDistMid = 0;
|
|
break;
|
|
case 16: //扶手伸出距离
|
|
{
|
|
int num=(nStepNum1>nStepNum2)?nStepNum1:nStepNum2;
|
|
double length=(num-1)*0.5*m_nStepWidth;
|
|
if(m_nRailDist-nIncLen>-length)
|
|
m_nRailDist -= nIncLen;
|
|
}
|
|
break;
|
|
case 17: //扶手伸出距离
|
|
{
|
|
int num=(nStepNum1>nStepNum2)?nStepNum1:nStepNum2;
|
|
double length=(num-1)*0.5*m_nStepWidth;
|
|
if(m_nRailDist+nIncLen>-length)
|
|
m_nRailDist += nIncLen;
|
|
}
|
|
break;
|
|
case 18:
|
|
case 19:
|
|
case 20:
|
|
case 21:
|
|
case 22:
|
|
case 23: //剖切位置
|
|
{
|
|
double lSectPos,rSectPos;
|
|
XPoint ptLeft2d,ptRight2d,ptLeft1, ptRight1;
|
|
double angle=m_dSectRotation;
|
|
if(CalSectPos(lSectPos,rSectPos,ptLeft2d,ptRight2d,ptLeft1, ptRight1))
|
|
{
|
|
XPoint ptMid;
|
|
if(idx == 18 || idx == 19|| idx == 20)
|
|
{
|
|
Midpoint(ptLeft2d,ptRight2d,ptMid);
|
|
}
|
|
else
|
|
{
|
|
Midpoint(ptLeft1,ptRight1,ptMid);
|
|
ptLeft2d=ptLeft1;
|
|
ptRight2d=ptRight1;
|
|
}
|
|
if(idx==18||idx==23)
|
|
{
|
|
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-19)%2==0)
|
|
{
|
|
ptTmp=ptLeft2d+vtOffset;
|
|
vectTo=ptTmp-ptMid;
|
|
}
|
|
else
|
|
{
|
|
ptTmp=ptRight2d+vtOffset;
|
|
vectTo=ptMid-ptTmp;
|
|
}
|
|
angle=vectFrom.angleTo(vectTo,AcGeVector3d::kZAxis);
|
|
SetSectRotation(angle);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
//return TDbEntity::moveGripPointsAt(indices, offset);
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbScissorsStair::subMoveStretchPointsAt(const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
assertWriteEnabled();
|
|
if(indices.length()) {
|
|
AcGeMatrix3d mat;
|
|
mat.setToTranslation(offset);
|
|
subTransformBy(mat);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
const TCHAR *
|
|
TDbScissorsStair::GetDefaultLayer() const
|
|
{
|
|
return LAY_STAIR;
|
|
}
|
|
|
|
void
|
|
TDbScissorsStair::GetTips(DList<TObjInfoUnit> &lstInfo) const
|
|
{
|
|
lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("交叉楼梯")));
|
|
lstInfo.Append(new TObjInfoUnit(_T("左梯步数"), XString(_T("%d"), int(GetStepNum1()))));
|
|
lstInfo.Append(new TObjInfoUnit(_T("右梯步数"), XString(_T("%d"), int(GetStepNum2()))));
|
|
lstInfo.Append(new TObjInfoUnit(_T("踏步高"), Dist2Str(GetStepHeight())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("踏步宽"), Dist2Str(GetStepWidth())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("楼梯高"), Dist2Str(GetStepHeight()*(GetStepNum1()+GetStepNum2()))));
|
|
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));
|
|
const TCHAR *pszStep=_T("齐休息平台");
|
|
if(m_nAlignment==1)
|
|
pszStep=_T("齐中间");
|
|
else if(m_nAlignment==2)
|
|
pszStep=_T("齐楼板");
|
|
lstInfo.Append(new TObjInfoUnit(_T("踏步取齐"), pszStep));
|
|
lstInfo.Append(new TObjInfoUnit(_T("上楼位置"), m_nStartSide? _T("右侧") : _T("左侧")));
|
|
}
|
|
//右边起步时的内侧扶手
|
|
void TDbScissorsStair::GetRailFromRight(TDbLineStair &stair1, //[in/out]左梯段
|
|
TDbLineStair &stair2, //[in/out]右梯段
|
|
XPoly2D &polyRail, //[in/out]内侧扶手
|
|
XPoint &ptStart //[in/out]扶手顶点
|
|
)const
|
|
{
|
|
double nDistToSide=(GetSpaceWidth()-2*GetStairWidth()<_DIST_SNAP &&m_nRailDistToSide<0)?
|
|
_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;
|
|
}
|
|
|
|
//梯段位置
|
|
XPoint ptLoc1, ptLoc2;
|
|
ptLoc1 = stair1.GetLocation();
|
|
ptLoc2 = stair2.GetLocation();
|
|
|
|
//梯段长度
|
|
double nLen1=stair1.GetStairLength(),
|
|
nLen2=stair2.GetStairLength();
|
|
|
|
double nRailDist=m_nRailDist-m_nRailWidth*0.5,
|
|
nRailDistMid=m_nRailDistMid-m_nRailWidth*0.5; //扶手有连接时回缩半个扶手宽度
|
|
//扶手伸出距离为负时产生的高差
|
|
double elev1=(nRailDist/nLen1)*(stair1.GetStairHeight()-m_nStepHeight),
|
|
elev2=(nRailDistMid/nLen1)*(stair1.GetStairHeight()-m_nStepHeight);
|
|
|
|
if(m_nStairFlag!=SF_TOP)
|
|
{
|
|
BOOL bFlag=FALSE;
|
|
if(m_nStairFlag!=SF_FIRST && nLen2<nLen1-_DIST_SNAP && m_nAlignment!=2)// 踏步不与楼板取齐
|
|
{
|
|
//扶手在左边梯起点
|
|
ads_polar(ptLoc1, stair2.GetRotation()-PI/2, nLen1+nRailDist, ptStart);
|
|
ads_polar(XPoint(ptStart), stair2.GetRotation()+PI, nDistToSide, ptStart);
|
|
if(nRailDist > m_nStepWidth*0.5+_DIST_SNAP)
|
|
{
|
|
ptStart.z = ptLoc2.z;
|
|
}
|
|
else
|
|
{
|
|
ptStart.z = ptLoc2.z-m_nStepHeight*0.5+elev1;
|
|
}
|
|
|
|
|
|
polyRail.AppendNode(ptStart);
|
|
|
|
//右下对齐点
|
|
ads_polar(XPoint(ptStart), stair2.GetRotation(), dStairWidth + nDistToSide*2, ptStart);
|
|
if(nRailDist > m_nStepWidth*0.5+_DIST_SNAP)
|
|
{
|
|
ptStart.z = ptLoc2.z;
|
|
}
|
|
else
|
|
{
|
|
ptStart.z = ptLoc2.z+m_nStepHeight*0.5-elev1;
|
|
}
|
|
polyRail.AppendNode(ptStart);
|
|
bFlag=TRUE;
|
|
|
|
}
|
|
if(m_nStairFlag==SF_MIDDLE)
|
|
{
|
|
if(nLen2>nLen1+_DIST_SNAP && m_nAlignment!=2)
|
|
{
|
|
//扶手在左边梯起点
|
|
ads_polar(ptLoc1, stair2.GetRotation()-PI/2, nLen1+nRailDist, ptStart);
|
|
ads_polar(XPoint(ptStart), stair2.GetRotation()+PI, nDistToSide, ptStart);
|
|
if(nRailDist > m_nStepWidth*0.5+_DIST_SNAP)
|
|
{
|
|
ptStart.z=ptLoc2.z;
|
|
}
|
|
else
|
|
{
|
|
ptStart.z=ptLoc2.z-m_nStepHeight*0.5+elev1;
|
|
}
|
|
polyRail.AppendNode(ptStart);
|
|
|
|
// 左下水平段顶点
|
|
ads_polar(XPoint(ptStart), stair2.GetRotation()-PI/2.0,
|
|
(m_nAlignment==1? (nLen2-nLen1)/2.0 : (nLen2-nLen1)), ptStart);
|
|
|
|
polyRail.AppendNode(ptStart);
|
|
}
|
|
else
|
|
{
|
|
if(!bFlag)
|
|
{
|
|
//扶手在左边梯起点
|
|
ads_polar(ptLoc2, stair2.GetRotation()+PI, dStairWidth + nDistToSide, ptStart);
|
|
ads_polar(XPoint(ptStart), stair2.GetRotation()-PI/2.0, nRailDist, ptStart);
|
|
if(nRailDist > m_nStepWidth*0.5+_DIST_SNAP)
|
|
{
|
|
ptStart.z = ptLoc2.z;
|
|
}
|
|
else
|
|
{
|
|
ptStart.z = ptLoc2.z+elev1-m_nStepHeight*0.5;
|
|
}
|
|
polyRail.AppendNode(ptStart);
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//右下水平段点
|
|
if(nLen2<nLen1-_DIST_SNAP && m_nAlignment!=2)
|
|
{
|
|
double dDist=m_nAlignment==1?(nLen1-nLen2)*0.5:(nLen1-nLen2);
|
|
ads_polar(ptLoc2, stair2.GetRotation(), nDistToSide, ptStart);
|
|
|
|
if(nRailDist >= m_nRailWidth*0.5)
|
|
{
|
|
ads_polar(XPoint(ptStart), stair2.GetRotation()-PI/2.0,dDist, ptStart);
|
|
ptStart.z = ptLoc2.z + m_nStepHeight*0.5;
|
|
}
|
|
else
|
|
{
|
|
ads_polar(XPoint(ptStart), stair2.GetRotation()-PI/2.0,dDist+nRailDist-m_nRailWidth*0.5, ptStart);
|
|
ptStart.z = ptLoc2.z + m_nStepHeight*0.5-elev1;
|
|
}
|
|
polyRail.AppendNode(ptStart);
|
|
}
|
|
}
|
|
|
|
//右梯扶手下顶点
|
|
ads_polar(ptLoc2, stair2.GetRotation(), nDistToSide, ptStart);
|
|
//modify by xlc on 090402 顶层扶手画法
|
|
if(m_nStairFlag==SF_TOP)
|
|
{
|
|
if(nRailDist>=m_nRailWidth*0.5)
|
|
{
|
|
ptStart.z=ptLoc2.z+m_nStepHeight*0.5;
|
|
}
|
|
else
|
|
{
|
|
ads_polar(XPoint(ptStart), stair2.GetRotation()-PI/2.0, nRailDist-(/*(fabs(nLen2-nLen1)<_DIST_SNAP||m_nAlignment==2)?*/m_nRailWidth*0.5/*:0*/), ptStart);
|
|
ptStart.z = ptLoc2.z-elev1+m_nStepHeight*0.5;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ads_polar(XPoint(ptStart), stair2.GetRotation()-PI/2.0,nRailDist, ptStart);
|
|
if(nRailDist > m_nStepWidth*0.5+_DIST_SNAP)
|
|
{
|
|
polyRail.AppendNode(ptStart);
|
|
ads_polar(XPoint(ptStart), stair2.GetRotation()+PI/2.0,nRailDist-m_nStepWidth*0.5, ptStart);
|
|
}
|
|
else
|
|
{
|
|
ptStart.z = ptLoc2.z - elev1 + m_nStepHeight*0.5;
|
|
}
|
|
}
|
|
|
|
polyRail.AppendNode(ptStart);
|
|
|
|
//右梯扶手上顶点
|
|
ads_polar(ptLoc2, stair2.GetRotation(), nDistToSide, ptStart);
|
|
if(nRailDistMid > m_nStepWidth*0.5+_DIST_SNAP)
|
|
{
|
|
ads_polar(XPoint(ptStart), stair2.GetRotation()+PI/2.0,nLen2+m_nStepWidth*0.5, ptStart);
|
|
ptStart.z = ptLoc2.z + stair2.GetStairHeight();
|
|
polyRail.AppendNode(ptStart);
|
|
ads_polar(XPoint(ptStart), stair2.GetRotation()+PI/2.0,nRailDistMid-m_nStepWidth*0.5, ptStart);
|
|
}
|
|
else
|
|
{
|
|
ads_polar(XPoint(ptStart), stair2.GetRotation()+PI/2.0,nLen2 + nRailDistMid,ptStart);
|
|
ptStart.z = ptLoc2.z + stair2.GetStairHeight() - m_nStepHeight*0.5 + elev2;
|
|
}
|
|
polyRail.AppendNode(ptStart);
|
|
|
|
if(nLen1<nLen2-_DIST_SNAP)
|
|
{
|
|
if(m_nAlignment!=0)
|
|
{
|
|
//左梯休息台水平段顶点
|
|
ads_polar(XPoint(ptStart), stair2.GetRotation()+PI,dStairWidth+nDistToSide*2, ptStart);
|
|
if(nRailDistMid < m_nStepWidth*0.5 - _DIST_SNAP)
|
|
{
|
|
ptStart.z = ptLoc1.z + m_nStepHeight*0.5 - elev2;
|
|
}
|
|
polyRail.AppendNode(ptStart);
|
|
}
|
|
}
|
|
else if(nLen2<nLen1-_DIST_SNAP)
|
|
{
|
|
if(m_nAlignment!=0)
|
|
{
|
|
//右梯休息台水平段顶点
|
|
ads_polar(XPoint(ptStart), stair2.GetRotation()+PI/2.0,
|
|
(m_nAlignment==1? (nLen1-nLen2)/2.0 : (nLen1-nLen2)), ptStart);
|
|
if(nRailDistMid < m_nStepWidth*0.5 - _DIST_SNAP)
|
|
{
|
|
ptStart.z = ptLoc1.z - m_nStepHeight*0.5 + elev2;
|
|
}
|
|
polyRail.AppendNode(ptStart);
|
|
}
|
|
}
|
|
|
|
//左梯扶手上顶点
|
|
ads_polar(XPoint(ptLoc1), stair2.GetRotation()+PI,nDistToSide, ptStart);
|
|
if(nRailDistMid > m_nStepWidth*0.5 + _DIST_SNAP)
|
|
{
|
|
ads_polar(XPoint(ptStart), stair2.GetRotation()+PI/2.0,nRailDistMid, ptStart);
|
|
ptStart.z = ptLoc1.z;
|
|
polyRail.AppendNode(ptStart);
|
|
ads_polar(XPoint(ptStart), stair2.GetRotation()-PI/2.0,nRailDistMid-m_nStepWidth*0.5, ptStart);
|
|
}
|
|
else
|
|
{
|
|
ads_polar(XPoint(ptStart), stair2.GetRotation()+PI/2.0,nRailDistMid, ptStart);
|
|
ptStart.z = ptLoc1.z + m_nStepHeight*0.5 - elev2;
|
|
}
|
|
polyRail.AppendNode(ptStart);
|
|
|
|
//左梯扶手下顶点
|
|
ads_polar(ptLoc1, stair1.GetRotation(), nDistToSide, ptStart);
|
|
if(nRailDist > m_nStepWidth*0.5 + _DIST_SNAP)
|
|
{
|
|
ads_polar(XPoint(ptStart), stair1.GetRotation()+PI/2.0, nLen1+m_nStepWidth*0.5, ptStart);
|
|
ptStart.z = ptLoc1.z+stair1.GetStairHeight();
|
|
polyRail.AppendNode(ptStart);
|
|
ads_polar(XPoint(ptStart), stair1.GetRotation()+PI/2.0, nRailDist-m_nStepWidth*0.5, ptStart);
|
|
}
|
|
else
|
|
{
|
|
ads_polar(XPoint(ptStart), stair1.GetRotation()+PI/2.0, nLen1+nRailDist, ptStart);
|
|
ptStart.z = ptLoc1.z+stair1.GetStairHeight()-m_nStepHeight*0.5 + elev1;
|
|
}
|
|
polyRail.AppendNode(ptStart);
|
|
}
|
|
//左边起步时的内侧扶手
|
|
void TDbScissorsStair::GetRailFromLeft(TDbLineStair &stair1, //[in/out]左梯段
|
|
TDbLineStair &stair2, //[in/out]右梯段
|
|
XPoly2D &polyRail, //[in/out]内侧扶手
|
|
XPoint &ptStart //[in/out]扶手顶点
|
|
)const
|
|
{
|
|
double nDistToSide=(GetSpaceWidth()-2*GetStairWidth()<_DIST_SNAP &&m_nRailDistToSide<0)?
|
|
_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;
|
|
}
|
|
|
|
//梯段位置
|
|
XPoint ptLoc1, ptLoc2;
|
|
ptLoc1 = stair1.GetLocation();
|
|
ptLoc2 = stair2.GetLocation();
|
|
|
|
//梯段长度
|
|
double nLen1=stair1.GetStairLength(),
|
|
nLen2=stair2.GetStairLength();
|
|
|
|
double nRailDist=m_nRailDist-m_nRailWidth*0.5,
|
|
nRailDistMid=m_nRailDistMid-m_nRailWidth*0.5; //扶手有连接时回缩半个扶手宽度
|
|
//扶手伸出距离为负时产生的高差
|
|
double elev1=nRailDist/nLen1*(stair1.GetStairHeight()-m_nStepHeight),
|
|
elev2=nRailDistMid/nLen1*(stair1.GetStairHeight()-m_nStepHeight);
|
|
|
|
|
|
if(m_nStairFlag!=SF_TOP) //首层或中间层
|
|
{
|
|
BOOL bFlag=FALSE; //
|
|
if(m_nStairFlag!=SF_FIRST && nLen2<nLen1-_DIST_SNAP && m_nAlignment!=2)// 踏步不与楼板取齐
|
|
{
|
|
//扶手从右梯开始
|
|
ads_polar(ptLoc2, stair1.GetRotation()-PI/2, nLen2+nRailDist, ptStart);
|
|
ads_polar(XPoint(ptStart), stair1.GetRotation()+PI, m_nStairWidth - nDistToSide, ptStart);
|
|
if(nRailDist > m_nStepWidth*0.5+_DIST_SNAP)
|
|
{
|
|
ptStart.z = ptLoc1.z;
|
|
}
|
|
else
|
|
{
|
|
ptStart.z = ptLoc1.z-m_nStepHeight*0.5+elev1;
|
|
}
|
|
polyRail.AppendNode(ptStart);
|
|
|
|
//右梯下水平段顶点
|
|
ads_polar(XPoint(ptStart), stair1.GetRotation()-PI/2.0,
|
|
(m_nAlignment==1? (nLen1-nLen2)/2.0 : (nLen1-nLen2)), ptStart);
|
|
|
|
polyRail.AppendNode(ptStart);
|
|
bFlag=TRUE;
|
|
}
|
|
if(m_nStairFlag==SF_MIDDLE)
|
|
{
|
|
if(nLen2>nLen1+_DIST_SNAP && m_nAlignment!=2)
|
|
{
|
|
//扶手从右梯开始
|
|
ads_polar(ptLoc2, stair1.GetRotation()-PI/2, nLen2+nRailDist, ptStart);
|
|
ads_polar(XPoint(ptStart), stair1.GetRotation()+PI, m_nStairWidth - nDistToSide, ptStart);
|
|
if(nRailDist > m_nStepWidth/2+_DIST_SNAP)
|
|
{
|
|
ptStart.z = ptLoc1.z;
|
|
}
|
|
else
|
|
{
|
|
ptStart.z = ptLoc1.z-m_nStepHeight*0.5+elev1;
|
|
}
|
|
polyRail.AppendNode(ptStart);
|
|
|
|
//对齐点
|
|
ads_polar(XPoint(ptStart), stair1.GetRotation()+PI, dStairWidth + nDistToSide*2, ptStart);
|
|
if(nRailDist > m_nStepWidth/2+_DIST_SNAP)
|
|
{
|
|
ptStart.z = ptLoc1.z;
|
|
}
|
|
else
|
|
{
|
|
ptStart.z = ptLoc1.z+m_nStepHeight*0.5-elev1;
|
|
}
|
|
//ptStart.z=ptLoc1.z+m_nStepHeight*0.5;
|
|
polyRail.AppendNode(ptStart);
|
|
}
|
|
else
|
|
{
|
|
if(!bFlag)
|
|
{
|
|
//右梯起点
|
|
ads_polar(ptLoc2, stair1.GetRotation()-PI/2, nLen2+nRailDist, ptStart);
|
|
ads_polar(XPoint(ptStart), stair1.GetRotation()+PI, m_nStairWidth - nDistToSide, ptStart);
|
|
if(nRailDist > m_nStepWidth/2+_DIST_SNAP)
|
|
{
|
|
ptStart.z = ptLoc1.z;
|
|
}
|
|
else
|
|
{
|
|
ptStart.z = ptLoc1.z+elev1-m_nStepHeight*0.5;
|
|
}
|
|
polyRail.AppendNode(ptStart);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(nLen2>nLen1+_DIST_SNAP&&m_nAlignment!=2)
|
|
{
|
|
//左梯起点
|
|
ads_polar(ptLoc2, stair1.GetRotation()+PI,m_nStairWidth+dStairWidth+ nDistToSide, ptStart);
|
|
if(nRailDist >= m_nRailWidth*0.5)
|
|
{
|
|
ads_polar(XPoint(ptStart), stair1.GetRotation()-PI/2.0, nLen2, ptStart);
|
|
ptStart.z = ptLoc1.z+m_nStepHeight*0.5;
|
|
}
|
|
else
|
|
{
|
|
ads_polar(XPoint(ptStart), stair1.GetRotation()-PI/2.0, nLen2+nRailDist-m_nRailWidth*0.5, ptStart);
|
|
ptStart.z=ptLoc1.z+m_nStepHeight*0.5-elev1;
|
|
}
|
|
polyRail.AppendNode(ptStart);
|
|
}
|
|
}
|
|
|
|
|
|
//左梯下顶点
|
|
ads_polar(ptLoc1, stair1.GetRotation(), m_nStairWidth - nDistToSide, ptStart);
|
|
//modify by xlc on 090402 顶层扶手画法
|
|
if(m_nStairFlag==SF_TOP)
|
|
{
|
|
if(nRailDist>=m_nRailWidth*0.5)
|
|
{
|
|
ptStart.z=ptLoc1.z+m_nStepHeight*0.5;
|
|
}
|
|
else
|
|
{
|
|
ads_polar(XPoint(ptStart), stair1.GetRotation()-PI/2.0, nRailDist-(/*(nLen2==nLen1||m_nAlignment==2)?*/(m_nRailWidth*0.5)/*:0*/), ptStart);
|
|
ptStart.z = ptLoc1.z-elev1+m_nStepHeight*0.5;
|
|
}
|
|
}
|
|
else
|
|
|
|
{
|
|
if(nRailDist > m_nStepWidth/2 + _DIST_SNAP)
|
|
{
|
|
ads_polar(XPoint(ptStart), stair1.GetRotation()-PI/2.0, nRailDist, ptStart);
|
|
ptStart.z = ptLoc1.z;
|
|
polyRail.AppendNode(ptStart);
|
|
ads_polar(XPoint(ptStart), stair1.GetRotation()+PI/2.0, nRailDist-m_nStepWidth*0.5, ptStart);
|
|
}
|
|
else
|
|
{
|
|
ads_polar(XPoint(ptStart), stair1.GetRotation()-PI/2.0, nRailDist, ptStart);
|
|
ptStart.z = ptLoc1.z+m_nStepHeight*0.5-elev1;
|
|
}
|
|
}
|
|
|
|
polyRail.AppendNode(ptStart);
|
|
|
|
//左梯上顶点
|
|
ads_polar(ptLoc1, stair1.GetRotation(), m_nStairWidth - nDistToSide, ptStart);
|
|
if(nRailDistMid > m_nStepWidth*0.5 + _DIST_SNAP)
|
|
{
|
|
ads_polar(XPoint(ptStart), stair1.GetRotation()+PI/2.0, nLen1+m_nStepWidth*0.5, ptStart);
|
|
ptStart.z = ptLoc1.z+stair1.GetStairHeight();
|
|
polyRail.AppendNode(ptStart);
|
|
ads_polar(XPoint(ptStart), stair1.GetRotation()+PI/2.0, nRailDistMid-m_nStepWidth*0.5, ptStart);
|
|
}
|
|
else
|
|
{
|
|
ads_polar(XPoint(ptStart), stair1.GetRotation()+PI/2.0,
|
|
nLen1+nRailDistMid, ptStart);
|
|
ptStart.z = ptLoc1.z+stair1.GetStairHeight()-m_nStepHeight*0.5+elev2;
|
|
}
|
|
polyRail.AppendNode(ptStart);
|
|
|
|
if(nLen1<nLen2-_DIST_SNAP)
|
|
{
|
|
if(m_nAlignment!=0)
|
|
{
|
|
// 左梯上水平段顶点
|
|
ads_polar(XPoint(ptStart), stair1.GetRotation()+PI/2.0,
|
|
(m_nAlignment==1? (nLen2-nLen1)/2.0 : (nLen2-nLen1)), ptStart);
|
|
polyRail.AppendNode(ptStart);
|
|
}
|
|
}
|
|
|
|
//对齐点
|
|
ads_polar(ptStart, stair1.GetRotation(),dStairWidth+nDistToSide*2, ptStart);
|
|
if(nRailDistMid < m_nStepWidth*0.5 - _DIST_SNAP)
|
|
{
|
|
ptStart.z = ptLoc2.z + m_nStepHeight*0.5 - elev2;
|
|
}
|
|
polyRail.AppendNode(ptStart);
|
|
|
|
if(nLen2<nLen1-_DIST_SNAP)
|
|
{
|
|
if(m_nAlignment!=0)
|
|
{
|
|
// 右梯上水平段顶点
|
|
ads_polar(XPoint(ptStart), stair1.GetRotation()-PI/2.0,
|
|
(m_nAlignment==1? (nLen1-nLen2)/2.0 : (nLen1-nLen2)), ptStart);
|
|
polyRail.AppendNode(ptStart);
|
|
}
|
|
}
|
|
if(nRailDistMid > m_nStepWidth*0.5+_DIST_SNAP)
|
|
{
|
|
ads_polar(ptLoc2, stair2.GetRotation(), m_nStairWidth-nDistToSide, ptStart);
|
|
ads_polar(XPoint(ptStart), stair2.GetRotation()-PI/2.0, m_nStepWidth*0.5, ptStart);
|
|
ptStart.z = ptLoc2.z;
|
|
polyRail.AppendNode(ptStart);
|
|
}
|
|
|
|
// 右梯下顶点
|
|
ads_polar(ptLoc2, stair2.GetRotation(), m_nStairWidth-nDistToSide, ptStart);
|
|
if(nRailDist > m_nStepWidth*0.5+_DIST_SNAP)
|
|
{
|
|
ads_polar(XPoint(ptStart), stair1.GetRotation()-PI/2.0, nLen2+m_nStepWidth*0.5, ptStart);
|
|
ptStart.z = ptLoc2.z+stair2.GetStairHeight();
|
|
polyRail.AppendNode(ptStart);
|
|
ads_polar(XPoint(ptStart), stair1.GetRotation()-PI/2.0, nRailDist-m_nStepWidth*0.5, ptStart);
|
|
}
|
|
else
|
|
{
|
|
ads_polar(XPoint(ptStart), stair1.GetRotation()-PI/2.0, nLen2+nRailDist, ptStart);
|
|
ptStart.z = ptLoc2.z+stair2.GetStairHeight()-m_nStepHeight*0.5+elev1;
|
|
}
|
|
polyRail.AppendNode(ptStart);
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbScissorsStair::ExplodeTo(TDbLineStair &stair1, //[in/out]左下梯段
|
|
TDbLineStair &stair2, //[in/out]右下梯段
|
|
TDbLineStair &stair3, //[in/out]左上梯段
|
|
TDbLineStair &stair4, //[in/out]右上梯段
|
|
TDbSlab &slab, //[in/out]休息平台
|
|
TDbHandRail &rail, //[in/out]内侧扶手
|
|
TDbHandRail &rail2, //[in/out]内侧扶手
|
|
TDbHandRail *pRailTop, //[out]顶层扶手
|
|
TDbHandRail *pRailTop2, //[out]顶层扶手
|
|
TDbHandRail* pRailOut1, //[out]外侧扶手
|
|
TDbHandRail*pRailOut2 //[out]外侧扶手
|
|
) const
|
|
{
|
|
assertReadEnabled();
|
|
int nSectStair=GetSectStairPos();
|
|
|
|
XPoint ptUpLeft, ptUpMid, ptUpRight,
|
|
ptLowLeft, ptLowMid, ptLowRight; //休息平台板的顶点
|
|
|
|
int nStepNum1=m_nStepNum1,nStepNum2=m_nStepNum2;
|
|
if(m_nStartSide!=OFFSET_LEFT)
|
|
{
|
|
nStepNum1=m_nStepNum2;
|
|
nStepNum2=m_nStepNum1;
|
|
}
|
|
|
|
double nLen1=(nStepNum1-1)*m_nStepWidth,
|
|
nLen2=(nStepNum2-1)*m_nStepWidth;
|
|
|
|
double dLeftDist = m_nSlabSize*0.5,dRightDist = m_nSlabSize*0.5;//平台中点到两侧梯段的距离
|
|
if(fabs(nLen1-nLen2)>_DIST_SNAP && m_nAlignment != 0)
|
|
{
|
|
double nTemp=(m_nAlignment==1)? 2.0 : 1.0;
|
|
if(nLen1 > nLen2) //左梯长
|
|
{
|
|
dRightDist = m_nSlabSize*0.5+(nLen1-nLen2)/nTemp;
|
|
}
|
|
else
|
|
{
|
|
dLeftDist = m_nSlabSize*0.5+(nLen2-nLen1)/nTemp;
|
|
}
|
|
}
|
|
|
|
ads_polar(GetMidLeft2d(), m_nRotation+PI/2.0, dRightDist, ptUpLeft);
|
|
ads_polar(GetMidRight2d(), m_nRotation+PI/2.0, dLeftDist, ptUpRight);
|
|
|
|
ads_polar(GetMidLeft2d(), m_nRotation-PI/2.0, dLeftDist, ptLowLeft);
|
|
ads_polar(GetMidRight2d(), m_nRotation-PI/2.0, dRightDist, ptLowRight);
|
|
|
|
//设置梯段宽度
|
|
stair1.SetStairWidth(m_nStairWidth);
|
|
stair2.SetStairWidth(m_nStairWidth);
|
|
stair3.SetStairWidth(m_nStairWidth);
|
|
stair4.SetStairWidth(m_nStairWidth);
|
|
|
|
//设置踏步高度
|
|
stair1.SetStepHeight(m_nStepHeight);
|
|
stair2.SetStepHeight(m_nStepHeight);
|
|
stair3.SetStepHeight(m_nStepHeight);
|
|
stair4.SetStepHeight(m_nStepHeight);
|
|
|
|
//设置踏步宽度
|
|
stair1.SetStepWidth(m_nStepWidth);
|
|
stair2.SetStepWidth(m_nStepWidth);
|
|
stair3.SetStepWidth(m_nStepWidth);
|
|
stair4.SetStepWidth(m_nStepWidth);
|
|
|
|
//设置踏步数
|
|
stair1.SetStepNum(nStepNum1);
|
|
stair2.SetStepNum(nStepNum2);
|
|
stair3.SetStepNum(nStepNum1);
|
|
stair4.SetStepNum(nStepNum2);
|
|
|
|
//设置踏步旋转角度
|
|
if(m_nStartSide == OFFSET_LEFT)
|
|
{
|
|
stair1.SetRotation(m_nRotation);
|
|
stair2.SetRotation(CT_std_angle(m_nRotation+PI));
|
|
stair3.SetRotation(CT_std_angle(m_nRotation+PI));
|
|
stair4.SetRotation(m_nRotation);
|
|
}
|
|
else
|
|
{
|
|
stair1.SetRotation(CT_std_angle(m_nRotation+PI));
|
|
stair2.SetRotation(m_nRotation);
|
|
stair3.SetRotation(m_nRotation);
|
|
stair4.SetRotation(CT_std_angle(m_nRotation+PI));
|
|
}
|
|
|
|
|
|
//计算梯段位置
|
|
XPoint ptLoc1, ptLoc2, ptLoc3, ptLoc4;
|
|
if(m_nStartSide==OFFSET_LEFT) //左边上楼
|
|
{
|
|
ads_polar(ptLowLeft, m_nRotation-PI/2, nLen1, ptLoc1);
|
|
ptLoc2 = ptLowRight;
|
|
ads_polar(ptUpRight, m_nRotation+PI/2, nLen1, ptLoc3);
|
|
ptLoc4 = ptUpLeft;
|
|
ptLoc1.z = ptLoc3.z = m_ptLocation.z;
|
|
ptLoc2.z = ptLoc4.z = ptLoc1.z + nStepNum1*m_nStepHeight;
|
|
}
|
|
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, nLen2, ptLoc2);
|
|
ads_polar(ptUpRight, m_nRotation+PI, m_nStairWidth, ptLoc3);
|
|
ads_polar(ptUpLeft, m_nRotation, m_nStairWidth, ptTmp);
|
|
ads_polar(ptTmp, m_nRotation+PI/2, nLen2, ptLoc4);
|
|
ptLoc2.z = ptLoc4.z = m_ptLocation.z;
|
|
ptLoc1.z = ptLoc3.z = ptLoc2.z + nStepNum2*m_nStepHeight;
|
|
}
|
|
//设置梯段位置
|
|
stair1.SetLocation(ptLoc1);
|
|
stair2.SetLocation(ptLoc2);
|
|
stair3.SetLocation(ptLoc3);
|
|
stair4.SetLocation(ptLoc4);
|
|
|
|
//设置梯段标记
|
|
stair1.Set3DFlag(m_nStairFlag==SF_TOP? 0 : SF_HAS3D);
|
|
stair2.Set3DFlag(m_nStairFlag==SF_TOP? 0 : SF_HAS3D);
|
|
stair3.Set3DFlag(m_nStairFlag==SF_TOP? 0 : SF_HAS3D);
|
|
stair4.Set3DFlag(m_nStairFlag==SF_TOP? 0 : SF_HAS3D);
|
|
|
|
stair1.Set2DFlag(SF_NOSECT);
|
|
stair2.Set2DFlag(SF_NOSECT);
|
|
stair3.Set2DFlag(SF_NOSECT);
|
|
stair4.Set2DFlag(SF_NOSECT);
|
|
if(m_nStairFlag==SF_FIRST) //首层
|
|
{
|
|
if(nSectStair==0) //左梯剖断
|
|
{
|
|
stair1.Set2DFlag(SF_1SECT);
|
|
stair3.Set2DFlag(SF_1SECT);
|
|
}
|
|
else if(nSectStair==1) //边梯剖断
|
|
{
|
|
stair2.Set2DFlag(SF_1SECT);
|
|
stair4.Set2DFlag(SF_1SECT);
|
|
}
|
|
}
|
|
else if(m_nStairFlag==SF_MIDDLE) //中间层
|
|
{
|
|
if(nSectStair==0) //左梯剖断
|
|
{
|
|
stair1.Set2DFlag(SF_2SECT);
|
|
stair3.Set2DFlag(SF_2SECT);
|
|
}
|
|
else if(nSectStair==1) //右梯剖断
|
|
{
|
|
stair2.Set2DFlag(SF_2SECT);
|
|
stair4.Set2DFlag(SF_2SECT);
|
|
}
|
|
}
|
|
|
|
// 设置边梁属性
|
|
/*for(int nSide=0; nSide<2; nSide++)
|
|
{
|
|
stair1.SetSideBeam(nSide, HasSideBeam(nSide));
|
|
stair2.SetSideBeam(nSide, HasSideBeam(nSide));
|
|
stair3.SetSideBeam(nSide, HasSideBeam(nSide));
|
|
stair4.SetSideBeam(nSide, HasSideBeam(nSide));
|
|
}*/
|
|
if(m_nStartSide==OFFSET_LEFT)
|
|
{
|
|
stair1.SetSideBeam(0, IsOutSideBeam());
|
|
stair2.SetSideBeam(0, IsOutSideBeam());
|
|
stair3.SetSideBeam(0, IsOutSideBeam());
|
|
stair4.SetSideBeam(0, IsOutSideBeam());
|
|
stair1.SetSideBeam(1, IsInSideBeam());
|
|
stair2.SetSideBeam(1, IsInSideBeam());
|
|
stair3.SetSideBeam(1, IsInSideBeam());
|
|
stair4.SetSideBeam(1, IsInSideBeam());
|
|
}
|
|
else
|
|
{
|
|
stair1.SetSideBeam(1, IsOutSideBeam());
|
|
stair2.SetSideBeam(1, IsOutSideBeam());
|
|
stair3.SetSideBeam(1, IsOutSideBeam());
|
|
stair4.SetSideBeam(1, IsOutSideBeam());
|
|
stair1.SetSideBeam(0, IsInSideBeam());
|
|
stair2.SetSideBeam(0, IsInSideBeam());
|
|
stair3.SetSideBeam(0, IsInSideBeam());
|
|
stair4.SetSideBeam(0, IsInSideBeam());
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////
|
|
//扶手, 考虑了详图画法
|
|
double nDistToSide=(GetSpaceWidth()-2*GetStairWidth()<_DIST_SNAP &&m_nRailDistToSide<0)?
|
|
_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; //内侧扶手
|
|
XPoint ptStart,ptStart2;
|
|
if(m_nStartSide==OFFSET_LEFT) //左边上楼
|
|
{
|
|
GetRailFromLeft(stair1,stair2,polyRail,ptStart);
|
|
GetRailFromLeft(stair3,stair4,polyRail2,ptStart2);
|
|
}
|
|
else //右边上楼
|
|
{
|
|
GetRailFromRight(stair1,stair2,polyRail,ptStart);
|
|
GetRailFromRight(stair3,stair4,polyRail2,ptStart2);
|
|
}
|
|
|
|
polyRail.SetFlag(0);
|
|
polyRail2.SetFlag(0);
|
|
if(m_nStairFlag==SF_TOP) //顶层
|
|
{
|
|
//处理扶手端点
|
|
XPoint ptA, ptB;
|
|
ptA = *polyRail.Head();
|
|
ads_polar(ptA, m_nRotation+PI/2, m_nRailWidth/2, ptB);
|
|
// *polyRail.Head() = ptB;
|
|
ptA = *polyRail2.Head();
|
|
ads_polar(ptA, m_nRotation-PI/2, m_nRailWidth/2, ptB);
|
|
// *polyRail2.Head() = ptB;
|
|
|
|
|
|
//顶端扶手
|
|
XPoly2D polyTopRail(0),polyTopRail2(0);
|
|
polyTopRail.AppendNode(XPoint(ptStart.x, ptStart.y, GetElevation())); //顶端扶手起点
|
|
polyTopRail2.AppendNode(XPoint(ptStart2.x, ptStart2.y, GetElevation()));//顶端扶手起点
|
|
if(nLen2<nLen1-_DIST_SNAP && m_nAlignment!=2)
|
|
{
|
|
if(m_nStartSide==OFFSET_LEFT)
|
|
{
|
|
double nTemp=(m_nAlignment==1)? 2.0 : 1.0;
|
|
double elev=ptStart.z;
|
|
ads_polar(ptLoc1, m_nRotation, m_nStairWidth+dStairWidth+nDistToSide, ptStart);
|
|
ads_polar(ptStart, m_nRotation-PI/2.0, m_nRailDist-m_nRailWidth*0.5, ptStart); //扶手下水平段点
|
|
|
|
ptStart.z = elev;
|
|
polyRail.AppendNode(ptStart);
|
|
polyTopRail.AppendNode(XPoint(ptStart.x, ptStart.y, GetElevation()));
|
|
|
|
//顶端扶手左侧对齐点
|
|
ads_polar(ptStart, m_nRotation+PI, m_nStairWidth+dStairWidth+nDistToSide, ptStart);
|
|
|
|
ads_polar(ptLoc3, m_nRotation+PI, m_nStairWidth+dStairWidth+nDistToSide, ptStart2);
|
|
ads_polar(ptStart2, m_nRotation+PI/2.0, m_nRailDist-m_nRailWidth*0.5, ptStart2); //扶手上水平段点
|
|
|
|
ptStart2.z = elev;
|
|
polyRail2.AppendNode(ptStart2);
|
|
polyTopRail2.AppendNode(XPoint(ptStart2.x, ptStart2.y, GetElevation()));
|
|
|
|
//顶端扶手左侧对齐点
|
|
ads_polar(ptStart2, m_nRotation, m_nStairWidth+dStairWidth+nDistToSide, ptStart2);
|
|
}
|
|
else
|
|
{
|
|
//顶端扶手终点
|
|
ads_polar(ptStart, m_nRotation, m_nStairWidth+dStairWidth+nDistToSide, ptStart);
|
|
ads_polar(ptStart2, m_nRotation+PI, m_nStairWidth+dStairWidth+nDistToSide, ptStart2);
|
|
}
|
|
|
|
polyRail.AppendNode(ptStart);
|
|
polyRail2.AppendNode(ptStart2);
|
|
polyTopRail.AppendNode(XPoint(ptStart.x, ptStart.y, GetElevation()));
|
|
polyTopRail2.AppendNode(XPoint(ptStart2.x, ptStart2.y, GetElevation()));
|
|
}
|
|
else
|
|
{
|
|
if(m_nStartSide==OFFSET_LEFT)
|
|
{
|
|
//顶端扶手终点
|
|
ads_polar(ptStart, m_nRotation+PI, m_nStairWidth+dStairWidth+nDistToSide, ptStart);
|
|
ads_polar(ptStart2, m_nRotation, m_nStairWidth+dStairWidth+nDistToSide, ptStart2);
|
|
|
|
|
|
polyRail.AppendNode(ptStart);
|
|
polyTopRail.AppendNode(XPoint(ptStart.x, ptStart.y, GetElevation()));
|
|
polyRail2.AppendNode(ptStart2);
|
|
polyTopRail2.AppendNode(XPoint(ptStart2.x, ptStart2.y, GetElevation()));
|
|
}
|
|
else
|
|
{
|
|
if(nLen2>nLen1+_DIST_SNAP && m_nAlignment!=2)
|
|
{
|
|
double nTemp=(m_nAlignment==1)? 2.0 : 1.0;
|
|
|
|
XPoint ptTmp=ptStart;
|
|
double elev=ptStart.z;
|
|
ads_polar(ptLoc2, m_nRotation+PI, dStairWidth+nDistToSide, ptStart);
|
|
ads_polar(ptStart, m_nRotation-PI/2.0, m_nRailDist-m_nRailWidth*0.5, ptStart);//扶手左侧下水平段点
|
|
|
|
ptStart.z = elev;
|
|
polyRail.AppendNode(ptStart);
|
|
polyTopRail.AppendNode(XPoint(ptStart.x, ptStart.y, GetElevation()));
|
|
|
|
//扶手右侧下水平段点
|
|
ads_polar(ptStart, m_nRotation, m_nStairWidth+dStairWidth+nDistToSide, ptStart);
|
|
|
|
polyRail.AppendNode(ptStart);
|
|
polyTopRail.AppendNode(XPoint(ptStart.x, ptStart.y, GetElevation()));
|
|
|
|
ads_polar(ptLoc4, m_nRotation, dStairWidth+nDistToSide, ptStart2);
|
|
ads_polar(ptStart2, m_nRotation+PI/2.0, m_nRailDist-m_nRailWidth*0.5, ptStart2);//扶手右侧上水平段点
|
|
|
|
ptStart2.z = elev;
|
|
polyRail2.AppendNode(ptStart2);
|
|
polyTopRail2.AppendNode(XPoint(ptStart2.x, ptStart2.y, GetElevation()));
|
|
|
|
//扶手右侧下水平段点
|
|
ads_polar(ptStart2, m_nRotation+PI, m_nStairWidth+dStairWidth+nDistToSide, ptStart2);
|
|
|
|
polyRail2.AppendNode(ptStart2);
|
|
polyTopRail2.AppendNode(XPoint(ptStart2.x, ptStart2.y, GetElevation()));
|
|
|
|
}
|
|
else
|
|
{
|
|
//顶端扶手终点
|
|
ads_polar(ptStart, m_nRotation, m_nStairWidth+dStairWidth+nDistToSide, ptStart);
|
|
polyTopRail.AppendNode(XPoint(ptStart.x, ptStart.y, GetElevation()));
|
|
ads_polar(ptStart2, m_nRotation+PI, m_nStairWidth+dStairWidth+nDistToSide, ptStart2);
|
|
polyTopRail2.AppendNode(XPoint(ptStart2.x, ptStart2.y, GetElevation()));
|
|
|
|
polyRail.AppendNode(ptStart);
|
|
polyRail2.AppendNode(ptStart2);
|
|
}
|
|
}
|
|
}
|
|
|
|
polyRail.SetFlag(0);
|
|
rail.SetHas2D(TRUE);
|
|
rail.SetHas3D(FALSE);
|
|
if(pRailTop)
|
|
{
|
|
pRailTop->SetPathPoly(polyTopRail,GetNormal().AsAcGeVector3d());
|
|
pRailTop->SetWidth(m_nRailWidth);
|
|
pRailTop->SetHeight(m_nRailHeight);
|
|
pRailTop->SetStyle(TDbHandRail::RS_RAIL1);
|
|
}
|
|
|
|
rail2.SetHas2D(TRUE);
|
|
rail2.SetHas3D(FALSE);
|
|
if(pRailTop2)
|
|
{
|
|
pRailTop2->SetPathPoly(polyTopRail2,GetNormal().AsAcGeVector3d());
|
|
pRailTop2->SetWidth(m_nRailWidth);
|
|
pRailTop2->SetHeight(m_nRailHeight);
|
|
pRailTop2->SetStyle(TDbHandRail::RS_RAIL1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
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);
|
|
|
|
if(pRailOut1!=0) //左边梯外侧扶手
|
|
{
|
|
XPoly2D poly;
|
|
if(m_nStartSide==OFFSET_LEFT)
|
|
{
|
|
GetRailPoly(stair1,stair4,poly);
|
|
if(m_nStairFlag == SF_TOP)
|
|
{
|
|
XPoint ptA, ptB;
|
|
ptA = *poly.Head();
|
|
ads_polar(ptA, m_nRotation+PI/2, m_nRailWidth/2, ptB);
|
|
// *poly.Head() = ptB;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
GetRailPoly(stair4,stair1,poly);
|
|
if(m_nStairFlag == SF_TOP)
|
|
{
|
|
XPoint ptA, ptB;
|
|
ptA = *poly.Head();
|
|
ads_polar(ptA, m_nRotation-PI/2, m_nRailWidth/2, ptB);
|
|
// *poly.Head() = ptB;
|
|
}
|
|
}
|
|
|
|
pRailOut1->SetPathPoly(poly,GetNormal().AsAcGeVector3d());
|
|
pRailOut1->SetWidth(m_nRailWidth);
|
|
pRailOut1->SetHeight(m_nRailHeight);
|
|
pRailOut1->SetStyle(TDbHandRail::RS_RAIL1);
|
|
}
|
|
if(pRailOut2!=0) //右边梯外侧扶手
|
|
{
|
|
XPoly2D poly;
|
|
if(m_nStartSide==OFFSET_LEFT)
|
|
{
|
|
GetRailPoly(stair3,stair2,poly);
|
|
if(m_nStairFlag == SF_TOP)
|
|
{
|
|
XPoint ptA, ptB;
|
|
ptA = *poly.Head();
|
|
ads_polar(ptA, m_nRotation-PI/2, m_nRailWidth/2, ptB);
|
|
// *poly.Head() = ptB;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
GetRailPoly(stair2,stair3,poly);
|
|
if(m_nStairFlag == SF_TOP)
|
|
{
|
|
XPoint ptA, ptB;
|
|
ptA = *poly.Head();
|
|
ads_polar(ptA, m_nRotation+PI/2, m_nRailWidth/2, ptB);
|
|
// *poly.Head() = ptB;
|
|
}
|
|
}
|
|
pRailOut2->SetPathPoly(poly,GetNormal().AsAcGeVector3d());
|
|
pRailOut2->SetWidth(m_nRailWidth);
|
|
pRailOut2->SetHeight(m_nRailHeight);
|
|
pRailOut2->SetStyle(TDbHandRail::RS_RAIL1);
|
|
}
|
|
|
|
//休息平台
|
|
if(m_nSlabSize>_DIST_SNAP)
|
|
{
|
|
XPoly2D polySlab(1);
|
|
polySlab.AppendNode(ptLowRight);
|
|
polySlab.AppendNode(ptUpRight);
|
|
if(fabs(nLen1-nLen2)>_DIST_SNAP && m_nAlignment!=0)
|
|
{
|
|
XPoint ptTemp1, ptTemp2;
|
|
if(nLen1 > nLen2-_DIST_SNAP)
|
|
{
|
|
ads_polar(ptUpRight, m_nRotation+PI, m_nStairWidth+dStairWidth, ptTemp1);
|
|
ads_polar(ptUpLeft, m_nRotation, m_nStairWidth, ptTemp2);
|
|
}
|
|
else
|
|
{
|
|
ads_polar(ptUpRight, m_nRotation+PI, m_nStairWidth, ptTemp1);
|
|
ads_polar(ptUpLeft, m_nRotation, m_nStairWidth+dStairWidth, ptTemp2);
|
|
}
|
|
|
|
polySlab.AppendNode(ptTemp1);
|
|
polySlab.AppendNode(ptTemp2);
|
|
}
|
|
|
|
polySlab.AppendNode(ptUpLeft);
|
|
XPoint ptMid;
|
|
Midpoint(ptUpLeft,ptLowLeft,ptMid);
|
|
polySlab.AppendNode(ptMid);
|
|
polySlab.AppendNode(ptLowLeft);
|
|
if(fabs(nLen1-nLen2)>_DIST_SNAP && m_nAlignment!=0)
|
|
{
|
|
XPoint ptTemp1, ptTemp2;
|
|
if(nLen1 > nLen2-_DIST_SNAP)
|
|
{
|
|
ads_polar(ptLowLeft, m_nRotation, m_nStairWidth+dStairWidth, ptTemp1);
|
|
ads_polar(ptLowRight, m_nRotation+PI, m_nStairWidth, ptTemp2);
|
|
}
|
|
else
|
|
{
|
|
ads_polar(ptLowLeft, m_nRotation, m_nStairWidth, ptTemp1);
|
|
ads_polar(ptLowRight, m_nRotation+PI, m_nStairWidth+dStairWidth, ptTemp2);
|
|
}
|
|
|
|
polySlab.AppendNode(ptTemp1);
|
|
polySlab.AppendNode(ptTemp2);
|
|
}
|
|
|
|
if(polySlab.PathArea()>0)
|
|
polySlab.Reverse();
|
|
slab.SetOutline(polySlab);
|
|
if(m_nStartSide==OFFSET_LEFT)
|
|
slab.SetElevation(ptLoc2.z);
|
|
else
|
|
slab.SetElevation(ptLoc1.z);
|
|
|
|
slab.SetThickness(-m_nSlabThick);
|
|
}
|
|
|
|
stair1.setPropertiesFrom(this);
|
|
stair2.setPropertiesFrom(this);
|
|
stair3.setPropertiesFrom(this);
|
|
stair4.setPropertiesFrom(this);
|
|
|
|
stair1.SetBeamHeight(GetBeamHeight());
|
|
stair2.SetBeamHeight(GetBeamHeight());
|
|
stair3.SetBeamHeight(GetBeamHeight());
|
|
stair4.SetBeamHeight(GetBeamHeight());
|
|
|
|
stair1.SetBeamThick(GetBeamThick());
|
|
stair2.SetBeamThick(GetBeamThick());
|
|
stair3.SetBeamThick(GetBeamThick());
|
|
stair4.SetBeamThick(GetBeamThick());
|
|
|
|
slab.setPropertiesFrom(this);
|
|
rail.setPropertiesFrom(this);
|
|
rail2.setPropertiesFrom(this);
|
|
|
|
if(pRailTop!=NULL)
|
|
pRailTop->setPropertiesFrom(this);
|
|
if(pRailTop2!=NULL)
|
|
pRailTop2->setPropertiesFrom(this);
|
|
if(pRailOut1!=NULL)
|
|
pRailOut1->setPropertiesFrom(this);
|
|
if(pRailOut2!=NULL)
|
|
pRailOut2->setPropertiesFrom(this);
|
|
if(m_idLayerStep3d.isValid())
|
|
{
|
|
slab.setLayer(m_idLayerStep3d);
|
|
stair1.SetLayerStep3d(m_idLayerStep3d);
|
|
stair2.SetLayerStep3d(m_idLayerStep3d);
|
|
stair3.SetLayerStep3d(m_idLayerStep3d);
|
|
stair4.SetLayerStep3d(m_idLayerStep3d);
|
|
}
|
|
if(m_idLayerBeam3d.isValid())
|
|
{
|
|
stair1.SetLayerBeam3d(m_idLayerBeam3d);
|
|
stair2.SetLayerBeam3d(m_idLayerBeam3d);
|
|
stair3.SetLayerBeam3d(m_idLayerBeam3d);
|
|
stair4.SetLayerBeam3d(m_idLayerBeam3d);
|
|
}
|
|
if(m_idLayerHand3d.isValid())
|
|
{
|
|
rail.setLayer(m_idLayerHand3d);
|
|
rail2.setLayer(m_idLayerHand3d);
|
|
if(pRailTop!=NULL)
|
|
pRailTop->setLayer(m_idLayerHand3d);
|
|
if(pRailTop2!=NULL)
|
|
pRailTop2->setLayer(m_idLayerHand3d);
|
|
if(pRailOut1!=NULL)
|
|
pRailOut1->setLayer(m_idLayerHand3d);
|
|
if(pRailOut2!=NULL)
|
|
pRailOut2->setLayer(m_idLayerHand3d);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
void TDbScissorsStair::GetRailPoly(TDbLineStair &stair1,TDbLineStair &stair2,XPoly2D &poly)const
|
|
{
|
|
double nDistToSide=(GetSpaceWidth()-2*GetStairWidth()<_DIST_SNAP*2 &&m_nRailDistToSide<0)?
|
|
_AS_SYS_UNIT(0) : m_nRailDistToSide;
|
|
nDistToSide += m_nRailWidth/2;
|
|
|
|
double nDist=m_nStartSide==OFFSET_LEFT?nDistToSide:-nDistToSide;
|
|
XLine line1=stair1.GetSideCurve2d(m_nStartSide==OFFSET_LEFT?0:1).Offset(nDist,0);
|
|
XLine line2=stair2.GetSideCurve2d(m_nStartSide==OFFSET_LEFT?0:1).Offset(nDist,0);
|
|
|
|
XPoint ptTemp;
|
|
{
|
|
double nRailDist=m_nRailDist;//顶层扶手起点的处理
|
|
if(m_nStairFlag==SF_TOP&&m_nRailDistToSide>=-m_nRailWidth)
|
|
{
|
|
if(m_nRailDist>=m_nRailWidth)
|
|
{
|
|
nRailDist=0;
|
|
}
|
|
else if(m_nRailDist>=0)
|
|
{
|
|
double width=0;//外侧扶手起点回缩距离
|
|
int n1=stair1.GetStepNum(),n2=stair2.GetStepNum();
|
|
if(m_nAlignment==2||stair1.GetStepNum()==stair2.GetStepNum())
|
|
{
|
|
nRailDist=m_nRailDist-m_nRailWidth;
|
|
}
|
|
else if((stair1.GetStepNum()<stair2.GetStepNum()))
|
|
{
|
|
nRailDist=0;
|
|
}
|
|
else if(stair1.GetStepNum()>stair2.GetStepNum())
|
|
{
|
|
nRailDist=m_nRailDist-m_nRailWidth;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
double width=0;//外侧扶手起点回缩距离
|
|
if(m_nAlignment==2||stair1.GetStepNum()==stair2.GetStepNum())
|
|
{
|
|
width=m_nRailWidth;
|
|
}
|
|
else if(stair1.GetStepNum()>stair2.GetStepNum())
|
|
{
|
|
width=m_nRailWidth;
|
|
}
|
|
nRailDist=m_nRailDist-width;
|
|
}
|
|
}
|
|
if(nRailDist > m_nStepWidth*0.5 + _DIST_SNAP)
|
|
{
|
|
ads_polar(XPoint(line1.StartPoint()),stair1.GetRotation()-PI/2,nRailDist,ptTemp);
|
|
ptTemp.z=GetElevation();
|
|
poly.AppendNode(ptTemp); //扶手伸出点
|
|
ads_polar(XPoint(line1.StartPoint()),stair1.GetRotation()-PI/2,m_nStepWidth*0.5,ptTemp);
|
|
ptTemp.z=GetElevation();
|
|
poly.AppendNode(ptTemp); //扶手拐点
|
|
}
|
|
else
|
|
{
|
|
ads_polar(XPoint(line1.StartPoint()),stair1.GetRotation()-PI/2,nRailDist,ptTemp);
|
|
double elev=0,length=0;
|
|
length=stair1.GetStairLength();
|
|
elev=(nRailDist/length)*(stair1.GetStairHeight()-m_nStepHeight);
|
|
ptTemp.z =GetElevation()+m_nStepHeight*0.5-elev;
|
|
poly.AppendNode(ptTemp); //扶手缩回点
|
|
}
|
|
|
|
//休息台段扶手
|
|
{
|
|
ads_polar(XPoint(line1.EndPoint()),stair1.GetRotation()+PI/2,m_nStepWidth*0.5,ptTemp);
|
|
ptTemp.z = GetElevation()+stair1.GetStairHeight();
|
|
poly.AppendNode(ptTemp); //伸出点
|
|
|
|
ads_polar(XPoint(line2.StartPoint()),stair2.GetRotation()-PI/2,m_nStepWidth*0.5,ptTemp);
|
|
ptTemp.z = GetElevation()+stair1.GetStairHeight();
|
|
poly.AppendNode(ptTemp); //伸出点
|
|
}
|
|
|
|
if(nRailDist > m_nStepWidth*0.5 + _DIST_SNAP)
|
|
{
|
|
ads_polar(XPoint(line2.EndPoint()),stair2.GetRotation()+PI/2,m_nStepWidth*0.5,ptTemp);
|
|
ptTemp.z=GetElevation()+GetStairHeight();
|
|
poly.AppendNode(ptTemp); //扶手拐点
|
|
ads_polar(ptTemp,stair2.GetRotation()+PI/2,nRailDist-m_nStepWidth*0.5,ptTemp);
|
|
poly.AppendNode(ptTemp); //扶手伸出点
|
|
}
|
|
else
|
|
{
|
|
ads_polar(XPoint(line2.EndPoint()),stair2.GetRotation()+PI/2,nRailDist,ptTemp);
|
|
double elev=0,length=0;
|
|
length=stair2.GetStairLength();
|
|
elev=(nRailDist/length)*(stair2.GetStairHeight()-m_nStepHeight);
|
|
ptTemp.z =GetElevation()+GetStairHeight()-m_nStepHeight*0.5+elev;
|
|
poly.AppendNode(ptTemp); //扶手缩回点
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void TDbScissorsStair::GetDefaultArrow(TDbLineStair &stair1,TDbLineStair &stair2,TDbLineStair &stair3,TDbLineStair &stair4,
|
|
TDbSymbArrow*pArrowUp1,TDbSymbArrow*pArrowUp2,
|
|
TDbSymbArrow*pArrowDown1,TDbSymbArrow*pArrowDown2)const
|
|
{
|
|
assertReadEnabled();
|
|
int nSectStair=GetSectStairPos();
|
|
if(m_nStairFlag != SF_TOP && nSectStair == -1)//剖断位置不正确
|
|
return;
|
|
|
|
int nSectStepNum=m_nSectStepNum; //剖断步数
|
|
if(nSectStepNum < 0) //负数调整为正的
|
|
{
|
|
nSectStepNum=m_nSectStepNum+m_nStepNum1+m_nStepNum2+1;
|
|
}
|
|
|
|
int nStepNum1=m_nStepNum1,nStepNum2=m_nStepNum2;
|
|
if(m_nStartSide!=OFFSET_LEFT)
|
|
{
|
|
nStepNum1=m_nStepNum2;
|
|
nStepNum2=m_nStepNum1;
|
|
}
|
|
if(nSectStepNum==m_nStepNum1
|
|
||nSectStepNum==m_nStepNum1+m_nStepNum2)
|
|
{
|
|
nSectStepNum--;
|
|
}
|
|
|
|
XPoint pt1,pt2,pt3,pt4,pt5,pt6,pt7,pt8,pt9,pt10,pt11,pt12,pt13,pt14,pt;
|
|
/*----------点相对位置示意----------------------
|
|
*pt11 | *pt12
|
|
| |
|
|
| |
|
|
*pt10 | *pt13
|
|
*pt9 | *pt14
|
|
| |
|
|
| |
|
|
--------------------------
|
|
*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*0.5,pt1);
|
|
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,stair2.GetStairLength()+m_nStepWidth*0.5,pt8);
|
|
ads_polar(pt,stair2.GetRotation()+PI/2,(m_nStepWidth*(nSectStepNum-nStepNum1)),pt7);
|
|
ads_polar(pt,stair2.GetRotation()+PI/2,(m_nStepWidth*(nSectStepNum-nStepNum1-1)),pt6);
|
|
|
|
ads_polar(stair3.GetLocation(),stair3.GetRotation(),stair3.GetStairWidth()*0.5,pt);
|
|
ads_polar(pt,stair3.GetRotation()-PI/2,m_nStepWidth*0.5,pt12);
|
|
ads_polar(pt,stair3.GetRotation()+PI/2,(m_nStepWidth*(nSectStepNum-1)),pt13);
|
|
ads_polar(pt,stair3.GetRotation()+PI/2,(m_nStepWidth*nSectStepNum),pt14);
|
|
|
|
ads_polar(stair4.GetLocation(),stair4.GetRotation(),stair4.GetStairWidth()/2,pt);
|
|
ads_polar(pt,stair4.GetRotation()+PI/2,stair4.GetStairLength()+m_nStepWidth*0.5,pt11);
|
|
ads_polar(pt,stair4.GetRotation()+PI/2,(m_nStepWidth*(nSectStepNum-nStepNum1)),pt10);
|
|
ads_polar(pt,stair4.GetRotation()+PI/2,(m_nStepWidth*(nSectStepNum-nStepNum1-1)),pt9);
|
|
}
|
|
else //右边起步
|
|
{
|
|
ads_polar(pt,stair1.GetRotation()+PI/2,(stair1.GetStairLength()+m_nStepWidth*0.5),pt1);
|
|
ads_polar(pt,stair1.GetRotation()+PI/2,(m_nStepWidth*(nSectStepNum-nStepNum2)),pt2);
|
|
ads_polar(pt,stair1.GetRotation()+PI/2,(m_nStepWidth*(nSectStepNum-nStepNum2-1)),pt3);
|
|
|
|
ads_polar(stair2.GetLocation(),stair2.GetRotation(),stair2.GetStairWidth()*0.5,pt);
|
|
ads_polar(pt,stair2.GetRotation()-PI/2,m_nStepWidth/2,pt8);
|
|
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(stair3.GetLocation(),stair3.GetRotation(),stair3.GetStairWidth()*0.5,pt);
|
|
ads_polar(pt,stair3.GetRotation()+PI/2,(stair3.GetStairLength()+m_nStepWidth*0.5),pt12);
|
|
ads_polar(pt,stair3.GetRotation()+PI/2,(m_nStepWidth*(nSectStepNum-nStepNum2)),pt13);
|
|
ads_polar(pt,stair3.GetRotation()+PI/2,(m_nStepWidth*(nSectStepNum-nStepNum2-1)),pt14);
|
|
|
|
ads_polar(stair4.GetLocation(),stair4.GetRotation(),stair4.GetStairWidth()*0.5,pt);
|
|
ads_polar(pt,stair4.GetRotation()-PI/2,m_nStepWidth/2,pt11);
|
|
ads_polar(pt,stair4.GetRotation()+PI/2,(m_nStepWidth*(nSectStepNum-1)),pt10);
|
|
ads_polar(pt,stair4.GetRotation()+PI/2,(m_nStepWidth*nSectStepNum),pt9);
|
|
}
|
|
|
|
ads_polar(GetMidLeft2d(),GetRotation(),GetStairWidth()*0.5,pt4);
|
|
ads_polar(GetMidLeft2d(),GetRotation(),GetSpaceWidth()-GetStairWidth()*0.5,pt5);
|
|
|
|
if(m_nStairFlag==SF_TOP) //顶层
|
|
{
|
|
XPoly2D poly1;
|
|
XPoly2D poly2;
|
|
if(m_nStartSide==OFFSET_LEFT) //左梯起跑
|
|
{
|
|
poly1.AppendNode(pt8);
|
|
poly1.AppendNode(pt5);
|
|
poly1.AppendNode(pt4);
|
|
ads_polar(pt1,m_nRotation+PI*0.5,m_nStepWidth,pt1);
|
|
poly1.AppendNode(pt1);
|
|
|
|
poly2.AppendNode(pt11);
|
|
poly2.AppendNode(pt4);
|
|
poly2.AppendNode(pt5);
|
|
ads_polar(pt12,m_nRotation-PI*0.5,m_nStepWidth,pt12);
|
|
poly2.AppendNode(pt12);
|
|
}
|
|
else //右梯起跑
|
|
{
|
|
poly1.AppendNode(pt1);
|
|
poly1.AppendNode(pt4);
|
|
poly1.AppendNode(pt5);
|
|
ads_polar(pt8,m_nRotation+PI*0.5,m_nStepWidth,pt8);
|
|
poly1.AppendNode(pt8);
|
|
|
|
poly2.AppendNode(pt12);
|
|
poly2.AppendNode(pt5);
|
|
poly2.AppendNode(pt4);
|
|
ads_polar(pt11,m_nRotation-PI*0.5,m_nStepWidth,pt11);
|
|
poly2.AppendNode(pt11);
|
|
}
|
|
poly1.SetElevation(GetElevation());
|
|
poly2.SetElevation(GetElevation());
|
|
pArrowDown1->SetPoly2D(poly1);
|
|
pArrowDown2->SetPoly2D(poly2);
|
|
}
|
|
else //首层和中间层
|
|
{
|
|
XPoly2D poly,poly2;
|
|
if(m_nStartSide==OFFSET_LEFT) //左边起跑
|
|
{
|
|
if(nSectStair==0) //左梯剖断
|
|
{
|
|
poly.AppendNode(pt1);
|
|
poly.AppendNode(pt2);
|
|
|
|
poly2.AppendNode(pt12);
|
|
poly2.AppendNode(pt13);
|
|
|
|
if(m_nStairFlag==SF_MIDDLE) //中间层
|
|
{
|
|
XPoly2D poly3,poly4;
|
|
poly3.AppendNode(pt8);
|
|
poly3.AppendNode(pt5);
|
|
poly3.AppendNode(pt4);
|
|
poly3.AppendNode(pt3);
|
|
|
|
poly4.AppendNode(pt11);
|
|
poly4.AppendNode(pt4);
|
|
poly4.AppendNode(pt5);
|
|
poly4.AppendNode(pt14);
|
|
|
|
poly3.SetElevation(GetElevation());
|
|
poly4.SetElevation(GetElevation());
|
|
pArrowDown1->SetPoly2D(poly3);
|
|
pArrowDown2->SetPoly2D(poly4);
|
|
}
|
|
}
|
|
else if(nSectStair==1) //右梯剖断
|
|
{
|
|
poly.AppendNode(pt1);
|
|
poly.AppendNode(pt4);
|
|
poly.AppendNode(pt5);
|
|
poly.AppendNode(pt6);
|
|
|
|
poly2.AppendNode(pt12);
|
|
poly2.AppendNode(pt5);
|
|
poly2.AppendNode(pt4);
|
|
poly2.AppendNode(pt9);
|
|
|
|
if(m_nStairFlag==SF_MIDDLE) //中间层
|
|
{
|
|
XPoly2D poly3,poly4;
|
|
poly3.AppendNode(pt8);
|
|
poly3.AppendNode(pt7);
|
|
|
|
poly4.AppendNode(pt11);
|
|
poly4.AppendNode(pt10);
|
|
|
|
poly3.SetElevation(GetElevation());
|
|
poly4.SetElevation(GetElevation());
|
|
pArrowDown1->SetPoly2D(poly3);
|
|
pArrowDown2->SetPoly2D(poly4);
|
|
}
|
|
}
|
|
}
|
|
else //右梯起跑
|
|
{
|
|
if(nSectStair==0) //左梯剖断
|
|
{
|
|
poly.AppendNode(pt8);
|
|
poly.AppendNode(pt5);
|
|
poly.AppendNode(pt4);
|
|
poly.AppendNode(pt3);
|
|
|
|
poly2.AppendNode(pt11);
|
|
poly2.AppendNode(pt4);
|
|
poly2.AppendNode(pt5);
|
|
poly2.AppendNode(pt14);
|
|
|
|
if(m_nStairFlag==SF_MIDDLE) //中间层
|
|
{
|
|
XPoly2D poly3,poly4;
|
|
poly3.AppendNode(pt1);
|
|
poly3.AppendNode(pt2);
|
|
|
|
poly4.AppendNode(pt12);
|
|
poly4.AppendNode(pt13);
|
|
poly3.SetElevation(GetElevation());
|
|
poly4.SetElevation(GetElevation());
|
|
pArrowDown1->SetPoly2D(poly3);
|
|
pArrowDown2->SetPoly2D(poly4);
|
|
}
|
|
}
|
|
else if(nSectStair==1) //右梯剖断
|
|
{
|
|
poly.AppendNode(pt8);
|
|
poly.AppendNode(pt7);
|
|
|
|
poly2.AppendNode(pt11);
|
|
poly2.AppendNode(pt10);
|
|
|
|
if(m_nStairFlag==SF_MIDDLE) //中间层
|
|
{
|
|
XPoly2D poly3,poly4;
|
|
poly3.AppendNode(pt1);
|
|
poly3.AppendNode(pt4);
|
|
poly3.AppendNode(pt5);
|
|
poly3.AppendNode(pt6);
|
|
|
|
poly4.AppendNode(pt12);
|
|
poly4.AppendNode(pt5);
|
|
poly4.AppendNode(pt4);
|
|
poly4.AppendNode(pt9);
|
|
poly3.SetElevation(GetElevation());
|
|
poly4.SetElevation(GetElevation());
|
|
pArrowDown1->SetPoly2D(poly3);
|
|
pArrowDown2->SetPoly2D(poly4);
|
|
}
|
|
}
|
|
}
|
|
poly.SetElevation(GetElevation());
|
|
poly2.SetElevation(GetElevation());
|
|
pArrowUp1->SetPoly2D(poly);
|
|
pArrowUp2->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 090122 获得梯段扶手线的位置
|
|
void TDbScissorsStair::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 TDbScissorsStair::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(40);
|
|
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
|
|
TDbScissorsStair::ExplodeOrDraw3d(XExplodeDraw &dc) const
|
|
{
|
|
if(m_nViewCtrl==1)
|
|
return Acad::eOk; //三维被禁止
|
|
|
|
assertReadEnabled();
|
|
|
|
TDbLineStair stair1, stair2, stair3, stair4;
|
|
TDbSlab slab;
|
|
TDbHandRail rail, rail2, railTop, railTop2,railOut1,railOut2;
|
|
ExplodeTo(stair1, stair2, stair3, stair4, slab, rail, rail2, &railTop, &railTop2,&railOut1,&railOut2);
|
|
|
|
if(m_nStairFlag==SF_TOP)
|
|
{
|
|
{
|
|
TPushProperty vProp(&railTop, dc);
|
|
if(dc.IsFullExplode())
|
|
railTop.ExplodeOrDraw3d(dc);
|
|
else
|
|
dc.DrawEntity(railTop);
|
|
}
|
|
|
|
{
|
|
TPushProperty vProp(&railTop2, dc);
|
|
if(dc.IsFullExplode())
|
|
railTop2.ExplodeOrDraw3d(dc);
|
|
else
|
|
dc.DrawEntity(railTop2);
|
|
}
|
|
|
|
// 内侧栏杆
|
|
if(IsAutoRail())
|
|
{
|
|
dc.SetColorLayer(colorIndex(), m_idLayerRail3d);
|
|
XPoly2D polyPath=railTop.GetOutline();
|
|
DrawRail(polyPath,m_nStepWidth,dc);
|
|
|
|
//if(m_nStartSide != OFFSET_LEFT)//顶层右边栏杆
|
|
{
|
|
XPoly2D polyPath=railTop2.GetOutline();
|
|
DrawRail(polyPath,m_nStepWidth,dc);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//左边梯段
|
|
{
|
|
TPushProperty vProp(&stair1, dc);
|
|
if(dc.IsFullExplode())
|
|
stair1.ExplodeOrDraw3d(dc);
|
|
else
|
|
dc.DrawEntity(stair1);
|
|
}
|
|
//中间梯段
|
|
{
|
|
TPushProperty vProp(&stair2, dc);
|
|
if(dc.IsFullExplode())
|
|
stair2.ExplodeOrDraw3d(dc);
|
|
else
|
|
dc.DrawEntity(stair2);
|
|
}
|
|
//右边梯段
|
|
{
|
|
TPushProperty vProp(&stair3, dc);
|
|
if(dc.IsFullExplode())
|
|
stair3.ExplodeOrDraw3d(dc);
|
|
else
|
|
dc.DrawEntity(stair3);
|
|
}
|
|
//中间梯段
|
|
{
|
|
TPushProperty vProp(&stair4, dc);
|
|
if(dc.IsFullExplode())
|
|
stair4.ExplodeOrDraw3d(dc);
|
|
else
|
|
dc.DrawEntity(stair4);
|
|
}
|
|
|
|
//休息平台
|
|
if(m_nSlabSize>_DIST_SNAP)
|
|
{
|
|
TPushProperty vProp(&slab, dc);
|
|
if(dc.IsFullExplode())
|
|
slab.ExplodeOrDraw3d(dc);
|
|
else
|
|
dc.DrawEntity(slab);
|
|
}
|
|
|
|
|
|
{
|
|
//外侧扶手
|
|
if(IsOutRail())
|
|
{
|
|
if(dc.IsFullExplode())
|
|
{
|
|
railOut1.ExplodeOrDraw3d(dc);
|
|
railOut2.ExplodeOrDraw3d(dc);
|
|
}
|
|
else
|
|
{
|
|
dc.DrawEntity(railOut1);
|
|
dc.DrawEntity(railOut2);
|
|
}
|
|
|
|
// 外侧栏杆
|
|
if(IsAutoOutRail())
|
|
{
|
|
dc.SetColorLayer(colorIndex(), m_idLayerRail3d);
|
|
XPoly2D polyPath=railOut1.GetOutline();
|
|
|
|
//add by xlc on 090121 修改栏杆画法，不作为坡道时，只在踏步中间画
|
|
// DrawRail(polyPath,m_nStepWidth,dc);
|
|
//
|
|
// polyPath=railOut2.GetOutline();
|
|
// DrawRail(polyPath,m_nStepWidth,dc);
|
|
double nDistToSide=(GetSpaceWidth()-2*GetStairWidth()<_DIST_SNAP*2 &&m_nRailDistToSide<0)?
|
|
_AS_SYS_UNIT(0) : m_nRailDistToSide;
|
|
nDistToSide += m_nRailWidth/2;
|
|
if(m_nStartSide == OFFSET_LEFT)
|
|
{
|
|
GetRailPolyFromStair(stair1,nDistToSide,m_nRailDist,0,0,polyPath);
|
|
DrawRail(polyPath,m_nStepWidth,dc);
|
|
|
|
GetRailPolyFromStair(stair4,nDistToSide,0,m_nRailDist,0,polyPath);
|
|
DrawRail(polyPath,m_nStepWidth,dc);
|
|
|
|
GetRailPolyFromStair(stair2,nDistToSide,0,m_nRailDist,0,polyPath);
|
|
DrawRail(polyPath,m_nStepWidth,dc);
|
|
|
|
GetRailPolyFromStair(stair3,nDistToSide,m_nRailDist,0,0,polyPath);
|
|
DrawRail(polyPath,m_nStepWidth,dc);
|
|
}
|
|
else
|
|
{
|
|
GetRailPolyFromStair(stair1,-nDistToSide,0,m_nRailDist,1,polyPath);
|
|
DrawRail(polyPath,m_nStepWidth,dc);
|
|
|
|
GetRailPolyFromStair(stair4,-nDistToSide,m_nRailDist,0,1,polyPath);
|
|
DrawRail(polyPath,m_nStepWidth,dc);
|
|
|
|
GetRailPolyFromStair(stair2,-nDistToSide,m_nRailDist,0,1,polyPath);
|
|
DrawRail(polyPath,m_nStepWidth,dc);
|
|
|
|
GetRailPolyFromStair(stair3,-nDistToSide,0,m_nRailDist,1,polyPath);
|
|
DrawRail(polyPath,m_nStepWidth,dc);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
//内侧扶手
|
|
extern BOOL g_bInElevProcess;
|
|
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);
|
|
}
|
|
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=rail.GetOutline();
|
|
|
|
//add by xlc on 090121 修改栏杆画法，只在踏步中间画
|
|
// DrawRail(polyPath,m_nStepWidth,dc);
|
|
//
|
|
// polyPath=railOut2.GetOutline();
|
|
// DrawRail(polyPath,m_nStepWidth,dc);
|
|
double nDistToSide=(GetSpaceWidth()-2*GetStairWidth()<_DIST_SNAP*2 &&m_nRailDistToSide<0)?
|
|
_AS_SYS_UNIT(0) : m_nRailDistToSide;
|
|
nDistToSide += m_nRailWidth/2;
|
|
if(m_nStartSide == OFFSET_LEFT)
|
|
{
|
|
GetRailPolyFromStair(stair1,-nDistToSide,m_nRailDist,0,1,polyPath);
|
|
DrawRail(polyPath,m_nStepWidth,dc);
|
|
|
|
GetRailPolyFromStair(stair4,-nDistToSide,0,m_nRailDist,1,polyPath);
|
|
DrawRail(polyPath,m_nStepWidth,dc);
|
|
|
|
GetRailPolyFromStair(stair2,-nDistToSide,0,m_nRailDist,1,polyPath);
|
|
DrawRail(polyPath,m_nStepWidth,dc);
|
|
|
|
GetRailPolyFromStair(stair3,-nDistToSide,m_nRailDist,0,1,polyPath);
|
|
DrawRail(polyPath,m_nStepWidth,dc);
|
|
}
|
|
else
|
|
{
|
|
GetRailPolyFromStair(stair1,nDistToSide,0,m_nRailDist,0,polyPath);
|
|
DrawRail(polyPath,m_nStepWidth,dc);
|
|
|
|
GetRailPolyFromStair(stair4,nDistToSide,m_nRailDist,0,0,polyPath);
|
|
DrawRail(polyPath,m_nStepWidth,dc);
|
|
|
|
GetRailPolyFromStair(stair2,nDistToSide,m_nRailDist,0,0,polyPath);
|
|
DrawRail(polyPath,m_nStepWidth,dc);
|
|
|
|
GetRailPolyFromStair(stair3,nDistToSide,0,m_nRailDist,0,polyPath);
|
|
DrawRail(polyPath,m_nStepWidth,dc);
|
|
}
|
|
}
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
bool TDbScissorsStair::IsClipMe(const TEntityBase* pEnt)const
|
|
{
|
|
if(TDbEntity::IsClipMe(pEnt))
|
|
return true;
|
|
|
|
if(pEnt->GetMe()->isKindOf(TDbColumn::desc()))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbScissorsStair::ExplodeOrDraw2d(XExplodeDraw &dc) const
|
|
{
|
|
if(m_nViewCtrl==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,stair3,stair4;
|
|
TDbSlab slab;
|
|
TDbHandRail rail,rail2,railOut1,railOut2;
|
|
ExplodeTo(stair1, stair2, stair3, stair4, slab, rail,rail2,NULL,NULL,&railOut1,&railOut2);
|
|
|
|
TDbSymbArrow pArrowUp1,pArrowUp2,pArrowDown1,pArrowDown2;
|
|
if(IsArrow()) //画箭头
|
|
{
|
|
GetDefaultArrow(stair1,stair2,stair3,stair4,&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);
|
|
}
|
|
}
|
|
|
|
stair1.AddTempRail(&rail);
|
|
stair2.AddTempRail(&rail);
|
|
stair3.AddTempRail(&rail2);
|
|
stair4.AddTempRail(&rail2);
|
|
|
|
int nSectStair=GetSectStairPos();
|
|
if(IsOutRail()) //外侧扶手
|
|
{
|
|
stair1.AddTempRail(&railOut1);
|
|
railOut1.AddTempStair(&stair1);
|
|
stair3.AddTempRail(&railOut2);
|
|
railOut2.AddTempStair(&stair3);
|
|
|
|
stair2.AddTempRail(&railOut2);
|
|
railOut2.AddTempStair(&stair2);
|
|
stair4.AddTempRail(&railOut1);
|
|
railOut1.AddTempStair(&stair4);
|
|
}
|
|
|
|
double lSectPos,rSectPos;
|
|
XPoint ptLeft1,ptRight1,ptLeft2,ptRight2;
|
|
if(CalSectPos(lSectPos,rSectPos,ptLeft1,ptRight1,ptLeft2, ptRight2))
|
|
{
|
|
if(nSectStair==0)
|
|
{
|
|
stair1.SetSectionPos(0, lSectPos);
|
|
stair1.SetSectionPos(1, rSectPos);
|
|
|
|
stair3.SetSectionPos(0, lSectPos);
|
|
stair3.SetSectionPos(1, rSectPos);
|
|
}
|
|
else if(nSectStair==1)
|
|
{
|
|
stair2.SetSectionPos(0, lSectPos);
|
|
stair2.SetSectionPos(1, rSectPos);
|
|
|
|
stair4.SetSectionPos(0, lSectPos);
|
|
stair4.SetSectionPos(1, rSectPos);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
stair1.Set2DFlag(SF_NOSECT);
|
|
stair2.Set2DFlag(SF_NOSECT);
|
|
stair3.Set2DFlag(SF_NOSECT);
|
|
stair4.Set2DFlag(SF_NOSECT);
|
|
}
|
|
|
|
|
|
//显示梯段
|
|
if(dc.IsFullExplode())
|
|
{
|
|
if(m_nStairFlag!=SF_FIRST)
|
|
{
|
|
stair1.ExplodeOrDraw2d(dc);
|
|
stair2.ExplodeOrDraw2d(dc);
|
|
stair3.ExplodeOrDraw2d(dc);
|
|
stair4.ExplodeOrDraw2d(dc);
|
|
}
|
|
else
|
|
{
|
|
if(m_nStartSide == OFFSET_LEFT)
|
|
{
|
|
stair1.ExplodeOrDraw2d(dc);
|
|
stair3.ExplodeOrDraw2d(dc);
|
|
if(nSectStair==1) //剖切右梯
|
|
{
|
|
stair2.ExplodeOrDraw2d(dc);
|
|
stair4.ExplodeOrDraw2d(dc);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
stair2.ExplodeOrDraw2d(dc);
|
|
stair4.ExplodeOrDraw2d(dc);
|
|
if(nSectStair == 0) //剖切左梯
|
|
{
|
|
stair1.ExplodeOrDraw2d(dc);
|
|
stair3.ExplodeOrDraw2d(dc);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(m_nStairFlag!=SF_FIRST)
|
|
{
|
|
dc.DrawEntity(stair1);
|
|
dc.DrawEntity(stair2);
|
|
dc.DrawEntity(stair3);
|
|
dc.DrawEntity(stair4);
|
|
}
|
|
else
|
|
{
|
|
if(m_nStartSide == OFFSET_LEFT)
|
|
{
|
|
dc.DrawEntity(stair1);
|
|
dc.DrawEntity(stair3);
|
|
if(nSectStair == 1) //剖切右梯
|
|
{
|
|
dc.DrawEntity(stair2);
|
|
dc.DrawEntity(stair4);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dc.DrawEntity(stair2);
|
|
dc.DrawEntity(stair4);
|
|
if(nSectStair == 0) //剖切中梯
|
|
{
|
|
dc.DrawEntity(stair1);
|
|
dc.DrawEntity(stair3);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
// 设置内侧扶手
|
|
{
|
|
if(nSectStair==0)
|
|
{
|
|
rail.SetTempStair(&stair1);
|
|
rail.setPropertiesFrom(this);
|
|
rail2.SetTempStair(&stair3);
|
|
rail2.setPropertiesFrom(this);
|
|
}
|
|
else if(nSectStair==1)
|
|
{
|
|
rail.SetTempStair(&stair2);
|
|
rail.setPropertiesFrom(this);
|
|
rail2.SetTempStair(&stair4);
|
|
rail2.setPropertiesFrom(this);
|
|
}
|
|
}
|
|
|
|
// 内侧扶手
|
|
rail.setPropertiesFrom(this);
|
|
rail2.setPropertiesFrom(this);
|
|
if(dc.IsFullExplode())
|
|
{
|
|
rail.ExplodeOrDraw2d(dc);
|
|
rail2.ExplodeOrDraw2d(dc);
|
|
}
|
|
else
|
|
{
|
|
dc.DrawEntity(rail);
|
|
dc.DrawEntity(rail2);
|
|
}
|
|
|
|
//外侧扶手
|
|
if(IsOutRail())
|
|
{
|
|
//add by xlc on 090326 修改顶层外侧扶手的遮挡
|
|
XPoly2D poly(1),poly2(1);
|
|
poly.Reset();
|
|
poly2.Reset();
|
|
long clipCount=0;
|
|
if(m_nStairFlag==SF_TOP&&GetRailDistToSide()>-GetRailWidth())
|
|
{
|
|
XPoint pt;
|
|
/*if(m_nStartSide==OFFSET_LEFT)
|
|
{
|
|
pt=stair1.GetLowLeft2d();
|
|
ads_polar(pt, m_nRotation-PI*0.5, GetRailDist()+_DIST_SNAP, pt);
|
|
poly.AppendNode(pt);
|
|
ads_polar(pt, m_nRotation+PI*0.5, GetRailWidth()+_DIST_SNAP, pt);
|
|
poly.AppendNode(pt);
|
|
ads_polar(pt, m_nRotation, GetRailDistToSide()+GetRailWidth()+3.0*_DIST_SNAP, pt);
|
|
poly.AppendNode(pt);
|
|
ads_polar(pt, m_nRotation-PI*0.5, GetRailWidth()+_DIST_SNAP, pt);
|
|
poly.AppendNode(pt);
|
|
if(poly.Length()>0)
|
|
{
|
|
dc.PushClip(poly);
|
|
clipCount++;
|
|
}
|
|
pt=stair3.GetLowLeft2d();
|
|
ads_polar(pt, m_nRotation+PI*0.5, GetRailDist()+_DIST_SNAP, pt);
|
|
poly2.AppendNode(pt);
|
|
ads_polar(pt, m_nRotation-PI*0.5, GetRailWidth()+_DIST_SNAP, pt);
|
|
poly2.AppendNode(pt);
|
|
ads_polar(pt, m_nRotation+PI, GetRailDistToSide()+GetRailWidth()+3.0*_DIST_SNAP, pt);
|
|
poly2.AppendNode(pt);
|
|
ads_polar(pt, m_nRotation+PI*0.5, GetRailWidth()+_DIST_SNAP, pt);
|
|
poly2.AppendNode(pt);
|
|
if(poly2.Length()>0)
|
|
{
|
|
dc.PushClip(poly2);
|
|
clipCount++;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
pt=stair2.GetLowRight2d();
|
|
ads_polar(pt, m_nRotation-PI*0.5, GetRailDist()+_DIST_SNAP, pt);
|
|
poly.AppendNode(pt);
|
|
ads_polar(pt, m_nRotation+PI*0.5, GetRailWidth()+_DIST_SNAP, pt);
|
|
poly.AppendNode(pt);
|
|
ads_polar(pt, m_nRotation+PI, GetRailDistToSide()+GetRailWidth()+3.0*_DIST_SNAP, pt);
|
|
poly.AppendNode(pt);
|
|
ads_polar(pt, m_nRotation-PI*0.5, GetRailWidth()+_DIST_SNAP, pt);
|
|
poly.AppendNode(pt);
|
|
if(poly.Length()>0)
|
|
{
|
|
dc.PushClip(poly);
|
|
clipCount++;
|
|
}
|
|
pt=stair4.GetLowRight2d();
|
|
ads_polar(pt, m_nRotation+PI*0.5, GetRailDist()+_DIST_SNAP, pt);
|
|
poly2.AppendNode(pt);
|
|
ads_polar(pt, m_nRotation-PI*0.5, GetRailWidth()+_DIST_SNAP, pt);
|
|
poly2.AppendNode(pt);
|
|
ads_polar(pt, m_nRotation, GetRailDistToSide()+GetRailWidth()+3.0*_DIST_SNAP, pt);
|
|
poly2.AppendNode(pt);
|
|
ads_polar(pt, m_nRotation+PI*0.5, GetRailWidth()+_DIST_SNAP, pt);
|
|
poly2.AppendNode(pt);
|
|
if(poly2.Length()>0)
|
|
{
|
|
dc.PushClip(poly2);
|
|
clipCount++;
|
|
}
|
|
|
|
}*/
|
|
|
|
}
|
|
railOut1.setPropertiesFrom(this);
|
|
railOut2.setPropertiesFrom(this);
|
|
if(dc.IsFullExplode())
|
|
{
|
|
railOut1.ExplodeOrDraw2d(dc);
|
|
railOut2.ExplodeOrDraw2d(dc);
|
|
}
|
|
else
|
|
{
|
|
dc.DrawEntity(railOut1);
|
|
dc.DrawEntity(railOut2);
|
|
}
|
|
for(long i=0;i<clipCount;i++)
|
|
dc.PopClip();
|
|
}
|
|
|
|
//休息平台
|
|
if(!(m_nStairFlag==SF_FIRST&&(
|
|
(nSectStair==0&&m_nStartSide==OFFSET_LEFT)
|
|
||(nSectStair==1&&m_nStartSide!=OFFSET_LEFT))))//首层中梯上楼中梯剖断与边梯上楼边梯剖断不画休息台
|
|
{
|
|
if(m_nSlabSize>_DIST_SNAP)
|
|
{
|
|
slab.AddTempRail(&rail);
|
|
slab.AddTempRail(&rail2);
|
|
|
|
if(IsOutRail())
|
|
{
|
|
slab.AddTempRail(&railOut1);
|
|
slab.AddTempRail(&railOut2);
|
|
}
|
|
|
|
if(dc.IsFullExplode())
|
|
slab.ExplodeOrDraw2d(dc);
|
|
else
|
|
dc.DrawEntity(slab);
|
|
}
|
|
}
|
|
|
|
// 绘制楼板线
|
|
if((m_nStairFlag!=SF_FIRST)/*&&(m_nRailDist<0||m_nRailDist>m_nRailWidth)*/)
|
|
{
|
|
double nLen1=stair1.GetStairLength(),nLen2=stair2.GetStairLength();
|
|
XPoint ptFromL=m_nStartSide==OFFSET_LEFT? stair2.GetUpRight2d() : stair2.GetLowLeft2d();
|
|
XPoint ptToL=m_nStartSide==OFFSET_LEFT? stair1.GetLowRight2d() : stair1.GetUpLeft2d();
|
|
XPoint ptFrom=m_nStartSide==OFFSET_LEFT? stair4.GetUpRight2d() : stair4.GetLowLeft2d();
|
|
XPoint ptTo=m_nStartSide==OFFSET_LEFT? stair3.GetLowRight2d() : stair3.GetUpLeft2d();
|
|
|
|
//modidy by xlc on 090313 对楼板线裁剪处理
|
|
// if(fabs(nLen1-nLen2)>_DIST_SNAP && m_nAlignment!=2)
|
|
// {
|
|
// double nIdent=m_nAlignment==1? (nLen2-nLen1)/2 : (nLen2-nLen1);
|
|
// XPoint ptTempL,ptTemp;
|
|
// if(nIdent>0)
|
|
// {
|
|
// ads_polar(ptToL, m_nRotation-PI/2, nIdent, ptTempL);
|
|
// ads_polar(ptTo, m_nRotation+PI/2, nIdent, ptTemp);
|
|
//
|
|
// ads_polar(ptTempL, m_nRotation+PI/2, fabs(m_nRailDist), ptToL);
|
|
// ads_polar(ptTemp, m_nRotation-PI/2, fabs(m_nRailDist), ptTo);
|
|
// }
|
|
// else
|
|
// {
|
|
// ads_polar(ptFromL, m_nRotation-PI/2, fabs(nIdent), ptTempL);
|
|
// ads_polar(ptFrom, m_nRotation+PI/2, fabs(nIdent), ptTemp);
|
|
//
|
|
// ads_polar(ptTempL, m_nRotation+PI/2, fabs(m_nRailDist), ptFromL);
|
|
// ads_polar(ptTemp, m_nRotation-PI/2, fabs(m_nRailDist), ptFrom);
|
|
// }
|
|
// dc << XLine(ptFromL, ptTempL) << XLine(ptTempL, ptToL)
|
|
// << XLine(ptFrom, ptTemp) << XLine(ptTemp, ptTo);
|
|
// }
|
|
// else
|
|
// {
|
|
// dc << XLine(ptFromL, ptToL)<< XLine(ptFrom, ptTo);
|
|
// }
|
|
XPoly2D poly(1);
|
|
poly.Reset();
|
|
long clipCount=0;
|
|
|
|
double nRailDist=m_nRailDist;
|
|
if(fabs(nLen1-nLen2)>_DIST_SNAP && m_nAlignment!=2)
|
|
{
|
|
double nIdent=m_nAlignment==1? (nLen2-nLen1)/2 : (nLen2-nLen1);
|
|
XPoint ptTempL,ptTemp;
|
|
if(nIdent>0)
|
|
{
|
|
ads_polar(ptToL, m_nRotation-PI/2, nIdent, ptTempL);
|
|
ads_polar(ptTo, m_nRotation+PI/2, nIdent, ptTemp);
|
|
|
|
XPoint ptTmp1,ptTmp2,ptTmp3;
|
|
if(nRailDist>-nIdent)
|
|
{
|
|
//stair1,stair2楼板线切割
|
|
ads_polar(ptToL, m_nRotation+PI, m_nRailDistToSide, ptTmp1);
|
|
ads_polar(ptTmp1, m_nRotation+PI, m_nRailWidth, ptTmp2);
|
|
ads_polar(ptTmp1, m_nRotation-PI*0.5, fabs(nIdent)+nRailDist-m_nRailWidth, ptTmp3);
|
|
poly.AppendNode(ptTmp3);
|
|
poly.AppendNode(ptTmp1);
|
|
poly.AppendNode(ptTmp2);
|
|
|
|
if(m_nStairFlag==SF_TOP&&m_nRailDistToSide<-m_nRailWidth&&m_nStartSide==OFFSET_LEFT)
|
|
{
|
|
ads_polar(ptTmp2, m_nRotation-PI*0.5, fabs(nIdent)+nRailDist-m_nRailWidth, ptTmp1);
|
|
poly.AppendNode(ptTmp1);
|
|
ads_polar(ptTmp1, m_nRotation+PI, fabs(m_nRailDistToSide+m_nRailWidth), ptTmp1);
|
|
poly.AppendNode(ptTmp1);
|
|
ads_polar(ptTmp1, m_nRotation-PI*0.5, m_nRailWidth, ptTmp3);
|
|
}
|
|
else
|
|
{
|
|
ads_polar(ptTmp2, m_nRotation-PI*0.5, fabs(nIdent)+nRailDist, ptTmp3);
|
|
}
|
|
|
|
poly.AppendNode(ptTmp3);
|
|
if(nRailDist<0)
|
|
{
|
|
ads_polar(ptFromL, m_nRotation, m_nRailDistToSide+m_nRailWidth, ptTmp1);
|
|
ads_polar(ptTmp1, m_nRotation-PI*0.5, nRailDist, ptTmp2);
|
|
ads_polar(ptTmp2, m_nRotation+PI*0.5, m_nRailWidth, ptTmp3);
|
|
poly.AppendNode(ptTmp2);
|
|
poly.AppendNode(ptTmp3);
|
|
}
|
|
else
|
|
{
|
|
ads_polar(ptFromL, m_nRotation, m_nRailDistToSide+m_nRailWidth, ptTmp2);
|
|
ads_polar(ptTmp2, m_nRotation-PI*0.5, nRailDist, ptTmp3);
|
|
poly.AppendNode(ptTmp3);
|
|
if(m_nStairFlag==SF_TOP
|
|
&&m_nRailDistToSide<-m_nRailWidth
|
|
&&nRailDist<=m_nRailWidth
|
|
&&m_nStartSide!=OFFSET_LEFT)
|
|
{
|
|
ads_polar(ptTmp3, m_nRotation, fabs(m_nRailDistToSide+m_nRailWidth), ptTmp2);
|
|
poly.AppendNode(ptTmp2);
|
|
ads_polar(ptTmp2, m_nRotation+PI*0.5, m_nRailWidth, ptTmp2);
|
|
poly.AppendNode(ptTmp2);
|
|
ads_polar(ptTmp2, m_nRotation+PI, fabs(m_nRailDistToSide+m_nRailWidth), ptTmp2);
|
|
poly.AppendNode(ptTmp2);
|
|
}
|
|
ads_polar(ptFromL, m_nRotation, m_nRailDistToSide, ptTmp1);
|
|
ads_polar(ptTmp1, m_nRotation, m_nRailWidth, ptTmp2);
|
|
ads_polar(ptTmp1, m_nRotation+PI*0.5, m_nRailWidth, ptTmp1);
|
|
ads_polar(ptTmp2, m_nRotation+PI*0.5, m_nRailWidth, ptTmp2);
|
|
poly.AppendNode(ptTmp2);
|
|
poly.AppendNode(ptTmp1);
|
|
ads_polar(ptTmp1, m_nRotation-PI*0.5, nRailDist, ptTmp3);
|
|
poly.AppendNode(ptTmp3);
|
|
}
|
|
if(poly.Length()>0)
|
|
{
|
|
dc.PushClip(poly);
|
|
clipCount++;
|
|
}
|
|
poly.Reset();
|
|
|
|
//stair3,stair4楼板线切割
|
|
ads_polar(ptTo, m_nRotation, m_nRailDistToSide, ptTmp1);
|
|
ads_polar(ptTmp1, m_nRotation, m_nRailWidth, ptTmp2);
|
|
ads_polar(ptTmp1, m_nRotation+PI*0.5, fabs(nIdent)+nRailDist-m_nRailWidth, ptTmp3);
|
|
poly.AppendNode(ptTmp3);
|
|
poly.AppendNode(ptTmp1);
|
|
poly.AppendNode(ptTmp2);
|
|
if(m_nStairFlag==SF_TOP
|
|
&&m_nRailDistToSide<-m_nRailWidth
|
|
&&m_nStartSide==OFFSET_LEFT
|
|
)
|
|
{
|
|
ads_polar(ptTmp2, m_nRotation+PI*0.5, fabs(nIdent)+nRailDist-m_nRailWidth, ptTmp1);
|
|
poly.AppendNode(ptTmp1);
|
|
ads_polar(ptTmp1, m_nRotation, fabs(m_nRailDistToSide+m_nRailWidth), ptTmp1);
|
|
poly.AppendNode(ptTmp1);
|
|
ads_polar(ptTmp1, m_nRotation+PI*0.5, m_nRailWidth, ptTmp3);
|
|
}
|
|
else
|
|
{
|
|
ads_polar(ptTmp2, m_nRotation+PI*0.5, fabs(nIdent)+nRailDist, ptTmp3);
|
|
}
|
|
poly.AppendNode(ptTmp3);
|
|
if(nRailDist<0)
|
|
{
|
|
ads_polar(ptFrom, m_nRotation+PI, m_nRailDistToSide+m_nRailWidth, ptTmp1);
|
|
ads_polar(ptTmp1, m_nRotation+PI*0.5, nRailDist, ptTmp2);
|
|
ads_polar(ptTmp2, m_nRotation-PI*0.5, m_nRailWidth, ptTmp3);
|
|
poly.AppendNode(ptTmp2);
|
|
poly.AppendNode(ptTmp3);
|
|
}
|
|
else
|
|
{
|
|
ads_polar(ptFrom, m_nRotation+PI, m_nRailDistToSide+m_nRailWidth, ptTmp2);
|
|
ads_polar(ptTmp2, m_nRotation+PI*0.5, nRailDist, ptTmp3);
|
|
poly.AppendNode(ptTmp3);
|
|
if(m_nStairFlag==SF_TOP
|
|
&&m_nRailDistToSide<-m_nRailWidth
|
|
&&nRailDist<=m_nRailWidth
|
|
&&m_nStartSide!=OFFSET_LEFT)
|
|
{
|
|
ads_polar(ptTmp3, m_nRotation+PI, fabs(m_nRailDistToSide+m_nRailWidth), ptTmp2);
|
|
poly.AppendNode(ptTmp2);
|
|
ads_polar(ptTmp2, m_nRotation-PI*0.5, m_nRailWidth, ptTmp2);
|
|
poly.AppendNode(ptTmp2);
|
|
ads_polar(ptTmp2, m_nRotation, fabs(m_nRailDistToSide+m_nRailWidth), ptTmp2);
|
|
poly.AppendNode(ptTmp2);
|
|
}
|
|
|
|
ads_polar(ptFrom, m_nRotation+PI, m_nRailDistToSide, ptTmp1);
|
|
ads_polar(ptTmp1, m_nRotation+PI, m_nRailWidth, ptTmp2);
|
|
ads_polar(ptTmp1, m_nRotation-PI*0.5, m_nRailWidth, ptTmp1);
|
|
ads_polar(ptTmp2, m_nRotation-PI*0.5, m_nRailWidth, ptTmp2);
|
|
poly.AppendNode(ptTmp2);
|
|
poly.AppendNode(ptTmp1);
|
|
ads_polar(ptTmp1, m_nRotation+PI*0.5, nRailDist, ptTmp3);
|
|
poly.AppendNode(ptTmp3);
|
|
}
|
|
if(poly.Length()>0)
|
|
{
|
|
dc.PushClip(poly);
|
|
clipCount++;
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
ads_polar(ptFromL, m_nRotation-PI/2, fabs(nIdent), ptTempL);
|
|
ads_polar(ptFrom, m_nRotation+PI/2, fabs(nIdent), ptTemp);
|
|
|
|
XPoint ptTmp1,ptTmp2,ptTmp3;
|
|
if(nRailDist>nIdent)
|
|
{
|
|
//stair1,stair2楼板线切割
|
|
ads_polar(ptFromL, m_nRotation, m_nRailDistToSide, ptTmp1);
|
|
ads_polar(ptTmp1, m_nRotation, m_nRailWidth, ptTmp2);
|
|
ads_polar(ptTmp1, m_nRotation-PI*0.5, fabs(nIdent)+nRailDist-m_nRailWidth, ptTmp3);
|
|
poly.AppendNode(ptTmp3);
|
|
poly.AppendNode(ptTmp1);
|
|
poly.AppendNode(ptTmp2);
|
|
|
|
if(m_nStairFlag==SF_TOP
|
|
&&m_nRailDistToSide<-m_nRailWidth
|
|
&&nRailDist<=m_nRailWidth
|
|
&&m_nStartSide!=OFFSET_LEFT)
|
|
{
|
|
ads_polar(ptTmp2, m_nRotation-PI*0.5, fabs(nIdent)+nRailDist-m_nRailWidth, ptTmp3);
|
|
poly.AppendNode(ptTmp3);
|
|
ads_polar(ptTmp3, m_nRotation, fabs(m_nRailDistToSide+m_nRailWidth), ptTmp2);
|
|
poly.AppendNode(ptTmp2);
|
|
ads_polar(ptTmp2, m_nRotation-PI*0.5, m_nRailWidth, ptTmp3);
|
|
}
|
|
else
|
|
{
|
|
ads_polar(ptTmp2, m_nRotation-PI*0.5, fabs(nIdent)+nRailDist, ptTmp3);
|
|
}
|
|
poly.AppendNode(ptTmp3);
|
|
if(nRailDist<0)
|
|
{
|
|
ads_polar(ptToL, m_nRotation+PI, m_nRailDistToSide+m_nRailWidth, ptTmp1);
|
|
ads_polar(ptTmp1, m_nRotation-PI*0.5, nRailDist, ptTmp2);
|
|
ads_polar(ptTmp2, m_nRotation+PI*0.5, m_nRailWidth, ptTmp3);
|
|
poly.AppendNode(ptTmp2);
|
|
poly.AppendNode(ptTmp3);
|
|
}
|
|
else
|
|
{
|
|
ads_polar(ptToL, m_nRotation+PI, m_nRailDistToSide+m_nRailWidth, ptTmp2);
|
|
if(m_nStairFlag==SF_TOP
|
|
&&m_nRailDistToSide<-m_nRailWidth
|
|
&&nRailDist<=m_nRailWidth
|
|
&&m_nStartSide==OFFSET_LEFT)
|
|
{
|
|
ads_polar(ptTmp2, m_nRotation-PI*0.5, nRailDist-m_nRailWidth, ptTmp1);
|
|
ads_polar(ptTmp1, m_nRotation+PI, fabs(m_nRailDistToSide+m_nRailWidth), ptTmp2);
|
|
ads_polar(ptTmp2, m_nRotation-PI*0.5, m_nRailWidth, ptTmp3);
|
|
poly.AppendNode(ptTmp3);
|
|
poly.AppendNode(ptTmp2);
|
|
poly.AppendNode(ptTmp1);
|
|
}
|
|
else
|
|
{
|
|
ads_polar(ptTmp2, m_nRotation-PI*0.5, nRailDist, ptTmp3);
|
|
poly.AppendNode(ptTmp3);
|
|
}
|
|
ads_polar(ptToL, m_nRotation+PI, m_nRailDistToSide, ptTmp1);
|
|
ads_polar(ptTmp1, m_nRotation+PI, m_nRailWidth, ptTmp2);
|
|
ads_polar(ptTmp1, m_nRotation+PI*0.5, m_nRailWidth, ptTmp1);
|
|
ads_polar(ptTmp2, m_nRotation+PI*0.5, m_nRailWidth, ptTmp2);
|
|
poly.AppendNode(ptTmp2);
|
|
poly.AppendNode(ptTmp1);
|
|
|
|
ads_polar(ptTmp1, m_nRotation-PI*0.5, nRailDist, ptTmp3);
|
|
poly.AppendNode(ptTmp3);
|
|
}
|
|
if(poly.Length()>0)
|
|
{
|
|
dc.PushClip(poly);
|
|
clipCount++;
|
|
}
|
|
poly.Reset();
|
|
|
|
//stair3,stair4楼板线切割
|
|
ads_polar(ptFrom, m_nRotation+PI, m_nRailDistToSide, ptTmp1);
|
|
ads_polar(ptTmp1, m_nRotation+PI, m_nRailWidth, ptTmp2);
|
|
ads_polar(ptTmp1, m_nRotation+PI*0.5, fabs(nIdent)+nRailDist-m_nRailWidth, ptTmp3);
|
|
poly.AppendNode(ptTmp3);
|
|
poly.AppendNode(ptTmp1);
|
|
poly.AppendNode(ptTmp2);
|
|
|
|
if(m_nStairFlag==SF_TOP
|
|
&&m_nRailDistToSide<-m_nRailWidth
|
|
&&nRailDist<=m_nRailWidth
|
|
&&m_nStartSide!=OFFSET_LEFT)
|
|
{
|
|
ads_polar(ptTmp2, m_nRotation+PI*0.5, fabs(nIdent)+nRailDist-m_nRailWidth, ptTmp3);
|
|
poly.AppendNode(ptTmp3);
|
|
ads_polar(ptTmp3, m_nRotation+PI, fabs(m_nRailDistToSide+m_nRailWidth), ptTmp2);
|
|
poly.AppendNode(ptTmp2);
|
|
ads_polar(ptTmp2, m_nRotation+PI*0.5, m_nRailWidth, ptTmp3);
|
|
}
|
|
else
|
|
{
|
|
ads_polar(ptTmp2, m_nRotation+PI*0.5, fabs(nIdent)+nRailDist, ptTmp3);
|
|
}
|
|
poly.AppendNode(ptTmp3);
|
|
if(nRailDist<0)
|
|
{
|
|
ads_polar(ptTo, m_nRotation, m_nRailDistToSide+m_nRailWidth, ptTmp1);
|
|
ads_polar(ptTmp1, m_nRotation+PI*0.5, nRailDist, ptTmp2);
|
|
ads_polar(ptTmp2, m_nRotation-PI*0.5, m_nRailWidth, ptTmp3);
|
|
poly.AppendNode(ptTmp2);
|
|
poly.AppendNode(ptTmp3);
|
|
}
|
|
else
|
|
{
|
|
ads_polar(ptTo, m_nRotation, m_nRailDistToSide+m_nRailWidth, ptTmp2);
|
|
if(m_nStairFlag==SF_TOP
|
|
&&m_nRailDistToSide<-m_nRailWidth
|
|
&&nRailDist<=m_nRailWidth
|
|
&&m_nStartSide==OFFSET_LEFT)
|
|
{
|
|
ads_polar(ptTmp2, m_nRotation+PI*0.5, nRailDist-m_nRailWidth, ptTmp1);
|
|
ads_polar(ptTmp1, m_nRotation, fabs(m_nRailDistToSide+m_nRailWidth), ptTmp2);
|
|
ads_polar(ptTmp2, m_nRotation+PI*0.5, m_nRailWidth, ptTmp3);
|
|
poly.AppendNode(ptTmp3);
|
|
poly.AppendNode(ptTmp2);
|
|
poly.AppendNode(ptTmp1);
|
|
}
|
|
else
|
|
{
|
|
ads_polar(ptTmp2, m_nRotation+PI*0.5, nRailDist, ptTmp3);
|
|
poly.AppendNode(ptTmp3);
|
|
}
|
|
ads_polar(ptTo, m_nRotation, m_nRailDistToSide, ptTmp1);
|
|
ads_polar(ptTmp1, m_nRotation, m_nRailWidth, ptTmp2);
|
|
ads_polar(ptTmp1, m_nRotation-PI*0.5, m_nRailWidth, ptTmp1);
|
|
ads_polar(ptTmp2, m_nRotation-PI*0.5, m_nRailWidth, ptTmp2);
|
|
poly.AppendNode(ptTmp2);
|
|
poly.AppendNode(ptTmp1);
|
|
|
|
ads_polar(ptTmp1, m_nRotation+PI*0.5, nRailDist, ptTmp3);
|
|
poly.AppendNode(ptTmp3);
|
|
}
|
|
if(poly.Length()>0)
|
|
{
|
|
dc.PushClip(poly);
|
|
clipCount++;
|
|
}
|
|
}
|
|
}
|
|
dc << XLine(ptFromL, ptTempL) << XLine(ptTempL, ptToL)
|
|
<< XLine(ptFrom, ptTemp) << XLine(ptTemp, ptTo);
|
|
}
|
|
else
|
|
{
|
|
if(nRailDist>0&&nRailDist<m_nRailWidth)//层间连接处扶手遮挡
|
|
{
|
|
XPoint ptTempL,ptTempR;
|
|
//stair1,stair2楼板线切割
|
|
if(m_nStairFlag==SF_TOP&&m_nRailDistToSide<-m_nRailWidth&&m_nStartSide!=OFFSET_LEFT)
|
|
{
|
|
ptTempL=ptFromL;
|
|
}
|
|
else
|
|
{
|
|
ads_polar(ptFromL, m_nRotation, m_nRailDistToSide+m_nRailWidth, ptTempL);
|
|
}
|
|
if(m_nStairFlag==SF_TOP&&m_nRailDistToSide<-m_nRailWidth&&m_nStartSide==OFFSET_LEFT)
|
|
{
|
|
ptTempR=ptToL;
|
|
}
|
|
else
|
|
ads_polar(ptToL, m_nRotation+PI, m_nRailDistToSide+m_nRailWidth, ptTempR);
|
|
|
|
|
|
ads_polar(ptTempL, m_nRotation-PI*0.5, nRailDist, ptTempL);
|
|
ads_polar(ptTempR, m_nRotation-PI*0.5, nRailDist, ptTempR);
|
|
poly.AppendNode(ptTempL);
|
|
poly.AppendNode(ptTempR);
|
|
|
|
ads_polar(ptTempL, m_nRotation+PI*0.5, m_nRailWidth, ptTempL);
|
|
ads_polar(ptTempR, m_nRotation+PI*0.5, m_nRailWidth, ptTempR);
|
|
poly.AppendNode(ptTempR);
|
|
poly.AppendNode(ptTempL);
|
|
|
|
if(poly.Length()>0)
|
|
{
|
|
dc.PushClip(poly);
|
|
clipCount++;
|
|
}
|
|
|
|
//stair3,stair4楼板线切割
|
|
poly.Reset();
|
|
if(m_nStairFlag==SF_TOP&&m_nRailDistToSide<-m_nRailWidth&&m_nStartSide!=OFFSET_LEFT)
|
|
{
|
|
ptTempL=ptFrom;
|
|
}
|
|
else
|
|
ads_polar(ptFrom, m_nRotation+PI, m_nRailDistToSide+m_nRailWidth, ptTempL);
|
|
if(m_nStairFlag==SF_TOP&&m_nRailDistToSide<-m_nRailWidth&&m_nStartSide==OFFSET_LEFT)
|
|
{
|
|
ptTempR=ptTo;
|
|
}
|
|
else
|
|
ads_polar(ptTo, m_nRotation, m_nRailDistToSide+m_nRailWidth, ptTempR);
|
|
|
|
ads_polar(ptTempL, m_nRotation+PI*0.5, nRailDist, ptTempL);
|
|
ads_polar(ptTempR, m_nRotation+PI*0.5, nRailDist, ptTempR);
|
|
poly.AppendNode(ptTempL);
|
|
poly.AppendNode(ptTempR);
|
|
|
|
ads_polar(ptTempL, m_nRotation-PI*0.5, m_nRailWidth, ptTempL);
|
|
ads_polar(ptTempR, m_nRotation-PI*0.5, m_nRailWidth, ptTempR);
|
|
poly.AppendNode(ptTempR);
|
|
poly.AppendNode(ptTempL);
|
|
|
|
if(poly.Length()>0)
|
|
{
|
|
dc.PushClip(poly);
|
|
clipCount++;
|
|
}
|
|
}
|
|
else if(nRailDist>=m_nRailWidth) //扶手遮挡
|
|
{
|
|
XPoint ptTempL,ptTempR;
|
|
//stair1,stair2楼板线切割
|
|
ads_polar(ptFromL, m_nRotation, m_nRailDistToSide, ptTempL);
|
|
ads_polar(ptTempL, m_nRotation, m_nRailWidth, ptTempR);
|
|
|
|
ads_polar(ptTempL, m_nRotation-PI*0.5, m_nRailWidth*0.5, ptTempL);
|
|
ads_polar(ptTempR, m_nRotation-PI*0.5, m_nRailWidth*0.5, ptTempR);
|
|
poly.AppendNode(ptTempL);
|
|
poly.AppendNode(ptTempR);
|
|
|
|
ads_polar(ptTempL, m_nRotation+PI*0.5, m_nRailWidth, ptTempL);
|
|
ads_polar(ptTempR, m_nRotation+PI*0.5, m_nRailWidth, ptTempR);
|
|
poly.AppendNode(ptTempR);
|
|
poly.AppendNode(ptTempL);
|
|
|
|
if(poly.Length()>0)
|
|
{
|
|
dc.PushClip(poly);
|
|
clipCount++;
|
|
}
|
|
|
|
poly.Reset();
|
|
ads_polar(ptToL, m_nRotation+PI, m_nRailDistToSide, ptTempL);
|
|
ads_polar(ptTempL, m_nRotation+PI, m_nRailWidth, ptTempR);
|
|
|
|
ads_polar(ptTempL, m_nRotation-PI*0.5, m_nRailWidth*0.5, ptTempL);
|
|
ads_polar(ptTempR, m_nRotation-PI*0.5, m_nRailWidth*0.5, ptTempR);
|
|
poly.AppendNode(ptTempL);
|
|
poly.AppendNode(ptTempR);
|
|
|
|
ads_polar(ptTempL, m_nRotation+PI*0.5, m_nRailWidth, ptTempL);
|
|
ads_polar(ptTempR, m_nRotation+PI*0.5, m_nRailWidth, ptTempR);
|
|
poly.AppendNode(ptTempR);
|
|
poly.AppendNode(ptTempL);
|
|
|
|
if(poly.Length()>0)
|
|
{
|
|
dc.PushClip(poly);
|
|
clipCount++;
|
|
}
|
|
//stair3,stair4楼板线切割
|
|
poly.Reset();
|
|
ads_polar(ptFrom, m_nRotation+PI, m_nRailDistToSide, ptTempL);
|
|
ads_polar(ptTempL, m_nRotation+PI, m_nRailWidth, ptTempR);
|
|
|
|
ads_polar(ptTempL, m_nRotation-PI*0.5, m_nRailWidth*0.5, ptTempL);
|
|
ads_polar(ptTempR, m_nRotation-PI*0.5, m_nRailWidth*0.5, ptTempR);
|
|
poly.AppendNode(ptTempL);
|
|
poly.AppendNode(ptTempR);
|
|
|
|
ads_polar(ptTempL, m_nRotation+PI*0.5, m_nRailWidth, ptTempL);
|
|
ads_polar(ptTempR, m_nRotation+PI*0.5, m_nRailWidth, ptTempR);
|
|
poly.AppendNode(ptTempR);
|
|
poly.AppendNode(ptTempL);
|
|
|
|
if(poly.Length()>0)
|
|
{
|
|
dc.PushClip(poly);
|
|
clipCount++;
|
|
}
|
|
poly.Reset();
|
|
ads_polar(ptTo, m_nRotation, m_nRailDistToSide, ptTempL);
|
|
ads_polar(ptTempL, m_nRotation, m_nRailWidth, ptTempR);
|
|
|
|
ads_polar(ptTempL, m_nRotation-PI*0.5, m_nRailWidth*0.5, ptTempL);
|
|
ads_polar(ptTempR, m_nRotation-PI*0.5, m_nRailWidth*0.5, ptTempR);
|
|
poly.AppendNode(ptTempL);
|
|
poly.AppendNode(ptTempR);
|
|
|
|
ads_polar(ptTempL, m_nRotation+PI*0.5, m_nRailWidth, ptTempL);
|
|
ads_polar(ptTempR, m_nRotation+PI*0.5, m_nRailWidth, ptTempR);
|
|
poly.AppendNode(ptTempR);
|
|
poly.AppendNode(ptTempL);
|
|
|
|
if(poly.Length()>0)
|
|
{
|
|
dc.PushClip(poly);
|
|
clipCount++;
|
|
}
|
|
|
|
}
|
|
dc << XLine(ptFromL, ptToL)<< XLine(ptFrom, ptTo);
|
|
}
|
|
|
|
for(long i=0;i<clipCount;i++)
|
|
dc.PopClip();
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
|
|
// From TDbPolyPathEnt
|
|
Acad::ErrorStatus
|
|
TDbScissorsStair::GetPathPoly(XPoly2D &polyPath,AcGeVector3d&normal) const
|
|
{
|
|
assertReadEnabled();
|
|
TDbLineStair stair1, stair2,stair3, stair4;
|
|
TDbSlab slab;
|
|
TDbHandRail rail, rail2, railTop,railTop2;
|
|
ExplodeTo(stair1, stair2, stair3, stair4, slab, rail, rail2, &railTop,&railTop2);
|
|
if(m_nStairFlag==SF_TOP)
|
|
railTop.GetBindPath(polyPath,normal);
|
|
else
|
|
rail.GetBindPath(polyPath,normal);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbScissorsStair::SetPathPoly(const XPoly2D &polyPath,const AcGeVector3d&normal)
|
|
{
|
|
return Acad::eNotApplicable;
|
|
}
|
|
|
|
BOOL TDbScissorsStair::CalSectPos(double &lSectPos,double &rSectPos,XPoint &ptLeft1,XPoint &ptRight1,XPoint &ptLeft2,XPoint &ptRight2)const
|
|
{
|
|
if(m_nStairFlag == SF_TOP)
|
|
return FALSE;
|
|
TDbLineStair stair1, stair2, stair3, stair4;
|
|
TDbSlab slab;
|
|
TDbHandRail rail, rail2, railTop,railTop2;
|
|
ExplodeTo(stair1, stair2, stair3, stair4, slab, rail, rail2, &railTop,&railTop2);
|
|
|
|
XDirectionCurve cvLeft1,cvRight1,cvLeft2,cvRight2;
|
|
double width=0; //剖断楼梯宽
|
|
double len=0; //剖断位置距楼梯起始点的距离
|
|
double length=0; //剖切梯段楼梯总长
|
|
int nSectStepNum=m_nSectStepNum; //剖断步数
|
|
if(nSectStepNum < 0) //负数调整为正的
|
|
{
|
|
nSectStepNum=m_nSectStepNum+m_nStepNum1+m_nStepNum2+1;
|
|
}
|
|
|
|
int nStepNum1=m_nStepNum1,nStepNum2=m_nStepNum2;
|
|
if(m_nStartSide!=OFFSET_LEFT)
|
|
{
|
|
nStepNum1=m_nStepNum2;
|
|
nStepNum2=m_nStepNum1;
|
|
}
|
|
|
|
if(nSectStepNum==m_nStepNum1
|
|
||nSectStepNum==nStepNum1+nStepNum2)
|
|
{
|
|
nSectStepNum--;
|
|
}
|
|
|
|
int nSectStair=GetSectStairPos();
|
|
len=(nSectStepNum-0.5)*m_nStepWidth;
|
|
if(nSectStair==0)
|
|
{
|
|
cvLeft1=stair1.GetSideCurve2d(0);
|
|
cvRight1=stair1.GetSideCurve2d(1);
|
|
cvLeft2=stair3.GetSideCurve2d(0);
|
|
cvRight2=stair3.GetSideCurve2d(1);
|
|
|
|
width=stair2.GetStairWidth()*0.5;
|
|
length=stair1.GetStairLength();
|
|
if(m_nStartSide!=OFFSET_LEFT)
|
|
{
|
|
len-=m_nStepWidth*nStepNum2;
|
|
}
|
|
}
|
|
else if(nSectStair==1)
|
|
{
|
|
cvLeft1=stair2.GetSideCurve2d(0);
|
|
cvRight1=stair2.GetSideCurve2d(1);
|
|
cvLeft2=stair4.GetSideCurve2d(0);
|
|
cvRight2=stair4.GetSideCurve2d(1);
|
|
|
|
width=stair2.GetStairWidth()*0.5;
|
|
length=stair2.GetStairLength();
|
|
if(m_nStartSide==OFFSET_LEFT)
|
|
{
|
|
len-=m_nStepWidth*nStepNum1;
|
|
}
|
|
}
|
|
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=0,nStairHeight2=0;
|
|
nStairHeight1=GetStepNum1()*GetStepHeight(); //边梯高
|
|
nStairHeight2=GetStepNum2()*GetStepHeight(); //中梯高
|
|
|
|
lSectPos=(len-dLen)/length;
|
|
rSectPos=(len+dLen)/length;
|
|
|
|
XPointDir2d pt;
|
|
cvLeft1.Polar(len-dLen, pt);
|
|
ptLeft1=pt;
|
|
cvRight1.Polar(len+dLen, pt);
|
|
ptRight1=pt;
|
|
|
|
cvLeft2.Polar(len-dLen, pt);
|
|
ptLeft2=pt;
|
|
cvRight2.Polar(len+dLen, pt);
|
|
ptRight2=pt;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//获得剖断线所在梯段：0，左梯段；1，右梯段；-1，没有剖断
|
|
int TDbScissorsStair::GetSectStairPos()const
|
|
{
|
|
if(m_nStairFlag==SF_TOP)
|
|
return -1;
|
|
|
|
if(abs(m_nSectStepNum)<1|| abs(m_nSectStepNum)>m_nStepNum1+m_nStepNum2)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
int nSectStepNum=m_nSectStepNum; //剖断步数
|
|
if(nSectStepNum < 0) //负数调整为正的
|
|
{
|
|
nSectStepNum=m_nSectStepNum+m_nStepNum1+m_nStepNum2+1;
|
|
}
|
|
|
|
int nStepNum1=m_nStepNum1,nStepNum2=m_nStepNum2;
|
|
if(m_nStartSide!=OFFSET_LEFT)
|
|
{
|
|
nStepNum1=m_nStepNum2;
|
|
nStepNum2=m_nStepNum1;
|
|
}
|
|
|
|
int nSectStair;
|
|
if((m_nStartSide==OFFSET_LEFT&&nSectStepNum<=nStepNum1)
|
|
||(m_nStartSide!=OFFSET_LEFT&&nSectStepNum>nStepNum2)
|
|
)
|
|
{
|
|
nSectStair=0; //剖断在左梯
|
|
}
|
|
else
|
|
{
|
|
nSectStair=1; //剖断在右梯
|
|
}
|
|
return nSectStair;
|
|
}
|
|
|
|
// 由平面二维点推算剖切步数
|
|
int TDbScissorsStair::HitSectPosByPoint2d(XPoint ptHit2d) const
|
|
{
|
|
TDbLineStair stair1, stair2,stair3,stair4;
|
|
TDbSlab slab;
|
|
TDbHandRail rail, rail2;
|
|
ExplodeTo(stair1, stair2, stair3,stair4, slab, 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 nStepNum1=m_nStepNum1,nStepNum2=m_nStepNum2;
|
|
if(m_nStartSide!=OFFSET_LEFT)
|
|
{
|
|
nStepNum1=m_nStepNum2;
|
|
nStepNum2=m_nStepNum1;
|
|
}
|
|
|
|
int nPosHit=-1;
|
|
if((ptHit2d&poly1)!=PR_OUTSIDE) //下端左梯段
|
|
{
|
|
XPoint ptPrj;
|
|
cvLeft1.ProjectToMe(ptHit2d, ptPrj);
|
|
nPosHit=(int)(ptPrj.Distance2d(cvLeft1.StartPoint())/m_nStepWidth);
|
|
if(m_nStartSide == OFFSET_LEFT)
|
|
{
|
|
nPosHit += 1;
|
|
}
|
|
else
|
|
{
|
|
nPosHit += nStepNum2+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) //下端右梯段
|
|
{
|
|
XPoint ptPrj;
|
|
cvLeft2.ProjectToMe(ptHit2d, ptPrj);
|
|
nPosHit=(int)(ptPrj.Distance2d(cvLeft2.StartPoint())/m_nStepWidth);
|
|
if(m_nStartSide == OFFSET_LEFT)
|
|
{
|
|
nPosHit += nStepNum1+1;
|
|
}
|
|
else
|
|
{
|
|
nPosHit += 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
XDirectionCurve cvLeft3=stair3.GetSideCurve2d(0);
|
|
XDirectionCurve cvRight3=stair3.GetSideCurve2d(1);
|
|
|
|
XPoly2D poly3(1);
|
|
poly3.AppendNode(cvLeft3.StartPoint());
|
|
poly3.AppendNode(cvRight3.StartPoint());
|
|
poly3.AppendNode(cvRight3.EndPoint());
|
|
poly3.AppendNode(cvLeft3.EndPoint());
|
|
if((ptHit2d&poly3)!=PR_OUTSIDE) //上端右梯段
|
|
{
|
|
XPoint ptPrj;
|
|
cvLeft3.ProjectToMe(ptHit2d, ptPrj);
|
|
nPosHit=(int)(ptPrj.Distance2d(cvLeft3.StartPoint())/m_nStepWidth);
|
|
if(m_nStartSide == OFFSET_LEFT)
|
|
{
|
|
nPosHit += 1;
|
|
}
|
|
else
|
|
{
|
|
nPosHit += nStepNum2+1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
XDirectionCurve cvLeft4=stair4.GetSideCurve2d(0);
|
|
XDirectionCurve cvRight4=stair4.GetSideCurve2d(1);
|
|
|
|
XPoly2D poly4(1);
|
|
poly4.AppendNode(cvLeft4.StartPoint());
|
|
poly4.AppendNode(cvRight4.StartPoint());
|
|
poly4.AppendNode(cvRight4.EndPoint());
|
|
poly4.AppendNode(cvLeft4.EndPoint());
|
|
if((ptHit2d&poly4)!=PR_OUTSIDE) //剖切上端左梯段
|
|
{
|
|
XPoint ptPrj;
|
|
cvLeft4.ProjectToMe(ptHit2d, ptPrj);
|
|
nPosHit=(int)(ptPrj.Distance2d(cvLeft4.StartPoint())/m_nStepWidth);
|
|
if(m_nStartSide == OFFSET_LEFT)
|
|
{
|
|
nPosHit += nStepNum1+1;
|
|
}
|
|
else
|
|
{
|
|
nPosHit += 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return nPosHit;
|
|
}
|
|
|
|
// Attribute Access method
|
|
double
|
|
TDbScissorsStair::GetTextHeight()const
|
|
{
|
|
assertReadEnabled();
|
|
return m_dTextHeight;
|
|
}
|
|
void
|
|
TDbScissorsStair::SetTextHeight(double h)
|
|
{
|
|
assertWriteEnabled();
|
|
m_dTextHeight=h;
|
|
}
|
|
|
|
Adesk::UInt8
|
|
TDbScissorsStair::GetStepNum1() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nStepNum1;
|
|
}
|
|
|
|
Adesk::UInt8
|
|
TDbScissorsStair::GetStepNum2() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nStepNum2;
|
|
}
|
|
|
|
double
|
|
TDbScissorsStair::GetStepHeight() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nStepHeight;
|
|
}
|
|
|
|
|
|
void
|
|
TDbScissorsStair::SetStepNum1(Adesk::UInt8 n)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nStepNum1=n;
|
|
}
|
|
|
|
void
|
|
TDbScissorsStair::SetStepNum2(Adesk::UInt8 n)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nStepNum2=n;
|
|
}
|
|
|
|
double
|
|
TDbScissorsStair::GetSlabSize() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nSlabSize;
|
|
}
|
|
|
|
double
|
|
TDbScissorsStair::GetRailHeight() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nRailHeight;
|
|
}
|
|
|
|
double
|
|
TDbScissorsStair::GetRailWidth() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nRailWidth;
|
|
}
|
|
|
|
double
|
|
TDbScissorsStair::GetRailDistToSide() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nRailDistToSide;
|
|
}
|
|
|
|
double
|
|
TDbScissorsStair::GetRailDistMid() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nRailDistMid;
|
|
}
|
|
|
|
double
|
|
TDbScissorsStair::GetRailDist() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nRailDist;
|
|
}
|
|
|
|
|
|
double
|
|
TDbScissorsStair::GetSpaceWidth() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nSpaceWidth;
|
|
}
|
|
|
|
double
|
|
TDbScissorsStair::GetStairWidth() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nStairWidth;
|
|
}
|
|
|
|
double
|
|
TDbScissorsStair::GetStepWidth() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nStepWidth;
|
|
}
|
|
|
|
Adesk::UInt8
|
|
TDbScissorsStair::GetStairFlag() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nStairFlag;
|
|
}
|
|
|
|
double
|
|
TDbScissorsStair::GetElevation() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_ptLocation.z;
|
|
}
|
|
|
|
XPoint
|
|
TDbScissorsStair::GetLocation() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_ptLocation;
|
|
}
|
|
|
|
double
|
|
TDbScissorsStair::GetRotation() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nRotation;
|
|
}
|
|
|
|
int
|
|
TDbScissorsStair::GetStartSide() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nStartSide;
|
|
}
|
|
|
|
int
|
|
TDbScissorsStair::GetAlignment() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nAlignment;
|
|
}
|
|
int
|
|
TDbScissorsStair::GetSectStepNum()const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nSectStepNum;
|
|
}
|
|
|
|
XPoint
|
|
TDbScissorsStair::GetMidRight2d() const
|
|
{
|
|
assertReadEnabled();
|
|
XPoint pt=GetMidLeft2d();
|
|
ads_polar(XPoint(pt), m_nRotation, m_nSpaceWidth, pt);
|
|
return pt;
|
|
}
|
|
|
|
XPoint
|
|
TDbScissorsStair::GetMidLeft2d() const
|
|
{
|
|
assertReadEnabled();
|
|
XPoint pt=m_ptLocation;
|
|
pt.z=0;
|
|
return pt;
|
|
}
|
|
|
|
void
|
|
TDbScissorsStair::SetSlabSize(double s)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nSlabSize=s;
|
|
}
|
|
|
|
void
|
|
TDbScissorsStair::SetRailHeight(double l)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nRailHeight=l;
|
|
}
|
|
|
|
void
|
|
TDbScissorsStair::SetRailWidth(double w)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nRailWidth=w;
|
|
}
|
|
|
|
|
|
void
|
|
TDbScissorsStair::SetRailDistToSide(double l)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nRailDistToSide=l;
|
|
}
|
|
void
|
|
TDbScissorsStair::SetRailDistMid(double l)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nRailDistMid=l;
|
|
}
|
|
|
|
|
|
void
|
|
TDbScissorsStair::SetRailDist(double l)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nRailDist=l;
|
|
}
|
|
|
|
void
|
|
TDbScissorsStair::SetStairFlag(Adesk::UInt8 flag)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nStairFlag=flag;
|
|
}
|
|
|
|
void
|
|
TDbScissorsStair::SetSpaceWidth(double w)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nSpaceWidth=w;
|
|
}
|
|
void
|
|
TDbScissorsStair::SetStepWidth(double w)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nStepWidth=w;
|
|
}
|
|
void
|
|
TDbScissorsStair::SetStairWidth(double w)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nStairWidth=w;
|
|
}
|
|
|
|
|
|
void
|
|
TDbScissorsStair::SetElevation(double elev)
|
|
{
|
|
assertWriteEnabled();
|
|
m_ptLocation.z = elev;
|
|
}
|
|
|
|
void
|
|
TDbScissorsStair::SetLocation(const XPoint &pt)
|
|
{
|
|
assertWriteEnabled();
|
|
m_ptLocation = pt;
|
|
}
|
|
|
|
void
|
|
TDbScissorsStair::SetRotation(double rot)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nRotation=rot;
|
|
}
|
|
|
|
void
|
|
TDbScissorsStair::SetStartSide(int nSide)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nStartSide=nSide;
|
|
}
|
|
|
|
void
|
|
TDbScissorsStair::SetAlignment(int nSide)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nAlignment=nSide;
|
|
}
|
|
|
|
void
|
|
TDbScissorsStair::SetStepHeight(double h)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nStepHeight=h;
|
|
}
|
|
void TDbScissorsStair::SetArrow(BOOL bTrue)
|
|
{
|
|
assertWriteEnabled();
|
|
if(bTrue)
|
|
m_nFlagEx|=SFEX_ARROW;
|
|
else
|
|
m_nFlagEx&=~SFEX_ARROW;
|
|
}
|
|
BOOL TDbScissorsStair::IsArrow() const
|
|
{
|
|
return ((m_nFlagEx&SFEX_ARROW)!=0);
|
|
}
|
|
BOOL TDbScissorsStair::IsAutoOutRail() const
|
|
{
|
|
return ((m_nFlagEx&SFEX_AUTOOUTRAIL)!=0);
|
|
}
|
|
// TArch6 memeber
|
|
BOOL TDbScissorsStair::IsAutoRail() const
|
|
{
|
|
return ((m_nFlagEx&SFEX_AUTORAIL)!=0);
|
|
}
|
|
|
|
BOOL TDbScissorsStair::IsOutRail()const
|
|
{
|
|
return (m_nFlagEx&SFEX_OUTRAIL)!=0;
|
|
}
|
|
void TDbScissorsStair::SetOutRail(BOOL bTrue)
|
|
{
|
|
assertWriteEnabled();
|
|
if(bTrue)
|
|
m_nFlagEx|=SFEX_OUTRAIL;
|
|
else
|
|
m_nFlagEx&=~SFEX_OUTRAIL;
|
|
}
|
|
BOOL TDbScissorsStair::IsArcPlatform() const
|
|
{
|
|
return ((m_nFlagEx&SFEX_ARCPLAT)!=0);
|
|
}
|
|
|
|
BOOL TDbScissorsStair::HasSideBeam(int nSide) const
|
|
{
|
|
int nBitFlag=nSide? SFEX_RBEAM : SFEX_LBEAM;
|
|
return ((m_nFlagEx&nBitFlag)!=0);
|
|
}
|
|
|
|
BOOL TDbScissorsStair::IsAscent() const
|
|
{
|
|
return ((m_nFlagEx&SFEX_ASCENT)!=0);
|
|
}
|
|
|
|
BOOL TDbScissorsStair::IsOnGround() const
|
|
{
|
|
return ((m_nFlagEx&SFEX_GROUND)!=0);
|
|
}
|
|
|
|
BOOL TDbScissorsStair::HasSlant() const
|
|
{
|
|
return ((m_nFlagEx&SFEX_SLANT)!=0);
|
|
}
|
|
void TDbScissorsStair::SetAutoOutRail(BOOL bTrue)
|
|
{
|
|
assertWriteEnabled();
|
|
if(bTrue)
|
|
m_nFlagEx |= SFEX_AUTOOUTRAIL;
|
|
else
|
|
m_nFlagEx &= ~SFEX_AUTOOUTRAIL;
|
|
}
|
|
void TDbScissorsStair::SetAutoRail(BOOL bTrue)
|
|
{
|
|
assertWriteEnabled();
|
|
if(bTrue)
|
|
m_nFlagEx |= SFEX_AUTORAIL;
|
|
else
|
|
m_nFlagEx &= ~SFEX_AUTORAIL;
|
|
}
|
|
|
|
void TDbScissorsStair::SetAscent(BOOL bTrue)
|
|
{
|
|
assertWriteEnabled();
|
|
if(bTrue)
|
|
m_nFlagEx |= SFEX_ASCENT;
|
|
else
|
|
m_nFlagEx &= ~SFEX_ASCENT;
|
|
}
|
|
|
|
void TDbScissorsStair::SetOnGround(BOOL bTrue)
|
|
{
|
|
assertWriteEnabled();
|
|
if(bTrue)
|
|
m_nFlagEx |= SFEX_GROUND;
|
|
else
|
|
m_nFlagEx &= ~SFEX_GROUND;
|
|
}
|
|
|
|
void TDbScissorsStair::SetSlant(BOOL bTrue)
|
|
{
|
|
assertWriteEnabled();
|
|
if(bTrue)
|
|
m_nFlagEx |= SFEX_SLANT;
|
|
else
|
|
m_nFlagEx &= ~SFEX_SLANT;
|
|
}
|
|
|
|
void TDbScissorsStair::SetArcPlatform(BOOL bTrue)
|
|
{
|
|
assertWriteEnabled();
|
|
if(bTrue)
|
|
m_nFlagEx |= SFEX_ARCPLAT;
|
|
else
|
|
m_nFlagEx &= ~SFEX_ARCPLAT;
|
|
}
|
|
|
|
void TDbScissorsStair::SetSideBeam(int nSide, BOOL bTrue)
|
|
{
|
|
assertWriteEnabled();
|
|
int nBitFlag=nSide? SFEX_RBEAM : SFEX_LBEAM;
|
|
if(bTrue)
|
|
m_nFlagEx |= nBitFlag;
|
|
else
|
|
m_nFlagEx &= ~nBitFlag;
|
|
}
|
|
|
|
|
|
double TDbScissorsStair::GetBeamHeight() const
|
|
{
|
|
return m_nBeamHeight;
|
|
}
|
|
|
|
double TDbScissorsStair::GetBeamThick() const
|
|
{
|
|
return m_nBeamThick;
|
|
}
|
|
|
|
double TDbScissorsStair::GetSlabThick() const
|
|
{
|
|
return m_nSlabThick;
|
|
}
|
|
|
|
AcDbObjectId TDbScissorsStair::GetLayerBeam3d() const
|
|
{
|
|
return m_idLayerBeam3d;
|
|
}
|
|
|
|
AcDbObjectId TDbScissorsStair::GetLayerStep3d() const
|
|
{
|
|
return m_idLayerStep3d;
|
|
}
|
|
|
|
AcDbObjectId TDbScissorsStair::GetLayerHand3d() const
|
|
{
|
|
return m_idLayerHand3d;
|
|
}
|
|
|
|
AcDbObjectId TDbScissorsStair::GetLayerRail3d() const
|
|
{
|
|
return m_idLayerRail3d;
|
|
}
|
|
AcDbObjectId TDbScissorsStair::GetLayerText() const
|
|
{
|
|
return m_idLayerText;
|
|
}
|
|
AcDbObjectId TDbScissorsStair::GetTextStyle() const
|
|
{
|
|
return m_idTextStyle;
|
|
}
|
|
AcDbObjectId TDbScissorsStair::GetLayerArrow() const
|
|
{
|
|
return m_idLayerArrow;
|
|
}
|
|
void TDbScissorsStair::SetBeamHeight(double val)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nBeamHeight = val;
|
|
}
|
|
|
|
void TDbScissorsStair::SetSlabThick(double val)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nSlabThick=val;
|
|
}
|
|
|
|
void TDbScissorsStair::SetBeamThick(double val)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nBeamThick=val;
|
|
}
|
|
|
|
void TDbScissorsStair::SetLayerBeam3d(AcDbObjectId idLayer)
|
|
{
|
|
assertWriteEnabled();
|
|
m_idLayerBeam3d=idLayer;
|
|
}
|
|
|
|
void TDbScissorsStair::SetLayerStep3d(AcDbObjectId idLayer)
|
|
{
|
|
assertWriteEnabled();
|
|
m_idLayerStep3d=idLayer;
|
|
}
|
|
|
|
|
|
void TDbScissorsStair::SetLayerHand3d(AcDbObjectId idLayer)
|
|
{
|
|
assertWriteEnabled();
|
|
m_idLayerHand3d=idLayer;
|
|
}
|
|
|
|
void TDbScissorsStair::SetLayerRail3d(AcDbObjectId idLayer)
|
|
{
|
|
assertWriteEnabled();
|
|
m_idLayerRail3d=idLayer;
|
|
}
|
|
void TDbScissorsStair::SetLayerText(AcDbObjectId idLayer)
|
|
{
|
|
assertWriteEnabled();
|
|
m_idLayerText=idLayer;
|
|
}
|
|
void TDbScissorsStair::SetTextStyle(AcDbObjectId idStyle)
|
|
{
|
|
assertWriteEnabled();
|
|
m_idTextStyle=idStyle;
|
|
}
|
|
void TDbScissorsStair::SetLayerArrow(AcDbObjectId idLayer)
|
|
{
|
|
assertWriteEnabled();
|
|
m_idLayerArrow=idLayer;
|
|
}
|
|
|
|
void TDbScissorsStair::SetSectStepNum(int n)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nSectStepNum=n;
|
|
}
|
|
|
|
double TDbScissorsStair::GetSectRotation()const
|
|
{
|
|
return m_dSectRotation;
|
|
}
|
|
|
|
void TDbScissorsStair::SetSectRotation(double r)
|
|
{
|
|
assertWriteEnabled();
|
|
m_dSectRotation=r;
|
|
}
|
|
|
|
|
|
//add by xlc 090426，箭头文字，动态数据
|
|
CString TDbScissorsStair::GetTextUp() const
|
|
{
|
|
assertReadEnabled();
|
|
CString sVal(_T("上"));
|
|
const TEntityFields &fd = GetFields();
|
|
fd.GFD(_T("上楼箭头文字"), sVal);
|
|
return sVal;
|
|
}
|
|
|
|
void TDbScissorsStair::SetTextUp(const TCHAR *sVal)
|
|
{
|
|
assertWriteEnabled();
|
|
TEntityFields &fd = Fields();
|
|
fd.SFD(_T("上楼箭头文字"), sVal);
|
|
}
|
|
CString TDbScissorsStair::GetTextDown() const
|
|
{
|
|
assertReadEnabled();
|
|
CString sVal(_T("下"));
|
|
const TEntityFields &fd = GetFields();
|
|
fd.GFD(_T("下楼箭头文字"), sVal);
|
|
return sVal;
|
|
}
|
|
|
|
void TDbScissorsStair::SetTextDown(const TCHAR *sVal)
|
|
{
|
|
assertWriteEnabled();
|
|
TEntityFields &fd = Fields();
|
|
fd.SFD(_T("下楼箭头文字"), sVal);
|
|
}
|
|
|
|
// sg add 101115，支持统一标高
|
|
bool TDbScissorsStair::UnifyElevation(double dElevation)
|
|
{
|
|
assertWriteEnabled();
|
|
SetElevation(dElevation);
|
|
return true;
|
|
}
|
|
|
|
// cet 2013.9.5 add
|
|
CString TDbScissorsStair::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 InitDbScissorsStair(BOOL bTrue)
|
|
{
|
|
if(bTrue)
|
|
{
|
|
TDbScissorsStair::rxInit();
|
|
acrxBuildClassHierarchy();
|
|
TDbScissorsStair::InitMatchProtocol(TRUE);
|
|
}
|
|
else
|
|
{
|
|
TDbScissorsStair::InitMatchProtocol(FALSE);
|
|
|
|
deleteAcRxClass(TDbScissorsStair::desc());
|
|
}
|
|
} |