Widgets are less of a mess

Author: gridbugs

caw/examples/live_example.rs

@@ -2,6 +2,7 @@ use caw::prelude::*;
 use std::thread;
 
 fn main() {
+    env_logger::init();
     let volume = sv_default();
     let out: LiveStereoOut = live_stereo_viz_udp(oscilloscope::Config {
         ..Default::default()

midi-udp-widgets-app-lib/Cargo.toml

@@ -18,6 +18,7 @@ caw_keyboard = { version = "0.4", path = "../keyboard" }
 lazy_static = "1.5"
 anyhow = "1.0"
 midly = "0.5"
+log = "0.4"
 
 [dev-dependencies]
 env_logger = "0.11"

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

@@ -0,0 +1,65 @@
+use crate::{
+    midi,
+    server::MidiChannelUdp,
+    widget::{ByTitle, Widget},
+};
+use caw_core::{Buf, Sig, SigShared, SigT};
+use caw_keyboard::Note;
+use caw_midi::{MidiKeyPress, MidiMessagesT};
+use lazy_static::lazy_static;
+
+pub struct Button {
+    sig: Sig<MidiKeyPress<MidiChannelUdp>>,
+}
+
+lazy_static! {
+    static ref BY_TITLE: ByTitle<Button> = Default::default();
+}
+
+impl Button {
+    pub fn new(title: String) -> Sig<SigShared<Self>> {
+        BY_TITLE.get_or_insert(title.as_str(), || {
+            let widget = Widget::new(
+                title.clone(),
+                midi::alloc_channel(),
+                "button",
+                vec![],
+            )
+            .unwrap();
+            // The choice of note here is arbitrary.
+            let sig = Sig(widget.channel().key_press(Note::default()));
+            Self { sig }
+        })
+    }
+}
+
+impl SigT for Button {
+    type Item = bool;
+
+    fn sample(&mut self, ctx: &caw_core::SigCtx) -> impl Buf<Self::Item> {
+        self.sig.sample(ctx)
+    }
+}
+
+mod button_builder {
+    use super::Button;
+    use caw_builder_proc_macros::builder;
+    use caw_core::{Sig, SigShared};
+
+    builder! {
+        #[constructor = "button_"]
+        #[constructor_doc = "A visual button in a new window"]
+        #[generic_setter_type_name = "X"]
+        #[build_fn = "Button::new"]
+        #[build_ty = "Sig<SigShared<Button>>"]
+        pub struct Props {
+            title: String,
+        }
+    }
+
+    pub fn button(title: impl Into<String>) -> Props {
+        button_(title.into())
+    }
+}
+
+pub use button_builder::button;

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

@@ -0,0 +1,68 @@
+use crate::{
+    midi,
+    server::MidiChannelUdp,
+    widget::{ByTitle, Widget},
+};
+use caw_core::{Buf, Sig, SigShared, SigT};
+use caw_keyboard::Note;
+use caw_midi::MidiMessages;
+use lazy_static::lazy_static;
+
+pub struct ComputerKeyboard {
+    sig: Sig<MidiChannelUdp>,
+}
+
+lazy_static! {
+    static ref BY_TITLE: ByTitle<ComputerKeyboard> = Default::default();
+}
+
+impl ComputerKeyboard {
+    pub fn new(title: String, start_note: Note) -> Sig<SigShared<Self>> {
+        BY_TITLE.get_or_insert(title.as_str(), || {
+            let channel = midi::alloc_channel();
+            let widget = Widget::new(
+                title.clone(),
+                channel,
+                "computer-keyboard",
+                vec![format!("--start-note={}", start_note)],
+            )
+            .unwrap();
+            let sig = widget.channel();
+            Self { sig }
+        })
+    }
+}
+
+impl SigT for ComputerKeyboard {
+    type Item = MidiMessages;
+
+    fn sample(&mut self, ctx: &caw_core::SigCtx) -> impl Buf<Self::Item> {
+        self.sig.sample(ctx)
+    }
+}
+
+mod computer_keyboard_builder {
+    use super::ComputerKeyboard;
+    use caw_builder_proc_macros::builder;
+    use caw_core::{Sig, SigShared};
+    use caw_keyboard::Note;
+
+    builder! {
+        #[constructor = "computer_keyboard_"]
+        #[constructor_doc = "Generate midi events with a computer keyboard when this widget is focused"]
+        #[generic_setter_type_name = "X"]
+        #[build_fn = "ComputerKeyboard::new"]
+        #[build_ty = "Sig<SigShared<ComputerKeyboard>>"]
+        pub struct Props {
+            title: String,
+            #[default = Note::B_1]
+            start_note: Note,
+        }
+    }
+
+    pub fn computer_keyboard(title: impl Into<String>) -> Props {
+        computer_keyboard_(title.into())
+    }
+}
+
+pub use computer_keyboard_builder::computer_keyboard;

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

@@ -0,0 +1,85 @@
+use crate::{
+    midi,
+    server::MidiChannelUdp,
+    widget::{ByTitle, Widget},
+};
+use caw_core::{Buf, Sig, SigShared, SigT};
+use caw_midi::{MidiController01, MidiMessagesT};
+use lazy_static::lazy_static;
+
+pub struct Knob {
+    sig: Sig<MidiController01<MidiChannelUdp>>,
+}
+
+lazy_static! {
+    // 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 BY_TITLE: ByTitle<Knob> = Default::default();
+}
+
+impl Knob {
+    pub fn new(
+        title: String,
+        initial_value_01: f32,
+        sensitivity: f32,
+    ) -> Sig<SigShared<Self>> {
+        BY_TITLE.get_or_insert(title.as_str(), || {
+            let channel = midi::alloc_channel();
+            let controller = midi::alloc_controller(channel);
+            let widget = Widget::new(
+                title.clone(),
+                channel,
+                "knob",
+                vec![
+                    format!("--controller={}", controller),
+                    format!("--initial-value={}", initial_value_01),
+                    format!("--sensitivity={}", sensitivity),
+                ],
+            )
+            .unwrap();
+            let sig = widget
+                .channel()
+                .controllers()
+                .get_with_initial_value_01(controller.into(), initial_value_01);
+            Self { sig }
+        })
+    }
+}
+
+impl SigT for Knob {
+    type Item = f32;
+
+    fn sample(&mut self, ctx: &caw_core::SigCtx) -> impl Buf<Self::Item> {
+        self.sig.sample(ctx)
+    }
+}
+
+mod knob_builder {
+    use super::Knob;
+    use caw_builder_proc_macros::builder;
+    use caw_core::{Sig, SigShared};
+
+    builder! {
+        #[constructor = "knob_"]
+        #[constructor_doc = "A visual knob in a new window"]
+        #[generic_setter_type_name = "X"]
+        #[build_fn = "Knob::new"]
+        #[build_ty = "Sig<SigShared<Knob>>"]
+        pub struct Props {
+            title: String,
+            #[default = 0.5]
+            initial_value_01: f32,
+            #[default = 0.2]
+            sensitivity: f32,
+        }
+    }
+
+    pub fn knob(title: impl Into<String>) -> Props {
+        knob_(title.into())
+    }
+}
+
+pub use knob_builder::knob;