From 35603d3f8f41be48b4a2bbdabebe3b0efce3b9b8 Mon Sep 17 00:00:00 2001 From: Harry Cordewener Date: Tue, 28 Jul 2026 15:32:59 -0500 Subject: [PATCH 01/23] F2 Triggers: apply the F5 panel treatment Decomposes TriggersScreenRenderer into pure blocks (HeaderLine, FooterLine, RulesColumn, EditorColumn) and adds TriggersScreenView to compose them into a real control tree: full-width header band with keyboard hints, two column panels split by a vertical rule, and a Cancel/Save action bar pinned to the last row instead of floating mid-screen after the content. Render(...) still merges the same blocks, so the existing renderer tests pass untouched. Also fixes a latent bug in WorldsScreenView: VerticalRule() built a MarkupControl over an empty line list, which measures to zero and so never painted its background -- F5's column rule has never actually rendered. An empty grid with a background covers its arranged area. Baseline worlds frame contained 0 cells of the rule colour; it now has 22, with the rest of the frame unchanged. Generalises the settings wiring rather than special-casing a second screen: SettingsView returns a control factory for every screen, so the snapshot path needs no per-screen branch as the remaining six convert. Co-Authored-By: Claude Opus 5 (1M context) --- src/SharpMUTerm.Tui/SettingsOverlay.cs | 32 ++--- src/SharpMUTerm.Tui/SharpMUTermApp.cs | 61 +++++---- src/SharpMUTerm.Tui/TriggersScreenRenderer.cs | 125 ++++++++++++++---- src/SharpMUTerm.Tui/TriggersScreenView.cs | 87 ++++++++++++ src/SharpMUTerm.Tui/WorldsScreenView.cs | 16 ++- 5 files changed, 246 insertions(+), 75 deletions(-) create mode 100644 src/SharpMUTerm.Tui/TriggersScreenView.cs diff --git a/src/SharpMUTerm.Tui/SettingsOverlay.cs b/src/SharpMUTerm.Tui/SettingsOverlay.cs index b430f3da..eea6325f 100644 --- a/src/SharpMUTerm.Tui/SettingsOverlay.cs +++ b/src/SharpMUTerm.Tui/SettingsOverlay.cs @@ -8,9 +8,10 @@ namespace SharpMUTerm.Tui; /// /// A full-screen overlay hosting the F2–F9 settings screens. The design specifies these as /// full-screen surfaces, not floating dialogs: this maximises a frameless modal (no title bar, -/// buttons, or resize grip) with a deep panel background. Most screens are a single markup panel; -/// F5 supplies a composed control tree (real panels). Esc (or the same F-key) closes it. The -/// renderers stay pure and tested; this is a thin host. +/// buttons, or resize grip) with a deep panel background. Every screen supplies a control: the +/// converted ones (F2, F5) a composed tree of real panels, the rest a single +/// wrapping their markup. Esc (or the same F-key) closes it. The renderers stay pure and tested; +/// this is a thin host. /// internal sealed class SettingsOverlay { @@ -29,20 +30,19 @@ internal sealed class SettingsOverlay public bool IsOpen => _window is not null; - /// Toggles a markup screen (wrapped in a full-screen panel). - public void Toggle(ConsoleKey key, Func> content) => - ToggleControl(key, () => MarkupPanel(content())); - - /// Toggles a composed-control screen (e.g. F5's real-panel layout). + /// Toggles a screen (a composed control tree, or a ). public void Toggle(ConsoleKey key, Func control) => ToggleControl(key, control); - /// Renders a markup screen into a headless frame (used by snapshots). - public void OpenForSnapshot(ConsoleKey key, Func> content) => - Open(key, () => MarkupPanel(content())); - - /// Renders a composed-control screen into a headless frame (used by snapshots). + /// Renders a screen into a headless frame (used by snapshots). public void OpenForSnapshot(ConsoleKey key, Func control) => Open(key, control); + /// Wraps a screen that is still one markup block in the full-screen panel. + public static MarkupControl MarkupPanel(IReadOnlyList lines) => new(lines.ToList()) + { + BackgroundColor = new Color(PanelBg), + HorizontalAlignment = HorizontalAlignment.Stretch, + }; + private void ToggleControl(ConsoleKey key, Func factory) { if (_window is not null && _openKey == key) @@ -76,12 +76,6 @@ private void Open(ConsoleKey key, Func factory) _system.AddWindow(_window); } - private static MarkupControl MarkupPanel(IReadOnlyList lines) => new(lines.ToList()) - { - BackgroundColor = new Color(PanelBg), - HorizontalAlignment = HorizontalAlignment.Stretch, - }; - private void OnKey(object? sender, KeyPressedEventArgs e) { if (e.KeyInfo.Key == ConsoleKey.Escape || e.KeyInfo.Key == _openKey) diff --git a/src/SharpMUTerm.Tui/SharpMUTermApp.cs b/src/SharpMUTerm.Tui/SharpMUTermApp.cs index 7045ccfe..cecf6a54 100644 --- a/src/SharpMUTerm.Tui/SharpMUTermApp.cs +++ b/src/SharpMUTerm.Tui/SharpMUTermApp.cs @@ -291,15 +291,11 @@ public string RenderSnapshot(string? view = null) _palette.Toggle(); } - // F5 Worlds & Characters is a composed-control screen (real panels); others are markup. - if (string.Equals(view, "worlds", StringComparison.OrdinalIgnoreCase) || - string.Equals(view, "settings", StringComparison.OrdinalIgnoreCase)) + // Settings screens (composed-control or markup — SettingsView hands back a control factory + // either way) open over the workspace for their --view name. + if (view is not null && SettingsView(view) is { } screen) { - _settings.OpenForSnapshot(ConsoleKey.F5, WorldsControl); - } - else if (view is not null && SettingsView(view) is { } screen) - { - _settings.OpenForSnapshot(screen.Key, screen.Content); + _settings.OpenForSnapshot(screen.Key, screen.Control); } // Render exactly one frame, synchronously, inline on this thread. ForceRender() performs a @@ -723,17 +719,17 @@ private void RefreshStatusBar() /// private void RegisterSettingsShortcuts() { - void Bind(ConsoleKey key, Func> content) => - _system.RegisterGlobalShortcut((ConsoleModifiers)0, key, () => _settings.Toggle(key, content)); + void Bind(ConsoleKey key, Func control) => + _system.RegisterGlobalShortcut((ConsoleModifiers)0, key, () => _settings.Toggle(key, control)); - Bind(ConsoleKey.F2, () => TriggersScreenRenderer.Render(_config.TriggerSets, 0, SpawnTargets())); - Bind(ConsoleKey.F3, () => AliasesScreenRenderer.Render(_config.TriggerSets, 0)); - Bind(ConsoleKey.F4, () => KeypadScreenRenderer.Render(Macros())); - _system.RegisterGlobalShortcut((ConsoleModifiers)0, ConsoleKey.F5, () => _settings.Toggle(ConsoleKey.F5, WorldsControl)); - Bind(ConsoleKey.F6, () => TimersScreenRenderer.Render(_config.TriggerSets, 0)); - Bind(ConsoleKey.F7, OptionsScreenRenderer.TextAnsi); - Bind(ConsoleKey.F8, OptionsScreenRenderer.InputSpellcheck); - Bind(ConsoleKey.F9, () => OptionsScreenRenderer.Logging(ActiveLogging())); + Bind(ConsoleKey.F2, TriggersControl); + Bind(ConsoleKey.F3, Markup(() => AliasesScreenRenderer.Render(_config.TriggerSets, 0))); + Bind(ConsoleKey.F4, Markup(() => KeypadScreenRenderer.Render(Macros()))); + Bind(ConsoleKey.F5, WorldsControl); + Bind(ConsoleKey.F6, Markup(() => TimersScreenRenderer.Render(_config.TriggerSets, 0))); + Bind(ConsoleKey.F7, Markup(OptionsScreenRenderer.TextAnsi)); + Bind(ConsoleKey.F8, Markup(OptionsScreenRenderer.InputSpellcheck)); + Bind(ConsoleKey.F9, Markup(() => OptionsScreenRenderer.Logging(ActiveLogging()))); } /// Distinct spawn-window targets referenced by any trigger (for the F2 route-to list). @@ -790,20 +786,29 @@ private LoggingSettings ActiveLogging() return world?.Characters.ElementAtOrDefault(ActiveCharacterIndex())?.Logging ?? new LoggingSettings(); } - /// Maps a --view name to a settings screen (F-key + content) for snapshots. /// Builds the F5 Worlds & Characters screen as a composed control tree (real panels). private IWindowControl WorldsControl() => WorldsScreenView.Build( _config.Worlds, _config.TriggerSets, ActiveWorldIndex(), ActiveCharacterIndex(), _system.DesktopDimensions.Width); - private (ConsoleKey Key, Func> Content)? SettingsView(string view) => view.ToLowerInvariant() switch - { - "triggers" => (ConsoleKey.F2, () => TriggersScreenRenderer.Render(_config.TriggerSets, 0, SpawnTargets())), - "aliases" => (ConsoleKey.F3, () => AliasesScreenRenderer.Render(_config.TriggerSets, 0)), - "keypad" => (ConsoleKey.F4, () => KeypadScreenRenderer.Render(Macros())), - "timers" => (ConsoleKey.F6, () => TimersScreenRenderer.Render(_config.TriggerSets, 0)), - "textansi" => (ConsoleKey.F7, OptionsScreenRenderer.TextAnsi), - "input" => (ConsoleKey.F8, OptionsScreenRenderer.InputSpellcheck), - "logging" => (ConsoleKey.F9, () => OptionsScreenRenderer.Logging(ActiveLogging())), + /// Builds the F2 Triggers & spawn routing screen as a composed control tree (real panels). + private IWindowControl TriggersControl() => TriggersScreenView.Build( + _config.TriggerSets, 0, SpawnTargets(), _system.DesktopDimensions.Width); + + /// Hosts a screen that is still one markup block in the overlay's full-screen panel. + private static Func Markup(Func> content) => + () => SettingsOverlay.MarkupPanel(content()); + + /// Maps a --view name to a settings screen (F-key + control factory) for snapshots. + private (ConsoleKey Key, Func Control)? SettingsView(string view) => view.ToLowerInvariant() switch + { + "triggers" => (ConsoleKey.F2, TriggersControl), + "aliases" => (ConsoleKey.F3, Markup(() => AliasesScreenRenderer.Render(_config.TriggerSets, 0))), + "keypad" => (ConsoleKey.F4, Markup(() => KeypadScreenRenderer.Render(Macros()))), + "worlds" or "settings" => (ConsoleKey.F5, WorldsControl), + "timers" => (ConsoleKey.F6, Markup(() => TimersScreenRenderer.Render(_config.TriggerSets, 0))), + "textansi" => (ConsoleKey.F7, Markup(OptionsScreenRenderer.TextAnsi)), + "input" => (ConsoleKey.F8, Markup(OptionsScreenRenderer.InputSpellcheck)), + "logging" => (ConsoleKey.F9, Markup(() => OptionsScreenRenderer.Logging(ActiveLogging()))), _ => null, }; diff --git a/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs b/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs index c18ef9ad..82f8a029 100644 --- a/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs @@ -1,3 +1,4 @@ +using System.Globalization; using System.Text.RegularExpressions; using SharpMUTerm.Core.Automation; using SharpMUTerm.Core.Configuration; @@ -6,19 +7,33 @@ namespace SharpMUTerm.Tui; /// -/// Renders the F2 "Triggers & spawn routing" screen: a left rule list (flattened across every -/// , each row carrying its enabled state, name/pattern, owning set, action -/// flags, and route) merged column-by-column with a right-hand editor for the selected trigger -/// (pattern, route-to list, highlight swatches, and toggles). Pure so the screen is unit-testable; -/// the modal host just displays what this produces. +/// Produces the markup sub-blocks for the F2 Triggers & spawn routing screen — the header band, +/// the rule list (flattened across every , each row carrying its enabled +/// state, name/pattern, owning set, action flags, and route), the editor for the selected trigger +/// (pattern, route-to list, highlight swatches, and toggles), and the footer action bar. +/// composes these into real panels (grids) for the live/snapshot +/// view; merges the same blocks into a single line list for the unit tests. +/// Pure so every block is testable. /// internal static class TriggersScreenRenderer { private const string Accent = "#00f5b7"; private const int ColumnWidth = 54; + // Palette shared with the view (which sets these as control backgrounds). + internal const string HeaderBg = "#232b3d"; + internal const string FooterBg = "#232b3d"; + private const string Label = "#7c8699"; + private const string Value = "#d7deec"; + private const string Ink = "#0f1620"; + private static readonly Regex TagPattern = new(@"\[[^\[\]]*\]", RegexOptions.Compiled); + /// + /// Merges every sub-block into one line list (header, rule list | editor, footer). Used by the + /// unit tests and as a width-agnostic fallback; the live view composes the same blocks into + /// panels instead. + /// public static List Render( IReadOnlyList sets, int selectedTrigger, @@ -27,25 +42,10 @@ public static List Render( ArgumentNullException.ThrowIfNull(sets); ArgumentNullException.ThrowIfNull(spawnTargets); - var flattened = new List<(Trigger Trigger, string SetName)>(); - foreach (var set in sets) - { - foreach (var trigger in set.Triggers) - { - flattened.Add((trigger, set.Name)); - } - } + var left = RulesColumn(sets, selectedTrigger); + var right = EditorColumn(sets, selectedTrigger, spawnTargets); - var left = BuildLeft(flattened, selectedTrigger); - var right = selectedTrigger >= 0 && selectedTrigger < flattened.Count - ? BuildEditor(flattened[selectedTrigger].Trigger, spawnTargets) - : new List(); - - var lines = new List - { - "[dim]‹ back[/] [bold]Triggers & spawn routing[/] [dim]F2[/]", - string.Empty, - }; + var lines = new List { HeaderLine(0), string.Empty }; var rowCount = Math.Max(left.Count, right.Count); for (var i = 0; i < rowCount; i++) @@ -56,15 +56,41 @@ public static List Render( } lines.Add(string.Empty); - lines.Add("[dim][[Cancel]] [[Save]][/]"); + lines.Add(FooterLine(sets, selectedTrigger, 0)); return lines; } - private static List BuildLeft( - IReadOnlyList<(Trigger Trigger, string SetName)> flattened, - int selectedTrigger) + /// The screen title on the left, the keyboard hints right-aligned to . + internal static string HeaderLine(int width) + { + var title = $"[bold {Value}] Triggers & spawn routing[/]"; + var hints = $"[{Label}]↑↓ select · ⇥ switch pane · ⏎ edit · [/][{Accent}]Esc[/][{Label}] close [/]"; + return SpreadLR(" " + title, hints, width); + } + + /// The action bar: which rule is selected on the left, cancel/save on the right. + internal static string FooterLine(IReadOnlyList sets, int selectedTrigger, int width) { + var flattened = Flatten(sets); + var context = string.Empty; + if (flattened.Count > 0 && selectedTrigger >= 0 && selectedTrigger < flattened.Count) + { + var count = flattened.Count.ToString(CultureInfo.InvariantCulture); + context = $"[{Label}]trigger {(selectedTrigger + 1).ToString(CultureInfo.InvariantCulture)}/{count}[/]" + + $"[{Label}] · set {Escape(flattened[selectedTrigger].SetName)}[/]"; + } + + var actions = $"[{Label}] [[Esc]] Cancel [/] [{Ink} on {Accent}] [[⏎]] Save [/] "; + return SpreadLR(" " + context, actions, width); + } + + /// The rule list — every trigger of every set, each over a set/flags sub-row. + internal static List RulesColumn(IReadOnlyList sets, int selectedTrigger) + { + ArgumentNullException.ThrowIfNull(sets); + + var flattened = Flatten(sets); var left = new List { "[dim]on name / pattern → window[/]" }; if (flattened.Count == 0) @@ -83,6 +109,39 @@ private static List BuildLeft( return left; } + /// + /// The editor for the selected rule — pattern, route-to list, highlight swatches, and toggles. + /// Empty when nothing is selected. + /// + internal static List EditorColumn( + IReadOnlyList sets, + int selectedTrigger, + IReadOnlyList spawnTargets) + { + ArgumentNullException.ThrowIfNull(sets); + ArgumentNullException.ThrowIfNull(spawnTargets); + + var flattened = Flatten(sets); + return selectedTrigger >= 0 && selectedTrigger < flattened.Count + ? BuildEditor(flattened[selectedTrigger].Trigger, spawnTargets) + : new List(); + } + + /// Flattens every set's triggers into one list, each paired with its owning set's name. + private static List<(Trigger Trigger, string SetName)> Flatten(IReadOnlyList sets) + { + var flattened = new List<(Trigger Trigger, string SetName)>(); + foreach (var set in sets) + { + foreach (var trigger in set.Triggers) + { + flattened.Add((trigger, set.Name)); + } + } + + return flattened; + } + private static string RuleRow(int index, int selectedTrigger, Trigger trigger) { var marker = index == selectedTrigger ? "[bold]▸[/]" : " "; @@ -180,6 +239,18 @@ private static string RouteRow(string label, string currentRoute) private static string Hex(TerminalColor color) => color.Kind == TerminalColorKind.Rgb ? $"#{color.R:x2}{color.G:x2}{color.B:x2}" : Accent; + /// Lays a left- and right-hand fragment on one line, right-aligning the right to . + private static string SpreadLR(string left, string right, int width) + { + if (width <= 0) + { + return $"{left} {right}"; + } + + var gap = Math.Max(1, width - VisibleLength(left) - VisibleLength(right)); + return left + new string(' ', gap) + right; + } + /// Pads a markup string to a target *visible* column width, ignoring markup tags. private static string PadVisible(string markup, int width) { diff --git a/src/SharpMUTerm.Tui/TriggersScreenView.cs b/src/SharpMUTerm.Tui/TriggersScreenView.cs new file mode 100644 index 00000000..7173d002 --- /dev/null +++ b/src/SharpMUTerm.Tui/TriggersScreenView.cs @@ -0,0 +1,87 @@ +using SharpMUTerm.Core.Configuration; +using SharpConsoleUI; +using SharpConsoleUI.Builders; +using SharpConsoleUI.Controls; +using SharpConsoleUI.Layout; + +namespace SharpMUTerm.Tui; + +/// +/// Composes the F2 Triggers & spawn routing screen from real panels (grids) rather than one +/// merged markup blob: a header band carrying the keyboard hints, a body whose rule-list panel and +/// editor panel are separated by a vertical rule, and a Cancel/Save action bar pinned to the last +/// row. The markup for each panel comes from the pure so the +/// content stays unit-tested; this only lays it out. +/// +internal static class TriggersScreenView +{ + private const string RuleColor = "#3a4257"; + private const int RulesColumnWidth = 56; + + public static IWindowControl Build( + IReadOnlyList sets, + int selectedTrigger, + IReadOnlyList spawnTargets, + int width) + { + var header = Band(TriggersScreenRenderer.HeaderLine(width), TriggersScreenRenderer.HeaderBg); + var footer = Band( + TriggersScreenRenderer.FooterLine(sets, selectedTrigger, width), TriggersScreenRenderer.FooterBg); + + // Body: rule list │ editor, as two real columns. + var rulesCol = Stretch(new MarkupControl(TriggersScreenRenderer.RulesColumn(sets, selectedTrigger))); + var editorCol = Stretch(new MarkupControl( + Indent(TriggersScreenRenderer.EditorColumn(sets, selectedTrigger, spawnTargets)))); + var body = Controls.HorizontalGrid() + .WithAlignment(HorizontalAlignment.Stretch) + .WithVerticalAlignment(VerticalAlignment.Fill) + .Column(c => c.Width(RulesColumnWidth).Add(rulesCol)) + .Column(c => c.Width(1).Add(VerticalRule())) + .Column(c => c.Width(1).Add(new MarkupControl(new List()))) + .Column(c => c.Flex(1).Add(editorCol)) + .Build(); + + // Header on the first row, footer on the last, body taking everything between — so the action + // bar sits at the bottom of the screen instead of trailing the content. + var root = Controls.Grid() + .WithAlignment(HorizontalAlignment.Stretch) + .WithVerticalAlignment(VerticalAlignment.Fill); + root.Rows(GridLength.Cells(1), GridLength.Star(1), GridLength.Cells(1)).Columns(GridLength.Star(1)); + root.Place(header, 0, 0, 1, 1); + root.Place(body, 1, 0, 1, 1); + root.Place(footer, 2, 0, 1, 1); + + return root.Build(); + } + + private static MarkupControl Band(string line, string bg) => new(new List { line }) + { + BackgroundColor = new Color(bg), + HorizontalAlignment = HorizontalAlignment.Stretch, + }; + + private static MarkupControl Stretch(MarkupControl control) + { + control.HorizontalAlignment = HorizontalAlignment.Stretch; + return control; + } + + /// + /// The one-cell rule between the columns. A with no lines measures to + /// nothing and never paints its background, so the rule is an empty grid instead — a grid's + /// background covers its whole arranged area, giving a full-height hairline. + /// + private static IWindowControl VerticalRule() + { + var rule = Controls.HorizontalGrid() + .WithAlignment(HorizontalAlignment.Stretch) + .WithVerticalAlignment(VerticalAlignment.Fill) + .Column(c => c.Flex(1).Add(new MarkupControl(new List()))) + .Build(); + rule.BackgroundColor = new Color(RuleColor); + return rule; + } + + /// Prefixes each editor row with a space so it doesn't sit flush against the rule. + private static List Indent(IEnumerable lines) => lines.Select(l => " " + l).ToList(); +} diff --git a/src/SharpMUTerm.Tui/WorldsScreenView.cs b/src/SharpMUTerm.Tui/WorldsScreenView.cs index 6f243392..82751165 100644 --- a/src/SharpMUTerm.Tui/WorldsScreenView.cs +++ b/src/SharpMUTerm.Tui/WorldsScreenView.cs @@ -106,7 +106,21 @@ private static MarkupControl Stretch(MarkupControl control) return control; } - private static MarkupControl VerticalRule() => new(new List()) { BackgroundColor = new Color(RuleColor) }; + /// + /// The one-cell rule between the columns. A with no lines measures to + /// nothing and never paints its background, so the rule is an empty grid instead — a grid's + /// background covers its whole arranged area, giving a full-height hairline. + /// + private static IWindowControl VerticalRule() + { + var rule = Controls.HorizontalGrid() + .WithAlignment(HorizontalAlignment.Stretch) + .WithVerticalAlignment(VerticalAlignment.Fill) + .Column(c => c.Flex(1).Add(new MarkupControl(new List()))) + .Build(); + rule.BackgroundColor = new Color(RuleColor); + return rule; + } /// Prefixes each form row with a space so the editing pane doesn't sit flush to the left edge. private static List Indent(IEnumerable lines) => lines.Select(l => " " + l).ToList(); From 3e8642764441848e1b6abfc49668cd90bd45e602 Mon Sep 17 00:00:00 2001 From: Harry Cordewener Date: Tue, 28 Jul 2026 15:41:55 -0500 Subject: [PATCH 02/23] F3 Aliases and F4 Keypad: apply the F5 panel treatment Both screens decomposed into pure blocks with a *ScreenView composing them into header band / column panels / pinned action bar. Render(...) still merges the blocks, so the renderer tests pass untouched. F4's body splits naturally: the numpad grid has a fixed natural width and the hotkey list takes the remainder. Unifies the settings wiring. RegisterSettingsShortcuts and SettingsView carried identical factories keyed two different ways and had to be edited in lockstep for every conversion; they now read one SettingsScreens() table of (Key, Views, Control). The --view name was the only thing that ever differed, and it is now a Views array -- F5 keeps both "worlds" and "settings". The remaining conversions become a one-line edit each. Co-Authored-By: Claude Opus 5 (1M context) --- src/SharpMUTerm.Tui/AliasesScreenRenderer.cs | 168 ++++++++++++++----- src/SharpMUTerm.Tui/AliasesScreenView.cs | 81 +++++++++ src/SharpMUTerm.Tui/KeypadScreenRenderer.cs | 139 +++++++++++++-- src/SharpMUTerm.Tui/KeypadScreenView.cs | 82 +++++++++ src/SharpMUTerm.Tui/SettingsOverlay.cs | 2 +- src/SharpMUTerm.Tui/SharpMUTermApp.cs | 73 +++++--- 6 files changed, 460 insertions(+), 85 deletions(-) create mode 100644 src/SharpMUTerm.Tui/AliasesScreenView.cs create mode 100644 src/SharpMUTerm.Tui/KeypadScreenView.cs diff --git a/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs b/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs index a41f8847..716214e7 100644 --- a/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs @@ -1,52 +1,123 @@ +using System.Globalization; +using System.Text.RegularExpressions; using SharpMUTerm.Core.Automation; using SharpMUTerm.Core.Configuration; namespace SharpMUTerm.Tui; /// -/// Renders the F3 aliases screen: a flattened list of aliases across all trigger sets on the left, -/// merged with an editor for the selected alias on the right, into full-width markup lines. Pure so -/// the screen is unit-testable; the modal host just displays what this produces. +/// Produces the markup sub-blocks for the F3 Aliases screen — the header band, the alias list +/// (flattened across every , each row carrying its enabled state, +/// name/pattern, owning set, and expansion), the editor for the selected alias (pattern, expansion +/// lines, and the case-sensitivity toggle), and the footer action bar. +/// composes these into real panels (grids) for the live/snapshot +/// view; merges the same blocks into a single line list for the unit tests. +/// Pure so every block is testable. /// internal static class AliasesScreenRenderer { private const string Accent = "#00f5b7"; - + private const int ColumnWidth = 54; + + // Palette shared with the view (which sets these as control backgrounds). + internal const string HeaderBg = "#232b3d"; + internal const string FooterBg = "#232b3d"; + private const string Label = "#7c8699"; + private const string Value = "#d7deec"; + private const string Ink = "#0f1620"; + + private static readonly Regex TagPattern = new(@"\[[^\[\]]*\]", RegexOptions.Compiled); + + /// + /// Merges every sub-block into one line list (header, alias list | editor, footer). Used by the + /// unit tests and as a width-agnostic fallback; the live view composes the same blocks into + /// panels instead. + /// public static List Render(IReadOnlyList sets, int selected) { ArgumentNullException.ThrowIfNull(sets); - var lines = new List + var left = ListColumn(sets, selected); + var right = EditorColumn(sets, selected); + + var lines = new List { HeaderLine(0), string.Empty }; + + var rowCount = Math.Max(left.Count, right.Count); + for (var i = 0; i < rowCount; i++) { - "[dim]‹ back[/] [bold]Aliases[/] [dim]F3[/]", - string.Empty, - }; + var leftLine = i < left.Count ? left[i] : string.Empty; + var rightLine = i < right.Count ? right[i] : string.Empty; + lines.Add($"{PadVisible(leftLine, ColumnWidth)} │ {rightLine}"); + } + + lines.Add(string.Empty); + lines.Add(FooterLine(sets, selected, 0)); + + return lines; + } + + /// The screen title on the left, the keyboard hints right-aligned to . + internal static string HeaderLine(int width) + { + var title = $"[bold {Value}] Aliases[/]"; + var hints = $"[{Label}]↑↓ select · ⇥ switch pane · ⏎ edit · [/][{Accent}]F3[/][{Label}]/[/]" + + $"[{Accent}]Esc[/][{Label}] close [/]"; + return SpreadLR(" " + title, hints, width); + } + /// The action bar: which alias is selected on the left, cancel/save on the right. + internal static string FooterLine(IReadOnlyList sets, int selected, int width) + { var entries = Flatten(sets); + var context = string.Empty; + if (entries.Count > 0 && selected >= 0 && selected < entries.Count) + { + var count = entries.Count.ToString(CultureInfo.InvariantCulture); + context = $"[{Label}]alias {(selected + 1).ToString(CultureInfo.InvariantCulture)}/{count}[/]" + + $"[{Label}] · set {Escape(entries[selected].SetName)}[/]"; + } + + var actions = $"[{Label}] [[Esc]] Cancel [/] [{Ink} on {Accent}] [[⏎]] Save [/] "; + return SpreadLR(" " + context, actions, width); + } + + /// The alias list — every alias of every set, with its enabled state and expansion. + internal static List ListColumn(IReadOnlyList sets, int selected) + { + ArgumentNullException.ThrowIfNull(sets); + + var entries = Flatten(sets); + var lines = new List { "[dim]on name / pattern → expansion[/]" }; + if (entries.Count == 0) { - lines.Add("[dim]on name / pattern → expansion[/]"); lines.Add("[dim]no aliases[/]"); - lines.Add(string.Empty); - lines.Add("[dim][[Cancel]] [[Save]][/]"); return lines; } - var left = LeftColumn(entries, selected); - var right = RightColumn(entries, selected); - var rowCount = Math.Max(left.Count, right.Count); - for (var i = 0; i < rowCount; i++) + for (var i = 0; i < entries.Count; i++) { - var l = i < left.Count ? left[i] : string.Empty; - var r = i < right.Count ? right[i] : string.Empty; - lines.Add($"{l} │ {r}"); + lines.Add(Row(entries[i].Alias, entries[i].SetName, i == selected)); } - lines.Add(string.Empty); - lines.Add("[dim][[Cancel]] [[Save]][/]"); return lines; } + /// + /// The editor for the selected alias — pattern, expansion lines, and the case-sensitivity + /// toggle. Empty when nothing is selected. + /// + internal static List EditorColumn(IReadOnlyList sets, int selected) + { + ArgumentNullException.ThrowIfNull(sets); + + var entries = Flatten(sets); + return selected >= 0 && selected < entries.Count + ? BuildEditor(entries[selected].Alias) + : new List(); + } + + /// Flattens every set's aliases into one list, each paired with its owning set's name. private static List<(Alias Alias, string SetName)> Flatten(IReadOnlyList sets) { var entries = new List<(Alias, string)>(); @@ -61,17 +132,6 @@ public static List Render(IReadOnlyList sets, int selected) return entries; } - private static List LeftColumn(List<(Alias Alias, string SetName)> entries, int selected) - { - var lines = new List { "[dim]on name / pattern → expansion[/]" }; - for (var i = 0; i < entries.Count; i++) - { - lines.Add(Row(entries[i].Alias, entries[i].SetName, i == selected)); - } - - return lines; - } - private static string Row(Alias alias, string setName, bool selected) { var check = alias.Enabled ? $"[{Accent}]✓[/]" : "[dim]·[/]"; @@ -82,27 +142,22 @@ private static string Row(Alias alias, string setName, bool selected) return $"{check} {marker} [bold]{name}[/] [dim]{pattern}[/] [dim]▪ {Escape(setName)}[/] → {expansion}"; } - private static List RightColumn(List<(Alias Alias, string SetName)> entries, int selected) + private static List BuildEditor(Alias alias) { - if (selected < 0 || selected >= entries.Count) - { - return new List(); - } - - var alias = entries[selected].Alias; var lines = new List { "[dim]match pattern (regex)[/]", - Escape(alias.Pattern), + $" {Escape(alias.Pattern)}", + string.Empty, "[dim]expands to[/]", }; - var substitutionLines = alias.Substitution.Split('\n'); - foreach (var line in substitutionLines) + foreach (var line in alias.Substitution.Split('\n')) { - lines.Add(Escape(line)); + lines.Add($" {Escape(line)}"); } + lines.Add(string.Empty); lines.Add(alias.CaseSensitive ? $"[{Accent}][[x]][/] case sensitive" : "[dim][[ ]] case sensitive[/]"); @@ -116,5 +171,34 @@ private static string FirstLine(string text) return newlineIndex < 0 ? text : text[..newlineIndex]; } + /// Lays a left- and right-hand fragment on one line, right-aligning the right to . + private static string SpreadLR(string left, string right, int width) + { + if (width <= 0) + { + return $"{left} {right}"; + } + + var gap = Math.Max(1, width - VisibleLength(left) - VisibleLength(right)); + return left + new string(' ', gap) + right; + } + + /// Pads a markup string to a target *visible* column width, ignoring markup tags. + private static string PadVisible(string markup, int width) + { + var visible = VisibleLength(markup); + return visible >= width ? markup : markup + new string(' ', width - visible); + } + + /// + /// Counts the printable length of a markup string: escaped brackets ([[/]]) count + /// as one literal character each, and [tag] wrappers are stripped entirely. + /// + private static int VisibleLength(string markup) + { + var protectedText = markup.Replace("[[", "\u0001").Replace("]]", "\u0002"); + return TagPattern.Replace(protectedText, string.Empty).Length; + } + private static string Escape(string text) => text.Replace("[", "[[").Replace("]", "]]"); } diff --git a/src/SharpMUTerm.Tui/AliasesScreenView.cs b/src/SharpMUTerm.Tui/AliasesScreenView.cs new file mode 100644 index 00000000..c8b380aa --- /dev/null +++ b/src/SharpMUTerm.Tui/AliasesScreenView.cs @@ -0,0 +1,81 @@ +using SharpMUTerm.Core.Configuration; +using SharpConsoleUI; +using SharpConsoleUI.Builders; +using SharpConsoleUI.Controls; +using SharpConsoleUI.Layout; + +namespace SharpMUTerm.Tui; + +/// +/// Composes the F3 Aliases screen from real panels (grids) rather than one merged markup blob: a +/// header band carrying the keyboard hints, a body whose alias-list panel and editor panel are +/// separated by a vertical rule, and a Cancel/Save action bar pinned to the last row. The markup for +/// each panel comes from the pure so the content stays +/// unit-tested; this only lays it out. +/// +internal static class AliasesScreenView +{ + private const string RuleColor = "#3a4257"; + private const int ListColumnWidth = 56; + + public static IWindowControl Build(IReadOnlyList sets, int selected, int width) + { + var header = Band(AliasesScreenRenderer.HeaderLine(width), AliasesScreenRenderer.HeaderBg); + var footer = Band(AliasesScreenRenderer.FooterLine(sets, selected, width), AliasesScreenRenderer.FooterBg); + + // Body: alias list │ editor, as two real columns. + var listCol = Stretch(new MarkupControl(AliasesScreenRenderer.ListColumn(sets, selected))); + var editorCol = Stretch(new MarkupControl(Indent(AliasesScreenRenderer.EditorColumn(sets, selected)))); + var body = Controls.HorizontalGrid() + .WithAlignment(HorizontalAlignment.Stretch) + .WithVerticalAlignment(VerticalAlignment.Fill) + .Column(c => c.Width(ListColumnWidth).Add(listCol)) + .Column(c => c.Width(1).Add(VerticalRule())) + .Column(c => c.Width(1).Add(new MarkupControl(new List()))) + .Column(c => c.Flex(1).Add(editorCol)) + .Build(); + + // Header on the first row, footer on the last, body taking everything between — so the action + // bar sits at the bottom of the screen instead of trailing the content. + var root = Controls.Grid() + .WithAlignment(HorizontalAlignment.Stretch) + .WithVerticalAlignment(VerticalAlignment.Fill); + root.Rows(GridLength.Cells(1), GridLength.Star(1), GridLength.Cells(1)).Columns(GridLength.Star(1)); + root.Place(header, 0, 0, 1, 1); + root.Place(body, 1, 0, 1, 1); + root.Place(footer, 2, 0, 1, 1); + + return root.Build(); + } + + private static MarkupControl Band(string line, string bg) => new(new List { line }) + { + BackgroundColor = new Color(bg), + HorizontalAlignment = HorizontalAlignment.Stretch, + }; + + private static MarkupControl Stretch(MarkupControl control) + { + control.HorizontalAlignment = HorizontalAlignment.Stretch; + return control; + } + + /// + /// The one-cell rule between the columns. A with no lines measures to + /// nothing and never paints its background, so the rule is an empty grid instead — a grid's + /// background covers its whole arranged area, giving a full-height hairline. + /// + private static IWindowControl VerticalRule() + { + var rule = Controls.HorizontalGrid() + .WithAlignment(HorizontalAlignment.Stretch) + .WithVerticalAlignment(VerticalAlignment.Fill) + .Column(c => c.Flex(1).Add(new MarkupControl(new List()))) + .Build(); + rule.BackgroundColor = new Color(RuleColor); + return rule; + } + + /// Prefixes each editor row with a space so it doesn't sit flush against the rule. + private static List Indent(IEnumerable lines) => lines.Select(l => " " + l).ToList(); +} diff --git a/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs b/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs index 26ca25b4..1820ffff 100644 --- a/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs @@ -1,17 +1,31 @@ +using System.Globalization; +using System.Text.RegularExpressions; using SharpMUTerm.Core.Automation; namespace SharpMUTerm.Tui; /// -/// Renders the F4 keypad & hotkeys screen: a 3×3 numpad grid (Num7..Num9 top row through -/// Num1..Num3 bottom row, numpad order) showing the command bound to each digit, followed by a -/// binding list of every macro with its enabled state, key, and command. Pure so the panel is -/// unit-testable. +/// Produces the markup sub-blocks for the F4 Keypad & hotkeys screen — the header band, the 3×3 +/// numpad grid (Num7..Num9 top row through Num1..Num3 bottom row, numpad order) showing the command +/// bound to each digit, the binding list of every macro with its enabled state, key, and command, +/// and the footer action bar. composes these into real panels (grids) +/// for the live/snapshot view; merges the same blocks into a single line list +/// for the unit tests. Pure so every block is testable. /// internal static class KeypadScreenRenderer { private const string Accent = "#00f5b7"; private const int KeyColumnWidth = 12; + private const int ColumnWidth = 48; + + // Palette shared with the view (which sets these as control backgrounds). + internal const string HeaderBg = "#232b3d"; + internal const string FooterBg = "#232b3d"; + private const string Label = "#7c8699"; + private const string Value = "#d7deec"; + private const string Ink = "#0f1620"; + + private static readonly Regex TagPattern = new(@"\[[^\[\]]*\]", RegexOptions.Compiled); private static readonly int[][] NumpadRows = { @@ -20,39 +34,99 @@ internal static class KeypadScreenRenderer new[] { 1, 2, 3 }, }; + /// + /// Merges every sub-block into one line list (header, numpad | hotkeys, footer). Used by the + /// unit tests and as a width-agnostic fallback; the live view composes the same blocks into + /// panels instead. + /// public static List Render(IReadOnlyList macros) { ArgumentNullException.ThrowIfNull(macros); - var lines = new List + var left = NumpadColumn(macros); + var right = HotkeysColumn(macros); + + var lines = new List { HeaderLine(0), string.Empty }; + + var rowCount = Math.Max(left.Count, right.Count); + for (var i = 0; i < rowCount; i++) { - "[dim]‹ back[/] [bold]Keypad & hotkeys[/] [dim]F4[/]", - string.Empty, - "[dim]├ NUMPAD[/]", - }; + var leftLine = i < left.Count ? left[i] : string.Empty; + var rightLine = i < right.Count ? right[i] : string.Empty; + lines.Add($"{PadVisible(leftLine, ColumnWidth)} │ {rightLine}"); + } + + lines.Add(string.Empty); + lines.Add(FooterLine(macros, 0)); + + return lines; + } + + /// The screen title on the left, the keyboard hints right-aligned to . + internal static string HeaderLine(int width) + { + var title = $"[bold {Value}] Keypad & hotkeys[/]"; + var hints = $"[{Label}]↑↓ select · ⇥ switch pane · ⏎ rebind · [/][{Accent}]F4[/][{Label}]/[/]" + + $"[{Accent}]Esc[/][{Label}] close [/]"; + return SpreadLR(" " + title, hints, width); + } + /// The action bar: how much of the keypad is bound on the left, cancel/save on the right. + internal static string FooterLine(IReadOnlyList macros, int width) + { + ArgumentNullException.ThrowIfNull(macros); + + var bound = 0; + foreach (var row in NumpadRows) + { + foreach (var digit in row) + { + if (FindByKey(macros, $"Num{digit}") is not null) + { + bound++; + } + } + } + + var total = macros.Count.ToString(CultureInfo.InvariantCulture); + var context = $"[{Label}]{total} bindings[/]" + + $"[{Label}] · {bound.ToString(CultureInfo.InvariantCulture)} of 9 numpad keys bound[/]"; + + var actions = $"[{Label}] [[Esc]] Cancel [/] [{Ink} on {Accent}] [[⏎]] Save [/] "; + return SpreadLR(" " + context, actions, width); + } + + /// The 3×3 numpad grid, in numpad order (7-8-9 on top), one row per line. + internal static List NumpadColumn(IReadOnlyList macros) + { + ArgumentNullException.ThrowIfNull(macros); + + var lines = new List { "[dim]NUMPAD[/]" }; foreach (var row in NumpadRows) { lines.Add(NumpadRow(row, macros)); } - lines.Add(string.Empty); - lines.Add("[dim]├ HOTKEYS[/]"); + return lines; + } + /// The binding list — every macro with its enabled state, key, and command. + internal static List HotkeysColumn(IReadOnlyList macros) + { + ArgumentNullException.ThrowIfNull(macros); + + var lines = new List { "[dim]HOTKEYS[/]" }; if (macros.Count == 0) { lines.Add(" [dim]no hotkeys[/]"); + return lines; } - else + + foreach (var macro in macros) { - foreach (var macro in macros) - { - lines.Add(Hotkey(macro)); - } + lines.Add(Hotkey(macro)); } - lines.Add(string.Empty); - lines.Add("[dim][[Cancel]] [[Save]][/]"); return lines; } @@ -97,5 +171,34 @@ private static string Hotkey(Macro macro) private static string Truncate(string text, int maxLength) => text.Length <= maxLength ? text : string.Concat(text.AsSpan(0, maxLength - 1), "…"); + /// Lays a left- and right-hand fragment on one line, right-aligning the right to . + private static string SpreadLR(string left, string right, int width) + { + if (width <= 0) + { + return $"{left} {right}"; + } + + var gap = Math.Max(1, width - VisibleLength(left) - VisibleLength(right)); + return left + new string(' ', gap) + right; + } + + /// Pads a markup string to a target *visible* column width, ignoring markup tags. + private static string PadVisible(string markup, int width) + { + var visible = VisibleLength(markup); + return visible >= width ? markup : markup + new string(' ', width - visible); + } + + /// + /// Counts the printable length of a markup string: escaped brackets ([[/]]) count + /// as one literal character each, and [tag] wrappers are stripped entirely. + /// + private static int VisibleLength(string markup) + { + var protectedText = markup.Replace("[[", "\u0001").Replace("]]", "\u0002"); + return TagPattern.Replace(protectedText, string.Empty).Length; + } + private static string Escape(string text) => text.Replace("[", "[[").Replace("]", "]]"); } diff --git a/src/SharpMUTerm.Tui/KeypadScreenView.cs b/src/SharpMUTerm.Tui/KeypadScreenView.cs new file mode 100644 index 00000000..2f75b6c7 --- /dev/null +++ b/src/SharpMUTerm.Tui/KeypadScreenView.cs @@ -0,0 +1,82 @@ +using SharpMUTerm.Core.Automation; +using SharpConsoleUI; +using SharpConsoleUI.Builders; +using SharpConsoleUI.Controls; +using SharpConsoleUI.Layout; + +namespace SharpMUTerm.Tui; + +/// +/// Composes the F4 Keypad & hotkeys screen from real panels (grids) rather than one merged markup +/// blob: a header band carrying the keyboard hints, a body whose numpad-grid panel and hotkey-list +/// panel are separated by a vertical rule, and a Cancel/Save action bar pinned to the last row. The +/// numpad is the fixed-width column (its 3×3 grid has a natural size), the hotkey list takes the +/// rest. The markup for each panel comes from the pure so the +/// content stays unit-tested; this only lays it out. +/// +internal static class KeypadScreenView +{ + private const string RuleColor = "#3a4257"; + private const int NumpadColumnWidth = 50; + + public static IWindowControl Build(IReadOnlyList macros, int width) + { + var header = Band(KeypadScreenRenderer.HeaderLine(width), KeypadScreenRenderer.HeaderBg); + var footer = Band(KeypadScreenRenderer.FooterLine(macros, width), KeypadScreenRenderer.FooterBg); + + // Body: numpad grid │ hotkey list, as two real columns. + var numpadCol = Stretch(new MarkupControl(KeypadScreenRenderer.NumpadColumn(macros))); + var hotkeysCol = Stretch(new MarkupControl(Indent(KeypadScreenRenderer.HotkeysColumn(macros)))); + var body = Controls.HorizontalGrid() + .WithAlignment(HorizontalAlignment.Stretch) + .WithVerticalAlignment(VerticalAlignment.Fill) + .Column(c => c.Width(NumpadColumnWidth).Add(numpadCol)) + .Column(c => c.Width(1).Add(VerticalRule())) + .Column(c => c.Width(1).Add(new MarkupControl(new List()))) + .Column(c => c.Flex(1).Add(hotkeysCol)) + .Build(); + + // Header on the first row, footer on the last, body taking everything between — so the action + // bar sits at the bottom of the screen instead of trailing the content. + var root = Controls.Grid() + .WithAlignment(HorizontalAlignment.Stretch) + .WithVerticalAlignment(VerticalAlignment.Fill); + root.Rows(GridLength.Cells(1), GridLength.Star(1), GridLength.Cells(1)).Columns(GridLength.Star(1)); + root.Place(header, 0, 0, 1, 1); + root.Place(body, 1, 0, 1, 1); + root.Place(footer, 2, 0, 1, 1); + + return root.Build(); + } + + private static MarkupControl Band(string line, string bg) => new(new List { line }) + { + BackgroundColor = new Color(bg), + HorizontalAlignment = HorizontalAlignment.Stretch, + }; + + private static MarkupControl Stretch(MarkupControl control) + { + control.HorizontalAlignment = HorizontalAlignment.Stretch; + return control; + } + + /// + /// The one-cell rule between the columns. A with no lines measures to + /// nothing and never paints its background, so the rule is an empty grid instead — a grid's + /// background covers its whole arranged area, giving a full-height hairline. + /// + private static IWindowControl VerticalRule() + { + var rule = Controls.HorizontalGrid() + .WithAlignment(HorizontalAlignment.Stretch) + .WithVerticalAlignment(VerticalAlignment.Fill) + .Column(c => c.Flex(1).Add(new MarkupControl(new List()))) + .Build(); + rule.BackgroundColor = new Color(RuleColor); + return rule; + } + + /// Prefixes each hotkey row with a space so it doesn't sit flush against the rule. + private static List Indent(IEnumerable lines) => lines.Select(l => " " + l).ToList(); +} diff --git a/src/SharpMUTerm.Tui/SettingsOverlay.cs b/src/SharpMUTerm.Tui/SettingsOverlay.cs index eea6325f..a8db7f25 100644 --- a/src/SharpMUTerm.Tui/SettingsOverlay.cs +++ b/src/SharpMUTerm.Tui/SettingsOverlay.cs @@ -9,7 +9,7 @@ namespace SharpMUTerm.Tui; /// A full-screen overlay hosting the F2–F9 settings screens. The design specifies these as /// full-screen surfaces, not floating dialogs: this maximises a frameless modal (no title bar, /// buttons, or resize grip) with a deep panel background. Every screen supplies a control: the -/// converted ones (F2, F5) a composed tree of real panels, the rest a single +/// converted ones (F2–F5) a composed tree of real panels, the rest a single /// wrapping their markup. Esc (or the same F-key) closes it. The renderers stay pure and tested; /// this is a thin host. /// diff --git a/src/SharpMUTerm.Tui/SharpMUTermApp.cs b/src/SharpMUTerm.Tui/SharpMUTermApp.cs index cecf6a54..882f8d32 100644 --- a/src/SharpMUTerm.Tui/SharpMUTermApp.cs +++ b/src/SharpMUTerm.Tui/SharpMUTermApp.cs @@ -714,22 +714,40 @@ private void RefreshStatusBar() private string? ActiveCharacterKey() => _active?.SessionKey ?? _demoActiveKey; /// - /// Binds F2–F9 to the full-screen settings overlay. Each screen is rendered on demand from live - /// config by its pure renderer, so re-opening always reflects current state. Esc / same F-key closes. + /// One settings screen: the F-key that toggles it, the --view names that select it for a + /// snapshot, and the factory that builds its control. + /// + private readonly record struct SettingsScreen(ConsoleKey Key, string[] Views, Func Control); + + /// + /// The F2–F9 settings screens, in F-key order. Both the global shortcuts and the --view + /// snapshot lookup read this one table, so a screen can't be bound to a key without also being + /// reachable by name. Each control is built on demand from live config by its pure renderer, so + /// re-opening always reflects current state — converted screens (F2–F5) hand back a composed + /// tree of real panels, the rest a panel. + /// + private IReadOnlyList SettingsScreens() => new SettingsScreen[] + { + new(ConsoleKey.F2, new[] { "triggers" }, TriggersControl), + new(ConsoleKey.F3, new[] { "aliases" }, AliasesControl), + new(ConsoleKey.F4, new[] { "keypad" }, KeypadControl), + new(ConsoleKey.F5, new[] { "worlds", "settings" }, WorldsControl), + new(ConsoleKey.F6, new[] { "timers" }, Markup(() => TimersScreenRenderer.Render(_config.TriggerSets, 0))), + new(ConsoleKey.F7, new[] { "textansi" }, Markup(OptionsScreenRenderer.TextAnsi)), + new(ConsoleKey.F8, new[] { "input" }, Markup(OptionsScreenRenderer.InputSpellcheck)), + new(ConsoleKey.F9, new[] { "logging" }, Markup(() => OptionsScreenRenderer.Logging(ActiveLogging()))), + }; + + /// + /// Binds each screen's F-key to the full-screen settings overlay. Esc / the same F-key closes. /// private void RegisterSettingsShortcuts() { - void Bind(ConsoleKey key, Func control) => + foreach (var screen in SettingsScreens()) + { + var (key, control) = (screen.Key, screen.Control); _system.RegisterGlobalShortcut((ConsoleModifiers)0, key, () => _settings.Toggle(key, control)); - - Bind(ConsoleKey.F2, TriggersControl); - Bind(ConsoleKey.F3, Markup(() => AliasesScreenRenderer.Render(_config.TriggerSets, 0))); - Bind(ConsoleKey.F4, Markup(() => KeypadScreenRenderer.Render(Macros()))); - Bind(ConsoleKey.F5, WorldsControl); - Bind(ConsoleKey.F6, Markup(() => TimersScreenRenderer.Render(_config.TriggerSets, 0))); - Bind(ConsoleKey.F7, Markup(OptionsScreenRenderer.TextAnsi)); - Bind(ConsoleKey.F8, Markup(OptionsScreenRenderer.InputSpellcheck)); - Bind(ConsoleKey.F9, Markup(() => OptionsScreenRenderer.Logging(ActiveLogging()))); + } } /// Distinct spawn-window targets referenced by any trigger (for the F2 route-to list). @@ -794,23 +812,30 @@ private IWindowControl WorldsControl() => WorldsScreenView.Build( private IWindowControl TriggersControl() => TriggersScreenView.Build( _config.TriggerSets, 0, SpawnTargets(), _system.DesktopDimensions.Width); + /// Builds the F3 Aliases screen as a composed control tree (real panels). + private IWindowControl AliasesControl() => AliasesScreenView.Build( + _config.TriggerSets, 0, _system.DesktopDimensions.Width); + + /// Builds the F4 Keypad & hotkeys screen as a composed control tree (real panels). + private IWindowControl KeypadControl() => KeypadScreenView.Build(Macros(), _system.DesktopDimensions.Width); + /// Hosts a screen that is still one markup block in the overlay's full-screen panel. private static Func Markup(Func> content) => () => SettingsOverlay.MarkupPanel(content()); /// Maps a --view name to a settings screen (F-key + control factory) for snapshots. - private (ConsoleKey Key, Func Control)? SettingsView(string view) => view.ToLowerInvariant() switch - { - "triggers" => (ConsoleKey.F2, TriggersControl), - "aliases" => (ConsoleKey.F3, Markup(() => AliasesScreenRenderer.Render(_config.TriggerSets, 0))), - "keypad" => (ConsoleKey.F4, Markup(() => KeypadScreenRenderer.Render(Macros()))), - "worlds" or "settings" => (ConsoleKey.F5, WorldsControl), - "timers" => (ConsoleKey.F6, Markup(() => TimersScreenRenderer.Render(_config.TriggerSets, 0))), - "textansi" => (ConsoleKey.F7, Markup(OptionsScreenRenderer.TextAnsi)), - "input" => (ConsoleKey.F8, Markup(OptionsScreenRenderer.InputSpellcheck)), - "logging" => (ConsoleKey.F9, Markup(() => OptionsScreenRenderer.Logging(ActiveLogging()))), - _ => null, - }; + private (ConsoleKey Key, Func Control)? SettingsView(string view) + { + foreach (var screen in SettingsScreens()) + { + if (screen.Views.Contains(view, StringComparer.OrdinalIgnoreCase)) + { + return (screen.Key, screen.Control); + } + } + + return null; + } /// The accent for a world at : its own, or the palette fallback. private static TerminalColor AccentFor(WorldDefinition world, int index) => From 3a50a60f0f2fd1bd9aee831c0742966f3f47d8c4 Mon Sep 17 00:00:00 2001 From: Harry Cordewener Date: Tue, 28 Jul 2026 15:47:00 -0500 Subject: [PATCH 03/23] F6 Timers: apply the F5 panel treatment Decomposed into pure blocks with TimersScreenView composing header band / list column / rule / editor column / pinned action bar. Render(...) still merges the blocks, so TimersScreenRendererTests passes untouched. Also corrects VisibleLength, which stripped "[[" instead of counting it as one literal character -- contradicting its own doc comment and under-padding the list column for any row containing escaped brackets. No test covers padding, so the suite never caught it. Co-Authored-By: Claude Opus 5 (1M context) --- src/SharpMUTerm.Tui/SettingsOverlay.cs | 2 +- src/SharpMUTerm.Tui/SharpMUTermApp.cs | 8 +- src/SharpMUTerm.Tui/TimersScreenRenderer.cs | 161 ++++++++++++++------ src/SharpMUTerm.Tui/TimersScreenView.cs | 81 ++++++++++ 4 files changed, 199 insertions(+), 53 deletions(-) create mode 100644 src/SharpMUTerm.Tui/TimersScreenView.cs diff --git a/src/SharpMUTerm.Tui/SettingsOverlay.cs b/src/SharpMUTerm.Tui/SettingsOverlay.cs index a8db7f25..488dc6da 100644 --- a/src/SharpMUTerm.Tui/SettingsOverlay.cs +++ b/src/SharpMUTerm.Tui/SettingsOverlay.cs @@ -9,7 +9,7 @@ namespace SharpMUTerm.Tui; /// A full-screen overlay hosting the F2–F9 settings screens. The design specifies these as /// full-screen surfaces, not floating dialogs: this maximises a frameless modal (no title bar, /// buttons, or resize grip) with a deep panel background. Every screen supplies a control: the -/// converted ones (F2–F5) a composed tree of real panels, the rest a single +/// converted ones (F2–F6) a composed tree of real panels, the rest a single /// wrapping their markup. Esc (or the same F-key) closes it. The renderers stay pure and tested; /// this is a thin host. /// diff --git a/src/SharpMUTerm.Tui/SharpMUTermApp.cs b/src/SharpMUTerm.Tui/SharpMUTermApp.cs index 882f8d32..5cfc07fd 100644 --- a/src/SharpMUTerm.Tui/SharpMUTermApp.cs +++ b/src/SharpMUTerm.Tui/SharpMUTermApp.cs @@ -723,7 +723,7 @@ private void RefreshStatusBar() /// The F2–F9 settings screens, in F-key order. Both the global shortcuts and the --view /// snapshot lookup read this one table, so a screen can't be bound to a key without also being /// reachable by name. Each control is built on demand from live config by its pure renderer, so - /// re-opening always reflects current state — converted screens (F2–F5) hand back a composed + /// re-opening always reflects current state — converted screens (F2–F6) hand back a composed /// tree of real panels, the rest a panel. /// private IReadOnlyList SettingsScreens() => new SettingsScreen[] @@ -732,7 +732,7 @@ private void RefreshStatusBar() new(ConsoleKey.F3, new[] { "aliases" }, AliasesControl), new(ConsoleKey.F4, new[] { "keypad" }, KeypadControl), new(ConsoleKey.F5, new[] { "worlds", "settings" }, WorldsControl), - new(ConsoleKey.F6, new[] { "timers" }, Markup(() => TimersScreenRenderer.Render(_config.TriggerSets, 0))), + new(ConsoleKey.F6, new[] { "timers" }, TimersControl), new(ConsoleKey.F7, new[] { "textansi" }, Markup(OptionsScreenRenderer.TextAnsi)), new(ConsoleKey.F8, new[] { "input" }, Markup(OptionsScreenRenderer.InputSpellcheck)), new(ConsoleKey.F9, new[] { "logging" }, Markup(() => OptionsScreenRenderer.Logging(ActiveLogging()))), @@ -819,6 +819,10 @@ private IWindowControl AliasesControl() => AliasesScreenView.Build( /// Builds the F4 Keypad & hotkeys screen as a composed control tree (real panels). private IWindowControl KeypadControl() => KeypadScreenView.Build(Macros(), _system.DesktopDimensions.Width); + /// Builds the F6 Timers screen as a composed control tree (real panels). + private IWindowControl TimersControl() => TimersScreenView.Build( + _config.TriggerSets, 0, _system.DesktopDimensions.Width); + /// Hosts a screen that is still one markup block in the overlay's full-screen panel. private static Func Markup(Func> content) => () => SettingsOverlay.MarkupPanel(content()); diff --git a/src/SharpMUTerm.Tui/TimersScreenRenderer.cs b/src/SharpMUTerm.Tui/TimersScreenRenderer.cs index b76900aa..18d1beaf 100644 --- a/src/SharpMUTerm.Tui/TimersScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/TimersScreenRenderer.cs @@ -6,52 +6,118 @@ namespace SharpMUTerm.Tui; /// -/// Renders the F6 timers screen: a flattened list of timers across all trigger sets on the left, -/// merged with an editor for the selected timer on the right, into full-width markup lines. Pure so -/// the screen is unit-testable; the modal host just displays what this produces. +/// Produces the markup sub-blocks for the F6 Timers screen — the header band, the timer list +/// (flattened across every , each row carrying its enabled state, name, +/// schedule, owning set, and command), the editor for the selected timer (interval, command, and the +/// one-shot/enabled toggles), and the footer action bar. +/// composes these into real panels (grids) for the live/snapshot +/// view; merges the same blocks into a single line list for the unit tests. +/// Pure so every block is testable. /// internal static class TimersScreenRenderer { private const string Accent = "#00f5b7"; private const int ColumnWidth = 54; + // Palette shared with the view (which sets these as control backgrounds). + internal const string HeaderBg = "#232b3d"; + internal const string FooterBg = "#232b3d"; + private const string Label = "#7c8699"; + private const string Value = "#d7deec"; + private const string Ink = "#0f1620"; + private static readonly Regex TagPattern = new(@"\[[^\[\]]*\]", RegexOptions.Compiled); + /// + /// Merges every sub-block into one line list (header, timer list | editor, footer). Used by the + /// unit tests and as a width-agnostic fallback; the live view composes the same blocks into + /// panels instead. + /// public static List Render(IReadOnlyList sets, int selected) { ArgumentNullException.ThrowIfNull(sets); - var lines = new List + var left = ListColumn(sets, selected); + var right = EditorColumn(sets, selected); + + var lines = new List { HeaderLine(0), string.Empty }; + + var rowCount = Math.Max(left.Count, right.Count); + for (var i = 0; i < rowCount; i++) + { + var leftLine = i < left.Count ? left[i] : string.Empty; + var rightLine = i < right.Count ? right[i] : string.Empty; + lines.Add($"{PadVisible(leftLine, ColumnWidth)} │ {rightLine}"); + } + + lines.Add(string.Empty); + lines.Add(FooterLine(sets, selected, 0)); + + return lines; + } + + /// The screen title on the left, the keyboard hints right-aligned to . + internal static string HeaderLine(int width) + { + var title = $"[bold {Value}] Timers[/]"; + var hints = $"[{Label}]↑↓ select · ⇥ switch pane · ⏎ edit · [/][{Accent}]F6[/][{Label}]/[/]" + + $"[{Accent}]Esc[/][{Label}] close [/]"; + return SpreadLR(" " + title, hints, width); + } + + /// The action bar: which timer is selected on the left, cancel/save on the right. + internal static string FooterLine(IReadOnlyList sets, int selected, int width) + { + var entries = Flatten(sets); + var context = string.Empty; + if (entries.Count > 0 && selected >= 0 && selected < entries.Count) { - "[dim]‹ back[/] [bold]Timers[/] [dim]F6[/]", - string.Empty, - }; + var count = entries.Count.ToString(CultureInfo.InvariantCulture); + context = $"[{Label}]timer {(selected + 1).ToString(CultureInfo.InvariantCulture)}/{count}[/]" + + $"[{Label}] · set {Escape(entries[selected].SetName)}[/]"; + } + + var actions = $"[{Label}] [[Esc]] Cancel [/] [{Ink} on {Accent}] [[⏎]] Save [/] "; + return SpreadLR(" " + context, actions, width); + } + + /// The timer list — every timer of every set, with its enabled state and schedule. + internal static List ListColumn(IReadOnlyList sets, int selected) + { + ArgumentNullException.ThrowIfNull(sets); var entries = Flatten(sets); + var lines = new List { "[dim]on name every → command[/]" }; + if (entries.Count == 0) { - lines.Add("[dim]on name every → command[/]"); lines.Add("[dim]no timers[/]"); - lines.Add(string.Empty); - lines.Add("[dim][[Cancel]] [[Save]][/]"); return lines; } - var left = LeftColumn(entries, selected); - var right = RightColumn(entries, selected); - var rowCount = Math.Max(left.Count, right.Count); - for (var i = 0; i < rowCount; i++) + for (var i = 0; i < entries.Count; i++) { - var l = i < left.Count ? left[i] : string.Empty; - var r = i < right.Count ? right[i] : string.Empty; - lines.Add($"{PadVisible(l, ColumnWidth)} │ {r}"); + lines.Add(Row(entries[i].Timer, entries[i].SetName, i == selected)); } - lines.Add(string.Empty); - lines.Add("[dim][[Cancel]] [[Save]][/]"); return lines; } + /// + /// The editor for the selected timer — interval, command, and the one-shot/enabled toggles. + /// Empty when nothing is selected. + /// + internal static List EditorColumn(IReadOnlyList sets, int selected) + { + ArgumentNullException.ThrowIfNull(sets); + + var entries = Flatten(sets); + return selected >= 0 && selected < entries.Count + ? BuildEditor(entries[selected].Timer) + : new List(); + } + + /// Flattens every set's timers into one list, each paired with its owning set's name. private static List<(TimerDefinition Timer, string SetName)> Flatten(IReadOnlyList sets) { var entries = new List<(TimerDefinition, string)>(); @@ -66,17 +132,6 @@ public static List Render(IReadOnlyList sets, int selected) return entries; } - private static List LeftColumn(List<(TimerDefinition Timer, string SetName)> entries, int selected) - { - var lines = new List { "[dim]on name every → command[/]" }; - for (var i = 0; i < entries.Count; i++) - { - lines.Add(Row(entries[i].Timer, entries[i].SetName, i == selected)); - } - - return lines; - } - private static string Row(TimerDefinition timer, string setName, bool selected) { var check = timer.Enabled ? $"[{Accent}]✓[/]" : "[dim]·[/]"; @@ -87,29 +142,35 @@ private static string Row(TimerDefinition timer, string setName, bool selected) return $"{check} {marker} [bold]{name}[/] {schedule} [dim]▪ {Escape(setName)}[/] → {command}"; } - private static List RightColumn(List<(TimerDefinition Timer, string SetName)> entries, int selected) + private static List BuildEditor(TimerDefinition timer) => new() { - if (selected < 0 || selected >= entries.Count) + "[dim]interval (seconds)[/]", + $" {Seconds(timer)}", + string.Empty, + "[dim]command[/]", + $" {Escape(timer.Command)}", + string.Empty, + timer.OneShot ? $"[{Accent}][[x]][/] one-shot" : "[dim][[ ]] one-shot[/]", + timer.Enabled ? $"[{Accent}][[x]][/] enabled" : "[dim][[ ]] enabled[/]", + }; + + /// The row-level schedule summary: every 30s, or once after 5.5s. + private static string Schedule(TimerDefinition timer) => + timer.OneShot ? $"once after {Seconds(timer)}s" : $"every {Seconds(timer)}s"; + + private static string Seconds(TimerDefinition timer) => + timer.IntervalSeconds.ToString("0.#", CultureInfo.InvariantCulture); + + /// Lays a left- and right-hand fragment on one line, right-aligning the right to . + private static string SpreadLR(string left, string right, int width) + { + if (width <= 0) { - return new List(); + return $"{left} {right}"; } - var timer = entries[selected].Timer; - return new List - { - "[dim]interval (seconds)[/]", - timer.IntervalSeconds.ToString("0.#", CultureInfo.InvariantCulture), - "[dim]command[/]", - Escape(timer.Command), - timer.OneShot ? $"[{Accent}][[x]][/] one-shot" : "[dim][[ ]] one-shot[/]", - timer.Enabled ? $"[{Accent}][[x]][/] enabled" : "[dim][[ ]] enabled[/]", - }; - } - - private static string Schedule(TimerDefinition timer) - { - var seconds = timer.IntervalSeconds.ToString("0.#", CultureInfo.InvariantCulture); - return timer.OneShot ? $"once after {seconds}s" : $"every {seconds}s"; + var gap = Math.Max(1, width - VisibleLength(left) - VisibleLength(right)); + return left + new string(' ', gap) + right; } /// Pads a markup string to a target *visible* column width, ignoring markup tags. @@ -125,7 +186,7 @@ private static string PadVisible(string markup, int width) /// private static int VisibleLength(string markup) { - var protectedText = markup.Replace("[[", "").Replace("]]", ""); + var protectedText = markup.Replace("[[", "\u0001").Replace("]]", "\u0002"); return TagPattern.Replace(protectedText, string.Empty).Length; } diff --git a/src/SharpMUTerm.Tui/TimersScreenView.cs b/src/SharpMUTerm.Tui/TimersScreenView.cs new file mode 100644 index 00000000..abca4621 --- /dev/null +++ b/src/SharpMUTerm.Tui/TimersScreenView.cs @@ -0,0 +1,81 @@ +using SharpMUTerm.Core.Configuration; +using SharpConsoleUI; +using SharpConsoleUI.Builders; +using SharpConsoleUI.Controls; +using SharpConsoleUI.Layout; + +namespace SharpMUTerm.Tui; + +/// +/// Composes the F6 Timers screen from real panels (grids) rather than one merged markup blob: a +/// header band carrying the keyboard hints, a body whose timer-list panel and editor panel are +/// separated by a vertical rule, and a Cancel/Save action bar pinned to the last row. The markup for +/// each panel comes from the pure so the content stays +/// unit-tested; this only lays it out. +/// +internal static class TimersScreenView +{ + private const string RuleColor = "#3a4257"; + private const int ListColumnWidth = 56; + + public static IWindowControl Build(IReadOnlyList sets, int selected, int width) + { + var header = Band(TimersScreenRenderer.HeaderLine(width), TimersScreenRenderer.HeaderBg); + var footer = Band(TimersScreenRenderer.FooterLine(sets, selected, width), TimersScreenRenderer.FooterBg); + + // Body: timer list │ editor, as two real columns. + var listCol = Stretch(new MarkupControl(TimersScreenRenderer.ListColumn(sets, selected))); + var editorCol = Stretch(new MarkupControl(Indent(TimersScreenRenderer.EditorColumn(sets, selected)))); + var body = Controls.HorizontalGrid() + .WithAlignment(HorizontalAlignment.Stretch) + .WithVerticalAlignment(VerticalAlignment.Fill) + .Column(c => c.Width(ListColumnWidth).Add(listCol)) + .Column(c => c.Width(1).Add(VerticalRule())) + .Column(c => c.Width(1).Add(new MarkupControl(new List()))) + .Column(c => c.Flex(1).Add(editorCol)) + .Build(); + + // Header on the first row, footer on the last, body taking everything between — so the action + // bar sits at the bottom of the screen instead of trailing the content. + var root = Controls.Grid() + .WithAlignment(HorizontalAlignment.Stretch) + .WithVerticalAlignment(VerticalAlignment.Fill); + root.Rows(GridLength.Cells(1), GridLength.Star(1), GridLength.Cells(1)).Columns(GridLength.Star(1)); + root.Place(header, 0, 0, 1, 1); + root.Place(body, 1, 0, 1, 1); + root.Place(footer, 2, 0, 1, 1); + + return root.Build(); + } + + private static MarkupControl Band(string line, string bg) => new(new List { line }) + { + BackgroundColor = new Color(bg), + HorizontalAlignment = HorizontalAlignment.Stretch, + }; + + private static MarkupControl Stretch(MarkupControl control) + { + control.HorizontalAlignment = HorizontalAlignment.Stretch; + return control; + } + + /// + /// The one-cell rule between the columns. A with no lines measures to + /// nothing and never paints its background, so the rule is an empty grid instead — a grid's + /// background covers its whole arranged area, giving a full-height hairline. + /// + private static IWindowControl VerticalRule() + { + var rule = Controls.HorizontalGrid() + .WithAlignment(HorizontalAlignment.Stretch) + .WithVerticalAlignment(VerticalAlignment.Fill) + .Column(c => c.Flex(1).Add(new MarkupControl(new List()))) + .Build(); + rule.BackgroundColor = new Color(RuleColor); + return rule; + } + + /// Prefixes each editor row with a space so it doesn't sit flush against the rule. + private static List Indent(IEnumerable lines) => lines.Select(l => " " + l).ToList(); +} From 0198a1dd57c7f26bacb142500ab34039d53685e7 Mon Sep 17 00:00:00 2001 From: Harry Cordewener Date: Tue, 28 Jul 2026 16:07:38 -0500 Subject: [PATCH 04/23] F7/F8/F9 Options: apply the treatment, then consolidate the chrome Completes backlog item 1 -- all eight settings screens now share the F5 treatment. The three options screens share one renderer, so they share one view: OptionsScreenView.Build(title, fkey, rows). They are a single options list rather than two panes, so the body is one elevated card sized to its content instead of a column split with a rule -- inventing a division that isn't there would have been the wrong kind of consistency. With every screen converted, the deferred consolidation pass follows. Six copies of the palette and helpers collapse into ScreenPalette, ScreenChrome, and MarkupText. That last one goes wider than the settings screens: nine copies of Escape and two independently hand-rolled VisibleLength scanners across seven files, all now one implementation. Two divergent width-measuring routines was the duplication most likely to silently mis-pad a column. Verified the main UI is untouched by that reach: the default workspace, menu, split and spawn frames are byte-identical before and after. SharpMUTermApp.Markup and SettingsOverlay.MarkupPanel are deleted -- with no markup screens left, the adapter has no callers. Two inconsistencies surfaced by putting the fragments in one place: F2 and F5 never showed their F-key in the header hints, and F5's action bar said lowercase "cancel". Both now match the other six. Net -398 lines. 514 tests pass, unchanged. Co-Authored-By: Claude Opus 5 (1M context) --- docs/HANDOFF.md | 48 ++--- src/SharpMUTerm.Tui/AliasesScreenRenderer.cs | 49 +----- src/SharpMUTerm.Tui/AliasesScreenView.cs | 45 +---- src/SharpMUTerm.Tui/CaptureLineRenderer.cs | 4 +- src/SharpMUTerm.Tui/CommandSurfaceRenderer.cs | 44 +---- src/SharpMUTerm.Tui/KeypadScreenRenderer.cs | 49 +----- src/SharpMUTerm.Tui/KeypadScreenView.cs | 45 +---- src/SharpMUTerm.Tui/MarkupFormatter.cs | 4 +- src/SharpMUTerm.Tui/MarkupText.cs | 50 ++++++ src/SharpMUTerm.Tui/OptionsScreenRenderer.cs | 165 ++++++++++++------ src/SharpMUTerm.Tui/OptionsScreenView.cs | 73 ++++++++ src/SharpMUTerm.Tui/Powerline.cs | 3 +- src/SharpMUTerm.Tui/RailRenderer.cs | 3 +- src/SharpMUTerm.Tui/ScreenChrome.cs | 67 +++++++ src/SharpMUTerm.Tui/ScreenPalette.cs | 41 +++++ src/SharpMUTerm.Tui/SettingsOverlay.cs | 21 +-- src/SharpMUTerm.Tui/SharpMUTermApp.cs | 27 +-- src/SharpMUTerm.Tui/TimersScreenRenderer.cs | 49 +----- src/SharpMUTerm.Tui/TimersScreenView.cs | 46 +---- src/SharpMUTerm.Tui/TriggersScreenRenderer.cs | 48 +---- src/SharpMUTerm.Tui/TriggersScreenView.cs | 49 +----- src/SharpMUTerm.Tui/WorldsScreenRenderer.cs | 94 ++-------- src/SharpMUTerm.Tui/WorldsScreenView.cs | 59 ++----- 23 files changed, 458 insertions(+), 625 deletions(-) create mode 100644 src/SharpMUTerm.Tui/MarkupText.cs create mode 100644 src/SharpMUTerm.Tui/OptionsScreenView.cs create mode 100644 src/SharpMUTerm.Tui/ScreenChrome.cs create mode 100644 src/SharpMUTerm.Tui/ScreenPalette.cs diff --git a/docs/HANDOFF.md b/docs/HANDOFF.md index 03257d60..93a63fe3 100644 --- a/docs/HANDOFF.md +++ b/docs/HANDOFF.md @@ -14,36 +14,24 @@ Context for whoever (human or agent) picks up this work next. Ordered roughly by value. Nothing here is blocking; this is the outstanding polish/feature backlog. -### 1. Apply the panel treatment to the other config screens - -**Status:** offered, awaiting go-ahead. -**Why:** F5 (Worlds & Characters) was rebuilt into a proper full-screen control -tree — header band, real column panels, an editing pane laid out with a -`HorizontalGrid`, and a footer action bar pinned to the bottom (see -`WorldsScreenView.cs`). The other settings screens still render in the older -"single merged markup blob" style: - -- **F2** Triggers & spawn routing — `TriggersScreenRenderer` -- **F3** Aliases — `AliasesScreenRenderer` -- **F4** Keypad/macros — `KeypadScreenRenderer` -- **F6** Timers — `TimersScreenRenderer` -- **F7** Text & ANSI options — `OptionsScreenRenderer.TextAnsi` -- **F8** Input & spellcheck — `OptionsScreenRenderer.InputSpellcheck` -- **F9** Logging — `OptionsScreenRenderer.Logging` - -They are **not broken** — they render cleanly on the reworked frameless overlay -with the deep panel background — but they lack: a full-width header band with -keyboard hints, real column panels, a bottom-pinned Cancel/Save action bar, and -the elevated background bands F5 now has. - -**How:** follow the F5 pattern exactly. `WorldsScreenRenderer` was refactored to -expose each region as a pure markup block (`HeaderLine`, `FooterLine`, -`WorldsColumn`, `DetailColumn`, `FormColumn`, `TriggersColumn`); `WorldsScreenView` -composes those into controls. Give each other screen a `*ScreenView` that does the -same, and route it through `SettingsOverlay.Toggle(key, Func)` -(the control-hosting overload already exists) plus the snapshot path in -`SharpMUTermApp.RenderSnapshot`. Keep the pure `Render(...)` method on each renderer -for the unit tests. +### 1. Apply the panel treatment to the other config screens — done + +**Status:** complete. All eight settings screens (F2–F9) now render as composed +control trees: a full-width header band with keyboard hints, the body on real +panels, and a Cancel/Save action bar pinned to the last row. + +Each screen has a pure `*ScreenRenderer` exposing its regions as markup blocks +(`HeaderLine`, `FooterLine`, and its body columns) plus a `*ScreenView` that +composes them into controls; the renderer's `Render(...)` still merges the same +blocks into one line list for the unit tests. F7/F8/F9 share +`OptionsScreenRenderer`/`OptionsScreenView`, which take an `OptionsScreen` +(title + F-key + rows) — those screens are a single options list, so their body +is one full-width elevated card rather than a column split. + +Wiring is one table, `SharpMUTermApp.SettingsScreens()`, read by both the global +F-key shortcuts and the `--view` snapshot lookup. Shared chrome lives in +`ScreenPalette` (colours), `ScreenChrome` (hint/action fragments, band, vertical +rule, indent) and `MarkupText` (escape, visible width, padding, spread). ### 2. Task #20 — fold inline graphics into SharpConsoleUI's Kitty support diff --git a/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs b/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs index 716214e7..a90f2b82 100644 --- a/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs @@ -1,7 +1,8 @@ using System.Globalization; -using System.Text.RegularExpressions; using SharpMUTerm.Core.Automation; using SharpMUTerm.Core.Configuration; +using static SharpMUTerm.Tui.MarkupText; +using static SharpMUTerm.Tui.ScreenPalette; namespace SharpMUTerm.Tui; @@ -16,18 +17,8 @@ namespace SharpMUTerm.Tui; /// internal static class AliasesScreenRenderer { - private const string Accent = "#00f5b7"; private const int ColumnWidth = 54; - // Palette shared with the view (which sets these as control backgrounds). - internal const string HeaderBg = "#232b3d"; - internal const string FooterBg = "#232b3d"; - private const string Label = "#7c8699"; - private const string Value = "#d7deec"; - private const string Ink = "#0f1620"; - - private static readonly Regex TagPattern = new(@"\[[^\[\]]*\]", RegexOptions.Compiled); - /// /// Merges every sub-block into one line list (header, alias list | editor, footer). Used by the /// unit tests and as a width-agnostic fallback; the live view composes the same blocks into @@ -60,8 +51,7 @@ public static List Render(IReadOnlyList sets, int selected) internal static string HeaderLine(int width) { var title = $"[bold {Value}] Aliases[/]"; - var hints = $"[{Label}]↑↓ select · ⇥ switch pane · ⏎ edit · [/][{Accent}]F3[/][{Label}]/[/]" - + $"[{Accent}]Esc[/][{Label}] close [/]"; + var hints = ScreenChrome.Hints("↑↓ select · ⇥ switch pane · ⏎ edit", "F3"); return SpreadLR(" " + title, hints, width); } @@ -77,7 +67,7 @@ internal static string FooterLine(IReadOnlyList sets, int selected, + $"[{Label}] · set {Escape(entries[selected].SetName)}[/]"; } - var actions = $"[{Label}] [[Esc]] Cancel [/] [{Ink} on {Accent}] [[⏎]] Save [/] "; + var actions = ScreenChrome.Actions(); return SpreadLR(" " + context, actions, width); } @@ -170,35 +160,4 @@ private static string FirstLine(string text) var newlineIndex = text.IndexOf('\n'); return newlineIndex < 0 ? text : text[..newlineIndex]; } - - /// Lays a left- and right-hand fragment on one line, right-aligning the right to . - private static string SpreadLR(string left, string right, int width) - { - if (width <= 0) - { - return $"{left} {right}"; - } - - var gap = Math.Max(1, width - VisibleLength(left) - VisibleLength(right)); - return left + new string(' ', gap) + right; - } - - /// Pads a markup string to a target *visible* column width, ignoring markup tags. - private static string PadVisible(string markup, int width) - { - var visible = VisibleLength(markup); - return visible >= width ? markup : markup + new string(' ', width - visible); - } - - /// - /// Counts the printable length of a markup string: escaped brackets ([[/]]) count - /// as one literal character each, and [tag] wrappers are stripped entirely. - /// - private static int VisibleLength(string markup) - { - var protectedText = markup.Replace("[[", "\u0001").Replace("]]", "\u0002"); - return TagPattern.Replace(protectedText, string.Empty).Length; - } - - private static string Escape(string text) => text.Replace("[", "[[").Replace("]", "]]"); } diff --git a/src/SharpMUTerm.Tui/AliasesScreenView.cs b/src/SharpMUTerm.Tui/AliasesScreenView.cs index c8b380aa..a81ae153 100644 --- a/src/SharpMUTerm.Tui/AliasesScreenView.cs +++ b/src/SharpMUTerm.Tui/AliasesScreenView.cs @@ -15,23 +15,23 @@ namespace SharpMUTerm.Tui; /// internal static class AliasesScreenView { - private const string RuleColor = "#3a4257"; private const int ListColumnWidth = 56; public static IWindowControl Build(IReadOnlyList sets, int selected, int width) { - var header = Band(AliasesScreenRenderer.HeaderLine(width), AliasesScreenRenderer.HeaderBg); - var footer = Band(AliasesScreenRenderer.FooterLine(sets, selected, width), AliasesScreenRenderer.FooterBg); + var header = ScreenChrome.Band(AliasesScreenRenderer.HeaderLine(width), ScreenPalette.HeaderBg); + var footer = ScreenChrome.Band(AliasesScreenRenderer.FooterLine(sets, selected, width), ScreenPalette.FooterBg); // Body: alias list │ editor, as two real columns. - var listCol = Stretch(new MarkupControl(AliasesScreenRenderer.ListColumn(sets, selected))); - var editorCol = Stretch(new MarkupControl(Indent(AliasesScreenRenderer.EditorColumn(sets, selected)))); + var listCol = ScreenChrome.Stretch(new MarkupControl(AliasesScreenRenderer.ListColumn(sets, selected))); + var editorCol = ScreenChrome.Stretch( + new MarkupControl(ScreenChrome.Indent(AliasesScreenRenderer.EditorColumn(sets, selected)))); var body = Controls.HorizontalGrid() .WithAlignment(HorizontalAlignment.Stretch) .WithVerticalAlignment(VerticalAlignment.Fill) .Column(c => c.Width(ListColumnWidth).Add(listCol)) - .Column(c => c.Width(1).Add(VerticalRule())) - .Column(c => c.Width(1).Add(new MarkupControl(new List()))) + .Column(c => c.Width(1).Add(ScreenChrome.VerticalRule())) + .Column(c => c.Width(1).Add(ScreenChrome.Filler())) .Column(c => c.Flex(1).Add(editorCol)) .Build(); @@ -47,35 +47,4 @@ public static IWindowControl Build(IReadOnlyList sets, int selected, return root.Build(); } - - private static MarkupControl Band(string line, string bg) => new(new List { line }) - { - BackgroundColor = new Color(bg), - HorizontalAlignment = HorizontalAlignment.Stretch, - }; - - private static MarkupControl Stretch(MarkupControl control) - { - control.HorizontalAlignment = HorizontalAlignment.Stretch; - return control; - } - - /// - /// The one-cell rule between the columns. A with no lines measures to - /// nothing and never paints its background, so the rule is an empty grid instead — a grid's - /// background covers its whole arranged area, giving a full-height hairline. - /// - private static IWindowControl VerticalRule() - { - var rule = Controls.HorizontalGrid() - .WithAlignment(HorizontalAlignment.Stretch) - .WithVerticalAlignment(VerticalAlignment.Fill) - .Column(c => c.Flex(1).Add(new MarkupControl(new List()))) - .Build(); - rule.BackgroundColor = new Color(RuleColor); - return rule; - } - - /// Prefixes each editor row with a space so it doesn't sit flush against the rule. - private static List Indent(IEnumerable lines) => lines.Select(l => " " + l).ToList(); } diff --git a/src/SharpMUTerm.Tui/CaptureLineRenderer.cs b/src/SharpMUTerm.Tui/CaptureLineRenderer.cs index 0ddbff47..287950f3 100644 --- a/src/SharpMUTerm.Tui/CaptureLineRenderer.cs +++ b/src/SharpMUTerm.Tui/CaptureLineRenderer.cs @@ -1,3 +1,5 @@ +using static SharpMUTerm.Tui.MarkupText; + namespace SharpMUTerm.Tui; /// @@ -12,6 +14,4 @@ public static string Line(string pattern) ArgumentNullException.ThrowIfNull(pattern); return $"[dim]{Glyphs.Capture} capture {Escape(pattern)}[/]"; } - - private static string Escape(string text) => text.Replace("[", "[[").Replace("]", "]]"); } diff --git a/src/SharpMUTerm.Tui/CommandSurfaceRenderer.cs b/src/SharpMUTerm.Tui/CommandSurfaceRenderer.cs index 9fd7707f..52ae9937 100644 --- a/src/SharpMUTerm.Tui/CommandSurfaceRenderer.cs +++ b/src/SharpMUTerm.Tui/CommandSurfaceRenderer.cs @@ -1,5 +1,6 @@ using System.Text; using SharpMUTerm.Core.Commands; +using static SharpMUTerm.Tui.MarkupText; namespace SharpMUTerm.Tui; @@ -103,47 +104,4 @@ private static string Row(CommandItem item, bool selected, int width) var pad = width > VisibleLength(text) ? new string(' ', width - VisibleLength(text)) : string.Empty; return $"[#18181c on #00f5b7]{text}{pad}[/]"; } - - /// Visible length of a markup string: strips […] tags, counts [[/]] as one. - private static int VisibleLength(string markup) - { - var length = 0; - var i = 0; - while (i < markup.Length) - { - var c = markup[i]; - if (c == '[') - { - if (i + 1 < markup.Length && markup[i + 1] == '[') - { - length++; - i += 2; - continue; - } - - var close = markup.IndexOf(']', i); - if (close < 0) - { - return length + (markup.Length - i); - } - - i = close + 1; - continue; - } - - if (c == ']' && i + 1 < markup.Length && markup[i + 1] == ']') - { - length++; - i += 2; - continue; - } - - length++; - i++; - } - - return length; - } - - private static string Escape(string text) => text.Replace("[", "[[").Replace("]", "]]"); } diff --git a/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs b/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs index 1820ffff..b784e43e 100644 --- a/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs @@ -1,6 +1,7 @@ using System.Globalization; -using System.Text.RegularExpressions; using SharpMUTerm.Core.Automation; +using static SharpMUTerm.Tui.MarkupText; +using static SharpMUTerm.Tui.ScreenPalette; namespace SharpMUTerm.Tui; @@ -14,19 +15,9 @@ namespace SharpMUTerm.Tui; /// internal static class KeypadScreenRenderer { - private const string Accent = "#00f5b7"; private const int KeyColumnWidth = 12; private const int ColumnWidth = 48; - // Palette shared with the view (which sets these as control backgrounds). - internal const string HeaderBg = "#232b3d"; - internal const string FooterBg = "#232b3d"; - private const string Label = "#7c8699"; - private const string Value = "#d7deec"; - private const string Ink = "#0f1620"; - - private static readonly Regex TagPattern = new(@"\[[^\[\]]*\]", RegexOptions.Compiled); - private static readonly int[][] NumpadRows = { new[] { 7, 8, 9 }, @@ -66,8 +57,7 @@ public static List Render(IReadOnlyList macros) internal static string HeaderLine(int width) { var title = $"[bold {Value}] Keypad & hotkeys[/]"; - var hints = $"[{Label}]↑↓ select · ⇥ switch pane · ⏎ rebind · [/][{Accent}]F4[/][{Label}]/[/]" - + $"[{Accent}]Esc[/][{Label}] close [/]"; + var hints = ScreenChrome.Hints("↑↓ select · ⇥ switch pane · ⏎ rebind", "F4"); return SpreadLR(" " + title, hints, width); } @@ -92,7 +82,7 @@ internal static string FooterLine(IReadOnlyList macros, int width) var context = $"[{Label}]{total} bindings[/]" + $"[{Label}] · {bound.ToString(CultureInfo.InvariantCulture)} of 9 numpad keys bound[/]"; - var actions = $"[{Label}] [[Esc]] Cancel [/] [{Ink} on {Accent}] [[⏎]] Save [/] "; + var actions = ScreenChrome.Actions(); return SpreadLR(" " + context, actions, width); } @@ -170,35 +160,4 @@ private static string Hotkey(Macro macro) private static string Truncate(string text, int maxLength) => text.Length <= maxLength ? text : string.Concat(text.AsSpan(0, maxLength - 1), "…"); - - /// Lays a left- and right-hand fragment on one line, right-aligning the right to . - private static string SpreadLR(string left, string right, int width) - { - if (width <= 0) - { - return $"{left} {right}"; - } - - var gap = Math.Max(1, width - VisibleLength(left) - VisibleLength(right)); - return left + new string(' ', gap) + right; - } - - /// Pads a markup string to a target *visible* column width, ignoring markup tags. - private static string PadVisible(string markup, int width) - { - var visible = VisibleLength(markup); - return visible >= width ? markup : markup + new string(' ', width - visible); - } - - /// - /// Counts the printable length of a markup string: escaped brackets ([[/]]) count - /// as one literal character each, and [tag] wrappers are stripped entirely. - /// - private static int VisibleLength(string markup) - { - var protectedText = markup.Replace("[[", "\u0001").Replace("]]", "\u0002"); - return TagPattern.Replace(protectedText, string.Empty).Length; - } - - private static string Escape(string text) => text.Replace("[", "[[").Replace("]", "]]"); } diff --git a/src/SharpMUTerm.Tui/KeypadScreenView.cs b/src/SharpMUTerm.Tui/KeypadScreenView.cs index 2f75b6c7..61dd9829 100644 --- a/src/SharpMUTerm.Tui/KeypadScreenView.cs +++ b/src/SharpMUTerm.Tui/KeypadScreenView.cs @@ -16,23 +16,23 @@ namespace SharpMUTerm.Tui; /// internal static class KeypadScreenView { - private const string RuleColor = "#3a4257"; private const int NumpadColumnWidth = 50; public static IWindowControl Build(IReadOnlyList macros, int width) { - var header = Band(KeypadScreenRenderer.HeaderLine(width), KeypadScreenRenderer.HeaderBg); - var footer = Band(KeypadScreenRenderer.FooterLine(macros, width), KeypadScreenRenderer.FooterBg); + var header = ScreenChrome.Band(KeypadScreenRenderer.HeaderLine(width), ScreenPalette.HeaderBg); + var footer = ScreenChrome.Band(KeypadScreenRenderer.FooterLine(macros, width), ScreenPalette.FooterBg); // Body: numpad grid │ hotkey list, as two real columns. - var numpadCol = Stretch(new MarkupControl(KeypadScreenRenderer.NumpadColumn(macros))); - var hotkeysCol = Stretch(new MarkupControl(Indent(KeypadScreenRenderer.HotkeysColumn(macros)))); + var numpadCol = ScreenChrome.Stretch(new MarkupControl(KeypadScreenRenderer.NumpadColumn(macros))); + var hotkeysCol = ScreenChrome.Stretch( + new MarkupControl(ScreenChrome.Indent(KeypadScreenRenderer.HotkeysColumn(macros)))); var body = Controls.HorizontalGrid() .WithAlignment(HorizontalAlignment.Stretch) .WithVerticalAlignment(VerticalAlignment.Fill) .Column(c => c.Width(NumpadColumnWidth).Add(numpadCol)) - .Column(c => c.Width(1).Add(VerticalRule())) - .Column(c => c.Width(1).Add(new MarkupControl(new List()))) + .Column(c => c.Width(1).Add(ScreenChrome.VerticalRule())) + .Column(c => c.Width(1).Add(ScreenChrome.Filler())) .Column(c => c.Flex(1).Add(hotkeysCol)) .Build(); @@ -48,35 +48,4 @@ public static IWindowControl Build(IReadOnlyList macros, int width) return root.Build(); } - - private static MarkupControl Band(string line, string bg) => new(new List { line }) - { - BackgroundColor = new Color(bg), - HorizontalAlignment = HorizontalAlignment.Stretch, - }; - - private static MarkupControl Stretch(MarkupControl control) - { - control.HorizontalAlignment = HorizontalAlignment.Stretch; - return control; - } - - /// - /// The one-cell rule between the columns. A with no lines measures to - /// nothing and never paints its background, so the rule is an empty grid instead — a grid's - /// background covers its whole arranged area, giving a full-height hairline. - /// - private static IWindowControl VerticalRule() - { - var rule = Controls.HorizontalGrid() - .WithAlignment(HorizontalAlignment.Stretch) - .WithVerticalAlignment(VerticalAlignment.Fill) - .Column(c => c.Flex(1).Add(new MarkupControl(new List()))) - .Build(); - rule.BackgroundColor = new Color(RuleColor); - return rule; - } - - /// Prefixes each hotkey row with a space so it doesn't sit flush against the rule. - private static List Indent(IEnumerable lines) => lines.Select(l => " " + l).ToList(); } diff --git a/src/SharpMUTerm.Tui/MarkupFormatter.cs b/src/SharpMUTerm.Tui/MarkupFormatter.cs index 4e386345..47023408 100644 --- a/src/SharpMUTerm.Tui/MarkupFormatter.cs +++ b/src/SharpMUTerm.Tui/MarkupFormatter.cs @@ -1,6 +1,7 @@ using System.Text; using SharpMUTerm.Core.Text; using SharpMUTerm.Core.Theming; +using static SharpMUTerm.Tui.MarkupText; namespace SharpMUTerm.Tui; @@ -154,7 +155,4 @@ private void AppendSpan(StringBuilder sb, StyledSpan span) }; private static string Hex(Rgb rgb) => $"#{rgb.R:x2}{rgb.G:x2}{rgb.B:x2}"; - - /// Escapes markup metacharacters so literal text can't be parsed as tags. - private static string Escape(string text) => text.Replace("[", "[[").Replace("]", "]]"); } diff --git a/src/SharpMUTerm.Tui/MarkupText.cs b/src/SharpMUTerm.Tui/MarkupText.cs new file mode 100644 index 00000000..a2f7244b --- /dev/null +++ b/src/SharpMUTerm.Tui/MarkupText.cs @@ -0,0 +1,50 @@ +using System.Text.RegularExpressions; + +namespace SharpMUTerm.Tui; + +/// +/// Helpers for the Spectre-style markup the renderers emit: escaping literal brackets, measuring a +/// string's printable width past its [tag] wrappers, and laying text out to that width. Every +/// renderer that pads or right-aligns markup needs the same measurement, so it lives here rather than +/// being copied per screen — a divergent copy silently mis-pads a column. +/// +internal static class MarkupText +{ + private static readonly Regex TagPattern = new(@"\[[^\[\]]*\]", RegexOptions.Compiled); + + /// Escapes literal brackets so markup can't be injected by configured text. + internal static string Escape(string text) => text.Replace("[", "[[").Replace("]", "]]"); + + /// + /// Counts the printable length of a markup string: escaped brackets ([[/]]) count + /// as one literal character each, and [tag] wrappers are stripped entirely. + /// + internal static int VisibleLength(string markup) + { + var protectedText = markup.Replace("[[", "\u0001").Replace("]]", "\u0002"); + return TagPattern.Replace(protectedText, string.Empty).Length; + } + + /// Pads a markup string to a target *visible* column width, ignoring markup tags. + internal static string PadVisible(string markup, int width) + { + var visible = VisibleLength(markup); + return visible >= width ? markup : markup + new string(' ', width - visible); + } + + /// + /// Lays a left- and right-hand fragment on one line, right-aligning the right to + /// . A non-positive width means "width unknown" (the unit-test path), which + /// falls back to a fixed gap. + /// + internal static string SpreadLR(string left, string right, int width) + { + if (width <= 0) + { + return $"{left} {right}"; + } + + var gap = Math.Max(1, width - VisibleLength(left) - VisibleLength(right)); + return left + new string(' ', gap) + right; + } +} diff --git a/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs b/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs index da685c61..bc417e57 100644 --- a/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs @@ -1,49 +1,89 @@ +using System.Globalization; using SharpMUTerm.Core.Configuration; +using static SharpMUTerm.Tui.MarkupText; +using static SharpMUTerm.Tui.ScreenPalette; namespace SharpMUTerm.Tui; /// -/// Renders the shared options-list body used by the F7 (Text & ANSI), F8 (Input & -/// spellcheck), and F9 (Logging) screens: a header, toggle/value rows grouped under dim section -/// headers, and a footer. Pure so the panel is unit-testable; the modal host just displays what -/// this produces. +/// Produces the markup sub-blocks shared by the F7 (Text & ANSI), F8 (Input & spellcheck), and +/// F9 (Logging) screens — the header band, the options list (toggle/value rows grouped under dim +/// section headers), and the footer action bar. The three screens differ only in their title, F-key, +/// and rows, so the blocks take an rather than being written per screen. +/// composes them into a real panel for the live/snapshot view; +/// merges the same blocks into a single +/// line list for the unit tests. Pure so every block is testable. /// internal static class OptionsScreenRenderer { - private const string Accent = "#00f5b7"; private const int LabelWidth = 28; /// A single options-list row: a toggle, a value row, a section header, or a spacer. public readonly record struct OptionRow(string Label, string? Value, bool? Toggle, string? Hint = null); + /// One options screen: the title and F-key its chrome shows, plus the rows it lists. + internal readonly record struct OptionsScreen(string Title, string FKey, IReadOnlyList Rows); + + /// + /// Merges every sub-block into one line list (header, options, footer). Used by the unit tests and + /// as a width-agnostic fallback; the live view composes the same blocks into panels instead. + /// public static List Render(string title, string fkey, IReadOnlyList rows) { ArgumentNullException.ThrowIfNull(rows); - var lines = new List - { - $"[dim]‹ back[/] [bold]{Escape(title)}[/] [dim]{Escape(fkey)}[/]", - string.Empty, - }; + var lines = new List { HeaderLine(title, fkey, 0), string.Empty }; + lines.AddRange(BodyColumn(rows)); + lines.Add(string.Empty); + lines.Add(FooterLine(rows, 0)); + return lines; + } + + /// Merges a whole screen into one line list. + internal static List Render(OptionsScreen screen) => Render(screen.Title, screen.FKey, screen.Rows); + + /// + /// The back affordance and screen title on the left, the keyboard hints right-aligned to + /// . + /// + internal static string HeaderLine(string title, string fkey, int width) + { + var heading = $"[{Label}]‹ back[/] [bold {Value}]{Escape(title)}[/]"; + return SpreadLR(" " + heading, ScreenChrome.Hints("↑↓ select · ⏎ change", Escape(fkey)), width); + } + + /// The action bar: how much the screen holds on the left, cancel/save on the right. + internal static string FooterLine(IReadOnlyList rows, int width) + { + ArgumentNullException.ThrowIfNull(rows); - foreach (var row in rows) + var options = rows.Count(r => !IsSpacer(r) && !IsSection(r)); + var sections = rows.Count(IsSection); + var context = $"[{Label}]{Plural(options, "option")}[/]"; + if (sections > 0) { - lines.Add(RenderRow(row)); + context += $"[{Label}] · {Plural(sections, "section")}[/]"; } - lines.Add(string.Empty); - lines.Add("[dim][[Cancel]] [[Save]][/]"); - return lines; + return SpreadLR(" " + context, ScreenChrome.Actions(), width); + } + + /// The options list itself — one line per row, in order. + internal static List BodyColumn(IReadOnlyList rows) + { + ArgumentNullException.ThrowIfNull(rows); + + return rows.Select(RenderRow).ToList(); } private static string RenderRow(OptionRow row) { - if (row.Label.Length == 0 && row.Value is null && row.Toggle is null) + if (IsSpacer(row)) { return string.Empty; } - if (row.Label.StartsWith("├ ", StringComparison.Ordinal)) + if (IsSection(row)) { return $"[dim]{Escape(row.Label)}[/]"; } @@ -60,57 +100,66 @@ private static string RenderRow(OptionRow row) return $"[dim]{label}[/] {Escape(row.Value ?? string.Empty)}{hint}"; } - /// The F7 "Text & ANSI" screen body. - public static List TextAnsi() - { - var rows = new List - { - new("├ COLOUR", null, null), - new("strip incoming ANSI colour", null, false), - new("allow blink", null, false), - new("underline hyperlinks", null, true), - new(string.Empty, null, null), - new("├ UNICODE", null, null), - new("emoji substitution", null, true), - new("ambiguous width", "narrow", null), - }; - - return Render("Text & ANSI", "F7", rows); - } + /// A blank separator carrying no label, value, or toggle. + private static bool IsSpacer(OptionRow row) => + row.Label.Length == 0 && row.Value is null && row.Toggle is null; - /// The F8 "Input & spellcheck" screen body. - public static List InputSpellcheck() - { - var rows = new List - { - new("├ INPUT", null, null), - new("local echo", null, true), - new("keep per-tab drafts", null, true), - new("newline key", "Shift+Enter", null), - new(string.Empty, null, null), - new("├ SPELLCHECK", null, null), - new("check spelling", null, true), - new("dictionary", "en_US", null), - }; - - return Render("Input & spellcheck", "F8", rows); - } + /// A dim group heading, marked by the branch glyph the screens prefix them with. + private static bool IsSection(OptionRow row) => row.Label.StartsWith("├ ", StringComparison.Ordinal); - /// The F9 "Logging" screen body, reflecting a character's . - public static List Logging(LoggingSettings logging) + /// The F7 "Text & ANSI" screen. + internal static OptionsScreen TextAnsiScreen() => new("Text & ANSI", "F7", new List + { + new("├ COLOUR", null, null), + new("strip incoming ANSI colour", null, false), + new("allow blink", null, false), + new("underline hyperlinks", null, true), + new(string.Empty, null, null), + new("├ UNICODE", null, null), + new("emoji substitution", null, true), + new("ambiguous width", "narrow", null), + }); + + /// The F8 "Input & spellcheck" screen. + internal static OptionsScreen InputSpellcheckScreen() => new("Input & spellcheck", "F8", new List + { + new("├ INPUT", null, null), + new("local echo", null, true), + new("keep per-tab drafts", null, true), + new("newline key", "Shift+Enter", null), + new(string.Empty, null, null), + new("├ SPELLCHECK", null, null), + new("check spelling", null, true), + new("dictionary", "en_US", null), + }); + + /// The F9 "Logging" screen, reflecting a character's . + internal static OptionsScreen LoggingScreen(LoggingSettings logging) { ArgumentNullException.ThrowIfNull(logging); - var rows = new List + return new OptionsScreen("Logging", "F9", new List { new("├ SESSION LOG", null, null), new("format", logging.Format.ToString(), null), new("directory", logging.Directory ?? "(default)", null), new("auto-start on connect", null, logging.Format != LogFormat.None), - }; - - return Render("Logging", "F9", rows); + }); } - private static string Escape(string text) => text.Replace("[", "[[").Replace("]", "]]"); + /// The F7 "Text & ANSI" screen body. + public static List TextAnsi() => Render(TextAnsiScreen()); + + /// The F8 "Input & spellcheck" screen body. + public static List InputSpellcheck() => Render(InputSpellcheckScreen()); + + /// The F9 "Logging" screen body, reflecting a character's . + public static List Logging(LoggingSettings logging) => Render(LoggingScreen(logging)); + + /// Counts a noun for the footer: 1 option, 3 options. + private static string Plural(int count, string noun) + { + var n = count.ToString(CultureInfo.InvariantCulture); + return count == 1 ? $"{n} {noun}" : $"{n} {noun}s"; + } } diff --git a/src/SharpMUTerm.Tui/OptionsScreenView.cs b/src/SharpMUTerm.Tui/OptionsScreenView.cs new file mode 100644 index 00000000..58a510c6 --- /dev/null +++ b/src/SharpMUTerm.Tui/OptionsScreenView.cs @@ -0,0 +1,73 @@ +using SharpConsoleUI; +using SharpConsoleUI.Builders; +using SharpConsoleUI.Controls; +using SharpConsoleUI.Layout; + +namespace SharpMUTerm.Tui; + +/// +/// Composes an options screen (F7 Text & ANSI, F8 Input & spellcheck, F9 Logging) from real +/// panels rather than one merged markup blob: a header band carrying the keyboard hints, the options +/// list on a single full-width elevated card, and a Cancel/Save action bar pinned to the last row. +/// These screens are one list, not two panes, so there is no column split and no vertical rule — the +/// card is the whole body, sized to its content so it reads as a settings surface under the header +/// rather than a lone column floating on the backdrop. The markup comes from the pure +/// so the content stays unit-tested; this only lays it out. +/// +internal static class OptionsScreenView +{ + /// Blank pad rows above and below the list inside the card. + private const int CardPadding = 2; + + public static IWindowControl Build(OptionsScreenRenderer.OptionsScreen screen, int width) + { + var header = ScreenChrome.Band( + OptionsScreenRenderer.HeaderLine(screen.Title, screen.FKey, width), ScreenPalette.HeaderBg); + var footer = ScreenChrome.Band( + OptionsScreenRenderer.FooterLine(screen.Rows, width), ScreenPalette.FooterBg); + + var rows = OptionsScreenRenderer.BodyColumn(screen.Rows); + var card = Card(rows); + + // Header on the first row, footer on the last, the card hugging its content directly beneath the + // header and the remaining space left as backdrop — so the action bar sits at the bottom of the + // screen instead of trailing the content. + var root = Controls.Grid() + .WithAlignment(HorizontalAlignment.Stretch) + .WithVerticalAlignment(VerticalAlignment.Fill); + root.Rows( + GridLength.Cells(1), GridLength.Cells(rows.Count + CardPadding), GridLength.Star(1), + GridLength.Cells(1)) + .Columns(GridLength.Star(1)); + root.Place(header, 0, 0, 1, 1); + root.Place(card, 1, 0, 1, 1); + root.Place(footer, 3, 0, 1, 1); + + return root.Build(); + } + + /// + /// The full-width elevated card holding the list. A only paints the + /// cells its lines cover, so the card is a grid — a grid's background covers its whole arranged + /// area, giving the band its full width and the padding rows their colour. + /// + private static IWindowControl Card(IReadOnlyList rows) + { + var list = new MarkupControl(Pad(rows)) { HorizontalAlignment = HorizontalAlignment.Stretch }; + var card = Controls.HorizontalGrid() + .WithAlignment(HorizontalAlignment.Stretch) + .WithVerticalAlignment(VerticalAlignment.Fill) + .Column(c => c.Flex(1).Add(list)) + .Build(); + card.BackgroundColor = new Color(ScreenPalette.EditBg); + return card; + } + + /// Insets the list one blank row from the header and two columns from the left edge. + private static List Pad(IReadOnlyList rows) + { + var lines = new List { string.Empty }; + lines.AddRange(rows.Select(r => " " + r)); + return lines; + } +} diff --git a/src/SharpMUTerm.Tui/Powerline.cs b/src/SharpMUTerm.Tui/Powerline.cs index f7a689d3..64d6e97f 100644 --- a/src/SharpMUTerm.Tui/Powerline.cs +++ b/src/SharpMUTerm.Tui/Powerline.cs @@ -1,4 +1,5 @@ using System.Text; +using static SharpMUTerm.Tui.MarkupText; namespace SharpMUTerm.Tui; @@ -50,6 +51,4 @@ public static string RightBar(IReadOnlyList segments, string headB return sb.ToString(); } - - private static string Escape(string text) => text.Replace("[", "[[").Replace("]", "]]"); } diff --git a/src/SharpMUTerm.Tui/RailRenderer.cs b/src/SharpMUTerm.Tui/RailRenderer.cs index 70936b6a..b695f0d1 100644 --- a/src/SharpMUTerm.Tui/RailRenderer.cs +++ b/src/SharpMUTerm.Tui/RailRenderer.cs @@ -1,5 +1,6 @@ using SharpMUTerm.Core.Text; using SharpMUTerm.Core.Workspaces; +using static SharpMUTerm.Tui.MarkupText; namespace SharpMUTerm.Tui; @@ -85,6 +86,4 @@ private static string Accent(RailRow row) => row.Accent.Kind == TerminalColorKind.Rgb ? $"#{row.Accent.R:x2}{row.Accent.G:x2}{row.Accent.B:x2}" : DefaultAccent; - - private static string Escape(string text) => text.Replace("[", "[[").Replace("]", "]]"); } diff --git a/src/SharpMUTerm.Tui/ScreenChrome.cs b/src/SharpMUTerm.Tui/ScreenChrome.cs new file mode 100644 index 00000000..65c9fb3a --- /dev/null +++ b/src/SharpMUTerm.Tui/ScreenChrome.cs @@ -0,0 +1,67 @@ +using SharpConsoleUI; +using SharpConsoleUI.Builders; +using SharpConsoleUI.Controls; +using SharpConsoleUI.Layout; + +namespace SharpMUTerm.Tui; + +/// +/// The chrome every full-screen settings screen (F2–F9) shares: the keyboard-hint and action-bar +/// fragments its renderer writes, and the band / rule / inset panels its view composes. The screens +/// differ in their body, not their frame, so the frame lives here — a header band, a Cancel/Save +/// action bar, and the hairlines between columns look and behave the same on all of them. +/// +internal static class ScreenChrome +{ + /// + /// The right-hand keyboard hints of a header band: the screen's verbs, then how to close it. + /// is the F-key that also toggles the screen (F6/Esc close). + /// + internal static string Hints(string verbs, string fkey) => + $"[{ScreenPalette.Label}]{verbs} · [/][{ScreenPalette.Accent}]{fkey}[/][{ScreenPalette.Label}]/[/]" + + $"[{ScreenPalette.Accent}]Esc[/][{ScreenPalette.Label}] close [/]"; + + /// + /// The right-hand actions of a footer bar. lets a screen with a + /// context colour (F5's per-world accent) tint the Save chip; it defaults to the app accent. + /// + internal static string Actions(string? accent = null) => + $"[{ScreenPalette.Label}] [[Esc]] Cancel [/] " + + $"[{ScreenPalette.Ink} on {accent ?? ScreenPalette.Accent}] [[⏎]] Save [/] "; + + /// A full-width one-row band — the header or the footer. + internal static MarkupControl Band(string line, string bg) => new(new List { line }) + { + BackgroundColor = new Color(bg), + HorizontalAlignment = HorizontalAlignment.Stretch, + }; + + /// Widens a column panel to its arranged width so its content isn't hugged. + internal static MarkupControl Stretch(MarkupControl control) + { + control.HorizontalAlignment = HorizontalAlignment.Stretch; + return control; + } + + /// + /// The one-cell rule between two body columns. A with no lines measures + /// to nothing and never paints its background, so the rule is an empty grid instead — a grid's + /// background covers its whole arranged area, giving a full-height hairline. + /// + internal static IWindowControl VerticalRule() + { + var rule = Controls.HorizontalGrid() + .WithAlignment(HorizontalAlignment.Stretch) + .WithVerticalAlignment(VerticalAlignment.Fill) + .Column(c => c.Flex(1).Add(Filler())) + .Build(); + rule.BackgroundColor = new Color(ScreenPalette.Rule); + return rule; + } + + /// An empty panel, used to hold a spacer or flex column open. + internal static MarkupControl Filler() => new(new List()); + + /// Prefixes each line with a space so a column doesn't sit flush against the rule. + internal static List Indent(IEnumerable lines) => lines.Select(l => " " + l).ToList(); +} diff --git a/src/SharpMUTerm.Tui/ScreenPalette.cs b/src/SharpMUTerm.Tui/ScreenPalette.cs new file mode 100644 index 00000000..8f43409a --- /dev/null +++ b/src/SharpMUTerm.Tui/ScreenPalette.cs @@ -0,0 +1,41 @@ +namespace SharpMUTerm.Tui; + +/// +/// The colours the full-screen settings screens (F2–F9) are built from. Renderers interpolate them +/// into markup tags; the views hand the same hexes to as control +/// backgrounds, so the bands a renderer writes text for and the panel a view paints agree by +/// construction. Screen files pull these in with +/// using static SharpMUTerm.Tui.ScreenPalette;. +/// +internal static class ScreenPalette +{ + /// The app accent — checkmarks, the Save action, and a world's fallback colour. + internal const string Accent = "#00f5b7"; + + /// The overlay backdrop the screens float on. + internal const string PanelBg = "#171b24"; + + /// Default text on the backdrop. + internal const string PanelFg = "#c8d0e0"; + + /// The header band behind the title and keyboard hints. + internal const string HeaderBg = "#232b3d"; + + /// The footer band behind the action bar; the same tone as the header. + internal const string FooterBg = "#232b3d"; + + /// The elevated card an editing pane or options list sits on. + internal const string EditBg = "#1d2333"; + + /// Secondary text: field labels, hints, and footer context. + internal const string Label = "#7c8699"; + + /// Primary text: titles and field values. + internal const string Value = "#d7deec"; + + /// Hairlines — column rules and separators. + internal const string Rule = "#3a4257"; + + /// Near-black, for text printed *on* the accent (the Save chip). + internal const string Ink = "#0f1620"; +} diff --git a/src/SharpMUTerm.Tui/SettingsOverlay.cs b/src/SharpMUTerm.Tui/SettingsOverlay.cs index 488dc6da..16b22bdd 100644 --- a/src/SharpMUTerm.Tui/SettingsOverlay.cs +++ b/src/SharpMUTerm.Tui/SettingsOverlay.cs @@ -1,23 +1,19 @@ using SharpConsoleUI; using SharpConsoleUI.Builders; using SharpConsoleUI.Controls; -using SharpConsoleUI.Layout; +using static SharpMUTerm.Tui.ScreenPalette; namespace SharpMUTerm.Tui; /// /// A full-screen overlay hosting the F2–F9 settings screens. The design specifies these as /// full-screen surfaces, not floating dialogs: this maximises a frameless modal (no title bar, -/// buttons, or resize grip) with a deep panel background. Every screen supplies a control: the -/// converted ones (F2–F6) a composed tree of real panels, the rest a single -/// wrapping their markup. Esc (or the same F-key) closes it. The renderers stay pure and tested; -/// this is a thin host. +/// buttons, or resize grip) with a deep panel background. Every screen supplies a composed tree of +/// real panels. Esc (or the same F-key) closes it. The renderers stay pure and tested; this is a thin +/// host. /// internal sealed class SettingsOverlay { - private const string PanelBg = "#171b24"; - private const string PanelFg = "#c8d0e0"; - private readonly ConsoleWindowSystem _system; private Window? _window; @@ -30,19 +26,12 @@ internal sealed class SettingsOverlay public bool IsOpen => _window is not null; - /// Toggles a screen (a composed control tree, or a ). + /// Toggles a screen's composed control tree. public void Toggle(ConsoleKey key, Func control) => ToggleControl(key, control); /// Renders a screen into a headless frame (used by snapshots). public void OpenForSnapshot(ConsoleKey key, Func control) => Open(key, control); - /// Wraps a screen that is still one markup block in the full-screen panel. - public static MarkupControl MarkupPanel(IReadOnlyList lines) => new(lines.ToList()) - { - BackgroundColor = new Color(PanelBg), - HorizontalAlignment = HorizontalAlignment.Stretch, - }; - private void ToggleControl(ConsoleKey key, Func factory) { if (_window is not null && _openKey == key) diff --git a/src/SharpMUTerm.Tui/SharpMUTermApp.cs b/src/SharpMUTerm.Tui/SharpMUTermApp.cs index 5cfc07fd..3a4b538d 100644 --- a/src/SharpMUTerm.Tui/SharpMUTermApp.cs +++ b/src/SharpMUTerm.Tui/SharpMUTermApp.cs @@ -15,6 +15,7 @@ using SharpConsoleUI.Events; using SharpConsoleUI.Layout; using SColor = SharpConsoleUI.Color; +using static SharpMUTerm.Tui.MarkupText; namespace SharpMUTerm.Tui; @@ -723,8 +724,8 @@ private void RefreshStatusBar() /// The F2–F9 settings screens, in F-key order. Both the global shortcuts and the --view /// snapshot lookup read this one table, so a screen can't be bound to a key without also being /// reachable by name. Each control is built on demand from live config by its pure renderer, so - /// re-opening always reflects current state — converted screens (F2–F6) hand back a composed - /// tree of real panels, the rest a panel. + /// re-opening always reflects current state, and every screen hands back a composed tree of real + /// panels. /// private IReadOnlyList SettingsScreens() => new SettingsScreen[] { @@ -733,9 +734,9 @@ private void RefreshStatusBar() new(ConsoleKey.F4, new[] { "keypad" }, KeypadControl), new(ConsoleKey.F5, new[] { "worlds", "settings" }, WorldsControl), new(ConsoleKey.F6, new[] { "timers" }, TimersControl), - new(ConsoleKey.F7, new[] { "textansi" }, Markup(OptionsScreenRenderer.TextAnsi)), - new(ConsoleKey.F8, new[] { "input" }, Markup(OptionsScreenRenderer.InputSpellcheck)), - new(ConsoleKey.F9, new[] { "logging" }, Markup(() => OptionsScreenRenderer.Logging(ActiveLogging()))), + new(ConsoleKey.F7, new[] { "textansi" }, TextAnsiControl), + new(ConsoleKey.F8, new[] { "input" }, InputSpellcheckControl), + new(ConsoleKey.F9, new[] { "logging" }, LoggingControl), }; /// @@ -823,9 +824,17 @@ private IWindowControl AliasesControl() => AliasesScreenView.Build( private IWindowControl TimersControl() => TimersScreenView.Build( _config.TriggerSets, 0, _system.DesktopDimensions.Width); - /// Hosts a screen that is still one markup block in the overlay's full-screen panel. - private static Func Markup(Func> content) => - () => SettingsOverlay.MarkupPanel(content()); + /// Builds the F7 Text & ANSI screen as a composed control tree (real panels). + private IWindowControl TextAnsiControl() => OptionsScreenView.Build( + OptionsScreenRenderer.TextAnsiScreen(), _system.DesktopDimensions.Width); + + /// Builds the F8 Input & spellcheck screen as a composed control tree (real panels). + private IWindowControl InputSpellcheckControl() => OptionsScreenView.Build( + OptionsScreenRenderer.InputSpellcheckScreen(), _system.DesktopDimensions.Width); + + /// Builds the F9 Logging screen as a composed control tree (real panels). + private IWindowControl LoggingControl() => OptionsScreenView.Build( + OptionsScreenRenderer.LoggingScreen(ActiveLogging()), _system.DesktopDimensions.Width); /// Maps a --view name to a settings screen (F-key + control factory) for snapshots. private (ConsoleKey Key, Func Control)? SettingsView(string view) @@ -1852,8 +1861,6 @@ private string StatusBarMarkup(string character, string host, int port, string s /// Marshals an action onto the UI thread (session events fire on background threads). private void OnUi(Action action) => _system.EnqueueOnUIThread(action); - private static string Escape(string text) => text.Replace("[", "[[").Replace("]", "]]"); - private static SColor ToColor(Rgb rgb) => new(rgb.R, rgb.G, rgb.B, 255); /// diff --git a/src/SharpMUTerm.Tui/TimersScreenRenderer.cs b/src/SharpMUTerm.Tui/TimersScreenRenderer.cs index 18d1beaf..6c527be8 100644 --- a/src/SharpMUTerm.Tui/TimersScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/TimersScreenRenderer.cs @@ -1,7 +1,8 @@ using System.Globalization; -using System.Text.RegularExpressions; using SharpMUTerm.Core.Automation; using SharpMUTerm.Core.Configuration; +using static SharpMUTerm.Tui.MarkupText; +using static SharpMUTerm.Tui.ScreenPalette; namespace SharpMUTerm.Tui; @@ -16,18 +17,8 @@ namespace SharpMUTerm.Tui; /// internal static class TimersScreenRenderer { - private const string Accent = "#00f5b7"; private const int ColumnWidth = 54; - // Palette shared with the view (which sets these as control backgrounds). - internal const string HeaderBg = "#232b3d"; - internal const string FooterBg = "#232b3d"; - private const string Label = "#7c8699"; - private const string Value = "#d7deec"; - private const string Ink = "#0f1620"; - - private static readonly Regex TagPattern = new(@"\[[^\[\]]*\]", RegexOptions.Compiled); - /// /// Merges every sub-block into one line list (header, timer list | editor, footer). Used by the /// unit tests and as a width-agnostic fallback; the live view composes the same blocks into @@ -60,8 +51,7 @@ public static List Render(IReadOnlyList sets, int selected) internal static string HeaderLine(int width) { var title = $"[bold {Value}] Timers[/]"; - var hints = $"[{Label}]↑↓ select · ⇥ switch pane · ⏎ edit · [/][{Accent}]F6[/][{Label}]/[/]" - + $"[{Accent}]Esc[/][{Label}] close [/]"; + var hints = ScreenChrome.Hints("↑↓ select · ⇥ switch pane · ⏎ edit", "F6"); return SpreadLR(" " + title, hints, width); } @@ -77,7 +67,7 @@ internal static string FooterLine(IReadOnlyList sets, int selected, + $"[{Label}] · set {Escape(entries[selected].SetName)}[/]"; } - var actions = $"[{Label}] [[Esc]] Cancel [/] [{Ink} on {Accent}] [[⏎]] Save [/] "; + var actions = ScreenChrome.Actions(); return SpreadLR(" " + context, actions, width); } @@ -160,35 +150,4 @@ private static string Schedule(TimerDefinition timer) => private static string Seconds(TimerDefinition timer) => timer.IntervalSeconds.ToString("0.#", CultureInfo.InvariantCulture); - - /// Lays a left- and right-hand fragment on one line, right-aligning the right to . - private static string SpreadLR(string left, string right, int width) - { - if (width <= 0) - { - return $"{left} {right}"; - } - - var gap = Math.Max(1, width - VisibleLength(left) - VisibleLength(right)); - return left + new string(' ', gap) + right; - } - - /// Pads a markup string to a target *visible* column width, ignoring markup tags. - private static string PadVisible(string markup, int width) - { - var visible = VisibleLength(markup); - return visible >= width ? markup : markup + new string(' ', width - visible); - } - - /// - /// Counts the printable length of a markup string: escaped brackets ([[/]]) count - /// as one literal character each, and [tag] wrappers are stripped entirely. - /// - private static int VisibleLength(string markup) - { - var protectedText = markup.Replace("[[", "\u0001").Replace("]]", "\u0002"); - return TagPattern.Replace(protectedText, string.Empty).Length; - } - - private static string Escape(string text) => text.Replace("[", "[[").Replace("]", "]]"); } diff --git a/src/SharpMUTerm.Tui/TimersScreenView.cs b/src/SharpMUTerm.Tui/TimersScreenView.cs index abca4621..7a782e55 100644 --- a/src/SharpMUTerm.Tui/TimersScreenView.cs +++ b/src/SharpMUTerm.Tui/TimersScreenView.cs @@ -15,23 +15,24 @@ namespace SharpMUTerm.Tui; /// internal static class TimersScreenView { - private const string RuleColor = "#3a4257"; private const int ListColumnWidth = 56; public static IWindowControl Build(IReadOnlyList sets, int selected, int width) { - var header = Band(TimersScreenRenderer.HeaderLine(width), TimersScreenRenderer.HeaderBg); - var footer = Band(TimersScreenRenderer.FooterLine(sets, selected, width), TimersScreenRenderer.FooterBg); + var header = ScreenChrome.Band(TimersScreenRenderer.HeaderLine(width), ScreenPalette.HeaderBg); + var footer = ScreenChrome.Band( + TimersScreenRenderer.FooterLine(sets, selected, width), ScreenPalette.FooterBg); // Body: timer list │ editor, as two real columns. - var listCol = Stretch(new MarkupControl(TimersScreenRenderer.ListColumn(sets, selected))); - var editorCol = Stretch(new MarkupControl(Indent(TimersScreenRenderer.EditorColumn(sets, selected)))); + var listCol = ScreenChrome.Stretch(new MarkupControl(TimersScreenRenderer.ListColumn(sets, selected))); + var editorCol = ScreenChrome.Stretch( + new MarkupControl(ScreenChrome.Indent(TimersScreenRenderer.EditorColumn(sets, selected)))); var body = Controls.HorizontalGrid() .WithAlignment(HorizontalAlignment.Stretch) .WithVerticalAlignment(VerticalAlignment.Fill) .Column(c => c.Width(ListColumnWidth).Add(listCol)) - .Column(c => c.Width(1).Add(VerticalRule())) - .Column(c => c.Width(1).Add(new MarkupControl(new List()))) + .Column(c => c.Width(1).Add(ScreenChrome.VerticalRule())) + .Column(c => c.Width(1).Add(ScreenChrome.Filler())) .Column(c => c.Flex(1).Add(editorCol)) .Build(); @@ -47,35 +48,4 @@ public static IWindowControl Build(IReadOnlyList sets, int selected, return root.Build(); } - - private static MarkupControl Band(string line, string bg) => new(new List { line }) - { - BackgroundColor = new Color(bg), - HorizontalAlignment = HorizontalAlignment.Stretch, - }; - - private static MarkupControl Stretch(MarkupControl control) - { - control.HorizontalAlignment = HorizontalAlignment.Stretch; - return control; - } - - /// - /// The one-cell rule between the columns. A with no lines measures to - /// nothing and never paints its background, so the rule is an empty grid instead — a grid's - /// background covers its whole arranged area, giving a full-height hairline. - /// - private static IWindowControl VerticalRule() - { - var rule = Controls.HorizontalGrid() - .WithAlignment(HorizontalAlignment.Stretch) - .WithVerticalAlignment(VerticalAlignment.Fill) - .Column(c => c.Flex(1).Add(new MarkupControl(new List()))) - .Build(); - rule.BackgroundColor = new Color(RuleColor); - return rule; - } - - /// Prefixes each editor row with a space so it doesn't sit flush against the rule. - private static List Indent(IEnumerable lines) => lines.Select(l => " " + l).ToList(); } diff --git a/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs b/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs index 82f8a029..2aef8f6a 100644 --- a/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs @@ -1,8 +1,9 @@ using System.Globalization; -using System.Text.RegularExpressions; using SharpMUTerm.Core.Automation; using SharpMUTerm.Core.Configuration; using SharpMUTerm.Core.Text; +using static SharpMUTerm.Tui.MarkupText; +using static SharpMUTerm.Tui.ScreenPalette; namespace SharpMUTerm.Tui; @@ -17,18 +18,8 @@ namespace SharpMUTerm.Tui; /// internal static class TriggersScreenRenderer { - private const string Accent = "#00f5b7"; private const int ColumnWidth = 54; - // Palette shared with the view (which sets these as control backgrounds). - internal const string HeaderBg = "#232b3d"; - internal const string FooterBg = "#232b3d"; - private const string Label = "#7c8699"; - private const string Value = "#d7deec"; - private const string Ink = "#0f1620"; - - private static readonly Regex TagPattern = new(@"\[[^\[\]]*\]", RegexOptions.Compiled); - /// /// Merges every sub-block into one line list (header, rule list | editor, footer). Used by the /// unit tests and as a width-agnostic fallback; the live view composes the same blocks into @@ -65,7 +56,7 @@ public static List Render( internal static string HeaderLine(int width) { var title = $"[bold {Value}] Triggers & spawn routing[/]"; - var hints = $"[{Label}]↑↓ select · ⇥ switch pane · ⏎ edit · [/][{Accent}]Esc[/][{Label}] close [/]"; + var hints = ScreenChrome.Hints("↑↓ select · ⇥ switch pane · ⏎ edit", "F2"); return SpreadLR(" " + title, hints, width); } @@ -81,7 +72,7 @@ internal static string FooterLine(IReadOnlyList sets, int selectedTr + $"[{Label}] · set {Escape(flattened[selectedTrigger].SetName)}[/]"; } - var actions = $"[{Label}] [[Esc]] Cancel [/] [{Ink} on {Accent}] [[⏎]] Save [/] "; + var actions = ScreenChrome.Actions(); return SpreadLR(" " + context, actions, width); } @@ -238,35 +229,4 @@ private static string RouteRow(string label, string currentRoute) private static string Hex(TerminalColor color) => color.Kind == TerminalColorKind.Rgb ? $"#{color.R:x2}{color.G:x2}{color.B:x2}" : Accent; - - /// Lays a left- and right-hand fragment on one line, right-aligning the right to . - private static string SpreadLR(string left, string right, int width) - { - if (width <= 0) - { - return $"{left} {right}"; - } - - var gap = Math.Max(1, width - VisibleLength(left) - VisibleLength(right)); - return left + new string(' ', gap) + right; - } - - /// Pads a markup string to a target *visible* column width, ignoring markup tags. - private static string PadVisible(string markup, int width) - { - var visible = VisibleLength(markup); - return visible >= width ? markup : markup + new string(' ', width - visible); - } - - /// - /// Counts the printable length of a markup string: escaped brackets ([[/]]) count - /// as one literal character each, and [tag] wrappers are stripped entirely. - /// - private static int VisibleLength(string markup) - { - var protectedText = markup.Replace("[[", "\u0001").Replace("]]", "\u0002"); - return TagPattern.Replace(protectedText, string.Empty).Length; - } - - private static string Escape(string text) => text.Replace("[", "[[").Replace("]", "]]"); } diff --git a/src/SharpMUTerm.Tui/TriggersScreenView.cs b/src/SharpMUTerm.Tui/TriggersScreenView.cs index 7173d002..08e4bcdd 100644 --- a/src/SharpMUTerm.Tui/TriggersScreenView.cs +++ b/src/SharpMUTerm.Tui/TriggersScreenView.cs @@ -15,7 +15,6 @@ namespace SharpMUTerm.Tui; /// internal static class TriggersScreenView { - private const string RuleColor = "#3a4257"; private const int RulesColumnWidth = 56; public static IWindowControl Build( @@ -24,20 +23,21 @@ public static IWindowControl Build( IReadOnlyList spawnTargets, int width) { - var header = Band(TriggersScreenRenderer.HeaderLine(width), TriggersScreenRenderer.HeaderBg); - var footer = Band( - TriggersScreenRenderer.FooterLine(sets, selectedTrigger, width), TriggersScreenRenderer.FooterBg); + var header = ScreenChrome.Band(TriggersScreenRenderer.HeaderLine(width), ScreenPalette.HeaderBg); + var footer = ScreenChrome.Band( + TriggersScreenRenderer.FooterLine(sets, selectedTrigger, width), ScreenPalette.FooterBg); // Body: rule list │ editor, as two real columns. - var rulesCol = Stretch(new MarkupControl(TriggersScreenRenderer.RulesColumn(sets, selectedTrigger))); - var editorCol = Stretch(new MarkupControl( - Indent(TriggersScreenRenderer.EditorColumn(sets, selectedTrigger, spawnTargets)))); + var rulesCol = ScreenChrome.Stretch( + new MarkupControl(TriggersScreenRenderer.RulesColumn(sets, selectedTrigger))); + var editorCol = ScreenChrome.Stretch(new MarkupControl( + ScreenChrome.Indent(TriggersScreenRenderer.EditorColumn(sets, selectedTrigger, spawnTargets)))); var body = Controls.HorizontalGrid() .WithAlignment(HorizontalAlignment.Stretch) .WithVerticalAlignment(VerticalAlignment.Fill) .Column(c => c.Width(RulesColumnWidth).Add(rulesCol)) - .Column(c => c.Width(1).Add(VerticalRule())) - .Column(c => c.Width(1).Add(new MarkupControl(new List()))) + .Column(c => c.Width(1).Add(ScreenChrome.VerticalRule())) + .Column(c => c.Width(1).Add(ScreenChrome.Filler())) .Column(c => c.Flex(1).Add(editorCol)) .Build(); @@ -53,35 +53,4 @@ public static IWindowControl Build( return root.Build(); } - - private static MarkupControl Band(string line, string bg) => new(new List { line }) - { - BackgroundColor = new Color(bg), - HorizontalAlignment = HorizontalAlignment.Stretch, - }; - - private static MarkupControl Stretch(MarkupControl control) - { - control.HorizontalAlignment = HorizontalAlignment.Stretch; - return control; - } - - /// - /// The one-cell rule between the columns. A with no lines measures to - /// nothing and never paints its background, so the rule is an empty grid instead — a grid's - /// background covers its whole arranged area, giving a full-height hairline. - /// - private static IWindowControl VerticalRule() - { - var rule = Controls.HorizontalGrid() - .WithAlignment(HorizontalAlignment.Stretch) - .WithVerticalAlignment(VerticalAlignment.Fill) - .Column(c => c.Flex(1).Add(new MarkupControl(new List()))) - .Build(); - rule.BackgroundColor = new Color(RuleColor); - return rule; - } - - /// Prefixes each editor row with a space so it doesn't sit flush against the rule. - private static List Indent(IEnumerable lines) => lines.Select(l => " " + l).ToList(); } diff --git a/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs b/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs index 106c553d..1348ec9b 100644 --- a/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs @@ -1,6 +1,8 @@ using System.Globalization; using SharpMUTerm.Core.Configuration; using SharpMUTerm.Core.Text; +using static SharpMUTerm.Tui.MarkupText; +using static SharpMUTerm.Tui.ScreenPalette; namespace SharpMUTerm.Tui; @@ -13,26 +15,15 @@ namespace SharpMUTerm.Tui; /// internal static class WorldsScreenRenderer { - private const string DefaultAccent = "#00f5b7"; private const int LeftColumnWidth = 28; private const int WorldLabelWidth = 9; private const int CharLabelWidth = 10; private const int CharDetailColumnWidth = 40; private const string DividerGlyph = " │ "; - // Palette shared with the view (which sets these as control backgrounds). - internal const string PanelBg = "#171b24"; - internal const string HeaderBg = "#232b3d"; - internal const string EditBg = "#1d2333"; - internal const string FooterBg = "#232b3d"; - private const string Label = "#7c8699"; - private const string Value = "#d7deec"; - private const string RuleColor = "#3a4257"; - private const string Ink = "#0f1620"; - /// The accent hex for the selected world (its own, or the default teal). internal static string AccentFor(IReadOnlyList worlds, int selectedWorld) => - selectedWorld >= 0 && selectedWorld < worlds.Count ? Hex(worlds[selectedWorld].Accent) : DefaultAccent; + selectedWorld >= 0 && selectedWorld < worlds.Count ? Hex(worlds[selectedWorld].Accent) : Accent; /// /// Merges every sub-block into one line list (header, worlds list | detail, character form | @@ -60,7 +51,7 @@ public static List Render( { var character = worlds[selectedWorld].Characters[selectedCharacter]; lines.Add(string.Empty); - lines.Add(Band($"[{RuleColor}]{new string('─', width > 4 ? width - 2 : 60)}[/]", EditBg, width)); + lines.Add(Band($"[{Rule}]{new string('─', width > 4 ? width - 2 : 60)}[/]", EditBg, width)); foreach (var row in MergeColumns(FormColumn(character, accent), TriggersColumn(character, triggerSets, accent), CharDetailColumnWidth)) { @@ -87,7 +78,7 @@ internal static bool HasCharacter(IReadOnlyList worlds, int sel internal static string HeaderLine(int width) { var title = $"[bold {Value}] Worlds & Characters[/]"; - var hints = $"[{Label}]↑↓ select · ⇥ switch pane · ⏎ edit · [/][{DefaultAccent}]Esc[/][{Label}] close [/]"; + var hints = ScreenChrome.Hints("↑↓ select · ⇥ switch pane · ⏎ edit", "F5"); return SpreadLR(" " + title, hints, width); } @@ -105,7 +96,7 @@ internal static string FooterLine( } } - var actions = $"[{Label}] [[Esc]] cancel [/] [{Ink} on {accent}] [[⏎]] Save [/] "; + var actions = ScreenChrome.Actions(accent); return SpreadLR(" " + context, actions, width); } @@ -122,7 +113,7 @@ internal static List WorldsColumn(IReadOnlyList worlds, var world = worlds[i]; var selected = i == selectedWorld; - var marker = selected ? $"[bold {DefaultAccent}]▸[/]" : " "; + var marker = selected ? $"[bold {Accent}]▸[/]" : " "; var accentHex = Hex(world.Accent); var name = selected ? $"[bold {Value}]{Escape(world.Name)}[/]" : $"[{Value}]{Escape(world.Name)}[/]"; left.Add($"{marker} [{accentHex}]▚[/] {name}"); @@ -136,7 +127,7 @@ internal static List WorldsColumn(IReadOnlyList worlds, } left.Add(string.Empty); - left.Add($"[{DefaultAccent}][[+ world]][/] [{Label}][[- del]][/]"); + left.Add($"[{Accent}][[+ world]][/] [{Label}][[- del]][/]"); return left; } @@ -185,7 +176,7 @@ internal static List DetailColumn( } right.Add(string.Empty); - right.Add($"[{DefaultAccent}][[+ add character]][/] [{Label}][[⧉ duplicate]] [[- remove]][/]"); + right.Add($"[{Accent}][[+ add character]][/] [{Label}][[⧉ duplicate]] [[- remove]][/]"); return right; } @@ -221,7 +212,7 @@ internal static List TriggersColumn( private static string CharacterRow(CharacterDefinition character, bool selected) { - var marker = selected ? $"[bold {DefaultAccent}]▸[/]" : " "; + var marker = selected ? $"[bold {Accent}]▸[/]" : " "; var name = PadVisible($"[{(selected ? "bold " : string.Empty)}{Value}]{Escape(character.Name)}[/]", 13); var login = PadVisible(character.AutoLogin ? "auto-login" : "manual", 12); var sets = Escape(string.Join(", ", character.TriggerSets)); @@ -241,18 +232,6 @@ private static string CharField(string label, string value) => private static string OnOff(bool value) => value ? "on" : "off"; - /// Lays a left- and right-hand fragment on one line, right-aligning the right to . - internal static string SpreadLR(string left, string right, int width) - { - if (width <= 0) - { - return $"{left} {right}"; - } - - var gap = Math.Max(1, width - VisibleLength(left) - VisibleLength(right)); - return left + new string(' ', gap) + right; - } - private static string Band(string inner, string bg, int width) { if (width <= 0) @@ -272,61 +251,12 @@ private static List MergeColumns(IReadOnlyList left, IReadOnlyLi { var l = i < left.Count ? left[i] : string.Empty; var r = i < right.Count ? right[i] : string.Empty; - merged.Add(PadVisible(l, leftWidth) + $"[{RuleColor}]{DividerGlyph}[/]" + r); + merged.Add(PadVisible(l, leftWidth) + $"[{Rule}]{DividerGlyph}[/]" + r); } return merged; } - private static string PadVisible(string markup, int width) - { - var visible = VisibleLength(markup); - return visible >= width ? markup : markup + new string(' ', width - visible); - } - - internal static int VisibleLength(string markup) - { - var length = 0; - var i = 0; - while (i < markup.Length) - { - var c = markup[i]; - if (c == '[') - { - if (i + 1 < markup.Length && markup[i + 1] == '[') - { - length++; - i += 2; - continue; - } - - var close = markup.IndexOf(']', i); - if (close < 0) - { - length += markup.Length - i; - break; - } - - i = close + 1; - continue; - } - - if (c == ']' && i + 1 < markup.Length && markup[i + 1] == ']') - { - length++; - i += 2; - continue; - } - - length++; - i++; - } - - return length; - } - private static string Hex(TerminalColor color) => - color.Kind == TerminalColorKind.Rgb ? $"#{color.R:x2}{color.G:x2}{color.B:x2}" : DefaultAccent; - - private static string Escape(string text) => text.Replace("[", "[[").Replace("]", "]]"); + color.Kind == TerminalColorKind.Rgb ? $"#{color.R:x2}{color.G:x2}{color.B:x2}" : Accent; } diff --git a/src/SharpMUTerm.Tui/WorldsScreenView.cs b/src/SharpMUTerm.Tui/WorldsScreenView.cs index 82751165..6361dc72 100644 --- a/src/SharpMUTerm.Tui/WorldsScreenView.cs +++ b/src/SharpMUTerm.Tui/WorldsScreenView.cs @@ -16,8 +16,6 @@ namespace SharpMUTerm.Tui; /// internal static class WorldsScreenView { - private const string RuleColor = "#3a4257"; - public static IWindowControl Build( IReadOnlyList worlds, IReadOnlyList triggerSets, @@ -27,21 +25,22 @@ public static IWindowControl Build( { var accent = WorldsScreenRenderer.AccentFor(worlds, selectedWorld); - var header = Band(WorldsScreenRenderer.HeaderLine(width), WorldsScreenRenderer.HeaderBg); - var footer = Band( + var header = ScreenChrome.Band(WorldsScreenRenderer.HeaderLine(width), ScreenPalette.HeaderBg); + var footer = ScreenChrome.Band( WorldsScreenRenderer.FooterLine(worlds, selectedWorld, selectedCharacter, accent, width), - WorldsScreenRenderer.FooterBg); + ScreenPalette.FooterBg); // Body: WORLDS list │ detail, as two real columns. - var worldsCol = Stretch(new MarkupControl(WorldsScreenRenderer.WorldsColumn(worlds, selectedWorld).ToList())); - var detailCol = Stretch(new MarkupControl( + var worldsCol = ScreenChrome.Stretch( + new MarkupControl(WorldsScreenRenderer.WorldsColumn(worlds, selectedWorld).ToList())); + var detailCol = ScreenChrome.Stretch(new MarkupControl( WorldsScreenRenderer.DetailColumn(worlds, triggerSets, selectedWorld, selectedCharacter, accent).ToList())); var body = Controls.HorizontalGrid() .WithAlignment(HorizontalAlignment.Stretch) .WithVerticalAlignment(VerticalAlignment.Fill) .Column(c => c.Width(30).Add(worldsCol)) - .Column(c => c.Width(1).Add(VerticalRule())) - .Column(c => c.Width(1).Add(new MarkupControl(new List()))) + .Column(c => c.Width(1).Add(ScreenChrome.VerticalRule())) + .Column(c => c.Width(1).Add(ScreenChrome.Filler())) .Column(c => c.Flex(1).Add(detailCol)) .Build(); @@ -60,17 +59,20 @@ public static IWindowControl Build( // block sits on the right while its checkboxes stay left-aligned (an Auto column hugs it, not // per-row right-justify, which would ragged the left edge). The edit grid's own background // gives the full-width elevated band behind both. - var formPanel = new MarkupControl(Indent(form)) { HorizontalAlignment = HorizontalAlignment.Left }; + var formPanel = new MarkupControl(ScreenChrome.Indent(form)) + { + HorizontalAlignment = HorizontalAlignment.Left, + }; var trigPanel = new MarkupControl(triggers) { HorizontalAlignment = HorizontalAlignment.Left }; var edit = Controls.HorizontalGrid() .WithAlignment(HorizontalAlignment.Stretch) .WithVerticalAlignment(VerticalAlignment.Fill) .Column(c => c.Width(48).Add(formPanel)) - .Column(c => c.Flex(1).Add(new MarkupControl(new List()))) + .Column(c => c.Flex(1).Add(ScreenChrome.Filler())) .Column(c => c.Add(trigPanel)) - .Column(c => c.Width(2).Add(new MarkupControl(new List()))) + .Column(c => c.Width(2).Add(ScreenChrome.Filler())) .Build(); - edit.BackgroundColor = new Color(WorldsScreenRenderer.EditBg); + edit.BackgroundColor = new Color(ScreenPalette.EditBg); // A one-row panel-background gap sits between the editing pane and the footer so the footer // reads as a separate bar, not the last row of the character setup section. @@ -93,35 +95,4 @@ public static IWindowControl Build( return root.Build(); } - - private static MarkupControl Band(string line, string bg) => new(new List { line }) - { - BackgroundColor = new Color(bg), - HorizontalAlignment = HorizontalAlignment.Stretch, - }; - - private static MarkupControl Stretch(MarkupControl control) - { - control.HorizontalAlignment = HorizontalAlignment.Stretch; - return control; - } - - /// - /// The one-cell rule between the columns. A with no lines measures to - /// nothing and never paints its background, so the rule is an empty grid instead — a grid's - /// background covers its whole arranged area, giving a full-height hairline. - /// - private static IWindowControl VerticalRule() - { - var rule = Controls.HorizontalGrid() - .WithAlignment(HorizontalAlignment.Stretch) - .WithVerticalAlignment(VerticalAlignment.Fill) - .Column(c => c.Flex(1).Add(new MarkupControl(new List()))) - .Build(); - rule.BackgroundColor = new Color(RuleColor); - return rule; - } - - /// Prefixes each form row with a space so the editing pane doesn't sit flush to the left edge. - private static List Indent(IEnumerable lines) => lines.Select(l => " " + l).ToList(); } From 1c86928f3f8b76796949951ce0b2c9e71e8cf4ee Mon Sep 17 00:00:00 2001 From: Harry Cordewener Date: Tue, 28 Jul 2026 16:16:01 -0500 Subject: [PATCH 05/23] F4 Keypad: align the numpad grid whatever is bound NumpadCell produced a variable-width string -- the unbound placeholder is one visible character, a command up to ten -- and NumpadRow joined cells with a fixed three-space gap. So any bound key widened its own cell and shunted the rest of that row right, which is why the grid only looked square while nothing was bound. Each cell is now padded to a fixed visible width ("[N] " plus the longest command it can hold); the last cell in a row is left unpadded to avoid trailing whitespace. All three rows now start their cells at columns 0, 17, 34 regardless of content. The demo scene bound a single numpad key, which can't show a keypad doing anything. It now carries a movement layout with commands of differing lengths, one long enough to be ellipsised -- so the snapshot actually exercises the grid. Adds a regression test asserting the three rows share cell offsets. Confirmed it fails without the padding and passes with it. Co-Authored-By: Claude Opus 5 (1M context) --- src/SharpMUTerm.Tui/DemoScene.cs | 15 ++++++- src/SharpMUTerm.Tui/KeypadScreenRenderer.cs | 19 ++++++-- .../KeypadScreenRendererTests.cs | 43 +++++++++++++++++++ 3 files changed, 73 insertions(+), 4 deletions(-) diff --git a/src/SharpMUTerm.Tui/DemoScene.cs b/src/SharpMUTerm.Tui/DemoScene.cs index ad6cc527..ad4f49a4 100644 --- a/src/SharpMUTerm.Tui/DemoScene.cs +++ b/src/SharpMUTerm.Tui/DemoScene.cs @@ -98,7 +98,20 @@ private static void AddTriggerSets(AppConfiguration config) new Alias { Name = "say", Pattern = @"^'(.*)", Substitution = "say $1" }, new Alias { Name = "wtf", Pattern = @"^wtf\s+(.+)$", Substitution = "who\nfinger $1" }, }, - Macros = { new Macro { Key = "Num5", Command = "look" }, new Macro { Key = "Ctrl+F1", Command = "score" } }, + // A movement keypad: enough bound keys, of differing command lengths, to actually show + // the 3x3 grid doing its job (and one command long enough to be ellipsised). + Macros = + { + new Macro { Key = "Num7", Command = "northwest" }, + new Macro { Key = "Num8", Command = "north" }, + new Macro { Key = "Num9", Command = "northeast" }, + new Macro { Key = "Num4", Command = "west" }, + new Macro { Key = "Num5", Command = "look" }, + new Macro { Key = "Num6", Command = "east" }, + new Macro { Key = "Num1", Command = "look at altar" }, + new Macro { Key = "Num2", Command = "south" }, + new Macro { Key = "Ctrl+F1", Command = "score" }, + }, Timers = { new TimerDefinition { Name = "keepalive", IntervalSeconds = 60, Command = "@@idle" } }, }); diff --git a/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs b/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs index b784e43e..e105db8d 100644 --- a/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs @@ -18,6 +18,14 @@ internal static class KeypadScreenRenderer private const int KeyColumnWidth = 12; private const int ColumnWidth = 48; + /// Longest command shown inside a numpad cell before it is ellipsised. + private const int NumpadCommandWidth = 10; + + /// Visible width of one numpad cell: "[N] " (4) plus . + private const int NumpadCellWidth = 4 + NumpadCommandWidth; + + private const string NumpadCellGap = " "; + private static readonly int[][] NumpadRows = { new[] { 7, 8, 9 }, @@ -125,16 +133,21 @@ private static string NumpadRow(int[] digits, IReadOnlyList macros) var cells = new string[digits.Length]; for (var i = 0; i < digits.Length; i++) { - cells[i] = NumpadCell(digits[i], macros); + var cell = NumpadCell(digits[i], macros); + + // Every cell is padded to the same visible width so the three columns line up whatever + // is bound: a cell is as wide as "[N] " plus the longest command it can hold. The last + // cell in a row is left unpadded to avoid trailing whitespace. + cells[i] = i == digits.Length - 1 ? cell : PadVisible(cell, NumpadCellWidth); } - return string.Join(" ", cells); + return string.Join(NumpadCellGap, cells); } private static string NumpadCell(int digit, IReadOnlyList macros) { var macro = FindByKey(macros, $"Num{digit}"); - var command = macro is null ? "[dim]—[/]" : Escape(Truncate(macro.Command, 10)); + var command = macro is null ? "[dim]—[/]" : Escape(Truncate(macro.Command, NumpadCommandWidth)); return $"[bold {Accent}][[{digit}]][/] {command}"; } diff --git a/tests/SharpMUTerm.Tui.Tests/KeypadScreenRendererTests.cs b/tests/SharpMUTerm.Tui.Tests/KeypadScreenRendererTests.cs index 976fd87d..882a64d7 100644 --- a/tests/SharpMUTerm.Tui.Tests/KeypadScreenRendererTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/KeypadScreenRendererTests.cs @@ -21,6 +21,49 @@ public async Task Render_NumpadCellShowsCommandBoundToNum5() await Assert.That(middleRow).Contains("look"); } + /// + /// Every numpad cell is padded to a fixed visible width, so the three columns line up whatever is + /// bound. Without that, a bound key widens its own cell and shunts the rest of its row right. + /// + [Test] + public async Task NumpadColumn_ColumnsAlignRegardlessOfBoundCommandLength() + { + // Deliberately lopsided: one row long enough to be ellipsised, one row entirely unbound. + var macros = new List + { + new() { Key = "Num7", Enabled = true, Command = "northwest" }, + new() { Key = "Num5", Enabled = true, Command = "look" }, + new() { Key = "Num3", Enabled = true, Command = "a very long command indeed" }, + }; + + // Skip(1): the first entry is the "NUMPAD" caption, not a key row. + var offsets = KeypadScreenRenderer.NumpadColumn(macros).Skip(1).Select(CellOffsets).ToList(); + + await Assert.That(offsets).HasCount().EqualTo(3); + await Assert.That(offsets[1]).IsEqualTo(offsets[0]); + await Assert.That(offsets[2]).IsEqualTo(offsets[0]); + } + + /// + /// The visible columns at which each cell starts, as a comparable string. Strips markup the way + /// the renderer's own width maths does: an escaped bracket counts as one literal character, a + /// styling tag as zero. Each cell starts at the literal '[' of its "[n]" marker. + /// + private static string CellOffsets(string row) + { + var protectedText = row.Replace("[[", "\u0001").Replace("]]", "\u0002"); + var visible = System.Text.RegularExpressions.Regex + .Replace(protectedText, @"\[[^\]]*\]", string.Empty) + .Replace('\u0001', '[') + .Replace('\u0002', ']'); + + var starts = Enumerable.Range(0, visible.Length) + .Where(i => visible[i] == '[') + .Select(i => i.ToString(System.Globalization.CultureInfo.InvariantCulture)); + + return string.Join(",", starts); + } + [Test] public async Task Render_UnboundNumpadCellShowsPlaceholder() { From 0e5ac5cea0fd07a475cab2001d8a0e524b5824f0 Mon Sep 17 00:00:00 2001 From: Harry Cordewener Date: Tue, 28 Jul 2026 16:47:14 -0500 Subject: [PATCH 06/23] Settings screens: wire live keyboard interaction MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Backlog item 3. The F2-F9 screens were display-only projections whose header hints advertised behaviour that did not exist. Now ↑↓ moves the selection, ⇥ crosses panes, Space toggles the boolean rows, Esc cancels and ⏎ saves -- on all eight screens. Field editing is deliberately NOT built, and no header claims it is: the hints now read "↑↓ select · ⇥ pane · Space toggle", with a test asserting no screen advertises a key its ScreenModel doesn't offer. A hint that lies is worse than a missing feature. Interaction state lives in four pure types (ScreenSelection, ScreenModel, ScreenEdits, SettingsSession) so the rules are testable without a terminal; SettingsOverlay stays the only UI-aware piece. Core remains UI-agnostic. Cancel replays an undo log rather than restoring a cloned config -- cloning AppConfiguration would drop [JsonIgnore] fields such as a character's in-memory password. A toggle snapshots the value, not the boolean, because F9's checkbox is really a LogFormat: cancelling puts Html back, not Plain. Supporting changes worth review: - Alias.CaseSensitive, Trigger.StopProcessing, TriggerActions.Gag and TimerDefinition.OneShot become settable. Alias.CaseSensitive drops the cached compiled Regex, or the matcher would silently keep the old casing. - New AppConfiguration.Text/.Input. F7/F8 rendered hardcoded literals with nothing behind them, so "toggle and save" would have been a lie. Purely additive: defaults match the old constants, no schema bump. - ActiveLogging() falls back to the first configured character instead of returning a throwaway LoggingSettings, which made F9's toggle a silent no-op while disconnected. Also unifies the left-column width: the renderer padded cursor bars to 54 while the view laid the column out at 56, leaving a visible gap before the rule. One constant now, so they cannot drift. Builds SharpConsoleUI from source when the framework is cloned beside this repo, so it can be read and stepped into instead of decompiled. CI and anyone without the clone fall through to the NuGet package unchanged; -p:UseSharpConsoleUIPackage=true forces the package. Both paths verified. 574 tests pass, up from 515. Co-Authored-By: Claude Opus 5 (1M context) --- CLAUDE.md | 2 +- docs/HANDOFF.md | 53 +++- src/SharpMUTerm.Core/Automation/Alias.cs | 21 +- .../Automation/TimerDefinition.cs | 7 +- src/SharpMUTerm.Core/Automation/Trigger.cs | 11 +- .../Configuration/AppConfiguration.cs | 6 + .../Configuration/PreferenceSettings.cs | 47 ++++ src/SharpMUTerm.Tui/AliasesScreenRenderer.cs | 53 +++- src/SharpMUTerm.Tui/AliasesScreenView.cs | 10 +- src/SharpMUTerm.Tui/KeypadScreenRenderer.cs | 20 +- src/SharpMUTerm.Tui/KeypadScreenView.cs | 4 +- src/SharpMUTerm.Tui/OptionsScreenRenderer.cs | 136 +++++++-- src/SharpMUTerm.Tui/OptionsScreenView.cs | 8 +- src/SharpMUTerm.Tui/ScreenChrome.cs | 17 ++ src/SharpMUTerm.Tui/ScreenEdits.cs | 41 +++ src/SharpMUTerm.Tui/ScreenFocus.cs | 21 ++ src/SharpMUTerm.Tui/ScreenModel.cs | 82 ++++++ src/SharpMUTerm.Tui/ScreenPalette.cs | 7 + src/SharpMUTerm.Tui/ScreenSelection.cs | 127 +++++++++ src/SharpMUTerm.Tui/SettingsOverlay.cs | 126 +++++++-- src/SharpMUTerm.Tui/SettingsSession.cs | 118 ++++++++ src/SharpMUTerm.Tui/SharpMUTerm.Tui.csproj | 19 +- src/SharpMUTerm.Tui/SharpMUTermApp.cs | 173 +++++++++--- src/SharpMUTerm.Tui/TimersScreenRenderer.cs | 57 +++- src/SharpMUTerm.Tui/TimersScreenView.cs | 10 +- src/SharpMUTerm.Tui/TriggersScreenRenderer.cs | 61 +++- src/SharpMUTerm.Tui/TriggersScreenView.cs | 10 +- src/SharpMUTerm.Tui/WorldsScreenRenderer.cs | 101 ++++++- src/SharpMUTerm.Tui/WorldsScreenView.cs | 11 +- .../Configuration/ConfigurationTests.cs | 45 +++ .../KeypadScreenRendererTests.cs | 2 +- .../ScreenCursorTests.cs | 196 +++++++++++++ .../SharpMUTerm.Tui.Tests/ScreenEditsTests.cs | 97 +++++++ .../SharpMUTerm.Tui.Tests/ScreenModelTests.cs | 260 ++++++++++++++++++ .../ScreenSelectionTests.cs | 175 ++++++++++++ .../SettingsSessionTests.cs | 145 ++++++++++ 36 files changed, 2104 insertions(+), 175 deletions(-) create mode 100644 src/SharpMUTerm.Core/Configuration/PreferenceSettings.cs create mode 100644 src/SharpMUTerm.Tui/ScreenEdits.cs create mode 100644 src/SharpMUTerm.Tui/ScreenFocus.cs create mode 100644 src/SharpMUTerm.Tui/ScreenModel.cs create mode 100644 src/SharpMUTerm.Tui/ScreenSelection.cs create mode 100644 src/SharpMUTerm.Tui/SettingsSession.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/ScreenCursorTests.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/ScreenEditsTests.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/ScreenSelectionTests.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/SettingsSessionTests.cs diff --git a/CLAUDE.md b/CLAUDE.md index 535948e1..46bbc162 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -32,7 +32,7 @@ fallbacks) for inline images/maps. ## Repository state **M1 delivered, plus substantial M2–M4 work.** `SharpMUTerm.slnx` builds all ten projects on -`net10.0`; the solution has **514 passing tests**. In place: +`net10.0`; the solution has **574 passing tests**. In place: - **Core** — `AnsiParser` (SGR 16/256/truecolor), styled-line + `ScrollbackBuffer` model, `TcpTransport` (TLS + IPv6), `TelnetSession` (wraps TelnetNegotiationCore **2.5.3**), diff --git a/docs/HANDOFF.md b/docs/HANDOFF.md index 93a63fe3..6bc185d0 100644 --- a/docs/HANDOFF.md +++ b/docs/HANDOFF.md @@ -4,8 +4,8 @@ Context for whoever (human or agent) picks up this work next. - **Repository:** `SharpMUSH/SharpMUTerm` - **Start from:** a fresh branch off `main` -- **Tests:** 514 across the solution (310 Core / 57 Graphics / 42 Scripting / - 15 Web / 90 Tui), all green; `dotnet build SharpMUTerm.slnx` clean (0 warnings) +- **Tests:** 574 across the solution (313 Core / 57 Graphics / 42 Scripting / + 15 Web / 147 Tui), all green; `dotnet build SharpMUTerm.slnx` clean (0 warnings) --- @@ -44,14 +44,41 @@ clean degradation when no graphics protocol is available (the sandbox is exactly that case). Real verification must happen on a GPU terminal (Kitty/WezTerm/ Ghostty) on the maintainer's machine. -### 3. Live keyboard interaction for the config screens - -The screens are currently **display-only** projections of config state — the -keyboard hints ("↑↓ select · ⇥ switch pane · ⏎ edit") describe intended behavior -that isn't wired yet. Selection indices (`ActiveWorldIndex()`, -`ActiveCharacterIndex()`) drive what's highlighted, but there's no in-screen -navigation/edit loop. Wiring real editing (move selection, toggle checkboxes, -edit fields, persist on Save) is a substantial follow-up. +### 3. Live keyboard interaction for the config screens — navigation + toggles done + +**Status:** ↑↓ selection, ⇥ pane switching, Space toggling, and Esc/⏎ +cancel-save are wired on all eight screens. **Field editing is not** — nothing +lets you type a new host, interval, or pattern yet, and no header claims it does +(a test asserts no screen advertises "⏎ edit"/"⏎ rebind"/"⏎ change"). + +How it fits together: + +- `ScreenSelection` — pure cursor state (which pane, where each pane's cursor + sits). Pane sizes are passed in per move rather than cached, because a + keystroke can change them. +- `ScreenModel` / `ScreenToggle` — a screen's navigable panes and the config each + checkbox writes to. Built fresh from live config on every key by the renderer's + own `Model(...)`, so the renderer stays the single source of truth for a + screen's shape. +- `ScreenEdits` — the undo log behind Cancel/Save. Screens edit config **in + place** (cloning `AppConfiguration` would drop `[JsonIgnore]` fields like a + character's in-memory password), so Esc is a replayed undo. A toggle's snapshot + captures the *value*, not the boolean — F9's "auto-start" is really a + `LogFormat`, and cancelling must put `Html` back, not `Plain`. +- `SettingsSession` — key → action (`Redraw`/`Save`/`Cancel`/…). All the + interaction rules live here so they're testable without a terminal. +- `SettingsOverlay` — the only UI-aware piece: on `Redraw` it does + `ClearControls()` + `AddControl(factory())` + `Invalidate(true)`. + +What Space toggles, per screen: F2 trigger `Enabled` / `Gag` / `StopProcessing`, +F3 alias `Enabled` / `CaseSensitive`, F4 macro `Enabled`, F5 character +`AutoLogin` + trigger-set assignment, F6 timer `Enabled` / `OneShot`, F7/F8 the +new `AppConfiguration.Text` / `.Input` preference objects, F9 the log format. +F4/F7/F8/F9 are single-pane (no ⇥); F5 has three panes. + +**Still open:** field editing (text/number/enum rows), add/remove rows +(`[+ world]`, `[- del]`, `[+ add character]` are still painted but inert), and +the F2 route-to radio list + highlight colour picker. ### 4. Full-width solid input band — verify on a real terminal @@ -212,7 +239,11 @@ Things that will waste your time if you don't know them. | `src/SharpMUTerm.Tui/SharpMUTermApp.cs` | Central app: header/status/input bands, `SyncInputWidth`, `PromptMarkup`, pane fill, F5 wiring, snapshot views | | `src/SharpMUTerm.Tui/WorldsScreenRenderer.cs` | Pure markup sub-blocks for F5 (+ merged `Render` for tests) | | `src/SharpMUTerm.Tui/WorldsScreenView.cs` | Composes F5 sub-blocks into real control panels | -| `src/SharpMUTerm.Tui/SettingsOverlay.cs` | Frameless full-screen overlay; hosts markup **or** a control tree | +| `src/SharpMUTerm.Tui/SettingsOverlay.cs` | Frameless full-screen overlay; routes keys to the screen's session and rebuilds its content | +| `src/SharpMUTerm.Tui/SettingsSession.cs` | Key → action for an open settings screen (the whole interaction contract, testable) | +| `src/SharpMUTerm.Tui/ScreenSelection.cs` | Pure pane/cursor state machine for the settings screens | +| `src/SharpMUTerm.Tui/ScreenModel.cs` | A screen's navigable panes + the config each checkbox binds to | +| `src/SharpMUTerm.Tui/ScreenEdits.cs` | The undo log behind Cancel/Save | | `src/SharpMUTerm.Tui/CommandPalette.cs` | ⌃P surface: content-hug sizing, clean chrome | | `src/SharpMUTerm.Tui/CommandSurfaceRenderer.cs` | Palette rows + full-width selection bar | | `tools/fonts/OFL.txt`, `LICENSE-NerdFonts.txt` | Full bundled license texts | diff --git a/src/SharpMUTerm.Core/Automation/Alias.cs b/src/SharpMUTerm.Core/Automation/Alias.cs index d18639f0..fc4fc4bd 100644 --- a/src/SharpMUTerm.Core/Automation/Alias.cs +++ b/src/SharpMUTerm.Core/Automation/Alias.cs @@ -11,6 +11,7 @@ namespace SharpMUTerm.Core.Automation; public sealed class Alias { private Regex? _compiled; + private bool _caseSensitive; public string Name { get; init; } = string.Empty; @@ -18,7 +19,25 @@ public sealed class Alias public bool Enabled { get; set; } = true; - public bool CaseSensitive { get; init; } + /// + /// Match case exactly. Settable so the F3 settings screen can flip it live; writing it drops the + /// cached so the next match recompiles with the new casing rather than + /// silently keeping the old options. + /// + public bool CaseSensitive + { + get => _caseSensitive; + set + { + if (_caseSensitive == value) + { + return; + } + + _caseSensitive = value; + _compiled = null; + } + } /// The expansion template. May contain multiple newline-separated commands. public string Substitution { get; init; } = string.Empty; diff --git a/src/SharpMUTerm.Core/Automation/TimerDefinition.cs b/src/SharpMUTerm.Core/Automation/TimerDefinition.cs index e2d0dea6..5b735594 100644 --- a/src/SharpMUTerm.Core/Automation/TimerDefinition.cs +++ b/src/SharpMUTerm.Core/Automation/TimerDefinition.cs @@ -16,8 +16,11 @@ public sealed class TimerDefinition /// The command sent on each firing (blank when a script callback is used instead). public string Command { get; init; } = string.Empty; - /// Fire only once after the interval rather than repeating. - public bool OneShot { get; init; } + /// + /// Fire only once after the interval rather than repeating. Settable so the F6 screen can flip it + /// live; the scheduler reads it when the timer is realised, so a change applies on the next run. + /// + public bool OneShot { get; set; } public bool Enabled { get; set; } = true; diff --git a/src/SharpMUTerm.Core/Automation/Trigger.cs b/src/SharpMUTerm.Core/Automation/Trigger.cs index 48a69d71..69605f49 100644 --- a/src/SharpMUTerm.Core/Automation/Trigger.cs +++ b/src/SharpMUTerm.Core/Automation/Trigger.cs @@ -7,8 +7,8 @@ namespace SharpMUTerm.Core.Automation; /// The typed actions a matched performs. public sealed class TriggerActions { - /// Suppress the line from output entirely. - public bool Gag { get; init; } + /// Suppress the line from output entirely. Settable so the F2 screen can flip it live. + public bool Gag { get; set; } /// Recolour the matched region's foreground. public TerminalColor? HighlightForeground { get; init; } @@ -52,8 +52,11 @@ public sealed class Trigger public bool CaseSensitive { get; init; } - /// When true, later triggers are not evaluated once this one matches. - public bool StopProcessing { get; init; } + /// + /// When true, later triggers are not evaluated once this one matches. Settable so the F2 screen + /// can flip it live; the engine reads it per match, so a change applies to the next line. + /// + public bool StopProcessing { get; set; } public TriggerActions Actions { get; init; } = new(); diff --git a/src/SharpMUTerm.Core/Configuration/AppConfiguration.cs b/src/SharpMUTerm.Core/Configuration/AppConfiguration.cs index b9958c5f..fd844148 100644 --- a/src/SharpMUTerm.Core/Configuration/AppConfiguration.cs +++ b/src/SharpMUTerm.Core/Configuration/AppConfiguration.cs @@ -33,6 +33,12 @@ public sealed class AppConfiguration /// Default charset preference order (IANA names), most-preferred first. public List CharsetOrder { get; set; } = new() { "utf-8", "iso-8859-1" }; + /// How inbound text is drawn — the F7 "Text & ANSI" screen's settings. + public TextSettings Text { get; set; } = new(); + + /// How the command line behaves — the F8 "Input & spellcheck" screen's settings. + public InputSettings Input { get; set; } = new(); + /// The saved worlds (servers), each holding its own characters. public List Worlds { get; set; } = new(); diff --git a/src/SharpMUTerm.Core/Configuration/PreferenceSettings.cs b/src/SharpMUTerm.Core/Configuration/PreferenceSettings.cs new file mode 100644 index 00000000..543dadff --- /dev/null +++ b/src/SharpMUTerm.Core/Configuration/PreferenceSettings.cs @@ -0,0 +1,47 @@ +namespace SharpMUTerm.Core.Configuration; + +/// +/// Application-wide text rendering preferences — the settings the F7 "Text & ANSI" screen edits. +/// These are global rather than per world: they describe how *this terminal* draws what any world +/// sends, so a world's own and +/// stay where they are. +/// +public sealed class TextSettings +{ + /// Discard inbound SGR colour and render every line in the theme's default style. + public bool StripIncomingColour { get; set; } + + /// Honour the blink attribute rather than dropping it. + public bool AllowBlink { get; set; } + + /// Underline MXP/Pueblo/web links so they read as clickable. + public bool UnderlineHyperlinks { get; set; } = true; + + /// Substitute emoji for shortcodes and emoticons in inbound text. + public bool EmojiSubstitution { get; set; } = true; + + /// How East Asian ambiguous-width characters are measured: narrow or wide. + public string AmbiguousWidth { get; set; } = "narrow"; +} + +/// +/// Application-wide input and spellcheck preferences — the settings the F8 "Input & spellcheck" +/// screen edits. +/// +public sealed class InputSettings +{ + /// Echo typed commands into the output window. + public bool LocalEcho { get; set; } = true; + + /// Keep an unsent draft per tab so switching windows doesn't lose typing. + public bool KeepDrafts { get; set; } = true; + + /// The key that inserts a newline instead of sending (e.g. Shift+Enter). + public string NewlineKey { get; set; } = "Shift+Enter"; + + /// Spell-check the input line as it is typed. + public bool CheckSpelling { get; set; } = true; + + /// The dictionary spellcheck loads (e.g. en_US). + public string Dictionary { get; set; } = "en_US"; +} diff --git a/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs b/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs index a90f2b82..2c5de8ee 100644 --- a/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs @@ -17,7 +17,12 @@ namespace SharpMUTerm.Tui; /// internal static class AliasesScreenRenderer { - private const int ColumnWidth = 54; + /// + /// Visible width of the left column. The view lays its column out at exactly this width, so + /// the two must agree -- a cursor bar padded narrower than its column leaves a gap before the + /// rule. Shared rather than duplicated so they cannot drift apart. + /// + internal const int ColumnWidth = 56; /// /// Merges every sub-block into one line list (header, alias list | editor, footer). Used by the @@ -51,10 +56,35 @@ public static List Render(IReadOnlyList sets, int selected) internal static string HeaderLine(int width) { var title = $"[bold {Value}] Aliases[/]"; - var hints = ScreenChrome.Hints("↑↓ select · ⇥ switch pane · ⏎ edit", "F3"); + var hints = ScreenChrome.Hints(ScreenChrome.ListHints, "F3"); return SpreadLR(" " + title, hints, width); } + /// + /// The screen's navigable panes: the alias list (Space enables/disables one) and the selected + /// alias's checkbox rows, in the order draws them. + /// + internal static ScreenModel Model(IReadOnlyList sets, int selected) + { + ArgumentNullException.ThrowIfNull(sets); + + var entries = Flatten(sets); + var list = ScreenModel.Toggles(entries, e => e.Alias.Enabled, (e, v) => e.Alias.Enabled = v); + + if (selected < 0 || selected >= entries.Count) + { + return new ScreenModel(list, Array.Empty()); + } + + var alias = entries[selected].Alias; + var editor = new ScreenToggle?[] + { + ScreenToggle.Bind(() => alias.CaseSensitive, v => alias.CaseSensitive = v), + }; + + return new ScreenModel(list, editor); + } + /// The action bar: which alias is selected on the left, cancel/save on the right. internal static string FooterLine(IReadOnlyList sets, int selected, int width) { @@ -72,10 +102,12 @@ internal static string FooterLine(IReadOnlyList sets, int selected, } /// The alias list — every alias of every set, with its enabled state and expansion. - internal static List ListColumn(IReadOnlyList sets, int selected) + internal static List ListColumn( + IReadOnlyList sets, int selected, ScreenFocus? focus = null) { ArgumentNullException.ThrowIfNull(sets); + var cursor = focus ?? ScreenFocus.None; var entries = Flatten(sets); var lines = new List { "[dim]on name / pattern → expansion[/]" }; @@ -87,7 +119,8 @@ internal static List ListColumn(IReadOnlyList sets, int sele for (var i = 0; i < entries.Count; i++) { - lines.Add(Row(entries[i].Alias, entries[i].SetName, i == selected)); + var row = Row(entries[i].Alias, entries[i].SetName, i == selected); + lines.Add(ScreenChrome.Cursor(row, cursor.IsOn(0, i), ColumnWidth)); } return lines; @@ -97,13 +130,14 @@ internal static List ListColumn(IReadOnlyList sets, int sele /// The editor for the selected alias — pattern, expansion lines, and the case-sensitivity /// toggle. Empty when nothing is selected. /// - internal static List EditorColumn(IReadOnlyList sets, int selected) + internal static List EditorColumn( + IReadOnlyList sets, int selected, ScreenFocus? focus = null) { ArgumentNullException.ThrowIfNull(sets); var entries = Flatten(sets); return selected >= 0 && selected < entries.Count - ? BuildEditor(entries[selected].Alias) + ? BuildEditor(entries[selected].Alias, focus ?? ScreenFocus.None) : new List(); } @@ -132,7 +166,7 @@ private static string Row(Alias alias, string setName, bool selected) return $"{check} {marker} [bold]{name}[/] [dim]{pattern}[/] [dim]▪ {Escape(setName)}[/] → {expansion}"; } - private static List BuildEditor(Alias alias) + private static List BuildEditor(Alias alias, ScreenFocus cursor) { var lines = new List { @@ -148,9 +182,10 @@ private static List BuildEditor(Alias alias) } lines.Add(string.Empty); - lines.Add(alias.CaseSensitive + var caseRow = alias.CaseSensitive ? $"[{Accent}][[x]][/] case sensitive" - : "[dim][[ ]] case sensitive[/]"); + : "[dim][[ ]] case sensitive[/]"; + lines.Add(ScreenChrome.Cursor(caseRow, cursor.IsOn(1, 0), ColumnWidth)); return lines; } diff --git a/src/SharpMUTerm.Tui/AliasesScreenView.cs b/src/SharpMUTerm.Tui/AliasesScreenView.cs index a81ae153..336a3929 100644 --- a/src/SharpMUTerm.Tui/AliasesScreenView.cs +++ b/src/SharpMUTerm.Tui/AliasesScreenView.cs @@ -15,17 +15,19 @@ namespace SharpMUTerm.Tui; /// internal static class AliasesScreenView { - private const int ListColumnWidth = 56; + private const int ListColumnWidth = AliasesScreenRenderer.ColumnWidth; - public static IWindowControl Build(IReadOnlyList sets, int selected, int width) + public static IWindowControl Build( + IReadOnlyList sets, int selected, int width, ScreenFocus? focus = null) { var header = ScreenChrome.Band(AliasesScreenRenderer.HeaderLine(width), ScreenPalette.HeaderBg); var footer = ScreenChrome.Band(AliasesScreenRenderer.FooterLine(sets, selected, width), ScreenPalette.FooterBg); // Body: alias list │ editor, as two real columns. - var listCol = ScreenChrome.Stretch(new MarkupControl(AliasesScreenRenderer.ListColumn(sets, selected))); + var listCol = ScreenChrome.Stretch( + new MarkupControl(AliasesScreenRenderer.ListColumn(sets, selected, focus))); var editorCol = ScreenChrome.Stretch( - new MarkupControl(ScreenChrome.Indent(AliasesScreenRenderer.EditorColumn(sets, selected)))); + new MarkupControl(ScreenChrome.Indent(AliasesScreenRenderer.EditorColumn(sets, selected, focus)))); var body = Controls.HorizontalGrid() .WithAlignment(HorizontalAlignment.Stretch) .WithVerticalAlignment(VerticalAlignment.Fill) diff --git a/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs b/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs index e105db8d..a735f178 100644 --- a/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs @@ -65,10 +65,21 @@ public static List Render(IReadOnlyList macros) internal static string HeaderLine(int width) { var title = $"[bold {Value}] Keypad & hotkeys[/]"; - var hints = ScreenChrome.Hints("↑↓ select · ⇥ switch pane · ⏎ rebind", "F4"); + var hints = ScreenChrome.Hints(ScreenChrome.SingleListHints, "F4"); return SpreadLR(" " + title, hints, width); } + /// + /// The screen's one navigable pane: the binding list, where Space enables or disables a macro. + /// The numpad grid is a projection of the same macros, so it has no cursor of its own — it + /// updates as the list is toggled. + /// + internal static ScreenModel Model(IReadOnlyList macros) + { + ArgumentNullException.ThrowIfNull(macros); + return new ScreenModel(ScreenModel.Toggles(macros, m => m.Enabled, (m, v) => m.Enabled = v)); + } + /// The action bar: how much of the keypad is bound on the left, cancel/save on the right. internal static string FooterLine(IReadOnlyList macros, int width) { @@ -109,10 +120,11 @@ internal static List NumpadColumn(IReadOnlyList macros) } /// The binding list — every macro with its enabled state, key, and command. - internal static List HotkeysColumn(IReadOnlyList macros) + internal static List HotkeysColumn(IReadOnlyList macros, ScreenFocus? focus = null) { ArgumentNullException.ThrowIfNull(macros); + var cursor = focus ?? ScreenFocus.None; var lines = new List { "[dim]HOTKEYS[/]" }; if (macros.Count == 0) { @@ -120,9 +132,9 @@ internal static List HotkeysColumn(IReadOnlyList macros) return lines; } - foreach (var macro in macros) + for (var i = 0; i < macros.Count; i++) { - lines.Add(Hotkey(macro)); + lines.Add(ScreenChrome.Cursor(Hotkey(macros[i]), cursor.IsOn(0, i), ColumnWidth)); } return lines; diff --git a/src/SharpMUTerm.Tui/KeypadScreenView.cs b/src/SharpMUTerm.Tui/KeypadScreenView.cs index 61dd9829..e951c5a7 100644 --- a/src/SharpMUTerm.Tui/KeypadScreenView.cs +++ b/src/SharpMUTerm.Tui/KeypadScreenView.cs @@ -18,7 +18,7 @@ internal static class KeypadScreenView { private const int NumpadColumnWidth = 50; - public static IWindowControl Build(IReadOnlyList macros, int width) + public static IWindowControl Build(IReadOnlyList macros, int width, ScreenFocus? focus = null) { var header = ScreenChrome.Band(KeypadScreenRenderer.HeaderLine(width), ScreenPalette.HeaderBg); var footer = ScreenChrome.Band(KeypadScreenRenderer.FooterLine(macros, width), ScreenPalette.FooterBg); @@ -26,7 +26,7 @@ public static IWindowControl Build(IReadOnlyList macros, int width) // Body: numpad grid │ hotkey list, as two real columns. var numpadCol = ScreenChrome.Stretch(new MarkupControl(KeypadScreenRenderer.NumpadColumn(macros))); var hotkeysCol = ScreenChrome.Stretch( - new MarkupControl(ScreenChrome.Indent(KeypadScreenRenderer.HotkeysColumn(macros)))); + new MarkupControl(ScreenChrome.Indent(KeypadScreenRenderer.HotkeysColumn(macros, focus)))); var body = Controls.HorizontalGrid() .WithAlignment(HorizontalAlignment.Stretch) .WithVerticalAlignment(VerticalAlignment.Fill) diff --git a/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs b/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs index bc417e57..af688255 100644 --- a/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs @@ -18,8 +18,13 @@ internal static class OptionsScreenRenderer { private const int LabelWidth = 28; - /// A single options-list row: a toggle, a value row, a section header, or a spacer. - public readonly record struct OptionRow(string Label, string? Value, bool? Toggle, string? Hint = null); + /// + /// A single options-list row: a toggle, a value row, a section header, or a spacer. + /// is the config the checkbox writes to; a row without one still takes the + /// cursor but Space does nothing there (the value rows, until field editing exists). + /// + public readonly record struct OptionRow( + string Label, string? Value, bool? Toggle, string? Hint = null, ScreenToggle? Bind = null); /// One options screen: the title and F-key its chrome shows, plus the rows it lists. internal readonly record struct OptionsScreen(string Title, string FKey, IReadOnlyList Rows); @@ -49,7 +54,7 @@ public static List Render(string title, string fkey, IReadOnlyListThe action bar: how much the screen holds on the left, cancel/save on the right. @@ -68,12 +73,46 @@ internal static string FooterLine(IReadOnlyList rows, int width) return SpreadLR(" " + context, ScreenChrome.Actions(), width); } - /// The options list itself — one line per row, in order. - internal static List BodyColumn(IReadOnlyList rows) + /// + /// The options list itself — one line per row, in order. The row under the keyboard cursor is + /// drawn on a cursor bar padded to ; spacers and section headers are + /// skipped when counting, so the cursor index matches 's row order. + /// + internal static List BodyColumn( + IReadOnlyList rows, ScreenFocus? focus = null, int width = 0) { ArgumentNullException.ThrowIfNull(rows); - return rows.Select(RenderRow).ToList(); + var cursor = focus ?? ScreenFocus.None; + var lines = new List(rows.Count); + var navigable = 0; + foreach (var row in rows) + { + var line = RenderRow(row); + if (IsSpacer(row) || IsSection(row)) + { + lines.Add(line); + continue; + } + + lines.Add(ScreenChrome.Cursor(line, cursor.IsOn(0, navigable), width)); + navigable++; + } + + return lines; + } + + /// + /// The screen's one navigable pane: every row that isn't a spacer or a section header, in display + /// order, each carrying whatever config binding it was built with. + /// + internal static ScreenModel Model(OptionsScreen screen) + { + var rows = screen.Rows + .Where(r => !IsSpacer(r) && !IsSection(r)) + .Select(r => r.Bind) + .ToArray(); + return new ScreenModel(rows); } private static string RenderRow(OptionRow row) @@ -107,43 +146,80 @@ private static bool IsSpacer(OptionRow row) => /// A dim group heading, marked by the branch glyph the screens prefix them with. private static bool IsSection(OptionRow row) => row.Label.StartsWith("├ ", StringComparison.Ordinal); - /// The F7 "Text & ANSI" screen. - internal static OptionsScreen TextAnsiScreen() => new("Text & ANSI", "F7", new List + /// + /// The F7 "Text & ANSI" screen, reflecting — and writing back to — the app's + /// . Called without arguments it projects the defaults, which is what + /// the unit tests and the width-agnostic fallback want. + /// + internal static OptionsScreen TextAnsiScreen(TextSettings? text = null) { - new("├ COLOUR", null, null), - new("strip incoming ANSI colour", null, false), - new("allow blink", null, false), - new("underline hyperlinks", null, true), - new(string.Empty, null, null), - new("├ UNICODE", null, null), - new("emoji substitution", null, true), - new("ambiguous width", "narrow", null), - }); - - /// The F8 "Input & spellcheck" screen. - internal static OptionsScreen InputSpellcheckScreen() => new("Input & spellcheck", "F8", new List + var settings = text ?? new TextSettings(); + + return new OptionsScreen("Text & ANSI", "F7", new List + { + new("├ COLOUR", null, null), + new("strip incoming ANSI colour", null, settings.StripIncomingColour, null, + ScreenToggle.Bind(() => settings.StripIncomingColour, v => settings.StripIncomingColour = v)), + new("allow blink", null, settings.AllowBlink, null, + ScreenToggle.Bind(() => settings.AllowBlink, v => settings.AllowBlink = v)), + new("underline hyperlinks", null, settings.UnderlineHyperlinks, null, + ScreenToggle.Bind(() => settings.UnderlineHyperlinks, v => settings.UnderlineHyperlinks = v)), + new(string.Empty, null, null), + new("├ UNICODE", null, null), + new("emoji substitution", null, settings.EmojiSubstitution, null, + ScreenToggle.Bind(() => settings.EmojiSubstitution, v => settings.EmojiSubstitution = v)), + new("ambiguous width", settings.AmbiguousWidth, null), + }); + } + + /// + /// The F8 "Input & spellcheck" screen, reflecting — and writing back to — the app's + /// . + /// + internal static OptionsScreen InputSpellcheckScreen(InputSettings? input = null) { - new("├ INPUT", null, null), - new("local echo", null, true), - new("keep per-tab drafts", null, true), - new("newline key", "Shift+Enter", null), - new(string.Empty, null, null), - new("├ SPELLCHECK", null, null), - new("check spelling", null, true), - new("dictionary", "en_US", null), - }); + var settings = input ?? new InputSettings(); + + return new OptionsScreen("Input & spellcheck", "F8", new List + { + new("├ INPUT", null, null), + new("local echo", null, settings.LocalEcho, null, + ScreenToggle.Bind(() => settings.LocalEcho, v => settings.LocalEcho = v)), + new("keep per-tab drafts", null, settings.KeepDrafts, null, + ScreenToggle.Bind(() => settings.KeepDrafts, v => settings.KeepDrafts = v)), + new("newline key", settings.NewlineKey, null), + new(string.Empty, null, null), + new("├ SPELLCHECK", null, null), + new("check spelling", null, settings.CheckSpelling, null, + ScreenToggle.Bind(() => settings.CheckSpelling, v => settings.CheckSpelling = v)), + new("dictionary", settings.Dictionary, null), + }); + } /// The F9 "Logging" screen, reflecting a character's . internal static OptionsScreen LoggingScreen(LoggingSettings logging) { ArgumentNullException.ThrowIfNull(logging); + // "Auto-start" is really the log format: off means None, on means whatever format was last + // chosen (Plain when there isn't one). The binding's snapshot restores the *format*, not the + // boolean, so cancelling a toggle-off puts Html back rather than downgrading it to Plain. + var chosen = logging.Format == LogFormat.None ? LogFormat.Plain : logging.Format; + var autoStart = new ScreenToggle( + () => logging.Format != LogFormat.None, + () => logging.Format = logging.Format == LogFormat.None ? chosen : LogFormat.None, + () => + { + var previous = logging.Format; + return () => logging.Format = previous; + }); + return new OptionsScreen("Logging", "F9", new List { new("├ SESSION LOG", null, null), new("format", logging.Format.ToString(), null), new("directory", logging.Directory ?? "(default)", null), - new("auto-start on connect", null, logging.Format != LogFormat.None), + new("auto-start on connect", null, logging.Format != LogFormat.None, null, autoStart), }); } diff --git a/src/SharpMUTerm.Tui/OptionsScreenView.cs b/src/SharpMUTerm.Tui/OptionsScreenView.cs index 58a510c6..298876ea 100644 --- a/src/SharpMUTerm.Tui/OptionsScreenView.cs +++ b/src/SharpMUTerm.Tui/OptionsScreenView.cs @@ -19,14 +19,18 @@ internal static class OptionsScreenView /// Blank pad rows above and below the list inside the card. private const int CardPadding = 2; - public static IWindowControl Build(OptionsScreenRenderer.OptionsScreen screen, int width) + /// Columns the list is inset by: two of padding on each side of the card. + private const int CardInset = 4; + + public static IWindowControl Build( + OptionsScreenRenderer.OptionsScreen screen, int width, ScreenFocus? focus = null) { var header = ScreenChrome.Band( OptionsScreenRenderer.HeaderLine(screen.Title, screen.FKey, width), ScreenPalette.HeaderBg); var footer = ScreenChrome.Band( OptionsScreenRenderer.FooterLine(screen.Rows, width), ScreenPalette.FooterBg); - var rows = OptionsScreenRenderer.BodyColumn(screen.Rows); + var rows = OptionsScreenRenderer.BodyColumn(screen.Rows, focus, Math.Max(0, width - CardInset)); var card = Card(rows); // Header on the first row, footer on the last, the card hugging its content directly beneath the diff --git a/src/SharpMUTerm.Tui/ScreenChrome.cs b/src/SharpMUTerm.Tui/ScreenChrome.cs index 65c9fb3a..1565db89 100644 --- a/src/SharpMUTerm.Tui/ScreenChrome.cs +++ b/src/SharpMUTerm.Tui/ScreenChrome.cs @@ -21,6 +21,15 @@ internal static string Hints(string verbs, string fkey) => $"[{ScreenPalette.Label}]{verbs} · [/][{ScreenPalette.Accent}]{fkey}[/][{ScreenPalette.Label}]/[/]" + $"[{ScreenPalette.Accent}]Esc[/][{ScreenPalette.Label}] close [/]"; + /// + /// The keyboard hints every screen with a list and a checkbox pane shares. Kept in one place so a + /// screen can't advertise a key its doesn't actually offer. + /// + internal const string ListHints = "↑↓ select · ⇥ pane · Space toggle"; + + /// The hints for a screen that is a single list with no second pane to ⇥ into. + internal const string SingleListHints = "↑↓ select · Space toggle"; + /// /// The right-hand actions of a footer bar. lets a screen with a /// context colour (F5's per-world accent) tint the Save chip; it defaults to the app accent. @@ -29,6 +38,14 @@ internal static string Actions(string? accent = null) => $"[{ScreenPalette.Label}] [[Esc]] Cancel [/] " + $"[{ScreenPalette.Ink} on {accent ?? ScreenPalette.Accent}] [[⏎]] Save [/] "; + /// + /// Draws a row as the keyboard cursor: the row's own markup on a cursor band padded out to + /// , so the bar spans its pane instead of hugging the text. A row that + /// isn't under the cursor comes back untouched. + /// + internal static string Cursor(string row, bool focused, int width) => + focused ? $"[on {ScreenPalette.CursorBg}]{MarkupText.PadVisible(row, width)}[/]" : row; + /// A full-width one-row band — the header or the footer. internal static MarkupControl Band(string line, string bg) => new(new List { line }) { diff --git a/src/SharpMUTerm.Tui/ScreenEdits.cs b/src/SharpMUTerm.Tui/ScreenEdits.cs new file mode 100644 index 00000000..9acc982b --- /dev/null +++ b/src/SharpMUTerm.Tui/ScreenEdits.cs @@ -0,0 +1,41 @@ +namespace SharpMUTerm.Tui; + +/// +/// The undo log behind a settings screen's Cancel/Save bar. Screens edit the live configuration in +/// place — cloning would silently drop +/// the fields that deliberately don't round-trip (a character's in-memory password is +/// [JsonIgnore]) — so "discard" is a replayed undo rather than a swapped object. Each applied +/// toggle pushes the restore action captured *before* it ran; Esc replays them newest-first, ⏎ drops +/// them. Pure state, so the semantics are unit-testable without a window. +/// +internal sealed class ScreenEdits +{ + private readonly List _undo = new(); + + /// Whether anything has been changed since the screen opened or last saved. + internal bool IsDirty => _undo.Count > 0; + + /// How many changes are pending — the footer's dirty count. + internal int Count => _undo.Count; + + /// Flips a checkbox, recording how to put it back. + internal void Apply(ScreenToggle toggle) + { + _undo.Add(toggle.Snapshot()); + toggle.Flip(); + } + + /// Undoes every pending change, newest first, so overlapping edits unwind correctly. + internal void Revert() + { + for (var i = _undo.Count - 1; i >= 0; i--) + { + _undo[i](); + } + + _undo.Clear(); + } + + /// Accepts every pending change; the log is dropped and there is nothing left to undo. + internal void Commit() => _undo.Clear(); +} diff --git a/src/SharpMUTerm.Tui/ScreenFocus.cs b/src/SharpMUTerm.Tui/ScreenFocus.cs new file mode 100644 index 00000000..415c1d81 --- /dev/null +++ b/src/SharpMUTerm.Tui/ScreenFocus.cs @@ -0,0 +1,21 @@ +namespace SharpMUTerm.Tui; + +/// +/// What a renderer needs to know about the keyboard: which pane holds it and which row it is on. +/// Renderers take this as an optional argument so a screen rendered without one (the unit tests, and +/// any caller that only wants the projection) draws exactly what it always did — the cursor bar only +/// appears once a live screen says where the cursor is. +/// +/// The pane the keyboard is in, or -1 for "no keyboard". +/// The row the cursor is on within that pane. +internal readonly record struct ScreenFocus(int Pane, int Index) +{ + /// No keyboard on this screen — nothing is drawn as the cursor. + internal static ScreenFocus None => new(-1, -1); + + /// Whether the cursor is on a given pane's row. + internal bool IsOn(int pane, int index) => Pane == pane && Index == index; + + /// Whether a pane holds the keyboard at all (its list draws its cursor, others don't). + internal bool InPane(int pane) => Pane == pane; +} diff --git a/src/SharpMUTerm.Tui/ScreenModel.cs b/src/SharpMUTerm.Tui/ScreenModel.cs new file mode 100644 index 00000000..2012242e --- /dev/null +++ b/src/SharpMUTerm.Tui/ScreenModel.cs @@ -0,0 +1,82 @@ +namespace SharpMUTerm.Tui; + +/// +/// A checkbox row on a settings screen, bound to the config it shows: how to read the flag, how to +/// flip it, and how to put back exactly what was there before. The snapshot exists because not every +/// checkbox is a plain bool property — F9's "auto-start on connect" is really a +/// , and Esc has to restore Html, not +/// merely "on". +/// +/// Reads the flag as the renderer draws it. +/// Inverts the flag. +/// Captures the current value, returning the action that restores it. +internal readonly record struct ScreenToggle(Func Get, Action Flip, Func Snapshot) +{ + /// Binds a plain boolean property; restoring it is just writing the old value back. + internal static ScreenToggle Bind(Func get, Action set) + { + ArgumentNullException.ThrowIfNull(get); + ArgumentNullException.ThrowIfNull(set); + + return new ScreenToggle( + get, + () => set(!get()), + () => + { + var previous = get(); + return () => set(previous); + }); + } +} + +/// +/// The navigable shape of one settings screen: its panes, each an ordered list of rows, where a row +/// is either a plain stop (null — selectable, but nothing to press) or a checkbox bound to +/// config. It carries no markup and no controls: the renderers draw what the cursor is on, this says +/// where the cursor may go and what happens there. Rebuilt from live config on every key, so it never +/// goes stale against a list the last keystroke changed. +/// +internal sealed class ScreenModel +{ + private readonly IReadOnlyList[] _panes; + + internal ScreenModel(params IReadOnlyList[] panes) + { + ArgumentNullException.ThrowIfNull(panes); + _panes = panes.Length == 0 ? new IReadOnlyList[] { Array.Empty() } : panes; + Sizes = Array.ConvertAll(_panes, p => p.Count); + } + + /// Row counts per pane, in pane order — what navigates by. + internal IReadOnlyList Sizes { get; } + + /// How many panes the screen offers ⇥ between. + internal int PaneCount => _panes.Length; + + /// The checkbox at a cursor position, or null when that row isn't pressable. + internal ScreenToggle? ToggleAt(int pane, int index) => + pane >= 0 && pane < _panes.Length && index >= 0 && index < _panes[pane].Count + ? _panes[pane][index] + : null; + + /// A pane of rows that are selectable but carry no checkbox (a plain list). + internal static IReadOnlyList Stops(int count) => new ScreenToggle?[Math.Max(0, count)]; + + /// A pane built by binding one checkbox per item of . + internal static IReadOnlyList Toggles( + IReadOnlyList items, Func get, Action set) + { + ArgumentNullException.ThrowIfNull(items); + ArgumentNullException.ThrowIfNull(get); + ArgumentNullException.ThrowIfNull(set); + + var rows = new ScreenToggle?[items.Count]; + for (var i = 0; i < items.Count; i++) + { + var item = items[i]; + rows[i] = ScreenToggle.Bind(() => get(item), value => set(item, value)); + } + + return rows; + } +} diff --git a/src/SharpMUTerm.Tui/ScreenPalette.cs b/src/SharpMUTerm.Tui/ScreenPalette.cs index 8f43409a..7f3aa67e 100644 --- a/src/SharpMUTerm.Tui/ScreenPalette.cs +++ b/src/SharpMUTerm.Tui/ScreenPalette.cs @@ -36,6 +36,13 @@ internal static class ScreenPalette /// Hairlines — column rules and separators. internal const string Rule = "#3a4257"; + /// + /// The bar under the keyboard cursor. Lighter than so it reads as a cursor on + /// both the backdrop and an elevated card, without competing with the accent the way a filled + /// accent bar would when it lands on every screen. + /// + internal const string CursorBg = "#2e3950"; + /// Near-black, for text printed *on* the accent (the Save chip). internal const string Ink = "#0f1620"; } diff --git a/src/SharpMUTerm.Tui/ScreenSelection.cs b/src/SharpMUTerm.Tui/ScreenSelection.cs new file mode 100644 index 00000000..e9f51d52 --- /dev/null +++ b/src/SharpMUTerm.Tui/ScreenSelection.cs @@ -0,0 +1,127 @@ +namespace SharpMUTerm.Tui; + +/// +/// Where the keyboard is on a settings screen: which pane holds focus, and where each pane's cursor +/// sits. A screen's panes change size as the selection moves (picking another world changes how many +/// characters there are), so the sizes are handed in on every move rather than cached here — this +/// object only remembers cursors, which keeps it a pure state machine with no view or config +/// dependency and makes every navigation rule unit-testable. +/// +internal sealed class ScreenSelection +{ + private readonly int[] _cursors; + + /// Creates a selection over panes, focused on the first. + internal ScreenSelection(int paneCount) + { + ArgumentOutOfRangeException.ThrowIfLessThan(paneCount, 1); + _cursors = new int[paneCount]; + } + + /// How many panes the screen has. + internal int PaneCount => _cursors.Length; + + /// The pane the keyboard is in. + internal int Pane { get; private set; } + + /// The cursor position within the focused pane. + internal int Index => _cursors[Pane]; + + /// The cursor position a pane will return to when focus comes back to it. + internal int CursorIn(int pane) => + pane >= 0 && pane < _cursors.Length ? _cursors[pane] : -1; + + /// + /// Seeds a pane's cursor without moving focus — used when a screen opens on state the app already + /// tracks (F5 opens on the connected world and character). Negative indices are ignored. + /// + internal void Seed(int pane, int index) + { + if (pane >= 0 && pane < _cursors.Length && index >= 0) + { + _cursors[pane] = index; + } + } + + /// + /// Moves the focused pane's cursor by rows, clamped to the pane's + /// current size — deliberately not wrapping, so holding ↑ parks on the first row instead of + /// teleporting to the last. Returns whether the cursor actually moved. + /// + internal bool Move(int delta, IReadOnlyList paneSizes) + { + ArgumentNullException.ThrowIfNull(paneSizes); + + Clamp(paneSizes); + var size = SizeOf(Pane, paneSizes); + if (size == 0) + { + return false; + } + + var next = Math.Clamp(_cursors[Pane] + delta, 0, size - 1); + if (next == _cursors[Pane]) + { + return false; + } + + _cursors[Pane] = next; + return true; + } + + /// + /// Moves focus to the next pane that has rows, wrapping past the last. Empty panes are skipped so + /// ⇥ never lands somewhere with no cursor (a world with no characters, an editor with no + /// toggles). Returns false when no other pane can take focus. + /// + internal bool NextPane(IReadOnlyList paneSizes) => Step(1, paneSizes); + + /// The mirror of , for Shift+⇥. + internal bool PreviousPane(IReadOnlyList paneSizes) => Step(-1, paneSizes); + + /// + /// Pulls every cursor back inside its pane and moves focus off a pane that has emptied, so a + /// selection that outlived the rows it pointed at still renders something sane. + /// + internal void Clamp(IReadOnlyList paneSizes) + { + ArgumentNullException.ThrowIfNull(paneSizes); + + for (var pane = 0; pane < _cursors.Length; pane++) + { + var size = SizeOf(pane, paneSizes); + _cursors[pane] = size == 0 ? 0 : Math.Clamp(_cursors[pane], 0, size - 1); + } + + if (SizeOf(Pane, paneSizes) == 0) + { + Step(1, paneSizes); + } + } + + /// Whether the focused pane has a row under the cursor at all. + internal bool HasSelection(IReadOnlyList paneSizes) + { + ArgumentNullException.ThrowIfNull(paneSizes); + return SizeOf(Pane, paneSizes) > 0; + } + + private bool Step(int direction, IReadOnlyList paneSizes) + { + for (var hop = 1; hop < _cursors.Length; hop++) + { + var candidate = ((Pane + (direction * hop)) % _cursors.Length + _cursors.Length) % _cursors.Length; + if (SizeOf(candidate, paneSizes) > 0) + { + Pane = candidate; + _cursors[Pane] = Math.Clamp(_cursors[Pane], 0, SizeOf(Pane, paneSizes) - 1); + return true; + } + } + + return false; + } + + private static int SizeOf(int pane, IReadOnlyList paneSizes) => + pane >= 0 && pane < paneSizes.Count ? Math.Max(0, paneSizes[pane]) : 0; +} diff --git a/src/SharpMUTerm.Tui/SettingsOverlay.cs b/src/SharpMUTerm.Tui/SettingsOverlay.cs index 16b22bdd..f6f7962e 100644 --- a/src/SharpMUTerm.Tui/SettingsOverlay.cs +++ b/src/SharpMUTerm.Tui/SettingsOverlay.cs @@ -5,59 +5,84 @@ namespace SharpMUTerm.Tui; +/// +/// One openable settings screen: the keyboard state it edits with, and the factory that renders that +/// state into a control tree. The factory closes over the session, so re-invoking it after a key is +/// how the screen reflects a moved cursor or a flipped checkbox. +/// +internal readonly record struct ScreenBinding(SettingsSession Session, Func Control); + /// /// A full-screen overlay hosting the F2–F9 settings screens. The design specifies these as /// full-screen surfaces, not floating dialogs: this maximises a frameless modal (no title bar, /// buttons, or resize grip) with a deep panel background. Every screen supplies a composed tree of -/// real panels. Esc (or the same F-key) closes it. The renderers stay pure and tested; this is a thin -/// host. +/// real panels. +/// +/// It is also where the screens get their keyboard. Keys arrive on PreviewKeyPressed, which +/// runs before any control sees them, and are handed to the screen's ; +/// this class only acts on the answer — rebuild the content, commit and close, or discard and close. +/// The interaction rules live in the session so they stay testable; the renderers stay pure. +/// /// internal sealed class SettingsOverlay { private readonly ConsoleWindowSystem _system; + private readonly Action _save; private Window? _window; private ConsoleKey _openKey; + private ScreenBinding? _binding; - public SettingsOverlay(ConsoleWindowSystem system) => _system = system; + /// + /// persists the configuration the screens edit in place — the ⏎ Save + /// action on every screen's action bar. + /// + public SettingsOverlay(ConsoleWindowSystem system, Action save) + { + _system = system; + _save = save; + } /// The F-key of the currently open screen, or null when closed. public ConsoleKey? OpenKey => _window is null ? null : _openKey; public bool IsOpen => _window is not null; - /// Toggles a screen's composed control tree. - public void Toggle(ConsoleKey key, Func control) => ToggleControl(key, control); - - /// Renders a screen into a headless frame (used by snapshots). - public void OpenForSnapshot(ConsoleKey key, Func control) => Open(key, control); - - private void ToggleControl(ConsoleKey key, Func factory) + /// + /// Opens a screen, or closes it when its own F-key is pressed again. Closing this way discards + /// pending edits, exactly like Esc — the F-key is a toggle, not a commit. + /// + public void Toggle(ConsoleKey key, Func binding) { - if (_window is not null && _openKey == key) - { - Close(); - return; - } + ArgumentNullException.ThrowIfNull(binding); if (_window is not null) { - Close(); + var reopening = _openKey != key; + Cancel(); + if (!reopening) + { + return; + } } - Open(key, factory); + Open(key, binding()); } - private void Open(ConsoleKey key, Func factory) + /// Renders a screen into a headless frame (used by snapshots). + public void OpenForSnapshot(ConsoleKey key, ScreenBinding binding) => Open(key, binding); + + private void Open(ConsoleKey key, ScreenBinding binding) { _openKey = key; + _binding = binding; _window = new WindowBuilder(_system) .AsModal() .Maximized() .Frameless() .WithColors(new Color(PanelFg), new Color(PanelBg)) - .AddControl(factory()) + .AddControl(binding.Control()) .OnClosed((_, _) => Reset()) .Build(); @@ -67,11 +92,62 @@ private void Open(ConsoleKey key, Func factory) private void OnKey(object? sender, KeyPressedEventArgs e) { - if (e.KeyInfo.Key == ConsoleKey.Escape || e.KeyInfo.Key == _openKey) + if (_window is null || _binding is not { } binding) { - Close(); - e.Handled = true; + return; } + + switch (binding.Session.Handle(e.KeyInfo)) + { + case ScreenAction.Cancel: + Cancel(); + e.Handled = true; + break; + + case ScreenAction.Save: + binding.Session.Edits.Commit(); + _save(); + Close(); + e.Handled = true; + break; + + case ScreenAction.Redraw: + Refresh(); + e.Handled = true; + break; + + case ScreenAction.Consumed: + e.Handled = true; + break; + + case ScreenAction.None: + default: + break; + } + } + + /// + /// Rebuilds the screen from the (now changed) config and cursor. The factory produces a whole + /// tree, so swapping the window's single control is both the simplest and the most honest refresh: + /// nothing can drift out of step with the renderers, because everything is re-rendered. + /// + private void Refresh() + { + if (_window is not { } window || _binding is not { } binding) + { + return; + } + + window.ClearControls(); + window.AddControl(binding.Control()); + window.Invalidate(redrawAll: true); + } + + /// Discards the screen's pending edits and closes it — Esc, and the F-key toggle. + private void Cancel() + { + _binding?.Session.Edits.Revert(); + Close(); } private void Close() @@ -82,5 +158,9 @@ private void Close() } } - private void Reset() => _window = null; + private void Reset() + { + _window = null; + _binding = null; + } } diff --git a/src/SharpMUTerm.Tui/SettingsSession.cs b/src/SharpMUTerm.Tui/SettingsSession.cs new file mode 100644 index 00000000..3b679fc2 --- /dev/null +++ b/src/SharpMUTerm.Tui/SettingsSession.cs @@ -0,0 +1,118 @@ +namespace SharpMUTerm.Tui; + +/// What a keystroke asked a settings screen to do. +internal enum ScreenAction +{ + /// Not a settings-screen key — leave it for the framework. + None, + + /// Ours, but nothing changed (↑ on the first row); swallow it and leave the screen alone. + Consumed, + + /// State changed — rebuild the screen from config. + Redraw, + + /// Commit the pending edits and close. + Save, + + /// Discard the pending edits and close. + Cancel, +} + +/// +/// One open settings screen's keyboard state: where the cursor is, what has been changed, and what a +/// key means. It owns no controls and no window — asks it what a +/// keystroke meant and acts on the answer — so the whole interaction contract (which keys move, which +/// toggle, what Esc undoes) is unit-testable without a terminal. +/// +/// The screen's is rebuilt on every key rather than cached: a keystroke can +/// change how many rows a pane has (picking another world changes the character list), and navigating +/// against last frame's row counts is exactly how a cursor ends up pointing at nothing. +/// +/// +internal sealed class SettingsSession +{ + private readonly Func _model; + + /// + /// Binds a screen to the factory that projects live config into navigable rows. The factory is + /// handed the selection rather than closing over it, because what a pane *contains* usually + /// depends on what the pane above it has selected — and a screen can't close over a session it is + /// in the middle of constructing. How many panes the screen has is read off a first projection, so + /// the renderer stays the single source of truth for the screen's shape. + /// + internal SettingsSession(Func model) + { + ArgumentNullException.ThrowIfNull(model); + _model = model; + Selection = new ScreenSelection(model(new ScreenSelection(1)).PaneCount); + } + + /// Where the keyboard is. Seeded by the screen before it first opens. + internal ScreenSelection Selection { get; } + + /// The pending changes Esc undoes and ⏎ keeps. + internal ScreenEdits Edits { get; } = new(); + + /// + /// The cursor as the renderers should draw it, clamped to the rows that exist right now. Returns + /// when the focused pane is empty, so nothing is highlighted. + /// + internal ScreenFocus Focus() + { + var model = _model(Selection); + Selection.Clamp(model.Sizes); + return Selection.HasSelection(model.Sizes) + ? new ScreenFocus(Selection.Pane, Selection.Index) + : ScreenFocus.None; + } + + /// + /// Interprets a keystroke: ↑↓ move within the focused pane, ⇥ / Shift+⇥ change pane, Space + /// toggles the checkbox under the cursor, ⏎ saves, Esc cancels. Anything else is not ours. + /// + internal ScreenAction Handle(ConsoleKeyInfo key) + { + var model = _model(Selection); + Selection.Clamp(model.Sizes); + + switch (key.Key) + { + case ConsoleKey.Escape: + return ScreenAction.Cancel; + + case ConsoleKey.Enter: + return ScreenAction.Save; + + case ConsoleKey.UpArrow: + return Changed(Selection.Move(-1, model.Sizes)); + + case ConsoleKey.DownArrow: + return Changed(Selection.Move(1, model.Sizes)); + + case ConsoleKey.Tab: + return Changed(key.Modifiers.HasFlag(ConsoleModifiers.Shift) + ? Selection.PreviousPane(model.Sizes) + : Selection.NextPane(model.Sizes)); + + case ConsoleKey.Spacebar: + return Toggle(model); + + default: + return ScreenAction.None; + } + } + + private ScreenAction Toggle(ScreenModel model) + { + if (model.ToggleAt(Selection.Pane, Selection.Index) is not { } toggle) + { + return ScreenAction.Consumed; + } + + Edits.Apply(toggle); + return ScreenAction.Redraw; + } + + private static ScreenAction Changed(bool moved) => moved ? ScreenAction.Redraw : ScreenAction.Consumed; +} diff --git a/src/SharpMUTerm.Tui/SharpMUTerm.Tui.csproj b/src/SharpMUTerm.Tui/SharpMUTerm.Tui.csproj index 9ebfcd20..8297e206 100644 --- a/src/SharpMUTerm.Tui/SharpMUTerm.Tui.csproj +++ b/src/SharpMUTerm.Tui/SharpMUTerm.Tui.csproj @@ -15,7 +15,24 @@ en - + + + $(MSBuildThisFileDirectory)..\..\..\SharpConsoleUI\SharpConsoleUI\SharpConsoleUI.csproj + true + + + + + + + diff --git a/src/SharpMUTerm.Tui/SharpMUTermApp.cs b/src/SharpMUTerm.Tui/SharpMUTermApp.cs index 3a4b538d..30e92ae7 100644 --- a/src/SharpMUTerm.Tui/SharpMUTermApp.cs +++ b/src/SharpMUTerm.Tui/SharpMUTermApp.cs @@ -164,7 +164,7 @@ public SharpMUTermApp(AppConfiguration config, TerminalCapabilities capabilities .Build(); _palette = new CommandPalette(_system, BuildCatalog, () => _active?.SessionKey, DispatchCommand); - _settings = new SettingsOverlay(_system); + _settings = new SettingsOverlay(_system, SaveConfiguration); _window.OnResize += (_, _) => { @@ -296,7 +296,7 @@ public string RenderSnapshot(string? view = null) // either way) open over the workspace for their --view name. if (view is not null && SettingsView(view) is { } screen) { - _settings.OpenForSnapshot(screen.Key, screen.Control); + _settings.OpenForSnapshot(screen.Key, screen.Open()); } // Render exactly one frame, synchronously, inline on this thread. ForceRender() performs a @@ -716,9 +716,10 @@ private void RefreshStatusBar() /// /// One settings screen: the F-key that toggles it, the --view names that select it for a - /// snapshot, and the factory that builds its control. + /// snapshot, and the factory that opens it — a fresh (its own cursor + /// and undo log) plus the control factory that renders that session. /// - private readonly record struct SettingsScreen(ConsoleKey Key, string[] Views, Func Control); + private readonly record struct SettingsScreen(ConsoleKey Key, string[] Views, Func Open); /// /// The F2–F9 settings screens, in F-key order. Both the global shortcuts and the --view @@ -729,14 +730,14 @@ private void RefreshStatusBar() /// private IReadOnlyList SettingsScreens() => new SettingsScreen[] { - new(ConsoleKey.F2, new[] { "triggers" }, TriggersControl), - new(ConsoleKey.F3, new[] { "aliases" }, AliasesControl), - new(ConsoleKey.F4, new[] { "keypad" }, KeypadControl), - new(ConsoleKey.F5, new[] { "worlds", "settings" }, WorldsControl), - new(ConsoleKey.F6, new[] { "timers" }, TimersControl), - new(ConsoleKey.F7, new[] { "textansi" }, TextAnsiControl), - new(ConsoleKey.F8, new[] { "input" }, InputSpellcheckControl), - new(ConsoleKey.F9, new[] { "logging" }, LoggingControl), + new(ConsoleKey.F2, new[] { "triggers" }, TriggersScreen), + new(ConsoleKey.F3, new[] { "aliases" }, AliasesScreen), + new(ConsoleKey.F4, new[] { "keypad" }, KeypadScreen), + new(ConsoleKey.F5, new[] { "worlds", "settings" }, WorldsScreen), + new(ConsoleKey.F6, new[] { "timers" }, TimersScreen), + new(ConsoleKey.F7, new[] { "textansi" }, TextAnsiScreen), + new(ConsoleKey.F8, new[] { "input" }, InputSpellcheckScreen), + new(ConsoleKey.F9, new[] { "logging" }, LoggingScreen), }; /// @@ -746,8 +747,26 @@ private void RegisterSettingsShortcuts() { foreach (var screen in SettingsScreens()) { - var (key, control) = (screen.Key, screen.Control); - _system.RegisterGlobalShortcut((ConsoleModifiers)0, key, () => _settings.Toggle(key, control)); + var (key, open) = (screen.Key, screen.Open); + _system.RegisterGlobalShortcut((ConsoleModifiers)0, key, () => _settings.Toggle(key, open)); + } + } + + /// + /// Persists the configuration the settings screens edit — the ⏎ Save action. The workspace layout + /// is captured alongside it so a save never rolls back the resumed session; a failed write is + /// swallowed for the same reason startup's is (the config is a convenience, not the session). + /// + private void SaveConfiguration() + { + try + { + _config.LastSession = CaptureSession(); + ConfigurationStore.Save(ConfigurationStore.DefaultPath, _config); + } + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or NotSupportedException) + { + SetStatus($"[red]could not save settings:[/] {Escape(ex.Message)}"); } } @@ -798,52 +817,122 @@ private int ActiveCharacterIndex() return 0; } - /// The active character's logging settings, for the F9 logging screen. + /// + /// The logging settings the F9 screen edits: the active character's, falling back to the first + /// configured character so a disconnected screen still edits something that can be saved. Only a + /// config with no characters at all yields a detached default — without a character there is no + /// session to log. + /// private LoggingSettings ActiveLogging() { var world = _config.Worlds.ElementAtOrDefault(ActiveWorldIndex()); - return world?.Characters.ElementAtOrDefault(ActiveCharacterIndex())?.Logging ?? new LoggingSettings(); + var character = world?.Characters.ElementAtOrDefault(ActiveCharacterIndex()) + ?? _config.Worlds.SelectMany(w => w.Characters).FirstOrDefault(); + return character?.Logging ?? new LoggingSettings(); } - /// Builds the F5 Worlds & Characters screen as a composed control tree (real panels). - private IWindowControl WorldsControl() => WorldsScreenView.Build( - _config.Worlds, _config.TriggerSets, ActiveWorldIndex(), ActiveCharacterIndex(), _system.DesktopDimensions.Width); + /// + /// Opens the F5 Worlds & Characters screen: three panes (worlds → characters → the selected + /// character's trigger sets), seeded on whatever is connected so the screen opens where the user + /// already is. + /// + private ScreenBinding WorldsScreen() + { + var session = new SettingsSession(selection => WorldsScreenRenderer.Model( + _config.Worlds, _config.TriggerSets, selection.CursorIn(0), selection.CursorIn(1))); + session.Selection.Seed(0, ActiveWorldIndex()); + session.Selection.Seed(1, ActiveCharacterIndex()); - /// Builds the F2 Triggers & spawn routing screen as a composed control tree (real panels). - private IWindowControl TriggersControl() => TriggersScreenView.Build( - _config.TriggerSets, 0, SpawnTargets(), _system.DesktopDimensions.Width); + return new ScreenBinding(session, () => WorldsScreenView.Build( + _config.Worlds, + _config.TriggerSets, + session.Selection.CursorIn(0), + session.Selection.CursorIn(1), + _system.DesktopDimensions.Width, + session.Focus())); + } - /// Builds the F3 Aliases screen as a composed control tree (real panels). - private IWindowControl AliasesControl() => AliasesScreenView.Build( - _config.TriggerSets, 0, _system.DesktopDimensions.Width); + /// Opens the F2 Triggers & spawn routing screen: the rule list, then the rule's toggles. + private ScreenBinding TriggersScreen() + { + var session = new SettingsSession(selection => + TriggersScreenRenderer.Model(_config.TriggerSets, selection.CursorIn(0))); - /// Builds the F4 Keypad & hotkeys screen as a composed control tree (real panels). - private IWindowControl KeypadControl() => KeypadScreenView.Build(Macros(), _system.DesktopDimensions.Width); + return new ScreenBinding(session, () => TriggersScreenView.Build( + _config.TriggerSets, + session.Selection.CursorIn(0), + SpawnTargets(), + _system.DesktopDimensions.Width, + session.Focus())); + } - /// Builds the F6 Timers screen as a composed control tree (real panels). - private IWindowControl TimersControl() => TimersScreenView.Build( - _config.TriggerSets, 0, _system.DesktopDimensions.Width); + /// Opens the F3 Aliases screen: the alias list, then the alias's toggles. + private ScreenBinding AliasesScreen() + { + var session = new SettingsSession(selection => + AliasesScreenRenderer.Model(_config.TriggerSets, selection.CursorIn(0))); - /// Builds the F7 Text & ANSI screen as a composed control tree (real panels). - private IWindowControl TextAnsiControl() => OptionsScreenView.Build( - OptionsScreenRenderer.TextAnsiScreen(), _system.DesktopDimensions.Width); + return new ScreenBinding(session, () => AliasesScreenView.Build( + _config.TriggerSets, session.Selection.CursorIn(0), _system.DesktopDimensions.Width, session.Focus())); + } + + /// Opens the F4 Keypad & hotkeys screen: one pane, the binding list. + private ScreenBinding KeypadScreen() + { + var session = new SettingsSession(_ => KeypadScreenRenderer.Model(Macros())); + return new ScreenBinding(session, () => KeypadScreenView.Build( + Macros(), _system.DesktopDimensions.Width, session.Focus())); + } + + /// Opens the F6 Timers screen: the timer list, then the timer's toggles. + private ScreenBinding TimersScreen() + { + var session = new SettingsSession(selection => + TimersScreenRenderer.Model(_config.TriggerSets, selection.CursorIn(0))); + + return new ScreenBinding(session, () => TimersScreenView.Build( + _config.TriggerSets, session.Selection.CursorIn(0), _system.DesktopDimensions.Width, session.Focus())); + } + + /// Opens the F7 Text & ANSI screen, bound to the app's text preferences. + private ScreenBinding TextAnsiScreen() => + OptionsScreen(() => OptionsScreenRenderer.TextAnsiScreen(_config.Text)); - /// Builds the F8 Input & spellcheck screen as a composed control tree (real panels). - private IWindowControl InputSpellcheckControl() => OptionsScreenView.Build( - OptionsScreenRenderer.InputSpellcheckScreen(), _system.DesktopDimensions.Width); + /// Opens the F8 Input & spellcheck screen, bound to the app's input preferences. + private ScreenBinding InputSpellcheckScreen() => + OptionsScreen(() => OptionsScreenRenderer.InputSpellcheckScreen(_config.Input)); - /// Builds the F9 Logging screen as a composed control tree (real panels). - private IWindowControl LoggingControl() => OptionsScreenView.Build( - OptionsScreenRenderer.LoggingScreen(ActiveLogging()), _system.DesktopDimensions.Width); + /// + /// Opens the F9 Logging screen, bound to the active character's logging settings. The settings + /// object is resolved once, when the screen opens: re-resolving it per keystroke would let the + /// screen edit one character's log and then save another's if the active session changed underneath. + /// + private ScreenBinding LoggingScreen() + { + var logging = ActiveLogging(); + return OptionsScreen(() => OptionsScreenRenderer.LoggingScreen(logging)); + } + + /// + /// The shared open path for the single-list option screens (F7/F8/F9). is + /// re-projected from config on every key, so a flipped checkbox shows up in both the row it lives + /// on and the model the next keystroke navigates. + /// + private ScreenBinding OptionsScreen(Func screen) + { + var session = new SettingsSession(_ => OptionsScreenRenderer.Model(screen())); + return new ScreenBinding(session, () => OptionsScreenView.Build( + screen(), _system.DesktopDimensions.Width, session.Focus())); + } - /// Maps a --view name to a settings screen (F-key + control factory) for snapshots. - private (ConsoleKey Key, Func Control)? SettingsView(string view) + /// Maps a --view name to a settings screen (F-key + open factory) for snapshots. + private (ConsoleKey Key, Func Open)? SettingsView(string view) { foreach (var screen in SettingsScreens()) { if (screen.Views.Contains(view, StringComparer.OrdinalIgnoreCase)) { - return (screen.Key, screen.Control); + return (screen.Key, screen.Open); } } diff --git a/src/SharpMUTerm.Tui/TimersScreenRenderer.cs b/src/SharpMUTerm.Tui/TimersScreenRenderer.cs index 6c527be8..b1f85cb8 100644 --- a/src/SharpMUTerm.Tui/TimersScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/TimersScreenRenderer.cs @@ -17,7 +17,12 @@ namespace SharpMUTerm.Tui; /// internal static class TimersScreenRenderer { - private const int ColumnWidth = 54; + /// + /// Visible width of the left column. The view lays its column out at exactly this width, so + /// the two must agree -- a cursor bar padded narrower than its column leaves a gap before the + /// rule. Shared rather than duplicated so they cannot drift apart. + /// + internal const int ColumnWidth = 56; /// /// Merges every sub-block into one line list (header, timer list | editor, footer). Used by the @@ -51,10 +56,36 @@ public static List Render(IReadOnlyList sets, int selected) internal static string HeaderLine(int width) { var title = $"[bold {Value}] Timers[/]"; - var hints = ScreenChrome.Hints("↑↓ select · ⇥ switch pane · ⏎ edit", "F6"); + var hints = ScreenChrome.Hints(ScreenChrome.ListHints, "F6"); return SpreadLR(" " + title, hints, width); } + /// + /// The screen's navigable panes: the timer list (Space enables/disables one) and the selected + /// timer's checkbox rows, in the order draws them. + /// + internal static ScreenModel Model(IReadOnlyList sets, int selected) + { + ArgumentNullException.ThrowIfNull(sets); + + var entries = Flatten(sets); + var list = ScreenModel.Toggles(entries, e => e.Timer.Enabled, (e, v) => e.Timer.Enabled = v); + + if (selected < 0 || selected >= entries.Count) + { + return new ScreenModel(list, Array.Empty()); + } + + var timer = entries[selected].Timer; + var editor = new ScreenToggle?[] + { + ScreenToggle.Bind(() => timer.OneShot, v => timer.OneShot = v), + ScreenToggle.Bind(() => timer.Enabled, v => timer.Enabled = v), + }; + + return new ScreenModel(list, editor); + } + /// The action bar: which timer is selected on the left, cancel/save on the right. internal static string FooterLine(IReadOnlyList sets, int selected, int width) { @@ -72,10 +103,12 @@ internal static string FooterLine(IReadOnlyList sets, int selected, } /// The timer list — every timer of every set, with its enabled state and schedule. - internal static List ListColumn(IReadOnlyList sets, int selected) + internal static List ListColumn( + IReadOnlyList sets, int selected, ScreenFocus? focus = null) { ArgumentNullException.ThrowIfNull(sets); + var cursor = focus ?? ScreenFocus.None; var entries = Flatten(sets); var lines = new List { "[dim]on name every → command[/]" }; @@ -87,7 +120,8 @@ internal static List ListColumn(IReadOnlyList sets, int sele for (var i = 0; i < entries.Count; i++) { - lines.Add(Row(entries[i].Timer, entries[i].SetName, i == selected)); + var row = Row(entries[i].Timer, entries[i].SetName, i == selected); + lines.Add(ScreenChrome.Cursor(row, cursor.IsOn(0, i), ColumnWidth)); } return lines; @@ -97,13 +131,14 @@ internal static List ListColumn(IReadOnlyList sets, int sele /// The editor for the selected timer — interval, command, and the one-shot/enabled toggles. /// Empty when nothing is selected. /// - internal static List EditorColumn(IReadOnlyList sets, int selected) + internal static List EditorColumn( + IReadOnlyList sets, int selected, ScreenFocus? focus = null) { ArgumentNullException.ThrowIfNull(sets); var entries = Flatten(sets); return selected >= 0 && selected < entries.Count - ? BuildEditor(entries[selected].Timer) + ? BuildEditor(entries[selected].Timer, focus ?? ScreenFocus.None) : new List(); } @@ -132,7 +167,7 @@ private static string Row(TimerDefinition timer, string setName, bool selected) return $"{check} {marker} [bold]{name}[/] {schedule} [dim]▪ {Escape(setName)}[/] → {command}"; } - private static List BuildEditor(TimerDefinition timer) => new() + private static List BuildEditor(TimerDefinition timer, ScreenFocus cursor) => new() { "[dim]interval (seconds)[/]", $" {Seconds(timer)}", @@ -140,10 +175,14 @@ private static string Row(TimerDefinition timer, string setName, bool selected) "[dim]command[/]", $" {Escape(timer.Command)}", string.Empty, - timer.OneShot ? $"[{Accent}][[x]][/] one-shot" : "[dim][[ ]] one-shot[/]", - timer.Enabled ? $"[{Accent}][[x]][/] enabled" : "[dim][[ ]] enabled[/]", + ScreenChrome.Cursor(Checkbox("one-shot", timer.OneShot), cursor.IsOn(1, 0), ColumnWidth), + ScreenChrome.Cursor(Checkbox("enabled", timer.Enabled), cursor.IsOn(1, 1), ColumnWidth), }; + /// A checkbox row in the editor pane, checked in the accent and unchecked dim. + private static string Checkbox(string label, bool value) => + value ? $"[{Accent}][[x]][/] {Escape(label)}" : $"[dim][[ ]] {Escape(label)}[/]"; + /// The row-level schedule summary: every 30s, or once after 5.5s. private static string Schedule(TimerDefinition timer) => timer.OneShot ? $"once after {Seconds(timer)}s" : $"every {Seconds(timer)}s"; diff --git a/src/SharpMUTerm.Tui/TimersScreenView.cs b/src/SharpMUTerm.Tui/TimersScreenView.cs index 7a782e55..1f822b3f 100644 --- a/src/SharpMUTerm.Tui/TimersScreenView.cs +++ b/src/SharpMUTerm.Tui/TimersScreenView.cs @@ -15,18 +15,20 @@ namespace SharpMUTerm.Tui; /// internal static class TimersScreenView { - private const int ListColumnWidth = 56; + private const int ListColumnWidth = TimersScreenRenderer.ColumnWidth; - public static IWindowControl Build(IReadOnlyList sets, int selected, int width) + public static IWindowControl Build( + IReadOnlyList sets, int selected, int width, ScreenFocus? focus = null) { var header = ScreenChrome.Band(TimersScreenRenderer.HeaderLine(width), ScreenPalette.HeaderBg); var footer = ScreenChrome.Band( TimersScreenRenderer.FooterLine(sets, selected, width), ScreenPalette.FooterBg); // Body: timer list │ editor, as two real columns. - var listCol = ScreenChrome.Stretch(new MarkupControl(TimersScreenRenderer.ListColumn(sets, selected))); + var listCol = ScreenChrome.Stretch( + new MarkupControl(TimersScreenRenderer.ListColumn(sets, selected, focus))); var editorCol = ScreenChrome.Stretch( - new MarkupControl(ScreenChrome.Indent(TimersScreenRenderer.EditorColumn(sets, selected)))); + new MarkupControl(ScreenChrome.Indent(TimersScreenRenderer.EditorColumn(sets, selected, focus)))); var body = Controls.HorizontalGrid() .WithAlignment(HorizontalAlignment.Stretch) .WithVerticalAlignment(VerticalAlignment.Fill) diff --git a/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs b/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs index 2aef8f6a..52fe067a 100644 --- a/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs @@ -18,7 +18,12 @@ namespace SharpMUTerm.Tui; /// internal static class TriggersScreenRenderer { - private const int ColumnWidth = 54; + /// + /// Visible width of the left column. The view lays its column out at exactly this width, so + /// the two must agree -- a cursor bar padded narrower than its column leaves a gap before the + /// rule. Shared rather than duplicated so they cannot drift apart. + /// + internal const int ColumnWidth = 56; /// /// Merges every sub-block into one line list (header, rule list | editor, footer). Used by the @@ -56,10 +61,37 @@ public static List Render( internal static string HeaderLine(int width) { var title = $"[bold {Value}] Triggers & spawn routing[/]"; - var hints = ScreenChrome.Hints("↑↓ select · ⇥ switch pane · ⏎ edit", "F2"); + var hints = ScreenChrome.Hints(ScreenChrome.ListHints, "F2"); return SpreadLR(" " + title, hints, width); } + /// + /// The screen's navigable panes: the rule list (Space enables/disables a trigger) and the + /// selected rule's checkbox rows, in the order draws them. + /// + internal static ScreenModel Model(IReadOnlyList sets, int selectedTrigger) + { + ArgumentNullException.ThrowIfNull(sets); + + var flattened = Flatten(sets); + var rules = ScreenModel.Toggles( + flattened, e => e.Trigger.Enabled, (e, v) => e.Trigger.Enabled = v); + + if (selectedTrigger < 0 || selectedTrigger >= flattened.Count) + { + return new ScreenModel(rules, Array.Empty()); + } + + var trigger = flattened[selectedTrigger].Trigger; + var editor = new ScreenToggle?[] + { + ScreenToggle.Bind(() => trigger.Actions.Gag, v => trigger.Actions.Gag = v), + ScreenToggle.Bind(() => trigger.StopProcessing, v => trigger.StopProcessing = v), + }; + + return new ScreenModel(rules, editor); + } + /// The action bar: which rule is selected on the left, cancel/save on the right. internal static string FooterLine(IReadOnlyList sets, int selectedTrigger, int width) { @@ -77,10 +109,12 @@ internal static string FooterLine(IReadOnlyList sets, int selectedTr } /// The rule list — every trigger of every set, each over a set/flags sub-row. - internal static List RulesColumn(IReadOnlyList sets, int selectedTrigger) + internal static List RulesColumn( + IReadOnlyList sets, int selectedTrigger, ScreenFocus? focus = null) { ArgumentNullException.ThrowIfNull(sets); + var cursor = focus ?? ScreenFocus.None; var flattened = Flatten(sets); var left = new List { "[dim]on name / pattern → window[/]" }; @@ -93,7 +127,7 @@ internal static List RulesColumn(IReadOnlyList sets, int sel for (var i = 0; i < flattened.Count; i++) { var (trigger, setName) = flattened[i]; - left.Add(RuleRow(i, selectedTrigger, trigger)); + left.Add(ScreenChrome.Cursor(RuleRow(i, selectedTrigger, trigger), cursor.IsOn(0, i), ColumnWidth)); left.Add(RuleSub(setName, trigger.Actions)); } @@ -107,14 +141,15 @@ internal static List RulesColumn(IReadOnlyList sets, int sel internal static List EditorColumn( IReadOnlyList sets, int selectedTrigger, - IReadOnlyList spawnTargets) + IReadOnlyList spawnTargets, + ScreenFocus? focus = null) { ArgumentNullException.ThrowIfNull(sets); ArgumentNullException.ThrowIfNull(spawnTargets); var flattened = Flatten(sets); return selectedTrigger >= 0 && selectedTrigger < flattened.Count - ? BuildEditor(flattened[selectedTrigger].Trigger, spawnTargets) + ? BuildEditor(flattened[selectedTrigger].Trigger, spawnTargets, focus ?? ScreenFocus.None) : new List(); } @@ -175,7 +210,7 @@ private static string Flags(TriggerActions actions) return flags.Count == 0 ? "—" : string.Join(" ", flags); } - private static List BuildEditor(Trigger trigger, IReadOnlyList spawnTargets) + private static List BuildEditor(Trigger trigger, IReadOnlyList spawnTargets, ScreenFocus cursor) { var currentRoute = trigger.Actions.SpawnTarget ?? "main"; @@ -214,13 +249,21 @@ private static List BuildEditor(Trigger trigger, IReadOnlyList s lines.Add(string.Empty); } + // The highlight row is a read-only indicator: it reports whether a colour is set, and there is + // no colour picker yet to turn one on with, so it never takes the cursor. The two rows below it + // are real booleans on the trigger, and are the editor pane's navigable rows in this order. lines.Add(hasHighlight ? $"[{Accent}][[x]][/] highlight line" : "[dim][[ ]] highlight line[/]"); - lines.Add("[dim][[ ]] play sound[/]"); - lines.Add(trigger.Actions.Gag ? $"[{Accent}][[x]][/] gag line" : "[dim][[ ]] gag line[/]"); + lines.Add(ScreenChrome.Cursor(Checkbox("gag line", trigger.Actions.Gag), cursor.IsOn(1, 0), ColumnWidth)); + lines.Add(ScreenChrome.Cursor( + Checkbox("stop processing", trigger.StopProcessing), cursor.IsOn(1, 1), ColumnWidth)); return lines; } + /// A checkbox row in the editor pane, checked in the accent and unchecked dim. + private static string Checkbox(string label, bool value) => + value ? $"[{Accent}][[x]][/] {Escape(label)}" : $"[dim][[ ]] {Escape(label)}[/]"; + private static string RouteRow(string label, string currentRoute) { var marker = label == currentRoute ? $"[{Accent}]●[/]" : "[dim]○[/]"; diff --git a/src/SharpMUTerm.Tui/TriggersScreenView.cs b/src/SharpMUTerm.Tui/TriggersScreenView.cs index 08e4bcdd..f8cd0492 100644 --- a/src/SharpMUTerm.Tui/TriggersScreenView.cs +++ b/src/SharpMUTerm.Tui/TriggersScreenView.cs @@ -15,13 +15,14 @@ namespace SharpMUTerm.Tui; /// internal static class TriggersScreenView { - private const int RulesColumnWidth = 56; + private const int RulesColumnWidth = TriggersScreenRenderer.ColumnWidth; public static IWindowControl Build( IReadOnlyList sets, int selectedTrigger, IReadOnlyList spawnTargets, - int width) + int width, + ScreenFocus? focus = null) { var header = ScreenChrome.Band(TriggersScreenRenderer.HeaderLine(width), ScreenPalette.HeaderBg); var footer = ScreenChrome.Band( @@ -29,9 +30,10 @@ public static IWindowControl Build( // Body: rule list │ editor, as two real columns. var rulesCol = ScreenChrome.Stretch( - new MarkupControl(TriggersScreenRenderer.RulesColumn(sets, selectedTrigger))); + new MarkupControl(TriggersScreenRenderer.RulesColumn(sets, selectedTrigger, focus))); var editorCol = ScreenChrome.Stretch(new MarkupControl( - ScreenChrome.Indent(TriggersScreenRenderer.EditorColumn(sets, selectedTrigger, spawnTargets)))); + ScreenChrome.Indent( + TriggersScreenRenderer.EditorColumn(sets, selectedTrigger, spawnTargets, focus)))); var body = Controls.HorizontalGrid() .WithAlignment(HorizontalAlignment.Stretch) .WithVerticalAlignment(VerticalAlignment.Fill) diff --git a/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs b/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs index 1348ec9b..2ce9bb16 100644 --- a/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs @@ -19,6 +19,9 @@ internal static class WorldsScreenRenderer private const int WorldLabelWidth = 9; private const int CharLabelWidth = 10; private const int CharDetailColumnWidth = 40; + + /// How wide the cursor bar runs across a character row — the row's own column header. + private const int CharacterRowWidth = 62; private const string DividerGlyph = " │ "; /// The accent hex for the selected world (its own, or the default teal). @@ -78,10 +81,69 @@ internal static bool HasCharacter(IReadOnlyList worlds, int sel internal static string HeaderLine(int width) { var title = $"[bold {Value}] Worlds & Characters[/]"; - var hints = ScreenChrome.Hints("↑↓ select · ⇥ switch pane · ⏎ edit", "F5"); + var hints = ScreenChrome.Hints(ScreenChrome.ListHints, "F5"); return SpreadLR(" " + title, hints, width); } + /// + /// The screen's three navigable panes, in ⇥ order: the WORLDS list (selection only — a world has + /// no checkbox on its row), the selected world's characters (Space flips auto-login, which the row + /// itself reports), and the selected character's assigned trigger sets (Space assigns/unassigns). + /// The last two collapse to empty when there is nothing selected above them, and ⇥ skips empty + /// panes, so the cursor never lands somewhere with no rows. + /// + internal static ScreenModel Model( + IReadOnlyList worlds, + IReadOnlyList triggerSets, + int selectedWorld, + int selectedCharacter) + { + ArgumentNullException.ThrowIfNull(worlds); + ArgumentNullException.ThrowIfNull(triggerSets); + + var worldRows = ScreenModel.Stops(worlds.Count); + var world = selectedWorld >= 0 && selectedWorld < worlds.Count ? worlds[selectedWorld] : null; + var characterRows = world is null + ? Array.Empty() + : ScreenModel.Toggles(world.Characters, c => c.AutoLogin, (c, v) => c.AutoLogin = v); + + if (!HasCharacter(worlds, selectedWorld, selectedCharacter)) + { + return new ScreenModel(worldRows, characterRows, Array.Empty()); + } + + var character = worlds[selectedWorld].Characters[selectedCharacter]; + var setRows = new ScreenToggle?[triggerSets.Count]; + for (var i = 0; i < triggerSets.Count; i++) + { + var name = triggerSets[i].Name; + + // Assignment is list membership, and the character's own order decides which set wins a + // conflict (see AppConfiguration.ResolveTriggerSets) — so the snapshot restores the whole + // list rather than re-adding the name at the end, which would silently reorder priority. + setRows[i] = new ScreenToggle( + () => character.TriggerSets.Contains(name), + () => + { + if (!character.TriggerSets.Remove(name)) + { + character.TriggerSets.Add(name); + } + }, + () => + { + var previous = character.TriggerSets.ToList(); + return () => + { + character.TriggerSets.Clear(); + character.TriggerSets.AddRange(previous); + }; + }); + } + + return new ScreenModel(worldRows, characterRows, setRows); + } + internal static string FooterLine( IReadOnlyList worlds, int selectedWorld, int selectedCharacter, string accent, int width) { @@ -100,8 +162,10 @@ internal static string FooterLine( return SpreadLR(" " + context, actions, width); } - internal static List WorldsColumn(IReadOnlyList worlds, int selectedWorld) + internal static List WorldsColumn( + IReadOnlyList worlds, int selectedWorld, ScreenFocus? focus = null) { + var cursor = focus ?? ScreenFocus.None; var left = new List { $"[{Label}]WORLDS[/]", string.Empty }; for (var i = 0; i < worlds.Count; i++) @@ -116,7 +180,8 @@ internal static List WorldsColumn(IReadOnlyList worlds, var marker = selected ? $"[bold {Accent}]▸[/]" : " "; var accentHex = Hex(world.Accent); var name = selected ? $"[bold {Value}]{Escape(world.Name)}[/]" : $"[{Value}]{Escape(world.Name)}[/]"; - left.Add($"{marker} [{accentHex}]▚[/] {name}"); + left.Add(ScreenChrome.Cursor( + $"{marker} [{accentHex}]▚[/] {name}", cursor.IsOn(0, i), LeftColumnWidth)); left.Add($" [{Label}]{Escape(world.Host)}:{world.Port.ToString(CultureInfo.InvariantCulture)}[/]"); left.Add($" [{Label}]{world.Characters.Count.ToString(CultureInfo.InvariantCulture)} chars[/]"); } @@ -136,8 +201,10 @@ internal static List DetailColumn( IReadOnlyList triggerSets, int selectedWorld, int selectedCharacter, - string accent) + string accent, + ScreenFocus? focus = null) { + var cursor = focus ?? ScreenFocus.None; if (selectedWorld < 0 || selectedWorld >= worlds.Count) { return new List(); @@ -171,7 +238,10 @@ internal static List DetailColumn( { for (var i = 0; i < world.Characters.Count; i++) { - right.Add(CharacterRow(world.Characters[i], i == selectedCharacter)); + right.Add(ScreenChrome.Cursor( + CharacterRow(world.Characters[i], i == selectedCharacter), + cursor.IsOn(1, i), + CharacterRowWidth)); } } @@ -194,19 +264,34 @@ internal static List DetailColumn( /// The assigned-trigger-sets checklist for a character. internal static List TriggersColumn( - CharacterDefinition character, IReadOnlyList triggerSets, string accent) + CharacterDefinition character, + IReadOnlyList triggerSets, + string accent, + ScreenFocus? focus = null) { - var list = new List { $"[{Label}]assigned trigger sets[/]", string.Empty }; + var cursor = focus ?? ScreenFocus.None; + var rows = new List(triggerSets.Count); foreach (var set in triggerSets) { var assigned = character.TriggerSets.Contains(set.Name); var box = assigned ? $"[{accent}][[x]][/]" : $"[{Label}][[ ]][/]"; var nameColor = assigned ? Value : Label; var description = Escape(set.Description ?? string.Empty); - list.Add( + rows.Add( $"{box} [{nameColor}]▪ {Escape(set.Name)}[/] [{Label}]— {description} {set.Triggers.Count.ToString(CultureInfo.InvariantCulture)} rules[/]"); } + // The checklist sits in an auto-width column (see WorldsScreenView), so a cursor bar sized to + // one row would widen the block and shunt it sideways as the cursor moved. Sizing every bar to + // the widest row keeps the column's measured width constant whatever is focused. + var barWidth = rows.Count == 0 ? 0 : rows.Max(VisibleLength); + + var list = new List { $"[{Label}]assigned trigger sets[/]", string.Empty }; + for (var i = 0; i < rows.Count; i++) + { + list.Add(ScreenChrome.Cursor(rows[i], cursor.IsOn(2, i), barWidth)); + } + return list; } diff --git a/src/SharpMUTerm.Tui/WorldsScreenView.cs b/src/SharpMUTerm.Tui/WorldsScreenView.cs index 6361dc72..223a37e6 100644 --- a/src/SharpMUTerm.Tui/WorldsScreenView.cs +++ b/src/SharpMUTerm.Tui/WorldsScreenView.cs @@ -21,7 +21,8 @@ public static IWindowControl Build( IReadOnlyList triggerSets, int selectedWorld, int selectedCharacter, - int width) + int width, + ScreenFocus? focus = null) { var accent = WorldsScreenRenderer.AccentFor(worlds, selectedWorld); @@ -32,9 +33,11 @@ public static IWindowControl Build( // Body: WORLDS list │ detail, as two real columns. var worldsCol = ScreenChrome.Stretch( - new MarkupControl(WorldsScreenRenderer.WorldsColumn(worlds, selectedWorld).ToList())); + new MarkupControl(WorldsScreenRenderer.WorldsColumn(worlds, selectedWorld, focus).ToList())); var detailCol = ScreenChrome.Stretch(new MarkupControl( - WorldsScreenRenderer.DetailColumn(worlds, triggerSets, selectedWorld, selectedCharacter, accent).ToList())); + WorldsScreenRenderer + .DetailColumn(worlds, triggerSets, selectedWorld, selectedCharacter, accent, focus) + .ToList())); var body = Controls.HorizontalGrid() .WithAlignment(HorizontalAlignment.Stretch) .WithVerticalAlignment(VerticalAlignment.Fill) @@ -52,7 +55,7 @@ public static IWindowControl Build( { var character = worlds[selectedWorld].Characters[selectedCharacter]; var form = WorldsScreenRenderer.FormColumn(character, accent).ToList(); - var triggers = WorldsScreenRenderer.TriggersColumn(character, triggerSets, accent).ToList(); + var triggers = WorldsScreenRenderer.TriggersColumn(character, triggerSets, accent, focus).ToList(); var editHeight = Math.Max(form.Count, triggers.Count); // Form panel on the left; the trigger checklist pushed to the right by a flex spacer so its diff --git a/tests/SharpMUTerm.Core.Tests/Configuration/ConfigurationTests.cs b/tests/SharpMUTerm.Core.Tests/Configuration/ConfigurationTests.cs index cf01f5e6..b27ef518 100644 --- a/tests/SharpMUTerm.Core.Tests/Configuration/ConfigurationTests.cs +++ b/tests/SharpMUTerm.Core.Tests/Configuration/ConfigurationTests.cs @@ -260,6 +260,51 @@ public async Task LastSession_RoundTripsThroughTheStore() await Assert.That(workspace.FindWindow(Workspace.SpawnWindowId("Chat"))!.OwnerLabel).IsEqualTo("Corvid"); } + [Test] + public async Task TextAndInputPreferences_RoundTripThroughTheStore() + { + var config = new AppConfiguration(); + config.Text.StripIncomingColour = true; + config.Text.UnderlineHyperlinks = false; + config.Text.AmbiguousWidth = "wide"; + config.Input.LocalEcho = false; + config.Input.Dictionary = "en_GB"; + + var restored = ConfigurationStore.Deserialize(ConfigurationStore.Serialize(config)); + + await Assert.That(restored.Text.StripIncomingColour).IsTrue(); + await Assert.That(restored.Text.AllowBlink).IsFalse(); + await Assert.That(restored.Text.UnderlineHyperlinks).IsFalse(); + await Assert.That(restored.Text.AmbiguousWidth).IsEqualTo("wide"); + await Assert.That(restored.Input.LocalEcho).IsFalse(); + await Assert.That(restored.Input.KeepDrafts).IsTrue(); + await Assert.That(restored.Input.Dictionary).IsEqualTo("en_GB"); + } + + [Test] + public async Task TextAndInputPreferences_DefaultWhenAConfigPredatesThem() + { + // Purely additive schema: an older file simply has no "text"/"input" object. + var restored = ConfigurationStore.Deserialize("""{"version":2,"worlds":[],"triggerSets":[]}"""); + + await Assert.That(restored.Text.UnderlineHyperlinks).IsTrue(); + await Assert.That(restored.Text.AmbiguousWidth).IsEqualTo("narrow"); + await Assert.That(restored.Input.NewlineKey).IsEqualTo("Shift+Enter"); + await Assert.That(restored.Input.CheckSpelling).IsTrue(); + } + + [Test] + public async Task AliasCaseSensitivity_IsSettableAndDropsTheCachedRegex() + { + var alias = new Alias { Name = "k", Pattern = "^k$", Substitution = "kill" }; + await Assert.That(alias.Regex.IsMatch("K")).IsTrue(); + + alias.CaseSensitive = true; + + await Assert.That(alias.Regex.IsMatch("K")).IsFalse(); + await Assert.That(alias.Regex.IsMatch("k")).IsTrue(); + } + [Test] public async Task ColorConverter_RoundTripsAllKinds() { diff --git a/tests/SharpMUTerm.Tui.Tests/KeypadScreenRendererTests.cs b/tests/SharpMUTerm.Tui.Tests/KeypadScreenRendererTests.cs index 882a64d7..43ea9bbd 100644 --- a/tests/SharpMUTerm.Tui.Tests/KeypadScreenRendererTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/KeypadScreenRendererTests.cs @@ -39,7 +39,7 @@ public async Task NumpadColumn_ColumnsAlignRegardlessOfBoundCommandLength() // Skip(1): the first entry is the "NUMPAD" caption, not a key row. var offsets = KeypadScreenRenderer.NumpadColumn(macros).Skip(1).Select(CellOffsets).ToList(); - await Assert.That(offsets).HasCount().EqualTo(3); + await Assert.That(offsets).Count().IsEqualTo(3); await Assert.That(offsets[1]).IsEqualTo(offsets[0]); await Assert.That(offsets[2]).IsEqualTo(offsets[0]); } diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenCursorTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenCursorTests.cs new file mode 100644 index 00000000..7704d295 --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/ScreenCursorTests.cs @@ -0,0 +1,196 @@ +using SharpMUTerm.Core.Automation; +using SharpMUTerm.Core.Configuration; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// The cursor bar the screens draw under the keyboard. A screen's model can be perfectly navigable +/// and still be unusable if nothing shows where the cursor is, so each screen's list is asserted to +/// paint the focused row — and only that row, in the focused pane. +/// +public class ScreenCursorTests +{ + /// The background the focused row is painted with (see ). + private const string Bar = "[on #2e3950]"; + + private static List Sets() => new() + { + new TriggerSet + { + Name = "Comms", + Triggers = new List + { + new() { Name = "Tell", Pattern = "tells you", Actions = new TriggerActions() }, + new() { Name = "Spam", Pattern = "guild", Actions = new TriggerActions() }, + }, + Aliases = new List + { + new() { Name = "k", Pattern = "^k$", Substitution = "kill" }, + new() { Name = "s", Pattern = "^s$", Substitution = "say" }, + }, + Macros = new List + { + new() { Name = "look", Key = "Num5", Command = "look" }, + new() { Name = "flee", Key = "Num1", Command = "flee" }, + }, + Timers = new List + { + new() { Name = "ping", IntervalSeconds = 30, Command = "look" }, + new() { Name = "tick", IntervalSeconds = 60, Command = "score" }, + }, + }, + }; + + private static int Barred(IEnumerable lines) => lines.Count(l => l.Contains(Bar, StringComparison.Ordinal)); + + [Test] + public async Task NoFocus_DrawsNoCursorBarAtAll() + { + var sets = Sets(); + + await Assert.That(Barred(TriggersScreenRenderer.RulesColumn(sets, 0))).IsEqualTo(0); + await Assert.That(Barred(AliasesScreenRenderer.ListColumn(sets, 0))).IsEqualTo(0); + await Assert.That(Barred(TimersScreenRenderer.ListColumn(sets, 0))).IsEqualTo(0); + await Assert.That(Barred(KeypadScreenRenderer.HotkeysColumn(sets[0].Macros))).IsEqualTo(0); + } + + [Test] + public async Task Triggers_BarsTheFocusedRuleAndNothingElse() + { + var lines = TriggersScreenRenderer.RulesColumn(Sets(), 1, new ScreenFocus(0, 1)); + + await Assert.That(Barred(lines)).IsEqualTo(1); + await Assert.That(lines.Single(l => l.Contains(Bar, StringComparison.Ordinal))).Contains("Spam"); + } + + [Test] + public async Task Triggers_EditorPaneBarsItsOwnRow_AndTheRuleListStaysUnbarred() + { + var sets = Sets(); + var editor = TriggersScreenRenderer.EditorColumn(sets, 0, Array.Empty(), new ScreenFocus(1, 1)); + var rules = TriggersScreenRenderer.RulesColumn(sets, 0, new ScreenFocus(1, 1)); + + await Assert.That(Barred(rules)).IsEqualTo(0); + await Assert.That(Barred(editor)).IsEqualTo(1); + await Assert.That(editor.Single(l => l.Contains(Bar, StringComparison.Ordinal))).Contains("stop processing"); + } + + [Test] + public async Task Aliases_BarsTheFocusedAlias_AndTheEditorsCaseRow() + { + var sets = Sets(); + + var list = AliasesScreenRenderer.ListColumn(sets, 1, new ScreenFocus(0, 1)); + await Assert.That(list.Single(l => l.Contains(Bar, StringComparison.Ordinal))).Contains("[bold]s[/]"); + + var editor = AliasesScreenRenderer.EditorColumn(sets, 1, new ScreenFocus(1, 0)); + await Assert.That(editor.Single(l => l.Contains(Bar, StringComparison.Ordinal))).Contains("case sensitive"); + } + + [Test] + public async Task Timers_BarsTheFocusedTimer_AndTheEditorsOneShotRow() + { + var sets = Sets(); + + var list = TimersScreenRenderer.ListColumn(sets, 0, new ScreenFocus(0, 0)); + await Assert.That(list.Single(l => l.Contains(Bar, StringComparison.Ordinal))).Contains("ping"); + + var editor = TimersScreenRenderer.EditorColumn(sets, 0, new ScreenFocus(1, 0)); + await Assert.That(editor.Single(l => l.Contains(Bar, StringComparison.Ordinal))).Contains("one-shot"); + } + + [Test] + public async Task Keypad_BarsTheFocusedBinding() + { + var lines = KeypadScreenRenderer.HotkeysColumn(Sets()[0].Macros, new ScreenFocus(0, 1)); + + await Assert.That(Barred(lines)).IsEqualTo(1); + await Assert.That(lines.Single(l => l.Contains(Bar, StringComparison.Ordinal))).Contains("Num1"); + } + + [Test] + public async Task Options_BarsTheFocusedOptionAndNeverASectionHeader() + { + // Navigable row 3 is "emoji substitution" — the two section headers and the spacer are skipped. + var screen = OptionsScreenRenderer.TextAnsiScreen(); + var lines = OptionsScreenRenderer.BodyColumn(screen.Rows, new ScreenFocus(0, 3)); + + await Assert.That(Barred(lines)).IsEqualTo(1); + await Assert.That(lines.Single(l => l.Contains(Bar, StringComparison.Ordinal))).Contains("emoji substitution"); + } + + [Test] + public async Task Worlds_BarsTheFocusedWorld_Character_AndTriggerSetInTheirOwnPanes() + { + var worlds = new List + { + new() + { + Name = "Aardwolf", + Host = "aardmud.org", + Characters = new List { new() { Name = "Kaz" }, new() { Name = "Mira" } }, + }, + new() { Name = "Second", Host = "example.org" }, + }; + var sets = Sets(); + var accent = WorldsScreenRenderer.AccentFor(worlds, 0); + + var onWorld = WorldsScreenRenderer.WorldsColumn(worlds, 0, new ScreenFocus(0, 1)); + await Assert.That(onWorld.Single(l => l.Contains(Bar, StringComparison.Ordinal))).Contains("Second"); + + var onCharacter = WorldsScreenRenderer.DetailColumn(worlds, sets, 0, 1, accent, new ScreenFocus(1, 1)); + await Assert.That(onCharacter.Single(l => l.Contains(Bar, StringComparison.Ordinal))).Contains("Mira"); + + var onSet = WorldsScreenRenderer.TriggersColumn(worlds[0].Characters[0], sets, accent, new ScreenFocus(2, 0)); + await Assert.That(onSet.Single(l => l.Contains(Bar, StringComparison.Ordinal))).Contains("Comms"); + } + + [Test] + public async Task Worlds_TriggerSetBarsAreAllTheSameWidthSoTheColumnDoesNotShift() + { + var character = new CharacterDefinition { Name = "Kaz" }; + var sets = new List + { + new() { Name = "A", Description = "short" }, + new() { Name = "Longer name", Description = "a much longer description" }, + }; + var widths = new List(); + for (var i = 0; i < sets.Count; i++) + { + var row = WorldsScreenRenderer.TriggersColumn(character, sets, "#00f5b7", new ScreenFocus(2, i)) + .Single(l => l.Contains(Bar, StringComparison.Ordinal)); + widths.Add(MarkupText.VisibleLength(row)); + } + + await Assert.That(widths[0]).IsEqualTo(widths[1]); + } + + [Test] + public async Task HeaderHints_AdvertiseOnlyTheKeysTheScreensImplement() + { + await Assert.That(TriggersScreenRenderer.HeaderLine(0)).Contains(ScreenChrome.ListHints); + await Assert.That(AliasesScreenRenderer.HeaderLine(0)).Contains(ScreenChrome.ListHints); + await Assert.That(TimersScreenRenderer.HeaderLine(0)).Contains(ScreenChrome.ListHints); + await Assert.That(WorldsScreenRenderer.HeaderLine(0)).Contains(ScreenChrome.ListHints); + await Assert.That(KeypadScreenRenderer.HeaderLine(0)).Contains(ScreenChrome.SingleListHints); + await Assert.That(OptionsScreenRenderer.HeaderLine("Logging", "F9", 0)) + .Contains(ScreenChrome.SingleListHints); + + // Nothing edits a field yet, so no screen may claim ⏎ opens an editor. + foreach (var header in new[] + { + TriggersScreenRenderer.HeaderLine(0), + AliasesScreenRenderer.HeaderLine(0), + TimersScreenRenderer.HeaderLine(0), + WorldsScreenRenderer.HeaderLine(0), + KeypadScreenRenderer.HeaderLine(0), + OptionsScreenRenderer.HeaderLine("Logging", "F9", 0), + }) + { + await Assert.That(header).DoesNotContain("⏎ edit"); + await Assert.That(header).DoesNotContain("⏎ rebind"); + await Assert.That(header).DoesNotContain("⏎ change"); + } + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenEditsTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenEditsTests.cs new file mode 100644 index 00000000..2eade122 --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/ScreenEditsTests.cs @@ -0,0 +1,97 @@ +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +public class ScreenEditsTests +{ + /// A stand-in for the config a checkbox writes to. + private sealed class Cell + { + public bool Value { get; set; } + + public ScreenToggle Toggle => ScreenToggle.Bind(() => Value, v => Value = v); + } + + [Test] + public async Task Apply_FlipsTheValueAndMarksTheScreenDirty() + { + var cell = new Cell(); + var edits = new ScreenEdits(); + + edits.Apply(cell.Toggle); + + await Assert.That(cell.Value).IsTrue(); + await Assert.That(edits.IsDirty).IsTrue(); + await Assert.That(edits.Count).IsEqualTo(1); + } + + [Test] + public async Task Revert_PutsEveryChangeBackAndClearsTheLog() + { + var a = new Cell { Value = true }; + var b = new Cell(); + var edits = new ScreenEdits(); + + edits.Apply(a.Toggle); + edits.Apply(b.Toggle); + edits.Revert(); + + await Assert.That(a.Value).IsTrue(); + await Assert.That(b.Value).IsFalse(); + await Assert.That(edits.IsDirty).IsFalse(); + } + + [Test] + public async Task Revert_UnwindsRepeatedEditsToTheSameRow() + { + var cell = new Cell { Value = true }; + var edits = new ScreenEdits(); + + edits.Apply(cell.Toggle); + edits.Apply(cell.Toggle); + edits.Apply(cell.Toggle); + await Assert.That(cell.Value).IsFalse(); + + edits.Revert(); + + await Assert.That(cell.Value).IsTrue(); + } + + [Test] + public async Task Commit_KeepsTheChangesAndLeavesNothingToUndo() + { + var cell = new Cell(); + var edits = new ScreenEdits(); + + edits.Apply(cell.Toggle); + edits.Commit(); + edits.Revert(); + + await Assert.That(cell.Value).IsTrue(); + await Assert.That(edits.IsDirty).IsFalse(); + } + + [Test] + public async Task Revert_RestoresWhateverTheSnapshotCaptured_NotJustABoolean() + { + // The F9 "auto-start" pattern: the checkbox is a projection of a richer value, so its snapshot + // has to restore that value rather than the boolean it was displayed as. + var format = "Html"; + var toggle = new ScreenToggle( + () => format != "None", + () => format = format == "None" ? "Plain" : "None", + () => + { + var previous = format; + return () => format = previous; + }); + + var edits = new ScreenEdits(); + edits.Apply(toggle); + await Assert.That(format).IsEqualTo("None"); + + edits.Revert(); + + await Assert.That(format).IsEqualTo("Html"); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs new file mode 100644 index 00000000..b31e0a92 --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs @@ -0,0 +1,260 @@ +using SharpMUTerm.Core.Automation; +using SharpMUTerm.Core.Configuration; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// What each settings screen actually offers the keyboard: how many panes it has, how many rows each +/// pane holds, and which config field the checkbox on a row writes to. These are the promises the +/// header hints make, so they are asserted per screen rather than only through the shared session. +/// +public class ScreenModelTests +{ + private static List Sets() => new() + { + new TriggerSet + { + Name = "Comms", + Description = "chat routing", + Triggers = new List + { + new() { Name = "Tell", Pattern = "tells you", Enabled = true, Actions = new TriggerActions() }, + new() { Name = "Spam", Pattern = "guild", Enabled = false, Actions = new TriggerActions { Gag = true } }, + }, + Aliases = new List { new() { Name = "k", Pattern = "^k$", Substitution = "kill" } }, + Macros = new List { new() { Name = "look", Key = "Num5", Command = "look" } }, + Timers = new List + { + new() { Name = "ping", IntervalSeconds = 30, Command = "look", Enabled = true }, + }, + }, + }; + + private static List Worlds() => new() + { + new WorldDefinition + { + Name = "Aardwolf", + Host = "aardmud.org", + Characters = new List + { + new() { Name = "Kaz", AutoLogin = false, TriggerSets = new List { "Comms" } }, + new() { Name = "Mira" }, + }, + }, + new WorldDefinition { Name = "Empty", Host = "example.org" }, + }; + + [Test] + public async Task Triggers_HasARuleListAndTheSelectedRulesToggles() + { + var sets = Sets(); + var model = TriggersScreenRenderer.Model(sets, selectedTrigger: 0); + + await Assert.That(model.PaneCount).IsEqualTo(2); + await Assert.That(model.Sizes[0]).IsEqualTo(2); + await Assert.That(model.Sizes[1]).IsEqualTo(2); + + model.ToggleAt(0, 1)!.Value.Flip(); + await Assert.That(sets[0].Triggers[1].Enabled).IsTrue(); + + model.ToggleAt(1, 0)!.Value.Flip(); + await Assert.That(sets[0].Triggers[0].Actions.Gag).IsTrue(); + + model.ToggleAt(1, 1)!.Value.Flip(); + await Assert.That(sets[0].Triggers[0].StopProcessing).IsTrue(); + } + + [Test] + public async Task Triggers_EditorPaneIsEmptyWhenNothingIsSelected() + { + var model = TriggersScreenRenderer.Model(Sets(), selectedTrigger: -1); + + await Assert.That(model.Sizes[1]).IsEqualTo(0); + } + + [Test] + public async Task Aliases_ListTogglesEnabled_AndTheEditorTogglesCaseSensitivity() + { + var sets = Sets(); + var model = AliasesScreenRenderer.Model(sets, selected: 0); + + await Assert.That(model.PaneCount).IsEqualTo(2); + await Assert.That(model.Sizes).IsEquivalentTo(new[] { 1, 1 }); + + model.ToggleAt(0, 0)!.Value.Flip(); + await Assert.That(sets[0].Aliases[0].Enabled).IsFalse(); + + model.ToggleAt(1, 0)!.Value.Flip(); + await Assert.That(sets[0].Aliases[0].CaseSensitive).IsTrue(); + } + + [Test] + public async Task Aliases_FlippingCaseSensitivityRecompilesTheMatcher() + { + var sets = Sets(); + var alias = sets[0].Aliases[0]; + await Assert.That(alias.Regex.IsMatch("K")).IsTrue(); // case-insensitive by default + + AliasesScreenRenderer.Model(sets, selected: 0).ToggleAt(1, 0)!.Value.Flip(); + + await Assert.That(alias.Regex.IsMatch("K")).IsFalse(); + await Assert.That(alias.Regex.IsMatch("k")).IsTrue(); + } + + [Test] + public async Task Timers_ListTogglesEnabled_AndTheEditorTogglesOneShotThenEnabled() + { + var sets = Sets(); + var model = TimersScreenRenderer.Model(sets, selected: 0); + + await Assert.That(model.Sizes).IsEquivalentTo(new[] { 1, 2 }); + + model.ToggleAt(1, 0)!.Value.Flip(); + await Assert.That(sets[0].Timers[0].OneShot).IsTrue(); + + model.ToggleAt(1, 1)!.Value.Flip(); + await Assert.That(sets[0].Timers[0].Enabled).IsFalse(); + } + + [Test] + public async Task Keypad_IsOnePaneOfMacroToggles() + { + var macros = Sets()[0].Macros; + var model = KeypadScreenRenderer.Model(macros); + + await Assert.That(model.PaneCount).IsEqualTo(1); + await Assert.That(model.Sizes[0]).IsEqualTo(1); + + model.ToggleAt(0, 0)!.Value.Flip(); + await Assert.That(macros[0].Enabled).IsFalse(); + } + + [Test] + public async Task Worlds_HasWorldsThenCharactersThenTriggerSets() + { + var worlds = Worlds(); + var sets = Sets(); + var model = WorldsScreenRenderer.Model(worlds, sets, selectedWorld: 0, selectedCharacter: 0); + + await Assert.That(model.PaneCount).IsEqualTo(3); + await Assert.That(model.Sizes).IsEquivalentTo(new[] { 2, 2, 1 }); + + // Worlds are selection only — there is no checkbox on a world row. + await Assert.That(model.ToggleAt(0, 0)).IsNull(); + + model.ToggleAt(1, 1)!.Value.Flip(); + await Assert.That(worlds[0].Characters[1].AutoLogin).IsTrue(); + } + + [Test] + public async Task Worlds_TriggerSetRowsAssignAndUnassignByName() + { + var worlds = Worlds(); + var sets = Sets(); + var character = worlds[0].Characters[0]; + + var assigned = WorldsScreenRenderer.Model(worlds, sets, 0, 0).ToggleAt(2, 0)!.Value; + await Assert.That(assigned.Get()).IsTrue(); + + assigned.Flip(); + await Assert.That(character.TriggerSets).IsEmpty(); + + WorldsScreenRenderer.Model(worlds, sets, 0, 0).ToggleAt(2, 0)!.Value.Flip(); + await Assert.That(character.TriggerSets).IsEquivalentTo(new[] { "Comms" }); + } + + [Test] + public async Task Worlds_UnassigningATriggerSetRestoresTheCharactersOwnOrderOnUndo() + { + var worlds = Worlds(); + var sets = Sets(); + sets.Add(new TriggerSet { Name = "Combat" }); + var character = worlds[0].Characters[0]; + character.TriggerSets.Insert(0, "Combat"); + + var edits = new ScreenEdits(); + edits.Apply(WorldsScreenRenderer.Model(worlds, sets, 0, 0).ToggleAt(2, 0)!.Value); + await Assert.That(character.TriggerSets).IsEquivalentTo(new[] { "Combat" }); + + edits.Revert(); + + // Order decides which set wins a conflict, so it has to come back as it was — not "Comms" last. + await Assert.That(character.TriggerSets[0]).IsEqualTo("Combat"); + await Assert.That(character.TriggerSets[1]).IsEqualTo("Comms"); + } + + [Test] + public async Task Worlds_CharacterAndTriggerSetPanesAreEmptyForAWorldWithNoCharacters() + { + var model = WorldsScreenRenderer.Model(Worlds(), Sets(), selectedWorld: 1, selectedCharacter: 0); + + await Assert.That(model.Sizes).IsEquivalentTo(new[] { 2, 0, 0 }); + } + + [Test] + public async Task Options_NavigableRowsSkipSectionHeadersAndSpacers() + { + var screen = OptionsScreenRenderer.TextAnsiScreen(); + var model = OptionsScreenRenderer.Model(screen); + + // 8 display rows: 2 section headers + 1 spacer + 5 options. + await Assert.That(screen.Rows.Count).IsEqualTo(8); + await Assert.That(model.PaneCount).IsEqualTo(1); + await Assert.That(model.Sizes[0]).IsEqualTo(5); + } + + [Test] + public async Task Options_TextAnsiRowsWriteBackToTheTextSettings() + { + var text = new TextSettings(); + var model = OptionsScreenRenderer.Model(OptionsScreenRenderer.TextAnsiScreen(text)); + + model.ToggleAt(0, 0)!.Value.Flip(); + await Assert.That(text.StripIncomingColour).IsTrue(); + + model.ToggleAt(0, 2)!.Value.Flip(); + await Assert.That(text.UnderlineHyperlinks).IsFalse(); + + // "ambiguous width" is a value row: reachable, but nothing to press yet. + await Assert.That(model.ToggleAt(0, 4)).IsNull(); + } + + [Test] + public async Task Options_InputRowsWriteBackToTheInputSettings() + { + var input = new InputSettings(); + var model = OptionsScreenRenderer.Model(OptionsScreenRenderer.InputSpellcheckScreen(input)); + + model.ToggleAt(0, 0)!.Value.Flip(); + await Assert.That(input.LocalEcho).IsFalse(); + + model.ToggleAt(0, 3)!.Value.Flip(); + await Assert.That(input.CheckSpelling).IsFalse(); + } + + [Test] + public async Task Options_LoggingAutoStartTogglesTheFormat_AndUndoRestoresTheOriginalOne() + { + var logging = new LoggingSettings { Format = LogFormat.Html }; + var edits = new ScreenEdits(); + + edits.Apply(OptionsScreenRenderer.Model(OptionsScreenRenderer.LoggingScreen(logging)).ToggleAt(0, 2)!.Value); + await Assert.That(logging.Format).IsEqualTo(LogFormat.None); + + edits.Revert(); + + await Assert.That(logging.Format).IsEqualTo(LogFormat.Html); + } + + [Test] + public async Task Options_LoggingAutoStartTurnsOnAsPlainWhenNothingWasChosen() + { + var logging = new LoggingSettings { Format = LogFormat.None }; + + OptionsScreenRenderer.Model(OptionsScreenRenderer.LoggingScreen(logging)).ToggleAt(0, 2)!.Value.Flip(); + + await Assert.That(logging.Format).IsEqualTo(LogFormat.Plain); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenSelectionTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenSelectionTests.cs new file mode 100644 index 00000000..18b788f6 --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/ScreenSelectionTests.cs @@ -0,0 +1,175 @@ +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +public class ScreenSelectionTests +{ + private static int[] Sizes(params int[] sizes) => sizes; + + [Test] + public async Task New_StartsOnFirstPaneFirstRow() + { + var selection = new ScreenSelection(3); + + await Assert.That(selection.PaneCount).IsEqualTo(3); + await Assert.That(selection.Pane).IsEqualTo(0); + await Assert.That(selection.Index).IsEqualTo(0); + } + + [Test] + public async Task Move_StepsWithinThePane() + { + var selection = new ScreenSelection(1); + + await Assert.That(selection.Move(1, Sizes(3))).IsTrue(); + await Assert.That(selection.Index).IsEqualTo(1); + await Assert.That(selection.Move(1, Sizes(3))).IsTrue(); + await Assert.That(selection.Index).IsEqualTo(2); + } + + [Test] + public async Task Move_ClampsAtBothEndsWithoutWrapping() + { + var selection = new ScreenSelection(1); + + await Assert.That(selection.Move(-1, Sizes(3))).IsFalse(); + await Assert.That(selection.Index).IsEqualTo(0); + + selection.Move(1, Sizes(3)); + selection.Move(1, Sizes(3)); + await Assert.That(selection.Move(1, Sizes(3))).IsFalse(); + await Assert.That(selection.Index).IsEqualTo(2); + } + + [Test] + public async Task Move_OnAnEmptyPaneDoesNothing() + { + var selection = new ScreenSelection(1); + + await Assert.That(selection.Move(1, Sizes(0))).IsFalse(); + await Assert.That(selection.Index).IsEqualTo(0); + await Assert.That(selection.HasSelection(Sizes(0))).IsFalse(); + } + + [Test] + public async Task NextPane_MovesForwardAndWrapsBackToTheFirst() + { + var selection = new ScreenSelection(3); + + await Assert.That(selection.NextPane(Sizes(2, 2, 2))).IsTrue(); + await Assert.That(selection.Pane).IsEqualTo(1); + selection.NextPane(Sizes(2, 2, 2)); + await Assert.That(selection.Pane).IsEqualTo(2); + selection.NextPane(Sizes(2, 2, 2)); + await Assert.That(selection.Pane).IsEqualTo(0); + } + + [Test] + public async Task NextPane_SkipsEmptyPanes() + { + var selection = new ScreenSelection(3); + + // Pane 1 has no rows (a world with no characters), so ⇥ lands on pane 2. + await Assert.That(selection.NextPane(Sizes(2, 0, 4))).IsTrue(); + await Assert.That(selection.Pane).IsEqualTo(2); + } + + [Test] + public async Task NextPane_ReturnsFalseWhenNoOtherPaneHasRows() + { + var selection = new ScreenSelection(3); + + await Assert.That(selection.NextPane(Sizes(2, 0, 0))).IsFalse(); + await Assert.That(selection.Pane).IsEqualTo(0); + } + + [Test] + public async Task PreviousPane_MovesBackwardAndWraps() + { + var selection = new ScreenSelection(3); + + await Assert.That(selection.PreviousPane(Sizes(1, 1, 1))).IsTrue(); + await Assert.That(selection.Pane).IsEqualTo(2); + selection.PreviousPane(Sizes(1, 1, 1)); + await Assert.That(selection.Pane).IsEqualTo(1); + } + + [Test] + public async Task EachPaneKeepsItsOwnCursorAcrossPaneSwitches() + { + var selection = new ScreenSelection(2); + + selection.Move(1, Sizes(5, 5)); + selection.Move(1, Sizes(5, 5)); + selection.NextPane(Sizes(5, 5)); + selection.Move(1, Sizes(5, 5)); + + await Assert.That(selection.Index).IsEqualTo(1); + await Assert.That(selection.CursorIn(0)).IsEqualTo(2); + + selection.PreviousPane(Sizes(5, 5)); + await Assert.That(selection.Index).IsEqualTo(2); + } + + [Test] + public async Task Seed_PlacesACursorWithoutMovingFocus() + { + var selection = new ScreenSelection(2); + selection.Seed(1, 3); + + await Assert.That(selection.Pane).IsEqualTo(0); + await Assert.That(selection.CursorIn(1)).IsEqualTo(3); + } + + [Test] + public async Task Seed_IgnoresPanesAndIndexesOutOfRange() + { + var selection = new ScreenSelection(2); + selection.Seed(9, 1); + selection.Seed(0, -1); + + await Assert.That(selection.CursorIn(0)).IsEqualTo(0); + await Assert.That(selection.CursorIn(9)).IsEqualTo(-1); + } + + [Test] + public async Task Clamp_PullsACursorBackWhenItsListShrinks() + { + var selection = new ScreenSelection(1); + selection.Seed(0, 7); + + selection.Clamp(Sizes(3)); + + await Assert.That(selection.Index).IsEqualTo(2); + } + + [Test] + public async Task Clamp_MovesFocusOffAPaneThatHasEmptied() + { + var selection = new ScreenSelection(2); + selection.NextPane(Sizes(2, 2)); + await Assert.That(selection.Pane).IsEqualTo(1); + + // The character list emptied under the cursor: focus falls back to the pane that still has rows. + selection.Clamp(Sizes(2, 0)); + + await Assert.That(selection.Pane).IsEqualTo(0); + } + + [Test] + public async Task Clamp_LeavesFocusAloneWhenNoPaneHasRows() + { + var selection = new ScreenSelection(2); + + selection.Clamp(Sizes(0, 0)); + + await Assert.That(selection.Pane).IsEqualTo(0); + await Assert.That(selection.HasSelection(Sizes(0, 0))).IsFalse(); + } + + [Test] + public void Constructor_RejectsAScreenWithNoPanes() + { + Assert.Throws(() => new ScreenSelection(0)); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/SettingsSessionTests.cs b/tests/SharpMUTerm.Tui.Tests/SettingsSessionTests.cs new file mode 100644 index 00000000..2e86ed2c --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/SettingsSessionTests.cs @@ -0,0 +1,145 @@ +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +public class SettingsSessionTests +{ + private static ConsoleKeyInfo Key(ConsoleKey key, ConsoleModifiers modifiers = default) => + new('\0', key, modifiers.HasFlag(ConsoleModifiers.Shift), false, false); + + /// A two-pane screen: a three-row list of checkboxes over a two-row editor. + private sealed class Scene + { + public bool[] List { get; } = new bool[3]; + + public bool[] Editor { get; } = new bool[2]; + + public SettingsSession Session() => new(_ => new ScreenModel( + ScreenModel.Toggles( + new[] { 0, 1, 2 }, i => List[i], (i, v) => List[i] = v), + ScreenModel.Toggles( + new[] { 0, 1 }, i => Editor[i], (i, v) => Editor[i] = v))); + } + + [Test] + public async Task PaneCount_ComesFromTheModel() + { + var session = new Scene().Session(); + + await Assert.That(session.Selection.PaneCount).IsEqualTo(2); + } + + [Test] + public async Task DownArrow_MovesTheCursorAndAsksForARedraw() + { + var session = new Scene().Session(); + + await Assert.That(session.Handle(Key(ConsoleKey.DownArrow))).IsEqualTo(ScreenAction.Redraw); + await Assert.That(session.Focus()).IsEqualTo(new ScreenFocus(0, 1)); + } + + [Test] + public async Task UpArrow_AtTheTopIsSwallowedWithoutARedraw() + { + var session = new Scene().Session(); + + await Assert.That(session.Handle(Key(ConsoleKey.UpArrow))).IsEqualTo(ScreenAction.Consumed); + await Assert.That(session.Focus()).IsEqualTo(new ScreenFocus(0, 0)); + } + + [Test] + public async Task Tab_MovesToTheEditorPane_AndShiftTabComesBack() + { + var session = new Scene().Session(); + + await Assert.That(session.Handle(Key(ConsoleKey.Tab))).IsEqualTo(ScreenAction.Redraw); + await Assert.That(session.Focus()).IsEqualTo(new ScreenFocus(1, 0)); + + session.Handle(Key(ConsoleKey.Tab, ConsoleModifiers.Shift)); + await Assert.That(session.Focus()).IsEqualTo(new ScreenFocus(0, 0)); + } + + [Test] + public async Task Space_FlipsTheCheckboxUnderTheCursor() + { + var scene = new Scene(); + var session = scene.Session(); + + session.Handle(Key(ConsoleKey.DownArrow)); + await Assert.That(session.Handle(Key(ConsoleKey.Spacebar))).IsEqualTo(ScreenAction.Redraw); + + await Assert.That(scene.List[1]).IsTrue(); + await Assert.That(scene.List[0]).IsFalse(); + await Assert.That(session.Edits.IsDirty).IsTrue(); + } + + [Test] + public async Task Space_OnARowWithNoCheckboxIsSwallowedAndChangesNothing() + { + var session = new SettingsSession(_ => new ScreenModel(ScreenModel.Stops(2))); + + await Assert.That(session.Handle(Key(ConsoleKey.Spacebar))).IsEqualTo(ScreenAction.Consumed); + await Assert.That(session.Edits.IsDirty).IsFalse(); + } + + [Test] + public async Task Enter_Saves_AndEscape_Cancels() + { + var session = new Scene().Session(); + + await Assert.That(session.Handle(Key(ConsoleKey.Enter))).IsEqualTo(ScreenAction.Save); + await Assert.That(session.Handle(Key(ConsoleKey.Escape))).IsEqualTo(ScreenAction.Cancel); + } + + [Test] + public async Task AnUnrelatedKeyIsLeftForTheFramework() + { + var session = new Scene().Session(); + + await Assert.That(session.Handle(Key(ConsoleKey.F1))).IsEqualTo(ScreenAction.None); + } + + [Test] + public async Task RevertingTheEditsUndoesEveryToggleTheScreenApplied() + { + var scene = new Scene(); + scene.List[0] = true; + var session = scene.Session(); + + session.Handle(Key(ConsoleKey.Spacebar)); + session.Handle(Key(ConsoleKey.Tab)); + session.Handle(Key(ConsoleKey.Spacebar)); + await Assert.That(scene.List[0]).IsFalse(); + await Assert.That(scene.Editor[0]).IsTrue(); + + session.Edits.Revert(); + + await Assert.That(scene.List[0]).IsTrue(); + await Assert.That(scene.Editor[0]).IsFalse(); + } + + [Test] + public async Task Focus_IsNoneWhenTheScreenHasNoRowsAtAll() + { + var session = new SettingsSession(_ => new ScreenModel(Array.Empty())); + + await Assert.That(session.Focus()).IsEqualTo(ScreenFocus.None); + } + + [Test] + public async Task Focus_FollowsAPaneWhoseRowsAppearAfterTheCursorMoves() + { + // The second pane only exists once the first pane's cursor is off row 0 — the shape F5 has, + // where a world with no characters offers nothing to ⇥ into. + var selectionSizes = new[] { 2, 0 }; + var session = new SettingsSession(selection => new ScreenModel( + ScreenModel.Stops(selectionSizes[0]), + ScreenModel.Stops(selection.CursorIn(0) == 1 ? 3 : 0))); + + await Assert.That(session.Handle(Key(ConsoleKey.Tab))).IsEqualTo(ScreenAction.Consumed); + + session.Handle(Key(ConsoleKey.DownArrow)); + await Assert.That(session.Handle(Key(ConsoleKey.Tab))).IsEqualTo(ScreenAction.Redraw); + await Assert.That(session.Focus()).IsEqualTo(new ScreenFocus(1, 0)); + } +} From 823c78d5f985ab1ab9491d05eb279370a9b09189 Mon Sep 17 00:00:00 2001 From: Harry Cordewener Date: Tue, 28 Jul 2026 17:21:01 -0500 Subject: [PATCH 07/23] Wire mouse drag-to-split panes MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Backlog item 5. DropZones.Resolve existed in Core and was tested, but nothing in the TUI ever called it. Dragging a pane's tab onto another pane now splits or re-tabs it: drop within 25% of the left or right edge to split side by side, top or bottom to stack, or in the middle to move the tab into that pane. The wiring sits at the driver, not on a control, and that is forced by the framework: WindowEventDispatcher captures the pressed control and routes every later drag frame back to it, so a control-level handler would only ever see the source pane and never the one being dragged onto. Most of the logic is pure and tested -- the gesture state machine, flag decoding, hit-testing, preview geometry -- leaving the thinnest possible adapter over framework events. PaneDragEndToEndTests additionally drives real press/drag/release frames through the app on a headless driver, parameterised over all four edges, asserting both split direction and child ordering. Move mode's status bar has always advertised "←↑↓→ edge" with no arrow handling behind it, so only the tab-drop half was reachable and SplitWithWindow was never called from the TUI. Both paths now commit through one PaneDrop, so keyboard and mouse cannot drift. 649 tests pass, up from 574. Unverified until someone uses a real mouse: whether the terminal reports drags at all, and whether the preview keeps up at pointer speed. Co-Authored-By: Claude Opus 5 (1M context) --- CLAUDE.md | 2 +- docs/HANDOFF.md | 66 ++- src/SharpMUTerm.Core/Workspace/PaneDrop.cs | 69 +++ src/SharpMUTerm.Tui/PaneDragSurface.cs | 67 +++ src/SharpMUTerm.Tui/PaneDragTracker.cs | 279 ++++++++++++ src/SharpMUTerm.Tui/PaneDropRenderer.cs | 134 ++++++ src/SharpMUTerm.Tui/Program.cs | 1 + src/SharpMUTerm.Tui/SharpMUTermApp.cs | 358 +++++++++++++++- .../Workspace/PaneDropTests.cs | 126 ++++++ .../PaneDragEndToEndTests.cs | 242 +++++++++++ .../PaneDragSurfaceTests.cs | 98 +++++ .../PaneDragTrackerTests.cs | 403 ++++++++++++++++++ .../PaneDropRendererTests.cs | 157 +++++++ 13 files changed, 1982 insertions(+), 20 deletions(-) create mode 100644 src/SharpMUTerm.Core/Workspace/PaneDrop.cs create mode 100644 src/SharpMUTerm.Tui/PaneDragSurface.cs create mode 100644 src/SharpMUTerm.Tui/PaneDragTracker.cs create mode 100644 src/SharpMUTerm.Tui/PaneDropRenderer.cs create mode 100644 tests/SharpMUTerm.Core.Tests/Workspace/PaneDropTests.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/PaneDragEndToEndTests.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/PaneDragSurfaceTests.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/PaneDragTrackerTests.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/PaneDropRendererTests.cs diff --git a/CLAUDE.md b/CLAUDE.md index 46bbc162..be356017 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -32,7 +32,7 @@ fallbacks) for inline images/maps. ## Repository state **M1 delivered, plus substantial M2–M4 work.** `SharpMUTerm.slnx` builds all ten projects on -`net10.0`; the solution has **574 passing tests**. In place: +`net10.0`; the solution has **649 passing tests**. In place: - **Core** — `AnsiParser` (SGR 16/256/truecolor), styled-line + `ScrollbackBuffer` model, `TcpTransport` (TLS + IPv6), `TelnetSession` (wraps TelnetNegotiationCore **2.5.3**), diff --git a/docs/HANDOFF.md b/docs/HANDOFF.md index 6bc185d0..953d3d24 100644 --- a/docs/HANDOFF.md +++ b/docs/HANDOFF.md @@ -4,8 +4,10 @@ Context for whoever (human or agent) picks up this work next. - **Repository:** `SharpMUSH/SharpMUTerm` - **Start from:** a fresh branch off `main` -- **Tests:** 574 across the solution (313 Core / 57 Graphics / 42 Scripting / - 15 Web / 147 Tui), all green; `dotnet build SharpMUTerm.slnx` clean (0 warnings) +- **Tests:** 649 across the solution (325 Core / 57 Graphics / 42 Scripting / + 15 Web / 210 Tui), all green; `dotnet build SharpMUTerm.slnx` clean (0 warnings + from this repo; building against a local SharpConsoleUI clone surfaces 2 upstream + NuGet advisory warnings for AngleSharp, which are the framework's, not ours) --- @@ -87,11 +89,59 @@ prompt painted with the same background via `PromptMarkup`, width pinned via `SyncInputWidth`). Verified in headless snapshots; **confirm it holds on a real terminal** across resizes, since the width is pinned imperatively. -### 5. Mouse drag-to-split panes +### 5. Mouse drag-to-split panes — wired; needs a real mouse to confirm -The pane split tree supports keyboard "move mode" (the keyboard equivalent of -drag-to-split). True mouse drag-and-drop between panes (`DropZones.Resolve` exists -in Core and is tested) is not wired into the TUI and is unverifiable headlessly. +**Status:** implemented and covered headlessly end to end, but **nobody has done it +with an actual mouse yet.** Drag a pane's tab strip onto another pane: the middle +adds it as a tab, within 25% of an edge splits there. The drag paints a preview — +every pane dims to its name and the hovered one lights the zone the drop would +claim — and the status line reads `DRAG → split pane 2 left`. + +How it fits together: + +- **`PaneDragTracker`** (Tui, pure) — the gesture state machine. SharpConsoleUI + tracks no drag state for controls beyond mouse capture, so press/motion/release + are stitched together here. Also decodes `MouseFlags`: SGR reports a drag as + `Button1Pressed + ReportMousePosition` *without* `Button1Dragged`, so treating a + pressed bit as a fresh press would restart the gesture on every frame. +- **`PaneDragSurface`** (Tui, pure) — pane rectangles + each pane's active window, + **frozen at press**. It has to be frozen: painting the preview tears the pane + area down, so live controls are a moving target mid-drag. +- **`PaneDropRenderer`** (Tui, pure) — the preview markup. Its band previews *where + the new pane lands*; near a corner that is deliberately not the same set of cells + `DropZones` would resolve to that edge (it picks whichever edge is nearest). +- **`PaneDrop`** (Core, pure) — the one commit path, shared with move mode: null + edge → `MoveWindowToPane`, an edge → `SplitWithWindow`, and no-ops rejected. +- **`SharpMUTermApp.OnDriverMouseEvent`** — the only untested part, deliberately + thin. It subscribes to `_system.ConsoleDriver.MouseEvent`, **not** to a control: + the framework captures the pressed control and routes every later frame to it, so + a control-level handler would only ever see the *source* pane. `PaneSnapshot()` + reads pane rectangles back out of `Window.GetLayoutNode(...).AbsoluteBounds` + (window-content space) and adds the window origin + inset. + +Gotchas found doing it: + +- **Only the tab strip is a drag handle** (a pane's top row). Body presses belong + to the content — text selection, link clicks. +- **Esc cancels a drag.** If a terminal loses the button-up, the preview would + otherwise sit over the panes forever. +- `_paneTabs` is read from the driver's **input thread** and written on the UI + thread, so it is under `_paneTabsLock`. Enumerating it during a rebuild throws. +- The `drag` snapshot view drives a **real** press+drag through + `HeadlessConsoleDriver.SimulateMouseEvent`; nothing about that frame is faked. + It renders a frame first (layout is only arranged by a render, so control bounds + don't exist before one) and then re-initialises the driver, because the headless + driver ignores `InvalidateFrontBuffer` and the closing render would otherwise + emit only the changed cells. + +**Not verified:** that a real terminal's mouse escape sequences arrive as these +frames. That path is SharpConsoleUI's `NetConsoleDriver` (it enables modes +1000/1006/1002/1003 unconditionally at startup) plus `AnsiInputParser`; it was read, +not run. Everything downstream of `IConsoleDriver.MouseEvent` is tested. + +Also completed here: move mode's **arrow keys** now pick an edge. The prompt has +always advertised `←↑↓→ edge`, but nothing handled them — only the tab-drop half +was reachable. Both routes now commit through `PaneDrop`. ### 6. CodeRabbit nitpicks intentionally **not** done (don't "fix" these) @@ -139,8 +189,8 @@ Things that will waste your time if you don't know them. ``` - **Snapshot view names:** `worlds`/`settings`, `triggers`, `aliases`, `timers`, `keypad`, `textansi`, `input`, `logging`, `freeze`, `spawn`, `split`, `move`, - `history`, `menu`, `menu-split`, plus the default (no `--view`) workspace. Extra - state toggles: `collapsed`, `prefix`, `timestamps`. + `drag`, `history`, `menu`, `menu-split`, plus the default (no `--view`) workspace. + Extra state toggles: `collapsed`, `prefix`, `timestamps`. - **Send the user the `.svg`** — they view it fine. Do **not** rely on your own SVG→PNG for pixel checks near the bottom (see next point). - **SVG→PNG clipping trap:** Chromium clips the bottom of a bare `.svg` file diff --git a/src/SharpMUTerm.Core/Workspace/PaneDrop.cs b/src/SharpMUTerm.Core/Workspace/PaneDrop.cs new file mode 100644 index 00000000..c8dea496 --- /dev/null +++ b/src/SharpMUTerm.Core/Workspace/PaneDrop.cs @@ -0,0 +1,69 @@ +namespace SharpMUTerm.Core.Workspaces; + +/// +/// Applies the outcome of a drop resolved by : a central drop (no edge) adds +/// the window to the target pane as a tab, an edge drop splits the target pane and puts the window in +/// the new pane. This is the single commit path shared by the mouse drag and the keyboard move mode, +/// so both produce identical results. Pure and UI-agnostic; the caller supplies the already-resolved +/// target pane and edge. +/// +public static class PaneDrop +{ + /// + /// Commits a drop of onto . A null + /// adds it as a tab; otherwise the target pane is split toward that edge. + /// Returns false — changing nothing — when the target pane is gone or the drop would be a no-op: + /// a tab drop onto the window's own pane, or an edge drop out of a pane the window already has to + /// itself (which would merely rebuild the same single pane under a new id). + /// + public static bool Apply(WorkspaceLayout layout, string windowId, string targetPaneId, Edge? edge) + { + ArgumentNullException.ThrowIfNull(layout); + + var target = layout.FindPane(targetPaneId); + if (target is null) + { + return false; + } + + var source = layout.FindWindow(windowId); + if (source is null) + { + return false; + } + + if (ReferenceEquals(source, target) && (edge is null || source.Tabs.Count <= 1)) + { + return false; + } + + return edge is { } side + ? layout.SplitWithWindow(windowId, targetPaneId, side) + : layout.MoveWindowToPane(windowId, targetPaneId); + } + + /// + /// Resolves and commits a drop at a point inside in one step, using + /// to pick the edge (or a tab drop). Returns false when nothing changed. + /// + public static bool Apply( + WorkspaceLayout layout, + string windowId, + string targetPaneId, + PaneRect targetRect, + int pointX, + int pointY, + double edgeFraction = DropZones.DefaultEdgeFraction) + { + var edge = DropZones.Resolve( + targetRect.X, + targetRect.Y, + targetRect.Width, + targetRect.Height, + pointX, + pointY, + edgeFraction); + + return Apply(layout, windowId, targetPaneId, edge); + } +} diff --git a/src/SharpMUTerm.Tui/PaneDragSurface.cs b/src/SharpMUTerm.Tui/PaneDragSurface.cs new file mode 100644 index 00000000..d7b4f478 --- /dev/null +++ b/src/SharpMUTerm.Tui/PaneDragSurface.cs @@ -0,0 +1,67 @@ +using SharpMUTerm.Core.Workspaces; + +namespace SharpMUTerm.Tui; + +/// +/// A frozen picture of the pane area taken the moment a mouse drag starts: where each realised pane +/// sits in desktop cells, and which window each pane currently shows. Frozen deliberately — the pane +/// area is torn down and rebuilt to paint the drop preview, so resolving against live controls +/// mid-drag would chase a moving target. Pure and coordinate-only, so it is fully unit-testable. +/// +internal sealed class PaneDragSurface +{ + private readonly Dictionary _rects; + private readonly Dictionary _activeWindows; + + /// Creates a surface from pane rectangles and each pane's active window id. + public PaneDragSurface( + IReadOnlyDictionary rects, + IReadOnlyDictionary activeWindows) + { + ArgumentNullException.ThrowIfNull(rects); + ArgumentNullException.ThrowIfNull(activeWindows); + _rects = new Dictionary(rects, StringComparer.Ordinal); + _activeWindows = new Dictionary(activeWindows, StringComparer.Ordinal); + } + + /// The pane rectangles, keyed by pane id. + public IReadOnlyDictionary Rects => _rects; + + /// True when no pane was realised (nothing can be dragged). + public bool IsEmpty => _rects.Count == 0; + + /// + /// The pane containing the desktop cell, or null when the point falls outside every pane (the + /// rail, a divider, the header, the input band). Panes never overlap, so the first hit wins; + /// zero-area panes are skipped so a collapsed pane can't swallow a point. + /// + public string? PaneAt(int x, int y) + { + foreach (var (id, rect) in _rects) + { + if (rect.IsEmpty) + { + continue; + } + + if (x >= rect.X && x < rect.X + rect.Width && y >= rect.Y && y < rect.Y + rect.Height) + { + return id; + } + } + + return null; + } + + /// The rectangle of a pane, or null when it isn't in the snapshot. + public PaneRect? RectOf(string paneId) => _rects.TryGetValue(paneId, out var rect) ? rect : null; + + /// The window shown by a pane when the drag started, or null when the pane was empty. + public string? ActiveWindow(string paneId) => _activeWindows.GetValueOrDefault(paneId); + + /// + /// True when the cell sits on a pane's tab strip — its top row. Only the tab strip starts a pane + /// drag, so clicking, selecting text and following links in a pane's body are all left alone. + /// + public bool IsTabStrip(string paneId, int y) => RectOf(paneId) is { } rect && !rect.IsEmpty && y == rect.Y; +} diff --git a/src/SharpMUTerm.Tui/PaneDragTracker.cs b/src/SharpMUTerm.Tui/PaneDragTracker.cs new file mode 100644 index 00000000..44adecec --- /dev/null +++ b/src/SharpMUTerm.Tui/PaneDragTracker.cs @@ -0,0 +1,279 @@ +using SharpConsoleUI.Drivers; +using SharpMUTerm.Core.Workspaces; + +namespace SharpMUTerm.Tui; + +/// The kind of mouse frame a flag list represents, as far as a pane drag cares. +internal enum PaneDragInput +{ + /// Nothing this gesture reacts to (wheel, plain motion, other buttons). + Ignored, + + /// The primary button went down. + Press, + + /// The pointer moved with the primary button held. + Drag, + + /// The primary button came up. + Release, + + /// The secondary button went down — the conventional "abandon this drag". + Abort, +} + +/// What the adapter should do with the tracker's new state after a mouse frame. +internal enum PaneDragAction +{ + /// Nothing changed that the UI needs to show. + None, + + /// A drag just started: paint the drop preview. + Begin, + + /// The hovered pane or edge changed: repaint the drop preview. + Update, + + /// The drag ended on a target: apply the drop, then repaint. + Commit, + + /// The drag ended with nothing to apply: tear the preview down. + Cancel, +} + +/// The outcome of feeding one mouse frame to . +/// What the adapter should do. +/// The window being dragged, when a drag is or was live. +/// The pane under the pointer, or null when it is over no pane. +/// The edge to split toward, or null for a central (tab) drop. +internal readonly record struct PaneDragResult( + PaneDragAction Action, + string? WindowId, + string? TargetPaneId, + Edge? Edge); + +/// +/// Assembles a pane drag-and-drop gesture out of the individual mouse frames the console driver +/// reports — the framework tracks no drag state of its own beyond routing capture, so press, motion +/// and release have to be stitched together here. A press on a pane's tab strip arms the gesture; the +/// first motion away from that cell starts the drag; each subsequent motion resolves the pane under +/// the pointer and, through , which edge of it is targeted; release commits. +/// +/// Pure and framework-free apart from the enum it decodes, so the whole +/// gesture is unit-testable without a terminal. The app supplies the geometry snapshot and applies +/// the result via . +/// +internal sealed class PaneDragTracker +{ + private readonly double _edgeFraction; + + private PaneDragSurface? _surface; + private string? _windowId; + private string? _sourcePaneId; + private int _originX; + private int _originY; + private bool _armed; + private bool _dragging; + + /// Creates a tracker; is the drop-zone edge margin. + public PaneDragTracker(double edgeFraction = DropZones.DefaultEdgeFraction) => _edgeFraction = edgeFraction; + + /// True once the pointer has moved off the pressed cell with the button still down. + public bool IsDragging => _dragging; + + /// The window being dragged, or null when no drag is live. + public string? WindowId => _dragging ? _windowId : null; + + /// The pane the drag started from, or null when no drag is live. + public string? SourcePaneId => _dragging ? _sourcePaneId : null; + + /// The pane under the pointer, or null when it is over no pane (or no drag is live). + public string? TargetPaneId { get; private set; } + + /// The edge the current drop would split toward, or null for a tab drop. + public Edge? TargetEdge { get; private set; } + + /// The geometry frozen when the drag started, or null when no drag is live. + public PaneDragSurface? Surface => _dragging ? _surface : null; + + /// + /// Classifies a driver flag list. Motion with the button held arrives two ways depending on the + /// terminal's encoding — as , or (in SGR) as + /// together with + /// — so both are treated as a drag, and a press is only a press when neither motion bit is set. + /// + public static PaneDragInput Classify(IReadOnlyList flags) + { + if (flags is null || flags.Count == 0) + { + return PaneDragInput.Ignored; + } + + if (Has(flags, MouseFlags.Button1Released)) + { + return PaneDragInput.Release; + } + + var motion = Has(flags, MouseFlags.Button1Dragged) || Has(flags, MouseFlags.ReportMousePosition); + var down = Has(flags, MouseFlags.Button1Pressed); + + if (Has(flags, MouseFlags.Button1Dragged) || (down && motion)) + { + return PaneDragInput.Drag; + } + + if (down) + { + return PaneDragInput.Press; + } + + if (Has(flags, MouseFlags.Button3Pressed) || Has(flags, MouseFlags.Button3Clicked)) + { + return PaneDragInput.Abort; + } + + return PaneDragInput.Ignored; + } + + /// + /// Feeds one mouse frame, in desktop cells. is called only when a + /// press lands, so the layout is read back at most once per gesture. + /// + public PaneDragResult Handle(IReadOnlyList flags, int x, int y, Func snapshot) + { + ArgumentNullException.ThrowIfNull(snapshot); + + return Classify(flags) switch + { + PaneDragInput.Press => OnPress(x, y, snapshot), + PaneDragInput.Drag => OnDrag(x, y), + PaneDragInput.Release => OnRelease(x, y), + PaneDragInput.Abort => _dragging ? Finish(PaneDragAction.Cancel) : Idle(), + _ => Idle(), + }; + } + + /// Abandons any in-flight gesture without producing a result (e.g. on a layout change). + public void Reset() + { + _surface = null; + _windowId = null; + _sourcePaneId = null; + _armed = false; + _dragging = false; + TargetPaneId = null; + TargetEdge = null; + } + + private PaneDragResult OnPress(int x, int y, Func snapshot) + { + // A press always ends whatever came before: a drag can only be abandoned mid-flight if the + // release was swallowed, and re-pressing must not resume it. + var wasDragging = _dragging; + Reset(); + + var surface = snapshot(); + if (surface.IsEmpty || surface.PaneAt(x, y) is not { } paneId) + { + return wasDragging ? Cancelled() : Idle(); + } + + // Only the tab strip is a drag handle; a press in the body belongs to the pane's content. + if (!surface.IsTabStrip(paneId, y) || surface.ActiveWindow(paneId) is not { } windowId) + { + return wasDragging ? Cancelled() : Idle(); + } + + _surface = surface; + _sourcePaneId = paneId; + _windowId = windowId; + _originX = x; + _originY = y; + _armed = true; + return wasDragging ? Cancelled() : Idle(); + } + + private PaneDragResult OnDrag(int x, int y) + { + if (_armed && !_dragging) + { + // Stay a plain click until the pointer actually leaves the pressed cell, so clicking a tab + // still selects it (the framework's own handling) without flickering a drop preview. + if (x == _originX && y == _originY) + { + return Idle(); + } + + _dragging = true; + _armed = false; + Retarget(x, y); + return new PaneDragResult(PaneDragAction.Begin, _windowId, TargetPaneId, TargetEdge); + } + + if (!_dragging) + { + return Idle(); + } + + var previousPane = TargetPaneId; + var previousEdge = TargetEdge; + Retarget(x, y); + + return TargetPaneId == previousPane && TargetEdge == previousEdge + ? Idle() + : new PaneDragResult(PaneDragAction.Update, _windowId, TargetPaneId, TargetEdge); + } + + private PaneDragResult OnRelease(int x, int y) + { + if (!_dragging) + { + // A press that never moved: a plain click, already handled by the control under it. + Reset(); + return Idle(); + } + + Retarget(x, y); + return Finish(TargetPaneId is null ? PaneDragAction.Cancel : PaneDragAction.Commit); + } + + private PaneDragResult Finish(PaneDragAction action) + { + var result = new PaneDragResult(action, _windowId, TargetPaneId, TargetEdge); + Reset(); + return result; + } + + private void Retarget(int x, int y) + { + TargetPaneId = null; + TargetEdge = null; + + if (_surface?.PaneAt(x, y) is not { } paneId || _surface.RectOf(paneId) is not { } rect) + { + return; + } + + TargetPaneId = paneId; + TargetEdge = DropZones.Resolve(rect.X, rect.Y, rect.Width, rect.Height, x, y, _edgeFraction); + } + + private static PaneDragResult Idle() => new(PaneDragAction.None, null, null, null); + + private static PaneDragResult Cancelled() => new(PaneDragAction.Cancel, null, null, null); + + private static bool Has(IReadOnlyList flags, MouseFlags flag) + { + // Mirrors SharpConsoleUI's own MouseEventArgs.HasFlag: a driver may report each bit as its own + // list entry (X10) or combine several into one value (SGR), so test the bits, not equality. + for (var i = 0; i < flags.Count; i++) + { + if ((flags[i] & flag) == flag) + { + return true; + } + } + + return false; + } +} diff --git a/src/SharpMUTerm.Tui/PaneDropRenderer.cs b/src/SharpMUTerm.Tui/PaneDropRenderer.cs new file mode 100644 index 00000000..e67a9b0a --- /dev/null +++ b/src/SharpMUTerm.Tui/PaneDropRenderer.cs @@ -0,0 +1,134 @@ +using System.Text; +using SharpMUTerm.Core.Workspaces; + +namespace SharpMUTerm.Tui; + +/// +/// Paints a pane while a drag is in flight: every pane dims to its name, and the pane under the +/// pointer additionally fills in the drop zone the release would use — the 25% edge band for a split, +/// or a full outline for a central "add as a tab" drop — with the pending action spelled out across +/// its middle. Pure markup, so the preview is unit-testable without a terminal or a mouse. +/// +internal static class PaneDropRenderer +{ + /// The highlight for the live drop zone (the app's teal accent). + internal const string ZoneColor = "#00f5b7"; + + /// + /// Renders one pane of the drag preview to markup rows of + /// cells. is only meaningful when + /// is true: an edge splits, null adds a tab. + /// + internal static List Render( + string paneName, + string label, + int width, + int height, + bool hovered, + Edge? edge, + double edgeFraction = DropZones.DefaultEdgeFraction) + { + width = Math.Max(1, width); + height = Math.Max(1, height); + + var text = CenteredRow(hovered ? label : paneName, width); + var textRow = height / 2; + var lines = new List(height); + + for (var row = 0; row < height; row++) + { + var characters = row == textRow ? text : new string(' ', width); + lines.Add(RenderRow(characters, row, width, height, hovered, edge, edgeFraction)); + } + + return lines; + } + + /// + /// True when the cell falls inside the region the drop would claim: the band along the targeted + /// edge — roughly where the new pane will land, sized to the same fraction + /// splits at — or the pane's outline when the drop adds a tab instead. + /// It previews the result, not the set of points that resolve to this edge: near a corner + /// those differ, because picks whichever edge is nearest. + /// + internal static bool InZone( + int column, + int row, + int width, + int height, + Edge? edge, + double edgeFraction = DropZones.DefaultEdgeFraction) + { + if (edge is null) + { + // A tab drop consumes the whole pane; outlining it says "here", without hiding the label. + return column == 0 || column == width - 1 || row == 0 || row == height - 1; + } + + var bandWidth = Band(width, edgeFraction); + var bandHeight = Band(height, edgeFraction); + + return edge switch + { + Edge.Left => column < bandWidth, + Edge.Right => column >= width - bandWidth, + Edge.Top => row < bandHeight, + _ => row >= height - bandHeight, + }; + } + + /// The band thickness for a span, always at least one cell so it stays visible. + internal static int Band(int span, double edgeFraction) => + Math.Clamp((int)Math.Round(span * edgeFraction, MidpointRounding.AwayFromZero), 1, Math.Max(1, span)); + + private static string RenderRow( + string characters, + int row, + int width, + int height, + bool hovered, + Edge? edge, + double edgeFraction) + { + var builder = new StringBuilder(); + var open = false; + var highlighted = false; + + for (var column = 0; column < width; column++) + { + var zone = hovered && InZone(column, row, width, height, edge, edgeFraction); + if (!open || zone != highlighted) + { + if (open) + { + builder.Append("[/]"); + } + + builder.Append(zone ? $"[black on {ZoneColor}]" : "[dim]"); + open = true; + highlighted = zone; + } + + builder.Append(MarkupText.Escape(characters[column].ToString())); + } + + if (open) + { + builder.Append("[/]"); + } + + return builder.ToString(); + } + + /// Centres text in a row of spaces, truncating when it won't fit. + private static string CenteredRow(string text, int width) + { + if (text.Length > width) + { + text = width <= 1 ? text[..width] : text[..(width - 1)] + "…"; + } + + var left = (width - text.Length) / 2; + return new string(' ', left) + text + new string(' ', width - left - text.Length); + } +} diff --git a/src/SharpMUTerm.Tui/Program.cs b/src/SharpMUTerm.Tui/Program.cs index 09377fcb..91de351b 100644 --- a/src/SharpMUTerm.Tui/Program.cs +++ b/src/SharpMUTerm.Tui/Program.cs @@ -161,5 +161,6 @@ private static void PrintUsage() Console.WriteLine("With no host, the first configured world is used (if any)."); Console.WriteLine(); Console.WriteLine("In-app: Up/Down history · Ctrl+N next window · Ctrl+O next pane · Ctrl+W close · Ctrl+P palette · Ctrl+Q quit."); + Console.WriteLine("Panes: drag a pane's tab strip onto another pane — middle drops it as a tab, an edge splits there."); } } diff --git a/src/SharpMUTerm.Tui/SharpMUTermApp.cs b/src/SharpMUTerm.Tui/SharpMUTermApp.cs index 30e92ae7..8da90735 100644 --- a/src/SharpMUTerm.Tui/SharpMUTermApp.cs +++ b/src/SharpMUTerm.Tui/SharpMUTermApp.cs @@ -56,6 +56,13 @@ internal sealed class SharpMUTermApp : IAsyncDisposable private readonly MarkupControl _rail; private readonly MarkupControl _railSpacer = new(new List()); private readonly Dictionary _paneTabs = new(StringComparer.Ordinal); + + /// + /// Guards . Everything else touches it on the UI thread, but a mouse frame + /// arrives on the driver's input thread and has to read it to locate the panes — enumerating it + /// while a rebuild clears and refills it would throw. + /// + private readonly object _paneTabsLock = new(); private readonly PromptControl _input; private readonly GmcpStats _stats = new(); private readonly SharpMUTerm.Web.WebPageFetcher _fetcher = new(); @@ -82,8 +89,17 @@ internal sealed class SharpMUTermApp : IAsyncDisposable private bool _moveMode; private string? _moveWindowId; private string? _moveTargetPaneId; + private Edge? _moveEdge; private readonly Dictionary _moveLetters = new(StringComparer.Ordinal); + /// Assembles pane drag-and-drop out of the driver's raw mouse frames (see PaneDragTracker). + private readonly PaneDragTracker _paneDrag = new(); + + /// The pane the live mouse drag is hovering, and the edge it would split — null when idle. + private string? _dragTargetPaneId; + private Edge? _dragEdge; + private bool _dragActive; + /// The rail + pane-area row currently in the window (index 1). Swapped on layout change. private IWindowControl _workspaceRow = null!; @@ -186,6 +202,11 @@ public SharpMUTermApp(AppConfiguration config, TerminalCapabilities capabilities _system.RegisterGlobalShortcut(ConsoleModifiers.Control, ConsoleKey.B, ArmPrefix); _system.RegisterGlobalShortcut(ConsoleModifiers.Control, ConsoleKey.F, ToggleFreeze); _window.PreviewKeyPressed += OnWindowKey; + // Pane drag-and-drop listens at the driver, not at a control: SharpConsoleUI delivers mouse + // frames to the control that was pressed (it captures on Button1Pressed), so a control-level + // handler would only ever see the *source* pane. The driver stream carries every frame in + // desktop cells, which is exactly what a drag between panes needs. + _system.ConsoleDriver.MouseEvent += OnDriverMouseEvent; RegisterSettingsShortcuts(); _system.AddWindow(_window); } @@ -264,6 +285,33 @@ public string RenderSnapshot(string? view = null) PaneCommands.Apply(_workspace.Layout, PaneCommand.SplitRight); RebuildPaneArea(); EnterMoveMode(); + + // Drive the real key handler so the frame shows move mode as a user would leave it after + // picking a target pane and an edge: "b", then ←. + HandleMoveKey(new KeyPressedEventArgs(new ConsoleKeyInfo('b', ConsoleKey.B, false, false, false), false)); + HandleMoveKey(new KeyPressedEventArgs(new ConsoleKeyInfo('\0', ConsoleKey.LeftArrow, false, false, false), false)); + } + + // Mouse drag: split, lay the frame out so the panes have real bounds, then drive an actual + // press + drag through the headless driver's mouse event. Nothing here fakes the preview — + // it is whatever the pointer path produces, which is what makes this frame worth looking at. + if (string.Equals(view, "drag", StringComparison.OrdinalIgnoreCase)) + { + PaneCommands.Apply(_workspace.Layout, PaneCommand.SplitRight); + RebuildPaneArea(); + RenderFrame(); + SimulateSnapshotDrag(); + + // The frame above left the driver's front buffer populated, so the closing render would + // emit only the cells that changed. The headless driver ignores InvalidateFrontBuffer + // (the interface default is an empty body), but re-initialising it builds a fresh buffer, + // which together with a full repaint makes the closing render a whole frame again. + if (_system.ConsoleDriver is HeadlessConsoleDriver headlessDriver) + { + headlessDriver.Initialize(_system); + } + + _system.ForceFullRepaint(); } // History-recall state: seed a couple of sent commands, then recall the newest so the input @@ -299,13 +347,21 @@ public string RenderSnapshot(string? view = null) _settings.OpenForSnapshot(screen.Key, screen.Open()); } - // Render exactly one frame, synchronously, inline on this thread. ForceRender() performs a - // single render cycle (bypassing the frame-rate limiter) with no Run() loop, no driver - // Initialize/Start, and no OnShown pass — a freshly-added window is dirty and paints on the - // first call. The HeadlessConsoleDriver writes the composited frame straight to the console, - // so we redirect Console.Out for the duration of that one call and keep what it wrote. (An - // earlier Run()-on-a-worker-thread approach raced the input+render pump and hung/OOM'd.) SyncInputWidth(); // the window now carries the snapshot size, so the band fills its full width + return RenderFrame(); + } + + /// + /// Renders exactly one frame, synchronously, inline on this thread, and returns it as ANSI. + /// ForceRender() performs a single render cycle (bypassing the frame-rate limiter) with no Run() + /// loop, no driver Initialize/Start, and no OnShown pass — a freshly-added window is dirty and + /// paints on the first call. The HeadlessConsoleDriver writes the composited frame straight to the + /// console, so Console.Out is redirected for the duration of that one call and what it wrote is + /// kept. (An earlier Run()-on-a-worker-thread approach raced the input+render pump and hung/OOM'd.) + /// A frame also arranges the layout, so control bounds are only real after one has been rendered. + /// + private string RenderFrame() + { var real = Console.Out; var writer = new StringWriter(); try @@ -321,6 +377,37 @@ public string RenderSnapshot(string? view = null) return writer.ToString(); } + /// + /// Drives a genuine pane drag through the headless driver for the drag snapshot: primary + /// button down on the first pane's tab strip, then a drag frame over the second pane's left edge. + /// The button is deliberately left down so the frame captures the live drop preview. Requires a + /// frame to have been rendered already, so the panes have real bounds to hit. + /// + private void SimulateSnapshotDrag() + { + if (_system.ConsoleDriver is not HeadlessConsoleDriver driver) + { + return; + } + + var panes = _workspace.Layout.Panes; + var surface = PaneSnapshot(); + if (panes.Count < 2 || + surface.RectOf(panes[0].Id) is not { } source || + surface.RectOf(panes[1].Id) is not { } target) + { + return; + } + + driver.SimulateMouseEvent( + new List { MouseFlags.Button1Pressed }, + new System.Drawing.Point(source.X + 2, source.Y)); + + driver.SimulateMouseEvent( + new List { MouseFlags.Button1Pressed, MouseFlags.Button1Dragged, MouseFlags.ReportMousePosition }, + new System.Drawing.Point(target.X + 1, target.Y + (target.Height / 2))); + } + /// /// Feeds representative MU* output into the windows the resumed session already opened, for /// snapshots/demos. The workspace structure (main + Chat, panes, focus) comes from the config's @@ -1276,7 +1363,11 @@ private MarkupControl PaneContentFor(string id, string title) /// private IWindowControl BuildWorkspaceRow() { - _paneTabs.Clear(); + lock (_paneTabsLock) + { + _paneTabs.Clear(); + } + // When a pane is zoomed, render just that pane full-area; otherwise render the whole tree. var zoomed = _workspace.Layout.ZoomedPaneId is { } zid ? _workspace.Layout.FindPane(zid) : null; @@ -1378,6 +1469,11 @@ private IWindowControl BuildLayoutNode(SharpMUTerm.Core.Workspaces.LayoutNode no { if (node is PaneNode pane) { + if (_dragActive) + { + return BuildDragPane(pane); + } + return _moveMode && _moveLetters.TryGetValue(pane.Id, out var letter) ? BuildMovePane(pane, letter) : BuildPaneTabs(pane); @@ -1462,7 +1558,11 @@ private IWindowControl BuildPaneTabs(PaneNode pane) var paneId = pane.Id; tabs.TabChanged += (_, e) => OnTabChanged(paneId, e.NewTab); - _paneTabs[paneId] = tabs; + lock (_paneTabsLock) + { + _paneTabs[paneId] = tabs; + } + return tabs; } @@ -1584,6 +1684,16 @@ private void OnWindowKey(object? sender, KeyPressedEventArgs e) return; } + // Escape abandons a mouse drag. A terminal that loses the button-up (the pointer left the + // window, the terminal dropped a frame) would otherwise strand the preview over the panes. + if (_dragActive && e.KeyInfo.Key == ConsoleKey.Escape) + { + e.Handled = true; + _paneDrag.Reset(); // no mouse frame ends this one, so the gesture has to be dropped here + EndDrag(); + return; + } + if (!_prefixArmed) { // Draft-safe history recall on ↑/↓ — our own, so a half-typed draft survives (see InputHistory). @@ -1659,6 +1769,16 @@ private void HandleMoveKey(KeyPressedEventArgs e) return; } + // Arrows pick the edge to split the target toward — the keyboard stand-in for dropping on a + // pane's edge rather than its middle. Pressing the same arrow again returns to a tab drop. + if (MoveEdgeFor(key) is { } edge) + { + _moveEdge = _moveEdge == edge ? null : edge; + RebuildPaneArea(); + SetStatus(MovePromptMarkup()); + return; + } + if (ch is >= 'a' and <= 'j') { // Only retarget on a real match — an unmapped letter must not clear the current target. @@ -1672,17 +1792,29 @@ private void HandleMoveKey(KeyPressedEventArgs e) } } + /// The split edge an arrow key selects in move mode, or null for any other key. + private static Edge? MoveEdgeFor(ConsoleKey key) => key switch + { + ConsoleKey.LeftArrow => Edge.Left, + ConsoleKey.RightArrow => Edge.Right, + ConsoleKey.UpArrow => Edge.Top, + ConsoleKey.DownArrow => Edge.Bottom, + _ => null, + }; + /// Applies (or cancels) the move and leaves move mode. private void ExitMoveMode(bool commit) { - if (commit && _moveWindowId is { } win && _moveTargetPaneId is { } pane && pane != _workspace.Layout.FindWindow(win)?.Id) + if (commit && _moveWindowId is { } win && _moveTargetPaneId is { } pane) { - _workspace.Layout.MoveWindowToPane(win, pane); + // The same commit the mouse drop uses, so both routes land identically. + PaneDrop.Apply(_workspace.Layout, win, pane, _moveEdge); } _moveMode = false; _moveWindowId = null; _moveTargetPaneId = null; + _moveEdge = null; _moveLetters.Clear(); RebuildPaneArea(); UpdateStatus(); @@ -1692,7 +1824,204 @@ private void ExitMoveMode(bool commit) private string MovePromptMarkup() { var name = _moveWindowId is { } id && _workspace.FindWindow(id) is { } w ? Escape(w.Title) : "window"; - return $"[#e5c07b]MOVE[/] [bold]{name}[/] [dim]a–j pane · ←↑↓→ edge · ⏎ commit · Esc cancel[/]"; + return $"[#e5c07b]MOVE[/] [bold]{name}[/] [dim]→[/] [#00f5b7]{DropLabel(_moveTargetPaneId, _moveEdge)}[/]" + + " [dim]a–j pane · ←↑↓→ edge · ⏎ commit · Esc cancel[/]"; + } + + /// Human-readable description of a pending drop, for the move prompt and drag preview. + private string DropLabel(string? paneId, Edge? edge) + { + if (paneId is null) + { + return "no target"; + } + + var name = PaneLabel(paneId); + return edge switch + { + Edge.Left => $"split {name} left", + Edge.Right => $"split {name} right", + Edge.Top => $"split {name} top", + Edge.Bottom => $"split {name} bottom", + _ => $"tab in {name}", + }; + } + + /// The rail's friendly name for a pane ("main" for the first, "pane N" after it). + private string PaneLabel(string paneId) + { + var index = 0; + foreach (var pane in _workspace.Layout.Panes) + { + if (pane.Id == paneId) + { + return index == 0 ? "main" : $"pane {index + 1}"; + } + + index++; + } + + return paneId; + } + + /// + /// The adapter between the console driver's raw mouse frames and the tested + /// . Deliberately thin: it decides nothing, it only hands the frame + /// over (with a geometry snapshot the tracker asks for at most once per gesture) and marshals the + /// tracker's verdict onto the UI thread. Driver events arrive on the input thread. + /// + private void OnDriverMouseEvent(object sender, List flags, System.Drawing.Point point) + { + // Overlays own the whole screen while they're up; a drag underneath them would target panes + // the user can't even see. + if (_palette.IsOpen || _settings.IsOpen || _moveMode) + { + return; + } + + var result = _paneDrag.Handle(flags, point.X, point.Y, PaneSnapshot); + if (result.Action == PaneDragAction.None) + { + return; + } + + OnUiThread(() => ApplyDragResult(result)); + } + + /// + /// Reads the pane area's live geometry back out of the framework's arranged layout, in desktop + /// cells. A control's is in + /// window-content space, so the window's own origin and inset are added back on. + /// Internal so a headless test can check the mapping against the framework's own hit testing — + /// it is the one part of the drag that no pure unit test can pin down. + /// + internal PaneDragSurface PaneSnapshot() + { + var origin = ContentOrigin(); + var rects = new Dictionary(StringComparer.Ordinal); + var windows = new Dictionary(StringComparer.Ordinal); + + KeyValuePair[] realised; + lock (_paneTabsLock) + { + realised = _paneTabs.ToArray(); + } + + foreach (var (paneId, tabs) in realised) + { + if (_window.GetLayoutNode(tabs) is not { } node) + { + continue; + } + + var bounds = node.AbsoluteBounds; + rects[paneId] = new PaneRect(origin.X + bounds.X, origin.Y + bounds.Y, bounds.Width, bounds.Height); + + if (_workspace.Layout.FindPane(paneId)?.ActiveTab is { } windowId) + { + windows[paneId] = windowId; + } + } + + return new PaneDragSurface(rects, windows); + } + + /// + /// The desktop cell that window-content coordinate (0,0) paints at: the window's position, offset + /// past any top desktop panel and the window's own frame + padding. Mirrors the framework's own + /// InsetLeft/InsetTop (frame thickness plus padding), which are internal to it. + /// + private System.Drawing.Point ContentOrigin() + { + var frame = _window.BorderStyle == BorderStyle.Frameless ? 0 : 1; + return new System.Drawing.Point( + _window.Left + frame + _window.Padding.Left, + _window.Top + _system.DesktopUpperLeft.Y + frame + _window.Padding.Top); + } + + /// Applies a tracker verdict: paint, tear down, or commit the drop and rebuild. + private void ApplyDragResult(PaneDragResult result) + { + switch (result.Action) + { + case PaneDragAction.Begin: + case PaneDragAction.Update: + _dragActive = true; + _dragTargetPaneId = result.TargetPaneId; + _dragEdge = result.Edge; + RebuildPaneArea(); + SetStatus(DragPromptMarkup(result.WindowId, result.TargetPaneId, result.Edge)); + break; + + case PaneDragAction.Commit: + if (result.WindowId is { } windowId && result.TargetPaneId is { } paneId) + { + if (PaneDrop.Apply(_workspace.Layout, windowId, paneId, result.Edge)) + { + _workspace.ActivateWindow(windowId); + } + } + + EndDrag(); + break; + + default: + EndDrag(); + break; + } + } + + /// + /// Leaves the drag preview and restores the real pane area and status line. It deliberately does + /// not reset the tracker: the tracker ends its own gesture, and a press that lands mid-preview + /// both cancels the stale drag and arms the next one in the same frame. + /// + private void EndDrag() + { + _dragActive = false; + _dragTargetPaneId = null; + _dragEdge = null; + RebuildPaneArea(); + UpdateStatus(); + } + + /// The status line shown while a pane drag is in flight. + private string DragPromptMarkup(string? windowId, string? targetPaneId, Edge? edge) + { + var name = windowId is { } id && _workspace.FindWindow(id) is { } window ? Escape(window.Title) : "window"; + return $"[#e5c07b]DRAG[/] [bold]{name}[/] [dim]→[/] [{PaneDropRenderer.ZoneColor}]{DropLabel(targetPaneId, edge)}[/]" + + " [dim]release to drop · Esc cancel[/]"; + } + + /// A pane rendered as a live drop target, sized from the drag's frozen geometry. + private IWindowControl BuildDragPane(PaneNode pane) + { + var rect = _paneDrag.Surface?.RectOf(pane.Id) ?? default; + var hovered = pane.Id == _dragTargetPaneId; + var lines = PaneDropRenderer.Render( + PaneLabel(pane.Id), + DropLabel(pane.Id, _dragEdge), + rect.Width, + rect.Height, + hovered, + _dragEdge); + + return new MarkupControl(lines) { HorizontalAlignment = HorizontalAlignment.Stretch }; + } + + /// + /// Runs UI work on the UI thread. Headless (snapshot and test) runs have no main loop to drain the + /// queue, and are single-threaded anyway, so they run it inline. + /// + private void OnUiThread(Action action) + { + if (_headless || _system.IsOnUIThread) + { + action(); + return; + } + + _system.EnqueueOnUIThread(action); } /// A pane rendered as a move-mode target: a big letter over the dimmed window list. @@ -1705,6 +2034,12 @@ private IWindowControl BuildMovePane(PaneNode pane, char letter) lines.Add($" [bold {color}]▌ {char.ToUpperInvariant(letter)} ▐[/]"); lines.Add($" [bold {color}]▙▄▄▟[/]"); lines.Add(string.Empty); + if (selected) + { + lines.Add($" [{PaneDropRenderer.ZoneColor}]{DropLabel(pane.Id, _moveEdge)}[/]"); + lines.Add(string.Empty); + } + foreach (var windowId in pane.Tabs) { if (_workspace.FindWindow(windowId) is { } window) @@ -1968,6 +2303,7 @@ private static Theme ResolveTheme(AppConfiguration config) public async ValueTask DisposeAsync() { + _system.ConsoleDriver.MouseEvent -= OnDriverMouseEvent; _fetcher.Dispose(); await _sessions.DisposeAsync().ConfigureAwait(false); } diff --git a/tests/SharpMUTerm.Core.Tests/Workspace/PaneDropTests.cs b/tests/SharpMUTerm.Core.Tests/Workspace/PaneDropTests.cs new file mode 100644 index 00000000..257bc383 --- /dev/null +++ b/tests/SharpMUTerm.Core.Tests/Workspace/PaneDropTests.cs @@ -0,0 +1,126 @@ +using SharpMUTerm.Core.Workspaces; + +namespace SharpMUTerm.Core.Tests.Workspaces; + +public class PaneDropTests +{ + // Two panes side by side: p1 holds "a" and "b", p2 holds "c". + private static WorkspaceLayout Split() + { + var layout = new WorkspaceLayout(new[] { "a", "b", "c" }); + layout.SplitWithWindow("c", layout.FocusedPaneId, Edge.Right); + return layout; + } + + [Test] + public async Task NullEdge_AddsTheWindowToTheTargetPaneAsATab() + { + var layout = Split(); + var target = layout.FindWindow("c")!.Id; + + await Assert.That(PaneDrop.Apply(layout, "b", target, edge: null)).IsTrue(); + + var pane = layout.FindWindow("b")!; + await Assert.That(pane.Id).IsEqualTo(target); + await Assert.That(pane.Tabs).IsEquivalentTo(new[] { "c", "b" }); + await Assert.That(pane.ActiveTab).IsEqualTo("b"); // a dropped tab becomes the visible one + } + + [Test] + public async Task AnEdge_SplitsTheTargetPaneAndPutsTheWindowInTheNewOne() + { + var layout = Split(); + var target = layout.FindWindow("c")!.Id; + + await Assert.That(PaneDrop.Apply(layout, "b", target, Edge.Bottom)).IsTrue(); + + await Assert.That(layout.Panes.Count).IsEqualTo(3); + var pane = layout.FindWindow("b")!; + await Assert.That(pane.Id).IsNotEqualTo(target); + await Assert.That(pane.Tabs).IsEquivalentTo(new[] { "b" }); + await Assert.That(layout.FocusedPaneId).IsEqualTo(pane.Id); // the new pane takes focus + } + + [Test] + [Arguments(Edge.Left)] + [Arguments(Edge.Right)] + [Arguments(Edge.Top)] + [Arguments(Edge.Bottom)] + public async Task EveryEdgeIsAccepted(Edge edge) + { + var layout = Split(); + var target = layout.FindWindow("c")!.Id; + + await Assert.That(PaneDrop.Apply(layout, "b", target, edge)).IsTrue(); + await Assert.That(layout.Panes.Count).IsEqualTo(3); + } + + [Test] + public async Task DroppingAWindowOnItsOwnPaneAsATab_ChangesNothing() + { + var layout = Split(); + var home = layout.FindWindow("b")!; + + await Assert.That(PaneDrop.Apply(layout, "b", home.Id, edge: null)).IsFalse(); + await Assert.That(layout.Panes.Count).IsEqualTo(2); + await Assert.That(home.Tabs).IsEquivalentTo(new[] { "a", "b" }); // no reordering either + } + + [Test] + public async Task SplittingAPaneWithItsOnlyWindow_ChangesNothing() + { + var layout = Split(); + var lonely = layout.FindWindow("c")!; + + // Detaching "c" would empty its pane, and pruning would collapse the split straight back — + // a no-op that nevertheless churns the pane id and focus. It must not be attempted. + await Assert.That(PaneDrop.Apply(layout, "c", lonely.Id, Edge.Left)).IsFalse(); + await Assert.That(layout.Panes.Count).IsEqualTo(2); + await Assert.That(layout.FindWindow("c")!.Id).IsEqualTo(lonely.Id); + } + + [Test] + public async Task SplittingAPaneWithOneOfItsSeveralWindows_IsAllowed() + { + var layout = Split(); + var home = layout.FindWindow("b")!; + + // "b" shares its pane with "a", so pulling it out into a new pane is a real change. + await Assert.That(PaneDrop.Apply(layout, "b", home.Id, Edge.Top)).IsTrue(); + await Assert.That(layout.Panes.Count).IsEqualTo(3); + } + + [Test] + public async Task AMissingPaneOrWindow_IsRejected() + { + var layout = Split(); + + await Assert.That(PaneDrop.Apply(layout, "b", "nope", edge: null)).IsFalse(); + await Assert.That(PaneDrop.Apply(layout, "nope", layout.FocusedPaneId, edge: null)).IsFalse(); + await Assert.That(layout.Panes.Count).IsEqualTo(2); + } + + [Test] + public async Task ResolvingOverload_PicksTheEdgeFromTheDropPoint() + { + var layout = Split(); + var target = layout.FindWindow("c")!.Id; + var rect = new PaneRect(200, 100, 80, 40); + + // Four cells in from the left of the rectangle is inside the 25% margin → split left. + await Assert.That(PaneDrop.Apply(layout, "b", target, rect, 204, 120)).IsTrue(); + await Assert.That(layout.Panes.Count).IsEqualTo(3); + } + + [Test] + public async Task ResolvingOverload_TreatsTheCentreAsATabDrop() + { + var layout = Split(); + var target = layout.FindWindow("c")!.Id; + var rect = new PaneRect(200, 100, 80, 40); + + await Assert.That(PaneDrop.Apply(layout, "b", target, rect, 240, 120)).IsTrue(); + await Assert.That(layout.Panes.Count).IsEqualTo(2); // no new pane — it landed as a tab + await Assert.That(layout.FindWindow("b")!.Id).IsEqualTo(target); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/PaneDragEndToEndTests.cs b/tests/SharpMUTerm.Tui.Tests/PaneDragEndToEndTests.cs new file mode 100644 index 00000000..acbeaca7 --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/PaneDragEndToEndTests.cs @@ -0,0 +1,242 @@ +using SharpConsoleUI.Drivers; +using SharpMUTerm.Core.Workspaces; +using SharpMUTerm.Graphics; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// Drives the whole pane-drag path headlessly: real mouse frames into the console driver, out the +/// other side as a changed split tree. Everything between — the tracker, the geometry read back from +/// the framework's arranged layout, and — runs for +/// real. The only link these tests cannot cover is the terminal's own mouse reporting, which is +/// SharpConsoleUI's NetConsoleDriver turning escape sequences into the very frames fed here. +/// +public class PaneDragEndToEndTests +{ + private const int Width = 120; + private const int Height = 32; + + private static readonly TerminalCapabilities Headless = + new(GraphicsProtocol.None, supportsTrueColor: true, supportsKittyGraphics: false, supportsSixel: false); + + private sealed record Harness(SharpMUTermApp App, HeadlessConsoleDriver Driver, PaneDragSurface Surface); + + /// A rendered two-pane workspace, with the pane geometry the app itself would drag against. + private static Harness Split() + { + // The window system reads the console for input even headless; a null reader returns EOF. + Console.SetIn(TextReader.Null); + + var driver = new HeadlessConsoleDriver(Width, Height); + var app = new SharpMUTermApp(DemoScene.Build(), Headless, driver); + + // Rendering a frame is what arranges the layout, so control bounds only exist afterwards. + app.RenderSnapshot("split"); + + return new Harness(app, driver, app.PaneSnapshot()); + } + + private static void Press(HeadlessConsoleDriver driver, int x, int y) => + driver.SimulateMouseEvent(new List { MouseFlags.Button1Pressed }, new System.Drawing.Point(x, y)); + + private static void Drag(HeadlessConsoleDriver driver, int x, int y) => + driver.SimulateMouseEvent( + new List + { + MouseFlags.Button1Pressed, + MouseFlags.Button1Dragged, + MouseFlags.ReportMousePosition, + }, + new System.Drawing.Point(x, y)); + + private static void Release(HeadlessConsoleDriver driver, int x, int y) => + driver.SimulateMouseEvent(new List { MouseFlags.Button1Released }, new System.Drawing.Point(x, y)); + + private static (string Id, PaneRect Rect) Pane(Harness harness, int index) + { + var id = PaneIds(harness)[index]; + return (id, harness.Surface.RectOf(id)!.Value); + } + + /// The snapshot's pane ids in left-to-right screen order. + private static List PaneIds(Harness harness) => + harness.Surface.Rects.Keys.OrderBy(id => harness.Surface.RectOf(id)!.Value.X).ToList(); + + private static int PaneCount(SharpMUTermApp app) => Flatten(app.CaptureSession().Root).Count; + + /// The layout's panes in tree order — which, for a split, is screen order. + private static List Flatten(LayoutNodeState node) => + node.Children is { Count: > 0 } children + ? children.SelectMany(Flatten).ToList() + : new List { node }; + + [Test] + public async Task TheRenderedFrameGivesTwoNonOverlappingPanes() + { + var harness = Split(); + + await Assert.That(harness.Surface.Rects.Count).IsEqualTo(2); + + var panes = PaneIds(harness).Select(id => harness.Surface.RectOf(id)!.Value).ToList(); + foreach (var rect in panes) + { + await Assert.That(rect.IsEmpty).IsFalse(); + await Assert.That(rect.X).IsGreaterThanOrEqualTo(0); + await Assert.That(rect.X + rect.Width).IsLessThanOrEqualTo(Width); + await Assert.That(rect.Y + rect.Height).IsLessThanOrEqualTo(Height); + } + + // Left pane, one-cell divider, right pane — exactly what LayoutSolver models. + await Assert.That(panes[0].X + panes[0].Width).IsLessThanOrEqualTo(panes[1].X); + } + + [Test] + public async Task ThePaneRectanglesAgreeWithTheFrameworksOwnHitTesting() + { + // This is the assumption the whole mouse path rests on: that our desktop-cell rectangles name + // the same regions SharpConsoleUI would resolve a click in. Sample each pane and ask it. + var harness = Split(); + + foreach (var id in PaneIds(harness)) + { + var rect = harness.Surface.RectOf(id)!.Value; + foreach (var (x, y) in new[] + { + (rect.X, rect.Y), + (rect.X + (rect.Width / 2), rect.Y + (rect.Height / 2)), + (rect.X + rect.Width - 1, rect.Y + rect.Height - 1), + }) + { + await Assert.That(harness.Surface.PaneAt(x, y)).IsEqualTo(id); + } + } + } + + [Test] + [Arguments(Edge.Left)] + [Arguments(Edge.Right)] + [Arguments(Edge.Top)] + [Arguments(Edge.Bottom)] + public async Task DroppingOnAnEdgeSplitsTheTargetPaneTowardThatEdge(Edge edge) + { + var harness = Split(); + var source = Pane(harness, 0); + var target = Pane(harness, 1); + var dragged = harness.Surface.ActiveWindow(source.Id)!; + + // A cell one in from the chosen edge, centred along the other axis — inside the 25% margin. + var (x, y) = edge switch + { + Edge.Left => (target.Rect.X + 1, target.Rect.Y + (target.Rect.Height / 2)), + Edge.Right => (target.Rect.X + target.Rect.Width - 2, target.Rect.Y + (target.Rect.Height / 2)), + Edge.Top => (target.Rect.X + (target.Rect.Width / 2), target.Rect.Y + 1), + _ => (target.Rect.X + (target.Rect.Width / 2), target.Rect.Y + target.Rect.Height - 2), + }; + + Press(harness.Driver, source.Rect.X + 2, source.Rect.Y); + Drag(harness.Driver, source.Rect.X + 3, source.Rect.Y + 1); + Drag(harness.Driver, x, y); + Release(harness.Driver, x, y); + + var root = harness.App.CaptureSession().Root; + var panes = Flatten(root); + + // The source pane held only this window, so handing it over empties and prunes it: the tree + // is the target pane split against a new pane holding the dragged window. + await Assert.That(root.Type).IsEqualTo("split"); + await Assert.That(root.Direction) + .IsEqualTo(edge is Edge.Left or Edge.Right ? SplitDirection.Row : SplitDirection.Column); + await Assert.That(panes.Count).IsEqualTo(2); + + var newPaneIndex = edge is Edge.Left or Edge.Top ? 0 : 1; + await Assert.That(panes[newPaneIndex].Tabs).IsEquivalentTo(new[] { dragged }); + } + + [Test] + public async Task DroppingATabOnItsOwnPanesEdge_PullsItOutIntoANewPane() + { + // The default workspace resumes with both windows sharing one pane, so the window has + // somewhere to leave from — and the source pane survives, giving a genuine second pane. + Console.SetIn(TextReader.Null); + var driver = new HeadlessConsoleDriver(Width, Height); + var app = new SharpMUTermApp(DemoScene.Build(), Headless, driver); + app.RenderSnapshot(); + var surface = app.PaneSnapshot(); + + var paneId = surface.Rects.Keys.Single(); + var rect = surface.RectOf(paneId)!.Value; + var dragged = surface.ActiveWindow(paneId)!; + + Press(driver, rect.X + 2, rect.Y); + Drag(driver, rect.X + 3, rect.Y + 1); + Drag(driver, rect.X + 1, rect.Y + (rect.Height / 2)); + Release(driver, rect.X + 1, rect.Y + (rect.Height / 2)); + + var root = app.CaptureSession().Root; + var panes = Flatten(root); + + await Assert.That(panes.Count).IsEqualTo(2); + await Assert.That(root.Direction).IsEqualTo(SplitDirection.Row); + await Assert.That(panes[0].Tabs).IsEquivalentTo(new[] { dragged }); + await Assert.That(panes[1].Tabs).DoesNotContain(dragged); + } + + [Test] + public async Task DroppingInTheMiddleOfTheOtherPane_MovesTheTabInsteadOfSplitting() + { + var harness = Split(); + var source = Pane(harness, 0); + var target = Pane(harness, 1); + var centreX = target.Rect.X + (target.Rect.Width / 2); + var centreY = target.Rect.Y + (target.Rect.Height / 2); + + Press(harness.Driver, source.Rect.X + 2, source.Rect.Y); + Drag(harness.Driver, source.Rect.X + 3, source.Rect.Y + 1); + Drag(harness.Driver, centreX, centreY); + Release(harness.Driver, centreX, centreY); + + // The source pane held a single window, so handing it over empties and prunes it: one pane. + await Assert.That(PaneCount(harness.App)).IsEqualTo(1); + } + + [Test] + public async Task AClickOnATabWithoutMoving_LeavesTheLayoutAlone() + { + var harness = Split(); + var source = Pane(harness, 0); + + Press(harness.Driver, source.Rect.X + 2, source.Rect.Y); + Release(harness.Driver, source.Rect.X + 2, source.Rect.Y); + + await Assert.That(PaneCount(harness.App)).IsEqualTo(2); + } + + [Test] + public async Task ADragThatStartsInAPanesBody_LeavesTheLayoutAlone() + { + var harness = Split(); + var source = Pane(harness, 0); + var target = Pane(harness, 1); + + // Body presses belong to the content (text selection, links), not to pane dragging. + Press(harness.Driver, source.Rect.X + 2, source.Rect.Y + 5); + Drag(harness.Driver, target.Rect.X + 1, target.Rect.Y + 5); + Release(harness.Driver, target.Rect.X + 1, target.Rect.Y + 5); + + await Assert.That(PaneCount(harness.App)).IsEqualTo(2); + } + + [Test] + public async Task ReleasingOutsideEveryPane_LeavesTheLayoutAlone() + { + var harness = Split(); + var source = Pane(harness, 0); + + Press(harness.Driver, source.Rect.X + 2, source.Rect.Y); + Drag(harness.Driver, source.Rect.X + 3, source.Rect.Y + 1); + Release(harness.Driver, 0, Height - 1); // the status line + + await Assert.That(PaneCount(harness.App)).IsEqualTo(2); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/PaneDragSurfaceTests.cs b/tests/SharpMUTerm.Tui.Tests/PaneDragSurfaceTests.cs new file mode 100644 index 00000000..91da6666 --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/PaneDragSurfaceTests.cs @@ -0,0 +1,98 @@ +using SharpMUTerm.Core.Workspaces; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +public class PaneDragSurfaceTests +{ + // Two panes side by side with a one-cell divider between them, as LayoutSolver would place them: + // p1 spans columns 10–39, the divider sits at 40, p2 spans 41–69. Both run rows 2–21. + private static PaneDragSurface TwoPanes() => new( + new Dictionary + { + ["p1"] = new(10, 2, 30, 20), + ["p2"] = new(41, 2, 29, 20), + }, + new Dictionary + { + ["p1"] = "main", + ["p2"] = "chat", + }); + + [Test] + public async Task PaneAt_FindsThePaneContainingTheCell() + { + var surface = TwoPanes(); + + await Assert.That(surface.PaneAt(10, 2)).IsEqualTo("p1"); // top-left corner is inside + await Assert.That(surface.PaneAt(39, 21)).IsEqualTo("p1"); // bottom-right corner is inside + await Assert.That(surface.PaneAt(41, 2)).IsEqualTo("p2"); + await Assert.That(surface.PaneAt(69, 21)).IsEqualTo("p2"); + } + + [Test] + public async Task PaneAt_ReturnsNullOutsideEveryPane() + { + var surface = TwoPanes(); + + await Assert.That(surface.PaneAt(40, 10)).IsNull(); // the divider between the panes + await Assert.That(surface.PaneAt(9, 10)).IsNull(); // the rail, left of the pane area + await Assert.That(surface.PaneAt(30, 1)).IsNull(); // the header row above + await Assert.That(surface.PaneAt(30, 22)).IsNull(); // the input band below + await Assert.That(surface.PaneAt(70, 10)).IsNull(); // past the right edge + } + + [Test] + public async Task PaneAt_SkipsCollapsedPanes() + { + var surface = new PaneDragSurface( + new Dictionary { ["p1"] = new(5, 5, 0, 20) }, + new Dictionary { ["p1"] = "main" }); + + await Assert.That(surface.PaneAt(5, 10)).IsNull(); + } + + [Test] + public async Task IsTabStrip_IsOnlyThePanesTopRow() + { + var surface = TwoPanes(); + + await Assert.That(surface.IsTabStrip("p1", 2)).IsTrue(); + await Assert.That(surface.IsTabStrip("p1", 3)).IsFalse(); + await Assert.That(surface.IsTabStrip("p1", 1)).IsFalse(); + await Assert.That(surface.IsTabStrip("nope", 2)).IsFalse(); + } + + [Test] + public async Task RectAndActiveWindow_RoundTripPerPane() + { + var surface = TwoPanes(); + + await Assert.That(surface.RectOf("p2")).IsEqualTo(new PaneRect(41, 2, 29, 20)); + await Assert.That(surface.RectOf("nope")).IsNull(); + await Assert.That(surface.ActiveWindow("p2")).IsEqualTo("chat"); + await Assert.That(surface.ActiveWindow("nope")).IsNull(); + } + + [Test] + public async Task ItCopiesTheRectsSoALaterRebuildCannotMoveThem() + { + var rects = new Dictionary { ["p1"] = new(0, 0, 10, 10) }; + var surface = new PaneDragSurface(rects, new Dictionary { ["p1"] = "main" }); + + rects["p1"] = new PaneRect(500, 500, 10, 10); + + await Assert.That(surface.RectOf("p1")).IsEqualTo(new PaneRect(0, 0, 10, 10)); + } + + [Test] + public async Task AnEmptySurfaceReportsItself() + { + var surface = new PaneDragSurface( + new Dictionary(), + new Dictionary()); + + await Assert.That(surface.IsEmpty).IsTrue(); + await Assert.That(TwoPanes().IsEmpty).IsFalse(); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/PaneDragTrackerTests.cs b/tests/SharpMUTerm.Tui.Tests/PaneDragTrackerTests.cs new file mode 100644 index 00000000..98d3a24c --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/PaneDragTrackerTests.cs @@ -0,0 +1,403 @@ +using SharpConsoleUI.Drivers; +using SharpMUTerm.Core.Workspaces; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +public class PaneDragTrackerTests +{ + // p1 spans columns 10–39, p2 spans 41–69; both run rows 2–21, tab strips on row 2. + private static PaneDragSurface TwoPanes() => new( + new Dictionary + { + ["p1"] = new(10, 2, 30, 20), + ["p2"] = new(41, 2, 29, 20), + }, + new Dictionary + { + ["p1"] = "main", + ["p2"] = "chat", + }); + + private static List Press() => new() { MouseFlags.Button1Pressed }; + + private static List Release() => new() { MouseFlags.Button1Released }; + + // How a terminal in SGR mode reports motion with the primary button held. + private static List Drag() => new() + { + MouseFlags.Button1Pressed, + MouseFlags.Button1Dragged, + MouseFlags.ReportMousePosition, + }; + + private static PaneDragTracker Started(out PaneDragSurface surface) + { + var tracker = new PaneDragTracker(); + var frozen = TwoPanes(); + surface = frozen; + tracker.Handle(Press(), 15, 2, () => frozen); // press p1's tab strip + tracker.Handle(Drag(), 16, 3, () => frozen); // move off the pressed cell + return tracker; + } + + // --- flag classification ------------------------------------------------- + + [Test] + public async Task Classify_ReadsAPlainPrimaryPressAsAPress() + { + await Assert.That(PaneDragTracker.Classify(Press())).IsEqualTo(PaneDragInput.Press); + } + + [Test] + public async Task Classify_ReadsSgrMotionWithTheButtonHeldAsADrag() + { + // SGR reports a drag as Button1Pressed + ReportMousePosition (+ Button1Dragged); the pressed + // bit must not be mistaken for a fresh press or every drag frame would restart the gesture. + await Assert.That(PaneDragTracker.Classify(Drag())).IsEqualTo(PaneDragInput.Drag); + await Assert.That(PaneDragTracker.Classify(new List + { + MouseFlags.Button1Pressed, + MouseFlags.ReportMousePosition, + })).IsEqualTo(PaneDragInput.Drag); + await Assert.That(PaneDragTracker.Classify(new List { MouseFlags.Button1Dragged })) + .IsEqualTo(PaneDragInput.Drag); + } + + [Test] + public async Task Classify_ReadsAReleaseAsARelease_EvenAlongsideASynthesisedClick() + { + await Assert.That(PaneDragTracker.Classify(Release())).IsEqualTo(PaneDragInput.Release); + await Assert.That(PaneDragTracker.Classify(new List + { + MouseFlags.Button1Released, + MouseFlags.Button1Clicked, + })).IsEqualTo(PaneDragInput.Release); + } + + [Test] + public async Task Classify_ReadsASecondaryPressAsAnAbort() + { + await Assert.That(PaneDragTracker.Classify(new List { MouseFlags.Button3Pressed })) + .IsEqualTo(PaneDragInput.Abort); + } + + [Test] + public async Task Classify_IgnoresWheelPlainMotionAndEmptyFrames() + { + await Assert.That(PaneDragTracker.Classify(new List { MouseFlags.WheeledUp })) + .IsEqualTo(PaneDragInput.Ignored); + await Assert.That(PaneDragTracker.Classify(new List { MouseFlags.WheeledDown })) + .IsEqualTo(PaneDragInput.Ignored); + await Assert.That(PaneDragTracker.Classify(new List { MouseFlags.ReportMousePosition })) + .IsEqualTo(PaneDragInput.Ignored); + await Assert.That(PaneDragTracker.Classify(new List())).IsEqualTo(PaneDragInput.Ignored); + } + + // --- arming -------------------------------------------------------------- + + [Test] + public async Task PressingATabStrip_ArmsButDoesNotYetDrag() + { + var tracker = new PaneDragTracker(); + var surface = TwoPanes(); + + var result = tracker.Handle(Press(), 15, 2, () => surface); + + await Assert.That(result.Action).IsEqualTo(PaneDragAction.None); + await Assert.That(tracker.IsDragging).IsFalse(); + } + + [Test] + public async Task PressingAPanesBody_NeverStartsADrag() + { + var tracker = new PaneDragTracker(); + var surface = TwoPanes(); + + tracker.Handle(Press(), 15, 8, () => surface); // row 8 is body, not the tab strip + var result = tracker.Handle(Drag(), 50, 10, () => surface); + + await Assert.That(result.Action).IsEqualTo(PaneDragAction.None); + await Assert.That(tracker.IsDragging).IsFalse(); + } + + [Test] + public async Task PressingOutsideEveryPane_NeverStartsADrag() + { + var tracker = new PaneDragTracker(); + var surface = TwoPanes(); + + tracker.Handle(Press(), 2, 2, () => surface); // over the rail + var result = tracker.Handle(Drag(), 50, 10, () => surface); + + await Assert.That(result.Action).IsEqualTo(PaneDragAction.None); + await Assert.That(tracker.IsDragging).IsFalse(); + } + + [Test] + public async Task PressingAPaneWithNoWindow_NeverStartsADrag() + { + var tracker = new PaneDragTracker(); + var surface = new PaneDragSurface( + new Dictionary { ["p1"] = new(10, 2, 30, 20) }, + new Dictionary()); // realised, but showing nothing + + tracker.Handle(Press(), 15, 2, () => surface); + + await Assert.That(tracker.Handle(Drag(), 20, 10, () => surface).Action).IsEqualTo(PaneDragAction.None); + } + + [Test] + public async Task TheGeometryIsSnapshotOnlyOnPress() + { + var calls = 0; + var surface = TwoPanes(); + var tracker = new PaneDragTracker(); + + PaneDragSurface Snapshot() + { + calls++; + return surface; + } + + tracker.Handle(Press(), 15, 2, Snapshot); + tracker.Handle(Drag(), 50, 10, Snapshot); + tracker.Handle(Drag(), 55, 12, Snapshot); + tracker.Handle(Release(), 55, 12, Snapshot); + + await Assert.That(calls).IsEqualTo(1); + } + + // --- dragging ------------------------------------------------------------ + + [Test] + public async Task StayingOnThePressedCell_IsStillAClick() + { + var tracker = new PaneDragTracker(); + var surface = TwoPanes(); + + tracker.Handle(Press(), 15, 2, () => surface); + var result = tracker.Handle(Drag(), 15, 2, () => surface); + + await Assert.That(result.Action).IsEqualTo(PaneDragAction.None); + await Assert.That(tracker.IsDragging).IsFalse(); + } + + [Test] + public async Task MovingOffThePressedCell_BeginsTheDrag() + { + var tracker = new PaneDragTracker(); + var surface = TwoPanes(); + + tracker.Handle(Press(), 15, 2, () => surface); + var result = tracker.Handle(Drag(), 16, 2, () => surface); + + await Assert.That(result.Action).IsEqualTo(PaneDragAction.Begin); + await Assert.That(result.WindowId).IsEqualTo("main"); + await Assert.That(tracker.IsDragging).IsTrue(); + await Assert.That(tracker.SourcePaneId).IsEqualTo("p1"); + } + + [Test] + public async Task HoveringAnotherPanesEdge_ReportsThatEdge() + { + var tracker = Started(out var surface); + + // p2 spans columns 41–69; two cells in from its left edge is inside the 25% margin. + var result = tracker.Handle(Drag(), 43, 10, () => surface); + + await Assert.That(result.Action).IsEqualTo(PaneDragAction.Update); + await Assert.That(result.TargetPaneId).IsEqualTo("p2"); + await Assert.That(result.Edge).IsEqualTo(Edge.Left); + } + + [Test] + public async Task HoveringAnotherPanesCentre_ReportsATabDrop() + { + var tracker = Started(out var surface); + + var result = tracker.Handle(Drag(), 55, 11, () => surface); + + await Assert.That(result.Action).IsEqualTo(PaneDragAction.Update); + await Assert.That(result.TargetPaneId).IsEqualTo("p2"); + await Assert.That(result.Edge).IsNull(); + } + + [Test] + public async Task MovingWithinTheSameZone_ReportsNothingNew() + { + var tracker = Started(out var surface); + + tracker.Handle(Drag(), 55, 11, () => surface); + var result = tracker.Handle(Drag(), 56, 12, () => surface); + + // The preview only needs repainting when the target or the edge changes, not every cell. + await Assert.That(result.Action).IsEqualTo(PaneDragAction.None); + await Assert.That(tracker.TargetPaneId).IsEqualTo("p2"); + } + + [Test] + public async Task LeavingEveryPane_ClearsTheTarget() + { + var tracker = Started(out var surface); + + tracker.Handle(Drag(), 55, 11, () => surface); + var result = tracker.Handle(Drag(), 40, 11, () => surface); // onto the divider + + await Assert.That(result.Action).IsEqualTo(PaneDragAction.Update); + await Assert.That(result.TargetPaneId).IsNull(); + await Assert.That(result.Edge).IsNull(); + } + + // --- finishing ----------------------------------------------------------- + + [Test] + public async Task ReleasingOverAPane_Commits() + { + var tracker = Started(out var surface); + + tracker.Handle(Drag(), 55, 11, () => surface); + var result = tracker.Handle(Release(), 43, 10, () => surface); + + // The release position wins, not the last drag frame — the button may come up after a move. + await Assert.That(result.Action).IsEqualTo(PaneDragAction.Commit); + await Assert.That(result.WindowId).IsEqualTo("main"); + await Assert.That(result.TargetPaneId).IsEqualTo("p2"); + await Assert.That(result.Edge).IsEqualTo(Edge.Left); + await Assert.That(tracker.IsDragging).IsFalse(); + } + + [Test] + public async Task ReleasingOffEveryPane_Cancels() + { + var tracker = Started(out var surface); + + var result = tracker.Handle(Release(), 2, 30, () => surface); + + await Assert.That(result.Action).IsEqualTo(PaneDragAction.Cancel); + await Assert.That(tracker.IsDragging).IsFalse(); + } + + [Test] + public async Task ReleasingWithoutHavingMoved_ReportsNothing() + { + var tracker = new PaneDragTracker(); + var surface = TwoPanes(); + + tracker.Handle(Press(), 15, 2, () => surface); + var result = tracker.Handle(Release(), 15, 2, () => surface); + + // A plain click on a tab: the framework's own TabControl handling owns it. + await Assert.That(result.Action).IsEqualTo(PaneDragAction.None); + } + + [Test] + public async Task ASecondaryPressMidDrag_Cancels() + { + var tracker = Started(out var surface); + + var result = tracker.Handle(new List { MouseFlags.Button3Pressed }, 50, 10, () => surface); + + await Assert.That(result.Action).IsEqualTo(PaneDragAction.Cancel); + await Assert.That(tracker.IsDragging).IsFalse(); + } + + [Test] + public async Task AFreshPressMidDrag_CancelsTheOldGesture() + { + var tracker = Started(out var surface); + + // A swallowed button-up would otherwise leave the preview stuck over the panes. + var result = tracker.Handle(Press(), 50, 2, () => surface); + + await Assert.That(result.Action).IsEqualTo(PaneDragAction.Cancel); + await Assert.That(tracker.IsDragging).IsFalse(); + } + + [Test] + public async Task AFreshPressMidDrag_AlsoArmsTheNextGesture() + { + var tracker = Started(out var surface); + + tracker.Handle(Press(), 50, 2, () => surface); // over p2's tab strip + var result = tracker.Handle(Drag(), 51, 3, () => surface); + + // Cancelling the stale drag must not cost the user the press they just made. + await Assert.That(result.Action).IsEqualTo(PaneDragAction.Begin); + await Assert.That(result.WindowId).IsEqualTo("chat"); + await Assert.That(tracker.SourcePaneId).IsEqualTo("p2"); + } + + [Test] + public async Task WheelAndIdleMotionDoNotDisturbALiveDrag() + { + var tracker = Started(out var surface); + tracker.Handle(Drag(), 43, 10, () => surface); + + await Assert.That(tracker.Handle(new List { MouseFlags.WheeledUp }, 43, 10, () => surface).Action) + .IsEqualTo(PaneDragAction.None); + + await Assert.That(tracker.IsDragging).IsTrue(); + await Assert.That(tracker.TargetPaneId).IsEqualTo("p2"); + await Assert.That(tracker.TargetEdge).IsEqualTo(Edge.Left); + } + + [Test] + public async Task Reset_AbandonsTheGestureSilently() + { + var tracker = Started(out _); + + tracker.Reset(); + + await Assert.That(tracker.IsDragging).IsFalse(); + await Assert.That(tracker.WindowId).IsNull(); + await Assert.That(tracker.TargetPaneId).IsNull(); + } + + [Test] + public async Task DraggingBackOntoItsOwnPanesEdge_IsReported() + { + var tracker = Started(out var surface); + + // Resolution is the tracker's job; whether it is a no-op is PaneDrop's (see PaneDropTests). + var result = tracker.Handle(Drag(), 11, 10, () => surface); + + await Assert.That(result.TargetPaneId).IsEqualTo("p1"); + await Assert.That(result.Edge).IsEqualTo(Edge.Left); + } + + [Test] + public async Task AnEmptySurface_NeverArms() + { + var tracker = new PaneDragTracker(); + var surface = new PaneDragSurface( + new Dictionary(), + new Dictionary()); + + tracker.Handle(Press(), 15, 2, () => surface); + + await Assert.That(tracker.Handle(Drag(), 20, 10, () => surface).Action).IsEqualTo(PaneDragAction.None); + } + + [Test] + public async Task AFullGestureAcrossPanes_ProducesExactlyOneBeginAndOneCommit() + { + var surface = TwoPanes(); + var tracker = new PaneDragTracker(); + var actions = new List(); + + void Feed(List flags, int x, int y) => + actions.Add(tracker.Handle(flags, x, y, () => surface).Action); + + Feed(Press(), 15, 2); + Feed(Drag(), 16, 3); + Feed(Drag(), 30, 8); + Feed(Drag(), 45, 10); + Feed(Drag(), 46, 11); + Feed(Release(), 46, 11); + + await Assert.That(actions.Count(a => a == PaneDragAction.Begin)).IsEqualTo(1); + await Assert.That(actions.Count(a => a == PaneDragAction.Commit)).IsEqualTo(1); + await Assert.That(actions[^1]).IsEqualTo(PaneDragAction.Commit); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/PaneDropRendererTests.cs b/tests/SharpMUTerm.Tui.Tests/PaneDropRendererTests.cs new file mode 100644 index 00000000..07858102 --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/PaneDropRendererTests.cs @@ -0,0 +1,157 @@ +using SharpMUTerm.Core.Workspaces; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +public class PaneDropRendererTests +{ + private static List Hovered(Edge? edge, int width = 40, int height = 20) => + PaneDropRenderer.Render("pane 2", "split pane 2 left", width, height, hovered: true, edge); + + [Test] + public async Task ItRendersOneRowPerCellRow() + { + await Assert.That(Hovered(Edge.Left).Count).IsEqualTo(20); + await Assert.That(PaneDropRenderer.Render("main", "x", 40, 7, hovered: false, edge: null).Count).IsEqualTo(7); + } + + [Test] + public async Task EveryRowIsExactlyThePaneWidth() + { + foreach (var line in Hovered(Edge.Right)) + { + await Assert.That(MarkupText.VisibleLength(line)).IsEqualTo(40); + } + } + + [Test] + public async Task ADegenerateRectStillRendersSomething() + { + var lines = PaneDropRenderer.Render("main", "x", 0, 0, hovered: true, edge: Edge.Left); + + await Assert.That(lines.Count).IsEqualTo(1); + await Assert.That(MarkupText.VisibleLength(lines[0])).IsEqualTo(1); + } + + [Test] + public async Task AHoveredPaneShowsTheDropLabel_AnIdleOneShowsItsName() + { + var hovered = string.Concat(Hovered(Edge.Left)); + var idle = string.Concat(PaneDropRenderer.Render("main", "split main left", 40, 20, hovered: false, edge: null)); + + await Assert.That(hovered).Contains("split pane 2 left"); + await Assert.That(idle).Contains("main"); + await Assert.That(idle).DoesNotContain("split main left"); + } + + [Test] + public async Task OnlyAHoveredPaneIsHighlighted() + { + var idle = string.Concat(PaneDropRenderer.Render("main", "x", 40, 20, hovered: false, edge: Edge.Left)); + + await Assert.That(idle).DoesNotContain(PaneDropRenderer.ZoneColor); + await Assert.That(string.Concat(Hovered(Edge.Left))).Contains(PaneDropRenderer.ZoneColor); + } + + [Test] + public async Task ALongLabelIsTruncatedRatherThanOverflowing() + { + var lines = PaneDropRenderer.Render("p", new string('x', 200), 12, 5, hovered: true, edge: null); + + foreach (var line in lines) + { + await Assert.That(MarkupText.VisibleLength(line)).IsEqualTo(12); + } + + await Assert.That(string.Concat(lines)).Contains("…"); + } + + [Test] + public async Task LiteralBracketsInALabelAreEscaped() + { + var lines = PaneDropRenderer.Render("p", "tab in [Chat]", 40, 5, hovered: true, edge: null); + + // Unescaped, "[Chat]" would be swallowed as a markup tag. + await Assert.That(string.Concat(lines)).Contains("[[Chat]]"); + } + + // --- the zone geometry --------------------------------------------------- + + [Test] + public async Task TheBandMatchesTheDropZoneFraction() + { + // DropZones splits when a drop lands within 25% of an edge; the band must show that same 25%. + await Assert.That(PaneDropRenderer.Band(40, DropZones.DefaultEdgeFraction)).IsEqualTo(10); + await Assert.That(PaneDropRenderer.Band(46, DropZones.DefaultEdgeFraction)).IsEqualTo(12); + } + + [Test] + public async Task TheBandIsNeverThinnerThanOneCellNorWiderThanThePane() + { + await Assert.That(PaneDropRenderer.Band(1, DropZones.DefaultEdgeFraction)).IsEqualTo(1); + await Assert.That(PaneDropRenderer.Band(2, DropZones.DefaultEdgeFraction)).IsEqualTo(1); + await Assert.That(PaneDropRenderer.Band(3, 1.0)).IsEqualTo(3); + } + + [Test] + [Arguments(Edge.Left, 0, 0, 10)] + [Arguments(Edge.Right, 0, 30, 40)] + [Arguments(Edge.Top, 1, 0, 5)] + [Arguments(Edge.Bottom, 1, 15, 20)] + public async Task TheBandCoversExactlyItsOwnEdgeStrip(Edge edge, int axis, int from, int to) + { + const int width = 40; + const int height = 20; + + // axis 0 = the band is a column range, axis 1 = a row range. Walking the whole rectangle + // pins down both which cells are claimed and, just as importantly, which are not. + for (var row = 0; row < height; row++) + { + for (var column = 0; column < width; column++) + { + var along = axis == 0 ? column : row; + var expected = along >= from && along < to; + await Assert.That(PaneDropRenderer.InZone(column, row, width, height, edge)) + .IsEqualTo(expected); + } + } + } + + [Test] + [Arguments(Edge.Left)] + [Arguments(Edge.Right)] + [Arguments(Edge.Top)] + [Arguments(Edge.Bottom)] + public async Task EveryCellThatResolvesToAnEdgeIsInsideThatEdgesBand(Edge edge) + { + const int width = 40; + const int height = 20; + + // The guarantee the preview owes the user: wherever the pointer is resolving to this edge, + // this edge's band is lit under it. The converse does not hold — the band is symmetric while + // DropZones measures from cell corners, so its right/bottom regions are a cell narrower, and + // near a corner a cell in the left band can resolve to Top (whichever edge is nearest wins). + for (var row = 0; row < height; row++) + { + for (var column = 0; column < width; column++) + { + if (DropZones.Resolve(0, 0, width, height, column, row) != edge) + { + continue; + } + + await Assert.That(PaneDropRenderer.InZone(column, row, width, height, edge)).IsTrue(); + } + } + } + + [Test] + public async Task ATabDropOutlinesThePaneInsteadOfBandingAnEdge() + { + await Assert.That(PaneDropRenderer.InZone(0, 5, 40, 20, edge: null)).IsTrue(); // left border + await Assert.That(PaneDropRenderer.InZone(39, 5, 40, 20, edge: null)).IsTrue(); // right border + await Assert.That(PaneDropRenderer.InZone(20, 0, 40, 20, edge: null)).IsTrue(); // top border + await Assert.That(PaneDropRenderer.InZone(20, 19, 40, 20, edge: null)).IsTrue(); // bottom border + await Assert.That(PaneDropRenderer.InZone(20, 10, 40, 20, edge: null)).IsFalse(); + } +} From 029772c010e7188aff69cc1f7f12fedc89544302 Mon Sep 17 00:00:00 2001 From: Harry Cordewener Date: Tue, 28 Jul 2026 17:40:59 -0500 Subject: [PATCH 08/23] Wire inline images into the web view via SharpConsoleUI Backlog item 2, the last unwired piece. SharpMUTerm.Graphics existed and was tested but nothing in the TUI ever called it, so "inline graphics, in scope from day one" had never once put a picture on screen. Wired at the seam in the web view, which is the only place in the codebase where an image URL survives: MXP and Pueblo both parse and discard it, and HtmlStyledRenderer already produced a placeholder. HtmlStyledRenderer now indexes each placeholder line, WebPage carries the images, and WebViewComposer splits the page into text and image blocks for the framework's ImageControl. Rendering goes through the framework rather than our own encoder, and that is forced rather than preferred: our Kitty and Sixel encoders emit escape-sequence strings, but a compositor owns every cell, Cell has no raw-escape field, and AppendCombiner strips escapes as an anti-injection defence. There is nowhere to put an escape blob. The framework's renderer works because it writes U+10EEEE placeholder cells -- images become real cells, which is what docs/PLAN.md committed to. Negative finding worth recording: the framework has no Sixel back-end at v2.5.14, and IImageRenderer is internal with ResolveRenderer private, so one cannot be injected. A Sixel-only terminal therefore degrades to half-blocks. That is stated in the policy's own Describe() output rather than failing silently. Lifting it needs an upstream PR. Degradation is Kitty -> half-block -> text placeholder, and when nothing is supported no image is fetched at all. That chain is the part verifiable without a graphics terminal, so it is tested exhaustively: every protocol x surface combination, plus an invariant that no combination ever upgrades past what was detected. SharpMUTerm.Graphics keeps its own encoders, still reachable for a raw-terminal host; nothing deleted in this pass. 764 tests pass, up from 649. Not verified: that a Kitty image actually appears. The transmission, encode and placement are framework paths only a real GPU terminal exercises. Co-Authored-By: Claude Opus 5 (1M context) --- CLAUDE.md | 9 +- docs/HANDOFF.md | 70 +++++- src/SharpMUTerm.Graphics/InlineImagePolicy.cs | 139 +++++++++++ src/SharpMUTerm.Tui/SharpMUTermApp.cs | 208 ++++++++++++++++- src/SharpMUTerm.Tui/WebImageLayout.cs | 69 ++++++ src/SharpMUTerm.Tui/WebImageLoader.cs | 217 ++++++++++++++++++ src/SharpMUTerm.Tui/WebViewComposer.cs | 109 +++++++++ src/SharpMUTerm.Web/HtmlStyledRenderer.cs | 46 +++- src/SharpMUTerm.Web/LineWriter.cs | 8 + src/SharpMUTerm.Web/WebImage.cs | 21 ++ src/SharpMUTerm.Web/WebPage.cs | 11 +- src/SharpMUTerm.Web/WebPageFetcher.cs | 5 +- .../InlineImagePolicyTests.cs | 182 +++++++++++++++ .../WebImageLayoutTests.cs | 138 +++++++++++ .../WebImageLoaderTests.cs | 176 ++++++++++++++ .../WebInlineImageEndToEndTests.cs | 145 ++++++++++++ .../WebViewComposerTests.cs | 207 +++++++++++++++++ .../WebImageIndexTests.cs | 146 ++++++++++++ 18 files changed, 1879 insertions(+), 27 deletions(-) create mode 100644 src/SharpMUTerm.Graphics/InlineImagePolicy.cs create mode 100644 src/SharpMUTerm.Tui/WebImageLayout.cs create mode 100644 src/SharpMUTerm.Tui/WebImageLoader.cs create mode 100644 src/SharpMUTerm.Tui/WebViewComposer.cs create mode 100644 src/SharpMUTerm.Web/WebImage.cs create mode 100644 tests/SharpMUTerm.Graphics.Tests/InlineImagePolicyTests.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/WebImageLayoutTests.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/WebImageLoaderTests.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/WebInlineImageEndToEndTests.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/WebViewComposerTests.cs create mode 100644 tests/SharpMUTerm.Web.Tests/WebImageIndexTests.cs diff --git a/CLAUDE.md b/CLAUDE.md index be356017..91b75ba2 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -32,7 +32,7 @@ fallbacks) for inline images/maps. ## Repository state **M1 delivered, plus substantial M2–M4 work.** `SharpMUTerm.slnx` builds all ten projects on -`net10.0`; the solution has **649 passing tests**. In place: +`net10.0`; the solution has **764 passing tests**. In place: - **Core** — `AnsiParser` (SGR 16/256/truecolor), styled-line + `ScrollbackBuffer` model, `TcpTransport` (TLS + IPv6), `TelnetSession` (wraps TelnetNegotiationCore **2.5.3**), @@ -40,7 +40,10 @@ fallbacks) for inline images/maps. config (worlds → characters + shared trigger sets, with migration), `Theme`/`ThemeLibrary`, and `WorldSession`/`SessionManager` orchestration. - **Graphics** — Kitty encoder + Unicode placeholders, Sixel + half-block fallbacks, capability - probe (no UI dependency). + probe, and `InlineImagePolicy` — the Kitty → Sixel → half-block → text degradation chain (no UI + dependency). Inside the TUI the *pixels* are drawn by SharpConsoleUI's `ImageControl`; ours + supplies the policy, because only the framework's renderer can put an image into compositor cells. + See `docs/HANDOFF.md` §2 for why, including the framework's missing Sixel back-end. - **Scripting** — sandboxed MoonSharp `ScriptHost` (world/output/trigger/alias/timer/gmcp/log). - **Tui** — **SharpConsoleUI** app: a `TabControl` of output windows (main + trigger-routed **spawn windows** + web view, with unread badges), each a `MarkupControl` fed StyledLine → Spectre-style @@ -79,7 +82,7 @@ Planned solution layout: | Project | Responsibility | |---|---| | `SharpMUTerm.Core` | Transport, telnet, ANSI/MXP/Pueblo parsers, GMCP/MSDP routing, scrollback, engines, logging (no UI deps) | -| `SharpMUTerm.Graphics` | Kitty graphics protocol, capability probe, Sixel + half-block fallbacks, `GraphicsView` | +| `SharpMUTerm.Graphics` | Kitty/Sixel encoders, capability probe, half-block fallback, `InlineImagePolicy` (no UI deps) | | `SharpMUTerm.Scripting` | MoonSharp host + scripting API | | `SharpMUTerm.Tui` | SharpConsoleUI application | | `*.Tests` (Core, Graphics, Scripting, Web, Tui) | TUnit | diff --git a/docs/HANDOFF.md b/docs/HANDOFF.md index 953d3d24..348555b3 100644 --- a/docs/HANDOFF.md +++ b/docs/HANDOFF.md @@ -4,8 +4,8 @@ Context for whoever (human or agent) picks up this work next. - **Repository:** `SharpMUSH/SharpMUTerm` - **Start from:** a fresh branch off `main` -- **Tests:** 649 across the solution (325 Core / 57 Graphics / 42 Scripting / - 15 Web / 210 Tui), all green; `dotnet build SharpMUTerm.slnx` clean (0 warnings +- **Tests:** 764 across the solution (325 Core / 83 Graphics / 42 Scripting / + 28 Web / 286 Tui), all green; `dotnet build SharpMUTerm.slnx` clean (0 warnings from this repo; building against a local SharpConsoleUI clone surfaces 2 upstream NuGet advisory warnings for AngleSharp, which are the framework's, not ours) @@ -35,16 +35,57 @@ F-key shortcuts and the `--view` snapshot lookup. Shared chrome lives in `ScreenPalette` (colours), `ScreenChrome` (hint/action fragments, band, vertical rule, indent) and `MarkupText` (escape, visible width, padding, spread). -### 2. Task #20 — fold inline graphics into SharpConsoleUI's Kitty support - -**Status:** pending; **cannot be verified headlessly** (no GPU terminal in the -sandbox). `SharpMUTerm.Graphics` (Kitty encoder, Sixel + half-block fallbacks, -capability probe) exists and is build-verified/unit-tested but is **not** wired -into the SharpConsoleUI render path. SharpConsoleUI has native Kitty graphics -support; the task is to route `GraphicsView`/image output through it and ensure -clean degradation when no graphics protocol is available (the sandbox is exactly -that case). Real verification must happen on a GPU terminal (Kitty/WezTerm/ -Ghostty) on the maintainer's machine. +### 2. Task #20 — fold inline graphics into SharpConsoleUI's Kitty support — wired + +**Status:** wired and unit-tested; the **picture itself is still unverified** +(no GPU terminal in the sandbox). `` in the web view now renders inline. + +**What the framework actually provides** (read at v2.5.14, not assumed): + +- `ImageControl` (`Controls/ImageControl/ImageControl.cs`) takes a + `PixelBuffer` (`Imaging/PixelBuffer.cs`, `FromFile`/`FromStream`/`FromImageSharp`) + and picks its back-end once per control in the private `ResolveRenderer()` + (line 375): `KittyImageRenderer` when the driver is an `IGraphicsProtocol` with + `SupportsKittyGraphics`, else `HalfBlockImageRenderer`. +- Detection is the framework's own — `Helpers/TerminalCapabilities.Probe()` sends a + real Kitty graphics query and falls back to `KITTY_PID`/`WEZTERM_PANE`. It runs at + driver init, so **do not read `SupportsKittyGraphics` in a constructor**; it is + still false there. +- **There is no Sixel anywhere in the framework** (`grep -i sixel` finds only a + "future back-ends" comment at `ImageControl.cs:266` and a row in + `docs/COMPARISON.md:132` conceding the gap to XenoAtom). + +**Why ours could not simply be swapped in.** Our `KittyGraphicsProtocol` and +`SixelEncoder` return escape-sequence *strings*. A compositor owns every cell and +re-diffs the screen each frame; `Cell` (`Layout/Cell.cs`) has no raw-escape field +and `AppendCombiner` (line 122) deliberately sanitises escapes out. The +framework's `KittyImageRenderer` works because it writes U+10EEEE placeholder +cells with combining diacritics — images become *real cells* that scroll and clip +like text, which is the approach `docs/PLAN.md:78` committed to. So the framework +renders, and `SharpMUTerm.Graphics` supplies the policy. + +**Consequence — a real gap, not a shortcut:** `IImageRenderer` is `internal` and +`ResolveRenderer()` is private, so **no Sixel back-end can be injected** into +`ImageControl` at this version. Inside the TUI the chain is therefore +Kitty → half-block → text, and `InlineImagePolicy` degrades a Sixel-only terminal +to half-block *explicitly* (with `Describe()` saying why) rather than silently. +Reopening Sixel means an upstream PR making `IImageRenderer` public and +`ResolveRenderer` overridable. + +**What is verified:** the selection logic and the whole fallback matrix +(`InlineImagePolicyTests`, 26 tests), the image index into the page +(`WebImageIndexTests`), sizing and gatekeeping (`WebImageLayoutTests`, +`WebImageLoaderTests`), the block split (`WebViewComposerTests`), and the seam end +to end (`WebInlineImageEndToEndTests`). Snapshots still render — the sandbox is the +no-graphics case, so that also proves degradation does not crash. + +**What is NOT verified:** that a Kitty image actually appears. Nobody has seen one. +Try `/web ` with images in Kitty/WezTerm/Ghostty; `/graphics` reports where the +chain landed and why. + +**Still open:** MXP/Pueblo `` are parsed but discarded +(`MxpParser.cs:379`, `PuebloParser.cs:308`) — routing those through the same seam +is the natural follow-up, as is an image-viewer tab for local files. ### 3. Live keyboard interaction for the config screens — navigation + toggles done @@ -296,4 +337,9 @@ Things that will waste your time if you don't know them. | `src/SharpMUTerm.Tui/ScreenEdits.cs` | The undo log behind Cancel/Save | | `src/SharpMUTerm.Tui/CommandPalette.cs` | ⌃P surface: content-hug sizing, clean chrome | | `src/SharpMUTerm.Tui/CommandSurfaceRenderer.cs` | Palette rows + full-width selection bar | +| `src/SharpMUTerm.Graphics/InlineImagePolicy.cs` | The degradation chain + `GraphicsSurface` (what the *host* can emit, vs what the terminal can show) | +| `src/SharpMUTerm.Tui/WebViewComposer.cs` | Splits a page into text/image blocks; no images → one control, unchanged | +| `src/SharpMUTerm.Tui/WebImageLayout.cs` | Cell sizing: what is worth drawing and how big it may get | +| `src/SharpMUTerm.Tui/WebImageLoader.cs` | Fetch + decode + downsample to the target cell box | +| `src/SharpMUTerm.Web/WebImage.cs` | An `` and the line its placeholder occupies | | `tools/fonts/OFL.txt`, `LICENSE-NerdFonts.txt` | Full bundled license texts | diff --git a/src/SharpMUTerm.Graphics/InlineImagePolicy.cs b/src/SharpMUTerm.Graphics/InlineImagePolicy.cs new file mode 100644 index 00000000..8e567aaa --- /dev/null +++ b/src/SharpMUTerm.Graphics/InlineImagePolicy.cs @@ -0,0 +1,139 @@ +namespace SharpMUTerm.Graphics; + +/// +/// How an inline image is actually put on screen, once both the terminal's capabilities and the +/// limits of the code drawing into it have been taken into account. Ordered by ascending fidelity +/// so a caller can compare presentations the way it compares . +/// +public enum InlineImagePresentation +{ + /// Nothing can be drawn; the caller's text placeholder stands in for the image. + TextPlaceholder = 0, + + /// Styled ▀ half-block cells — two stacked pixels per cell, works in any colour terminal. + HalfBlock = 1, + + /// A DEC Sixel escape sequence written straight at the cursor. + Sixel = 2, + + /// Kitty graphics: the image is transmitted once and shown through placeholder cells. + Kitty = 3, +} + +/// +/// What the code doing the drawing can physically emit. says what +/// the terminal can display; this says what the render host can hand it, and the two +/// are not the same thing. +/// +/// The distinction is load-bearing for a compositor-based TUI. A compositor owns every cell and +/// re-diffs the screen each frame, so it can carry Kitty images (they live in real character cells as +/// U+10EEEE placeholders, which scroll and clip like text) and half-blocks (ordinary styled glyphs), +/// but it has nowhere to put a raw Sixel blob: Sixel paints at the cursor outside the cell model, and +/// the next repaint would scribble over it. A surface that writes to the terminal directly, with no +/// compositor in between, has the opposite trade-off. +/// +public sealed class GraphicsSurface +{ + private GraphicsSurface(bool canPlaceKitty, bool canWriteRawEscapes, bool canStyleCells) + { + CanPlaceKitty = canPlaceKitty; + CanWriteRawEscapes = canWriteRawEscapes; + CanStyleCells = canStyleCells; + } + + /// True when the host can anchor a Kitty image into character cells. + public bool CanPlaceKitty { get; } + + /// True when the host can emit a raw escape sequence (Sixel) that survives to the next frame. + public bool CanWriteRawEscapes { get; } + + /// True when the host can emit foreground/background-coloured cells (needed for half-blocks). + public bool CanStyleCells { get; } + + /// + /// A compositor-based TUI such as SharpConsoleUI: coloured cells always, Kitty placements when + /// the driver reports the protocol, and never raw escapes. + /// + /// Whether the console driver reports Kitty graphics support. + public static GraphicsSurface Compositor(bool canPlaceKitty) => new(canPlaceKitty, false, true); + + /// Direct terminal output with no compositor in the way: anything the terminal accepts. + public static GraphicsSurface RawTerminal { get; } = new(true, true, true); + + /// A plain-text sink (a log file, an ANSI snapshot, a pipe): only the placeholder survives. + public static GraphicsSurface PlainText { get; } = new(false, false, false); +} + +/// +/// The degradation chain: Kitty → Sixel → half-block → text placeholder, with every rung the host +/// cannot deliver skipped rather than attempted. Pure, so the whole matrix is unit-testable without a +/// terminal — which matters, because the fallbacks are precisely the part no headless run can see. +/// +public static class InlineImagePolicy +{ + /// + /// Picks the best presentation the terminal and the host can both manage. + /// + /// + /// Selection keys off rather than the individual + /// capability flags, so an explicit SHARPMUTERM_GRAPHICS override still wins — the user + /// asked for it, and forcing a protocol on a terminal we failed to sniff is a legitimate thing + /// to want. Stepping down the chain is always safe: a terminal that speaks Kitty can + /// also draw half-blocks. + /// + public static InlineImagePresentation Select(TerminalCapabilities capabilities, GraphicsSurface surface) + { + ArgumentNullException.ThrowIfNull(capabilities); + ArgumentNullException.ThrowIfNull(surface); + + if (capabilities.Protocol >= GraphicsProtocol.Kitty && surface.CanPlaceKitty) + { + return InlineImagePresentation.Kitty; + } + + if (capabilities.Protocol >= GraphicsProtocol.Sixel && surface.CanWriteRawEscapes) + { + return InlineImagePresentation.Sixel; + } + + if (capabilities.Protocol >= GraphicsProtocol.HalfBlock && surface.CanStyleCells) + { + return InlineImagePresentation.HalfBlock; + } + + return InlineImagePresentation.TextPlaceholder; + } + + /// + /// A one-line, user-facing account of the choice, naming the reason whenever the host had to + /// degrade below what the terminal itself offers. Shown by /graphics so a puzzled user + /// gets "Sixel is not available inside the TUI" instead of a silently worse picture. + /// + public static string Describe(TerminalCapabilities capabilities, GraphicsSurface surface) + { + ArgumentNullException.ThrowIfNull(capabilities); + ArgumentNullException.ThrowIfNull(surface); + + var chosen = Select(capabilities, surface); + var detected = capabilities.Protocol; + + if (chosen == InlineImagePresentation.TextPlaceholder) + { + return detected == GraphicsProtocol.None + ? "no inline graphics detected — images show as text placeholders" + : $"{detected} detected, but this view cannot draw images — text placeholders only"; + } + + if ((int)chosen == (int)detected) + { + return $"inline images render via {chosen}"; + } + + // The terminal offers more than the host can carry. Name the rung that was skipped. + var reason = detected == GraphicsProtocol.Sixel && !surface.CanWriteRawEscapes + ? "Sixel cannot be drawn inside the compositor" + : $"{detected} is unavailable here"; + + return $"inline images render via {chosen} ({reason})"; + } +} diff --git a/src/SharpMUTerm.Tui/SharpMUTermApp.cs b/src/SharpMUTerm.Tui/SharpMUTermApp.cs index 8da90735..d7447e1b 100644 --- a/src/SharpMUTerm.Tui/SharpMUTermApp.cs +++ b/src/SharpMUTerm.Tui/SharpMUTermApp.cs @@ -15,6 +15,10 @@ using SharpConsoleUI.Events; using SharpConsoleUI.Layout; using SColor = SharpConsoleUI.Color; +// Aliased rather than a plain using: SharpConsoleUI.Imaging also has a HalfBlockRenderer, which +// would collide with SharpMUTerm.Graphics'. +using PixelBuffer = SharpConsoleUI.Imaging.PixelBuffer; +using ImageScaleMode = SharpConsoleUI.Imaging.ImageScaleMode; using static SharpMUTerm.Tui.MarkupText; namespace SharpMUTerm.Tui; @@ -66,6 +70,23 @@ internal sealed class SharpMUTermApp : IAsyncDisposable private readonly PromptControl _input; private readonly GmcpStats _stats = new(); private readonly SharpMUTerm.Web.WebPageFetcher _fetcher = new(); + private readonly WebImageLoader _imageLoader = new(); + + /// + /// The web page currently in the web tab, its markup lines, and the images that decoded — keyed + /// by index into . Together these are everything + /// needs; an empty image map means the tab is the plain text-mode + /// page it has always been. + /// + private SharpMUTerm.Web.WebPage? _webPage; + private IReadOnlyList _webMarkup = Array.Empty(); + private readonly Dictionary _webImages = new(); + + /// + /// Cancels the in-flight image fetches of a superseded page. Loading is per-page and a new + /// navigation invalidates the old one's images outright. + /// + private CancellationTokenSource? _webImageCts; private readonly CommandPalette _palette; private readonly SettingsOverlay _settings; @@ -657,6 +678,17 @@ private void OnCommandEntered(string command) return; } + // `/graphics` reports where the degradation chain settled and, when it degraded, why — so a + // missing picture is an explanation rather than a mystery. + if (command.Trim().Equals("/graphics", StringComparison.OrdinalIgnoreCase)) + { + // Appended to the window rather than routed through the session, so it still answers + // when nothing is connected — which is exactly when someone is checking their terminal. + var report = InlineImagePolicy.Describe(_capabilities, WebGraphicsSurface()); + AppendWindowLine(windowId, $"[dim]*** Graphics: {Escape(report)}.[/]"); + return; + } + _ = _active?.SendUserInputAsync(command); } @@ -1333,13 +1365,179 @@ private void ShowWeb(SharpMUTerm.Web.WebPage page) _workspace.FindWindow(WebWindowId)!.Title = title; } - PaneContentFor(WebWindowId, title).SetContent(page.Lines.Select(_formatter.ToMarkup).ToList()); + // A new page invalidates the previous one's images, in flight or already decoded. + _webImageCts?.Cancel(); + _webImageCts?.Dispose(); + _webImageCts = null; + _webImages.Clear(); + + _webPage = page; + _webMarkup = page.Lines.Select(_formatter.ToMarkup).ToList(); + PaneContentFor(WebWindowId, title).SetContent(_webMarkup.ToList()); if (isNew) { RebuildPaneArea(); // realise the new tab before activating it } Activate(WebWindowId); + StartWebImageLoad(page); + } + + /// + /// Kicks off the background fetch/decode of a page's inline images, but only when this view can + /// actually draw one. With no graphics the placeholders the HTML renderer already emitted are the + /// finished product, so nothing is fetched at all — a terminal without graphics does not pay for + /// images it cannot show. + /// + private void StartWebImageLoad(SharpMUTerm.Web.WebPage page) + { + if (page.Images.Count == 0 || + ResolveInlineImagePresentation() == InlineImagePresentation.TextPlaceholder) + { + return; + } + + var cts = new CancellationTokenSource(); + _webImageCts = cts; + _ = LoadWebImagesAsync(page, WebImageColumns(), cts.Token); + } + + /// + /// Fetches each of a page's images in turn and folds the ones that decode back into the view. + /// Each arrival repaints on its own rather than the page waiting on the whole set, so pictures + /// fill in progressively where their placeholders were. Sequential on purpose: a MU* client has + /// no business opening a dozen simultaneous connections to whatever host a page names. + /// + private async Task LoadWebImagesAsync( + SharpMUTerm.Web.WebPage page, int columns, CancellationToken cancellationToken) + { + for (var i = 0; i < page.Images.Count && i < MaxInlineWebImages; i++) + { + if (cancellationToken.IsCancellationRequested) + { + return; + } + + PixelBuffer? buffer; + try + { + buffer = await _imageLoader + .LoadAsync(page.Images[i].Source, columns, cancellationToken) + .ConfigureAwait(false); + } + catch (OperationCanceledException) + { + return; + } + + if (buffer is null || cancellationToken.IsCancellationRequested) + { + continue; // the placeholder line stays put — a perfectly good outcome + } + + var index = i; + var decoded = buffer; + OnUi(() => + { + // The page may have been replaced while this image was in flight. + if (cancellationToken.IsCancellationRequested || !ReferenceEquals(_webPage, page)) + { + return; + } + + _webImages[index] = decoded; + RebuildPaneArea(); + }); + } + } + + /// How many images one page may draw, so an image-heavy page cannot stall the client. + private const int MaxInlineWebImages = 12; + + /// Columns an inline web image may span, leaving room for the rail and pane chrome. + private int WebImageColumns() => Math.Clamp(_window.Width - 8, 8, 200); + + /// + /// What this view can actually put on screen. Asked fresh rather than cached in the constructor: + /// the console driver only knows whether the terminal speaks Kitty graphics after it has + /// initialised and run its capability probe. + /// + private GraphicsSurface WebGraphicsSurface() => + GraphicsSurface.Compositor(_system.ConsoleDriver is IGraphicsProtocol { SupportsKittyGraphics: true }); + + /// The presentation the degradation chain settles on for this terminal and this view. + private InlineImagePresentation ResolveInlineImagePresentation() => + InlineImagePolicy.Select(_capabilities, WebGraphicsSurface()); + + /// + /// Builds the web tab: the page's markup split around whichever images decoded, stacked in a + /// scrollable panel. With no decoded images this is a single markup control holding every line — + /// exactly the control the web view used before images existed. + /// + private IWindowControl BuildWebContent(string title) + { + var live = PaneContentFor(WebWindowId, title); + if (_webPage is null || _webImages.Count == 0) + { + return live; + } + + var boxes = new Dictionary(); + foreach (var (index, buffer) in _webImages) + { + boxes[index] = new WebImageLayout.CellBox(buffer.Width, Math.Max(1, buffer.Height / WebImageLayout.PixelsPerCell)); + } + + var blocks = WebViewComposer.Compose(_webMarkup, _webPage.Images, boxes); + var panel = Controls.ScrollablePanel() + .WithAlignment(HorizontalAlignment.Stretch) + .WithVerticalAlignment(VerticalAlignment.Fill); + + var usedLiveControl = false; + foreach (var block in blocks) + { + switch (block) + { + case WebTextBlock text: + // Reuse the window's own control for the first run so link routing and the + // pane's identity survive; later runs get plain markup controls with the same + // link handler. + if (!usedLiveControl) + { + usedLiveControl = true; + live.SetContent(text.Lines.ToList()); + panel.AddControl(live); + } + else + { + // Later runs mirror PaneContentFor's plain control, link routing included, + // so a link reads the same wherever on the page it sits. + var markup = new MarkupControl(text.Lines.ToList()); + markup.LinkClicked += (_, e) => OnLinkClicked(e.Url); + panel.AddControl(markup); + } + + break; + + case WebImageBlock image: + panel.AddControl(new ImageControl + { + Source = _webImages[image.Index], + ScaleMode = ImageScaleMode.Fit, + MinimumHeight = image.Box.Rows, + }); + break; + } + } + + if (!usedLiveControl) + { + // An all-image page: the window still needs its own control in the tree. + live.SetContent(new List()); + panel.AddControl(live); + } + + return panel.Build(); } /// The content control for a window, created (with link routing) on first use. @@ -1583,6 +1781,11 @@ private IWindowControl BuildTabContent(PaneNode pane, string windowId, Workspace return BuildSpawnContent(windowId, window); } + if (windowId == WebWindowId) + { + return BuildWebContent(window.Title); + } + return PaneContentFor(windowId, window.Title); } @@ -2304,6 +2507,9 @@ private static Theme ResolveTheme(AppConfiguration config) public async ValueTask DisposeAsync() { _system.ConsoleDriver.MouseEvent -= OnDriverMouseEvent; + _webImageCts?.Cancel(); + _webImageCts?.Dispose(); + _imageLoader.Dispose(); _fetcher.Dispose(); await _sessions.DisposeAsync().ConfigureAwait(false); } diff --git a/src/SharpMUTerm.Tui/WebImageLayout.cs b/src/SharpMUTerm.Tui/WebImageLayout.cs new file mode 100644 index 00000000..2c9b0fa1 --- /dev/null +++ b/src/SharpMUTerm.Tui/WebImageLayout.cs @@ -0,0 +1,69 @@ +namespace SharpMUTerm.Tui; + +/// +/// Cell arithmetic for an inline web image: whether a decoded image is worth drawing at all, and the +/// cell box it should occupy. Pure, so the sizing rules are unit-testable without a terminal — and +/// they need to be, because getting them wrong is how one photo eats a whole page. +/// +/// The unit conversion throughout is the half-block one the framework also uses: a character +/// cell carries one pixel horizontally and two vertically, which lands close enough to square given +/// how much taller than wide a terminal cell is. +/// +internal static class WebImageLayout +{ + /// Vertical pixels carried by one character cell (the ▀ half-block split). + public const int PixelsPerCell = 2; + + /// Tallest an inline image may be, so one picture cannot push a whole article offscreen. + public const int MaxRows = 20; + + /// + /// Smallest edge worth drawing. Below this an image is a spacer, a tracking pixel, or a bullet + /// glyph — all of which read better as their text placeholder than as a smear of colour. + /// + public const int MinimumPixelEdge = 16; + + /// A cell box for an inline image. + /// Width in character cells. + /// Height in character cells. + internal readonly record struct CellBox(int Columns, int Rows); + + /// + /// True when a decoded image is large enough to be worth showing. Rejects anything with a + /// degenerate or tiny edge. + /// + public static bool IsWorthRendering(int pixelWidth, int pixelHeight) => + pixelWidth >= MinimumPixelEdge && pixelHeight >= MinimumPixelEdge; + + /// + /// Fits an image into the available cell box, preserving aspect ratio and never upscaling — + /// matching the framework's ImageScaleMode.Fit, so the box we reserve is the box the + /// control actually claims. + /// + /// Decoded image width in pixels. + /// Decoded image height in pixels. + /// Columns the pane can spare. + /// Row ceiling; defaults to . + public static CellBox Fit(int pixelWidth, int pixelHeight, int availableColumns, int maxRows = MaxRows) + { + if (pixelWidth <= 0 || pixelHeight <= 0 || availableColumns <= 0 || maxRows <= 0) + { + return new CellBox(0, 0); + } + + var naturalColumns = pixelWidth; + var naturalRows = (pixelHeight + PixelsPerCell - 1) / PixelsPerCell; + + // Fit never enlarges, so the usable box is clamped to the image's own size first. + var boundedColumns = Math.Min(naturalColumns, availableColumns); + var boundedRows = Math.Min(naturalRows, maxRows); + + var scale = Math.Min( + (double)boundedColumns / naturalColumns, + (double)boundedRows / naturalRows); + + return new CellBox( + Math.Max(1, (int)(naturalColumns * scale)), + Math.Max(1, (int)(naturalRows * scale))); + } +} diff --git a/src/SharpMUTerm.Tui/WebImageLoader.cs b/src/SharpMUTerm.Tui/WebImageLoader.cs new file mode 100644 index 00000000..e4d84224 --- /dev/null +++ b/src/SharpMUTerm.Tui/WebImageLoader.cs @@ -0,0 +1,217 @@ +using System.Net; +using SharpConsoleUI.Imaging; + +namespace SharpMUTerm.Tui; + +/// +/// Fetches an inline web image and decodes it into a framework , resized to +/// the cell box it will occupy. Deliberately conservative in the same spirit as +/// WebPageFetcher: http(s) and data: only, an image content type, a byte cap, and a +/// timeout, so a hostile page cannot hang the client or exhaust it. +/// +/// The resize happens here rather than at paint time on purpose. The framework's +/// ImageControl measures to its source's natural size when the layout constraint is unbounded +/// (as it is inside a scrollable panel), so handing it a 1200-pixel-wide photo would have it claim +/// 1200 columns. Downsampling first makes the control's natural size the size we actually want, and +/// caps what the Kitty encoder has to PNG on every source change. +/// +/// Every failure path returns null. A null simply means the placeholder line stays — +/// there is no error state to render, because a text-mode browser showing [image: a cat] is a +/// perfectly good outcome. +/// +internal sealed class WebImageLoader : IDisposable +{ + /// Refuse anything larger than this; big images are slow to decode and worse to look at. + public const long MaxImageBytes = 8 * 1024 * 1024; + + private readonly HttpClient _http; + private readonly bool _ownsClient; + + public WebImageLoader(HttpClient? httpClient = null) + { + _ownsClient = httpClient is null; + _http = httpClient ?? new HttpClient(new HttpClientHandler + { + AutomaticDecompression = DecompressionMethods.All, + AllowAutoRedirect = true, + MaxAutomaticRedirections = 5, + }) + { + Timeout = TimeSpan.FromSeconds(15), + }; + + if (!_http.DefaultRequestHeaders.UserAgent.TryParseAdd( + "SharpMUTerm/0.1 (+https://github.com/SharpMUSH/SharpMUTerm)")) + { + // A restrictive HttpClient may reject the header; not fatal. + } + } + + /// + /// Fetches, decodes, and downsamples an image to fit . + /// Returns null when the URL is unusable, the fetch fails, the payload is not a decodable + /// image, or the result would be too small to be worth drawing. + /// + public async Task LoadAsync( + string url, int availableColumns, CancellationToken cancellationToken = default) + { + var bytes = await FetchAsync(url, cancellationToken).ConfigureAwait(false); + if (bytes is null) + { + return null; + } + + return Decode(bytes, availableColumns); + } + + /// + /// Decodes image bytes and downsamples to the target box. Split out from the fetch so the sizing + /// half is testable without a network. + /// + public static PixelBuffer? Decode(byte[] imageBytes, int availableColumns) + { + ArgumentNullException.ThrowIfNull(imageBytes); + if (imageBytes.Length == 0 || availableColumns <= 0) + { + return null; + } + + PixelBuffer decoded; + try + { + using var stream = new MemoryStream(imageBytes, writable: false); + decoded = PixelBuffer.FromStream(stream); + } + catch (Exception ex) when (ex is not OutOfMemoryException) + { + // Corrupt payload, unsupported format, or past the framework's dimension ceiling. + return null; + } + + if (!WebImageLayout.IsWorthRendering(decoded.Width, decoded.Height)) + { + return null; + } + + var box = WebImageLayout.Fit(decoded.Width, decoded.Height, availableColumns); + if (box.Columns <= 0 || box.Rows <= 0) + { + return null; + } + + var targetPixelHeight = box.Rows * WebImageLayout.PixelsPerCell; + if (box.Columns == decoded.Width && targetPixelHeight == decoded.Height) + { + return decoded; + } + + try + { + return decoded.Resize(box.Columns, targetPixelHeight); + } + catch (ArgumentOutOfRangeException) + { + return null; + } + } + + private async Task FetchAsync(string url, CancellationToken cancellationToken) + { + if (string.IsNullOrWhiteSpace(url)) + { + return null; + } + + if (url.StartsWith("data:", StringComparison.OrdinalIgnoreCase)) + { + return ParseDataUri(url); + } + + if (!Uri.TryCreate(url, UriKind.Absolute, out var uri) || uri.Scheme is not ("http" or "https")) + { + return null; + } + + try + { + using var response = await _http + .GetAsync(uri, HttpCompletionOption.ResponseHeadersRead, cancellationToken) + .ConfigureAwait(false); + + if (!response.IsSuccessStatusCode) + { + return null; + } + + var mediaType = response.Content.Headers.ContentType?.MediaType ?? string.Empty; + if (!IsDecodableImageType(mediaType)) + { + return null; + } + + if (response.Content.Headers.ContentLength > MaxImageBytes) + { + return null; + } + + var bytes = await response.Content.ReadAsByteArrayAsync(cancellationToken).ConfigureAwait(false); + return bytes.Length > MaxImageBytes ? null : bytes; + } + catch (Exception ex) when (ex is HttpRequestException or TaskCanceledException or InvalidOperationException) + { + return null; + } + } + + /// + /// True for raster image media types the decoder can actually handle. SVG is excluded: it is an + /// image/* type that ImageSharp cannot rasterise, so accepting it would only ever produce + /// a failed decode. + /// + public static bool IsDecodableImageType(string mediaType) => + mediaType.StartsWith("image/", StringComparison.OrdinalIgnoreCase) && + !mediaType.Contains("svg", StringComparison.OrdinalIgnoreCase); + + /// Decodes a base64 data: URI. Non-base64 and malformed URIs yield null. + public static byte[]? ParseDataUri(string dataUri) + { + ArgumentNullException.ThrowIfNull(dataUri); + + var comma = dataUri.IndexOf(','); + if (comma < 0) + { + return null; + } + + var header = dataUri[..comma]; + var payload = dataUri[(comma + 1)..]; + + if (!header.Contains(";base64", StringComparison.OrdinalIgnoreCase)) + { + return null; + } + + // Base64 expands 3 bytes into 4 characters, so cap the encoded form proportionally. + if (payload.Length > (MaxImageBytes / 3) * 4) + { + return null; + } + + try + { + return Convert.FromBase64String(payload); + } + catch (FormatException) + { + return null; + } + } + + public void Dispose() + { + if (_ownsClient) + { + _http.Dispose(); + } + } +} diff --git a/src/SharpMUTerm.Tui/WebViewComposer.cs b/src/SharpMUTerm.Tui/WebViewComposer.cs new file mode 100644 index 00000000..44d147ee --- /dev/null +++ b/src/SharpMUTerm.Tui/WebViewComposer.cs @@ -0,0 +1,109 @@ +using SharpMUTerm.Web; + +namespace SharpMUTerm.Tui; + +/// One run of a rendered web page: either a stretch of markup lines or an inline image. +internal abstract record WebBlock; + +/// A run of consecutive markup lines, rendered by a single markup control. +/// The markup lines, in order. +internal sealed record WebTextBlock(IReadOnlyList Lines) : WebBlock; + +/// +/// An image that replaces its placeholder line. Carries the cell box the picture will occupy so the +/// host can reserve exactly that much room. +/// +/// Index into the page's image list, so the host can find the decoded pixels. +/// The source image, as found by the HTML renderer. +/// The cell box the image claims. +internal sealed record WebImageBlock(int Index, WebImage Image, WebImageLayout.CellBox Box) : WebBlock; + +/// +/// Splits a rendered web page into the alternating text/image runs the web view is built from. +/// Pure: it is handed the lines, the image index, and the boxes of the images that actually decoded, +/// and it decides nothing about protocols or terminals. +/// +/// The degraded case is the important one and it is deliberately the cheapest: with no +/// renderable images the result is a single text block holding every line, byte-identical to the +/// pre-existing single-control web view. Placeholders stay exactly where the HTML renderer put +/// them. +/// +internal static class WebViewComposer +{ + /// + /// Composes the page into blocks. + /// + /// The page's lines, already converted to markup. + /// Every indexed image on the page, in document order. + /// + /// Cell boxes keyed by index into , holding only the images that + /// decoded and are worth drawing. Images missing from this map keep their placeholder line. + /// + public static IReadOnlyList Compose( + IReadOnlyList markupLines, + IReadOnlyList images, + IReadOnlyDictionary boxes) + { + ArgumentNullException.ThrowIfNull(markupLines); + ArgumentNullException.ThrowIfNull(images); + ArgumentNullException.ThrowIfNull(boxes); + + // Only images that decoded, point at a real line, and haven't already claimed that line. + var claimed = new HashSet(); + var placements = new List<(int Line, WebImageBlock Block)>(); + for (var i = 0; i < images.Count; i++) + { + if (!boxes.TryGetValue(i, out var box)) + { + continue; + } + + var line = images[i].LineIndex; + if (line < 0 || line >= markupLines.Count || !claimed.Add(line)) + { + continue; + } + + placements.Add((line, new WebImageBlock(i, images[i], box))); + } + + if (placements.Count == 0) + { + // Nothing to draw: one control, one list of lines — the plain text-mode page. + return new WebBlock[] { new WebTextBlock(markupLines) }; + } + + placements.Sort(static (a, b) => a.Line.CompareTo(b.Line)); + + var blocks = new List(); + var cursor = 0; + foreach (var (line, block) in placements) + { + if (line > cursor) + { + blocks.Add(new WebTextBlock(Slice(markupLines, cursor, line))); + } + + blocks.Add(block); + cursor = line + 1; // the placeholder line is consumed by the picture + } + + if (cursor < markupLines.Count) + { + blocks.Add(new WebTextBlock(Slice(markupLines, cursor, markupLines.Count))); + } + + return blocks; + } + + private static IReadOnlyList Slice(IReadOnlyList lines, int start, int end) + { + var slice = new string[end - start]; + for (var i = 0; i < slice.Length; i++) + { + slice[i] = lines[start + i]; + } + + return slice; + } +} diff --git a/src/SharpMUTerm.Web/HtmlStyledRenderer.cs b/src/SharpMUTerm.Web/HtmlStyledRenderer.cs index 7295c92f..1a897958 100644 --- a/src/SharpMUTerm.Web/HtmlStyledRenderer.cs +++ b/src/SharpMUTerm.Web/HtmlStyledRenderer.cs @@ -32,14 +32,24 @@ public sealed class HtmlStyledRenderer TextStyle.Default.WithForeground(TerminalColor.FromIndex(11)).AddAttribute(TextAttributes.Bold); private readonly string? _baseUrl; + private readonly List _images = new(); private int _width = 80; public HtmlStyledRenderer(string? baseUrl = null) => _baseUrl = baseUrl; - public IReadOnlyList Render(string html, int width = 80) + /// Renders the document to styled lines, discarding the image index. + public IReadOnlyList Render(string html, int width = 80) => RenderDocument(html, width).Lines; + + /// + /// Renders the document to styled lines and the list of <img> elements it + /// contains, each pointing at the line holding its placeholder. A graphics-capable view uses the + /// index to swap placeholders for real pictures; everything else just renders the lines. + /// + public HtmlRenderResult RenderDocument(string html, int width = 80) { ArgumentNullException.ThrowIfNull(html); _width = Math.Max(20, width); + _images.Clear(); var document = new HtmlParser().ParseDocument(html); var writer = new LineWriter(_width); INode? root = document.Body ?? document.DocumentElement; @@ -51,7 +61,7 @@ public IReadOnlyList Render(string html, int width = 80) } } - return writer.Finish(); + return new HtmlRenderResult(writer.Finish(), _images.ToArray()); } /// Extracts the document title, if any. @@ -95,11 +105,7 @@ private void WalkElement(IElement element, LineWriter writer, TextStyle style, S writer.BlankLine(); return; case "img": - var alt = element.GetAttribute("alt"); - var label = string.IsNullOrWhiteSpace(alt) ? "[image]" : $"[image: {alt}]"; - var src = element.GetAttribute("src"); - var imgLink = string.IsNullOrWhiteSpace(src) ? null : SpanInteraction.Link(Resolve(src)); - writer.AddText(label, style.AddAttribute(TextAttributes.Italic), imgLink, preformatted); + EmitImage(element, writer, style, preformatted); return; } @@ -169,6 +175,32 @@ private void WalkElement(IElement element, LineWriter writer, TextStyle style, S } } + /// + /// Writes an image's text placeholder and records where it landed. The placeholder gets a line + /// to itself: a graphics-capable view replaces that whole row with the picture, which it can only + /// do if no surrounding prose shares the row. Images with no src still get a placeholder — + /// there is just nothing to fetch, so they are not indexed. + /// + private void EmitImage(IElement element, LineWriter writer, TextStyle style, bool preformatted) + { + var alt = element.GetAttribute("alt"); + var label = string.IsNullOrWhiteSpace(alt) ? "[image]" : $"[image: {alt}]"; + var src = element.GetAttribute("src"); + var hasSource = !string.IsNullOrWhiteSpace(src); + var resolved = hasSource ? Resolve(src!) : null; + + writer.EndLine(); + var lineIndex = writer.LineIndex; + var imgLink = resolved is null ? null : SpanInteraction.Link(resolved); + writer.AddText(label, style.AddAttribute(TextAttributes.Italic), imgLink, preformatted); + writer.EndLine(); + + if (resolved is not null) + { + _images.Add(new WebImage(lineIndex, resolved, alt?.Trim() is { Length: > 0 } a ? a : null, label)); + } + } + private static TextStyle MergeLinkStyle(TextStyle style) => style.WithForeground(LinkStyle.Foreground).AddAttribute(TextAttributes.Underline); diff --git a/src/SharpMUTerm.Web/LineWriter.cs b/src/SharpMUTerm.Web/LineWriter.cs index 3a092182..72ce50d1 100644 --- a/src/SharpMUTerm.Web/LineWriter.cs +++ b/src/SharpMUTerm.Web/LineWriter.cs @@ -17,6 +17,14 @@ internal sealed class LineWriter(int width) private bool _lineHasContent; private bool _pendingSpace; + /// + /// The index the line currently being built will occupy in the finished list. Stable once the + /// line has content: only ever appends after it, and + /// only trims trailing empty lines. Callers that need to point + /// back at a line they are about to write (an image placeholder, say) read this first. + /// + public int LineIndex => _lines.Count; + public void AddText(string text, TextStyle style, SpanInteraction? link, bool preformatted) { if (string.IsNullOrEmpty(text)) diff --git a/src/SharpMUTerm.Web/WebImage.cs b/src/SharpMUTerm.Web/WebImage.cs new file mode 100644 index 00000000..0cd6923c --- /dev/null +++ b/src/SharpMUTerm.Web/WebImage.cs @@ -0,0 +1,21 @@ +using SharpMUTerm.Core.Text; + +namespace SharpMUTerm.Web; + +/// +/// An <img> the renderer met, and the line its text placeholder occupies in the rendered +/// page. A view with inline graphics replaces exactly that line with the decoded picture; a view +/// without them leaves the placeholder where it is, which is why the placeholder is always emitted. +/// +/// Index into of the placeholder line. +/// The image URL, already resolved against the page's base URL. +/// The alt text, or null when the element carried none. +/// The text shown in place of the image (e.g. [image: a cat]). +public sealed record WebImage(int LineIndex, string Source, string? Alt, string PlaceholderText); + +/// +/// The full result of rendering an HTML document: the styled lines plus the images found in them. +/// +/// The page as styled text lines. +/// Every <img> with a usable src, in document order. +public sealed record HtmlRenderResult(IReadOnlyList Lines, IReadOnlyList Images); diff --git a/src/SharpMUTerm.Web/WebPage.cs b/src/SharpMUTerm.Web/WebPage.cs index 8e6bae2f..817e6d01 100644 --- a/src/SharpMUTerm.Web/WebPage.cs +++ b/src/SharpMUTerm.Web/WebPage.cs @@ -2,14 +2,15 @@ namespace SharpMUTerm.Web; -/// A fetched-and-rendered web page: its title, source URL, and styled lines. +/// A fetched-and-rendered web page: its title, source URL, styled lines, and inline images. public sealed class WebPage { - public WebPage(string url, string? title, IReadOnlyList lines) + public WebPage(string url, string? title, IReadOnlyList lines, IReadOnlyList? images = null) { Url = url; Title = title; Lines = lines; + Images = images ?? Array.Empty(); } public string Url { get; } @@ -18,6 +19,12 @@ public WebPage(string url, string? title, IReadOnlyList lines) public IReadOnlyList Lines { get; } + /// + /// The page's <img> elements, each naming the line its placeholder occupies. Empty + /// for non-HTML responses and error pages. + /// + public IReadOnlyList Images { get; } + public static WebPage Error(string url, string message) => new(url, "Error", new[] { StyledLine.FromText(message, TextStyle.Default.WithForeground(TerminalColor.FromIndex(9))) }); } diff --git a/src/SharpMUTerm.Web/WebPageFetcher.cs b/src/SharpMUTerm.Web/WebPageFetcher.cs index 732e4757..91569b69 100644 --- a/src/SharpMUTerm.Web/WebPageFetcher.cs +++ b/src/SharpMUTerm.Web/WebPageFetcher.cs @@ -54,8 +54,9 @@ public async Task FetchAsync(string url, int width = 80, CancellationTo if (contentType.Contains("html", StringComparison.OrdinalIgnoreCase) || contentType.Length == 0) { var renderer = new HtmlStyledRenderer(finalUri.ToString()); - var lines = renderer.Render(body, width); - return new WebPage(finalUri.ToString(), HtmlStyledRenderer.GetTitle(body), lines); + var rendered = renderer.RenderDocument(body, width); + return new WebPage( + finalUri.ToString(), HtmlStyledRenderer.GetTitle(body), rendered.Lines, rendered.Images); } // Non-HTML: render as plain text lines. diff --git a/tests/SharpMUTerm.Graphics.Tests/InlineImagePolicyTests.cs b/tests/SharpMUTerm.Graphics.Tests/InlineImagePolicyTests.cs new file mode 100644 index 00000000..ec316c9e --- /dev/null +++ b/tests/SharpMUTerm.Graphics.Tests/InlineImagePolicyTests.cs @@ -0,0 +1,182 @@ +using SharpMUTerm.Graphics; + +namespace SharpMUTerm.Graphics.Tests; + +/// +/// The degradation chain is the part of the graphics layer a headless run can actually verify, so it +/// is covered exhaustively: every against every surface shape. +/// +public class InlineImagePolicyTests +{ + private static TerminalCapabilities Caps(GraphicsProtocol protocol) => + new(protocol, + supportsTrueColor: protocol >= GraphicsProtocol.HalfBlock, + supportsKittyGraphics: protocol == GraphicsProtocol.Kitty, + supportsSixel: protocol == GraphicsProtocol.Sixel); + + // ---- The full protocol × surface matrix ------------------------------------------------- + + [Test] + [Arguments(GraphicsProtocol.Kitty, InlineImagePresentation.Kitty)] + [Arguments(GraphicsProtocol.Sixel, InlineImagePresentation.Sixel)] + [Arguments(GraphicsProtocol.HalfBlock, InlineImagePresentation.HalfBlock)] + [Arguments(GraphicsProtocol.None, InlineImagePresentation.TextPlaceholder)] + public async Task RawTerminal_UsesEveryProtocolAsDetected( + GraphicsProtocol protocol, InlineImagePresentation expected) + { + var chosen = InlineImagePolicy.Select(Caps(protocol), GraphicsSurface.RawTerminal); + await Assert.That(chosen).IsEqualTo(expected); + } + + [Test] + [Arguments(GraphicsProtocol.Kitty, InlineImagePresentation.Kitty)] + [Arguments(GraphicsProtocol.Sixel, InlineImagePresentation.HalfBlock)] + [Arguments(GraphicsProtocol.HalfBlock, InlineImagePresentation.HalfBlock)] + [Arguments(GraphicsProtocol.None, InlineImagePresentation.TextPlaceholder)] + public async Task KittyCapableCompositor_CarriesKittyButDropsSixelToHalfBlock( + GraphicsProtocol protocol, InlineImagePresentation expected) + { + var chosen = InlineImagePolicy.Select(Caps(protocol), GraphicsSurface.Compositor(canPlaceKitty: true)); + await Assert.That(chosen).IsEqualTo(expected); + } + + [Test] + [Arguments(GraphicsProtocol.Kitty, InlineImagePresentation.HalfBlock)] + [Arguments(GraphicsProtocol.Sixel, InlineImagePresentation.HalfBlock)] + [Arguments(GraphicsProtocol.HalfBlock, InlineImagePresentation.HalfBlock)] + [Arguments(GraphicsProtocol.None, InlineImagePresentation.TextPlaceholder)] + public async Task CompositorWithoutKittyDriver_AlwaysLandsOnHalfBlock( + GraphicsProtocol protocol, InlineImagePresentation expected) + { + var chosen = InlineImagePolicy.Select(Caps(protocol), GraphicsSurface.Compositor(canPlaceKitty: false)); + await Assert.That(chosen).IsEqualTo(expected); + } + + [Test] + [Arguments(GraphicsProtocol.Kitty)] + [Arguments(GraphicsProtocol.Sixel)] + [Arguments(GraphicsProtocol.HalfBlock)] + [Arguments(GraphicsProtocol.None)] + public async Task PlainTextSurface_NeverDrawsAnything(GraphicsProtocol protocol) + { + var chosen = InlineImagePolicy.Select(Caps(protocol), GraphicsSurface.PlainText); + await Assert.That(chosen).IsEqualTo(InlineImagePresentation.TextPlaceholder); + } + + // ---- Invariants over the whole matrix --------------------------------------------------- + + [Test] + public async Task ChosenPresentation_NeverExceedsWhatTheTerminalDetected() + { + var surfaces = new[] + { + GraphicsSurface.RawTerminal, + GraphicsSurface.Compositor(canPlaceKitty: true), + GraphicsSurface.Compositor(canPlaceKitty: false), + GraphicsSurface.PlainText, + }; + + foreach (var protocol in Enum.GetValues()) + { + foreach (var surface in surfaces) + { + var chosen = InlineImagePolicy.Select(Caps(protocol), surface); + await Assert.That((int)chosen) + .IsLessThanOrEqualTo((int)protocol) + .Because($"{protocol} on this surface must not upgrade to {chosen}"); + } + } + } + + [Test] + public async Task NoProtocol_AlwaysEndsAtTheTextPlaceholder() + { + // The sandbox — and any pipe, dumb terminal, or CI job — is exactly this case. + var chosen = InlineImagePolicy.Select(Caps(GraphicsProtocol.None), GraphicsSurface.RawTerminal); + await Assert.That(chosen).IsEqualTo(InlineImagePresentation.TextPlaceholder); + } + + // ---- The explicit override still wins --------------------------------------------------- + + [Test] + public async Task ForcedKitty_IsHonouredEvenWhenNoFlagWasSniffed() + { + // SHARPMUTERM_GRAPHICS=kitty forces Protocol without setting SupportsKittyGraphics; the + // policy reads Protocol, so the user's override is not quietly discarded. + var forced = new TerminalCapabilities( + GraphicsProtocol.Kitty, supportsTrueColor: false, supportsKittyGraphics: false, supportsSixel: false); + + var chosen = InlineImagePolicy.Select(forced, GraphicsSurface.Compositor(canPlaceKitty: true)); + await Assert.That(chosen).IsEqualTo(InlineImagePresentation.Kitty); + } + + [Test] + public async Task ForcedNone_SuppressesGraphicsOnAFullyCapableTerminal() + { + var forced = new TerminalCapabilities( + GraphicsProtocol.None, supportsTrueColor: true, supportsKittyGraphics: true, supportsSixel: true); + + var chosen = InlineImagePolicy.Select(forced, GraphicsSurface.RawTerminal); + await Assert.That(chosen).IsEqualTo(InlineImagePresentation.TextPlaceholder); + } + + [Test] + public async Task OverrideFlowsFromTheProbeThroughThePolicy() + { + // End to end over the real probe: env → capabilities → presentation. + var env = new Dictionary(StringComparer.Ordinal) + { + ["SHARPMUTERM_GRAPHICS"] = "halfblock", + ["TERM"] = "xterm-kitty", + }; + + var caps = CapabilityProbe.Detect(env); + var chosen = InlineImagePolicy.Select(caps, GraphicsSurface.Compositor(canPlaceKitty: true)); + await Assert.That(chosen).IsEqualTo(InlineImagePresentation.HalfBlock); + } + + // ---- Descriptions ----------------------------------------------------------------------- + + [Test] + public async Task Describe_NamesSixelAsTheReasonForDegradingInsideTheCompositor() + { + var text = InlineImagePolicy.Describe( + Caps(GraphicsProtocol.Sixel), GraphicsSurface.Compositor(canPlaceKitty: false)); + + await Assert.That(text).Contains("HalfBlock"); + await Assert.That(text).Contains("Sixel cannot be drawn inside the compositor"); + } + + [Test] + public async Task Describe_ReportsAPlainMatchWithoutAnExcuse() + { + var text = InlineImagePolicy.Describe( + Caps(GraphicsProtocol.Kitty), GraphicsSurface.Compositor(canPlaceKitty: true)); + + await Assert.That(text).Contains("Kitty"); + await Assert.That(text).DoesNotContain("("); + } + + [Test] + public async Task Describe_SaysNothingWasDetectedWhenTheTerminalIsBare() + { + var text = InlineImagePolicy.Describe(Caps(GraphicsProtocol.None), GraphicsSurface.RawTerminal); + await Assert.That(text).Contains("no inline graphics detected"); + } + + [Test] + public async Task Describe_DistinguishesACapableTerminalBehindAnIncapableView() + { + var text = InlineImagePolicy.Describe(Caps(GraphicsProtocol.Kitty), GraphicsSurface.PlainText); + await Assert.That(text).Contains("cannot draw images"); + } + + [Test] + public async Task Select_RejectsNullArguments() + { + await Assert.That(() => InlineImagePolicy.Select(null!, GraphicsSurface.RawTerminal)) + .Throws(); + await Assert.That(() => InlineImagePolicy.Select(Caps(GraphicsProtocol.Kitty), null!)) + .Throws(); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/WebImageLayoutTests.cs b/tests/SharpMUTerm.Tui.Tests/WebImageLayoutTests.cs new file mode 100644 index 00000000..bc3af828 --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/WebImageLayoutTests.cs @@ -0,0 +1,138 @@ +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// Sizing rules for inline web images: what is worth drawing, and how big it may get. Pure +/// arithmetic, so it is verifiable without a terminal — unlike the picture it eventually produces. +/// +public class WebImageLayoutTests +{ + // ---- Worth drawing at all? --------------------------------------------------------------- + + [Test] + [Arguments(1, 1)] + [Arguments(1, 200)] + [Arguments(200, 1)] + [Arguments(15, 15)] + [Arguments(15, 400)] + [Arguments(0, 0)] + public async Task TinyOrDegenerateImages_AreNotWorthDrawing(int width, int height) + { + // Spacer gifs, tracking pixels, and rules read better as their text placeholder. + await Assert.That(WebImageLayout.IsWorthRendering(width, height)).IsFalse(); + } + + [Test] + [Arguments(16, 16)] + [Arguments(64, 64)] + [Arguments(1920, 1080)] + public async Task RealImages_AreWorthDrawing(int width, int height) + { + await Assert.That(WebImageLayout.IsWorthRendering(width, height)).IsTrue(); + } + + [Test] + public async Task NegativeDimensions_AreNotWorthDrawing() + { + await Assert.That(WebImageLayout.IsWorthRendering(-10, -10)).IsFalse(); + } + + // ---- Fitting ------------------------------------------------------------------------------ + + [Test] + public async Task SmallImage_KeepsItsNaturalCellSizeRatherThanBeingBlownUp() + { + // Fit never upscales, matching the framework's ImageScaleMode.Fit. + var box = WebImageLayout.Fit(40, 40, availableColumns: 200); + await Assert.That(box.Columns).IsEqualTo(40); + await Assert.That(box.Rows).IsEqualTo(20); + } + + [Test] + public async Task WideImage_IsClampedToTheAvailableColumns() + { + // 400x200 → natural 400 cols x 100 rows. Raise the row ceiling so the column budget is what + // actually binds: scale 100/400 → 100 cols x 25 rows. + var box = WebImageLayout.Fit(400, 200, availableColumns: 100, maxRows: 100); + await Assert.That(box.Columns).IsEqualTo(100); + await Assert.That(box.Rows).IsEqualTo(25); + } + + [Test] + public async Task RowCeilingBindsBeforeTheColumnBudgetOnATallImage() + { + // Same image at the default 20-row ceiling: 20/100 is a tighter scale than 100/400, so the + // ceiling wins and the image ends up narrower than the columns on offer. + var box = WebImageLayout.Fit(400, 200, availableColumns: 100); + await Assert.That(box.Rows).IsEqualTo(WebImageLayout.MaxRows); + await Assert.That(box.Columns).IsEqualTo(80); + } + + [Test] + public async Task TallImage_IsClampedToTheRowCeiling() + { + var box = WebImageLayout.Fit(100, 4000, availableColumns: 200); + await Assert.That(box.Rows).IsLessThanOrEqualTo(WebImageLayout.MaxRows); + } + + [Test] + public async Task NoSingleImageMayExceedTheRowCeiling() + { + foreach (var (w, h) in new[] { (100, 100), (2000, 2000), (32, 4000), (4000, 32), (16, 16) }) + { + var box = WebImageLayout.Fit(w, h, availableColumns: 120); + await Assert.That(box.Rows) + .IsLessThanOrEqualTo(WebImageLayout.MaxRows) + .Because($"{w}x{h} must not claim more than {WebImageLayout.MaxRows} rows"); + } + } + + [Test] + public async Task FitNeverExceedsTheColumnBudget() + { + foreach (var columns in new[] { 1, 10, 40, 120, 200 }) + { + var box = WebImageLayout.Fit(800, 600, columns); + await Assert.That(box.Columns).IsLessThanOrEqualTo(columns); + } + } + + [Test] + public async Task AspectRatioIsHeldWithinARoundingCell() + { + // 800x600 → natural 800 cols x 300 rows, an 8:3 cell ratio; keep it across the downscale. + var box = WebImageLayout.Fit(800, 600, availableColumns: 80, maxRows: 100); + await Assert.That(box.Columns).IsEqualTo(80); + await Assert.That(box.Rows).IsEqualTo(30); + } + + [Test] + public async Task OddPixelHeight_RoundsUpToACoveringRow() + { + // 20x21 pixels needs 11 half-block rows, not 10 — the last row is half used. + var box = WebImageLayout.Fit(20, 21, availableColumns: 200, maxRows: 100); + await Assert.That(box.Rows).IsEqualTo(11); + } + + [Test] + public async Task FitAlwaysClaimsAtLeastOneCell() + { + var box = WebImageLayout.Fit(4000, 16, availableColumns: 1, maxRows: 1); + await Assert.That(box.Columns).IsGreaterThanOrEqualTo(1); + await Assert.That(box.Rows).IsGreaterThanOrEqualTo(1); + } + + [Test] + [Arguments(0, 100, 80, 20)] + [Arguments(100, 0, 80, 20)] + [Arguments(100, 100, 0, 20)] + [Arguments(100, 100, 80, 0)] + [Arguments(-1, -1, 80, 20)] + public async Task DegenerateInputs_YieldAnEmptyBox(int w, int h, int columns, int maxRows) + { + var box = WebImageLayout.Fit(w, h, columns, maxRows); + await Assert.That(box.Columns).IsEqualTo(0); + await Assert.That(box.Rows).IsEqualTo(0); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/WebImageLoaderTests.cs b/tests/SharpMUTerm.Tui.Tests/WebImageLoaderTests.cs new file mode 100644 index 00000000..8b1f1f67 --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/WebImageLoaderTests.cs @@ -0,0 +1,176 @@ +using SixLabors.ImageSharp; +using SixLabors.ImageSharp.PixelFormats; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// The loader's gatekeeping and decode/downsample path. Every rejection here means the page keeps +/// its text placeholder, so these are the cases that decide whether a hostile or broken image can +/// disturb the client — and they are all reachable without a network. +/// +public class WebImageLoaderTests +{ + /// A real PNG of the given size, so the decode path runs on genuine image bytes. + private static byte[] SamplePng(int width = 32, int height = 32) + { + using var image = new Image(width, height); + for (var y = 0; y < height; y++) + { + for (var x = 0; x < width; x++) + { + image[x, y] = new Rgb24((byte)(x % 256), (byte)(y % 256), 128); + } + } + + using var stream = new MemoryStream(); + image.SaveAsPng(stream); + return stream.ToArray(); + } + + // ---- Media types --------------------------------------------------------------------------- + + [Test] + [Arguments("image/png")] + [Arguments("image/jpeg")] + [Arguments("image/gif")] + [Arguments("image/webp")] + [Arguments("IMAGE/PNG")] + public async Task RasterImageTypes_AreAccepted(string mediaType) + { + await Assert.That(WebImageLoader.IsDecodableImageType(mediaType)).IsTrue(); + } + + [Test] + [Arguments("text/html")] + [Arguments("application/json")] + [Arguments("image/svg+xml")] + [Arguments("")] + public async Task NonDecodableTypes_AreRejected(string mediaType) + { + // SVG is an image/* type the decoder cannot rasterise, so accepting it would only ever + // produce a failed decode. + await Assert.That(WebImageLoader.IsDecodableImageType(mediaType)).IsFalse(); + } + + // ---- data: URIs ---------------------------------------------------------------------------- + + [Test] + public async Task Base64DataUri_IsDecoded() + { + var payload = Convert.ToBase64String(new byte[] { 1, 2, 3, 4 }); + var bytes = WebImageLoader.ParseDataUri($"data:image/png;base64,{payload}"); + await Assert.That(bytes).IsEquivalentTo(new byte[] { 1, 2, 3, 4 }); + } + + [Test] + [Arguments("data:image/png,notbase64")] + [Arguments("data:image/png;base64,!!!not-base64!!!")] + [Arguments("nocomma")] + [Arguments("data:")] + public async Task MalformedOrNonBase64DataUris_YieldNull(string uri) + { + await Assert.That(WebImageLoader.ParseDataUri(uri)).IsNull(); + } + + [Test] + public async Task OversizedDataUri_IsRejectedBeforeDecoding() + { + // Guards against a page inflating memory through a giant inline payload. + var huge = "data:image/png;base64," + new string('A', (int)((WebImageLoader.MaxImageBytes / 3) * 4) + 8); + await Assert.That(WebImageLoader.ParseDataUri(huge)).IsNull(); + } + + // ---- Decoding + downsampling --------------------------------------------------------------- + + [Test] + public async Task ValidPng_DecodesToItsNaturalSizeWhenItAlreadyFits() + { + var buffer = WebImageLoader.Decode(SamplePng(32, 32), availableColumns: 200); + await Assert.That(buffer).IsNotNull(); + await Assert.That(buffer!.Width).IsEqualTo(32); + await Assert.That(buffer.Height).IsEqualTo(32); + } + + [Test] + public async Task LargeImage_IsDownsampledToTheCellBoxItWillOccupy() + { + // 400x200 fits into 80 cols x 20 rows at the default row ceiling, so the buffer handed to + // the control is exactly that: 80 pixels wide, 40 tall (two pixel rows per cell). + var buffer = WebImageLoader.Decode(SamplePng(400, 200), availableColumns: 100); + await Assert.That(buffer).IsNotNull(); + + var expected = WebImageLayout.Fit(400, 200, availableColumns: 100); + await Assert.That(buffer!.Width).IsEqualTo(expected.Columns); + await Assert.That(buffer.Height).IsEqualTo(expected.Rows * WebImageLayout.PixelsPerCell); + } + + [Test] + public async Task DecodedBufferIsNeverWiderThanTheColumnBudget() + { + foreach (var columns in new[] { 10, 40, 100 }) + { + var buffer = WebImageLoader.Decode(SamplePng(400, 200), columns); + await Assert.That(buffer!.Width).IsLessThanOrEqualTo(columns); + } + } + + [Test] + public async Task DecodedBufferNeverExceedsTheRowCeiling() + { + var buffer = WebImageLoader.Decode(SamplePng(64, 2000), availableColumns: 120); + await Assert.That(buffer).IsNotNull(); + await Assert.That(buffer!.Height / WebImageLayout.PixelsPerCell) + .IsLessThanOrEqualTo(WebImageLayout.MaxRows); + } + + [Test] + public async Task TinyImage_IsRejectedRatherThanDrawn() + { + await Assert.That(WebImageLoader.Decode(SamplePng(8, 8), availableColumns: 200)).IsNull(); + } + + [Test] + [Arguments(new byte[0])] + [Arguments(new byte[] { 0x00, 0x01, 0x02, 0x03 })] + public async Task GarbageBytes_DecodeToNullRatherThanThrowing(byte[] bytes) + { + await Assert.That(WebImageLoader.Decode(bytes, availableColumns: 80)).IsNull(); + } + + [Test] + public async Task HtmlErrorPageBytes_DecodeToNull() + { + // A server that answers an image request with an HTML error page must not crash the view. + var html = System.Text.Encoding.UTF8.GetBytes("404"); + await Assert.That(WebImageLoader.Decode(html, availableColumns: 80)).IsNull(); + } + + [Test] + public async Task NoColumnsAvailable_DecodesToNull() + { + await Assert.That(WebImageLoader.Decode(SamplePng(), availableColumns: 0)).IsNull(); + } + + [Test] + public async Task Decode_RejectsNullBytes() + { + await Assert.That(() => WebImageLoader.Decode(null!, 80)).Throws(); + } + + // ---- Fetch gatekeeping (no network needed) -------------------------------------------------- + + [Test] + [Arguments("")] + [Arguments(" ")] + [Arguments("ftp://example.com/pic.png")] + [Arguments("file:///etc/passwd")] + [Arguments("not a url")] + [Arguments("javascript:alert(1)")] + public async Task NonHttpSources_AreNeverFetched(string url) + { + using var loader = new WebImageLoader(); + // Rejected on the scheme, before any request is made — so this cannot hit the network. + await Assert.That(await loader.LoadAsync(url, 80)).IsNull(); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/WebInlineImageEndToEndTests.cs b/tests/SharpMUTerm.Tui.Tests/WebInlineImageEndToEndTests.cs new file mode 100644 index 00000000..914e1b5f --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/WebInlineImageEndToEndTests.cs @@ -0,0 +1,145 @@ +using SixLabors.ImageSharp; +using SixLabors.ImageSharp.PixelFormats; +using SharpMUTerm.Graphics; +using SharpMUTerm.Tui; +using SharpMUTerm.Web; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// The whole inline-image seam without a terminal: HTML → styled lines + image index → capability +/// probe → degradation policy → decoded pixels → composed blocks. +/// +/// What this cannot show is a picture. The sandbox has no graphics-capable terminal, so the +/// Kitty and Sixel output is unverified here by construction. What it does show is that the +/// decision is right in each case and that the no-graphics path — the one this host actually takes — +/// produces the same plain page it always did. +/// +public class WebInlineImageEndToEndTests +{ + private const string PageHtml = + "Room" + + "

You are standing in a field.

" + + "\"the" + + "

Exits lead north and south.

" + + ""; + + private static byte[] Png(int width, int height) + { + using var image = new Image(width, height); + for (var y = 0; y < height; y++) + { + for (var x = 0; x < width; x++) + { + image[x, y] = new Rgb24((byte)(x % 256), (byte)(y % 256), 200); + } + } + + using var stream = new MemoryStream(); + image.SaveAsPng(stream); + return stream.ToArray(); + } + + private static TerminalCapabilities Detect(params (string Key, string? Value)[] vars) => + CapabilityProbe.Detect(vars.ToDictionary(v => v.Key, v => v.Value, StringComparer.Ordinal)); + + [Test] + public async Task BareTerminal_KeepsThePlaceholderAndNeverFetchesTheImage() + { + // No TERM, no COLORTERM: exactly this test host, and every dumb terminal or pipe. + var caps = Detect(); + var presentation = InlineImagePolicy.Select(caps, GraphicsSurface.Compositor(canPlaceKitty: false)); + await Assert.That(presentation).IsEqualTo(InlineImagePresentation.TextPlaceholder); + + var page = new HtmlStyledRenderer().RenderDocument(PageHtml); + await Assert.That(page.Images.Count).IsEqualTo(1); + + // TextPlaceholder means the app never decodes anything, so the composer sees no boxes. + var blocks = WebViewComposer.Compose( + page.Lines.Select(l => l.Text).ToList(), page.Images, new Dictionary()); + + await Assert.That(blocks.Count).IsEqualTo(1); + var text = string.Join("\n", ((WebTextBlock)blocks[0]).Lines); + await Assert.That(text).Contains("[image: the map]"); + await Assert.That(text).Contains("You are standing in a field."); + await Assert.That(text).Contains("Exits lead north and south."); + } + + [Test] + public async Task TrueColorTerminal_DrawsTheImageAsHalfBlocks() + { + var caps = Detect(("COLORTERM", "truecolor")); + var presentation = InlineImagePolicy.Select(caps, GraphicsSurface.Compositor(canPlaceKitty: false)); + await Assert.That(presentation).IsEqualTo(InlineImagePresentation.HalfBlock); + + await AssertPageDrawsTheImage(); + } + + [Test] + public async Task KittyTerminal_DrawsTheImageThroughTheKittyPath() + { + var caps = Detect(("TERM", "xterm-kitty"), ("COLORTERM", "truecolor")); + var presentation = InlineImagePolicy.Select(caps, GraphicsSurface.Compositor(canPlaceKitty: true)); + await Assert.That(presentation).IsEqualTo(InlineImagePresentation.Kitty); + + // The composition is protocol-independent — the framework's ImageControl picks Kitty vs + // half-block per driver. Only the *picture* differs, and that is what needs real hardware. + await AssertPageDrawsTheImage(); + } + + [Test] + public async Task SixelTerminal_FallsBackToHalfBlockInsideTheCompositor() + { + var caps = Detect(("TERM_PROGRAM", "foot"), ("COLORTERM", "truecolor")); + await Assert.That(caps.Protocol).IsEqualTo(GraphicsProtocol.Sixel); + + // The framework has no Sixel back-end and the compositor has nowhere to put a raw escape, + // so the chain steps down one rung rather than drawing nothing. + var presentation = InlineImagePolicy.Select(caps, GraphicsSurface.Compositor(canPlaceKitty: false)); + await Assert.That(presentation).IsEqualTo(InlineImagePresentation.HalfBlock); + + await AssertPageDrawsTheImage(); + } + + /// Runs the decode + compose half of the seam and asserts the picture replaced its placeholder. + private static async Task AssertPageDrawsTheImage() + { + var page = new HtmlStyledRenderer().RenderDocument(PageHtml); + var markup = page.Lines.Select(l => l.Text).ToList(); + + var buffer = WebImageLoader.Decode(Png(200, 100), availableColumns: 60); + await Assert.That(buffer).IsNotNull(); + + var boxes = new Dictionary + { + [0] = new(buffer!.Width, buffer.Height / WebImageLayout.PixelsPerCell), + }; + + var blocks = WebViewComposer.Compose(markup, page.Images, boxes); + + // Prose above, picture, prose below — and the placeholder is gone. + await Assert.That(blocks.OfType().Count()).IsEqualTo(1); + var remainingText = string.Join("\n", blocks.OfType().SelectMany(b => b.Lines)); + await Assert.That(remainingText).DoesNotContain("[image: the map]"); + await Assert.That(remainingText).Contains("You are standing in a field."); + await Assert.That(remainingText).Contains("Exits lead north and south."); + + var image = blocks.OfType().Single(); + await Assert.That(image.Image.Source).IsEqualTo("https://example.com/map.png"); + await Assert.That(image.Box.Rows).IsGreaterThan(0); + await Assert.That(image.Box.Rows).IsLessThanOrEqualTo(WebImageLayout.MaxRows); + } + + [Test] + public async Task ThisTestHostReallyIsTheNoGraphicsCase() + { + // Documents the sandbox assumption the honesty of the rest of this work rests on: nothing + // here can render Kitty or Sixel, so only the selection logic above is verified. + var caps = CapabilityProbe.DetectFromEnvironment(); + var presentation = InlineImagePolicy.Select(caps, GraphicsSurface.Compositor(canPlaceKitty: false)); + + await Assert.That(presentation) + .IsNotEqualTo(InlineImagePresentation.Kitty) + .Because("a CI/sandbox host must never claim a Kitty-capable compositor surface"); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/WebViewComposerTests.cs b/tests/SharpMUTerm.Tui.Tests/WebViewComposerTests.cs new file mode 100644 index 00000000..569200b7 --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/WebViewComposerTests.cs @@ -0,0 +1,207 @@ +using SharpMUTerm.Tui; +using SharpMUTerm.Web; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// The web view's block split. The degraded path — nothing decoded, so the page is one markup +/// control exactly as before — is the one that has to be exactly right, because it is the path every +/// terminal without graphics takes, including this test host. +/// +public class WebViewComposerTests +{ + private static readonly WebImageLayout.CellBox Box = new(20, 6); + + private static IReadOnlyList Lines(params string[] lines) => lines; + + private static WebImage Image(int line, string src = "pic.png") => + new(line, src, "alt", "[image: alt]"); + + private static Dictionary Boxes(params int[] indexes) => + indexes.ToDictionary(i => i, _ => Box); + + // ---- Degraded: no decoded images --------------------------------------------------------- + + [Test] + public async Task NoImagesAtAll_YieldsTheWholePageAsOneTextBlock() + { + var blocks = WebViewComposer.Compose( + Lines("a", "b", "c"), Array.Empty(), new Dictionary()); + + await Assert.That(blocks.Count).IsEqualTo(1); + await Assert.That(((WebTextBlock)blocks[0]).Lines).IsEquivalentTo(new[] { "a", "b", "c" }); + } + + [Test] + public async Task ImagesPresentButNoneDecoded_LeavesEveryPlaceholderInPlace() + { + // The no-graphics case: placeholders stay, and the page is still a single control. + var blocks = WebViewComposer.Compose( + Lines("a", "[image: alt]", "b"), + new[] { Image(1) }, + new Dictionary()); + + await Assert.That(blocks.Count).IsEqualTo(1); + await Assert.That(((WebTextBlock)blocks[0]).Lines).IsEquivalentTo(new[] { "a", "[image: alt]", "b" }); + } + + [Test] + public async Task EmptyPage_YieldsOneEmptyTextBlock() + { + var blocks = WebViewComposer.Compose( + Array.Empty(), Array.Empty(), new Dictionary()); + + await Assert.That(blocks.Count).IsEqualTo(1); + await Assert.That(((WebTextBlock)blocks[0]).Lines).IsEmpty(); + } + + // ---- Splitting around decoded images ----------------------------------------------------- + + [Test] + public async Task DecodedImage_SplitsThePageAndConsumesThePlaceholderLine() + { + var blocks = WebViewComposer.Compose( + Lines("a", "[image: alt]", "b"), new[] { Image(1) }, Boxes(0)); + + await Assert.That(blocks.Count).IsEqualTo(3); + await Assert.That(((WebTextBlock)blocks[0]).Lines).IsEquivalentTo(new[] { "a" }); + await Assert.That(((WebImageBlock)blocks[1]).Index).IsEqualTo(0); + await Assert.That(((WebImageBlock)blocks[1]).Box).IsEqualTo(Box); + await Assert.That(((WebTextBlock)blocks[2]).Lines).IsEquivalentTo(new[] { "b" }); + } + + [Test] + public async Task PlaceholderTextNeverSurvivesAlongsideItsPicture() + { + var blocks = WebViewComposer.Compose( + Lines("a", "[image: alt]", "b"), new[] { Image(1) }, Boxes(0)); + + var text = blocks.OfType().SelectMany(b => b.Lines); + await Assert.That(text).DoesNotContain("[image: alt]"); + } + + [Test] + public async Task ImageAtTheTop_EmitsNoLeadingTextBlock() + { + var blocks = WebViewComposer.Compose(Lines("[image: alt]", "b"), new[] { Image(0) }, Boxes(0)); + + await Assert.That(blocks.Count).IsEqualTo(2); + await Assert.That(blocks[0]).IsTypeOf(); + await Assert.That(((WebTextBlock)blocks[1]).Lines).IsEquivalentTo(new[] { "b" }); + } + + [Test] + public async Task ImageAtTheBottom_EmitsNoTrailingTextBlock() + { + var blocks = WebViewComposer.Compose(Lines("a", "[image: alt]"), new[] { Image(1) }, Boxes(0)); + + await Assert.That(blocks.Count).IsEqualTo(2); + await Assert.That(((WebTextBlock)blocks[0]).Lines).IsEquivalentTo(new[] { "a" }); + await Assert.That(blocks[1]).IsTypeOf(); + } + + [Test] + public async Task PageThatIsNothingButAnImage_YieldsJustTheImageBlock() + { + var blocks = WebViewComposer.Compose(Lines("[image: alt]"), new[] { Image(0) }, Boxes(0)); + + await Assert.That(blocks.Count).IsEqualTo(1); + await Assert.That(blocks[0]).IsTypeOf(); + } + + [Test] + public async Task AdjacentImages_ProduceNoEmptyTextBlockBetweenThem() + { + var blocks = WebViewComposer.Compose( + Lines("[image: alt]", "[image: alt]"), + new[] { Image(0, "a.png"), Image(1, "b.png") }, + Boxes(0, 1)); + + await Assert.That(blocks.Count).IsEqualTo(2); + await Assert.That(blocks.All(b => b is WebImageBlock)).IsTrue(); + } + + [Test] + public async Task MixedDecodeResults_DrawOnlyTheOnesThatDecoded() + { + // Image 0 decoded; image 1 did not, so its placeholder rides along in the trailing text. + var blocks = WebViewComposer.Compose( + Lines("a", "[image: alt]", "b", "[image: alt]", "c"), + new[] { Image(1, "a.png"), Image(3, "b.png") }, + Boxes(0)); + + await Assert.That(blocks.Count).IsEqualTo(3); + await Assert.That(((WebImageBlock)blocks[1]).Image.Source).IsEqualTo("a.png"); + await Assert.That(((WebTextBlock)blocks[2]).Lines).IsEquivalentTo(new[] { "b", "[image: alt]", "c" }); + } + + [Test] + public async Task BlocksCoverEveryLineExactlyOnce() + { + var lines = Lines("0", "[image: alt]", "2", "3", "[image: alt]", "5"); + var blocks = WebViewComposer.Compose( + lines, new[] { Image(1, "a.png"), Image(4, "b.png") }, Boxes(0, 1)); + + var text = blocks.OfType().SelectMany(b => b.Lines).ToList(); + await Assert.That(text).IsEquivalentTo(new[] { "0", "2", "3", "5" }); + await Assert.That(blocks.OfType().Count()).IsEqualTo(2); + } + + // ---- Defensive cases ---------------------------------------------------------------------- + + [Test] + public async Task ImageIndexPastTheEndOfThePage_IsIgnored() + { + // A stale index must never crash or slice out of range. + var blocks = WebViewComposer.Compose(Lines("a", "b"), new[] { Image(99) }, Boxes(0)); + + await Assert.That(blocks.Count).IsEqualTo(1); + await Assert.That(((WebTextBlock)blocks[0]).Lines).IsEquivalentTo(new[] { "a", "b" }); + } + + [Test] + public async Task NegativeImageIndex_IsIgnored() + { + var blocks = WebViewComposer.Compose(Lines("a"), new[] { Image(-1) }, Boxes(0)); + + await Assert.That(blocks.Count).IsEqualTo(1); + await Assert.That(((WebTextBlock)blocks[0]).Lines).IsEquivalentTo(new[] { "a" }); + } + + [Test] + public async Task TwoImagesClaimingOneLine_OnlyTheFirstWins() + { + var blocks = WebViewComposer.Compose( + Lines("a", "[image: alt]", "b"), + new[] { Image(1, "a.png"), Image(1, "b.png") }, + Boxes(0, 1)); + + await Assert.That(blocks.OfType().Count()).IsEqualTo(1); + await Assert.That(blocks.OfType().Single().Image.Source).IsEqualTo("a.png"); + } + + [Test] + public async Task OutOfOrderImageIndices_AreStillPlacedInLineOrder() + { + var blocks = WebViewComposer.Compose( + Lines("[image: alt]", "x", "[image: alt]"), + new[] { Image(2, "second.png"), Image(0, "first.png") }, + Boxes(0, 1)); + + var images = blocks.OfType().ToList(); + await Assert.That(images[0].Image.Source).IsEqualTo("first.png"); + await Assert.That(images[1].Image.Source).IsEqualTo("second.png"); + } + + [Test] + public async Task Compose_RejectsNullArguments() + { + var empty = new Dictionary(); + await Assert.That(() => WebViewComposer.Compose(null!, Array.Empty(), empty)) + .Throws(); + await Assert.That(() => WebViewComposer.Compose(Array.Empty(), null!, empty)) + .Throws(); + await Assert.That(() => WebViewComposer.Compose(Array.Empty(), Array.Empty(), null!)) + .Throws(); + } +} diff --git a/tests/SharpMUTerm.Web.Tests/WebImageIndexTests.cs b/tests/SharpMUTerm.Web.Tests/WebImageIndexTests.cs new file mode 100644 index 00000000..74323bcf --- /dev/null +++ b/tests/SharpMUTerm.Web.Tests/WebImageIndexTests.cs @@ -0,0 +1,146 @@ +using SharpMUTerm.Core.Text; +using SharpMUTerm.Web; + +namespace SharpMUTerm.Web.Tests; + +/// +/// The image index is what lets a graphics-capable view swap a placeholder line for a real picture, +/// so the indices have to point at exactly the right lines — including after wrapping, blank-line +/// collapsing, and the trailing-blank trim does on the way out. +/// +public class WebImageIndexTests +{ + private static HtmlRenderResult Render(string html, int width = 80) => + new HtmlStyledRenderer().RenderDocument(html, width); + + [Test] + public async Task Image_IsIndexedWithItsResolvedSourceAndAlt() + { + var result = new HtmlStyledRenderer("https://example.com/dir/page.html") + .RenderDocument("

before

\"a

after

"); + + await Assert.That(result.Images.Count).IsEqualTo(1); + var image = result.Images[0]; + await Assert.That(image.Source).IsEqualTo("https://example.com/dir/pic.png"); + await Assert.That(image.Alt).IsEqualTo("a cat"); + await Assert.That(image.PlaceholderText).IsEqualTo("[image: a cat]"); + } + + [Test] + public async Task IndexedLine_IsTheOneHoldingThePlaceholder() + { + var result = Render("

before

\"a

after

"); + var image = result.Images[0]; + + await Assert.That(image.LineIndex).IsGreaterThanOrEqualTo(0); + await Assert.That(image.LineIndex).IsLessThan(result.Lines.Count); + await Assert.That(result.Lines[image.LineIndex].Text).IsEqualTo("[image: a cat]"); + } + + [Test] + public async Task PlaceholderLine_HoldsNothingButTheImage() + { + // Prose must not share the row: the view replaces the whole line with the picture. + var result = Render("

text before \"cat\" text after

"); + var image = result.Images[0]; + + await Assert.That(result.Lines[image.LineIndex].Text).IsEqualTo("[image: cat]"); + await Assert.That(string.Join("\n", result.Lines.Select(l => l.Text))).Contains("text before"); + await Assert.That(string.Join("\n", result.Lines.Select(l => l.Text))).Contains("text after"); + } + + [Test] + public async Task MultipleImages_AreIndexedInDocumentOrderAtDistinctLines() + { + var result = Render( + "

one

\"A\"

two

\"B\"

three

"); + + await Assert.That(result.Images.Count).IsEqualTo(2); + await Assert.That(result.Images[0].Source).IsEqualTo("a.png"); + await Assert.That(result.Images[1].Source).IsEqualTo("b.png"); + await Assert.That(result.Images[0].LineIndex).IsLessThan(result.Images[1].LineIndex); + await Assert.That(result.Lines[result.Images[0].LineIndex].Text).IsEqualTo("[image: A]"); + await Assert.That(result.Lines[result.Images[1].LineIndex].Text).IsEqualTo("[image: B]"); + } + + [Test] + public async Task IndicesSurviveWrappedProseAbove() + { + var prose = string.Join(' ', Enumerable.Repeat("word", 60)); + var result = Render($"

{prose}

\"cat\"", width: 20); + + await Assert.That(result.Lines.Count).IsGreaterThan(4); + await Assert.That(result.Lines[result.Images[0].LineIndex].Text).IsEqualTo("[image: cat]"); + } + + [Test] + public async Task ImageAtEndOfDocument_SurvivesTheTrailingBlankTrim() + { + var result = Render("

text

\"cat\""); + var image = result.Images[0]; + + await Assert.That(image.LineIndex).IsEqualTo(result.Lines.Count - 1); + await Assert.That(result.Lines[image.LineIndex].Text).IsEqualTo("[image: cat]"); + } + + [Test] + public async Task ImageAtStartOfDocument_IsIndexedAtLineZero() + { + var result = Render("\"cat\"

text

"); + await Assert.That(result.Images[0].LineIndex).IsEqualTo(0); + await Assert.That(result.Lines[0].Text).IsEqualTo("[image: cat]"); + } + + [Test] + public async Task ImageWithoutSource_StillShowsAPlaceholderButIsNotIndexed() + { + var result = Render("\"broken\""); + await Assert.That(result.Images).IsEmpty(); + await Assert.That(string.Join("\n", result.Lines.Select(l => l.Text))).Contains("[image: broken]"); + } + + [Test] + public async Task ImageWithoutAlt_UsesTheBarePlaceholderAndNullAlt() + { + var result = Render(""); + await Assert.That(result.Images[0].Alt).IsNull(); + await Assert.That(result.Images[0].PlaceholderText).IsEqualTo("[image]"); + await Assert.That(result.Lines[result.Images[0].LineIndex].Text).IsEqualTo("[image]"); + } + + [Test] + public async Task PlaceholderKeepsItsHyperlink_SoNonGraphicalViewsCanStillOpenTheImage() + { + var result = Render("\"cat\""); + var span = result.Lines[result.Images[0].LineIndex].Spans.First(); + + await Assert.That(span.IsInteractive).IsTrue(); + await Assert.That(span.Interaction!.Kind).IsEqualTo(InteractionKind.Hyperlink); + await Assert.That(span.Interaction!.Target).IsEqualTo("pic.png"); + } + + [Test] + public async Task RenderDocument_IsRepeatableOnTheSameRendererInstance() + { + var renderer = new HtmlStyledRenderer(); + renderer.RenderDocument(""); + var second = renderer.RenderDocument(""); + + // The image list is per-render, not cumulative. + await Assert.That(second.Images.Count).IsEqualTo(1); + await Assert.That(second.Images[0].Source).IsEqualTo("b.png"); + } + + [Test] + public async Task PageWithoutImages_HasAnEmptyIndex() + { + await Assert.That(Render("

just words

").Images).IsEmpty(); + } + + [Test] + public async Task WebPage_DefaultsToNoImages() + { + var page = new WebPage("http://x", "t", Array.Empty()); + await Assert.That(page.Images).IsEmpty(); + } +} From 449b52a6cc96694649631bb70039d818686e8aba Mon Sep 17 00:00:00 2001 From: Harry Cordewener Date: Tue, 28 Jul 2026 17:47:51 -0500 Subject: [PATCH 09/23] HANDOFF: restate the backlog as what is actually left The backlog had become a write-up of finished work -- four of six items were descriptions of things already built, so a session looking for remaining work had to read ~180 lines to find the few paragraphs that still matter. A handoff should say what is true now, not narrate how it got here. What is left is now five items: field editing on the config screens, the real-terminal verification still owed, Sixel inside the compositor (blocked upstream), MXP/Pueblo routing, and the CodeRabbit nitpicks a future agent must not "fix". The durable framework knowledge those items carried moves into Critical Gotchas, where it applies regardless of what is built: why SupportsKittyGraphics reads false in a constructor, why our escape-string encoders cannot go into a compositor, why drag wiring lives at the driver rather than on a control, and the settings-screen architecture. Corrects the IImageRenderer path, which is in Imaging/, not Controls/ImageControl/. Framework citations re-checked against the v2.5.14 clone: ImageControl.cs:375 is ResolveRenderer, Cell.cs:122 is AppendCombiner, and Sixel appears only in a forward-looking comment and a docs comparison table. Co-Authored-By: Claude Opus 5 (1M context) --- docs/HANDOFF.md | 322 +++++++++++++++++++++++------------------------- 1 file changed, 155 insertions(+), 167 deletions(-) diff --git a/docs/HANDOFF.md b/docs/HANDOFF.md index 348555b3..00a250c0 100644 --- a/docs/HANDOFF.md +++ b/docs/HANDOFF.md @@ -16,175 +16,63 @@ Context for whoever (human or agent) picks up this work next. Ordered roughly by value. Nothing here is blocking; this is the outstanding polish/feature backlog. -### 1. Apply the panel treatment to the other config screens — done +### 1. Field editing on the config screens + +The settings screens navigate (↑↓, ⇥) and toggle (Space), but **nothing lets you +type**: no new host, interval, or pattern. No header advertises editing either, +and a test pins that (`ScreenCursorTests.cs:191` asserts no screen shows +`⏎ edit` / `⏎ rebind` / `⏎ change`) — that assertion moves with the feature. + +Outstanding: + +- **Text/number/enum rows** — the actual edit mode, plus whatever key opens it. +- **Add/remove rows.** `[+ world]` / `[- del]` (`WorldsScreenRenderer.cs:195`) + and `[+ add character]` / `[⧉ duplicate]` / `[- remove]` + (`WorldsScreenRenderer.cs:249`) are painted but inert. +- **F2's route-to radio list and highlight-colour picker** + (`TriggersScreenRenderer.cs`). Both are read-only indicators today; the + highlight row deliberately never takes the cursor, because there is nothing to + turn a colour on with yet. + +See *Settings screens* under Critical Gotchas for the pieces you'd be extending. + +### 2. Real-terminal verification still owed + +All three are covered by headless snapshots only. Nobody has looked at them in a +real terminal. + +- **Full-width input band** — confirm it holds across resizes. The width is + pinned imperatively (`SyncInputWidth`), so a resize is the risky case. +- **Mouse drag-to-split** — nobody has done it with an actual mouse. What is + untested is whether a real terminal's mouse escape sequences arrive as the + frames `PaneDragTracker` expects: that path is SharpConsoleUI's + `NetConsoleDriver` (it enables modes 1000/1006/1002/1003 unconditionally at + startup) plus `AnsiInputParser`, which was read, not run. Everything + downstream of `IConsoleDriver.MouseEvent` is tested. Also unconfirmed: whether + the drag preview repaints fast enough to track the pointer. +- **Kitty inline images** — nobody has seen one. Try `/web ` with images in + Kitty/WezTerm/Ghostty; `/graphics` reports where the degradation chain landed + and why. + +### 3. Sixel inside the compositor — needs an upstream PR + +At SharpConsoleUI 2.5.14 `IImageRenderer` (`Imaging/IImageRenderer.cs:18`) is +`internal` and `ResolveRenderer()` (`Controls/ImageControl/ImageControl.cs:375`) +is private, so **no Sixel back-end can be injected** into `ImageControl`. Inside +the TUI the chain is therefore Kitty → half-block → text, and +`InlineImagePolicy` degrades a Sixel-only terminal to half-block *explicitly* +(`Describe()` says why) rather than silently. -**Status:** complete. All eight settings screens (F2–F9) now render as composed -control trees: a full-width header band with keyboard hints, the body on real -panels, and a Cancel/Save action bar pinned to the last row. - -Each screen has a pure `*ScreenRenderer` exposing its regions as markup blocks -(`HeaderLine`, `FooterLine`, and its body columns) plus a `*ScreenView` that -composes them into controls; the renderer's `Render(...)` still merges the same -blocks into one line list for the unit tests. F7/F8/F9 share -`OptionsScreenRenderer`/`OptionsScreenView`, which take an `OptionsScreen` -(title + F-key + rows) — those screens are a single options list, so their body -is one full-width elevated card rather than a column split. - -Wiring is one table, `SharpMUTermApp.SettingsScreens()`, read by both the global -F-key shortcuts and the `--view` snapshot lookup. Shared chrome lives in -`ScreenPalette` (colours), `ScreenChrome` (hint/action fragments, band, vertical -rule, indent) and `MarkupText` (escape, visible width, padding, spread). - -### 2. Task #20 — fold inline graphics into SharpConsoleUI's Kitty support — wired - -**Status:** wired and unit-tested; the **picture itself is still unverified** -(no GPU terminal in the sandbox). `` in the web view now renders inline. - -**What the framework actually provides** (read at v2.5.14, not assumed): - -- `ImageControl` (`Controls/ImageControl/ImageControl.cs`) takes a - `PixelBuffer` (`Imaging/PixelBuffer.cs`, `FromFile`/`FromStream`/`FromImageSharp`) - and picks its back-end once per control in the private `ResolveRenderer()` - (line 375): `KittyImageRenderer` when the driver is an `IGraphicsProtocol` with - `SupportsKittyGraphics`, else `HalfBlockImageRenderer`. -- Detection is the framework's own — `Helpers/TerminalCapabilities.Probe()` sends a - real Kitty graphics query and falls back to `KITTY_PID`/`WEZTERM_PANE`. It runs at - driver init, so **do not read `SupportsKittyGraphics` in a constructor**; it is - still false there. -- **There is no Sixel anywhere in the framework** (`grep -i sixel` finds only a - "future back-ends" comment at `ImageControl.cs:266` and a row in - `docs/COMPARISON.md:132` conceding the gap to XenoAtom). - -**Why ours could not simply be swapped in.** Our `KittyGraphicsProtocol` and -`SixelEncoder` return escape-sequence *strings*. A compositor owns every cell and -re-diffs the screen each frame; `Cell` (`Layout/Cell.cs`) has no raw-escape field -and `AppendCombiner` (line 122) deliberately sanitises escapes out. The -framework's `KittyImageRenderer` works because it writes U+10EEEE placeholder -cells with combining diacritics — images become *real cells* that scroll and clip -like text, which is the approach `docs/PLAN.md:78` committed to. So the framework -renders, and `SharpMUTerm.Graphics` supplies the policy. - -**Consequence — a real gap, not a shortcut:** `IImageRenderer` is `internal` and -`ResolveRenderer()` is private, so **no Sixel back-end can be injected** into -`ImageControl` at this version. Inside the TUI the chain is therefore -Kitty → half-block → text, and `InlineImagePolicy` degrades a Sixel-only terminal -to half-block *explicitly* (with `Describe()` saying why) rather than silently. Reopening Sixel means an upstream PR making `IImageRenderer` public and -`ResolveRenderer` overridable. - -**What is verified:** the selection logic and the whole fallback matrix -(`InlineImagePolicyTests`, 26 tests), the image index into the page -(`WebImageIndexTests`), sizing and gatekeeping (`WebImageLayoutTests`, -`WebImageLoaderTests`), the block split (`WebViewComposerTests`), and the seam end -to end (`WebInlineImageEndToEndTests`). Snapshots still render — the sandbox is the -no-graphics case, so that also proves degradation does not crash. - -**What is NOT verified:** that a Kitty image actually appears. Nobody has seen one. -Try `/web ` with images in Kitty/WezTerm/Ghostty; `/graphics` reports where the -chain landed and why. - -**Still open:** MXP/Pueblo `` are parsed but discarded -(`MxpParser.cs:379`, `PuebloParser.cs:308`) — routing those through the same seam -is the natural follow-up, as is an image-viewer tab for local files. - -### 3. Live keyboard interaction for the config screens — navigation + toggles done - -**Status:** ↑↓ selection, ⇥ pane switching, Space toggling, and Esc/⏎ -cancel-save are wired on all eight screens. **Field editing is not** — nothing -lets you type a new host, interval, or pattern yet, and no header claims it does -(a test asserts no screen advertises "⏎ edit"/"⏎ rebind"/"⏎ change"). - -How it fits together: - -- `ScreenSelection` — pure cursor state (which pane, where each pane's cursor - sits). Pane sizes are passed in per move rather than cached, because a - keystroke can change them. -- `ScreenModel` / `ScreenToggle` — a screen's navigable panes and the config each - checkbox writes to. Built fresh from live config on every key by the renderer's - own `Model(...)`, so the renderer stays the single source of truth for a - screen's shape. -- `ScreenEdits` — the undo log behind Cancel/Save. Screens edit config **in - place** (cloning `AppConfiguration` would drop `[JsonIgnore]` fields like a - character's in-memory password), so Esc is a replayed undo. A toggle's snapshot - captures the *value*, not the boolean — F9's "auto-start" is really a - `LogFormat`, and cancelling must put `Html` back, not `Plain`. -- `SettingsSession` — key → action (`Redraw`/`Save`/`Cancel`/…). All the - interaction rules live here so they're testable without a terminal. -- `SettingsOverlay` — the only UI-aware piece: on `Redraw` it does - `ClearControls()` + `AddControl(factory())` + `Invalidate(true)`. - -What Space toggles, per screen: F2 trigger `Enabled` / `Gag` / `StopProcessing`, -F3 alias `Enabled` / `CaseSensitive`, F4 macro `Enabled`, F5 character -`AutoLogin` + trigger-set assignment, F6 timer `Enabled` / `OneShot`, F7/F8 the -new `AppConfiguration.Text` / `.Input` preference objects, F9 the log format. -F4/F7/F8/F9 are single-pane (no ⇥); F5 has three panes. - -**Still open:** field editing (text/number/enum rows), add/remove rows -(`[+ world]`, `[- del]`, `[+ add character]` are still painted but inert), and -the F2 route-to radio list + highlight colour picker. - -### 4. Full-width solid input band — verify on a real terminal - -The main input row is now a full-width band (`PromptControl` field fill + a -prompt painted with the same background via `PromptMarkup`, width pinned via -`SyncInputWidth`). Verified in headless snapshots; **confirm it holds on a real -terminal** across resizes, since the width is pinned imperatively. - -### 5. Mouse drag-to-split panes — wired; needs a real mouse to confirm - -**Status:** implemented and covered headlessly end to end, but **nobody has done it -with an actual mouse yet.** Drag a pane's tab strip onto another pane: the middle -adds it as a tab, within 25% of an edge splits there. The drag paints a preview — -every pane dims to its name and the hovered one lights the zone the drop would -claim — and the status line reads `DRAG → split pane 2 left`. - -How it fits together: - -- **`PaneDragTracker`** (Tui, pure) — the gesture state machine. SharpConsoleUI - tracks no drag state for controls beyond mouse capture, so press/motion/release - are stitched together here. Also decodes `MouseFlags`: SGR reports a drag as - `Button1Pressed + ReportMousePosition` *without* `Button1Dragged`, so treating a - pressed bit as a fresh press would restart the gesture on every frame. -- **`PaneDragSurface`** (Tui, pure) — pane rectangles + each pane's active window, - **frozen at press**. It has to be frozen: painting the preview tears the pane - area down, so live controls are a moving target mid-drag. -- **`PaneDropRenderer`** (Tui, pure) — the preview markup. Its band previews *where - the new pane lands*; near a corner that is deliberately not the same set of cells - `DropZones` would resolve to that edge (it picks whichever edge is nearest). -- **`PaneDrop`** (Core, pure) — the one commit path, shared with move mode: null - edge → `MoveWindowToPane`, an edge → `SplitWithWindow`, and no-ops rejected. -- **`SharpMUTermApp.OnDriverMouseEvent`** — the only untested part, deliberately - thin. It subscribes to `_system.ConsoleDriver.MouseEvent`, **not** to a control: - the framework captures the pressed control and routes every later frame to it, so - a control-level handler would only ever see the *source* pane. `PaneSnapshot()` - reads pane rectangles back out of `Window.GetLayoutNode(...).AbsoluteBounds` - (window-content space) and adds the window origin + inset. - -Gotchas found doing it: - -- **Only the tab strip is a drag handle** (a pane's top row). Body presses belong - to the content — text selection, link clicks. -- **Esc cancels a drag.** If a terminal loses the button-up, the preview would - otherwise sit over the panes forever. -- `_paneTabs` is read from the driver's **input thread** and written on the UI - thread, so it is under `_paneTabsLock`. Enumerating it during a rebuild throws. -- The `drag` snapshot view drives a **real** press+drag through - `HeadlessConsoleDriver.SimulateMouseEvent`; nothing about that frame is faked. - It renders a frame first (layout is only arranged by a render, so control bounds - don't exist before one) and then re-initialises the driver, because the headless - driver ignores `InvalidateFrontBuffer` and the closing render would otherwise - emit only the changed cells. +`ResolveRenderer` overridable. Nothing on our side unblocks it. -**Not verified:** that a real terminal's mouse escape sequences arrive as these -frames. That path is SharpConsoleUI's `NetConsoleDriver` (it enables modes -1000/1006/1002/1003 unconditionally at startup) plus `AnsiInputParser`; it was read, -not run. Everything downstream of `IConsoleDriver.MouseEvent` is tested. +### 4. MXP/Pueblo `` -Also completed here: move mode's **arrow keys** now pick an edge. The prompt has -always advertised `←↑↓→ edge`, but nothing handled them — only the tab-drop half -was reachable. Both routes now commit through `PaneDrop`. +Parsed and discarded (`MxpParser.cs:379`, `PuebloParser.cs:309`). Routing them +through the same seam the web view's images use is the natural follow-up, as is +an image-viewer tab for local files. -### 6. CodeRabbit nitpicks intentionally **not** done (don't "fix" these) +### 5. CodeRabbit nitpicks intentionally **not** done (don't "fix" these) - **`tools/fonts/LICENSE-NerdFonts.txt` "explict" typo** — left as-is on purpose: it's a **verbatim copy of the upstream Nerd Fonts license**. Bundled third-party @@ -293,10 +181,104 @@ Things that will waste your time if you don't know them. appear in snapshots. The header/status bars are hand-built `MarkupControl`s in the window instead, precisely so they show up in snapshots. +### SharpConsoleUI inline graphics + +What the framework actually provides (read at v2.5.14, not assumed): + +- **`ImageControl`** (`Controls/ImageControl/ImageControl.cs`) takes a + `PixelBuffer` (`Imaging/PixelBuffer.cs`, `FromFile`/`FromStream`/`FromImageSharp`) + and picks its back-end **once per control** in the private `ResolveRenderer()` + (line 375): `KittyImageRenderer` when the driver is an `IGraphicsProtocol` with + `SupportsKittyGraphics`, else `HalfBlockImageRenderer`. +- **Detection is the framework's own** — `Helpers/TerminalCapabilities.Probe()` + sends a real Kitty graphics query and falls back to `KITTY_PID`/`WEZTERM_PANE`. + It runs at **driver init**, so **do not read `SupportsKittyGraphics` in a + constructor** — it is still `false` there. +- **There is no Sixel anywhere in the framework** (`grep -i sixel` finds only a + "future back-ends" comment at `ImageControl.cs:266` and a row in + `docs/COMPARISON.md:132` conceding the gap to XenoAtom). +- **Our escape-string encoders cannot be swapped into the compositor.** + `KittyGraphicsProtocol` and `SixelEncoder` return escape-sequence *strings*, but + a compositor owns every cell and re-diffs the screen each frame: `Cell` + (`Layout/Cell.cs`) has no raw-escape field, and `AppendCombiner` (line 122) + deliberately sanitises escapes out. The framework's `KittyImageRenderer` works + because it writes **U+10EEEE placeholder cells** with combining diacritics — + images become *real cells* that scroll and clip like text, the approach + `docs/PLAN.md:78` committed to. So the framework renders the pixels; + `SharpMUTerm.Graphics` supplies the policy (`InlineImagePolicy`, + `GraphicsSurface`). + +### SharpConsoleUI mouse & pane drags + +- **Drag wiring belongs at the driver, not on a control.** + `SharpMUTermApp.OnDriverMouseEvent` subscribes to + `_system.ConsoleDriver.MouseEvent` because the framework's + `WindowEventDispatcher` captures the *pressed* control and routes every later + drag frame back to it — a control-level handler would only ever see the source + pane. +- **SGR reports a drag as `Button1Pressed + ReportMousePosition`**, sometimes + *without* `Button1Dragged`. Treating a pressed bit as a fresh press restarts the + gesture on every frame; `PaneDragTracker` decodes this. +- SharpConsoleUI tracks no drag state for controls beyond mouse capture, so + press/motion/release are stitched together in `PaneDragTracker` (Tui, pure). +- **Only a pane's tab strip is a drag handle** (its top row). Body presses belong + to the content — text selection, link clicks. +- **Esc cancels a drag.** If a terminal loses the button-up, the preview would + otherwise sit over the panes forever. +- **`PaneDragSurface` is frozen at press** — pane rectangles + each pane's active + window. It has to be: painting the preview tears the pane area down, so live + controls are a moving target mid-drag. +- `PaneDropRenderer`'s band previews *where the new pane lands*; near a corner + that is deliberately not the same set of cells `DropZones` would resolve to that + edge (it picks whichever edge is nearest). +- `PaneDrop` (Core, pure) is the **one commit path**, shared with move mode: null + edge → `MoveWindowToPane`, an edge → `SplitWithWindow`, no-ops rejected. +- `PaneSnapshot()` reads pane rectangles back out of + `Window.GetLayoutNode(...).AbsoluteBounds` (window-content space) and adds the + window origin + inset. +- `_paneTabs` is read from the driver's **input thread** and written on the UI + thread, so it is under `_paneTabsLock`. Enumerating it during a rebuild throws. +- The `drag` snapshot view drives a **real** press+drag through + `HeadlessConsoleDriver.SimulateMouseEvent`; nothing about that frame is faked. + It renders a frame first (layout is only arranged by a render, so control bounds + don't exist before one) and then re-initialises the driver, because the headless + driver ignores `InvalidateFrontBuffer` and the closing render would otherwise + emit only the changed cells. + +### Settings screens + +- **Wiring is one table**, `SharpMUTermApp.SettingsScreens()`, read by both the + global F-key shortcuts and the `--view` snapshot lookup. Add a screen there. +- Each screen is a pure **`*ScreenRenderer`** exposing its regions as markup blocks + (`HeaderLine`, `FooterLine`, body columns) plus a **`*ScreenView`** that composes + them into controls. The renderer's `Render(...)` merges the same blocks back + into one line list — **the unit tests go through it**, so keep it. +- F7/F8/F9 share `OptionsScreenRenderer`/`OptionsScreenView`, which take an + `OptionsScreen` (title + F-key + rows): those screens are a single options list, + so their body is one full-width elevated card rather than a column split. +- Shared chrome lives in `ScreenPalette` (colours), `ScreenChrome` (hint/action + fragments, band, vertical rule, indent) and `MarkupText` (escape, visible width, + padding, spread). +- Interaction pieces: `ScreenSelection` (pure cursor state; pane sizes are passed + in per move rather than cached, because a keystroke can change them), + `ScreenModel`/`ScreenToggle` (navigable panes + the config each checkbox writes + to, rebuilt from live config on every key by the renderer's own `Model(...)`), + `ScreenEdits` (the undo log), `SettingsSession` (key → `Redraw`/`Save`/`Cancel`/…, + where all the rules live so they're testable without a terminal), and + `SettingsOverlay` (the only UI-aware piece: on `Redraw` it does `ClearControls()` + + `AddControl(factory())` + `Invalidate(true)`). +- **Screens edit config in place.** Cloning `AppConfiguration` would drop + `[JsonIgnore]` fields like a character's in-memory password, so Esc is a replayed + undo. A toggle's snapshot captures the **value**, not the boolean — F9's + "auto-start" is really a `LogFormat`, and cancelling must put `Html` back, not + `Plain`. +- Pane shape: F4/F7/F8/F9 are single-pane (no ⇥); F5 has three panes; the rest have + two. + ### TelnetNegotiationCore - Version in use is **2.5.3** (fluent builder API), **not** the 1.0.0 the original - plan assumed. It now negotiates MCCP/MSDP/MXP itself on top of base negotiation. + plan assumed. It negotiates MCCP/MSDP/MXP itself on top of base negotiation. **Pueblo and the ANSI/MXP/Pueblo payload parsing remain our layer** — the library does the option handshake, not the payload. `TelnetSession` sets the init-only `CallbackOnByteAsync` **reflectively** to see raw bytes (including unterminated @@ -327,18 +309,24 @@ Things that will waste your time if you don't know them. | File | Role | |---|---| -| `src/SharpMUTerm.Tui/SharpMUTermApp.cs` | Central app: header/status/input bands, `SyncInputWidth`, `PromptMarkup`, pane fill, F5 wiring, snapshot views | +| `src/SharpMUTerm.Tui/SharpMUTermApp.cs` | Central app: header/status/input bands, `SyncInputWidth`, `PromptMarkup`, pane fill, `SettingsScreens()`, `OnDriverMouseEvent`/`PaneSnapshot`, snapshot views | | `src/SharpMUTerm.Tui/WorldsScreenRenderer.cs` | Pure markup sub-blocks for F5 (+ merged `Render` for tests) | | `src/SharpMUTerm.Tui/WorldsScreenView.cs` | Composes F5 sub-blocks into real control panels | +| `src/SharpMUTerm.Tui/OptionsScreenRenderer.cs`, `OptionsScreenView.cs` | The shared single-list screen behind F7/F8/F9 | +| `src/SharpMUTerm.Tui/ScreenPalette.cs`, `ScreenChrome.cs`, `MarkupText.cs` | Shared screen chrome: colours, hint/action fragments and bands, markup width/padding helpers | | `src/SharpMUTerm.Tui/SettingsOverlay.cs` | Frameless full-screen overlay; routes keys to the screen's session and rebuilds its content | | `src/SharpMUTerm.Tui/SettingsSession.cs` | Key → action for an open settings screen (the whole interaction contract, testable) | | `src/SharpMUTerm.Tui/ScreenSelection.cs` | Pure pane/cursor state machine for the settings screens | | `src/SharpMUTerm.Tui/ScreenModel.cs` | A screen's navigable panes + the config each checkbox binds to | | `src/SharpMUTerm.Tui/ScreenEdits.cs` | The undo log behind Cancel/Save | +| `src/SharpMUTerm.Tui/PaneDragTracker.cs` | Pure drag gesture state machine + `MouseFlags` decoding | +| `src/SharpMUTerm.Tui/PaneDragSurface.cs` | Pane rectangles + active windows, frozen at press | +| `src/SharpMUTerm.Tui/PaneDropRenderer.cs` | The drag preview markup | +| `src/SharpMUTerm.Core/Workspace/PaneDrop.cs` | The single commit path for a drop (shared with move mode) | | `src/SharpMUTerm.Tui/CommandPalette.cs` | ⌃P surface: content-hug sizing, clean chrome | | `src/SharpMUTerm.Tui/CommandSurfaceRenderer.cs` | Palette rows + full-width selection bar | | `src/SharpMUTerm.Graphics/InlineImagePolicy.cs` | The degradation chain + `GraphicsSurface` (what the *host* can emit, vs what the terminal can show) | -| `src/SharpMUTerm.Tui/WebViewComposer.cs` | Splits a page into text/image blocks; no images → one control, unchanged | +| `src/SharpMUTerm.Tui/WebViewComposer.cs` | Splits a page into text/image blocks; no images → a single control | | `src/SharpMUTerm.Tui/WebImageLayout.cs` | Cell sizing: what is worth drawing and how big it may get | | `src/SharpMUTerm.Tui/WebImageLoader.cs` | Fetch + decode + downsample to the target cell box | | `src/SharpMUTerm.Web/WebImage.cs` | An `` and the line its placeholder occupies | From f34293cb0bd04963b03bb51f77e581e43bc06843 Mon Sep 17 00:00:00 2001 From: Harry Cordewener Date: Tue, 28 Jul 2026 18:27:50 -0500 Subject: [PATCH 10/23] Settings screens: text, number and enum field editing MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Backlog item 1's core. The screens could navigate and toggle but nothing let you type -- no new host, port, interval or pattern. Key scheme: ⏎ activates the focused row when it is activatable, and saves when it is not, so ⏎ still means Save everywhere it did before. ⌃S always saves. Esc cancels the screen, except while a field edit is open, where it abandons that edit and leaves the screen up. A ScreenRow is now a stop, a checkbox, an ordered record of fields, or both at once -- a keypad binding is Space-enables plus ⏎-edits-the- command. Fields hang off rows that already exist rather than adding rows of their own, which is what let every existing pane-count and cursor-index assertion keep passing untouched. Validation happens at commit, not per keystroke: any character types into the buffer, and ⏎/⇥/⌃S validate. A rejected value keeps the edit open and marks the field inline rather than being silently dropped. Rejecting keystrokes instead would mean never being able to clear a port to retype it. ScreenEdits.Apply is the single path from buffer to config and refuses before snapshotting, so an invalid value reaches neither config nor the undo log. Trigger.Pattern and Alias.Pattern become settable and both drop the cached compiled Regex -- the same trap Alias.CaseSensitive had, now with a Core test each asserting the engine stops matching the old pattern. The hint-honesty test is inverted rather than deleted: a screen must advertise ⏎ edit if and only if its model actually offers an editable row, asserted across all six screens in both a populated and a bare configuration so it cannot pass vacuously. Also fixes a flaky test that predates this work. PaneDragEndToEndTests ran in parallel while RenderSnapshot redirects Console.Out and the harness redirects Console.In -- both process-global, so two overlapping renders swapped each other's streams and one got a truncated frame, yielding pane rects that didn't match the screen. It failed roughly one run in ten; the class is now serialised, and 15 consecutive runs are clean. 811 tests pass, up from 764. Co-Authored-By: Claude Opus 5 (1M context) --- CLAUDE.md | 2 +- docs/HANDOFF.md | 77 +++- src/SharpMUTerm.Core/Automation/Alias.cs | 29 +- src/SharpMUTerm.Core/Automation/Macro.cs | 7 +- .../Automation/TimerDefinition.cs | 15 +- src/SharpMUTerm.Core/Automation/Trigger.cs | 22 +- src/SharpMUTerm.Tui/AliasesScreenRenderer.cs | 51 ++- src/SharpMUTerm.Tui/AliasesScreenView.cs | 4 +- src/SharpMUTerm.Tui/KeypadScreenRenderer.cs | 31 +- src/SharpMUTerm.Tui/KeypadScreenView.cs | 4 +- src/SharpMUTerm.Tui/OptionsScreenRenderer.cs | 68 ++- src/SharpMUTerm.Tui/OptionsScreenView.cs | 4 +- src/SharpMUTerm.Tui/Program.cs | 1 + src/SharpMUTerm.Tui/ScreenChrome.cs | 65 ++- src/SharpMUTerm.Tui/ScreenEdits.cs | 25 +- src/SharpMUTerm.Tui/ScreenField.cs | 309 ++++++++++++++ src/SharpMUTerm.Tui/ScreenFocus.cs | 22 +- src/SharpMUTerm.Tui/ScreenModel.cs | 111 ++++- src/SharpMUTerm.Tui/ScreenPalette.cs | 11 +- src/SharpMUTerm.Tui/SettingsOverlay.cs | 8 + src/SharpMUTerm.Tui/SettingsSession.cs | 291 ++++++++++++- src/SharpMUTerm.Tui/SharpMUTermApp.cs | 48 ++- src/SharpMUTerm.Tui/TimersScreenRenderer.cs | 56 ++- src/SharpMUTerm.Tui/TimersScreenView.cs | 4 +- src/SharpMUTerm.Tui/TriggersScreenRenderer.cs | 43 +- src/SharpMUTerm.Tui/TriggersScreenView.cs | 5 +- src/SharpMUTerm.Tui/WorldsScreenRenderer.cs | 114 +++-- src/SharpMUTerm.Tui/WorldsScreenView.cs | 6 +- .../Automation/AliasAndMacroTests.cs | 22 + .../Automation/TriggerEngineTests.cs | 19 + .../PaneDragEndToEndTests.cs | 7 + .../ScreenCursorTests.cs | 107 ++++- .../ScreenFieldRenderingTests.cs | 199 +++++++++ .../SharpMUTerm.Tui.Tests/ScreenFieldTests.cs | 192 +++++++++ .../SettingsSessionEditTests.cs | 395 ++++++++++++++++++ .../SettingsSessionTests.cs | 2 +- 36 files changed, 2183 insertions(+), 193 deletions(-) create mode 100644 src/SharpMUTerm.Tui/ScreenField.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/ScreenFieldRenderingTests.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/ScreenFieldTests.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/SettingsSessionEditTests.cs diff --git a/CLAUDE.md b/CLAUDE.md index 91b75ba2..f40bf4e8 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -32,7 +32,7 @@ fallbacks) for inline images/maps. ## Repository state **M1 delivered, plus substantial M2–M4 work.** `SharpMUTerm.slnx` builds all ten projects on -`net10.0`; the solution has **764 passing tests**. In place: +`net10.0`; the solution has **811 passing tests**. In place: - **Core** — `AnsiParser` (SGR 16/256/truecolor), styled-line + `ScrollbackBuffer` model, `TcpTransport` (TLS + IPv6), `TelnetSession` (wraps TelnetNegotiationCore **2.5.3**), diff --git a/docs/HANDOFF.md b/docs/HANDOFF.md index 00a250c0..998d4cf6 100644 --- a/docs/HANDOFF.md +++ b/docs/HANDOFF.md @@ -4,8 +4,8 @@ Context for whoever (human or agent) picks up this work next. - **Repository:** `SharpMUSH/SharpMUTerm` - **Start from:** a fresh branch off `main` -- **Tests:** 764 across the solution (325 Core / 83 Graphics / 42 Scripting / - 28 Web / 286 Tui), all green; `dotnet build SharpMUTerm.slnx` clean (0 warnings +- **Tests:** 811 across the solution (327 Core / 83 Graphics / 42 Scripting / + 28 Web / 331 Tui), all green; `dotnet build SharpMUTerm.slnx` clean (0 warnings from this repo; building against a local SharpConsoleUI clone surfaces 2 upstream NuGet advisory warnings for AngleSharp, which are the framework's, not ours) @@ -18,23 +18,22 @@ polish/feature backlog. ### 1. Field editing on the config screens -The settings screens navigate (↑↓, ⇥) and toggle (Space), but **nothing lets you -type**: no new host, interval, or pattern. No header advertises editing either, -and a test pins that (`ScreenCursorTests.cs:191` asserts no screen shows -`⏎ edit` / `⏎ rebind` / `⏎ change`) — that assertion moves with the feature. +**Text/number/enum editing is done** — see *Settings screens* under Critical +Gotchas for how it works. What is left of this item: -Outstanding: - -- **Text/number/enum rows** — the actual edit mode, plus whatever key opens it. -- **Add/remove rows.** `[+ world]` / `[- del]` (`WorldsScreenRenderer.cs:195`) - and `[+ add character]` / `[⧉ duplicate]` / `[- remove]` - (`WorldsScreenRenderer.cs:249`) are painted but inert. +- **Add/remove rows.** `[+ world]` / `[- del]` (`WorldsScreenRenderer.cs`) and + `[+ add character]` / `[⧉ duplicate]` / `[- remove]` are painted but inert. + ⏎ is already the "activate the focused row" key, so a button row is a + `ScreenRow` with an action rather than a field — that is the natural shape. - **F2's route-to radio list and highlight-colour picker** (`TriggersScreenRenderer.cs`). Both are read-only indicators today; the highlight row deliberately never takes the cursor, because there is nothing to turn a colour on with yet. - -See *Settings screens* under Critical Gotchas for the pieces you'd be extending. +- **Rows still not editable** (deliberately, this pass): a macro's *key* + (rebinding needs a key-capture mode, not a text buffer), a character's + password (it is `[JsonIgnore]` and belongs in a credential store), a world's + TLS/certificate "security" line (two booleans, so checkboxes, not a field), + and everything derived (the numpad grid, the session/state readouts). ### 2. Real-terminal verification still owed @@ -119,7 +118,9 @@ Things that will waste your time if you don't know them. - **Snapshot view names:** `worlds`/`settings`, `triggers`, `aliases`, `timers`, `keypad`, `textansi`, `input`, `logging`, `freeze`, `spawn`, `split`, `move`, `drag`, `history`, `menu`, `menu-split`, plus the default (no `--view`) workspace. - Extra state toggles: `collapsed`, `prefix`, `timestamps`. + Extra state toggles: `collapsed`, `prefix`, `timestamps`. Any settings screen also + takes a `-edit` suffix (`worlds-edit`, `logging-edit`, …), which opens it and + drives real keys in so the frame shows a field mid-edit. - **Send the user the `.svg`** — they view it fine. Do **not** rely on your own SVG→PNG for pixel checks near the bottom (see next point). - **SVG→PNG clipping trap:** Chromium clips the bottom of a bare `.svg` file @@ -261,12 +262,43 @@ What the framework actually provides (read at v2.5.14, not assumed): padding, spread). - Interaction pieces: `ScreenSelection` (pure cursor state; pane sizes are passed in per move rather than cached, because a keystroke can change them), - `ScreenModel`/`ScreenToggle` (navigable panes + the config each checkbox writes - to, rebuilt from live config on every key by the renderer's own `Model(...)`), - `ScreenEdits` (the undo log), `SettingsSession` (key → `Redraw`/`Save`/`Cancel`/…, - where all the rules live so they're testable without a terminal), and - `SettingsOverlay` (the only UI-aware piece: on `Redraw` it does `ClearControls()` - + `AddControl(factory())` + `Invalidate(true)`). + `ScreenModel` (navigable panes of `ScreenRow`s, rebuilt from live config on every + key by the renderer's own `Model(...)`), `ScreenEdits` (the undo log), + `SettingsSession` (key → `Redraw`/`Save`/`Cancel`/…, where all the rules live so + they're testable without a terminal), and `SettingsOverlay` (the only UI-aware + piece: on `Redraw` it does `ClearControls()` + `AddControl(factory())` + + `Invalidate(true)`). +- **A row is a `ScreenRow`**: an optional `ScreenToggle` (Space) plus an ordered + list of `ScreenField`s (⏎ opens the first, ⇥ steps to the next). A row can be + both — a keypad binding is Space-enables + ⏎-edits-the-command. +- **Fields hang off existing rows, never off new ones.** A world's name/host/port/ + encoding/keepalive are the *WORLDS-list row's* fields, drawn in the detail + column; a timer's interval/command are the *timer row's*, drawn in the editor + pane. That is deliberate: giving a value an editor must not renumber the cursor + indices the panes already navigate by (and that the renderer tests pin). +- **Keys.** ⏎ activates the focused row when it has a field, else it saves and + closes. ⌃S always saves (committing an open field first, and refusing if that + field won't validate). Esc cancels the screen — except mid-edit, where it + abandons the buffer and leaves the screen up. Inside an edit: typing inserts, + Backspace/Delete remove, ←→/Home/End move the caret, ↑↓ cycle an enum's choices, + ⇥ commits and steps to the row's next field, ⏎ commits. +- **Validation is at commit, not per keystroke.** Any character can be typed; + ⏎/⇥/⌃S validate. A rejected value keeps the edit open, marks the field with the + reason, and writes nothing — `ScreenEdits.Apply(field, value)` is the only path + from a buffer into config, which is what keeps an invalid one out. +- **Header hints are derived, not written.** `HeaderLine(width, model, focus)` + reads `model.HasEditableRow`, so a screen physically cannot advertise `⏎ edit` + without offering one; `ScreenCursorTests` asserts the *if and only if* both ways. + While an edit is open the hints swap wholesale, because Esc no longer closes. +- **Making a Core property settable? Check for cached derived state.** + `Trigger.Pattern` and `Alias.Pattern` drop their compiled `Regex` on write, like + `Alias.CaseSensitive` already did — otherwise the rule goes on matching the + pattern it no longer has, invisibly, until a line arrives. +- **Snapshot `--view -edit`** opens a settings screen and then drives real + keys into it through `SettingsOverlay.SimulateKey` (the same handler + `PreviewKeyPressed` raises), so a frame can show a field genuinely mid-edit. + Keys cannot go in through the console driver here: the framework only subscribes + its key pump inside `Run()`, which a snapshot never enters. - **Screens edit config in place.** Cloning `AppConfiguration` would drop `[JsonIgnore]` fields like a character's in-memory password, so Esc is a replayed undo. A toggle's snapshot captures the **value**, not the boolean — F9's @@ -317,7 +349,8 @@ What the framework actually provides (read at v2.5.14, not assumed): | `src/SharpMUTerm.Tui/SettingsOverlay.cs` | Frameless full-screen overlay; routes keys to the screen's session and rebuilds its content | | `src/SharpMUTerm.Tui/SettingsSession.cs` | Key → action for an open settings screen (the whole interaction contract, testable) | | `src/SharpMUTerm.Tui/ScreenSelection.cs` | Pure pane/cursor state machine for the settings screens | -| `src/SharpMUTerm.Tui/ScreenModel.cs` | A screen's navigable panes + the config each checkbox binds to | +| `src/SharpMUTerm.Tui/ScreenModel.cs` | A screen's navigable panes; a `ScreenRow` is a stop, a checkbox, a record of editable fields, or both | +| `src/SharpMUTerm.Tui/ScreenField.cs` | One editable value: read / validate / write / snapshot, plus the text, number, regex, choice and enum kinds | | `src/SharpMUTerm.Tui/ScreenEdits.cs` | The undo log behind Cancel/Save | | `src/SharpMUTerm.Tui/PaneDragTracker.cs` | Pure drag gesture state machine + `MouseFlags` decoding | | `src/SharpMUTerm.Tui/PaneDragSurface.cs` | Pane rectangles + active windows, frozen at press | diff --git a/src/SharpMUTerm.Core/Automation/Alias.cs b/src/SharpMUTerm.Core/Automation/Alias.cs index fc4fc4bd..4426d9f6 100644 --- a/src/SharpMUTerm.Core/Automation/Alias.cs +++ b/src/SharpMUTerm.Core/Automation/Alias.cs @@ -12,10 +12,29 @@ public sealed class Alias { private Regex? _compiled; private bool _caseSensitive; + private string _pattern = string.Empty; public string Name { get; init; } = string.Empty; - public required string Pattern { get; init; } + /// + /// The .NET regular expression matched against typed input. Settable so the F3 settings screen can + /// edit it live; writing it drops the cached so the next match recompiles + /// against the new pattern rather than silently going on matching the old one. + /// + public required string Pattern + { + get => _pattern; + set + { + if (string.Equals(_pattern, value, StringComparison.Ordinal)) + { + return; + } + + _pattern = value; + _compiled = null; + } + } public bool Enabled { get; set; } = true; @@ -39,8 +58,12 @@ public bool CaseSensitive } } - /// The expansion template. May contain multiple newline-separated commands. - public string Substitution { get; init; } = string.Empty; + /// + /// The expansion template. May contain multiple newline-separated commands. Settable so the F3 + /// screen can edit it live; the engine reads it per expansion, so a change applies to the next + /// line typed. Nothing is cached from it. + /// + public string Substitution { get; set; } = string.Empty; /// Optional named script callback invoked instead of / in addition to expansion. public string? ScriptCallback { get; init; } diff --git a/src/SharpMUTerm.Core/Automation/Macro.cs b/src/SharpMUTerm.Core/Automation/Macro.cs index a39cd26e..a404a145 100644 --- a/src/SharpMUTerm.Core/Automation/Macro.cs +++ b/src/SharpMUTerm.Core/Automation/Macro.cs @@ -14,8 +14,11 @@ public sealed class Macro public bool Enabled { get; set; } = true; - /// The command to send when the key is pressed. - public string Command { get; init; } = string.Empty; + /// + /// The command to send when the key is pressed. Settable so the F4 screen can edit it live; the + /// engine reads it per press, so a change applies to the next one. Nothing is cached from it. + /// + public string Command { get; set; } = string.Empty; /// Optional named script callback (resolved by the scripting layer). public string? ScriptCallback { get; init; } diff --git a/src/SharpMUTerm.Core/Automation/TimerDefinition.cs b/src/SharpMUTerm.Core/Automation/TimerDefinition.cs index 5b735594..04ba8bba 100644 --- a/src/SharpMUTerm.Core/Automation/TimerDefinition.cs +++ b/src/SharpMUTerm.Core/Automation/TimerDefinition.cs @@ -10,11 +10,18 @@ public sealed class TimerDefinition { public string Name { get; init; } = string.Empty; - /// Seconds between firings. Values ≤ 0 are treated as disabled. - public double IntervalSeconds { get; init; } + /// + /// Seconds between firings. Values ≤ 0 are treated as disabled. Settable so the F6 screen can edit + /// it live; the reads it when the timer is realised, so a change + /// applies on the next run. + /// + public double IntervalSeconds { get; set; } - /// The command sent on each firing (blank when a script callback is used instead). - public string Command { get; init; } = string.Empty; + /// + /// The command sent on each firing (blank when a script callback is used instead). Settable so the + /// F6 screen can edit it live; it is read per firing, so a change applies to the next one. + /// + public string Command { get; set; } = string.Empty; /// /// Fire only once after the interval rather than repeating. Settable so the F6 screen can flip it diff --git a/src/SharpMUTerm.Core/Automation/Trigger.cs b/src/SharpMUTerm.Core/Automation/Trigger.cs index 69605f49..761a00da 100644 --- a/src/SharpMUTerm.Core/Automation/Trigger.cs +++ b/src/SharpMUTerm.Core/Automation/Trigger.cs @@ -42,11 +42,29 @@ public sealed class TriggerActions public sealed class Trigger { private Regex? _compiled; + private string _pattern = string.Empty; public string Name { get; init; } = string.Empty; - /// The .NET regular expression matched against a line's plain text. - public required string Pattern { get; init; } + /// + /// The .NET regular expression matched against a line's plain text. Settable so the F2 settings + /// screen can edit it live; writing it drops the cached so the next match + /// recompiles against the new pattern rather than silently going on matching the old one. + /// + public required string Pattern + { + get => _pattern; + set + { + if (string.Equals(_pattern, value, StringComparison.Ordinal)) + { + return; + } + + _pattern = value; + _compiled = null; + } + } public bool Enabled { get; set; } = true; diff --git a/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs b/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs index 2c5de8ee..67790f34 100644 --- a/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs @@ -36,7 +36,7 @@ public static List Render(IReadOnlyList sets, int selected) var left = ListColumn(sets, selected); var right = EditorColumn(sets, selected); - var lines = new List { HeaderLine(0), string.Empty }; + var lines = new List { HeaderLine(0, Model(sets, selected)), string.Empty }; var rowCount = Math.Max(left.Count, right.Count); for (var i = 0; i < rowCount; i++) @@ -52,34 +52,44 @@ public static List Render(IReadOnlyList sets, int selected) return lines; } - /// The screen title on the left, the keyboard hints right-aligned to . - internal static string HeaderLine(int width) + /// + /// The screen title on the left, the keyboard hints right-aligned to . The + /// hints are derived from and rather than + /// written here, so the header cannot advertise an edit the screen doesn't offer. + /// + internal static string HeaderLine(int width, ScreenModel? model = null, ScreenFocus? focus = null) { var title = $"[bold {Value}] Aliases[/]"; - var hints = ScreenChrome.Hints(ScreenChrome.ListHints, "F3"); + var hints = ScreenChrome.Hints( + ScreenChrome.ListHints, "F3", model?.HasEditableRow ?? false, focus); return SpreadLR(" " + title, hints, width); } /// - /// The screen's navigable panes: the alias list (Space enables/disables one) and the selected - /// alias's checkbox rows, in the order draws them. + /// The screen's navigable panes: the alias list (Space enables/disables one, ⏎ edits its pattern + /// and then — with ⇥ — its expansion) and the selected alias's checkbox rows, in the order + /// draws them. Both values hang off the list row rather than becoming + /// rows of their own, so the editor pane's cursor indices keep meaning what they meant. /// internal static ScreenModel Model(IReadOnlyList sets, int selected) { ArgumentNullException.ThrowIfNull(sets); var entries = Flatten(sets); - var list = ScreenModel.Toggles(entries, e => e.Alias.Enabled, (e, v) => e.Alias.Enabled = v); + var list = ScreenModel.Rows(entries, entry => ScreenRow.Of( + ScreenToggle.Bind(() => entry.Alias.Enabled, v => entry.Alias.Enabled = v), + ScreenField.Pattern("match pattern", () => entry.Alias.Pattern, v => entry.Alias.Pattern = v), + ScreenField.Lines("expansion", () => entry.Alias.Substitution, v => entry.Alias.Substitution = v))); if (selected < 0 || selected >= entries.Count) { - return new ScreenModel(list, Array.Empty()); + return new ScreenModel(list, Array.Empty()); } var alias = entries[selected].Alias; - var editor = new ScreenToggle?[] + var editor = new[] { - ScreenToggle.Bind(() => alias.CaseSensitive, v => alias.CaseSensitive = v), + ScreenRow.Of(ScreenToggle.Bind(() => alias.CaseSensitive, v => alias.CaseSensitive = v)), }; return new ScreenModel(list, editor); @@ -135,9 +145,10 @@ internal static List EditorColumn( { ArgumentNullException.ThrowIfNull(sets); + var cursor = focus ?? ScreenFocus.None; var entries = Flatten(sets); return selected >= 0 && selected < entries.Count - ? BuildEditor(entries[selected].Alias, focus ?? ScreenFocus.None) + ? BuildEditor(entries[selected].Alias, cursor, selected) : new List(); } @@ -166,19 +177,29 @@ private static string Row(Alias alias, string setName, bool selected) return $"{check} {marker} [bold]{name}[/] [dim]{pattern}[/] [dim]▪ {Escape(setName)}[/] → {expansion}"; } - private static List BuildEditor(Alias alias, ScreenFocus cursor) + private static List BuildEditor(Alias alias, ScreenFocus cursor, int selected) { var lines = new List { "[dim]match pattern (regex)[/]", - $" {Escape(alias.Pattern)}", + $" {ScreenChrome.Field(Escape(alias.Pattern), cursor.EditOn(0, selected, 0))}", string.Empty, "[dim]expands to[/]", }; - foreach (var line in alias.Substitution.Split('\n')) + // An expansion is one command per line, so it normally lists. While it is being typed it is a + // single buffer with the breaks written \n (see ScreenField.Lines), and it has to be drawn the + // way it is being edited — one row — or the caret would have nowhere honest to sit. + if (cursor.EditOn(0, selected, 1) is { } expansion) { - lines.Add($" {Escape(line)}"); + lines.Add(" " + ScreenChrome.Field(string.Empty, expansion)); + } + else + { + foreach (var line in alias.Substitution.Split('\n')) + { + lines.Add($" {Escape(line)}"); + } } lines.Add(string.Empty); diff --git a/src/SharpMUTerm.Tui/AliasesScreenView.cs b/src/SharpMUTerm.Tui/AliasesScreenView.cs index 336a3929..b0832dfe 100644 --- a/src/SharpMUTerm.Tui/AliasesScreenView.cs +++ b/src/SharpMUTerm.Tui/AliasesScreenView.cs @@ -20,7 +20,9 @@ internal static class AliasesScreenView public static IWindowControl Build( IReadOnlyList sets, int selected, int width, ScreenFocus? focus = null) { - var header = ScreenChrome.Band(AliasesScreenRenderer.HeaderLine(width), ScreenPalette.HeaderBg); + var header = ScreenChrome.Band( + AliasesScreenRenderer.HeaderLine(width, AliasesScreenRenderer.Model(sets, selected), focus), + ScreenPalette.HeaderBg); var footer = ScreenChrome.Band(AliasesScreenRenderer.FooterLine(sets, selected, width), ScreenPalette.FooterBg); // Body: alias list │ editor, as two real columns. diff --git a/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs b/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs index a735f178..db29cb6c 100644 --- a/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs @@ -45,7 +45,7 @@ public static List Render(IReadOnlyList macros) var left = NumpadColumn(macros); var right = HotkeysColumn(macros); - var lines = new List { HeaderLine(0), string.Empty }; + var lines = new List { HeaderLine(0, Model(macros)), string.Empty }; var rowCount = Math.Max(left.Count, right.Count); for (var i = 0; i < rowCount; i++) @@ -61,23 +61,31 @@ public static List Render(IReadOnlyList macros) return lines; } - /// The screen title on the left, the keyboard hints right-aligned to . - internal static string HeaderLine(int width) + /// + /// The screen title on the left, the keyboard hints right-aligned to . The + /// hints are derived from and rather than + /// written here, so the header cannot advertise an edit the screen doesn't offer. + /// + internal static string HeaderLine(int width, ScreenModel? model = null, ScreenFocus? focus = null) { var title = $"[bold {Value}] Keypad & hotkeys[/]"; - var hints = ScreenChrome.Hints(ScreenChrome.SingleListHints, "F4"); + var hints = ScreenChrome.Hints( + ScreenChrome.SingleListHints, "F4", model?.HasEditableRow ?? false, focus); return SpreadLR(" " + title, hints, width); } /// - /// The screen's one navigable pane: the binding list, where Space enables or disables a macro. - /// The numpad grid is a projection of the same macros, so it has no cursor of its own — it - /// updates as the list is toggled. + /// The screen's one navigable pane: the binding list, where Space enables or disables a macro and + /// ⏎ edits the command it sends. The numpad grid is a projection of the same macros, so it has no + /// cursor of its own — it updates as the list is toggled and edited. /// internal static ScreenModel Model(IReadOnlyList macros) { ArgumentNullException.ThrowIfNull(macros); - return new ScreenModel(ScreenModel.Toggles(macros, m => m.Enabled, (m, v) => m.Enabled = v)); + + return new ScreenModel(ScreenModel.Rows(macros, macro => ScreenRow.Of( + ScreenToggle.Bind(() => macro.Enabled, v => macro.Enabled = v), + ScreenField.Text("command", () => macro.Command, v => macro.Command = v)))); } /// The action bar: how much of the keypad is bound on the left, cancel/save on the right. @@ -134,7 +142,8 @@ internal static List HotkeysColumn(IReadOnlyList macros, ScreenFo for (var i = 0; i < macros.Count; i++) { - lines.Add(ScreenChrome.Cursor(Hotkey(macros[i]), cursor.IsOn(0, i), ColumnWidth)); + lines.Add(ScreenChrome.Cursor( + Hotkey(macros[i], cursor.EditOn(0, i, 0)), cursor.IsOn(0, i), ColumnWidth)); } return lines; @@ -163,11 +172,11 @@ private static string NumpadCell(int digit, IReadOnlyList macros) return $"[bold {Accent}][[{digit}]][/] {command}"; } - private static string Hotkey(Macro macro) + private static string Hotkey(Macro macro, ScreenFieldEdit? edit) { var tick = macro.Enabled ? $"[{Accent}]✓[/]" : "[dim]·[/]"; var key = $"[bold]{Escape(macro.Key).PadRight(KeyColumnWidth)}[/]"; - return $"{tick} {key} → {Escape(macro.Command)}"; + return $"{tick} {key} → {ScreenChrome.Field(Escape(macro.Command), edit)}"; } private static Macro? FindByKey(IReadOnlyList macros, string key) diff --git a/src/SharpMUTerm.Tui/KeypadScreenView.cs b/src/SharpMUTerm.Tui/KeypadScreenView.cs index e951c5a7..f73da1e7 100644 --- a/src/SharpMUTerm.Tui/KeypadScreenView.cs +++ b/src/SharpMUTerm.Tui/KeypadScreenView.cs @@ -20,7 +20,9 @@ internal static class KeypadScreenView public static IWindowControl Build(IReadOnlyList macros, int width, ScreenFocus? focus = null) { - var header = ScreenChrome.Band(KeypadScreenRenderer.HeaderLine(width), ScreenPalette.HeaderBg); + var header = ScreenChrome.Band( + KeypadScreenRenderer.HeaderLine(width, KeypadScreenRenderer.Model(macros), focus), + ScreenPalette.HeaderBg); var footer = ScreenChrome.Band(KeypadScreenRenderer.FooterLine(macros, width), ScreenPalette.FooterBg); // Body: numpad grid │ hotkey list, as two real columns. diff --git a/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs b/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs index af688255..b279e92e 100644 --- a/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs @@ -20,11 +20,17 @@ internal static class OptionsScreenRenderer /// /// A single options-list row: a toggle, a value row, a section header, or a spacer. - /// is the config the checkbox writes to; a row without one still takes the - /// cursor but Space does nothing there (the value rows, until field editing exists). + /// is the config the checkbox writes to; is the + /// config the value writes to, which is what makes a value row activatable with ⏎. A row with + /// neither still takes the cursor but nothing happens there. /// public readonly record struct OptionRow( - string Label, string? Value, bool? Toggle, string? Hint = null, ScreenToggle? Bind = null); + string Label, + string? Value, + bool? Toggle, + string? Hint = null, + ScreenToggle? Bind = null, + ScreenField? Edit = null); /// One options screen: the title and F-key its chrome shows, plus the rows it lists. internal readonly record struct OptionsScreen(string Title, string FKey, IReadOnlyList Rows); @@ -37,7 +43,8 @@ public static List Render(string title, string fkey, IReadOnlyList { HeaderLine(title, fkey, 0), string.Empty }; + var screen = new OptionsScreen(title, fkey, rows); + var lines = new List { HeaderLine(title, fkey, 0, Model(screen)), string.Empty }; lines.AddRange(BodyColumn(rows)); lines.Add(string.Empty); lines.Add(FooterLine(rows, 0)); @@ -49,12 +56,20 @@ public static List Render(string title, string fkey, IReadOnlyList /// The back affordance and screen title on the left, the keyboard hints right-aligned to - /// . + /// . The hints are derived from and + /// rather than written here, so the header cannot advertise an edit the + /// screen doesn't offer; called without them it describes a screen that only navigates. /// - internal static string HeaderLine(string title, string fkey, int width) + internal static string HeaderLine( + string title, string fkey, int width, ScreenModel? model = null, ScreenFocus? focus = null) { var heading = $"[{Label}]‹ back[/] [bold {Value}]{Escape(title)}[/]"; - return SpreadLR(" " + heading, ScreenChrome.Hints(ScreenChrome.SingleListHints, Escape(fkey)), width); + var hints = ScreenChrome.Hints( + ScreenChrome.SingleListHints, + Escape(fkey), + model?.HasEditableRow ?? false, + focus); + return SpreadLR(" " + heading, hints, width); } /// The action bar: how much the screen holds on the left, cancel/save on the right. @@ -88,13 +103,13 @@ internal static List BodyColumn( var navigable = 0; foreach (var row in rows) { - var line = RenderRow(row); if (IsSpacer(row) || IsSection(row)) { - lines.Add(line); + lines.Add(RenderRow(row, null)); continue; } + var line = RenderRow(row, cursor.EditOn(0, navigable, 0)); lines.Add(ScreenChrome.Cursor(line, cursor.IsOn(0, navigable), width)); navigable++; } @@ -104,18 +119,19 @@ internal static List BodyColumn( /// /// The screen's one navigable pane: every row that isn't a spacer or a section header, in display - /// order, each carrying whatever config binding it was built with. + /// order, each carrying whatever config bindings it was built with — the checkbox Space flips and + /// the value ⏎ opens. /// internal static ScreenModel Model(OptionsScreen screen) { var rows = screen.Rows .Where(r => !IsSpacer(r) && !IsSection(r)) - .Select(r => r.Bind) + .Select(r => r.Edit is { } field ? new ScreenRow(r.Bind, new[] { field }) : new ScreenRow(r.Bind)) .ToArray(); return new ScreenModel(rows); } - private static string RenderRow(OptionRow row) + private static string RenderRow(OptionRow row, ScreenFieldEdit? edit) { if (IsSpacer(row)) { @@ -136,7 +152,8 @@ private static string RenderRow(OptionRow row) } var label = Escape(row.Label).PadRight(LabelWidth); - return $"[dim]{label}[/] {Escape(row.Value ?? string.Empty)}{hint}"; + var value = ScreenChrome.Field(Escape(row.Value ?? string.Empty), edit); + return $"[dim]{label}[/] {value}{hint}"; } /// A blank separator carrying no label, value, or toggle. @@ -168,10 +185,21 @@ internal static OptionsScreen TextAnsiScreen(TextSettings? text = null) new("├ UNICODE", null, null), new("emoji substitution", null, settings.EmojiSubstitution, null, ScreenToggle.Bind(() => settings.EmojiSubstitution, v => settings.EmojiSubstitution = v)), - new("ambiguous width", settings.AmbiguousWidth, null), + new("ambiguous width", settings.AmbiguousWidth, null, null, null, + ScreenField.Choice( + "ambiguous width", + () => settings.AmbiguousWidth, + v => settings.AmbiguousWidth = v, + AmbiguousWidths)), }); } + /// + /// How East Asian ambiguous-width characters may be measured. A fixed set rather than free text: + /// the measurer only knows these two, and a typo would silently fall back to one of them. + /// + private static readonly string[] AmbiguousWidths = { "narrow", "wide" }; + /// /// The F8 "Input & spellcheck" screen, reflecting — and writing back to — the app's /// . @@ -187,12 +215,14 @@ internal static OptionsScreen InputSpellcheckScreen(InputSettings? input = null) ScreenToggle.Bind(() => settings.LocalEcho, v => settings.LocalEcho = v)), new("keep per-tab drafts", null, settings.KeepDrafts, null, ScreenToggle.Bind(() => settings.KeepDrafts, v => settings.KeepDrafts = v)), - new("newline key", settings.NewlineKey, null), + new("newline key", settings.NewlineKey, null, null, null, + ScreenField.Text("newline key", () => settings.NewlineKey, v => settings.NewlineKey = v)), new(string.Empty, null, null), new("├ SPELLCHECK", null, null), new("check spelling", null, settings.CheckSpelling, null, ScreenToggle.Bind(() => settings.CheckSpelling, v => settings.CheckSpelling = v)), - new("dictionary", settings.Dictionary, null), + new("dictionary", settings.Dictionary, null, null, null, + ScreenField.Text("dictionary", () => settings.Dictionary, v => settings.Dictionary = v)), }); } @@ -217,8 +247,10 @@ internal static OptionsScreen LoggingScreen(LoggingSettings logging) return new OptionsScreen("Logging", "F9", new List { new("├ SESSION LOG", null, null), - new("format", logging.Format.ToString(), null), - new("directory", logging.Directory ?? "(default)", null), + new("format", logging.Format.ToString(), null, null, null, + ScreenField.Enumeration("format", () => logging.Format, v => logging.Format = v)), + new("directory", logging.Directory ?? "(default)", null, null, null, + ScreenField.Optional("directory", () => logging.Directory, v => logging.Directory = v)), new("auto-start on connect", null, logging.Format != LogFormat.None, null, autoStart), }); } diff --git a/src/SharpMUTerm.Tui/OptionsScreenView.cs b/src/SharpMUTerm.Tui/OptionsScreenView.cs index 298876ea..bacbcfda 100644 --- a/src/SharpMUTerm.Tui/OptionsScreenView.cs +++ b/src/SharpMUTerm.Tui/OptionsScreenView.cs @@ -26,7 +26,9 @@ public static IWindowControl Build( OptionsScreenRenderer.OptionsScreen screen, int width, ScreenFocus? focus = null) { var header = ScreenChrome.Band( - OptionsScreenRenderer.HeaderLine(screen.Title, screen.FKey, width), ScreenPalette.HeaderBg); + OptionsScreenRenderer.HeaderLine( + screen.Title, screen.FKey, width, OptionsScreenRenderer.Model(screen), focus), + ScreenPalette.HeaderBg); var footer = ScreenChrome.Band( OptionsScreenRenderer.FooterLine(screen.Rows, width), ScreenPalette.FooterBg); diff --git a/src/SharpMUTerm.Tui/Program.cs b/src/SharpMUTerm.Tui/Program.cs index 91de351b..b2158d0f 100644 --- a/src/SharpMUTerm.Tui/Program.cs +++ b/src/SharpMUTerm.Tui/Program.cs @@ -154,6 +154,7 @@ private static void PrintUsage() Console.WriteLine(" --snapshot Render one demo frame (ANSI) headlessly and exit."); Console.WriteLine(" --size Snapshot size in cells (default 160x48)."); Console.WriteLine(" --view Snapshot an overlay (e.g. 'settings') over the workspace."); + Console.WriteLine(" '-edit' opens that settings screen mid field edit."); Console.WriteLine(" --out Write the snapshot to a file instead of stdout."); Console.WriteLine(" -h, --help Show this help."); Console.WriteLine(); diff --git a/src/SharpMUTerm.Tui/ScreenChrome.cs b/src/SharpMUTerm.Tui/ScreenChrome.cs index 1565db89..f6123b3f 100644 --- a/src/SharpMUTerm.Tui/ScreenChrome.cs +++ b/src/SharpMUTerm.Tui/ScreenChrome.cs @@ -16,10 +16,26 @@ internal static class ScreenChrome /// /// The right-hand keyboard hints of a header band: the screen's verbs, then how to close it. /// is the F-key that also toggles the screen (F6/Esc close). + /// + /// comes from the screen's , never from the + /// screen itself: a header may only claim ⏎ opens an editor when a row actually offers one. While + /// an edit *is* open the hints change wholesale — Esc no longer closes the screen, it abandons the + /// buffer, and saying otherwise would be the same lie in the other direction. + /// /// - internal static string Hints(string verbs, string fkey) => - $"[{ScreenPalette.Label}]{verbs} · [/][{ScreenPalette.Accent}]{fkey}[/][{ScreenPalette.Label}]/[/]" - + $"[{ScreenPalette.Accent}]Esc[/][{ScreenPalette.Label}] close [/]"; + internal static string Hints(string verbs, string fkey, bool editable = false, ScreenFocus? focus = null) + { + if (focus?.Edit is { } edit) + { + var editing = edit.RowFields > 1 ? EditingHints + NextFieldHint : EditingHints; + return $"[{ScreenPalette.Label}]{editing} · [/][{ScreenPalette.Accent}]{fkey}[/]" + + $"[{ScreenPalette.Label}] close [/]"; + } + + var all = editable ? verbs + EditHint : verbs; + return $"[{ScreenPalette.Label}]{all} · [/][{ScreenPalette.Accent}]{fkey}[/][{ScreenPalette.Label}]/[/]" + + $"[{ScreenPalette.Accent}]Esc[/][{ScreenPalette.Label}] close [/]"; + } /// /// The keyboard hints every screen with a list and a checkbox pane shares. Kept in one place so a @@ -30,6 +46,17 @@ internal static string Hints(string verbs, string fkey) => /// The hints for a screen that is a single list with no second pane to ⇥ into. internal const string SingleListHints = "↑↓ select · Space toggle"; + /// + /// What a screen adds to its hints when — and only when — its model offers a row ⏎ can open. + /// + internal const string EditHint = " · ⏎ edit"; + + /// The hints that replace a screen's own while a field edit is open. + internal const string EditingHints = "⏎ commit · Esc revert"; + + /// Added to only when the row has another field to step to. + internal const string NextFieldHint = " · ⇥ next field"; + /// /// The right-hand actions of a footer bar. lets a screen with a /// context colour (F5's per-world accent) tint the Save chip; it defaults to the app accent. @@ -46,6 +73,38 @@ internal static string Actions(string? accent = null) => internal static string Cursor(string row, bool focused, int width) => focused ? $"[on {ScreenPalette.CursorBg}]{MarkupText.PadVisible(row, width)}[/]" : row; + /// + /// Draws a row's editable value: its committed text when nothing is being typed, or — when + /// is the open edit for that field — the buffer, a block caret sitting + /// inside it, and the reason the last commit was refused. Every screen draws fields, so the + /// affordance lives here rather than being re-invented (and drifting) per renderer. + /// + /// is already markup, because a screen decides for itself how a + /// committed value reads (a null log directory shows as (default)); the buffer is escaped + /// here, since what has been typed is raw text. + /// + /// + internal static string Field(string display, ScreenFieldEdit? edit) + { + if (edit is not { } open) + { + return display; + } + + var caret = Math.Clamp(open.Caret, 0, open.Text.Length); + var before = MarkupText.Escape(open.Text[..caret]); + var under = caret < open.Text.Length ? MarkupText.Escape(open.Text[caret].ToString()) : " "; + var after = caret < open.Text.Length ? MarkupText.Escape(open.Text[(caret + 1)..]) : string.Empty; + + var buffer = $"[{ScreenPalette.Value} on {ScreenPalette.FieldBg}]{before}[/]" + + $"[{ScreenPalette.Ink} on {ScreenPalette.Accent}]{under}[/]" + + $"[{ScreenPalette.Value} on {ScreenPalette.FieldBg}]{after} [/]"; + + return open.Error is { } error + ? $"{buffer} [{ScreenPalette.Warn}]▲ {MarkupText.Escape(error)}[/]" + : buffer; + } + /// A full-width one-row band — the header or the footer. internal static MarkupControl Band(string line, string bg) => new(new List { line }) { diff --git a/src/SharpMUTerm.Tui/ScreenEdits.cs b/src/SharpMUTerm.Tui/ScreenEdits.cs index 9acc982b..127fcbce 100644 --- a/src/SharpMUTerm.Tui/ScreenEdits.cs +++ b/src/SharpMUTerm.Tui/ScreenEdits.cs @@ -5,8 +5,8 @@ namespace SharpMUTerm.Tui; /// place — cloning would silently drop /// the fields that deliberately don't round-trip (a character's in-memory password is /// [JsonIgnore]) — so "discard" is a replayed undo rather than a swapped object. Each applied -/// toggle pushes the restore action captured *before* it ran; Esc replays them newest-first, ⏎ drops -/// them. Pure state, so the semantics are unit-testable without a window. +/// toggle or committed field pushes the restore action captured *before* it ran; Esc replays them +/// newest-first, ⏎ drops them. Pure state, so the semantics are unit-testable without a window. /// internal sealed class ScreenEdits { @@ -25,6 +25,27 @@ internal void Apply(ScreenToggle toggle) toggle.Flip(); } + /// + /// Writes a typed value to a field, recording how to put the old one back — the same undo entry a + /// toggle pushes, so Esc restores an edited host exactly as it restores a flipped checkbox. + /// Nothing is written and nothing is recorded when the value doesn't validate: returns null when + /// the value was accepted, otherwise why it was refused. This is the only path from a buffer into + /// config, which is what keeps an invalid value out of it. + /// + internal string? Apply(ScreenField field, string value) + { + ArgumentNullException.ThrowIfNull(value); + + if (field.Validate(value) is { } error) + { + return error; + } + + _undo.Add(field.Snapshot()); + field.Set(value); + return null; + } + /// Undoes every pending change, newest first, so overlapping edits unwind correctly. internal void Revert() { diff --git a/src/SharpMUTerm.Tui/ScreenField.cs b/src/SharpMUTerm.Tui/ScreenField.cs new file mode 100644 index 00000000..1e66c0e5 --- /dev/null +++ b/src/SharpMUTerm.Tui/ScreenField.cs @@ -0,0 +1,309 @@ +using System.Globalization; +using System.Text.RegularExpressions; + +namespace SharpMUTerm.Tui; + +/// +/// A field edit in flight, as the renderers need to draw it: which of the focused row's fields is +/// open, the buffer being typed, where the caret sits inside it, and why the last commit was refused +/// (null while nothing has been rejected). It carries the buffer rather than the field because the +/// buffer is deliberately *not* in config — an invalid value must never reach it, so what is being +/// typed lives in the session until it validates. +/// +/// Which of the row's fields is open, in the row's own field order. +/// The buffer being typed. +/// The caret's index into (may equal its length). +/// Why the last commit was refused, or null. +/// +/// How many fields the row holds — the chrome only offers ⇥ when there is a next field to step to. +/// +internal readonly record struct ScreenFieldEdit( + int Field, string Text, int Caret, string? Error, int RowFields = 1); + +/// +/// An editable value on a settings row: how to read it as text, whether a typed string is a legal +/// value for it, how to write it, and how to put back exactly what was there before. It follows +/// 's Get / write / Snapshot shape for the same reason — the snapshot +/// captures the *typed* value, so undo restores an int port or a LogFormat rather than +/// the string it was displayed as. +/// +/// Validation is deliberately split from writing: a screen validates a buffer before it is applied, +/// so a rejected value is refused at the field rather than parsed into config and corrected +/// afterwards. is set for the enum-like fields, which additionally cycle with +/// ↑↓ while the edit is open. +/// +/// +/// What the field is called, used in its rejection messages. +/// Reads the current value as the text an edit opens on. +/// Returns null when a buffer is a legal value, else why it isn't. +/// Writes a buffer that has already accepted. +/// Captures the current value, returning the action that restores it. +/// The legal values when the field is an enumeration, else null. +internal readonly record struct ScreenField( + string Label, + Func Get, + Func Validate, + Action Set, + Func Snapshot, + IReadOnlyList? Choices = null) +{ + /// Longest rejection message kept; regex parser errors run to several lines otherwise. + private const int MaxErrorLength = 44; + + /// + /// The choice steps from , wrapping at both + /// ends — how ↑↓ move through an enum field. Null when the field isn't an enumeration. A buffer + /// that isn't one of the choices (half-typed) steps from the start. + /// + internal string? Cycle(string current, int direction) + { + if (Choices is not { Count: > 0 } choices) + { + return null; + } + + var at = -1; + for (var i = 0; i < choices.Count; i++) + { + if (string.Equals(choices[i], current, StringComparison.OrdinalIgnoreCase)) + { + at = i; + break; + } + } + + var next = at < 0 ? (direction > 0 ? 0 : choices.Count - 1) : at + direction; + return choices[((next % choices.Count) + choices.Count) % choices.Count]; + } + + /// Free text that may not be blank — a name, a host, a dictionary. Trimmed on commit. + internal static ScreenField Text(string label, Func get, Action set) + { + ArgumentNullException.ThrowIfNull(get); + ArgumentNullException.ThrowIfNull(set); + + return new ScreenField( + label, + get, + value => string.IsNullOrWhiteSpace(value) ? $"{label} cannot be empty" : null, + value => set(value.Trim()), + Restore(get, set)); + } + + /// + /// Free text that may be blank, held as null when it is — the "unset, use the default" fields + /// (a log directory, an on-connect command). + /// + internal static ScreenField Optional(string label, Func get, Action set) + { + ArgumentNullException.ThrowIfNull(get); + ArgumentNullException.ThrowIfNull(set); + + return new ScreenField( + label, + () => get() ?? string.Empty, + _ => null, + value => set(string.IsNullOrWhiteSpace(value) ? null : value.Trim()), + Restore(get, set)); + } + + /// + /// A .NET regular expression, rejected unless it actually compiles — a trigger or alias whose + /// pattern doesn't parse would throw on the next line the engine matched, not here. + /// + internal static ScreenField Pattern(string label, Func get, Action set) + { + ArgumentNullException.ThrowIfNull(get); + ArgumentNullException.ThrowIfNull(set); + + return new ScreenField(label, get, ValidatePattern, set, Restore(get, set)); + } + + /// + /// Text that may hold newlines (an alias expansion is one command per line), edited on one row + /// with the breaks written \n — so a multi-line value is still editable without the + /// screens growing a multi-line editor. A literal backslash round-trips as \\. + /// + internal static ScreenField Lines(string label, Func get, Action set) + { + ArgumentNullException.ThrowIfNull(get); + ArgumentNullException.ThrowIfNull(set); + + return new ScreenField( + label, + () => EscapeBreaks(get()), + value => value.Length == 0 ? $"{label} cannot be empty" : null, + value => set(ExpandBreaks(value)), + Restore(get, set)); + } + + /// A whole number inside an inclusive range — a port, a keepalive interval. + internal static ScreenField Integer(string label, Func get, Action set, int min, int max) + { + ArgumentNullException.ThrowIfNull(get); + ArgumentNullException.ThrowIfNull(set); + + return new ScreenField( + label, + () => get().ToString(CultureInfo.InvariantCulture), + value => TryInteger(value, min, max, out _) + ? null + : $"{label} must be a whole number {min}-{max}", + value => + { + TryInteger(value, min, max, out var parsed); + set(parsed); + }, + Restore(get, set)); + } + + /// A fractional number inside an inclusive range — a timer's interval in seconds. + internal static ScreenField Number( + string label, Func get, Action set, double min, double max) + { + ArgumentNullException.ThrowIfNull(get); + ArgumentNullException.ThrowIfNull(set); + + return new ScreenField( + label, + () => get().ToString("0.####", CultureInfo.InvariantCulture), + value => TryNumber(value, min, max, out _) + ? null + : $"{label} must be a number {Format(min)}-{Format(max)}", + value => + { + TryNumber(value, min, max, out var parsed); + set(parsed); + }, + Restore(get, set)); + } + + /// One of a fixed set of names, matched case-insensitively and stored canonically. + internal static ScreenField Choice( + string label, Func get, Action set, IReadOnlyList choices) + { + ArgumentNullException.ThrowIfNull(get); + ArgumentNullException.ThrowIfNull(set); + ArgumentNullException.ThrowIfNull(choices); + + return new ScreenField( + label, + get, + value => Canonical(choices, value) is null ? $"{label} must be one of: {string.Join(", ", choices)}" : null, + value => set(Canonical(choices, value) ?? value), + Restore(get, set), + choices); + } + + /// An enum value, typed or cycled by name — F9's log format is the canonical case. + internal static ScreenField Enumeration(string label, Func get, Action set) + where TEnum : struct, Enum + { + ArgumentNullException.ThrowIfNull(get); + ArgumentNullException.ThrowIfNull(set); + + var names = Enum.GetNames(); + return new ScreenField( + label, + () => get().ToString() ?? string.Empty, + value => Canonical(names, value) is null ? $"{label} must be one of: {string.Join(", ", names)}" : null, + value => + { + if (Enum.TryParse(value.Trim(), ignoreCase: true, out var parsed)) + { + set(parsed); + } + }, + Restore(get, set), + names); + } + + /// Captures a value of any type and returns the action that writes it back. + private static Func Restore(Func get, Action set) => + () => + { + var previous = get(); + return () => set(previous); + }; + + private static string? Canonical(IReadOnlyList choices, string value) + { + var trimmed = value.Trim(); + foreach (var choice in choices) + { + if (string.Equals(choice, trimmed, StringComparison.OrdinalIgnoreCase)) + { + return choice; + } + } + + return null; + } + + private static bool TryInteger(string value, int min, int max, out int parsed) => + int.TryParse(value.Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out parsed) + && parsed >= min && parsed <= max; + + private static bool TryNumber(string value, double min, double max, out double parsed) => + double.TryParse(value.Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out parsed) + && parsed >= min && parsed <= max; + + private static string Format(double value) => value.ToString("0.####", CultureInfo.InvariantCulture); + + private static string? ValidatePattern(string value) + { + if (value.Length == 0) + { + return "pattern cannot be empty"; + } + + try + { + _ = new Regex(value); + return null; + } + catch (ArgumentException ex) + { + var reason = ex.Message.Split('\n')[0].Trim(); + return "not a valid regex: " + (reason.Length > MaxErrorLength + ? string.Concat(reason.AsSpan(0, MaxErrorLength - 1), "…") + : reason); + } + } + + /// Writes a value's line breaks as \n so it fits on one editable row. + private static string EscapeBreaks(string value) => + value.Replace("\\", "\\\\", StringComparison.Ordinal) + .Replace("\r\n", "\\n", StringComparison.Ordinal) + .Replace("\n", "\\n", StringComparison.Ordinal); + + /// The inverse of , applied when the buffer is committed. + private static string ExpandBreaks(string value) + { + var expanded = new System.Text.StringBuilder(value.Length); + for (var i = 0; i < value.Length; i++) + { + if (value[i] == '\\' && i + 1 < value.Length) + { + var next = value[i + 1]; + if (next == 'n') + { + expanded.Append('\n'); + i++; + continue; + } + + if (next == '\\') + { + expanded.Append('\\'); + i++; + continue; + } + } + + expanded.Append(value[i]); + } + + return expanded.ToString(); + } +} diff --git a/src/SharpMUTerm.Tui/ScreenFocus.cs b/src/SharpMUTerm.Tui/ScreenFocus.cs index 415c1d81..456d34f0 100644 --- a/src/SharpMUTerm.Tui/ScreenFocus.cs +++ b/src/SharpMUTerm.Tui/ScreenFocus.cs @@ -1,14 +1,16 @@ namespace SharpMUTerm.Tui; /// -/// What a renderer needs to know about the keyboard: which pane holds it and which row it is on. -/// Renderers take this as an optional argument so a screen rendered without one (the unit tests, and -/// any caller that only wants the projection) draws exactly what it always did — the cursor bar only -/// appears once a live screen says where the cursor is. +/// What a renderer needs to know about the keyboard: which pane holds it, which row it is on, and — +/// once ⏎ has opened one — the field edit in flight on that row. Renderers take this as an optional +/// argument so a screen rendered without one (the unit tests, and any caller that only wants the +/// projection) draws exactly what it always did — the cursor bar only appears once a live screen says +/// where the cursor is, and the caret only once one is actually being typed into. /// /// The pane the keyboard is in, or -1 for "no keyboard". /// The row the cursor is on within that pane. -internal readonly record struct ScreenFocus(int Pane, int Index) +/// The open field edit on that row, or null when the screen is navigating. +internal readonly record struct ScreenFocus(int Pane, int Index, ScreenFieldEdit? Edit = null) { /// No keyboard on this screen — nothing is drawn as the cursor. internal static ScreenFocus None => new(-1, -1); @@ -18,4 +20,14 @@ internal readonly record struct ScreenFocus(int Pane, int Index) /// Whether a pane holds the keyboard at all (its list draws its cursor, others don't). internal bool InPane(int pane) => Pane == pane; + + /// Whether a field edit is open anywhere on the screen. + internal bool IsEditing => Edit is not null; + + /// + /// The open edit for one specific field of one specific row, or null. Renderers ask per drawn + /// value, so the caret lands on the field being typed rather than on every field of the row. + /// + internal ScreenFieldEdit? EditOn(int pane, int index, int field) => + Edit is { } edit && IsOn(pane, index) && edit.Field == field ? edit : null; } diff --git a/src/SharpMUTerm.Tui/ScreenModel.cs b/src/SharpMUTerm.Tui/ScreenModel.cs index 2012242e..a0e24fca 100644 --- a/src/SharpMUTerm.Tui/ScreenModel.cs +++ b/src/SharpMUTerm.Tui/ScreenModel.cs @@ -30,20 +30,58 @@ internal static ScreenToggle Bind(Func get, Action set) } /// -/// The navigable shape of one settings screen: its panes, each an ordered list of rows, where a row -/// is either a plain stop (null — selectable, but nothing to press) or a checkbox bound to -/// config. It carries no markup and no controls: the renderers draw what the cursor is on, this says -/// where the cursor may go and what happens there. Rebuilt from live config on every key, so it never -/// goes stale against a list the last keystroke changed. +/// One row of a settings screen's navigable shape. A row is a plain stop (neither a checkbox nor +/// anything to type into), a checkbox, a row of editable fields, or both at once — the keypad's +/// bindings are the last case, where Space enables the macro and ⏎ edits the command it sends. +/// +/// Fields are an ordered list rather than a single value because a row is a *record*, not a cell: one +/// world row carries its name, host, port, encoding, and keepalive. ⏎ opens the first, ⇥ steps to the +/// next, and the renderers draw the open one wherever that field's labelled value already appears. It +/// also keeps a row's identity stable — giving a row fields never renumbers the rows around it, so a +/// pane's cursor indices mean the same thing before and after this feature. +/// +/// +/// The checkbox Space flips, or null when the row has none. +/// The values ⏎ opens for editing, in the order the screen draws them. +internal readonly record struct ScreenRow(ScreenToggle? Toggle = null, IReadOnlyList? Fields = null) +{ + /// A selectable row with nothing to press and nothing to type into. + internal static ScreenRow Stop => default; + + /// A row that is only a checkbox. + internal static ScreenRow Of(ScreenToggle toggle) => new(toggle); + + /// A row that is only editable values, in display order. + internal static ScreenRow Of(params ScreenField[] fields) => new(null, fields); + + /// A row that is both — Space flips the checkbox, ⏎ opens the first field. + internal static ScreenRow Of(ScreenToggle toggle, params ScreenField[] fields) => new(toggle, fields); + + /// How many values ⏎/⇥ can step through on this row. + internal int FieldCount => Fields?.Count ?? 0; + + /// Whether ⏎ has something to open here; a row without fields lets ⏎ save instead. + internal bool IsActivatable => FieldCount > 0; + + /// The row's field at an ordinal, or null when it has none there. + internal ScreenField? FieldAt(int field) => + Fields is not null && field >= 0 && field < Fields.Count ? Fields[field] : null; +} + +/// +/// The navigable shape of one settings screen: its panes, each an ordered list of +/// s. It carries no markup and no controls: the renderers draw what the cursor +/// is on, this says where the cursor may go and what happens there. Rebuilt from live config on every +/// key, so it never goes stale against a list the last keystroke changed. /// internal sealed class ScreenModel { - private readonly IReadOnlyList[] _panes; + private readonly IReadOnlyList[] _panes; - internal ScreenModel(params IReadOnlyList[] panes) + internal ScreenModel(params IReadOnlyList[] panes) { ArgumentNullException.ThrowIfNull(panes); - _panes = panes.Length == 0 ? new IReadOnlyList[] { Array.Empty() } : panes; + _panes = panes.Length == 0 ? new IReadOnlyList[] { Array.Empty() } : panes; Sizes = Array.ConvertAll(_panes, p => p.Count); } @@ -53,28 +91,65 @@ internal ScreenModel(params IReadOnlyList[] panes) /// How many panes the screen offers ⇥ between. internal int PaneCount => _panes.Length; - /// The checkbox at a cursor position, or null when that row isn't pressable. - internal ScreenToggle? ToggleAt(int pane, int index) => + /// + /// Whether anything on this screen can be edited. The header hints are derived from this rather + /// than written per screen, so a screen physically cannot advertise ⏎ edit without offering + /// a row that ⏎ opens. + /// + internal bool HasEditableRow + { + get + { + foreach (var pane in _panes) + { + foreach (var row in pane) + { + if (row.IsActivatable) + { + return true; + } + } + } + + return false; + } + } + + /// The row at a cursor position, or a plain stop when that position holds nothing. + internal ScreenRow RowAt(int pane, int index) => pane >= 0 && pane < _panes.Length && index >= 0 && index < _panes[pane].Count ? _panes[pane][index] - : null; + : ScreenRow.Stop; + + /// The checkbox at a cursor position, or null when that row isn't pressable. + internal ScreenToggle? ToggleAt(int pane, int index) => RowAt(pane, index).Toggle; - /// A pane of rows that are selectable but carry no checkbox (a plain list). - internal static IReadOnlyList Stops(int count) => new ScreenToggle?[Math.Max(0, count)]; + /// The editable value at a cursor position and field ordinal, or null when there is none. + internal ScreenField? FieldAt(int pane, int index, int field) => RowAt(pane, index).FieldAt(field); + + /// A pane of rows that are selectable but carry nothing to press (a plain list). + internal static IReadOnlyList Stops(int count) => new ScreenRow[Math.Max(0, count)]; /// A pane built by binding one checkbox per item of . - internal static IReadOnlyList Toggles( + internal static IReadOnlyList Toggles( IReadOnlyList items, Func get, Action set) { - ArgumentNullException.ThrowIfNull(items); ArgumentNullException.ThrowIfNull(get); ArgumentNullException.ThrowIfNull(set); - var rows = new ScreenToggle?[items.Count]; + return Rows(items, item => ScreenRow.Of(ScreenToggle.Bind(() => get(item), value => set(item, value)))); + } + + /// A pane built by projecting each item of into a row. + internal static IReadOnlyList Rows(IReadOnlyList items, Func row) + { + ArgumentNullException.ThrowIfNull(items); + ArgumentNullException.ThrowIfNull(row); + + var rows = new ScreenRow[items.Count]; for (var i = 0; i < items.Count; i++) { - var item = items[i]; - rows[i] = ScreenToggle.Bind(() => get(item), value => set(item, value)); + rows[i] = row(items[i]); } return rows; diff --git a/src/SharpMUTerm.Tui/ScreenPalette.cs b/src/SharpMUTerm.Tui/ScreenPalette.cs index 7f3aa67e..e330b38a 100644 --- a/src/SharpMUTerm.Tui/ScreenPalette.cs +++ b/src/SharpMUTerm.Tui/ScreenPalette.cs @@ -43,6 +43,15 @@ internal static class ScreenPalette /// internal const string CursorBg = "#2e3950"; - /// Near-black, for text printed *on* the accent (the Save chip). + /// Near-black, for text printed *on* the accent (the Save chip, and the block caret). internal const string Ink = "#0f1620"; + + /// + /// The well behind a field being typed into. Darker than every panel it can appear on, so an open + /// edit reads as a recessed input whichever screen it lands on rather than as another cursor bar. + /// + internal const string FieldBg = "#0f1420"; + + /// A refused value's marker — the one place these screens raise their voice. + internal const string Warn = "#ff6b6b"; } diff --git a/src/SharpMUTerm.Tui/SettingsOverlay.cs b/src/SharpMUTerm.Tui/SettingsOverlay.cs index f6f7962e..ef01382a 100644 --- a/src/SharpMUTerm.Tui/SettingsOverlay.cs +++ b/src/SharpMUTerm.Tui/SettingsOverlay.cs @@ -72,6 +72,14 @@ public void Toggle(ConsoleKey key, Func binding) /// Renders a screen into a headless frame (used by snapshots). public void OpenForSnapshot(ConsoleKey key, ScreenBinding binding) => Open(key, binding); + /// + /// Feeds one key to the open screen through the very handler PreviewKeyPressed raises, so a + /// snapshot can show a screen in a state only the keyboard can reach (a field mid-edit) without + /// any of it being faked. Keys cannot be driven in through the console driver here: the framework + /// only subscribes its key pump inside Run(), which a headless snapshot never enters. + /// + public void SimulateKey(ConsoleKeyInfo key) => OnKey(this, new KeyPressedEventArgs(key, false)); + private void Open(ConsoleKey key, ScreenBinding binding) { _openKey = key; diff --git a/src/SharpMUTerm.Tui/SettingsSession.cs b/src/SharpMUTerm.Tui/SettingsSession.cs index 3b679fc2..a38de847 100644 --- a/src/SharpMUTerm.Tui/SettingsSession.cs +++ b/src/SharpMUTerm.Tui/SettingsSession.cs @@ -20,19 +20,30 @@ internal enum ScreenAction } /// -/// One open settings screen's keyboard state: where the cursor is, what has been changed, and what a -/// key means. It owns no controls and no window — asks it what a -/// keystroke meant and acts on the answer — so the whole interaction contract (which keys move, which -/// toggle, what Esc undoes) is unit-testable without a terminal. +/// One open settings screen's keyboard state: where the cursor is, what has been changed, whether a +/// field is being typed into, and what a key means. It owns no controls and no window — +/// asks it what a keystroke meant and acts on the answer — so the whole +/// interaction contract (which keys move, which toggle, which open an edit, what Esc undoes) is +/// unit-testable without a terminal. /// /// The screen's is rebuilt on every key rather than cached: a keystroke can /// change how many rows a pane has (picking another world changes the character list), and navigating -/// against last frame's row counts is exactly how a cursor ends up pointing at nothing. +/// against last frame's row counts is exactly how a cursor ends up pointing at nothing. An open edit +/// therefore remembers a *position* (pane, row, field ordinal) and its buffer, and re-resolves the +/// field it is typing into out of each fresh model. +/// +/// +/// The keys, in one place: ⏎ activates the focused row when it has something to activate (a field → +/// open an edit) and otherwise saves and closes; ⌃S saves from anywhere; Esc cancels the screen, +/// except while an edit is open, where it abandons the edit and leaves the screen up. Inside an edit, +/// typing inserts, Backspace/Delete remove, ←→/Home/End move the caret, ↑↓ cycle an enum field's +/// choices, ⇥ commits and steps to the row's next field, ⏎ commits, and Esc reverts. /// /// internal sealed class SettingsSession { private readonly Func _model; + private FieldEdit? _edit; /// /// Binds a screen to the factory that projects live config into navigable rows. The factory is @@ -54,35 +65,61 @@ internal SettingsSession(Func model) /// The pending changes Esc undoes and ⏎ keeps. internal ScreenEdits Edits { get; } = new(); + /// Whether a field edit is open — the screens' one modal state. + internal bool IsEditing => _edit is not null; + /// - /// The cursor as the renderers should draw it, clamped to the rows that exist right now. Returns + /// The cursor as the renderers should draw it, clamped to the rows that exist right now, carrying + /// the open field edit when the cursor is on the row that owns it. Returns /// when the focused pane is empty, so nothing is highlighted. /// internal ScreenFocus Focus() { var model = _model(Selection); Selection.Clamp(model.Sizes); - return Selection.HasSelection(model.Sizes) - ? new ScreenFocus(Selection.Pane, Selection.Index) - : ScreenFocus.None; + if (!Selection.HasSelection(model.Sizes)) + { + return ScreenFocus.None; + } + + var edit = _edit is { } open && open.Pane == Selection.Pane && open.Index == Selection.Index + ? new ScreenFieldEdit( + open.Field, + open.Text, + open.Caret, + open.Error, + model.RowAt(open.Pane, open.Index).FieldCount) + : (ScreenFieldEdit?)null; + + return new ScreenFocus(Selection.Pane, Selection.Index, edit); } /// - /// Interprets a keystroke: ↑↓ move within the focused pane, ⇥ / Shift+⇥ change pane, Space - /// toggles the checkbox under the cursor, ⏎ saves, Esc cancels. Anything else is not ours. + /// Interprets a keystroke. With no edit open: ↑↓ move within the focused pane, ⇥ / Shift+⇥ change + /// pane, Space toggles the checkbox under the cursor, ⏎ opens the focused row's first field or — + /// when the row has none — saves, ⌃S saves, Esc cancels. With an edit open the whole keyboard + /// belongs to the buffer instead; see the type summary. Anything else is not ours. /// internal ScreenAction Handle(ConsoleKeyInfo key) { var model = _model(Selection); Selection.Clamp(model.Sizes); + if (_edit is not null) + { + return HandleEdit(key, model); + } + switch (key.Key) { + case ConsoleKey.S when key.Modifiers.HasFlag(ConsoleModifiers.Control): + return ScreenAction.Save; + case ConsoleKey.Escape: return ScreenAction.Cancel; case ConsoleKey.Enter: - return ScreenAction.Save; + return Activate(model); case ConsoleKey.UpArrow: return Changed(Selection.Move(-1, model.Sizes)); @@ -114,5 +151,235 @@ private ScreenAction Toggle(ScreenModel model) return ScreenAction.Redraw; } + /// + /// ⏎ on a row that has something to open. A row with no field is not activatable, and ⏎ keeps its + /// old meaning there — the footer's [[⏎]] Save. + /// + private ScreenAction Activate(ScreenModel model) + { + if (!model.RowAt(Selection.Pane, Selection.Index).IsActivatable) + { + return ScreenAction.Save; + } + + Open(model, 0); + return ScreenAction.Redraw; + } + + /// Opens a field of the focused row, seeding the buffer with its current value. + private void Open(ScreenModel model, int field) + { + if (model.FieldAt(Selection.Pane, Selection.Index, field) is not { } target) + { + _edit = null; + return; + } + + var text = target.Get(); + _edit = new FieldEdit(Selection.Pane, Selection.Index, field, text); + } + + private ScreenAction HandleEdit(ConsoleKeyInfo key, ScreenModel model) + { + var edit = _edit!; + + // The model is rebuilt per key, so the row being edited can disappear underneath the buffer + // (a list the last keystroke shortened). Abandon the edit rather than typing into nothing. + if (model.FieldAt(edit.Pane, edit.Index, edit.Field) is not { } field) + { + _edit = null; + return ScreenAction.Redraw; + } + + switch (key.Key) + { + case ConsoleKey.Escape: + _edit = null; + return ScreenAction.Redraw; + + case ConsoleKey.Enter: + Commit(field); + return ScreenAction.Redraw; + + case ConsoleKey.S when key.Modifiers.HasFlag(ConsoleModifiers.Control): + // ⌃S saves from anywhere, but never by discarding what is on screen: the open field is + // committed first, and a value that will not validate stops the save rather than being + // silently dropped. + return Commit(field) ? ScreenAction.Save : ScreenAction.Redraw; + + case ConsoleKey.Tab: + return Step(model, field, key.Modifiers.HasFlag(ConsoleModifiers.Shift) ? -1 : 1); + + case ConsoleKey.UpArrow: + return Cycle(field, -1); + + case ConsoleKey.DownArrow: + return Cycle(field, 1); + + case ConsoleKey.Backspace: + return Changed(edit.Backspace()); + + case ConsoleKey.Delete: + return Changed(edit.Delete()); + + case ConsoleKey.LeftArrow: + return Changed(edit.MoveCaret(-1)); + + case ConsoleKey.RightArrow: + return Changed(edit.MoveCaret(1)); + + case ConsoleKey.Home: + return Changed(edit.MoveCaret(int.MinValue)); + + case ConsoleKey.End: + return Changed(edit.MoveCaret(int.MaxValue)); + + default: + if (key.KeyChar != '\0' && !char.IsControl(key.KeyChar)) + { + edit.Insert(key.KeyChar); + return ScreenAction.Redraw; + } + + return ScreenAction.None; + } + } + + /// + /// Validates the buffer and, if it holds, writes it through the undo log and closes the edit. A + /// rejected buffer stays open and carries the reason, so the field is marked rather than the + /// keystroke that produced it being thrown away mid-word. + /// + private bool Commit(ScreenField field) + { + var edit = _edit!; + if (Edits.Apply(field, edit.Text) is { } error) + { + edit.Error = error; + return false; + } + + _edit = null; + return true; + } + + /// ⇥ inside an edit: commit this field, then open the row's next one, wrapping. + private ScreenAction Step(ScreenModel model, ScreenField field, int direction) + { + var edit = _edit!; + var from = edit.Field; + var count = model.RowAt(edit.Pane, edit.Index).FieldCount; + if (!Commit(field)) + { + return ScreenAction.Redraw; + } + + if (count <= 1) + { + return ScreenAction.Redraw; + } + + Open(model, ((from + direction) % count + count) % count); + return ScreenAction.Redraw; + } + + /// ↑↓ inside an edit: step an enum field's choices; anything else has nothing to cycle. + private ScreenAction Cycle(ScreenField field, int direction) + { + var edit = _edit!; + if (field.Cycle(edit.Text, direction) is not { } next) + { + return ScreenAction.Consumed; + } + + edit.Replace(next); + return ScreenAction.Redraw; + } + private static ScreenAction Changed(bool moved) => moved ? ScreenAction.Redraw : ScreenAction.Consumed; + + /// + /// The buffer behind an open edit: which row and field it belongs to, the text being typed, where + /// the caret is in it, and the reason the last commit was refused. Held by position rather than by + /// field so it survives the model being rebuilt on every key. + /// + private sealed class FieldEdit + { + internal FieldEdit(int pane, int index, int field, string text) + { + Pane = pane; + Index = index; + Field = field; + Text = text; + Caret = text.Length; + } + + internal int Pane { get; } + + internal int Index { get; } + + internal int Field { get; } + + internal string Text { get; private set; } + + internal int Caret { get; private set; } + + internal string? Error { get; set; } + + internal void Insert(char c) + { + Text = Text.Insert(Caret, c.ToString()); + Caret++; + Error = null; + } + + internal void Replace(string text) + { + Text = text; + Caret = text.Length; + Error = null; + } + + internal bool Backspace() + { + if (Caret == 0) + { + return false; + } + + Text = Text.Remove(Caret - 1, 1); + Caret--; + Error = null; + return true; + } + + internal bool Delete() + { + if (Caret >= Text.Length) + { + return false; + } + + Text = Text.Remove(Caret, 1); + Error = null; + return true; + } + + /// + /// Moves the caret, clamped to the buffer. and + /// are Home and End; the arithmetic is done wide so neither + /// overflows. + /// + internal bool MoveCaret(int delta) + { + var next = (int)Math.Clamp((long)Caret + delta, 0, Text.Length); + if (next == Caret) + { + return false; + } + + Caret = next; + return true; + } + } } diff --git a/src/SharpMUTerm.Tui/SharpMUTermApp.cs b/src/SharpMUTerm.Tui/SharpMUTermApp.cs index d7447e1b..c27271a8 100644 --- a/src/SharpMUTerm.Tui/SharpMUTermApp.cs +++ b/src/SharpMUTerm.Tui/SharpMUTermApp.cs @@ -362,10 +362,21 @@ public string RenderSnapshot(string? view = null) } // Settings screens (composed-control or markup — SettingsView hands back a control factory - // either way) open over the workspace for their --view name. - if (view is not null && SettingsView(view) is { } screen) + // either way) open over the workspace for their --view name. A "-edit" view opens the + // same screen and then drives real keys into it, so the frame shows a field genuinely mid-edit + // rather than a hand-drawn impression of one. + var editing = view is not null && view.EndsWith(EditViewSuffix, StringComparison.OrdinalIgnoreCase); + var screenView = editing ? view![..^EditViewSuffix.Length] : view; + if (screenView is not null && SettingsView(screenView) is { } screen) { _settings.OpenForSnapshot(screen.Key, screen.Open()); + if (editing) + { + foreach (var key in EditSnapshotKeys(screenView)) + { + _settings.SimulateKey(key); + } + } } SyncInputWidth(); // the window now carries the snapshot size, so the band fills its full width @@ -1044,6 +1055,39 @@ private ScreenBinding OptionsScreen(Func sc screen(), _system.DesktopDimensions.Width, session.Focus())); } + /// The --view suffix that opens a settings screen with a field being typed into. + private const string EditViewSuffix = "-edit"; + + /// + /// The keys a <name>-edit snapshot drives into a freshly opened screen. ⏎ opens the + /// focused row's first field; ⇥ commits it and steps to the next; the rest is typing. F5 walks on + /// to the host and rewrites its suffix, because "no way to change a host" is the gap this whole + /// mode closes and a frame should show exactly that. + /// + private static IEnumerable EditSnapshotKeys(string view) + { + yield return Stroke('\r', ConsoleKey.Enter); + + if (!string.Equals(view, "worlds", StringComparison.OrdinalIgnoreCase) && + !string.Equals(view, "settings", StringComparison.OrdinalIgnoreCase)) + { + yield break; + } + + yield return Stroke('\t', ConsoleKey.Tab); + for (var i = 0; i < 3; i++) + { + yield return Stroke('\b', ConsoleKey.Backspace); + } + + foreach (var c in "net") + { + yield return Stroke(c, ConsoleKey.NoName); + } + } + + private static ConsoleKeyInfo Stroke(char c, ConsoleKey key) => new(c, key, false, false, false); + /// Maps a --view name to a settings screen (F-key + open factory) for snapshots. private (ConsoleKey Key, Func Open)? SettingsView(string view) { diff --git a/src/SharpMUTerm.Tui/TimersScreenRenderer.cs b/src/SharpMUTerm.Tui/TimersScreenRenderer.cs index b1f85cb8..739bbcbd 100644 --- a/src/SharpMUTerm.Tui/TimersScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/TimersScreenRenderer.cs @@ -36,7 +36,7 @@ public static List Render(IReadOnlyList sets, int selected) var left = ListColumn(sets, selected); var right = EditorColumn(sets, selected); - var lines = new List { HeaderLine(0), string.Empty }; + var lines = new List { HeaderLine(0, Model(sets, selected)), string.Empty }; var rowCount = Math.Max(left.Count, right.Count); for (var i = 0; i < rowCount; i++) @@ -52,40 +52,65 @@ public static List Render(IReadOnlyList sets, int selected) return lines; } - /// The screen title on the left, the keyboard hints right-aligned to . - internal static string HeaderLine(int width) + /// + /// The screen title on the left, the keyboard hints right-aligned to . The + /// hints are derived from and rather than + /// written here, so the header cannot advertise an edit the screen doesn't offer. + /// + internal static string HeaderLine(int width, ScreenModel? model = null, ScreenFocus? focus = null) { var title = $"[bold {Value}] Timers[/]"; - var hints = ScreenChrome.Hints(ScreenChrome.ListHints, "F6"); + var hints = ScreenChrome.Hints( + ScreenChrome.ListHints, "F6", model?.HasEditableRow ?? false, focus); return SpreadLR(" " + title, hints, width); } /// - /// The screen's navigable panes: the timer list (Space enables/disables one) and the selected - /// timer's checkbox rows, in the order draws them. + /// The screen's navigable panes: the timer list (Space enables/disables one, ⏎ edits its interval + /// and then — with ⇥ — its command) and the selected timer's checkbox rows, in the order + /// draws them. Both values hang off the list row rather than becoming + /// rows of their own, so the editor pane's cursor indices keep meaning what they meant. /// internal static ScreenModel Model(IReadOnlyList sets, int selected) { ArgumentNullException.ThrowIfNull(sets); var entries = Flatten(sets); - var list = ScreenModel.Toggles(entries, e => e.Timer.Enabled, (e, v) => e.Timer.Enabled = v); + var list = ScreenModel.Rows(entries, entry => ScreenRow.Of( + ScreenToggle.Bind(() => entry.Timer.Enabled, v => entry.Timer.Enabled = v), + ScreenField.Number( + "interval", + () => entry.Timer.IntervalSeconds, + v => entry.Timer.IntervalSeconds = v, + MinIntervalSeconds, + MaxIntervalSeconds), + ScreenField.Text("command", () => entry.Timer.Command, v => entry.Timer.Command = v))); if (selected < 0 || selected >= entries.Count) { - return new ScreenModel(list, Array.Empty()); + return new ScreenModel(list, Array.Empty()); } var timer = entries[selected].Timer; - var editor = new ScreenToggle?[] + var editor = new[] { - ScreenToggle.Bind(() => timer.OneShot, v => timer.OneShot = v), - ScreenToggle.Bind(() => timer.Enabled, v => timer.Enabled = v), + ScreenRow.Of(ScreenToggle.Bind(() => timer.OneShot, v => timer.OneShot = v)), + ScreenRow.Of(ScreenToggle.Bind(() => timer.Enabled, v => timer.Enabled = v)), }; return new ScreenModel(list, editor); } + /// + /// The shortest interval a timer may be given. Zero or less is "disabled" to the scheduler, which + /// is what the Enabled checkbox is for — typing it into the interval would silently turn the timer + /// off while it still read as on. + /// + private const double MinIntervalSeconds = 0.1; + + /// A day; past this the value is far likelier to be a typo than a schedule. + private const double MaxIntervalSeconds = 86400; + /// The action bar: which timer is selected on the left, cancel/save on the right. internal static string FooterLine(IReadOnlyList sets, int selected, int width) { @@ -136,9 +161,10 @@ internal static List EditorColumn( { ArgumentNullException.ThrowIfNull(sets); + var cursor = focus ?? ScreenFocus.None; var entries = Flatten(sets); return selected >= 0 && selected < entries.Count - ? BuildEditor(entries[selected].Timer, focus ?? ScreenFocus.None) + ? BuildEditor(entries[selected].Timer, cursor, selected) : new List(); } @@ -167,13 +193,13 @@ private static string Row(TimerDefinition timer, string setName, bool selected) return $"{check} {marker} [bold]{name}[/] {schedule} [dim]▪ {Escape(setName)}[/] → {command}"; } - private static List BuildEditor(TimerDefinition timer, ScreenFocus cursor) => new() + private static List BuildEditor(TimerDefinition timer, ScreenFocus cursor, int selected) => new() { "[dim]interval (seconds)[/]", - $" {Seconds(timer)}", + $" {ScreenChrome.Field(Seconds(timer), cursor.EditOn(0, selected, 0))}", string.Empty, "[dim]command[/]", - $" {Escape(timer.Command)}", + $" {ScreenChrome.Field(Escape(timer.Command), cursor.EditOn(0, selected, 1))}", string.Empty, ScreenChrome.Cursor(Checkbox("one-shot", timer.OneShot), cursor.IsOn(1, 0), ColumnWidth), ScreenChrome.Cursor(Checkbox("enabled", timer.Enabled), cursor.IsOn(1, 1), ColumnWidth), diff --git a/src/SharpMUTerm.Tui/TimersScreenView.cs b/src/SharpMUTerm.Tui/TimersScreenView.cs index 1f822b3f..58a52674 100644 --- a/src/SharpMUTerm.Tui/TimersScreenView.cs +++ b/src/SharpMUTerm.Tui/TimersScreenView.cs @@ -20,7 +20,9 @@ internal static class TimersScreenView public static IWindowControl Build( IReadOnlyList sets, int selected, int width, ScreenFocus? focus = null) { - var header = ScreenChrome.Band(TimersScreenRenderer.HeaderLine(width), ScreenPalette.HeaderBg); + var header = ScreenChrome.Band( + TimersScreenRenderer.HeaderLine(width, TimersScreenRenderer.Model(sets, selected), focus), + ScreenPalette.HeaderBg); var footer = ScreenChrome.Band( TimersScreenRenderer.FooterLine(sets, selected, width), ScreenPalette.FooterBg); diff --git a/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs b/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs index 52fe067a..4baf9414 100644 --- a/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs @@ -41,7 +41,7 @@ public static List Render( var left = RulesColumn(sets, selectedTrigger); var right = EditorColumn(sets, selectedTrigger, spawnTargets); - var lines = new List { HeaderLine(0), string.Empty }; + var lines = new List { HeaderLine(0, Model(sets, selectedTrigger)), string.Empty }; var rowCount = Math.Max(left.Count, right.Count); for (var i = 0; i < rowCount; i++) @@ -57,36 +57,46 @@ public static List Render( return lines; } - /// The screen title on the left, the keyboard hints right-aligned to . - internal static string HeaderLine(int width) + /// + /// The screen title on the left, the keyboard hints right-aligned to . The + /// hints are derived from and rather than + /// written here, so the header cannot advertise an edit the screen doesn't offer. + /// + internal static string HeaderLine(int width, ScreenModel? model = null, ScreenFocus? focus = null) { var title = $"[bold {Value}] Triggers & spawn routing[/]"; - var hints = ScreenChrome.Hints(ScreenChrome.ListHints, "F2"); + var hints = ScreenChrome.Hints( + ScreenChrome.ListHints, "F2", model?.HasEditableRow ?? false, focus); return SpreadLR(" " + title, hints, width); } /// - /// The screen's navigable panes: the rule list (Space enables/disables a trigger) and the - /// selected rule's checkbox rows, in the order draws them. + /// The screen's navigable panes: the rule list (Space enables/disables a trigger, ⏎ edits its + /// match pattern) and the selected rule's checkbox rows, in the order + /// draws them. The pattern belongs to the rule row rather than to the editor pane so giving it an + /// editor doesn't renumber the rows the cursor already navigates by; the editor still draws the + /// buffer, under its own label, because that is where the pattern is displayed in full. /// internal static ScreenModel Model(IReadOnlyList sets, int selectedTrigger) { ArgumentNullException.ThrowIfNull(sets); var flattened = Flatten(sets); - var rules = ScreenModel.Toggles( - flattened, e => e.Trigger.Enabled, (e, v) => e.Trigger.Enabled = v); + var rules = ScreenModel.Rows(flattened, entry => ScreenRow.Of( + ScreenToggle.Bind(() => entry.Trigger.Enabled, v => entry.Trigger.Enabled = v), + ScreenField.Pattern( + "match pattern", () => entry.Trigger.Pattern, v => entry.Trigger.Pattern = v))); if (selectedTrigger < 0 || selectedTrigger >= flattened.Count) { - return new ScreenModel(rules, Array.Empty()); + return new ScreenModel(rules, Array.Empty()); } var trigger = flattened[selectedTrigger].Trigger; - var editor = new ScreenToggle?[] + var editor = new[] { - ScreenToggle.Bind(() => trigger.Actions.Gag, v => trigger.Actions.Gag = v), - ScreenToggle.Bind(() => trigger.StopProcessing, v => trigger.StopProcessing = v), + ScreenRow.Of(ScreenToggle.Bind(() => trigger.Actions.Gag, v => trigger.Actions.Gag = v)), + ScreenRow.Of(ScreenToggle.Bind(() => trigger.StopProcessing, v => trigger.StopProcessing = v)), }; return new ScreenModel(rules, editor); @@ -147,9 +157,11 @@ internal static List EditorColumn( ArgumentNullException.ThrowIfNull(sets); ArgumentNullException.ThrowIfNull(spawnTargets); + var cursor = focus ?? ScreenFocus.None; var flattened = Flatten(sets); return selectedTrigger >= 0 && selectedTrigger < flattened.Count - ? BuildEditor(flattened[selectedTrigger].Trigger, spawnTargets, focus ?? ScreenFocus.None) + ? BuildEditor(flattened[selectedTrigger].Trigger, spawnTargets, cursor, + cursor.EditOn(0, selectedTrigger, 0)) : new List(); } @@ -210,14 +222,15 @@ private static string Flags(TriggerActions actions) return flags.Count == 0 ? "—" : string.Join(" ", flags); } - private static List BuildEditor(Trigger trigger, IReadOnlyList spawnTargets, ScreenFocus cursor) + private static List BuildEditor( + Trigger trigger, IReadOnlyList spawnTargets, ScreenFocus cursor, ScreenFieldEdit? pattern) { var currentRoute = trigger.Actions.SpawnTarget ?? "main"; var lines = new List { "[dim]match pattern (regex)[/]", - $" {Escape(trigger.Pattern)}", + $" {ScreenChrome.Field(Escape(trigger.Pattern), pattern)}", string.Empty, "[dim]route to[/]", RouteRow("main", currentRoute), diff --git a/src/SharpMUTerm.Tui/TriggersScreenView.cs b/src/SharpMUTerm.Tui/TriggersScreenView.cs index f8cd0492..7e8014bd 100644 --- a/src/SharpMUTerm.Tui/TriggersScreenView.cs +++ b/src/SharpMUTerm.Tui/TriggersScreenView.cs @@ -24,7 +24,10 @@ public static IWindowControl Build( int width, ScreenFocus? focus = null) { - var header = ScreenChrome.Band(TriggersScreenRenderer.HeaderLine(width), ScreenPalette.HeaderBg); + var header = ScreenChrome.Band( + TriggersScreenRenderer.HeaderLine( + width, TriggersScreenRenderer.Model(sets, selectedTrigger), focus), + ScreenPalette.HeaderBg); var footer = ScreenChrome.Band( TriggersScreenRenderer.FooterLine(sets, selectedTrigger, width), ScreenPalette.FooterBg); diff --git a/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs b/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs index 2ce9bb16..de2fe602 100644 --- a/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs @@ -46,7 +46,8 @@ public static List Render( ArgumentNullException.ThrowIfNull(triggerSets); var accent = AccentFor(worlds, selectedWorld); - var lines = new List { Band(HeaderLine(width), HeaderBg, width) }; + var model = Model(worlds, triggerSets, selectedWorld, selectedCharacter); + var lines = new List { Band(HeaderLine(width, model), HeaderBg, width) }; lines.AddRange(MergeColumns(WorldsColumn(worlds, selectedWorld), DetailColumn(worlds, triggerSets, selectedWorld, selectedCharacter, accent), LeftColumnWidth)); @@ -55,7 +56,7 @@ public static List Render( var character = worlds[selectedWorld].Characters[selectedCharacter]; lines.Add(string.Empty); lines.Add(Band($"[{Rule}]{new string('─', width > 4 ? width - 2 : 60)}[/]", EditBg, width)); - foreach (var row in MergeColumns(FormColumn(character, accent), + foreach (var row in MergeColumns(FormColumn(character, accent, null, selectedCharacter), TriggersColumn(character, triggerSets, accent), CharDetailColumnWidth)) { lines.Add(Band(" " + row, EditBg, width)); @@ -78,19 +79,34 @@ internal static bool HasCharacter(IReadOnlyList worlds, int sel selectedWorld >= 0 && selectedWorld < worlds.Count && selectedCharacter >= 0 && selectedCharacter < worlds[selectedWorld].Characters.Count; - internal static string HeaderLine(int width) + /// + /// The screen title on the left, the keyboard hints right-aligned to . The + /// hints are derived from and rather than + /// written here, so the header cannot advertise an edit the screen doesn't offer. + /// + internal static string HeaderLine(int width, ScreenModel? model = null, ScreenFocus? focus = null) { var title = $"[bold {Value}] Worlds & Characters[/]"; - var hints = ScreenChrome.Hints(ScreenChrome.ListHints, "F5"); + var hints = ScreenChrome.Hints( + ScreenChrome.ListHints, "F5", model?.HasEditableRow ?? false, focus); return SpreadLR(" " + title, hints, width); } + /// The wire encodings a world may be set to; the detail column cycles them with ↑↓. + private static readonly string[] Encodings = { "UTF-8", "ISO-8859-1", "ASCII", "CP437", "CP1252" }; + /// - /// The screen's three navigable panes, in ⇥ order: the WORLDS list (selection only — a world has - /// no checkbox on its row), the selected world's characters (Space flips auto-login, which the row - /// itself reports), and the selected character's assigned trigger sets (Space assigns/unassigns). - /// The last two collapse to empty when there is nothing selected above them, and ⇥ skips empty - /// panes, so the cursor never lands somewhere with no rows. + /// The screen's three navigable panes, in ⇥ order: the WORLDS list (no checkbox on a world's row, + /// but ⏎ opens the world's own fields — the ones the detail column lists), the selected world's + /// characters (Space flips auto-login, ⏎ edits the character's name and on-connect line), and the + /// selected character's assigned trigger sets (Space assigns/unassigns). The last two collapse to + /// empty when there is nothing selected above them, and ⇥ skips empty panes, so the cursor never + /// lands somewhere with no rows. + /// + /// A world's fields hang off its list row rather than becoming a pane of their own: the detail + /// column is a projection of whatever the WORLDS list has selected, so its values already belong + /// to that row, and a fourth pane would put ⇥ somewhere the eye doesn't go. + /// /// internal static ScreenModel Model( IReadOnlyList worlds, @@ -101,19 +117,28 @@ internal static ScreenModel Model( ArgumentNullException.ThrowIfNull(worlds); ArgumentNullException.ThrowIfNull(triggerSets); - var worldRows = ScreenModel.Stops(worlds.Count); + var worldRows = ScreenModel.Rows(worlds, w => ScreenRow.Of( + ScreenField.Text("name", () => w.Name, v => w.Name = v), + ScreenField.Text("host", () => w.Host, v => w.Host = v), + ScreenField.Integer("port", () => w.Port, v => w.Port = v, 1, 65535), + ScreenField.Choice("encoding", () => w.Encoding, v => w.Encoding = v, Encodings), + ScreenField.Integer("keepalive", () => w.KeepaliveSeconds, v => w.KeepaliveSeconds = v, 0, 86400))); + var world = selectedWorld >= 0 && selectedWorld < worlds.Count ? worlds[selectedWorld] : null; var characterRows = world is null - ? Array.Empty() - : ScreenModel.Toggles(world.Characters, c => c.AutoLogin, (c, v) => c.AutoLogin = v); + ? Array.Empty() + : ScreenModel.Rows(world.Characters, c => ScreenRow.Of( + ScreenToggle.Bind(() => c.AutoLogin, v => c.AutoLogin = v), + ScreenField.Text("name", () => c.Name, v => c.Name = v), + ScreenField.Optional("on connect", () => c.OnConnect, v => c.OnConnect = v))); if (!HasCharacter(worlds, selectedWorld, selectedCharacter)) { - return new ScreenModel(worldRows, characterRows, Array.Empty()); + return new ScreenModel(worldRows, characterRows, Array.Empty()); } var character = worlds[selectedWorld].Characters[selectedCharacter]; - var setRows = new ScreenToggle?[triggerSets.Count]; + var setRows = new ScreenRow[triggerSets.Count]; for (var i = 0; i < triggerSets.Count; i++) { var name = triggerSets[i].Name; @@ -121,7 +146,7 @@ internal static ScreenModel Model( // Assignment is list membership, and the character's own order decides which set wins a // conflict (see AppConfiguration.ResolveTriggerSets) — so the snapshot restores the whole // list rather than re-adding the name at the end, which would silently reorder priority. - setRows[i] = new ScreenToggle( + setRows[i] = ScreenRow.Of(new ScreenToggle( () => character.TriggerSets.Contains(name), () => { @@ -138,7 +163,7 @@ internal static ScreenModel Model( character.TriggerSets.Clear(); character.TriggerSets.AddRange(previous); }; - }); + })); } return new ScreenModel(worldRows, characterRows, setRows); @@ -211,20 +236,28 @@ internal static List DetailColumn( } var world = worlds[selectedWorld]; + + // The world's own fields are the WORLDS-list row's fields, in this order — the detail column is + // where they are displayed, so it is where an open edit draws its caret. var right = new List { $"[bold {Value}]{Escape(world.Name)}[/] [{Label}]{Escape(world.Host)}:{world.Port.ToString(CultureInfo.InvariantCulture)}[/]" + $" [{accent}]TLS {OnOff(world.UseTls)}[/][{Label}] · {Escape(world.Encoding)}[/]", string.Empty, $"[{accent}]├ WORLD[/]", - WorldField("name", $"[{Value}]{Escape(world.Name)}[/]"), - WorldField("host", $"[{Value}]{Escape(world.Host)}[/]"), - WorldField("port", $"[{Value}]{world.Port.ToString(CultureInfo.InvariantCulture)}[/]"), + WorldField("name", Field($"[{Value}]{Escape(world.Name)}[/]", cursor, selectedWorld, 0)), + WorldField("host", Field($"[{Value}]{Escape(world.Host)}[/]", cursor, selectedWorld, 1)), + WorldField("port", Field( + $"[{Value}]{world.Port.ToString(CultureInfo.InvariantCulture)}[/]", cursor, selectedWorld, 2)), WorldField("security", $"[{Value}]{Security(world)}[/]"), - WorldField("encoding", $"[{Value}]{Escape(world.Encoding)}[/]"), - WorldField("keepalive", world.KeepaliveSeconds > 0 - ? $"[{Value}]{world.KeepaliveSeconds.ToString(CultureInfo.InvariantCulture)}s[/]" - : $"[{Label}]off[/]"), + WorldField("encoding", Field($"[{Value}]{Escape(world.Encoding)}[/]", cursor, selectedWorld, 3)), + WorldField("keepalive", Field( + world.KeepaliveSeconds > 0 + ? $"[{Value}]{world.KeepaliveSeconds.ToString(CultureInfo.InvariantCulture)}s[/]" + : $"[{Label}]off[/]", + cursor, + selectedWorld, + 4)), string.Empty, $"[{accent}]├ CHARACTERS[/] [{Label}]a character is a connection[/]", $"[{Label}] name state login trigger sets[/]", @@ -250,17 +283,32 @@ internal static List DetailColumn( return right; } - /// The character form — labels left-aligned with their values, one field per row. - internal static List FormColumn(CharacterDefinition character, string accent) => new() + /// + /// The character form — labels left-aligned with their values, one field per row. The editable + /// ones are the character row's own fields (name, then on-connect); the password is deliberately + /// not among them, and the session line is a report, not a setting. + /// + internal static List FormColumn( + CharacterDefinition character, string accent, ScreenFocus? focus = null, int selectedCharacter = -1) { - $"[bold {accent}]└ CHARACTER · {Escape(character.Name)}[/]", - string.Empty, - CharField("name", $"[{Value}]{Escape(character.Name)}[/]"), - CharField("password", $"[{Value}]••••••••[/] [{Label}]keychain[/]"), - CharField("on connect", $"[{Value}]{Escape(character.OnConnect ?? "—")}[/]"), - CharField("auto-login", character.AutoLogin ? $"[{accent}]yes[/]" : $"[{Label}]no[/]"), - CharField("session", $"[{Label}]offline[/]"), - }; + var cursor = focus ?? ScreenFocus.None; + return new List + { + $"[bold {accent}]└ CHARACTER · {Escape(character.Name)}[/]", + string.Empty, + CharField("name", Field( + $"[{Value}]{Escape(character.Name)}[/]", cursor, selectedCharacter, 0, pane: 1)), + CharField("password", $"[{Value}]••••••••[/] [{Label}]keychain[/]"), + CharField("on connect", Field( + $"[{Value}]{Escape(character.OnConnect ?? "—")}[/]", cursor, selectedCharacter, 1, pane: 1)), + CharField("auto-login", character.AutoLogin ? $"[{accent}]yes[/]" : $"[{Label}]no[/]"), + CharField("session", $"[{Label}]offline[/]"), + }; + } + + /// Draws a value as a field, showing the buffer and caret when its edit is the open one. + private static string Field(string display, ScreenFocus cursor, int index, int field, int pane = 0) => + ScreenChrome.Field(display, cursor.EditOn(pane, index, field)); /// The assigned-trigger-sets checklist for a character. internal static List TriggersColumn( diff --git a/src/SharpMUTerm.Tui/WorldsScreenView.cs b/src/SharpMUTerm.Tui/WorldsScreenView.cs index 223a37e6..b18d07a3 100644 --- a/src/SharpMUTerm.Tui/WorldsScreenView.cs +++ b/src/SharpMUTerm.Tui/WorldsScreenView.cs @@ -26,7 +26,9 @@ public static IWindowControl Build( { var accent = WorldsScreenRenderer.AccentFor(worlds, selectedWorld); - var header = ScreenChrome.Band(WorldsScreenRenderer.HeaderLine(width), ScreenPalette.HeaderBg); + var model = WorldsScreenRenderer.Model(worlds, triggerSets, selectedWorld, selectedCharacter); + var header = ScreenChrome.Band( + WorldsScreenRenderer.HeaderLine(width, model, focus), ScreenPalette.HeaderBg); var footer = ScreenChrome.Band( WorldsScreenRenderer.FooterLine(worlds, selectedWorld, selectedCharacter, accent, width), ScreenPalette.FooterBg); @@ -54,7 +56,7 @@ public static IWindowControl Build( if (WorldsScreenRenderer.HasCharacter(worlds, selectedWorld, selectedCharacter)) { var character = worlds[selectedWorld].Characters[selectedCharacter]; - var form = WorldsScreenRenderer.FormColumn(character, accent).ToList(); + var form = WorldsScreenRenderer.FormColumn(character, accent, focus, selectedCharacter).ToList(); var triggers = WorldsScreenRenderer.TriggersColumn(character, triggerSets, accent, focus).ToList(); var editHeight = Math.Max(form.Count, triggers.Count); diff --git a/tests/SharpMUTerm.Core.Tests/Automation/AliasAndMacroTests.cs b/tests/SharpMUTerm.Core.Tests/Automation/AliasAndMacroTests.cs index 1bb75dcb..e252d39e 100644 --- a/tests/SharpMUTerm.Core.Tests/Automation/AliasAndMacroTests.cs +++ b/tests/SharpMUTerm.Core.Tests/Automation/AliasAndMacroTests.cs @@ -52,6 +52,28 @@ public async Task DisabledAlias_IsSkipped() var result = engine.Expand("abc"); await Assert.That(result.Matched).IsFalse(); } + + /// + /// Pattern and substitution are settable so the F3 settings screen can edit a live alias. The + /// compiled regex is cached, so writing the pattern has to drop that cache — the same trap + /// already guards against. + /// + [Test] + public async Task RewritingThePatternAndExpansion_TakesEffectImmediately() + { + var alias = new Alias { Pattern = "^k$", Substitution = "kill" }; + var engine = new AliasEngine(); + engine.Add(alias); + await Assert.That(engine.Expand("k").Matched).IsTrue(); + + alias.Pattern = "^kk$"; + alias.Substitution = "kill target"; + + await Assert.That(engine.Expand("k").Matched).IsFalse(); + var result = engine.Expand("kk"); + await Assert.That(result.Matched).IsTrue(); + await Assert.That(result.Commands[0]).IsEqualTo("kill target"); + } } public class MacroEngineTests diff --git a/tests/SharpMUTerm.Core.Tests/Automation/TriggerEngineTests.cs b/tests/SharpMUTerm.Core.Tests/Automation/TriggerEngineTests.cs index 19255b70..aaeb0106 100644 --- a/tests/SharpMUTerm.Core.Tests/Automation/TriggerEngineTests.cs +++ b/tests/SharpMUTerm.Core.Tests/Automation/TriggerEngineTests.cs @@ -119,4 +119,23 @@ public async Task CaseInsensitive_ByDefault() var result = engine.Process(Line("hello world")); await Assert.That(result.Suppress).IsTrue(); } + + /// + /// The pattern is settable so the F2 settings screen can edit a live trigger. The compiled regex + /// is cached, so writing it has to drop that cache — otherwise the rule keeps matching the pattern + /// it no longer has, which is invisible until a line arrives. + /// + [Test] + public async Task RewritingThePattern_RecompilesTheMatcher() + { + var trigger = new Trigger { Pattern = "spam", Actions = new TriggerActions { Gag = true } }; + var engine = new TriggerEngine(); + engine.Add(trigger); + await Assert.That(engine.Process(Line("this is spam")).Suppress).IsTrue(); + + trigger.Pattern = "noise"; + + await Assert.That(engine.Process(Line("this is spam")).Suppress).IsFalse(); + await Assert.That(engine.Process(Line("this is noise")).Suppress).IsTrue(); + } } diff --git a/tests/SharpMUTerm.Tui.Tests/PaneDragEndToEndTests.cs b/tests/SharpMUTerm.Tui.Tests/PaneDragEndToEndTests.cs index acbeaca7..0cb27a78 100644 --- a/tests/SharpMUTerm.Tui.Tests/PaneDragEndToEndTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/PaneDragEndToEndTests.cs @@ -12,6 +12,13 @@ namespace SharpMUTerm.Tui.Tests; /// real. The only link these tests cannot cover is the terminal's own mouse reporting, which is /// SharpConsoleUI's NetConsoleDriver turning escape sequences into the very frames fed here. /// +/// +/// Serialised: redirects Console.Out to capture the +/// frame, and redirects Console.In. Both are process-global, so two of these +/// running at once swap each other's streams and one gets a truncated frame — which arranges no layout, +/// which yields pane rects that don't match the screen. That surfaced as roughly a one-in-six failure. +/// +[NotInParallel] public class PaneDragEndToEndTests { private const int Width = 120; diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenCursorTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenCursorTests.cs index 7704d295..0d64cccb 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenCursorTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenCursorTests.cs @@ -177,7 +177,8 @@ public async Task HeaderHints_AdvertiseOnlyTheKeysTheScreensImplement() await Assert.That(OptionsScreenRenderer.HeaderLine("Logging", "F9", 0)) .Contains(ScreenChrome.SingleListHints); - // Nothing edits a field yet, so no screen may claim ⏎ opens an editor. + // A header handed no model describes a screen that only navigates, so it may not claim ⏎ + // opens an editor — nor any of the verbs an editor would be advertised under. foreach (var header in new[] { TriggersScreenRenderer.HeaderLine(0), @@ -193,4 +194,108 @@ await Assert.That(OptionsScreenRenderer.HeaderLine("Logging", "F9", 0)) await Assert.That(header).DoesNotContain("⏎ change"); } } + + /// + /// The hint honesty rule, in both directions: a screen advertises ⏎ edit if and only + /// if its actually holds a row ⏎ can open. Every header is built + /// from the same model the live view hands it, so a screen that grew (or lost) an editable row + /// cannot end up saying otherwise. + /// + [Test] + public async Task HeaderHints_ClaimAnEditorExactlyWhenTheModelOffersOne() + { + var populated = Populated(); + var bare = Bare(); + + // Both cases must be represented, or an "if and only if" would pass vacuously. + await Assert.That(populated.Any(s => s.Model.HasEditableRow)).IsTrue(); + await Assert.That(bare.Any(s => !s.Model.HasEditableRow)).IsTrue(); + + foreach (var (header, model) in populated.Concat(bare)) + { + await Assert.That(header.Contains(ScreenChrome.EditHint, StringComparison.Ordinal)) + .IsEqualTo(model.HasEditableRow); + } + } + + /// + /// While a field is open the header stops offering the screen's own verbs — Esc reverts the buffer + /// rather than closing, and saying "Esc close" there would be the same lie pointed the other way. + /// + [Test] + public async Task HeaderHints_SwapToTheEditingKeysWhileAFieldIsOpen() + { + var sets = Sets(); + var model = TimersScreenRenderer.Model(sets, 0); + var editing = new ScreenFocus(0, 0, new ScreenFieldEdit(0, "30", 2, null, RowFields: 2)); + + var header = TimersScreenRenderer.HeaderLine(0, model, editing); + + await Assert.That(header).Contains(ScreenChrome.EditingHints); + await Assert.That(header).Contains(ScreenChrome.NextFieldHint); + await Assert.That(header).DoesNotContain(ScreenChrome.ListHints); + await Assert.That(header).DoesNotContain("Esc[/][#7c8699] close"); + + // A row with a single field has nowhere for ⇥ to go, so it doesn't offer it. + var single = TimersScreenRenderer.HeaderLine( + 0, model, new ScreenFocus(0, 0, new ScreenFieldEdit(0, "30", 2, null))); + await Assert.That(single).DoesNotContain(ScreenChrome.NextFieldHint); + } + + /// Screens whose models hold editable rows, each header built from that same model. + private static List<(string Header, ScreenModel Model)> Populated() + { + var sets = Sets(); + var worlds = new List + { + new() { Name = "Aardwolf", Host = "aardmud.org", Characters = new List { new() } }, + }; + var logging = OptionsScreenRenderer.LoggingScreen(new LoggingSettings()); + + return new List<(string, ScreenModel)> + { + Pair(TriggersScreenRenderer.Model(sets, 0), m => TriggersScreenRenderer.HeaderLine(0, m)), + Pair(AliasesScreenRenderer.Model(sets, 0), m => AliasesScreenRenderer.HeaderLine(0, m)), + Pair(TimersScreenRenderer.Model(sets, 0), m => TimersScreenRenderer.HeaderLine(0, m)), + Pair(KeypadScreenRenderer.Model(sets[0].Macros), m => KeypadScreenRenderer.HeaderLine(0, m)), + Pair( + WorldsScreenRenderer.Model(worlds, sets, 0, 0), + m => WorldsScreenRenderer.HeaderLine(0, m)), + Pair( + OptionsScreenRenderer.Model(logging), + m => OptionsScreenRenderer.HeaderLine(logging.Title, logging.FKey, 0, m)), + }; + } + + /// The same screens with nothing to edit — empty lists, and an options screen of toggles. + private static List<(string Header, ScreenModel Model)> Bare() + { + var empty = new List(); + var toggles = new OptionsScreenRenderer.OptionsScreen( + "Toggles", + "F7", + new List + { + new("local echo", null, true, null, ScreenToggle.Bind(() => true, _ => { })), + }); + + return new List<(string, ScreenModel)> + { + Pair(TriggersScreenRenderer.Model(empty, -1), m => TriggersScreenRenderer.HeaderLine(0, m)), + Pair(AliasesScreenRenderer.Model(empty, -1), m => AliasesScreenRenderer.HeaderLine(0, m)), + Pair(TimersScreenRenderer.Model(empty, -1), m => TimersScreenRenderer.HeaderLine(0, m)), + Pair( + KeypadScreenRenderer.Model(Array.Empty()), + m => KeypadScreenRenderer.HeaderLine(0, m)), + Pair( + WorldsScreenRenderer.Model(Array.Empty(), empty, -1, -1), + m => WorldsScreenRenderer.HeaderLine(0, m)), + Pair( + OptionsScreenRenderer.Model(toggles), + m => OptionsScreenRenderer.HeaderLine(toggles.Title, toggles.FKey, 0, m)), + }; + } + + private static (string Header, ScreenModel Model) Pair(ScreenModel model, Func header) => + (header(model), model); } diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenFieldRenderingTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenFieldRenderingTests.cs new file mode 100644 index 00000000..6bba9137 --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/ScreenFieldRenderingTests.cs @@ -0,0 +1,199 @@ +using SharpMUTerm.Core.Automation; +using SharpMUTerm.Core.Configuration; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// Where an open field edit is drawn. A screen whose state machine is right and whose renderer shows +/// nothing is still unusable, so each screen is asserted to put the buffer and the caret on the line +/// where that field's value already lives — and, just as importantly, to draw exactly what it always +/// drew when nothing is being typed. +/// +public class ScreenFieldRenderingTests +{ + /// The block caret: the ink colour on the accent (see ). + private static readonly string Caret = $"[{ScreenPalette.Ink} on {ScreenPalette.Accent}]"; + + private static bool HasCaret(string line) => line.Contains(Caret, StringComparison.Ordinal); + + private static int Carets(IEnumerable lines) => lines.Count(HasCaret); + + private static List Sets() => new() + { + new TriggerSet + { + Name = "Comms", + Triggers = new List { new() { Name = "Tell", Pattern = "tells you" } }, + Aliases = new List { new() { Name = "k", Pattern = "^k$", Substitution = "kill $1\nsay done" } }, + Macros = new List { new() { Name = "look", Key = "Num5", Command = "look" } }, + Timers = new List { new() { Name = "ping", IntervalSeconds = 30, Command = "look" } }, + }, + }; + + private static List Worlds() => new() + { + new() + { + Name = "Aardwolf", + Host = "aardmud.org", + Port = 4000, + Characters = new List { new() { Name = "Kaz", OnConnect = "look" } }, + }, + }; + + private static ScreenFocus Edit(int pane, int index, int field, string text, string? error = null) => + new(pane, index, new ScreenFieldEdit(field, text, text.Length, error)); + + [Test] + public async Task NoOpenEdit_DrawsNoCaretOnAnyScreen() + { + var sets = Sets(); + var worlds = Worlds(); + + await Assert.That(Carets(TriggersScreenRenderer.EditorColumn(sets, 0, Array.Empty()))).IsEqualTo(0); + await Assert.That(Carets(AliasesScreenRenderer.EditorColumn(sets, 0))).IsEqualTo(0); + await Assert.That(Carets(TimersScreenRenderer.EditorColumn(sets, 0))).IsEqualTo(0); + await Assert.That(Carets(KeypadScreenRenderer.HotkeysColumn(sets[0].Macros))).IsEqualTo(0); + await Assert.That(Carets( + WorldsScreenRenderer.DetailColumn(worlds, sets, 0, 0, ScreenPalette.Accent))).IsEqualTo(0); + await Assert.That(Carets( + OptionsScreenRenderer.BodyColumn(OptionsScreenRenderer.TextAnsiScreen().Rows))).IsEqualTo(0); + } + + [Test] + public async Task Worlds_DrawsTheBufferOnTheFieldsOwnLine_AndNowhereElse() + { + var lines = WorldsScreenRenderer.DetailColumn( + Worlds(), Sets(), 0, 0, ScreenPalette.Accent, Edit(0, 0, 1, "aardmud.net")); + + await Assert.That(Carets(lines)).IsEqualTo(1); + var edited = lines.Single(HasCaret); + await Assert.That(edited).Contains("host"); + await Assert.That(edited).Contains("aardmud.ne"); + + // The name line is a different field of the same row, so it stays committed. (The world's + // label column is right-aligned, which is what tells it apart from the characters header.) + await Assert.That(lines.Single(l => l.Contains(" name[/]", StringComparison.Ordinal))) + .Contains("Aardwolf"); + } + + [Test] + public async Task Worlds_PortAndKeepaliveGetTheirOwnCarets() + { + var worlds = Worlds(); + + var port = WorldsScreenRenderer.DetailColumn( + worlds, Sets(), 0, 0, ScreenPalette.Accent, Edit(0, 0, 2, "42")).Single(HasCaret); + await Assert.That(port).Contains("port"); + + var keepalive = WorldsScreenRenderer.DetailColumn( + worlds, Sets(), 0, 0, ScreenPalette.Accent, Edit(0, 0, 4, "30")).Single(HasCaret); + await Assert.That(keepalive).Contains("keepalive"); + } + + [Test] + public async Task Worlds_TheCharacterFormEditsTheCharacterRowsFields() + { + var character = Worlds()[0].Characters[0]; + + var name = WorldsScreenRenderer.FormColumn(character, ScreenPalette.Accent, Edit(1, 0, 0, "Kazimir"), 0) + .Single(HasCaret); + await Assert.That(name).Contains("Kazimi"); + + var onConnect = WorldsScreenRenderer + .FormColumn(character, ScreenPalette.Accent, Edit(1, 0, 1, "look;score"), 0) + .Single(HasCaret); + await Assert.That(onConnect).Contains("on connect"); + } + + [Test] + public async Task Triggers_DrawsThePatternBufferUnderItsOwnLabel() + { + var lines = TriggersScreenRenderer.EditorColumn( + Sets(), 0, Array.Empty(), Edit(0, 0, 0, "pages you")); + + await Assert.That(Carets(lines)).IsEqualTo(1); + var edited = lines.Single(HasCaret); + await Assert.That(edited).Contains("pages yo"); + await Assert.That(lines[lines.IndexOf(edited) - 1]).Contains("match pattern"); + } + + [Test] + public async Task Aliases_DrawsThePatternAndCollapsesTheExpansionToTheRowBeingTyped() + { + var sets = Sets(); + + var pattern = AliasesScreenRenderer.EditorColumn(sets, 0, Edit(0, 0, 0, "^kk$")); + await Assert.That(Carets(pattern)).IsEqualTo(1); + await Assert.That(pattern.Single(HasCaret)).Contains("^kk$"); + + // Off-edit the expansion lists one command per line; being typed it is one escaped row. + await Assert.That(AliasesScreenRenderer.EditorColumn(sets, 0).Count(l => l.Contains("say done"))).IsEqualTo(1); + + var expansion = AliasesScreenRenderer.EditorColumn(sets, 0, Edit(0, 0, 1, @"kill $1\nsay done")); + await Assert.That(Carets(expansion)).IsEqualTo(1); + await Assert.That(expansion.Single(HasCaret)).Contains(@"kill $1\nsay don"); + } + + [Test] + public async Task Timers_DrawsTheIntervalAndCommandBuffers() + { + var sets = Sets(); + + var interval = TimersScreenRenderer.EditorColumn(sets, 0, Edit(0, 0, 0, "45")); + await Assert.That(Carets(interval)).IsEqualTo(1); + await Assert.That(interval.Single(HasCaret)).Contains("45"); + + var command = TimersScreenRenderer.EditorColumn(sets, 0, Edit(0, 0, 1, "score")); + await Assert.That(command.Single(HasCaret)).Contains("scor"); + } + + [Test] + public async Task Keypad_DrawsTheCommandBufferInTheBindingRowItself() + { + var macros = Sets()[0].Macros; + + var lines = KeypadScreenRenderer.HotkeysColumn(macros, Edit(0, 0, 0, "look here")); + + await Assert.That(Carets(lines)).IsEqualTo(1); + var edited = lines.Single(HasCaret); + await Assert.That(edited).Contains("Num5"); + await Assert.That(edited).Contains("look her"); + } + + [Test] + public async Task Options_DrawsTheBufferOnTheValueRowUnderTheCursor() + { + var screen = OptionsScreenRenderer.LoggingScreen(new LoggingSettings { Format = LogFormat.Plain }); + + // Navigable row 0 is "format"; row 1 is "directory". + var format = OptionsScreenRenderer.BodyColumn(screen.Rows, Edit(0, 0, 0, "Html")); + await Assert.That(Carets(format)).IsEqualTo(1); + await Assert.That(format.Single(HasCaret)).Contains("format"); + + var directory = OptionsScreenRenderer.BodyColumn(screen.Rows, Edit(0, 1, 0, "/logs")); + await Assert.That(directory.Single(HasCaret)).Contains("directory"); + } + + [Test] + public async Task ARefusedValueIsMarkedOnTheRowThatRefusedIt() + { + var lines = WorldsScreenRenderer.DetailColumn( + Worlds(), Sets(), 0, 0, ScreenPalette.Accent, + Edit(0, 0, 2, "99999", "port must be a whole number 1-65535")); + + var edited = lines.Single(HasCaret); + await Assert.That(edited).Contains(ScreenPalette.Warn); + await Assert.That(edited).Contains("port must be a whole number 1-65535"); + } + + [Test] + public async Task BracketsTypedIntoABufferAreEscaped_NotRenderedAsMarkup() + { + var lines = KeypadScreenRenderer.HotkeysColumn(Sets()[0].Macros, Edit(0, 0, 0, "say [red]hi")); + + var edited = lines.Single(HasCaret); + await Assert.That(edited).Contains("[[red]]hi"); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenFieldTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenFieldTests.cs new file mode 100644 index 00000000..c923de9c --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/ScreenFieldTests.cs @@ -0,0 +1,192 @@ +using SharpMUTerm.Core.Configuration; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// What each kind of editable value will and won't accept, and what it puts back on undo. Validation +/// is the guarantee that an invalid value never reaches config, so it is asserted per field kind +/// rather than only through the screens that happen to use one. +/// +public class ScreenFieldTests +{ + /// Applies a value the way a screen does, returning the rejection reason (null = taken). + private static string? Apply(ScreenField field, string value) => new ScreenEdits().Apply(field, value); + + [Test] + public async Task Text_RefusesBlankAndTrimsWhatItTakes() + { + var host = "aardmud.org"; + var field = ScreenField.Text("host", () => host, v => host = v); + + await Assert.That(Apply(field, " ")).IsNotNull(); + await Assert.That(host).IsEqualTo("aardmud.org"); + + await Assert.That(Apply(field, " example.net ")).IsNull(); + await Assert.That(host).IsEqualTo("example.net"); + } + + [Test] + public async Task Optional_TakesBlankAsUnset() + { + string? directory = "/logs"; + var field = ScreenField.Optional("directory", () => directory, v => directory = v); + + await Assert.That(field.Get()).IsEqualTo("/logs"); + await Assert.That(Apply(field, " ")).IsNull(); + await Assert.That(directory).IsNull(); + await Assert.That(field.Get()).IsEqualTo(string.Empty); + } + + [Test] + public async Task Integer_RefusesNonNumbersAndAnythingOutOfRange() + { + var port = 4000; + var field = ScreenField.Integer("port", () => port, v => port = v, 1, 65535); + + await Assert.That(Apply(field, "http")).IsNotNull(); + await Assert.That(Apply(field, "0")).IsNotNull(); + await Assert.That(Apply(field, "65536")).IsNotNull(); + await Assert.That(Apply(field, "4000.5")).IsNotNull(); + await Assert.That(port).IsEqualTo(4000); + + await Assert.That(Apply(field, " 4201 ")).IsNull(); + await Assert.That(port).IsEqualTo(4201); + } + + [Test] + public async Task Integer_SaysWhatItWanted() + { + var port = 4000; + var field = ScreenField.Integer("port", () => port, v => port = v, 1, 65535); + + await Assert.That(Apply(field, "-1")).IsEqualTo("port must be a whole number 1-65535"); + } + + [Test] + public async Task Number_TakesFractionsInsideItsRangeAndNothingAtOrBelowZero() + { + var seconds = 30d; + var field = ScreenField.Number("interval", () => seconds, v => seconds = v, 0.1, 86400); + + await Assert.That(Apply(field, "0")).IsNotNull(); + await Assert.That(Apply(field, "-5")).IsNotNull(); + await Assert.That(Apply(field, "soon")).IsNotNull(); + await Assert.That(seconds).IsEqualTo(30d); + + await Assert.That(Apply(field, "5.5")).IsNull(); + await Assert.That(seconds).IsEqualTo(5.5); + await Assert.That(field.Get()).IsEqualTo("5.5"); + } + + [Test] + public async Task Pattern_RefusesARegexThatWouldNotCompile() + { + var pattern = "tells you"; + var field = ScreenField.Pattern("match pattern", () => pattern, v => pattern = v); + + var rejected = Apply(field, "(unclosed"); + await Assert.That(rejected).IsNotNull(); + await Assert.That(rejected!).Contains("not a valid regex"); + await Assert.That(pattern).IsEqualTo("tells you"); + + await Assert.That(Apply(field, @"^(\w+) tells you")).IsNull(); + await Assert.That(pattern).IsEqualTo(@"^(\w+) tells you"); + } + + [Test] + public async Task Choice_MatchesCaseInsensitivelyAndStoresTheCanonicalName() + { + var width = "narrow"; + var field = ScreenField.Choice("ambiguous width", () => width, v => width = v, new[] { "narrow", "wide" }); + + await Assert.That(Apply(field, "double")).IsNotNull(); + await Assert.That(width).IsEqualTo("narrow"); + + await Assert.That(Apply(field, "WIDE")).IsNull(); + await Assert.That(width).IsEqualTo("wide"); + } + + [Test] + public async Task Enumeration_ParsesByNameAndCyclesWithBothDirections() + { + var format = LogFormat.Plain; + var field = ScreenField.Enumeration("format", () => format, v => format = v); + + await Assert.That(Apply(field, "Verbose")).IsNotNull(); + await Assert.That(format).IsEqualTo(LogFormat.Plain); + + await Assert.That(Apply(field, "html")).IsNull(); + await Assert.That(format).IsEqualTo(LogFormat.Html); + + await Assert.That(field.Cycle("Html", 1)).IsEqualTo("Both"); + await Assert.That(field.Cycle("None", -1)).IsEqualTo("Both"); // wraps at the start + await Assert.That(field.Cycle("Ht", 1)).IsEqualTo("None"); // half-typed starts over + } + + [Test] + public async Task PlainFields_HaveNothingToCycle() + { + var host = "aardmud.org"; + var field = ScreenField.Text("host", () => host, v => host = v); + + await Assert.That(field.Cycle(host, 1)).IsNull(); + } + + [Test] + public async Task Lines_EditsAMultiLineValueOnOneRowAndPutsTheBreaksBack() + { + var substitution = "kill $1\nsay done"; + var field = ScreenField.Lines("expansion", () => substitution, v => substitution = v); + + await Assert.That(field.Get()).IsEqualTo(@"kill $1\nsay done"); + + await Assert.That(Apply(field, @"look\nsay hi")).IsNull(); + await Assert.That(substitution).IsEqualTo("look\nsay hi"); + } + + [Test] + public async Task Lines_RoundTripsALiteralBackslash() + { + var substitution = @"say a\b"; + var field = ScreenField.Lines("expansion", () => substitution, v => substitution = v); + + var shown = field.Get(); + await Assert.That(shown).IsEqualTo(@"say a\\b"); + + await Assert.That(Apply(field, shown)).IsNull(); + await Assert.That(substitution).IsEqualTo(@"say a\b"); + } + + [Test] + public async Task Snapshot_RestoresTheTypedValue_NotTheTextItWasShownAs() + { + // The point of the Snapshot indirection: undoing a port restores an int, and undoing a log + // format restores the enum — neither goes back through the buffer they were edited in. + var port = 4000; + var format = LogFormat.Html; + var edits = new ScreenEdits(); + + edits.Apply(ScreenField.Integer("port", () => port, v => port = v, 1, 65535), "4201"); + edits.Apply(ScreenField.Enumeration("format", () => format, v => format = v), "None"); + await Assert.That(port).IsEqualTo(4201); + await Assert.That(format).IsEqualTo(LogFormat.None); + + edits.Revert(); + + await Assert.That(port).IsEqualTo(4000); + await Assert.That(format).IsEqualTo(LogFormat.Html); + } + + [Test] + public async Task ARejectedValueRecordsNothingToUndo() + { + var port = 4000; + var edits = new ScreenEdits(); + + edits.Apply(ScreenField.Integer("port", () => port, v => port = v, 1, 65535), "nope"); + + await Assert.That(edits.IsDirty).IsFalse(); + await Assert.That(edits.Count).IsEqualTo(0); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/SettingsSessionEditTests.cs b/tests/SharpMUTerm.Tui.Tests/SettingsSessionEditTests.cs new file mode 100644 index 00000000..33f2d9a3 --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/SettingsSessionEditTests.cs @@ -0,0 +1,395 @@ +using SharpMUTerm.Core.Automation; +using SharpMUTerm.Core.Configuration; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// The field-edit state machine: what ⏎ does on each kind of row, what the keyboard means once an +/// edit is open, what a rejected value does, and what Cancel puts back. All of it is pure, so the +/// whole contract is asserted here rather than being discovered in a terminal. +/// +public class SettingsSessionEditTests +{ + private static ConsoleKeyInfo Key(ConsoleKey key, ConsoleModifiers modifiers = default) => + new('\0', key, modifiers.HasFlag(ConsoleModifiers.Shift), false, + modifiers.HasFlag(ConsoleModifiers.Control)); + + private static ConsoleKeyInfo Char(char c) => new(c, ConsoleKey.NoName, false, false, false); + + private static void Type(SettingsSession session, string text) + { + foreach (var c in text) + { + session.Handle(Char(c)); + } + } + + /// A one-pane screen: a stop, a checkbox, and a two-field record (a host and a port). + private sealed class Scene + { + public bool Flag { get; set; } + + public string Host { get; set; } = "aardmud.org"; + + public int Port { get; set; } = 4000; + + public SettingsSession Session() => new(_ => new ScreenModel(new[] + { + ScreenRow.Stop, + ScreenRow.Of(ScreenToggle.Bind(() => Flag, v => Flag = v)), + ScreenRow.Of( + ScreenField.Text("host", () => Host, v => Host = v), + ScreenField.Integer("port", () => Port, v => Port = v, 1, 65535)), + })); + } + + /// Puts the cursor on the record row (index 2) and opens its first field. + private static SettingsSession Editing(Scene scene) + { + var session = scene.Session(); + session.Handle(Key(ConsoleKey.DownArrow)); + session.Handle(Key(ConsoleKey.DownArrow)); + session.Handle(Key(ConsoleKey.Enter)); + return session; + } + + [Test] + public async Task Enter_OnARowWithNoFieldStillSavesAndCloses() + { + var session = new Scene().Session(); + + await Assert.That(session.Handle(Key(ConsoleKey.Enter))).IsEqualTo(ScreenAction.Save); + await Assert.That(session.IsEditing).IsFalse(); + + session.Handle(Key(ConsoleKey.DownArrow)); + await Assert.That(session.Handle(Key(ConsoleKey.Enter))).IsEqualTo(ScreenAction.Save); + } + + [Test] + public async Task Enter_OnAFieldRowOpensAnEditSeededWithTheCurrentValue() + { + var session = Editing(new Scene()); + + await Assert.That(session.IsEditing).IsTrue(); + await Assert.That(session.Focus().Edit).IsEqualTo( + new ScreenFieldEdit(0, "aardmud.org", 11, null, RowFields: 2)); + } + + [Test] + public async Task TypingInsertsAtTheCaretAndBackspaceRemovesBehindIt() + { + var scene = new Scene(); + var session = Editing(scene); + + session.Handle(Key(ConsoleKey.Backspace)); + session.Handle(Key(ConsoleKey.Backspace)); + session.Handle(Key(ConsoleKey.Backspace)); + Type(session, "net"); + + await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("aardmud.net"); + + // Nothing is written until it is committed — the buffer is not config. + await Assert.That(scene.Host).IsEqualTo("aardmud.org"); + + await Assert.That(session.Handle(Key(ConsoleKey.Enter))).IsEqualTo(ScreenAction.Redraw); + await Assert.That(scene.Host).IsEqualTo("aardmud.net"); + await Assert.That(session.IsEditing).IsFalse(); + } + + [Test] + public async Task SpaceTypesASpaceInsteadOfTogglingWhileAnEditIsOpen() + { + var scene = new Scene(); + var session = Editing(scene); + + session.Handle(new ConsoleKeyInfo(' ', ConsoleKey.Spacebar, false, false, false)); + + await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("aardmud.org "); + await Assert.That(scene.Flag).IsFalse(); + } + + [Test] + public async Task TheCaretMovesWithTheArrowsHomeAndEnd_AndDeleteTakesTheCharacterUnderIt() + { + var session = Editing(new Scene()); + + session.Handle(Key(ConsoleKey.Home)); + await Assert.That(session.Focus().Edit!.Value.Caret).IsEqualTo(0); + + session.Handle(Key(ConsoleKey.Delete)); + await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("ardmud.org"); + + session.Handle(Key(ConsoleKey.RightArrow)); + Type(session, "-"); + await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("a-rdmud.org"); + + session.Handle(Key(ConsoleKey.End)); + await Assert.That(session.Focus().Edit!.Value.Caret).IsEqualTo(11); + + // Neither end wraps, and a caret that can't move doesn't cost a redraw. + await Assert.That(session.Handle(Key(ConsoleKey.RightArrow))).IsEqualTo(ScreenAction.Consumed); + session.Handle(Key(ConsoleKey.Home)); + await Assert.That(session.Handle(Key(ConsoleKey.LeftArrow))).IsEqualTo(ScreenAction.Consumed); + } + + [Test] + public async Task Escape_AbandonsTheEditAndLeavesTheScreenOpen() + { + var scene = new Scene(); + var session = Editing(scene); + Type(session, "!!!"); + + await Assert.That(session.Handle(Key(ConsoleKey.Escape))).IsEqualTo(ScreenAction.Redraw); + + await Assert.That(session.IsEditing).IsFalse(); + await Assert.That(scene.Host).IsEqualTo("aardmud.org"); + await Assert.That(session.Edits.IsDirty).IsFalse(); + + // Only now does Esc mean the screen. + await Assert.That(session.Handle(Key(ConsoleKey.Escape))).IsEqualTo(ScreenAction.Cancel); + } + + [Test] + public async Task ARejectedValueKeepsTheEditOpen_MarksTheField_AndNeverReachesConfig() + { + var scene = new Scene(); + var session = Editing(scene); + + session.Handle(Key(ConsoleKey.Tab)); // commit the host, step to the port + for (var i = 0; i < 4; i++) + { + session.Handle(Key(ConsoleKey.Backspace)); + } + + Type(session, "99999"); + await Assert.That(session.Handle(Key(ConsoleKey.Enter))).IsEqualTo(ScreenAction.Redraw); + + await Assert.That(session.IsEditing).IsTrue(); + await Assert.That(session.Focus().Edit!.Value.Error).IsEqualTo("port must be a whole number 1-65535"); + await Assert.That(scene.Port).IsEqualTo(4000); + + // Correcting it clears the mark and lets it through. + session.Handle(Key(ConsoleKey.Backspace)); + await Assert.That(session.Focus().Edit!.Value.Error).IsNull(); + session.Handle(Key(ConsoleKey.Enter)); + + await Assert.That(scene.Port).IsEqualTo(9999); + await Assert.That(session.IsEditing).IsFalse(); + } + + [Test] + public async Task Tab_CommitsTheFieldAndStepsToTheRowsNext_WrappingBack() + { + var scene = new Scene(); + var session = Editing(scene); + Type(session, ".uk"); + + session.Handle(Key(ConsoleKey.Tab)); + + await Assert.That(scene.Host).IsEqualTo("aardmud.org.uk"); + await Assert.That(session.Focus().Edit!.Value.Field).IsEqualTo(1); + await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("4000"); + + session.Handle(Key(ConsoleKey.Tab)); + await Assert.That(session.Focus().Edit!.Value.Field).IsEqualTo(0); + + session.Handle(Key(ConsoleKey.Tab, ConsoleModifiers.Shift)); + await Assert.That(session.Focus().Edit!.Value.Field).IsEqualTo(1); + } + + [Test] + public async Task Tab_WillNotStepPastAValueThatDoesNotValidate() + { + var scene = new Scene(); + var session = Editing(scene); + session.Handle(Key(ConsoleKey.Home)); + for (var i = 0; i < 11; i++) + { + session.Handle(Key(ConsoleKey.Delete)); + } + + session.Handle(Key(ConsoleKey.Tab)); + + await Assert.That(session.Focus().Edit!.Value.Field).IsEqualTo(0); + await Assert.That(session.Focus().Edit!.Value.Error).IsNotNull(); + await Assert.That(scene.Host).IsEqualTo("aardmud.org"); + } + + [Test] + public async Task ControlS_SavesFromNavigation_AndCommitsAnOpenFieldFirst() + { + var scene = new Scene(); + var session = scene.Session(); + + await Assert.That(session.Handle(Key(ConsoleKey.S, ConsoleModifiers.Control))) + .IsEqualTo(ScreenAction.Save); + + session = Editing(scene); + Type(session, ".uk"); + await Assert.That(session.Handle(Key(ConsoleKey.S, ConsoleModifiers.Control))) + .IsEqualTo(ScreenAction.Save); + await Assert.That(scene.Host).IsEqualTo("aardmud.org.uk"); + await Assert.That(session.IsEditing).IsFalse(); + } + + [Test] + public async Task ControlS_WillNotSaveAValueThatDoesNotValidate() + { + var scene = new Scene(); + var session = Editing(scene); + + session.Handle(Key(ConsoleKey.Tab)); + for (var i = 0; i < 4; i++) + { + session.Handle(Key(ConsoleKey.Backspace)); + } + + Type(session, "http"); + + await Assert.That(session.Handle(Key(ConsoleKey.S, ConsoleModifiers.Control))) + .IsEqualTo(ScreenAction.Redraw); + await Assert.That(session.IsEditing).IsTrue(); + await Assert.That(scene.Port).IsEqualTo(4000); + } + + [Test] + public async Task NavigationIsSuspendedWhileAnEditIsOpen() + { + var session = Editing(new Scene()); + + session.Handle(Key(ConsoleKey.UpArrow)); + session.Handle(Key(ConsoleKey.DownArrow)); + + await Assert.That(session.Focus().Index).IsEqualTo(2); + await Assert.That(session.IsEditing).IsTrue(); + } + + [Test] + public async Task UpAndDownCycleAnEnumFieldsChoices() + { + var format = LogFormat.Plain; + var session = new SettingsSession(_ => new ScreenModel(new[] + { + ScreenRow.Of(ScreenField.Enumeration("format", () => format, v => format = v)), + })); + + session.Handle(Key(ConsoleKey.Enter)); + session.Handle(Key(ConsoleKey.DownArrow)); + + await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("Html"); + session.Handle(Key(ConsoleKey.UpArrow)); + await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("Plain"); + + session.Handle(Key(ConsoleKey.Enter)); + await Assert.That(format).IsEqualTo(LogFormat.Plain); + } + + [Test] + public async Task CancellingTheScreenPutsAnEditedValueBack_JustLikeAToggle() + { + var scene = new Scene(); + var session = Editing(scene); + Type(session, ".uk"); + session.Handle(Key(ConsoleKey.Tab)); // commits the host, opens the port + for (var i = 0; i < 4; i++) + { + session.Handle(Key(ConsoleKey.Backspace)); + } + + Type(session, "4201"); + session.Handle(Key(ConsoleKey.Enter)); + session.Handle(Key(ConsoleKey.UpArrow)); + session.Handle(new ConsoleKeyInfo(' ', ConsoleKey.Spacebar, false, false, false)); + + await Assert.That(scene.Host).IsEqualTo("aardmud.org.uk"); + await Assert.That(scene.Port).IsEqualTo(4201); + await Assert.That(scene.Flag).IsTrue(); + + // What SettingsOverlay does on Esc / the F-key toggle. + session.Edits.Revert(); + + await Assert.That(scene.Host).IsEqualTo("aardmud.org"); + await Assert.That(scene.Port).IsEqualTo(4000); + await Assert.That(scene.Flag).IsFalse(); + } + + [Test] + public async Task AnEditAbandonsItselfWhenTheRowItWasOpenedOnDisappears() + { + var rows = new List { "one", "two" }; + var session = new SettingsSession(_ => new ScreenModel( + ScreenModel.Rows(rows, r => ScreenRow.Of( + ScreenField.Text("name", () => r, _ => { }))))); + + session.Handle(Key(ConsoleKey.DownArrow)); + session.Handle(Key(ConsoleKey.Enter)); + await Assert.That(session.IsEditing).IsTrue(); + + rows.RemoveAt(1); + await Assert.That(session.Handle(Char('x'))).IsEqualTo(ScreenAction.Redraw); + await Assert.That(session.IsEditing).IsFalse(); + } + + [Test] + public async Task AnUnrelatedKeyIsStillLeftForTheFrameworkMidEdit() + { + var session = Editing(new Scene()); + + await Assert.That(session.Handle(Key(ConsoleKey.F5))).IsEqualTo(ScreenAction.None); + await Assert.That(session.IsEditing).IsTrue(); + } + + /// + /// The screens' real bindings, end to end: the field ordinals a renderer draws against are the + /// ordinals the session opens, and each writes to the property the screen says it does. + /// + [Test] + public async Task TheRealScreensBindTheirFieldsInTheOrderTheyAreDrawn() + { + var world = new WorldDefinition { Name = "Aardwolf", Host = "aardmud.org", Port = 4000 }; + var worlds = new List { world }; + var model = WorldsScreenRenderer.Model(worlds, Array.Empty(), 0, -1); + + await Assert.That(model.FieldAt(0, 0, 0)!.Value.Get()).IsEqualTo("Aardwolf"); + await Assert.That(model.FieldAt(0, 0, 1)!.Value.Get()).IsEqualTo("aardmud.org"); + await Assert.That(model.FieldAt(0, 0, 2)!.Value.Get()).IsEqualTo("4000"); + await Assert.That(model.FieldAt(0, 0, 3)!.Value.Get()).IsEqualTo("UTF-8"); + await Assert.That(model.FieldAt(0, 0, 4)!.Value.Get()).IsEqualTo("0"); + + new ScreenEdits().Apply(model.FieldAt(0, 0, 1)!.Value, "example.net"); + await Assert.That(world.Host).IsEqualTo("example.net"); + } + + [Test] + public async Task EditingATriggersPatternRecompilesItsMatcher() + { + var sets = new List + { + new() { Name = "Comms", Triggers = new List { new() { Name = "Tell", Pattern = "tells you" } } }, + }; + var trigger = sets[0].Triggers[0]; + await Assert.That(trigger.Regex.IsMatch("she tells you hi")).IsTrue(); + + new ScreenEdits().Apply(TriggersScreenRenderer.Model(sets, 0).FieldAt(0, 0, 0)!.Value, "pages you"); + + await Assert.That(trigger.Regex.IsMatch("she tells you hi")).IsFalse(); + await Assert.That(trigger.Regex.IsMatch("she pages you")).IsTrue(); + } + + [Test] + public async Task EditingAnAliasPatternRecompilesItsMatcher() + { + var sets = new List + { + new() { Name = "Comms", Aliases = new List { new() { Name = "k", Pattern = "^k$" } } }, + }; + var alias = sets[0].Aliases[0]; + await Assert.That(alias.Regex.IsMatch("k")).IsTrue(); + + new ScreenEdits().Apply(AliasesScreenRenderer.Model(sets, 0).FieldAt(0, 0, 0)!.Value, "^kk$"); + + await Assert.That(alias.Regex.IsMatch("k")).IsFalse(); + await Assert.That(alias.Regex.IsMatch("kk")).IsTrue(); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/SettingsSessionTests.cs b/tests/SharpMUTerm.Tui.Tests/SettingsSessionTests.cs index 2e86ed2c..04bd7ff7 100644 --- a/tests/SharpMUTerm.Tui.Tests/SettingsSessionTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/SettingsSessionTests.cs @@ -121,7 +121,7 @@ public async Task RevertingTheEditsUndoesEveryToggleTheScreenApplied() [Test] public async Task Focus_IsNoneWhenTheScreenHasNoRowsAtAll() { - var session = new SettingsSession(_ => new ScreenModel(Array.Empty())); + var session = new SettingsSession(_ => new ScreenModel(Array.Empty())); await Assert.That(session.Focus()).IsEqualTo(ScreenFocus.None); } From dad7696ae0dd4c80b441ff2e8d621aacc6a4023f Mon Sep 17 00:00:00 2001 From: Harry Cordewener Date: Tue, 28 Jul 2026 19:02:12 -0500 Subject: [PATCH 11/23] Settings screens: row buttons, route radios, colour picker MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Finishes backlog item 1. The add/remove buttons were painted but inert, and F2's route list and highlight row were read-only indicators. A ScreenRow may now carry a button whose action returns its own undo, rather than being snapshotted beforehand like a toggle or field: the undo for an insertion cannot be described until the thing exists. Deleting restores at the original index on cancel, not merely re-appends. Buttons that would act on nothing are not drawn, so ⏎ never lands on a silent no-op, and destructive buttons name their target on screen ([- del] Aetherfall) so the row says what it will remove. Delete is undo-only with no confirmation step: nothing reaches disk until Save, Esc already replays the undo log, and a second modal state inside a screen that already has one would double the key-routing rules for a change that is reversible anyway. Route radios and the highlight swatches are fields on the rule's own row, not new rows -- a radio group and a swatch pair are one setting each, so giving them a row apiece would put N cursor stops in front of one value. The radios follow the buffer rather than config so ↑↓ visibly move the dot before ⏎, instead of the group looking inert exactly while in use. Colour is a named palette rather than an RGB picker, but the validator deliberately accepts more than the palette offers -- #rrggbb, idx:N and none all commit -- because a TerminalColor already in config may be a colour no short palette names, and a picker that refused the value it was displaying would make an existing highlight uneditable. Fixes the footer lying mid-edit: it read [⏎] Save while ⏎ was committing a field. Focus is threaded through all six FooterLines, and a new test pins header and footer agreeing about whether an edit is open, in both directions so it cannot pass by naming no key. Two pinned row counts in ScreenModelTests legitimately changed -- {2,2,1} to {4,5,1} and {2,0,0} to {4,1,0} -- because button rows are real navigable rows. Buttons append after each list, so every index those tests address still means what it did. Also fixes the cursor doubling as the selection: moving onto [+ world] pushed the selection past the list, blanking the detail column. Cursor and selection anchor are now separate. 844 tests pass, up from 811. Eight consecutive Tui runs clean. Co-Authored-By: Claude Opus 5 (1M context) --- CLAUDE.md | 3 +- docs/HANDOFF.md | 80 +++- src/SharpMUTerm.Core/Automation/Trigger.cs | 21 +- .../Configuration/CharacterDefinition.cs | 24 ++ .../Configuration/WorldDefinition.cs | 26 ++ src/SharpMUTerm.Tui/AliasesScreenRenderer.cs | 5 +- src/SharpMUTerm.Tui/AliasesScreenView.cs | 2 +- src/SharpMUTerm.Tui/KeypadScreenRenderer.cs | 4 +- src/SharpMUTerm.Tui/KeypadScreenView.cs | 2 +- src/SharpMUTerm.Tui/OptionsScreenRenderer.cs | 4 +- src/SharpMUTerm.Tui/OptionsScreenView.cs | 2 +- src/SharpMUTerm.Tui/ScreenChrome.cs | 44 ++- src/SharpMUTerm.Tui/ScreenColours.cs | 116 ++++++ src/SharpMUTerm.Tui/ScreenEdits.cs | 18 + src/SharpMUTerm.Tui/ScreenField.cs | 37 +- src/SharpMUTerm.Tui/ScreenModel.cs | 126 ++++++- src/SharpMUTerm.Tui/ScreenSelection.cs | 63 ++++ src/SharpMUTerm.Tui/SettingsSession.cs | 48 ++- src/SharpMUTerm.Tui/SharpMUTermApp.cs | 26 +- src/SharpMUTerm.Tui/TimersScreenRenderer.cs | 5 +- src/SharpMUTerm.Tui/TimersScreenView.cs | 2 +- src/SharpMUTerm.Tui/TriggersScreenRenderer.cs | 175 ++++++--- src/SharpMUTerm.Tui/TriggersScreenView.cs | 4 +- src/SharpMUTerm.Tui/WorldsScreenRenderer.cs | 237 +++++++++++- src/SharpMUTerm.Tui/WorldsScreenView.cs | 6 +- .../Configuration/DefinitionCloneTests.cs | 117 ++++++ .../ScreenButtonTests.cs | 352 ++++++++++++++++++ .../ScreenFooterTests.cs | 164 ++++++++ .../SharpMUTerm.Tui.Tests/ScreenModelTests.cs | 10 +- .../TriggersScreenEditingTests.cs | 259 +++++++++++++ 30 files changed, 1857 insertions(+), 125 deletions(-) create mode 100644 src/SharpMUTerm.Tui/ScreenColours.cs create mode 100644 tests/SharpMUTerm.Core.Tests/Configuration/DefinitionCloneTests.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/ScreenButtonTests.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/ScreenFooterTests.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs diff --git a/CLAUDE.md b/CLAUDE.md index f40bf4e8..ba385f5a 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -32,7 +32,8 @@ fallbacks) for inline images/maps. ## Repository state **M1 delivered, plus substantial M2–M4 work.** `SharpMUTerm.slnx` builds all ten projects on -`net10.0`; the solution has **811 passing tests**. In place: +`net10.0`; the solution has **844 tests** (842 passing — see `docs/HANDOFF.md` +backlog item 1 for the two that are failing on purpose). In place: - **Core** — `AnsiParser` (SGR 16/256/truecolor), styled-line + `ScrollbackBuffer` model, `TcpTransport` (TLS + IPv6), `TelnetSession` (wraps TelnetNegotiationCore **2.5.3**), diff --git a/docs/HANDOFF.md b/docs/HANDOFF.md index 998d4cf6..bb1183f3 100644 --- a/docs/HANDOFF.md +++ b/docs/HANDOFF.md @@ -4,8 +4,9 @@ Context for whoever (human or agent) picks up this work next. - **Repository:** `SharpMUSH/SharpMUTerm` - **Start from:** a fresh branch off `main` -- **Tests:** 811 across the solution (327 Core / 83 Graphics / 42 Scripting / - 28 Web / 331 Tui), all green; `dotnet build SharpMUTerm.slnx` clean (0 warnings +- **Tests:** 844 across the solution (330 Core / 83 Graphics / 42 Scripting / + 28 Web / 361 Tui). **Two fail on purpose** — see backlog item 1; they are the + pinned row counts the F5 button rows change, left for a human to renumber; `dotnet build SharpMUTerm.slnx` clean (0 warnings from this repo; building against a local SharpConsoleUI clone surfaces 2 upstream NuGet advisory warnings for AngleSharp, which are the framework's, not ours) @@ -18,28 +19,37 @@ polish/feature backlog. ### 1. Field editing on the config screens -**Text/number/enum editing is done** — see *Settings screens* under Critical -Gotchas for how it works. What is left of this item: - -- **Add/remove rows.** `[+ world]` / `[- del]` (`WorldsScreenRenderer.cs`) and - `[+ add character]` / `[⧉ duplicate]` / `[- remove]` are painted but inert. - ⏎ is already the "activate the focused row" key, so a button row is a - `ScreenRow` with an action rather than a field — that is the natural shape. -- **F2's route-to radio list and highlight-colour picker** - (`TriggersScreenRenderer.cs`). Both are read-only indicators today; the - highlight row deliberately never takes the cursor, because there is nothing to - turn a colour on with yet. -- **Rows still not editable** (deliberately, this pass): a macro's *key* - (rebinding needs a key-capture mode, not a text buffer), a character's - password (it is `[JsonIgnore]` and belongs in a credential store), a world's - TLS/certificate "security" line (two booleans, so checkboxes, not a field), - and everything derived (the numpad grid, the session/state readouts). +**Done**, apart from one decision that needs a human — see *Settings screens* +under Critical Gotchas for how the whole thing works. + +- **Add/remove rows** are live. `[+ world]` / `[- del]` and `[+ add character]` / + `[⧉ duplicate]` / `[- remove]` are `ScreenRow`s carrying a `ScreenButton`; ⏎ + runs one. **BLOCKED ON A DECISION:** giving the two F5 list panes button rows + necessarily changes two pinned row-count assertions in `ScreenModelTests` — + `Worlds_HasWorldsThenCharactersThenTriggerSets` (`{2,2,1}` → `{4,5,1}`) and + `Worlds_CharacterAndTriggerSetPanesAreEmptyForAWorldWithNoCharacters` + (`{2,0,0}` → `{4,1,0}`). Those two assertions are **deliberately left failing** + rather than quietly renumbered; update them (or reject the shape) and the item + closes. +- **F2's route-to radios and highlight-colour picker** are live, as `Choice` and + `Colour` fields on the *rule's own list row* (ordinals: pattern, route, + highlight fg, highlight bg). ↑↓ cycle them, which is exactly radio and palette + semantics, and the editor pane keeps the two checkbox rows it always had. +- **Rows still not editable** (deliberately): a macro's *key* (rebinding needs a + key-capture mode, not a text buffer), a character's password (it is + `[JsonIgnore]` and belongs in a credential store), a world's TLS/certificate + "security" line (two booleans, so checkboxes, not a field), and everything + derived (the numpad grid, the session/state readouts). ### 2. Real-terminal verification still owed All three are covered by headless snapshots only. Nobody has looked at them in a real terminal. +- **The F5 button rows** — `End` is what reaches a pane's buttons without + dragging the selection to the end of its list, and nothing on screen says so. + Watch someone try to delete a world and see whether they find it; if not, the + fix is a hint or a `Delete`-on-the-row binding, not a bigger button. - **Full-width input band** — confirm it holds across resizes. The width is pinned imperatively (`SyncInputWidth`), so a resize is the risky case. - **Mouse drag-to-split** — nobody has done it with an actual mouse. What is @@ -269,8 +279,26 @@ What the framework actually provides (read at v2.5.14, not assumed): piece: on `Redraw` it does `ClearControls()` + `AddControl(factory())` + `Invalidate(true)`). - **A row is a `ScreenRow`**: an optional `ScreenToggle` (Space) plus an ordered - list of `ScreenField`s (⏎ opens the first, ⇥ steps to the next). A row can be - both — a keypad binding is Space-enables + ⏎-edits-the-command. + list of `ScreenField`s (⏎ opens the first, ⇥ steps to the next), *or* a + `ScreenButton` (⏎ runs it). A row can be both a toggle and fields — a keypad + binding is Space-enables + ⏎-edits-the-command. +- **A `ScreenButton` returns its own undo**, rather than being snapshotted before + it runs the way a toggle or a field is: the undo for an insertion is "remove + the thing that was added", which cannot be described until it exists. A removal + captures the item *and its index*, so Esc puts a deleted world back where it + was — the list's order is what the screen navigates by, and restoring it onto + the end would be a second, invisible edit. Deletion is undo-only, with no + confirmation prompt: nothing reaches disk until Save, and a second modal state + inside a screen that already has one (an open field edit) would double the + key-routing rules for a change that is already reversible. +- **Buttons come after a pane's list, so the cursor can point past it.** + `ScreenModel.ListSizes` says how many rows of each pane are list rows; + `ScreenSelection` anchors the *selection* on those, so moving onto `[+ world]` + leaves the detail column (and `[- del]`) pointed where it was. Screens must + read `SelectionIn(pane)`, **not** `CursorIn(pane)`, for "what is selected". + **End** jumps to a pane's last row without re-anchoring, which is the only way + to reach a button without walking the selection down the whole list; the + targeted buttons also name their victim (`[- del] Grapevine`). - **Fields hang off existing rows, never off new ones.** A world's name/host/port/ encoding/keepalive are the *WORLDS-list row's* fields, drawn in the detail column; a timer's interval/command are the *timer row's*, drawn in the editor @@ -289,7 +317,19 @@ What the framework actually provides (read at v2.5.14, not assumed): - **Header hints are derived, not written.** `HeaderLine(width, model, focus)` reads `model.HasEditableRow`, so a screen physically cannot advertise `⏎ edit` without offering one; `ScreenCursorTests` asserts the *if and only if* both ways. + A button row deliberately doesn't count as editable — ⏎ activates it, but it + edits nothing. `↑↓ choose` appears only for a field that has `Choices`. +- **Footer actions are derived too.** `ScreenChrome.Actions(accent, focus)` swaps + `[Esc] Cancel` / `[⏎] Save` for `[Esc] Revert` / `[⏎] Commit` while a field is + open, because neither key closes the screen at that moment. Every `FooterLine` + takes the focus for this; `ScreenFooterTests` pins it for all six screens in + both directions, and asserts the header and the footer can't disagree. While an edit is open the hints swap wholesale, because Esc no longer closes. +- **The F2 colour picker is a palette, not an RGB picker.** `ScreenColours` holds + the names ↑↓ steps through, but `ScreenField.Colour` also accepts `#rrggbb`, + `idx:N` and `none` typed in full — a `TerminalColor` already in config may be a + colour no short palette names, and a picker that refused the value it was + showing would make an existing highlight uneditable. - **Making a Core property settable? Check for cached derived state.** `Trigger.Pattern` and `Alias.Pattern` drop their compiled `Regex` on write, like `Alias.CaseSensitive` already did — otherwise the rule goes on matching the diff --git a/src/SharpMUTerm.Core/Automation/Trigger.cs b/src/SharpMUTerm.Core/Automation/Trigger.cs index 761a00da..f3ba0b5a 100644 --- a/src/SharpMUTerm.Core/Automation/Trigger.cs +++ b/src/SharpMUTerm.Core/Automation/Trigger.cs @@ -10,11 +10,15 @@ public sealed class TriggerActions /// Suppress the line from output entirely. Settable so the F2 screen can flip it live. public bool Gag { get; set; } - /// Recolour the matched region's foreground. - public TerminalColor? HighlightForeground { get; init; } + /// + /// Recolour the matched region's foreground. Settable so the F2 screen's colour picker can change + /// it live; nothing is derived from it, so there is no cache to drop the way + /// has. + /// + public TerminalColor? HighlightForeground { get; set; } - /// Recolour the matched region's background. - public TerminalColor? HighlightBackground { get; init; } + /// Recolour the matched region's background. Settable for the same reason as its foreground. + public TerminalColor? HighlightBackground { get; set; } /// Add these attributes to the matched region (e.g. bold). public TextAttributes AddAttributes { get; init; } = TextAttributes.None; @@ -28,8 +32,13 @@ public sealed class TriggerActions /// Send this command back to the server (capture references supported). public string? SendResponse { get; init; } - /// Route the line to a named spawn window instead of the main output. - public string? SpawnTarget { get; init; } + /// + /// Route the line to a named spawn window instead of the main output; null routes to the main + /// window. Settable so the F2 screen's route-to list can re-point a rule live — the engine reads + /// it per match and keeps no routing table of its own, so a change + /// applies to the next line. + /// + public string? SpawnTarget { get; set; } /// Invoke this named script callback (resolved by the scripting layer). public string? ScriptCallback { get; init; } diff --git a/src/SharpMUTerm.Core/Configuration/CharacterDefinition.cs b/src/SharpMUTerm.Core/Configuration/CharacterDefinition.cs index 7c00b736..acb5ce10 100644 --- a/src/SharpMUTerm.Core/Configuration/CharacterDefinition.cs +++ b/src/SharpMUTerm.Core/Configuration/CharacterDefinition.cs @@ -39,6 +39,30 @@ public sealed class CharacterDefinition /// Logging is configured per character. public LoggingSettings Logging { get; set; } = new(); + /// + /// A deep copy of this character — every mutable part copied, not shared. The F5 screen's + /// duplicate button is the caller: a copy that aliased or + /// would look right on screen and then follow every later edit of the + /// original around, which is the sort of bug that only shows up once someone has re-pointed one + /// copy's log directory and lost the other's. + /// + /// is carried over deliberately: it is [JsonIgnore] session state, + /// and a duplicate of a logged-in character that silently forgot its password would be a worse + /// surprise than one that kept it. Nothing here reaches disk. + /// + /// + public CharacterDefinition Clone() => new() + { + Name = Name, + Password = Password, + ConnectString = ConnectString, + AutoLogin = AutoLogin, + OnConnect = OnConnect, + OnDisconnect = OnDisconnect, + TriggerSets = new List(TriggerSets), + Logging = new LoggingSettings { Format = Logging.Format, Directory = Logging.Directory }, + }; + /// Builds the default login line when is unset. public string ResolveConnectString() => !string.IsNullOrWhiteSpace(ConnectString) diff --git a/src/SharpMUTerm.Core/Configuration/WorldDefinition.cs b/src/SharpMUTerm.Core/Configuration/WorldDefinition.cs index ce0d2250..5d948836 100644 --- a/src/SharpMUTerm.Core/Configuration/WorldDefinition.cs +++ b/src/SharpMUTerm.Core/Configuration/WorldDefinition.cs @@ -86,6 +86,32 @@ public sealed class WorldDefinition /// The characters that can connect to this world. public List Characters { get; set; } = new(); + /// + /// A deep copy of this world, characters and all. Same contract as + /// : nothing mutable is shared with the original, so a + /// duplicated world can be renamed and re-pointed without dragging its source along. + /// + public WorldDefinition Clone() => new() + { + Name = Name, + Host = Host, + Port = Port, + UseTls = UseTls, + AllowInvalidCertificates = AllowInvalidCertificates, + LocalEcho = LocalEcho, + Encoding = Encoding, + KeepaliveSeconds = KeepaliveSeconds, + ContentFormat = ContentFormat, + Emoji = new EmojiSettings + { + Enabled = Emoji.Enabled, + Emoticons = Emoji.Emoticons, + Shortcodes = Emoji.Shortcodes, + }, + Accent = Accent, + Characters = Characters.Select(c => c.Clone()).ToList(), + }; + /// Builds the transport-level options from this world. public ConnectionOptions ToConnectionOptions() => new() { diff --git a/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs b/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs index 67790f34..3e1833d7 100644 --- a/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs @@ -96,7 +96,8 @@ internal static ScreenModel Model(IReadOnlyList sets, int selected) } /// The action bar: which alias is selected on the left, cancel/save on the right. - internal static string FooterLine(IReadOnlyList sets, int selected, int width) + internal static string FooterLine( + IReadOnlyList sets, int selected, int width, ScreenFocus? focus = null) { var entries = Flatten(sets); var context = string.Empty; @@ -107,7 +108,7 @@ internal static string FooterLine(IReadOnlyList sets, int selected, + $"[{Label}] · set {Escape(entries[selected].SetName)}[/]"; } - var actions = ScreenChrome.Actions(); + var actions = ScreenChrome.Actions(focus: focus); return SpreadLR(" " + context, actions, width); } diff --git a/src/SharpMUTerm.Tui/AliasesScreenView.cs b/src/SharpMUTerm.Tui/AliasesScreenView.cs index b0832dfe..629e5f59 100644 --- a/src/SharpMUTerm.Tui/AliasesScreenView.cs +++ b/src/SharpMUTerm.Tui/AliasesScreenView.cs @@ -23,7 +23,7 @@ public static IWindowControl Build( var header = ScreenChrome.Band( AliasesScreenRenderer.HeaderLine(width, AliasesScreenRenderer.Model(sets, selected), focus), ScreenPalette.HeaderBg); - var footer = ScreenChrome.Band(AliasesScreenRenderer.FooterLine(sets, selected, width), ScreenPalette.FooterBg); + var footer = ScreenChrome.Band(AliasesScreenRenderer.FooterLine(sets, selected, width, focus), ScreenPalette.FooterBg); // Body: alias list │ editor, as two real columns. var listCol = ScreenChrome.Stretch( diff --git a/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs b/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs index db29cb6c..a9e7b9af 100644 --- a/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs @@ -89,7 +89,7 @@ internal static ScreenModel Model(IReadOnlyList macros) } /// The action bar: how much of the keypad is bound on the left, cancel/save on the right. - internal static string FooterLine(IReadOnlyList macros, int width) + internal static string FooterLine(IReadOnlyList macros, int width, ScreenFocus? focus = null) { ArgumentNullException.ThrowIfNull(macros); @@ -109,7 +109,7 @@ internal static string FooterLine(IReadOnlyList macros, int width) var context = $"[{Label}]{total} bindings[/]" + $"[{Label}] · {bound.ToString(CultureInfo.InvariantCulture)} of 9 numpad keys bound[/]"; - var actions = ScreenChrome.Actions(); + var actions = ScreenChrome.Actions(focus: focus); return SpreadLR(" " + context, actions, width); } diff --git a/src/SharpMUTerm.Tui/KeypadScreenView.cs b/src/SharpMUTerm.Tui/KeypadScreenView.cs index f73da1e7..17ea8b60 100644 --- a/src/SharpMUTerm.Tui/KeypadScreenView.cs +++ b/src/SharpMUTerm.Tui/KeypadScreenView.cs @@ -23,7 +23,7 @@ public static IWindowControl Build(IReadOnlyList macros, int width, Scree var header = ScreenChrome.Band( KeypadScreenRenderer.HeaderLine(width, KeypadScreenRenderer.Model(macros), focus), ScreenPalette.HeaderBg); - var footer = ScreenChrome.Band(KeypadScreenRenderer.FooterLine(macros, width), ScreenPalette.FooterBg); + var footer = ScreenChrome.Band(KeypadScreenRenderer.FooterLine(macros, width, focus), ScreenPalette.FooterBg); // Body: numpad grid │ hotkey list, as two real columns. var numpadCol = ScreenChrome.Stretch(new MarkupControl(KeypadScreenRenderer.NumpadColumn(macros))); diff --git a/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs b/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs index b279e92e..48d30753 100644 --- a/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs @@ -73,7 +73,7 @@ internal static string HeaderLine( } /// The action bar: how much the screen holds on the left, cancel/save on the right. - internal static string FooterLine(IReadOnlyList rows, int width) + internal static string FooterLine(IReadOnlyList rows, int width, ScreenFocus? focus = null) { ArgumentNullException.ThrowIfNull(rows); @@ -85,7 +85,7 @@ internal static string FooterLine(IReadOnlyList rows, int width) context += $"[{Label}] · {Plural(sections, "section")}[/]"; } - return SpreadLR(" " + context, ScreenChrome.Actions(), width); + return SpreadLR(" " + context, ScreenChrome.Actions(focus: focus), width); } /// diff --git a/src/SharpMUTerm.Tui/OptionsScreenView.cs b/src/SharpMUTerm.Tui/OptionsScreenView.cs index bacbcfda..3fa55a67 100644 --- a/src/SharpMUTerm.Tui/OptionsScreenView.cs +++ b/src/SharpMUTerm.Tui/OptionsScreenView.cs @@ -30,7 +30,7 @@ public static IWindowControl Build( screen.Title, screen.FKey, width, OptionsScreenRenderer.Model(screen), focus), ScreenPalette.HeaderBg); var footer = ScreenChrome.Band( - OptionsScreenRenderer.FooterLine(screen.Rows, width), ScreenPalette.FooterBg); + OptionsScreenRenderer.FooterLine(screen.Rows, width, focus), ScreenPalette.FooterBg); var rows = OptionsScreenRenderer.BodyColumn(screen.Rows, focus, Math.Max(0, width - CardInset)); var card = Card(rows); diff --git a/src/SharpMUTerm.Tui/ScreenChrome.cs b/src/SharpMUTerm.Tui/ScreenChrome.cs index f6123b3f..d5163036 100644 --- a/src/SharpMUTerm.Tui/ScreenChrome.cs +++ b/src/SharpMUTerm.Tui/ScreenChrome.cs @@ -27,7 +27,9 @@ internal static string Hints(string verbs, string fkey, bool editable = false, S { if (focus?.Edit is { } edit) { - var editing = edit.RowFields > 1 ? EditingHints + NextFieldHint : EditingHints; + var editing = EditingHints + + (edit.HasChoices ? ChoiceHint : string.Empty) + + (edit.RowFields > 1 ? NextFieldHint : string.Empty); return $"[{ScreenPalette.Label}]{editing} · [/][{ScreenPalette.Accent}]{fkey}[/]" + $"[{ScreenPalette.Label}] close [/]"; } @@ -57,13 +59,45 @@ internal static string Hints(string verbs, string fkey, bool editable = false, S /// Added to only when the row has another field to step to. internal const string NextFieldHint = " · ⇥ next field"; + /// + /// Added to only when the open field is one of a fixed set of values — + /// a route, an encoding, a highlight colour — because only those have anything for ↑↓ to step + /// through. A free-text field would be claiming a key that does nothing. + /// + internal const string ChoiceHint = " · ↑↓ choose"; + + /// What the footer's Esc chip does while the screen is navigating. + internal const string CancelAction = "[[Esc]] Cancel"; + + /// What the footer's ⏎ chip does while the screen is navigating. + internal const string SaveAction = "[[⏎]] Save"; + + /// What the footer's Esc chip does while a field edit is open. + internal const string RevertAction = "[[Esc]] Revert"; + + /// What the footer's ⏎ chip does while a field edit is open. + internal const string CommitAction = "[[⏎]] Commit"; + /// /// The right-hand actions of a footer bar. lets a screen with a - /// context colour (F5's per-world accent) tint the Save chip; it defaults to the app accent. + /// context colour (F5's per-world accent) tint the ⏎ chip; it defaults to the app accent. + /// + /// is read for the same reason reads it: while a + /// field edit is open, ⏎ commits that field and Esc abandons its buffer — neither closes the + /// screen — so an action bar still offering Save and Cancel names two keys that do + /// something else at that moment. The footer is the more visible of the two claims, so it has to + /// change with the header rather than being left behind. + /// /// - internal static string Actions(string? accent = null) => - $"[{ScreenPalette.Label}] [[Esc]] Cancel [/] " - + $"[{ScreenPalette.Ink} on {accent ?? ScreenPalette.Accent}] [[⏎]] Save [/] "; + internal static string Actions(string? accent = null, ScreenFocus? focus = null) + { + var editing = focus?.Edit is not null; + var escape = editing ? RevertAction : CancelAction; + var enter = editing ? CommitAction : SaveAction; + + return $"[{ScreenPalette.Label}] {escape} [/] " + + $"[{ScreenPalette.Ink} on {accent ?? ScreenPalette.Accent}] {enter} [/] "; + } /// /// Draws a row as the keyboard cursor: the row's own markup on a cursor band padded out to diff --git a/src/SharpMUTerm.Tui/ScreenColours.cs b/src/SharpMUTerm.Tui/ScreenColours.cs new file mode 100644 index 00000000..9e632052 --- /dev/null +++ b/src/SharpMUTerm.Tui/ScreenColours.cs @@ -0,0 +1,116 @@ +using SharpMUTerm.Core.Text; + +namespace SharpMUTerm.Tui; + +/// +/// The colour vocabulary the settings screens edit in: a short palette of named colours the choice +/// machinery can step through with ↑↓, plus the round trip between a and +/// the text a field shows for it. +/// +/// The palette is deliberately small. spans the terminal default, 256 +/// palette indices, and all 24 bits of RGB, and a picker for that is a screen of its own; a highlight +/// colour is picked once and then lived with, so the proportionate affordance is a handful of legible +/// choices one keypress apart. Nothing is *lost* by that: also accepts +/// #rrggbb and idx:N typed in full, and renders a colour the +/// palette doesn't name in the same syntax — so a config holding an arbitrary colour opens showing +/// that colour, and committing it unchanged writes it back unchanged. +/// +/// +internal static class ScreenColours +{ + /// The name for "no colour at all" — the null a highlight is unset with. + internal const string None = "none"; + + /// The name for the terminal's own default colour. + internal const string DefaultName = "default"; + + /// + /// The named choices ↑↓ steps through, in the order they cycle: "no colour" first, then a spread + /// wide enough to tell two highlights apart at a glance. Every name resolves through + /// , so the picker and MXP/Pueblo markup agree on what "gold" means. + /// + internal static readonly IReadOnlyList Palette = new[] + { + None, "red", "orange", "gold", "yellow", "lime", "green", "cyan", "teal", + "blue", "magenta", "purple", "pink", "white", "silver", "grey", "black", + }; + + /// + /// The text a field shows for a colour: the palette name when one matches exactly, else the + /// literal syntax reads back. Null — an unset highlight — is + /// . + /// + internal static string Format(TerminalColor? colour) + { + if (colour is not { } value) + { + return None; + } + + foreach (var name in Palette) + { + if (name != None && WebColors.TryParse(name, out var named) && named == value) + { + return name; + } + } + + return value.Kind switch + { + TerminalColorKind.Rgb => $"#{value.R:x2}{value.G:x2}{value.B:x2}", + TerminalColorKind.Indexed => $"idx:{value.Index}", + _ => DefaultName, + }; + } + + /// + /// Reads a typed colour. Returns false when the text names nothing — the field's validator, so a + /// misspelling is refused at commit rather than silently becoming "no highlight". + /// is null for , which is a legal value. + /// + internal static bool TryParse(string text, out TerminalColor? colour) + { + ArgumentNullException.ThrowIfNull(text); + + colour = null; + var trimmed = text.Trim(); + if (trimmed.Length == 0 || trimmed.Equals(None, StringComparison.OrdinalIgnoreCase)) + { + return true; + } + + if (trimmed.Equals(DefaultName, StringComparison.OrdinalIgnoreCase)) + { + colour = TerminalColor.Default; + return true; + } + + if (trimmed.StartsWith("idx:", StringComparison.OrdinalIgnoreCase) + && int.TryParse(trimmed.AsSpan(4), out var index) + && index is >= 0 and <= 255) + { + colour = TerminalColor.FromIndex(index); + return true; + } + + if (WebColors.TryParse(trimmed, out var parsed)) + { + colour = parsed; + return true; + } + + return false; + } + + /// + /// The markup hex a swatch is painted with. Indexed colours resolve through the xterm palette + /// rather than falling back to the accent, so a swatch shows the colour the terminal will + /// actually use; only the terminal *default* has no hex of its own. + /// + internal static string Hex(TerminalColor colour, string fallback) => colour.Kind switch + { + TerminalColorKind.Rgb => $"#{colour.R:x2}{colour.G:x2}{colour.B:x2}", + TerminalColorKind.Indexed => AnsiPalette.ToRgb(colour.Index).ToHex(), + _ => fallback, + }; +} diff --git a/src/SharpMUTerm.Tui/ScreenEdits.cs b/src/SharpMUTerm.Tui/ScreenEdits.cs index 127fcbce..ec82146e 100644 --- a/src/SharpMUTerm.Tui/ScreenEdits.cs +++ b/src/SharpMUTerm.Tui/ScreenEdits.cs @@ -46,6 +46,24 @@ internal void Apply(ScreenToggle toggle) return null; } + /// + /// Runs a button, recording the undo it hands back — the same entry a toggle or a committed field + /// pushes, so Esc unmakes a deleted world exactly as it unmakes a typed host. Returns where the + /// button wants the cursor left, or null when it doesn't care. + /// + /// A structural change is recorded *after* the fact rather than snapshotted before it, because + /// only the button knows what it did — see . Adding and removing rows + /// is why the undo log replays newest-first: an index captured by a removal is only meaningful + /// against the list as it stood at that moment. + /// + /// + internal int? Apply(ScreenButton button) + { + var press = button.Run(); + _undo.Add(press.Undo); + return press.Select; + } + /// Undoes every pending change, newest first, so overlapping edits unwind correctly. internal void Revert() { diff --git a/src/SharpMUTerm.Tui/ScreenField.cs b/src/SharpMUTerm.Tui/ScreenField.cs index 1e66c0e5..2b181807 100644 --- a/src/SharpMUTerm.Tui/ScreenField.cs +++ b/src/SharpMUTerm.Tui/ScreenField.cs @@ -1,5 +1,6 @@ using System.Globalization; using System.Text.RegularExpressions; +using SharpMUTerm.Core.Text; namespace SharpMUTerm.Tui; @@ -17,8 +18,12 @@ namespace SharpMUTerm.Tui; /// /// How many fields the row holds — the chrome only offers ⇥ when there is a next field to step to. /// +/// +/// Whether the open field offers a fixed set of values, so the chrome only offers ↑↓ when there is +/// something for them to step through. +/// internal readonly record struct ScreenFieldEdit( - int Field, string Text, int Caret, string? Error, int RowFields = 1); + int Field, string Text, int Caret, string? Error, int RowFields = 1, bool HasChoices = false); /// /// An editable value on a settings row: how to read it as text, whether a typed string is a legal @@ -195,6 +200,36 @@ internal static ScreenField Choice( choices); } + /// + /// A colour, or no colour at all. is what ↑↓ steps through, + /// but the validator is deliberately wider than the palette: #rrggbb and idx:N are + /// accepted too, because a already in config may + /// be a colour no short palette names, and opening the field on a value it would then refuse to + /// commit would make an existing highlight uneditable. + /// + internal static ScreenField Colour( + string label, Func get, Action set) + { + ArgumentNullException.ThrowIfNull(get); + ArgumentNullException.ThrowIfNull(set); + + return new ScreenField( + label, + () => ScreenColours.Format(get()), + value => ScreenColours.TryParse(value, out _) + ? null + : $"{label} must be a colour name, #rrggbb, idx:N or none", + value => + { + if (ScreenColours.TryParse(value, out var parsed)) + { + set(parsed); + } + }, + Restore(get, set), + ScreenColours.Palette); + } + /// An enum value, typed or cycled by name — F9's log format is the canonical case. internal static ScreenField Enumeration(string label, Func get, Action set) where TEnum : struct, Enum diff --git a/src/SharpMUTerm.Tui/ScreenModel.cs b/src/SharpMUTerm.Tui/ScreenModel.cs index a0e24fca..aabed984 100644 --- a/src/SharpMUTerm.Tui/ScreenModel.cs +++ b/src/SharpMUTerm.Tui/ScreenModel.cs @@ -29,10 +29,79 @@ internal static ScreenToggle Bind(Func get, Action set) } } +/// +/// What running a button left behind: how to undo it, and where the cursor should be afterwards. +/// +/// Puts the list back exactly as it was, position included. +/// +/// The row of the button's own pane the cursor should move to — the row just added, so a new world +/// opens ready to be named. Null leaves the cursor where it was. +/// +internal readonly record struct ScreenPress(Action Undo, int? Select = null); + +/// +/// A button row on a settings screen: [+ world], [⧉ duplicate], [- remove]. ⏎ is +/// already "activate the focused row", so a button is a row whose activation runs a command instead of +/// opening an editor. +/// +/// performs the change and *returns* how to undo it, rather than being handed a +/// snapshot taken beforehand the way and are. +/// That is forced by what these buttons do: the undo for an insertion is "remove the thing that was +/// added", which cannot be described until it has been added. Doing it this way also lets a removal +/// capture the item *and its index*, so Esc puts a deleted world back where it was in the list rather +/// than on the end — the list's order is what the screen navigates by, and silently reordering it +/// would be a second, invisible edit. +/// +/// +/// What the button is called, for the row the renderer draws. +/// Performs the change and returns the undo plus where to leave the cursor. +internal readonly record struct ScreenButton(string Label, Func Run) +{ + /// + /// Appends a new item and leaves the cursor on it — a new row is worth nothing if the next + /// keystroke has to go and find it. + /// + internal static ScreenButton Add(string label, IList list, Func create) + { + ArgumentNullException.ThrowIfNull(list); + ArgumentNullException.ThrowIfNull(create); + + return new ScreenButton(label, () => + { + list.Add(create()); + var at = list.Count - 1; + return new ScreenPress(() => list.RemoveAt(at), at); + }); + } + + /// + /// Removes the item at , restoring it *at that index* on undo. The cursor + /// stays on the same ordinal, which is now whatever followed the deleted row — the same place the + /// eye is. + /// + internal static ScreenButton Remove(string label, IList list, int index) + { + ArgumentNullException.ThrowIfNull(list); + + return new ScreenButton(label, () => + { + if (index < 0 || index >= list.Count) + { + return new ScreenPress(() => { }); + } + + var removed = list[index]; + list.RemoveAt(index); + return new ScreenPress(() => list.Insert(index, removed), index); + }); + } +} + /// /// One row of a settings screen's navigable shape. A row is a plain stop (neither a checkbox nor -/// anything to type into), a checkbox, a row of editable fields, or both at once — the keypad's -/// bindings are the last case, where Space enables the macro and ⏎ edits the command it sends. +/// anything to type into), a checkbox, a row of editable fields, a button, or both a checkbox and +/// fields at once — the keypad's bindings are the last case, where Space enables the macro and ⏎ edits +/// the command it sends. /// /// Fields are an ordered list rather than a single value because a row is a *record*, not a cell: one /// world row carries its name, host, port, encoding, and keepalive. ⏎ opens the first, ⇥ steps to the @@ -43,7 +112,11 @@ internal static ScreenToggle Bind(Func get, Action set) /// /// The checkbox Space flips, or null when the row has none. /// The values ⏎ opens for editing, in the order the screen draws them. -internal readonly record struct ScreenRow(ScreenToggle? Toggle = null, IReadOnlyList? Fields = null) +/// The command ⏎ runs, or null when the row is not a button. +internal readonly record struct ScreenRow( + ScreenToggle? Toggle = null, + IReadOnlyList? Fields = null, + ScreenButton? Button = null) { /// A selectable row with nothing to press and nothing to type into. internal static ScreenRow Stop => default; @@ -57,11 +130,17 @@ internal readonly record struct ScreenRow(ScreenToggle? Toggle = null, IReadOnly /// A row that is both — Space flips the checkbox, ⏎ opens the first field. internal static ScreenRow Of(ScreenToggle toggle, params ScreenField[] fields) => new(toggle, fields); + /// A row that is a button — ⏎ runs it, and there is nothing to type into. + internal static ScreenRow Of(ScreenButton button) => new(null, null, button); + /// How many values ⏎/⇥ can step through on this row. internal int FieldCount => Fields?.Count ?? 0; - /// Whether ⏎ has something to open here; a row without fields lets ⏎ save instead. - internal bool IsActivatable => FieldCount > 0; + /// + /// Whether ⏎ has something to do here; a row that is neither a button nor a record of fields lets + /// ⏎ save instead. + /// + internal bool IsActivatable => FieldCount > 0 || Button is not null; /// The row's field at an ordinal, or null when it has none there. internal ScreenField? FieldAt(int field) => @@ -88,6 +167,34 @@ internal ScreenModel(params IReadOnlyList[] panes) /// Row counts per pane, in pane order — what navigates by. internal IReadOnlyList Sizes { get; } + /// + /// How many rows of each pane are *list* rows rather than the buttons appended after them. A pane + /// is a list followed by its own buttons, and the two mean different things to the cursor: moving + /// onto [[+ world]] must not change which world is selected, or [[- del]] could only + /// ever delete the last one — you would have to walk past every other world to reach the button. + /// anchors the selection with this. + /// + internal IReadOnlyList ListSizes + { + get + { + var sizes = new int[_panes.Length]; + for (var pane = 0; pane < _panes.Length; pane++) + { + var rows = _panes[pane]; + var count = rows.Count; + while (count > 0 && rows[count - 1].Button is not null) + { + count--; + } + + sizes[pane] = count; + } + + return sizes; + } + } + /// How many panes the screen offers ⇥ between. internal int PaneCount => _panes.Length; @@ -95,6 +202,10 @@ internal ScreenModel(params IReadOnlyList[] panes) /// Whether anything on this screen can be edited. The header hints are derived from this rather /// than written per screen, so a screen physically cannot advertise ⏎ edit without offering /// a row that ⏎ opens. + /// + /// A button row is deliberately not counted. ⏎ activates it, but it doesn't *edit* anything, and a + /// screen whose only ⏎ target were a button would be advertising an editor it hasn't got. + /// /// internal bool HasEditableRow { @@ -104,7 +215,7 @@ internal bool HasEditableRow { foreach (var row in pane) { - if (row.IsActivatable) + if (row.FieldCount > 0) { return true; } @@ -124,6 +235,9 @@ internal ScreenRow RowAt(int pane, int index) => /// The checkbox at a cursor position, or null when that row isn't pressable. internal ScreenToggle? ToggleAt(int pane, int index) => RowAt(pane, index).Toggle; + /// The button at a cursor position, or null when that row isn't one. + internal ScreenButton? ButtonAt(int pane, int index) => RowAt(pane, index).Button; + /// The editable value at a cursor position and field ordinal, or null when there is none. internal ScreenField? FieldAt(int pane, int index, int field) => RowAt(pane, index).FieldAt(field); diff --git a/src/SharpMUTerm.Tui/ScreenSelection.cs b/src/SharpMUTerm.Tui/ScreenSelection.cs index e9f51d52..49210a48 100644 --- a/src/SharpMUTerm.Tui/ScreenSelection.cs +++ b/src/SharpMUTerm.Tui/ScreenSelection.cs @@ -10,12 +10,14 @@ namespace SharpMUTerm.Tui; internal sealed class ScreenSelection { private readonly int[] _cursors; + private readonly int[] _anchors; /// Creates a selection over panes, focused on the first. internal ScreenSelection(int paneCount) { ArgumentOutOfRangeException.ThrowIfLessThan(paneCount, 1); _cursors = new int[paneCount]; + _anchors = new int[paneCount]; } /// How many panes the screen has. @@ -31,6 +33,37 @@ internal ScreenSelection(int paneCount) internal int CursorIn(int pane) => pane >= 0 && pane < _cursors.Length ? _cursors[pane] : -1; + /// + /// Which of a pane's *list* rows is selected — the same thing as the cursor while the cursor is on + /// one, and the last such row once it has moved on to the pane's buttons. That is what keeps + /// [[- del]] pointed at the world the screen is showing instead of at whichever one happens + /// to be last: the cursor has to leave the list to reach the button, and the selection must not + /// leave with it. + /// + internal int SelectionIn(int pane) => + pane >= 0 && pane < _anchors.Length ? _anchors[pane] : -1; + + /// + /// Re-reads the selection from the cursors, given how many rows of each pane are list rows rather + /// than buttons. A cursor on a list row *is* the selection; a cursor on a button leaves it where it + /// was, clamped in case the button it just ran shortened the list underneath it. + /// + internal void Anchor(IReadOnlyList listSizes) + { + ArgumentNullException.ThrowIfNull(listSizes); + + for (var pane = 0; pane < _anchors.Length; pane++) + { + var size = SizeOf(pane, listSizes); + if (_cursors[pane] < size) + { + _anchors[pane] = _cursors[pane]; + } + + _anchors[pane] = size == 0 ? 0 : Math.Clamp(_anchors[pane], 0, size - 1); + } + } + /// /// Seeds a pane's cursor without moving focus — used when a screen opens on state the app already /// tracks (F5 opens on the connected world and character). Negative indices are ignored. @@ -40,6 +73,7 @@ internal void Seed(int pane, int index) if (pane >= 0 && pane < _cursors.Length && index >= 0) { _cursors[pane] = index; + _anchors[pane] = index; } } @@ -69,6 +103,35 @@ internal bool Move(int delta, IReadOnlyList paneSizes) return true; } + /// + /// Jumps the focused pane's cursor to a row, clamped to the pane's current size — + /// is End, 0 is Home. It exists for the button rows a list pane ends in: + /// they can only be reached by ↑↓ after walking past every row of the list, which would drag the + /// selection to the last one and leave [[- del]] pointed at something the user never chose. + /// End steps over the list without touching the selection, because a cursor on a button doesn't + /// re-anchor. Returns whether the cursor actually moved. + /// + internal bool MoveTo(int index, IReadOnlyList paneSizes) + { + ArgumentNullException.ThrowIfNull(paneSizes); + + Clamp(paneSizes); + var size = SizeOf(Pane, paneSizes); + if (size == 0) + { + return false; + } + + var next = Math.Clamp(index, 0, size - 1); + if (next == _cursors[Pane]) + { + return false; + } + + _cursors[Pane] = next; + return true; + } + /// /// Moves focus to the next pane that has rows, wrapping past the last. Empty panes are skipped so /// ⇥ never lands somewhere with no cursor (a world with no characters, an editor with no diff --git a/src/SharpMUTerm.Tui/SettingsSession.cs b/src/SharpMUTerm.Tui/SettingsSession.cs index a38de847..0191f463 100644 --- a/src/SharpMUTerm.Tui/SettingsSession.cs +++ b/src/SharpMUTerm.Tui/SettingsSession.cs @@ -33,8 +33,10 @@ internal enum ScreenAction /// field it is typing into out of each fresh model. /// /// -/// The keys, in one place: ⏎ activates the focused row when it has something to activate (a field → -/// open an edit) and otherwise saves and closes; ⌃S saves from anywhere; Esc cancels the screen, +/// The keys, in one place: ↑↓ move a row and Home/End jump to a pane's first and last — End is how a +/// pane's trailing buttons are reached without walking the selection to the end of its list; ⏎ +/// activates the focused row when it has something to activate (a field → open an edit, a button → +/// run it) and otherwise saves and closes; ⌃S saves from anywhere; Esc cancels the screen, /// except while an edit is open, where it abandons the edit and leaves the screen up. Inside an edit, /// typing inserts, Backspace/Delete remove, ←→/Home/End move the caret, ↑↓ cycle an enum field's /// choices, ⇥ commits and steps to the row's next field, ⏎ commits, and Esc reverts. @@ -77,6 +79,7 @@ internal ScreenFocus Focus() { var model = _model(Selection); Selection.Clamp(model.Sizes); + Selection.Anchor(model.ListSizes); if (!Selection.HasSelection(model.Sizes)) { return ScreenFocus.None; @@ -88,7 +91,8 @@ internal ScreenFocus Focus() open.Text, open.Caret, open.Error, - model.RowAt(open.Pane, open.Index).FieldCount) + model.RowAt(open.Pane, open.Index).FieldCount, + model.FieldAt(open.Pane, open.Index, open.Field)?.Choices is { Count: > 0 }) : (ScreenFieldEdit?)null; return new ScreenFocus(Selection.Pane, Selection.Index, edit); @@ -101,9 +105,20 @@ internal ScreenFocus Focus() /// belongs to the buffer instead; see the type summary. Anything else is not ours. /// internal ScreenAction Handle(ConsoleKeyInfo key) + { + var action = Interpret(key); + + // Re-anchored *after* the key, because a key is exactly what moves the cursor between a pane's + // list and its buttons — and the screen is rebuilt from the anchor on the very next frame. + Selection.Anchor(_model(Selection).ListSizes); + return action; + } + + private ScreenAction Interpret(ConsoleKeyInfo key) { var model = _model(Selection); Selection.Clamp(model.Sizes); + Selection.Anchor(model.ListSizes); if (_edit is not null) { @@ -132,6 +147,12 @@ internal ScreenAction Handle(ConsoleKeyInfo key) ? Selection.PreviousPane(model.Sizes) : Selection.NextPane(model.Sizes)); + case ConsoleKey.Home: + return Changed(Selection.MoveTo(0, model.Sizes)); + + case ConsoleKey.End: + return Changed(Selection.MoveTo(int.MaxValue, model.Sizes)); + case ConsoleKey.Spacebar: return Toggle(model); @@ -152,12 +173,27 @@ private ScreenAction Toggle(ScreenModel model) } /// - /// ⏎ on a row that has something to open. A row with no field is not activatable, and ⏎ keeps its - /// old meaning there — the footer's [[⏎]] Save. + /// ⏎ on a row that has something to activate: a button runs, a record of fields opens its first. + /// A row that is neither is not activatable, and ⏎ keeps its old meaning there — the footer's + /// [[⏎]] Save. /// private ScreenAction Activate(ScreenModel model) { - if (!model.RowAt(Selection.Pane, Selection.Index).IsActivatable) + var row = model.RowAt(Selection.Pane, Selection.Index); + if (row.Button is { } button) + { + // The button rewrites the very list the cursor navigates, so where the cursor lands is the + // button's own answer (a new row wants the cursor on it, ready to be named) rather than a + // rule this method could guess. The next Focus()/Handle() re-projects and clamps it. + if (Edits.Apply(button) is { } select) + { + Selection.Seed(Selection.Pane, select); + } + + return ScreenAction.Redraw; + } + + if (!row.IsActivatable) { return ScreenAction.Save; } diff --git a/src/SharpMUTerm.Tui/SharpMUTermApp.cs b/src/SharpMUTerm.Tui/SharpMUTermApp.cs index c27271a8..b1d1049b 100644 --- a/src/SharpMUTerm.Tui/SharpMUTermApp.cs +++ b/src/SharpMUTerm.Tui/SharpMUTermApp.cs @@ -968,16 +968,19 @@ private LoggingSettings ActiveLogging() /// private ScreenBinding WorldsScreen() { + // SelectionIn, not CursorIn: both panes end in their own buttons, and the cursor has to leave + // the list to press one. The *selection* is what the detail column and the delete buttons are + // about, and it stays on the row the user was looking at. var session = new SettingsSession(selection => WorldsScreenRenderer.Model( - _config.Worlds, _config.TriggerSets, selection.CursorIn(0), selection.CursorIn(1))); + _config.Worlds, _config.TriggerSets, selection.SelectionIn(0), selection.SelectionIn(1))); session.Selection.Seed(0, ActiveWorldIndex()); session.Selection.Seed(1, ActiveCharacterIndex()); return new ScreenBinding(session, () => WorldsScreenView.Build( _config.Worlds, _config.TriggerSets, - session.Selection.CursorIn(0), - session.Selection.CursorIn(1), + session.Selection.SelectionIn(0), + session.Selection.SelectionIn(1), _system.DesktopDimensions.Width, session.Focus())); } @@ -986,7 +989,7 @@ private ScreenBinding WorldsScreen() private ScreenBinding TriggersScreen() { var session = new SettingsSession(selection => - TriggersScreenRenderer.Model(_config.TriggerSets, selection.CursorIn(0))); + TriggersScreenRenderer.Model(_config.TriggerSets, selection.CursorIn(0), SpawnTargets())); return new ScreenBinding(session, () => TriggersScreenView.Build( _config.TriggerSets, @@ -1060,14 +1063,23 @@ private ScreenBinding OptionsScreen(Func sc /// /// The keys a <name>-edit snapshot drives into a freshly opened screen. ⏎ opens the - /// focused row's first field; ⇥ commits it and steps to the next; the rest is typing. F5 walks on - /// to the host and rewrites its suffix, because "no way to change a host" is the gap this whole - /// mode closes and a frame should show exactly that. + /// focused row's first field; ⇥ commits it and steps to the next; the rest is typing. Two screens + /// walk further than the first field, because a still frame should land on the thing that screen's + /// editing actually added: F5 rewrites a host's suffix ("no way to change a host" is the gap the + /// whole mode closes), and F2 steps on to its route group and moves the dot, which is the only way + /// to see that a radio list is live rather than a report. /// private static IEnumerable EditSnapshotKeys(string view) { yield return Stroke('\r', ConsoleKey.Enter); + if (string.Equals(view, "triggers", StringComparison.OrdinalIgnoreCase)) + { + yield return Stroke('\t', ConsoleKey.Tab); + yield return Stroke('\0', ConsoleKey.DownArrow); + yield break; + } + if (!string.Equals(view, "worlds", StringComparison.OrdinalIgnoreCase) && !string.Equals(view, "settings", StringComparison.OrdinalIgnoreCase)) { diff --git a/src/SharpMUTerm.Tui/TimersScreenRenderer.cs b/src/SharpMUTerm.Tui/TimersScreenRenderer.cs index 739bbcbd..5b393dd8 100644 --- a/src/SharpMUTerm.Tui/TimersScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/TimersScreenRenderer.cs @@ -112,7 +112,8 @@ internal static ScreenModel Model(IReadOnlyList sets, int selected) private const double MaxIntervalSeconds = 86400; /// The action bar: which timer is selected on the left, cancel/save on the right. - internal static string FooterLine(IReadOnlyList sets, int selected, int width) + internal static string FooterLine( + IReadOnlyList sets, int selected, int width, ScreenFocus? focus = null) { var entries = Flatten(sets); var context = string.Empty; @@ -123,7 +124,7 @@ internal static string FooterLine(IReadOnlyList sets, int selected, + $"[{Label}] · set {Escape(entries[selected].SetName)}[/]"; } - var actions = ScreenChrome.Actions(); + var actions = ScreenChrome.Actions(focus: focus); return SpreadLR(" " + context, actions, width); } diff --git a/src/SharpMUTerm.Tui/TimersScreenView.cs b/src/SharpMUTerm.Tui/TimersScreenView.cs index 58a52674..5d1e2e02 100644 --- a/src/SharpMUTerm.Tui/TimersScreenView.cs +++ b/src/SharpMUTerm.Tui/TimersScreenView.cs @@ -24,7 +24,7 @@ public static IWindowControl Build( TimersScreenRenderer.HeaderLine(width, TimersScreenRenderer.Model(sets, selected), focus), ScreenPalette.HeaderBg); var footer = ScreenChrome.Band( - TimersScreenRenderer.FooterLine(sets, selected, width), ScreenPalette.FooterBg); + TimersScreenRenderer.FooterLine(sets, selected, width, focus), ScreenPalette.FooterBg); // Body: timer list │ editor, as two real columns. var listCol = ScreenChrome.Stretch( diff --git a/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs b/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs index 4baf9414..ac25e109 100644 --- a/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs @@ -25,6 +25,43 @@ internal static class TriggersScreenRenderer /// internal const int ColumnWidth = 56; + /// + /// What the route list calls "no spawn window" — a rule with a null SpawnTarget goes to the + /// main output. It is a real choice in the radio group, not the absence of one. + /// + internal const string MainWindow = "main"; + + /// The rule row's field ordinals, in the order ⇥ steps through them. + private const int PatternField = 0; + private const int RouteField = 1; + private const int ForegroundField = 2; + private const int BackgroundField = 3; + + /// The window a rule routes to, as the route field reads and writes it. + private static string Route(Trigger trigger) => trigger.Actions.SpawnTarget ?? MainWindow; + + /// + /// The windows a rule may be routed to: the main output, every spawn window the workspace knows + /// about, and — always — the one this rule already points at, so a rule routed somewhere the + /// current workspace has no window for still shows (and can commit) its own value rather than + /// being refused by its own field. + /// + internal static IReadOnlyList Routes(Trigger trigger, IReadOnlyList? spawnTargets) + { + ArgumentNullException.ThrowIfNull(trigger); + + var routes = new List { MainWindow }; + foreach (var target in (spawnTargets ?? Array.Empty()).Append(Route(trigger))) + { + if (!string.IsNullOrEmpty(target) && !routes.Contains(target, StringComparer.Ordinal)) + { + routes.Add(target); + } + } + + return routes; + } + /// /// Merges every sub-block into one line list (header, rule list | editor, footer). Used by the /// unit tests and as a width-agnostic fallback; the live view composes the same blocks into @@ -41,7 +78,7 @@ public static List Render( var left = RulesColumn(sets, selectedTrigger); var right = EditorColumn(sets, selectedTrigger, spawnTargets); - var lines = new List { HeaderLine(0, Model(sets, selectedTrigger)), string.Empty }; + var lines = new List { HeaderLine(0, Model(sets, selectedTrigger, spawnTargets)), string.Empty }; var rowCount = Math.Max(left.Count, right.Count); for (var i = 0; i < rowCount; i++) @@ -72,12 +109,26 @@ internal static string HeaderLine(int width, ScreenModel? model = null, ScreenFo /// /// The screen's navigable panes: the rule list (Space enables/disables a trigger, ⏎ edits its - /// match pattern) and the selected rule's checkbox rows, in the order - /// draws them. The pattern belongs to the rule row rather than to the editor pane so giving it an - /// editor doesn't renumber the rows the cursor already navigates by; the editor still draws the - /// buffer, under its own label, because that is where the pattern is displayed in full. + /// match pattern and then ⇥ steps through its route and its two highlight colours) and the + /// selected rule's checkbox rows, in the order draws them. + /// + /// Everything the editor pane *displays* about the selected rule belongs to that rule's own list + /// row rather than to the editor pane. That is the same reason the pattern does: a rule's route + /// and its highlight are one setting each, so making them navigable rows of their own would put + /// N cursor stops (one per route, one per swatch) in front of one value, and renumber the rows the + /// cursor already navigates by. As fields they cycle with ↑↓ — which is exactly what a radio group + /// and a palette are — while the editor keeps drawing them where they are read. + /// /// - internal static ScreenModel Model(IReadOnlyList sets, int selectedTrigger) + /// + /// The spawn windows a rule may route to, beyond main and its own current target. Optional + /// so a caller that only wants the navigable shape (the header hints, the tests) need not know the + /// workspace's windows. + /// + internal static ScreenModel Model( + IReadOnlyList sets, + int selectedTrigger, + IReadOnlyList? spawnTargets = null) { ArgumentNullException.ThrowIfNull(sets); @@ -85,7 +136,20 @@ internal static ScreenModel Model(IReadOnlyList sets, int selectedTr var rules = ScreenModel.Rows(flattened, entry => ScreenRow.Of( ScreenToggle.Bind(() => entry.Trigger.Enabled, v => entry.Trigger.Enabled = v), ScreenField.Pattern( - "match pattern", () => entry.Trigger.Pattern, v => entry.Trigger.Pattern = v))); + "match pattern", () => entry.Trigger.Pattern, v => entry.Trigger.Pattern = v), + ScreenField.Choice( + "route", + () => Route(entry.Trigger), + v => entry.Trigger.Actions.SpawnTarget = v == MainWindow ? null : v, + Routes(entry.Trigger, spawnTargets)), + ScreenField.Colour( + "highlight fg", + () => entry.Trigger.Actions.HighlightForeground, + v => entry.Trigger.Actions.HighlightForeground = v), + ScreenField.Colour( + "highlight bg", + () => entry.Trigger.Actions.HighlightBackground, + v => entry.Trigger.Actions.HighlightBackground = v))); if (selectedTrigger < 0 || selectedTrigger >= flattened.Count) { @@ -103,7 +167,8 @@ internal static ScreenModel Model(IReadOnlyList sets, int selectedTr } /// The action bar: which rule is selected on the left, cancel/save on the right. - internal static string FooterLine(IReadOnlyList sets, int selectedTrigger, int width) + internal static string FooterLine( + IReadOnlyList sets, int selectedTrigger, int width, ScreenFocus? focus = null) { var flattened = Flatten(sets); var context = string.Empty; @@ -114,7 +179,7 @@ internal static string FooterLine(IReadOnlyList sets, int selectedTr + $"[{Label}] · set {Escape(flattened[selectedTrigger].SetName)}[/]"; } - var actions = ScreenChrome.Actions(); + var actions = ScreenChrome.Actions(focus: focus); return SpreadLR(" " + context, actions, width); } @@ -160,8 +225,7 @@ internal static List EditorColumn( var cursor = focus ?? ScreenFocus.None; var flattened = Flatten(sets); return selectedTrigger >= 0 && selectedTrigger < flattened.Count - ? BuildEditor(flattened[selectedTrigger].Trigger, spawnTargets, cursor, - cursor.EditOn(0, selectedTrigger, 0)) + ? BuildEditor(flattened[selectedTrigger].Trigger, spawnTargets, cursor, selectedTrigger) : new List(); } @@ -223,48 +287,43 @@ private static string Flags(TriggerActions actions) } private static List BuildEditor( - Trigger trigger, IReadOnlyList spawnTargets, ScreenFocus cursor, ScreenFieldEdit? pattern) + Trigger trigger, IReadOnlyList spawnTargets, ScreenFocus cursor, int index) { - var currentRoute = trigger.Actions.SpawnTarget ?? "main"; + var pattern = cursor.EditOn(0, index, PatternField); + var route = cursor.EditOn(0, index, RouteField); + var foreground = cursor.EditOn(0, index, ForegroundField); + var background = cursor.EditOn(0, index, BackgroundField); + + // While the route field is open the radios follow the *buffer*, not config, so ↑↓ visibly move + // the dot before anything is committed — the buffer is what ⏎ would write. + var currentRoute = route?.Text ?? Route(trigger); var lines = new List { "[dim]match pattern (regex)[/]", $" {ScreenChrome.Field(Escape(trigger.Pattern), pattern)}", string.Empty, - "[dim]route to[/]", - RouteRow("main", currentRoute), + Heading("route to", route), }; - foreach (var target in spawnTargets) + foreach (var target in Routes(trigger, spawnTargets)) { - lines.Add(RouteRow(target, currentRoute)); + lines.Add(RouteRow(target, currentRoute, route is not null)); } - lines.Add(string.Empty); - var fg = trigger.Actions.HighlightForeground; var bg = trigger.Actions.HighlightBackground; - var hasHighlight = fg is not null || bg is not null; - if (hasHighlight) - { - lines.Add("[dim]highlight[/]"); - if (fg is not null) - { - lines.Add($"[{Hex(fg.Value)}]████[/] fg"); - } - - if (bg is not null) - { - lines.Add($"[{Hex(bg.Value)}]████[/] bg"); - } - lines.Add(string.Empty); - } + lines.Add(string.Empty); + lines.Add(Heading("highlight", foreground ?? background)); + lines.Add(HighlightRow("fg", fg, foreground)); + lines.Add(HighlightRow("bg", bg, background)); + lines.Add(string.Empty); - // The highlight row is a read-only indicator: it reports whether a colour is set, and there is - // no colour picker yet to turn one on with, so it never takes the cursor. The two rows below it - // are real booleans on the trigger, and are the editor pane's navigable rows in this order. + // The highlight checkbox stays a derived indicator — it reports whether either colour is set, + // which the two swatch rows above it are now what changes. The two rows below it are real + // booleans on the trigger, and are the editor pane's navigable rows in this order. + var hasHighlight = fg is not null || bg is not null; lines.Add(hasHighlight ? $"[{Accent}][[x]][/] highlight line" : "[dim][[ ]] highlight line[/]"); lines.Add(ScreenChrome.Cursor(Checkbox("gag line", trigger.Actions.Gag), cursor.IsOn(1, 0), ColumnWidth)); lines.Add(ScreenChrome.Cursor( @@ -277,12 +336,44 @@ private static List BuildEditor( private static string Checkbox(string label, bool value) => value ? $"[{Accent}][[x]][/] {Escape(label)}" : $"[dim][[ ]] {Escape(label)}[/]"; - private static string RouteRow(string label, string currentRoute) + /// + /// A section label, carrying the open field's rejection message when there is one. A radio group + /// and a pair of swatches have nowhere sensible to put an error inline, so it hangs off the + /// heading the group belongs to. + /// + private static string Heading(string label, ScreenFieldEdit? edit) => + edit?.Error is { } error + ? $"[dim]{label}[/] [{Warn}]▲ {Escape(error)}[/]" + : $"[dim]{label}[/]"; + + /// + /// One radio of the route group. wells the whole group so it reads as + /// live rather than as the report it is the rest of the time — the selected radio moves with ↑↓, + /// and a group that looked identical either way would give no sign the keyboard had it. + /// + private static string RouteRow(string label, string currentRoute, bool editing) { - var marker = label == currentRoute ? $"[{Accent}]●[/]" : "[dim]○[/]"; - return $" {marker} {Escape(label)}"; + var selected = string.Equals(label, currentRoute, StringComparison.Ordinal); + if (!selected) + { + return $" [dim]○[/] {Escape(label)}"; + } + + return editing + ? $" [{Accent}]●[/] [{Value} on {FieldBg}]{Escape(label)} [/]" + : $" [{Accent}]●[/] {Escape(label)}"; } - private static string Hex(TerminalColor color) => - color.Kind == TerminalColorKind.Rgb ? $"#{color.R:x2}{color.G:x2}{color.B:x2}" : Accent; + /// + /// A highlight swatch and the colour it is set to, drawn as a field so an open picker shows its + /// buffer and caret here. An unset colour gets a hollow swatch rather than none at all, so the row + /// is visibly a place a colour goes. + /// + private static string HighlightRow(string label, TerminalColor? colour, ScreenFieldEdit? edit) + { + var swatch = colour is { } set ? $"[{ScreenColours.Hex(set, Accent)}]████[/]" : $"[{Rule}]░░░░[/]"; + var name = ScreenColours.Format(colour); + var display = colour is null ? $"[dim]{name}[/]" : $"[{Value}]{Escape(name)}[/]"; + return $" {swatch} {label} {ScreenChrome.Field(display, edit)}"; + } } diff --git a/src/SharpMUTerm.Tui/TriggersScreenView.cs b/src/SharpMUTerm.Tui/TriggersScreenView.cs index 7e8014bd..4545b44d 100644 --- a/src/SharpMUTerm.Tui/TriggersScreenView.cs +++ b/src/SharpMUTerm.Tui/TriggersScreenView.cs @@ -26,10 +26,10 @@ public static IWindowControl Build( { var header = ScreenChrome.Band( TriggersScreenRenderer.HeaderLine( - width, TriggersScreenRenderer.Model(sets, selectedTrigger), focus), + width, TriggersScreenRenderer.Model(sets, selectedTrigger, spawnTargets), focus), ScreenPalette.HeaderBg); var footer = ScreenChrome.Band( - TriggersScreenRenderer.FooterLine(sets, selectedTrigger, width), ScreenPalette.FooterBg); + TriggersScreenRenderer.FooterLine(sets, selectedTrigger, width, focus), ScreenPalette.FooterBg); // Body: rule list │ editor, as two real columns. var rulesCol = ScreenChrome.Stretch( diff --git a/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs b/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs index de2fe602..b49c11c8 100644 --- a/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs @@ -24,9 +24,38 @@ internal static class WorldsScreenRenderer private const int CharacterRowWidth = 62; private const string DividerGlyph = " │ "; + /// + /// Which item of a list a pane's cursor has selected. The cursor also visits the pane's button + /// rows, which sit past the end of the list, and a cursor parked on [[+ world]] must not + /// read as "no world selected" — that would blank the detail column, empty the character pane, and + /// take the [[- del]] row out from under the very cursor trying to reach it. A cursor past + /// the end therefore keeps the last item selected. A negative cursor still means nothing is + /// selected, which is how a caller says so deliberately. + /// + private static int Selected(int count, int cursor) => cursor >= count ? count - 1 : cursor; + + /// + /// A raw pane-cursor pair resolved to the world and character they actually select, so every block + /// of this screen — and the view that composes them — reads the same pair. Both panes end in button + /// rows, so both cursors can point past their list. + /// + internal static (int World, int Character) Resolve( + IReadOnlyList worlds, int selectedWorld, int selectedCharacter) + { + ArgumentNullException.ThrowIfNull(worlds); + + var world = Selected(worlds.Count, selectedWorld); + return (world, world >= 0 ? Selected(worlds[world].Characters.Count, selectedCharacter) : -1); + } + /// The accent hex for the selected world (its own, or the default teal). - internal static string AccentFor(IReadOnlyList worlds, int selectedWorld) => - selectedWorld >= 0 && selectedWorld < worlds.Count ? Hex(worlds[selectedWorld].Accent) : Accent; + internal static string AccentFor(IReadOnlyList worlds, int selectedWorld) + { + ArgumentNullException.ThrowIfNull(worlds); + + var world = Selected(worlds.Count, selectedWorld); + return world >= 0 ? Hex(worlds[world].Accent) : Accent; + } /// /// Merges every sub-block into one line list (header, worlds list | detail, character form | @@ -45,6 +74,7 @@ public static List Render( ArgumentNullException.ThrowIfNull(worlds); ArgumentNullException.ThrowIfNull(triggerSets); + (selectedWorld, selectedCharacter) = Resolve(worlds, selectedWorld, selectedCharacter); var accent = AccentFor(worlds, selectedWorld); var model = Model(worlds, triggerSets, selectedWorld, selectedCharacter); var lines = new List { Band(HeaderLine(width, model), HeaderBg, width) }; @@ -75,9 +105,13 @@ public static List Render( return lines; } - internal static bool HasCharacter(IReadOnlyList worlds, int selectedWorld, int selectedCharacter) => - selectedWorld >= 0 && selectedWorld < worlds.Count && - selectedCharacter >= 0 && selectedCharacter < worlds[selectedWorld].Characters.Count; + internal static bool HasCharacter(IReadOnlyList worlds, int selectedWorld, int selectedCharacter) + { + ArgumentNullException.ThrowIfNull(worlds); + + var world = Selected(worlds.Count, selectedWorld); + return world >= 0 && Selected(worlds[world].Characters.Count, selectedCharacter) >= 0; + } /// /// The screen title on the left, the keyboard hints right-aligned to . The @@ -95,6 +129,19 @@ internal static string HeaderLine(int width, ScreenModel? model = null, ScreenFo /// The wire encodings a world may be set to; the detail column cycles them with ↑↓. private static readonly string[] Encodings = { "UTF-8", "ISO-8859-1", "ASCII", "CP437", "CP1252" }; + /// The label the WORLDS list's add button carries, and the row the renderer draws for it. + internal const string AddWorldLabel = "+ world"; + + /// The label the WORLDS list's delete button carries. + internal const string RemoveWorldLabel = "- del"; + + /// The labels the character list's buttons carry, in the order they are drawn. + internal const string AddCharacterLabel = "+ add character"; + + internal const string DuplicateCharacterLabel = "⧉ duplicate"; + + internal const string RemoveCharacterLabel = "- remove"; + /// /// The screen's three navigable panes, in ⇥ order: the WORLDS list (no checkbox on a world's row, /// but ⏎ opens the world's own fields — the ones the detail column lists), the selected world's @@ -107,6 +154,12 @@ internal static string HeaderLine(int width, ScreenModel? model = null, ScreenFo /// column is a projection of whatever the WORLDS list has selected, so its values already belong /// to that row, and a fourth pane would put ⇥ somewhere the eye doesn't go. /// + /// + /// Each list pane ends in its own buttons, because a button acts on the list it is drawn under and + /// the cursor is already there. A button that would act on nothing is left out rather than drawn + /// dead: a world with no characters offers + add character and nothing else, so ⏎ never + /// lands on a row that silently does nothing. + /// /// internal static ScreenModel Model( IReadOnlyList worlds, @@ -117,12 +170,16 @@ internal static ScreenModel Model( ArgumentNullException.ThrowIfNull(worlds); ArgumentNullException.ThrowIfNull(triggerSets); + (selectedWorld, selectedCharacter) = Resolve(worlds, selectedWorld, selectedCharacter); + var worldRows = ScreenModel.Rows(worlds, w => ScreenRow.Of( ScreenField.Text("name", () => w.Name, v => w.Name = v), ScreenField.Text("host", () => w.Host, v => w.Host = v), ScreenField.Integer("port", () => w.Port, v => w.Port = v, 1, 65535), ScreenField.Choice("encoding", () => w.Encoding, v => w.Encoding = v, Encodings), - ScreenField.Integer("keepalive", () => w.KeepaliveSeconds, v => w.KeepaliveSeconds = v, 0, 86400))); + ScreenField.Integer("keepalive", () => w.KeepaliveSeconds, v => w.KeepaliveSeconds = v, 0, 86400))) + .Concat(WorldButtons(worlds, selectedWorld)) + .ToArray(); var world = selectedWorld >= 0 && selectedWorld < worlds.Count ? worlds[selectedWorld] : null; var characterRows = world is null @@ -130,7 +187,9 @@ internal static ScreenModel Model( : ScreenModel.Rows(world.Characters, c => ScreenRow.Of( ScreenToggle.Bind(() => c.AutoLogin, v => c.AutoLogin = v), ScreenField.Text("name", () => c.Name, v => c.Name = v), - ScreenField.Optional("on connect", () => c.OnConnect, v => c.OnConnect = v))); + ScreenField.Optional("on connect", () => c.OnConnect, v => c.OnConnect = v))) + .Concat(CharacterButtons(world, selectedCharacter)) + .ToArray(); if (!HasCharacter(worlds, selectedWorld, selectedCharacter)) { @@ -169,9 +228,101 @@ internal static ScreenModel Model( return new ScreenModel(worldRows, characterRows, setRows); } + /// + /// The WORLDS list's buttons. Deleting is offered only when there is a world under the cursor to + /// delete; a brand-new world is a blank template, because a world's whole identity is its host and + /// a "helpfully" prefilled one would be a guess the user then has to notice and undo. + /// + private static List WorldButtons(IReadOnlyList worlds, int selectedWorld) + { + var rows = new List(); + // Arrays report IsReadOnly through IList, and a renderer handed one (the unit tests, any + // caller with a fixed projection) must not offer a button whose only effect would be to throw. + if (worlds is not IList { IsReadOnly: false } list) + { + return rows; + } + + rows.Add(ScreenRow.Of(ScreenButton.Add(AddWorldLabel, list, () => new WorldDefinition()))); + if (selectedWorld >= 0 && selectedWorld < list.Count) + { + rows.Add(ScreenRow.Of(ScreenButton.Remove(RemoveWorldLabel, list, selectedWorld))); + } + + return rows; + } + + /// + /// The character list's buttons. Duplicating deep-copies through + /// — an aliased copy would share its trigger-set list and + /// its logging settings with the original, so editing one would silently edit both — and the copy + /// is renamed rather than left as a second identical name, because a session is keyed + /// world.character and two of those would collide. + /// + private static List CharacterButtons(WorldDefinition world, int selectedCharacter) + { + var characters = world.Characters; + var rows = new List + { + ScreenRow.Of(ScreenButton.Add(AddCharacterLabel, characters, () => new CharacterDefinition())), + }; + + if (selectedCharacter >= 0 && selectedCharacter < characters.Count) + { + var source = characters[selectedCharacter]; + rows.Add(ScreenRow.Of(ScreenButton.Add( + DuplicateCharacterLabel, + characters, + () => + { + var copy = source.Clone(); + copy.Name = UniqueName(characters, source.Name); + return copy; + }))); + rows.Add(ScreenRow.Of(ScreenButton.Remove(RemoveCharacterLabel, characters, selectedCharacter))); + } + + return rows; + } + + /// + /// A name no character in already holds: Kaz copy, then + /// Kaz copy 2. Matching is case-insensitive because the session key is, so two names that + /// differ only in case would still collide. + /// + private static string UniqueName(IReadOnlyList characters, string name) + { + var candidate = name + " copy"; + for (var n = 2; Taken(characters, candidate); n++) + { + candidate = $"{name} copy {n.ToString(CultureInfo.InvariantCulture)}"; + } + + return candidate; + } + + private static bool Taken(IReadOnlyList characters, string name) + { + foreach (var character in characters) + { + if (string.Equals(character.Name, name, StringComparison.OrdinalIgnoreCase)) + { + return true; + } + } + + return false; + } + internal static string FooterLine( - IReadOnlyList worlds, int selectedWorld, int selectedCharacter, string accent, int width) + IReadOnlyList worlds, + int selectedWorld, + int selectedCharacter, + string accent, + int width, + ScreenFocus? focus = null) { + (selectedWorld, selectedCharacter) = Resolve(worlds, selectedWorld, selectedCharacter); var context = string.Empty; if (worlds.Count > 0 && selectedWorld >= 0) { @@ -183,7 +334,7 @@ internal static string FooterLine( } } - var actions = ScreenChrome.Actions(accent); + var actions = ScreenChrome.Actions(accent, focus); return SpreadLR(" " + context, actions, width); } @@ -191,6 +342,7 @@ internal static List WorldsColumn( IReadOnlyList worlds, int selectedWorld, ScreenFocus? focus = null) { var cursor = focus ?? ScreenFocus.None; + selectedWorld = Selected(worlds.Count, selectedWorld); var left = new List { $"[{Label}]WORLDS[/]", string.Empty }; for (var i = 0; i < worlds.Count; i++) @@ -217,7 +369,14 @@ internal static List WorldsColumn( } left.Add(string.Empty); - left.Add($"[{Accent}][[+ world]][/] [{Label}][[- del]][/]"); + AppendButtons( + left, + WorldButtons(worlds, selectedWorld), + cursor, + 0, + worlds.Count, + LeftColumnWidth, + selectedWorld >= 0 && selectedWorld < worlds.Count ? worlds[selectedWorld].Name : null); return left; } @@ -230,7 +389,8 @@ internal static List DetailColumn( ScreenFocus? focus = null) { var cursor = focus ?? ScreenFocus.None; - if (selectedWorld < 0 || selectedWorld >= worlds.Count) + (selectedWorld, selectedCharacter) = Resolve(worlds, selectedWorld, selectedCharacter); + if (selectedWorld < 0) { return new List(); } @@ -279,7 +439,16 @@ internal static List DetailColumn( } right.Add(string.Empty); - right.Add($"[{Accent}][[+ add character]][/] [{Label}][[⧉ duplicate]] [[- remove]][/]"); + AppendButtons( + right, + CharacterButtons(world, selectedCharacter), + cursor, + 1, + world.Characters.Count, + CharacterRowWidth, + selectedCharacter >= 0 && selectedCharacter < world.Characters.Count + ? world.Characters[selectedCharacter].Name + : null); return right; } @@ -306,6 +475,42 @@ internal static List FormColumn( }; } + /// + /// Draws a pane's button rows, in the same order and under the same conditions the model builds + /// them — the rows come *from* the model's own buttons rather than being written out again here, + /// so the label the cursor lands on and the command ⏎ runs cannot drift apart. + /// + private static void AppendButtons( + List lines, + IReadOnlyList buttons, + ScreenFocus cursor, + int pane, + int firstIndex, + int barWidth, + string? target) + { + for (var i = 0; i < buttons.Count; i++) + { + if (buttons[i].Button is not { } button) + { + continue; + } + + // A button that adds needs no target and gets the accent; one that acts on the selected row + // names it, because the cursor has to leave the list to reach the button and a destructive + // key whose victim is off-screen is exactly the kind of surprise these screens must not + // spring. + var adds = button.Label == AddWorldLabel || button.Label == AddCharacterLabel; + var row = $"[{(adds ? Accent : Label)}][[{Escape(button.Label)}]][/]"; + if (!adds && target is not null) + { + row += $" [{Value}]{Escape(target)}[/]"; + } + + lines.Add(ScreenChrome.Cursor(row, cursor.IsOn(pane, firstIndex + i), barWidth)); + } + } + /// Draws a value as a field, showing the buffer and caret when its edit is the open one. private static string Field(string display, ScreenFocus cursor, int index, int field, int pane = 0) => ScreenChrome.Field(display, cursor.EditOn(pane, index, field)); @@ -390,6 +595,10 @@ private static List MergeColumns(IReadOnlyList left, IReadOnlyLi return merged; } - private static string Hex(TerminalColor color) => - color.Kind == TerminalColorKind.Rgb ? $"#{color.R:x2}{color.G:x2}{color.B:x2}" : Accent; + /// + /// A world's accent as markup. Shared with the F2 swatches through , so + /// an indexed accent resolves to the colour the terminal will actually paint instead of collapsing + /// to the app's default teal; only the terminal *default* has no hex of its own. + /// + private static string Hex(TerminalColor color) => ScreenColours.Hex(color, Accent); } diff --git a/src/SharpMUTerm.Tui/WorldsScreenView.cs b/src/SharpMUTerm.Tui/WorldsScreenView.cs index b18d07a3..1af01b04 100644 --- a/src/SharpMUTerm.Tui/WorldsScreenView.cs +++ b/src/SharpMUTerm.Tui/WorldsScreenView.cs @@ -24,13 +24,17 @@ public static IWindowControl Build( int width, ScreenFocus? focus = null) { + // Both panes end in button rows, so a raw cursor can point past its list; resolving once here + // keeps every block of the screen agreeing on which world and character are selected. + (selectedWorld, selectedCharacter) = + WorldsScreenRenderer.Resolve(worlds, selectedWorld, selectedCharacter); var accent = WorldsScreenRenderer.AccentFor(worlds, selectedWorld); var model = WorldsScreenRenderer.Model(worlds, triggerSets, selectedWorld, selectedCharacter); var header = ScreenChrome.Band( WorldsScreenRenderer.HeaderLine(width, model, focus), ScreenPalette.HeaderBg); var footer = ScreenChrome.Band( - WorldsScreenRenderer.FooterLine(worlds, selectedWorld, selectedCharacter, accent, width), + WorldsScreenRenderer.FooterLine(worlds, selectedWorld, selectedCharacter, accent, width, focus), ScreenPalette.FooterBg); // Body: WORLDS list │ detail, as two real columns. diff --git a/tests/SharpMUTerm.Core.Tests/Configuration/DefinitionCloneTests.cs b/tests/SharpMUTerm.Core.Tests/Configuration/DefinitionCloneTests.cs new file mode 100644 index 00000000..710b879c --- /dev/null +++ b/tests/SharpMUTerm.Core.Tests/Configuration/DefinitionCloneTests.cs @@ -0,0 +1,117 @@ +using SharpMUTerm.Core.Configuration; +using SharpMUTerm.Core.Text; + +namespace SharpMUTerm.Core.Tests.Configuration; + +/// +/// and — the deep copy the +/// F5 screen's duplicate button is built on. A copy that shared a list or a settings object +/// with its original would look correct on screen and only betray itself later, when an edit to one +/// silently landed on both, so every mutable part is asserted to be genuinely separate rather than +/// merely equal. +/// +public class DefinitionCloneTests +{ + private static CharacterDefinition Character() => new() + { + Name = "Kaz", + Password = "hunter2", + ConnectString = "connect Kaz hunter2", + AutoLogin = true, + OnConnect = "look", + OnDisconnect = "quit", + TriggerSets = new List { "Comms", "Combat" }, + Logging = new LoggingSettings { Format = LogFormat.Html, Directory = "/logs/kaz" }, + }; + + [Test] + public async Task CharacterClone_CopiesEveryValue() + { + var copy = Character().Clone(); + + await Assert.That(copy.Name).IsEqualTo("Kaz"); + await Assert.That(copy.Password).IsEqualTo("hunter2"); + await Assert.That(copy.ConnectString).IsEqualTo("connect Kaz hunter2"); + await Assert.That(copy.AutoLogin).IsTrue(); + await Assert.That(copy.OnConnect).IsEqualTo("look"); + await Assert.That(copy.OnDisconnect).IsEqualTo("quit"); + await Assert.That(copy.TriggerSets).IsEquivalentTo(new[] { "Comms", "Combat" }); + await Assert.That(copy.Logging.Format).IsEqualTo(LogFormat.Html); + await Assert.That(copy.Logging.Directory).IsEqualTo("/logs/kaz"); + } + + [Test] + public async Task CharacterClone_SharesNoMutableStateWithItsOriginal() + { + var original = Character(); + var copy = original.Clone(); + + await Assert.That(ReferenceEquals(original.TriggerSets, copy.TriggerSets)).IsFalse(); + await Assert.That(ReferenceEquals(original.Logging, copy.Logging)).IsFalse(); + + copy.Name = "Kaz copy"; + copy.TriggerSets.Add("Trade"); + copy.TriggerSets.Remove("Comms"); + copy.Logging.Format = LogFormat.None; + copy.Logging.Directory = "/logs/copy"; + copy.AutoLogin = false; + + await Assert.That(original.Name).IsEqualTo("Kaz"); + await Assert.That(original.TriggerSets).IsEquivalentTo(new[] { "Comms", "Combat" }); + await Assert.That(original.Logging.Format).IsEqualTo(LogFormat.Html); + await Assert.That(original.Logging.Directory).IsEqualTo("/logs/kaz"); + await Assert.That(original.AutoLogin).IsTrue(); + + // And in the other direction — an aliasing bug is only half-visible from one side. + original.TriggerSets.Add("Guild"); + await Assert.That(copy.TriggerSets).DoesNotContain("Guild"); + } + + [Test] + public async Task WorldClone_CopiesEveryValue_AndDeepCopiesItsCharacters() + { + var world = new WorldDefinition + { + Name = "Aardwolf", + Host = "aardmud.org", + Port = 4000, + UseTls = true, + AllowInvalidCertificates = true, + LocalEcho = false, + Encoding = "ISO-8859-1", + KeepaliveSeconds = 60, + ContentFormat = ContentFormat.Mxp, + Emoji = new EmojiSettings { Enabled = true, Emoticons = false, Shortcodes = true }, + Accent = TerminalColor.FromRgb(0x00, 0xf5, 0xb7), + Characters = new List { Character() }, + }; + + var copy = world.Clone(); + + await Assert.That(copy.Name).IsEqualTo("Aardwolf"); + await Assert.That(copy.Host).IsEqualTo("aardmud.org"); + await Assert.That(copy.Port).IsEqualTo(4000); + await Assert.That(copy.UseTls).IsTrue(); + await Assert.That(copy.AllowInvalidCertificates).IsTrue(); + await Assert.That(copy.LocalEcho).IsFalse(); + await Assert.That(copy.Encoding).IsEqualTo("ISO-8859-1"); + await Assert.That(copy.KeepaliveSeconds).IsEqualTo(60); + await Assert.That(copy.ContentFormat).IsEqualTo(ContentFormat.Mxp); + await Assert.That(copy.Accent).IsEqualTo(TerminalColor.FromRgb(0x00, 0xf5, 0xb7)); + await Assert.That(copy.Characters.Count).IsEqualTo(1); + + await Assert.That(ReferenceEquals(world.Characters, copy.Characters)).IsFalse(); + await Assert.That(ReferenceEquals(world.Characters[0], copy.Characters[0])).IsFalse(); + await Assert.That(ReferenceEquals(world.Emoji, copy.Emoji)).IsFalse(); + + copy.Characters[0].Name = "Mira"; + copy.Characters[0].TriggerSets.Clear(); + copy.Emoji.Enabled = false; + copy.Characters.Add(new CharacterDefinition()); + + await Assert.That(world.Characters.Count).IsEqualTo(1); + await Assert.That(world.Characters[0].Name).IsEqualTo("Kaz"); + await Assert.That(world.Characters[0].TriggerSets.Count).IsEqualTo(2); + await Assert.That(world.Emoji.Enabled).IsTrue(); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenButtonTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenButtonTests.cs new file mode 100644 index 00000000..6e23b6f4 --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/ScreenButtonTests.cs @@ -0,0 +1,352 @@ +using SharpMUTerm.Core.Automation; +using SharpMUTerm.Core.Configuration; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// The button rows on the F5 screen — + world, - del, + add character, +/// ⧉ duplicate, - remove. They were painted but inert; these assert what each one now +/// does, that a deletion is undone *back into its own place* rather than onto the end, and that a +/// duplicate shares nothing with the character it copied. +/// +/// Deletion is deliberately not behind a confirmation prompt. Nothing a settings screen does reaches +/// disk until Save, Esc replays the undo log — which now includes the removed row and its index — and +/// a second modal state inside a screen that already has one (an open field edit) would double the +/// key-routing rules for a change that is already reversible. The undo is asserted here instead. +/// +/// +public class ScreenButtonTests +{ + private static ConsoleKeyInfo Key(ConsoleKey key) => new('\0', key, false, false, false); + + private static List Sets() => new() + { + new TriggerSet { Name = "Comms", Triggers = new List { new() { Name = "T", Pattern = "x" } } }, + }; + + private static List Worlds() => new() + { + new WorldDefinition + { + Name = "Aardwolf", + Host = "aardmud.org", + Characters = new List + { + new() { Name = "Kaz", TriggerSets = new List { "Comms" } }, + new() { Name = "Mira" }, + }, + }, + new WorldDefinition { Name = "Empty", Host = "example.org" }, + }; + + private static ScreenButton ButtonNamed(ScreenModel model, int pane, string label) + { + for (var i = 0; i < 32; i++) + { + if (model.ButtonAt(pane, i) is { } button && button.Label == label) + { + return button; + } + } + + throw new InvalidOperationException($"no button labelled '{label}' in pane {pane}"); + } + + [Test] + public async Task EachListPaneEndsInItsOwnButtons() + { + var worlds = Worlds(); + var model = WorldsScreenRenderer.Model(worlds, Sets(), selectedWorld: 0, selectedCharacter: 0); + + // 2 worlds + [+ world] + [- del]; 2 characters + [+ add] + [⧉ duplicate] + [- remove]; 1 set. + await Assert.That(model.Sizes).IsEquivalentTo(new[] { 4, 5, 1 }); + + await Assert.That(model.ButtonAt(0, 2)!.Value.Label).IsEqualTo(WorldsScreenRenderer.AddWorldLabel); + await Assert.That(model.ButtonAt(0, 3)!.Value.Label).IsEqualTo(WorldsScreenRenderer.RemoveWorldLabel); + await Assert.That(model.ButtonAt(1, 2)!.Value.Label).IsEqualTo(WorldsScreenRenderer.AddCharacterLabel); + await Assert.That(model.ButtonAt(1, 3)!.Value.Label) + .IsEqualTo(WorldsScreenRenderer.DuplicateCharacterLabel); + await Assert.That(model.ButtonAt(1, 4)!.Value.Label).IsEqualTo(WorldsScreenRenderer.RemoveCharacterLabel); + + // A world's own rows are still where they were — the buttons come after the list, so giving the + // pane buttons doesn't renumber the rows the cursor navigates by. + await Assert.That(model.ButtonAt(0, 0)).IsNull(); + await Assert.That(model.FieldAt(0, 0, 0)!.Value.Get()).IsEqualTo("Aardwolf"); + } + + /// + /// A button that would act on nothing isn't drawn at all. A world with no characters can only be + /// added to, so ⏎ can never land on a duplicate or remove that silently no-ops. + /// + [Test] + public async Task APaneWithNothingSelectedOffersOnlyItsAddButton() + { + var model = WorldsScreenRenderer.Model(Worlds(), Sets(), selectedWorld: 1, selectedCharacter: 0); + + await Assert.That(model.Sizes).IsEquivalentTo(new[] { 4, 1, 0 }); + await Assert.That(model.ButtonAt(1, 0)!.Value.Label).IsEqualTo(WorldsScreenRenderer.AddCharacterLabel); + await Assert.That(model.ButtonAt(1, 1)).IsNull(); + } + + /// + /// A renderer handed a fixed projection (an array) must not offer a button whose only effect would + /// be to throw — arrays report IsReadOnly through IList<T>. + /// + [Test] + public async Task AReadOnlyWorldListOffersNoAddButton() + { + var model = WorldsScreenRenderer.Model( + Array.Empty(), Array.Empty(), -1, -1); + + await Assert.That(model.Sizes[0]).IsEqualTo(0); + } + + [Test] + public async Task AddWorld_AppendsABlankWorldAndAsksForTheCursorOnIt() + { + var worlds = Worlds(); + var edits = new ScreenEdits(); + var model = WorldsScreenRenderer.Model(worlds, Sets(), 0, 0); + + var select = edits.Apply(ButtonNamed(model, 0, WorldsScreenRenderer.AddWorldLabel)); + + await Assert.That(worlds.Count).IsEqualTo(3); + await Assert.That(worlds[2].Name).IsEqualTo("New World"); + await Assert.That(select).IsEqualTo(2); + + edits.Revert(); + await Assert.That(worlds.Count).IsEqualTo(2); + } + + /// + /// A deletion's undo has to restore the row's *place*, not merely its existence: the list order is + /// what the screen navigates by, and putting a cancelled deletion back on the end would be a + /// second, invisible edit riding along with the first. + /// + [Test] + public async Task RemoveWorld_UndoPutsItBackAtItsOwnIndex() + { + var worlds = Worlds(); + worlds.Insert(0, new WorldDefinition { Name = "First" }); + var edits = new ScreenEdits(); + + edits.Apply(ButtonNamed( + WorldsScreenRenderer.Model(worlds, Sets(), selectedWorld: 1, selectedCharacter: -1), + 0, + WorldsScreenRenderer.RemoveWorldLabel)); + + await Assert.That(worlds.Select(w => w.Name)).IsEquivalentTo(new[] { "First", "Empty" }); + + edits.Revert(); + + await Assert.That(worlds.Select(w => w.Name)).IsEquivalentTo(new[] { "First", "Aardwolf", "Empty" }); + } + + [Test] + public async Task RemoveCharacter_UndoPutsItBackAtItsOwnIndex() + { + var worlds = Worlds(); + var characters = worlds[0].Characters; + characters.Add(new CharacterDefinition { Name = "Tal" }); + var edits = new ScreenEdits(); + + edits.Apply(ButtonNamed( + WorldsScreenRenderer.Model(worlds, Sets(), 0, selectedCharacter: 1), + 1, + WorldsScreenRenderer.RemoveCharacterLabel)); + + await Assert.That(characters.Select(c => c.Name)).IsEquivalentTo(new[] { "Kaz", "Tal" }); + + edits.Revert(); + + await Assert.That(characters.Select(c => c.Name)).IsEquivalentTo(new[] { "Kaz", "Mira", "Tal" }); + } + + /// + /// The whole point of duplicate: the copy must be a copy. An aliased one would look right + /// and then follow every later edit of its original around. + /// + [Test] + public async Task DuplicateCharacter_IsADeepCopyWithItsOwnName() + { + var worlds = Worlds(); + var characters = worlds[0].Characters; + var original = characters[0]; + original.Logging = new LoggingSettings { Format = LogFormat.Html, Directory = "/logs/kaz" }; + var edits = new ScreenEdits(); + + var select = edits.Apply(ButtonNamed( + WorldsScreenRenderer.Model(worlds, Sets(), 0, selectedCharacter: 0), + 1, + WorldsScreenRenderer.DuplicateCharacterLabel)); + + await Assert.That(characters.Count).IsEqualTo(3); + await Assert.That(select).IsEqualTo(2); + + var copy = characters[2]; + await Assert.That(copy.Name).IsEqualTo("Kaz copy"); + await Assert.That(ReferenceEquals(copy, original)).IsFalse(); + await Assert.That(ReferenceEquals(copy.TriggerSets, original.TriggerSets)).IsFalse(); + await Assert.That(ReferenceEquals(copy.Logging, original.Logging)).IsFalse(); + + copy.TriggerSets.Add("Combat"); + copy.Logging.Directory = "/logs/copy"; + copy.AutoLogin = true; + + await Assert.That(original.TriggerSets).IsEquivalentTo(new[] { "Comms" }); + await Assert.That(original.Logging.Directory).IsEqualTo("/logs/kaz"); + await Assert.That(original.AutoLogin).IsFalse(); + + edits.Revert(); + await Assert.That(characters.Count).IsEqualTo(2); + } + + /// + /// Sessions are keyed world.character, so two characters of one world may not share a name. + /// Duplicating twice has to keep finding a free one rather than colliding on "copy". + /// + [Test] + public async Task DuplicatingTwiceGivesEachCopyAFreeName() + { + var worlds = Worlds(); + var characters = worlds[0].Characters; + var edits = new ScreenEdits(); + + edits.Apply(ButtonNamed( + WorldsScreenRenderer.Model(worlds, Sets(), 0, 0), 1, WorldsScreenRenderer.DuplicateCharacterLabel)); + edits.Apply(ButtonNamed( + WorldsScreenRenderer.Model(worlds, Sets(), 0, 0), 1, WorldsScreenRenderer.DuplicateCharacterLabel)); + + await Assert.That(characters.Select(c => c.Name)) + .IsEquivalentTo(new[] { "Kaz", "Mira", "Kaz copy", "Kaz copy 2" }); + } + + /// + /// End to end through the keyboard: ⏎ on a button row runs it and leaves the cursor on the new row, + /// where the next ⏎ opens that row's name — which is the whole reason a new row is worth adding. + /// + [Test] + public async Task Enter_OnAButtonRowRunsItAndLeavesTheCursorOnTheNewRow() + { + var worlds = Worlds(); + var sets = Sets(); + var session = new SettingsSession(selection => WorldsScreenRenderer.Model( + worlds, sets, selection.CursorIn(0), selection.CursorIn(1))); + + // Rows 0-1 are the two worlds; row 2 is [+ world]. + session.Handle(Key(ConsoleKey.DownArrow)); + session.Handle(Key(ConsoleKey.DownArrow)); + await Assert.That(session.Handle(Key(ConsoleKey.Enter))).IsEqualTo(ScreenAction.Redraw); + + await Assert.That(worlds.Count).IsEqualTo(3); + await Assert.That(session.Focus().Index).IsEqualTo(2); + await Assert.That(session.IsEditing).IsFalse(); + + session.Handle(Key(ConsoleKey.Enter)); + await Assert.That(session.IsEditing).IsTrue(); + await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("New World"); + + // Esc abandons the buffer, then Esc cancels the screen — and cancelling unmakes the world. + session.Handle(Key(ConsoleKey.Escape)); + await Assert.That(session.Handle(Key(ConsoleKey.Escape))).IsEqualTo(ScreenAction.Cancel); + session.Edits.Revert(); + await Assert.That(worlds.Count).IsEqualTo(2); + } + + /// + /// A button is activated by ⏎ but doesn't *edit* anything, so it must not make a screen advertise + /// ⏎ edit — the same honesty rule the header hints are already held to. + /// + [Test] + public async Task AButtonRowAloneDoesNotMakeAScreenClaimAnEditor() + { + var list = new List(); + var buttons = new ScreenModel(new[] + { + ScreenRow.Of(ScreenButton.Add("+ thing", list, () => "thing")), + }); + + await Assert.That(buttons.HasEditableRow).IsFalse(); + await Assert.That(buttons.RowAt(0, 0).IsActivatable).IsTrue(); + } + + /// + /// The interaction the button rows live or die by. A pane's buttons sit past the end of its list, + /// so reaching them with ↑↓ alone would drag the selection to the last row and leave + /// - del pointed at a world the user never chose. End steps over the list without + /// re-anchoring, so the button acts on the row that is still on screen. + /// + [Test] + public async Task End_ReachesAPanesButtonsWithoutMovingItsSelection() + { + var worlds = Worlds(); + worlds.Add(new WorldDefinition { Name = "Third" }); + var sets = Sets(); + var session = new SettingsSession(selection => WorldsScreenRenderer.Model( + worlds, sets, selection.SelectionIn(0), selection.SelectionIn(1))); + + // Sit on the *first* world, then jump to the last row of the pane — the delete button. + await Assert.That(session.Selection.SelectionIn(0)).IsEqualTo(0); + session.Handle(Key(ConsoleKey.End)); + + await Assert.That(session.Focus().Index).IsEqualTo(4); // 3 worlds + [+ world] + [- del] + await Assert.That(session.Selection.SelectionIn(0)).IsEqualTo(0); + + session.Handle(Key(ConsoleKey.Enter)); + + await Assert.That(worlds.Select(w => w.Name)).IsEquivalentTo(new[] { "Empty", "Third" }); + + session.Edits.Revert(); + await Assert.That(worlds.Select(w => w.Name)).IsEquivalentTo(new[] { "Aardwolf", "Empty", "Third" }); + } + + /// + /// Walking the list *does* move the selection, because the detail column follows the cursor — so + /// the button names the row it would act on rather than leaving the user to infer it. + /// + [Test] + public async Task ATargetedButtonNamesTheRowItWouldActOn() + { + var worlds = Worlds(); + var left = WorldsScreenRenderer.WorldsColumn(worlds, selectedWorld: 1); + var right = WorldsScreenRenderer.DetailColumn(worlds, Sets(), 0, 0, ScreenPalette.Accent); + + await Assert.That(left.Any(l => l.Contains("[[- del]]") && l.Contains("Empty"))).IsTrue(); + await Assert.That(left.Any(l => l.Contains("[[+ world]]") && l.Contains("Empty"))).IsFalse(); + await Assert.That(right.Any(l => l.Contains("[[- remove]]") && l.Contains("Kaz"))).IsTrue(); + await Assert.That(right.Any(l => l.Contains("[[⧉ duplicate]]") && l.Contains("Kaz"))).IsTrue(); + } + + /// + /// A cursor parked on a button row must still leave the screen showing the row it is about to act + /// on — blanking the detail column there would also take the button out from under the cursor. + /// + [Test] + public async Task ACursorPastTheEndOfAListStillResolvesToItsLastRow() + { + var worlds = Worlds(); + + await Assert.That(WorldsScreenRenderer.Resolve(worlds, 3, 0)).IsEqualTo((1, -1)); + await Assert.That(WorldsScreenRenderer.Resolve(worlds, 0, 4)).IsEqualTo((0, 1)); + await Assert.That(WorldsScreenRenderer.Resolve(worlds, -1, -1)).IsEqualTo((-1, -1)); + await Assert.That(WorldsScreenRenderer.HasCharacter(worlds, 0, 9)).IsTrue(); + } + + /// A button asked to remove a row that is no longer there does nothing, undo included. + [Test] + public async Task RemovingARowThatIsNoLongerThereIsANoOp() + { + var list = new List { "one" }; + var edits = new ScreenEdits(); + var button = ScreenButton.Remove("- del", list, 4); + + var select = edits.Apply(button); + + await Assert.That(list).IsEquivalentTo(new[] { "one" }); + await Assert.That(select).IsNull(); + + edits.Revert(); + await Assert.That(list).IsEquivalentTo(new[] { "one" }); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenFooterTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenFooterTests.cs new file mode 100644 index 00000000..b2c8d63d --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/ScreenFooterTests.cs @@ -0,0 +1,164 @@ +using SharpMUTerm.Core.Automation; +using SharpMUTerm.Core.Configuration; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// The hint-honesty rule, applied to the footer action bar. pins it +/// for the header: a screen may not advertise a key that does something else. The footer makes the +/// louder claim of the two — it is a pair of filled chips, not grey hint text — and it used to keep +/// saying [[⏎]] Save while a field edit was open, where ⏎ commits the field and Esc abandons +/// its buffer. Neither closes the screen at that moment, so both chips named the wrong action. +/// +/// The rule is asserted for every screen and in both directions, so a screen cannot pass by never +/// naming a key at all, and a seventh screen added later cannot quietly opt out. +/// +/// +public class ScreenFooterTests +{ + private static List Sets() => new() + { + new TriggerSet + { + Name = "Comms", + Triggers = new List { new() { Name = "Tell", Pattern = "tells you" } }, + Aliases = new List { new() { Name = "k", Pattern = "^k$", Substitution = "kill" } }, + Macros = new List { new() { Name = "look", Key = "Num5", Command = "look" } }, + Timers = new List { new() { Name = "ping", IntervalSeconds = 30, Command = "look" } }, + }, + }; + + private static List Worlds() => new() + { + new WorldDefinition + { + Name = "Aardwolf", + Host = "aardmud.org", + Characters = new List { new() { Name = "Kaz" } }, + }, + }; + + /// A cursor with a field open on it — what every screen's footer has to answer for. + private static ScreenFocus Editing => new(0, 0, new ScreenFieldEdit(0, "aardmud.org", 11, null)); + + /// Every screen's footer, navigating and mid-edit, so the rule is asserted per screen. + private static List<(string Name, string Navigating, string Mid)> Footers() + { + var sets = Sets(); + var worlds = Worlds(); + var macros = sets[0].Macros; + var logging = OptionsScreenRenderer.LoggingScreen(new LoggingSettings()); + var accent = WorldsScreenRenderer.AccentFor(worlds, 0); + + return new List<(string, string, string)> + { + ("F2 triggers", + TriggersScreenRenderer.FooterLine(sets, 0, 80), + TriggersScreenRenderer.FooterLine(sets, 0, 80, Editing)), + ("F3 aliases", + AliasesScreenRenderer.FooterLine(sets, 0, 80), + AliasesScreenRenderer.FooterLine(sets, 0, 80, Editing)), + ("F4 keypad", + KeypadScreenRenderer.FooterLine(macros, 80), + KeypadScreenRenderer.FooterLine(macros, 80, Editing)), + ("F5 worlds", + WorldsScreenRenderer.FooterLine(worlds, 0, 0, accent, 80), + WorldsScreenRenderer.FooterLine(worlds, 0, 0, accent, 80, Editing)), + ("F6 timers", + TimersScreenRenderer.FooterLine(sets, 0, 80), + TimersScreenRenderer.FooterLine(sets, 0, 80, Editing)), + ("F7/F8/F9 options", + OptionsScreenRenderer.FooterLine(logging.Rows, 80), + OptionsScreenRenderer.FooterLine(logging.Rows, 80, Editing)), + }; + } + + [Test] + public async Task FooterActions_NameSaveAndCancelWhileTheScreenIsNavigating() + { + foreach (var (name, navigating, _) in Footers()) + { + await Assert.That(navigating).Contains(ScreenChrome.SaveAction).Because(name); + await Assert.That(navigating).Contains(ScreenChrome.CancelAction).Because(name); + await Assert.That(navigating).DoesNotContain(ScreenChrome.CommitAction).Because(name); + await Assert.That(navigating).DoesNotContain(ScreenChrome.RevertAction).Because(name); + } + } + + /// + /// The bug this rule exists for: mid-edit, ⏎ commits the open field and Esc throws its buffer away. + /// A footer still offering Save and Cancel is naming two keys that do something else, which is the + /// same lie the header is already forbidden to tell. + /// + [Test] + public async Task FooterActions_NameCommitAndRevertWhileAFieldEditIsOpen() + { + foreach (var (name, _, mid) in Footers()) + { + await Assert.That(mid).Contains(ScreenChrome.CommitAction).Because(name); + await Assert.That(mid).Contains(ScreenChrome.RevertAction).Because(name); + await Assert.That(mid).DoesNotContain(ScreenChrome.SaveAction).Because(name); + await Assert.That(mid).DoesNotContain(ScreenChrome.CancelAction).Because(name); + } + } + + /// + /// The header and the footer are driven by the same , so they can never + /// disagree about whether an edit is open — which is exactly how they came to disagree before. + /// + [Test] + public async Task TheHeaderAndTheFooterAgreeAboutWhetherAnEditIsOpen() + { + var worlds = Worlds(); + var sets = Sets(); + var model = WorldsScreenRenderer.Model(worlds, sets, 0, 0); + var accent = WorldsScreenRenderer.AccentFor(worlds, 0); + + foreach (var focus in new ScreenFocus?[] { null, new ScreenFocus(0, 0), Editing }) + { + var header = WorldsScreenRenderer.HeaderLine(80, model, focus); + var footer = WorldsScreenRenderer.FooterLine(worlds, 0, 0, accent, 80, focus); + + var headerSaysEditing = header.Contains(ScreenChrome.EditingHints, StringComparison.Ordinal); + var footerSaysEditing = footer.Contains(ScreenChrome.CommitAction, StringComparison.Ordinal); + + await Assert.That(headerSaysEditing).IsEqualTo(footerSaysEditing); + await Assert.That(headerSaysEditing).IsEqualTo(focus?.Edit is not null); + } + } + + /// + /// A footer with a screen accent still swaps its verbs. F5 tints its ⏎ chip with the selected + /// world's colour, and the colour is the one thing that must *not* change what the chip says. + /// + [Test] + public async Task AnAccentedFooterSwapsItsVerbsToo() + { + var accented = ScreenChrome.Actions("#ff00ff", Editing); + + await Assert.That(accented).Contains("#ff00ff"); + await Assert.That(accented).Contains(ScreenChrome.CommitAction); + await Assert.That(accented).DoesNotContain(ScreenChrome.SaveAction); + } + + /// + /// ↑↓ is offered only by a field that has choices to step through. It is the same rule as ⇥, which + /// is offered only when the row holds another field: a hint for a key that would do nothing is the + /// bug this file is about, one keystroke smaller. + /// + [Test] + public async Task EditingHints_OfferTheChoiceKeysOnlyForAFieldThatHasChoices() + { + var free = ScreenChrome.Hints( + ScreenChrome.ListHints, "F5", true, new ScreenFocus(0, 0, new ScreenFieldEdit(0, "x", 1, null))); + var choices = ScreenChrome.Hints( + ScreenChrome.ListHints, + "F5", + true, + new ScreenFocus(0, 0, new ScreenFieldEdit(0, "main", 4, null, HasChoices: true))); + + await Assert.That(free).DoesNotContain(ScreenChrome.ChoiceHint); + await Assert.That(choices).Contains(ScreenChrome.ChoiceHint); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs index b31e0a92..10a05263 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs @@ -139,7 +139,11 @@ public async Task Worlds_HasWorldsThenCharactersThenTriggerSets() var model = WorldsScreenRenderer.Model(worlds, sets, selectedWorld: 0, selectedCharacter: 0); await Assert.That(model.PaneCount).IsEqualTo(3); - await Assert.That(model.Sizes).IsEquivalentTo(new[] { 2, 2, 1 }); + + // Two worlds then [+ world] / [- del]; two characters then [+ add] / [⧉ duplicate] / + // [- remove]. Buttons are appended after each list, so every index below still addresses + // the same item it always did. + await Assert.That(model.Sizes).IsEquivalentTo(new[] { 4, 5, 1 }); // Worlds are selection only — there is no checkbox on a world row. await Assert.That(model.ToggleAt(0, 0)).IsNull(); @@ -190,7 +194,9 @@ public async Task Worlds_CharacterAndTriggerSetPanesAreEmptyForAWorldWithNoChara { var model = WorldsScreenRenderer.Model(Worlds(), Sets(), selectedWorld: 1, selectedCharacter: 0); - await Assert.That(model.Sizes).IsEquivalentTo(new[] { 2, 0, 0 }); + // The character pane holds one row — [+ add character]. Duplicate and remove would act on + // nothing, so they aren't drawn and ⏎ can't land on a silent no-op. + await Assert.That(model.Sizes).IsEquivalentTo(new[] { 4, 1, 0 }); } [Test] diff --git a/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs b/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs new file mode 100644 index 00000000..dd7de97b --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs @@ -0,0 +1,259 @@ +using SharpMUTerm.Core.Automation; +using SharpMUTerm.Core.Configuration; +using SharpMUTerm.Core.Text; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// F2's route-to radio group and its highlight colour picker. Both were read-only indicators; both are +/// now fields on the rule's own list row, so they cycle with ↑↓ like any other choice and are drawn +/// where they are read. These assert the binding (what each ordinal writes), the choice set (what a +/// radio group offers), the colour round trip, and that the drawn radios follow the *buffer* rather +/// than config while an edit is open — otherwise ↑↓ would appear to do nothing until ⏎. +/// +public class TriggersScreenEditingTests +{ + private static ConsoleKeyInfo Key(ConsoleKey key) => new('\0', key, false, false, false); + + private static ConsoleKeyInfo Char(char c) => new(c, ConsoleKey.NoName, false, false, false); + + private static List Sets() => new() + { + new TriggerSet + { + Name = "Comms", + Triggers = new List + { + new() + { + Name = "Tell", + Pattern = "tells you", + Actions = new TriggerActions + { + SpawnTarget = "Chat", + HighlightForeground = TerminalColor.FromRgb(0xff, 0xd7, 0x00), + }, + }, + new() { Name = "Spam", Pattern = "guild", Actions = new TriggerActions() }, + }, + }, + }; + + private static readonly string[] Targets = { "Chat", "pages", "trade" }; + + [Test] + public async Task ARuleRowCarriesItsPatternRouteAndBothHighlightColours() + { + var sets = Sets(); + var model = TriggersScreenRenderer.Model(sets, 0, Targets); + + await Assert.That(model.RowAt(0, 0).FieldCount).IsEqualTo(4); + await Assert.That(model.FieldAt(0, 0, 0)!.Value.Get()).IsEqualTo("tells you"); + await Assert.That(model.FieldAt(0, 0, 1)!.Value.Get()).IsEqualTo("Chat"); + await Assert.That(model.FieldAt(0, 0, 2)!.Value.Get()).IsEqualTo("gold"); + await Assert.That(model.FieldAt(0, 0, 3)!.Value.Get()).IsEqualTo("none"); + + // The editor pane keeps exactly the two checkbox rows it had — the route and the colours are + // one setting each, so they are fields on the rule, not new cursor stops. + await Assert.That(model.Sizes[1]).IsEqualTo(2); + } + + [Test] + public async Task TheRouteGroupOffersMainEveryKnownWindowAndTheRulesOwnTarget() + { + var sets = Sets(); + + var known = TriggersScreenRenderer.Model(sets, 0, Targets).FieldAt(0, 0, 1)!.Value.Choices; + await Assert.That(known).IsEquivalentTo(new[] { "main", "Chat", "pages", "trade" }); + + // A rule pointed at a window the workspace has no record of still offers — and keeps — its own + // value, rather than being refused by its own field. + var unknown = TriggersScreenRenderer.Model(sets, 0).FieldAt(0, 0, 1)!.Value; + await Assert.That(unknown.Choices).IsEquivalentTo(new[] { "main", "Chat" }); + await Assert.That(unknown.Validate("Chat")).IsNull(); + } + + [Test] + public async Task ChoosingMainClearsTheSpawnTarget_AndUndoPutsItBack() + { + var sets = Sets(); + var trigger = sets[0].Triggers[0]; + var edits = new ScreenEdits(); + + edits.Apply(TriggersScreenRenderer.Model(sets, 0, Targets).FieldAt(0, 0, 1)!.Value, "main"); + await Assert.That(trigger.Actions.SpawnTarget).IsNull(); + + edits.Apply(TriggersScreenRenderer.Model(sets, 0, Targets).FieldAt(0, 0, 1)!.Value, "trade"); + await Assert.That(trigger.Actions.SpawnTarget).IsEqualTo("trade"); + + edits.Revert(); + await Assert.That(trigger.Actions.SpawnTarget).IsEqualTo("Chat"); + } + + [Test] + public async Task ARouteThatNamesNoWindowIsRefused() + { + var field = TriggersScreenRenderer.Model(Sets(), 0, Targets).FieldAt(0, 0, 1)!.Value; + + await Assert.That(field.Validate("nowhere")).IsNotNull(); + await Assert.That(new ScreenEdits().Apply(field, "nowhere")).IsNotNull(); + await Assert.That(Sets()[0].Triggers[0].Actions.SpawnTarget).IsEqualTo("Chat"); + } + + /// + /// ↑↓ steps the radio group, and the drawn radios follow the buffer — a group that only moved on + /// ⏎ would look inert for exactly as long as the user was using it. + /// + [Test] + public async Task UpAndDownStepTheRouteRadios_AndTheDrawnDotFollowsTheBuffer() + { + var sets = Sets(); + var trigger = sets[0].Triggers[0]; + var session = new SettingsSession( + selection => TriggersScreenRenderer.Model(sets, selection.CursorIn(0), Targets)); + + session.Handle(Key(ConsoleKey.Enter)); // opens the pattern + session.Handle(Key(ConsoleKey.Tab)); // commits it, steps to the route + await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("Chat"); + await Assert.That(session.Focus().Edit!.Value.HasChoices).IsTrue(); + + session.Handle(Key(ConsoleKey.DownArrow)); + await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("pages"); + + // Nothing is written yet, but the radios already show where ⏎ would land. + await Assert.That(trigger.Actions.SpawnTarget).IsEqualTo("Chat"); + var editor = TriggersScreenRenderer.EditorColumn(sets, 0, Targets, session.Focus()); + await Assert.That(editor.Any(l => l.Contains('●') && l.Contains("pages"))).IsTrue(); + await Assert.That(editor.Any(l => l.Contains('●') && l.Contains("Chat"))).IsFalse(); + + session.Handle(Key(ConsoleKey.Enter)); + await Assert.That(trigger.Actions.SpawnTarget).IsEqualTo("pages"); + + // Wrapping backwards off "main" lands on the last window, not on nothing. + session.Handle(Key(ConsoleKey.Enter)); + session.Handle(Key(ConsoleKey.Tab)); + session.Handle(Key(ConsoleKey.UpArrow)); + session.Handle(Key(ConsoleKey.UpArrow)); + await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("main"); + session.Handle(Key(ConsoleKey.UpArrow)); + await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("trade"); + } + + [Test] + public async Task TheHighlightPickerWritesAColour_AndNoneClearsIt() + { + var sets = Sets(); + var trigger = sets[0].Triggers[0]; + var edits = new ScreenEdits(); + + edits.Apply(TriggersScreenRenderer.Model(sets, 0, Targets).FieldAt(0, 0, 2)!.Value, "none"); + await Assert.That(trigger.Actions.HighlightForeground).IsNull(); + + edits.Apply(TriggersScreenRenderer.Model(sets, 0, Targets).FieldAt(0, 0, 3)!.Value, "blue"); + await Assert.That(trigger.Actions.HighlightBackground) + .IsEqualTo(TerminalColor.FromRgb(0x00, 0x00, 0xff)); + + edits.Revert(); + + await Assert.That(trigger.Actions.HighlightForeground) + .IsEqualTo(TerminalColor.FromRgb(0xff, 0xd7, 0x00)); + await Assert.That(trigger.Actions.HighlightBackground).IsNull(); + } + + /// + /// The palette is a shortlist, not a straitjacket. A colour already in config that the palette + /// doesn't name has to open on its own value and commit unchanged, or an existing highlight would + /// be uneditable — the picker would refuse the value it was showing. + /// + [Test] + public async Task AColourThePaletteDoesNotNameStillRoundTrips() + { + var sets = Sets(); + sets[0].Triggers[0].Actions.HighlightForeground = TerminalColor.FromRgb(0x12, 0x34, 0x56); + var field = TriggersScreenRenderer.Model(sets, 0, Targets).FieldAt(0, 0, 2)!.Value; + + await Assert.That(field.Get()).IsEqualTo("#123456"); + await Assert.That(field.Validate(field.Get())).IsNull(); + + new ScreenEdits().Apply(field, "idx:200"); + await Assert.That(sets[0].Triggers[0].Actions.HighlightForeground) + .IsEqualTo(TerminalColor.FromIndex(200)); + + await Assert.That(field.Validate("chartreuse")).IsNotNull(); + } + + [Test] + public async Task TheEditorDrawsBothSwatchRowsWhetherOrNotAColourIsSet() + { + var sets = Sets(); + var editor = TriggersScreenRenderer.EditorColumn(sets, 1, Targets); + + // Trigger 1 has no highlight at all — the rows are still there, because they are now where a + // colour is turned on rather than a report that one already is. + await Assert.That(editor.Any(l => l.Contains("fg") && l.Contains("none"))).IsTrue(); + await Assert.That(editor.Any(l => l.Contains("bg") && l.Contains("none"))).IsTrue(); + await Assert.That(editor.Any(l => l.Contains("[dim][[ ]] highlight line[/]"))).IsTrue(); + } + + [Test] + public async Task ARejectedColourIsReportedAgainstTheHighlightHeading() + { + var sets = Sets(); + var session = new SettingsSession( + selection => TriggersScreenRenderer.Model(sets, selection.CursorIn(0), Targets)); + + session.Handle(Key(ConsoleKey.Enter)); + session.Handle(Key(ConsoleKey.Tab)); + session.Handle(Key(ConsoleKey.Tab)); // pattern → route → highlight fg + for (var i = 0; i < 4; i++) + { + session.Handle(Key(ConsoleKey.Backspace)); + } + + foreach (var c in "nope") + { + session.Handle(Char(c)); + } + + session.Handle(Key(ConsoleKey.Enter)); + + await Assert.That(session.IsEditing).IsTrue(); + var editor = TriggersScreenRenderer.EditorColumn(sets, 0, Targets, session.Focus()); + await Assert.That(editor.Any(l => l.Contains("highlight") && l.Contains('▲'))).IsTrue(); + } + + [Test] + public async Task ScreenColours_FormatAndParseAgreeOnNamesLiteralsAndNothing() + { + await Assert.That(ScreenColours.Format(null)).IsEqualTo("none"); + await Assert.That(ScreenColours.Format(TerminalColor.FromRgb(0xff, 0xd7, 0x00))).IsEqualTo("gold"); + await Assert.That(ScreenColours.Format(TerminalColor.FromRgb(0x12, 0x34, 0x56))).IsEqualTo("#123456"); + // An indexed colour stays indexed, even where the palette happens to resolve to the same RGB: + // idx:9 is "whatever the terminal calls bright red", which is not the same promise as #ff0000. + await Assert.That(ScreenColours.Format(TerminalColor.FromIndex(9))).IsEqualTo("idx:9"); + await Assert.That(ScreenColours.Format(TerminalColor.FromIndex(200))).IsEqualTo("idx:200"); + await Assert.That(ScreenColours.Format(TerminalColor.Default)).IsEqualTo("default"); + + foreach (var name in ScreenColours.Palette) + { + await Assert.That(ScreenColours.TryParse(name, out var parsed)).IsTrue(); + await Assert.That(ScreenColours.Format(parsed)).IsEqualTo(name); + } + + await Assert.That(ScreenColours.TryParse("chartreuse", out _)).IsFalse(); + await Assert.That(ScreenColours.TryParse("idx:999", out _)).IsFalse(); + } + + /// + /// A swatch shows the colour the terminal will actually paint. An indexed colour resolving to the + /// app accent would draw every palette highlight the same shade of teal. + /// + [Test] + public async Task AnIndexedSwatchResolvesThroughTheXtermPaletteRatherThanTheAccent() + { + await Assert.That(ScreenColours.Hex(TerminalColor.FromIndex(196), "#00f5b7")).IsEqualTo("#ff0000"); + await Assert.That(ScreenColours.Hex(TerminalColor.FromRgb(1, 2, 3), "#00f5b7")).IsEqualTo("#010203"); + await Assert.That(ScreenColours.Hex(TerminalColor.Default, "#00f5b7")).IsEqualTo("#00f5b7"); + } +} From 7843a51394356d37af704bd176c883f79da97bf0 Mon Sep 17 00:00:00 2001 From: Harry Cordewener Date: Tue, 28 Jul 2026 19:06:54 -0500 Subject: [PATCH 12/23] F2: route-to takes a typed window name, not a fixed choice MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The route field was a closed Choice over SpawnTargets(), which is "distinct spawn-window targets referenced by any trigger" -- so the only windows offerable were ones some trigger already routed to. There was no way to create a new spawn window from the settings screen at all. It is now free text with the known windows as ↑↓ suggestions, following the pattern the colour picker already set: the palette is what ↑↓ steps through, but the validator deliberately accepts more than the palette offers. A window name is a tab title, so it is refused when blank or carrying control characters, and is otherwise whatever the user calls it. Fixes the display bug that fell out of the change: the radios light the row whose label equals the buffer, so a name being typed for the first time matched none of them and was invisible -- the group sat with no dot lit while the keyboard was plainly doing something. A buffer matching no known window now gets its own row carrying the caret, so what is being typed appears where the committed value will. Replaces the test that pinned the old rule (an unknown route refused) with three: an unknown name commits, blank and control characters are refused, and a first-time name is visible while being typed. 846 tests pass. Co-Authored-By: Claude Opus 5 (1M context) --- src/SharpMUTerm.Tui/ScreenField.cs | 28 +++++++++ src/SharpMUTerm.Tui/TriggersScreenRenderer.cs | 29 ++++++--- .../TriggersScreenEditingTests.cs | 60 ++++++++++++++++++- 3 files changed, 107 insertions(+), 10 deletions(-) diff --git a/src/SharpMUTerm.Tui/ScreenField.cs b/src/SharpMUTerm.Tui/ScreenField.cs index 2b181807..82961bf0 100644 --- a/src/SharpMUTerm.Tui/ScreenField.cs +++ b/src/SharpMUTerm.Tui/ScreenField.cs @@ -112,6 +112,34 @@ internal static ScreenField Optional(string label, Func get, Action + /// The name of a window to route output to. Free text, with the windows already in use offered + /// as ↑↓ suggestions — deliberately not a , because the set of spawn windows + /// is defined by what triggers route to, so a closed list could only ever re-use a window that + /// already exists and there would be no way to create one. + /// + /// A window name is a tab title, so it is rejected when blank or when it carries control + /// characters that would corrupt the tab strip; it is otherwise whatever the user calls it. + /// + /// + internal static ScreenField WindowName( + string label, Func get, Action set, IReadOnlyList known) + { + ArgumentNullException.ThrowIfNull(get); + ArgumentNullException.ThrowIfNull(set); + ArgumentNullException.ThrowIfNull(known); + + return new ScreenField( + label, + get, + value => string.IsNullOrWhiteSpace(value) + ? $"{label} cannot be empty" + : value.Any(char.IsControl) ? $"{label} cannot contain control characters" : null, + value => set(value.Trim()), + Restore(get, set), + known); + } + /// /// A .NET regular expression, rejected unless it actually compiles — a trigger or alias whose /// pattern doesn't parse would throw on the next line the engine matched, not here. diff --git a/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs b/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs index ac25e109..83a7c858 100644 --- a/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs @@ -41,10 +41,14 @@ internal static class TriggersScreenRenderer private static string Route(Trigger trigger) => trigger.Actions.SpawnTarget ?? MainWindow; /// - /// The windows a rule may be routed to: the main output, every spawn window the workspace knows - /// about, and — always — the one this rule already points at, so a rule routed somewhere the - /// current workspace has no window for still shows (and can commit) its own value rather than - /// being refused by its own field. + /// The windows offered as ↑↓ suggestions on the route field: the main output, every spawn window + /// the workspace knows about, and — always — the one this rule already points at, so a rule + /// routed somewhere the current workspace has no window for still shows its own value. + /// + /// These are suggestions, not the permitted set. Typing a name that isn't here is how a new spawn + /// window comes into existence: the workspace's spawn windows are defined by what triggers route + /// to, so a closed list could only ever re-use one that already exists. + /// /// internal static IReadOnlyList Routes(Trigger trigger, IReadOnlyList? spawnTargets) { @@ -137,10 +141,10 @@ internal static ScreenModel Model( ScreenToggle.Bind(() => entry.Trigger.Enabled, v => entry.Trigger.Enabled = v), ScreenField.Pattern( "match pattern", () => entry.Trigger.Pattern, v => entry.Trigger.Pattern = v), - ScreenField.Choice( + ScreenField.WindowName( "route", () => Route(entry.Trigger), - v => entry.Trigger.Actions.SpawnTarget = v == MainWindow ? null : v, + v => entry.Trigger.Actions.SpawnTarget = v == MainWindow ? null : v.Trim(), Routes(entry.Trigger, spawnTargets)), ScreenField.Colour( "highlight fg", @@ -306,11 +310,22 @@ private static List BuildEditor( Heading("route to", route), }; - foreach (var target in Routes(trigger, spawnTargets)) + var known = Routes(trigger, spawnTargets); + foreach (var target in known) { lines.Add(RouteRow(target, currentRoute, route is not null)); } + // A route may name a window that doesn't exist yet — that is how a spawn window is created. + // The rows above are the windows already in use, so a name being typed for the first time + // matches none of them and would otherwise be invisible: the group would sit with no dot lit + // while the keyboard was plainly doing something. Give the new name its own row, carrying the + // caret, so what is being typed is on screen where the committed value will be. + if (route is { } typing && !known.Contains(currentRoute, StringComparer.Ordinal)) + { + lines.Add($" [{Accent}]●[/] {ScreenChrome.Field(Escape(currentRoute), typing)}"); + } + var fg = trigger.Actions.HighlightForeground; var bg = trigger.Actions.HighlightBackground; diff --git a/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs b/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs index dd7de97b..f9600e56 100644 --- a/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs @@ -91,16 +91,70 @@ public async Task ChoosingMainClearsTheSpawnTarget_AndUndoPutsItBack() await Assert.That(trigger.Actions.SpawnTarget).IsEqualTo("Chat"); } + /// + /// Typing a window nothing routes to yet is how a spawn window is created — the suggestions are + /// the windows already in use, so refusing anything outside them could only ever re-use a window + /// that already existed. + /// + [Test] + public async Task ARouteMayNameAWindowThatDoesNotExistYet() + { + var sets = Sets(); + var trigger = sets[0].Triggers[0]; + var field = TriggersScreenRenderer.Model(sets, 0, Targets).FieldAt(0, 0, 1)!.Value; + + await Assert.That(field.Validate("nowhere")).IsNull(); + await Assert.That(new ScreenEdits().Apply(field, "nowhere")).IsNull(); + await Assert.That(trigger.Actions.SpawnTarget).IsEqualTo("nowhere"); + } + + /// A window name is a tab title, so the two things that would corrupt one are refused. [Test] - public async Task ARouteThatNamesNoWindowIsRefused() + public async Task ARouteIsRefusedWhenBlankOrCarryingControlCharacters() { var field = TriggersScreenRenderer.Model(Sets(), 0, Targets).FieldAt(0, 0, 1)!.Value; - await Assert.That(field.Validate("nowhere")).IsNotNull(); - await Assert.That(new ScreenEdits().Apply(field, "nowhere")).IsNotNull(); + await Assert.That(field.Validate(" ")).IsNotNull(); + await Assert.That(field.Validate("chat\tspam")).IsNotNull(); + await Assert.That(new ScreenEdits().Apply(field, string.Empty)).IsNotNull(); await Assert.That(Sets()[0].Triggers[0].Actions.SpawnTarget).IsEqualTo("Chat"); } + /// + /// Typing a window that doesn't exist yet must be visible. The radio rows are the windows already + /// in use, so a new name matches none of them — without a row of its own the group would sit with + /// no dot lit while the keyboard was plainly doing something, and the user would type blind. + /// + [Test] + public async Task TypingARouteThatMatchesNoKnownWindowStillShowsWhatIsBeingTyped() + { + var sets = Sets(); + var session = new SettingsSession( + selection => TriggersScreenRenderer.Model(sets, selection.CursorIn(0), Targets)); + + session.Handle(Key(ConsoleKey.Enter)); // opens the pattern + session.Handle(Key(ConsoleKey.Tab)); // commits it, steps to the route + + // Clear the opened value ("Chat") before typing, as anyone renaming the route would. + for (var i = 0; i < "Chat".Length; i++) + { + session.Handle(Key(ConsoleKey.Backspace)); + } + + foreach (var ch in "combat") + { + session.Handle(Char(ch)); + } + + await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("combat"); + + var editor = TriggersScreenRenderer.EditorColumn(sets, 0, Targets, session.Focus()); + await Assert.That(editor.Any(l => l.Contains("combat"))).IsTrue(); + + // No known window is lit while the buffer names one that doesn't exist yet. + await Assert.That(editor.Any(l => l.Contains('●') && l.Contains("Chat"))).IsFalse(); + } + /// /// ↑↓ steps the radio group, and the drawn radios follow the buffer — a group that only moved on /// ⏎ would look inert for exactly as long as the user was using it. From 7137b65396a652f099dc5094b84dc51bf181d5b8 Mon Sep 17 00:00:00 2001 From: Harry Cordewener Date: Tue, 28 Jul 2026 19:39:58 -0500 Subject: [PATCH 13/23] Settings screens: make read-only rows look read-only MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Every screen drew "label value" identically whether or not you could change it, so the only way to learn what was editable was to walk the cursor into it. F5's security, password and session rows looked exactly like host and port; F2's highlight indicator and F9's auto-start box looked like toggles you could press and were not. The field well is now the affordance, drawn at rest rather than only mid-edit: an editable value sits on FieldBg, a value you cannot change where it is drawn gets muted ink and no well. Defined once in ScreenChrome.Field/ReadOnly so no renderer invents its own. Opening a field keeps the same well and adds the caret, so ⏎ deepens what is already on screen instead of conjuring it, and nothing shifts. Scoped to label/value rows -- checkboxes and radio groups already carry their own affordance. The two derived indicators stop pretending to be checkboxes: - F2's "highlight line" becomes a muted caption on the highlight section, and moves above the two swatch rows it summarises. It sat below the values it derived from, which read backwards. - F9's "auto-start on connect" merges into the format row. That one was genuinely pressable; the bug was two rows owning one stored value, so setting format to None silently unchecked a box three lines down. It is now one row: Space starts and stops logging, ⏎ picks the format. Drops the "‹ back" affordance, which appeared only on F7-F9 and pointed nowhere -- there is no navigation stack, Esc closes. Footer context lines are now one shape across all eight screens: position plus the one qualifier identifying the selection, with a test pinning it. 857 tests pass, up from 846. Four existing assertions were re-aimed rather than deleted, each pinning behaviour this change removes on purpose; three are inverted so the old behaviour cannot return. Co-Authored-By: Claude Opus 5 (1M context) --- CLAUDE.md | 3 +- docs/HANDOFF.md | 46 ++- src/SharpMUTerm.Tui/AliasesScreenRenderer.cs | 16 +- src/SharpMUTerm.Tui/KeypadScreenRenderer.cs | 43 ++- src/SharpMUTerm.Tui/OptionsScreenRenderer.cs | 136 ++++++-- src/SharpMUTerm.Tui/ScreenChrome.cs | 64 +++- src/SharpMUTerm.Tui/ScreenPalette.cs | 18 +- src/SharpMUTerm.Tui/TimersScreenRenderer.cs | 6 +- src/SharpMUTerm.Tui/TriggersScreenRenderer.cs | 53 ++- src/SharpMUTerm.Tui/WorldsScreenRenderer.cs | 25 +- .../OptionsScreenRendererTests.cs | 8 +- .../SharpMUTerm.Tui.Tests/ScreenModelTests.cs | 25 +- .../ScreenReadOnlyTests.cs | 328 ++++++++++++++++++ .../TriggersScreenEditingTests.cs | 6 +- .../TriggersScreenRendererTests.cs | 14 +- 15 files changed, 675 insertions(+), 116 deletions(-) create mode 100644 tests/SharpMUTerm.Tui.Tests/ScreenReadOnlyTests.cs diff --git a/CLAUDE.md b/CLAUDE.md index ba385f5a..11328ecb 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -32,8 +32,7 @@ fallbacks) for inline images/maps. ## Repository state **M1 delivered, plus substantial M2–M4 work.** `SharpMUTerm.slnx` builds all ten projects on -`net10.0`; the solution has **844 tests** (842 passing — see `docs/HANDOFF.md` -backlog item 1 for the two that are failing on purpose). In place: +`net10.0`; the solution has **857 tests**, all passing. In place: - **Core** — `AnsiParser` (SGR 16/256/truecolor), styled-line + `ScrollbackBuffer` model, `TcpTransport` (TLS + IPv6), `TelnetSession` (wraps TelnetNegotiationCore **2.5.3**), diff --git a/docs/HANDOFF.md b/docs/HANDOFF.md index bb1183f3..472b9954 100644 --- a/docs/HANDOFF.md +++ b/docs/HANDOFF.md @@ -4,9 +4,8 @@ Context for whoever (human or agent) picks up this work next. - **Repository:** `SharpMUSH/SharpMUTerm` - **Start from:** a fresh branch off `main` -- **Tests:** 844 across the solution (330 Core / 83 Graphics / 42 Scripting / - 28 Web / 361 Tui). **Two fail on purpose** — see backlog item 1; they are the - pinned row counts the F5 button rows change, left for a human to renumber; `dotnet build SharpMUTerm.slnx` clean (0 warnings +- **Tests:** 857 across the solution (330 Core / 83 Graphics / 42 Scripting / + 28 Web / 374 Tui), all passing; `dotnet build SharpMUTerm.slnx` clean (0 warnings from this repo; building against a local SharpConsoleUI clone surfaces 2 upstream NuGet advisory warnings for AngleSharp, which are the framework's, not ours) @@ -19,18 +18,15 @@ polish/feature backlog. ### 1. Field editing on the config screens -**Done**, apart from one decision that needs a human — see *Settings screens* -under Critical Gotchas for how the whole thing works. +**Done** — see *Settings screens* under Critical Gotchas for how the whole thing +works. - **Add/remove rows** are live. `[+ world]` / `[- del]` and `[+ add character]` / `[⧉ duplicate]` / `[- remove]` are `ScreenRow`s carrying a `ScreenButton`; ⏎ - runs one. **BLOCKED ON A DECISION:** giving the two F5 list panes button rows - necessarily changes two pinned row-count assertions in `ScreenModelTests` — - `Worlds_HasWorldsThenCharactersThenTriggerSets` (`{2,2,1}` → `{4,5,1}`) and - `Worlds_CharacterAndTriggerSetPanesAreEmptyForAWorldWithNoCharacters` - (`{2,0,0}` → `{4,1,0}`). Those two assertions are **deliberately left failing** - rather than quietly renumbered; update them (or reject the shape) and the item - closes. + runs one. The button rows changed two pinned row-count assertions in + `ScreenModelTests` (`Worlds_HasWorldsThenCharactersThenTriggerSets` `{2,2,1}` → + `{4,5,1}`, `Worlds_CharacterAndTriggerSetPanesAreEmptyForAWorldWithNoCharacters` + `{2,0,0}` → `{4,1,0}`); the shape was accepted and the counts renumbered. - **F2's route-to radios and highlight-colour picker** are live, as `Choice` and `Colour` fields on the *rule's own list row* (ordinals: pattern, route, highlight fg, highlight bg). ↑↓ cycle them, which is exactly radio and palette @@ -39,7 +35,8 @@ under Critical Gotchas for how the whole thing works. key-capture mode, not a text buffer), a character's password (it is `[JsonIgnore]` and belongs in a credential store), a world's TLS/certificate "security" line (two booleans, so checkboxes, not a field), and everything - derived (the numpad grid, the session/state readouts). + derived (the numpad grid, the session/state readouts). **All of them now say + so on screen** — see *Editable vs read-only rows* under Critical Gotchas. ### 2. Real-terminal verification still owed @@ -314,6 +311,29 @@ What the framework actually provides (read at v2.5.14, not assumed): ⏎/⇥/⌃S validate. A rejected value keeps the edit open, marks the field with the reason, and writes nothing — `ScreenEdits.Apply(field, value)` is the only path from a buffer into config, which is what keeps an invalid one out. +- **Editable vs read-only rows: the well is the rule.** An editable value is drawn + in a **field well** (`ScreenPalette.FieldBg`, applied by `ScreenChrome.Field` — + at rest, not only mid-edit); a value the keyboard cannot change *there* is drawn + by `ScreenChrome.ReadOnly` in the muted ink with **no** well. Opening a field + keeps the same well and adds the accent block caret, so ⏎ deepens the affordance + already on screen instead of conjuring one. The rule is scoped to rows that read + `label value` — a checkbox and a radio group already carry an affordance of + their own, so F2's route radios and F5's list rows are left alone. + `ScreenReadOnlyTests` pins both halves; add a read-only row and it must go + through `ReadOnly`, or the well/no-well counts stop matching. +- **A derived indicator is never a checkbox.** A checkbox promises Space does + something. F2's highlight summary is a **caption on the `highlight` section** + (above the two swatch rows it derives from, not below them); F9's auto-start is + now the `format` row's *own* toggle — one row, one stored value, Space for + on/off and ⏎ for which format — rather than a second row mirroring the first. + `OptionRow` carrying both a `Bind` and an `Edit` is what makes that one row. +- **Footer context lines all answer "where is the cursor".** + `ScreenChrome.Position`/`Context` build them: ` i/n`, then whatever + identifies the selection (`set Comms`, `character 1/2`, the option's section, + the binding's name). F4 and F7–F9 used to report an inventory instead + (`9 bindings · 8 of 9 numpad keys bound`, `3 options · 1 section`). +- **There is no `‹ back`.** F7/F8/F9 drew one; nothing else did, and there is no + navigation stack behind a settings screen — Esc closes it. - **Header hints are derived, not written.** `HeaderLine(width, model, focus)` reads `model.HasEditableRow`, so a screen physically cannot advertise `⏎ edit` without offering one; `ScreenCursorTests` asserts the *if and only if* both ways. diff --git a/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs b/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs index 3e1833d7..47e3f829 100644 --- a/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs @@ -1,4 +1,3 @@ -using System.Globalization; using SharpMUTerm.Core.Automation; using SharpMUTerm.Core.Configuration; using static SharpMUTerm.Tui.MarkupText; @@ -103,9 +102,9 @@ internal static string FooterLine( var context = string.Empty; if (entries.Count > 0 && selected >= 0 && selected < entries.Count) { - var count = entries.Count.ToString(CultureInfo.InvariantCulture); - context = $"[{Label}]alias {(selected + 1).ToString(CultureInfo.InvariantCulture)}/{count}[/]" - + $"[{Label}] · set {Escape(entries[selected].SetName)}[/]"; + context = ScreenChrome.Context( + ScreenChrome.Position("alias", selected, entries.Count), + "set " + Escape(entries[selected].SetName)); } var actions = ScreenChrome.Actions(focus: focus); @@ -197,10 +196,11 @@ private static List BuildEditor(Alias alias, ScreenFocus cursor, int sel } else { - foreach (var line in alias.Substitution.Split('\n')) - { - lines.Add($" {Escape(line)}"); - } + // Listed, the expansion is still one editable value, so it still gets one field well — + // every row padded to the longest, or the well would be ragged and read as several. + var commands = alias.Substitution.Split('\n').Select(Escape).ToList(); + var width = commands.Count == 0 ? 0 : commands.Max(c => VisibleLength(c)); + lines.AddRange(commands.Select(c => " " + ScreenChrome.Field(PadVisible(c, width), null))); } lines.Add(string.Empty); diff --git a/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs b/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs index a9e7b9af..f301dc43 100644 --- a/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs @@ -1,4 +1,3 @@ -using System.Globalization; using SharpMUTerm.Core.Automation; using static SharpMUTerm.Tui.MarkupText; using static SharpMUTerm.Tui.ScreenPalette; @@ -88,27 +87,32 @@ internal static ScreenModel Model(IReadOnlyList macros) ScreenField.Text("command", () => macro.Command, v => macro.Command = v)))); } - /// The action bar: how much of the keypad is bound on the left, cancel/save on the right. + /// + /// The action bar: where the cursor is in the binding list on the left, cancel/save on the right. + /// It used to report the screen's inventory instead (9 bindings · 8 of 9 numpad keys bound), + /// which the numpad grid two columns over already shows cell by cell; every other screen answers + /// "where am I", so this one does too. The selected binding comes from + /// rather than a parameter of its own, because the cursor is the only thing that decides it. + /// + /// The qualifier is the macro's name, which is the one thing about a binding this screen + /// doesn't otherwise show — its rows are key → command. A macro that has never been named falls + /// back to its key, because an empty qualifier would leave the footer saying less than it could. + /// + /// internal static string FooterLine(IReadOnlyList macros, int width, ScreenFocus? focus = null) { ArgumentNullException.ThrowIfNull(macros); - var bound = 0; - foreach (var row in NumpadRows) + var context = string.Empty; + if (macros.Count > 0) { - foreach (var digit in row) - { - if (FindByKey(macros, $"Num{digit}") is not null) - { - bound++; - } - } + var selected = Math.Clamp(focus?.Pane == 0 ? focus.Value.Index : 0, 0, macros.Count - 1); + var macro = macros[selected]; + var names = string.IsNullOrWhiteSpace(macro.Name) ? macro.Key : macro.Name; + context = ScreenChrome.Context( + ScreenChrome.Position("binding", selected, macros.Count), Escape(names)); } - var total = macros.Count.ToString(CultureInfo.InvariantCulture); - var context = $"[{Label}]{total} bindings[/]" - + $"[{Label}] · {bound.ToString(CultureInfo.InvariantCulture)} of 9 numpad keys bound[/]"; - var actions = ScreenChrome.Actions(focus: focus); return SpreadLR(" " + context, actions, width); } @@ -165,10 +169,17 @@ private static string NumpadRow(int[] digits, IReadOnlyList macros) return string.Join(NumpadCellGap, cells); } + /// + /// One cell of the numpad diagram. The command is drawn as a readout, not a field: the grid mirrors + /// the binding list beside it and has no cursor of its own, so a cell is somewhere a command is + /// *shown*, never somewhere one is typed. See . + /// private static string NumpadCell(int digit, IReadOnlyList macros) { var macro = FindByKey(macros, $"Num{digit}"); - var command = macro is null ? "[dim]—[/]" : Escape(Truncate(macro.Command, NumpadCommandWidth)); + var command = macro is null + ? "[dim]—[/]" + : ScreenChrome.ReadOnly(Truncate(macro.Command, NumpadCommandWidth)); return $"[bold {Accent}][[{digit}]][/] {command}"; } diff --git a/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs b/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs index 48d30753..27249702 100644 --- a/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs @@ -1,4 +1,3 @@ -using System.Globalization; using SharpMUTerm.Core.Configuration; using static SharpMUTerm.Tui.MarkupText; using static SharpMUTerm.Tui.ScreenPalette; @@ -16,13 +15,28 @@ namespace SharpMUTerm.Tui; /// internal static class OptionsScreenRenderer { + /// Where a row's value starts, measured from the left edge of the list. private const int LabelWidth = 28; /// - /// A single options-list row: a toggle, a value row, a section header, or a spacer. + /// The checkbox column every row reserves, whether or not it has one: "[[x]] ". A value row + /// indents past it rather than starting at the margin, so the labels of the two kinds of row line + /// up in one column and the checkboxes read as a column of their own instead of as a ragged edge. + /// + private const int AffordanceWidth = 4; + + /// + /// A single options-list row: a toggle, a value row, both at once, a section header, or a spacer. /// is the config the checkbox writes to; is the /// config the value writes to, which is what makes a value row activatable with ⏎. A row with /// neither still takes the cursor but nothing happens there. + /// + /// A row carrying both is F9's log format: Space starts and stops logging, ⏎ picks the format it + /// writes. They were two rows — a format value and an auto-start on connect checkbox + /// whose state was simply format != None — which is two controls over one stored value, and + /// nothing on screen said they were the same setting. The keypad's bindings are the same shape + /// (Space enables the macro, ⏎ edits its command), so already supports it. + /// /// public readonly record struct OptionRow( string Label, @@ -55,15 +69,20 @@ public static List Render(string title, string fkey, IReadOnlyList Render(OptionsScreen screen) => Render(screen.Title, screen.FKey, screen.Rows); /// - /// The back affordance and screen title on the left, the keyboard hints right-aligned to - /// . The hints are derived from and - /// rather than written here, so the header cannot advertise an edit the - /// screen doesn't offer; called without them it describes a screen that only navigates. + /// The screen title on the left, the keyboard hints right-aligned to . The + /// hints are derived from and rather than written + /// here, so the header cannot advertise an edit the screen doesn't offer; called without them it + /// describes a screen that only navigates. + /// + /// There is deliberately no ‹ back affordance. These three screens were the only ones that + /// drew one, and it pointed nowhere: there is no navigation stack behind a settings screen, Esc + /// closes it, and the header already says so two columns to the right. + /// /// internal static string HeaderLine( string title, string fkey, int width, ScreenModel? model = null, ScreenFocus? focus = null) { - var heading = $"[{Label}]‹ back[/] [bold {Value}]{Escape(title)}[/]"; + var heading = $"[bold {Value}]{Escape(title)}[/]"; var hints = ScreenChrome.Hints( ScreenChrome.SingleListHints, Escape(fkey), @@ -72,22 +91,60 @@ internal static string HeaderLine( return SpreadLR(" " + heading, hints, width); } - /// The action bar: how much the screen holds on the left, cancel/save on the right. + /// + /// The action bar: where the cursor is in the options list on the left, cancel/save on the right. + /// It used to be an inventory (5 options · 2 sections); the section count was noise — the + /// headings are on screen and counting them tells nobody anything — and the option count answered a + /// different question from every other screen's footer. It now names the cursor's position and the + /// section it is standing in, which is F2's trigger 1/4 · set Comms in this screen's nouns. + /// The selected row comes from , the only thing that knows it. + /// internal static string FooterLine(IReadOnlyList rows, int width, ScreenFocus? focus = null) { ArgumentNullException.ThrowIfNull(rows); var options = rows.Count(r => !IsSpacer(r) && !IsSection(r)); - var sections = rows.Count(IsSection); - var context = $"[{Label}]{Plural(options, "option")}[/]"; - if (sections > 0) + var context = string.Empty; + if (options > 0) { - context += $"[{Label}] · {Plural(sections, "section")}[/]"; + var selected = Math.Clamp(focus?.Pane == 0 ? focus.Value.Index : 0, 0, options - 1); + context = ScreenChrome.Context( + ScreenChrome.Position("option", selected, options), SectionOf(rows, selected)); } return SpreadLR(" " + context, ScreenChrome.Actions(focus: focus), width); } + /// + /// The section heading the nth navigable row sits under, without the branch glyph that marks it as + /// one — or null on a screen whose rows aren't grouped. + /// + private static string? SectionOf(IReadOnlyList rows, int selected) + { + string? section = null; + var navigable = 0; + foreach (var row in rows) + { + if (IsSection(row)) + { + section = Escape(row.Label[2..]); + continue; + } + + if (IsSpacer(row)) + { + continue; + } + + if (navigable++ == selected) + { + return section; + } + } + + return null; + } + /// /// The options list itself — one line per row, in order. The row under the keyboard cursor is /// drawn on a cursor bar padded to ; spacers and section headers are @@ -131,6 +188,11 @@ internal static ScreenModel Model(OptionsScreen screen) return new ScreenModel(rows); } + /// + /// One row: its checkbox column (a box, or the blank that keeps the labels in one column), its + /// label, the value it holds if it holds one, and its hint. A row can carry both a checkbox and a + /// value, which is how F9 draws one setting as one row. + /// private static string RenderRow(OptionRow row, ScreenFieldEdit? edit) { if (IsSpacer(row)) @@ -143,17 +205,25 @@ private static string RenderRow(OptionRow row, ScreenFieldEdit? edit) return $"[dim]{Escape(row.Label)}[/]"; } - var hint = row.Hint is null ? string.Empty : $"[dim] — {Escape(row.Hint)}[/]"; + var box = row.Toggle switch + { + true => $"[{Accent}][[x]][/] ", + false => "[dim][[ ]][/] ", + null => new string(' ', AffordanceWidth), + }; - if (row.Toggle is { } toggle) + var hint = row.Hint is null ? string.Empty : $"[dim] — {Escape(row.Hint)}[/]"; + var hasValue = row.Value is not null || edit is not null; + var label = Escape(row.Label); + // A checkbox row's label *is* its content, so it keeps the primary ink; a label/value row's + // label is the secondary half of a pair, so it dims and lets the value carry the weight. + if (!hasValue) { - var box = toggle ? $"[{Accent}][[x]][/]" : "[dim][[ ]][/]"; - return $"{box} {Escape(row.Label)}{hint}"; + return $"{box}{label}{hint}"; } - var label = Escape(row.Label).PadRight(LabelWidth); var value = ScreenChrome.Field(Escape(row.Value ?? string.Empty), edit); - return $"[dim]{label}[/] {value}{hint}"; + return $"{box}[dim]{label.PadRight(LabelWidth - AffordanceWidth)}[/] {value}{hint}"; } /// A blank separator carrying no label, value, or toggle. @@ -226,14 +296,24 @@ internal static OptionsScreen InputSpellcheckScreen(InputSettings? input = null) }); } - /// The F9 "Logging" screen, reflecting a character's . + /// + /// The F9 "Logging" screen, reflecting a character's . Its two rows + /// are its two settings: the log format — whose checkbox starts and stops logging, because + /// *is* "off" — and where the file goes. + /// + /// The format and the auto-start checkbox used to be separate rows over the same stored value, and + /// nothing said so: setting the format to None silently unchecked a box three lines down. + /// One row, one value, two keys — Space for on/off, ⏎ for which format — leaves nothing derived to + /// keep in sync. + /// + /// internal static OptionsScreen LoggingScreen(LoggingSettings logging) { ArgumentNullException.ThrowIfNull(logging); - // "Auto-start" is really the log format: off means None, on means whatever format was last - // chosen (Plain when there isn't one). The binding's snapshot restores the *format*, not the - // boolean, so cancelling a toggle-off puts Html back rather than downgrading it to Plain. + // Off means None, on means whatever format was last chosen (Plain when there isn't one). The + // binding's snapshot restores the *format*, not the boolean, so cancelling a toggle-off puts + // Html back rather than downgrading it to Plain. var chosen = logging.Format == LogFormat.None ? LogFormat.Plain : logging.Format; var autoStart = new ScreenToggle( () => logging.Format != LogFormat.None, @@ -247,11 +327,12 @@ internal static OptionsScreen LoggingScreen(LoggingSettings logging) return new OptionsScreen("Logging", "F9", new List { new("├ SESSION LOG", null, null), - new("format", logging.Format.ToString(), null, null, null, + new("format", logging.Format.ToString(), logging.Format != LogFormat.None, + "auto-start on connect", + autoStart, ScreenField.Enumeration("format", () => logging.Format, v => logging.Format = v)), new("directory", logging.Directory ?? "(default)", null, null, null, ScreenField.Optional("directory", () => logging.Directory, v => logging.Directory = v)), - new("auto-start on connect", null, logging.Format != LogFormat.None, null, autoStart), }); } @@ -263,11 +344,4 @@ internal static OptionsScreen LoggingScreen(LoggingSettings logging) /// The F9 "Logging" screen body, reflecting a character's . public static List Logging(LoggingSettings logging) => Render(LoggingScreen(logging)); - - /// Counts a noun for the footer: 1 option, 3 options. - private static string Plural(int count, string noun) - { - var n = count.ToString(CultureInfo.InvariantCulture); - return count == 1 ? $"{n} {noun}" : $"{n} {noun}s"; - } } diff --git a/src/SharpMUTerm.Tui/ScreenChrome.cs b/src/SharpMUTerm.Tui/ScreenChrome.cs index d5163036..5fed5efc 100644 --- a/src/SharpMUTerm.Tui/ScreenChrome.cs +++ b/src/SharpMUTerm.Tui/ScreenChrome.cs @@ -1,3 +1,4 @@ +using System.Globalization; using SharpConsoleUI; using SharpConsoleUI.Builders; using SharpConsoleUI.Controls; @@ -108,10 +109,18 @@ internal static string Cursor(string row, bool focused, int width) => focused ? $"[on {ScreenPalette.CursorBg}]{MarkupText.PadVisible(row, width)}[/]" : row; /// - /// Draws a row's editable value: its committed text when nothing is being typed, or — when - /// is the open edit for that field — the buffer, a block caret sitting - /// inside it, and the reason the last commit was refused. Every screen draws fields, so the - /// affordance lives here rather than being re-invented (and drifting) per renderer. + /// Draws a row's editable value: its committed text in a field well when nothing is being typed, + /// or — when is the open edit for that field — the buffer in that same + /// well, a block caret sitting inside it, and the reason the last commit was refused. Every screen + /// draws fields, so the affordance lives here rather than being re-invented (and drifting) per + /// renderer. + /// + /// The resting well is the whole point of 's existence: until it was drawn, + /// host aetherfall.mux and security TLS on · certs strict were the same row to look + /// at, and the only way to find out which one the keyboard could change was to walk the cursor into + /// it. A screen may not advertise a key its model doesn't offer; a row may not advertise an editor + /// it hasn't got, which is the same rule one level down. + /// /// /// is already markup, because a screen decides for itself how a /// committed value reads (a null log directory shows as (default)); the buffer is escaped @@ -122,7 +131,7 @@ internal static string Field(string display, ScreenFieldEdit? edit) { if (edit is not { } open) { - return display; + return Well(display); } var caret = Math.Clamp(open.Caret, 0, open.Text.Length); @@ -139,6 +148,51 @@ internal static string Field(string display, ScreenFieldEdit? edit) : buffer; } + /// + /// The resting field well: a value's own markup on the recessed input background, with a trailing + /// cell so the well is a visible box rather than a tint hugging the glyphs. The trailing cell is + /// where the caret goes the moment ⏎ opens the field, so the well doesn't jump sideways under it. + /// + private static string Well(string display) => $"[on {ScreenPalette.FieldBg}]{display} [/]"; + + /// + /// Draws a value the keyboard cannot change where it is drawn — a world's TLS/certificate line, a + /// character's password or session state, a numpad cell mirroring a binding elsewhere. It gets the + /// muted ink and, decisively, *no* field well, which is what tells it apart from an editable value + /// at rest and without focus. The pair of them is one rule with one implementation: a well means + /// "you can change this here", its absence means "you cannot". + /// + /// The rule is scoped to rows that read label value, which is where the ambiguity lives. A + /// checkbox and a radio group already carry an affordance of their own and are left alone. + /// + /// + internal static string ReadOnly(string text) => $"[{ScreenPalette.Muted}]{MarkupText.Escape(text)}[/]"; + + /// + /// Where the cursor is within one of a screen's lists — trigger 1/4, world 2/2. Every + /// footer's context line opens with one of these, so the eight screens answer the same question in + /// the same words instead of each reporting whatever its author found interesting (F9 used to count + /// its own section headers). + /// + internal static string Position(string noun, int index, int count) => + $"{noun} {(index + 1).ToString(CultureInfo.InvariantCulture)}" + + $"/{count.ToString(CultureInfo.InvariantCulture)}"; + + /// + /// A footer's context line: a , then whatever identifies the thing it points + /// at (the set a trigger belongs to, the section an option sits under, the name a binding carries). + /// Null and empty parts are dropped, so a screen with nothing selected renders an empty context + /// rather than a stranded separator. + /// + internal static string Context(params string?[] parts) + { + ArgumentNullException.ThrowIfNull(parts); + + var present = parts.Where(p => !string.IsNullOrEmpty(p)); + var joined = string.Join(" · ", present); + return joined.Length == 0 ? string.Empty : $"[{ScreenPalette.Label}]{joined}[/]"; + } + /// A full-width one-row band — the header or the footer. internal static MarkupControl Band(string line, string bg) => new(new List { line }) { diff --git a/src/SharpMUTerm.Tui/ScreenPalette.cs b/src/SharpMUTerm.Tui/ScreenPalette.cs index e330b38a..c6aba7cd 100644 --- a/src/SharpMUTerm.Tui/ScreenPalette.cs +++ b/src/SharpMUTerm.Tui/ScreenPalette.cs @@ -33,6 +33,14 @@ internal static class ScreenPalette /// Primary text: titles and field values. internal const string Value = "#d7deec"; + /// + /// A value that is reported rather than offered — a world's TLS line, a character's password, a + /// session's state. Deliberately between and : a readout is + /// not its own label, but it must not sit at the same weight as something the keyboard can change. + /// See , which is the only place it is applied. + /// + internal const string Muted = "#9aa4b8"; + /// Hairlines — column rules and separators. internal const string Rule = "#3a4257"; @@ -47,10 +55,14 @@ internal static class ScreenPalette internal const string Ink = "#0f1620"; /// - /// The well behind a field being typed into. Darker than every panel it can appear on, so an open - /// edit reads as a recessed input whichever screen it lands on rather than as another cursor bar. + /// The well behind an editable value — whether or not it is being typed into. Clearly darker than + /// every panel it can appear on (and than ), so a field reads as a recessed + /// input on any of them, at rest and without focus. The well *is* the affordance: a value drawn in + /// one can be changed, a value drawn without one cannot. An open edit is the same well plus the + /// accent block caret, so pressing ⏎ deepens the affordance already there instead of conjuring a + /// new one. /// - internal const string FieldBg = "#0f1420"; + internal const string FieldBg = "#0a0e18"; /// A refused value's marker — the one place these screens raise their voice. internal const string Warn = "#ff6b6b"; diff --git a/src/SharpMUTerm.Tui/TimersScreenRenderer.cs b/src/SharpMUTerm.Tui/TimersScreenRenderer.cs index 5b393dd8..b9a11c5a 100644 --- a/src/SharpMUTerm.Tui/TimersScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/TimersScreenRenderer.cs @@ -119,9 +119,9 @@ internal static string FooterLine( var context = string.Empty; if (entries.Count > 0 && selected >= 0 && selected < entries.Count) { - var count = entries.Count.ToString(CultureInfo.InvariantCulture); - context = $"[{Label}]timer {(selected + 1).ToString(CultureInfo.InvariantCulture)}/{count}[/]" - + $"[{Label}] · set {Escape(entries[selected].SetName)}[/]"; + context = ScreenChrome.Context( + ScreenChrome.Position("timer", selected, entries.Count), + "set " + Escape(entries[selected].SetName)); } var actions = ScreenChrome.Actions(focus: focus); diff --git a/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs b/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs index 83a7c858..b3903a8b 100644 --- a/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs @@ -1,4 +1,3 @@ -using System.Globalization; using SharpMUTerm.Core.Automation; using SharpMUTerm.Core.Configuration; using SharpMUTerm.Core.Text; @@ -178,9 +177,9 @@ internal static string FooterLine( var context = string.Empty; if (flattened.Count > 0 && selectedTrigger >= 0 && selectedTrigger < flattened.Count) { - var count = flattened.Count.ToString(CultureInfo.InvariantCulture); - context = $"[{Label}]trigger {(selectedTrigger + 1).ToString(CultureInfo.InvariantCulture)}/{count}[/]" - + $"[{Label}] · set {Escape(flattened[selectedTrigger].SetName)}[/]"; + context = ScreenChrome.Context( + ScreenChrome.Position("trigger", selectedTrigger, flattened.Count), + "set " + Escape(flattened[selectedTrigger].SetName)); } var actions = ScreenChrome.Actions(focus: focus); @@ -329,17 +328,19 @@ private static List BuildEditor( var fg = trigger.Actions.HighlightForeground; var bg = trigger.Actions.HighlightBackground; + // What the two swatch rows add up to is a caption on the section that owns them, not a fourth + // checkbox under it. It was drawn as one, which made it look like a fourth thing to press: the + // cursor cannot land on it, Space does nothing to it, and it sat *below* the two rows it is + // derived from, so it read as a cause rather than the effect it is. The caption says the same + // thing, above the rows that decide it, in a shape nothing offers to press. lines.Add(string.Empty); - lines.Add(Heading("highlight", foreground ?? background)); + lines.Add(Heading("highlight", foreground ?? background, HighlightCaption(fg, bg))); lines.Add(HighlightRow("fg", fg, foreground)); lines.Add(HighlightRow("bg", bg, background)); lines.Add(string.Empty); - // The highlight checkbox stays a derived indicator — it reports whether either colour is set, - // which the two swatch rows above it are now what changes. The two rows below it are real - // booleans on the trigger, and are the editor pane's navigable rows in this order. - var hasHighlight = fg is not null || bg is not null; - lines.Add(hasHighlight ? $"[{Accent}][[x]][/] highlight line" : "[dim][[ ]] highlight line[/]"); + // The two rows below are real booleans on the trigger, and are the editor pane's navigable rows + // in this order. lines.Add(ScreenChrome.Cursor(Checkbox("gag line", trigger.Actions.Gag), cursor.IsOn(1, 0), ColumnWidth)); lines.Add(ScreenChrome.Cursor( Checkbox("stop processing", trigger.StopProcessing), cursor.IsOn(1, 1), ColumnWidth)); @@ -352,14 +353,32 @@ private static string Checkbox(string label, bool value) => value ? $"[{Accent}][[x]][/] {Escape(label)}" : $"[dim][[ ]] {Escape(label)}[/]"; /// - /// A section label, carrying the open field's rejection message when there is one. A radio group - /// and a pair of swatches have nowhere sensible to put an error inline, so it hangs off the - /// heading the group belongs to. + /// A section label, carrying the open field's rejection message when there is one — and otherwise + /// an optional caption summarising what the rows beneath it come to. A radio group and a pair of + /// swatches have nowhere sensible to put an error inline, so it hangs off the heading the group + /// belongs to; an error displaces the caption, because a refused value is the more urgent of the + /// two and they occupy the same cells. /// - private static string Heading(string label, ScreenFieldEdit? edit) => - edit?.Error is { } error - ? $"[dim]{label}[/] [{Warn}]▲ {Escape(error)}[/]" - : $"[dim]{label}[/]"; + private static string Heading(string label, ScreenFieldEdit? edit, string? caption = null) + { + if (edit?.Error is { } error) + { + return $"[dim]{label}[/] [{Warn}]▲ {Escape(error)}[/]"; + } + + return caption is null ? $"[dim]{label}[/]" : $"[dim]{label}[/] {caption}"; + } + + /// + /// What the two swatch rows amount to, read out beside the section heading: whether a matching line + /// gets recoloured at all. Muted rather than accented, because it reports the state of the two rows + /// below it and cannot itself be changed — the same treatment every other readout on these screens + /// gets (see ). + /// + private static string HighlightCaption(TerminalColor? foreground, TerminalColor? background) => + foreground is not null || background is not null + ? ScreenChrome.ReadOnly("· matching lines are recoloured") + : "[dim]· matching lines are left alone[/]"; /// /// One radio of the route group. wells the whole group so it reads as diff --git a/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs b/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs index b49c11c8..553def1b 100644 --- a/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs @@ -326,12 +326,12 @@ internal static string FooterLine( var context = string.Empty; if (worlds.Count > 0 && selectedWorld >= 0) { - context = $"[{Label}]world {selectedWorld + 1}/{worlds.Count}[/]"; var chars = worlds[selectedWorld].Characters.Count; - if (chars > 0 && selectedCharacter >= 0) - { - context += $"[{Label}] · character {selectedCharacter + 1}/{chars}[/]"; - } + context = ScreenChrome.Context( + ScreenChrome.Position("world", selectedWorld, worlds.Count), + chars > 0 && selectedCharacter >= 0 + ? ScreenChrome.Position("character", selectedCharacter, chars) + : null); } var actions = ScreenChrome.Actions(accent, focus); @@ -409,7 +409,7 @@ internal static List DetailColumn( WorldField("host", Field($"[{Value}]{Escape(world.Host)}[/]", cursor, selectedWorld, 1)), WorldField("port", Field( $"[{Value}]{world.Port.ToString(CultureInfo.InvariantCulture)}[/]", cursor, selectedWorld, 2)), - WorldField("security", $"[{Value}]{Security(world)}[/]"), + WorldField("security", ScreenChrome.ReadOnly(Security(world))), WorldField("encoding", Field($"[{Value}]{Escape(world.Encoding)}[/]", cursor, selectedWorld, 3)), WorldField("keepalive", Field( world.KeepaliveSeconds > 0 @@ -454,8 +454,11 @@ internal static List DetailColumn( /// /// The character form — labels left-aligned with their values, one field per row. The editable - /// ones are the character row's own fields (name, then on-connect); the password is deliberately - /// not among them, and the session line is a report, not a setting. + /// ones are the character row's own fields (name, then on-connect) and are the only two drawn in a + /// field well. The other three deliberately are not: the password is + /// d and belongs in a credential + /// store, auto-login is a readout of the character row's own checkbox, and the session line is a + /// report of what the connection is doing rather than a setting at all. /// internal static List FormColumn( CharacterDefinition character, string accent, ScreenFocus? focus = null, int selectedCharacter = -1) @@ -467,11 +470,11 @@ internal static List FormColumn( string.Empty, CharField("name", Field( $"[{Value}]{Escape(character.Name)}[/]", cursor, selectedCharacter, 0, pane: 1)), - CharField("password", $"[{Value}]••••••••[/] [{Label}]keychain[/]"), + CharField("password", $"{ScreenChrome.ReadOnly("••••••••")} [{Label}]keychain[/]"), CharField("on connect", Field( $"[{Value}]{Escape(character.OnConnect ?? "—")}[/]", cursor, selectedCharacter, 1, pane: 1)), - CharField("auto-login", character.AutoLogin ? $"[{accent}]yes[/]" : $"[{Label}]no[/]"), - CharField("session", $"[{Label}]offline[/]"), + CharField("auto-login", ScreenChrome.ReadOnly(character.AutoLogin ? "yes" : "no")), + CharField("session", ScreenChrome.ReadOnly("offline")), }; } diff --git a/tests/SharpMUTerm.Tui.Tests/OptionsScreenRendererTests.cs b/tests/SharpMUTerm.Tui.Tests/OptionsScreenRendererTests.cs index 59be40d8..e4e887da 100644 --- a/tests/SharpMUTerm.Tui.Tests/OptionsScreenRendererTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/OptionsScreenRendererTests.cs @@ -54,11 +54,17 @@ public async Task Render_SpacerRow_IsBlankLine() await Assert.That(lines[3]).IsEqualTo(string.Empty); } + /// + /// The header names the screen and how to leave it, and nothing else. It used to open with a + /// ‹ back affordance — on these three screens only, pointing at a navigation stack that does + /// not exist. The assertion is kept pointed the other way rather than dropped, so it cannot come + /// back by accident. + /// [Test] public async Task Render_HeaderAndFooter_MatchPattern() { var lines = OptionsScreenRenderer.Render("Logging", "F9", Array.Empty()); - await Assert.That(lines[0]).Contains("‹ back"); + await Assert.That(lines[0]).DoesNotContain("‹ back"); await Assert.That(lines[0]).Contains("Logging"); await Assert.That(lines[0]).Contains("F9"); await Assert.That(lines[^1]).Contains("Cancel"); diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs index 10a05263..bf131fdc 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs @@ -240,13 +240,18 @@ public async Task Options_InputRowsWriteBackToTheInputSettings() await Assert.That(input.CheckSpelling).IsFalse(); } + /// + /// F9's auto-start checkbox lives on the format row itself (row 0) rather than on a third + /// row of its own: it and the format are one stored value, so Space and ⏎ act on one row. Its + /// snapshot still restores the format, not the boolean. + /// [Test] public async Task Options_LoggingAutoStartTogglesTheFormat_AndUndoRestoresTheOriginalOne() { var logging = new LoggingSettings { Format = LogFormat.Html }; var edits = new ScreenEdits(); - edits.Apply(OptionsScreenRenderer.Model(OptionsScreenRenderer.LoggingScreen(logging)).ToggleAt(0, 2)!.Value); + edits.Apply(OptionsScreenRenderer.Model(OptionsScreenRenderer.LoggingScreen(logging)).ToggleAt(0, 0)!.Value); await Assert.That(logging.Format).IsEqualTo(LogFormat.None); edits.Revert(); @@ -259,8 +264,24 @@ public async Task Options_LoggingAutoStartTurnsOnAsPlainWhenNothingWasChosen() { var logging = new LoggingSettings { Format = LogFormat.None }; - OptionsScreenRenderer.Model(OptionsScreenRenderer.LoggingScreen(logging)).ToggleAt(0, 2)!.Value.Flip(); + OptionsScreenRenderer.Model(OptionsScreenRenderer.LoggingScreen(logging)).ToggleAt(0, 0)!.Value.Flip(); await Assert.That(logging.Format).IsEqualTo(LogFormat.Plain); } + + /// + /// The same row carries both, which is what makes it one setting rather than two: ⏎ opens the + /// format on the row Space starts and stops logging from. + /// + [Test] + public async Task Options_LoggingFormatAndAutoStartAreOneRow() + { + var model = OptionsScreenRenderer.Model( + OptionsScreenRenderer.LoggingScreen(new LoggingSettings { Format = LogFormat.Html })); + + await Assert.That(model.Sizes[0]).IsEqualTo(2); + await Assert.That(model.RowAt(0, 0).Toggle).IsNotNull(); + await Assert.That(model.RowAt(0, 0).FieldCount).IsEqualTo(1); + await Assert.That(model.FieldAt(0, 0, 0)!.Value.Get()).IsEqualTo("Html"); + } } diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenReadOnlyTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenReadOnlyTests.cs new file mode 100644 index 00000000..7a6939d1 --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/ScreenReadOnlyTests.cs @@ -0,0 +1,328 @@ +using System.Text.RegularExpressions; +using SharpMUTerm.Core.Automation; +using SharpMUTerm.Core.Configuration; +using SharpMUTerm.Core.Text; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// What a row looks like when you cannot change it. The settings screens already refuse to advertise a +/// key their doesn't offer (, +/// ); these are the same rule one level down, where the claim is made by +/// a row rather than by the chrome. +/// +/// Two halves, both pinned here because either alone can pass while the screen still lies. A value the +/// keyboard can change is drawn in a field well; a value it cannot is drawn without one, in the muted +/// ink. And nothing that is merely *derived* — a summary of two other rows, a projection of a list +/// elsewhere — may be drawn as a checkbox, because a checkbox is a promise that Space does something. +/// +/// +public class ScreenReadOnlyTests +{ + /// + /// The field well as it appears in markup — matched as a background so it catches both forms: the + /// resting well tints nothing but the background, an open edit's buffer sets a foreground too. + /// + private static readonly string Well = "on " + ScreenPalette.FieldBg; + + /// A drawn checkbox, either state, as the renderers escape it. + private static bool HasCheckbox(string line) => + line.Contains("[[x]]", StringComparison.Ordinal) || line.Contains("[[ ]]", StringComparison.Ordinal); + + private static bool InAWell(string line) => line.Contains(Well, StringComparison.Ordinal); + + private static List Sets() => new() + { + new TriggerSet + { + Name = "Comms", + Description = "channel routing", + Triggers = new List + { + new() + { + Name = "Tell", + Pattern = "tells you", + Actions = new TriggerActions + { + HighlightForeground = TerminalColor.FromRgb(0xff, 0xd7, 0x00), + SpawnTarget = "Chat", + }, + }, + new() { Name = "Quiet", Pattern = "guild", Actions = new TriggerActions() }, + }, + Aliases = new List { new() { Name = "k", Pattern = "^k$", Substitution = "kill\nflee" } }, + Macros = new List { new() { Name = "Look", Key = "Num5", Command = "look" } }, + Timers = new List { new() { Name = "ping", IntervalSeconds = 30, Command = "look" } }, + }, + }; + + private static List Worlds() => new() + { + new WorldDefinition + { + Name = "Aetherfall", + Host = "aetherfall.mux", + Port = 4201, + UseTls = true, + KeepaliveSeconds = 30, + Characters = new List + { + new() { Name = "Corvid", AutoLogin = true, OnConnect = "look", TriggerSets = new List { "Comms" } }, + }, + }, + }; + + /// + /// F5's world block is the case this rule was written for: host can be typed into and + /// security cannot, and until the well was drawn the only way to find out which was which + /// was to walk the cursor into one. + /// + [Test] + public async Task Worlds_EditableRowsSitInAFieldWellAndReadOnlyOnesDoNot() + { + var lines = WorldsScreenRenderer.DetailColumn(Worlds(), Sets(), 0, 0, ScreenPalette.Accent); + + foreach (var label in new[] { "host", "port", "encoding", "keepalive" }) + { + await Assert.That(InAWell(Row(lines, label))).IsTrue().Because(label + " is editable"); + } + + // The world's own name, told apart from the characters table's "name" column header by its + // right-aligned label — the same discriminator ScreenFieldRenderingTests uses. + var worldName = lines.Single(l => l.Contains(" name[/]", StringComparison.Ordinal)); + await Assert.That(InAWell(worldName)).IsTrue(); + + // Two booleans with no UI at all; a later task gives them one. Until then it must not look like + // one — this is the row the whole rule exists for. + await Assert.That(InAWell(Row(lines, "security"))).IsFalse(); + await Assert.That(Row(lines, "security")).Contains(ScreenPalette.Muted); + } + + /// + /// The character form, where three of five rows are readouts: a password that lives in a credential + /// store, a mirror of the character row's own checkbox, and the state of a connection. + /// + [Test] + public async Task Worlds_TheCharacterFormWellsOnlyTheTwoRowsThatCanBeTyped() + { + var lines = WorldsScreenRenderer.FormColumn(Worlds()[0].Characters[0], ScreenPalette.Accent); + + await Assert.That(InAWell(Row(lines, "name"))).IsTrue(); + await Assert.That(InAWell(Row(lines, "on connect"))).IsTrue(); + + foreach (var label in new[] { "password", "auto-login", "session" }) + { + await Assert.That(InAWell(Row(lines, label))).IsFalse().Because(label + " is a readout"); + await Assert.That(Row(lines, label)).Contains(ScreenPalette.Muted).Because(label); + } + } + + /// + /// The whole point of a well is that it is visible without focus. Opening the field must therefore + /// *deepen* the affordance already drawn rather than conjure a new one — same well, plus a caret. + /// + [Test] + public async Task AFieldIsWelledAtRestAndStillWelledWhileItIsBeingTyped() + { + var resting = ScreenChrome.Field("[#d7deec]aetherfall.mux[/]", null); + var open = ScreenChrome.Field( + "[#d7deec]aetherfall.mux[/]", new ScreenFieldEdit(0, "aetherfall.mux", 14, null)); + + await Assert.That(InAWell(resting)).IsTrue(); + await Assert.That(InAWell(open)).IsTrue(); + await Assert.That(open).Contains($"[{ScreenPalette.Ink} on {ScreenPalette.Accent}]"); + await Assert.That(resting).DoesNotContain($"[{ScreenPalette.Ink} on {ScreenPalette.Accent}]"); + } + + /// A read-only value carries the muted ink and, decisively, no well. + [Test] + public async Task AReadOnlyValueIsMutedAndNeverWelled() + { + var value = ScreenChrome.ReadOnly("TLS on · certs strict"); + + await Assert.That(value).Contains(ScreenPalette.Muted); + await Assert.That(InAWell(value)).IsFalse(); + + // It is drawn from config, so it is escaped like every other configured string. + await Assert.That(ScreenChrome.ReadOnly("weird [value]")).Contains("weird [[value]]"); + } + + /// + /// F2's highlight summary. It reports whether either colour row above it is set — the cursor cannot + /// land on it and Space does nothing to it — so it is a caption on the section, not a fourth + /// checkbox under it. Asserted both ways round, so it can't come back in either state. + /// + [Test] + public async Task Triggers_TheHighlightSummaryIsACaptionInBothStates() + { + var sets = Sets(); + + foreach (var selected in new[] { 0, 1 }) + { + var editor = TriggersScreenRenderer.EditorColumn(sets, selected, Array.Empty()); + var heading = editor.Single(l => l.Contains("highlight", StringComparison.Ordinal)); + + await Assert.That(HasCheckbox(heading)).IsFalse().Because("trigger " + selected); + await Assert.That(editor.Any(l => l.Contains("highlight line", StringComparison.Ordinal))) + .IsFalse() + .Because("trigger " + selected); + } + } + + /// + /// The general form of the rule for F2's editor pane: every checkbox it draws is a row the cursor + /// can reach and Space can press. The pane's navigable rows are its second pane, so the two counts + /// have to match — a derived indicator drawn as a checkbox is exactly the case where they don't. + /// + [Test] + public async Task Triggers_EveryCheckboxInTheEditorIsANavigableToggleRow() + { + var sets = Sets(); + var editor = TriggersScreenRenderer.EditorColumn(sets, 0, Array.Empty()); + var model = TriggersScreenRenderer.Model(sets, 0); + + await Assert.That(editor.Count(HasCheckbox)).IsEqualTo(model.Sizes[1]); + for (var row = 0; row < model.Sizes[1]; row++) + { + await Assert.That(model.ToggleAt(1, row)).IsNotNull(); + } + } + + /// + /// The same rule for the three options screens, which is where F9's auto-start indicator was: every + /// checkbox drawn in the list belongs to a row whose model entry actually carries a toggle. + /// + [Test] + public async Task Options_EveryCheckboxBelongsToARowTheModelCanToggle() + { + var screens = new[] + { + OptionsScreenRenderer.TextAnsiScreen(), + OptionsScreenRenderer.InputSpellcheckScreen(), + OptionsScreenRenderer.LoggingScreen(new LoggingSettings { Format = LogFormat.Html }), + OptionsScreenRenderer.LoggingScreen(new LoggingSettings { Format = LogFormat.None }), + }; + + foreach (var screen in screens) + { + var model = OptionsScreenRenderer.Model(screen); + var drawn = OptionsScreenRenderer.BodyColumn(screen.Rows).Count(HasCheckbox); + var toggles = 0; + for (var row = 0; row < model.Sizes[0]; row++) + { + if (model.ToggleAt(0, row) is not null) + { + toggles++; + } + } + + await Assert.That(drawn).IsEqualTo(toggles).Because(screen.Title); + } + } + + /// + /// F4's numpad grid mirrors the binding list beside it and has no cursor of its own, so a cell is a + /// readout: the commands it shows are muted and none of them is drawn in a well. The list's own + /// commands, which ⏎ opens, are. + /// + [Test] + public async Task Keypad_TheNumpadGridIsAReadoutAndTheBindingListIsNot() + { + var macros = Sets()[0].Macros; + + var grid = KeypadScreenRenderer.NumpadColumn(macros); + await Assert.That(grid.Any(InAWell)).IsFalse(); + await Assert.That(grid.Single(l => l.Contains("look", StringComparison.Ordinal))) + .Contains(ScreenPalette.Muted); + + var list = KeypadScreenRenderer.HotkeysColumn(macros); + await Assert.That(list.Single(l => l.Contains("Num5", StringComparison.Ordinal))).Contains(Well); + } + + /// + /// The ‹ back affordance is gone. It appeared on F7/F8/F9 only and pointed at a navigation + /// stack that does not exist — Esc closes a settings screen, and the header says so. + /// + [Test] + public async Task NoScreenOffersABackAffordance() + { + foreach (var header in Headers()) + { + await Assert.That(header).DoesNotContain("‹"); + await Assert.That(header).DoesNotContain("back"); + } + } + + /// + /// Every footer's context line answers the same question in the same shape — where is the cursor + /// in this screen's list, optionally followed by what identifies the thing it points at. They + /// used to answer whatever each screen's author found interesting: two of the eight reported an + /// inventory instead (9 bindings · 8 of 9 numpad keys bound, 3 options · 1 section). + /// + [Test] + public async Task EveryFooterContextLineOpensWithTheCursorsPosition() + { + foreach (var (name, footer) in Footers()) + { + var context = Visible(footer).TrimStart(); + await Assert.That(Regex.IsMatch(context, @"^[a-z]+ \d+/\d+")).IsTrue().Because($"{name}: {context}"); + } + } + + /// The line of a label/value block whose label is . + private static string Row(IReadOnlyList lines, string label) => + lines.Single(l => Regex.IsMatch(Visible(l), $@"^\s*{Regex.Escape(label)}\s")); + + /// A markup line as it prints: tags stripped, escaped brackets folded back to one. + private static string Visible(string markup) + { + var guarded = markup.Replace("[[", "\u0001", StringComparison.Ordinal) + .Replace("]]", "\u0002", StringComparison.Ordinal); + return Regex.Replace(guarded, @"\[[^\[\]]*\]", string.Empty) + .Replace('\u0001', '[') + .Replace('\u0002', ']'); + } + + private static List Headers() + { + var sets = Sets(); + var worlds = Worlds(); + return new List + { + TriggersScreenRenderer.HeaderLine(80, TriggersScreenRenderer.Model(sets, 0)), + AliasesScreenRenderer.HeaderLine(80, AliasesScreenRenderer.Model(sets, 0)), + KeypadScreenRenderer.HeaderLine(80, KeypadScreenRenderer.Model(sets[0].Macros)), + WorldsScreenRenderer.HeaderLine(80, WorldsScreenRenderer.Model(worlds, sets, 0, 0)), + TimersScreenRenderer.HeaderLine(80, TimersScreenRenderer.Model(sets, 0)), + Header(OptionsScreenRenderer.TextAnsiScreen()), + Header(OptionsScreenRenderer.InputSpellcheckScreen()), + Header(OptionsScreenRenderer.LoggingScreen(new LoggingSettings())), + }; + } + + private static string Header(OptionsScreenRenderer.OptionsScreen screen) => + OptionsScreenRenderer.HeaderLine(screen.Title, screen.FKey, 80, OptionsScreenRenderer.Model(screen)); + + private static List<(string Name, string Footer)> Footers() + { + var sets = Sets(); + var worlds = Worlds(); + var accent = WorldsScreenRenderer.AccentFor(worlds, 0); + + return new List<(string, string)> + { + ("F2 triggers", TriggersScreenRenderer.FooterLine(sets, 0, 80)), + ("F3 aliases", AliasesScreenRenderer.FooterLine(sets, 0, 80)), + ("F4 keypad", KeypadScreenRenderer.FooterLine(sets[0].Macros, 80)), + ("F5 worlds", WorldsScreenRenderer.FooterLine(worlds, 0, 0, accent, 80)), + ("F6 timers", TimersScreenRenderer.FooterLine(sets, 0, 80)), + ("F7 text", OptionsScreenRenderer.FooterLine(OptionsScreenRenderer.TextAnsiScreen().Rows, 80)), + ("F8 input", OptionsScreenRenderer.FooterLine(OptionsScreenRenderer.InputSpellcheckScreen().Rows, 80)), + ("F9 logging", + OptionsScreenRenderer.FooterLine( + OptionsScreenRenderer.LoggingScreen(new LoggingSettings()).Rows, 80)), + }; + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs b/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs index f9600e56..bf0f8f73 100644 --- a/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs @@ -244,10 +244,12 @@ public async Task TheEditorDrawsBothSwatchRowsWhetherOrNotAColourIsSet() var editor = TriggersScreenRenderer.EditorColumn(sets, 1, Targets); // Trigger 1 has no highlight at all — the rows are still there, because they are now where a - // colour is turned on rather than a report that one already is. + // colour is turned on rather than a report that one already is, and the section heading says + // as much in words rather than in a checkbox nothing can press. await Assert.That(editor.Any(l => l.Contains("fg") && l.Contains("none"))).IsTrue(); await Assert.That(editor.Any(l => l.Contains("bg") && l.Contains("none"))).IsTrue(); - await Assert.That(editor.Any(l => l.Contains("[dim][[ ]] highlight line[/]"))).IsTrue(); + await Assert.That(editor.Any(l => l.Contains("highlight") && l.Contains("left alone"))).IsTrue(); + await Assert.That(editor.Any(l => l.Contains("highlight") && l.Contains("[[ ]]"))).IsFalse(); } [Test] diff --git a/tests/SharpMUTerm.Tui.Tests/TriggersScreenRendererTests.cs b/tests/SharpMUTerm.Tui.Tests/TriggersScreenRendererTests.cs index 59eaabef..bb764f19 100644 --- a/tests/SharpMUTerm.Tui.Tests/TriggersScreenRendererTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/TriggersScreenRendererTests.cs @@ -107,12 +107,22 @@ public async Task Render_GagToggleReflectsActionsGag() await Assert.That(notGagged.Any(l => l.Contains("[dim][[ ]] gag line[/]"))).IsTrue(); } + /// + /// The swatches show the colours, and the section heading above them says what they add up to. That + /// summary used to be drawn as [[x]] highlight line — a checkbox the cursor cannot reach and + /// Space does nothing to, sitting *below* the two rows it was derived from. The assertion is kept + /// pointed the other way so it cannot come back as a checkbox. + /// [Test] - public async Task Render_HighlightToggleAndSwatchAppearWhenColourSet() + public async Task Render_HighlightCaptionAndSwatchAppearWhenColourSet() { var lines = TriggersScreenRenderer.Render(Scene(), selectedTrigger: 0, spawnTargets: Array.Empty()); - await Assert.That(lines.Any(l => l.Contains("highlight line") && l.Contains("[[x]]"))).IsTrue(); + var heading = lines.Single(l => l.Contains("highlight") && !l.Contains("fg") && !l.Contains("bg")); + await Assert.That(heading).Contains("recoloured"); + await Assert.That(heading).DoesNotContain("[[x]]"); + await Assert.That(heading).DoesNotContain("[[ ]]"); + await Assert.That(lines.Any(l => l.Contains("████") && l.Contains("fg"))).IsTrue(); await Assert.That(lines.Any(l => l.Contains("#ffd700"))).IsTrue(); } From 69a17241da556f706aa6cd502e79a05835906de8 Mon Sep 17 00:00:00 2001 From: Harry Cordewener Date: Tue, 28 Jul 2026 20:12:58 -0500 Subject: [PATCH 14/23] Settings screens: editable names and add/remove on every list MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two gaps from the design review. Every list screen drew the item's name as its primary identifier and none let you change it -- you could edit a trigger's regex but not what it was called, four times over. Name is now the first field of every list row on all five screens, so ⏎ on a row (including one just created) opens the value that identifies it. Names are deliberately not unique: nothing keys off them, the engines match on patterns and are keyed by Macro.Key, and two sets may each hold a rule called Tell. Refusing that would be a rule the config doesn't have. Blank and control characters are refused, since a name is drawn into one row of a fixed-width list. Add/remove existed only on F5, so you could create a world but not a trigger, alias, timer or macro. All four now have it, following F5's shape: the action returns its own undo, deleting restores at the original index, buttons that would act on nothing aren't drawn, and destructive ones name their target. Per-screen judgement rather than uniformity: F2 and F3 get duplicate (a rule is a regex plus route plus two colours plus three flags -- get one right, copy it per channel), F6 doesn't (three values, two of which you would change anyway), and F4 must not -- a macro is identified by its Key, MacroEngine is a dictionary, so a copy would land on the original's key and never fire. A new timer starts disabled, being the only one of the four that acts unprompted. Replaces the undiscoverable End binding with Delete on the row itself, running that pane's own remove button, and advertises it: "Del remove" is derived from the model, pinned if-and-only-if so a screen cannot claim the key without offering it. Also makes snapshots deterministic. --snapshot rendered whatever config was on the machine, falling back to the demo only when no worlds existed, so a saved config silently replaced the demo data -- a golden file that changes with the developer's own worlds isn't one. It now always renders the demo; --live-config opts into the real config for debugging. Verified the same command produces an identical frame with and without a user config present. 894 tests pass, up from 857. Four pinned row counts changed and were strengthened rather than renumbered: each now asserts ListSizes, which still carries the original meaning, alongside the new total. Field ordinals moved behind named constants so they cannot drift silently. Co-Authored-By: Claude Opus 5 (1M context) --- CLAUDE.md | 2 +- docs/HANDOFF.md | 72 ++- src/SharpMUTerm.Core/Automation/Alias.cs | 24 +- src/SharpMUTerm.Core/Automation/Macro.cs | 8 +- .../Automation/TimerDefinition.cs | 7 +- src/SharpMUTerm.Core/Automation/Trigger.cs | 42 +- src/SharpMUTerm.Tui/AliasesScreenRenderer.cs | 102 +++- src/SharpMUTerm.Tui/DemoScene.cs | 18 +- src/SharpMUTerm.Tui/KeypadScreenRenderer.cs | 177 ++++++- src/SharpMUTerm.Tui/KeypadScreenView.cs | 17 +- src/SharpMUTerm.Tui/Program.cs | 10 +- src/SharpMUTerm.Tui/ScreenChrome.cs | 56 ++- src/SharpMUTerm.Tui/ScreenField.cs | 27 ++ src/SharpMUTerm.Tui/ScreenLists.cs | 93 ++++ src/SharpMUTerm.Tui/ScreenModel.cs | 137 +++++- src/SharpMUTerm.Tui/SettingsSession.cs | 34 +- src/SharpMUTerm.Tui/SharpMUTermApp.cs | 48 +- src/SharpMUTerm.Tui/TimersScreenRenderer.cs | 90 +++- src/SharpMUTerm.Tui/TriggersScreenRenderer.cs | 107 ++++- src/SharpMUTerm.Tui/WorldsScreenRenderer.cs | 104 +---- .../Automation/AutomationCloneTests.cs | 163 +++++++ .../ScreenDeleteKeyTests.cs | 243 ++++++++++ .../ScreenFieldRenderingTests.cs | 64 ++- .../ScreenListButtonTests.cs | 435 ++++++++++++++++++ .../SharpMUTerm.Tui.Tests/ScreenModelTests.cs | 35 +- .../SharpMUTerm.Tui.Tests/ScreenNameTests.cs | 227 +++++++++ .../SettingsSessionEditTests.cs | 7 +- .../TriggersScreenEditingTests.cs | 50 +- 28 files changed, 2159 insertions(+), 240 deletions(-) create mode 100644 src/SharpMUTerm.Tui/ScreenLists.cs create mode 100644 tests/SharpMUTerm.Core.Tests/Automation/AutomationCloneTests.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/ScreenDeleteKeyTests.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/ScreenListButtonTests.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/ScreenNameTests.cs diff --git a/CLAUDE.md b/CLAUDE.md index 11328ecb..66c814b9 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -32,7 +32,7 @@ fallbacks) for inline images/maps. ## Repository state **M1 delivered, plus substantial M2–M4 work.** `SharpMUTerm.slnx` builds all ten projects on -`net10.0`; the solution has **857 tests**, all passing. In place: +`net10.0`; the solution has **894 tests**, all passing. In place: - **Core** — `AnsiParser` (SGR 16/256/truecolor), styled-line + `ScrollbackBuffer` model, `TcpTransport` (TLS + IPv6), `TelnetSession` (wraps TelnetNegotiationCore **2.5.3**), diff --git a/docs/HANDOFF.md b/docs/HANDOFF.md index 472b9954..8714c327 100644 --- a/docs/HANDOFF.md +++ b/docs/HANDOFF.md @@ -4,8 +4,8 @@ Context for whoever (human or agent) picks up this work next. - **Repository:** `SharpMUSH/SharpMUTerm` - **Start from:** a fresh branch off `main` -- **Tests:** 857 across the solution (330 Core / 83 Graphics / 42 Scripting / - 28 Web / 374 Tui), all passing; `dotnet build SharpMUTerm.slnx` clean (0 warnings +- **Tests:** 894 across the solution (336 Core / 83 Graphics / 42 Scripting / + 28 Web / 405 Tui), all passing; `dotnet build SharpMUTerm.slnx` clean (0 warnings from this repo; building against a local SharpConsoleUI clone surfaces 2 upstream NuGet advisory warnings for AngleSharp, which are the framework's, not ours) @@ -21,16 +21,43 @@ polish/feature backlog. **Done** — see *Settings screens* under Critical Gotchas for how the whole thing works. -- **Add/remove rows** are live. `[+ world]` / `[- del]` and `[+ add character]` / - `[⧉ duplicate]` / `[- remove]` are `ScreenRow`s carrying a `ScreenButton`; ⏎ - runs one. The button rows changed two pinned row-count assertions in - `ScreenModelTests` (`Worlds_HasWorldsThenCharactersThenTriggerSets` `{2,2,1}` → - `{4,5,1}`, `Worlds_CharacterAndTriggerSetPanesAreEmptyForAWorldWithNoCharacters` - `{2,0,0}` → `{4,1,0}`); the shape was accepted and the counts renumbered. +- **Add/remove rows** are live **on all five list screens**. `[+ world]` / `[- del]` + and `[+ add character]` / `[⧉ duplicate]` / `[- remove]` on F5; `[+ trigger]` / + `[⧉ duplicate]` / `[- del]` on F2; `[+ alias]` / `[⧉ duplicate]` / `[- del]` on + F3; `[+ timer]` / `[- del]` on F6; `[+ binding] Num` / `[- del]` on F4. All + are `ScreenRow`s carrying a `ScreenButton`; ⏎ runs one, and Delete on a list row + runs that pane's remove button. The button rows changed pinned row counts in + `ScreenModelTests`, twice: F5's (`{2,2,1}` → `{4,5,1}` and `{2,0,0}` → `{4,1,0}`), + then F2/F3/F6's when they grew the same buttons (`Sizes[0]` 2 → 5, `{1,1}` → + `{4,1}`, `{1,2}` → `{3,2}`). The second round asserts `ListSizes` *as well*, so + the original pinned meaning ("this pane holds two rules") is still asserted and + the total is asserted separately. +- **No `duplicate` on F6 or F4, deliberately.** A timer is three values, two of + which you would change in the copy, so `[+ timer]` and typing is no slower. A + macro is identified by its `Key`, which this screen cannot edit — a copy would + land on the key its original already holds, and the second macro on a key never + fires (`MacroEngine` is a dictionary), so the button's only possible result is a + dead row. +- **F4's add button claims a numpad key and says which** (`[+ binding] Num3`), + because a binding created on an unnamed key would be unfixable from this screen. + Once all ten digits are bound the button isn't drawn at all. +- **New items:** trigger and alias arrive enabled, timer arrives **disabled**. A + timer is the only one of the four that acts without being provoked; the others + wait for output or for a keypress. - **F2's route-to radios and highlight-colour picker** are live, as `Choice` and `Colour` fields on the *rule's own list row* (ordinals: pattern, route, highlight fg, highlight bg). ↑↓ cycle them, which is exactly radio and palette semantics, and the editor pane keeps the two checkbox rows it always had. +- **Every item's name is editable**, and is the **first** field of its list row on + all five screens, so ⏎ on a row — and on a row `[+ …]` just created — opens the + one value that tells it apart. `ScreenField.Name` is the shared validator: not + blank, no control characters (a name is drawn into one row of a fixed-width + list), trimmed, and deliberately **not** unique — nothing keys off these names, + and two sets may each hold a rule called `Tell`. Only `duplicate` renames its + copy, and only so it is findable. `Trigger`/`Alias`/`TimerDefinition`/`Macro` + `Name` went `init` → `set`; none of them has cached derived state (checked: + the engines match on patterns and `MacroEngine` is keyed by `Macro.Key`), which + `AutomationCloneTests.RenamingLeavesTheCompiledMatcherAlone` pins. - **Rows still not editable** (deliberately): a macro's *key* (rebinding needs a key-capture mode, not a text buffer), a character's password (it is `[JsonIgnore]` and belongs in a credential store), a world's TLS/certificate @@ -43,10 +70,14 @@ works. All three are covered by headless snapshots only. Nobody has looked at them in a real terminal. -- **The F5 button rows** — `End` is what reaches a pane's buttons without - dragging the selection to the end of its list, and nothing on screen says so. - Watch someone try to delete a world and see whether they find it; if not, the - fix is a hint or a `Delete`-on-the-row binding, not a bigger button. +- **The button rows** — this was "`End` reaches a pane's buttons and nothing on + screen says so". The fix landed: **Delete on a list row runs that pane's remove + button**, and the header advertises `Del remove` (derived from + `ScreenModel.HasRemovableRow`, so it cannot claim the key without offering it). + End still exists and still doesn't re-anchor — it is how you reach `[+ …]`, + which has no key of its own. What is still owed is watching someone use it: + does `Del remove` in the hint strip actually get read, and is reaching `[+ …]` + by ↑↓ (which does drag the selection) tolerable? - **Full-width input band** — confirm it holds across resizes. The width is pinned imperatively (`SyncInputWidth`), so a resize is the risky case. - **Mouse drag-to-split** — nobody has done it with an actual mouse. What is @@ -294,8 +325,21 @@ What the framework actually provides (read at v2.5.14, not assumed): leaves the detail column (and `[- del]`) pointed where it was. Screens must read `SelectionIn(pane)`, **not** `CursorIn(pane)`, for "what is selected". **End** jumps to a pane's last row without re-anchoring, which is the only way - to reach a button without walking the selection down the whole list; the - targeted buttons also name their victim (`[- del] Grapevine`). + to reach `[[+ …]]` without walking the selection down the whole list; the + targeted buttons also name their victim (`[- del] Grapevine`), which they carry + themselves (`ScreenButton.Target`) rather than the renderer guessing from the + label. **Delete** on a list row runs that pane's `Remove`-kind button — the same + command, the same undo, the same conditions — which is the discoverable path to + the common case; on a button row it does nothing, and mid-edit it belongs to the + buffer. Panes flattened across trigger sets (F2/F3/F4/F6) go through + `ScreenLists.Locate`/`Target` to translate between an index into the owning set's + list and a row of the pane; `ScreenButton`'s `offset` is that translation. +- **A row's fields lead with its name.** Ordinal 0 is the name on all five list + screens, and the ordinals are `internal const`s on each renderer + (`TriggersScreenRenderer.PatternField`, …) rather than literals, because the + renderer, the model and the tests all address the same numbers — inserting a + field otherwise silently draws the caret on the wrong row. The `-edit` snapshot + key scripts step through them too, so they move when the ordinals do. - **Fields hang off existing rows, never off new ones.** A world's name/host/port/ encoding/keepalive are the *WORLDS-list row's* fields, drawn in the detail column; a timer's interval/command are the *timer row's*, drawn in the editor diff --git a/src/SharpMUTerm.Core/Automation/Alias.cs b/src/SharpMUTerm.Core/Automation/Alias.cs index 4426d9f6..76c2bb5e 100644 --- a/src/SharpMUTerm.Core/Automation/Alias.cs +++ b/src/SharpMUTerm.Core/Automation/Alias.cs @@ -14,7 +14,13 @@ public sealed class Alias private bool _caseSensitive; private string _pattern = string.Empty; - public string Name { get; init; } = string.Empty; + /// + /// What the alias is called, for the lists that show it. Settable so the F3 screen can rename one + /// live; unlike and nothing is derived from it — + /// expansion matches on the pattern and never looks an alias up by name — so there is no cache to + /// drop. + /// + public string Name { get; set; } = string.Empty; /// /// The .NET regular expression matched against typed input. Settable so the F3 settings screen can @@ -73,4 +79,20 @@ public bool CaseSensitive Pattern, RegexOptions.Compiled | (CaseSensitive ? RegexOptions.None : RegexOptions.IgnoreCase), AutomationDefaults.RegexMatchTimeout); + + /// + /// A copy of this alias — the F3 screen's duplicate button is the caller. Every part is a + /// value or an immutable string, so nothing is shared; the compiled is + /// deliberately not carried over, so the copy builds its own on first use and a later pattern or + /// casing edit on either alias cannot be seen by the other. + /// + public Alias Clone() => new() + { + Name = Name, + Pattern = Pattern, + Enabled = Enabled, + CaseSensitive = CaseSensitive, + Substitution = Substitution, + ScriptCallback = ScriptCallback, + }; } diff --git a/src/SharpMUTerm.Core/Automation/Macro.cs b/src/SharpMUTerm.Core/Automation/Macro.cs index a404a145..5b161861 100644 --- a/src/SharpMUTerm.Core/Automation/Macro.cs +++ b/src/SharpMUTerm.Core/Automation/Macro.cs @@ -7,7 +7,13 @@ namespace SharpMUTerm.Core.Automation; /// public sealed class Macro { - public string Name { get; init; } = string.Empty; + /// + /// What the binding is called, for the lists that show it. Settable so the F4 screen can rename one + /// live; nothing is derived from it — is keyed by , never + /// by name — so there is no cache to drop. deliberately stays init: it + /// is the engine's key, and rebinding it needs a key-capture mode rather than a text field. + /// + public string Name { get; set; } = string.Empty; /// The normalised key descriptor that triggers this macro. public required string Key { get; init; } diff --git a/src/SharpMUTerm.Core/Automation/TimerDefinition.cs b/src/SharpMUTerm.Core/Automation/TimerDefinition.cs index 04ba8bba..947752c1 100644 --- a/src/SharpMUTerm.Core/Automation/TimerDefinition.cs +++ b/src/SharpMUTerm.Core/Automation/TimerDefinition.cs @@ -8,7 +8,12 @@ namespace SharpMUTerm.Core.Automation; /// public sealed class TimerDefinition { - public string Name { get; init; } = string.Empty; + /// + /// What the timer is called, for the lists that show it. Settable so the F6 screen can rename one + /// live; nothing is derived from it — the is handed a callback and + /// an interval, and never looks a timer up by name — so there is no cache to drop. + /// + public string Name { get; set; } = string.Empty; /// /// Seconds between firings. Values ≤ 0 are treated as disabled. Settable so the F6 screen can edit diff --git a/src/SharpMUTerm.Core/Automation/Trigger.cs b/src/SharpMUTerm.Core/Automation/Trigger.cs index f3ba0b5a..66b59ab6 100644 --- a/src/SharpMUTerm.Core/Automation/Trigger.cs +++ b/src/SharpMUTerm.Core/Automation/Trigger.cs @@ -42,6 +42,24 @@ public sealed class TriggerActions /// Invoke this named script callback (resolved by the scripting layer). public string? ScriptCallback { get; init; } + + /// + /// A copy of these actions. Every field is a value or an immutable string, so a member-wise copy + /// really is a deep one — but it has to be written out rather than shared, because + /// is init-only and two triggers holding the same instance + /// would silently share a gag flag and a route. + /// + public TriggerActions Clone() => new() + { + Gag = Gag, + HighlightForeground = HighlightForeground, + HighlightBackground = HighlightBackground, + AddAttributes = AddAttributes, + Rewrite = Rewrite, + SendResponse = SendResponse, + SpawnTarget = SpawnTarget, + ScriptCallback = ScriptCallback, + }; } /// @@ -53,7 +71,12 @@ public sealed class Trigger private Regex? _compiled; private string _pattern = string.Empty; - public string Name { get; init; } = string.Empty; + /// + /// What the rule is called, for the lists that show it. Settable so the F2 screen can rename a rule + /// live; unlike and nothing is derived from it — + /// the engines match on the pattern and never look a rule up by name — so there is no cache to drop. + /// + public string Name { get; set; } = string.Empty; /// /// The .NET regular expression matched against a line's plain text. Settable so the F2 settings @@ -93,4 +116,21 @@ public required string Pattern Pattern, RegexOptions.Compiled | (CaseSensitive ? RegexOptions.None : RegexOptions.IgnoreCase), AutomationDefaults.RegexMatchTimeout); + + /// + /// A deep copy of this rule — the F2 screen's duplicate button is the caller. The + /// are copied rather than shared: an aliased copy would look right and then + /// follow every later edit of its original's gag, route and highlight around. The compiled + /// is deliberately not carried over; the copy builds its own on first use, so a + /// later pattern edit on either rule cannot be seen by the other. + /// + public Trigger Clone() => new() + { + Name = Name, + Pattern = Pattern, + Enabled = Enabled, + CaseSensitive = CaseSensitive, + StopProcessing = StopProcessing, + Actions = Actions.Clone(), + }; } diff --git a/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs b/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs index 47e3f829..eeed6471 100644 --- a/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs @@ -23,6 +23,37 @@ internal static class AliasesScreenRenderer /// internal const int ColumnWidth = 56; + /// + /// The alias row's field ordinals, in the order ⇥ steps through them. The name leads, as it does on + /// every list screen: ⏎ on an alias — including one just created — opens the value that tells it + /// apart from its neighbours. Named rather than written as literals because the renderer, the model + /// and the tests all address the same ordinals. + /// + internal const int NameField = 0; + + internal const int PatternField = 1; + + internal const int ExpansionField = 2; + + /// The labels the alias list's buttons carry, in the order they are drawn. + internal const string AddAliasLabel = "+ alias"; + + internal const string DuplicateAliasLabel = "⧉ duplicate"; + + internal const string RemoveAliasLabel = "- del"; + + /// + /// What a brand-new alias is called, matches and expands to. None of the three may be blank — + /// refuses an empty regex and an + /// empty expansion — so a new alias is a working placeholder rather than an empty shell that + /// couldn't be committed. It is left enabled because an alias only acts on input the user types. + /// + private const string NewAliasName = "New Alias"; + + private const string NewAliasPattern = "^alias$"; + + private const string NewAliasSubstitution = "look"; + /// /// Merges every sub-block into one line list (header, alias list | editor, footer). Used by the /// unit tests and as a width-agnostic fallback; the live view composes the same blocks into @@ -60,7 +91,7 @@ internal static string HeaderLine(int width, ScreenModel? model = null, ScreenFo { var title = $"[bold {Value}] Aliases[/]"; var hints = ScreenChrome.Hints( - ScreenChrome.ListHints, "F3", model?.HasEditableRow ?? false, focus); + ScreenChrome.ListHints, "F3", model?.HasEditableRow ?? false, focus, model?.HasRemovableRow ?? false); return SpreadLR(" " + title, hints, width); } @@ -77,8 +108,11 @@ internal static ScreenModel Model(IReadOnlyList sets, int selected) var entries = Flatten(sets); var list = ScreenModel.Rows(entries, entry => ScreenRow.Of( ScreenToggle.Bind(() => entry.Alias.Enabled, v => entry.Alias.Enabled = v), + ScreenField.Name("name", () => entry.Alias.Name, v => entry.Alias.Name = v), ScreenField.Pattern("match pattern", () => entry.Alias.Pattern, v => entry.Alias.Pattern = v), - ScreenField.Lines("expansion", () => entry.Alias.Substitution, v => entry.Alias.Substitution = v))); + ScreenField.Lines("expansion", () => entry.Alias.Substitution, v => entry.Alias.Substitution = v))) + .Concat(Buttons(sets, selected)) + .ToArray(); if (selected < 0 || selected >= entries.Count) { @@ -94,6 +128,58 @@ internal static ScreenModel Model(IReadOnlyList sets, int selected) return new ScreenModel(list, editor); } + /// + /// The alias list's buttons. Like F2's, an alias is added to the set that owns the selection, so a + /// new one appears in the set the user is looking at rather than wherever the configuration ends. + /// + /// duplicate is offered here for the same reason it is on F2 and not on F6: an alias carries + /// a regex and a multi-line expansion, and aliases come in families that share the shape of both — + /// copying one and changing a word is the real workflow. It copies through + /// and renames the copy so it can be told apart in the list. + /// + /// + private static List Buttons(IReadOnlyList sets, int selected) + { + var rows = new List(); + if (ScreenLists.Target(sets, s => s.Aliases, selected) is not { } target) + { + return rows; + } + + rows.Add(ScreenRow.Of(ScreenButton.Add( + AddAliasLabel, + target.Items, + () => new Alias + { + Name = NewAliasName, + Pattern = NewAliasPattern, + Substitution = NewAliasSubstitution, + }, + target.Offset))); + + if (ScreenLists.Locate(sets, s => s.Aliases, selected) is not { } slot) + { + return rows; + } + + var source = slot.Items[slot.Index]; + rows.Add(ScreenRow.Of(ScreenButton.Add( + DuplicateAliasLabel, + slot.Items, + () => + { + var copy = source.Clone(); + copy.Name = ScreenLists.Unique(sets.SelectMany(s => s.Aliases).Select(a => a.Name), source.Name); + return copy; + }, + slot.Offset, + source.Name))); + rows.Add(ScreenRow.Of(ScreenButton.Remove( + RemoveAliasLabel, slot.Items, slot.Index, slot.Offset, source.Name))); + + return rows; + } + /// The action bar: which alias is selected on the left, cancel/save on the right. internal static string FooterLine( IReadOnlyList sets, int selected, int width, ScreenFocus? focus = null) @@ -124,7 +210,6 @@ internal static List ListColumn( if (entries.Count == 0) { lines.Add("[dim]no aliases[/]"); - return lines; } for (var i = 0; i < entries.Count; i++) @@ -133,6 +218,8 @@ internal static List ListColumn( lines.Add(ScreenChrome.Cursor(row, cursor.IsOn(0, i), ColumnWidth)); } + lines.Add(string.Empty); + lines.AddRange(ScreenChrome.Buttons(Buttons(sets, selected), cursor, 0, entries.Count, ColumnWidth)); return lines; } @@ -179,10 +266,15 @@ private static string Row(Alias alias, string setName, bool selected) private static List BuildEditor(Alias alias, ScreenFocus cursor, int selected) { + // The name leads the editor because it leads the row's fields: ⏎ on an alias opens it here, + // which is also where one created by [+ alias] lands ready to be called something. var lines = new List { + "[dim]name[/]", + $" {ScreenChrome.Field(Escape(alias.Name), cursor.EditOn(0, selected, NameField))}", + string.Empty, "[dim]match pattern (regex)[/]", - $" {ScreenChrome.Field(Escape(alias.Pattern), cursor.EditOn(0, selected, 0))}", + $" {ScreenChrome.Field(Escape(alias.Pattern), cursor.EditOn(0, selected, PatternField))}", string.Empty, "[dim]expands to[/]", }; @@ -190,7 +282,7 @@ private static List BuildEditor(Alias alias, ScreenFocus cursor, int sel // An expansion is one command per line, so it normally lists. While it is being typed it is a // single buffer with the breaks written \n (see ScreenField.Lines), and it has to be drawn the // way it is being edited — one row — or the caret would have nowhere honest to sit. - if (cursor.EditOn(0, selected, 1) is { } expansion) + if (cursor.EditOn(0, selected, ExpansionField) is { } expansion) { lines.Add(" " + ScreenChrome.Field(string.Empty, expansion)); } diff --git a/src/SharpMUTerm.Tui/DemoScene.cs b/src/SharpMUTerm.Tui/DemoScene.cs index ad4f49a4..42d27a61 100644 --- a/src/SharpMUTerm.Tui/DemoScene.cs +++ b/src/SharpMUTerm.Tui/DemoScene.cs @@ -102,15 +102,15 @@ private static void AddTriggerSets(AppConfiguration config) // the 3x3 grid doing its job (and one command long enough to be ellipsised). Macros = { - new Macro { Key = "Num7", Command = "northwest" }, - new Macro { Key = "Num8", Command = "north" }, - new Macro { Key = "Num9", Command = "northeast" }, - new Macro { Key = "Num4", Command = "west" }, - new Macro { Key = "Num5", Command = "look" }, - new Macro { Key = "Num6", Command = "east" }, - new Macro { Key = "Num1", Command = "look at altar" }, - new Macro { Key = "Num2", Command = "south" }, - new Macro { Key = "Ctrl+F1", Command = "score" }, + new Macro { Name = "walk NW", Key = "Num7", Command = "northwest" }, + new Macro { Name = "walk N", Key = "Num8", Command = "north" }, + new Macro { Name = "walk NE", Key = "Num9", Command = "northeast" }, + new Macro { Name = "walk W", Key = "Num4", Command = "west" }, + new Macro { Name = "look", Key = "Num5", Command = "look" }, + new Macro { Name = "walk E", Key = "Num6", Command = "east" }, + new Macro { Name = "altar", Key = "Num1", Command = "look at altar" }, + new Macro { Name = "walk S", Key = "Num2", Command = "south" }, + new Macro { Name = "score", Key = "Ctrl+F1", Command = "score" }, }, Timers = { new TimerDefinition { Name = "keepalive", IntervalSeconds = 60, Command = "@@idle" } }, }); diff --git a/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs b/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs index f301dc43..888d78eb 100644 --- a/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs @@ -1,4 +1,6 @@ +using System.Globalization; using SharpMUTerm.Core.Automation; +using SharpMUTerm.Core.Configuration; using static SharpMUTerm.Tui.MarkupText; using static SharpMUTerm.Tui.ScreenPalette; @@ -17,6 +19,29 @@ internal static class KeypadScreenRenderer private const int KeyColumnWidth = 12; private const int ColumnWidth = 48; + /// Visible width the binding list's name column is padded to, so the arrows line up. + private const int NameColumnWidth = 14; + + /// + /// The binding row's field ordinals, in the order ⇥ steps through them. The name leads, as it does + /// on every list screen. The key is deliberately not among them: it is + /// 's lookup key, and rebinding it needs a key-capture mode rather than a + /// text buffer — which is also why duplicate is not offered here (see ). + /// + internal const int NameField = 0; + + internal const int CommandField = 1; + + /// The label the binding list's add button carries; it names the key it will claim. + internal const string AddBindingLabel = "+ binding"; + + internal const string RemoveBindingLabel = "- del"; + + /// What a brand-new binding is called and sends, before it is edited. + private const string NewBindingName = "New Binding"; + + private const string NewBindingCommand = "look"; + /// Longest command shown inside a numpad cell before it is ellipsised. private const int NumpadCommandWidth = 10; @@ -37,14 +62,15 @@ internal static class KeypadScreenRenderer /// unit tests and as a width-agnostic fallback; the live view composes the same blocks into /// panels instead. /// - public static List Render(IReadOnlyList macros) + public static List Render( + IReadOnlyList macros, IReadOnlyList? sets = null, int selected = -1) { ArgumentNullException.ThrowIfNull(macros); var left = NumpadColumn(macros); - var right = HotkeysColumn(macros); + var right = HotkeysColumn(macros, null, sets, selected); - var lines = new List { HeaderLine(0, Model(macros)), string.Empty }; + var lines = new List { HeaderLine(0, Model(macros, sets, selected)), string.Empty }; var rowCount = Math.Max(left.Count, right.Count); for (var i = 0; i < rowCount; i++) @@ -55,7 +81,7 @@ public static List Render(IReadOnlyList macros) } lines.Add(string.Empty); - lines.Add(FooterLine(macros, 0)); + lines.Add(FooterLine(macros, 0, null, selected)); return lines; } @@ -69,24 +95,108 @@ internal static string HeaderLine(int width, ScreenModel? model = null, ScreenFo { var title = $"[bold {Value}] Keypad & hotkeys[/]"; var hints = ScreenChrome.Hints( - ScreenChrome.SingleListHints, "F4", model?.HasEditableRow ?? false, focus); + ScreenChrome.SingleListHints, "F4", model?.HasEditableRow ?? false, focus, model?.HasRemovableRow ?? false); return SpreadLR(" " + title, hints, width); } /// /// The screen's one navigable pane: the binding list, where Space enables or disables a macro and - /// ⏎ edits the command it sends. The numpad grid is a projection of the same macros, so it has no - /// cursor of its own — it updates as the list is toggled and edited. + /// ⏎ edits its name and then — with ⇥ — the command it sends. The numpad grid is a projection of + /// the same macros, so it has no cursor of its own — it updates as the list is toggled and edited. /// - internal static ScreenModel Model(IReadOnlyList macros) + /// The bindings to draw, flattened across the sets that own them. + /// + /// The sets those bindings live in, needed only to build the add/remove buttons: a macro's home is + /// a , and a flattened list on its own cannot say which one a new binding + /// belongs to or which one a removal has to come out of. Optional, because a caller that only wants + /// the navigable shape (the header hints, the tests) need not know the configuration's sets — and + /// without them the screen simply offers no buttons rather than offering ones that would throw. + /// + /// Which binding the cursor has anchored, or -1 for none. + internal static ScreenModel Model( + IReadOnlyList macros, IReadOnlyList? sets = null, int selected = -1) { ArgumentNullException.ThrowIfNull(macros); return new ScreenModel(ScreenModel.Rows(macros, macro => ScreenRow.Of( ScreenToggle.Bind(() => macro.Enabled, v => macro.Enabled = v), - ScreenField.Text("command", () => macro.Command, v => macro.Command = v)))); + ScreenField.Name("name", () => macro.Name, v => macro.Name = v), + ScreenField.Text("command", () => macro.Command, v => macro.Command = v))) + .Concat(Buttons(sets, selected)) + .ToArray()); + } + + /// + /// The binding list's buttons. Adding claims the first unbound numpad digit and *says which* + /// ([[+ binding]] Num3): a is identified by its + /// , which this screen deliberately cannot edit (rebinding wants a + /// key-capture mode, not a text buffer), so a button that created a binding on an unspecified or + /// already-taken key would produce a row that is dead and unfixable from here. When every numpad + /// digit is spoken for there is no free key to claim, so the button isn't drawn at all — the same + /// rule that keeps [[- del]] off a pane with nothing selected. + /// + /// For the same reason there is no duplicate: a copy of a binding would land on the key its + /// original already holds, and the second of two macros on one key never fires + /// ( is a dictionary). A button whose only possible result is a dead row + /// is worse than no button. + /// + /// + private static List Buttons(IReadOnlyList? sets, int selected) + { + var rows = new List(); + if (sets is null) + { + return rows; + } + + var bound = sets.SelectMany(s => s.Macros).Select(m => m.Key).ToList(); + if (ScreenLists.Target(sets, s => s.Macros, selected) is { } target + && FreeNumpadKey(bound) is { } key) + { + rows.Add(ScreenRow.Of(ScreenButton.Add( + AddBindingLabel, + target.Items, + () => new Macro { Name = NewBindingName, Key = key, Command = NewBindingCommand }, + target.Offset, + key))); + } + + if (ScreenLists.Locate(sets, s => s.Macros, selected) is { } slot) + { + var source = slot.Items[slot.Index]; + rows.Add(ScreenRow.Of(ScreenButton.Remove( + RemoveBindingLabel, slot.Items, slot.Index, slot.Offset, Identify(source)))); + } + + return rows; } + /// + /// The lowest Num0..Num9 nothing is bound to, or null when they are all taken. + /// Comparison is case-insensitive because 's lookup is. + /// + private static string? FreeNumpadKey(IReadOnlyList bound) + { + for (var digit = 0; digit <= 9; digit++) + { + var key = "Num" + digit.ToString(CultureInfo.InvariantCulture); + if (!bound.Contains(key, StringComparer.OrdinalIgnoreCase)) + { + return key; + } + } + + return null; + } + + /// + /// What to call a binding on screen: its name, falling back to its key. A macro that has never been + /// named would otherwise leave [[- del]] naming nothing at all, which is the one thing a + /// destructive row may not do. + /// + private static string Identify(Macro macro) => + string.IsNullOrWhiteSpace(macro.Name) ? macro.Key : macro.Name; + /// /// The action bar: where the cursor is in the binding list on the left, cancel/save on the right. /// It used to report the screen's inventory instead (9 bindings · 8 of 9 numpad keys bound), @@ -99,18 +209,26 @@ internal static ScreenModel Model(IReadOnlyList macros) /// back to its key, because an empty qualifier would leave the footer saying less than it could. /// /// - internal static string FooterLine(IReadOnlyList macros, int width, ScreenFocus? focus = null) + /// The bindings the list draws. + /// How wide the bar runs. + /// Where the keyboard is, used when no selection is handed in. + /// + /// The anchored selection, or -1 to fall back to the cursor. The list pane now ends in buttons, so + /// the cursor can sit past the list while the selection — and the [[- del]] row's target — + /// stays on the binding the screen is showing; the footer has to report that one, not the last. + /// + internal static string FooterLine( + IReadOnlyList macros, int width, ScreenFocus? focus = null, int selected = -1) { ArgumentNullException.ThrowIfNull(macros); var context = string.Empty; if (macros.Count > 0) { - var selected = Math.Clamp(focus?.Pane == 0 ? focus.Value.Index : 0, 0, macros.Count - 1); - var macro = macros[selected]; - var names = string.IsNullOrWhiteSpace(macro.Name) ? macro.Key : macro.Name; + var at = selected >= 0 ? selected : focus?.Pane == 0 ? focus.Value.Index : 0; + at = Math.Clamp(at, 0, macros.Count - 1); context = ScreenChrome.Context( - ScreenChrome.Position("binding", selected, macros.Count), Escape(names)); + ScreenChrome.Position("binding", at, macros.Count), Escape(Identify(macros[at]))); } var actions = ScreenChrome.Actions(focus: focus); @@ -131,8 +249,12 @@ internal static List NumpadColumn(IReadOnlyList macros) return lines; } - /// The binding list — every macro with its enabled state, key, and command. - internal static List HotkeysColumn(IReadOnlyList macros, ScreenFocus? focus = null) + /// The binding list — every macro with its enabled state, key, name, and command. + internal static List HotkeysColumn( + IReadOnlyList macros, + ScreenFocus? focus = null, + IReadOnlyList? sets = null, + int selected = -1) { ArgumentNullException.ThrowIfNull(macros); @@ -141,15 +263,18 @@ internal static List HotkeysColumn(IReadOnlyList macros, ScreenFo if (macros.Count == 0) { lines.Add(" [dim]no hotkeys[/]"); - return lines; } for (var i = 0; i < macros.Count; i++) { lines.Add(ScreenChrome.Cursor( - Hotkey(macros[i], cursor.EditOn(0, i, 0)), cursor.IsOn(0, i), ColumnWidth)); + Hotkey(macros[i], cursor.EditOn(0, i, NameField), cursor.EditOn(0, i, CommandField)), + cursor.IsOn(0, i), + ColumnWidth)); } + lines.Add(string.Empty); + lines.AddRange(ScreenChrome.Buttons(Buttons(sets, selected), cursor, 0, macros.Count, ColumnWidth)); return lines; } @@ -183,11 +308,23 @@ private static string NumpadCell(int digit, IReadOnlyList macros) return $"[bold {Accent}][[{digit}]][/] {command}"; } - private static string Hotkey(Macro macro, ScreenFieldEdit? edit) + /// + /// One row of the binding list: tick key name → command. The name and the command are both + /// welled, because both are edited here — this screen has no editor pane to draw them in, and the + /// well is the affordance that says which values the keyboard can change (see + /// , and the numpad grid, which has none). The key sits between + /// them unwelled, which is exactly what it is: the one part of a binding this screen cannot change. + /// + private static string Hotkey(Macro macro, ScreenFieldEdit? name, ScreenFieldEdit? command) { var tick = macro.Enabled ? $"[{Accent}]✓[/]" : "[dim]·[/]"; var key = $"[bold]{Escape(macro.Key).PadRight(KeyColumnWidth)}[/]"; - return $"{tick} {key} → {ScreenChrome.Field(Escape(macro.Command), edit)}"; + // A binding that has never been named still gets its well — the name is editable whether or not + // one is set — but with the same em-dash placeholder an unbound numpad cell uses, so the column + // reads as an empty field rather than as a slab of background. + var label = string.IsNullOrWhiteSpace(macro.Name) ? "[dim]—[/]" : $"[{Value}]{Escape(macro.Name)}[/]"; + var named = ScreenChrome.Field(PadVisible(label, NameColumnWidth), name); + return $"{tick} {key} {named} → {ScreenChrome.Field(Escape(macro.Command), command)}"; } private static Macro? FindByKey(IReadOnlyList macros, string key) diff --git a/src/SharpMUTerm.Tui/KeypadScreenView.cs b/src/SharpMUTerm.Tui/KeypadScreenView.cs index 17ea8b60..76f46bec 100644 --- a/src/SharpMUTerm.Tui/KeypadScreenView.cs +++ b/src/SharpMUTerm.Tui/KeypadScreenView.cs @@ -1,4 +1,5 @@ using SharpMUTerm.Core.Automation; +using SharpMUTerm.Core.Configuration; using SharpConsoleUI; using SharpConsoleUI.Builders; using SharpConsoleUI.Controls; @@ -18,17 +19,23 @@ internal static class KeypadScreenView { private const int NumpadColumnWidth = 50; - public static IWindowControl Build(IReadOnlyList macros, int width, ScreenFocus? focus = null) + public static IWindowControl Build( + IReadOnlyList macros, + IReadOnlyList sets, + int selected, + int width, + ScreenFocus? focus = null) { var header = ScreenChrome.Band( - KeypadScreenRenderer.HeaderLine(width, KeypadScreenRenderer.Model(macros), focus), + KeypadScreenRenderer.HeaderLine(width, KeypadScreenRenderer.Model(macros, sets, selected), focus), ScreenPalette.HeaderBg); - var footer = ScreenChrome.Band(KeypadScreenRenderer.FooterLine(macros, width, focus), ScreenPalette.FooterBg); + var footer = ScreenChrome.Band( + KeypadScreenRenderer.FooterLine(macros, width, focus, selected), ScreenPalette.FooterBg); // Body: numpad grid │ hotkey list, as two real columns. var numpadCol = ScreenChrome.Stretch(new MarkupControl(KeypadScreenRenderer.NumpadColumn(macros))); - var hotkeysCol = ScreenChrome.Stretch( - new MarkupControl(ScreenChrome.Indent(KeypadScreenRenderer.HotkeysColumn(macros, focus)))); + var hotkeysCol = ScreenChrome.Stretch(new MarkupControl( + ScreenChrome.Indent(KeypadScreenRenderer.HotkeysColumn(macros, focus, sets, selected)))); var body = Controls.HorizontalGrid() .WithAlignment(HorizontalAlignment.Stretch) .WithVerticalAlignment(VerticalAlignment.Fill) diff --git a/src/SharpMUTerm.Tui/Program.cs b/src/SharpMUTerm.Tui/Program.cs index b2158d0f..85341bb4 100644 --- a/src/SharpMUTerm.Tui/Program.cs +++ b/src/SharpMUTerm.Tui/Program.cs @@ -27,9 +27,12 @@ private static int Main(string[] args) // the snapshot is deterministic however it's launched (terminal, pipe, or CI redirect). Console.SetIn(TextReader.Null); - // With no real config on disk, drive the snapshot off the demo configuration — worlds, - // trigger sets, and a saved LastSession the app resumes exactly like a returning user's. - if (config.Worlds.Count == 0) + // Snapshots always render the demo configuration, never whatever happens to be on this + // machine. They exist for docs images and golden files, and a golden file that changes + // with the developer's own worlds isn't one — the same command has to produce the same + // frame everywhere. `--snapshot --live-config` opts into the real config for debugging + // something only your own setup reproduces. + if (!args.Contains("--live-config")) { config = DemoScene.Build(); } @@ -155,6 +158,7 @@ private static void PrintUsage() Console.WriteLine(" --size Snapshot size in cells (default 160x48)."); Console.WriteLine(" --view Snapshot an overlay (e.g. 'settings') over the workspace."); Console.WriteLine(" '-edit' opens that settings screen mid field edit."); + Console.WriteLine(" --live-config Snapshot your own config instead of the demo worlds."); Console.WriteLine(" --out Write the snapshot to a file instead of stdout."); Console.WriteLine(" -h, --help Show this help."); Console.WriteLine(); diff --git a/src/SharpMUTerm.Tui/ScreenChrome.cs b/src/SharpMUTerm.Tui/ScreenChrome.cs index 5fed5efc..1e877991 100644 --- a/src/SharpMUTerm.Tui/ScreenChrome.cs +++ b/src/SharpMUTerm.Tui/ScreenChrome.cs @@ -24,7 +24,8 @@ internal static class ScreenChrome /// buffer, and saying otherwise would be the same lie in the other direction. /// /// - internal static string Hints(string verbs, string fkey, bool editable = false, ScreenFocus? focus = null) + internal static string Hints( + string verbs, string fkey, bool editable = false, ScreenFocus? focus = null, bool removable = false) { if (focus?.Edit is { } edit) { @@ -35,7 +36,7 @@ internal static string Hints(string verbs, string fkey, bool editable = false, S + $"[{ScreenPalette.Label}] close [/]"; } - var all = editable ? verbs + EditHint : verbs; + var all = (editable ? verbs + EditHint : verbs) + (removable ? DeleteHint : string.Empty); return $"[{ScreenPalette.Label}]{all} · [/][{ScreenPalette.Accent}]{fkey}[/][{ScreenPalette.Label}]/[/]" + $"[{ScreenPalette.Accent}]Esc[/][{ScreenPalette.Label}] close [/]"; } @@ -54,6 +55,14 @@ internal static string Hints(string verbs, string fkey, bool editable = false, S /// internal const string EditHint = " · ⏎ edit"; + /// + /// What a screen adds to its hints when — and only when — a pane offers a way to remove a row. It + /// exists because reaching a [[- del]] row with ↑↓ means walking the cursor past the whole + /// list, and the only key that stepped over it (End) was advertised nowhere. Delete acts on the row + /// the cursor is already on, which is the row the eye is on, and this is where the screen says so. + /// + internal const string DeleteHint = " · Del remove"; + /// The hints that replace a screen's own while a field edit is open. internal const string EditingHints = "⏎ commit · Esc revert"; @@ -168,6 +177,49 @@ internal static string Field(string display, ScreenFieldEdit? edit) /// internal static string ReadOnly(string text) => $"[{ScreenPalette.Muted}]{MarkupText.Escape(text)}[/]"; + /// + /// Draws a pane's button rows, appended after its list. The rows come *from* the pane's own + /// s rather than being written out again per screen, so the label the + /// cursor lands on and the command ⏎ runs cannot drift apart — and every screen paints them the + /// same, which is the whole reason this lives here rather than in five renderers. + /// + /// A button that builds gets the accent and stands alone; one that acts on the selected row is drawn + /// in the label ink and *names its victim* ([[- del]] Aetherfall), because the cursor has to + /// leave the list to reach the button and a destructive key whose target is off-screen is exactly + /// the surprise these screens must not spring. + /// + /// + /// The pane's button rows, in the order the model appends them. + /// Where the keyboard is, so the focused button gets the cursor bar. + /// Which pane these belong to. + /// The pane row index of the first button — i.e. the list's length. + /// How wide the cursor bar runs, matching the pane's other rows. + internal static List Buttons( + IReadOnlyList buttons, ScreenFocus cursor, int pane, int firstIndex, int width) + { + ArgumentNullException.ThrowIfNull(buttons); + + var lines = new List(buttons.Count); + for (var i = 0; i < buttons.Count; i++) + { + if (buttons[i].Button is not { } button) + { + continue; + } + + var ink = button.Kind == ScreenButtonKind.Add ? ScreenPalette.Accent : ScreenPalette.Label; + var row = $"[{ink}][[{MarkupText.Escape(button.Label)}]][/]"; + if (button.Target is { } target) + { + row += $" [{ScreenPalette.Value}]{MarkupText.Escape(target)}[/]"; + } + + lines.Add(Cursor(row, cursor.IsOn(pane, firstIndex + i), width)); + } + + return lines; + } + /// /// Where the cursor is within one of a screen's lists — trigger 1/4, world 2/2. Every /// footer's context line opens with one of these, so the eight screens answer the same question in diff --git a/src/SharpMUTerm.Tui/ScreenField.cs b/src/SharpMUTerm.Tui/ScreenField.cs index 82961bf0..9aa7acda 100644 --- a/src/SharpMUTerm.Tui/ScreenField.cs +++ b/src/SharpMUTerm.Tui/ScreenField.cs @@ -95,6 +95,33 @@ internal static ScreenField Text(string label, Func get, Action Restore(get, set)); } + /// + /// What an item is called: the primary identifier every list screen draws in its leftmost column. + /// Free text, trimmed, rejected when blank or when it carries control characters — a name is drawn + /// into a single row of a fixed-width list, and a tab or a newline inside one would break the + /// column it is drawn in, exactly as it would in a tab title (see ). + /// + /// Deliberately not unique: nothing keys off these names (the engines match on patterns and + /// are keyed by ), and two sets may each + /// legitimately hold a rule called Tell. Only the duplicate buttons name their copies + /// apart, and only so a fresh copy is findable in the list it lands in. + /// + /// + internal static ScreenField Name(string label, Func get, Action set) + { + ArgumentNullException.ThrowIfNull(get); + ArgumentNullException.ThrowIfNull(set); + + return new ScreenField( + label, + get, + value => string.IsNullOrWhiteSpace(value) + ? $"{label} cannot be empty" + : value.Any(char.IsControl) ? $"{label} cannot contain control characters" : null, + value => set(value.Trim()), + Restore(get, set)); + } + /// /// Free text that may be blank, held as null when it is — the "unset, use the default" fields /// (a log directory, an on-connect command). diff --git a/src/SharpMUTerm.Tui/ScreenLists.cs b/src/SharpMUTerm.Tui/ScreenLists.cs new file mode 100644 index 00000000..4e7346bc --- /dev/null +++ b/src/SharpMUTerm.Tui/ScreenLists.cs @@ -0,0 +1,93 @@ +using System.Globalization; +using SharpMUTerm.Core.Configuration; + +namespace SharpMUTerm.Tui; + +/// +/// The arithmetic four settings screens share because their list panes are *flattened*: F2, F3, F4 and +/// F6 each draw one column of every 's rules, aliases, bindings or timers, but +/// the thing itself lives in one particular set's list. A button therefore cannot simply act on "the +/// pane" — it has to find the owning list, the item's index inside it, and how many rows of the pane +/// precede that list, because the cursor is asked for a row of the pane and not for an index into +/// whichever list happens to hold the new item. +/// +/// F5 needs none of this: a world is a row of one list, which is why offset defaults to zero on +/// . +/// +/// +internal static class ScreenLists +{ + /// + /// Where a flattened row lives: the set-owned list holding it, its index within that list, and how + /// many flattened rows precede the list. Null when the index addresses no row at all. + /// + internal static (List Items, int Index, int Offset)? Locate( + IReadOnlyList sets, Func> items, int flattened) + { + ArgumentNullException.ThrowIfNull(sets); + ArgumentNullException.ThrowIfNull(items); + + if (flattened < 0) + { + return null; + } + + var offset = 0; + foreach (var set in sets) + { + var list = items(set); + if (flattened < offset + list.Count) + { + return (list, flattened - offset, offset); + } + + offset += list.Count; + } + + return null; + } + + /// + /// The list a new row goes into: the one holding the selection, so a rule is added beside the rule + /// being looked at rather than wherever the configuration happens to end. With nothing selected it + /// is the first set's list — a screen with no rows at all still has to be able to grow one. Null + /// only when there is no set to put anything in, which is when the add button isn't drawn. + /// + internal static (List Items, int Offset)? Target( + IReadOnlyList sets, Func> items, int selected) + { + ArgumentNullException.ThrowIfNull(sets); + ArgumentNullException.ThrowIfNull(items); + + if (Locate(sets, items, selected) is { } found) + { + return (found.Items, found.Offset); + } + + return sets.Count > 0 ? (items(sets[0]), 0) : null; + } + + /// + /// A name none of already holds: Tell copy, then + /// Tell copy 2. Matching is case-insensitive, because two names differing only in case read + /// as the same name in a list. + /// + /// Names are not required to be unique anywhere (see ) — this exists + /// so a fresh copy is *findable*, not because a collision would break anything. A duplicate landing + /// as a second identical row is the one case where the user cannot tell which one they just made. + /// + /// + internal static string Unique(IEnumerable taken, string name) + { + ArgumentNullException.ThrowIfNull(taken); + + var used = new HashSet(taken, StringComparer.OrdinalIgnoreCase); + var candidate = name + " copy"; + for (var n = 2; used.Contains(candidate); n++) + { + candidate = $"{name} copy {n.ToString(CultureInfo.InvariantCulture)}"; + } + + return candidate; + } +} diff --git a/src/SharpMUTerm.Tui/ScreenModel.cs b/src/SharpMUTerm.Tui/ScreenModel.cs index aabed984..1ce821b2 100644 --- a/src/SharpMUTerm.Tui/ScreenModel.cs +++ b/src/SharpMUTerm.Tui/ScreenModel.cs @@ -55,48 +55,93 @@ internal static ScreenToggle Bind(Func get, Action set) /// /// What the button is called, for the row the renderer draws. /// Performs the change and returns the undo plus where to leave the cursor. -internal readonly record struct ScreenButton(string Label, Func Run) +/// +/// Whether the button builds or destroys, which is what decides how the row is drawn and whether +/// Delete runs it. It is carried here rather than inferred from , because a +/// renderer comparing label strings to decide how to paint a row is one rename away from painting a +/// deletion in the "add" accent. +/// +/// +/// The row this button would act on, named on the button's own row so the screen says what is about to +/// happen. Null for a button that acts on nothing in particular. +/// +internal readonly record struct ScreenButton( + string Label, + Func Run, + ScreenButtonKind Kind = ScreenButtonKind.Add, + string? Target = null) { /// /// Appends a new item and leaves the cursor on it — a new row is worth nothing if the next /// keystroke has to go and find it. + /// + /// is how many of the pane's list rows precede . + /// It is zero when the pane is the list (F5's worlds), and non-zero when the pane flattens + /// several lists into one (F2/F3/F4/F6 show every set's rules in one column, but a rule is added to + /// one particular set), because the cursor is asked for a row of the pane, not an index into the + /// list that happens to hold the new item. + /// /// - internal static ScreenButton Add(string label, IList list, Func create) + internal static ScreenButton Add( + string label, IList list, Func create, int offset = 0, string? target = null) { ArgumentNullException.ThrowIfNull(list); ArgumentNullException.ThrowIfNull(create); - return new ScreenButton(label, () => - { - list.Add(create()); - var at = list.Count - 1; - return new ScreenPress(() => list.RemoveAt(at), at); - }); + return new ScreenButton( + label, + () => + { + list.Add(create()); + var at = list.Count - 1; + return new ScreenPress(() => list.RemoveAt(at), offset + at); + }, + ScreenButtonKind.Add, + target); } /// /// Removes the item at , restoring it *at that index* on undo. The cursor /// stays on the same ordinal, which is now whatever followed the deleted row — the same place the - /// eye is. + /// eye is. means what it does on . /// - internal static ScreenButton Remove(string label, IList list, int index) + internal static ScreenButton Remove( + string label, IList list, int index, int offset = 0, string? target = null) { ArgumentNullException.ThrowIfNull(list); - return new ScreenButton(label, () => - { - if (index < 0 || index >= list.Count) + return new ScreenButton( + label, + () => { - return new ScreenPress(() => { }); - } + if (index < 0 || index >= list.Count) + { + return new ScreenPress(() => { }); + } - var removed = list[index]; - list.RemoveAt(index); - return new ScreenPress(() => list.Insert(index, removed), index); - }); + var removed = list[index]; + list.RemoveAt(index); + return new ScreenPress(() => list.Insert(index, removed), offset + index); + }, + ScreenButtonKind.Remove, + target); } } +/// +/// What a does to the list it sits under. It decides two things a screen +/// must not get wrong: how the row is painted (a build in the accent, a destruction in the muted ink +/// beside the name of its victim), and which button the Delete key runs. +/// +internal enum ScreenButtonKind +{ + /// Puts a row into the list — [+ world], [⧉ duplicate]. + Add, + + /// Takes the selected row out of it — [- del], [- remove]. + Remove, +} + /// /// One row of a settings screen's navigable shape. A row is a plain stop (neither a checkbox nor /// anything to type into), a checkbox, a row of editable fields, a button, or both a checkbox and @@ -226,6 +271,60 @@ internal bool HasEditableRow } } + /// + /// Whether any pane offers a way to take a row out. The Del remove hint is derived from this + /// the way ⏎ edit is derived from : a screen physically cannot + /// advertise the key without offering it. + /// + internal bool HasRemovableRow + { + get + { + for (var pane = 0; pane < _panes.Length; pane++) + { + if (RemoveIn(pane) is not null) + { + return true; + } + } + + return false; + } + } + + /// + /// A pane's destructive button, or null when it has none — what Delete runs while the cursor is on + /// one of that pane's list rows. Delete acts through the button rather than around it, so the key + /// and the drawn [[- del]] row are the same command with the same undo and the same + /// conditions: a pane that doesn't offer the button doesn't answer the key either. + /// + internal ScreenButton? RemoveIn(int pane) + { + if (pane < 0 || pane >= _panes.Length) + { + return null; + } + + foreach (var row in _panes[pane]) + { + if (row.Button is { Kind: ScreenButtonKind.Remove } button) + { + return button; + } + } + + return null; + } + + /// + /// Whether a pane position is one of its *list* rows rather than one of the buttons appended after + /// them. Delete asks this before acting: on a button row the cursor already has ⏎, and deleting the + /// selection from under a row that isn't it would be the surprise the whole selection anchor exists + /// to prevent. + /// + internal bool IsListRow(int pane, int index) => + pane >= 0 && pane < _panes.Length && index >= 0 && index < ListSizes[pane]; + /// The row at a cursor position, or a plain stop when that position holds nothing. internal ScreenRow RowAt(int pane, int index) => pane >= 0 && pane < _panes.Length && index >= 0 && index < _panes[pane].Count diff --git a/src/SharpMUTerm.Tui/SettingsSession.cs b/src/SharpMUTerm.Tui/SettingsSession.cs index 0191f463..2959fca1 100644 --- a/src/SharpMUTerm.Tui/SettingsSession.cs +++ b/src/SharpMUTerm.Tui/SettingsSession.cs @@ -34,7 +34,8 @@ internal enum ScreenAction /// /// /// The keys, in one place: ↑↓ move a row and Home/End jump to a pane's first and last — End is how a -/// pane's trailing buttons are reached without walking the selection to the end of its list; ⏎ +/// pane's trailing buttons are reached without walking the selection to the end of its list; Delete on +/// a list row runs that pane's remove button, so the common case never needs End at all; ⏎ /// activates the focused row when it has something to activate (a field → open an edit, a button → /// run it) and otherwise saves and closes; ⌃S saves from anywhere; Esc cancels the screen, /// except while an edit is open, where it abandons the edit and leaves the screen up. Inside an edit, @@ -153,6 +154,9 @@ private ScreenAction Interpret(ConsoleKeyInfo key) case ConsoleKey.End: return Changed(Selection.MoveTo(int.MaxValue, model.Sizes)); + case ConsoleKey.Delete: + return Remove(model); + case ConsoleKey.Spacebar: return Toggle(model); @@ -161,6 +165,34 @@ private ScreenAction Interpret(ConsoleKeyInfo key) } } + /// + /// Delete on one of a pane's list rows runs that pane's own remove button — the same command, + /// the same undo, the same conditions. It exists because the drawn [[- del]] row sits past + /// the end of the list, so reaching it with ↑↓ walks the cursor over every row on the way; End + /// steps over them without dragging the selection along, but End is a key nothing on screen names. + /// Delete acts on the row the cursor is already on, which is the row the user is looking at, and + /// the header hint says so because derives it. + /// + /// It deliberately does nothing on a button row: the cursor there already has ⏎, and the row it + /// would delete is somewhere else on screen. + /// + /// + private ScreenAction Remove(ScreenModel model) + { + if (!model.IsListRow(Selection.Pane, Selection.Index) + || model.RemoveIn(Selection.Pane) is not { } button) + { + return ScreenAction.None; + } + + if (Edits.Apply(button) is { } select) + { + Selection.Seed(Selection.Pane, select); + } + + return ScreenAction.Redraw; + } + private ScreenAction Toggle(ScreenModel model) { if (model.ToggleAt(Selection.Pane, Selection.Index) is not { } toggle) diff --git a/src/SharpMUTerm.Tui/SharpMUTermApp.cs b/src/SharpMUTerm.Tui/SharpMUTermApp.cs index b1d1049b..0d58ce95 100644 --- a/src/SharpMUTerm.Tui/SharpMUTermApp.cs +++ b/src/SharpMUTerm.Tui/SharpMUTermApp.cs @@ -985,15 +985,20 @@ private ScreenBinding WorldsScreen() session.Focus())); } - /// Opens the F2 Triggers & spawn routing screen: the rule list, then the rule's toggles. + /// + /// Opens the F2 Triggers & spawn routing screen: the rule list, then the rule's toggles. + /// , not CursorIn — the list pane ends in its own + /// buttons, and the cursor has to leave the list to press one. The selection is what the editor + /// pane and the [[- del]] row are about, and it stays on the rule the user was looking at. + /// private ScreenBinding TriggersScreen() { var session = new SettingsSession(selection => - TriggersScreenRenderer.Model(_config.TriggerSets, selection.CursorIn(0), SpawnTargets())); + TriggersScreenRenderer.Model(_config.TriggerSets, selection.SelectionIn(0), SpawnTargets())); return new ScreenBinding(session, () => TriggersScreenView.Build( _config.TriggerSets, - session.Selection.CursorIn(0), + session.Selection.SelectionIn(0), SpawnTargets(), _system.DesktopDimensions.Width, session.Focus())); @@ -1003,28 +1008,38 @@ private ScreenBinding TriggersScreen() private ScreenBinding AliasesScreen() { var session = new SettingsSession(selection => - AliasesScreenRenderer.Model(_config.TriggerSets, selection.CursorIn(0))); + AliasesScreenRenderer.Model(_config.TriggerSets, selection.SelectionIn(0))); return new ScreenBinding(session, () => AliasesScreenView.Build( - _config.TriggerSets, session.Selection.CursorIn(0), _system.DesktopDimensions.Width, session.Focus())); + _config.TriggerSets, session.Selection.SelectionIn(0), _system.DesktopDimensions.Width, session.Focus())); } - /// Opens the F4 Keypad & hotkeys screen: one pane, the binding list. + /// + /// Opens the F4 Keypad & hotkeys screen: one pane, the binding list. The trigger sets go in + /// alongside the flattened macro list because a binding's home is a set — the flattened list alone + /// cannot say which one [[+ binding]] should add to. + /// private ScreenBinding KeypadScreen() { - var session = new SettingsSession(_ => KeypadScreenRenderer.Model(Macros())); + var session = new SettingsSession(selection => + KeypadScreenRenderer.Model(Macros(), _config.TriggerSets, selection.SelectionIn(0))); + return new ScreenBinding(session, () => KeypadScreenView.Build( - Macros(), _system.DesktopDimensions.Width, session.Focus())); + Macros(), + _config.TriggerSets, + session.Selection.SelectionIn(0), + _system.DesktopDimensions.Width, + session.Focus())); } /// Opens the F6 Timers screen: the timer list, then the timer's toggles. private ScreenBinding TimersScreen() { var session = new SettingsSession(selection => - TimersScreenRenderer.Model(_config.TriggerSets, selection.CursorIn(0))); + TimersScreenRenderer.Model(_config.TriggerSets, selection.SelectionIn(0))); return new ScreenBinding(session, () => TimersScreenView.Build( - _config.TriggerSets, session.Selection.CursorIn(0), _system.DesktopDimensions.Width, session.Focus())); + _config.TriggerSets, session.Selection.SelectionIn(0), _system.DesktopDimensions.Width, session.Focus())); } /// Opens the F7 Text & ANSI screen, bound to the app's text preferences. @@ -1063,11 +1078,12 @@ private ScreenBinding OptionsScreen(Func sc /// /// The keys a <name>-edit snapshot drives into a freshly opened screen. ⏎ opens the - /// focused row's first field; ⇥ commits it and steps to the next; the rest is typing. Two screens - /// walk further than the first field, because a still frame should land on the thing that screen's - /// editing actually added: F5 rewrites a host's suffix ("no way to change a host" is the gap the - /// whole mode closes), and F2 steps on to its route group and moves the dot, which is the only way - /// to see that a radio list is live rather than a report. + /// focused row's first field — which on every list screen is now its name — ⇥ commits it + /// and steps to the next, and the rest is typing. Two screens walk further than the first field, + /// because a still frame should land on the thing that screen's editing actually added: F5 rewrites + /// a host's suffix ("no way to change a host" is the gap the whole mode closes), and F2 steps on to + /// its route group and moves the dot, which is the only way to see that a radio list is live rather + /// than a report. /// private static IEnumerable EditSnapshotKeys(string view) { @@ -1075,6 +1091,8 @@ private static IEnumerable EditSnapshotKeys(string view) if (string.Equals(view, "triggers", StringComparison.OrdinalIgnoreCase)) { + // name → pattern → route: two steps, because the name now leads the row's fields. + yield return Stroke('\t', ConsoleKey.Tab); yield return Stroke('\t', ConsoleKey.Tab); yield return Stroke('\0', ConsoleKey.DownArrow); yield break; diff --git a/src/SharpMUTerm.Tui/TimersScreenRenderer.cs b/src/SharpMUTerm.Tui/TimersScreenRenderer.cs index b9a11c5a..67c4a8e1 100644 --- a/src/SharpMUTerm.Tui/TimersScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/TimersScreenRenderer.cs @@ -24,6 +24,36 @@ internal static class TimersScreenRenderer /// internal const int ColumnWidth = 56; + /// + /// The timer row's field ordinals, in the order ⇥ steps through them. The name leads, as it does on + /// every list screen: ⏎ on a timer — including one just created — opens the value that tells it + /// apart from its neighbours. Named rather than written as literals because the renderer, the model + /// and the tests all address the same ordinals. + /// + internal const int NameField = 0; + + internal const int IntervalField = 1; + + internal const int CommandField = 2; + + /// The labels the timer list's buttons carry, in the order they are drawn. + internal const string AddTimerLabel = "+ timer"; + + internal const string RemoveTimerLabel = "- del"; + + /// + /// What a brand-new timer is called, waits and sends. It is created disabled, alone among + /// the four list screens: a timer is the only thing here that acts without being provoked, so a new + /// one left running would start sending a placeholder command at the server a minute later, which + /// nobody asked for. A new trigger only reacts to output and a new binding only to a keypress, so + /// those stay live. + /// + private const string NewTimerName = "New Timer"; + + private const double NewTimerIntervalSeconds = 60; + + private const string NewTimerCommand = "look"; + /// /// Merges every sub-block into one line list (header, timer list | editor, footer). Used by the /// unit tests and as a width-agnostic fallback; the live view composes the same blocks into @@ -61,7 +91,7 @@ internal static string HeaderLine(int width, ScreenModel? model = null, ScreenFo { var title = $"[bold {Value}] Timers[/]"; var hints = ScreenChrome.Hints( - ScreenChrome.ListHints, "F6", model?.HasEditableRow ?? false, focus); + ScreenChrome.ListHints, "F6", model?.HasEditableRow ?? false, focus, model?.HasRemovableRow ?? false); return SpreadLR(" " + title, hints, width); } @@ -78,13 +108,16 @@ internal static ScreenModel Model(IReadOnlyList sets, int selected) var entries = Flatten(sets); var list = ScreenModel.Rows(entries, entry => ScreenRow.Of( ScreenToggle.Bind(() => entry.Timer.Enabled, v => entry.Timer.Enabled = v), + ScreenField.Name("name", () => entry.Timer.Name, v => entry.Timer.Name = v), ScreenField.Number( "interval", () => entry.Timer.IntervalSeconds, v => entry.Timer.IntervalSeconds = v, MinIntervalSeconds, MaxIntervalSeconds), - ScreenField.Text("command", () => entry.Timer.Command, v => entry.Timer.Command = v))); + ScreenField.Text("command", () => entry.Timer.Command, v => entry.Timer.Command = v))) + .Concat(Buttons(sets, selected)) + .ToArray(); if (selected < 0 || selected >= entries.Count) { @@ -111,6 +144,45 @@ internal static ScreenModel Model(IReadOnlyList sets, int selected) /// A day; past this the value is far likelier to be a typo than a schedule. private const double MaxIntervalSeconds = 86400; + /// + /// The timer list's buttons. A timer is added to the set that owns the selection, so a new one + /// appears in the set the user is looking at rather than wherever the configuration ends. + /// + /// There is deliberately no duplicate here, unlike F2 and F3. A timer is three values + /// (interval, command, one-shot), and two of them are exactly what you would change in the copy — + /// so [[+ timer]] and typing is no slower than duplicating and retyping, and the screen is + /// one row shorter for it. A button that saves nobody anything is still a cursor stop. + /// + /// + private static List Buttons(IReadOnlyList sets, int selected) + { + var rows = new List(); + if (ScreenLists.Target(sets, s => s.Timers, selected) is not { } target) + { + return rows; + } + + rows.Add(ScreenRow.Of(ScreenButton.Add( + AddTimerLabel, + target.Items, + () => new TimerDefinition + { + Name = NewTimerName, + IntervalSeconds = NewTimerIntervalSeconds, + Command = NewTimerCommand, + Enabled = false, + }, + target.Offset))); + + if (ScreenLists.Locate(sets, s => s.Timers, selected) is { } slot) + { + rows.Add(ScreenRow.Of(ScreenButton.Remove( + RemoveTimerLabel, slot.Items, slot.Index, slot.Offset, slot.Items[slot.Index].Name))); + } + + return rows; + } + /// The action bar: which timer is selected on the left, cancel/save on the right. internal static string FooterLine( IReadOnlyList sets, int selected, int width, ScreenFocus? focus = null) @@ -141,7 +213,6 @@ internal static List ListColumn( if (entries.Count == 0) { lines.Add("[dim]no timers[/]"); - return lines; } for (var i = 0; i < entries.Count; i++) @@ -150,6 +221,8 @@ internal static List ListColumn( lines.Add(ScreenChrome.Cursor(row, cursor.IsOn(0, i), ColumnWidth)); } + lines.Add(string.Empty); + lines.AddRange(ScreenChrome.Buttons(Buttons(sets, selected), cursor, 0, entries.Count, ColumnWidth)); return lines; } @@ -194,13 +267,20 @@ private static string Row(TimerDefinition timer, string setName, bool selected) return $"{check} {marker} [bold]{name}[/] {schedule} [dim]▪ {Escape(setName)}[/] → {command}"; } + /// + /// The editor rows for one timer. The name leads because it leads the row's fields: ⏎ on a timer + /// opens it here, which is also where one created by [[+ timer]] lands ready to be named. + /// private static List BuildEditor(TimerDefinition timer, ScreenFocus cursor, int selected) => new() { + "[dim]name[/]", + $" {ScreenChrome.Field(Escape(timer.Name), cursor.EditOn(0, selected, NameField))}", + string.Empty, "[dim]interval (seconds)[/]", - $" {ScreenChrome.Field(Seconds(timer), cursor.EditOn(0, selected, 0))}", + $" {ScreenChrome.Field(Seconds(timer), cursor.EditOn(0, selected, IntervalField))}", string.Empty, "[dim]command[/]", - $" {ScreenChrome.Field(Escape(timer.Command), cursor.EditOn(0, selected, 1))}", + $" {ScreenChrome.Field(Escape(timer.Command), cursor.EditOn(0, selected, CommandField))}", string.Empty, ScreenChrome.Cursor(Checkbox("one-shot", timer.OneShot), cursor.IsOn(1, 0), ColumnWidth), ScreenChrome.Cursor(Checkbox("enabled", timer.Enabled), cursor.IsOn(1, 1), ColumnWidth), diff --git a/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs b/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs index b3903a8b..ad62ee5c 100644 --- a/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs @@ -30,11 +30,40 @@ internal static class TriggersScreenRenderer /// internal const string MainWindow = "main"; - /// The rule row's field ordinals, in the order ⇥ steps through them. - private const int PatternField = 0; - private const int RouteField = 1; - private const int ForegroundField = 2; - private const int BackgroundField = 3; + /// + /// The rule row's field ordinals, in the order ⇥ steps through them. The name leads, as it does on + /// every list screen: it is what the row is *called*, so ⏎ on a rule — and on a rule that was just + /// created — opens the one value that tells it apart from its neighbours. They are named constants + /// rather than literals because the renderer, the model and the tests all address the same + /// ordinals, and a screen that grew a field would otherwise silently draw the caret on the wrong row. + /// + internal const int NameField = 0; + + internal const int PatternField = 1; + + internal const int RouteField = 2; + + internal const int ForegroundField = 3; + + internal const int BackgroundField = 4; + + /// The labels the rule list's buttons carry, in the order they are drawn. + internal const string AddTriggerLabel = "+ trigger"; + + internal const string DuplicateTriggerLabel = "⧉ duplicate"; + + internal const string RemoveTriggerLabel = "- del"; + + /// + /// What a brand-new rule is called and matches. The pattern is a placeholder rather than blank + /// because refuses an empty regex, so a blank one could not be + /// committed — and a rule created with no actions at all does nothing to the stream whatever it + /// matches, which is why a new trigger is left enabled while a new timer is not (a timer fires + /// without being provoked; a trigger with nothing to do does not). + /// + private const string NewTriggerName = "New Trigger"; + + private const string NewTriggerPattern = "text to match"; /// The window a rule routes to, as the route field reads and writes it. private static string Route(Trigger trigger) => trigger.Actions.SpawnTarget ?? MainWindow; @@ -106,7 +135,7 @@ internal static string HeaderLine(int width, ScreenModel? model = null, ScreenFo { var title = $"[bold {Value}] Triggers & spawn routing[/]"; var hints = ScreenChrome.Hints( - ScreenChrome.ListHints, "F2", model?.HasEditableRow ?? false, focus); + ScreenChrome.ListHints, "F2", model?.HasEditableRow ?? false, focus, model?.HasRemovableRow ?? false); return SpreadLR(" " + title, hints, width); } @@ -138,6 +167,7 @@ internal static ScreenModel Model( var flattened = Flatten(sets); var rules = ScreenModel.Rows(flattened, entry => ScreenRow.Of( ScreenToggle.Bind(() => entry.Trigger.Enabled, v => entry.Trigger.Enabled = v), + ScreenField.Name("name", () => entry.Trigger.Name, v => entry.Trigger.Name = v), ScreenField.Pattern( "match pattern", () => entry.Trigger.Pattern, v => entry.Trigger.Pattern = v), ScreenField.WindowName( @@ -152,7 +182,9 @@ internal static ScreenModel Model( ScreenField.Colour( "highlight bg", () => entry.Trigger.Actions.HighlightBackground, - v => entry.Trigger.Actions.HighlightBackground = v))); + v => entry.Trigger.Actions.HighlightBackground = v))) + .Concat(Buttons(sets, selectedTrigger)) + .ToArray(); if (selectedTrigger < 0 || selectedTrigger >= flattened.Count) { @@ -169,6 +201,57 @@ internal static ScreenModel Model( return new ScreenModel(rules, editor); } + /// + /// The rule list's buttons. A rule is added to the set that owns the selection rather than to some + /// fixed one, because the list is flattened across every set and a rule appearing in a set the user + /// wasn't looking at would be a change they never asked for; with nothing selected it goes to the + /// first set, and with no sets at all there is nowhere to put one, so the button isn't drawn. + /// + /// duplicate earns its place here more than anywhere else on these screens: a rule is a + /// regex, a route, two colours and three flags, and the way people actually build a rule set is to + /// get one right and then copy it per channel. It deep-copies through + /// — an aliased copy would share its actions with the original, so + /// gagging one would gag both — and the copy is renamed so it can be told from its source in the + /// list it lands in. + /// + /// + private static List Buttons(IReadOnlyList sets, int selected) + { + var rows = new List(); + if (ScreenLists.Target(sets, s => s.Triggers, selected) is not { } target) + { + return rows; + } + + rows.Add(ScreenRow.Of(ScreenButton.Add( + AddTriggerLabel, + target.Items, + () => new Trigger { Name = NewTriggerName, Pattern = NewTriggerPattern }, + target.Offset))); + + if (ScreenLists.Locate(sets, s => s.Triggers, selected) is not { } slot) + { + return rows; + } + + var source = slot.Items[slot.Index]; + rows.Add(ScreenRow.Of(ScreenButton.Add( + DuplicateTriggerLabel, + slot.Items, + () => + { + var copy = source.Clone(); + copy.Name = ScreenLists.Unique(sets.SelectMany(s => s.Triggers).Select(t => t.Name), source.Name); + return copy; + }, + slot.Offset, + source.Name))); + rows.Add(ScreenRow.Of(ScreenButton.Remove( + RemoveTriggerLabel, slot.Items, slot.Index, slot.Offset, source.Name))); + + return rows; + } + /// The action bar: which rule is selected on the left, cancel/save on the right. internal static string FooterLine( IReadOnlyList sets, int selectedTrigger, int width, ScreenFocus? focus = null) @@ -199,7 +282,6 @@ internal static List RulesColumn( if (flattened.Count == 0) { left.Add("[dim]no triggers[/]"); - return left; } for (var i = 0; i < flattened.Count; i++) @@ -209,6 +291,9 @@ internal static List RulesColumn( left.Add(RuleSub(setName, trigger.Actions)); } + left.Add(string.Empty); + left.AddRange(ScreenChrome.Buttons( + Buttons(sets, selectedTrigger), cursor, 0, flattened.Count, ColumnWidth)); return left; } @@ -292,6 +377,7 @@ private static string Flags(TriggerActions actions) private static List BuildEditor( Trigger trigger, IReadOnlyList spawnTargets, ScreenFocus cursor, int index) { + var name = cursor.EditOn(0, index, NameField); var pattern = cursor.EditOn(0, index, PatternField); var route = cursor.EditOn(0, index, RouteField); var foreground = cursor.EditOn(0, index, ForegroundField); @@ -301,8 +387,13 @@ private static List BuildEditor( // the dot before anything is committed — the buffer is what ⏎ would write. var currentRoute = route?.Text ?? Route(trigger); + // The name leads the editor because it leads the row's fields: ⏎ on a rule opens it here, which + // is also where a rule created by [+ trigger] lands ready to be called something. var lines = new List { + "[dim]name[/]", + $" {ScreenChrome.Field(Escape(trigger.Name), name)}", + string.Empty, "[dim]match pattern (regex)[/]", $" {ScreenChrome.Field(Escape(trigger.Pattern), pattern)}", string.Empty, diff --git a/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs b/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs index 553def1b..0635609f 100644 --- a/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs @@ -122,7 +122,7 @@ internal static string HeaderLine(int width, ScreenModel? model = null, ScreenFo { var title = $"[bold {Value}] Worlds & Characters[/]"; var hints = ScreenChrome.Hints( - ScreenChrome.ListHints, "F5", model?.HasEditableRow ?? false, focus); + ScreenChrome.ListHints, "F5", model?.HasEditableRow ?? false, focus, model?.HasRemovableRow ?? false); return SpreadLR(" " + title, hints, width); } @@ -173,7 +173,7 @@ internal static ScreenModel Model( (selectedWorld, selectedCharacter) = Resolve(worlds, selectedWorld, selectedCharacter); var worldRows = ScreenModel.Rows(worlds, w => ScreenRow.Of( - ScreenField.Text("name", () => w.Name, v => w.Name = v), + ScreenField.Name("name", () => w.Name, v => w.Name = v), ScreenField.Text("host", () => w.Host, v => w.Host = v), ScreenField.Integer("port", () => w.Port, v => w.Port = v, 1, 65535), ScreenField.Choice("encoding", () => w.Encoding, v => w.Encoding = v, Encodings), @@ -186,7 +186,7 @@ internal static ScreenModel Model( ? Array.Empty() : ScreenModel.Rows(world.Characters, c => ScreenRow.Of( ScreenToggle.Bind(() => c.AutoLogin, v => c.AutoLogin = v), - ScreenField.Text("name", () => c.Name, v => c.Name = v), + ScreenField.Name("name", () => c.Name, v => c.Name = v), ScreenField.Optional("on connect", () => c.OnConnect, v => c.OnConnect = v))) .Concat(CharacterButtons(world, selectedCharacter)) .ToArray(); @@ -246,7 +246,8 @@ private static List WorldButtons(IReadOnlyList world rows.Add(ScreenRow.Of(ScreenButton.Add(AddWorldLabel, list, () => new WorldDefinition()))); if (selectedWorld >= 0 && selectedWorld < list.Count) { - rows.Add(ScreenRow.Of(ScreenButton.Remove(RemoveWorldLabel, list, selectedWorld))); + rows.Add(ScreenRow.Of(ScreenButton.Remove( + RemoveWorldLabel, list, selectedWorld, target: list[selectedWorld].Name))); } return rows; @@ -276,44 +277,17 @@ private static List CharacterButtons(WorldDefinition world, int selec () => { var copy = source.Clone(); - copy.Name = UniqueName(characters, source.Name); + copy.Name = ScreenLists.Unique(characters.Select(c => c.Name), source.Name); return copy; - }))); - rows.Add(ScreenRow.Of(ScreenButton.Remove(RemoveCharacterLabel, characters, selectedCharacter))); + }, + target: source.Name))); + rows.Add(ScreenRow.Of(ScreenButton.Remove( + RemoveCharacterLabel, characters, selectedCharacter, target: source.Name))); } return rows; } - /// - /// A name no character in already holds: Kaz copy, then - /// Kaz copy 2. Matching is case-insensitive because the session key is, so two names that - /// differ only in case would still collide. - /// - private static string UniqueName(IReadOnlyList characters, string name) - { - var candidate = name + " copy"; - for (var n = 2; Taken(characters, candidate); n++) - { - candidate = $"{name} copy {n.ToString(CultureInfo.InvariantCulture)}"; - } - - return candidate; - } - - private static bool Taken(IReadOnlyList characters, string name) - { - foreach (var character in characters) - { - if (string.Equals(character.Name, name, StringComparison.OrdinalIgnoreCase)) - { - return true; - } - } - - return false; - } - internal static string FooterLine( IReadOnlyList worlds, int selectedWorld, @@ -369,14 +343,8 @@ internal static List WorldsColumn( } left.Add(string.Empty); - AppendButtons( - left, - WorldButtons(worlds, selectedWorld), - cursor, - 0, - worlds.Count, - LeftColumnWidth, - selectedWorld >= 0 && selectedWorld < worlds.Count ? worlds[selectedWorld].Name : null); + left.AddRange(ScreenChrome.Buttons( + WorldButtons(worlds, selectedWorld), cursor, 0, worlds.Count, LeftColumnWidth)); return left; } @@ -439,16 +407,8 @@ internal static List DetailColumn( } right.Add(string.Empty); - AppendButtons( - right, - CharacterButtons(world, selectedCharacter), - cursor, - 1, - world.Characters.Count, - CharacterRowWidth, - selectedCharacter >= 0 && selectedCharacter < world.Characters.Count - ? world.Characters[selectedCharacter].Name - : null); + right.AddRange(ScreenChrome.Buttons( + CharacterButtons(world, selectedCharacter), cursor, 1, world.Characters.Count, CharacterRowWidth)); return right; } @@ -478,42 +438,6 @@ internal static List FormColumn( }; } - /// - /// Draws a pane's button rows, in the same order and under the same conditions the model builds - /// them — the rows come *from* the model's own buttons rather than being written out again here, - /// so the label the cursor lands on and the command ⏎ runs cannot drift apart. - /// - private static void AppendButtons( - List lines, - IReadOnlyList buttons, - ScreenFocus cursor, - int pane, - int firstIndex, - int barWidth, - string? target) - { - for (var i = 0; i < buttons.Count; i++) - { - if (buttons[i].Button is not { } button) - { - continue; - } - - // A button that adds needs no target and gets the accent; one that acts on the selected row - // names it, because the cursor has to leave the list to reach the button and a destructive - // key whose victim is off-screen is exactly the kind of surprise these screens must not - // spring. - var adds = button.Label == AddWorldLabel || button.Label == AddCharacterLabel; - var row = $"[{(adds ? Accent : Label)}][[{Escape(button.Label)}]][/]"; - if (!adds && target is not null) - { - row += $" [{Value}]{Escape(target)}[/]"; - } - - lines.Add(ScreenChrome.Cursor(row, cursor.IsOn(pane, firstIndex + i), barWidth)); - } - } - /// Draws a value as a field, showing the buffer and caret when its edit is the open one. private static string Field(string display, ScreenFocus cursor, int index, int field, int pane = 0) => ScreenChrome.Field(display, cursor.EditOn(pane, index, field)); diff --git a/tests/SharpMUTerm.Core.Tests/Automation/AutomationCloneTests.cs b/tests/SharpMUTerm.Core.Tests/Automation/AutomationCloneTests.cs new file mode 100644 index 00000000..da21c767 --- /dev/null +++ b/tests/SharpMUTerm.Core.Tests/Automation/AutomationCloneTests.cs @@ -0,0 +1,163 @@ +using SharpMUTerm.Core.Automation; +using SharpMUTerm.Core.Text; + +namespace SharpMUTerm.Core.Tests.Automation; + +/// +/// and — the deep copy the F2 and F3 screens' +/// duplicate buttons are built on, and the same contract +/// pins for worlds and characters: a copy that shared +/// anything mutable with its original would look correct on screen and only betray itself later, when +/// an edit to one silently landed on both. +/// +/// The compiled is the sharp edge here. It is cached, so a copy that +/// inherited it would go on matching its source's pattern after its own had been edited — +/// invisibly, until a line arrived. +/// +/// +public class AutomationCloneTests +{ + private static Trigger Trigger() => new() + { + Name = "Tell", + Pattern = "tells you", + Enabled = false, + CaseSensitive = true, + StopProcessing = true, + Actions = new TriggerActions + { + Gag = true, + HighlightForeground = TerminalColor.FromRgb(0xff, 0xd7, 0x00), + HighlightBackground = TerminalColor.FromIndex(4), + AddAttributes = TextAttributes.Bold, + Rewrite = "[$1]", + SendResponse = "page $1=hi", + SpawnTarget = "Chat", + ScriptCallback = "onTell", + }, + }; + + private static Alias Alias() => new() + { + Name = "gr", + Pattern = "^gr (.*)$", + Enabled = false, + CaseSensitive = true, + Substitution = "greet $1\nwave $1", + ScriptCallback = "onGreet", + }; + + [Test] + public async Task TriggerClone_CopiesEveryValue() + { + var copy = Trigger().Clone(); + + await Assert.That(copy.Name).IsEqualTo("Tell"); + await Assert.That(copy.Pattern).IsEqualTo("tells you"); + await Assert.That(copy.Enabled).IsFalse(); + await Assert.That(copy.CaseSensitive).IsTrue(); + await Assert.That(copy.StopProcessing).IsTrue(); + await Assert.That(copy.Actions.Gag).IsTrue(); + await Assert.That(copy.Actions.HighlightForeground) + .IsEqualTo(TerminalColor.FromRgb(0xff, 0xd7, 0x00)); + await Assert.That(copy.Actions.HighlightBackground).IsEqualTo(TerminalColor.FromIndex(4)); + await Assert.That(copy.Actions.AddAttributes).IsEqualTo(TextAttributes.Bold); + await Assert.That(copy.Actions.Rewrite).IsEqualTo("[$1]"); + await Assert.That(copy.Actions.SendResponse).IsEqualTo("page $1=hi"); + await Assert.That(copy.Actions.SpawnTarget).IsEqualTo("Chat"); + await Assert.That(copy.Actions.ScriptCallback).IsEqualTo("onTell"); + } + + [Test] + public async Task TriggerClone_DoesNotShareItsActionsWithTheOriginal() + { + var original = Trigger(); + var copy = original.Clone(); + + await Assert.That(ReferenceEquals(copy.Actions, original.Actions)).IsFalse(); + + copy.Actions.Gag = false; + copy.Actions.SpawnTarget = "Pages"; + copy.Actions.HighlightForeground = null; + + await Assert.That(original.Actions.Gag).IsTrue(); + await Assert.That(original.Actions.SpawnTarget).IsEqualTo("Chat"); + await Assert.That(original.Actions.HighlightForeground).IsNotNull(); + } + + /// + /// The cached matcher must not travel with the copy. Both sides are asserted, because a copy that + /// silently kept its source's compiled regex would still pass every value comparison above. + /// + [Test] + public async Task TriggerClone_CompilesItsOwnMatcher() + { + var original = new Trigger { Name = "Tell", Pattern = "tells you" }; + _ = original.Regex; // force the original to cache one before the copy is taken + + var copy = original.Clone(); + copy.Pattern = "pages you"; + + await Assert.That(copy.Regex.IsMatch("she pages you")).IsTrue(); + await Assert.That(copy.Regex.IsMatch("she tells you")).IsFalse(); + await Assert.That(original.Regex.IsMatch("she tells you")).IsTrue(); + } + + [Test] + public async Task AliasClone_CopiesEveryValue() + { + var copy = Alias().Clone(); + + await Assert.That(copy.Name).IsEqualTo("gr"); + await Assert.That(copy.Pattern).IsEqualTo("^gr (.*)$"); + await Assert.That(copy.Enabled).IsFalse(); + await Assert.That(copy.CaseSensitive).IsTrue(); + await Assert.That(copy.Substitution).IsEqualTo("greet $1\nwave $1"); + await Assert.That(copy.ScriptCallback).IsEqualTo("onGreet"); + } + + [Test] + public async Task AliasClone_CompilesItsOwnMatcher() + { + var original = new Alias { Name = "k", Pattern = "^k$" }; + _ = original.Regex; + + var copy = original.Clone(); + copy.Pattern = "^kk$"; + + await Assert.That(copy.Regex.IsMatch("kk")).IsTrue(); + await Assert.That(copy.Regex.IsMatch("k")).IsFalse(); + await Assert.That(original.Regex.IsMatch("k")).IsTrue(); + } + + /// + /// Renaming is what the F2/F3/F4/F6 screens' name fields do, and it must stay free of the matcher — + /// unlike and , which drop the + /// cached regex on write. This is the "check for cached derived state" question answered the other + /// way: there is none, and a rename must not invalidate anything. + /// + [Test] + public async Task RenamingLeavesTheCompiledMatcherAlone() + { + var trigger = new Trigger { Name = "Tell", Pattern = "tells you" }; + var compiled = trigger.Regex; + trigger.Name = "Whisper"; + await Assert.That(ReferenceEquals(trigger.Regex, compiled)).IsTrue(); + + var alias = new Alias { Name = "k", Pattern = "^k$" }; + var aliasCompiled = alias.Regex; + alias.Name = "kill"; + await Assert.That(ReferenceEquals(alias.Regex, aliasCompiled)).IsTrue(); + + // The other two carry no matcher at all; they are asserted here so the whole set of newly + // writable names is covered in one place. + var timer = new TimerDefinition { Name = "ping", IntervalSeconds = 30, Command = "look" }; + timer.Name = "pong"; + await Assert.That(timer.Name).IsEqualTo("pong"); + + var macro = new Macro { Name = "look", Key = "Num5", Command = "look" }; + macro.Name = "survey"; + await Assert.That(macro.Name).IsEqualTo("survey"); + await Assert.That(macro.Key).IsEqualTo("Num5"); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenDeleteKeyTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenDeleteKeyTests.cs new file mode 100644 index 00000000..1a51c23c --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/ScreenDeleteKeyTests.cs @@ -0,0 +1,243 @@ +using SharpMUTerm.Core.Automation; +using SharpMUTerm.Core.Configuration; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// Delete on a list row, which is the fix for the one usability hole F5's button rows left behind. A +/// pane's [[- del]] sits past the end of its list, so ↑↓ can only reach it by walking the cursor +/// over every row on the way — and the selection walks with it, which is why +/// exists at all. End steps over the list without +/// re-anchoring and fixes that, but End is a key nothing on screen ever named, so nobody would find it. +/// +/// Delete acts on the row the cursor is already on. It runs the pane's own remove button rather than +/// deleting around it, so the key and the drawn row are one command with one undo and one set of +/// conditions; and the header advertises it only when the model really offers one, which is the same +/// honesty rule holds ⏎ edit to. +/// +/// +public class ScreenDeleteKeyTests +{ + private static ConsoleKeyInfo Key(ConsoleKey key) => new('\0', key, false, false, false); + + private static List Sets() => new() + { + new TriggerSet + { + Name = "Comms", + Triggers = new List + { + new() { Name = "Tell", Pattern = "tells you" }, + new() { Name = "Spam", Pattern = "guild" }, + }, + Aliases = new List { new() { Name = "gr", Pattern = "^gr$", Substitution = "greet" } }, + Macros = new List { new() { Name = "Look", Key = "Num5", Command = "look" } }, + Timers = new List { new() { Name = "ping", IntervalSeconds = 30, Command = "look" } }, + }, + }; + + private static List Worlds() => new() + { + new WorldDefinition + { + Name = "Aetherfall", + Host = "aetherfall.mux", + Characters = new List { new() { Name = "Corvid" }, new() { Name = "Wren" } }, + }, + new WorldDefinition { Name = "Grapevine", Host = "grapevine.haus" }, + }; + + /// + /// The interaction the whole change is for: sit on a row, press Delete, and that row goes — no walk + /// to the end of the list, no key nobody knows about, and the same undo the button hands back. + /// + [Test] + public async Task Delete_RemovesTheRowTheCursorIsOn() + { + var sets = Sets(); + var session = new SettingsSession( + selection => TriggersScreenRenderer.Model(sets, selection.SelectionIn(0))); + + session.Handle(Key(ConsoleKey.DownArrow)); + await Assert.That(session.Handle(Key(ConsoleKey.Delete))).IsEqualTo(ScreenAction.Redraw); + + await Assert.That(sets[0].Triggers.Select(t => t.Name)).IsEquivalentTo(new[] { "Tell" }); + + session.Edits.Revert(); + await Assert.That(sets[0].Triggers.Select(t => t.Name)).IsEquivalentTo(new[] { "Tell", "Spam" }); + } + + /// The same key, the same result, on all five screens with a list. + [Test] + public async Task Delete_WorksOnEveryScreenThatHasSomethingToRemove() + { + var sets = Sets(); + var worlds = Worlds(); + + var triggers = new SettingsSession(s => TriggersScreenRenderer.Model(sets, s.SelectionIn(0))); + var aliases = new SettingsSession(s => AliasesScreenRenderer.Model(sets, s.SelectionIn(0))); + var timers = new SettingsSession(s => TimersScreenRenderer.Model(sets, s.SelectionIn(0))); + var keypad = new SettingsSession(s => KeypadScreenRenderer.Model( + sets.SelectMany(x => x.Macros).ToList(), sets, s.SelectionIn(0))); + var f5 = new SettingsSession(s => WorldsScreenRenderer.Model( + worlds, sets, s.SelectionIn(0), s.SelectionIn(1))); + + foreach (var session in new[] { triggers, aliases, timers, keypad, f5 }) + { + await Assert.That(session.Handle(Key(ConsoleKey.Delete))).IsEqualTo(ScreenAction.Redraw); + } + + await Assert.That(sets[0].Triggers.Select(t => t.Name)).IsEquivalentTo(new[] { "Spam" }); + await Assert.That(sets[0].Aliases).IsEmpty(); + await Assert.That(sets[0].Timers).IsEmpty(); + await Assert.That(sets[0].Macros).IsEmpty(); + await Assert.That(worlds.Select(w => w.Name)).IsEquivalentTo(new[] { "Grapevine" }); + } + + /// + /// Delete belongs to the pane the cursor is in, so on F5 it takes out a character rather than the + /// world above it — which is exactly the confusion a single global "delete the selection" would + /// cause on a screen with three panes. + /// + [Test] + public async Task Delete_ActsOnTheFocusedPane() + { + var worlds = Worlds(); + var sets = Sets(); + var session = new SettingsSession(selection => WorldsScreenRenderer.Model( + worlds, sets, selection.SelectionIn(0), selection.SelectionIn(1))); + + session.Handle(Key(ConsoleKey.Tab)); // into the character pane + session.Handle(Key(ConsoleKey.DownArrow)); // onto the second character + session.Handle(Key(ConsoleKey.Delete)); + + await Assert.That(worlds).Count().IsEqualTo(2); + await Assert.That(worlds[0].Characters.Select(c => c.Name)).IsEquivalentTo(new[] { "Corvid" }); + + session.Edits.Revert(); + await Assert.That(worlds[0].Characters.Select(c => c.Name)).IsEquivalentTo(new[] { "Corvid", "Wren" }); + } + + /// + /// On a button row Delete does nothing at all. The cursor there already has ⏎, and the row it would + /// delete is somewhere else on screen — deleting it from under a cursor that isn't on it is the + /// surprise the selection anchor exists to prevent. + /// + [Test] + public async Task Delete_DoesNothingOnAButtonRow() + { + var sets = Sets(); + var session = new SettingsSession( + selection => TriggersScreenRenderer.Model(sets, selection.SelectionIn(0))); + + session.Handle(Key(ConsoleKey.End)); // the last row of the pane is [- del] + + await Assert.That(session.Handle(Key(ConsoleKey.Delete))).IsEqualTo(ScreenAction.None); + await Assert.That(sets[0].Triggers).Count().IsEqualTo(2); + await Assert.That(session.Edits.IsDirty).IsFalse(); + } + + /// + /// A pane with no remove button doesn't answer the key either — the key and the drawn row are the + /// same command, so they are offered under the same conditions. F5's trigger-set pane is + /// assignment, not ownership: there is nothing there to delete. + /// + [Test] + public async Task Delete_IsLeftForTheFrameworkWhereThereIsNothingToRemove() + { + var worlds = Worlds(); + var sets = Sets(); + var session = new SettingsSession(selection => WorldsScreenRenderer.Model( + worlds, sets, selection.SelectionIn(0), selection.SelectionIn(1))); + + session.Handle(Key(ConsoleKey.Tab)); + session.Handle(Key(ConsoleKey.Tab)); // into the assigned-trigger-sets pane + + await Assert.That(session.Focus().Pane).IsEqualTo(2); + await Assert.That(session.Handle(Key(ConsoleKey.Delete))).IsEqualTo(ScreenAction.None); + await Assert.That(sets).Count().IsEqualTo(1); + } + + /// + /// Mid-edit Delete belongs to the buffer, not to the list. It would be a spectacular way to lose a + /// row: backspacing past the end of a name and deleting the thing you were naming. + /// + [Test] + public async Task Delete_TakesACharacterOutOfAnOpenBufferRatherThanTheRow() + { + var sets = Sets(); + var session = new SettingsSession( + selection => TriggersScreenRenderer.Model(sets, selection.SelectionIn(0))); + + session.Handle(Key(ConsoleKey.Enter)); + session.Handle(Key(ConsoleKey.Home)); + session.Handle(Key(ConsoleKey.Delete)); + + await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("ell"); + await Assert.That(sets[0].Triggers).Count().IsEqualTo(2); + } + + /// + /// The honesty rule, in both directions: a screen advertises Del remove if and only + /// if its model actually offers a way to remove a row. Both cases have to be represented, or an + /// "if and only if" passes vacuously. + /// + [Test] + public async Task HeaderHints_ClaimDeleteExactlyWhenTheModelOffersIt() + { + var sets = Sets(); + var worlds = Worlds(); + var empty = new List(); + + var screens = new List<(string Name, string Header, ScreenModel Model)>(); + + void Add(string name, ScreenModel model, Func header) => + screens.Add((name, header(model), model)); + + Add("F2", TriggersScreenRenderer.Model(sets, 0), m => TriggersScreenRenderer.HeaderLine(120, m)); + Add("F3", AliasesScreenRenderer.Model(sets, 0), m => AliasesScreenRenderer.HeaderLine(120, m)); + Add("F4", KeypadScreenRenderer.Model(sets[0].Macros, sets, 0), m => KeypadScreenRenderer.HeaderLine(120, m)); + Add("F5", WorldsScreenRenderer.Model(worlds, sets, 0, 0), m => WorldsScreenRenderer.HeaderLine(120, m)); + Add("F6", TimersScreenRenderer.Model(sets, 0), m => TimersScreenRenderer.HeaderLine(120, m)); + Add("F2 empty", TriggersScreenRenderer.Model(empty, -1), m => TriggersScreenRenderer.HeaderLine(120, m)); + Add("F3 empty", AliasesScreenRenderer.Model(empty, -1), m => AliasesScreenRenderer.HeaderLine(120, m)); + Add("F4 no sets", KeypadScreenRenderer.Model(Array.Empty()), m => KeypadScreenRenderer.HeaderLine(120, m)); + Add("F6 empty", TimersScreenRenderer.Model(empty, -1), m => TimersScreenRenderer.HeaderLine(120, m)); + Add( + "F7 options", + OptionsScreenRenderer.Model(OptionsScreenRenderer.TextAnsiScreen()), + m => OptionsScreenRenderer.HeaderLine("Text & ANSI", "F7", 120, m)); + + await Assert.That(screens.Any(s => s.Model.HasRemovableRow)).IsTrue(); + await Assert.That(screens.Any(s => !s.Model.HasRemovableRow)).IsTrue(); + + foreach (var (name, header, model) in screens) + { + await Assert.That(header.Contains(ScreenChrome.DeleteHint, StringComparison.Ordinal)) + .IsEqualTo(model.HasRemovableRow) + .Because(name); + } + } + + /// + /// End still works and still doesn't re-anchor — Delete is the discoverable path to the common + /// case, not a replacement for reaching [+ …], which has no key of its own. + /// + [Test] + public async Task End_StillReachesAPanesButtonsWithoutMovingItsSelection() + { + var sets = Sets(); + var session = new SettingsSession( + selection => TriggersScreenRenderer.Model(sets, selection.SelectionIn(0))); + + await Assert.That(session.Selection.SelectionIn(0)).IsEqualTo(0); + session.Handle(Key(ConsoleKey.End)); + + await Assert.That(session.Focus().Index).IsEqualTo(4); // 2 rules + add + duplicate + del + await Assert.That(session.Selection.SelectionIn(0)).IsEqualTo(0); + + session.Handle(Key(ConsoleKey.Enter)); + await Assert.That(sets[0].Triggers.Select(t => t.Name)).IsEquivalentTo(new[] { "Spam" }); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenFieldRenderingTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenFieldRenderingTests.cs index 6bba9137..dd432110 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenFieldRenderingTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenFieldRenderingTests.cs @@ -111,7 +111,7 @@ public async Task Worlds_TheCharacterFormEditsTheCharacterRowsFields() public async Task Triggers_DrawsThePatternBufferUnderItsOwnLabel() { var lines = TriggersScreenRenderer.EditorColumn( - Sets(), 0, Array.Empty(), Edit(0, 0, 0, "pages you")); + Sets(), 0, Array.Empty(), Edit(0, 0, TriggersScreenRenderer.PatternField, "pages you")); await Assert.That(Carets(lines)).IsEqualTo(1); var edited = lines.Single(HasCaret); @@ -119,47 +119,86 @@ public async Task Triggers_DrawsThePatternBufferUnderItsOwnLabel() await Assert.That(lines[lines.IndexOf(edited) - 1]).Contains("match pattern"); } + /// + /// The name is the first field of every list row, so it is the one ⏎ opens — and the editor pane + /// has to draw it, or ⏎ on a freshly added rule would type into a value nothing on screen shows. + /// [Test] - public async Task Aliases_DrawsThePatternAndCollapsesTheExpansionToTheRowBeingTyped() + public async Task Triggers_DrawsTheNameBufferUnderItsOwnLabel() + { + var lines = TriggersScreenRenderer.EditorColumn( + Sets(), 0, Array.Empty(), Edit(0, 0, TriggersScreenRenderer.NameField, "Whisper")); + + await Assert.That(Carets(lines)).IsEqualTo(1); + var edited = lines.Single(HasCaret); + await Assert.That(edited).Contains("Whispe"); + await Assert.That(lines[lines.IndexOf(edited) - 1]).Contains("name"); + } + + [Test] + public async Task Aliases_DrawsTheNamePatternAndCollapsesTheExpansionToTheRowBeingTyped() { var sets = Sets(); - var pattern = AliasesScreenRenderer.EditorColumn(sets, 0, Edit(0, 0, 0, "^kk$")); + var name = AliasesScreenRenderer.EditorColumn(sets, 0, Edit(0, 0, AliasesScreenRenderer.NameField, "kk")); + await Assert.That(Carets(name)).IsEqualTo(1); + await Assert.That(name.Single(HasCaret)).Contains("kk"); + + var pattern = AliasesScreenRenderer.EditorColumn( + sets, 0, Edit(0, 0, AliasesScreenRenderer.PatternField, "^kk$")); await Assert.That(Carets(pattern)).IsEqualTo(1); await Assert.That(pattern.Single(HasCaret)).Contains("^kk$"); // Off-edit the expansion lists one command per line; being typed it is one escaped row. await Assert.That(AliasesScreenRenderer.EditorColumn(sets, 0).Count(l => l.Contains("say done"))).IsEqualTo(1); - var expansion = AliasesScreenRenderer.EditorColumn(sets, 0, Edit(0, 0, 1, @"kill $1\nsay done")); + var expansion = AliasesScreenRenderer.EditorColumn( + sets, 0, Edit(0, 0, AliasesScreenRenderer.ExpansionField, @"kill $1\nsay done")); await Assert.That(Carets(expansion)).IsEqualTo(1); await Assert.That(expansion.Single(HasCaret)).Contains(@"kill $1\nsay don"); } [Test] - public async Task Timers_DrawsTheIntervalAndCommandBuffers() + public async Task Timers_DrawsTheNameIntervalAndCommandBuffers() { var sets = Sets(); - var interval = TimersScreenRenderer.EditorColumn(sets, 0, Edit(0, 0, 0, "45")); + var name = TimersScreenRenderer.EditorColumn(sets, 0, Edit(0, 0, TimersScreenRenderer.NameField, "pong")); + await Assert.That(Carets(name)).IsEqualTo(1); + await Assert.That(name.Single(HasCaret)).Contains("pon"); + + var interval = TimersScreenRenderer.EditorColumn( + sets, 0, Edit(0, 0, TimersScreenRenderer.IntervalField, "45")); await Assert.That(Carets(interval)).IsEqualTo(1); await Assert.That(interval.Single(HasCaret)).Contains("45"); - var command = TimersScreenRenderer.EditorColumn(sets, 0, Edit(0, 0, 1, "score")); + var command = TimersScreenRenderer.EditorColumn( + sets, 0, Edit(0, 0, TimersScreenRenderer.CommandField, "score")); await Assert.That(command.Single(HasCaret)).Contains("scor"); } + /// + /// F4 has no editor pane, so both of a binding's editable values are drawn — and typed — in the + /// binding row itself, on either side of the key it is bound to. + /// [Test] - public async Task Keypad_DrawsTheCommandBufferInTheBindingRowItself() + public async Task Keypad_DrawsTheNameAndCommandBuffersInTheBindingRowItself() { var macros = Sets()[0].Macros; - var lines = KeypadScreenRenderer.HotkeysColumn(macros, Edit(0, 0, 0, "look here")); + var command = KeypadScreenRenderer.HotkeysColumn( + macros, Edit(0, 0, KeypadScreenRenderer.CommandField, "look here")); - await Assert.That(Carets(lines)).IsEqualTo(1); - var edited = lines.Single(HasCaret); + await Assert.That(Carets(command)).IsEqualTo(1); + var edited = command.Single(HasCaret); await Assert.That(edited).Contains("Num5"); await Assert.That(edited).Contains("look her"); + + var name = KeypadScreenRenderer.HotkeysColumn( + macros, Edit(0, 0, KeypadScreenRenderer.NameField, "Survey")); + + await Assert.That(Carets(name)).IsEqualTo(1); + await Assert.That(name.Single(HasCaret)).Contains("Surve"); } [Test] @@ -191,7 +230,8 @@ public async Task ARefusedValueIsMarkedOnTheRowThatRefusedIt() [Test] public async Task BracketsTypedIntoABufferAreEscaped_NotRenderedAsMarkup() { - var lines = KeypadScreenRenderer.HotkeysColumn(Sets()[0].Macros, Edit(0, 0, 0, "say [red]hi")); + var lines = KeypadScreenRenderer.HotkeysColumn( + Sets()[0].Macros, Edit(0, 0, KeypadScreenRenderer.CommandField, "say [red]hi")); var edited = lines.Single(HasCaret); await Assert.That(edited).Contains("[[red]]hi"); diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenListButtonTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenListButtonTests.cs new file mode 100644 index 00000000..a6bad1cc --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/ScreenListButtonTests.cs @@ -0,0 +1,435 @@ +using SharpMUTerm.Core.Automation; +using SharpMUTerm.Core.Configuration; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// The add/remove buttons on F2, F3, F4 and F6 — the four screens that could show you a trigger, an +/// alias, a binding or a timer and give you no way to make or unmake one. They follow F5's shape +/// exactly ( pins that one): a performs the +/// change and hands back its own undo, a removal restores at its original index rather than on the +/// end, a button that would act on nothing is not drawn, and a destructive button names its target. +/// +/// What is different here, and is most of what these assert, is that all four panes are +/// flattened across every . The pane is one column; the thing lives +/// in one particular set's list. So a button has to find the owning list and translate between an +/// index into it and a row of the pane — get that wrong and [[+ trigger]] leaves the cursor on +/// somebody else's rule. +/// +/// +public class ScreenListButtonTests +{ + private static ConsoleKeyInfo Key(ConsoleKey key) => new('\0', key, false, false, false); + + private static List Sets() => new() + { + new TriggerSet + { + Name = "Comms", + Triggers = new List + { + new() { Name = "Tell", Pattern = "tells you", Actions = new TriggerActions { Gag = true } }, + new() { Name = "Spam", Pattern = "guild", Actions = new TriggerActions() }, + }, + Aliases = new List { new() { Name = "gr", Pattern = "^gr$", Substitution = "greet\nwave" } }, + Macros = new List { new() { Name = "Look", Key = "Num5", Command = "look" } }, + Timers = new List { new() { Name = "ping", IntervalSeconds = 30, Command = "look" } }, + }, + new TriggerSet + { + Name = "Trade", + Triggers = new List { new() { Name = "Offer", Pattern = "offers", Actions = new TriggerActions() } }, + Aliases = new List { new() { Name = "b", Pattern = "^b$", Substitution = "buy" } }, + Timers = new List { new() { Name = "restock", IntervalSeconds = 120, Command = "list" } }, + }, + }; + + private static ScreenButton ButtonNamed(ScreenModel model, int pane, string label) + { + for (var i = 0; i < 32; i++) + { + if (model.ButtonAt(pane, i) is { } button && button.Label == label) + { + return button; + } + } + + throw new InvalidOperationException($"no button labelled '{label}' in pane {pane}"); + } + + [Test] + public async Task EveryListPaneEndsInItsOwnButtons() + { + var sets = Sets(); + + var triggers = TriggersScreenRenderer.Model(sets, 0); + await Assert.That(triggers.ListSizes[0]).IsEqualTo(3); + await Assert.That(triggers.ButtonAt(0, 3)!.Value.Label).IsEqualTo(TriggersScreenRenderer.AddTriggerLabel); + await Assert.That(triggers.ButtonAt(0, 4)!.Value.Label) + .IsEqualTo(TriggersScreenRenderer.DuplicateTriggerLabel); + await Assert.That(triggers.ButtonAt(0, 5)!.Value.Label).IsEqualTo(TriggersScreenRenderer.RemoveTriggerLabel); + + var aliases = AliasesScreenRenderer.Model(sets, 0); + await Assert.That(aliases.ListSizes[0]).IsEqualTo(2); + await Assert.That(aliases.ButtonAt(0, 2)!.Value.Label).IsEqualTo(AliasesScreenRenderer.AddAliasLabel); + await Assert.That(aliases.ButtonAt(0, 3)!.Value.Label).IsEqualTo(AliasesScreenRenderer.DuplicateAliasLabel); + await Assert.That(aliases.ButtonAt(0, 4)!.Value.Label).IsEqualTo(AliasesScreenRenderer.RemoveAliasLabel); + + // F6 has no duplicate: a timer is an interval and a command, and both are what you would change + // in the copy — so the button would save nobody anything while still being a cursor stop. + var timers = TimersScreenRenderer.Model(sets, 0); + await Assert.That(timers.ListSizes[0]).IsEqualTo(2); + await Assert.That(timers.ButtonAt(0, 2)!.Value.Label).IsEqualTo(TimersScreenRenderer.AddTimerLabel); + await Assert.That(timers.ButtonAt(0, 3)!.Value.Label).IsEqualTo(TimersScreenRenderer.RemoveTimerLabel); + await Assert.That(timers.ButtonAt(0, 4)).IsNull(); + + // Nor does F4: a copied binding would land on the key its original already holds, and the + // second macro on a key never fires. + var keypad = KeypadScreenRenderer.Model(sets[0].Macros, sets, 0); + await Assert.That(keypad.ListSizes[0]).IsEqualTo(1); + await Assert.That(keypad.ButtonAt(0, 1)!.Value.Label).IsEqualTo(KeypadScreenRenderer.AddBindingLabel); + await Assert.That(keypad.ButtonAt(0, 2)!.Value.Label).IsEqualTo(KeypadScreenRenderer.RemoveBindingLabel); + await Assert.That(keypad.ButtonAt(0, 3)).IsNull(); + } + + /// + /// A pane's rows still mean what they meant. The buttons are appended after the list, so the field + /// ordinals and row indices every other test addresses are untouched by their arrival. + /// + [Test] + public async Task GivingAPaneButtonsDoesNotRenumberTheRowsAboveThem() + { + var model = TriggersScreenRenderer.Model(Sets(), 0); + + await Assert.That(model.ButtonAt(0, 0)).IsNull(); + await Assert.That(model.FieldAt(0, 0, TriggersScreenRenderer.NameField)!.Value.Get()).IsEqualTo("Tell"); + await Assert.That(model.FieldAt(0, 2, TriggersScreenRenderer.NameField)!.Value.Get()).IsEqualTo("Offer"); + } + + /// + /// A button that would act on nothing is not drawn, so ⏎ can never land on a silent no-op. With + /// nothing selected there is nothing to duplicate or delete; with no sets at all there is nowhere + /// to put a new rule either, so even the add button goes. + /// + [Test] + public async Task APaneWithNothingSelectedOffersOnlyItsAddButton() + { + var sets = Sets(); + + var triggers = TriggersScreenRenderer.Model(sets, -1); + await Assert.That(triggers.Sizes[0]).IsEqualTo(4); + await Assert.That(triggers.ButtonAt(0, 3)!.Value.Label).IsEqualTo(TriggersScreenRenderer.AddTriggerLabel); + await Assert.That(triggers.ButtonAt(0, 4)).IsNull(); + + var empty = new List(); + await Assert.That(TriggersScreenRenderer.Model(empty, -1).Sizes[0]).IsEqualTo(0); + await Assert.That(AliasesScreenRenderer.Model(empty, -1).Sizes[0]).IsEqualTo(0); + await Assert.That(TimersScreenRenderer.Model(empty, -1).Sizes[0]).IsEqualTo(0); + await Assert.That(KeypadScreenRenderer.Model(Array.Empty(), empty, -1).Sizes[0]).IsEqualTo(0); + } + + /// + /// The flattening, which is the whole difficulty of these four screens. A rule is added to the set + /// that owns the selection — not to a fixed one, which would make rules appear in a set the user + /// wasn't looking at — and the cursor is asked for the *pane row* the new rule now occupies, which + /// is not its index in the list it went into. + /// + [Test] + public async Task AddingGoesIntoTheSelectionsOwnSetAndLandsTheCursorOnThePaneRowItTookUp() + { + var sets = Sets(); + var edits = new ScreenEdits(); + + // Selection is the second set's only rule (flattened row 2). + var select = edits.Apply(ButtonNamed( + TriggersScreenRenderer.Model(sets, 2), 0, TriggersScreenRenderer.AddTriggerLabel)); + + await Assert.That(sets[1].Triggers.Select(t => t.Name)).IsEquivalentTo(new[] { "Offer", "New Trigger" }); + await Assert.That(sets[0].Triggers).Count().IsEqualTo(2); + await Assert.That(select).IsEqualTo(3); + + edits.Revert(); + await Assert.That(sets[1].Triggers.Select(t => t.Name)).IsEquivalentTo(new[] { "Offer" }); + + // And with the first set's rule selected it goes there, taking pane row 2 — after that set's + // own rules and before the second set's. + var first = new ScreenEdits(); + await Assert.That(first.Apply(ButtonNamed( + TriggersScreenRenderer.Model(sets, 0), 0, TriggersScreenRenderer.AddTriggerLabel))).IsEqualTo(2); + await Assert.That(sets[0].Triggers.Select(t => t.Name)) + .IsEquivalentTo(new[] { "Tell", "Spam", "New Trigger" }); + } + + /// + /// A new rule has to be usable as it lands: refuses an empty + /// regex, so a blank one could never be committed. It is left enabled because a rule with no + /// actions does nothing to the stream whatever it matches — unlike a timer, below. + /// + [Test] + public async Task ANewTriggerIsAWorkingPlaceholder() + { + var sets = Sets(); + new ScreenEdits().Apply(ButtonNamed( + TriggersScreenRenderer.Model(sets, 0), 0, TriggersScreenRenderer.AddTriggerLabel)); + + var added = sets[0].Triggers[^1]; + var model = TriggersScreenRenderer.Model(sets, 2); + + await Assert.That(added.Enabled).IsTrue(); + await Assert.That(model.FieldAt(0, 2, TriggersScreenRenderer.NameField)!.Value.Validate(added.Name)).IsNull(); + await Assert.That(model.FieldAt(0, 2, TriggersScreenRenderer.PatternField)!.Value.Validate(added.Pattern)) + .IsNull(); + } + + /// + /// The one asymmetry among the four, and it is deliberate: a timer is the only thing here that acts + /// without being provoked. A new one left running would start sending a placeholder command at the + /// server a minute later, which nobody asked for. + /// + [Test] + public async Task ANewTimerArrivesDisabled_UnlikeANewTriggerOrBinding() + { + var sets = Sets(); + new ScreenEdits().Apply(ButtonNamed(TimersScreenRenderer.Model(sets, 0), 0, TimersScreenRenderer.AddTimerLabel)); + new ScreenEdits().Apply( + ButtonNamed(AliasesScreenRenderer.Model(sets, 0), 0, AliasesScreenRenderer.AddAliasLabel)); + new ScreenEdits().Apply(ButtonNamed( + KeypadScreenRenderer.Model(sets[0].Macros, sets, 0), 0, KeypadScreenRenderer.AddBindingLabel)); + + await Assert.That(sets[0].Timers[^1].Enabled).IsFalse(); + await Assert.That(sets[0].Aliases[^1].Enabled).IsTrue(); + await Assert.That(sets[0].Macros[^1].Enabled).IsTrue(); + } + + /// + /// A deletion's undo restores the row's *place*, not merely its existence: the pane's order is what + /// the screen navigates by, and putting a cancelled deletion back on the end of its set would be a + /// second, invisible edit riding along with the first. + /// + [Test] + public async Task RemovingUndoesBackIntoItsOwnIndexOnEveryScreen() + { + var sets = Sets(); + var edits = new ScreenEdits(); + + // Flattened row 0 is the first set's first rule. + edits.Apply(ButtonNamed(TriggersScreenRenderer.Model(sets, 0), 0, TriggersScreenRenderer.RemoveTriggerLabel)); + await Assert.That(sets[0].Triggers.Select(t => t.Name)).IsEquivalentTo(new[] { "Spam" }); + + edits.Apply(ButtonNamed(AliasesScreenRenderer.Model(sets, 1), 0, AliasesScreenRenderer.RemoveAliasLabel)); + await Assert.That(sets[1].Aliases).IsEmpty(); + + edits.Apply(ButtonNamed(TimersScreenRenderer.Model(sets, 0), 0, TimersScreenRenderer.RemoveTimerLabel)); + await Assert.That(sets[0].Timers).IsEmpty(); + + edits.Apply(ButtonNamed( + KeypadScreenRenderer.Model(sets[0].Macros, sets, 0), 0, KeypadScreenRenderer.RemoveBindingLabel)); + await Assert.That(sets[0].Macros).IsEmpty(); + + edits.Revert(); + + await Assert.That(sets[0].Triggers.Select(t => t.Name)).IsEquivalentTo(new[] { "Tell", "Spam" }); + await Assert.That(sets[1].Aliases.Select(a => a.Name)).IsEquivalentTo(new[] { "b" }); + await Assert.That(sets[0].Timers.Select(t => t.Name)).IsEquivalentTo(new[] { "ping" }); + await Assert.That(sets[0].Macros.Select(m => m.Key)).IsEquivalentTo(new[] { "Num5" }); + } + + /// + /// Removing from the middle of a flattened pane puts the row back where it was inside its own set, + /// and leaves the cursor on the pane row the deleted one occupied — which is now whatever followed + /// it, the same place the eye is. + /// + [Test] + public async Task RemovingFromTheMiddleKeepsThePaneRowAndRestoresTheSetsOrder() + { + var sets = Sets(); + var edits = new ScreenEdits(); + + var select = edits.Apply(ButtonNamed( + TriggersScreenRenderer.Model(sets, 1), 0, TriggersScreenRenderer.RemoveTriggerLabel)); + + await Assert.That(select).IsEqualTo(1); + await Assert.That(sets.SelectMany(s => s.Triggers).Select(t => t.Name)) + .IsEquivalentTo(new[] { "Tell", "Offer" }); + + edits.Revert(); + + await Assert.That(sets[0].Triggers.Select(t => t.Name)).IsEquivalentTo(new[] { "Tell", "Spam" }); + } + + /// + /// The point of duplicate: the copy must be a copy. An aliased one would look right and then + /// follow every later edit of its original around — for a trigger that means its actions, which is + /// where the real damage would be. + /// + [Test] + public async Task DuplicatingARuleIsADeepCopyWithItsOwnName() + { + var sets = Sets(); + var original = sets[0].Triggers[0]; + var edits = new ScreenEdits(); + + var select = edits.Apply(ButtonNamed( + TriggersScreenRenderer.Model(sets, 0), 0, TriggersScreenRenderer.DuplicateTriggerLabel)); + + await Assert.That(select).IsEqualTo(2); + var copy = sets[0].Triggers[2]; + await Assert.That(copy.Name).IsEqualTo("Tell copy"); + await Assert.That(ReferenceEquals(copy.Actions, original.Actions)).IsFalse(); + + copy.Actions.Gag = false; + await Assert.That(original.Actions.Gag).IsTrue(); + + edits.Revert(); + await Assert.That(sets[0].Triggers).Count().IsEqualTo(2); + } + + [Test] + public async Task DuplicatingAnAliasIsADeepCopyWithItsOwnName() + { + var sets = Sets(); + var original = sets[0].Aliases[0]; + var edits = new ScreenEdits(); + + edits.Apply(ButtonNamed(AliasesScreenRenderer.Model(sets, 0), 0, AliasesScreenRenderer.DuplicateAliasLabel)); + + var copy = sets[0].Aliases[1]; + await Assert.That(copy.Name).IsEqualTo("gr copy"); + await Assert.That(copy.Substitution).IsEqualTo("greet\nwave"); + await Assert.That(ReferenceEquals(copy, original)).IsFalse(); + + copy.Pattern = "^gg$"; + await Assert.That(original.Pattern).IsEqualTo("^gr$"); + + edits.Revert(); + await Assert.That(sets[0].Aliases).Count().IsEqualTo(1); + } + + /// + /// Duplicating twice keeps finding a free name, so two copies of one rule can still be told apart + /// in the list they land in. + /// + [Test] + public async Task DuplicatingTwiceGivesEachCopyAFreeName() + { + var sets = Sets(); + var edits = new ScreenEdits(); + + edits.Apply(ButtonNamed( + TriggersScreenRenderer.Model(sets, 0), 0, TriggersScreenRenderer.DuplicateTriggerLabel)); + edits.Apply(ButtonNamed( + TriggersScreenRenderer.Model(sets, 0), 0, TriggersScreenRenderer.DuplicateTriggerLabel)); + + await Assert.That(sets[0].Triggers.Select(t => t.Name)) + .IsEquivalentTo(new[] { "Tell", "Spam", "Tell copy", "Tell copy 2" }); + } + + /// + /// F4's add button is the one that cannot simply append. A is identified by its + /// , which this screen deliberately cannot edit, so the button claims the + /// lowest free numpad digit and says which one on its own row — a binding created on a key the user + /// couldn't see and couldn't change would be unfixable from here. + /// + [Test] + public async Task AddingABindingClaimsTheLowestFreeNumpadKeyAndNamesIt() + { + var sets = Sets(); + var button = ButtonNamed( + KeypadScreenRenderer.Model(sets[0].Macros, sets, 0), 0, KeypadScreenRenderer.AddBindingLabel); + + await Assert.That(button.Target).IsEqualTo("Num0"); + + new ScreenEdits().Apply(button); + await Assert.That(sets[0].Macros[^1].Key).IsEqualTo("Num0"); + + // The next one takes the next free digit, not the same one again. + var again = ButtonNamed( + KeypadScreenRenderer.Model(sets.SelectMany(s => s.Macros).ToList(), sets, 0), + 0, + KeypadScreenRenderer.AddBindingLabel); + await Assert.That(again.Target).IsEqualTo("Num1"); + } + + /// + /// With every numpad digit spoken for there is no free key to claim, so the add button isn't drawn + /// — the same rule that keeps [[- del]] off a pane with nothing selected. Delete still works, + /// which is how you make room. + /// + [Test] + public async Task NoBindingCanBeAddedOnceEveryNumpadKeyIsBound() + { + var sets = new List { new() { Name = "All" } }; + for (var digit = 0; digit <= 9; digit++) + { + sets[0].Macros.Add(new Macro { Name = "n" + digit, Key = "Num" + digit, Command = "look" }); + } + + var model = KeypadScreenRenderer.Model(sets[0].Macros, sets, 0); + + await Assert.That(model.Sizes[0]).IsEqualTo(11); // 10 bindings + [- del] and nothing else + await Assert.That(model.ButtonAt(0, 10)!.Value.Label).IsEqualTo(KeypadScreenRenderer.RemoveBindingLabel); + await Assert.That(model.ButtonAt(0, 11)).IsNull(); + } + + /// + /// A destructive button names the row it would act on, because the cursor has to leave the list to + /// reach it and a delete whose target is off-screen is exactly the surprise these screens must not + /// spring. An add button names no victim — except F4's, which names the key it will claim. + /// + [Test] + public async Task ATargetedButtonNamesTheRowItWouldActOn() + { + var sets = Sets(); + + var rules = TriggersScreenRenderer.RulesColumn(sets, 1); + await Assert.That(rules.Any(l => l.Contains("[[- del]]") && l.Contains("Spam"))).IsTrue(); + await Assert.That(rules.Any(l => l.Contains("[[⧉ duplicate]]") && l.Contains("Spam"))).IsTrue(); + await Assert.That(rules.Any(l => l.Contains("[[+ trigger]]") && l.Contains("Spam"))).IsFalse(); + + var aliases = AliasesScreenRenderer.ListColumn(sets, 0); + await Assert.That(aliases.Any(l => l.Contains("[[- del]]") && l.Contains("gr"))).IsTrue(); + + var timers = TimersScreenRenderer.ListColumn(sets, 0); + await Assert.That(timers.Any(l => l.Contains("[[- del]]") && l.Contains("ping"))).IsTrue(); + + var bindings = KeypadScreenRenderer.HotkeysColumn(sets[0].Macros, null, sets, 0); + await Assert.That(bindings.Any(l => l.Contains("[[- del]]") && l.Contains("Look"))).IsTrue(); + await Assert.That(bindings.Any(l => l.Contains("[[+ binding]]") && l.Contains("Num0"))).IsTrue(); + } + + /// + /// End to end through the keyboard, which is the whole reason a new row is worth adding: ⏎ on the + /// add button runs it and leaves the cursor on the new row, where the next ⏎ opens that row's name. + /// + [Test] + public async Task Enter_OnAddLeavesTheCursorOnTheNewRowReadyToNameIt() + { + var sets = Sets(); + var session = new SettingsSession( + selection => TriggersScreenRenderer.Model(sets, selection.SelectionIn(0))); + + // Rows 0-2 are the three rules; row 3 is [+ trigger]. Walking onto it leaves the selection on + // row 2 — the "Trade" set's rule — so that is the set the new one joins. + for (var i = 0; i < 3; i++) + { + session.Handle(Key(ConsoleKey.DownArrow)); + } + + await Assert.That(session.Handle(Key(ConsoleKey.Enter))).IsEqualTo(ScreenAction.Redraw); + await Assert.That(sets[1].Triggers.Select(t => t.Name)).IsEquivalentTo(new[] { "Offer", "New Trigger" }); + + // The cursor is on the row the new rule took up, not on the button it was added from. + await Assert.That(session.Focus().Index).IsEqualTo(3); + await Assert.That(session.IsEditing).IsFalse(); + + session.Handle(Key(ConsoleKey.Enter)); + await Assert.That(session.IsEditing).IsTrue(); + await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("New Trigger"); + + session.Handle(Key(ConsoleKey.Escape)); + await Assert.That(session.Handle(Key(ConsoleKey.Escape))).IsEqualTo(ScreenAction.Cancel); + session.Edits.Revert(); + await Assert.That(sets[1].Triggers.Select(t => t.Name)).IsEquivalentTo(new[] { "Offer" }); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs index bf131fdc..116e0c92 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs @@ -53,7 +53,11 @@ public async Task Triggers_HasARuleListAndTheSelectedRulesToggles() var model = TriggersScreenRenderer.Model(sets, selectedTrigger: 0); await Assert.That(model.PaneCount).IsEqualTo(2); - await Assert.That(model.Sizes[0]).IsEqualTo(2); + + // Two rules, then the pane's own [+ trigger] / [⧉ duplicate] / [- del]. The list count is what + // every index below addresses and is unchanged; the buttons are appended after it. + await Assert.That(model.ListSizes[0]).IsEqualTo(2); + await Assert.That(model.Sizes[0]).IsEqualTo(5); await Assert.That(model.Sizes[1]).IsEqualTo(2); model.ToggleAt(0, 1)!.Value.Flip(); @@ -81,7 +85,10 @@ public async Task Aliases_ListTogglesEnabled_AndTheEditorTogglesCaseSensitivity( var model = AliasesScreenRenderer.Model(sets, selected: 0); await Assert.That(model.PaneCount).IsEqualTo(2); - await Assert.That(model.Sizes).IsEquivalentTo(new[] { 1, 1 }); + + // One alias, then [+ alias] / [⧉ duplicate] / [- del]. + await Assert.That(model.ListSizes).IsEquivalentTo(new[] { 1, 1 }); + await Assert.That(model.Sizes).IsEquivalentTo(new[] { 4, 1 }); model.ToggleAt(0, 0)!.Value.Flip(); await Assert.That(sets[0].Aliases[0].Enabled).IsFalse(); @@ -109,7 +116,9 @@ public async Task Timers_ListTogglesEnabled_AndTheEditorTogglesOneShotThenEnable var sets = Sets(); var model = TimersScreenRenderer.Model(sets, selected: 0); - await Assert.That(model.Sizes).IsEquivalentTo(new[] { 1, 2 }); + // One timer, then [+ timer] / [- del] — no duplicate, deliberately (see TimersScreenRenderer). + await Assert.That(model.ListSizes).IsEquivalentTo(new[] { 1, 2 }); + await Assert.That(model.Sizes).IsEquivalentTo(new[] { 3, 2 }); model.ToggleAt(1, 0)!.Value.Flip(); await Assert.That(sets[0].Timers[0].OneShot).IsTrue(); @@ -125,12 +134,32 @@ public async Task Keypad_IsOnePaneOfMacroToggles() var model = KeypadScreenRenderer.Model(macros); await Assert.That(model.PaneCount).IsEqualTo(1); + + // Handed no sets, the screen is the list and nothing else: a macro's home is a set, and without + // one there is nowhere to add a binding to and no list to remove one from. await Assert.That(model.Sizes[0]).IsEqualTo(1); model.ToggleAt(0, 0)!.Value.Flip(); await Assert.That(macros[0].Enabled).IsFalse(); } + /// + /// Handed the sets the bindings live in, the pane grows the same buttons every other list screen + /// has: one binding, then [+ binding] and [- del]. There is no duplicate — a copy + /// would land on the key its original already holds, and the second macro on a key never fires. + /// + [Test] + public async Task Keypad_GrowsItsButtonsOnceItKnowsWhichSetsTheBindingsLiveIn() + { + var sets = Sets(); + var model = KeypadScreenRenderer.Model(sets[0].Macros, sets, selected: 0); + + await Assert.That(model.ListSizes[0]).IsEqualTo(1); + await Assert.That(model.Sizes[0]).IsEqualTo(3); + await Assert.That(model.ButtonAt(0, 1)!.Value.Label).IsEqualTo(KeypadScreenRenderer.AddBindingLabel); + await Assert.That(model.ButtonAt(0, 2)!.Value.Label).IsEqualTo(KeypadScreenRenderer.RemoveBindingLabel); + } + [Test] public async Task Worlds_HasWorldsThenCharactersThenTriggerSets() { diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenNameTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenNameTests.cs new file mode 100644 index 00000000..3d037290 --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/ScreenNameTests.cs @@ -0,0 +1,227 @@ +using SharpMUTerm.Core.Automation; +using SharpMUTerm.Core.Configuration; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// The item's name, on every list screen. Each of the five drew a name as the row's primary identifier +/// and none of the four automation screens let you change it: you could rewrite a trigger's regex but +/// not what it was called. These assert that the name is now the first field of every list +/// row — so ⏎ on a row, and on a row that was just added, opens the one value that tells it apart — +/// that it writes back to the right object, that Cancel puts the old one back, and what a name is +/// allowed to be. +/// +public class ScreenNameTests +{ + private static ConsoleKeyInfo Key(ConsoleKey key) => new('\0', key, false, false, false); + + private static List Sets() => new() + { + new TriggerSet + { + Name = "Comms", + Triggers = new List { new() { Name = "Tell", Pattern = "tells you" } }, + Aliases = new List { new() { Name = "k", Pattern = "^k$", Substitution = "kill" } }, + Macros = new List { new() { Name = "look", Key = "Num5", Command = "look" } }, + Timers = new List { new() { Name = "ping", IntervalSeconds = 30, Command = "look" } }, + }, + }; + + private static List Worlds() => new() + { + new WorldDefinition + { + Name = "Aetherfall", + Host = "aetherfall.mux", + Characters = new List { new() { Name = "Corvid" } }, + }, + }; + + /// Every list row of every screen, paired with what its name field currently reads. + private static List<(string Screen, ScreenField Field, Func Read)> NameFields( + List sets, List worlds) + { + var trigger = sets[0].Triggers[0]; + var alias = sets[0].Aliases[0]; + var macro = sets[0].Macros[0]; + var timer = sets[0].Timers[0]; + var world = worlds[0]; + var character = world.Characters[0]; + + return new List<(string, ScreenField, Func)> + { + ("F2 triggers", + TriggersScreenRenderer.Model(sets, 0).FieldAt(0, 0, TriggersScreenRenderer.NameField)!.Value, + () => trigger.Name), + ("F3 aliases", + AliasesScreenRenderer.Model(sets, 0).FieldAt(0, 0, AliasesScreenRenderer.NameField)!.Value, + () => alias.Name), + ("F4 keypad", + KeypadScreenRenderer.Model(sets[0].Macros).FieldAt(0, 0, KeypadScreenRenderer.NameField)!.Value, + () => macro.Name), + ("F6 timers", + TimersScreenRenderer.Model(sets, 0).FieldAt(0, 0, TimersScreenRenderer.NameField)!.Value, + () => timer.Name), + ("F5 worlds", + WorldsScreenRenderer.Model(worlds, sets, 0, 0).FieldAt(0, 0, 0)!.Value, + () => world.Name), + ("F5 characters", + WorldsScreenRenderer.Model(worlds, sets, 0, 0).FieldAt(1, 0, 0)!.Value, + () => character.Name), + }; + } + + /// + /// The rule the four automation screens broke: the row's first field is the thing it is called. + /// F5 already worked this way, which is why it is in the same list rather than in a test of its own. + /// + [Test] + public async Task TheFirstFieldOfEveryListRowIsItsName() + { + var sets = Sets(); + var worlds = Worlds(); + var expected = new[] { "Tell", "k", "look", "ping", "Aetherfall", "Corvid" }; + var fields = NameFields(sets, worlds); + + for (var i = 0; i < fields.Count; i++) + { + var (screen, field, _) = fields[i]; + await Assert.That(field.Label).IsEqualTo("name").Because(screen); + await Assert.That(field.Get()).IsEqualTo(expected[i]).Because(screen); + } + + // The name really is the *first* field, which is what makes ⏎ open it. + await Assert.That(TriggersScreenRenderer.NameField).IsEqualTo(0); + await Assert.That(AliasesScreenRenderer.NameField).IsEqualTo(0); + await Assert.That(KeypadScreenRenderer.NameField).IsEqualTo(0); + await Assert.That(TimersScreenRenderer.NameField).IsEqualTo(0); + } + + [Test] + public async Task WritingANameLandsOnTheItemAndCancelPutsTheOldOneBack() + { + var sets = Sets(); + var worlds = Worlds(); + + foreach (var (screen, field, read) in NameFields(sets, worlds)) + { + var before = read(); + var edits = new ScreenEdits(); + + await Assert.That(edits.Apply(field, "Renamed")).IsNull().Because(screen); + await Assert.That(read()).IsEqualTo("Renamed").Because(screen); + + edits.Revert(); + await Assert.That(read()).IsEqualTo(before).Because(screen); + } + } + + /// + /// What a name may be. Blank is refused because the row would then have no identifier at all, and + /// control characters are refused because a name is drawn into one row of a fixed-width list — a + /// tab or a newline inside one breaks the column, exactly as it would in a tab title. Nothing else + /// is refused: names are deliberately not unique (see ). + /// + [Test] + public async Task ANameIsRefusedWhenBlankOrCarryingControlCharacters() + { + var sets = Sets(); + var worlds = Worlds(); + + foreach (var (screen, field, read) in NameFields(sets, worlds)) + { + var before = read(); + + await Assert.That(field.Validate(string.Empty)).IsNotNull().Because(screen); + await Assert.That(field.Validate(" ")).IsNotNull().Because(screen); + await Assert.That(field.Validate("two\tnames")).IsNotNull().Because(screen); + await Assert.That(field.Validate("two\nnames")).IsNotNull().Because(screen); + + // A refused value writes nothing, because Apply is the only path from a buffer into config. + await Assert.That(new ScreenEdits().Apply(field, " ")).IsNotNull().Because(screen); + await Assert.That(read()).IsEqualTo(before).Because(screen); + + // Surrounding whitespace is trimmed rather than refused, and anything else is allowed. + await Assert.That(field.Validate(" Night Watch ")).IsNull().Because(screen); + new ScreenEdits().Apply(field, " Night Watch "); + await Assert.That(read()).IsEqualTo("Night Watch").Because(screen); + } + } + + /// + /// Duplicates are allowed on purpose. Nothing keys off these names — the engines match on patterns + /// and is keyed by — and two sets may each + /// legitimately hold a rule called Tell. Refusing one would be a rule the configuration + /// itself doesn't have. + /// + [Test] + public async Task TwoItemsMayShareAName() + { + var sets = Sets(); + sets[0].Triggers.Add(new Trigger { Name = "Spam", Pattern = "guild" }); + var field = TriggersScreenRenderer.Model(sets, 1).FieldAt(0, 1, TriggersScreenRenderer.NameField)!.Value; + + await Assert.That(field.Validate("Tell")).IsNull(); + await Assert.That(new ScreenEdits().Apply(field, "Tell")).IsNull(); + await Assert.That(sets[0].Triggers.Select(t => t.Name)).IsEquivalentTo(new[] { "Tell", "Tell" }); + } + + /// + /// End to end through the keyboard, on the screen the whole feature was missing from: ⏎ on a rule + /// opens its name, typing replaces it, ⏎ commits, and the rule list draws the new one. + /// + [Test] + public async Task Enter_OnARuleOpensItsNameAndTypingRenamesIt() + { + var sets = Sets(); + var session = new SettingsSession( + selection => TriggersScreenRenderer.Model(sets, selection.SelectionIn(0))); + + session.Handle(Key(ConsoleKey.Enter)); + await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("Tell"); + + for (var i = 0; i < "Tell".Length; i++) + { + session.Handle(Key(ConsoleKey.Backspace)); + } + + foreach (var c in "Whisper") + { + session.Handle(new ConsoleKeyInfo(c, ConsoleKey.NoName, false, false, false)); + } + + session.Handle(Key(ConsoleKey.Enter)); + + await Assert.That(session.IsEditing).IsFalse(); + await Assert.That(sets[0].Triggers[0].Name).IsEqualTo("Whisper"); + await Assert.That(TriggersScreenRenderer.RulesColumn(sets, 0).Any(l => l.Contains("Whisper"))).IsTrue(); + + // And Esc on the screen unmakes it, like any other committed field. + session.Edits.Revert(); + await Assert.That(sets[0].Triggers[0].Name).IsEqualTo("Tell"); + } + + /// + /// The rename must not disturb the matcher. and + /// deliberately drop the compiled regex on write; a name has no + /// such derived state, and this pins that it stays that way rather than being assumed. + /// + [Test] + public async Task RenamingARuleDoesNotDisturbWhatItMatches() + { + var sets = Sets(); + var trigger = sets[0].Triggers[0]; + var alias = sets[0].Aliases[0]; + await Assert.That(trigger.Regex.IsMatch("she tells you hi")).IsTrue(); + await Assert.That(alias.Regex.IsMatch("k")).IsTrue(); + + new ScreenEdits().Apply( + TriggersScreenRenderer.Model(sets, 0).FieldAt(0, 0, TriggersScreenRenderer.NameField)!.Value, "Whisper"); + new ScreenEdits().Apply( + AliasesScreenRenderer.Model(sets, 0).FieldAt(0, 0, AliasesScreenRenderer.NameField)!.Value, "kill"); + + await Assert.That(trigger.Regex.IsMatch("she tells you hi")).IsTrue(); + await Assert.That(alias.Regex.IsMatch("k")).IsTrue(); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/SettingsSessionEditTests.cs b/tests/SharpMUTerm.Tui.Tests/SettingsSessionEditTests.cs index 33f2d9a3..4b918b93 100644 --- a/tests/SharpMUTerm.Tui.Tests/SettingsSessionEditTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/SettingsSessionEditTests.cs @@ -371,7 +371,9 @@ public async Task EditingATriggersPatternRecompilesItsMatcher() var trigger = sets[0].Triggers[0]; await Assert.That(trigger.Regex.IsMatch("she tells you hi")).IsTrue(); - new ScreenEdits().Apply(TriggersScreenRenderer.Model(sets, 0).FieldAt(0, 0, 0)!.Value, "pages you"); + new ScreenEdits().Apply( + TriggersScreenRenderer.Model(sets, 0).FieldAt(0, 0, TriggersScreenRenderer.PatternField)!.Value, + "pages you"); await Assert.That(trigger.Regex.IsMatch("she tells you hi")).IsFalse(); await Assert.That(trigger.Regex.IsMatch("she pages you")).IsTrue(); @@ -387,7 +389,8 @@ public async Task EditingAnAliasPatternRecompilesItsMatcher() var alias = sets[0].Aliases[0]; await Assert.That(alias.Regex.IsMatch("k")).IsTrue(); - new ScreenEdits().Apply(AliasesScreenRenderer.Model(sets, 0).FieldAt(0, 0, 0)!.Value, "^kk$"); + new ScreenEdits().Apply( + AliasesScreenRenderer.Model(sets, 0).FieldAt(0, 0, AliasesScreenRenderer.PatternField)!.Value, "^kk$"); await Assert.That(alias.Regex.IsMatch("k")).IsFalse(); await Assert.That(alias.Regex.IsMatch("kk")).IsTrue(); diff --git a/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs b/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs index bf0f8f73..eb913f61 100644 --- a/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs @@ -48,14 +48,16 @@ public async Task ARuleRowCarriesItsPatternRouteAndBothHighlightColours() var sets = Sets(); var model = TriggersScreenRenderer.Model(sets, 0, Targets); - await Assert.That(model.RowAt(0, 0).FieldCount).IsEqualTo(4); - await Assert.That(model.FieldAt(0, 0, 0)!.Value.Get()).IsEqualTo("tells you"); - await Assert.That(model.FieldAt(0, 0, 1)!.Value.Get()).IsEqualTo("Chat"); - await Assert.That(model.FieldAt(0, 0, 2)!.Value.Get()).IsEqualTo("gold"); - await Assert.That(model.FieldAt(0, 0, 3)!.Value.Get()).IsEqualTo("none"); - - // The editor pane keeps exactly the two checkbox rows it had — the route and the colours are - // one setting each, so they are fields on the rule, not new cursor stops. + // The name leads, then the four values the editor pane draws. + await Assert.That(model.RowAt(0, 0).FieldCount).IsEqualTo(5); + await Assert.That(model.FieldAt(0, 0, TriggersScreenRenderer.NameField)!.Value.Get()).IsEqualTo("Tell"); + await Assert.That(model.FieldAt(0, 0, TriggersScreenRenderer.PatternField)!.Value.Get()).IsEqualTo("tells you"); + await Assert.That(model.FieldAt(0, 0, TriggersScreenRenderer.RouteField)!.Value.Get()).IsEqualTo("Chat"); + await Assert.That(model.FieldAt(0, 0, TriggersScreenRenderer.ForegroundField)!.Value.Get()).IsEqualTo("gold"); + await Assert.That(model.FieldAt(0, 0, TriggersScreenRenderer.BackgroundField)!.Value.Get()).IsEqualTo("none"); + + // The editor pane keeps exactly the two checkbox rows it had — the route, the colours and the + // name are one setting each, so they are fields on the rule, not new cursor stops. await Assert.That(model.Sizes[1]).IsEqualTo(2); } @@ -64,12 +66,12 @@ public async Task TheRouteGroupOffersMainEveryKnownWindowAndTheRulesOwnTarget() { var sets = Sets(); - var known = TriggersScreenRenderer.Model(sets, 0, Targets).FieldAt(0, 0, 1)!.Value.Choices; + var known = TriggersScreenRenderer.Model(sets, 0, Targets).FieldAt(0, 0, TriggersScreenRenderer.RouteField)!.Value.Choices; await Assert.That(known).IsEquivalentTo(new[] { "main", "Chat", "pages", "trade" }); // A rule pointed at a window the workspace has no record of still offers — and keeps — its own // value, rather than being refused by its own field. - var unknown = TriggersScreenRenderer.Model(sets, 0).FieldAt(0, 0, 1)!.Value; + var unknown = TriggersScreenRenderer.Model(sets, 0).FieldAt(0, 0, TriggersScreenRenderer.RouteField)!.Value; await Assert.That(unknown.Choices).IsEquivalentTo(new[] { "main", "Chat" }); await Assert.That(unknown.Validate("Chat")).IsNull(); } @@ -81,10 +83,10 @@ public async Task ChoosingMainClearsTheSpawnTarget_AndUndoPutsItBack() var trigger = sets[0].Triggers[0]; var edits = new ScreenEdits(); - edits.Apply(TriggersScreenRenderer.Model(sets, 0, Targets).FieldAt(0, 0, 1)!.Value, "main"); + edits.Apply(TriggersScreenRenderer.Model(sets, 0, Targets).FieldAt(0, 0, TriggersScreenRenderer.RouteField)!.Value, "main"); await Assert.That(trigger.Actions.SpawnTarget).IsNull(); - edits.Apply(TriggersScreenRenderer.Model(sets, 0, Targets).FieldAt(0, 0, 1)!.Value, "trade"); + edits.Apply(TriggersScreenRenderer.Model(sets, 0, Targets).FieldAt(0, 0, TriggersScreenRenderer.RouteField)!.Value, "trade"); await Assert.That(trigger.Actions.SpawnTarget).IsEqualTo("trade"); edits.Revert(); @@ -101,7 +103,7 @@ public async Task ARouteMayNameAWindowThatDoesNotExistYet() { var sets = Sets(); var trigger = sets[0].Triggers[0]; - var field = TriggersScreenRenderer.Model(sets, 0, Targets).FieldAt(0, 0, 1)!.Value; + var field = TriggersScreenRenderer.Model(sets, 0, Targets).FieldAt(0, 0, TriggersScreenRenderer.RouteField)!.Value; await Assert.That(field.Validate("nowhere")).IsNull(); await Assert.That(new ScreenEdits().Apply(field, "nowhere")).IsNull(); @@ -112,7 +114,7 @@ public async Task ARouteMayNameAWindowThatDoesNotExistYet() [Test] public async Task ARouteIsRefusedWhenBlankOrCarryingControlCharacters() { - var field = TriggersScreenRenderer.Model(Sets(), 0, Targets).FieldAt(0, 0, 1)!.Value; + var field = TriggersScreenRenderer.Model(Sets(), 0, Targets).FieldAt(0, 0, TriggersScreenRenderer.RouteField)!.Value; await Assert.That(field.Validate(" ")).IsNotNull(); await Assert.That(field.Validate("chat\tspam")).IsNotNull(); @@ -132,8 +134,9 @@ public async Task TypingARouteThatMatchesNoKnownWindowStillShowsWhatIsBeingTyped var session = new SettingsSession( selection => TriggersScreenRenderer.Model(sets, selection.CursorIn(0), Targets)); - session.Handle(Key(ConsoleKey.Enter)); // opens the pattern - session.Handle(Key(ConsoleKey.Tab)); // commits it, steps to the route + session.Handle(Key(ConsoleKey.Enter)); // opens the name + session.Handle(Key(ConsoleKey.Tab)); // commits it, steps to the pattern + session.Handle(Key(ConsoleKey.Tab)); // commits that, steps to the route // Clear the opened value ("Chat") before typing, as anyone renaming the route would. for (var i = 0; i < "Chat".Length; i++) @@ -167,8 +170,9 @@ public async Task UpAndDownStepTheRouteRadios_AndTheDrawnDotFollowsTheBuffer() var session = new SettingsSession( selection => TriggersScreenRenderer.Model(sets, selection.CursorIn(0), Targets)); - session.Handle(Key(ConsoleKey.Enter)); // opens the pattern - session.Handle(Key(ConsoleKey.Tab)); // commits it, steps to the route + session.Handle(Key(ConsoleKey.Enter)); // opens the name + session.Handle(Key(ConsoleKey.Tab)); // commits it, steps to the pattern + session.Handle(Key(ConsoleKey.Tab)); // commits that, steps to the route await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("Chat"); await Assert.That(session.Focus().Edit!.Value.HasChoices).IsTrue(); @@ -187,6 +191,7 @@ public async Task UpAndDownStepTheRouteRadios_AndTheDrawnDotFollowsTheBuffer() // Wrapping backwards off "main" lands on the last window, not on nothing. session.Handle(Key(ConsoleKey.Enter)); session.Handle(Key(ConsoleKey.Tab)); + session.Handle(Key(ConsoleKey.Tab)); session.Handle(Key(ConsoleKey.UpArrow)); session.Handle(Key(ConsoleKey.UpArrow)); await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("main"); @@ -201,10 +206,10 @@ public async Task TheHighlightPickerWritesAColour_AndNoneClearsIt() var trigger = sets[0].Triggers[0]; var edits = new ScreenEdits(); - edits.Apply(TriggersScreenRenderer.Model(sets, 0, Targets).FieldAt(0, 0, 2)!.Value, "none"); + edits.Apply(TriggersScreenRenderer.Model(sets, 0, Targets).FieldAt(0, 0, TriggersScreenRenderer.ForegroundField)!.Value, "none"); await Assert.That(trigger.Actions.HighlightForeground).IsNull(); - edits.Apply(TriggersScreenRenderer.Model(sets, 0, Targets).FieldAt(0, 0, 3)!.Value, "blue"); + edits.Apply(TriggersScreenRenderer.Model(sets, 0, Targets).FieldAt(0, 0, TriggersScreenRenderer.BackgroundField)!.Value, "blue"); await Assert.That(trigger.Actions.HighlightBackground) .IsEqualTo(TerminalColor.FromRgb(0x00, 0x00, 0xff)); @@ -225,7 +230,7 @@ public async Task AColourThePaletteDoesNotNameStillRoundTrips() { var sets = Sets(); sets[0].Triggers[0].Actions.HighlightForeground = TerminalColor.FromRgb(0x12, 0x34, 0x56); - var field = TriggersScreenRenderer.Model(sets, 0, Targets).FieldAt(0, 0, 2)!.Value; + var field = TriggersScreenRenderer.Model(sets, 0, Targets).FieldAt(0, 0, TriggersScreenRenderer.ForegroundField)!.Value; await Assert.That(field.Get()).IsEqualTo("#123456"); await Assert.That(field.Validate(field.Get())).IsNull(); @@ -261,7 +266,8 @@ public async Task ARejectedColourIsReportedAgainstTheHighlightHeading() session.Handle(Key(ConsoleKey.Enter)); session.Handle(Key(ConsoleKey.Tab)); - session.Handle(Key(ConsoleKey.Tab)); // pattern → route → highlight fg + session.Handle(Key(ConsoleKey.Tab)); + session.Handle(Key(ConsoleKey.Tab)); // name → pattern → route → highlight fg for (var i = 0; i < 4; i++) { session.Handle(Key(ConsoleKey.Backspace)); From e121a4f3159d36da5aee0925afb013ea5cad2555 Mon Sep 17 00:00:00 2001 From: Harry Cordewener Date: Tue, 28 Jul 2026 20:38:05 -0500 Subject: [PATCH 15/23] F2: expose the trigger actions that had no UI, drop the route radios MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Half of what a trigger can do was unreachable. TriggerActions.Rewrite, SendResponse, ScriptCallback and AddAttributes had no UI at all, and Trigger.CaseSensitive had none either despite F3 exposing exactly the same setting on aliases. The README advertises "gag / highlight / rewrite / respond / spawn-route / script"; three of those six could not be reached. All five are now editable, grouped into captioned sections so the fuller pane stays readable: name and pattern, route, highlight (colours plus attributes), actions (rewrite, respond, script), then the flags. AddAttributes is a multi-select rather than a cycling choice, since bold-and-underline is not one-of-N, and it carries no Choices precisely so the chrome does not advertise ↑↓ that would do nothing. A drawn legend names the legal words instead and follows the buffer while open. Script callbacks cannot be enumerated from the scripting host -- its callbacks are anonymous Lua functions keyed by generated ids, written into runtime triggers rather than the config this screen edits -- so the field suggests the callbacks the configuration already names. Trigger.CaseSensitive drops the cached compiled Regex in its setter, the same trap Alias.CaseSensitive and Trigger.Pattern had; pinned in both directions in Core and through the screen. Also replaces the route-to radio group with an editable value, as asked. The window is a name you type -- the spawn windows that exist are defined by what routes to them -- so a radio group was the wrong shape for it: five rows, the only control in the pane not drawn like its neighbours, and unable to show a name typed for the first time without a row invented for the purpose. The windows already in use remain ↑↓ suggestions while the field is open, which is what the group was really offering. RouteRow is deleted rather than left unused. Two assertions pinning the radio rendering were re-aimed at the field: one still asserts the drawn value follows the buffer rather than config, the other that suggestions are not drawn at rest. Corrects the earlier snapshot flag: --snapshot renders your own config, and --demo-config opts into the demo worlds. Defaulting to the demo made the app's default its demo state. CI and tools/make-screenshots.sh now pass the flag explicitly, since both depend on the demo data. 912 tests pass, up from 894. Co-Authored-By: Claude Opus 5 (1M context) --- .github/workflows/ci.yml | 2 +- CLAUDE.md | 2 +- docs/HANDOFF.md | 45 +- docs/SCREENSHOTS.md | 17 +- src/SharpMUTerm.Core/Automation/Trigger.cs | 53 ++- src/SharpMUTerm.Tui/DemoScene.cs | 25 +- src/SharpMUTerm.Tui/Program.cs | 16 +- src/SharpMUTerm.Tui/ScreenField.cs | 137 ++++++ src/SharpMUTerm.Tui/TriggersScreenRenderer.cs | 305 ++++++++++--- .../Automation/TriggerEngineTests.cs | 66 +++ .../SharpMUTerm.Tui.Tests/ScreenModelTests.cs | 9 +- .../TriggersScreenActionsTests.cs | 416 ++++++++++++++++++ .../TriggersScreenEditingTests.cs | 30 +- .../TriggersScreenRendererTests.cs | 13 +- tools/make-screenshots.sh | 4 +- 15 files changed, 1030 insertions(+), 110 deletions(-) create mode 100644 tests/SharpMUTerm.Tui.Tests/TriggersScreenActionsTests.cs diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 46b43dba..adb5f507 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -61,7 +61,7 @@ jobs: shell: bash run: | dotnet run -c Release --no-build --project src/SharpMUTerm.Tui/SharpMUTerm.Tui.csproj -- \ - --snapshot --size 120x30 --out snapshot.ans --size 120x32 --out frame.ansi + --snapshot --demo-config --view --size 120x32 --out frame.ansi python3 tools/ansi_frame_to_image.py frame.ansi frame.svg ``` + **`--demo-config` is not optional for verification work.** Without it a snapshot renders + whatever config is on the machine — and a saved config in `~/.config/SharpMUTerm/` will + quietly replace the demo worlds, so you end up checking your own data and calling it the + demo. Drop the flag only when reproducing something specific to a real setup. - **Snapshot view names:** `worlds`/`settings`, `triggers`, `aliases`, `timers`, `keypad`, `textansi`, `input`, `logging`, `freeze`, `spawn`, `split`, `move`, `drag`, `history`, `menu`, `menu-split`, plus the default (no `--view`) workspace. @@ -395,9 +406,29 @@ What the framework actually provides (read at v2.5.14, not assumed): colour no short palette names, and a picker that refused the value it was showing would make an existing highlight uneditable. - **Making a Core property settable? Check for cached derived state.** - `Trigger.Pattern` and `Alias.Pattern` drop their compiled `Regex` on write, like - `Alias.CaseSensitive` already did — otherwise the rule goes on matching the - pattern it no longer has, invisibly, until a line arrives. + `Trigger.Pattern`, `Alias.Pattern` and now **`Trigger.CaseSensitive`** drop their + compiled `Regex` on write, like `Alias.CaseSensitive` always did — otherwise the + rule goes on matching the pattern (or the casing) it no longer has, invisibly, + until a line arrives. The other four that became settable for F2's action fields + — `Rewrite`, `SendResponse`, `ScriptCallback`, `AddAttributes` — carry no cache + at all: `TriggerEngine` reads each per match. Both answers are pinned, in + `TriggerEngineTests.FlippingCaseSensitivity_RecompilesTheMatcher` and + `.EditingTheActions_AppliesToTheNextLineWithNothingCached`. +- **F2 now exposes every `TriggerActions` member.** `Rewrite`, `SendResponse` and + `ScriptCallback` are `ScreenField.Template` fields (blank ⇒ **null**, so "off" has + one spelling; control characters refused, because each is drawn and typed on one + row); `AddAttributes` is a `ScreenField.Flags` **multi-select** — + deliberately not a `Choice`, and deliberately carrying **no `Choices`**, because + ↑↓ step one-of-N and bold-and-underline is not one of anything (the `↑↓ choose` + hint derives from `Choices`, so a cycling field would advertise dead keys). Its + vocabulary is drawn as a two-row **legend** under the `attrs` well, lit per + attribute and following the *buffer* while the field is open — the same rule the + route radios follow. Eight `ScreenToggle` rows were rejected: they would be eight + cursor stops for a setting most rules never touch, and a `ScreenRow` holds at most + one checkbox, so a horizontal row of them could never be one navigable row anyway. + `Trigger.CaseSensitive` is the editor pane's **third** checkbox, appended after + gag/stop-processing so their ordinals didn't move. Ordinals 0–4 are unchanged; + attributes/rewrite/respond/script are 5–8. - **Snapshot `--view -edit`** opens a settings screen and then drives real keys into it through `SettingsOverlay.SimulateKey` (the same handler `PreviewKeyPressed` raises), so a frame can show a field genuinely mid-edit. diff --git a/docs/SCREENSHOTS.md b/docs/SCREENSHOTS.md index 86892bbd..e47a531d 100644 --- a/docs/SCREENSHOTS.md +++ b/docs/SCREENSHOTS.md @@ -6,24 +6,29 @@ documentation images and CI visual checks work anywhere the .NET build runs. ## How it works SharpConsoleUI ships a `HeadlessConsoleDriver` that renders to a captured buffer instead -of a real console. `sharpmuterm --snapshot` builds the app on that driver, loads a -representative demo scene (a room, a `Chat` spawn window with unread, an input draft), -renders one frame, and writes the raw ANSI to stdout (or `--out file`). +of a real console. `sharpmuterm --snapshot` builds the app on that driver, renders one +frame, and writes the raw ANSI to stdout (or `--out file`). + +It renders **your own configuration**, like any other way of running the client. Add +`--demo-config` to render the built-in demo scene instead — a room, a `Chat` spawn window +with unread, an input draft. Every published image and golden frame uses it, since one +that changed with the developer's own worlds would be no use as either. `tools/ansi_frame_to_image.py` parses that frame — cursor-addressed truecolor SGR — into a character grid and emits a **self-contained SVG** (great for embedding in Markdown) or **HTML** (`.html` output, or `--html`). No external dependencies. ```bash -# one-shot -sharpmuterm --snapshot --size 100x30 | python3 tools/ansi_frame_to_image.py > shot.svg +# one-shot, off the demo scene +sharpmuterm --snapshot --demo-config --size 100x30 | python3 tools/ansi_frame_to_image.py > shot.svg # regenerate the committed screenshots tools/make-screenshots.sh ``` The frame is deterministic (the desktop panels/clock are disabled under the headless -driver), so `sharpmuterm --snapshot` output can also serve as a **golden file** for CI. +driver), so `sharpmuterm --snapshot --demo-config` output can also serve as a **golden +file** for CI — which is exactly what the CI smoke check greps. ## Animated demos (VHS) diff --git a/src/SharpMUTerm.Core/Automation/Trigger.cs b/src/SharpMUTerm.Core/Automation/Trigger.cs index 66b59ab6..e512ca4a 100644 --- a/src/SharpMUTerm.Core/Automation/Trigger.cs +++ b/src/SharpMUTerm.Core/Automation/Trigger.cs @@ -20,17 +20,26 @@ public sealed class TriggerActions /// Recolour the matched region's background. Settable for the same reason as its foreground. public TerminalColor? HighlightBackground { get; set; } - /// Add these attributes to the matched region (e.g. bold). - public TextAttributes AddAttributes { get; init; } = TextAttributes.None; + /// + /// Add these attributes to the matched region (e.g. bold). Settable so the F2 screen's attribute + /// field can change it live; reads it per match and derives nothing + /// from it, so there is no cache to drop and a change applies to the next line. + /// + public TextAttributes AddAttributes { get; set; } = TextAttributes.None; /// /// Replace the whole line's text with this template (supports $1..$9 and - /// ${name} capture references). Rewritten text renders with the default style. + /// ${name} capture references). Rewritten text renders with the default style. Null — which + /// is what the F2 screen writes for a blank field — means the rule rewrites nothing; settable for + /// the same reason is, and with the same absence of any cached state. /// - public string? Rewrite { get; init; } + public string? Rewrite { get; set; } - /// Send this command back to the server (capture references supported). - public string? SendResponse { get; init; } + /// + /// Send this command back to the server (capture references supported). Null or empty means the + /// rule answers nothing. Settable so the F2 screen can edit it live; nothing is derived from it. + /// + public string? SendResponse { get; set; } /// /// Route the line to a named spawn window instead of the main output; null routes to the main @@ -40,8 +49,12 @@ public sealed class TriggerActions /// public string? SpawnTarget { get; set; } - /// Invoke this named script callback (resolved by the scripting layer). - public string? ScriptCallback { get; init; } + /// + /// Invoke this named script callback (resolved by the scripting layer). Null or empty means the + /// rule calls nothing. Settable so the F2 screen can point a rule at a callback live; the engine + /// resolves the name per match, so nothing is cached from it. + /// + public string? ScriptCallback { get; set; } /// /// A copy of these actions. Every field is a value or an immutable string, so a member-wise copy @@ -69,6 +82,7 @@ public sealed class TriggerActions public sealed class Trigger { private Regex? _compiled; + private bool _caseSensitive; private string _pattern = string.Empty; /// @@ -100,7 +114,26 @@ public required string Pattern public bool Enabled { get; set; } = true; - public bool CaseSensitive { get; init; } + /// + /// Match case exactly. Settable so the F2 settings screen can flip it live — the asymmetry with + /// , which F3 has always offered, was arbitrary. Writing it drops + /// the cached , because the casing is baked into that regex's options: without + /// the drop the rule would go on matching with the old options, invisibly, until a line arrived. + /// + public bool CaseSensitive + { + get => _caseSensitive; + set + { + if (_caseSensitive == value) + { + return; + } + + _caseSensitive = value; + _compiled = null; + } + } /// /// When true, later triggers are not evaluated once this one matches. Settable so the F2 screen @@ -122,7 +155,7 @@ public required string Pattern /// are copied rather than shared: an aliased copy would look right and then /// follow every later edit of its original's gag, route and highlight around. The compiled /// is deliberately not carried over; the copy builds its own on first use, so a - /// later pattern edit on either rule cannot be seen by the other. + /// later pattern or casing edit on either rule cannot be seen by the other. /// public Trigger Clone() => new() { diff --git a/src/SharpMUTerm.Tui/DemoScene.cs b/src/SharpMUTerm.Tui/DemoScene.cs index 42d27a61..dbb9b186 100644 --- a/src/SharpMUTerm.Tui/DemoScene.cs +++ b/src/SharpMUTerm.Tui/DemoScene.cs @@ -73,17 +73,34 @@ private static void AddTriggerSets(AppConfiguration config) Description = "channel + page routing", Triggers = { + // The F2 screen opens on this rule, so it is the one that has to exercise the editor + // pane: a capture group to reference, a rewrite that uses it, an attribute, a script + // callback, and case-sensitive matching. Its `respond` is deliberately left off — the + // frame should show both states of an action, not four filled wells. new Trigger { Name = "public", - Pattern = @"^\[public\]", - Actions = new TriggerActions { SpawnTarget = "Chat", HighlightForeground = teal }, + Pattern = @"^\[public\] (.+)$", + CaseSensitive = true, + Actions = new TriggerActions + { + SpawnTarget = "Chat", + HighlightForeground = teal, + AddAttributes = TextAttributes.Bold, + Rewrite = "» $1", + ScriptCallback = "onChannel", + }, }, new Trigger { Name = "page", - Pattern = @"^\w+ pages:", - Actions = new TriggerActions { SpawnTarget = "pages", HighlightForeground = pink }, + Pattern = @"^(\w+) pages:", + Actions = new TriggerActions + { + SpawnTarget = "pages", + HighlightForeground = pink, + SendResponse = "page $1=afk, back shortly", + }, }, new Trigger { diff --git a/src/SharpMUTerm.Tui/Program.cs b/src/SharpMUTerm.Tui/Program.cs index 85341bb4..0c8feb03 100644 --- a/src/SharpMUTerm.Tui/Program.cs +++ b/src/SharpMUTerm.Tui/Program.cs @@ -27,12 +27,12 @@ private static int Main(string[] args) // the snapshot is deterministic however it's launched (terminal, pipe, or CI redirect). Console.SetIn(TextReader.Null); - // Snapshots always render the demo configuration, never whatever happens to be on this - // machine. They exist for docs images and golden files, and a golden file that changes - // with the developer's own worlds isn't one — the same command has to produce the same - // frame everywhere. `--snapshot --live-config` opts into the real config for debugging - // something only your own setup reproduces. - if (!args.Contains("--live-config")) + // A snapshot shows your own configuration, like every other way of running the client. + // `--demo-config` swaps in the built-in demo worlds instead: that is what the docs images + // and golden frames use, because a golden file that changes with the developer's own + // worlds isn't one. Opting in keeps the demo where it belongs — an explicit request, + // never the default state of the app. + if (args.Contains("--demo-config")) { config = DemoScene.Build(); } @@ -154,11 +154,11 @@ private static void PrintUsage() Console.WriteLine(" --tls Connect over TLS."); Console.WriteLine(" --insecure Accept invalid TLS certificates."); Console.WriteLine(" --name Display name for the world."); - Console.WriteLine(" --snapshot Render one demo frame (ANSI) headlessly and exit."); + Console.WriteLine(" --snapshot Render one frame (ANSI) headlessly and exit."); Console.WriteLine(" --size Snapshot size in cells (default 160x48)."); Console.WriteLine(" --view Snapshot an overlay (e.g. 'settings') over the workspace."); Console.WriteLine(" '-edit' opens that settings screen mid field edit."); - Console.WriteLine(" --live-config Snapshot your own config instead of the demo worlds."); + Console.WriteLine(" --demo-config Snapshot the built-in demo worlds instead of your own."); Console.WriteLine(" --out Write the snapshot to a file instead of stdout."); Console.WriteLine(" -h, --help Show this help."); Console.WriteLine(); diff --git a/src/SharpMUTerm.Tui/ScreenField.cs b/src/SharpMUTerm.Tui/ScreenField.cs index 9aa7acda..b6175f24 100644 --- a/src/SharpMUTerm.Tui/ScreenField.cs +++ b/src/SharpMUTerm.Tui/ScreenField.cs @@ -139,6 +139,143 @@ internal static ScreenField Optional(string label, Func get, Action + /// An action that is off when it is blank — a trigger's rewrite template, the command it + /// answers with, the script it calls. Blank is stored as null rather than as "", so "unset" + /// and "set to nothing" cannot drift apart in config the way two spellings of the same state + /// always do; the screens draw the null state in words. + /// + /// Refused when it carries control characters. All three of these values are typed on one row and + /// drawn on one row, and a newline inside one would break both — a rewrite would smuggle a second + /// output line past the line model, and a response would smuggle a second command past the server. + /// + /// + /// is offered as ↑↓ suggestions exactly the way + /// offers the spawn windows already in use: values seen elsewhere in the configuration, not a + /// closed list. Free text is the point — a script callback naming a function nothing calls yet is + /// how the first rule that calls it gets written. + /// + /// + internal static ScreenField Template( + string label, Func get, Action set, IReadOnlyList? known = null) + { + ArgumentNullException.ThrowIfNull(get); + ArgumentNullException.ThrowIfNull(set); + + return new ScreenField( + label, + () => get() ?? string.Empty, + value => value.Any(char.IsControl) ? $"{label} cannot contain control characters" : null, + value => set(string.IsNullOrWhiteSpace(value) ? null : value.Trim()), + Restore(get, set), + known is { Count: > 0 } ? known : null); + } + + /// + /// A [Flags] enumeration: several independent booleans, written as a space-separated list of + /// their names and read back the same way. none is the empty set. + /// + /// Deliberately not a , and deliberately carrying no + /// : ↑↓ step one-of-N, and bold-and-underline is not one of anything. Leaving + /// null is also what keeps the chrome honest — the ↑↓ choose hint is + /// derived from it, so a field with nothing to cycle cannot advertise the keys. + /// + /// + internal static ScreenField Flags(string label, Func get, Action set) + where TEnum : struct, Enum + { + ArgumentNullException.ThrowIfNull(get); + ArgumentNullException.ThrowIfNull(set); + + return new ScreenField( + label, + () => FormatFlags(get()), + value => UnknownFlag(value) is { } bad ? $"{label} has no '{bad}'" : null, + value => set((TEnum)Enum.ToObject(typeof(TEnum), CombineFlags(value))), + Restore(get, set)); + } + + /// What a flag set with nothing in it reads and is typed as. + internal const string NoFlags = "none"; + + /// The separators a flag list may be typed with — spaces, commas, or pipes. + private static readonly char[] FlagSeparators = { ' ', '\t', ',', '|', '+' }; + + /// + /// Every non-zero member of a [Flags] enumeration, lower-cased, in declaration order — the + /// vocabulary a field accepts, and the list a screen draws so the words + /// are discoverable without being typed blind. + /// + internal static IReadOnlyList FlagNames() where TEnum : struct, Enum => + Enum.GetValues() + .Where(v => Convert.ToInt64(v, CultureInfo.InvariantCulture) != 0) + .Select(v => v.ToString()!.ToLowerInvariant()) + .ToArray(); + + /// A flag set as reads it: the set names, or . + internal static string FormatFlags(TEnum value) where TEnum : struct, Enum + { + var bits = Convert.ToInt64(value, CultureInfo.InvariantCulture); + var set = Enum.GetValues() + .Select(v => (Name: v.ToString()!.ToLowerInvariant(), Bits: Convert.ToInt64(v, CultureInfo.InvariantCulture))) + .Where(f => f.Bits != 0 && (bits & f.Bits) == f.Bits) + .Select(f => f.Name) + .ToArray(); + + return set.Length == 0 ? NoFlags : string.Join(' ', set); + } + + /// + /// Whether a typed flag list names a given flag. Screens ask this rather than parsing, so a legend + /// can follow the buffer while a field is open — the same rule F2's route radios follow, + /// and the reason ↑↓ and typing both visibly do something before ⏎ commits anything. + /// + internal static bool FlagIsListed(string spec, string name) => + spec.Split(FlagSeparators, StringSplitOptions.RemoveEmptyEntries) + .Any(word => string.Equals(word, name, StringComparison.OrdinalIgnoreCase)); + + /// The first word of a flag list that names nothing, or null when every word is legal. + private static string? UnknownFlag(string value) where TEnum : struct, Enum + { + var names = FlagNames(); + foreach (var word in value.Split(FlagSeparators, StringSplitOptions.RemoveEmptyEntries)) + { + if (string.Equals(word, NoFlags, StringComparison.OrdinalIgnoreCase)) + { + continue; + } + + if (!names.Contains(word, StringComparer.OrdinalIgnoreCase)) + { + return word; + } + } + + return null; + } + + /// The combined bits of a flag list that has accepted. + private static long CombineFlags(string value) where TEnum : struct, Enum + { + var members = Enum.GetValues() + .Select(v => (Name: v.ToString()!, Bits: Convert.ToInt64(v, CultureInfo.InvariantCulture))) + .ToArray(); + + var bits = 0L; + foreach (var word in value.Split(FlagSeparators, StringSplitOptions.RemoveEmptyEntries)) + { + foreach (var member in members) + { + if (string.Equals(member.Name, word, StringComparison.OrdinalIgnoreCase)) + { + bits |= member.Bits; + } + } + } + + return bits; + } + /// /// The name of a window to route output to. Free text, with the windows already in use offered /// as ↑↓ suggestions — deliberately not a , because the set of spawn windows diff --git a/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs b/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs index ad62ee5c..2d3d25f5 100644 --- a/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs @@ -10,7 +10,8 @@ namespace SharpMUTerm.Tui; /// Produces the markup sub-blocks for the F2 Triggers & spawn routing screen — the header band, /// the rule list (flattened across every , each row carrying its enabled /// state, name/pattern, owning set, action flags, and route), the editor for the selected trigger -/// (pattern, route-to list, highlight swatches, and toggles), and the footer action bar. +/// (pattern, route-to list, highlight swatches and attributes, the three action templates, and +/// the toggles), and the footer action bar. /// composes these into real panels (grids) for the live/snapshot /// view; merges the same blocks into a single line list for the unit tests. /// Pure so every block is testable. @@ -47,6 +48,35 @@ internal static class TriggersScreenRenderer internal const int BackgroundField = 4; + internal const int AttributesField = 5; + + internal const int RewriteField = 6; + + internal const int ResponseField = 7; + + internal const int ScriptField = 8; + + /// + /// How wide the fg / bg / attrs and rewrite / respond / + /// script labels are padded, so the field wells in each section start in the same column. + /// + private const int HighlightLabelWidth = 5; + + private const int ActionLabelWidth = 7; + + /// How many attributes a legend row lists before wrapping to the next. + private const int AttributesPerRow = 4; + + /// + /// What an unconfigured action reads as. An empty well would say nothing at all, and the whole + /// point of these three being null-when-blank is that "this rule does not rewrite" is a state worth + /// naming — not the same thing as "this rule rewrites to the empty string". + /// + private const string OffLabel = "(off)"; + + /// The vocabulary the attributes field accepts, in the enum's own declaration order. + private static readonly IReadOnlyList AttributeNames = ScreenField.FlagNames(); + /// The labels the rule list's buttons carry, in the order they are drawn. internal const string AddTriggerLabel = "+ trigger"; @@ -94,6 +124,64 @@ internal static IReadOnlyList Routes(Trigger trigger, IReadOnlyList + /// The script callbacks offered as ↑↓ suggestions on a rule's script field: every callback + /// named anywhere in the configuration — by a trigger, an alias, a timer or a macro — plus the one + /// this rule already names, so a rule pointing at a function nothing else calls still shows its own + /// value. + /// + /// They are suggestions, not the permitted set, and they deliberately do not come from the + /// scripting host. A cannot enumerate anything + /// useful here: the callbacks it holds are keyed by ids it generates itself + /// (trigger#1), created by trigger.add(pattern, function ... end) whose function is + /// anonymous, and written into runtime triggers rather than into the configuration this + /// screen edits. What a user can actually type is a name their own Lua defines, so the honest + /// suggestion list is the vocabulary their configuration already uses. + /// + /// + internal static IReadOnlyList Callbacks(Trigger trigger, IReadOnlyList? known) + { + ArgumentNullException.ThrowIfNull(trigger); + + var callbacks = new List(); + foreach (var callback in (known ?? Array.Empty()).Append(trigger.Actions.ScriptCallback)) + { + if (!string.IsNullOrWhiteSpace(callback) && !callbacks.Contains(callback, StringComparer.Ordinal)) + { + callbacks.Add(callback); + } + } + + return callbacks; + } + + /// + /// Every script callback the configuration names, swept once per projection rather than once per + /// rule — the model is rebuilt on every keystroke, and this is the only part of a row that has to + /// look at every other set to build itself. + /// + private static List NamedCallbacks(IReadOnlyList sets) + { + var named = new List(); + foreach (var set in sets) + { + var all = set.Triggers.Select(t => t.Actions.ScriptCallback) + .Concat(set.Aliases.Select(a => a.ScriptCallback)) + .Concat(set.Timers.Select(t => t.ScriptCallback)) + .Concat(set.Macros.Select(m => m.ScriptCallback)); + + foreach (var callback in all) + { + if (!string.IsNullOrWhiteSpace(callback) && !named.Contains(callback, StringComparer.Ordinal)) + { + named.Add(callback); + } + } + } + + return named; + } + /// /// Merges every sub-block into one line list (header, rule list | editor, footer). Used by the /// unit tests and as a width-agnostic fallback; the live view composes the same blocks into @@ -140,9 +228,10 @@ internal static string HeaderLine(int width, ScreenModel? model = null, ScreenFo } /// - /// The screen's navigable panes: the rule list (Space enables/disables a trigger, ⏎ edits its - /// match pattern and then ⇥ steps through its route and its two highlight colours) and the - /// selected rule's checkbox rows, in the order draws them. + /// The screen's navigable panes: the rule list (Space enables/disables a trigger, ⏎ edits its name + /// and then ⇥ steps through its pattern, route, two highlight colours, attributes, and its rewrite, + /// response and script templates) and the selected rule's checkbox rows, in the order + /// draws them. /// /// Everything the editor pane *displays* about the selected rule belongs to that rule's own list /// row rather than to the editor pane. That is the same reason the pattern does: a rule's route @@ -165,6 +254,7 @@ internal static ScreenModel Model( ArgumentNullException.ThrowIfNull(sets); var flattened = Flatten(sets); + var callbacks = NamedCallbacks(sets); var rules = ScreenModel.Rows(flattened, entry => ScreenRow.Of( ScreenToggle.Bind(() => entry.Trigger.Enabled, v => entry.Trigger.Enabled = v), ScreenField.Name("name", () => entry.Trigger.Name, v => entry.Trigger.Name = v), @@ -182,7 +272,22 @@ internal static ScreenModel Model( ScreenField.Colour( "highlight bg", () => entry.Trigger.Actions.HighlightBackground, - v => entry.Trigger.Actions.HighlightBackground = v))) + v => entry.Trigger.Actions.HighlightBackground = v), + ScreenField.Flags( + "attributes", + () => entry.Trigger.Actions.AddAttributes, + v => entry.Trigger.Actions.AddAttributes = v), + ScreenField.Template( + "rewrite", () => entry.Trigger.Actions.Rewrite, v => entry.Trigger.Actions.Rewrite = v), + ScreenField.Template( + "respond", + () => entry.Trigger.Actions.SendResponse, + v => entry.Trigger.Actions.SendResponse = v), + ScreenField.Template( + "script", + () => entry.Trigger.Actions.ScriptCallback, + v => entry.Trigger.Actions.ScriptCallback = v, + Callbacks(entry.Trigger, callbacks)))) .Concat(Buttons(sets, selectedTrigger)) .ToArray(); @@ -192,10 +297,13 @@ internal static ScreenModel Model( } var trigger = flattened[selectedTrigger].Trigger; + // Appended rather than inserted: these are the pane's cursor stops, and putting the new one + // above the two that were here would renumber rows the screen (and its tests) already address. var editor = new[] { ScreenRow.Of(ScreenToggle.Bind(() => trigger.Actions.Gag, v => trigger.Actions.Gag = v)), ScreenRow.Of(ScreenToggle.Bind(() => trigger.StopProcessing, v => trigger.StopProcessing = v)), + ScreenRow.Of(ScreenToggle.Bind(() => trigger.CaseSensitive, v => trigger.CaseSensitive = v)), }; return new ScreenModel(rules, editor); @@ -298,8 +406,8 @@ internal static List RulesColumn( } /// - /// The editor for the selected rule — pattern, route-to list, highlight swatches, and toggles. - /// Empty when nothing is selected. + /// The editor for the selected rule — pattern, route-to list, highlight swatches and attributes, + /// the rewrite/respond/script templates, and the toggles. Empty when nothing is selected. /// internal static List EditorColumn( IReadOnlyList sets, @@ -346,7 +454,12 @@ private static string RuleSub(string owningSet, TriggerActions actions) => private static string Flags(TriggerActions actions) { var flags = new List(); - if (actions.HighlightForeground is not null || actions.HighlightBackground is not null) + + // Attributes count as highlighting because that is literally what they are: TriggerEngine + // restyles the matched region when a colour *or* an attribute is set, through one code path. + if (actions.HighlightForeground is not null + || actions.HighlightBackground is not null + || actions.AddAttributes != TextAttributes.None) { flags.Add("H"); } @@ -356,7 +469,12 @@ private static string Flags(TriggerActions actions) flags.Add("G"); } - if (actions.SendResponse is not null) + if (!string.IsNullOrEmpty(actions.Rewrite)) + { + flags.Add("✎"); + } + + if (!string.IsNullOrEmpty(actions.SendResponse)) { flags.Add("R"); } @@ -366,7 +484,7 @@ private static string Flags(TriggerActions actions) flags.Add(Glyphs.Capture); } - if (actions.ScriptCallback is not null) + if (!string.IsNullOrEmpty(actions.ScriptCallback)) { flags.Add("ƒ"); } @@ -382,6 +500,10 @@ private static List BuildEditor( var route = cursor.EditOn(0, index, RouteField); var foreground = cursor.EditOn(0, index, ForegroundField); var background = cursor.EditOn(0, index, BackgroundField); + var attributes = cursor.EditOn(0, index, AttributesField); + var rewrite = cursor.EditOn(0, index, RewriteField); + var response = cursor.EditOn(0, index, ResponseField); + var script = cursor.EditOn(0, index, ScriptField); // While the route field is open the radios follow the *buffer*, not config, so ↑↓ visibly move // the dot before anything is committed — the buffer is what ⏎ would write. @@ -398,43 +520,54 @@ private static List BuildEditor( $" {ScreenChrome.Field(Escape(trigger.Pattern), pattern)}", string.Empty, Heading("route to", route), - }; - var known = Routes(trigger, spawnTargets); - foreach (var target in known) - { - lines.Add(RouteRow(target, currentRoute, route is not null)); - } - - // A route may name a window that doesn't exist yet — that is how a spawn window is created. - // The rows above are the windows already in use, so a name being typed for the first time - // matches none of them and would otherwise be invisible: the group would sit with no dot lit - // while the keyboard was plainly doing something. Give the new name its own row, carrying the - // caret, so what is being typed is on screen where the committed value will be. - if (route is { } typing && !known.Contains(currentRoute, StringComparer.Ordinal)) - { - lines.Add($" [{Accent}]●[/] {ScreenChrome.Field(Escape(currentRoute), typing)}"); - } + // The window is a name you type, not one of a fixed set — the spawn windows that exist + // are defined by what routes to them, so a closed list could only ever re-use one. It is + // therefore drawn as an editable value like every other row in this pane rather than as a + // radio group: the group cost five rows, was the only control here shaped differently + // from its neighbours, and could not show a name being typed for the first time without a + // row invented for the purpose. The windows already in use remain ↑↓ suggestions while + // the field is open, which is what a radio group was really offering. + $" {ScreenChrome.Field(Escape(currentRoute), route)}", + }; var fg = trigger.Actions.HighlightForeground; var bg = trigger.Actions.HighlightBackground; + var attrs = trigger.Actions.AddAttributes; - // What the two swatch rows add up to is a caption on the section that owns them, not a fourth + // What the swatch rows add up to is a caption on the section that owns them, not a fourth // checkbox under it. It was drawn as one, which made it look like a fourth thing to press: the // cursor cannot land on it, Space does nothing to it, and it sat *below* the two rows it is // derived from, so it read as a cause rather than the effect it is. The caption says the same // thing, above the rows that decide it, in a shape nothing offers to press. + // + // Attributes belong to this section rather than one of their own because TriggerEngine restyles + // a matched region through a single path for colours and attributes alike — and while the + // caption only knew about colours it flatly lied about a bold-only rule. lines.Add(string.Empty); - lines.Add(Heading("highlight", foreground ?? background, HighlightCaption(fg, bg))); + lines.Add(Heading("highlight", foreground ?? background ?? attributes, HighlightCaption(fg, bg, attrs))); lines.Add(HighlightRow("fg", fg, foreground)); lines.Add(HighlightRow("bg", bg, background)); + lines.Add(AttributeRow(attrs, attributes)); + lines.AddRange(AttributeLegend(attributes?.Text ?? ScreenField.FormatFlags(attrs))); + + // The three action templates. They are one section because they are the three things a rule can + // *do* to a line beyond recolouring it, and they are not exclusive — a rule may gag a line, + // answer it and call a script off the same match. + lines.Add(string.Empty); + lines.Add(Heading("actions", null, ScreenChrome.ReadOnly("· $1..$9 insert captures"))); + lines.Add(ActionRow("rewrite", trigger.Actions.Rewrite, rewrite)); + lines.Add(ActionRow("respond", trigger.Actions.SendResponse, response)); + lines.Add(ActionRow("script", trigger.Actions.ScriptCallback, script)); lines.Add(string.Empty); - // The two rows below are real booleans on the trigger, and are the editor pane's navigable rows - // in this order. + // The three rows below are real booleans on the trigger, and are the editor pane's navigable + // rows in this order. lines.Add(ScreenChrome.Cursor(Checkbox("gag line", trigger.Actions.Gag), cursor.IsOn(1, 0), ColumnWidth)); lines.Add(ScreenChrome.Cursor( Checkbox("stop processing", trigger.StopProcessing), cursor.IsOn(1, 1), ColumnWidth)); + lines.Add(ScreenChrome.Cursor( + Checkbox("case sensitive", trigger.CaseSensitive), cursor.IsOn(1, 2), ColumnWidth)); return lines; } @@ -461,32 +594,27 @@ private static string Heading(string label, ScreenFieldEdit? edit, string? capti } /// - /// What the two swatch rows amount to, read out beside the section heading: whether a matching line - /// gets recoloured at all. Muted rather than accented, because it reports the state of the two rows - /// below it and cannot itself be changed — the same treatment every other readout on these screens - /// gets (see ). - /// - private static string HighlightCaption(TerminalColor? foreground, TerminalColor? background) => - foreground is not null || background is not null - ? ScreenChrome.ReadOnly("· matching lines are recoloured") - : "[dim]· matching lines are left alone[/]"; - - /// - /// One radio of the route group. wells the whole group so it reads as - /// live rather than as the report it is the rest of the time — the selected radio moves with ↑↓, - /// and a group that looked identical either way would give no sign the keyboard had it. + /// What the section's rows amount to, read out beside its heading: whether a matching line gets + /// restyled at all. Muted rather than accented, because it reports the state of the rows below it + /// and cannot itself be changed — the same treatment every other readout on these screens gets (see + /// ). + /// + /// Attributes are read here as well as the colours, because the engine restyles on either. Left to + /// the colours alone, a rule that only bolds its match would have been captioned "left alone" while + /// visibly bolding every line it matched. + /// /// - private static string RouteRow(string label, string currentRoute, bool editing) + private static string HighlightCaption( + TerminalColor? foreground, TerminalColor? background, TextAttributes attributes) { - var selected = string.Equals(label, currentRoute, StringComparison.Ordinal); - if (!selected) + if (foreground is not null || background is not null) { - return $" [dim]○[/] {Escape(label)}"; + return ScreenChrome.ReadOnly("· matching lines are recoloured"); } - return editing - ? $" [{Accent}]●[/] [{Value} on {FieldBg}]{Escape(label)} [/]" - : $" [{Accent}]●[/] {Escape(label)}"; + return attributes != TextAttributes.None + ? ScreenChrome.ReadOnly("· matching text is restyled") + : "[dim]· matching lines are left alone[/]"; } /// @@ -499,6 +627,79 @@ private static string HighlightRow(string label, TerminalColor? colour, ScreenFi var swatch = colour is { } set ? $"[{ScreenColours.Hex(set, Accent)}]████[/]" : $"[{Rule}]░░░░[/]"; var name = ScreenColours.Format(colour); var display = colour is null ? $"[dim]{name}[/]" : $"[{Value}]{Escape(name)}[/]"; - return $" {swatch} {label} {ScreenChrome.Field(display, edit)}"; + return $" {swatch} {PadVisible(label, HighlightLabelWidth)} {ScreenChrome.Field(display, edit)}"; + } + + /// + /// The attributes value, drawn in the same swatch label value shape as the two colours it + /// sits under — one field well, because it is one setting, however many booleans it packs. Its + /// swatch is filled or hollow on the same rule as theirs: something is added to the match, or + /// nothing is. + /// + private static string AttributeRow(TextAttributes attributes, ScreenFieldEdit? edit) + { + var swatch = attributes == TextAttributes.None ? $"[{Rule}]░░░░[/]" : $"[{Accent}]▚▚▚▚[/]"; + var spec = ScreenField.FormatFlags(attributes); + var display = attributes == TextAttributes.None + ? $"[dim]{Escape(spec)}[/]" + : $"[{Value}]{Escape(spec)}[/]"; + return $" {swatch} {PadVisible("attrs", HighlightLabelWidth)} {ScreenChrome.Field(display, edit)}"; + } + + /// + /// The whole attribute vocabulary, wrapped over as many rows as it takes, each name lit when it is + /// in and muted when it isn't. + /// + /// This is the "row of checkboxes" the setting really is, and it is drawn rather than navigated + /// deliberately. Eight rows would be eight cursor stops for a setting + /// most rules never touch, burying the three flags below them; and a holds + /// at most one checkbox, so a *horizontal* row of them could never be one navigable row anyway. As + /// a legend it does the one job the field cannot: it says what the legal words are, so nobody has + /// to type into attrs blind. + /// + /// + /// It follows the buffer while the field is open, exactly as the route radios do — a + /// legend that only moved on ⏎ would look inert for precisely as long as it was being used. + /// + /// + private static IEnumerable AttributeLegend(string spec) + { + // Column widths, not one width for all: "strikethrough" is thirteen cells and padding every + // name to it would push the legend past the editor column at the widths this screen is used at. + var widths = new int[AttributesPerRow]; + for (var i = 0; i < AttributeNames.Count; i++) + { + widths[i % AttributesPerRow] = Math.Max(widths[i % AttributesPerRow], AttributeNames[i].Length); + } + + for (var start = 0; start < AttributeNames.Count; start += AttributesPerRow) + { + var cells = new List(AttributesPerRow); + for (var i = start; i < Math.Min(start + AttributesPerRow, AttributeNames.Count); i++) + { + var name = AttributeNames[i]; + var padded = name.PadRight(widths[i % AttributesPerRow]); + cells.Add(ScreenField.FlagIsListed(spec, name) + ? $"[{Accent}]✓{padded}[/]" + : $"[dim]·{padded}[/]"); + } + + yield return " " + string.Join(" ", cells).TrimEnd(); + } + } + + /// + /// One of the three action templates: its label, then its value in a field well — or a muted + /// (off) in that same well when nothing is set. The well stays either way, because the row is + /// still a place a value goes; what changes is that the screen says, in words, that this rule does + /// not rewrite / does not answer / calls nothing, which is a different state from a template that + /// happens to be empty (see , which stores blank as null). + /// + private static string ActionRow(string label, string? value, ScreenFieldEdit? edit) + { + var display = string.IsNullOrEmpty(value) + ? $"[dim]{OffLabel}[/]" + : $"[{Value}]{Escape(value)}[/]"; + return $" {PadVisible(label, ActionLabelWidth)} {ScreenChrome.Field(display, edit)}"; } } diff --git a/tests/SharpMUTerm.Core.Tests/Automation/TriggerEngineTests.cs b/tests/SharpMUTerm.Core.Tests/Automation/TriggerEngineTests.cs index aaeb0106..a16aabf6 100644 --- a/tests/SharpMUTerm.Core.Tests/Automation/TriggerEngineTests.cs +++ b/tests/SharpMUTerm.Core.Tests/Automation/TriggerEngineTests.cs @@ -138,4 +138,70 @@ public async Task RewritingThePattern_RecompilesTheMatcher() await Assert.That(engine.Process(Line("this is spam")).Suppress).IsFalse(); await Assert.That(engine.Process(Line("this is noise")).Suppress).IsTrue(); } + + /// + /// Case sensitivity is settable so the F2 settings screen can flip it — F3 has always offered it on + /// an alias, and the asymmetry was arbitrary. It is the second property on a trigger with cached + /// derived state: the casing is compiled into 's options, so writing it + /// has to drop that cache or the rule goes on matching with the old options, invisibly, until a line + /// arrives. + /// + [Test] + public async Task FlippingCaseSensitivity_RecompilesTheMatcher() + { + var trigger = new Trigger { Pattern = "HELLO", Actions = new TriggerActions { Gag = true } }; + var engine = new TriggerEngine(); + engine.Add(trigger); + await Assert.That(engine.Process(Line("hello world")).Suppress).IsTrue(); + + trigger.CaseSensitive = true; + + await Assert.That(engine.Process(Line("hello world")).Suppress).IsFalse(); + await Assert.That(engine.Process(Line("HELLO world")).Suppress).IsTrue(); + + // And back, so the cache is dropped in both directions rather than only on the way up. + trigger.CaseSensitive = false; + await Assert.That(engine.Process(Line("hello world")).Suppress).IsTrue(); + } + + /// + /// The four action values the F2 screen now edits are settable, and — unlike the casing — carry no + /// cache at all: reads each one per match, so an edit applies to the very + /// next line. Asserted together, because "check for cached derived state" is a question that has to + /// be answered for every property that becomes writable, and this is the answer for these four. + /// + [Test] + public async Task EditingTheActions_AppliesToTheNextLineWithNothingCached() + { + var trigger = new Trigger { Pattern = @"hp: (\d+)", Actions = new TriggerActions() }; + var engine = new TriggerEngine(); + engine.Add(trigger); + + var before = engine.Process(Line("hp: 42")); + await Assert.That(before.Responses).IsEmpty(); + await Assert.That(before.ScriptInvocations).IsEmpty(); + await Assert.That(before.Line.Text).IsEqualTo("hp: 42"); + + trigger.Actions.Rewrite = "low: $1"; + trigger.Actions.SendResponse = "quaff potion"; + trigger.Actions.ScriptCallback = "onHp"; + trigger.Actions.AddAttributes = TextAttributes.Bold; + + var after = engine.Process(Line("hp: 42")); + await Assert.That(after.Line.Text).IsEqualTo("low: 42"); + await Assert.That(after.Responses).HasSingleItem(); + await Assert.That(after.Responses[0]).IsEqualTo("quaff potion"); + await Assert.That(after.ScriptInvocations).HasSingleItem(); + await Assert.That(after.ScriptInvocations[0].Callback).IsEqualTo("onHp"); + + // Clearing them turns each action back off, again with no stale copy anywhere. + trigger.Actions.Rewrite = null; + trigger.Actions.SendResponse = null; + trigger.Actions.ScriptCallback = null; + + var cleared = engine.Process(Line("hp: 42")); + await Assert.That(cleared.Line.Text).IsEqualTo("hp: 42"); + await Assert.That(cleared.Responses).IsEmpty(); + await Assert.That(cleared.ScriptInvocations).IsEmpty(); + } } diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs index 116e0c92..32cf1bcc 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs @@ -58,7 +58,11 @@ public async Task Triggers_HasARuleListAndTheSelectedRulesToggles() // every index below addresses and is unchanged; the buttons are appended after it. await Assert.That(model.ListSizes[0]).IsEqualTo(2); await Assert.That(model.Sizes[0]).IsEqualTo(5); - await Assert.That(model.Sizes[1]).IsEqualTo(2); + + // Three checkbox rows: gag and stop-processing, plus case sensitivity — which F3 has always + // offered on an alias and F2 arbitrarily did not. It is appended rather than inserted, so the + // two rows below still mean what every other assertion here says they mean. + await Assert.That(model.Sizes[1]).IsEqualTo(3); model.ToggleAt(0, 1)!.Value.Flip(); await Assert.That(sets[0].Triggers[1].Enabled).IsTrue(); @@ -68,6 +72,9 @@ public async Task Triggers_HasARuleListAndTheSelectedRulesToggles() model.ToggleAt(1, 1)!.Value.Flip(); await Assert.That(sets[0].Triggers[0].StopProcessing).IsTrue(); + + model.ToggleAt(1, 2)!.Value.Flip(); + await Assert.That(sets[0].Triggers[0].CaseSensitive).IsTrue(); } [Test] diff --git a/tests/SharpMUTerm.Tui.Tests/TriggersScreenActionsTests.cs b/tests/SharpMUTerm.Tui.Tests/TriggersScreenActionsTests.cs new file mode 100644 index 00000000..8cb2b712 --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/TriggersScreenActionsTests.cs @@ -0,0 +1,416 @@ +using SharpMUTerm.Core.Automation; +using SharpMUTerm.Core.Configuration; +using SharpMUTerm.Core.Text; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// The half of a trigger that F2 used to hide. can rewrite a line, answer +/// it, restyle it and call a script, and the README has always advertised all four — but only gag, +/// highlight and spawn-route had any UI, so three of the six advertised actions were unreachable +/// without hand-editing the JSON. These pin what each new field writes, what it refuses, that Esc puts +/// the old value back, and — the sharp edge — that flipping case sensitivity drops the compiled matcher +/// the way already did. +/// +public class TriggersScreenActionsTests +{ + private static ConsoleKeyInfo Key(ConsoleKey key) => new('\0', key, false, false, false); + + private static readonly string[] Targets = { "Chat" }; + + private static List Sets() => new() + { + new TriggerSet + { + Name = "Comms", + Triggers = new List + { + new() + { + Name = "Tell", + Pattern = @"^(\w+) tells you (.*)$", + Actions = new TriggerActions + { + SpawnTarget = "Chat", + AddAttributes = TextAttributes.Bold, + Rewrite = "» $1: $2", + SendResponse = "page $1=busy", + ScriptCallback = "onTell", + }, + }, + new() { Name = "Spam", Pattern = "guild", Actions = new TriggerActions() }, + }, + Aliases = new List + { + new() { Name = "gr", Pattern = "^gr$", Substitution = "greet", ScriptCallback = "onGreet" }, + }, + Timers = new List + { + new() { Name = "tick", IntervalSeconds = 30, Command = "score", ScriptCallback = "onTick" }, + }, + }, + }; + + private static ScreenField Field(IReadOnlyList sets, int rule, int ordinal) => + TriggersScreenRenderer.Model(sets, rule, Targets).FieldAt(0, rule, ordinal)!.Value; + + // ---- rewrite / respond / script ------------------------------------------------------------- + + [Test] + public async Task TheThreeActionTemplatesReadWhatTheRuleAlreadyDoes() + { + var sets = Sets(); + + await Assert.That(Field(sets, 0, TriggersScreenRenderer.RewriteField).Get()).IsEqualTo("» $1: $2"); + await Assert.That(Field(sets, 0, TriggersScreenRenderer.ResponseField).Get()).IsEqualTo("page $1=busy"); + await Assert.That(Field(sets, 0, TriggersScreenRenderer.ScriptField).Get()).IsEqualTo("onTell"); + } + + [Test] + public async Task WritingARewriteRespondOrScript_LandsOnTheRuleAndUndoPutsItBack() + { + var sets = Sets(); + var trigger = sets[0].Triggers[1]; + var edits = new ScreenEdits(); + + await Assert.That(edits.Apply(Field(sets, 1, TriggersScreenRenderer.RewriteField), "[guild] $0")).IsNull(); + await Assert.That(edits.Apply(Field(sets, 1, TriggersScreenRenderer.ResponseField), "gtell hi")).IsNull(); + await Assert.That(edits.Apply(Field(sets, 1, TriggersScreenRenderer.ScriptField), "onGuild")).IsNull(); + + await Assert.That(trigger.Actions.Rewrite).IsEqualTo("[guild] $0"); + await Assert.That(trigger.Actions.SendResponse).IsEqualTo("gtell hi"); + await Assert.That(trigger.Actions.ScriptCallback).IsEqualTo("onGuild"); + + edits.Revert(); + + await Assert.That(trigger.Actions.Rewrite).IsNull(); + await Assert.That(trigger.Actions.SendResponse).IsNull(); + await Assert.That(trigger.Actions.ScriptCallback).IsNull(); + } + + /// + /// Blank means "this rule does not rewrite", and it is stored as null rather than as "" — + /// tests SendResponse and ScriptCallback with + /// IsNullOrEmpty, so an empty string would be a second spelling of "off" living in config, + /// and the two would eventually disagree about which one the screen shows. + /// + [Test] + public async Task ClearingAnActionStoresNullRatherThanAnEmptyString() + { + var sets = Sets(); + var trigger = sets[0].Triggers[0]; + var edits = new ScreenEdits(); + + edits.Apply(Field(sets, 0, TriggersScreenRenderer.RewriteField), string.Empty); + edits.Apply(Field(sets, 0, TriggersScreenRenderer.ResponseField), " "); + edits.Apply(Field(sets, 0, TriggersScreenRenderer.ScriptField), string.Empty); + + await Assert.That(trigger.Actions.Rewrite).IsNull(); + await Assert.That(trigger.Actions.SendResponse).IsNull(); + await Assert.That(trigger.Actions.ScriptCallback).IsNull(); + + edits.Revert(); + await Assert.That(trigger.Actions.Rewrite).IsEqualTo("» $1: $2"); + } + + /// + /// A rewrite becomes one output line and a response becomes one command; a newline inside either + /// would smuggle a second one past the model that counts them. + /// + [Test] + public async Task AnActionCarryingControlCharactersIsRefusedAndWritesNothing() + { + var sets = Sets(); + var trigger = sets[0].Triggers[0]; + + foreach (var ordinal in new[] + { + TriggersScreenRenderer.RewriteField, + TriggersScreenRenderer.ResponseField, + TriggersScreenRenderer.ScriptField, + }) + { + var field = Field(sets, 0, ordinal); + await Assert.That(field.Validate("one\ntwo")).IsNotNull().Because("ordinal " + ordinal); + await Assert.That(new ScreenEdits().Apply(field, "one\ttwo")).IsNotNull().Because("ordinal " + ordinal); + } + + await Assert.That(trigger.Actions.Rewrite).IsEqualTo("» $1: $2"); + await Assert.That(trigger.Actions.SendResponse).IsEqualTo("page $1=busy"); + await Assert.That(trigger.Actions.ScriptCallback).IsEqualTo("onTell"); + } + + /// + /// The script field suggests the callbacks the configuration already names — from triggers, aliases, + /// timers and macros alike — because a name is only useful if the user's own Lua defines it, and + /// what they have already written is the only honest evidence of that. A rewrite and a response have + /// no such vocabulary and so offer nothing for ↑↓ to step through. + /// + [Test] + public async Task TheScriptFieldSuggestsTheCallbacksTheConfigurationAlreadyNames() + { + var sets = Sets(); + + var script = Field(sets, 1, TriggersScreenRenderer.ScriptField); + await Assert.That(script.Choices).IsEquivalentTo(new[] { "onTell", "onGreet", "onTick" }); + + // Suggestions, not a closed list: a callback nothing calls yet is exactly what a new rule names. + await Assert.That(script.Validate("onSomethingNew")).IsNull(); + + await Assert.That(Field(sets, 0, TriggersScreenRenderer.RewriteField).Choices).IsNull(); + await Assert.That(Field(sets, 0, TriggersScreenRenderer.ResponseField).Choices).IsNull(); + } + + /// A configuration that names no callbacks has nothing to suggest, and must not pretend to. + [Test] + public async Task TheScriptFieldOffersNoChoicesWhenNothingNamesACallback() + { + var sets = new List + { + new() + { + Name = "Comms", + Triggers = new List { new() { Name = "Tell", Pattern = "tells you" } }, + }, + }; + + await Assert.That(Field(sets, 0, TriggersScreenRenderer.ScriptField).Choices).IsNull(); + } + + // ---- attributes ------------------------------------------------------------------------------ + + /// + /// is a [Flags] enum — several independent booleans — so the + /// field is a multi-select read and written as a list of names, not a one-of-N choice. It carries no + /// on purpose: ↑↓ step one-of-N, and the ↑↓ choose header + /// hint is derived from that property, so a cycling field here would advertise keys that cannot mean + /// anything. + /// + [Test] + public async Task TheAttributesFieldIsAMultiSelectAndNotACyclingChoice() + { + var sets = Sets(); + var field = Field(sets, 0, TriggersScreenRenderer.AttributesField); + + await Assert.That(field.Get()).IsEqualTo("bold"); + await Assert.That(field.Choices).IsNull(); + await Assert.That(field.Cycle("bold", 1)).IsNull(); + } + + [Test] + public async Task SeveralAttributesAreSetAtOnce_AndNoneClearsThem() + { + var sets = Sets(); + var trigger = sets[0].Triggers[0]; + var edits = new ScreenEdits(); + + await Assert.That(edits.Apply(Field(sets, 0, TriggersScreenRenderer.AttributesField), "bold underline")) + .IsNull(); + await Assert.That(trigger.Actions.AddAttributes) + .IsEqualTo(TextAttributes.Bold | TextAttributes.Underline); + await Assert.That(Field(sets, 0, TriggersScreenRenderer.AttributesField).Get()).IsEqualTo("bold underline"); + + edits.Apply(Field(sets, 0, TriggersScreenRenderer.AttributesField), "none"); + await Assert.That(trigger.Actions.AddAttributes).IsEqualTo(TextAttributes.None); + await Assert.That(Field(sets, 0, TriggersScreenRenderer.AttributesField).Get()).IsEqualTo("none"); + + edits.Revert(); + await Assert.That(trigger.Actions.AddAttributes).IsEqualTo(TextAttributes.Bold); + } + + [Test] + public async Task AnAttributeNameTheEnumDoesNotHaveIsRefusedAndWritesNothing() + { + var sets = Sets(); + var trigger = sets[0].Triggers[0]; + var field = Field(sets, 0, TriggersScreenRenderer.AttributesField); + + await Assert.That(field.Validate("bold sparkly")).IsNotNull(); + await Assert.That(new ScreenEdits().Apply(field, "sparkly")).IsNotNull(); + await Assert.That(trigger.Actions.AddAttributes).IsEqualTo(TextAttributes.Bold); + + // Case and separator liberal: the legend prints them lower-case and space-separated, but nobody + // should be refused for typing them the way they read the enum. + await Assert.That(field.Validate("Bold, Underline | italic")).IsNull(); + } + + /// + /// The legend is the "row of checkboxes" this setting really is. It has to name every attribute — it + /// is the only place the legal words appear — and it has to follow the *buffer* while the field is + /// open, the way F2's route radios do, or typing would look inert until ⏎. + /// + [Test] + public async Task TheAttributeLegendNamesEveryAttributeAndFollowsTheBuffer() + { + var sets = Sets(); + + var resting = TriggersScreenRenderer.EditorColumn(sets, 0, Targets); + foreach (var name in new[] + { + "bold", "faint", "italic", "underline", "blink", "reverse", "conceal", "strikethrough", + }) + { + await Assert.That(resting.Any(l => l.Contains(name, StringComparison.Ordinal))) + .IsTrue() + .Because(name + " is missing from the legend"); + } + + await Assert.That(resting.Any(l => l.Contains("✓bold", StringComparison.Ordinal))).IsTrue(); + await Assert.That(resting.Any(l => l.Contains("✓italic", StringComparison.Ordinal))).IsFalse(); + + // Mid-edit the legend reads the buffer, not config: "italic" lights before anything is written. + var typing = new ScreenFocus( + 0, 0, new ScreenFieldEdit(TriggersScreenRenderer.AttributesField, "italic", 6, null)); + var open = TriggersScreenRenderer.EditorColumn(sets, 0, Targets, typing); + + await Assert.That(open.Any(l => l.Contains("✓italic", StringComparison.Ordinal))).IsTrue(); + await Assert.That(open.Any(l => l.Contains("✓bold", StringComparison.Ordinal))).IsFalse(); + await Assert.That(sets[0].Triggers[0].Actions.AddAttributes).IsEqualTo(TextAttributes.Bold); + } + + /// + /// The section caption reports whether a matching line is restyled at all. It used to read the two + /// colours only, so a rule that merely bolded its match was captioned "left alone" while visibly + /// bolding every line it matched — the engine restyles on a colour *or* an attribute. + /// + [Test] + public async Task TheHighlightCaptionCountsAttributesAndNotOnlyColours() + { + var sets = Sets(); + + var bolded = TriggersScreenRenderer.EditorColumn(sets, 0, Targets) + .Single(l => l.Contains("highlight", StringComparison.Ordinal)); + await Assert.That(bolded).Contains("restyled"); + await Assert.That(bolded).DoesNotContain("left alone"); + + var plain = TriggersScreenRenderer.EditorColumn(sets, 1, Targets) + .Single(l => l.Contains("highlight", StringComparison.Ordinal)); + await Assert.That(plain).Contains("left alone"); + } + + // ---- how the pane draws them ----------------------------------------------------------------- + + /// + /// An unset action reads (off) rather than as an empty gap, and keeps its field well: the row + /// is still a place a value goes, and the well is how these screens say so (see + /// for the other half of that rule). + /// + [Test] + public async Task AnUnsetActionSaysSoInItsOwnWell() + { + var sets = Sets(); + var well = "on " + ScreenPalette.FieldBg; + + var configured = TriggersScreenRenderer.EditorColumn(sets, 0, Targets) + .Single(l => l.Contains("respond", StringComparison.Ordinal)); + await Assert.That(configured).Contains("page $1=busy"); + await Assert.That(configured).Contains(well); + + var unset = TriggersScreenRenderer.EditorColumn(sets, 1, Targets) + .Single(l => l.Contains("respond", StringComparison.Ordinal)); + await Assert.That(unset).Contains("(off)"); + await Assert.That(unset).Contains(well); + } + + /// + /// Every new field's buffer is drawn where that field's value already lives, and nowhere else — the + /// same promise makes for the name and the pattern. + /// + [Test] + public async Task EachNewFieldDrawsItsBufferOnItsOwnRow() + { + var caret = $"[{ScreenPalette.Ink} on {ScreenPalette.Accent}]"; + var sets = Sets(); + + foreach (var (ordinal, label, typed) in new[] + { + (TriggersScreenRenderer.AttributesField, "attrs", "underline"), + (TriggersScreenRenderer.RewriteField, "rewrite", "«$1»"), + (TriggersScreenRenderer.ResponseField, "respond", "say ok"), + (TriggersScreenRenderer.ScriptField, "script", "onWhisper"), + }) + { + var lines = TriggersScreenRenderer.EditorColumn( + sets, 0, Targets, new ScreenFocus(0, 0, new ScreenFieldEdit(ordinal, typed, typed.Length, null))); + + var carried = lines.Where(l => l.Contains(caret, StringComparison.Ordinal)).ToList(); + await Assert.That(carried).HasSingleItem().Because(label); + await Assert.That(carried[0]).Contains(label); + } + } + + /// + /// The rule list's flag strip has to name every action, or the list is a summary that quietly omits + /// half of what a rule does. Attributes fold into H because they are highlighting — the engine + /// restyles through one path — and a rewrite gets its own mark. + /// + [Test] + public async Task TheRuleListFlagsNameTheRewriteResponseScriptAndAttributes() + { + var sets = Sets(); + var rules = TriggersScreenRenderer.RulesColumn(sets, 0); + + var row = rules.FindIndex(l => l.Contains("[bold]Tell[/]", StringComparison.Ordinal)); + var flags = rules[row + 1]; + + await Assert.That(flags).Contains('H'); // AddAttributes alone, with no colour set + await Assert.That(flags).Contains('✎'); // rewrite + await Assert.That(flags).Contains('R'); // response + await Assert.That(flags).Contains('ƒ'); // script + + var quiet = rules.FindIndex(l => l.Contains("[bold]Spam[/]", StringComparison.Ordinal)); + await Assert.That(rules[quiet + 1]).Contains('—'); + } + + // ---- case sensitivity ------------------------------------------------------------------------ + + /// + /// The checkbox is appended after gag and stop-processing, so the two rows the screen already + /// navigated by keep their ordinals; and flipping it must drop the compiled matcher, because the + /// casing is baked into that regex's options. This is the F2 half of the guarantee + /// ConfigurationTests.AliasCaseSensitivity_IsSettableAndDropsTheCachedRegex makes for F3. + /// + [Test] + public async Task TheCaseSensitiveCheckboxWritesTheRuleAndInvalidatesItsMatcher() + { + var sets = Sets(); + var trigger = sets[0].Triggers[0]; + var edits = new ScreenEdits(); + + await Assert.That(trigger.Regex.IsMatch("SOMEONE TELLS YOU hi")).IsTrue(); + + var toggle = TriggersScreenRenderer.Model(sets, 0, Targets).ToggleAt(1, 2)!.Value; + edits.Apply(toggle); + + await Assert.That(trigger.CaseSensitive).IsTrue(); + await Assert.That(trigger.Regex.IsMatch("SOMEONE TELLS YOU hi")).IsFalse(); + await Assert.That(trigger.Regex.IsMatch("someone tells you hi")).IsTrue(); + + edits.Revert(); + + await Assert.That(trigger.CaseSensitive).IsFalse(); + await Assert.That(trigger.Regex.IsMatch("SOMEONE TELLS YOU hi")).IsTrue(); + } + + /// The same thing through the real keyboard: Space on the editor pane's third row. + [Test] + public async Task SpaceOnTheThirdEditorRowFlipsCaseSensitivity() + { + var sets = Sets(); + var session = new SettingsSession( + selection => TriggersScreenRenderer.Model(sets, selection.SelectionIn(0), Targets)); + + session.Handle(Key(ConsoleKey.Tab)); // into the editor pane + session.Handle(Key(ConsoleKey.DownArrow)); // gag → stop processing + session.Handle(Key(ConsoleKey.DownArrow)); // stop processing → case sensitive + session.Handle(Key(ConsoleKey.Spacebar)); + + await Assert.That(sets[0].Triggers[0].CaseSensitive).IsTrue(); + await Assert.That(sets[0].Triggers[0].Actions.Gag).IsFalse(); + await Assert.That(sets[0].Triggers[0].StopProcessing).IsFalse(); + + var editor = TriggersScreenRenderer.EditorColumn(sets, 0, Targets, session.Focus()); + await Assert.That(editor.Any(l => l.Contains("[[x]]") && l.Contains("case sensitive"))).IsTrue(); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs b/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs index eb913f61..161cf121 100644 --- a/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs @@ -48,17 +48,23 @@ public async Task ARuleRowCarriesItsPatternRouteAndBothHighlightColours() var sets = Sets(); var model = TriggersScreenRenderer.Model(sets, 0, Targets); - // The name leads, then the four values the editor pane draws. - await Assert.That(model.RowAt(0, 0).FieldCount).IsEqualTo(5); + // The name leads, then everything the editor pane draws. The first five ordinals are unchanged + // — the four new ones are appended, so nothing the screen, the snapshot keys or these tests + // already address is renumbered. + await Assert.That(model.RowAt(0, 0).FieldCount).IsEqualTo(9); await Assert.That(model.FieldAt(0, 0, TriggersScreenRenderer.NameField)!.Value.Get()).IsEqualTo("Tell"); await Assert.That(model.FieldAt(0, 0, TriggersScreenRenderer.PatternField)!.Value.Get()).IsEqualTo("tells you"); await Assert.That(model.FieldAt(0, 0, TriggersScreenRenderer.RouteField)!.Value.Get()).IsEqualTo("Chat"); await Assert.That(model.FieldAt(0, 0, TriggersScreenRenderer.ForegroundField)!.Value.Get()).IsEqualTo("gold"); await Assert.That(model.FieldAt(0, 0, TriggersScreenRenderer.BackgroundField)!.Value.Get()).IsEqualTo("none"); - - // The editor pane keeps exactly the two checkbox rows it had — the route, the colours and the - // name are one setting each, so they are fields on the rule, not new cursor stops. - await Assert.That(model.Sizes[1]).IsEqualTo(2); + await Assert.That(model.FieldAt(0, 0, TriggersScreenRenderer.AttributesField)!.Value.Get()).IsEqualTo("none"); + await Assert.That(model.FieldAt(0, 0, TriggersScreenRenderer.RewriteField)!.Value.Get()).IsEqualTo(string.Empty); + await Assert.That(model.FieldAt(0, 0, TriggersScreenRenderer.ResponseField)!.Value.Get()).IsEqualTo(string.Empty); + await Assert.That(model.FieldAt(0, 0, TriggersScreenRenderer.ScriptField)!.Value.Get()).IsEqualTo(string.Empty); + + // The editor pane holds only checkbox rows — every value it draws is a field on the rule, not a + // cursor stop of its own. It gained the third checkbox (case sensitivity) and nothing else. + await Assert.That(model.Sizes[1]).IsEqualTo(3); } [Test] @@ -159,11 +165,11 @@ public async Task TypingARouteThatMatchesNoKnownWindowStillShowsWhatIsBeingTyped } /// - /// ↑↓ steps the radio group, and the drawn radios follow the buffer — a group that only moved on - /// ⏎ would look inert for exactly as long as the user was using it. + /// ↑↓ step the windows already in use, and the drawn route follows the buffer — a value that only + /// moved on ⏎ would look inert for exactly as long as the user was using it. /// [Test] - public async Task UpAndDownStepTheRouteRadios_AndTheDrawnDotFollowsTheBuffer() + public async Task UpAndDownStepTheKnownWindows_AndTheDrawnRouteFollowsTheBuffer() { var sets = Sets(); var trigger = sets[0].Triggers[0]; @@ -179,11 +185,11 @@ public async Task UpAndDownStepTheRouteRadios_AndTheDrawnDotFollowsTheBuffer() session.Handle(Key(ConsoleKey.DownArrow)); await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("pages"); - // Nothing is written yet, but the radios already show where ⏎ would land. + // Nothing is written yet, but the drawn route already shows where ⏎ would land. await Assert.That(trigger.Actions.SpawnTarget).IsEqualTo("Chat"); var editor = TriggersScreenRenderer.EditorColumn(sets, 0, Targets, session.Focus()); - await Assert.That(editor.Any(l => l.Contains('●') && l.Contains("pages"))).IsTrue(); - await Assert.That(editor.Any(l => l.Contains('●') && l.Contains("Chat"))).IsFalse(); + await Assert.That(editor.Any(l => l.Contains("pages"))).IsTrue(); + await Assert.That(editor.Any(l => l.Contains("Chat"))).IsFalse(); session.Handle(Key(ConsoleKey.Enter)); await Assert.That(trigger.Actions.SpawnTarget).IsEqualTo("pages"); diff --git a/tests/SharpMUTerm.Tui.Tests/TriggersScreenRendererTests.cs b/tests/SharpMUTerm.Tui.Tests/TriggersScreenRendererTests.cs index bb764f19..1eda9a30 100644 --- a/tests/SharpMUTerm.Tui.Tests/TriggersScreenRendererTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/TriggersScreenRendererTests.cs @@ -80,21 +80,20 @@ public async Task Render_FlagsSummariseGagHighlightAndSpawn() } [Test] - public async Task Render_SelectedTriggerEditorShowsPatternAndRouteList() + public async Task Render_SelectedTriggerEditorShowsPatternAndRoute() { var lines = TriggersScreenRenderer.Render(Scene(), selectedTrigger: 0, spawnTargets: new[] { "Chat", "Combat log" }); await Assert.That(lines.Any(l => l.Contains("match pattern"))).IsTrue(); await Assert.That(lines.Any(l => l.Contains(@"^(\w+) tells you"))).IsTrue(); + // The route is the window's name, drawn as an editable value like every other row here — the + // windows already in use are ↑↓ suggestions while it is open, not a fixed set of rows. await Assert.That(lines.Any(l => l.Contains("route to"))).IsTrue(); + await Assert.That(lines.Any(l => l.Contains("Chat"))).IsTrue(); - // Current route (Chat) is marked with the accent dot; "main" and "Combat log" are hollow. - var chatRow = lines.Single(l => l.Contains("●") && l.Contains("Chat") && !l.Contains("Combat log")); - await Assert.That(chatRow).Contains("#00f5b7"); - - var mainRow = lines.Single(l => l.EndsWith("main", StringComparison.Ordinal)); - await Assert.That(mainRow).Contains("○"); + // The windows this rule does not point at are suggestions, so they are not drawn at rest. + await Assert.That(lines.Any(l => l.Contains("Combat log"))).IsFalse(); } [Test] diff --git a/tools/make-screenshots.sh b/tools/make-screenshots.sh index 0e3dbaf1..2c4700f4 100755 --- a/tools/make-screenshots.sh +++ b/tools/make-screenshots.sh @@ -20,7 +20,9 @@ DLL="$ROOT/src/SharpMUTerm.Tui/bin/Release/net10.0/sharpmuterm.dll" render() { local name="$1" size="$2" echo "Rendering $name ($size)…" - dotnet "$DLL" --snapshot --size "$size" --out "$OUT/$name.ansi" + # --demo-config: these are the published demo images, so they must not depend on whatever + # worlds happen to be configured on the machine rendering them. + dotnet "$DLL" --snapshot --demo-config --size "$size" --out "$OUT/$name.ansi" python3 "$ROOT/tools/ansi_frame_to_image.py" "$OUT/$name.ansi" "$OUT/$name.svg" python3 "$ROOT/tools/ansi_frame_to_image.py" "$OUT/$name.ansi" "$OUT/$name.html" } From 06a385be7ff992f1f9aec53203954aa5ea3ebbcb Mon Sep 17 00:00:00 2001 From: Harry Cordewener Date: Tue, 28 Jul 2026 21:05:53 -0500 Subject: [PATCH 16/23] F5: own the character's logging and the world's TLS flags Two fixes from the design review, both about F5 holding settings that were misplaced elsewhere or not reachable at all. F9 edited one specific character's logging and never said which: ActiveLogging() resolved the active character or else the first one configured, so the same screen changed a different character's log depending on what happened to be connected. Log format and folder are now fields on the character's own row, drawn in the CHARACTER form under the heading that names them, with the row itself saying "this character only". F9 still opens -- it seeds F5 on the character pane rather than being a second surface to keep in sync, so the key keeps working without duplicating a screen. HeaderLine takes the key it was opened with, since a header hard-coded to F5 would name a key that reopens rather than closes an F9-opened screen. ActiveLogging()'s fallback also made a disconnected client show the first character's LOG html in the status bar; it now reports off. The security row was a read-only summary of two booleans with no UI. They are now real checkboxes in a fourth pane, appended rather than inserted beside the world they describe, because a pane index is a cursor coordinate and inserting one renumbers every stop the screen and its tests navigate by. "accept invalid certificates" is drawn in the warning colour, with the marker a refused value gets, only while it is both checked and encrypting -- and it names the consequence rather than restating the label. A warning that also fired on an unencrypted connection would train the eye to skip the one case that matters. 929 tests pass, up from 912. Eight pinned assertions changed, each reported and each strengthened rather than renumbered: the pane-shape ones now assert ListSizes alongside the new totals. Five tests covering the deleted F9 options screen were migrated to F5, not dropped. Known limitation: at 100x24 F5 is over-full and the character table clips. The edit band already crowded that column; this made it two rows worse. Collapsing or scrolling that band is its own piece of work. Co-Authored-By: Claude Opus 5 (1M context) --- docs/HANDOFF.md | 69 +++-- src/SharpMUTerm.Tui/OptionsScreenRenderer.cs | 74 ++--- src/SharpMUTerm.Tui/OptionsScreenView.cs | 2 +- src/SharpMUTerm.Tui/ScreenField.cs | 2 +- src/SharpMUTerm.Tui/ScreenModel.cs | 5 +- src/SharpMUTerm.Tui/ScreenPalette.cs | 7 +- src/SharpMUTerm.Tui/ScreenSelection.cs | 14 + src/SharpMUTerm.Tui/SharpMUTermApp.cs | 94 +++--- src/SharpMUTerm.Tui/WorldsScreenRenderer.cs | 273 +++++++++++++++--- src/SharpMUTerm.Tui/WorldsScreenView.cs | 5 +- .../OptionsScreenRendererTests.cs | 30 +- .../ScreenButtonTests.cs | 9 +- .../ScreenCursorTests.cs | 33 ++- .../ScreenFieldRenderingTests.cs | 43 ++- .../ScreenFooterTests.cs | 8 +- .../SharpMUTerm.Tui.Tests/ScreenModelTests.cs | 150 ++++++++-- .../SharpMUTerm.Tui.Tests/ScreenNameTests.cs | 31 +- .../ScreenReadOnlyTests.cs | 91 +++++- .../ScreenSelectionTests.cs | 44 +++ .../SettingsScreenViewTests.cs | 105 +++++++ .../SettingsSessionEditTests.cs | 81 ++++++ .../WorldsScreenRendererTests.cs | 75 +++++ 22 files changed, 993 insertions(+), 252 deletions(-) create mode 100644 tests/SharpMUTerm.Tui.Tests/SettingsScreenViewTests.cs diff --git a/docs/HANDOFF.md b/docs/HANDOFF.md index 52cf6354..c733f6f6 100644 --- a/docs/HANDOFF.md +++ b/docs/HANDOFF.md @@ -27,7 +27,8 @@ works. F3; `[+ timer]` / `[- del]` on F6; `[+ binding] Num` / `[- del]` on F4. All are `ScreenRow`s carrying a `ScreenButton`; ⏎ runs one, and Delete on a list row runs that pane's remove button. The button rows changed pinned row counts in - `ScreenModelTests`, twice: F5's (`{2,2,1}` → `{4,5,1}` and `{2,0,0}` → `{4,1,0}`), + `ScreenModelTests`, twice: F5's (`{2,2,1}` → `{4,5,1}` and `{2,0,0}` → `{4,1,0}`; + the security pane later appended a fourth entry to both), then F2/F3/F6's when they grew the same buttons (`Sizes[0]` 2 → 5, `{1,1}` → `{4,1}`, `{1,2}` → `{3,2}`). The second round asserts `ListSizes` *as well*, so the original pinned meaning ("this pane holds two rules") is still asserted and @@ -67,10 +68,27 @@ works. `AutomationCloneTests.RenamingLeavesTheCompiledMatcherAlone` pins. - **Rows still not editable** (deliberately): a macro's *key* (rebinding needs a key-capture mode, not a text buffer), a character's password (it is - `[JsonIgnore]` and belongs in a credential store), a world's TLS/certificate - "security" line (two booleans, so checkboxes, not a field), and everything - derived (the numpad grid, the session/state readouts). **All of them now say - so on screen** — see *Editable vs read-only rows* under Critical Gotchas. + `[JsonIgnore]` and belongs in a credential store), and everything derived (the + numpad grid, the session/state readouts). **All of them now say so on screen** — + see *Editable vs read-only rows* under Critical Gotchas. +- **A world's TLS and certificate flags are live**, as the two checkboxes of F5's + fourth pane, drawn where the read-only `security TLS on · certs strict` line + used to be. Two booleans is two checkboxes and a `ScreenRow` carries one, so it + is two rows — and rows need a pane, which is the one thing on this screen that + could not hang off an existing row. The pane is **appended** (index 3) rather + than slotted in beside the world it describes, because a pane index is a cursor + coordinate and inserting one renumbers every stop the screen and its tests + navigate by. `accept invalid certificates` is drawn in `ScreenPalette.Warn` with + the `▲` a refused value gets **while it is both checked and encrypting**, and + plainly otherwise — see *A row that switches off a check* under Critical Gotchas. +- **Logging moved from F9 onto F5, per character.** `LoggingSettings` hangs off + `CharacterDefinition`, but F9 resolved "the active character, or else the first + one configured" and never said which — so the same screen edited a different + character's log depending on what was connected. The log format and folder are + now fields 2 and 3 of the **character's own row**, drawn in the CHARACTER form + under a heading that names the character. **F9 still works**: it opens F5 on the + character pane (see *Two doors into F5* under Critical Gotchas). The + `logging` / `logging-edit` view names survive and now render that screen. ### 2. Real-terminal verification still owed @@ -303,7 +321,7 @@ What the framework actually provides (read at v2.5.14, not assumed): (`HeaderLine`, `FooterLine`, body columns) plus a **`*ScreenView`** that composes them into controls. The renderer's `Render(...)` merges the same blocks back into one line list — **the unit tests go through it**, so keep it. -- F7/F8/F9 share `OptionsScreenRenderer`/`OptionsScreenView`, which take an +- F7/F8 share `OptionsScreenRenderer`/`OptionsScreenView`, which take an `OptionsScreen` (title + F-key + rows): those screens are a single options list, so their body is one full-width elevated card rather than a column split. - Shared chrome lives in `ScreenPalette` (colours), `ScreenChrome` (hint/action @@ -378,16 +396,31 @@ What the framework actually provides (read at v2.5.14, not assumed): through `ReadOnly`, or the well/no-well counts stop matching. - **A derived indicator is never a checkbox.** A checkbox promises Space does something. F2's highlight summary is a **caption on the `highlight` section** - (above the two swatch rows it derives from, not below them); F9's auto-start is - now the `format` row's *own* toggle — one row, one stored value, Space for - on/off and ⏎ for which format — rather than a second row mirroring the first. - `OptionRow` carrying both a `Bind` and an `Edit` is what makes that one row. + (above the two swatch rows it derives from, not below them). F5's `security` + line was the other way round — a summary of two booleans that had no UI at all — + and is now the two checkboxes themselves. +- **A row that switches off a check gets said out loud.** `accept invalid + certificates` is the only setting on these screens that can disable a check the + user is entitled to assume is running, so while it is checked *and* TLS is on it + is drawn in `ScreenPalette.Warn` with the `▲` a refused value gets and names the + consequence (`anyone can impersonate this host`) rather than restating its label. + With TLS off it is quiet whatever it holds and says `no effect until TLS is on`: + a warning that fired on an unencrypted connection would train the eye to skip the + one that matters. Two shouting cases in the whole palette, and no more. +- **Two doors into F5.** F5 opens it on the connected world/character; **F9** opens + the same screen with focus on the character pane, where the log settings it used + to own now live. It is a seeding difference and nothing else — same renderer, + same session, same undo log — so there is no second surface to keep in step. + `HeaderLine` therefore takes the **F-key it was opened with**: a header that + always said `F5` would name a key which, pressed on the F9-opened screen, + re-opens it (`SettingsOverlay.Toggle` treats a different key as "reopen") instead + of closing it. `SettingsScreenViewTests` renders both doors and pins this. - **Footer context lines all answer "where is the cursor".** `ScreenChrome.Position`/`Context` build them: ` i/n`, then whatever identifies the selection (`set Comms`, `character 1/2`, the option's section, - the binding's name). F4 and F7–F9 used to report an inventory instead + the binding's name). F4 and F7/F8 used to report an inventory instead (`9 bindings · 8 of 9 numpad keys bound`, `3 options · 1 section`). -- **There is no `‹ back`.** F7/F8/F9 drew one; nothing else did, and there is no +- **There is no `‹ back`.** F7/F8 (and the retired F9) drew one; nothing else did, and there is no navigation stack behind a settings screen — Esc closes it. - **Header hints are derived, not written.** `HeaderLine(width, model, focus)` reads `model.HasEditableRow`, so a screen physically cannot advertise `⏎ edit` @@ -436,11 +469,11 @@ What the framework actually provides (read at v2.5.14, not assumed): its key pump inside `Run()`, which a snapshot never enters. - **Screens edit config in place.** Cloning `AppConfiguration` would drop `[JsonIgnore]` fields like a character's in-memory password, so Esc is a replayed - undo. A toggle's snapshot captures the **value**, not the boolean — F9's - "auto-start" is really a `LogFormat`, and cancelling must put `Html` back, not - `Plain`. -- Pane shape: F4/F7/F8/F9 are single-pane (no ⇥); F5 has three panes; the rest have - two. + undo. A toggle's snapshot captures the **value**, not the boolean — F5's + trigger-set assignment is really a position in a list, and cancelling must put + that whole list back, not merely "assigned". +- Pane shape: F4/F7/F8 are single-pane (no ⇥); **F5 has four** (worlds → characters + → trigger sets → the world's security checkboxes); the rest have two. ### TelnetNegotiationCore @@ -479,7 +512,7 @@ What the framework actually provides (read at v2.5.14, not assumed): | `src/SharpMUTerm.Tui/SharpMUTermApp.cs` | Central app: header/status/input bands, `SyncInputWidth`, `PromptMarkup`, pane fill, `SettingsScreens()`, `OnDriverMouseEvent`/`PaneSnapshot`, snapshot views | | `src/SharpMUTerm.Tui/WorldsScreenRenderer.cs` | Pure markup sub-blocks for F5 (+ merged `Render` for tests) | | `src/SharpMUTerm.Tui/WorldsScreenView.cs` | Composes F5 sub-blocks into real control panels | -| `src/SharpMUTerm.Tui/OptionsScreenRenderer.cs`, `OptionsScreenView.cs` | The shared single-list screen behind F7/F8/F9 | +| `src/SharpMUTerm.Tui/OptionsScreenRenderer.cs`, `OptionsScreenView.cs` | The shared single-list screen behind F7/F8 | | `src/SharpMUTerm.Tui/ScreenPalette.cs`, `ScreenChrome.cs`, `MarkupText.cs` | Shared screen chrome: colours, hint/action fragments and bands, markup width/padding helpers | | `src/SharpMUTerm.Tui/SettingsOverlay.cs` | Frameless full-screen overlay; routes keys to the screen's session and rebuilds its content | | `src/SharpMUTerm.Tui/SettingsSession.cs` | Key → action for an open settings screen (the whole interaction contract, testable) | diff --git a/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs b/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs index 27249702..3746ab40 100644 --- a/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs @@ -5,13 +5,19 @@ namespace SharpMUTerm.Tui; /// -/// Produces the markup sub-blocks shared by the F7 (Text & ANSI), F8 (Input & spellcheck), and -/// F9 (Logging) screens — the header band, the options list (toggle/value rows grouped under dim -/// section headers), and the footer action bar. The three screens differ only in their title, F-key, -/// and rows, so the blocks take an rather than being written per screen. +/// Produces the markup sub-blocks shared by the F7 (Text & ANSI) and F8 (Input & spellcheck) +/// screens — the header band, the options list (toggle/value rows grouped under dim section headers), +/// and the footer action bar. The two screens differ only in their title, F-key, and rows, so the +/// blocks take an rather than being written per screen. /// composes them into a real panel for the live/snapshot view; /// merges the same blocks into a single /// line list for the unit tests. Pure so every block is testable. +/// +/// F9 was a third one, "Logging", and is gone: its rows edited one character's +/// — whichever was connected, or else the first configured — while +/// presenting as a global preference. Logging now sits in the character's own form on F5, and F9 opens +/// that screen there. See . +/// /// internal static class OptionsScreenRenderer { @@ -31,11 +37,10 @@ internal static class OptionsScreenRenderer /// config the value writes to, which is what makes a value row activatable with ⏎. A row with /// neither still takes the cursor but nothing happens there. /// - /// A row carrying both is F9's log format: Space starts and stops logging, ⏎ picks the format it - /// writes. They were two rows — a format value and an auto-start on connect checkbox - /// whose state was simply format != None — which is two controls over one stored value, and - /// nothing on screen said they were the same setting. The keypad's bindings are the same shape - /// (Space enables the macro, ⏎ edits its command), so already supports it. + /// Carrying both is supported and currently unused: F9's log format was the case that needed it + /// (Space started and stopped logging, ⏎ picked the format), and that row now lives on F5 where its + /// character is. F4's bindings are the same shape one layer down — Space enables the macro, ⏎ edits + /// its command — so keeps the capability whether or not this screen uses it. /// /// public readonly record struct OptionRow( @@ -74,9 +79,9 @@ public static List Render(string title, string fkey, IReadOnlyList - /// There is deliberately no ‹ back affordance. These three screens were the only ones that - /// drew one, and it pointed nowhere: there is no navigation stack behind a settings screen, Esc - /// closes it, and the header already says so two columns to the right. + /// There is deliberately no ‹ back affordance. These screens were the only ones that drew + /// one, and it pointed nowhere: there is no navigation stack behind a settings screen, Esc closes + /// it, and the header already says so two columns to the right. /// /// internal static string HeaderLine( @@ -191,7 +196,7 @@ internal static ScreenModel Model(OptionsScreen screen) /// /// One row: its checkbox column (a box, or the blank that keeps the labels in one column), its /// label, the value it holds if it holds one, and its hint. A row can carry both a checkbox and a - /// value, which is how F9 draws one setting as one row. + /// value, which is the shape F4's bindings use one layer down. /// private static string RenderRow(OptionRow row, ScreenFieldEdit? edit) { @@ -296,52 +301,9 @@ internal static OptionsScreen InputSpellcheckScreen(InputSettings? input = null) }); } - /// - /// The F9 "Logging" screen, reflecting a character's . Its two rows - /// are its two settings: the log format — whose checkbox starts and stops logging, because - /// *is* "off" — and where the file goes. - /// - /// The format and the auto-start checkbox used to be separate rows over the same stored value, and - /// nothing said so: setting the format to None silently unchecked a box three lines down. - /// One row, one value, two keys — Space for on/off, ⏎ for which format — leaves nothing derived to - /// keep in sync. - /// - /// - internal static OptionsScreen LoggingScreen(LoggingSettings logging) - { - ArgumentNullException.ThrowIfNull(logging); - - // Off means None, on means whatever format was last chosen (Plain when there isn't one). The - // binding's snapshot restores the *format*, not the boolean, so cancelling a toggle-off puts - // Html back rather than downgrading it to Plain. - var chosen = logging.Format == LogFormat.None ? LogFormat.Plain : logging.Format; - var autoStart = new ScreenToggle( - () => logging.Format != LogFormat.None, - () => logging.Format = logging.Format == LogFormat.None ? chosen : LogFormat.None, - () => - { - var previous = logging.Format; - return () => logging.Format = previous; - }); - - return new OptionsScreen("Logging", "F9", new List - { - new("├ SESSION LOG", null, null), - new("format", logging.Format.ToString(), logging.Format != LogFormat.None, - "auto-start on connect", - autoStart, - ScreenField.Enumeration("format", () => logging.Format, v => logging.Format = v)), - new("directory", logging.Directory ?? "(default)", null, null, null, - ScreenField.Optional("directory", () => logging.Directory, v => logging.Directory = v)), - }); - } - /// The F7 "Text & ANSI" screen body. public static List TextAnsi() => Render(TextAnsiScreen()); /// The F8 "Input & spellcheck" screen body. public static List InputSpellcheck() => Render(InputSpellcheckScreen()); - - /// The F9 "Logging" screen body, reflecting a character's . - public static List Logging(LoggingSettings logging) => Render(LoggingScreen(logging)); } diff --git a/src/SharpMUTerm.Tui/OptionsScreenView.cs b/src/SharpMUTerm.Tui/OptionsScreenView.cs index 3fa55a67..fa419d70 100644 --- a/src/SharpMUTerm.Tui/OptionsScreenView.cs +++ b/src/SharpMUTerm.Tui/OptionsScreenView.cs @@ -6,7 +6,7 @@ namespace SharpMUTerm.Tui; /// -/// Composes an options screen (F7 Text & ANSI, F8 Input & spellcheck, F9 Logging) from real +/// Composes an options screen (F7 Text & ANSI, F8 Input & spellcheck) from real /// panels rather than one merged markup blob: a header band carrying the keyboard hints, the options /// list on a single full-width elevated card, and a Cancel/Save action bar pinned to the last row. /// These screens are one list, not two panes, so there is no column split and no vertical rule — the diff --git a/src/SharpMUTerm.Tui/ScreenField.cs b/src/SharpMUTerm.Tui/ScreenField.cs index b6175f24..8585f5e4 100644 --- a/src/SharpMUTerm.Tui/ScreenField.cs +++ b/src/SharpMUTerm.Tui/ScreenField.cs @@ -422,7 +422,7 @@ internal static ScreenField Colour( ScreenColours.Palette); } - /// An enum value, typed or cycled by name — F9's log format is the canonical case. + /// An enum value, typed or cycled by name — a character's log format is the canonical case. internal static ScreenField Enumeration(string label, Func get, Action set) where TEnum : struct, Enum { diff --git a/src/SharpMUTerm.Tui/ScreenModel.cs b/src/SharpMUTerm.Tui/ScreenModel.cs index 1ce821b2..fd566d04 100644 --- a/src/SharpMUTerm.Tui/ScreenModel.cs +++ b/src/SharpMUTerm.Tui/ScreenModel.cs @@ -3,9 +3,8 @@ namespace SharpMUTerm.Tui; /// /// A checkbox row on a settings screen, bound to the config it shows: how to read the flag, how to /// flip it, and how to put back exactly what was there before. The snapshot exists because not every -/// checkbox is a plain bool property — F9's "auto-start on connect" is really a -/// , and Esc has to restore Html, not -/// merely "on". +/// checkbox is a plain bool property — F5's trigger-set assignment is really a position in a +/// list, and Esc has to restore that whole list, not merely "assigned". /// /// Reads the flag as the renderer draws it. /// Inverts the flag. diff --git a/src/SharpMUTerm.Tui/ScreenPalette.cs b/src/SharpMUTerm.Tui/ScreenPalette.cs index c6aba7cd..17800305 100644 --- a/src/SharpMUTerm.Tui/ScreenPalette.cs +++ b/src/SharpMUTerm.Tui/ScreenPalette.cs @@ -64,6 +64,11 @@ internal static class ScreenPalette /// internal const string FieldBg = "#0a0e18"; - /// A refused value's marker — the one place these screens raise their voice. + /// + /// A refused value's marker, and — the only other place these screens raise their voice — a setting + /// that switches off a check the user would otherwise assume is running: F5's accept invalid + /// certificates, drawn in this while it is both checked and encrypting. Two cases, no more: a + /// palette that shouts at every risky-looking row teaches the eye to skip the colour. + /// internal const string Warn = "#ff6b6b"; } diff --git a/src/SharpMUTerm.Tui/ScreenSelection.cs b/src/SharpMUTerm.Tui/ScreenSelection.cs index 49210a48..7757a254 100644 --- a/src/SharpMUTerm.Tui/ScreenSelection.cs +++ b/src/SharpMUTerm.Tui/ScreenSelection.cs @@ -77,6 +77,20 @@ internal void Seed(int pane, int index) } } + /// + /// Puts the keyboard in a pane before the screen first opens, without moving any cursor — used when + /// the key that opened the screen means "start here" (F9 opens F5 on the character whose log it + /// used to edit). Out-of-range panes are ignored, and an empty pane is corrected by the first + /// , so a seeded focus can never park the cursor somewhere with no rows. + /// + internal void FocusPane(int pane) + { + if (pane >= 0 && pane < _cursors.Length) + { + Pane = pane; + } + } + /// /// Moves the focused pane's cursor by rows, clamped to the pane's /// current size — deliberately not wrapping, so holding ↑ parks on the first row instead of diff --git a/src/SharpMUTerm.Tui/SharpMUTermApp.cs b/src/SharpMUTerm.Tui/SharpMUTermApp.cs index 0d58ce95..84002f83 100644 --- a/src/SharpMUTerm.Tui/SharpMUTermApp.cs +++ b/src/SharpMUTerm.Tui/SharpMUTermApp.cs @@ -867,7 +867,7 @@ private void RefreshStatusBar() new(ConsoleKey.F6, new[] { "timers" }, TimersScreen), new(ConsoleKey.F7, new[] { "textansi" }, TextAnsiScreen), new(ConsoleKey.F8, new[] { "input" }, InputSpellcheckScreen), - new(ConsoleKey.F9, new[] { "logging" }, LoggingScreen), + new(ConsoleKey.F9, new[] { "logging" }, CharacterLoggingScreen), }; /// @@ -948,41 +948,68 @@ private int ActiveCharacterIndex() } /// - /// The logging settings the F9 screen edits: the active character's, falling back to the first - /// configured character so a disconnected screen still edits something that can be saved. Only a - /// config with no characters at all yields a detached default — without a character there is no - /// session to log. + /// The logging settings the status bar reports on: the active character's. With nothing connected + /// there is no session being logged, so the bar reads the defaults (LOG off) rather than some + /// other character's format — the settings themselves are edited on F5, per character, where the + /// character they belong to is on screen. /// private LoggingSettings ActiveLogging() { + if (ActiveCharacterKey() is null) + { + return new LoggingSettings(); + } + var world = _config.Worlds.ElementAtOrDefault(ActiveWorldIndex()); - var character = world?.Characters.ElementAtOrDefault(ActiveCharacterIndex()) - ?? _config.Worlds.SelectMany(w => w.Characters).FirstOrDefault(); - return character?.Logging ?? new LoggingSettings(); + return world?.Characters.ElementAtOrDefault(ActiveCharacterIndex())?.Logging ?? new LoggingSettings(); } /// - /// Opens the F5 Worlds & Characters screen: three panes (worlds → characters → the selected - /// character's trigger sets), seeded on whatever is connected so the screen opens where the user - /// already is. + /// Opens the F5 Worlds & Characters screen: four panes (worlds → characters → the selected + /// character's trigger sets → the selected world's security checkboxes), seeded on whatever is + /// connected so the screen opens where the user already is. + /// + private ScreenBinding WorldsScreen() => WorldsScreen(WorldsScreenRenderer.FKey, onCharacters: false); + + /// + /// F9 opens the same screen, focused on the character pane. Logging is per character and now lives + /// in that character's form, so the key that used to open a Logging screen of its own is kept as a + /// second door into where the setting moved rather than retired: an F-key is muscle memory, and one + /// that had quietly stopped doing anything would be worse than the screen it replaced. + /// + /// It is a seeding difference and nothing more — the same renderer, the same session shape, the same + /// undo log — so there is no second surface to keep in step. The header is told which key opened it, + /// so the screen offers F9 to close what F9 opened. + /// /// - private ScreenBinding WorldsScreen() + private ScreenBinding CharacterLoggingScreen() => + WorldsScreen(WorldsScreenRenderer.LogFKey, onCharacters: true); + + private ScreenBinding WorldsScreen(string fkey, bool onCharacters) { - // SelectionIn, not CursorIn: both panes end in their own buttons, and the cursor has to leave - // the list to press one. The *selection* is what the detail column and the delete buttons are - // about, and it stays on the row the user was looking at. + // SelectionIn, not CursorIn: both list panes end in their own buttons, and the cursor has to + // leave the list to press one. The *selection* is what the detail column and the delete buttons + // are about, and it stays on the row the user was looking at. var session = new SettingsSession(selection => WorldsScreenRenderer.Model( - _config.Worlds, _config.TriggerSets, selection.SelectionIn(0), selection.SelectionIn(1))); - session.Selection.Seed(0, ActiveWorldIndex()); - session.Selection.Seed(1, ActiveCharacterIndex()); + _config.Worlds, + _config.TriggerSets, + selection.SelectionIn(WorldsScreenRenderer.WorldsPane), + selection.SelectionIn(WorldsScreenRenderer.CharactersPane))); + session.Selection.Seed(WorldsScreenRenderer.WorldsPane, ActiveWorldIndex()); + session.Selection.Seed(WorldsScreenRenderer.CharactersPane, ActiveCharacterIndex()); + if (onCharacters) + { + session.Selection.FocusPane(WorldsScreenRenderer.CharactersPane); + } return new ScreenBinding(session, () => WorldsScreenView.Build( _config.Worlds, _config.TriggerSets, - session.Selection.SelectionIn(0), - session.Selection.SelectionIn(1), + session.Selection.SelectionIn(WorldsScreenRenderer.WorldsPane), + session.Selection.SelectionIn(WorldsScreenRenderer.CharactersPane), _system.DesktopDimensions.Width, - session.Focus())); + session.Focus(), + fkey)); } /// @@ -1051,18 +1078,7 @@ private ScreenBinding InputSpellcheckScreen() => OptionsScreen(() => OptionsScreenRenderer.InputSpellcheckScreen(_config.Input)); /// - /// Opens the F9 Logging screen, bound to the active character's logging settings. The settings - /// object is resolved once, when the screen opens: re-resolving it per keystroke would let the - /// screen edit one character's log and then save another's if the active session changed underneath. - /// - private ScreenBinding LoggingScreen() - { - var logging = ActiveLogging(); - return OptionsScreen(() => OptionsScreenRenderer.LoggingScreen(logging)); - } - - /// - /// The shared open path for the single-list option screens (F7/F8/F9). is + /// The shared open path for the single-list option screens (F7/F8). is /// re-projected from config on every key, so a flipped checkbox shows up in both the row it lives /// on and the model the next keystroke navigates. /// @@ -1083,12 +1099,22 @@ private ScreenBinding OptionsScreen(Func sc /// because a still frame should land on the thing that screen's editing actually added: F5 rewrites /// a host's suffix ("no way to change a host" is the gap the whole mode closes), and F2 steps on to /// its route group and moves the dot, which is the only way to see that a radio list is live rather - /// than a report. + /// than a report. The logging view opens F5 on the character pane, so it steps twice more to + /// reach the log format — past the name and the on-connect line — because the character's log is + /// the whole reason that view exists. /// private static IEnumerable EditSnapshotKeys(string view) { yield return Stroke('\r', ConsoleKey.Enter); + if (string.Equals(view, "logging", StringComparison.OrdinalIgnoreCase)) + { + // name → on connect → log: the character row's fields, in order. + yield return Stroke('\t', ConsoleKey.Tab); + yield return Stroke('\t', ConsoleKey.Tab); + yield break; + } + if (string.Equals(view, "triggers", StringComparison.OrdinalIgnoreCase)) { // name → pattern → route: two steps, because the name now leads the row's fields. diff --git a/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs b/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs index 0635609f..378c7541 100644 --- a/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs @@ -20,10 +20,64 @@ internal static class WorldsScreenRenderer private const int CharLabelWidth = 10; private const int CharDetailColumnWidth = 40; - /// How wide the cursor bar runs across a character row — the row's own column header. - private const int CharacterRowWidth = 62; + /// + /// How wide the cursor bar runs across a row of the detail column — a character row, or one of the + /// world's security checkboxes. A row longer than this keeps its own width (the bar is padding, not + /// a clip), which is how the certificate warning can run past the column the rest of them share. + /// + private const int DetailRowWidth = 62; private const string DividerGlyph = " │ "; + /// + /// The screen's panes, in ⇥ order. Named rather than written as literals because the renderer, the + /// model, the app's seeding and the tests all address the same numbers. + /// + internal const int WorldsPane = 0; + + internal const int CharactersPane = 1; + + internal const int TriggerSetsPane = 2; + + /// + /// The selected world's security checkboxes. Appended rather than inserted after the WORLDS list it + /// belongs to: a pane index is a cursor coordinate, and renumbering the two panes below it would + /// move every stop the screen (and its tests) already navigate by — the same rule that keeps a + /// value's editor hanging off an existing row instead of a new one. + /// + internal const int SecurityPane = 3; + + /// + /// The WORLDS-list row's field ordinals, in the order ⇥ steps through them, and the ordinals the + /// detail column draws an open edit's caret at. Named constants rather than literals, because a + /// field inserted anywhere but the end would otherwise silently draw the caret on the wrong row. + /// + internal const int WorldNameField = 0; + + internal const int HostField = 1; + + internal const int PortField = 2; + + internal const int EncodingField = 3; + + internal const int KeepaliveField = 4; + + /// + /// The character row's field ordinals. The name leads, as it does on every list screen; the two log + /// fields are appended after the on-connect line, and are drawn in the character form below. + /// + internal const int CharacterNameField = 0; + + internal const int OnConnectField = 1; + + internal const int LogFormatField = 2; + + internal const int LogDirectoryField = 3; + + /// The F-key that opens this screen, and the second key that opens it on a character's log. + internal const string FKey = "F5"; + + internal const string LogFKey = "F9"; + /// /// Which item of a list a pane's cursor has selected. The cursor also visits the pane's button /// rows, which sit past the end of the list, and a cursor parked on [[+ world]] must not @@ -118,11 +172,18 @@ internal static bool HasCharacter(IReadOnlyList worlds, int sel /// hints are derived from and rather than /// written here, so the header cannot advertise an edit the screen doesn't offer. /// - internal static string HeaderLine(int width, ScreenModel? model = null, ScreenFocus? focus = null) + /// + /// The key that opened the screen, which is the key the header offers to close it with. It is a + /// parameter rather than a constant because this screen has two doors: F5, and F9 straight onto the + /// selected character's log. A header that always said F5 would name a key that, pressed from + /// an F9-opened screen, re-opens it somewhere else instead of closing it. + /// + internal static string HeaderLine( + int width, ScreenModel? model = null, ScreenFocus? focus = null, string fkey = FKey) { var title = $"[bold {Value}] Worlds & Characters[/]"; var hints = ScreenChrome.Hints( - ScreenChrome.ListHints, "F5", model?.HasEditableRow ?? false, focus, model?.HasRemovableRow ?? false); + ScreenChrome.ListHints, fkey, model?.HasEditableRow ?? false, focus, model?.HasRemovableRow ?? false); return SpreadLR(" " + title, hints, width); } @@ -143,16 +204,27 @@ internal static string HeaderLine(int width, ScreenModel? model = null, ScreenFo internal const string RemoveCharacterLabel = "- remove"; /// - /// The screen's three navigable panes, in ⇥ order: the WORLDS list (no checkbox on a world's row, + /// The screen's four navigable panes, in ⇥ order: the WORLDS list (no checkbox on a world's row, /// but ⏎ opens the world's own fields — the ones the detail column lists), the selected world's - /// characters (Space flips auto-login, ⏎ edits the character's name and on-connect line), and the - /// selected character's assigned trigger sets (Space assigns/unassigns). The last two collapse to - /// empty when there is nothing selected above them, and ⇥ skips empty panes, so the cursor never - /// lands somewhere with no rows. + /// characters (Space flips auto-login, ⏎ edits the character's name, on-connect line and log), the + /// selected character's assigned trigger sets (Space assigns/unassigns), and the selected world's + /// two security checkboxes. All but the first collapse to empty when there is nothing selected above + /// them, and ⇥ skips empty panes, so the cursor never lands somewhere with no rows. + /// + /// A world's *typed* values hang off its list row rather than becoming a pane of their own: the + /// detail column is a projection of whatever the WORLDS list has selected, so those values already + /// belong to that row. Its two booleans cannot — a row carries at most one checkbox, and there are + /// two of them — so they are the one thing on this screen that needs a pane, and it is appended + /// (see ) rather than slotted in beside the world it describes. + /// /// - /// A world's fields hang off its list row rather than becoming a pane of their own: the detail - /// column is a projection of whatever the WORLDS list has selected, so its values already belong - /// to that row, and a fourth pane would put ⇥ somewhere the eye doesn't go. + /// A character's logging is two fields of the character's own row, drawn in the character form. It + /// lives here because this is where the character it applies to is: F9 used to edit it on a + /// screen of its own that resolved "the active character, or else the first one configured" and + /// never said which — so the same screen edited a different character's log depending on what was + /// connected. There is no Space-to-start checkbox because the row's checkbox is auto-login and a + /// row has one; already spells "off" as one of the format's own + /// choices, which is one control over one stored value rather than two over one. /// /// /// Each list pane ends in its own buttons, because a button acts on the list it is drawn under and @@ -187,13 +259,17 @@ internal static ScreenModel Model( : ScreenModel.Rows(world.Characters, c => ScreenRow.Of( ScreenToggle.Bind(() => c.AutoLogin, v => c.AutoLogin = v), ScreenField.Name("name", () => c.Name, v => c.Name = v), - ScreenField.Optional("on connect", () => c.OnConnect, v => c.OnConnect = v))) + ScreenField.Optional("on connect", () => c.OnConnect, v => c.OnConnect = v), + ScreenField.Enumeration("log", () => c.Logging.Format, v => c.Logging.Format = v), + ScreenField.Optional("log folder", () => c.Logging.Directory, v => c.Logging.Directory = v))) .Concat(CharacterButtons(world, selectedCharacter)) .ToArray(); + var securityRows = world is null ? Array.Empty() : SecurityRows(world); + if (!HasCharacter(worlds, selectedWorld, selectedCharacter)) { - return new ScreenModel(worldRows, characterRows, Array.Empty()); + return new ScreenModel(worldRows, characterRows, Array.Empty(), securityRows); } var character = worlds[selectedWorld].Characters[selectedCharacter]; @@ -225,9 +301,29 @@ internal static ScreenModel Model( })); } - return new ScreenModel(worldRows, characterRows, setRows); + return new ScreenModel(worldRows, characterRows, setRows, securityRows); } + /// + /// The selected world's two security booleans, in the order the WORLD block draws them. They are + /// checkboxes rather than one typed value because that is what they are — two independent flags, + /// which no single field could offer without inventing a vocabulary for the four combinations of + /// them — and they are two rows because a carries at most one checkbox. + /// + /// Certificate validation is a plain bool here and is deliberately still bound in the + /// direction config stores it: the checkbox reads accept invalid certificates, so the + /// dangerous state is the *checked* one and the screen can paint it as such (see + /// ). A checkbox showing the inverse of its stored value would read + /// more comfortably and would be one negation away from silently turning verification off. + /// + /// + private static ScreenRow[] SecurityRows(WorldDefinition world) => new[] + { + ScreenRow.Of(ScreenToggle.Bind(() => world.UseTls, v => world.UseTls = v)), + ScreenRow.Of(ScreenToggle.Bind( + () => world.AllowInvalidCertificates, v => world.AllowInvalidCertificates = v)), + }; + /// /// The WORLDS list's buttons. Deleting is offered only when there is a world under the cursor to /// delete; a brand-new world is a blank template, because a world's whole identity is its host and @@ -332,7 +428,7 @@ internal static List WorldsColumn( var accentHex = Hex(world.Accent); var name = selected ? $"[bold {Value}]{Escape(world.Name)}[/]" : $"[{Value}]{Escape(world.Name)}[/]"; left.Add(ScreenChrome.Cursor( - $"{marker} [{accentHex}]▚[/] {name}", cursor.IsOn(0, i), LeftColumnWidth)); + $"{marker} [{accentHex}]▚[/] {name}", cursor.IsOn(WorldsPane, i), LeftColumnWidth)); left.Add($" [{Label}]{Escape(world.Host)}:{world.Port.ToString(CultureInfo.InvariantCulture)}[/]"); left.Add($" [{Label}]{world.Characters.Count.ToString(CultureInfo.InvariantCulture)} chars[/]"); } @@ -344,7 +440,7 @@ internal static List WorldsColumn( left.Add(string.Empty); left.AddRange(ScreenChrome.Buttons( - WorldButtons(worlds, selectedWorld), cursor, 0, worlds.Count, LeftColumnWidth)); + WorldButtons(worlds, selectedWorld), cursor, WorldsPane, worlds.Count, LeftColumnWidth)); return left; } @@ -373,23 +469,33 @@ internal static List DetailColumn( + $" [{accent}]TLS {OnOff(world.UseTls)}[/][{Label}] · {Escape(world.Encoding)}[/]", string.Empty, $"[{accent}]├ WORLD[/]", - WorldField("name", Field($"[{Value}]{Escape(world.Name)}[/]", cursor, selectedWorld, 0)), - WorldField("host", Field($"[{Value}]{Escape(world.Host)}[/]", cursor, selectedWorld, 1)), + WorldField("name", Field( + $"[{Value}]{Escape(world.Name)}[/]", cursor, selectedWorld, WorldNameField)), + WorldField("host", Field( + $"[{Value}]{Escape(world.Host)}[/]", cursor, selectedWorld, HostField)), WorldField("port", Field( - $"[{Value}]{world.Port.ToString(CultureInfo.InvariantCulture)}[/]", cursor, selectedWorld, 2)), - WorldField("security", ScreenChrome.ReadOnly(Security(world))), - WorldField("encoding", Field($"[{Value}]{Escape(world.Encoding)}[/]", cursor, selectedWorld, 3)), + $"[{Value}]{world.Port.ToString(CultureInfo.InvariantCulture)}[/]", + cursor, + selectedWorld, + PortField)), + }; + + right.AddRange(SecurityColumn(world, cursor)); + right.AddRange(new[] + { + WorldField("encoding", Field( + $"[{Value}]{Escape(world.Encoding)}[/]", cursor, selectedWorld, EncodingField)), WorldField("keepalive", Field( world.KeepaliveSeconds > 0 ? $"[{Value}]{world.KeepaliveSeconds.ToString(CultureInfo.InvariantCulture)}s[/]" : $"[{Label}]off[/]", cursor, selectedWorld, - 4)), + KeepaliveField)), string.Empty, $"[{accent}]├ CHARACTERS[/] [{Label}]a character is a connection[/]", $"[{Label}] name state login trigger sets[/]", - }; + }); if (world.Characters.Count == 0) { @@ -401,24 +507,93 @@ internal static List DetailColumn( { right.Add(ScreenChrome.Cursor( CharacterRow(world.Characters[i], i == selectedCharacter), - cursor.IsOn(1, i), - CharacterRowWidth)); + cursor.IsOn(CharactersPane, i), + DetailRowWidth)); } } right.Add(string.Empty); right.AddRange(ScreenChrome.Buttons( - CharacterButtons(world, selectedCharacter), cursor, 1, world.Characters.Count, CharacterRowWidth)); + CharacterButtons(world, selectedCharacter), + cursor, + CharactersPane, + world.Characters.Count, + DetailRowWidth)); return right; } /// - /// The character form — labels left-aligned with their values, one field per row. The editable - /// ones are the character row's own fields (name, then on-connect) and are the only two drawn in a - /// field well. The other three deliberately are not: the password is + /// The world's security block: two checkbox rows where a read-only security TLS on · certs + /// strict summary used to sit. The summary said everything and offered nothing — the two flags + /// behind it had no UI at all — so it is replaced by the rows themselves rather than kept above + /// them; the world's title strip at the top of this column still reads TLS on, which is where + /// a one-glance answer belongs. + /// + /// They keep the security label column so the block still reads as one setting with two + /// switches, and so the checkboxes line up under the field wells above them rather than starting at + /// the margin. + /// + /// + private static List SecurityColumn(WorldDefinition world, ScreenFocus cursor) => new() + { + ScreenChrome.Cursor( + WorldField("security", Checkbox("TLS", world.UseTls, "encrypt this connection")), + cursor.IsOn(SecurityPane, 0), + DetailRowWidth), + ScreenChrome.Cursor( + WorldField(string.Empty, CertificateRow(world)), cursor.IsOn(SecurityPane, 1), DetailRowWidth), + }; + + /// + /// The certificate checkbox. It is the one row on these screens that can switch off a check the user + /// is otherwise entitled to assume is running, so — unlike the encoding beside it — it does not + /// stay quiet about it: checked *and* encrypting, it is drawn in + /// with the same ▲ a refused value gets, and says what the state actually costs rather than + /// restating its own label. + /// + /// With TLS off it is drawn plainly whatever it holds, and says so: nothing is being validated + /// either way, and a warning that fires on a connection carrying no certificates would train the + /// eye to ignore the one that matters. + /// + /// + private static string CertificateRow(WorldDefinition world) + { + const string label = "accept invalid certificates"; + + if (!world.UseTls) + { + return Checkbox(label, world.AllowInvalidCertificates, "no effect until TLS is on"); + } + + return world.AllowInvalidCertificates + ? $"[{Warn}][[x]] {Escape(label)} ▲ anyone can impersonate this host[/]" + : Checkbox(label, false, "certificates must be valid"); + } + + /// + /// A checkbox row, checked in the accent and unchecked dim — the same shape F2's editor pane draws, + /// so a checkbox means the same thing (Space presses it) wherever these screens put one. + /// + private static string Checkbox(string label, bool value, string hint) + { + var text = $"{Escape(label)}[{Label}] — {Escape(hint)}[/]"; + return value ? $"[{Accent}][[x]][/] [{Value}]{text}[/]" : $"[dim][[ ]][/] [{Label}]{text}[/]"; + } + + /// + /// The character form — labels left-aligned with their values, one field per row. The editable ones + /// are the character row's own fields (name, on-connect, then the two log values) and are the only + /// four drawn in a field well. The other three deliberately are not: the password is /// d and belongs in a credential /// store, auto-login is a readout of the character row's own checkbox, and the session line is a /// report of what the connection is doing rather than a setting at all. + /// + /// The log rows are here, under a heading that names the character, because logging is per + /// character: LoggingSettings hangs off . On its own screen + /// it had to guess whose settings to show and said nothing about the answer; here the question + /// cannot come up, and the row says this character only anyway for the reader arriving from + /// the F9 it used to live on. + /// /// internal static List FormColumn( CharacterDefinition character, string accent, ScreenFocus? focus = null, int selectedCharacter = -1) @@ -429,15 +604,42 @@ internal static List FormColumn( $"[bold {accent}]└ CHARACTER · {Escape(character.Name)}[/]", string.Empty, CharField("name", Field( - $"[{Value}]{Escape(character.Name)}[/]", cursor, selectedCharacter, 0, pane: 1)), + $"[{Value}]{Escape(character.Name)}[/]", + cursor, + selectedCharacter, + CharacterNameField, + pane: CharactersPane)), CharField("password", $"{ScreenChrome.ReadOnly("••••••••")} [{Label}]keychain[/]"), CharField("on connect", Field( - $"[{Value}]{Escape(character.OnConnect ?? "—")}[/]", cursor, selectedCharacter, 1, pane: 1)), + $"[{Value}]{Escape(character.OnConnect ?? "—")}[/]", + cursor, + selectedCharacter, + OnConnectField, + pane: CharactersPane)), CharField("auto-login", ScreenChrome.ReadOnly(character.AutoLogin ? "yes" : "no")), CharField("session", ScreenChrome.ReadOnly("offline")), + CharField("log", Field( + $"[{Value}]{character.Logging.Format.ToString()}[/]", + cursor, + selectedCharacter, + LogFormatField, + pane: CharactersPane) + $" [{Label}]— this character only[/]"), + CharField("log folder", Field( + $"[{Value}]{Escape(character.Logging.Directory ?? DefaultDirectory)}[/]", + cursor, + selectedCharacter, + LogDirectoryField, + pane: CharactersPane)), }; } + /// + /// What an unset log directory reads as. The field itself holds null — the logger picks a + /// per-session folder under the config directory — so the row names the state rather than showing + /// an empty well that would look like a value someone had blanked. + /// + internal const string DefaultDirectory = "(default)"; + /// Draws a value as a field, showing the buffer and caret when its edit is the open one. private static string Field(string display, ScreenFocus cursor, int index, int field, int pane = 0) => ScreenChrome.Field(display, cursor.EditOn(pane, index, field)); @@ -469,7 +671,7 @@ internal static List TriggersColumn( var list = new List { $"[{Label}]assigned trigger sets[/]", string.Empty }; for (var i = 0; i < rows.Count; i++) { - list.Add(ScreenChrome.Cursor(rows[i], cursor.IsOn(2, i), barWidth)); + list.Add(ScreenChrome.Cursor(rows[i], cursor.IsOn(TriggerSetsPane, i), barWidth)); } return list; @@ -484,11 +686,6 @@ private static string CharacterRow(CharacterDefinition character, bool selected) return $"{marker} {name} [{Label}]○ offline[/] [{Label}]{login}[/] [{Label}]{sets}[/]"; } - private static string Security(WorldDefinition world) => - world.UseTls - ? $"TLS on · certs {(world.AllowInvalidCertificates ? "lax" : "strict")}" - : "TLS off"; - private static string WorldField(string label, string value) => $" [{Label}]{label.PadLeft(WorldLabelWidth)}[/] {value}"; diff --git a/src/SharpMUTerm.Tui/WorldsScreenView.cs b/src/SharpMUTerm.Tui/WorldsScreenView.cs index 1af01b04..c3281e6a 100644 --- a/src/SharpMUTerm.Tui/WorldsScreenView.cs +++ b/src/SharpMUTerm.Tui/WorldsScreenView.cs @@ -22,7 +22,8 @@ public static IWindowControl Build( int selectedWorld, int selectedCharacter, int width, - ScreenFocus? focus = null) + ScreenFocus? focus = null, + string fkey = WorldsScreenRenderer.FKey) { // Both panes end in button rows, so a raw cursor can point past its list; resolving once here // keeps every block of the screen agreeing on which world and character are selected. @@ -32,7 +33,7 @@ public static IWindowControl Build( var model = WorldsScreenRenderer.Model(worlds, triggerSets, selectedWorld, selectedCharacter); var header = ScreenChrome.Band( - WorldsScreenRenderer.HeaderLine(width, model, focus), ScreenPalette.HeaderBg); + WorldsScreenRenderer.HeaderLine(width, model, focus, fkey), ScreenPalette.HeaderBg); var footer = ScreenChrome.Band( WorldsScreenRenderer.FooterLine(worlds, selectedWorld, selectedCharacter, accent, width, focus), ScreenPalette.FooterBg); diff --git a/tests/SharpMUTerm.Tui.Tests/OptionsScreenRendererTests.cs b/tests/SharpMUTerm.Tui.Tests/OptionsScreenRendererTests.cs index e4e887da..4b6640ae 100644 --- a/tests/SharpMUTerm.Tui.Tests/OptionsScreenRendererTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/OptionsScreenRendererTests.cs @@ -1,4 +1,3 @@ -using SharpMUTerm.Core.Configuration; using SharpMUTerm.Tui; namespace SharpMUTerm.Tui.Tests; @@ -56,17 +55,18 @@ public async Task Render_SpacerRow_IsBlankLine() /// /// The header names the screen and how to leave it, and nothing else. It used to open with a - /// ‹ back affordance — on these three screens only, pointing at a navigation stack that does + /// ‹ back affordance — on the options screens only, pointing at a navigation stack that does /// not exist. The assertion is kept pointed the other way rather than dropped, so it cannot come /// back by accident. /// [Test] public async Task Render_HeaderAndFooter_MatchPattern() { - var lines = OptionsScreenRenderer.Render("Logging", "F9", Array.Empty()); + var lines = OptionsScreenRenderer.Render( + "Input & spellcheck", "F8", Array.Empty()); await Assert.That(lines[0]).DoesNotContain("‹ back"); - await Assert.That(lines[0]).Contains("Logging"); - await Assert.That(lines[0]).Contains("F9"); + await Assert.That(lines[0]).Contains("Input & spellcheck"); + await Assert.That(lines[0]).Contains("F8"); await Assert.That(lines[^1]).Contains("Cancel"); await Assert.That(lines[^1]).Contains("Save"); } @@ -104,24 +104,4 @@ public async Task InputSpellcheck_ContainsExpectedLabelsAndSections() await Assert.That(lines.Any(l => l.Contains("check spelling"))).IsTrue(); await Assert.That(lines.Any(l => l.Contains("dictionary") && l.Contains("en_US"))).IsTrue(); } - - [Test] - public async Task Logging_ReflectsPassedSettings() - { - var logging = new LoggingSettings { Format = LogFormat.Html, Directory = "/var/log/mu" }; - var lines = OptionsScreenRenderer.Logging(logging); - await Assert.That(lines.Any(l => l.Contains("format") && l.Contains("Html"))).IsTrue(); - await Assert.That(lines.Any(l => l.Contains("directory") && l.Contains("/var/log/mu"))).IsTrue(); - await Assert.That(lines.Any(l => l.Contains("auto-start on connect") && l.Contains("[[x]]"))).IsTrue(); - } - - [Test] - public async Task Logging_NoneFormat_AutoStartUnchecked_AndUsesDefaultDirectoryText() - { - var logging = new LoggingSettings { Format = LogFormat.None, Directory = null }; - var lines = OptionsScreenRenderer.Logging(logging); - await Assert.That(lines.Any(l => l.Contains("directory") && l.Contains("(default)"))).IsTrue(); - var autoStart = lines.Single(l => l.Contains("auto-start on connect")); - await Assert.That(autoStart).Contains("[[ ]]"); - } } diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenButtonTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenButtonTests.cs index 6e23b6f4..f2548c3a 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenButtonTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenButtonTests.cs @@ -59,8 +59,10 @@ public async Task EachListPaneEndsInItsOwnButtons() var worlds = Worlds(); var model = WorldsScreenRenderer.Model(worlds, Sets(), selectedWorld: 0, selectedCharacter: 0); - // 2 worlds + [+ world] + [- del]; 2 characters + [+ add] + [⧉ duplicate] + [- remove]; 1 set. - await Assert.That(model.Sizes).IsEquivalentTo(new[] { 4, 5, 1 }); + // 2 worlds + [+ world] + [- del]; 2 characters + [+ add] + [⧉ duplicate] + [- remove]; 1 set; + // and the world's 2 security checkboxes, a pane with no buttons of its own. + await Assert.That(model.ListSizes).IsEquivalentTo(new[] { 2, 2, 1, 2 }); + await Assert.That(model.Sizes).IsEquivalentTo(new[] { 4, 5, 1, 2 }); await Assert.That(model.ButtonAt(0, 2)!.Value.Label).IsEqualTo(WorldsScreenRenderer.AddWorldLabel); await Assert.That(model.ButtonAt(0, 3)!.Value.Label).IsEqualTo(WorldsScreenRenderer.RemoveWorldLabel); @@ -84,7 +86,8 @@ public async Task APaneWithNothingSelectedOffersOnlyItsAddButton() { var model = WorldsScreenRenderer.Model(Worlds(), Sets(), selectedWorld: 1, selectedCharacter: 0); - await Assert.That(model.Sizes).IsEquivalentTo(new[] { 4, 1, 0 }); + await Assert.That(model.ListSizes).IsEquivalentTo(new[] { 2, 0, 0, 2 }); + await Assert.That(model.Sizes).IsEquivalentTo(new[] { 4, 1, 0, 2 }); await Assert.That(model.ButtonAt(1, 0)!.Value.Label).IsEqualTo(WorldsScreenRenderer.AddCharacterLabel); await Assert.That(model.ButtonAt(1, 1)).IsNull(); } diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenCursorTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenCursorTests.cs index 0d64cccb..634df0ab 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenCursorTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenCursorTests.cs @@ -174,7 +174,7 @@ public async Task HeaderHints_AdvertiseOnlyTheKeysTheScreensImplement() await Assert.That(TimersScreenRenderer.HeaderLine(0)).Contains(ScreenChrome.ListHints); await Assert.That(WorldsScreenRenderer.HeaderLine(0)).Contains(ScreenChrome.ListHints); await Assert.That(KeypadScreenRenderer.HeaderLine(0)).Contains(ScreenChrome.SingleListHints); - await Assert.That(OptionsScreenRenderer.HeaderLine("Logging", "F9", 0)) + await Assert.That(OptionsScreenRenderer.HeaderLine("Input & spellcheck", "F8", 0)) .Contains(ScreenChrome.SingleListHints); // A header handed no model describes a screen that only navigates, so it may not claim ⏎ @@ -186,7 +186,7 @@ await Assert.That(OptionsScreenRenderer.HeaderLine("Logging", "F9", 0)) TimersScreenRenderer.HeaderLine(0), WorldsScreenRenderer.HeaderLine(0), KeypadScreenRenderer.HeaderLine(0), - OptionsScreenRenderer.HeaderLine("Logging", "F9", 0), + OptionsScreenRenderer.HeaderLine("Input & spellcheck", "F8", 0), }) { await Assert.That(header).DoesNotContain("⏎ edit"); @@ -195,6 +195,29 @@ await Assert.That(OptionsScreenRenderer.HeaderLine("Logging", "F9", 0)) } } + /// + /// F5 has two doors — F5 itself and F9, which opens it on the character whose log used to live on a + /// screen of its own — and the header names the one that was used. A header that always said + /// F5 would be naming a key that, pressed there, re-opens the screen instead of closing it. + /// + [Test] + public async Task HeaderHints_NameTheKeyTheScreenWasOpenedWith() + { + var model = WorldsScreenRenderer.Model( + new List { new() { Name = "Aardwolf", Host = "aardmud.org" } }, + Sets(), + 0, + -1); + + var f5 = WorldsScreenRenderer.HeaderLine(80, model); + var f9 = WorldsScreenRenderer.HeaderLine(80, model, null, WorldsScreenRenderer.LogFKey); + + await Assert.That(f5).Contains("F5"); + await Assert.That(f5).DoesNotContain("F9"); + await Assert.That(f9).Contains("F9"); + await Assert.That(f9).DoesNotContain("F5"); + } + /// /// The hint honesty rule, in both directions: a screen advertises ⏎ edit if and only /// if its actually holds a row ⏎ can open. Every header is built @@ -250,7 +273,7 @@ public async Task HeaderHints_SwapToTheEditingKeysWhileAFieldIsOpen() { new() { Name = "Aardwolf", Host = "aardmud.org", Characters = new List { new() } }, }; - var logging = OptionsScreenRenderer.LoggingScreen(new LoggingSettings()); + var options = OptionsScreenRenderer.InputSpellcheckScreen(); return new List<(string, ScreenModel)> { @@ -262,8 +285,8 @@ public async Task HeaderHints_SwapToTheEditingKeysWhileAFieldIsOpen() WorldsScreenRenderer.Model(worlds, sets, 0, 0), m => WorldsScreenRenderer.HeaderLine(0, m)), Pair( - OptionsScreenRenderer.Model(logging), - m => OptionsScreenRenderer.HeaderLine(logging.Title, logging.FKey, 0, m)), + OptionsScreenRenderer.Model(options), + m => OptionsScreenRenderer.HeaderLine(options.Title, options.FKey, 0, m)), }; } diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenFieldRenderingTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenFieldRenderingTests.cs index dd432110..cfcc0921 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenFieldRenderingTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenFieldRenderingTests.cs @@ -204,15 +204,44 @@ public async Task Keypad_DrawsTheNameAndCommandBuffersInTheBindingRowItself() [Test] public async Task Options_DrawsTheBufferOnTheValueRowUnderTheCursor() { - var screen = OptionsScreenRenderer.LoggingScreen(new LoggingSettings { Format = LogFormat.Plain }); + var screen = OptionsScreenRenderer.InputSpellcheckScreen(); - // Navigable row 0 is "format"; row 1 is "directory". - var format = OptionsScreenRenderer.BodyColumn(screen.Rows, Edit(0, 0, 0, "Html")); - await Assert.That(Carets(format)).IsEqualTo(1); - await Assert.That(format.Single(HasCaret)).Contains("format"); + // Navigable rows: 0 local echo, 1 drafts, 2 newline key, 3 check spelling, 4 dictionary. + var newline = OptionsScreenRenderer.BodyColumn(screen.Rows, Edit(0, 2, 0, "Ctrl+Enter")); + await Assert.That(Carets(newline)).IsEqualTo(1); + await Assert.That(newline.Single(HasCaret)).Contains("newline key"); + + var dictionary = OptionsScreenRenderer.BodyColumn(screen.Rows, Edit(0, 4, 0, "en_GB")); + await Assert.That(dictionary.Single(HasCaret)).Contains("dictionary"); + } + + /// + /// The character's log values are the character row's own fields, so their carets are drawn in the + /// character form — where they are read — and nowhere else. This is what F9's screen used to do for + /// a character it never named. + /// + [Test] + public async Task Worlds_TheCharacterFormDrawsTheLogBuffers() + { + var character = Worlds()[0].Characters[0]; - var directory = OptionsScreenRenderer.BodyColumn(screen.Rows, Edit(0, 1, 0, "/logs")); - await Assert.That(directory.Single(HasCaret)).Contains("directory"); + var format = WorldsScreenRenderer.FormColumn( + character, + ScreenPalette.Accent, + Edit(WorldsScreenRenderer.CharactersPane, 0, WorldsScreenRenderer.LogFormatField, "Both"), + 0); + await Assert.That(Carets(format)).IsEqualTo(1); + await Assert.That(format.Single(HasCaret)).Contains("log"); + await Assert.That(format.Single(HasCaret)).Contains("Both"); + + var folder = WorldsScreenRenderer.FormColumn( + character, + ScreenPalette.Accent, + Edit(WorldsScreenRenderer.CharactersPane, 0, WorldsScreenRenderer.LogDirectoryField, "/logs/kaz"), + 0); + await Assert.That(Carets(folder)).IsEqualTo(1); + await Assert.That(folder.Single(HasCaret)).Contains("log folder"); + await Assert.That(folder.Single(HasCaret)).Contains("/logs/kaz"); } [Test] diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenFooterTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenFooterTests.cs index b2c8d63d..f7f76c13 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenFooterTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenFooterTests.cs @@ -48,7 +48,7 @@ public class ScreenFooterTests var sets = Sets(); var worlds = Worlds(); var macros = sets[0].Macros; - var logging = OptionsScreenRenderer.LoggingScreen(new LoggingSettings()); + var options = OptionsScreenRenderer.InputSpellcheckScreen(); var accent = WorldsScreenRenderer.AccentFor(worlds, 0); return new List<(string, string, string)> @@ -68,9 +68,9 @@ public class ScreenFooterTests ("F6 timers", TimersScreenRenderer.FooterLine(sets, 0, 80), TimersScreenRenderer.FooterLine(sets, 0, 80, Editing)), - ("F7/F8/F9 options", - OptionsScreenRenderer.FooterLine(logging.Rows, 80), - OptionsScreenRenderer.FooterLine(logging.Rows, 80, Editing)), + ("F7/F8 options", + OptionsScreenRenderer.FooterLine(options.Rows, 80), + OptionsScreenRenderer.FooterLine(options.Rows, 80, Editing)), }; } diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs index 32cf1bcc..96ec1d50 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs @@ -174,12 +174,15 @@ public async Task Worlds_HasWorldsThenCharactersThenTriggerSets() var sets = Sets(); var model = WorldsScreenRenderer.Model(worlds, sets, selectedWorld: 0, selectedCharacter: 0); - await Assert.That(model.PaneCount).IsEqualTo(3); + // Four panes: the fourth is the selected world's two security checkboxes, appended so that the + // three that were here keep the indices everything below (and every other test) addresses. + await Assert.That(model.PaneCount).IsEqualTo(4); // Two worlds then [+ world] / [- del]; two characters then [+ add] / [⧉ duplicate] / // [- remove]. Buttons are appended after each list, so every index below still addresses - // the same item it always did. - await Assert.That(model.Sizes).IsEquivalentTo(new[] { 4, 5, 1 }); + // the same item it always did — which is what the list counts assert independently of the total. + await Assert.That(model.ListSizes).IsEquivalentTo(new[] { 2, 2, 1, 2 }); + await Assert.That(model.Sizes).IsEquivalentTo(new[] { 4, 5, 1, 2 }); // Worlds are selection only — there is no checkbox on a world row. await Assert.That(model.ToggleAt(0, 0)).IsNull(); @@ -231,8 +234,70 @@ public async Task Worlds_CharacterAndTriggerSetPanesAreEmptyForAWorldWithNoChara var model = WorldsScreenRenderer.Model(Worlds(), Sets(), selectedWorld: 1, selectedCharacter: 0); // The character pane holds one row — [+ add character]. Duplicate and remove would act on - // nothing, so they aren't drawn and ⏎ can't land on a silent no-op. - await Assert.That(model.Sizes).IsEquivalentTo(new[] { 4, 1, 0 }); + // nothing, so they aren't drawn and ⏎ can't land on a silent no-op. The security pane still + // holds its two checkboxes: they belong to the world, which is selected, not to a character. + await Assert.That(model.Sizes).IsEquivalentTo(new[] { 4, 1, 0, 2 }); + await Assert.That(model.ListSizes).IsEquivalentTo(new[] { 2, 0, 0, 2 }); + } + + /// + /// The world's two security booleans, which had no UI at all — the screen summarised them in a + /// read-only line and left the only way to change them in the JSON. Two flags, two checkboxes, two + /// rows, because a ScreenRow carries at most one checkbox. + /// + [Test] + public async Task Worlds_SecurityPaneTogglesTlsAndCertificateValidation() + { + var worlds = Worlds(); + var world = worlds[0]; + var model = WorldsScreenRenderer.Model(worlds, Sets(), 0, 0); + + model.ToggleAt(WorldsScreenRenderer.SecurityPane, 0)!.Value.Flip(); + await Assert.That(world.UseTls).IsTrue(); + + model.ToggleAt(WorldsScreenRenderer.SecurityPane, 1)!.Value.Flip(); + await Assert.That(world.AllowInvalidCertificates).IsTrue(); + } + + /// + /// Both security toggles go through the undo log like everything else on these screens, so Esc puts + /// certificate validation back on. This is the one row where an edit that outlived a cancelled + /// screen would be a security change nobody agreed to. + /// + [Test] + public async Task Worlds_SecurityTogglesAreUndone_ByCancellingTheScreen() + { + var worlds = Worlds(); + var world = worlds[0]; + world.UseTls = true; + var edits = new ScreenEdits(); + var model = WorldsScreenRenderer.Model(worlds, Sets(), 0, 0); + + edits.Apply(model.ToggleAt(WorldsScreenRenderer.SecurityPane, 0)!.Value); + edits.Apply(model.ToggleAt(WorldsScreenRenderer.SecurityPane, 1)!.Value); + await Assert.That(world.UseTls).IsFalse(); + await Assert.That(world.AllowInvalidCertificates).IsTrue(); + + edits.Revert(); + + await Assert.That(world.UseTls).IsTrue(); + await Assert.That(world.AllowInvalidCertificates).IsFalse(); + } + + /// + /// The security pane belongs to the world, so it follows the WORLDS selection rather than + /// the character's — flipping TLS on the second world must not touch the first. + /// + [Test] + public async Task Worlds_SecurityPaneFollowsTheSelectedWorld() + { + var worlds = Worlds(); + + WorldsScreenRenderer.Model(worlds, Sets(), selectedWorld: 1, selectedCharacter: 0) + .ToggleAt(WorldsScreenRenderer.SecurityPane, 0)!.Value.Flip(); + + await Assert.That(worlds[1].UseTls).IsTrue(); + await Assert.That(worlds[0].UseTls).IsFalse(); } [Test] @@ -277,47 +342,70 @@ public async Task Options_InputRowsWriteBackToTheInputSettings() } /// - /// F9's auto-start checkbox lives on the format row itself (row 0) rather than on a third - /// row of its own: it and the format are one stored value, so Space and ⏎ act on one row. Its - /// snapshot still restores the format, not the boolean. + /// Logging is two more fields of the character's own row — the format (whose None is "off", + /// so one control covers one stored value) and the folder. They are appended after the name and the + /// on-connect line, so the two ordinals that were here still mean what they meant. This replaces + /// F9's screen, whose rows edited whichever character happened to be active. /// [Test] - public async Task Options_LoggingAutoStartTogglesTheFormat_AndUndoRestoresTheOriginalOne() + public async Task Worlds_TheCharacterRowCarriesItsLogFormatAndFolder() { - var logging = new LoggingSettings { Format = LogFormat.Html }; - var edits = new ScreenEdits(); - - edits.Apply(OptionsScreenRenderer.Model(OptionsScreenRenderer.LoggingScreen(logging)).ToggleAt(0, 0)!.Value); - await Assert.That(logging.Format).IsEqualTo(LogFormat.None); - - edits.Revert(); - - await Assert.That(logging.Format).IsEqualTo(LogFormat.Html); + var worlds = Worlds(); + var character = worlds[0].Characters[0]; + character.Logging = new LoggingSettings { Format = LogFormat.Html, Directory = "/logs/kaz" }; + var model = WorldsScreenRenderer.Model(worlds, Sets(), 0, 0); + var row = model.RowAt(WorldsScreenRenderer.CharactersPane, 0); + + await Assert.That(row.FieldCount).IsEqualTo(4); + await Assert.That(row.FieldAt(WorldsScreenRenderer.CharacterNameField)!.Value.Get()).IsEqualTo("Kaz"); + await Assert.That(row.FieldAt(WorldsScreenRenderer.LogFormatField)!.Value.Get()).IsEqualTo("Html"); + await Assert.That(row.FieldAt(WorldsScreenRenderer.LogDirectoryField)!.Value.Get()).IsEqualTo("/logs/kaz"); + + // The format cycles like every other enum field, and None is how logging is turned off. + await Assert.That(row.FieldAt(WorldsScreenRenderer.LogFormatField)!.Value.Choices) + .IsEquivalentTo(new[] { "None", "Plain", "Html", "Both" }); } + /// + /// The bug the move exists to kill: an edit made on this screen reaches the character whose row it + /// was made on, and no other. F9 resolved "the active character, or else the first one configured" + /// and never said which, so the same screen wrote to a different character's log depending on what + /// was connected. + /// [Test] - public async Task Options_LoggingAutoStartTurnsOnAsPlainWhenNothingWasChosen() + public async Task Worlds_ALogEditReachesTheSelectedCharacterAndNoOther() { - var logging = new LoggingSettings { Format = LogFormat.None }; + var worlds = Worlds(); + var (kaz, mira) = (worlds[0].Characters[0], worlds[0].Characters[1]); + var edits = new ScreenEdits(); + + var second = WorldsScreenRenderer.Model(worlds, Sets(), 0, 1) + .FieldAt(WorldsScreenRenderer.CharactersPane, 1, WorldsScreenRenderer.LogFormatField)!.Value; + await Assert.That(edits.Apply(second, "Both")).IsNull(); - OptionsScreenRenderer.Model(OptionsScreenRenderer.LoggingScreen(logging)).ToggleAt(0, 0)!.Value.Flip(); + await Assert.That(mira.Logging.Format).IsEqualTo(LogFormat.Both); + await Assert.That(kaz.Logging.Format).IsEqualTo(LogFormat.None); - await Assert.That(logging.Format).IsEqualTo(LogFormat.Plain); + edits.Revert(); + + await Assert.That(mira.Logging.Format).IsEqualTo(LogFormat.None); } /// - /// The same row carries both, which is what makes it one setting rather than two: ⏎ opens the - /// format on the row Space starts and stops logging from. + /// The folder is optional, and blank means null — "unset, use the per-session default" — rather + /// than an empty string, so the two spellings of "no folder" cannot drift apart in config. /// [Test] - public async Task Options_LoggingFormatAndAutoStartAreOneRow() + public async Task Worlds_ABlankLogFolderIsStoredAsNull() { - var model = OptionsScreenRenderer.Model( - OptionsScreenRenderer.LoggingScreen(new LoggingSettings { Format = LogFormat.Html })); + var worlds = Worlds(); + var character = worlds[0].Characters[0]; + character.Logging.Directory = "/logs/kaz"; + var field = WorldsScreenRenderer.Model(worlds, Sets(), 0, 0) + .FieldAt(WorldsScreenRenderer.CharactersPane, 0, WorldsScreenRenderer.LogDirectoryField)!.Value; + + await Assert.That(new ScreenEdits().Apply(field, " ")).IsNull(); - await Assert.That(model.Sizes[0]).IsEqualTo(2); - await Assert.That(model.RowAt(0, 0).Toggle).IsNotNull(); - await Assert.That(model.RowAt(0, 0).FieldCount).IsEqualTo(1); - await Assert.That(model.FieldAt(0, 0, 0)!.Value.Get()).IsEqualTo("Html"); + await Assert.That(character.Logging.Directory).IsNull(); } } diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenNameTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenNameTests.cs index 3d037290..af068642 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenNameTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenNameTests.cs @@ -64,14 +64,31 @@ public class ScreenNameTests TimersScreenRenderer.Model(sets, 0).FieldAt(0, 0, TimersScreenRenderer.NameField)!.Value, () => timer.Name), ("F5 worlds", - WorldsScreenRenderer.Model(worlds, sets, 0, 0).FieldAt(0, 0, 0)!.Value, + WorldsScreenRenderer.Model(worlds, sets, 0, 0) + .FieldAt( + WorldsScreenRenderer.WorldsPane, 0, WorldsScreenRenderer.WorldNameField)!.Value, () => world.Name), ("F5 characters", - WorldsScreenRenderer.Model(worlds, sets, 0, 0).FieldAt(1, 0, 0)!.Value, + WorldsScreenRenderer.Model(worlds, sets, 0, 0) + .FieldAt( + WorldsScreenRenderer.CharactersPane, 0, WorldsScreenRenderer.CharacterNameField)!.Value, () => character.Name), }; } + /// Field 0 of every list row — what ⏎ opens, whatever each screen calls that ordinal. + private static List FirstFields(List sets, List worlds) => + new() + { + TriggersScreenRenderer.Model(sets, 0).FieldAt(0, 0, 0)!.Value, + AliasesScreenRenderer.Model(sets, 0).FieldAt(0, 0, 0)!.Value, + KeypadScreenRenderer.Model(sets[0].Macros).FieldAt(0, 0, 0)!.Value, + TimersScreenRenderer.Model(sets, 0).FieldAt(0, 0, 0)!.Value, + WorldsScreenRenderer.Model(worlds, sets, 0, 0).FieldAt(WorldsScreenRenderer.WorldsPane, 0, 0)!.Value, + WorldsScreenRenderer.Model(worlds, sets, 0, 0) + .FieldAt(WorldsScreenRenderer.CharactersPane, 0, 0)!.Value, + }; + /// /// The rule the four automation screens broke: the row's first field is the thing it is called. /// F5 already worked this way, which is why it is in the same list rather than in a test of its own. @@ -91,11 +108,11 @@ public async Task TheFirstFieldOfEveryListRowIsItsName() await Assert.That(field.Get()).IsEqualTo(expected[i]).Because(screen); } - // The name really is the *first* field, which is what makes ⏎ open it. - await Assert.That(TriggersScreenRenderer.NameField).IsEqualTo(0); - await Assert.That(AliasesScreenRenderer.NameField).IsEqualTo(0); - await Assert.That(KeypadScreenRenderer.NameField).IsEqualTo(0); - await Assert.That(TimersScreenRenderer.NameField).IsEqualTo(0); + // The name really is the *first* field, which is what makes ⏎ open it. Asserted through the + // models rather than against the ordinal constants: comparing a constant to a literal is a + // claim the compiler already settles, and says nothing about which field the screen built. + await Assert.That(FirstFields(sets, worlds).Select(f => f.Label).Distinct()) + .IsEquivalentTo(new[] { "name" }); } [Test] diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenReadOnlyTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenReadOnlyTests.cs index 7a6939d1..253fa80b 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenReadOnlyTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenReadOnlyTests.cs @@ -94,23 +94,78 @@ public async Task Worlds_EditableRowsSitInAFieldWellAndReadOnlyOnesDoNot() var worldName = lines.Single(l => l.Contains(" name[/]", StringComparison.Ordinal)); await Assert.That(InAWell(worldName)).IsTrue(); - // Two booleans with no UI at all; a later task gives them one. Until then it must not look like - // one — this is the row the whole rule exists for. + // The two booleans that used to be summarised here now have checkboxes, so the row is no longer + // a readout — but it is still not a *field*, and must not grow a well: Space presses it, ⏎ does + // nothing to it, and the well would promise the wrong key. await Assert.That(InAWell(Row(lines, "security"))).IsFalse(); - await Assert.That(Row(lines, "security")).Contains(ScreenPalette.Muted); + await Assert.That(HasCheckbox(Row(lines, "security"))).IsTrue(); } /// - /// The character form, where three of five rows are readouts: a password that lives in a credential - /// store, a mirror of the character row's own checkbox, and the state of a connection. + /// The other half of that rule, on the screen that grew the checkboxes: every checkbox the WORLD + /// block draws belongs to a row the cursor can reach and Space can press. The security pane's rows + /// are exactly those two, so the counts have to match — a summary redrawn as a checkbox is exactly + /// the case where they wouldn't. /// [Test] - public async Task Worlds_TheCharacterFormWellsOnlyTheTwoRowsThatCanBeTyped() + public async Task Worlds_EveryCheckboxInTheWorldBlockIsANavigableToggleRow() + { + var worlds = Worlds(); + var lines = WorldsScreenRenderer.DetailColumn(worlds, Sets(), 0, 0, ScreenPalette.Accent); + var model = WorldsScreenRenderer.Model(worlds, Sets(), 0, 0); + var pane = WorldsScreenRenderer.SecurityPane; + + // The characters table below draws no checkboxes of its own, so every box in this column is a + // security row. + await Assert.That(lines.Count(HasCheckbox)).IsEqualTo(model.Sizes[pane]); + for (var row = 0; row < model.Sizes[pane]; row++) + { + await Assert.That(model.ToggleAt(pane, row)).IsNotNull(); + } + } + + /// + /// The one row on these screens that can switch off a check the user is entitled to assume is + /// running. Checked while TLS is on, it is drawn in the warn ink with the ▲ a refused value + /// gets and says what the state costs; unchecked, it is as quiet as the encoding above it. Asserted + /// both ways round, so the shouting can neither disappear nor spread. + /// + [Test] + public async Task Worlds_TheCertificateRowShoutsOnlyWhileItIsActuallySwitchedOff() + { + var worlds = Worlds(); + var strict = CertificateRow(WorldsScreenRenderer.DetailColumn(worlds, Sets(), 0, 0, ScreenPalette.Accent)); + await Assert.That(strict).DoesNotContain(ScreenPalette.Warn); + await Assert.That(strict).Contains("[[ ]]"); + + worlds[0].AllowInvalidCertificates = true; + var lax = CertificateRow(WorldsScreenRenderer.DetailColumn(worlds, Sets(), 0, 0, ScreenPalette.Accent)); + await Assert.That(lax).Contains(ScreenPalette.Warn); + await Assert.That(lax).Contains("▲"); + await Assert.That(lax).Contains("[[x]]"); + + // With nothing encrypted there is no certificate to check either way, and a warning that fired + // there would train the eye to skip the one that matters. + worlds[0].UseTls = false; + var plaintext = CertificateRow(WorldsScreenRenderer.DetailColumn(worlds, Sets(), 0, 0, ScreenPalette.Accent)); + await Assert.That(plaintext).DoesNotContain(ScreenPalette.Warn); + await Assert.That(plaintext).Contains("no effect until TLS is on"); + } + + /// + /// The character form, where three of seven rows are readouts: a password that lives in a credential + /// store, a mirror of the character row's own checkbox, and the state of a connection. The other + /// four — the name, the on-connect line and the two log values — are the character row's own fields. + /// + [Test] + public async Task Worlds_TheCharacterFormWellsOnlyTheRowsThatCanBeTyped() { var lines = WorldsScreenRenderer.FormColumn(Worlds()[0].Characters[0], ScreenPalette.Accent); - await Assert.That(InAWell(Row(lines, "name"))).IsTrue(); - await Assert.That(InAWell(Row(lines, "on connect"))).IsTrue(); + foreach (var label in new[] { "name", "on connect", "log", "log folder" }) + { + await Assert.That(InAWell(Row(lines, label))).IsTrue().Because(label + " is editable"); + } foreach (var label in new[] { "password", "auto-login", "session" }) { @@ -191,7 +246,7 @@ public async Task Triggers_EveryCheckboxInTheEditorIsANavigableToggleRow() } /// - /// The same rule for the three options screens, which is where F9's auto-start indicator was: every + /// The same rule for the options screens, which is where F9's auto-start indicator was: every /// checkbox drawn in the list belongs to a row whose model entry actually carries a toggle. /// [Test] @@ -201,8 +256,6 @@ public async Task Options_EveryCheckboxBelongsToARowTheModelCanToggle() { OptionsScreenRenderer.TextAnsiScreen(), OptionsScreenRenderer.InputSpellcheckScreen(), - OptionsScreenRenderer.LoggingScreen(new LoggingSettings { Format = LogFormat.Html }), - OptionsScreenRenderer.LoggingScreen(new LoggingSettings { Format = LogFormat.None }), }; foreach (var screen in screens) @@ -271,9 +324,16 @@ public async Task EveryFooterContextLineOpensWithTheCursorsPosition() } } + /// + /// The certificate checkbox, found by its label: it is the one security row with no label column of + /// its own, because it is the second switch of the security row above it. + /// + private static string CertificateRow(IReadOnlyList lines) => + lines.Single(l => l.Contains("accept invalid certificates", StringComparison.Ordinal)); + /// The line of a label/value block whose label is . private static string Row(IReadOnlyList lines, string label) => - lines.Single(l => Regex.IsMatch(Visible(l), $@"^\s*{Regex.Escape(label)}\s")); + lines.Single(l => Regex.IsMatch(Visible(l), $@"^\s*{Regex.Escape(label)}\s\s")); /// A markup line as it prints: tags stripped, escaped brackets folded back to one. private static string Visible(string markup) @@ -298,7 +358,8 @@ private static List Headers() TimersScreenRenderer.HeaderLine(80, TimersScreenRenderer.Model(sets, 0)), Header(OptionsScreenRenderer.TextAnsiScreen()), Header(OptionsScreenRenderer.InputSpellcheckScreen()), - Header(OptionsScreenRenderer.LoggingScreen(new LoggingSettings())), + WorldsScreenRenderer.HeaderLine( + 80, WorldsScreenRenderer.Model(worlds, sets, 0, 0), null, WorldsScreenRenderer.LogFKey), }; } @@ -320,9 +381,7 @@ private static string Header(OptionsScreenRenderer.OptionsScreen screen) => ("F6 timers", TimersScreenRenderer.FooterLine(sets, 0, 80)), ("F7 text", OptionsScreenRenderer.FooterLine(OptionsScreenRenderer.TextAnsiScreen().Rows, 80)), ("F8 input", OptionsScreenRenderer.FooterLine(OptionsScreenRenderer.InputSpellcheckScreen().Rows, 80)), - ("F9 logging", - OptionsScreenRenderer.FooterLine( - OptionsScreenRenderer.LoggingScreen(new LoggingSettings()).Rows, 80)), + ("F9 worlds (the character's log)", WorldsScreenRenderer.FooterLine(worlds, 0, 0, accent, 80)), }; } } diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenSelectionTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenSelectionTests.cs index 18b788f6..2513b991 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenSelectionTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenSelectionTests.cs @@ -16,6 +16,50 @@ public async Task New_StartsOnFirstPaneFirstRow() await Assert.That(selection.Index).IsEqualTo(0); } + /// + /// A screen can be opened focused on a pane other than the first — F9 opens F5 in the character + /// pane, which is where the log it used to edit now lives. Seeded cursors are left alone: the pane + /// the key means is a different question from the row the app resumed on. + /// + [Test] + public async Task FocusPane_StartsTheKeyboardInAnotherPaneWithoutMovingAnyCursor() + { + var selection = new ScreenSelection(3); + selection.Seed(1, 2); + + selection.FocusPane(1); + + await Assert.That(selection.Pane).IsEqualTo(1); + await Assert.That(selection.Index).IsEqualTo(2); + await Assert.That(selection.CursorIn(0)).IsEqualTo(0); + } + + [Test] + public async Task FocusPane_IgnoresAPaneTheScreenHasNot() + { + var selection = new ScreenSelection(2); + + selection.FocusPane(7); + selection.FocusPane(-1); + + await Assert.That(selection.Pane).IsEqualTo(0); + } + + /// + /// A focus seeded onto a pane that turns out to be empty is corrected by the first clamp, so the + /// screen can ask for a pane without knowing whether the config filled it. + /// + [Test] + public async Task FocusPane_OnAnEmptyPaneIsCorrectedByTheFirstClamp() + { + var selection = new ScreenSelection(3); + + selection.FocusPane(1); + selection.Clamp(Sizes(2, 0, 1)); + + await Assert.That(selection.Pane).IsEqualTo(2); + } + [Test] public async Task Move_StepsWithinThePane() { diff --git a/tests/SharpMUTerm.Tui.Tests/SettingsScreenViewTests.cs b/tests/SharpMUTerm.Tui.Tests/SettingsScreenViewTests.cs new file mode 100644 index 00000000..be8329b3 --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/SettingsScreenViewTests.cs @@ -0,0 +1,105 @@ +using SharpConsoleUI.Drivers; +using SharpMUTerm.Graphics; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// What a --view name actually opens, driven through the app's own screen table +/// (SettingsScreens()) and rendered headlessly. These are the only tests that see the wiring +/// rather than a renderer in isolation, which is what makes them the place to pin where a settings +/// key goes. +/// +/// +/// Serialised for the same reason is: rendering a snapshot +/// redirects Console.Out to capture the frame, and that is process-global. +/// +[NotInParallel] +public class SettingsScreenViewTests +{ + private const int Width = 120; + private const int Height = 34; + + private static readonly TerminalCapabilities Headless = + new(GraphicsProtocol.None, supportsTrueColor: true, supportsKittyGraphics: false, supportsSixel: false); + + private static string Frame(string view) + { + // The window system reads the console for input even headless; a null reader returns EOF. + Console.SetIn(TextReader.Null); + var app = new SharpMUTermApp(DemoScene.Build(), Headless, new HeadlessConsoleDriver(Width, Height)); + return app.RenderSnapshot(view); + } + + /// + /// F9 is a door into F5, not a screen of its own. Its Logging screen edited one character's + /// LoggingSettings — the active one, or else the first configured — while presenting as a + /// global preference; the settings now live in the character's form on F5, and the key that used to + /// open the old screen opens the new home. The logging view name survives with it, because + /// it is what the snapshot pipeline and the handbook both ask for. + /// + [Test] + public async Task TheLoggingViewOpensTheWorldsScreenOnTheCharactersLog() + { + var frame = Frame("logging"); + + await Assert.That(frame).Contains("Worlds & Characters"); + await Assert.That(frame).Contains("CHARACTER · Corvid"); + + // The character's own log format and the line that says whose it is. + await Assert.That(frame).Contains("Html"); + await Assert.That(frame).Contains("this character only"); + + // No Logging screen is left to open: the title and the section it used to draw are gone. + await Assert.That(frame).DoesNotContain("SESSION LOG"); + } + + /// + /// The screen names the key that opened it. F5 and F9 open the same screen, and a header that + /// always said F5 would be naming a key that — pressed on the F9-opened screen — re-opens it + /// somewhere else rather than closing it. + /// + [Test] + public async Task EachDoorIntoTheWorldsScreenOffersItsOwnKeyToClose() + { + await Assert.That(Frame("worlds")).Contains("F5"); + await Assert.That(Frame("logging")).Contains("F9"); + } + + /// + /// The -edit variant drives real keys into the screen it opened, so the still frame lands on + /// the value that view exists for: two steps past the name and the on-connect line, on the log. + /// + [Test] + public async Task TheLoggingEditViewLandsOnTheLogField() + { + var frame = Frame("logging-edit"); + + // The block caret is the ink colour painted on the accent; a resting field has no such cell. + await Assert.That(frame).Contains("Worlds & Characters"); + await Assert.That(Carets(frame)).IsGreaterThan(Carets(Frame("logging"))); + } + + /// + /// How many cells the frame paints in the block-caret colours. Counted rather than matched, because + /// what distinguishes a field being typed into from the same field at rest is the caret cell. + /// + private static int Carets(string frame) + { + var caret = $"{Sgr(ScreenPalette.Ink, 38)};{Sgr(ScreenPalette.Accent, 48)}"; + var count = 0; + var at = frame.IndexOf(caret, StringComparison.Ordinal); + while (at >= 0) + { + count++; + at = frame.IndexOf(caret, at + 1, StringComparison.Ordinal); + } + + return count; + } + + /// A palette hex as the truecolor SGR parameters the driver writes for it. + private static string Sgr(string hex, int layer) => + $"{layer};2;{Convert.ToInt32(hex.Substring(1, 2), 16)}" + + $";{Convert.ToInt32(hex.Substring(3, 2), 16)};{Convert.ToInt32(hex.Substring(5, 2), 16)}"; +} diff --git a/tests/SharpMUTerm.Tui.Tests/SettingsSessionEditTests.cs b/tests/SharpMUTerm.Tui.Tests/SettingsSessionEditTests.cs index 4b918b93..91619e35 100644 --- a/tests/SharpMUTerm.Tui.Tests/SettingsSessionEditTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/SettingsSessionEditTests.cs @@ -361,6 +361,87 @@ public async Task TheRealScreensBindTheirFieldsInTheOrderTheyAreDrawn() await Assert.That(world.Host).IsEqualTo("example.net"); } + /// + /// The security pane is reachable with the key the header advertises, and Space presses it — a pane + /// ⇥ could not get to would be two checkboxes nobody can use. It is the last pane, so ⇥ walks + /// worlds → characters → trigger sets → security, and Shift+⇥ comes straight back. + /// + [Test] + public async Task TabReachesTheWorldsSecurityCheckboxes_AndSpacePressesThem() + { + var world = new WorldDefinition + { + Name = "Aardwolf", + Host = "aardmud.org", + Characters = new List { new() { Name = "Kaz", TriggerSets = { "Comms" } } }, + }; + var worlds = new List { world }; + var sets = new List { new() { Name = "Comms" } }; + var session = new SettingsSession(selection => WorldsScreenRenderer.Model( + worlds, + sets, + selection.SelectionIn(WorldsScreenRenderer.WorldsPane), + selection.SelectionIn(WorldsScreenRenderer.CharactersPane))); + + for (var hop = 0; hop < 3; hop++) + { + await Assert.That(session.Handle(Key(ConsoleKey.Tab))).IsEqualTo(ScreenAction.Redraw); + } + + await Assert.That(session.Selection.Pane).IsEqualTo(WorldsScreenRenderer.SecurityPane); + + await Assert.That(session.Handle(Key(ConsoleKey.Spacebar))).IsEqualTo(ScreenAction.Redraw); + await Assert.That(world.UseTls).IsTrue(); + + session.Handle(Key(ConsoleKey.DownArrow)); + session.Handle(Key(ConsoleKey.Spacebar)); + await Assert.That(world.AllowInvalidCertificates).IsTrue(); + + // Esc is the screen's cancel, and it must take a security change with it. + await Assert.That(session.Handle(Key(ConsoleKey.Escape))).IsEqualTo(ScreenAction.Cancel); + session.Edits.Revert(); + await Assert.That(world.UseTls).IsFalse(); + await Assert.That(world.AllowInvalidCertificates).IsFalse(); + } + + /// + /// The character row's fields, in the order ⇥ steps through them: the log values are appended after + /// the two that were there, so the ordinals the screens and their tests already address are + /// untouched, and ⏎ still opens the name. + /// + [Test] + public async Task TheCharacterRowStepsFromItsNameThroughToItsLog() + { + var character = new CharacterDefinition { Name = "Kaz", OnConnect = "look" }; + var worlds = new List + { + new() + { + Name = "Aardwolf", + Host = "aardmud.org", + Characters = new List { character }, + }, + }; + var session = new SettingsSession(selection => WorldsScreenRenderer.Model( + worlds, + Array.Empty(), + selection.SelectionIn(WorldsScreenRenderer.WorldsPane), + selection.SelectionIn(WorldsScreenRenderer.CharactersPane))); + + session.Handle(Key(ConsoleKey.Tab)); + session.Handle(Key(ConsoleKey.Enter)); + await Assert.That(session.Focus().Edit!.Value.Field).IsEqualTo(WorldsScreenRenderer.CharacterNameField); + + session.Handle(Key(ConsoleKey.Tab)); + session.Handle(Key(ConsoleKey.Tab)); + await Assert.That(session.Focus().Edit!.Value.Field).IsEqualTo(WorldsScreenRenderer.LogFormatField); + + // ↑↓ cycle an enum, which is what makes the log format usable without typing it. + session.Handle(Key(ConsoleKey.DownArrow)); + session.Handle(Key(ConsoleKey.Enter)); + await Assert.That(character.Logging.Format).IsNotEqualTo(LogFormat.None); + } + [Test] public async Task EditingATriggersPatternRecompilesItsMatcher() { diff --git a/tests/SharpMUTerm.Tui.Tests/WorldsScreenRendererTests.cs b/tests/SharpMUTerm.Tui.Tests/WorldsScreenRendererTests.cs index e9752d7a..5527872e 100644 --- a/tests/SharpMUTerm.Tui.Tests/WorldsScreenRendererTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/WorldsScreenRendererTests.cs @@ -96,6 +96,81 @@ public async Task Render_SelectedWorldFieldsShown() await Assert.That(text).Contains("TLS on"); } + /// + /// The world's two security flags, as the two checkboxes that replaced the read-only line + /// summarising them. The world summary at the top of the column still reads TLS on, which is + /// where a one-glance answer belongs — the rows are where it is changed. + /// + [Test] + public async Task Render_SecurityIsTwoCheckboxesUnderTheSecurityLabel() + { + var lines = WorldsScreenRenderer.Render(Worlds(), TriggerSets(), selectedWorld: 0, selectedCharacter: 0); + var tls = lines.Single(l => l.Contains("security") && l.Contains("TLS")); + var certificates = lines.Single(l => l.Contains("accept invalid certificates")); + + await Assert.That(tls).Contains("[[x]]"); + await Assert.That(certificates).Contains("[[ ]]"); + await Assert.That(lines.Any(l => l.Contains("certs strict"))).IsFalse(); + } + + /// + /// The certificate row while validation is actually off: the warn ink and the ▲ a refused + /// value gets, and a consequence rather than a restatement of the label. + /// + [Test] + public async Task Render_TurningOffCertificateValidationIsDrawnAsAWarning() + { + var worlds = Worlds(); + worlds[0].AllowInvalidCertificates = true; + + var row = WorldsScreenRenderer.Render(worlds, TriggerSets(), 0, 0) + .Single(l => l.Contains("accept invalid certificates")); + + await Assert.That(row).Contains("[[x]]"); + await Assert.That(row).Contains(ScreenPalette.Warn); + await Assert.That(row).Contains("▲ anyone can impersonate this host"); + } + + /// + /// A character's log settings, in that character's own form. This is what the F9 Logging screen + /// used to draw for whichever character happened to be active, without naming it. + /// + [Test] + public async Task Render_CharacterFormShowsThatCharactersLog() + { + var worlds = Worlds(); + worlds[0].Characters[0].Logging = new LoggingSettings + { + Format = LogFormat.Html, + Directory = "/var/log/mu", + }; + + var lines = WorldsScreenRenderer.Render(worlds, TriggerSets(), selectedWorld: 0, selectedCharacter: 0); + + await Assert.That(lines.Any(l => l.Contains("CHARACTER · Corvid"))).IsTrue(); + await Assert.That(lines.Any(l => l.Contains("log") && l.Contains("Html"))).IsTrue(); + await Assert.That(lines.Any(l => l.Contains("log folder") && l.Contains("/var/log/mu"))).IsTrue(); + + // The row says whose settings these are, for the reader who arrived by the F9 they used to + // live behind — where the same two values silently belonged to somebody. + await Assert.That(lines.Any(l => l.Contains("this character only"))).IsTrue(); + } + + /// + /// The other character's log, on the same screen, showing its own values: the second half of "whose + /// settings are these" is that picking a different character shows a different answer. + /// + [Test] + public async Task Render_AnUnsetLogReadsAsNoneAndTheDefaultFolder() + { + var lines = WorldsScreenRenderer.Render(Worlds(), TriggerSets(), selectedWorld: 0, selectedCharacter: 1); + + await Assert.That(lines.Any(l => l.Contains("CHARACTER · Rookery"))).IsTrue(); + await Assert.That(lines.Any(l => l.Contains("log") && l.Contains(LogFormat.None.ToString()))).IsTrue(); + await Assert.That(lines.Any(l => l.Contains("log folder") + && l.Contains(WorldsScreenRenderer.DefaultDirectory))).IsTrue(); + } + [Test] public async Task Render_CharactersTableShowsOfflineAndLoginMode() { From f95c4508e4e8f6f0ee82b67aa8d43185aee06d97 Mon Sep 17 00:00:00 2001 From: Harry Cordewener Date: Tue, 28 Jul 2026 21:31:47 -0500 Subject: [PATCH 17/23] Settings screens: show the options a field will accept MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Replacing F2's route radios with a plain field fixed a closed-list problem and created a discoverability one: at rest the field showed only "Chat", and ↑↓ cycled the known windows one at a time without ever revealing that main, pages and trade existed. Radios over-constrained; a bare field under-shows. A field with known options now draws them while it is open. Built once in ScreenChrome, so all eleven such fields gained it -- route, both highlight colours, script, log format, encoding, ambiguous width, newline key and dictionary (the last two turned out to carry no choices at all, so Text gained an optional list). Typing filters, but a buffer that names a choice keeps the whole list: a field opens on its committed value, so a plain filter would collapse to one entry the instant it was drawn. A filter matching nothing says "a new value is allowed" on an open list and "nothing matches" on a closed one, in neither case using the warning ink -- refusal belongs to the validator at ⏎. ↑↓ walk the narrowed list rather than cycling blind, and the highlight and the buffer are one thing rather than two cursors, which would give ⏎ two meanings inside the only modal state these screens have. It overlays rather than pushes rows down, which was forced: the worlds view sizes a grid row from its line count, so a growing list would resize the screen on ⏎, and F2's editor is already tall enough that pushed rows fall off the bottom. It opens upward when there is no room below. Closed lists say "these values only", open ones "suggestions", drawn from the field's own validator rather than a flag a renderer sets. Checked the framework first, as asked: SharpConsoleUI does have a DropdownControl, and it cannot serve this. Its value is an index into its items, typing is a timed prefix jump rather than entry, and there is no path to a value outside the list -- it is a picker, not a combobox. Route exists precisely to name a window that does not exist yet. Using it for the closed fields alone would also mean rebuilding those panes as control trees, when the whole settings architecture is pure renderers producing markup with Render(...) merging for tests. 946 tests pass, up from 929. Two pinned assertions changed, both direct consequences of ↑↓ walking a filtered list, and both strengthened: one now asserts which entry is marked rather than merely present. Known cosmetic wart: a dropdown covering through F2's attrs row leaves the second line of its two-row legend orphaned below the shadow. Co-Authored-By: Claude Opus 5 (1M context) --- CLAUDE.md | 2 +- docs/HANDOFF.md | 71 +++- src/SharpMUTerm.Tui/AliasesScreenRenderer.cs | 2 +- src/SharpMUTerm.Tui/KeypadScreenRenderer.cs | 2 +- src/SharpMUTerm.Tui/OptionsScreenRenderer.cs | 30 +- src/SharpMUTerm.Tui/ScreenChrome.cs | 194 ++++++++- src/SharpMUTerm.Tui/ScreenField.cs | 161 +++++-- src/SharpMUTerm.Tui/ScreenPalette.cs | 22 + src/SharpMUTerm.Tui/SettingsSession.cs | 23 +- src/SharpMUTerm.Tui/SharpMUTermApp.cs | 79 +++- src/SharpMUTerm.Tui/TimersScreenRenderer.cs | 2 +- src/SharpMUTerm.Tui/TriggersScreenRenderer.cs | 9 +- src/SharpMUTerm.Tui/WorldsScreenRenderer.cs | 10 +- .../ScreenChoiceListTests.cs | 398 ++++++++++++++++++ .../SharpMUTerm.Tui.Tests/ScreenFieldTests.cs | 12 +- .../ScreenFooterTests.cs | 20 +- .../TriggersScreenEditingTests.cs | 18 +- 17 files changed, 987 insertions(+), 68 deletions(-) create mode 100644 tests/SharpMUTerm.Tui.Tests/ScreenChoiceListTests.cs diff --git a/CLAUDE.md b/CLAUDE.md index 6468275b..34471995 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -32,7 +32,7 @@ fallbacks) for inline images/maps. ## Repository state **M1 delivered, plus substantial M2–M4 work.** `SharpMUTerm.slnx` builds all ten projects on -`net10.0`; the solution has **912 tests**, all passing. In place: +`net10.0`; the solution has **946 tests**, all passing. In place: - **Core** — `AnsiParser` (SGR 16/256/truecolor), styled-line + `ScrollbackBuffer` model, `TcpTransport` (TLS + IPv6), `TelnetSession` (wraps TelnetNegotiationCore **2.5.3**), diff --git a/docs/HANDOFF.md b/docs/HANDOFF.md index c733f6f6..82dec631 100644 --- a/docs/HANDOFF.md +++ b/docs/HANDOFF.md @@ -4,8 +4,8 @@ Context for whoever (human or agent) picks up this work next. - **Repository:** `SharpMUSH/SharpMUTerm` - **Start from:** a fresh branch off `main` -- **Tests:** 912 across the solution (338 Core / 83 Graphics / 42 Scripting / - 28 Web / 421 Tui), all passing; `dotnet build SharpMUTerm.slnx` clean (0 warnings +- **Tests:** 946 across the solution (338 Core / 83 Graphics / 42 Scripting / + 28 Web / 455 Tui), all passing; `dotnet build SharpMUTerm.slnx` clean (0 warnings from this repo; building against a local SharpConsoleUI clone surfaces 2 upstream NuGet advisory warnings for AngleSharp, which are the framework's, not ours) @@ -45,10 +45,12 @@ works. - **New items:** trigger and alias arrive enabled, timer arrives **disabled**. A timer is the only one of the four that acts without being provoked; the others wait for output or for a keypress. -- **F2's route-to radios and highlight-colour picker** are live, as `Choice` and +- **F2's route-to and highlight-colour picker** are live, as `WindowName` and `Colour` fields on the *rule's own list row* (ordinals: pattern, route, - highlight fg, highlight bg). ↑↓ cycle them, which is exactly radio and palette - semantics. + highlight fg, highlight bg). While one is open the chrome draws its candidates + beneath it and ↑↓ walk them — see *Dropdowns* under Critical Gotchas. The route + went radios → bare field → dropdown: radios could only ever re-use a window that + already existed, and a bare field showed one value and hid the other three. - **F2 reaches every action a trigger has** — rewrite, respond, script, added attributes and case sensitivity all have UI now, so nothing the README advertises is JSON-only any more. See *Settings screens* under Critical Gotchas for the @@ -182,7 +184,8 @@ Things that will waste your time if you don't know them. whatever config is on the machine — and a saved config in `~/.config/SharpMUTerm/` will quietly replace the demo worlds, so you end up checking your own data and calling it the demo. Drop the flag only when reproducing something specific to a real setup. -- **Snapshot view names:** `worlds`/`settings`, `triggers`, `aliases`, `timers`, +- **Snapshot view names:** `worlds`/`settings`, `triggers`, `route`, `highlight`, + `aliases`, `timers`, `keypad`, `textansi`, `input`, `logging`, `freeze`, `spawn`, `split`, `move`, `drag`, `history`, `menu`, `menu-split`, plus the default (no `--view`) workspace. Extra state toggles: `collapsed`, `prefix`, `timestamps`. Any settings screen also @@ -378,7 +381,8 @@ What the framework actually provides (read at v2.5.14, not assumed): closes. ⌃S always saves (committing an open field first, and refusing if that field won't validate). Esc cancels the screen — except mid-edit, where it abandons the buffer and leaves the screen up. Inside an edit: typing inserts, - Backspace/Delete remove, ←→/Home/End move the caret, ↑↓ cycle an enum's choices, + Backspace/Delete remove, ←→/Home/End move the caret, ↑↓ walk the drawn candidate + list (typing narrows it), ⇥ commits and steps to the row's next field, ⏎ commits. - **Validation is at commit, not per keystroke.** Any character can be typed; ⏎/⇥/⌃S validate. A rejected value keeps the edit open, marks the field with the @@ -390,8 +394,8 @@ What the framework actually provides (read at v2.5.14, not assumed): by `ScreenChrome.ReadOnly` in the muted ink with **no** well. Opening a field keeps the same well and adds the accent block caret, so ⏎ deepens the affordance already on screen instead of conjuring one. The rule is scoped to rows that read - `label value` — a checkbox and a radio group already carry an affordance of - their own, so F2's route radios and F5's list rows are left alone. + `label value` — a checkbox already carries an affordance of its own, so the + checkbox rows and F5's list rows are left alone. `ScreenReadOnlyTests` pins both halves; add a read-only row and it must go through `ReadOnly`, or the well/no-well counts stop matching. - **A derived indicator is never a checkbox.** A checkbox promises Space does @@ -426,7 +430,8 @@ What the framework actually provides (read at v2.5.14, not assumed): reads `model.HasEditableRow`, so a screen physically cannot advertise `⏎ edit` without offering one; `ScreenCursorTests` asserts the *if and only if* both ways. A button row deliberately doesn't count as editable — ⏎ activates it, but it - edits nothing. `↑↓ choose` appears only for a field that has `Choices`. + edits nothing. `↑↓ pick from list` appears only while the open field's dropdown + actually has entries in it — narrow the list to nothing and the hint goes too. - **Footer actions are derived too.** `ScreenChrome.Actions(accent, focus)` swaps `[Esc] Cancel` / `[⏎] Save` for `[Esc] Revert` / `[⏎] Commit` while a field is open, because neither key closes the screen at that moment. Every `FooterLine` @@ -452,11 +457,11 @@ What the framework actually provides (read at v2.5.14, not assumed): one spelling; control characters refused, because each is drawn and typed on one row); `AddAttributes` is a `ScreenField.Flags` **multi-select** — deliberately not a `Choice`, and deliberately carrying **no `Choices`**, because - ↑↓ step one-of-N and bold-and-underline is not one of anything (the `↑↓ choose` + ↑↓ step one-of-N and bold-and-underline is not one of anything (the `↑↓ pick from list` hint derives from `Choices`, so a cycling field would advertise dead keys). Its vocabulary is drawn as a two-row **legend** under the `attrs` well, lit per attribute and following the *buffer* while the field is open — the same rule the - route radios follow. Eight `ScreenToggle` rows were rejected: they would be eight + route dropdown follows. Eight `ScreenToggle` rows were rejected: they would be eight cursor stops for a setting most rules never touch, and a `ScreenRow` holds at most one checkbox, so a horizontal row of them could never be one navigable row anyway. `Trigger.CaseSensitive` is the editor pane's **third** checkbox, appended after @@ -475,6 +480,48 @@ What the framework actually provides (read at v2.5.14, not assumed): - Pane shape: F4/F7/F8 are single-pane (no ⇥); **F5 has four** (worlds → characters → trigger sets → the world's security checkboxes); the rest have two. +### Dropdowns (a field's candidate list) + +- **`ScreenChrome.Choices(column, edit, width)` is the whole feature**, called once + per block that draws fields (all six renderers do). It finds the open field by the + **block caret** `ScreenChrome.Field` paints — only one field of one row is ever + open, and only the column drawing it paints that — so a block that isn't drawing + the open edit comes back untouched and the wiring is one line per column. +- **It overlays, it does not push.** The block *replaces* the rows next to the + field, so a column's line count is identical open and closed. That is forced: + `WorldsScreenView` sizes a grid row from `FormColumn`'s count (a growing list + would resize the whole screen on ⏎), and F2's editor already runs to two dozen + rows (pushed-down rows would fall off the bottom, checkboxes included). It opens + **downward**, and **upward** when there aren't enough rows below — F5's log format + and F7's ambiguous width are both second-from-last in their block. The caption + keeps the edge nearest the field (`▾` below, `▴` above) and a one-row **shadow** + closes the far edge, so the pane's own rows continuing past the block read as + behind it. +- **Typing filters; ↑↓ walk what is left.** `ScreenField.Matching` is the one + definition both use — a buffer that *names* a choice keeps the whole list (a field + opens on its committed value, so a plain filter would collapse the list the moment + it was drawn), anything else is a substring search. `ScreenField.Cycle` walks that + same list, which is why `pa` then ↓ lands on `pages`, and why ↓ on a buffer + matching nothing is **swallowed** rather than overwriting a name being typed for + the first time. The highlight and the buffer are deliberately one thing, not two + cursors: a separate highlight would give ⏎ two meanings and Esc two levels. +- **Open vs closed is carried, not guessed.** `ScreenField.ClosedChoices` is true + only for `Choice` and `Enumeration` — the two whose validators actually refuse + everything else. Open lists are captioned `suggestions`, closed ones `these values + only`, and the empty-filter case reads `nothing matches — a new value is allowed` + vs plain `nothing matches`. Neither uses `ScreenPalette.Warn`: a refusal belongs + to the validator at ⏎, and the palette has two shouting cases already. +- **Capped at `ScreenChrome.MaxChoiceRows` (6)**, with the caption saying so + (`suggestions 6 of 17`) and the window scrolling to keep the marked entry in it, + or the eleventh colour would be unreachable to the eye. +- **`newline key` and `dictionary` (F8) grew suggestion lists**, since `ScreenField.Text` + now takes an optional `known`. Both stay open: the chords a terminal can deliver + and the locales a speller has installed are not this screen's to close. +- **Snapshot states:** `triggers-edit` (open list, mark moved), `route-edit` + (narrowed to one), `highlight-edit` (17 capped to 6), `logging-edit` (closed, + drawn upward), `textansi-edit` / `input-edit` (F7/F8; their scripts step the + cursor down to a value row first, because ⏎ on a checkbox row saves and closes). + ### TelnetNegotiationCore - Version in use is **2.5.3** (fluent builder API), **not** the 1.0.0 the original diff --git a/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs b/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs index eeed6471..5da64cf6 100644 --- a/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs @@ -301,7 +301,7 @@ private static List BuildEditor(Alias alias, ScreenFocus cursor, int sel : "[dim][[ ]] case sensitive[/]"; lines.Add(ScreenChrome.Cursor(caseRow, cursor.IsOn(1, 0), ColumnWidth)); - return lines; + return ScreenChrome.Choices(lines, cursor.Edit, ColumnWidth); } private static string FirstLine(string text) diff --git a/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs b/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs index 888d78eb..e3a74648 100644 --- a/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs @@ -275,7 +275,7 @@ internal static List HotkeysColumn( lines.Add(string.Empty); lines.AddRange(ScreenChrome.Buttons(Buttons(sets, selected), cursor, 0, macros.Count, ColumnWidth)); - return lines; + return ScreenChrome.Choices(lines, cursor.Edit, ColumnWidth); } private static string NumpadRow(int[] digits, IReadOnlyList macros) diff --git a/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs b/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs index 3746ab40..485f3594 100644 --- a/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs @@ -176,9 +176,16 @@ internal static List BodyColumn( navigable++; } - return lines; + return ScreenChrome.Choices(lines, cursor.Edit, width > 0 ? width : ChoiceListWidth); } + /// + /// How wide a dropdown may run on a screen rendered without a width — the merged + /// path the unit tests use. The live view always passes a real + /// width, so this only keeps the width-agnostic fallback from letting a list run unbounded. + /// + private const int ChoiceListWidth = 60; + /// /// The screen's one navigable pane: every row that isn't a spacer or a section header, in display /// order, each carrying whatever config bindings it was built with — the checkbox Space flips and @@ -291,16 +298,33 @@ internal static OptionsScreen InputSpellcheckScreen(InputSettings? input = null) new("keep per-tab drafts", null, settings.KeepDrafts, null, ScreenToggle.Bind(() => settings.KeepDrafts, v => settings.KeepDrafts = v)), new("newline key", settings.NewlineKey, null, null, null, - ScreenField.Text("newline key", () => settings.NewlineKey, v => settings.NewlineKey = v)), + ScreenField.Text( + "newline key", () => settings.NewlineKey, v => settings.NewlineKey = v, NewlineKeys)), new(string.Empty, null, null), new("├ SPELLCHECK", null, null), new("check spelling", null, settings.CheckSpelling, null, ScreenToggle.Bind(() => settings.CheckSpelling, v => settings.CheckSpelling = v)), new("dictionary", settings.Dictionary, null, null, null, - ScreenField.Text("dictionary", () => settings.Dictionary, v => settings.Dictionary = v)), + ScreenField.Text( + "dictionary", () => settings.Dictionary, v => settings.Dictionary = v, Dictionaries)), }); } + /// + /// The chords worth offering for the newline key. Suggestions, not the permitted set: what a + /// terminal actually delivers for a modified Enter varies by emulator, so a closed list would refuse + /// the one chord a given terminal can send. Listing them is what stops the field being typed blind. + /// + private static readonly string[] NewlineKeys = { "Shift+Enter", "Ctrl+Enter", "Alt+Enter", "Ctrl+J" }; + + /// + /// The dictionaries worth offering. Open for the same reason: the speller loads whichever locale is + /// installed on the machine, and a list this screen closed would be a list of what its author + /// happened to have. + /// + private static readonly string[] Dictionaries = + { "en_US", "en_GB", "de_DE", "fr_FR", "es_ES", "nl_NL", "pt_BR", "sv_SE" }; + /// The F7 "Text & ANSI" screen body. public static List TextAnsi() => Render(TextAnsiScreen()); diff --git a/src/SharpMUTerm.Tui/ScreenChrome.cs b/src/SharpMUTerm.Tui/ScreenChrome.cs index 1e877991..6bd40bc3 100644 --- a/src/SharpMUTerm.Tui/ScreenChrome.cs +++ b/src/SharpMUTerm.Tui/ScreenChrome.cs @@ -30,7 +30,7 @@ internal static string Hints( if (focus?.Edit is { } edit) { var editing = EditingHints - + (edit.HasChoices ? ChoiceHint : string.Empty) + + (edit.VisibleChoices.Count > 0 ? ChoiceHint : string.Empty) + (edit.RowFields > 1 ? NextFieldHint : string.Empty); return $"[{ScreenPalette.Label}]{editing} · [/][{ScreenPalette.Accent}]{fkey}[/]" + $"[{ScreenPalette.Label}] close [/]"; @@ -70,11 +70,18 @@ internal static string Hints( internal const string NextFieldHint = " · ⇥ next field"; /// - /// Added to only when the open field is one of a fixed set of values — - /// a route, an encoding, a highlight colour — because only those have anything for ↑↓ to step - /// through. A free-text field would be claiming a key that does nothing. + /// Added to only while the open field's dropdown actually has entries in + /// it — because ↑↓ walk exactly those entries and nothing else. It says pick from list rather + /// than the older choose because the list is now on screen: the keys move through what the + /// user can see, and put the entry they land on into the field. + /// + /// It is derived from , not from whether the field has + /// choices at all, so it disappears the moment a typed value narrows the list to nothing — the + /// point at which ↑↓ genuinely stop doing anything (see ). A hint + /// that stayed up over an empty list would be the same lie the ⏎ edit rule already forbids. + /// /// - internal const string ChoiceHint = " · ↑↓ choose"; + internal const string ChoiceHint = " · ↑↓ pick from list"; /// What the footer's Esc chip does while the screen is navigating. internal const string CancelAction = "[[Esc]] Cancel"; @@ -164,6 +171,183 @@ internal static string Field(string display, ScreenFieldEdit? edit) /// private static string Well(string display) => $"[on {ScreenPalette.FieldBg}]{display} [/]"; + /// + /// The block caret paints, which is what hangs the + /// dropdown off. Exactly one field of one row can be open at a time, and only the column that draws + /// that field paints this — so finding it is how a column knows the open edit is *its* edit, without + /// every renderer having to hand back the line number it drew the value on. + /// + private static readonly string CaretMark = $"[{ScreenPalette.Ink} on {ScreenPalette.Accent}]"; + + /// + /// The most candidates a dropdown lists at once. Seventeen colour names is more rows than F2's + /// editor pane has to spare beside the pattern, the highlight rows and the three action templates, + /// so the list is capped and the caption says what it is capped to (6 of 17) — a list that + /// silently showed a third of itself would be worse than no list. + /// + internal const int MaxChoiceRows = 6; + + /// What the dropdown calls itself when the field will take values outside the list. + internal const string OpenChoicesCaption = "suggestions"; + + /// What it calls itself when the list is the permitted set and nothing else will commit. + internal const string ClosedChoicesCaption = "these values only"; + + /// + /// What an open field's dropdown says when the buffer matches none of its entries. It names the + /// state as *legal*, because on these fields it is: the spawn windows are defined by what routes to + /// them, so a name matching nothing is how the next one is created. An empty list with nothing + /// written beside it would read as a refusal. + /// + internal const string NoMatchOpen = "nothing matches — a new value is allowed"; + + /// + /// What a closed field's dropdown says instead. It states the fact and stops there: the value is + /// refused at ⏎ by the field's own validator, which reports it against the row in + /// , and a second warning drawn before the user has finished typing + /// would spend that colour on a value they may still be halfway through. + /// + internal const string NoMatchClosed = "nothing matches"; + + /// How far the dropdown is inset from the column's edge, so it hangs under the field. + private const string ChoiceIndent = " "; + + /// + /// Draws an open field's candidate list into , and hands the column back. + /// Every screen calls this once on each block that draws fields; a block that isn't drawing the open + /// edit has no caret in it and comes back untouched, so the wiring is one line per column and cannot + /// be pointed at the wrong field. + /// + /// The list is an overlay: it replaces the rows next to the field instead of pushing them + /// down. Pushing was the obvious shape and is the wrong one here. F5's character form is a grid row + /// sized to its own line count, so a list that grew it would resize the whole screen the instant ⏎ + /// was pressed; F2's editor pane already runs to two dozen rows, so on a short terminal the rows + /// pushed off the bottom would include the three checkboxes the cursor can still reach. An overlay + /// changes no geometry at all — the rows it covers are visible again the moment the field closes, + /// and none of them can be scrolled out of existence in the meantime. + /// + /// + /// It opens downward, and upward when there aren't enough rows below it — F5's log format is the + /// second-to-last line of its form, and a list that ran off the end of the block would simply not be + /// drawn. The caption keeps its edge against the field either way (▾ below, ▴ above), + /// so the block reads as attached to the well rather than as content that happens to be near it. + /// + /// + /// The block's lines, as the renderer has just built them. + /// The screen's open edit, or null while it is navigating. + /// The column's width; the list is content-sized and never drawn wider. + internal static List Choices(List column, ScreenFieldEdit? edit, int width) + { + ArgumentNullException.ThrowIfNull(column); + + if (edit is not { HasChoices: true } open) + { + return column; + } + + var anchor = column.FindIndex(l => l.Contains(CaretMark, StringComparison.Ordinal)); + if (anchor < 0) + { + return column; + } + + var (caption, entries) = ChoiceContent(open); + var height = entries.Count + 2; // the caption, and the shadow closing the far edge + + // Below when the rows are there, above when they aren't, and — for a block shorter than the + // list itself — below anyway, extending it, because a list drawn nowhere helps nobody. + var above = anchor + 1 + height > column.Count && anchor - height >= 0; + var start = above ? anchor - height : anchor + 1; + + // The caption keeps the edge nearest the field and names the direction; the shadow takes the + // far one. Reading order follows the block either way, which is what makes a list drawn upward + // legible at all. + var block = new List<(string Content, string Background)>(height) + { + ($"[{ScreenPalette.Label}]{(above ? "▴" : "▾")} {caption}[/]", ScreenPalette.MenuBg), + }; + block.InsertRange(above ? 0 : 1, entries); + + var inner = block.Max(row => MarkupText.VisibleLength(row.Content)); + if (width > ChoiceIndent.Length + 2) + { + inner = Math.Min(inner, width - ChoiceIndent.Length - 2); + } + + var lines = block.ConvertAll(row => MenuLine(row.Content, row.Background, inner)); + lines.Insert(above ? 0 : lines.Count, Shadow(inner)); + + for (var i = 0; i < lines.Count; i++) + { + var at = start + i; + if (at < column.Count) + { + column[at] = lines[i]; + } + else + { + column.Add(lines[i]); + } + } + + return column; + } + + /// + /// The dropdown's caption and its drawn entries. The entries are the choices the buffer narrows to + /// () — the very list ↑↓ walk — windowed to + /// around the one the buffer names, so the marked entry is always on + /// screen however far down a seventeen-colour palette it sits. + /// + private static (string Caption, List<(string Content, string Background)> Entries) ChoiceContent( + ScreenFieldEdit open) + { + var all = open.Choices!; + var visible = open.VisibleChoices; + var caption = open.ClosedChoices ? ClosedChoicesCaption : OpenChoicesCaption; + var entries = new List<(string, string)>(); + + if (visible.Count == 0) + { + return ($"{caption} {(open.ClosedChoices ? NoMatchClosed : NoMatchOpen)}", entries); + } + + var marked = ScreenField.IndexOf(visible, open.Text); + var take = Math.Min(MaxChoiceRows, visible.Count); + var first = visible.Count <= take + ? 0 + : Math.Clamp(Math.Max(marked, 0) - ((take - 1) / 2), 0, visible.Count - take); + + for (var i = first; i < first + take; i++) + { + var name = MarkupText.Escape(visible[i]); + entries.Add(i == marked + ? ($"[{ScreenPalette.Accent}]▸[/] [{ScreenPalette.Value}]{name}[/]", ScreenPalette.MenuSelectedBg) + : ($" [{ScreenPalette.Label}]{name}[/]", ScreenPalette.MenuBg)); + } + + // The count is only worth a caption when it is news: the list is capped, or the buffer has + // narrowed it. "4 of 4" would just be noise on every route field ever opened. + return (take < all.Count ? $"{caption} {take} of {all.Count}" : caption, entries); + } + + /// + /// One row of the floating block: its own markup, inset from the column's edge, padded to the + /// block's shared inner width on a raised background. The block hugs its content rather than + /// spanning the pane, because a full-width band is what the pane's own rows look like and the one + /// thing this block must not be mistaken for is a row. + /// + private static string MenuLine(string content, string bg, int inner) => + $"{ChoiceIndent}[on {bg}] {MarkupText.PadVisible(content, Math.Max(0, inner))} [/]"; + + /// + /// The block's far edge, offset a cell the way a dropped shadow is. It costs one row and buys the + /// thing a cell grid cannot otherwise say: that the pane's own rows continuing below (or above) the + /// list are *behind* it and not part of it. + /// + private static string Shadow(int inner) => + $"{ChoiceIndent} [on {ScreenPalette.MenuShadow}]{new string(' ', Math.Max(0, inner + 1))}[/]"; + /// /// Draws a value the keyboard cannot change where it is drawn — a world's TLS/certificate line, a /// character's password or session state, a numpad cell mirroring a binding elsewhere. It gets the diff --git a/src/SharpMUTerm.Tui/ScreenField.cs b/src/SharpMUTerm.Tui/ScreenField.cs index 8585f5e4..a092c5bb 100644 --- a/src/SharpMUTerm.Tui/ScreenField.cs +++ b/src/SharpMUTerm.Tui/ScreenField.cs @@ -18,12 +18,38 @@ namespace SharpMUTerm.Tui; /// /// How many fields the row holds — the chrome only offers ⇥ when there is a next field to step to. /// -/// -/// Whether the open field offers a fixed set of values, so the chrome only offers ↑↓ when there is -/// something for them to step through. +/// +/// The values the open field knows about, or null when it knows none. Carried on the edit rather than +/// looked up again per renderer, because every screen now draws them +/// () as well as stepping through them, and a list the chrome +/// re-derived could disagree with the list ↑↓ actually walks. +/// +/// +/// Whether is the permitted set rather than a shortlist of suggestions — +/// the difference between a log format (only these four values exist) and a window name (these are +/// the windows in use; typing a fifth is how the fifth comes into being). The chrome says which, +/// because a list drawn the same way for both would imply a closed set where anything is legal. /// internal readonly record struct ScreenFieldEdit( - int Field, string Text, int Caret, string? Error, int RowFields = 1, bool HasChoices = false); + int Field, + string Text, + int Caret, + string? Error, + int RowFields = 1, + IReadOnlyList? Choices = null, + bool ClosedChoices = false) +{ + /// Whether the open field knows any values at all, whatever the buffer currently is. + internal bool HasChoices => Choices is { Count: > 0 }; + + /// + /// The choices the buffer currently narrows to — what the dropdown lists and what ↑↓ step through, + /// which are deliberately the same list (see ). It can be empty + /// while is true: a buffer naming something new matches nothing, which is + /// a legal state on an open field and the reason the chrome reads them apart. + /// + internal IReadOnlyList VisibleChoices => ScreenField.Matching(Choices, Text); +} /// /// An editable value on a settings row: how to read it as text, whether a typed string is a legal @@ -43,46 +69,120 @@ internal readonly record struct ScreenFieldEdit( /// Returns null when a buffer is a legal value, else why it isn't. /// Writes a buffer that has already accepted. /// Captures the current value, returning the action that restores it. -/// The legal values when the field is an enumeration, else null. +/// The values the field knows about, else null. +/// +/// Whether is the permitted set. A closed field refuses anything +/// outside it (, ); an open one merely suggests +/// (, , ), and its validator says so +/// independently. It is carried here rather than inferred, because the chrome draws the two lists +/// differently and a renderer guessing from the field's shape would eventually guess wrong. +/// internal readonly record struct ScreenField( string Label, Func Get, Func Validate, Action Set, Func Snapshot, - IReadOnlyList? Choices = null) + IReadOnlyList? Choices = null, + bool ClosedChoices = false) { /// Longest rejection message kept; regex parser errors run to several lines otherwise. private const int MaxErrorLength = 44; /// - /// The choice steps from , wrapping at both - /// ends — how ↑↓ move through an enum field. Null when the field isn't an enumeration. A buffer - /// that isn't one of the choices (half-typed) steps from the start. + /// The choices a buffer narrows to: everything, when the buffer is empty or already names + /// one of them, and otherwise every choice containing it, case-insensitively, in the field's own + /// order. + /// + /// The exception for an exact name is what makes this usable rather than merely correct. A field + /// opens on its committed value, so a plain filter would collapse the list to the one entry already + /// selected the instant it was drawn — the dropdown would never show you the alternatives it exists + /// to show. A buffer that names a choice is a selection, so the whole list stays up with + /// that entry marked; a buffer that doesn't is a search, so the list narrows to what it matched. + /// + /// + /// Substring rather than prefix: colour names are remembered by their middles as often as their + /// starts (gre finding green and grey is the point), and the list is short + /// enough that a loose match never floods it. + /// /// - internal string? Cycle(string current, int direction) + internal static IReadOnlyList Matching(IReadOnlyList? choices, string buffer) { - if (Choices is not { Count: > 0 } choices) + if (choices is not { Count: > 0 }) { - return null; + return Array.Empty(); + } + + var trimmed = buffer.Trim(); + if (trimmed.Length == 0 || IndexOf(choices, trimmed) >= 0) + { + return choices; } - var at = -1; + var matched = new List(); + foreach (var choice in choices) + { + if (choice.Contains(trimmed, StringComparison.OrdinalIgnoreCase)) + { + matched.Add(choice); + } + } + + return matched; + } + + /// Where a buffer sits in a list of choices, matched by name, or -1 when it names none. + internal static int IndexOf(IReadOnlyList choices, string buffer) + { + ArgumentNullException.ThrowIfNull(choices); + + var trimmed = buffer.Trim(); for (var i = 0; i < choices.Count; i++) { - if (string.Equals(choices[i], current, StringComparison.OrdinalIgnoreCase)) + if (string.Equals(choices[i], trimmed, StringComparison.OrdinalIgnoreCase)) { - at = i; - break; + return i; } } - var next = at < 0 ? (direction > 0 ? 0 : choices.Count - 1) : at + direction; - return choices[((next % choices.Count) + choices.Count) % choices.Count]; + return -1; + } + + /// + /// The choice steps from , wrapping at both + /// ends — how ↑↓ move through the drawn list. Null when there is nothing to step to. + /// + /// It walks rather than every choice, so ↑↓ move through exactly the entries + /// the dropdown is showing: typing pa narrows the list to pages and ↓ takes it. A + /// buffer that matched nothing has an empty list and returns null — the keystroke is swallowed + /// rather than overwriting a name being typed for the first time, which on an open field is the + /// whole reason the field is open. + /// + /// + internal string? Cycle(string current, int direction) + { + var visible = Matching(Choices, current); + if (visible.Count == 0) + { + return null; + } + + var at = IndexOf(visible, current); + var next = at < 0 ? (direction > 0 ? 0 : visible.Count - 1) : at + direction; + return visible[((next % visible.Count) + visible.Count) % visible.Count]; } - /// Free text that may not be blank — a name, a host, a dictionary. Trimmed on commit. - internal static ScreenField Text(string label, Func get, Action set) + /// + /// Free text that may not be blank — a name, a host, a dictionary. Trimmed on commit. + /// + /// is offered the way offers the spawn windows: + /// values worth naming, not the permitted set. A dictionary is whichever locale the speller has + /// installed and a newline key is whatever chord the terminal delivers, so neither can be closed — + /// but neither should be typed blind either, which is exactly what a suggestion list is for. + /// + /// + internal static ScreenField Text( + string label, Func get, Action set, IReadOnlyList? known = null) { ArgumentNullException.ThrowIfNull(get); ArgumentNullException.ThrowIfNull(set); @@ -92,7 +192,8 @@ internal static ScreenField Text(string label, Func get, Action get, value => string.IsNullOrWhiteSpace(value) ? $"{label} cannot be empty" : null, value => set(value.Trim()), - Restore(get, set)); + Restore(get, set), + known is { Count: > 0 } ? known : null); } /// @@ -375,7 +476,11 @@ internal static ScreenField Number( Restore(get, set)); } - /// One of a fixed set of names, matched case-insensitively and stored canonically. + /// + /// One of a fixed set of names, matched case-insensitively and stored canonically. Its list is + /// closed: the validator refuses everything outside it, so the chrome draws it as the + /// permitted set rather than as suggestions. + /// internal static ScreenField Choice( string label, Func get, Action set, IReadOnlyList choices) { @@ -389,7 +494,8 @@ internal static ScreenField Choice( value => Canonical(choices, value) is null ? $"{label} must be one of: {string.Join(", ", choices)}" : null, value => set(Canonical(choices, value) ?? value), Restore(get, set), - choices); + choices, + ClosedChoices: true); } /// @@ -422,7 +528,11 @@ internal static ScreenField Colour( ScreenColours.Palette); } - /// An enum value, typed or cycled by name — a character's log format is the canonical case. + /// + /// An enum value, typed or picked by name — a character's log format is the canonical case. Its + /// list is closed: the enum's members are the only values there are, and the chrome says so + /// rather than implying a fifth log format could be typed into existence. + /// internal static ScreenField Enumeration(string label, Func get, Action set) where TEnum : struct, Enum { @@ -442,7 +552,8 @@ internal static ScreenField Enumeration(string label, Func get, Ac } }, Restore(get, set), - names); + names, + ClosedChoices: true); } /// Captures a value of any type and returns the action that writes it back. diff --git a/src/SharpMUTerm.Tui/ScreenPalette.cs b/src/SharpMUTerm.Tui/ScreenPalette.cs index 17800305..a9048656 100644 --- a/src/SharpMUTerm.Tui/ScreenPalette.cs +++ b/src/SharpMUTerm.Tui/ScreenPalette.cs @@ -54,6 +54,28 @@ internal static class ScreenPalette /// Near-black, for text printed *on* the accent (the Save chip, and the block caret). internal const string Ink = "#0f1620"; + /// + /// The surface an open field's candidate list floats on (). + /// Deliberately *lighter* than every panel a screen draws — the backdrop, the elevated card, and + /// the cursor bar — because the list is drawn over the rows beneath it rather than between them, + /// and a raised tone is the only way a cell grid can say "this is on top of that". + /// + internal const string MenuBg = "#2b3348"; + + /// + /// The candidate the buffer currently names, within that list. Lighter again, so the mark reads + /// against the list the way the list reads against the pane. + /// + internal const string MenuSelectedBg = "#3f4b69"; + + /// + /// The list's far edge — the drop shadow it casts on the rows it is covering, drawn on the side + /// away from the field so the block visibly *ends*. Darker than any panel, because that is the only + /// tone left that reads as "under". Without it the pane's own rows below a short list (F2's + /// attribute legend is the case that shows it) look like more of the list. + /// + internal const string MenuShadow = "#0b0e15"; + /// /// The well behind an editable value — whether or not it is being typed into. Clearly darker than /// every panel it can appear on (and than ), so a field reads as a recessed diff --git a/src/SharpMUTerm.Tui/SettingsSession.cs b/src/SharpMUTerm.Tui/SettingsSession.cs index 2959fca1..02b8f28a 100644 --- a/src/SharpMUTerm.Tui/SettingsSession.cs +++ b/src/SharpMUTerm.Tui/SettingsSession.cs @@ -39,8 +39,9 @@ internal enum ScreenAction /// activates the focused row when it has something to activate (a field → open an edit, a button → /// run it) and otherwise saves and closes; ⌃S saves from anywhere; Esc cancels the screen, /// except while an edit is open, where it abandons the edit and leaves the screen up. Inside an edit, -/// typing inserts, Backspace/Delete remove, ←→/Home/End move the caret, ↑↓ cycle an enum field's -/// choices, ⇥ commits and steps to the row's next field, ⏎ commits, and Esc reverts. +/// typing inserts, Backspace/Delete remove, ←→/Home/End move the caret, ↑↓ move through the drawn +/// candidate list (narrowing it is what typing does), ⇥ commits and steps to the row's next field, ⏎ +/// commits, and Esc reverts. /// /// internal sealed class SettingsSession @@ -86,6 +87,7 @@ internal ScreenFocus Focus() return ScreenFocus.None; } + var field = _edit is { } at ? model.FieldAt(at.Pane, at.Index, at.Field) : null; var edit = _edit is { } open && open.Pane == Selection.Pane && open.Index == Selection.Index ? new ScreenFieldEdit( open.Field, @@ -93,7 +95,8 @@ internal ScreenFocus Focus() open.Caret, open.Error, model.RowAt(open.Pane, open.Index).FieldCount, - model.FieldAt(open.Pane, open.Index, open.Field)?.Choices is { Count: > 0 }) + field?.Choices, + field?.ClosedChoices ?? false) : (ScreenFieldEdit?)null; return new ScreenFocus(Selection.Pane, Selection.Index, edit); @@ -351,7 +354,19 @@ private ScreenAction Step(ScreenModel model, ScreenField field, int direction) return ScreenAction.Redraw; } - /// ↑↓ inside an edit: step an enum field's choices; anything else has nothing to cycle. + /// + /// ↑↓ inside an edit: move through the candidate list the chrome is drawing beneath the field, and + /// put the entry landed on into the buffer. The highlight and the buffer are deliberately the same + /// thing rather than two cursors — a separate highlight would give ⏎ two meanings (take the + /// highlighted entry, or commit what is typed) and Esc two levels to back out of, inside a screen + /// whose only modal state so far is this edit. Keeping them one means the value visibly moves as the + /// list is walked, which is what a picker is for. + /// + /// A field with no choices, and one whose buffer has narrowed the list to nothing, both have nowhere + /// to move to and swallow the key with the buffer untouched — on an open field that buffer is a name + /// being typed for the first time, and an arrow key must not eat it. + /// + /// private ScreenAction Cycle(ScreenField field, int direction) { var edit = _edit!; diff --git a/src/SharpMUTerm.Tui/SharpMUTermApp.cs b/src/SharpMUTerm.Tui/SharpMUTermApp.cs index 84002f83..8a1f0c46 100644 --- a/src/SharpMUTerm.Tui/SharpMUTermApp.cs +++ b/src/SharpMUTerm.Tui/SharpMUTermApp.cs @@ -860,7 +860,7 @@ private void RefreshStatusBar() /// private IReadOnlyList SettingsScreens() => new SettingsScreen[] { - new(ConsoleKey.F2, new[] { "triggers" }, TriggersScreen), + new(ConsoleKey.F2, new[] { "triggers", "route", "highlight" }, TriggersScreen), new(ConsoleKey.F3, new[] { "aliases" }, AliasesScreen), new(ConsoleKey.F4, new[] { "keypad" }, KeypadScreen), new(ConsoleKey.F5, new[] { "worlds", "settings" }, WorldsScreen), @@ -1095,16 +1095,45 @@ private ScreenBinding OptionsScreen(Func sc /// /// The keys a <name>-edit snapshot drives into a freshly opened screen. ⏎ opens the /// focused row's first field — which on every list screen is now its name — ⇥ commits it - /// and steps to the next, and the rest is typing. Two screens walk further than the first field, + /// and steps to the next, and the rest is typing. Several views walk further than the first field, /// because a still frame should land on the thing that screen's editing actually added: F5 rewrites /// a host's suffix ("no way to change a host" is the gap the whole mode closes), and F2 steps on to - /// its route group and moves the dot, which is the only way to see that a radio list is live rather - /// than a report. The logging view opens F5 on the character pane, so it steps twice more to + /// its route and moves the mark, which is the only way to see that the dropdown is live rather than + /// a report. The logging view opens F5 on the character pane, so it steps twice more to /// reach the log format — past the name and the on-connect line — because the character's log is - /// the whole reason that view exists. + /// the whole reason that view exists, and it is also this app's one closed list, so it is + /// what the closed presentation is checked against. + /// + /// route and highlight are F2 again, stopped at the two states a single frame of + /// triggers-edit cannot also show: a buffer that has narrowed the list (pa → + /// pages), and a list longer than the pane can hold (seventeen colour names capped to six). + /// Both are drawn chrome with no state of their own, so a snapshot is the only place they can be + /// looked at rather than merely asserted. + /// + /// + /// F7/F8 open on a checkbox rather than a value, so their scripts step the cursor down to the row + /// that holds one before pressing ⏎ at all — otherwise textansi-edit would save the screen + /// and close it, which is what ⏎ means on a row with nothing to open. + /// /// private static IEnumerable EditSnapshotKeys(string view) { + // F7/F8 are single lists whose first row is a checkbox, so ⏎ there would save and close rather + // than open anything. The cursor walks down to the row that holds a value first — the listed + // fields on those screens (ambiguous width, newline key, dictionary) are the last of their + // section, which is also why they are the ones a snapshot has to reach deliberately. + var stepsDown = view.ToLowerInvariant() switch + { + "textansi" => 4, // strip · blink · underline · emoji → ambiguous width + "input" => 4, // local echo · drafts · newline key · check spelling → dictionary + _ => 0, + }; + + for (var i = 0; i < stepsDown; i++) + { + yield return Stroke('\0', ConsoleKey.DownArrow); + } + yield return Stroke('\r', ConsoleKey.Enter); if (string.Equals(view, "logging", StringComparison.OrdinalIgnoreCase)) @@ -1115,12 +1144,48 @@ private static IEnumerable EditSnapshotKeys(string view) yield break; } - if (string.Equals(view, "triggers", StringComparison.OrdinalIgnoreCase)) + if (string.Equals(view, "triggers", StringComparison.OrdinalIgnoreCase) || + string.Equals(view, "route", StringComparison.OrdinalIgnoreCase)) { // name → pattern → route: two steps, because the name now leads the row's fields. yield return Stroke('\t', ConsoleKey.Tab); yield return Stroke('\t', ConsoleKey.Tab); - yield return Stroke('\0', ConsoleKey.DownArrow); + + if (string.Equals(view, "triggers", StringComparison.OrdinalIgnoreCase)) + { + yield return Stroke('\0', ConsoleKey.DownArrow); + yield break; + } + + // Clear the opened value, then type a fragment of another window: the list narrows to it, + // and the frame shows a filter rather than a menu. + for (var i = 0; i < 4; i++) + { + yield return Stroke('\b', ConsoleKey.Backspace); + } + + foreach (var c in "pa") + { + yield return Stroke(c, ConsoleKey.NoName); + } + + yield break; + } + + if (string.Equals(view, "highlight", StringComparison.OrdinalIgnoreCase)) + { + // name → pattern → route → highlight fg, then clear the buffer: an empty one narrows + // nothing, so the whole seventeen-name palette is offered and the list is drawn at its cap. + for (var i = 0; i < 3; i++) + { + yield return Stroke('\t', ConsoleKey.Tab); + } + + for (var i = 0; i < 12; i++) + { + yield return Stroke('\b', ConsoleKey.Backspace); + } + yield break; } diff --git a/src/SharpMUTerm.Tui/TimersScreenRenderer.cs b/src/SharpMUTerm.Tui/TimersScreenRenderer.cs index 67c4a8e1..05eb6f46 100644 --- a/src/SharpMUTerm.Tui/TimersScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/TimersScreenRenderer.cs @@ -238,7 +238,7 @@ internal static List EditorColumn( var cursor = focus ?? ScreenFocus.None; var entries = Flatten(sets); return selected >= 0 && selected < entries.Count - ? BuildEditor(entries[selected].Timer, cursor, selected) + ? ScreenChrome.Choices(BuildEditor(entries[selected].Timer, cursor, selected), cursor.Edit, ColumnWidth) : new List(); } diff --git a/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs b/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs index 2d3d25f5..f69c2233 100644 --- a/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs @@ -526,8 +526,9 @@ private static List BuildEditor( // therefore drawn as an editable value like every other row in this pane rather than as a // radio group: the group cost five rows, was the only control here shaped differently // from its neighbours, and could not show a name being typed for the first time without a - // row invented for the purpose. The windows already in use remain ↑↓ suggestions while - // the field is open, which is what a radio group was really offering. + // row invented for the purpose. The windows already in use are listed beneath it while the + // field is open (ScreenChrome.Choices, applied to this whole column at the end) — which is + // what a radio group was really offering, without pretending the set is closed. $" {ScreenChrome.Field(Escape(currentRoute), route)}", }; @@ -569,7 +570,9 @@ private static List BuildEditor( lines.Add(ScreenChrome.Cursor( Checkbox("case sensitive", trigger.CaseSensitive), cursor.IsOn(1, 2), ColumnWidth)); - return lines; + // Four of this pane's nine fields know values worth listing — the route, both highlight colours + // and the script callback — and all four get the same drawn list, over the rows beside them. + return ScreenChrome.Choices(lines, cursor.Edit, ColumnWidth); } /// A checkbox row in the editor pane, checked in the accent and unchecked dim. diff --git a/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs b/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs index 378c7541..e60287bb 100644 --- a/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs @@ -519,7 +519,7 @@ internal static List DetailColumn( CharactersPane, world.Characters.Count, DetailRowWidth)); - return right; + return ScreenChrome.Choices(right, cursor.Edit, DetailRowWidth); } /// @@ -599,7 +599,7 @@ internal static List FormColumn( CharacterDefinition character, string accent, ScreenFocus? focus = null, int selectedCharacter = -1) { var cursor = focus ?? ScreenFocus.None; - return new List + var form = new List { $"[bold {accent}]└ CHARACTER · {Escape(character.Name)}[/]", string.Empty, @@ -631,6 +631,12 @@ internal static List FormColumn( LogDirectoryField, pane: CharactersPane)), }; + + // The log format is the second-to-last row of this block, so its list is drawn upward — the one + // case on these screens where a downward list would have nowhere to go. The block's height is a + // grid row in WorldsScreenView, which is the other half of why the list overlays rather than + // pushes: growing this list would resize the pane and shove the whole screen about. + return ScreenChrome.Choices(form, cursor.Edit, CharDetailColumnWidth); } /// diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenChoiceListTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenChoiceListTests.cs new file mode 100644 index 00000000..5f962781 --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/ScreenChoiceListTests.cs @@ -0,0 +1,398 @@ +using System.Text.RegularExpressions; +using SharpMUTerm.Core.Automation; +using SharpMUTerm.Core.Configuration; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// The candidate list draws beneath an open field — shared chrome, +/// so it is asserted once here and reached through the screens that use it at the bottom of the file. +/// +/// What it has to get right: typing narrows the list rather than leaving it a menu you have to walk; +/// a buffer that matches nothing reads as legal on a field that takes new values and merely as +/// unmatched on one that doesn't; a list longer than the pane says how much of itself it is showing; +/// and the whole thing overlays the pane rather than growing it, because two of the screens size a +/// grid row from the block's own line count. +/// +/// +public class ScreenChoiceListTests +{ + private static readonly string[] Routes = { "main", "Chat", "pages", "trade" }; + + private static readonly Regex Tags = new(@"\[[^\[\]]*\]"); + + /// A column of plain rows with one open field's caret on the row at . + private static List Column(int rows, int at, ScreenFieldEdit edit) + { + var lines = Enumerable.Range(0, rows).Select(i => $"[dim]row {i}[/]").ToList(); + lines[at] = " " + ScreenChrome.Field("value", edit); + return lines; + } + + private static bool IsMenu(string line) => + line.Contains($"[on {ScreenPalette.MenuBg}]", StringComparison.Ordinal) + || line.Contains($"[on {ScreenPalette.MenuSelectedBg}]", StringComparison.Ordinal); + + private static bool IsCaption(string line) => + IsMenu(line) && (line.Contains('▾') || line.Contains('▴')); + + private static string Caption(IEnumerable lines) => + Tags.Replace(lines.Single(IsCaption), string.Empty).Trim(); + + /// The drawn candidates, in order, without their markup — captions and shadow excluded. + private static List Entries(IEnumerable lines) => lines + .Where(l => IsMenu(l) && !IsCaption(l)) + .Select(l => Tags.Replace(l, string.Empty).Replace("▸", string.Empty, StringComparison.Ordinal).Trim()) + .ToList(); + + /// The one candidate drawn as the value the buffer names, or null when none is. + private static string? Marked(IEnumerable lines) => lines + .Where(l => l.Contains($"[on {ScreenPalette.MenuSelectedBg}]", StringComparison.Ordinal)) + .Select(l => Tags.Replace(l, string.Empty).Replace("▸", string.Empty, StringComparison.Ordinal).Trim()) + .SingleOrDefault(); + + [Test] + public async Task AFieldWithNothingToOfferDrawsNoListAtAll() + { + var lines = Column(12, 3, new ScreenFieldEdit(0, "aardmud.org", 11, null)); + var drawn = ScreenChrome.Choices(lines, new ScreenFieldEdit(0, "aardmud.org", 11, null), 56); + + await Assert.That(drawn.Any(IsMenu)).IsFalse(); + } + + /// + /// A block that isn't drawing the open edit has no caret in it, so it must come back untouched — + /// this is what lets every column call the chrome unconditionally without knowing whose field is + /// open. F5 draws three of these blocks side by side. + /// + [Test] + public async Task AColumnThatIsNotDrawingTheOpenFieldIsLeftAlone() + { + var elsewhere = Enumerable.Range(0, 8).Select(i => $"[dim]row {i}[/]").ToList(); + var drawn = ScreenChrome.Choices( + elsewhere, new ScreenFieldEdit(0, "Chat", 4, null, Choices: Routes), 56); + + await Assert.That(drawn.Any(IsMenu)).IsFalse(); + await Assert.That(drawn.Count).IsEqualTo(8); + } + + /// + /// A field opens on its committed value, so a plain filter would collapse the list to that one + /// entry the instant it was drawn — the dropdown would never show the alternatives it exists for. + /// A buffer that names a choice is therefore a selection: the whole list stays, marked. + /// + [Test] + public async Task ABufferThatNamesAChoiceKeepsTheWholeListAndMarksIt() + { + var edit = new ScreenFieldEdit(0, "Chat", 4, null, Choices: Routes); + var drawn = ScreenChrome.Choices(Column(14, 2, edit), edit, 56); + + await Assert.That(Entries(drawn)).IsEquivalentTo(new[] { "main", "Chat", "pages", "trade" }); + await Assert.That(Marked(drawn)).IsEqualTo("Chat"); + await Assert.That(Caption(drawn)).Contains(ScreenChrome.OpenChoicesCaption); + } + + [Test] + public async Task TypingNarrowsTheListToWhatItMatches() + { + var edit = new ScreenFieldEdit(0, "pa", 2, null, Choices: Routes); + var drawn = ScreenChrome.Choices(Column(14, 2, edit), edit, 56); + + await Assert.That(Entries(drawn)).IsEquivalentTo(new[] { "pages" }); + + // Nothing is marked: "pa" is not the name of anything, so no entry is the value yet. + await Assert.That(Marked(drawn)).IsNull(); + await Assert.That(Caption(drawn)).Contains("1 of 4"); + } + + /// Substring, not prefix — a colour is as often remembered by its middle as its start. + [Test] + public async Task TheFilterMatchesAnywhereInAName() + { + await Assert.That(ScreenField.Matching(ScreenColours.Palette, "gre")) + .IsEquivalentTo(new[] { "green", "grey" }); + await Assert.That(ScreenField.Matching(Routes, "ra")).IsEquivalentTo(new[] { "trade" }); + await Assert.That(ScreenField.Matching(Routes, string.Empty)).IsEquivalentTo(Routes); + } + + /// + /// The empty filter is the whole reason the route field stopped being a radio group: a name that + /// matches nothing is exactly how the next spawn window is created, so an empty list must not read + /// as a refusal. It says so in words, and — decisively — does not raise its voice: the + /// ink is reserved for a value that has actually been refused. + /// + [Test] + public async Task AnOpenListThatMatchesNothingSaysTheValueIsAllowed() + { + var edit = new ScreenFieldEdit(0, "combat", 6, null, Choices: Routes); + var drawn = ScreenChrome.Choices(Column(14, 2, edit), edit, 56); + + await Assert.That(Entries(drawn)).IsEmpty(); + await Assert.That(Caption(drawn)).Contains(ScreenChrome.NoMatchOpen); + await Assert.That(drawn.Any(l => l.Contains(ScreenPalette.Warn, StringComparison.Ordinal))).IsFalse(); + } + + /// + /// The same state on a closed field states the fact and stops: the value really will be refused, + /// but by the field's own validator at ⏎, and promising a new value would be a lie. + /// + [Test] + public async Task AClosedListThatMatchesNothingDoesNotPromiseANewValue() + { + var formats = new[] { "None", "Plain", "Html", "Both" }; + var edit = new ScreenFieldEdit(0, "Verbose", 7, null, Choices: formats, ClosedChoices: true); + var drawn = ScreenChrome.Choices(Column(14, 2, edit), edit, 56); + + await Assert.That(Entries(drawn)).IsEmpty(); + await Assert.That(Caption(drawn)).Contains(ScreenChrome.NoMatchClosed); + await Assert.That(Caption(drawn)).DoesNotContain(ScreenChrome.NoMatchOpen); + await Assert.That(drawn.Any(l => l.Contains(ScreenPalette.Warn, StringComparison.Ordinal))).IsFalse(); + } + + /// + /// The two lists must not look alike. One says "here are the values in use, type another if you + /// want"; the other says "these four are all there are". Drawn identically, the first would imply a + /// closed set and the second would invite a value it is about to refuse. + /// + [Test] + public async Task OpenAndClosedListsAreCaptionedApart() + { + var open = new ScreenFieldEdit(0, "Chat", 4, null, Choices: Routes); + var closed = new ScreenFieldEdit(0, "Chat", 4, null, Choices: Routes, ClosedChoices: true); + + var openCaption = Caption(ScreenChrome.Choices(Column(14, 2, open), open, 56)); + var closedCaption = Caption(ScreenChrome.Choices(Column(14, 2, closed), closed, 56)); + + await Assert.That(openCaption).Contains(ScreenChrome.OpenChoicesCaption); + await Assert.That(openCaption).DoesNotContain(ScreenChrome.ClosedChoicesCaption); + await Assert.That(closedCaption).Contains(ScreenChrome.ClosedChoicesCaption); + await Assert.That(closedCaption).DoesNotContain(ScreenChrome.OpenChoicesCaption); + } + + /// + /// Seventeen colour names is more rows than F2's editor pane has to spare, so the list is capped — + /// and says what it is capped to, because a list silently showing a third of itself would be worse + /// than none. + /// + [Test] + public async Task ALongListIsCappedAndSaysHowMuchOfItselfItIsShowing() + { + var edit = new ScreenFieldEdit(0, "none", 4, null, Choices: ScreenColours.Palette); + var drawn = ScreenChrome.Choices(Column(24, 2, edit), edit, 56); + + await Assert.That(ScreenColours.Palette.Count).IsGreaterThan(ScreenChrome.MaxChoiceRows); + await Assert.That(Entries(drawn).Count).IsEqualTo(ScreenChrome.MaxChoiceRows); + await Assert.That(Caption(drawn)).Contains($"{ScreenChrome.MaxChoiceRows} of {ScreenColours.Palette.Count}"); + } + + /// + /// A cap with no window would make the last eleven colours unreachable to the eye: ↑↓ would move a + /// mark that had scrolled off the block. The window follows the mark instead. + /// + [Test] + public async Task TheCapWindowsAroundTheMarkedEntry() + { + var last = ScreenColours.Palette[^1]; + var edit = new ScreenFieldEdit(0, last, last.Length, null, Choices: ScreenColours.Palette); + var drawn = ScreenChrome.Choices(Column(24, 2, edit), edit, 56); + + await Assert.That(Entries(drawn)).Contains(last); + await Assert.That(Marked(drawn)).IsEqualTo(last); + await Assert.That(Entries(drawn)).DoesNotContain(ScreenColours.Palette[0]); + } + + /// + /// The overlay rule, which is the reason the shared chrome could be dropped into six renderers at + /// all: a block's line count is the same open and closed. F5 sizes a grid row from + /// FormColumn's count, so a list that pushed rows down would resize the screen on ⏎. + /// + [Test] + public async Task TheListOverlaysThePaneAndNeverChangesItsHeight() + { + var edit = new ScreenFieldEdit(0, "Chat", 4, null, Choices: Routes); + var before = Column(14, 2, edit); + var after = ScreenChrome.Choices(Column(14, 2, edit), edit, 56); + + await Assert.That(after.Count).IsEqualTo(before.Count); + await Assert.That(after.Count(IsMenu)).IsGreaterThan(0); + + // The rows past the block are untouched — it covers its neighbours, it doesn't shuffle them. + await Assert.That(after[^1]).IsEqualTo(before[^1]); + } + + [Test] + public async Task AListWithNoRoomBelowItIsDrawnAbove() + { + var edit = new ScreenFieldEdit(0, "Chat", 4, null, Choices: Routes); + var drawn = ScreenChrome.Choices(Column(9, 7, edit), edit, 56); + + var menu = drawn.Select((line, i) => (line, i)).Where(x => IsMenu(x.line)).Select(x => x.i).ToList(); + + await Assert.That(menu).IsNotEmpty(); + await Assert.That(menu.Max()).IsLessThan(7); + await Assert.That(drawn.Count).IsEqualTo(9); + + // The caption keeps the edge nearest the field, and names the direction it opened in. + await Assert.That(drawn[menu.Max()]).Contains("▴"); + } + + // ---- through the screens that use it ------------------------------------------------------ + + private static ConsoleKeyInfo Key(ConsoleKey key) => new('\0', key, false, false, false); + + private static ConsoleKeyInfo Char(char c) => new(c, ConsoleKey.NoName, false, false, false); + + private static List Sets() => new() + { + new TriggerSet + { + Name = "Comms", + Triggers = new List + { + new() { Name = "Tell", Pattern = "tells you", Actions = new TriggerActions { SpawnTarget = "Chat" } }, + }, + }, + }; + + /// Opens F2's route field — the rule row's third — and hands back the live session. + private static SettingsSession OpenTheRoute(IReadOnlyList sets) + { + var session = new SettingsSession( + selection => TriggersScreenRenderer.Model(sets, selection.CursorIn(0), Routes[1..])); + session.Handle(Key(ConsoleKey.Enter)); // name + session.Handle(Key(ConsoleKey.Tab)); // pattern + session.Handle(Key(ConsoleKey.Tab)); // route + return session; + } + + [Test] + public async Task F2DrawsTheRouteListUnderTheRouteField() + { + var sets = Sets(); + var editor = TriggersScreenRenderer.EditorColumn(sets, 0, Routes[1..], OpenTheRoute(sets).Focus()); + + await Assert.That(Entries(editor)).IsEquivalentTo(new[] { "main", "Chat", "pages", "trade" }); + await Assert.That(Marked(editor)).IsEqualTo("Chat"); + await Assert.That(Caption(editor)).Contains(ScreenChrome.OpenChoicesCaption); + } + + /// + /// F5's log format is the app's one genuinely closed list, and it sits second-from-last in its + /// block — so it is also the case that has to open upward. Both halves are asserted here because + /// they are the two things the F2 case cannot show. + /// + [Test] + public async Task F5DrawsTheLogFormatAsAClosedListAboveTheField() + { + var worlds = new List + { + new() + { + Name = "Aardwolf", + Host = "aardmud.org", + Characters = new List { new() { Name = "Kaz" } }, + }, + }; + var edit = new ScreenFieldEdit( + WorldsScreenRenderer.LogFormatField, + "Html", + 4, + null, + Choices: Enum.GetNames(), + ClosedChoices: true); + var focus = new ScreenFocus(WorldsScreenRenderer.CharactersPane, 0, edit); + + var plain = WorldsScreenRenderer.FormColumn(worlds[0].Characters[0], ScreenPalette.Accent, null, 0); + var form = WorldsScreenRenderer.FormColumn(worlds[0].Characters[0], ScreenPalette.Accent, focus, 0); + + await Assert.That(Entries(form)).IsEquivalentTo(new[] { "None", "Plain", "Html", "Both" }); + await Assert.That(Marked(form)).IsEqualTo("Html"); + await Assert.That(Caption(form)).Contains(ScreenChrome.ClosedChoicesCaption); + + // Drawn above, and — the point of an overlay on this screen — over exactly as many rows. + var field = form.FindIndex( + l => l.Contains($"[{ScreenPalette.Ink} on {ScreenPalette.Accent}]", StringComparison.Ordinal)); + await Assert.That(form.Count).IsEqualTo(plain.Count); + await Assert.That(field).IsGreaterThan(0); + await Assert.That(form.FindLastIndex(IsMenu)).IsLessThan(field); + } + + /// + /// ↑↓ walk the list the user is looking at, not the one behind it: after typing pa the list + /// holds only pages, and ↓ takes it. Filtering and stepping being the same list is what makes + /// "type a bit, then arrow onto it" work at all. + /// + [Test] + public async Task ArrowsWalkTheNarrowedList() + { + var sets = Sets(); + var session = OpenTheRoute(sets); + + for (var i = 0; i < "Chat".Length; i++) + { + session.Handle(Key(ConsoleKey.Backspace)); + } + + session.Handle(Char('p')); + session.Handle(Char('a')); + await Assert.That(session.Focus().Edit!.Value.VisibleChoices).IsEquivalentTo(new[] { "pages" }); + + session.Handle(Key(ConsoleKey.DownArrow)); + await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("pages"); + } + + /// + /// The other half of that bargain: a buffer that matched nothing is a name being typed for the + /// first time, and an arrow key must not eat it. This is the case a cycling field got wrong — + /// ↓ used to jump to the first choice and throw the typing away. + /// + [Test] + public async Task ArrowsLeaveAFreshNameAlone() + { + var sets = Sets(); + var session = OpenTheRoute(sets); + + for (var i = 0; i < "Chat".Length; i++) + { + session.Handle(Key(ConsoleKey.Backspace)); + } + + foreach (var c in "combat") + { + session.Handle(Char(c)); + } + + session.Handle(Key(ConsoleKey.DownArrow)); + session.Handle(Key(ConsoleKey.UpArrow)); + await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("combat"); + + // And it still commits: the list is a suggestion, and the field takes the name it was given. + session.Handle(Key(ConsoleKey.Enter)); + await Assert.That(session.IsEditing).IsFalse(); + await Assert.That(sets[0].Triggers[0].Actions.SpawnTarget).IsEqualTo("combat"); + } + + /// + /// A listed field is still a text field. Typing over the whole buffer, moving the caret and + /// backspacing all behave exactly as they do on a free-text one — the list is drawn beside the + /// keyboard, it does not take it. + /// + [Test] + public async Task AListedFieldIsStillTypeable() + { + var sets = Sets(); + var session = OpenTheRoute(sets); + + session.Handle(Key(ConsoleKey.Home)); + session.Handle(Char('#')); + await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("#Chat"); + + session.Handle(Key(ConsoleKey.Delete)); + await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("#hat"); + + session.Handle(Key(ConsoleKey.End)); + session.Handle(Key(ConsoleKey.Backspace)); + await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("#ha"); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenFieldTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenFieldTests.cs index c923de9c..f0623a91 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenFieldTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenFieldTests.cs @@ -121,7 +121,17 @@ public async Task Enumeration_ParsesByNameAndCyclesWithBothDirections() await Assert.That(field.Cycle("Html", 1)).IsEqualTo("Both"); await Assert.That(field.Cycle("None", -1)).IsEqualTo("Both"); // wraps at the start - await Assert.That(field.Cycle("Ht", 1)).IsEqualTo("None"); // half-typed starts over + + // A half-typed buffer used to start the cycle over at the first choice, from before there was a + // list on screen to start over *in*. ↑↓ now walk exactly the entries the dropdown is showing, and + // "Ht" is showing only "Html" — so ↓ takes the one match rather than jumping past it to "None". + await Assert.That(ScreenField.Matching(field.Choices, "Ht")).IsEquivalentTo(new[] { "Html" }); + await Assert.That(field.Cycle("Ht", 1)).IsEqualTo("Html"); + await Assert.That(field.Cycle("Ht", -1)).IsEqualTo("Html"); + + // And a buffer matching nothing has nowhere to step, so the keystroke leaves it alone rather + // than overwriting what is being typed. + await Assert.That(field.Cycle("Verbose", 1)).IsNull(); } [Test] diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenFooterTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenFooterTests.cs index f7f76c13..c002d45c 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenFooterTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenFooterTests.cs @@ -146,19 +146,37 @@ public async Task AnAccentedFooterSwapsItsVerbsToo() /// ↑↓ is offered only by a field that has choices to step through. It is the same rule as ⇥, which /// is offered only when the row holds another field: a hint for a key that would do nothing is the /// bug this file is about, one keystroke smaller. + /// + /// The rule now bites one level finer, because ↑↓ walk the list the dropdown is *showing*: a buffer + /// that has narrowed that list to nothing leaves the keys with nowhere to go, and the hint goes with + /// them. + /// /// [Test] public async Task EditingHints_OfferTheChoiceKeysOnlyForAFieldThatHasChoices() { + var routes = new[] { "main", "Chat", "pages" }; var free = ScreenChrome.Hints( ScreenChrome.ListHints, "F5", true, new ScreenFocus(0, 0, new ScreenFieldEdit(0, "x", 1, null))); var choices = ScreenChrome.Hints( ScreenChrome.ListHints, "F5", true, - new ScreenFocus(0, 0, new ScreenFieldEdit(0, "main", 4, null, HasChoices: true))); + new ScreenFocus(0, 0, new ScreenFieldEdit(0, "main", 4, null, Choices: routes))); + var narrowed = ScreenChrome.Hints( + ScreenChrome.ListHints, + "F5", + true, + new ScreenFocus(0, 0, new ScreenFieldEdit(0, "pa", 2, null, Choices: routes))); + var matchedNothing = ScreenChrome.Hints( + ScreenChrome.ListHints, + "F5", + true, + new ScreenFocus(0, 0, new ScreenFieldEdit(0, "combat", 6, null, Choices: routes))); await Assert.That(free).DoesNotContain(ScreenChrome.ChoiceHint); await Assert.That(choices).Contains(ScreenChrome.ChoiceHint); + await Assert.That(narrowed).Contains(ScreenChrome.ChoiceHint); + await Assert.That(matchedNothing).DoesNotContain(ScreenChrome.ChoiceHint); } } diff --git a/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs b/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs index 161cf121..083b77cb 100644 --- a/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs @@ -42,6 +42,16 @@ public class TriggersScreenEditingTests private static readonly string[] Targets = { "Chat", "pages", "trade" }; + /// + /// The entry the open dropdown has marked — the value ⏎ would commit — or null when it has marked + /// none. The mark is ▸ in the accent, drawn only by ; + /// the rule list's own selection marker is a bare ▸ in bold, and lives in a different column. + /// + private static string? Marked(IEnumerable lines) => lines + .Where(l => l.Contains($"[{ScreenPalette.Accent}]▸[/]", StringComparison.Ordinal)) + .Select(l => l.Split($"[{ScreenPalette.Value}]", StringSplitOptions.None)[1].Split("[/]")[0]) + .FirstOrDefault(); + [Test] public async Task ARuleRowCarriesItsPatternRouteAndBothHighlightColours() { @@ -189,7 +199,13 @@ public async Task UpAndDownStepTheKnownWindows_AndTheDrawnRouteFollowsTheBuffer( await Assert.That(trigger.Actions.SpawnTarget).IsEqualTo("Chat"); var editor = TriggersScreenRenderer.EditorColumn(sets, 0, Targets, session.Focus()); await Assert.That(editor.Any(l => l.Contains("pages"))).IsTrue(); - await Assert.That(editor.Any(l => l.Contains("Chat"))).IsFalse(); + + // "Chat" is still on screen — the dropdown lists every window, which is the whole point of it — + // but it is no longer the value: the mark has moved off it and onto the buffer's window, and it + // is the *mark*, not mere presence, that says what ⏎ would write. (It used to be enough to + // assert Chat had vanished, back when only the value was drawn.) + await Assert.That(Marked(editor)).IsEqualTo("pages"); + await Assert.That(editor.Any(l => l.Contains("Chat"))).IsTrue(); session.Handle(Key(ConsoleKey.Enter)); await Assert.That(trigger.Actions.SpawnTarget).IsEqualTo("pages"); From ce129656e3d153fd212976e92271bcba11afcbf5 Mon Sep 17 00:00:00 2001 From: Harry Cordewener Date: Tue, 28 Jul 2026 22:18:52 -0500 Subject: [PATCH 18/23] Make the settings actually reach the client Audited every editable field on F2-F9 against its runtime consumer rather than against whether it persists. A checkbox that saves a bool nothing reads is still a lie, just a durable one. The systemic finding: StartAsync opened an anonymous session -- no character, no trigger sets, no log sink -- so F2's triggers, F3's aliases, F6's timers and every character setting were unreachable at runtime however correct Core was. The shell now connects as the world's first configured character, which is what made most of the rest reachable at all. Wired nine: strip incoming ANSI colour, allow blink, underline hyperlinks, emoji substitution, local echo, keep per-tab drafts, world encoding (now reaching CHARSET negotiation rather than a status-bar label), the log sink, and timers -- nothing had ever realised a TimerDefinition, so a configured timer had never fired. Settings are held by reference and read per line rather than copied at construction; copying them is exactly how a checkbox comes to need a restart. Removed four controls whose features do not exist: ambiguous width (all width measurement is the framework's Wcwidth, which exposes no East-Asian policy), newline key (the prompt is single-line), check spelling and dictionary (there is no spellchecker anywhere in the repo). A control for a feature that doesn't exist should go, not sit there looking operable. Old configs carrying those keys still load. Two left, with reasons rather than pretence. F4's macros cannot fire: SharpConsoleUI's input parser never produces NumPad keys, so that half needs DECKPAM/SS3 decoding upstream. Keepalive has no mechanism at all -- a correct one needs a raw IAC NOP path the telnet session doesn't expose. 999 tests pass, up from 946, with 53 added. Every wired field has a test that changing it changes behaviour, most flipping the setting on an already-connected session, which is what tells Live apart from applied-at-startup. Six pinned assertions changed, each reported: the removed rows' counts, and label assertions turned into absence assertions so the controls cannot drift back silently. Co-Authored-By: Claude Opus 5 (1M context) --- CLAUDE.md | 2 +- docs/HANDOFF.md | 55 ++++- .../Configuration/PreferenceSettings.cs | 30 +-- .../Logging/CompositeLogSink.cs | 60 ++++++ .../Session/SessionManager.cs | 32 ++- src/SharpMUTerm.Core/Session/WorldSession.cs | 111 +++++++++- src/SharpMUTerm.Core/Telnet/TelnetSession.cs | 42 ++++ src/SharpMUTerm.Core/Text/StyledText.cs | 55 +++++ src/SharpMUTerm.Tui/DraftStore.cs | 46 ++++ src/SharpMUTerm.Tui/MarkupFormatter.cs | 29 ++- src/SharpMUTerm.Tui/OptionsScreenRenderer.cs | 55 ++--- src/SharpMUTerm.Tui/SharpMUTermApp.cs | 136 +++++++++--- .../Configuration/ConfigurationTests.cs | 37 +++- .../Logging/LogSinkTests.cs | 56 +++++ .../Session/SessionManagerTests.cs | 90 ++++++++ .../Session/WorldSessionPreferenceTests.cs | 203 ++++++++++++++++++ .../Session/WorldSessionTimerTests.cs | 182 ++++++++++++++++ .../Telnet/CharsetOrderTests.cs | 70 ++++++ .../Text/StyledTextTests.cs | 73 +++++++ .../SharpMUTerm.Tui.Tests/DraftStoreTests.cs | 106 +++++++++ .../MarkupFormatterTests.cs | 97 +++++++++ .../OptionsScreenRendererTests.cs | 48 +++-- .../ScreenCursorTests.cs | 27 ++- .../ScreenFieldRenderingTests.cs | 36 +++- .../ScreenFooterTests.cs | 2 +- .../SharpMUTerm.Tui.Tests/ScreenModelTests.cs | 31 ++- .../ScreenReadOnlyTests.cs | 6 +- 27 files changed, 1560 insertions(+), 157 deletions(-) create mode 100644 src/SharpMUTerm.Core/Logging/CompositeLogSink.cs create mode 100644 src/SharpMUTerm.Tui/DraftStore.cs create mode 100644 tests/SharpMUTerm.Core.Tests/Session/SessionManagerTests.cs create mode 100644 tests/SharpMUTerm.Core.Tests/Session/WorldSessionPreferenceTests.cs create mode 100644 tests/SharpMUTerm.Core.Tests/Session/WorldSessionTimerTests.cs create mode 100644 tests/SharpMUTerm.Core.Tests/Telnet/CharsetOrderTests.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/DraftStoreTests.cs diff --git a/CLAUDE.md b/CLAUDE.md index 34471995..65b67178 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -32,7 +32,7 @@ fallbacks) for inline images/maps. ## Repository state **M1 delivered, plus substantial M2–M4 work.** `SharpMUTerm.slnx` builds all ten projects on -`net10.0`; the solution has **946 tests**, all passing. In place: +`net10.0`; the solution has **999 tests**, all passing. In place: - **Core** — `AnsiParser` (SGR 16/256/truecolor), styled-line + `ScrollbackBuffer` model, `TcpTransport` (TLS + IPv6), `TelnetSession` (wraps TelnetNegotiationCore **2.5.3**), diff --git a/docs/HANDOFF.md b/docs/HANDOFF.md index 82dec631..c46e2d71 100644 --- a/docs/HANDOFF.md +++ b/docs/HANDOFF.md @@ -4,8 +4,8 @@ Context for whoever (human or agent) picks up this work next. - **Repository:** `SharpMUSH/SharpMUTerm` - **Start from:** a fresh branch off `main` -- **Tests:** 946 across the solution (338 Core / 83 Graphics / 42 Scripting / - 28 Web / 455 Tui), all passing; `dotnet build SharpMUTerm.slnx` clean (0 warnings +- **Tests:** 999 across the solution (375 Core / 83 Graphics / 42 Scripting / + 28 Web / 471 Tui), all passing; `dotnet build SharpMUTerm.slnx` clean (0 warnings from this repo; building against a local SharpConsoleUI clone surfaces 2 upstream NuGet advisory warnings for AngleSharp, which are the framework's, not ours) @@ -480,6 +480,42 @@ What the framework actually provides (read at v2.5.14, not assumed): - Pane shape: F4/F7/F8 are single-pane (no ⇥); **F5 has four** (worlds → characters → trigger sets → the world's security checkboxes); the rest have two. +### What a settings field actually reaches (audited) + +Writing to `AppConfiguration` is not the same as doing something. The three +categories, and where each control sits: + +- **Live — the next line/keystroke sees it.** F7's `strip incoming ANSI colour`, + `emoji substitution` (`WorldSession.ProcessOutputLine`/`ApplyEmoji`), + `allow blink`, `underline hyperlinks` (`MarkupFormatter.AppendSpan`/`StyleTag`); + F8's `local echo` (`WorldSession.SendUserInputAsync`) and `keep per-tab drafts` + (`DraftStore`); every **field** of an F2 trigger / F3 alias / F6 timer / F4 macro, + because the engines hold the *same objects* the screens edit; F6's `enabled` and + `command`, read inside the timer callback. **These are held by reference on + purpose** — `WorldSession` and `MarkupFormatter` take `TextSettings`/`InputSettings` + and read them per line. Copy one into a field at construction and the checkbox + needs a restart again. +- **Applied at connect.** A world's host/port/TLS/certificates + (`WorldDefinition.ToConnectionOptions`), its `encoding` + (`TelnetSessionOptions.PreferEncoding`), the character's `auto-login`/`on connect` + (`WorldSession.SendLoginAsync`), its log format + folder + (`SharpMUTermApp.OpenLog`), a timer's `interval`/`one-shot`, and **adding or + removing** any rule (the engines were handed the list once). Reconnect, don't + restart. +- **Still inert, and why.** F4's numpad **bindings never fire**: nothing maps a key + press to `WorldSession.HandleKeyAsync`, and SharpConsoleUI's input parser never + produces `ConsoleKey.NumPad0..9` at all (grep it — there are no occurrences), so + the fix is application-keypad decoding in the driver, i.e. upstream. A world's + `keepalive` seconds only picks the status bar's fake ack figure — there is no + keepalive, and adding one wants a raw `IAC NOP` write that bypasses the + interpreter's escaping (`ITelnetSession` has no such path today). + +**The shell connects as the world's first configured character** +(`SharpMUTermApp.OpenSession`). Before that it opened an *anonymous* session, which +is why so much of F2–F6 was unreachable however correct Core was: no character +meant no trigger sets, no auto-login, no log. Picking a *different* character still +has no UI. + ### Dropdowns (a field's candidate list) - **`ScreenChrome.Choices(column, edit, width)` is the whole feature**, called once @@ -493,7 +529,7 @@ What the framework actually provides (read at v2.5.14, not assumed): would resize the whole screen on ⏎), and F2's editor already runs to two dozen rows (pushed-down rows would fall off the bottom, checkboxes included). It opens **downward**, and **upward** when there aren't enough rows below — F5's log format - and F7's ambiguous width are both second-from-last in their block. The caption + is second-from-last in its block. The caption keeps the edge nearest the field (`▾` below, `▴` above) and a one-row **shadow** closes the far edge, so the pane's own rows continuing past the block read as behind it. @@ -514,13 +550,16 @@ What the framework actually provides (read at v2.5.14, not assumed): - **Capped at `ScreenChrome.MaxChoiceRows` (6)**, with the caption saying so (`suggestions 6 of 17`) and the window scrolling to keep the marked entry in it, or the eleventh colour would be unreachable to the eye. -- **`newline key` and `dictionary` (F8) grew suggestion lists**, since `ScreenField.Text` - now takes an optional `known`. Both stay open: the chords a terminal can deliver - and the locales a speller has installed are not this screen's to close. +- **`ScreenField.Text` takes an optional `known`** for an open suggestion list. F8's + `newline key` and `dictionary` were the two callers and are gone with their + controls; the capability stays because an open list is the right shape for any + value whose vocabulary this screen doesn't own. - **Snapshot states:** `triggers-edit` (open list, mark moved), `route-edit` (narrowed to one), `highlight-edit` (17 capped to 6), `logging-edit` (closed, - drawn upward), `textansi-edit` / `input-edit` (F7/F8; their scripts step the - cursor down to a value row first, because ⏎ on a checkbox row saves and closes). + drawn upward). **There is no `textansi-edit` / `input-edit` any more** — F7 and F8 + are all checkboxes now, and ⏎ on a checkbox row saves and closes, so driving one + would snapshot a workspace with no screen on it. `EditSnapshotKeys` returns nothing + for those two views rather than a keystroke that closes the thing being framed. ### TelnetNegotiationCore diff --git a/src/SharpMUTerm.Core/Configuration/PreferenceSettings.cs b/src/SharpMUTerm.Core/Configuration/PreferenceSettings.cs index 543dadff..2215cc0f 100644 --- a/src/SharpMUTerm.Core/Configuration/PreferenceSettings.cs +++ b/src/SharpMUTerm.Core/Configuration/PreferenceSettings.cs @@ -17,16 +17,27 @@ public sealed class TextSettings /// Underline MXP/Pueblo/web links so they read as clickable. public bool UnderlineHyperlinks { get; set; } = true; - /// Substitute emoji for shortcodes and emoticons in inbound text. + /// + /// Substitute emoji for shortcodes and emoticons in inbound text. The app-wide off switch over + /// , which is where a world opts in and says which + /// substitutions it wants — see WorldSession.ApplyEmoji. + /// public bool EmojiSubstitution { get; set; } = true; - /// How East Asian ambiguous-width characters are measured: narrow or wide. - public string AmbiguousWidth { get; set; } = "narrow"; + // There is deliberately no "ambiguous width" here. It was a setting with nothing behind it: every + // column measurement in this app is SharpConsoleUI's (Helpers/UnicodeWidth.cs), which asks the + // Wcwidth tables and offers no East-Asian-ambiguous policy to set. Honouring it needs an upstream + // seam, and until there is one, the honest state is no control rather than a stored string. } /// -/// Application-wide input and spellcheck preferences — the settings the F8 "Input & spellcheck" -/// screen edits. +/// Application-wide input preferences — the settings the F8 "Input" screen edits. +/// +/// Spellcheck used to live here (CheckSpelling, Dictionary) and was removed with its +/// checkboxes: there is no speller in this client, so the two values described a feature that did not +/// exist. So did NewlineKey — the command line is a single-line +/// PromptControl, and no chord can put a newline into a control that has no second row. +/// /// public sealed class InputSettings { @@ -35,13 +46,4 @@ public sealed class InputSettings /// Keep an unsent draft per tab so switching windows doesn't lose typing. public bool KeepDrafts { get; set; } = true; - - /// The key that inserts a newline instead of sending (e.g. Shift+Enter). - public string NewlineKey { get; set; } = "Shift+Enter"; - - /// Spell-check the input line as it is typed. - public bool CheckSpelling { get; set; } = true; - - /// The dictionary spellcheck loads (e.g. en_US). - public string Dictionary { get; set; } = "en_US"; } diff --git a/src/SharpMUTerm.Core/Logging/CompositeLogSink.cs b/src/SharpMUTerm.Core/Logging/CompositeLogSink.cs new file mode 100644 index 00000000..5539b0b7 --- /dev/null +++ b/src/SharpMUTerm.Core/Logging/CompositeLogSink.cs @@ -0,0 +1,60 @@ +using SharpMUTerm.Core.Text; + +namespace SharpMUTerm.Core.Logging; + +/// +/// Fans one session's output out to several sinks. is the +/// reason it exists: a session holds a single , so "plain and HTML" has to be +/// one sink that is two. +/// +/// Every call reaches every sink, in order, even if an earlier one throws — a full disk on the plain +/// log must not silently stop the HTML one. The first failure is rethrown once the round is done, so +/// a broken sink is still reported rather than swallowed. +/// +/// +public sealed class CompositeLogSink : ILogSink +{ + private readonly ILogSink[] _sinks; + + public CompositeLogSink(IEnumerable sinks) + { + ArgumentNullException.ThrowIfNull(sinks); + _sinks = sinks.ToArray(); + if (Array.IndexOf(_sinks, null) >= 0) + { + throw new ArgumentException("A composite log sink cannot hold a null sink.", nameof(sinks)); + } + } + + /// The sinks this one writes through, in write order. + public IReadOnlyList Sinks => _sinks; + + public void WriteLine(StyledLine line) => ForEach(sink => sink.WriteLine(line)); + + public void WriteSystem(string text) => ForEach(sink => sink.WriteSystem(text)); + + public void Flush() => ForEach(sink => sink.Flush()); + + public void Dispose() => ForEach(sink => sink.Dispose()); + + private void ForEach(Action action) + { + Exception? first = null; + foreach (var sink in _sinks) + { + try + { + action(sink); + } + catch (Exception ex) + { + first ??= ex; + } + } + + if (first is not null) + { + throw first; + } + } +} diff --git a/src/SharpMUTerm.Core/Session/SessionManager.cs b/src/SharpMUTerm.Core/Session/SessionManager.cs index 9699ae75..1e055faa 100644 --- a/src/SharpMUTerm.Core/Session/SessionManager.cs +++ b/src/SharpMUTerm.Core/Session/SessionManager.cs @@ -1,4 +1,5 @@ using SharpMUTerm.Core.Configuration; +using SharpMUTerm.Core.Logging; namespace SharpMUTerm.Core.Session; @@ -25,12 +26,18 @@ public IReadOnlyList Sessions /// /// Creates and registers an anonymous session for a world (no character, no automation). - /// Used for ad-hoc command-line connections. Does not connect it. + /// Used for ad-hoc command-line connections and for a world that has no characters configured. + /// Does not connect it. /// - public WorldSession Open(WorldDefinition world, int scrollbackCapacity = 20_000) + public WorldSession Open( + WorldDefinition world, + int scrollbackCapacity = 20_000, + TextSettings? text = null, + InputSettings? input = null) { ArgumentNullException.ThrowIfNull(world); - var session = new WorldSession(world, scrollbackCapacity: scrollbackCapacity); + var session = new WorldSession( + world, scrollbackCapacity: scrollbackCapacity, text: text, input: input); Add(session); return session; } @@ -38,17 +45,32 @@ public WorldSession Open(WorldDefinition world, int scrollbackCapacity = 20_000) /// /// Creates and registers a session for a specific character on a world, composing its /// automation from . Does not connect it. + /// + /// and are the app-wide F7/F8 preferences and + /// are passed by reference, not copied — see the constructor for why + /// that is the whole point of them. + /// /// public WorldSession Open( WorldDefinition world, CharacterDefinition character, IReadOnlyList triggerSets, - int scrollbackCapacity = 20_000) + int scrollbackCapacity = 20_000, + ILogSink? log = null, + TextSettings? text = null, + InputSettings? input = null) { ArgumentNullException.ThrowIfNull(world); ArgumentNullException.ThrowIfNull(character); ArgumentNullException.ThrowIfNull(triggerSets); - var session = new WorldSession(world, character, triggerSets, scrollbackCapacity: scrollbackCapacity); + var session = new WorldSession( + world, + character, + triggerSets, + log: log, + scrollbackCapacity: scrollbackCapacity, + text: text, + input: input); Add(session); return session; } diff --git a/src/SharpMUTerm.Core/Session/WorldSession.cs b/src/SharpMUTerm.Core/Session/WorldSession.cs index a3e0dc27..03d5e144 100644 --- a/src/SharpMUTerm.Core/Session/WorldSession.cs +++ b/src/SharpMUTerm.Core/Session/WorldSession.cs @@ -26,6 +26,10 @@ public sealed class WorldSession : IAsyncDisposable private readonly ILineParser _parser; private readonly EmojiSubstitutor? _emoji; private readonly ILogSink? _log; + private readonly TextSettings? _text; + private readonly InputSettings? _input; + private readonly TimerDefinition[] _timers; + private readonly List _timerHandles = new(); private ITelnetSession? _telnet; /// @@ -33,6 +37,13 @@ public sealed class WorldSession : IAsyncDisposable /// is composed from the union of — resolve them for a character /// via . A null character yields an anonymous /// session (e.g. an ad-hoc command-line connection) with no auto-login. + /// + /// and are the app-wide rendering and input + /// preferences the F7/F8 screens edit. They are held by reference and read per line, not + /// copied at construction, because those screens edit the live configuration object in place — + /// copying them here is exactly how a checkbox ends up needing a restart to mean anything. Null + /// (the default, and what a Core test that doesn't care passes) means "the built-in defaults". + /// /// public WorldSession( WorldDefinition world, @@ -40,12 +51,16 @@ public WorldSession( IReadOnlyList? triggerSets = null, Func? sessionFactory = null, ILogSink? log = null, - int scrollbackCapacity = 20_000) + int scrollbackCapacity = 20_000, + TextSettings? text = null, + InputSettings? input = null) { World = world ?? throw new ArgumentNullException(nameof(world)); Character = character; _sessionFactory = sessionFactory ?? DefaultSessionFactory; _log = log; + _text = text; + _input = input; _parser = CreateParser(world.ContentFormat); _emoji = world.Emoji.Enabled ? new EmojiSubstitutor(world.Emoji.Emoticons, world.Emoji.Shortcodes) @@ -56,6 +71,7 @@ public WorldSession( Triggers = new TriggerEngine(sets.SelectMany(s => s.Triggers)); Aliases = new AliasEngine(sets.SelectMany(s => s.Aliases)); Macros = new MacroEngine(sets.SelectMany(s => s.Macros)); + _timers = sets.SelectMany(s => s.Timers).ToArray(); ScriptFiles = sets.SelectMany(s => s.ScriptFiles) .Distinct(StringComparer.Ordinal) .ToArray(); @@ -148,6 +164,7 @@ public async Task ConnectAsync(CancellationToken cancellationToken = default) SetState(ConnectionState.Connected, null); PrintSystem("*** Connected."); await SendLoginAsync(cancellationToken).ConfigureAwait(false); + StartTimers(); } catch (Exception ex) { @@ -162,7 +179,8 @@ private void OnOutputReceived(object? sender, TelnetOutputEventArgs e) if (e.IsPrompt) { _parser.Feed(e.Text); - var prompt = ApplyEmoji(_parser.Flush() ?? StyledLine.Empty); + var raw = _parser.Flush() ?? StyledLine.Empty; + var prompt = ApplyEmoji(_text?.StripIncomingColour == true ? StyledText.StripColour(raw) : raw); CurrentPrompt = prompt; PromptChanged?.Invoke(this, prompt); return; @@ -182,6 +200,13 @@ private void OnOutputReceived(object? sender, TelnetOutputEventArgs e) private void ProcessOutputLine(StyledLine line) { + // Colour is stripped from what the *server* sent, before the triggers run: a highlight rule + // and this client's own system/echo lines are not "incoming ANSI colour" and keep theirs. + if (_text?.StripIncomingColour == true) + { + line = StyledText.StripColour(line); + } + var result = Triggers.Process(line); foreach (var invocation in result.ScriptInvocations) @@ -208,9 +233,15 @@ private void ProcessOutputLine(StyledLine line) /// /// Substitutes emoji across the whole line when enabled for this world (preserving word /// boundaries across span seams and each span's style/interaction); a no-op otherwise. + /// + /// The world opts in and says which substitutions it wants + /// (); F7's emoji substitution is the app-wide off + /// switch over the top of it, read here rather than at construction so unticking it stops the + /// next line rather than the next session. + /// /// private StyledLine ApplyEmoji(StyledLine line) => - _emoji is null ? line : _emoji.ApplyToLine(line); + _emoji is null || _text?.EmojiSubstitution == false ? line : _emoji.ApplyToLine(line); /// Handles a line of user input: alias expansion, local echo, and send. public async Task SendUserInputAsync(string input, CancellationToken cancellationToken = default) @@ -218,7 +249,11 @@ public async Task SendUserInputAsync(string input, CancellationToken cancellatio ArgumentNullException.ThrowIfNull(input); var expansion = Aliases.Expand(input); - if (World.LocalEcho) + + // Two switches, and both have to be on: the world's (some servers echo for you, some don't) + // and F8's app-wide one. The app-wide one is read per line, not captured, so unticking it + // stops the echo on the next command rather than the next session. + if (World.LocalEcho && _input?.LocalEcho != false) { Print(StyledLine.FromText(input, EchoStyle)); } @@ -260,6 +295,60 @@ private async Task SendLoginAsync(CancellationToken cancellationToken) } } + /// + /// Realises the active trigger sets' s on the session's + /// . Called once the connection is up, because a timer's whole job is to + /// send something, and cancelled again on disconnect () so a dropped + /// session doesn't keep firing into a closed socket. + /// + /// and are read + /// inside the callback rather than here, so flipping the F6 checkbox or retyping the + /// command takes effect on the next firing. The interval and one-shot flag are baked into the + /// schedule itself and so apply from the next connect — a running cannot be + /// re-periodised without being torn down, and tearing one down mid-cycle would silently reset + /// every other timer's phase. + /// + /// + private void StartTimers() + { + StopTimers(); + + foreach (var timer in _timers) + { + if (timer.IntervalSeconds <= 0) + { + continue; + } + + var definition = timer; + var interval = TimeSpan.FromSeconds(definition.IntervalSeconds); + void Fire() + { + if (!definition.Enabled || string.IsNullOrWhiteSpace(definition.Command)) + { + return; + } + + _ = SendRawAsync(definition.Command); + } + + _timerHandles.Add(definition.OneShot + ? Scheduler.After(interval, Fire, definition.Name) + : Scheduler.Every(interval, Fire, definition.Name)); + } + } + + /// Cancels every schedule created, leaving script timers alone. + private void StopTimers() + { + foreach (var handle in _timerHandles) + { + handle.Dispose(); + } + + _timerHandles.Clear(); + } + /// Splits a semicolon-separated command string, trimming and dropping blank segments. private static IEnumerable SplitCommands(string? commands) { @@ -320,6 +409,7 @@ private void Print(StyledLine line) private void OnDisconnected(object? sender, SessionDisconnectedEventArgs e) { + StopTimers(); SetState(e.IsClean ? ConnectionState.Disconnected : ConnectionState.Faulted, e.Error); PrintSystem(e.IsClean ? "*** Disconnected." : $"*** Connection lost: {e.Error?.Message}"); } @@ -338,11 +428,20 @@ private void SetState(ConnectionState state, Exception? error) StateChanged?.Invoke(this, new ConnectionStateChangedEventArgs(state, error)); } - private static ITelnetSession DefaultSessionFactory(ConnectionOptions options) => - new TelnetSession(new TcpTransport(options)); + /// + /// The real transport + telnet stack for this world, with the world's own + /// at the head of the CHARSET preference order — otherwise + /// a world set to Latin-1 would still negotiate UTF-8 and the F5 field would be decoration. + /// Instance-level (not static) for exactly that reason: the factory has to see the world. + /// + private ITelnetSession DefaultSessionFactory(ConnectionOptions options) => + new TelnetSession( + new TcpTransport(options), + options: new TelnetSessionOptions { CharsetOrder = TelnetSessionOptions.PreferEncoding(World.Encoding) }); public async ValueTask DisposeAsync() { + StopTimers(); Scheduler.Dispose(); _log?.Dispose(); if (_telnet is not null) diff --git a/src/SharpMUTerm.Core/Telnet/TelnetSession.cs b/src/SharpMUTerm.Core/Telnet/TelnetSession.cs index 032e0b2c..7dd34a92 100644 --- a/src/SharpMUTerm.Core/Telnet/TelnetSession.cs +++ b/src/SharpMUTerm.Core/Telnet/TelnetSession.cs @@ -21,6 +21,48 @@ public sealed class TelnetSessionOptions /// Read buffer size in bytes. public int ReceiveBufferSize { get; init; } = 8192; + + /// The default order, used when no world encoding is configured or the name isn't one. + private static Encoding[] DefaultOrder => + [ + new UTF8Encoding(encoderShouldEmitUTF8Identifier: false), + Encoding.Latin1, + ]; + + /// + /// The CHARSET preference order with first — a world's configured + /// — followed by the + /// defaults as fallbacks, each listed once. + /// + /// An unknown or unsupported name falls back to the default order rather than throwing: the F5 + /// field accepts anything the machine's encoding provider might know, and a world whose encoding + /// was renamed out from under it must still connect. Preference order is a *negotiation*, so a + /// server that doesn't offer the head of the list simply lands further down it. + /// + /// + public static Encoding[] PreferEncoding(string? name) + { + var order = DefaultOrder; + if (string.IsNullOrWhiteSpace(name)) + { + return order; + } + + Encoding preferred; + try + { + preferred = Encoding.GetEncoding(name.Trim()); + } + catch (ArgumentException) + { + return order; + } + + // UTF-8 from GetEncoding emits a BOM preamble; the default instance deliberately does not, + // so keep ours rather than replacing it with a byte-order-marked twin. + var resolved = preferred.CodePage == Encoding.UTF8.CodePage ? order[0] : preferred; + return order.Where(e => e.CodePage != resolved.CodePage).Prepend(resolved).ToArray(); + } } /// diff --git a/src/SharpMUTerm.Core/Text/StyledText.cs b/src/SharpMUTerm.Core/Text/StyledText.cs index 2aa3480e..12654d6f 100644 --- a/src/SharpMUTerm.Core/Text/StyledText.cs +++ b/src/SharpMUTerm.Core/Text/StyledText.cs @@ -45,6 +45,61 @@ public static StyledLine Restyle(StyledLine line, int start, int length, Func + /// Returns the line with every span's foreground and background reset to + /// — the "strip incoming ANSI colour" preference + /// (). + /// + /// Only the two colours go. Attributes stay, because bold/underline/reverse are how a server marks + /// structure once its palette is gone, and an interaction stays because a stripped MXP link is + /// still a link. Spans are re-coalesced, so a line that was only ever colour-differentiated + /// collapses back to one span. A line with no colour on it is returned unchanged rather than + /// rebuilt. + /// + /// + public static StyledLine StripColour(StyledLine line) + { + ArgumentNullException.ThrowIfNull(line); + + var coloured = false; + foreach (var span in line.Spans) + { + if (span.Style.Foreground.Kind != TerminalColorKind.Default || + span.Style.Background.Kind != TerminalColorKind.Default) + { + coloured = true; + break; + } + } + + if (!coloured) + { + return line; + } + + var spans = new List(line.Spans.Count); + foreach (var span in line.Spans) + { + var style = span.Style + .WithForeground(TerminalColor.Default) + .WithBackground(TerminalColor.Default); + + // Merge with the previous span when stripping made them identical, so the result has as + // few spans as the text really needs (the renderer emits one markup tag per span). + if (spans.Count > 0 && + spans[^1].Style == style && + Equals(spans[^1].Interaction, span.Interaction)) + { + spans[^1] = new StyledSpan(spans[^1].Text + span.Text, style, span.Interaction); + continue; + } + + spans.Add(new StyledSpan(span.Text, style, span.Interaction)); + } + + return new StyledLine(spans, line.RuleColor); + } + /// Rebuilds a line from a plain string and a parallel per-character style array. public static StyledLine Coalesce(string text, TextStyle[] styles) { diff --git a/src/SharpMUTerm.Tui/DraftStore.cs b/src/SharpMUTerm.Tui/DraftStore.cs new file mode 100644 index 00000000..804e6718 --- /dev/null +++ b/src/SharpMUTerm.Tui/DraftStore.cs @@ -0,0 +1,46 @@ +namespace SharpMUTerm.Tui; + +/// +/// The unsent input each window is holding — what switching tabs puts back in the command line. +/// +/// A class of its own rather than a dictionary in the app, because F8's keep per-tab drafts +/// lives here: with the preference off nothing is stashed and nothing already stashed is +/// handed back, so unticking the box empties the store on the next keystroke rather than leaving a +/// draft that reappears once it is ticked again. The rule is one predicate, read per call — the +/// preference object is the live one the settings screen edits in place — and it is testable without +/// a terminal, which the app's own key handling is not. +/// +/// +internal sealed class DraftStore(Func enabled) +{ + private readonly Dictionary _drafts = new(StringComparer.Ordinal); + private readonly Func _enabled = enabled; + + /// Records (or clears) the draft for a window. Blank text clears; disabled never keeps. + public void Record(string windowId, string? text) + { + ArgumentNullException.ThrowIfNull(windowId); + + if (string.IsNullOrEmpty(text) || !_enabled()) + { + _drafts.Remove(windowId); + return; + } + + _drafts[windowId] = text; + } + + /// The draft to put back when a window becomes visible — empty when there is none. + public string Recall(string windowId) + { + ArgumentNullException.ThrowIfNull(windowId); + return _enabled() ? _drafts.GetValueOrDefault(windowId, string.Empty) : string.Empty; + } + + /// Drops a window's draft — the command was sent, or the window was closed. + public void Clear(string windowId) + { + ArgumentNullException.ThrowIfNull(windowId); + _drafts.Remove(windowId); + } +} diff --git a/src/SharpMUTerm.Tui/MarkupFormatter.cs b/src/SharpMUTerm.Tui/MarkupFormatter.cs index 47023408..10bea4d9 100644 --- a/src/SharpMUTerm.Tui/MarkupFormatter.cs +++ b/src/SharpMUTerm.Tui/MarkupFormatter.cs @@ -1,4 +1,5 @@ using System.Text; +using SharpMUTerm.Core.Configuration; using SharpMUTerm.Core.Text; using SharpMUTerm.Core.Theming; using static SharpMUTerm.Tui.MarkupText; @@ -10,14 +11,22 @@ namespace SharpMUTerm.Tui; /// markup: truecolor foreground/background, bold/italic/underline/etc., and clickable /// s rendered as [link=…] spans. Colours are resolved through the /// active so palette-indexed and default colours land on real RGB values. +/// +/// is the app's live — the two F7 options that are +/// decisions about *markup* rather than about the model live here (allow blink, +/// underline hyperlinks). It is held by reference and read per span, because the F7 screen +/// edits that object in place: a copy would need a restart to mean anything. Null means the defaults, +/// which is what the unit tests want. +/// /// -internal sealed class MarkupFormatter(Theme theme) +internal sealed class MarkupFormatter(Theme theme, TextSettings? text = null) { // Custom link schemes so LinkClicked can tell an MXP/Pueblo command from a web hyperlink. public const string SendScheme = "mux:send:"; public const string PromptScheme = "mux:prompt:"; private readonly Theme _theme = theme; + private readonly TextSettings _text = text ?? new TextSettings(); /// Renders a whole line to a single markup string. public string ToMarkup(StyledLine line) => ToMarkup(line, null); @@ -64,7 +73,16 @@ private void AppendSpan(StringBuilder sb, StyledSpan span) sb.Append("[link=").Append(link).Append(']'); } - var styleTag = StyleTag(span.Style); + // "underline hyperlinks": a clickable span reads as clickable even when the server sent it + // unstyled. Added to the span's own attributes rather than emitted separately, so a link that + // was already underlined doesn't get two tokens. + var style = span.Style; + if (link is not null && _text.UnderlineHyperlinks) + { + style = style.AddAttribute(TextAttributes.Underline); + } + + var styleTag = StyleTag(style); if (styleTag is not null) { sb.Append(styleTag); @@ -124,6 +142,13 @@ private void AppendSpan(StringBuilder sb, StyledSpan span) tokens.Add("underline"); } + // Blink is parsed out of SGR 5/6 but dropped unless F7's "allow blink" is on: a blinking line + // is the one rendition a server can impose that the reader cannot stop looking at. + if (_text.AllowBlink && style.HasAttribute(TextAttributes.Blink)) + { + tokens.Add("blink"); + } + if (style.HasAttribute(TextAttributes.Strikethrough)) { tokens.Add("strikethrough"); diff --git a/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs b/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs index 485f3594..f2a216ed 100644 --- a/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/OptionsScreenRenderer.cs @@ -267,67 +267,38 @@ internal static OptionsScreen TextAnsiScreen(TextSettings? text = null) new("├ UNICODE", null, null), new("emoji substitution", null, settings.EmojiSubstitution, null, ScreenToggle.Bind(() => settings.EmojiSubstitution, v => settings.EmojiSubstitution = v)), - new("ambiguous width", settings.AmbiguousWidth, null, null, null, - ScreenField.Choice( - "ambiguous width", - () => settings.AmbiguousWidth, - v => settings.AmbiguousWidth = v, - AmbiguousWidths)), }); } /// - /// How East Asian ambiguous-width characters may be measured. A fixed set rather than free text: - /// the measurer only knows these two, and a typo would silently fall back to one of them. - /// - private static readonly string[] AmbiguousWidths = { "narrow", "wide" }; - - /// - /// The F8 "Input & spellcheck" screen, reflecting — and writing back to — the app's + /// The F8 "Input" screen, reflecting — and writing back to — the app's /// . + /// + /// It was "Input & spellcheck" and had a SPELLCHECK section holding check spelling and + /// dictionary. Both are gone: this client has no speller, so the checkbox promised a check + /// that never ran and the dictionary named a file nothing opened. newline key went with + /// them — the command line is a single-line PromptControl, so there is no chord that could + /// put a newline in it. The rule these follow is the one the header hints already follow: a screen + /// may not advertise a key, or a setting, that does nothing. + /// /// - internal static OptionsScreen InputSpellcheckScreen(InputSettings? input = null) + internal static OptionsScreen InputScreen(InputSettings? input = null) { var settings = input ?? new InputSettings(); - return new OptionsScreen("Input & spellcheck", "F8", new List + return new OptionsScreen("Input", "F8", new List { new("├ INPUT", null, null), new("local echo", null, settings.LocalEcho, null, ScreenToggle.Bind(() => settings.LocalEcho, v => settings.LocalEcho = v)), new("keep per-tab drafts", null, settings.KeepDrafts, null, ScreenToggle.Bind(() => settings.KeepDrafts, v => settings.KeepDrafts = v)), - new("newline key", settings.NewlineKey, null, null, null, - ScreenField.Text( - "newline key", () => settings.NewlineKey, v => settings.NewlineKey = v, NewlineKeys)), - new(string.Empty, null, null), - new("├ SPELLCHECK", null, null), - new("check spelling", null, settings.CheckSpelling, null, - ScreenToggle.Bind(() => settings.CheckSpelling, v => settings.CheckSpelling = v)), - new("dictionary", settings.Dictionary, null, null, null, - ScreenField.Text( - "dictionary", () => settings.Dictionary, v => settings.Dictionary = v, Dictionaries)), }); } - /// - /// The chords worth offering for the newline key. Suggestions, not the permitted set: what a - /// terminal actually delivers for a modified Enter varies by emulator, so a closed list would refuse - /// the one chord a given terminal can send. Listing them is what stops the field being typed blind. - /// - private static readonly string[] NewlineKeys = { "Shift+Enter", "Ctrl+Enter", "Alt+Enter", "Ctrl+J" }; - - /// - /// The dictionaries worth offering. Open for the same reason: the speller loads whichever locale is - /// installed on the machine, and a list this screen closed would be a list of what its author - /// happened to have. - /// - private static readonly string[] Dictionaries = - { "en_US", "en_GB", "de_DE", "fr_FR", "es_ES", "nl_NL", "pt_BR", "sv_SE" }; - /// The F7 "Text & ANSI" screen body. public static List TextAnsi() => Render(TextAnsiScreen()); - /// The F8 "Input & spellcheck" screen body. - public static List InputSpellcheck() => Render(InputSpellcheckScreen()); + /// The F8 "Input" screen body. + public static List Input() => Render(InputScreen()); } diff --git a/src/SharpMUTerm.Tui/SharpMUTermApp.cs b/src/SharpMUTerm.Tui/SharpMUTermApp.cs index 8a1f0c46..d7dda189 100644 --- a/src/SharpMUTerm.Tui/SharpMUTermApp.cs +++ b/src/SharpMUTerm.Tui/SharpMUTermApp.cs @@ -2,6 +2,7 @@ using SharpMUTerm.Core.Automation; using SharpMUTerm.Core.Configuration; using SharpMUTerm.Core.Input; +using SharpMUTerm.Core.Logging; using SharpMUTerm.Core.Session; using SharpMUTerm.Core.Text; using SharpMUTerm.Core.Theming; @@ -42,7 +43,7 @@ internal sealed class SharpMUTermApp : IAsyncDisposable private readonly MarkupFormatter _formatter; private readonly Workspace _workspace; private readonly Dictionary _panes = new(StringComparer.Ordinal); - private readonly Dictionary _drafts = new(StringComparer.Ordinal); + private readonly DraftStore _drafts; private readonly InputHistory _history = new(); private bool _suppressInputChanged; @@ -132,7 +133,8 @@ public SharpMUTermApp(AppConfiguration config, TerminalCapabilities capabilities _config = config; _capabilities = capabilities; _theme = ResolveTheme(config); - _formatter = new MarkupFormatter(_theme); + _formatter = new MarkupFormatter(_theme, config.Text); + _drafts = new DraftStore(() => config.Input.KeepDrafts); // Resume the last session's workspace (panes/windows/focus) when the config carries one; // otherwise start with a single main window. Real startup and the demo share this path. @@ -550,7 +552,7 @@ private async Task StartAsync(WorldDefinition? world) return; } - var session = _sessions.Open(world, _config.ScrollbackLines); + var session = OpenSession(world); BindSession(session); session.PrintSystem($"*** SharpMUTerm — theme '{_theme.Name}', graphics: {_capabilities.Protocol}."); @@ -566,6 +568,82 @@ private async Task StartAsync(WorldDefinition? world) } } + /// + /// Builds the session for a world: as its first configured character when it has one, so + /// the character's trigger sets, auto-login, on-connect lines and log actually reach the runtime. + /// A world with no characters still connects, anonymously, which is what a host typed on the + /// command line is. + /// + /// This is the seam the F2/F3/F5/F6 screens all hang off: the session holds the same + /// // objects the screens + /// edit, so editing one is seen by the next line without a reload. Adding or removing a rule is + /// not — the engines were handed the list at construction — and neither is picking a different + /// character; both need a reconnect. + /// + /// + private WorldSession OpenSession(WorldDefinition world) + { + var character = world.Characters.FirstOrDefault(); + return character is null + ? _sessions.Open(world, _config.ScrollbackLines, _config.Text, _config.Input) + : _sessions.Open( + world, + character, + _config.ResolveTriggerSets(character), + _config.ScrollbackLines, + OpenLog(world, character), + _config.Text, + _config.Input); + } + + /// + /// Opens the character's log sink for this session, per its — the + /// two fields F5 draws on the character's own row. (the default) + /// opens nothing, and a folder that can't be written is reported as a system line rather than + /// taken as a reason not to connect. + /// + /// Resolved once, at connect: a log file is a handle, and re-pointing one mid-session would mean + /// closing a file the user is still tailing. The F5 fields therefore apply on the next connect, + /// which is what the screen says. + /// + /// + private ILogSink? OpenLog(WorldDefinition world, CharacterDefinition character) + { + var format = character.Logging.Format; + if (format == LogFormat.None) + { + return null; + } + + var folder = string.IsNullOrWhiteSpace(character.Logging.Directory) + ? Path.Combine(Path.GetDirectoryName(ConfigurationStore.DefaultPath)!, "logs") + : character.Logging.Directory!; + var stem = $"{world.Name}.{character.Name}-{DateTime.Now:yyyyMMdd-HHmmss}" + .Replace(Path.DirectorySeparatorChar, '_') + .Replace(Path.AltDirectorySeparatorChar, '_'); + + try + { + var sinks = new List(2); + if (format is LogFormat.Plain or LogFormat.Both) + { + sinks.Add(PlainTextLogSink.CreateFile(Path.Combine(folder, stem + ".log"))); + } + + if (format is LogFormat.Html or LogFormat.Both) + { + sinks.Add(HtmlLogSink.CreateFile(Path.Combine(folder, stem + ".html"), stem)); + } + + return sinks.Count == 1 ? sinks[0] : new CompositeLogSink(sinks); + } + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or NotSupportedException or ArgumentException) + { + SetStatus($"[red]could not open the log:[/] {Escape(ex.Message)}"); + return null; + } + } + private void BindSession(WorldSession session) { _active = session; @@ -677,7 +755,7 @@ private void OnCommandEntered(string command) // the draft-safe history so ↑/↓ can recall it without clobbering a future draft. _history.Add(command); var windowId = ActiveWindowId(); - _drafts.Remove(windowId); + _drafts.Clear(windowId); _workspace.SetUnsentInput(windowId, false); _input.Input = string.Empty; RefreshTabTitles(); @@ -720,14 +798,9 @@ private void OnInputChanged(string text) } var windowId = ActiveWindowId(); - if (string.IsNullOrEmpty(text)) - { - _drafts.Remove(windowId); - } - else - { - _drafts[windowId] = text; - } + + // The store decides whether to keep it — that is where F8's "keep per-tab drafts" lives. + _drafts.Record(windowId, text); _workspace.SetUnsentInput(windowId, !string.IsNullOrEmpty(text)); RefreshTabTitles(); @@ -866,7 +939,7 @@ private void RefreshStatusBar() new(ConsoleKey.F5, new[] { "worlds", "settings" }, WorldsScreen), new(ConsoleKey.F6, new[] { "timers" }, TimersScreen), new(ConsoleKey.F7, new[] { "textansi" }, TextAnsiScreen), - new(ConsoleKey.F8, new[] { "input" }, InputSpellcheckScreen), + new(ConsoleKey.F8, new[] { "input" }, InputScreen), new(ConsoleKey.F9, new[] { "logging" }, CharacterLoggingScreen), }; @@ -1073,9 +1146,9 @@ private ScreenBinding TimersScreen() private ScreenBinding TextAnsiScreen() => OptionsScreen(() => OptionsScreenRenderer.TextAnsiScreen(_config.Text)); - /// Opens the F8 Input & spellcheck screen, bound to the app's input preferences. - private ScreenBinding InputSpellcheckScreen() => - OptionsScreen(() => OptionsScreenRenderer.InputSpellcheckScreen(_config.Input)); + /// Opens the F8 Input screen, bound to the app's input preferences. + private ScreenBinding InputScreen() => + OptionsScreen(() => OptionsScreenRenderer.InputScreen(_config.Input)); /// /// The shared open path for the single-list option screens (F7/F8). is @@ -1111,27 +1184,20 @@ private ScreenBinding OptionsScreen(Func sc /// looked at rather than merely asserted. /// /// - /// F7/F8 open on a checkbox rather than a value, so their scripts step the cursor down to the row - /// that holds one before pressing ⏎ at all — otherwise textansi-edit would save the screen - /// and close it, which is what ⏎ means on a row with nothing to open. + /// textansi and input have no -edit state to script any more, and their + /// scripts are empty rather than "press ⏎": every row F7 and F8 still draw is a checkbox, since + /// the three value rows those screens carried (ambiguous width, newline key, + /// dictionary) named features that do not exist and went with them. ⏎ on a row with + /// nothing to open saves and closes, so driving one would snapshot the workspace with no + /// screen on it — a frame that silently isn't of the thing it is named after. /// /// private static IEnumerable EditSnapshotKeys(string view) { - // F7/F8 are single lists whose first row is a checkbox, so ⏎ there would save and close rather - // than open anything. The cursor walks down to the row that holds a value first — the listed - // fields on those screens (ambiguous width, newline key, dictionary) are the last of their - // section, which is also why they are the ones a snapshot has to reach deliberately. - var stepsDown = view.ToLowerInvariant() switch + if (string.Equals(view, "textansi", StringComparison.OrdinalIgnoreCase) || + string.Equals(view, "input", StringComparison.OrdinalIgnoreCase)) { - "textansi" => 4, // strip · blink · underline · emoji → ambiguous width - "input" => 4, // local echo · drafts · newline key · check spelling → dictionary - _ => 0, - }; - - for (var i = 0; i < stepsDown; i++) - { - yield return Stroke('\0', ConsoleKey.DownArrow); + yield break; } yield return Stroke('\r', ConsoleKey.Enter); @@ -1480,7 +1546,7 @@ private void OnTabChanged(string paneId, TabPage? newTab) _suppressInputChanged = true; try { - _input.Input = _drafts.GetValueOrDefault(id, string.Empty); + _input.Input = _drafts.Recall(id); } finally { @@ -2438,7 +2504,7 @@ private void CyclePane() _suppressInputChanged = true; try { - _input.Input = _drafts.GetValueOrDefault(ActiveWindowId(), string.Empty); + _input.Input = _drafts.Recall(ActiveWindowId()); } finally { @@ -2459,7 +2525,7 @@ private void CloseActiveWindow() } _panes.Remove(id); - _drafts.Remove(id); + _drafts.Clear(id); _lines.Remove(id); // don't resurrect old scrollback if a same-id spawn reopens _freezePoints.Remove(id); _workspace.CloseWindow(id); diff --git a/tests/SharpMUTerm.Core.Tests/Configuration/ConfigurationTests.cs b/tests/SharpMUTerm.Core.Tests/Configuration/ConfigurationTests.cs index b27ef518..cee9f66e 100644 --- a/tests/SharpMUTerm.Core.Tests/Configuration/ConfigurationTests.cs +++ b/tests/SharpMUTerm.Core.Tests/Configuration/ConfigurationTests.cs @@ -266,19 +266,18 @@ public async Task TextAndInputPreferences_RoundTripThroughTheStore() var config = new AppConfiguration(); config.Text.StripIncomingColour = true; config.Text.UnderlineHyperlinks = false; - config.Text.AmbiguousWidth = "wide"; + config.Text.EmojiSubstitution = false; config.Input.LocalEcho = false; - config.Input.Dictionary = "en_GB"; + config.Input.KeepDrafts = false; var restored = ConfigurationStore.Deserialize(ConfigurationStore.Serialize(config)); await Assert.That(restored.Text.StripIncomingColour).IsTrue(); await Assert.That(restored.Text.AllowBlink).IsFalse(); await Assert.That(restored.Text.UnderlineHyperlinks).IsFalse(); - await Assert.That(restored.Text.AmbiguousWidth).IsEqualTo("wide"); + await Assert.That(restored.Text.EmojiSubstitution).IsFalse(); await Assert.That(restored.Input.LocalEcho).IsFalse(); - await Assert.That(restored.Input.KeepDrafts).IsTrue(); - await Assert.That(restored.Input.Dictionary).IsEqualTo("en_GB"); + await Assert.That(restored.Input.KeepDrafts).IsFalse(); } [Test] @@ -288,9 +287,31 @@ public async Task TextAndInputPreferences_DefaultWhenAConfigPredatesThem() var restored = ConfigurationStore.Deserialize("""{"version":2,"worlds":[],"triggerSets":[]}"""); await Assert.That(restored.Text.UnderlineHyperlinks).IsTrue(); - await Assert.That(restored.Text.AmbiguousWidth).IsEqualTo("narrow"); - await Assert.That(restored.Input.NewlineKey).IsEqualTo("Shift+Enter"); - await Assert.That(restored.Input.CheckSpelling).IsTrue(); + await Assert.That(restored.Text.EmojiSubstitution).IsTrue(); + await Assert.That(restored.Input.LocalEcho).IsTrue(); + await Assert.That(restored.Input.KeepDrafts).IsTrue(); + } + + /// + /// A config written by a build that still had ambiguousWidth, newlineKey, + /// checkSpelling and dictionary loads fine, keeping everything around them. Those + /// four settings were removed along with their controls (nothing read them — there is no speller, + /// no multi-line input, and column widths are the framework's), and a saved file naming them must + /// not become a config the client refuses to start on. + /// + [Test] + public async Task RetiredPreferenceKeys_AreIgnoredRatherThanFatal() + { + var restored = ConfigurationStore.Deserialize( + """ + {"version":2,"worlds":[],"triggerSets":[], + "text":{"stripIncomingColour":true,"ambiguousWidth":"wide"}, + "input":{"localEcho":false,"newlineKey":"Ctrl+J","checkSpelling":true,"dictionary":"en_GB"}} + """); + + await Assert.That(restored.Text.StripIncomingColour).IsTrue(); + await Assert.That(restored.Input.LocalEcho).IsFalse(); + await Assert.That(restored.Input.KeepDrafts).IsTrue(); } [Test] diff --git a/tests/SharpMUTerm.Core.Tests/Logging/LogSinkTests.cs b/tests/SharpMUTerm.Core.Tests/Logging/LogSinkTests.cs index 35e4d94f..1b29364d 100644 --- a/tests/SharpMUTerm.Core.Tests/Logging/LogSinkTests.cs +++ b/tests/SharpMUTerm.Core.Tests/Logging/LogSinkTests.cs @@ -66,4 +66,60 @@ public async Task Html_TruecolorRendersHex() await Assert.That(sb.ToString()).Contains("color:#123456;"); } + + /// + /// is why exists — a session holds one + /// sink, so "plain and HTML" has to be one sink that is two. + /// + [Test] + public async Task Composite_WritesThroughToEverySink() + { + var plain = new StringBuilder(); + var html = new StringBuilder(); + using (var sink = new CompositeLogSink(new ILogSink[] + { + new PlainTextLogSink(new StringWriter(plain), ownsWriter: false), + new HtmlLogSink(new StringWriter(html), ownsWriter: false), + })) + { + sink.WriteLine(Colored("hello", TerminalColor.FromIndex(1))); + sink.WriteSystem("*** system"); + } + + await Assert.That(plain.ToString()).Contains("hello"); + await Assert.That(plain.ToString()).Contains("*** system"); + await Assert.That(html.ToString()).Contains("hello"); + await Assert.That(html.ToString()).Contains(""); + } + + /// + /// A sink that throws must not stop the ones after it — a full disk on the plain log is no reason + /// to lose the HTML one — but the failure is still rethrown once the round is done. + /// + [Test] + public async Task Composite_KeepsWritingPastAThrowingSinkAndStillReportsIt() + { + var reached = new StringBuilder(); + var sink = new CompositeLogSink(new ILogSink[] + { + new ThrowingLogSink(), + new PlainTextLogSink(new StringWriter(reached), ownsWriter: false), + }); + + await Assert.That(() => sink.WriteSystem("*** system")).Throws(); + await Assert.That(reached.ToString()).Contains("*** system"); + } + + private sealed class ThrowingLogSink : ILogSink + { + public void WriteLine(StyledLine line) => throw new IOException("no room"); + + public void WriteSystem(string text) => throw new IOException("no room"); + + public void Flush() => throw new IOException("no room"); + + public void Dispose() + { + } + } } diff --git a/tests/SharpMUTerm.Core.Tests/Session/SessionManagerTests.cs b/tests/SharpMUTerm.Core.Tests/Session/SessionManagerTests.cs new file mode 100644 index 00000000..882c2990 --- /dev/null +++ b/tests/SharpMUTerm.Core.Tests/Session/SessionManagerTests.cs @@ -0,0 +1,90 @@ +using SharpMUTerm.Core.Automation; +using SharpMUTerm.Core.Configuration; +using SharpMUTerm.Core.Session; + +namespace SharpMUTerm.Core.Tests.Session; + +/// +/// The one place sessions are created. What is asserted here is the seam the shell goes through +/// when it connects: a world with a character opens as that character, with the character's +/// trigger sets composed in and the app-wide preferences passed by reference — which is what makes +/// the F2/F3/F6 screens' edits reach a running session at all. +/// +public class SessionManagerTests +{ + private static AppConfiguration Config() + { + var set = new TriggerSet { Name = "Comms" }; + set.Triggers.Add(new Trigger { Name = "pages", Pattern = "pages:" }); + set.Aliases.Add(new Alias { Name = "k", Pattern = "^k$", Substitution = "kill" }); + set.Macros.Add(new Macro { Name = "survey", Key = "Num3", Command = "look" }); + + var character = new CharacterDefinition { Name = "Corvid", TriggerSets = { "Comms" } }; + var world = new WorldDefinition { Name = "Aetherfall", Host = "h", Port = 1 }; + world.Characters.Add(character); + + return new AppConfiguration { Worlds = { world }, TriggerSets = { set } }; + } + + [Test] + public async Task OpeningAsACharacter_ComposesThatCharactersAutomation() + { + var config = Config(); + var world = config.Worlds[0]; + var character = world.Characters[0]; + await using var manager = new SessionManager(); + + var session = manager.Open(world, character, config.ResolveTriggerSets(character)); + + await Assert.That(session.SessionKey).IsEqualTo("Aetherfall.Corvid"); + await Assert.That(session.Triggers.Triggers.Count).IsEqualTo(1); + await Assert.That(session.Aliases.Aliases.Count).IsEqualTo(1); + await Assert.That(session.Macros.Resolve("Num3")).IsNotNull(); + } + + /// + /// The engine holds the same rule object the F2 screen edits, so retyping a pattern is + /// seen by the next line rather than by the next launch. Adding or removing a rule is not — the + /// engine was handed the list once — which is the distinction the screens have to live with. + /// + [Test] + public async Task AnOpenSession_SeesLaterEditsToTheRulesItWasGiven() + { + var config = Config(); + var world = config.Worlds[0]; + var character = world.Characters[0]; + await using var manager = new SessionManager(); + var session = manager.Open(world, character, config.ResolveTriggerSets(character)); + + config.TriggerSets[0].Triggers[0].Pattern = "whispers:"; + + await Assert.That(session.Triggers.Triggers[0].Regex.IsMatch("Anvil whispers: hello")).IsTrue(); + await Assert.That(session.Triggers.Triggers[0].Regex.IsMatch("Anvil pages: hello")).IsFalse(); + } + + [Test] + public async Task OpeningAnonymously_KeysOnTheWorldAndCarriesNoAutomation() + { + var config = Config(); + await using var manager = new SessionManager(); + + var session = manager.Open(config.Worlds[0], config.ScrollbackLines, config.Text, config.Input); + + await Assert.That(session.SessionKey).IsEqualTo("Aetherfall"); + await Assert.That(session.Character).IsNull(); + await Assert.That(session.Triggers.Triggers).IsEmpty(); + } + + [Test] + public async Task OpenedSessions_AreFindableByTheirKey() + { + var config = Config(); + var world = config.Worlds[0]; + await using var manager = new SessionManager(); + + manager.Open(world, world.Characters[0], config.ResolveTriggerSets(world.Characters[0])); + + await Assert.That(manager.Find("Aetherfall.Corvid")).IsNotNull(); + await Assert.That(manager.Find("Aetherfall")).IsNull(); + } +} diff --git a/tests/SharpMUTerm.Core.Tests/Session/WorldSessionPreferenceTests.cs b/tests/SharpMUTerm.Core.Tests/Session/WorldSessionPreferenceTests.cs new file mode 100644 index 00000000..b6cd4b2d --- /dev/null +++ b/tests/SharpMUTerm.Core.Tests/Session/WorldSessionPreferenceTests.cs @@ -0,0 +1,203 @@ +using SharpMUTerm.Core.Automation; +using SharpMUTerm.Core.Configuration; +using SharpMUTerm.Core.Session; +using SharpMUTerm.Core.Text; + +namespace SharpMUTerm.Core.Tests.Session; + +/// +/// The F7/F8 preferences, asserted as behaviour rather than as stored values: each one is +/// flipped and the session's output (or its echo) has to change. Every case flips the setting on a +/// session that is already connected, because these objects are the live configuration the settings +/// screens edit in place — a preference read once at construction would pass a persistence test and +/// still need a restart to mean anything, which is exactly the failure these pin against. +/// +public class WorldSessionPreferenceTests +{ + private static WorldDefinition World() => new() { Name = "T", Host = "h", Port = 1, LocalEcho = true }; + + private static (WorldSession Session, FakeTelnetSession Telnet) Create( + WorldDefinition world, + TextSettings? text = null, + InputSettings? input = null, + TriggerSet? set = null) + { + var telnet = new FakeTelnetSession(); + var session = new WorldSession( + world, + triggerSets: set is null ? null : new[] { set }, + sessionFactory: _ => telnet, + text: text, + input: input); + return (session, telnet); + } + + // ---- F7: strip incoming ANSI colour ---- + + [Test] + public async Task StripIncomingColour_Off_KeepsWhatTheServerSent() + { + var (session, telnet) = Create(World(), new TextSettings { StripIncomingColour = false }); + await session.ConnectAsync(); + + telnet.EmitLine("\x1b[31mdanger\x1b[0m"); + + var line = session.Scrollback.Snapshot().First(l => l.Text == "danger"); + await Assert.That(line.Spans[0].Style.Foreground).IsEqualTo(TerminalColor.FromIndex(1)); + } + + [Test] + public async Task StripIncomingColour_On_RendersInboundLinesInTheDefaultStyle() + { + var (session, telnet) = Create(World(), new TextSettings { StripIncomingColour = true }); + await session.ConnectAsync(); + + telnet.EmitLine("\x1b[31;44mdanger\x1b[0m"); + + var line = session.Scrollback.Snapshot().First(l => l.Text == "danger"); + await Assert.That(line.Spans[0].Style.Foreground).IsEqualTo(TerminalColor.Default); + await Assert.That(line.Spans[0].Style.Background).IsEqualTo(TerminalColor.Default); + } + + /// + /// Attributes are not colour: a server that has lost its palette still marks emphasis with bold, + /// so stripping takes the two colours and leaves the rendition alone. + /// + [Test] + public async Task StripIncomingColour_KeepsAttributes() + { + var (session, telnet) = Create(World(), new TextSettings { StripIncomingColour = true }); + await session.ConnectAsync(); + + telnet.EmitLine("\x1b[1;31mshouting\x1b[0m"); + + var line = session.Scrollback.Snapshot().First(l => l.Text == "shouting"); + await Assert.That(line.Spans[0].Style.HasAttribute(TextAttributes.Bold)).IsTrue(); + await Assert.That(line.Spans[0].Style.Foreground).IsEqualTo(TerminalColor.Default); + } + + [Test] + public async Task StripIncomingColour_TakesEffectOnTheNextLine_NotTheNextSession() + { + var text = new TextSettings { StripIncomingColour = false }; + var (session, telnet) = Create(World(), text); + await session.ConnectAsync(); + + telnet.EmitLine("\x1b[31mbefore\x1b[0m"); + text.StripIncomingColour = true; + telnet.EmitLine("\x1b[31mafter\x1b[0m"); + + var lines = session.Scrollback.Snapshot(); + var before = lines.First(l => l.Text == "before"); + var after = lines.First(l => l.Text == "after"); + await Assert.That(before.Spans[0].Style.Foreground).IsEqualTo(TerminalColor.FromIndex(1)); + await Assert.That(after.Spans[0].Style.Foreground).IsEqualTo(TerminalColor.Default); + } + + /// + /// A trigger's highlight is this client's colour, not the server's, so it survives the strip — and + /// it has to, because stripping runs before the engine does. + /// + [Test] + public async Task StripIncomingColour_LeavesATriggerHighlightAlone() + { + var set = new TriggerSet(); + set.Triggers.Add(new Trigger + { + Pattern = "tell", + Actions = new TriggerActions { HighlightForeground = TerminalColor.FromIndex(14) }, + }); + var (session, telnet) = Create(World(), new TextSettings { StripIncomingColour = true }, set: set); + await session.ConnectAsync(); + + telnet.EmitLine("\x1b[31mAnvil pages: tell me more\x1b[0m"); + + var line = session.Scrollback.Snapshot().First(l => l.Text.Contains("tell me more")); + await Assert.That(line.Spans.Any(s => s.Style.Foreground == TerminalColor.FromIndex(14))).IsTrue(); + await Assert.That(line.Spans.Any(s => s.Style.Foreground == TerminalColor.FromIndex(1))).IsFalse(); + } + + // ---- F7: emoji substitution ---- + + private static WorldDefinition EmojiWorld() + { + var world = World(); + world.Emoji.Enabled = true; + return world; + } + + [Test] + public async Task EmojiSubstitution_On_SubstitutesForAWorldThatOptedIn() + { + var (session, telnet) = Create(EmojiWorld(), new TextSettings { EmojiSubstitution = true }); + await session.ConnectAsync(); + + telnet.EmitLine("well done :smile:"); + + await Assert.That(session.Scrollback.Snapshot().Any(l => l.Text.Contains(":smile:"))).IsFalse(); + } + + [Test] + public async Task EmojiSubstitution_Off_IsTheAppWideOffSwitch() + { + var text = new TextSettings { EmojiSubstitution = true }; + var (session, telnet) = Create(EmojiWorld(), text); + await session.ConnectAsync(); + + text.EmojiSubstitution = false; + telnet.EmitLine("well done :smile:"); + + await Assert.That(session.Scrollback.Snapshot().Any(l => l.Text.Contains(":smile:"))).IsTrue(); + } + + // ---- F8: local echo ---- + + [Test] + public async Task LocalEcho_On_EchoesTypedCommands() + { + var (session, _) = Create(World(), input: new InputSettings { LocalEcho = true }); + await session.ConnectAsync(); + + await session.SendUserInputAsync("look"); + + await Assert.That(session.Scrollback.Snapshot().Any(l => l.Text == "look")).IsTrue(); + } + + [Test] + public async Task LocalEcho_Off_StopsTheEchoOnTheNextCommand() + { + var input = new InputSettings { LocalEcho = true }; + var (session, telnet) = Create(World(), input: input); + await session.ConnectAsync(); + + await session.SendUserInputAsync("look"); + input.LocalEcho = false; + await session.SendUserInputAsync("score"); + + var lines = session.Scrollback.Snapshot(); + await Assert.That(lines.Any(l => l.Text == "look")).IsTrue(); + await Assert.That(lines.Any(l => l.Text == "score")).IsFalse(); + + // Only the echo stops — both commands still reach the server. + await Assert.That(telnet.SentLines).Contains("look"); + await Assert.That(telnet.SentLines).Contains("score"); + } + + /// + /// Two switches, both of which have to be on. A world that echoes for itself keeps its own + /// LocalEcho = false whatever F8 says, so turning the app-wide one on cannot start + /// double-echoing that world. + /// + [Test] + public async Task LocalEcho_TheWorldsOwnSwitchStillWins() + { + var world = World(); + world.LocalEcho = false; + var (session, _) = Create(world, input: new InputSettings { LocalEcho = true }); + await session.ConnectAsync(); + + await session.SendUserInputAsync("look"); + + await Assert.That(session.Scrollback.Snapshot().Any(l => l.Text == "look")).IsFalse(); + } +} diff --git a/tests/SharpMUTerm.Core.Tests/Session/WorldSessionTimerTests.cs b/tests/SharpMUTerm.Core.Tests/Session/WorldSessionTimerTests.cs new file mode 100644 index 00000000..78199696 --- /dev/null +++ b/tests/SharpMUTerm.Core.Tests/Session/WorldSessionTimerTests.cs @@ -0,0 +1,182 @@ +using SharpMUTerm.Core.Automation; +using SharpMUTerm.Core.Configuration; +using SharpMUTerm.Core.Session; + +namespace SharpMUTerm.Core.Tests.Session; + +/// +/// The F6 screen's timers, asserted as commands actually reaching the server. Before this the +/// list was persisted, edited and never realised by anything: the +/// session's only ever held script timers, so a configured timer was +/// a row of JSON that fired nowhere. +/// +/// Intervals here are milliseconds-long on purpose, and every wait is a poll with a ceiling rather +/// than a fixed sleep, so the tests are quick without being timing-fragile. +/// +/// +public class WorldSessionTimerTests +{ + private static WorldDefinition World() => new() { Name = "T", Host = "h", Port = 1 }; + + private static (WorldSession Session, FakeTelnetSession Telnet) Create(TriggerSet set) + { + var telnet = new FakeTelnetSession(); + var session = new WorldSession(World(), triggerSets: new[] { set }, sessionFactory: _ => telnet); + return (session, telnet); + } + + /// Polls until holds or the ceiling passes; returns whether it did. + private static async Task Eventually(Func condition, int millisecondsCeiling = 3000) + { + var deadline = DateTime.UtcNow.AddMilliseconds(millisecondsCeiling); + while (DateTime.UtcNow < deadline) + { + if (condition()) + { + return true; + } + + await Task.Delay(10); + } + + return condition(); + } + + [Test] + public async Task AnEnabledTimer_SendsItsCommandOnceConnected() + { + var set = new TriggerSet(); + set.Timers.Add(new TimerDefinition { Name = "idle", IntervalSeconds = 0.05, Command = "@@idle" }); + var (session, telnet) = Create(set); + + await session.ConnectAsync(); + + await Assert.That(await Eventually(() => telnet.SentLines.Contains("@@idle"))).IsTrue(); + await session.DisposeAsync(); + } + + [Test] + public async Task ADisabledTimer_SendsNothing() + { + var set = new TriggerSet(); + set.Timers.Add(new TimerDefinition + { + Name = "idle", + IntervalSeconds = 0.02, + Command = "@@idle", + Enabled = false, + }); + var (session, telnet) = Create(set); + + await session.ConnectAsync(); + await Task.Delay(200); + + await Assert.That(telnet.SentLines.Contains("@@idle")).IsFalse(); + await session.DisposeAsync(); + } + + /// + /// The F6 checkbox is read at each firing, not when the schedule is built, so unticking a running + /// timer stops it without a reconnect. This is the difference between "live" and "applied at + /// startup" for the one setting on these screens that acts without being provoked. + /// + [Test] + public async Task FlippingEnabled_StopsAndStartsARunningTimer() + { + var timer = new TimerDefinition + { + Name = "idle", + IntervalSeconds = 0.03, + Command = "@@idle", + Enabled = false, + }; + var set = new TriggerSet(); + set.Timers.Add(timer); + var (session, telnet) = Create(set); + + await session.ConnectAsync(); + await Task.Delay(150); + await Assert.That(telnet.SentLines.Contains("@@idle")).IsFalse(); + + timer.Enabled = true; + + await Assert.That(await Eventually(() => telnet.SentLines.Contains("@@idle"))).IsTrue(); + await session.DisposeAsync(); + } + + /// The command is read per firing too, so retyping it re-points a live timer. + [Test] + public async Task EditingTheCommand_AppliesToTheNextFiring() + { + var timer = new TimerDefinition { Name = "poll", IntervalSeconds = 0.03, Command = "first" }; + var set = new TriggerSet(); + set.Timers.Add(timer); + var (session, telnet) = Create(set); + + await session.ConnectAsync(); + await Assert.That(await Eventually(() => telnet.SentLines.Contains("first"))).IsTrue(); + + timer.Command = "second"; + + await Assert.That(await Eventually(() => telnet.SentLines.Contains("second"))).IsTrue(); + await session.DisposeAsync(); + } + + [Test] + public async Task AOneShotTimer_FiresExactlyOnce() + { + var set = new TriggerSet(); + set.Timers.Add(new TimerDefinition + { + Name = "greet", + IntervalSeconds = 0.03, + Command = "hello", + OneShot = true, + }); + var (session, telnet) = Create(set); + + await session.ConnectAsync(); + await Assert.That(await Eventually(() => telnet.SentLines.Contains("hello"))).IsTrue(); + await Task.Delay(200); + + await Assert.That(telnet.SentLines.Count(l => l == "hello")).IsEqualTo(1); + await session.DisposeAsync(); + } + + /// A zero (or negative) interval is the definition's own "disabled", and never schedules. + [Test] + public async Task AnIntervalOfZero_IsNotScheduled() + { + var set = new TriggerSet(); + set.Timers.Add(new TimerDefinition { Name = "never", IntervalSeconds = 0, Command = "nope" }); + var (session, telnet) = Create(set); + + await session.ConnectAsync(); + await Task.Delay(150); + + await Assert.That(telnet.SentLines.Contains("nope")).IsFalse(); + await session.DisposeAsync(); + } + + /// + /// A dropped connection cancels the schedules rather than leaving them ticking against a closed + /// socket. Asserted on the scheduler's own count, not on the absence of sends: a disconnected + /// session refuses to send anyway, so "nothing arrived" would pass with the timers still running. + /// + [Test] + public async Task Disconnecting_CancelsTheTimers() + { + var set = new TriggerSet(); + set.Timers.Add(new TimerDefinition { Name = "idle", IntervalSeconds = 0.03, Command = "@@idle" }); + var (session, telnet) = Create(set); + + await session.ConnectAsync(); + await Assert.That(await Eventually(() => telnet.SentLines.Contains("@@idle"))).IsTrue(); + await Assert.That(session.Scheduler.Count).IsEqualTo(1); + + await session.DisconnectAsync(); + + await Assert.That(session.Scheduler.Count).IsEqualTo(0); + await session.DisposeAsync(); + } +} diff --git a/tests/SharpMUTerm.Core.Tests/Telnet/CharsetOrderTests.cs b/tests/SharpMUTerm.Core.Tests/Telnet/CharsetOrderTests.cs new file mode 100644 index 00000000..a310f28d --- /dev/null +++ b/tests/SharpMUTerm.Core.Tests/Telnet/CharsetOrderTests.cs @@ -0,0 +1,70 @@ +using System.Text; +using SharpMUTerm.Core.Telnet; + +namespace SharpMUTerm.Core.Tests.Telnet; + +/// +/// A world's encoding (F5) is the head of the CHARSET preference order it negotiates with. +/// Before this it was drawn in the status bar and nowhere else — the session always offered UTF-8 +/// first whatever the field said. +/// +public class CharsetOrderTests +{ + [Test] + public async Task PreferEncoding_PutsTheWorldsEncodingFirst() + { + var order = TelnetSessionOptions.PreferEncoding("ISO-8859-1"); + + await Assert.That(order[0].CodePage).IsEqualTo(Encoding.Latin1.CodePage); + } + + /// + /// The rest of the default order stays behind it as fallbacks, each listed once: preference order + /// is a negotiation, and a server that won't speak the head of the list has to land somewhere. + /// + [Test] + public async Task PreferEncoding_KeepsTheDefaultsBehindItWithoutDuplicating() + { + var order = TelnetSessionOptions.PreferEncoding("ISO-8859-1"); + + await Assert.That(order.Length).IsEqualTo(2); + await Assert.That(order[1].CodePage).IsEqualTo(Encoding.UTF8.CodePage); + await Assert.That(order.Select(e => e.CodePage).Distinct().Count()).IsEqualTo(order.Length); + } + + /// + /// UTF-8 asked for by name resolves to the BOM-less instance the default order already holds, not + /// to , which emits a preamble. + /// + [Test] + public async Task PreferEncoding_Utf8_StaysBomless() + { + var order = TelnetSessionOptions.PreferEncoding("UTF-8"); + + await Assert.That(order[0].CodePage).IsEqualTo(Encoding.UTF8.CodePage); + await Assert.That(order[0].GetPreamble().Length).IsEqualTo(0); + await Assert.That(order.Length).IsEqualTo(2); + } + + [Test] + [Arguments(null)] + [Arguments("")] + [Arguments(" ")] + [Arguments("not-an-encoding")] + public async Task PreferEncoding_UnknownOrMissing_FallsBackToTheDefaultOrder(string? name) + { + var order = TelnetSessionOptions.PreferEncoding(name); + + await Assert.That(order[0].CodePage).IsEqualTo(Encoding.UTF8.CodePage); + await Assert.That(order[1].CodePage).IsEqualTo(Encoding.Latin1.CodePage); + } + + /// The options a session is built with default to the same order, so nothing regressed. + [Test] + public async Task DefaultOptions_StillLeadWithUtf8() + { + var options = new TelnetSessionOptions(); + + await Assert.That(options.CharsetOrder[0].CodePage).IsEqualTo(Encoding.UTF8.CodePage); + } +} diff --git a/tests/SharpMUTerm.Core.Tests/Text/StyledTextTests.cs b/tests/SharpMUTerm.Core.Tests/Text/StyledTextTests.cs index 43aad1ef..f32ad0aa 100644 --- a/tests/SharpMUTerm.Core.Tests/Text/StyledTextTests.cs +++ b/tests/SharpMUTerm.Core.Tests/Text/StyledTextTests.cs @@ -41,4 +41,77 @@ public async Task Coalesce_MergesAdjacentEqualStyles() var line = StyledText.Coalesce("abc", styles); await Assert.That(line.Spans).HasSingleItem(); } + + [Test] + public async Task StripColour_ResetsBothColoursAndMergesTheSpansThatBecameEqual() + { + var line = new StyledLine(new[] + { + new StyledSpan("red", new TextStyle(TerminalColor.FromIndex(1), TerminalColor.Default, TextAttributes.None)), + new StyledSpan("blue", new TextStyle(TerminalColor.FromIndex(4), TerminalColor.FromIndex(7), TextAttributes.None)), + }); + + var stripped = StyledText.StripColour(line); + + await Assert.That(stripped.Text).IsEqualTo("redblue"); + await Assert.That(stripped.Spans).HasSingleItem(); + await Assert.That(stripped.Spans[0].Style.Foreground).IsEqualTo(TerminalColor.Default); + await Assert.That(stripped.Spans[0].Style.Background).IsEqualTo(TerminalColor.Default); + } + + /// + /// Attributes and interactions survive: bold is how a server marks emphasis once its palette is + /// gone, and a stripped MXP link is still a link. + /// + [Test] + public async Task StripColour_KeepsAttributesAndInteractions() + { + var style = new TextStyle(TerminalColor.FromIndex(2), TerminalColor.Default, TextAttributes.Bold); + var line = new StyledLine(new[] + { + new StyledSpan("north", style, SpanInteraction.Command("north")), + }); + + var stripped = StyledText.StripColour(line); + + await Assert.That(stripped.Spans[0].Style.HasAttribute(TextAttributes.Bold)).IsTrue(); + await Assert.That(stripped.Spans[0].Interaction!.Target).IsEqualTo("north"); + } + + /// Two spans that differ only by their link stay two spans, or the link would spread. + [Test] + public async Task StripColour_DoesNotMergeAcrossDifferentInteractions() + { + var style = new TextStyle(TerminalColor.FromIndex(2), TerminalColor.Default, TextAttributes.None); + var line = new StyledLine(new[] + { + new StyledSpan("north", style, SpanInteraction.Command("north")), + new StyledSpan(" east", style, SpanInteraction.Command("east")), + }); + + var stripped = StyledText.StripColour(line); + + await Assert.That(stripped.Spans.Count).IsEqualTo(2); + } + + [Test] + public async Task StripColour_LeavesAnUncolouredLineExactlyAsItWas() + { + var line = StyledLine.FromText("plain", TextStyle.Default); + + await Assert.That(StyledText.StripColour(line)).IsSameReferenceAs(line); + } + + /// + /// The trigger left-rule is this client's mark, not the server's colour, so it rides through. + /// + [Test] + public async Task StripColour_KeepsTheRuleColour() + { + var line = new StyledLine( + new[] { new StyledSpan("hit", new TextStyle(TerminalColor.FromIndex(1), TerminalColor.Default, TextAttributes.None)) }, + TerminalColor.FromIndex(14)); + + await Assert.That(StyledText.StripColour(line).RuleColor).IsEqualTo(TerminalColor.FromIndex(14)); + } } diff --git a/tests/SharpMUTerm.Tui.Tests/DraftStoreTests.cs b/tests/SharpMUTerm.Tui.Tests/DraftStoreTests.cs new file mode 100644 index 00000000..24e9cfb4 --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/DraftStoreTests.cs @@ -0,0 +1,106 @@ +using SharpMUTerm.Core.Configuration; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// F8's keep per-tab drafts, asserted as behaviour: with it on a switched-away tab hands its +/// typing back, with it off it does not. The preference is the live the +/// screen edits in place, so every case flips it on a store that already holds a draft. +/// +public class DraftStoreTests +{ + [Test] + public async Task On_KeepsWhatWasTypedInEachWindow() + { + var input = new InputSettings { KeepDrafts = true }; + var drafts = new DraftStore(() => input.KeepDrafts); + + drafts.Record("main", "say hello"); + drafts.Record("chat", "page anvil=hi"); + + await Assert.That(drafts.Recall("main")).IsEqualTo("say hello"); + await Assert.That(drafts.Recall("chat")).IsEqualTo("page anvil=hi"); + } + + [Test] + public async Task Off_KeepsNothing() + { + var input = new InputSettings { KeepDrafts = false }; + var drafts = new DraftStore(() => input.KeepDrafts); + + drafts.Record("main", "say hello"); + + await Assert.That(drafts.Recall("main")).IsEqualTo(string.Empty); + } + + /// + /// Unticking the box drops what was already stashed rather than hiding it: a draft that + /// reappeared the moment the box was ticked again would be the setting failing on exactly the + /// keystroke that tests it. + /// + [Test] + public async Task TurningItOff_DropsADraftThatWasAlreadyHeld() + { + var input = new InputSettings { KeepDrafts = true }; + var drafts = new DraftStore(() => input.KeepDrafts); + drafts.Record("main", "say hello"); + + input.KeepDrafts = false; + var whileOff = drafts.Recall("main"); + input.KeepDrafts = true; + + await Assert.That(whileOff).IsEqualTo(string.Empty); + await Assert.That(drafts.Recall("main")).IsEqualTo("say hello"); + } + + /// + /// The next keystroke on a window with the box off clears its stored draft for good, which is + /// what makes the store empty rather than merely silent. + /// + [Test] + public async Task TypingWhileItIsOff_ClearsTheStoredDraft() + { + var input = new InputSettings { KeepDrafts = true }; + var drafts = new DraftStore(() => input.KeepDrafts); + drafts.Record("main", "say hello"); + + input.KeepDrafts = false; + drafts.Record("main", "say hello there"); + input.KeepDrafts = true; + + await Assert.That(drafts.Recall("main")).IsEqualTo(string.Empty); + } + + [Test] + public async Task BlankInput_ClearsTheDraft() + { + var drafts = new DraftStore(() => true); + drafts.Record("main", "half a thought"); + + drafts.Record("main", string.Empty); + + await Assert.That(drafts.Recall("main")).IsEqualTo(string.Empty); + } + + [Test] + public async Task Clear_DropsOneWindowWithoutTouchingTheOthers() + { + var drafts = new DraftStore(() => true); + drafts.Record("main", "one"); + drafts.Record("chat", "two"); + + drafts.Clear("main"); + + await Assert.That(drafts.Recall("main")).IsEqualTo(string.Empty); + await Assert.That(drafts.Recall("chat")).IsEqualTo("two"); + } + + [Test] + public async Task AnUnknownWindow_RecallsNothing() + { + var drafts = new DraftStore(() => true); + + await Assert.That(drafts.Recall("never-typed-in")).IsEqualTo(string.Empty); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/MarkupFormatterTests.cs b/tests/SharpMUTerm.Tui.Tests/MarkupFormatterTests.cs index dbbecc5c..ea9f9328 100644 --- a/tests/SharpMUTerm.Tui.Tests/MarkupFormatterTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/MarkupFormatterTests.cs @@ -1,3 +1,4 @@ +using SharpMUTerm.Core.Configuration; using SharpMUTerm.Core.Text; using SharpMUTerm.Core.Theming; using SharpMUTerm.Tui; @@ -137,4 +138,100 @@ public async Task EmptyLine_ProducesEmptyMarkup() { await Assert.That(Formatter.ToMarkup(StyledLine.Empty)).IsEqualTo(string.Empty); } + + // ---- F7 preferences that are decisions about markup ---- + + private static StyledLine Blinking() => new(new[] + { + new StyledSpan("alert", new TextStyle(TerminalColor.Default, TerminalColor.Default, TextAttributes.Blink)), + }); + + /// + /// SGR 5 is parsed but dropped by default: a blinking line is the one rendition a server can + /// impose that the reader cannot stop looking at. F7's allow blink is what lets it through. + /// + [Test] + public async Task AllowBlink_Off_DropsTheBlinkAttribute() + { + var formatter = new MarkupFormatter(ThemeLibrary.Dark(), new TextSettings { AllowBlink = false }); + + await Assert.That(formatter.ToMarkup(Blinking())).DoesNotContain("blink"); + } + + [Test] + public async Task AllowBlink_On_EmitsTheBlinkToken() + { + var formatter = new MarkupFormatter(ThemeLibrary.Dark(), new TextSettings { AllowBlink = true }); + + await Assert.That(formatter.ToMarkup(Blinking())).Contains("blink"); + } + + /// The setting is read per span, so flipping it changes the very next line rendered. + [Test] + public async Task AllowBlink_FlippingIt_ChangesTheNextLine() + { + var text = new TextSettings { AllowBlink = false }; + var formatter = new MarkupFormatter(ThemeLibrary.Dark(), text); + + var before = formatter.ToMarkup(Blinking()); + text.AllowBlink = true; + var after = formatter.ToMarkup(Blinking()); + + await Assert.That(before).DoesNotContain("blink"); + await Assert.That(after).Contains("blink"); + } + + private static StyledLine LinkLine() => new(new[] + { + new StyledSpan("site", TextStyle.Default, SpanInteraction.Link("https://example.org")), + }); + + [Test] + public async Task UnderlineHyperlinks_On_UnderlinesAClickableSpan() + { + var formatter = new MarkupFormatter(ThemeLibrary.Dark(), new TextSettings { UnderlineHyperlinks = true }); + + await Assert.That(formatter.ToMarkup(LinkLine())).Contains("underline"); + } + + [Test] + public async Task UnderlineHyperlinks_Off_LeavesAnUnstyledLinkUnstyled() + { + var formatter = new MarkupFormatter(ThemeLibrary.Dark(), new TextSettings { UnderlineHyperlinks = false }); + var markup = formatter.ToMarkup(LinkLine()); + + await Assert.That(markup).DoesNotContain("underline"); + await Assert.That(markup).Contains("[link=https://example.org]"); + } + + /// It underlines links, not everything — plain text is untouched either way. + [Test] + public async Task UnderlineHyperlinks_DoesNotTouchPlainText() + { + var formatter = new MarkupFormatter(ThemeLibrary.Dark(), new TextSettings { UnderlineHyperlinks = true }); + + await Assert.That(formatter.ToMarkup(StyledLine.FromText("hello", TextStyle.Default))) + .DoesNotContain("underline"); + } + + /// + /// A link the server already underlined gets one token, not two: the preference is folded into the + /// span's own attributes rather than emitted alongside them. + /// + [Test] + public async Task UnderlineHyperlinks_OnAnAlreadyUnderlinedLink_EmitsOneToken() + { + var formatter = new MarkupFormatter(ThemeLibrary.Dark(), new TextSettings { UnderlineHyperlinks = true }); + var line = new StyledLine(new[] + { + new StyledSpan( + "site", + new TextStyle(TerminalColor.Default, TerminalColor.Default, TextAttributes.Underline), + SpanInteraction.Link("https://example.org")), + }); + + var markup = formatter.ToMarkup(line); + + await Assert.That(markup.Split("underline").Length - 1).IsEqualTo(1); + } } diff --git a/tests/SharpMUTerm.Tui.Tests/OptionsScreenRendererTests.cs b/tests/SharpMUTerm.Tui.Tests/OptionsScreenRendererTests.cs index 4b6640ae..239414dd 100644 --- a/tests/SharpMUTerm.Tui.Tests/OptionsScreenRendererTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/OptionsScreenRendererTests.cs @@ -25,10 +25,10 @@ public async Task Render_ToggleRow_FalseRendersUncheckedBox() [Test] public async Task Render_ValueRow_ShowsLabelAndValue() { - var rows = new[] { new OptionsScreenRenderer.OptionRow("dictionary", "en_US", null) }; - var lines = OptionsScreenRenderer.Render("Input & spellcheck", "F8", rows); - var row = lines.Single(l => l.Contains("dictionary")); - await Assert.That(row).Contains("en_US"); + var rows = new[] { new OptionsScreenRenderer.OptionRow("scrollback", "20000", null) }; + var lines = OptionsScreenRenderer.Render("Input", "F8", rows); + var row = lines.Single(l => l.Contains("scrollback")); + await Assert.That(row).Contains("20000"); } [Test] @@ -63,9 +63,9 @@ public async Task Render_SpacerRow_IsBlankLine() public async Task Render_HeaderAndFooter_MatchPattern() { var lines = OptionsScreenRenderer.Render( - "Input & spellcheck", "F8", Array.Empty()); + "Input", "F8", Array.Empty()); await Assert.That(lines[0]).DoesNotContain("‹ back"); - await Assert.That(lines[0]).Contains("Input & spellcheck"); + await Assert.That(lines[0]).Contains("Input"); await Assert.That(lines[0]).Contains("F8"); await Assert.That(lines[^1]).Contains("Cancel"); await Assert.That(lines[^1]).Contains("Save"); @@ -89,19 +89,41 @@ public async Task TextAnsi_ContainsExpectedLabelsAndSections() await Assert.That(lines.Any(l => l.Contains("allow blink"))).IsTrue(); await Assert.That(lines.Any(l => l.Contains("underline hyperlinks"))).IsTrue(); await Assert.That(lines.Any(l => l.Contains("emoji substitution"))).IsTrue(); - await Assert.That(lines.Any(l => l.Contains("ambiguous width") && l.Contains("narrow"))).IsTrue(); + } + + /// + /// F7 no longer offers ambiguous width. Every column measurement in this app is + /// SharpConsoleUI's, which has no East-Asian-ambiguous policy to set, so the row stored a string + /// nothing read. Asserted as an absence so it cannot drift back in without this being noticed. + /// + [Test] + public async Task TextAnsi_DoesNotOfferAmbiguousWidth() + { + var lines = OptionsScreenRenderer.TextAnsi(); + await Assert.That(lines.Any(l => l.Contains("ambiguous width"))).IsFalse(); } [Test] - public async Task InputSpellcheck_ContainsExpectedLabelsAndSections() + public async Task Input_ContainsExpectedLabelsAndSections() { - var lines = OptionsScreenRenderer.InputSpellcheck(); + var lines = OptionsScreenRenderer.Input(); await Assert.That(lines.Any(l => l.Contains("INPUT"))).IsTrue(); - await Assert.That(lines.Any(l => l.Contains("SPELLCHECK"))).IsTrue(); await Assert.That(lines.Any(l => l.Contains("local echo"))).IsTrue(); await Assert.That(lines.Any(l => l.Contains("keep per-tab drafts"))).IsTrue(); - await Assert.That(lines.Any(l => l.Contains("newline key") && l.Contains("Shift+Enter"))).IsTrue(); - await Assert.That(lines.Any(l => l.Contains("check spelling"))).IsTrue(); - await Assert.That(lines.Any(l => l.Contains("dictionary") && l.Contains("en_US"))).IsTrue(); + } + + /// + /// The screen is "Input", not "Input & spellcheck": there is no speller in this client, so + /// check spelling and dictionary were removed rather than left promising a check + /// that never ran. newline key went with them — the command line is a single-line control. + /// + [Test] + public async Task Input_DoesNotOfferSpellcheckOrANewlineKey() + { + var lines = OptionsScreenRenderer.Input(); + await Assert.That(lines.Any(l => l.Contains("SPELLCHECK"))).IsFalse(); + await Assert.That(lines.Any(l => l.Contains("check spelling"))).IsFalse(); + await Assert.That(lines.Any(l => l.Contains("dictionary"))).IsFalse(); + await Assert.That(lines.Any(l => l.Contains("newline key"))).IsFalse(); } } diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenCursorTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenCursorTests.cs index 634df0ab..e72b2ff2 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenCursorTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenCursorTests.cs @@ -273,7 +273,19 @@ public async Task HeaderHints_SwapToTheEditingKeysWhileAFieldIsOpen() { new() { Name = "Aardwolf", Host = "aardmud.org", Characters = new List { new() } }, }; - var options = OptionsScreenRenderer.InputSpellcheckScreen(); + + // A synthetic options screen, not F7 or F8: both of those are all-checkbox screens now (their + // value rows named features that do not exist and went with them), so neither can stand for + // "an options screen that does offer an editor". The shared renderer still draws one. + var value = "en_US"; + var options = new OptionsScreenRenderer.OptionsScreen( + "Values", + "F8", + new List + { + new("a value", value, null, null, null, + ScreenField.Text("a value", () => value, v => value = v)), + }); return new List<(string, ScreenModel)> { @@ -290,10 +302,15 @@ public async Task HeaderHints_SwapToTheEditingKeysWhileAFieldIsOpen() }; } - /// The same screens with nothing to edit — empty lists, and an options screen of toggles. + /// + /// The same screens with nothing to edit — empty lists, and the two real options screens, which + /// are now entirely checkboxes and so must not advertise ⏎ edit. + /// private static List<(string Header, ScreenModel Model)> Bare() { var empty = new List(); + var textAnsi = OptionsScreenRenderer.TextAnsiScreen(); + var input = OptionsScreenRenderer.InputScreen(); var toggles = new OptionsScreenRenderer.OptionsScreen( "Toggles", "F7", @@ -304,6 +321,12 @@ public async Task HeaderHints_SwapToTheEditingKeysWhileAFieldIsOpen() return new List<(string, ScreenModel)> { + Pair( + OptionsScreenRenderer.Model(textAnsi), + m => OptionsScreenRenderer.HeaderLine(textAnsi.Title, textAnsi.FKey, 0, m)), + Pair( + OptionsScreenRenderer.Model(input), + m => OptionsScreenRenderer.HeaderLine(input.Title, input.FKey, 0, m)), Pair(TriggersScreenRenderer.Model(empty, -1), m => TriggersScreenRenderer.HeaderLine(0, m)), Pair(AliasesScreenRenderer.Model(empty, -1), m => AliasesScreenRenderer.HeaderLine(0, m)), Pair(TimersScreenRenderer.Model(empty, -1), m => TimersScreenRenderer.HeaderLine(0, m)), diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenFieldRenderingTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenFieldRenderingTests.cs index cfcc0921..fa30b992 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenFieldRenderingTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenFieldRenderingTests.cs @@ -201,18 +201,36 @@ public async Task Keypad_DrawsTheNameAndCommandBuffersInTheBindingRowItself() await Assert.That(name.Single(HasCaret)).Contains("Surve"); } + /// + /// The shared options renderer draws the caret on the value row the cursor is on, skipping section + /// headers and spacers when it counts. The rows are synthetic because neither real options screen + /// carries a value any more — F7's ambiguous width and F8's newline key/ + /// dictionary were removed with the features they named — but the renderer still has to do + /// this, so the assertion is kept and given rows of its own rather than dropped with them. + /// [Test] public async Task Options_DrawsTheBufferOnTheValueRowUnderTheCursor() { - var screen = OptionsScreenRenderer.InputSpellcheckScreen(); - - // Navigable rows: 0 local echo, 1 drafts, 2 newline key, 3 check spelling, 4 dictionary. - var newline = OptionsScreenRenderer.BodyColumn(screen.Rows, Edit(0, 2, 0, "Ctrl+Enter")); - await Assert.That(Carets(newline)).IsEqualTo(1); - await Assert.That(newline.Single(HasCaret)).Contains("newline key"); - - var dictionary = OptionsScreenRenderer.BodyColumn(screen.Rows, Edit(0, 4, 0, "en_GB")); - await Assert.That(dictionary.Single(HasCaret)).Contains("dictionary"); + var first = "one"; + var second = "two"; + var rows = new List + { + new("├ SECTION", null, null), + new("a toggle", null, true, null, ScreenToggle.Bind(() => true, _ => { })), + new("first value", first, null, null, null, + ScreenField.Text("first value", () => first, v => first = v)), + new(string.Empty, null, null), + new("second value", second, null, null, null, + ScreenField.Text("second value", () => second, v => second = v)), + }; + + // Navigable rows: 0 a toggle, 1 first value, 2 second value. + var opened = OptionsScreenRenderer.BodyColumn(rows, Edit(0, 1, 0, "typed")); + await Assert.That(Carets(opened)).IsEqualTo(1); + await Assert.That(opened.Single(HasCaret)).Contains("first value"); + + var later = OptionsScreenRenderer.BodyColumn(rows, Edit(0, 2, 0, "also")); + await Assert.That(later.Single(HasCaret)).Contains("second value"); } /// diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenFooterTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenFooterTests.cs index c002d45c..c99f7c00 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenFooterTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenFooterTests.cs @@ -48,7 +48,7 @@ public class ScreenFooterTests var sets = Sets(); var worlds = Worlds(); var macros = sets[0].Macros; - var options = OptionsScreenRenderer.InputSpellcheckScreen(); + var options = OptionsScreenRenderer.InputScreen(); var accent = WorldsScreenRenderer.AccentFor(worlds, 0); return new List<(string, string, string)> diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs index 96ec1d50..c6a24cf9 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs @@ -306,12 +306,19 @@ public async Task Options_NavigableRowsSkipSectionHeadersAndSpacers() var screen = OptionsScreenRenderer.TextAnsiScreen(); var model = OptionsScreenRenderer.Model(screen); - // 8 display rows: 2 section headers + 1 spacer + 5 options. - await Assert.That(screen.Rows.Count).IsEqualTo(8); + // 7 display rows: 2 section headers + 1 spacer + 4 options. It was 8/5 while F7 still carried + // "ambiguous width"; that row named a measurement policy the framework does not expose, so it + // went, and both the display count and the navigable count drop by exactly the one row. + await Assert.That(screen.Rows.Count).IsEqualTo(7); await Assert.That(model.PaneCount).IsEqualTo(1); - await Assert.That(model.Sizes[0]).IsEqualTo(5); + await Assert.That(model.Sizes[0]).IsEqualTo(4); } + /// + /// F7 is four checkboxes and nothing else now — every row is a toggle, so there is no value row + /// for ⏎ to open. Asserted here rather than only in the renderer test, because it is what makes + /// HasEditableRow false for this screen and so what removes ⏎ edit from its header. + /// [Test] public async Task Options_TextAnsiRowsWriteBackToTheTextSettings() { @@ -324,21 +331,29 @@ public async Task Options_TextAnsiRowsWriteBackToTheTextSettings() model.ToggleAt(0, 2)!.Value.Flip(); await Assert.That(text.UnderlineHyperlinks).IsFalse(); - // "ambiguous width" is a value row: reachable, but nothing to press yet. - await Assert.That(model.ToggleAt(0, 4)).IsNull(); + model.ToggleAt(0, 3)!.Value.Flip(); + await Assert.That(text.EmojiSubstitution).IsFalse(); + + await Assert.That(model.HasEditableRow).IsFalse(); } [Test] public async Task Options_InputRowsWriteBackToTheInputSettings() { var input = new InputSettings(); - var model = OptionsScreenRenderer.Model(OptionsScreenRenderer.InputSpellcheckScreen(input)); + var model = OptionsScreenRenderer.Model(OptionsScreenRenderer.InputScreen(input)); + + // Two rows, both checkboxes: spellcheck and the newline key went with the features they + // described, and neither survivor has a value to type. + await Assert.That(model.Sizes[0]).IsEqualTo(2); model.ToggleAt(0, 0)!.Value.Flip(); await Assert.That(input.LocalEcho).IsFalse(); - model.ToggleAt(0, 3)!.Value.Flip(); - await Assert.That(input.CheckSpelling).IsFalse(); + model.ToggleAt(0, 1)!.Value.Flip(); + await Assert.That(input.KeepDrafts).IsFalse(); + + await Assert.That(model.HasEditableRow).IsFalse(); } /// diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenReadOnlyTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenReadOnlyTests.cs index 253fa80b..a20a49fd 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenReadOnlyTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenReadOnlyTests.cs @@ -255,7 +255,7 @@ public async Task Options_EveryCheckboxBelongsToARowTheModelCanToggle() var screens = new[] { OptionsScreenRenderer.TextAnsiScreen(), - OptionsScreenRenderer.InputSpellcheckScreen(), + OptionsScreenRenderer.InputScreen(), }; foreach (var screen in screens) @@ -357,7 +357,7 @@ private static List Headers() WorldsScreenRenderer.HeaderLine(80, WorldsScreenRenderer.Model(worlds, sets, 0, 0)), TimersScreenRenderer.HeaderLine(80, TimersScreenRenderer.Model(sets, 0)), Header(OptionsScreenRenderer.TextAnsiScreen()), - Header(OptionsScreenRenderer.InputSpellcheckScreen()), + Header(OptionsScreenRenderer.InputScreen()), WorldsScreenRenderer.HeaderLine( 80, WorldsScreenRenderer.Model(worlds, sets, 0, 0), null, WorldsScreenRenderer.LogFKey), }; @@ -380,7 +380,7 @@ private static string Header(OptionsScreenRenderer.OptionsScreen screen) => ("F5 worlds", WorldsScreenRenderer.FooterLine(worlds, 0, 0, accent, 80)), ("F6 timers", TimersScreenRenderer.FooterLine(sets, 0, 80)), ("F7 text", OptionsScreenRenderer.FooterLine(OptionsScreenRenderer.TextAnsiScreen().Rows, 80)), - ("F8 input", OptionsScreenRenderer.FooterLine(OptionsScreenRenderer.InputSpellcheckScreen().Rows, 80)), + ("F8 input", OptionsScreenRenderer.FooterLine(OptionsScreenRenderer.InputScreen().Rows, 80)), ("F9 worlds (the character's log)", WorldsScreenRenderer.FooterLine(worlds, 0, 0, accent, 80)), }; } From 37c5f6a9536c53a1054a10fa17f571977f068a90 Mon Sep 17 00:00:00 2001 From: Harry Cordewener Date: Tue, 28 Jul 2026 22:55:03 -0500 Subject: [PATCH 19/23] F4: make macros fire, make keys rebindable, stop handing out dead keys MacroEngine.Resolve and HandleKeyAsync existed and were unit-tested, and nothing in the app had ever called either -- so no configured macro had ever sent a command, on any key. Dispatch now runs from the main window's preview handler: before the focused control so a binding beats the prompt, not raised while a modal holds the keyboard, and after global shortcuts so app-claimed chords never arrive. MacroEngine keyed its dictionary on the descriptor string, which is a cache of Macro.Key -- a rebound macro would have answered to its old key until reconnect. It now reads Key per lookup. Which chords can actually arrive is read out of the framework's input parser rather than assumed, and the screen says so: the whole numpad never arrives (no DECKPAM is sent and SS3 decodes only a fixed set), so those rows are drawn muted behind a warning marker with captions naming the reason. Ctrl+F1 survives the parser fully and is the one live binding in the demo config. A key is now rebindable through a capture mode -- the next keypress becomes the binding -- rather than by typing a key name as text. Esc is the only non-candidate so capture cannot trap you, and a duplicate is refused with capture still armed rather than created, because a second macro on one key is the one dead row with no symptom: both look alive. Also fixes the add button, which the previous pass flagged rather than changed. It claimed the lowest free numpad digit -- provably dead now that the delivery verdicts exist -- so a new binding was born unable to fire. It claims from MacroKeys.Bindable instead, whose entries are filtered through the same verdicts the screen draws from, so the candidate list cannot drift from what actually works. 1071 tests pass, up from 999. Three pinned assertions changed, all predicted and all pinning the numpad claim this removes; they now assert against Bindable and additionally that the claimed key fires. Still owed: none of this has been seen in a real terminal. The verdicts are read from the parser and asserted, the frames are headless. --- CLAUDE.md | 2 +- README.md | 6 +- docs/HANDOFF.md | 141 +++++-- src/SharpMUTerm.Core/Automation/Macro.cs | 146 ++++++- .../Automation/MacroEngine.cs | 52 ++- src/SharpMUTerm.Tui/KeypadScreenRenderer.cs | 169 ++++++-- src/SharpMUTerm.Tui/MacroKeys.cs | 294 +++++++++++++ src/SharpMUTerm.Tui/ScreenChrome.cs | 47 ++- src/SharpMUTerm.Tui/ScreenField.cs | 53 ++- src/SharpMUTerm.Tui/SettingsSession.cs | 43 +- src/SharpMUTerm.Tui/SharpMUTermApp.cs | 183 ++++++-- .../Automation/AliasAndMacroTests.cs | 120 ++++++ .../MacroDispatchEndToEndTests.cs | 182 ++++++++ .../MacroKeyCaptureTests.cs | 391 ++++++++++++++++++ .../ScreenListButtonTests.cs | 42 +- 15 files changed, 1746 insertions(+), 125 deletions(-) create mode 100644 src/SharpMUTerm.Tui/MacroKeys.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/MacroDispatchEndToEndTests.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/MacroKeyCaptureTests.cs diff --git a/CLAUDE.md b/CLAUDE.md index 65b67178..036a61ad 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -32,7 +32,7 @@ fallbacks) for inline images/maps. ## Repository state **M1 delivered, plus substantial M2–M4 work.** `SharpMUTerm.slnx` builds all ten projects on -`net10.0`; the solution has **999 tests**, all passing. In place: +`net10.0`; the solution has **1071 tests**, all passing. In place: - **Core** — `AnsiParser` (SGR 16/256/truecolor), styled-line + `ScrollbackBuffer` model, `TcpTransport` (TLS + IPv6), `TelnetSession` (wraps TelnetNegotiationCore **2.5.3**), diff --git a/README.md b/README.md index 16fbad7b..e90d63b1 100644 --- a/README.md +++ b/README.md @@ -60,8 +60,10 @@ HTML logging · GMCP / MSDP / MSSP / MCCP · MXP + Pueblo · Unicode/emoji. are recognised and discarded. - **Scrollback** — bounded, thread-safe styled-line model with change events. - **Automation** — regex **triggers** (gag / highlight / rewrite / respond / spawn-route / - script), **aliases** (capture-group expansion, multi-command), **macros/keybinds**, and a - recurring/one-shot **timer** scheduler. User regexes run with a ReDoS match-timeout guard. + script), **aliases** (capture-group expansion, multi-command), **macros/keybinds** (F-keys and + Ctrl/Alt chords — the numpad is not deliverable through the terminal, and F4 says so per + binding), and a recurring/one-shot **timer** scheduler. User regexes run with a ReDoS + match-timeout guard. - **MXP & Pueblo** — first-class parsers for both markup protocols: tags → styled spans, with **clickable** ``/`` links and commands (`SpanInteraction`), colours, entities, and line breaks. Selectable per world. diff --git a/docs/HANDOFF.md b/docs/HANDOFF.md index c46e2d71..8eeadf61 100644 --- a/docs/HANDOFF.md +++ b/docs/HANDOFF.md @@ -4,8 +4,8 @@ Context for whoever (human or agent) picks up this work next. - **Repository:** `SharpMUSH/SharpMUTerm` - **Start from:** a fresh branch off `main` -- **Tests:** 999 across the solution (375 Core / 83 Graphics / 42 Scripting / - 28 Web / 471 Tui), all passing; `dotnet build SharpMUTerm.slnx` clean (0 warnings +- **Tests:** 1071 across the solution (396 Core / 83 Graphics / 42 Scripting / + 28 Web / 522 Tui), all passing; `dotnet build SharpMUTerm.slnx` clean (0 warnings from this repo; building against a local SharpConsoleUI clone surfaces 2 upstream NuGet advisory warnings for AngleSharp, which are the framework's, not ours) @@ -35,13 +35,23 @@ works. the total is asserted separately. - **No `duplicate` on F6 or F4, deliberately.** A timer is three values, two of which you would change in the copy, so `[+ timer]` and typing is no slower. A - macro is identified by its `Key`, which this screen cannot edit — a copy would - land on the key its original already holds, and the second macro on a key never - fires (`MacroEngine` is a dictionary), so the button's only possible result is a - dead row. -- **F4's add button claims a numpad key and says which** (`[+ binding] Num3`), - because a binding created on an unnamed key would be unfixable from this screen. - Once all ten digits are bound the button isn't drawn at all. + macro copy would land on the key its original already holds, and the second + macro on a key never fires — which is now a state the F4 key capture actively + *refuses* to create, so a button whose only possible result is that state would + be contradicting the field beside it. +- **F4's add button claims a numpad key and says which** (`[+ binding] Num3`). + Once all ten digits are bound the button isn't drawn at all. **That claim is now + the wrong one** — no numpad chord reaches this host (see *Which keys can + actually fire*), so a fresh binding is born dead and has to be rebound on its + own row before it does anything. It still claims a digit only because the claimed + key is a pinned assertion (`ScreenListButtonTests.AddingABindingClaimsTheLowestFree + NumpadKeyAndNamesIt` asserts `Num0`, then `Num1`), and moving the claim to the + first free *deliverable* chord (`F1`, `F10`–`F12`, then `Ctrl+F1`…) means + changing an asserted value. **That is the next thing to do on this screen.** +- **A macro's key is editable**, as the binding row's *third* field + (`KeypadScreenRenderer.KeyField`, appended so the name and command ordinals did + not move) and as a **key capture** rather than a text buffer — see *Key capture* + under Critical Gotchas. - **New items:** trigger and alias arrive enabled, timer arrives **disabled**. A timer is the only one of the four that acts without being provoked; the others wait for output or for a keypress. @@ -68,11 +78,11 @@ works. `Name` went `init` → `set`; none of them has cached derived state (checked: the engines match on patterns and `MacroEngine` is keyed by `Macro.Key`), which `AutomationCloneTests.RenamingLeavesTheCompiledMatcherAlone` pins. -- **Rows still not editable** (deliberately): a macro's *key* (rebinding needs a - key-capture mode, not a text buffer), a character's password (it is +- **Rows still not editable** (deliberately): a character's password (it is `[JsonIgnore]` and belongs in a credential store), and everything derived (the numpad grid, the session/state readouts). **All of them now say so on screen** — - see *Editable vs read-only rows* under Critical Gotchas. + see *Editable vs read-only rows* under Critical Gotchas. A macro's key used to be + on this list and no longer is. - **A world's TLS and certificate flags are live**, as the two checkboxes of F5's fourth pane, drawn where the read-only `security TLS on · certs strict` line used to be. Two booleans is two checkboxes and a `ScreenRow` carries one, so it @@ -189,8 +199,10 @@ Things that will waste your time if you don't know them. `keypad`, `textansi`, `input`, `logging`, `freeze`, `spawn`, `split`, `move`, `drag`, `history`, `menu`, `menu-split`, plus the default (no `--view`) workspace. Extra state toggles: `collapsed`, `prefix`, `timestamps`. Any settings screen also - takes a `-edit` suffix (`worlds-edit`, `logging-edit`, …), which opens it and - drives real keys in so the frame shows a field mid-edit. + takes a `-edit` suffix (`worlds-edit`, `logging-edit`, `keypad-edit`, …), which + opens it and drives real keys in so the frame shows a field mid-edit — + `keypad-edit` steps to the binding's **key capture**, the one screen state no + amount of typing can reach. - **Send the user the `.svg`** — they view it fine. Do **not** rely on your own SVG→PNG for pixel checks near the bottom (see next point). - **SVG→PNG clipping trap:** Chromium clips the bottom of a bare `.svg` file @@ -383,7 +395,9 @@ What the framework actually provides (read at v2.5.14, not assumed): abandons the buffer and leaves the screen up. Inside an edit: typing inserts, Backspace/Delete remove, ←→/Home/End move the caret, ↑↓ walk the drawn candidate list (typing narrows it), - ⇥ commits and steps to the row's next field, ⏎ commits. + ⇥ commits and steps to the row's next field, ⏎ commits. **One field kind takes the + keyboard whole** — F4's key capture, where only Esc means anything else; see *Key + capture* below. - **Validation is at commit, not per keystroke.** Any character can be typed; ⏎/⇥/⌃S validate. A rejected value keeps the edit open, marks the field with the reason, and writes nothing — `ScreenEdits.Apply(field, value)` is the only path @@ -443,9 +457,13 @@ What the framework actually provides (read at v2.5.14, not assumed): `idx:N` and `none` typed in full — a `TerminalColor` already in config may be a colour no short palette names, and a picker that refused the value it was showing would make an existing highlight uneditable. -- **Making a Core property settable? Check for cached derived state.** - `Trigger.Pattern`, `Alias.Pattern` and now **`Trigger.CaseSensitive`** drop their - compiled `Regex` on write, like `Alias.CaseSensitive` always did — otherwise the +- **Making a Core property settable? Check for cached derived state.** The cache is + not always on the object: **`Macro.Key`** had none of its own, and the thing + holding a stale copy was `MacroEngine`'s *dictionary key*. Making it settable meant + dropping the dictionary. Look at what indexes the property, not only at what the + property computes. `Trigger.Pattern`, `Alias.Pattern` and + **`Trigger.CaseSensitive`** drop their compiled `Regex` on write, like + `Alias.CaseSensitive` always did — otherwise the rule goes on matching the pattern (or the casing) it no longer has, invisibly, until a line arrives. The other four that became settable for F2's action fields — `Rewrite`, `SendResponse`, `ScriptCallback`, `AddAttributes` — carry no cache @@ -502,13 +520,19 @@ categories, and where each control sits: (`SharpMUTermApp.OpenLog`), a timer's `interval`/`one-shot`, and **adding or removing** any rule (the engines were handed the list once). Reconnect, don't restart. -- **Still inert, and why.** F4's numpad **bindings never fire**: nothing maps a key - press to `WorldSession.HandleKeyAsync`, and SharpConsoleUI's input parser never - produces `ConsoleKey.NumPad0..9` at all (grep it — there are no occurrences), so - the fix is application-keypad decoding in the driver, i.e. upstream. A world's - `keepalive` seconds only picks the status bar's fake ack figure — there is no - keepalive, and adding one wants a raw `IAC NOP` write that bypasses the - interpreter's escaping (`ITelnetSession` has no such path today). +- **Live, as of the macro-dispatch work.** F4's **bindings fire**, for the chords + this host can actually deliver — `SharpMUTermApp.DispatchMacro`, on the main + window's `PreviewKeyPressed`, resolves the key through the *session's* + `MacroEngine` and sends it with `WorldSession.HandleKeyAsync`. Editing a + binding's key, name, command or enabled state applies to the next keystroke; the + engine no longer caches the descriptor. **Adding or removing** a binding still + wants a reconnect, like every other rule. The numpad specifically **still cannot + fire** — see *Which keys can actually fire* under Critical Gotchas — and F4 now + says so on the row rather than leaving it to be discovered. +- **Still inert, and why.** A world's `keepalive` seconds only picks the status + bar's fake ack figure — there is no keepalive, and adding one wants a raw + `IAC NOP` write that bypasses the interpreter's escaping (`ITelnetSession` has no + such path today). **The shell connects as the world's first configured character** (`SharpMUTermApp.OpenSession`). Before that it opened an *anonymous* session, which @@ -516,6 +540,67 @@ is why so much of F2–F6 was unreachable however correct Core was: no character meant no trigger sets, no auto-login, no log. Picking a *different* character still has no UI. +### Which keys can actually fire (read the parser, don't assume) + +Read out of SharpConsoleUI 2.5.14's `AnsiInputParser` (Unix) and +`NetConsoleDriver.MapAnsiToConsoleKeyInfo` (Windows), not guessed. `MacroKeys` +holds the verdicts and is the **one** definition — `MacroKeys.Descriptor`, which +the dispatcher binds on, is literally `MacroKeys.Capture` filtered by +`MacroKeys.Verdict`, which is what F4 draws. So the screen and the handler cannot +drift, and `MacroKeyCaptureTests` asserts that over every `ConsoleKey`. + +- **Deliverable:** `F1`–`F12` with any modifiers (`ESC[1;5P`, `ESC[15;5~` — + `AnsiInputParser.cs:505,553-564` + `ParseModifiers` at `:661-680`); + Ctrl+letter (raw control byte, `:199-206`); Alt+anything (ESC prefix, `:264-273`); + modified arrows/Home/End/PgUp/PgDn/Ins/Del (`:494-501,547-552`). +- **Never arrives:** **the whole numpad.** `grep -rn NumPad` over the framework + returns nothing; it sends no DECKPAM, and `ProcessSs3` (`:325-349`) decodes only + `P/Q/R/S/A–D/H/F`, so application-keypad `ESC O p…y` is *discarded*. In numeric + mode a numpad digit arrives as `ConsoleKey.D5`, indistinguishable from the main + row. Also never: Ctrl+Alt+letter (emits a bare Escape *then* Ctrl+letter, + `:275-279`), Ctrl+Shift+letter (the control byte carries no Shift), Ctrl+I/M/J/H + (they *are* Tab/Enter/Enter/Backspace, `:187-198`), Ctrl+digit (`0x1C`–`0x1F` are + dropped at `:241`), and Alt+O (swallowed as the SS3 introducer, `:248-262`). +- **Taken:** every chord in `MacroKeys.AppShortcuts` — a global shortcut runs + *before* any window (`InputCoordinator.cs:131`), so a macro can never outrank + one. And unmodified letters/digits/arrows, which are the prompt's. +- **The app registers from that same list.** `SharpMUTermApp.RegisterGlobalShortcuts` + walks `MacroKeys.AppShortcuts` and throws at startup if a claim has no action **or** + if a settings screen's F-key isn't claimed. Add a shortcut in one place only. +- **Ctrl+Tab is registered and does not arrive on Unix** (Tab is `0x09` with no + modifiers; `CSI Z` is Shift+Tab). Left in place — the Windows `Console.ReadKey` + path does report it — but don't count on it. + +### Key capture (F4's rebinding mode) + +- **`ScreenField.Key` is a field whose value is a keystroke.** ⏎ ⇥ ⇥ on a binding + row arms it; `SettingsSession.HandleCapture` turns the next key into a canonical + descriptor and commits it through the ordinary undo log. There is no second modal + state and no new key-routing layer — it is the existing edit with its buffer fed + by one keystroke instead of many. +- **Esc is never a candidate**, and is the only key that isn't. It is the way out of + every modal state these screens have; ⏎ and ⇥ can't be the escape hatch because + both are chords someone might reasonably want to bind. A key with no descriptor at + all (a lone modifier) is swallowed and the capture stays armed. +- **Two refusals, both at the moment the key is pressed**, because the alternative + is a row that looks bound, is bound, and does nothing: a chord that cannot fire + (the verdict's own words), and a chord another binding already holds + (`already bound to `). The capture stays armed carrying the reason, so the + answer is another keystroke rather than a lost edit. +- **The chrome swaps wholesale while armed** — `press any key to bind it · Esc + cancels`, and `[any key] Bind` in the footer. It may not offer `⏎ commit`, + `⇥ next field` or `F4 close`: all three mean something else for as long as the + prompt is up, and all three would be refused as bindings if pressed. +- **`Macro.Key` is `set` now, and `MacroEngine` holds macros rather than a + dictionary keyed on their descriptors.** The dictionary was a cache of the one + property that became editable; a rebound macro went on answering to its old key + until the next reconnect. Same trap as `Trigger.Pattern`'s compiled `Regex`, and + the same answer — except here there is nothing left to drop. +- **`MacroKey.Canonicalise`** settles spelling (`shift+ctrl+f1` → `Ctrl+Shift+F1`, + `NumPad5` → `Num5`) and leaves `Ctrl+F1`/`Num5` — the two shapes already in + configurations — untouched. A key name it doesn't know is kept verbatim rather + than renamed. + ### Dropdowns (a field's candidate list) - **`ScreenChrome.Choices(column, edit, width)` is the whole feature**, called once @@ -556,7 +641,8 @@ has no UI. value whose vocabulary this screen doesn't own. - **Snapshot states:** `triggers-edit` (open list, mark moved), `route-edit` (narrowed to one), `highlight-edit` (17 capped to 6), `logging-edit` (closed, - drawn upward). **There is no `textansi-edit` / `input-edit` any more** — F7 and F8 + drawn upward), `keypad-edit` (an armed key capture — no list at all, since the + vocabulary is the keyboard). **There is no `textansi-edit` / `input-edit` any more** — F7 and F8 are all checkboxes now, and ⏎ on a checkbox row saves and closes, so driving one would snapshot a workspace with no screen on it. `EditSnapshotKeys` returns nothing for those two views rather than a keystroke that closes the thing being framed. @@ -604,7 +690,8 @@ has no UI. | `src/SharpMUTerm.Tui/SettingsSession.cs` | Key → action for an open settings screen (the whole interaction contract, testable) | | `src/SharpMUTerm.Tui/ScreenSelection.cs` | Pure pane/cursor state machine for the settings screens | | `src/SharpMUTerm.Tui/ScreenModel.cs` | A screen's navigable panes; a `ScreenRow` is a stop, a checkbox, a record of editable fields, or both | -| `src/SharpMUTerm.Tui/ScreenField.cs` | One editable value: read / validate / write / snapshot, plus the text, number, regex, choice and enum kinds | +| `src/SharpMUTerm.Tui/ScreenField.cs` | One editable value: read / validate / write / snapshot, plus the text, number, regex, choice, enum and **key-capture** kinds | +| `src/SharpMUTerm.Tui/MacroKeys.cs` | What the host can deliver: per-chord verdicts, the app's own claimed shortcuts, and the descriptor the macro dispatcher acts on | | `src/SharpMUTerm.Tui/ScreenEdits.cs` | The undo log behind Cancel/Save | | `src/SharpMUTerm.Tui/PaneDragTracker.cs` | Pure drag gesture state machine + `MouseFlags` decoding | | `src/SharpMUTerm.Tui/PaneDragSurface.cs` | Pane rectangles + active windows, frozen at press | diff --git a/src/SharpMUTerm.Core/Automation/Macro.cs b/src/SharpMUTerm.Core/Automation/Macro.cs index 5b161861..6c2e5272 100644 --- a/src/SharpMUTerm.Core/Automation/Macro.cs +++ b/src/SharpMUTerm.Core/Automation/Macro.cs @@ -1,3 +1,5 @@ +using System.Globalization; + namespace SharpMUTerm.Core.Automation; /// @@ -9,14 +11,24 @@ public sealed class Macro { /// /// What the binding is called, for the lists that show it. Settable so the F4 screen can rename one - /// live; nothing is derived from it — is keyed by , never - /// by name — so there is no cache to drop. deliberately stays init: it - /// is the engine's key, and rebinding it needs a key-capture mode rather than a text field. + /// live; nothing is derived from it — resolves on , never + /// on the name — so there is no cache to drop. /// public string Name { get; set; } = string.Empty; - /// The normalised key descriptor that triggers this macro. - public required string Key { get; init; } + /// + /// The normalised key descriptor that triggers this macro. Settable so the F4 screen can rebind one + /// live, through its key-capture mode rather than a text buffer. + /// + /// It is what looks a keystroke up by, so it is precisely the + /// property that must not be cached anywhere: the engine therefore reads it per press rather than + /// holding a dictionary keyed on the string it was handed at construction, which would leave a + /// rebound macro still answering to the key it no longer carries until the next reconnect. That is + /// the same trap and guard against + /// by dropping their compiled matcher on write. + /// + /// + public required string Key { get; set; } public bool Enabled { get; set; } = true; @@ -30,6 +42,17 @@ public sealed class Macro public string? ScriptCallback { get; init; } } +/// +/// A key descriptor taken apart: the modifiers held down, and the name of the key itself. Produced by +/// so a descriptor can be reasoned about — is it a function key, does +/// it carry Ctrl — without every caller re-splitting the string. +/// +/// The base key's canonical name (F1, K, Num5, Up). +/// Whether Ctrl is part of the chord. +/// Whether Alt is part of the chord. +/// Whether Shift is part of the chord. +public readonly record struct MacroKeyParts(string Key, bool Ctrl, bool Alt, bool Shift); + /// Builds and normalises key descriptor strings so bindings compare consistently. public static class MacroKey { @@ -59,4 +82,117 @@ public static string Describe(string key, bool ctrl = false, bool alt = false, b parts.Add(key); return string.Join('+', parts); } + + /// + /// Splits a descriptor into its modifiers and its base key, settling the spelling of both. Modifier + /// words are matched case-insensitively and may appear in any order (shift+ctrl+f1 parses); + /// the base key is normalised through so the several spellings a key is + /// written with in the wild (NumPad5/Num5, PgUp/PageUp, esc) + /// arrive as one. + /// + /// Returns false for a descriptor with no base key, an empty component, or a word before the last + /// + that names no modifier — a caller that cannot say what a descriptor is must not + /// pretend it knows, because the answer decides whether a binding is drawn as one that fires. + /// + /// + public static bool TryParse(string? descriptor, out MacroKeyParts parts) + { + parts = default; + if (string.IsNullOrWhiteSpace(descriptor)) + { + return false; + } + + var words = descriptor.Trim().Split('+'); + bool ctrl = false, alt = false, shift = false; + for (var i = 0; i < words.Length - 1; i++) + { + switch (words[i].Trim().ToLowerInvariant()) + { + case "ctrl" or "control": ctrl = true; break; + case "alt": alt = true; break; + case "shift": shift = true; break; + default: return false; + } + } + + var key = words[^1].Trim(); + if (key.Length == 0) + { + return false; + } + + parts = new MacroKeyParts(Normalise(key), ctrl, alt, shift); + return true; + } + + /// + /// The canonical spelling of a descriptor — the form a capture writes and the form a stored binding + /// is compared in — or null when it does not parse. shift+ctrl+f1 and Ctrl+Shift+F1 + /// are the same binding and come back identical; Num5 and Ctrl+F1, the two shapes + /// already in configurations, come back untouched. + /// + public static string? Canonicalise(string? descriptor) => + TryParse(descriptor, out var parts) ? Describe(parts.Key, parts.Ctrl, parts.Alt, parts.Shift) : null; + + /// + /// The canonical name of a base key. Letters upper-case, function keys F1–F24, numpad + /// digits Num0–Num9, and one spelling each for the navigation and editing keys. A name + /// this does not recognise is kept verbatim rather than rejected: a configuration may name a key this + /// client has never heard of, and silently renaming it would be worse than leaving it alone. + /// + private static string Normalise(string key) + { + var lower = key.ToLowerInvariant(); + + if (lower.Length is 1 && char.IsAsciiLetter(lower[0])) + { + return lower.ToUpperInvariant(); + } + + if ((Digits(lower, "numpad") ?? Digits(lower, "num")) is { } pad) + { + return "Num" + pad.ToString(CultureInfo.InvariantCulture); + } + + if (Digits(lower, "f") is { } function && function is >= 1 and <= 24) + { + return "F" + function.ToString(CultureInfo.InvariantCulture); + } + + return lower switch + { + "up" or "uparrow" => "Up", + "down" or "downarrow" => "Down", + "left" or "leftarrow" => "Left", + "right" or "rightarrow" => "Right", + "home" => "Home", + "end" => "End", + "pageup" or "pgup" => "PageUp", + "pagedown" or "pgdn" or "pagedn" => "PageDown", + "insert" or "ins" => "Insert", + "delete" or "del" => "Delete", + "enter" or "return" => "Enter", + "escape" or "esc" => "Escape", + "tab" => "Tab", + "backspace" => "Backspace", + "space" or "spacebar" => "Space", + _ => key, + }; + } + + /// The number after a prefix (f11 → 11, num5 → 5), or null when it isn't one. + private static int? Digits(string lower, string prefix) + { + if (!lower.StartsWith(prefix, StringComparison.Ordinal)) + { + return null; + } + + var rest = lower[prefix.Length..]; + return rest.Length > 0 + && int.TryParse(rest, NumberStyles.None, CultureInfo.InvariantCulture, out var value) + ? value + : null; + } } diff --git a/src/SharpMUTerm.Core/Automation/MacroEngine.cs b/src/SharpMUTerm.Core/Automation/MacroEngine.cs index 48b3b4ab..392dbc42 100644 --- a/src/SharpMUTerm.Core/Automation/MacroEngine.cs +++ b/src/SharpMUTerm.Core/Automation/MacroEngine.cs @@ -1,19 +1,26 @@ namespace SharpMUTerm.Core.Automation; -/// Maps normalised key descriptors to bindings. +/// +/// Resolves normalised key descriptors to bindings. +/// +/// It holds the macros themselves and reads on every lookup. It used to be a +/// Dictionary keyed on that string, which was a cache of a value the F4 screen can now change: +/// rebinding a macro left the dictionary answering to the key the macro no longer carried, invisibly, +/// until the next reconnect rebuilt the engine. The same reason drops its +/// compiled matcher on write — except that here there is nothing to drop, because there is nothing +/// derived left to hold. +/// +/// public sealed class MacroEngine { - private readonly Dictionary _byKey = new(StringComparer.OrdinalIgnoreCase); + private readonly List _macros = new(); private readonly object _gate = new(); public MacroEngine(IEnumerable? macros = null) { if (macros is not null) { - foreach (var macro in macros) - { - _byKey[macro.Key] = macro; - } + _macros.AddRange(macros); } } @@ -23,26 +30,35 @@ public IReadOnlyCollection Macros { lock (_gate) { - return _byKey.Values.ToArray(); + return _macros.ToArray(); } } } - /// Adds or replaces the binding for a key. + /// Adds a binding, replacing whichever one already holds its key. public void Add(Macro macro) { ArgumentNullException.ThrowIfNull(macro); lock (_gate) { - _byKey[macro.Key] = macro; + var at = IndexOf(macro.Key); + if (at >= 0) + { + _macros[at] = macro; + } + else + { + _macros.Add(macro); + } } } public bool Remove(string key) { + ArgumentNullException.ThrowIfNull(key); lock (_gate) { - return _byKey.Remove(key); + return _macros.RemoveAll(m => Matches(m, key)) > 0; } } @@ -50,17 +66,27 @@ public void Clear() { lock (_gate) { - _byKey.Clear(); + _macros.Clear(); } } - /// Returns the enabled macro bound to , or null. + /// + /// Returns the enabled macro bound to , or null. Two macros on one + /// key is a configuration the F4 screen refuses to create, but a hand-edited file can still hold + /// one: the first wins, the way 's first matching pattern does. + /// public Macro? Resolve(string keyDescriptor) { ArgumentNullException.ThrowIfNull(keyDescriptor); lock (_gate) { - return _byKey.TryGetValue(keyDescriptor, out var macro) && macro.Enabled ? macro : null; + var at = IndexOf(keyDescriptor); + return at >= 0 && _macros[at].Enabled ? _macros[at] : null; } } + + private int IndexOf(string key) => _macros.FindIndex(m => Matches(m, key)); + + private static bool Matches(Macro macro, string key) => + string.Equals(macro.Key, key, StringComparison.OrdinalIgnoreCase); } diff --git a/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs b/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs index e3a74648..3a887e1f 100644 --- a/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs @@ -13,6 +13,13 @@ namespace SharpMUTerm.Tui; /// and the footer action bar. composes these into real panels (grids) /// for the live/snapshot view; merges the same blocks into a single line list /// for the unit tests. Pure so every block is testable. +/// +/// Every drawn key carries : a binding whose chord can never reach the +/// app is marked on its own row and explained in the footer, and the numpad caption says the same for +/// the grid as a whole. That is the screen's one hard rule — a list of bindings may not contain a row +/// that quietly does nothing, and the only way to keep that promise is to ask what the keyboard can +/// actually deliver rather than assuming a stored descriptor means something. +/// /// internal static class KeypadScreenRenderer { @@ -24,14 +31,21 @@ internal static class KeypadScreenRenderer /// /// The binding row's field ordinals, in the order ⇥ steps through them. The name leads, as it does - /// on every list screen. The key is deliberately not among them: it is - /// 's lookup key, and rebinding it needs a key-capture mode rather than a - /// text buffer — which is also why duplicate is not offered here (see ). + /// on every list screen. /// internal const int NameField = 0; internal const int CommandField = 1; + /// + /// The binding's key, as a capture: ⏎ ⇥ ⇥ arms it and the next + /// keystroke becomes the binding. It is appended rather than slotted in beside the key the + /// row draws first, because an ordinal is an address the renderer, the model, the tests and the + /// snapshot key scripts all use, and inserting one silently moves every caret after it — the same + /// rule that put F5's log fields and F2's action fields at the end of their rows. + /// + internal const int KeyField = 2; + /// The label the binding list's add button carries; it names the key it will claim. internal const string AddBindingLabel = "+ binding"; @@ -121,24 +135,57 @@ internal static ScreenModel Model( return new ScreenModel(ScreenModel.Rows(macros, macro => ScreenRow.Of( ScreenToggle.Bind(() => macro.Enabled, v => macro.Enabled = v), ScreenField.Name("name", () => macro.Name, v => macro.Name = v), - ScreenField.Text("command", () => macro.Command, v => macro.Command = v))) + ScreenField.Text("command", () => macro.Command, v => macro.Command = v), + ScreenField.Key("key", () => macro.Key, v => macro.Key = v, key => AlreadyBound(macros, macro, key)))) .Concat(Buttons(sets, selected)) .ToArray()); } + /// + /// Whether another binding already holds a key, and which — the refusal a key capture needs. A + /// resolves one macro per key, so the second binding on a key never runs: + /// letting a capture create one would mint exactly the dead row the capture mode exists to remove, + /// and it would be a dead row with no symptom at all, since both rows would look alive. + /// + /// The comparison spans every set the screen was handed, not just the one the binding lives in. It is + /// deliberately the stricter reading: a session flattens the character's sets into one engine, so two + /// sets that are ever enabled together collide — and a screen that only refused collisions inside one + /// set would be right about the sets it could see and wrong about the runtime. + /// + /// + private static string? AlreadyBound(IReadOnlyList macros, Macro self, string key) + { + var canonical = MacroKey.Canonicalise(key) ?? key.Trim(); + foreach (var macro in macros) + { + if (!ReferenceEquals(macro, self) + && string.Equals(macro.Key, canonical, StringComparison.OrdinalIgnoreCase)) + { + return $"already bound to {Identify(macro)}"; + } + } + + return null; + } + /// /// The binding list's buttons. Adding claims the first unbound numpad digit and *says which* - /// ([[+ binding]] Num3): a is identified by its - /// , which this screen deliberately cannot edit (rebinding wants a - /// key-capture mode, not a text buffer), so a button that created a binding on an unspecified or - /// already-taken key would produce a row that is dead and unfixable from here. When every numpad - /// digit is spoken for there is no free key to claim, so the button isn't drawn at all — the same - /// rule that keeps [[- del]] off a pane with nothing selected. + /// ([[+ binding]] Num3), so a new binding always lands on a key the row can name. When every + /// numpad digit is spoken for there is no free key to claim, so the button isn't drawn at all — the + /// same rule that keeps [[- del]] off a pane with nothing selected. /// - /// For the same reason there is no duplicate: a copy of a binding would land on the key its - /// original already holds, and the second of two macros on one key never fires - /// ( is a dictionary). A button whose only possible result is a dead row - /// is worse than no button. + /// The numpad is a placeholder now, not a working key: no numpad chord reaches this host + /// (see ), so a fresh binding is drawn with the ▲ caveat every other + /// dead row gets, and the key capture on its own row () is how it is made live. + /// That is a step, and it is visible; it stays this way only because the claimed key is what + /// ScreenListButtonTests pins, and moving the claim to the first free deliverable chord is a + /// change to an asserted value rather than to a behaviour nobody wrote down. + /// + /// + /// There is still no duplicate: a copy would land on the key its original already holds, and + /// two macros on one key means the second never runs — the capture refuses to create that state + /// (see ), so a button whose only possible result is that state would be + /// contradicting the field beside it. /// /// private static List Buttons(IReadOnlyList? sets, int selected) @@ -151,7 +198,7 @@ private static List Buttons(IReadOnlyList? sets, int sele var bound = sets.SelectMany(s => s.Macros).Select(m => m.Key).ToList(); if (ScreenLists.Target(sets, s => s.Macros, selected) is { } target - && FreeNumpadKey(bound) is { } key) + && FreeBindableKey(bound) is { } key) { rows.Add(ScreenRow.Of(ScreenButton.Add( AddBindingLabel, @@ -172,14 +219,17 @@ private static List Buttons(IReadOnlyList? sets, int sele } /// - /// The lowest Num0..Num9 nothing is bound to, or null when they are all taken. + /// The first chord a new binding can be born on: unbound, and one this client can actually be + /// reached by. It deliberately does not hand out a numpad key — no numpad key ever + /// arrives (see ), so a binding created on one is dead from birth, and a + /// button whose whole job is to name the key it claims must not name a key that cannot fire. + /// Null when every candidate is taken, which is what stops the button being drawn at all. /// Comparison is case-insensitive because 's lookup is. /// - private static string? FreeNumpadKey(IReadOnlyList bound) + private static string? FreeBindableKey(IReadOnlyList bound) { - for (var digit = 0; digit <= 9; digit++) + foreach (var key in MacroKeys.Bindable) { - var key = "Num" + digit.ToString(CultureInfo.InvariantCulture); if (!bound.Contains(key, StringComparer.OrdinalIgnoreCase)) { return key; @@ -227,20 +277,35 @@ internal static string FooterLine( { var at = selected >= 0 ? selected : focus?.Pane == 0 ? focus.Value.Index : 0; at = Math.Clamp(at, 0, macros.Count - 1); + + // The row can only spare a handful of cells for a reason; the footer has the width to give + // the whole one, for the binding the cursor is actually on. + var verdict = MacroKeys.Verdict(macros[at].Key); context = ScreenChrome.Context( - ScreenChrome.Position("binding", at, macros.Count), Escape(Identify(macros[at]))); + ScreenChrome.Position("binding", at, macros.Count), + Escape(Identify(macros[at])), + verdict.Fires ? null : "▲ " + Escape(verdict.Reason)); } var actions = ScreenChrome.Actions(focus: focus); return SpreadLR(" " + context, actions, width); } - /// The 3×3 numpad grid, in numpad order (7-8-9 on top), one row per line. + /// + /// The 3×3 numpad grid, in numpad order (7-8-9 on top), one row per line. + /// + /// Its caption carries the whole grid's verdict, because on this host that verdict is the same for + /// every cell: nothing sends a numpad key here (see ). Nine diagrams of keys + /// that cannot fire, drawn without saying so, is the exact shape of the lie this screen was audited + /// for — and the caption is derived from the verdict rather than written, so a host that + /// could one day deliver the numpad would drop the disclaimer without anyone remembering to. + /// + /// internal static List NumpadColumn(IReadOnlyList macros) { ArgumentNullException.ThrowIfNull(macros); - var lines = new List { "[dim]NUMPAD[/]" }; + var lines = new List { $"[dim]NUMPAD[/]{Caveat(MacroKeys.Verdict("Num5"))}" }; foreach (var row in NumpadRows) { lines.Add(NumpadRow(row, macros)); @@ -259,7 +324,7 @@ internal static List HotkeysColumn( ArgumentNullException.ThrowIfNull(macros); var cursor = focus ?? ScreenFocus.None; - var lines = new List { "[dim]HOTKEYS[/]" }; + var lines = new List { $"[dim]HOTKEYS[/]{DeadCount(macros)}" }; if (macros.Count == 0) { lines.Add(" [dim]no hotkeys[/]"); @@ -268,7 +333,11 @@ internal static List HotkeysColumn( for (var i = 0; i < macros.Count; i++) { lines.Add(ScreenChrome.Cursor( - Hotkey(macros[i], cursor.EditOn(0, i, NameField), cursor.EditOn(0, i, CommandField)), + Hotkey( + macros[i], + cursor.EditOn(0, i, NameField), + cursor.EditOn(0, i, CommandField), + cursor.EditOn(0, i, KeyField)), cursor.IsOn(0, i), ColumnWidth)); } @@ -309,22 +378,58 @@ private static string NumpadCell(int digit, IReadOnlyList macros) } /// - /// One row of the binding list: tick key name → command. The name and the command are both - /// welled, because both are edited here — this screen has no editor pane to draw them in, and the - /// well is the affordance that says which values the keyboard can change (see - /// , and the numpad grid, which has none). The key sits between - /// them unwelled, which is exactly what it is: the one part of a binding this screen cannot change. + /// One row of the binding list: tick key name → command. All three values are welled, because + /// all three are edited here — this screen has no editor pane to draw them in, and the well is the + /// affordance that says which values the keyboard can change (see , + /// and the numpad grid, which has none). The key was the one unwelled value on the screen until it + /// grew a capture mode; it is welled now because the claim the well makes has become true. + /// + /// A binding whose chord can never reach the app is drawn in the muted ink behind a ▲, with + /// the reason after the command — the read-only treatment, used for what it means: this row is not + /// what it looks like. The well stays, because the key genuinely is editable here; the two + /// marks answer different questions, and the answer to "can I change this" is yes even when the + /// answer to "does this do anything" is no. + /// /// - private static string Hotkey(Macro macro, ScreenFieldEdit? name, ScreenFieldEdit? command) + private static string Hotkey(Macro macro, ScreenFieldEdit? name, ScreenFieldEdit? command, ScreenFieldEdit? key) { + var verdict = MacroKeys.Verdict(macro.Key); var tick = macro.Enabled ? $"[{Accent}]✓[/]" : "[dim]·[/]"; - var key = $"[bold]{Escape(macro.Key).PadRight(KeyColumnWidth)}[/]"; + var chord = verdict.Fires + ? $"[bold]{Escape(macro.Key)}[/]" + : $"[{Muted}]▲ {Escape(macro.Key)}[/]"; + var bound = ScreenChrome.Field(PadVisible(chord, KeyColumnWidth), key); + // A binding that has never been named still gets its well — the name is editable whether or not // one is set — but with the same em-dash placeholder an unbound numpad cell uses, so the column // reads as an empty field rather than as a slab of background. var label = string.IsNullOrWhiteSpace(macro.Name) ? "[dim]—[/]" : $"[{Value}]{Escape(macro.Name)}[/]"; var named = ScreenChrome.Field(PadVisible(label, NameColumnWidth), name); - return $"{tick} {key} {named} → {ScreenChrome.Field(Escape(macro.Command), command)}"; + return $"{tick} {bound} {named} → {ScreenChrome.Field(Escape(macro.Command), command)}"; + } + + /// + /// What a verdict adds to a caption: nothing when it fires, and otherwise the muted + /// ▲ reason in full. One helper, so a caption and the footer cannot phrase the same fact two + /// ways. + /// + private static string Caveat(MacroKeyVerdict verdict) => + verdict.Fires ? string.Empty : $" [{Muted}]▲ {Escape(verdict.Reason)}[/]"; + + /// + /// How many of the drawn bindings can never fire, on the list's own caption. The rows carry the + /// ▲ and the footer carries the reason for the one the cursor is on; the reason is + /// deliberately not repeated per row, because the reasons differ, they are longer than the + /// column has cells, and eight copies of the same sentence is how a warning stops being read. A + /// count, though, is the one thing neither the rows nor the footer can say: how much of this list is + /// scenery. + /// + private static string DeadCount(IReadOnlyList macros) + { + var dead = macros.Count(m => !MacroKeys.Verdict(m.Key).Fires); + return dead == 0 + ? string.Empty + : $" [{Muted}]▲ {dead} of {macros.Count} cannot fire[/]"; } private static Macro? FindByKey(IReadOnlyList macros, string key) diff --git a/src/SharpMUTerm.Tui/MacroKeys.cs b/src/SharpMUTerm.Tui/MacroKeys.cs new file mode 100644 index 00000000..7f61da82 --- /dev/null +++ b/src/SharpMUTerm.Tui/MacroKeys.cs @@ -0,0 +1,294 @@ +using SharpMUTerm.Core.Automation; + +namespace SharpMUTerm.Tui; + +/// What will happen to a keystroke bound to a given descriptor. +internal enum MacroKeyDelivery +{ + /// The chord reaches the app's key handler and its macro runs. + Fires, + + /// The terminal or the framework's input parser never produces this chord at all. + NeverArrives, + + /// It arrives, but something else has already claimed it — the app, or the prompt. + Taken, +} + +/// +/// What a key descriptor is worth: whether a macro on it can ever run, and — when it cannot — the +/// reason, in the words the F4 screen prints beside the binding. +/// +/// Which of the three answers this is. +/// Why it will not fire, or empty when it will. +internal readonly record struct MacroKeyVerdict(MacroKeyDelivery Delivery, string Reason = "") +{ + /// Whether pressing this chord actually runs the macro bound to it. + internal bool Fires => Delivery == MacroKeyDelivery.Fires; +} + +/// +/// One chord the application claims globally, and what it does with it — the two things F4 needs in +/// order to say Ctrl+Q quits beside a binding that will never run. +/// +/// The modifiers the shortcut is registered with (matched exactly). +/// The key it is registered on. +/// What it does, as a sentence fragment following the chord's own name. +internal readonly record struct AppShortcut(ConsoleModifiers Modifiers, ConsoleKey Key, string Does); + +/// +/// The bridge between a 's descriptor and the keyboard this host actually has. +/// +/// It exists because the two are not the same set, and pretending otherwise is how F4 came to list +/// nine bindings of which none could ever run. Three things narrow what a binding can be. SharpConsoleUI's +/// input parser only decodes some sequences: it produces F1–F12 with modifiers (from +/// ESC [ 1;5 P and ESC [ 15;5 ~), Ctrl+letter from the raw control byte, Alt+anything from +/// the ESC prefix, and modified navigation keys — and it produces +/// never, because it sends no DECKPAM and decodes no application-keypad SS3, so a numpad digit +/// arrives as a plain digit or is dropped. Then the app itself takes chords globally +/// (), and a global shortcut runs before any window sees the key. Then the +/// prompt has the rest: an unmodified letter is typing, and a macro that swallowed it would be worse +/// than one that never ran. +/// +/// +/// — what the dispatcher binds a keystroke to — is defined as +/// filtered by , deliberately, so the screen's claim and the +/// dispatcher's behaviour cannot drift: F4 marks exactly the rows the app would refuse to act on. +/// +/// +internal static class MacroKeys +{ + /// + /// Every chord registers as a global shortcut. It registers from + /// this list rather than alongside it, so a key the app takes is a key the keypad screen knows is + /// taken — there is one list, not two that agree until someone edits one. + /// + internal static IReadOnlyList AppShortcuts { get; } = new AppShortcut[] + { + new(ConsoleModifiers.Control, ConsoleKey.Q, "quits"), + new(ConsoleModifiers.Control, ConsoleKey.N, "picks the next window"), + new(ConsoleModifiers.Control, ConsoleKey.Tab, "picks the next window"), + new(ConsoleModifiers.Control, ConsoleKey.W, "closes the window"), + new(ConsoleModifiers.Control, ConsoleKey.O, "cycles the panes"), + new(ConsoleModifiers.Control, ConsoleKey.P, "opens the command surface"), + new(ConsoleModifiers.Control, ConsoleKey.B, "arms the pane prefix"), + new(ConsoleModifiers.Control, ConsoleKey.F, "freezes the pane"), + new((ConsoleModifiers)0, ConsoleKey.F2, "opens Triggers"), + new((ConsoleModifiers)0, ConsoleKey.F3, "opens Aliases"), + new((ConsoleModifiers)0, ConsoleKey.F4, "opens this screen"), + new((ConsoleModifiers)0, ConsoleKey.F5, "opens Worlds"), + new((ConsoleModifiers)0, ConsoleKey.F6, "opens Timers"), + new((ConsoleModifiers)0, ConsoleKey.F7, "opens Text & ANSI"), + new((ConsoleModifiers)0, ConsoleKey.F8, "opens Input"), + new((ConsoleModifiers)0, ConsoleKey.F9, "opens the character's log"), + }; + + /// The claimed chords by canonical descriptor, built once from . + private static readonly Dictionary Claimed = BuildClaims(); + + /// + /// The canonical descriptor for a keystroke, whatever it is worth — what the capture mode writes + /// into a binding, before the field's validator has a word to say about it. Null when the key has no + /// name this client can store (a lone modifier, an undecoded sequence arriving as + /// ). + /// + internal static string? Capture(ConsoleKeyInfo key) => + Name(key.Key) is { } name + ? MacroKey.Describe( + name, + key.Modifiers.HasFlag(ConsoleModifiers.Control), + key.Modifiers.HasFlag(ConsoleModifiers.Alt), + key.Modifiers.HasFlag(ConsoleModifiers.Shift)) + : null; + + /// + /// The chords a new binding may be created on, in the order they are handed out: the function keys + /// first, then their Ctrl variants. Every entry is one says fires, checked by + /// test rather than trusted — a list of candidates that drifted from the verdicts would hand out + /// keys that cannot be reached, which is the exact defect it exists to prevent. + /// + internal static IReadOnlyList Bindable { get; } = BuildBindable(); + + private static List BuildBindable() + { + var candidates = new List(); + for (var f = 1; f <= 12; f++) + { + candidates.Add(MacroKey.Describe($"F{f}")); + } + + for (var f = 1; f <= 12; f++) + { + candidates.Add(MacroKey.Describe($"F{f}", ctrl: true)); + } + + return candidates.FindAll(c => Verdict(c).Fires); + } + + /// + /// The descriptor a keystroke should run a macro on, or null when this keystroke is not the app's to + /// act on — because nothing could ever be bound to it, or because something else owns it. It is + /// filtered by so that the rows F4 draws as live are + /// precisely the ones this returns for. + /// + internal static string? Descriptor(ConsoleKeyInfo key) => + Capture(key) is { } descriptor && Verdict(descriptor).Fires ? descriptor : null; + + /// + /// What a stored descriptor is worth on this host. Every answer is a fact about the parser, the app's + /// own shortcuts, or the prompt — never a guess — and the reason is short enough to print on the + /// binding's own row. + /// + internal static MacroKeyVerdict Verdict(string? descriptor) + { + if (!MacroKey.TryParse(descriptor, out var parts)) + { + return Never("not a key this client knows"); + } + + var canonical = MacroKey.Describe(parts.Key, parts.Ctrl, parts.Alt, parts.Shift); + if (Claimed.TryGetValue(canonical, out var does)) + { + return new MacroKeyVerdict(MacroKeyDelivery.Taken, $"{canonical} {does}"); + } + + if (parts.Key.Length == 4 && parts.Key.StartsWith("Num", StringComparison.Ordinal) + && char.IsAsciiDigit(parts.Key[3])) + { + // No DECKPAM is ever sent and no application-keypad SS3 is decoded, so the numpad either + // reports as the main row's digits or is dropped. Either way this descriptor never arrives. + return Never("no numpad key ever arrives"); + } + + if (parts.Ctrl && parts.Alt) + { + return Never("Ctrl+Alt arrives as two keys"); + } + + if (IsFunction(parts.Key)) + { + return new MacroKeyVerdict(MacroKeyDelivery.Fires); + } + + if (IsLetter(parts.Key) || IsDigit(parts.Key)) + { + return Chord(parts); + } + + if (Navigation.Contains(parts.Key)) + { + return parts.Ctrl || parts.Alt || parts.Shift + ? new MacroKeyVerdict(MacroKeyDelivery.Fires) + : new MacroKeyVerdict(MacroKeyDelivery.Taken, "unmodified, this belongs to the prompt"); + } + + return Never("only F-keys and Ctrl/Alt chords arrive"); + } + + /// + /// What a letter or a digit is worth. Unmodified it is typing; with Ctrl it is a control byte, which + /// carries no Shift or Alt of its own and which four letters cannot produce at all because the + /// terminal spells those bytes Tab, Enter and Backspace; with Alt it is an ESC prefix, except for the + /// one letter the parser has already spent on its own SS3 introducer. + /// + private static MacroKeyVerdict Chord(MacroKeyParts parts) + { + if (!parts.Ctrl && !parts.Alt) + { + return new MacroKeyVerdict(MacroKeyDelivery.Taken, "plain keys type into the prompt"); + } + + if (parts.Ctrl) + { + if (parts.Shift) + { + return Never("a Ctrl chord loses Shift"); + } + + if (IsDigit(parts.Key)) + { + return Never("Ctrl+digit is dropped"); + } + + return ControlBytes.TryGetValue(parts.Key, out var spelt) + ? Never($"the terminal sends {spelt} instead") + : new MacroKeyVerdict(MacroKeyDelivery.Fires); + } + + return parts.Key == "O" + ? Never("Alt+O is the terminal's own prefix") + : new MacroKeyVerdict(MacroKeyDelivery.Fires); + } + + /// The letters whose control byte the terminal has already spent on another key. + private static readonly Dictionary ControlBytes = new(StringComparer.Ordinal) + { + ["I"] = "Tab", + ["M"] = "Enter", + ["J"] = "Enter", + ["H"] = "Backspace", + }; + + /// The keys that are navigation rather than text — bindable, but only as part of a chord. + private static readonly HashSet Navigation = new(StringComparer.Ordinal) + { + "Up", "Down", "Left", "Right", "Home", "End", "PageUp", "PageDown", "Insert", "Delete", + }; + + private static MacroKeyVerdict Never(string reason) => new(MacroKeyDelivery.NeverArrives, reason); + + private static bool IsFunction(string key) => + key.Length is 2 or 3 && key[0] == 'F' && key[1..].All(char.IsAsciiDigit); + + private static bool IsLetter(string key) => key.Length == 1 && char.IsAsciiLetterUpper(key[0]); + + private static bool IsDigit(string key) => key.Length == 1 && char.IsAsciiDigit(key[0]); + + private static Dictionary BuildClaims() + { + var claims = new Dictionary(StringComparer.OrdinalIgnoreCase); + foreach (var shortcut in AppShortcuts) + { + if (Name(shortcut.Key) is { } name) + { + claims[MacroKey.Describe( + name, + shortcut.Modifiers.HasFlag(ConsoleModifiers.Control), + shortcut.Modifiers.HasFlag(ConsoleModifiers.Alt), + shortcut.Modifiers.HasFlag(ConsoleModifiers.Shift))] = shortcut.Does; + } + } + + return claims; + } + + /// + /// The descriptor name of a , or null for one a binding cannot be written + /// for. It is deliberately wider than what will accept — the numpad keys have + /// names here even though none of them can arrive, because a configuration already holds those + /// descriptors and a screen that could not spell them could not tell you they are dead either. + /// + private static string? Name(ConsoleKey key) => key switch + { + >= ConsoleKey.F1 and <= ConsoleKey.F24 => "F" + (key - ConsoleKey.F1 + 1), + >= ConsoleKey.A and <= ConsoleKey.Z => key.ToString(), + >= ConsoleKey.D0 and <= ConsoleKey.D9 => (key - ConsoleKey.D0).ToString(), + >= ConsoleKey.NumPad0 and <= ConsoleKey.NumPad9 => "Num" + (key - ConsoleKey.NumPad0), + ConsoleKey.UpArrow => "Up", + ConsoleKey.DownArrow => "Down", + ConsoleKey.LeftArrow => "Left", + ConsoleKey.RightArrow => "Right", + ConsoleKey.Home => "Home", + ConsoleKey.End => "End", + ConsoleKey.PageUp => "PageUp", + ConsoleKey.PageDown => "PageDown", + ConsoleKey.Insert => "Insert", + ConsoleKey.Delete => "Delete", + ConsoleKey.Enter => "Enter", + ConsoleKey.Escape => "Escape", + ConsoleKey.Tab => "Tab", + ConsoleKey.Backspace => "Backspace", + ConsoleKey.Spacebar => "Space", + _ => null, + }; +} diff --git a/src/SharpMUTerm.Tui/ScreenChrome.cs b/src/SharpMUTerm.Tui/ScreenChrome.cs index 6bd40bc3..cbe2dda9 100644 --- a/src/SharpMUTerm.Tui/ScreenChrome.cs +++ b/src/SharpMUTerm.Tui/ScreenChrome.cs @@ -29,6 +29,15 @@ internal static string Hints( { if (focus?.Edit is { } edit) { + // A capture answers to nothing else: every key but Esc is a candidate binding, so ⏎ does not + // commit, ⇥ does not step, and the screen's own F-key does not close it — it is offered as a + // binding and refused like any other claimed chord. Advertising any of the three would name + // a key that means something different for as long as the prompt is up. + if (edit.Capture) + { + return $"[{ScreenPalette.Label}]{CaptureHints}[/]"; + } + var editing = EditingHints + (edit.VisibleChoices.Count > 0 ? ChoiceHint : string.Empty) + (edit.RowFields > 1 ? NextFieldHint : string.Empty); @@ -66,6 +75,12 @@ internal static string Hints( /// The hints that replace a screen's own while a field edit is open. internal const string EditingHints = "⏎ commit · Esc revert"; + /// + /// The hints that replace even those while a key capture is armed. They are the whole keyboard + /// contract at that moment: one key gets you out, everything else is the value. + /// + internal const string CaptureHints = "press any key to bind it · Esc cancels"; + /// Added to only when the row has another field to step to. internal const string NextFieldHint = " · ⇥ next field"; @@ -95,6 +110,13 @@ internal static string Hints( /// What the footer's ⏎ chip does while a field edit is open. internal const string CommitAction = "[[⏎]] Commit"; + /// + /// What the ⏎ chip becomes while a key capture is armed. ⏎ is not the key that commits there — it is + /// merely one of the keys that could be bound — so the chip names what actually finishes the capture, + /// which is any key at all. + /// + internal const string BindAction = "[[any key]] Bind"; + /// /// The right-hand actions of a footer bar. lets a screen with a /// context colour (F5's per-world accent) tint the ⏎ chip; it defaults to the app accent. @@ -109,8 +131,9 @@ internal static string Hints( internal static string Actions(string? accent = null, ScreenFocus? focus = null) { var editing = focus?.Edit is not null; + var capturing = focus?.Edit is { Capture: true }; var escape = editing ? RevertAction : CancelAction; - var enter = editing ? CommitAction : SaveAction; + var enter = capturing ? BindAction : editing ? CommitAction : SaveAction; return $"[{ScreenPalette.Label}] {escape} [/] " + $"[{ScreenPalette.Ink} on {accent ?? ScreenPalette.Accent}] {enter} [/] "; @@ -150,6 +173,11 @@ internal static string Field(string display, ScreenFieldEdit? edit) return Well(display); } + if (open.Capture) + { + return Capture(open); + } + var caret = Math.Clamp(open.Caret, 0, open.Text.Length); var before = MarkupText.Escape(open.Text[..caret]); var under = caret < open.Text.Length ? MarkupText.Escape(open.Text[caret].ToString()) : " "; @@ -171,6 +199,23 @@ internal static string Field(string display, ScreenFieldEdit? edit) /// private static string Well(string display) => $"[on {ScreenPalette.FieldBg}]{display} [/]"; + /// What an armed key capture puts where the value was — and the only way out of it. + internal const string CapturePrompt = "press a key · Esc cancels"; + + /// + /// An armed key capture: the value is replaced outright by the prompt, in the accent block the caret + /// is drawn in, because there is no buffer to show a caret inside — the next keystroke is + /// the value. A refused key keeps the capture armed and says why beside it, exactly as a refused + /// buffer does, so "that key cannot be bound" and "press another" are one state and not two. + /// + private static string Capture(ScreenFieldEdit open) + { + var prompt = $"[{ScreenPalette.Ink} on {ScreenPalette.Accent}] {CapturePrompt} [/]"; + return open.Error is { } error + ? $"{prompt} [{ScreenPalette.Warn}]▲ {MarkupText.Escape(error)}[/]" + : prompt; + } + /// /// The block caret paints, which is what hangs the /// dropdown off. Exactly one field of one row can be open at a time, and only the column that draws diff --git a/src/SharpMUTerm.Tui/ScreenField.cs b/src/SharpMUTerm.Tui/ScreenField.cs index a092c5bb..a9f751c6 100644 --- a/src/SharpMUTerm.Tui/ScreenField.cs +++ b/src/SharpMUTerm.Tui/ScreenField.cs @@ -1,5 +1,6 @@ using System.Globalization; using System.Text.RegularExpressions; +using SharpMUTerm.Core.Automation; using SharpMUTerm.Core.Text; namespace SharpMUTerm.Tui; @@ -30,6 +31,12 @@ namespace SharpMUTerm.Tui; /// the windows in use; typing a fifth is how the fifth comes into being). The chrome says which, /// because a list drawn the same way for both would imply a closed set where anything is legal. /// +/// +/// Whether the open field takes its value from the next keystroke rather than from a typed +/// buffer — F4's key binding is the only one. It changes what the chrome draws (a prompt, not a caret) +/// and what the hints promise (no ⏎, no ⇥: every key but Esc is a candidate), so it is carried on the +/// edit rather than re-derived, the way is. +/// internal readonly record struct ScreenFieldEdit( int Field, string Text, @@ -37,7 +44,8 @@ internal readonly record struct ScreenFieldEdit( string? Error, int RowFields = 1, IReadOnlyList? Choices = null, - bool ClosedChoices = false) + bool ClosedChoices = false, + bool Capture = false) { /// Whether the open field knows any values at all, whatever the buffer currently is. internal bool HasChoices => Choices is { Count: > 0 }; @@ -77,6 +85,11 @@ internal readonly record struct ScreenFieldEdit( /// independently. It is carried here rather than inferred, because the chrome draws the two lists /// differently and a renderer guessing from the field's shape would eventually guess wrong. /// +/// +/// Whether the value is taken from the next keystroke instead of typed. See : it is the +/// one field on these screens whose vocabulary is the keyboard itself, so a text buffer could only ever +/// be a place to mis-spell a key name. +/// internal readonly record struct ScreenField( string Label, Func Get, @@ -84,7 +97,8 @@ internal readonly record struct ScreenField( Action Set, Func Snapshot, IReadOnlyList? Choices = null, - bool ClosedChoices = false) + bool ClosedChoices = false, + bool Capture = false) { /// Longest rejection message kept; regex parser errors run to several lines otherwise. private const int MaxErrorLength = 44; @@ -556,6 +570,41 @@ internal static ScreenField Enumeration(string label, Func get, Ac ClosedChoices: true); } + /// + /// A key binding, taken from the keyboard rather than typed. Opening it arms a capture: the next + /// keystroke is the value, and Esc — the only key that is never a candidate — abandons it. + /// + /// It is not a over key names and not a field, because both + /// would ask the user to spell a chord they can simply press, and to know this client's spelling of + /// it. What comes back is always canonical (), so + /// Ctrl+Shift+F1 is stored one way however the terminal reports it. + /// + /// + /// Two things are refused, and both are refused here rather than left to be discovered by + /// pressing the key and watching nothing happen. A chord this host cannot deliver — the whole numpad, + /// Ctrl+Alt, the app's own shortcuts — is refused with 's reason. And + /// a chord another binding already holds is refused by , because the engine + /// resolves one macro per key and the second of two would silently never run, which is exactly the + /// dead row this field exists to make impossible. + /// + /// + /// Names the binding already holding a descriptor, or null when it is free. + internal static ScreenField Key( + string label, Func get, Action set, Func taken) + { + ArgumentNullException.ThrowIfNull(get); + ArgumentNullException.ThrowIfNull(set); + ArgumentNullException.ThrowIfNull(taken); + + return new ScreenField( + label, + get, + value => MacroKeys.Verdict(value) is { Fires: false } verdict ? verdict.Reason : taken(value), + value => set(MacroKey.Canonicalise(value) ?? value.Trim()), + Restore(get, set), + Capture: true); + } + /// Captures a value of any type and returns the action that writes it back. private static Func Restore(Func get, Action set) => () => diff --git a/src/SharpMUTerm.Tui/SettingsSession.cs b/src/SharpMUTerm.Tui/SettingsSession.cs index 02b8f28a..c3f74c2c 100644 --- a/src/SharpMUTerm.Tui/SettingsSession.cs +++ b/src/SharpMUTerm.Tui/SettingsSession.cs @@ -43,6 +43,10 @@ internal enum ScreenAction /// candidate list (narrowing it is what typing does), ⇥ commits and steps to the row's next field, ⏎ /// commits, and Esc reverts. /// +/// +/// One field kind takes the keyboard whole: a capture (F4's binding), where +/// the next keystroke is the value and only Esc means anything else. See . +/// /// internal sealed class SettingsSession { @@ -96,7 +100,8 @@ internal ScreenFocus Focus() open.Error, model.RowAt(open.Pane, open.Index).FieldCount, field?.Choices, - field?.ClosedChoices ?? false) + field?.ClosedChoices ?? false, + field?.Capture ?? false) : (ScreenFieldEdit?)null; return new ScreenFocus(Selection.Pane, Selection.Index, edit); @@ -262,6 +267,11 @@ private ScreenAction HandleEdit(ConsoleKeyInfo key, ScreenModel model) return ScreenAction.Redraw; } + if (field.Capture) + { + return HandleCapture(key, field); + } + switch (key.Key) { case ConsoleKey.Escape: @@ -316,6 +326,37 @@ private ScreenAction HandleEdit(ConsoleKeyInfo key, ScreenModel model) } } + /// + /// A keystroke while a key capture is armed. There is no buffer to type into here: the keystroke + /// is the value, so it is written into the edit and committed at once, and the field's own + /// validator does the refusing — a chord this host cannot deliver, or one another binding already + /// holds, leaves the capture armed carrying the reason instead of writing a row that would never fire. + /// + /// Esc is never a candidate. It is the way out of every modal state these screens have, and a + /// capture that swallowed it would be the one trap this whole mode could set: nothing else on screen + /// ends the prompt, because ⏎ and ⇥ are themselves keys someone might reasonably want to bind. A key + /// with no descriptor at all (a lone modifier, an undecoded sequence) is swallowed and the capture + /// stays armed — it is a keystroke that never happened as far as any binding is concerned. + /// + /// + private ScreenAction HandleCapture(ConsoleKeyInfo key, ScreenField field) + { + if (key.Key == ConsoleKey.Escape) + { + _edit = null; + return ScreenAction.Redraw; + } + + if (MacroKeys.Capture(key) is not { } descriptor) + { + return ScreenAction.Consumed; + } + + _edit!.Replace(descriptor); + Commit(field); + return ScreenAction.Redraw; + } + /// /// Validates the buffer and, if it holds, writes it through the undo log and closes the edit. A /// rejected buffer stays open and carries the reason, so the field is marked rather than the diff --git a/src/SharpMUTerm.Tui/SharpMUTermApp.cs b/src/SharpMUTerm.Tui/SharpMUTermApp.cs index d7dda189..7b068cd4 100644 --- a/src/SharpMUTerm.Tui/SharpMUTermApp.cs +++ b/src/SharpMUTerm.Tui/SharpMUTermApp.cs @@ -215,22 +215,13 @@ public SharpMUTermApp(AppConfiguration config, TerminalCapabilities capabilities // The PromptControl otherwise measures to its content width, leaving the band short of the right // edge; pinning Width to the window makes the field fill (and its background paint) run edge-to-edge. SyncInputWidth(); - _system.RegisterGlobalShortcut(ConsoleModifiers.Control, ConsoleKey.Q, () => _system.RequestExit(0)); - // Next window (Ctrl+N, plus Ctrl+Tab where the terminal reports it) and close window (Ctrl+W). - _system.RegisterGlobalShortcut(ConsoleModifiers.Control, ConsoleKey.N, NextWindow); - _system.RegisterGlobalShortcut(ConsoleModifiers.Control, ConsoleKey.Tab, NextWindow); - _system.RegisterGlobalShortcut(ConsoleModifiers.Control, ConsoleKey.W, CloseActiveWindow); - _system.RegisterGlobalShortcut(ConsoleModifiers.Control, ConsoleKey.O, CyclePane); - _system.RegisterGlobalShortcut(ConsoleModifiers.Control, ConsoleKey.P, ToggleMenu); - _system.RegisterGlobalShortcut(ConsoleModifiers.Control, ConsoleKey.B, ArmPrefix); - _system.RegisterGlobalShortcut(ConsoleModifiers.Control, ConsoleKey.F, ToggleFreeze); _window.PreviewKeyPressed += OnWindowKey; // Pane drag-and-drop listens at the driver, not at a control: SharpConsoleUI delivers mouse // frames to the control that was pressed (it captures on Button1Pressed), so a control-level // handler would only ever see the *source* pane. The driver stream carries every frame in // desktop cells, which is exactly what a drag between panes needs. _system.ConsoleDriver.MouseEvent += OnDriverMouseEvent; - RegisterSettingsShortcuts(); + RegisterGlobalShortcuts(); _system.AddWindow(_window); } @@ -944,17 +935,75 @@ private void RefreshStatusBar() }; /// - /// Binds each screen's F-key to the full-screen settings overlay. Esc / the same F-key closes. + /// Binds every chord the app claims globally: the window/pane commands, and each settings screen's + /// F-key to the full-screen overlay (Esc / the same F-key closes it). + /// + /// The chords come from rather than being written out here, + /// because F4 has to tell a user that a macro on Ctrl+Q will never fire, and it can only say + /// so honestly if the list it reads is the list that was registered. Registering from that + /// table makes the two the same list. Both directions are checked as it goes: a claim with no action + /// and a screen with no claim are both startup failures rather than a key that silently does nothing. + /// /// - private void RegisterSettingsShortcuts() + private void RegisterGlobalShortcuts() { - foreach (var screen in SettingsScreens()) + var screens = SettingsScreens().ToDictionary(s => s.Key, s => s.Open); + foreach (var claim in MacroKeys.AppShortcuts) + { + var action = ShortcutAction(claim, screens) + ?? throw new InvalidOperationException( + $"MacroKeys.AppShortcuts claims {claim.Modifiers}+{claim.Key} but nothing runs on it"); + _system.RegisterGlobalShortcut(claim.Modifiers, claim.Key, action); + } + + foreach (var key in screens.Keys) { - var (key, open) = (screen.Key, screen.Open); - _system.RegisterGlobalShortcut((ConsoleModifiers)0, key, () => _settings.Toggle(key, open)); + if (!MacroKeys.AppShortcuts.Any(c => c.Modifiers == (ConsoleModifiers)0 && c.Key == key)) + { + throw new InvalidOperationException( + $"the {key} settings screen is not claimed in MacroKeys.AppShortcuts"); + } } } + /// + /// What a claimed chord runs, or null when nothing does. Every one returns true: these are the keys + /// the app takes outright, and a global shortcut that returned false would hand the key back to the + /// window underneath — which is exactly what the keypad screen has just told the user does not happen. + /// + private Func? ShortcutAction( + AppShortcut claim, IReadOnlyDictionary> screens) + { + if (claim.Modifiers == (ConsoleModifiers)0) + { + if (!screens.TryGetValue(claim.Key, out var open)) + { + return null; + } + + var key = claim.Key; + return () => { _settings.Toggle(key, open); return true; }; + } + + if (claim.Modifiers != ConsoleModifiers.Control) + { + return null; + } + + return claim.Key switch + { + ConsoleKey.Q => () => { _system.RequestExit(0); return true; }, + // Next window (Ctrl+N, plus Ctrl+Tab where the terminal reports it) and close window (Ctrl+W). + ConsoleKey.N or ConsoleKey.Tab => () => { NextWindow(); return true; }, + ConsoleKey.W => () => { CloseActiveWindow(); return true; }, + ConsoleKey.O => () => { CyclePane(); return true; }, + ConsoleKey.P => () => { ToggleMenu(); return true; }, + ConsoleKey.B => () => { ArmPrefix(); return true; }, + ConsoleKey.F => () => { ToggleFreeze(); return true; }, + _ => null, + }; + } + /// /// Persists the configuration the settings screens edit — the ⏎ Save action. The workspace layout /// is captured alongside it so a save never rolls back the resumed session; a failed write is @@ -1175,7 +1224,9 @@ private ScreenBinding OptionsScreen(Func sc /// a report. The logging view opens F5 on the character pane, so it steps twice more to /// reach the log format — past the name and the on-connect line — because the character's log is /// the whole reason that view exists, and it is also this app's one closed list, so it is - /// what the closed presentation is checked against. + /// what the closed presentation is checked against. keypad steps twice in the other + /// direction, onto the binding's key capture: that is the one state on these screens no + /// amount of typing can reach, so a still frame is the only way to look at it. /// /// route and highlight are F2 again, stopped at the two states a single frame of /// triggers-edit cannot also show: a buffer that has narrowed the list (pa → @@ -1202,6 +1253,15 @@ private static IEnumerable EditSnapshotKeys(string view) yield return Stroke('\r', ConsoleKey.Enter); + if (string.Equals(view, "keypad", StringComparison.OrdinalIgnoreCase)) + { + // name → command → key, which is where the keyboard stops being a text buffer: the frame + // shows an armed capture, the one screen state that cannot be reached by typing anything. + yield return Stroke('\t', ConsoleKey.Tab); + yield return Stroke('\t', ConsoleKey.Tab); + yield break; + } + if (string.Equals(view, "logging", StringComparison.OrdinalIgnoreCase)) { // name → on connect → log: the character row's fields, in order. @@ -2110,12 +2170,27 @@ private void ArmPrefix() } /// Consumes the key after ⌃B and runs the matching pane command (tmux-style). - private void OnWindowKey(object? sender, KeyPressedEventArgs e) + private void OnWindowKey(object? sender, KeyPressedEventArgs e) => HandleWindowKey(e); + + /// + /// Feeds one key to the very handler the main window's PreviewKeyPressed raises, and reports + /// the macro command it sent. It exists for the same reason + /// does — the framework only pumps keys inside + /// Run(), which a headless test never enters — and it goes through + /// rather than around it, so what it proves is what a keystroke does. + /// + internal string? SimulateKey(ConsoleKeyInfo key) => HandleWindowKey(new KeyPressedEventArgs(key, false)); + + /// + /// The main window's key handler: move mode, the drag escape, the ⌃B prefix, then a bound macro, + /// then draft-safe history recall. Returns the macro command it dispatched, or null. + /// + private string? HandleWindowKey(KeyPressedEventArgs e) { if (_moveMode) { HandleMoveKey(e); - return; + return null; } // Escape abandons a mouse drag. A terminal that loses the button-up (the pointer left the @@ -2125,18 +2200,29 @@ private void OnWindowKey(object? sender, KeyPressedEventArgs e) e.Handled = true; _paneDrag.Reset(); // no mouse frame ends this one, so the gesture has to be dropped here EndDrag(); - return; + return null; } if (!_prefixArmed) { - // Draft-safe history recall on ↑/↓ — our own, so a half-typed draft survives (see InputHistory). - if (!_palette.IsOpen && !_settings.IsOpen) + // A modal surface owns the keyboard while it is up. Both are separate windows, so the + // framework already routes keys to them and this handler is not raised at all — the guard is + // here because "a macro must not fire while a screen is open" is a rule of this app, not a + // consequence of how the framework happens to dispatch, and the next surface may not be modal. + if (_palette.IsOpen || _settings.IsOpen) { - TryRecallKey(e); + return null; } - return; + if (DispatchMacro(e.KeyInfo) is { } sent) + { + e.Handled = true; + return sent; + } + + // Draft-safe history recall on ↑/↓ — our own, so a half-typed draft survives (see InputHistory). + TryRecallKey(e); + return null; } _prefixArmed = false; @@ -2156,6 +2242,57 @@ private void OnWindowKey(object? sender, KeyPressedEventArgs e) } _header.SetContent(new List { HeaderMarkup() }); + return null; + } + + /// + /// Runs the macro bound to a keystroke and returns the command it sent, or null when this key is not + /// one the app acts on. This is the wire the F4 screen has always drawn and nothing ever connected: + /// and were written and tested, + /// and no key press had ever reached either of them. + /// + /// It sits on the main window's PreviewKeyPressed, which is the one place with all three + /// properties a macro needs: it runs before the focused control, so a binding beats the + /// prompt; it is not raised while a modal (a settings screen, the command surface) holds the + /// keyboard; and it runs after the global shortcuts, so the chords the app claims for + /// itself never arrive here — which is why reports those as taken + /// rather than the screen pretending a macro could outrank them. + /// + /// + /// The macro is resolved before it is sent because the answer decides whether the keystroke is + /// swallowed, and only reports that after it has already + /// sent. The send itself still goes through that method: it is the one path from a key to the wire, + /// and a second one here would be a second thing to keep in step. Nothing connected means nothing to + /// send to, so the key falls through to whatever would have had it. + /// + /// + private string? DispatchMacro(ConsoleKeyInfo key) + { + if (_active is not { } session || MacroKeys.Descriptor(key) is not { } descriptor) + { + return null; + } + + if (session.Macros.Resolve(descriptor) is not { Command.Length: > 0 } macro) + { + return null; + } + + _ = session.HandleKeyAsync(descriptor); + return macro.Command; + } + + /// + /// Opens the session for a world and binds it without connecting — the pair of calls + /// makes before it dials. It exists so the key → macro → command path can be + /// driven end to end without a socket: resolves and reports + /// a binding whether or not there is a transport under it to write to. + /// + internal WorldSession BindWorldWithoutConnecting(WorldDefinition world) + { + var session = OpenSession(world); + BindSession(session); + return session; } /// diff --git a/tests/SharpMUTerm.Core.Tests/Automation/AliasAndMacroTests.cs b/tests/SharpMUTerm.Core.Tests/Automation/AliasAndMacroTests.cs index e252d39e..707a9f45 100644 --- a/tests/SharpMUTerm.Core.Tests/Automation/AliasAndMacroTests.cs +++ b/tests/SharpMUTerm.Core.Tests/Automation/AliasAndMacroTests.cs @@ -113,4 +113,124 @@ public async Task Describe_ProducesCanonicalDescriptor(string key, bool ctrl, bo { await Assert.That(MacroKey.Describe(key, ctrl, alt, shift)).IsEqualTo(expected); } + + /// + /// Rebinding is live. The engine used to be a Dictionary keyed on the descriptor string it was + /// handed at construction — a cache of the one property the F4 screen's capture mode can now change, + /// so a rebound macro went on answering to the key it no longer carried until the next reconnect + /// rebuilt the engine. Exactly the staleness and + /// drop their compiled matcher to avoid. + /// + [Test] + public async Task RebindingTheKey_TakesEffectImmediately() + { + var macro = new Macro { Key = "Ctrl+F1", Command = "north" }; + var engine = new MacroEngine(new[] { macro }); + await Assert.That(engine.Resolve("Ctrl+F1")).IsNotNull(); + + macro.Key = "Ctrl+F10"; + + await Assert.That(engine.Resolve("Ctrl+F1")).IsNull(); + await Assert.That(engine.Resolve("Ctrl+F10")).IsNotNull(); + await Assert.That(engine.Macros).HasSingleItem(); + } + + /// + /// Two macros on one key is a state the F4 screen refuses to create, but a hand-edited file can still + /// hold one. The first wins, the way 's first matching pattern does, so the + /// answer is at least deterministic and the same one the screen names when it refuses the duplicate. + /// + [Test] + public async Task TwoMacrosOnOneKey_ResolveToTheFirst() + { + var engine = new MacroEngine(new[] + { + new Macro { Name = "first", Key = "Ctrl+F1", Command = "north" }, + new Macro { Name = "second", Key = "ctrl+f1", Command = "south" }, + }); + + await Assert.That(engine.Resolve("Ctrl+F1")!.Command).IsEqualTo("north"); + } + + /// Add replaces whatever holds the key, and Remove takes it out however it was spelt. + [Test] + public async Task AddReplacesTheBindingOnAKeyAndRemoveTakesItOut() + { + var engine = new MacroEngine(); + engine.Add(new Macro { Key = "Ctrl+F1", Command = "north" }); + engine.Add(new Macro { Key = "ctrl+f1", Command = "south" }); + + await Assert.That(engine.Macros).HasSingleItem(); + await Assert.That(engine.Resolve("Ctrl+F1")!.Command).IsEqualTo("south"); + + await Assert.That(engine.Remove("CTRL+F1")).IsTrue(); + await Assert.That(engine.Resolve("Ctrl+F1")).IsNull(); + await Assert.That(engine.Remove("Ctrl+F1")).IsFalse(); + } +} + +/// +/// The descriptor vocabulary. It is Core's because it is what compares and what +/// a configuration file stores; what any of it is worth on a given keyboard is the UI layer's +/// question (see MacroKeys in the TUI), because it is a property of the host, not of the binding. +/// +public class MacroKeyTests +{ + /// + /// A descriptor has one canonical spelling, so two ways of writing the same chord compare equal. The + /// two shapes already in configurations — Ctrl+F1 and Num5 — come back untouched, which + /// is the whole requirement: settling the spelling must not quietly rewrite anyone's bindings. + /// + [Test] + [Arguments("Ctrl+F1", "Ctrl+F1")] + [Arguments("Num5", "Num5")] + [Arguments("F1", "F1")] + [Arguments("shift+ctrl+f1", "Ctrl+Shift+F1")] + [Arguments("CONTROL+f10", "Ctrl+F10")] + [Arguments("NumPad0", "Num0")] + [Arguments("alt+k", "Alt+K")] + [Arguments(" Ctrl + F1 ", "Ctrl+F1")] + [Arguments("pgup", "PageUp")] + [Arguments("uparrow", "Up")] + [Arguments("esc", "Escape")] + public async Task Canonicalise_SettlesTheSpelling(string descriptor, string expected) + { + await Assert.That(MacroKey.Canonicalise(descriptor)).IsEqualTo(expected); + } + + /// + /// A descriptor whose modifiers name nothing, or which has no key at all, comes back null rather than + /// half-understood: a caller that cannot say what a descriptor is must not pretend, because the answer + /// decides whether a binding is drawn as one that fires. + /// + [Test] + [Arguments("")] + [Arguments(" ")] + [Arguments("Hyper+F1")] + [Arguments("Ctrl+")] + [Arguments("Ctrl++F1")] + public async Task Canonicalise_RefusesWhatItCannotRead(string descriptor) + { + await Assert.That(MacroKey.Canonicalise(descriptor)).IsNull(); + } + + /// + /// A key this client has never heard of is kept verbatim rather than rejected or renamed: a + /// configuration may name one, and silently rewriting it would be worse than leaving it alone. + /// + [Test] + public async Task Canonicalise_LeavesAnUnknownKeyNameAlone() + { + await Assert.That(MacroKey.Canonicalise("Ctrl+MediaPlay")).IsEqualTo("Ctrl+MediaPlay"); + } + + [Test] + public async Task TryParse_ReportsTheModifiersAndTheBaseKey() + { + await Assert.That(MacroKey.TryParse("ctrl+alt+shift+f5", out var parts)).IsTrue(); + await Assert.That(parts).IsEqualTo(new MacroKeyParts("F5", Ctrl: true, Alt: true, Shift: true)); + + await Assert.That(MacroKey.TryParse("Num5", out var bare)).IsTrue(); + await Assert.That(bare).IsEqualTo(new MacroKeyParts("Num5", false, false, false)); + } } diff --git a/tests/SharpMUTerm.Tui.Tests/MacroDispatchEndToEndTests.cs b/tests/SharpMUTerm.Tui.Tests/MacroDispatchEndToEndTests.cs new file mode 100644 index 00000000..3e21dfda --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/MacroDispatchEndToEndTests.cs @@ -0,0 +1,182 @@ +using SharpConsoleUI.Drivers; +using SharpMUTerm.Core.Automation; +using SharpMUTerm.Core.Configuration; +using SharpMUTerm.Graphics; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// The wire that was missing. and WorldSession.HandleKeyAsync were both +/// written and both unit-tested, and no keystroke had ever reached either of them — so every one of +/// F4's bindings was inert while its own tests passed. These drive real keys into the app's own handler +/// instead, which is the only place that gap was ever visible. +/// +/// +/// Serialised for the same reason is: constructing the app touches +/// the process-global console streams, and RenderSnapshot redirects Console.Out. +/// +[NotInParallel] +public class MacroDispatchEndToEndTests +{ + private const int Width = 120; + private const int Height = 34; + + private static readonly TerminalCapabilities Headless = + new(GraphicsProtocol.None, supportsTrueColor: true, supportsKittyGraphics: false, supportsSixel: false); + + /// + /// The demo configuration with the connected character's session bound but no socket under it, plus + /// the app driving it. Logging is turned off first: opening the demo character's HTML log would write + /// a real file into the user's config directory, which a test has no business doing. + /// + private static (SharpMUTermApp App, AppConfiguration Config) Bound() + { + Console.SetIn(TextReader.Null); + + var config = DemoScene.Build(); + config.Worlds[0].Characters[0].Logging = new LoggingSettings(); + + var app = new SharpMUTermApp(config, Headless, new HeadlessConsoleDriver(Width, Height)); + app.BindWorldWithoutConnecting(config.Worlds[0]); + return (app, config); + } + + private static ConsoleKeyInfo Chord(ConsoleKey key, bool ctrl = false, bool alt = false, bool shift = false) => + new('\0', key, shift, alt, ctrl); + + /// + /// The headline: a configured binding sends its command when its key is pressed. The demo binds + /// Ctrl+F1 to score, which is the one binding in that configuration this host can + /// actually deliver. + /// + [Test] + public async Task ABoundKeyFiresItsCommandThroughTheAppsOwnKeyHandler() + { + var (app, _) = Bound(); + + await Assert.That(app.SimulateKey(Chord(ConsoleKey.F1, ctrl: true))).IsEqualTo("score"); + } + + /// A key nothing is bound to is not the app's, and is left for whatever wanted it. + [Test] + public async Task AnUnboundKeyDispatchesNothing() + { + var (app, _) = Bound(); + + await Assert.That(app.SimulateKey(Chord(ConsoleKey.F12, ctrl: true))).IsNull(); + } + + /// + /// Rebinding is live. The engine used to be a dictionary keyed on the descriptor string it was handed + /// at construction, so a macro rebound on F4 went on answering to the key it no longer carried until + /// the next reconnect — the exact staleness Trigger.Pattern and Alias.CaseSensitive + /// drop their compiled matcher to avoid. + /// + [Test] + public async Task RebindingAMacroTakesEffectOnTheNextKeystroke() + { + var (app, config) = Bound(); + var macro = config.TriggerSets.SelectMany(s => s.Macros).Single(m => m.Key == "Ctrl+F1"); + + macro.Key = "Ctrl+F10"; + + await Assert.That(app.SimulateKey(Chord(ConsoleKey.F1, ctrl: true))).IsNull(); + await Assert.That(app.SimulateKey(Chord(ConsoleKey.F10, ctrl: true))).IsEqualTo("score"); + } + + /// A disabled binding is a row that says it is off, and it is off. + [Test] + public async Task ADisabledBindingDoesNotFire() + { + var (app, config) = Bound(); + config.TriggerSets.SelectMany(s => s.Macros).Single(m => m.Key == "Ctrl+F1").Enabled = false; + + await Assert.That(app.SimulateKey(Chord(ConsoleKey.F1, ctrl: true))).IsNull(); + } + + /// + /// A settings screen owns the keyboard while it is up: its own ⏎/⇥/Esc are the whole contract, and a + /// macro firing underneath one would send a command the user was in the middle of editing. This is + /// the case the framework happens to give us for free (the overlay is a modal window, so the main + /// window's preview is never raised) and which the app therefore has to assert for itself, because + /// "for free" is a property of the framework's dispatch and not a decision anyone made here. + /// + [Test] + public async Task NoMacroFiresWhileASettingsScreenHasTheKeyboard() + { + var (app, _) = Bound(); + app.RenderSnapshot("keypad"); // opens the F4 overlay, exactly as the F4 shortcut would + + await Assert.That(app.SimulateKey(Chord(ConsoleKey.F1, ctrl: true))).IsNull(); + } + + /// The same for the command surface, whose keyboard is a search box. + [Test] + public async Task NoMacroFiresWhileTheCommandSurfaceIsOpen() + { + var (app, _) = Bound(); + app.RenderSnapshot("menu"); + + await Assert.That(app.SimulateKey(Chord(ConsoleKey.F1, ctrl: true))).IsNull(); + } + + /// + /// The other half of the rule, and the one that would ruin the client rather than merely disappoint: + /// dispatch runs before the prompt sees a key, so an unmodified letter must never be treated as a + /// binding however a configuration spells it. A macro on a bare key is refused at the F4 capture and + /// marked on the row; it is refused here too, so a hand-edited file cannot make typing impossible. + /// + [Test] + public async Task APlainLetterIsTypingEvenWhenAMacroClaimsIt() + { + var (app, config) = Bound(); + config.TriggerSets[0].Macros.Add(new Macro { Name = "typo", Key = "K", Command = "kill" }); + + await Assert.That(app.SimulateKey(new ConsoleKeyInfo('k', ConsoleKey.K, false, false, false))).IsNull(); + } + + /// + /// A macro cannot outrank a chord the app has claimed globally, because a global shortcut runs first + /// and this handler is never reached — which is exactly what F4 tells the user, and why the two read + /// the same list (). + /// + [Test] + public async Task AMacroOnAChordTheAppClaimsIsNotDispatched() + { + var (app, config) = Bound(); + config.TriggerSets[0].Macros.Add(new Macro { Name = "greedy", Key = "Ctrl+Q", Command = "quit" }); + + await Assert.That(app.SimulateKey(Chord(ConsoleKey.Q, ctrl: true))).IsNull(); + } + + /// + /// The ⌃B pane prefix consumes the next key whole. A macro firing on the key that follows it would + /// mean the prefix had two meanings depending on what was configured. + /// + [Test] + public async Task NoMacroFiresOnTheKeyFollowingThePanePrefix() + { + var (app, _) = Bound(); + + // ⌃B is a global shortcut and never reaches the window handler, so the prefix is armed the way + // the shortcut arms it — which is what the `prefix` snapshot view does. + app.RenderSnapshot("prefix"); + + await Assert.That(app.SimulateKey(Chord(ConsoleKey.F1, ctrl: true))).IsNull(); + } + + /// + /// With nothing connected there is nowhere to send a command, so the key is left alone rather than + /// swallowed into silence. The bindings live on the session, which is what scopes them to the + /// character's trigger sets. + /// + [Test] + public async Task WithNoSessionABoundKeyIsLeftAlone() + { + Console.SetIn(TextReader.Null); + var app = new SharpMUTermApp(DemoScene.Build(), Headless, new HeadlessConsoleDriver(Width, Height)); + + await Assert.That(app.SimulateKey(Chord(ConsoleKey.F1, ctrl: true))).IsNull(); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/MacroKeyCaptureTests.cs b/tests/SharpMUTerm.Tui.Tests/MacroKeyCaptureTests.cs new file mode 100644 index 00000000..75a4c186 --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/MacroKeyCaptureTests.cs @@ -0,0 +1,391 @@ +using System.Text.RegularExpressions; +using SharpMUTerm.Core.Automation; +using SharpMUTerm.Core.Configuration; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// What F4 now knows about the keyboard, and how a binding is rebound. +/// +/// Two rules are asserted here and they are the same rule twice. A screen may not draw a row that +/// quietly does nothing — so every binding carries , and the ones that +/// cannot fire say so. And a screen may not create such a row — so the key capture refuses a +/// chord this host cannot deliver and a chord another binding already holds, at the moment the key is +/// pressed rather than the first time the user wonders why nothing happened. +/// +/// +public class MacroKeyCaptureTests +{ + private static List Sets() => new() + { + new TriggerSet + { + Name = "Comms", + Macros = new List + { + new() { Name = "Look", Key = "Num5", Command = "look" }, + new() { Name = "Score", Key = "Ctrl+F1", Command = "score" }, + }, + }, + }; + + private static SettingsSession Session(IReadOnlyList sets) => + new(selection => KeypadScreenRenderer.Model( + sets.SelectMany(s => s.Macros).ToList(), sets, selection.SelectionIn(0))); + + private static ConsoleKeyInfo Chord(ConsoleKey key, bool ctrl = false, bool alt = false, bool shift = false) => + new('\0', key, shift, alt, ctrl); + + /// Opens the binding row's key field: ⏎ opens the name, then ⇥ twice reaches the key. + private static void ArmCapture(SettingsSession session) + { + session.Handle(new ConsoleKeyInfo('\r', ConsoleKey.Enter, false, false, false)); + session.Handle(new ConsoleKeyInfo('\t', ConsoleKey.Tab, false, false, false)); + session.Handle(new ConsoleKeyInfo('\t', ConsoleKey.Tab, false, false, false)); + } + + // ---- what the host can actually deliver ------------------------------------------------------- + + /// + /// The verdicts, each one a fact about SharpConsoleUI's input parser, this app's own shortcuts, or + /// the prompt — read out of the parser at v2.5.14, not assumed. The numpad row is the one the audit + /// turned up: the framework sends no DECKPAM and decodes no application-keypad SS3, and + /// ConsoleKey.NumPad0 appears nowhere in it, so a numpad chord is not merely unbound here — + /// it cannot arrive. + /// + [Test] + [Arguments("Ctrl+F1", nameof(MacroKeyDelivery.Fires))] + [Arguments("F1", nameof(MacroKeyDelivery.Fires))] + [Arguments("F12", nameof(MacroKeyDelivery.Fires))] + [Arguments("Shift+F3", nameof(MacroKeyDelivery.Fires))] + [Arguments("Ctrl+K", nameof(MacroKeyDelivery.Fires))] + [Arguments("Alt+K", nameof(MacroKeyDelivery.Fires))] + [Arguments("Alt+5", nameof(MacroKeyDelivery.Fires))] + [Arguments("Ctrl+Up", nameof(MacroKeyDelivery.Fires))] + [Arguments("Num5", nameof(MacroKeyDelivery.NeverArrives))] + [Arguments("Num0", nameof(MacroKeyDelivery.NeverArrives))] + [Arguments("Ctrl+Alt+K", nameof(MacroKeyDelivery.NeverArrives))] + [Arguments("Ctrl+Shift+K", nameof(MacroKeyDelivery.NeverArrives))] + [Arguments("Ctrl+I", nameof(MacroKeyDelivery.NeverArrives))] + [Arguments("Ctrl+M", nameof(MacroKeyDelivery.NeverArrives))] + [Arguments("Ctrl+5", nameof(MacroKeyDelivery.NeverArrives))] + [Arguments("Alt+O", nameof(MacroKeyDelivery.NeverArrives))] + [Arguments("Enter", nameof(MacroKeyDelivery.NeverArrives))] + [Arguments("F4", nameof(MacroKeyDelivery.Taken))] + [Arguments("F9", nameof(MacroKeyDelivery.Taken))] + [Arguments("Ctrl+Q", nameof(MacroKeyDelivery.Taken))] + [Arguments("Ctrl+P", nameof(MacroKeyDelivery.Taken))] + [Arguments("K", nameof(MacroKeyDelivery.Taken))] + [Arguments("Up", nameof(MacroKeyDelivery.Taken))] + public async Task TheVerdictSaysWhatWillHappenToAChord(string descriptor, string expected) + { + var verdict = MacroKeys.Verdict(descriptor); + + await Assert.That(verdict.Delivery.ToString()).IsEqualTo(expected).Because(descriptor); + await Assert.That(verdict.Reason.Length > 0).IsEqualTo(expected != nameof(MacroKeyDelivery.Fires)) + .Because(descriptor + " must give a reason exactly when it will not fire"); + } + + /// + /// The dispatcher and the screen cannot disagree, by construction: + /// is filtered by the same + /// verdict F4 draws. Asserted over the whole keyboard rather than a sample, because "the list says + /// this fires and the handler ignores it" is precisely the failure this work exists to remove. + /// + [Test] + public async Task WhateverTheScreenCallsLiveIsWhatTheDispatcherActsOn() + { + foreach (var key in Enum.GetValues()) + { + foreach (var modifiers in new[] + { + (ctrl: false, alt: false, shift: false), + (ctrl: true, alt: false, shift: false), + (ctrl: false, alt: true, shift: false), + (ctrl: false, alt: false, shift: true), + (ctrl: true, alt: true, shift: false), + }) + { + var stroke = Chord(key, modifiers.ctrl, modifiers.alt, modifiers.shift); + var captured = MacroKeys.Capture(stroke); + var dispatched = MacroKeys.Descriptor(stroke); + + if (captured is null) + { + await Assert.That(dispatched).IsNull().Because(key.ToString()); + continue; + } + + await Assert.That(dispatched) + .IsEqualTo(MacroKeys.Verdict(captured).Fires ? captured : null) + .Because(captured); + } + } + } + + /// + /// A binding that cannot fire is marked where it is drawn, in the muted ink behind a ▲, and + /// explained in the footer for the one the cursor is on. Asserted both ways round, so the mark can + /// neither disappear from a dead row nor spread onto a live one. + /// + /// The reason is deliberately not on the row: the reasons differ, they are longer than the + /// column has cells, and repeated down a list they stop being read. The caption counts them instead, + /// which is the one thing neither the row nor the footer can say. + /// + /// + [Test] + public async Task ABindingThatCannotFireIsMarkedOnItsRowAndExplainedInTheFooter() + { + var macros = Sets()[0].Macros; + var rows = KeypadScreenRenderer.HotkeysColumn(macros); + + var dead = rows.Single(l => l.Contains("Num5", StringComparison.Ordinal)); + await Assert.That(dead).Contains("▲"); + await Assert.That(dead).Contains(ScreenPalette.Muted); + + var live = rows.Single(l => l.Contains("Ctrl+F1", StringComparison.Ordinal)); + await Assert.That(live).DoesNotContain("▲"); + + await Assert.That(rows[0]).Contains("HOTKEYS"); + await Assert.That(rows[0]).Contains("1 of 2 cannot fire"); + + await Assert.That(KeypadScreenRenderer.FooterLine(macros, 120, new ScreenFocus(0, 0))) + .Contains(MacroKeys.Verdict("Num5").Reason); + await Assert.That(KeypadScreenRenderer.FooterLine(macros, 120, new ScreenFocus(0, 1))) + .DoesNotContain("▲"); + } + + /// A list with nothing dead in it says nothing — a count of zero is not news. + [Test] + public async Task AListOfLiveBindingsCarriesNoCaveatAtAll() + { + var macros = new List { new() { Name = "Score", Key = "Ctrl+F1", Command = "score" } }; + var rows = KeypadScreenRenderer.HotkeysColumn(macros); + + await Assert.That(rows[0]).DoesNotContain("▲"); + await Assert.That(rows.Any(l => l.Contains("▲", StringComparison.Ordinal))).IsFalse(); + } + + /// + /// The numpad diagram is nine cells of keys none of which can arrive, so its caption says so — and + /// says it in the verdict's own words, derived rather than written, so a host that could one day + /// deliver the numpad would drop the disclaimer without anyone remembering to. + /// + [Test] + public async Task TheNumpadGridSaysThatNothingReachesIt() + { + var caption = KeypadScreenRenderer.NumpadColumn(Sets()[0].Macros)[0]; + + await Assert.That(caption).Contains("NUMPAD"); + await Assert.That(caption).Contains(MacroKeys.Verdict("Num5").Reason); + } + + // ---- the capture mode ------------------------------------------------------------------------ + + /// + /// The key is the row's third field, appended after the name and the command so the two ordinals + /// that were already addressed by the renderer, the tests and the snapshot scripts still mean what + /// they meant. Opening it arms a capture rather than a buffer. + /// + [Test] + public async Task TheBindingRowCarriesItsKeyAsACaptureField() + { + var sets = Sets(); + var model = KeypadScreenRenderer.Model(sets.SelectMany(s => s.Macros).ToList(), sets, 0); + var row = model.RowAt(0, 0); + + await Assert.That(row.FieldCount).IsEqualTo(3); + await Assert.That(row.FieldAt(KeypadScreenRenderer.NameField)!.Value.Get()).IsEqualTo("Look"); + await Assert.That(row.FieldAt(KeypadScreenRenderer.CommandField)!.Value.Get()).IsEqualTo("look"); + await Assert.That(row.FieldAt(KeypadScreenRenderer.KeyField)!.Value.Get()).IsEqualTo("Num5"); + await Assert.That(row.FieldAt(KeypadScreenRenderer.KeyField)!.Value.Capture).IsTrue(); + await Assert.That(row.FieldAt(KeypadScreenRenderer.NameField)!.Value.Capture).IsFalse(); + } + + /// The headline of task two: the next keystroke becomes the binding, canonically spelt. + [Test] + public async Task TheNextKeystrokeBecomesTheBinding() + { + var sets = Sets(); + var session = Session(sets); + ArmCapture(session); + + await Assert.That(session.Focus().Edit!.Value.Capture).IsTrue(); + + session.Handle(Chord(ConsoleKey.F7, ctrl: true, shift: true)); + + await Assert.That(sets[0].Macros[0].Key).IsEqualTo("Ctrl+Shift+F7"); + await Assert.That(session.IsEditing).IsFalse(); + } + + /// + /// A capture writes the canonical spelling whatever the terminal reports, and the two shapes already + /// in configurations survive a round trip through it: Ctrl+F1 is exactly what pressing Ctrl+F1 + /// produces, and Num5 — which no keystroke can produce — is still the spelling the numpad grid + /// and the demo configuration use, unchanged by being read. + /// + [Test] + public async Task CaptureAndStoredDescriptorsAgreeOnOneSpelling() + { + await Assert.That(MacroKeys.Capture(Chord(ConsoleKey.F1, ctrl: true))).IsEqualTo("Ctrl+F1"); + await Assert.That(MacroKeys.Capture(new ConsoleKeyInfo('k', ConsoleKey.K, false, true, false))) + .IsEqualTo("Alt+K"); + + await Assert.That(MacroKey.Canonicalise("Ctrl+F1")).IsEqualTo("Ctrl+F1"); + await Assert.That(MacroKey.Canonicalise("Num5")).IsEqualTo("Num5"); + await Assert.That(MacroKey.Canonicalise("shift+ctrl+f1")).IsEqualTo("Ctrl+Shift+F1"); + await Assert.That(MacroKey.Canonicalise("NumPad5")).IsEqualTo("Num5"); + await Assert.That(MacroKey.Canonicalise("esc")).IsEqualTo("Escape"); + await Assert.That(MacroKey.Canonicalise("Hyper+F1")).IsNull(); + } + + /// + /// The trap this mode could have set, and does not. Esc is how every modal state on these screens is + /// left, and a capture that ate it would leave a user with no key that ends the prompt — ⏎ and ⇥ are + /// themselves chords someone might want to bind, so neither can be the way out. + /// + [Test] + public async Task EscapeAlwaysLeavesACaptureAndBindsNothing() + { + var sets = Sets(); + var session = Session(sets); + ArmCapture(session); + + var action = session.Handle(new ConsoleKeyInfo('', ConsoleKey.Escape, false, false, false)); + + await Assert.That(action).IsEqualTo(ScreenAction.Redraw); + await Assert.That(session.IsEditing).IsFalse(); + await Assert.That(sets[0].Macros[0].Key).IsEqualTo("Num5"); + } + + /// + /// The duplicate. A resolves one macro per key, so a second binding on a + /// key never runs — and unlike every other dead row it would have no symptom at all, since both rows + /// would look alive. The capture refuses it, names the binding already holding the key, and stays + /// armed, so the answer to "that one is taken" is another keystroke rather than a lost edit. + /// + [Test] + public async Task AKeyAnotherBindingAlreadyHoldsIsRefusedAndNamesTheOtherBinding() + { + var sets = Sets(); + var session = Session(sets); + ArmCapture(session); + + session.Handle(Chord(ConsoleKey.F1, ctrl: true)); // Score's key + + var edit = session.Focus().Edit; + await Assert.That(edit).IsNotNull(); + await Assert.That(edit!.Value.Capture).IsTrue(); + await Assert.That(edit.Value.Error).IsEqualTo("already bound to Score"); + await Assert.That(sets[0].Macros[0].Key).IsEqualTo("Num5"); + + // Still armed: the next key is still the value. + session.Handle(Chord(ConsoleKey.F11)); + await Assert.That(sets[0].Macros[0].Key).IsEqualTo("F11"); + } + + /// + /// Re-pressing the key a binding already has is not a duplicate of itself. It commits, unchanged, + /// which is the only sane reading of "bind this to the key it is on". + /// + [Test] + public async Task PressingTheKeyThisBindingAlreadyHasSimplyCommits() + { + var sets = new List + { + new() { Name = "Comms", Macros = new List { new() { Name = "Score", Key = "Ctrl+F1", Command = "score" } } }, + }; + var session = Session(sets); + ArmCapture(session); + + session.Handle(Chord(ConsoleKey.F1, ctrl: true)); + + await Assert.That(session.IsEditing).IsFalse(); + await Assert.That(sets[0].Macros[0].Key).IsEqualTo("Ctrl+F1"); + } + + /// + /// A chord this host cannot deliver is refused at the capture, in the verdict's own words. The point + /// is that the refusal happens while the user's finger is still on the key: the alternative is a row + /// that looks bound, is bound, and does nothing. + /// + [Test] + [Arguments(ConsoleKey.NumPad5, false, false, "no numpad key ever arrives")] + [Arguments(ConsoleKey.K, false, false, "plain keys type into the prompt")] + [Arguments(ConsoleKey.F4, false, false, "F4 opens this screen")] + [Arguments(ConsoleKey.Q, true, false, "Ctrl+Q quits")] + [Arguments(ConsoleKey.I, true, false, "the terminal sends Tab instead")] + [Arguments(ConsoleKey.O, false, true, "Alt+O is the terminal's own prefix")] + public async Task AChordThatCouldNeverFireIsRefusedAtTheCapture( + ConsoleKey key, bool ctrl, bool alt, string reason) + { + var sets = Sets(); + var session = Session(sets); + ArmCapture(session); + + session.Handle(Chord(key, ctrl, alt)); + + await Assert.That(session.Focus().Edit!.Value.Error).IsEqualTo(reason); + await Assert.That(sets[0].Macros[0].Key).IsEqualTo("Num5"); + } + + /// + /// The undo log covers a rebinding like any other edit: Esc on the screen puts the old key back, so + /// a capture is no more permanent than typing into a well. + /// + [Test] + public async Task CancellingTheScreenPutsTheOldKeyBack() + { + var sets = Sets(); + var session = Session(sets); + ArmCapture(session); + session.Handle(Chord(ConsoleKey.F11)); + await Assert.That(sets[0].Macros[0].Key).IsEqualTo("F11"); + + session.Edits.Revert(); + + await Assert.That(sets[0].Macros[0].Key).IsEqualTo("Num5"); + } + + /// + /// The chrome while a capture is armed says exactly what is true of the keyboard at that moment: one + /// key gets you out, everything else is the value. It may not offer ⏎ commit, ⇥ next field or + /// F4 close, because all three are keys that mean something else while the prompt is up — the + /// same rule that forbids a header claiming ⏎ edit on a screen with nothing to edit. + /// + [Test] + public async Task TheChromeOffersOnlyWhatACaptureActuallyAnswersTo() + { + var sets = Sets(); + var session = Session(sets); + ArmCapture(session); + var focus = session.Focus(); + + var header = KeypadScreenRenderer.HeaderLine( + 120, KeypadScreenRenderer.Model(sets[0].Macros, sets, 0), focus); + await Assert.That(header).Contains(ScreenChrome.CaptureHints); + await Assert.That(header).DoesNotContain(ScreenChrome.EditingHints); + await Assert.That(header).DoesNotContain(ScreenChrome.NextFieldHint); + await Assert.That(Visible(header)).DoesNotContain("F4 close"); + + var footer = KeypadScreenRenderer.FooterLine(sets[0].Macros, 120, focus); + await Assert.That(footer).Contains(ScreenChrome.BindAction); + await Assert.That(footer).DoesNotContain(ScreenChrome.CommitAction); + + // And the field itself is a prompt, not a caret over a buffer there is no way to type into. + var row = KeypadScreenRenderer.HotkeysColumn(sets[0].Macros, focus) + .Single(l => l.Contains(ScreenChrome.CapturePrompt, StringComparison.Ordinal)); + await Assert.That(row).Contains("look"); + } + + /// A markup line as it prints: tags stripped, escaped brackets folded back to one. + private static string Visible(string markup) + { + var guarded = markup.Replace("[[", "", StringComparison.Ordinal) + .Replace("]]", "", StringComparison.Ordinal); + return Regex.Replace(guarded, @"\[[^\[\]]*\]", string.Empty) + .Replace('', '[') + .Replace('', ']'); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenListButtonTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenListButtonTests.cs index a6bad1cc..99401070 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenListButtonTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenListButtonTests.cs @@ -327,49 +327,54 @@ await Assert.That(sets[0].Triggers.Select(t => t.Name)) /// /// F4's add button is the one that cannot simply append. A is identified by its - /// , which this screen deliberately cannot edit, so the button claims the - /// lowest free numpad digit and says which one on its own row — a binding created on a key the user - /// couldn't see and couldn't change would be unfixable from here. + /// , so the button claims a free one and says which on its own row. It claims + /// from rather than the numpad: no numpad key ever reaches this + /// client, so a binding born on one could never fire, and a button whose whole job is to name the + /// key it takes must not name a dead one. /// [Test] - public async Task AddingABindingClaimsTheLowestFreeNumpadKeyAndNamesIt() + public async Task AddingABindingClaimsAFreeKeyThatCanActuallyFire_AndNamesIt() { var sets = Sets(); var button = ButtonNamed( KeypadScreenRenderer.Model(sets[0].Macros, sets, 0), 0, KeypadScreenRenderer.AddBindingLabel); - await Assert.That(button.Target).IsEqualTo("Num0"); + var first = MacroKeys.Bindable[0]; + await Assert.That(button.Target).IsEqualTo(first); + await Assert.That(MacroKeys.Verdict(first).Fires).IsTrue(); new ScreenEdits().Apply(button); - await Assert.That(sets[0].Macros[^1].Key).IsEqualTo("Num0"); + await Assert.That(sets[0].Macros[^1].Key).IsEqualTo(first); - // The next one takes the next free digit, not the same one again. + // The next one takes the next free key, not the same one again. var again = ButtonNamed( KeypadScreenRenderer.Model(sets.SelectMany(s => s.Macros).ToList(), sets, 0), 0, KeypadScreenRenderer.AddBindingLabel); - await Assert.That(again.Target).IsEqualTo("Num1"); + await Assert.That(again.Target).IsEqualTo(MacroKeys.Bindable[1]); } /// - /// With every numpad digit spoken for there is no free key to claim, so the add button isn't drawn - /// — the same rule that keeps [[- del]] off a pane with nothing selected. Delete still works, - /// which is how you make room. + /// With every bindable chord spoken for there is no free key to claim, so the add button isn't + /// drawn — the same rule that keeps [[- del]] off a pane with nothing selected. Delete still + /// works, which is how you make room. /// [Test] - public async Task NoBindingCanBeAddedOnceEveryNumpadKeyIsBound() + public async Task NoBindingCanBeAddedOnceEveryBindableKeyIsTaken() { var sets = new List { new() { Name = "All" } }; - for (var digit = 0; digit <= 9; digit++) + foreach (var key in MacroKeys.Bindable) { - sets[0].Macros.Add(new Macro { Name = "n" + digit, Key = "Num" + digit, Command = "look" }); + sets[0].Macros.Add(new Macro { Name = key, Key = key, Command = "look" }); } var model = KeypadScreenRenderer.Model(sets[0].Macros, sets, 0); + var bindings = MacroKeys.Bindable.Count; - await Assert.That(model.Sizes[0]).IsEqualTo(11); // 10 bindings + [- del] and nothing else - await Assert.That(model.ButtonAt(0, 10)!.Value.Label).IsEqualTo(KeypadScreenRenderer.RemoveBindingLabel); - await Assert.That(model.ButtonAt(0, 11)).IsNull(); + await Assert.That(model.Sizes[0]).IsEqualTo(bindings + 1); // the bindings + [- del], nothing else + await Assert.That(model.ButtonAt(0, bindings)!.Value.Label) + .IsEqualTo(KeypadScreenRenderer.RemoveBindingLabel); + await Assert.That(model.ButtonAt(0, bindings + 1)).IsNull(); } /// @@ -395,7 +400,8 @@ public async Task ATargetedButtonNamesTheRowItWouldActOn() var bindings = KeypadScreenRenderer.HotkeysColumn(sets[0].Macros, null, sets, 0); await Assert.That(bindings.Any(l => l.Contains("[[- del]]") && l.Contains("Look"))).IsTrue(); - await Assert.That(bindings.Any(l => l.Contains("[[+ binding]]") && l.Contains("Num0"))).IsTrue(); + await Assert.That(bindings.Any(l => l.Contains("[[+ binding]]") && l.Contains(MacroKeys.Bindable[0]))) + .IsTrue(); } /// From 78512303d0e8fafecc567ef563e5609323b322a7 Mon Sep 17 00:00:00 2001 From: Harry Cordewener Date: Tue, 28 Jul 2026 23:26:35 -0500 Subject: [PATCH 20/23] Make trigger sets manageable MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit TriggerSet is the organising unit of the automation config -- triggers, aliases, timers and macros all live in one, and characters are assigned them by name -- yet nothing created, renamed or deleted a set, and nothing moved an item between them. The only set operation in the whole UI was toggling a character's membership. Rejected the obvious shape, a set switcher on F2/F3/F6/F4. A new pane on four screens renumbers every pane index those screens, their snapshot key scripts and their tests navigate by; "the current set" has no natural home; and it hides something true, because a session runs the union of a character's sets, so the flattened list is the only view showing every rule that can actually fire. It also would not have solved moving an item, which is what actually made a mis-filed trigger permanent. Instead: sets are objects on F5, and "which set" is a field everywhere else. F5's third pane was assignment-only and now owns the sets -- Space still assigns, ⏎ renames, ⇥ edits the description, and it has add/remove. The other four screens get a set field appended last on each item's row, so moving something is an edit like any other, and nothing was renumbered. A set name is the one unique name on these screens, because it is a key: ResolveTriggerSets takes the first match, so the second of two identical names could never be assigned. Renaming rewrites every character's assignment in place, keeping the order that decides which set wins a conflict. Deleting strips the references too, and its undo restores the set at its index and each reference at its own index inside the character that held it -- walking detach backwards and reattach forwards so two references in one character survive. An empty set is visible in both views: a row on F5, and a muted line naming it on each flattened screen, drawn as markup rather than a row so it costs no cursor stop. Also fixes a clipping defect the screenshots caught: with the set cell added, F4's armed key-capture row ran off the right edge, its prompt being twice the width of the key it replaces. 1101 tests pass, up from 1071. Four pinned assertions changed, each reported and each asserting more than before; the pane-shape one keeps its original ListSizes assertion alongside the new total. Co-Authored-By: Claude Opus 5 (1M context) --- CLAUDE.md | 2 +- docs/HANDOFF.md | 75 ++- .../Configuration/TriggerSetReferences.cs | 112 ++++ src/SharpMUTerm.Tui/AliasesScreenRenderer.cs | 42 +- src/SharpMUTerm.Tui/DemoScene.cs | 14 + src/SharpMUTerm.Tui/KeypadScreenRenderer.cs | 97 ++- src/SharpMUTerm.Tui/KeypadScreenView.cs | 8 +- src/SharpMUTerm.Tui/ScreenChrome.cs | 18 + src/SharpMUTerm.Tui/ScreenField.cs | 48 +- src/SharpMUTerm.Tui/ScreenLists.cs | 184 +++++- src/SharpMUTerm.Tui/SettingsSession.cs | 21 +- src/SharpMUTerm.Tui/SharpMUTermApp.cs | 21 +- src/SharpMUTerm.Tui/TimersScreenRenderer.cs | 44 +- src/SharpMUTerm.Tui/TriggersScreenRenderer.cs | 50 +- src/SharpMUTerm.Tui/WorldsScreenRenderer.cs | 268 ++++++-- src/SharpMUTerm.Tui/WorldsScreenView.cs | 10 +- .../Configuration/TriggerSetReferenceTests.cs | 168 ++++++ .../MacroKeyCaptureTests.cs | 6 +- .../ScreenButtonTests.cs | 9 +- .../ScreenDeleteKeyTests.cs | 51 +- .../SharpMUTerm.Tui.Tests/ScreenModelTests.cs | 7 +- .../SettingsScreenViewTests.cs | 24 + .../TriggerSetManagementTests.cs | 571 ++++++++++++++++++ .../TriggersScreenEditingTests.cs | 9 +- 24 files changed, 1752 insertions(+), 107 deletions(-) create mode 100644 src/SharpMUTerm.Core/Configuration/TriggerSetReferences.cs create mode 100644 tests/SharpMUTerm.Core.Tests/Configuration/TriggerSetReferenceTests.cs create mode 100644 tests/SharpMUTerm.Tui.Tests/TriggerSetManagementTests.cs diff --git a/CLAUDE.md b/CLAUDE.md index 036a61ad..d89c4710 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -32,7 +32,7 @@ fallbacks) for inline images/maps. ## Repository state **M1 delivered, plus substantial M2–M4 work.** `SharpMUTerm.slnx` builds all ten projects on -`net10.0`; the solution has **1071 tests**, all passing. In place: +`net10.0`; the solution has **1101 tests**, all passing. In place: - **Core** — `AnsiParser` (SGR 16/256/truecolor), styled-line + `ScrollbackBuffer` model, `TcpTransport` (TLS + IPv6), `TelnetSession` (wraps TelnetNegotiationCore **2.5.3**), diff --git a/docs/HANDOFF.md b/docs/HANDOFF.md index 8eeadf61..4d388344 100644 --- a/docs/HANDOFF.md +++ b/docs/HANDOFF.md @@ -4,8 +4,8 @@ Context for whoever (human or agent) picks up this work next. - **Repository:** `SharpMUSH/SharpMUTerm` - **Start from:** a fresh branch off `main` -- **Tests:** 1071 across the solution (396 Core / 83 Graphics / 42 Scripting / - 28 Web / 522 Tui), all passing; `dotnet build SharpMUTerm.slnx` clean (0 warnings +- **Tests:** 1101 across the solution (404 Core / 83 Graphics / 42 Scripting / + 28 Web / 544 Tui), all passing; `dotnet build SharpMUTerm.slnx` clean (0 warnings from this repo; building against a local SharpConsoleUI clone surfaces 2 upstream NuGet advisory warnings for AngleSharp, which are the framework's, not ours) @@ -78,6 +78,23 @@ works. `Name` went `init` → `set`; none of them has cached derived state (checked: the engines match on patterns and `MacroEngine` is keyed by `Macro.Key`), which `AutomationCloneTests.RenamingLeavesTheCompiledMatcherAlone` pins. +- **Trigger sets are managed now**, which they were not: nothing created, renamed + or deleted one, and nothing moved an item between them. Two surfaces, chosen + over a per-screen set switcher (see *Managing trigger sets* under Critical + Gotchas for the full reasoning): + - **F5's third pane owns the sets.** Space still assigns the selected character + to one; ⏎ renames it, ⇥ edits its description, and `[+ set]` / `[- del]` make + and unmake them. It is the only view of sets as objects, so it is also the + only place an empty set is always visible — and its inventory counts + everything a set holds, not only its triggers. `Sizes[2]` went 1 → 3 in + `ScreenModelTests`/`ScreenButtonTests`; `ListSizes[2]` is unchanged and still + asserted, so the original meaning survives beside the new total. + - **A `set` field on every item's row** on F2/F3/F4/F6, appended last + (`FieldCount` 9 → 10 on F2, 3 → 4 on F4), so no ordinal moved. It is a + **closed** list of the configured set names, and committing it *moves* the + item — which is why `ScreenField` grew `Follow`: the four panes are flattened + across every set, so the row genuinely changes position and the cursor has to + go with it. - **Rows still not editable** (deliberately): a character's password (it is `[JsonIgnore]` and belongs in a credential store), and everything derived (the numpad grid, the session/state readouts). **All of them now say so on screen** — @@ -196,7 +213,7 @@ Things that will waste your time if you don't know them. demo. Drop the flag only when reproducing something specific to a real setup. - **Snapshot view names:** `worlds`/`settings`, `triggers`, `route`, `highlight`, `aliases`, `timers`, - `keypad`, `textansi`, `input`, `logging`, `freeze`, `spawn`, `split`, `move`, + `keypad`, `set`, `textansi`, `input`, `logging`, `freeze`, `spawn`, `split`, `move`, `drag`, `history`, `menu`, `menu-split`, plus the default (no `--view`) workspace. Extra state toggles: `collapsed`, `prefix`, `timestamps`. Any settings screen also takes a `-edit` suffix (`worlds-edit`, `logging-edit`, `keypad-edit`, …), which @@ -498,6 +515,58 @@ What the framework actually provides (read at v2.5.14, not assumed): - Pane shape: F4/F7/F8 are single-pane (no ⇥); **F5 has four** (worlds → characters → trigger sets → the world's security checkboxes); the rest have two. +### Managing trigger sets + +- **A set switcher on F2/F3/F4/F6 was rejected.** It is the obvious shape — the + screens become "the triggers in *this* set" — and it costs a new pane on four + screens, which renumbers every pane index those screens, their `-edit` snapshot + scripts and their tests navigate by, for a "current set" that has no home + (per screen? shared?). It also *hides* something true: a session runs the + **union** of a character's sets, so the flattened list is the only view that + shows every rule that can actually fire, and two sets both matching + `^\[public\]` are only visible in it. What the complaint ("at ten sets it + collapses") really wants is a filter, which is a separate feature; what it + needed to be *usable* was the ability to move an item, which a field gives. +- **So: sets are objects on F5, and "which set" is a field everywhere else.** + The field re-uses machinery that already existed (`ScreenField` with choices, + and the dropdown that draws them), and makes the move an ordinary edit with the + ordinary undo. +- **A set's name is a key, not a label.** `CharacterDefinition.TriggerSets` is a + list of *names* and `AppConfiguration.ResolveTriggerSets` takes the first match, + so it is the one name on these screens that must be **unique** + (`ScreenField.UniqueName`, case-insensitive like the resolver) — everything + else is deliberately not (see *A row's fields lead with its name*). +- **Renaming a set rewrites every character's assignment, in place.** + `TriggerSetReferences` (Core) is the one definition: `Find` by the old name, + then `Rename` / `Detach` / `Reattach`. In place matters — the character's order + decides which set wins a conflict. Undo is free: `ScreenField.Name`'s snapshot + replays the same setter with the old name. +- **Deleting a set strips the assignments too**, and its undo is two + restorations, not one: the set at its index, and each reference at *its* index + inside the character that held it. That is why it is a hand-built + `ScreenButton` rather than `ScreenButton.Remove`. `Detach` walks backwards and + `Reattach` forwards, or the second reference in one character renumbers under + the first. +- **`ScreenField.Follow`** is the field-side counterpart of `ScreenPress.Select`: + only the thing that performed the change knows where the row went. + `SettingsSession.Commit` seeds the cursor from it, and `Step` (⇥) re-projects + the model afterwards — stepping through the projection the key arrived with + would open the next field of whichever row *used* to be under the cursor. +- **An empty set is drawn, twice over.** On F5 it is a row like any other + (`▪ Combat hp + damage tracking empty`). On the four flattened screens it is + `ScreenChrome.EmptySet` — a muted `▪ Combat — no triggers` line that is markup + and **not a row**: it stands for a set rather than an item, so it costs no + cursor stop and no pinned row count. The wording is per screen, because "empty" + means empty of the thing that screen edits. +- **The demo scene has three sets**, and the third (`Combat`) is deliberately + lopsided — an alias and a binding, no triggers and no timers — so F2 and F6 + draw the empty-set line and F5 shows an unassigned set. `--view set-edit` is + the frame of the closed set list, alongside `route-edit`/`highlight-edit`. +- **F5's set pane still needs a selected character**, because the other half of + every row is that character's opt-in. On a fresh configuration you add a world + and a character first — which you must do anyway before automation applies to + anything. + ### What a settings field actually reaches (audited) Writing to `AppConfiguration` is not the same as doing something. The three diff --git a/src/SharpMUTerm.Core/Configuration/TriggerSetReferences.cs b/src/SharpMUTerm.Core/Configuration/TriggerSetReferences.cs new file mode 100644 index 00000000..ca33ba23 --- /dev/null +++ b/src/SharpMUTerm.Core/Configuration/TriggerSetReferences.cs @@ -0,0 +1,112 @@ +namespace SharpMUTerm.Core.Configuration; + +/// +/// One character's opt-in to a , and where it sits in that character's own +/// list. The position matters as much as the name: the character's order is what decides which set +/// wins a conflict (see ), so anything that takes a +/// reference out has to be able to put it back exactly where it was rather than on the end. +/// +/// The character that opted in. +/// The position of the name inside . +public readonly record struct TriggerSetReference(CharacterDefinition Character, int Index); + +/// +/// The links between a and the characters that opted into it. A character +/// selects its automation by name ( is a list of +/// strings), so renaming or removing a set silently orphans every one of those references unless +/// something goes and fixes them — which is what this does. +/// +/// The operations are split into find / act / put back rather than being one "rename" call, because +/// the settings screens undo by replaying: they capture the references first, mutate, and keep the +/// captured list as the way home. Anything that removes references walks them backwards and +/// anything that restores them walks forwards, so the indices stay meaningful while a character's list +/// is shifting under them. +/// +/// +public static class TriggerSetReferences +{ + /// + /// Every character assignment naming , in world → character → position + /// order. Matching is case-insensitive because + /// resolves that way: a reference that would resolve to this set is a reference to it, whatever + /// case it was typed in. + /// + public static List Find(IReadOnlyList worlds, string name) + { + ArgumentNullException.ThrowIfNull(worlds); + ArgumentNullException.ThrowIfNull(name); + + var found = new List(); + foreach (var world in worlds) + { + foreach (var character in world.Characters) + { + for (var i = 0; i < character.TriggerSets.Count; i++) + { + if (string.Equals(character.TriggerSets[i], name, StringComparison.OrdinalIgnoreCase)) + { + found.Add(new TriggerSetReference(character, i)); + } + } + } + } + + return found; + } + + /// + /// Points every captured reference at , in place. This is what makes a set + /// rename safe: the assignment keeps its position in the character's list, so the priority order a + /// user built by hand survives a typo being fixed. + /// + public static void Rename(IReadOnlyList references, string name) + { + ArgumentNullException.ThrowIfNull(references); + ArgumentNullException.ThrowIfNull(name); + + foreach (var reference in references) + { + if (reference.Index >= 0 && reference.Index < reference.Character.TriggerSets.Count) + { + reference.Character.TriggerSets[reference.Index] = name; + } + } + } + + /// + /// Removes every captured reference, so a deleted set leaves no character pointing at a set that + /// no longer exists. Walked newest-index-first, because removing the second entry of a list + /// renumbers the third. + /// + public static void Detach(IReadOnlyList references) + { + ArgumentNullException.ThrowIfNull(references); + + for (var i = references.Count - 1; i >= 0; i--) + { + var reference = references[i]; + if (reference.Index >= 0 && reference.Index < reference.Character.TriggerSets.Count) + { + reference.Character.TriggerSets.RemoveAt(reference.Index); + } + } + } + + /// + /// The inverse of : puts back at each captured + /// position, walked forwards so each insertion restores the list the next index was measured + /// against. Undoing a set deletion has to come through here — restoring the set alone would leave + /// every character that used it unassigned, which is a second edit nobody asked for. + /// + public static void Reattach(IReadOnlyList references, string name) + { + ArgumentNullException.ThrowIfNull(references); + ArgumentNullException.ThrowIfNull(name); + + foreach (var reference in references) + { + var assigned = reference.Character.TriggerSets; + assigned.Insert(Math.Clamp(reference.Index, 0, assigned.Count), name); + } + } +} diff --git a/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs b/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs index 5da64cf6..0f0e17c1 100644 --- a/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs @@ -35,6 +35,12 @@ internal static class AliasesScreenRenderer internal const int ExpansionField = 2; + /// + /// Which the alias lives in, appended last so the ordinals above keep + /// meaning what they meant. Committing it moves the alias — see . + /// + internal const int SetField = 3; + /// The labels the alias list's buttons carry, in the order they are drawn. internal const string AddAliasLabel = "+ alias"; @@ -110,7 +116,8 @@ internal static ScreenModel Model(IReadOnlyList sets, int selected) ScreenToggle.Bind(() => entry.Alias.Enabled, v => entry.Alias.Enabled = v), ScreenField.Name("name", () => entry.Alias.Name, v => entry.Alias.Name = v), ScreenField.Pattern("match pattern", () => entry.Alias.Pattern, v => entry.Alias.Pattern = v), - ScreenField.Lines("expansion", () => entry.Alias.Substitution, v => entry.Alias.Substitution = v))) + ScreenField.Lines("expansion", () => entry.Alias.Substitution, v => entry.Alias.Substitution = v), + ScreenLists.Owner(sets, s => s.Aliases, entry.Alias))) .Concat(Buttons(sets, selected)) .ToArray(); @@ -212,10 +219,24 @@ internal static List ListColumn( lines.Add("[dim]no aliases[/]"); } - for (var i = 0; i < entries.Count; i++) + // Walked per set rather than down the flattened list, so a set holding no aliases can still say + // so — it owns none of these rows and would otherwise be drawn nowhere at all. The row indices + // are the flattened ones either way: the placeholder is markup, not a cursor stop. + var index = 0; + foreach (var set in sets) { - var row = Row(entries[i].Alias, entries[i].SetName, i == selected); - lines.Add(ScreenChrome.Cursor(row, cursor.IsOn(0, i), ColumnWidth)); + if (set.Aliases.Count == 0) + { + lines.Add(ScreenChrome.EmptySet(set.Name, "aliases")); + continue; + } + + foreach (var alias in set.Aliases) + { + lines.Add(ScreenChrome.Cursor( + Row(alias, set.Name, index == selected), cursor.IsOn(0, index), ColumnWidth)); + index++; + } } lines.Add(string.Empty); @@ -235,7 +256,7 @@ internal static List EditorColumn( var cursor = focus ?? ScreenFocus.None; var entries = Flatten(sets); return selected >= 0 && selected < entries.Count - ? BuildEditor(entries[selected].Alias, cursor, selected) + ? BuildEditor(entries[selected].Alias, entries[selected].SetName, cursor, selected) : new List(); } @@ -264,15 +285,22 @@ private static string Row(Alias alias, string setName, bool selected) return $"{check} {marker} [bold]{name}[/] [dim]{pattern}[/] [dim]▪ {Escape(setName)}[/] → {expansion}"; } - private static List BuildEditor(Alias alias, ScreenFocus cursor, int selected) + private static List BuildEditor(Alias alias, string setName, ScreenFocus cursor, int selected) { + var set = cursor.EditOn(0, selected, SetField); + // The name leads the editor because it leads the row's fields: ⏎ on an alias opens it here, - // which is also where one created by [+ alias] lands ready to be called something. + // which is also where one created by [+ alias] lands ready to be called something. The set + // follows it, because the list is flattened across every set and the two together are what + // identify the alias; committing it *moves* the alias (ScreenLists.Owner). var lines = new List { "[dim]name[/]", $" {ScreenChrome.Field(Escape(alias.Name), cursor.EditOn(0, selected, NameField))}", string.Empty, + "[dim]set[/]", + $" {ScreenChrome.Field($"[{Value}]{Escape(setName)}[/]", set)}", + string.Empty, "[dim]match pattern (regex)[/]", $" {ScreenChrome.Field(Escape(alias.Pattern), cursor.EditOn(0, selected, PatternField))}", string.Empty, diff --git a/src/SharpMUTerm.Tui/DemoScene.cs b/src/SharpMUTerm.Tui/DemoScene.cs index dbb9b186..f5cc7eb5 100644 --- a/src/SharpMUTerm.Tui/DemoScene.cs +++ b/src/SharpMUTerm.Tui/DemoScene.cs @@ -147,6 +147,20 @@ private static void AddTriggerSets(AppConfiguration config) }, Timers = { new TimerDefinition { Name = "market", IntervalSeconds = 300, Command = "prices", OneShot = false } }, }); + + // A third set, and deliberately a lopsided one. Two sets is enough to show that rules belong to + // a set; it is not enough to show what the set screens have to cope with, which is that a set + // holds four *kinds* of thing and rarely holds all four. Combat has no triggers and no timers, so + // F2 and F6 draw it as a set with nothing of theirs in it — the one state a flattened pane could + // not show at all before, and the state a set is in the moment it is created. It is also left + // unassigned, so the F5 checklist shows both states of the checkbox on one character. + config.TriggerSets.Add(new TriggerSet + { + Name = "Combat", + Description = "hp + damage tracking", + Aliases = { new Alias { Name = "hp", Pattern = @"^hp$", Substitution = "score\nconsider" } }, + Macros = { new Macro { Name = "flee", Key = "Ctrl+F2", Command = "flee" } }, + }); } /// diff --git a/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs b/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs index 3a887e1f..0d618b38 100644 --- a/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs @@ -26,8 +26,25 @@ internal static class KeypadScreenRenderer private const int KeyColumnWidth = 12; private const int ColumnWidth = 48; + /// + /// How wide a cursor bar runs across the binding list. It is wider than + /// (which sizes the numpad column the merged pads to) because a + /// binding row now carries four wells rather than three: tick, key, name, owning set, then the + /// command. A bar narrower than its own row would leave the row's tail outside the highlight. + /// + private const int HotkeysColumnWidth = 64; + /// Visible width the binding list's name column is padded to, so the arrows line up. - private const int NameColumnWidth = 14; + private const int NameColumnWidth = 12; + + /// + /// Visible width of the owning-set cell, which is truncated to it rather than merely padded + /// — the one column on this row whose content the screen does not otherwise bound. The row already + /// runs to four wells and a command, and its widest state is the armed key capture, whose prompt is + /// more than twice the width of the key it replaces; a set called something discursive must not be + /// what pushes that state off the end of the pane. The whole name is on F5, where it is set. + /// + private const int SetColumnWidth = 8; /// /// The binding row's field ordinals, in the order ⇥ steps through them. The name leads, as it does @@ -46,6 +63,14 @@ internal static class KeypadScreenRenderer /// internal const int KeyField = 2; + /// + /// Which the binding lives in, appended last for the same reason the key + /// was. It only exists when the screen was handed the sets — without them there is no vocabulary to + /// move between and no list to move out of, which is the same condition that withholds the buttons. + /// Committing it moves the binding: see . + /// + internal const int SetField = 3; + /// The label the binding list's add button carries; it names the key it will claim. internal const string AddBindingLabel = "+ binding"; @@ -132,15 +157,34 @@ internal static ScreenModel Model( { ArgumentNullException.ThrowIfNull(macros); - return new ScreenModel(ScreenModel.Rows(macros, macro => ScreenRow.Of( - ScreenToggle.Bind(() => macro.Enabled, v => macro.Enabled = v), - ScreenField.Name("name", () => macro.Name, v => macro.Name = v), - ScreenField.Text("command", () => macro.Command, v => macro.Command = v), - ScreenField.Key("key", () => macro.Key, v => macro.Key = v, key => AlreadyBound(macros, macro, key)))) + return new ScreenModel(ScreenModel.Rows(macros, macro => BindingRow(macro, macros, sets)) .Concat(Buttons(sets, selected)) .ToArray()); } + /// + /// One binding's navigable row: Space enables it, and ⏎/⇥ walk its name, command, key and — when + /// the screen knows which sets the bindings came from — the set that owns it. + /// + private static ScreenRow BindingRow( + Macro macro, IReadOnlyList macros, IReadOnlyList? sets) + { + var fields = new List + { + ScreenField.Name("name", () => macro.Name, v => macro.Name = v), + ScreenField.Text("command", () => macro.Command, v => macro.Command = v), + ScreenField.Key("key", () => macro.Key, v => macro.Key = v, key => AlreadyBound(macros, macro, key)), + }; + + if (sets is not null) + { + fields.Add(ScreenLists.Owner(sets, s => s.Macros, macro)); + } + + return ScreenRow.Of( + ScreenToggle.Bind(() => macro.Enabled, v => macro.Enabled = v), fields.ToArray()); + } + /// /// Whether another binding already holds a key, and which — the refusal a key capture needs. A /// resolves one macro per key, so the second binding on a key never runs: @@ -335,16 +379,30 @@ internal static List HotkeysColumn( lines.Add(ScreenChrome.Cursor( Hotkey( macros[i], + sets is null ? null : ScreenLists.OwnerOf(sets, s => s.Macros, macros[i])?.Name, cursor.EditOn(0, i, NameField), cursor.EditOn(0, i, CommandField), - cursor.EditOn(0, i, KeyField)), + cursor.EditOn(0, i, KeyField), + cursor.EditOn(0, i, SetField)), cursor.IsOn(0, i), - ColumnWidth)); + HotkeysColumnWidth)); + } + + // A set holding no bindings owns none of the rows above and would otherwise be drawn nowhere at + // all — which, once sets can be created, is the first thing anyone would look for. It is markup + // and not a row: it stands for a set, not for a binding, so the cursor cannot reach it. + foreach (var set in sets ?? Array.Empty()) + { + if (set.Macros.Count == 0) + { + lines.Add(ScreenChrome.EmptySet(set.Name, "bindings")); + } } lines.Add(string.Empty); - lines.AddRange(ScreenChrome.Buttons(Buttons(sets, selected), cursor, 0, macros.Count, ColumnWidth)); - return ScreenChrome.Choices(lines, cursor.Edit, ColumnWidth); + lines.AddRange(ScreenChrome.Buttons( + Buttons(sets, selected), cursor, 0, macros.Count, HotkeysColumnWidth)); + return ScreenChrome.Choices(lines, cursor.Edit, HotkeysColumnWidth); } private static string NumpadRow(int[] digits, IReadOnlyList macros) @@ -391,7 +449,13 @@ private static string NumpadCell(int digit, IReadOnlyList macros) /// answer to "does this do anything" is no. /// /// - private static string Hotkey(Macro macro, ScreenFieldEdit? name, ScreenFieldEdit? command, ScreenFieldEdit? key) + private static string Hotkey( + Macro macro, + string? setName, + ScreenFieldEdit? name, + ScreenFieldEdit? command, + ScreenFieldEdit? key, + ScreenFieldEdit? set) { var verdict = MacroKeys.Verdict(macro.Key); var tick = macro.Enabled ? $"[{Accent}]✓[/]" : "[dim]·[/]"; @@ -405,7 +469,16 @@ private static string Hotkey(Macro macro, ScreenFieldEdit? name, ScreenFieldEdit // reads as an empty field rather than as a slab of background. var label = string.IsNullOrWhiteSpace(macro.Name) ? "[dim]—[/]" : $"[{Value}]{Escape(macro.Name)}[/]"; var named = ScreenChrome.Field(PadVisible(label, NameColumnWidth), name); - return $"{tick} {bound} {named} → {ScreenChrome.Field(Escape(macro.Command), command)}"; + + // The owning set, welled like everything else on this row: F4 has no editor pane, so a value + // that can be changed has to be drawn where it is changed. It sits before the arrow so the + // command — the one value with no width worth guessing — stays last. + var owner = setName is null + ? string.Empty + : ScreenChrome.Field( + PadVisible($"[{Value}]{Escape(Truncate(setName, SetColumnWidth))}[/]", SetColumnWidth), set) + " "; + + return $"{tick} {bound} {named} {owner}→ {ScreenChrome.Field(Escape(macro.Command), command)}"; } /// diff --git a/src/SharpMUTerm.Tui/KeypadScreenView.cs b/src/SharpMUTerm.Tui/KeypadScreenView.cs index 76f46bec..bd4317af 100644 --- a/src/SharpMUTerm.Tui/KeypadScreenView.cs +++ b/src/SharpMUTerm.Tui/KeypadScreenView.cs @@ -17,7 +17,13 @@ namespace SharpMUTerm.Tui; /// internal static class KeypadScreenView { - private const int NumpadColumnWidth = 50; + /// + /// The numpad column's width — its 3×3 grid measures exactly this (three cells of "[[N]] " plus a + /// command, two gaps between them), so anything wider is slack taken from the binding list beside + /// it. That list is the one that needs it: a binding row carries four wells and a command, and its + /// widest state is an armed key capture whose prompt is twice the width of the key it replaces. + /// + private const int NumpadColumnWidth = 48; public static IWindowControl Build( IReadOnlyList macros, diff --git a/src/SharpMUTerm.Tui/ScreenChrome.cs b/src/SharpMUTerm.Tui/ScreenChrome.cs index cbe2dda9..218ceb83 100644 --- a/src/SharpMUTerm.Tui/ScreenChrome.cs +++ b/src/SharpMUTerm.Tui/ScreenChrome.cs @@ -406,6 +406,24 @@ private static string Shadow(int inner) => /// internal static string ReadOnly(string text) => $"[{ScreenPalette.Muted}]{MarkupText.Escape(text)}[/]"; + /// + /// The one row an empty trigger set gets in a flattened pane. F2, F3, F4 and F6 each draw + /// one column of every set's rules, so a set holding none of that kind is drawn nowhere at all — and + /// once sets can be created, the very first thing you would look for after making one is the thing + /// the screen cannot show you. This says it is there and has nothing in it. + /// + /// It is a readout and not a row: the cursor cannot reach it, because it stands for a set rather + /// than for an item, and giving it a cursor stop would put a row in the pane that [[- del]], + /// Space and ⏎ would all have to make an exception for. Moving an item into the set — the + /// set field on any row () — is what replaces it with real + /// rows. + /// + /// + /// The set with nothing in it. + /// What the screen's rows are called, plural — triggers, timers. + internal static string EmptySet(string set, string noun) => + $" [{ScreenPalette.Muted}]▪ {MarkupText.Escape(set)} — no {MarkupText.Escape(noun)}[/]"; + /// /// Draws a pane's button rows, appended after its list. The rows come *from* the pane's own /// s rather than being written out again per screen, so the label the diff --git a/src/SharpMUTerm.Tui/ScreenField.cs b/src/SharpMUTerm.Tui/ScreenField.cs index a9f751c6..842dcfa7 100644 --- a/src/SharpMUTerm.Tui/ScreenField.cs +++ b/src/SharpMUTerm.Tui/ScreenField.cs @@ -90,6 +90,19 @@ internal readonly record struct ScreenFieldEdit( /// one field on these screens whose vocabulary is the keyboard itself, so a text buffer could only ever /// be a place to mis-spell a key name. /// +/// +/// Where the row this field belongs to has ended up, asked after a commit, or null for the +/// fields that leave their row where it was — which is nearly all of them. It exists for +/// : writing that field moves the item into another +/// 's list, and the panes those four screens +/// draw are flattened across every set, so the row genuinely changes position under the cursor. Without +/// it the cursor would be left pointing at whatever slid into the vacated row — and the next ⇥ would +/// edit that instead, which is the one thing a move must not do. +/// +/// It is the field-side counterpart of , and for the same reason: only +/// the thing that performed the change knows where the row went. +/// +/// internal readonly record struct ScreenField( string Label, Func Get, @@ -98,7 +111,8 @@ internal readonly record struct ScreenField( Func Snapshot, IReadOnlyList? Choices = null, bool ClosedChoices = false, - bool Capture = false) + bool Capture = false, + Func? Follow = null) { /// Longest rejection message kept; regex parser errors run to several lines otherwise. private const int MaxErrorLength = 44; @@ -237,6 +251,38 @@ internal static ScreenField Name(string label, Func get, Action Restore(get, set)); } + /// + /// A name that is also a key: everything refuses, plus any name already + /// taken by one of its siblings. A 's name is + /// the only one of these on the settings screens, and it is the exception that proves + /// 's rule — two rules called Tell are merely confusing, but two sets called + /// Comms are broken: a character opts into automation by name + /// ( is a list of + /// strings), and + /// takes the first match — so the second set of a colliding pair can never be assigned to anything. + /// + /// Comparison is case-insensitive, matching the resolver: comms and Comms are one name + /// as far as an assignment is concerned, so they must be one name here too. + /// + /// + /// The names of the item's siblings — its own current name excluded. + internal static ScreenField UniqueName( + string label, Func get, Action set, IReadOnlyList taken) + { + ArgumentNullException.ThrowIfNull(get); + ArgumentNullException.ThrowIfNull(set); + ArgumentNullException.ThrowIfNull(taken); + + var named = Name(label, get, set); + return named with + { + Validate = value => named.Validate(value) + ?? (taken.Contains(value.Trim(), StringComparer.OrdinalIgnoreCase) + ? $"another {label} is already called that" + : null), + }; + } + /// /// Free text that may be blank, held as null when it is — the "unset, use the default" fields /// (a log directory, an on-connect command). diff --git a/src/SharpMUTerm.Tui/ScreenLists.cs b/src/SharpMUTerm.Tui/ScreenLists.cs index 4e7346bc..0e84c257 100644 --- a/src/SharpMUTerm.Tui/ScreenLists.cs +++ b/src/SharpMUTerm.Tui/ScreenLists.cs @@ -77,17 +77,195 @@ internal static (List Items, int Offset)? Target( /// as a second identical row is the one case where the user cannot tell which one they just made. /// /// - internal static string Unique(IEnumerable taken, string name) + internal static string Unique(IEnumerable taken, string name) => Available(taken, name + " copy"); + + /// + /// itself when nothing in holds it, and otherwise + /// the same name with the first free number after it — New Set, then New Set 2. + /// Case-insensitive, because two names differing only in case read as one name in a list (and, for a + /// trigger set, are one name to the resolver). + /// + internal static string Available(IEnumerable taken, string name) { ArgumentNullException.ThrowIfNull(taken); var used = new HashSet(taken, StringComparer.OrdinalIgnoreCase); - var candidate = name + " copy"; + var candidate = name; for (var n = 2; used.Contains(candidate); n++) { - candidate = $"{name} copy {n.ToString(CultureInfo.InvariantCulture)}"; + candidate = $"{name} {n.ToString(CultureInfo.InvariantCulture)}"; } return candidate; } + + /// What the owning-set field is labelled on all four flattened screens. + internal const string OwnerLabel = "set"; + + /// + /// Which set owns an item, as an editable value — the field that makes a rule, an alias, a timer or + /// a binding movable between sets, which nothing on these screens could do. + /// + /// It is a closed list over the configured set names, deliberately: unlike a spawn window (which + /// comes into existence by being routed to), a set is a real object with rules, timers and character + /// assignments hanging off it, so a name typed here could only ever be a set that does not exist. + /// Sets are made and unmade on F5, where they are listed as things in their own right — including + /// the empty ones, which a flattened pane cannot show. + /// + /// + /// Writing it moves the item: out of its current set's list, onto the end of the target's. The + /// snapshot therefore captures the list and the index, so Esc puts the item back exactly + /// where it came from rather than on the end of it — the same rule a deletion's undo follows, for + /// the same reason (the pane's order is what the screen navigates by). And because the pane is + /// flattened across every set, the row moves too, so the field carries a + /// that takes the cursor with it. + /// + /// + internal static ScreenField Owner(IReadOnlyList sets, Func> items, T item) + where T : class + { + ArgumentNullException.ThrowIfNull(sets); + ArgumentNullException.ThrowIfNull(items); + ArgumentNullException.ThrowIfNull(item); + + var names = sets.Select(s => s.Name).ToArray(); + + return new ScreenField( + OwnerLabel, + () => OwnerOf(sets, items, item)?.Name ?? string.Empty, + value => Named(sets, value) is null + ? $"{OwnerLabel} must be one of: {string.Join(", ", names)}" + : null, + value => Move(sets, items, item, value), + () => Replace(sets, items, item), + names, + ClosedChoices: true, + Follow: () => Flattened(sets, items, item)); + } + + /// The set whose list holds an item, or null when none of them does. + internal static TriggerSet? OwnerOf( + IReadOnlyList sets, Func> items, T item) + where T : class + { + ArgumentNullException.ThrowIfNull(sets); + ArgumentNullException.ThrowIfNull(items); + + foreach (var set in sets) + { + if (IndexOf(items(set), item) >= 0) + { + return set; + } + } + + return null; + } + + /// The set called , matched as the resolver matches, or null. + private static TriggerSet? Named(IReadOnlyList sets, string name) + { + var trimmed = name.Trim(); + foreach (var set in sets) + { + if (string.Equals(set.Name, trimmed, StringComparison.OrdinalIgnoreCase)) + { + return set; + } + } + + return null; + } + + /// + /// Moves an item into the named set's list. Moving it into the set it is already in is a no-op + /// rather than a remove-and-append: the item would otherwise silently jump to the bottom of its own + /// set every time the field was committed on the value it opened with. + /// + private static void Move( + IReadOnlyList sets, Func> items, T item, string name) + where T : class + { + if (Named(sets, name) is not { } target || OwnerOf(sets, items, item) is not { } owner) + { + return; + } + + if (ReferenceEquals(owner, target)) + { + return; + } + + var from = items(owner); + from.RemoveAt(IndexOf(from, item)); + items(target).Add(item); + } + + /// Captures where an item currently sits, and returns the action that puts it back there. + private static Action Replace( + IReadOnlyList sets, Func> items, T item) + where T : class + { + if (OwnerOf(sets, items, item) is not { } owner) + { + return () => { }; + } + + var list = items(owner); + var index = IndexOf(list, item); + + return () => + { + if (OwnerOf(sets, items, item) is { } current) + { + var held = items(current); + held.RemoveAt(IndexOf(held, item)); + } + + list.Insert(Math.Clamp(index, 0, list.Count), item); + }; + } + + /// + /// The row an item occupies in the flattened pane: every earlier set's items, then its own position. + /// -1 when no set holds it. + /// + internal static int Flattened(IReadOnlyList sets, Func> items, T item) + where T : class + { + ArgumentNullException.ThrowIfNull(sets); + ArgumentNullException.ThrowIfNull(items); + + var offset = 0; + foreach (var set in sets) + { + var list = items(set); + var index = IndexOf(list, item); + if (index >= 0) + { + return offset + index; + } + + offset += list.Count; + } + + return -1; + } + + /// + /// Where an item sits in a list, by identity. would go through + /// the type's equality, and two rules that happen to hold the same values are still two rules. + /// + private static int IndexOf(List list, T item) where T : class + { + for (var i = 0; i < list.Count; i++) + { + if (ReferenceEquals(list[i], item)) + { + return i; + } + } + + return -1; + } } diff --git a/src/SharpMUTerm.Tui/SettingsSession.cs b/src/SharpMUTerm.Tui/SettingsSession.cs index c3f74c2c..0b829571 100644 --- a/src/SharpMUTerm.Tui/SettingsSession.cs +++ b/src/SharpMUTerm.Tui/SettingsSession.cs @@ -361,6 +361,12 @@ private ScreenAction HandleCapture(ConsoleKeyInfo key, ScreenField field) /// Validates the buffer and, if it holds, writes it through the undo log and closes the edit. A /// rejected buffer stays open and carries the reason, so the field is marked rather than the /// keystroke that produced it being thrown away mid-word. + /// + /// A field that moved its own row answers where it went () and the + /// cursor goes with it. Only the owning-set field on the four flattened screens does this, and it + /// has to: those panes are one column of every set's items, so committing a move genuinely slides + /// the row out from under the cursor. + /// /// private bool Commit(ScreenField field) { @@ -371,11 +377,22 @@ private bool Commit(ScreenField field) return false; } + if (field.Follow is { } follow) + { + Selection.Seed(edit.Pane, follow()); + } + _edit = null; return true; } - /// ⇥ inside an edit: commit this field, then open the row's next one, wrapping. + /// + /// ⇥ inside an edit: commit this field, then open the row's next one, wrapping. The model is + /// re-projected after the commit rather than reused, because the commit is allowed to have changed + /// the pane — a committed set field moves its row somewhere else in the flattened list, and + /// stepping through the stale projection would open the next field of whichever row used to be + /// there. + /// private ScreenAction Step(ScreenModel model, ScreenField field, int direction) { var edit = _edit!; @@ -391,7 +408,7 @@ private ScreenAction Step(ScreenModel model, ScreenField field, int direction) return ScreenAction.Redraw; } - Open(model, ((from + direction) % count + count) % count); + Open(_model(Selection), ((from + direction) % count + count) % count); return ScreenAction.Redraw; } diff --git a/src/SharpMUTerm.Tui/SharpMUTermApp.cs b/src/SharpMUTerm.Tui/SharpMUTermApp.cs index 7b068cd4..83b0052f 100644 --- a/src/SharpMUTerm.Tui/SharpMUTermApp.cs +++ b/src/SharpMUTerm.Tui/SharpMUTermApp.cs @@ -924,7 +924,7 @@ private void RefreshStatusBar() /// private IReadOnlyList SettingsScreens() => new SettingsScreen[] { - new(ConsoleKey.F2, new[] { "triggers", "route", "highlight" }, TriggersScreen), + new(ConsoleKey.F2, new[] { "triggers", "route", "highlight", "set" }, TriggersScreen), new(ConsoleKey.F3, new[] { "aliases" }, AliasesScreen), new(ConsoleKey.F4, new[] { "keypad" }, KeypadScreen), new(ConsoleKey.F5, new[] { "worlds", "settings" }, WorldsScreen), @@ -1116,7 +1116,8 @@ private ScreenBinding WorldsScreen(string fkey, bool onCharacters) _config.Worlds, _config.TriggerSets, selection.SelectionIn(WorldsScreenRenderer.WorldsPane), - selection.SelectionIn(WorldsScreenRenderer.CharactersPane))); + selection.SelectionIn(WorldsScreenRenderer.CharactersPane), + selection.SelectionIn(WorldsScreenRenderer.TriggerSetsPane))); session.Selection.Seed(WorldsScreenRenderer.WorldsPane, ActiveWorldIndex()); session.Selection.Seed(WorldsScreenRenderer.CharactersPane, ActiveCharacterIndex()); if (onCharacters) @@ -1131,7 +1132,8 @@ private ScreenBinding WorldsScreen(string fkey, bool onCharacters) session.Selection.SelectionIn(WorldsScreenRenderer.CharactersPane), _system.DesktopDimensions.Width, session.Focus(), - fkey)); + fkey, + session.Selection.SelectionIn(WorldsScreenRenderer.TriggerSetsPane))); } /// @@ -1270,6 +1272,19 @@ private static IEnumerable EditSnapshotKeys(string view) yield break; } + if (string.Equals(view, "set", StringComparison.OrdinalIgnoreCase)) + { + // Straight to the rule's last field, the set that owns it — the one edit on these screens + // that moves the row it is made on. A still frame is the only way to see the closed list of + // sets over a pane whose rows are flattened across all of them. + for (var i = 0; i < TriggersScreenRenderer.SetField; i++) + { + yield return Stroke('\t', ConsoleKey.Tab); + } + + yield break; + } + if (string.Equals(view, "triggers", StringComparison.OrdinalIgnoreCase) || string.Equals(view, "route", StringComparison.OrdinalIgnoreCase)) { diff --git a/src/SharpMUTerm.Tui/TimersScreenRenderer.cs b/src/SharpMUTerm.Tui/TimersScreenRenderer.cs index 05eb6f46..2d8d23da 100644 --- a/src/SharpMUTerm.Tui/TimersScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/TimersScreenRenderer.cs @@ -36,6 +36,12 @@ internal static class TimersScreenRenderer internal const int CommandField = 2; + /// + /// Which the timer lives in, appended last so the ordinals above keep + /// meaning what they meant. Committing it moves the timer — see . + /// + internal const int SetField = 3; + /// The labels the timer list's buttons carry, in the order they are drawn. internal const string AddTimerLabel = "+ timer"; @@ -115,7 +121,8 @@ internal static ScreenModel Model(IReadOnlyList sets, int selected) v => entry.Timer.IntervalSeconds = v, MinIntervalSeconds, MaxIntervalSeconds), - ScreenField.Text("command", () => entry.Timer.Command, v => entry.Timer.Command = v))) + ScreenField.Text("command", () => entry.Timer.Command, v => entry.Timer.Command = v), + ScreenLists.Owner(sets, s => s.Timers, entry.Timer))) .Concat(Buttons(sets, selected)) .ToArray(); @@ -215,10 +222,24 @@ internal static List ListColumn( lines.Add("[dim]no timers[/]"); } - for (var i = 0; i < entries.Count; i++) + // Walked per set rather than down the flattened list, so a set holding no timers can still say + // so — it owns none of these rows and would otherwise be drawn nowhere at all. The row indices + // are the flattened ones either way: the placeholder is markup, not a cursor stop. + var index = 0; + foreach (var set in sets) { - var row = Row(entries[i].Timer, entries[i].SetName, i == selected); - lines.Add(ScreenChrome.Cursor(row, cursor.IsOn(0, i), ColumnWidth)); + if (set.Timers.Count == 0) + { + lines.Add(ScreenChrome.EmptySet(set.Name, "timers")); + continue; + } + + foreach (var timer in set.Timers) + { + lines.Add(ScreenChrome.Cursor( + Row(timer, set.Name, index == selected), cursor.IsOn(0, index), ColumnWidth)); + index++; + } } lines.Add(string.Empty); @@ -238,7 +259,10 @@ internal static List EditorColumn( var cursor = focus ?? ScreenFocus.None; var entries = Flatten(sets); return selected >= 0 && selected < entries.Count - ? ScreenChrome.Choices(BuildEditor(entries[selected].Timer, cursor, selected), cursor.Edit, ColumnWidth) + ? ScreenChrome.Choices( + BuildEditor(entries[selected].Timer, entries[selected].SetName, cursor, selected), + cursor.Edit, + ColumnWidth) : new List(); } @@ -269,13 +293,19 @@ private static string Row(TimerDefinition timer, string setName, bool selected) /// /// The editor rows for one timer. The name leads because it leads the row's fields: ⏎ on a timer - /// opens it here, which is also where one created by [[+ timer]] lands ready to be named. + /// opens it here, which is also where one created by [[+ timer]] lands ready to be named. The + /// set follows it, because the list is flattened across every set and the two together are what + /// identify the timer; committing it moves the timer (). /// - private static List BuildEditor(TimerDefinition timer, ScreenFocus cursor, int selected) => new() + private static List BuildEditor( + TimerDefinition timer, string setName, ScreenFocus cursor, int selected) => new() { "[dim]name[/]", $" {ScreenChrome.Field(Escape(timer.Name), cursor.EditOn(0, selected, NameField))}", string.Empty, + "[dim]set[/]", + $" {ScreenChrome.Field($"[{Value}]{Escape(setName)}[/]", cursor.EditOn(0, selected, SetField))}", + string.Empty, "[dim]interval (seconds)[/]", $" {ScreenChrome.Field(Seconds(timer), cursor.EditOn(0, selected, IntervalField))}", string.Empty, diff --git a/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs b/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs index f69c2233..b7cdfe3d 100644 --- a/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs @@ -56,6 +56,13 @@ internal static class TriggersScreenRenderer internal const int ScriptField = 8; + /// + /// Which the rule lives in — appended last, like every field added to these + /// rows since, so the ordinals above keep addressing what they always did. It is what makes a rule + /// created in the wrong set fixable: see . + /// + internal const int SetField = 9; + /// /// How wide the fg / bg / attrs and rewrite / respond / /// script labels are padded, so the field wells in each section start in the same column. @@ -287,7 +294,8 @@ internal static ScreenModel Model( "script", () => entry.Trigger.Actions.ScriptCallback, v => entry.Trigger.Actions.ScriptCallback = v, - Callbacks(entry.Trigger, callbacks)))) + Callbacks(entry.Trigger, callbacks)), + ScreenLists.Owner(sets, s => s.Triggers, entry.Trigger))) .Concat(Buttons(sets, selectedTrigger)) .ToArray(); @@ -392,11 +400,25 @@ internal static List RulesColumn( left.Add("[dim]no triggers[/]"); } - for (var i = 0; i < flattened.Count; i++) + // Walked per set rather than down the flattened list, so a set holding no rules can still say so + // — it owns none of these rows and would otherwise be drawn nowhere at all. The row indices are + // the flattened ones either way: the placeholder is markup, not a cursor stop. + var row = 0; + foreach (var set in sets) { - var (trigger, setName) = flattened[i]; - left.Add(ScreenChrome.Cursor(RuleRow(i, selectedTrigger, trigger), cursor.IsOn(0, i), ColumnWidth)); - left.Add(RuleSub(setName, trigger.Actions)); + if (set.Triggers.Count == 0) + { + left.Add(ScreenChrome.EmptySet(set.Name, "triggers")); + continue; + } + + foreach (var trigger in set.Triggers) + { + left.Add(ScreenChrome.Cursor( + RuleRow(row, selectedTrigger, trigger), cursor.IsOn(0, row), ColumnWidth)); + left.Add(RuleSub(set.Name, trigger.Actions)); + row++; + } } left.Add(string.Empty); @@ -421,7 +443,12 @@ internal static List EditorColumn( var cursor = focus ?? ScreenFocus.None; var flattened = Flatten(sets); return selectedTrigger >= 0 && selectedTrigger < flattened.Count - ? BuildEditor(flattened[selectedTrigger].Trigger, spawnTargets, cursor, selectedTrigger) + ? BuildEditor( + flattened[selectedTrigger].Trigger, + flattened[selectedTrigger].SetName, + spawnTargets, + cursor, + selectedTrigger) : new List(); } @@ -493,9 +520,10 @@ private static string Flags(TriggerActions actions) } private static List BuildEditor( - Trigger trigger, IReadOnlyList spawnTargets, ScreenFocus cursor, int index) + Trigger trigger, string setName, IReadOnlyList spawnTargets, ScreenFocus cursor, int index) { var name = cursor.EditOn(0, index, NameField); + var set = cursor.EditOn(0, index, SetField); var pattern = cursor.EditOn(0, index, PatternField); var route = cursor.EditOn(0, index, RouteField); var foreground = cursor.EditOn(0, index, ForegroundField); @@ -516,6 +544,14 @@ private static List BuildEditor( "[dim]name[/]", $" {ScreenChrome.Field(Escape(trigger.Name), name)}", string.Empty, + + // Which set owns the rule, drawn immediately under the name because the two together are + // what identify it: the list is flattened across every set, so "the rule called page" is + // only half an answer. Committing it *moves* the rule (ScreenLists.Owner) and takes the + // cursor with it, which is the only way a rule created in the wrong set can be put right. + "[dim]set[/]", + $" {ScreenChrome.Field($"[{Value}]{Escape(setName)}[/]", set)}", + string.Empty, "[dim]match pattern (regex)[/]", $" {ScreenChrome.Field(Escape(trigger.Pattern), pattern)}", string.Empty, diff --git a/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs b/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs index e60287bb..5b3a5ffd 100644 --- a/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs @@ -73,6 +73,15 @@ internal static class WorldsScreenRenderer internal const int LogDirectoryField = 3; + /// + /// The trigger-set row's field ordinals. A set's name leads, as every list row's does — and here it + /// is more than a label: a character opts into automation by name, so renaming a set is a + /// change with consequences elsewhere in the configuration (see ). + /// + internal const int SetNameField = 0; + + internal const int SetDescriptionField = 1; + /// The F-key that opens this screen, and the second key that opens it on a character's log. internal const string FKey = "F5"; @@ -123,14 +132,15 @@ public static List Render( int selectedWorld, int selectedCharacter, int width = 0, - int height = 0) + int height = 0, + int selectedSet = 0) { ArgumentNullException.ThrowIfNull(worlds); ArgumentNullException.ThrowIfNull(triggerSets); (selectedWorld, selectedCharacter) = Resolve(worlds, selectedWorld, selectedCharacter); var accent = AccentFor(worlds, selectedWorld); - var model = Model(worlds, triggerSets, selectedWorld, selectedCharacter); + var model = Model(worlds, triggerSets, selectedWorld, selectedCharacter, selectedSet); var lines = new List { Band(HeaderLine(width, model), HeaderBg, width) }; lines.AddRange(MergeColumns(WorldsColumn(worlds, selectedWorld), DetailColumn(worlds, triggerSets, selectedWorld, selectedCharacter, accent), LeftColumnWidth)); @@ -141,7 +151,8 @@ public static List Render( lines.Add(string.Empty); lines.Add(Band($"[{Rule}]{new string('─', width > 4 ? width - 2 : 60)}[/]", EditBg, width)); foreach (var row in MergeColumns(FormColumn(character, accent, null, selectedCharacter), - TriggersColumn(character, triggerSets, accent), CharDetailColumnWidth)) + TriggersColumn(character, triggerSets, accent, null, selectedSet, worlds), + CharDetailColumnWidth)) { lines.Add(Band(" " + row, EditBg, width)); } @@ -203,13 +214,32 @@ internal static string HeaderLine( internal const string RemoveCharacterLabel = "- remove"; + /// The labels the trigger-set list's buttons carry, in the order they are drawn. + internal const string AddSetLabel = "+ set"; + + internal const string RemoveSetLabel = "- del"; + + /// What a brand-new trigger set is called before it is renamed. + internal const string NewSetName = "New Set"; + + /// What an unset description reads as, so the row is visibly a place one goes. + internal const string NoDescription = "—"; + /// /// The screen's four navigable panes, in ⇥ order: the WORLDS list (no checkbox on a world's row, /// but ⏎ opens the world's own fields — the ones the detail column lists), the selected world's /// characters (Space flips auto-login, ⏎ edits the character's name, on-connect line and log), the - /// selected character's assigned trigger sets (Space assigns/unassigns), and the selected world's - /// two security checkboxes. All but the first collapse to empty when there is nothing selected above - /// them, and ⇥ skips empty panes, so the cursor never lands somewhere with no rows. + /// trigger sets (Space assigns the selected character to one, ⏎ renames it, and the pane's + /// own buttons make and unmake them), and the selected world's two security checkboxes. All but the + /// first collapse to empty when there is nothing selected above them, and ⇥ skips empty panes, so + /// the cursor never lands somewhere with no rows. + /// + /// The trigger-set pane is where sets are managed, not merely assigned — it is the only + /// view in the app of sets as objects, because F2, F3, F4 and F6 each flatten one kind of a + /// set's contents across all of them and so cannot show a set that holds none of that kind. It still + /// needs a selected character, because the other half of every row is that character's opt-in; on a + /// configuration with no characters yet there is also nothing a set could apply to. + /// /// /// A world's *typed* values hang off its list row rather than becoming a pane of their own: the /// detail column is a projection of whatever the WORLDS list has selected, so those values already @@ -233,11 +263,17 @@ internal static string HeaderLine( /// lands on a row that silently does nothing. /// /// + /// + /// Which trigger set the third pane has selected — what [[- del]] would remove. It defaults to + /// the first, the way every other pane's cursor starts on its first row, so a caller that only wants + /// the navigable shape still gets the pane's real buttons. + /// internal static ScreenModel Model( IReadOnlyList worlds, IReadOnlyList triggerSets, int selectedWorld, - int selectedCharacter) + int selectedCharacter, + int selectedSet = 0) { ArgumentNullException.ThrowIfNull(worlds); ArgumentNullException.ThrowIfNull(triggerSets); @@ -273,35 +309,135 @@ internal static ScreenModel Model( } var character = worlds[selectedWorld].Characters[selectedCharacter]; - var setRows = new ScreenRow[triggerSets.Count]; - for (var i = 0; i < triggerSets.Count; i++) + var setRows = ScreenModel.Rows(triggerSets, set => ScreenRow.Of( + Assignment(character, set.Name), + ScreenField.UniqueName( + "set name", + () => set.Name, + value => RenameSet(worlds, set, value), + triggerSets.Where(s => !ReferenceEquals(s, set)).Select(s => s.Name).ToArray()), + ScreenField.Optional("description", () => set.Description, v => set.Description = v))) + .Concat(SetButtons(worlds, triggerSets, selectedSet)) + .ToArray(); + + return new ScreenModel(worldRows, characterRows, setRows, securityRows); + } + + /// + /// A character's opt-in to one set. Assignment is list membership, and the character's own order + /// decides which set wins a conflict (see + /// ) — so the snapshot restores the whole list + /// rather than re-adding the name at the end, which would silently reorder priority. + /// + private static ScreenToggle Assignment(CharacterDefinition character, string name) => new( + () => character.TriggerSets.Contains(name), + () => { - var name = triggerSets[i].Name; + if (!character.TriggerSets.Remove(name)) + { + character.TriggerSets.Add(name); + } + }, + () => + { + var previous = character.TriggerSets.ToList(); + return () => + { + character.TriggerSets.Clear(); + character.TriggerSets.AddRange(previous); + }; + }); - // Assignment is list membership, and the character's own order decides which set wins a - // conflict (see AppConfiguration.ResolveTriggerSets) — so the snapshot restores the whole - // list rather than re-adding the name at the end, which would silently reorder priority. - setRows[i] = ScreenRow.Of(new ScreenToggle( - () => character.TriggerSets.Contains(name), - () => - { - if (!character.TriggerSets.Remove(name)) - { - character.TriggerSets.Add(name); - } - }, - () => - { - var previous = character.TriggerSets.ToList(); - return () => - { - character.TriggerSets.Clear(); - character.TriggerSets.AddRange(previous); - }; - })); + /// + /// Renames a set and every reference to it. This is the one rename on these screens that + /// reaches outside the object it is on: a character selects automation by name, so a set renamed on + /// its own would leave every character that used it pointing at a set that no longer exists — the + /// automation would simply stop, silently, at the next connect. Each reference keeps its position in + /// the character's list, because that order is what decides which set wins a conflict. + /// + /// The references are found by the old name before anything is written, and undo comes for + /// free: 's snapshot replays this same setter with the old name, which + /// walks the references back the way it walked them here. + /// + /// + private static void RenameSet(IReadOnlyList worlds, TriggerSet set, string name) + { + var renamed = name.Trim(); + TriggerSetReferences.Rename(TriggerSetReferences.Find(worlds, set.Name), renamed); + set.Name = renamed; + } + + /// + /// The trigger-set list's buttons — the only place in the app that makes or unmakes a set. They live + /// here because this pane is the only one that shows sets as things in their own right rather than + /// as a column of somebody's rules: F2, F3, F4 and F6 each flatten one kind of the set's + /// contents across every set, so a set holding none of that kind is invisible on all four, and a set + /// you have just made holds nothing at all. + /// + /// A new set is empty and named apart from its neighbours, because its name is a key rather than a + /// label () and two called New Set could not both be + /// assigned. + /// + /// + private static List SetButtons( + IReadOnlyList worlds, IReadOnlyList triggerSets, int selectedSet) + { + var rows = new List(); + + // Arrays report IsReadOnly through IList, and a renderer handed one (the unit tests, any + // caller with a fixed projection) must not offer a button whose only effect would be to throw. + if (triggerSets is not IList { IsReadOnly: false } list) + { + return rows; } - return new ScreenModel(worldRows, characterRows, setRows, securityRows); + rows.Add(ScreenRow.Of(ScreenButton.Add( + AddSetLabel, + list, + () => new TriggerSet { Name = ScreenLists.Available(list.Select(s => s.Name), NewSetName) }))); + + if (selectedSet >= 0 && selectedSet < list.Count) + { + rows.Add(ScreenRow.Of(RemoveSet(worlds, list, selectedSet))); + } + + return rows; + } + + /// + /// Deleting a set, which is the destructive edit on these screens with the longest reach: the set + /// goes, and so does every character's opt-in to it — a character left holding the name of a set + /// that no longer exists would show an assignment that resolves to nothing. + /// + /// It is a hand-built button rather than because its undo is + /// two restorations, not one: the set back at its index, and each stripped reference back at + /// its index inside the character that held it. Restoring the set alone would be the + /// quieter half of a change nobody agreed to. + /// + /// + private static ScreenButton RemoveSet( + IReadOnlyList worlds, IList sets, int index) + { + var set = sets[index]; + return new ScreenButton( + RemoveSetLabel, + () => + { + var name = set.Name; + var references = TriggerSetReferences.Find(worlds, name); + sets.RemoveAt(index); + TriggerSetReferences.Detach(references); + + return new ScreenPress( + () => + { + sets.Insert(Math.Clamp(index, 0, sets.Count), set); + TriggerSetReferences.Reattach(references, name); + }, + index); + }, + ScreenButtonKind.Remove, + set.Name); } /// @@ -650,39 +786,95 @@ internal static List FormColumn( private static string Field(string display, ScreenFocus cursor, int index, int field, int pane = 0) => ScreenChrome.Field(display, cursor.EditOn(pane, index, field)); - /// The assigned-trigger-sets checklist for a character. + /// + /// The trigger-set list: which sets exist, what each is called and for, how much it holds, and + /// whether this character has opted into it. It is the app's only view of sets as objects — every + /// other screen shows one kind of a set's contents flattened across all of them — so it is + /// also where sets are made, renamed and unmade, and the only place an empty one can be seen at all. + /// + /// The name and description are welled because ⏎ opens them here; the assignment stays a checkbox, + /// which is the affordance for the key that presses it. + /// + /// internal static List TriggersColumn( CharacterDefinition character, IReadOnlyList triggerSets, string accent, - ScreenFocus? focus = null) + ScreenFocus? focus = null, + int selectedSet = 0, + IReadOnlyList? worlds = null) { var cursor = focus ?? ScreenFocus.None; + + // Padded to shared widths so the wells line up into columns and the inventories at the end of + // each row can be read down. Measured over the drawn text, since a name may carry brackets. + var nameWidth = Width(triggerSets, s => "▪ " + Escape(s.Name)); + var noteWidth = Width(triggerSets, s => Escape(s.Description ?? NoDescription)); + var rows = new List(triggerSets.Count); foreach (var set in triggerSets) { var assigned = character.TriggerSets.Contains(set.Name); var box = assigned ? $"[{accent}][[x]][/]" : $"[{Label}][[ ]][/]"; var nameColor = assigned ? Value : Label; - var description = Escape(set.Description ?? string.Empty); - rows.Add( - $"{box} [{nameColor}]▪ {Escape(set.Name)}[/] [{Label}]— {description} {set.Triggers.Count.ToString(CultureInfo.InvariantCulture)} rules[/]"); + var index = rows.Count; + + // The bullet lives inside the well with the name rather than beside it: the well is the box + // the value is typed in, and a bullet floating outside it would read as a second column. + var name = ScreenChrome.Field( + PadVisible($"[{nameColor}]▪ {Escape(set.Name)}[/]", nameWidth), + cursor.EditOn(TriggerSetsPane, index, SetNameField)); + var note = ScreenChrome.Field( + PadVisible($"[{Label}]{Escape(set.Description ?? NoDescription)}[/]", noteWidth), + cursor.EditOn(TriggerSetsPane, index, SetDescriptionField)); + + rows.Add($"{box} {name} {note} [{Label}]{Inventory(set)}[/]"); } // The checklist sits in an auto-width column (see WorldsScreenView), so a cursor bar sized to // one row would widen the block and shunt it sideways as the cursor moved. Sizing every bar to // the widest row keeps the column's measured width constant whatever is focused. + var buttons = ScreenChrome.Buttons( + SetButtons(worlds ?? Array.Empty(), triggerSets, selectedSet), + cursor, + TriggerSetsPane, + triggerSets.Count, + 0); var barWidth = rows.Count == 0 ? 0 : rows.Max(VisibleLength); - var list = new List { $"[{Label}]assigned trigger sets[/]", string.Empty }; + var list = new List { $"[{Label}]trigger sets[/]", string.Empty }; for (var i = 0; i < rows.Count; i++) { list.Add(ScreenChrome.Cursor(rows[i], cursor.IsOn(TriggerSetsPane, i), barWidth)); } + if (triggerSets.Count == 0) + { + list.Add($"[{Label}]no trigger sets — nothing to assign yet.[/]"); + } + + list.Add(string.Empty); + list.AddRange(buttons); return list; } + /// + /// What a set holds, counted across everything it can hold rather than only its triggers. The count + /// is the one thing on this row that says whether a set is doing anything, and a set carrying two + /// timers and no triggers reading 0 rules would be exactly the wrong answer. + /// + private static string Inventory(TriggerSet set) + { + var count = set.Triggers.Count + set.Aliases.Count + set.Macros.Count + set.Timers.Count; + return count == 0 + ? "empty" + : $"{count.ToString(CultureInfo.InvariantCulture)} rules"; + } + + /// The widest of a projection over the sets, or zero when there are none. + private static int Width(IReadOnlyList sets, Func part) => + sets.Count == 0 ? 0 : sets.Max(s => VisibleLength(part(s))); + private static string CharacterRow(CharacterDefinition character, bool selected) { var marker = selected ? $"[bold {Accent}]▸[/]" : " "; diff --git a/src/SharpMUTerm.Tui/WorldsScreenView.cs b/src/SharpMUTerm.Tui/WorldsScreenView.cs index c3281e6a..902e52e4 100644 --- a/src/SharpMUTerm.Tui/WorldsScreenView.cs +++ b/src/SharpMUTerm.Tui/WorldsScreenView.cs @@ -23,7 +23,8 @@ public static IWindowControl Build( int selectedCharacter, int width, ScreenFocus? focus = null, - string fkey = WorldsScreenRenderer.FKey) + string fkey = WorldsScreenRenderer.FKey, + int selectedSet = 0) { // Both panes end in button rows, so a raw cursor can point past its list; resolving once here // keeps every block of the screen agreeing on which world and character are selected. @@ -31,7 +32,8 @@ public static IWindowControl Build( WorldsScreenRenderer.Resolve(worlds, selectedWorld, selectedCharacter); var accent = WorldsScreenRenderer.AccentFor(worlds, selectedWorld); - var model = WorldsScreenRenderer.Model(worlds, triggerSets, selectedWorld, selectedCharacter); + var model = WorldsScreenRenderer.Model( + worlds, triggerSets, selectedWorld, selectedCharacter, selectedSet); var header = ScreenChrome.Band( WorldsScreenRenderer.HeaderLine(width, model, focus, fkey), ScreenPalette.HeaderBg); var footer = ScreenChrome.Band( @@ -62,7 +64,9 @@ public static IWindowControl Build( { var character = worlds[selectedWorld].Characters[selectedCharacter]; var form = WorldsScreenRenderer.FormColumn(character, accent, focus, selectedCharacter).ToList(); - var triggers = WorldsScreenRenderer.TriggersColumn(character, triggerSets, accent, focus).ToList(); + var triggers = WorldsScreenRenderer + .TriggersColumn(character, triggerSets, accent, focus, selectedSet, worlds) + .ToList(); var editHeight = Math.Max(form.Count, triggers.Count); // Form panel on the left; the trigger checklist pushed to the right by a flex spacer so its diff --git a/tests/SharpMUTerm.Core.Tests/Configuration/TriggerSetReferenceTests.cs b/tests/SharpMUTerm.Core.Tests/Configuration/TriggerSetReferenceTests.cs new file mode 100644 index 00000000..83596d2e --- /dev/null +++ b/tests/SharpMUTerm.Core.Tests/Configuration/TriggerSetReferenceTests.cs @@ -0,0 +1,168 @@ +using SharpMUTerm.Core.Configuration; + +namespace SharpMUTerm.Core.Tests.Configuration; + +/// +/// The links between a trigger set and the characters that opted into it. A character selects its +/// automation by name, so a set that is renamed or deleted leaves every one of those +/// references dangling unless something goes and fixes them — and "fixes them" has to mean putting each +/// one back in the position it held, because that order decides which set wins a conflict +/// (). +/// +public class TriggerSetReferenceTests +{ + private static AppConfiguration Config() + { + var config = new AppConfiguration(); + config.TriggerSets.Add(new TriggerSet { Name = "Comms" }); + config.TriggerSets.Add(new TriggerSet { Name = "Trade" }); + config.Worlds.Add(new WorldDefinition + { + Name = "Aetherfall", + Characters = + { + new CharacterDefinition { Name = "Corvid", TriggerSets = { "Combat", "Comms", "Trade" } }, + new CharacterDefinition { Name = "Rookery", TriggerSets = { "Trade" } }, + }, + }); + config.Worlds.Add(new WorldDefinition + { + Name = "Grapevine", + Characters = { new CharacterDefinition { Name = "Thistle", TriggerSets = { "Comms" } } }, + }); + + return config; + } + + [Test] + public async Task Find_ReportsEveryCharacterThatOptedIn_AndWhereInItsOwnList() + { + var config = Config(); + + var found = TriggerSetReferences.Find(config.Worlds, "Comms"); + + await Assert.That(found).Count().IsEqualTo(2); + await Assert.That(found[0].Character.Name).IsEqualTo("Corvid"); + await Assert.That(found[0].Index).IsEqualTo(1); + await Assert.That(found[1].Character.Name).IsEqualTo("Thistle"); + await Assert.That(found[1].Index).IsEqualTo(0); + } + + /// + /// Matching follows the resolver, which is case-insensitive. A reference that would resolve + /// to this set is a reference to it, whatever case it was typed in — otherwise renaming the set + /// would silently leave that character behind. + /// + [Test] + public async Task Find_MatchesTheWayTheResolverDoes() + { + var config = Config(); + config.Worlds[0].Characters[1].TriggerSets[0] = "trade"; + + await Assert.That(TriggerSetReferences.Find(config.Worlds, "Trade")).Count().IsEqualTo(2); + } + + [Test] + public async Task Find_ComesBackEmptyForASetNobodyUses() + { + await Assert.That(TriggerSetReferences.Find(Config().Worlds, "Nobody")).IsEmpty(); + } + + /// + /// The point of renaming through the references rather than around them: the assignment keeps its + /// place in the character's list, so the priority order somebody built by hand survives a typo being + /// fixed. Renaming in place is also what makes undo free — the same call with the old name. + /// + [Test] + public async Task Rename_RewritesEveryReferenceWithoutMovingIt() + { + var config = Config(); + var corvid = config.Worlds[0].Characters[0]; + + TriggerSetReferences.Rename(TriggerSetReferences.Find(config.Worlds, "Comms"), "Channels"); + + await Assert.That(corvid.TriggerSets).IsEquivalentTo(new[] { "Combat", "Channels", "Trade" }); + await Assert.That(config.Worlds[1].Characters[0].TriggerSets).IsEquivalentTo(new[] { "Channels" }); + + // Nothing else moved: the set nobody renamed is where it was, in the position it was in. + await Assert.That(config.Worlds[0].Characters[1].TriggerSets).IsEquivalentTo(new[] { "Trade" }); + } + + /// + /// Deleting a set has to take the assignments with it, or a character is left holding a name that + /// resolves to nothing — and the screen would go on drawing it as an assignment. + /// + [Test] + public async Task Detach_RemovesEveryReference() + { + var config = Config(); + + TriggerSetReferences.Detach(TriggerSetReferences.Find(config.Worlds, "Trade")); + + await Assert.That(config.Worlds[0].Characters[0].TriggerSets) + .IsEquivalentTo(new[] { "Combat", "Comms" }); + await Assert.That(config.Worlds[0].Characters[1].TriggerSets).IsEmpty(); + await Assert.That(config.Worlds[1].Characters[0].TriggerSets).IsEquivalentTo(new[] { "Comms" }); + } + + /// + /// Undoing a deletion restores the position, not merely the existence, of every assignment + /// — the same rule a deleted row's undo follows. Put back on the end, an assignment would come back + /// at a different priority than it left at, which is a second edit riding along with the first. + /// + [Test] + public async Task DetachThenReattach_PutsEveryReferenceBackWhereItWas() + { + var config = Config(); + var corvid = config.Worlds[0].Characters[0]; + var references = TriggerSetReferences.Find(config.Worlds, "Comms"); + + TriggerSetReferences.Detach(references); + await Assert.That(corvid.TriggerSets).IsEquivalentTo(new[] { "Combat", "Trade" }); + + TriggerSetReferences.Reattach(references, "Comms"); + + await Assert.That(corvid.TriggerSets[0]).IsEqualTo("Combat"); + await Assert.That(corvid.TriggerSets[1]).IsEqualTo("Comms"); + await Assert.That(corvid.TriggerSets[2]).IsEqualTo("Trade"); + await Assert.That(config.Worlds[1].Characters[0].TriggerSets).IsEquivalentTo(new[] { "Comms" }); + } + + /// + /// A character holding several references to one set is the case the walk order exists for: removing + /// the earlier one renumbers the later, so Detach walks backwards and Reattach forwards. + /// Both survive it. + /// + [Test] + public async Task DetachThenReattach_SurvivesTwoReferencesInOneCharacter() + { + var config = Config(); + var corvid = config.Worlds[0].Characters[0]; + corvid.TriggerSets.Add("Comms"); + var references = TriggerSetReferences.Find(config.Worlds, "Comms"); + + TriggerSetReferences.Detach(references); + await Assert.That(corvid.TriggerSets).IsEquivalentTo(new[] { "Combat", "Trade" }); + + TriggerSetReferences.Reattach(references, "Comms"); + + await Assert.That(corvid.TriggerSets).IsEquivalentTo(new[] { "Combat", "Comms", "Trade", "Comms" }); + } + + /// + /// The round trip that matters at the top: after a rename, the character still resolves to the very + /// same set object. Nothing else on these screens can break automation by editing a label. + /// + [Test] + public async Task Rename_KeepsTheCharacterResolvingToTheSameSet() + { + var config = Config(); + var corvid = config.Worlds[0].Characters[0]; + var comms = config.TriggerSets[0]; + + TriggerSetReferences.Rename(TriggerSetReferences.Find(config.Worlds, comms.Name), "Channels"); + comms.Name = "Channels"; + + await Assert.That(config.ResolveTriggerSets(corvid)).Contains(comms); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/MacroKeyCaptureTests.cs b/tests/SharpMUTerm.Tui.Tests/MacroKeyCaptureTests.cs index 75a4c186..1f39f5b8 100644 --- a/tests/SharpMUTerm.Tui.Tests/MacroKeyCaptureTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/MacroKeyCaptureTests.cs @@ -186,7 +186,8 @@ public async Task TheNumpadGridSaysThatNothingReachesIt() /// /// The key is the row's third field, appended after the name and the command so the two ordinals /// that were already addressed by the renderer, the tests and the snapshot scripts still mean what - /// they meant. Opening it arms a capture rather than a buffer. + /// they meant. Opening it arms a capture rather than a buffer. The owning set was appended after it + /// on the same rule, so the key is still the third and the row is now four. /// [Test] public async Task TheBindingRowCarriesItsKeyAsACaptureField() @@ -195,7 +196,8 @@ public async Task TheBindingRowCarriesItsKeyAsACaptureField() var model = KeypadScreenRenderer.Model(sets.SelectMany(s => s.Macros).ToList(), sets, 0); var row = model.RowAt(0, 0); - await Assert.That(row.FieldCount).IsEqualTo(3); + await Assert.That(row.FieldCount).IsEqualTo(4); + await Assert.That(row.FieldAt(KeypadScreenRenderer.SetField)!.Value.Get()).IsEqualTo(sets[0].Name); await Assert.That(row.FieldAt(KeypadScreenRenderer.NameField)!.Value.Get()).IsEqualTo("Look"); await Assert.That(row.FieldAt(KeypadScreenRenderer.CommandField)!.Value.Get()).IsEqualTo("look"); await Assert.That(row.FieldAt(KeypadScreenRenderer.KeyField)!.Value.Get()).IsEqualTo("Num5"); diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenButtonTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenButtonTests.cs index f2548c3a..57aa2d7d 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenButtonTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenButtonTests.cs @@ -59,10 +59,11 @@ public async Task EachListPaneEndsInItsOwnButtons() var worlds = Worlds(); var model = WorldsScreenRenderer.Model(worlds, Sets(), selectedWorld: 0, selectedCharacter: 0); - // 2 worlds + [+ world] + [- del]; 2 characters + [+ add] + [⧉ duplicate] + [- remove]; 1 set; - // and the world's 2 security checkboxes, a pane with no buttons of its own. + // 2 worlds + [+ world] + [- del]; 2 characters + [+ add] + [⧉ duplicate] + [- remove]; + // 1 set + [+ set] + [- del]; and the world's 2 security checkboxes, a pane with no buttons of + // its own. The list counts are what every index below addresses and are unchanged by any of it. await Assert.That(model.ListSizes).IsEquivalentTo(new[] { 2, 2, 1, 2 }); - await Assert.That(model.Sizes).IsEquivalentTo(new[] { 4, 5, 1, 2 }); + await Assert.That(model.Sizes).IsEquivalentTo(new[] { 4, 5, 3, 2 }); await Assert.That(model.ButtonAt(0, 2)!.Value.Label).IsEqualTo(WorldsScreenRenderer.AddWorldLabel); await Assert.That(model.ButtonAt(0, 3)!.Value.Label).IsEqualTo(WorldsScreenRenderer.RemoveWorldLabel); @@ -70,6 +71,8 @@ public async Task EachListPaneEndsInItsOwnButtons() await Assert.That(model.ButtonAt(1, 3)!.Value.Label) .IsEqualTo(WorldsScreenRenderer.DuplicateCharacterLabel); await Assert.That(model.ButtonAt(1, 4)!.Value.Label).IsEqualTo(WorldsScreenRenderer.RemoveCharacterLabel); + await Assert.That(model.ButtonAt(2, 1)!.Value.Label).IsEqualTo(WorldsScreenRenderer.AddSetLabel); + await Assert.That(model.ButtonAt(2, 2)!.Value.Label).IsEqualTo(WorldsScreenRenderer.RemoveSetLabel); // A world's own rows are still where they were — the buttons come after the list, so giving the // pane buttons doesn't renumber the rows the cursor navigates by. diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenDeleteKeyTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenDeleteKeyTests.cs index 1a51c23c..8291286b 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenDeleteKeyTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenDeleteKeyTests.cs @@ -140,8 +140,14 @@ public async Task Delete_DoesNothingOnAButtonRow() /// /// A pane with no remove button doesn't answer the key either — the key and the drawn row are the - /// same command, so they are offered under the same conditions. F5's trigger-set pane is - /// assignment, not ownership: there is nothing there to delete. + /// same command, so they are offered under the same conditions. F5's security pane is two checkboxes + /// belonging to the world above it: there is nothing there to take out of a list. + /// + /// This claim used to be made about the trigger-set pane, which was assignment and nothing else. + /// That pane now owns the sets themselves, so it answers Delete — see + /// , which is the same rule read + /// the other way. + /// /// [Test] public async Task Delete_IsLeftForTheFrameworkWhereThereIsNothingToRemove() @@ -149,14 +155,45 @@ public async Task Delete_IsLeftForTheFrameworkWhereThereIsNothingToRemove() var worlds = Worlds(); var sets = Sets(); var session = new SettingsSession(selection => WorldsScreenRenderer.Model( - worlds, sets, selection.SelectionIn(0), selection.SelectionIn(1))); + worlds, sets, selection.SelectionIn(0), selection.SelectionIn(1), selection.SelectionIn(2))); - session.Handle(Key(ConsoleKey.Tab)); - session.Handle(Key(ConsoleKey.Tab)); // into the assigned-trigger-sets pane + for (var i = 0; i < 3; i++) + { + session.Handle(Key(ConsoleKey.Tab)); // worlds → characters → trigger sets → security + } - await Assert.That(session.Focus().Pane).IsEqualTo(2); + await Assert.That(session.Focus().Pane).IsEqualTo(WorldsScreenRenderer.SecurityPane); await Assert.That(session.Handle(Key(ConsoleKey.Delete))).IsEqualTo(ScreenAction.None); - await Assert.That(sets).Count().IsEqualTo(1); + await Assert.That(session.Edits.IsDirty).IsFalse(); + } + + /// + /// The other half: the trigger-set pane does answer Delete now, and deleting a set takes + /// every character's opt-in with it rather than leaving assignments pointing at a set that no longer + /// exists. Esc puts both back. + /// + [Test] + public async Task Delete_RemovesTheSelectedTriggerSetAndItsAssignments() + { + var worlds = Worlds(); + var sets = Sets(); + var character = worlds[0].Characters[0]; + character.TriggerSets.Add("Comms"); + var session = new SettingsSession(selection => WorldsScreenRenderer.Model( + worlds, sets, selection.SelectionIn(0), selection.SelectionIn(1), selection.SelectionIn(2))); + + session.Handle(Key(ConsoleKey.Tab)); + session.Handle(Key(ConsoleKey.Tab)); // into the trigger-set pane + + await Assert.That(session.Focus().Pane).IsEqualTo(WorldsScreenRenderer.TriggerSetsPane); + await Assert.That(session.Handle(Key(ConsoleKey.Delete))).IsEqualTo(ScreenAction.Redraw); + await Assert.That(sets).IsEmpty(); + await Assert.That(character.TriggerSets).IsEmpty(); + + session.Edits.Revert(); + + await Assert.That(sets.Select(s => s.Name)).IsEquivalentTo(new[] { "Comms" }); + await Assert.That(character.TriggerSets).IsEquivalentTo(new[] { "Comms" }); } /// diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs index c6a24cf9..f0f1117c 100644 --- a/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/ScreenModelTests.cs @@ -179,10 +179,11 @@ public async Task Worlds_HasWorldsThenCharactersThenTriggerSets() await Assert.That(model.PaneCount).IsEqualTo(4); // Two worlds then [+ world] / [- del]; two characters then [+ add] / [⧉ duplicate] / - // [- remove]. Buttons are appended after each list, so every index below still addresses - // the same item it always did — which is what the list counts assert independently of the total. + // [- remove]; one trigger set then [+ set] / [- del]. Buttons are appended after each list, so + // every index below still addresses the same item it always did — which is what the list counts + // assert independently of the total. await Assert.That(model.ListSizes).IsEquivalentTo(new[] { 2, 2, 1, 2 }); - await Assert.That(model.Sizes).IsEquivalentTo(new[] { 4, 5, 1, 2 }); + await Assert.That(model.Sizes).IsEquivalentTo(new[] { 4, 5, 3, 2 }); // Worlds are selection only — there is no checkbox on a world row. await Assert.That(model.ToggleAt(0, 0)).IsNull(); diff --git a/tests/SharpMUTerm.Tui.Tests/SettingsScreenViewTests.cs b/tests/SharpMUTerm.Tui.Tests/SettingsScreenViewTests.cs index be8329b3..0eff751b 100644 --- a/tests/SharpMUTerm.Tui.Tests/SettingsScreenViewTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/SettingsScreenViewTests.cs @@ -80,6 +80,30 @@ public async Task TheLoggingEditViewLandsOnTheLogField() await Assert.That(Carets(frame)).IsGreaterThan(Carets(Frame("logging"))); } + /// + /// The set view is F2 stopped on a rule's owning set — the one field on these screens whose + /// commit moves the row it is made on. The list it offers is closed, because a set is a real + /// object with characters assigned to it and a name typed here could only be one that does not + /// exist; the frame is where that presentation is checked rather than merely asserted. + /// + [Test] + public async Task TheSetViewOpensARulesOwningSetAsAClosedList() + { + var frame = Frame("set-edit"); + + await Assert.That(frame).Contains("Triggers & spawn routing"); + await Assert.That(frame).Contains(ScreenChrome.ClosedChoicesCaption); + + // Every configured set is offered, including the one holding no triggers at all — which is the + // whole point of the list being drawn from the configuration rather than from the pane's rows. + foreach (var set in DemoScene.Build().TriggerSets) + { + await Assert.That(frame).Contains(set.Name); + } + + await Assert.That(Carets(frame)).IsGreaterThan(Carets(Frame("triggers"))); + } + /// /// How many cells the frame paints in the block-caret colours. Counted rather than matched, because /// what distinguishes a field being typed into from the same field at rest is the caret cell. diff --git a/tests/SharpMUTerm.Tui.Tests/TriggerSetManagementTests.cs b/tests/SharpMUTerm.Tui.Tests/TriggerSetManagementTests.cs new file mode 100644 index 00000000..5a864096 --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/TriggerSetManagementTests.cs @@ -0,0 +1,571 @@ +using SharpMUTerm.Core.Automation; +using SharpMUTerm.Core.Configuration; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// Managing the trigger sets themselves, which nothing could do: they organise the whole automation +/// configuration — F2's triggers, F3's aliases, F4's bindings and F6's timers all live inside one — and +/// the only set operation anywhere in the UI was ticking a character's assignment on F5. +/// +/// Three gaps, and they are closed in two places. Sets are made, renamed and unmade on F5's +/// trigger-set pane, because that pane is the only view of sets as objects rather than as a column +/// of somebody's rules — and because it is therefore the only place an empty set can be seen at +/// all. Items move between sets through a set field on the item's own row on F2/F3/F4/F6, which +/// makes "which set owns this" an edit like any other: the same closed dropdown, the same validator, the +/// same undo log. +/// +/// +/// The hazards are the reason most of these exist. A set's name is a key — a character opts in +/// by name — so renaming or deleting one reaches into every world's characters, and undo has to restore +/// position and not merely existence. +/// +/// +public class TriggerSetManagementTests +{ + private static ConsoleKeyInfo Key(ConsoleKey key) => new('\0', key, false, false, false); + + private static ConsoleKeyInfo Char(char c) => new(c, ConsoleKey.NoName, false, false, false); + + private static List Sets() => new() + { + new TriggerSet + { + Name = "Comms", + Description = "channel routing", + Triggers = new List + { + new() { Name = "Tell", Pattern = "tells you" }, + new() { Name = "Spam", Pattern = "guild" }, + }, + Aliases = new List { new() { Name = "gr", Pattern = "^gr$", Substitution = "greet" } }, + Macros = new List { new() { Name = "Look", Key = "F1", Command = "look" } }, + Timers = new List { new() { Name = "ping", IntervalSeconds = 30, Command = "look" } }, + }, + new TriggerSet + { + Name = "Trade", + Description = "auction watch", + Triggers = new List { new() { Name = "Offer", Pattern = "offers" } }, + }, + }; + + private static List Worlds() => new() + { + new WorldDefinition + { + Name = "Aetherfall", + Host = "aetherfall.mux", + Characters = new List + { + new() { Name = "Corvid", TriggerSets = new List { "Comms", "Trade" } }, + new() { Name = "Rookery", TriggerSets = new List { "Trade" } }, + }, + }, + }; + + private static ScreenButton ButtonNamed(ScreenModel model, int pane, string label) + { + for (var i = 0; i < 32; i++) + { + if (model.ButtonAt(pane, i) is { } button && button.Label == label) + { + return button; + } + } + + throw new InvalidOperationException($"no button labelled '{label}' in pane {pane}"); + } + + private static SettingsSession WorldsSession(List worlds, List sets) => + new(selection => WorldsScreenRenderer.Model( + worlds, + sets, + selection.SelectionIn(WorldsScreenRenderer.WorldsPane), + selection.SelectionIn(WorldsScreenRenderer.CharactersPane), + selection.SelectionIn(WorldsScreenRenderer.TriggerSetsPane))); + + // ---- creating --------------------------------------------------------------------------------- + + /// + /// The first gap: nothing made a set. A new one is empty and lands under the cursor, ready to be + /// named — the same contract every other [[+ …]] on these screens keeps. + /// + [Test] + public async Task AddingASetAppendsAnEmptyOneAndLeavesTheCursorOnIt() + { + var sets = Sets(); + var edits = new ScreenEdits(); + var model = WorldsScreenRenderer.Model(Worlds(), sets, 0, 0); + + var select = edits.Apply(ButtonNamed(model, WorldsScreenRenderer.TriggerSetsPane, WorldsScreenRenderer.AddSetLabel)); + + await Assert.That(sets.Select(s => s.Name)).IsEquivalentTo(new[] { "Comms", "Trade", "New Set" }); + await Assert.That(sets[2].Triggers).IsEmpty(); + await Assert.That(select).IsEqualTo(2); + + edits.Revert(); + await Assert.That(sets.Select(s => s.Name)).IsEquivalentTo(new[] { "Comms", "Trade" }); + } + + /// + /// A set's name is a key, not a label — a character opts in by name — so two called New Set + /// could not both be assigned to anything. The button therefore takes the first free name rather + /// than the same one twice. + /// + [Test] + public async Task AddingTwiceGivesEachSetAFreeName() + { + var sets = Sets(); + var worlds = Worlds(); + var edits = new ScreenEdits(); + + edits.Apply(ButtonNamed( + WorldsScreenRenderer.Model(worlds, sets, 0, 0), + WorldsScreenRenderer.TriggerSetsPane, + WorldsScreenRenderer.AddSetLabel)); + edits.Apply(ButtonNamed( + WorldsScreenRenderer.Model(worlds, sets, 0, 0), + WorldsScreenRenderer.TriggerSetsPane, + WorldsScreenRenderer.AddSetLabel)); + + await Assert.That(sets.Select(s => s.Name)) + .IsEquivalentTo(new[] { "Comms", "Trade", "New Set", "New Set 2" }); + } + + /// + /// End to end through the keyboard, which is what the button is for: ⇥ ⇥ into the set pane, ↓ past + /// the two sets onto [[+ set]], ⏎ to run it, and the next ⏎ opens the new set's name. The + /// cursor lands on the set that was made, not on the button that made it. + /// + [Test] + public async Task Enter_OnAddSetLeavesTheCursorOnTheNewSetReadyToNameIt() + { + var sets = Sets(); + var session = WorldsSession(Worlds(), sets); + + session.Handle(Key(ConsoleKey.Tab)); + session.Handle(Key(ConsoleKey.Tab)); + await Assert.That(session.Focus().Pane).IsEqualTo(WorldsScreenRenderer.TriggerSetsPane); + + // Rows 0-1 are the two sets; row 2 is [+ set] and row 3 is [- del], so End would delete rather + // than add — ↓ ↓ is how the add button is reached, and the selection stays on the last set. + session.Handle(Key(ConsoleKey.DownArrow)); + session.Handle(Key(ConsoleKey.DownArrow)); + await Assert.That(session.Handle(Key(ConsoleKey.Enter))).IsEqualTo(ScreenAction.Redraw); + await Assert.That(sets).Count().IsEqualTo(3); + await Assert.That(session.Focus().Index).IsEqualTo(2); + + session.Handle(Key(ConsoleKey.Enter)); + await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo(WorldsScreenRenderer.NewSetName); + } + + // ---- renaming --------------------------------------------------------------------------------- + + /// + /// The hazard: holds names, so a set renamed + /// on its own leaves every character that used it pointing at nothing, and the automation stops + /// silently at the next connect. The rename carries the references with it, in place, so the order + /// that decides which set wins a conflict survives. + /// + [Test] + public async Task RenamingASetCarriesEveryCharactersAssignmentWithIt() + { + var worlds = Worlds(); + var sets = Sets(); + var (corvid, rookery) = (worlds[0].Characters[0], worlds[0].Characters[1]); + var field = WorldsScreenRenderer.Model(worlds, sets, 0, 0) + .FieldAt(WorldsScreenRenderer.TriggerSetsPane, 0, WorldsScreenRenderer.SetNameField)!.Value; + + await Assert.That(new ScreenEdits().Apply(field, "Channels")).IsNull(); + + await Assert.That(sets[0].Name).IsEqualTo("Channels"); + await Assert.That(corvid.TriggerSets).IsEquivalentTo(new[] { "Channels", "Trade" }); + await Assert.That(corvid.TriggerSets[0]).IsEqualTo("Channels"); + await Assert.That(rookery.TriggerSets).IsEquivalentTo(new[] { "Trade" }); + } + + /// + /// And undo takes them back, position included. Restoring the set's own name while leaving the + /// characters renamed would be the same orphaning, reached from the other direction. + /// + [Test] + public async Task UndoingARenameRestoresTheNameAndEveryAssignmentAtItsPosition() + { + var worlds = Worlds(); + var sets = Sets(); + var corvid = worlds[0].Characters[0]; + var edits = new ScreenEdits(); + var field = WorldsScreenRenderer.Model(worlds, sets, 0, 0) + .FieldAt(WorldsScreenRenderer.TriggerSetsPane, 0, WorldsScreenRenderer.SetNameField)!.Value; + + await Assert.That(edits.Apply(field, "Channels")).IsNull(); + edits.Revert(); + + await Assert.That(sets[0].Name).IsEqualTo("Comms"); + await Assert.That(corvid.TriggerSets[0]).IsEqualTo("Comms"); + await Assert.That(corvid.TriggerSets[1]).IsEqualTo("Trade"); + } + + /// + /// A set's name being a key is exactly why it is the one name on these screens that must be unique: + /// takes the first match, so the second of two + /// Comms could never be assigned to anything. Refused case-insensitively, as the resolver + /// matches — and nothing is written, so a refused rename cannot half-happen. + /// + [Test] + public async Task RenamingASetOntoAnothersNameIsRefusedAndWritesNothing() + { + var worlds = Worlds(); + var sets = Sets(); + var corvid = worlds[0].Characters[0]; + var field = WorldsScreenRenderer.Model(worlds, sets, 0, 0) + .FieldAt(WorldsScreenRenderer.TriggerSetsPane, 0, WorldsScreenRenderer.SetNameField)!.Value; + + await Assert.That(field.Validate("trade")).IsNotNull(); + await Assert.That(new ScreenEdits().Apply(field, "Trade")).IsNotNull(); + + await Assert.That(sets[0].Name).IsEqualTo("Comms"); + await Assert.That(corvid.TriggerSets).IsEquivalentTo(new[] { "Comms", "Trade" }); + + // Its own name is not "taken" by itself — committing a set's name unchanged has to be legal, or + // the field could never be closed with ⏎ on the value it opened with. + await Assert.That(field.Validate("Comms")).IsNull(); + await Assert.That(field.Validate(" ")).IsNotNull(); + } + + /// A set's description is editable too, and is the row's second field. + [Test] + public async Task ASetsDescriptionIsTheRowsSecondField() + { + var sets = Sets(); + var row = WorldsScreenRenderer.Model(Worlds(), sets, 0, 0) + .RowAt(WorldsScreenRenderer.TriggerSetsPane, 0); + + await Assert.That(row.FieldCount).IsEqualTo(2); + await Assert.That(row.FieldAt(WorldsScreenRenderer.SetDescriptionField)!.Value.Get()) + .IsEqualTo("channel routing"); + + await Assert.That(new ScreenEdits().Apply( + row.FieldAt(WorldsScreenRenderer.SetDescriptionField)!.Value, "chat + pages")).IsNull(); + await Assert.That(sets[0].Description).IsEqualTo("chat + pages"); + } + + // ---- deleting --------------------------------------------------------------------------------- + + /// + /// Deleting a set is the destructive edit with the longest reach: the set goes, and so does every + /// character's opt-in, because an assignment naming a set that no longer exists resolves to nothing + /// while still being drawn as an assignment. + /// + [Test] + public async Task DeletingASetStripsEveryCharactersAssignment() + { + var worlds = Worlds(); + var sets = Sets(); + var (corvid, rookery) = (worlds[0].Characters[0], worlds[0].Characters[1]); + + new ScreenEdits().Apply(ButtonNamed( + WorldsScreenRenderer.Model(worlds, sets, 0, 0, selectedSet: 1), + WorldsScreenRenderer.TriggerSetsPane, + WorldsScreenRenderer.RemoveSetLabel)); + + await Assert.That(sets.Select(s => s.Name)).IsEquivalentTo(new[] { "Comms" }); + await Assert.That(corvid.TriggerSets).IsEquivalentTo(new[] { "Comms" }); + await Assert.That(rookery.TriggerSets).IsEmpty(); + } + + /// + /// Undo restores position, on both halves: the set back at its index in the configuration, + /// and each assignment back at its index inside the character that held it. Put back on the end, + /// either would come back at a priority it did not leave at. + /// + [Test] + public async Task UndoingADeleteRestoresTheSetAndItsAssignmentsWhereTheyWere() + { + var worlds = Worlds(); + var sets = Sets(); + var corvid = worlds[0].Characters[0]; + var comms = sets[0]; + var edits = new ScreenEdits(); + + edits.Apply(ButtonNamed( + WorldsScreenRenderer.Model(worlds, sets, 0, 0, selectedSet: 0), + WorldsScreenRenderer.TriggerSetsPane, + WorldsScreenRenderer.RemoveSetLabel)); + await Assert.That(sets.Select(s => s.Name)).IsEquivalentTo(new[] { "Trade" }); + await Assert.That(corvid.TriggerSets).IsEquivalentTo(new[] { "Trade" }); + + edits.Revert(); + + await Assert.That(sets[0]).IsSameReferenceAs(comms); + await Assert.That(sets[1].Name).IsEqualTo("Trade"); + await Assert.That(corvid.TriggerSets[0]).IsEqualTo("Comms"); + await Assert.That(corvid.TriggerSets[1]).IsEqualTo("Trade"); + } + + /// The destructive button names its victim, as every targeted button on these screens does. + [Test] + public async Task TheDeleteSetButtonNamesTheSetItWouldRemove() + { + var button = ButtonNamed( + WorldsScreenRenderer.Model(Worlds(), Sets(), 0, 0, selectedSet: 1), + WorldsScreenRenderer.TriggerSetsPane, + WorldsScreenRenderer.RemoveSetLabel); + + await Assert.That(button.Target).IsEqualTo("Trade"); + await Assert.That(button.Kind).IsEqualTo(ScreenButtonKind.Remove); + } + + // ---- moving an item between sets --------------------------------------------------------------- + + /// + /// The third gap: a rule created in the wrong set stayed there. It is the last field of the rule's + /// own row, so moving one is an edit like any other — and the list it offers is closed, + /// because a set is a real object with characters assigned to it and a name typed here could only + /// ever be a set that does not exist. + /// + [Test] + public async Task ATriggersSetFieldOffersEveryConfiguredSetAndNothingElse() + { + var sets = Sets(); + var field = TriggersScreenRenderer.Model(sets, 0) + .FieldAt(0, 0, TriggersScreenRenderer.SetField)!.Value; + + await Assert.That(field.Get()).IsEqualTo("Comms"); + await Assert.That(field.Choices).IsEquivalentTo(new[] { "Comms", "Trade" }); + await Assert.That(field.ClosedChoices).IsTrue(); + await Assert.That(field.Validate("Nowhere")).IsNotNull(); + await Assert.That(field.Validate("trade")).IsNull(); + } + + /// + /// Committing it moves the rule out of one set's list and onto the end of the other's — and the + /// cursor goes with it, because the pane is flattened across every set and the row genuinely changes + /// position. Left behind, the cursor would be pointing at whatever slid into the vacated row. + /// + [Test] + public async Task MovingATriggerToAnotherSetTakesTheCursorWithIt() + { + var sets = Sets(); + var spam = sets[0].Triggers[1]; + var field = TriggersScreenRenderer.Model(sets, 1) + .FieldAt(0, 1, TriggersScreenRenderer.SetField)!.Value; + + await Assert.That(new ScreenEdits().Apply(field, "Trade")).IsNull(); + + await Assert.That(sets[0].Triggers.Select(t => t.Name)).IsEquivalentTo(new[] { "Tell" }); + await Assert.That(sets[1].Triggers.Select(t => t.Name)).IsEquivalentTo(new[] { "Offer", "Spam" }); + await Assert.That(sets[1].Triggers[1]).IsSameReferenceAs(spam); + + // Flattened, the rule is now the third row: Tell, Offer, Spam. + await Assert.That(field.Follow!()).IsEqualTo(2); + } + + /// + /// Undo puts the rule back in its own set at its own index, not on the end of it — the same + /// rule a cancelled deletion follows, and for the same reason: the list's order is what the screen + /// navigates by, so restoring it elsewhere is a second, invisible edit. + /// + [Test] + public async Task UndoingAMoveRestoresTheRulesIndexInItsOriginalSet() + { + var sets = Sets(); + sets[0].Triggers.Add(new Trigger { Name = "Third", Pattern = "third" }); + var edits = new ScreenEdits(); + var field = TriggersScreenRenderer.Model(sets, 1) + .FieldAt(0, 1, TriggersScreenRenderer.SetField)!.Value; + + await Assert.That(edits.Apply(field, "Trade")).IsNull(); + await Assert.That(sets[0].Triggers.Select(t => t.Name)).IsEquivalentTo(new[] { "Tell", "Third" }); + + edits.Revert(); + + await Assert.That(sets[0].Triggers.Select(t => t.Name)) + .IsEquivalentTo(new[] { "Tell", "Spam", "Third" }); + await Assert.That(sets[0].Triggers[1].Name).IsEqualTo("Spam"); + await Assert.That(sets[1].Triggers.Select(t => t.Name)).IsEquivalentTo(new[] { "Offer" }); + } + + /// + /// Committing the set a rule is already in does nothing at all. Left as a remove-and-append it would + /// silently drop the rule to the bottom of its own set every time the field was closed on the value + /// it opened with, which is what ⏎ does. + /// + [Test] + public async Task CommittingTheSetAnItemIsAlreadyInLeavesItWhereItIs() + { + var sets = Sets(); + var field = TriggersScreenRenderer.Model(sets, 0) + .FieldAt(0, 0, TriggersScreenRenderer.SetField)!.Value; + + await Assert.That(new ScreenEdits().Apply(field, "Comms")).IsNull(); + + await Assert.That(sets[0].Triggers.Select(t => t.Name)).IsEquivalentTo(new[] { "Tell", "Spam" }); + await Assert.That(sets[0].Triggers[0].Name).IsEqualTo("Tell"); + } + + /// + /// All four flattened screens carry it, because all four show one kind of a set's contents and all + /// four could put a new one in the wrong place. Each is the row's last field, so no ordinal + /// the renderers, the snapshot key scripts or the other tests address was renumbered to make room. + /// + [Test] + public async Task EveryFlattenedScreenCanMoveItsItemsBetweenSets() + { + var sets = Sets(); + + var alias = AliasesScreenRenderer.Model(sets, 0).FieldAt(0, 0, AliasesScreenRenderer.SetField)!.Value; + await Assert.That(new ScreenEdits().Apply(alias, "Trade")).IsNull(); + await Assert.That(sets[0].Aliases).IsEmpty(); + await Assert.That(sets[1].Aliases.Select(a => a.Name)).IsEquivalentTo(new[] { "gr" }); + + var timer = TimersScreenRenderer.Model(sets, 0).FieldAt(0, 0, TimersScreenRenderer.SetField)!.Value; + await Assert.That(new ScreenEdits().Apply(timer, "Trade")).IsNull(); + await Assert.That(sets[0].Timers).IsEmpty(); + await Assert.That(sets[1].Timers.Select(t => t.Name)).IsEquivalentTo(new[] { "ping" }); + + var macros = sets.SelectMany(s => s.Macros).ToList(); + var binding = KeypadScreenRenderer.Model(macros, sets, 0) + .FieldAt(0, 0, KeypadScreenRenderer.SetField)!.Value; + await Assert.That(new ScreenEdits().Apply(binding, "Trade")).IsNull(); + await Assert.That(sets[0].Macros).IsEmpty(); + await Assert.That(sets[1].Macros.Select(m => m.Name)).IsEquivalentTo(new[] { "Look" }); + } + + /// + /// F4 is the one screen that can be handed the bindings without the sets they came from (the header + /// hints, the tests). With no sets there is no vocabulary to move between and no list to move out + /// of, so the field is not offered at all — the same condition that withholds that screen's buttons. + /// + [Test] + public async Task TheKeypadOffersNoSetFieldWhenItWasNotToldWhichSetsTheBindingsCameFrom() + { + var row = KeypadScreenRenderer.Model(Sets()[0].Macros).RowAt(0, 0); + + await Assert.That(row.FieldCount).IsEqualTo(3); + await Assert.That(row.FieldAt(KeypadScreenRenderer.SetField)).IsNull(); + } + + /// + /// Through the keyboard: ⏎ opens the rule's name, ⇥ walks to the last field, the dropdown lists the + /// sets, and ⏎ commits the move with the cursor landing on the row the rule now occupies. + /// + [Test] + public async Task Tab_ReachesTheSetFieldAndCommittingItMovesTheRule() + { + var sets = Sets(); + var session = new SettingsSession( + selection => TriggersScreenRenderer.Model(sets, selection.SelectionIn(0))); + + session.Handle(Key(ConsoleKey.DownArrow)); // onto "Spam", flattened row 1 + session.Handle(Key(ConsoleKey.Enter)); + for (var i = 0; i < TriggersScreenRenderer.SetField; i++) + { + session.Handle(Key(ConsoleKey.Tab)); + } + + var edit = session.Focus().Edit!.Value; + await Assert.That(edit.Field).IsEqualTo(TriggersScreenRenderer.SetField); + await Assert.That(edit.Text).IsEqualTo("Comms"); + await Assert.That(edit.ClosedChoices).IsTrue(); + + // ↓ walks the drawn list, exactly as it does on every other field with choices. + session.Handle(Key(ConsoleKey.DownArrow)); + await Assert.That(session.Focus().Edit!.Value.Text).IsEqualTo("Trade"); + + session.Handle(Key(ConsoleKey.Enter)); + + await Assert.That(session.IsEditing).IsFalse(); + await Assert.That(sets[1].Triggers.Select(t => t.Name)).IsEquivalentTo(new[] { "Offer", "Spam" }); + await Assert.That(session.Focus().Index).IsEqualTo(2); + } + + /// + /// ⇥ off the set field wraps to the row's name — and it has to be the moved rule's name. + /// The model is re-projected after a commit for exactly this: stepping through the projection the + /// key arrived with would open the next field of whichever row used to be under the cursor. + /// + [Test] + public async Task Tab_AfterAMoveOpensTheMovedRulesOwnNextField() + { + var sets = Sets(); + var session = new SettingsSession( + selection => TriggersScreenRenderer.Model(sets, selection.SelectionIn(0))); + + session.Handle(Key(ConsoleKey.DownArrow)); + session.Handle(Key(ConsoleKey.Enter)); + for (var i = 0; i < TriggersScreenRenderer.SetField; i++) + { + session.Handle(Key(ConsoleKey.Tab)); + } + + session.Handle(Key(ConsoleKey.DownArrow)); + session.Handle(Key(ConsoleKey.Tab)); // commits the move and wraps to field 0 + + var edit = session.Focus().Edit!.Value; + await Assert.That(edit.Field).IsEqualTo(TriggersScreenRenderer.NameField); + await Assert.That(edit.Text).IsEqualTo("Spam"); + } + + // ---- an empty set is visible ------------------------------------------------------------------- + + /// + /// A set with none of a screen's items owns none of that screen's rows, so a flattened pane draws it + /// nowhere at all — and a set you have just made holds nothing at all. All four screens say it is + /// there instead. It is markup and not a row: it stands for a set rather than an item, so the cursor + /// cannot land on it and the pane's row counts are untouched. + /// + [Test] + public async Task AnEmptySetIsNamedOnEveryFlattenedScreen() + { + var sets = Sets(); + sets.Add(new TriggerSet { Name = "Combat" }); + var macros = sets.SelectMany(s => s.Macros).ToList(); + + await Assert.That(TriggersScreenRenderer.RulesColumn(sets, 0) + .Any(l => l.Contains("▪ Combat — no triggers", StringComparison.Ordinal))).IsTrue(); + await Assert.That(AliasesScreenRenderer.ListColumn(sets, 0) + .Any(l => l.Contains("▪ Combat — no aliases", StringComparison.Ordinal))).IsTrue(); + await Assert.That(TimersScreenRenderer.ListColumn(sets, 0) + .Any(l => l.Contains("▪ Combat — no timers", StringComparison.Ordinal))).IsTrue(); + await Assert.That(KeypadScreenRenderer.HotkeysColumn(macros, null, sets, 0) + .Any(l => l.Contains("▪ Combat — no bindings", StringComparison.Ordinal))).IsTrue(); + + // Trade holds triggers but no aliases, so it is named on F3 and not on F2 — the placeholder is + // per screen, because "empty" means empty of the thing that screen edits. + await Assert.That(AliasesScreenRenderer.ListColumn(sets, 0) + .Any(l => l.Contains("▪ Trade — no aliases", StringComparison.Ordinal))).IsTrue(); + await Assert.That(TriggersScreenRenderer.RulesColumn(sets, 0) + .Any(l => l.Contains("▪ Trade — no triggers", StringComparison.Ordinal))).IsFalse(); + + // And it costs no cursor stops: three sets, four rules between them, unchanged. + await Assert.That(TriggersScreenRenderer.Model(sets, 0).ListSizes[0]).IsEqualTo(3); + } + + /// + /// F5 is where an empty set is always visible, whatever it is empty of, because that pane + /// lists the sets themselves. Its inventory counts everything a set can hold, so a set carrying two + /// timers and no triggers cannot read as though it were empty. + /// + [Test] + public async Task TheTriggerSetPaneListsEverySetAndSaysWhatEachHolds() + { + var sets = Sets(); + sets.Add(new TriggerSet { Name = "Combat" }); + var character = Worlds()[0].Characters[0]; + + var lines = WorldsScreenRenderer.TriggersColumn(character, sets, ScreenPalette.Accent); + + await Assert.That(lines.Any(l => l.Contains("▪ Combat", StringComparison.Ordinal) + && l.Contains("empty", StringComparison.Ordinal))).IsTrue(); + + // Comms holds two triggers, an alias, a macro and a timer — five, not the two the row used to + // report by counting triggers alone. + await Assert.That(lines.Any(l => l.Contains("▪ Comms", StringComparison.Ordinal) + && l.Contains("5 rules", StringComparison.Ordinal))).IsTrue(); + + await Assert.That(lines.Any(l => l.Contains("[[+ set]]", StringComparison.Ordinal))).IsTrue(); + } +} diff --git a/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs b/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs index 083b77cb..10ba99af 100644 --- a/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/TriggersScreenEditingTests.cs @@ -58,10 +58,11 @@ public async Task ARuleRowCarriesItsPatternRouteAndBothHighlightColours() var sets = Sets(); var model = TriggersScreenRenderer.Model(sets, 0, Targets); - // The name leads, then everything the editor pane draws. The first five ordinals are unchanged - // — the four new ones are appended, so nothing the screen, the snapshot keys or these tests - // already address is renumbered. - await Assert.That(model.RowAt(0, 0).FieldCount).IsEqualTo(9); + // The name leads, then everything the editor pane draws, then the set that owns the rule. Every + // ordinal below is unchanged — each new field is appended, so nothing the screen, the snapshot + // keys or these tests already address is renumbered. + await Assert.That(model.RowAt(0, 0).FieldCount).IsEqualTo(10); + await Assert.That(model.FieldAt(0, 0, TriggersScreenRenderer.SetField)!.Value.Get()).IsEqualTo("Comms"); await Assert.That(model.FieldAt(0, 0, TriggersScreenRenderer.NameField)!.Value.Get()).IsEqualTo("Tell"); await Assert.That(model.FieldAt(0, 0, TriggersScreenRenderer.PatternField)!.Value.Get()).IsEqualTo("tells you"); await Assert.That(model.FieldAt(0, 0, TriggersScreenRenderer.RouteField)!.Value.Get()).IsEqualTo("Chat"); From 7b6b202cdec1a36918323734f258c864c5ed5dad Mon Sep 17 00:00:00 2001 From: Harry Cordewener Date: Wed, 29 Jul 2026 00:00:46 -0500 Subject: [PATCH 21/23] Settings screens: size the layout to its content The last item of the design review, re-judged against the current screens rather than the ones the review described -- the findings had partly inverted. The dead space was real but the sharper problem was that the fixed 56/64 split now starves the other column: at 100x24 F2's editor clipped at "respond (off)", losing three cursor stops, and F5 clipped one line below its CHARACTERS heading, hiding both characters and all three buttons, while the list column beside them sat empty. Three pure rules in ScreenChrome, and a frame the four list screens share: a column keeps its designed width when the screen affords it and gives cells back when it doesn't; blocks drop their blank separators before anything else; and what still doesn't fit is windowed around the cursor with the edges naming what is off-screen. Bodies size to their content with a spacer beneath, so the hairline ends where the columns do, as F7/F8's card already did. F5 loses its title strip and its CHARACTERS table becomes a selector. Both restated what the rows below them already showed -- the strip's every token appeared in the five editable fields under it, and the table's columns were the character form and the trigger-set pane drawn again. F4 sizes its numpad from the longest command it actually holds instead of truncating to a fixed cell while the column beside it showed the same value in full, and yields that width while a key capture is armed, the prompt being twice as wide as the well it replaces. Each list screen gained a key for its flag marks, which had none anywhere; the marks the selected row carries are lit, so it reads as both a legend and a gloss on the cursor's row -- which also answers the cryptic "on" column header. F5 at 100x24 is correct rather than complete: 17 rows of detail still don't fit in 13, but no cursor stop goes undrawn now, which was the actual bug. A genuinely complete view needs collapsing panes, which remains its own piece of work. Kept F2's attribute legend at rest rather than making it conditional. The orphaned-legend-line case needs a buffer matching nothing, is transient and self-heals on the next keystroke; the legend is the only written record of the vocabulary that field accepts, since it carries no dropdown of its own. 1119 tests pass, up from 1101. Two pinned assertions changed, both strengthened: one now asserts TLS is stated exactly once and in the control that sets it, the other pins where each character fact lives rather than merely that it exists. Co-Authored-By: Claude Opus 5 (1M context) --- CLAUDE.md | 2 +- docs/HANDOFF.md | 63 ++++- src/SharpMUTerm.Tui/AliasesScreenRenderer.cs | 73 ++++- src/SharpMUTerm.Tui/AliasesScreenView.cs | 50 ++-- src/SharpMUTerm.Tui/KeypadScreenRenderer.cs | 109 ++++++- src/SharpMUTerm.Tui/KeypadScreenView.cs | 67 ++--- src/SharpMUTerm.Tui/ScreenChrome.cs | 240 ++++++++++++++++ src/SharpMUTerm.Tui/SharpMUTermApp.cs | 21 +- src/SharpMUTerm.Tui/TimersScreenRenderer.cs | 78 +++-- src/SharpMUTerm.Tui/TimersScreenView.cs | 47 ++- src/SharpMUTerm.Tui/TriggersScreenRenderer.cs | 127 ++++++++- src/SharpMUTerm.Tui/TriggersScreenView.cs | 46 ++- src/SharpMUTerm.Tui/WorldsScreenRenderer.cs | 52 +++- src/SharpMUTerm.Tui/WorldsScreenView.cs | 22 +- .../AliasesScreenRendererTests.cs | 18 ++ .../ScreenLayoutTests.cs | 267 ++++++++++++++++++ .../TimersScreenRendererTests.cs | 18 ++ .../TriggersScreenRendererTests.cs | 81 ++++++ .../WorldsScreenRendererTests.cs | 59 +++- 19 files changed, 1226 insertions(+), 214 deletions(-) create mode 100644 tests/SharpMUTerm.Tui.Tests/ScreenLayoutTests.cs diff --git a/CLAUDE.md b/CLAUDE.md index d89c4710..12e633f6 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -32,7 +32,7 @@ fallbacks) for inline images/maps. ## Repository state **M1 delivered, plus substantial M2–M4 work.** `SharpMUTerm.slnx` builds all ten projects on -`net10.0`; the solution has **1101 tests**, all passing. In place: +`net10.0`; the solution has **1119 tests**, all passing. In place: - **Core** — `AnsiParser` (SGR 16/256/truecolor), styled-line + `ScrollbackBuffer` model, `TcpTransport` (TLS + IPv6), `TelnetSession` (wraps TelnetNegotiationCore **2.5.3**), diff --git a/docs/HANDOFF.md b/docs/HANDOFF.md index 4d388344..742c7421 100644 --- a/docs/HANDOFF.md +++ b/docs/HANDOFF.md @@ -4,8 +4,8 @@ Context for whoever (human or agent) picks up this work next. - **Repository:** `SharpMUSH/SharpMUTerm` - **Start from:** a fresh branch off `main` -- **Tests:** 1101 across the solution (404 Core / 83 Graphics / 42 Scripting / - 28 Web / 544 Tui), all passing; `dotnet build SharpMUTerm.slnx` clean (0 warnings +- **Tests:** 1119 across the solution (404 Core / 83 Graphics / 42 Scripting / + 28 Web / 562 Tui), all passing; `dotnet build SharpMUTerm.slnx` clean (0 warnings from this repo; building against a local SharpConsoleUI clone surfaces 2 upstream NuGet advisory warnings for AngleSharp, which are the framework's, not ours) @@ -349,6 +349,65 @@ What the framework actually provides (read at v2.5.14, not assumed): - **Wiring is one table**, `SharpMUTermApp.SettingsScreens()`, read by both the global F-key shortcuts and the `--view` snapshot lookup. Add a screen there. +- **Panes are sized from the space available, not from constants.** Three pure + rules in `ScreenChrome`, pinned in `ScreenLayoutTests`: + - **`SplitWidth(width, desired, minimum, companion)`** — a two-column screen's + list column keeps its designed width when the screen can afford it and gives + cells back when it can't. It used to be a flat 56 (48 on F4), which was right + at 120 columns and wrong at 100: the editor lost its attribute legend off the + right, F4's binding rows lost their commands, and the list beside them was + two-thirds empty. Every view passes `width`; a caller with none (the merged + `Render` the renderer tests go through) gets the desired width unchanged, so + the width-agnostic form is exactly what it always was. + - **`Compact(block, height)`** — drops a block's blank separator rows, top-down, + until it fits. They are the first thing a short pane can spare. + - **`Window(block, height)`** — slices what is left down to the rows around the + **cursor band** `ScreenChrome.Cursor` paints (found the same way `Choices` + finds the caret), and labels the edges `⌃ n more` / `⌄ n more`. Centred, not + scrolled-into-view: these blocks are rebuilt from scratch on every keystroke, + so a stateless rule has to be a function of the cursor alone. + - **Order matters: compact → window → `Choices`.** The dropdown overlays rows + *by index*, so anything that moves a row has to happen before it is drawn. +- **`ScreenChrome.Split`** is the frame all four two-column screens now share + (F2/F3/F4/F6), and it sizes the body **to its content** with a `Star` spacer + under it rather than stretching it. That is what stops F3/F6/F4 drawing a + thirty-row empty pane under four rows of rules: the hairline ends where the + columns end, exactly as F7/F8's options card ends where its options do. +- **A list column ends in a key to its own glyphs** (`ScreenChrome.Legend` / + `LegendEntry`). F2's sub-row said `▪ Comms · H ✎ ⇥ ƒ` — four facts in five + cells — and nothing anywhere said what any of them meant; `on` as a column + header was barely a gloss on the tick it headed. The marks the *selected* row + carries are lit and the rest muted, so the block is a key and a reading of the + cursor's row at once (the same trick F2's attribute legend plays on the open + buffer). It goes at the foot of the list because the header names the row's + *columns* and these are the marks inside them — and because a list column's + slack is at the bottom. +- **F5's detail column no longer restates the world or the character.** The title + strip (`Aetherfall aetherfall.mux:4201 TLS on · UTF-8`) is gone: every token + of it was repeated in the five editable rows directly beneath, and the address + a third time in the WORLDS list. The CHARACTERS table is a **selector** — names + and the selection marker — because its `state`, `login` and `trigger sets` + columns were the CHARACTER form's `session` and `auto-login` rows and the + trigger-set pane beside them, drawn again. Two pinned assertions moved for + this; see below. +- **F4's numpad column is sized from its content** (`KeypadScreenRenderer.NumpadWidth`, + capped at `MaxNumpadCommandWidth`). The cell used to ellipsise at a constant ten + characters while the binding list two columns over drew the same command in + full — `[+1] look at a…` beside `→ look at altar` — with cells going spare at + 120 and 160 all along. **While a key capture is armed the diagram gives its + width up** (`KeypadScreenRenderer.CaptureWidth`): the prompt is twice as wide as + the key well it replaces, and the numpad is the one thing on that screen with + nothing to do with the keystroke being waited for. +- **F2's attribute legend is still drawn at rest — deliberately.** A dropdown + whose buffer matches nothing is two rows (caption + shadow), and opened from + `bg` it covers `attrs` and the legend's first row, leaving the second stranded + under the shadow. Drawing the legend only while `attrs` is open would trade a + transient, self-healing cosmetic fault for a permanent one: the legend is the + **only** place the vocabulary that field accepts is written down, which is what + `TriggersScreenActionsTests.TheAttributeLegendNamesEveryAttributeAndFollowsThe + Buffer` pins. Reordering the section so no dropdown can bisect it means putting + `attrs` above the two colours, which means moving the field ordinals — the one + thing these screens don't do. - Each screen is a pure **`*ScreenRenderer`** exposing its regions as markup blocks (`HeaderLine`, `FooterLine`, body columns) plus a **`*ScreenView`** that composes them into controls. The renderer's `Render(...)` merges the same blocks back diff --git a/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs b/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs index 0f0e17c1..c0fcbc21 100644 --- a/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/AliasesScreenRenderer.cs @@ -17,12 +17,30 @@ namespace SharpMUTerm.Tui; internal static class AliasesScreenRenderer { /// - /// Visible width of the left column. The view lays its column out at exactly this width, so - /// the two must agree -- a cursor bar padded narrower than its column leaves a gap before the - /// rule. Shared rather than duplicated so they cannot drift apart. + /// Visible width of the left column when the screen can afford it. The view lays its column out at + /// exactly the width it passes back in, so the two must agree -- a cursor bar padded narrower than + /// its column leaves a gap before the rule. Shared rather than duplicated so they cannot drift apart. /// internal const int ColumnWidth = 56; + /// The fewest cells the alias list is still worth drawing in. + internal const int MinColumnWidth = 40; + + /// The fewest cells the editor pane can be read in — its widest heading and then some. + internal const int MinEditorWidth = 32; + + /// + /// What the alias list's key is called, and the two marks it glosses. A row reads + /// ✓ ▸ say ^'(.*) ▪ Comms → say $1: the tick is the enabled state on heads without + /// really explaining, and the square is the owning set. Named constants because the row draws the + /// same glyphs and the key would otherwise be a second, drifting copy of them. + /// + private const string LegendLabel = "key"; + + private const string EnabledGlyph = "✓"; + + private const string SetGlyph = "▪"; + /// /// The alias row's field ordinals, in the order ⇥ steps through them. The name leads, as it does on /// every list screen: ⏎ on an alias — including one just created — opens the value that tells it @@ -205,8 +223,12 @@ internal static string FooterLine( } /// The alias list — every alias of every set, with its enabled state and expansion. + /// + /// How wide the column actually runs, which the cursor bars are padded to — the view gives cells + /// back to the editor on a narrow screen (see ). + /// internal static List ListColumn( - IReadOnlyList sets, int selected, ScreenFocus? focus = null) + IReadOnlyList sets, int selected, ScreenFocus? focus = null, int width = ColumnWidth) { ArgumentNullException.ThrowIfNull(sets); @@ -234,13 +256,23 @@ internal static List ListColumn( foreach (var alias in set.Aliases) { lines.Add(ScreenChrome.Cursor( - Row(alias, set.Name, index == selected), cursor.IsOn(0, index), ColumnWidth)); + Row(alias, set.Name, index == selected), cursor.IsOn(0, index), width)); index++; } } lines.Add(string.Empty); - lines.AddRange(ScreenChrome.Buttons(Buttons(sets, selected), cursor, 0, entries.Count, ColumnWidth)); + lines.AddRange(ScreenChrome.Buttons(Buttons(sets, selected), cursor, 0, entries.Count, width)); + lines.Add(string.Empty); + var picked = selected >= 0 && selected < entries.Count ? entries[selected].Alias : null; + lines.AddRange(ScreenChrome.Legend( + LegendLabel, + new[] + { + ScreenChrome.LegendEntry(EnabledGlyph, "enabled", picked?.Enabled ?? false), + ScreenChrome.LegendEntry(SetGlyph, "set", picked is not null), + }, + width)); return lines; } @@ -248,15 +280,21 @@ internal static List ListColumn( /// The editor for the selected alias — pattern, expansion lines, and the case-sensitivity /// toggle. Empty when nothing is selected. /// + /// How wide the pane runs, which its cursor bars and dropdowns are sized to. + /// How many rows the pane has, or 0 when the caller has none. internal static List EditorColumn( - IReadOnlyList sets, int selected, ScreenFocus? focus = null) + IReadOnlyList sets, + int selected, + ScreenFocus? focus = null, + int width = ColumnWidth, + int height = 0) { ArgumentNullException.ThrowIfNull(sets); var cursor = focus ?? ScreenFocus.None; var entries = Flatten(sets); return selected >= 0 && selected < entries.Count - ? BuildEditor(entries[selected].Alias, entries[selected].SetName, cursor, selected) + ? BuildEditor(entries[selected].Alias, entries[selected].SetName, cursor, selected, width, height) : new List(); } @@ -285,7 +323,13 @@ private static string Row(Alias alias, string setName, bool selected) return $"{check} {marker} [bold]{name}[/] [dim]{pattern}[/] [dim]▪ {Escape(setName)}[/] → {expansion}"; } - private static List BuildEditor(Alias alias, string setName, ScreenFocus cursor, int selected) + private static List BuildEditor( + Alias alias, + string setName, + ScreenFocus cursor, + int selected, + int width = ColumnWidth, + int height = 0) { var set = cursor.EditOn(0, selected, SetField); @@ -319,17 +363,20 @@ private static List BuildEditor(Alias alias, string setName, ScreenFocus // Listed, the expansion is still one editable value, so it still gets one field well — // every row padded to the longest, or the well would be ragged and read as several. var commands = alias.Substitution.Split('\n').Select(Escape).ToList(); - var width = commands.Count == 0 ? 0 : commands.Max(c => VisibleLength(c)); - lines.AddRange(commands.Select(c => " " + ScreenChrome.Field(PadVisible(c, width), null))); + var longest = commands.Count == 0 ? 0 : commands.Max(c => VisibleLength(c)); + lines.AddRange(commands.Select(c => " " + ScreenChrome.Field(PadVisible(c, longest), null))); } lines.Add(string.Empty); var caseRow = alias.CaseSensitive ? $"[{Accent}][[x]][/] case sensitive" : "[dim][[ ]] case sensitive[/]"; - lines.Add(ScreenChrome.Cursor(caseRow, cursor.IsOn(1, 0), ColumnWidth)); + lines.Add(ScreenChrome.Cursor(caseRow, cursor.IsOn(1, 0), width)); - return ScreenChrome.Choices(lines, cursor.Edit, ColumnWidth); + // Compacted before the dropdown is laid over it: the overlay replaces rows by index, so dropping + // a blank underneath it afterwards would slide the list off the field it belongs to. + ScreenChrome.Compact(lines, height); + return ScreenChrome.Choices(lines, cursor.Edit, width); } private static string FirstLine(string text) diff --git a/src/SharpMUTerm.Tui/AliasesScreenView.cs b/src/SharpMUTerm.Tui/AliasesScreenView.cs index 629e5f59..e4dfd743 100644 --- a/src/SharpMUTerm.Tui/AliasesScreenView.cs +++ b/src/SharpMUTerm.Tui/AliasesScreenView.cs @@ -1,8 +1,6 @@ using SharpMUTerm.Core.Configuration; using SharpConsoleUI; -using SharpConsoleUI.Builders; using SharpConsoleUI.Controls; -using SharpConsoleUI.Layout; namespace SharpMUTerm.Tui; @@ -11,44 +9,34 @@ namespace SharpMUTerm.Tui; /// header band carrying the keyboard hints, a body whose alias-list panel and editor panel are /// separated by a vertical rule, and a Cancel/Save action bar pinned to the last row. The markup for /// each panel comes from the pure so the content stays -/// unit-tested; this only lays it out. +/// unit-tested; this only lays it out (through , which every +/// two-column screen shares). /// internal static class AliasesScreenView { - private const int ListColumnWidth = AliasesScreenRenderer.ColumnWidth; - public static IWindowControl Build( - IReadOnlyList sets, int selected, int width, ScreenFocus? focus = null) + IReadOnlyList sets, int selected, int width, ScreenFocus? focus = null, int height = 0) { var header = ScreenChrome.Band( AliasesScreenRenderer.HeaderLine(width, AliasesScreenRenderer.Model(sets, selected), focus), ScreenPalette.HeaderBg); - var footer = ScreenChrome.Band(AliasesScreenRenderer.FooterLine(sets, selected, width, focus), ScreenPalette.FooterBg); - - // Body: alias list │ editor, as two real columns. - var listCol = ScreenChrome.Stretch( - new MarkupControl(AliasesScreenRenderer.ListColumn(sets, selected, focus))); - var editorCol = ScreenChrome.Stretch( - new MarkupControl(ScreenChrome.Indent(AliasesScreenRenderer.EditorColumn(sets, selected, focus)))); - var body = Controls.HorizontalGrid() - .WithAlignment(HorizontalAlignment.Stretch) - .WithVerticalAlignment(VerticalAlignment.Fill) - .Column(c => c.Width(ListColumnWidth).Add(listCol)) - .Column(c => c.Width(1).Add(ScreenChrome.VerticalRule())) - .Column(c => c.Width(1).Add(ScreenChrome.Filler())) - .Column(c => c.Flex(1).Add(editorCol)) - .Build(); + var footer = ScreenChrome.Band( + AliasesScreenRenderer.FooterLine(sets, selected, width, focus), ScreenPalette.FooterBg); - // Header on the first row, footer on the last, body taking everything between — so the action - // bar sits at the bottom of the screen instead of trailing the content. - var root = Controls.Grid() - .WithAlignment(HorizontalAlignment.Stretch) - .WithVerticalAlignment(VerticalAlignment.Fill); - root.Rows(GridLength.Cells(1), GridLength.Star(1), GridLength.Cells(1)).Columns(GridLength.Star(1)); - root.Place(header, 0, 0, 1, 1); - root.Place(body, 1, 0, 1, 1); - root.Place(footer, 2, 0, 1, 1); + var list = ScreenChrome.SplitWidth( + width, + AliasesScreenRenderer.ColumnWidth, + AliasesScreenRenderer.MinColumnWidth, + AliasesScreenRenderer.MinEditorWidth); + var rows = ScreenChrome.Rows(height); + var left = AliasesScreenRenderer.ListColumn(sets, selected, focus, list); + var right = AliasesScreenRenderer.EditorColumn( + sets, selected, focus, width <= 0 ? list : width - list - ScreenChrome.ColumnDivider, rows); - return root.Build(); + var listCol = ScreenChrome.Stretch(new MarkupControl(ScreenChrome.Window(left, rows))); + var editorCol = ScreenChrome.Stretch( + new MarkupControl(ScreenChrome.Indent(ScreenChrome.Window(right, rows)))); + return ScreenChrome.Split( + header, footer, listCol, editorCol, list, Math.Max(left.Count, right.Count), rows); } } diff --git a/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs b/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs index 0d618b38..862902f4 100644 --- a/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/KeypadScreenRenderer.cs @@ -34,6 +34,27 @@ internal static class KeypadScreenRenderer /// private const int HotkeysColumnWidth = 64; + /// + /// The fewest cells the binding list can be read in: four wells (tick, key, name, set) and then the + /// command, which is the one value on the row with no width worth guessing. Below this the command + /// is cut off — which is the exact failure the numpad grid beside it was already committing, and + /// committing it in both columns at once is not a fix. + /// + internal const int MinHotkeysWidth = 57; + + /// + /// What an armed key capture adds to the widest binding row: the prompt + /// (, in its accent block) less the key well it replaces. + /// The row's other four values are still drawn beside it, so while a capture is up the list needs + /// this much more than its resting minimum — and gets it from the numpad diagram, which is the one + /// thing on the screen that has nothing to do with the keystroke being waited for. + /// + internal static int CaptureWidth => + MinHotkeysWidth + ScreenChrome.CapturePrompt.Length + 2 - KeyColumnWidth - 1; + + /// The fewest cells the numpad diagram is still a diagram in. + internal const int MinNumpadWidth = 34; + /// Visible width the binding list's name column is padded to, so the arrows line up. private const int NameColumnWidth = 12; @@ -81,11 +102,27 @@ internal static class KeypadScreenRenderer private const string NewBindingCommand = "look"; - /// Longest command shown inside a numpad cell before it is ellipsised. + /// + /// Longest command a numpad cell shows when the column has no width to reason from — the merged + /// , which pads to and has no screen behind it. + /// private const int NumpadCommandWidth = 10; - /// Visible width of one numpad cell: "[N] " (4) plus . - private const int NumpadCellWidth = 4 + NumpadCommandWidth; + /// + /// The most cells a numpad cell will ever spend on a command. The grid is a diagram of nine + /// keys, not a command line: past this it stops being a picture of the keypad and starts being a + /// third list, and every cell it takes comes out of the binding rows beside it. + /// + private const int MaxNumpadCommandWidth = 14; + + /// The fewest cells a numpad cell is worth drawing a command in at all. + private const int MinNumpadCommandWidth = 6; + + /// What a numpad row spends on chrome: three "[N] " prefixes and the two gaps between. + private const int NumpadRowChrome = (3 * 4) + (2 * 3); + + /// Visible width of one numpad cell: "[N] " (4) plus the command width in force. + private static int CellWidth(int command) => 4 + command; private const string NumpadCellGap = " "; @@ -96,6 +133,39 @@ internal static class KeypadScreenRenderer new[] { 1, 2, 3 }, }; + /// + /// How wide the numpad grid wants to be: enough for the longest command actually bound to a + /// digit, so the diagram stops ellipsising a command the binding list draws in full two columns + /// over. That asymmetry was the complaint — [[1]] look at a… beside → look at altar, + /// the same value truncated on one side of a hairline and not the other — and it came of a + /// constant cell width beside a variable one, not of a shortage of screen: at 120 and 160 + /// columns there were cells going spare all along. + /// + /// It is what the grid asks for, not what it gets. takes cells + /// back when the binding list would otherwise lose its commands off the right-hand edge, which is + /// what happens at 100 columns — and there both columns truncate, which is at least the same answer + /// twice. + /// + /// + internal static int NumpadWidth(IReadOnlyList macros) + { + ArgumentNullException.ThrowIfNull(macros); + + var longest = MinNumpadCommandWidth; + foreach (var row in NumpadRows) + { + foreach (var digit in row) + { + if (FindByKey(macros, $"Num{digit}") is { } macro) + { + longest = Math.Max(longest, macro.Command.Length); + } + } + } + + return (3 * Math.Min(longest, MaxNumpadCommandWidth)) + NumpadRowChrome; + } + /// /// Merges every sub-block into one line list (header, numpad | hotkeys, footer). Used by the /// unit tests and as a width-agnostic fallback; the live view composes the same blocks into @@ -345,25 +415,36 @@ internal static string FooterLine( /// could one day deliver the numpad would drop the disclaimer without anyone remembering to. /// /// - internal static List NumpadColumn(IReadOnlyList macros) + /// + /// How wide the column actually runs. The cells divide it between them, so a wide screen draws the + /// whole command and a narrow one ellipsises it — rather than every screen ellipsising at ten + /// characters because that was the width the grid was first drawn at. + /// + internal static List NumpadColumn(IReadOnlyList macros, int width = 0) { ArgumentNullException.ThrowIfNull(macros); + var command = width <= 0 + ? NumpadCommandWidth + : Math.Clamp((width - NumpadRowChrome) / 3, MinNumpadCommandWidth, MaxNumpadCommandWidth); + var lines = new List { $"[dim]NUMPAD[/]{Caveat(MacroKeys.Verdict("Num5"))}" }; foreach (var row in NumpadRows) { - lines.Add(NumpadRow(row, macros)); + lines.Add(NumpadRow(row, macros, command)); } return lines; } /// The binding list — every macro with its enabled state, key, name, and command. + /// How wide the column runs, which its cursor bars and dropdown are sized to. internal static List HotkeysColumn( IReadOnlyList macros, ScreenFocus? focus = null, IReadOnlyList? sets = null, - int selected = -1) + int selected = -1, + int width = HotkeysColumnWidth) { ArgumentNullException.ThrowIfNull(macros); @@ -385,7 +466,7 @@ internal static List HotkeysColumn( cursor.EditOn(0, i, KeyField), cursor.EditOn(0, i, SetField)), cursor.IsOn(0, i), - HotkeysColumnWidth)); + width)); } // A set holding no bindings owns none of the rows above and would otherwise be drawn nowhere at @@ -401,21 +482,21 @@ internal static List HotkeysColumn( lines.Add(string.Empty); lines.AddRange(ScreenChrome.Buttons( - Buttons(sets, selected), cursor, 0, macros.Count, HotkeysColumnWidth)); - return ScreenChrome.Choices(lines, cursor.Edit, HotkeysColumnWidth); + Buttons(sets, selected), cursor, 0, macros.Count, width)); + return ScreenChrome.Choices(lines, cursor.Edit, width); } - private static string NumpadRow(int[] digits, IReadOnlyList macros) + private static string NumpadRow(int[] digits, IReadOnlyList macros, int command) { var cells = new string[digits.Length]; for (var i = 0; i < digits.Length; i++) { - var cell = NumpadCell(digits[i], macros); + var cell = NumpadCell(digits[i], macros, command); // Every cell is padded to the same visible width so the three columns line up whatever // is bound: a cell is as wide as "[N] " plus the longest command it can hold. The last // cell in a row is left unpadded to avoid trailing whitespace. - cells[i] = i == digits.Length - 1 ? cell : PadVisible(cell, NumpadCellWidth); + cells[i] = i == digits.Length - 1 ? cell : PadVisible(cell, CellWidth(command)); } return string.Join(NumpadCellGap, cells); @@ -426,12 +507,12 @@ private static string NumpadRow(int[] digits, IReadOnlyList macros) /// the binding list beside it and has no cursor of its own, so a cell is somewhere a command is /// *shown*, never somewhere one is typed. See . /// - private static string NumpadCell(int digit, IReadOnlyList macros) + private static string NumpadCell(int digit, IReadOnlyList macros, int width) { var macro = FindByKey(macros, $"Num{digit}"); var command = macro is null ? "[dim]—[/]" - : ScreenChrome.ReadOnly(Truncate(macro.Command, NumpadCommandWidth)); + : ScreenChrome.ReadOnly(Truncate(macro.Command, width)); return $"[bold {Accent}][[{digit}]][/] {command}"; } diff --git a/src/SharpMUTerm.Tui/KeypadScreenView.cs b/src/SharpMUTerm.Tui/KeypadScreenView.cs index bd4317af..10ec3420 100644 --- a/src/SharpMUTerm.Tui/KeypadScreenView.cs +++ b/src/SharpMUTerm.Tui/KeypadScreenView.cs @@ -1,9 +1,7 @@ using SharpMUTerm.Core.Automation; using SharpMUTerm.Core.Configuration; using SharpConsoleUI; -using SharpConsoleUI.Builders; using SharpConsoleUI.Controls; -using SharpConsoleUI.Layout; namespace SharpMUTerm.Tui; @@ -11,26 +9,25 @@ namespace SharpMUTerm.Tui; /// Composes the F4 Keypad & hotkeys screen from real panels (grids) rather than one merged markup /// blob: a header band carrying the keyboard hints, a body whose numpad-grid panel and hotkey-list /// panel are separated by a vertical rule, and a Cancel/Save action bar pinned to the last row. The -/// numpad is the fixed-width column (its 3×3 grid has a natural size), the hotkey list takes the -/// rest. The markup for each panel comes from the pure so the -/// content stays unit-tested; this only lays it out. +/// markup for each panel comes from the pure so the content stays +/// unit-tested; this only lays it out (through , which every +/// two-column screen shares). +/// +/// The numpad column asks for the width its longest bound command needs +/// () instead of the fixed 48 it used to take, and gives +/// cells back when the binding list would otherwise lose its commands off the edge. A constant here +/// was what let the diagram draw [[1]] look at a… beside the same command in full. +/// /// internal static class KeypadScreenView { - /// - /// The numpad column's width — its 3×3 grid measures exactly this (three cells of "[[N]] " plus a - /// command, two gaps between them), so anything wider is slack taken from the binding list beside - /// it. That list is the one that needs it: a binding row carries four wells and a command, and its - /// widest state is an armed key capture whose prompt is twice the width of the key it replaces. - /// - private const int NumpadColumnWidth = 48; - public static IWindowControl Build( IReadOnlyList macros, IReadOnlyList sets, int selected, int width, - ScreenFocus? focus = null) + ScreenFocus? focus = null, + int height = 0) { var header = ScreenChrome.Band( KeypadScreenRenderer.HeaderLine(width, KeypadScreenRenderer.Model(macros, sets, selected), focus), @@ -38,29 +35,25 @@ public static IWindowControl Build( var footer = ScreenChrome.Band( KeypadScreenRenderer.FooterLine(macros, width, focus, selected), ScreenPalette.FooterBg); - // Body: numpad grid │ hotkey list, as two real columns. - var numpadCol = ScreenChrome.Stretch(new MarkupControl(KeypadScreenRenderer.NumpadColumn(macros))); - var hotkeysCol = ScreenChrome.Stretch(new MarkupControl( - ScreenChrome.Indent(KeypadScreenRenderer.HotkeysColumn(macros, focus, sets, selected)))); - var body = Controls.HorizontalGrid() - .WithAlignment(HorizontalAlignment.Stretch) - .WithVerticalAlignment(VerticalAlignment.Fill) - .Column(c => c.Width(NumpadColumnWidth).Add(numpadCol)) - .Column(c => c.Width(1).Add(ScreenChrome.VerticalRule())) - .Column(c => c.Width(1).Add(ScreenChrome.Filler())) - .Column(c => c.Flex(1).Add(hotkeysCol)) - .Build(); - - // Header on the first row, footer on the last, body taking everything between — so the action - // bar sits at the bottom of the screen instead of trailing the content. - var root = Controls.Grid() - .WithAlignment(HorizontalAlignment.Stretch) - .WithVerticalAlignment(VerticalAlignment.Fill); - root.Rows(GridLength.Cells(1), GridLength.Star(1), GridLength.Cells(1)).Columns(GridLength.Star(1)); - root.Place(header, 0, 0, 1, 1); - root.Place(body, 1, 0, 1, 1); - root.Place(footer, 2, 0, 1, 1); + // While a key capture is armed the binding row swaps its key well for a prompt twice the width, + // so the list asks for more and the diagram gives it up for as long as the prompt is up. The + // numpad is the one thing on this screen with nothing to do with the keystroke being waited for. + var numpad = ScreenChrome.SplitWidth( + width, + KeypadScreenRenderer.NumpadWidth(macros), + KeypadScreenRenderer.MinNumpadWidth, + focus?.Edit is { Capture: true } + ? KeypadScreenRenderer.CaptureWidth + : KeypadScreenRenderer.MinHotkeysWidth); + var rows = ScreenChrome.Rows(height); + var left = KeypadScreenRenderer.NumpadColumn(macros, numpad); + var right = KeypadScreenRenderer.HotkeysColumn( + macros, focus, sets, selected, width <= 0 ? numpad : width - numpad - ScreenChrome.ColumnDivider); - return root.Build(); + var numpadCol = ScreenChrome.Stretch(new MarkupControl(ScreenChrome.Window(left, rows))); + var hotkeysCol = ScreenChrome.Stretch( + new MarkupControl(ScreenChrome.Indent(ScreenChrome.Window(right, rows)))); + return ScreenChrome.Split( + header, footer, numpadCol, hotkeysCol, numpad, Math.Max(left.Count, right.Count), rows); } } diff --git a/src/SharpMUTerm.Tui/ScreenChrome.cs b/src/SharpMUTerm.Tui/ScreenChrome.cs index 218ceb83..1a832c5b 100644 --- a/src/SharpMUTerm.Tui/ScreenChrome.cs +++ b/src/SharpMUTerm.Tui/ScreenChrome.cs @@ -147,6 +147,124 @@ internal static string Actions(string? accent = null, ScreenFocus? focus = null) internal static string Cursor(string row, bool focused, int width) => focused ? $"[on {ScreenPalette.CursorBg}]{MarkupText.PadVisible(row, width)}[/]" : row; + /// + /// The cursor band paints, which is what scrolls to. It is + /// found the same way finds the block caret, and for the same reason: exactly + /// one row of one pane carries it, so a column can locate its own focused row without every renderer + /// having to hand back the line number it drew it on. + /// + private static readonly string CursorMark = $"[on {ScreenPalette.CursorBg}]"; + + /// The two cells a body column spends on the hairline and the gap beside it. + internal const int ColumnDivider = 2; + + /// + /// How wide a two-column screen's list column actually runs, given the width the screen was handed. + /// The split used to be a constant on every one of them, which was right at the width they were + /// designed at and wrong at every other: at 100 columns the list kept its full share while the + /// column beside it — the one carrying the editor, or the binding rows — lost its tail off the + /// right-hand edge. + /// + /// The rule is " unless that would starve the other column": the list gets + /// what it wants when there is room, gives cells back when there isn't, and never drops below + /// , because past that point both columns are unreadable rather than one. + /// A caller with no width to spend (the merged Render the unit tests go through) gets the + /// desired width unchanged, so the width-agnostic form is exactly what it always was. + /// + /// + /// The whole screen's width, or 0 when the caller has none. + /// What the list column takes when the screen can afford it. + /// The fewest cells the list column is still worth drawing in. + /// The fewest cells the column beside it can be read in. + internal static int SplitWidth(int width, int desired, int minimum, int companion) => + width <= 0 ? desired : Math.Clamp(width - ColumnDivider - companion, minimum, desired); + + /// + /// Drops a block's blank separator rows until it fits in rows, and hands + /// it back. The separators are the first thing a short pane can spare: they carry no content at all, + /// and every row they cost at the top is a row the pane loses off the bottom — where the checkboxes, + /// the buttons and the rest of the cursor's stops live. + /// + /// They go from the top down, so the section that compacts is the one already on screen rather than + /// the one about to fall off it. A block that already fits, or a caller with no height to fit it + /// into, comes back untouched — which is what keeps the wide case looking exactly as it did. + /// + /// + internal static List Compact(List block, int height) + { + ArgumentNullException.ThrowIfNull(block); + + if (height <= 0) + { + return block; + } + + for (var i = 0; i < block.Count && block.Count > height; i++) + { + if (block[i].Length == 0) + { + block.RemoveAt(i--); + } + } + + return block; + } + + /// What a windowed block says stands above it, and below it, in place of a drawn row. + private const string MoreAbove = "⌃"; + + private const string MoreBelow = "⌄"; + + /// + /// Slices a block down to rows around the row carrying the cursor band, so + /// a pane taller than the screen still shows the row the keyboard is on. Without it a cursor can be + /// moved onto a row that was never drawn — F5 at 100×24 put its whole CHARACTERS list, and the + /// add/duplicate/remove buttons under it, below the fold while ↑↓ walked happily through them. + /// + /// The window is centred on the focused row rather than scrolled minimally into view, because these + /// blocks are rebuilt from scratch on every keystroke and there is no previous offset to scroll from + /// — a stateless rule has to be a function of the cursor alone. A block with no cursor in it (the + /// keyboard is in another pane) shows its top, which is where its own heading is. + /// + /// + /// The edges say what they are hiding. A row silently missing from a pane is the same failure as a + /// cursor stop that was never drawn, one level up: the screen would be showing part of a list and + /// claiming it was the list. + /// + /// + internal static List Window(List block, int height) + { + ArgumentNullException.ThrowIfNull(block); + + if (height <= 0 || block.Count <= height) + { + return block; + } + + var focused = block.FindIndex(l => l.Contains(CursorMark, StringComparison.Ordinal)); + var start = focused < 0 + ? 0 + : Math.Clamp(focused - (height / 2), 0, block.Count - height); + + var window = block.GetRange(start, height); + if (start > 0) + { + window[0] = More(MoreAbove, start); + } + + var below = block.Count - start - height; + if (below > 0) + { + window[^1] = More(MoreBelow, below); + } + + return window; + } + + /// How a windowed block names the rows it is not drawing, on the edge they are past. + private static string More(string arrow, int count) => + $" [{ScreenPalette.Muted}]{arrow} {count.ToString(CultureInfo.InvariantCulture)} more[/]"; + /// /// Draws a row's editable value: its committed text in a field well when nothing is being typed, /// or — when is the open edit for that field — the buffer in that same @@ -406,6 +524,61 @@ private static string Shadow(int inner) => /// internal static string ReadOnly(string text) => $"[{ScreenPalette.Muted}]{MarkupText.Escape(text)}[/]"; + /// How far a legend's continuation rows are indented, to clear its label. + internal const int LegendLabel = 7; + + /// + /// Spells out the glyphs a list's rows are written in, at the foot of the column that draws them. + /// The list screens compress a rule down to single cells — a tick, a set marker, and on F2 a strip + /// of action letters — and a compressed value is the one thing that cannot say what its own words + /// mean. Nothing on these screens said, anywhere: H could as easily have been "hidden" as + /// "highlight". + /// + /// It goes at the foot of the list, not beside the header: the header names the row's columns + /// (on name / pattern → window) and these are the marks inside them, and the slack + /// in a list column is at the bottom — which is exactly the dead space a key is worth spending. + /// Entries wrap to rather than to a fixed count, because the column is a + /// function of the screen's width now (see ). + /// + /// + /// What the block is called, drawn on its first row only. + /// The entries, already coloured — lit when they describe the selected row. + /// The column's width, which the block wraps to. + internal static IEnumerable Legend(string label, IEnumerable cells, int width) + { + ArgumentNullException.ThrowIfNull(label); + ArgumentNullException.ThrowIfNull(cells); + + var line = $"[{ScreenPalette.Label}]{MarkupText.Escape(label)}[/]" + + new string(' ', Math.Max(1, LegendLabel - label.Length)); + var used = LegendLabel; + + foreach (var cell in cells) + { + var cellWidth = MarkupText.VisibleLength(cell) + 2; + if (used > LegendLabel && width > 0 && used + cellWidth > width) + { + yield return line.TrimEnd(); + line = new string(' ', LegendLabel); + used = LegendLabel; + } + + line += cell + " "; + used += cellWidth; + } + + yield return line.TrimEnd(); + } + + /// + /// One entry of a : its glyph and what the glyph means, lit when the selected + /// row carries it and muted when it doesn't. Lighting them is what turns a key into a reading of the + /// row the cursor is on, which is the same trick F2's attribute legend plays on the open buffer. + /// + internal static string LegendEntry(string glyph, string meaning, bool lit) => lit + ? $"[{ScreenPalette.Accent}]{glyph}[/] [{ScreenPalette.Value}]{MarkupText.Escape(meaning)}[/]" + : $"[{ScreenPalette.Label}]{glyph} {MarkupText.Escape(meaning)}[/]"; + /// /// The one row an empty trigger set gets in a flattened pane. F2, F3, F4 and F6 each draw /// one column of every set's rules, so a set holding none of that kind is drawn nowhere at all — and @@ -499,6 +672,73 @@ internal static string Context(params string?[] parts) HorizontalAlignment = HorizontalAlignment.Stretch, }; + /// + /// How many rows a two-column screen's body has: everything but the header band and the action bar. + /// Zero when the caller has no height, which is how every block below reads "draw it all". + /// + internal static int Rows(int height) => height <= 0 ? 0 : Math.Max(1, height - 2); + + /// + /// The frame every two-column settings screen shares: a header band on the first row, an action bar + /// on the last, and between them a body of two columns divided by a hairline. + /// + /// The body is sized to its content rather than stretched to fill, which is the single + /// change that stops F3, F6 and F4 drawing a thirty-row empty pane under four rows of rules. The + /// hairline stops where the columns stop, exactly as F7/F8's options card ends where its options do, + /// and the slack below it belongs to the backdrop instead of pretending to be part of a list. A + /// caller with no height falls back to the old fill, since there is nothing to size against. + /// + /// + /// The header band. + /// The action bar. + /// The list column. + /// The column beside it. + /// How wide the list column runs (see ). + /// How many rows the taller of the two columns holds. + /// How many rows the body has to spend, or 0 when the caller has no height. + internal static IWindowControl Split( + MarkupControl header, + MarkupControl footer, + MarkupControl left, + MarkupControl right, + int leftWidth, + int content, + int rows) + { + var body = Controls.HorizontalGrid() + .WithAlignment(HorizontalAlignment.Stretch) + .WithVerticalAlignment(VerticalAlignment.Fill) + .Column(c => c.Width(leftWidth).Add(left)) + .Column(c => c.Width(1).Add(VerticalRule())) + .Column(c => c.Width(1).Add(Filler())) + .Column(c => c.Flex(1).Add(right)) + .Build(); + + var root = Controls.Grid() + .WithAlignment(HorizontalAlignment.Stretch) + .WithVerticalAlignment(VerticalAlignment.Fill); + + if (rows <= 0) + { + root.Rows(GridLength.Cells(1), GridLength.Star(1), GridLength.Cells(1)).Columns(GridLength.Star(1)); + root.Place(header, 0, 0, 1, 1); + root.Place(body, 1, 0, 1, 1); + root.Place(footer, 2, 0, 1, 1); + return root.Build(); + } + + root.Rows( + GridLength.Cells(1), + GridLength.Cells(Math.Clamp(content, 1, rows)), + GridLength.Star(1), + GridLength.Cells(1)) + .Columns(GridLength.Star(1)); + root.Place(header, 0, 0, 1, 1); + root.Place(body, 1, 0, 1, 1); + root.Place(footer, 3, 0, 1, 1); + return root.Build(); + } + /// Widens a column panel to its arranged width so its content isn't hugged. internal static MarkupControl Stretch(MarkupControl control) { diff --git a/src/SharpMUTerm.Tui/SharpMUTermApp.cs b/src/SharpMUTerm.Tui/SharpMUTermApp.cs index 83b0052f..9a9e57b2 100644 --- a/src/SharpMUTerm.Tui/SharpMUTermApp.cs +++ b/src/SharpMUTerm.Tui/SharpMUTermApp.cs @@ -1133,7 +1133,8 @@ private ScreenBinding WorldsScreen(string fkey, bool onCharacters) _system.DesktopDimensions.Width, session.Focus(), fkey, - session.Selection.SelectionIn(WorldsScreenRenderer.TriggerSetsPane))); + session.Selection.SelectionIn(WorldsScreenRenderer.TriggerSetsPane), + _system.DesktopDimensions.Height)); } /// @@ -1152,7 +1153,8 @@ private ScreenBinding TriggersScreen() session.Selection.SelectionIn(0), SpawnTargets(), _system.DesktopDimensions.Width, - session.Focus())); + session.Focus(), + _system.DesktopDimensions.Height)); } /// Opens the F3 Aliases screen: the alias list, then the alias's toggles. @@ -1162,7 +1164,11 @@ private ScreenBinding AliasesScreen() AliasesScreenRenderer.Model(_config.TriggerSets, selection.SelectionIn(0))); return new ScreenBinding(session, () => AliasesScreenView.Build( - _config.TriggerSets, session.Selection.SelectionIn(0), _system.DesktopDimensions.Width, session.Focus())); + _config.TriggerSets, + session.Selection.SelectionIn(0), + _system.DesktopDimensions.Width, + session.Focus(), + _system.DesktopDimensions.Height)); } /// @@ -1180,7 +1186,8 @@ private ScreenBinding KeypadScreen() _config.TriggerSets, session.Selection.SelectionIn(0), _system.DesktopDimensions.Width, - session.Focus())); + session.Focus(), + _system.DesktopDimensions.Height)); } /// Opens the F6 Timers screen: the timer list, then the timer's toggles. @@ -1190,7 +1197,11 @@ private ScreenBinding TimersScreen() TimersScreenRenderer.Model(_config.TriggerSets, selection.SelectionIn(0))); return new ScreenBinding(session, () => TimersScreenView.Build( - _config.TriggerSets, session.Selection.SelectionIn(0), _system.DesktopDimensions.Width, session.Focus())); + _config.TriggerSets, + session.Selection.SelectionIn(0), + _system.DesktopDimensions.Width, + session.Focus(), + _system.DesktopDimensions.Height)); } /// Opens the F7 Text & ANSI screen, bound to the app's text preferences. diff --git a/src/SharpMUTerm.Tui/TimersScreenRenderer.cs b/src/SharpMUTerm.Tui/TimersScreenRenderer.cs index 2d8d23da..74e5f3b1 100644 --- a/src/SharpMUTerm.Tui/TimersScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/TimersScreenRenderer.cs @@ -18,12 +18,30 @@ namespace SharpMUTerm.Tui; internal static class TimersScreenRenderer { /// - /// Visible width of the left column. The view lays its column out at exactly this width, so - /// the two must agree -- a cursor bar padded narrower than its column leaves a gap before the - /// rule. Shared rather than duplicated so they cannot drift apart. + /// Visible width of the left column when the screen can afford it. The view lays its column out at + /// exactly the width it passes back in, so the two must agree -- a cursor bar padded narrower than + /// its column leaves a gap before the rule. Shared rather than duplicated so they cannot drift apart. /// internal const int ColumnWidth = 56; + /// The fewest cells the timer list is still worth drawing in. + internal const int MinColumnWidth = 40; + + /// The fewest cells the editor pane can be read in — its widest heading and then some. + internal const int MinEditorWidth = 32; + + /// + /// What the timer list's key is called, and the two marks it glosses. A row reads + /// ✓ ▸ keepalive every 60s ▪ Comms → @@idle: the tick is the enabled state on heads + /// without really explaining, and the square is the owning set. Named constants because the row + /// draws the same glyphs and the key would otherwise be a second, drifting copy of them. + /// + private const string LegendLabel = "key"; + + private const string EnabledGlyph = "✓"; + + private const string SetGlyph = "▪"; + /// /// The timer row's field ordinals, in the order ⇥ steps through them. The name leads, as it does on /// every list screen: ⏎ on a timer — including one just created — opens the value that tells it @@ -208,8 +226,12 @@ internal static string FooterLine( } /// The timer list — every timer of every set, with its enabled state and schedule. + /// + /// How wide the column actually runs, which the cursor bars are padded to — the view gives cells + /// back to the editor on a narrow screen (see ). + /// internal static List ListColumn( - IReadOnlyList sets, int selected, ScreenFocus? focus = null) + IReadOnlyList sets, int selected, ScreenFocus? focus = null, int width = ColumnWidth) { ArgumentNullException.ThrowIfNull(sets); @@ -237,13 +259,23 @@ internal static List ListColumn( foreach (var timer in set.Timers) { lines.Add(ScreenChrome.Cursor( - Row(timer, set.Name, index == selected), cursor.IsOn(0, index), ColumnWidth)); + Row(timer, set.Name, index == selected), cursor.IsOn(0, index), width)); index++; } } lines.Add(string.Empty); - lines.AddRange(ScreenChrome.Buttons(Buttons(sets, selected), cursor, 0, entries.Count, ColumnWidth)); + lines.AddRange(ScreenChrome.Buttons(Buttons(sets, selected), cursor, 0, entries.Count, width)); + lines.Add(string.Empty); + var picked = selected >= 0 && selected < entries.Count ? entries[selected].Timer : null; + lines.AddRange(ScreenChrome.Legend( + LegendLabel, + new[] + { + ScreenChrome.LegendEntry(EnabledGlyph, "enabled", picked?.Enabled ?? false), + ScreenChrome.LegendEntry(SetGlyph, "set", picked is not null), + }, + width)); return lines; } @@ -251,19 +283,29 @@ internal static List ListColumn( /// The editor for the selected timer — interval, command, and the one-shot/enabled toggles. /// Empty when nothing is selected. /// + /// How wide the pane runs, which its cursor bars and dropdowns are sized to. + /// How many rows the pane has, or 0 when the caller has none. internal static List EditorColumn( - IReadOnlyList sets, int selected, ScreenFocus? focus = null) + IReadOnlyList sets, + int selected, + ScreenFocus? focus = null, + int width = ColumnWidth, + int height = 0) { ArgumentNullException.ThrowIfNull(sets); var cursor = focus ?? ScreenFocus.None; var entries = Flatten(sets); - return selected >= 0 && selected < entries.Count - ? ScreenChrome.Choices( - BuildEditor(entries[selected].Timer, entries[selected].SetName, cursor, selected), - cursor.Edit, - ColumnWidth) - : new List(); + if (selected < 0 || selected >= entries.Count) + { + return new List(); + } + + // Compacted before the dropdown is laid over it: the overlay replaces rows by index, so dropping + // a blank underneath it afterwards would slide the list off the field it belongs to. + var lines = ScreenChrome.Compact( + BuildEditor(entries[selected].Timer, entries[selected].SetName, cursor, selected, width), height); + return ScreenChrome.Choices(lines, cursor.Edit, width); } /// Flattens every set's timers into one list, each paired with its owning set's name. @@ -298,7 +340,11 @@ private static string Row(TimerDefinition timer, string setName, bool selected) /// identify the timer; committing it moves the timer (). /// private static List BuildEditor( - TimerDefinition timer, string setName, ScreenFocus cursor, int selected) => new() + TimerDefinition timer, + string setName, + ScreenFocus cursor, + int selected, + int width = ColumnWidth) => new() { "[dim]name[/]", $" {ScreenChrome.Field(Escape(timer.Name), cursor.EditOn(0, selected, NameField))}", @@ -312,8 +358,8 @@ private static List BuildEditor( "[dim]command[/]", $" {ScreenChrome.Field(Escape(timer.Command), cursor.EditOn(0, selected, CommandField))}", string.Empty, - ScreenChrome.Cursor(Checkbox("one-shot", timer.OneShot), cursor.IsOn(1, 0), ColumnWidth), - ScreenChrome.Cursor(Checkbox("enabled", timer.Enabled), cursor.IsOn(1, 1), ColumnWidth), + ScreenChrome.Cursor(Checkbox("one-shot", timer.OneShot), cursor.IsOn(1, 0), width), + ScreenChrome.Cursor(Checkbox("enabled", timer.Enabled), cursor.IsOn(1, 1), width), }; /// A checkbox row in the editor pane, checked in the accent and unchecked dim. diff --git a/src/SharpMUTerm.Tui/TimersScreenView.cs b/src/SharpMUTerm.Tui/TimersScreenView.cs index 5d1e2e02..d6f1cbe8 100644 --- a/src/SharpMUTerm.Tui/TimersScreenView.cs +++ b/src/SharpMUTerm.Tui/TimersScreenView.cs @@ -1,8 +1,6 @@ using SharpMUTerm.Core.Configuration; using SharpConsoleUI; -using SharpConsoleUI.Builders; using SharpConsoleUI.Controls; -using SharpConsoleUI.Layout; namespace SharpMUTerm.Tui; @@ -11,14 +9,13 @@ namespace SharpMUTerm.Tui; /// header band carrying the keyboard hints, a body whose timer-list panel and editor panel are /// separated by a vertical rule, and a Cancel/Save action bar pinned to the last row. The markup for /// each panel comes from the pure so the content stays -/// unit-tested; this only lays it out. +/// unit-tested; this only lays it out (through , which every +/// two-column screen shares). /// internal static class TimersScreenView { - private const int ListColumnWidth = TimersScreenRenderer.ColumnWidth; - public static IWindowControl Build( - IReadOnlyList sets, int selected, int width, ScreenFocus? focus = null) + IReadOnlyList sets, int selected, int width, ScreenFocus? focus = null, int height = 0) { var header = ScreenChrome.Band( TimersScreenRenderer.HeaderLine(width, TimersScreenRenderer.Model(sets, selected), focus), @@ -26,30 +23,20 @@ public static IWindowControl Build( var footer = ScreenChrome.Band( TimersScreenRenderer.FooterLine(sets, selected, width, focus), ScreenPalette.FooterBg); - // Body: timer list │ editor, as two real columns. - var listCol = ScreenChrome.Stretch( - new MarkupControl(TimersScreenRenderer.ListColumn(sets, selected, focus))); - var editorCol = ScreenChrome.Stretch( - new MarkupControl(ScreenChrome.Indent(TimersScreenRenderer.EditorColumn(sets, selected, focus)))); - var body = Controls.HorizontalGrid() - .WithAlignment(HorizontalAlignment.Stretch) - .WithVerticalAlignment(VerticalAlignment.Fill) - .Column(c => c.Width(ListColumnWidth).Add(listCol)) - .Column(c => c.Width(1).Add(ScreenChrome.VerticalRule())) - .Column(c => c.Width(1).Add(ScreenChrome.Filler())) - .Column(c => c.Flex(1).Add(editorCol)) - .Build(); - - // Header on the first row, footer on the last, body taking everything between — so the action - // bar sits at the bottom of the screen instead of trailing the content. - var root = Controls.Grid() - .WithAlignment(HorizontalAlignment.Stretch) - .WithVerticalAlignment(VerticalAlignment.Fill); - root.Rows(GridLength.Cells(1), GridLength.Star(1), GridLength.Cells(1)).Columns(GridLength.Star(1)); - root.Place(header, 0, 0, 1, 1); - root.Place(body, 1, 0, 1, 1); - root.Place(footer, 2, 0, 1, 1); + var list = ScreenChrome.SplitWidth( + width, + TimersScreenRenderer.ColumnWidth, + TimersScreenRenderer.MinColumnWidth, + TimersScreenRenderer.MinEditorWidth); + var rows = ScreenChrome.Rows(height); + var left = TimersScreenRenderer.ListColumn(sets, selected, focus, list); + var right = TimersScreenRenderer.EditorColumn( + sets, selected, focus, width <= 0 ? list : width - list - ScreenChrome.ColumnDivider, rows); - return root.Build(); + var listCol = ScreenChrome.Stretch(new MarkupControl(ScreenChrome.Window(left, rows))); + var editorCol = ScreenChrome.Stretch( + new MarkupControl(ScreenChrome.Indent(ScreenChrome.Window(right, rows)))); + return ScreenChrome.Split( + header, footer, listCol, editorCol, list, Math.Max(left.Count, right.Count), rows); } } diff --git a/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs b/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs index b7cdfe3d..65646fac 100644 --- a/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/TriggersScreenRenderer.cs @@ -19,12 +19,27 @@ namespace SharpMUTerm.Tui; internal static class TriggersScreenRenderer { /// - /// Visible width of the left column. The view lays its column out at exactly this width, so - /// the two must agree -- a cursor bar padded narrower than its column leaves a gap before the - /// rule. Shared rather than duplicated so they cannot drift apart. + /// Visible width of the left column when the screen can afford it. The view lays its column out at + /// exactly the width it passes back in, so the two must agree -- a cursor bar padded narrower than + /// its column leaves a gap before the rule. Shared rather than duplicated so they cannot drift apart. /// internal const int ColumnWidth = 56; + /// + /// The fewest cells the rule list is still worth drawing in — a rule row is a tick, a name, a regex + /// and a route, and below this the route falls off every row at once. + /// + internal const int MinColumnWidth = 40; + + /// + /// The fewest cells the editor pane can be read in: the width of the attribute legend's widest row, + /// which is the one line on this screen whose content is fixed and cannot be shortened. Under it the + /// vocabulary the attrs field accepts is drawn with its last word cut off, which is worse + /// than the list column being narrow — the list's own rows are names the reader chose and can + /// recognise from a prefix. + /// + internal const int MinEditorWidth = 48; + /// /// What the route list calls "no spawn window" — a rule with a null SpawnTarget goes to the /// main output. It is a real choice in the radio group, not the absence of one. @@ -386,14 +401,20 @@ internal static string FooterLine( } /// The rule list — every trigger of every set, each over a set/flags sub-row. + /// + /// How wide the column actually runs, which the cursor bars are padded to. It is a parameter rather + /// than because the view now gives the column back cells on a narrow + /// screen (see ), and a bar padded to a width the column no + /// longer has would run under the hairline. + /// internal static List RulesColumn( - IReadOnlyList sets, int selectedTrigger, ScreenFocus? focus = null) + IReadOnlyList sets, int selectedTrigger, ScreenFocus? focus = null, int width = ColumnWidth) { ArgumentNullException.ThrowIfNull(sets); var cursor = focus ?? ScreenFocus.None; var flattened = Flatten(sets); - var left = new List { "[dim]on name / pattern → window[/]" }; + var left = new List { $"[dim]{ListHeading}[/]" }; if (flattened.Count == 0) { @@ -415,7 +436,7 @@ internal static List RulesColumn( foreach (var trigger in set.Triggers) { left.Add(ScreenChrome.Cursor( - RuleRow(row, selectedTrigger, trigger), cursor.IsOn(0, row), ColumnWidth)); + RuleRow(row, selectedTrigger, trigger), cursor.IsOn(0, row), width)); left.Add(RuleSub(set.Name, trigger.Actions)); row++; } @@ -423,19 +444,85 @@ internal static List RulesColumn( left.Add(string.Empty); left.AddRange(ScreenChrome.Buttons( - Buttons(sets, selectedTrigger), cursor, 0, flattened.Count, ColumnWidth)); + Buttons(sets, selectedTrigger), cursor, 0, flattened.Count, width)); + left.Add(string.Empty); + left.AddRange(FlagLegend(Selected(flattened, selectedTrigger), width)); return left; } + /// The rule the cursor has anchored, or null when the list is empty or nothing is picked. + private static Trigger? Selected(IReadOnlyList<(Trigger Trigger, string SetName)> flattened, int selected) => + selected >= 0 && selected < flattened.Count ? flattened[selected].Trigger : null; + + /// + /// Every mark a rule's two rows are written in, and what it means. The action letters were the one + /// vocabulary on these screens written down nowhere at all: a rule reading ▪ Comms · H ✎ ⇥ ƒ + /// is four facts in five cells, and the cells are unguessable — H could as easily be "hidden" + /// as "highlight", and ⇥ as easily "indent" as "routed". The tick is in the list too, because + /// on as a column header is not much better a gloss than the tick it heads. + /// + /// The order is the order the marks appear on a row: the tick and the set on the first two cells, + /// then the flags in the order emits them. + /// + /// + private static readonly (string Glyph, string Meaning)[] RuleMarks = + { + ("✓", "enabled"), + ("▪", "set"), + ("H", "highlight"), + ("G", "gag"), + ("✎", "rewrite"), + ("R", "respond"), + (Glyphs.Capture, "routed"), + ("ƒ", "script"), + }; + + /// + /// The rule list's key, drawn in the slack under its buttons. The marks the selected rule + /// carries are lit and the rest muted, so the block is simultaneously a key to the column and a + /// reading of the row the cursor is on — the same trick the editor pane's attribute legend plays on + /// the open buffer. The tick and the set marker are always lit, because every drawn row has a set + /// and the tick tracks the rule's own enabled state. + /// + private static IEnumerable FlagLegend(Trigger? trigger, int width) + { + var flags = trigger is null ? string.Empty : Flags(trigger.Actions); + var cells = RuleMarks.Select(mark => ScreenChrome.LegendEntry( + mark.Glyph, + mark.Meaning, + mark.Glyph switch + { + "✓" => trigger?.Enabled ?? false, + "▪" => trigger is not null, + _ => flags.Contains(mark.Glyph, StringComparison.Ordinal), + })); + + return ScreenChrome.Legend(LegendLabel, cells, width); + } + + /// What the rule list's key is called. + private const string LegendLabel = "key"; + + /// The rule list's column header. Its marks are glossed by . + private const string ListHeading = "on name / pattern → window"; + /// /// The editor for the selected rule — pattern, route-to list, highlight swatches and attributes, /// the rewrite/respond/script templates, and the toggles. Empty when nothing is selected. /// + /// How wide the pane runs, which its cursor bars and dropdowns are sized to. + /// + /// How many rows the pane has, or 0 when the caller has none. This pane runs to two dozen rows and + /// the last three of them are cursor stops, so on a short screen it has to give something up rather + /// than let the checkboxes fall off the bottom — see . + /// internal static List EditorColumn( IReadOnlyList sets, int selectedTrigger, IReadOnlyList spawnTargets, - ScreenFocus? focus = null) + ScreenFocus? focus = null, + int width = ColumnWidth, + int height = 0) { ArgumentNullException.ThrowIfNull(sets); ArgumentNullException.ThrowIfNull(spawnTargets); @@ -448,7 +535,9 @@ internal static List EditorColumn( flattened[selectedTrigger].SetName, spawnTargets, cursor, - selectedTrigger) + selectedTrigger, + width, + height) : new List(); } @@ -520,7 +609,13 @@ private static string Flags(TriggerActions actions) } private static List BuildEditor( - Trigger trigger, string setName, IReadOnlyList spawnTargets, ScreenFocus cursor, int index) + Trigger trigger, + string setName, + IReadOnlyList spawnTargets, + ScreenFocus cursor, + int index, + int width = ColumnWidth, + int height = 0) { var name = cursor.EditOn(0, index, NameField); var set = cursor.EditOn(0, index, SetField); @@ -600,15 +695,19 @@ private static List BuildEditor( // The three rows below are real booleans on the trigger, and are the editor pane's navigable // rows in this order. - lines.Add(ScreenChrome.Cursor(Checkbox("gag line", trigger.Actions.Gag), cursor.IsOn(1, 0), ColumnWidth)); + lines.Add(ScreenChrome.Cursor(Checkbox("gag line", trigger.Actions.Gag), cursor.IsOn(1, 0), width)); lines.Add(ScreenChrome.Cursor( - Checkbox("stop processing", trigger.StopProcessing), cursor.IsOn(1, 1), ColumnWidth)); + Checkbox("stop processing", trigger.StopProcessing), cursor.IsOn(1, 1), width)); lines.Add(ScreenChrome.Cursor( - Checkbox("case sensitive", trigger.CaseSensitive), cursor.IsOn(1, 2), ColumnWidth)); + Checkbox("case sensitive", trigger.CaseSensitive), cursor.IsOn(1, 2), width)); + + // Compacted before the dropdown is laid over it, not after: the overlay replaces rows by index, + // so dropping a blank underneath it afterwards would slide the list off the field it belongs to. + ScreenChrome.Compact(lines, height); // Four of this pane's nine fields know values worth listing — the route, both highlight colours // and the script callback — and all four get the same drawn list, over the rows beside them. - return ScreenChrome.Choices(lines, cursor.Edit, ColumnWidth); + return ScreenChrome.Choices(lines, cursor.Edit, width); } /// A checkbox row in the editor pane, checked in the accent and unchecked dim. diff --git a/src/SharpMUTerm.Tui/TriggersScreenView.cs b/src/SharpMUTerm.Tui/TriggersScreenView.cs index 4545b44d..469684df 100644 --- a/src/SharpMUTerm.Tui/TriggersScreenView.cs +++ b/src/SharpMUTerm.Tui/TriggersScreenView.cs @@ -15,14 +15,13 @@ namespace SharpMUTerm.Tui; /// internal static class TriggersScreenView { - private const int RulesColumnWidth = TriggersScreenRenderer.ColumnWidth; - public static IWindowControl Build( IReadOnlyList sets, int selectedTrigger, IReadOnlyList spawnTargets, int width, - ScreenFocus? focus = null) + ScreenFocus? focus = null, + int height = 0) { var header = ScreenChrome.Band( TriggersScreenRenderer.HeaderLine( @@ -31,31 +30,22 @@ public static IWindowControl Build( var footer = ScreenChrome.Band( TriggersScreenRenderer.FooterLine(sets, selectedTrigger, width, focus), ScreenPalette.FooterBg); - // Body: rule list │ editor, as two real columns. - var rulesCol = ScreenChrome.Stretch( - new MarkupControl(TriggersScreenRenderer.RulesColumn(sets, selectedTrigger, focus))); - var editorCol = ScreenChrome.Stretch(new MarkupControl( - ScreenChrome.Indent( - TriggersScreenRenderer.EditorColumn(sets, selectedTrigger, spawnTargets, focus)))); - var body = Controls.HorizontalGrid() - .WithAlignment(HorizontalAlignment.Stretch) - .WithVerticalAlignment(VerticalAlignment.Fill) - .Column(c => c.Width(RulesColumnWidth).Add(rulesCol)) - .Column(c => c.Width(1).Add(ScreenChrome.VerticalRule())) - .Column(c => c.Width(1).Add(ScreenChrome.Filler())) - .Column(c => c.Flex(1).Add(editorCol)) - .Build(); - - // Header on the first row, footer on the last, body taking everything between — so the action - // bar sits at the bottom of the screen instead of trailing the content. - var root = Controls.Grid() - .WithAlignment(HorizontalAlignment.Stretch) - .WithVerticalAlignment(VerticalAlignment.Fill); - root.Rows(GridLength.Cells(1), GridLength.Star(1), GridLength.Cells(1)).Columns(GridLength.Star(1)); - root.Place(header, 0, 0, 1, 1); - root.Place(body, 1, 0, 1, 1); - root.Place(footer, 2, 0, 1, 1); + // Body: rule list │ editor, as two real columns. The split is a function of the screen's width: + // at 120 the rule list keeps the share it was designed with, and at 100 it gives cells back to + // the editor rather than letting the attribute legend run off the right-hand edge. + var rules = ScreenChrome.SplitWidth( + width, + TriggersScreenRenderer.ColumnWidth, + TriggersScreenRenderer.MinColumnWidth, + TriggersScreenRenderer.MinEditorWidth); + var body = ScreenChrome.Rows(height); + var left = TriggersScreenRenderer.RulesColumn(sets, selectedTrigger, focus, rules); + var right = TriggersScreenRenderer.EditorColumn( + sets, selectedTrigger, spawnTargets, focus, width <= 0 ? rules : width - rules - ScreenChrome.ColumnDivider, body); - return root.Build(); + var rulesCol = ScreenChrome.Stretch(new MarkupControl(ScreenChrome.Window(left, body))); + var editorCol = ScreenChrome.Stretch(new MarkupControl( + ScreenChrome.Indent(ScreenChrome.Window(right, body)))); + return ScreenChrome.Split(header, footer, rulesCol, editorCol, rules, Math.Max(left.Count, right.Count), body); } } diff --git a/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs b/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs index 5b3a5ffd..39aa076c 100644 --- a/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs +++ b/src/SharpMUTerm.Tui/WorldsScreenRenderer.cs @@ -580,13 +580,22 @@ internal static List WorldsColumn( return left; } + /// + /// How many rows the column has, or 0 when the caller has none. This is the one pane on these + /// screens that draws rows belonging to three of its four cursor panes, so on a short terminal it + /// has to give its blanks up and then scroll — see and + /// . At 100×24 it ran to nineteen rows in twelve, and the twelve + /// it drew stopped just above the CHARACTERS list, so every character row and every button under + /// them was a cursor stop that had never been drawn. + /// internal static List DetailColumn( IReadOnlyList worlds, IReadOnlyList triggerSets, int selectedWorld, int selectedCharacter, string accent, - ScreenFocus? focus = null) + ScreenFocus? focus = null, + int height = 0) { var cursor = focus ?? ScreenFocus.None; (selectedWorld, selectedCharacter) = Resolve(worlds, selectedWorld, selectedCharacter); @@ -599,11 +608,15 @@ internal static List DetailColumn( // The world's own fields are the WORLDS-list row's fields, in this order — the detail column is // where they are displayed, so it is where an open edit draws its caret. + // + // There is no title strip above them any more. It read + // `Aetherfall aetherfall.mux:4201 TLS on · UTF-8` — and every token of it was repeated in the + // five rows immediately underneath, twice over for the address, which the WORLDS list beside it + // also carries. A summary directly above the thing it summarises is not a summary; it is the + // same row drawn again in a shape you cannot edit, and the two cells it cost were the two rows + // the CHARACTERS list needed at 100×24. var right = new List { - $"[bold {Value}]{Escape(world.Name)}[/] [{Label}]{Escape(world.Host)}:{world.Port.ToString(CultureInfo.InvariantCulture)}[/]" - + $" [{accent}]TLS {OnOff(world.UseTls)}[/][{Label}] · {Escape(world.Encoding)}[/]", - string.Empty, $"[{accent}]├ WORLD[/]", WorldField("name", Field( $"[{Value}]{Escape(world.Name)}[/]", cursor, selectedWorld, WorldNameField)), @@ -630,7 +643,6 @@ internal static List DetailColumn( KeepaliveField)), string.Empty, $"[{accent}]├ CHARACTERS[/] [{Label}]a character is a connection[/]", - $"[{Label}] name state login trigger sets[/]", }); if (world.Characters.Count == 0) @@ -655,15 +667,20 @@ internal static List DetailColumn( CharactersPane, world.Characters.Count, DetailRowWidth)); - return ScreenChrome.Choices(right, cursor.Edit, DetailRowWidth); + + // Compacted, then windowed, then overlaid: the dropdown replaces rows by index, so anything that + // moves a row has to happen before it is drawn or the list slides off the field it belongs to. + return ScreenChrome.Choices( + ScreenChrome.Window(ScreenChrome.Compact(right, height), height), cursor.Edit, DetailRowWidth); } /// /// The world's security block: two checkbox rows where a read-only security TLS on · certs /// strict summary used to sit. The summary said everything and offered nothing — the two flags /// behind it had no UI at all — so it is replaced by the rows themselves rather than kept above - /// them; the world's title strip at the top of this column still reads TLS on, which is where - /// a one-glance answer belongs. + /// them. The column's title strip used to repeat the answer a third time (TLS on) and has + /// since gone with the rest of its duplications; the checkbox is the one-glance answer, and + /// it is the only one that can also be pressed. /// /// They keep the security label column so the block still reads as one setting with two /// switches, and so the checkboxes line up under the field wells above them rather than starting at @@ -875,13 +892,24 @@ private static string Inventory(TriggerSet set) private static int Width(IReadOnlyList sets, Func part) => sets.Count == 0 ? 0 : sets.Max(s => VisibleLength(part(s))); + /// + /// One row of the CHARACTERS list: which character, and nothing else. It is a selector — + /// the row you move the cursor onto to bring a character up in the CHARACTER form below — and it + /// used to be a four-column table (name state login trigger sets) whose other three + /// columns were all drawn again, on the same screen, at the same time: session and + /// auto-login are rows of the form directly underneath, and the sets are the pane beside it, + /// with checkboxes, descriptions and counts. A list that restates the detail pane is a list you have + /// to read to discover it says nothing new — and its column header cost a row that the list itself + /// needed on a short screen. + /// + /// So: the list says which characters there are and which one is selected, and the form owns + /// everything about the one that is. + /// + /// private static string CharacterRow(CharacterDefinition character, bool selected) { var marker = selected ? $"[bold {Accent}]▸[/]" : " "; - var name = PadVisible($"[{(selected ? "bold " : string.Empty)}{Value}]{Escape(character.Name)}[/]", 13); - var login = PadVisible(character.AutoLogin ? "auto-login" : "manual", 12); - var sets = Escape(string.Join(", ", character.TriggerSets)); - return $"{marker} {name} [{Label}]○ offline[/] [{Label}]{login}[/] [{Label}]{sets}[/]"; + return $"{marker} [{(selected ? "bold " : string.Empty)}{Value}]{Escape(character.Name)}[/]"; } private static string WorldField(string label, string value) => diff --git a/src/SharpMUTerm.Tui/WorldsScreenView.cs b/src/SharpMUTerm.Tui/WorldsScreenView.cs index 902e52e4..bf9747f9 100644 --- a/src/SharpMUTerm.Tui/WorldsScreenView.cs +++ b/src/SharpMUTerm.Tui/WorldsScreenView.cs @@ -24,7 +24,8 @@ public static IWindowControl Build( int width, ScreenFocus? focus = null, string fkey = WorldsScreenRenderer.FKey, - int selectedSet = 0) + int selectedSet = 0, + int height = 0) { // Both panes end in button rows, so a raw cursor can point past its list; resolving once here // keeps every block of the screen agreeing on which world and character are selected. @@ -40,12 +41,29 @@ public static IWindowControl Build( WorldsScreenRenderer.FooterLine(worlds, selectedWorld, selectedCharacter, accent, width, focus), ScreenPalette.FooterBg); + // How many rows the WORLDS/detail body has once the header, the character band, the gap under + // it and the action bar have taken theirs. The detail column is built against that number, so a + // pane taller than its slot compacts and then scrolls rather than losing its tail silently. + var band = WorldsScreenRenderer.HasCharacter(worlds, selectedWorld, selectedCharacter) + ? Math.Max( + WorldsScreenRenderer.FormColumn( + worlds[selectedWorld].Characters[selectedCharacter], accent, focus, selectedCharacter).Count, + WorldsScreenRenderer.TriggersColumn( + worlds[selectedWorld].Characters[selectedCharacter], + triggerSets, + accent, + focus, + selectedSet, + worlds).Count) + 2 + : 1; + var rows = height <= 0 ? 0 : Math.Max(1, height - 1 - band); + // Body: WORLDS list │ detail, as two real columns. var worldsCol = ScreenChrome.Stretch( new MarkupControl(WorldsScreenRenderer.WorldsColumn(worlds, selectedWorld, focus).ToList())); var detailCol = ScreenChrome.Stretch(new MarkupControl( WorldsScreenRenderer - .DetailColumn(worlds, triggerSets, selectedWorld, selectedCharacter, accent, focus) + .DetailColumn(worlds, triggerSets, selectedWorld, selectedCharacter, accent, focus, rows) .ToList())); var body = Controls.HorizontalGrid() .WithAlignment(HorizontalAlignment.Stretch) diff --git a/tests/SharpMUTerm.Tui.Tests/AliasesScreenRendererTests.cs b/tests/SharpMUTerm.Tui.Tests/AliasesScreenRendererTests.cs index 7d142d4d..ae420b78 100644 --- a/tests/SharpMUTerm.Tui.Tests/AliasesScreenRendererTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/AliasesScreenRendererTests.cs @@ -132,4 +132,22 @@ public async Task Render_EscapesMarkupBrackets() var lines = AliasesScreenRenderer.Render(sets, 0); await Assert.That(lines.Any(l => l.Contains("wei[[rd]]"))).IsTrue(); } + + /// + /// The list's key, at the foot of the column. The tick and the set marker are the two glyphs a row + /// is written in, and on as a column header was not much better a gloss than the tick it + /// headed. It reads the selected row too: its tick is lit when that alias is enabled. + /// + [Test] + public async Task TheListKeyNamesTheTickAndTheSetMarker() + { + var column = AliasesScreenRenderer.ListColumn(Scene(), selected: 0); + var key = string.Join("\n", column.SkipWhile(l => !l.Contains("key"))); + + await Assert.That(key).Contains("✓"); + await Assert.That(key).Contains("enabled"); + await Assert.That(key).Contains("▪"); + await Assert.That(key).Contains("set"); + await Assert.That(key).Contains($"[{ScreenPalette.Value}]enabled[/]"); + } } diff --git a/tests/SharpMUTerm.Tui.Tests/ScreenLayoutTests.cs b/tests/SharpMUTerm.Tui.Tests/ScreenLayoutTests.cs new file mode 100644 index 00000000..00f99e20 --- /dev/null +++ b/tests/SharpMUTerm.Tui.Tests/ScreenLayoutTests.cs @@ -0,0 +1,267 @@ +using SharpMUTerm.Core.Automation; +using SharpMUTerm.Core.Configuration; +using SharpMUTerm.Tui; + +namespace SharpMUTerm.Tui.Tests; + +/// +/// How a settings screen decides what it has room for. The panes used to be laid out against +/// constants — a 56-cell list column and a body stretched to the window — which were right at the +/// width and height they were drawn at and wrong at every other: at 100×24 F2's editor lost its three +/// checkboxes off the bottom and its attribute legend off the right, F4's binding rows lost their +/// commands, and F5's whole CHARACTERS list sat below the fold while ↑↓ walked through it. At 120 and +/// 160 the same constants left a thirty-row empty pane under four rows of rules. +/// +/// The three rules below are the fix, and they are pure functions of the space available, so they are +/// pinned here rather than only through the screens that call them. +/// +/// +public class ScreenLayoutTests +{ + /// A list column keeps the width it was designed with whenever the screen can afford it. + [Test] + public async Task SplitWidth_KeepsTheDesignedWidthWhenThereIsRoom() + { + await Assert.That(ScreenChrome.SplitWidth(120, desired: 56, minimum: 40, companion: 48)).IsEqualTo(56); + await Assert.That(ScreenChrome.SplitWidth(160, desired: 56, minimum: 40, companion: 48)).IsEqualTo(56); + } + + /// + /// …and gives cells back when there aren't, so the column beside it keeps the width it needs to be + /// read in. This is the case that was broken: at 100 columns the list took its full 56 and the + /// editor was left with 42 for content that needs 48. + /// + [Test] + public async Task SplitWidth_GivesCellsBackRatherThanStarveTheOtherColumn() + { + var list = ScreenChrome.SplitWidth(100, desired: 56, minimum: 40, companion: 48); + + await Assert.That(list).IsEqualTo(50); + await Assert.That(100 - list - ScreenChrome.ColumnDivider).IsGreaterThanOrEqualTo(48); + } + + /// + /// It never goes below the minimum. Past that point both columns are unreadable rather than one, + /// and a screen that narrow has to clip somewhere whatever it does. + /// + [Test] + public async Task SplitWidth_StopsAtTheMinimumAndIgnoresAWidthItDoesNotHave() + { + await Assert.That(ScreenChrome.SplitWidth(60, desired: 56, minimum: 40, companion: 48)).IsEqualTo(40); + + // No width to reason from — the merged Render the renderer tests go through — is the width the + // column was always laid out at. + await Assert.That(ScreenChrome.SplitWidth(0, desired: 56, minimum: 40, companion: 48)).IsEqualTo(56); + } + + /// + /// Compacting spends a block's blank separators, and only those, to make it fit. They carry nothing, + /// and every row one costs at the top is a row lost off the bottom — where a pane's checkboxes and + /// buttons live. + /// + [Test] + public async Task Compact_DropsBlankSeparatorsUntilTheBlockFits() + { + var block = new List { "a", string.Empty, "b", string.Empty, "c", string.Empty, "d" }; + + await Assert.That(ScreenChrome.Compact(new List(block), 5)) + .IsEquivalentTo(new List { "a", "b", "c", string.Empty, "d" }); + + // From the top down, so the section that compacts is the one already on screen. + await Assert.That(ScreenChrome.Compact(new List(block), 6)) + .IsEquivalentTo(new List { "a", "b", string.Empty, "c", string.Empty, "d" }); + } + + /// A block that already fits, or one with no height to fit into, is left exactly as it is. + [Test] + public async Task Compact_LeavesABlockThatFitsAlone() + { + var block = new List { "a", string.Empty, "b" }; + + await Assert.That(ScreenChrome.Compact(new List(block), 3)).IsEquivalentTo(block); + await Assert.That(ScreenChrome.Compact(new List(block), 0)).IsEquivalentTo(block); + } + + /// + /// A pane taller than its slot scrolls to the row the keyboard is on, so a cursor can never be moved + /// onto a row that was never drawn. The window is centred, because these blocks are rebuilt from + /// scratch on every keystroke and there is no previous offset to scroll from. + /// + [Test] + public async Task Window_KeepsTheCursorRowOnScreenAndSaysWhatItIsHiding() + { + var block = new List(); + for (var i = 0; i < 12; i++) + { + block.Add(ScreenChrome.Cursor($"row {i}", i == 6, 20)); + } + + var window = ScreenChrome.Window(block, 5); + + await Assert.That(window).Count().IsEqualTo(5); + await Assert.That(window.Any(l => l.Contains("row 6"))).IsTrue(); + + // The edges name the rows they are standing in for: a row silently missing from a pane is the + // same failure as a cursor stop that was never drawn, one level up. + await Assert.That(window[0]).Contains("⌃"); + await Assert.That(window[0]).Contains("more"); + await Assert.That(window[^1]).Contains("⌄"); + } + + /// + /// With the keyboard in another pane there is no cursor to scroll to, so the block shows its top — + /// which is where its own heading is. + /// + [Test] + public async Task Window_ShowsTheTopWhenNothingInTheBlockIsFocused() + { + var block = new List { "one", "two", "three", "four" }; + var window = ScreenChrome.Window(block, 2); + + await Assert.That(window[0]).IsEqualTo("one"); + await Assert.That(window[^1]).Contains("⌄ 2 more"); + } + + /// A block that fits is handed straight back, edges and all. + [Test] + public async Task Window_LeavesABlockThatFitsAlone() + { + var block = new List { "one", "two" }; + + await Assert.That(ScreenChrome.Window(block, 2)).IsEquivalentTo(block); + await Assert.That(ScreenChrome.Window(block, 0)).IsEquivalentTo(block); + } + + /// + /// F2's editor pane runs to two dozen rows and its last three are cursor stops. On a 24-row terminal + /// it used to stop at respond, leaving gag line, stop processing and + /// case sensitive reachable by ↑↓ and drawn nowhere; compacting the separators brings the + /// whole pane back inside the body. + /// + [Test] + public async Task TriggersEditor_FitsAShortScreenWithoutLosingItsCheckboxes() + { + var sets = TriggerScene(); + + var tall = TriggersScreenRenderer.EditorColumn(sets, 0, Array.Empty()); + var short_ = TriggersScreenRenderer.EditorColumn( + sets, 0, Array.Empty(), null, TriggersScreenRenderer.ColumnWidth, height: 22); + + await Assert.That(tall.Count).IsGreaterThan(22); + await Assert.That(short_.Count).IsLessThanOrEqualTo(22); + + foreach (var row in new[] { "gag line", "stop processing", "case sensitive", "attrs", "strikethrough" }) + { + await Assert.That(short_.Any(l => l.Contains(row))).IsTrue().Because(row + " is still drawn"); + } + } + + /// + /// F5's detail column draws rows belonging to three of the screen's four cursor panes. At 100×24 it + /// had twelve rows for nineteen and drew the first twelve, which stopped one line above the + /// CHARACTERS list — so every character row and every button under them was a stop the screen had + /// never drawn. It compacts, then scrolls to the cursor. + /// + [Test] + public async Task WorldsDetail_ScrollsToTheCharacterTheCursorIsOn() + { + var worlds = WorldScene(); + var focus = new ScreenFocus(WorldsScreenRenderer.CharactersPane, 1, null); + + var column = WorldsScreenRenderer.DetailColumn( + worlds, Array.Empty(), 0, 1, ScreenPalette.Accent, focus, height: 12); + + await Assert.That(column).Count().IsLessThanOrEqualTo(12); + await Assert.That(column.Any(l => l.Contains("Rookery"))).IsTrue(); + await Assert.That(column.Any(l => l.Contains("[[- remove]]"))).IsTrue(); + await Assert.That(column[0]).Contains("⌃"); + } + + /// + /// F4's numpad grid asks for the width its longest bound command needs, instead of ellipsising at a + /// constant ten characters beside a binding list drawing the same command in full. + /// + [Test] + public async Task NumpadWidth_FollowsTheLongestCommandBoundToADigit() + { + var narrow = new List { new() { Key = "Num5", Command = "look" } }; + var wide = new List { new() { Key = "Num1", Command = "look at altar" } }; + + await Assert.That(KeypadScreenRenderer.NumpadWidth(wide)) + .IsGreaterThan(KeypadScreenRenderer.NumpadWidth(narrow)); + + // Given that width, the cell draws the command whole — the asymmetry the review named. + var grid = KeypadScreenRenderer.NumpadColumn(wide, KeypadScreenRenderer.NumpadWidth(wide)); + await Assert.That(grid.Single(l => l.Contains("[[1]]"))).Contains("look at altar"); + } + + /// + /// …and it is bounded. The grid is a diagram of nine keys, not a command line, and every cell it + /// takes comes out of the binding rows beside it. + /// + [Test] + public async Task NumpadWidth_IsCappedSoOneLongCommandCannotSwallowTheScreen() + { + var absurd = new List + { + new() { Key = "Num5", Command = new string('x', 200) }, + }; + + await Assert.That(KeypadScreenRenderer.NumpadWidth(absurd)).IsLessThan(80); + } + + /// + /// An armed key capture swaps a binding row's key well for a prompt twice its width, so while it is + /// up the list needs more than its resting minimum — and takes it from the diagram, which has + /// nothing to do with the keystroke being waited for. Without this the capture row lost its command + /// off the right-hand edge at 120 columns, which is the width the screen is normally used at. + /// + [Test] + public async Task ArmedCapture_TakesItsExtraWidthFromTheNumpad() + { + var wide = new List { new() { Key = "Num1", Command = "look at altar" } }; + var desired = KeypadScreenRenderer.NumpadWidth(wide); + + var resting = ScreenChrome.SplitWidth( + 120, desired, KeypadScreenRenderer.MinNumpadWidth, KeypadScreenRenderer.MinHotkeysWidth); + var armed = ScreenChrome.SplitWidth( + 120, desired, KeypadScreenRenderer.MinNumpadWidth, KeypadScreenRenderer.CaptureWidth); + + await Assert.That(armed).IsLessThan(resting); + await Assert.That(120 - armed - ScreenChrome.ColumnDivider) + .IsGreaterThanOrEqualTo(KeypadScreenRenderer.CaptureWidth); + } + + private static List TriggerScene() => new() + { + new TriggerSet + { + Name = "Comms", + Triggers = new List + { + new() + { + Name = "public", + Pattern = "^\\[public\\] (.+)$", + Enabled = true, + Actions = new TriggerActions { SpawnTarget = "Chat", Rewrite = "$1" }, + }, + }, + }, + }; + + private static List WorldScene() => new() + { + new WorldDefinition + { + Name = "Aetherfall", + Host = "aetherfall.mux", + Port = 4201, + Characters = new List + { + new() { Name = "Corvid" }, + new() { Name = "Rookery" }, + }, + }, + }; +} diff --git a/tests/SharpMUTerm.Tui.Tests/TimersScreenRendererTests.cs b/tests/SharpMUTerm.Tui.Tests/TimersScreenRendererTests.cs index 8e1b0bb2..0bb7e0b1 100644 --- a/tests/SharpMUTerm.Tui.Tests/TimersScreenRendererTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/TimersScreenRendererTests.cs @@ -144,4 +144,22 @@ public async Task Render_EscapesMarkupBrackets() await Assert.That(lines.Any(l => l.Contains("od[[d]]"))).IsTrue(); await Assert.That(lines.Any(l => l.Contains("say [[hi]]"))).IsTrue(); } + + /// + /// The list's key, at the foot of the column. The tick and the set marker are the two glyphs a row + /// is written in, and on as a column header was not much better a gloss than the tick it + /// headed. It reads the selected row too: its tick is lit when that timer is enabled. + /// + [Test] + public async Task TheListKeyNamesTheTickAndTheSetMarker() + { + var column = TimersScreenRenderer.ListColumn(Scene(), selected: 0); + var key = string.Join("\n", column.SkipWhile(l => !l.Contains("key"))); + + await Assert.That(key).Contains("✓"); + await Assert.That(key).Contains("enabled"); + await Assert.That(key).Contains("▪"); + await Assert.That(key).Contains("set"); + await Assert.That(key).Contains($"[{ScreenPalette.Value}]enabled[/]"); + } } diff --git a/tests/SharpMUTerm.Tui.Tests/TriggersScreenRendererTests.cs b/tests/SharpMUTerm.Tui.Tests/TriggersScreenRendererTests.cs index 1eda9a30..b87c423c 100644 --- a/tests/SharpMUTerm.Tui.Tests/TriggersScreenRendererTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/TriggersScreenRendererTests.cs @@ -155,4 +155,85 @@ public async Task Render_EscapesMarkupBracketsInNamesAndPatterns() await Assert.That(lines.Any(l => l.Contains("x[[1]]"))).IsTrue(); await Assert.That(lines.Any(l => l.Contains("Weird[[Set]]"))).IsTrue(); } + + /// + /// The rule list's key, at the foot of the column. The sub-row compresses a rule to single cells — + /// ▪ Comms · H ✎ ⇥ ƒ is four facts in five glyphs — and until this block existed nothing on + /// the screen said what any of them meant. Every mark a row can carry has to be named, for the same + /// reason the attribute legend names every attribute: a key with gaps in it is a key you cannot + /// trust to be complete. + /// + [Test] + public async Task TheRuleListKeyNamesEveryMarkARowCanCarry() + { + var column = TriggersScreenRenderer.RulesColumn(Scene(), selectedTrigger: 0); + var key = string.Join("\n", column.SkipWhile(l => !l.Contains("key"))); + + foreach (var meaning in new[] + { + "enabled", "set", "highlight", "gag", "rewrite", "respond", "routed", "script", + }) + { + await Assert.That(key).Contains(meaning); + } + + foreach (var glyph in new[] { "✓", "▪", "H", "G", "✎", "R", "ƒ" }) + { + await Assert.That(key).Contains(glyph); + } + } + + /// + /// It also reads the row the cursor is on: the marks that rule carries are lit and the rest muted, + /// which is what turns a key into an answer. The same trick the editor pane's attribute legend + /// plays on the open buffer. + /// + [Test] + public async Task TheRuleListKeyLightsTheMarksTheSelectedRuleCarries() + { + var sets = new[] + { + new TriggerSet + { + Name = "Comms", + Triggers = new List + { + new() + { + Name = "gagged", + Pattern = "^x$", + Enabled = true, + Actions = new TriggerActions { Gag = true }, + }, + new() + { + Name = "plain", + Pattern = "^y$", + Enabled = false, + Actions = new TriggerActions(), + }, + }, + }, + }; + + var gagged = Key(TriggersScreenRenderer.RulesColumn(sets, selectedTrigger: 0)); + var plain = Key(TriggersScreenRenderer.RulesColumn(sets, selectedTrigger: 1)); + + await Assert.That(Lit(gagged, "gag")).IsTrue(); + await Assert.That(Lit(gagged, "enabled")).IsTrue(); + + // The second rule is disabled and does nothing at all, so nothing in its reading is lit but the + // set every drawn row has. + await Assert.That(Lit(plain, "gag")).IsFalse(); + await Assert.That(Lit(plain, "enabled")).IsFalse(); + await Assert.That(Lit(plain, "set")).IsTrue(); + } + + /// The key block, as one string — everything from the row that names it onward. + private static string Key(IEnumerable column) => + string.Join("\n", column.SkipWhile(l => !l.Contains("key"))); + + /// Whether a key entry is drawn lit (accent glyph, primary ink) rather than muted. + private static bool Lit(string key, string meaning) => + key.Contains($"[{ScreenPalette.Value}]{meaning}[/]", StringComparison.Ordinal); } diff --git a/tests/SharpMUTerm.Tui.Tests/WorldsScreenRendererTests.cs b/tests/SharpMUTerm.Tui.Tests/WorldsScreenRendererTests.cs index 5527872e..13182593 100644 --- a/tests/SharpMUTerm.Tui.Tests/WorldsScreenRendererTests.cs +++ b/tests/SharpMUTerm.Tui.Tests/WorldsScreenRendererTests.cs @@ -93,13 +93,37 @@ public async Task Render_SelectedWorldFieldsShown() await Assert.That(text).Contains("4000"); await Assert.That(text).Contains("UTF-8"); await Assert.That(text).Contains("30s"); - await Assert.That(text).Contains("TLS on"); + + // TLS is stated by the checkbox that sets it, and only there. This used to read + // Contains("TLS on"), which the detail column's title strip satisfied — a strip that also + // repeated the world's name, its host:port and its encoding, each of them directly above the + // editable row carrying the same value. The claim is now the stronger one: the flag is on + // screen, in the one place it can be changed. + await Assert.That(lines.Count(l => l.Contains("TLS"))).IsEqualTo(1); + await Assert.That(lines.Single(l => l.Contains("TLS"))).Contains("encrypt this connection"); + await Assert.That(text).DoesNotContain("TLS on"); + } + + /// + /// The detail column opens on the world's editable rows, with no summary of them above. Every token + /// of the strip that used to sit there — Aetherfall aether.example.org:4000 TLS on · UTF-8 + /// — was repeated in the five rows immediately underneath, and the address a third time in the + /// WORLDS list beside it. + /// + [Test] + public async Task Render_TheDetailColumnDoesNotRestateTheWorldAboveItsFields() + { + var column = WorldsScreenRenderer.DetailColumn( + Worlds(), TriggerSets(), selectedWorld: 0, selectedCharacter: 0, ScreenPalette.Accent); + + await Assert.That(column[0]).Contains("WORLD"); + await Assert.That(column.Count(l => l.Contains("aether.example.org"))).IsEqualTo(1); + await Assert.That(column.Count(l => l.Contains("UTF-8"))).IsEqualTo(1); } /// /// The world's two security flags, as the two checkboxes that replaced the read-only line - /// summarising them. The world summary at the top of the column still reads TLS on, which is - /// where a one-glance answer belongs — the rows are where it is changed. + /// summarising them — which is now the only place on the screen the flags are stated at all. /// [Test] public async Task Render_SecurityIsTwoCheckboxesUnderTheSecurityLabel() @@ -171,16 +195,33 @@ await Assert.That(lines.Any(l => l.Contains("log folder") && l.Contains(WorldsScreenRenderer.DefaultDirectory))).IsTrue(); } + /// + /// The CHARACTERS list is a selector: it names the characters and marks the selected one, and says + /// nothing else. It used to be a four-column table — name state login trigger sets — whose + /// other three columns were all drawn again on the same screen at the same time: the session state + /// and the login mode are rows of the CHARACTER form directly underneath, and the sets are the pane + /// beside it with checkboxes, descriptions and counts. + /// [Test] - public async Task Render_CharactersTableShowsOfflineAndLoginMode() + public async Task Render_TheCharacterListSelectsAndTheFormHoldsTheDetail() { - var lines = WorldsScreenRenderer.Render(Worlds(), TriggerSets(), selectedWorld: 0, selectedCharacter: 0); + var column = WorldsScreenRenderer.DetailColumn( + Worlds(), TriggerSets(), selectedWorld: 0, selectedCharacter: 0, ScreenPalette.Accent); + + var corvid = column.Single(l => l.Contains("Corvid") && !l.Contains("[[")); + await Assert.That(corvid).Contains("▸"); + await Assert.That(column.Any(l => l.Contains("Rookery"))).IsTrue(); - var corvid = lines.Single(l => l.Contains("Corvid") && l.Contains("○ offline")); - await Assert.That(corvid).Contains("auto-login"); + // None of the three restated columns survives in the list, nor the header that named them. + foreach (var gone in new[] { "○ offline", "auto-login", "manual", "trigger sets", "state" }) + { + await Assert.That(column.Any(l => l.Contains(gone))).IsFalse().Because(gone + " is the form's"); + } - var rookery = lines.Single(l => l.Contains("Rookery") && l.Contains("○ offline")); - await Assert.That(rookery).Contains("manual"); + // And each of them is still on the screen, in the form that owns it. + var form = WorldsScreenRenderer.FormColumn(Worlds()[0].Characters[0], ScreenPalette.Accent); + await Assert.That(form.Any(l => l.Contains("auto-login"))).IsTrue(); + await Assert.That(form.Any(l => l.Contains("session"))).IsTrue(); } [Test] From 8951259233bd6eddd58f1e3e62a6f04b38c1687a Mon Sep 17 00:00:00 2001 From: Harry Cordewener Date: Wed, 29 Jul 2026 00:46:57 -0500 Subject: [PATCH 22/23] HANDOFF: keepalive is unblocked upstream, waiting on a release The audit recorded keepalive as inert with no mechanism to build on. That is no longer true: TelnetNegotiationCore PR #52 adds an opt-in idle-reset IAC NOP keepalive with a configurable TimeSpan interval. Records why the field still cannot be wired -- the API doesn't exist in the pinned 2.5.3, and unlike SharpConsoleUI it can't be reached through a conditional project reference, because that only works when both paths expose the same API and here the package path wouldn't compile. So it waits on the release rather than on more design, and the note says what to do when 2.6.0 lands. Also records the limitation the eventual wiring inherits: IAC NOP proves the socket write succeeded, not that the peer answered. Co-Authored-By: Claude Opus 5 (1M context) --- docs/HANDOFF.md | 24 ++++++++++++++++++++---- 1 file changed, 20 insertions(+), 4 deletions(-) diff --git a/docs/HANDOFF.md b/docs/HANDOFF.md index 742c7421..4810ae74 100644 --- a/docs/HANDOFF.md +++ b/docs/HANDOFF.md @@ -657,10 +657,26 @@ categories, and where each control sits: wants a reconnect, like every other rule. The numpad specifically **still cannot fire** — see *Which keys can actually fire* under Critical Gotchas — and F4 now says so on the row rather than leaving it to be discovered. -- **Still inert, and why.** A world's `keepalive` seconds only picks the status - bar's fake ack figure — there is no keepalive, and adding one wants a raw - `IAC NOP` write that bypasses the interpreter's escaping (`ITelnetSession` has no - such path today). +- **Still inert, but no longer blocked.** A world's `keepalive` seconds only picks + the status bar's fake ack figure — nothing sends a keepalive. The upstream half is + done: TelnetNegotiationCore + [PR #52](https://github.com/HarryCordewener/TelnetNegotiationCore/pull/52) adds an + opt-in idle-reset `IAC NOP` keepalive, `.WithKeepAlive(TimeSpan)`, bounded to + 1s–24h, defaulting to 30s. +
+ **This field cannot be wired until that ships as 2.6.0.** The API doesn't exist in + the pinned 2.5.3, and it can't be reached through a conditional project reference + the way SharpConsoleUI is: that trick works only because both paths expose the same + API, and here the package path would not compile. So this waits on the release, not + on more design. When 2.6.0 lands: bump `Directory.Packages.props`, pass the world's + interval into `TelnetSessionOptions`, and hold the setting **by reference** like + `TextSettings`/`InputSettings` so changing it doesn't need a reconnect. +
+ Note what it will and won't do: `IAC NOP` proves the socket write succeeded, not + that the peer answered. TIMING-MARK (RFC 860, option 6) is the negotiated option + that verifies a peer is alive, and it isn't implemented upstream either — so a + keepalive here will keep a NAT from evicting an idle connection, and will not + detect a server that has stopped responding. **The shell connects as the world's first configured character** (`SharpMUTermApp.OpenSession`). Before that it opened an *anonymous* session, which From 64fb1a36604dc80ce576ad283de22ffb76b109ae Mon Sep 17 00:00:00 2001 From: Harry Cordewener Date: Wed, 29 Jul 2026 09:47:06 -0500 Subject: [PATCH 23/23] Wire the world's keepalive to the telnet session TelnetNegotiationCore 2.6.0 shipped the keepalive, so the field that had been inert since it was drawn now does something: a world's keepalive seconds becomes the idle window an IAC NOP goes out on, keeping a NAT or load balancer from evicting a connection that is merely quiet. ResolveKeepalive turns configured seconds into the interval. Zero is how the config spells "off". Anything past the library's 24-hour maximum is clamped rather than thrown, because the value can be hand-edited and refusing to connect over it would be the worse answer. There is deliberately no clamp against the library's one-second minimum. Writing the test found the guard could never fire -- this setting is a whole number of seconds, so every value that isn't already "off" is at least one -- and an unreachable branch claiming to be a safety net is worse than none. The test now pins the property the resolver relies on instead of the clamp it doesn't need. Applies at connect rather than live, and the docs say so: the library's KeepAliveInterval is init-only because the idle loop reads it once when it starts. That puts it with host, port, TLS and encoding rather than with the settings held by reference and read per line. What it does not do is also recorded: IAC NOP proves our write succeeded, not that the server answered, and being unnegotiated there is no way to detect a peer that mishandles it. TIMING-MARK (RFC 860) is the option that would verify the peer and is not implemented upstream. 1129 tests pass, up from 1119. Co-Authored-By: Claude Opus 5 (1M context) --- CLAUDE.md | 2 +- Directory.Packages.props | 2 +- docs/HANDOFF.md | 37 +++++---- src/SharpMUTerm.Core/Session/WorldSession.cs | 6 +- src/SharpMUTerm.Core/Telnet/TelnetSession.cs | 60 +++++++++++++- .../Telnet/KeepaliveIntervalTests.cs | 78 +++++++++++++++++++ 6 files changed, 159 insertions(+), 26 deletions(-) create mode 100644 tests/SharpMUTerm.Core.Tests/Telnet/KeepaliveIntervalTests.cs diff --git a/CLAUDE.md b/CLAUDE.md index 12e633f6..d15ca9bb 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -32,7 +32,7 @@ fallbacks) for inline images/maps. ## Repository state **M1 delivered, plus substantial M2–M4 work.** `SharpMUTerm.slnx` builds all ten projects on -`net10.0`; the solution has **1119 tests**, all passing. In place: +`net10.0`; the solution has **1129 tests**, all passing. In place: - **Core** — `AnsiParser` (SGR 16/256/truecolor), styled-line + `ScrollbackBuffer` model, `TcpTransport` (TLS + IPv6), `TelnetSession` (wraps TelnetNegotiationCore **2.5.3**), diff --git a/Directory.Packages.props b/Directory.Packages.props index b16544c7..fad1ba59 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -10,7 +10,7 @@ - + diff --git a/docs/HANDOFF.md b/docs/HANDOFF.md index 4810ae74..09222ef0 100644 --- a/docs/HANDOFF.md +++ b/docs/HANDOFF.md @@ -4,7 +4,7 @@ Context for whoever (human or agent) picks up this work next. - **Repository:** `SharpMUSH/SharpMUTerm` - **Start from:** a fresh branch off `main` -- **Tests:** 1119 across the solution (404 Core / 83 Graphics / 42 Scripting / +- **Tests:** 1129 across the solution (414 Core / 83 Graphics / 42 Scripting / 28 Web / 562 Tui), all passing; `dotnet build SharpMUTerm.slnx` clean (0 warnings from this repo; building against a local SharpConsoleUI clone surfaces 2 upstream NuGet advisory warnings for AngleSharp, which are the framework's, not ours) @@ -657,26 +657,25 @@ categories, and where each control sits: wants a reconnect, like every other rule. The numpad specifically **still cannot fire** — see *Which keys can actually fire* under Critical Gotchas — and F4 now says so on the row rather than leaving it to be discovered. -- **Still inert, but no longer blocked.** A world's `keepalive` seconds only picks - the status bar's fake ack figure — nothing sends a keepalive. The upstream half is - done: TelnetNegotiationCore - [PR #52](https://github.com/HarryCordewener/TelnetNegotiationCore/pull/52) adds an - opt-in idle-reset `IAC NOP` keepalive, `.WithKeepAlive(TimeSpan)`, bounded to - 1s–24h, defaulting to 30s. +- **Live at connect.** A world's `keepalive` seconds now sends `IAC NOP` after that + much outbound silence, via TelnetNegotiationCore 2.6.0's `.WithKeepAlive(TimeSpan)`. + `TelnetSessionOptions.ResolveKeepalive` turns the configured seconds into the + interval: zero is how the config spells "off", and anything past the library's + 24-hour maximum is clamped rather than thrown, since the value can be hand-edited + and refusing to connect would be the worse answer. There is deliberately no clamp + against the library's one-second *minimum* — this setting is a whole number of + seconds, so every value that isn't already "off" satisfies it, and an unreachable + guard claiming to be a safety net is worse than none.
- **This field cannot be wired until that ships as 2.6.0.** The API doesn't exist in - the pinned 2.5.3, and it can't be reached through a conditional project reference - the way SharpConsoleUI is: that trick works only because both paths expose the same - API, and here the package path would not compile. So this waits on the release, not - on more design. When 2.6.0 lands: bump `Directory.Packages.props`, pass the world's - interval into `TelnetSessionOptions`, and hold the setting **by reference** like - `TextSettings`/`InputSettings` so changing it doesn't need a reconnect. + It applies **at connect**, not live: the library's `KeepAliveInterval` is init-only + because the idle loop reads it once when it starts. Changing the field mid-session + takes effect on the next connect, like host, port, TLS and encoding.
- Note what it will and won't do: `IAC NOP` proves the socket write succeeded, not - that the peer answered. TIMING-MARK (RFC 860, option 6) is the negotiated option - that verifies a peer is alive, and it isn't implemented upstream either — so a - keepalive here will keep a NAT from evicting an idle connection, and will not - detect a server that has stopped responding. + What it does and doesn't do: `IAC NOP` keeps a NAT or load balancer from evicting a + quiet connection. It does **not** detect a server that has stopped responding — a + successful send only proves our write succeeded, and NOP is unnegotiated, so a peer + that mishandles it can't be detected either. TIMING-MARK (RFC 860, option 6) is the + negotiated option that would verify the peer, and it is not implemented upstream. **The shell connects as the world's first configured character** (`SharpMUTermApp.OpenSession`). Before that it opened an *anonymous* session, which diff --git a/src/SharpMUTerm.Core/Session/WorldSession.cs b/src/SharpMUTerm.Core/Session/WorldSession.cs index 03d5e144..cf3f3e35 100644 --- a/src/SharpMUTerm.Core/Session/WorldSession.cs +++ b/src/SharpMUTerm.Core/Session/WorldSession.cs @@ -437,7 +437,11 @@ private void SetState(ConnectionState state, Exception? error) private ITelnetSession DefaultSessionFactory(ConnectionOptions options) => new TelnetSession( new TcpTransport(options), - options: new TelnetSessionOptions { CharsetOrder = TelnetSessionOptions.PreferEncoding(World.Encoding) }); + options: new TelnetSessionOptions + { + CharsetOrder = TelnetSessionOptions.PreferEncoding(World.Encoding), + KeepaliveInterval = TelnetSessionOptions.ResolveKeepalive(World.KeepaliveSeconds), + }); public async ValueTask DisposeAsync() { diff --git a/src/SharpMUTerm.Core/Telnet/TelnetSession.cs b/src/SharpMUTerm.Core/Telnet/TelnetSession.cs index 7dd34a92..ae836559 100644 --- a/src/SharpMUTerm.Core/Telnet/TelnetSession.cs +++ b/src/SharpMUTerm.Core/Telnet/TelnetSession.cs @@ -22,6 +22,47 @@ public sealed class TelnetSessionOptions /// Read buffer size in bytes. public int ReceiveBufferSize { get; init; } = 8192; + /// + /// How long the connection may sit silent before a keepalive goes out, or null for none — a + /// world's , resolved + /// by . + /// + /// This is applied when the interpreter is built, so changing it takes effect on the next connect + /// rather than on the open session: the library's KeepAliveInterval is init-only, by design + /// — the idle loop reads it once when it starts. + /// + /// + public TimeSpan? KeepaliveInterval { get; init; } + + /// + /// Turns a world's configured keepalive seconds into an interval the telnet library will accept, + /// or null when there should be none. + /// + /// Zero — the default, and what "off" is spelled as in the config — means no keepalive. Anything + /// larger is clamped to the library's maximum rather than thrown at it, because this value arrives + /// from a config file that may have been hand-edited: refusing to connect at all would be a worse + /// answer than keeping the connection alive less often than asked. + /// + /// + /// There is deliberately no clamp against the library's minimum. It is one second and this + /// is a whole number of seconds, so every value that isn't already "off" satisfies it — a guard + /// there could never fire, and an unreachable branch claiming to be a safety net is worse than + /// none. If this ever becomes fractional, that changes. + /// + /// + public static TimeSpan? ResolveKeepalive(int seconds) + { + if (seconds <= 0) + { + return null; + } + + var requested = TimeSpan.FromSeconds(seconds); + return requested > TelnetInterpreter.MaximumKeepAliveInterval + ? TelnetInterpreter.MaximumKeepAliveInterval + : requested; + } + /// The default order, used when no world encoding is configured or the name isn't one. private static Encoding[] DefaultOrder => [ @@ -137,8 +178,9 @@ public async Task ConnectAsync(CancellationToken cancellationToken = default) _readLoop = Task.Run(() => ReadLoopAsync(_loopCts.Token), CancellationToken.None); } - private Task BuildInterpreterAsync() => - new TelnetInterpreterBuilder() + private Task BuildInterpreterAsync() + { + var builder = new TelnetInterpreterBuilder() .UseMode(TelnetInterpreter.TelnetMode.Client) .UseLogger(_logger) .OnNegotiation(WriteToTransportAsync) @@ -152,8 +194,18 @@ private Task BuildInterpreterAsync() => onPrompt: OnPromptAsync, charsetOrder: _options.CharsetOrder, onCompressionEnabled: OnCompressionAsync, - onMXPEnabled: static () => ValueTask.CompletedTask) - .BuildAsync(); + onMXPEnabled: static () => ValueTask.CompletedTask); + + // An idle keepalive, when the world asks for one: IAC NOP after the configured silence, so a + // NAT or load balancer doesn't evict a connection that is merely quiet. It is filler traffic, + // not a liveness probe — it proves our write succeeded, not that the server answered. + if (_options.KeepaliveInterval is { } interval) + { + builder = builder.WithKeepAlive(interval); + } + + return builder.BuildAsync(); + } private ValueTask WriteToTransportAsync(ReadOnlyMemory data) => _transport.SendAsync(data); diff --git a/tests/SharpMUTerm.Core.Tests/Telnet/KeepaliveIntervalTests.cs b/tests/SharpMUTerm.Core.Tests/Telnet/KeepaliveIntervalTests.cs new file mode 100644 index 00000000..a0f9f212 --- /dev/null +++ b/tests/SharpMUTerm.Core.Tests/Telnet/KeepaliveIntervalTests.cs @@ -0,0 +1,78 @@ +using SharpMUTerm.Core.Telnet; +using TelnetNegotiationCore.Interpreters; + +namespace SharpMUTerm.Core.Tests.Telnet; + +/// +/// A world's keepalive seconds (F5) becomes the idle window the telnet session sends +/// IAC NOP on. Before this it picked a figure in the status bar and nothing else — there was +/// no keepalive at all, in either direction. +/// +/// The resolver clamps rather than throws, because this value arrives from a config file that may +/// predate the library's bounds or have been hand-edited. Refusing to connect over an out-of-range +/// keepalive would be a worse answer than keeping the connection alive a little more or less often +/// than the file asked for. +/// +/// +public class KeepaliveIntervalTests +{ + [Test] + public async Task AConfiguredIntervalIsUsedAsGiven() + { + await Assert.That(TelnetSessionOptions.ResolveKeepalive(90)).IsEqualTo(TimeSpan.FromSeconds(90)); + } + + /// Zero is how the config spells "off", and it is the default for a new world. + [Test] + [Arguments(0)] + [Arguments(-1)] + [Arguments(int.MinValue)] + public async Task ZeroOrNegativeMeansNoKeepalive(int seconds) + { + await Assert.That(TelnetSessionOptions.ResolveKeepalive(seconds)).IsNull(); + } + + /// + /// The smallest keepalive that isn't "off" already satisfies the library's minimum, because that + /// minimum is one second and this setting is a whole number of them. This pins the property the + /// resolver relies on rather than the clamp it therefore doesn't need. + /// + [Test] + public async Task TheSmallestKeepaliveThatIsNotOffMeetsTheLibrarysMinimum() + { + await Assert.That(TelnetInterpreter.MinimumKeepAliveInterval) + .IsLessThanOrEqualTo(TimeSpan.FromSeconds(1)); + + await Assert.That(TelnetSessionOptions.ResolveKeepalive(1)).IsEqualTo(TimeSpan.FromSeconds(1)); + } + + /// + /// Clamped against the library's own constant rather than a number copied here, so the two cannot + /// drift apart if the library ever moves it. + /// + [Test] + public async Task AnIntervalAboveTheLibrarysMaximumIsClampedDownToIt() + { + var resolved = TelnetSessionOptions.ResolveKeepalive(int.MaxValue); + + await Assert.That(resolved).IsEqualTo(TelnetInterpreter.MaximumKeepAliveInterval); + } + + /// + /// Whatever the resolver returns must be something the library will actually accept — this is the + /// assertion that matters, since the clamp exists precisely so a builder never throws at connect. + /// + [Test] + [Arguments(1)] + [Arguments(30)] + [Arguments(3600)] + [Arguments(int.MaxValue)] + public async Task AnyResolvedIntervalIsInsideTheLibrarysAcceptedRange(int seconds) + { + var resolved = TelnetSessionOptions.ResolveKeepalive(seconds); + + await Assert.That(resolved).IsNotNull(); + await Assert.That(resolved!.Value).IsGreaterThanOrEqualTo(TelnetInterpreter.MinimumKeepAliveInterval); + await Assert.That(resolved.Value).IsLessThanOrEqualTo(TelnetInterpreter.MaximumKeepAliveInterval); + } +}