Ignore changes that don't change anything

src/ChangeableDocument/Actions/Properties/SetStructureMemberName_Action.cs

@@ -15,6 +15,6 @@ public record class SetStructureMemberName_Action : IMakeChangeAction
 
     IChange IMakeChangeAction.CreateCorrespondingChange()
     {
-        return new StructureMemberProperties_Change(GuidValue) { NewName = Name };
+        return new StructureMemberName_Change(GuidValue, Name);
     }
 }

src/ChangeableDocument/Actions/Properties/SetStructureMemberVisibility_Action.cs

@@ -15,6 +15,6 @@ public record class SetStructureMemberVisibility_Action : IMakeChangeAction
 
     IChange IMakeChangeAction.CreateCorrespondingChange()
     {
-        return new StructureMemberProperties_Change(GuidValue) { NewIsVisible = isVisible };
+        return new StructureMemberVisibility_Change(GuidValue, isVisible);
     }
 }

src/ChangeableDocument/ChangeInfos/CreateStructureMember_ChangeInfo.cs

@@ -0,0 +1,7 @@
+namespace ChangeableDocument.ChangeInfos
+{
+    public record class CreateStructureMember_ChangeInfo : IChangeInfo
+    {
+        public Guid GuidValue { get; init; }
+    }
+}

src/ChangeableDocument/ChangeInfos/DeleteStructureMember_ChangeInfo.cs

@@ -0,0 +1,7 @@
+namespace ChangeableDocument.ChangeInfos
+{
+    public record class DeleteStructureMember_ChangeInfo : IChangeInfo
+    {
+        public Guid GuidValue { get; init; }
+    }
+}

src/ChangeableDocument/ChangeInfos/MoveStructureMember_ChangeInfo.cs

@@ -0,0 +1,7 @@
+namespace ChangeableDocument.ChangeInfos
+{
+    public record class MoveStructureMember_ChangeInfo : IChangeInfo
+    {
+        public Guid GuidValue { get; init; }
+    }
+}

src/ChangeableDocument/ChangeInfos/StructureChangeInfos.cs

@@ -1,17 +0,0 @@
-namespace ChangeableDocument.ChangeInfos
-{
-    public record class CreateStructureMember_ChangeInfo : IChangeInfo
-    {
-        public Guid GuidValue { get; init; }
-    }
-
-    public record class DeleteStructureMember_ChangeInfo : IChangeInfo
-    {
-        public Guid GuidValue { get; init; }
-    }
-
-    public record class MoveStructureMember_ChangeInfo : IChangeInfo
-    {
-        public Guid GuidValue { get; init; }
-    }
-}

src/ChangeableDocument/ChangeInfos/StructureMemberIsVisible_ChangeInfo.cs

@@ -0,0 +1,7 @@
+namespace ChangeableDocument.ChangeInfos
+{
+    public record class StructureMemberIsVisible_ChangeInfo : IChangeInfo
+    {
+        public Guid GuidValue { get; init; }
+    }
+}

src/ChangeableDocument/ChangeInfos/StructureMemberName_ChangeInfo.cs

@@ -0,0 +1,7 @@
+namespace ChangeableDocument.ChangeInfos
+{
+    public record class StructureMemberName_ChangeInfo : IChangeInfo
+    {
+        public Guid GuidValue { get; init; }
+    }
+}

src/ChangeableDocument/ChangeInfos/StructureMemberProperties_ChangeInfo.cs

@@ -1,9 +0,0 @@
-namespace ChangeableDocument.ChangeInfos
-{
-    public record class StructureMemberProperties_ChangeInfo : IChangeInfo
-    {
-        public Guid GuidValue { get; init; }
-        public bool IsVisibleChanged { get; init; } = false;
-        public bool NameChanged { get; init; } = false;
-    }
-}

src/ChangeableDocument/Changes/CreateStructureMember_Change.cs

@@ -23,7 +23,7 @@ namespace ChangeableDocument.Changes
             newMemberGuid = Guid.NewGuid();
         }
 
