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; /// /// 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 (). /// public sealed class PlateEdits { public PlateEdits(IPlateToolHost host) { Host = host ?? throw new ArgumentNullException(nameof(host)); } public IPlateToolHost Host { get; } /// 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; 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 (!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(); } /// /// 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 (!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(); } /// /// Pushes the selection in until it meets a part or the edge. /// 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(); } /// /// 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 (!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(); } /// 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); } private bool TryGetSelectedParts(out Plate plate, out List 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; } /// /// 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); } }