1017 lines
27 KiB
C++
1017 lines
27 KiB
C++
#include "stdafx.h"
|
|
#include "TDbColumn.h"
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
// 屋顶对象类
|
|
/////////////////////////////////////////////////////////////
|
|
|
|
const Adesk::UInt8 TDbAscent::g_nVersion = 1;
|
|
|
|
|
|
|
|
ACRX_DXF_DEFINE_MEMBERS(ATSAscent, ATSEntity, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent, 1,
|
|
ATS_ASCENT, "ATS_ASCENT图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
|
|
|
|
IMPLEMENT_TENTBASE(TDbAscent);
|
|
|
|
TDbAscent::TDbAscent()
|
|
{
|
|
m_nLength = m_nWidth = m_nHeight = m_nIdent = 0.0;
|
|
m_nRotation = 0.0;
|
|
m_nFlag=0;
|
|
m_pTempRail=NULL;
|
|
}
|
|
|
|
|
|
TDbAscent::~TDbAscent()
|
|
{
|
|
}
|
|
|
|
BOOL
|
|
TDbAscent::IsValid() const
|
|
{
|
|
BOOL bRet=TDbEntity::IsValid();
|
|
if(!bRet)
|
|
return bRet;
|
|
return (m_nLength>0 && m_nWidth>0 && m_nWidth>m_nIdent*2
|
|
&& m_nHeight>0); // && m_nIdent>-1.0E-6
|
|
}
|
|
|
|
// 提供对格式刷的支持
|
|
void TDbAscent::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbEntity::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
|
|
TDbAscent *pSrc=TDbAscent::cast(pSrcEntity);
|
|
if(pSrc) {
|
|
m_nLength=pSrc->m_nLength;
|
|
m_nHeight=pSrc->m_nHeight;
|
|
m_nWidth=pSrc->m_nWidth;
|
|
m_nIdent=pSrc->m_nIdent;
|
|
m_nFlag=pSrc->m_nFlag;
|
|
}
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbAscent::subGetClassID(CLSID* pClsid) const
|
|
{
|
|
return Acad::eOk;
|
|
|
|
}
|
|
|
|
// 从DWG读入数据:
|
|
Acad::ErrorStatus TDbAscent::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((AcGePoint3d *)&m_ptLocation);
|
|
pFiler->readItem(&m_nRotation);
|
|
pFiler->readItem(&m_nFlag);
|
|
pFiler->readItem(&m_nLength);
|
|
pFiler->readItem(&m_nWidth);
|
|
pFiler->readItem(&m_nHeight);
|
|
pFiler->readItem(&m_nIdent);
|
|
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbAscent::dwgOutFields(AcDbDwgFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es = TDbEntity::dwgOutFields(pFiler);
|
|
if(es != Acad::eOk) return es;
|
|
|
|
pFiler->writeItem(g_nVersion);
|
|
|
|
pFiler->writeItem((AcGePoint3d &)m_ptLocation);
|
|
pFiler->writeItem(m_nRotation);
|
|
pFiler->writeItem(m_nFlag);
|
|
pFiler->writeItem(m_nLength);
|
|
pFiler->writeItem(m_nWidth);
|
|
pFiler->writeItem(m_nHeight);
|
|
pFiler->writeItem(m_nIdent);
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbAscent::dxfInFields (AcDbDxfFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
Acad::ErrorStatus es = TDbEntity::dxfInFields(pFiler);
|
|
if(es!=Acad::eOk)
|
|
return es;
|
|
if (!pFiler->atSubclassData(_T("TDbAscent"))) {
|
|
return Acad::eBadDxfSequence;
|
|
}
|
|
int fieldsFlags=0;
|
|
resbuf rb;
|
|
int nFlag;
|
|
double r1, r2, r3, r4, r5;
|
|
XPoint pt;
|
|
while ((es == Acad::eOk)
|
|
&& ((es = pFiler->readResBuf(&rb)) == Acad::eOk)) {
|
|
switch (rb.restype) {
|
|
case AcDb::kDxfXCoord:
|
|
pt=rb.resval.rpoint;
|
|
fieldsFlags |= 0x01;
|
|
break;
|
|
case AcDb::kDxfReal:
|
|
r1=rb.resval.rreal;
|
|
fieldsFlags |= 0x02;
|
|
break;
|
|
case AcDb::kDxfReal+1:
|
|
r2 = rb.resval.rreal;
|
|
fieldsFlags |= 0x04;
|
|
break;
|
|
case AcDb::kDxfReal+2:
|
|
r3=rb.resval.rreal;
|
|
fieldsFlags |= 0x08;
|
|
break;
|
|
case AcDb::kDxfReal+3:
|
|
r4=rb.resval.rreal;
|
|
fieldsFlags |= 0x10;
|
|
break;
|
|
case AcDb::kDxfAngle:
|
|
r5=rb.resval.rreal;
|
|
fieldsFlags |= 0x20;
|
|
break;
|
|
case AcDb::kDxfInt16:
|
|
nFlag=rb.resval.rint;
|
|
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&0x01)) {
|
|
pFiler->setError(Acad::eMissingDxfField,
|
|
_T("\nMissing DXF group code: 10"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
if (!(fieldsFlags&0x02)) {
|
|
pFiler->setError(Acad::eMissingDxfField,
|
|
_T("\nMissing DXF group code: 40"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
if (!(fieldsFlags&0x04)) {
|
|
pFiler->setError(Acad::eMissingDxfField,
|
|
_T("\nMissing DXF group code: 41"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
if (!(fieldsFlags&0x08)) {
|
|
pFiler->setError(Acad::eMissingDxfField,
|
|
_T("\nMissing DXF group code: 42"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
|
|
m_ptLocation=pt;
|
|
m_nLength=r1;
|
|
m_nWidth=r2;
|
|
m_nHeight=r3;
|
|
if(fieldsFlags&0x10)
|
|
m_nIdent=r4;
|
|
if(fieldsFlags&0x20)
|
|
m_nRotation=r5;
|
|
if(fieldsFlags&0x40)
|
|
m_nFlag=nFlag;
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbAscent::dxfOutFields(AcDbDxfFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es = TDbEntity::dxfOutFields(pFiler);
|
|
if(es!=Acad::eOk)
|
|
return es;
|
|
|
|
pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbAscent"));
|
|
pFiler->writePoint3d(AcDb::kDxfXCoord, m_ptLocation);
|
|
pFiler->writeDouble(AcDb::kDxfReal, m_nLength);
|
|
pFiler->writeDouble(AcDb::kDxfReal+1, m_nWidth);
|
|
pFiler->writeDouble(AcDb::kDxfReal+2, m_nHeight);
|
|
pFiler->writeDouble(AcDb::kDxfReal+3, m_nIdent);
|
|
pFiler->writeDouble(AcDb::kDxfAngle, m_nRotation);
|
|
pFiler->writeInt16(AcDb::kDxfInt16, m_nFlag);
|
|
return es;
|
|
}
|
|
|
|
|
|
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Overriden functions for edit
|
|
// to do:
|
|
// 允许通过夹点改变边界
|
|
Acad::ErrorStatus TDbAscent::subGetGripPoints(AcGePoint3dArray& gripPoints,
|
|
AcDbIntArray& osnapModes,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
//modify by xlc on 090209
|
|
// return getStretchPoints(gripPoints);
|
|
assertReadEnabled();
|
|
// 0 -- 移动
|
|
gripPoints.append(m_ptLocation);
|
|
// 1, 2 -- 改长度和宽度
|
|
gripPoints.append(GetLowLeft2d().AsAcGePoint3d());
|
|
gripPoints.append(GetLowRight2d().AsAcGePoint3d());
|
|
|
|
// [3,4]
|
|
XPoint ptUpRight=GetUpRight2d();
|
|
XPoint ptUpLeft=GetUpLeft2d();
|
|
if(!IsAligned(OFFSET_LEFT) && fabs(m_nIdent)>_DIST_SNAP) { //左小坡
|
|
XPoint ptTemp;
|
|
ads_polar(ptUpLeft, m_nRotation, m_nIdent, ptTemp);
|
|
gripPoints.append(ptTemp);
|
|
}
|
|
if(!IsAligned(OFFSET_RIGHT) && fabs(m_nIdent)>_DIST_SNAP) { //左小坡
|
|
XPoint ptTemp;
|
|
ads_polar(ptUpRight, m_nRotation+PI, m_nIdent, ptTemp);
|
|
gripPoints.append(ptTemp);
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// stretch points is diffrent from grep points, with no midpoint included
|
|
Acad::ErrorStatus TDbAscent::subGetStretchPoints(AcGePoint3dArray & stretchPoints) const
|
|
{
|
|
assertReadEnabled();
|
|
|
|
//modify by xlc on 090209修改stretch效果
|
|
// // 0 -- 移动
|
|
// stretchPoints.append(m_ptLocation);
|
|
// // 1, 2 -- 改长度和宽度
|
|
// stretchPoints.append(GetLowLeft2d().AsAcGePoint3d());
|
|
// stretchPoints.append(GetLowRight2d().AsAcGePoint3d());
|
|
//
|
|
// // [3,4]
|
|
// XPoint ptUpRight=GetUpRight2d();
|
|
// XPoint ptUpLeft=GetUpLeft2d();
|
|
// if(!IsAligned(OFFSET_LEFT) && fabs(m_nIdent)>_DIST_SNAP) { //左小坡
|
|
// XPoint ptTemp;
|
|
// ads_polar(ptUpLeft, m_nRotation, m_nIdent, ptTemp);
|
|
// stretchPoints.append(ptTemp);
|
|
// }
|
|
// if(!IsAligned(OFFSET_RIGHT) && fabs(m_nIdent)>_DIST_SNAP) { //左小坡
|
|
// XPoint ptTemp;
|
|
// ads_polar(ptUpRight, m_nRotation+PI, m_nIdent, ptTemp);
|
|
// stretchPoints.append(ptTemp);
|
|
// }
|
|
// 0 -- 改长度
|
|
stretchPoints.append(m_ptLocation);
|
|
XPoint pt;
|
|
Midpoint(GetLowLeft2d(),GetLowRight2d(),pt);
|
|
// 1 -- 改长度
|
|
stretchPoints.append(pt);
|
|
Midpoint(GetLowLeft2d(),GetUpLeft2d(),pt);
|
|
// 2 -- 改宽度
|
|
stretchPoints.append(pt);
|
|
Midpoint(GetLowRight2d(),GetUpRight2d(),pt);
|
|
// 3 -- 改宽度
|
|
stretchPoints.append(pt);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
|
|
|
|
// Active when being rotated, scaled, moved, etc.
|
|
Acad::ErrorStatus TDbAscent::subTransformBy(const AcGeMatrix3d& xform)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbEntity::subTransformBy(xform);
|
|
XPoint ptX, ptY;
|
|
ads_polar(m_ptLocation, m_nRotation, GetWidth(), ptX);
|
|
ads_polar(m_ptLocation, m_nRotation+PI/2.0, 1000.0, ptY);
|
|
((AcGePoint3d &)ptX).transformBy(xform);
|
|
((AcGePoint3d &)ptY).transformBy(xform);
|
|
((AcGePoint3d &)m_ptLocation).transformBy(xform);
|
|
double nAng = CT_std_angle(ads_angle(m_ptLocation, ptY)-
|
|
ads_angle(m_ptLocation, ptX));
|
|
if(fabs(nAng-PI*1.5)<_angSnap) {
|
|
int bLeft=IsAligned(OFFSET_LEFT),
|
|
bRight=IsAligned(OFFSET_RIGHT);
|
|
TchPrivate::Exchange(bLeft, bRight);
|
|
SetAlignment(OFFSET_LEFT, bLeft);
|
|
SetAlignment(OFFSET_RIGHT, bRight);
|
|
}
|
|
m_nRotation = ads_angle(m_ptLocation, ptY)-PI/2;
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// 功能: 夹点操作
|
|
Acad::ErrorStatus TDbAscent::subMoveGripPointsAt(
|
|
const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
assertWriteEnabled();
|
|
XVector3D vtOffset=*(XPoint *)&offset;
|
|
vtOffset.z=0;
|
|
double nVtRot=CT_std_angle(ads_angle(XPoint(), vtOffset)-m_nRotation);
|
|
double nLen=ads_distance(XPoint(), vtOffset);
|
|
double nIncWidth=nLen * cos(nVtRot);
|
|
double nIncLen=nLen * sin(nVtRot);
|
|
|
|
int idx=0;
|
|
int num=indices.length();
|
|
BOOL bChLen=FALSE;
|
|
for (int i = 0; i < num; i++) {
|
|
idx = indices[i];
|
|
switch(idx) {
|
|
case 0: // Move Location
|
|
m_ptLocation += vtOffset;
|
|
break;
|
|
case 1:
|
|
case 2: {
|
|
if(nIncLen<m_nLength && !bChLen) {
|
|
m_nLength -= nIncLen;
|
|
bChLen=TRUE; //为避免重复Stretch
|
|
}
|
|
if(idx==2) {
|
|
if(nIncWidth>-m_nWidth) {
|
|
m_nWidth += nIncWidth;
|
|
ads_polar(XPoint(m_ptLocation), m_nRotation, nIncWidth/2.0, m_ptLocation);
|
|
}
|
|
} else {
|
|
if(nIncWidth<m_nWidth) {
|
|
m_nWidth -= nIncWidth;
|
|
ads_polar(XPoint(m_ptLocation), m_nRotation, nIncWidth/2.0, m_ptLocation);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 3:
|
|
case 4:
|
|
if(!IsAligned(OFFSET_LEFT) && fabs(m_nIdent)>_DIST_SNAP && idx==3) {
|
|
double nNewIdent=m_nIdent+nIncWidth;
|
|
if(m_nWidth>nNewIdent*2)
|
|
m_nIdent = nNewIdent;
|
|
} else {
|
|
double nNewIdent=m_nIdent-nIncWidth;
|
|
if(m_nWidth>nNewIdent*2)
|
|
m_nIdent = nNewIdent;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// 取得夹点说明
|
|
Acad::ErrorStatus
|
|
TDbAscent::GetGripText(int i, CString &cs) const
|
|
{
|
|
Acad::ErrorStatus es=Acad::eOk;
|
|
switch(i) {
|
|
case 0:
|
|
cs = _T("移动斜坡");
|
|
break;
|
|
case 1:
|
|
case 2:
|
|
cs = _T("改长宽");
|
|
break;
|
|
case 3:
|
|
case 4:
|
|
cs = _T("改边坡");
|
|
break;
|
|
}
|
|
return es;
|
|
}
|
|
|
|
// 功能: 夹点操作
|
|
// 状态: 有待完成修改相关墙体门窗的操作
|
|
Acad::ErrorStatus TDbAscent::subMoveStretchPointsAt(
|
|
const AcDbIntArray& indices,
|
|
const AcGeVector3d& offset)
|
|
{
|
|
//modify by xlc on 090209修改stretch效果，改变长宽
|
|
//add by whl on 060213
|
|
// int pos;
|
|
// if(indices.find(0,pos))
|
|
// {
|
|
// AcDbIntArray indices1;
|
|
// indices1.append(0);
|
|
// return moveGripPointsAt(indices1,offset);
|
|
// }
|
|
assertWriteEnabled();
|
|
XVector3D vtOffset=*(XPoint *)&offset;
|
|
vtOffset.z=0;
|
|
double nVtRot=CT_std_angle(ads_angle(XPoint(), vtOffset)-m_nRotation);
|
|
double nLen=ads_distance(XPoint(), vtOffset);
|
|
double nIncWidth=nLen * cos(nVtRot);
|
|
double nIncLen=nLen * sin(nVtRot);
|
|
|
|
int idx=0;
|
|
int num=indices.length();
|
|
if(num!=1)
|
|
{
|
|
m_ptLocation += vtOffset;
|
|
}
|
|
else
|
|
{
|
|
int idx=indices[0];
|
|
switch(idx)
|
|
{
|
|
case 0:
|
|
if(nIncLen+m_nLength>_DIST_SNAP)
|
|
{
|
|
m_nLength += nIncLen;
|
|
ads_polar(XPoint(m_ptLocation), m_nRotation+PI*0.5, nIncLen, m_ptLocation);
|
|
}
|
|
break;
|
|
case 1:
|
|
if(m_nLength-nIncLen>_DIST_SNAP)
|
|
{
|
|
m_nLength -= nIncLen;
|
|
}
|
|
break;
|
|
case 2:
|
|
if(m_nWidth-nIncWidth>_DIST_SNAP)
|
|
{
|
|
m_nWidth -= nIncWidth;
|
|
ads_polar(XPoint(m_ptLocation), m_nRotation, nIncWidth*0.5, m_ptLocation);
|
|
}
|
|
break;
|
|
case 3:
|
|
if(m_nWidth+nIncWidth>_DIST_SNAP)
|
|
{
|
|
m_nWidth += nIncWidth;
|
|
ads_polar(XPoint(m_ptLocation), m_nRotation, nIncWidth*0.5, m_ptLocation);
|
|
}
|
|
break;
|
|
default:
|
|
m_ptLocation += vtOffset;
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
|
|
//return moveGripPointsAt(indices, offset);
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbAscent::GetExtents2d(XPoint &ptLow, XPoint &ptUp) const
|
|
{
|
|
assertReadEnabled();
|
|
XPoly2D poly(1);
|
|
poly.AppendNode(GetLowLeft2d());
|
|
poly.AppendNode(GetLowRight2d());
|
|
poly.AppendNode(GetUpRight2d());
|
|
poly.AppendNode(GetUpLeft2d());
|
|
poly.GetExtend(ptLow, ptUp);
|
|
ptLow.z=ptUp.z=0;
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbAscent::GetExtents(XPoint &ptLow, XPoint &ptUp) const
|
|
{
|
|
Acad::ErrorStatus es=GetExtents2d(ptLow, ptUp);
|
|
if(es==Acad::eOk) {
|
|
ptLow.z = GetElevation();
|
|
ptUp.z = ptLow.z + GetHeight();
|
|
}
|
|
return es;
|
|
}
|
|
|
|
|
|
Acad::ErrorStatus
|
|
TDbAscent::ExplodeOrDraw3d(XExplodeDraw &dc) const
|
|
{
|
|
//TPushProperty vProp(this, dc);
|
|
|
|
assertReadEnabled();
|
|
XPoint ptLowLeft=GetLowLeft2d();
|
|
XPoint ptLowRight=GetLowRight2d();
|
|
XPoint ptUpRight=GetUpRight2d();
|
|
XPoint ptUpLeft=GetUpLeft2d();
|
|
XPoint ptUpLeft1=ptUpLeft, ptUpRight1=ptUpRight;
|
|
|
|
XPoint lPts[3], rPts[3];
|
|
if(!IsAligned(OFFSET_LEFT) && fabs(m_nIdent)>_DIST_SNAP) { //绘制左小坡
|
|
XPoint ptTemp;
|
|
ads_polar(ptUpLeft, m_nRotation, m_nIdent, ptTemp);
|
|
ptUpLeft1=ptTemp;
|
|
lPts[0]=ptLowLeft; lPts[0].z=m_ptLocation.z-m_nHeight;
|
|
if(m_nIdent>0) {
|
|
lPts[1]=ptTemp; lPts[1].z=m_ptLocation.z;
|
|
lPts[2]=ptUpLeft; lPts[2].z=m_ptLocation.z-m_nHeight;
|
|
} else {
|
|
lPts[1]=ptUpLeft; lPts[1].z=m_ptLocation.z;
|
|
lPts[2]=ptTemp; lPts[2].z=m_ptLocation.z-m_nHeight;
|
|
}
|
|
} else { // 直面
|
|
lPts[0]=ptLowLeft; lPts[0].z=m_ptLocation.z-m_nHeight;
|
|
lPts[1]=ptUpLeft; lPts[1].z=m_ptLocation.z;
|
|
lPts[2]=ptUpLeft; lPts[2].z=m_ptLocation.z-m_nHeight;
|
|
}
|
|
|
|
|
|
if(!IsAligned(OFFSET_RIGHT) && fabs(m_nIdent)>_DIST_SNAP) { //绘制右小坡
|
|
XPoint ptTemp;
|
|
ads_polar(ptUpRight, m_nRotation+PI, m_nIdent, ptTemp);
|
|
ptUpRight1=ptTemp;
|
|
rPts[0]=ptLowRight; rPts[0].z=m_ptLocation.z-m_nHeight;
|
|
if(m_nIdent>0) {
|
|
rPts[1]=ptTemp; rPts[1].z=m_ptLocation.z;
|
|
rPts[2]=ptUpRight; rPts[2].z=m_ptLocation.z-m_nHeight;
|
|
} else {
|
|
rPts[1]=ptUpRight; rPts[1].z=m_ptLocation.z;
|
|
rPts[2]=ptTemp; rPts[2].z=m_ptLocation.z-m_nHeight;
|
|
}
|
|
} else { // 直面
|
|
rPts[0]=ptLowRight; rPts[0].z=m_ptLocation.z-m_nHeight;
|
|
rPts[1]=ptUpRight; rPts[1].z=m_ptLocation.z;
|
|
rPts[2]=ptUpRight; rPts[2].z=m_ptLocation.z-m_nHeight;
|
|
}
|
|
|
|
XPoly2D lPoly(1), rPoly(1);
|
|
for(int m=0; m<3; m++) {
|
|
lPoly.AppendNode(lPts[m]);
|
|
rPoly.AppendNode(rPts[m]);
|
|
}
|
|
dc.DrawColumn(lPoly, rPoly);
|
|
|
|
// 绘制斜面
|
|
XLine lnLeft(ptUpLeft, ptLowLeft), lnRight(ptUpRight, ptLowRight);
|
|
if(m_nIdent>_DIST_SNAP) {
|
|
if(!IsAligned(OFFSET_LEFT))
|
|
ads_polar(ptUpLeft, m_nRotation, m_nIdent, lnLeft.StartPoint());
|
|
if(!IsAligned(OFFSET_RIGHT))
|
|
ads_polar(ptUpRight, m_nRotation+PI, m_nIdent, lnRight.StartPoint());
|
|
}
|
|
if(HasSlant()) { //有防滑条
|
|
int nLineNum=AS_INT(GetLength()/_AS_SYS_UNIT(100.0));
|
|
double nInc=GetLength()/nLineNum;
|
|
double nIncH=GetHeight()/nLineNum;
|
|
XLine lnUp(ptUpLeft, ptUpRight);
|
|
XLine *pArray=new XLine[nLineNum];
|
|
for(int i=0; i<nLineNum; i++) {
|
|
XLine lnOff=lnUp.Offset((i+1)*nInc);
|
|
lnOff.SetLineFlag(LS_INFINITE);
|
|
VERIFY(lnLeft.Intersection(&lnOff, pArray[i].StartPoint()) &&
|
|
lnRight.Intersection(&lnOff, pArray[i].EndPoint()));
|
|
pArray[i].SetElevation(m_ptLocation.z - (i+1)*nIncH);
|
|
}
|
|
for(i=0; i<nLineNum-1; i++) {
|
|
XLine &lnCur=pArray[i];
|
|
XLine &lnNext=pArray[i+1];
|
|
XPoly2D polyLeft(1), polyRight(1);
|
|
XLine lnCurUp=lnCur;
|
|
lnCurUp.SetElevation(lnCur.StartPoint().z + _AS_SYS_UNIT(10.0));
|
|
polyLeft.AppendNode(lnCur.StartPoint());
|
|
polyRight.AppendNode(lnCur.EndPoint());
|
|
polyLeft.AppendNode(lnNext.StartPoint());
|
|
polyRight.AppendNode(lnNext.EndPoint());
|
|
polyLeft.AppendNode(lnCurUp.StartPoint());
|
|
polyRight.AppendNode(lnCurUp.EndPoint());
|
|
dc.DrawColumn(polyLeft, polyRight);
|
|
}
|
|
delete [] pArray;
|
|
}
|
|
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus TDbAscent::GetClipBoundary(XPoly2D &poly)const
|
|
{
|
|
poly.AppendNode(GetLowLeft2d());
|
|
poly.AppendNode(GetLowRight2d());
|
|
poly.AppendNode(GetUpRight2d());
|
|
poly.AppendNode(GetUpLeft2d());
|
|
poly.SetFlag(1);
|
|
return Acad::eOk;
|
|
}
|
|
bool TDbAscent::IsClipMe(const TEntityBase* pEnt)const
|
|
{
|
|
if(TDbEntity::IsClipMe(pEnt))
|
|
return true;
|
|
|
|
if(pEnt->GetMe()->isKindOf(TDbColumn::desc()))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
Acad::ErrorStatus
|
|
TDbAscent::ExplodeOrDraw2d(XExplodeDraw &dc) const
|
|
{
|
|
//TPushProperty vProp(this, dc);
|
|
XCurveStream dcSrc;
|
|
XPoint ptLowLeft=GetLowLeft2d();
|
|
XPoint ptLowRight=GetLowRight2d();
|
|
XPoint ptUpRight=GetUpRight2d();
|
|
XPoint ptUpLeft=GetUpLeft2d();
|
|
|
|
|
|
XLine lnLeft(ptUpLeft, ptLowLeft), lnRight(ptUpRight, ptLowRight);
|
|
if(m_nIdent>_DIST_SNAP) {
|
|
if(!IsAligned(OFFSET_LEFT))
|
|
ads_polar(ptUpLeft, m_nRotation, m_nIdent, lnLeft.StartPoint());
|
|
if(!IsAligned(OFFSET_RIGHT))
|
|
ads_polar(ptUpRight, m_nRotation+PI, m_nIdent, lnRight.StartPoint());
|
|
}
|
|
|
|
dcSrc << XLine(ptLowLeft, ptLowRight)
|
|
<< XLine(ptLowLeft, ptUpLeft)
|
|
<< XLine(ptLowRight, ptUpRight)
|
|
<< XLine(ptUpLeft, ptUpRight);
|
|
|
|
if(!IsAligned(OFFSET_LEFT) && fabs(m_nIdent)>_DIST_SNAP) {
|
|
if(m_nIdent>0) {
|
|
dcSrc << lnLeft;
|
|
} else {
|
|
XPoint ptTemp;
|
|
ads_polar(ptUpLeft, m_nRotation+PI, fabs(m_nIdent), ptTemp);
|
|
dcSrc << XLine(ptTemp, ptUpLeft) << XLine(ptTemp, ptLowLeft);
|
|
}
|
|
}
|
|
|
|
if(!IsAligned(OFFSET_RIGHT) && fabs(m_nIdent)>_DIST_SNAP) {
|
|
if(m_nIdent>0) {
|
|
dcSrc << lnRight;
|
|
} else {
|
|
XPoint ptTemp;
|
|
ads_polar(ptUpRight, m_nRotation, fabs(m_nIdent), ptTemp);
|
|
dcSrc << XLine(ptTemp, ptUpRight) << XLine(ptTemp, ptLowRight);
|
|
}
|
|
}
|
|
|
|
if(HasSlant()) { //有防滑条
|
|
int nLineNum=AS_INT(GetLength()/100.0);
|
|
double nInc=GetLength()/nLineNum;
|
|
XLine lnUp(ptUpLeft, ptUpRight);
|
|
for(int i=1; i<nLineNum; i++) {
|
|
XLine lnOff=lnUp.Offset(i*nInc);
|
|
lnOff.SetLineFlag(LS_INFINITE);
|
|
XPoint ptLeft, ptRight;
|
|
VERIFY(lnLeft.Intersection(&lnOff, ptLeft) &&
|
|
lnRight.Intersection(&lnOff, ptRight));
|
|
dcSrc << XLine(ptLeft, ptRight);
|
|
}
|
|
}
|
|
|
|
|
|
// 扶手裁剪
|
|
if(m_pTempRail) {
|
|
m_pTempRail->ClipCurveByTrace(dcSrc.m_lstCurves);
|
|
} else {
|
|
XPoly2D polyOutline(1);
|
|
polyOutline.AppendNode(GetLowLeft2d());
|
|
polyOutline.AppendNode(GetLowRight2d());
|
|
polyOutline.AppendNode(GetUpRight2d());
|
|
polyOutline.AppendNode(GetUpLeft2d());
|
|
|
|
AcDbObjectId idOwner=ownerId();
|
|
AcDbObjectIdArray railArray;
|
|
if(!!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(dcSrc.m_lstCurves);
|
|
OPENOBJ_END();
|
|
}
|
|
}
|
|
}
|
|
dcSrc.CopyTo(dc);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
|
|
|
|
const TCHAR *TDbAscent::GetDefaultLayer() const
|
|
{
|
|
return LAY_STAIR;
|
|
}
|
|
|
|
|
|
|
|
/* * * * * * * * * * 取 动 态 属 性 显 示 数 据 的 函 数 * * * * * * * * * */
|
|
void TDbAscent::GetTips(DList<TObjInfoUnit> &lstInfo) const
|
|
{
|
|
lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("坡道")));
|
|
lstInfo.Append(new TObjInfoUnit(_T("长度"), Dist2Str(GetLength())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("宽度"), Dist2Str(GetWidth())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("高度"), Dist2Str(GetHeight())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("缩进"), Dist2Str(GetIdent())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("防滑条"), m_nFlag? _T("有") : _T("无")));
|
|
lstInfo.Append(new TObjInfoUnit(_T("坡顶标高"), Dist2Str(GetElevation())));
|
|
}
|
|
|
|
void
|
|
TDbAscent::SetTempRail(TDbHandRail *pRail)
|
|
{
|
|
m_pTempRail=pRail;
|
|
}
|
|
|
|
|
|
XPoint
|
|
TDbAscent::GetUpLeft2d() const
|
|
{
|
|
assertReadEnabled();
|
|
XPoint ptUpLeft;
|
|
ads_polar(m_ptLocation, m_nRotation+PI, m_nWidth/2.0, ptUpLeft);
|
|
ptUpLeft.z=0;
|
|
return ptUpLeft;
|
|
}
|
|
|
|
XPoint
|
|
TDbAscent::GetLowLeft2d() const
|
|
{
|
|
assertReadEnabled();
|
|
XPoint ptUpLeft=GetUpLeft2d();
|
|
XPoint ptLowLeft;
|
|
ads_polar(ptUpLeft, m_nRotation-PI/2, m_nLength, ptLowLeft);
|
|
return ptLowLeft;
|
|
}
|
|
|
|
XPoint
|
|
TDbAscent::GetUpRight2d() const
|
|
{
|
|
assertReadEnabled();
|
|
XPoint ptUpRight;
|
|
ads_polar(m_ptLocation, m_nRotation, m_nWidth/2.0, ptUpRight);
|
|
ptUpRight.z=0;
|
|
return ptUpRight;
|
|
}
|
|
|
|
XPoint
|
|
TDbAscent::GetLowRight2d() const
|
|
{
|
|
assertReadEnabled();
|
|
XPoint ptUpRight=GetUpRight2d();
|
|
XPoint ptLowRight;
|
|
ads_polar(ptUpRight, m_nRotation-PI/2, m_nLength, ptLowRight);
|
|
return ptLowRight;
|
|
}
|
|
|
|
|
|
double
|
|
TDbAscent::GetElevation() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_ptLocation.z;
|
|
}
|
|
|
|
double
|
|
TDbAscent::GetHeight() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nHeight;
|
|
}
|
|
|
|
double
|
|
TDbAscent::GetWidth() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nWidth;
|
|
}
|
|
|
|
double
|
|
TDbAscent::GetIdent() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nIdent;
|
|
}
|
|
|
|
XPoint
|
|
TDbAscent::GetLocation() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_ptLocation;
|
|
}
|
|
|
|
double
|
|
TDbAscent::GetLength() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nLength;
|
|
}
|
|
|
|
double
|
|
TDbAscent::GetRotation() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nRotation;
|
|
}
|
|
|
|
BOOL
|
|
TDbAscent::HasSlant() const
|
|
{
|
|
assertReadEnabled();
|
|
return ((m_nFlag&AF_SLANT)!=0);
|
|
}
|
|
|
|
BOOL
|
|
TDbAscent::IsAligned(int nSide) const
|
|
{
|
|
assertReadEnabled();
|
|
int nTestBit=(nSide==OFFSET_LEFT? AF_LEFT : AF_RIGHT);
|
|
return ((m_nFlag&nTestBit)!=0);
|
|
}
|
|
|
|
|
|
void
|
|
TDbAscent::SetElevation(double elev)
|
|
{
|
|
assertWriteEnabled();
|
|
m_ptLocation.z = elev;
|
|
}
|
|
|
|
void
|
|
TDbAscent::SetLength(double l)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nLength=l;
|
|
}
|
|
|
|
void
|
|
TDbAscent::SetHeight(double h)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nHeight=h;
|
|
}
|
|
|
|
void
|
|
TDbAscent::SetWidth(double w)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nWidth=w;
|
|
}
|
|
|
|
void
|
|
TDbAscent::SetIdent(double i)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nIdent=i;
|
|
}
|
|
|
|
void
|
|
TDbAscent::SetLocation(XPoint ptLoc)
|
|
{
|
|
assertWriteEnabled();
|
|
m_ptLocation=ptLoc;
|
|
}
|
|
|
|
void
|
|
TDbAscent::SetRotation(double rot)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nRotation=rot;
|
|
}
|
|
|
|
void
|
|
TDbAscent::SetSlant(BOOL bTrue)
|
|
{
|
|
assertWriteEnabled();
|
|
if(bTrue)
|
|
m_nFlag |= AF_SLANT;
|
|
else
|
|
m_nFlag &= ~AF_SLANT;
|
|
}
|
|
|
|
void
|
|
TDbAscent::SetAlignment(int nSide, BOOL bTrue)
|
|
{
|
|
assertWriteEnabled();
|
|
int nTestBit=(nSide==OFFSET_LEFT? AF_LEFT : AF_RIGHT);
|
|
if(bTrue)
|
|
m_nFlag |= nTestBit;
|
|
else
|
|
m_nFlag &= ~nTestBit;
|
|
}
|
|
|
|
|
|
void InitDbAscent(BOOL bTrue)
|
|
{
|
|
if(bTrue) {
|
|
TDbAscent::rxInit();
|
|
acrxBuildClassHierarchy();
|
|
TDbAscent::InitMatchProtocol(TRUE);
|
|
TDbAscent::SetEditMethod(EditAscent0);
|
|
} else {
|
|
TDbAscent::InitMatchProtocol(FALSE);
|
|
deleteAcRxClass(TDbAscent::desc());
|
|
}
|
|
}
|
|
|
|
|
|
// Command:编辑斜坡
|
|
int EditAscent0(AcDbObjectId id)
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForRead, TDbAscent, pStep);
|
|
if(!pStep)
|
|
return RTERROR;
|
|
while(1) {
|
|
const TCHAR *szPrompt1=_T("\n选择 [长度(E)/宽度(W)/高度(H)/缩进(D)/防滑(F)/标高(T)/左齐(L)/右齐(R)]<退出>:");
|
|
XString sKeyword;
|
|
int nRet=0;
|
|
INITGET_BEG(0, _T("E W H D F T L R"));
|
|
nRet=ads_getkword(szPrompt1, sKeyword);
|
|
INITGET_END();
|
|
|
|
if(nRet!=RTNORM)
|
|
break;
|
|
if(sKeyword[0]==_T('H')) {
|
|
double nRailHeight=pStep->GetHeight();
|
|
nRet=GetReal(_T("\n高度"), nRailHeight, RSG_NONEG|RSG_NOZERO);
|
|
if(nRet==RTCAN)
|
|
break;
|
|
if(nRet==RTNORM) {
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->SetHeight(nRailHeight);
|
|
pStep->downgradeOpen();
|
|
}
|
|
} else if(sKeyword[0]==_T('T')) {
|
|
double nElev=pStep->GetElevation();
|
|
nRet=GetReal(_T("\n标高"), nElev);
|
|
if(nRet==RTCAN)
|
|
break;
|
|
if(nRet==RTNORM) {
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->SetElevation(nElev);
|
|
pStep->downgradeOpen();
|
|
}
|
|
} else if(sKeyword[0]==_T('L')) {
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->SetAlignment(OFFSET_LEFT, !pStep->IsAligned(OFFSET_LEFT));
|
|
pStep->downgradeOpen();
|
|
} else if(sKeyword[0]==_T('R')) {
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->SetAlignment(OFFSET_RIGHT, !pStep->IsAligned(OFFSET_RIGHT));
|
|
pStep->downgradeOpen();
|
|
} else if(sKeyword[0]==_T('W')) {
|
|
double nRailHeight=pStep->GetWidth();
|
|
nRet=GetReal(_T("\n宽度"), nRailHeight, RSG_NONEG|RSG_NOZERO);
|
|
if(nRet==RTCAN)
|
|
break;
|
|
if(nRet==RTNORM) {
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->SetWidth(nRailHeight);
|
|
pStep->downgradeOpen();
|
|
}
|
|
} else if(sKeyword[0]==_T('D')) {
|
|
double nRailHeight=pStep->GetIdent();
|
|
nRet=GetReal(_T("\n缩进"), nRailHeight, RSG_NOZERO);
|
|
if(nRet==RTCAN)
|
|
break;
|
|
if(nRet==RTNORM) {
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->SetIdent(nRailHeight);
|
|
pStep->downgradeOpen();
|
|
}
|
|
} else if(sKeyword[0]==_T('E')) {
|
|
double nRailHeight=pStep->GetLength();
|
|
nRet=GetReal(_T("\n长度"), nRailHeight, RSG_NONEG|RSG_NOZERO);
|
|
if(nRet==RTCAN)
|
|
break;
|
|
if(nRet==RTNORM) {
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->SetLength(nRailHeight);
|
|
pStep->downgradeOpen();
|
|
}
|
|
} else if(sKeyword[0]==_T('F')) {
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->SetSlant(!pStep->HasSlant());
|
|
pStep->downgradeOpen();
|
|
}
|
|
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
return RTNORM;
|
|
}
|
|
|