Add undo and redo to the interface

Ctrl+Z undoes, Ctrl+Y and Ctrl+Shift+Z redo, caught in the capture
phase so a focused entry or spin never undoes only its own text; both
are in the header-bar menu too. The history keeps whole snapshots of
the project (currentProject() plus the immutable source list itself,
so stepping back never decodes again), compared by their JSON.
requestRender() notes every edit, and a step is committed once the
controls have been still for half a second. New and Open start the
history over once the project's images are in.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

CHANGELOG.md

@@ -4,6 +4,17 @@ Every release of Effector, newest first. The version lives in one place, the
 `project()` line of `CMakeLists.txt`, and each release is a `vX.Y.Z` tag on the
 commit that made it. The interface shows this file under Changelog in its menu.
 
+## [0.8.1] - 2026-09-26
+
+### Added
+- The Font of a text stage (and of a text style) is picked from the fonts
+  installed on this machine with a font chooser, rather than typed by name.
+  The command line still takes any family, as `--font-family "DejaVu Serif"`.
+- Undo and redo: Ctrl+Z steps back through the edits to the project (the
+  chain, params, styles, canvas, video settings, seed and images), and Ctrl+Y
+  or Ctrl+Shift+Z steps forward again; both are in the menu as well. A burst
+  of edits, like a spin held down or a word typed, is one step.
+
 ## [0.8.0] - 2026-09-26
 
 ### Added

CLAUDE.md

@@ -73,7 +73,9 @@ GUI or the parser — add a `ParamSpec` instead. A `Path` param names a file on
 disk; like a source path it is written relative to the project folder. A `Text`
 param is free-form text the user types, and a `Color` param is a colour written
 `#rrggbb` (`parseColor`/`formatColor`/`paramColor` in `src/core/params.hpp`),
-shown as a colour button in the interface. Values
+shown as a colour button in the interface. A `Font` param is a font family
+named as the machine names it ("DejaVu Serif"), a family-only font chooser in
+the interface and a plain string everywhere else. Values
 travel as `ParamValues` (a
 `map<string, variant<long,double,bool,string>>`), read back with
 `paramInt`/`paramDouble`/`paramBool`/`paramChoice`.
@@ -173,6 +175,16 @@ the `effector` application name on each entry; the GUI tests point
 `XDG_DATA_HOME` at a temporary folder so they never touch the user's list. Opening one replaces the sources, so a decode still in flight
 is discarded rather than mixed into the new project (`dropLoadedImages_`).
 
+Undo and redo (Ctrl+Z, Ctrl+Y / Ctrl+Shift+Z, caught in the capture phase so
+an entry never undoes its own text instead) keep whole snapshots of the
+project: `captureState` is `currentProject()` plus the `sources_` list itself,
+so stepping back never decodes again, compared by `projectToJson`. There is
+nothing to call per edit: `requestRender()` calls `noteChange()`, which commits
+a step once the controls have been still for `kHistoryPause`; an edit that
+renders nothing (renaming a style) calls `noteChange()` itself. New and Open
+start the history over, after the project's images are in
+(`historyAfterLoad_`).
+
 ### Video projects
 
 A project is a still or a clip: `VideoSettings` (`src/core/video.hpp`: enabled,

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.20)
-project(effector VERSION 0.8.0 LANGUAGES CXX)
+project(effector VERSION 0.8.1 LANGUAGES CXX)
 
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)

packaging/arch/PKGBUILD

@@ -2,7 +2,7 @@
 # so pkgver must follow the project() line of CMakeLists.txt (the version core
 # test checks it). From this folder: makepkg -si
 pkgname=effector
-pkgver=0.8.0
+pkgver=0.8.1
 pkgrel=1
 pkgdesc='Image effects app: a GTK4 interface and a headless CLI over pluggable effects'
 arch=('x86_64' 'aarch64')

src/cli/options.cpp

@@ -182,6 +182,7 @@ Options parseOptions(int argc, char** argv) {
                 }
                 case ParamSpec::Type::Path:
                 case ParamSpec::Type::Text:
