Various improvements to widgets

Author: gridbugs

Cargo.toml

@@ -11,6 +11,7 @@ members = [
     "core",
     "interactive",
     "keyboard",
+    "live",
     "midi",
     "midi-file",
     "midi-live",

core/src/sig.rs

@@ -1101,6 +1101,7 @@ where
         }
     }
 
+    /// Call a supplied function on the `SigT` implementation inside `self`.
     pub fn with_inner<T, F>(&self, mut f: F) -> T
     where
         F: FnMut(&S) -> T,

live/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "caw_live"
+version = "0.1.0"
+edition = "2024"
+description = "Helpers for live-coding performances with CAW"
+
+[dependencies]
+caw_core = { version = "0.5", path = "../core" }
+caw_player = { version = "0.7", path = "../player" }
+lazy_static = "1.5"

live/src/lib.rs

@@ -0,0 +1,21 @@
+use caw_core::{Sig, SigBoxedVar, Stereo, StereoPair, svf32};
+use caw_player::play_stereo_default;
+use lazy_static::lazy_static;
+use std::sync::Mutex;
+
+lazy_static! {
+    static ref OUT: StereoPair<Sig<SigBoxedVar<f32>>> =
+        Stereo::new_fn(|| svf32(0.0));
+    static ref INITIALIZED: Mutex<bool> = Mutex::new(false);
+}
+
+pub fn live_stereo() -> StereoPair<Sig<SigBoxedVar<f32>>> {
+    let mut initialized = INITIALIZED.lock().unwrap();
+    if *initialized {
+        return OUT.clone();
+    }
+    *initialized = true;
+    let player = play_stereo_default(OUT.clone()).unwrap();
+    std::mem::forget(player);
+    OUT.clone()
+}

midi-udp-widgets-app-lib/examples/midi_udp_widgets_app_lib_knob.rs

