Let Tab write a suggestion and open the list on typing, not on caret moves

CHANGELOG.md

@@ -86,6 +86,12 @@ is not part of this repository.
 - A button that cannot be pressed has no fill, and one that can has a slightly lighter fill than
   before.
 - The state and startup type marks in the list and in the details panel are a little larger.
+- Tab in the search box writes the highlighted suggestion, the same as Enter, and keeps the cursor
+  in the box - so `sta`, Tab, Tab gives `status:running`. When there is nothing to write, or the
+  list shows the example questions, Tab moves on to the next control as before. While an input
+  method is still composing a character, neither Tab nor Enter writes a suggestion.
+- The list of suggestions opens when you type, not when you only move the cursor with the arrow
+  keys or a click. Down still opens it wherever the cursor is.
 
 ### Removed
 

README.md

@@ -492,7 +492,8 @@ the third ends the process.
 shows every component of the window in every state, and reads nothing from your machine.
 
 Three lists on the switch above the search box - *Services*, *Drivers*, *All* - each saying
-how big it is. The search box takes the query language and suggests as you type. The filter
+how big it is. The search box takes the query language and suggests as you type - Tab or Enter
+writes the highlighted word. The filter
 buttons write into the box. *Columns* chooses what the list shows, a right-click on a column heading
 narrows the list to that value or puts the column away, and the layout you leave is the layout it
 opens in. A row's menu previews every operation before offering it, and copies the name or

src/Bws.Gui/MainWindow.Keyboard.cs

@@ -80,6 +80,11 @@ protected override async void OnPreviewKeyDown(KeyEventArgs e)
     /// <b>And in the box, Enter belongs to the list UNDER the box while that list is open</b> - and
     /// to nobody while it is closed, which is what it was before the list existed (decision 8 of
     /// the design). Down and Up belong to that list from the box and to the grid from the grid.
+    ///
+    /// <b>Tab writes a word in the box while a list of WORDS is open, and walks on otherwise</b> -
+    /// in the box with the questions open or nothing to write, and everywhere outside the box.
+    /// Owner's decision of 2026-09-25, and why the questions are left out is at
+    /// <see cref="Suggesting.TabWrites"/>.
     /// </summary>
     internal Shortcut Wanted(Key key, ModifierKeys modifiers, bool inTheBox, bool inTheGrid)
     {
@@ -89,14 +94,15 @@ internal Shortcut Wanted(Key key, ModifierKeys modifiers, bool inTheBox, bool in
         {
             return wanted switch
             {
-                Shortcut.OpenDetails => _model.Suggesting.IsOpen ? Shortcut.TakeSuggestion : Shortcut.None,
+                Shortcut.OpenDetails => _model.Suggesting.CanTake ? Shortcut.TakeSuggestion : Shortcut.None,
+                Shortcut.CompleteWord => _model.Suggesting.TabWrites ? Shortcut.TakeSuggestion : Shortcut.None,
                 Shortcut.CopyRow => Shortcut.None,
                 _ => wanted
             };
         }
 
         var theListPress = wanted is Shortcut.OpenDetails or Shortcut.CopyRow;
-        var theBoxPress = wanted is Shortcut.NextSuggestion or Shortcut.PreviousSuggestion;
+        var theBoxPress = wanted is Shortcut.NextSuggestion or Shortcut.PreviousSuggestion or Shortcut.CompleteWord;
 
         return (theListPress && !inTheGrid) || theBoxPress ? Shortcut.None : wanted;
     }

src/Bws.Gui/MainWindow.Suggesting.cs

@@ -125,11 +125,23 @@ private void WatchTheBoxForSuggestions()
         // THE BOX'S TEXT, NOT THE MODEL'S. The binding to QueryText waits 400 ms so that the list
         // of entries does not narrow under every keystroke, and a list of completions that waited
         // with it would be a list answering the previous keystroke. The caret and the text arrive
-        // as two events and both recompute from the current values, so their order is not relied
-        // on.
+        // as two events and both go to Follow with the current values, which tells typing from a
+        // caret moving through unchanged text by the text itself - so their order is not relied on.
         box.TextChanged += (_, _) => FollowTheBox();
         box.SelectionChanged += (_, _) => FollowTheBox();
 
+        // NOTHING IS WRITTEN OVER A CHARACTER STILL BEING COMPOSED - review of PR 22, and
+        // Suggesting.CanTake says why. The start and the end of every text composition in the box,
+        // handled or not, because an input method's own handling is exactly the case this is for.
+        box.AddHandler(
+            TextCompositionManager.PreviewTextInputStartEvent,
+            new TextCompositionEventHandler((_, _) => list.Composing(open: true)),
+            handledEventsToo: true);
+        box.AddHandler(
+            TextCompositionManager.PreviewTextInputEvent,
+            new TextCompositionEventHandler((_, _) => list.Composing(open: false)),
+            handledEventsToo: true);
+
         Search.List.PreviewMouseLeftButtonUp += (_, e) => TakeUnderThePointer(e);
 
         Deactivated += (_, _) => list.Close();
@@ -257,6 +269,11 @@ private bool Write(Suggestion? taken)
         box.SelectedText = taken.Written;
         box.CaretIndex = start + taken.Written.Length;
 
+        // Followed as typing, because the last thing the box just reported is its caret moving
+        // through unchanged text - which closes the list since 2026-09-25, and would take away the
+        // values that belong after a field just written. Suggesting.Wrote says it in full.
+        _model.Suggesting.Wrote(box.Text, box.CaretIndex);
+
         return true;
     }
 }

