flatten workspace into 1 crate

bin/cli_arranger.rs

@@ -0,0 +1,133 @@
+include!("./lib.rs");
+use tek::ArrangerTui;
+pub fn main () -> Usually<()> { ArrangerCli::parse().run() }
+
+/// Launches an interactive MIDI arranger.
+#[derive(Debug, Parser)]
+#[command(version, about, long_about = None)]
+pub struct ArrangerCli {
+    /// Name of JACK client
+    #[arg(short, long)]
+    name: Option<String>,
+
+    /// Whether to include a transport toolbar (default: true)
+    #[arg(short, long, default_value_t = true)]
+    transport: bool,
+
+    /// Number of tracks
+    #[arg(short = 'x', long, default_value_t = 4)]
+    tracks: usize,
+
+    /// Number of scenes
+    #[arg(short, long, default_value_t = 8)]
+    scenes: usize,
+
+    /// MIDI outs to connect each track to.
+    #[arg(short='i', long)]
+    midi_from: Vec<String>,
+
+    /// MIDI ins to connect each track to.
+    #[arg(short='o', long)]
+    midi_to:   Vec<String>,
+}
+
+impl ArrangerCli {
+    /// Run the arranger TUI from CLI arguments.
+    fn run (&self) -> Usually<()> {
+        let mut client_name = String::from("tek_arranger");
+        if let Some(name) = self.name.as_ref() {
+            client_name = name.clone();
+        }
+        Tui::run(JackClient::new(client_name.as_str())?.activate_with(|jack|{
+            let mut app = ArrangerTui::try_from(jack)?;
+            let jack  = jack.read().unwrap();
+            app.color = ItemPalette::random();
+            add_tracks(&jack, &mut app, self)?;
+            add_scenes(&mut app, self.scenes)?;
+            Ok(app)
+        })?)?;
+        Ok(())
+    }
+}
+
+fn add_tracks (jack: &JackClient, app: &mut ArrangerTui, cli: &ArrangerCli) -> Usually<()> {
+    let n = cli.tracks;
+    let track_color_1 = ItemColor::random();
+    let track_color_2 = ItemColor::random();
+    for i in 0..n {
+        let track = app.track_add(None, Some(
+            track_color_1.mix(track_color_2, i as f32 / n as f32).into()
+        ))?;
+        track.width = 8;
+        let name = track.name.read().unwrap();
+        track.player.midi_ins.push(
+            jack.register_port(&format!("{}I", &name), MidiIn::default())?
+        );
+        track.player.midi_outs.push(
+            jack.register_port(&format!("{}O", &name), MidiOut::default())?
+        );
+    }
+    for connection in cli.midi_from.iter() {
+        let mut split = connection.split("=");
+        let number = split.next().unwrap().trim();
+        if let Ok(track) = number.parse::<usize>() {
+            if track < 1 {
+                panic!("Tracks are zero-indexed")
+            }
+            if track > n {
+                panic!("Tried to connect track {track} or {n}. Pass -t {track} to increase number of tracks.")
+            }
+            if let Some(port) = split.next() {
+                if let Some(port) = jack.port_by_name(port).as_ref() {
+                    jack.client().connect_ports(port, &app.tracks[track-1].player.midi_ins[0])?;
+                } else {
+                    panic!("Missing MIDI output: {port}. Use jack_lsp to list all port names.");
+                }
+            } else {
+                panic!("No port specified for track {track}. Format is TRACK_NUMBER=PORT_NAME")
+            }
+        } else {
+            panic!("Failed to parse track number: {number}")
+        }
+    }
+    for connection in cli.midi_to.iter() {
+        let mut split = connection.split("=");
+        let number = split.next().unwrap().trim();
+        if let Ok(track) = number.parse::<usize>() {
+            if track < 1 {
+                panic!("Tracks are zero-indexed")
+            }
+            if track > n {
+                panic!("Tried to connect track {track} or {n}. Pass -t {track} to increase number of tracks.")
+            }
+            if let Some(port) = split.next() {
+                if let Some(port) = jack.port_by_name(port).as_ref() {
+                    jack.client().connect_ports(&app.tracks[track-1].player.midi_outs[0], port)?;
+                } else {
+                    panic!("Missing MIDI input: {port}. Use jack_lsp to list all port names.");
+                }
+            } else {
+                panic!("No port specified for track {track}. Format is TRACK_NUMBER=PORT_NAME")
+            }
+        } else {
+            panic!("Failed to parse track number: {number}")
+        }
+    }
+    Ok(())
+}
+
+fn add_scenes (app: &mut ArrangerTui, n: usize) -> Usually<()> {
+    let scene_color_1 = ItemColor::random();
+    let scene_color_2 = ItemColor::random();
+    for i in 0..n {
+        let _scene = app.scene_add(None, Some(
+            scene_color_1.mix(scene_color_2, i as f32 / n as f32).into()
+        ))?;
+    }
+    Ok(())
+}
+
+#[test] fn verify_arranger_cli () {
+    use clap::CommandFactory;
+    ArrangerCli::command().debug_assert();
+}

