using System; using System.Collections.Generic; using System.Linq; using System.Runtime.CompilerServices; using OpenNest.Engine.Fill; using OpenNest.Geometry; using OpenNest.Math; using OpenNest.Undo; namespace OpenNest.Desktop.Interaction; /// /// 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 (). /// /// While a is active in , nudge, step, push and rotate /// move its previews instead, which are not on the plate: no undo step is opened (WinForms /// records an empty one) and cut-offs are not rebuilt. Delete then removes the tool's sources /// (). /// /// public sealed class PlateEdits { public PlateEdits(IPlateToolHost host) { Host = host ?? throw new ArgumentNullException(nameof(host)); } public IPlateToolHost Host { get; } /// /// The view's tools, so edits can act on a place tool's previews; null for none. /// public PlateToolManager Tools { get; set; } /// /// Whether nudge, push and rotate have parts to move: a place tool's previews, or selected /// parts still on the plate. The view checks it before a middle click or Shift+wheel rotates. /// public bool HasPartsToEdit => Placing is { Previews.Count: > 0 } || (Host.Plate != null && Host.Selection.Parts.Any(Host.Plate.Parts.Contains)); private PlaceTool Placing => Tools?.Current as PlaceTool; /// How far an arrow-key nudge moves the selection, in plate units. public double OffsetIncrement { get; set; } = 10; /// /// Whether an arrow key steps the selection by its own size instead (). /// public bool CalculatedOffset { get; set; } /// How far one wheel notch rotates the selection, in degrees. public double RotateIncrementDegrees { get; set; } = 10; /// /// 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. /// public void Delete() { var plate = Host.Plate; if (plate == null || Host.EditsLocked) return; if (Placing is { } placing) { placing.DeleteSources(); 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(); } /// /// An arrow key: moves by , or with /// steps. /// public void Nudge(PushDirection direction) { if (CalculatedOffset) { Step(direction); return; } var offset = SpatialQuery.DirectionToOffset(direction, OffsetIncrement); NudgeBy(offset.X, offset.Y); } /// Moves the selection by (, ). public void NudgeBy(double dx, double dy) { if (!TryGetEditParts(out var plate, out var parts, out var previews)) return; using var change = BeginEdit(previews, "Nudge", new SelectionKey("Nudge", plate, parts)); change.MarkChanged(); foreach (var part in parts) part.Offset(dx, dy); Host.Invalidate(); change.Complete(); } /// /// Moves the selection one repeat step in : its size along that /// axis plus the part spacing, measured on its geometry (). /// public void Step(PushDirection direction) { if (!TryGetEditParts(out var plate, out var parts, out var previews)) return; using var change = BeginEdit(previews, "Nudge", new SelectionKey("Nudge", plate, parts)); if (Compactor.Step(parts, plate, direction) > 0) change.MarkChanged(); Host.Invalidate(); change.Complete(); } /// /// Pushes the selection in until it meets a part or the edge. /// public void Push(PushDirection direction) { if (!TryGetEditParts(out var plate, out var parts, out var previews)) return; using var change = BeginEdit(previews, "Push"); change.MarkChanged(); Compactor.Push(parts, plate, direction); Host.Invalidate(); change.Complete(); } /// /// Rotates the selection by about its center, keeping its lower-left /// corner; with , quick repeats undo as one. /// public void Rotate(double radians, bool coalesce = false) { if (!TryGetEditParts(out var plate, out var parts, out var previews)) return; using var change = BeginEdit(previews, "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 (!previews && plate.CutOffs.Count > 0) plate.RegenerateCutOffs(Host.CutOffSettings); Host.Invalidate(); change.Complete(); } /// A middle click: a quarter turn counterclockwise, its own undo step. public void RotateQuarterTurn() => Rotate(Angle.ToRadians(90)); /// /// Shift+wheel: wheel notches, positive turned away from the user, /// rotate clockwise by each (a tenth of it when /// , Ctrl held); a turn of the wheel undoes as one rotation. /// 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); } // The parts an edit moves: a place tool's previews (previews is true), else the selection. private bool TryGetEditParts(out Plate plate, out List parts, out bool previews) { plate = Host.Plate; parts = null; previews = false; if (plate == null || Host.EditsLocked) return false; if (Placing is { } placing) { previews = true; parts = placing.Previews.ToList(); return parts.Count > 0; } Host.Selection.Prune(); parts = Host.Selection.Parts.ToList(); return parts.Count > 0; } // Previews are not on the nest, so moving them opens no undo step. private ChangeScope BeginEdit(bool previews, string label, object coalesceKey = null) => previews ? ChangeScope.Detached() : Host.BeginChange(label, coalesceKey); /// /// 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. /// private sealed class SelectionKey : IEquatable { private readonly string operation; private readonly Plate plate; private readonly Part[] parts; public SelectionKey(string operation, Plate plate, IEnumerable 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); } }