+                case ParamSpec::Type::Font:
                     options.params[spec->key] = requireValue(argc, argv, i, arg);
                     break;
                 case ParamSpec::Type::Color: {

src/core/params.cpp

@@ -100,6 +100,17 @@ ParamSpec ParamSpec::makeColor(std::string key, std::string label, std::string d
     return spec;
 }
 
+ParamSpec ParamSpec::makeFont(std::string key, std::string label, std::string defaultFamily,
+                              std::string help) {
+    ParamSpec spec;
+    spec.type = Type::Font;
+    spec.key = std::move(key);
+    spec.label = std::move(label);
+    spec.help = std::move(help);
+    spec.defaultChoice = std::move(defaultFamily);
+    return spec;
+}
+
 namespace {
 
 const ParamValue* find(const ParamValues& values, const std::string& key) {
@@ -121,6 +132,7 @@ ParamValue paramDefault(const ParamSpec& spec) {
         case ParamSpec::Type::Path:
         case ParamSpec::Type::Text:
         case ParamSpec::Type::Color:
+        case ParamSpec::Type::Font:
             break;
     }
     return spec.defaultChoice;

src/core/params.hpp

@@ -11,7 +11,7 @@ namespace effector {
 // Declarative description of one effect knob. The GUI turns these into widgets
 // and the CLI turns them into flags, so neither knows about any effect.
 struct ParamSpec {
-    enum class Type { Int, Double, Bool, Choice, Path, Text, Color };
+    enum class Type { Int, Double, Bool, Choice, Path, Text, Color, Font };
 
     Type type = Type::Int;
     std::string key;
@@ -56,6 +56,11 @@ struct ParamSpec {
     // spelling as a flag value.
     static ParamSpec makeColor(std::string key, std::string label, std::string defaultColor,
                                std::string help = {});
+    // A font family as it is named on this machine ("Sans", "DejaVu Serif"):
+    // a font chooser in the interface, a flag taking any string on the
+    // command line. A family the machine lacks is kept as written.
+    static ParamSpec makeFont(std::string key, std::string label, std::string defaultFamily,
+                              std::string help = {});
 };
 
 using ParamValue = std::variant<long, double, bool, std::string>;

src/core/project.cpp

@@ -366,6 +366,7 @@ void writeParams(std::ostream& out, const std::vector<ParamSpec>& specs, const P
                 break;
             case ParamSpec::Type::Choice:
             case ParamSpec::Type::Text:
+            case ParamSpec::Type::Font:
                 out << quote(paramText(values, spec.key, spec.defaultChoice));
                 break;
             case ParamSpec::Type::Color: {
@@ -412,6 +413,7 @@ void readParams(const std::vector<ParamSpec>& specs, const Json& params,
                 }
                 break;
             case ParamSpec::Type::Text:
+            case ParamSpec::Type::Font:
                 if (value->kind == Json::Kind::String) values[spec.key] = value->text;
                 break;
             case ParamSpec::Type::Color: {

src/effects/text.cpp

@@ -16,7 +16,7 @@ const std::vector<ParamSpec>& TextEffect::params() const {
     static const std::vector<ParamSpec> specs = {
         ParamSpec::makeText("text", "Text", "Effector",
                             "What to write; a line break starts a new line."),
-        ParamSpec::makeText("font_family", "Font", "Sans",
+        ParamSpec::makeFont("font_family", "Font", "Sans",
                             "Font family, as it is named on this machine: Sans, Serif, Monospace, "
                             "\"DejaVu Serif\", ...")
             .styled(),

src/gui/window.cpp

@@ -29,6 +29,11 @@ const char* const kImagePatterns[] = {"*.png",  "*.jpg",  "*.jpeg", "*.webp", "*
 const char* const kRecentApp = "effector";
 const std::size_t kRecentCount = 10;
 
+// Undo keeps this many steps, and an edit becomes one once the controls have
+// been still this long (ms): a spin held down or a word typed is one step.
+const std::size_t kHistoryDepth = 100;
+constexpr unsigned kHistoryPause = 500;
+
 Glib::RefPtr<Gio::ListStore<Gtk::FileFilter>> projectFilters() {
     auto filter = Gtk::FileFilter::create();
     filter->set_name("Effector projects");
@@ -116,13 +121,21 @@ EffectorWindow::EffectorWindow(const Options& initial) {
 
     renderDone_.connect(sigc::mem_fun(*this, &EffectorWindow::onRenderFinished));
     loadProgress_.connect(sigc::mem_fun(*this, &EffectorWindow::onLoadProgress));
-    loadFinished_.connect(sigc::mem_fun(*this, &EffectorWindow::onLoadFinished));
+    loadFinished_.connect([this] {
+        onLoadFinished();
+        if (historyAfterLoad_ && !loading_) {
+            historyAfterLoad_ = false;
+            resetHistory();
+        }
+    });
     clipProgress_.connect(sigc::mem_fun(*this, &EffectorWindow::onClipProgress));
     exportProgress_.connect(sigc::mem_fun(*this, &EffectorWindow::onExportProgress));
     exportDone_.connect(sigc::mem_fun(*this, &EffectorWindow::onExportFinished));
 
     buildUi();
     applyInitial(initial);
+    historyAfterLoad_ = loading_;
+    resetHistory();
 
     suspendRender_ = false;
     if (loading_) {
@@ -136,6 +149,7 @@ EffectorWindow::EffectorWindow(const Options& initial) {
 
 EffectorWindow::~EffectorWindow() {
     debounce_.disconnect();
+    historyCommit_.disconnect();
     chainSplitFit_.disconnect();
     recentChanged_.disconnect();
     loadWindowDelay_.disconnect();
@@ -594,6 +608,11 @@ Gtk::Widget& EffectorWindow::buildVideoSection() {
     videoQualityDrop_.set_selected(standard);
     videoQualityDrop_.set_hexpand(true);
     videoQualityDrop_.set_tooltip_text(qualityTooltip);
+    // Only the export hears of the quality, so it asks for no render; it is
+    // still part of the project, and of its history.
+    videoQualityDrop_.property_selected().signal_changed().connect([this] {
+        if (!suspendVideoSync_) noteChange();
+    });
     auto* qualityLabel = Gtk::make_managed<Gtk::Label>("Quality");
     qualityLabel->set_xalign(0.0F);
     grid->attach(*qualityLabel, 0, 2);
@@ -995,6 +1014,21 @@ void EffectorWindow::buildParamWidgets() {
                 widget = std::move(button);
                 break;
             }
+            case ParamSpec::Type::Font: {
+                // Only the family is chosen here: weight, slant and size are
+                // params of their own.
+                auto button = std::make_unique<Gtk::FontDialogButton>(Gtk::FontDialog::create());
+                button->set_halign(Gtk::Align::START);
+                button->set_level(Gtk::FontLevel::FAMILY);
+                button->set_use_font(true);
+                Pango::FontDescription font;
+                font.set_family(paramText(values, spec.key, spec.defaultChoice));
+                button->set_font_desc(font);
+                button->property_font_desc().signal_changed().connect(
+                    sigc::mem_fun(*this, &EffectorWindow::onParamChanged));
+                widget = std::move(button);
+                break;
+            }
             case ParamSpec::Type::Choice: {
                 std::vector<Glib::ustring> choices(spec.choices.begin(), spec.choices.end());
                 auto dropdown = std::make_unique<Gtk::DropDown>();
@@ -1051,6 +1085,14 @@ ParamValues EffectorWindow::paramValues() const {
                 values[entry.spec.key] = formatColor(rgb);
                 break;
             }
+            case ParamSpec::Type::Font: {
+                // A family the machine lacks keeps its name, so a project
+                // from elsewhere still says which font it wanted.
+                const auto family =
+                    static_cast<Gtk::FontDialogButton*>(entry.widget)->get_font_desc().get_family();
+                if (!family.empty()) values[entry.spec.key] = std::string(family);
+                break;
+            }
             case ParamSpec::Type::Choice: {
                 const auto index = static_cast<Gtk::DropDown*>(entry.widget)->get_selected();
                 if (index < entry.spec.choices.size()) values[entry.spec.key] = entry.spec.choices[index];
@@ -1222,6 +1264,7 @@ void EffectorWindow::onRenameStyle() {
             if (stage.effect->styleKind() == kind && stage.style == was) stage.style = name;
         }
         buildParamWidgets();
+        noteChange();  // the picture is the same, so no render asks for it
     });
 }
 
@@ -2191,6 +2234,7 @@ void EffectorWindow::onRecreate() {
     seed_ = Rng::randomSeed();
     seedEntry_.set_text(std::to_string(seed_));
     if (!canRender()) {
+        noteChange();
         showError(missingText());
         return;
     }
@@ -2227,6 +2271,9 @@ void EffectorWindow::showPlaceholder() {
 }
 
 void EffectorWindow::requestRender() {
+    // Every edit of the project asks for a render, so this is where the
+    // history hears of them.
+    noteChange();
     if (suspendRender_) return;
     if (!canRender()) {
         showPlaceholder();
@@ -2414,10 +2461,16 @@ Gtk::Widget& EffectorWindow::buildMainMenu() {
                               });
     // Never enabled: it only stands in for an empty list.
     add_action("no-recent")->set_enabled(false);
+    undoAction_ = add_action("undo", sigc::mem_fun(*this, &EffectorWindow::undo));
+    redoAction_ = add_action("redo", sigc::mem_fun(*this, &EffectorWindow::redo));
     add_action("show-changelog", sigc::mem_fun(*this, &EffectorWindow::showChangelog));
     add_action("about", sigc::mem_fun(*this, &EffectorWindow::showAbout));
 
     auto menu = Gio::Menu::create();
+    auto edit = Gio::Menu::create();
+    edit->append("Undo", "win.undo");
+    edit->append("Redo", "win.redo");
+    menu->append_section(edit);
     auto open = Gio::Menu::create();
     open->append("New Project", "win.new-project");
     open->append("Open Project…", "win.open-project");
@@ -2453,6 +2506,20 @@ Gtk::Widget& EffectorWindow::buildMainMenu() {
     }
     add_controller(shortcuts);
 
+    // Undo and redo are caught before the focused widget sees them: an entry
+    // would otherwise undo its own text, and a spin button only the digits
+    // typed into it, rather than the step the project took.
+    auto history = Gtk::ShortcutController::create();
+    history->set_propagation_phase(Gtk::PropagationPhase::CAPTURE);
+    const Accel historyAccels[] = {{"<Control>z", "win.undo"},
+                                   {"<Control>y", "win.redo"},
+                                   {"<Control><Shift>z", "win.redo"}};
+    for (const Accel& accel : historyAccels) {
+        history->add_shortcut(Gtk::Shortcut::create(
+            Gtk::ShortcutTrigger::parse_string(accel.keys), Gtk::NamedAction::create(accel.action)));
+    }
+    add_controller(history);
+
     return *Gtk::make_managed<Gtk::PopoverMenu>(menu);
 }
 
@@ -2502,6 +2569,8 @@ void EffectorWindow::applyProject(const Project& project, const std::string& pat
     } else {
         addPaths(project.sources);  // renders once the images are decoded
     }
+    historyAfterLoad_ = loading_;
+    resetHistory();
 }
 
 void EffectorWindow::clearSources() {
@@ -2810,6 +2879,123 @@ void EffectorWindow::updateTitle() {
     set_title(std::filesystem::path(projectPath_).stem().string() + " — Effector");
 }
 
+// -------------------------------------------------------------- history ---
+
+EffectorWindow::HistoryState EffectorWindow::captureState() const {
+    HistoryState state;
+    state.project = currentProject();
+    state.json = projectToJson(state.project);
+    state.sources = sources_;
+    state.refusedSources = refusedSources_;
+    state.selectedStage = selectedStage_;
+    return state;
+}
+
+// Puts a step back the way a project is opened, but with the images already
+// in hand: the source list is the very one the step held.
+void EffectorWindow::restoreState(const HistoryState& state) {
+    suspendHistory_ = true;
+    suspendRender_ = true;
+    closeStyleWindow();  // it may name a style the step does not hold
+    const bool wasVideo = isVideo();
+    const Project& project = state.project;
+
+    stages_ = project.stages;
+    styles_ = project.styles;
+    selectedStage_ =
+        stages_.empty() ? 0 : std::clamp(state.selectedStage, 0, static_cast<int>(stages_.size()) - 1);
+    widthSpin_.set_value(project.width);
+    heightSpin_.set_value(project.height);
+    setCanvasFormat(project.format, project.dpi);
+    setVideoSettings(project.video);  // rebuilds the chain rows and the params
+    seed_ = project.seed.value_or(seed_);
+    seedEntry_.set_text(std::to_string(seed_));
+
+    if (state.sources != sources_) {
+        while (auto* row = sourceList_.get_row_at_index(0)) sourceList_.remove(*row);
+        sources_ = state.sources;
+        for (const auto& image : *sources_) appendSourceRow(image.path());
+        updateSourcesLabel();
+    }
+    refusedSources_ = state.refusedSources;
+
+    if (isVideo() != wasVideo) {
+        // What is on screen is the other kind of result, as in onVideoToggled.
+        result_ = Image();
+        saveButton_.set_sensitive(false);
+    }
+    clearError();
+    suspendRender_ = false;
+    requestRender();
+    suspendHistory_ = false;
+}
+
+void EffectorWindow::noteChange() {
+    if (suspendHistory_) return;
+    // Something is waiting to become a step, so there is something to undo
+    // even before the timer runs.
+    if (undoAction_) undoAction_->set_enabled(true);
+    historyCommit_.disconnect();
+    historyCommit_ = Glib::signal_timeout().connect(
+        [this] {
+            commitHistory();
+            return false;
+        },
+        kHistoryPause);
+}
+
+void EffectorWindow::commitHistory() {
+    historyCommit_.disconnect();
+    HistoryState now = captureState();
+    if (now.json != committed_.json) {
+        // The step remembers the stage being worked on as it was left, so
+        // undoing it lands on that stage again.
+        committed_.selectedStage = selectedStage_;
+        undo_.push_back(std::move(committed_));
+        if (undo_.size() > kHistoryDepth) undo_.erase(undo_.begin());
+        redo_.clear();
+    }
+    committed_ = std::move(now);
+    updateHistoryActions();
+}
+
+void EffectorWindow::resetHistory() {
+    historyCommit_.disconnect();
+    undo_.clear();
+    redo_.clear();
+    committed_ = captureState();
+    updateHistoryActions();
+}
+
+void EffectorWindow::undo() {
+    commitHistory();  // an edit still waiting on the timer is the step undone
+    if (undo_.empty()) return;
+    committed_.selectedStage = selectedStage_;
+    redo_.push_back(std::move(committed_));
+    const HistoryState previous = std::move(undo_.back());
+    undo_.pop_back();
+    restoreState(previous);
+    committed_ = captureState();
+    updateHistoryActions();
+}
+
+void EffectorWindow::redo() {
+    commitHistory();  // a fresh edit clears the redo list, as it should
+    if (redo_.empty()) return;
+    committed_.selectedStage = selectedStage_;
+    undo_.push_back(std::move(committed_));
+    const HistoryState next = std::move(redo_.back());
+    redo_.pop_back();
+    restoreState(next);
+    committed_ = captureState();
+    updateHistoryActions();
+}
+
+void EffectorWindow::updateHistoryActions() {
+    if (undoAction_) undoAction_->set_enabled(!undo_.empty());
+    if (redoAction_) redoAction_->set_enabled(!redo_.empty());
+}
+
 // --------------------------------------------------------------- saving ---
 
 void EffectorWindow::onSave() {

src/gui/window.hpp

@@ -161,6 +161,26 @@ private:
     void writeProject(const std::string& path);
     void updateTitle();
 
+    // Undo and redo. The history is a list of whole snapshots of the project,
+    // taken a moment after the edits stop, so a spin held down or a word typed
+    // is one step rather than one per tick. The sources ride along as the
+    // immutable list they already are, so stepping back never decodes again.
+    struct HistoryState {
+        std::string json;  // what the step is compared by
+        Project project;
+        std::shared_ptr<const std::vector<Image>> sources;
+        std::vector<std::string> refusedSources;
+        int selectedStage = 0;
+    };
+    HistoryState captureState() const;
+    void restoreState(const HistoryState& state);
+    void noteChange();     // coalesced: restarts the short history timer
+    void commitHistory();  // the current project becomes a step, if it changed
+    void resetHistory();   // a new or opened project starts with none
+    void undo();
+    void redo();
+    void updateHistoryActions();
+
     void onParamChanged();
     // The chooser behind a Path param. The chosen file goes straight into the
     // stage's values rather than into the widget, which may well have been
@@ -213,6 +233,17 @@ private:
     sigc::connection recentChanged_;  // the recent list outlives the window
     bool suspendRender_ = true;
 
+    std::vector<HistoryState> undo_;
+    std::vector<HistoryState> redo_;
+    HistoryState committed_;       // the project as the last step left it
+    sigc::connection historyCommit_;
+    bool suspendHistory_ = false;  // set while a step is being put back
+    // The sources of a project being opened are not a step of their own: the
+    // history starts over once they are in.
+    bool historyAfterLoad_ = false;
+    Glib::RefPtr<Gio::SimpleAction> undoAction_;
+    Glib::RefPtr<Gio::SimpleAction> redoAction_;
+
     // Source loading. Decoding a batch of large photographs takes seconds, so
     // it runs off the main thread and reports into a small progress window.
     std::thread loader_;

tests/gui_tests.cpp

@@ -591,6 +591,169 @@ void testVideo(Gtk::Window& window, const std::filesystem::path& dir) {
     stack->set_visible_child("chain");
 }
 
+// A font param is a font chooser showing the family, and the family picked
+// there is what the stage renders with and what the project saves.
+void testFont(Gtk::Window& window, const std::filesystem::path& dir) {
+    std::cout << "font\n";
+    std::filesystem::create_directories(dir);
+    const auto path = dir / "lettering.json";
+    effector::Project project;
+    effector::ChainStage stage{effector::effectByName("text"), {}};
+    stage.values["font_family"] = std::string("Serif");
+    project.stages.push_back(stage);
+    effector::saveProject(path.string(), project);
+    window.activate_action("win.open-recent",
+                           Glib::Variant<Glib::ustring>::create(Glib::filename_to_uri(path.string())));
+    pump(300);
+
+    auto* chainList = named<Gtk::ListBox>(window, "chain-list");
+    if (chainList != nullptr && chainList->get_row_at_index(0) != nullptr) {
+        chainList->select_row(*chainList->get_row_at_index(0));
+    }
+    pump(100);
+    std::vector<Gtk::FontDialogButton*> buttons;
+    collect<Gtk::FontDialogButton>(window, [](Gtk::FontDialogButton& b) { return b.is_drawable(); },
+                                   buttons);
+    check(buttons.size() == 1, "the text stage picks its font with a font chooser");
+    if (buttons.size() != 1) return;
+    auto* button = buttons.front();
+    check(button->get_level() == Gtk::FontLevel::FAMILY,
+          "which chooses only the family, the weight and size being params of their own");
+    check(button->get_font_desc().get_family() == "Serif", "and shows the family saved");
+
+    Pango::FontDescription mono;
+    mono.set_family("Monospace");
+    button->set_font_desc(mono);
+    pump(100);
+    window.activate_action("win.save-project");
+    pump(100);
+    const auto saved = effector::loadProject(path.string());
+    check(saved.stages.size() == 1 &&
+              effector::paramText(saved.stages[0].values, "font_family", "") == "Monospace",
+          "a family chosen there is saved with the project");
+}
+
+bool actionEnabled(Gtk::Window& window, const std::string& name) {
+    auto action = dynamic_cast<Gtk::ApplicationWindow&>(window).lookup_action(name);
+    return action && action->get_enabled();
+}
+
+// Whether the window catches `keys` for `action` before the focused widget.
+bool capturesShortcut(Gtk::Window& window, const std::string& keys, const std::string& action) {
+    auto controllers = window.observe_controllers();
+    for (guint i = 0; i < controllers->get_n_items(); ++i) {
+        auto* controller = GTK_EVENT_CONTROLLER(g_list_model_get_item(controllers->gobj(), i));
+        const bool capture = gtk_event_controller_get_propagation_phase(controller) == GTK_PHASE_CAPTURE;
+        if (GTK_IS_SHORTCUT_CONTROLLER(controller) && capture) {
+            auto* list = G_LIST_MODEL(controller);
+            for (guint j = 0; j < g_list_model_get_n_items(list); ++j) {
+                auto* shortcut = GTK_SHORTCUT(g_list_model_get_item(list, j));
+                char* trigger = gtk_shortcut_trigger_to_string(gtk_shortcut_get_trigger(shortcut));
+                auto* named = gtk_shortcut_get_action(shortcut);
+                const bool match = trigger == keys && GTK_IS_NAMED_ACTION(named) &&
+                                   action == gtk_named_action_get_action_name(GTK_NAMED_ACTION(named));
+                g_free(trigger);
+                g_object_unref(shortcut);
+                if (match) {
+                    g_object_unref(controller);
+                    return true;
+                }
+            }
+        }
+        g_object_unref(controller);
+    }
+    return false;
+}
+
+void testHistory(Gtk::Window& window, const std::filesystem::path& dir) {
+    std::cout << "undo and redo\n";
+    auto* chainList = named<Gtk::ListBox>(window, "chain-list");
+    auto* add = named<Gtk::MenuButton>(window, "add-effect");
+    if (chainList == nullptr || add == nullptr) return;
+
+    check(capturesShortcut(window, "<Control>z", "win.undo") &&
+              capturesShortcut(window, "<Control>y", "win.redo") &&
+              capturesShortcut(window, "<Shift><Control>z", "win.redo"),
+          "Ctrl+Z undoes, Ctrl+Y and Ctrl+Shift+Z redo, ahead of the focused widget");
+
+    window.activate_action("win.new-project");
+    pump(700);
+    check(!actionEnabled(window, "undo") && !actionEnabled(window, "redo"),
+          "a new project has nothing to undo or redo");
+
+    addFromMenu(*add, "Blur");
+    pump(700);
+    addFromMenu(*add, "Scanlines");
+    pump(700);
+    check(rowCount(*chainList) == 2 && actionEnabled(window, "undo"), "two stages added");
+
+    window.activate_action("win.undo");
+    pump();
+    check(rowCount(*chainList) == 1 && rowTitle(*chainList, 0) == "1. Blur",
+          "undo takes the last stage off");
+    check(actionEnabled(window, "redo"), "and it can be redone");
+    window.activate_action("win.undo");
+    pump();
+    check(rowCount(*chainList) == 0 && !actionEnabled(window, "undo"), "undo again empties the chain");
+
+    window.activate_action("win.redo");
+    pump();
+    window.activate_action("win.redo");
+    pump();
+    check(rowCount(*chainList) == 2 && rowTitle(*chainList, 1) == "2. Scanlines" &&
+              !actionEnabled(window, "redo"),
+          "redo puts both back");
+
+    // Undone straight away, before the edit has settled into a step.
+    addFromMenu(*add, "Blur");
+    check(actionEnabled(window, "undo"), "an edit can be undone at once");
+    window.activate_action("win.undo");
+    pump();
+    check(rowCount(*chainList) == 2, "and undoing it takes that edit back");
+
+    window.activate_action("win.undo");
+    pump();
+    addFromMenu(*add, "Blur");
+    pump(700);
+    check(!actionEnabled(window, "redo"), "a new edit after an undo drops what could be redone");
+
+    // The images of an opened project arrive after it, from the decoder, and
+    // are part of it rather than a step to undo.
+    std::filesystem::create_directories(dir);
+    const auto source = dir / "source.png";
+    effector::Image(64, 64).save(source.string());
+    effector::Project project;
+    project.sources.push_back(source.string());
+    project.stages.push_back({effector::effectByName("scanlines"), {}});
+    const auto path = dir / "history.json";
+    effector::saveProject(path.string(), project);
+    window.activate_action("win.open-recent",
+                           Glib::Variant<Glib::ustring>::create(Glib::filename_to_uri(path.string())));
+    pump(1000);
+    auto* sources = named<Gtk::Box>(window, "sources");
+    auto lists = sources != nullptr ? all<Gtk::ListBox>(*sources) : std::vector<Gtk::ListBox*>{};
+    auto* sourceList = lists.empty() ? nullptr : lists.front();
+    check(sourceList != nullptr && rowCount(*sourceList) == 1 && !actionEnabled(window, "undo"),
+          "opening a project with images leaves nothing to undo");
+    if (sourceList == nullptr || rowCount(*sourceList) != 1) return;
+
+    // Removing an image is undone with the image still in hand.
+    auto* stack = all<Gtk::Stack>(window).front();
+    stack->set_visible_child("setup");
+    pump();
+    const auto removes = all<Gtk::Button>(*sourceList->get_row_at_index(0));
+    if (!removes.empty()) press(*removes.front());
+    pump(700);
+    check(rowCount(*sourceList) == 0, "an image removed");
+    window.activate_action("win.undo");
+    pump();
+    check(rowCount(*sourceList) == 1, "comes back with undo");
+    stack->set_visible_child("chain");
+
+    window.activate_action("win.new-project");
+    pump(700);
+}
+
 // A project whose images will not fit is refused before any is decoded, and
 // saving it then must not quietly drop them from the file.
 void testMemoryGuard(Gtk::Window& window, const std::filesystem::path& dir) {
@@ -658,6 +821,8 @@ int main(int argc, char** argv) {
         testHelpWindows(*window);
         testRecentProjects(*window, dataDir / "projects");
         testVideo(*window, dataDir / "video");
+        testFont(*window, dataDir / "font");
+        testHistory(*window, dataDir / "history");
         testMemoryGuard(*window, dataDir / "memory");
         app->remove_window(*window);
     });