bin/cli_groovebox.rs

@@ -0,0 +1,52 @@
+include!("./lib.rs");
+pub fn main () -> Usually<()> { GrooveboxCli::parse().run() }
+#[derive(Debug, Parser)]
+#[command(version, about, long_about = None)]
+pub struct GrooveboxCli {
+    /// Name of JACK client
+    #[arg(short, long)]
+    name:      Option<String>,
+    /// Whether to include a transport toolbar (default: true)
+    #[arg(short, long, default_value_t = true)]
+    transport: bool,
+    /// MIDI outs to connect to MIDI input
+    #[arg(short='i', long)]
+    midi_from: Vec<String>,
+    /// MIDI ins to connect from MIDI output
+    #[arg(short='o', long)]
+    midi_to:   Vec<String>,
+    /// Audio outs to connect to left input
+    #[arg(short='l', long)]
+    l_from:    Vec<String>,
+    /// Audio outs to connect to right input
+    #[arg(short='r', long)]
+    r_from:    Vec<String>,
+    /// Audio ins to connect from left output
+    #[arg(short='L', long)]
+    l_to:      Vec<String>,
+    /// Audio ins to connect from right output
+    #[arg(short='R', long)]
+    r_to:      Vec<String>,
+}
+impl GrooveboxCli {
+    fn run (&self) -> Usually<()> {
+        Tui::run(JackClient::new("tek_groovebox")?.activate_with(|jack|{
+            let app  = tek::GrooveboxTui::try_from(jack)?;
+            jack.read().unwrap().client().connect_ports(&app.player.midi_outs[0], &app.sampler.midi_in)?;
+            jack.connect_midi_from(&app.player.midi_ins[0],    &self.midi_from)?;
+            jack.connect_midi_from(&app.sampler.midi_in,       &self.midi_from)?;
+            jack.connect_midi_to(&app.player.midi_outs[0],     &self.midi_to)?;
+            jack.connect_audio_from(&app.sampler.audio_ins[0], &self.l_from)?;
+            jack.connect_audio_from(&app.sampler.audio_ins[1], &self.r_from)?;
+            jack.connect_audio_to(&app.sampler.audio_outs[0],  &self.l_to)?;
+            jack.connect_audio_to(&app.sampler.audio_outs[1],  &self.r_to)?;
+            Ok(app)
+        })?)?;
+        Ok(())
+    }
+}
+
+#[test] fn verify_groovebox_cli () {
+    use clap::CommandFactory;
+    GrooveboxCli::command().debug_assert();
+}

bin/cli_sampler.rs