@@ -4,7 +4,7 @@ use caw_midi_udp_widgets_app_lib::knob;
 use caw_modules::*;
 
 fn sig() -> Sig<impl SigT<Item = f32>> {
-    oscillator(waveform::Saw, 40.0 + 40.0 * knob().title("freq").build())
+    oscillator(waveform::Saw, 40.0 + 40.0 * knob("freq").build())
         .build()
         .zip(oscillator(waveform::Saw, 40.1).build())
         .map(|(a, b)| (a + b) / 10.0)

midi-udp-widgets-app-lib/src/lib.rs

@@ -3,29 +3,53 @@ use caw_midi::{MidiController01, MidiMessagesT};
 use caw_midi_udp::{MidiLiveUdp, MidiLiveUdpChannel};
 use lazy_static::lazy_static;
 use std::{
+    collections::HashMap,
     net::SocketAddr,
     process::{Child, Command},
+    sync::Mutex,
 };
 
 // For now this library only supports midi channel 0
 const CHANNEL: u8 = 0;
 
 lazy_static! {
+    // A stream of MIDI events received by the UDP/IP server. It owns the UDP/IP server.
     static ref SIG: Sig<SigShared<MidiLiveUdpChannel>> =
         sig_shared(MidiLiveUdp::new_unspecified().unwrap().channel(CHANNEL).0);
+
+    // Used to prevent multiple windows from opening at the same time with the same name. Note that
+    // when using with evcxr this seems to get cleared when a cell is recomputed, but this is still
+    // valuable in the context of stereo signals, where a function is evaluated once for the left
+    // channel and once for the right channel. In such a case, this prevents each knob openned by
+    // that function from being openned twice.
+    static ref KNOBS_BY_TITLE: Mutex<HashMap<String, Sig<SigShared<Knob>>>> =
+        Mutex::new(HashMap::new());
+
+    /// MIDI controller indices are allocated dynamically and this global tracks the value of the
+    /// next controller index to allocate.
+    static ref NEXT_CONTROLLER_INDEX: Mutex<u8> = Mutex::new(0);
 }
 
+/// Returns the IP address of the server that will receive MIDI events.
 fn sig_server_local_socket_address() -> SocketAddr {
     SIG.0.with_inner(|midi_live_udp_channel| {
         midi_live_udp_channel.server.local_socket_address().unwrap()
     })
 }
 
+/// Allocates and returns unique MIDI controller value.
+fn alloc_controller() -> u8 {
+    let mut next_controller_index = NEXT_CONTROLLER_INDEX.lock().unwrap();
+    let controller_index = *next_controller_index;
+    *next_controller_index += 1;
+    controller_index
+}
+
 const PROGRAM_NAME: &str = "caw_midi_udp_widgets_app";
 
 pub struct Knob {
     controller: u8,
-    title: Option<String>,
+    title: String,
     initial_value_01: f32,
     sensitivity: f32,
     process: Option<Child>,
@@ -34,35 +58,44 @@ pub struct Knob {
 
 impl Knob {
     pub fn new(
-        controller: u8,
-        title: Option<String>,
+        title: String,
         initial_value_01: f32,
         sensitivity: f32,
-    ) -> Sig<Self> {
-        let sig = SIG
-            .clone()
-            .controllers()
-            .get_with_initial_value_01(controller, initial_value_01);
-        let mut s = Self {
-            controller,
-            title,
-            initial_value_01,
-            sensitivity,
-            process: None,
-            sig,
-        };
-        let child = s
-            .command()
-            .unwrap()
-            .spawn()
-            .expect("Failed to launch process");
-        s.process = Some(child);
-        Sig(s)
+    ) -> Sig<SigShared<Self>> {
+        let mut knobs_by_title = KNOBS_BY_TITLE.lock().unwrap();
+        if let Some(knob) = knobs_by_title.get(&title) {
+            knob.clone()
+        } else {
+            let controller = alloc_controller();
+            let sig = SIG
+                .clone()
+                .controllers()
+                .get_with_initial_value_01(controller, initial_value_01);
+            let mut s = Self {
+                controller,
+                title: title.clone(),
+                initial_value_01,
+                sensitivity,
+                process: None,
+                sig,
+            };
+            let child = match s.command().spawn() {
+                Ok(child) => child,
+                Err(e) => panic!(
+                    "{} (make sure `{}` is in your PATH",
+                    e, PROGRAM_NAME
+                ),
+            };
+            s.process = Some(child);
+            let s = sig_shared(s);
+            knobs_by_title.insert(title, s.clone());
+            s
+        }
     }
 
-    fn command(&self) -> anyhow::Result<Command> {
+    fn command(&self) -> Command {
         let mut command = Command::new(PROGRAM_NAME);
-        let mut args = vec![
+        let args = vec![
             "knob".to_string(),
             "--server".to_string(),
             sig_server_local_socket_address().to_string(),
@@ -74,12 +107,11 @@ impl Knob {
             format!("{}", self.initial_value_01),
             "--sensitivity".to_string(),
             format!("{}", self.sensitivity),
+            "--title".to_string(),
+            self.title.clone(),
         ];
-        if let Some(title) = self.title.as_ref() {
-            args.extend(["--title".to_string(), title.clone()]);
-        }
         command.args(args);
-        Ok(command)
+        command
     }
 }
 
@@ -94,30 +126,25 @@ impl SigT for Knob {
 mod builder {
     use super::Knob;
     use caw_builder_proc_macros::builder;
-    use caw_core::Sig;
+    use caw_core::{Sig, SigShared};
 
     builder! {
-        #[constructor = "knob"]
+        #[constructor = "knob_"]
         #[constructor_doc = "A visual knob in a new window"]
         #[generic_setter_type_name = "X"]
         #[build_fn = "Knob::new"]
-        #[build_ty = "Sig<Knob>"]
+        #[build_ty = "Sig<SigShared<Knob>>"]
         pub struct Props {
-            #[default = 0]
-            controller: u8,
-            #[default = None]
-            title_opt: Option<String>,
+            title: String,
             #[default = 0.5]
             initial_value_01: f32,
             #[default = 0.2]
             sensitivity: f32,
         }
     }
 
-    impl Props {
-        pub fn title(self, title: impl Into<String>) -> Self {
-            self.title_opt(Some(title.into()))
-        }
+    pub fn knob(title: impl Into<String>) -> Props {
+        knob_(title.into())
     }
 }
 

midi-udp-widgets-app/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "caw_midi_udp_widgets_app"
-version = "0.1.1"
+version = "0.1.2"
 edition = "2024"
 description = "App for launching widgets that communicate with a caw synthesizer by sending midi commands over UDP"
 authors = ["Stephen Sherratt <[email protected]>"]

midi-udp-widgets-app/README.md

@@ -0,0 +1,17 @@
+![CAW Logo](../assets/logo.png)
+
+# caw_midi_udp_widgets_app
+
+[![Version](https://img.shields.io/crates/v/caw_midi_udp_widgets_app.svg)](https://crates.io/crates/caw_midi_udp_widgets_app)
+[![Documentation](https://docs.rs/caw_midi_udp_widgets_app/badge.svg)](https://docs.rs/caw_midi_udp_widgets_app)
+[![test](https://github.com/gridbugs/caw/actions/workflows/test.yml/badge.svg)](https://github.com/gridbugs/caw/actions/workflows/test.yml)
+[![dependency status](https://deps.rs/repo/github/gridbugs/caw/status.svg)](https://deps.rs/repo/github/gridbugs/caw)
+
+App for launching widgets that communicate with a caw synthesizer by sending
+midi commands over UDP. Sometimes it can be useful to pop up a graphical window
+and manually interact with a widget. This app can open windows containing
+widgets that can act as UDP clients, sending MIDI commands to a UDP server,
+such as is contained in the
+[caw_midi_udp](https://crates.io/crates/caw_midi_udp).
+
+Part of the [CAW Synthesizer Framework](..).

midi-udp/Cargo.toml

@@ -2,6 +2,12 @@
 name = "caw_midi_udp"
 version = "0.1.0"
 edition = "2024"
+description = "A caw signal of MIDI events backed by a UDP/IP server which can receive serialized MIDI events"
+authors = ["Stephen Sherratt <[email protected]>"]
+license = "MIT"
+homepage = "https://github.com/gridbugs/caw.git"
+repository = "https://github.com/gridbugs/caw.git"
+documentation = "https://docs.rs/caw_midi_udp"
 
 [dependencies]
 anyhow = "1.0"

midi-udp/README.md

@@ -0,0 +1,12 @@
+![CAW Logo](../assets/logo.png)
+
+# caw_midi_udp
+
+[![Version](https://img.shields.io/crates/v/caw_midi_udp.svg)](https://crates.io/crates/caw_midi_udp)
+[![Documentation](https://docs.rs/caw_midi_udp/badge.svg)](https://docs.rs/caw_midi_udp)
+[![test](https://github.com/gridbugs/caw/actions/workflows/test.yml/badge.svg)](https://github.com/gridbugs/caw/actions/workflows/test.yml)
+[![dependency status](https://deps.rs/repo/github/gridbugs/caw/status.svg)](https://deps.rs/repo/github/gridbugs/caw)
+
+A caw signal of MIDI events backed by a UDP/IP server which can receive serialized MIDI events.
+
+Part of the [CAW Synthesizer Framework](..).