diff --git a/CLAUDE.md b/CLAUDE.md index fb6a940..e040702 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -59,9 +59,11 @@ pi_writer.py → pi_image.py (cloud-init SD card, installs server.py as a system REW's own computer; so Sound Lab is only in the desktop apps (`S.isApp`, the server refuses `/api/rew/` otherwise). Only checked against a fake server built from its OpenAPI spec. Pictures of the handbooks: `static/docimg/..jpg`, one per language, only ever from this app itself. * **DJ Brake** (`static/djbrake.html`, `App.dj_stream`) – the only page without a login, off by default. It may only ever learn - `{on, ready, room, hint}` from `/djbrake/state`: never add device data or controls there. `dj_margin` moves its limit + `{on, ready, room, avg, hint}` from `/djbrake/state`: never add device data or controls there. `dj_margin` moves its limit down on purpose, so the page must never reveal it. On its own on purpose, without `app.js`. Its settings sit in the access section; in the apps it needs remote access, since the app itself only listens on 127.0.0.1. +* **Preset looks** – `Device.looks` keeps `colors`/`linknames` per preset name; `sync_look` swaps them whenever a read of the DSP + shows another name (the DSP has no preset IDs: same name = same look). Preset files carry them as `look`. * **Network search** – `App.scan_network` probes the local /24 networks on TCP 9761 (handshake + device info), skipping DSPs this app is connected to. * **Copy settings / mute all** – `App.copy_settings` (`POST /api/copy`, groups level/filters/eq/dynamics/routing) and @@ -139,8 +141,8 @@ Not verified yet – ask for a log (`python server.py -v`) from real hardware be only; whether the generator is pre or post input gain is unknown (the app therefore only lowers the outputs) * Device lock (`0x2C` byte 5, `0x2D`, `0x2F`, `0x11`) – implemented from the control software's behaviour and tested against the simulator only; no command to remove a lock is known -* DJ Brake distance to the limiter: output meter dB minus threshold dB, assumes both share one reference (only the - light, from the limiter-active bits, is certain) +* DJ Brake distance to the limiter: output meter dB minus threshold dB, corrected by what real limiter hits show (`dj_cal`); + only the light, from the limiter-active bits, is certain * Limiter calculator reference level (assumes limiter 0 dB = 0 dBu at the output; adjustable per device) * Pi Writer: raw write to a real SD card and first boot on a real Pi (only tested with an image file) diff --git a/README.md b/README.md index 6b36405..25f0fc1 100644 --- a/README.md +++ b/README.md @@ -35,9 +35,11 @@ Control both devices at the same time from your phone, tablet or computer – ov * **Sound Lab** (Windows and macOS apps) – together with REW (Room EQ Wizard): take the filters of a measurement or a REW filter file onto a channel, compare before applying, send a channel's curve or filters back to REW. Handbook with real cases here and in SoundField * **DJ Brake** – optional page `/djbrake` for a tablet at the DJ booth: a big red light while a limiter is working and a horizontal - bar with the distance to the limiter. You choose which limiters count (a monitor can be left out) and can make it - warn a few dB before the real limiter. Needs no PIN and shows + bar with the distance to the limiter. You can leave out limiters (a monitor, say) and make it warn a few dB before + the real limiter. The bar shows the average of the last seconds, a mark the recent peaks, and the page learns from real limiter + hits where the limiter sits on the meter. Needs no PIN and shows nothing else +* **Preset looks** – colours and link group names belong to the preset (by its name) and also travel in preset files * **Mixer** – faders, mute and live meters for all inputs and outputs, limiter LED on every output (status read from the DSP) * **Channel** – name, gain, delay, polarity, high/low pass, 8/9-band PEQ with a draggable curve; the curve shows diff --git a/dsp/device.py b/dsp/device.py index 0b6675d..f95971a 100644 --- a/dsp/device.py +++ b/dsp/device.py @@ -22,7 +22,8 @@ class Device: def __init__(self, dev_id: str, name: str, host: str, port: int = P.PORT, model: str = "auto", addr: int = 1, autoconnect: bool = True, on_event=None, transport: str = "tcp", usb: str = "", lock_code: str = "", auto_unlock: bool = False, test_saved: list | None = None, - colors: dict | None = None, maxgain: dict | None = None, linknames: dict | None = None): + colors: dict | None = None, maxgain: dict | None = None, linknames: dict | None = None, + looks: dict | None = None, look_name: str = ""): self.id = dev_id self.name = name self.host = host @@ -39,6 +40,11 @@ class Device: self.demo = False # in-process simulator of the demo mode, never saved self.colors: dict[str, str] = colors or {} # channel colours chosen in the app, e.g. {"in0": "#38bdf8"} self.linknames: dict[str, str] = linknames or {} # names of link groups, e.g. {"out:0,1": "Tops"} + # colours and group names per preset. The DSP has no IDs for presets, only slots and names, and only the name + # is in its memory image, so that is the key. colors/linknames above always are those of look_name. + self.looks: dict[str, dict] = looks or {} + self.look_name = look_name + self.look_dirty = False self.maxgain: dict[str, int] = maxgain or {} # software limit of the gain fader per channel (raw), e.g. {"out0": 260} # audio test: output gains from before the test (restored when it ends) and the test fader level self.test_saved: list[int] | None = test_saved if isinstance(test_saved, list) else None @@ -75,11 +81,13 @@ class Device: "model": self.model_key, "addr": self.addr, "autoconnect": self.autoconnect, "transport": self.transport, "usb": self.usb, "lock_code": self.lock_code, "auto_unlock": self.auto_unlock, "test_saved": self.test_saved, - "colors": self.colors, "maxgain": self.maxgain, "linknames": self.linknames} + "colors": self.colors, "maxgain": self.maxgain, "linknames": self.linknames, + "looks": self.looks, "look_name": self.look_name} def snapshot(self) -> dict: cfg = self.config() cfg["lock_code"] = bool(self.lock_code) # clients only learn whether a code is remembered + del cfg["looks"], cfg["look_name"] cfg["test_level"] = self.test_level return {**cfg, "demo": self.demo, "status": self.status, "error": self.error, "info": self.info, "detected_model": self.model_name or None, @@ -245,6 +253,24 @@ class Device: self.state = state self._emit_state() + def remember_look(self): + """Keeps the current colours and group names with the loaded preset.""" + self.looks[self.look_name] = {"colors": dict(self.colors), "linknames": dict(self.linknames)} + while len(self.looks) > 64: + del self.looks[next(k for k in self.looks if k != self.look_name)] + self.look_dirty = True + + def sync_look(self): + """After reading the DSP: another preset brings its own look. One not seen yet starts with the current one.""" + name = (self.state or {}).get("preset_name", "").strip() + if self.state is None or (name == self.look_name and name in self.looks): + return + look = self.looks.get(name) + if look: + self.colors, self.linknames = dict(look["colors"]), dict(look["linknames"]) + self.look_name = name + self.remember_look() + async def recall_preset(self, index: int): await self._request(P.CMD_PRESET_RECALL, bytes([index + 1]), timeout=2.0) await asyncio.sleep(0.3) @@ -259,6 +285,8 @@ class Device: self.presets[index] = name if self.state: self.state["preset_name"] = name + self.look_name = name.strip() # also when overwriting: what is stored now is what we see now + self.remember_look() self._emit_state() @property @@ -268,7 +296,8 @@ class Device: async def export_preset(self) -> dict: """The DSP's current state, read fresh from the device.""" await self.refresh() - return preset.export_doc(self.model_name, self.info, self.state, self.raw) + return {**preset.export_doc(self.model_name, self.info, self.state, self.raw), + "look": {"colors": self.colors, "linknames": self.linknames}} async def import_preset(self, state: dict) -> list[str]: """Put the DSP into `state` (working state only). Returns the paths that did not take.""" @@ -440,6 +469,7 @@ class Device: if self.model.fir and self.state: # where this model keeps the test signal in its memory is not known state["test"] = self.state.get("test", state["test"]) self.state = state + self.sync_look() async def _read_config(self) -> dict: model = self.model diff --git a/server.py b/server.py index 9fbc46d..d252704 100644 --- a/server.py +++ b/server.py @@ -212,7 +212,10 @@ def rew_send_curve(body: dict): "magnitude": rew_floats(mag), "phase": rew_floats(phase)}) -DJ_HOLD = 0.8 # s the light of /djbrake stays on after a limiter acted, so short hits are seen +DJ_HOLD = 1.5 # s the light of /djbrake stays on after a limiter acted, so it doesn't flicker with the music +DJ_PEAK_HOLD = 1.5 # s the peak marker stays, then it falls ... +DJ_PEAK_FALL = 3.0 # ... this many dB/s: the display follows the music, not every single beat +DJ_AVG_TAU = 3.0 # s time constant of the average level def clean_dj_margin(value) -> int: @@ -271,6 +274,15 @@ def clean_linknames(v) -> dict: return out +def clean_looks(v) -> dict: + """Colours and group names per preset name: {"Party": {"colors": {...}, "linknames": {...}}}.""" + out = {} + for k, look in list(v.items() if isinstance(v, dict) else [])[:64]: + if isinstance(look, dict): + out[str(k)[:14]] = {"colors": clean_colors(look.get("colors")), "linknames": clean_linknames(look.get("linknames"))} + return out + + def clean_maxgain(v) -> dict: """Software gain limits per channel: {"in0": raw 0..399} (400 = +12 dB would be no limit).""" out = {} @@ -316,6 +328,10 @@ class App: self.dj_hint_en = True # that text always in English, else in the language of the browser self.dj_hit = 0.0 # when a limiter was last seen acting self.dj_rooms: dict = {} # device id -> dB left to the nearest watched limiter, False = nothing watched + self.dj_avgs: dict = {} # the same for the average level + self.dj_env: dict = {} # "device:output" -> peak and average of the level + self.dj_cal: dict = {} # "device:output" -> dB the limiter sits below its threshold on the meter, learned from hits + self.dj_cal_saved = 0.0 self.dj_streams = 0 self.logo = "" # desktop app: its own window logs in with a one-time token, other devices need the PIN @@ -368,6 +384,8 @@ class App: self.djbrake = bool(cfg.get("djbrake")) self.dj_ignore = clean_dj_ignore(cfg.get("dj_ignore")) self.dj_margin = clean_dj_margin(cfg.get("dj_margin")) + self.dj_cal = {str(k)[:80]: float(v) for k, v in (cfg.get("dj_cal") if isinstance(cfg.get("dj_cal"), dict) else {}).items() + if type(v) in (int, float)} self.dj_hint = bool(cfg.get("dj_hint", True)) self.dj_hint_en = bool(cfg.get("dj_hint_en", True)) if "logo" in cfg: @@ -386,7 +404,7 @@ class App: return {"format": CONFIG_FORMAT, "version": 1, "exported": time.strftime("%Y-%m-%dT%H:%M:%S"), "devices": [d.config() for d in self.real_devices()], "auth": self.auth, "limiter": self.limiter, "remote": self.remote, "soundfield": self.soundfield, "logo": self.logo, - "dashboard": self.dashboard, "djbrake": self.djbrake, "dj_ignore": self.dj_ignore, "dj_hint": self.dj_hint, "dj_hint_en": self.dj_hint_en, "dj_margin": self.dj_margin} + "dashboard": self.dashboard, "djbrake": self.djbrake, "dj_ignore": self.dj_ignore, "dj_hint": self.dj_hint, "dj_hint_en": self.dj_hint_en, "dj_margin": self.dj_margin, "dj_cal": self.dj_cal} async def restore_config(self, doc: dict, session: str): if not isinstance(doc, dict) or doc.get("format") != CONFIG_FORMAT: @@ -428,8 +446,17 @@ class App: for old in self.undo_files(dev.id)[MAX_UNDO:]: old.unlink(missing_ok=True) diffs = await dev.import_preset(state) + self.take_look(dev, body.get("doc")) return {"ok": not diffs, "differences": diffs[:20], "name": state.get("preset_name", "")} + def take_look(self, dev: Device, doc): + """Colours and group names that came with a preset file (older files have none).""" + look = doc.get("look") if isinstance(doc, dict) else None + if isinstance(look, dict): + dev.colors, dev.linknames = clean_colors(look.get("colors")), clean_linknames(look.get("linknames")) + dev.remember_look() + self.broadcast({"type": "device", "device": dev.id, "data": dev.snapshot()}) + async def undo_import(self, dev: Device) -> dict: files = self.undo_files(dev.id) if not files: @@ -437,6 +464,7 @@ class App: doc = json.loads(files[0].read_text(encoding="utf-8")) state = preset.read_file(dev.model_name, dev.model, dev.state, doc=doc) diffs = await dev.import_preset(state) + self.take_look(dev, doc) files[0].unlink() return {"ok": not diffs, "differences": diffs[:20]} @@ -460,7 +488,8 @@ class App: transport="usb" if usb else "tcp", usb=str(d.get("usb") or ""), lock_code=str(d.get("lock_code") or ""), auto_unlock=bool(d.get("auto_unlock")), test_saved=clean_gains(d.get("test_saved")), colors=clean_colors(d.get("colors")), - maxgain=clean_maxgain(d.get("maxgain")), linknames=clean_linknames(d.get("linknames"))) + maxgain=clean_maxgain(d.get("maxgain")), linknames=clean_linknames(d.get("linknames")), + looks=clean_looks(d.get("looks")), look_name=str(d.get("look_name") or "")[:14]) dev.on_online = self.device_online self.devices[dev_id] = dev if dev.autoconnect: @@ -900,29 +929,56 @@ class App: # ------------------------------------------------------------ events - def dj_note(self, ev: dict): + def dj_track(self, key: str, level: float, limit: bool, threshold: int, now: float) -> tuple: + """One meter reading of a watched output: (dB left by the peak, dB left by the average, warn now).""" + e = self.dj_env.setdefault(key, {"peak": -120.0, "until": 0.0, "pow": 0.0, "t": now}) + dt = min(now - e["t"], 1.0) + e["t"] = now + db = 20 * math.log10(level) if level > 0 else -120.0 + if db >= e["peak"]: + e["peak"], e["until"] = db, now + DJ_PEAK_HOLD + elif now > e["until"]: + e["peak"] = max(db, e["peak"] - DJ_PEAK_FALL * dt) + e["pow"] += (level * level - e["pow"]) * (1 - math.exp(-dt / DJ_AVG_TAU)) + thr = P.threshold_to_db(threshold) + if limit and e["peak"] > -70: # the limiter acts: this is where it really sits on the meter + seen = max(-6.0, min(30.0, thr - e["peak"])) + self.dj_cal[key] = seen if key not in self.dj_cal else self.dj_cal[key] + (seen - self.dj_cal[key]) * (1 - math.exp(-dt)) + top = thr - self.dj_cal.get(key, 0.0) - self.dj_margin + left = 0.0 if limit else max(0.0, top - e["peak"]) if e["peak"] > -70 else None + mean = max(0.0, top - 10 * math.log10(e["pow"])) if e["pow"] > 1e-7 else None + return left, mean, limit or bool(self.dj_margin and db >= top) + + def dj_note(self, ev: dict, now: float | None = None): """Keeps the state of the /djbrake page. A muted output is not watched: nobody hears it.""" dev = self.devices.get(ev["device"]) if not dev or not dev.state: return - room, ignore = False, self.dj_ignore.get(dev.id, ()) + now = time.monotonic() if now is None else now + room, avg, ignore = False, None, self.dj_ignore.get(dev.id, ()) for i, (level, limit) in enumerate(zip(ev["out"], ev["limit"])): - ch = dev.state["outputs"][i] + ch, key = dev.state["outputs"][i], f"{dev.id}:{i}" if i in ignore or ch["mute"]: + self.dj_env.pop(key, None) continue - if limit: - self.dj_hit = time.monotonic() - left = 0.0 if limit else None - if not limit and level > 0: - left = max(0.0, P.threshold_to_db(ch["limit"]["threshold"]) - self.dj_margin - 20 * math.log10(level)) - if self.dj_margin and left == 0: - self.dj_hit = time.monotonic() + left, mean, warn = self.dj_track(key, level, limit, ch["limit"]["threshold"], now) + if warn: + self.dj_hit = now room = left if room is False or room is None else room if left is None else min(room, left) - self.dj_rooms[dev.id] = room + avg = mean if avg is None else avg if mean is None else min(avg, mean) + self.dj_rooms[dev.id], self.dj_avgs[dev.id] = room, avg + if self.dj_cal and now - self.dj_cal_saved > 60: # an SD card is not for writing with every beat + self.dj_cal_saved = now + self.save() def broadcast(self, ev: dict): if ev["type"] == "meters": self.dj_note(ev) + elif ev["type"] == "device": + dev = self.devices.get(ev["device"]) + if dev and dev.look_dirty: + dev.look_dirty = False + self.save() msg = json.dumps(ev, separators=(",", ":")) for q in list(self.clients): if ev["type"] == "meters" and q.qsize() > 50: @@ -950,6 +1006,8 @@ class App: self.djbrake = bool(body["enabled"]) if "ignore" in body: self.dj_ignore = clean_dj_ignore(body["ignore"]) + if body.get("relearn"): + self.dj_cal = {} if "margin" in body: self.dj_margin = clean_dj_margin(body["margin"]) if "hint" in body: @@ -1097,11 +1155,13 @@ class App: return {"ok": True} if action == "colors": # display only, stays in the app (the DSP doesn't know colours) dev.colors = clean_colors(body.get("colors")) + dev.remember_look() self.save() self.broadcast({"type": "device", "device": dev.id, "data": dev.snapshot()}) return {"ok": True, "colors": dev.colors} if action == "linknames": # display only, like the colours dev.linknames = clean_linknames(body.get("linknames")) + dev.remember_look() self.save() self.broadcast({"type": "device", "device": dev.id, "data": dev.snapshot()}) return {"ok": True, "linknames": dev.linknames} @@ -1313,11 +1373,13 @@ class App: try: while self.djbrake: now = time.monotonic() - rooms = [self.dj_rooms.get(d.id, False) for d in self.devices.values() if d.status == "online"] - rooms = [r for r in rooms if r is not False] + online = [d.id for d in self.devices.values() if d.status == "online"] + rooms = [r for r in (self.dj_rooms.get(i, False) for i in online) if r is not False] known = [r for r in rooms if r is not None] + avgs = [r for r in (self.dj_avgs.get(i) for i in online) if r is not None] state = {"on": now - self.dj_hit < DJ_HOLD, "ready": bool(rooms), "room": round(min(known) * 2) / 2 if known else None, + "avg": round(min(avgs)) if avgs else None, "hint": ("en" if self.dj_hint_en else "auto") if self.dj_hint else None} if state != last: writer.write(f"data: {json.dumps(state)}\n\n".encode()) diff --git a/static/app.js b/static/app.js index 9a21449..21f3dd9 100644 --- a/static/app.js +++ b/static/app.js @@ -1678,6 +1678,7 @@ function colorCard(d) { g.length > 1 ? h("span", { class: "lnk" }, svgIcon(ICON.link)) : null); }; return h("div", { class: "card wide colorbox" }, h("h3", {}, t("Channel colours")), + h("p", { class: "info" }, t("Colours and group names belong to the loaded preset (by its name) and come back when you load it.")), h("p", { class: "info" }, t("Shown on the mixer strips and in the channel view. Linked channels share one colour; every colour can only be used once per DSP.")), h("div", { class: "colgrid" }, h("div", {}, h("div", { class: "sub" }, t("Inputs")), chanGroups(d, "in").map(g => row("in", g))), @@ -2401,7 +2402,12 @@ function djMarginOption() { catch (e) { toast(t("Error: ") + trMsg(e.message)); render(); } } }); return h("div", { class: "djlim" }, h("div", { class: "row" }, h("b", { class: "grow" }, t("Warn earlier")), val), input, - h("p", { class: "info" }, t("The page acts as if the limiter came this much earlier, so the DJ stays below the real one. The limiter itself does not change and the page does not show this setting."))); + h("p", { class: "info" }, t("The page acts as if the limiter came this much earlier, so the DJ stays below the real one. The limiter itself does not change and the page does not show this setting.")), + h("p", { class: "info" }, t("With every real limiter hit the page learns where the limiter sits on the meter, so the distance gets more accurate.")), + h("button", { class: "small", onclick: async () => { + try { await api("PUT", "/api/djbrake", { relearn: true }); toast(t("Learned limiter levels forgotten")); } + catch (e) { toast(t("Error: ") + trMsg(e.message)); } + } }, t("Forget learned levels"))); } function djHintOptions() { @@ -2426,11 +2432,12 @@ function djLimiters() { try { S.djIgnore = (await api("PUT", "/api/djbrake", { ignore })).ignore; render(); } catch (e) { toast(t("Error: ") + trMsg(e.message)); } }; - return h("div", { class: "djlim" }, h("b", {}, t("Limiters that count")), + return h("div", { class: "djlim" }, h("b", {}, t("Leave out these limiters")), + h("p", { class: "info" }, t("All others count. Muted outputs never count.")), devs.length ? devs.map(d => h("div", { class: "djdev" }, devs.length > 1 ? h("small", {}, d.name) : null, h("div", { class: "djchs" }, chans(d, "out").map((c, i) => { - const on = !(S.djIgnore[d.id] || []).includes(i); - return h("button", { class: "djch" + (on ? " on" : ""), "aria-pressed": String(on), onclick: () => toggle(d.id, i) }, + const out = (S.djIgnore[d.id] || []).includes(i); + return h("button", { class: "djch" + (out ? " out" : ""), "aria-pressed": String(out), onclick: () => toggle(d.id, i) }, chLabel("out", i), c.name ? h("small", {}, c.name) : null); })))) : h("p", { class: "info" }, t("Connect a DSP to choose."))); } diff --git a/static/dashboard.js b/static/dashboard.js index 898cc2b..34f9422 100644 --- a/static/dashboard.js +++ b/static/dashboard.js @@ -10,6 +10,8 @@ const DASH_DEFAULT = () => [ ].map((m, i) => ({ id: `m${i}`, cfg: {}, ...m })); let dashEdit = false, dashTimer = 0, dashSaveTimer = 0; +// dragging modules around is no good on a touchscreen: there only their settings can be changed +const dashTouch = () => matchMedia("(pointer: coarse)").matches; const dashBrowse = new Map(); // module id -> { kind, idx, band } const dashMods = () => S.dash || (S.dash = DASH_DEFAULT()); @@ -377,15 +379,15 @@ function dashModule(m) { const controls = dashEdit ? (() => { return h("div", { class: "dctl" }, h("button", { class: "small", "aria-label": t("Module settings"), title: t("Module settings"), onclick: () => dashSettings(m) }, "⚙"), - h("button", { class: "small danger", "aria-label": t("Remove"), title: t("Remove"), onclick: () => { + dashTouch() ? null : h("button", { class: "small danger", "aria-label": t("Remove"), title: t("Remove"), onclick: () => { dashMods().splice(dashMods().indexOf(m), 1); dashSave(); render(); } }, "×")); })() : null; - const head = h("h3", { title: dashEdit ? t("Drag to move") : null }, svgIcon(def.icon), h("span", { class: "grow dtitle" }, m.cfg.title || def.title()), + const head = h("h3", { title: dashEdit && !dashTouch() ? t("Drag to move") : null }, svgIcon(def.icon), h("span", { class: "grow dtitle" }, m.cfg.title || def.title()), d && dashDevs().length > 1 ? h("small", { class: "ddev" }, d.name) : null, controls); const el = h("section", { class: `card dmod dt-${m.type}`, style: dashSizeStyle(m.w, dashHeight(m, d)) }, head, h("div", { class: "dbody" }, body)); - if (dashEdit) { + if (dashEdit && !dashTouch()) { head.addEventListener("pointerdown", e => { if (!e.target.closest("button")) dashDrag(e, { mod: m }, head); }); const handle = (axes, cls, arrow, label) => { const g = h("span", { class: "dgrab " + cls, title: label }, arrow); @@ -403,9 +405,9 @@ function viewDash() { const mods = dashMods(); return [ h("div", { class: "dhead" }, h("h2", {}, "Dashboard"), - viewOnly() ? null : h("button", { class: dashEdit ? "on" : "", onclick: () => { dashEdit = !dashEdit; render(); } }, dashEdit ? t("Done") : t("Customise"))), - dashEdit ? dashPalette() : null, - mods.length ? h("div", { class: "dash" + (dashEdit ? " editing" : "") }, mods.map(dashModule)) + viewOnly() ? null : h("button", { class: dashEdit ? "on" : "", onclick: () => { dashEdit = !dashEdit; render(); } }, dashEdit ? t("Done") : dashTouch() ? t("Widget settings") : t("Customise"))), + dashEdit && !dashTouch() ? dashPalette() : null, + mods.length ? h("div", { class: "dash" + (dashEdit && !dashTouch() ? " editing" : "") }, mods.map(dashModule)) : h("div", { class: "dash" + (dashEdit ? " editing" : "") }, h("div", { class: "dmod dblank", style: dashSizeStyle(12, 4) }, t("Nothing here yet – press “Customise” and add modules."))), ]; } diff --git a/static/djbrake.html b/static/djbrake.html index d3bc419..d4e2e96 100644 --- a/static/djbrake.html +++ b/static/djbrake.html @@ -2,12 +2,13 @@ - + DJ Brake