@@ -0,0 +1,17 @@
+include!("./lib.rs");
+pub fn main () -> Usually<()> { SamplerCli::parse().run() }
+#[derive(Debug, Parser)] #[command(version, about, long_about = None)] pub struct SamplerCli {
+    /// Name of JACK client
+    #[arg(short, long)] name: Option<String>,
+    /// Path to plugin
+    #[arg(short, long)] path: Option<String>,
+}
+impl SamplerCli {
+    fn run (&self) -> Usually<()> {
+        Tui::run(JackClient::new("tek_sampler")?.activate_with(|x|{
+            let sampler = tek::SamplerTui::try_from(x)?;
+            Ok(sampler)
+        })?)?;
+        Ok(())
+    }
+}

bin/cli_sequencer.rs

@@ -0,0 +1,46 @@
+include!("./lib.rs");
+
+pub fn main () -> Usually<()> {
+    SequencerCli::parse().run()
+}
+
+/// Launches a single interactive MIDI sequencer.
+#[derive(Debug, Parser)]
+#[command(version, about, long_about = None)]
+pub struct SequencerCli {
+    /// Name of JACK client
+    #[arg(short, long)]
+    name:      Option<String>,
+    /// Whether to include a transport toolbar (default: true)
+    #[arg(short, long, default_value_t = true)]
+    transport: bool,
+    /// MIDI outs to connect to (multiple instances accepted)
+    #[arg(short='i', long)]
+    midi_from: Vec<String>,
+    /// MIDI ins to connect to (multiple instances accepted)
+    #[arg(short='o', long)]
+    midi_to:   Vec<String>,
+}
+
+impl SequencerCli {
+    fn run (&self) -> Usually<()> {
+        let name = self.name.as_deref().unwrap_or("tek_sequencer");
+        Tui::run(JackClient::new(name)?.activate_with(|jack|{
+            let mut app  = SequencerTui::try_from(jack)?;
+            let jack     = jack.read().unwrap();
+            let midi_in  = jack.register_port("i", MidiIn::default())?;
+            let midi_out = jack.register_port("o", MidiOut::default())?;
+            connect_from(&jack, &midi_in, &self.midi_from)?;
+            connect_to(&jack, &midi_out, &self.midi_to)?;
+            app.player.midi_ins.push(midi_in);
+            app.player.midi_outs.push(midi_out);
+            Ok(app)
+        })?)?;
+        Ok(())
+    }
+}
+
+#[test] fn verify_sequencer_cli () {
+    use clap::CommandFactory;
+    SequencerCli::command().debug_assert();
+}

bin/cli_transport.rs

@@ -0,0 +1,9 @@
+include!("./lib.rs");
+
+/// Application entrypoint.
+pub fn main () -> Usually<()> {
+    Tui::run(JackClient::new("tek_transport")?.activate_with(|jack|{
+        TransportTui::try_from(jack)
+    })?)?;
+    Ok(())
+}

bin/lib.rs

@@ -0,0 +1,51 @@
+#[allow(unused_imports)] use std::sync::Arc;
+#[allow(unused_imports)] use clap::{self, Parser};
+#[allow(unused_imports)] use tek::{*, jack::*};
+
+#[allow(unused)]
+fn connect_from (jack: &JackClient, input: &Port<MidiIn>, ports: &[String]) -> Usually<()> {
+    for port in ports.iter() {
+        if let Some(port) = jack.port_by_name(port).as_ref() {
+            jack.client().connect_ports(port, input)?;
+        } else {
+            panic!("Missing MIDI output: {port}. Use jack_lsp to list all port names.");
+        }
+    }
+    Ok(())
+}
+
+#[allow(unused)]
+fn connect_to (jack: &JackClient, output: &Port<MidiOut>, ports: &[String]) -> Usually<()> {
+    for port in ports.iter() {
+        if let Some(port) = jack.port_by_name(port).as_ref() {
+            jack.client().connect_ports(output, port)?;
+        } else {
+            panic!("Missing MIDI input: {port}. Use jack_lsp to list all port names.");
+        }
+    }
+    Ok(())
+}
+
+#[allow(unused)]
+fn connect_audio_from (jack: &JackClient, input: &Port<AudioIn>, ports: &[String]) -> Usually<()> {
+    for port in ports.iter() {
+        if let Some(port) = jack.port_by_name(port).as_ref() {
+            jack.client().connect_ports(port, input)?;
+        } else {
+            panic!("Missing MIDI output: {port}. Use jack_lsp to list all port names.");
+        }
+    }
+    Ok(())
+}
+
+#[allow(unused)]
+fn connect_audio_to (jack: &JackClient, output: &Port<AudioOut>, ports: &[String]) -> Usually<()> {
+    for port in ports.iter() {
+        if let Some(port) = jack.port_by_name(port).as_ref() {
+            jack.client().connect_ports(output, port)?;
+        } else {
+            panic!("Missing MIDI input: {port}. Use jack_lsp to list all port names.");
+        }
+    }
+    Ok(())
+}

