mirror of
https://github.com/ajisaacs/OpenNest.git
synced 2026-11-20 16:57:41 -05:00
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:
1 parent
e2a27df7ef
commit
203945dabf
7 files changed
+933
-4
No files matched your search
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user