-        public IChangeInfo Apply(Document document)
+        public IChangeInfo Apply(Document document, out bool ignoreInUndo)
         {
             var folder = (Folder)document.FindMemberOrThrow(parentFolderGuid);
 
@@ -36,6 +36,7 @@ namespace ChangeableDocument.Changes
 
             folder.Children.Insert(parentFolderIndex, member);
 
+            ignoreInUndo = false;
             return new CreateStructureMember_ChangeInfo() { GuidValue = newMemberGuid };
         }
 

src/ChangeableDocument/Changes/DeleteStructureMember_Change.cs

@@ -23,11 +23,12 @@ namespace ChangeableDocument.Changes
             savedCopy = member.Clone();
         }
 
-        public IChangeInfo Apply(Document document)
+        public IChangeInfo Apply(Document document, out bool ignoreInUndo)
         {
             var (member, parent) = document.FindChildAndParentOrThrow(memberGuid);
             parent.Children.Remove(member);
             member.Dispose();
+            ignoreInUndo = false;
             return new DeleteStructureMember_ChangeInfo() { GuidValue = memberGuid };
         }
 

src/ChangeableDocument/Changes/Drawing/ClearSelection_Change.cs

@@ -16,10 +16,13 @@ namespace ChangeableDocument.Changes.Drawing
                 savedSelection = new(target.Selection.SelectionImage, target.Selection.SelectionImage.FindAllChunks());
         }
 
-        public IChangeInfo? Apply(Document target)
+        public IChangeInfo? Apply(Document target, out bool ignoreInUndo)
         {
             if (originalIsEmpty)
-                return new Selection_ChangeInfo() { Chunks = new() };
+            {
+                ignoreInUndo = true;
+                return null;
+            }
             target.Selection.IsEmptyAndInactive = true;
 
             target.Selection.SelectionImage.CancelChanges();
@@ -27,6 +30,7 @@ namespace ChangeableDocument.Changes.Drawing
             HashSet<Vector2i> affChunks = target.Selection.SelectionImage.FindAffectedChunks();
             target.Selection.SelectionImage.CommitChanges();
 
+            ignoreInUndo = false;
             return new Selection_ChangeInfo() { Chunks = affChunks };
         }
 

src/ChangeableDocument/Changes/Drawing/CombineStructureMembersOnto_Change.cs

@@ -44,7 +44,7 @@ namespace ChangeableDocument.Changes.Drawing
             }
         }
 
-        public IChangeInfo? Apply(Document target)
+        public IChangeInfo? Apply(Document target, out bool ignoreInUndo)
         {
             Layer toDrawOn = (Layer)target.FindMemberOrThrow(targetLayer);
 
@@ -65,6 +65,7 @@ namespace ChangeableDocument.Changes.Drawing
             originalChunks = new CommittedChunkStorage(toDrawOn.LayerImage, affectedChunks);
             toDrawOn.LayerImage.CommitChanges();
 
+            ignoreInUndo = false;
             return new LayerImageChunks_ChangeInfo()
             {
                 LayerGuid = targetLayer,

src/ChangeableDocument/Changes/Drawing/DrawRectangle_UpdateableChange.cs

@@ -40,12 +40,14 @@ namespace ChangeableDocument.Changes.Drawing
             };
         }
 
-        public IChangeInfo? Apply(Document target)
+        public IChangeInfo? Apply(Document target, out bool ignoreInUndo)
         {
             Layer layer = (Layer)target.FindMemberOrThrow(layerGuid);
             var changes = ApplyTemporarily(target);
             storedChunks = new CommittedChunkStorage(layer.LayerImage, ((LayerImageChunks_ChangeInfo)changes!).Chunks!);
             layer.LayerImage.CommitChanges();
+
+            ignoreInUndo = false;
             return changes;
         }
 

src/ChangeableDocument/Changes/Drawing/SelectRectangle_UpdateableChange.cs

@@ -38,12 +38,13 @@ namespace ChangeableDocument.Changes.Drawing
             return new Selection_ChangeInfo() { Chunks = oldChunks };
         }
 