src/Bws.Gui/Resources/gui.en.json

@@ -121,6 +121,7 @@
   "gui.example.waitingOnTrigger": "Stopped, waiting on a trigger",
 
   "gui.suggest.keys": "Up and Down choose, Enter writes it, Escape closes",
+  "gui.suggest.keys.words": "Tab or Enter writes it, Up and Down choose, Escape closes",
   "gui.suggest.caption.questions": "Questions to start from",
   "gui.suggest.caption.words": "What can go here",
   "gui.suggest.spoken": "{0}, {1}, {2} of {3}",

src/Bws.Gui/Shortcuts.cs

@@ -51,7 +51,8 @@ internal static Shortcut For(Key key, ModifierKeys modifiers)
 
         // DOWN AND UP MEAN THE LIST UNDER THE SEARCH BOX, since 2026-09-15 - and only there, which
         // is the window's half to decide, the same way Enter means the details only from the grid.
-        // From anywhere else they are the arrows every control already has an opinion about.
+        // From anywhere else they are the arrows every control already has an opinion about. Tab
+        // the same, since 2026-09-25 - and only without a modifier, so Shift+Tab always walks back.
         return key switch
         {
             Key.F5 => Shortcut.Refresh,
@@ -60,6 +61,7 @@ internal static Shortcut For(Key key, ModifierKeys modifiers)
             Key.Enter => Shortcut.OpenDetails,
             Key.Down => Shortcut.NextSuggestion,
             Key.Up => Shortcut.PreviousSuggestion,
+            Key.Tab => Shortcut.CompleteWord,
             _ => Shortcut.None
         };
     }
@@ -157,5 +159,16 @@ internal enum Shortcut
     /// Enter, and Enter from the grid means the details - which of the two a press means depends
     /// on where the keyboard is and whether the list is open, and both are the window's to know.
     /// </summary>
-    TakeSuggestion
+    TakeSuggestion,
+
+    /// <summary>
+    /// Tab: write the chosen WORD of the list under the search box - the reflex from PowerShell and
+    /// every editor, owner's decision of 2026-09-25 (`docs/PROJEKT-PODPOWIEDZI-UX-20260925.md`, T1).
+    ///
+    /// <b>Never carried out as itself.</b> Tab walks through the window everywhere else, so the
+    /// window turns this into <see cref="TakeSuggestion"/> in the box while a list of words is open
+    /// and into <see cref="None"/> in every other case - handed back, the press moves the keyboard on
+    /// as it always did.
+    /// </summary>
+    CompleteWord
 }

src/Bws.Gui/ViewModels/MainViewModel.Checking.cs

