gui: a press puts the keyboard on a switch, a frozen control answers no key

Four findings of an outside review of the pull request, each checked
against the toolkit's source before anything was changed, and one more
found beside them.

A press on a switch - the square and the segmented one - now puts the
keyboard on it quietly, and the first key drawn on it turns the ring on: the
rule PointerFocus has stated since the menus, which the Chooser followed and
the two controls of the rework did not. The desktop driver unfocuses whatever
had the keyboard on a press and leaves focusing to the widget
(internal/driver/glfw/window.go, mouseClicked); the toolkit's own Check and
radio item focus themselves in Tapped, and ours did not, so after a click
the keyboard was nowhere - the next Space flipped nothing and the next Tab
started from the top of the screen. The review said the keyboard stayed on
the previous control, which the driver does not do, and drew the right
conclusion from the wrong mechanism. The guard that promised "a press moves
the keyboard without drawing its mark" asked only about the mark, so a
control that took the keyboard nowhere passed it. It asks both now.

A frozen control answers no key. The focus manager asks Disabled only when
it moves the focus, and the driver hands every key to whatever is focused,
so a segmented switch that had the keyboard when a run began went on moving
its choice under a form drawn as frozen. The review named the switch. The
menu does the same through the toolkit's Select.TypedKey, which asks nothing
either, and is stopped in the same place.

One press of the space bar flips a switch once. Toggle.TypedRune answered the
space character as Button.TypedRune did, so a press flipped the switch twice
and left it where it was, which reads as a switch that ignores space. Found
by reading the control beside the one the review named.

An ownWork exemption that no build spends is red, as a registry entry that
no build matches already was: a key for a file that has gone would exempt
whatever landed at that path next.

The catalogue no longer writes its window size down as the size the
ordinary window opens at. The comment beside it said nothing about it was
remembered, and the close callback two lines below remembered it. Behind
cgo, like the rest of the remembering, so no guard reaches it.

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

Author: donislawdev

internal/guard/controlstates_test.go

@@ -111,6 +111,58 @@ func TestOnePressOfSpacePressesAButtonOnce(t *testing.T) {
 	}
 }
 
+// And flips a switch once - the same two deliveries, and a switch that
+// answered both flipped twice, back to where it started, which reads as a
+// switch that ignores the space bar. Found by reading the switch beside the
+// button on 2026-09-16, not by the review that named the button.
+func TestOnePressOfSpaceFlipsASwitchOnce(t *testing.T) {
+	flips := 0
+	s := parts.NewToggle(func(bool) { flips++ })
+	s.TypedKey(&fyne.KeyEvent{Name: fyne.KeySpace})
+	s.TypedRune(' ')
+	if flips != 1 || !s.Checked {
+		t.Errorf("one press of the space bar flipped the switch %d times and left it %v", flips, s.Checked)
+	}
+}
+
+// A frozen control answers no key.
+//
+// A form is frozen for the length of a run (Fields.Freeze disables every
+// control), and a control that had the keyboard keeps it: the focus manager
+// asks Disabled only when it MOVES the focus (internal/app/focus_manager.go)
+// and the driver hands every key to whatever is focused. So a disabled
+// switch went on moving its choice under a form drawn as frozen, and a
+// disabled menu went on changing its value on Left and Right through the
+// toolkit's own Select.TypedKey, which asks nothing either. An outside review
+// of the pull request named the switch on 2026-09-16. The menu came out of
+// reading what the switch's fix had to cover.
+func TestAFrozenControlAnswersNoKey(t *testing.T) {
+	changed := 0
+	segments := parts.NewSegments([]string{"one", "two", "three"}, func(string) { changed++ })
+	segments.Disable()
+	segments.TypedKey(&fyne.KeyEvent{Name: fyne.KeyRight})
+	if segments.Selected != "one" || changed != 0 {
+		t.Errorf("a frozen segmented switch moved to %q on an arrow and reported %d change(s)", segments.Selected, changed)
+	}
+
+	menu := parts.NewChooser([]string{"one", "two", "three"}, func(string) { changed++ })
+	menu.SetSelected("one")
+	changed = 0
+	menu.Disable()
+	menu.TypedKey(&fyne.KeyEvent{Name: fyne.KeyRight})
+	if menu.Selected != "one" || changed != 0 {
+		t.Errorf("a frozen menu moved to %q on an arrow and reported %d change(s)", menu.Selected, changed)
+	}
+
+	toggle := parts.NewToggle(func(bool) { changed++ })
+	changed = 0
+	toggle.Disable()
+	toggle.TypedKey(&fyne.KeyEvent{Name: fyne.KeySpace})
+	if toggle.Checked || changed != 0 {
+		t.Errorf("a frozen switch flipped on the space bar and reported %d change(s)", changed)
+	}
+}
+
 // A segmented switch ignores a value it does not hold.
 //
 // A switch of fixed choices is not a box: handed a word it does not offer it

