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);
}
}