838 lines
24 KiB
C++
838 lines
24 KiB
C++
#include "stdafx.h"
|
|
|
|
GEOAPI Acad::ErrorStatus ExplodeAcis(const AcDbEntity *pEntity, AcDbVoidPtrArray &entSet);
|
|
void ExplodeBlock3d(AcDbObjectId idBlock, AcDbVoidPtrArray &entSet);
|
|
//extern BOOL g_bMakeBlock;
|
|
/////////////////////////////////////////////////////////////
|
|
// 栏杆对象类
|
|
/////////////////////////////////////////////////////////////
|
|
|
|
const Adesk::UInt8 TDbRail::g_nVersion = 1;
|
|
|
|
|
|
ACRX_DXF_DEFINE_MEMBERS(ATSRail, ATSPolyPathEnt, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
|
1, ATS_RAIL, "ATS_RAIL图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
|
|
|
|
IMPLEMENT_TENTBASE(TDbRail);
|
|
|
|
TDbRail::TDbRail()
|
|
{
|
|
m_nUnitWidth=m_nInitDist=0;
|
|
m_nRailFlag=0;
|
|
m_nQuickMarker=0;
|
|
}
|
|
|
|
|
|
TDbRail::~TDbRail()
|
|
{
|
|
}
|
|
|
|
BOOL TDbRail::IsValid() const
|
|
{
|
|
BOOL bRet=TDbPolyPathEnt::IsValid();
|
|
if(!bRet)
|
|
return bRet;
|
|
|
|
bRet=(m_nUnitWidth>_DIST_SNAP); //单元宽
|
|
return bRet;
|
|
}
|
|
|
|
// 提供对格式刷的支持
|
|
void TDbRail::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
|
|
{
|
|
assertWriteEnabled();
|
|
TDbPolyPathEnt::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
|
|
TDbRail *pSrc=TDbRail::cast(pSrcEntity);
|
|
if(pSrc) {
|
|
if(database()==NULL||
|
|
pSrcEntity->database()==NULL||
|
|
database()==pSrcEntity->database())//add by whl on 060317
|
|
{
|
|
m_idUnit=pSrc->m_idUnit; //自定义扶手
|
|
}
|
|
m_nUnitWidth=pSrc->m_nUnitWidth; //单元宽
|
|
m_nInitDist=pSrc->m_nInitDist; //初始间距
|
|
m_nRailFlag=pSrc->m_nRailFlag; //单元对齐方式
|
|
}
|
|
}
|
|
|
|
|
|
Acad::ErrorStatus
|
|
TDbRail::subGetClassID(CLSID* pClsid) const
|
|
{
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// 从DWG读入数据:
|
|
Acad::ErrorStatus TDbRail::dwgInFields (AcDbDwgFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
Acad::ErrorStatus es = TDbPolyPathEnt::dwgInFields(pFiler);
|
|
if(es != Acad::eOk) return es;
|
|
Adesk::UInt8 nVer;
|
|
pFiler->readItem(&nVer);
|
|
if(nVer>g_nVersion) {// Version is too new
|
|
return Acad::eMakeMeProxy;
|
|
}
|
|
|
|
pFiler->readItem(&m_idUnit);
|
|
m_polyBase.Reset();
|
|
Adesk::UInt8 nPolyFlag;
|
|
pFiler->readItem(&nPolyFlag);
|
|
m_polyBase.SetFlag(nPolyFlag);
|
|
|
|
Adesk::UInt16 m_nCount=0;
|
|
pFiler->readItem(&m_nCount);
|
|
for(Adesk::UInt16 i=0; i<m_nCount; i++) {
|
|
AcGePoint3d pt;
|
|
double nBulge=0.0;
|
|
pFiler->readItem(&pt);
|
|
pFiler->readItem(&nBulge);
|
|
m_polyBase.AppendNode(XPoint(pt), nBulge);
|
|
}
|
|
|
|
pFiler->readItem(&m_nUnitWidth);
|
|
pFiler->readItem(&m_nInitDist);
|
|
pFiler->readItem(&m_nRailFlag);
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbRail::dwgOutFields(AcDbDwgFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es = TDbPolyPathEnt::dwgOutFields(pFiler);
|
|
if(es != Acad::eOk) return es;
|
|
|
|
pFiler->writeItem(g_nVersion);
|
|
pFiler->writeItem(m_idUnit);
|
|
|
|
pFiler->writeItem((Adesk::UInt8) m_polyBase.GetFlag());
|
|
Adesk::UInt16 nCount=m_polyBase.Length();
|
|
pFiler->writeItem(nCount);
|
|
for(Adesk::UInt16 i=0; i<nCount; i++) {
|
|
pFiler->writeItem((AcGePoint3d &)m_polyBase[i]);
|
|
pFiler->writeItem(m_polyBase.GetBulge(i));
|
|
}
|
|
|
|
|
|
pFiler->writeItem(m_nUnitWidth);
|
|
pFiler->writeItem(m_nInitDist);
|
|
pFiler->writeItem(m_nRailFlag);
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
|
|
Acad::ErrorStatus TDbRail::dxfInFields (AcDbDxfFiler* pFiler)
|
|
{
|
|
assertWriteEnabled();
|
|
|
|
Acad::ErrorStatus es = TDbPolyPathEnt::dxfInFields(pFiler);
|
|
if(es!=Acad::eOk)
|
|
return es;
|
|
|
|
if (!pFiler->atSubclassData(_T("TDbRail"))) {
|
|
return Acad::eBadDxfSequence;
|
|
}
|
|
|
|
int fieldsFlags=0;
|
|
resbuf rb;
|
|
int n1, n2;
|
|
double r1, r2;
|
|
DList<XPoint> pts;
|
|
DList<double> bulges;
|
|
XString sName;
|
|
while ((es == Acad::eOk)
|
|
&& ((es = pFiler->readResBuf(&rb)) == Acad::eOk)) {
|
|
switch (rb.restype) {
|
|
case AcDb::kDxfBlockName:
|
|
sName=rb.resval.rstring;
|
|
fieldsFlags |= 0x01;
|
|
break;
|
|
case AcDb::kDxfInt16:
|
|
n1=rb.resval.rint;
|
|
fieldsFlags |= 0x02;
|
|
break;
|
|
case AcDb::kDxfInt16+1:
|
|
n2=rb.resval.rint;
|
|
fieldsFlags |= 0x04;
|
|
break;
|
|
case AcDb::kDxfReal:
|
|
r1=rb.resval.rreal;
|
|
fieldsFlags |= 0x08;
|
|
break;
|
|
case AcDb::kDxfReal+1:
|
|
r2=rb.resval.rreal;
|
|
fieldsFlags |= 0x10;
|
|
break;
|
|
case AcDb::kDxfXCoord:
|
|
pts.Append(new XPoint(rb.resval.rpoint));
|
|
break;
|
|
case AcDb::kDxfAngle:
|
|
bulges.Append(new double(rb.resval.rreal));
|
|
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(_T("\nMissing DXF group code: 3"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
if(!(fieldsFlags&0x08)) {
|
|
pFiler->setError(_T("\nMissing DXF group code: 40"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
if(pts.Length()<2 || pts.Length()!=bulges.Length()) {
|
|
pFiler->setError(_T("\nError DXF group code: 10, 50"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
|
|
AcDbObjectId idUnit=InitBlock(sName);
|
|
if(!idUnit) {
|
|
pFiler->setError(_T("\nError DXF group code: 3"));
|
|
return Acad::eMissingDxfField;
|
|
}
|
|
m_idUnit=idUnit;
|
|
if(fieldsFlags&0x02)
|
|
m_nRailFlag=n1;
|
|
if(fieldsFlags&0x04)
|
|
m_polyBase.SetFlag(n2);
|
|
m_nUnitWidth=r1;
|
|
if (fieldsFlags&0x10)
|
|
m_nInitDist=r2;
|
|
|
|
m_polyBase.Reset();
|
|
for(int i=0; i<pts.Length(); i++) {
|
|
m_polyBase.AppendNode(*pts[i], *bulges[i]);
|
|
}
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
Acad::ErrorStatus TDbRail::dxfOutFields(AcDbDxfFiler* pFiler) const
|
|
{
|
|
assertReadEnabled();
|
|
Acad::ErrorStatus es;
|
|
|
|
es = TDbPolyPathEnt::dxfOutFields(pFiler);
|
|
assert(es == Acad::eOk);
|
|
|
|
es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbRail"));
|
|
assert(es == Acad::eOk);
|
|
XString sName=GetSymbolName(m_idUnit);
|
|
|
|
pFiler->writeString(AcDb::kDxfBlockName, sName);
|
|
pFiler->writeDouble(AcDb::kDxfReal, m_nUnitWidth);
|
|
pFiler->writeDouble(AcDb::kDxfReal+1, m_nInitDist);
|
|
pFiler->writeInt16(AcDb::kDxfInt16, m_nRailFlag);
|
|
pFiler->writeInt16(AcDb::kDxfInt16+1, m_polyBase.GetFlag());
|
|
for(int i=0; i<m_polyBase.Length(); i++) {
|
|
pFiler->writePoint3d(AcDb::kDxfXCoord, m_polyBase[i]);
|
|
pFiler->writeDouble(AcDb::kDxfAngle, m_polyBase.GetBulge(i));
|
|
}
|
|
|
|
return pFiler->filerStatus();
|
|
}
|
|
|
|
|
|
|
|
Acad::ErrorStatus
|
|
TDbRail::ExplodeOrDraw3d(XExplodeDraw &dc) const
|
|
{
|
|
// extern double g_nAcadVer;
|
|
assertReadEnabled();
|
|
if(!Has3D())
|
|
return Acad::eOk;
|
|
|
|
//add by whl 060106
|
|
if(g_bOsnapExpl&&!g_bGetExtents)
|
|
return Acad::eOk;
|
|
|
|
//if(g_bOsnapExpl)
|
|
// return Acad::eOk;
|
|
|
|
//TPushProperty vProp(this, dc);
|
|
|
|
// Add 2 line on 2002/10/41
|
|
BOOL bAutoProp=dc.IsAutoProp();
|
|
dc.SetAutoProp(FALSE);
|
|
|
|
INT_PTR nQuickMarker=GetQuickMarker();
|
|
|
|
int nEdgeNum=m_polyBase.TotalSegments();
|
|
AcDbVoidPtrArray entSet;
|
|
AcDbBlockReference entInsert(AcGePoint3d(0,0,0), m_idUnit);
|
|
entInsert.setPropertiesFrom(this);
|
|
|
|
TMasterProperties prop;
|
|
prop.SetFrom(this);
|
|
//BOOL bAcGi=false;
|
|
//if(g_nAcadVer>15.0001)
|
|
// bAcGi=(_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0);
|
|
|
|
//ExplodeBlock3d(m_idUnit, entSet);
|
|
BOOL bNewMethod=((g_nAcadVer>15.0001 && g_bMakeBlock) ||
|
|
_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())!=0);
|
|
|
|
{
|
|
extern BOOL g_bExplodeMesh;
|
|
int nDrawMode=DocGetDrawMode();
|
|
DocSetDrawMode(DRAW_3D);
|
|
XPushMemVar<BOOL> tVar1(TchGeLib::g_bExplodeMesh, TRUE); //不能使用ACIS
|
|
InitModel(prop, &entInsert, NULL, entSet);
|
|
DocSetDrawMode(nDrawMode);
|
|
}
|
|
|
|
|
|
int nGsMarker=1;
|
|
for(int n=0; n<nEdgeNum; n++) {
|
|
XDirectionCurve cvSeg;
|
|
m_polyBase.Nth(n, cvSeg);
|
|
XDirectionCurve seg2d=cvSeg;
|
|
seg2d.SetElevation(0.0);
|
|
double leng=seg2d.GetLength();
|
|
if(leng<_DIST_SNAP)
|
|
continue;
|
|
double nSlopeRate=(cvSeg.EndPoint().z - cvSeg.StartPoint().z)/leng;
|
|
leng -= m_nInitDist;
|
|
|
|
int nSeg=IsAutoExpand()? AS_INT(leng/m_nUnitWidth) : int((leng+_DIST_SNAP)/m_nUnitWidth);
|
|
if(nSeg<1)
|
|
continue;
|
|
double nNewUnitWidth=IsAutoExpand()? leng/nSeg : m_nUnitWidth ;
|
|
double sx = nNewUnitWidth/m_nUnitWidth;
|
|
|
|
// double nInitDist= (n==0? m_nInitDist : 0.0);
|
|
for(int i=0; i<nSeg; i++) {
|
|
dc.SetSelectionMarker(nGsMarker);
|
|
nGsMarker++;
|
|
if(nQuickMarker && (nGsMarker-1)!=nQuickMarker) //用于捕捉时加速
|
|
continue;
|
|
|
|
XPointDir2d ptIns;
|
|
double nDist=m_nInitDist+(i+ (IsLeftAlign()? 0.0 : 0.5))*nNewUnitWidth;
|
|
seg2d.Polar(nDist, ptIns);
|
|
ptIns.z = cvSeg.StartPoint().z + nSlopeRate*nDist;
|
|
|
|
AcGeMatrix3d matTrans;
|
|
matTrans.setToIdentity();
|
|
|
|
if(fabs(sx-1.0)>1.0E-6) {
|
|
AcGeMatrix3d mat;
|
|
mat.setToIdentity();
|
|
mat(0,0)=sx;
|
|
matTrans.preMultBy(mat);
|
|
}
|
|
double zs=nSlopeRate;
|
|
if(fabs(zs)>_DIST_SNAP) {
|
|
AcGeMatrix3d mat;
|
|
mat.setToIdentity();
|
|
mat(2,0)=zs;
|
|
matTrans.preMultBy(mat);
|
|
}
|
|
|
|
double nRot=ptIns.nDirection;
|
|
if(fabs(nRot)>_angSnap) {
|
|
AcGeMatrix3d mat;
|
|
mat.setToIdentity();
|
|
mat(0,0)=cos(nRot); mat(0,1)=-sin(nRot);
|
|
mat(1,0)=sin(nRot); mat(1,1)=cos(nRot);
|
|
matTrans.preMultBy(mat);
|
|
}
|
|
if(ptIns.Distance(XPoint())>_DIST_SNAP) {
|
|
AcGeMatrix3d mat;
|
|
mat.setToTranslation(ptIns);
|
|
matTrans.preMultBy(mat);
|
|
}
|
|
if(!bNewMethod || fabs(zs)>_DIST_SNAP) {
|
|
dc.SetAutoProp(FALSE);
|
|
dc.DrawAtomicEntSet(entSet, matTrans);
|
|
} else {
|
|
dc.SetAutoProp(TRUE);
|
|
dc<<XBlockRef(m_idUnit, ptIns, AcGeScale3d(sx, 1.0, 1.0), ptIns.nDirection, bNewMethod);
|
|
}
|
|
|
|
if(nQuickMarker && (nGsMarker-1)==nQuickMarker)
|
|
break;
|
|
}
|
|
}
|
|
ReleaseEntSet(entSet);
|
|
dc.SetAutoProp(bAutoProp); // Add On 2002/10/13
|
|
return Acad::eOk;
|
|
}
|
|
|
|
//extern double g_nAcadVer;
|
|
Acad::ErrorStatus
|
|
TDbRail::ExplodeOrDraw2d(XExplodeDraw &dc) const
|
|
{
|
|
if(!Has2D())
|
|
return Acad::eOk;
|
|
assertReadEnabled();
|
|
if(g_bOsnapExpl&&!g_bGetExtents)
|
|
return Acad::eOk;
|
|
|
|
INT_PTR nQuickMarker=GetQuickMarker();
|
|
XPoly2D polyBase(m_polyBase);
|
|
polyBase.SetElevation(0.0);
|
|
|
|
int nEdgeNum=polyBase.TotalSegments();
|
|
|
|
BOOL bNewMethod=((g_nAcadVer>15.0001 && g_bMakeBlock) ||
|
|
_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())!=0);
|
|
|
|
int nGsMarker=1;
|
|
for(int n=0; n<nEdgeNum; n++)
|
|
{
|
|
XDirectionCurve cvSeg;
|
|
polyBase.Nth(n, cvSeg);
|
|
XDirectionCurve seg2d=cvSeg;
|
|
seg2d.SetElevation(0.0);
|
|
double leng=seg2d.GetLength();
|
|
if(leng<_DIST_SNAP)
|
|
continue;
|
|
leng -= m_nInitDist;
|
|
|
|
int nSeg=IsAutoExpand()? AS_INT(leng/m_nUnitWidth) : int((leng+_DIST_SNAP)/m_nUnitWidth);
|
|
if(nSeg<1)
|
|
continue;
|
|
double nNewUnitWidth=IsAutoExpand()? leng/nSeg : m_nUnitWidth ;
|
|
double sx = nNewUnitWidth/m_nUnitWidth;
|
|
|
|
for(int i=0; i<nSeg; i++)
|
|
{
|
|
dc.SetSelectionMarker(nGsMarker);
|
|
nGsMarker++;
|
|
if(nQuickMarker && (nGsMarker-1)!=nQuickMarker) //用于捕捉时加速
|
|
continue;
|
|
|
|
XPointDir2d ptIns;
|
|
double nDist=m_nInitDist+(i+ (IsLeftAlign()? 0.0 : 0.5))*nNewUnitWidth;
|
|
seg2d.Polar(nDist, ptIns);
|
|
ptIns.z = cvSeg.StartPoint().z;
|
|
dc<<XBlockRef(m_idUnit, ptIns, AcGeScale3d(sx, 1.0, 1.0), ptIns.nDirection, bNewMethod);
|
|
if(nQuickMarker && (nGsMarker-1)==nQuickMarker)
|
|
break;
|
|
}
|
|
}
|
|
return Acad::eOk;
|
|
}
|
|
|
|
/*
|
|
Acad::ErrorStatus TDbRail::getOsnapPoints(
|
|
AcDb::OsnapMode osnapMode,
|
|
int gsSelectionMark,
|
|
const AcGePoint3d& ptPick,
|
|
const AcGePoint3d& lastPoint,
|
|
const AcGeMatrix3d& viewXform,
|
|
AcGePoint3dArray& snapPoints,
|
|
AcDbIntArray& geomIds) const
|
|
{
|
|
assertReadEnabled();
|
|
return Acad::eOk;
|
|
}
|
|
*/
|
|
|
|
// k3D 有错
|
|
TEntityBase::DrawType
|
|
TDbRail::GetDrawType() const
|
|
{
|
|
return TEntityBase::k2Dand3D;
|
|
}
|
|
|
|
const TCHAR *
|
|
TDbRail::GetDefaultLayer() const
|
|
{
|
|
return LAY_RAIL;
|
|
}
|
|
|
|
|
|
void
|
|
TDbRail::GetTips(DList<TObjInfoUnit> &lstInfo) const
|
|
{
|
|
assertReadEnabled();
|
|
lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("路径排列")));
|
|
lstInfo.Append(new TObjInfoUnit(_T("单元宽度"), Dist2Str(GetUnitWidth())));
|
|
lstInfo.Append(new TObjInfoUnit(_T("初始间距"), Dist2Str(GetInitDist())));
|
|
|
|
lstInfo.Append(new TObjInfoUnit(_T("单元自调"), IsAutoExpand()? _T("是") : _T("否")));
|
|
lstInfo.Append(new TObjInfoUnit(_T("对齐方式"), IsLeftAlign()? _T("左对齐") : _T("中间对齐")));
|
|
|
|
//lstInfo.Append(new TObjInfoUnit(_T("路径长度"), Dist2Str(GetLength())));
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////
|
|
|
|
Acad::ErrorStatus
|
|
TDbRail::SetPathPoly(const XPoly2D &polyPath,const AcGeVector3d&normal)
|
|
{
|
|
assertWriteEnabled();
|
|
m_polyBase=polyPath;
|
|
SetNormal(normal);
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus
|
|
TDbRail::GetPathPoly(XPoly2D &polyPath,AcGeVector3d &normal) const
|
|
{
|
|
assertReadEnabled();
|
|
polyPath=m_polyBase;
|
|
normal=GetNormal().AsAcGeVector3d();
|
|
return Acad::eOk;
|
|
}
|
|
|
|
|
|
AcDbObjectId
|
|
TDbRail::GetUnitId() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_idUnit;
|
|
}
|
|
|
|
BOOL
|
|
TDbRail::IsLeftAlign() const
|
|
{
|
|
assertReadEnabled();
|
|
return ((m_nRailFlag&RF_ALIGN_LEFT)!=0);
|
|
}
|
|
|
|
BOOL
|
|
TDbRail::IsAutoExpand() const
|
|
{
|
|
assertReadEnabled();
|
|
return ((m_nRailFlag&RF_AUTOEXPAND)!=0);
|
|
}
|
|
|
|
|
|
void
|
|
TDbRail::SetLeftAlign(BOOL bTrue)
|
|
{
|
|
assertWriteEnabled();
|
|
if(bTrue)
|
|
m_nRailFlag |= RF_ALIGN_LEFT;
|
|
else
|
|
m_nRailFlag &= ~RF_ALIGN_LEFT;
|
|
}
|
|
|
|
void
|
|
TDbRail::SetAutoExpand(BOOL bTrue)
|
|
{
|
|
assertWriteEnabled();
|
|
if(bTrue)
|
|
m_nRailFlag |= RF_AUTOEXPAND;
|
|
else
|
|
m_nRailFlag &= ~RF_AUTOEXPAND;
|
|
}
|
|
|
|
void
|
|
TDbRail::SetUnitId(AcDbObjectId id)
|
|
{
|
|
assertWriteEnabled();
|
|
m_idUnit=id;
|
|
}
|
|
|
|
double
|
|
TDbRail::GetInitDist() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nInitDist;
|
|
}
|
|
|
|
double
|
|
TDbRail::GetUnitWidth() const
|
|
{
|
|
assertReadEnabled();
|
|
return m_nUnitWidth;
|
|
}
|
|
|
|
|
|
void
|
|
TDbRail::SetInitDist(double h)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nInitDist=h;
|
|
}
|
|
|
|
void
|
|
TDbRail::SetUnitWidth(double w)
|
|
{
|
|
assertWriteEnabled();
|
|
m_nUnitWidth = w;
|
|
}
|
|
|
|
void
|
|
TDbRail::SetHas2D(BOOL bTrue)
|
|
{
|
|
assertWriteEnabled();
|
|
if(bTrue)
|
|
m_nRailFlag |= RF_NEED2D;
|
|
else
|
|
m_nRailFlag &= ~RF_NEED2D;
|
|
}
|
|
|
|
void
|
|
TDbRail::SetHas3D(BOOL bTrue)
|
|
{
|
|
assertWriteEnabled();
|
|
if(!bTrue)
|
|
m_nRailFlag |= RF_DISABLE3D;
|
|
else
|
|
m_nRailFlag &= ~RF_DISABLE3D;
|
|
}
|
|
|
|
BOOL TDbRail::Has2D() const
|
|
{
|
|
return ((m_nRailFlag&RF_NEED2D)!=0);
|
|
}
|
|
|
|
BOOL TDbRail::Has3D() const
|
|
{
|
|
return ((m_nRailFlag&RF_DISABLE3D)==0);
|
|
}
|
|
|
|
int EditRail0(AcDbObjectId id);
|
|
|
|
void InitDbRail(BOOL bTrue)
|
|
{
|
|
AecObjectEditMethod pOldEdit=NULL;
|
|
if(bTrue) {
|
|
TDbRail::rxInit();
|
|
acrxBuildClassHierarchy();
|
|
TDbRail::InitMatchProtocol(TRUE);
|
|
pOldEdit=TDbRail::SetEditMethod(EditRail0);
|
|
} else {
|
|
TDbRail::InitMatchProtocol(FALSE);
|
|
TDbRail::SetEditMethod(pOldEdit);
|
|
deleteAcRxClass(TDbRail::desc());
|
|
}
|
|
}
|
|
|
|
// 编辑扶手
|
|
int EditRail0(AcDbObjectId id)
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForRead, TDbRail, pStep);
|
|
if(!pStep)
|
|
return RTERROR;
|
|
while(1) {
|
|
const TCHAR *szPrompts[2]= {
|
|
_T("\n选择 [加顶点(A)/减顶点(D)/设顶点(S)/单元宽(W)/单元对齐(R)/单元自调(F)/初始间距(H)/上下移动(M)/视图模式(V)]<退出>:"),
|
|
_T("\n选择 [单元宽(W)/单元对齐(R)/单元自调(F)/初始间距(H)/上下移动(M)/二维视图(V)]<退出>:")
|
|
};
|
|
const TCHAR *szKeywords[2] = {_T("A D R S F W H M V"), _T(" W R F H M V"),};
|
|
int nIdx=pStep->IsBind()? 1: 0;
|
|
XString sKeyword;
|
|
int nRet=0;
|
|
INITGET_BEG(0, szKeywords[nIdx]);
|
|
nRet=ads_getkword(szPrompts[nIdx], sKeyword);
|
|
INITGET_END();
|
|
|
|
if(nRet!=RTNORM)
|
|
break;
|
|
if(sKeyword[0]==_T('A')) {
|
|
int nOsMode=0;
|
|
xg_getvar(_T("OSMODE"), &nOsMode);
|
|
nOsMode &= ~0x4000;
|
|
nOsMode |= OS_INT;
|
|
XPushVar<int> tVar(_T("OSMODE"), nOsMode);
|
|
XPoint ptAdd;
|
|
if(XGetPoint(NULL, _T("\n点取新的顶点位置"), ptAdd)==RTNORM) {
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
if(!pStep->AddVertex(ptAdd)) {
|
|
adsout << _T("\n请正确点取!");
|
|
}
|
|
pStep->downgradeOpen();
|
|
}
|
|
} else if(sKeyword[0]==_T('D')) {
|
|
XPushVar<int> osmode(_T("OSMODE"), OS_NOD);
|
|
XPoint ptVert;
|
|
while(ads_getpoint(NULL, _T("\n选取顶点: "), ptVert)==RTNORM) {
|
|
int nPos=pStep->HitTestOnBase2d(ptVert);
|
|
if(nPos>0) {
|
|
nPos--;
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->RemoveVertexAt(nPos);
|
|
pStep->downgradeOpen();
|
|
}
|
|
}
|
|
} else if(sKeyword[0]==_T('S')) {
|
|
XPushVar<int> osmode(_T("OSMODE"), OS_NOD);
|
|
XPoint ptVert;
|
|
while(ads_getpoint(NULL, _T("\n选取顶点: "), ptVert)==RTNORM) {
|
|
int nPos=pStep->HitTestOnBase2d(ptVert);
|
|
if(nPos>0) {
|
|
nPos--;
|
|
if(nPos==0) {
|
|
XPoly2D poly2d;
|
|
AcGeVector3d normal;
|
|
pStep->GetPathPoly(poly2d,normal);
|
|
poly2d.SetElevation(0.0);
|
|
if(poly2d.IsClosed()) {
|
|
int nAns=YesNoQuestion(_T("\n起点和终点的平面投影相同,您指的是起点吗"));
|
|
if(nAns==RTCAN)
|
|
continue;
|
|
else if(nAns==Q_NO)
|
|
nPos = poly2d.Length();
|
|
}
|
|
}
|
|
double nElev=pStep->GetElevationAt(nPos);
|
|
adsout << _T("\n改夹角[A]/点取[P]/输入顶点标高<")
|
|
<< Dist2Str(nElev)
|
|
<< _T(">: ");
|
|
int nCode;
|
|
INITGET_BEG(0, _T("A P"));
|
|
nCode=ads_getreal(_T(""), &nElev);
|
|
INITGET_END();
|
|
if(nCode==RTKWORD) {
|
|
TCHAR szKey[80]=_T("");
|
|
ads_getinput(szKey);
|
|
if(szKey[0]==_T('P')) {
|
|
XPushVar<int> osMode(_T("OSMODE"), OS_NEA);
|
|
XPoint ptElev;
|
|
nCode=ads_getpoint(NULL, _T("\n点取参照物:"), ptElev);
|
|
if(nCode==RTNORM) {
|
|
nElev=ptElev.z;
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->SetElevationAt(nPos, nElev);
|
|
pStep->downgradeOpen();
|
|
}
|
|
} else if(szKey[0]==_T('A')) {
|
|
double nOldAng=pStep->GetSweepAngleAt(nPos)*180.0/PI;
|
|
nCode=GetReal(_T("\n输入夹角"), nOldAng);
|
|
if(nCode==RTNORM) {
|
|
nOldAng *= PI/180.0;
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->SetSweepAngleAt(nPos, nOldAng);
|
|
pStep->downgradeOpen();
|
|
}
|
|
}
|
|
} else if(nCode==RTNORM) {
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->SetElevationAt(nPos, nElev);
|
|
pStep->downgradeOpen();
|
|
}
|
|
} else {
|
|
adsout << _T("\n请正确点取!");
|
|
}
|
|
}
|
|
} else if(sKeyword[0]==_T('W')) {
|
|
double nWidth=pStep->GetUnitWidth();
|
|
nRet=GetReal(_T("\n单元宽度"), nWidth, RSG_NOZERO|RSG_NONEG);
|
|
if(nRet==RTCAN)
|
|
break;
|
|
if(nRet==RTNORM) {
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->SetUnitWidth(nWidth);
|
|
pStep->downgradeOpen();
|
|
}
|
|
} else if(sKeyword[0]==_T('H')) {
|
|
double nHeight=pStep->GetInitDist();
|
|
nRet=GetReal(_T("\n初始间距"), nHeight, RSG_NONEG);
|
|
if(nRet==RTCAN)
|
|
break;
|
|
if(nRet==RTNORM) {
|
|
Acad::ErrorStatus es=pStep->upgradeOpen();
|
|
if(es!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->SetInitDist(nHeight);
|
|
es=pStep->downgradeOpen();
|
|
}
|
|
} else if(sKeyword[0]==_T('R')) {
|
|
BOOL nAlignment=pStep->IsLeftAlign();
|
|
adsout << _T("\n单元对齐方式[中间对齐(0)/左对齐(1)]<") << int(nAlignment) << _T(">: ");
|
|
XString sAlignment;
|
|
INITGET_BEG(0, _T("0 1"));
|
|
nRet=ads_getkword(_T(""), sAlignment);
|
|
INITGET_END();
|
|
|
|
if(nRet==RTCAN)
|
|
break;
|
|
if(nRet==RTNORM) {
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->SetLeftAlign(_ttoi(sAlignment));
|
|
pStep->downgradeOpen();
|
|
}
|
|
} else if(sKeyword[0]==_T('F')) {
|
|
if(pStep->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pStep->SetAutoExpand(!pStep->IsAutoExpand());
|
|
pStep->downgradeOpen();
|
|
} else if(sKeyword[0]==_T('M')) {
|
|
double nDistMove=0.0;
|
|
if(GetDist(_T("\n移动距离(正数--上移;负数--下移)"), nDistMove)==RTNORM) {
|
|
AcDbObjectId idUnit=pStep->GetUnitId();
|
|
OPENOBJ_BEGIN(idUnit, AcDb::kForWrite, AcDbBlockTableRecord, pBlock);
|
|
if(pBlock) {
|
|
AcGeMatrix3d mat;
|
|
mat.setToTranslation(AcGeVector3d(0, 0, nDistMove));
|
|
AcDbBlockTableRecordIterator *pIter=NULL;
|
|
VERIFY(pBlock->newIterator(pIter)==Acad::eOk);
|
|
for(pIter->start(); !pIter->done(); pIter->step()) {
|
|
AcDbEntity *pEnt=NULL;
|
|
VERIFY(pIter->getEntity(pEnt, AcDb::kForWrite)==Acad::eOk);
|
|
ASSERT(pEnt);
|
|
pEnt->transformBy(mat);
|
|
pEnt->close();
|
|
}
|
|
delete pIter;
|
|
|
|
//XPoint ptOrg=pBlock->origin();
|
|
//ptOrg.z -= nDistMove;
|
|
//pBlock->setOrigin(ptOrg);
|
|
}
|
|
OPENOBJ_END();
|
|
if(pStep->upgradeOpen()==Acad::eOk) {
|
|
pStep->assertWriteEnabled();
|
|
pStep->downgradeOpen();
|
|
}
|
|
}
|
|
} else if(sKeyword[0]==_T('V')) {
|
|
if(pStep->upgradeOpen()==Acad::eOk) {
|
|
pStep->assertWriteEnabled();
|
|
BOOL bHas3D=pStep->Has3D();
|
|
BOOL bHas2D=pStep->Has2D();
|
|
if(bHas2D && bHas3D)
|
|
pStep->SetHas2D(FALSE); // Disable 2d
|
|
else if(bHas3D && !bHas2D) {
|
|
pStep->SetHas3D(FALSE);
|
|
pStep->SetHas2D(TRUE);
|
|
} else {
|
|
pStep->SetHas2D(TRUE);
|
|
pStep->SetHas3D(TRUE);
|
|
}
|
|
//pStep->SetHas2D(!pStep->Has2D());
|
|
pStep->downgradeOpen();
|
|
}
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
|
|
return RTNORM;
|
|
}
|
|
|
|
|