gui: the format list's contents as their own type, the Space that opens it kept out of its filter, and the focus guard asked where the list sends the keyboard

CI on #127 was red on every system with the same three guards:
- TestAPressMovesTheKeyboardWithoutDrawingItsMark still asked for the
  keyboard on the list itself, and the list now hands it to its filter box.
  It asks OpenList.Keyboard and presses Down on whatever has the keyboard.
- OpenList had grown to 24 methods, the fourth type past the crowding line.
  What the list holds and has drawn moved to listContents, embedded, so
  Rows, DrawnRows and RowShowing read as before. 24 -> 19.

From the review of #127:
- Space at the shut Format menu opened the list and then typed a space into
  its filter (the driver hands the character to whatever has the keyboard
  after the key moved it). Seen in the real window. FilterBox drops white
  space while it is empty, held by a new guard.
- The heading-shape check fails when no heading was drawn.
- CHANGELOG: a kind matches when any of its words starts with what is typed.

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

Author: donislawdev

CHANGELOG.md

@@ -20,7 +20,8 @@ because it turns other people's test suites red.
   list stands under headings - Archives, Documents, Pictures, Sound, Text and
   data - each saying how many formats are under it, and a box at its top
   narrows it to the formats whose name holds what is typed, or whose kind
-  starts with it (`gz` finds `targz`, `pict` every picture). The letters that
+  has a word that starts with it (`gz` finds `targz`, `pict` every picture,
+  `data` every text and data format). The letters that
   matched are drawn in bold, the arrows step over the headings, and typing
   at the shut `Format` menu opens the list with those letters in the box, so
   `jxl` typed there ends on `jxl`. The shut menu draws the kind of the format

internal/guard/formatlist_test.go

@@ -131,11 +131,22 @@ func TestTheFormatListStandsUnderAHeadingForEachKind(t *testing.T) {
 	if !sort.StringsAreSorted(titles) {
 		t.Errorf("the headings stand in the order %v, and a closed set is in the order of its words", titles)
 	}
+	// Counted, because a loop over the drawn rows passes just as well when no
+	// heading was drawn at all - an outside review of #127 named it, and it is
+	// trap 1 of CLAUDE.md: the guard has to be in the state it asks about.
+	drawnHeadings := 0
 	for _, row := range list.DrawnRows() {
-		if row.Heading() && (row.Kind() != nil || row.Marked()) {
+		if !row.Heading() {
+			continue
+		}
+		drawnHeadings++
+		if row.Kind() != nil || row.Marked() {
 			t.Errorf("the heading %q draws a picture or a tick, which says it is a value somebody can take", row.Label())
 		}
 	}
+	if drawnHeadings == 0 {
+		t.Fatal("no heading row is drawn, so nothing was asked about how a heading looks")
+	}
 }
 
 // TestTypingIntoTheFormatListNarrowsItAndLandsOnWhatStartsWithIt types into
@@ -252,6 +263,40 @@ func TestTypingAtTheShutFormatMenuOpensItsFilter(t *testing.T) {
 	}
 }
 
