From 46f309337afbfcbf86640e0664abc56d9e02e861 Mon Sep 17 00:00:00 2001
From: David Smith <david@smithers.co.za>
Date: Wed, 14 Oct 2026 12:01:13 +0200
Subject: [PATCH 1/4] feat(markup): a list column can draw a button in each row

A `<column type="button" items="{Captions}" onclick="{Act}">` draws each
row's caption on a button with the face and border of a markup `<button>`
(the theme's colours on a themed window), lighter while hovered and darker
while pressed. It fires the column's onclick with the row index when the
left button comes up over the button it went down on, and never selects
the row. An empty caption draws no button. Optional `buttonw`/`buttonh`
size the button, centred in its cell and never larger than it; only the
button itself takes clicks.

Claude-Session: https://claude.ai/code/session_01Lm9T9oP2Hi5FEjwsLmXeyN
---
 docs/plugin-ui-markup.md                      |  23 +-
 src/AcDream.App/UI/MarkupDocument.cs          |  19 +-
 src/AcDream.App/UI/PluginMarkupTheme.cs       |   3 +
 src/AcDream.App/UI/UiMarkupList.cs            | 177 +++++++++
 src/AcDream.App/UI/UiMarkupListColumn.cs      |  33 +-
 src/AcDream.App/UI/UiPointerState.cs          |   4 +
 .../UI/ListButtonColumnTests.cs               | 337 ++++++++++++++++++
 7 files changed, 590 insertions(+), 6 deletions(-)
 create mode 100644 src/AcDream.App/UI/UiPointerState.cs
 create mode 100644 tests/AcDream.App.Tests/UI/ListButtonColumnTests.cs

diff --git a/docs/plugin-ui-markup.md b/docs/plugin-ui-markup.md
index 7d0dd3f16..b21a9a858 100644
--- a/docs/plugin-ui-markup.md
+++ b/docs/plugin-ui-markup.md
@@ -313,13 +313,14 @@ The two forms cannot be mixed on one list.
       selected="{SelectedMonster}" onchange="{SelectMonster}">
   <column type="check" width="20"  values="{MonsterFlags}" onchange="{ToggleFlag}"/>
   <column type="text"  width="127" items="{MonsterNames}"  onclick="{PingMonster}"/>
-  <column type="icon"  width="*"   iconkind="did" values="{MonsterIcons}" onclick="{MoveUp}"/>
+  <column type="icon"  width="20"  iconkind="did" values="{MonsterIcons}" onclick="{MoveUp}"/>
+  <column type="button" width="*"  items="{MonsterActions}" onclick="{ActOnMonster}"/>
 </list>
 ```
 
 | Attribute | Column type | Required | Binding |
 |---|---|---|---|
-| `type` | all | yes | `text`, `check`, or `icon` |
+| `type` | all | yes | `text`, `check`, `icon`, or `button` |
 | `width` | all | see below | pixels, or `*` for auto |
 | `items` | `text` | yes | `IReadOnlyList<string>` |
 | `colors` | `text` | no | `IReadOnlyList<uint>` or `<int>`, `0xRRGGBB` per row |
@@ -329,6 +330,9 @@ The two forms cannot be mixed on one list.
 | `values` | `icon` | yes | `IReadOnlyList<uint>` or `<int>` |
 | `iconkind` | `icon` | no | `did` (default), `spell`, or `item` |
 | `onclick` | `icon` | yes | `Action<int>` with the row index |
+| `items` | `button` | yes | `IReadOnlyList<string>`, each row's caption; an empty caption draws no button |
+| `onclick` | `button` | yes | `Action<int>` with the row index; the click does not select the row |
+| `buttonw`, `buttonh` | `button` | no | pixels; the button's size, centred in its cell (default: the whole cell) |
 
 Widths: `*` shares the remaining width equally with every other `*` column.
 The last column is always automatic; it takes the whole remainder unless
@@ -336,12 +340,23 @@ another column is also `*`. Every other column needs a positive `width` or
 `*`. Columns that would overflow the list are clamped and later ones draw
 nothing. Remainder pixels go to the last sharing column.
 
-Rows: the row count is the longest bound column. A `text` or `icon` cell past
-its own column's data draws nothing; a `check` cell draws unchecked. A click
+Rows: the row count is the longest bound column. A `text`, `icon` or `button`
+cell past its own column's data draws nothing; a `check` cell draws unchecked. A click
 in a `text` column without `onclick` selects the row and fires the list's
 `onchange`; any other click fires the column's own callback and leaves the
 selection alone. A click past a column's own data does nothing.
 
+A `button` cell is drawn as a button one pixel inside its cell, or at
+`buttonw` by `buttonh` centred in the cell (never larger than the cell; set
+either alone to size only that side), with its caption centred. It has the
+face and border of a markup `<button>`, in the theme's colours on a themed
+window, lighter while hovered and darker while pressed. It fires like a
+`<button>`, when the left button comes up over the button it went down on, so
+a press dragged off the button cancels it; a click beside a smaller button
+does nothing. A cell with an empty caption is not a button and ignores clicks.
+On a host older than button columns, a `type="button"` column fails the build
+of its window as an unknown type.
+
 There is no header row; place `<label>` elements above the list. A `check`
 cell draws the same lamp glyph as `<toggle>`. When rows overflow the list's
 height it reserves a 16-pixel scrollbar at its right edge, drawn with the
diff --git a/src/AcDream.App/UI/MarkupDocument.cs b/src/AcDream.App/UI/MarkupDocument.cs
index 1ebc1fb41..291e00408 100644
--- a/src/AcDream.App/UI/MarkupDocument.cs
+++ b/src/AcDream.App/UI/MarkupDocument.cs
@@ -1009,12 +1009,29 @@ private static UiMarkupListColumn BuildListColumn(
                     : null;
                 return UiMarkupListColumn.Icon(width, valuesSource, resolve, onClick, isAutoWidth);
             }
+            case "button":
+            {
+                var captionSource = BindStringList(
+                    (string?)columnEl.Attribute("items"), binding, ColumnContext(index, "button", "items"));
+                var onClick = BindRequiredIntAction(
+                    (string?)columnEl.Attribute("onclick"), binding, ColumnContext(index, "button", "onclick"));
+                return UiMarkupListColumn.Button(width, captionSource, onClick, isAutoWidth,
+                    ButtonSize(columnEl, "buttonw", index), ButtonSize(columnEl, "buttonh", index));
+            }
             default:
                 throw new FormatException(
-                    $"column[{index}] has unknown type=\"{type}\" (expected text, check, or icon)");
+                    $"column[{index}] has unknown type=\"{type}\" (expected text, check, icon, or button)");
         }
     }
 
+    private static float ButtonSize(XElement columnEl, string attribute, int index)
+    {
+        float size = FOr(columnEl, attribute, 0f);
+        if (size < 0f)
+            throw new FormatException($"{ColumnContext(index, "button", attribute)} must not be negative");
+        return size;
+    }
+
     private static string ColumnContext(int index, string type, string attribute) =>
         $"column[{index}] type=\"{type}\" {attribute}";
 
diff --git a/src/AcDream.App/UI/PluginMarkupTheme.cs b/src/AcDream.App/UI/PluginMarkupTheme.cs
index 41fbc226d..8e42bb0d4 100644
--- a/src/AcDream.App/UI/PluginMarkupTheme.cs
+++ b/src/AcDream.App/UI/PluginMarkupTheme.cs
@@ -91,10 +91,13 @@ void Bind(Func<UiDatFont?> get, Action<UiDatFont?> set)
             case UiMarkupList list:
                 var lb = list.BackgroundColor; var le = list.BorderColor; var lt = list.TextColor;
                 var ls = list.SelectedColor; var band = list.SelectionBandEnabled;
+                var lbf = list.ButtonColor; var lbe = list.ButtonBorderColor;
                 panel.AddThemeAction(p => {
                     list.ThemePalette = p; list.BackgroundColor = p?.Field ?? lb;
                     list.BorderColor = p?.Border ?? le; list.TextColor = p?.Text ?? lt;
                     list.SelectedColor = p?.Selected ?? ls; list.SelectionBandEnabled = p is not null || band;
+                    // The list's own ground is the field colour, so its buttons take the window's.
+                    list.ButtonColor = p?.Background ?? lbf; list.ButtonBorderColor = p?.Border ?? lbe;
                 });
                 break;
             case UiScrollbar scroll:
diff --git a/src/AcDream.App/UI/UiMarkupList.cs b/src/AcDream.App/UI/UiMarkupList.cs
index 91daf704b..596e7218a 100644
--- a/src/AcDream.App/UI/UiMarkupList.cs
+++ b/src/AcDream.App/UI/UiMarkupList.cs
@@ -29,6 +29,8 @@ public IReadOnlyList<UiMarkupListColumn>? Columns
             _scratchIsAuto = new bool[count];
             _scratchFixedWidth = new float[count];
             _cachedRowCount = 0;
+            _hasButtons = value?.Any(static c => c.Kind == UiMarkupListColumnKind.Button) ?? false;
+            ClearButtonPointer();
         }
     }
     public UiDatFont? DatFont { get; set; }
@@ -39,6 +41,10 @@ public IReadOnlyList<UiMarkupListColumn>? Columns
     public Vector4 TextColor { get; set; } = new(0.91f, 0.87f, 0.76f, 1f);
     public Vector4 SelectedColor { get; set; } = new(0.28f, 0.23f, 0.08f, 0.95f);
 
+    /// <summary>The face of a <c>button</c> column's cells; Classic matches a markup <c>&lt;button&gt;</c>.</summary>
+    public Vector4 ButtonColor { get; set; } = new(0.1f, 0.1f, 0.15f, 0.8f);
+    public Vector4 ButtonBorderColor { get; set; } = new(0.45f, 0.45f, 0.55f, 1f);
+
     public bool SelectionBandEnabled { get; set; }
 
     public Func<uint, (uint tex, int w, int h)>? SpriteResolve { get; set; }
@@ -68,8 +74,17 @@ public IReadOnlyList<UiMarkupListColumn>? Columns
     private float[] _scratchFixedWidth = Array.Empty<float>();
     private int _cachedRowCount;
 
+    // The button cell under the pointer and the one the left button went
+    // down on, as (row, column); -1 for none.
+    private bool _hasButtons;
+    private int _hoverRow = -1, _hoverColumn = -1;
+    private int _pressRow = -1, _pressColumn = -1;
+
     public override bool HandlesClick => true;
 
+    /// <summary>Button cells show hover, so a list with any takes moves while hovered.</summary>
+    public override bool ReceivesHoverMouseMove => _hasButtons;
+
     protected override void OnDraw(UiRenderContext context)
     {
         if (Columns is { Count: > 0 } columns)
@@ -250,6 +265,10 @@ private void DrawColumns(UiRenderContext context, IReadOnlyList<UiMarkupListColu
                     _cachedColorRows[c] = col.ColorsSource?.Invoke();
                     rowCount = Math.Max(rowCount, _cachedTextRows[c]!.Count);
                     break;
+                case UiMarkupListColumnKind.Button:
+                    _cachedTextRows[c] = col.TextSource!();
+                    rowCount = Math.Max(rowCount, _cachedTextRows[c]!.Count);
+                    break;
                 case UiMarkupListColumnKind.Check:
                     _cachedCheckRows[c] = col.CheckSource!();
                     rowCount = Math.Max(rowCount, _cachedCheckRows[c]!.Count);
@@ -311,6 +330,9 @@ private void DrawColumns(UiRenderContext context, IReadOnlyList<UiMarkupListColu
                         case UiMarkupListColumnKind.Icon:
                             DrawIconCell(context, columns[c], _cachedIconRows[c], index, cellX, cellW, y);
                             break;
+                        case UiMarkupListColumnKind.Button:
+                            DrawButtonCell(context, c, index, cellX, cellW, y);
+                            break;
                     }
                 }
                 finally
@@ -376,6 +398,154 @@ private void DrawIconCell(
             0f, 0f, 1f, 1f, Vector4.One);
     }
 
+    /// <summary>
+    /// A button cell inset by a pixel all round, so neighbouring buttons and
+    /// rows do not touch, with its caption centred in the list's text colour.
+    /// </summary>
+    private void DrawButtonCell(UiRenderContext context, int column, int index, float cellX, float cellW, float y)
+    {
+        if (!HasButtonCaption(column, index, out string caption))
+            return;
+        (float x, float top, float w, float h) = ButtonRect(_columns![column], cellX, cellW, y);
+        UiControlState state = ButtonState(index, column);
+        Vector4 face = state switch
+        {
+            UiControlState.Hovered => Vector4.Lerp(ButtonColor, ButtonBorderColor, 0.3f) with { W = ButtonColor.W },
+            UiControlState.Pressed => Vector4.Lerp(ButtonColor, Vector4.Zero, 0.25f) with { W = ButtonColor.W },
+            _ => ButtonColor,
+        };
+        context.DrawFill(x, top, w, h, face);
+        context.DrawRectOutline(x, top, w, h, ButtonBorderColor, 1f);
+        Vector4 textColor = state == UiControlState.Disabled ? TextColor with { W = TextColor.W * 0.45f } : TextColor;
+
+        if (DatFont is { } font)
+        {
+            context.DrawStringDat(font, caption,
+                x + (w - font.MeasureWidth(caption)) * 0.5f,
+                top + (h - font.LineHeight) * 0.5f,
+                textColor, ThemePalette is null);
+        }
+        else if (context.DefaultFont is { } fallback)
+        {
+            context.DrawString(caption,
+                x + (w - fallback.MeasureWidth(caption)) * 0.5f,
+                top + (h - fallback.LineHeight) * 0.5f,
+                textColor);
+        }
+    }
+
+    /// <summary>
+    /// Where a button sits in its cell: its column's size, centred, never past
+    /// the cell's one-pixel inset; a size of 0 fills the inset cell.
+    /// </summary>
+    private (float x, float y, float w, float h) ButtonRect(
+        UiMarkupListColumn column, float cellX, float cellW, float rowY)
+    {
+        float maxW = MathF.Max(0f, cellW - 2f), maxH = MathF.Max(0f, RowHeight - 2f);
+        float w = column.ButtonWidth > 0f ? MathF.Min(column.ButtonWidth, maxW) : maxW;
+        float h = column.ButtonHeight > 0f ? MathF.Min(column.ButtonHeight, maxH) : maxH;
+        return (MathF.Floor(cellX + (cellW - w) * 0.5f), MathF.Floor(rowY + (RowHeight - h) * 0.5f), w, h);
+    }
+
+    private bool HasButtonCaption(int column, int index, out string caption)
+    {
+        caption = string.Empty;
+        if (_columns is not { } columns || column < 0 || column >= columns.Count
+            || columns[column].Kind != UiMarkupListColumnKind.Button)
+            return false;
+        if (_cachedTextRows[column] is not { } captions || index < 0 || index >= captions.Count)
+            return false;
+        caption = captions[index] ?? string.Empty;
+        return caption.Length > 0;
+    }
+
+    /// <summary>
+    /// The look of one button cell: pressed only while the pointer is still
+    /// over the button it went down on, and no other button hovers while one
+    /// is held.
+    /// </summary>
+    private UiControlState ButtonState(int index, int column)
+    {
+        if (!Enabled)
+            return UiControlState.Disabled;
+        bool over = _hoverRow == index && _hoverColumn == column;
+        if (_pressRow >= 0)
+            return _pressRow == index && _pressColumn == column && over
+                ? UiControlState.Pressed
+                : UiControlState.Normal;
+        return over ? UiControlState.Hovered : UiControlState.Normal;
+    }
+
+    internal UiControlState ButtonStateForTest(int index, int column) =>
+        HasButtonCaption(column, index, out _) ? ButtonState(index, column) : UiControlState.Normal;
+
+    /// <summary>The button cell at a point inside the list, or (-1, -1) where there is none.</summary>
+    private (int index, int column) ButtonCellAt(float localX, float localY, float contentWidth, int visibleRows)
+    {
+        if (_columns is not { } columns || localX < 0f || localX >= contentWidth)
+            return (-1, -1);
+        int row = (int)MathF.Floor(localY / MathF.Max(1f, RowHeight));
+        int index = _topRow + row;
+        if (row < 0 || row >= visibleRows)
+            return (-1, -1);
+        for (int c = 0; c < columns.Count; c++)
+        {
+            (float cellX, float cellW) = _cachedLayout[c];
+            if (localX < cellX || localX >= cellX + cellW)
+                continue;
+            if (!HasButtonCaption(c, index, out _))
+                return (-1, -1);
+            (float bx, float by, float bw, float bh) = ButtonRect(columns[c], cellX, cellW, row * RowHeight);
+            bool onButton = localX >= bx && localX < bx + bw && localY >= by && localY < by + bh;
+            return onButton ? (index, c) : (-1, -1);
+        }
+        return (-1, -1);
+    }
+
+    private void ClearButtonPointer()
+    {
+        _hoverRow = _hoverColumn = -1;
+        _pressRow = _pressColumn = -1;
+    }
+
+    /// <summary>
+    /// Follows the pointer over button cells and fires a button when the left
+    /// button comes up over the one it went down on. Only a release that fires
+    /// a button is handled here; everything else carries on to the list.
+    /// </summary>
+    private bool TrackButtonPointer(
+        in UiEvent e, IReadOnlyList<UiMarkupListColumn> columns, float contentWidth, int visibleRows)
+    {
+        switch (e.Type)
+        {
+            case UiEventType.HoverEnter:
+            case UiEventType.MouseMove:
+            case UiEventType.MouseDown:
+                (_hoverRow, _hoverColumn) = _draggingThumb
+                    ? (-1, -1)
+                    : ButtonCellAt(e.Data1, e.Data2, contentWidth, visibleRows);
+                return false;
+            case UiEventType.HoverLeave:
+                _hoverRow = _hoverColumn = -1;
+                return false;
+            case UiEventType.CaptureChanged:
+                _pressRow = _pressColumn = -1;
+                return false;
+            case UiEventType.MouseUp:
+            {
+                (int index, int column) = (_pressRow, _pressColumn);
+                _pressRow = _pressColumn = -1;
+                (_hoverRow, _hoverColumn) = ButtonCellAt(e.Data1, e.Data2, contentWidth, visibleRows);
+                if (index < 0 || !Enabled || (_hoverRow, _hoverColumn) != (index, column))
+                    return false;
+                columns[column].ButtonClicked?.Invoke(index);
+                return true;
+            }
+            default:
+                return false;
+        }
+    }
+
     private bool OnEventColumns(in UiEvent e, IReadOnlyList<UiMarkupListColumn> columns)
     {
         int rowCount = _cachedRowCount;
@@ -383,6 +553,8 @@ private bool OnEventColumns(in UiEvent e, IReadOnlyList<UiMarkupListColumn> colu
         float contentWidth = rowCount > visibleRows
             ? MathF.Max(0f, Width - ScrollbarWidth)
             : Width;
+        if (_hasButtons && TrackButtonPointer(e, columns, contentWidth, visibleRows))
+            return true;
         if (TryHandleScrollbarEvent(e, contentWidth, rowCount, visibleRows))
             return true;
 
@@ -427,6 +599,11 @@ private bool OnEventColumns(in UiEvent e, IReadOnlyList<UiMarkupListColumn> colu
                     if (index < (_cachedIconRows[c]?.Count ?? 0))
                         columns[c].IconClicked?.Invoke(index);
                     break;
+                case UiMarkupListColumnKind.Button:
+                    // Fires on release over the same button; see TrackButtonPointer.
+                    if ((_hoverRow, _hoverColumn) == (index, c))
+                        (_pressRow, _pressColumn) = (index, c);
+                    break;
             }
             break;
         }
diff --git a/src/AcDream.App/UI/UiMarkupListColumn.cs b/src/AcDream.App/UI/UiMarkupListColumn.cs
index 3fedea06c..aac48351a 100644
--- a/src/AcDream.App/UI/UiMarkupListColumn.cs
+++ b/src/AcDream.App/UI/UiMarkupListColumn.cs
@@ -5,6 +5,7 @@ public enum UiMarkupListColumnKind
     Text,
     Check,
     Icon,
+    Button,
 }
 
 public sealed class UiMarkupListColumn
@@ -24,6 +25,12 @@ public sealed class UiMarkupListColumn
     public Func<uint, (uint tex, int w, int h)>? IconResolve { get; internal init; }
     public Action<int>? IconClicked { get; internal init; }
 
+    public Action<int>? ButtonClicked { get; internal init; }
+
+    /// <summary>A button's size inside its cell; 0 fills the cell. Never larger than the cell.</summary>
+    public float ButtonWidth { get; internal init; }
+    public float ButtonHeight { get; internal init; }
+
     public static UiMarkupListColumn Text(
         float width,
         Func<IReadOnlyList<string>> textSource,
@@ -67,9 +74,33 @@ public static UiMarkupListColumn Icon(
         IconClicked = onClick,
     };
 
+    /// <summary>
+    /// A column of buttons: each row's caption is drawn on a button face, an
+    /// empty caption draws no button, and a click on one fires
+    /// <paramref name="onClick"/> with the row index without selecting the row.
+    /// A button <paramref name="buttonWidth"/> by <paramref name="buttonHeight"/>
+    /// is centred in its cell; 0 fills the cell that way.
+    /// </summary>
+    public static UiMarkupListColumn Button(
+        float width,
+        Func<IReadOnlyList<string>> captionSource,
+        Action<int> onClick,
+        bool isAutoWidth = false,
+        float buttonWidth = 0f,
+        float buttonHeight = 0f) => new()
+    {
+        Kind = UiMarkupListColumnKind.Button,
+        Width = width,
+        IsAutoWidth = isAutoWidth,
+        TextSource = captionSource,
+        ButtonClicked = onClick,
+        ButtonWidth = buttonWidth,
+        ButtonHeight = buttonHeight,
+    };
+
     public int RowCount() => Kind switch
     {
-        UiMarkupListColumnKind.Text => TextSource?.Invoke().Count ?? 0,
+        UiMarkupListColumnKind.Text or UiMarkupListColumnKind.Button => TextSource?.Invoke().Count ?? 0,
         UiMarkupListColumnKind.Check => CheckSource?.Invoke().Count ?? 0,
         UiMarkupListColumnKind.Icon => IconValuesSource?.Invoke().Count ?? 0,
         _ => 0,
diff --git a/src/AcDream.App/UI/UiPointerState.cs b/src/AcDream.App/UI/UiPointerState.cs
new file mode 100644
index 000000000..07b75dffd
--- /dev/null
+++ b/src/AcDream.App/UI/UiPointerState.cs
@@ -0,0 +1,4 @@
+namespace AcDream.App.UI;
+
+/// <summary>The look a control takes from the pointer and its own enabled flag.</summary>
+public enum UiControlState { Normal, Hovered, Pressed, Disabled }
diff --git a/tests/AcDream.App.Tests/UI/ListButtonColumnTests.cs b/tests/AcDream.App.Tests/UI/ListButtonColumnTests.cs
new file mode 100644
index 000000000..78f147728
--- /dev/null
+++ b/tests/AcDream.App.Tests/UI/ListButtonColumnTests.cs
@@ -0,0 +1,337 @@
+using System.Numerics;
+using AcDream.App.Rendering;
+using AcDream.App.Rendering.Gpu;
+using AcDream.App.Tests.Rendering.Gpu;
+using AcDream.App.UI;
+using Xunit;
+
+namespace AcDream.App.Tests.UI;
+
+public sealed class ListButtonColumnTests
+{
+    private static (uint, int, int) Sprite(uint id) => (1u, 32, 32);
+
+    private sealed class FoundBinding
+    {
+        public IReadOnlyList<string> Names { get; } = new[] { "Drudge", "Rat", "Mosswart" };
+        public IReadOnlyList<string> Captions { get; } = new[] { "Select", "", "Select" };
+        public int Selected { get; set; } = -1;
+        public List<int> Acted { get; } = new();
+        public Action<int> Act => row => Acted.Add(row);
+    }
+
+    private static string FoundXml(string buttonColumn) =>
+        "<panel x=\"0\" y=\"0\" w=\"200\" h=\"100\">" +
+        "<list x=\"0\" y=\"0\" w=\"180\" h=\"60\" rowheight=\"18\" selected=\"{Selected}\">" +
+        "  <column type=\"text\" width=\"100\" items=\"{Names}\"/>" +
+        buttonColumn +
+        "</list></panel>";
+
+    [Fact]
+    public void ButtonColumn_BindsItsCaptionsAndOnclick()
+    {
+        var binding = new FoundBinding();
+        var panel = MarkupDocument.Build(
+            FoundXml("<column type=\"button\" width=\"60\" items=\"{Captions}\" onclick=\"{Act}\"/>"),
+            binding, Sprite);
+        var list = Assert.IsType<UiMarkupList>(panel.Children[0]);
+
+        var column = list.Columns![1];
+        Assert.Equal(UiMarkupListColumnKind.Button, column.Kind);
+        Assert.Equal(binding.Captions, column.TextSource!());
+        Assert.Equal(3, column.RowCount());
+        column.ButtonClicked!(2);
+        Assert.Equal(new[] { 2 }, binding.Acted);
+    }
+
+    [Fact]
+    public void ButtonColumn_MissingOnclick_ThrowsAtBuild()
+    {
+        var ex = Assert.Throws<FormatException>(() => MarkupDocument.Build(
+            FoundXml("<column type=\"button\" width=\"60\" items=\"{Captions}\"/>"),
+            new FoundBinding(), Sprite));
+        Assert.Contains("column[1] type=\"button\" onclick", ex.Message);
+    }
+
+    [Fact]
+    public void ButtonColumn_MissingItems_ThrowsAtBuild()
+    {
+        var ex = Assert.Throws<FormatException>(() => MarkupDocument.Build(
+            FoundXml("<column type=\"button\" width=\"60\" onclick=\"{Act}\"/>"),
+            new FoundBinding(), Sprite));
+        Assert.Contains("column[1] type=\"button\" items", ex.Message);
+    }
+
+    [Fact]
+    public void UnknownColumnType_NamesButtonAmongTheExpectedTypes()
+    {
+        var ex = Assert.Throws<FormatException>(() => MarkupDocument.Build(
+            FoundXml("<column type=\"bogus\" width=\"60\" items=\"{Captions}\"/>"),
+            new FoundBinding(), Sprite));
+        Assert.Contains("button", ex.Message);
+    }
+
+    private static UiMarkupList MakeList(
+        List<int> acted, List<int> selections, string[]? captions = null)
+    {
+        captions ??= new[] { "Go", "", "Go" };
+        var list = new UiMarkupList
+        {
+            Width = 100f, Height = 60f, RowHeight = 20f,
+            SelectedIndexSource = () => -1,
+            SelectionChanged = row => selections.Add(row),
+            BackgroundColor = default, BorderColor = default,
+            Columns = new[]
+            {
+                UiMarkupListColumn.Text(50f, () => new[] { "a", "b", "c" }, null),
+                UiMarkupListColumn.Button(50f, () => captions, row => acted.Add(row)),
+            },
+        };
+        var (_, ctx) = MakeContext(200f, 200f);
+        list.DrawSelfAndChildren(ctx);
+        return list;
+    }
+
+    [Fact]
+    public void PressAndReleaseOnAButton_FiresOnclickWithTheRow_WithoutSelecting()
+    {
+        var acted = new List<int>();
+        var selections = new List<int>();
+        var list = MakeList(acted, selections);
+
+        // Row 2 (y = 40..60), button column (x = 50..100).
+        list.OnEvent(new UiEvent { Type = UiEventType.MouseDown, Data1 = 70, Data2 = 45 });
+        Assert.Empty(acted);
+        list.OnEvent(new UiEvent { Type = UiEventType.MouseUp, Data1 = 72, Data2 = 47 });
+
+        Assert.Equal(new[] { 2 }, acted);
+        Assert.Empty(selections);
+    }
+
+    [Fact]
+    public void ReleaseOffThePressedButton_DoesNotFire()
+    {
+        var acted = new List<int>();
+        var list = MakeList(acted, new List<int>());
+
+        list.OnEvent(new UiEvent { Type = UiEventType.MouseDown, Data1 = 70, Data2 = 5 });
+        list.OnEvent(new UiEvent { Type = UiEventType.MouseUp, Data1 = 70, Data2 = 45 });
+        list.OnEvent(new UiEvent { Type = UiEventType.MouseDown, Data1 = 70, Data2 = 5 });
+        list.OnEvent(new UiEvent { Type = UiEventType.MouseUp, Data1 = 10, Data2 = 5 });
+
+        Assert.Empty(acted);
+    }
+
+    [Fact]
+    public void EmptyCaption_IsNoButton_AndAClickOnItDoesNothing()
+    {
+        var acted = new List<int>();
+        var selections = new List<int>();
+        var list = MakeList(acted, selections);
+
+        list.OnEvent(new UiEvent { Type = UiEventType.MouseDown, Data1 = 70, Data2 = 25 });
+        list.OnEvent(new UiEvent { Type = UiEventType.MouseUp, Data1 = 70, Data2 = 25 });
+
+        Assert.Empty(acted);
+        Assert.Empty(selections);
+        Assert.Equal(UiControlState.Normal, list.ButtonStateForTest(1, 1));
+    }
+
+    [Fact]
+    public void ButtonCell_ShowsHoverAndPressOnlyOnTheCellUnderThePointer()
+    {
+        var list = MakeList(new List<int>(), new List<int>());
+        Assert.True(list.ReceivesHoverMouseMove);
+
+        list.OnEvent(new UiEvent { Type = UiEventType.HoverEnter, Data1 = 70, Data2 = 5 });
+        Assert.Equal(UiControlState.Hovered, list.ButtonStateForTest(0, 1));
+        Assert.Equal(UiControlState.Normal, list.ButtonStateForTest(2, 1));
+
+        list.OnEvent(new UiEvent { Type = UiEventType.MouseMove, Data1 = 70, Data2 = 45 });
+        Assert.Equal(UiControlState.Normal, list.ButtonStateForTest(0, 1));
+        Assert.Equal(UiControlState.Hovered, list.ButtonStateForTest(2, 1));
+
+        list.OnEvent(new UiEvent { Type = UiEventType.MouseDown, Data1 = 70, Data2 = 45 });
+        Assert.Equal(UiControlState.Pressed, list.ButtonStateForTest(2, 1));
+
+        // Dragged off the pressed button: it lets go of its pressed look.
+        list.OnEvent(new UiEvent { Type = UiEventType.MouseMove, Data1 = 70, Data2 = 5 });
+        Assert.Equal(UiControlState.Normal, list.ButtonStateForTest(2, 1));
+        Assert.Equal(UiControlState.Normal, list.ButtonStateForTest(0, 1));
+
+        list.OnEvent(new UiEvent { Type = UiEventType.MouseUp, Data1 = 70, Data2 = 5 });
+        Assert.Equal(UiControlState.Hovered, list.ButtonStateForTest(0, 1));
+
+        list.OnEvent(new UiEvent { Type = UiEventType.HoverLeave });
+        Assert.Equal(UiControlState.Normal, list.ButtonStateForTest(0, 1));
+    }
+
+    [Fact]
+    public void ListWithoutButtonColumns_TakesNoHoverMoves()
+    {
+        var list = new UiMarkupList
+        {
+            Columns = new[] { UiMarkupListColumn.Text(50f, () => new[] { "a" }, null) },
+        };
+        Assert.False(list.ReceivesHoverMouseMove);
+    }
+
+    [Fact]
+    public void DisabledList_ShowsItsButtonsDisabled()
+    {
+        var list = MakeList(new List<int>(), new List<int>());
+        list.Enabled = false;
+        Assert.Equal(UiControlState.Disabled, list.ButtonStateForTest(0, 1));
+    }
+
+    [Fact]
+    public void ClassicButtonCell_DrawsAFaceInsideItsCell_OnlyWhereThereIsACaption()
+    {
+        var face = new Vector4(0.2f, 0.4f, 0.6f, 1f);
+        var list = new UiMarkupList
+        {
+            Width = 100f, Height = 60f, RowHeight = 20f,
+            SelectedIndexSource = () => -1,
+            BackgroundColor = default, BorderColor = default,
+            ButtonColor = face,
+            Columns = new[]
+            {
+                UiMarkupListColumn.Text(50f, () => new[] { "a", "b", "c" }, null),
+                UiMarkupListColumn.Button(50f, () => new[] { "Go", "", "Go" }, _ => { }),
+            },
+        };
+        var (renderer, ctx) = MakeContext(200f, 200f);
+
+        list.DrawSelfAndChildren(ctx);
+
+        var faceVerts = renderer.DebugSpriteSegmentVerts
+            .Where(s => s.Texture == 0u)
+            .SelectMany(s => Chunk(s.Verts))
+            .Where(v => ColorMatches(v, face))
+            .ToList();
+        Assert.NotEmpty(faceVerts);
+        Assert.All(faceVerts, v => Assert.InRange(v[0], 50f, 100f));
+        // Rows 0 and 2 only: nothing in row 1 (y = 20..40).
+        Assert.Contains(faceVerts, v => v[1] < 20f);
+        Assert.Contains(faceVerts, v => v[1] > 40f);
+        Assert.DoesNotContain(faceVerts, v => v[1] > 21f && v[1] < 39f);
+    }
+
+    [Fact]
+    public void ButtonColumn_BindsItsButtonSize()
+    {
+        var panel = MarkupDocument.Build(
+            FoundXml("<column type=\"button\" width=\"60\" items=\"{Captions}\" onclick=\"{Act}\" buttonw=\"40\" buttonh=\"12\"/>"),
+            new FoundBinding(), Sprite);
+        var column = Assert.IsType<UiMarkupList>(panel.Children[0]).Columns![1];
+        Assert.Equal(40f, column.ButtonWidth);
+        Assert.Equal(12f, column.ButtonHeight);
+    }
+
+    [Fact]
+    public void ButtonColumn_NegativeButtonSize_ThrowsAtBuild()
+    {
+        var ex = Assert.Throws<FormatException>(() => MarkupDocument.Build(
+            FoundXml("<column type=\"button\" width=\"60\" items=\"{Captions}\" onclick=\"{Act}\" buttonh=\"-1\"/>"),
+            new FoundBinding(), Sprite));
+        Assert.Contains("column[1] type=\"button\" buttonh", ex.Message);
+    }
+
+    [Fact]
+    public void SizedButton_IsCentredInItsCell_AndOnlyTheButtonTakesClicks()
+    {
+        var face = new Vector4(0.2f, 0.4f, 0.6f, 1f);
+        var acted = new List<int>();
+        var list = new UiMarkupList
+        {
+            Width = 100f, Height = 60f, RowHeight = 20f,
+            SelectedIndexSource = () => -1,
+            BackgroundColor = default, BorderColor = default,
+            ButtonColor = face,
+            Columns = new[]
+            {
+                UiMarkupListColumn.Text(50f, () => new[] { "a" }, null),
+                // Cell x = 50..100, y = 0..20; a 30x10 button sits at x = 60..90, y = 5..15.
+                UiMarkupListColumn.Button(50f, () => new[] { "Go" }, row => acted.Add(row),
+                    buttonWidth: 30f, buttonHeight: 10f),
+            },
+        };
+        var (renderer, ctx) = MakeContext(200f, 200f);
+        list.DrawSelfAndChildren(ctx);
+
+        var faceVerts = renderer.DebugSpriteSegmentVerts
+            .Where(s => s.Texture == 0u)
+            .SelectMany(s => Chunk(s.Verts))
+            .Where(v => ColorMatches(v, face))
+            .ToList();
+        Assert.NotEmpty(faceVerts);
+        Assert.All(faceVerts, v => Assert.InRange(v[0], 60f, 90f));
+        Assert.All(faceVerts, v => Assert.InRange(v[1], 5f, 15f));
+
+        // Inside the cell but beside the button: nothing.
+        list.OnEvent(new UiEvent { Type = UiEventType.MouseDown, Data1 = 55, Data2 = 10 });
+        list.OnEvent(new UiEvent { Type = UiEventType.MouseUp, Data1 = 55, Data2 = 10 });
+        list.OnEvent(new UiEvent { Type = UiEventType.MouseMove, Data1 = 75, Data2 = 2 });
+        Assert.Equal(UiControlState.Normal, list.ButtonStateForTest(0, 1));
+        Assert.Empty(acted);
+
+        list.OnEvent(new UiEvent { Type = UiEventType.MouseDown, Data1 = 75, Data2 = 10 });
+        list.OnEvent(new UiEvent { Type = UiEventType.MouseUp, Data1 = 75, Data2 = 10 });
+        Assert.Equal(new[] { 0 }, acted);
+    }
+
+    [Fact]
+    public void SizedButton_NeverGrowsPastItsCell()
+    {
+        var face = new Vector4(0.2f, 0.4f, 0.6f, 1f);
+        var list = new UiMarkupList
+        {
+            Width = 100f, Height = 60f, RowHeight = 20f,
+            SelectedIndexSource = () => -1,
+            BackgroundColor = default, BorderColor = default,
+            ButtonColor = face,
+            Columns = new[]
+            {
+                UiMarkupListColumn.Text(50f, () => new[] { "a" }, null),
+                UiMarkupListColumn.Button(50f, () => new[] { "Go" }, _ => { },
+                    buttonWidth: 500f, buttonHeight: 500f),
+            },
+        };
+        var (renderer, ctx) = MakeContext(200f, 200f);
+        list.DrawSelfAndChildren(ctx);
+
+        var faceVerts = renderer.DebugSpriteSegmentVerts
+            .Where(s => s.Texture == 0u)
+            .SelectMany(s => Chunk(s.Verts))
+            .Where(v => ColorMatches(v, face))
+            .ToList();
+        Assert.All(faceVerts, v => Assert.InRange(v[0], 51f, 99f));
+        Assert.All(faceVerts, v => Assert.InRange(v[1], 1f, 19f));
+    }
+
+    private static IEnumerable<float[]> Chunk(IReadOnlyList<float> verts)
+    {
+        for (int i = 0; i + 8 <= verts.Count; i += 8)
+            yield return verts.Skip(i).Take(8).ToArray();
+    }
+
+    private static bool ColorMatches(float[] vertex, Vector4 color) =>
+        MathF.Abs(vertex[4] - color.X) < 0.001f
+        && MathF.Abs(vertex[5] - color.Y) < 0.001f
+        && MathF.Abs(vertex[6] - color.Z) < 0.001f
+        && MathF.Abs(vertex[7] - color.W) < 0.001f;
+
+    private static (TextRenderer renderer, UiRenderContext ctx) MakeContext(float w, float h)
+    {
+        var device = new RecordingGpuDevice();
+        var renderer = new TextRenderer(device, new NullGpuFrameSource(), "unused");
+        renderer.Begin(new Vector2(w, h));
+        var ctx = new UiRenderContext(renderer, new Vector2(w, h));
+        return (renderer, ctx);
+    }
+
+    private sealed class NullGpuFrameSource : ICurrentGpuFrameSource
+    {
+        public IGpuFrame? CurrentFrame => null;
+    }
+}

From ea56eee5a7bd4d267b9548f7765b03bf31db655c Mon Sep 17 00:00:00 2001
From: Erik <erik.nihlen@gmail.com>
Date: Mon, 19 Oct 2026 18:09:23 +0200
Subject: [PATCH 2/4] refactor(markup): give UiControlState its own file and
 make it internal

The enum sat alone in a file named for something else. Only the list's
button cells and their tests use it, and nothing public returns it, so it
does not need to be part of the App's public surface.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/AcDream.App/UI/{UiPointerState.cs => UiControlState.cs} | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 rename src/AcDream.App/UI/{UiPointerState.cs => UiControlState.cs} (63%)

diff --git a/src/AcDream.App/UI/UiPointerState.cs b/src/AcDream.App/UI/UiControlState.cs
similarity index 63%
rename from src/AcDream.App/UI/UiPointerState.cs
rename to src/AcDream.App/UI/UiControlState.cs
index 07b75dffd..7993df7d1 100644
--- a/src/AcDream.App/UI/UiPointerState.cs
+++ b/src/AcDream.App/UI/UiControlState.cs
@@ -1,4 +1,4 @@
 namespace AcDream.App.UI;
 
 /// <summary>The look a control takes from the pointer and its own enabled flag.</summary>
-public enum UiControlState { Normal, Hovered, Pressed, Disabled }
+internal enum UiControlState { Normal, Hovered, Pressed, Disabled }

From d35393a3e6c50759e3270120a1ef067577276817 Mon Sep 17 00:00:00 2001
From: Erik <erik.nihlen@gmail.com>
Date: Mon, 19 Oct 2026 18:09:23 +0200
Subject: [PATCH 3/4] fix(markup): list buttons fire only for the row pressed,
 and look disabled

A button column's onclick gets a row index, so a release could fire for a
different item than the one pressed. The press is now dropped if, before
the release, the list scrolls, its row count changes, or the pressed row's
text, caption or icon changes. The rows are re-read at the release, so a
change with no frame drawn in between still counts. Rows re-read with the
same content (bindings hand over a fresh array each read) still fire.
Disabling the list while pressed drops the press too.

A wheel scroll with no pointer move left the hover on a button that had
scrolled away; the hover is now found again from the last pointer position
after a scroll and on every draw.

A disabled list drew an enabled-looking face; face, border and caption now
fade by the alpha a disabled toggle's caption uses (named for both). A
caption wider than its button is cut at the button's edges instead of
running across the cell.

The docs now say what the button looks like on and off a theme, that its
hover and pressed looks are its own, and when a press is cancelled. New
tests go through UiRoot dispatch (press, release, capture taken away) and
cover each fix; the fix tests fail on the previous commit.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/plugin-ui-markup.md                      |  21 +-
 src/AcDream.App/UI/UiMarkupList.cs            | 209 +++++++++++---
 src/AcDream.App/UI/UiMarkupToggle.cs          |   5 +-
 .../UI/ListButtonColumnTests.cs               | 254 ++++++++++++++++++
 4 files changed, 440 insertions(+), 49 deletions(-)

diff --git a/docs/plugin-ui-markup.md b/docs/plugin-ui-markup.md
index b21a9a858..95513d0e8 100644
--- a/docs/plugin-ui-markup.md
+++ b/docs/plugin-ui-markup.md
@@ -348,12 +348,21 @@ selection alone. A click past a column's own data does nothing.
 
 A `button` cell is drawn as a button one pixel inside its cell, or at
 `buttonw` by `buttonh` centred in the cell (never larger than the cell; set
-either alone to size only that side), with its caption centred. It has the
-face and border of a markup `<button>`, in the theme's colours on a themed
-window, lighter while hovered and darker while pressed. It fires like a
-`<button>`, when the left button comes up over the button it went down on, so
-a press dragged off the button cancels it; a click beside a smaller button
-does nothing. A cell with an empty caption is not a button and ignores clicks.
+either alone to size only that side), with its caption centred in the list's
+text colour and cut off at the button's edges. Without a theme its face and
+border are those of an unthemed `<button>`. On a themed window the face is the
+theme's background colour (the list itself is drawn in the field colour that
+a themed `<button>` uses) and the border is the theme's border colour. Unlike
+a `<button>`, it lightens while hovered and darkens while pressed. A disabled
+list draws its buttons' face, border and caption faded and fires none of them.
+
+It fires like a `<button>`, when the left button comes up over the button it
+went down on, so a press dragged off the button cancels it; a click beside a
+smaller button does nothing. Because `onclick` gets a row index, a press is
+also cancelled if, before the release, the list scrolls, its row count changes,
+or the pressed row's text, caption or icon changes; a `check` value changing
+does not cancel it. A cell with an empty caption is not a button and ignores
+clicks.
 On a host older than button columns, a `type="button"` column fails the build
 of its window as an unknown type.
 
diff --git a/src/AcDream.App/UI/UiMarkupList.cs b/src/AcDream.App/UI/UiMarkupList.cs
index 596e7218a..e8196cbde 100644
--- a/src/AcDream.App/UI/UiMarkupList.cs
+++ b/src/AcDream.App/UI/UiMarkupList.cs
@@ -29,6 +29,8 @@ public IReadOnlyList<UiMarkupListColumn>? Columns
             _scratchIsAuto = new bool[count];
             _scratchFixedWidth = new float[count];
             _cachedRowCount = 0;
+            _pressRowText = new string?[count];
+            _pressRowIcon = new uint[count];
             _hasButtons = value?.Any(static c => c.Kind == UiMarkupListColumnKind.Button) ?? false;
             ClearButtonPointer();
         }
@@ -80,6 +82,18 @@ public IReadOnlyList<UiMarkupListColumn>? Columns
     private int _hoverRow = -1, _hoverColumn = -1;
     private int _pressRow = -1, _pressColumn = -1;
 
+    // What the list showed when the button went down: a release fires by row
+    // index, so the press is dropped if the list scrolls, its row count
+    // changes, or the pressed row's text, caption or icon changes before then.
+    private int _pressTopRow, _pressRowCount;
+    private string?[] _pressRowText = Array.Empty<string?>();
+    private uint[] _pressRowIcon = Array.Empty<uint>();
+
+    // The pointer's last position in list space, so the hovered button can be
+    // found again when the rows move under a pointer that did not.
+    private bool _pointerKnown;
+    private float _pointerX, _pointerY;
+
     public override bool HandlesClick => true;
 
     /// <summary>Button cells show hover, so a list with any takes moves while hovered.</summary>
@@ -254,32 +268,7 @@ private void ComputeColumnLayout(IReadOnlyList<UiMarkupListColumn> columns, floa
 
     private void DrawColumns(UiRenderContext context, IReadOnlyList<UiMarkupListColumn> columns)
     {
-        int rowCount = 0;
-        for (int c = 0; c < columns.Count; c++)
-        {
-            var col = columns[c];
-            switch (col.Kind)
-            {
-                case UiMarkupListColumnKind.Text:
-                    _cachedTextRows[c] = col.TextSource!();
-                    _cachedColorRows[c] = col.ColorsSource?.Invoke();
-                    rowCount = Math.Max(rowCount, _cachedTextRows[c]!.Count);
-                    break;
-                case UiMarkupListColumnKind.Button:
-                    _cachedTextRows[c] = col.TextSource!();
-                    rowCount = Math.Max(rowCount, _cachedTextRows[c]!.Count);
-                    break;
-                case UiMarkupListColumnKind.Check:
-                    _cachedCheckRows[c] = col.CheckSource!();
-                    rowCount = Math.Max(rowCount, _cachedCheckRows[c]!.Count);
-                    break;
-                case UiMarkupListColumnKind.Icon:
-                    _cachedIconRows[c] = col.IconValuesSource!();
-                    rowCount = Math.Max(rowCount, _cachedIconRows[c]!.Count);
-                    break;
-            }
-        }
-        _cachedRowCount = rowCount;
+        int rowCount = RefreshRows(columns);
 
         int visibleRows = VisibleRows;
         bool showScrollbar = rowCount > visibleRows;
@@ -299,6 +288,11 @@ private void DrawColumns(UiRenderContext context, IReadOnlyList<UiMarkupListColu
             }
         }
         ClampTop(rowCount, visibleRows);
+        if (_hasButtons)
+        {
+            CancelPressIfRowsMoved();
+            RefreshHover(contentWidth, visibleRows);
+        }
 
         context.DrawFill(0f, 0f, Width, Height, BackgroundColor);
         context.DrawRectOutline(0f, 0f, Width, Height, BorderColor, 1f);
@@ -346,6 +340,38 @@ private void DrawColumns(UiRenderContext context, IReadOnlyList<UiMarkupListColu
             DrawScrollbar(context, contentWidth, rowCount, visibleRows);
     }
 
+    /// <summary>Reads every column's rows from its binding; returns the row count, the longest column.</summary>
+    private int RefreshRows(IReadOnlyList<UiMarkupListColumn> columns)
+    {
+        int rowCount = 0;
+        for (int c = 0; c < columns.Count; c++)
+        {
+            var col = columns[c];
+            switch (col.Kind)
+            {
+                case UiMarkupListColumnKind.Text:
+                    _cachedTextRows[c] = col.TextSource!();
+                    _cachedColorRows[c] = col.ColorsSource?.Invoke();
+                    rowCount = Math.Max(rowCount, _cachedTextRows[c]!.Count);
+                    break;
+                case UiMarkupListColumnKind.Button:
+                    _cachedTextRows[c] = col.TextSource!();
+                    rowCount = Math.Max(rowCount, _cachedTextRows[c]!.Count);
+                    break;
+                case UiMarkupListColumnKind.Check:
+                    _cachedCheckRows[c] = col.CheckSource!();
+                    rowCount = Math.Max(rowCount, _cachedCheckRows[c]!.Count);
+                    break;
+                case UiMarkupListColumnKind.Icon:
+                    _cachedIconRows[c] = col.IconValuesSource!();
+                    rowCount = Math.Max(rowCount, _cachedIconRows[c]!.Count);
+                    break;
+            }
+        }
+        _cachedRowCount = rowCount;
+        return rowCount;
+    }
+
     private void DrawTextCell(
         UiRenderContext context, IReadOnlyList<string>? texts, IReadOnlyList<uint>? colors,
         int index, float cellX, float y)
@@ -400,7 +426,9 @@ private void DrawIconCell(
 
     /// <summary>
     /// A button cell inset by a pixel all round, so neighbouring buttons and
-    /// rows do not touch, with its caption centred in the list's text colour.
+    /// rows do not touch, with its caption centred in the list's text colour
+    /// and cut at the button's edges. A disabled list draws face, border and
+    /// caption at the alpha a disabled toggle's caption takes.
     /// </summary>
     private void DrawButtonCell(UiRenderContext context, int column, int index, float cellX, float cellW, float y)
     {
@@ -414,26 +442,43 @@ private void DrawButtonCell(UiRenderContext context, int column, int index, floa
             UiControlState.Pressed => Vector4.Lerp(ButtonColor, Vector4.Zero, 0.25f) with { W = ButtonColor.W },
             _ => ButtonColor,
         };
+        Vector4 border = ButtonBorderColor;
+        Vector4 textColor = TextColor;
+        if (state == UiControlState.Disabled)
+        {
+            face = Dimmed(face);
+            border = Dimmed(border);
+            textColor = Dimmed(textColor);
+        }
         context.DrawFill(x, top, w, h, face);
-        context.DrawRectOutline(x, top, w, h, ButtonBorderColor, 1f);
-        Vector4 textColor = state == UiControlState.Disabled ? TextColor with { W = TextColor.W * 0.45f } : TextColor;
+        context.DrawRectOutline(x, top, w, h, border, 1f);
 
-        if (DatFont is { } font)
+        context.PushClip(x, top, w, h);
+        try
         {
-            context.DrawStringDat(font, caption,
-                x + (w - font.MeasureWidth(caption)) * 0.5f,
-                top + (h - font.LineHeight) * 0.5f,
-                textColor, ThemePalette is null);
+            if (DatFont is { } font)
+            {
+                context.DrawStringDat(font, caption,
+                    x + (w - font.MeasureWidth(caption)) * 0.5f,
+                    top + (h - font.LineHeight) * 0.5f,
+                    textColor, ThemePalette is null);
+            }
+            else if (context.DefaultFont is { } fallback)
+            {
+                context.DrawString(caption,
+                    x + (w - fallback.MeasureWidth(caption)) * 0.5f,
+                    top + (h - fallback.LineHeight) * 0.5f,
+                    textColor);
+            }
         }
-        else if (context.DefaultFont is { } fallback)
+        finally
         {
-            context.DrawString(caption,
-                x + (w - fallback.MeasureWidth(caption)) * 0.5f,
-                top + (h - fallback.LineHeight) * 0.5f,
-                textColor);
+            context.PopClip();
         }
     }
 
+    private static Vector4 Dimmed(Vector4 color) => color with { W = color.W * UiMarkupToggle.DisabledAlpha };
+
     /// <summary>
     /// Where a button sits in its cell: its column's size, centred, never past
     /// the cell's one-pixel inset; a size of 0 fills the inset cell.
@@ -506,8 +551,70 @@ private void ClearButtonPointer()
     {
         _hoverRow = _hoverColumn = -1;
         _pressRow = _pressColumn = -1;
+        _pointerKnown = false;
+    }
+
+    protected override void OnEnabledChanged()
+    {
+        if (!Enabled)
+            _pressRow = _pressColumn = -1;
+    }
+
+    private void TrackPointer(in UiEvent e)
+    {
+        _pointerKnown = true;
+        (_pointerX, _pointerY) = (e.Data1, e.Data2);
+    }
+
+    /// <summary>Finds the hovered button again from the last pointer position, after the rows moved.</summary>
+    private void RefreshHover(float contentWidth, int visibleRows) =>
+        (_hoverRow, _hoverColumn) = _pointerKnown && !_draggingThumb
+            ? ButtonCellAt(_pointerX, _pointerY, contentWidth, visibleRows)
+            : (-1, -1);
+
+    private void RememberPressedRow()
+    {
+        _pressTopRow = _topRow;
+        _pressRowCount = _cachedRowCount;
+        for (int c = 0; c < _pressRowText.Length; c++)
+        {
+            _pressRowText[c] = PressedRowText(c);
+            _pressRowIcon[c] = PressedRowIcon(c);
+        }
+    }
+
+    /// <summary>
+    /// Drops the press when the row under it may no longer be the item that was
+    /// pressed: the list scrolled, its row count changed, or the pressed row's
+    /// text, caption or icon changed. Check values are the row's state, not
+    /// which item it is, so they do not count.
+    /// </summary>
+    private void CancelPressIfRowsMoved()
+    {
+        if (_pressRow < 0)
+            return;
+        bool moved = _topRow != _pressTopRow || _cachedRowCount != _pressRowCount;
+        for (int c = 0; !moved && c < _pressRowText.Length; c++)
+        {
+            moved = !string.Equals(PressedRowText(c), _pressRowText[c], StringComparison.Ordinal)
+                || PressedRowIcon(c) != _pressRowIcon[c];
+        }
+        if (moved)
+            _pressRow = _pressColumn = -1;
     }
 
+    private string? PressedRowText(int column) =>
+        _columns![column].Kind is UiMarkupListColumnKind.Text or UiMarkupListColumnKind.Button
+            && _cachedTextRows[column] is { } texts && _pressRow < texts.Count
+            ? texts[_pressRow]
+            : null;
+
+    private uint PressedRowIcon(int column) =>
+        _columns![column].Kind == UiMarkupListColumnKind.Icon
+            && _cachedIconRows[column] is { } icons && _pressRow < icons.Count
+            ? icons[_pressRow]
+            : 0u;
+
     /// <summary>
     /// Follows the pointer over button cells and fires a button when the left
     /// button comes up over the one it went down on. Only a release that fires
@@ -521,11 +628,11 @@ private bool TrackButtonPointer(
             case UiEventType.HoverEnter:
             case UiEventType.MouseMove:
             case UiEventType.MouseDown:
-                (_hoverRow, _hoverColumn) = _draggingThumb
-                    ? (-1, -1)
-                    : ButtonCellAt(e.Data1, e.Data2, contentWidth, visibleRows);
+                TrackPointer(e);
+                RefreshHover(contentWidth, visibleRows);
                 return false;
             case UiEventType.HoverLeave:
+                _pointerKnown = false;
                 _hoverRow = _hoverColumn = -1;
                 return false;
             case UiEventType.CaptureChanged:
@@ -533,6 +640,13 @@ private bool TrackButtonPointer(
                 return false;
             case UiEventType.MouseUp:
             {
+                TrackPointer(e);
+                if (_pressRow >= 0)
+                {
+                    // Read the rows as they are now, not as last drawn.
+                    RefreshRows(columns);
+                    CancelPressIfRowsMoved();
+                }
                 (int index, int column) = (_pressRow, _pressColumn);
                 _pressRow = _pressColumn = -1;
                 (_hoverRow, _hoverColumn) = ButtonCellAt(e.Data1, e.Data2, contentWidth, visibleRows);
@@ -562,6 +676,14 @@ private bool OnEventColumns(in UiEvent e, IReadOnlyList<UiMarkupListColumn> colu
         {
             _topRow -= Math.Sign(e.Data0);
             ClampTop(rowCount, visibleRows);
+            if (_hasButtons)
+            {
+                // The rows moved under the pointer: a press no longer names
+                // the row it went down on, and the hovered button may differ.
+                CancelPressIfRowsMoved();
+                TrackPointer(e);
+                RefreshHover(contentWidth, visibleRows);
+            }
             return true;
         }
         if (e.Type != UiEventType.MouseDown || !Enabled)
@@ -602,7 +724,10 @@ private bool OnEventColumns(in UiEvent e, IReadOnlyList<UiMarkupListColumn> colu
                 case UiMarkupListColumnKind.Button:
                     // Fires on release over the same button; see TrackButtonPointer.
                     if ((_hoverRow, _hoverColumn) == (index, c))
+                    {
                         (_pressRow, _pressColumn) = (index, c);
+                        RememberPressedRow();
+                    }
                     break;
             }
             break;
diff --git a/src/AcDream.App/UI/UiMarkupToggle.cs b/src/AcDream.App/UI/UiMarkupToggle.cs
index fbc84b986..fc63e9190 100644
--- a/src/AcDream.App/UI/UiMarkupToggle.cs
+++ b/src/AcDream.App/UI/UiMarkupToggle.cs
@@ -19,6 +19,9 @@ public sealed class UiMarkupToggle : UiElement
 
     public bool IsChecked => CheckedSource?.Invoke() ?? false;
 
+    /// <summary>The alpha a disabled toggle's caption draws at; a disabled list button dims by it too.</summary>
+    internal const float DisabledAlpha = 0.42f;
+
     public override bool HandlesClick => true;
 
     private readonly UiKeyboardActivation _keyboardActivation = new();
@@ -46,7 +49,7 @@ protected override void OnDraw(UiRenderContext ctx)
         Vector4 textColor = TextColorSource?.Invoke() ?? TextColor;
         Vector4 color = Enabled
             ? textColor
-            : new Vector4(textColor.X, textColor.Y, textColor.Z, 0.42f);
+            : textColor with { W = DisabledAlpha };
         float y = DatFont is { } font
             ? (Height - font.LineHeight) * 0.5f
             : 1f;
diff --git a/tests/AcDream.App.Tests/UI/ListButtonColumnTests.cs b/tests/AcDream.App.Tests/UI/ListButtonColumnTests.cs
index 78f147728..c6fb50fd4 100644
--- a/tests/AcDream.App.Tests/UI/ListButtonColumnTests.cs
+++ b/tests/AcDream.App.Tests/UI/ListButtonColumnTests.cs
@@ -309,6 +309,260 @@ public void SizedButton_NeverGrowsPastItsCell()
         Assert.All(faceVerts, v => Assert.InRange(v[1], 1f, 19f));
     }
 
+    // ── A press names the row it went down on ───────────
+
+    private sealed class LiveRows
+    {
+        public string[] Names = { "a", "b", "c", "d", "e" };
+        public string[] Captions = { "Go", "Go", "Go", "Go", "Go" };
+        public List<int> Acted { get; } = new();
+    }
+
+    /// <summary>A 60-high list of 20-high rows (three visible), names in x = 0..50, buttons in 50..84.</summary>
+    private static UiMarkupList MakeLiveList(LiveRows rows)
+    {
+        var list = new UiMarkupList
+        {
+            Width = 100f, Height = 60f, RowHeight = 20f,
+            SelectedIndexSource = () => -1,
+            BackgroundColor = default, BorderColor = default,
+            Columns = new[]
+            {
+                // Fresh arrays every read, the way a markup binding hands them over.
+                UiMarkupListColumn.Text(50f, () => rows.Names.ToArray(), null),
+                UiMarkupListColumn.Button(50f, () => rows.Captions.ToArray(), row => rows.Acted.Add(row)),
+            },
+        };
+        Draw(list);
+        return list;
+    }
+
+    private static void Draw(UiMarkupList list)
+    {
+        var (_, ctx) = MakeContext(200f, 200f);
+        list.DrawSelfAndChildren(ctx);
+    }
+
+    private static UiEvent At(int type, int x, int y) => new() { Type = type, Data1 = x, Data2 = y };
+
+    [Fact]
+    public void RowsRedrawnWithTheSameContent_StillFire()
+    {
+        var rows = new LiveRows();
+        var list = MakeLiveList(rows);
+
+        list.OnEvent(At(UiEventType.MouseDown, 60, 25));
+        Draw(list);
+        list.OnEvent(At(UiEventType.MouseUp, 60, 25));
+
+        Assert.Equal(new[] { 1 }, rows.Acted);
+    }
+
+    [Fact]
+    public void RowRemovedAboveThePress_BeforeRelease_DoesNotFireForTheRowThatMovedIn()
+    {
+        var rows = new LiveRows();
+        var list = MakeLiveList(rows);
+
+        list.OnEvent(At(UiEventType.MouseDown, 60, 25));       // row 1, "b"
+        rows.Names = new[] { "b", "c", "d", "e" };             // "a" goes; "c" is now row 1
+        rows.Captions = new[] { "Go", "Go", "Go", "Go" };
+        list.OnEvent(At(UiEventType.MouseUp, 60, 25));
+
+        Assert.Empty(rows.Acted);
+    }
+
+    [Fact]
+    public void RowsReorderedBeforeRelease_DoesNotFire_EvenWithNoDrawBetween()
+    {
+        var rows = new LiveRows();
+        var list = MakeLiveList(rows);
+
+        list.OnEvent(At(UiEventType.MouseDown, 60, 25));       // row 1, "b"
+        rows.Names = new[] { "a", "c", "b", "d", "e" };        // same count, "c" is now row 1
+        list.OnEvent(At(UiEventType.MouseUp, 60, 25));
+
+        Assert.Empty(rows.Acted);
+    }
+
+    [Fact]
+    public void RowsChangedWhilePressed_DropThePressedLookAtTheNextDraw()
+    {
+        var rows = new LiveRows();
+        var list = MakeLiveList(rows);
+
+        list.OnEvent(At(UiEventType.MouseDown, 60, 25));
+        Assert.Equal(UiControlState.Pressed, list.ButtonStateForTest(1, 1));
+        rows.Names = new[] { "a", "c", "b", "d", "e" };
+        Draw(list);
+
+        Assert.Equal(UiControlState.Hovered, list.ButtonStateForTest(1, 1));
+    }
+
+    [Fact]
+    public void ListScrolledWhilePressed_DoesNotFire()
+    {
+        var rows = new LiveRows();
+        var list = MakeLiveList(rows);
+
+        list.OnEvent(At(UiEventType.MouseDown, 60, 25));       // row 1
+        list.OnEvent(new UiEvent { Type = UiEventType.Scroll, Data0 = -1, Data1 = 60, Data2 = 25 });
+        // Row 1 is now drawn at y = 0..20; release on it there.
+        list.OnEvent(At(UiEventType.MouseUp, 60, 5));
+
+        Assert.Empty(rows.Acted);
+    }
+
+    [Fact]
+    public void WheelScroll_WithNoPointerMove_MovesTheHoverToTheButtonNowUnderThePointer()
+    {
+        var rows = new LiveRows();
+        var list = MakeLiveList(rows);
+        var root = new UiRoot { Width = 800, Height = 600 };
+        root.AddChild(list);
+
+        root.OnMouseMove(60, 5);
+        Assert.Equal(UiControlState.Hovered, list.ButtonStateForTest(0, 1));
+
+        root.OnScroll(-1);
+
+        Assert.Equal(UiControlState.Normal, list.ButtonStateForTest(0, 1));
+        Assert.Equal(UiControlState.Hovered, list.ButtonStateForTest(1, 1));
+    }
+
+    [Fact]
+    public void ThroughUiRoot_PressAndRelease_FiresOnce()
+    {
+        var rows = new LiveRows();
+        var list = MakeLiveList(rows);
+        var root = new UiRoot { Width = 800, Height = 600 };
+        root.AddChild(list);
+
+        root.OnMouseMove(60, 45);
+        root.OnMouseDown(UiMouseButton.Left, 60, 45);
+        root.OnMouseUp(UiMouseButton.Left, 60, 45);
+
+        Assert.Equal(new[] { 2 }, rows.Acted);
+    }
+
+    [Fact]
+    public void ThroughUiRoot_CaptureTakenAway_ClearsThePress()
+    {
+        var rows = new LiveRows();
+        var list = MakeLiveList(rows);
+        var other = new UiPanel { Left = 300, Top = 300, Width = 20, Height = 20 };
+        var root = new UiRoot { Width = 800, Height = 600 };
+        root.AddChild(list);
+        root.AddChild(other);
+
+        root.OnMouseMove(60, 45);
+        root.OnMouseDown(UiMouseButton.Left, 60, 45);
+        Assert.Same(list, root.Captured);
+        Assert.Equal(UiControlState.Pressed, list.ButtonStateForTest(2, 1));
+
+        root.SetCapture(other);
+
+        Assert.NotEqual(UiControlState.Pressed, list.ButtonStateForTest(2, 1));
+        list.OnEvent(At(UiEventType.MouseUp, 60, 45));
+        Assert.Empty(rows.Acted);
+    }
+
+    [Fact]
+    public void DisabledList_DoesNotFire()
+    {
+        var acted = new List<int>();
+        var list = MakeList(acted, new List<int>());
+        list.Enabled = false;
+
+        list.OnEvent(At(UiEventType.MouseDown, 70, 5));
+        list.OnEvent(At(UiEventType.MouseUp, 70, 5));
+
+        Assert.Empty(acted);
+    }
+
+    [Fact]
+    public void ListDisabledWhilePressed_DoesNotFire_EvenIfEnabledAgainBeforeRelease()
+    {
+        var acted = new List<int>();
+        var list = MakeList(acted, new List<int>());
+
+        list.OnEvent(At(UiEventType.MouseDown, 70, 5));
+        list.Enabled = false;
+        list.Enabled = true;
+        list.OnEvent(At(UiEventType.MouseUp, 70, 5));
+
+        Assert.Empty(acted);
+    }
+
+    // ── Drawing ───────────
+
+    [Fact]
+    public void DisabledList_DrawsItsButtonFaceAndBorderFaded()
+    {
+        var face = new Vector4(0.2f, 0.4f, 0.6f, 1f);
+        var border = new Vector4(0.7f, 0.1f, 0.3f, 1f);
+        var list = new UiMarkupList
+        {
+            Width = 100f, Height = 60f, RowHeight = 20f,
+            SelectedIndexSource = () => -1,
+            BackgroundColor = default, BorderColor = default,
+            ButtonColor = face, ButtonBorderColor = border,
+            Enabled = false,
+            Columns = new[]
+            {
+                UiMarkupListColumn.Text(50f, () => new[] { "a" }, null),
+                UiMarkupListColumn.Button(50f, () => new[] { "Go" }, _ => { }),
+            },
+        };
+        var (renderer, ctx) = MakeContext(200f, 200f);
+        list.DrawSelfAndChildren(ctx);
+
+        var verts = renderer.DebugSpriteSegmentVerts
+            .Where(s => s.Texture == 0u)
+            .SelectMany(s => Chunk(s.Verts))
+            .ToList();
+        float faded = UiMarkupToggle.DisabledAlpha;
+        Assert.Contains(verts, v => ColorMatches(v, face with { W = faded }));
+        Assert.Contains(verts, v => ColorMatches(v, border with { W = faded }));
+        Assert.DoesNotContain(verts, v => ColorMatches(v, face));
+        Assert.DoesNotContain(verts, v => ColorMatches(v, border));
+    }
+
+    [Fact]
+    public void CaptionWiderThanItsButton_IsCutAtTheButtonEdges()
+    {
+        var glyphs = new Dictionary<char, DatReaderWriter.Types.FontCharDesc>
+        {
+            ['W'] = new DatReaderWriter.Types.FontCharDesc { Unicode = 'W', Width = 8, Height = 8 },
+        };
+        var font = new UiDatFont(
+            fgTex: 1u, fgW: 32, fgH: 32,
+            bgTex: 0, bgW: 0, bgH: 0,
+            lineHeight: 16f, baselineOffset: 12f,
+            glyphs);
+        var list = new UiMarkupList
+        {
+            Width = 100f, Height = 60f, RowHeight = 20f, DatFont = font,
+            SelectedIndexSource = () => -1,
+            BackgroundColor = default, BorderColor = default,
+            Columns = new[]
+            {
+                UiMarkupListColumn.Text(50f, () => new[] { "" }, null),
+                // Cell x = 50..100; a 20-wide button sits at x = 65..85. The caption is 80 wide.
+                UiMarkupListColumn.Button(50f, () => new[] { "WWWWWWWWWW" }, _ => { }, buttonWidth: 20f),
+            },
+        };
+        var (renderer, ctx) = MakeContext(200f, 200f);
+        list.DrawSelfAndChildren(ctx);
+
+        var glyphVerts = renderer.DebugSpriteSegmentVerts
+            .Where(s => s.Texture == 1u)
+            .SelectMany(s => Chunk(s.Verts))
+            .ToList();
+        Assert.NotEmpty(glyphVerts);
+        Assert.All(glyphVerts, v => Assert.InRange(v[0], 65f - 0.01f, 85f + 0.01f));
+    }
+
     private static IEnumerable<float[]> Chunk(IReadOnlyList<float> verts)
     {
         for (int i = 0; i + 8 <= verts.Count; i += 8)

From e58b78f8e64420cbd81df52e229b12c09936a453 Mon Sep 17 00:00:00 2001
From: Erik <erik.nihlen@gmail.com>
Date: Mon, 19 Oct 2026 18:13:21 +0200
Subject: [PATCH 4/4] fix(markup): a list button's press survives changes in
 other columns

Comparing the whole pressed row cancelled presses in lists with a live
column: a distance that updates every frame changed the row between press
and release, so the button beside it fired only now and then. The press is
now cancelled only when the list scrolls, its row count changes, or the
pressed button's own caption changes or becomes empty. Disabling the list
while the button is held still cancels it.

The docs say so, and note that a plugin which reorders rows without
changing the count should change the caption too. A new test has a
different column change between press and release and still fire; it fails
on the previous commit.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/plugin-ui-markup.md                      |  8 ++--
 src/AcDream.App/UI/UiMarkupList.cs            | 42 +++++--------------
 .../UI/ListButtonColumnTests.cs               | 40 +++++++++++++++---
 3 files changed, 51 insertions(+), 39 deletions(-)

diff --git a/docs/plugin-ui-markup.md b/docs/plugin-ui-markup.md
index 95513d0e8..0c17e932e 100644
--- a/docs/plugin-ui-markup.md
+++ b/docs/plugin-ui-markup.md
@@ -360,9 +360,11 @@ It fires like a `<button>`, when the left button comes up over the button it
 went down on, so a press dragged off the button cancels it; a click beside a
 smaller button does nothing. Because `onclick` gets a row index, a press is
 also cancelled if, before the release, the list scrolls, its row count changes,
-or the pressed row's text, caption or icon changes; a `check` value changing
-does not cancel it. A cell with an empty caption is not a button and ignores
-clicks.
+or the pressed button's own caption changes or becomes empty. Changes in the
+row's other columns, such as a distance that updates every frame, do not
+cancel it, so a plugin that reorders rows with the same count should change
+the caption too, or the click fires for whatever item is at the pressed row.
+A cell with an empty caption is not a button and ignores clicks.
 On a host older than button columns, a `type="button"` column fails the build
 of its window as an unknown type.
 
diff --git a/src/AcDream.App/UI/UiMarkupList.cs b/src/AcDream.App/UI/UiMarkupList.cs
index e8196cbde..0caab39b1 100644
--- a/src/AcDream.App/UI/UiMarkupList.cs
+++ b/src/AcDream.App/UI/UiMarkupList.cs
@@ -29,8 +29,6 @@ public IReadOnlyList<UiMarkupListColumn>? Columns
             _scratchIsAuto = new bool[count];
             _scratchFixedWidth = new float[count];
             _cachedRowCount = 0;
-            _pressRowText = new string?[count];
-            _pressRowIcon = new uint[count];
             _hasButtons = value?.Any(static c => c.Kind == UiMarkupListColumnKind.Button) ?? false;
             ClearButtonPointer();
         }
@@ -84,10 +82,9 @@ public IReadOnlyList<UiMarkupListColumn>? Columns
 
     // What the list showed when the button went down: a release fires by row
     // index, so the press is dropped if the list scrolls, its row count
-    // changes, or the pressed row's text, caption or icon changes before then.
+    // changes, or the pressed button's caption changes before then.
     private int _pressTopRow, _pressRowCount;
-    private string?[] _pressRowText = Array.Empty<string?>();
-    private uint[] _pressRowIcon = Array.Empty<uint>();
+    private string _pressCaption = string.Empty;
 
     // The pointer's last position in list space, so the hovered button can be
     // found again when the rows move under a pointer that did not.
@@ -576,45 +573,28 @@ private void RememberPressedRow()
     {
         _pressTopRow = _topRow;
         _pressRowCount = _cachedRowCount;
-        for (int c = 0; c < _pressRowText.Length; c++)
-        {
-            _pressRowText[c] = PressedRowText(c);
-            _pressRowIcon[c] = PressedRowIcon(c);
-        }
+        HasButtonCaption(_pressColumn, _pressRow, out _pressCaption);
     }
 
     /// <summary>
     /// Drops the press when the row under it may no longer be the item that was
-    /// pressed: the list scrolled, its row count changed, or the pressed row's
-    /// text, caption or icon changed. Check values are the row's state, not
-    /// which item it is, so they do not count.
+    /// pressed: the list scrolled, its row count changed, or the pressed
+    /// button's caption changed or went empty. Other columns are left out on
+    /// purpose: a live column such as a distance changes every frame and would
+    /// make the buttons beside it unreliable.
     /// </summary>
     private void CancelPressIfRowsMoved()
     {
         if (_pressRow < 0)
             return;
-        bool moved = _topRow != _pressTopRow || _cachedRowCount != _pressRowCount;
-        for (int c = 0; !moved && c < _pressRowText.Length; c++)
-        {
-            moved = !string.Equals(PressedRowText(c), _pressRowText[c], StringComparison.Ordinal)
-                || PressedRowIcon(c) != _pressRowIcon[c];
-        }
+        bool moved = _topRow != _pressTopRow
+            || _cachedRowCount != _pressRowCount
+            || !HasButtonCaption(_pressColumn, _pressRow, out string caption)
+            || !string.Equals(caption, _pressCaption, StringComparison.Ordinal);
         if (moved)
             _pressRow = _pressColumn = -1;
     }
 
-    private string? PressedRowText(int column) =>
-        _columns![column].Kind is UiMarkupListColumnKind.Text or UiMarkupListColumnKind.Button
-            && _cachedTextRows[column] is { } texts && _pressRow < texts.Count
-            ? texts[_pressRow]
-            : null;
-
-    private uint PressedRowIcon(int column) =>
-        _columns![column].Kind == UiMarkupListColumnKind.Icon
-            && _cachedIconRows[column] is { } icons && _pressRow < icons.Count
-            ? icons[_pressRow]
-            : 0u;
-
     /// <summary>
     /// Follows the pointer over button cells and fires a button when the left
     /// button comes up over the one it went down on. Only a release that fires
diff --git a/tests/AcDream.App.Tests/UI/ListButtonColumnTests.cs b/tests/AcDream.App.Tests/UI/ListButtonColumnTests.cs
index c6fb50fd4..e1dcb14c6 100644
--- a/tests/AcDream.App.Tests/UI/ListButtonColumnTests.cs
+++ b/tests/AcDream.App.Tests/UI/ListButtonColumnTests.cs
@@ -373,27 +373,57 @@ public void RowRemovedAboveThePress_BeforeRelease_DoesNotFireForTheRowThatMovedI
     }
 
     [Fact]
-    public void RowsReorderedBeforeRelease_DoesNotFire_EvenWithNoDrawBetween()
+    public void PressedButtonsCaptionChangedBeforeRelease_DoesNotFire_EvenWithNoDrawBetween()
     {
         var rows = new LiveRows();
         var list = MakeLiveList(rows);
 
-        list.OnEvent(At(UiEventType.MouseDown, 60, 25));       // row 1, "b"
-        rows.Names = new[] { "a", "c", "b", "d", "e" };        // same count, "c" is now row 1
+        list.OnEvent(At(UiEventType.MouseDown, 60, 25));       // row 1
+        rows.Captions = new[] { "Go", "Stop", "Go", "Go", "Go" };
+        list.OnEvent(At(UiEventType.MouseUp, 60, 25));
+
+        Assert.Empty(rows.Acted);
+    }
+
+    [Fact]
+    public void PressedButtonsCaptionEmptiedBeforeRelease_DoesNotFire()
+    {
+        var rows = new LiveRows();
+        var list = MakeLiveList(rows);
+
+        list.OnEvent(At(UiEventType.MouseDown, 60, 25));       // row 1
+        rows.Captions = new[] { "Go", "", "Go", "Go", "Go" };
+        Draw(list);
+        rows.Captions = new[] { "Go", "Go", "Go", "Go", "Go" };
         list.OnEvent(At(UiEventType.MouseUp, 60, 25));
 
         Assert.Empty(rows.Acted);
     }
 
     [Fact]
-    public void RowsChangedWhilePressed_DropThePressedLookAtTheNextDraw()
+    public void OtherColumnChangedBetweenPressAndRelease_StillFires()
+    {
+        var rows = new LiveRows();
+        var list = MakeLiveList(rows);
+
+        list.OnEvent(At(UiEventType.MouseDown, 60, 25));       // row 1
+        rows.Names = new[] { "a", "b 12.3m", "c", "d", "e" };  // a live column ticks
+        Draw(list);
+        rows.Names = new[] { "a", "b 11.9m", "c", "d", "e" };
+        list.OnEvent(At(UiEventType.MouseUp, 60, 25));
+
+        Assert.Equal(new[] { 1 }, rows.Acted);
+    }
+
+    [Fact]
+    public void ButtonCaptionChangedWhilePressed_DropsThePressedLookAtTheNextDraw()
     {
         var rows = new LiveRows();
         var list = MakeLiveList(rows);
 
         list.OnEvent(At(UiEventType.MouseDown, 60, 25));
         Assert.Equal(UiControlState.Pressed, list.ButtonStateForTest(1, 1));
-        rows.Names = new[] { "a", "c", "b", "d", "e" };
+        rows.Captions = new[] { "Go", "Stop", "Go", "Go", "Go" };
         Draw(list);
 
         Assert.Equal(UiControlState.Hovered, list.ButtonStateForTest(1, 1));