internal/guard/embeddedassets_test.go

@@ -31,10 +31,18 @@ func TestEveryFileEmbeddedFromSomebodyElseIsAccountedFor(t *testing.T) {
 	seen := map[string]bool{}
 	matched := map[string]bool{}
 	total := 0
+	// Every key of ownWork has to be spent on a file some build embeds, or it
+	// is an exemption that outlived its file - and an exemption nobody uses
+	// today is the one that exempts somebody else's bytes tomorrow, at the
+	// same package and path, without a word. Asked the same way the registry
+	// is asked below, since an unused entry and an unused exemption are the
+	// same drift facing two ways. An outside review of the pull request
+	// pointed at the missing half on 2026-09-16.
+	usedExemptions := map[string]bool{}
 
 	for _, target := range []string{"../../cmd/tfg-gui", "../../cmd/tfg"} {
 		for _, goos := range []string{"windows", "linux", "darwin"} {
-			total += accountForBuild(t, target, goos, seen, matched)
+			total += accountForBuild(t, target, goos, seen, matched, usedExemptions)
 		}
 	}
 
@@ -59,6 +67,18 @@ func TestEveryFileEmbeddedFromSomebodyElseIsAccountedFor(t *testing.T) {
 			"An entry for bytes that no longer ship is a notice nobody needs, and it hides the day "+
 			"the real thing was replaced by something else.", len(stale), strings.Join(stale, "\n  "))
 	}
+	var unspent []string
+	for key := range ownWork {
+		if !usedExemptions[key] {
+			unspent = append(unspent, key)
+		}
+	}
+	if len(unspent) > 0 {
+		sort.Strings(unspent)
+		t.Errorf("%d ownWork exemption(s) name a file no build embeds:\n  %s\n"+
+			"An exemption without a file is a licence check switched off for whatever lands at that "+
+			"path next. Take it off the list.", len(unspent), strings.Join(unspent, "\n  "))
+	}
 	t.Logf("%d embedded file(s) across every package, all accounted for by %d registry entr(y/ies) or named as our own work",
 		total, len(legal.Assets()))
 }
