gui: the window's words come from a catalogue, so a second language can arrive

D9 gives this window translations and keeps the command line English forever.
The text package has been the seam for that since 2026-08-10, and there was
nothing underneath it: every word was a constant, so the language was chosen
when the binary was compiled.

Each of the 75 entries is now a lookup with its English beside it as the
default, and a catalogue is embedded with go:embed. English is written once, in
the code, next to the reason it is worded that way - en.json is that same
English written out again by tools/gen-locale.py so a translator has a complete
file to copy, and a guard holds the two together.

Nothing about the window changed: all 25 stored screens render byte for byte as
they did, without regenerating a single reference.

The library is go-i18n rather than the toolkit's wrapper around go-i18n, and
that is measured rather than preferred. fyne.io/fyne/v2/lang writes a
"Translation failure" line for every message missing from the system language
even when handed a fallback - 33 lines from building one screen on a machine
set to pl-PL, with correct English on the screen throughout. go-i18n answers
with the default and says nothing: the same measurement gives zero. It is not a
new module either. The toolkit already requires it, so go.sum did not move.

Not here yet, on purpose: asking the machine which language it wants, and a
switch in the window. Screens are built once so that a run in flight and
everything typed into a form survive moving between tabs, so changing language
without a restart is its own piece of work.

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

Author: donislawdev

go.mod

