backpack-backbone 0.3.0__tar.gz → 0.3.1__tar.gz

{backpack_backbone-0.3.0/backpack_backbone.egg-info → backpack_backbone-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: backpack-backbone
-Version: 0.3.0
+Version: 0.3.1
 Summary: Shared code for the back* tools: terminal UI, prompt widgets, live views, logging, dates, settings plumbing and small file helpers, implemented once.
 License: MIT
 Project-URL: Homepage, https://github.com/RedEraRrow/backbone

{backpack_backbone-0.3.0 → backpack_backbone-0.3.1}/backbone/prompt/audio.py

@@ -67,12 +67,12 @@ keys.define("levels", "Volume and equaliser", [
     ("up_big", ("PGUP",), "raise by 3"),
     ("down_big", ("PGDN",), "lower by 3"),
     ("zero", ("0",), "back to zero"),
-    ("prev_band", ("LEFT",), "previous band (equaliser)"),
-    ("next_band", ("RIGHT",), "next band (equaliser)"),
-    ("add", ("a", "A"), "add a band (equaliser)"),
-    ("delete", ("d", "D", "BACKSPACE", "DELETE"), "delete the band (equaliser)"),
-    ("flat", ("f", "F"), "flatten every band (equaliser)"),
-    ("preset", ("p", "P"), "next preset (equaliser)"),
+    ("prev_band", ("LEFT",), "previous band"),
+    ("next_band", ("RIGHT",), "next band"),
+    ("add", ("a", "A"), "add a band"),
+    ("delete", ("d", "D", "BACKSPACE", "DELETE"), "delete the band"),
+    ("flat", ("f", "F"), "flatten every band"),
+    ("preset", ("p", "P"), "next preset"),
     ("save", ("ENTER",), "save"),
     ("back", ("ESC",), "back"),
 ], within=("list", "global"))

{backpack_backbone-0.3.0 → backpack_backbone-0.3.1}/backbone/prompt/chrome.py

@@ -79,20 +79,22 @@ _command_line = None
 
 
 def set_command_line(fn) -> None:
-    """Register a ``callable()`` that `:` opens, where a screen leaves it free.
-    It returns whether it opened a screen of its own (the screen under it then
-    needs drawing again)."""
+    """Register a ``callable(around=None)`` that `:` opens, where a screen
+    leaves it free. It returns whether it opened a screen of its own (the
+    screen under it then needs drawing again), opening it inside `around()`
+    when given."""
     global _command_line
     _command_line = fn
 
 
-def open_command_line() -> bool | None:
-    """Run the registered command line: whether it opened a screen of its own;
-    None when there is none to run here (none registered, or a screen that
-    keeps you in it, nav.modal())."""
+def open_command_line(around=None) -> bool | None:
+    """Run the registered command line: whether it opened a screen of its own
+    (inside the context `around()`, when given: the player steps out of view
+    only for that); None when there is none to run here (none registered, or
+    a screen that keeps you in it, nav.modal())."""
     if _command_line is None or nav.is_modal():
         return None
-    return bool(_command_line())
+    return bool(_command_line(around=around) if around else _command_line())
 
 
 # --- shared widget chrome -------------------------------------------------
@@ -142,7 +144,7 @@ def append_chrome(out: list, pairs, cells: dict, *, extra: str = "",
 
     The bar is empty unless hints are switched on; either way the top line
     (`out[0]`) carries the corner toggle. `help_key`: this screen leaves `?` free,
-    so `?` toggles and the corner says so; otherwise it names Ctrl-/.
+    so `?` toggles and the corner says so; otherwise it names Ctrl-/ (or Ctrl-G).
     """
     items = chrome_hint_pairs(pairs)
     hint_lines = _hint(*items, extra=extra).splitlines()

{backpack_backbone-0.3.0 → backpack_backbone-0.3.1}/backbone/prompt/core.py

@@ -8,7 +8,7 @@ import textwrap
 import time
 import select as _sel
 from dataclasses import dataclass, field
-from typing import Any
+from typing import Any, Callable
 
 from backbone import keys, nav, ui
 from backbone.log import log, enabled as _logging, quietly
@@ -110,6 +110,7 @@ def screen_invalidate() -> None:
         _screen_size[0] = size
     _reserved.clear()                    # a frame after this reserves afresh
     _shown_pictures.clear()              # a clear took them with it
+    _picture_areas.clear()
     _float.clear()
     _screen.clear()
     _cells.clear()
@@ -140,6 +141,7 @@ def _resize_wipe() -> str:
     _screen.clear()
     _cells.clear()
     _shown_pictures.clear()
+    _float.clear()                       # the wipe takes a floating box with it; it isn't drawn back at the old place
     return "\033[H\033[2J" if was is not None else ""
 
 
@@ -301,7 +303,8 @@ def _notched(cells: list, notch: tuple) -> list:
 def _title_right(cells: list, left: int, right: int, after: int) -> None:
     """Move a box's top-border title (" Title ", just after its corner) to
     the right end of the border, before what's already there (a subtitle,
-    the help toggle), past column `after`; drop it if it won't fit."""
+    the help toggle), past column `after`: shortened by whole " · " parts
+    where it won't fit, and dropped where even its first won't."""
     if left + 2 >= right or cells[left + 1][1] not in _EDGE or cells[left + 2][1] != " ":
         return
     end = next((i for i in range(left + 3, right) if cells[i][1] in _EDGE and cells[i - 1][1] == " "), None)
@@ -312,11 +315,10 @@ def _title_right(cells: list, left: int, right: int, after: int) -> None:
         cells[i] = dash
     stop = next((i for i in range(end, right) if cells[i][1] not in _EDGE), right) - 1
     room = stop - (after + 2)                          # columns between the tab and what's at the right
-    if len(title) > room >= 8:                         # shortened, rather than lost: " Tag ID (e.g. …"
-        title = title[:room - 2] + [(title[room - 3][0], "…"), title[-1]]
-        while title[-3][1] == "":                      # never half a wide character before the …
-            title[-3:-2] = []
-            title.insert(-2, (title[-2][0], " "))
+    if len(title) > room:                              # never cut short: whole " · " parts off the end, else none
+        cuts = [i for i in range(len(title) - 2, 0, -1)
+                if (title[i - 1][1], title[i][1], title[i + 1][1]) == (" ", "·", " ") and i <= room]
+        title = title[:cuts[0]] if cuts else []        # " Queue · 1 of 28 " → " Queue "
     start = stop - len(title)
     if start > after + 1:
         cells[start:stop] = title
@@ -356,6 +358,9 @@ def screen_span_paint(row: int, col: int, text: str) -> str:
     before = list(new)
     if old is None:                                  # unknown row: the span's cells all written
         before = [_UNKNOWN] * len(new)
+    for first, last in _picture_cols(row):           # an image is there, whatever the cells say:
+        for k in range(max(first, col) - 1, min(last, col - 1 + len(span))):
+            before[k] = _UNKNOWN                     # write them all, or it shows through the blanks
     new[col - 1:col - 1 + len(span)] = span
     _cells[row] = new
     _screen[row] = _screen.get(row, "") + "\x00span"          # the row's text no longer says it all
@@ -507,14 +512,67 @@ def screen_float(lines: list, seconds: float) -> None:
     cols, rows = ui.get_terminal_size()
     lines = [ui.clip_ansi(ln, cols) for ln in lines[:rows]]
     w = max((ui.visual_len(ln) for ln in lines), default=0)
-    place = dict(w=w, top=max(1, (rows - len(lines)) // 2 + 1), left=max(1, (cols - w) // 2 + 1))
-    if _float and (len(_float['lines']), _float['w'], _float['top'], _float['left']) != (
+    place = dict(w=w, top=max(1, (rows - len(lines)) // 2 + 1), left=max(1, (cols - w) // 2 + 1), size=(cols, rows))
+    if _float and _float['size'] == (cols, rows) and (len(_float['lines']), _float['w'], _float['top'], _float['left']) != (
             len(lines), place['w'], place['top'], place['left']):
-        _float_gone()                # a new shape: put back what the old one covered first
+        _float_gone()                # a new shape: put back what the old one covered (not at a new size: those cells are gone)
     _float.update(lines=lines, until=time.time() + seconds, **place)
     _float_draw()
 
 
+_backdrops: list = []                # the screens showing, innermost last: their redraw, and how they meet a small window
+
+
+def screen_backdrop(redraw, small: bool = False) -> Callable[[], None]:
+    """Say the screen now showing is this one, till the returned call (for
+    its `finally`) takes it back. `redraw()` lays it out afresh at the current
+    size, what an overlay over it calls on a resize; None: it notices a new
+    size itself (asked to with ui.request_relayout). `small`: it lays out a
+    window too small for boxes itself (the player, the miniplayer), so no
+    miniplayer takes over from it."""
+    entry = {'redraw': redraw, 'small': small, 'overlay': False}
+    _backdrops.append(entry)
+    return lambda: _backdrops.remove(entry) if entry in _backdrops else None
+
+
+def overlay_layer() -> Callable[[], None]:
+    """An overlay opening over the screen showing: it meets any size itself,
+    and what it redraws under it is that screen. Returns the call that closes
+    the layer, made before the screen under it is put back."""
+    entry = {'redraw': None, 'small': True, 'overlay': True}
+    _backdrops.append(entry)
+    return lambda: _backdrops.remove(entry) if entry in _backdrops else None
+
+
+def _screen_under_overlay() -> dict | None:
+    """The screen an overlay is over (or the top one, with none open)."""
+    return next((e for e in reversed(_backdrops) if not e['overlay']), None)
+
+
+def relayout_under_overlay() -> None:
+    """The window was resized while an overlay is open: the screen under it
+    lays itself out at the new size, where it can keep its boxes (smaller,
+    the overlay has the window to itself). The overlay then places itself
+    afresh over what's there now."""
+    _float.clear()                       # a floating box goes; its owner shows it again if it's still wanted
+    if box_fits():
+        redraw_under_overlay()
+
+
+def redraw_under_overlay() -> None:
+    """The screen under an overlay drawn again, whole, at the current size:
+    by its redraw, or, with none to call, cleared and asked to lay itself out
+    (it notices at its next resize check)."""
+    under = _screen_under_overlay()
+    if under and under['redraw'] is not None:
+        under['redraw']()
+        return
+    sys.stdout.write("\033[H\033[2J")
+    sys.stdout.flush()
+    screen_invalidate()
+    ui.request_relayout()
+
+
 def screen_float_close() -> None:
     """Take a floating box away now, putting back what it covered."""
     if _float:
