#pragma warning restore CS0618
private void MainImage_PointerMoved(object sender, PointerEventArgs e)
{
// allow to move cursor out leaving selection/hignlighting unchanged
if (IgnorePointerMove(e))
{
return;
}
PointerPoint p = e.GetCurrentPoint(_mainImageControl);
_pointerPos = p.Position;
//
if (p.Properties.IsMiddleButtonPressed)
{
TD.Point delta = ToPoint(_pointerPosDrag - _pointerPos);
_pointerPosDrag = _pointerPos;
_viewport.MoveOrigin(delta);
UpdateDrawerBounds();
MarkPresetChanged();
InvalidateView(false); // viewport moved only
}
else
{
TD.Point u = _viewport.ToUser(ToPoint(_pointerPos));
_gridDrawer.SetCursor(u.X, u.Y);
var mode = e.KeyModifiers.HasFlag(KeyModifiers.Alt)
? GridDrawer.CursorHighlightMode.Cents
: GridDrawer.CursorHighlightMode.NearestRational;
_gridDrawer.SetCursorHighlightMode(mode);
InvalidateView();
}
}
private void UpdateMarkers()
{
double x1 = Line.Start.X;
double y1 = Line.Start.Y;
double x2 = Line.End.X;
double y2 = Line.End.Y;
if (Style.Stroke.StartArrow.ArrowType != ArrowType.None)
{
double a1 = Math.Atan2(y1 - y2, x1 - x2);
StartMarker = CreatArrowMarker(x1, y1, a1, Style, Style.Stroke.StartArrow);
StartMarker.UpdateStyle();
P0 = (StartMarker as MarkerBase).Point;
}
else
{
StartMarker = null;
P0 = new A.Point(x1, y1);
}
if (Style.Stroke.EndArrow.ArrowType != ArrowType.None)
{
double a2 = Math.Atan2(y2 - y1, x2 - x1);
EndMarker = CreatArrowMarker(x2, y2, a2, Style, Style.Stroke.EndArrow);
EndMarker.UpdateStyle();
P1 = (EndMarker as MarkerBase).Point;
}
else
{
EndMarker = null;
P1 = new A.Point(x2, y2);
}
}
/// <summary>
/// Convert from WPF point to core point.
/// </summary>
public static Point[] Convert(RPoint[] points)
{
Point[] myPoints = new Point[points.Length];
for (int i = 0; i < points.Length; i++)
myPoints[i] = Convert(points[i]);
return myPoints;
}
private void SetColor(Point mousePosition)
{
var centerPoint = new Point(Bounds.Width / 2, Bounds.Height / 2);
var radius = (Bounds.Height - _cursorEllipse.Height) / 2;
var dx = Math.Abs(mousePosition.X - centerPoint.X);
var dy = Math.Abs(mousePosition.Y - centerPoint.Y);
var angle = Math.Atan(dy / dx) / Math.PI * 180;
var distance = Math.Pow(Math.Pow(dx, 2) + Math.Pow(dy, 2), 0.5);
var saturation = distance / radius;
if (mousePosition.X < centerPoint.X)
{
angle = 180 - angle;
}
if (mousePosition.Y > centerPoint.Y)
{
angle = 360 - angle;
}
_colorManager.SetColorFromHsl(angle, saturation, 0.5);
}
private void DrawGridInternal(AM.DrawingContext dc, AM.Pen stroke, ref Rect2 rect, double offsetX, double offsetY, double cellWidth, double cellHeight, bool isStroked)
{
double ox = rect.X;
double oy = rect.Y;
double sx = ox + offsetX;
double sy = oy + offsetY;
double ex = ox + rect.Width;
double ey = oy + rect.Height;
for (double x = sx; x < ex; x += cellWidth)
{
var p0 = new A.Point(
_scaleToPage(x),
_scaleToPage(oy));
var p1 = new A.Point(
_scaleToPage(x),
_scaleToPage(ey));
DrawLineInternal(dc, stroke, isStroked, ref p0, ref p1);
}
for (double y = sy; y < ey; y += cellHeight)
{
var p0 = new A.Point(
_scaleToPage(ox),
_scaleToPage(y));
var p1 = new A.Point(
_scaleToPage(ex),
_scaleToPage(y));
DrawLineInternal(dc, stroke, isStroked, ref p0, ref p1);
}
}
Avalonia.Point ScreenPointToDominoCoordinates(Avalonia.Point p)
{
var tempx = p.X / Zoom + ShiftX;
var tempy = p.Y / Zoom + ShiftY;
return(new Avalonia.Point(tempx, tempy));
}
public override void UpdateGeometry()
{
ScaleThickness = Line.State.HasFlag(ShapeStateFlags.Thickness);
ScaleSize = Line.State.HasFlag(ShapeStateFlags.Size);
P0 = new A.Point(Line.Start.X, Line.Start.Y);
P1 = new A.Point(Line.End.X, Line.End.Y);
Center = new A.Point((P0.X + P1.X) / 2.0, (P0.Y + P1.Y) / 2.0);
UpdateMarkers();
}
private void UpdateMarkers()
{
if (Line.Start is null || Line.End is null)
{
StartMarker = null;
P0 = new A.Point();
EndMarker = null;
P1 = new A.Point();
}
public static A.Point[] ToPoints(this IList <Point> points)
{
var skPoints = new A.Point[points.Count];
for (int i = 0; i < points.Count; i++)
{
skPoints[i] = points[i].ToPoint();
}
return(skPoints);
}
public static A.Point[] ToPoints(this IList <global::Svg.Model.Primitives.Point> points)
{
var skPoints = new A.Point[points.Count];
for (int i = 0; i < points.Count; i++)
{
skPoints[i] = points[i].ToPoint();
}
return(skPoints);
}
private void MainImage_PointerPressed(object sender, PointerPressedEventArgs e)
{
PointerPoint p = e.GetCurrentPoint(_mainImageControl);
if (_pointerPos != p.Position)
{
return;
}
// _gridDrawer.SetCursor already called from OnMouseMove
if (p.Properties.IsLeftButtonPressed)
{
// Get tempered note
SomeInterval t = null;
if (e.KeyModifiers.HasFlag(KeyModifiers.Alt)) // by cents
{
float c = _gridDrawer.GetCursorCents();
t = new SomeInterval {
cents = c
};
}
else // nearest rational
{
_gridDrawer.UpdateCursorItem();
Rational r = _gridDrawer.GetCursorRational();
if (!r.IsDefault())
{
t = new SomeInterval {
rational = r
};
}
}
if (t != null)
{
// Toggle selection
if (e.KeyModifiers.HasFlag(KeyModifiers.Control))
{
ToggleSelection(t);
//!!! invalidate image
}
// Play note
else
{
PlayNote(t);
}
}
}
else if (p.Properties.IsMiddleButtonPressed)
{
_pointerPosDrag = _pointerPos;
}
}
protected void RectangleBoundOnPointerMoved(object?sender, PointerEventArgs e)
{
Rect rect = RectangleBoundWindow.Bounds;
PRectangleBoundClick = e.GetCurrentPoint(RectangleBoundWindow).Position;
if (PRectangleBoundClick.Y < rect.Height - (RectangleBoundWindow.StrokeThickness + 3) &&
PRectangleBoundClick.X <= RectangleBoundWindow.StrokeThickness)
{
if (!IsCursorCapture)
{
Cursor = new Cursor(StandardCursorType.LeftSide);
}
}
else if (PRectangleBoundClick.X >= rect.Width - RectangleBoundWindow.StrokeThickness &&
PRectangleBoundClick.Y < rect.Height - (RectangleBoundWindow.StrokeThickness + 3))
{
if (!IsCursorCapture)
{
Cursor = new Cursor(StandardCursorType.RightSide);
}
}
else if (PRectangleBoundClick.Y >= rect.Height - RectangleBoundWindow.StrokeThickness &&
PRectangleBoundClick.X > RectangleBoundWindow.StrokeThickness + 3 &&
PRectangleBoundClick.X < rect.Width - (RectangleBoundWindow.StrokeThickness + 3))
{
if (!IsCursorCapture)
{
Cursor = new Cursor(StandardCursorType.BottomSide);
}
}
else if (PRectangleBoundClick.X <= RectangleBoundWindow.StrokeThickness &&
PRectangleBoundClick.Y >= rect.Height - (RectangleBoundWindow.StrokeThickness + 3))
{
if (!IsCursorCapture)
{
Cursor = new Cursor(StandardCursorType.BottomLeftCorner);
}
}
else if (PRectangleBoundClick.X >= rect.Width - (RectangleBoundWindow.StrokeThickness + 3) &&
PRectangleBoundClick.Y >= rect.Height - (RectangleBoundWindow.StrokeThickness + 3))
{
if (!IsCursorCapture)
{
Cursor = new Cursor(StandardCursorType.BottomRightCorner);
}
}
}
protected void RectangleBoundOnPointerPressed(object?sender, PointerPressedEventArgs e)
{
Rect rect = RectangleBoundWindow.Bounds;
PPRectangleBoundClick = e.GetCurrentPoint(null);
PRectangleBoundClick = PPRectangleBoundClick.Position;
PointerPointRectangleBoundWindowX = PPRectangleBoundClick.Position.X;
PointerPointRectangleBoundWindowY = PPRectangleBoundClick.Position.Y;
RectangleBoundWindowWidth = Position.Y;
if (PRectangleBoundClick.Y < rect.Height - (RectangleBoundWindow.StrokeThickness + 3) &&
PRectangleBoundClick.X <= RectangleBoundWindow.StrokeThickness)
{
IsCursorCapture = true;
IsLeftClickRectangleBoundWindow = true;
}
else if (PRectangleBoundClick.X >= rect.Width - RectangleBoundWindow.StrokeThickness &&
PRectangleBoundClick.Y < rect.Height - (RectangleBoundWindow.StrokeThickness + 3))
{
IsCursorCapture = true;
IsRightClickRectangleBoundWindow = true;
}
else if (PRectangleBoundClick.Y >= rect.Height - RectangleBoundWindow.StrokeThickness &&
PRectangleBoundClick.X > RectangleBoundWindow.StrokeThickness + 3 &&
PRectangleBoundClick.X < rect.Width - (RectangleBoundWindow.StrokeThickness + 3))
{
IsCursorCapture = true;
IsBottomClickRectangleBoundWindow = true;
}
else if (PRectangleBoundClick.X <= RectangleBoundWindow.StrokeThickness &&
PRectangleBoundClick.Y >= rect.Height - (RectangleBoundWindow.StrokeThickness + 3))
{
IsCursorCapture = true;
IsBottomLeftClickRectangleBoundWindow = true;
}
else if (PRectangleBoundClick.X >= rect.Width - (RectangleBoundWindow.StrokeThickness + 3) &&
PRectangleBoundClick.Y >= rect.Height - (RectangleBoundWindow.StrokeThickness + 3))
{
IsCursorCapture = true;
IsBottomRightClickRectangleBoundWindow = true;
}
}
private AM.StreamGeometry CreateCurveGeometry(A.Point p0, A.Point p1, double curvature, CurveOrientation orientation, PointAlignment pt0a, PointAlignment pt1a)
{
var curveGeometry = new AM.StreamGeometry();
using (var geometryContext = curveGeometry.Open())
{
geometryContext.BeginFigure(new A.Point(p0.X, p0.Y), false);
double p0x = p0.X;
double p0y = p0.Y;
double p1x = p1.X;
double p1y = p1.Y;
LineShapeExtensions.GetCurvedLineBezierControlPoints(orientation, curvature, pt0a, pt1a, ref p0x, ref p0y, ref p1x, ref p1y);
var point1 = new A.Point(p0x, p0y);
var point2 = new A.Point(p1x, p1y);
var point3 = new A.Point(p1.X, p1.Y);
geometryContext.CubicBezierTo(point1, point2, point3);
geometryContext.EndFigure(false);
}
return(curveGeometry);
}
public override void OnDraw(object dc, double zoom)
{
var context = dc as AM.DrawingContext;
if (Grid.GridStrokeColor != null)
{
if (Grid.IsGridEnabled)
{
double ox = Rect.X;
double ex = Rect.X + Rect.Width;
double oy = Rect.Y;
double ey = Rect.Y + Rect.Height;
double cw = Grid.GridCellWidth;
double ch = Grid.GridCellHeight;
for (double x = ox + cw; x < ex; x += cw)
{
var p0 = new A.Point(x, oy);
var p1 = new A.Point(x, ey);
context.DrawLine(Stroke, p0, p1);
}
for (double y = oy + ch; y < ey; y += ch)
{
var p0 = new A.Point(ox, y);
var p1 = new A.Point(ex, y);
context.DrawLine(Stroke, p0, p1);
}
}
if (Grid.IsBorderEnabled)
{
context.DrawRectangle(Stroke, Rect);
}
}
}
private static A.Point DrawLineArrowInternal(AM.DrawingContext dc, AM.Pen pen, AM.IBrush brush, float x, float y, double angle, ArrowStyle style)
{
A.Point pt = default(A.Point);
var rt = APAZ.MatrixHelper.Rotation(angle, new A.Vector(x, y));
double rx = style.RadiusX;
double ry = style.RadiusY;
double sx = 2.0 * rx;
double sy = 2.0 * ry;
switch (style.ArrowType)
{
default:
case ArrowType.None:
{
pt = new A.Point(x, y);
}
break;
case ArrowType.Rectangle:
{
pt = APAZ.MatrixHelper.TransformPoint(rt, new A.Point(x - (float)sx, y));
var rect = new Rect2(x - sx, y - ry, sx, sy);
using (var d = dc.PushPreTransform(rt))
{
DrawRectangleInternal(dc, brush, pen, style.IsStroked, style.IsFilled, ref rect);
}
}
break;
case ArrowType.Ellipse:
{
pt = APAZ.MatrixHelper.TransformPoint(rt, new A.Point(x - (float)sx, y));
using (var d = dc.PushPreTransform(rt))
{
var rect = new Rect2(x - sx, y - ry, sx, sy);
DrawEllipseInternal(dc, brush, pen, style.IsStroked, style.IsFilled, ref rect);
}
}
break;
case ArrowType.Arrow:
{
var pts = new A.Point[]
{
new A.Point(x, y),
new A.Point(x - (float)sx, y + (float)sy),
new A.Point(x, y),
new A.Point(x - (float)sx, y - (float)sy),
new A.Point(x, y)
};
pt = APAZ.MatrixHelper.TransformPoint(rt, pts[0]);
var p11 = APAZ.MatrixHelper.TransformPoint(rt, pts[1]);
var p21 = APAZ.MatrixHelper.TransformPoint(rt, pts[2]);
var p12 = APAZ.MatrixHelper.TransformPoint(rt, pts[3]);
var p22 = APAZ.MatrixHelper.TransformPoint(rt, pts[4]);
DrawLineInternal(dc, pen, style.IsStroked, ref p11, ref p21);
DrawLineInternal(dc, pen, style.IsStroked, ref p12, ref p22);
}
break;
}
return(pt);
}
private void DrawLineArrowsInternal(AM.DrawingContext dc, LineShape line, double dx, double dy, out A.Point pt1, out A.Point pt2)
{
AM.IBrush fillStartArrow = ToBrush(line.Style.StartArrowStyle.Fill);
AM.Pen strokeStartArrow = ToPen(line.Style.StartArrowStyle, _scaleToPage);
AM.IBrush fillEndArrow = ToBrush(line.Style.EndArrowStyle.Fill);
AM.Pen strokeEndArrow = ToPen(line.Style.EndArrowStyle, _scaleToPage);
double _x1 = line.Start.X + dx;
double _y1 = line.Start.Y + dy;
double _x2 = line.End.X + dx;
double _y2 = line.End.Y + dy;
line.GetMaxLength(ref _x1, ref _y1, ref _x2, ref _y2);
float x1 = _scaleToPage(_x1);
float y1 = _scaleToPage(_y1);
float x2 = _scaleToPage(_x2);
float y2 = _scaleToPage(_y2);
var sas = line.Style.StartArrowStyle;
var eas = line.Style.EndArrowStyle;
double a1 = Math.Atan2(y1 - y2, x1 - x2);
double a2 = Math.Atan2(y2 - y1, x2 - x1);
// Draw start arrow.
pt1 = DrawLineArrowInternal(dc, strokeStartArrow, fillStartArrow, x1, y1, a1, sas);
// Draw end arrow.
pt2 = DrawLineArrowInternal(dc, strokeEndArrow, fillEndArrow, x2, y2, a2, eas);
}
private static void DrawLineCurveInternal(AM.DrawingContext _dc, AM.Pen pen, bool isStroked, ref A.Point pt1, ref A.Point pt2, double curvature, CurveOrientation orientation, PointAlignment pt1a, PointAlignment pt2a)
{
if (isStroked)
{
var sg = new AM.StreamGeometry();
using (var sgc = sg.Open())
{
sgc.BeginFigure(new A.Point(pt1.X, pt1.Y), false);
double p1x = pt1.X;
double p1y = pt1.Y;
double p2x = pt2.X;
double p2y = pt2.Y;
LineShapeExtensions.GetCurvedLineBezierControlPoints(orientation, curvature, pt1a, pt2a, ref p1x, ref p1y, ref p2x, ref p2y);
sgc.CubicBezierTo(
new A.Point(p1x, p1y),
new A.Point(p2x, p2y),
new A.Point(pt2.X, pt2.Y));
sgc.EndFigure(false);
}
_dc.DrawGeometry(null, pen, sg);
}
}
private static void DrawLineInternal(AM.DrawingContext dc, AM.Pen pen, bool isStroked, ref A.Point p0, ref A.Point p1)
{
if (isStroked)
{
dc.DrawLine(pen, p0, p1);
}
}
public static AM.Geometry?ToGeometry(this Path path, bool isFilled)
{
if (path.Commands == null)
{
return(null);
}
var streamGeometry = new AM.StreamGeometry();
using var streamGeometryContext = streamGeometry.Open();
streamGeometryContext.SetFillRule(path.FillType.ToSKPathFillType());
bool endFigure = false;
bool haveFigure = false;
for (int i = 0; i < path.Commands.Count; i++)
{
var pathCommand = path.Commands[i];
var isLast = i == path.Commands.Count - 1;
switch (pathCommand)
{
case MoveToPathCommand moveToPathCommand:
{
if (endFigure == true && haveFigure == false)
{
return(null);
}
if (haveFigure == true)
{
streamGeometryContext.EndFigure(false);
}
if (isLast == true)
{
return(streamGeometry);
}
else
{
if (path.Commands[i + 1] is MoveToPathCommand)
{
return(streamGeometry);
}
if (path.Commands[i + 1] is ClosePathCommand)
{
return(streamGeometry);
}
}
endFigure = true;
haveFigure = false;
var x = moveToPathCommand.X;
var y = moveToPathCommand.Y;
var point = new A.Point(x, y);
streamGeometryContext.BeginFigure(point, isFilled); // TODO: isFilled
}
break;
case LineToPathCommand lineToPathCommand:
{
if (endFigure == false)
{
return(null);
}
haveFigure = true;
var x = lineToPathCommand.X;
var y = lineToPathCommand.Y;
var point = new A.Point(x, y);
streamGeometryContext.LineTo(point);
}
break;
case ArcToPathCommand arcToPathCommand:
{
if (endFigure == false)
{
return(null);
}
haveFigure = true;
var x = arcToPathCommand.X;
var y = arcToPathCommand.Y;
var point = new A.Point(x, y);
var rx = arcToPathCommand.Rx;
var ry = arcToPathCommand.Ry;
var size = new A.Size(rx, ry);
var rotationAngle = arcToPathCommand.XAxisRotate;
var isLargeArc = arcToPathCommand.LargeArc == PathArcSize.Large;
var sweep = arcToPathCommand.Sweep.ToSweepDirection();
streamGeometryContext.ArcTo(point, size, rotationAngle, isLargeArc, sweep);
}
break;
case QuadToPathCommand quadToPathCommand:
{
if (endFigure == false)
{
return(null);
}
haveFigure = true;
var x0 = quadToPathCommand.X0;
var y0 = quadToPathCommand.Y0;
var x1 = quadToPathCommand.X1;
var y1 = quadToPathCommand.Y1;
var control = new A.Point(x0, y0);
var endPoint = new A.Point(x1, y1);
streamGeometryContext.QuadraticBezierTo(control, endPoint);
}
break;
case CubicToPathCommand cubicToPathCommand:
{
if (endFigure == false)
{
return(null);
}
haveFigure = true;
var x0 = cubicToPathCommand.X0;
var y0 = cubicToPathCommand.Y0;
var x1 = cubicToPathCommand.X1;
var y1 = cubicToPathCommand.Y1;
var x2 = cubicToPathCommand.X2;
var y2 = cubicToPathCommand.Y2;
var point1 = new A.Point(x0, y0);
var point2 = new A.Point(x1, y1);
var point3 = new A.Point(x2, y2);
streamGeometryContext.CubicBezierTo(point1, point2, point3);
}
break;
case ClosePathCommand _:
{
if (endFigure == false)
{
return(null);
}
if (haveFigure == false)
{
return(null);
}
endFigure = false;
haveFigure = false;
streamGeometryContext.EndFigure(true);
}
break;
default:
break;
}
}
if (endFigure)
{
if (haveFigure == false)
{
return(null);
}
streamGeometryContext.EndFigure(false);
}
return(streamGeometry);
}
private static void Record(CanvasCommand canvasCommand, AvaloniaPicture avaloniaPicture)
{
if (avaloniaPicture == null || avaloniaPicture._commands == null)
{
return;
}
switch (canvasCommand)
{
case ClipPathCanvasCommand clipPathCanvasCommand:
{
var path = clipPathCanvasCommand.ClipPath.ToGeometry(false);
if (path != null)
{
// TODO: clipPathCanvasCommand.Operation;
// TODO: clipPathCanvasCommand.Antialias;
avaloniaPicture._commands.Add(new GeometryClipDrawCommand(path));
}
}
break;
case ClipRectCanvasCommand clipRectCanvasCommand:
{
var rect = clipRectCanvasCommand.Rect.ToSKRect();
// TODO: clipRectCanvasCommand.Operation;
// TODO: clipRectCanvasCommand.Antialias;
avaloniaPicture._commands.Add(new ClipDrawCommand(rect));
}
break;
case SaveCanvasCommand _:
{
// TODO:
avaloniaPicture._commands.Add(new SaveDrawCommand());
}
break;
case RestoreCanvasCommand _:
{
// TODO:
avaloniaPicture._commands.Add(new RestoreDrawCommand());
}
break;
case SetMatrixCanvasCommand setMatrixCanvasCommand:
{
var matrix = setMatrixCanvasCommand.Matrix.ToMatrix();
avaloniaPicture._commands.Add(new SetTransformDrawCommand(matrix));
}
break;
case SaveLayerCanvasCommand saveLayerCanvasCommand:
{
// TODO:
avaloniaPicture._commands.Add(new SaveLayerDrawCommand());
}
break;
case DrawImageCanvasCommand drawImageCanvasCommand:
{
if (drawImageCanvasCommand.Image != null)
{
var image = drawImageCanvasCommand.Image.ToBitmap();
if (image != null)
{
var source = drawImageCanvasCommand.Source.ToSKRect();
var dest = drawImageCanvasCommand.Dest.ToSKRect();
var bitmapInterpolationMode = drawImageCanvasCommand.Paint?.FilterQuality.ToBitmapInterpolationMode() ?? AVMI.BitmapInterpolationMode.Default;
avaloniaPicture._commands.Add(new ImageDrawCommand(image, source, dest, bitmapInterpolationMode));
}
}
}
break;
case DrawPathCanvasCommand drawPathCanvasCommand:
{
if (drawPathCanvasCommand.Path != null && drawPathCanvasCommand.Paint != null)
{
(var brush, var pen) = drawPathCanvasCommand.Paint.ToBrushAndPen();
if (drawPathCanvasCommand.Path.Commands?.Count == 1)
{
var pathCommand = drawPathCanvasCommand.Path.Commands[0];
var success = false;
switch (pathCommand)
{
case AddRectPathCommand addRectPathCommand:
{
var rect = addRectPathCommand.Rect.ToSKRect();
avaloniaPicture._commands.Add(new RectangleDrawCommand(brush, pen, rect, 0, 0));
success = true;
}
break;
case AddRoundRectPathCommand addRoundRectPathCommand:
{
var rect = addRoundRectPathCommand.Rect.ToSKRect();
var rx = addRoundRectPathCommand.Rx;
var ry = addRoundRectPathCommand.Ry;
avaloniaPicture._commands.Add(new RectangleDrawCommand(brush, pen, rect, rx, ry));
success = true;
}
break;
case AddOvalPathCommand addOvalPathCommand:
{
var rect = addOvalPathCommand.Rect.ToSKRect();
var ellipseGeometry = new AM.EllipseGeometry(rect);
avaloniaPicture._commands.Add(new GeometryDrawCommand(brush, pen, ellipseGeometry));
success = true;
}
break;
case AddCirclePathCommand addCirclePathCommand:
{
var x = addCirclePathCommand.X;
var y = addCirclePathCommand.Y;
var radius = addCirclePathCommand.Radius;
var rect = new A.Rect(x - radius, y - radius, radius + radius, radius + radius);
var ellipseGeometry = new AM.EllipseGeometry(rect);
avaloniaPicture._commands.Add(new GeometryDrawCommand(brush, pen, ellipseGeometry));
success = true;
}
break;
case AddPolyPathCommand addPolyPathCommand:
{
if (addPolyPathCommand.Points != null)
{
var points = addPolyPathCommand.Points.ToPoints();
var close = addPolyPathCommand.Close;
var polylineGeometry = new AM.PolylineGeometry(points, close);
avaloniaPicture._commands.Add(new GeometryDrawCommand(brush, pen, polylineGeometry));
success = true;
}
}
break;
}
if (success)
{
break;
}
}
if (drawPathCanvasCommand.Path.Commands?.Count == 2)
{
var pathCommand1 = drawPathCanvasCommand.Path.Commands[0];
var pathCommand2 = drawPathCanvasCommand.Path.Commands[1];
if (pathCommand1 is MoveToPathCommand moveTo && pathCommand2 is LineToPathCommand lineTo)
{
var p1 = new A.Point(moveTo.X, moveTo.Y);
var p2 = new A.Point(lineTo.X, lineTo.Y);
avaloniaPicture._commands.Add(new LineDrawCommand(pen, p1, p2));
break;
}
}
var geometry = drawPathCanvasCommand.Path.ToGeometry(brush != null);
if (geometry != null)
{
avaloniaPicture._commands.Add(new GeometryDrawCommand(brush, pen, geometry));
}
}
}
break;
case DrawTextBlobCanvasCommand drawPositionedTextCanvasCommand:
{
// TODO:
}
break;
case DrawTextCanvasCommand drawTextCanvasCommand:
{
if (drawTextCanvasCommand.Paint != null)
{
(var brush, _) = drawTextCanvasCommand.Paint.ToBrushAndPen();
var text = drawTextCanvasCommand.Paint.ToFormattedText(drawTextCanvasCommand.Text);
var x = drawTextCanvasCommand.X;
var y = drawTextCanvasCommand.Y;
var origin = new A.Point(x, y - drawTextCanvasCommand.Paint.TextSize);
avaloniaPicture._commands.Add(new TextDrawCommand(brush, origin, text));
}
}
break;
case DrawTextOnPathCanvasCommand drawTextOnPathCanvasCommand:
{
// TODO:
}
break;
default:
break;
}
}
private Ava.Point GetPixelPosition(PointerEventArgs e)
{
Ava.Point pos = e.GetPosition(this);
Ava.Point dpiCorrectedPos = new Ava.Point(pos.X * backend.dpiScaleInput, pos.Y * backend.dpiScaleInput);
return(dpiCorrectedPos);
}
public static Vector2 ToStride(this AvaloniaPoint point)
{
return(new((float)point.X, (float)point.Y));
}
/// <summary>
/// Transforms a point by this matrix.
/// </summary>
/// <param name="matrix">The matrix to use as a transformation matrix.</param>
/// <param name="point">>The original point to apply the transformation.</param>
/// <returns>The result of the transformation for the input point.</returns>
public static Point TransformPoint(Matrix matrix, Point point)
{
return new Point(
(point.X * matrix.M11) + (point.Y * matrix.M21) + matrix.M31,
(point.X * matrix.M12) + (point.Y * matrix.M22) + matrix.M32);
}
public bool HitTest(Avalonia.Point p) => true;
private static A.Point DrawLineArrowInternal(AM.DrawingContext dc, AM.Pen pen, AM.IBrush brush, float x, float y, double angle, ArrowStyle style)
{
A.Point pt = default(A.Point);
var rt = APAZ.MatrixHelper.Rotation(angle, new A.Vector(x, y));
double rx = style.RadiusX;
double ry = style.RadiusY;
double sx = 2.0 * rx;
double sy = 2.0 * ry;
switch (style.ArrowType)
{
default:
case ArrowType.None:
{
pt = new A.Point(x, y);
}
break;
case ArrowType.Rectangle:
{
pt = APAZ.MatrixHelper.TransformPoint(rt, new A.Point(x - (float)sx, y));
var rect = new Rect2(x - sx, y - ry, sx, sy);
using (var d = dc.PushPreTransform(rt))
{
DrawRectangleInternal(dc, brush, pen, style.IsStroked, style.IsFilled, ref rect);
}
}
break;
case ArrowType.Ellipse:
{
pt = APAZ.MatrixHelper.TransformPoint(rt, new A.Point(x - (float)sx, y));
using (var d = dc.PushPreTransform(rt))
{
var rect = new Rect2(x - sx, y - ry, sx, sy);
DrawEllipseInternal(dc, brush, pen, style.IsStroked, style.IsFilled, ref rect);
}
}
break;
case ArrowType.Arrow:
{
var pts = new A.Point[]
{
new A.Point(x, y),
new A.Point(x - (float)sx, y + (float)sy),
new A.Point(x, y),
new A.Point(x - (float)sx, y - (float)sy),
new A.Point(x, y)
};
pt = APAZ.MatrixHelper.TransformPoint(rt, pts[0]);
var p11 = APAZ.MatrixHelper.TransformPoint(rt, pts[1]);
var p21 = APAZ.MatrixHelper.TransformPoint(rt, pts[2]);
var p12 = APAZ.MatrixHelper.TransformPoint(rt, pts[3]);
var p22 = APAZ.MatrixHelper.TransformPoint(rt, pts[4]);
DrawLineInternal(dc, pen, style.IsStroked, ref p11, ref p21);
DrawLineInternal(dc, pen, style.IsStroked, ref p12, ref p22);
}
break;
}
return pt;
}
public LineDrawCommand(AM.IPen?pen, A.Point p1, A.Point p2)
{
Pen = pen;
P1 = p1;
P2 = p2;
}
protected void UpdateTextGeometry()
{
BoundText = Text.GetProperty(nameof(TextShapeViewModel.Text)) is string boundText ? boundText : Text.Text;
if (BoundText is null)
{
return;
}
if (Style.TextStyle.FontSize < 0.0)
{
return;
}
var fontStyle = AM.FontStyle.Normal;
var fontWeight = AM.FontWeight.Normal;
if (Style.TextStyle.FontStyle.HasFlag(FontStyleFlags.Italic))
{
fontStyle |= AM.FontStyle.Italic;
}
if (Style.TextStyle.FontStyle.HasFlag(FontStyleFlags.Bold))
{
fontWeight |= AM.FontWeight.Bold;
}
// TODO: Cache Typeface
// TODO: Cache FormattedText
Typeface = new AM.Typeface(Style.TextStyle.FontName, fontStyle, fontWeight);
var textAlignment = Style.TextStyle.TextHAlignment switch
{
TextHAlignment.Right => AM.TextAlignment.Right,
TextHAlignment.Center => AM.TextAlignment.Center,
_ => AM.TextAlignment.Left,
};
FormattedText = new AM.FormattedText()
{
Typeface = Typeface,
Text = BoundText,
TextAlignment = textAlignment,
TextWrapping = AM.TextWrapping.NoWrap,
FontSize = Style.TextStyle.FontSize,
Constraint = Rect.Size
};
var size = FormattedText.Bounds.Size;
var rect = Rect;
// NOTE: Using AM.TextAlignment
var originX = rect.X;
//var originX = Style.TextStyle.TextHAlignment switch
//{
// TextHAlignment.Left => rect.X,
// TextHAlignment.Right => rect.Right - size.Width,
// _ => (rect.Left + rect.Width / 2.0) - (size.Width / 2.0)
//};
var originY = Style.TextStyle.TextVAlignment switch
{
TextVAlignment.Top => rect.Y,
TextVAlignment.Bottom => rect.Bottom - size.Height,
_ => (rect.Bottom - rect.Height / 2f) - (size.Height / 2f)
};
Origin = new A.Point(originX, originY);
}
private System.Drawing.PointF SDPointF(Ava.Point pt)
{
return(new System.Drawing.PointF((float)pt.X, (float)pt.Y));
}
public TextDrawCommand(AM.IBrush?brush, A.Point origin, AM.FormattedText?formattedText)
{
Brush = brush;
Origin = origin;
FormattedText = formattedText;
}
private void DrawGridInternal(AM.DrawingContext dc, AM.Pen stroke, ref Rect2 rect, double offsetX, double offsetY, double cellWidth, double cellHeight, bool isStroked)
{
double ox = rect.X;
double oy = rect.Y;
double sx = ox + offsetX;
double sy = oy + offsetY;
double ex = ox + rect.Width;
double ey = oy + rect.Height;
for (double x = sx; x < ex; x += cellWidth)
{
var p0 = new A.Point(
_scaleToPage(x),
_scaleToPage(oy));
var p1 = new A.Point(
_scaleToPage(x),
_scaleToPage(ey));
DrawLineInternal(dc, stroke, isStroked, ref p0, ref p1);
}
for (double y = sy; y < ey; y += cellHeight)
{
var p0 = new A.Point(
_scaleToPage(ox),
_scaleToPage(y));
var p1 = new A.Point(
_scaleToPage(ex),
_scaleToPage(y));
DrawLineInternal(dc, stroke, isStroked, ref p0, ref p1);
}
}
public Avalonia.Point PointToDisplayAvaloniaPoint(Avalonia.Point p)
{
return(new Avalonia.Point((float)((p.X - shift_x) * zoom), (float)((p.Y - shift_y) * zoom)));
}
/// <summary>
/// Convert from WPF point to core point.
/// </summary>
public static RPoint Convert(Point p)
{
return new RPoint(p.X, p.Y);
}
){kind=link}