3880 lines
115 KiB
C++
3880 lines
115 KiB
C++
#include "stdafx.h"
|
|
#include "TDbColumn.h"
|
|
#include "TchKernalGlobalFunc.h"
|
|
|
|
|
|
//T20 扩展数据定义 wlw add 150615
|
|
#define sKEY_LINESTAIR_SLABWIDTH _T("T20d1") // pc构件增加踏板宽度440
|
|
|
|
ACRX_NO_CONS_DEFINE_MEMBERS(ATSStair, ATSEntity);
|
|
|
|
// TArch5 ver=2
|
|
// TArch6 ver=3
|
|
const Adesk::UInt8 TDbStair::g_nVersion=3;
|
|
// Ver2 New: m_lSectionPos, m_rSectionPos;
|
|
TDbStair::TDbStair()
|
|
{
|
|
m_nStepNum=0;
|
|
m_nStepHeight=0.0;
|
|
m_nStairFlag=SF_2SECT + (1<<4);
|
|
//m_pTempRail=NULL;
|
|
m_lSectionPos=0.4;
|
|
m_rSectionPos=0.6;
|
|
|
|
// TArch 6 member
|
|
m_nFlagEx=0;
|
|
m_nBeamHeight=_AS_SYS_UNIT(200); //边梁高，坡道专用
|
|
m_nBeamThick=_AS_SYS_UNIT(120); //边梁厚度
|
|
m_nSlabThick=_AS_SYS_UNIT(120); //板厚或梁厚
|
|
}
|
|
|
|
TDbStair::~TDbStair()
|
|
{
|
|
}
|
|
|
|
BOOL TDbStair::IsValid() const
|
|
{
|
|
BOOL bRet=TDbEntity::IsValid();
|
|
if(!bRet)
|
|
return bRet;
|
|
bRet=(m_nStepNum>1 //踏步数目
|
|
&& GreatEqual(m_nBeamHeight, 0.0)
|
|
&& GreatEqual(m_nBeamThick, 0.0)
|
|
&& GreatEqual(m_nSlabThick, 0.0)
|
|
&& m_nStepHeight>_DIST_SNAP); //踏步高
|
|
return bRet;
|
|
}
|
|
|
|
// 提供对格式刷的支持
|
|
void TDbStair::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbEntity::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
|
|
TDbStair *pSrc=TDbStair::cast(pSrcEntity);
|
|
if(pSrc) {
|
|
m_nStepNum=pSrc->m_nStepNum; //踏步数目
|
|
m_nStepHeight=pSrc->m_nStepHeight; //踏步高
|
|
m_lSectionPos=pSrc->m_lSectionPos;
|
|
m_rSectionPos=pSrc->m_rSectionPos; // 0~1.0
|
|
m_nStairFlag=pSrc->m_nStairFlag;
|
|
// TArch 6 member
|
|
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())//add by whl on 060317
|
|
{
|
|
m_idLayerBeam3d=pSrc->m_idLayerBeam3d;
|
|
m_idLayerStep3d=pSrc->m_idLayerStep3d;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 从DWG读入数据:
|
|
Acad::ErrorStatus TDbStair::dwgInFields (AcDbDwgFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
Acad::ErrorStatus es = TDbEntity::dwgInFields(pFiler);
|
|
if(es != Acad::eOk) return es;
|
|
Adesk::UInt8 nVer;
|
|
pFiler->readItem(&nVer);
|
|
if(nVer>g_nVersion) {// Version is too new
|
|
return Acad::eMakeMeProxy;
|
|
}
|
|
pFiler->readItem(&m_nStepNum);
|
|
pFiler->readItem(&m_nStepHeight);
|
|
pFiler->readItem(&m_nStairFlag);
|
|
|
|
if(nVer>=2) {
|
|
pFiler->readItem(&m_lSectionPos);
|
|
pFiler->readItem(&m_rSectionPos);
|
|
if(nVer>=3) {
|
|
// TArch 6 member
|
|
pFiler->readItem(&m_nFlagEx);
|
|
pFiler->readItem(&m_nBeamHeight); //边梁高，坡道专用
|
|
pFiler->readItem(&m_nBeamThick); //边梁厚度
|
|
pFiler->readItem(&m_nSlabThick); //板厚或梁厚
|
|
pFiler->readItem(&m_idLayerStep3d);
|
|
pFiler->readItem(&m_idLayerBeam3d);
|
|
}
|
|
}
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbStair::dwgOutFields(AcDbDwgFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es = TDbEntity::dwgOutFields(pFiler);
|
|
if(es != Acad::eOk) return es;
|
|
|
|
if(g_nSaveTArchVer==5)
|
|
pFiler->writeItem((Adesk::UInt8)2);
|
|
else
|
|
pFiler->writeItem(g_nVersion);
|
|
pFiler->writeItem(m_nStepNum);
|
|
pFiler->writeItem(m_nStepHeight);
|
|
pFiler->writeItem(m_nStairFlag);
|
|
|
|
pFiler->writeItem(m_lSectionPos);
|
|
pFiler->writeItem(m_rSectionPos);
|
|
|
|
// TArch 6 member
|
|
if(g_nSaveTArchVer!=5) {
|
|
pFiler->writeItem(m_nFlagEx);
|
|
pFiler->writeItem(m_nBeamHeight); //边梁高，坡道专用
|
|
pFiler->writeItem(m_nBeamThick); //边梁厚度
|
|
pFiler->writeItem(m_nSlabThick); //板厚或梁厚
|
|
pFiler->writeItem(m_idLayerStep3d);
|
|
pFiler->writeItem(m_idLayerBeam3d);
|
|
}
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbStair::dxfInFields (AcDbDxfFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
Acad::ErrorStatus es = TDbEntity::dxfInFields(pFiler);
|
|
if(es!=Acad::eOk)
|
|
return es;
|
|
if (!pFiler->atSubclassData(_T("TDbStair"))) {
|
|
return Acad::eBadDxfSequence;
|
|
}
|
|
|
|
int fieldsFlags=0;
|
|
resbuf rb;
|
|
int n1, n2;
|
|
double r1, r2, r3;
|
|
while ((es == Acad::eOk)
|
|
&& ((es = pFiler->readResBuf(&rb)) == Acad::eOk)) {
|
|
switch (rb.restype) {
|
|
case AcDb::kDxfInt16:
|
|
n1=rb.resval.rint;
|
|
fieldsFlags |= 0x01;
|
|
break;
|
|
case AcDb::kDxfInt16+1:
|
|
n2=rb.resval.rint;
|
|
fieldsFlags |= 0x02;
|
|
break;
|
|
case AcDb::kDxfReal:
|
|
r1 = rb.resval.rreal;
|
|
fieldsFlags |= 0x04;
|
|
break;
|
|
case AcDb::kDxfReal+1:
|
|
r2=rb.resval.rreal;
|
|
fieldsFlags |= 0x08;
|
|
break;
|
|
case AcDb::kDxfReal+2:
|
|
r3=rb.resval.rreal;
|
|
fieldsFlags |= 0x10;
|
|
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;
|
|
//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&0x02)) {
|
|
pFiler->setError(Acad::eMissingDxfField,
|
|
_T("\nMissing DXF group code: 71"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
if (!(fieldsFlags&0x04)) {
|
|
pFiler->setError(Acad::eMissingDxfField,
|
|
_T("\nMissing DXF group code: 40"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
if(fieldsFlags&0x01)
|
|
m_nStairFlag=n1;
|
|
m_nStepNum=n2;
|
|
m_nStepHeight = r1;
|
|
if(fieldsFlags&0x08) {
|
|
if(r2>0.0 && r2<1.0)
|
|
m_lSectionPos=r2;
|
|
}
|
|
if(fieldsFlags&0x10) {
|
|
if(r3>0.0 && r3<1.0)
|
|
m_rSectionPos=r3;
|
|
}
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbStair::dxfOutFields(AcDbDxfFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
VERIFY(TDbEntity::dxfOutFields(pFiler)==Acad::eOk);
|
|
pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbLineStair"));
|
|
pFiler->writeInt16(AcDb::kDxfInt16, (Adesk::Int16)m_nStairFlag);
|
|
pFiler->writeInt16(AcDb::kDxfInt16+1, m_nStepNum);
|
|
pFiler->writeDouble(AcDb::kDxfReal, m_nStepHeight);
|
|
pFiler->writeDouble(AcDb::kDxfReal+1, m_lSectionPos);
|
|
pFiler->writeDouble(AcDb::kDxfReal+2, m_rSectionPos);
|
|
|
|
pFiler->writeInt32(90, m_nFlagEx);
|
|
pFiler->writeDouble(145, m_nBeamHeight);
|
|
pFiler->writeDouble(146, m_nBeamThick);
|
|
pFiler->writeDouble(147, m_nSlabThick);
|
|
pFiler->writeString(412, LayerId2String(m_idLayerStep3d));
|
|
pFiler->writeString(413, LayerId2String(m_idLayerBeam3d));
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
|
|
|
|
Acad::ErrorStatus
|
|
TDbStair::GetExtents2d(XPoint &ptLow, XPoint &ptUp) const
|
|
{
|
|
assertReadEnabled();
|
|
XPoly2D poly2d(1);
|
|
GetOutline2d(poly2d);
|
|
poly2d.GetExtend(ptLow, ptUp);
|
|
ptLow.z=ptUp.z=0;
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbStair::GetExtents(XPoint &ptLow, XPoint &ptUp) const
|
|
{
|
|
Acad::ErrorStatus es=Acad::eOk;
|
|
es=GetExtents2d(ptLow, ptUp);
|
|
ptLow.z=GetElevation();
|
|
ptUp.z=ptLow.z+GetStairHeight();
|
|
return es;
|
|
}
|
|
|
|
// sg add 101115，支持统一标高
|
|
bool TDbStair::UnifyElevation(double dElevation)
|
|
{
|
|
assertWriteEnabled();
|
|
SetElevation(dElevation);
|
|
return true;
|
|
}
|
|
|
|
const TCHAR *
|
|
TDbStair::GetDefaultLayer() const
|
|
{
|
|
return LAY_STAIR;
|
|
}
|
|
|
|
void
|
|
TDbStair::GetOutline2d(XPoly2D &poly) const
|
|
{
|
|
assertReadEnabled();
|
|
XDirectionCurve lCurve, rCurve;
|
|
lCurve=GetSideCurve2d(OFFSET_LEFT);
|
|
rCurve=GetSideCurve2d(OFFSET_RIGHT);
|
|
poly.AppendNode(lCurve.EndPoint(), -lCurve.GetBulge());
|
|
poly.AppendNode(lCurve.StartPoint());
|
|
poly.AppendNode(rCurve.StartPoint(), rCurve.GetBulge());
|
|
poly.AppendNode(rCurve.EndPoint());
|
|
poly.SetFlag(1);
|
|
}
|
|
|
|
XPoint
|
|
TDbStair::GetLowLeft2d() const
|
|
{
|
|
assertReadEnabled();
|
|
XDirectionCurve lCurve;
|
|
lCurve=GetSideCurve2d(OFFSET_LEFT);
|
|
return lCurve.StartPoint();
|
|
}
|
|
|
|
XPoint
|
|
TDbStair::GetUpLeft2d() const
|
|
{
|
|
assertReadEnabled();
|
|
XDirectionCurve lCurve;
|
|
lCurve=GetSideCurve2d(OFFSET_LEFT);
|
|
return lCurve.EndPoint();
|
|
}
|
|
|
|
XPoint
|
|
TDbStair::GetLowRight2d() const
|
|
{
|
|
assertReadEnabled();
|
|
XDirectionCurve rCurve;
|
|
rCurve=GetSideCurve2d(OFFSET_RIGHT);
|
|
return rCurve.StartPoint();
|
|
}
|
|
|
|
XPoint
|
|
TDbStair::GetUpRight2d() const
|
|
{
|
|
assertReadEnabled();
|
|
XDirectionCurve rCurve;
|
|
rCurve=GetSideCurve2d(OFFSET_RIGHT);
|
|
return rCurve.EndPoint();
|
|
}
|
|
|
|
double
|
|
TDbStair::GetStepHeight() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nStepHeight;
|
|
}
|
|
|
|
double
|
|
TDbStair::GetStairHeight() const
|
|
{
|
|
return (GetStepHeight()*GetStepNum());
|
|
}
|
|
|
|
|
|
int
|
|
TDbStair::GetStepNum() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nStepNum;
|
|
}
|
|
|
|
void
|
|
TDbStair::SetStepNum(int nNum)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nStepNum=nNum;
|
|
}
|
|
|
|
void
|
|
TDbStair::SetStepHeight(double h)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nStepHeight=h;
|
|
}
|
|
|
|
void
|
|
TDbStair::Set2DFlag(int nFlag2d)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nStairFlag = nFlag2d + (Get3DFlag()<<4);
|
|
}
|
|
|
|
void
|
|
TDbStair::Set3DFlag(int nFlag3d)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nStairFlag = Get2DFlag() + (nFlag3d<<4);
|
|
}
|
|
|
|
int
|
|
TDbStair::Get2DFlag() const
|
|
{
|
|
assertReadEnabled();
|
|
int nRet=(m_nStairFlag&(0x01|0x02|0x04|0x08));
|
|
return nRet;
|
|
}
|
|
|
|
int
|
|
TDbStair::Get3DFlag() const
|
|
{
|
|
assertReadEnabled();
|
|
int nFlag=(m_nStairFlag>>4);
|
|
return nFlag;
|
|
}
|
|
|
|
BOOL TDbStair::Has3D() const
|
|
{
|
|
int nFlag=Get3DFlag();
|
|
return ((nFlag&SF_HAS3D)!=0);
|
|
}
|
|
|
|
|
|
BOOL
|
|
TDbStair::GetSideBeam(int nSide) const
|
|
{
|
|
assertReadEnabled();
|
|
int nFlag3d=Get3DFlag();
|
|
int nTest=(nSide==OFFSET_LEFT? SF_LBEAM : SF_RBEAM);
|
|
return (/*(nFlag3d&SF_HAS3D) &&*/ (nFlag3d&nTest));
|
|
}
|
|
|
|
void
|
|
TDbStair::SetSideBeam(int nSide, BOOL bTrue)
|
|
{
|
|
assertWriteEnabled();
|
|
int nFlag2d=Get2DFlag();
|
|
int nFlag3d=Get3DFlag();
|
|
int nTest=(nSide==OFFSET_LEFT? SF_LBEAM : SF_RBEAM);
|
|
if(bTrue)
|
|
nFlag3d |= nTest;
|
|
else
|
|
nFlag3d &=~nTest;
|
|
m_nStairFlag = nFlag2d + (nFlag3d<<4);
|
|
}
|
|
|
|
void TDbStair::SetHas3D(BOOL bTrue)
|
|
{
|
|
assertWriteEnabled();
|
|
int nFlag2d=Get2DFlag();
|
|
int nFlag3d=Get3DFlag();
|
|
if(bTrue)
|
|
nFlag3d |= SF_HAS3D;
|
|
else
|
|
nFlag3d &=~SF_HAS3D;
|
|
m_nStairFlag = nFlag2d + (nFlag3d<<4);
|
|
}
|
|
|
|
void
|
|
TDbStair::AddTempRail(const TDbHandRail *pRail)
|
|
{
|
|
//m_pTempRail=(TDbHandRail *)pRail;
|
|
if(pRail)
|
|
m_tempRailArray.append((void *)pRail);
|
|
}
|
|
|
|
|
|
double
|
|
TDbStair::GetStepSideWidth(int idx, int nSide) const
|
|
{
|
|
ASSERT(GetStepNum()>1);
|
|
XDirectionCurve cv=GetSideCurve2d(nSide);
|
|
return cv.GetLength()/(GetStepNum()-1);
|
|
|
|
}
|
|
|
|
double
|
|
TDbStair::GetSectionPos(int nSide) const
|
|
{
|
|
return (nSide? m_rSectionPos : m_lSectionPos);
|
|
}
|
|
|
|
void
|
|
TDbStair::SetSectionPos(int nSide, double nRatio)
|
|
{
|
|
assertWriteEnabled();
|
|
if(nRatio>0 && nRatio<1) {
|
|
double &val=nSide? m_rSectionPos : m_lSectionPos;
|
|
val=nRatio;
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
TDbStair::GetSectionPoly(XPoly &polyDown, XPoly &polyUp, XPoly &polyMid) const
|
|
{
|
|
double nAng = PI/8.0;
|
|
XDirectionCurve lCurve=GetSideCurve2d(OFFSET_LEFT),
|
|
rCurve=GetSideCurve2d(OFFSET_RIGHT);
|
|
lCurve.SetLineFlag(LS_FINITE);
|
|
rCurve.SetLineFlag(LS_FINITE);
|
|
|
|
XPoint ptFrom, ptTo;
|
|
ptFrom = XLine(lCurve.StartPoint(), rCurve.StartPoint()).MidPoint();
|
|
ptTo = XLine(lCurve.EndPoint(), rCurve.EndPoint()).MidPoint();
|
|
int nIntNum;
|
|
XPoint ptInter[2];
|
|
XPointDir2d ptTemp1, ptTemp2;
|
|
lCurve.Polar(lCurve.GetLength()*m_lSectionPos, ptTemp1);
|
|
rCurve.Polar(rCurve.GetLength()*m_rSectionPos, ptTemp2);
|
|
XLine lnCen(ptTemp1, ptTemp2);
|
|
XPoint ptCen;
|
|
ptCen = lnCen.MidPoint();
|
|
double nSectDir=lnCen.Direction();
|
|
|
|
double nOffDist = _AS_SYS_UNIT(50.0);
|
|
XLine lnDown=lnCen.Offset(nOffDist),
|
|
lnUp=lnCen.Offset(-nOffDist);
|
|
|
|
nIntNum=lCurve.Intersection(lnUp, ptInter[0], ptInter[1]);
|
|
if(!nIntNum) return FALSE;
|
|
else if(nIntNum==1) lnUp.StartPoint()=ptInter[0];
|
|
else lnUp.StartPoint()=XLine(ptInter[0], ptInter[1]).NearPoint(ptTemp1);
|
|
nIntNum=rCurve.Intersection(lnUp, ptInter[0], ptInter[1]);
|
|
if(!nIntNum) return FALSE;
|
|
else if(nIntNum==1) lnUp.EndPoint()=ptInter[0];
|
|
else lnUp.EndPoint()=XLine(ptInter[0], ptInter[1]).NearPoint(ptTemp2);
|
|
|
|
nIntNum=lCurve.Intersection(lnDown, ptInter[0], ptInter[1]);
|
|
if(!nIntNum) return FALSE;
|
|
else if(nIntNum==1) lnDown.StartPoint()=ptInter[0];
|
|
else lnDown.StartPoint()=XLine(ptInter[0], ptInter[1]).NearPoint(ptTemp1);
|
|
nIntNum=rCurve.Intersection(lnDown, ptInter[0], ptInter[1]);
|
|
if(!nIntNum) return FALSE;
|
|
else if(nIntNum==1) lnDown.EndPoint()=ptInter[0];
|
|
else lnDown.EndPoint()=XLine(ptInter[0], ptInter[1]).NearPoint(ptTemp2);
|
|
|
|
XPoint ptUp1, ptUp2, ptDown1, ptDown2, ptUp, ptDown, ptMid1, ptMid2;
|
|
ads_polar(ptCen, nSectDir+115.0/180.0*PI, _AS_SYS_UNIT(270.0)/2.0, ptUp);
|
|
ads_polar(ptCen, nSectDir-75.0/180*PI, _AS_SYS_UNIT(270.0)/2.0, ptDown);
|
|
|
|
XLine lnLeft(ptUp, CT_std_angle(nSectDir+75.0/180*PI));
|
|
XLine lnRight(ptDown, CT_std_angle(nSectDir+75.0/180*PI));
|
|
if(lnUp.Intersection(&lnLeft, ptUp1)!=1 ||
|
|
lnUp.Intersection(&lnRight, ptUp2)!=1)
|
|
return FALSE;
|
|
if(lnDown.Intersection(&lnLeft, ptDown1)!=1 ||
|
|
lnDown.Intersection(&lnRight, ptDown2)!=1)
|
|
return FALSE;
|
|
if(lnCen.Intersection(&lnLeft, ptMid1)!=1 ||
|
|
lnCen.Intersection(&lnRight, ptMid2)!=1)
|
|
return FALSE;
|
|
polyDown.Reset();
|
|
polyUp.Reset();
|
|
polyMid.Reset();
|
|
|
|
polyUp.Append(new XPoint(lnUp.StartPoint()));
|
|
polyUp.Append(new XPoint(ptUp1));
|
|
polyUp.Append(new XPoint(ptUp));
|
|
polyUp.Append(new XPoint(ptUp2));
|
|
polyUp.Append(new XPoint(lnUp.EndPoint()));
|
|
|
|
polyDown.Append(new XPoint(lnDown.EndPoint()));
|
|
polyDown.Append(new XPoint(ptDown2));
|
|
polyDown.Append(new XPoint(ptDown));
|
|
polyDown.Append(new XPoint(ptDown1));
|
|
polyDown.Append(new XPoint(lnDown.StartPoint()));
|
|
|
|
polyMid.Append(new XPoint(lnCen.EndPoint()));
|
|
polyMid.Append(new XPoint(ptMid2));
|
|
polyMid.Append(new XPoint(ptDown));
|
|
polyMid.Append(new XPoint(ptUp));
|
|
polyMid.Append(new XPoint(ptMid1));
|
|
polyMid.Append(new XPoint(lnCen.StartPoint()));
|
|
return TRUE;
|
|
}
|
|
|
|
// 绘制边梁或侧边的一截
|
|
void TDbStair::DrawAscentSideSeg(XExplodeDraw &dc, const XDirectionCurve &seg, int nSide, BOOL bVisStart, BOOL bVisEnd) const
|
|
{
|
|
X3DFace faceOutside;
|
|
faceOutside.GetVertex(0) = faceOutside.GetVertex(3) = seg.StartPoint();
|
|
faceOutside.GetVertex(1) = faceOutside.GetVertex(2) = seg.EndPoint();
|
|
//faceOutside.SetElevation(nElev);
|
|
double nElev = GetElevation();
|
|
if(IsOnGround()) {
|
|
faceOutside.GetVertex(2).z = faceOutside.GetVertex(3).z = nElev;
|
|
} else {
|
|
faceOutside.GetVertex(2).z -= m_nSlabThick;
|
|
faceOutside.GetVertex(3).z -= m_nSlabThick;
|
|
}
|
|
BOOL bSideBeam = GetSideBeam(nSide);
|
|
if(bSideBeam) {
|
|
faceOutside.GetVertex(0).z += m_nBeamHeight;
|
|
faceOutside.GetVertex(1).z += m_nBeamHeight;
|
|
}
|
|
|
|
int nFaceFlag = faceOutside.GetFlag();
|
|
if(!bVisStart)
|
|
nFaceFlag |= 0x08;
|
|
if(!bVisEnd)
|
|
nFaceFlag |= 0x02;
|
|
faceOutside.SetFlag(nFaceFlag);
|
|
|
|
double nFactor = (nSide? -1.0 : 1.0);
|
|
if(bSideBeam) { //绘制顶和内侧
|
|
XDirectionCurve seg0(seg);
|
|
seg0.SetElevation(0.0);
|
|
double nDir1=CT_std_angle(seg0.IDirection(0) - nFactor*PI/2.0);
|
|
double nDir2=CT_std_angle(seg0.IDirection(1) + nFactor*PI/2.0);
|
|
X3DFace faceTop, faceInside;
|
|
faceTop.SetVertex(0, faceOutside.GetVertex(0));
|
|
faceTop.SetVertex(3, faceOutside.GetVertex(1));
|
|
ads_polar(faceTop.GetVertex(0), nDir1, m_nBeamThick, faceTop.GetVertex(1));
|
|
ads_polar(faceTop.GetVertex(3), nDir2, m_nBeamThick, faceTop.GetVertex(2));
|
|
|
|
faceInside.GetVertex(0)=faceInside.GetVertex(1)=faceTop.GetVertex(1);
|
|
faceInside.GetVertex(3)=faceInside.GetVertex(2)=faceTop.GetVertex(2);
|
|
faceInside.GetVertex(1).z -= m_nBeamHeight;
|
|
faceInside.GetVertex(2).z -= m_nBeamHeight;
|
|
|
|
int nFaceTopFlag = faceTop.GetFlag(),
|
|
nFaceInsideFlag = faceInside.GetFlag();
|
|
if(!bVisStart)
|
|
{
|
|
nFaceTopFlag |= 0x01;
|
|
nFaceInsideFlag |= 0x01;
|
|
}
|
|
|
|
if(!bVisEnd)
|
|
{
|
|
nFaceTopFlag |= 0x04;
|
|
nFaceInsideFlag |= 0x04;
|
|
}
|
|
|
|
faceTop.SetFlag(nFaceTopFlag);
|
|
faceInside.SetFlag(nFaceInsideFlag);
|
|
|
|
if(nSide)
|
|
{
|
|
faceInside.Reverse();
|
|
faceTop.Reverse();
|
|
}
|
|
|
|
dc.DrawFace(faceTop);
|
|
dc.DrawFace(faceInside);
|
|
}
|
|
if(nSide)
|
|
faceOutside.Reverse(); //纠正法向
|
|
dc.DrawFace(faceOutside);
|
|
}
|
|
|
|
// 绘制坡道的坡面
|
|
// bSlant -- 是否绘制突起
|
|
// bRev －是否逆转法向，用于bSlant==0
|
|
// bVisStart, bVisEnd－用于bSlant==0
|
|
void TDbStair::DrawAscentSlant(XExplodeDraw &dc, const XLine &lnLeft, const XLine& lnRight,
|
|
BOOL bVisStart, BOOL bVisEnd, BOOL bSlant, BOOL bRev) const
|
|
{
|
|
if(!bSlant)
|
|
{
|
|
X3DFace face;
|
|
face.GetVertex(0)=lnLeft.StartPoint();
|
|
face.GetVertex(1)=lnRight.StartPoint();
|
|
face.GetVertex(2)=lnRight.EndPoint();
|
|
face.GetVertex(3)=lnLeft.EndPoint();
|
|
|
|
int nFlag = face.GetFlag();
|
|
if(!bVisStart)
|
|
nFlag |= 0x01;
|
|
if(!bVisStart)
|
|
nFlag |= 0x04;
|
|
face.SetFlag(nFlag);
|
|
|
|
if(bRev)
|
|
face.Reverse();
|
|
dc.DrawFace(face);
|
|
}
|
|
else
|
|
{
|
|
X3DFace lFace, rFace, vFace, face;
|
|
face.GetVertex(0)=lnLeft.StartPoint();
|
|
face.GetVertex(1)=lnRight.StartPoint();
|
|
face.GetVertex(2)=lnRight.EndPoint();
|
|
face.GetVertex(3)=lnLeft.EndPoint();
|
|
face.GetVertex(2).z += 10.0;
|
|
face.GetVertex(3).z += 10.0;
|
|
dc.DrawFace(face);
|
|
|
|
lFace.GetVertex(0)=lFace.GetVertex(3)=lnLeft.StartPoint();
|
|
lFace.GetVertex(1)=lFace.GetVertex(2)=lnLeft.EndPoint();
|
|
lFace.GetVertex(1).z += 10.0;
|
|
int nFlag = lFace.GetFlag();
|
|
nFlag |= 0x04;
|
|
lFace.SetFlag(nFlag);
|
|
dc.DrawFace(lFace);
|
|
|
|
rFace.GetVertex(0)=rFace.GetVertex(3)=lnRight.StartPoint();
|
|
rFace.GetVertex(1)=rFace.GetVertex(2)=lnRight.EndPoint();
|
|
rFace.GetVertex(1).z += 10.0;
|
|
nFlag = rFace.GetFlag();
|
|
nFlag |= 0x04;
|
|
rFace.SetFlag(nFlag);
|
|
rFace.Reverse();
|
|
dc.DrawFace(rFace);
|
|
|
|
vFace.GetVertex(0)=vFace.GetVertex(1)=lnLeft.EndPoint();
|
|
vFace.GetVertex(2)=vFace.GetVertex(3)=lnRight.EndPoint();
|
|
vFace.GetVertex(1).z += 10.0;
|
|
vFace.GetVertex(2).z += 10.0;
|
|
dc.DrawFace(vFace);
|
|
}
|
|
}
|
|
|
|
|
|
//绘制坡道侧面
|
|
void TDbStair::DrawAscentSide(XExplodeDraw &dc, const XDirectionCurve &seg, int nSide) const
|
|
{
|
|
double nFactor=nSide? -1.0 : 1.0;
|
|
double nElev=GetElevation();
|
|
BOOL bSideBeam=GetSideBeam(nSide);
|
|
if(seg.Is(CURVE_LINE)) {
|
|
XDirectionCurve ln = seg;
|
|
ln.StartPoint().z = nElev;
|
|
ln.EndPoint().z = GetStairHeight() + nElev;
|
|
DrawAscentSideSeg(dc, ln, nSide, TRUE, TRUE);
|
|
} else { // Arc side
|
|
XPointDir2d ptLast;
|
|
seg.Polar(0, ptLast);
|
|
ptLast.z = nElev;
|
|
ASSERT(m_nStepNum>=1);
|
|
double nStepWidth=seg.GetLength()/m_nStepNum;
|
|
for(int i=1; i<=m_nStepNum; i++) {
|
|
XPointDir2d ptNext;
|
|
seg.Polar(i*nStepWidth, ptNext);
|
|
ptNext.z = ptLast.z + m_nStepHeight;
|
|
XDirectionCurve segNew(ptLast, ptNext, seg.GetBulge()/m_nStepNum, LS_FINITE);
|
|
//segNew.SetPoints(XPoint(ptLast.x, ptLast.y), XPoint(ptNext.x, ptNext.y));
|
|
//segNew.StartPoint().z=ptLast.z; segNew.EndPoint().z=ptNext.z;
|
|
DrawAscentSideSeg(dc, segNew, nSide, (i==1), (i==m_nStepNum));
|
|
ptLast=ptNext;
|
|
}
|
|
} // end Arc Side
|
|
|
|
if(bSideBeam) { //封首末端
|
|
XPoint ptS, ptE;
|
|
XDirectionCurve segTemp(seg);
|
|
segTemp.SetElevation(0.0);
|
|
double nDir1=CT_std_angle(segTemp.IDirection(0) - nFactor*PI/2);
|
|
double nDir2=CT_std_angle(segTemp.IDirection(1) + nFactor*PI/2);
|
|
ads_polar(seg.StartPoint(), nDir1, m_nBeamThick, ptS);
|
|
ads_polar(seg.EndPoint(), nDir2, m_nBeamThick, ptE);
|
|
X3DFace faceS, faceE;
|
|
faceS.GetVertex(0)=seg.StartPoint();
|
|
faceS.GetVertex(1)=ptS;
|
|
faceS.GetVertex(2)=ptS;
|
|
faceS.GetVertex(3)=seg.StartPoint();
|
|
faceS.SetElevation(nElev);
|
|
if(!IsOnGround()) {
|
|
faceS.GetVertex(0).z = faceS.GetVertex(1).z = nElev - m_nSlabThick;
|
|
}
|
|
faceS.GetVertex(2).z += m_nBeamHeight;
|
|
faceS.GetVertex(3).z += m_nBeamHeight;
|
|
int nFlag = faceS.GetFlag();
|
|
nFlag |= 0x02;
|
|
faceS.SetFlag(nFlag);
|
|
|
|
faceE.GetVertex(0)=seg.EndPoint(); faceE.GetVertex(1)=seg.EndPoint();
|
|
faceE.GetVertex(2)=ptE; faceE.GetVertex(3)=ptE;
|
|
faceE.SetElevation(nElev+GetStairHeight());
|
|
if(IsOnGround()) {
|
|
faceE.GetVertex(0).z=faceE.GetVertex(3).z=nElev;
|
|
} else {
|
|
faceE.GetVertex(0).z -= m_nSlabThick;
|
|
faceE.GetVertex(3).z -= m_nSlabThick;
|
|
}
|
|
faceE.GetVertex(1).z += m_nBeamHeight;
|
|
faceE.GetVertex(2).z += m_nBeamHeight;
|
|
nFlag = faceE.GetFlag();
|
|
nFlag |= 0x04;
|
|
faceE.SetFlag(nFlag);
|
|
|
|
if(nSide) {
|
|
faceS.Reverse();
|
|
faceE.Reverse();
|
|
}
|
|
dc.DrawFace(faceS);
|
|
dc.DrawFace(faceE);
|
|
}
|
|
}
|
|
|
|
|
|
Acad::ErrorStatus
|
|
TDbStair::DrawAscent3d(XExplodeDraw &dc) const
|
|
{
|
|
if(!IsAscent())
|
|
return Acad::eInvalidInput;
|
|
XDirectionCurve lCurve1=GetSideCurve2d(OFFSET_LEFT),
|
|
rCurve1=GetSideCurve2d(OFFSET_RIGHT);
|
|
XDirectionCurve lCurve(lCurve1), rCurve(rCurve1);
|
|
if(GetSideBeam(OFFSET_LEFT))
|
|
lCurve = lCurve1.Offset(m_nBeamThick, LS_FINITE);
|
|
if(GetSideBeam(OFFSET_RIGHT))
|
|
rCurve = rCurve.Offset(-m_nBeamThick, LS_FINITE);
|
|
|
|
//AcDbObjectId idLay=dc.GetLayerId();
|
|
TMasterProperties prop;
|
|
dc.BackUpProperties(prop);
|
|
if(GetSideBeam(OFFSET_LEFT) && !!m_idLayerBeam3d)
|
|
dc.SetColorLayer(colorIndex(), m_idLayerBeam3d);
|
|
DrawAscentSide(dc, lCurve1, OFFSET_LEFT);
|
|
dc.RestoreProperties(prop);
|
|
|
|
if(GetSideBeam(OFFSET_RIGHT) && !!m_idLayerBeam3d)
|
|
dc.SetColorLayer(colorIndex(), m_idLayerBeam3d);
|
|
DrawAscentSide(dc, rCurve1, OFFSET_RIGHT);
|
|
dc.RestoreProperties(prop);
|
|
|
|
dc.SetColorLayer(colorIndex(), m_idLayerStep3d);
|
|
|
|
double nElev = GetElevation();
|
|
if(lCurve.Is(CURVE_LINE) && rCurve.Is(CURVE_LINE) && !HasSlant()) { //绘制直光滑坡面
|
|
XLine lnLeft=lCurve.GetLine();
|
|
XLine lnRight=rCurve.GetLine();
|
|
lnLeft.StartPoint().z = lnRight.StartPoint().z = nElev;
|
|
lnLeft.EndPoint().z = lnRight.EndPoint().z = nElev + GetStairHeight();
|
|
DrawAscentSlant(dc, lnLeft, lnRight, TRUE, TRUE, FALSE, FALSE);
|
|
} else {
|
|
XPointDir2d ptLast1, ptLast2;
|
|
lCurve.Polar(0, ptLast1);
|
|
rCurve.Polar(0, ptLast2);
|
|
ptLast1.z = ptLast2.z = nElev;
|
|
ASSERT(m_nStepNum>=1);
|
|
double nStepWidth1=lCurve.GetLength()/m_nStepNum; //与楼梯不一样，梯段的长度为步数×步距
|
|
double nStepWidth2=rCurve.GetLength()/m_nStepNum;
|
|
BOOL bHasSlant=HasSlant();
|
|
double nStepHeight = m_nStepHeight; //GetStairHeight()/(m_nStepNum-1);
|
|
for(int i=1; i<=m_nStepNum; i++) {
|
|
XPointDir2d ptNext1, ptNext2;
|
|
lCurve.Polar(i*nStepWidth1, ptNext1);
|
|
rCurve.Polar(i*nStepWidth2, ptNext2);
|
|
ptNext1.z = ptLast1.z + nStepHeight;
|
|
ptNext2.z = ptLast2.z + nStepHeight;
|
|
XLine lnLeft=XLine(ptLast1, ptNext1);
|
|
XLine lnRight=XLine(ptLast2,ptNext2);
|
|
DrawAscentSlant(dc, lnLeft, lnRight, (i==1),
|
|
(i==m_nStepNum), (bHasSlant&&(i!=m_nStepNum)));
|
|
ptLast1=ptNext1;
|
|
ptLast2=ptNext2;
|
|
}
|
|
|
|
}
|
|
|
|
if(!IsOnGround()) { //绘制底面
|
|
if(lCurve.Is(CURVE_LINE) && rCurve.Is(CURVE_LINE)) { //
|
|
XLine lnLeft = lCurve1.GetLine();
|
|
XLine lnRight = rCurve1.GetLine();
|
|
lnLeft.StartPoint().z = lnRight.StartPoint().z = nElev - m_nSlabThick;
|
|
lnLeft.EndPoint().z = lnRight.EndPoint().z = nElev + GetStairHeight() - m_nSlabThick;
|
|
DrawAscentSlant(dc, lnLeft, lnRight, TRUE, TRUE, FALSE, TRUE);
|
|
} else {
|
|
XPointDir2d ptLast1, ptLast2;
|
|
lCurve1.Polar(0, ptLast1);
|
|
rCurve1.Polar(0, ptLast2);
|
|
ptLast1.z = ptLast2.z = nElev;
|
|
ASSERT(m_nStepNum>=1);
|
|
double nStepWidth1=lCurve1.GetLength()/m_nStepNum;
|
|
double nStepWidth2=rCurve1.GetLength()/m_nStepNum;
|
|
for(int i=1; i<=m_nStepNum; i++) {
|
|
XPointDir2d ptNext1, ptNext2;
|
|
lCurve1.Polar(i*nStepWidth1, ptNext1);
|
|
rCurve1.Polar(i*nStepWidth2, ptNext2);
|
|
ptNext1.z = ptLast1.z + m_nStepHeight;
|
|
ptNext2.z = ptLast2.z + m_nStepHeight;
|
|
XLine lnLeft=XLine(ptLast1, ptNext1);
|
|
XLine lnRight=XLine(ptLast2,ptNext2);
|
|
|
|
lnLeft.StartPoint().z -= m_nSlabThick;
|
|
lnLeft.EndPoint().z -= m_nSlabThick;
|
|
lnRight.StartPoint().z -= m_nSlabThick;
|
|
lnRight.EndPoint().z -= m_nSlabThick;
|
|
DrawAscentSlant(dc, lnLeft, lnRight, (i==1),
|
|
(i==m_nStepNum-1), FALSE, TRUE);
|
|
ptLast1=ptNext1;
|
|
ptLast2=ptNext2;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 封首末断面
|
|
X3DFace faceS, faceE;
|
|
faceS.GetVertex(0)=faceS.GetVertex(3)=lCurve.StartPoint();
|
|
faceS.GetVertex(1)=faceS.GetVertex(2)=rCurve.StartPoint();
|
|
faceS.SetElevation(nElev);
|
|
|
|
int nFlag = faceS.GetFlag();
|
|
if(!IsOnGround())
|
|
{
|
|
faceS.GetVertex(0).z -= m_nSlabThick;
|
|
faceS.GetVertex(1).z -= m_nSlabThick;
|
|
nFlag |= (0x02|0x08);
|
|
faceS.SetFlag(nFlag);
|
|
dc.DrawFace(faceS);
|
|
}
|
|
faceE.GetVertex(0)=faceE.GetVertex(1)=lCurve.EndPoint();
|
|
faceE.GetVertex(2)=faceE.GetVertex(3)=rCurve.EndPoint();
|
|
faceE.SetElevation(nElev+GetStairHeight());
|
|
if(IsOnGround()) {
|
|
faceE.GetVertex(0).z = faceE.GetVertex(3).z = nElev;
|
|
} else {
|
|
faceE.GetVertex(0).z -= m_nSlabThick;
|
|
faceE.GetVertex(3).z -= m_nSlabThick;
|
|
}
|
|
|
|
nFlag = faceE.GetFlag();
|
|
nFlag |= (0x01|0x04);
|
|
faceE.SetFlag(nFlag);
|
|
dc.DrawFace(faceE);
|
|
|
|
dc.RestoreProperties(prop);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbStair::ExplodeOrDraw3d(XExplodeDraw &dc) const
|
|
{
|
|
assertReadEnabled();
|
|
if(!IsValid())
|
|
return Acad::eInvalidInput;
|
|
if(!Has3D())
|
|
return Acad::eOk;
|
|
|
|
//add by whl on 060404
|
|
//解决TDbStair和TDbMultiStair在2006平台多三维视口时切换为平面视口时崩溃问题
|
|
// extern double g_nAcadVer;
|
|
if(g_nAcadVer>16.11)
|
|
dc.SetSelectionMarker(1);
|
|
if(IsAscent())
|
|
return DrawAscent3d(dc);
|
|
|
|
XDirectionCurve lCurve1=GetSideCurve2d(OFFSET_LEFT),
|
|
rCurve1=GetSideCurve2d(OFFSET_RIGHT);
|
|
XDirectionCurve lCurve(lCurve1), rCurve(rCurve1);
|
|
|
|
if(GetSideBeam(OFFSET_LEFT)) {
|
|
lCurve = lCurve1.Offset(m_nBeamThick, LS_FINITE);
|
|
//XDirectionCurve cvRail=lCurve1.Offset(nGirderThick/2.0, LS_FINITE);
|
|
XPoly2D polyRail;
|
|
lCurve.AsPoly2D(polyRail);
|
|
TDbHandRail *pRail=new TDbHandRail;
|
|
pRail->setPropertiesFrom(this);
|
|
pRail->SetOutline(polyRail);
|
|
pRail->SetHeight(max(GetStepHeight()+m_nSlabThick,GetBeamHeight()));
|
|
pRail->SetWidth(m_nBeamThick);
|
|
pRail->SetStyle(TDbHandRail::RS_SLAB);
|
|
pRail->SetAlignment(AL_RIGHT);
|
|
pRail->SetElevationAt(0, GetElevation()-m_nSlabThick);
|
|
pRail->SetElevationAt(1, GetElevation()-m_nSlabThick+GetStairHeight()-GetStepHeight());
|
|
if(!!m_idLayerBeam3d) {
|
|
//dc.SetColorLayer(colorIndex(), m_idLayerBeam3d);
|
|
pRail->setLayer(m_idLayerBeam3d);
|
|
}
|
|
TPushProperty vProp(pRail, dc);
|
|
if(dc.IsFullExplode())
|
|
pRail->ExplodeOrDraw3d(dc);
|
|
else
|
|
dc.DrawEntity(*pRail);
|
|
delete pRail;
|
|
//if(!!m_idLayerBeam3d)
|
|
// dc.SetLayer(idLay);
|
|
}
|
|
if(GetSideBeam(OFFSET_RIGHT)) {
|
|
rCurve = rCurve.Offset(-m_nBeamThick, LS_FINITE);
|
|
//XDirectionCurve cvRail=rCurve1.Offset(-nGirderThick/2.0, LS_FINITE);
|
|
XPoly2D polyRail;
|
|
rCurve1.AsPoly2D(polyRail);
|
|
TDbHandRail *pRail=new TDbHandRail;
|
|
pRail->setPropertiesFrom(this);
|
|
pRail->SetOutline(polyRail);
|
|
pRail->SetHeight(max(GetStepHeight()+m_nSlabThick,GetBeamHeight()));
|
|
pRail->SetWidth(m_nBeamThick);
|
|
pRail->SetStyle(TDbHandRail::RS_SLAB);
|
|
pRail->SetAlignment(AL_RIGHT);
|
|
pRail->SetElevationAt(0, GetElevation()-m_nSlabThick);
|
|
pRail->SetElevationAt(1, GetElevation()-m_nSlabThick+GetStairHeight()-GetStepHeight());
|
|
if(!!m_idLayerBeam3d) {
|
|
//dc.SetLayer(m_idLayerBeam3d);
|
|
pRail->setLayer(m_idLayerBeam3d);
|
|
}
|
|
|
|
TPushProperty vProp(pRail, dc);
|
|
if(dc.IsFullExplode())
|
|
pRail->ExplodeOrDraw3d(dc);
|
|
else
|
|
dc.DrawEntity(*pRail);
|
|
delete pRail;
|
|
//if(!!m_idLayerBeam3d)
|
|
// dc.SetLayer(idLay);
|
|
}
|
|
|
|
//if(!!m_idLayerStep3d)
|
|
dc.SetColorLayer(colorIndex(), m_idLayerStep3d);
|
|
|
|
BOOL bUseParDiv=FALSE;
|
|
XLine lnTop(lCurve1.EndPoint(), rCurve1.EndPoint());
|
|
XLine lnBot(lCurve1.StartPoint(), rCurve1.StartPoint());
|
|
if((lCurve1.Is(CURVE_ARC) || rCurve1.Is(CURVE_ARC)) && isA()==TDbCurveStair::desc()) {
|
|
if(CT_IsExactSameDrt(lnTop.Direction(), lnBot.Direction(), _angSnap))
|
|
bUseParDiv=TRUE;
|
|
}
|
|
double nStepWidth=0.0;
|
|
if(bUseParDiv) {
|
|
XPoint ptPrj;
|
|
lnTop.StartPoint().Project(&lnBot, ptPrj);
|
|
double nStairLen=lnTop.StartPoint().Distance2d(ptPrj);
|
|
nStepWidth=nStairLen/(m_nStepNum-1);
|
|
}
|
|
//wlw add 150611住总pc构件增加上下两个踏板
|
|
double dslabwidth = 0.0;
|
|
m_XDataMap.GetAt(sKEY_LINESTAIR_SLABWIDTH, dslabwidth);
|
|
if (dslabwidth > 0.1)
|
|
{
|
|
XPointDir2d pt1, pt2;
|
|
lCurve.Polar(-dslabwidth, pt1);
|
|
rCurve.Polar(-dslabwidth, pt2);
|
|
XPoly2D polyS;
|
|
polyS.AppendNode(lCurve.StartPoint());
|
|
polyS.AppendNode(pt1);
|
|
polyS.AppendNode(pt2);
|
|
polyS.AppendNode(rCurve.StartPoint());
|
|
polyS.SetElevation(GetElevation());
|
|
XVector3D vtUpS(0,0,-m_nSlabThick);
|
|
dc.DrawBody(polyS, vtUpS);
|
|
|
|
lCurve.Polar(dslabwidth + lCurve.GetLength(), pt1);
|
|
rCurve.Polar(dslabwidth + rCurve.GetLength(), pt2);
|
|
XPoly2D polyE;
|
|
polyE.AppendNode(lCurve.EndPoint());
|
|
polyE.AppendNode(pt1);
|
|
polyE.AppendNode(pt2);
|
|
polyE.AppendNode(rCurve.EndPoint());
|
|
polyE.SetElevation(GetStairHeight() + GetElevation());
|
|
XVector3D vtUpE(0,0,-m_nSlabThick);
|
|
dc.DrawBody(polyE, vtUpE);
|
|
}
|
|
//end
|
|
|
|
double nLeftDist=0.0, nRightDist=0.0;
|
|
for(int n=0; n<m_nStepNum; n++) {
|
|
XPointDir2d ptLeft[5], ptRight[5];
|
|
if(bUseParDiv) {
|
|
XLine ln=lnBot.Offset(-nStepWidth*n);
|
|
ln.SetLineFlag(LS_INFINITE);
|
|
if(n==0) {
|
|
(XPoint &)ptLeft[0]=lCurve.StartPoint();
|
|
(XPoint &)ptRight[0]=rCurve.StartPoint();
|
|
} else if(n==m_nStepNum-1) {
|
|
(XPoint &)ptLeft[0]=lCurve.EndPoint();
|
|
(XPoint &)ptRight[0]=rCurve.EndPoint();
|
|
} else {
|
|
lCurve.Intersection(ln, ptLeft[0], XPoint());
|
|
rCurve.Intersection(ln, ptRight[0], XPoint());
|
|
}
|
|
} else {
|
|
lCurve.Polar(nLeftDist, ptLeft[0]);
|
|
rCurve.Polar(nRightDist, ptRight[0]);
|
|
}
|
|
|
|
ptLeft[0].z = GetElevation() + n*m_nStepHeight;
|
|
ptLeft[1]=ptLeft[0]; ptLeft[1].z += m_nStepHeight;
|
|
|
|
ptRight[0].z = GetElevation() + n*m_nStepHeight;
|
|
ptRight[1]=ptRight[0]; ptRight[1].z += m_nStepHeight;
|
|
ptLeft[4]=ptLeft[0]; ptLeft[4].z -= m_nSlabThick;
|
|
ptRight[4]=ptRight[0]; ptRight[4].z -= m_nSlabThick;
|
|
if(n<m_nStepNum-1) {
|
|
if(bUseParDiv) {
|
|
XLine ln=lnBot.Offset(-nStepWidth*(n+1));
|
|
ln.SetLineFlag(LS_INFINITE);
|
|
if(n+1==m_nStepNum-1) {
|
|
(XPoint &)ptLeft[2]=lCurve.EndPoint();
|
|
(XPoint &)ptRight[2]=rCurve.EndPoint();
|
|
} else {
|
|
lCurve.Intersection(ln, ptLeft[2], XPoint());
|
|
rCurve.Intersection(ln, ptRight[2], XPoint());
|
|
}
|
|
} else {
|
|
nLeftDist += lCurve.GetLength()/(GetStepNum()-1); //GetStepSideWidth(n, OFFSET_LEFT);
|
|
nRightDist += rCurve.GetLength()/(GetStepNum()-1); //GetStepSideWidth(n, OFFSET_RIGHT);
|
|
lCurve.Polar(nLeftDist, ptLeft[2]);
|
|
rCurve.Polar(nRightDist, ptRight[2]);
|
|
}
|
|
|
|
ptLeft[2].z = GetElevation() + (n+1)*m_nStepHeight;
|
|
ptLeft[3]=ptLeft[2]; ptLeft[3].z -= m_nSlabThick;
|
|
|
|
|
|
ptRight[2].z = GetElevation() + (n+1)*m_nStepHeight;
|
|
ptRight[3]=ptRight[2]; ptRight[3].z -= m_nSlabThick;
|
|
|
|
X3DFace faceLeft1, faceLeft2;
|
|
faceLeft1.GetVertex(0)=ptLeft[0]; faceLeft1.GetVertex(1)=ptLeft[1];
|
|
faceLeft1.GetVertex(2)=ptLeft[2]; faceLeft1.GetVertex(3)=ptLeft[2];
|
|
faceLeft1.SetFlag(0x08);
|
|
faceLeft2.GetVertex(0)=ptLeft[0]; faceLeft2.GetVertex(1)=ptLeft[2];
|
|
faceLeft2.GetVertex(2)=ptLeft[3]; faceLeft2.GetVertex(3)=ptLeft[4];
|
|
faceLeft2.SetFlag(0x01|0x02|0x08);
|
|
dc.DrawFace(faceLeft1); dc.DrawFace(faceLeft2);
|
|
|
|
X3DFace faceRight1, faceRight2;
|
|
faceRight1.GetVertex(0)=ptRight[0]; faceRight1.GetVertex(1)=ptRight[1];
|
|
faceRight1.GetVertex(2)=ptRight[2]; faceRight1.GetVertex(3)=ptRight[2];
|
|
faceRight1.SetFlag(0x08);
|
|
faceRight2.GetVertex(0)=ptRight[0]; faceRight2.GetVertex(1)=ptRight[2];
|
|
faceRight2.GetVertex(2)=ptRight[3]; faceRight2.GetVertex(3)=ptRight[4];
|
|
faceRight2.SetFlag(0x01|0x02|0x08);
|
|
dc.DrawFace(faceRight1); dc.DrawFace(faceRight2);
|
|
|
|
X3DFace faceBot;
|
|
faceBot.GetVertex(0)=ptLeft[4]; faceBot.GetVertex(1)=ptLeft[3];
|
|
faceBot.GetVertex(2)=ptRight[3]; faceBot.GetVertex(3)=ptRight[4];
|
|
faceBot.SetFlag(0x02|0x08);
|
|
dc.DrawFace(faceBot);
|
|
|
|
XPoint ptArray[6];
|
|
ptArray[0]=ptLeft[0]; ptArray[1]=ptLeft[1]; ptArray[2]=ptLeft[2];
|
|
ptArray[3]=ptRight[0]; ptArray[4]=ptRight[1]; ptArray[5]=ptRight[2];
|
|
dc.DrawMesh(2, 3, (AcGePoint3d *)ptArray);
|
|
|
|
if(n==0) {
|
|
X3DFace face;
|
|
face.GetVertex(0)=ptLeft[4]; face.GetVertex(1)=ptRight[4];
|
|
face.GetVertex(2)=ptRight[0]; face.GetVertex(3)=ptLeft[0];
|
|
face.SetFlag(0x01|0x04);
|
|
dc.DrawFace(face);
|
|
}
|
|
} else {
|
|
(XPoint &)ptLeft[0] = lCurve1.EndPoint();
|
|
ptLeft[0].z = GetElevation() + n*m_nStepHeight;
|
|
ptLeft[1]=ptLeft[0]; ptLeft[1].z += m_nStepHeight;
|
|
(XPoint &)ptRight[0]=rCurve1.EndPoint();
|
|
ptRight[0].z = GetElevation() + n*m_nStepHeight;
|
|
ptRight[1]=ptRight[0]; ptRight[1].z += m_nStepHeight;
|
|
ptLeft[4]=ptLeft[0]; ptLeft[4].z -= m_nSlabThick;
|
|
ptRight[4]=ptRight[0]; ptRight[4].z -= m_nSlabThick;
|
|
|
|
X3DFace face;
|
|
face.GetVertex(0)=ptLeft[0]; face.GetVertex(1)=ptRight[0];
|
|
face.GetVertex(2)=ptRight[1]; face.GetVertex(3)=ptLeft[1];
|
|
dc.DrawFace(face);
|
|
|
|
// 绘制楼梯梁
|
|
/*
|
|
XPoint ptLeftTemp1, ptLeftTemp2, ptRightTemp1, ptRightTemp2;
|
|
double nGirderWidth=300.0*UNIT_SCALE;
|
|
ads_polar(ptLeft[1], lCurve1.IDirection(1)+PI, nGirderWidth, ptLeftTemp1);
|
|
ads_polar(ptLeft[4], lCurve1.IDirection(1)+PI, nGirderWidth, ptLeftTemp2);
|
|
ads_polar(ptRight[1], rCurve1.IDirection(1)+PI, nGirderWidth, ptRightTemp1);
|
|
ads_polar(ptRight[4], rCurve1.IDirection(1)+PI, nGirderWidth, ptRightTemp2);
|
|
face.vertex[0] = ptLeft[1]; face.vertex[1]=ptLeftTemp1;
|
|
face.vertex[2]=ptLeftTemp2; face.vertex[3]=ptLeft[4];
|
|
face.flag = 0x01|0x08;
|
|
dc.DrawFace(face);
|
|
|
|
face.vertex[0] = ptRight[1]; face.vertex[1]=ptRightTemp1;
|
|
face.vertex[2]=ptRightTemp2; face.vertex[3]=ptRight[4];
|
|
face.flag = 0x01|0x08;
|
|
dc.DrawFace(face);
|
|
|
|
face.vertex[0] = ptLeft[4]; face.vertex[1]=ptLeftTemp2;
|
|
face.vertex[2]=ptRightTemp2; face.vertex[3]=ptRight[4];
|
|
face.flag = 0;
|
|
dc.DrawFace(face);
|
|
|
|
face.vertex[0] = ptLeft[1]; face.vertex[1]=ptLeftTemp1;
|
|
face.vertex[2]=ptRightTemp1; face.vertex[3]=ptRight[1];
|
|
dc.DrawFace(face);
|
|
|
|
face.vertex[0] = ptLeftTemp2; face.vertex[1]=ptLeftTemp1;
|
|
face.vertex[2]=ptRightTemp1; face.vertex[3]=ptRightTemp2;
|
|
dc.DrawFace(face);
|
|
*/
|
|
XPoint lPoint[3], rPoint[3];
|
|
lPoint[0]=ptLeft[1]; lPoint[0].z -= m_nSlabThick;
|
|
lPoint[2]=lPoint[0]; lPoint[2].z -= m_nStepHeight;
|
|
rPoint[0]=ptRight[1]; rPoint[0].z -= m_nSlabThick;
|
|
rPoint[2]=rPoint[0]; rPoint[2].z -= m_nStepHeight;
|
|
double lWidth=nStepWidth, rWidth=nStepWidth;
|
|
if(!bUseParDiv) {
|
|
lWidth=lCurve1.GetLength()/(GetStepNum()-1);
|
|
rWidth=rCurve1.GetLength()/(GetStepNum()-1);
|
|
}
|
|
ads_polar(lPoint[0], lCurve1.IDirection(1)+PI, lWidth, lPoint[1]);
|
|
ads_polar(rPoint[0], rCurve1.IDirection(1)+PI, rWidth, rPoint[1]);
|
|
|
|
X3DFace lFace;
|
|
lFace.GetVertex(0)=lFace.GetVertex(3)=lPoint[0];
|
|
lFace.GetVertex(1)=lPoint[1];
|
|
lFace.GetVertex(2)=lPoint[2];
|
|
lFace.SetFlag(0x01|0x04|0x08);
|
|
dc.DrawFace(lFace);
|
|
|
|
X3DFace rFace;
|
|
rFace.GetVertex(0)=rFace.GetVertex(3)=rPoint[0];
|
|
rFace.GetVertex(1)=rPoint[1];
|
|
rFace.GetVertex(2)=rPoint[2];
|
|
rFace.SetFlag(0x01|0x04|0x08);
|
|
rFace.Reverse();
|
|
dc.DrawFace(rFace);
|
|
|
|
X3DFace tFace;
|
|
tFace.GetVertex(0)=lPoint[0];
|
|
tFace.GetVertex(1)=rPoint[0];
|
|
tFace.GetVertex(2)=rPoint[1];
|
|
tFace.GetVertex(3)=lPoint[1];
|
|
tFace.SetFlag(0x01|0x02|0x08);
|
|
dc.DrawFace(tFace);
|
|
|
|
X3DFace bFace;
|
|
bFace.GetVertex(0)=lPoint[2];
|
|
bFace.GetVertex(1)=rPoint[2];
|
|
bFace.GetVertex(2)=rPoint[1];
|
|
bFace.GetVertex(3)=lPoint[1];
|
|
bFace.SetFlag(0x01);
|
|
bFace.Reverse();
|
|
dc.DrawFace(bFace);
|
|
}
|
|
}
|
|
//if(!!m_idLayerStep3d)
|
|
// dc.SetLayer(idLay);
|
|
|
|
return Acad::eOk;
|
|
}
|
|
bool TDbStair::IsClipMe(const TEntityBase* pEnt)const
|
|
{
|
|
if(TDbEntity::IsClipMe(pEnt))
|
|
return true;
|
|
|
|
if(pEnt->GetMe()->isKindOf(TDbColumn::desc()))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
// 修改：2002/7/4，解决任意梯段的划分问题
|
|
// 即对于首尾踏步平行的情况，中间踏步也要平行
|
|
Acad::ErrorStatus
|
|
TDbStair::ExplodeOrDraw2d(XExplodeDraw &dc) const
|
|
{
|
|
//TPushProperty vProp(this, dc);
|
|
|
|
assertReadEnabled();
|
|
int nFlag2d=Get2DFlag();
|
|
if(nFlag2d==SF_NO2D)
|
|
return Acad::eOk;
|
|
|
|
if(_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0 ||
|
|
g_bOsnapExpl) {
|
|
XPushMemVar<BOOL> bExpl(g_bOsnapExpl, FALSE);
|
|
AcDbVoidPtrArray entSet;
|
|
XExplodeStream dcExp(entSet);
|
|
dcExp.SetPropertiesFrom(this);//add by whl on 060404
|
|
ExplodeOrDraw2d(dcExp);
|
|
INT_PTR nQuickMarker=GetQuickMarker();
|
|
int nGsMarker=1;
|
|
int nCount=entSet.length();
|
|
for(int i=0; i<nCount; i++) {
|
|
AcDbEntity *pEnt=(AcDbEntity *)entSet[i];
|
|
dc.SetSelectionMarker(nGsMarker);
|
|
nGsMarker++;
|
|
if(nQuickMarker && (nGsMarker-1)!=nQuickMarker) //用于捕捉时加速
|
|
continue;
|
|
|
|
dc.DrawEntity(*pEnt);
|
|
if(nQuickMarker && (nGsMarker-1)==nQuickMarker)
|
|
break;
|
|
}
|
|
ReleaseEntSet(entSet);
|
|
} else {
|
|
DList<XCurveSegment> lnSet;
|
|
XDirectionCurve lCurve=GetSideCurve2d(OFFSET_LEFT),
|
|
rCurve=GetSideCurve2d(OFFSET_RIGHT);
|
|
if(!IsAlongWall(0))
|
|
lnSet.Append(new XCurveSegment(lCurve.GetCurve()));
|
|
if(!IsAlongWall(1))
|
|
lnSet.Append(new XCurveSegment(rCurve.GetCurve()));
|
|
|
|
//wlw add 150611住总pc构件增加上下两个踏板
|
|
double dslabwidth = 0.0;
|
|
m_XDataMap.GetAt(sKEY_LINESTAIR_SLABWIDTH, dslabwidth);
|
|
if (dslabwidth > 0.1)
|
|
{
|
|
XPointDir2d pt1, pt2;
|
|
lCurve.Polar(-dslabwidth, pt1);
|
|
rCurve.Polar(-dslabwidth, pt2);
|
|
lnSet.Append(new XCurveSegment(pt1,lCurve.StartPoint(),0.0));
|
|
lnSet.Append(new XCurveSegment(pt1,pt2,0.0));
|
|
lnSet.Append(new XCurveSegment(rCurve.StartPoint(),pt2,0.0));
|
|
|
|
lCurve.Polar(dslabwidth + lCurve.GetLength(), pt1);
|
|
rCurve.Polar(dslabwidth + rCurve.GetLength(), pt2);
|
|
lnSet.Append(new XCurveSegment(pt1,lCurve.EndPoint(),0.0));
|
|
lnSet.Append(new XCurveSegment(pt1,pt2,0.0));
|
|
lnSet.Append(new XCurveSegment(rCurve.EndPoint(),pt2,0.0));
|
|
}
|
|
//end
|
|
BOOL bUseParDiv=FALSE;
|
|
XLine lnTop(lCurve.EndPoint(), rCurve.EndPoint());
|
|
XLine lnBot(lCurve.StartPoint(), rCurve.StartPoint());
|
|
if((lCurve.Is(CURVE_ARC) || rCurve.Is(CURVE_ARC)) && isA()==TDbCurveStair::desc()) {
|
|
if(CT_IsExactSameDrt(lnTop.Direction(), lnBot.Direction(), _angSnap))
|
|
bUseParDiv=TRUE;
|
|
}
|
|
|
|
XDirectionCurve leftCurve=lCurve, rightCurve=rCurve; // backup
|
|
// 边粱线
|
|
if(GetSideBeam(OFFSET_LEFT)) {
|
|
XDirectionCurve lCurve1=lCurve.Offset(m_nBeamThick, LS_INFINITE);
|
|
if(bUseParDiv) {
|
|
XPoint ptInt[2];
|
|
XPoint ptS=lCurve1.StartPoint(), ptE=lCurve1.EndPoint();
|
|
int nIntNum=lCurve1.Intersection(lnBot, ptInt[0], ptInt[1]);
|
|
if(nIntNum==1) ptS=ptInt[0];
|
|
else if(nIntNum==2) ptS=XLine(ptInt[0], ptInt[1]).NearPoint(lCurve1.StartPoint());
|
|
nIntNum=lCurve1.Intersection(lnTop, ptInt[0], ptInt[1]);
|
|
if(nIntNum==1) ptE=ptInt[0];
|
|
else ptE=XLine(ptInt[0], ptInt[1]).NearPoint(lCurve1.EndPoint());
|
|
lCurve1.SetPoints(ptS, ptE);
|
|
}
|
|
lnSet.Append(new XCurveSegment(lCurve.StartPoint(), lCurve1.StartPoint(), 0.0));
|
|
lnSet.Append(new XCurveSegment(lCurve.EndPoint(), lCurve1.EndPoint(), 0.0));
|
|
lCurve.StartPoint()=lCurve1.StartPoint();
|
|
lCurve.EndPoint()=lCurve1.EndPoint();
|
|
lCurve.SetBulge(lCurve1.GetBulge());
|
|
lnBot.StartPoint()=lCurve.StartPoint();
|
|
lnTop.StartPoint()=lCurve.EndPoint();
|
|
lnSet.Append(new XCurveSegment(lCurve1.GetCurve()));
|
|
|
|
}
|
|
if(GetSideBeam(OFFSET_RIGHT)) {
|
|
XDirectionCurve rCurve1=rCurve.Offset(-m_nBeamThick, LS_INFINITE);
|
|
if(bUseParDiv) {
|
|
XPoint ptInt[2];
|
|
XPoint ptS=rCurve1.StartPoint(), ptE=rCurve1.EndPoint();
|
|
int nIntNum=rCurve1.Intersection(lnBot, ptInt[0], ptInt[1]);
|
|
if(nIntNum==1) ptS=ptInt[0];
|
|
else if(nIntNum==2) ptS=XLine(ptInt[0], ptInt[1]).NearPoint(rCurve1.StartPoint());
|
|
nIntNum=rCurve1.Intersection(lnTop, ptInt[0], ptInt[1]);
|
|
if(nIntNum==1) ptE=ptInt[0];
|
|
else ptE=XLine(ptInt[0], ptInt[1]).NearPoint(rCurve1.EndPoint());
|
|
rCurve1.SetPoints(ptS, ptE);
|
|
}
|
|
lnSet.Append(new XCurveSegment(rCurve.StartPoint(), rCurve1.StartPoint(), 0.0));
|
|
lnSet.Append(new XCurveSegment(rCurve.EndPoint(), rCurve1.EndPoint(), 0.0));
|
|
rCurve.StartPoint()=rCurve1.StartPoint();
|
|
rCurve.EndPoint()=rCurve1.EndPoint();
|
|
rCurve.SetBulge(rCurve1.GetBulge());
|
|
lnBot.EndPoint()=rCurve.StartPoint();
|
|
lnTop.EndPoint()=rCurve.EndPoint();
|
|
lnSet.Append(new XCurveSegment(rCurve1.GetCurve()));
|
|
}
|
|
|
|
BOOL bMidLines=TRUE; //是否绘制中间的踏步线
|
|
if(IsAscent() && !HasSlant())
|
|
bMidLines=FALSE;
|
|
|
|
int nStepNum=IsAscent()? m_nStepNum : (m_nStepNum-1);
|
|
if(bUseParDiv) {
|
|
XPoint ptPrj;
|
|
lnTop.StartPoint().Project(&lnBot, ptPrj);
|
|
double nStairLen=lnTop.StartPoint().Distance2d(ptPrj);
|
|
double nStepWidth=nStairLen/nStepNum;
|
|
lnSet.Append(new XCurveSegment(lnBot.StartPoint(), lnBot.EndPoint(), 0.0));
|
|
if(bMidLines) for(int n=1; n<nStepNum; n++) {
|
|
XLine ln=lnBot.Offset(-nStepWidth*n);
|
|
ln.SetLineFlag(LS_INFINITE);
|
|
XPoint pt[2], qt[2];
|
|
if(lCurve.Intersection(ln, pt[0], pt[1])==1 && rCurve.Intersection(ln, qt[0], qt[1])) {
|
|
lnSet.Append(new XCurveSegment(pt[0], qt[0], 0.0));
|
|
}
|
|
}
|
|
lnSet.Append(new XCurveSegment(lnTop.StartPoint(), lnTop.EndPoint(), 0.0));
|
|
|
|
} else {
|
|
double nLeftDist=0.0, nRightDist=0.0;
|
|
for(int n=0; n<nStepNum+1; n++) {
|
|
XPointDir2d ptLeft, ptRight;
|
|
lCurve.Polar(nLeftDist, ptLeft);
|
|
rCurve.Polar(nRightDist, ptRight);
|
|
if(!bMidLines && n>0 && n<m_nStepNum)
|
|
;
|
|
else
|
|
lnSet.Append(new XCurveSegment(ptLeft, ptRight, 0.0));
|
|
if(n<nStepNum) {
|
|
nLeftDist += lCurve.GetLength()/nStepNum; //GetStepSideWidth(n, OFFSET_LEFT);
|
|
nRightDist += rCurve.GetLength()/nStepNum; //GetStepSideWidth(n, OFFSET_RIGHT);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 扶手裁剪
|
|
if(m_tempRailArray.length()) {
|
|
int num=m_tempRailArray.length();
|
|
for(int n=0; n<num; n++) {
|
|
TDbHandRail *pHand=(TDbHandRail*)m_tempRailArray[n];
|
|
pHand->ClipCurveByTrace(lnSet);
|
|
}
|
|
} else {
|
|
XPoly2D polyOutline(1);
|
|
GetOutline2d(polyOutline);
|
|
AcDbObjectId idOwner=ownerId();
|
|
AcDbObjectIdArray railArray;
|
|
if(!!objectId() && !!polyOutline && !!idOwner && TDbHandRail::GetRailsByCP(polyOutline, idOwner, railArray)) {
|
|
int nCount=railArray.length();
|
|
for(int cnt=0; cnt<nCount; cnt++) {
|
|
AcDbObjectId idRail=railArray[cnt];
|
|
OPENOBJ_BEGIN(idRail, AcDb::kForRead, TDbHandRail, pRail);
|
|
if(pRail)
|
|
pRail->ClipCurveByTrace(lnSet);
|
|
OPENOBJ_END();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// 剖切线
|
|
lCurve=leftCurve;
|
|
rCurve=rightCurve; //Restore
|
|
XPoly polyUp, polyDown, polyMid;
|
|
if(nFlag2d!=SF_NOSECT && GetSectionPoly(polyDown, polyUp, polyMid)) {
|
|
if(nFlag2d==SF_1SECT) { //下剖断
|
|
XPoly2D polyClip(1);
|
|
for(int k=0; k<polyMid.Length(); k++)
|
|
polyClip.AppendNode(*polyMid[k]);
|
|
XDirectionCurve lCurve0(lCurve), rCurve0(rCurve);
|
|
lCurve0.SetPoints(lCurve.StartPoint(), *polyMid.Tail());
|
|
rCurve0.SetPoints(rCurve.StartPoint(), *polyMid.Head());
|
|
|
|
int nLength = polyClip.Length();
|
|
polyClip.SetBulge(nLength-1, -lCurve0.GetBulge());
|
|
polyClip.AppendNode(lCurve0.StartPoint());
|
|
polyClip.AppendNode(rCurve0.StartPoint(), rCurve0.GetBulge());
|
|
DList<XCurveSegment> ssIn, ssOut, ssEdge;
|
|
PolyClip(lnSet, polyClip, ssIn, ssOut, ssEdge);
|
|
for(k=0; k<ssIn.Length(); k++)
|
|
dc << *ssIn[k];
|
|
for(k=0; k<ssEdge.Length(); k++)
|
|
dc << *ssEdge[k];
|
|
for(k=0; k<polyMid.Length()-1; k++)
|
|
dc << XLine(*polyMid[k], *polyMid[k+1]);
|
|
} else if(nFlag2d==SF_UP_SECT) {
|
|
XPoly2D polyClip(1);
|
|
for(int k=polyMid.Length()-1; k>=0; k--)
|
|
polyClip.AppendNode(*polyMid[k]);
|
|
XDirectionCurve lCurve0(lCurve), rCurve0(rCurve);
|
|
lCurve0.SetPoints(*polyMid.Tail(), lCurve.EndPoint());
|
|
rCurve0.SetPoints(*polyMid.Head(), rCurve.EndPoint());
|
|
|
|
int nLength = polyClip.Length();
|
|
polyClip.SetBulge(nLength-1, rCurve0.GetBulge());
|
|
polyClip.AppendNode(rCurve0.EndPoint());
|
|
polyClip.AppendNode(lCurve0.EndPoint(), -lCurve0.GetBulge());
|
|
DList<XCurveSegment> ssIn, ssOut, ssEdge;
|
|
PolyClip(lnSet, polyClip, ssIn, ssOut, ssEdge);
|
|
for(k=0; k<ssIn.Length(); k++)
|
|
dc << *ssIn[k];
|
|
for(k=0; k<ssEdge.Length(); k++)
|
|
dc << *ssEdge[k];
|
|
for(k=0; k<polyMid.Length()-1; k++)
|
|
dc << XLine(*polyMid[k], *polyMid[k+1]);
|
|
} else if(nFlag2d==SF_2SECT) { //双剖断
|
|
XDirectionCurve lCurve0(lCurve), rCurve0(rCurve);
|
|
lCurve0.SetPoints(*polyDown.Tail(), *polyUp.Head());
|
|
rCurve0.SetPoints(*polyDown.Head(), *polyUp.Tail());
|
|
|
|
XPoly2D polyClip(1);
|
|
for(int k=0; k<polyUp.Length(); k++)
|
|
polyClip.AppendNode(*polyUp[k]);
|
|
int nLength = polyClip.Length();
|
|
polyClip.SetBulge(nLength-1, -rCurve0.GetBulge());
|
|
for(k=0; k<polyDown.Length(); k++)
|
|
polyClip.AppendNode(*polyDown[k]);
|
|
|
|
nLength = polyClip.Length();
|
|
polyClip.SetBulge(nLength-1, lCurve0.GetBulge());
|
|
polyClip.Reverse();
|
|
BOOL bSingleSect=FALSE;
|
|
TDbConfig *pConfig=GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
|
|
if(pConfig) {
|
|
bSingleSect=pConfig->IsSingleSect();
|
|
pConfig->close();
|
|
}
|
|
if(bSingleSect) {
|
|
for(k=0; k<lnSet.Length(); k++)
|
|
dc << *lnSet[k];
|
|
for(k=0; k<polyMid.Length()-1; k++)
|
|
dc << XLine(*polyMid[k], *polyMid[k+1]);
|
|
} else {
|
|
DList<XCurveSegment> ssIn, ssOut, ssEdge;
|
|
PolyClip(lnSet, polyClip, ssIn, ssOut, ssEdge);
|
|
for(k=0; k<ssOut.Length(); k++)
|
|
dc << *ssOut[k];
|
|
if(polyDown.Length()==5 && polyUp.Length()==5) {
|
|
dc << XLine(*polyUp[0], *polyUp[1])
|
|
<< XLine(*polyDown[4], *polyDown[3])
|
|
<< XLine(*polyDown[3], *polyUp[2])
|
|
<< XLine(*polyUp[2], *polyDown[2])
|
|
<< XLine(*polyDown[2], *polyUp[3])
|
|
<< XLine(*polyUp[3], *polyUp[4])
|
|
<< XLine(*polyDown[1], *polyDown[0]);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
for(int i=0; i<lnSet.Length(); i++)
|
|
dc << *lnSet[i];
|
|
}
|
|
|
|
// 显示上楼方向
|
|
int numRail=m_tempRailArray.length();
|
|
AcDbObjectId idThis=objectId();
|
|
if(ShowArrow() /*&& strcmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0*/) {
|
|
XPoint ptFrom, ptTo, ptEnd;
|
|
ptFrom = XLine(lCurve.StartPoint(), rCurve.StartPoint()).MidPoint();
|
|
ptTo = XLine(lCurve.MidPoint(), rCurve.MidPoint()).MidPoint();
|
|
XDirectionCurve segMid(ptFrom, ptTo, (lCurve.GetBulge()+rCurve.GetBulge())/4.0);
|
|
|
|
double nDirection=segMid.IDirection(1)+PI;
|
|
ads_polar(ptTo, nDirection, 1.6*GetPScale(), ptEnd);
|
|
XPoint ptA, ptB;
|
|
ads_polar(ptTo, nDirection-PI/2.0, 0.5*GetPScale(), ptA);
|
|
ads_polar(ptTo, nDirection+PI/2.0, 0.5*GetPScale(), ptB);
|
|
dc << segMid << XLine(ptTo, ptEnd) << XLine(ptEnd, ptA) << XLine(ptEnd, ptB);
|
|
}
|
|
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
|
|
|
|
void TDbStair::ClipPolyPath(XPoly2D &lPath, XPoly2D &rPath) const
|
|
{
|
|
XPoly polyDown, polyUp, polyMid;
|
|
if((Get2DFlag()==SF_1SECT||Get2DFlag()==SF_UP_SECT) && GetSectionPoly(polyDown, polyUp, polyMid)) { //下剖断或上剖断
|
|
ASSERT(polyMid.Length());
|
|
AcDbLine lnSect(*polyMid.Head(), *polyMid.Tail());
|
|
for(int nSide=0; nSide<2; nSide++) {
|
|
XPoly2D &polyPath=nSide? rPath : lPath;
|
|
|
|
//add by xlc on 080724 上剖断
|
|
if(Get2DFlag()==SF_UP_SECT)
|
|
polyPath.Reverse();
|
|
|
|
polyPath.SetFlag(0);
|
|
AcDbPolyline pline;
|
|
PolyConvert(polyPath, pline);
|
|
AcGePoint3dArray intPoints;
|
|
pline.intersectWith(&lnSect, AcDb::kOnBothOperands, intPoints);
|
|
AcDbVoidPtrArray entSet;
|
|
pline.getSplitCurves(intPoints, entSet);
|
|
if(entSet.length()) {
|
|
AcDbEntity *pEnt=(AcDbEntity *)entSet[0];
|
|
ASSERT(pEnt->isA()==AcDbPolyline::desc());
|
|
PolyConvert(*(AcDbPolyline *)pEnt, polyPath);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// 用剖切区域对lnSet进行裁剪
|
|
void TDbStair::ClipCurveBySection(DList<XCurveSegment> &lnSet) const
|
|
{
|
|
XDirectionCurve lCurve=GetSideCurve2d(OFFSET_LEFT),
|
|
rCurve=GetSideCurve2d(OFFSET_RIGHT);
|
|
|
|
int nFlag2d=Get2DFlag();
|
|
XPoly polyUp, polyDown, polyMid;
|
|
if(nFlag2d!=SF_NOSECT && GetSectionPoly(polyDown, polyUp, polyMid)) {
|
|
if(nFlag2d==SF_1SECT) { //下剖断
|
|
XPoly2D polyClip(1);
|
|
for(int k=0; k<polyMid.Length(); k++)
|
|
polyClip.AppendNode(*polyMid[k]);
|
|
XDirectionCurve lCurve0(lCurve), rCurve0(rCurve);
|
|
lCurve0.SetPoints(lCurve.StartPoint(), *polyMid.Tail());
|
|
rCurve0.SetPoints(rCurve.StartPoint(), *polyMid.Head());
|
|
|
|
int nLength = polyClip.Length();
|
|
polyClip.SetBulge(nLength-1, -lCurve0.GetBulge());
|
|
polyClip.AppendNode(lCurve0.StartPoint());
|
|
polyClip.AppendNode(rCurve0.StartPoint(), rCurve0.GetBulge());
|
|
DList<XCurveSegment> ssIn(0), ssOut, ssEdge(0);
|
|
PolyClip(lnSet, polyClip, ssIn, ssOut, ssEdge);
|
|
lnSet.Reset();
|
|
for(k=0; k<ssIn.Length(); k++)
|
|
{
|
|
lnSet.Append(ssIn[k]);
|
|
}
|
|
for(k=0; k<ssEdge.Length(); k++)
|
|
{
|
|
lnSet.Append(ssEdge[k]);
|
|
}
|
|
} else if(nFlag2d==SF_2SECT) { //双剖断
|
|
BOOL bSingleSect=FALSE;
|
|
TDbConfig *pConfig=GetDwgGlobal(AcDb::kForRead,g_pCurrentDb);
|
|
if(pConfig) {
|
|
bSingleSect=pConfig->IsSingleSect();
|
|
pConfig->close();
|
|
}
|
|
if(!bSingleSect) {
|
|
XDirectionCurve lCurve0(lCurve), rCurve0(rCurve);
|
|
lCurve0.SetPoints(*polyDown.Tail(), *polyUp.Head());
|
|
rCurve0.SetPoints(*polyDown.Head(), *polyUp.Tail());
|
|
|
|
XPoly2D polyClip(1);
|
|
for(int k=0; k<polyUp.Length(); k++)
|
|
polyClip.AppendNode(*polyUp[k]);
|
|
|
|
int nLength = polyClip.Length();
|
|
polyClip.SetBulge(nLength-1, -rCurve0.GetBulge());
|
|
for(k=0; k<polyDown.Length(); k++)
|
|
polyClip.AppendNode(*polyDown[k]);
|
|
|
|
nLength = polyClip.Length();
|
|
polyClip.SetBulge(nLength-1, lCurve0.GetBulge());
|
|
polyClip.Reverse();
|
|
DList<XCurveSegment> ssIn, ssOut(0), ssEdge;
|
|
PolyClip(lnSet, polyClip, ssIn, ssOut, ssEdge);
|
|
lnSet.Reset();
|
|
for(k=0; k<ssOut.Length(); k++)
|
|
lnSet.Append(ssOut[k]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// TArch6 memeber
|
|
BOOL TDbStair::IsAscent() const
|
|
{
|
|
return ((m_nFlagEx&SFEX_ASCENT)!=0);
|
|
}
|
|
|
|
BOOL TDbStair::IsOnGround() const
|
|
{
|
|
return ((m_nFlagEx&SFEX_GROUND)!=0);
|
|
}
|
|
|
|
BOOL TDbStair::HasSlant() const
|
|
{
|
|
return ((m_nFlagEx&SFEX_SLANT)!=0);
|
|
}
|
|
|
|
void TDbStair::SetAscent(BOOL bTrue)
|
|
{
|
|
assertWriteEnabled();
|
|
if(bTrue)
|
|
m_nFlagEx |= SFEX_ASCENT;
|
|
else
|
|
m_nFlagEx &= ~SFEX_ASCENT;
|
|
}
|
|
|
|
void TDbStair::SetOnGround(BOOL bTrue)
|
|
{
|
|
assertWriteEnabled();
|
|
if(bTrue)
|
|
m_nFlagEx |= SFEX_GROUND;
|
|
else
|
|
m_nFlagEx &= ~SFEX_GROUND;
|
|
}
|
|
|
|
void TDbStair::SetSlant(BOOL bTrue)
|
|
{
|
|
assertWriteEnabled();
|
|
if(bTrue)
|
|
m_nFlagEx |= SFEX_SLANT;
|
|
else
|
|
m_nFlagEx &= ~SFEX_SLANT;
|
|
}
|
|
|
|
|
|
double TDbStair::GetBeamHeight() const
|
|
{
|
|
return m_nBeamHeight;
|
|
}
|
|
|
|
double TDbStair::GetBeamThick() const
|
|
{
|
|
return m_nBeamThick;
|
|
}
|
|
|
|
double TDbStair::GetSlabThick() const
|
|
{
|
|
return m_nSlabThick;
|
|
}
|
|
|
|
AcDbObjectId TDbStair::GetLayerBeam3d() const
|
|
{
|
|
return m_idLayerBeam3d;
|
|
}
|
|
|
|
AcDbObjectId TDbStair::GetLayerStep3d() const
|
|
{
|
|
return m_idLayerStep3d;
|
|
}
|
|
|
|
|
|
void TDbStair::SetBeamHeight(double val)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nBeamHeight = val;
|
|
}
|
|
|
|
void TDbStair::SetSlabThick(double val)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nSlabThick=val;
|
|
}
|
|
|
|
void TDbStair::SetBeamThick(double val)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nBeamThick=val;
|
|
}
|
|
|
|
void TDbStair::SetLayerBeam3d(AcDbObjectId idLayer)
|
|
{
|
|
assertWriteEnabled();
|
|
m_idLayerBeam3d=idLayer;
|
|
}
|
|
|
|
void TDbStair::SetLayerStep3d(AcDbObjectId idLayer)
|
|
{
|
|
assertWriteEnabled();
|
|
m_idLayerStep3d=idLayer;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
// 直线梯段对象类
|
|
/////////////////////////////////////////////////////////////
|
|
//ver:2-TArch8
|
|
const Adesk::UInt8 TDbLineStair::g_nVersion = 2;
|
|
|
|
|
|
ACRX_DXF_DEFINE_MEMBERS(ATSLineStair, ATSStair, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
|
1, ATS_LINESTAIR, "ATS_LINESTAIR图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
|
|
|
|
IMPLEMENT_TENTBASE(TDbLineStair);
|
|
|
|
TDbLineStair::TDbLineStair()
|
|
{
|
|
m_nStepWidth=m_nStairWidth=0;
|
|
m_nRotation=0;
|
|
m_dSlopeLength=0;
|
|
}
|
|
|
|
|
|
TDbLineStair::~TDbLineStair()
|
|
{
|
|
}
|
|
|
|
BOOL TDbLineStair::IsValid() const
|
|
{
|
|
BOOL bRet=TDbStair::IsValid();
|
|
if(!bRet)
|
|
return bRet;
|
|
bRet=(m_nStepWidth>_DIST_SNAP && //踏步宽
|
|
m_nStairWidth>_DIST_SNAP); //梯段宽
|
|
return bRet;
|
|
}
|
|
|
|
// 提供对格式刷的支持
|
|
void TDbLineStair::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbStair::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
|
|
TDbLineStair *pSrc=TDbLineStair::cast(pSrcEntity);
|
|
if(pSrc) {
|
|
m_nStepWidth=pSrc->m_nStepWidth; //踏步宽
|
|
// 梯段宽是否要支持格式刷
|
|
m_nStairWidth=pSrc->m_nStairWidth; //梯段宽
|
|
m_dSlopeLength=pSrc->m_dSlopeLength;//坡道长
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbLineStair::subGetClassID(CLSID* pClsid) const
|
|
{
|
|
return Acad::eOk;
|
|
|
|
}
|
|
|
|
// 从DWG读入数据:
|
|
Acad::ErrorStatus TDbLineStair::dwgInFields (AcDbDwgFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
Acad::ErrorStatus es = TDbStair::dwgInFields(pFiler);
|
|
if(es != Acad::eOk) return es;
|
|
Adesk::UInt8 nVer;
|
|
pFiler->readItem(&nVer);
|
|
if(nVer>g_nVersion) {// Version is too new
|
|
return Acad::eMakeMeProxy;
|
|
}
|
|
|
|
pFiler->readItem(&m_nStepWidth);
|
|
pFiler->readItem(&m_nStairWidth);
|
|
pFiler->readItem((AcGePoint3d *)&m_ptLocation);
|
|
pFiler->readItem(&m_nRotation);
|
|
|
|
//TArch8
|
|
if(nVer>1)
|
|
{
|
|
pFiler->readItem(&m_dSlopeLength);
|
|
}
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbLineStair::dwgOutFields(AcDbDwgFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es = TDbStair::dwgOutFields(pFiler);
|
|
if(es != Acad::eOk) return es;
|
|
|
|
//modify by xlc on 081218
|
|
if (g_nSaveTArchVer<8)
|
|
{
|
|
pFiler->writeItem((Adesk::UInt8)1);
|
|
}
|
|
else
|
|
{
|
|
pFiler->writeItem(g_nVersion);
|
|
}
|
|
|
|
pFiler->writeItem(m_nStepWidth);
|
|
pFiler->writeItem(m_nStairWidth);
|
|
pFiler->writeItem((AcGePoint3d &)m_ptLocation);
|
|
pFiler->writeItem(m_nRotation);
|
|
|
|
//Tarch8
|
|
if(g_nSaveTArchVer>7)
|
|
{
|
|
pFiler->writeItem(m_dSlopeLength);
|
|
}
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbLineStair::dxfInFields (AcDbDxfFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
Acad::ErrorStatus es = TDbStair::dxfInFields(pFiler);
|
|
if(es!=Acad::eOk)
|
|
return es;
|
|
|
|
if (!pFiler->atSubclassData(_T("TDbLineStair"))) {
|
|
return Acad::eBadDxfSequence;
|
|
}
|
|
int fieldsFlags=0;
|
|
resbuf rb;
|
|
double r1, r2, r3;
|
|
XPoint pt;
|
|
while ((es == Acad::eOk)
|
|
&& ((es = pFiler->readResBuf(&rb)) == Acad::eOk)) {
|
|
switch (rb.restype) {
|
|
case AcDb::kDxfReal+3:
|
|
r1=rb.resval.rreal;
|
|
fieldsFlags |= 0x01;
|
|
break;
|
|
case AcDb::kDxfReal+4:
|
|
r2=rb.resval.rreal;
|
|
fieldsFlags |= 0x02;
|
|
break;
|
|
case AcDb::kDxfAngle:
|
|
r3 = rb.resval.rreal;
|
|
fieldsFlags |= 0x04;
|
|
break;
|
|
case AcDb::kDxfXCoord:
|
|
pt=rb.resval.rpoint;
|
|
fieldsFlags |= 0x08;
|
|
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: 43"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
if (!(fieldsFlags&0x02)) {
|
|
pFiler->setError(Acad::eMissingDxfField,
|
|
_T("\nMissing DXF group code: 44"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
if (!(fieldsFlags&0x08)) {
|
|
pFiler->setError(Acad::eMissingDxfField,
|
|
_T("\nMissing DXF group code: 10"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
m_nStepWidth=r1;
|
|
m_nStairWidth=r2;
|
|
if(fieldsFlags&0x04)
|
|
m_nRotation=r3;
|
|
m_ptLocation=pt;
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbLineStair::dxfOutFields(AcDbDxfFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es=TDbStair::dxfOutFields(pFiler);
|
|
assert(es == Acad::eOk);
|
|
|
|
es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbLineStair"));
|
|
assert(es == Acad::eOk);
|
|
pFiler->writeDouble(AcDb::kDxfReal+3, m_nStepWidth);
|
|
pFiler->writeDouble(AcDb::kDxfReal+4, m_nStairWidth);
|
|
pFiler->writeDouble(AcDb::kDxfAngle, m_nRotation);
|
|
pFiler->writePoint3d(AcDb::kDxfXCoord, m_ptLocation);
|
|
return es;
|
|
}
|
|
|
|
|
|
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Overriden functions for edit
|
|
// to do:
|
|
// 允许通过夹点改变边界
|
|
Acad::ErrorStatus TDbLineStair::subGetGripPoints(AcGePoint3dArray& gripPoints,
|
|
AcDbIntArray& osnapModes,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
assertReadEnabled();
|
|
gripPoints.append(m_ptLocation);
|
|
XPoint ptCorn[3];
|
|
ads_polar(m_ptLocation, m_nRotation, GetStairWidth(), ptCorn[0]);
|
|
ads_polar(ptCorn[0], m_nRotation+PI/2.0, GetStairLength(), ptCorn[1]);
|
|
ptCorn[1].z += GetStairHeight();
|
|
ads_polar(ptCorn[1], m_nRotation-PI, GetStairWidth(), ptCorn[2]);
|
|
for(int i=0; i<3; i++)
|
|
gripPoints.append(ptCorn[i]);
|
|
|
|
XPoint ptSideLeft, ptSideRight;
|
|
ads_polar(m_ptLocation, m_nRotation+PI/2.0, GetStairLength()/2.0, ptSideLeft);
|
|
ads_polar(ptCorn[0], m_nRotation+PI/2.0, GetStairLength()/2.0, ptSideRight);
|
|
gripPoints.append(ptSideLeft); // 4
|
|
gripPoints.append(ptSideRight); //5
|
|
|
|
|
|
int nFlag2d=Get2DFlag();
|
|
if(nFlag2d==SF_1SECT || nFlag2d==SF_2SECT) {
|
|
XDirectionCurve lCurve=GetSideCurve2d(OFFSET_LEFT),
|
|
rCurve=GetSideCurve2d(OFFSET_RIGHT);
|
|
XPointDir2d ptTemp1, ptTemp2;
|
|
lCurve.Polar(lCurve.GetLength()*m_lSectionPos, ptTemp1);
|
|
rCurve.Polar(rCurve.GetLength()*m_rSectionPos, ptTemp2);
|
|
gripPoints.append(ptTemp1); //6
|
|
gripPoints.append(ptTemp2); //7
|
|
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// stretch points is diffrent from grep points, with no midpoint included
|
|
Acad::ErrorStatus TDbLineStair::subGetStretchPoints(AcGePoint3dArray & gripPoints) const
|
|
{
|
|
assertReadEnabled();
|
|
gripPoints.append(m_ptLocation);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
|
|
|
|
// Active when being rotated, scaled, moved, etc.
|
|
Acad::ErrorStatus TDbLineStair::subTransformBy(const AcGeMatrix3d& xform)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbStair::subTransformBy(xform);
|
|
XPoint ptX, ptY;
|
|
ads_polar(m_ptLocation, m_nRotation, GetStairWidth(), ptX);
|
|
ads_polar(m_ptLocation, m_nRotation+PI/2.0, GetStairLength(), 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_nRotation = ads_angle(m_ptLocation, ptX);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// 功能: 夹点操作
|
|
Acad::ErrorStatus TDbLineStair::subMoveGripPointsAt(
|
|
const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
assertWriteEnabled();
|
|
XPoint vtOffset=*(XPoint *)&offset;
|
|
vtOffset.z=0;
|
|
int nLen=indices.length();
|
|
for (int i = 0; i < indices.length(); i++) {
|
|
int idx = indices[i];
|
|
if(idx<4 && nLen==1)
|
|
m_ptLocation += vtOffset;
|
|
else if(idx==4) {
|
|
XPoint vt(cos(m_nRotation), sin(m_nRotation));
|
|
double nOffset=vtOffset&vt;
|
|
if(nOffset<m_nStairWidth) {
|
|
m_nStairWidth -= nOffset;
|
|
ads_polar(XPoint(m_ptLocation), m_nRotation, nOffset, m_ptLocation);
|
|
}
|
|
} else if(idx==5) {
|
|
XPoint vt(cos(m_nRotation), sin(m_nRotation));
|
|
double nOffset=vtOffset&vt;
|
|
if(nOffset > -m_nStairWidth)
|
|
m_nStairWidth += nOffset;
|
|
} else if(idx==6) { // new
|
|
XDirectionCurve lCurve=GetSideCurve2d(OFFSET_LEFT);
|
|
XPointDir2d ptTemp1;
|
|
lCurve.Polar(lCurve.GetLength()*m_lSectionPos, ptTemp1);
|
|
XPoint ptSect(ptTemp1);
|
|
ptSect += vtOffset;
|
|
if(lCurve.ProjectToMe(XPoint(ptSect), ptSect)==RTNORM) {
|
|
double nDist=lCurve.PathDistance(ptSect);
|
|
if(nDist>0 && nDist<lCurve.GetLength())
|
|
m_lSectionPos = nDist/lCurve.GetLength();
|
|
}
|
|
} else if(idx==7) { // new
|
|
XDirectionCurve rCurve=GetSideCurve2d(OFFSET_RIGHT);
|
|
XPointDir2d ptTemp1;
|
|
rCurve.Polar(rCurve.GetLength()*m_rSectionPos, ptTemp1);
|
|
XPoint ptSect(ptTemp1);
|
|
ptSect += vtOffset;
|
|
if(rCurve.ProjectToMe(XPoint(ptSect), ptSect)==RTNORM) {
|
|
double nDist=rCurve.PathDistance(ptSect);
|
|
if(nDist>0 && nDist<rCurve.GetLength())
|
|
m_rSectionPos = nDist/rCurve.GetLength();
|
|
}
|
|
}
|
|
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
|
|
// 功能: 夹点操作
|
|
// 状态: 有待完成修改相关墙体门窗的操作
|
|
Acad::ErrorStatus TDbLineStair::subMoveStretchPointsAt(
|
|
const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
assertWriteEnabled();
|
|
(AcGePoint3d &)m_ptLocation += offset;
|
|
return Acad::eOk;
|
|
//return moveGripPointsAt(indices, offset);
|
|
}
|
|
|
|
|
|
// 取得夹点说明
|
|
Acad::ErrorStatus TDbLineStair::GetGripText(int i, CString &cs) const
|
|
{
|
|
Acad::ErrorStatus es=Acad::eOk;
|
|
if(i<4)
|
|
cs = _T("移动梯段");
|
|
else if(i==4 || i==5)
|
|
cs = _T("改梯段宽");
|
|
// new ...
|
|
else if(i==6)
|
|
cs = _T("改剖切位置");
|
|
else if(i==7)
|
|
cs = _T("改剖切位置");
|
|
|
|
return es;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* * * * * * * * * * 取 动 态 属 性 显 示 数 据 的 函 数 * * * * * * * * * */
|
|
void TDbLineStair::GetTips(DList<TObjInfoUnit> &lstInfo) const
|
|
{
|
|
assertReadEnabled();
|
|
lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("直线梯段")));
|
|
lstInfo.Append(new TObjInfoUnit(_T("踏步宽度"), Dist2Str(GetStepWidth())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("踏步高度"), Dist2Str(GetStepHeight())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("踏步数目"), XString(_T("%d"), int(GetStepNum()))));
|
|
lstInfo.Append(new TObjInfoUnit(_T("梯段宽度"), Dist2Str(GetStairWidth())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("梯段高度"), Dist2Str(GetStairHeight())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("梯段长度"), Dist2Str(GetStairLength())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("位置标高"), Dist2Str(GetElevation())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("旋转角度"), Angle2Str(GetRotation()*180.0/PI)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("左边梁"), GetSideBeam(OFFSET_LEFT)? _T("有") : _T("无")));
|
|
lstInfo.Append(new TObjInfoUnit(_T("右边梁"), GetSideBeam(OFFSET_RIGHT)? _T("有") : _T("无")));
|
|
lstInfo.Append(new TObjInfoUnit(_T("需要2D"), Get2DFlag()? _T("是") : _T("否")));
|
|
lstInfo.Append(new TObjInfoUnit(_T("需要3D"), Get3DFlag()? _T("是") : _T("否")));
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// derived from TDbStair
|
|
XDirectionCurve
|
|
TDbLineStair::GetSideCurve2d(int nSide) const
|
|
{
|
|
assertReadEnabled();
|
|
XPoint pt[4];
|
|
pt[0]=m_ptLocation;
|
|
pt[0].z=0;
|
|
ads_polar(pt[0], m_nRotation, GetStairWidth(), pt[1]);
|
|
ads_polar(pt[1], m_nRotation+PI/2.0, GetStairLength(), pt[2]);
|
|
ads_polar(pt[0], m_nRotation+PI/2.0, GetStairLength(), pt[3]);
|
|
XDirectionCurve cv;
|
|
if(nSide==OFFSET_LEFT)
|
|
cv = XDirectionCurve(pt[0], pt[3], 0.0);
|
|
else
|
|
cv = XDirectionCurve(pt[1], pt[2], 0.0);
|
|
return cv;
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
double
|
|
TDbLineStair::GetStairLength() const
|
|
{
|
|
assertReadEnabled();
|
|
int nStepNum=IsAscent()? m_nStepNum : (m_nStepNum-1);
|
|
|
|
return GetStepWidth()*nStepNum;
|
|
}
|
|
|
|
double
|
|
TDbLineStair::GetStairWidth() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nStairWidth;
|
|
}
|
|
|
|
|
|
|
|
double
|
|
TDbLineStair::GetStepWidth() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nStepWidth;
|
|
}
|
|
|
|
|
|
void
|
|
TDbLineStair::SetStepWidth(double w)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nStepWidth = w;
|
|
}
|
|
|
|
|
|
void
|
|
TDbLineStair::SetStairWidth(double w)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nStairWidth = w;
|
|
}
|
|
|
|
double
|
|
TDbLineStair::GetElevation() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_ptLocation.z;
|
|
}
|
|
|
|
void
|
|
TDbLineStair::SetElevation(double nElev)
|
|
{
|
|
assertWriteEnabled();
|
|
m_ptLocation.z = nElev;
|
|
}
|
|
|
|
void
|
|
TDbLineStair::SetLocation(const XPoint &pt)
|
|
{
|
|
assertWriteEnabled();
|
|
m_ptLocation = pt;
|
|
}
|
|
|
|
XPoint
|
|
TDbLineStair::GetLocation() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_ptLocation;
|
|
}
|
|
|
|
double
|
|
TDbLineStair::GetRotation() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nRotation;
|
|
}
|
|
|
|
void
|
|
TDbLineStair::SetRotation(double r)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nRotation=CT_std_angle(r);
|
|
}
|
|
|
|
//add by xlc on 080729
|
|
//TArch8
|
|
double TDbLineStair::GetSlopeLength()const
|
|
{
|
|
assertReadEnabled();
|
|
return m_dSlopeLength;
|
|
}
|
|
void TDbLineStair::SetSlopeLength(double l)
|
|
{
|
|
assertWriteEnabled();
|
|
m_dSlopeLength=l;
|
|
}
|
|
|
|
// cet 2013.9.3 add
|
|
CString TDbLineStair::GetXml(const AcGeMatrix3d& mat) const
|
|
{
|
|
TXmlTree xmlTree;
|
|
POSITION posRoot = xmlTree.Insert(_T("ATS_LINESTAIR"), NULL, NULL);
|
|
{
|
|
xmlTree.SetAttribute(posRoot, _T("name"), _T("楼梯"));
|
|
xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称"));
|
|
}
|
|
|
|
POSITION posWidth = xmlTree.Insert(_T("StairWidth"), posRoot, NULL);
|
|
{
|
|
xmlTree.SetAttribute(posWidth, _T("name"), _T("楼梯宽度"));
|
|
CString sText;
|
|
sText.Format(_T("%f"), m_nStairWidth);
|
|
xmlTree.SetItemText(posWidth, sText);
|
|
}
|
|
|
|
POSITION posStepWidth = xmlTree.Insert(_T("StepWidth"), posRoot, posWidth);
|
|
{
|
|
xmlTree.SetAttribute(posStepWidth, _T("name"), _T("踏步宽度"));
|
|
CString sText;
|
|
sText.Format(_T("%f"), m_nStepWidth);
|
|
xmlTree.SetItemText(posStepWidth, sText);
|
|
}
|
|
|
|
POSITION posStepNum = xmlTree.Insert(_T("StepNum"), posRoot, posStepWidth);
|
|
{
|
|
xmlTree.SetAttribute(posStepNum, _T("name"), _T("踏步数"));
|
|
CString sText;
|
|
sText.Format(_T("%d"), m_nStepNum);
|
|
xmlTree.SetItemText(posStepNum, sText);
|
|
}
|
|
|
|
POSITION posStepHeight = xmlTree.Insert(_T("StepHeight"), posRoot, posStepNum);
|
|
{
|
|
xmlTree.SetAttribute(posStepHeight, _T("name"), _T("踏步高度"));
|
|
CString sText;
|
|
sText.Format(_T("%f"), m_nStepHeight);
|
|
xmlTree.SetItemText(posStepHeight, sText);
|
|
}
|
|
|
|
POSITION posAngle = xmlTree.Insert(_T("Angle"), posRoot, posStepHeight);
|
|
{
|
|
xmlTree.SetAttribute(posAngle, _T("name"), _T("旋转角度"));
|
|
AcGeVector3d vtAngle = AcGeVector3d::kXAxis;
|
|
vtAngle.rotateBy(Wcs2Ucs(m_nRotation), AcGeVector3d::kZAxis);
|
|
vtAngle.transformBy(mat);
|
|
double dAngle = AcGeVector3d::kXAxis.angleTo(vtAngle, AcGeVector3d::kZAxis);
|
|
dAngle = Ucs2Wcs(dAngle);
|
|
CString sText;
|
|
sText.Format(_T("%f"), dAngle);
|
|
xmlTree.SetItemText(posAngle, sText);
|
|
}
|
|
|
|
POSITION posLoc = xmlTree.Insert(_T("Location"), posRoot, posAngle);
|
|
{
|
|
XPoint ptLoc = m_ptLocation;
|
|
ptLoc.TransformBy(mat);
|
|
xmlTree.SetAttribute(posLoc, _T("name"), _T("位置点"));
|
|
CString sText;
|
|
sText.Format(_T("%f,%f,%f"), ptLoc.x, ptLoc.y, ptLoc.z);
|
|
xmlTree.SetItemText(posLoc, sText);
|
|
}
|
|
|
|
POSITION posElevation = xmlTree.Insert(_T("Elevation"), posRoot, posLoc);
|
|
{
|
|
xmlTree.SetAttribute(posElevation, _T("name"), _T("底标高"));
|
|
CString sText;
|
|
sText.Format(_T("%f"), GetElevation());
|
|
xmlTree.SetItemText(posElevation, sText);
|
|
}
|
|
|
|
POSITION posPath = xmlTree.Insert(_T("Path"), posRoot, posElevation);
|
|
{
|
|
xmlTree.SetAttribute(posPath, _T("name"), _T("路径"));
|
|
// 楼梯平面长度
|
|
double dLen = (int)(m_nStepNum * m_nStepWidth + 0.5);
|
|
AcGeVector3d vtDir = AcGeVector3d::kXAxis;
|
|
vtDir.rotateBy(Ucs2Wcs(0) + PI / 2 + m_nRotation, AcGeVector3d::kZAxis);
|
|
XPoint ptS = m_ptLocation, ptE = m_ptLocation + vtDir * dLen;
|
|
vtDir.rotateBy(PI / 2, AcGeVector3d::kZAxis);
|
|
ptS -= vtDir * m_nStairWidth * 0.5;
|
|
ptE -= vtDir * m_nStairWidth * 0.5;
|
|
ptS.TransformBy(mat);
|
|
ptE.TransformBy(mat);
|
|
POSITION posStartPoint = xmlTree.Insert(_T("Start_Point"), posPath, NULL);
|
|
{
|
|
xmlTree.SetAttribute(posStartPoint, _T("name"), _T("起点"));
|
|
CString sText;
|
|
sText.Format(_T("%f,%f,%f"), ptS.x, ptS.y, 0);
|
|
xmlTree.SetItemText(posStartPoint, sText);
|
|
}
|
|
|
|
POSITION posEndPoint = xmlTree.Insert(_T("End_Point"), posPath, posStartPoint);
|
|
{
|
|
xmlTree.SetAttribute(posEndPoint, _T("name"), _T("终点"));
|
|
CString sText;
|
|
sText.Format(_T("%f,%f,%f"), ptE.x, ptE.y, 0);
|
|
xmlTree.SetItemText(posEndPoint, sText);
|
|
}
|
|
}
|
|
|
|
POSITION posId = xmlTree.Insert(_T("Object_ID"), posRoot, posPath);
|
|
{
|
|
xmlTree.SetAttribute(posId, _T("name"), _T("对象编号"));
|
|
xmlTree.SetAttribute(posId, _T("comment"), _T("当前对象的句柄"));
|
|
CString sText;
|
|
sText.Format(_T("%ld"), objectId());
|
|
xmlTree.SetItemText(posId, sText);
|
|
}
|
|
|
|
CString strBase = TEntityBase::GetXml(mat);
|
|
CString strXml = xmlTree.GetXml();
|
|
int nIndex = strXml.Find(_T("<Object_ID"));
|
|
strXml.Insert(nIndex, strBase);
|
|
return strXml;
|
|
}
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
// 圆弧梯段对象类
|
|
/////////////////////////////////////////////////////////////
|
|
//TArch5,6=1,TArch7=2
|
|
const Adesk::UInt8 TDbArcStair::g_nVersion = 2;
|
|
|
|
|
|
ACRX_DXF_DEFINE_MEMBERS(ATSArcStair, ATSStair, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
|
1, ATS_ARCSTAIR, "ATS_ARCSTAIR图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
|
|
|
|
IMPLEMENT_TENTBASE(TDbArcStair);
|
|
|
|
TDbArcStair::TDbArcStair()
|
|
{
|
|
m_nStartAngle=m_nSweepAngle=0;
|
|
m_nRadiusIn=m_nRadiusOut=0;
|
|
}
|
|
|
|
|
|
TDbArcStair::~TDbArcStair()
|
|
{
|
|
}
|
|
|
|
// 提供对格式刷的支持
|
|
void TDbArcStair::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbStair::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
|
|
TDbArcStair *pSrc=TDbArcStair::cast(pSrcEntity);
|
|
if(pSrc) {
|
|
}
|
|
}
|
|
|
|
|
|
BOOL
|
|
TDbArcStair::IsValid() const
|
|
{
|
|
BOOL bRet=TDbStair::IsValid();
|
|
if(!bRet)
|
|
return bRet;
|
|
return (m_nRadiusIn>_DIST_SNAP &&
|
|
m_nRadiusOut>(m_nRadiusIn+_DIST_SNAP));
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbArcStair::subGetClassID(CLSID* pClsid) const
|
|
{
|
|
return Acad::eOk;
|
|
|
|
}
|
|
|
|
// 从DWG读入数据:
|
|
Acad::ErrorStatus TDbArcStair::dwgInFields (AcDbDwgFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
Acad::ErrorStatus es = TDbStair::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_ptCenter);
|
|
pFiler->readItem(&m_nRadiusIn);
|
|
pFiler->readItem(&m_nRadiusOut);
|
|
pFiler->readItem(&m_nStartAngle);
|
|
pFiler->readItem(&m_nSweepAngle);
|
|
|
|
if(nVer>1)
|
|
{
|
|
ReadPoly2D(pFiler,m_polyIn);
|
|
ReadPoly2D(pFiler,m_polyOut);
|
|
}
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbArcStair::dwgOutFields(AcDbDwgFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es = TDbStair::dwgOutFields(pFiler);
|
|
if(es != Acad::eOk) return es;
|
|
|
|
if(g_nSaveTArchVer<7)
|
|
pFiler->writeItem((Adesk::UInt8)1);
|
|
else
|
|
pFiler->writeItem(g_nVersion);
|
|
|
|
pFiler->writeItem((AcGePoint3d &)m_ptCenter);
|
|
pFiler->writeItem(m_nRadiusIn);
|
|
pFiler->writeItem(m_nRadiusOut);
|
|
pFiler->writeItem(m_nStartAngle);
|
|
pFiler->writeItem(m_nSweepAngle);
|
|
|
|
if(g_nSaveTArchVer>6)
|
|
{
|
|
WritePoly2D(pFiler,m_polyIn);
|
|
WritePoly2D(pFiler,m_polyOut);
|
|
}
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
|
|
|
|
Acad::ErrorStatus TDbArcStair::dxfInFields (AcDbDxfFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
Acad::ErrorStatus es = TDbStair::dxfInFields(pFiler);
|
|
if(es!=Acad::eOk)
|
|
return es;
|
|
if (!pFiler->atSubclassData(_T("TDbArcStair"))) {
|
|
return Acad::eBadDxfSequence;
|
|
}
|
|
int fieldsFlags=0;
|
|
resbuf rb;
|
|
double r1, r2, r3, r4;
|
|
XPoint pt;
|
|
while ((es == Acad::eOk)
|
|
&& ((es = pFiler->readResBuf(&rb)) == Acad::eOk)) {
|
|
switch (rb.restype) {
|
|
case AcDb::kDxfReal+3:
|
|
r1=rb.resval.rreal;
|
|
fieldsFlags |= 0x01;
|
|
break;
|
|
case AcDb::kDxfReal+4:
|
|
r2=rb.resval.rreal;
|
|
fieldsFlags |= 0x02;
|
|
break;
|
|
case AcDb::kDxfAngle:
|
|
r3 = rb.resval.rreal;
|
|
fieldsFlags |= 0x04;
|
|
break;
|
|
case AcDb::kDxfAngle+1:
|
|
r4 = rb.resval.rreal;
|
|
fieldsFlags |= 0x08;
|
|
break;
|
|
case AcDb::kDxfXCoord:
|
|
pt=rb.resval.rpoint;
|
|
fieldsFlags |= 0x10;
|
|
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: 43"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
if (!(fieldsFlags&0x02)) {
|
|
pFiler->setError(Acad::eMissingDxfField,
|
|
_T("\nMissing DXF group code: 44"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
if(r1>=r2) {
|
|
pFiler->setError(Acad::eMissingDxfField,
|
|
_T("\nError DXF group code: 43, 44"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
if (!(fieldsFlags&0x08)) {
|
|
pFiler->setError(Acad::eMissingDxfField,
|
|
_T("\nMissing DXF group code: 51"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
if (!(fieldsFlags&0x10)) {
|
|
pFiler->setError(Acad::eMissingDxfField,
|
|
_T("\nMissing DXF group code: 10"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
m_nRadiusIn=r1;
|
|
m_nRadiusOut=r2;
|
|
if(fieldsFlags&0x04)
|
|
m_nStartAngle=r3;
|
|
m_nSweepAngle=r4;
|
|
m_ptCenter=pt;
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbArcStair::dxfOutFields(AcDbDxfFiler* pFiler) const
|
|
{
|
|
Acad::ErrorStatus es = TDbStair::dxfOutFields(pFiler);
|
|
if(es!=Acad::eOk)
|
|
return es;
|
|
pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbArcStair"));
|
|
pFiler->writeDouble(AcDb::kDxfReal+3, m_nRadiusIn);
|
|
pFiler->writeDouble(AcDb::kDxfReal+4, m_nRadiusOut);
|
|
pFiler->writeDouble(AcDb::kDxfAngle, m_nStartAngle);
|
|
pFiler->writeDouble(AcDb::kDxfAngle+1, m_nSweepAngle);
|
|
pFiler->writePoint3d(AcDb::kDxfXCoord, m_ptCenter);
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Overriden functions for edit
|
|
// to do:
|
|
// 允许通过夹点改变边界
|
|
Acad::ErrorStatus TDbArcStair::subGetGripPoints(AcGePoint3dArray& gripPoints,
|
|
AcDbIntArray& osnapModes,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
assertReadEnabled();
|
|
gripPoints.append(m_ptCenter);
|
|
|
|
XPoint ptCorn[4];
|
|
ads_polar(m_ptCenter, m_nStartAngle, m_nRadiusIn, ptCorn[0]);
|
|
ads_polar(m_ptCenter, m_nStartAngle, m_nRadiusOut, ptCorn[1]);
|
|
double nEndAngle=CT_std_angle(m_nStartAngle+m_nSweepAngle);
|
|
ads_polar(m_ptCenter, nEndAngle, m_nRadiusIn, ptCorn[2]);
|
|
ads_polar(m_ptCenter, nEndAngle, m_nRadiusOut, ptCorn[3]);
|
|
ptCorn[2].z += GetStairHeight();
|
|
ptCorn[3].z += GetStairHeight();
|
|
for(int i=0; i<4; i++)
|
|
gripPoints.append(ptCorn[i]);
|
|
|
|
|
|
XPoint ptSideIn, ptSideOut;
|
|
double nMidAngle=CT_std_angle(m_nStartAngle+m_nSweepAngle/2.0);
|
|
ads_polar(m_ptCenter, nMidAngle, m_nRadiusIn, ptSideIn);
|
|
ads_polar(m_ptCenter, nMidAngle, m_nRadiusOut, ptSideOut);
|
|
gripPoints.append(ptSideIn); // 5
|
|
gripPoints.append(ptSideOut); //6
|
|
|
|
int nFlag2d=Get2DFlag();
|
|
if(nFlag2d==SF_1SECT || nFlag2d==SF_2SECT) {
|
|
XDirectionCurve lCurve=GetSideCurve2d(OFFSET_LEFT),
|
|
rCurve=GetSideCurve2d(OFFSET_RIGHT);
|
|
XPointDir2d ptTemp1, ptTemp2;
|
|
lCurve.Polar(lCurve.GetLength()*m_lSectionPos, ptTemp1);
|
|
rCurve.Polar(rCurve.GetLength()*m_rSectionPos, ptTemp2);
|
|
gripPoints.append(ptTemp1);
|
|
gripPoints.append(ptTemp2);
|
|
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// stretch points is diffrent from grep points, with no midpoint included
|
|
Acad::ErrorStatus TDbArcStair::subGetStretchPoints(AcGePoint3dArray & gripPoints) const
|
|
{
|
|
assertReadEnabled();
|
|
XDirectionCurve lCurve=GetSideCurve2d(OFFSET_LEFT),
|
|
rCurve=GetSideCurve2d(OFFSET_RIGHT);
|
|
gripPoints.append(lCurve.StartPoint());
|
|
gripPoints.append(lCurve.EndPoint());
|
|
gripPoints.append(rCurve.StartPoint());
|
|
gripPoints.append(rCurve.EndPoint());
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
|
|
|
|
// Active when being rotated, scaled, moved, etc.
|
|
Acad::ErrorStatus TDbArcStair::subTransformBy(const AcGeMatrix3d& xform)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbStair::subTransformBy(xform);
|
|
|
|
XPoint ptS, ptE, ptM;
|
|
ads_polar(m_ptCenter, m_nStartAngle, m_nRadiusOut, ptS);
|
|
ads_polar(m_ptCenter, GetEndAngle(), m_nRadiusOut, ptE);
|
|
ads_polar(m_ptCenter, m_nStartAngle+GetSweepAngle()/2.0, m_nRadiusOut, ptM);
|
|
((AcGePoint3d &)ptS).transformBy(xform);
|
|
((AcGePoint3d &)ptE).transformBy(xform);
|
|
((AcGePoint3d &)ptM).transformBy(xform);
|
|
((AcGePoint3d &)m_ptCenter).transformBy(xform);
|
|
m_nStartAngle = ads_angle(m_ptCenter, ptS);
|
|
double nEndAngle = ads_angle(m_ptCenter, ptE);
|
|
double nMidAngle = ads_angle(m_ptCenter, ptM);
|
|
|
|
XSector sec1(m_nStartAngle, nEndAngle), sec2(nEndAngle, m_nStartAngle);
|
|
if(CT_IsExactSameDrt(sec1.MidAngle(), nMidAngle, _angSnap))
|
|
m_nSweepAngle=fabs(m_nSweepAngle);
|
|
else if(CT_IsExactSameDrt(sec2.MidAngle(), nMidAngle, _angSnap))
|
|
m_nSweepAngle=-fabs(m_nSweepAngle);
|
|
|
|
if(!!m_polyIn)
|
|
m_polyIn.TransformBy(xform);
|
|
if(!!m_polyOut)
|
|
m_polyOut.TransformBy(xform);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// 功能: 夹点操作
|
|
Acad::ErrorStatus TDbArcStair::subMoveGripPointsAt(
|
|
const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
assertWriteEnabled();
|
|
XPoint vtOffset=*(XPoint *)&offset;
|
|
BOOL bMoved=FALSE;
|
|
for (int i = 0; i < indices.length(); i++) {
|
|
int idx = indices[i];
|
|
if(idx<5 && !bMoved) {
|
|
m_ptCenter += vtOffset;
|
|
bMoved=TRUE;
|
|
} else if(idx==5) {
|
|
double nMidAngle=CT_std_angle(m_nStartAngle+m_nSweepAngle/2.0);
|
|
XPoint vt(cos(nMidAngle), sin(nMidAngle));
|
|
double nOffset=vtOffset&vt;
|
|
if(-nOffset<m_nRadiusIn && nOffset<GetStairWidth())
|
|
m_nRadiusIn += nOffset;
|
|
} else if(idx==6) {
|
|
double nMidAngle=CT_std_angle(m_nStartAngle+m_nSweepAngle/2.0);
|
|
XPoint vt(cos(nMidAngle), sin(nMidAngle));
|
|
double nOffset=vtOffset&vt;
|
|
if(-nOffset<GetStairWidth())
|
|
m_nRadiusOut += nOffset;
|
|
} else if(idx==7) {
|
|
XDirectionCurve lCurve=GetSideCurve2d(OFFSET_LEFT);
|
|
XPointDir2d ptTemp1;
|
|
lCurve.Polar(lCurve.GetLength()*m_lSectionPos, ptTemp1);
|
|
XPoint ptSect(ptTemp1);
|
|
ptSect += vtOffset;
|
|
if(lCurve.ProjectToMe(XPoint(ptSect), ptSect)==RTNORM) {
|
|
double nDist=lCurve.PathDistance(ptSect);
|
|
if(nDist>0 && nDist<lCurve.GetLength())
|
|
m_lSectionPos = nDist/lCurve.GetLength();
|
|
}
|
|
} else if(idx==8) {
|
|
XDirectionCurve rCurve=GetSideCurve2d(OFFSET_RIGHT);
|
|
XPointDir2d ptTemp1;
|
|
rCurve.Polar(rCurve.GetLength()*m_rSectionPos, ptTemp1);
|
|
XPoint ptSect(ptTemp1);
|
|
ptSect += vtOffset;
|
|
if(rCurve.ProjectToMe(XPoint(ptSect), ptSect)==RTNORM) {
|
|
double nDist=rCurve.PathDistance(ptSect);
|
|
if(nDist>0 && nDist<rCurve.GetLength())
|
|
m_rSectionPos = nDist/rCurve.GetLength();
|
|
}
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
|
|
// 功能: 夹点操作
|
|
// 状态: 有待完成修改相关墙体门窗的操作
|
|
Acad::ErrorStatus TDbArcStair::subMoveStretchPointsAt(
|
|
const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
if(indices.length()) {
|
|
AcGeMatrix3d mat;
|
|
mat.setToTranslation(offset);
|
|
subTransformBy(mat);
|
|
}
|
|
return Acad::eOk;
|
|
//return moveGripPointsAt(indices, offset);
|
|
}
|
|
|
|
|
|
// 取得夹点说明
|
|
Acad::ErrorStatus TDbArcStair::GetGripText(int i, CString &cs) const
|
|
{
|
|
Acad::ErrorStatus es=Acad::eOk;
|
|
if(i<5)
|
|
cs = _T("移动梯段");
|
|
else if(i==5)
|
|
cs = _T("改内径");
|
|
else if(i==6)
|
|
cs = _T("改外径");
|
|
else if(i==7)
|
|
cs = _T("改剖切位置");
|
|
else if(i==8)
|
|
cs = _T("改剖切位置");
|
|
return es;
|
|
}
|
|
|
|
|
|
|
|
|
|
/* * * * * * * * * * 取 动 态 属 性 显 示 数 据 的 函 数 * * * * * * * * * */
|
|
void TDbArcStair::GetTips(DList<TObjInfoUnit> &lstInfo) const
|
|
{
|
|
lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("圆弧梯段")));
|
|
lstInfo.Append(new TObjInfoUnit(_T("踏步高度"), Dist2Str(GetStepHeight())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("踏步数目"), XString(_T("%d"), int(GetStepNum()))));
|
|
lstInfo.Append(new TObjInfoUnit(_T("内半径"), Dist2Str(GetRadiusIn())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("外半径"), Dist2Str(GetRadiusOut())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("起始角度"), Dist2Str(GetStartAngle()*180/PI)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("圆心角"), Angle2Str(GetSweepAngle()*180/PI)));
|
|
lstInfo.Append(new TObjInfoUnit(_T("梯段宽度"), Dist2Str(GetStairWidth())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("梯段高度"), Dist2Str(GetStairHeight())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("起始标高"), Dist2Str(GetElevation())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("左边梁"), GetSideBeam(OFFSET_LEFT)? _T("有") : _T("无")));
|
|
lstInfo.Append(new TObjInfoUnit(_T("右边梁"), GetSideBeam(OFFSET_RIGHT)? _T("有") : _T("无")));
|
|
lstInfo.Append(new TObjInfoUnit(_T("需要2D"), Get2DFlag()? _T("是") : _T("否")));
|
|
lstInfo.Append(new TObjInfoUnit(_T("需要3D"), Get3DFlag()? _T("是") : _T("否")));
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// derived from TDbStair
|
|
XDirectionCurve
|
|
TDbArcStair::GetSideCurve2d(int nSide) const
|
|
{
|
|
assertReadEnabled();
|
|
XPoint pt0=m_ptCenter;
|
|
pt0.z=0;
|
|
|
|
double nEndAng=GetEndAngle();
|
|
XDirectionCurve cv;
|
|
if(IsClockwise()) {
|
|
cv = XDirectionCurve(XArc(pt0, nSide==OFFSET_RIGHT? m_nRadiusIn : m_nRadiusOut,
|
|
nEndAng, m_nStartAngle), TRUE);
|
|
} else {
|
|
cv = XDirectionCurve(XArc(pt0, nSide==OFFSET_LEFT? m_nRadiusIn : m_nRadiusOut,
|
|
m_nStartAngle, nEndAng), FALSE);
|
|
}
|
|
return cv;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbArcStair::ExplodeOrDraw2d(XExplodeDraw&dc)const
|
|
{
|
|
if(!!m_polyIn||!!m_polyOut)
|
|
{
|
|
XPoly2D in=m_polyIn,out=m_polyOut;
|
|
if(!in)
|
|
GetSideCurve2d(IsClockwise()?OFFSET_RIGHT:OFFSET_LEFT).AsPoly2D(in);
|
|
if(!out)
|
|
GetSideCurve2d(IsClockwise()?OFFSET_LEFT:OFFSET_RIGHT).AsPoly2D(out);
|
|
|
|
XPoly2D outline(1);
|
|
outline<<out;
|
|
outline.GetBulges() << out.GetBulges();
|
|
in.Reverse();
|
|
outline<<in;
|
|
outline.GetBulges() << in.GetBulges();
|
|
outline.SetElevation(0);
|
|
dc.PushClip(outline,XDcClip::kClipOut);
|
|
|
|
if(!!m_polyIn)
|
|
dc<<m_polyIn;
|
|
if(!!m_polyOut)
|
|
dc<<m_polyOut;
|
|
dc.PopClip();
|
|
}
|
|
|
|
return TDbStair::ExplodeOrDraw2d(dc);
|
|
}
|
|
//扇步
|
|
void FanStair()
|
|
{
|
|
Entity ent;
|
|
if(SelectEntity(_T("\n选择圆弧梯段<退出>:"),ent,RBList(RTDXF0,_T("ATS_ARCSTAIR"),NULL))!=RTNORM)
|
|
return;
|
|
|
|
RBList mask(RTDXF0,_T("LWPOLYLINE,LINE,ARC"),0);
|
|
OPENOBJ_BEGIN(ent,AcDb::kForWrite,TDbArcStair,pStair)
|
|
if(pStair!=NULL)
|
|
{
|
|
Entity entPoly;
|
|
if(SelectEntity(_T("\n选择扇步内侧边界<不变>:"),entPoly,mask)==RTNORM)
|
|
{
|
|
XPoly2D poly(entPoly);
|
|
pStair->SetPolyIn(poly);
|
|
entPoly.Delete();
|
|
}
|
|
if(SelectEntity(_T("\n选择扇步外侧边界<不变>:"),entPoly,mask)==RTNORM)
|
|
{
|
|
XPoly2D poly(entPoly);
|
|
pStair->SetPolyOut(poly);
|
|
entPoly.Delete();
|
|
}
|
|
}
|
|
OPENOBJ_END()
|
|
}
|
|
/////////////////////////////////////////////////////////////////
|
|
|
|
double
|
|
TDbArcStair::GetStairWidth() const
|
|
{
|
|
assertReadEnabled();
|
|
return (m_nRadiusOut-m_nRadiusIn);
|
|
}
|
|
|
|
|
|
|
|
double
|
|
TDbArcStair::GetAverageStepWidth() const
|
|
{
|
|
assertReadEnabled();
|
|
double nAng = fabs(m_nSweepAngle/(m_nStepNum-1));
|
|
return ((nAng*m_nRadiusIn+nAng*m_nRadiusOut)/2.0);
|
|
}
|
|
|
|
double
|
|
TDbArcStair::GetRadiusIn() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nRadiusIn;
|
|
}
|
|
|
|
double
|
|
TDbArcStair::GetRadiusOut() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nRadiusOut;
|
|
}
|
|
|
|
|
|
|
|
|
|
XPoint
|
|
TDbArcStair::GetCenter() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_ptCenter;
|
|
}
|
|
|
|
double
|
|
TDbArcStair::GetElevation() const
|
|
{
|
|
return m_ptCenter.z;
|
|
}
|
|
|
|
double
|
|
TDbArcStair::GetStartAngle() const
|
|
{
|
|
return m_nStartAngle;
|
|
}
|
|
|
|
double
|
|
TDbArcStair::GetEndAngle() const
|
|
{
|
|
return CT_std_angle(m_nStartAngle+m_nSweepAngle);
|
|
}
|
|
|
|
double
|
|
TDbArcStair::GetSweepAngle() const
|
|
{
|
|
return m_nSweepAngle;
|
|
}
|
|
|
|
BOOL
|
|
TDbArcStair::IsClockwise() const
|
|
{
|
|
assertReadEnabled();
|
|
return (m_nSweepAngle<0);
|
|
}
|
|
|
|
|
|
void
|
|
TDbArcStair::SetRadiusIn(double r)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nRadiusIn=r;
|
|
}
|
|
|
|
void
|
|
TDbArcStair::SetRadiusOut(double r)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nRadiusOut = r;
|
|
}
|
|
|
|
|
|
void
|
|
TDbArcStair::SetElevation(double nElev)
|
|
{
|
|
assertWriteEnabled();
|
|
m_ptCenter.z = nElev;
|
|
}
|
|
|
|
void
|
|
TDbArcStair::SetCenter(const XPoint &pt)
|
|
{
|
|
assertWriteEnabled();
|
|
m_ptCenter = pt;
|
|
}
|
|
|
|
|
|
void
|
|
TDbArcStair::SetStartAngle(double ang)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nStartAngle=CT_std_angle(ang);
|
|
}
|
|
|
|
void
|
|
TDbArcStair::SetSweepAngle(double ang)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nSweepAngle = ang;
|
|
}
|
|
|
|
// cet 2013.9.4 add
|
|
CString TDbArcStair::GetXml(const AcGeMatrix3d& mat) const
|
|
{
|
|
TXmlTree xmlTree;
|
|
POSITION posRoot = xmlTree.Insert(_T("ATS_ARCSTAIR"), NULL, NULL);
|
|
{
|
|
xmlTree.SetAttribute(posRoot, _T("name"), _T("楼梯"));
|
|
xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称"));
|
|
}
|
|
|
|
POSITION posStepNum = xmlTree.Insert(_T("StepNum"), posRoot, NULL);
|
|
{
|
|
xmlTree.SetAttribute(posStepNum, _T("name"), _T("踏步数"));
|
|
CString sText;
|
|
sText.Format(_T("%d"), m_nStepNum);
|
|
xmlTree.SetItemText(posStepNum, sText);
|
|
}
|
|
|
|
POSITION posStepHeight = xmlTree.Insert(_T("StepHeight"), posRoot, posStepNum);
|
|
{
|
|
xmlTree.SetAttribute(posStepHeight, _T("name"), _T("踏步高度"));
|
|
CString sText;
|
|
sText.Format(_T("%f"), m_nStepHeight);
|
|
xmlTree.SetItemText(posStepHeight, sText);
|
|
}
|
|
|
|
POSITION posExRadius = xmlTree.Insert(_T("ExcircleRadius"), posRoot, posStepHeight);
|
|
{
|
|
xmlTree.SetAttribute(posExRadius, _T("name"), _T("外圆半径"));
|
|
CString sText;
|
|
sText.Format(_T("%f"), m_nRadiusOut);
|
|
xmlTree.SetItemText(posExRadius, sText);
|
|
}
|
|
|
|
POSITION posInRadius = xmlTree.Insert(_T("InnerCircleRadius"), posRoot, posExRadius);
|
|
{
|
|
xmlTree.SetAttribute(posInRadius, _T("name"), _T("内圆半径"));
|
|
CString sText;
|
|
sText.Format(_T("%f"), m_nRadiusIn);
|
|
xmlTree.SetItemText(posInRadius, sText);
|
|
}
|
|
|
|
POSITION posCenterAngle = xmlTree.Insert(_T("CentralAngle"), posRoot, posInRadius);
|
|
{
|
|
xmlTree.SetAttribute(posCenterAngle, _T("name"), _T("圆心角"));
|
|
CString sText;
|
|
sText.Format(_T("%f"), m_nSweepAngle);
|
|
xmlTree.SetItemText(posCenterAngle, sText);
|
|
}
|
|
|
|
POSITION posLoc = xmlTree.Insert(_T("Location"), posRoot, posCenterAngle);
|
|
{
|
|
XPoint ptLoc = m_ptCenter;
|
|
ptLoc.TransformBy(mat);
|
|
xmlTree.SetAttribute(posLoc, _T("name"), _T("位置点"));
|
|
CString sText;
|
|
sText.Format(_T("%f,%f,%f"), ptLoc.x, ptLoc.y, ptLoc.z);
|
|
xmlTree.SetItemText(posLoc, sText);
|
|
}
|
|
|
|
POSITION posElevation = xmlTree.Insert(_T("Elevation"), posRoot, posLoc);
|
|
{
|
|
xmlTree.SetAttribute(posElevation, _T("name"), _T("底标高"));
|
|
CString sText;
|
|
sText.Format(_T("%f"), GetElevation());
|
|
xmlTree.SetItemText(posElevation, sText);
|
|
}
|
|
|
|
POSITION posPath = xmlTree.Insert(_T("Path"), posRoot, posElevation);
|
|
{
|
|
xmlTree.SetAttribute(posPath, _T("name"), _T("路径"));
|
|
AcGeVector3d vtDir = AcGeVector3d::kXAxis;
|
|
vtDir.rotateBy(Ucs2Wcs(0) + m_nStartAngle, AcGeVector3d::kZAxis);
|
|
double dRadius = m_nRadiusIn + (m_nRadiusOut - m_nRadiusIn) * 0.5;
|
|
XPoint ptS = m_ptCenter + vtDir * dRadius;
|
|
vtDir.rotateBy(m_nSweepAngle * 0.5, AcGeVector3d::kZAxis);
|
|
XPoint ptMid = m_ptCenter + vtDir * dRadius;
|
|
vtDir.rotateBy(m_nSweepAngle * 0.5, AcGeVector3d::kZAxis);
|
|
XPoint ptE = m_ptCenter + vtDir * dRadius;
|
|
ptS.TransformBy(mat);
|
|
ptMid.TransformBy(mat);
|
|
ptE.TransformBy(mat);
|
|
POSITION posStartPoint = xmlTree.Insert(_T("Start_Point"), posPath, NULL);
|
|
{
|
|
xmlTree.SetAttribute(posStartPoint, _T("name"), _T("起点"));
|
|
CString sText;
|
|
sText.Format(_T("%f,%f,%f"), ptS.x, ptS.y, 0);
|
|
xmlTree.SetItemText(posStartPoint, sText);
|
|
}
|
|
|
|
POSITION posMidPoint = xmlTree.Insert(_T("Mid_Point"), posPath, posStartPoint);
|
|
{
|
|
xmlTree.SetAttribute(posMidPoint, _T("name"), _T("中点"));
|
|
CString sText;
|
|
sText.Format(_T("%f,%f,%f"), ptMid.x, ptMid.y, 0);
|
|
xmlTree.SetItemText(posMidPoint, sText);
|
|
}
|
|
|
|
POSITION posEndPoint = xmlTree.Insert(_T("End_Point"), posPath, posMidPoint);
|
|
{
|
|
xmlTree.SetAttribute(posEndPoint, _T("name"), _T("终点"));
|
|
CString sText;
|
|
sText.Format(_T("%f,%f,%f"), ptE.x, ptE.y, 0);
|
|
xmlTree.SetItemText(posEndPoint, sText);
|
|
}
|
|
}
|
|
|
|
POSITION posId = xmlTree.Insert(_T("Object_ID"), posRoot, posPath);
|
|
{
|
|
xmlTree.SetAttribute(posId, _T("name"), _T("对象编号"));
|
|
xmlTree.SetAttribute(posId, _T("comment"), _T("当前对象的句柄"));
|
|
CString sText;
|
|
sText.Format(_T("%ld"), objectId());
|
|
xmlTree.SetItemText(posId, sText);
|
|
}
|
|
|
|
CString strBase = TEntityBase::GetXml(mat);
|
|
CString strXml = xmlTree.GetXml();
|
|
int nIndex = strXml.Find(_T("<Object_ID"));
|
|
strXml.Insert(nIndex, strBase);
|
|
return strXml;
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
static BOOL ValidateCurve(const XDirectionCurve &m_lCurve, const XDirectionCurve &m_rCurve)
|
|
{
|
|
XDirectionCurve lCurve=m_lCurve, rCurve=m_rCurve;
|
|
lCurve.SetElevation(0.0);
|
|
rCurve.SetElevation(0.0);
|
|
lCurve.SetLineFlag(LS_FINITE);
|
|
rCurve.SetLineFlag(LS_FINITE);
|
|
BOOL bRet=(!!lCurve && !!rCurve && !lCurve.Intersection(rCurve, XPoint(), XPoint())
|
|
&& rCurve.OnWhichSide(lCurve.StartPoint())==OFFSET_LEFT
|
|
&& rCurve.OnWhichSide(lCurve.EndPoint())==OFFSET_LEFT
|
|
&& rCurve.OnWhichSide(lCurve.MidPoint())==OFFSET_LEFT);
|
|
return bRet;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
// 任意梯段对象类
|
|
/////////////////////////////////////////////////////////////
|
|
|
|
const Adesk::UInt8 TDbCurveStair::g_nVersion = 1;
|
|
|
|
|
|
ACRX_DXF_DEFINE_MEMBERS(ATSCurveStair, ATSStair, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
|
1, ATS_CURVESTAIR, "ATS_CURVESTAIR图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
|
|
|
|
IMPLEMENT_TENTBASE(TDbCurveStair);
|
|
|
|
TDbCurveStair::TDbCurveStair()
|
|
{
|
|
m_nElevation=0.0;
|
|
}
|
|
|
|
|
|
TDbCurveStair::~TDbCurveStair()
|
|
{
|
|
}
|
|
|
|
BOOL TDbCurveStair::IsValid() const
|
|
{
|
|
BOOL bRet=TDbStair::IsValid();
|
|
if(!bRet)
|
|
return bRet;
|
|
XDirectionCurve lCurve=m_lCurve;
|
|
XDirectionCurve rCurve=m_rCurve;
|
|
lCurve.SetLineFlag(LS_FINITE);
|
|
rCurve.SetLineFlag(LS_FINITE);
|
|
bRet=ValidateCurve(m_lCurve, m_rCurve);
|
|
return bRet;
|
|
}
|
|
|
|
// 提供对格式刷的支持
|
|
void TDbCurveStair::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbStair::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
|
|
TDbCurveStair *pSrc=TDbCurveStair::cast(pSrcEntity);
|
|
if(pSrc) {
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbCurveStair::subGetClassID(CLSID* pClsid) const
|
|
{
|
|
return Acad::eOk;
|
|
|
|
}
|
|
|
|
// 从DWG读入数据:
|
|
Acad::ErrorStatus TDbCurveStair::dwgInFields (AcDbDwgFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
Acad::ErrorStatus es = TDbStair::dwgInFields(pFiler);
|
|
if(es != Acad::eOk) return es;
|
|
Adesk::UInt8 nVer;
|
|
pFiler->readItem(&nVer);
|
|
if(nVer>g_nVersion) {// Version is too new
|
|
return Acad::eMakeMeProxy;
|
|
}
|
|
|
|
pFiler->readItem(&m_nElevation);
|
|
AcGePoint2d ptTemp;
|
|
pFiler->readItem(&ptTemp); m_lCurve.StartPoint()=ptTemp;
|
|
pFiler->readItem(&ptTemp); m_lCurve.EndPoint()=ptTemp;
|
|
|
|
double dBulge = 0;
|
|
pFiler->readItem(&dBulge);
|
|
m_lCurve.SetBulge(dBulge);
|
|
pFiler->readItem(&ptTemp); m_rCurve.StartPoint()=ptTemp;
|
|
pFiler->readItem(&ptTemp); m_rCurve.EndPoint()=ptTemp;
|
|
pFiler->readItem(&dBulge);
|
|
m_rCurve.SetBulge(dBulge);
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveStair::dwgOutFields(AcDbDwgFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es = TDbStair::dwgOutFields(pFiler);
|
|
if(es != Acad::eOk) return es;
|
|
|
|
pFiler->writeItem(g_nVersion);
|
|
|
|
pFiler->writeItem(m_nElevation);
|
|
pFiler->writeItem(m_lCurve.StartPoint().AsAcGePoint2d());
|
|
pFiler->writeItem(m_lCurve.EndPoint().AsAcGePoint2d());
|
|
pFiler->writeItem(m_lCurve.GetBulge());
|
|
pFiler->writeItem(m_rCurve.StartPoint().AsAcGePoint2d());
|
|
pFiler->writeItem(m_rCurve.EndPoint().AsAcGePoint2d());
|
|
pFiler->writeItem(m_rCurve.GetBulge());
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
|
|
Acad::ErrorStatus TDbCurveStair::dxfInFields (AcDbDxfFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
Acad::ErrorStatus es = TDbStair::dxfInFields(pFiler);
|
|
if(es!=Acad::eOk)
|
|
return es;
|
|
|
|
if (!pFiler->atSubclassData(_T("TDbCurveStair"))) {
|
|
return Acad::eBadDxfSequence;
|
|
}
|
|
|
|
int fieldsFlags=0;
|
|
resbuf rb;
|
|
double r1, r2, r3;
|
|
XPoint pt1, pt2, pt3, pt4;
|
|
while ((es == Acad::eOk)
|
|
&& ((es = pFiler->readResBuf(&rb)) == Acad::eOk)) {
|
|
switch (rb.restype) {
|
|
case 148:
|
|
r1=rb.resval.rreal;
|
|
fieldsFlags |= 0x01;
|
|
break;
|
|
case AcDb::kDxfXCoord:
|
|
pt1=rb.resval.rpoint;
|
|
fieldsFlags |= 0x02;
|
|
break;
|
|
case AcDb::kDxfXCoord+1:
|
|
pt2=rb.resval.rpoint;
|
|
fieldsFlags |= 0x04;
|
|
break;
|
|
case AcDb::kDxfXCoord+2:
|
|
pt3=rb.resval.rpoint;
|
|
fieldsFlags |= 0x08;
|
|
break;
|
|
case AcDb::kDxfXCoord+3:
|
|
pt4=rb.resval.rpoint;
|
|
fieldsFlags |= 0x10;
|
|
break;
|
|
case AcDb::kDxfAngle:
|
|
r2 = rb.resval.rreal;
|
|
fieldsFlags |= 0x20;
|
|
break;
|
|
case AcDb::kDxfAngle+1:
|
|
r3 = rb.resval.rreal;
|
|
fieldsFlags |= 0x40;
|
|
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&0x02)) {
|
|
pFiler->setError(Acad::eMissingDxfField,
|
|
_T("\nMissing DXF group code: 10"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
if (!(fieldsFlags&0x04)) {
|
|
pFiler->setError(Acad::eMissingDxfField,
|
|
_T("\nMissing DXF group code: 11"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
if (!(fieldsFlags&0x08)) {
|
|
pFiler->setError(Acad::eMissingDxfField,
|
|
_T("\nMissing DXF group code: 12"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
if (!(fieldsFlags&0x10)) {
|
|
pFiler->setError(Acad::eMissingDxfField,
|
|
_T("\nMissing DXF group code: 13"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
m_lCurve.StartPoint()=pt1;
|
|
m_lCurve.EndPoint()=pt2;
|
|
m_rCurve.StartPoint()=pt3;
|
|
m_rCurve.EndPoint()=pt4;
|
|
if(fieldsFlags&0x01) {
|
|
m_lCurve.SetElevation(r1);
|
|
m_rCurve.SetElevation(r1);
|
|
} else {
|
|
m_lCurve.SetElevation(0.0);
|
|
m_rCurve.SetElevation(0.0);
|
|
}
|
|
|
|
if(fieldsFlags&0x20)
|
|
m_lCurve.SetBulge(r2);
|
|
else
|
|
m_lCurve.SetBulge(0.0);
|
|
if(fieldsFlags&0x40)
|
|
m_rCurve.SetBulge(r3);
|
|
else
|
|
m_rCurve.SetBulge(0.0);
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbCurveStair::dxfOutFields(AcDbDxfFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es = TDbStair::dxfOutFields(pFiler);
|
|
if(es!=Acad::eOk)
|
|
return es;
|
|
es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbCurveStair"));
|
|
assert(es == Acad::eOk);
|
|
|
|
pFiler->writeDouble(148, GetElevation());
|
|
pFiler->writePoint2d(AcDb::kDxfXCoord, m_lCurve.StartPoint());
|
|
pFiler->writePoint2d(AcDb::kDxfXCoord+1, m_lCurve.EndPoint());
|
|
pFiler->writePoint2d(AcDb::kDxfXCoord+2, m_rCurve.StartPoint());
|
|
pFiler->writePoint2d(AcDb::kDxfXCoord+3, m_rCurve.EndPoint());
|
|
pFiler->writeDouble(AcDb::kDxfAngle, m_lCurve.GetBulge());
|
|
pFiler->writeDouble(AcDb::kDxfAngle+1, m_rCurve.GetBulge());
|
|
|
|
return pFiler->filerStatus();;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Overriden functions for edit
|
|
// to do:
|
|
// 允许通过夹点改变边界
|
|
Acad::ErrorStatus TDbCurveStair::subGetGripPoints(AcGePoint3dArray& gripPoints,
|
|
AcDbIntArray& osnapModes,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
assertReadEnabled();
|
|
gripPoints.append(m_lCurve.StartPoint());
|
|
gripPoints.append(m_lCurve.EndPoint());
|
|
XPoint ptMid = m_lCurve.MidPoint();
|
|
gripPoints.append(ptMid);
|
|
|
|
gripPoints.append(m_rCurve.StartPoint());
|
|
gripPoints.append(m_rCurve.EndPoint());
|
|
ptMid = m_rCurve.MidPoint();
|
|
gripPoints.append(ptMid);
|
|
|
|
int nFlag2d=Get2DFlag();
|
|
if(nFlag2d==SF_1SECT || nFlag2d==SF_2SECT) {
|
|
XDirectionCurve lCurve=GetSideCurve2d(OFFSET_LEFT),
|
|
rCurve=GetSideCurve2d(OFFSET_RIGHT);
|
|
XPointDir2d ptTemp1, ptTemp2;
|
|
lCurve.Polar(lCurve.GetLength()*m_lSectionPos, ptTemp1);
|
|
rCurve.Polar(rCurve.GetLength()*m_rSectionPos, ptTemp2);
|
|
gripPoints.append(ptTemp1); //6
|
|
gripPoints.append(ptTemp2); //7
|
|
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// stretch points is diffrent from grep points, with no midpoint included
|
|
Acad::ErrorStatus TDbCurveStair::subGetStretchPoints(AcGePoint3dArray & gripPoints) const
|
|
{
|
|
assertReadEnabled();
|
|
XDirectionCurve lCurve=GetSideCurve2d(OFFSET_LEFT),
|
|
rCurve=GetSideCurve2d(OFFSET_RIGHT);
|
|
gripPoints.append(lCurve.StartPoint());
|
|
gripPoints.append(lCurve.EndPoint());
|
|
gripPoints.append(rCurve.StartPoint());
|
|
gripPoints.append(rCurve.EndPoint());
|
|
return Acad::eOk;
|
|
}
|
|
|
|
|
|
|
|
// Active when being rotated, scaled, moved, etc.
|
|
Acad::ErrorStatus TDbCurveStair::subTransformBy(const AcGeMatrix3d& xform)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbStair::subTransformBy(xform);
|
|
ads_matrix mat;
|
|
memcpy(mat, &xform, sizeof(ads_matrix));
|
|
|
|
XDirectionCurve lCurve=m_lCurve, rCurve=m_rCurve;
|
|
|
|
lCurve.TransUCS(mat);
|
|
rCurve.TransUCS(mat);
|
|
double nNewElevation = m_nElevation + lCurve.StartPoint().z;
|
|
lCurve.SetElevation(0.0);
|
|
rCurve.SetElevation(0.0);
|
|
|
|
if(IsMirrorMatrix(mat))
|
|
TchPrivate::Exchange(lCurve, rCurve);
|
|
|
|
Acad::ErrorStatus es=Acad::eOk;
|
|
if(ValidateCurve(lCurve, rCurve)) {
|
|
m_lCurve=lCurve;
|
|
m_rCurve=rCurve;
|
|
m_nElevation=nNewElevation;
|
|
} else {
|
|
es=Acad::eInvalidInput;
|
|
}
|
|
|
|
return es;
|
|
}
|
|
|
|
// 功能: 夹点操作
|
|
Acad::ErrorStatus TDbCurveStair::subMoveGripPointsAt(
|
|
const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
assertWriteEnabled();
|
|
XPoint vtOffset=*(XPoint *)&offset;
|
|
vtOffset.z=0;
|
|
ads_matrix matTrans;
|
|
XPoint ptOrg;
|
|
ptOrg.GetMoveMatrix(vtOffset, matTrans);
|
|
BOOL bMoveLeft=(indices.contains(0) && indices.contains(1) && indices.contains(2));
|
|
BOOL bMoveRight=(indices.contains(3) && indices.contains(4) && indices.contains(5));
|
|
Acad::ErrorStatus es=Acad::eOk;
|
|
XDirectionCurve lCurve=m_lCurve;
|
|
XDirectionCurve rCurve=m_rCurve;
|
|
if(bMoveLeft && bMoveRight) {
|
|
AcGeMatrix3d mat;
|
|
memcpy(&mat, &matTrans, sizeof(ads_matrix));
|
|
return subTransformBy(mat);
|
|
} else if(bMoveLeft) {
|
|
lCurve.StartPoint() += vtOffset;
|
|
lCurve.EndPoint() += vtOffset;
|
|
if(ValidateCurve(lCurve, m_rCurve))
|
|
m_lCurve=lCurve;
|
|
else
|
|
es=Acad::eInvalidInput;
|
|
return es;
|
|
} else if(bMoveRight) {
|
|
rCurve.StartPoint() += vtOffset;
|
|
rCurve.EndPoint() += vtOffset;
|
|
if(ValidateCurve(m_lCurve, rCurve))
|
|
m_rCurve=rCurve;
|
|
else
|
|
es=Acad::eInvalidInput;
|
|
return es;
|
|
}
|
|
|
|
for (int i = 0; i < indices.length(); i++) {
|
|
int idx = indices[i];
|
|
if(idx==6) { // new
|
|
XDirectionCurve lCurve=GetSideCurve2d(OFFSET_LEFT);
|
|
XPointDir2d ptTemp1;
|
|
lCurve.Polar(lCurve.GetLength()*m_lSectionPos, ptTemp1);
|
|
XPoint ptSect(ptTemp1);
|
|
ptSect += vtOffset;
|
|
if(lCurve.ProjectToMe(XPoint(ptSect), ptSect)==RTNORM) {
|
|
double nDist=lCurve.PathDistance(ptSect);
|
|
if(nDist>0 && nDist<lCurve.GetLength())
|
|
m_lSectionPos = nDist/lCurve.GetLength();
|
|
}
|
|
} else if(idx==7) { // new
|
|
XDirectionCurve rCurve=GetSideCurve2d(OFFSET_RIGHT);
|
|
XPointDir2d ptTemp1;
|
|
rCurve.Polar(rCurve.GetLength()*m_rSectionPos, ptTemp1);
|
|
XPoint ptSect(ptTemp1);
|
|
ptSect += vtOffset;
|
|
if(rCurve.ProjectToMe(XPoint(ptSect), ptSect)==RTNORM) {
|
|
double nDist=rCurve.PathDistance(ptSect);
|
|
if(nDist>0 && nDist<rCurve.GetLength())
|
|
m_rSectionPos = nDist/rCurve.GetLength();
|
|
}
|
|
} else {
|
|
XDirectionCurve &cv= idx<3? m_lCurve : m_rCurve;
|
|
if(idx>=3)
|
|
idx -= 3;
|
|
switch(idx) {
|
|
case 0:
|
|
cv.StartPoint() += vtOffset;
|
|
break;
|
|
case 1:
|
|
cv.EndPoint() += vtOffset;
|
|
break;
|
|
case 2:
|
|
if(cv.Is(CURVE_LINE)) {
|
|
cv.StartPoint() += vtOffset;
|
|
cv.EndPoint() += vtOffset;
|
|
} else {
|
|
XPoint ptMid=cv.MidPoint();
|
|
ptMid += vtOffset;
|
|
XArc ar1(cv.StartPoint(), ptMid, cv.EndPoint());
|
|
if(!!ar1) {
|
|
int nSideOld=cv.XLine::OnWhichSide(cv.MidPoint());
|
|
int nSideNew=cv.XLine::OnWhichSide(ptMid);
|
|
if(nSideOld!=nSideNew)
|
|
cv.SetBulge(- (cv.GetBulge()/fabs(cv.GetBulge()))*ar1.Bulge());
|
|
else
|
|
cv.SetBulge((cv.GetBulge()/fabs(cv.GetBulge()))*ar1.Bulge());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(!ValidateCurve(m_lCurve, m_rCurve)) {
|
|
m_lCurve=lCurve;
|
|
m_rCurve=rCurve;
|
|
es=Acad::eInvalidInput;
|
|
}
|
|
return es;
|
|
}
|
|
|
|
|
|
// 功能: 夹点操作
|
|
// 状态: 有待完成修改相关墙体门窗的操作
|
|
Acad::ErrorStatus TDbCurveStair::subMoveStretchPointsAt(
|
|
const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
assertWriteEnabled();
|
|
if(indices.length()) {
|
|
AcGeMatrix3d mat;
|
|
mat.setToTranslation(offset);
|
|
subTransformBy(mat);
|
|
}
|
|
return Acad::eOk;
|
|
// return moveGripPointsAt(indices, offset);
|
|
}
|
|
|
|
|
|
// 取得夹点说明
|
|
Acad::ErrorStatus TDbCurveStair::GetGripText(int i, CString &cs) const
|
|
{
|
|
Acad::ErrorStatus es=Acad::eOk;
|
|
if(i==6)
|
|
cs = _T("改剖切位置");
|
|
else if(i==7)
|
|
cs = _T("改剖切位置");
|
|
else {
|
|
int idx = i;
|
|
const XDirectionCurve &cv= idx<3? m_lCurve : m_rCurve;
|
|
if(idx>=3)
|
|
idx -= 3;
|
|
switch(idx) {
|
|
case 0:
|
|
cs=_T("改起点");
|
|
break;
|
|
case 1:
|
|
cs=_T("改终点");
|
|
break;
|
|
case 2:
|
|
if(cv.Is(CURVE_LINE)) {
|
|
cs = _T("平移边线");
|
|
} else {
|
|
cs = _T("改圆弧");
|
|
}
|
|
}
|
|
}
|
|
return es;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* * * * * * * * * * 取 动 态 属 性 显 示 数 据 的 函 数 * * * * * * * * * */
|
|
void TDbCurveStair::GetTips(DList<TObjInfoUnit> &lstInfo) const
|
|
{
|
|
lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("任意梯段")));
|
|
lstInfo.Append(new TObjInfoUnit(_T("踏步高度"), Dist2Str(GetStepHeight())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("踏步数目"), XString(_T("%d"), int(GetStepNum()))));
|
|
lstInfo.Append(new TObjInfoUnit(_T("梯段高度"), Dist2Str(GetStairHeight())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("位置标高"), Dist2Str(GetElevation())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("左边梁"), GetSideBeam(OFFSET_LEFT)? _T("有") : _T("无")));
|
|
lstInfo.Append(new TObjInfoUnit(_T("右边梁"), GetSideBeam(OFFSET_RIGHT)? _T("有") : _T("无")));
|
|
lstInfo.Append(new TObjInfoUnit(_T("需要2D"), Get2DFlag()? _T("是") : _T("否")));
|
|
lstInfo.Append(new TObjInfoUnit(_T("需要3D"), Get3DFlag()? _T("是") : _T("否")));
|
|
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// derived from TDbStair
|
|
XDirectionCurve
|
|
TDbCurveStair::GetSideCurve2d(int nSide) const
|
|
{
|
|
return (nSide==OFFSET_LEFT? m_lCurve : m_rCurve);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
double
|
|
TDbCurveStair::GetElevation() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nElevation;
|
|
}
|
|
|
|
void
|
|
TDbCurveStair::SetElevation(double nElev)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nElevation = nElev;
|
|
}
|
|
|
|
|
|
void
|
|
TDbCurveStair::SetSideCurve2d(XDirectionCurve lCurve, XDirectionCurve rCurve)
|
|
{
|
|
assertWriteEnabled();
|
|
m_lCurve = lCurve;
|
|
m_rCurve = rCurve;
|
|
}
|
|
|
|
|
|
|
|
int EditStair0(TDbStair *pStep, TCHAR cKey)
|
|
{
|
|
int nRet=RTNONE;
|
|
if(cKey==_T('H')) {
|
|
double nStepHeight=pStep->GetStepHeight();
|
|
nRet=GetReal(_T("\n踏步高度"), nStepHeight);
|
|
if(nRet==RTNORM) {
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->assertWriteEnabled();
|
|
pStep->SetStepHeight(nStepHeight);
|
|
pStep->downgradeOpen();
|
|
}
|
|
} else if(cKey==_T('N')) {
|
|
int nStepNum=pStep->GetStepNum();
|
|
ads_initget(RSG_NOZERO|RSG_NONEG, NULL);
|
|
adsout << _T("\n踏步数目<") << nStepNum << _T(">:");
|
|
nRet=ads_getint(_T(""), &nStepNum);
|
|
if(nRet==RTNORM) {
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->assertWriteEnabled();
|
|
pStep->SetStepNum(nStepNum);
|
|
pStep->downgradeOpen();
|
|
}
|
|
} else if(cKey==_T('T')) {
|
|
double nElev=pStep->GetElevation();
|
|
nRet=GetReal(_T("\n起始标高"), nElev);
|
|
if(nRet==RTNORM) {
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->assertWriteEnabled();
|
|
pStep->SetElevation(nElev);
|
|
pStep->downgradeOpen();
|
|
}
|
|
} else if(cKey==_T('2')) {
|
|
int nCode=0;
|
|
XString sKeyword1;
|
|
XString sPrompt(256);
|
|
sPrompt << _T("\n无二维[0]/无剖断[1]/下剖断[2]/双剖断[3]/<") << pStep->Get2DFlag() << _T(">: ");
|
|
INITGET_BEG(0, _T("0 1 2 3"));
|
|
nCode=ads_getkword(sPrompt, sKeyword1);
|
|
INITGET_END();
|
|
if(nCode==RTNORM) {
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->assertWriteEnabled();
|
|
pStep->Set2DFlag(_ttoi(sKeyword1));
|
|
pStep->downgradeOpen();
|
|
}
|
|
} else if(cKey==_T('3')) {
|
|
int nCode=0;
|
|
XString sKeyword1;
|
|
XString sPrompt(256);
|
|
int nFlag3d=pStep->Get3DFlag();
|
|
if(nFlag3d==(SF_HAS3D|SF_LBEAM)) nFlag3d=2;
|
|
else if(nFlag3d==(SF_HAS3D|SF_RBEAM)) nFlag3d=3;
|
|
else if(nFlag3d==(SF_HAS3D|SF_LBEAM|SF_RBEAM)) nFlag3d=4;
|
|
sPrompt << _T("\n无三维[0]/无边梁[1]/左边梁[2]/右边梁[3]/双边梁[4]/<") << nFlag3d << _T(">:");
|
|
|
|
INITGET_BEG(0, _T("0 1 2 3 4"));
|
|
nCode=ads_getkword(sPrompt, sKeyword1);
|
|
INITGET_END();
|
|
if(nCode==RTNORM) {
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->assertWriteEnabled();
|
|
int nInput=_ttoi(sKeyword1);
|
|
nFlag3d=0;
|
|
if(nInput<2)
|
|
nFlag3d=nInput;
|
|
else if(nInput==2)
|
|
nFlag3d=(SF_HAS3D|SF_LBEAM);
|
|
else if(nInput==3)
|
|
nFlag3d=(SF_HAS3D|SF_RBEAM);
|
|
else if(nInput==4)
|
|
nFlag3d=(SF_HAS3D|SF_LBEAM|SF_RBEAM);
|
|
pStep->Set3DFlag(nFlag3d);
|
|
pStep->downgradeOpen();
|
|
}
|
|
} else if(cKey==_T('L')) {
|
|
pStep->list();
|
|
}
|
|
|
|
return nRet;
|
|
}
|
|
|
|
// Command:编辑梯段
|
|
int EditLineStair0(AcDbObjectId id)
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForRead, TDbLineStair, pStep);
|
|
if(!pStep)
|
|
return RTERROR;
|
|
while(1) {
|
|
const TCHAR *szPrompt1=_T("\n踏步宽[W]/踏步高[H]/踏步数[N]/梯段宽[D]/二维[2]/三维[3]/起高[T]/参数[L]/<退出>:");
|
|
XString sKeyword;
|
|
int nRet=0;
|
|
INITGET_BEG(0, _T("W H N D 2 3 T L"));
|
|
nRet=ads_getkword(szPrompt1, sKeyword);
|
|
INITGET_END();
|
|
|
|
if(nRet!=RTNORM)
|
|
break;
|
|
nRet=EditStair0(pStep, sKeyword[0]);
|
|
if(nRet==RTCAN || nRet==RTERROR)
|
|
break;
|
|
else if(nRet==RTNONE) {
|
|
if(sKeyword[0]==_T('W')) {
|
|
double nStepWidth=pStep->GetStepWidth();
|
|
nRet=GetReal(_T("\n踏步宽度"), nStepWidth);
|
|
if(nRet==RTCAN)
|
|
break;
|
|
if(nRet==RTNORM) {
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->assertWriteEnabled();
|
|
pStep->SetStepWidth(nStepWidth);
|
|
if(nStepWidth>0)
|
|
pStep->SetStepHeight(fabs(pStep->GetStepHeight()));
|
|
else
|
|
pStep->SetStepHeight(-fabs(pStep->GetStepHeight()));
|
|
pStep->downgradeOpen();
|
|
}
|
|
} else if(sKeyword[0]==_T('D')) {
|
|
double nW=pStep->GetStairWidth();
|
|
nRet=GetReal(_T("\n梯段宽度"), nW);
|
|
if(nRet==RTCAN)
|
|
break;
|
|
if(nRet==RTNORM) {
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->assertWriteEnabled();
|
|
pStep->SetStairWidth(nW);
|
|
pStep->downgradeOpen();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
return RTNORM;
|
|
}
|
|
|
|
|
|
// Command:编辑弧段楼梯
|
|
int EditArcStair0(AcDbObjectId id)
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForRead, TDbArcStair, pStep);
|
|
if(!pStep)
|
|
return RTERROR;
|
|
while(1) {
|
|
const TCHAR *szPrompt1=_T("\n内径[I]/外径[O]/踏步高[H]/踏步数[N]/起角[S]/夹角[A]/二维[2]/三维[3]/起高[T]/参数[L]/<退出>:");
|
|
XString sKeyword;
|
|
int nRet=0;
|
|
INITGET_BEG(0, _T("I O H N S A 2 3 T L"));
|
|
nRet=ads_getkword(szPrompt1, sKeyword);
|
|
INITGET_END();
|
|
|
|
if(nRet!=RTNORM)
|
|
break;
|
|
nRet=EditStair0(pStep, sKeyword[0]);
|
|
if(nRet==RTCAN || nRet==RTERROR)
|
|
break;
|
|
else if(nRet==RTNONE) {
|
|
if(sKeyword[0]==_T('I')) {
|
|
double nRadiusIn=pStep->GetRadiusIn();
|
|
nRet=XGetDist(pStep->GetCenter(), _T("\n内半径"), nRadiusIn, RSG_NOZERO|RSG_NONEG);
|
|
if(nRet==RTCAN)
|
|
break;
|
|
if(nRet==RTNORM) {
|
|
if(nRadiusIn>=pStep->GetRadiusOut()) {
|
|
adsout <<_T("\n内半径不能大于外半径!");
|
|
break;
|
|
}
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->assertWriteEnabled();
|
|
pStep->SetRadiusIn(nRadiusIn);
|
|
pStep->downgradeOpen();
|
|
}
|
|
} else if(sKeyword[0]==_T('O')) {
|
|
double nRadiusOut=pStep->GetRadiusOut();
|
|
nRet=XGetDist(pStep->GetCenter(), _T("\n外半径"), nRadiusOut, RSG_NOZERO|RSG_NONEG);
|
|
if(nRet==RTCAN)
|
|
break;
|
|
if(nRet==RTNORM) {
|
|
if(nRadiusOut<=pStep->GetRadiusIn()) {
|
|
adsout <<_T("\n外半径不能小于内半径!");
|
|
break;
|
|
}
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->assertWriteEnabled();
|
|
pStep->SetRadiusOut(nRadiusOut);
|
|
pStep->downgradeOpen();
|
|
}
|
|
} else if(sKeyword[0]==_T('S')) {
|
|
double nAng=pStep->GetStartAngle();
|
|
adsout << _T("\n起始角度<") << Angle2Str(nAng*180.0/PI) << _T(">: ");
|
|
nRet=ads_getangle(pStep->GetCenter(), _T(""), &nAng);
|
|
if(nRet==RTCAN)
|
|
break;
|
|
if(nRet==RTNORM) {
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->assertWriteEnabled();
|
|
pStep->SetStartAngle(nAng);
|
|
pStep->downgradeOpen();
|
|
}
|
|
} else if(sKeyword[0]==_T('A')) {
|
|
double nAng=pStep->GetSweepAngle()*180/PI;
|
|
nRet=GetReal(_T("\n圆心角"), nAng, RSG_NOZERO);
|
|
if(nRet==RTCAN)
|
|
break;
|
|
if(nRet==RTNORM) {
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->assertWriteEnabled();
|
|
pStep->SetSweepAngle(nAng*PI/180.0);
|
|
pStep->downgradeOpen();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
return RTNORM;
|
|
}
|
|
|
|
|
|
// Command:编辑任意梯段
|
|
int EditCurveStair0(AcDbObjectId id)
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForRead, TDbCurveStair, pStep);
|
|
if(!pStep)
|
|
return RTERROR;
|
|
while(1) {
|
|
const TCHAR *szPrompt1=_T("\n踏步高[H]/踏步数[N]/二维[2]/三维[3]/起高[T]/参数[L]/<退出>:");
|
|
XString sKeyword;
|
|
int nRet=0;
|
|
INITGET_BEG(0, _T("H N 2 3 T L"));
|
|
nRet=ads_getkword(szPrompt1, sKeyword);
|
|
INITGET_END();
|
|
|
|
if(nRet!=RTNORM)
|
|
break;
|
|
nRet=EditStair0(pStep, sKeyword[0]);
|
|
if(nRet==RTCAN || nRet==RTERROR)
|
|
break;
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
return RTNORM;
|
|
}
|
|
|
|
|