966 lines
24 KiB
C++
966 lines
24 KiB
C++
#include "StdAfx.h"
|
|
#include "globalFunc.h"
|
|
#include "XDbOsnapPoint.h"
|
|
#include "rbgroups.h"
|
|
#include "AcDbObjectPtr.h"
|
|
#include "SHAcDbBlockTableRecPtr.h"
|
|
#include "GeCurveInline.h"
|
|
|
|
bool g_bAssisitantSnap = true; // 是否使用辅助捕捉
|
|
|
|
int GetSnapPoint(double *ptFrom, const TCHAR *prompt, XPoint &pt, int nFlag, double dAngle,
|
|
const TCHAR *pKeyWord, int *pNKeyIndex, bool bCloseSnap)
|
|
{
|
|
bool bSnapOpen = false; // cad捕捉是否打开
|
|
if (bCloseSnap) // 关闭cad捕捉
|
|
{
|
|
int nOsMode;
|
|
GlobalFunc::TGGetVar(_T("OSMODE"), &nOsMode); // cad当前捕捉状态
|
|
bSnapOpen = (nOsMode & 0x4000) > 0;
|
|
if (bSnapOpen)
|
|
{
|
|
nOsMode |= 0x4000;
|
|
GlobalFunc::TGSetVar(_T("OSMODE"), nOsMode);
|
|
}
|
|
}
|
|
XOsPointEdJig jig;
|
|
jig.SetKeyWord(pKeyWord);
|
|
jig.SetPrompt(prompt);
|
|
jig.SetptTo(pt);
|
|
jig.SetUsageFlag(nFlag);
|
|
if(ptFrom)
|
|
jig.SetptFrom(ptFrom);
|
|
jig.SetRectAngle(dAngle);
|
|
jig.doIt();
|
|
|
|
int nKeyword = -1;
|
|
int nRetCode=jig.GetRetCode(&nKeyword);
|
|
if(nRetCode==RTNORM)
|
|
{
|
|
pt = jig.GetptTo();
|
|
}
|
|
else if (nRetCode == RTKWORD && pNKeyIndex != NULL)
|
|
{
|
|
*pNKeyIndex = nKeyword;
|
|
}
|
|
// 打开cad捕捉
|
|
if (bSnapOpen)
|
|
{
|
|
int nOsMode;
|
|
GlobalFunc::TGGetVar(_T("OSMODE"), &nOsMode); // cad当前捕捉状态
|
|
nOsMode &= ~0x4000;
|
|
GlobalFunc::TGSetVar(_T("OSMODE"), nOsMode);
|
|
}
|
|
|
|
return nRetCode;
|
|
}
|
|
|
|
int SelRectByWall(double dAngle,double& dLength,double& dWidth)
|
|
{
|
|
|
|
int nRet = 0;
|
|
XPoint ptStart,ptEnd;
|
|
CString sPrompt1 = _T("\n请输入起始点<退出>:");
|
|
|
|
|
|
int nKeyIndex = 0;
|
|
nRet = GetSnapPoint(NULL,sPrompt1,ptStart,0,0.0,NULL,NULL,false);
|
|
if (nRet == RTNORM)
|
|
{
|
|
nRet = GetSnapPoint(ptStart,_T("\n选择终点<退出>:"),ptEnd,2,dAngle,NULL,NULL,false);
|
|
if (nRet == RTNORM)
|
|
{
|
|
AcGeVector3d vtX = AcGeVector3d::kXAxis;
|
|
vtX.rotateBy(GlobalFunc::Wcs2Ucs(dAngle),AcGeVector3d::kZAxis);
|
|
AcGeVector3d vtDir = ptEnd - ptStart;
|
|
double dDist = ptEnd.Distance(ptStart);
|
|
double dAng = vtDir.angleTo(vtX);
|
|
|
|
dLength = fabs(dDist * cos(dAng));
|
|
dWidth = fabs(dDist * sin(dAng));
|
|
}
|
|
}
|
|
return nRet;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
// 获取输入点, 自动进行模糊捕捉 bCloseSnap控制cad捕捉的开关 nFlag(0--不带橡皮巾; 1--待橡皮巾; 2--矩形拖曳)
|
|
int GetSnapPoint(double *ptFrom, const TCHAR *prompt, XPoint &pt, int nFlag = 0, double dAngle = 0.0,const TCHAR *pKeyWord = NULL, int *pNKeyIndex = NULL, bool bCloseSnap = true)
|
|
{
|
|
bool bSnapOpen = false; // cad捕捉是否打开
|
|
if (bCloseSnap) // 关闭cad捕捉
|
|
{
|
|
int nOsMode;
|
|
GlobalFunc::TGGetVar(_T("OSMODE"), &nOsMode); // cad当前捕捉状态
|
|
bSnapOpen = (nOsMode & 0x4000) > 0;
|
|
if (bSnapOpen)
|
|
{
|
|
nOsMode |= 0x4000;
|
|
GlobalFunc::TGSetVar(_T("OSMODE"), nOsMode);
|
|
}
|
|
}
|
|
XOsPointEdJig jig;
|
|
jig.SetKeyWord(pKeyWord);
|
|
jig.SetPrompt(prompt);
|
|
jig.SetptTo(pt);
|
|
jig.SetUsageFlag(nFlag);
|
|
if(ptFrom)
|
|
jig.SetptFrom(ptFrom);
|
|
jig.SetRectAngle(dAngle);
|
|
jig.doIt();
|
|
|
|
int nKeyword = -1;
|
|
int nRetCode=jig.GetRetCode(&nKeyword);
|
|
if(nRetCode==RTNORM)
|
|
{
|
|
pt = jig.GetptTo();
|
|
}
|
|
else if (nRetCode == RTKWORD && pNKeyIndex != NULL)
|
|
{
|
|
*pNKeyIndex = nKeyword;
|
|
}
|
|
// 打开cad捕捉
|
|
if (bSnapOpen)
|
|
{
|
|
int nOsMode;
|
|
GlobalFunc::TGGetVar(_T("OSMODE"), &nOsMode); // cad当前捕捉状态
|
|
nOsMode &= ~0x4000;
|
|
GlobalFunc::TGSetVar(_T("OSMODE"), nOsMode);
|
|
}
|
|
|
|
return nRetCode;
|
|
}
|
|
*/
|
|
|
|
///////////////////////////////////////////
|
|
const int g_nSnapPixelNum = 10; // 捕捉点距离
|
|
// 捕捉端点
|
|
bool SnapEnd(DList<XCurveSegment> &lst, const XRectAngle &box, XPoint &ptWcs);
|
|
// 捕捉最近点
|
|
bool SnapNear(DList<XCurveSegment> &lst, XPoint &ptWcs, XCurveSegment &seg);
|
|
// 捕捉交点
|
|
bool SnapInt(DList<XCurveSegment> &lst, XPoint &ptWcs);
|
|
// 获得区域内指定的实体信息
|
|
void GetXCurveSegment(const XPoint &ptLow, const XPoint &ptUp, DList<XCurveSegment> &lst);
|
|
// 自动捕捉点
|
|
int AutoSnapPoint(XPoint &ptWcs, XPoint *ptBase=NULL);
|
|
// nOsShape: 0--没有捕捉; 1--墙基线端点; 2--轴线交点; 3--墙基线最近点; 4--轴线最近点
|
|
int AsOsnapMask(int nOsShape);
|
|
// 需要捕捉的实体
|
|
void GetSnapEntity(DList<AcRxClass> &lstClass);
|
|
|
|
// nOsShape: 0--没有捕捉; 1--端点; 2--交点; 3--最近点; 4--垂足
|
|
// 对应: 的捕捉代码
|
|
int AsOsnapMask(int nOsShape)
|
|
{
|
|
int nRet=0;
|
|
switch(nOsShape)
|
|
{
|
|
case 1:
|
|
nRet=AcDb::kOsMaskEnd;
|
|
break;
|
|
case 2:
|
|
nRet=AcDb::kOsMaskInt;
|
|
break;
|
|
case 3:
|
|
nRet=AcDb::kOsMaskNear;
|
|
break;
|
|
case 4:
|
|
nRet=AcDb::kOsMaskPerp;
|
|
break;
|
|
}
|
|
return nRet;
|
|
}
|
|
|
|
// 捕捉顺序: 端点,交点,垂足,最近点
|
|
// ptWcs -- I/O
|
|
// 返回: 0--没有捕捉; 1--端点; 2--交点; 3--最近点; 4--垂足
|
|
int AutoSnapPoint(XPoint &ptWcs, XPoint *ptBase)
|
|
{
|
|
double nApertureWcs=GlobalFunc::GetApertureWcs();
|
|
if(nApertureWcs<1.0E-6)
|
|
return 0;
|
|
int bSnap=0;
|
|
XPoint vtSnap(nApertureWcs, nApertureWcs);
|
|
XPoint ptLow=ptWcs-vtSnap;
|
|
XPoint ptUp = ptWcs+vtSnap;
|
|
|
|
// 获取需要获得捕捉点的线
|
|
DList<XCurveSegment> lst;
|
|
GetXCurveSegment(ptLow, ptUp, lst);
|
|
bool bNearWall = lst.Length() > 0 ? true : false;
|
|
|
|
XRectAngle box(ptLow, ptUp);
|
|
if(bNearWall) // 端点
|
|
if(SnapEnd(lst, box, ptWcs))
|
|
bSnap = 1;
|
|
|
|
if (!bSnap && bNearWall) // 交点
|
|
{
|
|
if (SnapInt(lst, ptWcs))
|
|
{
|
|
bSnap = 2;
|
|
}
|
|
}
|
|
|
|
XCurveSegment seg;
|
|
if(!bSnap && bNearWall)
|
|
{
|
|
Entity entNear;
|
|
XPoint ptCursor=ptWcs;
|
|
if(SnapNear(lst, ptWcs, seg)) // 最近点
|
|
{
|
|
bSnap = 3;
|
|
AcDbCurve *pCurve = seg.AsAcDbCurve();
|
|
if (pCurve != NULL && ptBase)
|
|
{
|
|
AcGePoint3d pt((*ptBase)[0], (*ptBase)[1], (*ptBase)[2]);
|
|
AcGePoint3d ptPrj;
|
|
if (pCurve->getClosestPointTo(pt, ptPrj) == Acad::eOk)
|
|
{
|
|
double nIntAng=GlobalFunc::AngleRangeToPI(ads_angle(*ptBase, XPoint(ptPrj))-ads_angle(*ptBase, ptCursor));
|
|
if((ptPrj&(seg))==PR_INSIDE && nIntAng<5.0*PI/180.0) // 垂足
|
|
{
|
|
bSnap=4;
|
|
ptWcs=ptPrj;
|
|
}
|
|
}
|
|
delete pCurve;
|
|
pCurve = NULL;
|
|
}
|
|
}
|
|
}
|
|
return bSnap;
|
|
}
|
|
|
|
// 捕捉墙的端点
|
|
bool SnapEnd(DList<XCurveSegment> &lst, const XRectAngle &box, XPoint &ptWcs)
|
|
{
|
|
bool bRet = false;
|
|
XPoint ptNearest;
|
|
double nMinDist=0.0;
|
|
long nCount = lst.Length();
|
|
AcGePoint3d ptS, ptE;
|
|
XPoint ptEnd[2];
|
|
for(long i = 0L; i < nCount; i++)
|
|
{
|
|
ptEnd[0] = lst[i]->StartPoint();
|
|
ptEnd[1] = lst[i]->EndPoint();
|
|
ptEnd[0].z = ptWcs.z;
|
|
ptEnd[1].z = ptWcs.z;
|
|
for(int n = 0; n < 2; n++)
|
|
{
|
|
if((ptEnd[n]&box) != PR_OUTSIDE)
|
|
{
|
|
double nDist = ptEnd[n].Distance(ptWcs);
|
|
if (nDist > GlobalFunc::PixelToWcs(g_nSnapPixelNum)) // 捕捉点距离限制
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if(bRet)
|
|
{
|
|
if(nDist < nMinDist)
|
|
{
|
|
nMinDist = nDist;
|
|
ptNearest = ptEnd[n];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nMinDist = nDist;
|
|
ptNearest = ptEnd[n];
|
|
bRet = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(bRet)
|
|
ptWcs=ptNearest;
|
|
return bRet;
|
|
}
|
|
|
|
// 捕捉最近点
|
|
bool SnapNear(DList<XCurveSegment> &lst, XPoint &ptWcs, XCurveSegment &seg)
|
|
{
|
|
bool bRet = false;
|
|
return bRet; // sr add 2012-3-7 暂时取消最近点
|
|
XPoint ptNearest;
|
|
double nMinDist=0.0;
|
|
AcDb::Intersect intType=AcDb::kOnBothOperands;
|
|
|
|
// 构造WCS到Dcs的转换矩阵
|
|
AcGeMatrix3d transWcsToDcs;
|
|
XPoint xAxesWcs(1,0,0), yAxesWcs(0,1,0), zAxesWcs(0,0,1),
|
|
xAxesDcs, yAxesDcs, zAxesDcs;
|
|
XPoint ptOrginWcs(0,0,0), ptOrginDcs(0,0,0);
|
|
RBGroups fromWcs(0), toDcs(2);
|
|
ads_trans(ptOrginWcs, (resbuf *)&fromWcs, (resbuf *)&toDcs, 0, ptOrginDcs);
|
|
ads_trans(xAxesWcs, (resbuf *)&fromWcs, (resbuf *)&toDcs, 1, xAxesDcs);
|
|
ads_trans(yAxesWcs, (resbuf *)&fromWcs, (resbuf *)&toDcs, 1, yAxesDcs);
|
|
ads_trans(zAxesWcs, (resbuf *)&fromWcs, (resbuf *)&toDcs, 1, zAxesDcs);
|
|
transWcsToDcs.setCoordSystem(ptOrginDcs, xAxesDcs, yAxesDcs, zAxesDcs);
|
|
|
|
XPoint ptLast;
|
|
for (int k = 0; k < lst.Length(); k++)
|
|
{
|
|
AcDbCurve *pCurve = lst[k]->AsAcDbCurve();
|
|
if(pCurve == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
AcGePoint3dArray points;
|
|
AcDbIntArray ar;
|
|
if(pCurve->getOsnapPoints(AcDb::kOsModeNear, 0, ptWcs, ptLast, transWcsToDcs, points, ar)==Acad::eOk)
|
|
{
|
|
int numPoints=points.length();
|
|
for(int i = 0; i < numPoints; i++)
|
|
{
|
|
XPoint ptCur = points[i];
|
|
ptCur.z = ptWcs.z;
|
|
double nDist = ptWcs.Distance(ptCur);
|
|
if (nDist > GlobalFunc::PixelToWcs(g_nSnapPixelNum)) // 捕捉点距离限制
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if(bRet)
|
|
{
|
|
if(nDist < nMinDist)
|
|
{
|
|
nMinDist = nDist;
|
|
ptNearest = ptCur;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nMinDist = nDist;
|
|
ptNearest = ptCur;
|
|
bRet = true;
|
|
}
|
|
}
|
|
|
|
if (numPoints > 0)
|
|
{
|
|
seg = *lst[k];
|
|
}
|
|
}
|
|
delete pCurve;
|
|
}
|
|
|
|
if(bRet)
|
|
{
|
|
ptWcs=ptNearest;
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
// 捕捉交点
|
|
bool SnapInt(DList<XCurveSegment> &lst, XPoint &ptWcs)
|
|
{
|
|
if (lst.Length() < 2)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool bRet = false;
|
|
XPoint ptNearest;
|
|
|
|
AcGePoint3dArray arrPts;
|
|
int nLen = lst.Length();
|
|
for(int i = 0; i < nLen - 1; i++)
|
|
{
|
|
AcDbCurve *pCurve1 = lst[i]->AsAcDbCurve();
|
|
if (pCurve1 == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
for (int j = i + 1; j < nLen - 1; j++)
|
|
{
|
|
AcDbCurve *pCurve2 = lst[j]->AsAcDbCurve();
|
|
if (pCurve2 == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
pCurve1->intersectWith(pCurve2, AcDb::kExtendBoth, arrPts);
|
|
}
|
|
}
|
|
|
|
double nMinDist=0.0;
|
|
int nInters=arrPts.length();
|
|
for(int k = 0; k < nInters; k++)
|
|
{
|
|
XPoint ptCur = arrPts[k];
|
|
double nDist = ptWcs.Distance(ptCur);
|
|
if (nDist > GlobalFunc::PixelToWcs(g_nSnapPixelNum)) // 捕捉点距离限制
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if(bRet)
|
|
{
|
|
if(nDist < nMinDist)
|
|
{
|
|
nMinDist = nDist;
|
|
ptNearest = ptCur;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nMinDist = nDist;
|
|
ptNearest = ptCur;
|
|
bRet=TRUE;
|
|
}
|
|
}
|
|
if(bRet)
|
|
ptWcs=ptNearest;
|
|
return bRet;
|
|
}
|
|
|
|
void GetSnapEntity(std::vector<AcRxClass*> &vecClass)
|
|
{
|
|
//vecClass.push_back(TDbWall::desc());
|
|
vecClass.push_back(AcDbLine::desc());
|
|
}
|
|
|
|
void GetXCurveSegment(const XPoint &ptLow, const XPoint &ptUp, DList<XCurveSegment> &lst)
|
|
{
|
|
// 获取实体
|
|
std::vector<AcRxClass*> vecClass;
|
|
GetSnapEntity(vecClass);
|
|
XCurvePickSet ss;
|
|
std::vector<AcRxClass*>::iterator it;
|
|
for (it = vecClass.begin(); it != vecClass.end(); it++)
|
|
{
|
|
GlobalFunc::GetSafeSelectionEx(ss, TRUE, ptLow, ptUp, *it);
|
|
}
|
|
|
|
// 得到实体中需要捕捉的线
|
|
Entity ent;
|
|
for (long i = 0; i < ss.Length(); i++)
|
|
{
|
|
ent = ss[i];
|
|
/*if (ent.Is(_T("ATS_WALL")))
|
|
{
|
|
OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbWall, pWall);
|
|
if (pWall != NULL)
|
|
{
|
|
XCurveSegment *pLeft = new XCurveSegment;
|
|
XCurveSegment *pRight = new XCurveSegment;
|
|
pWall->GetStandardCurve(*pLeft, *pRight);
|
|
lst.Append(pLeft);
|
|
lst.Append(pRight);
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
else*/ if (ent.Is(_T("LINE")))
|
|
{
|
|
OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbLine, pLine);
|
|
if (pLine != NULL)
|
|
{
|
|
XCurveSegment *pLeft = new XCurveSegment;
|
|
pLeft->SetLine(pLine->startPoint(), pLine->endPoint());
|
|
lst.Append(pLeft);
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
XDbOsnapPoint::XDbOsnapPoint(): m_nOsShape(0), m_pEntityEx(NULL)
|
|
, m_nFlag(0), m_dRectAngle(GlobalFunc::Ucs2Wcs(0.0)), m_bDrawSnap(true)
|
|
{
|
|
|
|
}
|
|
|
|
Adesk::Boolean XDbOsnapPoint::subWorldDraw(AcGiWorldDraw *mode)
|
|
{
|
|
DrawShape(mode);
|
|
if (m_pEntityEx != NULL)
|
|
{
|
|
m_pEntityEx->worldDraw(mode);
|
|
}
|
|
return Adesk::kFalse;
|
|
}
|
|
|
|
// 由于视窗的实体不能访问, 因此本函数目前没有使用
|
|
void XDbOsnapPoint::subViewportDraw(AcGiViewportDraw *mode)
|
|
{
|
|
DrawOsnapShape(mode);
|
|
}
|
|
|
|
// 绘制点的形状
|
|
void XDbOsnapPoint::DrawOsnapShape(AcGiViewportDraw *pVd)
|
|
{
|
|
AcGiViewDraw dc(NULL, pVd);
|
|
AcGePoint2d pixelArea;
|
|
pVd->viewport().getNumPixelsInUnitSquare(m_ptLoc,pixelArea);
|
|
double nAperture = 16/pixelArea.asVector().length();
|
|
if(nAperture<1.0E-6)
|
|
return;
|
|
XRectAngle box(m_ptLoc, nAperture, nAperture);
|
|
AcDbPolyline pline;
|
|
pVd->subEntityTraits().setColor(2);
|
|
double nWidth=1/pixelArea.asVector().length();
|
|
pline.setConstantWidth(nWidth);
|
|
|
|
ads_matrix mat;
|
|
m_ptLoc.GetRotationMatrix(GlobalFunc::Ucs2Wcs(0.0),mat);
|
|
//dc.SetColor(6); //用粉红色
|
|
switch(m_nOsShape)
|
|
{
|
|
case AcDb::kOsMaskEnd:
|
|
{
|
|
pline.addVertexAt(0, box.GetLowLeft().AsAcGePoint2d());
|
|
pline.addVertexAt(1, box.GetLowRight().AsAcGePoint2d());
|
|
pline.addVertexAt(2, box.GetUpRight().AsAcGePoint2d());
|
|
pline.addVertexAt(3, box.GetUpLeft().AsAcGePoint2d());
|
|
pline.setClosed(Adesk::kTrue);
|
|
//pline.viewportDraw(pVd);
|
|
XPoly2D poly1, poly2, poly;
|
|
GlobalFunc::PolyConvert(pline, poly);
|
|
poly.TransUCS(mat);//add by whl for ucs
|
|
poly.QuickOffset(-nWidth, poly1);
|
|
poly.QuickOffset(nWidth, poly2);
|
|
|
|
dc.DrawEntity(poly1.AsAcDbCurve());
|
|
dc.DrawEntity(poly2.AsAcDbCurve());
|
|
|
|
//dc << poly1 << poly2;
|
|
break;
|
|
}
|
|
case AcDb::kOsMaskInt:
|
|
{
|
|
pline.setClosed(Adesk::kFalse);
|
|
pline.addVertexAt(0, box.GetLowLeft().AsAcGePoint2d());
|
|
pline.addVertexAt(1, box.GetUpRight().AsAcGePoint2d());
|
|
XPoly2D poly1, poly2, poly;
|
|
GlobalFunc::PolyConvert(pline, poly);
|
|
poly.TransUCS(mat);//add by whl for ucs
|
|
poly.QuickOffset(-nWidth, poly1);
|
|
poly.QuickOffset(nWidth, poly2);
|
|
//dc << poly1 << poly2;
|
|
dc.DrawEntity(poly1.AsAcDbCurve());
|
|
dc.DrawEntity(poly2.AsAcDbCurve());
|
|
pline.reset(Adesk::kFalse, 0);
|
|
poly1.Reset(); poly2.Reset(); poly.Reset();
|
|
pline.addVertexAt(0, box.GetLowRight().AsAcGePoint2d());
|
|
pline.addVertexAt(1, box.GetUpLeft().AsAcGePoint2d());
|
|
GlobalFunc::PolyConvert(pline, poly);
|
|
poly.TransUCS(mat);//add by whl for ucs
|
|
poly.QuickOffset(-nWidth, poly1);
|
|
poly.QuickOffset(nWidth, poly2);
|
|
//dc << poly1 << poly2;
|
|
dc.DrawEntity(poly1.AsAcDbCurve());
|
|
dc.DrawEntity(poly2.AsAcDbCurve());
|
|
break;
|
|
}
|
|
case AcDb::kOsMaskNear:
|
|
{
|
|
pline.addVertexAt(0, box.GetLowLeft().AsAcGePoint2d());
|
|
pline.addVertexAt(1, box.GetLowRight().AsAcGePoint2d());
|
|
pline.addVertexAt(2, box.GetUpLeft().AsAcGePoint2d());
|
|
pline.addVertexAt(3, box.GetUpRight().AsAcGePoint2d());
|
|
pline.setClosed(Adesk::kTrue);
|
|
XPoly2D poly1, poly2, poly;
|
|
GlobalFunc::PolyConvert(pline, poly);
|
|
poly.TransUCS(mat);//add by whl for ucs
|
|
poly.QuickOffset(-nWidth, poly1);
|
|
poly.QuickOffset(nWidth, poly2);
|
|
//dc << poly1 << poly2;
|
|
dc.DrawEntity(poly1.AsAcDbCurve());
|
|
dc.DrawEntity(poly2.AsAcDbCurve());
|
|
break;
|
|
}
|
|
case AcDb::kOsMaskPerp:
|
|
{
|
|
pline.addVertexAt(0, box.GetUpLeft().AsAcGePoint2d());
|
|
pline.addVertexAt(1, box.GetLowLeft().AsAcGePoint2d());
|
|
pline.addVertexAt(2, box.GetLowRight().AsAcGePoint2d());
|
|
pline.setClosed(Adesk::kFalse);
|
|
XPoly2D poly1, poly2, poly;
|
|
GlobalFunc::PolyConvert(pline, poly);
|
|
poly.TransUCS(mat);//add by whl for ucs
|
|
poly.QuickOffset(-nWidth, poly1);
|
|
poly.QuickOffset(nWidth, poly2);
|
|
//dc << poly1 << poly2;
|
|
dc.DrawEntity(poly1.AsAcDbCurve());
|
|
dc.DrawEntity(poly2.AsAcDbCurve());
|
|
pline.reset(Adesk::kFalse, 0);
|
|
poly1.Reset(); poly2.Reset(); poly.Reset();
|
|
XPoint pt1, pt2;
|
|
Midpoint(box.GetUpLeft(), box.GetLowLeft(), pt1);
|
|
Midpoint(box.GetLowRight(), box.GetLowLeft(), pt2);
|
|
pline.addVertexAt(0, pt1.AsAcGePoint2d());
|
|
pline.addVertexAt(1, m_ptLoc.AsAcGePoint2d());
|
|
pline.addVertexAt(2, pt2.AsAcGePoint2d());
|
|
pline.setClosed(Adesk::kFalse);
|
|
GlobalFunc::PolyConvert(pline, poly);
|
|
poly.TransUCS(mat);//add by whl for ucs
|
|
poly.QuickOffset(-nWidth, poly1);
|
|
poly.QuickOffset(nWidth, poly2);
|
|
//dc << poly1 << poly2;
|
|
dc.DrawEntity(poly1.AsAcDbCurve());
|
|
dc.DrawEntity(poly2.AsAcDbCurve());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void XDbOsnapPoint::DrawShape(AcGiWorldDraw *mode)
|
|
{
|
|
AcGiViewDraw dc(mode, NULL);
|
|
switch(m_nFlag)
|
|
{
|
|
case 1: // 橡皮筋
|
|
{
|
|
//dc << XLine(m_ptBase, m_ptLoc);
|
|
dc.DrawLine(AcGeLineSeg3d(m_ptBase.AsAcGePoint3d(), m_ptLoc.AsAcGePoint3d()));
|
|
break;
|
|
}
|
|
case 2: // 矩形框
|
|
{
|
|
AcGeVector3d vtX = AcGeVector3d::kXAxis;
|
|
vtX.rotateBy(GlobalFunc::Wcs2Ucs(m_dRectAngle), AcGeVector3d::kZAxis);
|
|
AcGeVector3d vtY;
|
|
XPoint pt1 = m_ptLoc;
|
|
XPoint pt2 = m_ptBase;
|
|
pt1.z = 0.0;
|
|
pt2.z = 0.0;
|
|
XPoint pt3, pt4;
|
|
if (fabs(GlobalFunc::Wcs2Ucs(m_dRectAngle)) < 0.001)
|
|
{
|
|
pt1 = GlobalFunc::Wcs2Ucs(pt1);
|
|
pt2 = GlobalFunc::Wcs2Ucs(pt2);
|
|
pt3.x = pt1.x;
|
|
pt3.y = pt2.y;
|
|
pt3.z = 0.0;
|
|
pt4.x = pt2.x;
|
|
pt4.y = pt1.y;
|
|
pt4.z = 0.0;
|
|
}
|
|
else
|
|
{
|
|
AcGeVector3d vtY = vtX;
|
|
vtY.rotateBy(PI / 2,AcGeVector3d::kZAxis);
|
|
|
|
int nSignX = 1,nSignY = 1;
|
|
|
|
AcGeVector3d vt = pt1 - pt2;
|
|
vt.normalize();
|
|
double dAngle = vt.angleTo(vtX);
|
|
if (dAngle > PI / 2)
|
|
{
|
|
nSignX = -1;
|
|
}
|
|
|
|
double dDist = pt1.Distance2d(pt2);
|
|
double dLen = fabs(dDist * cos(dAngle));
|
|
double dWidth = fabs(dDist * sin(dAngle));
|
|
//axc add 2014-10-16 解决16平台在UCS下崩溃问题
|
|
if (dLen <= 0 || dWidth <= 0 || vt.isZeroLength() == Adesk::kTrue)
|
|
{
|
|
return;
|
|
}
|
|
|
|
dAngle = vt.angleTo(vtY);
|
|
if (dAngle > PI / 2)
|
|
{
|
|
nSignY = -1;
|
|
}
|
|
|
|
vtX.normalize();
|
|
vtY.normalize();
|
|
|
|
pt3 = pt2 + vtX * dLen * nSignX;
|
|
pt4 = pt2 + vtY * dWidth * nSignY;
|
|
}
|
|
|
|
//dc << XLine(pt1, pt3);
|
|
dc.DrawLine(AcGeLineSeg3d(pt1.AsAcGePoint3d(), pt3.AsAcGePoint3d()));
|
|
//dc << XLine(pt1, pt4);
|
|
dc.DrawLine(AcGeLineSeg3d(pt1.AsAcGePoint3d(), pt4.AsAcGePoint3d()));
|
|
//dc << XLine(pt2, pt3);
|
|
dc.DrawLine(AcGeLineSeg3d(pt2.AsAcGePoint3d(), pt3.AsAcGePoint3d()));
|
|
//dc << XLine(pt2, pt4);
|
|
dc.DrawLine(AcGeLineSeg3d(pt2.AsAcGePoint3d(), pt4.AsAcGePoint3d()));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void XDbOsnapPoint::SetLocation(const XPoint &ptLoc)
|
|
{
|
|
m_ptLoc = ptLoc;
|
|
}
|
|
|
|
XPoint XDbOsnapPoint::GetLocation() const
|
|
{
|
|
return m_ptLoc;
|
|
}
|
|
|
|
void XDbOsnapPoint::SetSnapShape(int nShape)
|
|
{
|
|
m_nOsShape = nShape;
|
|
}
|
|
|
|
void XDbOsnapPoint::SetEntityEx(AcDbEntity *pEnt)
|
|
{
|
|
m_pEntityEx = pEnt;
|
|
}
|
|
|
|
void XDbOsnapPoint::SetBasePoint(const XPoint &pt)
|
|
{
|
|
m_ptBase = pt;
|
|
}
|
|
|
|
void XDbOsnapPoint::SetDrawShape(int nFlag)
|
|
{
|
|
m_nFlag = nFlag;
|
|
}
|
|
|
|
void XDbOsnapPoint::SetRectAngle(double dAngle)
|
|
{
|
|
m_dRectAngle = dAngle;
|
|
}
|
|
|
|
void XDbOsnapPoint::SetDrawSnap(bool bSnap)
|
|
{
|
|
m_bDrawSnap = bSnap;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////
|
|
XOsPointEdJig::XOsPointEdJig()
|
|
:m_pszKeyword(NULL), m_pszPrompt(NULL), m_pDrawEnt(NULL),
|
|
m_nRetCode(0), m_nOsShape(0)
|
|
{
|
|
m_pDrawEnt = new XDbOsnapPoint;
|
|
}
|
|
|
|
XOsPointEdJig::~XOsPointEdJig()
|
|
{
|
|
if(m_pDrawEnt)
|
|
delete m_pDrawEnt;
|
|
}
|
|
|
|
// 开始执行拖动
|
|
void XOsPointEdJig::doIt()
|
|
{
|
|
m_pDrawEnt->SetSnapShape(AsOsnapMask(m_nOsShape));
|
|
m_pDrawEnt->SetLocation(m_ptTo);
|
|
|
|
setDispPrompt(m_pszPrompt);
|
|
if(m_pszKeyword)
|
|
{
|
|
INITGET_BEG(-1, m_pszKeyword);
|
|
try
|
|
{
|
|
m_nRetCode = drag();
|
|
}
|
|
catch(...)
|
|
{
|
|
m_nRetCode=AcEdJig::kCancel;
|
|
}
|
|
INITGET_END();
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
m_nRetCode = drag();
|
|
}
|
|
catch(...)
|
|
{
|
|
m_nRetCode=AcEdJig::kCancel;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 反馈
|
|
AcEdJig::DragStatus XOsPointEdJig::sampler()
|
|
{
|
|
DragStatus stat;
|
|
setUserInputControls((UserInputControls)
|
|
(AcEdJig::kAccept3dCoordinates | AcEdJig::kNullResponseAccepted
|
|
| AcEdJig::kNoNegativeResponseAccepted
|
|
| AcEdJig::kNoZeroResponseAccepted));
|
|
|
|
if (m_pszKeyword) setKeywordList(m_pszKeyword);
|
|
XPoint ptTemp;
|
|
stat = acquirePoint(ptTemp);
|
|
if(stat == AcEdJig::kNormal)
|
|
{
|
|
if (g_bAssisitantSnap)
|
|
{
|
|
m_nOsShape = AutoSnapPoint(ptTemp, NULL);
|
|
}
|
|
m_pDrawEnt->SetDrawSnap(g_bAssisitantSnap);
|
|
|
|
if (ads_distance(ptTemp, m_ptTo)>g_Option::instance()._DIST_SNAP)
|
|
{
|
|
m_ptTo=ptTemp;
|
|
}
|
|
else
|
|
return AcEdJig::kNoChange;
|
|
}
|
|
|
|
return stat;
|
|
}
|
|
|
|
// 更新实体数据
|
|
Adesk::Boolean XOsPointEdJig::update()
|
|
{
|
|
if(!(m_pDrawEnt->GetLocation() == m_ptTo))
|
|
{
|
|
m_pDrawEnt->SetLocation(m_ptTo);
|
|
m_pDrawEnt->SetSnapShape(AsOsnapMask(m_nOsShape));
|
|
}
|
|
return Adesk::kTrue;
|
|
}
|
|
|
|
AcDbEntity* XOsPointEdJig::entity() const
|
|
{
|
|
return m_pDrawEnt;
|
|
}
|
|
|
|
// 转换成ADS代码
|
|
int XOsPointEdJig::GetRetCode(int *kwordId) const
|
|
{
|
|
int ret = m_nRetCode;
|
|
if (ret == AcEdJig::kCancel)
|
|
ret = RTCAN;
|
|
else if(ret == AcEdJig::kNull)
|
|
ret = RTNONE;
|
|
else if (ret <= 0)
|
|
ret = RTNORM;
|
|
else
|
|
{
|
|
if(kwordId) *kwordId = ret;
|
|
ret = RTKWORD;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
AcEdJig::DragStatus XOsPointEdJig::GetRetStatus() const
|
|
{
|
|
return (AcEdJig::DragStatus)m_nRetCode;
|
|
}
|
|
|
|
void XOsPointEdJig::SetKeyWord(const TCHAR *pszKeyWord)
|
|
{
|
|
m_pszKeyword = pszKeyWord;
|
|
}
|
|
|
|
void XOsPointEdJig::SetPrompt(const TCHAR *pszPormpt)
|
|
{
|
|
m_pszPrompt = pszPormpt;
|
|
}
|
|
|
|
void XOsPointEdJig::SetptFrom(const XPoint &ptFrom)
|
|
{
|
|
m_pDrawEnt->SetBasePoint(ptFrom);
|
|
}
|
|
|
|
void XOsPointEdJig::SetptTo(const XPoint &ptTo)
|
|
{
|
|
m_ptTo = ptTo;
|
|
}
|
|
|
|
XPoint XOsPointEdJig::GetptTo() const
|
|
{
|
|
return m_ptTo;
|
|
}
|
|
|
|
void XOsPointEdJig::SetUsageFlag(int nFlag)
|
|
{
|
|
m_pDrawEnt->SetDrawShape(nFlag);
|
|
}
|
|
|
|
void XOsPointEdJig::SetRectAngle(double dAngle)
|
|
{
|
|
m_pDrawEnt->SetRectAngle(dAngle);
|
|
}
|
|
|
|
////////////////////////////////////////
|
|
XCurvePickSet::XCurvePickSet():PickSet(SS_FREE)
|
|
{
|
|
|
|
}
|
|
|
|
void XCurvePickSet::SetLayerFilter(XStringList &lstLay)
|
|
{
|
|
m_lstLayerFilter=lstLay;
|
|
}
|
|
|
|
void XCurvePickSet::SetDxfNameFilter(XStringList &lstDxf)
|
|
{
|
|
m_lstDxfNameFilter=lstDxf;
|
|
}
|
|
|
|
// 给定窗口进行搜索
|
|
int XCurvePickSet::GetByCrossing(const XPoint &ptLow, const XPoint &ptUp)
|
|
{
|
|
SHAcDbBlockTableRecPtr objMSpace;
|
|
if(!objMSpace)
|
|
return RTERROR;
|
|
int nRet=RTNONE;
|
|
XRectAngle rect(ptLow, ptUp);
|
|
XPoint ptMid;
|
|
Midpoint(ptLow, ptUp, ptMid);
|
|
AcDbBlockTableRecordIterator* pBlockIterator=NULL;
|
|
Acad::ErrorStatus es = objMSpace.m_pBlockTableRec->newIterator(pBlockIterator);
|
|
ASSERT(es==Acad::eOk && pBlockIterator!=NULL);
|
|
|
|
for (pBlockIterator->start(); !pBlockIterator->done(); pBlockIterator->step()) {
|
|
AcDbEntity *pEntity=NULL;
|
|
es = pBlockIterator->getEntity(pEntity, AcDb::kForRead);
|
|
if(es!=Acad::eOk) continue;
|
|
ASSERT(pEntity);
|
|
AcDbObjectPtr vTemp(pEntity);
|
|
//不处理不可见的实体
|
|
if (pEntity->visibility() == AcDb::kInvisible) {
|
|
continue;
|
|
}
|
|
AcDbCurve *pCurve=AcDbCurve::cast(pEntity);
|
|
if(!pCurve)
|
|
continue;
|
|
if(!!m_lstDxfNameFilter) {
|
|
const TCHAR *pszDxfName=pEntity->isA()->dxfName();
|
|
if(m_lstDxfNameFilter.Index(pszDxfName, 0)<0)
|
|
continue;
|
|
}
|
|
AcDbObjectId idLayer=pEntity->layerId();
|
|
OPENOBJ_BEGIN(idLayer, AcDb::kForRead, AcDbLayerTableRecord, pLayer);
|
|
if(pLayer) {
|
|
if(pLayer && pLayer->isFrozen() || pLayer->isOff())
|
|
continue;
|
|
}
|
|
OPENOBJ_END();
|
|
if(!!m_lstLayerFilter) {
|
|
TCHAR *pszLayer=pEntity->layer();
|
|
ASSERT(pszLayer);
|
|
if(m_lstLayerFilter.Index(pszLayer, 0)<0) {
|
|
delete pszLayer;
|
|
continue;
|
|
}
|
|
delete pszLayer;
|
|
}
|
|
XPoint ptCloseToCurve;
|
|
if(pCurve->getClosestPointTo(ptMid, ptCloseToCurve)==Acad::eOk &&
|
|
(ptCloseToCurve&rect)==PR_INSIDE) {
|
|
Entity ent;
|
|
VERIFY(acdbGetAdsName(ent.name, pCurve->objectId())==Acad::eOk);
|
|
*this += ent;
|
|
nRet=RTNORM;
|
|
}
|
|
}
|
|
delete pBlockIterator;
|
|
return nRet;
|
|
} |