"""QLC+ show model: universes, fixtures, scenes, and the virtual-console root.""" from __future__ import annotations from dataclasses import dataclass, field from pathlib import Path from typing import Any from patternstudio.fixturedefs import FixtureLibrary, ModeInfo from .xmlutil import appearance, attr, text QLC_VERSION = "4.12.7" INVALID_FUNCTION = 4294967295 def midi_note(channel: int, note: int) -> int: """QLC+ input channel for a MIDI note. Channel is 0–15.""" return (int(channel) << 12) | (128 + int(note)) def midi_cc(channel: int, cc: int) -> int: """QLC+ input channel for a MIDI control change. Channel is 0–15.""" return (int(channel) << 12) | int(cc) def blend_maps( into: dict[int, dict[int, int]], prev: dict[int, dict[int, int]], curr: dict[int, dict[int, int]], prog: float, ) -> None: """Write prev→curr into `into`. Channels fade up from 0 when prev lacks them.""" prog = max(0.0, min(1.0, prog)) for fid in set(prev) | set(curr): bucket = into.setdefault(fid, {}) channels = set(prev.get(fid, {})) | set(curr.get(fid, {})) for ch in channels: start = prev.get(fid, {}).get(ch, 0) end = curr.get(fid, {}).get(ch, 0) bucket[ch] = int(round(start + (end - start) * prog)) @dataclass class MidiBinding: universe: int channel: int @dataclass class ArtNetOutput: uid: str ip: str universe: int = 0 line: int = 0 @dataclass class MidiInput: uid: str profile: str channel: int = 0 line: int = 0 @dataclass class Universe: id: int name: str output: ArtNetOutput | None = None midi: MidiInput | None = None @dataclass class Fixture: id: int key: str manufacturer: str model: str mode: str name: str universe: int address: int channels: int mode_info: ModeInfo | None = None x: float | None = None y: float | None = None direction: float | None = None zero: float | None = None kind: str = "" def named(self, name: str) -> list[int]: """Channel indexes for a name. "Red" is Red, or Red 1 … Red N when those exist.""" if self.mode_info is None: raise ValueError(f"{self.key} has no channel map") query = name.strip().lower() exact: list[int] = [] numbered: list[tuple[int, int]] = [] for channel in self.mode_info.channels: label = channel.name.strip() if label.lower() == query: exact.append(channel.index) continue head, sep, tail = label.rpartition(" ") if sep and head.lower() == query and tail.isdigit(): numbered.append((int(tail), channel.index)) if exact: return exact if numbered: numbered.sort() return [index for _, index in numbered] raise KeyError(f"{self.key} has no channel {name!r}") def channel(self, name: str) -> int: return self.named(name)[0] @property def pan_msb(self) -> int | None: return None if self.mode_info is None else self.mode_info.pan_msb @property def pan_lsb(self) -> int | None: return None if self.mode_info is None else self.mode_info.pan_lsb @property def tilt_msb(self) -> int | None: return None if self.mode_info is None else self.mode_info.tilt_msb @property def tilt_lsb(self) -> int | None: return None if self.mode_info is None else self.mode_info.tilt_lsb def preview_channels(self) -> dict[int, int]: if self.mode_info is None: return {} return self.mode_info.preview_channels() @dataclass class FixtureGroup: id: int name: str columns: int fixture_ids: list[int] head: int = 0 @dataclass class Scene: id: int key: str name: str values: dict[int, dict[int, int]] fade_in: int = 0 fade_out: int = 0 duration: int = 0 primary: bool = True type: str = "Scene" def duration_ms(self, _show: Show) -> int: return max(0, self.fade_in) + max(0, self.duration) def apply(self, _show: Show, elapsed_ms: float, into: dict[int, dict[int, int]]) -> None: prog = 1.0 if self.fade_in <= 0 else min(1.0, elapsed_ms / self.fade_in) blend_maps(into, {}, self.values, prog) def render(self) -> str: vals = [] for fid, channels in sorted(self.values.items()): if not channels: continue body = ",".join(f"{ch},{val}" for ch, val in sorted(channels.items())) vals.append(f' {body}') inner = ("\n" + "\n".join(vals)) if vals else "" return ( f' \n' f' ' f"{inner}\n" f" " ) @dataclass class Collection: id: int key: str name: str members: list[int] primary: bool = True type: str = "Collection" def duration_ms(self, show: Show) -> int: return max((show.functions_by_id[mid].duration_ms(show) for mid in self.members), default=0) def apply(self, show: Show, elapsed_ms: float, into: dict[int, dict[int, int]]) -> None: for mid in self.members: show.functions_by_id[mid].apply(show, elapsed_ms, into) def render(self) -> str: steps = "\n".join(f' {mid}' for i, mid in enumerate(self.members)) return ( f' \n' f"{steps}\n" f" " ) @dataclass class RawFunction: id: int key: str name: str xml: str primary: bool = True type: str = "Raw" def duration_ms(self, _show: Show) -> int: return 0 def apply(self, _show: Show, _elapsed_ms: float, _into: dict[int, dict[int, int]]) -> None: return None def render(self) -> str: return self.xml @dataclass class Show: author: str = "Jimmy" version: str = QLC_VERSION root: Path | None = None universes: list[Universe] = field(default_factory=list) fixtures: list[Fixture] = field(default_factory=list) groups: list[FixtureGroup] = field(default_factory=list) functions: list[Any] = field(default_factory=list) playback: list[str] = field(default_factory=list) vc_size: tuple[int, int] | None = None def __post_init__(self) -> None: from .vc import Frame self._fixture_seq = 0 self._function_seq = 0 self._widget_seq = 0 self._group_seq = 0 self.fixtures_by_key: dict[str, Fixture] = {} self.functions_by_key: dict[str, Any] = {} self.functions_by_id: dict[int, Any] = {} project = self.root or Path(__file__).resolve().parents[1] self.library = FixtureLibrary(project) self.vc = Frame(self, "", root=True) # -- allocation ------------------------------------------------------- def alloc_fixture(self) -> int: value = self._fixture_seq self._fixture_seq += 1 return value def alloc_function(self) -> int: value = self._function_seq self._function_seq += 1 return value def alloc_widget(self) -> int: value = self._widget_seq self._widget_seq += 1 return value def _add_function(self, fn: Any) -> Any: if fn.key in self.functions_by_key: raise ValueError(f"duplicate function key {fn.key!r}") self.functions.append(fn) self.functions_by_key[fn.key] = fn self.functions_by_id[fn.id] = fn return fn def fixture_id(self, fx: Fixture | int | str) -> int: if isinstance(fx, Fixture): return fx.id if isinstance(fx, int) and not isinstance(fx, bool): return fx try: return self.fixtures_by_key[str(fx)].id except KeyError as exc: raise KeyError(f"no fixture {fx!r}") from exc # -- patch ------------------------------------------------------------ def universe( self, uid: int, name: str | None = None, *, output: ArtNetOutput | None = None, midi: MidiInput | None = None, ) -> Universe: uni = Universe(int(uid), name or f"Universe {int(uid) + 1}", output, midi) self.universes.append(uni) return uni def patch( self, manufacturer: str, model: str, mode: str, *, address: int, name: str | None = None, universe: int = 0, channels: int | None = None, key: str | None = None, ) -> Fixture: definition = self.library.find(manufacturer, model) mode_info = definition.mode(mode) if definition is not None else None if channels is None: if mode_info is None: raise ValueError( f"no fixture definition for {manufacturer} {model} mode {mode!r}; pass channels=" ) channels = len(mode_info.channels) elif mode_info is not None and channels != len(mode_info.channels): mode_info = None fid = self.alloc_fixture() fx_key = key or f"fixture{fid}" if fx_key in self.fixtures_by_key: raise ValueError(f"duplicate fixture key {fx_key!r}") fixture = Fixture( id=fid, key=fx_key, manufacturer=manufacturer, model=model, mode=mode, name=name or f"{model} #{fid + 1}", universe=int(universe), address=int(address), channels=int(channels), mode_info=mode_info, ) self.fixtures.append(fixture) self.fixtures_by_key[fx_key] = fixture return fixture def group(self, name: str, fixtures: list[Fixture | str | int], *, columns: int | None = None) -> FixtureGroup: ids = [self.fixture_id(fx) for fx in fixtures] group = FixtureGroup( id=self._group_seq, name=name, columns=columns or max(1, len(ids)), fixture_ids=ids, ) self._group_seq += 1 self.groups.append(group) return group def patch_stage(self, path: str | Path | None = None) -> Any: """Patch every fixture in a stage map. Keys are the map ids, such as "#1" and "M1".""" from .stage import patch_stage return patch_stage(self, path) def scene( self, name: str, values: dict[Any, dict[Any, int]], *, key: str | None = None, fade_in: int = 0, fade_out: int = 0, duration: int = 0, primary: bool = True, ) -> Scene: norm = _channel_map(self, values) fn_key = key or _key_for(name, self.functions_by_key) scene = Scene( id=self.alloc_function(), key=fn_key, name=name, values=norm, fade_in=int(fade_in), fade_out=int(fade_out), duration=int(duration), primary=primary, ) return self._add_function(scene) def collection( self, name: str, members: list[Any], *, key: str | None = None, primary: bool = True, ) -> Collection: ids = [] for member in members: if isinstance(member, int) and not isinstance(member, bool): ids.append(member) elif isinstance(member, str): ids.append(self.functions_by_key[member].id) else: ids.append(member.id) fn_key = key or _key_for(name, self.functions_by_key) coll = Collection( id=self.alloc_function(), key=fn_key, name=name, members=ids, primary=primary, ) return self._add_function(coll) def function_xml(self, xml: str, *, key: str | None = None, name: str = "Function") -> RawFunction: fid = self.alloc_function() fn_key = key or f"function{fid}" stamped = _stamp_function_id(xml.strip(), fid) raw = RawFunction(id=fid, key=fn_key, name=name, xml=stamped) return self._add_function(raw) def run(self, *keys: str) -> None: missing = [key for key in keys if key not in self.functions_by_key] if missing: raise KeyError(f"no function {missing[0]!r}") self.playback = list(keys) def efx(self, name: str, fixtures: list[Any], **kwargs: Any) -> Any: from .animate import add_efx return add_efx(self, name, fixtures, **kwargs) def sequence(self, name: str, steps: list[Any], **kwargs: Any) -> Any: from .animate import add_sequence return add_sequence(self, name, steps, **kwargs) def path_sequence(self, name: str, fixtures: list[Any], points: list[Any], **kwargs: Any) -> Any: from .animate import add_path return add_path(self, name, fixtures, points, **kwargs) def chaser(self, name: str, steps: list[Any], **kwargs: Any) -> Any: from .animate import add_chaser return add_chaser(self, name, steps, **kwargs) def colour_chase(self, name: str, fixtures: list[Any], channels: dict[str, int], frames: list[Any], **kwargs: Any) -> Any: from .animate import add_colour_chase return add_colour_chase(self, name, fixtures, channels, frames, **kwargs) # -- output ----------------------------------------------------------- def size(self) -> tuple[int, int]: if self.vc_size is not None: return self.vc_size max_x = max_y = 0 for widget in self.vc.children: max_x = max(max_x, widget.x + widget.w) max_y = max(max_y, widget.y + widget.h) return max_x + 16, max_y + 16 def xml(self) -> str: from .xml import render_show return render_show(self) def write(self, path: Path | str) -> Path: target = Path(path) target.parent.mkdir(parents=True, exist_ok=True) target.write_text(self.xml(), encoding="utf-8") return target def summary(self) -> dict[str, Any]: return { "fixtures": { fx.key: { "id": fx.id, "name": fx.name, "address": fx.address, "channels": fx.channels, "universe": fx.universe, } for fx in self.fixtures }, "functions": { fn.key: {"id": fn.id, "type": fn.type, "name": fn.name} for fn in self.functions }, "widgets": _widgets(self.vc), } def _channel_map(show: Show, values: Any) -> dict[int, dict[int, int]]: pairs = values if isinstance(values, list) else values.items() norm: dict[int, dict[int, int]] = {} for fx, channels in pairs: norm[show.fixture_id(fx)] = {int(ch): int(val) for ch, val in channels.items()} return norm def _widgets(frame: Any) -> list[dict[str, Any]]: found: list[dict[str, Any]] = [] for child in frame.children: found.append({"id": child.id, "type": child.type_name, "caption": child.caption}) if child.type_name in ("Frame", "SoloFrame"): found.extend(_widgets(child)) return found def _key_for(name: str, existing: dict[str, Any]) -> str: base = "".join(ch.lower() if ch.isalnum() else "-" for ch in name).strip("-") or "function" key = base n = 2 while key in existing: key = f"{base}-{n}" n += 1 return key def _stamp_function_id(xml: str, fid: int) -> str: import re if re.search(r"\bID=\"\d+\"", xml): return re.sub(r"\bID=\"\d+\"", f'ID="{fid}"', xml, count=1) return xml.replace(" str: return ( " \n" f" {text(fx.manufacturer)}\n" f" {text(fx.model)}\n" f" {text(fx.mode)}\n" f" {fx.id}\n" f" {text(fx.name)}\n" f" {fx.universe}\n" f"
{fx.address}
\n" f" {fx.channels}\n" "
" ) def group_xml(group: FixtureGroup) -> str: columns = max(1, group.columns) rows = max(1, (len(group.fixture_ids) + columns - 1) // columns) heads = [] for index, fid in enumerate(group.fixture_ids): heads.append( f' {group.head}' ) body = "\n".join(heads) return ( f' \n' f" {text(group.name)}\n" f' \n' f"{body}\n" " " ) def universe_xml(uni: Universe) -> str: if uni.output is None and uni.midi is None: return f' ' parts = [f' '] if uni.output is not None: out = uni.output parts.append( f' \n' f' \n' " " ) if uni.midi is not None: midi = uni.midi parts.append( f' \n' f' \n' " " ) parts.append(" ") return "\n".join(parts) def root_appearance() -> str: return appearance(frame="None", indent=" ")