@@ -578,6 +636,26 @@ def float_tick() -> bool:
     return True
 
 
+_picture_areas: dict = {}            # pictures other screens draw themselves: name → (top, left, rows, cols)
+
+
+def screen_picture_area(name: str, area: tuple | None) -> None:
+    """Say a screen drawing its own picture (the player's cover) has one at
+    `area` (top, left, rows, cols; 1-based), or None now it's gone: anything
+    drawn over it then writes every cell, so none of the image shows through."""
+    if area:
+        _picture_areas[name] = area
+    else:
+        _picture_areas.pop(name, None)
+
+
+def _picture_cols(row: int) -> list[tuple[int, int]]:
+    """The columns (first, last; 1-based) of `row` a picture covers."""
+    return ([(c, c + size[0] - 1 if size else 10 ** 6)
+             for r, c, n, _k, _esc, *size in _shown_pictures if r <= row < r + n]
+            + [(c, c + w - 1) for r, c, n, w in _picture_areas.values() if r <= row < r + n])
+
+
 def screen_forget_pictures() -> None:
     """For a screen that draws without _Widget (a player view): forget the
     cells under the pictures the last widget drew, so this screen's paint
@@ -590,6 +668,21 @@ def screen_forget_pictures() -> None:
     _shown_pictures.clear()
 
 
+_BORDER_CHARS = set("╭╮╰╯│─├┤┬┴┼┊┈")
+
+
+def screen_crosses_box(first_row: int, last_row: int, first_col: int, last_col: int) -> bool:
+    """Whether any box's border on screen lies in the rectangle (1-based,
+    inclusive): something drawn there would cut that box, leaving it half a
+    box. A rectangle wholly inside one box's inside crosses nothing."""
+    for r in range(first_row, last_row + 1):
+        cells = _cells.get(r) or []
+        for c in range(first_col - 1, min(last_col, len(cells))):
+            if cells[c] is not _UNKNOWN and cells[c][1] in _BORDER_CHARS:
+                return True
+    return False
+
+
 def screen_save(first_row: int, last_row: int, first_col: int, last_col: int) -> dict:
     """What the painter holds in a rectangle, to put back with screen_restore
     once something drawn over it (an overlay) is gone."""
