Button widget detects space

Author: gridbugs

caw/examples/live_example.rs

@@ -25,7 +25,7 @@ fn main() {
     let space_button = keyboard.space_button().shared();
     let key_events = keyboard.key_events().shared();
     let (drum_bits, drum_space) = num_keys_bits_7_with_space("drums").build();
-    let length = 16;
+    let length = 32;
     let drum_bits_loop = value_looper(drum_bits, clock.clone(), drum_space)
         .persist_with_name("drums")
         .length(length)
@@ -54,7 +54,7 @@ fn main() {
     .shared();
     out.set_channel(|channel| {
         let voice = key_events.clone().mono_voice();
-        let (note, gate) = key_looper(voice.triggered_note(), clock.clone())
+        let (note, gate) = key_looper(voice.gated_note(), clock.clone())
             .clearing(space_button.clone())
             .length(length)
             .persist_with_name("keys")
@@ -64,23 +64,40 @@ fn main() {
         let max = semitone_ratio_sig(knob("vib scale").build() * 4.).shared();
         let min = (1.0 / max.clone()).shared();
         let vib = sine(vib_hz).build().signed_to_range(min, max);
-        let lfo =
-            sine(10.0).build().signed_to_01() * knob("lfo").build() * 1000.;
         let cutoff_hz =
             value_looper(cutoff_hz.clone(), clock.clone(), lpf_space.clone())
                 .persist_with_name("low_pass")
                 .length(length)
                 .build();
-        let env = adsr(gate)
-            .key_press_trig(clock.clone())
-            .a(tempo_s.clone() * knob("attack").build() * 4.)
-            //   .r(tempo_s.clone() * knob("release").build() * 4.)
-            .s(knob("sustain").build())
-            .d(tempo_s.clone() * knob("decay").build() * 4.)
-            .build()
-            .exp_01(1.)
+        let env = adsr(
+            (gate & clock.clone())
+                .trig_to_gate(tempo_s.clone() * knob("duration").build()),
+        )
+        .key_press_trig(clock.clone())
+        .a(tempo_s.clone() * knob("attack").build() * 4.)
+        .r(tempo_s.clone() * knob("release").build() * 4.)
+        .s(knob("sustain").build())
+        .d(tempo_s.clone() * knob("decay").build() * 4.)
+        .build()
+        .exp_01(1.)
+        .shared();
+        let (glide_enable, glide_enable_record) =
+            button_with_space("glide enable").build();
+        let note_freq = (note.freq_hz() * vib)
+            .filter_enable(
+                value_looper(glide_enable, clock.clone(), glide_enable_record)
+                    .persist_with_name("glide")
+                    .length(length)
+                    .build(),
+                low_pass::butterworth(10. * knob("glide").build()),
+            )
             .shared();
-        let voice = (saw(note.freq_hz() * vib)
+        let lfo = sine(knob("lfo rate").build() * note_freq.clone())
+            .build()
+            .signed_to_01()
+            * knob("lfo amp").build()
+            * 2_000.;
+        let voice = (saw(note_freq)
             .reset_offset_01(channel.circle_phase_offset_01())
             .build()
             * env.clone())

core/src/sig.rs

@@ -728,7 +728,7 @@ where
         self,
         enable: E,
         filter: F,
-    ) -> impl SigT<Item = S::Item>
+    ) -> Sig<impl SigT<Item = S::Item>>
     where
         E: SigT<Item = bool>,
         F: Filter<ItemIn = S::Item>,

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

@@ -1,35 +1,49 @@
 use crate::{
     midi,
     server::MidiChannelUdp,
-    widget::{ByTitle, Widget},
+    widget::{ByTitle, MidiControllerBoolUdp, Widget},
 };
 use caw_core::{Sig, SigShared, sig_shared};
 use caw_keyboard::Note;
 use caw_midi::{MidiKeyPress, MidiMessagesT};
 use lazy_static::lazy_static;
 
-pub type Button = MidiKeyPress<MidiChannelUdp>;
+pub type ButtonWithSpace = (
+    Sig<SigShared<MidiKeyPress<MidiChannelUdp>>>,
+    Sig<SigShared<MidiControllerBoolUdp>>,
+);
 
 lazy_static! {
-    static ref BY_TITLE: ByTitle<Sig<SigShared<Button>>> = Default::default();
+    static ref BY_TITLE: ByTitle<ButtonWithSpace> = Default::default();
 }
 
-fn new_button(title: String) -> Sig<SigShared<Button>> {
+fn new_button_with_space(title: String) -> ButtonWithSpace {
     let (channel, key) = midi::alloc_key();
+    let (space_channel, space_controller) = midi::alloc_controller();
     let note = Note::from_midi_index(key);
     BY_TITLE.get_or_insert(title.as_str(), || {
         let widget = Widget::new(
             title.clone(),
             channel,
             "button",
-            vec![format!("--note={}", note)],
+            vec![
+                format!("--note={}", note),
+                format!("--space-channel={}", space_channel),
+                format!("--space-controller={}", space_controller),
+            ],
         )
         .unwrap();
-        // The choice of note here is arbitrary.
-        sig_shared(widget.channel().key_press(note))
+        let controllers = widget.channel().controllers();
+        let value = sig_shared(widget.channel().key_press(note));
+        let space = controllers.get_bool(space_controller.into()).shared();
+        (value, space)
     })
 }
 
+fn new_button(title: String) -> Sig<SigShared<MidiKeyPress<MidiChannelUdp>>> {
+    new_button_with_space(title).0
+}
+
 mod builder {
     use super::*;
     use caw_builder_proc_macros::builder;
@@ -40,7 +54,7 @@ mod builder {
         #[constructor_doc = "A visual button in a new window"]
         #[generic_setter_type_name = "X"]
         #[build_fn = "new_button"]
-        #[build_ty = "Sig<SigShared<Button>>"]
+        #[build_ty = "Sig<SigShared<MidiKeyPress<MidiChannelUdp>>>"]
         pub struct Props {
             title: String,
         }
@@ -49,6 +63,21 @@ mod builder {
     pub fn button(title: impl Into<String>) -> Props {
         button_(title.into())
     }
+
+    builder! {
+        #[constructor = "button_with_space_"]
+        #[constructor_doc = "A visual button in a new window"]
+        #[generic_setter_type_name = "X"]
+        #[build_fn = "new_button_with_space"]
+        #[build_ty = "ButtonWithSpace"]
+        pub struct PropsWithSpace {
+            title: String,
+        }
+    }
+
+    pub fn button_with_space(title: impl Into<String>) -> PropsWithSpace {
+        button_with_space_(title.into())
+    }
 }
 
-pub use builder::button;
+pub use builder::{button, button_with_space};

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

@@ -1,5 +1,5 @@
 pub mod button;
-pub use button::button;
+pub use button::{button, button_with_space};
 
 pub mod switch;
 pub use switch::switch;

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

@@ -16,10 +16,18 @@ use midly::num::u7;
 #[derive(Subcommand)]
 enum Command {
     Button {
+        /// Buttons are implemented with midi key presses. The note determines which key will
+        /// represent this button.
         #[arg(long)]
         note: Note,
+        #[arg(long)]
+        space_channel: Option<u8>,
+        #[arg(long)]
+        space_controller: Option<u8>,
     },
     Switch {
+        /// Switches are implemented with midi key presses. The note determines which key will
+        /// represent this switch.
         #[arg(long)]
         note: Note,
     },
@@ -92,9 +100,14 @@ fn main() {
     let spam_end = Instant::now() + SPAM_DURATION;
     let is_spam = || Instant::now() < spam_end;
     match cli.command {
-        Command::Button { note } => {
+        Command::Button {
+            note,
+            space_channel,
+            space_controller,
+        } => {
             let mut button = Button::new(cli.title.as_deref()).unwrap();
             let mut prev_pressed = false;
+            let mut prev_space = false;
             loop {
                 button.tick().unwrap();
                 let pressed = button.pressed();
@@ -108,6 +121,27 @@ fn main() {
                     client.send(MidiEvent { channel, message }).unwrap();
                     prev_pressed = pressed;
                 }
+                let space = button.is_space_pressed();
+                if let Some(space_controller) = space_controller {
+                    if is_spam() || space != prev_space {
+                        client
+                            .send(MidiEvent {
+                                channel: space_channel
+                                    .map(|x| x.into())
+                                    .unwrap_or(channel),
+                                message: MidiMessage::Controller {
+                                    controller: space_controller.into(),
+                                    value: if space {
+                                        u7::max_value()
+                                    } else {
+                                        0.into()
+                                    },
+                                },
+                            })
+                            .unwrap();
+                        prev_space = space;
+                    }
+                }
             }
         }
         Command::Switch { note } => {
@@ -177,7 +211,6 @@ fn main() {
                                 },
                             })
                             .unwrap();
-
                         prev_space = space;
                     }
                 }

widgets/src/button.rs

@@ -1,6 +1,6 @@
 use crate::window::{TitlePosition, Window};
 use anyhow::anyhow;
-use sdl2::{pixels::Color, rect::Rect};
+use sdl2::{keyboard::Scancode, pixels::Color, rect::Rect};
 use std::time::Instant;
 
 const WIDTH_PX: u32 = 128;
@@ -9,6 +9,7 @@ const HEIGHT_PX: u32 = 128;
 pub struct Button {
     window: Window,
     pressed: bool,
+    space_pressed: bool,
 }
 
 impl Button {
@@ -17,6 +18,7 @@ impl Button {
         Ok(Self {
             window,
             pressed: false,
+            space_pressed: false,
         })
     }
 
@@ -34,6 +36,18 @@ impl Button {
                 Event::MouseButtonUp { .. } => {
                     self.pressed = false;
                 }
+                Event::KeyDown {
+                    scancode: Some(Scancode::Space),
+                    ..
+                } => {
+                    self.space_pressed = true;
+                }
+                Event::KeyUp {
+                    scancode: Some(Scancode::Space),
+                    ..
+                } => {
+                    self.space_pressed = false;
+                }
                 _ => (),
             }
         }
@@ -88,4 +102,8 @@ impl Button {
     pub fn pressed(&self) -> bool {
         self.pressed
     }
+
+    pub fn is_space_pressed(&self) -> bool {
+        self.space_pressed
+    }
 }