-        public IChangeInfo? Apply(Document target)
+        public IChangeInfo? Apply(Document target, out bool ignoreInUndo)
         {
             var changes = ApplyTemporarily(target);
             originalSelectionState = new CommittedChunkStorage(target.Selection.SelectionImage, ((Selection_ChangeInfo)changes!).Chunks!);
             target.Selection.SelectionImage.CommitChanges();
             target.Selection.IsEmptyAndInactive = target.Selection.SelectionImage.CheckIfCommittedIsEmpty();
+            ignoreInUndo = false;
             return changes;
         }
 

src/ChangeableDocument/Changes/IChange.cs

@@ -6,7 +6,7 @@ namespace ChangeableDocument.Changes
     internal interface IChange : IDisposable
     {
         void Initialize(Document target);
-        IChangeInfo? Apply(Document target);
+        IChangeInfo? Apply(Document target, out bool ignoreInUndo);
         IChangeInfo? Revert(Document target);
     };
 }

src/ChangeableDocument/Changes/MoveStructureMember_Change.cs

@@ -36,9 +36,10 @@ namespace ChangeableDocument.Changes
             targetFolder.Children.Insert(targetIndex, member);
         }
 
-        public IChangeInfo? Apply(Document target)
+        public IChangeInfo? Apply(Document target, out bool ignoreInUndo)
         {
             Move(target, memberGuid, targetFolderGuid, targetFolderIndex);
+            ignoreInUndo = false;
             return new MoveStructureMember_ChangeInfo() { GuidValue = memberGuid };
         }
 

src/ChangeableDocument/Changes/ResizeCanvas_Change.cs

@@ -33,8 +33,14 @@ namespace ChangeableDocument.Changes
             }
         }
 
