staticfx 2.0.0__py3-none-any.whl

staticfx/ui/browser.py

@@ -0,0 +1,269 @@
+"""The effect browser: groups on the left, effects on the right, live preview behind."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from staticfx.effects.builtin import CATEGORIES
+from staticfx.effects.registry import GENERATED_CATEGORY, USER_CATEGORY
+from staticfx.effects.spec import USER, EffectSpec
+from staticfx.ui.dialogs import Confirm
+from staticfx.ui.screen import Screen
+from staticfx.ui.studio import open_studio
+from staticfx.ui.widgets import Canvas, Cursor, fit
+
+if TYPE_CHECKING:
+    from staticfx.app.app import App
+
+GROUP_WIDTH = 19
+
+
+@dataclass
+class Group:
+    name: str
+    effects: Callable[[], list[EffectSpec]]
+    empty: str = "Nothing here yet"
+
+
+def rank(spec: EffectSpec, query: str) -> int:
+    """Lower is better: exact name, name prefix, name contains, anything else."""
+    label = spec.label.lower()
+    if query in (label, spec.key):
+        return 0
+    if label.startswith(query):
+        return 1
+    return 2 if query in label else 3
+
+
+class Browser(Screen):
+    help = (
+        ("↑ ↓  PgUp PgDn", "move"),
+        ("← →", "switch between groups and effects"),
+        ("Tab", "next group"),
+        ("Enter", "play the highlighted effect"),
+        ("/", "search the selected group (Enter plays, Esc clears)"),
+        ("f", "add to / remove from favourites"),
+        ("e", "open in the Studio (generated and your own effects)"),
+        ("n", "new effect"),
+        ("d  Del", "delete one of your effects"),
+        ("Esc  q", "close"),
+    )
+
+    def __init__(self, app: App) -> None:
+        super().__init__(app)
+        registry = app.registry
+        specs = registry.specs
+
+        def by_keys(keys: list[str] | tuple[str, ...]) -> list[EffectSpec]:
+            return [registry[k] for k in keys if k in registry]
+
+        def by_category(name: str) -> Callable[[], list[EffectSpec]]:
+            return lambda: [s for s in specs() if s.category == name]
+
+        new_key = app.keymap.label("new_effect", app.ascii_only)
+        fav_key = app.keymap.label("favorite", app.ascii_only)
+        self.groups = [
+            Group("All", specs),
+            Group(
+                "Favourites",
+                lambda: by_keys(app.settings.favorites),
+                f"None yet: press {fav_key} on an effect here or while it plays",
+            ),
+            Group("Recent", lambda: by_keys(app.settings.recent), "Nothing played yet"),
+            Group(
+                USER_CATEGORY, by_category(USER_CATEGORY), f"None yet: press {new_key} to make one"
+            ),
+            Group("Gallery", lambda: by_keys(registry.gallery)),
+            *(Group(name, by_category(name)) for name in CATEGORIES),
+            Group(GENERATED_CATEGORY, by_category(GENERATED_CATEGORY)),
+        ]
+        self.search_text = {s.key: s.search_text() for s in specs()}
+        self.group = Cursor()
+        self.cursor = Cursor()
+        self.focus = "list"  # "list", "groups" or "search"
+        self.query = ""
+        self.items: list[EffectSpec] = []
+        self.counts: list[int] = []
+        self.rows = 10
+        self.refresh(keep=app.player.key)
+
+    @property
+    def current(self) -> EffectSpec | None:
+        return self.items[self.cursor.index] if self.items else None
+
+    def refresh(self, keep: str | None = None) -> None:
+        """Recompute the visible list, keeping the cursor on ``keep`` if it's still there."""
+        if keep is None and self.current is not None:
+            keep = self.current.key
+        items = self.groups[self.group.index].effects()
+        tokens = self.query.lower().split()
+        if tokens:
+            items = [s for s in items if all(t in self.search_text.get(s.key, "") for t in tokens)]
+            phrase = " ".join(tokens)
+            items.sort(key=lambda s: rank(s, phrase))
+        self.items = items
+        self.counts = [len(g.effects()) for g in self.groups]
+        keys = [s.key for s in items]
+        self.cursor.index = keys.index(keep) if keep in keys else 0
+        self.preview()
+
+    def preview(self) -> None:
+        self.app.player.preview(self.current.key if self.current else None)
+
+    def on_close(self) -> None:
+        self.app.player.preview(None)
+
+    def handle(self, key: str) -> None:
+        if self.focus == "search":
+            self.handle_search(key)
+            return
+        app, current = self.app, self.current
+        if key in ("escape", "ctrl-c", "q"):
+            self.close()
+        elif key == "/":
+            self.focus = "search"
+        elif key == "left":
+            self.focus = "groups"
+        elif key == "right":
+            self.focus = "list"
+        elif key in ("tab", "shift-tab"):
+            self.select_group(self.group.index + (1 if key == "tab" else -1))
+        elif self.focus == "groups" and self.group.handle(key, len(self.groups), 5):
+            self.select_group(self.group.index)
+        elif self.cursor.handle(key, len(self.items), self.rows):
+            self.preview()
+        elif key == "enter":
+            if self.focus == "groups":
+                self.focus = "list"
+            else:
+                self.play()
+        elif key == "n":
+            self.close()
+            open_studio(app, None)
+        elif current is None:
+            return
+        elif key == "f":
+            added = app.toggle_favorite(current.key)
+            app.toast(f"{'Added to' if added else 'Removed from'} favourites: {current.label}")
+            self.refresh()
+        elif key == "e":
+            self.edit(current)
+        elif key in ("d", "delete"):
+            self.delete(current)
+
+    def handle_search(self, key: str) -> None:
+        """Typing goes into the search; arrows still move through the results."""
+        if key in ("escape", "ctrl-c"):
+            self.query = ""
+            self.focus = "list"
+            self.refresh()
+        elif key == "enter":
+            self.play()
+        elif key in ("tab", "shift-tab"):
+            self.focus = "list"
+        elif self.cursor.handle(key, len(self.items), self.rows):
+            self.preview()
+        elif key == "backspace":
+            if not self.query:
+                self.focus = "list"
+            self.query = self.query[:-1]
+            self.refresh()
+        elif key == "space" or (len(key) == 1 and key.isprintable()):
+            self.query += " " if key == "space" else key
+            self.refresh()
+
+    def play(self) -> None:
+        if self.current is not None:
+            self.close()
+            self.app.play(self.current.key)
+
+    def select_group(self, index: int) -> None:
+        self.group.index = index % len(self.groups)
+        self.cursor.first = 0
+        self.refresh()
+
+    def edit(self, spec: EffectSpec) -> None:
+        if not spec.editable:
+            self.app.toast("Hand-written built-ins can't be edited; try a Generated effect")
+            return
+        self.close()
+        open_studio(self.app, spec.key)
+
+    def delete(self, spec: EffectSpec) -> None:
+        if spec.kind != USER:
+            self.app.toast("Only your own effects can be deleted")
+            return
+
+        def confirmed() -> None:
+            self.app.delete_effect(spec.key)
+            self.app.toast(f"Deleted {spec.label}")
+            self.refresh()
+
+        lines = [f"Delete '{spec.label}'?", "Its .sfx file will be removed."]
+        self.app.push(Confirm(self.app, "Delete effect", lines, confirmed))
+
+    def draw(self, canvas: Canvas) -> None:
+        app, c, s = self.app, canvas.chrome, canvas.style
+        w = canvas.width - 2 if canvas.width < 90 else min(84, max(64, canvas.width * 3 // 5))
+        h = canvas.height - 2
+        x, y = 1, 1
+        group = self.groups[self.group.index]
+        canvas.box(
+            x, y, w, h, "Effects", f"{len(self.items):,} of {self.counts[self.group.index]:,}"
+        )
+
+        if self.focus == "search":
+            canvas.text(x + 2, y + 1, f"Search: {self.query}_", s.selected, w - 4)
+        elif self.query:
+            canvas.text(x + 2, y + 1, f"Search: {self.query}   (/ to change)", s.text, w - 4)
+        else:
+            canvas.text(x + 2, y + 1, "Press / to search", s.dim, w - 4)
+        split = GROUP_WIDTH + 1
+        canvas.rule(x, y + 2, w, split, c.top_tee)
+        body_top, body_bottom = y + 3, y + h - 4
+        self.rows = max(1, body_bottom - body_top)
+        canvas.column(x + split, body_top, body_bottom)
+        canvas.rule(x, body_bottom, w, split, c.bottom_tee)
+
+        # groups
+        for row, i in enumerate(self.group.window(self.rows, len(self.groups)), body_top):
+            g = self.groups[i]
+            marker = c.cursor if i == self.group.index else " "
+            focused = i == self.group.index and self.focus == "groups"
+            colour = s.selected if focused else s.text if i == self.group.index else s.dim
+            label = f"{marker} {fit(g.name, GROUP_WIDTH - 7, c.ellipsis)}"
+            canvas.text(x + 1, row, label, colour, GROUP_WIDTH - 4)
+            canvas.text(x + split - 5, row, f"{self.counts[i]:>4}", s.dim)
+
+        # effects
+        lx, lw = x + split + 2, w - split - 4
+        if not self.items:
+            canvas.text(lx, body_top, "No matches" if self.query else group.empty, s.dim, lw)
+        for row, index in enumerate(self.cursor.window(self.rows, len(self.items))):
+            spec = self.items[index]
+            selected = index == self.cursor.index
+            star = c.star if app.is_favorite(spec.key) else " "
+            marker = c.cursor if selected else " "
+            tag = "" if group.name == spec.category else spec.category
+            name = fit(spec.label, lw - len(tag) - 5, c.ellipsis)
+            colour = s.selected if selected and self.focus == "list" else s.text
+            canvas.text(lx, body_top + row, f"{marker}{star} {name}", colour, lw - len(tag))
+            canvas.text(lx + lw - len(tag), body_top + row, tag, s.dim)
+        canvas.scrollbar(x + w - 2, body_top, self.rows, self.cursor.first, len(self.items))
+
+        # description and keys
+        current = self.current
+        if current is not None:
+            canvas.text(x + 2, body_bottom + 1, current.description, s.text, w - 4)
+        if self.focus == "search":
+            keys = ["type to search", "Enter play", "↑↓ move", "Esc clear"]
+        else:
+            keys = ["Enter play", "/ search", "f favourite"]
+            if current is not None and current.editable:
+                keys.append("e edit")
+            if current is not None and current.kind == USER:
+                keys.append("d delete")
+            keys += ["n new", "Esc close"]
+        canvas.text(x + 2, body_bottom + 2, f"  {c.dot}  ".join(keys), s.dim, w - 4)

staticfx/ui/dialogs.py

@@ -0,0 +1,95 @@
+"""Small modal dialogs: a text prompt and a yes/no confirmation."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+from staticfx.library.files import NAME_LIMIT, clean_name
+from staticfx.ui.screen import Screen
+from staticfx.ui.widgets import Canvas
+
+if TYPE_CHECKING:
+    from staticfx.app.app import App
+
+
+class Prompt(Screen):
+    """Asks for one line of text. ``on_submit`` runs only if the user presses Enter."""
+
+    help = (("Enter", "confirm"), ("Esc", "cancel"))
+
+    def __init__(
+        self, app: App, title: str, on_submit: Callable[[str], None], text: str = ""
+    ) -> None:
+        super().__init__(app)
+        self.title = title
+        self.text = text[:NAME_LIMIT]
+        self.on_submit = on_submit
+        self.error = ""
+
+    def handle(self, key: str) -> None:
+        if key in ("escape", "ctrl-c"):
+            self.close()
+        elif key == "enter":
+            value = clean_name(self.text)
+            if not value:
+                self.error = "Type a name first"
+                return
+            self.close()
+            self.on_submit(value)
+        elif key == "backspace":
+            self.text = self.text[:-1]
+        elif len(self.text) < NAME_LIMIT and (
+            key == "space" or (len(key) == 1 and key.isprintable())
+        ):
+            self.text += " " if key == "space" else key
+            self.error = ""
+
+    def draw(self, canvas: Canvas) -> None:
+        s = canvas.style
+        width = min(canvas.width - 4, NAME_LIMIT + 8)
+        x, y = (canvas.width - width) // 2, canvas.height // 2 - 3
+        canvas.box(x, y, width, 6, self.title)
+        canvas.text(x + 2, y + 2, self.text[-(width - 6) :] + "_", s.selected, width - 4)
+        canvas.text(x + 2, y + 3, self.error, s.accent, width - 4)
+        canvas.text(x + 2, y + 4, "Enter save   Esc cancel", s.dim, width - 4)
+
+
+class Confirm(Screen):
+    """A yes/no question. ``on_yes`` runs only if the user presses y."""
+
+    help = (("y", "yes"), ("n  Esc", "no"))
+
+    def __init__(self, app: App, title: str, lines: list[str], on_yes: Callable[[], None]) -> None:
+        super().__init__(app)
+        self.title = title
+        self.lines = lines
+        self.on_yes = on_yes
+
+    def handle(self, key: str) -> None:
+        if key in ("y", "Y"):
+            self.close()
+            self.on_yes()
+        elif key in ("n", "N", "escape", "ctrl-c", "enter"):
+            self.close()
+
+    def draw(self, canvas: Canvas) -> None:
+        s = canvas.style
+        width = min(canvas.width - 4, max(36, *(len(line) + 6 for line in self.lines)))
+        height = len(self.lines) + 5
+        x, y = (canvas.width - width) // 2, (canvas.height - height) // 2
+        canvas.box(x, y, width, height, self.title)
+        for i, line in enumerate(self.lines):
+            canvas.text(x + 3, y + 2 + i, line, s.text, width - 6)
+        canvas.text(x + 3, y + height - 2, "y yes   n no", s.accent, width - 6)
+
+
+def ask_look_name(app: App) -> None:
+    """Prompt for a name and save the current effect, theme and filters as a look."""
+
+    def save(name: str) -> None:
+        replaced = app.looks.put(app.current_look(name))
+        looks = app.keymap.label("looks", app.ascii_only)
+        app.toast(f"Look {'updated' if replaced else 'saved'}: {name} ({looks} to recall it)")
+
+    app.push(Prompt(app, "Save this look as", save))

staticfx/ui/help.py

@@ -0,0 +1,99 @@
+"""Every key, generated from the live key map and each screen's own list.
+
+Because the main-view section is built from the current bindings, the help
+screen is always right, including after the user rebinds keys.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from staticfx.app.keymap import ACTIONS, key_label
+from staticfx.ui.browser import Browser
+from staticfx.ui.pickers import LookPicker
+from staticfx.ui.screen import Screen
+from staticfx.ui.settings import SettingsScreen
+from staticfx.ui.studio import Studio
+from staticfx.ui.widgets import Canvas
+
+if TYPE_CHECKING:
+    from staticfx.app.app import App
+
+WIDTH = 66
+ALWAYS = (
+    ("Esc", "close the current menu (twice in the main view: quit)"),
+    ("Ctrl-C", "close the current menu, or quit"),
+    ("Ctrl-Z", "suspend to the shell (fg comes back)"),
+)
+
+
+def help_lines(app: App) -> list[tuple[str, str, str]]:
+    """``(kind, keys, text)`` rows; kind is "group", "row" or "note"."""
+    lines: list[tuple[str, str, str]] = []
+    group = ""
+    for action, (action_group, description) in ACTIONS.items():
+        if action_group != group:
+            group = action_group
+            lines.append(("group", group, ""))
+        keys = app.keymap.keys_for(action)
+        shown = " ".join(key_label(k, app.ascii_only) for k in keys) or "(unbound)"
+        lines.append(("row", shown, description))
+    lines.append(("group", "Anywhere", ""))
+    lines += [("row", keys, text) for keys, text in ALWAYS]
+    for title, screen in (
+        ("Effect browser", Browser),
+        ("Effect Studio", Studio),
+        ("Looks", LookPicker),
+        ("Settings", SettingsScreen),
+    ):
+        lines.append(("group", title, ""))
+        lines += [("row", keys, text) for keys, text in screen.help]
+    settings = app.keymap.label("settings", app.ascii_only)
+    lines.append(
+        ("note", "", f"Rebind keys in Settings ({settings}). Strobe is unlocked there too.")
+    )
+    return lines
+
+
+class HelpScreen(Screen):
+    def __init__(self, app: App) -> None:
+        super().__init__(app)
+        self.lines = help_lines(app)
+        self.scroll = 0
+        self.rows = 10
+
+    def handle(self, key: str) -> None:
+        moves = {"up": -1, "down": 1, "pageup": -self.rows, "pagedown": self.rows}
+        if key in moves:
+            self.scroll += moves[key]
+        elif key == "home":
+            self.scroll = 0
+        elif key == "end":
+            self.scroll = len(self.lines)
+        else:
+            self.close()
+        self.scroll = max(0, min(self.scroll, len(self.lines) - self.rows))
+
+    def draw(self, canvas: Canvas) -> None:
+        c, s = canvas.chrome, canvas.style
+        w = min(canvas.width - 2, WIDTH)
+        h = min(canvas.height - 2, len(self.lines) + 4)
+        x, y = (canvas.width - w) // 2, (canvas.height - h) // 2
+        canvas.box(x, y, w, h, "Keys")
+        self.rows = h - 4
+        self.scroll = max(0, min(self.scroll, len(self.lines) - self.rows))
+        key_width = 16
+        for line, (kind, keys, text) in enumerate(
+            self.lines[self.scroll : self.scroll + self.rows], y + 1
+        ):
+            if kind == "group":
+                canvas.text(x + 2, line, f"{c.h * 2} {keys} ", s.dim, w - 4)
+            elif kind == "note":
+                canvas.text(x + 2, line, text, s.accent, w - 4)
+            else:
+                canvas.text(x + 3, line, keys, s.selected, key_width)
+                canvas.text(x + 3 + key_width, line, text, s.text, w - 6 - key_width)
+        canvas.scrollbar(x + w - 2, y + 1, self.rows, self.scroll, len(self.lines))
+        canvas.rule(x, y + h - 3, w)
+        more = "  (more below)" if self.scroll + self.rows < len(self.lines) else ""
+        canvas.text(x + 2, y + h - 2, f"↑ ↓ scroll   any other key closes{more}", s.dim, w - 4)

staticfx/ui/pickers.py

@@ -0,0 +1,221 @@
+"""Short lists with live preview: themes and looks."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from staticfx import themes
+from staticfx.core.color import RGB, hsv
+from staticfx.library.looks import BUILTIN_LOOKS, Look
+from staticfx.ui.dialogs import Confirm, ask_look_name
+from staticfx.ui.screen import Screen
+from staticfx.ui.widgets import Canvas, Cursor
+
+if TYPE_CHECKING:
+    from staticfx.app.app import App
+
+
+@dataclass
+class Entry:
+    key: str
+    label: str
+    note: str = ""
+    heading: bool = False  # a section title, skipped by the cursor
+    swatch: tuple[RGB, ...] = ()  # colours shown as a strip on the right
+
+
+class Picker(Screen):
+    """A left-docked list; the highlighted entry is previewed as you move."""
+
+    title = ""
+    footer = "Enter choose   Esc close"
+    width = 46
+
+    def __init__(self, app: App) -> None:
+        super().__init__(app)
+        self.cursor = Cursor()  # over selectable entries
+        self.view = Cursor()  # over every row, for scrolling
+        self.entries: list[Entry] = []
+        self.rows = 10
+
+    def selectable(self) -> list[int]:
+        return [i for i, e in enumerate(self.entries) if not e.heading]
+
+    @property
+    def current(self) -> Entry | None:
+        choices = self.selectable()
+        return self.entries[choices[self.cursor.index]] if choices else None
+
+    def select(self, key: str) -> None:
+        for n, i in enumerate(self.selectable()):
+            if self.entries[i].key == key:
+                self.cursor.index = n
+        self.hover()
+
+    def hover(self) -> None:
+        """Preview the current entry."""
+
+    def choose(self, entry: Entry) -> None:
+        """Apply the entry the user picked."""
+
+    def extra_key(self, key: str) -> None:
+        """Keys beyond navigation, Enter and Esc."""
+
+    def handle(self, key: str) -> None:
+        if key in ("escape", "ctrl-c", "q"):
+            self.close()
+        elif self.cursor.handle(key, len(self.selectable()), self.rows):
+            self.hover()
+        elif key == "enter" and self.current is not None:
+            entry = self.current
+            self.close()
+            self.choose(entry)
+        else:
+            self.extra_key(key)
+
+    def draw(self, canvas: Canvas) -> None:
+        c, s = canvas.chrome, canvas.style
+        w = min(canvas.width - 2, self.width)
+        h = min(canvas.height - 2, len(self.entries) + 5)
+        x, y = 1, 1
+        canvas.box(x, y, w, h, self.title)
+        self.rows = h - 5
+        choices = self.selectable()
+        chosen = choices[self.cursor.index] if choices else -1
+        self.view.index = max(0, chosen)  # scroll over all rows, headings included
+        for row, i in enumerate(self.view.window(self.rows, len(self.entries)), y + 1):
+            entry = self.entries[i]
+            if entry.heading:
+                canvas.text(x + 2, row, entry.label, s.dim, w - 4)
+                continue
+            selected = i == chosen
+            marker = c.cursor if selected else " "
+            right = x + w - 3  # one column in from the scrollbar
+            if entry.swatch:
+                right -= len(entry.swatch)
+                block = "#" if self.app.ascii_only else "█"
+                for offset, colour in enumerate(entry.swatch):
+                    canvas.frame.put(right + offset, row, block, colour)
+                right -= 1
+            note_width = min(len(entry.note), (w - 8) // 2)
+            label_colour = s.selected if selected else s.text
+            canvas.text(
+                x + 2, row, f"{marker} {entry.label}", label_colour, right - x - 3 - note_width
+            )
+            canvas.text(right - note_width, row, entry.note, s.dim, note_width)
+        canvas.scrollbar(x + w - 2, y + 1, self.rows, self.view.first, len(self.entries))
+        canvas.rule(x, y + h - 3, w)
+        canvas.text(x + 2, y + h - 2, self.footer, s.dim, w - 4)
+
+
+SWATCH_WIDTH = 12
+
+
+def swatch(theme_name: str) -> tuple[RGB, ...]:
+    """A strip of colours along the theme's ramp (or around the hue wheel, for animated ones)."""
+    if theme_name in themes.STATIC_THEMES:
+        theme = themes.STATIC_THEMES[theme_name]
+        return tuple(theme.ramp(0.15 + 0.85 * i / (SWATCH_WIDTH - 1)) for i in range(SWATCH_WIDTH))
+    return tuple(hsv(i / SWATCH_WIDTH) for i in range(SWATCH_WIDTH))
+
+
+class ThemePicker(Picker):
+    title = "Themes"
+    help = (("↑ ↓", "preview a theme"), ("Enter", "keep it"), ("Esc", "go back to the old one"))
+
+    def __init__(self, app: App) -> None:
+        super().__init__(app)
+        notes = {"rainbow": "animated", "strobe": "flashing"}
+        self.entries = [
+            Entry(name, themes.LABELS[name], notes.get(name, ""), swatch=swatch(name))
+            for name in app.theme_names()
+        ]
+        self.select(app.player.theme_name)
+
+    def hover(self) -> None:
+        if self.current is not None:
+            self.app.player.preview_theme = self.current.key
+
+    def on_close(self) -> None:
+        self.app.player.preview_theme = None
+
+    def choose(self, entry: Entry) -> None:
+        self.app.set_theme(entry.key)
+        self.app.toast(f"Theme: {entry.label}")
+
+
+class LookPicker(Picker):
+    title = "Looks"
+    footer = "Enter apply   s save current   d delete   Esc close"
+    width = 60
+    help = (
+        ("↑ ↓", "preview a look"),
+        ("Enter", "apply it"),
+        ("s", "save what's playing now as a look"),
+        ("d  Del", "delete one of your looks"),
+    )
+
+    def __init__(self, app: App) -> None:
+        super().__init__(app)
+        self.looks: dict[str, Look] = {}
+        self.rebuild()
+
+    def rebuild(self) -> None:
+        mine = self.app.looks.looks
+        entries = [Entry("", "Your looks", heading=True)]
+        if not mine:
+            entries.append(Entry("", "  none yet: press s to save one", heading=True))
+        for look in mine:
+            entries.append(
+                Entry(
+                    f"mine:{look.name}",
+                    look.name,
+                    self.app.registry[look.effect].label
+                    if look.effect in self.app.registry
+                    else "missing effect",
+                )
+            )
+        entries.append(Entry("", "Built in", heading=True))
+        entries += [Entry(f"builtin:{look.name}", look.name, look.note) for look in BUILTIN_LOOKS]
+        self.entries = entries
+        self.looks = {f"mine:{look.name}": look for look in mine}
+        self.looks.update({f"builtin:{look.name}": look for look in BUILTIN_LOOKS})
+        self.cursor.clamp(len(self.selectable()))
+        self.hover()
+
+    def hover(self) -> None:
+        player = self.app.player
+        look = self.looks.get(self.current.key) if self.current else None
+        if look is None or (look.theme == "strobe" and not self.app.settings.allow_flashing):
+            player.preview(None)
+            player.preview_theme = None
+            return
+        player.preview(look.effect)
+        player.preview_theme = look.theme
+
+    def on_close(self) -> None:
+        self.app.player.preview(None)
+        self.app.player.preview_theme = None
+
+    def choose(self, entry: Entry) -> None:
+        self.app.apply_look(self.looks[entry.key])
+
+    def extra_key(self, key: str) -> None:
+        entry = self.current
+        if key.lower() == "s":
+            self.close()
+            ask_look_name(self.app)
+        elif key in ("d", "D", "delete") and entry is not None:
+            if not entry.key.startswith("mine:"):
+                self.app.toast("Built-in looks can't be deleted")
+                return
+            name = self.looks[entry.key].name
+
+            def confirmed() -> None:
+                self.app.looks.remove(name)
+                self.rebuild()
+
+            self.app.push(
+                Confirm(self.app, "Delete look", [f"Delete the look '{name}'?"], confirmed)
+            )