@@ -49,7 +49,7 @@ require (
 	github.com/jsummers/gobmp v0.0.0-20230614200233-a9de23ed2e25 // indirect
 	github.com/mattn/go-runewidth v0.0.24 // indirect
 	github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 // indirect
-	github.com/nicksnyder/go-i18n/v2 v2.5.1 // indirect
+	github.com/nicksnyder/go-i18n/v2 v2.5.1
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/rymdport/portal v0.4.2 // indirect
 	github.com/srwiley/oksvg v0.0.0-20221011165216-be6e8873101c // indirect

internal/guard/actionbar_test.go

@@ -30,9 +30,9 @@ import (
 func TestTheButtonsThatRunSomethingSitInTheMiddle(t *testing.T) {
 	_, content := screenOnACanvas(t)
 
-	run := buttonNamed(content, text.ButtonGenerate)
+	run := buttonNamed(content, text.ButtonGenerate())
 	if run == nil {
-		t.Fatalf("there is no %q button, so this guard read the wrong tree", text.ButtonGenerate)
+		t.Fatalf("there is no %q button, so this guard read the wrong tree", text.ButtonGenerate())
 	}
 	row := rowHolding(content, run)
 	if row == nil {
@@ -43,9 +43,9 @@ func TestTheButtonsThatRunSomethingSitInTheMiddle(t *testing.T) {
 	// layout's arithmetic rather than a statement about where the button is.
 	const slack = 8
 
-	first := buttonNamed(content, text.ButtonPreview)
+	first := buttonNamed(content, text.ButtonPreview())
 	if first == nil {
-		t.Fatalf("there is no %q button, so this guard read the wrong tree", text.ButtonPreview)
+		t.Fatalf("there is no %q button, so this guard read the wrong tree", text.ButtonPreview())
 	}
 
 	// The group is measured rather than one button, because being centred is a

internal/guard/actionbarheight_test.go

@@ -71,7 +71,7 @@ func TestTheFormDoesNotMoveWhenARunStarts(t *testing.T) {
 		},
 	}
 
-	for _, tab := range []string{text.TabOneTarget, text.TabPresets, text.TabRecipe} {
+	for _, tab := range []string{text.TabOneTarget(), text.TabPresets(), text.TabRecipe()} {
 		for _, state := range restingStates {
 			t.Run(tab+"/"+state.name, func(t *testing.T) {
 				content, w := screenInAWindow(t, tab)
@@ -86,7 +86,7 @@ func TestTheFormDoesNotMoveWhenARunStarts(t *testing.T) {
 				}
 
 				if state.clearTheBox {
-					box := entryUnder(t, content, text.FieldOutputDir)
+					box := entryUnder(t, content, text.FieldOutputDir())
 					if box == nil {
 						t.Fatalf("the %s screen has no output directory box, so this guard read the wrong tree", tab)
 					}
@@ -166,11 +166,11 @@ func TestTheFormDoesNotMoveWhenARunStarts(t *testing.T) {
 // Asked through Preview because it goes down the same path and writes nothing,
 // so this stays a guard about words rather than a guard that generates files.
 func TestWhatARunSaysComesBeforeWhatSettlingSaid(t *testing.T) {
-	content, w, host := screenInAWindowWithHost(t, text.TabPresets)
+	content, w, host := screenInAWindowWithHost(t, text.TabPresets())
 
 	// Nothing is filled in. A note is what the run says about a value nobody
 	// gave it, so leaving the settings alone is what produces one at all.
-	press(t, content, text.ButtonPreview)
+	press(t, content, text.ButtonPreview())
 	// This preview is ACCEPTED, so it answers from a worker. Joined before the
 	// status line is read - see join.
 	join(host)

internal/guard/actionrail_test.go

@@ -31,15 +31,15 @@ import (
 // that is on all four - see TestTheDonateButtonIsOnEveryScreen.
 func TestWhatIsNotAboutTheRunStandsAtTheEdgeOfTheBar(t *testing.T) {
 	for _, tab := range []string{
-		text.TabOneTarget, text.TabPresets, text.TabRecipe, text.TabAbout,
+		text.TabOneTarget(), text.TabPresets(), text.TabRecipe(), text.TabAbout(),
 	} {
 		t.Run(tab, func(t *testing.T) {
 			content, w := screenInAWindow(t, tab)
 
-			donate := buttonNamed(content, text.ButtonDonate)
+			donate := buttonNamed(content, text.ButtonDonate())
 			if donate == nil {
 				t.Fatalf("this screen has no %q button, so this guard read the wrong tree",
-					text.ButtonDonate)
+					text.ButtonDonate())
 			}
 
 			atOpening := fyne.CurrentApp().Driver().AbsolutePositionForObject(donate).X
@@ -57,7 +57,7 @@ func TestWhatIsNotAboutTheRunStandsAtTheEdgeOfTheBar(t *testing.T) {
 					"standing at the edge of the bar.\n"+
 					"What to do: it belongs in the rail argument of parts.ActionBar, which is laid "+
 					"outside the form's column. Put back inside that column it moves with it.",
-					text.ButtonDonate, atOpening, window.OpenSize.Width, whenWider, wider.Width)
+					text.ButtonDonate(), atOpening, window.OpenSize.Width, whenWider, wider.Width)
 			}
 
 			// The bar's own padding is the only thing that should stand between
@@ -66,7 +66,7 @@ func TestWhatIsNotAboutTheRunStandsAtTheEdgeOfTheBar(t *testing.T) {
 			if room := float32(parts.ColumnWidth) / 2; atOpening > room {
 				t.Errorf("%q starts %.0f px from the left edge, which is further in than half a "+
 					"form column (%.0f px) - it does not read as standing at the edge.",
-					text.ButtonDonate, atOpening, room)
+					text.ButtonDonate(), atOpening, room)
 			}
 		})
 	}

internal/guard/alwaysvisible_test.go

@@ -23,12 +23,12 @@ import (
 // It is also checked to go out of use during a run, because pressing it then
 // rebuilds the form underneath a run that is writing files.
 func TestAddingABatchIsReachableWithoutScrolling(t *testing.T) {
-	content, _ := screenInAWindow(t, text.TabRecipe)
+	content, _ := screenInAWindow(t, text.TabRecipe())
 
-	add := buttonNamed(content, text.ButtonAddBatch)
+	add := buttonNamed(content, text.ButtonAddBatch())
 	if add == nil {
 		t.Fatalf("the batch screen has no %q button. It has: %v",
-			text.ButtonAddBatch, buttonNames(content))
+			text.ButtonAddBatch(), buttonNames(content))
 	}
 
 	scroll := scrollIn(content)
@@ -38,7 +38,7 @@ func TestAddingABatchIsReachableWithoutScrolling(t *testing.T) {
 	if holds(scroll.Content, add) {
 		t.Errorf("%q is inside the scrolling part of the batch screen, so it is only reachable "+
 			"after scrolling past a batch taller than the window - and it is the one control "+
-			"this screen exists for.", text.ButtonAddBatch)
+			"this screen exists for.", text.ButtonAddBatch())
 	}
 }
 
@@ -55,10 +55,10 @@ func TestAddingABatchIsOutOfUseWhileARunIsGoing(t *testing.T) {
 	body := screen.Object()
 	fields := screen.Fields()
 
-	add := buttonNamed(body, text.ButtonAddBatch)
+	add := buttonNamed(body, text.ButtonAddBatch())
 	if add == nil {
 		t.Fatalf("the batch screen has no %q button. It has: %v",
-			text.ButtonAddBatch, buttonNames(body))
+			text.ButtonAddBatch(), buttonNames(body))
 	}
 	if add.Disabled() {
 		t.Fatal("the add button starts disabled, so this guard cannot tell a run from a fresh screen")

internal/guard/boxwidth_test.go

@@ -101,7 +101,7 @@ func TestABoxIsWideEnoughForItsOwnPlaceholder(t *testing.T) {
 // drift apart in what they mean.
 func placeholderShownFor(p format.Property) string {
 	if p.Default == "" {
-		return text.PlaceholderWorkedOut
+		return text.PlaceholderWorkedOut()
 	}
 	return text.PlaceholderLeftEmpty(p.Default)
 }
@@ -126,8 +126,8 @@ func formatsLaidOut(t *testing.T) (fyne.CanvasObject, *formatChooser) {
 	t.Cleanup(w.Close)
 	w.Resize(fyne.NewSize(window.OpenSize.Width, 1600))
 
-	generate := tabNamed(t, host.content, text.TabOneTarget)
-	picker, ok := controlUnder(generate, text.FieldFormat).(*parts.Chooser)
+	generate := tabNamed(t, host.content, text.TabOneTarget())
+	picker, ok := controlUnder(generate, text.FieldFormat()).(*parts.Chooser)
 	if !ok {
 		t.Fatal("the format field is not a list to choose from, so this guard read the wrong tree")
 	}
@@ -193,12 +193,12 @@ func TestABoxForANumberIsNotAsWideAsTheFormOnTheBatchScreen(t *testing.T) {
 	if host.content == nil {
 		t.Fatal("opening the window put no screen in it")
 	}
-	batches := selectTab(t, host.content, text.TabRecipe)
+	batches := selectTab(t, host.content, text.TabRecipe())
 	w := test.NewWindow(host.content)
 	t.Cleanup(w.Close)
 	w.Resize(fyne.NewSize(window.OpenSize.Width, 1600))
 
-	picker, ok := controlUnder(batches, text.FieldFormat).(*parts.Chooser)
+	picker, ok := controlUnder(batches, text.FieldFormat()).(*parts.Chooser)
 	if !ok {
 		t.Fatal("the first batch has no format list, so this guard read the wrong tree")
 	}
@@ -262,11 +262,11 @@ func TestTwoNarrowSettingsShareARowOnEveryScreenThatDrawsThem(t *testing.T) {
 	ourTheme(t)
 	content, _ := laidOutWindow(t)
 
-	for _, tab := range []string{text.TabOneTarget, text.TabRecipe} {
+	for _, tab := range []string{text.TabOneTarget(), text.TabRecipe()} {
 		t.Run(tab, func(t *testing.T) {
 			screen := tabContent(t, content, tab)
 
-			picker, ok := controlUnder(screen, text.FieldFormat).(*parts.Chooser)
+			picker, ok := controlUnder(screen, text.FieldFormat()).(*parts.Chooser)
 			if !ok {
 				t.Fatal("this screen has no format list, so this guard read the wrong tree")
 			}

internal/guard/bytecount_test.go

@@ -27,7 +27,7 @@ import (
 func TestABoxHoldingASizeSaysWhatItComesTo(t *testing.T) {
 	_, content := screen(t)
 
-	count := byteCountBeside(t, content, text.FieldSize)
+	count := byteCountBeside(t, content, text.FieldSize())
 	if count.Text == "" {
 		t.Fatal("the size box opens with 10mb in it and nothing says what that comes to")
 	}
@@ -42,14 +42,14 @@ func TestABoxHoldingASizeSaysWhatItComesTo(t *testing.T) {
 	// It follows the box rather than being set once. A count that stopped at
 	// the opening value would be worse than none: it would be a wrong number
 	// beside a right one.
-	fill(t, content, text.FieldSize, "1kb")
+	fill(t, content, text.FieldSize(), "1kb")
 	if want := text.ExactBytes(1024); count.Text != want {
 		t.Errorf("1kb was typed and the count beside the box reads %q, not %q", count.Text, want)
 	}
 
 	// And says nothing at all about something that is not a size, which is
 	// every box somebody is halfway through typing.
-	fill(t, content, text.FieldSize, "abc")
+	fill(t, content, text.FieldSize(), "abc")
 	if count.Text != "" {
 		t.Errorf("the size box holds something that is not a size and the count reads %q, "+
 			"so it is showing a number for a value the run will refuse", count.Text)
@@ -68,15 +68,15 @@ func TestABoxHoldingASizeSaysWhatItComesTo(t *testing.T) {
 func TestOnlyABoxHoldingASizeCarriesACount(t *testing.T) {
 	_, content := screen(t)
 
-	for _, label := range []string{text.FieldCount, text.FieldSeed, text.FieldTargetID, text.FieldNameTemplate} {
+	for _, label := range []string{text.FieldCount(), text.FieldSeed(), text.FieldTargetID(), text.FieldNameTemplate()} {
 		if count := byteCountIn(fieldBox(content, label)); count != nil {
 			t.Errorf("%q does not hold a size and carries a count reading %q", label, count.Text)
 		}
 	}
 	// And the one that does still has it, so this cannot pass by there being no
 	// counts anywhere.
-	if byteCountIn(fieldBox(content, text.FieldSize)) == nil {
-		t.Errorf("%q holds a size and carries no count, so the check above proved nothing", text.FieldSize)
+	if byteCountIn(fieldBox(content, text.FieldSize())) == nil {
+		t.Errorf("%q holds a size and carries no count, so the check above proved nothing", text.FieldSize())
 	}
 }
 
@@ -118,7 +118,7 @@ func byteCountIn(o fyne.CanvasObject) *parts.ByteCount {
 func TestADeclaredSizeSaysWhatItComesToOnEveryScreenThatDrawsOne(t *testing.T) {
 	t.Run("a format setting", func(t *testing.T) {
 		_, content := screen(t)
-		picker, ok := controlUnder(content, text.FieldFormat).(*parts.Chooser)
+		picker, ok := controlUnder(content, text.FieldFormat()).(*parts.Chooser)
 		if !ok {
 			t.Fatal("this screen has no format list, so this guard read the wrong tree")
 		}