Files
OpenNest/OpenNest.Avalonia/Controls/PlateCanvas.cs
T
aj f11f77f879 feat(avalonia): add parts from the drawing list
As in the WinForms nest window, a part can be added from the Drawings
tab two ways. Pressing a drawing picks it up: when the pointer then
enters the plate view, the place tool starts with one part of the
drawing selected in the list, placed by a click, Enter or F1 like a
copy. Dragging a drawing onto the plate adds one part centred where it
is dropped, as one Add Part step.

A drop is refused while Auto Nest runs on the nest and for a drawing of
another nest. A double-click, a drop (at once, before the pointer can
re-enter the plate on X11 and macOS), Edit > Cut or Copy, or an Undo
puts the pick-up down, and the plate takes it only once. The list
selects one drawing at a time and keeps it selected when rebuilt.

As in WinForms, the pointer entering the plate view gives it the
keyboard, and a dropped part leaves the cut-offs as they are.
2026-11-17 17:36:19 -05:00

1181 lines
52 KiB
C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using Avalonia;
using Avalonia.Input;
using Avalonia.Media;
using Avalonia.Platform;
using Avalonia.Rendering.SceneGraph;
using Avalonia.Skia;
using OpenNest.Avalonia.Rendering;
using OpenNest.CNC;
using OpenNest.CommonLines;
using OpenNest.CutOffs;
using OpenNest.Desktop.Interaction;
using OpenNest.Desktop.Rendering;
using OpenNest.Engine.Fill;
using OpenNest.Geometry;
using OpenNest.Support;
using SkiaSharp;
using Control = Avalonia.Controls.Control;
using Vector = OpenNest.Geometry.Vector;
namespace OpenNest.Avalonia.Controls
{
/// <summary>
/// Draws one plate with Skia as the WinForms plate view does, in the colours of
/// <see cref="Scheme"/>: the sheet (or irregular outline), edge spacing, filled parts with their
/// numbers, cut-offs, clamps, common lines and the View toggles in <see cref="Options"/>. Pans
/// with a middle drag, zooms at the cursor with the wheel, fits on a middle double click, and
/// highlights the part under the cursor. Left and right clicks go to the active plate tool
/// (<see cref="Tools"/>, Select by default); Escape steps out of it.
/// </summary>
public sealed class PlateCanvas : Control, IPlateToolHost
{
// Paths are built once per part pose and only read afterwards, so the render thread may draw
// them while the UI thread builds others.
private readonly Dictionary<Part, PartPaths> paths = new();
private readonly Dictionary<Drawing, (CNC.Program Program, double Rotation, Vector Point)> labelPoints = new();
private readonly ConditionalWeakTable<Part, OffsetEntry> offsets = new();
private readonly SupportAnalysisCache supports = new();
private readonly Dictionary<CommonLineGroup, (string State, CommonLineCheck Check)> commonLineChecks = new();
private readonly ViewTransform view = new();
private readonly PlateSelection selection = new();
private readonly PlateHitTester hitTester;
private readonly PlateToolManager tools;
private Plate plate;
private Point? panStart;
// Where the middle button went down: a press released within 5 px turns the selection.
private Point? middleDown;
private bool fitPending = true;
private sealed record OffsetEntry(CNC.Program Program, double Rotation, double Spacing, double Tolerance,
SKPath Path);
public Plate Plate
{
get => plate;
set
{
var changed = !ReferenceEquals(plate, value);
plate = value;
HoveredPart = null;
if (changed)
{
selection.Plate = value;
tools.OnPlateChanged();
}
fitPending = true;
TrimCache();
InvalidateVisual();
}
}
/// <summary>
/// Shows <paramref name="value"/>, a copy of the shown plate an Undo or Redo read back,
/// keeping the zoom and pan, and selects its parts at <paramref name="selectedIndices"/>
/// (indices off the plate are skipped).
/// </summary>
public void ReplacePlate(Plate value, IEnumerable<int> selectedIndices)
{
var fit = fitPending;
Plate = value;
fitPending = fit;
selection.SelectIndices(selectedIndices);
}
/// <summary>The colours drawn with: the application's active scheme unless set.</summary>
public ColorScheme Scheme { get; set; } = ColorScheme.Default;
/// <summary>The View menu toggles this view draws with.</summary>
public PlateViewOptions Options { get; set; } = new();
public Part HoveredPart { get; private set; }
/// <summary>The parts and cut-offs selected on the shown plate.</summary>
public PlateSelection Selection => selection;
/// <summary>The active plate tool and its status text.</summary>
public PlateToolManager Tools => tools;
public PlateHitTester HitTester => hitTester;
/// <summary>Delete, nudge, push and rotate the selection, as WinForms does.</summary>
public PlateEdits Edits { get; }
/// <summary>
/// Opens one undoable edit of the shown nest (its tab's history); unset, edits are not
/// recorded.
/// </summary>
public Func<string, object, Undo.ChangeScope> BeginChangeHandler { get; set; }
/// <summary>The nest's settings that cut-offs regenerate with after an edit.</summary>
public CutOffSettings CutOffSettings { get; set; } = new();
/// <summary>No edits while Auto Nest works on the nest (WinForms EditsLocked).</summary>
public bool EditsLocked { get; set; }
/// <summary>
/// Which way Shift+click and Ctrl+click settle a placed copy (Tools &gt; Options &gt; Clone
/// push placement), read at each click.
/// </summary>
public Func<SettleOrder> PlacementOrder { get; set; } = () => SettleOrder.ClosestToCorner;
/// <summary>
/// Edit &gt; Copy: places copies of the selected parts with the place tool; false when
/// nothing is selected or edits are locked.
/// </summary>
public bool CopySelection() => PlateClipboard.Copy(this, tools, ReadPlacementOrder) != null;
/// <summary>
/// Edit &gt; Cut: as <see cref="CopySelection"/>, then removes the parts as one Cut step.
/// </summary>
public bool CutSelection() => PlateClipboard.Cut(this, tools, ReadPlacementOrder) != null;
/// <summary>
/// A drawing picked in the drawing list and carried into the view: the place tool with one
/// new part of it.
/// </summary>
public void PlaceDrawing(Drawing drawing) =>
tools.SetTool(DrawingPlacement.CreatePlaceTool(this, drawing, ReadPlacementOrder));
/// <summary>
/// A drawing dragged from the drawing list and dropped at <paramref name="at"/> (view
/// coordinates): one part centred there, or null while edits are locked.
/// </summary>
public Part DropDrawing(Drawing drawing, Point at) =>
DrawingPlacement.AddPart(this, drawing, ToWorld(at));
private SettleOrder ReadPlacementOrder() =>
PlacementOrder?.Invoke() ?? SettleOrder.ClosestToCorner;
Undo.ChangeScope IPlateToolHost.BeginChange(string label, object coalesceKey) =>
BeginChangeHandler?.Invoke(label, coalesceKey) ?? Undo.ChangeScope.Detached();
/// <summary>The cursor in plate coordinates, or null when it is outside the view.</summary>
public Vector? CursorWorld { get; private set; }
/// <summary>Pixels per drawing unit.</summary>
public double Zoom => view.Scale;
/// <summary>The view's world/screen mapping.</summary>
public ViewTransform View => view;
public event EventHandler ViewChanged;
public PlateCanvas()
{
ClipToBounds = true;
Focusable = true;
hitTester = new PlateHitTester(part => PathsFor(part).Geometry);
tools = new PlateToolManager(this);
// While the place tool is active, edits move its copies.
Edits = new PlateEdits(this) { Tools = tools };
selection.Changed += (_, _) =>
{
InvalidateVisual();
ViewChanged?.Invoke(this, EventArgs.Empty);
};
tools.StatusChanged += (_, _) =>
{
// A place tool's copies leave the cache when the tool ends.
TrimCache();
ViewChanged?.Invoke(this, EventArgs.Empty);
};
}
void IPlateToolHost.Invalidate() => InvalidateVisual();
/// <summary>Edit &gt; Select All: every part on the plate, cut-off segments excepted.</summary>
public void SelectAll() => selection.SelectAll();
public void ClearCache()
{
paths.Clear();
labelPoints.Clear();
commonLineChecks.Clear();
}
// Keeps only the shown plate's parts and the place tool's copies, so closed plates and
// ended tools do not hold their paths.
private void TrimCache()
{
if (plate == null)
{
paths.Clear();
labelPoints.Clear();
return;
}
var shown = new HashSet<Part>(plate.Parts);
if (tools?.Current is PlaceTool place)
shown.UnionWith(place.Previews);
foreach (var stale in paths.Keys.Where(part => !shown.Contains(part)).ToList())
paths.Remove(stale);
var drawings = new HashSet<Drawing>(plate.Parts.Select(part => part.BaseDrawing));
foreach (var stale in labelPoints.Keys.Where(drawing => !drawings.Contains(drawing)).ToList())
labelPoints.Remove(stale);
}
public void ZoomToFit()
{
if (!Fit())
return;
InvalidateVisual();
ViewChanged?.Invoke(this, EventArgs.Empty);
}
/// <summary>Fits the view to the plate and its parts without requesting a redraw.</summary>
private bool Fit()
{
if (plate == null || Bounds.Width <= 0 || Bounds.Height <= 0)
return false;
view.Resize(Bounds.Width, Bounds.Height);
if (!view.ZoomToArea(plate.BoundingBox(true)))
return false;
fitPending = false;
return true;
}
private Vector ToWorld(Point p) => view.ScreenToWorld(p.X, p.Y);
private SKMatrix WorldMatrix =>
new((float)view.Scale, 0, (float)view.OriginX, 0, (float)-view.Scale, (float)view.OriginY, 0, 0, 1);
private PartPaths PathsFor(Part part)
{
if (!paths.TryGetValue(part, out var result) || !result.Geometry.IsCurrentFor(part))
paths[part] = result = PartPaths.Build(part);
return result;
}
private Vector LabelPoint(Part part)
{
if (PartLabels.CutOffSegmentPoint(part) is { } cutOff)
return cutOff;
var drawing = part.BaseDrawing;
if (!labelPoints.TryGetValue(drawing, out var cached)
|| !ReferenceEquals(cached.Program, drawing.Program) || cached.Rotation != drawing.Program.Rotation)
{
cached = (drawing.Program, drawing.Program.Rotation, PartLabels.LabelPoint(drawing));
labelPoints[drawing] = cached;
}
return PartLabels.Place(part, cached.Point);
}
private SKPath OffsetFor(Part part, double spacing, double tolerance)
{
if (offsets.TryGetValue(part, out var entry) && ReferenceEquals(entry.Program, part.Program)
&& entry.Rotation == part.Rotation && entry.Spacing == spacing && entry.Tolerance == tolerance)
return entry.Path;
var polygons = PlateOverlays.OffsetOutline(part, spacing, tolerance);
var path = SkiaFigures.Polygons(polygons.Select(p => (IReadOnlyList<Vector>)p.Vertices));
offsets.AddOrUpdate(part, new OffsetEntry(part.Program, part.Rotation, spacing, tolerance, path));
return path;
}
public override void Render(DrawingContext context)
{
// A redraw may not be requested during a render, so tell listeners afterwards.
if (fitPending && Fit())
global::Avalonia.Threading.Dispatcher.UIThread.Post(() => ViewChanged?.Invoke(this, EventArgs.Empty));
if (Bounds.Width > 0 && Bounds.Height > 0)
view.Resize(Bounds.Width, Bounds.Height);
var scene = new Scene
{
Bounds = new Rect(Bounds.Size),
Palette = SkiaSchemePalette.For(Scheme ?? ColorScheme.Default),
Matrix = WorldMatrix,
Scale = view.Scale,
DrawOrigin = Options.DrawOrigin,
};
if (plate != null)
BuildScene(scene);
context.Custom(new PlateDrawOperation(scene));
}
private void BuildScene(Scene scene)
{
var options = Options;
var visible = view.VisibleWorld();
scene.Sheet = PlateOverlays.Sheet(plate);
if (plate.Outline is { } outline)
{
scene.SheetOutline = SkiaFigures.Polygons(new[] { PlateOverlays.PlaceOutline(plate, outline.Points) }
.Concat(outline.Obstacles.Select(o => PlateOverlays.PlaceOutline(plate, o))));
scene.Obstacles = outline.Obstacles.Count == 0 ? null
: SkiaFigures.Polygons(outline.Obstacles.Select(o => PlateOverlays.PlaceOutline(plate, o)));
var usable = PlateOverlays.UsableOutline(plate);
scene.Usable = usable.Count == 0 ? null : SkiaFigures.Polygons(usable);
}
else
{
var edge = PlateOverlays.EdgeSpacing(plate);
// As WinForms: the edge-spacing line is left out while it surrounds the whole view.
if (!Contains(edge, visible))
scene.EdgeSpacing = edge;
}
var palette = scene.Palette;
for (var i = 0; i < plate.Parts.Count; i++)
{
var part = plate.Parts[i];
var partPaths = PathsFor(part);
var bounds = partPaths.StrokeBounds;
var placed = bounds == null ? null : bounds.Translate(part.Location.X, part.Location.Y);
if (placed == null || !Intersects(placed, visible))
continue;
var color = ToSkColor(part.BaseDrawing.Color);
scene.Parts.Add(new PartItem(partPaths, part.Location, placed, color, palette.PartOutline(color),
(i + 1).ToString(), LabelPoint(part), selection.Contains(part),
ReferenceEquals(part, HoveredPart), part.BaseDrawing.IsCutOff));
}
// The place tool's copies, drawn selected and unnumbered over the plate, as WinForms.
if (tools.Current is PlaceTool { Previews: var previews })
{
foreach (var preview in previews)
{
var bounds = PathsFor(preview).StrokeBounds;
if (bounds == null)
continue;
var placed = bounds.Translate(preview.Location.X, preview.Location.Y);
var color = ToSkColor(preview.BaseDrawing.Color);
scene.Parts.Add(new PartItem(PathsFor(preview), preview.Location, placed, color,
palette.PartOutline(color), Label: null, preview.Location, Selected: true,
Hovered: false, IsCutOff: false));
}
}
if (options.DrawOffset && plate.PartSpacing > 0)
{
foreach (var part in plate.Parts)
scene.Offsets.Add((OffsetFor(part, plate.PartSpacing, options.OffsetTolerance), part.Location));
}
if (options.DrawBounds)
scene.SelectionBounds = PlateOverlays.SelectionBounds(selection.Parts.Where(plate.Parts.Contains));
if (options.DrawRapid)
scene.Rapids = PlateOverlays.Rapids(plate);
if (options.DrawPiercePoints)
scene.PiercePoints = PlateOverlays.PiercePoints(plate);
if (options.DrawCutDirection)
scene.Arrows = PlateOverlays.CutDirection(plate, view.LengthToWorld(60));
scene.Clamps = PlateOverlays.Clamps(plate);
scene.RemovedClamps = PlateOverlays.RemovedClamps(plate);
BuildCutOffs(scene);
if (tools.Current is SelectTool { Window: { } window })
scene.Window = window;
BuildCommonLines(scene);
if (options.DrawSupport)
BuildSupport(scene);
}
// A selected cut-off is drawn solid blue in place of its dashes, as in WinForms.
private void BuildCutOffs(Scene scene)
{
foreach (var cutOff in plate.CutOffs)
{
var program = cutOff.Drawing?.Program;
if (program == null || program.Codes.Count == 0)
continue;
var strokes = selection.Contains(cutOff) ? scene.SelectedCutOffStrokes : scene.CutOffStrokes;
strokes.AddRange(CutOff.CutStrokes(program, Vector.Zero));
}
}
private void BuildCommonLines(Scene scene)
{
if (plate.CommonLines is not { Count: > 0 } groups)
{
commonLineChecks.Clear();
return;
}
foreach (var stale in commonLineChecks.Keys.Where(group => !groups.Contains(group)).ToList())
commonLineChecks.Remove(stale);
foreach (var group in groups)
{
var state = string.Join(";", group.Members.Select(m =>
$"{m.Location.X:R},{m.Location.Y:R},{m.Rotation:R},{RuntimeHelpers.GetHashCode(m.BaseDrawing.Program)}"));
if (!commonLineChecks.TryGetValue(group, out var cached) || cached.State != state)
{
cached = (state, CommonLineGeometry.Check(group));
commonLineChecks[group] = cached;
}
foreach (var path in CommonLineGeometry.Paths(cached.Check.Spans, group.Kerf))
scene.CommonLines.Add(path.Points);
foreach (var problem in cached.Check.Problems)
{
// A copy: moving the part changes its box in place while the render thread draws.
var box = problem.Part.BoundingBox;
scene.CommonLineProblems.Add(new Box(box.X, box.Y, box.Length, box.Width));
}
}
}
private void BuildSupport(Scene scene)
{
if (plate.SupportBed is not { } bed)
return;
// Grid points and slats only while they are at least 6 pixels apart on screen.
const double minimumSpacing = 6;
if (bed is SupportGrid grid
&& view.LengthToScreen(System.Math.Min(grid.PitchX, grid.PitchY)) >= minimumSpacing)
scene.GridPoints = grid.PointsIn(scene.Sheet, plate.Quadrant);
else if (bed is SupportSlats slats && view.LengthToScreen(slats.Pitch) >= minimumSpacing)
scene.Slats = slats.SlatsIn(scene.Sheet, plate.Quadrant);
var clearance = PlateOverlays.SupportClearance(plate);
foreach (var part in plate.Parts)
{
var support = supports.Analyze(part, bed, plate.Quadrant, clearance);
if (support is not { IsComplete: true })
continue;
scene.Supports.Add(new SupportItem(support.Contacts, support.CenterOfGravity, support.IsSupported,
support.IsSupported ? null : support.BestTabPoint));
}
}
private static bool Contains(Box outer, Box inner) =>
inner.Left >= outer.Left && inner.Right <= outer.Right && inner.Bottom >= outer.Bottom && inner.Top <= outer.Top;
private static bool Intersects(Box a, Box b) =>
a.Left <= b.Right && a.Right >= b.Left && a.Bottom <= b.Top && a.Top >= b.Bottom;
private static SKColor ToSkColor(System.Drawing.Color color) =>
color.IsEmpty ? new SKColor(130, 204, 130) : new SKColor(color.R, color.G, color.B, color.A);
protected override void OnPointerWheelChanged(PointerWheelEventArgs e)
{
// As WinForms: Shift+wheel turns the selection (Ctrl+Shift by a tenth); without a
// selection the wheel zooms. Some platforms report Shift+wheel as horizontal.
if (e.KeyModifiers.HasFlag(KeyModifiers.Shift) && Edits.HasPartsToEdit
&& !EditsLocked)
{
var delta = e.Delta.Y != 0 ? e.Delta.Y : e.Delta.X;
Edits.RotateByWheel(
(int)System.Math.Truncate(delta), fine: IsControl(e.KeyModifiers));
e.Handled = true;
return;
}
var at = e.GetPosition(this);
view.ZoomAt(new ScreenPoint(at.X, at.Y), System.Math.Pow(1.2, e.Delta.Y));
InvalidateVisual();
ViewChanged?.Invoke(this, EventArgs.Empty);
e.Handled = true;
}
protected override void OnPointerPressed(PointerPressedEventArgs e)
{
Focus();
var point = e.GetCurrentPoint(this);
var properties = point.Properties;
if (properties.IsMiddleButtonPressed)
{
// As WinForms: a middle double-click fits only with nothing selected; with a
// selection each click turns it, so a double-click turns it 180 degrees.
if (e.ClickCount == 2 && (EditsLocked || !Edits.HasPartsToEdit))
{
ZoomToFit();
return;
}
panStart = point.Position;
middleDown = point.Position;
e.Pointer.Capture(this);
return;
}
var button = properties.IsLeftButtonPressed ? ToolButton.Left
: properties.IsRightButtonPressed ? ToolButton.Right : ToolButton.None;
if (button == ToolButton.None)
return;
ClearHover();
if (tools.Current.PointerPressed(ToolPointerAt(point.Position, button, e.KeyModifiers)))
e.Handled = true;
if (button == ToolButton.Left)
e.Pointer.Capture(this);
}
protected override void OnPointerMoved(PointerEventArgs e)
{
var point = e.GetCurrentPoint(this);
var at = point.Position;
CursorWorld = ToWorld(at);
if (panStart is { } start)
{
view.Pan(at.X - start.X, at.Y - start.Y);
panStart = at;
InvalidateVisual();
}
else
{
var button = point.Properties.IsLeftButtonPressed ? ToolButton.Left
: point.Properties.IsRightButtonPressed ? ToolButton.Right : ToolButton.None;
tools.Current.PointerMoved(ToolPointerAt(at, button, e.KeyModifiers));
// As WinForms: the part under the cursor is highlighted only in Select, while no
// button is held.
var hovered = button == ToolButton.None && tools.Current is SelectTool
? hitTester.PartAt(plate, CursorWorld.Value) : null;
if (!ReferenceEquals(hovered, HoveredPart))
{
HoveredPart = hovered;
InvalidateVisual();
}
}
ViewChanged?.Invoke(this, EventArgs.Empty);
}
protected override void OnPointerReleased(PointerReleasedEventArgs e)
{
var button = e.InitialPressMouseButton switch
{
MouseButton.Left => ToolButton.Left,
MouseButton.Right => ToolButton.Right,
MouseButton.Middle => ToolButton.Middle,
_ => ToolButton.None,
};
if (button == ToolButton.Middle)
{
panStart = null;
// A middle click, not a drag, turns the selection 90 degrees.
var at = e.GetPosition(this);
if (middleDown is { } down && Edits.HasPartsToEdit
&& (at.X - down.X) * (at.X - down.X) + (at.Y - down.Y) * (at.Y - down.Y) < 25)
Edits.RotateQuarterTurn();
middleDown = null;
}
else if (button != ToolButton.None
&& tools.Current.PointerReleased(ToolPointerAt(e.GetPosition(this), button, e.KeyModifiers)))
e.Handled = true;
// Kept while another button is still down: a middle click during a left drag must
// not end the drag.
var held = e.GetCurrentPoint(this).Properties;
if (!held.IsLeftButtonPressed && !held.IsMiddleButtonPressed
&& !held.IsRightButtonPressed)
e.Pointer.Capture(null);
}
// The pointer was taken away mid-gesture (Alt+Tab during a drag): the tool ends what it
// was doing, and a pan or middle click stops.
protected override void OnPointerCaptureLost(PointerCaptureLostEventArgs e)
{
base.OnPointerCaptureLost(e);
panStart = null;
middleDown = null;
tools.Current.PointerCaptureLost();
}
// As the WinForms plate view: the pointer entering the view gives it the keyboard, which
// also places a drawing picked up in the drawing list.
protected override void OnPointerEntered(PointerEventArgs e)
{
base.OnPointerEntered(e);
if (!IsFocused)
Focus();
}
protected override void OnPointerExited(PointerEventArgs e)
{
CursorWorld = null;
ClearHover();
ViewChanged?.Invoke(this, EventArgs.Empty);
}
private void ClearHover()
{
if (HoveredPart == null)
return;
HoveredPart = null;
InvalidateVisual();
}
private ToolPointer ToolPointerAt(Point at, ToolButton button, KeyModifiers keys) =>
new(ToWorld(at), new ScreenPoint(at.X, at.Y), button, ModifiersOf(keys));
private static ToolModifiers ModifiersOf(KeyModifiers keys)
{
var modifiers = ToolModifiers.None;
if (keys.HasFlag(KeyModifiers.Shift))
modifiers |= ToolModifiers.Shift;
// Command on macOS stands in for Ctrl, as Avalonia's own gestures do.
if (IsControl(keys))
modifiers |= ToolModifiers.Control;
if (keys.HasFlag(KeyModifiers.Alt))
modifiers |= ToolModifiers.Alt;
return modifiers;
}
protected override void OnKeyDown(KeyEventArgs e)
{
if (e.Key == Key.Escape && e.KeyModifiers == KeyModifiers.None)
{
tools.Escape();
e.Handled = true;
}
else if (e.Key == Key.F && e.KeyModifiers == KeyModifiers.None)
{
ZoomToFit();
e.Handled = true;
}
else if (e.Key is Key.Enter or Key.F1 && tools.Current is PlaceTool place)
{
// As WinForms: Enter and F1 place a copy, Shift or Ctrl held settling it.
place.Apply(ModifiersOf(e.KeyModifiers));
e.Handled = true;
}
else if (EditFor(e.Key, e.KeyModifiers) is { } edit)
{
edit();
e.Handled = true;
}
}
private static bool IsControl(KeyModifiers keys) =>
keys.HasFlag(KeyModifiers.Control) || keys.HasFlag(KeyModifiers.Meta);
// The WinForms plate view's editing keys: Delete; arrows nudge; Shift+arrows, X, Shift+X,
// Shift+Y and Y push to contact.
private Action EditFor(Key key, KeyModifiers modifiers) => (key, modifiers) switch
{
// WinForms deletes on the Delete key whatever modifiers are held.
(Key.Delete, _) => Edits.Delete,
(Key.Left, KeyModifiers.None) => () => Edits.Nudge(PushDirection.Left),
(Key.Right, KeyModifiers.None) => () => Edits.Nudge(PushDirection.Right),
(Key.Up, KeyModifiers.None) => () => Edits.Nudge(PushDirection.Up),
(Key.Down, KeyModifiers.None) => () => Edits.Nudge(PushDirection.Down),
(Key.Left, KeyModifiers.Shift) or (Key.X, KeyModifiers.None) =>
() => Edits.Push(PushDirection.Left),
(Key.Right, KeyModifiers.Shift) or (Key.X, KeyModifiers.Shift) =>
() => Edits.Push(PushDirection.Right),
(Key.Up, KeyModifiers.Shift) or (Key.Y, KeyModifiers.Shift) =>
() => Edits.Push(PushDirection.Up),
(Key.Down, KeyModifiers.Shift) or (Key.Y, KeyModifiers.None) =>
() => Edits.Push(PushDirection.Down),
_ => null,
};
protected override void OnSizeChanged(global::Avalonia.Controls.SizeChangedEventArgs e)
{
base.OnSizeChanged(e);
view.Resize(e.NewSize.Width, e.NewSize.Height);
InvalidateVisual();
}
private sealed record PartItem(PartPaths Paths, Vector Location, Box Bounds, SKColor Color, SKColor Outline,
string Label, Vector LabelPoint, bool Selected, bool Hovered, bool IsCutOff);
private sealed record SupportItem(IReadOnlyList<Vector> Contacts, Vector CenterOfGravity, bool Supported,
Vector? Tab);
/// <summary>Everything one frame draws, built on the UI thread and only read on the render thread.</summary>
private sealed class Scene
{
public Rect Bounds;
public SkiaSchemePalette Palette;
public SKMatrix Matrix;
public double Scale;
public bool DrawOrigin;
public Box Sheet;
public SKPath SheetOutline;
public SKPath Obstacles;
public SKPath Usable;
public Box EdgeSpacing;
public readonly List<PartItem> Parts = new();
public readonly List<(SKPath Path, Vector Location)> Offsets = new();
public Box SelectionBounds;
public IReadOnlyList<RapidEnumerator.Segment> Rapids;
public IReadOnlyList<Vector> PiercePoints;
public IReadOnlyList<ContourSample> Arrows;
public IReadOnlyList<Box> Clamps;
public IReadOnlyList<Box> RemovedClamps;
public readonly List<Line> CutOffStrokes = new();
public readonly List<Line> SelectedCutOffStrokes = new();
public SelectionWindow? Window;
public readonly List<IReadOnlyList<Vector>> CommonLines = new();
public readonly List<Box> CommonLineProblems = new();
public IReadOnlyList<Vector> GridPoints;
public IReadOnlyList<Box> Slats;
public readonly List<SupportItem> Supports = new();
}
private sealed class PlateDrawOperation : ICustomDrawOperation
{
private readonly Scene scene;
public PlateDrawOperation(Scene scene)
{
this.scene = scene;
}
public Rect Bounds => scene.Bounds;
public bool HitTest(Point p) => Bounds.Contains(p);
public bool Equals(ICustomDrawOperation other) => false;
public void Dispose()
{
}
public void Render(ImmediateDrawingContext context)
{
var lease = context.TryGetFeature<ISkiaSharpApiLeaseFeature>();
if (lease == null)
return;
using var api = lease.Lease();
var canvas = api.SkCanvas;
canvas.Save();
canvas.ClipRect(new SKRect(0, 0, (float)Bounds.Width, (float)Bounds.Height));
canvas.Clear(scene.Palette.Background);
new PlatePainter(canvas, scene).Paint();
canvas.Restore();
}
}
/// <summary>
/// Paints a scene in the WinForms view's order and pen sizes: widths and dashes are screen
/// pixels, so parts drawn in world units scale them by the zoom.
/// </summary>
private sealed class PlatePainter
{
private static readonly SKColor LeadColor = new(255, 69, 0); // OrangeRed
private static readonly SKColor DisplayColor = new(70, 110, 140);
private static readonly SKColor OffsetColor = new(255, 100, 100, 120);
private static readonly SKColor CutDirectionColor = new(60, 60, 60);
private static readonly SKColor PierceFill = new(255, 0, 0);
private static readonly SKColor PierceOutline = new(139, 0, 0); // DarkRed
private static readonly SKColor ClampHatch = new(70, 80, 90, 150);
private static readonly SKColor ClampBack = new(230, 170, 40, 70);
private static readonly SKColor ClampOutline = new(150, 100, 0, 220);
private static readonly SKColor RemovedClampOutline = new(110, 110, 110, 200);
private static readonly SKColor ObstacleHatch = new(120, 60, 60, 170);
private static readonly SKColor ObstacleBack = new(200, 80, 80, 60);
private static readonly SKColor CutOffColor = new(255, 69, 0); // OrangeRed
private static readonly SKColor SelectedCutOffColor = new(0, 120, 255);
private static readonly SKColor WindowContainsBorder = new(99, 162, 228);
private static readonly SKColor WindowContainsFill = new(150, 200, 255, 90);
private static readonly SKColor WindowIntersectBorder = new(50, 255, 50);
private static readonly SKColor WindowIntersectFill = new(50, 255, 50, 50);
private static readonly SKColor CommonLineColor = new(0, 150, 136);
private static readonly SKColor BrokenCommonLineColor = new(255, 0, 0);
private static readonly SKColor GridColor = new(120, 120, 120, 110);
private static readonly SKColor SlatColor = new(120, 120, 120, 90);
private static readonly SKColor ContactColor = new(30, 150, 60, 220);
private static readonly SKColor SupportedColor = new(20, 140, 50, 230);
private static readonly SKColor TippingColor = new(210, 30, 30, 240);
private static readonly SKColor TabColor = new(240, 140, 0, 240);
// The WinForms default font, bold and underlined, for part numbers.
private static readonly SKTypeface LabelTypeface =
SKTypeface.FromFamilyName(null, SKFontStyle.Bold) ?? SKTypeface.Default;
private readonly SKCanvas canvas;
private readonly Scene scene;
// Not readonly: SKCanvas.Concat takes it by reference.
private SKMatrix matrix;
private readonly float scale;
public PlatePainter(SKCanvas canvas, Scene scene)
{
this.canvas = canvas;
this.scene = scene;
matrix = scene.Matrix;
scale = (float)scene.Scale;
}
private SKPoint Screen(Vector world) => matrix.MapPoint((float)world.X, (float)world.Y);
private SKRect Screen(Box box)
{
var a = Screen(new Vector(box.Left, box.Top));
var b = Screen(new Vector(box.Right, box.Bottom));
return new SKRect(System.Math.Min(a.X, b.X), System.Math.Min(a.Y, b.Y),
System.Math.Max(a.X, b.X), System.Math.Max(a.Y, b.Y));
}
private static SKPaint Stroke(SKColor color, float width = 1, float[] dash = null) => new()
{
Style = SKPaintStyle.Stroke,
Color = color,
StrokeWidth = width,
IsAntialias = true,
PathEffect = dash == null ? null : SKPathEffect.CreateDash(dash, 0),
};
private static SKPaint Fill(SKColor color) => new() { Style = SKPaintStyle.Fill, Color = color, IsAntialias = true };
// A pen of screen width in the world frame: width 1 stays a one-pixel hairline.
private SKPaint WorldStroke(SKColor color, float width = 1, float[] dash = null) =>
Stroke(color, width <= 1 && dash == null ? 0 : width / scale,
dash?.Select(d => d / scale).ToArray());
public void Paint()
{
if (scene.DrawOrigin)
{
using var origin = Stroke(scene.Palette.Origin);
origin.IsAntialias = false;
var o = Screen(Vector.Zero);
canvas.DrawLine(o.X, 0, o.X, (float)scene.Bounds.Height, origin);
canvas.DrawLine(0, o.Y, (float)scene.Bounds.Width, o.Y, origin);
}
if (scene.Sheet == null)
return;
DrawSheet();
DrawParts();
DrawOffsets();
if (scene.SelectionBounds != null)
{
using var pen = Stroke(scene.Palette.BoundingBox);
canvas.DrawRect(Screen(scene.SelectionBounds), pen);
}
DrawRapids();
DrawPiercePoints();
DrawCutDirection();
DrawClamps();
DrawCutOffs();
DrawCommonLines();
DrawSupport();
DrawSelectionWindow();
}
private void DrawSheet()
{
var palette = scene.Palette;
canvas.Save();
canvas.Concat(ref matrix);
using var sheetFill = Fill(palette.PlateFill);
if (scene.SheetOutline != null)
{
canvas.DrawPath(scene.SheetOutline, sheetFill);
canvas.Restore();
if (scene.Obstacles != null)
{
HatchPath(scene.Obstacles, ObstacleHatch, ObstacleBack);
using var obstaclePen = WorldStroke(ObstacleHatch, 1.5f);
DrawWorld(scene.Obstacles, obstaclePen);
}
if (scene.Usable != null)
{
using var usablePen = WorldStroke(palette.EdgeSpacing, 1, new float[] { 3, 3 });
DrawWorld(scene.Usable, usablePen);
}
using var outlinePen = WorldStroke(palette.PlateOutline);
DrawWorld(scene.SheetOutline, outlinePen);
return;
}
var sheet = scene.Sheet;
canvas.DrawRect(new SKRect((float)sheet.Left, (float)sheet.Bottom, (float)sheet.Right, (float)sheet.Top),
sheetFill);
canvas.Restore();
if (scene.EdgeSpacing != null)
{
using var edgePen = Stroke(palette.EdgeSpacing, 1, new float[] { 3, 3 });
edgePen.IsAntialias = false;
canvas.DrawRect(Screen(scene.EdgeSpacing), edgePen);
}
using var outline = Stroke(palette.PlateOutline);
outline.IsAntialias = false;
canvas.DrawRect(Screen(sheet), outline);
}
private void DrawWorld(SKPath path, SKPaint paint)
{
canvas.Save();
canvas.Concat(ref matrix);
canvas.DrawPath(path, paint);
canvas.Restore();
}
// GDI+ WideUpwardDiagonal: three-pixel "/" stripes every eight pixels, in screen space.
private void HatchPath(SKPath worldPath, SKColor hatch, SKColor back)
{
using var screenPath = new SKPath(worldPath);
screenPath.Transform(matrix);
using var shader = HatchShader(hatch, back);
using var paint = new SKPaint { Style = SKPaintStyle.Fill, Shader = shader };
canvas.DrawPath(screenPath, paint);
}
private void HatchRect(SKRect rect, SKColor hatch, SKColor back)
{
using var shader = HatchShader(hatch, back);
using var paint = new SKPaint { Style = SKPaintStyle.Fill, Shader = shader };
canvas.DrawRect(rect, paint);
}
private static SKShader HatchShader(SKColor hatch, SKColor back)
{
using var bitmap = new SKBitmap(8, 8, SKColorType.Rgba8888, SKAlphaType.Unpremul);
for (var y = 0; y < 8; y++)
for (var x = 0; x < 8; x++)
bitmap.SetPixel(x, y, (x + y) % 8 < 3 ? hatch : back);
return SKShader.CreateBitmap(bitmap, SKShaderTileMode.Repeat, SKShaderTileMode.Repeat);
}
private void DrawParts()
{
var palette = scene.Palette;
using var fill = Fill(SKColors.Black);
using var cut = WorldStroke(SKColors.Black);
using var etch = WorldStroke(palette.Etch, 1.5f);
using var lead = WorldStroke(LeadColor, 1.5f);
using var display = WorldStroke(DisplayColor, 1, new float[] { 6, 3 });
using var text = new SKPaint
{
Color = SKColors.Black,
IsAntialias = true,
TextSize = 11,
Typeface = LabelTypeface,
TextAlign = SKTextAlign.Center,
};
using var underline = Stroke(SKColors.Black);
var metrics = text.FontMetrics;
var textHeight = metrics.Descent - metrics.Ascent;
foreach (var item in scene.Parts)
{
canvas.Save();
canvas.Concat(ref matrix);
canvas.Translate((float)item.Location.X, (float)item.Location.Y);
fill.Color = item.Selected ? palette.SelectedFill
: item.Hovered ? Lighten(item.Color) : item.Color;
canvas.DrawPath(item.Paths.Material, fill);
if (item.Paths.Display != null)
canvas.DrawPath(item.Paths.Display, display);
canvas.DrawPath(item.Paths.Etch, etch);
// Keep real cuts visible even where an etch overlaps them.
cut.Color = item.Selected ? palette.SelectedOutline : item.Outline;
canvas.DrawPath(item.Paths.Cut, cut);
// As on the desktop, only manually placed lead-ins are shown.
canvas.DrawPath(item.Paths.Lead, lead);
canvas.Restore();
// A number shows only once the part is big enough on screen to hold it.
if (item.IsCutOff || item.Label == null)
continue;
var bounds = Screen(item.Bounds);
var width = text.MeasureText(item.Label);
if (bounds.Width < width || bounds.Height < textHeight)
continue;
var at = Screen(item.LabelPoint);
var baseline = at.Y - (metrics.Ascent + metrics.Descent) / 2;
canvas.DrawText(item.Label, at.X, baseline, text);
var lineY = baseline + System.Math.Max(1, metrics.UnderlinePosition ?? 1.5f);
canvas.DrawLine(at.X - width / 2, lineY, at.X + width / 2, lineY, underline);
}
}
private void DrawOffsets()
{
if (scene.Offsets.Count == 0)
return;
using var pen = WorldStroke(OffsetColor);
foreach (var (path, location) in scene.Offsets)
{
canvas.Save();
canvas.Concat(ref matrix);
canvas.Translate((float)location.X, (float)location.Y);
canvas.DrawPath(path, pen);
canvas.Restore();
}
}
private void DrawRapids()
{
if (scene.Rapids == null)
return;
using var pen = Stroke(scene.Palette.Rapid, 1, new float[] { 10, 10 });
foreach (var segment in scene.Rapids)
canvas.DrawLine(Screen(segment.From), Screen(segment.To), pen);
}
private void DrawPiercePoints()
{
if (scene.PiercePoints == null)
return;
using var fill = Fill(PierceFill);
using var pen = Stroke(PierceOutline);
foreach (var point in scene.PiercePoints)
{
var p = Screen(point);
canvas.DrawCircle(p, 2, fill);
canvas.DrawCircle(p, 2, pen);
}
}
private void DrawCutDirection()
{
if (scene.Arrows == null)
return;
const float size = 6;
using var pen = Stroke(CutDirectionColor, 1.5f);
foreach (var sample in scene.Arrows)
{
var tip = Screen(sample.Position);
// Screen space flips Y, so the screen angle mirrors the world tangent.
var angle = System.Math.Atan2(-sample.Direction.Y, sample.Direction.X);
foreach (var side in new[] { 0.5, -0.5 })
{
var a = angle + System.Math.PI + side;
canvas.DrawLine(tip.X + size * (float)System.Math.Cos(a), tip.Y + size * (float)System.Math.Sin(a),
tip.X, tip.Y, pen);
}
}
}
// Machine clamps are fixtures, not material: a translucent hatched amber keep-out.
private void DrawClamps()
{
using var outline = Stroke(ClampOutline, 1.5f);
foreach (var clamp in scene.Clamps)
{
var rect = Screen(clamp);
HatchRect(rect, ClampHatch, ClampBack);
canvas.DrawRect(rect, outline);
}
using var removed = Stroke(RemovedClampOutline, 1.5f, new float[] { 4.5f, 1.5f });
using var text = new SKPaint { Color = RemovedClampOutline, IsAntialias = true, TextSize = 9 };
foreach (var clamp in scene.RemovedClamps)
{
var rect = Screen(clamp);
canvas.DrawRect(rect, removed);
canvas.DrawText("remove", rect.Left, rect.Top - text.FontMetrics.Descent, text);
}
}
// Scrap cut-off lines stand out from the dark part outlines: a saturated orange-red dash.
private void DrawCutOffs()
{
using var pen = Stroke(CutOffColor, 2, new float[] { 6, 2 });
foreach (var stroke in scene.CutOffStrokes)
canvas.DrawLine(Screen(stroke.StartPoint), Screen(stroke.EndPoint), pen);
using var selectedPen = Stroke(SelectedCutOffColor, 3.5f);
foreach (var stroke in scene.SelectedCutOffStrokes)
canvas.DrawLine(Screen(stroke.StartPoint), Screen(stroke.EndPoint), selectedPen);
// Each segment's number over the line, on a disc of the line's colour.
using var disc = Fill(CutOffColor);
using var text = new SKPaint
{
Color = SKColors.White,
IsAntialias = true,
TextSize = 11,
Typeface = LabelTypeface,
TextAlign = SKTextAlign.Center,
};
var metrics = text.FontMetrics;
var textHeight = metrics.Descent - metrics.Ascent;
foreach (var item in scene.Parts)
{
if (!item.IsCutOff)
continue;
var bounds = Screen(item.Bounds);
var diameter = System.Math.Max(text.MeasureText(item.Label), textHeight) + 2;
if (System.Math.Max(bounds.Width, bounds.Height) < diameter)
continue;
var at = Screen(item.LabelPoint);
canvas.DrawCircle(at, diameter / 2, disc);
canvas.DrawText(item.Label, at.X, at.Y - (metrics.Ascent + metrics.Descent) / 2, text);
}
}
// The Select tool's window: blue while it selects what it contains, green while it
// selects what it touches, in the WinForms colours.
private void DrawSelectionWindow()
{
if (scene.Window is not { } window)
return;
var contains = window.Mode == WindowSelectionMode.Contains;
var rect = Screen(window.Box);
using var fill = Fill(contains ? WindowContainsFill : WindowIntersectFill);
fill.IsAntialias = false;
canvas.DrawRect(rect, fill);
using var border = Stroke(contains ? WindowContainsBorder : WindowIntersectBorder);
border.IsAntialias = false;
canvas.DrawRect(rect, border);
}
private void DrawCommonLines()
{
using var pen = Stroke(CommonLineColor, 2, new float[] { 6, 2 });
foreach (var points in scene.CommonLines)
for (var i = 1; i < points.Count; i++)
canvas.DrawLine(Screen(points[i - 1]), Screen(points[i]), pen);
using var broken = Stroke(BrokenCommonLineColor, 2);
foreach (var box in scene.CommonLineProblems)
canvas.DrawRect(Screen(box), broken);
}
private void DrawSupport()
{
if (scene.GridPoints != null)
{
// Whole-pixel squares, not anti-aliased dots, so every point is the same size.
using var grid = new SKPaint { Style = SKPaintStyle.Fill, Color = GridColor, IsAntialias = false };
foreach (var point in scene.GridPoints)
{
var p = Screen(point);
var x = (float)System.Math.Round(p.X) - 1;
var y = (float)System.Math.Round(p.Y) - 1;
canvas.DrawRect(x, y, 3, 3, grid);
}
}
if (scene.Slats != null)
{
using var slat = new SKPaint { Style = SKPaintStyle.Fill, Color = SlatColor, IsAntialias = false };
foreach (var box in scene.Slats)
{
var rect = Screen(box);
// At least a pixel wide however far out the view is.
if (rect.Width < 1)
rect = new SKRect(rect.MidX - 0.5f, rect.Top, rect.MidX + 0.5f, rect.Bottom);
if (rect.Height < 1)
rect = new SKRect(rect.Left, rect.MidY - 0.5f, rect.Right, rect.MidY + 0.5f);
canvas.DrawRect(rect, slat);
}
}
using var contact = Fill(ContactColor);
using var supported = Stroke(SupportedColor, 2);
using var tipping = Stroke(TippingColor, 2);
using var tab = Fill(TabColor);
foreach (var item in scene.Supports)
{
foreach (var point in item.Contacts)
canvas.DrawCircle(Screen(point), 2.5f, contact);
const float size = 6;
var c = Screen(item.CenterOfGravity);
var pen = item.Supported ? supported : tipping;
canvas.DrawCircle(c, size, pen);
canvas.DrawLine(c.X - size, c.Y, c.X + size, c.Y, pen);
canvas.DrawLine(c.X, c.Y - size, c.X, c.Y + size, pen);
if (item.Tab is { } point2)
{
const float d = 5;
var t = Screen(point2);
using var diamond = new SKPath();
diamond.MoveTo(t.X, t.Y - d);
diamond.LineTo(t.X + d, t.Y);
diamond.LineTo(t.X, t.Y + d);
diamond.LineTo(t.X - d, t.Y);
diamond.Close();
canvas.DrawPath(diamond, tab);
}
}
}
private static SKColor Lighten(SKColor c) =>
new((byte)(c.Red + (255 - c.Red) / 2), (byte)(c.Green + (255 - c.Green) / 2),
(byte)(c.Blue + (255 - c.Blue) / 2), c.Alpha);
}
}
}