Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-music

Source of release 0.1.0

0.1.0 / src / inspector.luc

## The Parameters panel: one ParameterPanel showing what was clicked last:
## a patch node's parameters (the engine's ranges and menus), a device's
## name and voices, a track's mix, a lane, a clip, the picked notes, or with
## nothing picked the song (tempo, meter). A knob's drag is one undo step and
## reaches the engine as it moves.
from luce_ui.ui import VStack, Text, Font, ParameterPanel, ParameterSpec, ParameterKind
from interop import Connection
from workspace import Workspace
import workspace as ws
import catalog
import edits
import groups
from song import GraphNode

## A row: what it edits (a role) and, for a node's parameter, its slot.
struct Row:
    var role: str
    var slot: int
    ## The node a parameter row edits (-1: the picked node).
    var node: int = -1

pub class Inspector:
    pub let body: VStack
    let workspace: Workspace
    let title: Text
    let panel: ParameterPanel
    var rows: list[Row]
    var shown: str = ""
    let connections: list[Connection]

    pub func init(self, workspace: Workspace, font: Font) -> unit!:
        self.workspace = workspace
        self.rows = []
        self.connections = []
        self.title = Text("", font = font)
        self.panel = ParameterPanel([], font = font)
        self.body = VStack([self.title, self.panel], spacing = 4.0, padding = 6.0)
        self.connections.append(self.panel.on_begin(func (index: int) -> unit!:
            self.workspace.begin("Change " + self.label_of(index))))
        self.connections.append(self.panel.on_change(self.changed))
        self.connections.append(self.panel.on_commit(func (index: int) -> unit!:
            self.workspace.commit()))

    pub func close(self):
        for connection in self.connections:
            connection.disconnect()

    func label_of(self, index: int) -> str:
        if index >= 0 and index < self.rows.length:
            return self.rows[index].role
        return "value"

    ## What is shown, as a key: rebuild the rows only when it changes.
    func subject(self) -> str:
        let w = self.workspace
        if w.focus == ws.focus_node:
            if let node = w.selected_node():
                return f"node {w.device} {w.groups} {node.id}"
        if w.focus == ws.focus_notes:
            if let found15 = w.edited_clip():
                let (_, lane, clip) = found15
                if w.picked.length > 0 and not lane.curve:
                    return f"notes {clip.id} {w.picked.length} {w.picked[0]}"
        if w.focus == ws.focus_clip or w.focus == ws.focus_notes:
            if let found16 = w.edited_clip():
                let (_, _, clip) = found16
                return f"clip {clip.id}"
        if w.focus == ws.focus_key and w.selected_key() != none:
            return f"key {w.key_row} {w.key}"
        if w.focus == ws.focus_lane:
            if let lane = w.selected_lane():
                return f"lane {lane.id}"
        if let track = w.selected_track():
            return f"track {track.id}"
        return "song"

    ## MIDI sources came or went: rebuild the rows that list them.
    pub func sources_changed(self):
        self.shown = ""

    ## The MIDI inputs as menu items: none, every one, then each source.
    func midi_items(self) -> str!:
        let engine = self.workspace.bridge.engine
        let items = ["None=-1", "All inputs=0"]
        for at in 0..<engine.midi_refresh():
            let name = engine.midi_source_name(at).replace("|", "/").replace("=", "-")
            items.append(f"{name}={engine.midi_source_id(at)}")
        return items.join("|")

    ## Rebuild or refresh the panel for the workspace's selection.
    pub func refresh(self) -> unit!:
        let key = self.subject()
        if key != self.shown:
            self.shown = key
            self.build(key)
        self.fill()

    func build(self, key: str) -> unit!:
        let w = self.workspace
        let specs: list[ParameterSpec] = []
        self.rows = []
        if key.starts_with("node"):
            let node = w.selected_node() else return
            self.title.set_text(node.name + "  ·  " + catalog.kind_name(node.kind))
            if catalog.is_patch(node.kind):
                self.add(specs, "name", -1, ParameterSpec(name = "name", label = "Name", kind = ParameterKind.text, text = node.name))
                let infos = catalog.params(node.kind)
                for slot in 0..<infos.length:
                    self.add_param(specs, node, slot, infos[slot])
                self.add(specs, "info", -1, ParameterSpec(name = "doc", label = " ", kind = ParameterKind.info, text = catalog.doc(node.kind)))
            elif node.kind == catalog.group_kind:
                self.add(specs, "name", -1, ParameterSpec(name = "name", label = "Name", kind = ParameterKind.text, text = node.name))
                self.add(specs, "info", -1, ParameterSpec(name = "doc", label = " ", kind = ParameterKind.info, text = "Double-click to enter; Cmd-Shift-P saves it as a module."))
                if let inner = node.patch:
                    for member in groups.flatten(inner).nodes:
                        let infos = catalog.params(member.kind)
                        if infos.length == 0:
                            continue
                        self.add(specs, "folder", -1, ParameterSpec(name = f"f{member.id}", label = member.name, kind = ParameterKind.folder))
                        for slot in 0..<infos.length:
                            self.add_param(specs, member, slot, infos[slot])
            elif node.kind == catalog.inlet_kind or node.kind == catalog.outlet_kind:
                self.add(specs, "name", -1, ParameterSpec(name = "name", label = "Socket name", kind = ParameterKind.text, text = node.name))
                self.add(specs, "info", -1, ParameterSpec(name = "doc", label = " ", kind = ParameterKind.info, text = catalog.doc(node.kind)))
            elif node.kind == catalog.device_kind:
                self.add(specs, "name", -1, ParameterSpec(name = "name", label = "Name", kind = ParameterKind.text, text = node.name))
                self.add(specs, "voices", -1, ParameterSpec(name = "voices", label = "Voices", kind = ParameterKind.integer, value = 8.0, minimum = 1.0, maximum = 32.0, slider = true))
                self.add(specs, "info", -1, ParameterSpec(name = "doc", label = " ", kind = ParameterKind.info, text = "Double-click the device to open its patch; U goes back."))
            else:
                self.add(specs, "info", -1, ParameterSpec(name = "doc", label = " ", kind = ParameterKind.info, text = catalog.doc(node.kind)))
        elif key.starts_with("notes"):
            self.title.set_text("Notes")
            self.add(specs, "velocity", -1, ParameterSpec(name = "velocity", label = "Velocity", value = 0.8, minimum = 0.0, maximum = 1.0, decimals = 2, slider = true))
            if w.picked.length == 1:
                self.add(specs, "pitch", -1, ParameterSpec(name = "pitch", label = "Pitch", kind = ParameterKind.integer, value = 60.0, minimum = 0.0, maximum = 127.0))
                self.add(specs, "note_start", -1, ParameterSpec(name = "start", label = "Start", value = 0.0, minimum = 0.0, maximum = 4096.0, decimals = 3, suffix = " beats"))
                self.add(specs, "note_length", -1, ParameterSpec(name = "length", label = "Length", value = 1.0, minimum = 0.01, maximum = 4096.0, decimals = 3, suffix = " beats"))
        elif key.starts_with("clip"):
            let found17 = w.edited_clip() else return
            let (_, lane, clip) = found17
            self.title.set_text("Clip")
            self.add(specs, "clip_name", -1, ParameterSpec(name = "name", label = "Name", kind = ParameterKind.text, text = clip.name))
            self.add(specs, "start", -1, ParameterSpec(name = "start", label = "Start", value = 0.0, minimum = 0.0, maximum = 100000.0, decimals = 2, suffix = " beats", step = 1.0))
            self.add(specs, "length", -1, ParameterSpec(name = "length", label = "Length", value = 4.0, minimum = 0.25, maximum = 100000.0, decimals = 2, suffix = " beats", step = 1.0))
            self.add(specs, "loop", -1, ParameterSpec(name = "loop", label = "Loop every", value = 4.0, minimum = 0.25, maximum = 100000.0, decimals = 2, suffix = " beats", step = 1.0))
            if not lane.curve:
                self.add(specs, "clip_pan", -1, ParameterSpec(name = "pan", label = "Pan", value = 0.0, minimum = -1.0, maximum = 1.0, decimals = 2, slider = true))
        elif key.starts_with("lane"):
            let lane = w.selected_lane() else return
            self.title.set_text("Lane")
            self.add(specs, "lane_name", -1, ParameterSpec(name = "name", label = "Name", kind = ParameterKind.text, text = lane.name))
            if lane.curve:
                self.add(specs, "low", -1, ParameterSpec(name = "low", label = "Bottom", value = 0.0, minimum = -100.0, maximum = 100.0, decimals = 2))
                self.add(specs, "high", -1, ParameterSpec(name = "high", label = "Top", value = 1.0, minimum = -100.0, maximum = 100.0, decimals = 2))
        elif key.starts_with("key"):
            self.title.set_text("Scale key  ·  " + ("song" if w.key_row == ws.song_keys else "track"))
            self.add(specs, "key_root", -1, ParameterSpec(name = "root", label = "Root", kind = ParameterKind.menu, items = numbered(catalog.scale_roots(), 0.0), value = 0.0))
            self.add(specs, "key_mode", -1, ParameterSpec(name = "mode", label = "Scale", kind = ParameterKind.menu, items = numbered(catalog.scale_modes(), 0.0), value = 1.0))
            self.add(specs, "key_beat", -1, ParameterSpec(name = "beat", label = "From beat", value = 0.0, minimum = 0.0, maximum = 100000.0, decimals = 2, step = 1.0))
            self.add(specs, "info", -1, ParameterSpec(name = "doc", label = " ", kind = ParameterKind.info, text = "Every track following the song plays its notes in this scale from here to the next key. Delete removes it."))
        elif key.starts_with("track"):
            let track = w.selected_track() else return
            self.title.set_text("Track")
            self.add(specs, "track_name", -1, ParameterSpec(name = "name", label = "Name", kind = ParameterKind.text, text = track.name))
            self.add(specs, "channels", -1, ParameterSpec(name = "channels", label = "Channels", kind = ParameterKind.menu, items = "Mono=1|Stereo=2", value = 2.0))
            self.add(specs, "volume", -1, ParameterSpec(name = "volume", label = "Volume", value = 0.0, minimum = -90.0, maximum = 12.0, soft_minimum = -48.0, soft_maximum = 6.0, decimals = 1, suffix = " dB", slider = true))
            self.add(specs, "pan", -1, ParameterSpec(name = "pan", label = "Pan", value = 0.0, minimum = -1.0, maximum = 1.0, decimals = 2, slider = true))
            self.add(specs, "mute", -1, ParameterSpec(name = "mute", label = "Mute", kind = ParameterKind.toggle))
            self.add(specs, "solo", -1, ParameterSpec(name = "solo", label = "Solo", kind = ParameterKind.toggle))
            self.add(specs, "color", -1, ParameterSpec(name = "color", label = "Color", kind = ParameterKind.menu, items = "Red=0|Amber=1|Green=2|Teal=3|Blue=4|Violet=5|Pink=6|Grey=7", value = 0.0))
            if not track.master:
                self.add(specs, "midi_in", -1, ParameterSpec(name = "midi_in", label = "MIDI in", kind = ParameterKind.menu, items = self.midi_items(), value = 0.0,
                                                             doc = "The MIDI this track plays live and records. With no track armed the selected track hears it."))
                self.add(specs, "midi_channel", -1, ParameterSpec(name = "midi_channel", label = "Channel", kind = ParameterKind.menu,
                                                                  items = "Any=0|1=1|2=2|3=3|4=4|5=5|6=6|7=7|8=8|9=9|10=10|11=11|12=12|13=13|14=14|15=15|16=16", value = 0.0))
                self.add(specs, "armed", -1, ParameterSpec(name = "armed", label = "Armed", kind = ParameterKind.toggle,
                                                           doc = "Armed tracks hear MIDI even when not selected, and Record (R) takes what they play."))
            self.add(specs, "keyed", -1, ParameterSpec(name = "keyed", label = "Scale", kind = ParameterKind.menu, items = "As written=0|Song's keys=1|Its own keys=2", value = 1.0,
                                                       doc = "How its notes take a scale: as written (drums), the song's Scale row, or its own keys on its row (double-click there to add one)."))
        else:
            self.title.set_text("Song")
            self.add(specs, "tempo", -1, ParameterSpec(name = "tempo", label = "Tempo", value = 120.0, minimum = 20.0, maximum = 400.0, soft_minimum = 60.0, soft_maximum = 200.0, decimals = 1, suffix = " bpm", slider = true))
            self.add(specs, "meter", -1, ParameterSpec(name = "meter", label = "Beats a bar", kind = ParameterKind.integer, value = 4.0, minimum = 1.0, maximum = 16.0))
            self.add(specs, "master", -1, ParameterSpec(name = "master", label = "Master", value = 0.0, minimum = -90.0, maximum = 12.0, soft_minimum = -48.0, soft_maximum = 6.0, decimals = 1, suffix = " dB", slider = true))
            self.add(specs, "info", -1, ParameterSpec(name = "doc", label = " ", kind = ParameterKind.info, text = "Double-click the Scale row under the ruler to add a key change; every track following the song plays in it."))
        self.panel.set_specs(specs)

    func add(self, specs: list[ParameterSpec], role: str, slot: int, spec: ParameterSpec, node: int = -1):
        specs.append(spec)
        self.rows.append(Row(role = role, slot = slot, node = node))

    ## A row for parameter `slot` of patch node `node`.
    func add_param(self, specs: list[ParameterSpec], node: GraphNode, slot: int, info: catalog.ParamInfo):
        let key = f"p{node.id}_{slot}"
        if info.items != "":
            self.add(specs, "param", slot, ParameterSpec(name = key, label = info.name, kind = ParameterKind.menu, items = numbered(info.items, info.minimum), value = info.initial, doc = catalog.doc(node.kind)), node = node.id)
        else:
            let whole = info.units == "" and info.name in ["Octave", "Semitones"]
            self.add(specs, "param", slot, ParameterSpec(name = key, label = info.name, kind = ParameterKind.integer if whole else ParameterKind.number,
                                                         value = info.initial, minimum = info.minimum, maximum = info.maximum,
                                                         soft_minimum = info.minimum, soft_maximum = soft_top(info.maximum, info.logarithmic),
                                                         decimals = 0 if whole else decimals_for(info.maximum - info.minimum),
                                                         suffix = " " + info.units if info.units != "" else "", slider = true), node = node.id)

    ## The node row `row` edits.
    func row_node(self, row: Row) -> GraphNode?:
        let w = self.workspace
        if row.node >= 0:
            if let found = w.patch_node(row.node):
                return found
            if let graph = w.shown_graph():
                return graph.find(row.node)
        return w.selected_node()

    ## Put the model's values in the rows (a row the user drags keeps its own).
    func fill(self) -> unit!:
        let w = self.workspace
        for index in 0..<self.rows.length:
            let row = self.rows[index]
            let value = self.current(row) else continue
            if self.panel.value(index) != value:
                self.panel.set_value(index, value)

    func current(self, row: Row) -> float?:
        let w = self.workspace
        let role = row.role
        if role == "param":
            if let node = self.row_node(row):
                if row.slot < node.params.length:
                    return node.params[row.slot]
        elif role == "voices":
            if let node = w.selected_node():
                return float(node.voices)
        elif role == "velocity" or role == "pitch" or role == "note_start" or role == "note_length":
            if let found18 = w.edited_clip():
                let (_, _, clip) = found18
                if w.picked.length > 0 and w.picked[0] < clip.notes.length:
                    let note = clip.notes[w.picked[0]]
                    return note.velocity if role == "velocity" else (float(note.pitch) if role == "pitch" else (note.start if role == "note_start" else note.length))
        elif role == "start" or role == "length" or role == "loop" or role == "clip_pan":
            if let found19 = w.edited_clip():
                let (_, _, clip) = found19
                return clip.start if role == "start" else (clip.length if role == "length" else (clip.loop if role == "loop" else clip.pan))
        elif role == "low" or role == "high":
            if let lane = w.selected_lane():
                return lane.low if role == "low" else lane.high
        elif role == "key_root" or role == "key_mode" or role == "key_beat":
            if let picked = w.selected_key():
                return float(picked.root) if role == "key_root" else (float(picked.mode) if role == "key_mode" else picked.beat)
        elif role == "channels" or role == "volume" or role == "pan" or role == "mute" or role == "solo" or role == "color" or role == "keyed" or role == "midi_in" or role == "midi_channel" or role == "armed":
            if let track = w.selected_track():
                if role == "keyed":
                    return float(track.keyed)
                if role == "midi_in":
                    return float(track.midi_in)
                if role == "midi_channel":
                    return float(track.midi_channel)
                if role == "armed":
                    return 1.0 if track.armed else 0.0
                if role == "channels":
                    return float(track.channels)
                if role == "volume":
                    return track.volume
                if role == "pan":
                    return track.pan
                if role == "mute":
                    return 1.0 if track.mute else 0.0
                if role == "solo":
                    return 1.0 if track.solo else 0.0
                return float(track.color)
        elif role == "tempo":
            return w.song.tempo
        elif role == "meter":
            return float(w.song.beats_per_bar)
        elif role == "master":
            return w.song.master
        return none

    func changed(self, index: int) -> unit!:
        if index < 0 or index >= self.rows.length:
            return
        let w = self.workspace
        let row = self.rows[index]
        let role = row.role
        let value = self.panel.value(index)
        let text = self.panel.text(index)
        if role == "param":
            if let node = self.row_node(row):
                edits.set_param(w, node, row.slot, value)
            return
        if role == "name":
            if let node = w.selected_node():
                node.name = text
        elif role == "voices":
            if let node = w.selected_node():
                node.voices = int(value)
        elif role == "velocity" or role == "pitch" or role == "note_start" or role == "note_length":
            if let found20 = w.edited_clip():
                let (_, _, clip) = found20
                for at in w.picked:
                    if at < clip.notes.length:
                        if role == "velocity":
                            clip.notes[at].velocity = value
                        elif role == "pitch":
                            clip.notes[at].pitch = int(value)
                        elif role == "note_start":
                            clip.notes[at].start = value
                        else:
                            clip.notes[at].length = value
        elif role == "clip_name" or role == "start" or role == "length" or role == "loop" or role == "clip_pan":
            if let found21 = w.edited_clip():
                let (_, _, clip) = found21
                if role == "clip_name":
                    clip.name = text
                elif role == "start":
                    clip.start = value
                elif role == "length":
                    clip.length = value
                elif role == "loop":
                    clip.loop = value
                else:
                    clip.pan = value
        elif role == "lane_name" or role == "low" or role == "high":
            if let lane = w.selected_lane():
                if role == "lane_name":
                    lane.name = text
                    if let track = w.selected_track():
                        if let node = w.song.lane_node(track, lane.id):
                            node.name = text
                elif role == "low":
                    lane.low = value
                else:
                    lane.high = value
        elif role == "track_name":
            if let track = w.selected_track():
                track.name = text
        elif role == "volume" or role == "pan" or role == "mute" or role == "solo":
            if let track = w.selected_track():
                edits.set_mix(w, track, value if role == "volume" else track.volume, value if role == "pan" else track.pan,
                              (value > 0.5) if role == "mute" else track.mute, (value > 0.5) if role == "solo" else track.solo)
                return
        elif role == "channels" or role == "color" or role == "keyed" or role == "midi_in" or role == "midi_channel" or role == "armed":
            if let track = w.selected_track():
                if role == "midi_in":
                    track.midi_in = int(value)
                elif role == "midi_channel":
                    track.midi_channel = int(value)
                elif role == "armed":
                    track.armed = value > 0.5
                elif role == "channels":
                    track.channels = int(value)
                elif role == "keyed":
                    track.keyed = int(value)
                else:
                    track.color = int(value)
        elif role == "key_root" or role == "key_mode" or role == "key_beat":
            if let keys = w.keys_of(w.key_row):
                if w.key >= 0 and w.key < keys.length:
                    if role == "key_root":
                        keys[w.key].root = int(value)
                    elif role == "key_mode":
                        keys[w.key].mode = int(value)
                    else:
                        keys[w.key].beat = value
                        edits.settle_keys(w, w.key_row, value)
        elif role == "tempo":
            w.song.tempo = value
            w.bridge.engine.set_tempo(value)
            w.changed(live = true)
            return
        elif role == "meter":
            w.song.beats_per_bar = int(value)
        elif role == "master":
            w.song.master = value
            w.bridge.engine.set_master(10.0 ** (value / 20.0))
            w.changed(live = true)
            return
        w.changed()

## A menu's items numbered from `first` ("Sine=0|Saw=1"), as the engine
## counts them.
func numbered(items: str, first: float) -> str:
    let parts = items.split("|")
    let made: list[str] = []
    for at in 0..<parts.length:
        made.append(f"{parts[at]}={int(first) + at}")
    return made.join("|")

func decimals_for(span: float) -> int:
    if span >= 1000.0:
        return 0
    if span >= 50.0:
        return 1
    if span >= 5.0:
        return 2
    return 3

## The slider's top for a range: a logarithmic one (a frequency, a time)
## gives the low end room with a shorter slider.
func soft_top(maximum: float, logarithmic: bool) -> float:
    if logarithmic:
        return maximum / 4.0
    return maximum