@@ -640,6 +733,8 @@ def screen_paint(rows: dict, *, cursor: tuple | None = None,
     inputs); `save_cursor` wraps the frame in DEC save/restore so a caret
     elsewhere is left alone (background repaints).
     """
+    if _cramped():                     # a frame without its boxes: the miniplayer shows instead
+        return
     rows = _takeover_rows(rows)
     parts: list[str] = []
     for row in sorted(rows):
@@ -722,6 +817,8 @@ def _render_footer_bar() -> None:
     change lands) when nothing else redraws. Repaints when either the track
     identity or the styled rows changed, so an idle screen never flickers yet a
     new song is never missed."""
+    if _chrome_held():                     # the miniplayer has the window
+        return
     rows = ui.get_terminal_height()
     cols = ui.get_terminal_width()
     lines = ui.footer_lines(cols)
@@ -736,11 +833,97 @@ def _render_footer_bar() -> None:
         sys.stdout.flush()
 
 
+# A window too small for a screen's boxes: the screen gives way to the
+# miniplayer (a tool registers it), which keeps the window till the boxes fit
+# again. A screen that lays out small windows itself (the player) says so
+# when it registers (screen_backdrop small=True).
+_cramped_view = [None]
+_cramped_showing = [0]                  # the miniplayer is up (nested: a screen opened from it, then it again)
+
+
+def set_cramped_view(fn) -> None:
+    """Register ``fn()``: what shows while a window is too small for any
+    screen's boxes, returning once they fit again (the miniplayer). With
+    none, a box saying the window's too small (_too_small_notice)."""
+    _cramped_view[0] = fn
+
+
+def _too_small() -> bool:
+    """The screen on top can't keep its boxes (it doesn't lay out small
+    windows itself), so the miniplayer, or the notice, shows instead."""
+    top = _backdrops[-1] if _backdrops else None
+    return not box_fits() and not (top and top['small'])
+
+
+_TOO_SMALL_NOTE = "Make the window bigger"
+
+
+def _too_small_notice() -> None:
+    """A tool with no miniplayer, in a window too small for its screen's
+    boxes: a box saying so where one fits, else nothing (no box, no
+    content), till the window grows. Keys wait; Ctrl-C still stops."""
+    fd = sys.stdin.fileno()
+    drawn = None
+    while not box_fits():
+        size = ui.get_terminal_size()
+        if size != drawn:
+            cols, rows = size
+            w = ui.visual_len(_TOO_SMALL_NOTE) + 4
+            sys.stdout.write("\033[H\033[2J")
+            if rows >= 3 and cols >= w:
+                top, left = (rows - 3) // 2 + 1, (cols - w) // 2 + 1
+                box = box_lines([f"{C.DIM}{_TOO_SMALL_NOTE}{C.RESET}"], w, 3)
+                sys.stdout.write("".join(f"\033[{top + k};{left}H{ln[ui.MARGIN_H:]}" for k, ln in enumerate(box)))
+            sys.stdout.flush()
+            drawn = size
+        if _byte_ready(fd, 0.1) and _read_key(fd) == 'CTRL_C':
+            raise KeyboardInterrupt
+
+
+_cramped = _too_small                   # a screen's paint is held back: the miniplayer shows instead
+
+
+def _chrome_held() -> bool:
+    """The now-playing box and status line stay off: the miniplayer has the window."""
+    return _too_small() or _cramped_showing[0] > 0
+
+
+def _run_cramped() -> None:
+    """The miniplayer until the boxes fit, then the screen under it laid out
+    afresh (its next resize check says yes)."""
+    tabs_were = ui.set_tabs_hidden(True)                 # the miniplayer alone
+    _cramped_showing[0] += 1
+    log.debug("window too small for boxes: the miniplayer")
+    try:
+        (_cramped_view[0] or _too_small_notice)()
+    finally:
+        _cramped_showing[0] -= 1
+        ui.set_tabs_hidden(tabs_were)
+        sys.stdout.write("\033[H\033[2J")
+        sys.stdout.flush()
+        screen_invalidate()
+        ui.request_relayout()
+
+
+_wheel_at: list = [None]               # (row, col) of the last wheel or trackpad scroll
+
+
+def wheel_at() -> tuple | None:
+    """Where the last SCROLL_UP / SCROLL_DOWN happened, (row, col) 1-based:
+    for a screen with more than one thing to scroll."""
+    return _wheel_at[0]
+
+
 def _wait_for_keypress(timeout: float = 0.05) -> bool:
     """Block up to `timeout` seconds for a keypress; return whether one arrived.
 
     Also refreshes the now-playing box at ~4 Hz so background-audio status
-    stays live on every widget/menu without each one needing its own tick."""
+    stays live on every widget/menu without each one needing its own tick.
+    In a window too small for the screen's boxes, the miniplayer instead
+    (returning no key once the screen's back)."""
+    if _cramped():
+        _run_cramped()
+        return False
     now = time.time()
     if now - _footer_last_draw[0] >= 0.12:
         _footer_last_draw[0] = now
@@ -783,17 +966,20 @@ def _cols() -> int:
 
 
 # --- Hint bar visibility ------------------------------------------------------
-# One switch for every screen's hint bar, off until turned on (`?`, Ctrl-/ where
-# `?` is typed, or a click on the corner toggle each screen shows on its top
+# One switch for every screen's hint bar, off until turned on (`?`, Ctrl-/ or
+# Ctrl-G where `?` is typed, or a click on the corner toggle each screen shows on its top
 # line), remembered between runs.
 # Kept in its own small file rather than config.json: screens hold a loaded
 # config and save it back later, which would quietly undo a toggle made meanwhile.
 HINTS_CLICK = '\x00hints'     # the key a click on the corner toggle replays
+_TYPED_HELP_KEYS = (("\x07", "\x1f") if os.environ.get("TERM_PROGRAM") == "Apple_Terminal"
+                    else ("\x1f", "\x07"))
 keys.define("global", "Everywhere", [
-    # Wherever it isn't typed or bound; Ctrl-/ (the same key with Ctrl) is the
-    # way where it is, and works everywhere.
+    # Wherever it isn't typed or bound; where it is, Ctrl-/ (the same key with
+    # Ctrl), and Ctrl-G (nano's help key) for macOS's Terminal, which sends
+    # nothing for Ctrl-/. Both work everywhere; what's shown is the first.
     ("help", ("?",), "show or hide the key hints"),
-    ("help_typed", ("\x1f",), "show or hide the key hints, in a text field too"),
+    ("help_typed", _TYPED_HELP_KEYS, "show or hide the key hints, in a text field too"),
 ], within=())
 _hints_on: list = [None]      # None until first read
 
@@ -862,7 +1048,7 @@ def set_help_toggle_shown(shown: bool) -> None:
 
 
 def is_hints_key(key: str, key_free: bool) -> bool:
-    """Whether `key` toggles the hints: a click on the corner, Ctrl-/, or `?`
+    """Whether `key` toggles the hints: a click on the corner, Ctrl-/ or Ctrl-G, or `?`
     where the screen leaves `?` free (not typed or bound)."""
     return (key == HINTS_CLICK or keys.pressed(key, "global.help_typed")
             or (key_free and keys.pressed(key, "global.help")))
@@ -870,7 +1056,8 @@ def is_hints_key(key: str, key_free: bool) -> bool:
 
 def help_corner_text(help_key: bool = True, shown: bool | None = None) -> tuple[str, int]:
     """The header toggle, styled, and its width: `[?] help` / `[?] hide help`,
-    or `[^/] …` where `?` is typed (a text field) and Ctrl-/ is the key.
+    or `[^/] …` where `?` is typed (a text field) and Ctrl-/ is the key
+    (`[^g]`, Ctrl-G, in macOS's Terminal).
     `shown`: the hints' state to describe (default: as they are now).
     Nothing, when the toggle is switched off (help_toggle_shown)."""
     if not help_toggle_shown():
@@ -896,7 +1083,7 @@ def add_help_corner(line: str, row: int, cells: dict, help_key: bool = False) ->
     """`line` (a screen's top line, drawn on screen row `row`) with the toggle
     right-aligned on it, clipping the line if the two would meet. Only the key
     is clickable (a click replays HINTS_CLICK). `help_key`: pressing `?` toggles
-    here; elsewhere `?` is typed or bound, and the toggle names Ctrl-/."""
+    here; elsewhere `?` is typed or bound, and the toggle names Ctrl-/ (or Ctrl-G)."""
     text, width = help_corner_text(help_key)
     if not width:                                    # the toggle is switched off
         if help_key:
@@ -947,25 +1134,34 @@ def box_lines(lines: list[str], width: int, height: int, title: str = "", right:
     h, v = ("┈", "┊") if dotted else ("─", "│")
     inner = max(1, width - 4)                         # "│ " + content + " │"
     pad = " " * ui.MARGIN_H
+    # Nothing in a border is ever cut short. Short of room, whole parts give
+    # way, least first: the title's " · " parts after its name, then the
+    # right end's (a subtitle, a message), then the help toggle, then the name.
+    toggle = next((t for t, _w in _toggle_variants() if t and right.endswith(t)), "") if right else ""
+    sub = ui.strip_ansi(right[:len(right) - len(toggle)]).rstrip(" ─") if right else ""
+    tparts, sparts = (title.split(" · ") if title else []), (sub.split(" · ") if sub else [])
+
+    def fits(tp: list, sp: list, tg: str) -> bool:
+        name_w = ui.visual_len(" · ".join(tp)) + 2 if tp else 0
+        r = " ─ ".join(x for x in (" · ".join(sp), tg) if x)
+        return name_w + (ui.visual_len(r) + 3 if r else 0) <= width - 4
+
+    while not fits(tparts, sparts, toggle):
+        if len(tparts) > 1:
+            tparts = tparts[:-1]
+        elif sparts:
+            sparts = sparts[:-1]
+        elif toggle:
+            toggle = ""
+        elif tparts:
+            tparts = []
+        else:
+            break
+    title = " · ".join(tparts)
     name = f" {title} " if title else ""
-    # Short of room, the title and the right end (a subtitle, the help
-    # toggle) each keep up to half the border, the longer giving way first.
-    avail = width - 4 - 3
-    ln, lr = ui.visual_len(name), ui.visual_len(right)
-    if right and ln + lr > avail:
-        fit = avail - min(ln, max(avail // 2, avail - lr))
-        if lr > fit:
-            # The help toggle at its end stays whole (it's clicked, and found
-            # there by place_help_toggle); what's before it shortens.
-            toggle = next((t for t, _w in _toggle_variants() if t and right.endswith(t)), "")
-            head, tw = right[:len(right) - len(toggle)], ui.visual_len(toggle)
-            room_h = fit - tw
-            head = (_clip_ansi(head, room_h - 2) + f"{C.DIM}… {C.RESET}") if room_h > 4 else ""
-            right = head + toggle if tw <= fit else ""
+    sub = " · ".join(sparts)
+    right = (f"{C.DIM}{sub}{C.RESET}" if sub else "") + (f"{C.DIM} ─ {C.RESET}" if sub and toggle else "") + toggle
     tail = f" {right} ─" if right else ""
-    room = width - 4 - ui.visual_len(tail)
-    if ui.visual_len(name) > room:
-        name = (_clip_ansi(name, max(0, room - 2)) + "… ") if room > 2 else ""
     rule = max(1, width - 3 - ui.visual_len(name) - ui.visual_len(tail))
     shade = C.PRIMARY if focused else C.DIM
     tail = f"{C.DIM} {C.RESET}{right}{C.DIM} ─{C.RESET}" if right else ""
@@ -979,6 +1175,18 @@ def box_lines(lines: list[str], width: int, height: int, title: str = "", right:
     return [top, *mid, f"{pad}{C.DIM}╰{h * (width - 2)}╯{C.RESET}"]
 
 
+def whole_parts(text: str, room: int) -> str:
+    """`text` as it is if it fits in `room` columns, else with whole " · "
+    parts dropped from the end till it does, else nothing: never cut short."""
+    parts = text.split(" · ")
+    while parts:
+        shown = " · ".join(parts)
+        if ui.visual_len(shown) <= room:
+            return shown
+        parts.pop()
+    return ""
+
+
 def border_right(subtitle: str | None, help_key: bool | None) -> str:
     """The right end of a box's top border: a dim `subtitle`, then the hints
     toggle (`help_key` None: none; else as help_corner_text has it)."""
@@ -1254,6 +1462,10 @@ def place_help_toggle(out: list, first_row: int, cells: dict, help_key: bool = F
             if help_key:
                 cells['__help_key__'] = True
             return
+    if out and ui.strip_ansi(out[0]).lstrip().startswith("╭"):
+        if help_key:                                 # a box's border without it: it had no room (`?` still works)
+            cells['__help_key__'] = True
+        return
     if out:
         out[0] = add_help_corner(out[0], first_row, cells, help_key)
 
@@ -1532,6 +1744,8 @@ def footer_click_action(row: int, col: int) -> str | None:
 def render_status_bar():
     """Redraw the bottom status bar in place, saving/restoring the cursor so
     the text input caret doesn't move."""
+    if _chrome_held():                     # the miniplayer has the window
+        return
     rows = ui.get_terminal_height()
     float_tick()
     if rows <= 0 or not ui.chrome_fits():             # too short a window: its rows are the screen's
@@ -2050,8 +2264,9 @@ def _read_key_raw(fd: int) -> str:
                                     btn, col, row = int(parts[0]), int(parts[1]), int(parts[2])
                                     if c == 'm':
                                         return f'MOUSE_RELEASE:{btn}:{row}:{col}'
-                                    if btn == 64: return 'SCROLL_UP'
-                                    if btn == 65: return 'SCROLL_DOWN'
+                                    if btn in (64, 65):
+                                        _wheel_at[0] = (row, col)
+                                        return 'SCROLL_UP' if btn == 64 else 'SCROLL_DOWN'
                                     if btn in (0, 1, 2): return f'MOUSE_CLICK:{btn}:{row}:{col}'
                                 except ValueError:
                                     pass
@@ -2184,6 +2399,8 @@ class _Widget:
         status bar) are left exactly as they are instead of being wiped and
         restamped on every keystroke.
         """
+        if _cramped():                       # a frame without its boxes: the miniplayer shows instead
+            return
         mv   = ui.MARGIN_V
         top  = ui.top_margin()
         rows = ui.get_terminal_height()

{backpack_backbone-0.3.0 → backpack_backbone-0.3.1}/backbone/prompt/lists.py

@@ -9,7 +9,7 @@ from typing import Any, Callable, Literal, overload
 from backbone.prompt.core import (
     _COLUMNS_MAX_WIDTH, _EDGE_MARGIN, _get_term_attrs, _set_raw, _restore_term_attrs,
     _wait_for_keypress, _table_widths, _render_table_row, _clip_ansi, _norm, block_cursor,
-    _read_key, _visible_rows, _cols, _Widget, _hint_pin_target, screen_takeover_next,
+    _read_key, _visible_rows, _cols, _Widget, _hint_pin_target, screen_takeover_next, screen_backdrop,
     Choice, Column, JumpTo, PanelTitle, Trail, border_right, box_fits, box_lines, boxed_frame, column_widths,
     COL_GAP, _COL_MAIN_MIN, _COL_PREVIEW, _LIST_ROWS_MIN, _SHAPE_SAMPLE, _STRIP_SPLIT, strip_rows,
     columns_shown, help_corner_text, panel_header, rounded_header, set_columns_shown, trail_lines,
@@ -83,14 +83,14 @@ keys.define("list", "Lists", [
     ("top", ("HOME",), "first row"),
     ("bottom", ("END",), "last row"),
     ("choose", ("ENTER", "RIGHT"), "choose the row"),
-    ("toggle", ("SPACE",), "tick the row (lists with ticks)"),
-    ("toggle_all", ("a", "A"), "tick or clear every row (lists with ticks)"),
+    ("toggle", ("SPACE",), "tick the row, in lists with ticks"),
+    ("toggle_all", ("a", "A"), "tick or clear every row, in lists with ticks"),
     ("back", ("ESC", "b", "LEFT"), "back"),
     ("quit", ("q", "Q"), "quit the app"),
     ("sections", ("/",), "a long list's sections, or the whole list"),
     ("row_options", ("o",), "everything you can do with the row"),
     ("list_options", ("O",), "everything you can do with the whole list"),
-    ("columns", ("v",), "side columns on or off (lists that have them)"),
+    ("columns", ("v",), "side columns on or off, in lists that have them"),
 ])
 # The live search lists: typing goes into the query, so their keys are the
 # ones that can't be typed.
@@ -108,7 +108,7 @@ keys.define("confirm", "Yes/no questions", [
     ("yes", ("y", "Y"), "yes"),
     ("no", ("n", "N"), "no"),
     ("default", ("ENTER",), "the default answer"),
-    ("back", ("ESC",), "back (answers no)"),
+    ("back", ("ESC",), "back, answering no"),
 ])
 L = keys.label
 
@@ -558,7 +558,8 @@ def _select_flat(message: str, choices: list, *,
         """The preview's width moved a few columns, if need be, so the edge
         between the browser's box and the preview's isn't under the showing
         tab (whose outline opens into the box under it: ui.tab_notch); the
-        shorter way, as far as both keep their least. Else as it was."""
+        shorter way, as far as both keep their least. Where neither way
+        fits, no preview (0): a box cut by the tab is no box."""
         notch = ui.tab_notch() if pw else None
         if not notch:
             return pw
@@ -573,7 +574,7 @@ def _select_flat(message: str, choices: list, *,
         move = right - (a - mh - 1)                          # the preview's corner at the tab's left side
         if _cols() - pw - move - mh - 4 - trails_w >= _COL_MAIN_MIN[0]:
             fits.append(pw + move)
-        return min(fits, key=lambda w: abs(w - pw)) if fits else pw
+        return min(fits, key=lambda w: abs(w - pw)) if fits else 0
 
     def _contents_box(pv, width: int, height: int, title: bool = True) -> list:
         """What the highlighted row holds, in a box `width` × `height`."""
@@ -620,7 +621,8 @@ def _select_flat(message: str, choices: list, *,
     def _browser_rows(body, shown, main_in, height, first, lead) -> list:
         """The column browser's rows inside its box: the levels above that fit
         (`shown`: (trail, width)), then the list (`body`, its rows' margin
-        dropped), the levels' rows level with the list's (`lead` lines down).
+        dropped), the levels' rows from the top of the box (`lead` lines down:
+        the message), not moved by the list's "N above".
         Records where each column landed (_col_geo), for clicks."""
         sep = f" {C.DIM}│{C.RESET} "
         x = 1 + ui.MARGIN_H + 2                  # the screen column inside "│ "
@@ -814,7 +816,7 @@ def _select_flat(message: str, choices: list, *,
         for line, col, rows, key, esc, *size in getattr(h_lines, 'pictures', ()):
             w.pictures.append((1 + ui.top_margin() + line, col + 1, rows, key, esc, *size))
         if boxed and (shown or pw or strip_h):
-            browser = box_lines(_browser_rows(out, shown, main_in, box_h - 2, first, len(pre) + (viewport > 0)),
+            browser = box_lines(_browser_rows(out, shown, main_in, box_h - 2, first, len(pre)),
                                 browser_w, box_h, box_title, box_right)
             if pw:
                 browser = [b + p for b, p in zip(browser, _preview_column(pview, pw, box_h, browser_w, first))]
@@ -842,17 +844,22 @@ def _select_flat(message: str, choices: list, *,
 
     result = None
     _sel_last_click: int | None = None
+    _drop_backdrop = lambda: None      # noqa: E731 (none until the loop's first frame)
     try:
         _set_raw(fd)
         enable_mouse()
         screen_takeover_next()   # paint over the previous screen, no flash
         w.render(_lines())
 
+        def _relaid() -> None:
+            ui.clear_screen()
+            w.anchor_reset()
+            w.render(_lines())
+        _drop_backdrop = screen_backdrop(_relaid)
+
         while True:
             if ui.consume_resize():
-                ui.clear_screen()
-                w.anchor_reset()
-                w.render(_lines())
+                _relaid()
                 continue
 
             if not _wait_for_keypress(0.05):
@@ -1101,6 +1108,7 @@ def _select_flat(message: str, choices: list, *,
                     w.render(_lines())
 
     finally:
+        _drop_backdrop()
         disable_mouse()
         _restore_term_attrs(fd, old)
         w.clear()
@@ -1351,11 +1359,15 @@ def live_select(message: str, provider: Callable[[str], list], *,
         screen_takeover_next()   # paint over the previous screen, no flash
         w.render(_lines())
 
+        def _relaid() -> None:
+            ui.clear_screen()
+            w.anchor_reset()
+            w.render(_lines())
+        _drop_backdrop = screen_backdrop(_relaid)
+
         while True:
             if ui.consume_resize():
-                ui.clear_screen()
-                w.anchor_reset()
-                w.render(_lines())
+                _relaid()
                 continue
             if not _wait_for_keypress(0.05):
                 continue