gui: Lock the groups that matched when a card is read back

After a mismatch, only the highlighted groups can still be edited. An
edit that reaches a group that matched is undone. An edit inside an open
group is cut, or padded with "?", back to that group's size, so the card
keeps its length and no later group shifts. Clearing the field unlocks
it.

Claude-Session: https://claude.ai/code/session_018HrKoywz6PT9c91jvKou7Q

Author: claude

src/codex32_gui/entry.py

@@ -31,6 +31,7 @@ def __init__(self, *, accepted: tuple[str, ...] = (), length: int | None = None)
         self._accepted, self._length, self._pending = accepted, length, 0
         self._limit = (length or TEXT_LENGTHS[-1]) + SLACK
         self._dropped, self._rewriting, self._unpublishing = "", False, 0
+        self._locked, self._shown = frozenset[int](), PREFIX
         self.set_hexpand(True)
         self.add_css_class("card-entry")
         self.set_input_hints(Gtk.InputHints.NO_SPELLCHECK | Gtk.InputHints.NO_EMOJI)
@@ -53,9 +54,14 @@ def reading(self) -> Reading:
 
     def clear(self) -> None:
         """Drop the entered recovery text."""
-        self._dropped = ""
+        self._dropped, self._locked = "", frozenset()
         self.set_text(PREFIX)
 
