feat(desktop): share part delete, nudge, push, rotate and drag-move edits

PlateEdits ports the WinForms plate view's edits of the selection, with
its undo labels and coalescing: Delete (parts and cut-offs, cut-offs
regenerated once when the plate has any), Nudge by the offset increment
or one repeat step, Push to contact, Rotate about the selection's
centre keeping its lower-left corner (a quarter turn, or by wheel
notches at 10 degrees or a tenth of that), repeated nudges and wheel
turns undoing as one step.

The Select tool drags the selection as one Move step. Cut-offs
regenerate when a drag actually moved parts (WinForms also does it on a
plain click, adding an extra undo step); the regeneration runs before
the step completes, so a failure rolls the drag back, and a view that
loses the pointer mid-drag ends the move as a release would, keeping
the selection.

A plate tool host now has to supply its undo wiring, the nest's cut-off
settings and an edits lock (WinForms EditsLocked): while locked no edit
runs and no press selects or starts a move.
This commit is contained in:
aj committed 2026-11-14 20:26:01 -05:00
1 parent e2a27df7ef
commit 203945dabf
7 files changed
+933 -4

No files matched your search

+216
View File
@@ -0,0 +1,216 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using OpenNest.Engine.Fill;
using OpenNest.Geometry;
using OpenNest.Math;
namespace OpenNest.Desktop.Interaction;
/// <summary>
/// The WinForms plate view's edits of the selection, toolkit-neutral: delete, nudge, step, push
/// and rotate. Each edit is one undo step named as in WinForms; repeated nudges and steps of the
/// same parts, and wheel rotations, undo as one. Every edit does nothing without a plate or
/// selected parts (Delete also acts on selected cut-offs alone) and redraws the view, and nothing
/// at all while the host's edits are locked (<see cref="IPlateToolHost.EditsLocked"/>).
/// </summary>
public sealed class PlateEdits
{
public PlateEdits(IPlateToolHost host)
{
Host = host ?? throw new ArgumentNullException(nameof(host));
}
public IPlateToolHost Host { get; }
/// <summary>How far an arrow-key nudge moves the selection, in plate units.</summary>
public double OffsetIncrement { get; set; } = 10;
/// <summary>
/// Whether an arrow key steps the selection by its own size instead (<see cref="Step"/>).
/// </summary>
public bool CalculatedOffset { get; set; }
/// <summary>How far one wheel notch rotates the selection, in degrees.</summary>
public double RotateIncrementDegrees { get; set; } = 10;
/// <summary>
/// Removes the selected parts and cut-offs and clears the selection. When the plate had
/// cut-offs, the remaining ones are rebuilt once both kinds are gone, so they close the gaps
/// left around deleted parts.
/// </summary>
public void Delete()
{
var plate = Host.Plate;
if (plate == null || Host.EditsLocked)
return;
var selection = Host.Selection;
selection.Prune();
var parts = selection.Parts.ToList();
var cutOffs = selection.CutOffs.ToList();
if (parts.Count == 0 && cutOffs.Count == 0)
return;
using var change = Host.BeginChange("Delete");
var regenerateCutOffs = plate.CutOffs.Count > 0;
change.MarkChanged();
foreach (var cutOff in cutOffs)
plate.CutOffs.Remove(cutOff);
foreach (var part in parts)
plate.Parts.Remove(part);
selection.Clear();
if (regenerateCutOffs)
plate.RegenerateCutOffs(Host.CutOffSettings);
Host.Invalidate();
change.Complete();
}
/// <summary>
/// An arrow key: moves by <see cref="OffsetIncrement"/>, or with
/// <see cref="CalculatedOffset"/> steps.
/// </summary>
public void Nudge(PushDirection direction)
{
if (CalculatedOffset)
{
Step(direction);
return;
}
var offset = SpatialQuery.DirectionToOffset(direction, OffsetIncrement);
NudgeBy(offset.X, offset.Y);
}
/// <summary>Moves the selection by (<paramref name="dx"/>, <paramref name="dy"/>).</summary>
public void NudgeBy(double dx, double dy)
{
if (!TryGetSelectedParts(out var plate, out var parts))
return;
using var change = Host.BeginChange("Nudge", new SelectionKey("Nudge", plate, parts));
change.MarkChanged();
foreach (var part in parts)
part.Offset(dx, dy);
Host.Invalidate();
change.Complete();
}
/// <summary>
/// Moves the selection one repeat step in <paramref name="direction"/>: its size along that
/// axis plus the part spacing, measured on its geometry (<see cref="Compactor.Step"/>).
/// </summary>
public void Step(PushDirection direction)
{
if (!TryGetSelectedParts(out var plate, out var parts))
return;
using var change = Host.BeginChange("Nudge", new SelectionKey("Nudge", plate, parts));
if (Compactor.Step(parts, plate, direction) > 0)
change.MarkChanged();
Host.Invalidate();
change.Complete();
}
/// <summary>
/// Pushes the selection in <paramref name="direction"/> until it meets a part or the edge.
/// </summary>
public void Push(PushDirection direction)
{
if (!TryGetSelectedParts(out var plate, out var parts))
return;
using var change = Host.BeginChange("Push");
change.MarkChanged();
Compactor.Push(parts, plate, direction);
Host.Invalidate();
change.Complete();
}
/// <summary>
/// Rotates the selection by <paramref name="radians"/> about its center, keeping its lower-left
/// corner; with <paramref name="coalesce"/>, quick repeats undo as one.
/// </summary>
public void Rotate(double radians, bool coalesce = false)
{
if (!TryGetSelectedParts(out var plate, out var parts))
return;
using var change = Host.BeginChange("Rotate",
coalesce ? new SelectionKey("Rotate", plate, parts) : null);
change.MarkChanged();
var bounds = parts.GetBoundingBox();
var center = bounds.Center;
var anchor = bounds.Location;
foreach (var part in parts)
part.Rotate(radians, center);
var diff = anchor - parts.GetBoundingBox().Location;
foreach (var part in parts)
part.Offset(diff);
if (plate.CutOffs.Count > 0)
plate.RegenerateCutOffs(Host.CutOffSettings);
Host.Invalidate();
change.Complete();
}
/// <summary>A middle click: a quarter turn counterclockwise, its own undo step.</summary>
public void RotateQuarterTurn() => Rotate(Angle.ToRadians(90));
/// <summary>
/// Shift+wheel: <paramref name="notches"/> wheel notches, positive turned away from the user,
/// rotate clockwise by <see cref="RotateIncrementDegrees"/> each (a tenth of it when
/// <paramref name="fine"/>, Ctrl held); a turn of the wheel undoes as one rotation.
/// </summary>
public void RotateByWheel(int notches, bool fine)
{
if (notches == 0)
return;
var increment = fine ? RotateIncrementDegrees * 0.1 : RotateIncrementDegrees;
var degrees = (notches > 0 ? -increment : increment) * System.Math.Abs(notches);
var angle = Angle.ToRadians(degrees);
Rotate(angle, coalesce: true);
}
private bool TryGetSelectedParts(out Plate plate, out List<Part> parts)
{
plate = Host.Plate;
parts = null;
if (plate == null || Host.EditsLocked)
return false;
Host.Selection.Prune();
parts = Host.Selection.Parts.ToList();
return parts.Count > 0;
}
/// <summary>
/// Equal for the same edit of the same parts, in the same order, on the same plate, so
/// repeated nudges or wheel turns coalesce into one undo entry.
/// </summary>
private sealed class SelectionKey : IEquatable<SelectionKey>
{
private readonly string operation;
private readonly Plate plate;
private readonly Part[] parts;
public SelectionKey(string operation, Plate plate, IEnumerable<Part> selection)
{
this.operation = operation;
this.plate = plate;
parts = selection.ToArray();
}
public bool Equals(SelectionKey other) =>
other != null
&& operation == other.operation
&& ReferenceEquals(plate, other.plate)
&& parts.Length == other.parts.Length
&& parts.Zip(other.parts).All(pair => ReferenceEquals(pair.First, pair.Second));
public override bool Equals(object obj) => Equals(obj as SelectionKey);
public override int GetHashCode() =>
HashCode.Combine(operation, RuntimeHelpers.GetHashCode(plate), parts.Length);
}
}
+26
View File
@@ -1,6 +1,8 @@
using System;
using OpenNest.CutOffs;
using OpenNest.Desktop.Rendering;
using OpenNest.Geometry;
using OpenNest.Undo;
namespace OpenNest.Desktop.Interaction;
@@ -44,6 +46,24 @@ public interface IPlateToolHost
/// <summary>Requests a redraw.</summary>
void Invalidate();
/// <summary>
/// Opens one undoable edit of the plate (see <see cref="NestUndoRecorder.BeginChange"/>). A
/// view without a nest history records nothing.
/// </summary>
ChangeScope BeginChange(string label, object coalesceKey = null);
/// <summary>
/// The settings cut-offs are rebuilt with after an edit moves or removes parts.
/// </summary>
CutOffSettings CutOffSettings { get; }
/// <summary>
/// True while the plate must not be edited, as the WinForms view's <c>EditsLocked</c>: the
/// nest is locked (Auto Nest is running on it; later, an inspection panel shows it). Edits
/// and drag-moves are refused; panning and zooming stay live.
/// </summary>
bool EditsLocked { get; }
}
/// <summary>
@@ -99,5 +119,11 @@ public abstract class PlateTool
/// <returns>Whether the tool used the event.</returns>
public virtual bool PointerReleased(ToolPointer pointer) => false;
/// <summary>
/// The view lost the pointer mid-gesture (Alt+Tab during a drag, say), so no release will
/// follow: the tool ends the gesture in progress.
/// </summary>
public virtual void PointerCaptureLost() { }
protected void RaiseHintChanged() => HintChanged?.Invoke(this, EventArgs.Empty);
}
+93 -4
View File
@@ -1,3 +1,6 @@
using OpenNest.Geometry;
using OpenNest.Undo;
namespace OpenNest.Desktop.Interaction;
/// <summary>
@@ -6,12 +9,24 @@ namespace OpenNest.Desktop.Interaction;
/// <item>A left click within <see cref="CutOffPickPixels"/> of a cut-off's stroke selects that cut-off alone.</item>
/// <item>A left click on a part selects it (with its common-line group) in place of the selection;
/// with Ctrl alone held, or on a part already selected, it adds to the selection instead.</item>
/// <item>Dragging from a part moves every selected part with the pointer, as one "Move" undo
/// step; on release the plate's cut-offs are rebuilt around the parts' new places.</item>
/// <item>A left press on an empty area clears the selection and starts a selection window; on
/// release the window adds the parts and cut-offs it selects (<see cref="SelectionWindow"/>).</item>
/// <item>A right click on an unselected part selects it alone, for its menu; on an empty area it
/// clears the selection.</item>
/// </list>
/// Moving the selection by dragging belongs to the move tools built on this one.
/// Cancelling ends a move in progress where it is (still one undo step) and clears the selection.
/// Losing the pointer mid-drag ends a move as a release where it is and keeps the selection; a
/// selection window is dropped without selecting.
/// <para>
/// While the host's edits are locked (<see cref="IPlateToolHost.EditsLocked"/>) a press does
/// nothing at all, as in WinForms, whose <c>PlateView.OnMouseDown</c> returns before the Select
/// action sees the press: nothing is selected or deselected and no move starts. A move already
/// open when the lock appears is left to finish at its release: a lock is started by a command,
/// not mid-drag, and ending the move then would leave WinForms' quirk of a drag scope held open
/// until some later release.
/// </para>
/// </summary>
public sealed class SelectTool : PlateTool
{
@@ -28,11 +43,19 @@ public sealed class SelectTool : PlateTool
/// <summary>The window being dragged, or null.</summary>
public SelectionWindow? Window { get; private set; }
/// <summary>Whether a drag is moving the selected parts.</summary>
public bool IsMoving => move != null;
private ChangeScope move;
private Vector lastMoveWorld;
/// <summary>Busy while dragging a window or while anything is selected, so Escape first deselects.</summary>
public override bool IsBusy => Window != null || !Host.Selection.IsEmpty;
public override void Cancel()
{
// Parts already dragged stay where they are, so the move is recorded.
EndMove();
Window = null;
Host.Selection.Clear();
Host.Invalidate();
@@ -41,13 +64,14 @@ public sealed class SelectTool : PlateTool
public override bool PointerPressed(ToolPointer pointer)
{
var plate = Host.Plate;
if (plate == null)
if (plate == null || Host.EditsLocked)
return false;
var selection = Host.Selection;
selection.Prune();
if (pointer.Button == ToolButton.Left)
{
EndMove();
Window = null;
var tolerance = Host.View.LengthToWorld(CutOffPickPixels);
var cutOff = Host.HitTester.CutOffAt(plate, pointer.World, tolerance);
@@ -70,6 +94,8 @@ public sealed class SelectTool : PlateTool
if (pointer.Modifiers != ToolModifiers.Control && !selection.Contains(part))
selection.Clear();
selection.Select(part);
move = Host.BeginChange("Move");
lastMoveWorld = pointer.World;
}
Host.Invalidate();
return true;
@@ -93,7 +119,19 @@ public sealed class SelectTool : PlateTool
public override bool PointerMoved(ToolPointer pointer)
{
if (Window is not { } window || pointer.Button != ToolButton.Left)
if (pointer.Button != ToolButton.Left)
return false;
if (move != null)
{
var offset = pointer.World - lastMoveWorld;
lastMoveWorld = pointer.World;
move.MarkChanged();
foreach (var part in Host.Selection.Parts)
part.Offset(offset.X, offset.Y);
Host.Invalidate();
return true;
}
if (Window is not { } window)
return false;
Window = window with { Second = pointer.World };
Host.Invalidate();
@@ -102,7 +140,14 @@ public sealed class SelectTool : PlateTool
public override bool PointerReleased(ToolPointer pointer)
{
if (Window is not { } window || pointer.Button != ToolButton.Left)
if (pointer.Button != ToolButton.Left)
return false;
if (move != null)
{
FinishMove();
return true;
}
if (Window is not { } window)
return false;
window = window with { Second = pointer.World };
Window = null;
@@ -115,4 +160,48 @@ public sealed class SelectTool : PlateTool
Host.Invalidate();
return true;
}
public override void PointerCaptureLost()
{
if (move != null)
FinishMove();
Window = null;
Host.Invalidate();
}
/// <summary>
/// Ends the open move as a release does: the cut-offs are rebuilt around moved parts, then
/// the step is recorded. If rebuilding throws, the scope is disposed incomplete, so the move
/// rolls back, and the exception propagates.
/// </summary>
private void FinishMove()
{
var scope = move;
move = null;
try
{
// Only after a real move: rebuilding gives the cut-offs new programs, which would
// otherwise count as an unrecorded change after a plain click.
var movedOn = Host.Plate;
if (scope.IsChanged && movedOn != null && Host.Selection.Parts.Count > 0
&& movedOn.CutOffs.Count > 0)
movedOn.RegenerateCutOffs(Host.CutOffSettings);
scope.Complete();
}
finally
{
scope.Dispose();
Host.Invalidate();
}
}
private void EndMove()
{
var scope = move;
move = null;
if (scope == null)
return;
scope.Complete();
scope.Dispose();
}
}