public Xline(CADPoint basePoint, CADVector direction)
{
_basePoint = basePoint;
_direction = direction;
}
public Circle2(CADPoint center, double radius)
{
this.center = center;
this.radius = radius;
}
public override void DrawLine(CADPoint startPoint, CADPoint endPoint, bool mdoelToCanvas = true)
{
DrawLine(_drawing, thisDC, Selected ? sPen : Pen, startPoint, endPoint);
}
public virtual void DrawRay(CADPoint basePoint, CADVector direction, bool mdoelToCanvas = true)
{
}
public ObjectSnapPoint(ObjectSnapMode type, CADPoint pos)
{
Type = type;
Position = pos;
}
public void DrawEllipse(CADPoint center, double radiusX, double radiusY, bool mdoelToCanvas = true)
{
DrawCircle(_drawing, thisDC, FillBrush, Pen, center, radiusX, radiusY, mdoelToCanvas);
}
public virtual void DrawRectangle(CADPoint startPoint, double width, double height, bool mdoelToCanvas = true)
{
DrawRectangle(_drawing, thisDC, FillBrush, Pen, startPoint, width, height, mdoelToCanvas);
}
public Line(CADPoint startPnt, CADPoint endPnt)
{
_startPoint = startPnt;
_endPoint = endPnt;
}
public override void Translate(CADVector translation)
{
_startPoint += translation;
_endPoint += translation;
}
public abstract bool Read(string name, out CADPoint value);
public static Point AsWPF(this CADPoint p)
{
return(new Point(p.X, p.Y));
}
public abstract bool Write(string name, CADPoint value);
internal override bool Cross(Bounding selectBound, Entity entity)
{
Arc arc = entity as Arc;
if (arc == null)
{
return(false);
}
Bounding arcBounding = arc.Bounding;
if (selectBound.Contains(arcBounding))
{
return(true);
}
if (!selectBound.IntersectWith(arcBounding))
{
return(false);
}
Circle circle = new Circle(arc.center, arc.radius);
CADPoint nearestPntOnBound = new CADPoint(
System.Math.Max(selectBound.left, System.Math.Min(circle.center.X, selectBound.right)),
System.Math.Max(selectBound.bottom, System.Math.Min(circle.center.Y, selectBound.top)));
if (CADPoint.Distance(nearestPntOnBound, circle.center) <= circle.radius)
{
double bdLeft = selectBound.left;
double bdRight = selectBound.right;
double bdTop = selectBound.top;
double bdBottom = selectBound.bottom;
List <CADPoint> pnts = new List <CADPoint>();
pnts.Add(new CADPoint(bdLeft, bdTop));
pnts.Add(new CADPoint(bdLeft, bdBottom));
pnts.Add(new CADPoint(bdRight, bdTop));
pnts.Add(new CADPoint(bdRight, bdBottom));
CADVector xp = new CADVector(1, 0);
foreach (CADPoint pnt in pnts)
{
if (CADPoint.Distance(pnt, circle.center) >= circle.radius)
{
CADVector v = pnt - circle.center;
double rad = CADVector.AngleInRadian(xp, v);
if (CADVector.Cross(xp, v) < 0)
{
rad = System.Math.PI * 2 - rad;
}
if (AngleInRange(rad, arc.startAngle, arc.endAngle))
{
return(true);
}
}
}
return(false);
}
else
{
return(false);
}
}
public override void Translate(CADVector translation)
{
_basePoint += translation;
}
protected static void DrawRectangle(IDrawing owner, DrawingContext thisDC, Brush fillBrush, Pen pen, CADPoint startPoint, double width, double height, bool mdoelToCanvas = true)
{
var p = startPoint;
if (mdoelToCanvas)
{
p = owner.ModelToCanvas(new CADPoint(startPoint.X, startPoint.Y));
}
thisDC.DrawRectangle(fillBrush, pen, new Rect(new Point(p.X, p.Y), new Size(width, height)));
}
public override void TransformBy(Matrix3 transform)
{
_startPoint = transform * _startPoint;
_endPoint = transform * _endPoint;
}
public static void DrawXLine(IDrawing owner, DrawingContext thisDC, Pen pen, CADPoint basePoint, CADVector direction, bool mdoelToCanvas = true)
{
CADVector dir;
CADPoint basePnt;
if (mdoelToCanvas)
{
basePnt = owner.ModelToCanvas(basePoint);
CADPoint otherPnt = owner.ModelToCanvas(basePoint + direction);
dir = (otherPnt - basePnt).normalized;
}
else
{
basePnt = basePoint;
dir = direction;
dir.Normalize();
}
double xk = double.MinValue;
double yk = double.MinValue;
if (dir.Y != 0)
{
double k = basePnt.Y / dir.Y;
xk = basePnt.X - k * dir.X;
}
if (dir.X != 0)
{
double k = basePnt.X / dir.X;
yk = basePnt.Y - k * dir.Y;
}
if (xk > 0 ||
(xk == 0 && dir.X * dir.Y >= 0))
{
CADPoint spnt = new CADPoint(xk, 0);
if (dir.Y < 0)
{
dir = -dir;
}
CADPoint epnt = spnt + 10000 * dir;
DrawLine(owner, thisDC, pen,
new CADPoint((float)spnt.X, (float)spnt.Y),
new CADPoint((float)epnt.X, (float)epnt.Y), false);
}
else if (yk > 0 ||
(yk == 0 && dir.X * dir.Y >= 0))
{
CADPoint spnt = new CADPoint(0, yk);
if (dir.X < 0)
{
dir = -dir;
}
CADPoint epnt = spnt + 10000 * dir;
DrawLine(owner, thisDC, pen,
new CADPoint((float)spnt.X, (float)spnt.Y),
new CADPoint((float)epnt.X, (float)epnt.Y), false);
}
}
public Selection(ObjectId objectId, CADPoint pickPosition)
{
_objectId = objectId;
_position = pickPosition;
}
public virtual void DrawLine(CADPoint startPoint, CADPoint endPoint, bool mdoelToCanvas = true)
{
DrawLine(_drawing, thisDC, Pen, startPoint, endPoint, mdoelToCanvas);
}
public Ellipse(CADPoint center, double radiusX, double radiusY)
{
_center = center;
RadiusX = radiusX;
RadiusY = radiusY;
}
public virtual void DrawXLine(CADPoint basePoint, CADVector direction, bool mdoelToCanvas = true)
{
DrawXLine(_drawing, thisDC, Pen, basePoint, direction, mdoelToCanvas);
}
public override void Translate(CADVector translation)
{
_center += translation;
}
public virtual void DrawArc(CADPoint center, double radius, double startAngle, double endAngle, bool mdoelToCanvas = true)
{
DrawArc(_drawing, thisDC, Pen, center, radius, startAngle, endAngle, mdoelToCanvas);
}
protected static void DrawCircle(IDrawing drawing, DrawingContext thisDC, Brush fillBrush, Pen pen, CADPoint center, double radiusX, double radiusY, bool mdoelToCanvas)
{
var p = center;
var rx = radiusX;
var ry = radiusY;
if (mdoelToCanvas)
{
p = drawing.ModelToCanvas(new CADPoint(center.X, center.Y));
rx = drawing.ModelToCanvas(radiusX);
ry = drawing.ModelToCanvas(radiusY);
}
thisDC.DrawEllipse(fillBrush, pen, new Point(p.X, p.Y), rx, ry);
}
public virtual void SetGripPointAt(int index, GripPoint gripPoint, CADPoint newPosition)
{
}
/// <summary>
/// https://stackoverflow.com/questions/16667072/how-to-draw-arc-with-radius-and-start-and-stop-angle
/// </summary>
/// <param name="drawing"></param>
/// <param name="thisDC"></param>
/// <param name="pen"></param>
/// <param name="center"></param>
/// <param name="radius"></param>
/// <param name="startAngle"></param>
/// <param name="endAngle"></param>
/// <param name="mdoelToCanvas"></param>
protected static void DrawArc(IDrawing drawing, DrawingContext thisDC, Pen pen, CADPoint center, double radius, double startAngle, double endAngle, bool mdoelToCanvas = true)
{
CADPoint centerInCanvas = mdoelToCanvas ? drawing.ModelToCanvas(center) : center;
double radiusInCanvas = mdoelToCanvas ? drawing.ModelToCanvas(radius) : radius;
double startAngleInCanvas = MathUtils.NormalizeRadianAngle(-startAngle);
double endAngleInCanvas = MathUtils.NormalizeRadianAngle(-endAngle);
//
double angle = endAngle - startAngle;
if (endAngle < startAngle)
{
angle += Utils.PI * 2;
}
if (radiusInCanvas > 0)
{
double a0 = startAngleInCanvas < 0 ? startAngleInCanvas + 2 * Math.PI : startAngleInCanvas;
double a1 = endAngleInCanvas < 0 ? endAngleInCanvas + 2 * Math.PI : endAngleInCanvas;
if (a1 < a0)
{
a1 += Math.PI * 2;
}
SweepDirection d = SweepDirection.Counterclockwise;
bool large;
bool SmallAngle = false;
if (SmallAngle)
{
large = false;
d = (a1 - a0) > Math.PI ? SweepDirection.Counterclockwise : SweepDirection.Clockwise;
}
else
{
large = (Math.Abs(a1 - a0) < Math.PI);
}
Point p0 = centerInCanvas.AsWPF() + new Vector(Math.Cos(a0), Math.Sin(a0)) * radiusInCanvas;
Point p1 = centerInCanvas.AsWPF() + new Vector(Math.Cos(a1), Math.Sin(a1)) * radiusInCanvas;
List <PathSegment> segments = new List <PathSegment>
{
new ArcSegment(p1, new Size(radiusInCanvas, radiusInCanvas), 0.0, large, d, true)
};
List <PathFigure> figures = new List <PathFigure>
{
new PathFigure(p0, segments, true)
{
IsClosed = false
}
};
thisDC.DrawGeometry(null, pen, new PathGeometry(figures, FillRule.EvenOdd, null));
}
}
private void Zoom(IMouseWheelEventArgs e)
{
CADPoint globalPnt_UnderMouse = _drawing.CanvasToModel(new CADPoint(e.X, e.Y));
CADPoint localPnt_UnderMouse = new CADPoint(e.X, e.Y);
//
// Mouse wheel was spinned.
// Calculate new scale.
double currentScale = Scale;
//
// Delta > 0 - scrolling to user
// Delta < 0 - from user
if (e.Delta > 0)
{
// zoom out
if (currentScale >= m_ScaleList[m_ScaleList.Count - 1])
{
return;
}
foreach (double rVal in m_ScaleList)
{
if (currentScale < rVal)
{
Scale = rVal;
break;
}
}
}
else
{
// zoom in
if (currentScale <= m_ScaleList[0])
{
return;
}
int iIndex = m_ScaleList.Count - 1;
while (iIndex >= 0)
{
if (currentScale > m_ScaleList[iIndex])
{
Scale = m_ScaleList[iIndex];
break;
}
--iIndex;
}
}
//
// Need to save cursor position - cursor should been placed over same point in global coordiantes.
globalPnt_UnderMouse.X *= Scale;
globalPnt_UnderMouse.Y *= Scale;
// reverse Y
// read comment in GetLocalPoint()
globalPnt_UnderMouse.Y *= -1;
_drawing.Origin = globalPnt_UnderMouse - localPnt_UnderMouse;
// reverse Y
_drawing.Origin.Y *= -1;
// m_TempOffsetVector.X = 0;
// m_TempOffsetVector.Y = 0;
_drawing.Canvas.Redraw();
}
protected static void DrawLine(IDrawing owner, DrawingContext thisDC, Pen pen, CADPoint startPoint, CADPoint endPoint, bool mdoelToCanvas = true)
{
var p1 = startPoint;
var p2 = endPoint;
if (mdoelToCanvas)
{
p1 = owner.ModelToCanvas(new CADPoint(startPoint.X, startPoint.Y));
p2 = owner.ModelToCanvas(new CADPoint(endPoint.X, endPoint.Y));
}
thisDC.DrawLine(pen, new Point(p1.X, p1.Y), new Point(p2.X, p2.Y));
}
public void AddVertexAt(int index, CADPoint point)
{
_vertices.Insert(index, point);
}
public Ray(CADPoint basePoint, CADVector direction)
{
_basePoint = basePoint;
_direction = direction.normalized;
}
