Settings tabs no longer commit on open; lock login fields while connected (#128)

* Commit settings fields only on a real edit, not when a tab opens

Form.committed treated every onFocusChanged callback with "not focused"
as the operator leaving the field. Compose also fires that callback once
when the modifier is attached, so drawing a tab committed each of its
committed fields: opening Colours wrote all six roles as overrides of
themselves (shown as "changed", and after "Save settings" they hid the
profile's stylesheet file for good), opening Beacon validated both
templates and restarted the beacon timer, opening Notification
re-committed the port and the spotter callsign.

The field now commits only on a transition from focused to unfocused,
or on Enter, and only when the draft differs from the stored value.
A real edit still commits on leaving the field or on Enter.

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

* Lock the Station tab's login fields while a session exists

StationTabState.loginFieldsEnabled was a plain field that nothing ever
wrote and that Compose could not observe, so callsign, names, locator,
password and both chat categories stayed editable while connected,
although the running session does not pick up a change.

The flag is now derived from the ON4KST connection state, read through
a lambda over the main window's Compose state (MainWindowSurroundings),
so the tab follows the session while it is open: the fields are locked
for every state but DISCONNECTED and unlocked again after disconnecting.

The screen-test helper fieldBeside now matches text fields by their
editable text, because a disabled field offers no set-text action.

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

* Drop changelog entries for defects that never shipped

The committed-field and login-field defects exist only in the Compose
settings tabs, which are in neither v1.44.0 nor beta-v1.50.0-beta-001,
so there is nothing for an operator to read about.

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

* Compare committed fields with their last commit, not a stale value

Form.committed skipped a commit when the draft equalled `stored`, the
value the caller passed at its last composition. Most callers read it
from plain preference getters, so nothing recomposes them after a
commit: after Enter, `stored` still named the old value, and leaving the
field committed the same entry again, restarting the beacon timer twice
for one edit. The field now keeps the value it last committed in its own
holder, compares the draft with that, and falls back to it on a refusal.

The comparison is pluggable. The Colours tab compares the way
PaletteOverrides normalises a colour (trimmed, case ignored), so retyping
the shown colour in lower case no longer becomes an override of itself.

Behaviour kept on purpose: Enter on an unchanged value commits nothing,
so it neither restarts the beacon timer nor reports a stored value the
rule refuses. A field removed while it holds the focus (tab switched,
window closed) still commits a typed entry once, because Compose reports
the cleared focus as a focus loss; a test now pins this, as it was before.

Also: a test drives the Station tab's lock from ConnectionStateFeed
through MainWindowSurroundings, the chain the application wires, and the
Javadoc of openSettingsWindow is back above its own method.

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

* Judge a committed field against the live stored value

be6862c8 kept the value a field last committed in a holder keyed on
`stored`. That holder could outlive the truth: the field commits 9 over
5, nothing recomposes the tab, a profile switch puts 5 back and the tab
recomposes with 5 -- the same key -- so the holder still said 9. The
field showed 9, the preference held 5, and leaving the field committed
nothing, where main would have committed 9.

Form.committed now takes `current`, the value stored right now, read
when the field commits; the draft is judged against it and falls back to
it on a refusal. The holder is gone. Right after a commit the getter
already returns the new value, so Enter followed by leaving the field
still commits once. Every caller passes its preference getter: both
beacon templates, the beacon interval, the DX cluster port, the spotter
callsign and the colour roles.

`isUnchanged` must agree with what commit stores, which the KDoc now
says. The interval and the port compare as the number stored, the
spotter callsign ignoring case and surrounding blanks, the colours as
PaletteOverrides normalises them.

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

* Require the live value in committed fields and compare the spotter call as stored

Review follow-up. `current` has no default any more, so a future caller
cannot silently bring back the stale comparison. The spotter call is
compared after the same uppercase(ROOT) the commit applies, so a typed
"X" against a stored "x" still commits.

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

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

app-desktop/src/main/kotlin/kst4contest/view/compose/FormControls.kt

@@ -111,10 +111,25 @@ object Form {
      * every prefix of a valid entry, so the draft lives here until the operator leaves
      * the field or presses Enter.
      *
-     * @param stored the value currently stored; the draft falls back to it when an
-     *        entry is refused, which is what those fields did with setText
+     * Only an edited draft is committed: drawing the field, or entering and leaving it
+     * without typing, commits nothing, and neither does Enter on an unchanged value.
+     * A field removed while it holds the focus -- its tab switched away, its window
+     * closed -- commits a typed entry once: Compose reports the cleared focus to the
+     * field as a focus loss.
+     *
+     * @param stored the value stored when the caller composed; the draft starts from it
      * @param commit returns null when the value was accepted, otherwise the reason
      * @param onRefused shown to the operator; the JavaFX fields opened an alert
+     * @param isUnchanged whether the draft names the stored value. Textual by default,
+     *        looser where two spellings mean one value, as with colours. It must agree
+     *        with what [commit] stores: a draft that commit would store as `c` has to count
+     *        as unchanged against `c`, or leaving the field after Enter commits it again.
+     * @param current the value stored right now, read when the field commits. The draft
+     *        is judged against it, and falls back to it on a refusal (what the JavaFX
+     *        fields did with setText). Required, because [stored] alone goes stale when it
+     *        comes from a plain getter: nothing recomposes the caller after a commit, so
+     *        after Enter it still names the old value, and once the preference is reset
+     *        behind the field it names the new one by coincidence only.
      */
     @Composable
     fun committed(
@@ -122,14 +137,32 @@ object Form {
         stored: String,
         commit: (String) -> String?,
         onRefused: (String) -> Unit,
+        isUnchanged: (draft: String, stored: String) -> Boolean = { typed, now -> typed == now },
+        current: () -> String,
     ) {
         var draft by remember(stored) { mutableStateOf(stored) }
 
+        /*
+         * Whether the field has held the focus since it was last committed. onFocusChanged
+         * also fires when the modifier is first attached, with "not focused"; reading that
+         * as a focus loss committed every such field the moment its tab was opened. Only a
+         * change from focused to unfocused is the operator leaving the field. A plain holder,
+         * not state: nothing is drawn from it.
+         */
+        val hadFocus = remember { booleanArrayOf(false) }
+
         fun commitDraft() {
+            /*
+             * An untouched draft is no edit. Committing it anyway would turn a shipped colour
+             * into an override of itself, restart the beacon timer, or report a stored value
+             * the rule refuses although the operator only passed through the field.
+             */
+            if (isUnchanged(draft, current())) return
+
             val refusal = commit(draft)
             if (refusal != null) {
                 onRefused(refusal)
-                draft = stored
+                draft = current()
             }
         }
 
@@ -139,7 +172,14 @@ object Form {
                 onValueChange = { draft = it },
                 modifier = Modifier
                     .fillMaxWidth()
-                    .onFocusChanged { focus -> if (!focus.isFocused) commitDraft() }
+                    .onFocusChanged { focus ->
+                        if (focus.isFocused) {
+                            hadFocus[0] = true
+                        } else if (hadFocus[0]) {
+                            hadFocus[0] = false
+                            commitDraft()
+                        }
+                    }
                     .onKeyEvent { event ->
                         if (event.type == KeyEventType.KeyUp && event.key == Key.Enter) {
                             commitDraft()

app-desktop/src/main/kotlin/kst4contest/view/compose/SettingsTabs.kt

@@ -8,6 +8,7 @@ import androidx.compose.runtime.setValue
 import kst4contest.controller.ChatController
 import kst4contest.controller.ActiveOperatorProfile
 import kst4contest.controller.OperatorProfileManagementService
+import kst4contest.controller.On4KstConnectionState
 import kst4contest.controller.OperatorProfilePaths
 import kst4contest.model.ChatMember
 import kst4contest.model.OperatorProfile
@@ -113,6 +114,10 @@ interface SettingsHost {
  * place, and the foreign-write coverage test can see it. A tab that only wrote a
  * preference and skipped its session call would look correct in the file and do
  * nothing until the next restart.
+ *
+ * @param connectionState the session state as Compose state reads it; the Station tab
+ *        locks the login fields from it. The controller's own getter is not observable,
+ *        so a tab reading it would stay on whatever the link was when the window opened.
  */
 fun buildSettingsTabs(
     controller: ChatController,
@@ -120,6 +125,7 @@ fun buildSettingsTabs(
     notices: SettingsNotices,
     paletteStore: PaletteStore,
     languageStore: kst4contest.view.i18n.LanguageStore,
+    connectionState: () -> On4KstConnectionState,
 ): List<SettingsTab> {
 
     val prefs = controller.chatPreferences
@@ -128,6 +134,7 @@ fun buildSettingsTabs(
         prefs,
         applyMainCategory = { category -> controller.setChatCategoryMain(category) },
         applySecondCategory = { category -> controller.setChatCategorySecondChat(category) },
+        connectionState = connectionState,
     )
 
     val notificationState = NotificationTabState(

app-desktop/src/main/kotlin/kst4contest/view/compose/tabs/BeaconTab.kt

@@ -31,6 +31,7 @@ fun BeaconTab(state: BeaconTabState, onRefused: (String) -> Unit) {
                 stored = state.beaconTextMainCat,
                 commit = state::commitBeaconTextMainCat,
                 onRefused = onRefused,
+                current = { state.beaconTextMainCat },
             )
         }
 
@@ -43,6 +44,7 @@ fun BeaconTab(state: BeaconTabState, onRefused: (String) -> Unit) {
                 stored = state.beaconTextSecondCat,
                 commit = state::commitBeaconTextSecondCat,
                 onRefused = onRefused,
+                current = { state.beaconTextSecondCat },
             )
         }
 
@@ -52,6 +54,12 @@ fun BeaconTab(state: BeaconTabState, onRefused: (String) -> Unit) {
                 stored = state.beaconIntervalMinutes.toString(),
                 commit = state::commitBeaconInterval,
                 onRefused = onRefused,
+                /*
+                 * Compared as the number commitBeaconInterval stores, so " 9" or "09" after
+                 * Enter does not count as a second edit and restart the timer again.
+                 */
+                isUnchanged = { typed, now -> typed.trim().toIntOrNull()?.toString() == now },
+                current = { state.beaconIntervalMinutes.toString() },
             )
         }
     }

app-desktop/src/main/kotlin/kst4contest/view/compose/tabs/ColoursTab.kt

@@ -119,6 +119,13 @@ fun ColoursTab(
                     stored = row.hex,
                     commit = { typed -> state.set(row.role, typed) },
                     onRefused = reportRefusal,
+                    /*
+                     * A colour is compared the way PaletteOverrides normalises it -- trimmed,
+                     * case ignored -- so retyping the shown colour in lower case is no edit
+                     * and does not turn it into an override of itself.
+                     */
+                    isUnchanged = { typed, now -> typed.trim().equals(now.trim(), ignoreCase = true) },
+                    current = { state.roles().single { it.role == row.role }.hex },
                 )
             }
         }

app-desktop/src/main/kotlin/kst4contest/view/compose/tabs/NotificationTab.kt

@@ -77,12 +77,18 @@ fun NotificationTab(state: NotificationTabState, onRefused: (String) -> Unit) {
                 stored = state.notify_dxclusterServerPort.toString(),
                 commit = state::commitDxClusterServerPort,
                 onRefused = onRefused,
+                // Compared as the number commitDxClusterServerPort stores.
+                isUnchanged = { typed, now -> typed.trim().toIntOrNull()?.toString() == now },
+                current = { state.notify_dxclusterServerPort.toString() },
             )
             Form.committed(
                 label = strings.notificationSpotterCallsign,
                 stored = state.notify_DXCSrv_SpottersCallSign,
                 commit = state::commitSpotterCallSign,
                 onRefused = onRefused,
+                // commitSpotterCallSign stores the callsign trimmed and in upper case.
+                isUnchanged = { typed, now -> typed.trim().uppercase(java.util.Locale.ROOT) == now },
+                current = { state.notify_DXCSrv_SpottersCallSign },
             )
             /*
              * Shows the band prefix, as the JavaFX ComboBox did: the prefix is what the

app-desktop/src/main/kotlin/kst4contest/view/compose/tabs/StationTabState.kt

@@ -1,5 +1,6 @@
 package kst4contest.view.compose.tabs
 
+import kst4contest.controller.On4KstConnectionState
 import kst4contest.model.ChatCategory
 import kst4contest.model.ChatPreferences
 
@@ -26,6 +27,11 @@ class StationTabState(
      */
     private val applyMainCategory: (ChatCategory?) -> Unit,
     private val applySecondCategory: (ChatCategory?) -> Unit,
+    /**
+     * The state of the ON4KST session. A lambda over Compose state, so the login fields
+     * follow it while the tab is open; the default suits a state built without a session.
+     */
+    private val connectionState: () -> On4KstConnectionState = { On4KstConnectionState.DISCONNECTED },
 ) {
 
     var loginChatCategoryMain: ChatCategory?
@@ -173,8 +179,14 @@ class StationTabState(
      * password, name, locator and both category pickers once the session was logged
      * in: changing them there would not reach the running connection, so an edit
      * would look applied and be ignored until the next login.
+     *
+     * Locked for every state but DISCONNECTED: a reconnect wait or a session being
+     * stopped still belongs to the credentials it was started with. Derived on each read
+     * rather than held, so a composition reading it follows the connection state the
+     * moment that changes, provided [connectionState] reads Compose state.
      */
-    var loginFieldsEnabled: Boolean = true
+    val loginFieldsEnabled: Boolean
+        get() = connectionState() == On4KstConnectionState.DISCONNECTED
 
     /**
      * The categories the operator can log into, built the way the JavaFX choice box