Merge pull request #7 from sandman21vs/scrolled-number-entry

Scroll a number in place instead of hunting for it on a keypad

Author: oroderico

host/origo_sdl.c

@@ -113,6 +113,20 @@ void seedtool_display_dice_screen(const char* title, const char* line1, const ch
     present();
 }
 
+void seedtool_display_digits(const char* title, const char* digits, const size_t count, const size_t active,
+    const char* footer, const seedtool_progress_t* progress)
+{
+    seedtool_render_digits(title, digits, count, active, footer, progress);
+    present();
+}
+
+void seedtool_display_value_box(
+    const char* title, const char* text, const bool back, const char* footer, const seedtool_progress_t* progress)
+{
+    seedtool_render_value_box(title, text, back, footer, progress);
+    present();
+}
+
 void seedtool_display_splash(void)
 {
     seedtool_render_splash();

main/seedtool_app.c

@@ -75,6 +75,12 @@ _Static_assert(ADDRESS_SHOWN_ROWS <= ADDRESS_LIST_ROWS, "more address rows are s
 _Static_assert(ADDRESS_INDEX_DIGITS == 2 && SEEDTOOL_MAX_ADDRESS_INDEX == 99,
     "the address-index keypad width and the derived address range must be changed together");
 
+/* The word-number field draws one box per digit, and the renderer bounds how
+ * many of those fit across the display. Widening a word number without the
+ * boxes to show it would run the row off both edges, which clips silently. */
+_Static_assert(SEEDTOOL_MAX_WORD_DIGITS <= SEEDTOOL_DIGIT_BOXES_MAX,
+    "a word number has more digits than the digit field can draw boxes for");
+
 /* Every key is found by its character rather than by where it sits, so the
  * layouts are QWERTY, or anything else, purely by changing the strings above. */
 #define PASSPHRASE_PAGES SEEDTOOL_PASSPHRASE_PAGES
@@ -368,7 +374,15 @@ static int enter_value(const char* title, const unsigned position, const unsigne
          * mis-keyed roll is caught against the paper now rather than at the end
          * of ninety-nine of them. Only its tail fits, which is the part that
          * just changed. */
-        if (progress) {
+        /* A plain number scrolls in its own box, the same shape the word-number
+         * field uses - up and down are the value, and there is nothing else on
+         * screen to hunt through. A formatted value (a card, "A Clubs") is too
+         * wide for a box and stays on the text screen, where the running
+         * transcript sits under it. */
+        if (!format) {
+            seedtool_display_value_box(
+                heading, shown, on_back, chord_learned ? NULL : NAV_FOOTER, progress);
+        } else if (progress) {
             seedtool_display_dice_screen(
                 heading, on_back ? "[back]" : shown, history, chord_learned ? NULL : NAV_FOOTER, progress);
         } else {
@@ -901,92 +915,157 @@ static int enter_word(
  * chosen, 0 when the user deleted back out of this word, -1 on timeout or
  * overflow. Only digits that still lead to a word number are reachable, and the
  * number is shown as its word before it is accepted: a digit misread off paper
- * is otherwise a different seed with no sign that anything went wrong. */
+ * is otherwise a different seed with no sign that anything went wrong.
+ *
+ * `allowed` narrows that further on a mnemonic's last word, where the checksum
+ * leaves only a handful of words possible. It is the same set the letter
+ * keyboard narrows by, and it has to be applied here too: a restore that
+ * refuses a word by letter and accepts it by number is worse than one that does
+ * neither, because the reader who used the number pad has been told nothing.
+ *
+ * Up to four boxes, scrolled one at a time, and a number ends where the reader
+ * says it does: `240` is typed as three digits, not as `0240`. The ring for the
+ * current box carries the digits that still lead somewhere, then OK once what
+ * is typed is already a word number, then backspace - the same ring Jade's
+ * index entry uses, where a short number also has to be able to stop early.
+ *
+ * A fixed four-box field was tried first and was wrong: it made 240 a dead end,
+ * since no fourth digit takes 240x into 1..2048, so the reader who typed it
+ * found a box with nothing in it but backspace. Ending the number early is not
+ * a convenience here, it is what makes three-digit numbers reachable at all.
+ *
+ * Replaces a twelve-key keypad the reader had to walk a cursor across. Two
+ * buttons that mean "the digit goes up" and "the digit goes down" need no
+ * hunting, and the row of boxes shows how much is left to type without a
+ * separate readout. */
 static int enter_word_number(
     const size_t position, const size_t total, const seedtool_wordset_t* allowed, char* output, const size_t output_len)
 {
     char digits[SEEDTOOL_MAX_WORD_DIGITS + 1] = { 0 };
-    size_t digits_len = 0;
-    size_t selected = seedtool_layout_center(WORD_NUMBER_LAYOUT);
-    const size_t accept_index = layout_key_index(WORD_NUMBER_LAYOUT, SEEDTOOL_KEY_ACCEPT);
+    /* What each box shows, including the one being scrolled. */
+    char shown[SEEDTOOL_MAX_WORD_DIGITS + 1] = { 0 };
+    size_t at = 0;
     char title[24];
     (void)snprintf(title, sizeof(title), "Word %u/%u", (unsigned)position, (unsigned)total);
 
-    for (;;) {
-        bool reachable[SEEDTOOL_DIGITS] = { false };
-        bool enabled[WORD_NUMBER_KEYS] = { false };
-        (void)seedtool_next_digits_in(allowed, digits, digits_len, reachable);
-        const unsigned number = seedtool_word_number_in(allowed, digits, digits_len);
-        for (size_t i = 0; i < WORD_NUMBER_KEYS; ++i) {
-            const char key = seedtool_layout_key(WORD_NUMBER_LAYOUT, i);
-            enabled[i] = key == SEEDTOOL_KEY_BACKSPACE ? true
-                : key == SEEDTOOL_KEY_ACCEPT           ? number != 0
-                                                       : reachable[key - '0'];
-        }
-        /* Once the typed digits are themselves a complete valid number and
-         * cannot be extended any further, every digit key goes dark at once
-         * and the cursor has to land somewhere. nearest_enabled's ring
-         * distance to Accept vs. Backspace from here depends on exactly
-         * which key the reader was last on - circumstantial, and it lands on
-         * Backspace as often as not. Accept is the deliberate target
-         * whenever it's actually reachable; only fall back to the generic
-         * search when it isn't (still mid-prefix, no complete number yet). */
-        selected = !enabled[selected] && number ? accept_index : nearest_enabled(enabled, WORD_NUMBER_KEYS, selected);
-        bool picked = false;
-        while (!picked) {
-            seedtool_display_keyboard(
-                title, digits_len ? digits : "-", WORD_NUMBER_LAYOUT, enabled, selected, position, total);
-            switch (wait_key()) {
-            case KEY_SELECT:
-                picked = true;
-                break;
-            case KEY_PREV:
-                selected = step_key(enabled, WORD_NUMBER_KEYS, selected, false);
-                break;
-            case KEY_NEXT:
-                selected = step_key(enabled, WORD_NUMBER_KEYS, selected, true);
-                break;
-            case KEY_REDRAW:
-                break;
-            default:
-                seedtool_zero(digits, sizeof(digits));
-                return -1;
-            }
-        }
+    /* The ring for the current box: the digits still reachable, then backspace.
+     * Rebuilt whenever the box changes, since which digits are reachable
+     * depends on the ones already set. */
+    char ring[SEEDTOOL_DIGITS + 2];
+    size_t ring_len = 0, on = 0;
+    bool rebuild = true;
 
-        const char pressed = seedtool_layout_key(WORD_NUMBER_LAYOUT, selected);
-        if (pressed == SEEDTOOL_KEY_ACCEPT) {
-            const char* const word = seedtool_word(number - 1);
-            char counted[32];
-            (void)snprintf(counted, sizeof(counted), "Number %u of %u", number, (unsigned)SEEDTOOL_WORDLIST_LEN);
-            const seedtool_key_t key = confirm(title, word, counted);
-            seedtool_zero(counted, sizeof(counted));
-            if (key == KEY_SELECT) {
-                const int result = !word || strlen(word) + 1 > output_len ? -1 : 1;
-                if (result == 1) {
-                    strcpy(output, word);
+    for (;;) {
+        if (rebuild) {
+            bool reachable[SEEDTOOL_DIGITS] = { false };
+            /* Narrowed by `allowed`, exactly as the letter keyboard is. The
+             * ring is built per box, so a digit that cannot begin an allowed
+             * word never appears to be scrolled to in the first place. */
+            (void)seedtool_next_digits_in(allowed, digits, at, reachable);
+            ring_len = 0;
+            for (size_t d = 0; d < SEEDTOOL_DIGITS; ++d) {
+                if (reachable[d]) {
+                    ring[ring_len++] = (char)('0' + d);
                 }
-                seedtool_zero(digits, sizeof(digits));
-                return result;
             }
-            if (key == KEY_TIMEOUT) {
-                seedtool_zero(digits, sizeof(digits));
-                return -1;
+            /* OK only once the digits already name a word - so it is absent on
+             * an empty field and on a prefix like `20`, which is a real number
+             * but is offered here as a step towards 200x rather than as 20
+             * itself... which it also is. Both readings are live, which is
+             * exactly why the reader has to say which one they meant. */
+            if (seedtool_word_number_in(allowed, digits, at)) {
+                ring[ring_len++] = SEEDTOOL_KEY_ACCEPT;
             }
-            /* Went back: the number is cleared rather than left half-entered, so
-             * what is on screen is always the whole of what was typed. */
+            ring[ring_len++] = SEEDTOOL_KEY_BACKSPACE;
+            on = 0;
+            rebuild = false;
+        }
+
+        memset(shown, 0, sizeof(shown));
+        memcpy(shown, digits, at);
+        shown[at] = ring[on];
+        for (size_t i = at + 1; i < SEEDTOOL_MAX_WORD_DIGITS; ++i) {
+            shown[i] = ' ';
+        }
+        seedtool_display_digits(title, shown, SEEDTOOL_MAX_WORD_DIGITS, at, ACK_FOOTER, NULL);
+
+        seedtool_key_t key = wait_key();
+        if (key == KEY_REDRAW) {
+            continue;
+        }
+        if (key == KEY_TIMEOUT) {
             seedtool_zero(digits, sizeof(digits));
-            digits_len = 0;
-        } else if (pressed == SEEDTOOL_KEY_BACKSPACE) {
-            if (!digits_len) {
+            seedtool_zero(shown, sizeof(shown));
+            return -1;
+        }
+        if (key == KEY_PREV) {
+            on = on ? on - 1 : ring_len - 1;
+            continue;
+        }
+        if (key == KEY_NEXT) {
+            on = on + 1 < ring_len ? on + 1 : 0;
+            continue;
+        }
+
+        /* KEY_SELECT: commit whatever the box is showing. */
+        if (ring[on] == SEEDTOOL_KEY_BACKSPACE) {
+            if (!at) {
                 seedtool_zero(digits, sizeof(digits));
+                seedtool_zero(shown, sizeof(shown));
                 return 0;
             }
-            digits[--digits_len] = '\0';
-        } else if (digits_len < SEEDTOOL_MAX_WORD_DIGITS) {
-            digits[digits_len++] = pressed;
-            digits[digits_len] = '\0';
+            digits[--at] = '\0';
+            rebuild = true;
+            continue;
+        }
+        bool typed_last = false;
+        if (ring[on] != SEEDTOOL_KEY_ACCEPT) {
+            digits[at++] = ring[on];
+            digits[at] = '\0';
+            rebuild = true;
+            /* A fourth digit has nowhere left to go, so it confirms itself
+             * rather than asking for an OK the field has no box to show. */
+            if (at < SEEDTOOL_MAX_WORD_DIGITS) {
+                continue;
+            }
+            typed_last = true;
+        }
+
+        /* Narrowed here too, not only where the ring is built. The ring should
+         * already have made a disallowed number untypeable - but this is the
+         * gate a number passes through to become a word, and a gate that
+         * inherits its guarantee from the screen upstream is one bug away from
+         * accepting what that screen was supposed to have refused. A number
+         * outside the set reads as no word at all, which sends the reader back
+         * to the field rather than into a confirmation they should never see. */
+        const unsigned number = seedtool_word_number_in(allowed, digits, at);
+        const char* const word = number ? seedtool_word(number - 1) : NULL;
+        char counted[32];
+        (void)snprintf(counted, sizeof(counted), "Number %u of %u", number, (unsigned)SEEDTOOL_WORDLIST_LEN);
+        const seedtool_key_t answer = word ? confirm(title, word, counted) : KEY_PREV;
+        seedtool_zero(counted, sizeof(counted));
+        if (answer == KEY_SELECT) {
+            const int result = strlen(word) + 1 > output_len ? -1 : 1;
+            if (result == 1) {
+                strcpy(output, word);
+            }
+            seedtool_zero(digits, sizeof(digits));
+            seedtool_zero(shown, sizeof(shown));
+            return result;
+        }
+        if (answer == KEY_TIMEOUT) {
+            seedtool_zero(digits, sizeof(digits));
+            seedtool_zero(shown, sizeof(shown));
+            return -1;
+        }
+        /* Went back from the confirmation. A number that confirmed itself on a
+         * fourth digit reopens that digit, so a wrong last one costs a press
+         * rather than the whole number; one the reader ended with OK returns to
+         * the field exactly as it was, with the OK still on the ring. */
+        if (typed_last) {
+            digits[--at] = '\0';
         }
+        rebuild = true;
     }
 }
 

main/seedtool_display.c

@@ -202,6 +202,20 @@ void seedtool_display_screen4(const char* title, const char* line1, const char*
     flush();
 }
 
+void seedtool_display_digits(const char* title, const char* digits, const size_t count, const size_t active,
+    const char* footer, const seedtool_progress_t* progress)
+{
+    seedtool_render_digits(title, digits, count, active, footer, progress);
+    flush();
+}
+
+void seedtool_display_value_box(
+    const char* title, const char* text, const bool back, const char* footer, const seedtool_progress_t* progress)
+{
+    seedtool_render_value_box(title, text, back, footer, progress);
+    flush();
+}
+
 void seedtool_display_dice_screen(const char* title, const char* line1, const char* line2, const char* footer,
     const seedtool_progress_t* progress)
 {

main/seedtool_display.h

@@ -34,6 +34,10 @@ void seedtool_display_dice_screen(const char* title, const char* line1, const ch
 void seedtool_display_splash(void);
 void seedtool_display_list(const char* title, const char* const* items, size_t count, size_t selected, size_t top,
     const char* footer);
+void seedtool_display_digits(const char* title, const char* digits, size_t count, size_t active, const char* footer,
+    const seedtool_progress_t* progress);
+void seedtool_display_value_box(
+    const char* title, const char* text, bool back, const char* footer, const seedtool_progress_t* progress);
 void seedtool_display_keyboard(const char* title, const char* text, const char* layout, const bool* enabled,
     size_t selected, size_t position, size_t total);
 bool seedtool_display_qr(const char* title, const char* text);