@@ -34,7 +34,7 @@ protected override IEnumerable<string> ErrorsOf(string property) =>
     /// </summary>
     private void AboutTheQuery(string problem)
     {
-        if (Says.AboutTheQuery(_queryText, problem))
+        if (Says.AboutTheQuery(problem))
         {
             RaiseErrors(nameof(QueryText));
         }

src/Bws.Gui/ViewModels/Says.cs

@@ -23,7 +23,6 @@ public sealed class Says : Observable
     private string _status = Texts.Of("gui.status.reading");
 
     private string _queryProblem = string.Empty;
-    private bool _asking;
     private string _refusal = string.Empty;
     private string _layout = string.Empty;
     private string _done = string.Empty;
@@ -129,40 +128,30 @@ private void Admit(Admitted admitted)
     public string QueryProblem => _queryProblem;
 
     /// <summary>
-    /// The line under the search box: what is wrong with the query, or else what the answer to it
-    /// has to admit.
+    /// What the search field says about its query: what is wrong with it, or else what the answer
+    /// to it has to admit. Since 2026-09-25 in a short form at the field's right end and in full in
+    /// the panel under it - it stood in a line of its own under the box until then.
     ///
-    /// <b>One line rather than two, and the mistake wins</b> - a query that does not read has no
+    /// <b>One sentence rather than two, and the mistake wins</b> - a query that does not read has no
     /// answer of its own to qualify, and the list under it is the previous one.
+    ///
+    /// <b>It still speaks with the box empty, and that is rule 8.</b> A column on screen asks for a
+    /// family too (MainViewModel.Asked), so a shown Memory column gets a note here while the window
+    /// reads what fills it - or the window reads for seconds with no sentence about it.
     /// </summary>
     public string AnswerLine => _queryProblem.Length > 0 ? _queryProblem : _admitted.Reservations;
 
     /// <summary>Whether <see cref="AnswerLine"/> is a mistake - what colours it.</summary>
     public bool AnswerLineIsProblem => _queryProblem.Length > 0;
 
-    /// <summary>
-    /// Whether the line under the box takes any room: while there is text in the box, or while
-    /// the line has something to say.
-    ///
-    /// <b>Not always, because the window's chrome already takes nearly half its height</b>
-    /// (UX-GUI-007). <b>Not only while it has words, because then the list would jump</b> each time a
-    /// reading note came and went under somebody's typing. Tied to the box instead, the line appears
-    /// with the first character and goes when the box is emptied - a move the person made.
-    ///
-    /// <b>UNLESS IT STILL HAS SOMETHING TO SAY, and that half is rule 8 rather than layout.</b> A
-    /// column on screen asks for a family too (MainViewModel.Asked), so with the box empty a shown
-    /// Memory column still gets a note while the window reads what fills it. The reservations no
-    /// longer stand under the list, so without this half that note would be said nowhere - the
-    /// window reading for seconds with no sentence about it. The review of PR #11 caught the user
-    /// changelog promising only the first half.
-    /// </summary>
-    public bool AnswerLineShown => _asking || AnswerLine.Length > 0;
+    // AnswerLineShown and the flag behind it went on 2026-09-25 (backlog 461): they said whether
+    // a line under the box took room, and that line went with the palette the same day, when the
+    // sentence moved into the field so that typing no longer moves the window.
 
     private void RaiseTheAnswerLine()
     {
         Raise(nameof(AnswerLine));
         Raise(nameof(AnswerLineIsProblem));
-        Raise(nameof(AnswerLineShown));
     }
 
     /// <summary>
@@ -413,35 +402,29 @@ internal void Moved()
     }
 
     /// <summary>
-    /// What is wrong with the query in the box, which may be nothing, and whether the box holds
-    /// anything at all. Answers whether the sentence changed, so the caller can tell the box
-    /// without telling it once a second for nothing.
+    /// What is wrong with the query in the box, which may be nothing. Answers whether the sentence
+    /// changed, so the caller can tell the box without telling it once a second for nothing.
     ///
     /// <b>The second half of the sentence is written here rather than by the caller</b>, because it
     /// is true of every mistake: the list stays, so it is the previous answer.
     /// </summary>
-    internal bool AboutTheQuery(string text, string problem)
+    internal bool AboutTheQuery(string problem)
     {
         var sentence = problem.Length == 0
             ? string.Empty
             : problem + " " + Texts.Of("gui.query.listIsPrevious");
 
-        var asking = text.Length > 0;
-
-        if (_queryProblem == sentence && _asking == asking)
+        if (_queryProblem == sentence)
         {
             return false;
         }
 
-        var changed = _queryProblem != sentence;
-
         _queryProblem = sentence;
-        _asking = asking;
 
         Raise(nameof(QueryProblem));
         RaiseTheAnswerLine();
 
-        return changed;
+        return true;
     }
 
     /// <summary>