bin/todo_cli_mixer.rs

@@ -0,0 +1,25 @@
+include!("./lib.rs");
+
+pub fn main () -> Usually<()> {
+    MixerCli::parse().run()
+}
+
+#[derive(Debug, Parser)] #[command(version, about, long_about = None)] pub struct MixerCli {
+    /// Name of JACK client
+    #[arg(short, long)] name: Option<String>,
+    /// Number of tracks
+    #[arg(short, long)] channels: Option<usize>,
+}
+
+impl MixerCli {
+    fn run (&self) -> Usually<()> {
+        Tui::run(JackClient::new("tek_mixer")?.activate_with(|jack|{
+            let mut mixer = Mixer::new(jack, self.name.as_ref().map(|x|x.as_str()).unwrap_or("mixer"))?;
+            for channel in 0..self.channels.unwrap_or(8) {
+                mixer.track_add(&format!("Track {}", channel + 1), 1)?;
+            }
+            Ok(mixer)
+        })?)?;
+        Ok(())
+    }
+}

bin/todo_cli_plugin.rs

@@ -0,0 +1,26 @@
+include!("./lib.rs");
+
+pub fn main () -> Usually<()> {
+    PluginCli::parse().run()
+}
+
+#[derive(Debug, Parser)] #[command(version, about, long_about = None)] pub struct PluginCli {
+    /// Name of JACK client
+    #[arg(short, long)] name: Option<String>,
+    /// Path to plugin
+    #[arg(short, long)] path: Option<String>,
+}
+
+impl PluginCli {
+    fn run (&self) -> Usually<()> {
+        Tui::run(JackClient::new("tek_plugin")?.activate_with(|jack|{
+            let mut plugin = Plugin::new_lv2(
+                jack,
+                self.name.as_ref().map(|x|x.as_str()).unwrap_or("mixer"),
+                self.path.as_ref().expect("pass --path /to/lv2/plugin.so")
+            )?;
+            Ok(plugin)
+        })?)?;
+        Ok(())
+    }
+}

bin/todo_cli_sampler.rs

@@ -0,0 +1,26 @@
+include!("./lib.rs");
+
+pub fn main () -> Usually<()> {
+    SamplerCli::parse().run()
+}
+
+#[derive(Debug, Parser)] #[command(version, about, long_about = None)] pub struct SamplerCli {
+    /// Name of JACK client
+    #[arg(short, long)] name: Option<String>,
+    /// Path to plugin
+    #[arg(short, long)] path: Option<String>,
+}
+
+impl SamplerCli {
+    fn run (&self) -> Usually<()> {
+        Tui::run(JackClient::new("tek_sampler")?.activate_with(|jack|{
+            let mut plugin = Sampler::new(
+                jack,
+                self.name.as_ref().map(|x|x.as_str()).unwrap_or("mixer"),
+                None,
+            )?;
+            Ok(plugin)
+        })?)?;
+        Ok(())
+    }
+}