backpack-backbone 0.2.0__py3-none-any.whl

backbone/prompt/dates.py

@@ -0,0 +1,555 @@
+"""Date and date-time pickers."""
+from __future__ import annotations
+import re
+import sys
+import datetime
+import calendar as cal
+from backbone.prompt.core import (
+    _get_term_attrs, _set_raw, _restore_term_attrs, _wait_for_keypress, block_cursor,
+    _read_key, _Widget, screen_takeover_next,
+)
+from backbone import keys, ui
+from backbone import datetime_parse as dtp
+from backbone.nav import QuitToTerminal
+from backbone.prompt import chrome
+from backbone.prompt.chrome import CHROME_HANDLED, CHROME_REDRAW, MODE_TOGGLE, _with_toggle_hint, append_chrome, consume_chrome, disable_mouse, enable_mouse
+from backbone.prompt.text import text
+from backbone.prompt.core import C
+
+
+keys.define("calendar", "Calendar", [
+    ("later", ("RIGHT",), "next month, or day"),
+    ("earlier", ("LEFT",), "previous month, or day"),
+    ("up", ("UP",), "previous year, or week"),
+    ("down", ("DOWN",), "next year, or week"),
+    ("switch", ("TAB", "BACKTAB"), "switch between months and days"),
+    ("manual", ("m",), "type a date"),
+    ("save", ("ENTER",), "save"),
+    ("back", ("ESC",), "back"),
+], within=("list", "global"))
+
+
+def _is_leap_year(year: int) -> bool:
+    """Gregorian leap-year rule."""
+    return (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)
+
+
+def _days_in_month(year: int, month: int) -> int:
+    """Number of days in `month` of `year` (Feb accounts for leap years)."""
+    if month in (1, 3, 5, 7, 8, 10, 12):
+        return 31
+    elif month in (4, 6, 9, 11):
+        return 30
+    elif month == 2:
+        return 29 if _is_leap_year(year) else 28
+    return 0
+
+
+def _parse_date(date_str: str) -> tuple[int, int, int] | None:
+    """Parse a typed date to ``(year, month, day)``, or None if unreadable.
+
+    Thin wrapper over the project-wide parser in :mod:`backbone.datetime_parse`
+    so the calendar and date/time widgets read dates by exactly the same rules as
+    everywhere else.  ``dayfirst=False`` preserves this widget's long-standing
+    reading of an ambiguous ``02/07/2008`` as month-first; a part over 12 still
+    settles the order on its own (``13/07/2008`` is day-first either way).
+    """
+    return dtp.parse_date_parts(date_str, dayfirst=False)
+
+
+def calendar_select(message: str = "Select date:", initial: str = "") -> str | None:
+    """
+    Interactive calendar widget for date selection.
+    Allows month/year navigation and in-place day selection.
+
+    Args:
+        message: Prompt label
+        initial: Initial date (YYYY-MM-DD or flexible format)
+
+    Returns:
+        Selected date as YYYY-MM-DD string, or None if cancelled
+    """
+    if initial:
+        parsed = _parse_date(initial)
+        if parsed:
+            y, m, d = parsed
+        else:
+            # Fallback to today
+            today = datetime.date.today()
+            y, m, d = today.year, today.month, today.day
+    else:
+        today = datetime.date.today()
+        y, m, d = today.year, today.month, today.day
+
+    cursor_day = d
+    day_mode = False  # False: Navigates Month/Year | True: Navigates Days
+    _digit_buf = ""   # accumulates a leading 1/2/3 so days 10-31 are typable
+
+    fd = sys.stdin.fileno()
+    old = _get_term_attrs(fd)
+    w = _Widget(fd)
+    _hint_cells: dict = {}   # clickable hint keys, filled by append_chrome
+
+    def _render():
+        lines = []
+
+        # Header
+        lines.append(f"  {C.DIM}{message}{C.RESET}")
+        lines.append(f"{C.DIM}{'─' * ui.get_terminal_width()}{C.RESET}")
+
+        # Month/Year display
+        month_name = ["", "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+                      "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"][m]
+
+        lines.append(f"  {C.BOLD}{month_name} {y}{C.RESET}")
+
+        lines.append(f"{C.DIM}{'─' * ui.get_terminal_width()}{C.RESET}")
+
+        # Day headers
+        day_headers = "Mo Tu We Th Fr Sa Su"
+        lines.append(f"  {day_headers}")
+
+        # Calendar grid
+        cal_obj = cal.monthcalendar(y, m)
+
+        for week in cal_obj:
+            week_parts = []
+            for day in week:
+                if day == 0:
+                    week_parts.append("   ")
+                else:
+                    is_selected = (day == cursor_day)
+                    if is_selected:
+                        style = f"{C.ACCENT}{C.BOLD}" if day_mode else f"{C.BOLD}"
+                        week_parts.append(f"{style}{day:2d}{C.RESET} ")
+                    else:
+                        week_parts.append(f"{day:2d} ")
+            lines.append(f"  {''.join(week_parts)}")
+
+        lines.append(f"{C.DIM}{'─' * ui.get_terminal_width()}{C.RESET}")
+
+        L = keys.label
+        _cal_pairs = [(L("calendar.save"), "save"), (L("calendar.back"), "back"),
+                      (L("list.quit"), "quit app"), (L("calendar.switch", first=True), "month/day"),
+                      (L("calendar.earlier", "calendar.later"), "±1 day" if day_mode else "month"),
+                      (L("calendar.up", "calendar.down"), "±7 days" if day_mode else "year"),
+                      (L("calendar.manual"), "manual entry")]
+
+        append_chrome(lines, _with_toggle_hint(_cal_pairs), _hint_cells)
+        w.render(lines)
+
+    result = None
+    try:
+        _set_raw(fd)
+        enable_mouse()          # so the hint keys below can be clicked
+        screen_takeover_next()   # paint over the previous screen, no flash
+        _render()
+
+        while True:
+            if ui.consume_resize():
+                ui.clear_screen()
+                w.anchor_reset()
+                _render()
+                continue
+
+            if not _wait_for_keypress(0.05):
+                continue
+
+            key = _read_key(fd)
+            # A transport key, a click on the now-playing box, or a click on one of our
+            # own hint keys, handled the same way on every screen.
+            _ch = consume_chrome(key, _hint_cells)
+            if _ch is CHROME_HANDLED:
+                continue
+            if _ch is CHROME_REDRAW:
+                w.anchor_reset(); _render(); continue
+            if _ch is not None:
+                key = _ch
+
+            if chrome.is_mode_toggle(key):
+                return MODE_TOGGLE  # type: ignore[return-value]
+            act = keys.action(key, "calendar")
+            if act == 'calendar.save':
+                result = f"{y:04d}-{m:02d}-{cursor_day:02d}"
+                break
+            elif key == 'CTRL_C' or act == 'calendar.back':   # Ctrl-C cancels, as in every widget
+                break
+            elif act == 'list.quit':
+                raise QuitToTerminal()   # q quits the app; it never just leaves a widget
+
+            elif act == 'calendar.switch':
+                day_mode = not day_mode      # two modes: reverse is the same flip
+
+            elif act == 'calendar.later':
+                if not day_mode:
+                    m += 1
+                    if m > 12:
+                        m = 1
+                        y += 1
+                    cursor_day = min(cursor_day, _days_in_month(y, m))
+                else:
+                    cursor_day += 1
+                    if cursor_day > _days_in_month(y, m):
+                        m += 1
+                        if m > 12:
+                            m = 1
+                            y += 1
+                        cursor_day = 1
+
+            elif act == 'calendar.earlier':
+                if not day_mode:
+                    m -= 1
+                    if m < 1:
+                        m = 12
+                        y -= 1
+                    cursor_day = min(cursor_day, _days_in_month(y, m))
+                else:
+                    cursor_day -= 1
+                    if cursor_day < 1:
+                        m -= 1
+                        if m < 1:
+                            m = 12
+                            y -= 1
+                        cursor_day = _days_in_month(y, m)
+
+            elif act == 'calendar.up':
+                if not day_mode:
+                    y -= 1
+                    cursor_day = min(cursor_day, _days_in_month(y, m))
+                else:
+                    cursor_day -= 7
+                    if cursor_day < 1:
+                        m -= 1
+                        if m < 1:
+                            m = 12
+                            y -= 1
+                        # Wraps into the last day of the previous month
+                        cursor_day = _days_in_month(y, m)
+
+            elif act == 'calendar.down':
+                if not day_mode:
+                    y += 1
+                    cursor_day = min(cursor_day, _days_in_month(y, m))
+                else:
+                    cursor_day += 7
+                    if cursor_day > _days_in_month(y, m):
+                        m += 1
+                        if m > 12:
+                            m = 1
+                            y += 1
+                        # Wraps into the first day of the next month
+                        cursor_day = 1
+
+            elif act == 'calendar.manual':
+                w.clear()
+                manual = text("Enter date (YYYY-MM-DD):", default=f"{y:04d}-{m:02d}-{cursor_day:02d}")
+                if manual:
+                    parsed = _parse_date(manual)
+                    if parsed:
+                        y, m, d = parsed
+                        cursor_day = d
+                ui.clear_screen()
+                enable_mouse()           # text() turns it off on its way out
+                w.anchor_reset()
+
+            elif key.isdigit():
+                # Accumulate a leading 1/2/3 into a two-digit day (10-31),
+                # otherwise jump straight to the single-digit day.
+                dm = _days_in_month(y, m)
+                if _digit_buf in ("1", "2", "3") and 1 <= int(_digit_buf + key) <= dm:
+                    cursor_day = int(_digit_buf + key)
+                    _digit_buf = ""
+                else:
+                    d1 = int(key)
+                    _digit_buf = key if d1 in (1, 2, 3) else ""
+                    if 1 <= d1 <= dm:
+                        cursor_day = d1
+            else:
+                _digit_buf = ""
+
+            _render()
+
+    finally:
+        disable_mouse()
+        _restore_term_attrs(fd, old)
+        w.clear()
+
+    return result
+
+
+def datetime_edit(message: str = "Edit date and time:", initial: str = "") -> str | None:
+    """
+    Combined single-screen date + time editor.
+
+    Date section: calendar grid (TAB toggles month/year ↔ day navigation).
+    Time section: HH:MM:SS.ms fields (TAB advances field).
+    TAB from date-day-mode → time section; TAB from last time field → date.
+    ENTER saves from any position. Returns ISO 8601 string or None if cancelled.
+    """
+    date_str, time_str = dtp.split_stamp(initial)
+
+    parsed = _parse_date(date_str) if date_str else None
+    if parsed:
+        year, month, cursor_day = parsed
+    else:
+        _today = datetime.date.today()
+        year, month, cursor_day = _today.year, _today.month, _today.day
+
+    day_mode = False
+
+    def _digits_only(s: str) -> str:
+        """Strip everything from the first non-digit onward, keeping just the leading digit run."""
+        return re.sub(r'\D.*', '', s)   # keep only leading digit run
+
+    t_parts = time_str.split(':') if time_str else []
+    _h  = _digits_only(t_parts[0]) if t_parts else ""
+    _mi = _digits_only(t_parts[1]) if len(t_parts) > 1 else ""
+    if len(t_parts) > 2:
+        _sp = t_parts[2].split('.')
+        _s  = _digits_only(_sp[0]) if _sp else ""
+        _ms = _digits_only(_sp[1]) if len(_sp) > 1 else ""
+    else:
+        _s, _ms = "", ""
+
+    tfields = {
+        'hours':   list((_h  or "00")[-2:].zfill(2)),
+        'minutes': list((_mi or "00")[-2:].zfill(2)),
+        'seconds': list((_s  or "00")[-2:].zfill(2)),
+        'millis':  list((_ms or "000")[-3:].zfill(3)),
+    }
+    torder  = ['hours', 'minutes', 'seconds', 'millis']
+    tmaxlen = {'hours': 2, 'minutes': 2, 'seconds': 2, 'millis': 3}
+    tcursor = 0
+    tpos    = {k: len(tfields[k]) for k in torder}
+
+    section = 'date'
+
+    fd  = sys.stdin.fileno()
+    old = _get_term_attrs(fd)
+    w   = _Widget(fd)
+    _hint_cells: dict = {}   # clickable hint keys, filled by append_chrome
+
+    def _render():
+        lines = []
+
+        lines.append(f"  {C.DIM}{message}{C.RESET}")
+        lines.append(f"{C.DIM}{'─' * ui.get_terminal_width()}{C.RESET}")
+
+        # Date section
+        month_name = ["", "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+                      "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"][month]
+        dpfx = C.BOLD if section == 'date' else C.DIM
+        lines.append(f"  {dpfx}{month_name} {year}{C.RESET}")
+        lines.append(f"{C.DIM}{'─' * ui.get_terminal_width()}{C.RESET}")
+        lines.append("  Mo Tu We Th Fr Sa Su")
+
+        for week in cal.monthcalendar(year, month):
+            parts = []
+            for day in week:
+                if day == 0:
+                    parts.append("   ")
+                elif day == cursor_day and section == 'date':
+                    style = f"{C.ACCENT}{C.BOLD}" if day_mode else C.BOLD
+                    parts.append(f"{style}{day:2d}{C.RESET} ")
+                else:
+                    parts.append(f"{day:2d} ")
+            lines.append(f"  {''.join(parts)}")
+
+        lines.append(f"{C.DIM}{'─' * ui.get_terminal_width()}{C.RESET}")
+
+        # Time section
+        tpfx = C.BOLD if section == 'time' else C.DIM
+        row = f"  {tpfx}Time{C.RESET}  "
+        for i, field in enumerate(torder):
+            val = "".join(tfields[field])
+            pos = tpos[field]
+            if section == 'time' and i == tcursor:
+                cell = block_cursor(val, pos)
+            else:
+                cell = f"{C.DIM}{val.ljust(tmaxlen[field], '0')}{C.RESET}"
+            row += cell
+            if i == 0:   row += ":"
+            elif i == 1: row += ":"
+            elif i == 2: row += "."
+        lines.append(row)
+
+        lines.append(f"{C.DIM}{'─' * ui.get_terminal_width()}{C.RESET}")
+
+        h = ""
+        if section == 'date':
+            if not day_mode:
+                h = [("←→", "month"), ("↑↓", "year"), ("tab/⇧tab", "field"),
+                     ("↵", "save"), ("esc", "back"), (keys.label("list.quit"), "quit app")]
+            else:
+                h = [("←→↑↓", "navigate"), ("tab/⇧tab", "field"), ("↵", "save"),
+                     ("esc", "back"), (keys.label("list.quit"), "quit app")]
+        elif section == 'time':
+            h = [("←→", "cursor"), ("tab/⇧tab", "field"), ("↵", "save"),
+                 ("esc", "back"), (keys.label("list.quit"), "quit app")]
+
+        append_chrome(lines, _with_toggle_hint(h), _hint_cells)
+        w.render(lines)
+
+    def _build_result() -> str:
+        """Assemble the ISO datetime string from date + time fields, omitting a zero time-of-day or trailing zero millis."""
+        h  = "".join(tfields['hours']).zfill(2)
+        mi = "".join(tfields['minutes']).zfill(2)
+        s  = "".join(tfields['seconds']).zfill(2)
+        ms = "".join(tfields['millis']).zfill(3)
+        hms = f"{h}:{mi}:{s}"
+        date_part = f"{year:04d}-{month:02d}-{cursor_day:02d}"
+        if hms == "00:00:00":
+            return date_part
+        if ms == "000":
+            return f"{date_part}T{hms}"
+        return f"{date_part}T{hms}.{ms}"
+
+    result = None
+    try:
+        _set_raw(fd)
+        enable_mouse()          # so the hint keys below can be clicked
+        screen_takeover_next()   # paint over the previous screen, no flash
+        _render()
+
+        while True:
+            if ui.consume_resize():
+                ui.clear_screen()
+                w.anchor_reset()
+                _render()
+                continue
+
+            if not _wait_for_keypress(0.05):
+                continue
+
+            key = _read_key(fd)
+            # A transport key, a click on the now-playing box, or a click on one of our
+            # own hint keys, handled the same way on every screen.
+            _ch = consume_chrome(key, _hint_cells)
+            if _ch is CHROME_HANDLED:
+                continue
+            if _ch is CHROME_REDRAW:
+                w.anchor_reset(); _render(); continue
+            if _ch is not None:
+                key = _ch
+
+            if chrome.is_mode_toggle(key):
+                return MODE_TOGGLE  # type: ignore[return-value]
+            if key in ('ESC', 'CTRL_C'):
+                break
+            if keys.pressed(key, 'list.quit'):
+                raise QuitToTerminal()   # q quits the app; it never just leaves a widget
+
+            if key == 'ENTER':
+                result = _build_result()
+                break
+
+            elif key == 'TAB':
+                if section == 'date':
+                    if not day_mode:
+                        day_mode = True
+                    else:
+                        day_mode = False
+                        section = 'time'
+                        tcursor = 0
+                elif section == 'time':
+                    if tcursor < len(torder) - 1:
+                        tcursor += 1
+                    else:
+                        # Cycle back to the date section (docstring contract),
+                        # starting at the month/year view.
+                        section = 'date'
+                        day_mode = False
+                        tcursor = 0
+
+            elif key == 'BACKTAB':
+                # The same chain backwards: month/year ← day grid ← time fields.
+                if section == 'date':
+                    if day_mode:
+                        day_mode = False
+                    else:
+                        section = 'time'
+                        tcursor = len(torder) - 1
+                else:
+                    if tcursor > 0:
+                        tcursor -= 1
+                    else:
+                        section = 'date'
+                        day_mode = True
+
+            elif section == 'date':
+                if key == 'RIGHT':
+                    if not day_mode:
+                        month += 1
+                        if month > 12: month, year = 1, year + 1
+                        cursor_day = min(cursor_day, _days_in_month(year, month))
+                    else:
+                        cursor_day += 1
+                        if cursor_day > _days_in_month(year, month):
+                            month += 1
+                            if month > 12: month, year = 1, year + 1
+                            cursor_day = 1
+                elif key == 'LEFT':
+                    if not day_mode:
+                        month -= 1
+                        if month < 1: month, year = 12, year - 1
+                        cursor_day = min(cursor_day, _days_in_month(year, month))
+                    else:
+                        cursor_day -= 1
+                        if cursor_day < 1:
+                            month -= 1
+                            if month < 1: month, year = 12, year - 1
+                            cursor_day = _days_in_month(year, month)
+                elif key == 'UP':
+                    if not day_mode:
+                        year -= 1
+                        cursor_day = min(cursor_day, _days_in_month(year, month))
+                    else:
+                        cursor_day -= 7
+                        if cursor_day < 1:
+                            month -= 1
+                            if month < 1: month, year = 12, year - 1
+                            cursor_day = _days_in_month(year, month)
+                elif key == 'DOWN':
+                    if not day_mode:
+                        year += 1
+                        cursor_day = min(cursor_day, _days_in_month(year, month))
+                    else:
+                        cursor_day += 7
+                        if cursor_day > _days_in_month(year, month):
+                            month += 1
+                            if month > 12: month, year = 1, year + 1
+                            cursor_day = 1
+
+            else:  # time section
+                cur_f = torder[tcursor]
+                buf   = tfields[cur_f]
+                pos   = tpos[cur_f]
+                maxl  = tmaxlen[cur_f]
+
+                if key == 'BACKSPACE':
+                    if pos > 0:
+                        buf.pop(pos - 1)
+                        tpos[cur_f] = pos - 1
+                elif key == 'DELETE':
+                    if pos < len(buf):
+                        buf.pop(pos)
+                elif key == 'LEFT':
+                    tpos[cur_f] = max(0, pos - 1)
+                elif key == 'RIGHT':
+                    tpos[cur_f] = min(len(buf), pos + 1)
+                elif key == 'HOME':
+                    tpos[cur_f] = 0
+                elif key == 'END':
+                    tpos[cur_f] = len(buf)
+                elif key.isdigit() and len(buf) < maxl:
+                    buf.insert(pos, key)
+                    tpos[cur_f] = pos + 1
+
+            _render()
+
+    finally:
+        disable_mouse()
+        _restore_term_attrs(fd, old)
+        w.clear()
+
+    return result

backbone/prompt/keymap.py

@@ -0,0 +1,143 @@
+"""Settings → Key bindings: every action in backbone.keys, one row each, with
+its keys. ↵ adds a key (press it), and the page's own keys remove one, reset
+one, or reset everything. Changes save at once, so every hint follows."""
+from __future__ import annotations
+import sys
+
+from backbone import keys, ui
+from backbone.log import log
+from backbone.prompt.core import Choice, Column, _read_key, rounded_header, separator
+from backbone.ui import Colors as C
+
+keys.define("keys_editor", "Key bindings page", [
+    ("remove", ("d", "DELETE", "BACKSPACE"), "remove a key from the action"),
+    ("reset", ("r",), "put the action back to its default keys"),
+    ("reset_all", ("R",), "put every action back to its default keys"),
+])
+
+_COLUMNS = [
+    Column(style='primary'),                        # what it does
+    Column(),                                       # its keys: grey, or accent once changed
+    Column(style='dynamic-dim', flex=True),         # default / changed
+]
+
+
+def _row(a: keys.Action) -> Choice:
+    shown = keys.label(a.id) or "unbound"
+    changed = keys.changed(a.id)
+    return Choice(title=a.label, value=a.id,
+                  cells=[a.label, [(shown, 'accent' if changed else 'dynamic-dim')],
+                         "changed" if changed else ""])
+
+
+def _choices() -> list:
+    out: list = []
+    for scope, title in keys.scopes():
+        if scope == "keys_editor":
+            continue                                 # listed last, below
+        out.append(separator(title))
+        out += [_row(a) for a in keys.actions(scope)]
+    out.append(separator("This page"))
+    out += [_row(a) for a in keys.actions("keys_editor")]
+    return out
+
+
+def _capture(what: str) -> str | None:
+    """The next key pressed, for `what`; None on Esc."""
+    from backbone.terminal_input import raw_mode
+    ui.clear_screen()
+    pad = " " * ui.MARGIN_H
+    sys.stdout.write(f"\n{pad}{C.BOLD}Press the new key for: {what}{C.RESET}\n"
+                     f"{pad}{C.DIM}esc cancels{C.RESET}\n")
+    sys.stdout.flush()
+    with raw_mode(sys.stdin):
+        while True:
+            key = _read_key(sys.stdin.fileno())
+            if key == 'ESC':
+                return None
+            if keys.bindable(key):
+                return key
+
+
+def _title(aid: str) -> str:
+    a = next(x for x in keys.actions() if x.id == aid)
+    scope_title = dict(keys.scopes()).get(a.scope, a.scope)
+    return f"{a.label} ({scope_title})"
+
+
+def _add_key(aid: str) -> None:
+    from backbone.prompt.lists import select
+    key = _capture(_title(aid))
+    if key is None:
+        return
+    shown = keys.glyph(key)
+    if key in keys.of(aid):
+        ui.show_status(f"{shown} is already one of its keys.")
+        return
+    others = keys.conflicts(aid, key)
+    if others:
+        names = "; ".join(_title(o) for o in others)
+        pick = select(f"{shown} is already used for {names}.",
+                      [Choice("Move it to this action", value="move"), Choice("Cancel", value=None)])
+        if pick != "move":
+            return
+        for o in others:
+            keys.bind(o, tuple(k for k in keys.of(o) if k != key))
+    keys.bind(aid, keys.of(aid) + (key,))
+    log.info("key binding %s += %r", aid, key)
+    ui.show_status(f"{shown} now: {_title(aid)}")
+
+
+def _remove_key(aid: str) -> None:
+    from backbone.prompt.lists import select
+    bound = keys.of(aid)
+    if not bound:
+        return
+    key = bound[0] if len(bound) == 1 else select(
+        f"Remove which key from {_title(aid)}?",
+        [Choice(keys.glyph(k), value=k) for k in bound])
+    if key is None:
+        return
+    keys.bind(aid, tuple(k for k in bound if k != key))
+    ui.show_status(f"{keys.glyph(key)} removed" + ("" if len(bound) > 1 else ": the action has no key now"))
+
+
+def keys_editor() -> None:
+    """The Key bindings page. Returns when backed out of."""
+    from backbone.prompt.lists import ListPlace, select
+    place = ListPlace()
+    while True:
+        changed = sum(keys.changed(a.id) for a in keys.actions())
+        done: dict = {}
+
+        def _act(name):
+            def run(aid):
+                done['act'], done['aid'] = name, aid
+                return aid                          # end the list; the loop redraws it
+            return run
+
+        row_actions, hints = {}, {}
+        for name in ("remove", "reset", "reset_all"):
+            aid = f"keys_editor.{name}"
+            for k in keys.of(aid):
+                row_actions[k] = _act(name)
+            hints[keys.label(aid)] = {"remove": "remove a key", "reset": "reset",
+                                      "reset_all": "reset all"}[name]
+
+        choice = select("", _choices(), columns=_COLUMNS, place=place,
+                        header=lambda: rounded_header("Key bindings", "",
+                                                      f"{changed} changed" if changed else "all default"),
+                        extra_hints={"↵": "add a key"},
+                        row_actions=row_actions, row_action_hints=hints)
+        if choice is None:
+            return
+        act = done.get('act')
+        if act == "remove":
+            _remove_key(choice)
+        elif act == "reset":
+            keys.reset(choice)
+        elif act == "reset_all":
+            keys.reset()
+            ui.show_status("Every key is back to its default.")
+        else:
+            _add_key(choice)