-        public IChangeInfo? Apply(Document target)
+        public IChangeInfo? Apply(Document target, out bool ignoreInUndo)
         {
+            if (originalSize == newSize)
+            {
+                ignoreInUndo = true;
+                return null;
+            }
+
             target.Size = newSize;
 
             ForEachLayer(target.StructureRoot, (layer) =>
@@ -48,11 +54,15 @@ namespace ChangeableDocument.Changes
             selectionChunkStorage = new(target.Selection.SelectionImage, target.Selection.SelectionImage.FindAffectedChunks());
             target.Selection.SelectionImage.CommitChanges();
 
+            ignoreInUndo = false;
             return new Size_ChangeInfo();
         }
 
         public IChangeInfo? Revert(Document target)
         {
+            if (originalSize == newSize)
+                return null;
+
             target.Size = originalSize;
             ForEachLayer(target.StructureRoot, (layer) =>
             {

src/ChangeableDocument/Changes/StructureMemberName_Change.cs

@@ -0,0 +1,46 @@
+using ChangeableDocument.Changeables;
+using ChangeableDocument.ChangeInfos;
+
+namespace ChangeableDocument.Changes
+{
+    internal class StructureMemberName_Change : IChange
+    {
+        private string? originalName;
+        private string newName;
+        private Guid targetMember;
+        public StructureMemberName_Change(Guid targetMember, string newName)
+        {
+            this.targetMember = targetMember;
+            this.newName = newName;
+        }
+
+        public void Initialize(Document target)
+        {
+            var member = target.FindMemberOrThrow(targetMember);
+            originalName = member.Name;
+        }
+
+        public IChangeInfo? Apply(Document target, out bool ignoreInUndo)
+        {
+            if (originalName == newName)
+            {
+                ignoreInUndo = true;
+                return null;
+            }
+            target.FindMemberOrThrow(targetMember).Name = newName;
+
+            ignoreInUndo = false;
+            return new StructureMemberName_ChangeInfo() { GuidValue = targetMember };
+        }
+
+        public IChangeInfo? Revert(Document target)
+        {
+            if (originalName == null)
+                throw new Exception("No name to revert to");
+            target.FindMemberOrThrow(targetMember).Name = originalName;
+            return new StructureMemberName_ChangeInfo() { GuidValue = targetMember };
+        }
+
+        public void Dispose() { }
+    }
+}

src/ChangeableDocument/Changes/StructureMemberOpacity_UpdateableChange.cs

@@ -8,17 +8,17 @@ namespace ChangeableDocument.Changes
         private Guid memberGuid;
 
         private float originalOpacity;
-        public float NewOpacity { get; private set; }
+        private float newOpacity;
 
         public StructureMemberOpacity_UpdateableChange(Guid memberGuid, float opacity)
         {
             this.memberGuid = memberGuid;
-            NewOpacity = opacity;
+            newOpacity = opacity;
         }
 
         public void Update(float updatedOpacity)
         {
-            NewOpacity = updatedOpacity;
+            newOpacity = updatedOpacity;
         }
 
         public void Initialize(Document document)
@@ -27,18 +27,28 @@ namespace ChangeableDocument.Changes
             originalOpacity = member.Opacity;
         }
 
-        public IChangeInfo? ApplyTemporarily(Document target) => Apply(target);
+        public IChangeInfo? ApplyTemporarily(Document target) => Apply(target, out _);
 
-        public IChangeInfo? Apply(Document document)
+        public IChangeInfo? Apply(Document document, out bool ignoreInUndo)
         {
+            if (originalOpacity == newOpacity)
+            {
+                ignoreInUndo = true;
+                return null;
+            }
+
             var member = document.FindMemberOrThrow(memberGuid);
-            member.Opacity = NewOpacity;
+            member.Opacity = newOpacity;
 
+            ignoreInUndo = false;
             return new StructureMemberOpacity_ChangeInfo() { GuidValue = memberGuid };
         }
 
         public IChangeInfo? Revert(Document document)
         {
+            if (originalOpacity == newOpacity)
+                return null;
+
             var member = document.FindMemberOrThrow(memberGuid);
             member.Opacity = originalOpacity;
 

src/ChangeableDocument/Changes/StructureMemberProperties_Change.cs

@@ -1,58 +0,0 @@
-using ChangeableDocument.Changeables;
-using ChangeableDocument.ChangeInfos;
-
-namespace ChangeableDocument.Changes
-{
-    internal class StructureMemberProperties_Change : IChange
-    {
-        private Guid memberGuid;
-
-        private bool originalIsVisible;
-        public bool? NewIsVisible { get; init; } = null;
-
-        private string? originalName;
-        public string? NewName { get; init; } = null;
-
-        public StructureMemberProperties_Change(Guid memberGuid)
-        {
-            this.memberGuid = memberGuid;
-        }
-
-        public void Initialize(Document document)
-        {
-            var member = document.FindMemberOrThrow(memberGuid);
-            if (NewIsVisible != null) originalIsVisible = member.IsVisible;
-            if (NewName != null) originalName = member.Name;
-        }
-
-        public IChangeInfo? Apply(Document document)
-        {
-            var member = document.FindMemberOrThrow(memberGuid);
-            if (NewIsVisible != null) member.IsVisible = NewIsVisible.Value;
-            if (NewName != null) member.Name = NewName;
-
-            return new StructureMemberProperties_ChangeInfo()
-            {
-                GuidValue = member.GuidValue,
-                IsVisibleChanged = NewIsVisible != null,
-                NameChanged = NewName != null
-            };
-        }
-
-        public IChangeInfo? Revert(Document document)
-        {
-            var member = document.FindMemberOrThrow(memberGuid);
-            if (NewIsVisible != null) member.IsVisible = originalIsVisible;
-            if (NewName != null) member.Name = originalName!;
-
-            return new StructureMemberProperties_ChangeInfo()
-            {
-                GuidValue = member.GuidValue,
-                IsVisibleChanged = NewIsVisible != null,
-                NameChanged = NewName != null,
-            };
-        }
-
-        public void Dispose() { }
-    }
-}

src/ChangeableDocument/Changes/StructureMemberVisibility_Change.cs

@@ -0,0 +1,44 @@
+using ChangeableDocument.Changeables;
+using ChangeableDocument.ChangeInfos;
+
+namespace ChangeableDocument.Changes
+{
+    internal class StructureMemberVisibility_Change : IChange
+    {
+        private bool? originalIsVisible;
+        private bool newIsVisible;
+        private Guid targetMember;
+        public StructureMemberVisibility_Change(Guid targetMember, bool newIsVisible)
+        {
+            this.targetMember = targetMember;
+            this.newIsVisible = newIsVisible;
+        }
+
+        public void Initialize(Document target)
+        {
+            var member = target.FindMemberOrThrow(targetMember);
+            originalIsVisible = member.IsVisible;
+        }
+
+        public IChangeInfo? Apply(Document target, out bool ignoreInUndo)
+        {
+            // don't record layer/folder visibility changes - it's just more convenient this way
+            ignoreInUndo = true;
+            if (originalIsVisible == newIsVisible)
+                return null;
+            target.FindMemberOrThrow(targetMember).IsVisible = newIsVisible;
+
+            return new StructureMemberIsVisible_ChangeInfo() { GuidValue = targetMember };
+        }
+
+        public IChangeInfo? Revert(Document target)
+        {
+            if (originalIsVisible == null)
+                throw new Exception("No name to revert to");
+            target.FindMemberOrThrow(targetMember).IsVisible = originalIsVisible.Value;
+            return new StructureMemberIsVisible_ChangeInfo() { GuidValue = targetMember };
+        }
+
+        public void Dispose() { }
+    }
+}

src/ChangeableDocument/DocumentChangeTracker.cs

@@ -45,11 +45,52 @@ namespace ChangeableDocument
             if (redoStack.Count == 0)
                 return null;
             IChange change = redoStack.Pop();
-            var info = change.Apply(document);
+            var info = change.Apply(document, out bool _);
             undoStack.Push(change);
             return info;
         }
 
+        private IChangeInfo? ProcessMakeChangeAction(IMakeChangeAction act)
+        {
+            if (activeChange != null)
+                throw new Exception("Can't make a change while another change is active");
+            var change = act.CreateCorrespondingChange();
+            change.Initialize(document);
+            var info = change.Apply(document, out bool ignoreInUndo);
+            if (!ignoreInUndo)
+                AddToUndo(change);
+            else
+                change.Dispose();
+            return info;
+        }
+
+        private IChangeInfo? ProcessStartOrUpdateChangeAction(IStartOrUpdateChangeAction act)
+        {
+            if (activeChange == null)
+            {
+                activeChange = act.CreateCorrespondingChange();
+                activeChange.Initialize(document);
+            }
+            act.UpdateCorrespodingChange(activeChange);
+            return activeChange.ApplyTemporarily(document);
+        }
+
+        private IChangeInfo? ProcessEndChangeAction(IEndChangeAction act)
+        {
+            if (activeChange == null)
+                throw new Exception("Can't end a change: no changes are active");
+            if (!act.IsChangeTypeMatching(activeChange))
+                throw new Exception($"Trying to end a change via action of type {act.GetType()} while a change of type {activeChange.GetType()} is active");
+
+            var info = activeChange.Apply(document, out bool ignoreInUndo);
+            if (!ignoreInUndo)
+                AddToUndo(activeChange);
+            else
+                activeChange.Dispose();
+            activeChange = null;
+            return info;
+        }
+
         public async Task<List<IChangeInfo?>> ProcessActions(List<IAction> actions)
         {
             List<IChangeInfo?> result = await Task.Run(() =>
@@ -60,30 +101,13 @@ namespace ChangeableDocument
                     switch (action)
                     {
                         case IMakeChangeAction act:
-                            if (activeChange != null)
-                                throw new Exception("Can't make a change while another change is active");
-                            var change = act.CreateCorrespondingChange();
-                            change.Initialize(document);
-                            changeInfos.Add(change.Apply(document));
-                            AddToUndo(change);
+                            changeInfos.Add(ProcessMakeChangeAction(act));
                             break;
                         case IStartOrUpdateChangeAction act:
-                            if (activeChange == null)
-                            {
-                                activeChange = act.CreateCorrespondingChange();
-                                activeChange.Initialize(document);
-                            }
-                            act.UpdateCorrespodingChange(activeChange);
-                            changeInfos.Add(activeChange.ApplyTemporarily(document));
+                            changeInfos.Add(ProcessStartOrUpdateChangeAction(act));
                             break;
                         case IEndChangeAction act:
-                            if (activeChange == null)
-                                throw new Exception("Can't end a change: no changes are active");
-                            if (!act.IsChangeTypeMatching(activeChange))
-                                throw new Exception($"Trying to end a change via action of type {act.GetType()} while a change of type {activeChange.GetType()} is active");
-                            changeInfos.Add(activeChange.Apply(document));
-                            AddToUndo(activeChange);
-                            activeChange = null;
+                            changeInfos.Add(ProcessEndChangeAction(act));
                             break;
                         case Undo_Action act:
                             changeInfos.Add(Undo());

src/PixiEditorPrototype/Models/DocumentUpdater.cs

@@ -29,8 +29,11 @@ namespace PixiEditorPrototype.Models
                 case DeleteStructureMember_ChangeInfo info:
                     ProcessDeleteStructureMember(info);
                     break;
-                case StructureMemberProperties_ChangeInfo info:
-                    ProcessUpdateStructureMemberProperties(info);
+                case StructureMemberName_ChangeInfo info:
+                    ProcessUpdateStructureMemberName(info);
+                    break;
+                case StructureMemberIsVisible_ChangeInfo info:
+                    ProcessUpdateStructureMemberIsVisible(info);
                     break;
                 case StructureMemberOpacity_ChangeInfo info:
                     ProcessUpdateStructureMemberOpacity(info);
@@ -86,11 +89,16 @@ namespace PixiEditorPrototype.Models
             folderVM.Children.Remove(memberVM);
         }
 
-        private void ProcessUpdateStructureMemberProperties(StructureMemberProperties_ChangeInfo info)
+        private void ProcessUpdateStructureMemberIsVisible(StructureMemberIsVisible_ChangeInfo info)
+        {
+            var memberVM = doc.StructureHelper.FindOrThrow(info.GuidValue);
+            memberVM.RaisePropertyChanged(nameof(memberVM.IsVisible));
+        }
+
+        private void ProcessUpdateStructureMemberName(StructureMemberName_ChangeInfo info)
         {
             var memberVM = doc.StructureHelper.FindOrThrow(info.GuidValue);
-            if (info.NameChanged) memberVM.RaisePropertyChanged(nameof(memberVM.Name));
-            if (info.IsVisibleChanged) memberVM.RaisePropertyChanged(nameof(memberVM.IsVisible));
+            memberVM.RaisePropertyChanged(nameof(memberVM.Name));
         }
 
         private void ProcessUpdateStructureMemberOpacity(StructureMemberOpacity_ChangeInfo info)

src/PixiEditorPrototype/Models/Rendering/WriteableBitmapUpdater.cs

@@ -67,10 +67,8 @@ namespace PixiEditorPrototype.Models.Rendering
                         else
                             return null;
                         break;
-                    case StructureMemberProperties_ChangeInfo propertiesChangeInfo:
-                        if (!propertiesChangeInfo.IsVisibleChanged)
-                            break;
-                        var memberWithVisibility = tracker.Document.FindMemberOrThrow(propertiesChangeInfo.GuidValue);
+                    case StructureMemberIsVisible_ChangeInfo visibilityChangeInfo:
+                        var memberWithVisibility = tracker.Document.FindMemberOrThrow(visibilityChangeInfo.GuidValue);
                         if (memberWithVisibility is IReadOnlyLayer layerWithVisibility)
                             chunks.UnionWith(layerWithVisibility.ReadOnlyLayerImage.FindAllChunks());
                         else