1897 lines
44 KiB
C++
1897 lines
44 KiB
C++
#include "stdafx.h"
|
||
#include "SymbolAnnotateJig.h"
|
||
|
||
|
||
//以下类是从EditSymbolAnnotate.cpp中分离出来 by lgy 20120109
|
||
TComposingEdJig::TComposingEdJig(TDbSymbComposing *pElev)
|
||
{
|
||
m_pDrawEnt=pElev;
|
||
}
|
||
|
||
AcEdJig::DragStatus
|
||
TComposingEdJig::GetPoint(XPoint &pt)
|
||
{
|
||
XPoint ptBase=m_nOperCode==kTextLine? m_pDrawEnt->GetTurnPoint() : m_pDrawEnt->GetStartPoint();
|
||
return acquirePoint(pt, ptBase);
|
||
}
|
||
|
||
// 开始执行拖动
|
||
int TComposingEdJig::DoIt(int *keyIndex)
|
||
{
|
||
// delete by xly on 100917 做法标注绘制过程中不影响对象捕捉
|
||
//XPushVar<int> osmode(_T("OSMODE"), 0);//add by whl
|
||
if(m_nOperCode==kTurnPoint) {
|
||
m_ptResult=m_pDrawEnt->GetStartPoint();
|
||
} else if(m_nOperCode==kTextLine) {
|
||
XPoint ptTemp;
|
||
ads_polar(m_pDrawEnt->GetTurnPoint(), 0.0, m_pDrawEnt->GetTextBaseLen(FALSE), ptTemp);
|
||
m_ptResult=ptTemp;
|
||
}
|
||
int nRet = TSymbEdJig::DoIt(keyIndex);
|
||
return nRet;
|
||
}
|
||
|
||
// 更新实体数据，sg modify 081105
|
||
Adesk::Boolean TComposingEdJig::update()
|
||
{
|
||
Adesk::Boolean bRet = Adesk::kTrue;
|
||
double nVal(0); // sg add 081105，当前线长，统一代码用
|
||
if (m_nOperCode == kTurnPoint) {
|
||
m_pDrawEnt->SetTurnPoint(m_ptResult);
|
||
nVal = m_pDrawEnt->GetTextBaseLen(FALSE); // sg add 081105
|
||
}
|
||
else if (m_nOperCode == kTextLine)
|
||
{
|
||
// refreshed by whl on 060208
|
||
// double nVal=m_ptResult.x - m_pDrawEnt->GetTurnPoint().x;
|
||
// double nVal = Wcs2Ucs(m_ptResult).x - Wcs2Ucs(m_pDrawEnt->GetTurnPoint()).x;
|
||
// sg modify 081105
|
||
nVal = Wcs2Ucs(m_ptResult).x - Wcs2Ucs(m_pDrawEnt->GetTurnPoint()).x;
|
||
m_pDrawEnt->SetTextBaseLen(nVal, FALSE);
|
||
}
|
||
|
||
// sg modify 090225，解决M单位图的问题
|
||
// double dDist2Line = m_pDrawEnt->GetDistSymbol()*57, // 距线距离系数
|
||
// sg modify 090429，解决改变比例后，绘制距离远的BUG，此解决方案，可兼顾M单位图的问题
|
||
double dFixDist = 0.57 * DocGetPScale();
|
||
double dDist2Line = m_pDrawEnt->GetDistSymbol()*dFixDist, // 距线距离系数
|
||
dPageWidth = 0; // 页宽，sg add 081104
|
||
m_pDrawEnt->SetDist2Line(dDist2Line, FALSE);
|
||
m_pDrawEnt->SetAlignBySymbol(); // 设置对齐方式，sg add 081104
|
||
if (!m_pDrawEnt->IsSideText()) // 文字在线上，sg modify 081105
|
||
{
|
||
dPageWidth = nVal - 2*m_pDrawEnt->GetDist2Line(FALSE);
|
||
}
|
||
m_pDrawEnt->SetPageWidth(dPageWidth, FALSE);
|
||
return bRet;
|
||
}
|
||
|
||
AcDbEntity* TComposingEdJig::entity() const
|
||
{
|
||
return (AcDbEntity *)m_pDrawEnt;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
TComposingAddOtherPtJig::TComposingAddOtherPtJig(XPoint ptStart, XPoint ptBase)
|
||
{
|
||
m_ptLeader = ptBase.AsAcGePoint3d();
|
||
m_ptFirstVertexes = ptStart.AsAcGePoint3d();
|
||
m_line.setStartPoint(m_ptLeader);
|
||
}
|
||
|
||
// 开始执行拖动
|
||
int TComposingAddOtherPtJig::DoIt(int *keyIndex)
|
||
{
|
||
return TSymbEdJig::DoIt(keyIndex);
|
||
}
|
||
|
||
AcEdJig::DragStatus TComposingAddOtherPtJig::GetPoint(AcGePoint3d &pt)
|
||
{
|
||
// 自由拖拽，不受正交控制
|
||
return acquirePoint(pt);
|
||
}
|
||
|
||
Adesk::Boolean TComposingAddOtherPtJig::update()
|
||
{
|
||
// 将JIG时的鼠标位置点，投影到第一条引线上
|
||
AcGePoint3d ptRet = m_ptResult,
|
||
ptOnLine;
|
||
// 引线
|
||
AcDbLine line(m_ptFirstVertexes, m_ptLeader);
|
||
|
||
// 获得拖拽点到引线的投影点
|
||
line.getClosestPointTo(ptRet, ptOnLine, Adesk::kTrue);
|
||
m_ptResult = ptOnLine;
|
||
|
||
m_line.setEndPoint(m_ptResult);
|
||
return Adesk::kTrue;
|
||
}
|
||
AcDbEntity* TComposingAddOtherPtJig::entity() const
|
||
{
|
||
return (AcDbEntity *)&m_line;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
TIndexPointerEdJig::TIndexPointerEdJig(TDbSymbIndexPointer *pElev)
|
||
{
|
||
m_pDrawEnt = pElev;
|
||
m_pDlg = NULL;
|
||
}
|
||
|
||
void TIndexPointerEdJig::InitCutLine()
|
||
{
|
||
ASSERT(m_pDrawEnt != NULL);
|
||
ASSERT(!m_pDrawEnt->IsIndexPointer());
|
||
|
||
m_pDrawEnt->GetCutLineAll(m_arCutAdded);
|
||
m_arCutAdded.RemoveAt(0); // 删除第一个。
|
||
}
|
||
|
||
// 开始执行拖动
|
||
int TIndexPointerEdJig::DoIt(int *keyIndex)
|
||
{
|
||
XPushVar<int> osmode(_T("OSMODE"), 0); // add by whl，关闭对象捕捉
|
||
if (m_nOperCode == kSourceExtent) // 指向范围
|
||
{
|
||
m_drawEnt.setPropertiesFrom(m_pDrawEnt);
|
||
m_drawEnt.setRadius(m_pDrawEnt->GetSourceExtent()/2.0);
|
||
m_drawEnt.setCenter((const AcGePoint3d &)m_pDrawEnt->GetStartPoint());
|
||
m_ptResult = m_pDrawEnt->GetStartPoint();
|
||
}
|
||
else if (m_nOperCode==kTurnPoint || m_nOperCode==kViewDirection) // 转折点、剖视方向
|
||
{
|
||
m_ptResult = m_pDrawEnt->GetStartPoint();
|
||
}
|
||
else if (m_nOperCode == kTextBasePoint)
|
||
{
|
||
m_ptResult = m_pDrawEnt->GetTextBasePoint();
|
||
}
|
||
|
||
int nRet = TSymbEdJig::DoIt(keyIndex);
|
||
if (m_nOperCode==kSourceExtent && nRet==RTNORM)
|
||
m_pDrawEnt->SetSourceExtent(m_drawEnt.radius()*2.0);
|
||
if (m_nOperCode == kMoreCuts)
|
||
{
|
||
if (nRet == RTNORM)
|
||
{
|
||
m_arCutAdded.Add(m_cutCurrDrag);
|
||
}
|
||
else if (nRet == RTNONE)
|
||
{
|
||
m_pDrawEnt->SetCutLine(m_arCutAdded);
|
||
m_arCutAdded.RemoveAll();
|
||
}
|
||
}
|
||
return nRet;
|
||
}
|
||
|
||
// 反馈
|
||
AcEdJig::DragStatus TIndexPointerEdJig::GetPoint(XPoint &pt)
|
||
{
|
||
DragStatus stat;
|
||
if (m_nOperCode==kSourceExtent || m_nOperCode==kViewDirection ||
|
||
m_nOperCode==kTurnPoint || m_nOperCode == kAddedTurn)
|
||
{ // modify by lgh，添加对“新添得转折点的支持。”
|
||
XPoint ptBase = m_pDrawEnt->GetStartPoint();
|
||
if (m_nOperCode == kTurnPoint && m_pDrawEnt->HasAddedPoint())
|
||
{
|
||
m_pDrawEnt->GetAddedPoint(ptBase);
|
||
}
|
||
stat = acquirePoint(pt, ptBase);
|
||
}
|
||
else
|
||
stat = acquirePoint(pt);
|
||
return stat;
|
||
}
|
||
|
||
extern XPoint pptfirst_; // [11/12/2007 nsh]
|
||
extern double sAngle_;
|
||
Adesk::Boolean TIndexPointerEdJig::update() // 更新实体数据
|
||
{
|
||
if ((m_pDlg != NULL) && (m_pDrawEnt != NULL))
|
||
{
|
||
if (m_pDlg->m_bDimOnExtent)
|
||
{
|
||
m_pDlg->UpdateData();
|
||
const double dMinLen = TDbSymbIndexPointer::GetDefaultExtendLineLen();
|
||
double dTextLen1 = m_pDlg->GetUpDimLen();
|
||
double dTextLen2 = m_pDlg->GetDownDimLen();
|
||
double dLen = max(dTextLen1, dTextLen2)/m_pDrawEnt->GetPScale();
|
||
if (dLen < dMinLen)
|
||
dLen = dMinLen;
|
||
|
||
m_pDrawEnt->SetExtendLineLen(dLen);
|
||
m_pDrawEnt->SetDimPos(1);
|
||
}
|
||
else
|
||
{
|
||
m_pDrawEnt->SetExtendLineLen(0.0);
|
||
m_pDrawEnt->SetDimPos(0);
|
||
}
|
||
}
|
||
|
||
Adesk::Boolean bRet = Adesk::kTrue;
|
||
if (m_nOperCode == kSourceExtent) // 指向范围
|
||
{
|
||
m_drawEnt.setRadius(m_ptResult.Distance2d(m_pDrawEnt->GetStartPoint()));
|
||
}
|
||
else if (m_nOperCode == kTurnPoint) // 引线首个转折点
|
||
{
|
||
// m_pDrawEnt->SetTurnPoint(m_ptResult); // add by cwk on 060704
|
||
if (!m_bFixAngle) // add by cwk on 060704
|
||
{
|
||
m_pDrawEnt->SetTurnPoint(m_ptResult);
|
||
}
|
||
else
|
||
{
|
||
// [11/12/2007 nsh]
|
||
static double ss = sAngle_;
|
||
if (CIndexDimDlg::m_iIndexType == 0) // 非剖切的情况
|
||
{
|
||
if (ss >= 0) // 处理输入的角度值为大于零的数值
|
||
{
|
||
AcGePoint3d ap3;
|
||
ads_real x0, y0;
|
||
ads_real xi, yi;
|
||
XPoint xxxx = pptfirst_;
|
||
x0 = pptfirst_.x;
|
||
y0 = pptfirst_.y;
|
||
xi = Wcs2Ucs(m_ptResult).x;
|
||
yi = Wcs2Ucs(m_ptResult).y;
|
||
if (xi>=x0 && yi>=y0)
|
||
{
|
||
m_dFixAngle = sAngle_;
|
||
}
|
||
else if (xi<x0 && yi>=y0)
|
||
{
|
||
m_dFixAngle = 180 - sAngle_;
|
||
}
|
||
else if (xi<=x0 && yi<y0)
|
||
{
|
||
m_dFixAngle = 180 + sAngle_;
|
||
}
|
||
else if (xi>x0 && yi<y0)
|
||
{
|
||
m_dFixAngle = 360 - sAngle_;
|
||
}
|
||
}
|
||
else if (ss < 0) // 处理角度值为小于零的情况
|
||
{
|
||
AcGePoint3d ap3;
|
||
static double fabsAngle;
|
||
fabsAngle = fabs(sAngle_);
|
||
double x0, y0;
|
||
double xi, yi;
|
||
x0 = pptfirst_.x;
|
||
y0 = pptfirst_.y;
|
||
xi = m_ptResult.x;
|
||
yi = m_ptResult.y;
|
||
if (xi>=x0 && yi>=y0) // 第一象限
|
||
{
|
||
m_dFixAngle = fabsAngle;
|
||
}
|
||
else if (xi<x0 && yi>=y0)
|
||
{
|
||
m_dFixAngle = 180 - fabsAngle;
|
||
}
|
||
else if (xi<=x0 && yi<y0)
|
||
{
|
||
m_dFixAngle = 180 + fabsAngle;
|
||
}
|
||
else if (xi>x0 && yi<y0)
|
||
{
|
||
m_dFixAngle = 360 - fabsAngle;
|
||
}
|
||
}
|
||
|
||
XPoint ptTemp = m_pDrawEnt->GetStartPoint();
|
||
double d1 = sqrt((Wcs2Ucs(m_ptResult).x - Wcs2Ucs(ptTemp).x)
|
||
* (Wcs2Ucs(m_ptResult).x - Wcs2Ucs(ptTemp).x)
|
||
+ (Wcs2Ucs(m_ptResult).y - Wcs2Ucs(ptTemp).y)
|
||
* (Wcs2Ucs(m_ptResult).y - Wcs2Ucs(ptTemp).y));
|
||
double d3 = atan2(Wcs2Ucs(m_ptResult).y - Wcs2Ucs(ptTemp).y,
|
||
Wcs2Ucs(m_ptResult).x - Wcs2Ucs(ptTemp).x);
|
||
double d2 = cos((m_dFixAngle / 180)* PI - d3);
|
||
double d = d1 * d2;
|
||
|
||
XPoint ptTurn;
|
||
ptTurn.y = Wcs2Ucs(ptTemp).y + d * sin((m_dFixAngle / 180)* PI);
|
||
ptTurn.x = Wcs2Ucs(ptTemp).x + d * cos((m_dFixAngle / 180)* PI);
|
||
m_pDrawEnt->SetTurnPoint(Ucs2Wcs(ptTurn));
|
||
}
|
||
else
|
||
{
|
||
m_pDrawEnt->SetTurnPoint(m_ptResult);
|
||
}
|
||
}
|
||
}
|
||
else if (m_nOperCode == kTextBasePoint) // Modify on 2002/10/14，文字基线长度
|
||
{
|
||
XPoint ptTurn = m_pDrawEnt->GetTurnPoint();
|
||
// modified by whl on 060208
|
||
double nDist = Wcs2Ucs(m_ptResult).x - Wcs2Ucs(ptTurn).x;
|
||
// double nDist = m_ptResult.Distance2d(ptTurn);
|
||
// if (m_ptResult.x < ptTurn.x)
|
||
// nDist = -nDist;
|
||
|
||
/*
|
||
XLine ln(m_pDrawEnt->GetStartPoint(), m_pDrawEnt->GetTurnPoint());
|
||
// Modify on 2002/2/25 by ZJQ, 解决水平方向的问题
|
||
if (fabs(sin(ln.Direction())) < 1.0E-6)
|
||
{
|
||
if (fabs(ln.Direction()-PI) < 1.0E-6)
|
||
nDist = -nDist;
|
||
}
|
||
else
|
||
{
|
||
int nSide = ln.OnWhichSide(m_ptResult);
|
||
if (nSide == OFFSET_LEFT)
|
||
nDist = -nDist;
|
||
}
|
||
*/
|
||
m_pDrawEnt->SetTextBaseLen(nDist, FALSE);
|
||
}
|
||
else if (m_nOperCode == kViewDirection) // 剖视方向
|
||
{
|
||
XLine ln(m_pDrawEnt->GetStartPoint(), m_pDrawEnt->GetTurnPoint());
|
||
int nSide = ln.OnWhichSide(m_ptResult);
|
||
double nVal = (nSide==OFFSET_LEFT) ?
|
||
fabs(m_pDrawEnt->GetSourceExtent()) : -fabs(m_pDrawEnt->GetSourceExtent());
|
||
m_pDrawEnt->SetSourceExtent(nVal);
|
||
}
|
||
// add by lgh.添加多“新增转折点”和"多个剖切线"的支持
|
||
else if (m_nOperCode == kAddedTurn)
|
||
{
|
||
m_pDrawEnt->SetAddedPoint(m_ptResult);
|
||
m_pDrawEnt->SetTurnPoint(m_ptResult);
|
||
}
|
||
else if (m_nOperCode == kMoreCuts)
|
||
{
|
||
XLine firstLine = m_pDrawEnt->GetFirstLine();
|
||
AcGeLineSeg3d geFirstLine(firstLine.StartPoint().AsAcGePoint3d(), firstLine.EndPoint().AsAcGePoint3d());
|
||
|
||
XPoint nearPoint = geFirstLine.closestPointTo(m_ptResult.AsAcGePoint3d());
|
||
|
||
if (nearPoint != firstLine.StartPoint() && nearPoint != firstLine.EndPoint())
|
||
{
|
||
XVector3D vecLine = firstLine.Direction3d();
|
||
|
||
double dLen = fabs(TDbSymbIndexPointer::GetDefaultCutLineLen()*m_pDrawEnt->GetPScale());
|
||
vecLine.Scale(dLen);
|
||
XLine cutLine(nearPoint, nearPoint + vecLine);
|
||
XPoint endNearPoint = geFirstLine.closestPointTo(cutLine.EndPoint().AsAcGePoint3d());
|
||
if (endNearPoint != firstLine.StartPoint() && endNearPoint != firstLine.EndPoint())
|
||
{
|
||
if (m_cutCurrDrag == cutLine)
|
||
bRet = Adesk::kFalse;
|
||
else
|
||
{
|
||
m_cutCurrDrag = cutLine;
|
||
CArray<XLine, XLine&> arCuts;
|
||
arCuts.Append(m_arCutAdded);
|
||
arCuts.Add(m_cutCurrDrag);
|
||
m_pDrawEnt->SetCutLine(arCuts);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return bRet;
|
||
}
|
||
|
||
AcDbEntity* TIndexPointerEdJig::entity() const
|
||
{
|
||
return ((m_nOperCode==kSourceExtent) ? (AcDbEntity *)&m_drawEnt : (AcDbEntity *)m_pDrawEnt);
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
TArrowEdJig::TArrowEdJig(TDbSymbArrow *pElev)
|
||
{
|
||
m_pDrawEnt = pElev;
|
||
m_bFirst = TRUE;
|
||
}
|
||
|
||
AcEdJig::DragStatus TArrowEdJig::GetPoint(XPoint &pt)
|
||
{
|
||
XPoly2D poly;
|
||
m_pDrawEnt->GetPoly2D(poly);
|
||
if (poly.Length() > 1)
|
||
{
|
||
if (m_bFirst)
|
||
{
|
||
XPoint ptBase = *poly.Head();
|
||
return acquirePoint(pt, ptBase); // [3/7/2008 nsh]
|
||
}
|
||
else
|
||
{
|
||
XPoint ptBase = *poly[1];
|
||
return acquirePoint(pt, ptBase);
|
||
}
|
||
}
|
||
else
|
||
return acquirePoint(pt);
|
||
}
|
||
|
||
// 开始执行拖动
|
||
int TArrowEdJig::DoIt(int *keyIndex)
|
||
{
|
||
m_bFirst = TRUE;
|
||
XPoly2D poly2d;
|
||
m_pDrawEnt->GetPoly2D(poly2d);
|
||
if (m_nOperCode==kLinePoint || m_nOperCode==kArcPoint)
|
||
{
|
||
m_ptResult = *poly2d.Head();
|
||
}
|
||
else if (m_nOperCode == kArcMidPoint) // MidPoint
|
||
{
|
||
XCurveSegment cv;
|
||
poly2d.Nth(0, cv);
|
||
m_ptResult = cv.MidPoint();
|
||
}
|
||
|
||
int nRet = TSymbEdJig::DoIt(keyIndex);
|
||
return nRet;
|
||
}
|
||
|
||
// 更新实体数据
|
||
Adesk::Boolean TArrowEdJig::update()
|
||
{
|
||
Adesk::Boolean bRet = Adesk::kTrue;
|
||
XPoly2D poly2d;
|
||
m_pDrawEnt->GetPoly2D(poly2d);
|
||
if (m_nOperCode==kLinePoint || m_nOperCode==kArcPoint)
|
||
{
|
||
if (m_bFirst)
|
||
{
|
||
m_bFirst = FALSE;
|
||
poly2d.InsertNodeAt(0, m_ptResult);
|
||
}
|
||
else
|
||
*poly2d.Head() = m_ptResult;
|
||
}
|
||
else if (m_nOperCode == kArcMidPoint)
|
||
{
|
||
XDirectionCurve cv;
|
||
poly2d.Nth(0, cv);
|
||
XCurveSegment seg;
|
||
seg = XArc(cv.GetStartPoint(), m_ptResult, cv.GetEndPoint());
|
||
if (!!seg)
|
||
{
|
||
if (seg.GetStartPoint().Distance(cv.GetStartPoint())>_DIST_SNAP)
|
||
seg.SetBulge(-seg.GetBulge());
|
||
poly2d.SetBulge(0, seg.GetBulge());
|
||
}
|
||
}
|
||
else if (m_nOperCode == kArcRadius)
|
||
{
|
||
XPoint ptBase, ptPrev;
|
||
int nLen = poly2d.Length();
|
||
ptBase = *poly2d[0];
|
||
ptPrev = *poly2d[1];
|
||
double nChordLen = ptBase.Distance2d(ptPrev);
|
||
double nRadius = ptBase.Distance2d(m_ptResult);
|
||
if (nChordLen < 2.0*nRadius+1.0E-6)
|
||
{
|
||
double bulge = 2.0*asin(nChordLen/2.0/nRadius);
|
||
if (XLine(ptBase, ptPrev).OnWhichSide(m_ptResult) == OFFSET_LEFT)
|
||
bulge = -bulge;
|
||
poly2d.SetBulge(0, bulge);
|
||
}
|
||
}
|
||
m_pDrawEnt->SetPoly2D(poly2d);
|
||
m_pDrawEnt->SetTextLocation(m_pDrawEnt->GetDefaultTextLocation());
|
||
m_pDrawEnt->SetText2Location(m_pDrawEnt->GetDefaultText2Location()); // sg add 090107
|
||
// sg add 090119，JIG过程中支持预览箭头样式
|
||
m_pDrawEnt->SetArrowType((TDbSymbArrow::TArrowType)g_nSymbArrowStyle);
|
||
return bRet;
|
||
}
|
||
|
||
AcDbEntity* TArrowEdJig::entity() const
|
||
{
|
||
return (AcDbEntity *)m_pDrawEnt;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
TCoordEdJig::TCoordEdJig(TDbSymbCoord *pElev)
|
||
{
|
||
m_pDrawEnt=pElev;
|
||
}
|
||
|
||
// 开始执行拖动
|
||
int TCoordEdJig::DoIt()
|
||
{
|
||
// sg modify 120618，解决设置固定度角后，坐标文字位置不正确的问题
|
||
savePoint = m_saveFirstPt;
|
||
|
||
XPushVar<int> osmode(_T("OSMODE"), 0);//add by whl
|
||
return TSymbEdJig::DoIt();
|
||
}
|
||
|
||
// 更新实体数据
|
||
Adesk::Boolean TCoordEdJig::update()
|
||
{
|
||
//if(m_ptResult.Distance2d(m_pDrawEnt->GetTurnPoint())<_DIST_SNAP*10)
|
||
// return Adesk::kFalse;
|
||
if(CCoordDlg::m_bFixAngle)
|
||
{
|
||
{
|
||
//add by lgy 20120606 固定的角度值应该应该在固定绘制之前设置
|
||
dAngle = CCoordDlg::m_strAngle;
|
||
|
||
XPoint temp = Ucs2Wcs(savePoint);
|
||
if (CCoordDlg::m_bFixAngle)
|
||
{
|
||
//这个点的坐标有问题
|
||
double x0,y0;
|
||
double xi,yi;
|
||
x0=savePoint.x;
|
||
y0=savePoint.y;
|
||
xi=Wcs2Ucs(m_ptResult).x;
|
||
yi=Wcs2Ucs(m_ptResult).y;
|
||
if(xi>=x0 && yi>=y0)
|
||
{
|
||
m_dFixAngle=::_tstof(dAngle);
|
||
}
|
||
else if(xi<x0 && yi>=y0)
|
||
{
|
||
m_dFixAngle=180-::_tstof(dAngle);
|
||
}
|
||
else if(xi<=x0 && yi<y0)
|
||
{
|
||
m_dFixAngle =180+::_tstof(dAngle);
|
||
}
|
||
else if(xi>x0 && yi<y0)
|
||
{
|
||
m_dFixAngle=360-::_tstof(dAngle);
|
||
}
|
||
}
|
||
|
||
BOOL bShift=IsKeyPressed(VK_SHIFT);
|
||
XVector3D vt=m_ptResult-m_pDrawEnt->GetLocation();
|
||
double nAngle=ads_angle(XPoint(), vt);
|
||
nAngle=CT_std_angle(nAngle-Ucs2Wcs(0.0));//add by whl
|
||
Adesk::UInt8 nQuadrant;
|
||
if(nAngle>=0.0 && nAngle<PI/2)
|
||
{
|
||
nQuadrant=0;
|
||
if(bShift)
|
||
nAngle=PI/4;
|
||
}
|
||
else if(nAngle>=PI/2 && nAngle<PI)
|
||
{
|
||
nQuadrant=1;
|
||
if(bShift)
|
||
nAngle=PI/2+PI/4;
|
||
}
|
||
else if(nAngle>=PI && nAngle<PI*1.5)
|
||
{
|
||
nQuadrant=2;
|
||
if(bShift)
|
||
nAngle=PI+PI/4;
|
||
}
|
||
else {
|
||
nQuadrant=3;
|
||
if(bShift)
|
||
nAngle=2*PI-PI/4;
|
||
}
|
||
|
||
XLine ln(m_pDrawEnt->GetLocation(), nAngle);
|
||
if(bShift)
|
||
{
|
||
XPoint(m_ptResult).Project(&ln, m_ptResult);
|
||
}
|
||
|
||
XPoint mm=Wcs2Ucs(m_ptResult);
|
||
double x5=Wcs2Ucs(m_ptResult.x);
|
||
double d1 = sqrt((Wcs2Ucs(m_ptResult).x - Wcs2Ucs(temp).x)
|
||
* (Wcs2Ucs(m_ptResult).x - Wcs2Ucs(temp).x)
|
||
+ (Wcs2Ucs(m_ptResult).y - Wcs2Ucs(temp).y)
|
||
* (Wcs2Ucs(m_ptResult).y - Wcs2Ucs(temp).y));
|
||
double d3 = atan2(Wcs2Ucs(m_ptResult).y - Wcs2Ucs(temp).y,
|
||
Wcs2Ucs(m_ptResult).x - Wcs2Ucs(temp).x);
|
||
double d2 = cos((m_dFixAngle / 180)* PI - d3);
|
||
double d = d1 * d2;
|
||
XPoint ptTemp;
|
||
ptTemp.y = Wcs2Ucs(temp).y + d * sin((m_dFixAngle / 180)* PI);
|
||
ptTemp.x = Wcs2Ucs(temp).x + d * cos((m_dFixAngle / 180)* PI);
|
||
m_pDrawEnt->SetQuadrant(nQuadrant);//设置象限
|
||
m_pDrawEnt->SetTurnPoint(Ucs2Wcs(ptTemp));
|
||
}
|
||
}
|
||
else if(!CCoordDlg::m_bFixAngle)
|
||
{
|
||
BOOL bShift=IsKeyPressed(VK_SHIFT);
|
||
XVector3D vt=m_ptResult-m_pDrawEnt->GetLocation();
|
||
double nAngle=ads_angle(XPoint(), vt);
|
||
|
||
nAngle=CT_std_angle(nAngle-Ucs2Wcs(0.0));//add by whl
|
||
|
||
Adesk::UInt8 nQuadrant;
|
||
if(nAngle>=0.0 && nAngle<PI/2)
|
||
{
|
||
nQuadrant=0;
|
||
if(bShift)
|
||
nAngle=PI/4;
|
||
}
|
||
else if(nAngle>=PI/2 && nAngle<PI)
|
||
{
|
||
nQuadrant=1;
|
||
if(bShift)
|
||
nAngle=PI/2+PI/4;
|
||
}
|
||
else if(nAngle>=PI && nAngle<PI*1.5)
|
||
{
|
||
nQuadrant=2;
|
||
if(bShift)
|
||
nAngle=PI+PI/4;
|
||
}
|
||
else {
|
||
nQuadrant=3;
|
||
if(bShift)
|
||
nAngle=2*PI-PI/4;
|
||
}
|
||
XLine ln(m_pDrawEnt->GetLocation(), nAngle);
|
||
if(bShift) {
|
||
XPoint(m_ptResult).Project(&ln, m_ptResult);
|
||
}
|
||
m_pDrawEnt->SetQuadrant(nQuadrant);//设置象限
|
||
//m_pDrawEnt->SetTurnPoint(Ucs2Wcs(m_ptResult));
|
||
m_pDrawEnt->SetTurnPoint(m_ptResult);
|
||
}
|
||
|
||
return Adesk::kTrue;
|
||
}
|
||
|
||
AcDbEntity* TCoordEdJig::entity() const
|
||
{
|
||
return (AcDbEntity *)m_pDrawEnt;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
TDrawingNameJig::TDrawingNameJig(TDbDrawingName *pEnt)
|
||
: m_pDrawEnt(pEnt)
|
||
, m_pszPrompt(NULL)
|
||
, m_pszKeyword(NULL)
|
||
{
|
||
}
|
||
|
||
void TDrawingNameJig::SetPrompt(const TCHAR *pszPrompt)
|
||
{
|
||
m_pszPrompt = pszPrompt;
|
||
}
|
||
|
||
void TDrawingNameJig::SetKeyword(const TCHAR *pszKeyword)
|
||
{
|
||
m_pszKeyword = pszKeyword;
|
||
}
|
||
|
||
int TDrawingNameJig::start(int *keyIndex)
|
||
{
|
||
setDispPrompt( m_pszPrompt );
|
||
AcEdJig::DragStatus stat = drag();
|
||
|
||
if ( kNormal == stat )
|
||
append();
|
||
else
|
||
delete m_pDrawEnt;
|
||
|
||
int nRet;
|
||
if (stat == AcEdJig::kCancel)
|
||
nRet = RTCAN;
|
||
else if(stat == AcEdJig::kNull)
|
||
nRet = RTNONE;
|
||
else if (stat <= 0)
|
||
nRet = RTNORM;
|
||
else
|
||
{
|
||
if(keyIndex) *keyIndex = stat;
|
||
nRet = RTKWORD;
|
||
}
|
||
return nRet;
|
||
}
|
||
|
||
AcEdJig::DragStatus TDrawingNameJig::sampler()
|
||
{
|
||
setUserInputControls( ( UserInputControls )
|
||
( kNullResponseAccepted | kAccept3dCoordinates ));
|
||
|
||
if (m_pszKeyword)
|
||
setKeywordList(m_pszKeyword);
|
||
|
||
AcGePoint3d point;
|
||
DragStatus stat = acquirePoint(point);
|
||
if (stat == kNormal)
|
||
{
|
||
if (point == m_ptIns)
|
||
return AcEdJig::kNoChange;
|
||
else
|
||
m_ptIns = point;
|
||
}
|
||
return stat;
|
||
}
|
||
|
||
Adesk::Boolean TDrawingNameJig::update()
|
||
{
|
||
// m_pDrawEnt->SetLocation(m_ptIns); // sg modify 090112
|
||
m_pDrawEnt->SetMidLocation(m_ptIns);
|
||
return Adesk::kTrue;
|
||
}
|
||
|
||
AcDbEntity *TDrawingNameJig::entity() const
|
||
{
|
||
return m_pDrawEnt;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
TLeaderEdJig::TLeaderEdJig(TDbSymbMultiLeader *pElev)
|
||
{
|
||
m_nOperCode = TLeaderEdJig::kNone;
|
||
m_pDrawEnt = pElev;
|
||
}
|
||
|
||
XPoint TLeaderEdJig::GetDragPoint() const
|
||
{
|
||
XPoint ptDrag = m_ptResult;
|
||
if (m_nOperCode == TLeaderEdJig::kLeader)
|
||
ptDrag = m_pDrawEnt->GetLeaderPoint();
|
||
else if (m_nOperCode == TLeaderEdJig::kTextLine)
|
||
ptDrag = m_pDrawEnt->GetTextBasePoint();
|
||
return ptDrag;
|
||
}
|
||
|
||
XPoint TLeaderEdJig::GetBasePoint() const
|
||
{
|
||
XPoint ptDrag = m_ptResult;
|
||
if (m_nOperCode == TLeaderEdJig::kLeader)
|
||
{
|
||
XPointList pts;
|
||
m_pDrawEnt->GetLeaderVertexes(pts);
|
||
if (pts.Length())
|
||
ptDrag = *pts[0];
|
||
}
|
||
else
|
||
{
|
||
ptDrag = m_pDrawEnt->GetLeaderPoint();
|
||
}
|
||
return ptDrag;
|
||
}
|
||
|
||
// 开始执行拖动
|
||
int TLeaderEdJig::DoIt(int *keyIndex)
|
||
{
|
||
//ces
|
||
sAngle;
|
||
m_ptResult = GetDragPoint();
|
||
XPushVar<int> osmode(_T("OSMODE"), 0); // add by whl
|
||
|
||
if (m_bFixAngle) // sg add 090330，如果固定角度，则自动关闭正交
|
||
{
|
||
XPushVar<int> orthomode(_T("ORTHOMODE"), 0);
|
||
return TSymbEdJig::DoIt(keyIndex);
|
||
}
|
||
return TSymbEdJig::DoIt(keyIndex);
|
||
}
|
||
void TLeaderEdJig::SetDlg(CLeaderDlg *pLeadDlg)
|
||
{
|
||
m_pDlg = pLeadDlg;
|
||
}
|
||
|
||
// 反馈
|
||
AcEdJig::DragStatus
|
||
TLeaderEdJig::GetPoint(XPoint &pt)
|
||
{
|
||
DragStatus stat;
|
||
if (m_nOperCode == kTextLine)
|
||
stat = acquirePoint(pt);
|
||
else
|
||
// sg modify 090325，恢复了被NSH删除的代码，可能会带来闪烁问题，修改的目的是解决不支持正交的问题
|
||
stat = acquirePoint(pt, GetBasePoint().AsAcGePoint3d());
|
||
// [10/18/2007 nsh]
|
||
// stat = acquirePoint(pt);
|
||
return stat;
|
||
}
|
||
|
||
Adesk::Boolean TLeaderEdJig::update()
|
||
{
|
||
Adesk::Boolean bRet = Adesk::kTrue;
|
||
if (m_nOperCode == TLeaderEdJig::kLeader)
|
||
{
|
||
// add by cwk on 060606
|
||
if (!m_bFixAngle)
|
||
{
|
||
XVector3D vtOffset = m_ptResult - GetBasePoint();
|
||
m_pDrawEnt->SetLeaderPoint(m_ptResult);
|
||
if (vtOffset.x < 0.0)
|
||
m_pDrawEnt->SetTextBaseLen(-fabs(m_pDrawEnt->GetTextBaseLen()));
|
||
else
|
||
m_pDrawEnt->SetTextBaseLen(fabs(m_pDrawEnt->GetTextBaseLen()));
|
||
}
|
||
else
|
||
{
|
||
//modify by lgy 20120206 固定角度角度出现问题
|
||
static double ss = sAngle;
|
||
sAngle = _tstof(m_pDlg->m_sFixAngle);
|
||
if (ss >= 0)
|
||
{
|
||
// 处理输入的角度值为大于零的数值
|
||
AcGePoint3d ap3;
|
||
ads_real x0,y0;
|
||
ads_real xi,yi;
|
||
XPoint xxxx=pptfirst;
|
||
x0=pptfirst.x;
|
||
y0=pptfirst.y;
|
||
xi=Wcs2Ucs(m_ptResult).x;
|
||
yi=Wcs2Ucs(m_ptResult).y;
|
||
if(xi>=x0 && yi>=y0)
|
||
{
|
||
m_dFixAngle=sAngle;
|
||
}
|
||
else if(xi<x0 && yi>=y0)
|
||
{
|
||
m_dFixAngle=180-sAngle;
|
||
}
|
||
else if(xi<=x0 && yi<y0)
|
||
{
|
||
m_dFixAngle =180+sAngle;
|
||
}
|
||
else if(xi>x0 && yi<y0)
|
||
{
|
||
m_dFixAngle=360-sAngle;
|
||
}
|
||
}
|
||
else if (ss<0)
|
||
{
|
||
//处理角度值为小于零的情况
|
||
AcGePoint3d ap3;
|
||
static double fabsAngle;
|
||
fabsAngle=fabs(sAngle);
|
||
double x0,y0;
|
||
double xi,yi;
|
||
x0=pptfirst.x;
|
||
y0=pptfirst.y;
|
||
xi=m_ptResult.x;
|
||
yi=m_ptResult.y;
|
||
|
||
if (xi>=x0 && yi>=y0) // 第一象限
|
||
{
|
||
m_dFixAngle=fabsAngle;
|
||
}
|
||
else if(xi<x0 && yi>=y0)
|
||
{
|
||
m_dFixAngle=180-fabsAngle;
|
||
}
|
||
else if(xi<=x0 && yi<y0)
|
||
{
|
||
m_dFixAngle =180+fabsAngle;
|
||
}
|
||
else if(xi>x0 && yi<y0)
|
||
{
|
||
m_dFixAngle=360-fabsAngle;
|
||
}
|
||
}
|
||
|
||
XPoint temp = GetBasePoint();
|
||
XPoint xxx=Wcs2Ucs(temp);
|
||
double d1 = sqrt((Wcs2Ucs(m_ptResult).x - Wcs2Ucs(temp).x)
|
||
* (Wcs2Ucs(m_ptResult).x - Wcs2Ucs(temp).x)
|
||
+ (Wcs2Ucs(m_ptResult).y - Wcs2Ucs(temp).y)
|
||
* (Wcs2Ucs(m_ptResult).y - Wcs2Ucs(temp).y));
|
||
double d3 = atan2(Wcs2Ucs(m_ptResult).y - Wcs2Ucs(temp).y,
|
||
Wcs2Ucs(m_ptResult).x - Wcs2Ucs(temp).x);
|
||
double d2 = cos((m_dFixAngle / 180)* PI - d3);
|
||
double d = d1 * d2;
|
||
|
||
XPoint ptTemp;
|
||
ptTemp.y = Wcs2Ucs(temp).y + d * sin((m_dFixAngle / 180)* PI);
|
||
ptTemp.x = Wcs2Ucs(temp).x + d * cos((m_dFixAngle / 180)* PI);
|
||
XVector3D vtOffset = ptTemp - Wcs2Ucs(temp);
|
||
m_pDrawEnt->SetLeaderPoint(Ucs2Wcs(ptTemp));
|
||
if (vtOffset.x<0.0)
|
||
m_pDrawEnt->SetTextBaseLen(-fabs(m_pDrawEnt->GetTextBaseLen()),FALSE);
|
||
else
|
||
m_pDrawEnt->SetTextBaseLen(fabs(m_pDrawEnt->GetTextBaseLen()),FALSE);
|
||
}
|
||
}
|
||
else if (m_nOperCode==TLeaderEdJig::kVertex)
|
||
{
|
||
}
|
||
else if (m_nOperCode==TLeaderEdJig::kTextLine)
|
||
{
|
||
XPoint ptLeader = m_pDrawEnt->GetLeaderPoint();
|
||
// mofidied by whl on 060208
|
||
// m_pDrawEnt->SetTextBaseLen(m_ptResult.x - ptLeader.x, FALSE);
|
||
m_pDrawEnt->SetTextBaseLen(Wcs2Ucs(m_ptResult).x - Wcs2Ucs(ptLeader).x, FALSE);
|
||
}
|
||
return bRet;
|
||
}
|
||
|
||
AcDbEntity* TLeaderEdJig::entity() const
|
||
{
|
||
return (AcDbEntity *)m_pDrawEnt;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
TLeaderAddOtherPtJig::TLeaderAddOtherPtJig(CLeaderDlg *pDlg, XPoint ptStart, XPoint ptBase,double dLayoutRotation)
|
||
:m_pDlg(pDlg)
|
||
{
|
||
m_bLeaderParall = FALSE;
|
||
m_bUpdateDlg = TRUE;
|
||
m_ptLeader = ptBase.AsAcGePoint3d();
|
||
m_ptFirstVertexes = ptStart.AsAcGePoint3d();
|
||
m_line.setStartPoint(m_ptLeader);
|
||
m_nLayoutRotation = dLayoutRotation;
|
||
}
|
||
|
||
TLeaderAddOtherPtJig::TLeaderAddOtherPtJig(BOOL bAllPtsOnLine, XPoint ptStart, XPoint ptBase,double dLayoutRotation,BOOL b)
|
||
:m_bAllOnLine(bAllPtsOnLine)
|
||
{
|
||
m_bUpdateDlg = FALSE;
|
||
m_ptLeader = ptBase.AsAcGePoint3d();
|
||
m_ptFirstVertexes = ptStart.AsAcGePoint3d();
|
||
m_line.setStartPoint(m_ptLeader);
|
||
m_nLayoutRotation = dLayoutRotation;
|
||
m_bLeaderParall = b;
|
||
}
|
||
|
||
// 开始执行拖动
|
||
int TLeaderAddOtherPtJig::DoIt(int *keyIndex)
|
||
{
|
||
// modify by xly on 100903 对象捕捉有效，不影响用户设置
|
||
// XPushVar<int> osmode(_T("OSMODE"), 0); // 临时将对象捕捉关掉
|
||
return TSymbEdJig::DoIt(keyIndex);
|
||
}
|
||
|
||
AcEdJig::DragStatus TLeaderAddOtherPtJig::GetPoint(XPoint &pt)
|
||
{
|
||
return acquirePoint(pt); // 自由拖拽，不受正交控制
|
||
}
|
||
|
||
Adesk::Boolean TLeaderAddOtherPtJig::update()
|
||
{
|
||
/* BOOL bOnLine;
|
||
if (m_bUpdateDlg) // 时时更新对话框
|
||
{
|
||
m_pDlg->UpdateData(TRUE);
|
||
bOnLine = m_pDlg->m_bAllPtsOnLine;
|
||
}
|
||
else // 一次性判断
|
||
{
|
||
bOnLine = m_bAllOnLine;
|
||
}
|
||
|
||
if (bOnLine) // 多点共线，将JIG时的鼠标位置点，投影到第一条引线上
|
||
{
|
||
AcGePoint3d ptRet = m_ptResult,
|
||
ptOnLine;
|
||
AcDbLine line(m_ptFirstVertexes, m_ptLeader); // 第一条引线
|
||
line.getClosestPointTo(ptRet, ptOnLine, Adesk::kTrue);
|
||
m_ptResult = ptOnLine;
|
||
}
|
||
m_line.setEndPoint(m_ptResult);
|
||
return Adesk::kTrue;
|
||
*/
|
||
int iStyle = 0;
|
||
if (m_bUpdateDlg)
|
||
{
|
||
m_pDlg->UpdateData();
|
||
iStyle = m_pDlg->GetLeaderStyle();
|
||
}
|
||
else
|
||
{
|
||
iStyle = m_bLeaderParall;
|
||
}
|
||
|
||
if (iStyle == 0) //多点共线
|
||
{
|
||
BOOL bOnLine;
|
||
if (m_bUpdateDlg) // 时时更新对话框
|
||
{
|
||
m_pDlg->UpdateData(TRUE);
|
||
bOnLine = m_pDlg->m_bAllPtsOnLine;
|
||
}
|
||
else // 一次性判断
|
||
{
|
||
bOnLine = m_bAllOnLine;
|
||
}
|
||
|
||
if (bOnLine) // 多点共线，将JIG时的鼠标位置点，投影到第一条引线上
|
||
{
|
||
AcGePoint3d ptRet = m_ptResult,
|
||
ptOnLine;
|
||
AcDbLine line(m_ptFirstVertexes, m_ptLeader); // 第一条引线
|
||
line.getClosestPointTo(ptRet, ptOnLine, Adesk::kTrue);
|
||
m_ptResult = ptOnLine;
|
||
}
|
||
}
|
||
else if (iStyle == 1) //引线平行
|
||
{
|
||
XPoint ptTemp;
|
||
ads_polar(TADSGePoint3d(m_ptLeader),m_nLayoutRotation, 100.0, ptTemp);
|
||
XLine textbaseline(TADSGePoint3d(m_ptLeader), ptTemp);
|
||
XLine line(m_ptResult,m_ptResult+(m_ptFirstVertexes - m_ptLeader));
|
||
ads_point ptads;
|
||
textbaseline.Intersection(&line,ptads);
|
||
m_line.setStartPoint(m_ptResult.AsAcGePoint3d());
|
||
m_line.setEndPoint(TADSGePoint3d(ptads).AsAcGePoint3d());
|
||
return Adesk::kTrue;
|
||
}
|
||
|
||
m_line.setEndPoint(m_ptResult);
|
||
return Adesk::kTrue;
|
||
}
|
||
|
||
AcDbEntity* TLeaderAddOtherPtJig::entity() const
|
||
{
|
||
return (AcDbEntity *)&m_line;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
TDrawingIndexEdJig::TDrawingIndexEdJig(TDbSymbDrawingIndex *pEnt,TCHAR *pszPormat,TCHAR *pszKeyWord):
|
||
m_pEnt(pEnt),
|
||
m_ptCur(0,0,0),
|
||
m_ptLast(0,0,0),
|
||
m_pszPormat(pszPormat),
|
||
m_pszKeyWord(pszKeyWord)
|
||
{
|
||
}
|
||
|
||
TDrawingIndexEdJig::~TDrawingIndexEdJig()
|
||
{
|
||
|
||
}
|
||
|
||
AcEdJig::DragStatus TDrawingIndexEdJig::doIt()
|
||
{
|
||
AcEdJig::DragStatus status =AcEdJig::kNull;
|
||
|
||
setDispPrompt(m_pszPormat);
|
||
|
||
try
|
||
{
|
||
status = drag();
|
||
}
|
||
catch(...)
|
||
{
|
||
status = AcEdJig::kCancel;
|
||
}
|
||
return status;
|
||
}
|
||
|
||
AcEdJig::DragStatus TDrawingIndexEdJig::sampler()
|
||
{
|
||
setUserInputControls((UserInputControls)(AcEdJig::kAccept3dCoordinates|
|
||
AcEdJig::kNullResponseAccepted));
|
||
|
||
AcEdJig::DragStatus status =AcEdJig::kCancel;
|
||
|
||
if (m_pszKeyWord)
|
||
{
|
||
setKeywordList(m_pszKeyWord);
|
||
}
|
||
|
||
status = acquirePoint(m_ptCur);
|
||
|
||
if (status == AcEdJig::kNormal)
|
||
{
|
||
if (m_ptCur.isEqualTo(m_ptLast))
|
||
{
|
||
return AcEdJig::kNoChange;
|
||
}
|
||
}
|
||
m_ptLast = m_ptCur;
|
||
|
||
return status;
|
||
}
|
||
|
||
Adesk::Boolean TDrawingIndexEdJig::update()
|
||
{
|
||
m_pEnt->SetCenter(m_ptCur); //位置
|
||
return Adesk::kTrue;
|
||
}
|
||
|
||
AcDbEntity *TDrawingIndexEdJig::entity() const
|
||
{
|
||
return (m_pEnt);
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
TElevEdJig::TElevEdJig(TDbSymbElevation *pElev)
|
||
{
|
||
m_nOperCode = TElevEdJig::kNone;
|
||
m_pDrawEnt = pElev;
|
||
}
|
||
|
||
XPoint TElevEdJig::GetDragPoint() const
|
||
{
|
||
XPoint ptDrag = m_ptResult;
|
||
XPoint ptArray[7];
|
||
m_pDrawEnt->GetVertexes(ptArray);
|
||
if (m_nOperCode == TElevEdJig::kDirection)
|
||
ptDrag = ptArray[2];
|
||
else if (m_nOperCode == TElevEdJig::kBaseLine)
|
||
ptDrag = ptArray[4];
|
||
else if (m_nOperCode==TElevEdJig::kLeader)
|
||
ptDrag = ptArray[6];
|
||
else if (m_nOperCode == TElevEdJig::kMove) // add by zkm
|
||
ptDrag = ptArray[0];
|
||
return ptDrag;
|
||
}
|
||
|
||
XPoint TElevEdJig::GetBasePoint() const
|
||
{
|
||
XPoint ptDrag = m_ptResult;
|
||
XPoint ptArray[7];
|
||
m_pDrawEnt->GetVertexes(ptArray);
|
||
if (m_nOperCode == TElevEdJig::kDirection)
|
||
// ptDrag = ptArray[2];
|
||
ptDrag = ptArray[0]; // sg modify 090209，根据林工提出的意见，仿照理正修改，方向JIG更明显
|
||
else if (m_nOperCode == TElevEdJig::kBaseLine)
|
||
ptDrag = ptArray[0];
|
||
else if (m_nOperCode == TElevEdJig::kMove) // add by zkm
|
||
{
|
||
ptDrag = m_ptBase;
|
||
if (g_bHightWrite)
|
||
ptDrag = ptArray[0];
|
||
}
|
||
return ptDrag;
|
||
}
|
||
|
||
// 开始执行拖动
|
||
int TElevEdJig::DoIt(int *keyIndex)
|
||
{
|
||
m_ptResult = GetDragPoint();
|
||
return TSymbEdJig::DoIt(keyIndex);
|
||
}
|
||
|
||
// 反馈
|
||
AcEdJig::DragStatus TElevEdJig::GetPoint(XPoint &pt)
|
||
{
|
||
return acquirePoint(pt, GetBasePoint().AsAcGePoint3d());
|
||
}
|
||
|
||
// 更新实体数据
|
||
Adesk::Boolean TElevEdJig::update()
|
||
{
|
||
Adesk::Boolean bRet = Adesk::kTrue;
|
||
AcGePoint3dArray gripPoints;
|
||
TDbSymbElevation *pElev = m_pDrawEnt;
|
||
VERIFY(pElev->getStretchPoints(gripPoints) == Acad::eOk);
|
||
if (m_nOperCode == TElevEdJig::kDirection)
|
||
{
|
||
// sg modify 090327，解决正交打开时，无法绘制文字在符号左下方的情况；
|
||
// AcGeVector3d vtOffset = m_ptResult.AsAcGePoint3d() - gripPoints[1];
|
||
AcGeVector3d vtOffset = m_ptResult.AsAcGePoint3d() - gripPoints[0];
|
||
AcDbIntArray indices;
|
||
indices.append(1);
|
||
if (vtOffset.length() > _DIST_SNAP*10)
|
||
{
|
||
// sg modify 090330，解决灵敏度丢失问题，首先将矢量单位化，再扩大
|
||
vtOffset.normalize();
|
||
double dScale = (2*DocGetEleTriangleSize() + 0.5) * DocGetPScale();
|
||
vtOffset *= dScale;
|
||
pElev->moveGripPointsAt(indices, vtOffset);
|
||
}
|
||
|
||
if (pElev->IsFilled() || pElev->IsHollowTriangle()) // sg add 090209，增加文字位置点设置
|
||
pElev->SetTextBaseLen(DocGetEleTriangleSize());
|
||
else if (pElev->IsDote())
|
||
pElev->SetTextBaseLen(DocGetEleDoteSize());
|
||
else
|
||
pElev->SetTextBaseLen(pElev->GetDefaultTextBaseLen());
|
||
pElev->SetTextPoint(pElev->GetDefaultTextLocation());
|
||
pElev->SetLowTextPt(pElev->GetDefaultTextLocation2()); // sg add 090223
|
||
}
|
||
else if (m_nOperCode == TElevEdJig::kBaseLine)
|
||
{
|
||
AcGeVector3d vtOffset = m_ptResult.AsAcGePoint3d() - gripPoints[3];
|
||
AcDbIntArray indices;
|
||
indices.append(3);
|
||
if (vtOffset.length() > _DIST_SNAP)
|
||
pElev->moveGripPointsAt(indices, vtOffset);
|
||
}
|
||
else if (m_nOperCode == TElevEdJig::kLeader)
|
||
{
|
||
int idx=pElev->HasBaseLine()? 4 : 3;
|
||
AcGeVector3d vtOffset = m_ptResult.AsAcGePoint3d() - gripPoints[idx];
|
||
AcDbIntArray indices;
|
||
indices.append(idx);
|
||
if (vtOffset.length() > _DIST_SNAP*10)
|
||
pElev->moveGripPointsAt(indices, vtOffset);
|
||
}
|
||
// add by zkm
|
||
else if (m_nOperCode == TElevEdJig::kMove)
|
||
{
|
||
XPoint pt = Wcs2Ucs(m_ptResult);
|
||
XPoint pt1 = Wcs2Ucs(gripPoints[0]);
|
||
XPoint vtOffset = pt - pt1;
|
||
// sg modify 120611，不能直接使用全局变量
|
||
//if (g_bOrder && !CElevDlg::g_pElevDlg->m_bOrderTou)
|
||
if (CElevDlg::g_pElevDlg->IsOrder() && !CElevDlg::g_pElevDlg->m_bOrderTou)
|
||
{
|
||
pt1.y = pt.y;
|
||
pt1.x = m_dPointX;
|
||
gripPoints[0] = Ucs2Wcs(pt1).AsAcGePoint3d();
|
||
}
|
||
else
|
||
gripPoints[0] = m_ptResult.AsAcGePoint3d();
|
||
|
||
pElev->SetLocation(gripPoints[0]);
|
||
acedGetAcadDwgView()->SetFocus();
|
||
CElevDlg::g_pElevDlg->UpdateGrid(m_fBaseElev+_AS_METER(pt.y-Wcs2Ucs(m_ptBase).y)); // [12/4/2007 nsh]，解决M单位问题
|
||
CElevDlg::g_pElevDlg->UpdataEnt();
|
||
CElevDlg::g_pElevDlg->UpdateEntText();
|
||
pElev->SetTextPoint(pElev->GetDefaultTextLocation()); // sg add 090209，增加文字位置点设置
|
||
pElev->SetLowTextPt(pElev->GetDefaultTextLocation2()); // sg add 090223
|
||
}
|
||
else
|
||
{
|
||
bRet = Adesk::kFalse;
|
||
}
|
||
return bRet;
|
||
}
|
||
|
||
AcDbEntity* TElevEdJig::entity() const
|
||
{
|
||
return (AcDbEntity *)m_pDrawEnt;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
TNorthThumbEdJig::TNorthThumbEdJig(TDbSymbNorthThumb *pElev)
|
||
{
|
||
m_pDrawEnt=pElev;
|
||
}
|
||
|
||
// 开始执行拖动
|
||
int TNorthThumbEdJig::DoIt(int *keyIndex)
|
||
{
|
||
m_ptResult=m_nOperCode==kCenter?
|
||
m_pDrawEnt->GetCenter() : m_pDrawEnt->GetNorthPoint();
|
||
|
||
int nRet=TSymbEdJig::DoIt(keyIndex);
|
||
return nRet;
|
||
}
|
||
|
||
BOOL TNorthThumbEdJig::IsPosChanged(XPoint ptNew) const
|
||
{
|
||
BOOL bRet;
|
||
if(m_nOperCode==kCenter)
|
||
bRet=TSymbEdJig::IsPosChanged(ptNew);
|
||
else {
|
||
double nAngOld=ads_angle(m_pDrawEnt->GetCenter(), m_ptResult);
|
||
double nAngNew=ads_angle(m_pDrawEnt->GetCenter(), ptNew);
|
||
double nAng1=CT_std_angle(nAngOld-nAngNew);
|
||
double nAng2=CT_std_angle(nAngNew-nAngOld);
|
||
if(nAng1<_angSnap || nAng2<_angSnap)
|
||
bRet=FALSE;
|
||
else bRet=TRUE;
|
||
}
|
||
return bRet;
|
||
}
|
||
|
||
// 反馈
|
||
AcEdJig::DragStatus TNorthThumbEdJig::GetPoint(XPoint &pt)
|
||
{
|
||
AcEdJig::DragStatus stat;
|
||
if(m_nOperCode==kCenter)
|
||
stat=acquirePoint(pt);
|
||
else {
|
||
double nAng=PI/2.0;
|
||
stat=acquireAngle(nAng, m_pDrawEnt->GetCenter().AsAcGePoint3d());
|
||
if(stat==AcEdJig::kNull) {
|
||
nAng=PI/2.0;
|
||
stat=AcEdJig::kNormal;
|
||
}
|
||
if(stat==AcEdJig::kNormal)
|
||
ads_polar(m_pDrawEnt->GetCenter(), nAng, m_pDrawEnt->GetRadius(), pt);
|
||
}
|
||
|
||
return stat;
|
||
}
|
||
|
||
// 更新实体数据
|
||
Adesk::Boolean TNorthThumbEdJig::update()
|
||
{
|
||
Adesk::Boolean bRet=Adesk::kTrue;
|
||
if(m_nOperCode==kCenter)
|
||
m_pDrawEnt->SetCenter(m_ptResult);
|
||
else
|
||
m_pDrawEnt->SetRotation(ads_angle(m_pDrawEnt->GetCenter(), m_ptResult));
|
||
return bRet;
|
||
}
|
||
|
||
AcDbEntity* TNorthThumbEdJig::entity() const
|
||
{
|
||
return (AcDbEntity *)m_pDrawEnt;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
TSymmetryEdJig::TSymmetryEdJig(TDbSymbSymmetry *pElev)
|
||
{
|
||
m_pDrawEnt=pElev;
|
||
m_ptResult=m_pDrawEnt->GetEndPoint();
|
||
}
|
||
|
||
// 反馈
|
||
AcEdJig::DragStatus TSymmetryEdJig::GetPoint(XPoint &pt)
|
||
{
|
||
return acquirePoint(pt, m_pDrawEnt->GetStartPoint().AsAcGePoint3d());
|
||
}
|
||
|
||
// 更新实体数据
|
||
Adesk::Boolean TSymmetryEdJig::update()
|
||
{
|
||
Adesk::Boolean bRet=Adesk::kTrue;
|
||
m_pDrawEnt->SetEndPoint(m_ptResult);
|
||
return bRet;
|
||
}
|
||
|
||
AcDbEntity* TSymmetryEdJig::entity() const
|
||
{
|
||
return (AcDbEntity *)m_pDrawEnt;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
TSectionEdJig::TSectionEdJig(TDbSymbSection *pElev)
|
||
{
|
||
m_pDrawEnt=pElev;
|
||
m_iFlag2=0;
|
||
//add by lgy 20120320 控制莫种jig剖面符号方式显示
|
||
m_nMode = 1;
|
||
m_pDlg = NULL;
|
||
}
|
||
|
||
//add by lgy 20120322 为jig添加对话框，为了jig时能实时与对话框交互
|
||
void TSectionEdJig::SetJigDlg(CSectionDlg *pDlg)
|
||
{
|
||
m_pDlg = pDlg;
|
||
}
|
||
int TSectionEdJig::GetiFlag2()
|
||
{
|
||
return m_iFlag2;
|
||
}
|
||
|
||
void TSectionEdJig::SetJigMode(int nMode)
|
||
{
|
||
m_nMode = nMode;
|
||
}
|
||
|
||
// 开始执行拖动
|
||
int TSectionEdJig::DoIt(int *keyIndex)
|
||
{
|
||
XPushVar<int> osmode(_T("OSMODE"), 0);//add by whl
|
||
|
||
if(m_nOperCode==kSectPointOther)
|
||
{
|
||
m_iFlag2=1-m_iFlag2;
|
||
CopyObject(*m_pDrawEnt, m_drawEnt);
|
||
XPoly2D poly;
|
||
m_drawEnt.GetPoly2D(poly);
|
||
ASSERT(poly.Length()>=2);
|
||
m_ptResult=*poly.Tail();
|
||
//modify by lgy 20120320 如果为非正交转折剖切
|
||
//if(m_iFlag2==1)
|
||
m_nMode = m_pDlg->GetSectionMode();
|
||
if(m_iFlag2==1&&m_nMode!=3)
|
||
{
|
||
poly.AppendNode(m_ptResult);
|
||
poly.AppendNode(m_ptResult);
|
||
}
|
||
else if (m_nMode == 3) //非正交转折剖切
|
||
{
|
||
poly.AppendNode(m_ptResult);
|
||
}
|
||
m_drawEnt.SetPoly2D(poly);
|
||
}
|
||
else if(m_nOperCode==kSectPoint || m_nOperCode==kViewDirection)
|
||
{
|
||
XPoly2D poly;
|
||
m_pDrawEnt->GetPoly2D(poly);
|
||
ASSERT(poly.Length()>=2);
|
||
m_ptResult=*poly.Tail();
|
||
}
|
||
|
||
//modify by lgy 20120530 非正交剖切支持对象捕捉
|
||
//int nRet = TSymbEdJig::DoIt(keyIndex);
|
||
int nRet = 0;
|
||
if (m_nMode != 3)
|
||
{
|
||
nRet = TSymbEdJig::DoIt(keyIndex);
|
||
}
|
||
else //绘制模式为非正交转正剖切，需要恢复对象捕捉
|
||
{
|
||
XPushVar<int> osmode(_T("OSMODE"), 16383);
|
||
nRet = TSymbEdJig::DoIt(keyIndex);
|
||
}
|
||
if(m_nOperCode==kSectPointOther)
|
||
{
|
||
if(nRet==RTNORM||(nRet==RTNONE&&m_iFlag2==0))
|
||
CopyObject(m_drawEnt, *m_pDrawEnt);
|
||
}
|
||
return nRet;
|
||
}
|
||
|
||
// 反馈
|
||
AcEdJig::DragStatus TSectionEdJig::GetPoint(XPoint &pt)
|
||
{
|
||
DragStatus stat;
|
||
XPoint ptBase;
|
||
XPoly2D poly;
|
||
m_pDrawEnt->GetPoly2D(poly);
|
||
if(m_nOperCode==kSectPoint)
|
||
{
|
||
ASSERT(poly.Length()==2);
|
||
ptBase=*poly.Head();
|
||
}
|
||
else if(m_nOperCode==kSectPointOther ||
|
||
m_nOperCode==kViewDirection)
|
||
{
|
||
ASSERT(poly.Length()>=2);
|
||
if(m_iFlag2==1)
|
||
ptBase=*poly.Tail();
|
||
else
|
||
ptBase=*poly[poly.Length()-2];
|
||
}
|
||
else
|
||
{
|
||
ASSERT(0);
|
||
}
|
||
|
||
//add by lgy 20120525 如果是非正交剖切，jig时橡皮线需要修改
|
||
if (m_nMode == 3)
|
||
{
|
||
if(m_nOperCode==kSectPoint)
|
||
{
|
||
ASSERT(poly.Length()==2);
|
||
ptBase=*poly.Head();
|
||
}
|
||
else
|
||
{
|
||
ptBase = *poly.Tail();
|
||
}
|
||
}
|
||
stat=acquirePoint(pt, ptBase);
|
||
return stat;
|
||
}
|
||
|
||
// 更新实体数据
|
||
Adesk::Boolean TSectionEdJig::update()
|
||
{
|
||
//add by lgy 20120426 确保对话框中内容能与实体实时交互
|
||
double dHeight = m_pDlg->GetNumHeight();
|
||
m_pDrawEnt->SetTextHeight(dHeight);
|
||
m_pDrawEnt->SetText(m_pDlg->GetSectionNum());
|
||
AcDbObjectId idScaleStyle = InitTextStyle(m_pDlg->GetNumStyle());
|
||
m_pDrawEnt->SetTextStyleId(idScaleStyle);
|
||
|
||
if (m_pDlg->GetIsShowDrawText())
|
||
{
|
||
if (m_pDlg->GetLocal() == 0) //两端显示
|
||
{
|
||
m_pDrawEnt->SetIsHasIndexS(TRUE);
|
||
m_pDrawEnt->SetIsHasIndexE(TRUE);
|
||
}
|
||
else if (m_pDlg->GetLocal() == 1)//始端显示
|
||
{
|
||
m_pDrawEnt->SetIsHasIndexS(TRUE);
|
||
m_pDrawEnt->SetIsHasIndexE(FALSE);
|
||
}
|
||
else if (m_pDlg->GetLocal() == 2)//末端显示
|
||
{
|
||
m_pDrawEnt->SetIsHasIndexS(FALSE);
|
||
m_pDrawEnt->SetIsHasIndexE(TRUE);
|
||
}
|
||
|
||
if (!m_pDlg->GetDirect())
|
||
{
|
||
m_pDrawEnt->SetDimDirection(0); //剖切方向
|
||
}
|
||
else
|
||
{
|
||
m_pDrawEnt->SetDimDirection(1); //剖视方向
|
||
}
|
||
|
||
m_pDrawEnt->SetDrawingIndex(m_pDlg->GetDrawNum());
|
||
m_pDrawEnt->SetIndexHeight(m_pDlg->GetDrawHeight());
|
||
m_pDrawEnt->SetIndexStyleId(InitTextStyle(m_pDlg->GetDrawingStyle()));
|
||
}
|
||
else //不显示文字时，默认仍要有文字样式
|
||
{
|
||
m_pDrawEnt->SetDrawingIndex(_T("1")); //如果不显示文字，为标注设置默认位置为1
|
||
m_pDrawEnt->SetIndexStyleId(InitTextStyle(TS_INDEXSCALE));
|
||
m_pDrawEnt->SetIndexHeight(3.5);
|
||
}
|
||
|
||
Adesk::Boolean bRet=Adesk::kTrue;
|
||
if(m_nOperCode==kSectPoint)
|
||
{
|
||
XPoly2D poly;
|
||
m_pDrawEnt->GetPoly2D(poly);
|
||
ASSERT(poly.Length()==2);
|
||
XPoint pt1=*poly[0];
|
||
*poly[1]=m_ptResult;
|
||
double nViewDir=ads_angle(pt1, m_ptResult)-PI/2.0;
|
||
m_pDrawEnt->SetPoly2D(poly);
|
||
m_pDrawEnt->SetViewDirection(nViewDir);
|
||
//add by lgy 20120525 如果是非正交转正剖切，需要设置末尾点的剖视线的角度
|
||
if(m_nMode == 3)
|
||
{
|
||
m_pDrawEnt->SetNonPerpendicularitySection(TRUE);
|
||
m_pDrawEnt->SetViewDirection2(nViewDir);
|
||
}
|
||
|
||
m_pDrawEnt->SetTextLocation(0, m_pDrawEnt->GetDefaultTextLocation(0));
|
||
m_pDrawEnt->SetTextLocation(1, m_pDrawEnt->GetDefaultTextLocation(1));
|
||
//add by lgy 20120319 9.0中添加剖面符号文字，需要设置其显示的位置点
|
||
m_pDrawEnt->SetIndexLocation(0, m_pDrawEnt->GetDefaultIndexLocation(0));
|
||
m_pDrawEnt->SetIndexLocation(1, m_pDrawEnt->GetDefaultIndexLocation(1));
|
||
}
|
||
else if(m_nOperCode==kSectPointOther)
|
||
{
|
||
XPoly2D poly;
|
||
m_drawEnt.GetPoly2D(poly);
|
||
int nLen=poly.Length();
|
||
ASSERT(nLen>=3);
|
||
if(m_iFlag2==0)
|
||
{
|
||
//add by lgy 20120320 添加以下if判断，是为了解决非正交转折剖面的问题
|
||
if (m_nMode != 3) //不是非正交转折
|
||
{
|
||
XPoint pt1=*poly[nLen-3];
|
||
XPoint pt2=*poly[nLen-2];
|
||
XLine ln(m_ptResult, ads_angle(pt1, pt2));
|
||
XPoint pt3;
|
||
pt2.Project(&ln, pt3);
|
||
*poly[nLen-1]=pt3;
|
||
}
|
||
else
|
||
{
|
||
*poly[nLen-1]=m_ptResult;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//add by lgy 20120320 添加以下if判断，是为了解决非正交转折剖面的问题
|
||
if (m_nMode != 3) //不是非正交转折
|
||
{
|
||
XPoint pt1=*poly[nLen-4];
|
||
XPoint pt2=*poly[nLen-3];
|
||
XLine ln(m_ptResult, ads_angle(pt1, pt2));
|
||
XPoint pt3;
|
||
pt2.Project(&ln, pt3);
|
||
*poly[nLen-2]=pt3;
|
||
*poly[nLen-1]=m_ptResult;
|
||
}
|
||
else
|
||
{
|
||
*poly[nLen-1]=m_ptResult;
|
||
}
|
||
}
|
||
|
||
SetPrompt(_T("\n点取下一个剖切点<结束>:"));
|
||
m_drawEnt.SetPoly2D(poly);
|
||
nLen=poly.Length();
|
||
ASSERT(nLen>=2);
|
||
if(m_iFlag2==1)
|
||
{
|
||
//modify by lgy 20120525 考虑非正交转正剖切时剖视线的方向
|
||
//XLine ln1(*poly[nLen-4], *poly[nLen-3]);
|
||
//int nSide=ln1.OnWhichSide(m_ptResult);
|
||
//if(nSide==OFFSET_LEFT)
|
||
// m_drawEnt.SetViewDirection(CT_std_angle(ln1.Direction()+PI/2));
|
||
//else
|
||
// m_drawEnt.SetViewDirection(CT_std_angle(ln1.Direction()-PI/2));
|
||
if (m_nMode != 3)
|
||
{
|
||
XLine ln1(*poly[nLen-4], *poly[nLen-3]);
|
||
int nSide=ln1.OnWhichSide(m_ptResult);
|
||
if(nSide==OFFSET_LEFT)
|
||
{
|
||
m_drawEnt.SetViewDirection(CT_std_angle(ln1.Direction()+PI/2));
|
||
}
|
||
else
|
||
{
|
||
m_drawEnt.SetViewDirection(CT_std_angle(ln1.Direction()-PI/2));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
m_drawEnt.SetNonPerpendicularitySection(TRUE);
|
||
|
||
XLine ln2(*poly[nLen-2], *poly[nLen-1]);
|
||
XLine ln3(*poly[0], *poly[1]);
|
||
int nSide=ln3.OnWhichSide(m_ptResult);
|
||
|
||
if (nSide == OFFSET_LEFT)
|
||
{
|
||
m_drawEnt.SetViewDirection(CT_std_angle(ln3.Direction()+PI/2));
|
||
m_drawEnt.SetViewDirection2(CT_std_angle(ln2.Direction()+PI/2));
|
||
}
|
||
else
|
||
{
|
||
m_drawEnt.SetViewDirection(CT_std_angle(ln3.Direction()-PI/2));
|
||
m_drawEnt.SetViewDirection2(CT_std_angle(ln2.Direction()-PI/2));
|
||
}
|
||
}
|
||
|
||
|
||
m_drawEnt.SetTextLocation(0, m_drawEnt.GetDefaultTextLocation(0));
|
||
m_drawEnt.SetTextLocation(1, m_drawEnt.GetDefaultTextLocation(1));
|
||
//add by lgy 20120319 9.0中添加剖面符号文字，需要设置其显示的位置点
|
||
m_drawEnt.SetIndexLocation(0, m_drawEnt.GetDefaultIndexLocation(0));
|
||
m_drawEnt.SetIndexLocation(1, m_drawEnt.GetDefaultIndexLocation(1));
|
||
}
|
||
else
|
||
{
|
||
//modify by lgy 20120525 考虑非转正剖切时剖视角度
|
||
//if(nSide==OFFSET_LEFT)
|
||
// m_drawEnt.SetViewDirection(CT_std_angle(ln1.Direction()+PI/2));
|
||
//else
|
||
// m_drawEnt.SetViewDirection(CT_std_angle(ln1.Direction()-PI/2));
|
||
if (m_nMode != 3)
|
||
{
|
||
XLine ln1(*poly[nLen-2], *poly[nLen-1]);
|
||
int nSide=ln1.OnWhichSide(m_ptResult);
|
||
if(nSide==OFFSET_LEFT)
|
||
{
|
||
m_drawEnt.SetViewDirection(CT_std_angle(ln1.Direction()+PI/2));
|
||
}
|
||
else
|
||
{
|
||
m_drawEnt.SetViewDirection(CT_std_angle(ln1.Direction()-PI/2));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
m_drawEnt.SetNonPerpendicularitySection(TRUE);
|
||
XLine ln2(*poly[nLen-2], *poly[nLen-1]);
|
||
XLine ln3(*poly[0], *poly[1]);
|
||
int nSide=ln3.OnWhichSide(m_ptResult);
|
||
if (nSide == OFFSET_LEFT)
|
||
{
|
||
m_drawEnt.SetViewDirection(CT_std_angle(ln3.Direction()+PI/2));
|
||
m_drawEnt.SetViewDirection2(CT_std_angle(ln2.Direction()+PI/2));
|
||
}
|
||
else
|
||
{
|
||
m_drawEnt.SetViewDirection(CT_std_angle(ln3.Direction()-PI/2));
|
||
m_drawEnt.SetViewDirection2(CT_std_angle(ln2.Direction()-PI/2));
|
||
}
|
||
}
|
||
|
||
|
||
m_drawEnt.SetTextLocation(1, m_drawEnt.GetDefaultTextLocation(1));
|
||
//add by lgy 20120319 9.0中添加剖面符号文字，需要设置其显示的位置点
|
||
m_drawEnt.SetIndexLocation(0, m_drawEnt.GetDefaultIndexLocation(0));
|
||
m_drawEnt.SetIndexLocation(1, m_drawEnt.GetDefaultIndexLocation(1));
|
||
}
|
||
|
||
}
|
||
else if(m_nOperCode==kViewDirection)
|
||
{
|
||
XPoly2D poly;
|
||
m_pDrawEnt->GetPoly2D(poly);
|
||
int nLen=poly.Length();
|
||
//modify by lgy 20120525 考虑非正交转正剖切
|
||
// ASSERT(nLen>=2);
|
||
// XLine ln(*poly[nLen-2], *poly[nLen-1]);
|
||
// int nSide=ln.OnWhichSide(m_ptResult);
|
||
// if(nSide==OFFSET_LEFT)
|
||
// m_pDrawEnt->SetViewDirection(CT_std_angle(ln.Direction()+PI/2));
|
||
// else
|
||
// m_pDrawEnt->SetViewDirection(CT_std_angle(ln.Direction()-PI/2));
|
||
if (m_nMode != 3)
|
||
{
|
||
if (nLen < 2)
|
||
{
|
||
return Adesk::kFalse;
|
||
}
|
||
XLine ln(*poly[nLen-2], *poly[nLen-1]);
|
||
int nSide=ln.OnWhichSide(m_ptResult);
|
||
if(nSide==OFFSET_LEFT)
|
||
{
|
||
m_pDrawEnt->SetViewDirection(CT_std_angle(ln.Direction()+PI/2));
|
||
}
|
||
else
|
||
{
|
||
m_pDrawEnt->SetViewDirection(CT_std_angle(ln.Direction()-PI/2));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (nLen < 2)
|
||
{
|
||
return Adesk::kFalse;
|
||
}
|
||
m_pDrawEnt->SetNonPerpendicularitySection(TRUE);
|
||
|
||
XLine ln(*poly[nLen-2], *poly[nLen-1]);
|
||
XLine ln1(*poly[0], *poly[1]);
|
||
int nSide=ln.OnWhichSide(m_ptResult);
|
||
if(nSide==OFFSET_LEFT)
|
||
{
|
||
m_pDrawEnt->SetViewDirection(CT_std_angle(ln1.Direction()+PI/2));
|
||
m_pDrawEnt->SetViewDirection2(CT_std_angle(ln.Direction()+PI/2));
|
||
}
|
||
else
|
||
{
|
||
m_pDrawEnt->SetViewDirection(CT_std_angle(ln1.Direction()-PI/2));
|
||
m_pDrawEnt->SetViewDirection2(CT_std_angle(ln.Direction()-PI/2));
|
||
}
|
||
}
|
||
|
||
|
||
|
||
m_pDrawEnt->SetTextLocation(0, m_pDrawEnt->GetDefaultTextLocation(0));
|
||
m_pDrawEnt->SetTextLocation(1, m_pDrawEnt->GetDefaultTextLocation(1));
|
||
//add by lgy 20120319 9.0中添加剖面符号文字，需要设置其显示的位置点
|
||
m_pDrawEnt->SetIndexLocation(0, m_pDrawEnt->GetDefaultIndexLocation(0));
|
||
m_pDrawEnt->SetIndexLocation(1, m_pDrawEnt->GetDefaultIndexLocation(1));
|
||
}
|
||
return bRet;
|
||
}
|
||
|
||
AcDbEntity* TSectionEdJig::entity() const
|
||
{
|
||
|
||
return ((m_nOperCode==kSectPointOther)? (AcDbEntity *)&m_drawEnt : (AcDbEntity *)m_pDrawEnt);
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
TCloudLineJig::TCloudLineJig(TDbSymbModi *pModi, XPoint ptFirst, double dMax, double dMin)
|
||
{
|
||
m_dMax = dMax;
|
||
m_dMin = dMin;
|
||
m_ptFirst = ptFirst;
|
||
|
||
m_pline.Reset();
|
||
m_pline.AppendNode(m_ptFirst);
|
||
|
||
m_pModi = pModi;
|
||
m_pModi->SetModiPoly(m_pline);
|
||
}
|
||
|
||
TCloudLineJig::~TCloudLineJig()
|
||
{
|
||
}
|
||
|
||
int TCloudLineJig::DoIt(int *keyIndex)
|
||
{
|
||
int nLength = m_pline.Length();
|
||
if (nLength > 1)
|
||
m_ptResult = *m_pline[nLength-1];
|
||
else
|
||
m_ptResult = m_ptFirst;
|
||
|
||
int nRet = TSymbEdJig::DoIt(keyIndex);
|
||
|
||
{
|
||
XPoint ptLast;
|
||
int nLength = m_pline.Length();
|
||
if (nLength > 1)
|
||
ptLast = *m_pline[nLength-1];
|
||
else
|
||
ptLast = m_ptFirst;
|
||
|
||
double dLengh(0.0);
|
||
XCurveSegment segTemp(ptLast, m_ptFirst, 0);
|
||
while (dLengh < segTemp.GetLength() - _DIST_SNAP)
|
||
{
|
||
TADSGePointDir2d ptMid;
|
||
segTemp.Polar(dLengh, ptMid);
|
||
m_pline.AppendNode(ptMid.AsAcGePoint3d());
|
||
|
||
double dTotalLen = (rand()%10)/10.000;
|
||
dTotalLen = dTotalLen*m_dMax;
|
||
if (dTotalLen < m_dMin)
|
||
{
|
||
dTotalLen += m_dMin;
|
||
}
|
||
|
||
dLengh = dLengh + dTotalLen;
|
||
}
|
||
}
|
||
|
||
m_pline.SetClosed();
|
||
if (m_pline.PathArea() > 0)
|
||
m_pline.Reverse();
|
||
m_pModi->SetModiPoly(m_pline);
|
||
return nRet;
|
||
}
|
||
|
||
AcEdJig::DragStatus TCloudLineJig::GetPoint(XPoint &pt)
|
||
{
|
||
XPoint ptBase;
|
||
int nLength = m_pline.Length();
|
||
if (nLength > 1)
|
||
ptBase = *m_pline[nLength-1];
|
||
else
|
||
ptBase = m_ptFirst;
|
||
|
||
AcEdJig::DragStatus status;
|
||
status = acquirePoint(pt, ptBase);
|
||
|
||
double dDistance = pt.Distance(ptBase);
|
||
if (dDistance>m_dMin-_DIST_SNAP && dDistance<m_dMax+_DIST_SNAP) // 直接1个弧就可以解决
|
||
{
|
||
m_pline.AppendNode(pt);
|
||
}
|
||
else if (dDistance > m_dMax+_DIST_SNAP) // 需要多个弧连接
|
||
{
|
||
XCurveSegment segTemp(ptBase, pt, 0);
|
||
|
||
double dLengh(0.0);
|
||
while (dLengh < dDistance + _DIST_SNAP)
|
||
{
|
||
TADSGePointDir2d ptMid;
|
||
segTemp.Polar(dLengh, ptMid);
|
||
m_pline.AppendNode(ptMid.AsAcGePoint3d());
|
||
|
||
double dTotalLen = (rand()%10)/10.000;
|
||
dTotalLen = dTotalLen*m_dMax;
|
||
if (dTotalLen < m_dMin)
|
||
{
|
||
dTotalLen += m_dMin;
|
||
}
|
||
dLengh = dLengh + dTotalLen;
|
||
}
|
||
}
|
||
return status;
|
||
}
|
||
|
||
Adesk::Boolean TCloudLineJig::update()
|
||
{
|
||
if (m_pline.PathArea() > 0)
|
||
m_pModi->SetArcAngle(-0.5);
|
||
else
|
||
m_pModi->SetArcAngle(0.5);
|
||
|
||
m_pModi->SetModiPoly(m_pline);
|
||
return Adesk::kTrue;
|
||
}
|
||
|
||
AcDbEntity* TCloudLineJig::entity() const
|
||
{
|
||
return (AcDbEntity*)m_pModi;
|
||
}
|
||
|
||
|
||
|