6673 lines
161 KiB
C++
6673 lines
161 KiB
C++
#include "stdafx.h"
|
||
#include "resource.h"
|
||
#include "DimAxisLabelDlg.h"
|
||
#include "axisdim.h"
|
||
#include "geassign.h"
|
||
#include "TDragPickEntSet.h"
|
||
#include <afxtempl.h>
|
||
#include "EdJigEx.h"
|
||
//#include "AxisNoParser.h"
|
||
|
||
#include "ManualDimAxisDlg.h"
|
||
// 逐点轴标命令中，多轴号不连续文字部分的文字高度
|
||
#define AXISTEXT_HEIGHT 5.5
|
||
|
||
extern GEOAPI int GetClipBoundary(XPoly2D &poly2d);
|
||
// extern GEOAPI int XGetCorner(const XPoint &ptCorn1, const TCHAR *pszMsg, XPoint &ptCorn2);
|
||
static XPoint g_ptDragCenter;
|
||
static ads_real g_nOldRadius;
|
||
static ads_real g_nOldAngle = 0.0;
|
||
|
||
int ComputDist(AcGePoint3d ptStart1,AcGePoint3d ptEnd1,AcGePoint3d ptStart2,AcGePoint3d ptEnd2,BOOL bDim=FALSE);
|
||
void AlignAxis(PickSet ss);
|
||
void AlignLine(PickSet ss,Entity ent);
|
||
// BOOL RemoveDupLine(PickSet ss,BOOL bDim=FALSE);
|
||
|
||
class TAxisLabelEdJig : public TSymbEdJig
|
||
{
|
||
public:
|
||
TAxisLabelEdJig(TDbAxisLabelSet *);
|
||
virtual int DoIt(int *pKeyIndex=NULL);
|
||
DragStatus GetPoint(XPoint &pt);
|
||
|
||
protected:
|
||
virtual Adesk::Boolean update();
|
||
virtual AcDbEntity* entity() const;
|
||
|
||
private:
|
||
// I/O
|
||
TDbAxisLabelSet *m_pDrawEnt;
|
||
};
|
||
|
||
TAxisLabelEdJig::TAxisLabelEdJig(TDbAxisLabelSet *pElev)
|
||
{
|
||
m_pDrawEnt=pElev;
|
||
}
|
||
|
||
AcEdJig::DragStatus TAxisLabelEdJig::GetPoint(XPoint &pt)
|
||
{
|
||
XCurveSegment seg=m_pDrawEnt->GetAxis(0);
|
||
XPoint ptBase=seg.StartPoint();
|
||
|
||
return acquirePoint(pt, ptBase);
|
||
}
|
||
|
||
// 开始执行拖动
|
||
int TAxisLabelEdJig::DoIt(int *keyIndex)
|
||
{
|
||
XCurveSegment seg=m_pDrawEnt->GetAxis(0);
|
||
ads_polar(seg.StartPoint(), seg.IDirection(0)+PI, seg.GetLength(), m_ptResult);
|
||
int nRet = TSymbEdJig::DoIt(keyIndex);
|
||
|
||
return nRet;
|
||
}
|
||
|
||
// 更新实体数据
|
||
Adesk::Boolean TAxisLabelEdJig::update()
|
||
{
|
||
XDirectionCurve cv=m_pDrawEnt->GetOrthoCurve(0);
|
||
XCurveSegment segFirst=m_pDrawEnt->GetAxis(0);
|
||
double nSide=cv.OnWhichSide(m_ptResult);
|
||
if (nSide == cv.OnWhichSide(segFirst.EndPoint()))
|
||
{
|
||
double nDir=segFirst.IDirection(0);
|
||
ads_polar(segFirst.StartPoint(), nDir+PI, 100.0, segFirst.EndPoint());
|
||
m_pDrawEnt->SetFirstSegment(segFirst);
|
||
m_pDrawEnt->NegateParams();
|
||
}
|
||
m_pDrawEnt->SetLeaderLen(0, m_ptResult.Distance2d(segFirst.StartPoint()), FALSE);
|
||
m_pDrawEnt->SetLeaderLen(1, m_ptResult.Distance2d(segFirst.StartPoint()), FALSE);
|
||
|
||
return Adesk::kTrue;
|
||
}
|
||
|
||
AcDbEntity* TAxisLabelEdJig::entity() const
|
||
{
|
||
return (AcDbEntity *)m_pDrawEnt;
|
||
}
|
||
|
||
static int DragArcOrCircle(ads_point pt, ads_matrix mt)
|
||
{
|
||
assert(g_nOldRadius>1.0E-9);
|
||
ads_real nScale = ads_distance(Ucs2Wcs(g_ptDragCenter), Ucs2Wcs(pt))/g_nOldRadius;
|
||
Ucs2Wcs(g_ptDragCenter).GetScaleMatrix(nScale, mt);
|
||
|
||
return RTNORM;
|
||
}
|
||
|
||
static int DragRotationAction(ads_point pt, ads_matrix mt)
|
||
{
|
||
ads_real nRot=CT_std_angle(ads_angle(Ucs2Wcs(g_ptDragCenter), Ucs2Wcs(pt))-g_nOldAngle);
|
||
Ucs2Wcs(g_ptDragCenter).GetRotationMatrix(nRot, mt);
|
||
|
||
return RTNORM;
|
||
}
|
||
|
||
|
||
|
||
// [2010-4-20 wubo] 设置所有的轴标实体为显示隐藏
|
||
// 成功返回true，否则返回false
|
||
bool SetShowHiddenAxisLable(bool bShow)
|
||
{
|
||
TPickEntSet ssAxisLabelSet(SS_FREE);
|
||
if (ssAxisLabelSet.Get(_T("A"), NULL, NULL, TRBList(RTDXF0, _T("ATS_AXIS_LABEL"), NULL)) == RTNORM)
|
||
{
|
||
long lLength = ssAxisLabelSet.Length();
|
||
for (long i = 0; i < lLength; i++)
|
||
{
|
||
OPENOBJ_BEGIN(ssAxisLabelSet[i], AcDb::kForWrite, TDbAxisLabelSet, pAxisLabelSet);
|
||
if (pAxisLabelSet == NULL)
|
||
{
|
||
continue;
|
||
}
|
||
pAxisLabelSet->SetShowHide(bShow);
|
||
OPENOBJ_END();
|
||
}
|
||
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// ptPick--UCS
|
||
int DragRadius(const Entity &e, const TCHAR *pszPrompt, const XPoint &ptPick)
|
||
{
|
||
Entity ent=e;
|
||
ent.GetData(10, &g_ptDragCenter);
|
||
ent.GetData(40, &g_nOldRadius);
|
||
g_ptDragCenter=Wcs2Ucs(g_ptDragCenter);
|
||
XPoint ptLow=ptPick-XPoint(_DIST_SNAP, _DIST_SNAP);
|
||
XPoint ptUp=ptPick+XPoint(_DIST_SNAP, _DIST_SNAP);
|
||
AssureOnScreen(ptLow, ptUp);
|
||
|
||
TDragPickEntSet ssDrag(ptPick, SS_FREE);
|
||
ssDrag += ent;
|
||
XPoint ptDrag=ptPick;
|
||
ads_initget(RSG_OTHER, NULL);
|
||
int rc = ads_draggen(ssDrag, pszPrompt, 0,
|
||
DragArcOrCircle,
|
||
ptDrag);
|
||
if (rc == RTNORM)
|
||
{
|
||
ads_real nRadius=ads_distance(g_ptDragCenter, ptDrag);
|
||
ent.SetData(40, nRadius);
|
||
|
||
return ent.Modify();
|
||
}
|
||
else if (rc == RTSTR)
|
||
{
|
||
TCHAR sInput[80]=_T("");
|
||
ads_getinput(sInput);
|
||
if (!sInput[0])
|
||
{
|
||
return RTERROR;
|
||
}
|
||
ads_real nRadius=_tstof(sInput);
|
||
if (nRadius<1.0E-9)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
ent.SetData(40, nRadius);
|
||
|
||
return ent.Modify();
|
||
}
|
||
|
||
return RTERROR;
|
||
}
|
||
|
||
// 适合于Z轴方向==WCS Z轴的UCS
|
||
// ptBase--UCS
|
||
// ptPick0--UCS
|
||
int DragRotation(const Entity &e, const TCHAR *pszPrompt, const XPoint &ptBase, const XPoint &ptPick0)
|
||
{
|
||
Entity ent=e;
|
||
g_ptDragCenter = ptBase;
|
||
g_nOldAngle = ads_angle(Ucs2Wcs(ptBase), Ucs2Wcs(ptPick0));
|
||
|
||
XPoint ptLow=ptBase-XPoint(_DIST_SNAP, _DIST_SNAP);
|
||
XPoint ptUp=ptBase+XPoint(_DIST_SNAP, _DIST_SNAP);
|
||
AssureOnScreen(ptLow, ptUp);
|
||
|
||
TDragPickEntSet ssDrag(ptBase, SS_FREE);
|
||
ssDrag += ent;
|
||
XPoint ptDrag=ptPick0;
|
||
ads_initget(RSG_OTHER, NULL);
|
||
int rc = ads_draggen(ssDrag, pszPrompt, 0,
|
||
DragRotationAction,
|
||
ptDrag);
|
||
if (rc == RTNORM)
|
||
{
|
||
ads_real nRot=CT_std_angle(ads_angle(Ucs2Wcs(g_ptDragCenter), Ucs2Wcs(ptDrag))-g_nOldAngle)*180/PI;
|
||
XPushVar<int> vOsMode(_T("OSMODE"), 0);
|
||
// Zyu modify on 100726，支持64位
|
||
//return SHads_command(RTSTR, _T(".ROTATE"), RTPICKS, (long *)ssDrag, RTSTR, _T(""),
|
||
// RT3DPOINT, &g_ptDragCenter, RTREAL, nRot, RTNONE);
|
||
return SHads_command(RTSTR, _T(".ROTATE"), RTPICKS, (TLong_ptr *)ssDrag, RTSTR, _T(""),
|
||
RT3DPOINT, &g_ptDragCenter, RTREAL, nRot, RTNONE);
|
||
}
|
||
else if (rc == RTSTR)
|
||
{
|
||
TCHAR sInput[80]=_T("");
|
||
ads_getinput(sInput);
|
||
if (!sInput[0])
|
||
{
|
||
return RTERROR;
|
||
}
|
||
ads_real nRot=_tstof(sInput);
|
||
if (fabs(nRot)<_angSnap)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
XPushVar<int> vOsMode(_T("OSMODE"), 0);
|
||
// Zyu modify on 100726，支持64位
|
||
//return SHads_command(RTSTR, _T(".ROTATE"), RTPICKS, (long *)ssDrag, RTSTR, _T(""),
|
||
// RT3DPOINT, &g_ptDragCenter, RTREAL, nRot, RTNONE);
|
||
return SHads_command(RTSTR, _T(".ROTATE"), RTPICKS, (TLong_ptr *)ssDrag, RTSTR, _T(""),
|
||
RT3DPOINT, &g_ptDragCenter, RTREAL, nRot, RTNONE);
|
||
}
|
||
|
||
return RTERROR;
|
||
}
|
||
|
||
|
||
|
||
/////////////////////////////////////////////
|
||
// 通过一线裁剪轴网，命令：TrimOneSideLine
|
||
void TrimOneSideLine()
|
||
{
|
||
// 设置捕捉模式为nea
|
||
XPushVar<int> vOsMode(_T("OSMODE"), 512);
|
||
//xg_setvar(_T("OSMODE"), 512);
|
||
|
||
// 取得裁剪线起点或裁减线上一点
|
||
XPoint ptStart, ptEnd, ptSide;
|
||
if (ads_getpoint(NULL, _T("\n请输入裁剪线的起点或选择一裁剪线:"), ptStart) != RTNORM)
|
||
{
|
||
return;
|
||
}
|
||
|
||
// 关闭捕捉模式
|
||
xg_setvar(_T("OSMODE"), 0);
|
||
|
||
// 检查是否选择了直线或多义线段
|
||
Entity entTrim;
|
||
ads_matrix xformres;
|
||
struct resbuf *refstkres;
|
||
BOOL bSelectedLine = FALSE;
|
||
if (ads_nentselp(NULL, entTrim, ptStart, TRUE, xformres, &refstkres) == RTNORM)
|
||
{
|
||
RBList rb(refstkres);
|
||
OPENOBJ_BEGIN(entTrim, AcDb::kForRead, AcDbCurve, pLine);
|
||
if (pLine != NULL)
|
||
{
|
||
ASSERT(pLine->isKindOf(AcDbCurve::desc()));
|
||
if (pLine->isKindOf(AcDbLine::desc()))
|
||
{
|
||
// 取得直线起点和终点
|
||
bSelectedLine = TRUE;
|
||
ptStart = ((AcDbLine*)pLine)->startPoint();
|
||
ptEnd = ((AcDbLine*)pLine)->endPoint();
|
||
}
|
||
else if (pLine->isKindOf(AcDbPolyline::desc()))
|
||
{
|
||
// 取得所选的多义线段起点和终点
|
||
XPoint pt;
|
||
double dParam;
|
||
pt=Ucs2Wcs(ptStart);
|
||
//acdbUcs2Wcs(ptStart, pt, Adesk::kFalse);
|
||
if (((AcDbPolyline*)pLine)->getParamAtPoint(pt, dParam) == Acad::eOk)
|
||
{
|
||
bSelectedLine = TRUE;
|
||
dParam = int(dParam);
|
||
((AcDbPolyline*)pLine)->getPointAtParam(dParam, ptStart);
|
||
((AcDbPolyline*)pLine)->getPointAtParam(dParam + 1.0, ptEnd);
|
||
}
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
|
||
// 如果没有选择直线，则提示选择裁剪线终点
|
||
if (!bSelectedLine)
|
||
{
|
||
if (ads_getpoint(ptStart, _T("\n请输入裁剪线的终点:"), ptEnd) != RTNORM)
|
||
{
|
||
return;
|
||
}
|
||
ptStart=Ucs2Wcs(ptStart);
|
||
ptEnd=Ucs2Wcs(ptEnd);
|
||
}
|
||
|
||
// 取得裁减方向
|
||
ads_grdraw(ptStart, ptEnd, -1, 1);
|
||
if (ads_getpoint(NULL, _T("\n请输入一点以确定裁剪的是哪一边:"), ptSide) != RTNORM)
|
||
{
|
||
SHads_command(RTSTR, _T("REDRAW"), RTNONE);
|
||
|
||
return;
|
||
}
|
||
ptSide=Ucs2Wcs(ptSide);
|
||
SHads_command(RTSTR, _T("REDRAW"), RTNONE);
|
||
|
||
// 取得所有轴网
|
||
PickSet ss(SS_FREE);
|
||
RBList mask(RTDXF0, _T("LINE"), 8, LAY_AXIS, NULL);
|
||
if (ss.Get(_T("X"), NULL, NULL, mask) != RTNORM)
|
||
{
|
||
return;
|
||
}
|
||
|
||
// 生成运算对象
|
||
AcGeVector3d vec1, vec2;
|
||
AcDbLine TrimLine(ptStart, ptEnd);
|
||
AcDbLine SideLine(ptSide, asPnt3d(ptSide) + (asPnt3d(ptEnd) - asPnt3d(ptStart)));
|
||
|
||
// 裁剪与裁剪线相交的轴网
|
||
long lCount = ss.Length();
|
||
for (long l = 0; l < lCount; l++)
|
||
{
|
||
// 取得并打开轴线实体
|
||
Entity ent = ss[l];
|
||
OPENOBJ_BEGIN(ent, AcDb::kForWrite, AcDbLine, pLine);
|
||
if (pLine == NULL)
|
||
{
|
||
continue;
|
||
}
|
||
ASSERT(pLine->isKindOf(AcDbLine::desc()));
|
||
|
||
// 求得与裁剪线的交点
|
||
AcGePoint3dArray arptInt1, arptInt2;
|
||
if (TrimLine.intersectWith(pLine, AcDb::kOnBothOperands, arptInt1) != Acad::eOk
|
||
|| arptInt1.length() <= 0)
|
||
{
|
||
continue;
|
||
}
|
||
if (SideLine.intersectWith(pLine, AcDb::kExtendBoth, arptInt2) != Acad::eOk
|
||
|| arptInt2.length() <= 0)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// 修改轴线的裁剪端顶点到交点
|
||
if ((arptInt2[0] - arptInt1[0]).isCodirectionalTo(pLine->endPoint() - arptInt1[0]))
|
||
{
|
||
pLine->setEndPoint(arptInt1[0]);
|
||
}
|
||
else
|
||
{
|
||
pLine->setStartPoint(arptInt1[0]);
|
||
}
|
||
|
||
OPENOBJ_END();
|
||
}
|
||
}
|
||
|
||
|
||
|
||
////////////////////////////////////////////////
|
||
// 命令: 轴线多边形裁剪
|
||
// 条件: 必须在WCS下
|
||
void ClipAxis()
|
||
{
|
||
XPoly2D poly2d(1);
|
||
const TCHAR *szPrompts[2]={_T("\n矩形的第一个角点或 [多边形裁剪(P)/轴线取齐(F)]<退出>:"),
|
||
_T("\n多边形的第一点<退出>:")};
|
||
const TCHAR *szKeywords=_T("P F");
|
||
int nClipType=0;
|
||
|
||
XPoint ptStart;
|
||
//while (1)
|
||
{
|
||
adsout << szPrompts[0];
|
||
int nCode;
|
||
INITGET_BEG(0, szKeywords);
|
||
nCode=ads_getpoint(NULL, _T(""), ptStart);
|
||
INITGET_END();
|
||
if (nCode == RTKWORD)
|
||
{
|
||
XString sKey;
|
||
ads_getinput(sKey);
|
||
if (sKey[0] == _T('P'))
|
||
{
|
||
if (ads_getpoint(NULL, szPrompts[1], ptStart)!=RTNORM)
|
||
{
|
||
return;
|
||
}
|
||
nClipType=1;
|
||
}
|
||
else
|
||
{
|
||
nClipType=2;
|
||
}
|
||
}
|
||
else if (nCode!=RTNORM)
|
||
{
|
||
return;
|
||
}
|
||
}
|
||
|
||
if (nClipType == 0)
|
||
{
|
||
XPoint ptOther;
|
||
int nCode=XGetCorner(ptStart, _T("\n另一个角点<退出>:"), ptOther);
|
||
if (nCode!=RTNORM)
|
||
{
|
||
return;
|
||
}
|
||
XRectAngle rect(ptStart, ptOther);
|
||
rect.AsPoly2D(poly2d);
|
||
}
|
||
else if (nClipType == 1)
|
||
{
|
||
XPoint pt2;
|
||
XScreenDc dc;
|
||
dc.m_nDrawMode=1;
|
||
DStack<XPoint> aStack;
|
||
aStack.Push(new XPoint(ptStart));
|
||
while (1)
|
||
{
|
||
XPoint &ptFrom=*aStack.Top();
|
||
if (aStack.Length()>=3)
|
||
{
|
||
adsout << _T("\n下一点或 [回退(U)]<封闭>: ");
|
||
}
|
||
else
|
||
{
|
||
adsout << _T("\n下一点或 [回退(U)]<退出>: ");
|
||
}
|
||
int rc;
|
||
INITGET_BEG(0, _T("U"));
|
||
rc=ads_getpoint(ptFrom, _T(""), pt2);
|
||
INITGET_END();
|
||
if (rc == RTCAN)
|
||
{
|
||
aStack.Reset();
|
||
|
||
return;
|
||
}
|
||
else if (rc == RTKWORD)
|
||
{
|
||
if (*aStack.Top() != ptStart) // Not on first state
|
||
{
|
||
XPoint *pPt2 = aStack.Pop();
|
||
XPoint *pPt1 = aStack.Top();
|
||
dc.SetColor(-1);
|
||
dc << XLine(*pPt1, *pPt2);
|
||
delete pPt2;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (rc == RTNONE)
|
||
{
|
||
if (aStack.Length()<3)
|
||
{
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
pt2=ptStart;
|
||
}
|
||
}
|
||
XLine ln(*aStack.Top(), pt2);
|
||
if (ln.GetLength()>_DIST_SNAP)
|
||
{
|
||
dc.SetColor(7);
|
||
dc << ln;
|
||
if (!(rc == RTNONE))
|
||
{
|
||
aStack.Push(new XPoint(pt2));
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
poly2d.Reset();
|
||
XPoint *ptCur=NULL;
|
||
while ((ptCur=aStack.Pop())!=NULL)
|
||
{
|
||
poly2d.AppendNode(*ptCur);
|
||
delete ptCur;
|
||
}
|
||
poly2d.Compress();
|
||
if (!poly2d || poly2d.Length()<3)
|
||
{
|
||
return;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
TrimOneSideLine();
|
||
|
||
return;
|
||
}
|
||
|
||
XPoly poly1;
|
||
poly2d.MapToPolygon(poly1);
|
||
RBList mask=ads_buildlist(RTDXF0, _T("LINE,ARC,CIRCLE"), 8, LAY_AXIS, NULL);
|
||
PickSet ss(SS_FREE), ssIn(SS_FREE|SS_CREATE), ssOut(SS_FREE|SS_CREATE);
|
||
if (ss.Get(_T("CP"), RBList(poly1.Fence()), NULL, mask)!=RTNORM)
|
||
{
|
||
return ;
|
||
}
|
||
|
||
// UCS to WCS
|
||
poly2d.TransUCS(Groups(1), Groups(0));
|
||
if (PolyClip(ss, poly2d, ssIn, ssOut) == RTNORM)
|
||
{
|
||
ssIn.Erase();
|
||
//ads_redraw(NULL,0);
|
||
}
|
||
poly2d.TransUCS(Groups(0), Groups(1));
|
||
XScreenDc dc;
|
||
dc.m_nDrawMode=1;
|
||
dc << poly2d;
|
||
}
|
||
|
||
|
||
|
||
///////////////////////////////////////////
|
||
// 命令: 矩形裁剪
|
||
// 条件: 必须在WCS下
|
||
void RClipA()
|
||
{
|
||
//AsureWCS();
|
||
XPoint ptCorner1, ptCorner2;
|
||
if (XGetPoint(NULL, _T("\n第一个角点"), ptCorner1)!=RTNORM)
|
||
{
|
||
return ;
|
||
}
|
||
if (XGetCorner(ptCorner1, _T("\n另一个角点<退出>:"), ptCorner2)!=RTNORM)
|
||
{
|
||
return ;
|
||
}
|
||
if (ptCorner1 == ptCorner2)
|
||
{
|
||
return ;
|
||
}
|
||
|
||
XRectAngle box(ptCorner1, ptCorner2);
|
||
XPoly2D poly(1);
|
||
poly.AppendNode(box.lowLeft);
|
||
poly.AppendNode(XPoint(box.upRight.x, box.lowLeft.y, box.lowLeft.z));
|
||
poly.AppendNode(box.upRight);
|
||
poly.AppendNode(XPoint(box.lowLeft.x, box.upRight.y, box.lowLeft.z));
|
||
|
||
RBList mask=ads_buildlist(RTDXF0, _T("LINE,ARC,CIRCLE"), 8, LAY_AXIS, NULL);
|
||
PickSet ss(SS_FREE), ssIn(SS_FREE|SS_CREATE), ssOut(SS_FREE|SS_CREATE);
|
||
if (ss.Get(_T("C"), ptCorner1, ptCorner2, mask)!=RTNORM)
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (PolyClip(ss, poly, ssIn, ssOut) == RTNORM)
|
||
{
|
||
ssIn.Erase();
|
||
ads_redraw(NULL,0);
|
||
XScreenDc dc;
|
||
dc.m_nDrawMode = 1;
|
||
dc << box;
|
||
}
|
||
|
||
return ;
|
||
}
|
||
|
||
// add by xlc on 070730
|
||
// 判断两条直线端点的最远距离
|
||
int ComputDist(AcGePoint3d ptStart1, // [in]line1起点
|
||
AcGePoint3d ptEnd1, // [in]line1终点
|
||
AcGePoint3d ptStart2, // [in]line2起点
|
||
AcGePoint3d ptEnd2, // [in]line2终点
|
||
BOOL bDim) // [in]是否标注（轴网标注时轴线没有搭在一起时不合并）
|
||
{
|
||
double ss = ptStart1.distanceTo(ptStart2);
|
||
double se = ptStart1.distanceTo(ptEnd2);
|
||
double es = ptEnd1.distanceTo(ptStart2);
|
||
double ee = ptEnd1.distanceTo(ptEnd2);
|
||
|
||
// modify by xlc on 090511 两点轴标时不合并不相交的轴线
|
||
XLine line1(XPoint(ptStart1),XPoint(ptEnd1),LS_FINITE),
|
||
line2(XPoint(ptStart2),XPoint(ptEnd2),LS_FINITE);
|
||
|
||
if ((ss - se > 1.0E-6) && (ss - ee > 1.0E-6) && (ss - es > 1.0E-6)
|
||
|| (es < 1.0E-6 && se < 1.0E-6))
|
||
{
|
||
if (bDim &&
|
||
(line1.HitTest2d(line2.EndPoint())>5 &&
|
||
line2.HitTest2d(line1.EndPoint())>5))
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
else if ((se - ss > 1.0E-6) && (se - ee > 1.0E-6) && (se - es > 1.0E-6)
|
||
|| (ss < 1.0E-6 && ee < 1.0E-6))
|
||
{
|
||
if (bDim &&
|
||
(line1.HitTest2d(line2.StartPoint())>5 &&
|
||
line2.HitTest2d (line1.EndPoint())>5))
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
return 1;
|
||
}
|
||
else if ((es - se > 1.0E-6) && (es - ee > 1.0E-6) && (es - ss > 1.0E-6))
|
||
{
|
||
if (bDim &&
|
||
(line1.HitTest2d(line2.EndPoint())>5 &&
|
||
line2.HitTest2d (line1.StartPoint())>5))
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
return 2;
|
||
}
|
||
else if ((ee - se > 1.0E-6) && (ee - ss > 1.0E-6) && (ee - es > 1.0E-6))
|
||
{
|
||
if (bDim &&
|
||
(line1.HitTest2d(line2.StartPoint())>5 &&
|
||
line2.HitTest2d (line1.StartPoint())>5))
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
return 3;
|
||
}
|
||
|
||
return -1;
|
||
}
|
||
|
||
// Zyu add on 100610, 计算两条圆弧合并后的起始角度和结束角度，返回值代表是否可以合并圆弧
|
||
bool MergeArc(double &dStartAngle1, // [in, out] 合并圆弧的起始角度
|
||
double &dEndAngle1, // [in, out] 合并圆弧的结束角度
|
||
double dStartAngle2, // [in] 被合并圆弧的起始角度
|
||
double dEndAngle2, // [in] 被合并圆弧的结束角度
|
||
BOOL bDim = FALSE) // [in] 是否标注（轴网标注时轴线没有搭在一起时不合并）
|
||
{
|
||
TGGeSector sec1(dStartAngle1, dEndAngle1); // 合并圆弧对应的扇形
|
||
TGGeSector sec2(dStartAngle2, dEndAngle2); // 被合并圆弧对应的扇形
|
||
|
||
// 如果两个圆弧有重合的部分
|
||
if (sec1.AngleFlag(dStartAngle2) || sec1.AngleFlag(dEndAngle2) ||
|
||
sec2.AngleFlag(dStartAngle1) || sec2.AngleFlag(dEndAngle1))
|
||
{
|
||
// 判断一平面向量是否在扇形区内
|
||
if (sec2.AngleFlag(dStartAngle1))
|
||
{
|
||
dStartAngle1 = dStartAngle2;
|
||
}
|
||
|
||
if (sec2.AngleFlag(dEndAngle1))
|
||
{
|
||
dEndAngle1 = dEndAngle2;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
// sg delete 100720，增加了圆、弧等功能的支持，变成了新的里TchDupAxis的函数
|
||
/*
|
||
// 消除重线
|
||
BOOL RemoveDupLine(PickSet ss, BOOL bDim)
|
||
{
|
||
if (ss.Length() < 2)
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
long n = 0;
|
||
do
|
||
{
|
||
Entity ent = ss[n];
|
||
XDbObject obj(ent, AcDb::kForRead);
|
||
if (!obj)
|
||
continue;
|
||
|
||
AcDbLine *pLine = AcDbLine::cast(obj.m_pObject);
|
||
if (pLine != NULL) // 直线
|
||
{
|
||
XLine line;
|
||
line.StartPoint() = XPoint(pLine->startPoint().x, pLine->startPoint().y, pLine->startPoint().z);
|
||
line.EndPoint() = XPoint(pLine->endPoint().x, pLine->endPoint().y, pLine->endPoint().z);
|
||
AcGeVector3d vect = pLine->endPoint() - pLine->startPoint();
|
||
|
||
for (long i=n+1; i<ss.Length(); i++)
|
||
{
|
||
Entity en = ss[i];
|
||
XDbObject objNew(en, AcDb::kForRead);
|
||
if (!objNew)
|
||
continue;
|
||
|
||
AcDbLine *pLineNew = AcDbLine::cast(objNew.m_pObject);
|
||
if (pLineNew != NULL)
|
||
{
|
||
XLine lineNew;
|
||
lineNew.StartPoint() =
|
||
XPoint(pLineNew->startPoint().x, pLineNew->startPoint().y, pLineNew->startPoint().z);
|
||
lineNew.EndPoint() =
|
||
XPoint(pLineNew->endPoint().x, pLineNew->endPoint().y, pLineNew->endPoint().z);
|
||
AcGeVector3d vectNew = pLineNew->endPoint() - pLineNew->startPoint();
|
||
|
||
if (vect.isParallelTo(vectNew)) // 平行
|
||
{
|
||
int nn = (lineNew.StartPoint())&(line);
|
||
if (nn != PR_OUTSIDE) // 共线
|
||
{
|
||
int nRet = ComputDist(pLine->startPoint(), pLine->endPoint(),
|
||
pLineNew->startPoint(), pLineNew->endPoint(), bDim);
|
||
if (nRet != -1) // 可以合并
|
||
{
|
||
pLine->upgradeOpen();
|
||
if (nRet == 0) // ss
|
||
{
|
||
pLine->setEndPoint(pLineNew->startPoint());
|
||
}
|
||
else if (nRet == 1) // se
|
||
{
|
||
pLine->setEndPoint(pLineNew->endPoint());
|
||
}
|
||
else if (nRet == 2) // es
|
||
{
|
||
pLine->setStartPoint(pLineNew->startPoint());
|
||
}
|
||
else // ee
|
||
{
|
||
pLine->setStartPoint(pLineNew->endPoint());
|
||
}
|
||
pLine->downgradeOpen();
|
||
|
||
pLineNew->upgradeOpen();
|
||
pLineNew->erase();
|
||
pLineNew->close();
|
||
ss -= en;
|
||
}
|
||
else // 不可以合并
|
||
{
|
||
pLineNew->close();
|
||
}
|
||
}
|
||
else // 不共线
|
||
{
|
||
pLineNew->close();
|
||
}
|
||
}
|
||
else // 不平行
|
||
{
|
||
pLineNew->close();
|
||
}
|
||
}
|
||
}
|
||
pLine->close();
|
||
}
|
||
n++;
|
||
} while (n<ss.Length() - 1);
|
||
|
||
return TRUE;
|
||
}
|
||
*/
|
||
// 重合轴网
|
||
namespace TchDupAxis
|
||
{
|
||
// 判断两直线是否重合
|
||
bool IsDupLine(AcDbLine *pLine1, AcDbLine *pLine2, bool bDim = false);
|
||
// 判断两弧线是否重合
|
||
bool IsDupArc(AcDbArc *pArc1, AcDbArc *pArc2, bool bDim = false);
|
||
// 判断两圆是否重合
|
||
bool IsDupCircle(AcDbCircle *pCircle1, AcDbCircle *pCircle2, bool bDim = false);
|
||
|
||
// 消除重线
|
||
bool RemoveDupLine(PickSet &ssLine, bool bDim = false);
|
||
// 消除重弧线
|
||
bool RemoveDupArc(PickSet &ssArc, bool bDim = false);
|
||
// 消除重圆
|
||
bool RemoveDupCircle(PickSet &ssCircle, bool bDim = false);
|
||
|
||
// 消除重合轴网
|
||
bool RemoveDupAxis(PickSet ss, bool bDim = false);
|
||
};
|
||
|
||
// 判断两直线是否重合
|
||
bool TchDupAxis::IsDupLine(AcDbLine *pLine1, AcDbLine *pLine2, bool bDim)
|
||
{
|
||
if (pLine1==NULL || pLine2==NULL)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// 后续可增加首先对图层、线型等的过滤
|
||
|
||
AcGeVector3d vect1 = pLine1->endPoint() - pLine1->startPoint();
|
||
AcGeVector3d vect2 = pLine2->endPoint() - pLine2->startPoint();
|
||
if (vect1.isParallelTo(vect2) != Adesk::kTrue) // 不平行
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// 问题描述：1.重合的轴线数量≥3个时，不能完全消重。2.合并的轴线不是最大长度，
|
||
// 完全重合的两条轴线不能合并。
|
||
// 解决方法：1.在选择集ss里删除实体en时，对应的下标计数器i也要减1，保证
|
||
// 遍历时不会漏掉任何一个实体。2.废弃原有算法。新算法是将被合并的直线端点投影到
|
||
// 原直线上，如果投影点在直线的延长线上，则设置为端点。
|
||
// 修改人，修改时间：Zyu modify on 100612.
|
||
TGGeCurveSegment cvSegLine1; // 原来的线段
|
||
cvSegLine1.StartPoint() = XPoint(pLine1->startPoint().x, pLine1->startPoint().y, pLine1->startPoint().z);
|
||
cvSegLine1.EndPoint() = XPoint(pLine1->endPoint().x, pLine1->endPoint().y, pLine1->endPoint().z);
|
||
cvSegLine1.SetLineFlag(LS_FINITE);
|
||
|
||
TGGeCurveSegment cvSegLine2; // 被合并的线段
|
||
cvSegLine2.StartPoint() = XPoint(pLine2->startPoint().x, pLine2->startPoint().y, pLine2->startPoint().z);
|
||
cvSegLine2.EndPoint() = XPoint(pLine2->endPoint().x, pLine2->endPoint().y, pLine2->endPoint().z);
|
||
cvSegLine2.SetLineFlag(LS_FINITE);
|
||
|
||
int nRet = (cvSegLine2.StartPoint())&(cvSegLine1);
|
||
if (nRet == PR_OUTSIDE) // 不共线
|
||
{
|
||
return false;
|
||
}
|
||
|
||
TADSGePoint3d ptResStart; // 被合并线段起点投影点
|
||
TADSGePoint3d ptResEnd; // 被合并线段终点投影点
|
||
bool bExtendStart = false; // 被合并线段起点投影在原线段的延长线上
|
||
bool bExtendEnd = false; // 被合并线段终点投影在原线段的延长线上
|
||
bool bMerge = true; // 是否合并两条线段
|
||
|
||
// 求被合并线段的开始点在原线段上的投影点
|
||
if (RTNORM == cvSegLine1.ProjectToMe(cvSegLine2.StartPoint(), ptResStart))
|
||
{
|
||
bExtendStart = (PR_EXTEND == (ptResStart & cvSegLine1));
|
||
}
|
||
|
||
// 求被合并线段的结束点在原线段上的投影点
|
||
if (RTNORM == cvSegLine1.ProjectToMe(cvSegLine2.EndPoint(), ptResEnd))
|
||
{
|
||
bExtendEnd = (PR_EXTEND == (ptResEnd & cvSegLine1));
|
||
}
|
||
|
||
// 求line上与投影点最近的端点
|
||
AcGePoint3d ptNearStart = asPnt3d(cvSegLine1.NearPoint(asDblArray((AcGePoint3d)ptResStart)));
|
||
AcGePoint3d ptNearEnd = asPnt3d(cvSegLine1.NearPoint(asDblArray((AcGePoint3d)ptResEnd)));
|
||
|
||
// 当进行轴网标注时轴线没有搭在一起时不合并
|
||
if (bDim && bExtendStart && bExtendEnd)
|
||
{
|
||
// 当两个投影点在与line的最近点是同一个点时，说明两轴线没有搭在一起，不合并
|
||
bMerge = !ptNearStart.isEqualTo(ptNearEnd);
|
||
}
|
||
|
||
if (!bMerge)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// 如果投影点在原直线的延长线上
|
||
if (pLine1->upgradeOpen() == Acad::eOk)
|
||
{
|
||
if (bExtendStart)
|
||
{
|
||
// 将离投影点更近的端点延长到投影点
|
||
if (ptNearStart.isEqualTo(cvSegLine1.GetStartPoint()))
|
||
{
|
||
pLine1->setStartPoint(ptResStart);
|
||
cvSegLine1.SetStartPoint(ptResStart);
|
||
}
|
||
else
|
||
{
|
||
pLine1->setEndPoint(ptResStart);
|
||
cvSegLine1.SetEndPoint(ptResStart);
|
||
}
|
||
}
|
||
|
||
bExtendEnd = (PR_EXTEND == (ptResEnd & cvSegLine1));
|
||
if (bExtendEnd)
|
||
{
|
||
ptNearEnd = asPnt3d(cvSegLine1.NearPoint(asDblArray((AcGePoint3d)ptResEnd)));
|
||
// 将离投影点更近的端点延长到投影点
|
||
if (ptNearEnd.isEqualTo(cvSegLine1.GetEndPoint()))
|
||
{
|
||
pLine1->setEndPoint(ptResEnd);
|
||
cvSegLine1.SetEndPoint(ptResEnd);
|
||
}
|
||
else
|
||
{
|
||
pLine1->setStartPoint(ptResEnd);
|
||
cvSegLine1.SetStartPoint(ptResEnd);
|
||
}
|
||
}
|
||
pLine1->downgradeOpen();
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// 判断两弧线是否重合
|
||
bool TchDupAxis::IsDupArc(AcDbArc *pArc1, AcDbArc *pArc2, bool bDim)
|
||
{
|
||
if (pArc1==NULL || pArc2==NULL)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// 判断条件：两条弧圆心和半径都相同
|
||
if (pArc1->center().isEqualTo(pArc2->center()) &&
|
||
fabs(pArc1->radius() - pArc2->radius()) < _DIST_SNAP)
|
||
{
|
||
double dStartAngle = pArc1->startAngle(),
|
||
dEndAngle = pArc1->endAngle();
|
||
if (!MergeArc(dStartAngle, dEndAngle, pArc2->startAngle(), pArc2->endAngle(), bDim))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (pArc1->upgradeOpen() == Acad::eOk)
|
||
{
|
||
pArc1->setStartAngle(dStartAngle);
|
||
pArc1->setEndAngle(dEndAngle);
|
||
pArc1->downgradeOpen();
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
// 判断两圆是否重合
|
||
bool TchDupAxis::IsDupCircle(AcDbCircle *pCircle1, AcDbCircle *pCircle2, bool bDim)
|
||
{
|
||
if (pCircle1==NULL || pCircle2==NULL)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (pCircle1->center().isEqualTo(pCircle2->center()) &&
|
||
fabs(pCircle1->radius() - pCircle2->radius()) < _DIST_SNAP)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
// 消除重线
|
||
bool TchDupAxis::RemoveDupLine(PickSet &ssLine, bool bDim)
|
||
{
|
||
long lLength = ssLine.Length();
|
||
for (long i=0; i<lLength-1; i++)
|
||
{
|
||
Entity ent1 = ssLine[i];
|
||
OPENOBJ_BEGIN(ent1, AcDb::kForRead, AcDbLine, pLine1);
|
||
if (pLine1 == NULL)
|
||
continue;
|
||
|
||
for (long j=i+1; j<lLength; j++) // 与选择集里的第n个以后的实体，做重合检查
|
||
{
|
||
Entity ent2 = ssLine[j];
|
||
OPENOBJ_BEGIN(ent2, AcDb::kForRead, AcDbLine, pLine2);
|
||
if (pLine2 == NULL)
|
||
continue;
|
||
|
||
// 判断是否是重复的直线
|
||
if (!TchDupAxis::IsDupLine(pLine1, pLine2, bDim)) // 不重合
|
||
continue;
|
||
|
||
if (pLine2->upgradeOpen() == Acad::eOk) // 重合
|
||
{
|
||
pLine2->erase(); // 删除
|
||
pLine2->downgradeOpen();
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
ssLine -= ent2;
|
||
j--; // 下标减1，保证选择集里遍历时不会漏掉任何一个实体
|
||
lLength--;
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// 消除重弧线
|
||
bool TchDupAxis::RemoveDupArc(PickSet &ssArc, bool bDim)
|
||
{
|
||
long lLength = ssArc.Length();
|
||
for (long i=0; i<lLength-1; i++)
|
||
{
|
||
Entity ent1 = ssArc[i];
|
||
OPENOBJ_BEGIN(ent1, AcDb::kForRead, AcDbArc, pArc1);
|
||
if (pArc1 == NULL)
|
||
continue;
|
||
|
||
for (long j=i+1; j<lLength; j++) // 与选择集里的第n个以后的实体，做重合检查
|
||
{
|
||
Entity ent2 = ssArc[j];
|
||
OPENOBJ_BEGIN(ent2, AcDb::kForRead, AcDbArc, pArc2);
|
||
if (pArc2 == NULL)
|
||
continue;
|
||
|
||
// 判断是否是重复的直线
|
||
if (!TchDupAxis::IsDupArc(pArc1, pArc2, bDim)) // 不重合
|
||
continue;
|
||
|
||
if (pArc2->upgradeOpen() == Acad::eOk) // 重合
|
||
{
|
||
pArc2->erase(); // 删除
|
||
pArc2->downgradeOpen();
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
ssArc -= ent2;
|
||
j--;
|
||
lLength--;
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// 消除重圆
|
||
bool TchDupAxis::RemoveDupCircle(PickSet &ssCircle, bool bDim)
|
||
{
|
||
long lLength = ssCircle.Length();
|
||
for (long i=0; i<lLength-1; i++)
|
||
{
|
||
Entity ent1 = ssCircle[i];
|
||
OPENOBJ_BEGIN(ent1, AcDb::kForRead, AcDbCircle, pCircle1);
|
||
if (pCircle1 == NULL)
|
||
continue;
|
||
|
||
for (long j=i+1; j<lLength; j++) // 与选择集里的第n个以后的实体，做重合检查
|
||
{
|
||
Entity ent2 = ssCircle[j];
|
||
OPENOBJ_BEGIN(ent2, AcDb::kForRead, AcDbCircle, pCircle2);
|
||
if (pCircle2 == NULL)
|
||
continue;
|
||
|
||
// 判断是否是重复的直线
|
||
if (!TchDupAxis::IsDupCircle(pCircle1, pCircle2, bDim)) // 不重合
|
||
continue;
|
||
|
||
if (pCircle2->upgradeOpen() == Acad::eOk) // 重合
|
||
{
|
||
pCircle2->erase(); // 删除
|
||
pCircle2->downgradeOpen();
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
ssCircle -= ent2;
|
||
j--;
|
||
lLength--;
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// 消除重合轴网
|
||
bool TchDupAxis::RemoveDupAxis(PickSet ss, bool bDim)
|
||
{
|
||
if (ss.Length() < 2)
|
||
{
|
||
return false; // 选择集内对象不足两个，不需要消重
|
||
}
|
||
|
||
PickSet ssLine(SS_FREE);
|
||
ssLine += ss;
|
||
ssLine.BaseFilter(RBList(RTDXF0, _T("LINE"), NULL)); // 只保留直线
|
||
if (ssLine.Length() > 0)
|
||
{
|
||
ss -= ssLine;
|
||
|
||
TchDupAxis::RemoveDupLine(ssLine, bDim); // 处理直线和直线相交的情况
|
||
ss += ssLine;
|
||
}
|
||
|
||
PickSet ssArc(SS_FREE);
|
||
ssArc += ss;
|
||
ssArc.BaseFilter(RBList(RTDXF0, _T("ARC"), NULL)); // 只保留弧线
|
||
if (ssArc.Length() > 0)
|
||
{
|
||
ss -= ssArc;
|
||
|
||
TchDupAxis::RemoveDupArc(ssArc, bDim); // 处理弧线和弧线相交的情况
|
||
ss += ssArc;
|
||
}
|
||
|
||
|
||
PickSet ssCircle(SS_FREE);
|
||
ssCircle += ss;
|
||
ssCircle.BaseFilter(RBList(RTDXF0, _T("CIRCLE"), NULL)); // 只保留圆
|
||
if (ssCircle.Length() > 0)
|
||
{
|
||
ss -= ssCircle;
|
||
|
||
TchDupAxis::RemoveDupCircle(ssCircle, bDim); // 处理圆和圆相交的情况
|
||
ss += ssCircle;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////
|
||
// modified by cwk
|
||
// 命令：两点轴标
|
||
void DimAxisBy2Curve()
|
||
{
|
||
XAxisDimSet::g_AntiClockWise = TRUE; // 默认逆时针方向
|
||
InitLayer(LAY_DIMAX, TRUE);
|
||
|
||
// [2010-4-7 wubo] 重复语句。与函数开头重复。
|
||
// XAxisDimSet::g_AntiClockWise = 1; // 默认逆时针方向
|
||
Entity entFirst, entFinal;
|
||
XPoint ptPick1, ptPick2;
|
||
TCHAR szLabStart[80] = _T(""); // 起始轴号
|
||
double nAxisDirection = 0.0;
|
||
|
||
CTemporaryResourceOverride vTemp;
|
||
CAxisDim *pDlg = new CAxisDim(acedGetAcadFrame());
|
||
pDlg->m_csLabel = szLabStart;
|
||
pDlg->m_Flag = 0;
|
||
pDlg->Create(CAxisDim::IDD,acedGetAcadFrame());
|
||
acedGetAcadFrame()->SetFocus();
|
||
|
||
RBList mask(RTDXF0, _T("LINE,ARC,CIRCLE"), 8, LAY_AXIS, NULL); // 8为AcDb::kDxfLayerName
|
||
while (pDlg != NULL)
|
||
{
|
||
// 清空上次标注值，不过不知道为什么这样做
|
||
pDlg->m_csLabel = _T("");
|
||
pDlg->UpdateData(FALSE);
|
||
|
||
if (SelectEntity1(_T("\n请选择起始轴线<退出>:"), entFirst, ptPick1, mask) != RTNORM)
|
||
{
|
||
if (pDlg != NULL)
|
||
{
|
||
pDlg->DestroyWindow();
|
||
delete pDlg;
|
||
pDlg = NULL;
|
||
}
|
||
return ;
|
||
}
|
||
|
||
XCurveSegment curveFirst(entFirst);
|
||
if (!curveFirst.Is(CURVE_CIRCLE))
|
||
{
|
||
nAxisDirection = curveFirst.IDirection(0);
|
||
if (nAxisDirection<PI/4 || nAxisDirection>1.75*PI ||
|
||
(nAxisDirection>0.75*PI && nAxisDirection<1.25*PI))
|
||
{
|
||
_tcscpy(szLabStart, _T("A"));
|
||
|
||
}
|
||
else
|
||
{
|
||
_tcscpy(szLabStart, _T("1"));
|
||
}
|
||
|
||
if (!pDlg->m_csLabel.IsEmpty())
|
||
{
|
||
_tcscpy(szLabStart, pDlg->m_csLabel);
|
||
}
|
||
else
|
||
{
|
||
TCHAR cTemp[256];
|
||
_tcscpy(cTemp,szLabStart);
|
||
pDlg->m_csLabel = cTemp;
|
||
pDlg->UpdateData(FALSE);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
pDlg->DestroyWindow();
|
||
delete pDlg;
|
||
pDlg = NULL;
|
||
// return;
|
||
}
|
||
|
||
if (entFinal.FilterSelect1(GetPickBoxWcs()/2, _T("\n请选择终止轴线<退出>:"), mask, ptPick2) != RTNORM)
|
||
{
|
||
if (pDlg != NULL)
|
||
{
|
||
pDlg->DestroyWindow();
|
||
delete pDlg;
|
||
pDlg = NULL;
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (entFirst == entFinal)
|
||
{
|
||
if (pDlg != NULL)
|
||
{
|
||
pDlg->DestroyWindow();
|
||
delete pDlg;
|
||
pDlg = NULL;
|
||
}
|
||
return;
|
||
}
|
||
|
||
ptPick1 = Ucs2Wcs(ptPick1);
|
||
ptPick2 = Ucs2Wcs(ptPick2);
|
||
|
||
XCurveSegment curveFinal(entFinal);
|
||
if (curveFirst.GetCurveType() != curveFinal.GetCurveType())
|
||
{
|
||
if (pDlg != NULL)
|
||
{
|
||
pDlg->DestroyWindow();
|
||
delete pDlg;
|
||
pDlg = NULL;
|
||
}
|
||
return;
|
||
}
|
||
|
||
BOOL bRadian = FALSE,
|
||
bCirAngular = FALSE;
|
||
XPoint ptAxisNetCen;
|
||
if (curveFirst.Is(CURVE_LINE) &&
|
||
(!CT_IsSameDrt(curveFirst.IDirection(0), curveFinal.IDirection(0), _angSnap) ||
|
||
(curveFirst.StartPoint()&curveFinal) != PR_OUTSIDE))
|
||
{
|
||
PickSet ssTemp(SS_FREE);
|
||
TADSGePoint3d pt1(Wcs2Ucs(curveFirst.StartPoint())),
|
||
pt2(Wcs2Ucs(curveFirst.EndPoint()));
|
||
RBList rbFence = ads_buildlist(RT3DPOINT, &pt1,
|
||
RT3DPOINT, &pt2, NULL);
|
||
bCirAngular = (ssTemp.Get(_T("F"), rbFence, NULL,
|
||
RBList(RTDXF0, _T("CIRCLE"), 8, LAY_AXIS, NULL)) == RTNORM);
|
||
|
||
bRadian = TRUE;
|
||
if ((curveFirst.StartPoint()&curveFinal)!=PR_OUTSIDE)
|
||
{
|
||
ptAxisNetCen = curveFirst.StartPoint()+curveFirst.EndPoint()
|
||
+curveFinal.StartPoint()+curveFinal.EndPoint();
|
||
ptAxisNetCen /= 4.0;
|
||
}
|
||
else
|
||
{
|
||
XLine ln1 = curveFirst.GetLine();
|
||
XLine ln2 = curveFinal.GetLine();
|
||
ln1.SetLineFlag(LS_INFINITE);
|
||
ln2.SetLineFlag(LS_INFINITE);
|
||
ln1.Intersection(&ln2, ptAxisNetCen);
|
||
}
|
||
|
||
int nAnswer = YesNoQuestion(_T("\n是否为按逆时针方向排序编号"));
|
||
if (nAnswer == RTCAN)
|
||
{
|
||
if (pDlg != NULL)
|
||
{
|
||
pDlg->DestroyWindow();
|
||
delete pDlg;
|
||
pDlg = NULL;
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
if (nAnswer == Q_NO)
|
||
{
|
||
XAxisDimSet::g_AntiClockWise = FALSE;
|
||
}
|
||
else
|
||
{
|
||
XAxisDimSet::g_AntiClockWise = TRUE;
|
||
}
|
||
}
|
||
|
||
XAxisPickSet ssAxis(SS_FREE);
|
||
if (bRadian && !XAxisDimSet::g_AntiClockWise)
|
||
{
|
||
ssAxis.GetFrom2Curve(curveFinal, curveFirst);
|
||
}
|
||
else
|
||
{
|
||
ssAxis.GetFrom2Curve(curveFirst, curveFinal);
|
||
}
|
||
|
||
// Zyu add on 100617，将原选择集内的对象，绘制为高亮显示
|
||
ssAxis.Redraw(3);
|
||
|
||
// 增加对辅助轴线的判断，即允许用户自行指定不进行标注的轴线
|
||
PickSet ssCancel(SS_FREE);
|
||
ssCancel += ssAxis;
|
||
|
||
// add by xly on 110304 清空pickfirt选择集
|
||
ads_name ssPickFirst; // 定义一个ads_name变量
|
||
if (acedSSAdd(NULL, NULL, ssPickFirst) == RTNORM) // 构造一个空选择集
|
||
{
|
||
acedSSSetFirst(ssPickFirst, NULL); // 将空选择集赋给PICKFIRST
|
||
}
|
||
|
||
const TCHAR *szTempPrompts[2]={ _T("\n请选择不需要标注的轴线:"), _T("") };
|
||
while(ssCancel.Get(_T(":S:$"), szTempPrompts, NULL, mask) == RTNORM)
|
||
{
|
||
// 首先将不需要标注的轴线，取消高亮
|
||
ssCancel.Redraw(4);
|
||
|
||
// 去掉用户指定的不进行标注的轴线
|
||
ssAxis -= ssCancel;
|
||
}
|
||
|
||
// modify by xly on 100812 如果只剩一个轴网被选中，退出命令时选中轴网不能回复原始状态
|
||
//if (!ssAxis)
|
||
if (!ssAxis || ssAxis.Length()<2)
|
||
{
|
||
// 取消轴网的高亮状态
|
||
ssAxis.Redraw(4);
|
||
adsout << _T("\n不能找到轴网!");
|
||
if (pDlg != NULL)
|
||
{
|
||
pDlg->DestroyWindow();
|
||
delete pDlg;
|
||
pDlg = NULL;
|
||
}
|
||
|
||
return ;
|
||
}
|
||
|
||
// modify by xlc on 090225 解决圆弧轴网径线消重合并的问题
|
||
// if (!RemoveDupLine(ssAxis)) //add by xlc on 070806 消除重线
|
||
// return;
|
||
// if (!bRadian)
|
||
// {
|
||
|
||
// 消除重线
|
||
// if (!RemoveDupLine(ssAxis,TRUE))
|
||
|
||
// modify by xly on 100812 修改 命令行多出“Dangerous TPickEntSet = !”的提示
|
||
PickSet ssAxisNew(SS_CREATE);
|
||
ssAxisNew += ssAxis;
|
||
//if (!TchDupAxis::RemoveDupAxis(ssAxis,TRUE))
|
||
if (!TchDupAxis::RemoveDupAxis(ssAxisNew,TRUE))
|
||
{
|
||
// sg add 100609，增加消除重现不成功时，销毁对话框
|
||
if (pDlg != NULL)
|
||
{
|
||
pDlg->DestroyWindow();
|
||
delete pDlg;
|
||
pDlg = NULL;
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
ssAxis.Free();
|
||
ssAxis += ssAxisNew;
|
||
ssAxisNew.Free();
|
||
// }
|
||
|
||
// 似乎没有用处，可删除
|
||
ssAxis.Redraw(3);
|
||
|
||
XPoint ptAxisEnd = curveFirst.NearPoint(ptPick1);
|
||
XCurveSegment cvSortBase; // 排序的基线
|
||
|
||
if (!bRadian)
|
||
{
|
||
if (curveFirst.Is(CURVE_CIRCLE))
|
||
{
|
||
Entity entBase;
|
||
if (entBase.FilterSelect(_T("\n请选择圆形轴网的横(径)线:"), RBList(RTDXF0, _T("LINE"), 8, LAY_AXIS, NULL))!=RTNORM)
|
||
{
|
||
ssAxis.Redraw(4);
|
||
if (pDlg != NULL)
|
||
{
|
||
pDlg->DestroyWindow();
|
||
delete pDlg;
|
||
pDlg = NULL;
|
||
}
|
||
|
||
return;
|
||
}
|
||
cvSortBase = XCurveSegment(entBase);
|
||
}
|
||
else
|
||
{
|
||
double nDist2Me = curveFirst.GetDist2Me(curveFinal.StartPoint());
|
||
cvSortBase.StartPoint() = curveFirst.StartPoint();
|
||
ads_polar(curveFirst.StartPoint(), curveFirst.IDirection(0)-PI/2.0, nDist2Me, cvSortBase.EndPoint());
|
||
cvSortBase.SetBulge(0.0);
|
||
// cvSortBase.Make();
|
||
}
|
||
}
|
||
else if (bCirAngular)
|
||
{
|
||
// 圆形轴网角度标注
|
||
cvSortBase = XCircle(ptAxisNetCen, ptAxisNetCen.Distance2d(curveFirst.FarPoint(ptAxisNetCen)));
|
||
}
|
||
else
|
||
{
|
||
double nAng1 = ads_angle(ptAxisNetCen, curveFirst.FarPoint(ptAxisNetCen));
|
||
double nAng2 = ads_angle(ptAxisNetCen, curveFinal.FarPoint(ptAxisNetCen));
|
||
if (XAxisDimSet::g_AntiClockWise == FALSE)
|
||
{
|
||
Exchange(nAng1, nAng2);
|
||
}
|
||
cvSortBase = XArc(ptAxisNetCen, ptAxisNetCen.Distance2d(curveFirst.FarPoint(ptAxisNetCen)),
|
||
nAng1, nAng2);
|
||
}
|
||
|
||
// Add on 2002/6/14, 解决圆形轴网起始轴角度不是最小时无法标注的问题
|
||
double nVal = XAxisDimSet::g_nAngleBegin;
|
||
if (cvSortBase.Is(CURVE_CIRCLE))
|
||
{
|
||
nVal = ads_angle(ptAxisNetCen, curveFirst.FarPoint(ptAxisNetCen));
|
||
}
|
||
|
||
XPushMemVar<double> vTemp1(XAxisDimSet::g_nAngleBegin, nVal);
|
||
if (curveFirst.Is(CURVE_CIRCLE))
|
||
{
|
||
XLine lnBase = cvSortBase.GetLine();
|
||
lnBase.SetLineFlag(LS_FINITE);
|
||
XPoint ptInt;
|
||
if (!curveFirst.Intersection(lnBase, ptInt, XPoint()))
|
||
{
|
||
if (pDlg != NULL)
|
||
{
|
||
pDlg->DestroyWindow();
|
||
delete pDlg;
|
||
pDlg = NULL;
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
nAxisDirection = ads_angle(curveFirst.GetCircle().GetCenterPt(), ptInt)+PI/2.0;
|
||
if (nAxisDirection<PI/4 || nAxisDirection>1.75*PI ||
|
||
(nAxisDirection>0.75*PI && nAxisDirection<1.25*PI))
|
||
{
|
||
_tcscpy(szLabStart, _T("A"));
|
||
}
|
||
else
|
||
{
|
||
_tcscpy(szLabStart, _T("1"));
|
||
}
|
||
}
|
||
|
||
// 建立排序的轴网单侧
|
||
XAxisDimSet dimSet(&cvSortBase);
|
||
long ssLen = ssAxis.Length();
|
||
for (long i=0; i<ssLen; i++)
|
||
{
|
||
Entity ent = ssAxis[i];
|
||
dimSet.Append(new XCurveSegment(ent));
|
||
}
|
||
dimSet.QuickSort(XAxisDimSet::SortFunc);
|
||
|
||
if (!(*dimSet.Head() == curveFirst))
|
||
{
|
||
if (cvSortBase.Is(CURVE_CIRCLE))
|
||
{
|
||
adsout << _T("\n发现不能正确分析的轴网!");
|
||
if (pDlg != NULL)
|
||
{
|
||
pDlg->DestroyWindow();
|
||
delete pDlg;
|
||
pDlg = NULL;
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
if (*dimSet.Tail() == curveFirst)
|
||
{
|
||
dimSet.Reverse();
|
||
XAxisDimSet::g_AntiClockWise = FALSE;
|
||
}
|
||
else
|
||
{
|
||
adsout << _T("\n所选择的不是起始轴线!");
|
||
if (pDlg != NULL)
|
||
{
|
||
pDlg->DestroyWindow();
|
||
delete pDlg;
|
||
pDlg = NULL;
|
||
}
|
||
|
||
return;
|
||
}
|
||
}
|
||
|
||
AcDbObjectId idDimStyle = InitDimStyle(bRadian ? DS_ANGLE : DS_LINEAR);
|
||
|
||
TDbAxisLabelSet *pAxisDim = new TDbAxisLabelSet;
|
||
pAxisDim->SetTextStyleId(InitTextStyle(TS_AXIS));
|
||
pAxisDim->ConvertFrom(dimSet);
|
||
pAxisDim->SetChangePreNum(1 == pDlg->m_iRule); // 设置轴号规则（变前项或者变后项），Zyu add on 100618
|
||
|
||
double nOldLen = pAxisDim->GetLeaderLen(0, TRUE);
|
||
if (pAxisDim->IsArcAxisNet() && pAxisDim->IsArcAxis())
|
||
{
|
||
pAxisDim->SetLeaderLen(0, nOldLen+10.0, TRUE); //圆弧轴网的进深标注, 引线需要加长
|
||
pAxisDim->SetLeaderLen(1, nOldLen+10.0, TRUE); //圆弧轴网的进深标注, 引线需要加长
|
||
}
|
||
|
||
int nLabelFlag = 0, nDimFlag = 0;
|
||
AcDbObjectId idPrevLink;
|
||
if (curveFirst.Is(CURVE_CIRCLE))
|
||
{
|
||
XString szBackup;
|
||
szBackup = szLabStart;
|
||
adsout << _T("\n请输入起始轴号(.空号)<") << szLabStart << _T(">: ");
|
||
if (ads_getstring(0, _T(""), szLabStart) == RTNORM)
|
||
{
|
||
if (_tcscmp(szLabStart, _T(".")) == 0)
|
||
{
|
||
_tcscpy(szLabStart, _T(""));
|
||
}
|
||
else if (!szLabStart[0])
|
||
{
|
||
_tcscpy(szLabStart, szBackup);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (pDlg != NULL)
|
||
{
|
||
pDlg->DestroyWindow();
|
||
delete pDlg;
|
||
pDlg = NULL;
|
||
}
|
||
|
||
return;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (pDlg->m_bPrevLink)
|
||
{
|
||
/* Entity entPrev;
|
||
ads_sssetfirst(NULL, NULL);
|
||
if (entPrev.FilterSelect(_T("\n点取前接轴号<退出>:"), RBList(RTDXF0, _T("ATS_AXIS_LABEL"),NULL))!=RTNORM)
|
||
{
|
||
if (pDlg != NULL)
|
||
{
|
||
pDlg->DestroyWindow();
|
||
delete pDlg;
|
||
pDlg = NULL;
|
||
}
|
||
return;
|
||
}
|
||
acdbGetObjectId(idPrevLink, entPrev);*/
|
||
|
||
//add by cwk on 070123
|
||
PickSet ss(SS_FREE);
|
||
XLine xLineTemp = curveFirst;
|
||
xLineTemp.StartPoint() = Wcs2Ucs(xLineTemp.StartPoint());
|
||
xLineTemp.EndPoint() = Wcs2Ucs(xLineTemp.EndPoint());
|
||
|
||
RBList rbFence = ads_buildlist(RT3DPOINT, &xLineTemp.StartPoint(), RT3DPOINT, &xLineTemp.EndPoint(), NULL);
|
||
ss.Get(_T("F"),rbFence, NULL, RBList(RTDXF0, _T("ATS_AXIS_LABEL"), NULL));
|
||
if (ss.Length() > 0)
|
||
{
|
||
Entity entPrev = ss[0L];
|
||
acdbGetObjectId(idPrevLink, entPrev);
|
||
}
|
||
else
|
||
{
|
||
// add by xly on 101029 解决公共轴线选则失败时恢复亮显
|
||
ssAxis.Redraw(4);
|
||
acutPrintf(_T("\n没有找到前接轴号!"));
|
||
continue;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//modified by whl on 070511,保留空号功能
|
||
//if (!pDlg->m_csLabel.IsEmpty())
|
||
//{
|
||
// _tcscpy(szLabStart, pDlg->m_csLabel);
|
||
//}
|
||
_tcscpy(szLabStart, pDlg->m_csLabel);
|
||
}
|
||
|
||
nLabelFlag = pDlg->m_Flag;
|
||
nDimFlag = pDlg->m_Flag;
|
||
/*if (pDlg != NULL)
|
||
{
|
||
pDlg->DestroyWindow();
|
||
delete pDlg;
|
||
pDlg = NULL;
|
||
}*/
|
||
}
|
||
|
||
if (!idPrevLink)
|
||
{
|
||
pAxisDim->SortAxisLabel(szLabStart);
|
||
}
|
||
|
||
AcDbObjectId idDimLay = InitLayer(LAY_DIMAX, TRUE);
|
||
AcDbObjectId idTextLay = InitLayer(LAY_AXIS_TEXT, TRUE);
|
||
|
||
List<TDbDimension2*> lstNewDim;
|
||
if (curveFirst.Is(CURVE_CIRCLE))
|
||
{
|
||
pAxisDim->HideSide(1);
|
||
|
||
TAxisLabelEdJig jig(pAxisDim);
|
||
jig.SetPrompt(_T("\n请输入标注位置<退出>:"));
|
||
if (jig.DoIt()!=RTNORM)
|
||
{
|
||
delete pAxisDim;
|
||
return;
|
||
}
|
||
|
||
if (pAxisDim->GetAxisNum()>1)
|
||
{
|
||
TDbDimension2 *pDim1 = new TDbDimension2;
|
||
TDbDimension2 *pDim2 = new TDbDimension2;
|
||
pDim1->SetLayoutRotation(Ucs2Wcs(0));//add by whl on 070306
|
||
pDim2->SetLayoutRotation(Ucs2Wcs(0));//add by whl on 070306
|
||
pDim1->SetStyleId(idDimStyle);
|
||
pDim2->SetStyleId(idDimStyle);
|
||
|
||
if (pAxisDim->GetDimension(0, *pDim1, *pDim2))
|
||
{
|
||
pDim1->setLayer(idDimLay);
|
||
pDim2->setLayer(idDimLay);
|
||
lstNewDim<<pDim1<<pDim2;
|
||
}
|
||
else
|
||
{
|
||
delete pDim1;
|
||
delete pDim2;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
int nSidePick = pAxisDim->OnWhichSide(ptPick1);
|
||
if (nLabelFlag != 2)
|
||
{
|
||
if (nLabelFlag == 0)
|
||
pAxisDim->HideSide(1-nSidePick);
|
||
else
|
||
pAxisDim->HideSide(nSidePick);
|
||
}
|
||
|
||
//Modify on 2002/2/22 by ZJQ, 解决弧线标注的半径未能设置在相关的轴线的半径
|
||
// 增加扇形的标注半径
|
||
XAxisPickSet ssOpp(SS_FREE);
|
||
double nRadMin = 0.0,
|
||
nRadMax = 0.0;
|
||
if (bRadian)
|
||
{
|
||
nRadMin = nRadMax = cvSortBase.GetArc().GetRadius();
|
||
ssOpp.GetFromOppsite(curveFirst, FILT_CIRARC_ONLY);
|
||
|
||
long lNum = ssOpp.Length();
|
||
for (long idx=0L; idx<lNum; idx++)
|
||
{
|
||
Entity ent = ssOpp[idx];
|
||
XCurveSegment segTemp(ent);
|
||
if (segTemp.Is(CURVE_ARC))
|
||
{
|
||
if (idx == 0)
|
||
{
|
||
nRadMin = nRadMax = segTemp.GetArc().GetRadius();
|
||
}
|
||
else
|
||
{
|
||
nRadMax = max(nRadMax, segTemp.GetArc().GetRadius());
|
||
nRadMin = min(nRadMin, segTemp.GetArc().GetRadius());
|
||
}
|
||
}
|
||
else if (segTemp.Is(CURVE_CIRCLE))
|
||
{
|
||
if (idx == 0)
|
||
{
|
||
nRadMin = nRadMax = segTemp.GetCircle().GetRadius();
|
||
}
|
||
else
|
||
{
|
||
nRadMax = max(nRadMax, segTemp.GetCircle().GetRadius());
|
||
nRadMin = min(nRadMin, segTemp.GetCircle().GetRadius());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// End
|
||
if (pAxisDim->GetAxisNum() > 1)
|
||
{
|
||
for (int nSide=0; nSide<2; nSide++)
|
||
{
|
||
if (nDimFlag == 0 && nSide != nSidePick)
|
||
{
|
||
continue;
|
||
}
|
||
else if (nDimFlag == 1 && nSide == nSidePick)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
TDbDimension2 *pDim1 = new TDbDimension2;
|
||
TDbDimension2 *pDim2 = new TDbDimension2;
|
||
pDim1->SetLayoutRotation(Ucs2Wcs(0)); // add by whl on 070306
|
||
pDim2->SetLayoutRotation(Ucs2Wcs(0)); // add by whl on 070306
|
||
|
||
pDim1->SetStyleId(idDimStyle);
|
||
pDim2->SetStyleId(idDimStyle);
|
||
|
||
// Zyu modify on 100618，根据“尺寸标注对侧”选项设置尺寸的位置
|
||
int iMarkSide = pDlg->m_bOtherSide? !nSide : nSide;
|
||
// if(pAxisDim->GetDimension(nSide, *pDim1, *pDim2))
|
||
if (pAxisDim->GetDimension(iMarkSide, *pDim1, *pDim2))
|
||
{
|
||
// Modify on 2002/2/22 by ZJQ, 解决弧线标注的半径未能设置在相关的轴线的半径
|
||
if (bRadian)
|
||
{
|
||
// Zyu modify on 100618
|
||
// 弧线轴网的开间标注
|
||
// pDim1->SetObjRadius(nSide ? nRadMax : nRadMin);
|
||
// pDim2->SetObjRadius(nSide ? nRadMax : nRadMin);
|
||
pDim1->SetObjRadius(iMarkSide ? nRadMax : nRadMin);
|
||
pDim2->SetObjRadius(iMarkSide ? nRadMax : nRadMin);
|
||
}
|
||
// End
|
||
|
||
pDim1->setLayer(idDimLay);
|
||
pDim2->setLayer(idDimLay);
|
||
lstNewDim<<pDim1<<pDim2;
|
||
}
|
||
else
|
||
{
|
||
delete pDim1;
|
||
delete pDim2;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (pAxisDim->IsValid())
|
||
{
|
||
pAxisDim->SetTextLayerId(idTextLay);
|
||
pAxisDim->SetLayoutRotation(Ucs2Wcs(0.0));//modified by whl
|
||
pAxisDim->AddToMSpace(Adesk::kFalse);
|
||
if (!!idPrevLink)
|
||
{
|
||
pAxisDim->SetPrevLink(idPrevLink);
|
||
}
|
||
pAxisDim->close();
|
||
}
|
||
else if (pAxisDim != NULL)
|
||
{
|
||
delete pAxisDim;
|
||
}
|
||
|
||
//尺寸最后画
|
||
for (lstNewDim.MoveToFirst();!lstNewDim.IsOut();lstNewDim.MoveToNext())
|
||
{
|
||
AddToModelSpace(lstNewDim.GetCurData(),Adesk::kTrue);
|
||
}
|
||
ssAxis.Redraw(4);
|
||
}
|
||
|
||
if (pDlg != NULL)
|
||
{
|
||
pDlg->DestroyWindow();
|
||
delete pDlg;
|
||
pDlg = NULL;
|
||
}
|
||
}
|
||
|
||
// curve--第一根轴线
|
||
// cvSortBase--用来排序的正交线
|
||
// ssAxis--待标注的轴线
|
||
// ptPick--点取位置
|
||
// bRadian--是否为角度标注
|
||
void DimAxisLabel(const XCurveSegment &curve, XCurveSegment &cvSortBase,
|
||
PickSet &ssAxis, XPoint ptPick, BOOL bRadian)
|
||
{
|
||
TCHAR szLabStart[80]=_T("1");
|
||
double nAxisDirection=0.0;
|
||
if (curve.Is(CURVE_CIRCLE))
|
||
{
|
||
XLine lnBase=cvSortBase.GetLine();
|
||
lnBase.SetLineFlag(LS_FINITE);
|
||
XPoint ptInt;
|
||
if (!curve.Intersection(lnBase, ptInt, XPoint()))
|
||
{
|
||
return;
|
||
}
|
||
nAxisDirection=ads_angle(curve.GetCircle().GetCenterPt(), ptInt)+PI/2.0;
|
||
}
|
||
else
|
||
{
|
||
nAxisDirection= curve.IDirection(0);
|
||
}
|
||
|
||
if (nAxisDirection<PI/4 || nAxisDirection>1.75*PI ||
|
||
(nAxisDirection>0.75*PI && nAxisDirection<1.25*PI))
|
||
{
|
||
_tcscpy(szLabStart, _T("A"));
|
||
}
|
||
|
||
// 建立排序的轴网单侧
|
||
XAxisDimSet dimSet(&cvSortBase);
|
||
long ssLen=ssAxis.Length();
|
||
for (long i=0; i<ssLen; i++)
|
||
{
|
||
Entity ent=ssAxis[i];
|
||
dimSet.Append(new XCurveSegment(ent));
|
||
}
|
||
dimSet.QuickSort(XAxisDimSet::SortFunc);
|
||
|
||
if (!(*dimSet.Head() == curve))
|
||
{
|
||
if (cvSortBase.Is(CURVE_CIRCLE))
|
||
{
|
||
adsout << _T("\n发现不能正确分析的轴网!");
|
||
return;
|
||
}
|
||
|
||
if (*dimSet.Tail() == curve)
|
||
{
|
||
dimSet.Reverse();
|
||
XAxisDimSet::g_AntiClockWise=FALSE;
|
||
}
|
||
else
|
||
{
|
||
adsout << _T("\n所选择的不是起始轴线!");
|
||
return;
|
||
}
|
||
}
|
||
|
||
AcDbObjectId idDimStyle=InitDimStyle(bRadian? DS_ANGLE : DS_LINEAR);
|
||
TDbAxisLabelSet *pAxisDim=new TDbAxisLabelSet;
|
||
pAxisDim->SetTextStyleId(InitTextStyle(TS_AXIS));
|
||
pAxisDim->ConvertFrom(dimSet);
|
||
double nOldLen=pAxisDim->GetLeaderLen(0, TRUE);
|
||
if (pAxisDim->IsArcAxisNet() && pAxisDim->IsArcAxis())
|
||
{
|
||
pAxisDim->SetLeaderLen(0, nOldLen+10.0, TRUE); //圆弧轴网的进深标注, 引线需要加长
|
||
pAxisDim->SetLeaderLen(1, nOldLen+10.0, TRUE); //圆弧轴网的进深标注, 引线需要加长
|
||
}
|
||
|
||
int nLabelFlag=0, nDimFlag=0;
|
||
AcDbObjectId idPrevLink;
|
||
if (curve.Is(CURVE_CIRCLE))
|
||
{
|
||
XString szBackup;
|
||
szBackup=szLabStart;
|
||
adsout << _T("\n请输入起始轴号(.空号)<") << szLabStart << _T(">: ");
|
||
if (ads_getstring(0, _T(""), szLabStart) == RTNORM)
|
||
{
|
||
if (_tcscmp(szLabStart, _T(".")) == 0)
|
||
{
|
||
_tcscpy(szLabStart, _T(""));
|
||
}
|
||
else if (!szLabStart[0])
|
||
{
|
||
_tcscpy(szLabStart, szBackup);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
return;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
CDimAxisLabelDlg dlg(acedGetAcadFrame());
|
||
dlg.m_bPrevLink=FALSE;
|
||
dlg.m_csLabel=szLabStart;
|
||
if (bRadian)
|
||
{
|
||
int nSide=pAxisDim->OnWhichSide(ptPick);
|
||
dlg.m_dimFlag=nSide? 1 : 0;
|
||
dlg.m_labelFlag=nSide? 0 : 1;
|
||
}
|
||
else
|
||
{
|
||
//modified by whl
|
||
//dlg.m_dimFlag=0;
|
||
//dlg.m_labelFlag=0;
|
||
dlg.m_dimFlag=2;
|
||
dlg.m_labelFlag=2;
|
||
}
|
||
|
||
{
|
||
CTemporaryResourceOverride vTemp;
|
||
if (dlg.DoModal()!=IDOK)
|
||
{
|
||
delete pAxisDim;
|
||
return;
|
||
}
|
||
}
|
||
|
||
if (dlg.m_bPrevLink)
|
||
{
|
||
Entity entPrev;
|
||
ads_sssetfirst(NULL, NULL);
|
||
if (entPrev.FilterSelect(_T("\n点取前接轴号<退出>:"), RBList(RTDXF0, _T("ATS_AXIS_LABEL"),NULL))!=RTNORM)
|
||
{
|
||
return;
|
||
}
|
||
acdbGetObjectId(idPrevLink, entPrev);
|
||
}
|
||
else
|
||
{
|
||
_tcscpy(szLabStart, dlg.m_csLabel);
|
||
}
|
||
nLabelFlag=dlg.m_labelFlag;
|
||
nDimFlag=dlg.m_dimFlag;
|
||
}
|
||
|
||
if (!idPrevLink)
|
||
{
|
||
pAxisDim->SortAxisLabel(szLabStart);
|
||
}
|
||
|
||
AcDbObjectId idDimLay=InitLayer(LAY_DIMAX, TRUE);
|
||
AcDbObjectId idTextLay=InitLayer(LAY_AXIS_TEXT, TRUE);
|
||
if (curve.Is(CURVE_CIRCLE))
|
||
{
|
||
pAxisDim->HideSide(1);
|
||
TAxisLabelEdJig jig(pAxisDim);
|
||
jig.SetPrompt(_T("\n请输入标注位置<退出>:"));
|
||
if (jig.DoIt()!=RTNORM)
|
||
{
|
||
delete pAxisDim;
|
||
|
||
return;
|
||
}
|
||
if (pAxisDim->GetAxisNum()>1)
|
||
{
|
||
TDbDimension2 *pDim1=new TDbDimension2;
|
||
TDbDimension2 *pDim2=new TDbDimension2;
|
||
pDim1->SetLayoutRotation(Ucs2Wcs(0));//add by whl on 070306
|
||
pDim2->SetLayoutRotation(Ucs2Wcs(0));//add by whl on 070306
|
||
pDim1->SetStyleId(idDimStyle);
|
||
pDim2->SetStyleId(idDimStyle);
|
||
if (pAxisDim->GetDimension(0, *pDim1, *pDim2))
|
||
{
|
||
pDim1->setLayer(idDimLay);
|
||
pDim2->setLayer(idDimLay);
|
||
AddToModelSpace(pDim1,Adesk::kTrue);
|
||
AddToModelSpace(pDim2,Adesk::kTrue);
|
||
|
||
}
|
||
else
|
||
{
|
||
delete pDim1;
|
||
delete pDim2;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
int nSidePick=pAxisDim->OnWhichSide(ptPick);
|
||
if (nLabelFlag!=2)
|
||
{
|
||
if (nLabelFlag == 0)
|
||
{
|
||
pAxisDim->HideSide(1-nSidePick);
|
||
}
|
||
else
|
||
{
|
||
pAxisDim->HideSide(nSidePick);
|
||
}
|
||
}
|
||
|
||
//Modify on 2002/2/22 by ZJQ, 解决弧线标注的半径未能设置在相关的轴线的半径
|
||
// 增加扇形的标注半径
|
||
XAxisPickSet ssOpp(SS_FREE);
|
||
double nRadMin=0.0, nRadMax=0.0;
|
||
if (bRadian)
|
||
{
|
||
nRadMin=nRadMax=cvSortBase.GetArc().GetRadius();
|
||
ssOpp.GetFromOppsite(curve, FILT_CIRARC_ONLY);
|
||
long lNum=ssOpp.Length();
|
||
for (long idx=0L; idx<lNum; idx++)
|
||
{
|
||
Entity ent=ssOpp[idx];
|
||
XCurveSegment segTemp(ent);
|
||
if (segTemp.Is(CURVE_ARC))
|
||
{
|
||
if (idx == 0)
|
||
{
|
||
nRadMin=nRadMax=segTemp.GetArc().GetRadius();
|
||
}
|
||
else
|
||
{
|
||
nRadMax=max(nRadMax, segTemp.GetArc().GetRadius());
|
||
nRadMin=min(nRadMin, segTemp.GetArc().GetRadius());
|
||
}
|
||
}
|
||
else if (segTemp.Is(CURVE_CIRCLE))
|
||
{
|
||
if (idx == 0)
|
||
{
|
||
nRadMin=nRadMax=segTemp.GetCircle().GetRadius();
|
||
}
|
||
else
|
||
{
|
||
nRadMax=max(nRadMax, segTemp.GetCircle().GetRadius());
|
||
nRadMin=min(nRadMin, segTemp.GetCircle().GetRadius());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// End
|
||
|
||
if (pAxisDim->GetAxisNum()>1)
|
||
{
|
||
for (int nSide=0; nSide<2; nSide++)
|
||
{
|
||
if (nDimFlag == 0 && nSide!=nSidePick)
|
||
{
|
||
continue;
|
||
}
|
||
else if (nDimFlag == 1 && nSide == nSidePick)
|
||
{
|
||
continue;
|
||
}
|
||
TDbDimension2 *pDim1=new TDbDimension2;
|
||
TDbDimension2 *pDim2=new TDbDimension2;
|
||
pDim1->SetLayoutRotation(Ucs2Wcs(0));//add by whl on 070306
|
||
pDim2->SetLayoutRotation(Ucs2Wcs(0));//add by whl on 070306
|
||
pDim1->SetStyleId(idDimStyle);
|
||
pDim2->SetStyleId(idDimStyle);
|
||
if (pAxisDim->GetDimension(nSide, *pDim1, *pDim2))
|
||
{
|
||
// Modify on 2002/2/22 by ZJQ, 解决弧线标注的半径未能设置在相关的轴线的半径
|
||
if (bRadian)
|
||
{
|
||
//弧线轴网的开间标注
|
||
pDim1->SetObjRadius(nSide? nRadMax : nRadMin);
|
||
pDim2->SetObjRadius(nSide? nRadMax : nRadMin);
|
||
} // End
|
||
|
||
pDim1->setLayer(idDimLay);
|
||
pDim2->setLayer(idDimLay);
|
||
AddToModelSpace(pDim1,Adesk::kTrue);
|
||
AddToModelSpace(pDim2,Adesk::kTrue);
|
||
}
|
||
else
|
||
{
|
||
delete pDim1;
|
||
delete pDim2;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (pAxisDim->IsValid())
|
||
{
|
||
pAxisDim->SetTextLayerId(idTextLay);
|
||
pAxisDim->SetLayoutRotation(Ucs2Wcs(0.0));//modified by whl
|
||
pAxisDim->AddToMSpace(Adesk::kFalse);
|
||
if (!!idPrevLink)
|
||
{
|
||
pAxisDim->SetPrevLink(idPrevLink);
|
||
}
|
||
pAxisDim->close();
|
||
}
|
||
else
|
||
{
|
||
delete pAxisDim;
|
||
}
|
||
}
|
||
|
||
void DimAxisBy2Curve0()
|
||
{
|
||
XAxisDimSet::g_AntiClockWise=TRUE;
|
||
InitLayer(LAY_DIMAX, TRUE);
|
||
|
||
XAxisDimSet::g_AntiClockWise = 1; //默认逆时针方向
|
||
Entity entFirst, entFinal;
|
||
XPoint ptPick1, ptPick2;
|
||
|
||
RBList mask(RTDXF0, _T("LINE,ARC,CIRCLE"), 8, LAY_AXIS, NULL);
|
||
if (SelectEntity1(_T("\n请选择起始轴线<退出>:"), entFirst, ptPick1, mask)!=RTNORM)
|
||
{
|
||
return;
|
||
}
|
||
if (entFinal.FilterSelect1(GetPickBoxWcs()/2, _T("\n请选择终止轴线<退出>:"), mask, ptPick2)!=RTNORM)
|
||
{
|
||
return;
|
||
}
|
||
if (entFirst == entFinal)
|
||
{
|
||
return;
|
||
}
|
||
ptPick1=Ucs2Wcs(ptPick1);
|
||
ptPick2=Ucs2Wcs(ptPick2);
|
||
|
||
XCurveSegment curveFirst(entFirst);
|
||
XCurveSegment curveFinal(entFinal);
|
||
if (curveFirst.GetCurveType()!=curveFinal.GetCurveType())
|
||
{
|
||
return;
|
||
}
|
||
|
||
BOOL bRadian=FALSE, bCirAngular=FALSE;
|
||
XPoint ptAxisNetCen;
|
||
if (curveFirst.Is(CURVE_LINE)
|
||
&& (!CT_IsSameDrt(curveFirst.IDirection(0), curveFinal.IDirection(0), _angSnap)
|
||
|| (curveFirst.StartPoint()&curveFinal)!=PR_OUTSIDE))
|
||
{
|
||
PickSet ssTemp(SS_FREE);
|
||
|
||
TADSGePoint3d pt1(Wcs2Ucs(curveFirst.StartPoint())),
|
||
pt2(Wcs2Ucs(curveFirst.EndPoint()));
|
||
|
||
RBList rbFence=ads_buildlist(RT3DPOINT, &pt1,
|
||
RT3DPOINT, &pt2, NULL);
|
||
bCirAngular=(ssTemp.Get(_T("F"), rbFence, NULL,
|
||
RBList(RTDXF0, _T("CIRCLE"), 8, LAY_AXIS, NULL)) == RTNORM);
|
||
bRadian=TRUE;
|
||
if ((curveFirst.StartPoint()&curveFinal)!=PR_OUTSIDE)
|
||
{
|
||
ptAxisNetCen = curveFirst.StartPoint() + curveFirst.EndPoint()
|
||
+ curveFinal.StartPoint() + curveFinal.EndPoint();
|
||
ptAxisNetCen /= 4.0;
|
||
}
|
||
else
|
||
{
|
||
XLine ln1=curveFirst.GetLine();
|
||
XLine ln2=curveFinal.GetLine();
|
||
ln1.SetLineFlag(LS_INFINITE);
|
||
ln2.SetLineFlag(LS_INFINITE);
|
||
ln1.Intersection(&ln2, ptAxisNetCen);
|
||
}
|
||
int nAnswer=YesNoQuestion(_T("\n是否为按逆时针方向排序编号"));
|
||
if (nAnswer == RTCAN)
|
||
{
|
||
return;
|
||
}
|
||
if (nAnswer == Q_NO)
|
||
{
|
||
XAxisDimSet::g_AntiClockWise=FALSE;
|
||
}
|
||
else
|
||
{
|
||
XAxisDimSet::g_AntiClockWise=TRUE;
|
||
}
|
||
}
|
||
XAxisPickSet ssAxis(SS_FREE);
|
||
if (bRadian && !XAxisDimSet::g_AntiClockWise)
|
||
{
|
||
ssAxis.GetFrom2Curve(curveFinal, curveFirst);
|
||
}
|
||
else
|
||
{
|
||
ssAxis.GetFrom2Curve(curveFirst, curveFinal);
|
||
}
|
||
|
||
if (!ssAxis)
|
||
{
|
||
adsout << _T("\n不能找到轴网!");
|
||
return ;
|
||
}
|
||
|
||
ssAxis.Redraw(3);
|
||
|
||
XPoint ptAxisEnd=curveFirst.NearPoint(ptPick1);
|
||
XCurveSegment cvSortBase; //排序的基线
|
||
|
||
if (!bRadian)
|
||
{
|
||
if (curveFirst.Is(CURVE_CIRCLE))
|
||
{
|
||
Entity entBase;
|
||
if (entBase.FilterSelect(_T("\n请选择圆形轴网的横(径)线:"), RBList(RTDXF0, _T("LINE"), 8, LAY_AXIS, NULL)) != RTNORM)
|
||
{
|
||
ssAxis.Redraw(4);
|
||
|
||
return;
|
||
}
|
||
cvSortBase = XCurveSegment(entBase);
|
||
}
|
||
else
|
||
{
|
||
double nDist2Me=curveFirst.GetDist2Me(curveFinal.StartPoint());
|
||
cvSortBase.StartPoint()=curveFirst.StartPoint();
|
||
ads_polar(curveFirst.StartPoint(), curveFirst.IDirection(0)-PI/2.0, nDist2Me, cvSortBase.EndPoint());
|
||
cvSortBase.SetBulge(0.0);
|
||
//cvSortBase.Make();
|
||
}
|
||
}
|
||
else if (bCirAngular)
|
||
{
|
||
//圆形轴网角度标注
|
||
cvSortBase=XCircle(ptAxisNetCen, ptAxisNetCen.Distance2d(curveFirst.FarPoint(ptAxisNetCen)));
|
||
}
|
||
else
|
||
{
|
||
double nAng1=ads_angle(ptAxisNetCen, curveFirst.FarPoint(ptAxisNetCen));
|
||
double nAng2=ads_angle(ptAxisNetCen, curveFinal.FarPoint(ptAxisNetCen));
|
||
if (XAxisDimSet::g_AntiClockWise == FALSE)
|
||
{
|
||
Exchange(nAng1, nAng2);
|
||
}
|
||
cvSortBase = XArc(ptAxisNetCen, ptAxisNetCen.Distance2d(curveFirst.FarPoint(ptAxisNetCen)),
|
||
nAng1, nAng2);
|
||
}
|
||
|
||
// Add on 2002/6/14, 解决圆形轴网起始轴角度不是最小时无法标注的问题
|
||
double nVal=XAxisDimSet::g_nAngleBegin;
|
||
if (cvSortBase.Is(CURVE_CIRCLE))
|
||
{
|
||
nVal=ads_angle(ptAxisNetCen, curveFirst.FarPoint(ptAxisNetCen));
|
||
}
|
||
XPushMemVar<double> vTemp1(XAxisDimSet::g_nAngleBegin, nVal);
|
||
|
||
DimAxisLabel(curveFirst, cvSortBase, ssAxis, ptPick1, bRadian);
|
||
ssAxis.Redraw(4);
|
||
}
|
||
|
||
void AutoLabelAxisArg(BOOL bRadian)
|
||
{
|
||
XAxisDimSet::g_AntiClockWise=TRUE;
|
||
InitLayer(LAY_DIMAX, TRUE);
|
||
|
||
XAxisDimSet::g_AntiClockWise = 1; //默认逆时针方向
|
||
Entity entFirst;
|
||
XPoint ptPick;
|
||
|
||
const TCHAR *pszDxf=bRadian? _T("LINE") : _T("LINE,ARC,CIRCLE");
|
||
RBList mask(RTDXF0, pszDxf, 8, LAY_AXIS, NULL);
|
||
if (SelectEntity((bRadian?
|
||
_T("\n请选择起始轴线(弧线轴网的径线)<退出>:")
|
||
: _T("\n请选择起始轴线(直线轴网的轴线或弧线轴网的弧线)<退出>"))
|
||
, entFirst, ptPick, mask)!=RTNORM)
|
||
{
|
||
return ;
|
||
}
|
||
ptPick=Ucs2Wcs(ptPick);
|
||
|
||
XCurveSegment curve(entFirst);
|
||
int nFiltFlag=0;
|
||
if (bRadian)
|
||
{
|
||
nFiltFlag |= FILT_RADIATE_LINE;
|
||
}
|
||
else if (curve.Is(CURVE_LINE))
|
||
{
|
||
nFiltFlag |= FILT_LINE_ONLY;
|
||
}
|
||
else
|
||
{
|
||
nFiltFlag |= FILT_CIRARC_ONLY;
|
||
}
|
||
XAxisPickSet ssAxis(entFirst, nFiltFlag);
|
||
if (!ssAxis)
|
||
{
|
||
adsout << _T("\n不能找到轴网!");
|
||
return ;
|
||
}
|
||
|
||
//另外正交方向的一组轴线
|
||
XAxisPickSet &ssOppsite = *ssAxis.GetOppsite();
|
||
if (!ssOppsite)
|
||
{
|
||
adsout << _T("\n不能找到轴网!");
|
||
|
||
return ;
|
||
}
|
||
|
||
XPoint ptAxisEnd=curve.NearPoint(ptPick);
|
||
XCurveSegment cvSortBase; //排序的基线
|
||
XPoint ptAxisNetCen;
|
||
|
||
Entity entSortBase;
|
||
if (!GetClosestAxis(ssOppsite, curve.Is(CURVE_CIRCLE)? ptPick : ptAxisEnd, entSortBase))
|
||
{
|
||
adsout << _T("\n找不到最近的另一侧轴线!");
|
||
|
||
return ;
|
||
}
|
||
|
||
cvSortBase = XCurveSegment(entSortBase);
|
||
if (!cvSortBase)
|
||
{
|
||
adsout << _T("\n不能取得排序轴线!");
|
||
|
||
return ;
|
||
}
|
||
|
||
|
||
if (ssAxis.IsArcAxis() && curve.Is(CURVE_LINE))
|
||
{
|
||
//弧形轴网开间
|
||
if (cvSortBase.Is(CURVE_ARC))
|
||
{
|
||
ptAxisNetCen=cvSortBase.GetArc().GetCenterPt();
|
||
}
|
||
else if (cvSortBase.Is(CURVE_CIRCLE))
|
||
{
|
||
//标注圆形轴网的开间
|
||
ptAxisNetCen=cvSortBase.GetCircle().GetCenterPt();
|
||
XAxisDimSet::g_nAngleBegin=ads_angle(ptAxisNetCen, curve.FarPoint(ptAxisNetCen));
|
||
int nAnswer=YesNoQuestion(_T("\n是否为按逆时针方向排序编号"));
|
||
if (nAnswer == RTCAN)
|
||
{
|
||
return;
|
||
}
|
||
if (nAnswer == Q_NO)
|
||
{
|
||
XAxisDimSet::g_AntiClockWise=FALSE;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!curve.Is(CURVE_CIRCLE))
|
||
{
|
||
// 把cvSortBase偏移到 ptAxisEnd
|
||
int nOffSide=cvSortBase.OnWhichSide(ptAxisEnd);
|
||
XPoint ptPrjToSortBase;
|
||
//不是标注弧形轴网的进深
|
||
if (curve.Is(CURVE_LINE) && cvSortBase.ProjectToMe(ptAxisEnd, ptPrjToSortBase) == RTNORM)
|
||
{
|
||
cvSortBase = cvSortBase.Offset(nOffSide, ptAxisEnd.Distance(ptPrjToSortBase), LS_FINITE);
|
||
}
|
||
}
|
||
|
||
ssAxis.Redraw(3);
|
||
DimAxisLabel(curve, cvSortBase, ssAxis, ptPick, bRadian);
|
||
ssAxis.Redraw(4);
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////
|
||
// 命令：轴网标注(矩形轴网和圆弧轴网的弧线)
|
||
void AutoLabelAxis()
|
||
{
|
||
AutoLabelAxisArg(FALSE);
|
||
}
|
||
|
||
|
||
|
||
/////////////////////////////////////////////
|
||
// 命令：角注轴网(圆弧轴网的径线)
|
||
void AutoLabelAxisAngle()
|
||
{
|
||
AutoLabelAxisArg(TRUE);
|
||
}
|
||
|
||
static XPoint g_ptRef;
|
||
static int CompareDimDist(const Entity *p1, const Entity *p2)
|
||
{
|
||
double nDist1=0.0, nDist2=0.0;
|
||
Entity en1=*p1;
|
||
OPENOBJ_BEGIN(en1, AcDb::kForRead, TDbDimension2, pDim1);
|
||
if (pDim1)
|
||
{
|
||
XCurveSegment cvDim=pDim1->GetDimCurve();
|
||
cvDim.SetLineFlag(LS_INFINITE);
|
||
XPoint ptPrj;
|
||
cvDim.ProjectToMe(g_ptRef, ptPrj);
|
||
nDist1=ptPrj.Distance2d(g_ptRef);
|
||
}
|
||
OPENOBJ_END();
|
||
Entity en2=*p2;
|
||
OPENOBJ_BEGIN(en2, AcDb::kForRead, TDbDimension2, pDim2);
|
||
if (pDim2)
|
||
{
|
||
XCurveSegment cvDim=pDim2->GetDimCurve();
|
||
cvDim.SetLineFlag(LS_INFINITE);
|
||
XPoint ptPrj;
|
||
cvDim.ProjectToMe(g_ptRef, ptPrj);
|
||
nDist2=ptPrj.Distance2d(g_ptRef);
|
||
}
|
||
OPENOBJ_END();
|
||
if (nDist1<nDist2)
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
return 1;
|
||
}
|
||
|
||
//////////////////////////////////
|
||
// bRadian: 0--直线轴号; 1--角度轴号
|
||
void InsAxisArg(BOOL bRadian)
|
||
{
|
||
Entity entRefAxis;
|
||
RBList mask(RTDXF0, _T("LINE,ARC,CIRCLE"), 8, LAY_AXIS, NULL);
|
||
XPoint ptPick;
|
||
if (SelectEntity((bRadian ? _T("\n选择参考轴线(弧线轴网的径线)<退出>:")
|
||
: _T("\n选择参考轴线(直线轴网的轴线或弧线轴网的弧线)<退出>:"))
|
||
, entRefAxis, ptPick, mask) != RTNORM)
|
||
{
|
||
return;
|
||
}
|
||
|
||
ptPick=Ucs2Wcs(ptPick);
|
||
int nAnswer=YesNoQuestion(_T("\n新增轴线是否为附加轴线"), Q_NO);
|
||
if (nAnswer == RTCAN)
|
||
{
|
||
return ;
|
||
}
|
||
|
||
XCurveSegment cv(entRefAxis);
|
||
XCurveSegment curve=cv;
|
||
|
||
int nFiltFlag=0;
|
||
if (bRadian)
|
||
{
|
||
nFiltFlag |= FILT_RADIATE_LINE;
|
||
}
|
||
else if (curve.Is(CURVE_LINE))
|
||
{
|
||
nFiltFlag |= FILT_LINE_ONLY;
|
||
}
|
||
else
|
||
{
|
||
nFiltFlag |= FILT_CIRARC_ONLY;
|
||
}
|
||
|
||
XAxisPickSet ssAxis(entRefAxis, nFiltFlag);
|
||
if (!ssAxis)
|
||
{
|
||
adsout << _T("\n请正确选择!");
|
||
|
||
return;
|
||
}
|
||
VERIFY(curve.ProjectToMe(XPoint(ptPick), ptPick) == RTNORM);
|
||
XPoint ptAxisEnd=curve.NearPoint(ptPick);
|
||
|
||
// 取得标志
|
||
XAxisPickSet &ssOpp = *ssAxis.GetOppsite();
|
||
|
||
// 矩形轴网或没有信息的轴线
|
||
if (!ssAxis.IsArcAxis())
|
||
{
|
||
XPoint ptBase;
|
||
cv.ProjectToMe(ptPick, ptBase);
|
||
XPoint ptSide;
|
||
ads_real nOffset;
|
||
if (ads_getpoint(Wcs2Ucs(ptPick), _T("\n偏移方向<退出>: "), ptSide)!=RTNORM)
|
||
{
|
||
return;
|
||
}
|
||
ptSide=Ucs2Wcs(ptSide);
|
||
ads_initget(RSG_NONEG|RSG_NOZERO, NULL);
|
||
if (ads_getdist(Wcs2Ucs(ptPick), _T("\n距参考轴线的距离<退出>: "), &nOffset)!=RTNORM)
|
||
{
|
||
return;
|
||
}
|
||
int nSide=cv.OnWhichSide(ptSide);
|
||
XCurveSegment cvNew = cv.Offset(nSide, nOffset, LS_FINITE);
|
||
if (!cvNew)
|
||
{
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
cvNew.MakeEntity(entRefAxis);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (cv.Is(CURVE_LINE))
|
||
{
|
||
XPoint ptRotBase; //弧网圆心
|
||
if (!ssOpp) ptRotBase=cv.StartPoint();
|
||
else
|
||
{
|
||
Entity entOneAxis=ssOpp[0L];
|
||
assert(!entOneAxis.Is(_T("LINE")));
|
||
XCircle cirOrArc(entOneAxis);
|
||
ptRotBase = cirOrArc.GetCenterPt();
|
||
}
|
||
if (cv.GetLine().MakeEntity(&entRefAxis) == RTNORM)
|
||
{
|
||
Entity entNew;
|
||
entNew.GetLast();
|
||
XPoint ptPick0;
|
||
cv.ProjectToMe(ptPick, ptPick0);
|
||
if (DragRotation(entNew, _T("\n输入转角<退出>:"), Wcs2Ucs(ptRotBase), Wcs2Ucs(ptPick0))!=RTNORM)
|
||
{
|
||
entNew.Delete();
|
||
return ;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (cv.MakeEntity(entRefAxis) == RTNORM)
|
||
{
|
||
Entity entNew;
|
||
entNew.GetLast();
|
||
if (DragRadius(entNew, _T("\n输入半径<退出>:"), Wcs2Ucs(ptPick))!=RTNORM)
|
||
{
|
||
entNew.Delete();
|
||
return ;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//修改标记
|
||
Entity entNewAxis;
|
||
entNewAxis.GetLast();
|
||
|
||
XCurveSegment segNew(entNewAxis);
|
||
PickSet ssLabelSet(SS_FREE);
|
||
PickSet ssOnStart(SS_FREE);
|
||
double nOffset=GetPickBoxWcs();
|
||
XPoint ptOffset(nOffset, nOffset);
|
||
XPoint pt1=cv.StartPoint()+ptOffset;
|
||
XPoint pt2=cv.StartPoint() - ptOffset;
|
||
if (ssOnStart.Get(_T("C"), pt1, pt2, RBList(RTDXF0, _T("ATS_AXIS_LABEL"), NULL)) == RTNORM)
|
||
{
|
||
if (ssOnStart.Length() == 1)
|
||
{
|
||
Entity entLabelSet=ssOnStart[0L];
|
||
ssLabelSet += entLabelSet;
|
||
}
|
||
}
|
||
|
||
pt1=cv.EndPoint()+ptOffset;
|
||
pt2=cv.EndPoint() - ptOffset;
|
||
if (ssOnStart.Get(_T("C"), pt1, pt2, RBList(RTDXF0, _T("ATS_AXIS_LABEL"), NULL)) == RTNORM)
|
||
{
|
||
if (ssOnStart.Length() == 1)
|
||
{
|
||
Entity entLabelSet=ssOnStart[0L];
|
||
ssLabelSet += entLabelSet;
|
||
}
|
||
}
|
||
|
||
if (!ssLabelSet)
|
||
{
|
||
return;
|
||
}
|
||
PickSet ssDim1(SS_FREE), ssDim2(SS_FREE);
|
||
RBList rbDimMask(RTDXF0, _T("ATS_DIMENSION2"), NULL);
|
||
long num=ssLabelSet.Length();
|
||
double nPrec=GetPickBoxWcs();
|
||
BOOL bGetDim1=FALSE, bGetDim2=FALSE;
|
||
for (long i=0; i<num; i++)
|
||
{
|
||
Entity entLabelSet=ssLabelSet[i];
|
||
AcDbVoidPtrArray entSet;
|
||
XExplodeStream dc(entSet);
|
||
OPENOBJ_BEGIN(entLabelSet, AcDb::kForWrite, TDbAxisLabelSet, pSet);
|
||
pSet->ExplodeOrDraw2d(dc);
|
||
pSet->AddAxis(segNew, nAnswer == Q_YES, NULL);
|
||
OPENOBJ_END();
|
||
int nCount=entSet.length();
|
||
for (int n=0; n<nCount; n++)
|
||
{
|
||
AcDbEntity *pEnt=(AcDbEntity *)entSet[n];
|
||
if (pEnt->isA() == AcDbLine::desc())
|
||
{
|
||
XPoint pt1, pt2;
|
||
AcDbLine *pLine=AcDbLine::cast(pEnt);
|
||
pLine->getStartPoint(pt1);
|
||
pLine->getEndPoint(pt2);
|
||
if (pt1.Distance2d(cv.StartPoint())<nPrec || pt2.Distance2d(cv.StartPoint())<nPrec)
|
||
{
|
||
AssureOnScreen(pt1, pt2);
|
||
bGetDim1=TRUE;
|
||
RBList rbFence=ads_buildlist(RT3DPOINT, &pt1, RT3DPOINT, &pt2, NULL);
|
||
ssDim1.Get(_T("F"), rbFence, NULL, rbDimMask);
|
||
}
|
||
else if (pt1.Distance2d(cv.EndPoint())<nPrec || pt2.Distance2d(cv.EndPoint())<nPrec)
|
||
{
|
||
AssureOnScreen(pt1, pt2);
|
||
bGetDim2=TRUE;
|
||
RBList rbFence=ads_buildlist(RT3DPOINT, &pt1, RT3DPOINT, &pt2, NULL);
|
||
ssDim2.Get(_T("F"), rbFence, NULL, rbDimMask);
|
||
}
|
||
}
|
||
}
|
||
ReleaseEntSet(entSet);
|
||
}
|
||
if (bGetDim1 && !!ssDim1)
|
||
{
|
||
DList<Entity> lstDim1;
|
||
long lDim1=ssDim1.Length();
|
||
for (long idx=0L; idx<lDim1; idx++)
|
||
{
|
||
Entity *pEnt=new Entity;
|
||
*pEnt=ssDim1[idx];
|
||
lstDim1.Append(pEnt);
|
||
}
|
||
g_ptRef=cv.StartPoint();
|
||
lstDim1.QuickSort(CompareDimDist);
|
||
if (lDim1 == 2)
|
||
{
|
||
Entity entDim=*lstDim1[0];
|
||
OPENOBJ_BEGIN(entDim, AcDb::kForWrite, TDbDimension2, pDim1);
|
||
if (pDim1)
|
||
{
|
||
pDim1->AddSegment(segNew.StartPoint());
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
else if (lDim1>2)
|
||
{
|
||
for (int j=0; j<2; j++)
|
||
{
|
||
Entity entDim=*lstDim1[j];
|
||
OPENOBJ_BEGIN(entDim, AcDb::kForWrite, TDbDimension2, pDim1);
|
||
if (pDim1)
|
||
{
|
||
pDim1->AddSegment(segNew.StartPoint());
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
}
|
||
}
|
||
if (bGetDim2 && !!ssDim2)
|
||
{
|
||
DList<Entity> lstDim2;
|
||
long lDim2=ssDim2.Length();
|
||
for (long idx=0L; idx<lDim2; idx++)
|
||
{
|
||
Entity *pEnt=new Entity;
|
||
*pEnt=ssDim2[idx];
|
||
lstDim2.Append(pEnt);
|
||
}
|
||
g_ptRef=cv.EndPoint();
|
||
lstDim2.QuickSort(CompareDimDist);
|
||
if (lDim2 == 2)
|
||
{
|
||
Entity entDim=*lstDim2[0];
|
||
OPENOBJ_BEGIN(entDim, AcDb::kForWrite, TDbDimension2, pDim2);
|
||
if (pDim2)
|
||
{
|
||
pDim2->AddSegment(segNew.EndPoint());
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
else if (lDim2>2)
|
||
{
|
||
for (int j=0; j<2; j++)
|
||
{
|
||
Entity entDim=*lstDim2[j];
|
||
OPENOBJ_BEGIN(entDim, AcDb::kForWrite, TDbDimension2, pDim2);
|
||
if (pDim2)
|
||
{
|
||
pDim2->AddSegment(segNew.EndPoint());
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/////////////////////////////////////////////
|
||
// 命令：添加轴线
|
||
void InsAxis()
|
||
{
|
||
|
||
Entity entRefAxis;
|
||
RBList mask(RTDXF0, _T("LINE,ARC,CIRCLE"), 8, LAY_AXIS, NULL);
|
||
XPoint ptPick;
|
||
if (SelectEntity(_T("\n选择参考轴线 <退出>:") ,entRefAxis, ptPick, mask)!=RTNORM)
|
||
{
|
||
return;
|
||
}
|
||
|
||
int old(0);
|
||
TGGetVar(_T("ORTHOMODE"), &old);
|
||
|
||
do // add by gjm 2014/05/12
|
||
{
|
||
ptPick=Ucs2Wcs(ptPick);
|
||
XCurveSegment cv(entRefAxis);
|
||
XCurveSegment curve=cv;
|
||
|
||
XAxisPickSet *pAxisSS=NULL;
|
||
DList<XAxisPickSet> lstAxisSS;//用于自动delete
|
||
if (curve.Is(CURVE_LINE))
|
||
{
|
||
TGSetVar(_T("ORTHOMODE"), 1);
|
||
pAxisSS=new XAxisPickSet(entRefAxis,FILT_RADIATE_LINE);
|
||
lstAxisSS.Append(pAxisSS);
|
||
if (!(*pAxisSS))
|
||
{
|
||
pAxisSS=new XAxisPickSet(entRefAxis,FILT_LINE_ONLY);
|
||
lstAxisSS.Append(pAxisSS);
|
||
if (!(*pAxisSS))
|
||
{
|
||
adsout << _T("\n请正确选择!");
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else //弧线
|
||
{
|
||
pAxisSS = new XAxisPickSet(entRefAxis,FILT_CIRARC_ONLY);
|
||
lstAxisSS.Append(pAxisSS);
|
||
if (!(*pAxisSS))
|
||
{
|
||
adsout << _T("\n请正确选择!");
|
||
break;
|
||
}
|
||
}
|
||
|
||
XAxisPickSet &ssAxis=*pAxisSS;
|
||
|
||
int nAnswer=YesNoQuestion(_T("\n新增轴线是否为附加轴线"), Q_NO);
|
||
if (nAnswer == RTCAN)
|
||
{
|
||
break;
|
||
}
|
||
|
||
VERIFY(curve.ProjectToMe(XPoint(ptPick), ptPick) == RTNORM);
|
||
XPoint ptAxisEnd=curve.NearPoint(ptPick);
|
||
|
||
// 取得标志
|
||
XAxisPickSet &ssOpp = *ssAxis.GetOppsite();
|
||
|
||
//add by lgy 20120208 是否重排标注
|
||
BOOL bAuto = TRUE;
|
||
if (!ssAxis.IsArcAxis())
|
||
{ // 矩形轴网或没有信息的轴线
|
||
//XPoint ptBase;
|
||
//cv.ProjectToMe(ptPick, ptBase);
|
||
//add by lgy 20120208 是否重排标注根据用户输入
|
||
int nAuto = YesNoQuestion(_T("\n是否重排轴号"), Q_YES);
|
||
if (nAuto == RTCAN)
|
||
{
|
||
break;
|
||
}
|
||
bAuto = (nAuto == Q_YES);
|
||
XPoint ptSide;
|
||
ads_real nOffset;
|
||
//modify by lgy 20120208 新的需求不需要偏移方向而是通过据参考轴线的距离而获得方向
|
||
//if (ads_getpoint(Wcs2Ucs(ptPick), _T("\n偏移方向<退出>: "), ptSide)!=RTNORM)
|
||
//{
|
||
// return;
|
||
//}
|
||
if (ads_getpoint(Wcs2Ucs(ptPick), _T("\n距参考轴线的距离<退出>: "), ptSide)!=RTNORM)
|
||
{
|
||
break;
|
||
}
|
||
ptSide=Ucs2Wcs(ptSide);
|
||
ads_initget(RSG_NONEG|RSG_NOZERO, NULL);
|
||
//modify by lgy 20120208 新的需求不需要偏移方向而是通过据参考轴线的距离而获得方向
|
||
//if (ads_getdist(Wcs2Ucs(ptPick), _T("\n距参考轴线的距离<退出>: "), &nOffset)!=RTNORM)
|
||
//{
|
||
// return;
|
||
//}
|
||
nOffset = cv.GetDist2Me(ptSide);
|
||
nOffset = fabs(nOffset);
|
||
|
||
int nSide=cv.OnWhichSide(ptSide);
|
||
XCurveSegment cvNew = cv.Offset(nSide, nOffset, LS_FINITE);
|
||
if (!cvNew)
|
||
{
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
cvNew.MakeEntity(entRefAxis);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// add by lgy 20120208，是否重排标注根据用户输入
|
||
int nAuto = YesNoQuestion(_T("\n是否重排轴号"), Q_YES);
|
||
if (nAuto == RTCAN)
|
||
{
|
||
break;
|
||
}
|
||
bAuto = (nAuto == Q_YES);
|
||
|
||
if (cv.Is(CURVE_LINE))
|
||
{
|
||
XPoint ptRotBase; //弧网圆心
|
||
if (!ssOpp)
|
||
ptRotBase=cv.StartPoint();
|
||
else
|
||
{
|
||
Entity entOneAxis=ssOpp[0L];
|
||
assert(!entOneAxis.Is(_T("LINE")));
|
||
XCircle cirOrArc(entOneAxis);
|
||
ptRotBase = cirOrArc.GetCenterPt();
|
||
}
|
||
|
||
if (cv.GetLine().MakeEntity(&entRefAxis) == RTNORM)
|
||
{
|
||
Entity entNew;
|
||
entNew.GetLast();
|
||
XPoint ptPick0;
|
||
cv.ProjectToMe(ptPick, ptPick0);
|
||
if (DragRotation(entNew, _T("\n输入转角<退出>:"), Wcs2Ucs(ptRotBase), Wcs2Ucs(ptPick0))!=RTNORM)
|
||
{
|
||
entNew.Delete();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (cv.MakeEntity(entRefAxis) == RTNORM)
|
||
{
|
||
Entity entNew;
|
||
entNew.GetLast();
|
||
if (DragRadius(entNew, _T("\n输入半径<退出>:"), Wcs2Ucs(ptPick))!=RTNORM)
|
||
{
|
||
entNew.Delete();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 修改标记
|
||
Entity entNewAxis;
|
||
entNewAxis.GetLast();
|
||
|
||
XCurveSegment segNew(entNewAxis);
|
||
PickSet ssLabelSet(SS_FREE);
|
||
PickSet ssOnStart(SS_FREE);
|
||
double nOffset=GetPickBoxWcs();
|
||
XPoint ptOffset(nOffset, nOffset);
|
||
XPoint pt1=cv.StartPoint()+ptOffset;
|
||
XPoint pt2=cv.StartPoint() - ptOffset;
|
||
if (ssOnStart.Get(_T("C"), pt1, pt2, RBList(RTDXF0, _T("ATS_AXIS_LABEL"), NULL)) == RTNORM)
|
||
{
|
||
if (ssOnStart.Length() == 1)
|
||
{
|
||
Entity entLabelSet=ssOnStart[0L];
|
||
ssLabelSet += entLabelSet;
|
||
}
|
||
}
|
||
|
||
pt1=cv.EndPoint()+ptOffset;
|
||
pt2=cv.EndPoint() - ptOffset;
|
||
if (ssOnStart.Get(_T("C"), pt1, pt2, RBList(RTDXF0, _T("ATS_AXIS_LABEL"), NULL)) == RTNORM)
|
||
{
|
||
if (ssOnStart.Length() == 1)
|
||
{
|
||
Entity entLabelSet=ssOnStart[0L];
|
||
ssLabelSet += entLabelSet;
|
||
}
|
||
}
|
||
|
||
if (!ssLabelSet)
|
||
{
|
||
break;
|
||
}
|
||
PickSet ssDim1(SS_FREE), ssDim2(SS_FREE);
|
||
RBList rbDimMask(RTDXF0, _T("ATS_DIMENSION2"), NULL);
|
||
long num=ssLabelSet.Length();
|
||
double nPrec=GetPickBoxWcs();
|
||
BOOL bGetDim1=FALSE, bGetDim2=FALSE;
|
||
for (long i=0; i<num; i++)
|
||
{
|
||
Entity entLabelSet=ssLabelSet[i];
|
||
AcDbVoidPtrArray entSet;
|
||
XExplodeStream dc(entSet);
|
||
OPENOBJ_BEGIN(entLabelSet, AcDb::kForWrite, TDbAxisLabelSet, pSet);
|
||
pSet->ExplodeOrDraw2d(dc);
|
||
//modify by lgy 20120208 添加轴线时是否标注重排根据参数
|
||
//pSet->AddAxis(segNew, nAnswer == Q_YES, NULL);
|
||
pSet->AddAxis(segNew, nAnswer == Q_YES, NULL, bAuto);
|
||
OPENOBJ_END();
|
||
int nCount=entSet.length();
|
||
for (int n=0; n<nCount; n++)
|
||
{
|
||
AcDbEntity *pEnt=(AcDbEntity *)entSet[n];
|
||
if (pEnt->isA() == AcDbLine::desc())
|
||
{
|
||
XPoint pt1, pt2;
|
||
AcDbLine *pLine=AcDbLine::cast(pEnt);
|
||
pLine->getStartPoint(pt1);
|
||
pLine->getEndPoint(pt2);
|
||
if (pt1.Distance2d(cv.StartPoint())<nPrec || pt2.Distance2d(cv.StartPoint())<nPrec)
|
||
{
|
||
AssureOnScreen(pt1, pt2);
|
||
bGetDim1=TRUE;
|
||
RBList rbFence=ads_buildlist(RT3DPOINT, &pt1, RT3DPOINT, &pt2, NULL);
|
||
ssDim1.Get(_T("F"), rbFence, NULL, rbDimMask);
|
||
}
|
||
else if (pt1.Distance2d(cv.EndPoint())<nPrec || pt2.Distance2d(cv.EndPoint())<nPrec)
|
||
{
|
||
AssureOnScreen(pt1, pt2);
|
||
bGetDim2=TRUE;
|
||
RBList rbFence=ads_buildlist(RT3DPOINT, &pt1, RT3DPOINT, &pt2, NULL);
|
||
ssDim2.Get(_T("F"), rbFence, NULL, rbDimMask);
|
||
}
|
||
}
|
||
}
|
||
ReleaseEntSet(entSet);
|
||
}
|
||
if (bGetDim1 && !!ssDim1)
|
||
{
|
||
DList<Entity> lstDim1;
|
||
long lDim1=ssDim1.Length();
|
||
for (long idx=0L; idx<lDim1; idx++)
|
||
{
|
||
Entity *pEnt=new Entity;
|
||
*pEnt=ssDim1[idx];
|
||
lstDim1.Append(pEnt);
|
||
}
|
||
g_ptRef=cv.StartPoint();
|
||
lstDim1.QuickSort(CompareDimDist);
|
||
if (lDim1 == 2)
|
||
{
|
||
Entity entDim=*lstDim1[0];
|
||
OPENOBJ_BEGIN(entDim, AcDb::kForWrite, TDbDimension2, pDim1);
|
||
if (pDim1)
|
||
{
|
||
pDim1->AddSegment(segNew.StartPoint());
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
else if (lDim1>2)
|
||
{
|
||
for (int j=0; j<2; j++)
|
||
{
|
||
Entity entDim=*lstDim1[j];
|
||
OPENOBJ_BEGIN(entDim, AcDb::kForWrite, TDbDimension2, pDim1);
|
||
if (pDim1)
|
||
{
|
||
pDim1->AddSegment(segNew.StartPoint());
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
}
|
||
}
|
||
if (bGetDim2 && !!ssDim2)
|
||
{
|
||
DList<Entity> lstDim2;
|
||
long lDim2=ssDim2.Length();
|
||
for (long idx=0L; idx<lDim2; idx++)
|
||
{
|
||
Entity *pEnt=new Entity;
|
||
*pEnt=ssDim2[idx];
|
||
lstDim2.Append(pEnt);
|
||
}
|
||
g_ptRef=cv.EndPoint();
|
||
lstDim2.QuickSort(CompareDimDist);
|
||
if (lDim2 == 2)
|
||
{
|
||
Entity entDim=*lstDim2[0];
|
||
OPENOBJ_BEGIN(entDim, AcDb::kForWrite, TDbDimension2, pDim2);
|
||
if (pDim2)
|
||
{
|
||
pDim2->AddSegment(segNew.EndPoint());
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
else if (lDim2>2)
|
||
{
|
||
for (int j=0; j<2; j++)
|
||
{
|
||
Entity entDim=*lstDim2[j];
|
||
OPENOBJ_BEGIN(entDim, AcDb::kForWrite, TDbDimension2, pDim2);
|
||
if (pDim2)
|
||
{
|
||
pDim2->AddSegment(segNew.EndPoint());
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
}
|
||
}
|
||
|
||
} while (false);
|
||
|
||
TGSetVar(_T("ORTHOMODE"), old);
|
||
}
|
||
|
||
void ExtendToBound(XLine *pLine,DList<XLine> &BoundLine)
|
||
{
|
||
pLine->SetLineFlag(LS_INFINITE);//把线的长度改为无限
|
||
ads_point pt;
|
||
XPoint startPt,endPt;
|
||
int interNum=0;
|
||
for (int i=0;i<4;i++)
|
||
{
|
||
XLine bLine=*BoundLine[i];
|
||
if (pLine->Intersection (&bLine,pt))//如果有交点
|
||
{
|
||
if (interNum == 0)
|
||
{
|
||
startPt=pt;
|
||
interNum=1;
|
||
}
|
||
else
|
||
{
|
||
endPt=pt;
|
||
interNum=2;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (interNum == 2)//如果有两个交点
|
||
{
|
||
pLine->StartPoint() =startPt;
|
||
pLine->EndPoint() =endPt;
|
||
}
|
||
else
|
||
{
|
||
ads_printf(_T("\n计算有误!"));
|
||
}
|
||
pLine->SetLineFlag(LS_FINITE);//变回有限长度;
|
||
}
|
||
//画轴网
|
||
void DrawAxisNet(DList<XLine> &lstLine,DList<XArc> &lstArc,DList<XCircle> &lstCircle)
|
||
{
|
||
int len,i,len1,j;
|
||
XLine *pLine=NULL;
|
||
XWcsStream dc;
|
||
dc.sLayer=LAY_AXIS;
|
||
ads_real angle;
|
||
//开始画矩形轴网
|
||
len=lstLine.Length();
|
||
for (i=0;i<len;i++)
|
||
{
|
||
pLine=lstLine[i];
|
||
angle=pLine->Direction ();
|
||
if (fabs(angle)<0.0001 || fabs(angle-PI)<0.0001 || fabs(angle-2*PI)<0.0001)//如果大致在水平方向,属于进深
|
||
{
|
||
dc<<*pLine;
|
||
}
|
||
}
|
||
for (i=0;i<len;i++)
|
||
{
|
||
pLine=lstLine[i];
|
||
angle=pLine->Direction ();
|
||
if (fabs(angle-PI/2)<0.0001 || fabs(angle-3*PI/2)<0.0001)//如果大致在垂直方向,属于开间
|
||
{
|
||
dc<<*pLine;
|
||
}
|
||
}
|
||
|
||
for (i=0;i<len;i++)
|
||
{
|
||
pLine=lstLine[i];
|
||
angle=pLine->Direction ();
|
||
if (fabs(angle)>=0.0001 && fabs(angle-PI/2)>=0.0001 && fabs(angle-PI)>=0.0001
|
||
&& fabs(angle-PI*3/2)>=0.0001 && fabs(angle-PI*2)>=0.0001)
|
||
{
|
||
dc<<*pLine;
|
||
}
|
||
}
|
||
|
||
//画弧形轴网:必须考虑不同圆心有不同标注
|
||
len=lstArc.Length();
|
||
DList<XPoint> bakofcenter;
|
||
for (i = 0; i < len; i++)//以下的处理是对于同一个圆心的圆弧轴网要求包含的弧度一致(整齐化)
|
||
{
|
||
XArc *pArc=NULL,*pArc1=NULL;
|
||
XPoint center,center1;
|
||
pArc=lstArc[i];
|
||
pArc->Center(center);
|
||
if (i == 0)//第一个:直接加入到使用过的圆心链表
|
||
{
|
||
bakofcenter.Append(new XPoint(center));
|
||
}
|
||
else//其余:检查是否已经使用过
|
||
{
|
||
BOOL isUsedCenter=FALSE;
|
||
len1=bakofcenter.Length();
|
||
for (j=0;j<len1;j++)
|
||
{
|
||
XPoint bak=*bakofcenter[j];
|
||
if (bak == center)
|
||
{
|
||
isUsedCenter=TRUE;
|
||
break;
|
||
}
|
||
}
|
||
if (isUsedCenter)//如果已经使用过,看下一个;
|
||
{
|
||
continue;
|
||
}
|
||
else//否则把这个没有用过的圆心加入到链表中
|
||
{
|
||
bakofcenter.Append(new XPoint(center));
|
||
}
|
||
}
|
||
dc<<*pArc;
|
||
for (j=i+1;j<len;j++)//此循环得到最大范围的起始终止角度
|
||
{
|
||
pArc1=lstArc[j];
|
||
pArc1->Center(center1);
|
||
if (center == center1)
|
||
{
|
||
dc<<*pArc1;
|
||
}
|
||
}
|
||
}
|
||
//画圆轴网:也必须考虑不同圆心有不同标注
|
||
bakofcenter.Reset();
|
||
len=lstCircle.Length();
|
||
for (i=0;i<len;i++)//以下的处理是对于同一个圆心的圆弧轴网要求包含的弧度一致(整齐化)
|
||
{
|
||
XCircle *pCircle=NULL,*pCircle1=NULL;
|
||
XPoint center,center1;
|
||
pCircle=lstCircle[i];
|
||
pCircle->Center(center);
|
||
if (i == 0)//第一个:直接加入到使用过的圆心链表
|
||
{
|
||
bakofcenter.Append(new XPoint(center));
|
||
}
|
||
else//其余:检查是否已经使用过
|
||
{
|
||
BOOL isUsedCenter=FALSE;
|
||
len1=bakofcenter.Length();
|
||
for (j=0;j<len1;j++)
|
||
{
|
||
XPoint bak=*bakofcenter[j];
|
||
if (bak == center)
|
||
{
|
||
isUsedCenter=TRUE;
|
||
break;
|
||
}
|
||
}
|
||
if (isUsedCenter)//如果已经使用过,看下一个;
|
||
{
|
||
continue;
|
||
}
|
||
else//否则把这个没有用过的圆心加入到链表中
|
||
{
|
||
bakofcenter.Append(new XPoint(center));
|
||
}
|
||
}
|
||
|
||
dc<<*pCircle;
|
||
for (j=i+1;j<len;j++)
|
||
{
|
||
pCircle1=lstCircle[i];
|
||
dc<<*pCircle1;
|
||
}
|
||
}
|
||
}
|
||
|
||
//考虑弧线墙以及圆墙?以成员bulge为准,如果它为2PI那么是圆,起点终点是直径的端点
|
||
//如果是0,就是直线?如果为一个正数,是一段弧,该弧如何计算?
|
||
//如果存在一个微小的角度该如何处理?弧段不能拉通到边界上又该如何?
|
||
void GenerateAxisNet(PickSet &Set,DList<XLine> &BoundLine,ads_real precision,ads_real anglespace)
|
||
{
|
||
long len,i,len1,j;
|
||
Entity ent;
|
||
XPoint Startpt,Endpt,pt;
|
||
ads_real angle,angle1;
|
||
DList<XLine> lstLine;
|
||
DList<XArc> lstArc;
|
||
DList<XCircle> lstCircle;
|
||
|
||
len=Set.Length ();
|
||
for (i=0;i<len;i++)
|
||
{
|
||
ent=Set[i];
|
||
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbWall, pWall);
|
||
if (!pWall || !pWall->IsValid())
|
||
{
|
||
continue;
|
||
}
|
||
|
||
//bulge=pWall->bulge ;
|
||
if (pWall->Is(CURVE_LINE))
|
||
{
|
||
//直线
|
||
XLine ln=pWall->GetLine();
|
||
ln.SetElevation (0.0);
|
||
ExtendToBound(&ln,BoundLine);
|
||
len1=lstLine.Length();
|
||
angle=ln.Direction();
|
||
BOOL canAdd=TRUE;
|
||
for (j=0;j<len1;j++)
|
||
{
|
||
XLine *pLine1=lstLine[j];
|
||
angle1=pLine1->Direction ();
|
||
if (ln.Intersection (pLine1,pt) == 0)//如果没有交点,平行;考虑精度和拉通
|
||
{
|
||
//只比较两对距离因为延长到边界函数中已经调整了起始终止点.
|
||
if ( ads_distance(ln.StartPoint() ,pLine1->StartPoint() )<precision &&
|
||
ads_distance(ln.EndPoint() ,pLine1->EndPoint() )<precision)
|
||
{
|
||
canAdd=FALSE;//有可能平行,也有可能不平行也不相交所以判断两个端点的距离
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (canAdd) //如果不重合,加入到链表;
|
||
{
|
||
lstLine.Append(new XLine(ln));
|
||
}
|
||
}
|
||
else //如果是圆弧:仅仅拉通它.不再要求到达边界
|
||
{
|
||
XArc ar=pWall->GetArc ();
|
||
TADSGePoint3d ptTemp = ar.GetCenterPt();
|
||
ptTemp.z = 0.0;
|
||
ar.SetCenterPt(ptTemp);
|
||
XPoint center,center1;
|
||
len1=lstArc.Length();
|
||
ar.Center(center);
|
||
BOOL canAdd=TRUE;
|
||
for (j=0;j<len1;j++)
|
||
{
|
||
XArc *pArc1=lstArc[j];
|
||
pArc1->Center(center1);
|
||
if (center == center1)
|
||
{// 如果是同一个圆心
|
||
if (fabs(ar.GetRadius()-pArc1->GetRadius())<precision/2)//如果半径相差在精度的一半以内,认为两段弧需要合并
|
||
{
|
||
if (ar.GetStarAngle() <pArc1->GetStarAngle() )//把起始和终止角度进行合并
|
||
{
|
||
pArc1->SetStarAngle(ar.GetStarAngle());
|
||
}
|
||
if (ar.GetEndAngle() >pArc1->GetEndAngle() )
|
||
{
|
||
pArc1->SetEndAngle(ar.GetEndAngle());
|
||
}
|
||
canAdd=FALSE;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (canAdd) //如果不重合,加入到链表;
|
||
{
|
||
lstArc.Append(new XArc(ar));
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
len=lstArc.Length();
|
||
DList<XPoint> bakofcenter;
|
||
for (i=0;i<len;i++) //以下的处理是对于同一个圆心的圆弧轴网要求包含的弧度一致(整齐化)
|
||
{
|
||
XArc *pArc=NULL,*pArc1=NULL;
|
||
XPoint center,center1;
|
||
ads_real minStartAngle,maxEndAngle;
|
||
pArc=lstArc[i];
|
||
pArc->Center(center);
|
||
if (i == 0) //第一个:直接加入到使用过的圆心链表
|
||
{
|
||
bakofcenter.Append(new XPoint(center));
|
||
}
|
||
else //其余:检查是否已经使用过
|
||
{
|
||
BOOL isUsedCenter=FALSE;
|
||
len1=bakofcenter.Length();
|
||
for (j=0;j<len1;j++)
|
||
{
|
||
XPoint bak=*bakofcenter[j];
|
||
if (bak == center)
|
||
{
|
||
isUsedCenter=TRUE;
|
||
break;
|
||
}
|
||
}
|
||
if (isUsedCenter)//如果已经使用过,看下一个;
|
||
{
|
||
continue;
|
||
}
|
||
else//否则把这个没有用过的圆心加入到链表中
|
||
{
|
||
bakofcenter.Append(new XPoint(center));
|
||
}
|
||
}
|
||
minStartAngle=pArc->GetStarAngle();
|
||
maxEndAngle=pArc->GetEndAngle();
|
||
if (minStartAngle>maxEndAngle)//如果起始角大于终止角,看是否是要建立起始角大于终止角的弧形轴网
|
||
{
|
||
if (MessageBox(NULL,_T("\n发现起始角大于终止角的弧段.要建立起始角大于终止角的弧形轴网吗?"),_T("请您确定"),MB_YESNO) == IDYES)
|
||
{
|
||
for (j=i+1;j<len;j++)//此循环得到最大范围的起始终止角度
|
||
{
|
||
pArc1=lstArc[j];
|
||
pArc1->Center(center1);
|
||
if (center == center1)
|
||
{
|
||
if (minStartAngle>pArc1->GetStarAngle())
|
||
{
|
||
minStartAngle=pArc1->GetStarAngle();
|
||
}
|
||
if (maxEndAngle<pArc1->GetEndAngle())
|
||
{
|
||
maxEndAngle=pArc1->GetEndAngle();
|
||
}
|
||
}
|
||
}
|
||
minStartAngle-=anglespace;//减少/增加规定的弧度.都可调
|
||
maxEndAngle+=anglespace;//
|
||
for (j=i;j<len;j++)//此循环把最大范围的起始终止角度赋给各个同圆心的弧墙
|
||
{
|
||
pArc1=lstArc[j];
|
||
pArc1->Center(center1);
|
||
if (center == center1)
|
||
{
|
||
if (pArc1->GetStarAngle()<pArc1->GetEndAngle())
|
||
{
|
||
ads_printf(_T("\n存在起始角(约为%d度)小于终止角(约%d度)的弧段,系统不能对其拉通和齐整,忽略之..."),(int)(pArc1->GetStarAngle()*180/PI),(int)(pArc1->GetEndAngle()*180/PI));
|
||
pArc1->SetStarAngle(pArc1->GetStarAngle() - anglespace);
|
||
pArc1->SetEndAngle(pArc1->GetEndAngle() + anglespace);
|
||
}
|
||
else
|
||
{
|
||
pArc1->SetStarAngle(minStartAngle);
|
||
pArc1->SetEndAngle(maxEndAngle);
|
||
}
|
||
}
|
||
}
|
||
continue;
|
||
}
|
||
}
|
||
//建立起始角小于终止角的弧形轴网
|
||
for (j=i+1;j<len;j++)//此循环得到最大范围的起始终止角度
|
||
{
|
||
pArc1=lstArc[j];
|
||
pArc1->Center(center1);
|
||
if (center == center1)
|
||
{
|
||
if (minStartAngle>pArc1->GetStarAngle())
|
||
{
|
||
minStartAngle=pArc1->GetStarAngle();
|
||
}
|
||
if (maxEndAngle<pArc1->GetEndAngle())
|
||
{
|
||
maxEndAngle=pArc1->GetEndAngle();
|
||
}
|
||
}
|
||
}
|
||
minStartAngle-=anglespace;//减少/增加规定的弧度.都可调
|
||
maxEndAngle+=anglespace;//
|
||
for (j=i;j<len;j++)//此循环把最大范围的起始终止角度赋给各个同圆心的弧墙
|
||
{
|
||
pArc1=lstArc[j];
|
||
pArc1->Center(center1);
|
||
if (center == center1)
|
||
{
|
||
if (pArc1->GetStarAngle()>pArc1->GetEndAngle())
|
||
{
|
||
ads_printf(_T("\n存在起始角(约为%d度)大于终止角(约%d度)的弧段,系统不能对其拉通和齐整,忽略之..."),(int)(pArc1->GetStarAngle()*180/PI),(int)(pArc1->GetEndAngle()*180/PI));
|
||
pArc1->SetStarAngle(pArc1->GetStarAngle() - anglespace);
|
||
pArc1->SetEndAngle(pArc1->GetEndAngle() + anglespace);
|
||
}
|
||
else
|
||
{
|
||
pArc1->SetStarAngle(minStartAngle);
|
||
pArc1->SetEndAngle(maxEndAngle);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
DrawAxisNet(lstLine,lstArc,lstCircle);
|
||
}
|
||
|
||
extern TARCH_IMPEXP double g_dBaseDist;
|
||
|
||
void GetConfig(ads_real &space,ads_real &precision,ads_real &anglespace)
|
||
{
|
||
//modified by whl on 070202
|
||
//space=2000;
|
||
space=g_dBaseDist;
|
||
|
||
precision=100;
|
||
anglespace=0.1;
|
||
}
|
||
|
||
|
||
|
||
/////////////////////////////////////////////
|
||
// 命令：墙生轴网
|
||
void Wall2Axis()
|
||
{
|
||
InitLayer(LAY_AXIS, TRUE);
|
||
PickSet Set(SS_FREE), Set1(SS_FREE);
|
||
ads_real x,y,space=0,precision=0,anglespace=0;
|
||
XPoint cen,pt1,pt2,pt3,pt4;
|
||
DList<XLine> BoundLine;//边界线的集合
|
||
|
||
if (SelectEntities(_T("\n请选取要从中生成轴网的墙体:"), Set,
|
||
RBList(RTDXF0, _T("ATS_WALL,ATS_CURTAIN_WALL"), NULL))!=RTNORM)
|
||
{
|
||
return;
|
||
}
|
||
//if (FilterWall(Set)==FALSE) return RTERROR;
|
||
GetConfig(space,precision,anglespace);
|
||
Set.GetExtend(cen,&x,&y);
|
||
x=x/2+space;//加上一个边距
|
||
y=y/2+space;//加上一个边距
|
||
pt1[X]=cen[X]+x;
|
||
pt1[Y]=cen[Y]+y;
|
||
pt2[X]=cen[X]+x;
|
||
pt2[Y]=cen[Y]-y;
|
||
BoundLine.Append (new XLine(pt1,pt2,LS_FINITE));//有限的线长度以及边界
|
||
pt3[X]=cen[X]-x;
|
||
pt3[Y]=cen[Y]-y;
|
||
BoundLine.Append (new XLine(pt2,pt3,LS_FINITE));
|
||
pt4[X]=cen[X]-x;
|
||
pt4[Y]=cen[Y]+y;
|
||
BoundLine.Append (new XLine(pt3,pt4,LS_FINITE));
|
||
BoundLine.Append (new XLine(pt4,pt1,LS_FINITE));
|
||
GenerateAxisNet(Set,BoundLine,precision,anglespace);
|
||
}
|
||
|
||
int EditAxisNet(AcDbObjectId id)
|
||
{
|
||
OPENOBJ_BEGIN(id, AcDb::kForRead, TDbAxisLabelSet, pNet);
|
||
if (!pNet)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
|
||
if (pNet->upgradeOpen()!=Acad::eOk)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
pNet->SetShowHide(TRUE);
|
||
pNet->downgradeOpen();
|
||
|
||
while (1)
|
||
{
|
||
const TCHAR *szPrompt1=_T("\n选择 [变标注侧(M)/单轴变标注侧(S)/添补轴号(A)/删除轴号(D)/单轴变号(N)/重排轴号(R)/轴圈半径(Z)]<退出>:");
|
||
XString sKeyword;
|
||
int nRet=0;
|
||
INITGET_BEG(0, _T("S M A D R N Z"));
|
||
nRet=ads_getkword(szPrompt1, sKeyword);
|
||
INITGET_END();
|
||
|
||
if (nRet!=RTNORM)
|
||
{
|
||
break;
|
||
}
|
||
if (sKeyword[0] == _T('M'))
|
||
{
|
||
if (pNet->upgradeOpen()!=Acad::eOk)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
pNet->assertWriteEnabled();
|
||
int nVisSides=pNet->GetVisSides();
|
||
nVisSides ++;
|
||
if (nVisSides>3)
|
||
{
|
||
nVisSides=1;
|
||
}
|
||
pNet->SetVisSides(nVisSides);
|
||
pNet->downgradeOpen();
|
||
}
|
||
else if (sKeyword[0] == _T('S'))
|
||
{
|
||
XPoint ptPick;
|
||
while (ads_getpoint(NULL, _T("\n在需要改变标注侧的轴号附近取一点:"), ptPick) == RTNORM)
|
||
{
|
||
ptPick=Ucs2Wcs(ptPick);
|
||
//int nIdx=pNet->HitTestOnLabel(ptPick);modified by whl on 041117
|
||
int nIdx=pNet->HitTestOnLabel0(ptPick);//不忽略隐藏轴号
|
||
if (nIdx>=0)
|
||
{
|
||
int nVisSides=pNet->GetAxisVisSides(nIdx);
|
||
if (pNet->upgradeOpen()!=Acad::eOk)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
pNet->assertWriteEnabled();
|
||
nVisSides ++;
|
||
if (nVisSides>3)
|
||
{
|
||
nVisSides=0;
|
||
}
|
||
pNet->SetAxisVisSides(nIdx, nVisSides);
|
||
pNet->downgradeOpen();
|
||
}
|
||
}
|
||
}
|
||
else if (sKeyword[0] == _T('D'))
|
||
{
|
||
XPoint ptPick;
|
||
if (XGetPoint(NULL, _T("\n在需要删除的轴号附近取一点"), ptPick) == RTNORM)
|
||
{
|
||
ptPick=Ucs2Wcs(ptPick);
|
||
int nAns=YesNoQuestion(_T("\n是否重排轴号"));
|
||
if (nAns!=RTCAN)
|
||
{
|
||
if (pNet->upgradeOpen()!=Acad::eOk)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
int idx=pNet->HitTestOnAxis(ptPick);
|
||
if (idx>=0)
|
||
{
|
||
pNet->RemoveLabel(idx, nAns==Q_YES);
|
||
}
|
||
pNet->downgradeOpen();
|
||
}
|
||
}
|
||
}
|
||
else if (sKeyword[0] == _T('A'))
|
||
{
|
||
XPoint ptAdd;
|
||
if (XGetPoint(NULL, _T("\n请点取新轴号的位置"), ptAdd) == RTNORM)
|
||
{
|
||
ptAdd = Ucs2Wcs(ptAdd);
|
||
TCHAR szLab[64]=_T("");
|
||
const TCHAR *pszLab=NULL;
|
||
if (!pNet->IsSortAuto())
|
||
{
|
||
if (ads_getstring(0, _T("\n新增轴号<空号>:"), szLab) == RTCAN)
|
||
{
|
||
continue;
|
||
}
|
||
pszLab=szLab;
|
||
}
|
||
|
||
int nAns=YesNoQuestion(_T("\n新增轴号是否双侧标注"));
|
||
if (nAns == RTCAN)
|
||
{
|
||
continue;
|
||
}
|
||
int nAxisFlag=0;
|
||
if (nAns == Q_NO)
|
||
{
|
||
nAxisFlag = (pNet->OnWhichSide(ptAdd) == 0)? AXF_NOSIDE2 : AXF_NOSIDE1;
|
||
}
|
||
|
||
if (!pszLab)
|
||
{
|
||
int nAns1=YesNoQuestion(_T("\n新增轴号是否为附加轴号"), Q_NO);
|
||
if (nAns1 == RTCAN)
|
||
{
|
||
continue;
|
||
}
|
||
if (nAns1 == Q_YES)
|
||
{
|
||
nAxisFlag |= AXF_ATTACH;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (_tcschr(pszLab, _T('/')))
|
||
{
|
||
nAxisFlag |= AXF_ATTACH;
|
||
}
|
||
}
|
||
if (pNet->upgradeOpen() == Acad::eOk)
|
||
{
|
||
pNet->AddLabel(ptAdd, nAxisFlag, pszLab);
|
||
pNet->downgradeOpen();
|
||
}
|
||
}
|
||
}
|
||
else if (sKeyword[0] == _T('N') || sKeyword[0] == _T('R'))
|
||
{
|
||
XPoint ptPick;
|
||
if (ads_getpoint(NULL, _T("\n请在要更改的轴号附近取一点:"), ptPick) == RTNORM)
|
||
{
|
||
ptPick=Ucs2Wcs(ptPick);
|
||
int nIdx=pNet->HitTestOnLabel(ptPick);
|
||
if (nIdx>=0)
|
||
{
|
||
const TCHAR *pszOld=pNet->GetLabel(nIdx);
|
||
TCHAR szOld[80]=_T("");
|
||
_tcscpy(szOld, pszOld);
|
||
adsout << _T("\n请输入新的轴号(.空号)<") << szOld << _T(">: ");
|
||
if (ads_getstring(0, _T(""), szOld) == RTNORM)
|
||
{
|
||
if (_tcscmp(szOld, _T(".")) == 0)
|
||
{
|
||
_tcscpy(szOld, _T(""));
|
||
}
|
||
else if (!szOld[0])
|
||
{
|
||
_tcscpy(szOld, pszOld);
|
||
}
|
||
if (pNet->upgradeOpen() == Acad::eOk)
|
||
{
|
||
pNet->SetLabel(nIdx, szOld, sKeyword[0]==_T('R'));
|
||
pNet->downgradeOpen();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else if (sKeyword[0] == _T('Z'))
|
||
{
|
||
double nRad=pNet->GetCirRadius();
|
||
if (GetReal(_T("\n轴圈在纸面上的半径"), nRad, RSG_NONEG|RSG_NOZERO) == RTNORM)
|
||
{
|
||
if (pNet->upgradeOpen() == Acad::eOk)
|
||
{
|
||
pNet->SetCirRadius(nRad);
|
||
pNet->downgradeOpen();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (pNet->upgradeOpen()!=Acad::eOk)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
pNet->SetShowHide(FALSE);
|
||
|
||
OPENOBJ_END();
|
||
return RTNORM;
|
||
}
|
||
|
||
|
||
|
||
/////////////////////////////////////////////
|
||
// 命令：添补轴号
|
||
void AddAxisLabel()
|
||
{
|
||
// sg add 100521，进入命令后，临时显示全部隐藏轴号
|
||
SetShowHiddenAxisLable(true);
|
||
|
||
Entity ent;
|
||
XPoint ptPick;
|
||
RBList mask(RTDXF0, _T("ATS_AXIS_LABEL"), NULL);
|
||
if (SelectEntity(_T("\n请选择轴号对象<退出>: "), ent, ptPick, mask) != RTNORM)
|
||
{
|
||
// sg add 100521，退出命令时，恢复隐藏
|
||
SetShowHiddenAxisLable(false);
|
||
return;
|
||
}
|
||
ptPick = Ucs2Wcs(ptPick);
|
||
|
||
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbAxisLabelSet, pSet);
|
||
if (!pSet)
|
||
{
|
||
// sg add 100521，退出命令时，恢复隐藏
|
||
SetShowHiddenAxisLable(false);
|
||
return;
|
||
}
|
||
|
||
int idx = pSet->HitTestOnAxis(ptPick);
|
||
if (idx < 0)
|
||
{
|
||
// sg add 100521，退出命令时，恢复隐藏
|
||
pSet->close();
|
||
SetShowHiddenAxisLable(false);
|
||
return;
|
||
}
|
||
|
||
XCurveSegment segRef = pSet->GetAxis(idx);
|
||
XPoint ptNear = segRef.NearPoint(ptPick);
|
||
XPoint ptAdd;
|
||
if (XGetPoint(Wcs2Ucs(ptNear), _T("\n请点取新轴号的位置"), ptAdd)!=RTNORM)
|
||
{
|
||
// sg add 100521，退出命令时，恢复隐藏
|
||
pSet->close();
|
||
SetShowHiddenAxisLable(false);
|
||
return;
|
||
}
|
||
ptAdd = Ucs2Wcs(ptAdd);
|
||
|
||
TCHAR szLab[64] = _T("");
|
||
const TCHAR *pszLab = NULL;
|
||
if (!pSet->IsSortAuto())
|
||
{
|
||
if (ads_getstring(0, _T("\n新增轴号<空号>:"), szLab) == RTCAN)
|
||
{
|
||
// sg add 100521，退出命令时，恢复隐藏
|
||
pSet->close();
|
||
SetShowHiddenAxisLable(false);
|
||
return;
|
||
}
|
||
pszLab = szLab;
|
||
}
|
||
|
||
int nAns = YesNoQuestion(_T("\n新增轴号是否双侧标注"));
|
||
if (nAns == RTCAN)
|
||
{
|
||
// sg add 100521，退出命令时，恢复隐藏
|
||
pSet->close();
|
||
SetShowHiddenAxisLable(false);
|
||
return;
|
||
}
|
||
|
||
int nAxisFlag = 0;
|
||
if (nAns == Q_NO)
|
||
{
|
||
nAxisFlag = (pSet->OnWhichSide(ptAdd) == 0) ? AXF_NOSIDE2 : AXF_NOSIDE1;
|
||
}
|
||
|
||
if (!pszLab)
|
||
{
|
||
int nAns1 = YesNoQuestion(_T("\n新增轴号是否为附加轴号"), Q_NO);
|
||
if (nAns1 == RTCAN)
|
||
{
|
||
// sg add 100521，退出命令时，恢复隐藏
|
||
pSet->close();
|
||
SetShowHiddenAxisLable(false);
|
||
return;
|
||
}
|
||
|
||
if (nAns1 == Q_YES)
|
||
{
|
||
nAxisFlag |= AXF_ATTACH;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (_tcschr(pszLab, _T('/')))
|
||
{
|
||
nAxisFlag |= AXF_ATTACH;
|
||
}
|
||
}
|
||
|
||
//add by lgy 20120208 添加提示是否需要重排号
|
||
int iAns = YesNoQuestion(_T("\n是否重排轴号"), Q_YES);
|
||
if (iAns == RTCAN)
|
||
{
|
||
SetShowHiddenAxisLable(false);
|
||
pSet->close();
|
||
return;
|
||
}
|
||
bool bSortLabel = (iAns==Q_YES);
|
||
if (pSet->upgradeOpen() == Acad::eOk)
|
||
{
|
||
//modify by lgy 20120208 增加是否需要重排号
|
||
//pSet->AddLabel(ptAdd, nAxisFlag, pszLab);
|
||
pSet->AddLabel(ptAdd, nAxisFlag, pszLab, bSortLabel);
|
||
pSet->downgradeOpen();
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
// sg add 100521，退出命令时，恢复隐藏
|
||
SetShowHiddenAxisLable(false);
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////
|
||
// Command: 添加轴号
|
||
//void DelAxisLabel()
|
||
//{
|
||
// Entity ent;
|
||
// XPoint ptPick;
|
||
// if (SelectEntity(_T("\n请选择轴号对象<退出>: "), ent, ptPick, RBList(RTDXF0, _T("ATS_AXIS_LABEL"),NULL))!=RTNORM)
|
||
// return;
|
||
// int nAns=YesNoQuestion(_T("\n是否重排轴号"), Q_YES);
|
||
// if (nAns==RTCAN)
|
||
// return;
|
||
// BOOL bSortLabel=(nAns==Q_YES);
|
||
// ptPick=Ucs2Wcs(ptPick);
|
||
// OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbAxisLabelSet, pSet);
|
||
// if (!pSet)
|
||
// return;
|
||
// int idx=pSet->HitTestOnAxis(ptPick);
|
||
// if (idx<0)
|
||
// return;
|
||
// pSet->RemoveLabel(idx, bSortLabel);
|
||
// OPENOBJ_END();
|
||
//}
|
||
|
||
// Modify By LCF 2004/07/08
|
||
// 需要删除轴号的轴标实体
|
||
class TAxisLabelSet
|
||
{
|
||
public:
|
||
DualList<long> m_lstIndex; // 所有将要删除的轴号的索引
|
||
AcDbObjectId m_iId; // 轴号实体
|
||
TDbAxisLabelSet *pEnt;
|
||
|
||
public:
|
||
bool AppendIndexDel(int i)
|
||
{
|
||
long oldLen=m_lstIndex.GetLength();
|
||
m_lstIndex.FindOrAddTail(i);
|
||
return oldLen<m_lstIndex.GetLength();
|
||
}
|
||
|
||
//ok,如果已经存在不添加
|
||
void RemoveLabel(bool bSort)
|
||
{
|
||
m_lstIndex.Arrange(false);
|
||
|
||
// modify by xly on 110306 修改删除附加轴号是首根轴号的错误
|
||
/*acdbOpenObject(pEnt,m_iId,AcDb::kForWrite);
|
||
for (m_lstIndex.MoveToFirst();!m_lstIndex.IsOut();m_lstIndex.MoveToNext())
|
||
{
|
||
pEnt->RemoveLabel(m_lstIndex.GetCurData(),bSort);
|
||
}
|
||
pEnt->close();*/
|
||
if (Acad::eOk==acdbOpenObject(pEnt,m_iId,AcDb::kForWrite))
|
||
{
|
||
for (m_lstIndex.MoveToFirst();!m_lstIndex.IsOut();m_lstIndex.MoveToNext())
|
||
{
|
||
pEnt->RemoveLabel(m_lstIndex.GetCurData(),bSort);
|
||
if (bSort)// 删除重排后主轴号之前的错误部分处理
|
||
{
|
||
int nPosMajar(-1);
|
||
int i=0;
|
||
for (i=0;i<pEnt->GetAxisNum(); i++)
|
||
{
|
||
CString csLable = pEnt->GetLabel(i);
|
||
int iIndex = csLable.Find(_T("/"));
|
||
if (iIndex<0)
|
||
{
|
||
nPosMajar = i;
|
||
break;
|
||
}
|
||
}
|
||
if (nPosMajar>0)
|
||
{
|
||
int nTemp = nPosMajar;
|
||
CString csLable = pEnt->GetLabel(nPosMajar);
|
||
bool bFenQu = (csLable.Find(_T("-"))>-1);
|
||
if (bFenQu)// 主轴号是分区轴号
|
||
{
|
||
csLable.Insert((csLable.Find(_T("-"))+1),_T('0'));
|
||
}
|
||
for (i=0; i<nPosMajar;i++)
|
||
{
|
||
CString csFir = _T("");
|
||
if (bFenQu)// 主轴号是分区轴号
|
||
{
|
||
csFir.Format(_T("%d/"),nTemp);
|
||
}
|
||
else
|
||
{
|
||
csFir.Format(_T("%d/0"),nTemp);
|
||
}
|
||
|
||
csFir += csLable;
|
||
pEnt->SetLabel(i,csFir,FALSE);
|
||
nTemp--;
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
pEnt->close();
|
||
}
|
||
|
||
}
|
||
|
||
bool operator ==(const TAxisLabelSet&aSet){return m_iId==aSet.m_iId;}//ok
|
||
bool operator >(const TAxisLabelSet&){return false;}
|
||
bool operator <(const TAxisLabelSet&){return false;}
|
||
};
|
||
|
||
// 需要删除轴号的所有轴标实体
|
||
class TAllAxis:public PDList<TAxisLabelSet>
|
||
{
|
||
public:
|
||
long Find(AcDbObjectId id)//搜索id对应的轴标项，返回其索引,如果不存在则先建立一个id代表的新项。
|
||
{
|
||
for (MoveToFirst();!IsOut();MoveToNext())
|
||
{
|
||
if (GetCurData()->m_iId == id)//找到
|
||
{
|
||
return GetCur();
|
||
}
|
||
}
|
||
TAxisLabelSet *pAxis=new TAxisLabelSet;
|
||
pAxis->m_iId=id;
|
||
AddTail(pAxis);//没有找到就添加
|
||
|
||
return GetLastIndex();
|
||
}
|
||
|
||
void RemoveLabel(bool bSort)
|
||
{
|
||
for (MoveToFirst();!IsOut();MoveToNext())
|
||
{
|
||
GetCurData()->RemoveLabel(bSort);
|
||
}
|
||
}
|
||
};
|
||
|
||
// [2010-4-20 wubo] 根据两个角点得到一个poly。从DelAxisLabel()中提取函数。
|
||
TGGePoly2D GetExtentPolyByTwoCorner(const TADSGePoint3d &ptStart, const TADSGePoint3d &ptEnd )
|
||
{
|
||
TADSGePoint3d ptLowLeft, ptLowRight, ptUpRight, ptUpLeft;
|
||
if (ptStart.x > ptEnd.x)
|
||
{
|
||
ptLowLeft.x = ptEnd.x;
|
||
ptUpLeft.x = ptEnd.x;
|
||
ptLowRight.x = ptStart.x;
|
||
ptUpRight.x = ptStart.x;
|
||
}
|
||
else
|
||
{
|
||
ptLowLeft.x = ptStart.x;
|
||
ptUpLeft.x = ptStart.x;
|
||
ptLowRight.x = ptEnd.x;
|
||
ptUpRight.x = ptEnd.x;
|
||
}
|
||
|
||
if (ptStart.y > ptEnd.y)
|
||
{
|
||
ptLowLeft.y = ptEnd.y;
|
||
ptLowRight.y = ptEnd.y;
|
||
ptUpLeft.y = ptStart.y;
|
||
ptUpRight.y = ptStart.y;
|
||
}
|
||
else
|
||
{
|
||
ptLowLeft.y = ptStart.y;
|
||
ptLowRight.y = ptStart.y;
|
||
ptUpLeft.y = ptEnd.y;
|
||
ptUpRight.y = ptEnd.y;
|
||
}
|
||
|
||
TGGePoly2D poly(1);
|
||
poly.AppendNode(ptLowLeft);
|
||
poly.AppendNode(ptLowRight);
|
||
poly.AppendNode(ptUpRight);
|
||
poly.AppendNode(ptUpLeft);
|
||
return poly;
|
||
}
|
||
|
||
// add by xly on 110306 将选择集中的轴号虚显
|
||
void SetVisulShow(PickSet ssMouseSel, TGGePoly2D extentPoly, PickSet& ssLabel)
|
||
{
|
||
long l = 0,
|
||
lSelLength = ssMouseSel.Length(); // 选择集的长度
|
||
|
||
for (l = 0; l<lSelLength; l++)
|
||
{
|
||
Entity ent = ssMouseSel[l];
|
||
// modify by xly on 110503 以安全的方式打开
|
||
//OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbAxisLabelSet, pSet);
|
||
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbAxisLabelSet, pSet);
|
||
if (pSet == NULL)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// 克隆实体
|
||
TDbAxisLabelSet *pNewAxis = (TDbAxisLabelSet *)pSet->clone();
|
||
|
||
int nSide = pNewAxis->GetVisSides(),
|
||
nTmpIndex = 0;
|
||
|
||
// 对框选中的轴圈操作时，遍历实体，寻找框选到的轴号
|
||
int iNum = 0,
|
||
iAxisNumLength = pNewAxis->GetAxisNum();
|
||
AcDbIntArray aryAxisInSel;
|
||
|
||
if (nSide == 1 || nSide == 3) // 只标第0侧，或双侧标注
|
||
{
|
||
TADSGePoint3d ptLabelCenter;
|
||
for (iNum = 0; iNum < iAxisNumLength; iNum++)
|
||
{
|
||
ptLabelCenter = pNewAxis->GetLabelCenter(iNum, 0);
|
||
if ((ptLabelCenter&extentPoly) != PR_OUTSIDE) // 在框选范围外
|
||
{
|
||
if (!aryAxisInSel.find(iNum, nTmpIndex)) // 找不到就添加
|
||
{
|
||
aryAxisInSel.append(iNum);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (nSide == 2 || nSide == 3) // 只标第1侧，或双侧标注
|
||
{
|
||
TADSGePoint3d ptLabelCenter;
|
||
for (iNum = 0; iNum < iAxisNumLength; iNum++)
|
||
{
|
||
ptLabelCenter = pNewAxis->GetLabelCenter(iNum, 1);
|
||
if ((ptLabelCenter&extentPoly) != PR_OUTSIDE) // 在框选范围内
|
||
{
|
||
if (!aryAxisInSel.find(iNum, nTmpIndex)) // 找不到就添加
|
||
{
|
||
aryAxisInSel.append(iNum);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
int nTemp = 0;
|
||
for (iNum = 0; iNum < iAxisNumLength; iNum++)
|
||
{
|
||
if (!aryAxisInSel.find(nTemp, nTmpIndex)) // 找不到，表示被选中，不删除
|
||
{
|
||
pNewAxis->RemoveLabel(iNum, FALSE);
|
||
iAxisNumLength--;
|
||
iNum--;
|
||
}
|
||
nTemp++;
|
||
}
|
||
ssLabel += pNewAxis->AddToMSpace(Adesk::kFalse);
|
||
// modify by xly on 110503 以安全的方式打开,增加一个成功的判断
|
||
if (pNewAxis->downgradeOpen()==Acad::eOk)
|
||
{
|
||
pNewAxis->highlight();
|
||
}
|
||
pNewAxis->close();
|
||
OPENOBJ_END();
|
||
}
|
||
}
|
||
|
||
/////////////////////////////////////////////
|
||
// 命令：删除轴号
|
||
void DelAxisLabel()
|
||
{
|
||
// sg add 100521，进入命令后，临时显示全部隐藏轴号
|
||
SetShowHiddenAxisLable(true);
|
||
|
||
XPushVar<int> osmode(_T("OSMODE"), 0);
|
||
|
||
TAllAxis allEnt; // 所有相关轴标实体
|
||
|
||
// modify by xly on 110306 保存框选到的的轴号
|
||
//PickSet ssLabel(SS_FREE);
|
||
PickSet ssLabel(SS_CREATE);
|
||
while (1)
|
||
{
|
||
XPoint ptStart, ptEnd;
|
||
Entity ent;
|
||
int ret = acedGetPoint(NULL, _T("\n请框选轴号对象<退出>:"), ptStart);
|
||
if (ret == RTCAN)
|
||
{
|
||
ssLabel.Erase();
|
||
|
||
// sg add 100521，退出命令时，恢复隐藏
|
||
SetShowHiddenAxisLable(false);
|
||
return;
|
||
}
|
||
|
||
if (ret != RTNORM)
|
||
{
|
||
break;
|
||
}
|
||
|
||
if (XGetCorner(ptStart, NULL, ptEnd) != RTNORM)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// [2010-4-20 wubo] 提取了公共函数GetExtentPolyByTwoCorner
|
||
//XPoint ptLowLeft, ptLowRight, ptUpRight, ptUpLeft;
|
||
//if (ptStart.x > ptEnd.x)
|
||
//{
|
||
// ptLowLeft.x = ptEnd.x;
|
||
// ptUpLeft.x = ptEnd.x;
|
||
// ptLowRight.x = ptStart.x;
|
||
// ptUpRight.x = ptStart.x;
|
||
//}
|
||
//else
|
||
//{
|
||
// ptLowLeft.x = ptStart.x;
|
||
// ptUpLeft.x = ptStart.x;
|
||
// ptLowRight.x = ptEnd.x;
|
||
// ptUpRight.x = ptEnd.x;
|
||
//}
|
||
//if (ptStart.y > ptEnd.y)
|
||
//{
|
||
// ptLowLeft.y = ptEnd.y;
|
||
// ptLowRight.y = ptEnd.y;
|
||
// ptUpLeft.y = ptStart.y;
|
||
// ptUpRight.y = ptStart.y;
|
||
//}
|
||
//else
|
||
//{
|
||
// ptLowLeft.y = ptStart.y;
|
||
// ptLowRight.y = ptStart.y;
|
||
// ptUpLeft.y = ptEnd.y;
|
||
// ptUpRight.y = ptEnd.y;
|
||
//}
|
||
//
|
||
//XPoly2D poly(1);
|
||
//poly.AppendNode(ptLowLeft);
|
||
//poly.AppendNode(ptLowRight);
|
||
//poly.AppendNode(ptUpRight);
|
||
//poly.AppendNode(ptUpLeft);
|
||
|
||
XPoly2D poly = GetExtentPolyByTwoCorner(ptStart, ptEnd);
|
||
|
||
RBList rbRegion = poly.Polygon();
|
||
PickSet ss(SS_FREE);
|
||
if (ss.Get(_T("CP"), rbRegion, NULL, RBList(RTDXF0, _T("ATS_AXIS_LABEL"), NULL)) != RTNORM)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
poly.TransUCS(Groups(1), Groups(0));
|
||
|
||
long num = ss.Length();
|
||
for (long i=0; i<num; i++)
|
||
{
|
||
Entity ent = ss[i];
|
||
OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbAxisLabelSet, pSet);
|
||
if (pSet == NULL) // add by lcf on 050224
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// add by xly on 100810 解决删除轴号时，不能删除隐藏轴号
|
||
// 判断框选的范围内是否有隐藏轴号
|
||
for(int k = 0; k<pSet->GetAxisNum();k++)
|
||
{
|
||
// 获得标注的信息
|
||
XCurveSegment seg = pSet->GetAxis(k);
|
||
|
||
// 判断在框选的范围内标注是否有隐藏
|
||
XPoint ptCentre = pSet->GetLabelCenter(k,0);
|
||
int iIsIn = ptCentre & poly;
|
||
if (iIsIn != PR_OUTSIDE) // 0侧
|
||
{
|
||
pSet->HideAxisLabel(k,0,FALSE);
|
||
}
|
||
|
||
ptCentre = pSet->GetLabelCenter(k,1);
|
||
iIsIn = ptCentre & poly;
|
||
if (iIsIn != PR_OUTSIDE)// 1侧
|
||
{
|
||
pSet->HideAxisLabel(k,1,FALSE);
|
||
}
|
||
}
|
||
|
||
AcDbObjectId eId = pSet->objectId();
|
||
allEnt.Find(eId);
|
||
|
||
TAxisLabelSet *pLabelSet = allEnt.GetCurData();
|
||
AcDbVoidPtrArray entSet;
|
||
pSet->Explode(entSet);
|
||
|
||
long nLen = entSet.length();
|
||
for (long index=nLen-1; index>=0; index--)
|
||
{
|
||
AcDbEntity *pEnt = (AcDbEntity*)entSet[index];
|
||
if (!pEnt->isKindOf(TDbSymbDrawingIndex::desc()))
|
||
{
|
||
delete pEnt;
|
||
entSet.removeAt(index);
|
||
}
|
||
}
|
||
|
||
for (long j=0; j<entSet.length(); j++)
|
||
{
|
||
TDbSymbDrawingIndex *pIndex = (TDbSymbDrawingIndex*)entSet[j];
|
||
XPoint ptCen = pIndex->GetCenter();
|
||
int rtInSide = ptCen & poly;
|
||
if (rtInSide != PR_OUTSIDE)
|
||
{
|
||
//modified by whl on 060107
|
||
//int idx = pSet->HitTestOnAxis(ptCen);
|
||
int idx = pSet->HitTestOnLabel(ptCen);
|
||
|
||
if (idx >= 0 && pLabelSet->AppendIndexDel(idx))
|
||
{
|
||
int iSide = pSet->GetAxisVisSides(idx);
|
||
if (iSide == 3)
|
||
{
|
||
XPoint ptStaCen, ptEndCen;
|
||
ptStaCen = pSet->GetLabelCenter(idx, 0);
|
||
ptEndCen = pSet->GetLabelCenter(idx, 1);
|
||
|
||
for (long k=0; k<entSet.length(); k++)
|
||
{
|
||
TDbSymbDrawingIndex *pSideIndex = (TDbSymbDrawingIndex*)entSet[k];
|
||
XPoint ptSideCen = pSideIndex->GetCenter();
|
||
double dSta = ptSideCen.Distance2d(ptStaCen);
|
||
double dEnd = ptSideCen.Distance2d(ptEndCen);
|
||
if (dSta < 1.0E-6 || dEnd < 1.0E-6)
|
||
{
|
||
// delete by xly on 110306 设置框选的轴号的虚显不用此函数
|
||
/*TDbSymbDrawingIndex *pHightlight = (TDbSymbDrawingIndex*)pSideIndex->clone();
|
||
ssLabel += pHightlight->AddToMSpace(Adesk::kFalse);
|
||
pHightlight->downgradeOpen();
|
||
pHightlight->highlight();
|
||
pHightlight->close();*/
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// delete by xly on 110306 设置框选的轴号的虚显不用此函数
|
||
/*TDbSymbDrawingIndex *pHightlight = (TDbSymbDrawingIndex*)pIndex->clone();
|
||
ssLabel+=pHightlight->AddToMSpace(Adesk::kFalse);
|
||
pHightlight->downgradeOpen();
|
||
pHightlight->highlight();
|
||
pHightlight->close();*/
|
||
}
|
||
}
|
||
}
|
||
}
|
||
ReleaseEntSet(entSet);
|
||
OPENOBJ_END();
|
||
}
|
||
// add by xly on 110306 设置轴号的虚显
|
||
PickSet ssTemp(SS_CREATE);
|
||
ssTemp += ss;
|
||
SetVisulShow(ssTemp, poly, ssLabel);
|
||
ssTemp.Free();
|
||
continue;
|
||
}
|
||
|
||
long nlight = ssLabel.Length();
|
||
if (nlight <= 0)
|
||
{
|
||
// sg add 100521，退出命令时，恢复隐藏
|
||
SetShowHiddenAxisLable(false);
|
||
return;
|
||
}
|
||
|
||
int nAns = YesNoQuestion(_T("\n是否重排轴号"), Q_YES);
|
||
// modify by xly on 110503 重复框选同一个轴标出现错误，提到下面调用
|
||
//ssLabel.Erase();
|
||
if (nAns == RTCAN)
|
||
{
|
||
// add by xly on 110503 取消时清除轴号
|
||
ssLabel.Erase();
|
||
|
||
// sg add 100521，退出命令时，恢复隐藏
|
||
SetShowHiddenAxisLable(false);
|
||
return;
|
||
}
|
||
|
||
bool bSortLabel = (nAns==Q_YES);
|
||
allEnt.RemoveLabel(bSortLabel);
|
||
|
||
ssLabel.Erase();
|
||
// sg add 100521，退出命令时，恢复隐藏
|
||
SetShowHiddenAxisLable(false);
|
||
}
|
||
|
||
|
||
|
||
/////////////////////////////////////////////
|
||
// sg add 100530，判断是否需要在“重排轴号”命令中，提示用户选择“变前项”、“变后项”
|
||
bool IsPromptChangeNoRule(const TCHAR *pszText)
|
||
{
|
||
int nLength = (int)_tcslen(pszText);
|
||
if (nLength < 2) // 单个字母或者为空，不需要提示选择排序原则
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (IsDigital(pszText)) // 全部是数字，也不需要提示选择排序原则
|
||
{
|
||
return false;
|
||
}
|
||
|
||
const TCHAR *pSep = _tcschr(pszText, _T('/'));
|
||
if (pSep != NULL) // 附加轴号，也不需要提示选择排序原则
|
||
{
|
||
return false;
|
||
}
|
||
|
||
return true; // 字母数字组合
|
||
}
|
||
|
||
// 命令: 重排轴号
|
||
void ChAxisLabel1()
|
||
{
|
||
XPoint ptPick;
|
||
Entity entAxisNo;
|
||
RBList mask(RTDXF0, _T("ATS_AXIS_LABEL"), NULL);
|
||
if (SelectEntity(_T("\n请选择需重排的第一根轴号<退出>: "), entAxisNo, ptPick, mask) == RTNORM)
|
||
{
|
||
ptPick = Ucs2Wcs(ptPick); // Add on 2001/11/29 by ZJQ
|
||
|
||
OPENOBJ_BEGIN(entAxisNo, AcDb::kForRead, TDbAxisLabelSet, pLabel);
|
||
int nIdx = pLabel->HitTestOnLabel(ptPick);
|
||
if (nIdx >= 0)
|
||
{
|
||
const TCHAR *pszOld = pLabel->GetLabel(nIdx);
|
||
|
||
TCHAR szOld[80] = _T("");
|
||
_tcscpy(szOld, pszOld);
|
||
adsout << _T("\n请输入新的轴号(.空号)<") << szOld << _T(">: ");
|
||
|
||
if (ads_getstring(0, _T(""), szOld) == RTNORM)
|
||
{
|
||
if (_tcscmp(szOld, _T(".")) == 0)
|
||
{
|
||
_tcscpy(szOld, _T(""));
|
||
}
|
||
else if (!szOld[0])
|
||
{
|
||
_tcscpy(szOld, pszOld);
|
||
}
|
||
|
||
// sg add 100530，根据8.5的需求，增加了“变前项”、“变后项”的设置
|
||
// 需要给出提示“请输入轴号规则”的提示
|
||
bool bPrompt = ::IsPromptChangeNoRule(szOld);
|
||
|
||
BOOL bChangePreNo = pLabel->IsChangePreNum(); // 当前规则
|
||
if (bPrompt)
|
||
{
|
||
TCHAR szSortRule[10] = _T("");
|
||
if (bChangePreNo) // 变前项
|
||
{
|
||
_tcscpy(szSortRule, _T("F"));
|
||
}
|
||
else // 变后项
|
||
{
|
||
_tcscpy(szSortRule, _T("B"));
|
||
}
|
||
adsout << _T("\n请输入轴号规则[变后项(B)/变前项(F)]<") << szSortRule << _T(">: ");
|
||
|
||
int nRet = ads_getstring(0, _T(""), szSortRule);
|
||
if (nRet == RTNORM)
|
||
{
|
||
if (szSortRule[0])
|
||
{
|
||
bChangePreNo = _tcscmp(szSortRule, _T("F"))==0 || _tcscmp(szSortRule, _T("f"))==0;
|
||
}
|
||
}
|
||
else // 其他
|
||
{
|
||
return;
|
||
}
|
||
}
|
||
|
||
if (pLabel->upgradeOpen() == Acad::eOk)
|
||
{
|
||
// sg add 100530，将用户设置的“变前项”、“变后项”的值，传递给对象
|
||
if (bPrompt)
|
||
{
|
||
pLabel->SetChangePreNum(bChangePreNo);
|
||
}
|
||
|
||
pLabel->SetLabel(nIdx, szOld, TRUE);
|
||
pLabel->downgradeOpen();
|
||
}
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////
|
||
// 命令：修改轴号
|
||
void ChAxisLabel2()
|
||
{
|
||
XPoint ptPick;
|
||
Entity entAxisNo;
|
||
RBList mask(RTDXF0, _T("ATS_AXIS_LABEL"), NULL);
|
||
while (SelectEntity(_T("\n请选择轴号<退出>: "), entAxisNo, ptPick, mask) == RTNORM)
|
||
{
|
||
ptPick = Ucs2Wcs(ptPick); // Add on 2001/11/29 by ZJQ
|
||
|
||
OPENOBJ_BEGIN(entAxisNo, AcDb::kForRead, TDbAxisLabelSet, pLabel);
|
||
int nIdx = pLabel->HitTestOnLabel(ptPick);
|
||
if (nIdx >= 0)
|
||
{
|
||
const TCHAR *pszOld = pLabel->GetLabel(nIdx);
|
||
TCHAR szOld[80] = _T("");
|
||
_tcscpy(szOld, pszOld);
|
||
adsout << _T("\n请输入新的轴号(.空号)<") << szOld << _T(">: ");
|
||
|
||
if (ads_getstring(0, _T(""), szOld) == RTNORM)
|
||
{
|
||
if (_tcscmp(szOld, _T(".")) == 0)
|
||
{
|
||
_tcscpy(szOld, _T(""));
|
||
}
|
||
else if (!szOld[0])
|
||
{
|
||
_tcscpy(szOld, pszOld);
|
||
}
|
||
|
||
if (pLabel->upgradeOpen() == Acad::eOk)
|
||
{
|
||
pLabel->SetLabel(nIdx, szOld, FALSE);
|
||
pLabel->downgradeOpen();
|
||
}
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/////////////////////////////////////////
|
||
// 必须在WCS下
|
||
// modify by xly 1005010，完成8.5的新需求，整体修该命令
|
||
/*
|
||
void ManualDimAxis()
|
||
{
|
||
InitLayer(LAY_DIMAX, TRUE);
|
||
RBList mask(RTDXF0, _T("LINE,ARC"), 8, LAY_AXIS, NULL);
|
||
XPoint ptPick;
|
||
while (1) {
|
||
Entity entFirstAxis;
|
||
{
|
||
XPushVar<int> osmode(_T("OSMODE"), OS_END|OS_NEA);
|
||
if (SelectEntity1(_T("\n点取待标注的轴线<退出>:"), entFirstAxis, ptPick, mask)!=RTNORM)
|
||
return;
|
||
ptPick=Ucs2Wcs(ptPick); // Add on 2001/11/29 by ZJQ
|
||
}
|
||
XCurveSegment curve(entFirstAxis);
|
||
BOOL bOnStart=ptPick.Distance2d(curve.StartPoint())<ptPick.Distance2d(curve.EndPoint());
|
||
XPoint ptAxisEnd = curve.NearPoint(ptPick);
|
||
XPoint ptAxisEnd1;
|
||
double nAxisDirection=curve.IDirection(bOnStart? 0: 1);
|
||
ads_polar(ptAxisEnd, nAxisDirection, curve.GetLength(), ptAxisEnd1);
|
||
|
||
TCHAR szLabel[256]=_T("");
|
||
if (ads_getstring(0, _T("\n请输入轴号<空号>:"), szLabel)==RTCAN)
|
||
return;
|
||
|
||
TDbAxisLabelSet *pAxisDim=new TDbAxisLabelSet;
|
||
pAxisDim->SetTextStyleId(InitTextStyle(TS_AXIS));
|
||
pAxisDim->SetTextLayerId(InitLayer(LAY_AXIS_TEXT, FALSE));
|
||
pAxisDim->AddAxis(XCurveSegment(ptAxisEnd, ptAxisEnd1, 0.0, LS_FINITE), FALSE, szLabel);
|
||
ASSERT(pAxisDim->IsValid());
|
||
pAxisDim->SetSortAuto(FALSE);
|
||
pAxisDim->HideSide(1);
|
||
pAxisDim->SetLayoutRotation(Ucs2Wcs(0));
|
||
pAxisDim->AddToMSpace(Adesk::kTrue);
|
||
}
|
||
}
|
||
*/
|
||
|
||
|
||
/////////////////////////////////////////////
|
||
// 命令：逐点标注(逐点轴标)
|
||
void ManualDimAxis()
|
||
{
|
||
// 初始化图层
|
||
InitLayer(LAY_DIMAX, TRUE);
|
||
|
||
// 初始化对话框
|
||
CManualDimAxisDlg dlg(acedGetAcadFrame());
|
||
{
|
||
CAcModuleResourceOverride vTemp;
|
||
if (!dlg.Create(CManualDimAxisDlg::IDD, acedGetAcadFrame()))
|
||
{
|
||
return;
|
||
}
|
||
}
|
||
dlg.ShowWindow(SW_SHOW);
|
||
acedGetAcadDwgView()->SetFocus();
|
||
|
||
XPoint ptPick;
|
||
Entity entFirstAxis;
|
||
CString csLabel = _T("");
|
||
RBList mask(RTDXF0, _T("LINE,ARC"), 8, LAY_AXIS, NULL);
|
||
|
||
// 当前UCS
|
||
double dUcsAngle = Ucs2Wcs(0.0);
|
||
AcGeVector3d vtCurXAxis(cos(dUcsAngle), sin(dUcsAngle), 0); // 当前坐标系下的X轴
|
||
|
||
while (1)
|
||
{
|
||
{
|
||
XPushVar<int> osmode(_T("OSMODE"), OS_END|OS_NEA);
|
||
if (SelectEntity1(_T("\n点取待标注的轴线<退出>:"), entFirstAxis, ptPick, mask) != RTNORM)
|
||
{
|
||
// add by xly on 101029 释放对话框资源，解决运行命令后CAD中的打开、新建、图纸切换不可用
|
||
if (IsWindow(dlg.m_hWnd))
|
||
{
|
||
dlg.DestroyWindow();
|
||
}
|
||
return;
|
||
}
|
||
|
||
ptPick = Ucs2Wcs(ptPick);
|
||
}
|
||
|
||
XCurveSegment curve(entFirstAxis);
|
||
bool bOnStart = ptPick.Distance2d(curve.StartPoint())<ptPick.Distance2d(curve.EndPoint());
|
||
|
||
// 获取轴线中，离拾取点较近的一侧
|
||
XPoint ptAxisNear = curve.NearPoint(ptPick),
|
||
ptAxisFar;
|
||
double nAxisDirection = curve.IDirection(bOnStart ? 0 : 1);
|
||
ads_polar(ptAxisNear, nAxisDirection, curve.GetLength(), ptAxisFar);
|
||
|
||
// 对话框的选择项目
|
||
int iSelected = dlg.m_iWhichSlected;
|
||
int iTxtOrGraph = dlg.m_iTxtorGrap;
|
||
BOOL bIsContinue = dlg.m_bButCon;
|
||
|
||
// 获得多轴，不连续图形的所有值
|
||
CStringArray aryAxisLable;
|
||
dlg.GetAllAxis(aryAxisLable);
|
||
|
||
// 获得起、止位置的内容
|
||
CString csStartAxis = _T(""),
|
||
csEnfAxis = _T("");
|
||
dlg.GetStartAndEndAxis(csStartAxis, csEnfAxis);
|
||
|
||
// 根据对话框的选项设置第一个轴圈内容
|
||
if (bIsContinue && iSelected == 1) // 多轴，连续
|
||
{
|
||
csLabel = csStartAxis;
|
||
}
|
||
else if (iTxtOrGraph == 1 && iSelected == 1) // 多轴，图形
|
||
{
|
||
csLabel = aryAxisLable.GetAt(0);
|
||
}
|
||
else // 单轴，多轴、文字
|
||
{
|
||
csLabel = dlg.GetFirstAxis();
|
||
}
|
||
|
||
// add by xly 100813 修改轴标引线长度的变量
|
||
// 设置轴标的引线长度
|
||
double dLeaderLen = dlg.GetLeaderLen();
|
||
dLeaderLen = dLeaderLen * DocGetPScale();
|
||
|
||
// 绘制第一个轴圈
|
||
TDbAxisLabelSet *pAxisDim = new TDbAxisLabelSet;
|
||
pAxisDim->SetTextStyleId(InitTextStyle(TS_AXIS));
|
||
pAxisDim->SetTextLayerId(InitLayer(LAY_AXIS_TEXT, FALSE));
|
||
pAxisDim->AddAxis(XCurveSegment(ptAxisNear, ptAxisFar, 0.0, LS_FINITE), 0, csLabel);
|
||
|
||
ASSERT(pAxisDim->IsValid());
|
||
pAxisDim->SetSortAuto(FALSE);
|
||
pAxisDim->HideSide(1);
|
||
pAxisDim->SetLayoutRotation(dUcsAngle);
|
||
|
||
// add by xly 100813 修改轴标引线长度的变量
|
||
pAxisDim->SetLeaderLen(0,dLeaderLen, FALSE);
|
||
|
||
pAxisDim->AddToMSpace(Adesk::kTrue);
|
||
|
||
if (iSelected == 0) // 单轴只有一个轴圈
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// modify by xly 100813 预留可以修改轴标引线长度的变量
|
||
// 引线默认长度
|
||
//pAxisDim->GetLeaderLen((pAxisDim->GetVisSides()), FALSE);
|
||
double dLenLeader = dLeaderLen;
|
||
|
||
// 图形类多轴号
|
||
if (!bIsContinue && iTxtOrGraph == 1)
|
||
{
|
||
AcGePoint3d ptPos, ptFar;
|
||
|
||
// 将获得的csArry数组的1到iLen-1个字符串做成轴标
|
||
int nLength = (int)aryAxisLable.GetSize();
|
||
for (int i = 1; i < nLength; i++)
|
||
{
|
||
// 获得引线长度
|
||
dLenLeader = dLenLeader + pAxisDim->GetCirRadius(FALSE) * 2;
|
||
ads_polar(ptAxisNear, nAxisDirection + PI, dLenLeader , asDblArray(ptPos));
|
||
ads_polar(ptAxisFar, nAxisDirection, dLenLeader , asDblArray(ptFar));
|
||
|
||
|
||
// 声明轴标对象，设置相关内容
|
||
TDbAxisLabelSet *pNewAxisDim = new TDbAxisLabelSet;
|
||
pNewAxisDim->SetTextStyleId(InitTextStyle(TS_AXIS));
|
||
pNewAxisDim->SetTextLayerId(InitLayer(LAY_AXIS_TEXT, FALSE));
|
||
pNewAxisDim->AddAxis(XCurveSegment(ptPos, ptFar, 0.0, LS_FINITE), 0, aryAxisLable.GetAt(i));
|
||
|
||
// 将新生成的多轴号，引线长度设置为0
|
||
pNewAxisDim->SetLeaderLen(0, 0.0, TRUE);
|
||
pNewAxisDim->SetLeaderLen(1, 0.0, TRUE);
|
||
ASSERT(pNewAxisDim->IsValid());
|
||
|
||
pNewAxisDim->SetSortAuto(FALSE);
|
||
pNewAxisDim->HideSide(1);
|
||
pNewAxisDim->SetLayoutRotation(dUcsAngle);
|
||
pNewAxisDim->AddToMSpace(Adesk::kTrue);
|
||
}
|
||
|
||
continue;
|
||
}
|
||
|
||
double dRadCir = pAxisDim->GetCirRadius(FALSE), // 轴圈半径
|
||
dTextHeight = AXISTEXT_HEIGHT * DocGetPScale(), // 默认字高
|
||
dAngleVet = 0.0;
|
||
dTextHeight = dRadCir*5.5/4;
|
||
|
||
CString csTextHeight;
|
||
csTextHeight.Format(_T("%.1f"), dTextHeight);
|
||
dTextHeight = _tstof(csTextHeight);
|
||
|
||
// 获得第一轴圈的中心点半径
|
||
AcGePoint3d ptTextPos,
|
||
ptCenter = pAxisDim->GetLabelCenter(0, pAxisDim->GetAxisVisSides(pAxisDim->GetVisSides()));
|
||
// modify by xly on 110410 修改文字的对齐方式
|
||
// 单行文字对齐方式
|
||
//XExplodeDraw::TextAlignment nAlign = XExplodeDraw::kBottomLeft;
|
||
XExplodeDraw::TextAlignment nAlign = XExplodeDraw::kMiddleLeft;
|
||
|
||
{
|
||
// 轴网所在位置的判断
|
||
AcGeVector3d ver = ptCenter - ptAxisNear.AsAcGePoint3d();
|
||
dAngleVet = vtCurXAxis.angleTo(ver, AcGeVector3d::kZAxis);
|
||
|
||
if (dAngleVet > PI * 0.5 + _angSnap && dAngleVet < PI + _angSnap)
|
||
{
|
||
acutPolar(asDblArray(ptCenter), dUcsAngle+PI, dRadCir * 1.2, asDblArray(ptTextPos));
|
||
//nAlign = XExplodeDraw::kBottomRight;
|
||
nAlign = XExplodeDraw::kMiddleRight;
|
||
}
|
||
else
|
||
{
|
||
acutPolar(asDblArray(ptCenter), dUcsAngle, dRadCir * 1.2, asDblArray(ptTextPos));
|
||
}
|
||
// delete by xly on 110410 修改文字的对齐方式
|
||
//acutPolar(asDblArray(ptTextPos), dUcsAngle-PI/2, dTextHeight * 0.5, asDblArray(ptTextPos));
|
||
}
|
||
|
||
|
||
if (bIsContinue) // 多轴,连续第一轴圈后的内容
|
||
{
|
||
if (csEnfAxis.IsEmpty())
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// “～”文本的绘制
|
||
TDbText *pText = new TDbText();
|
||
pText->SetStyleId(InitTextStyle(TS_AXIS));
|
||
pText->SetHeight(dTextHeight, FALSE);
|
||
pText->SetText(_T("～"));
|
||
pText->SetAlignment(nAlign);
|
||
pText->SetLocation(ptTextPos);
|
||
|
||
// 获得文字的外包围框大小
|
||
XPoint ptMax, ptMin;
|
||
pText->SetLayoutRotation(0);
|
||
pText->GetExtents2d(ptMin, ptMax);
|
||
pText->SetLayoutRotation(dUcsAngle);
|
||
|
||
// modify by xly on 110316 设置文字的图层在轴号的文字图层
|
||
//pText->AddToMSpace(Adesk::kTrue);
|
||
AcDbObjectId id = pText->AddToMSpace(Adesk::kTrue);
|
||
if (Acad::eOk ==acdbOpenObject(pText, id,AcDb::kForWrite))
|
||
{
|
||
pText->setLayer(InitLayer(LAY_AXIS_TEXT, FALSE));
|
||
pText->close();
|
||
}
|
||
|
||
|
||
// 文字宽度
|
||
double dTextWidth = ptMax.x - ptMin.x;
|
||
|
||
// 终止轴线
|
||
AcGePoint3d ptNearAxisPos ,ptFarAxisPos;
|
||
ads_polar(asDblArray(ptCenter), nAxisDirection, dRadCir, asDblArray(ptNearAxisPos));
|
||
if (dAngleVet > PI * 0.5 + _angSnap && dAngleVet < PI + _angSnap)
|
||
{
|
||
ads_polar(asDblArray(ptNearAxisPos), dUcsAngle-PI, dRadCir*2.4+dTextWidth, asDblArray(ptNearAxisPos));
|
||
}
|
||
else
|
||
{
|
||
ads_polar(asDblArray(ptNearAxisPos), dUcsAngle, dRadCir*2.4+dTextWidth, asDblArray(ptNearAxisPos));
|
||
}
|
||
ads_polar(asDblArray(ptNearAxisPos), nAxisDirection, curve.GetLength()+2*dLenLeader, asDblArray(ptFarAxisPos));
|
||
|
||
// 声明轴标对象，设置相关内容
|
||
TDbAxisLabelSet *pNewAxisDim = new TDbAxisLabelSet;
|
||
pNewAxisDim->SetTextStyleId(InitTextStyle(TS_AXIS));
|
||
pNewAxisDim->SetTextLayerId(InitLayer(LAY_AXIS_TEXT, FALSE));
|
||
pNewAxisDim->SetLayoutRotation(dUcsAngle);
|
||
pNewAxisDim->AddAxis(XCurveSegment(ptNearAxisPos, ptFarAxisPos, 0.0, LS_FINITE), FALSE, csEnfAxis);
|
||
|
||
pNewAxisDim->SetLeaderLen(0, 0.0, TRUE);
|
||
pNewAxisDim->SetLeaderLen(1, 0.0, TRUE);
|
||
ASSERT(pNewAxisDim->IsValid());
|
||
pNewAxisDim->SetSortAuto(FALSE);
|
||
pNewAxisDim->HideSide(1);
|
||
pNewAxisDim->AddToMSpace(Adesk::kTrue);
|
||
|
||
continue;
|
||
}
|
||
|
||
// 文字类多轴号
|
||
CString csNextText = dlg.GetOtherAxis();
|
||
if (csNextText.IsEmpty()) // 文字部分为空
|
||
{
|
||
continue;
|
||
}
|
||
|
||
TDbText *pText = new TDbText();
|
||
pText->SetStyleId(InitTextStyle(TS_AXIS));
|
||
pText->SetHeight(dTextHeight, FALSE);
|
||
pText->SetLayoutRotation(dUcsAngle);
|
||
pText->SetText(csNextText);
|
||
pText->SetAlignment(nAlign);
|
||
pText->SetLocation(ptTextPos);
|
||
|
||
pText->setLayer(InitLayer(_T("0")));
|
||
|
||
// modify by xly on 110316 设置文字的图层在轴号的文字图层
|
||
//pText->AddToMSpace(Adesk::kTrue);
|
||
AcDbObjectId id = pText->AddToMSpace(Adesk::kTrue);
|
||
if (Acad::eOk ==acdbOpenObject(pText, id,AcDb::kForWrite))
|
||
{
|
||
pText->setLayer(InitLayer(LAY_AXIS_TEXT, FALSE));
|
||
pText->close();
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
///////////////////////////////////////////////////////////////////////////////////
|
||
// 手动标注
|
||
#if 0
|
||
/////////////////////////////////////////////////////////
|
||
// Command: 驱动轴网
|
||
void DriveAxis()
|
||
{
|
||
PickSet ss(SS_FREE);
|
||
adsout << _T("\n请选择参加驱动的轴网及相关的对象!");
|
||
if (ss.Get()!=RTNORM)
|
||
{
|
||
return;
|
||
}
|
||
|
||
Entity entDim;
|
||
XPoint ptPick;
|
||
RBList mask(RTDXF0, _T("DIMENSION"), NULL), maskAxisNo(RTDXF0, _T("INSERT"), 2, _T("_AXISO*"), NULL);
|
||
int nRetCode=entDim.FilterSelect(_T("\n请选择第二道尺寸(点取驱动的一侧): "), mask, ptPick);
|
||
if (nRetCode!=RTNORM) return;
|
||
do
|
||
{
|
||
if (nRetCode!=RTNORM && nRetCode!=RTKWORD)
|
||
{
|
||
break;
|
||
}
|
||
if (nRetCode == RTKWORD)
|
||
{
|
||
SHads_command(RTSTR, _T(".UNDO"), RTSTR, _T("BACK"), RTNONE);
|
||
continue;
|
||
}
|
||
|
||
int nDimType;
|
||
entDim.GetData(70, &nDimType);
|
||
ASSERT(ADS>12);
|
||
nDimType &= ~(32+128);
|
||
if (nDimType!=0 && nDimType!=1 && nDimType!=5)
|
||
{
|
||
adsout << _T("\n请正确选择标注类型!");
|
||
continue;
|
||
}
|
||
|
||
XPoint ptLimStart, ptLimEnd, ptTextBaseline, ptArcCen;
|
||
if (nDimType == 5)
|
||
{
|
||
entDim.GetData(15, &ptArcCen);
|
||
}
|
||
|
||
entDim.GetData(13, &ptLimStart);
|
||
entDim.GetData(14, &ptLimEnd);
|
||
entDim.GetData(10, &ptTextBaseline);
|
||
double nDimDirection=0.0;
|
||
if (nDimType == 0) //Rotate,Horizontal,Vertical
|
||
{
|
||
entDim.GetData(50, &nDimDirection);
|
||
}
|
||
else if (nDimType == 1)
|
||
{
|
||
nDimDirection = ads_angle(ptLimStart, ptLimEnd);
|
||
}
|
||
|
||
XCurveSegment cvTextBase;
|
||
int nRetCode=0;
|
||
AcGeMatrix3d mat;
|
||
XVector3D vtMove;
|
||
if (nDimType == 5)
|
||
{
|
||
cvTextBase=XArc(ptArcCen, ads_distance(ptArcCen, ptTextBaseline),
|
||
ads_angle(ptArcCen, ptLimStart), ads_angle(ptArcCen, ptLimEnd));
|
||
XString sTextDim;
|
||
entDim.GetData(1, (TCHAR *)sTextDim);
|
||
if (!sTextDim)
|
||
{
|
||
double nAngle=cvTextBase.bulge*180/PI;
|
||
nRetCode=GetReal(_T("\n输入新的夹角"), nAngle, RSG_NONEG|RSG_NOZERO);
|
||
if (nRetCode == RTNORM)
|
||
{
|
||
double nRot=nAngle*PI/180-cvTextBase.bulge;
|
||
mat.setToRotation(nRot, AcGeVector3d(0,0,1), ptArcCen);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
adsout << _T("\n只能对角度标注进行驱动,不能对弧长标注进行驱动!");
|
||
continue;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
cvTextBase=XLine(ptTextBaseline, nDimDirection);
|
||
XPoint ptLimS, ptLimE;
|
||
cvTextBase.ProjectToMe(ptLimStart, ptLimS);
|
||
cvTextBase.ProjectToMe(ptLimEnd, ptLimE);
|
||
cvTextBase.SetPoints(ptLimS, ptLimE);
|
||
|
||
XPoint ptBase = cvTextBase.FarPoint(ptPick);
|
||
XPoint ptDrive = cvTextBase.NearPoint(ptPick);
|
||
double nNewDist=cvTextBase.Length();
|
||
nRetCode = XGetDist(ptBase, _T("\n请输入新的距离"), nNewDist, RSG_NONEG);
|
||
|
||
XPoint ptDest;
|
||
ads_polar(ptBase, ads_angle(ptBase, ptDrive), nNewDist, ptDest);
|
||
vtMove = ptDest - ptDrive; //移动的位移
|
||
AcGeVector3d vtOffset(vtMove.x, vtMove.y, vtMove.z);
|
||
mat.setToTranslation(vtOffset);
|
||
}
|
||
|
||
if (nRetCode == RTCAN)
|
||
{
|
||
break;
|
||
}
|
||
if (nRetCode == RTNORM)
|
||
{
|
||
SHads_command(RTSTR, _T(".UNDO"), RTSTR, _T("MARK"), RTNONE); // Make a undo mark
|
||
XPoint ptBase = cvTextBase.FarPoint(ptPick);
|
||
XPoint ptDrive = cvTextBase.NearPoint(ptPick);
|
||
XLine lnDivider(ptDrive, cvTextBase.Direction(ptDrive)+PI/2.0);
|
||
int nDrvSide=1-lnDivider.OnWhichSide(ptBase);
|
||
long lCount=ss.Length();
|
||
PickSet ssTransformed(SS_FREE|SS_CREATE);
|
||
for (long lIndex=0L; lIndex<lCount; lIndex++)
|
||
{
|
||
Entity ent=ss[lIndex];
|
||
if (ent.In(ssTransformed))
|
||
{
|
||
continue;
|
||
}
|
||
BOOL bAxisNo=ent.MatchBase(maskAxisNo);
|
||
XDbObject obj(ent, AcDb::kForWrite);
|
||
if (!obj) continue;
|
||
AcDbEntity &dbEnt=obj;
|
||
if (bAxisNo) // 轴号
|
||
{
|
||
AcDbBlockReference *pBlock=AcDbBlockReference::cast(obj.m_pObject);
|
||
ASSERT(pBlock);
|
||
XPoint ptInsert=pBlock->position();
|
||
XPoint ptPrj;
|
||
ptInsert.Project(lnDivider, ptPrj);
|
||
if (ptInsert.Distance2d(ptPrj)<_DIST_SNAP || lnDivider.OnWhichSide(ptInsert) == nDrvSide)
|
||
{
|
||
pBlock->transformBy(mat);
|
||
}
|
||
continue;
|
||
}
|
||
else if (dbEnt.isKindOf(TDbWall::desc()))
|
||
{
|
||
TDbWall *pWall=TDbWall::cast(obj.m_pObject);
|
||
int nPrFlag1=pWall->startPoint&lnDivider;
|
||
int nPrFlag2=pWall->endPoint&lnDivider;
|
||
BOOL bTransForm=FALSE;
|
||
if (nPrFlag1!=PR_OUTSIDE && nPrFlag2!=PR_OUTSIDE)
|
||
{
|
||
bTransForm=TRUE;
|
||
}
|
||
else if (nPrFlag1 == PR_OUTSIDE && nPrFlag2 == PR_OUTSIDE
|
||
&& lnDivider.OnWhichSide(pWall->startPoint) == nDrvSide)
|
||
{
|
||
bTransForm=TRUE;
|
||
}
|
||
if (bTransForm)
|
||
{
|
||
DStack<TDbOpening> lstOpening;
|
||
pWall->GetOpenings(lstOpening, AcDb::kForWrite, FALSE);
|
||
for (int k=0; k<lstOpening.Length(); k++)
|
||
{
|
||
TDbOpening *pOp=lstOpening[k];
|
||
Entity entOp;
|
||
VERIFY(acdbGetAdsName(entOp.name, pOp->objectId()) == Acad::eOk);
|
||
if (!entOp.In(ssTransformed))
|
||
{
|
||
pOp->transformBy(mat);
|
||
ssTransformed += entOp;
|
||
}
|
||
pOp->close();
|
||
}
|
||
pWall->transformBy(mat);
|
||
continue;
|
||
}
|
||
/*
|
||
TDbOpening *pWin=TDbOpening::cast(obj.m_pObject);
|
||
ASSERT(pWin);
|
||
XPoint ptInsert=pWin->GetLocation();
|
||
XPoint ptPrj;
|
||
ptInsert.Project(lnDivider, ptPrj);
|
||
if (ptInsert.Distance2d(ptPrj)<_DIST_SNAP ||
|
||
CT_IsExactSameDrt(ads_angle(ptBase, ptDrive), ads_angle(ptPrj, ptInsert), _angSnap)) {
|
||
pWin->transformBy(mat);
|
||
}*/
|
||
}
|
||
else if (dbEnt.isKindOf(TDbColumn::desc()))
|
||
{
|
||
TDbColumn *pColu=TDbColumn::cast(obj.m_pObject);
|
||
ASSERT(pColu);
|
||
XPoly2D polyOutline=pColu->GetOutlinePoly();
|
||
polyOutline.SetElevation(lnDivider.StartPoint().z);
|
||
BOOL bIntsect=FALSE;
|
||
for (int n=0; n<polyOutline.TotalSegments();n++)
|
||
{
|
||
XCurveSegment seg;
|
||
polyOutline.Nth(n, seg);
|
||
seg.flag=LS_FINITE;
|
||
if (seg.Intersection(lnDivider, XPoint(), XPoint()))
|
||
{
|
||
bIntsect=TRUE;
|
||
break;
|
||
}
|
||
}
|
||
BOOL bDrive=bIntsect;
|
||
if (!bIntsect)
|
||
{
|
||
XPoint ptCen, ptPrj;
|
||
polyOutline.Center(ptCen);
|
||
ptCen.Project(lnDivider, ptPrj);
|
||
bDrive=CT_IsExactSameDrt(ads_angle(ptBase, ptDrive), ads_angle(ptPrj, ptCen), _angSnap);
|
||
}
|
||
if (bDrive)
|
||
{
|
||
pColu->transformBy(mat);
|
||
continue;
|
||
}
|
||
}
|
||
|
||
AcGePoint3dArray ptStretchArray;
|
||
Acad::ErrorStatus es = dbEnt.getStretchPoints(ptStretchArray);
|
||
if (es == Acad::eOk)
|
||
{
|
||
long nLenOfArray=ptStretchArray.length();
|
||
AcDbIntArray indices;
|
||
for (long i=0L; i<nLenOfArray; i++)
|
||
{
|
||
XPoint ptStretch = ptStretchArray[i];
|
||
XPoint ptPrj;
|
||
ptStretch.Project(lnDivider, ptPrj);
|
||
if (ads_distance(ptStretch, ptPrj)<_DIST_SNAP || lnDivider.OnWhichSide(ptStretch) == nDrvSide)
|
||
{
|
||
if (nDimType == 5)
|
||
{
|
||
AcDbIntArray indices0;
|
||
indices0.append(i);
|
||
XPoint ptDest=ptStretch;
|
||
((AcGePoint3d &)ptDest).transformBy(mat);
|
||
XVector3D vtOff=ptDest-ptStretch;
|
||
dbEnt.moveStretchPointsAt(indices0,vtOff);
|
||
}
|
||
else
|
||
{
|
||
indices.append(i);
|
||
}
|
||
}
|
||
}
|
||
if (nDimType!=5)
|
||
{
|
||
dbEnt.moveStretchPointsAt(indices,vtMove);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
while (ads_initget(0, _T("U"))
|
||
&& (nRetCode=entDim.FilterSelect(_T("\n回退(U)/请选择第二道尺寸标注(点取驱动的一侧): "), mask, ptPick)));
|
||
}
|
||
|
||
#endif
|
||
|
||
// add by xlc on 070730
|
||
// 线对齐
|
||
void AlignLine(PickSet ss, //[in]需对齐的实体
|
||
Entity en) //[in]对齐边界
|
||
{
|
||
OPENOBJ_BEGIN(en, AcDb::kForRead, AcDbLine, pLine);
|
||
if (pLine != NULL)
|
||
{
|
||
for (long i=0;i<ss.Length();i++)
|
||
{
|
||
AcGePoint3d ptTmp;
|
||
Entity ent=ss[i];
|
||
OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbLine, pLineNew);
|
||
|
||
if (pLineNew)
|
||
{
|
||
AcGePoint3dArray ptInt;
|
||
pLineNew->intersectWith(pLine,AcDb::kExtendThis,ptInt);
|
||
if (ptInt.length()>0)//修改线端点
|
||
{
|
||
pLineNew->upgradeOpen();
|
||
if (pLineNew->endPoint().distanceTo(ptInt[0])
|
||
<= pLineNew->startPoint().distanceTo(ptInt[0]))
|
||
{
|
||
pLineNew->setEndPoint(ptInt[0]);
|
||
}
|
||
else
|
||
{
|
||
pLineNew->setStartPoint(ptInt[0]);
|
||
}
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
|
||
// add by xlc on 070730
|
||
// 轴线对齐
|
||
// ss [in]要对齐的轴线
|
||
void AlignAxis(PickSet ss)
|
||
{
|
||
if (ss.Length() <= 1)
|
||
{
|
||
return;
|
||
}
|
||
|
||
//轴线分组
|
||
CArray<PickSet,PickSet> ssArray;
|
||
PickSet ssTmp(SS_CREATE);
|
||
ssTmp += ss[0L];
|
||
ssArray.Add(ssTmp);
|
||
|
||
for (long i = 1; i < ss.Length(); i++)
|
||
{
|
||
BOOL bFlag = FALSE;
|
||
Entity ent=ss[i];
|
||
OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbLine, pLineNew);
|
||
if (pLineNew)
|
||
{
|
||
AcGeVector3d vect=pLineNew->endPoint()-pLineNew->startPoint();
|
||
|
||
for (long j=0; j<ssArray.GetSize();j++)
|
||
{
|
||
PickSet eName(SS_FREE);
|
||
eName += ssArray[j];
|
||
|
||
long size=eName.Length();
|
||
for (long k=0;k<size;k++)
|
||
{
|
||
Entity en = eName[k];
|
||
OPENOBJ_BEGIN(en, AcDb::kForRead, AcDbLine, pLine);
|
||
if (pLine)
|
||
{
|
||
AcGeVector3d dir=pLine->endPoint()-pLine->startPoint();
|
||
if (dir.isParallelTo(vect))
|
||
{
|
||
ssArray[j] += ent;
|
||
|
||
bFlag = TRUE;
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
if (j == ssArray.GetSize()-1)
|
||
{
|
||
PickSet sName(SS_CREATE);
|
||
sName += ent;
|
||
int aa=sName.Length();
|
||
ssArray.Add(sName);
|
||
|
||
bFlag = TRUE;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
if (bFlag)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
|
||
//删除只有一条线的选择集
|
||
for (i = 0;i < ssArray.GetSize();i++)
|
||
{
|
||
if (ssArray[i].Length() <= 1)
|
||
{
|
||
ssArray.RemoveAt(i);
|
||
i--;
|
||
}
|
||
}
|
||
|
||
//计算外包边界
|
||
PickSet delEnt(SS_FREE);
|
||
for (i = 0;i < ssArray.GetSize();i++)
|
||
{
|
||
int c=ssArray[i].Length();
|
||
if (ssArray[i].Length() <= 1)
|
||
{
|
||
continue;
|
||
}
|
||
else
|
||
{
|
||
BOOL bFlag=FALSE; //是否打开实体
|
||
double rotAng=0.0;
|
||
|
||
Entity ent=ssArray[i][0L];
|
||
OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbLine, pLineNew);
|
||
if (pLineNew)
|
||
{
|
||
AcGeVector3d vect=pLineNew->endPoint()-pLineNew->startPoint();
|
||
rotAng = AcGeVector3d::kXAxis.angleTo(vect,AcGeVector3d::kZAxis);
|
||
bFlag = TRUE;
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
if (bFlag)
|
||
{
|
||
ads_matrix mat,matInv;
|
||
XPoint().GetRotationMatrix(-rotAng,mat);
|
||
AT_amatrix(mat,matInv);
|
||
|
||
ssArray[i].Transform(mat);
|
||
|
||
ads_point lowPt,upPt;
|
||
ssArray[i]. GetExtend(lowPt, upPt);
|
||
|
||
PickSet ssNew(SS_CREATE);
|
||
ssNew.IncludeBegin();
|
||
|
||
AcDbLine *line=new AcDbLine(asPnt3d(lowPt),AcGePoint3d(lowPt[0],upPt[1],lowPt[2]));
|
||
if (line)
|
||
{
|
||
line->setColorIndex(6);
|
||
AddToModelSpace(line,TRUE);
|
||
}
|
||
else
|
||
{
|
||
delete line;
|
||
}
|
||
AcDbLine *line2=new AcDbLine(asPnt3d(upPt),AcGePoint3d(upPt[0],lowPt[1],upPt[2]));
|
||
if (line)
|
||
{
|
||
line2->setColorIndex(6);
|
||
AddToModelSpace(line2,TRUE);
|
||
}
|
||
else
|
||
{
|
||
delete line2;
|
||
}
|
||
ssNew.IncludeEnd();
|
||
ssArray[i].Transform(matInv);
|
||
ssNew.Transform(matInv);
|
||
delEnt += ssNew;
|
||
}
|
||
}
|
||
}
|
||
|
||
//确定对齐边界
|
||
for (i = 0;;i++)
|
||
{
|
||
Entity enSel;
|
||
RBList rbMask2(RTDXF0, _T("LINE"), NULL);
|
||
int stat = enSel.FilterSelect(_T("\n请选择对齐边界<退出>:"),rbMask2);
|
||
if (stat == RTCAN || stat == RTERROR)
|
||
{
|
||
break;
|
||
}
|
||
else if (stat == RTNORM)
|
||
{
|
||
if (delEnt.IsInclude(enSel))
|
||
{
|
||
long j=0;
|
||
for (;j<delEnt.Length();j++)
|
||
{
|
||
if (enSel == delEnt[j])
|
||
{
|
||
AlignLine(ssArray[j/2],enSel);
|
||
break;
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
delEnt.Erase();
|
||
}
|
||
|
||
|
||
|
||
/////////////////////////////////////////////
|
||
// 命令：轴网合并
|
||
void MergeAxis()
|
||
{
|
||
g_ssPickFirst.Free();
|
||
|
||
PickSet ss(SS_CREATE);
|
||
XString sLayer;
|
||
sLayer<<_T("DOTE,")<<LAY_AXIS;
|
||
|
||
RBList mask(RTDXF0, _T("LINE"), 8, (const TCHAR*)sLayer, NULL);
|
||
int nRet = SelectEntities(_T("\n请选择需要合并对齐的轴线<退出>:"),ss,mask);
|
||
if (nRet != RTNORM)
|
||
{
|
||
return;
|
||
}
|
||
|
||
// if (!RemoveDupLine(ss))
|
||
if (!TchDupAxis::RemoveDupAxis(ss))
|
||
{
|
||
return;
|
||
}
|
||
|
||
PickSet ssEnt(SS_CREATE);
|
||
ssEnt += ss;
|
||
AlignAxis(ssEnt);
|
||
}
|
||
|
||
|
||
/*
|
||
// 对齐轴线
|
||
void AlignAxis()
|
||
{
|
||
XString sLayer;
|
||
sLayer<<_T("DOTE,")<<LAY_AXIS;
|
||
RBList mask(RTDXF0, _T("LINE"), 8, (const TCHAR*)sLayer, NULL);
|
||
|
||
while (1)
|
||
{
|
||
PickSet ss(SS_FREE);
|
||
int nRet = SelectEntities(_T("\n选择要对齐的轴线<退出>:"),ss,mask);
|
||
if (nRet == RTCAN||nRet == RTNONE||nRet == RTERROR)
|
||
break;
|
||
else if (nRet != RTNORM)
|
||
continue;
|
||
|
||
if (ss.Length() < 1)
|
||
continue;
|
||
|
||
//确定对齐边界
|
||
XPoint ptStart,ptEnd;
|
||
while (1)
|
||
{
|
||
nRet = ads_getpoint(NULL, _T("\n请输入轴线对齐边界线起点<退出>:"), ptStart);
|
||
if (nRet == RTCAN||nRet == RTNONE)
|
||
return;
|
||
else if (nRet != RTNORM)
|
||
continue;
|
||
else
|
||
{
|
||
while (1)
|
||
{
|
||
nRet = ads_getpoint(ptStart, _T("\n请输入轴线对齐边界线终点<退出>:"), ptEnd);
|
||
if (nRet == RTCAN||nRet == RTNONE)
|
||
return;
|
||
else if (nRet != RTNORM)
|
||
continue;
|
||
else
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (ptStart.Distance(ptEnd) < 1.0E-6)
|
||
{
|
||
adsout<<_T("\n无法进行操作!");
|
||
return;
|
||
}
|
||
|
||
AcGeVector3d vect=ptEnd.AsAcGePoint3d() - ptStart.AsAcGePoint3d();
|
||
vect.normalize();
|
||
|
||
AcDbLine *pLine=new AcDbLine(ptStart.AsAcGePoint3d()+vect*100000.0,ptStart.AsAcGePoint3d()-vect*100000.0);
|
||
if (pLine)
|
||
{
|
||
AddToModelSpace(pLine,FALSE);
|
||
pLine->downgradeOpen();
|
||
|
||
for (long i=0;i<ss.Length();i++)
|
||
{
|
||
AcGePoint3d ptTmp;
|
||
Entity ent=ss[i];
|
||
OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbLine, pLineNew);
|
||
|
||
if (pLineNew)
|
||
{
|
||
AcGePoint3dArray ptInt;
|
||
pLineNew->intersectWith(pLine,AcDb::kExtendBoth,ptInt);
|
||
if (ptInt.length()>0)//修改线端点
|
||
{
|
||
pLineNew->upgradeOpen();
|
||
if (pLineNew->endPoint().distanceTo(ptInt[0])
|
||
<= pLineNew->startPoint().distanceTo(ptInt[0]))
|
||
{
|
||
pLineNew->setEndPoint(ptInt[0]);
|
||
}
|
||
else
|
||
{
|
||
pLineNew->setStartPoint(ptInt[0]);
|
||
}
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
|
||
pLine->upgradeOpen();
|
||
pLine->erase(TRUE);
|
||
pLine->close();
|
||
}
|
||
else
|
||
{
|
||
delete pLine;
|
||
}
|
||
}
|
||
}
|
||
*/
|
||
|
||
// 从当前图层标准文件LAYERDEF.DAT中，获取“轴线”图层名
|
||
CString GetAxisLayerName()
|
||
{
|
||
// 当前图层标准文件名
|
||
CString csFileName = _T("layerdef.dat");
|
||
|
||
// Zyu modify on 100730，适应64位平台的文件夹名称变化
|
||
// 完整路径
|
||
//CString csFullPath = g_sAppPath;
|
||
//csFullPath = csFullPath.Left(csFullPath.GetLength() - 7) + _T("\\sys\\") + csFileName;
|
||
CString csFullPath = g_sDwbPath;
|
||
csFullPath = csFullPath.Left(csFullPath.GetLength() - 5) + _T("\\sys\\") + csFileName;
|
||
|
||
// “轴线”图层名
|
||
CString csName;
|
||
|
||
CStdioFile file;
|
||
if (!file.Open(csFullPath, CFile::modeRead))
|
||
{
|
||
acutPrintf(CString(_T("\n打开文件 \"")) + csFullPath + _T("\" 失败!"));
|
||
return csName;
|
||
}
|
||
|
||
CString sString;
|
||
while (file.ReadString(sString)) // 逐行读取
|
||
{
|
||
TCHAR sKey[256] = _T("");
|
||
TCHAR sName[256] = _T("");
|
||
int nColor = 0;
|
||
TCHAR sLineType[256] = _T("");
|
||
TCHAR sNote[256] = _T("");
|
||
_stscanf(sString, _T("%s%s%d%s%s"), sKey, sName, &nColor, sLineType, sNote);
|
||
|
||
if (_tcscmp(sKey, _T("轴线")) != 0)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (_tcscmp(sName, _T("")) == 0)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
csName = sName; // 获取图层名称
|
||
break;
|
||
}
|
||
|
||
file.Close();
|
||
|
||
if (csName.IsEmpty())
|
||
{
|
||
acutPrintf(_T("\n获取轴线图层名称失败!"));
|
||
}
|
||
return csName;
|
||
}
|
||
|
||
// sg add 100511，增加对外部参照图纸的支持
|
||
void GetAllAxisLayerName(const CString &csLayerName, CStringArray &aryNames)
|
||
{
|
||
aryNames.Add(csLayerName); // 不存在外部参照图纸
|
||
|
||
// 获取所有图层名称
|
||
XSymbolList lstLayer(_T("LAYER"));
|
||
|
||
// 注：CAD里的外部参照图层，固定使用“|”，暂时写死
|
||
CString csFind = _T("|");
|
||
csFind += csLayerName;
|
||
|
||
// sg add 100811，追加需求，CAD里的外部参照图层，还有可能使用“$*$”符号
|
||
CString csFind2 = _T("$");
|
||
csFind2 += csLayerName;
|
||
|
||
int nLength = lstLayer.Length();
|
||
for (int i=0; i<nLength; i++)
|
||
{
|
||
CString csLayer = lstLayer[i];
|
||
if (csLayer.Find(csFind, 0) > -1) // 判断是否存在外部参照图纸
|
||
{
|
||
aryNames.Add(csLayer);
|
||
continue;
|
||
}
|
||
|
||
// sg add 100811，支持“$*$”类符号的外部参照图纸
|
||
// 注：有可能出现“轴网|$0$DOTE”和“$0$DOTE”两类情况，因此，只需要判断“$DOTE”即可，但有误差
|
||
if (csLayer.Find(csFind2, 0) > -1)
|
||
{
|
||
aryNames.Add(csLayer);
|
||
continue;
|
||
}
|
||
}
|
||
}
|
||
|
||
/////////////////////////////////////////////
|
||
// sg add 091223，新增命令：轴改线型
|
||
void Axis2Dote()
|
||
{
|
||
// 获取轴线图层名称
|
||
CString csLayerName = GetAxisLayerName();
|
||
if (csLayerName.IsEmpty())
|
||
{
|
||
return;
|
||
}
|
||
|
||
// 获取线型ID
|
||
AcDbObjectId idDote = InitLineType(_T("DOTE")),
|
||
idContinuous = InitLineType(_T("CONTINUOUS"));
|
||
if (idDote.isNull() || !idDote.isValid() || idContinuous.isNull() || !idContinuous.isValid())
|
||
{
|
||
acutPrintf(_T("\n创建线型失败! 请确认Acad.lin中包含指定线型!"));
|
||
return;
|
||
}
|
||
|
||
// 获得所有正确的图层名
|
||
CStringArray aryLayers;
|
||
GetAllAxisLayerName(csLayerName, aryLayers);
|
||
|
||
bool bFlag = true; // 判断是否所有图层名都不包含
|
||
CStringArray aryDotes, aryContinuous;
|
||
|
||
// 获取轴线图层ID
|
||
// Zyu modify on 100726，去掉编译警告
|
||
//int nLength = aryLayers.GetSize(),
|
||
// i(0);
|
||
int nLength = (int)aryLayers.GetSize(),
|
||
i(0);
|
||
for (i=0; i<nLength; i++)
|
||
{
|
||
csLayerName = aryLayers.GetAt(i);
|
||
|
||
AcDbObjectId idLayer = GetLayerIdFromString(csLayerName);
|
||
if (idLayer.isNull() || !idLayer.isValid())
|
||
{
|
||
continue;
|
||
}
|
||
|
||
|
||
OPENOBJ_BEGIN(idLayer, AcDb::kForRead, AcDbLayerTableRecord, pLayer);
|
||
if (pLayer == NULL)
|
||
{
|
||
continue;
|
||
}
|
||
// 获取当前线型名称
|
||
AcDbObjectId idCurType = pLayer->linetypeObjectId();
|
||
|
||
// modify by xly on 110303 获得线型的名称
|
||
//if (idCurType == idDote)
|
||
//{
|
||
// aryContinuous.Add(csLayerName); // 将变成CONTINUOUS线形
|
||
//}
|
||
//else
|
||
//{
|
||
// aryDotes.Add(csLayerName); // 将变成DOTE线形
|
||
//}
|
||
|
||
OPENOBJ_BEGIN(idCurType, AcDb::kForRead, AcDbLinetypeTableRecord, pLineType);
|
||
if (pLineType)
|
||
{
|
||
const TCHAR* sLineType = NULL;
|
||
pLineType->getName(sLineType);
|
||
CString csName = sLineType;
|
||
|
||
if (csName.Find(_T("DOTE"))>-1)
|
||
{
|
||
aryContinuous.Add(csLayerName); // 将变成CONTINUOUS线形
|
||
}
|
||
else
|
||
{
|
||
aryDotes.Add(csLayerName); // 将变成DOTE线形
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
bFlag = false;
|
||
OPENOBJ_END();
|
||
}
|
||
|
||
if (bFlag)
|
||
{
|
||
acutPrintf(_T("\n请确认轴线层与当前图层标准一致!"));
|
||
return;
|
||
}
|
||
|
||
// Zyu modify on 100726，强制转换，去除编译警告
|
||
//nLength = aryContinuous.GetSize();
|
||
nLength = (int)aryContinuous.GetSize();
|
||
if (nLength > 0)
|
||
{
|
||
csLayerName = aryContinuous.GetAt(0);
|
||
for (i=1; i<nLength; i++)
|
||
{
|
||
csLayerName += _T(",");
|
||
csLayerName += aryContinuous.GetAt(i);
|
||
}
|
||
|
||
SHads_command(RTSTR, _T("-layer"), RTSTR, _T("l"), RTSTR, _T("CONTINUOUS"), RTSTR, csLayerName, RTSTR, _T(""), RTNONE);
|
||
}
|
||
|
||
// Zyu modify on 100726，强制转换，去除编译警告
|
||
//nLength = aryDotes.GetSize();
|
||
nLength = (int)aryDotes.GetSize();
|
||
if (nLength > 0)
|
||
{
|
||
csLayerName = aryDotes.GetAt(0);
|
||
for (i=1; i<nLength; i++)
|
||
{
|
||
csLayerName += _T(",");
|
||
csLayerName += aryDotes.GetAt(i);
|
||
}
|
||
|
||
SHads_command(RTSTR, _T("-layer"), RTSTR, _T("l"), RTSTR, _T("DOTE"), RTSTR, csLayerName, RTSTR, _T(""), RTNONE);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/////////////////////////////////////////////
|
||
// [2010-4-20 wubo] 新增命令：轴号隐现
|
||
void ShowAndHideAxisDim()
|
||
{
|
||
static bool s_bHideAxisDim = true; // 保存是否“隐藏轴号”
|
||
static bool s_bSingleSideDim = true; // 保存是否“单侧操作”
|
||
|
||
// 所有的轴标集实体都显示隐藏的轴标
|
||
SetShowHiddenAxisLable(true);
|
||
|
||
TADSGePoint3d ptStart;
|
||
TADSGePoint3d ptEnd;
|
||
CString sPrompt;
|
||
|
||
//add by lgy 20120214 9.0将所有隐藏的轴号都能通过轴号隐现显示出来
|
||
BOOL bShow = TRUE; //由整侧不显示改为整侧中每一个轴号都不显示
|
||
|
||
while (true)
|
||
{
|
||
// 生成提示字符串，如：
|
||
// 请选择需隐藏的轴号或 [显示轴号(F)/设为双侧操作(Q), 当前: 单侧隐藏] <退出>:
|
||
sPrompt = _T("\n请选择需");
|
||
sPrompt += s_bHideAxisDim ? _T("隐藏") : _T("显示");
|
||
sPrompt += _T("的轴号或 [");
|
||
sPrompt += s_bHideAxisDim ? _T("显示") : _T("隐藏");
|
||
sPrompt += _T("轴号(F)/设为");
|
||
sPrompt += s_bSingleSideDim ? _T("双侧") : _T("单侧");
|
||
sPrompt += _T("操作(Q), 当前: ");
|
||
sPrompt += s_bSingleSideDim ? _T("单侧"): _T("双侧");
|
||
sPrompt += s_bHideAxisDim ? _T("隐藏") : _T("显示");
|
||
sPrompt += _T("] <退出>:");
|
||
|
||
int iRet = 0;
|
||
INITGET_BEG(0, _T("F Q"));
|
||
iRet = acedGetPoint(NULL, sPrompt, ptStart);
|
||
INITGET_END();
|
||
if (iRet == RTKWORD)
|
||
{
|
||
TCHAR szKey[132];
|
||
if (acedGetInput(szKey) != RTNORM)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (szKey[0] == _T('F') || szKey[0] == _T('f'))
|
||
{
|
||
s_bHideAxisDim = !s_bHideAxisDim;
|
||
}
|
||
else if (szKey[0] == _T('Q') || szKey[0] == _T('q'))
|
||
{
|
||
s_bSingleSideDim = !s_bSingleSideDim;
|
||
}
|
||
|
||
continue;
|
||
}
|
||
else if (iRet == RTNORM)
|
||
{
|
||
if (GetCornerPoint(ptStart, NULL, ptEnd) != RTNORM)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// 选择框选范围中的TDbAxisLabelSet对象
|
||
TGGePoly2D extentPoly = GetExtentPolyByTwoCorner(ptStart, ptEnd);
|
||
TRBList rbRegion = extentPoly.Polygon();
|
||
TPickEntSet ssAxisLable(SS_FREE);
|
||
if (ssAxisLable.Get(_T("CP"), rbRegion, NULL,
|
||
TRBList(RTDXF0, _T("ATS_AXIS_LABEL"), NULL)) != RTNORM)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
extentPoly.TransUCS(Groups(1), Groups(0));
|
||
|
||
long num = ssAxisLable.Length();
|
||
for (long i = 0; i < num; i++)
|
||
{
|
||
OPENOBJ_BEGIN(ssAxisLable[i], AcDb::kForWrite, TDbAxisLabelSet, pSet);
|
||
if (pSet == NULL)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
//add by lgy 20120214 9.0将所有隐藏的轴号都能通过轴号隐现显示出来
|
||
int iSide = -1;
|
||
if(pSet->GetHideSide() == ANF_HIDESIDE1)
|
||
{
|
||
iSide = 0;
|
||
}
|
||
else if (pSet->GetHideSide() == ANF_HIDESIDE2)
|
||
{
|
||
iSide = 1;
|
||
}
|
||
|
||
int iAxisCount = pSet->GetAxisNum();
|
||
for (int j = 0; j < iAxisCount; j++)
|
||
{
|
||
for (int k = 0; k <= 1; k++)
|
||
{
|
||
// 对于框选范围中的每个TDbAxisLabelSet对象，
|
||
// 判断其中的每个Label是否在框选范围内
|
||
TADSGePoint3d ptLabelCenter = pSet->GetLabelCenter(j, k);
|
||
int iRelativePosition = ptLabelCenter & extentPoly;
|
||
// 如果Label在框选范围内，则进行相应的显示或隐藏操作
|
||
if (iRelativePosition != PR_OUTSIDE)
|
||
{
|
||
//add by lgy 20120214 9.0将所有隐藏的轴号都能通过轴号隐现显示出来
|
||
if ((iSide == k)&&!s_bHideAxisDim&&bShow)
|
||
{
|
||
pSet->HideSide(k, FALSE);
|
||
for (int m = 0; m < iAxisCount; m++)
|
||
{
|
||
pSet->HideAxisLabel(m, k, TRUE);
|
||
}
|
||
bShow = FALSE;
|
||
}
|
||
|
||
// 单侧操作情况下，只设置本侧
|
||
if (s_bSingleSideDim)
|
||
{
|
||
pSet->HideAxisLabel(j, k, s_bHideAxisDim);
|
||
}
|
||
// 双侧操作情况下，设置两侧
|
||
else
|
||
{
|
||
pSet->HideAxisLabel(j, 0, s_bHideAxisDim);
|
||
pSet->HideAxisLabel(j, 1, s_bHideAxisDim);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 所有的轴标集实体都不显示隐藏的轴标
|
||
SetShowHiddenAxisLable(false);
|
||
}
|
||
|
||
|
||
|
||
// 判断轴号的主附
|
||
bool IsMajorNo(CString csLable)
|
||
{
|
||
int iIndex = csLable.Find(_T("/"));
|
||
if (iIndex>-1)
|
||
{
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// add by xly on 10415 查找第一个非自己的主轴号
|
||
int FindMajor(TDbAxisLabelSet *pSet, int nIndex)
|
||
{
|
||
int i =0;
|
||
CString csLabel;
|
||
int iLen = pSet->GetAxisNum();
|
||
for (i = 0; i<iLen; i++)
|
||
{
|
||
csLabel = pSet->GetLabel(i);
|
||
if (nIndex>-1)
|
||
{
|
||
if(!IsMajorNo(csLabel)&&i!=nIndex)
|
||
{
|
||
return i;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if(!IsMajorNo(csLabel))
|
||
{
|
||
return i;
|
||
}
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
// 查找轴网中第一个主轴号，返回主轴号的位置
|
||
int FindMajor(TDbAxisLabelSet *pSet)
|
||
{
|
||
int i =0;
|
||
CString csLabel;
|
||
int iLen = pSet->GetAxisNum();
|
||
for (i = 0; i<iLen; i++)
|
||
{
|
||
csLabel = pSet->GetLabel(i);
|
||
if(!IsMajorNo(csLabel))
|
||
{
|
||
return i;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
/////////////////////////////////////////////
|
||
// 命令：主附转换
|
||
void ExchangeAxisNo()
|
||
{
|
||
static bool s_bM2AAxisDim = true; // 保存是否“主轴号变附加轴号”
|
||
static bool s_bReAAxisDim = true; // 保存是否“重排轴号”
|
||
|
||
// sg add 100521，进入命令后，临时显示全部隐藏轴号
|
||
SetShowHiddenAxisLable(true);
|
||
|
||
int nRet = 0;
|
||
CString csPrompt;
|
||
TADSGePoint3d ptStart, ptEnd;
|
||
|
||
while (true)
|
||
{
|
||
// 生成提示字符串
|
||
// 请选择需主号变附的轴号或[附号变主(F)/设为不重排(Q), 当前: 重排]<退出>:
|
||
csPrompt = _T("\n请选择需");
|
||
csPrompt += s_bM2AAxisDim ? _T("主号变附") : _T("附号变主");
|
||
csPrompt += _T("的轴号或 [");
|
||
csPrompt += s_bM2AAxisDim ? _T("附号变主") : _T("主号变附");
|
||
csPrompt += _T("(F)/设为");
|
||
csPrompt += s_bReAAxisDim ? _T("不重排") : _T("重排");
|
||
csPrompt += _T("(Q), 当前: ");
|
||
csPrompt += s_bReAAxisDim ? _T("重排") : _T("不重排");
|
||
csPrompt += _T("] <退出>:");
|
||
|
||
INITGET_BEG(0, _T("F Q"));
|
||
nRet = acedGetPoint(NULL, csPrompt, ptStart);
|
||
INITGET_END();
|
||
if (nRet == RTKWORD) // 出现关键字
|
||
{
|
||
TCHAR szKey[132];
|
||
if (acedGetInput(szKey) != RTNORM)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (szKey[0] == _T('F') || szKey[0] == _T('f')) // 是否“主轴号变附加轴号”
|
||
{
|
||
s_bM2AAxisDim = !s_bM2AAxisDim;
|
||
}
|
||
else if (szKey[0] == _T('Q') || szKey[0] == _T('q')) // 是否“重排轴号”
|
||
{
|
||
s_bReAAxisDim = !s_bReAAxisDim;
|
||
}
|
||
|
||
continue;
|
||
}
|
||
|
||
if (nRet != RTNORM) // 退出
|
||
{
|
||
break;
|
||
}
|
||
|
||
// 获得框选范围
|
||
if (GetCornerPoint(ptStart, NULL, ptEnd) != RTNORM)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
TGGePoly2D extentPoly = GetExtentPolyByTwoCorner(ptStart, ptEnd);
|
||
TRBList rbRegion = extentPoly.Polygon();
|
||
|
||
// 在框选范围中，过滤TDbAxisLabelSet对象
|
||
TPickEntSet ssAxisLable(SS_FREE);
|
||
if (ssAxisLable.Get(_T("CP"), rbRegion, NULL, TRBList(RTDXF0, _T("ATS_AXIS_LABEL"), NULL)) != RTNORM)
|
||
{
|
||
continue;
|
||
}
|
||
extentPoly.TransUCS(Groups(1), Groups(0));
|
||
|
||
long lLabelsCount = ssAxisLable.Length();
|
||
if (lLabelsCount < 1)
|
||
{
|
||
continue; // 框选范围内，没有TDbAxisLabelSet对象
|
||
}
|
||
|
||
// 对框选范围中的每个TDbAxisLabelSet对象，进行检查、判断，确定是否在框选范围内
|
||
for (long l = 0; l < lLabelsCount; l++)
|
||
{
|
||
OPENOBJ_BEGIN(ssAxisLable[l], AcDb::kForRead, TDbAxisLabelSet, pSet);
|
||
if (pSet == NULL)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
int nSide = pSet->GetVisSides(); // 获取标注侧
|
||
if (nSide == 0)
|
||
{
|
||
continue; // 双侧都不标注
|
||
}
|
||
|
||
int nIndex = 0,
|
||
nTmpIndex = 0,
|
||
nAxisCount = pSet->GetAxisNum(); // 轴号数量
|
||
AcDbIntArray aryAxisInSel; // 保存选择到、需要变化的轴号索引
|
||
|
||
if (nSide == 1 || nSide == 3) // 只标第0侧，或双侧标注
|
||
{
|
||
TADSGePoint3d ptLabelCenter;
|
||
for (nIndex = 0; nIndex < nAxisCount; nIndex++)
|
||
{
|
||
ptLabelCenter = pSet->GetLabelCenter(nIndex, 0); // 获得标注点位置
|
||
if ((ptLabelCenter&extentPoly) != PR_OUTSIDE) // 判断Label点是否在框选范围内
|
||
{
|
||
if (!aryAxisInSel.find(nIndex, nTmpIndex))
|
||
{
|
||
aryAxisInSel.append(nIndex); // 找不到就添加
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (nSide == 2 || nSide == 3) // 只标第1侧，或双侧标注
|
||
{
|
||
TADSGePoint3d ptLabelCenter;
|
||
for (nIndex = 0; nIndex < nAxisCount; nIndex++)
|
||
{
|
||
ptLabelCenter = pSet->GetLabelCenter(nIndex, 1); // 获得标注点位置
|
||
if ((ptLabelCenter&extentPoly) != PR_OUTSIDE) // 判断Label点是否在框选范围内
|
||
{
|
||
if (!aryAxisInSel.find(nIndex, nTmpIndex))
|
||
{
|
||
aryAxisInSel.append(nIndex); // 找不到就添加
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 获取编号规则，变前项还是变后项
|
||
BOOL bChangePre = pSet->IsChangePreNum();
|
||
|
||
// modify by xly on 100816 解决选取第一个轴号为空时的错误处理，以及选择的第一个轴号是首个轴号时重排问题
|
||
//int nSelLength = aryAxisInSel.length(); // 保存总共选择了多少个轴号
|
||
//for (nIndex = 0; nIndex < nSelLength; nIndex++)
|
||
//{
|
||
// nTmpIndex = aryAxisInSel[nIndex];
|
||
//
|
||
// if (nTmpIndex == 0) // 获取到的轴号为第1根轴号，则获取其后面的一位内容，进行推导
|
||
// {
|
||
// if (nAxisCount > 1) // 多轴号
|
||
// {
|
||
//
|
||
// CString csLable = pSet->GetLabel(1);
|
||
|
||
// // 调用tch_kernal导出的推导轴号类，获取正确的标注内容
|
||
// XString csNext;
|
||
// XAxisNoParser parser(csLable, bChangePre);
|
||
// parser.GetPre(csNext, !s_bM2AAxisDim);
|
||
|
||
// if (pSet->upgradeOpen() == Acad::eOk)
|
||
// {
|
||
// pSet->SetLabel(0, csNext, s_bReAAxisDim);
|
||
// pSet->downgradeOpen();
|
||
// }
|
||
//
|
||
// }
|
||
// else // 单轴号
|
||
// {
|
||
// }
|
||
// }
|
||
// else // 获取到的轴号不是第1根轴号，则获取前其前面的一位内容，进行推导
|
||
// {
|
||
// CString csLable = pSet->GetLabel(nTmpIndex - 1);
|
||
|
||
// // 调用tch_kernal导出的推导轴号类，获取正确的标注内容
|
||
// XString csNext;
|
||
// XAxisNoParser parser(csLable, bChangePre);
|
||
// parser.GetNext(csNext, !s_bM2AAxisDim);
|
||
|
||
// if (pSet->upgradeOpen() == Acad::eOk)
|
||
// {
|
||
// pSet->SetLabel(nTmpIndex, csNext, s_bReAAxisDim);
|
||
// pSet->downgradeOpen();
|
||
// }
|
||
// }
|
||
//}
|
||
|
||
|
||
int nSelLength = aryAxisInSel.length(); // 保存总共选择了多少个轴号
|
||
if (nSelLength<1)
|
||
{
|
||
//return;
|
||
continue;
|
||
}
|
||
|
||
CString csLable, csNextLable;// 定义标记首根轴号，下一根轴号
|
||
bool bAxisStyle; // 定义标记轴号是否为分区轴号
|
||
|
||
// 获得第一个选择到的轴标
|
||
int iFirstNum = aryAxisInSel[0];
|
||
|
||
// 选择到的第一个轴标是首个轴标
|
||
if (iFirstNum<1)
|
||
{
|
||
// 查找主轴号
|
||
nIndex = FindMajor(pSet);
|
||
CString csLableFir = pSet->GetLabel(nIndex);
|
||
|
||
// modi fy by xly on 110414 修改带有首个轴号的主附变化
|
||
for (nIndex = 0; nIndex < nSelLength; nIndex++)
|
||
{
|
||
// 判断首跟轴号是否为空
|
||
csLable = pSet->GetLabel(nIndex);
|
||
if (csLable.IsEmpty())
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// 判断首根是否是附加轴号
|
||
bAxisStyle = IsMajorNo(csLable);
|
||
if (bAxisStyle)// 首根轴号是附加轴号
|
||
{
|
||
if (s_bM2AAxisDim)// 主变附
|
||
{
|
||
// 框选轴号是附加轴号，做主附转换重排，调整附加轴号顺序
|
||
if (s_bReAAxisDim)
|
||
{
|
||
int nPos = csLable.Find(_T('/'));
|
||
CString csOld = csLable.Right(csLable.GetLength()-nPos);
|
||
csNextLable.Format(_T("%d"),nSelLength-nIndex);
|
||
csLable = csNextLable;
|
||
csLable += csOld;
|
||
|
||
if (pSet->upgradeOpen() == Acad::eOk)
|
||
{
|
||
pSet->SetLabel(nIndex, csLable, FALSE);
|
||
pSet->downgradeOpen();
|
||
}
|
||
|
||
}
|
||
|
||
continue;
|
||
}
|
||
|
||
XAxisNoParser::GetRegion(csNextLable);
|
||
|
||
// 修改轴号
|
||
int unicode = (int)csLable.GetAt(csLable.GetLength()-1);
|
||
if (nIndex>0)
|
||
{
|
||
unicode++;
|
||
}
|
||
csLable.SetAt(csLable.GetLength()-1,(TCHAR)unicode);
|
||
int nPos = csLable.Find(_T('/'));
|
||
CString csNewLable = csLable.Right(csLable.GetLength()-nPos-1);
|
||
csNewLable.Remove(_T('0'));
|
||
csLable = csNewLable;
|
||
|
||
if (pSet->upgradeOpen() == Acad::eOk)
|
||
{
|
||
pSet->SetLabel(nIndex, csLable, s_bReAAxisDim);
|
||
// sg add 110614，由于底层限制，只能处理手工指定轴号为特殊的首个主轴号前的附加轴号
|
||
pSet->SetPreFirstAttachLabel(nIndex, FALSE);
|
||
pSet->downgradeOpen();
|
||
}
|
||
|
||
}
|
||
else// 轴号是主轴号
|
||
{
|
||
if (!s_bM2AAxisDim)// 附变主
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// 主变附
|
||
// 获得轴根轴的标号，判断是否有标号
|
||
csLable = pSet->GetLabel(nIndex);
|
||
if (csLable.IsEmpty())
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// 转化为符合的样式
|
||
csNextLable = csLableFir;
|
||
XAxisNoParser::GetRegion(csNextLable);
|
||
|
||
CString csKvalue;
|
||
if(s_bReAAxisDim)
|
||
{
|
||
csKvalue.Format(_T("%d"),nSelLength-nIndex);
|
||
csLable = csKvalue;
|
||
csLable += csNextLable;
|
||
}
|
||
else
|
||
{
|
||
csKvalue.Format(_T("%d/"),1);
|
||
csLable = csKvalue;
|
||
csLable += pSet->GetLabel(nIndex);
|
||
}
|
||
|
||
// 更新首个轴号的标号
|
||
if (pSet->upgradeOpen() == Acad::eOk)
|
||
{
|
||
pSet->SetLabel(nIndex, csLable, s_bReAAxisDim);
|
||
// sg add 110614，由于底层限制，只能处理手工指定轴号为特殊的首个主轴号前的附加轴号
|
||
pSet->SetPreFirstAttachLabel(nIndex, TRUE);
|
||
pSet->downgradeOpen();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else// 选择到的第一个轴标不是首个轴标
|
||
{
|
||
for (nIndex = 0; nIndex < nSelLength; nIndex++)
|
||
{
|
||
// 框选到的轴号
|
||
nTmpIndex = aryAxisInSel[nIndex];
|
||
|
||
// 判断自己的前一个是否为空
|
||
CString csPreSlef = pSet->GetLabel(nTmpIndex - 1);
|
||
if (csPreSlef.IsEmpty())
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// 判断本身是否为空
|
||
csLable = pSet->GetLabel(nTmpIndex);
|
||
if (csLable.IsEmpty())
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// add by xly on 11007 增加变化判断
|
||
if (IsMajorNo(csLable))// 附加轴号
|
||
{
|
||
if (s_bM2AAxisDim)// 主变附
|
||
{
|
||
continue;
|
||
}
|
||
}
|
||
else// 主轴号
|
||
{
|
||
if (!s_bM2AAxisDim)// 附变主
|
||
{
|
||
continue;
|
||
}
|
||
}
|
||
|
||
// 查找第一个主轴号的位置
|
||
int iIndex = FindMajor(pSet);
|
||
if (iIndex<0)// 不存在主轴号
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// add by xly on 110307 框选轴号为第一个主轴号
|
||
if (iIndex == nTmpIndex)
|
||
{
|
||
int nTrueFir = FindMajor(pSet,iIndex);
|
||
if (nTrueFir<0)// 不存在主轴号
|
||
{
|
||
continue;
|
||
}
|
||
//bool bIsFenQu = XAxisNoParser::GetRegion(pSet->GetLabel(nTrueFir));
|
||
// 更新首个轴号的标号
|
||
if (pSet->upgradeOpen() == Acad::eOk)
|
||
{
|
||
// 重排时，更新主轴号前面的所有轴号
|
||
if (s_bReAAxisDim)
|
||
{
|
||
int nPos = csPreSlef.Find(_T("/"));
|
||
int nTemp = nTmpIndex+1;
|
||
CString csTemp=_T("");
|
||
CString csRight = csPreSlef.Right(csPreSlef.GetLength()-nPos);
|
||
for (int i=0; i<nTmpIndex; i++)
|
||
{
|
||
csTemp.Format(_T("%d"),nTrueFir);
|
||
csPreSlef = csTemp;
|
||
csPreSlef += csRight;
|
||
pSet->SetLabel(i,csPreSlef,FALSE);
|
||
nTrueFir--;
|
||
}
|
||
csTemp.Format(_T("%d"),nTrueFir);
|
||
csPreSlef = csTemp;
|
||
csPreSlef += csRight;
|
||
}
|
||
else
|
||
{
|
||
csPreSlef = pSet->GetLabel(nTmpIndex);
|
||
CString csPre = _T("1/");
|
||
csPre += csPreSlef;
|
||
csPreSlef = csPre;
|
||
}
|
||
|
||
pSet->SetLabel(nTmpIndex, csPreSlef, s_bReAAxisDim);
|
||
pSet->downgradeOpen();
|
||
}
|
||
continue;
|
||
}
|
||
|
||
// 获得第一个主轴号的轴标
|
||
CString csMajorAxis = pSet->GetLabel(iIndex);
|
||
if (IsMajorNo(csPreSlef))// 判断前一个轴标是附加轴标
|
||
{
|
||
CString csTemp;
|
||
int iPos = csPreSlef.Find(_T("-"));
|
||
if (XAxisNoParser::GetRegion(csMajorAxis))// 判断主轴标的样式，带分区
|
||
{
|
||
if (iPos<0)// 前一个是不带分区的样式
|
||
{
|
||
// 将前一个轴标转化为符合的样式
|
||
csTemp = csPreSlef.Left(csPreSlef.Find(_T("/")));
|
||
csPreSlef = csTemp;
|
||
csPreSlef += csMajorAxis;
|
||
}
|
||
}
|
||
else// 主轴标不带分区
|
||
{
|
||
if (iPos>-1)// 前一个是带分区的样式
|
||
{
|
||
// 将前一个轴标转化为符合的样式
|
||
csTemp = csPreSlef.Left(csPreSlef.Find(_T("-")));
|
||
csPreSlef = csTemp;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 调用tch_kernal导出的推导轴号类，获取正确的标注内容
|
||
XString csNext;
|
||
XAxisNoParser parser(csPreSlef, bChangePre);
|
||
parser.GetNext(csNext, !s_bM2AAxisDim);
|
||
if (pSet->upgradeOpen() == Acad::eOk)
|
||
{
|
||
pSet->SetLabel(nTmpIndex, csNext, s_bReAAxisDim);
|
||
pSet->downgradeOpen();
|
||
}
|
||
}
|
||
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
}
|
||
|
||
// sg add 100521，退出命令时，恢复隐藏
|
||
SetShowHiddenAxisLable(false);
|
||
}
|
||
|
||
|
||
|
||
/////////////////////////////////////////////
|
||
// 命令：一轴多号
|
||
// xly add 100520
|
||
void MutiAxisLabel()
|
||
{
|
||
static bool s_bSelectAllAxisDim = true; // 保存是否“选中全部轴号”
|
||
static short s_nCloneRowNum = 1; // 保存“复制行数”
|
||
|
||
// add by xly on 100811 添加单、双侧创建多轴号
|
||
static bool s_bDoubleSide = true; // 保存是否双侧创建多轴号
|
||
|
||
XPushVar<int> osmode(_T("OSMODE"), 0); // 进入命令后，临时关闭OSMODE
|
||
SetShowHiddenAxisLable(true); // 进入命令后，临时显示全部隐藏轴号
|
||
|
||
int nRet(0);
|
||
TADSGePoint3d ptStart, ptEnd; // 框选模式的两个点
|
||
PickSet ssLabel(SS_FREE); // 保存用户选中的轴号标注对象
|
||
|
||
if (g_bIgnoreAttach)
|
||
{
|
||
acutPrintf(_T("\n当前: 忽略附加轴号。状态可在高级选项中修改。"));
|
||
}
|
||
else
|
||
{
|
||
acutPrintf(_T("\n当前: 不忽略附加轴号。状态可在高级选项中修改。"));
|
||
}
|
||
|
||
bool bFlag = true; // 标记是否需要关键字
|
||
|
||
// CString csPrompt = // 命令行提示
|
||
// s_bSelectAllAxisDim?_T("\n请选择已有轴号或[框选轴圈局部操作 (Q)] <退出>:"):_T("\n请选择已有轴号或[选中轴号整体操作 (Q)] <退出>:");
|
||
// 命令行提示
|
||
CString csPrompt;
|
||
|
||
while (true)
|
||
{
|
||
// add by xly on 100811 添加单、双侧创建多轴号
|
||
// 提示语的格式请选择已有轴号或[选中轴号整体操作（F）/单侧创建多号(Q)]<退出>:
|
||
csPrompt = _T("\n请选择已有轴号或["); // 命令行提示
|
||
csPrompt += s_bSelectAllAxisDim?_T("框选轴圈局部操作(F)"):_T("选中轴号整体操作(F)");
|
||
csPrompt += _T("/");
|
||
csPrompt += s_bDoubleSide?_T("单侧创建多号(Q)"):_T("双侧创建多号(Q)");
|
||
csPrompt += _T("]<退出>:");
|
||
|
||
if (bFlag) // 需要提示关键字
|
||
{
|
||
INITGET_BEG(0, _T("F Q"));
|
||
nRet = acedGetPoint(NULL, csPrompt, ptStart);
|
||
INITGET_END();
|
||
}
|
||
else // 不需要提示关键字
|
||
{
|
||
// add by xly on 110316 设置提示
|
||
csPrompt = _T("\n请选择已有轴号:");
|
||
nRet = acedGetPoint(NULL, csPrompt, ptStart);
|
||
}
|
||
|
||
if (nRet == RTKWORD) // 关键字
|
||
{
|
||
TCHAR szKey[132];
|
||
if (acedGetInput(szKey) != RTNORM)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// modify by xly on 100811 添加单、双侧创建多轴号
|
||
//if (szKey[0] == _T('Q') || szKey[0] == _T('q'))
|
||
//{
|
||
// s_bSelectAllAxisDim = !s_bSelectAllAxisDim;
|
||
// csPrompt = // 命令行提示
|
||
// s_bSelectAllAxisDim?_T("\n请选择已有轴号或[框选轴圈局部操作 (Q)] <退出>:"):_T("\n请选择已有轴号或[选中轴号整体操作 (Q)] <退出>:");
|
||
//}
|
||
|
||
if (szKey[0] == _T('F') || szKey[0] == _T('f'))// 框选还是整体
|
||
{
|
||
s_bSelectAllAxisDim = !s_bSelectAllAxisDim;
|
||
}
|
||
else if (szKey[0] == _T('Q') || szKey[0] == _T('q'))// 单侧还是双侧多轴号标注
|
||
{
|
||
s_bDoubleSide = !s_bDoubleSide;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
if (nRet != RTNORM) // 退出或操作结束
|
||
{
|
||
break;
|
||
}
|
||
// 输入另一个点
|
||
if (GetCornerPoint(ptStart, NULL, ptEnd) != RTNORM)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// 框选范围显示
|
||
TGGePoly2D poly = GetExtentPolyByTwoCorner(ptStart, ptEnd);
|
||
RBList rbRegion = poly.Polygon();
|
||
|
||
// 框选模式选择集
|
||
PickSet ssMouseSel(SS_FREE);
|
||
if (ssMouseSel.Get(_T("CP"), rbRegion, NULL, RBList(RTDXF0, _T("ATS_AXIS_LABEL"), NULL)) != RTNORM)
|
||
{
|
||
continue;
|
||
}
|
||
poly.TransUCS(Groups(1), Groups(0));
|
||
|
||
long l = 0,
|
||
lSelLength = ssMouseSel.Length(); // 选择集的长度
|
||
for (l = 0; l<lSelLength; l++)
|
||
{
|
||
Entity ent = ssMouseSel[l];
|
||
OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbAxisLabelSet, pSet);
|
||
if (pSet == NULL)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// 克隆实体
|
||
TDbAxisLabelSet *pNewAxis = (TDbAxisLabelSet *)pSet->clone();
|
||
|
||
int nSide = pNewAxis->GetVisSides(),
|
||
nTmpIndex = 0;
|
||
|
||
// 只对框选中的轴圈操作时，遍历实体，寻找框选到的轴号
|
||
int iNum = 0,
|
||
iAxisNumLength = pNewAxis->GetAxisNum();
|
||
|
||
if (s_bSelectAllAxisDim) // 选中一个轴圈对整体操作
|
||
{
|
||
// add by xly on 100811 添加单、双侧创建多轴号
|
||
if (!s_bDoubleSide) // 单侧创建多轴号
|
||
{
|
||
// modify by xly on 110315 对每个轴圈的中心判断，以便准确查找
|
||
//AcGePoint3d ptCen = pNewAxis->GetLabelCenter(0, 0);
|
||
//if((ptCen&poly) != PR_OUTSIDE)// 选中0侧
|
||
//{
|
||
// pNewAxis->HideSide(1,TRUE);
|
||
//}
|
||
//else // 选中1侧
|
||
//{
|
||
// pNewAxis->HideSide(0,TRUE);
|
||
//}
|
||
bool bIsFir(false);
|
||
for(iNum=0; iNum<iAxisNumLength; iNum++)
|
||
{
|
||
AcGePoint3d ptCen = pNewAxis->GetLabelCenter(iNum, 0);
|
||
if((ptCen&poly) != PR_OUTSIDE)// 选中0侧
|
||
{
|
||
bIsFir = true;
|
||
break;
|
||
}
|
||
|
||
}
|
||
if (bIsFir)
|
||
{
|
||
pNewAxis->HideSide(1,TRUE);
|
||
}
|
||
else
|
||
{
|
||
pNewAxis->HideSide(0,TRUE);
|
||
}
|
||
}
|
||
|
||
ssLabel += pNewAxis->AddToMSpace(Adesk::kFalse);
|
||
pNewAxis->downgradeOpen();
|
||
pNewAxis->highlight();
|
||
pNewAxis->close();
|
||
|
||
continue;
|
||
}
|
||
|
||
AcDbIntArray aryAxisInSel;
|
||
|
||
if (nSide == 1 || nSide == 3) // 只标第0侧，或双侧标注
|
||
{
|
||
TADSGePoint3d ptLabelCenter;
|
||
for (iNum = 0; iNum < iAxisNumLength; iNum++)
|
||
{
|
||
ptLabelCenter = pNewAxis->GetLabelCenter(iNum, 0);
|
||
if ((ptLabelCenter&poly) != PR_OUTSIDE) // 在框选范围外
|
||
{
|
||
// add by xly on 100811 添加单、双侧创建多轴号
|
||
if (!s_bDoubleSide)// 单侧创建多轴号
|
||
{
|
||
pNewAxis->HideSide(1,TRUE);
|
||
}
|
||
if (!aryAxisInSel.find(iNum, nTmpIndex)) // 找不到就添加
|
||
{
|
||
aryAxisInSel.append(iNum);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (nSide == 2 || nSide == 3) // 只标第1侧，或双侧标注
|
||
{
|
||
TADSGePoint3d ptLabelCenter;
|
||
for (iNum = 0; iNum < iAxisNumLength; iNum++)
|
||
{
|
||
ptLabelCenter = pNewAxis->GetLabelCenter(iNum, 1);
|
||
if ((ptLabelCenter&poly) != PR_OUTSIDE) // 在框选范围内
|
||
{
|
||
// add by xly on 100811 添加单、双侧创建多轴号
|
||
if (!s_bDoubleSide)// 单侧创建多轴号
|
||
{
|
||
pNewAxis->HideSide(0,TRUE);
|
||
}
|
||
|
||
if (!aryAxisInSel.find(iNum, nTmpIndex)) // 找不到就添加
|
||
{
|
||
aryAxisInSel.append(iNum);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
int nTemp = 0;
|
||
for (iNum = 0; iNum < iAxisNumLength; iNum++)
|
||
{
|
||
if (!aryAxisInSel.find(nTemp, nTmpIndex)) // 找不到，表示被选中，不删除
|
||
{
|
||
pNewAxis->RemoveLabel(iNum, FALSE);
|
||
iAxisNumLength--;
|
||
iNum--;
|
||
}
|
||
nTemp++;
|
||
}
|
||
ssLabel += pNewAxis->AddToMSpace(Adesk::kFalse);
|
||
pNewAxis->downgradeOpen();
|
||
pNewAxis->highlight();
|
||
pNewAxis->close();
|
||
OPENOBJ_END();
|
||
}
|
||
|
||
// delete by xly on 110316 提到前面设置
|
||
//csPrompt = _T("\n请选择已有轴号:");
|
||
bFlag = false;
|
||
}
|
||
|
||
long lNewAixLength = ssLabel.Length();
|
||
if (lNewAixLength <= 0) // 没有选中的轴号，命令结束
|
||
{
|
||
SetShowHiddenAxisLable(false); // 退出命令时，恢复隐藏
|
||
return;
|
||
}
|
||
|
||
// 等待用户输入复制排数
|
||
int iNclone = s_nCloneRowNum;
|
||
acedInitGet(RSG_NONEG + RSG_NOZERO, NULL); // 输入不允许0和负数
|
||
|
||
csPrompt.Format(_T("\n请输入复制排数<%d>:"), s_nCloneRowNum);
|
||
nRet = acedGetInt(csPrompt, &iNclone);
|
||
if (nRet == RTCAN)
|
||
{
|
||
ssLabel.Erase();
|
||
SetShowHiddenAxisLable(false); // 退出命令时，恢复隐藏
|
||
return;
|
||
}
|
||
s_nCloneRowNum = iNclone;
|
||
|
||
|
||
// 创建新对象，并修改位置
|
||
for (long l = 0; l<lNewAixLength; l++)
|
||
{
|
||
Entity ent = ssLabel[l];
|
||
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbAxisLabelSet, pAxisDim);
|
||
if (pAxisDim == NULL)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
int iAxisNumLength = pAxisDim->GetAxisNum();
|
||
if (g_bIgnoreAttach) // 根据高级选项中的设置，确定是否忽略附加轴号
|
||
{
|
||
for (int i = 0; i < iAxisNumLength; i++)
|
||
{
|
||
CString csLabel = pAxisDim->GetLabel(i);
|
||
const TCHAR *pSep = _tcschr(csLabel, _T('/'));
|
||
if (pSep != NULL)
|
||
{
|
||
if (pAxisDim->upgradeOpen() == Acad::eOk)
|
||
{
|
||
pAxisDim->RemoveLabel(i, FALSE);
|
||
i--;
|
||
iAxisNumLength--;
|
||
pAxisDim->downgradeOpen();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (iAxisNumLength < 1)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// 获取轴号标注位置
|
||
XCurveSegment seg = pAxisDim->GetAxis(0);
|
||
|
||
TADSGePoint3d ptSt = seg.GetStartPoint(),
|
||
ptEn = seg.GetEndPoint();
|
||
double dStartDirection = seg.IDirection(1),
|
||
dEndDirection = seg.IDirection(0);
|
||
|
||
// 获取标注半径、两侧引线长度
|
||
double dRadCir = pAxisDim->GetCirRadius(FALSE),
|
||
dStartLength = pAxisDim->GetLeaderLen(0, FALSE),
|
||
dEndLength = pAxisDim->GetLeaderLen(1, FALSE);
|
||
|
||
TADSGePoint3d ptNear, ptFar;
|
||
|
||
// 生成多轴号的行数
|
||
for (int j = 1; j<=s_nCloneRowNum; j++)
|
||
{
|
||
dStartLength += dRadCir * 2;
|
||
dEndLength += dRadCir * 2;
|
||
|
||
// 生成新轴标
|
||
TDbAxisLabelSet *pAxisClon = (TDbAxisLabelSet *)pAxisDim->clone();
|
||
|
||
|
||
// 获得一个轴网标注的信息，是否是圆弧轴网
|
||
if(pAxisClon->IsArcAxisNet())
|
||
{
|
||
if (pAxisClon->IsArcAxis()) // 标注弧轴线
|
||
{
|
||
// 圆弧起始点的切线方向
|
||
dStartDirection = seg.Direction(ptSt);
|
||
dEndDirection = seg.Direction(ptEn);
|
||
|
||
// 圆弧的bugle值
|
||
double dBulge = seg.GetBulge();
|
||
|
||
// 计算新圆弧的起始点
|
||
acutPolar(ptSt, PI+(dStartDirection), dStartLength, ptNear);
|
||
acutPolar(ptEn, (dEndDirection), dEndLength, ptFar);
|
||
|
||
// 新圆弧的curve
|
||
XCurveSegment segNewArc(ptNear,ptFar,dBulge,1);
|
||
|
||
pAxisClon->AddToMSpace(Adesk::kFalse);
|
||
pAxisClon->SetFirstAxis(segNewArc);
|
||
|
||
// 设置两册的引线长度都为0
|
||
pAxisClon->SetLeaderLen(0, 0.0, TRUE);
|
||
pAxisClon->SetLeaderLen(1, 0.0, TRUE);
|
||
// sg modify 110607，根据测试反馈，如果存在拉伸情况，需要逐个修改每一个引线长度
|
||
pAxisClon->SetLeaderLenOneByOne(0, 0, TRUE);
|
||
pAxisClon->SetLeaderLenOneByOne(1, 0, TRUE);
|
||
pAxisClon->close();
|
||
|
||
}
|
||
else // 圆弧轴网在直线上的标注
|
||
{
|
||
int nSideHide(-1);
|
||
// 只有一个的情况
|
||
if (iAxisNumLength==1)
|
||
{
|
||
acutPolar(ptSt, dStartDirection, dStartLength, ptNear);
|
||
acutPolar(ptEn, dEndDirection, dStartLength, ptFar);
|
||
seg.SetPoints(ptNear, ptFar);
|
||
|
||
nSideHide = pAxisDim->GetHideSide();
|
||
if (nSideHide==4)
|
||
{
|
||
pAxisClon->HideSide(0,TRUE);
|
||
}
|
||
else if (nSideHide==8)
|
||
{
|
||
pAxisClon->HideSide(1,TRUE);
|
||
}
|
||
|
||
// 设置两册的引线长度都为0
|
||
pAxisClon->SetLeaderLen(0, 0.0, TRUE);
|
||
pAxisClon->SetLeaderLen(1, 0.0, TRUE);
|
||
// sg modify 110607，根据测试反馈，如果存在拉伸情况，需要逐个修改每一个引线长度
|
||
pAxisClon->SetLeaderLenOneByOne(0, 0, TRUE);
|
||
pAxisClon->SetLeaderLenOneByOne(1, 0, TRUE);
|
||
pAxisClon->SetFirstAxis(seg);
|
||
pAxisClon->AddToMSpace(Adesk::kFalse);
|
||
|
||
pAxisClon->close();
|
||
}
|
||
else// 多于1个轴号的添加一轴多号
|
||
{
|
||
XCurveSegment cvSortBase; // 排序的基线
|
||
|
||
// 保存起始轴线
|
||
XCurveSegment curveFirst,curveFinal;
|
||
// 获得起始轴线的信息
|
||
int nIndex(0);
|
||
for (int i=0;i<2;i++)
|
||
{
|
||
XCurveSegment segTemp = pAxisDim->GetAxis(nIndex);
|
||
ptSt = segTemp.GetStartPoint();
|
||
ptEn = segTemp.GetEndPoint();
|
||
dStartDirection = segTemp.IDirection(1);
|
||
dEndDirection = segTemp.IDirection(0);
|
||
|
||
acutPolar(ptSt, dStartDirection, dStartLength, ptNear);
|
||
acutPolar(ptEn, dEndDirection, dStartLength, ptFar);
|
||
segTemp.SetPoints(ptNear, ptFar);
|
||
nIndex = iAxisNumLength-1;
|
||
if (i==0)
|
||
{
|
||
curveFirst = segTemp;
|
||
}
|
||
if (i==1)
|
||
{
|
||
curveFinal = segTemp;
|
||
}
|
||
}
|
||
|
||
// 建立圆弧轴网中直线的圆弧
|
||
XPoint ptAxisNetCen = pAxisDim->GetArcNetCenter();
|
||
double nAng1 = ads_angle(ptAxisNetCen, curveFirst.FarPoint(ptAxisNetCen));
|
||
double nAng2 = ads_angle(ptAxisNetCen, curveFinal.FarPoint(ptAxisNetCen));
|
||
if (XAxisDimSet::g_AntiClockWise == FALSE)
|
||
{
|
||
Exchange(nAng1, nAng2);
|
||
}
|
||
cvSortBase = XArc(ptAxisNetCen, ptAxisNetCen.Distance2d(curveFirst.FarPoint(ptAxisNetCen)),
|
||
nAng1, nAng2);
|
||
|
||
// 建立排序的轴网单侧
|
||
XAxisDimSet dimSet(&cvSortBase);
|
||
for (i=0;i<iAxisNumLength;i++)
|
||
{
|
||
XCurveSegment segTemp = pAxisDim->GetAxis(i);
|
||
ptSt = segTemp.GetStartPoint();
|
||
ptEn = segTemp.GetEndPoint();
|
||
dStartDirection = segTemp.IDirection(1);
|
||
dEndDirection = segTemp.IDirection(0);
|
||
|
||
acutPolar(ptSt, dStartDirection, dStartLength, ptNear);
|
||
acutPolar(ptEn, dEndDirection, dEndLength, ptFar);
|
||
segTemp.SetPoints(ptNear, ptFar);
|
||
dimSet.Append(new XCurveSegment(segTemp));
|
||
}
|
||
dimSet.QuickSort(XAxisDimSet::SortFunc);
|
||
|
||
// 创建新的轴标
|
||
TDbAxisLabelSet *pAxisDim1 = new TDbAxisLabelSet;
|
||
pAxisDim1->SetTextStyleId(InitTextStyle(TS_AXIS));
|
||
pAxisDim1->SetTextLayerId(InitLayer(LAY_AXIS_TEXT, FALSE));
|
||
pAxisDim1->ConvertFrom(dimSet,true);
|
||
pAxisDim1->SetLayoutRotation(Ucs2Wcs(0.0));
|
||
pAxisDim1->SetLeaderLen(0, 0.0, TRUE);
|
||
pAxisDim1->SetLeaderLen(1, 0.0, TRUE);
|
||
// sg modify 110607，根据测试反馈，如果存在拉伸情况，需要逐个修改每一个引线长度
|
||
pAxisClon->SetLeaderLenOneByOne(0, 0, TRUE);
|
||
pAxisClon->SetLeaderLenOneByOne(1, 0, TRUE);
|
||
|
||
// 判断原有轴号的隐藏信息
|
||
nSideHide = pAxisDim->GetHideSide();
|
||
if (nSideHide==4)// 起始侧隐藏
|
||
{
|
||
pAxisDim1->HideSide(0,TRUE);
|
||
}
|
||
else if (nSideHide==8)// 终止侧隐藏
|
||
{
|
||
pAxisDim1->HideSide(1,TRUE);
|
||
}
|
||
|
||
|
||
pAxisDim1->SetLabel(0,pAxisDim->GetLabel(0),TRUE);
|
||
|
||
// add by xly on 110418 解决一周多号顺时针排序不正确的问题
|
||
if(XAxisDimSet::g_AntiClockWise==FALSE)
|
||
{
|
||
pAxisDim1->ReverseOrder();
|
||
}
|
||
pAxisDim1->AddToMSpace(Adesk::kTrue);
|
||
}
|
||
}
|
||
}
|
||
else // 直线轴网
|
||
{
|
||
acutPolar(ptSt, dStartDirection, dStartLength, ptNear);
|
||
acutPolar(ptEn, dEndDirection, dEndLength, ptFar);
|
||
|
||
seg.SetPoints(ptNear, ptFar);
|
||
|
||
pAxisClon->AddToMSpace(Adesk::kFalse);
|
||
pAxisClon->SetFirstAxis(seg);
|
||
|
||
// 设置两册的引线长度都为0
|
||
pAxisClon->SetLeaderLen(0, 0.0, TRUE);
|
||
pAxisClon->SetLeaderLen(1, 0.0, TRUE);
|
||
// sg modify 110607，根据测试反馈，如果存在拉伸情况，需要逐个修改每一个引线长度
|
||
pAxisClon->SetLeaderLenOneByOne(0, 0, TRUE);
|
||
pAxisClon->SetLeaderLenOneByOne(1, 0, TRUE);
|
||
|
||
pAxisClon->close();
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
|
||
SetShowHiddenAxisLable(false); // 退出命令时，恢复隐藏
|
||
ssLabel.Erase();
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////
|
||
// 命令：单根轴线
|
||
// sg add 110928，根据结构专业的需求，增加单根轴线的功能
|
||
void TAxislineCmd()
|
||
{
|
||
}
|