diff --git a/OpenNest.Desktop.Tests/Undo/NestUndoRecorderTests.cs b/OpenNest.Desktop.Tests/Undo/NestUndoRecorderTests.cs new file mode 100644 index 00000000..2fa5bef2 --- /dev/null +++ b/OpenNest.Desktop.Tests/Undo/NestUndoRecorderTests.cs @@ -0,0 +1,258 @@ +using OpenNest.Geometry; +using OpenNest.Undo; + +namespace OpenNest.Desktop.Tests.Undo; + +public class NestUndoRecorderTests +{ + private static NestUndoRecorder Open(out Document document) + { + document = new Document { Nest = TestNests.OneSquare() }; + var recorder = new NestUndoRecorder(document); + recorder.Reset(); + return recorder; + } + + private static Vector FirstPartLocation(Document document) => + document.Nest.Plates[0].Parts[0].Location; + + [Fact] + public void RecordedEdit_UndoesAndRedoesUnderItsLabel() + { + var recorder = Open(out var document); + var start = FirstPartLocation(document); + + recorder.RecordChange("Move", () => document.Nest.Plates[0].Parts[0].Offset(5, 0)); + var moved = FirstPartLocation(document); + + Assert.Equal("Undo Move", recorder.UndoText); + Assert.Equal("Redo", recorder.RedoText); + Assert.True(recorder.CanUndo); + + recorder.Undo(); + + Assert.Equal(start, FirstPartLocation(document)); + Assert.Equal("Undo", recorder.UndoText); + Assert.Equal("Redo Move", recorder.RedoText); + + recorder.Redo(); + + Assert.Equal(moved, FirstPartLocation(document)); + Assert.Equal("Undo Move", recorder.UndoText); + } + + [Fact] + public void Undo_SwapsTheRestoredCopyInThroughTheView_KeepingTheNestsIdentity() + { + var recorder = Open(out var document); + var live = document.Nest; + Nest swapped = null; + var restoringDuringSwap = false; + recorder.SwapIn = restored => + { + restoringDuringSwap = recorder.IsRestoring && recorder.IsChangeInProgress; + // Rebinding the view is not an edit. + using (var change = recorder.BeginChange("Rebind")) + { + change.MarkChanged(); + change.Complete(); + } + swapped = restored; + document.Nest = restored; + }; + var restoredEvents = 0; + recorder.Restored += (_, _) => restoredEvents++; + recorder.RecordChange("Move", () => live.Plates[0].Parts[0].Offset(5, 0)); + live.Name = "renamed"; + live.Status = NestStatus.HasBeenCut; + + recorder.Undo(); + + Assert.True(restoringDuringSwap); + Assert.NotSame(live, document.Nest); + Assert.Same(swapped, document.Nest); + Assert.Equal("renamed", document.Nest.Name); + Assert.Equal(NestStatus.HasBeenCut, document.Nest.Status); + Assert.Equal(1, restoredEvents); + Assert.False(recorder.IsRestoring); + Assert.Equal(0, recorder.History.UndoCount); + Assert.Equal(1, recorder.History.RedoCount); + } + + [Fact] + public void ASwapInThatRefuses_LeavesTheLiveNest() + { + var recorder = Open(out var document); + recorder.RecordChange("Move", () => document.Nest.Plates[0].Parts[0].Offset(5, 0)); + var live = document.Nest; + recorder.SwapIn = _ => throw new InvalidOperationException("busy"); + + Assert.Throws(recorder.Undo); + + Assert.Same(live, document.Nest); + Assert.False(recorder.IsChangeInProgress); + } + + [Fact] + public void EditOutsideAScope_IsCommittedAsChangeBeforeUndo_SoRedoBringsItBack() + { + var recorder = Open(out var document); + var start = FirstPartLocation(document); + + // An entry point that forgot its scope. + document.Nest.Plates[0].Parts[0].Offset(3, 0); + var moved = FirstPartLocation(document); + + Assert.True(recorder.HasUnrecordedChange); + Assert.False(recorder.History.CanUndo); + + recorder.Undo(); + + Assert.Equal(start, FirstPartLocation(document)); + Assert.Equal("Redo Change", recorder.RedoText); + recorder.Redo(); + Assert.Equal(moved, FirstPartLocation(document)); + } + + [Fact] + public void BeginChange_FirstCommitsAnEditNoScopeRecorded() + { + var recorder = Open(out var document); + document.Nest.Drawings.First().Quantity.Required = 7; + + recorder.RecordChange("Rotate", () => document.Nest.Plates[0].Parts[0].Rotate(System.Math.PI / 2)); + + Assert.Equal(2, recorder.History.UndoCount); + Assert.Equal("Undo Rotate", recorder.UndoText); + recorder.Undo(); + Assert.Equal("Undo Change", recorder.UndoText); + Assert.Equal(7, document.Nest.Drawings.First().Quantity.Required); + } + + [Fact] + public void HasUnsavedChanges_FollowsTheSavePointAndUnrecordedEdits() + { + var recorder = Open(out var document); + Assert.False(recorder.HasUnsavedChanges); + + document.Nest.Plates[0].Parts[0].Offset(1, 0); + Assert.True(recorder.HasUnsavedChanges); + + recorder.Undo(); + Assert.False(recorder.HasUnsavedChanges); + + recorder.Redo(); + Assert.True(recorder.HasUnsavedChanges); + + recorder.MarkSaved(); + Assert.False(recorder.HasUnsavedChanges); + } + + [Fact] + public void MarkSaved_RecordsAnUnrecordedEditFirst_SoTheSavePointCoversIt() + { + var recorder = Open(out var document); + document.Nest.Plates[0].Parts[0].Offset(1, 0); + + recorder.MarkSaved(); + + Assert.False(recorder.HasUnsavedChanges); + Assert.Equal("Undo Change", recorder.UndoText); + Assert.True(recorder.History.IsAtSavePoint); + } + + [Fact] + public void AScopeLeftIncomplete_RollsTheNestBack() + { + var recorder = Open(out var document); + var start = FirstPartLocation(document); + + using (var change = recorder.BeginChange("Push")) + { + change.MarkChanged(); + document.Nest.Plates[0].Parts[0].Offset(9, 0); + // An exception or a cancellation: never completed. + } + + Assert.Equal(start, FirstPartLocation(document)); + Assert.False(recorder.History.CanUndo); + Assert.False(recorder.HasUnsavedChanges); + } + + [Fact] + public void AScopeThatChangedNothing_RecordsNothing() + { + var recorder = Open(out _); + var changed = 0; + recorder.Changed += (_, _) => changed++; + + using (var change = recorder.BeginChange("Fill")) + change.Complete(); + + Assert.False(recorder.History.CanUndo); + Assert.Equal(0, changed); + } + + [Fact] + public void NestedScopes_UndoAsOneEntryUnderTheOuterLabel() + { + var recorder = Open(out var document); + + using (var outer = recorder.BeginChange("Auto Nest")) + { + Assert.True(recorder.IsChangeInProgress); + Assert.False(recorder.CanUndo); + recorder.RecordChange("Add Plate", () => document.Nest.CreatePlate()); + outer.MarkChanged(); + document.Nest.Plates[0].Parts[0].Offset(2, 0); + outer.Complete(); + } + + Assert.Equal(1, recorder.History.UndoCount); + Assert.Equal("Undo Auto Nest", recorder.UndoText); + } + + [Fact] + public void UndoAndRedo_DoNothingWhileAScopeIsOpen() + { + var recorder = Open(out var document); + recorder.RecordChange("Move", () => document.Nest.Plates[0].Parts[0].Offset(5, 0)); + var live = document.Nest; + + using (var change = recorder.BeginChange("Rotate")) + { + recorder.Undo(); + Assert.Same(live, document.Nest); + change.Complete(); + } + + Assert.Equal(1, recorder.History.UndoCount); + } + + [Fact] + public void TakeUnrecordedChangeWarning_ReportsEachUnrecordedEditOnce() + { + var recorder = Open(out var document); + Assert.False(recorder.TakeUnrecordedChangeWarning()); + + document.Nest.Plates[0].Parts[0].Offset(1, 0); + + Assert.True(recorder.TakeUnrecordedChangeWarning()); + Assert.False(recorder.TakeUnrecordedChangeWarning()); + document.Nest.Plates[0].Parts[0].Offset(1, 0); + Assert.True(recorder.TakeUnrecordedChangeWarning()); + } + + [Fact] + public void MenuText_NamesTheNextStep() + { + var recorder = Open(out var document); + Assert.Equal("Undo", recorder.UndoText); + Assert.Equal("Redo", recorder.RedoText); + Assert.Equal("Undo", NestUndoRecorder.UndoMenuText(null)); + + recorder.RecordChange("Fill", () => document.Nest.Plates[0].Parts[0].Offset(1, 0)); + + Assert.Equal("Undo Fill", recorder.UndoText); + } +} diff --git a/OpenNest.Desktop/Undo/NestUndoRecorder.cs b/OpenNest.Desktop/Undo/NestUndoRecorder.cs new file mode 100644 index 00000000..2655aef1 --- /dev/null +++ b/OpenNest.Desktop/Undo/NestUndoRecorder.cs @@ -0,0 +1,256 @@ +using System; +using OpenNest.Data; +using OpenNest.IO; + +namespace OpenNest.Undo +{ + /// + /// Records a document's nest edits into its undo history and steps through it, for any + /// desktop front end. Edits go through or + /// ; an edit made outside a scope is found by fingerprint before + /// the next scope, Undo, Redo or save and committed as "Change". Undo and Redo read a + /// whole-nest copy back and hand it to , which the view sets to rebind + /// everything that held the old nest. + /// + public sealed class NestUndoRecorder + { + /// The label of an edit no scope recorded, found by fingerprint. + public const string UnrecordedChangeLabel = "Change"; + + private readonly Document document; + private ChangeScope openChange; + private int recordedFingerprint; + private int warnedFingerprint; + + public NestUndoRecorder(Document document) + { + ArgumentNullException.ThrowIfNull(document); + this.document = document; + document.History.Changed += (_, _) => Changed?.Invoke(this, EventArgs.Empty); + } + + /// + /// Raised after the history or the recorded state changed: a commit, an Undo or Redo, + /// a save point or a restore. Unsaved-change marks and Edit menu labels follow it. + /// + public event EventHandler Changed; + + /// Raised after swapped a nest in. + public event EventHandler Restored; + + public Document Document => document; + + public UndoHistory History => document.History; + + /// + /// Puts a nest read back from the history in the document and rebinds the view to it. + /// It must set ; the default does only that. A view + /// that cannot take the nest now throws and the live nest stays. + /// + public Action SwapIn { get; set; } + + /// True while swaps a nest in. + public bool IsRestoring { get; private set; } + + /// True while a change scope is open or a nest is being swapped in. + public bool IsChangeInProgress => openChange != null || IsRestoring; + + /// Whether would step back: there is a step and no edit is open. + public bool CanUndo => History.CanUndo && !IsChangeInProgress; + + public bool CanRedo => History.CanRedo && !IsChangeInProgress; + + /// "Undo Rotate", or "Undo" when there is nothing to undo. + public string UndoText => UndoMenuText(History); + + /// "Redo Fill", or "Redo" when there is nothing to redo. + public string RedoText => RedoMenuText(History); + + public static string UndoMenuText(UndoHistory history) + where TState : class, IUndoState => + history?.UndoLabel is { } label ? $"Undo {label}" : "Undo"; + + public static string RedoMenuText(UndoHistory history) + where TState : class, IUndoState => + history?.RedoLabel is { } label ? $"Redo {label}" : "Redo"; + + /// + /// True when the nest differs from the state last saved (or opened): the history has + /// moved off its save point, or an edit no scope recorded is pending. + /// + public bool HasUnsavedChanges => + History.Current != null + && (!History.IsAtSavePoint || NestFingerprint.Compute(document.Nest) != recordedFingerprint); + + /// True when the nest changed since the last recorded state without a scope. + public bool HasUnrecordedChange => + History.Current != null && NestFingerprint.Compute(document.Nest) != recordedFingerprint; + + /// + /// Starts the history over from the nest as it stands, as opening it does. The state is + /// treated as saved. + /// + public void Reset() + { + History.Reset(new NestUndoState(NestSnapshot.Capture(document.Nest))); + recordedFingerprint = NestFingerprint.Compute(document.Nest); + Changed?.Invoke(this, EventArgs.Empty); + } + + /// + /// Opens a scope that records one undoable edit named . Mark it + /// changed and complete it; a scope opened inside another merges into the outermost one. + /// Repeated edits with an equal within a second undo as one. + /// + public ChangeScope BeginChange(string label, object coalesceKey = null) + { + ArgumentException.ThrowIfNullOrEmpty(label); + if (openChange != null) + return ChangeScope.Nested(openChange); + // Swapping a nest in rebinds the view; nothing it does is an edit. + if (IsRestoring) + return ChangeScope.Detached(); + + RecordUnrecordedChange(); + openChange = ChangeScope.Root(label, coalesceKey, EndChange); + return openChange; + } + + /// Runs , which changes the nest, as one undoable step. + public void RecordChange(string label, Action edit) + { + ArgumentNullException.ThrowIfNull(edit); + using var change = BeginChange(label); + change.MarkChanged(); + edit(); + change.Complete(); + } + + /// Steps back one edit; does nothing while an edit or restore is in progress. + public void Undo() + { + if (IsChangeInProgress) + return; + RecordUnrecordedChange(); + if (History.CanUndo) + Restore(History.Undo(), History.Redo); + } + + /// Repeats the next undone edit; does nothing while an edit or restore is in progress. + public void Redo() + { + if (IsChangeInProgress) + return; + // An edit made since the undo drops what could be redone. + RecordUnrecordedChange(); + if (History.CanRedo) + Restore(History.Redo(), History.Undo); + } + + /// + /// Marks the nest as it stands saved, committing any edit no scope recorded first so + /// the save point covers it. + /// + public void MarkSaved() + { + RecordUnrecordedChange(); + if (History.Current != null) + History.MarkSaved(); + } + + /// + /// Commits an edit no scope recorded as its own entry, so a rollback, Undo or Redo + /// does not silently discard it, and a save marks it saved. Detected by fingerprint, so + /// best effort. + /// + public void RecordUnrecordedChange() + { + if (HasUnrecordedChange) + Commit(UnrecordedChangeLabel, null); + } + + /// + /// True the first time an unrecorded edit is seen, for a debug warning that an entry + /// point forgot its scope; false while a scope is open or for the edit already reported. + /// + public bool TakeUnrecordedChangeWarning() + { + if (IsChangeInProgress || History.Current == null) + return false; + var fingerprint = NestFingerprint.Compute(document.Nest); + if (fingerprint == recordedFingerprint || fingerprint == warnedFingerprint) + return false; + warnedFingerprint = fingerprint; + return true; + } + + /// + /// Replaces the document's nest with , a copy read back from + /// the history, through . The nest's identity (name, status, author, + /// creation date) is carried over from the live nest; nothing it does is recorded. + /// + public void RestoreNest(Nest restored) + { + ArgumentNullException.ThrowIfNull(restored); + var live = document.Nest; + restored.Name = live.Name; + restored.Status = live.Status; + restored.MadeBy = live.MadeBy; + restored.DateCreated = live.DateCreated; + + IsRestoring = true; + try + { + if (SwapIn != null) + SwapIn(restored); + else + document.Nest = restored; + } + finally + { + IsRestoring = false; + } + + recordedFingerprint = NestFingerprint.Compute(document.Nest); + Changed?.Invoke(this, EventArgs.Empty); + Restored?.Invoke(this, EventArgs.Empty); + } + + /// + /// Reads back and swaps it in; when the copy cannot be read the + /// live nest is untouched, so points the history back at it. + /// + private void Restore(NestUndoState state, Func moveBack) + { + Nest restored; + try + { + restored = state.Snapshot.Restore(document.Nest); + } + catch + { + moveBack(); + throw; + } + RestoreNest(restored); + } + + private void EndChange(ChangeScope scope) + { + openChange = null; + if (!scope.IsChanged) + return; + if (scope.Succeeded) + Commit(scope.Label, scope.CoalesceKey); + else + RestoreNest(History.Current.Snapshot.Restore(document.Nest)); + } + + private void Commit(string label, object coalesceKey) + { + History.Commit(label, new NestUndoState(NestSnapshot.Capture(document.Nest)), coalesceKey); + recordedFingerprint = NestFingerprint.Compute(document.Nest); + Changed?.Invoke(this, EventArgs.Empty); + } + } +} diff --git a/OpenNest/Forms/EditNestForm.Undo.cs b/OpenNest/Forms/EditNestForm.Undo.cs index 9d1f101a..f125f59c 100644 --- a/OpenNest/Forms/EditNestForm.Undo.cs +++ b/OpenNest/Forms/EditNestForm.Undo.cs @@ -5,107 +5,60 @@ using System.Windows.Forms; using OpenNest.Actions; using OpenNest.CutOffs; using OpenNest.Data; -using OpenNest.IO; using OpenNest.Undo; namespace OpenNest.Forms { - // Undo and Redo: the history holds whole-nest copies and a restore swaps one in. + // Undo and Redo: the history holds whole-nest copies and a restore swaps one in. Recording, + // the fingerprint check and stepping are the shared NestUndoRecorder; this window rebinds. public partial class EditNestForm { - private ChangeScope openChange; - private int recordedFingerprint; - private bool restoringNest; + private NestUndoRecorder undo; /// Raised after swapped a nest in, for windows that show it. public event EventHandler NestRestored; public UndoHistory History => Document.History; + /// The shared recorder of this window's nest edits. + internal NestUndoRecorder UndoRecorder => undo ??= CreateRecorder(); + /// True while a change scope is open or a nest is being swapped in. - public bool IsChangeInProgress => openChange != null || restoringNest; + public bool IsChangeInProgress => UndoRecorder.IsChangeInProgress; /// /// Opens a scope that records one undoable edit named . Mark it /// changed and complete it; a scope opened inside another merges into the outermost one. /// Repeated edits with an equal within a second undo as one. /// - public ChangeScope BeginChange(string label, object coalesceKey = null) - { - ArgumentException.ThrowIfNullOrEmpty(label); - if (openChange != null) - return ChangeScope.Nested(openChange); - // Swapping a nest in rebinds the view; nothing it does is an edit. - if (restoringNest) - return ChangeScope.Detached(); - - RecordUnrecordedChange(); - openChange = ChangeScope.Root(label, coalesceKey, EndChange); - return openChange; - } + public ChangeScope BeginChange(string label, object coalesceKey = null) => + UndoRecorder.BeginChange(label, coalesceKey); /// Runs , which changes the nest, as one undoable step. - public void RecordChange(string label, System.Action edit) - { - ArgumentNullException.ThrowIfNull(edit); - using var change = BeginChange(label); - change.MarkChanged(); - edit(); - change.Complete(); - } + public void RecordChange(string label, System.Action edit) => UndoRecorder.RecordChange(label, edit); /// Whether would step back: no edit or inspection is open. - public bool CanUndo => History.CanUndo && CanRestore; + public bool CanUndo => UndoRecorder.CanUndo && !IsInspecting; - public bool CanRedo => History.CanRedo && CanRestore; - - private bool CanRestore => !IsChangeInProgress && !IsInspecting; + public bool CanRedo => UndoRecorder.CanRedo && !IsInspecting; public void Undo() { - if (!CanRestore) - return; - RecordUnrecordedChange(); - if (History.CanUndo) - Restore(History.Undo(), History.Redo); + if (!IsInspecting) + UndoRecorder.Undo(); } public void Redo() { - if (!CanRestore) - return; - // An edit made since the undo drops what could be redone. - RecordUnrecordedChange(); - if (History.CanRedo) - Restore(History.Redo(), History.Undo); - } - - /// - /// Reads back and swaps it in; when the copy cannot be read the - /// live nest is untouched, so points the history back at it. - /// - private void Restore(NestUndoState state, Func moveBack) - { - Nest restored; - try - { - restored = state.Snapshot.Restore(Nest); - } - catch - { - moveBack(); - throw; - } - RestoreNest(restored); + if (!IsInspecting) + UndoRecorder.Redo(); } /// /// True when the nest differs from the state last saved (or opened): the history has /// moved off its save point, or an edit no scope recorded is pending. /// - public bool HasUnsavedChanges => - History.Current != null - && (!History.IsAtSavePoint || NestFingerprint.Compute(Nest) != recordedFingerprint); + public bool HasUnsavedChanges => UndoRecorder.HasUnsavedChanges; /// /// Marks the nest as it stands saved, for a nest something else wrote to the server @@ -113,54 +66,36 @@ namespace OpenNest.Forms /// internal void MarkSaved() { - RecordUnrecordedChange(); - if (History.Current != null) - History.MarkSaved(); + UndoRecorder.MarkSaved(); UpdateTitle(); } /// Shows the nest's name, marked with an asterisk while it has unsaved changes. internal void UpdateTitle() => Text = HasUnsavedChanges ? $"{Nest.Name} *" : Nest.Name; + private NestUndoRecorder CreateRecorder() + { + var recorder = new NestUndoRecorder(Document) { SwapIn = SwapInRestoredNest }; + recorder.Changed += (_, _) => UpdateTitle(); + recorder.Restored += (_, _) => NestRestored?.Invoke(this, EventArgs.Empty); + return recorder; + } + private void InitializeHistory() { - History.Reset(new NestUndoState(NestSnapshot.Capture(Nest))); - recordedFingerprint = NestFingerprint.Compute(Nest); - History.Changed += (_, _) => UpdateTitle(); + UndoRecorder.Reset(); #if DEBUG Application.Idle += CheckForUnrecordedChange; FormClosed += (_, _) => Application.Idle -= CheckForUnrecordedChange; #endif } - private void EndChange(ChangeScope scope) - { - openChange = null; - if (!scope.IsChanged) - return; - if (scope.Succeeded) - Commit(scope.Label, scope.CoalesceKey); - else - RestoreNest(History.Current.Snapshot.Restore(Nest)); - } - - private void Commit(string label, object coalesceKey) - { - History.Commit(label, new NestUndoState(NestSnapshot.Capture(Nest)), coalesceKey); - recordedFingerprint = NestFingerprint.Compute(Nest); - UpdateTitle(); - } - /// /// Commits an edit no scope recorded as its own entry, so a rollback, Undo or Redo /// does not silently discard it, and a save marks it saved. Detected by fingerprint, so /// best effort. /// - internal void RecordUnrecordedChange() - { - if (History.Current != null && NestFingerprint.Compute(Nest) != recordedFingerprint) - Commit("Change", null); - } + internal void RecordUnrecordedChange() => UndoRecorder.RecordUnrecordedChange(); /// /// Replaces the document's nest with , a copy read back from @@ -168,20 +103,16 @@ namespace OpenNest.Forms /// identity (name, status, author, creation date), the plate shown, the viewport and the /// selection (by part index) are kept. /// - public void RestoreNest(Nest restored) + public void RestoreNest(Nest restored) => UndoRecorder.RestoreNest(restored); + + // The recorder's swap-in, run with the identity already carried over and nothing recorded. + private void SwapInRestoredNest(Nest restored) { - ArgumentNullException.ThrowIfNull(restored); // Apply after a restore would commit to plates no longer in the nest. CuttingInspection?.RequestClose(); if (CuttingInspection != null) throw new InvalidOperationException("Close Cutting Inspection before undoing."); - var live = Nest; - restored.Name = live.Name; - restored.Status = live.Status; - restored.MadeBy = live.MadeBy; - restored.DateCreated = live.DateCreated; - var plateIndex = PlateManager.CurrentIndex; var partCount = PlateView.Plate?.Parts.Count ?? 0; var selected = PlateView.SelectedParts @@ -190,55 +121,43 @@ namespace OpenNest.Forms .ToArray(); var viewport = PlateView.CaptureViewport(); - restoringNest = true; + // Actions, previews and side panels hold parts and plates of the old nest. + PlateView.EndAction(); + PlateView.ClearPreviewParts(); + PlateView.CancelOverlapCheck(); + drawingListBox1.CancelPickup(); + addPart = false; + if (IsSidePanelVisible) + HideSidePanel(); + + UnbindNest(); + Document.Nest = restored; + BindNest(restored); + // Reading regenerates cut-offs with default settings; the view's apply here. + // Regenerating empties a cut-off-only plate for a moment, so the batch keeps + // the new-plate sentinel from adding or dropping plates until all are done. + PlateManager.BeginBatch(); try { - // Actions, previews and side panels hold parts and plates of the old nest. - PlateView.EndAction(); - PlateView.ClearPreviewParts(); - PlateView.CancelOverlapCheck(); - drawingListBox1.CancelPickup(); - addPart = false; - if (IsSidePanelVisible) - HideSidePanel(); - - UnbindNest(); - Document.Nest = restored; - BindNest(restored); - // Reading regenerates cut-offs with default settings; the view's apply here. - // Regenerating empties a cut-off-only plate for a moment, so the batch keeps - // the new-plate sentinel from adding or dropping plates until all are done. - PlateManager.BeginBatch(); - try - { - foreach (var plate in restored.Plates.Where(plate => plate.CutOffs.Count > 0).ToArray()) - plate.RegenerateCutOffs(PlateView.CutOffSettings); - } - finally - { - PlateManager.EndBatch(); - } - ColorSchemeRegistry.RecolorDrawings(restored); - - // Loading a plate zooms to fit; an undo keeps the view where it was. - PlateManager.LoadAt(System.Math.Clamp(plateIndex, 0, System.Math.Max(0, PlateManager.Count - 1))); - PlateView.RestoreViewport(viewport); - if (PlateView.Plate.Parts.Count == partCount && selected.Length > 0) - Reselect(selected); - - UpdatePlateList(); - UpdatePlateHeader(); - UpdateRemovePlateButton(); - PlateView.Invalidate(); + foreach (var plate in restored.Plates.Where(plate => plate.CutOffs.Count > 0).ToArray()) + plate.RegenerateCutOffs(PlateView.CutOffSettings); } finally { - restoringNest = false; + PlateManager.EndBatch(); } + ColorSchemeRegistry.RecolorDrawings(restored); - recordedFingerprint = NestFingerprint.Compute(Nest); - UpdateTitle(); - NestRestored?.Invoke(this, EventArgs.Empty); + // Loading a plate zooms to fit; an undo keeps the view where it was. + PlateManager.LoadAt(System.Math.Clamp(plateIndex, 0, System.Math.Max(0, PlateManager.Count - 1))); + PlateView.RestoreViewport(viewport); + if (PlateView.Plate.Parts.Count == partCount && selected.Length > 0) + Reselect(selected); + + UpdatePlateList(); + UpdatePlateHeader(); + UpdateRemovePlateButton(); + PlateView.Invalidate(); } private void Reselect(int[] indices) @@ -255,7 +174,6 @@ namespace OpenNest.Forms #if DEBUG private DateTime nextUnrecordedCheck; - private int warnedFingerprint; // Every edit should open a change scope; one that does not folds into the next entry. private void CheckForUnrecordedChange(object sender, EventArgs e) @@ -263,11 +181,8 @@ namespace OpenNest.Forms if (IsDisposed || IsChangeInProgress || PlateView.IsFillInProgress || DateTime.UtcNow < nextUnrecordedCheck) return; nextUnrecordedCheck = DateTime.UtcNow.AddMilliseconds(500); - var fingerprint = NestFingerprint.Compute(Nest); - if (fingerprint == recordedFingerprint || fingerprint == warnedFingerprint) - return; - warnedFingerprint = fingerprint; - Debug.WriteLine($"Undo: '{Nest.Name}' changed outside a change scope; the edit is not recorded yet."); + if (UndoRecorder.TakeUnrecordedChangeWarning()) + Debug.WriteLine($"Undo: '{Nest.Name}' changed outside a change scope; the edit is not recorded yet."); } #endif } diff --git a/OpenNest/Forms/MainForm.Undo.cs b/OpenNest/Forms/MainForm.Undo.cs index c37412f9..a65343d9 100644 --- a/OpenNest/Forms/MainForm.Undo.cs +++ b/OpenNest/Forms/MainForm.Undo.cs @@ -2,6 +2,7 @@ using System; using System.Linq; using System.Windows.Forms; using OpenNest.Controls; +using OpenNest.Undo; namespace OpenNest.Forms { @@ -119,8 +120,8 @@ namespace OpenNest.Forms var history = form?.History; mnuEditUndo.Enabled = available && form.CanUndo; mnuEditRedo.Enabled = available && form.CanRedo; - mnuEditUndo.Text = history?.UndoLabel is { } undo ? $"Undo {undo}" : "Undo"; - mnuEditRedo.Text = history?.RedoLabel is { } redo ? $"Redo {redo}" : "Redo"; + mnuEditUndo.Text = NestUndoRecorder.UndoMenuText(history); + mnuEditRedo.Text = NestUndoRecorder.RedoMenuText(history); } private void EditForm_NestRestored(object sender, EventArgs e)