+// TestTheSpaceThatOpensTheFormatListIsNotTypedIntoItsFilter presses Space at
+// the shut menu the way the driver delivers it: the key to whatever has the
+// keyboard, then the character to whatever has it NOW (fyne v2.8.1
+// internal/driver/glfw/window.go, processKeyPressed and processCharInput both
+// ask canvas.Focused()). The key opens the list and hands the keyboard to the
+// box, so the character landed in the box.
+//
+// Reported by an outside review of #127 and seen in the real window through
+// tools/pilot.py before this was written: after Space the box lost its
+// placeholder and the caret stood one space in, with nothing visible typed.
+func TestTheSpaceThatOpensTheFormatListIsNotTypedIntoItsFilter(t *testing.T) {
+	c, content := screenOnACanvas(t)
+	menu := chooserUnder(t, content, text.FieldFormat())
+	c.Focus(menu)
+	c.Focused().TypedKey(&fyne.KeyEvent{Name: fyne.KeySpace})
+	list := menu.Opened()
+	if list == nil || list.Filter() == nil {
+		t.Fatal("Space at the shut format menu opened no list with a box to narrow it, so this guard is not in the state it asks about")
+	}
+	if c.Focused() != fyne.Focusable(list.Filter()) {
+		t.Fatalf("after Space the keyboard is on %T rather than in the box, so the character would not reach it", c.Focused())
+	}
+	c.Focused().TypedRune(' ')
+	if got := list.Filter().Text; got != "" {
+		t.Errorf("the Space that opened the list left %q in its box, which hides the placeholder and moves the caret", got)
+	}
+	// A space between words is still a space: only an empty box drops one.
+	c.Focused().TypedRune('t')
+	c.Focused().TypedRune(' ')
+	if got := list.Filter().Text; got != "t " {
+		t.Errorf("t then Space typed into the box left %q, and a space after a letter is somebody typing", got)
+	}
+}
+
 // TestThePartOfAValueThatMatchedIsDrawnInBold reads a row's drawn words.
 func TestThePartOfAValueThatMatchedIsDrawnInBold(t *testing.T) {
 	_, _, list, filter := openFormatList(t)

internal/guard/pointerfocus_test.go

@@ -50,8 +50,26 @@ func TestAPressMovesTheKeyboardWithoutDrawingItsMark(t *testing.T) {
 	// a press and leaves focusing to the widget, and the switch left it.
 	// On the list the press opened, which is where the arrows have to work.
 	// Closing it hands the keyboard back to the menu (see Chooser.giveBack).
-	if list := menu.Opened(); list == nil || c.Focused() != fyne.Focusable(list) {
-		t.Errorf("the format menu was pressed and the keyboard is on %T, not on the list it opened", c.Focused())
+	//
+	// "On the list" is where the list says the keyboard goes, since the list
+	// of 2026-09-23 took a filter: the box at its top has the keyboard and
+	// hands the arrows on (FilterBox.TypedKey). Asked of OpenList.Keyboard
+	// rather than of a type, and then the arrow is pressed on whatever has the
+	// keyboard - so the guard holds the promise, not the shape it took.
+	list := menu.Opened()
+	if list == nil {
+		t.Fatal("the format menu was pressed and opened no list")
+	}
+	if c.Focused() != list.Keyboard() {
+		t.Errorf("the format menu was pressed and the keyboard is on %T, not where the list it opened takes it (%T)",
+			c.Focused(), list.Keyboard())
+	}
+	if focused := c.Focused(); focused != nil {
+		before := list.Active()
+		focused.TypedKey(&fyne.KeyEvent{Name: fyne.KeyDown})
+		if list.Active() == before {
+			t.Errorf("Down pressed on %T moved nothing in the list the press opened - the keyboard is somewhere the arrows do not work", focused)
+		}
 	}
 
 	// The list the press opened is taken away first. A real press respects what

internal/gui/parts/filterbox.go

@@ -1,6 +1,8 @@
 package parts
 
 import (
+	"unicode"
+
 	"fyne.io/fyne/v2"
 
 	"github.com/donislawdev/TestingFilesGenerator/internal/gui/text"
@@ -47,3 +49,25 @@ func (f *FilterBox) TypedKey(event *fyne.KeyEvent) {
 	}
 	f.Entry.Entry.TypedKey(event)
 }
+
+// TypedRune drops white space typed into an empty box, and takes everything
+// else as the box it is.
+//
+// The case it is for is the Space that OPENS the list. The driver hands the
+// key to whatever has the keyboard and then the character to whatever has it
+// after that - and the key is what moved the keyboard here (Chooser.TypedKey
+// opens the list, the list hands the keyboard to this box). So the character
+// of the same press landed in the box: no placeholder, the caret one space in,
+// and nothing on screen saying why. Reported by an outside review of #127,
+// seen in the real window, held by
+// TestTheSpaceThatOpensTheFormatListIsNotTypedIntoItsFilter.
+//
+// Only while the box is empty, because a space after a word is somebody
+// typing - and a leading one means nothing to the list anyway, which trims
+// what it narrows by (narrowTo).
+func (f *FilterBox) TypedRune(r rune) {
+	if f.Text == "" && unicode.IsSpace(r) {
+		return
+	}
+	f.Entry.TypedRune(r)
+}

internal/gui/parts/listcontents.go

@@ -0,0 +1,106 @@
+package parts
+
+import (
+	"fyne.io/fyne/v2/widget"
+)
+
+// listContents is what an open list holds and what it has drawn: the values,
+// how they are grouped and narrowed, the rows that arrangement comes to, and
+// the rows the toolkit has actually built for it.
+//
+// Its own type rather than more of OpenList, since the list of 2026-09-23
+// took headings and a filter. OpenList stood at 24 methods, the fourth type in
+// the tree past the crowding line, and TestNoSecondTypeIsCreepingUpOnTheTypeCeilings
+// asks for behaviour to move out rather than for the line to move. What moved
+// is one question - what is in this list, and what does each row draw - which
+// the widget, the keyboard and the layout only ask. OpenList embeds it, so a
+// guard still reads list.Rows() and list.DrawnRows() where it always did.
+type listContents struct {
+	options []string
+	// chosen is the value in the box, marked with a tick. Empty when the box
+	// shows a default nobody has confirmed - see the note in preset.go about a
+	// filled field making "I did not say" impossible to express.
+	chosen string
+
+	// headingOf is the heading a value stands under, or nil for a list with no
+	// headings. See OpenList.GroupUnder.
+	headingOf func(string) string
+	// typed is what is in the filter box, or nothing for a list without one.
+	typed string
+	// entries is what the list draws now - headings, values and the notice
+	// that nothing matched - worked out by arrange. Every row number in this
+	// package is a position in entries, never in options, because the two part
+	// the moment a list has a heading.
+	entries []listEntry
+
+	// rows is the row showing each position, recorded as the list fills them.
+	//
+	// A registry rather than a walk, because a walk cannot get in: widget.List
+	// keeps the rows it built inside its renderer, so a tree walk stops at the
+	// list and reports an open list with nothing in it. Measured on 2026-08-18
+	// while trying to photograph a row under the pointer.
+	//
+	// Every entry is current whatever the list has scrolled past, because a
+	// recycled row is refilled before it is shown and fill is what writes here.
+	rows map[widget.ListItemID]*ListRow
+}
+
+// rearrange works out the rows again after the filter or the grouping
+// changed, and forgets the rows it recorded: a row built for the old
+// arrangement can still hold a label the list no longer draws, and
+// RowShowing would report it.
+func (c *listContents) rearrange() {
+	c.entries = arrange(c.options, c.headingOf, c.typed)
+	c.rows = map[widget.ListItemID]*ListRow{}
+}
+
+// Rows is what this list is showing, for a guard to read, in the order it is
+// drawn - headings and the notice included, so that a position from Active
+// is a position here.
+//
+// The toolkit's menu turned items into widgets of an unexported type, so what
+// was marked could not be read back off the canvas - only that something was
+// open. This is the half of that pair we own, and it says what is in the list
+// and which row carries the tick.
+func (c *listContents) Rows() []Choice {
+	out := make([]Choice, 0, len(c.entries))
+	for _, e := range c.entries {
+		value := e.kind == entryValue
+		out = append(out, Choice{Label: e.text, Marked: value && c.isChosen(e.text), Choosable: value})
+	}
+	return out
+}
+
+// isChosen says whether a value is the one in the box.
+//
+// One function rather than the same comparison written where a row is filled
+// and again where the list reports itself. Two copies is what it was for an
+// hour on 2026-08-18, and the mutation runner said so at once: blanking the
+// drawn mark left the guard green, because the guard was reading the other
+// copy. A rule with two homes is a rule no test can pin down.
+func (c *listContents) isChosen(value string) bool { return value == c.chosen }
+
+// DrawnRows is every row the list has actually built, for a guard that has to
+// ask what is on the screen rather than what the list holds.
+//
+// Rows above answers from the options, which is the right half for "what is in
+// this list" and the wrong half for "what does a row draw". A picture that
+// never reaches a row would pass the first and fail this one.
+func (c *listContents) DrawnRows() []*ListRow {
+	out := make([]*ListRow, 0, len(c.rows))
+	for _, row := range c.rows {
+		out = append(out, row)
+	}
+	return out
+}
+
+// RowShowing is the row currently drawing one value, or nil if that value is
+// scrolled out of sight. For a guard that needs to press or hover a real row.
+func (c *listContents) RowShowing(label string) *ListRow {
+	for _, row := range c.rows {
+		if row.Label() == label {
+			return row
+		}
+	}
+	return nil
+}

internal/gui/parts/openlist.go

@@ -39,14 +39,13 @@ import (
 type OpenList struct {
 	widget.BaseWidget
 
-	options []string
+	// listContents is what the list holds and what it has drawn - see
+	// listcontents.go for why it is a type of its own.
+	listContents
+
 	// room is how much height the window has left for this list, or nought for
 	// no limit. See LimitTo and MinSize.
 	room float32
-	// chosen is the value in the box, marked with a tick. Empty when the box
-	// shows a default nobody has confirmed - see the note in preset.go about a
-	// filled field making "I did not say" impossible to express.
-	chosen string
 	// active is the row the keyboard is on, or -1 when it has not been used,
 	// and shown is whether that is drawn.
 	//
@@ -63,41 +62,22 @@ type OpenList struct {
 	close func(byKeyboard bool)
 
 	list *widget.List
-	// rows is the row showing each position, recorded as the list fills them.
-	//
-	// A registry rather than a walk, because a walk cannot get in: widget.List
-	// keeps the rows it built inside its renderer, so a tree walk stops at the
-	// list and reports an open list with nothing in it. Measured on 2026-08-18
-	// while trying to photograph a row under the pointer.
-	//
-	// Every entry is current whatever the list has scrolled past, because a
-	// recycled row is refilled before it is shown and fill is what writes here.
-	rows map[widget.ListItemID]*ListRow
 
 	// KindOf says what picture goes in front of one value, or nil for a list
 	// whose values are not things of different kinds. Set from outside, because
 	// only the screen putting values in knows what they are.
 	KindOf func(string) fyne.Resource
 
-	// headingOf is the heading a value stands under, or nil for a list with no
-	// headings. See GroupUnder.
-	headingOf func(string) string
 	// filter is the box at the top that narrows the list, or nil for a list
-	// without one, and typed is what is in it. See WithFilter.
+	// without one. What is typed into it is listContents.typed. See WithFilter.
 	filter *FilterBox
-	typed  string
-	// entries is what the list draws now - headings, values and the notice
-	// that nothing matched - worked out by arrange. Every row number in this
-	// file is a position in entries, never in options, because the two part
-	// the moment a list has a heading.
-	entries []listEntry
 }
 
 // NewOpenList builds the list. take is called with the value somebody settled
 // on, and close when they left without settling on one.
 func NewOpenList(options []string, chosen string, take func(string, bool), close func(bool)) *OpenList {
-	l := &OpenList{options: options, chosen: chosen, active: -1, take: take, close: close,
-		rows: map[widget.ListItemID]*ListRow{}}
+	l := &OpenList{active: -1, take: take, close: close,
+		listContents: listContents{options: options, chosen: chosen, rows: map[widget.ListItemID]*ListRow{}}}
 	l.entries = arrange(options, nil, "")
 	l.list = widget.NewList(
 		func() int { return len(l.entries) },
@@ -138,15 +118,6 @@ func (l *OpenList) Keyboard() fyne.Focusable {
 // Filter is the box at the top of the list, or nil, for a guard to type into.
 func (l *OpenList) Filter() *FilterBox { return l.filter }
 
-// rearrange works out the rows again after the filter or the grouping
-// changed, and forgets the rows it recorded: a row built for the old
-// arrangement can still hold a label the list no longer draws, and
-// RowShowing would report it.
-func (l *OpenList) rearrange() {
-	l.entries = arrange(l.options, l.headingOf, l.typed)
-	l.rows = map[widget.ListItemID]*ListRow{}
-}
-
 // narrowTo is the filter box reporting what it now holds. The keyboard lands
 // where landing says and the bar is drawn, because typing is using the
 // keyboard - except when the box has been emptied, where the list goes back
@@ -204,57 +175,6 @@ func (l *OpenList) fill(id widget.ListItemID, row fyne.CanvasObject) {
 	r.Refresh()
 }
 
-// Rows is what this list is showing, for a guard to read, in the order it is
-// drawn - headings and the notice included, so that a position from Active
-// is a position here.
-//
-// The toolkit's menu turned items into widgets of an unexported type, so what
-// was marked could not be read back off the canvas - only that something was
-// open. This is the half of that pair we own, and it says what is in the list
-// and which row carries the tick.
-func (l *OpenList) Rows() []Choice {
-	out := make([]Choice, 0, len(l.entries))
-	for _, e := range l.entries {
-		value := e.kind == entryValue
-		out = append(out, Choice{Label: e.text, Marked: value && l.isChosen(e.text), Choosable: value})
-	}
-	return out
-}
-
-// isChosen says whether a value is the one in the box.
-//
-// One function rather than the same comparison written where a row is filled
-// and again where the list reports itself. Two copies is what it was for an
-// hour on 2026-08-18, and the mutation runner said so at once: blanking the
-// drawn mark left the guard green, because the guard was reading the other
-// copy. A rule with two homes is a rule no test can pin down.
-func (l *OpenList) isChosen(value string) bool { return value == l.chosen }
-
-// DrawnRows is every row the list has actually built, for a guard that has to
-// ask what is on the screen rather than what the list holds.
-//
-// Rows above answers from the options, which is the right half for "what is in
-// this list" and the wrong half for "what does a row draw". A picture that
-// never reaches a row would pass the first and fail this one.
-func (l *OpenList) DrawnRows() []*ListRow {
-	out := make([]*ListRow, 0, len(l.rows))
-	for _, row := range l.rows {
-		out = append(out, row)
-	}
-	return out
-}
-
-// RowShowing is the row currently drawing one value, or nil if that value is
-// scrolled out of sight. For a guard that needs to press or hover a real row.
-func (l *OpenList) RowShowing(label string) *ListRow {
-	for _, row := range l.rows {
-		if row.Label() == label {
-			return row
-		}
-	}
-	return nil
-}
-
 // Choice is one row of an open list, for a guard to read. Choosable is false
 // on a heading and on the notice that nothing matched.
 type Choice struct {