Add method to update state mid chain.

This solves the 2 separate history entries for beat insert then note editing.

This method is inheritably unsafe to use due to possible desync in history / chart state if misused, but allows for much more possibilities for compressing history entries.

Author: Psycast

src/Editor/Editing.cpp

@@ -990,14 +990,12 @@ struct EditingImpl : public Editing {
             lastBoundStart = boundStart;
             rit++;
         }
-        gHistory->finishChain("[Recolorize] Beat Inserts");
+        gHistory->updateChain();
 
         // Step 2: Move Notes, and Tempo changes.
         // The selected notes will now have moved from the beat inserts, so the
         // relative location will be accurate. Now just adjust the BPM / Scroll
         // to offset the changes needed.
-        gHistory->startChain();
-
         NoteEdit notesEdit;
         SegmentEdit tempoEdit;
 
@@ -1067,7 +1065,7 @@ struct EditingImpl : public Editing {
 
         gNotes->modify(notesEdit, false);
         gTempo->modify(tempoEdit, false);
-        gHistory->finishChain("[Recolorize] Note Movement");
+        gHistory->finishChain("Recolorized Selected Notes");
     }
 
     /*

src/Editor/History.cpp

@@ -156,6 +156,9 @@ struct HistoryImpl : public History {
     EntryList myChain;
     int myOpenChains = 0;
 
+    int myChainEntries = 0;
+    int myAppliedChainEntries = 0;
+
     Vector<Callback> myCallbacks;
 
     // ================================================================================================
@@ -217,6 +220,7 @@ struct HistoryImpl : public History {
         Entry* entry = CreateEntry(id, data, size, targetChart, targetTempo);
         if (myOpenChains > 0) {
             myChain.add(entry);
+            myChainEntries++;
         } else {
             pushEntry(entry);
         }
@@ -346,17 +350,46 @@ struct HistoryImpl : public History {
     void finishChain(std::string msg) override {
         myOpenChains = max(0, myOpenChains - 1);
         if (myChain.head && myOpenChains == 0) {
+            bool partialApply = myAppliedChainEntries > 0;
+
             clearUnappliedEntries();
+            if (partialApply) updateChain();
 
             WriteStream stream;
             stream.write(myChain);
             stream.writeStr(msg);
 
             myChain.head = nullptr;
+            myChainEntries = 0;
+            myAppliedChainEntries = 0;
 
             auto entry =
                 CreateEntry(0, stream.data(), stream.size(), nullptr, nullptr);
-            pushEntry(entry);
+
+            if (partialApply) {
+                myEntries.add(entry);
+                ++myAppliedEntries;
+                ++myTotalEntries;
+            } else {
+                pushEntry(entry);
+            }
+        }
+    }
+
+    void updateChain() override {
+        if (myChain.head && myAppliedChainEntries < myChainEntries) {
+            clearUnappliedEntries();
+
+            Bindings bound = {mySimfile, nullptr, nullptr};
+            auto it = myEntries.head;
+            while (it) it = Advance(it, bound);
+
+            it = myChain.head;
+            for (int i = 0; i < myAppliedChainEntries && it; ++i) it = it->next;
+            for (; it; it = it->next) {
+                ApplyEntry(it, bound, false, false);
+                myAppliedChainEntries++;
+            }
         }
     }
 

src/Editor/History.h

@@ -33,6 +33,12 @@ struct History : public InputHandler {
     virtual void startChain() = 0;
     virtual void finishChain(std::string message) = 0;
 
+    /// Applies queued changes directly without a history entry.
+    /// This can cause a desync between changes and history if "finishChain()"
+    /// isn't called, but allows for chart state to be updated during a chain
+    /// instead of at the end of it.
+    virtual void updateChain() = 0;
+
     virtual void onFileOpen(Simfile* simfile) = 0;
     virtual void onFileClosed() = 0;
     virtual void onFileSaved() = 0;