+    def lock(self, open_groups: frozenset[int] | None) -> None:
+        """Freeze every four-character group except `open_groups`, which stay editable in place."""
+        self._shown, every = self.get_text(), range(-(-len(normalize(self.get_text())) // GROUP))
+        self._locked = frozenset(every) - open_groups if open_groups else frozenset()
+
     def _unpublish(self, *_arguments: object) -> None:
         # Selecting text in a Gtk.Entry hands it to the primary selection, where a
         # clipboard manager would copy the card into a history file on disk. The
@@ -85,12 +91,28 @@ def _reformat(self) -> bool:
         canonical = normalize(raw)[: self._limit]
         if header_fault(canonical, self._accepted):
             canonical = canonical[: len(PREFIX) + HEADER_LENGTH]
-        shown = grouped(canonical)
+        kept = min(len(normalize(raw[:position])), len(canonical))
+        if self._locked and canonical != normalize(self._shown):
+            canonical, kept = self._within_open_group(normalize(self._shown), canonical)
+        shown = self._shown = grouped(canonical)
         self._dropped = lookalike_fault(raw)
         if shown != raw:
-            kept = min(len(normalize(raw[:position])), len(canonical))
             self._rewriting = True
             self.set_text(shown)
             self._rewriting = False
             self.set_position(kept + max(kept - 1, 0) // GROUP)
         return False
+
+    def _within_open_group(self, old: str, new: str) -> tuple[str, int]:
+        # Once groups are locked the card keeps its length and they keep their
+        # text: an edit inside one open group is cut or padded with "?" back to
+        # that group's size, and an edit reaching any other group is undone.
+        same = min(len(old), len(new))
+        start = next((i for i in range(same) if old[i] != new[i]), same)
+        tail = next((i for i in range(same - start) if old[-1 - i] != new[-1 - i]), same - start)
+        first, end = start - start % GROUP, min(start - start % GROUP + GROUP, len(old))
+        if first // GROUP in self._locked or len(old) - tail > end:
+            return old, start
+        typed = new[start : len(new) - tail]
+        edited = (old[first:start] + typed + old[len(old) - tail : end] + "?" * GROUP)[: end - first]
+        return old[:first] + edited + old[end:], min(start + len(typed), end)

src/codex32_gui/pages.py

@@ -492,7 +492,8 @@ def _read_back_page(
     accept = _button("Confirm card", lambda: None, style="suggested-action")
 
     def update(*_arguments: object) -> None:
-        comparison.set_child(None)
+        if field.get_text() == reading.PREFIX:  # Cleared: the redrawn copy goes too.
+            comparison.set_child(None)
         state = field.reading()
         accept.set_sensitive(state.complete)
         # A character a card can never carry is named, never quietly deleted: this
@@ -511,6 +512,7 @@ def check() -> None:
         if not result.accepted:
             groups = frozenset(group - 1 for group in result.mismatched_groups)
             comparison.set_child(_card(typed, groups))
+            field.lock(groups or None)  # Only the highlighted groups can still be edited.
             _say(status, "The highlighted groups do not match. Re-read them from the card.", "error")
             return
         field.clear()
@@ -529,8 +531,8 @@ def check() -> None:
         status,
         comparison,
         _note(
-            "Spaces and capitals do not matter, and you may try as many times as you like. Correct the "
-            "highlighted groups; the rest stays as you typed it."
+            "Spaces and capitals do not matter, and you may try as many times as you like. Only the "
+            "highlighted groups can be changed; the rest is locked as you typed it."
         ),
     )
     page = _page(

tests/test_gui_read_back.py

@@ -11,7 +11,7 @@
     gi.require_version("Gtk", "4.0")
     gi.require_version("Adw", "1")
     gi.require_version("Gdk", "4.0")
-    from gi.repository import Adw, Gdk, Gtk
+    from gi.repository import Adw, Gdk, GLib, Gtk
 except (ImportError, ValueError):
     pytest.skip("GTK 4 and libadwaita are unavailable", allow_module_level=True)
 if not Gtk.init_check() or Gdk.Display.get_default() is None:
@@ -22,7 +22,7 @@
 
 from codex32 import parse_codex32
 from codex32.generation import ConfirmationResult
-from codex32_gui import pages
+from codex32_gui import pages, reading
 
 SHARE = VECTOR_2["share_A"]
 
@@ -77,3 +77,57 @@ def test_a_mismatch_highlights_every_wrong_group_of_the_typed_text() -> None:
 
     field.clear()
     assert list(_widgets(page, Gtk.FlowBox)) == []
+
+
+def _settle() -> None:
+    while GLib.MainContext.default().iteration(False):
+        pass
+
+
+def _groups(text: str) -> list[str]:
+    return text.split(" ")
+
+
+def test_a_mismatch_locks_every_group_that_matched() -> None:
+    _page, field, _typed, _finished = _read_back(ConfirmationResult(False, (2, 12)))
+    field.prefill(SHARE)
+    field.emit("activate")
+    before = _groups(field.get_text())
+
+    edited = before.copy()
+    edited[0], edited[2] = "XXXX", "YYYY"
+    field.set_text(" ".join(edited))
+    _settle()
+    assert field.get_text() == " ".join(before)
+
+    edited = before.copy()
+    edited[1] = "QQQQ"
+    field.set_text(" ".join(edited))
+    _settle()
+    assert field.get_text() == " ".join(edited)
+
+
+def test_an_open_group_keeps_its_size_and_the_card_its_length() -> None:
+    _page, field, _typed, _finished = _read_back(ConfirmationResult(False, (12,)))
+    field.prefill(SHARE)
+    field.emit("activate")
+    before = _groups(field.get_text())
+
+    field.delete_text(56, 57)  # the second character of group 12
+    _settle()
+    after = _groups(field.get_text())
+    assert after[:11] == before[:11] and after[11] == before[11][0] + before[11][2:] + "?"
+
+    field.insert_text("WXYZ", 55)
+    _settle()
+    assert _groups(field.get_text())[11] == "WXYZ" and len(field.get_text()) == len(" ".join(before))
+
+
+def test_clearing_unlocks_the_card() -> None:
+    _page, field, _typed, _finished = _read_back(ConfirmationResult(False, (2,)))
+    field.prefill(SHARE)
+    field.emit("activate")
+    field.clear()
+    field.prefill(SHARE[:20])
+    _settle()
+    assert reading.normalize(field.get_text()) == SHARE[:20].upper()