@@ -67,19 +87,19 @@ func TestEveryFileEmbeddedFromSomebodyElseIsAccountedFor(t *testing.T) {
 // added. Split out rather than nested inside the test because the depth ceiling
 // said so, and the ceiling is a measurement rather than a preference - see
 // docs/QUALITY.md.
-func accountForBuild(t *testing.T, target, goos string, seen, matched map[string]bool) int {
+func accountForBuild(t *testing.T, target, goos string, seen, matched, usedExemptions map[string]bool) int {
 	t.Helper()
 	added := 0
 	for pkg, files := range embeddedFiles(t, target, goos) {
-		added += accountForPackage(t, pkg, files, seen, matched)
+		added += accountForPackage(t, pkg, files, seen, matched, usedExemptions)
 	}
 	return added
 }
 
 // accountForPackage does one package, skipping what another platform already
 // answered for. Three systems are asked and they agree about most of the tree,
 // so without seen the same font would be reported six times.
-func accountForPackage(t *testing.T, pkg string, files []string, seen, matched map[string]bool) int {
+func accountForPackage(t *testing.T, pkg string, files []string, seen, matched, usedExemptions map[string]bool) int {
 	t.Helper()
 	added := 0
 	for _, file := range files {
@@ -89,6 +109,7 @@ func accountForPackage(t *testing.T, pkg string, files []string, seen, matched m
 		seen[pkg+" "+file] = true
 		added++
 		if ownWork[pkg+" "+file] {
+			usedExemptions[pkg+" "+file] = true
 			continue
 		}
 		accountFor(t, pkg, file, matched)

internal/guard/pointerfocus_test.go

@@ -43,6 +43,16 @@ func TestAPressMovesTheKeyboardWithoutDrawingItsMark(t *testing.T) {
 		t.Error("the format menu was pressed with the pointer and drew the keyboard mark, " +
 			"so the value chosen sits on a blue box until something else is clicked")
 	}
+	// And the keyboard IS there. The name of this guard promised that from
+	// the start and until 2026-09-16 only the second half was asked, so a
+	// control that took the keyboard nowhere at all passed it - which is what
+	// the switch below did: the driver unfocuses whatever had the keyboard on
+	// 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())
+	}
 
 	// The list the press opened is taken away first. A real press respects what
 	// covers it - which is the point of pressing for real - so leaving an open
@@ -71,6 +81,46 @@ func TestAPressMovesTheKeyboardWithoutDrawingItsMark(t *testing.T) {
 		t.Error("the switch was pressed with the pointer and drew the keyboard mark, " +
 			"which is the blue disc behind the square that was reported on 2026-08-18")
 	}
+	if c.Focused() != toggle {
+		t.Errorf("the switch was pressed and the keyboard is on %T, not on the switch - so the next "+
+			"Space flips nothing and the next Tab starts from the top of the screen", c.Focused())
+	}
+}
+
+// A press on a segmented switch puts the keyboard on it quietly, and the
+// first arrow says so.
+//
+// The same rule as the two above, on the third control that can hold the
+// keyboard. Asked on a bare canvas rather than on a screen, because a press
+// aimed at one segment needs a position, and the segment widths are the
+// control's own to know.
+func TestAPressOnASegmentedSwitchPutsTheKeyboardOnItQuietly(t *testing.T) {
+	app := test.NewApp()
+	app.Settings().SetTheme(parts.Theme())
+	t.Cleanup(func() { test.NewApp() })
+
+	s := parts.NewSegments([]string{"one", "two", "three"}, nil)
+	w := test.NewWindow(s)
+	t.Cleanup(w.Close)
+	w.Resize(s.MinSize())
+
+	test.TapAt(s, fyne.NewPos(s.Size().Width-1, s.Size().Height/2))
+	if s.Selected != "three" {
+		t.Fatalf("the press on the last segment chose %q, so this guard never reached the state it is about", s.Selected)
+	}
+	if w.Canvas().Focused() != s {
+		t.Errorf("the switch was pressed and the keyboard is on %T, not on the switch", w.Canvas().Focused())
+	}
+	if s.Marked() {
+		t.Error("the switch was pressed with the pointer and drew the keyboard mark")
+	}
+	s.TypedKey(&fyne.KeyEvent{Name: fyne.KeyLeft})
+	if !s.Marked() {
+		t.Error("an arrow was pressed on the switch and the mark that says the keyboard is here did not come on")
+	}
+	if s.Selected != "two" {
+		t.Errorf("the arrow after the press moved to %q, not on from the segment that was pressed", s.Selected)
+	}
 }
 
 // The other half, and it is the half that makes the first one safe.

internal/gui/parts/ring.go

@@ -529,6 +529,13 @@ func (c *Chooser) Quietly(focus func()) { c.from.Quietly(focus) }
 // UX9 asks that whatever the mouse can do the keyboard can - which has to mean
 // the same thing, not a second version of it.
 func (c *Chooser) TypedKey(event *fyne.KeyEvent) {
+	// A frozen menu answers no key. The toolkit's Select.TypedKey moves the
+	// value on Left and Right without asking, and a menu frozen for a run
+	// keeps the keyboard if it had it - see Segments.TypedKey for the same
+	// finding on the same day.
+	if event == nil || c.Disabled() {
+		return
+	}
 	// The keyboard has been used, so from here on it is worth saying where it
 	// is. Somebody who opened this list with the mouse and then reached for the
 	// arrows is somebody who now needs to see which control is listening.

internal/gui/parts/segments.go

@@ -38,6 +38,9 @@ type Segments struct {
 
 	hovered int // the segment under the pointer, or -1
 	marked  bool
+	// from knows whether the keyboard arrived by press or by key - see
+	// PointerFocus and Toggle, which follow the same rule.
+	from PointerFocus
 }
 
 var (
@@ -85,16 +88,38 @@ func (s *Segments) indexOf(value string) int {
 	return -1
 }
 
-// Tapped chooses the segment under the pointer.
+// Tapped chooses the segment under the pointer and puts the keyboard on the
+// switch, quietly - the way the toolkit's radio item does (widget/radio_item.go
+// Tapped), so the arrows step on from what was clicked. See Toggle.Tapped for
+// the whole of why, and for what stood here until 2026-09-16.
 func (s *Segments) Tapped(event *fyne.PointEvent) {
 	if s.Disabled() || event == nil {
 		return
 	}
+	s.takeTheKeyboardQuietly()
 	if at := s.segmentAt(event.Position.X); at >= 0 {
 		s.SetSelected(s.Options[at])
 	}
 }
 
+// takeTheKeyboardQuietly moves the focus here without the mark, unless it is
+// here already.
+func (s *Segments) takeTheKeyboardQuietly() {
+	app := fyne.CurrentApp()
+	if app == nil {
+		return
+	}
+	canvas := app.Driver().CanvasForObject(s)
+	if canvas == nil || canvas.Focused() == s {
+		return
+	}
+	s.from.Quietly(func() { canvas.Focus(s) })
+}
+
+// Quietly runs a focus change without drawing the mark. See PointerFocus and
+// FocusQuietly.
+func (s *Segments) Quietly(focus func()) { s.from.Quietly(focus) }
+
 // segmentAt is the segment a point falls in, or -1 past the last one.
 func (s *Segments) segmentAt(x float32) int {
 	edge := float32(0)
@@ -130,7 +155,16 @@ func (s *Segments) MouseOut() {
 	}
 }
 
+// FocusGained draws the ring when the keyboard is what brought the focus here.
+// A press brings it quietly and the first key turns the ring on.
 func (s *Segments) FocusGained() {
+	if s.from.Quiet() {
+		return
+	}
+	s.mark()
+}
+
+func (s *Segments) mark() {
 	s.marked = true
 	s.Refresh()
 }
@@ -147,9 +181,18 @@ func (s *Segments) TypedRune(rune) {}
 // tab strip makes (see TabWord) not applying where the choice does not move the
 // keyboard off the control.
 func (s *Segments) TypedKey(event *fyne.KeyEvent) {
-	if event == nil || len(s.Options) == 0 {
+	// Disabled asked here and not left to the renderer: a switch frozen for
+	// the length of a run keeps the keyboard if it had it, because the focus
+	// manager checks Disabled only when it MOVES the focus (internal/app/
+	// focus_manager.go), and the driver hands every key to whatever is
+	// focused. Without this the arrows moved the choice under a form drawn as
+	// frozen - an outside review of the pull request named it, 2026-09-16.
+	if event == nil || s.Disabled() || len(s.Options) == 0 {
 		return
 	}
+	if !s.marked {
+		s.mark()
+	}
 	at := s.indexOf(s.Selected)
 	switch event.Name {
 	case fyne.KeyLeft: