# SPDX-FileCopyrightText: 2026 Brad Barnett
#
# SPDX-License-Identifier: MIT
"""The control panel for an instrument: one file, laid out from the shared controls.
``build(instrument, screen=..., ...)`` puts the panel on a screen for an
instrument from ``audioinstruments.create()``, or for a ``PanelAdapter``
already wrapped. Sixteen encoders with LED rings on the right, sixteen
patch pads in eight banks on the left, a dot-matrix display, and the
FINE, BYPASS, RELOAD and EXIT buttons.
The controls come from ``controls`` (apps/lib/controlkit) and LVGL, imported
here inside a guard: without them this module still loads, and ``build()``
raises ImportError. A host with its own control surface never needs them.
"""
try:
import lvgl as lv
from controlkit import encoder as _encoder
from controlkit import sprites
from controlkit._draw import Lamp as _Led
from controlkit._draw import box as _box
from controlkit._draw import fill as _fill
from controlkit._draw import finish as _finish
from controlkit._draw import label as _label
from controlkit._draw import text_width as _text_width
from controlkit._safe import safe
from controlkit.dotmatrix import DotMatrix
from controlkit.theme import resolve
except ImportError: # the shared controls, or LVGL, are optional: this file still loads
lv = None
def _require():
if lv is None:
raise ImportError("this panel needs LVGL and the shared controls (apps/lib/controlkit)")
MACRO_COUNT = 16
PADS = 16
BANKS = 8
BANK_NAMES = "ABCDEFGH"
DISPLAY_COLUMNS = 16
#: How long the display shows a value after the last turn, in milliseconds.
SHOW_MS = 1500
_TICK_MS = 100
_STATUS_MS = 400
# RELOAD's LED stays lit at least this long, so a quick reload still shows.
_RELOAD_MS = 600
[docs]
class Panel:
"""The built panel, and the few things that update it.
*adapter* is what it edits. *screen* is the object to build on (the
active screen by default) and *group* the input group the encoders join
(the default group). *theme* is a theme name or dict, *title* replaces
the adapter's name on the faceplate, *subtitle* the line under it, and
*on_close*, when given, adds an EXIT button that calls it.
*two_wheels* is for a setup with a second wheel that moves focus between
the controls (see ``display_driver.set_wheel_mapping``): the group stays
in edit mode, so the other wheel always turns the control that has focus.
"""
def __init__(
self,
adapter,
screen=None,
group=None,
theme=None,
title=None,
subtitle=None,
on_close=None,
two_wheels=False,
):
self.adapter = adapter
self.screen = screen if screen is not None else lv.screen_active()
self.group = group if group is not None else lv.group_get_default()
self.theme = resolve(theme)
self.fine = False
self.encoders = []
self.pads = []
self.banks = []
self.bank = 0
self.patch = None
# True while a control is being moved to match the engine, so the
# change it makes isn't published straight back as a fresh edit.
# Without it every echo would start a new gesture and the two sides
# would chase each other.
self._echoing = False
self._defaults = [64] * MACRO_COUNT
self._show_until = 0
self._status_at = 0
self._snapshot_due = False
self._status = None
self._reload_at = None
self._on_close = on_close
self._status_text = None
self._two_wheels = two_wheels
self._timer = None
self._build(title, subtitle)
if two_wheels and self.group is not None:
self.group.set_editing(True)
adapter.on_external_change(self._apply_external)
# ---- sizes ----------------------------------------------------------------
def _s(self, value):
return max(1, int(value * self.scale + 0.5))
# ---- construction -----------------------------------------------------------
def _build(self, title, subtitle):
theme = self.theme
screen = self.screen
screen.update_layout()
width = screen.get_width()
height = screen.get_height()
self.width = width
self.height = height
self.scale = min(width / 800, height / 480)
# Under about 640 x 384 the panel drops what it can't fit: the
# legends above the header buttons, the pad numbers, the name plate.
self.compact = self.scale < 0.8
s = self._s
self.travel = s(200)
root = _box(screen, 0, 0, width, height)
_fill(root, theme["face"])
_finish(root, theme["face"], theme["face_finish"])
root.add_event_cb(safe(self._on_delete), lv.EVENT.DELETE, None)
self.root = root
header_h = s(78)
self._build_header(header_h, title, subtitle)
top = header_h + 2
patches = self.adapter.patches
inset = s(24)
if patches:
left_w = int(width * 0.34)
self._build_patches(inset, top, left_w - inset, height - top)
divider = left_w + s(10)
_fill(_box(root, divider, top + s(14), 1, height - top - s(28)), theme["bevel_dark"])
_fill(
_box(root, divider + 1, top + s(14), 1, height - top - s(28)), theme["bevel_light"]
)
right_x = divider + s(12)
else:
right_x = inset
self._build_encoders(right_x, top, width - inset - right_x, height - top)
# Four screws hold the faceplate on.
buf, size = sprites.screw(max(3, s(5)), theme)
edge = s(7)
for x, y in (
(edge, edge),
(width - edge - size, edge),
(edge, height - edge - size),
(width - edge - size, height - edge - size),
):
screw = lv.image(root)
screw.set_src(buf)
screw.set_pos(x, y)
self._sync_macros()
self._defaults = list(self._macro_values())
if patches:
self._select(min(max(self.adapter.patch_index, 0), len(patches) - 1))
self._refresh_display(force=True)
self.refresh_status()
self._timer = lv.timer_create(safe(self._tick), _TICK_MS, None)
def _build_header(self, h, title, subtitle):
theme = self.theme
s = self._s
width = self.width
header = _box(self.root, 0, 0, width, h)
_fill(header, theme["header"])
_finish(header, theme["header"], theme["header_finish"])
_fill(_box(self.root, 0, h, width, 1), theme["bevel_dark"])
_fill(_box(self.root, 0, h + 1, width, 1), theme["bevel_light"])
self.header = header
# The controls on the right: engine light, then the buttons.
names = ["FINE", "BYPASS", "RELOAD"]
if self._on_close is not None:
names.append("EXIT")
button_w = 64 if self.compact else max(s(62), 66)
gap = 4 if self.compact else s(8)
x = width - s(26) - len(names) * button_w - (len(names) - 1) * gap
right_start = x
self.buttons = {}
for name in names:
self.buttons[name] = self._header_button(header, name, x, button_w, h)
x += button_w + gap
# The display window, just left of the controls.
# Sixteen characters, like a 16 x 2 module, unless the name plate
# would be left too narrow to read: then as few as twelve.
pitch = 2 if self.scale < 0.9 else (3 if self.scale < 1.2 else 4)
columns = DISPLAY_COLUMNS
while True:
matrix_w = columns * 6 * pitch - pitch
bezel_w = matrix_w + 2 * s(8)
bezel_x = right_start - s(22) - bezel_w
if self.compact or columns <= 12 or bezel_x - s(42) >= s(120):
break
columns -= 1
matrix_h = 2 * 8 * pitch + pitch
bezel_h = min(h - s(12), matrix_h + 2 * s(7))
bezel_y = (h - bezel_h) // 2
# The maker's plate on the left: the instrument's name, and under it
# the engine light and a line of small print.
left = s(30)
plate_w = max(s(40), bezel_x - left - s(12))
name = ((title if title is not None else self.adapter.script_name) or "").upper()
if self.compact:
plate_w = 0
big = self.scale >= 0.9 and _text_width(name, lv.font_montserrat_24, 2) <= plate_w
font = lv.font_montserrat_24 if big else lv.font_montserrat_16
brand = _label(header, name, theme["brand"], font, 2 if big else 1)
brand.set_long_mode(lv.label.LONG_MODE.DOTS)
brand.set_size(max(1, plate_w), 28 if big else 19)
brand.set_pos(left, s(15) if big else s(17))
self.title = brand
lens = max(2.0, s(5) * 0.8)
led_y = h // 2 if self.compact else s(55)
self._status_led = _Led(header, left + lens + 1, led_y, lens, theme)
if self.compact:
brand.add_flag(lv.obj.FLAG.HIDDEN)
sub = _label(
header,
(subtitle if subtitle is not None else theme["subtitle"]).upper(),
theme["header_legend_dim"],
None,
2,
)
sub.set_long_mode(lv.label.LONG_MODE.DOTS)
sub.set_size(max(1, plate_w - int(2 * lens) - s(10)), 16)
if self.compact:
sub.add_flag(lv.obj.FLAG.HIDDEN)
sub.set_pos(left + int(2 * lens) + s(10), s(47))
self.subtitle = sub
bezel = _box(header, bezel_x, bezel_y, bezel_w, bezel_h)
_fill(bezel, theme["display_bezel"])
bezel.set_style_radius(s(4), 0)
bezel.set_style_border_width(1, 0)
bezel.set_style_border_color(lv.color_hex(theme["bevel_light"]), 0)
bezel.set_style_border_side(lv.BORDER_SIDE.BOTTOM, 0)
window = _box(bezel, s(4), s(3), bezel_w - 2 * s(4), bezel_h - 2 * s(3) - 1)
_fill(window, theme["display_bg"])
window.set_style_radius(s(2), 0)
self.display = DotMatrix(window, columns, 2, pitch, theme)
self.display.obj.set_pos(
(bezel_w - 2 * s(4) - matrix_w) // 2,
(bezel_h - 2 * s(3) - 1 - self.display.height) // 2,
)
# A sheen across the top of the glass.
glass = _box(window, 0, 0, bezel_w - 2 * s(4), (bezel_h - 2 * s(3)) // 2)
glass.set_style_bg_color(lv.color_hex(0xFFFFFF), 0)
glass.set_style_bg_opa(22, 0)
glass.set_style_bg_grad_color(lv.color_hex(0xFFFFFF), 0)
glass.set_style_bg_grad_dir(lv.GRAD_DIR.VER, 0)
glass.set_style_bg_main_opa(26, 0)
glass.set_style_bg_grad_opa(4, 0)
def _header_button(self, header, name, x, w, h):
theme = self.theme
s = self._s
if self.compact:
# No room for a legend above: print it on the button, with the
# LED in its corner.
button_h = 24
button = _box(header, x, (h - button_h) // 2, w, button_h)
else:
legend = _label(header, name, theme["header_legend"], None, 0)
legend.set_size(w, 16)
legend.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
legend.set_pos(x, s(12))
button = _box(header, x, s(34), w, s(26))
button.add_flag(lv.obj.FLAG.CLICKABLE)
_fill(button, theme["button"], theme["button_bottom"])
button.set_style_radius(s(4), 0)
button.set_style_border_width(1, 0)
button.set_style_border_color(lv.color_hex(theme["pad_edge"]), 0)
button.set_style_shadow_width(s(4), 0)
button.set_style_shadow_offset_y(s(2), 0)
button.set_style_shadow_opa(170, 0)
button.set_style_shadow_color(lv.color_hex(0), 0)
button.set_style_translate_y(1, lv.STATE.PRESSED)
button.set_style_shadow_offset_y(0, lv.STATE.PRESSED)
# EXIT has nothing to show, so it has no LED.
has_led = name != "EXIT"
if self.compact:
text = _label(button, name, theme["button_text"], None, 0)
text.align(lv.ALIGN.CENTER, -3 if has_led else 0, 0)
led = None
if has_led and self.compact:
led = _Led(header, x + w - 5, (h - 24) // 2 + 5, 2.0, theme)
elif has_led:
led = _Led(header, x + w // 2, s(47), max(2.0, s(5) * 0.7), theme)
handler = {
"FINE": self._on_fine,
"BYPASS": self._on_bypass,
"RELOAD": self._on_reload,
"EXIT": self._on_exit,
}[name]
button.add_event_cb(safe(handler), lv.EVENT.CLICKED, None)
return button, led
def _build_patches(self, x, y, w, h):
theme = self.theme
s = self._s
title = _label(self.root, "PATCH", theme["legend"], None, 2)
title.set_pos(x, y + s(10))
self._patch_title = title
rule = _box(self.root, x + s(66), y + s(19), w - s(66), 1)
_fill(rule, theme["rule"])
# The bank buttons, A to H, across the top.
count = len(self.adapter.patches)
bank_y = y + s(36)
bank_h = s(24)
gap = s(5)
bank_w = (w - (BANKS - 1) * gap) // BANKS
for i in range(BANKS):
used = i * PADS < count
button = _box(self.root, x + i * (bank_w + gap), bank_y, bank_w, bank_h)
button.set_style_radius(s(3), 0)
button.set_style_border_width(1, 0)
button.set_style_border_color(lv.color_hex(theme["pad_edge"]), 0)
_fill(button, theme["button"], theme["button_bottom"])
letter = _label(
button, BANK_NAMES[i], theme["button_text"] if used else theme["pad_empty_text"]
)
letter.center()
if used:
button.add_flag(lv.obj.FLAG.CLICKABLE)
button.set_style_translate_y(1, lv.STATE.PRESSED)
button.add_event_cb(
safe(lambda e, bank=i: self._on_bank(bank)), lv.EVENT.CLICKED, None
)
self.banks.append((button, letter, used))
# The sixteen pads: two columns of eight, numbered down each column.
grid_y = bank_y + bank_h + s(12)
grid_h = y + h - s(18) - grid_y
grid = _box(self.root, x, grid_y, w, grid_h)
grid.add_flag(lv.obj.FLAG.CLICKABLE)
grid.add_event_cb(safe(self._on_grid_key), lv.EVENT.KEY, None)
grid.add_event_cb(safe(self._on_grid_focus), lv.EVENT.FOCUSED, None)
grid.add_event_cb(safe(self._on_grid_defocus), lv.EVENT.DEFOCUSED, None)
self.grid = grid
if self.group is not None:
self.group.add_obj(grid)
col_gap = s(10)
row_gap = s(7)
pad_w = (w - col_gap) // 2
pad_h = (grid_h - 7 * row_gap) // 8
for k in range(PADS):
column, row = divmod(k, 8)
pad = _box(grid, column * (pad_w + col_gap), row * (pad_h + row_gap), pad_w, pad_h)
pad.add_flag(lv.obj.FLAG.CLICKABLE)
pad.set_style_radius(s(5), 0)
pad.set_style_border_width(1, 0)
pad.set_style_border_color(lv.color_hex(theme["pad_edge"]), 0)
pad.set_style_shadow_color(lv.color_hex(0), 0)
pad.set_style_shadow_width(s(5), 0)
pad.set_style_shadow_offset_y(s(2), 0)
pad.set_style_shadow_opa(180, 0)
pad.set_style_translate_y(1, lv.STATE.PRESSED)
number = _label(pad, "%d" % (k + 1), theme["legend_dim"], None, 0)
number.set_pos(s(7), (pad_h - 16) // 2)
name = _label(pad, "", theme["pad_text"], None, 0)
name.set_long_mode(lv.label.LONG_MODE.DOTS)
if self.compact:
number.add_flag(lv.obj.FLAG.HIDDEN)
name.set_size(pad_w - 8, 16)
name.set_pos(4, (pad_h - 16) // 2)
name.set_style_text_align(lv.TEXT_ALIGN.CENTER, 0)
else:
name.set_size(pad_w - s(34), 16)
name.set_pos(s(28), (pad_h - 16) // 2)
pad.add_event_cb(safe(lambda e, k=k: self._on_pad(k)), lv.EVENT.CLICKED, None)
pad.add_event_cb(safe(self._on_pad_pressed), lv.EVENT.PRESSED, None)
self.pads.append([pad, number, name, None])
def _build_encoders(self, x, y, w, h):
theme = self.theme
s = self._s
# No legend over the encoders: their own labels say what each one does.
grid_y = y + s(10)
grid_h = h - s(10) - s(14)
cell_w = w // 4
cell_h = grid_h // 4
geom = _encoder.geometry(cell_w, cell_h, self.scale)
labels = list(self.adapter.macro_labels)
count = min(self.adapter.macro_count, MACRO_COUNT)
for i in range(MACRO_COUNT):
row, column = divmod(i, 4)
label = labels[i] if i < len(labels) else ""
enc = _encoder.Encoder(
self,
self.root,
i,
label,
x + column * cell_w,
grid_y + row * cell_h,
cell_w,
cell_h,
geom,
theme,
i < count,
)
if i < count and self.group is not None:
self.group.add_obj(enc.obj)
self.encoders.append(enc)
# ---- the engine's side ---------------------------------------------------------
def _macro_values(self):
values = list(self.adapter.macro_values)
return values + [0] * (MACRO_COUNT - len(values))
def _sync_macros(self):
"""Move every encoder to the adapter's values, publishing nothing."""
self._echoing = True
try:
values = self._macro_values()
for i, enc in enumerate(self.encoders):
enc.set_value(values[i])
finally:
self._echoing = False
def _apply_external(self, kind, index, value):
"""The engine changed something: show it, and publish nothing."""
self._echoing = True
try:
if kind == "macro":
# A macro the panel doesn't draw can still be automated; its
# echo is ignored rather than an index error.
if 0 <= index < len(self.encoders):
self.encoders[index].set_value(value)
elif kind == "patch":
if self.pads and 0 <= value < len(self.adapter.patches):
self._select(value)
# A patch sets every macro. An adapter may echo each one as
# well, but the panel doesn't rely on it: it moves every
# encoder now, and again once the patch has settled.
self._sync_macros()
self._snapshot_due = True
self._refresh_display()
elif kind == "bypass":
self.adapter.bypass = bool(value)
self._refresh_display()
self.refresh_status()
finally:
self._echoing = False
[docs]
def refresh_status(self):
"""Repaint the engine light and the buttons' LEDs from the adapter."""
theme = self.theme
adapter = self.adapter
ready = getattr(adapter, "engine_ready", True)
error = getattr(adapter, "engine_error", 0)
if error:
state = "error"
rgb = theme["status_bad"]
elif not ready:
state = "wait"
rgb = theme["status_wait"]
else:
state = "ok"
rgb = theme["status_ok"]
self._status_led.set(rgb)
self.buttons["BYPASS"][1].set(theme["amber"] if getattr(adapter, "bypass", False) else None)
self.buttons["FINE"][1].set(theme["led_on"] if self.fine else None)
# RELOAD stays lit from the press until the engine is ready again,
# and goes out at once on an error: the status light shows that.
if self._reload_at is not None and (
error or (ready and lv.tick_get() - self._reload_at >= _RELOAD_MS)
):
self._reload_at = None
self.buttons["RELOAD"][1].set(theme["amber"] if self._reload_at is not None else None)
if state != self._status:
# A change in the engine's state is news: it replaces whatever
# the display was showing.
self._status = state
self._show_until = 0
self._refresh_display()
[docs]
def set_status(self, text):
"""Show *text* on the display's second line in place of READY.
For a live readout (a meter, a load figure) that fits the display's
width. An engine error, a restart or BYPASSED still takes its place,
and so does a value being shown while a control moves. None puts
READY back.
"""
self._status_text = text
if not self._show_until:
self.display.set_line(1, self._idle_line())
[docs]
def default_value(self, index):
"""The value a reset returns macro *index* to: what the patch set."""
return self._defaults[index] if index < len(self._defaults) else 64
# ---- the display ------------------------------------------------------------------
def _patch_line(self):
patches = self.adapter.patches
if not patches or self.patch is None:
return (self.adapter.script_name or "").upper()
bank, pad = divmod(self.patch, PADS)
# An asterisk after the number, as on a hardware synth: the sound
# has been edited away from what the patch stored.
mark = "*" if self.edited() else " "
return "%s%02d%s%s" % (BANK_NAMES[bank], pad + 1, mark, patches[self.patch])
[docs]
def edited(self):
"""True when an encoder sits away from the value the patch gave it."""
for i, enc in enumerate(self.encoders):
if enc.enabled and enc.value != self._defaults[i]:
return True
return False
def _idle_line(self):
adapter = self.adapter
error = getattr(adapter, "engine_error", 0)
if error:
return "ENGINE ERROR %d" % error
if not getattr(adapter, "engine_ready", True):
return "ENGINE STARTING"
if getattr(adapter, "bypass", False):
return "BYPASSED"
if self._status_text:
return self._status_text.upper()
if not adapter.macro_count:
return "NO MACROS"
return "READY"
def _refresh_display(self, force=False):
self.display.set_line(0, self._patch_line())
if force or not self._show_until:
self.display.set_line(1, self._idle_line())
def _flash(self, text):
self.display.set_line(1, text)
self._show_until = lv.tick_get() + SHOW_MS
def _tick(self, _timer):
now = lv.tick_get()
if self._show_until and now - self._show_until >= 0:
self._show_until = 0
self.display.set_line(1, self._idle_line())
if self._snapshot_due:
self._snapshot_due = False
self._sync_macros()
self._defaults = self._macro_values()
self.display.set_line(0, self._patch_line())
if now - self._status_at >= _STATUS_MS:
self._status_at = now
self.refresh_status()
# ---- the user's side ---------------------------------------------------------------
def _turned(self, enc, value):
label = (
self.adapter.macro_labels[enc.index]
if enc.index < len(self.adapter.macro_labels)
else ""
)
room = self.display.columns - 4
self._flash(label.upper()[:room] + " " * (room - len(label[:room])) + "%4d" % value)
self.display.set_line(0, self._patch_line())
if self._echoing:
return
self.adapter.set_macro(enc.index, value)
def _focused(self, enc):
self._edit_if_clicked()
def _edit_if_clicked(self):
# A click lands in navigate mode; editing makes the wheel turn the
# control that was clicked rather than move focus away from it.
# Focus that arrives any other way (a wheel or an encoder stepping
# through the controls) leaves the mode alone, so a hardware encoder
# can still leave edit mode with its button.
# With two wheels the group never leaves edit mode at all.
if self.group is None:
return
if self._two_wheels:
self.group.set_editing(True)
return
indev = lv.indev_active()
if indev is not None and indev.get_type() == lv.INDEV_TYPE.POINTER:
self.group.set_editing(True)
def _select(self, index):
"""Light the pad for patch *index*, turning to its bank."""
self.patch = index
self._show_bank(index // PADS)
def _show_bank(self, bank):
theme = self.theme
self.bank = bank
patches = self.adapter.patches
for i, (button, letter, used) in enumerate(self.banks):
if not used:
continue
if i == bank:
_fill(button, theme["pad_tint"], theme["button_bottom"])
letter.set_style_text_color(lv.color_hex(theme["dot_on"]), 0)
else:
_fill(button, theme["button"], theme["button_bottom"])
letter.set_style_text_color(lv.color_hex(theme["button_text"]), 0)
for k, entry in enumerate(self.pads):
pad, number, name, state = entry
index = bank * PADS + k
if index == self.patch:
new = "lit"
elif index < len(patches):
new = "used"
else:
new = "empty"
text = patches[index] if index < len(patches) else ""
if name.get_text() != text:
name.set_text(text)
if new == state:
continue
entry[3] = new
if new == "lit":
_fill(pad, theme["pad_lit"], theme["pad_lit_bottom"])
pad.set_style_shadow_color(lv.color_hex(theme["pad_glow"]), 0)
pad.set_style_shadow_width(self._s(16), 0)
pad.set_style_shadow_spread(self._s(1), 0)
pad.set_style_shadow_offset_y(0, 0)
pad.set_style_shadow_opa(170, 0)
name.set_style_text_color(lv.color_hex(theme["pad_lit_text"]), 0)
number.set_style_text_color(lv.color_hex(theme["pad_lit_text"]), 0)
else:
if new == "used":
_fill(pad, theme["pad"], theme["pad_bottom"])
else:
_fill(pad, theme["pad_bottom"], theme["pad_bottom"])
pad.set_style_shadow_color(lv.color_hex(0), 0)
pad.set_style_shadow_width(self._s(5), 0)
pad.set_style_shadow_spread(0, 0)
pad.set_style_shadow_offset_y(self._s(2), 0)
pad.set_style_shadow_opa(180, 0)
rgb = theme["pad_text"] if new == "used" else theme["pad_empty_text"]
name.set_style_text_color(lv.color_hex(rgb), 0)
number.set_style_text_color(lv.color_hex(theme["legend_dim"]), 0)
if new == "empty":
pad.remove_flag(lv.obj.FLAG.CLICKABLE)
else:
pad.add_flag(lv.obj.FLAG.CLICKABLE)
[docs]
def choose_patch(self, index):
"""Pick patch *index* as if its pad were pressed."""
patches = self.adapter.patches
if not patches:
return
index = min(max(index, 0), len(patches) - 1)
self._select(index)
if not self._echoing:
self.adapter.set_patch(index)
# Some adapters report the new macros, some only change them: move
# every encoder to what the patch set, and make that the reset point.
self._sync_macros()
self._defaults = self._macro_values()
self._refresh_display()
def _on_pad(self, k):
index = self.bank * PADS + k
if index < len(self.adapter.patches):
self.choose_patch(index)
def _on_pad_pressed(self, _event):
if self.group is not None and self.grid is not None:
lv.group_focus_obj(self.grid)
def _on_bank(self, bank):
self._show_bank(bank)
first = bank * PADS + 1
last = min(len(self.adapter.patches), bank * PADS + PADS)
self._flash("BANK %s %03d-%03d" % (BANK_NAMES[bank], first, last))
def _on_grid_key(self, event):
key = event.get_key()
if self.patch is None:
return
if key in (lv.KEY.RIGHT, lv.KEY.UP):
self.choose_patch(self.patch + 1)
elif key in (lv.KEY.LEFT, lv.KEY.DOWN):
self.choose_patch(self.patch - 1)
def _on_grid_focus(self, _event):
self._patch_title.set_style_text_color(lv.color_hex(self.theme["legend_lit"]), 0)
self._edit_if_clicked()
def _on_grid_defocus(self, _event):
self._patch_title.set_style_text_color(lv.color_hex(self.theme["legend"]), 0)
def _on_fine(self, _event):
self.fine = not self.fine
self._flash("FINE ON" if self.fine else "FINE OFF")
self.refresh_status()
def _on_bypass(self, _event):
enabled = not getattr(self.adapter, "bypass", False)
if not self._echoing:
self.adapter.set_bypass(enabled)
self.adapter.bypass = enabled
self.refresh_status()
self._refresh_display(force=True)
def _on_reload(self, _event):
self.adapter.request_reload()
self._reload_at = lv.tick_get()
self._flash("RELOADING")
self.refresh_status()
def _on_exit(self, _event):
if self._on_close is not None:
self._on_close()
def _on_delete(self, _event):
# The panel's objects are going (its own delete(), or its screen's):
# its timer goes with them.
self.root = None
if self._timer is not None:
self._timer.delete()
self._timer = None
[docs]
def delete(self):
"""Take the panel off the screen and stop its timer."""
if self.root is not None:
self.root.delete()
self.root = None
[docs]
def build(instrument, screen=None, group=None, **options):
"""Build the panel for *instrument* (or its adapter) and return it.
*options* are the keywords ``Panel`` takes: ``theme``, ``title``,
``subtitle``, ``on_close``, ``two_wheels``.
"""
_require()
if not hasattr(instrument, "macro_values"):
from audioinstruments.panel import PanelAdapter
instrument = PanelAdapter(instrument)
return Panel(instrument, screen=screen, group=group, **options)