832 lines
26 KiB
C++
832 lines
26 KiB
C++
#include "stdafx.h"
|
||
|
||
//GEOAPI Acad::ErrorStatus ExplodeAcis(const AcDbEntity *pEntity, AcDbVoidPtrArray &entSet);
|
||
void ExplodeBlock3d(AcDbObjectId idBlock, AcDbVoidPtrArray &entSet);
|
||
//extern BOOL g_bMakeBlock;
|
||
/////////////////////////////////////////////////////////////
|
||
// 路径排列类
|
||
//TArch7 Beta1、2：1;TArch7 Beta3 2
|
||
const Adesk::UInt8 TDbPolyPathArray::g_nVersion = 2;
|
||
ACRX_DXF_DEFINE_MEMBERS(ATSPolyPathArray, ATSPolyCurveEnt, AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
|
||
1, ATS_PATH_ARRAY, "ATS_PATH_ARRAY图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
|
||
IMPLEMENT_TENTBASE(TDbPolyPathArray);
|
||
|
||
TDbPolyPathArray::TDbPolyPathArray()
|
||
{
|
||
m_nUnitHeight=1;
|
||
m_nRailFlag=0;
|
||
m_nRatio=1.0;
|
||
}
|
||
BOOL TDbPolyPathArray::IsValid() const
|
||
{
|
||
BOOL bRet=TDbPolyCurveEnt::IsValid();
|
||
if(!bRet)
|
||
return bRet;
|
||
|
||
bRet=(m_nUnitHeight>_DIST_SNAP&&m_nRatio>0.1); //单元宽
|
||
return bRet;
|
||
}
|
||
// 提供对格式刷的支持
|
||
void TDbPolyPathArray::CopyPropertiesFrom(AcDbEntity *pSrcEntity, unsigned gMatchFlag)
|
||
{
|
||
assertWriteEnabled();
|
||
TDbPolyCurveEnt::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
|
||
TDbPolyPathArray *pSrc=TDbPolyPathArray::cast(pSrcEntity);
|
||
if(pSrc) {
|
||
if(database()==NULL||
|
||
pSrcEntity->database()==NULL||
|
||
database()==pSrcEntity->database())//add by whl on 060317
|
||
{
|
||
m_idUnit=pSrc->m_idUnit; //自定义扶手
|
||
}
|
||
m_nUnitHeight=pSrc->m_nUnitHeight; //初始间距
|
||
m_nRailFlag=pSrc->m_nRailFlag; //单元对齐方式
|
||
m_nRatio=pSrc->m_nRatio;
|
||
}
|
||
}
|
||
|
||
Acad::ErrorStatus TDbPolyPathArray::subGetClassID(CLSID* pClsid) const
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
// 从DWG读入数据:
|
||
Acad::ErrorStatus TDbPolyPathArray::dwgInFields (AcDbDwgFiler* pFiler)
|
||
{
|
||
assertWriteEnabled();
|
||
|
||
Acad::ErrorStatus es = TDbPolyCurveEnt::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);
|
||
pFiler->readItem(&m_nUnitHeight);
|
||
pFiler->readItem(&m_nRailFlag);
|
||
|
||
if(nVer>1)//TArch7 Beta3
|
||
pFiler->readItem(&m_nRatio);
|
||
else
|
||
m_nRatio=1.0;
|
||
|
||
return pFiler->filerStatus();
|
||
}
|
||
|
||
Acad::ErrorStatus TDbPolyPathArray::dwgOutFields(AcDbDwgFiler* pFiler) const
|
||
{
|
||
assertReadEnabled();
|
||
Acad::ErrorStatus es = TDbPolyCurveEnt::dwgOutFields(pFiler);
|
||
if(es != Acad::eOk) return es;
|
||
|
||
pFiler->writeItem(g_nVersion);
|
||
|
||
pFiler->writeItem(m_idUnit);
|
||
pFiler->writeItem(m_nUnitHeight);
|
||
pFiler->writeItem(m_nRailFlag);
|
||
pFiler->writeItem(m_nRatio);
|
||
|
||
return pFiler->filerStatus();
|
||
}
|
||
|
||
|
||
Acad::ErrorStatus TDbPolyPathArray::dxfInFields (AcDbDxfFiler* pFiler)
|
||
{
|
||
assertWriteEnabled();
|
||
|
||
Acad::ErrorStatus es = TDbPolyCurveEnt::dxfInFields(pFiler);
|
||
if(es!=Acad::eOk)
|
||
return es;
|
||
|
||
if (!pFiler->atSubclassData(_T("TDbPolyPathArray"))) {
|
||
return Acad::eBadDxfSequence;
|
||
}
|
||
|
||
int fieldsFlags=0;
|
||
resbuf rb;
|
||
int n1;
|
||
double r1;
|
||
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::kDxfReal:
|
||
r1=rb.resval.rreal;
|
||
fieldsFlags |= 0x08;
|
||
break;
|
||
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;
|
||
}
|
||
|
||
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;
|
||
m_nUnitHeight=r1;
|
||
|
||
|
||
|
||
return pFiler->filerStatus();
|
||
}
|
||
Acad::ErrorStatus TDbPolyPathArray::dxfOutFields(AcDbDxfFiler* pFiler) const
|
||
{
|
||
assertReadEnabled();
|
||
Acad::ErrorStatus es;
|
||
|
||
es = TDbPolyCurveEnt::dxfOutFields(pFiler);
|
||
assert(es == Acad::eOk);
|
||
|
||
es = pFiler->writeItem(AcDb::kDxfSubclass,_T("TDbPolyPathArray"));
|
||
assert(es == Acad::eOk);
|
||
XString sName=GetSymbolName(m_idUnit);
|
||
|
||
pFiler->writeString(AcDb::kDxfBlockName, sName);
|
||
pFiler->writeDouble(AcDb::kDxfReal, m_nUnitHeight);
|
||
pFiler->writeInt16(AcDb::kDxfInt16, m_nRailFlag);
|
||
|
||
return pFiler->filerStatus();
|
||
}
|
||
//extern double g_nAcadVer;
|
||
Acad::ErrorStatus
|
||
TDbPolyPathArray::ExplodeOrDraw2d(XExplodeDraw &dc) const
|
||
{
|
||
assertReadEnabled();
|
||
if(m_idUnit.isNull()||!m_idUnit.isValid())
|
||
return Acad::eOk;
|
||
|
||
|
||
BOOL bFullExplode = ((TGGiExplodeDraw &)dc).m_bFullExplode;
|
||
BOOL bIsWdDraw = FALSE;
|
||
|
||
if (_tcscmp(dc.Desc(), TGGiWorldViewportDraw::Descriptor()) == 0)
|
||
{
|
||
bIsWdDraw = TRUE;
|
||
bFullExplode = TRUE;
|
||
}
|
||
|
||
if (!bFullExplode)
|
||
{
|
||
return Acad::eOk;
|
||
}
|
||
|
||
XPoint ptLow,ptUp;
|
||
GetBlockExtents(m_idUnit,ptLow,ptUp);
|
||
double nOldSy=ptUp.y-ptLow.y;
|
||
|
||
INT_PTR nQuickMarker=GetQuickMarker();
|
||
XPoly2D polyBase(m_polyBase);
|
||
polyBase.SetElevation(0.0);
|
||
polyBase.Compress();
|
||
|
||
int nEdgeNum=polyBase.TotalSegments();
|
||
{
|
||
BOOL bNewMethod=((g_nAcadVer>15.0001 && g_bMakeBlock) ||
|
||
_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())!=0);
|
||
|
||
//add by xlc on 120424 线图案填充显示时裁剪特殊处理
|
||
if (g_bWallLinepatClip)
|
||
{
|
||
bNewMethod = FALSE;
|
||
}
|
||
|
||
double nUnitWidth=GetUnitWidth(),nNewUnitWidth=nUnitWidth;
|
||
int nGsMarker=1;
|
||
for(int n=0; n<nEdgeNum; n++)
|
||
{
|
||
XDirectionCurve cvSeg;
|
||
polyBase.Nth(n, cvSeg);
|
||
if(GetBaseType()==0)
|
||
cvSeg=cvSeg.Offset(m_nUnitHeight*(1-m_nRatio)*0.5,LS_FINITE);
|
||
else if(GetBaseType()==1)
|
||
cvSeg=cvSeg.Offset(-m_nUnitHeight*(1+m_nRatio)*0.5,LS_FINITE);
|
||
else
|
||
cvSeg=cvSeg.Offset(-m_nUnitHeight*m_nRatio/2,LS_FINITE);
|
||
|
||
XDirectionCurve seg2d=cvSeg;
|
||
seg2d.SetElevation(0.0);
|
||
double leng=seg2d.GetLength();
|
||
if(leng<_DIST_SNAP)
|
||
continue;
|
||
|
||
double sy=GetScaleY(),sz=sy,sx=sy;
|
||
int nSeg=int((leng+_DIST_SNAP)/nUnitWidth);
|
||
if(nSeg<1)
|
||
continue;
|
||
|
||
double nEmpty=leng-nSeg*nUnitWidth;
|
||
if(IsEqualScale())
|
||
{
|
||
if(IsAutoExpand())
|
||
nNewUnitWidth=(leng+nEmpty/(nSeg-1))/nSeg;
|
||
sx=sy;
|
||
}
|
||
else
|
||
{
|
||
nNewUnitWidth=leng/nSeg;
|
||
sx*=nNewUnitWidth/nUnitWidth;
|
||
}
|
||
|
||
double sArc=1.0;
|
||
//if(cvSeg.IsMinusArc())
|
||
// sArc=(cvSeg.GetArc().radius-nOldSy)/cvSeg.GetArc().radius;
|
||
|
||
for(int i=0; i<nSeg; i++)
|
||
{
|
||
dc.SetSelectionMarker(nGsMarker);
|
||
nGsMarker++;
|
||
if(nQuickMarker && (nGsMarker-1)!=nQuickMarker) //用于捕捉时加速
|
||
continue;
|
||
|
||
XPointDir2d ptIns;
|
||
double nDist=i*nNewUnitWidth;
|
||
double dx=nNewUnitWidth;
|
||
if(IsEqualScale()&&!IsAutoExpand())
|
||
{
|
||
nDist+=nEmpty/2;
|
||
dx+=nEmpty/2;
|
||
}
|
||
|
||
if(IsReversed())
|
||
{
|
||
seg2d.Polar(nDist+nNewUnitWidth, ptIns);
|
||
ptIns.z = cvSeg.StartPoint().z;
|
||
if(seg2d.Is(CURVE_LINE))
|
||
dc<<XBlockRef(m_idUnit, ptIns, AcGeScale3d(-sx,sy,sz), ptIns.nDirection, bNewMethod);
|
||
else
|
||
{
|
||
XPointDir2d ptIns1,ptMid,ptMid1;
|
||
seg2d.Polar(nDist,ptIns1);
|
||
seg2d.Polar(nDist+dx/2,ptMid);
|
||
Midpoint(ptIns,ptIns1,ptMid1);
|
||
XPoint vtOffset=ptMid-ptMid1;
|
||
XPoint vt=ptIns-ptIns1;
|
||
vt.Normalize();
|
||
dc<<XBlockRef(m_idUnit, ptIns+vtOffset, AcGeScale3d(-sx*(ptIns1.Distance2d(ptIns)/nNewUnitWidth)*sArc,sy,sz),vt.AsAcGeVector2d().angle(), bNewMethod);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
seg2d.Polar(nDist, ptIns);
|
||
ptIns.z = cvSeg.StartPoint().z;
|
||
if(seg2d.Is(CURVE_LINE))
|
||
dc<<XBlockRef(m_idUnit, ptIns, AcGeScale3d(sx,sy,sz), ptIns.nDirection, bNewMethod);
|
||
else
|
||
{
|
||
XPointDir2d ptIns1,ptMid,ptMid1;
|
||
seg2d.Polar(nDist+nNewUnitWidth,ptIns1);
|
||
seg2d.Polar(nDist+dx/2,ptMid);
|
||
Midpoint(ptIns,ptIns1,ptMid1);
|
||
XPoint vtOffset=ptMid-ptMid1;
|
||
XPoint vt=ptIns1-ptIns;
|
||
vt.Normalize();
|
||
dc<<XBlockRef(m_idUnit, ptIns+vtOffset, AcGeScale3d(sx*(ptIns1.Distance2d(ptIns)/nNewUnitWidth)*sArc,sy,sz),vt.AsAcGeVector2d().angle(), bNewMethod);
|
||
}
|
||
}
|
||
if(nQuickMarker && (nGsMarker-1)==nQuickMarker)
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
return Acad::eOk;
|
||
}
|
||
Acad::ErrorStatus
|
||
TDbPolyPathArray::subGetOsnapPoints( AcDb::OsnapMode osnapMode,
|
||
INT_PTR gsSelectionMark,
|
||
const AcGePoint3d& ptPick,
|
||
const AcGePoint3d& lastPoint,
|
||
const AcGeMatrix3d& viewXform,
|
||
AcGePoint3dArray& snapPoints,
|
||
AcDbIntArray& geomIds) const
|
||
{
|
||
assertReadEnabled();
|
||
XPushMemVar<BOOL> vTemp(g_bSnapCurveBase,TRUE);
|
||
return TDbCurveEntity::GetOsnapPoints(osnapMode,gsSelectionMark,
|
||
ptPick, lastPoint, viewXform,snapPoints, geomIds);
|
||
}
|
||
Acad::ErrorStatus
|
||
TDbPolyPathArray::subGetOsnapPoints( AcDb::OsnapMode osnapMode,
|
||
INT_PTR gsSelectionMark,
|
||
const AcGePoint3d& ptPick,
|
||
const AcGePoint3d& lastPoint,
|
||
const AcGeMatrix3d& viewXform,
|
||
AcGePoint3dArray& snapPoints,
|
||
AcDbIntArray& geomIds,
|
||
const AcGeMatrix3d &mat) const
|
||
{
|
||
assertReadEnabled();
|
||
Acad::ErrorStatus es=Acad::eOk;
|
||
XPushMemVar<BOOL> vTemp(g_bSnapCurveBase,TRUE);
|
||
return TDbCurveEntity::GetOsnapPoints(osnapMode,gsSelectionMark,
|
||
ptPick, lastPoint, viewXform,snapPoints, geomIds,mat);
|
||
}
|
||
Acad::ErrorStatus TDbPolyPathArray::subTransformBy(const AcGeMatrix3d&mat)
|
||
{
|
||
assertWriteEnabled();
|
||
|
||
Acad::ErrorStatus es=TDbPolyCurveEnt::subTransformBy(mat);
|
||
ads_matrix mat1;
|
||
AsAdsMatrix(mat,mat1);
|
||
if(IsMirrorMatrix(mat1))
|
||
{
|
||
Reverse();//左右翻转
|
||
m_polyBase.Reverse();//上下翻转
|
||
}
|
||
|
||
return es;
|
||
}
|
||
|
||
// k3D 有错
|
||
TEntityBase::DrawType TDbPolyPathArray::GetDrawType() const
|
||
{
|
||
return TEntityBase::k2Dand3D;
|
||
}
|
||
|
||
const TCHAR * TDbPolyPathArray::GetDefaultLayer() const
|
||
{
|
||
return LAY_RAIL;
|
||
}
|
||
void TDbPolyPathArray::GetTips(DList<TObjInfoUnit> &lstInfo) const
|
||
{
|
||
assertReadEnabled();
|
||
lstInfo.Append(new TObjInfoUnit(_T("对象类型"), _T("线图案")));
|
||
lstInfo.Append(new TObjInfoUnit(_T("线宽"), Dist2Str(m_nUnitHeight)));
|
||
lstInfo.Append(new TObjInfoUnit(_T("填充比例"), XString(_T("%d %%"),(int)(m_nRatio*100))));
|
||
lstInfo.Append(new TObjInfoUnit(_T("长度"), Dist2Str(m_polyBase.Distance2d())));
|
||
if(IsEqualScale())
|
||
lstInfo.Append(new TObjInfoUnit(_T("对齐方式"), IsAutoExpand()? _T("两边对齐") : _T("中间对齐")));
|
||
else
|
||
lstInfo.Append(new TObjInfoUnit(_T("对齐方式"), _T("单元自调")));
|
||
XString sBase;
|
||
if(GetBaseType()==0)
|
||
sBase=_T("基线居左");
|
||
else if(GetBaseType()==1)
|
||
sBase=_T("基线居右");
|
||
else
|
||
sBase=_T("基线居中");
|
||
lstInfo.Append(new TObjInfoUnit(_T("基线位置"), sBase));
|
||
}
|
||
////////////////////////////////////////////////////////////////
|
||
AcDbObjectId TDbPolyPathArray::GetUnitId() const
|
||
{
|
||
assertReadEnabled();
|
||
return m_idUnit;
|
||
}
|
||
int TDbPolyPathArray::GetBaseType() const
|
||
{
|
||
assertReadEnabled();
|
||
if((m_nRailFlag&RF_RIGHTBASE)!=0)
|
||
return 1;
|
||
else if((m_nRailFlag&RF_MIDBASE)!=0)
|
||
return 2;
|
||
else
|
||
return 0;
|
||
}
|
||
void TDbPolyPathArray::SetBaseType(int type)
|
||
{
|
||
assertWriteEnabled();
|
||
if(type==1)
|
||
{
|
||
m_nRailFlag |= RF_RIGHTBASE;
|
||
m_nRailFlag &=~RF_MIDBASE;
|
||
}
|
||
else if(type==2)
|
||
{
|
||
m_nRailFlag &=~RF_RIGHTBASE;
|
||
m_nRailFlag |= RF_MIDBASE;
|
||
}
|
||
else
|
||
{
|
||
m_nRailFlag &=~RF_RIGHTBASE;
|
||
m_nRailFlag &=~RF_MIDBASE;
|
||
}
|
||
}
|
||
BOOL TDbPolyPathArray::IsAutoExpand() const
|
||
{
|
||
assertReadEnabled();
|
||
return ((m_nRailFlag&RF_AUTOEXPAND)!=0);
|
||
}
|
||
void TDbPolyPathArray::SetAutoExpand(BOOL bTrue)
|
||
{
|
||
assertWriteEnabled();
|
||
if(bTrue)
|
||
m_nRailFlag |= RF_AUTOEXPAND;
|
||
else
|
||
m_nRailFlag &= ~RF_AUTOEXPAND;
|
||
}
|
||
BOOL TDbPolyPathArray::IsEqualScale() const
|
||
{
|
||
assertReadEnabled();
|
||
return ((m_nRailFlag&RF_EQUALSCALE)!=0);
|
||
}
|
||
void TDbPolyPathArray::SetEqualScale(BOOL bTrue)
|
||
{
|
||
assertWriteEnabled();
|
||
if(bTrue)
|
||
m_nRailFlag |= RF_EQUALSCALE;
|
||
else
|
||
m_nRailFlag &= ~RF_EQUALSCALE;
|
||
}
|
||
BOOL TDbPolyPathArray::IsReversed() const
|
||
{
|
||
assertReadEnabled();
|
||
return ((m_nRailFlag&RF_REVERSE)!=0);
|
||
}
|
||
void TDbPolyPathArray::Reverse()
|
||
{
|
||
assertWriteEnabled();
|
||
if((m_nRailFlag&RF_REVERSE)!=0)
|
||
m_nRailFlag &= ~RF_REVERSE;
|
||
else
|
||
m_nRailFlag |= RF_REVERSE;
|
||
}
|
||
void TDbPolyPathArray::SetUnitId(AcDbObjectId id)
|
||
{
|
||
assertWriteEnabled();
|
||
m_idUnit=id;
|
||
}
|
||
double TDbPolyPathArray::GetScaleY()const
|
||
{
|
||
XPoint ptLow, ptUp;
|
||
double nRet=1.0;
|
||
if(GetBlockExtents(m_idUnit, ptLow, ptUp)==RTNORM)
|
||
{
|
||
double height0=ptUp.y-ptLow.y;
|
||
nRet=m_nUnitHeight*m_nRatio/height0;
|
||
}
|
||
return nRet;
|
||
}
|
||
double TDbPolyPathArray::GetUnitHeight()const
|
||
{
|
||
assertReadEnabled();
|
||
return m_nUnitHeight;
|
||
}
|
||
void TDbPolyPathArray::SetUnitHeight(double height)
|
||
{
|
||
assertWriteEnabled();
|
||
m_nUnitHeight=height;
|
||
}
|
||
double TDbPolyPathArray::GetRatio()const
|
||
{
|
||
assertReadEnabled();
|
||
return m_nRatio;
|
||
}
|
||
void TDbPolyPathArray::SetRatio(double ratio)
|
||
{
|
||
assertWriteEnabled();
|
||
m_nRatio=ratio;
|
||
}
|
||
double TDbPolyPathArray::GetUnitWidth() const
|
||
{
|
||
assertReadEnabled();
|
||
XPoint ptLow, ptUp;
|
||
GetBlockExtents(m_idUnit, ptLow, ptUp);
|
||
double width0=ptUp.x-ptLow.x;
|
||
return GetScaleY()*width0;
|
||
}
|
||
|
||
int EditPolyPathArray(AcDbObjectId id);
|
||
void InitDbPolyPathArray(BOOL bTrue)
|
||
{
|
||
AecObjectEditMethod pOldEdit=NULL;
|
||
if(bTrue)
|
||
{
|
||
TDbPolyPathArray::rxInit();
|
||
acrxBuildClassHierarchy();
|
||
TDbPolyPathArray::InitMatchProtocol(TRUE);
|
||
pOldEdit=TDbPolyPathArray::SetEditMethod(EditPolyPathArray);
|
||
}
|
||
else
|
||
{
|
||
TDbPolyPathArray::InitMatchProtocol(FALSE);
|
||
TDbPolyPathArray::SetEditMethod(pOldEdit);
|
||
deleteAcRxClass(TDbPolyPathArray::desc());
|
||
}
|
||
}
|
||
|
||
//TARCH_IMPEXP Acad::ErrorStatus ExplodeBlockRef(const AcDbBlockTableRecord &blockRec,
|
||
// const AcGeMatrix3d &mat, AcDbVoidPtrArray &entSet);
|
||
|
||
void ExplodeBlock3d(AcDbObjectId idBlock, AcDbVoidPtrArray & entSet)
|
||
{
|
||
//AcDbBlockReference blkIns(AcGePoint3d(0,0,0), idBlock);
|
||
AcDbVoidPtrArray entSet0;
|
||
ads_matrix mat;
|
||
OPENOBJ_BEGIN(idBlock, AcDb::kForRead, AcDbBlockTableRecord, pBlock);
|
||
ASSERT(pBlock);
|
||
XPoint ptOrg=pBlock->origin();
|
||
ConstructMatrix(ptOrg, XPoint(0,0,0), 1.0, 1.0, 1.0, 0.0, mat);
|
||
ExplodeBlockRef(*pBlock, AsAcGeMatrix3d(mat), entSet0);
|
||
OPENOBJ_END();
|
||
|
||
//if(blkIns.explode(entSet0)==Acad::eOk) {
|
||
int nCount=entSet0.length();
|
||
for(int i=0; i<nCount; i++) {
|
||
AcDbEntity *pEnt=(AcDbEntity *)entSet0[i];
|
||
AcRxClass *pRxInfo=pEnt->isA();
|
||
if(pEnt->isKindOf(AcDbFace::desc())) { // 3DFACE
|
||
entSet.append(pEnt);
|
||
entSet0.removeAt(i);
|
||
i--;
|
||
nCount--;
|
||
} else if(pEnt->isKindOf(AcDbPolyFaceMesh::desc()) ||
|
||
pEnt->isKindOf(AcDbPolygonMesh::desc())) {
|
||
pEnt->explode(entSet);
|
||
} else if(_tcscmp(pRxInfo->dxfName(), _T("3DSOLID"))==0 ||
|
||
_tcscmp(pRxInfo->dxfName(), _T("REGION"))==0) {
|
||
ExplodeAcis(pEnt, entSet);
|
||
} else {
|
||
BOOL bExp=FALSE;
|
||
if(pEnt->isKindOf(AcDbPolyline::desc())) {
|
||
AcDbPolyline *pline=AcDbPolyline::cast(pEnt);
|
||
ASSERT(pline);
|
||
double nWidth=0.0;
|
||
if(pline->normal()==AcGeVector3d(0,0,1) && pline->thickness()>_DIST_SNAP &&
|
||
pline->getConstantWidth(nWidth)==Acad::eOk && nWidth<1.0E-3) {
|
||
double nHeight=pline->thickness();
|
||
XPoly2D poly;
|
||
PolyConvert(*pline, poly);
|
||
XPoly poly1;
|
||
poly.MapToPolygon(poly1);
|
||
if(poly.IsClosed()) {
|
||
XPolygonEx polyEx(poly1);
|
||
XTrianglePface lstTris;
|
||
if(polyEx.Trianglize(lstTris, FALSE)==RTNORM) {
|
||
for(int n=0; n<lstTris.Length(); n++) {
|
||
XTriangle *triangle=lstTris[n];
|
||
Adesk::Boolean bSide1=!(triangle->m_nFlag&SIDE1_INVISIBLE);
|
||
Adesk::Boolean bSide2=!(triangle->m_nFlag&SIDE2_INVISIBLE);
|
||
Adesk::Boolean bSide3=!(triangle->m_nFlag&SIDE3_INVISIBLE);
|
||
AcDbFace *pFace=new AcDbFace(triangle->vertex1, triangle->vertex2,
|
||
triangle->vertex3, triangle->vertex1, bSide1, bSide2, bSide3);
|
||
entSet.append(pFace);
|
||
triangle->vertex1.z += nHeight;
|
||
triangle->vertex2.z += nHeight;
|
||
triangle->vertex3.z += nHeight;
|
||
pFace=new AcDbFace(triangle->vertex1, triangle->vertex2,
|
||
triangle->vertex3, triangle->vertex1, bSide1, bSide2, bSide3);
|
||
entSet.append(pFace);
|
||
}
|
||
}
|
||
}
|
||
int nSeg=poly1.Length();
|
||
if(!poly.IsClosed())
|
||
nSeg --;
|
||
for(int n=0; n<nSeg; n++) {
|
||
XLine ln, ln1;
|
||
poly1.NthLine(n, ln);
|
||
ln1=ln;
|
||
ln1.StartPoint().z += nHeight;
|
||
ln1.EndPoint().z += nHeight;
|
||
bool bVisStart=poly.HitTestOnCurve(ln.StartPoint(), 1.0E-3)>0;
|
||
bool bVisEnd=poly.HitTestOnCurve(ln.EndPoint(), 1.0E-3)>0;
|
||
AcDbFace *pFace=new AcDbFace(ln.StartPoint(), ln.EndPoint(),
|
||
ln1.EndPoint(), ln1.StartPoint(),
|
||
Adesk::kTrue, bVisStart, Adesk::kTrue, bVisEnd);
|
||
entSet.append(pFace);
|
||
}
|
||
bExp=TRUE;
|
||
}
|
||
}
|
||
if(!bExp) {
|
||
entSet.append(pEnt);
|
||
entSet0.removeAt(i);
|
||
i--;
|
||
nCount--;
|
||
}
|
||
}
|
||
|
||
}
|
||
//}
|
||
ReleaseEntSet(entSet0);
|
||
}
|
||
// 编辑路径排列
|
||
int EditPolyPathArray(AcDbObjectId id)
|
||
{
|
||
OPENOBJ_BEGIN(id, AcDb::kForRead, TDbPolyPathArray, pStep);
|
||
if(!pStep)
|
||
return RTERROR;
|
||
while(1) {
|
||
const TCHAR *szPrompts[2]= {
|
||
_T("\n选择 [加顶点(A)/减顶点(D)/设顶点(S)/宽度(W)/填充比例(G)/图案翻转(F)/单元对齐(R)/基线位置(B)]<退出>:"),
|
||
_T("\n选择 [宽度(W)/填充比例(G)/图案翻转(F)/单元对齐(R)/基线位置(B)]<退出>:")
|
||
};
|
||
const TCHAR *szKeywords[2] = {_T("A D S W G F R B"), _T("W G F R B"),};
|
||
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_END);
|
||
XPushMemVar<BOOL> vTemp(g_bSnapCurveBase,TRUE);
|
||
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 {
|
||
adsout << _T("\n请正确点取!");
|
||
}
|
||
}
|
||
} else if(sKeyword[0]==_T('S')) {
|
||
XPushVar<int> osmode(_T("OSMODE"), OS_END);
|
||
XPushMemVar<BOOL> vTemp(g_bSnapCurveBase,TRUE);
|
||
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->GetUnitHeight();
|
||
nRet=GetReal(_T("\n线宽"), nWidth, RSG_NOZERO|RSG_NONEG);
|
||
if(nRet==RTCAN)
|
||
break;
|
||
if(nRet==RTNORM) {
|
||
if(pStep->upgradeOpen()!=Acad::eOk)
|
||
return RTERROR;
|
||
pStep->SetUnitHeight(nWidth);
|
||
pStep->downgradeOpen();
|
||
}
|
||
}else if(sKeyword[0]==_T('G')) {
|
||
double nWidth=pStep->GetRatio();
|
||
nRet=GetReal(_T("\n填充比例"), nWidth, RSG_NOZERO|RSG_NONEG);
|
||
if(nRet==RTCAN)
|
||
break;
|
||
if(nRet==RTNORM) {
|
||
if(pStep->upgradeOpen()!=Acad::eOk)
|
||
return RTERROR;
|
||
pStep->SetRatio(nWidth);
|
||
pStep->downgradeOpen();
|
||
}
|
||
}
|
||
else if(sKeyword[0]==_T('R'))
|
||
{
|
||
if(pStep->upgradeOpen()!=Acad::eOk)
|
||
return RTERROR;
|
||
if(!pStep->IsEqualScale())
|
||
{
|
||
pStep->SetEqualScale(TRUE);
|
||
pStep->SetAutoExpand(TRUE);
|
||
adsout<<_T("<两边对齐>");
|
||
}
|
||
else if(pStep->IsAutoExpand())
|
||
{
|
||
pStep->SetAutoExpand(FALSE);
|
||
adsout<<_T("<中间对齐>");
|
||
}
|
||
else
|
||
{
|
||
pStep->SetEqualScale(FALSE);
|
||
adsout<<_T("<单元自调>");
|
||
}
|
||
pStep->downgradeOpen();
|
||
}
|
||
else if(sKeyword[0]==_T('B'))
|
||
{
|
||
if(pStep->upgradeOpen()!=Acad::eOk)
|
||
return RTERROR;
|
||
if(pStep->GetBaseType()==0)
|
||
{
|
||
pStep->SetBaseType(1);
|
||
adsout<<_T("<基线居右>");
|
||
}
|
||
else if(pStep->GetBaseType()==1)
|
||
{
|
||
pStep->SetBaseType(2);
|
||
adsout<<_T("<基线居中>");
|
||
}
|
||
else
|
||
{
|
||
pStep->SetBaseType(0);
|
||
adsout<<_T("<基线居左>");
|
||
}
|
||
pStep->downgradeOpen();
|
||
}
|
||
else if(sKeyword[0]==_T('F'))
|
||
{
|
||
if(pStep->upgradeOpen()!=Acad::eOk)
|
||
return RTERROR;
|
||
pStep->Reverse();
|
||
pStep->downgradeOpen();
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
return RTNORM;
|
||
}
|
||
|
||
|