Add num_keys_bits_7 widget

Author: gridbugs

caw/examples/live_example.rs

@@ -22,7 +22,34 @@ fn main() {
     let keyboard = computer_keyboard("keys").start_note(note::B_1).build_();
     let space_button = keyboard.space_button().shared();
     let key_events = keyboard.key_events().shared();
-    let length = 16;
+    let (drum_bits, drum_space) = num_keys_bits_7_with_space("drums").build();
+    let length = 8;
+    let drum_bits_loop = value_looper(drum_bits, clock.clone(), drum_space)
+        .persist_with_name("drums")
+        .length(length)
+        .build()
+        .shared();
+    let drums = (vec![
+        clock
+            .clone()
+            .and(drum_bits_loop.clone().map(|x| x & (1 << 0) != 0))
+            .trig(drum::kick())
+            .boxed(),
+        clock
+            .clone()
+            .and(drum_bits_loop.clone().map(|x| x & (1 << 1) != 0))
+            .trig(drum::snare())
+            .boxed(),
+        clock
+            .clone()
+            .and(drum_bits_loop.clone().map(|x| x & (1 << 2) != 0))
+            .trig(drum::hat_closed())
+            .boxed(),
+    ]
+    .into_iter()
+    .sum::<Sig<_>>()
+        * knob("drum vol").build())
+    .shared();
     out.set_channel(|channel| {
         let voice = key_events.clone().mono_voice();
         let (note, gate) = key_looper(voice.triggered_note(), clock.clone())
@@ -82,6 +109,7 @@ fn main() {
                     .feedback_ratio(0.5),
             )
             .filter(reverb::default().room_size(0.9).damping(0.1))
+            + drums.clone()
     });
     thread::park();
 }

core/src/sig.rs

@@ -773,7 +773,7 @@ where
     }
 }
 
-pub fn sig_boxed<S>(sig: S) -> SigBoxed<S::Item>
+pub fn sig_boxed<S>(sig: S) -> Sig<SigBoxed<S::Item>>
 where
     S: SigT + Send + Sync + 'static,
 {
@@ -784,11 +784,11 @@ impl<S> Sig<S>
 where
     S: SigT + Send + Sync + 'static,
 {
-    pub fn boxed(self) -> SigBoxed<S::Item> {
-        SigBoxed {
+    pub fn boxed(self) -> Sig<SigBoxed<S::Item>> {
+        Sig(SigBoxed {
             sig: Arc::new(RwLock::new(self)),
             buf: Vec::new(),
-        }
+        })
     }
 }
 
@@ -987,6 +987,13 @@ where
     {
         self.zip(other).map(|(s, o)| s || o)
     }
+
+    pub fn and<O>(self, other: O) -> Sig<impl SigT<Item = bool>>
+    where
+        O: SigT<Item = bool>,
+    {
+        self.zip(other).map(|(s, o)| s && o)
+    }
 }
 
 /// A counting gate, which is a gate which implements a counter each time it transitions to "on".
@@ -1658,7 +1665,7 @@ impl<T: Clone> SigBoxedVarUnshared<T> {
         S: SigT<Item = T> + Sync + Send + 'static,
     {
         SigBoxedVarUnshared {
-            sig_boxed: Arc::new(RwLock::new(sig_boxed(sig))),
+            sig_boxed: Arc::new(RwLock::new(sig_boxed(sig).0)),
             buf: Vec::new(),
         }
     }
@@ -1667,7 +1674,7 @@ impl<T: Clone> SigBoxedVarUnshared<T> {
     where
         S: SigT<Item = T> + Sync + Send + 'static,
     {
-        *self.sig_boxed.write().unwrap() = sig_boxed(sig);
+        *self.sig_boxed.write().unwrap() = sig_boxed(sig).0;
     }
 }
 
@@ -1686,7 +1693,7 @@ where
 {
     pub fn new_const(value: T) -> Self {
         SigBoxedVarUnshared {
-            sig_boxed: Arc::new(RwLock::new(sig_boxed(Const(value)))),
+            sig_boxed: Arc::new(RwLock::new(sig_boxed(Const(value)).0)),
             buf: Vec::new(),
         }
     }

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

@@ -24,7 +24,7 @@ fn new_button(title: String) -> Sig<SigShared<Button>> {
     })
 }
 
-mod button_builder {
+mod builder {
     use super::*;
     use caw_builder_proc_macros::builder;
     use caw_core::{Sig, SigShared};
@@ -45,4 +45,4 @@ mod button_builder {
     }
 }
 
-pub use button_builder::button;
+pub use builder::button;

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

@@ -44,7 +44,7 @@ impl ComputerKeyboard {
     }
 }
 
-mod computer_keyboard_builder {
+mod builder {
     use super::*;
     use caw_builder_proc_macros::builder;
     use caw_core::{Sig, SigShared};
@@ -75,4 +75,4 @@ mod computer_keyboard_builder {
     }
 }
 
-pub use computer_keyboard_builder::computer_keyboard;
+pub use builder::computer_keyboard;

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

@@ -1,14 +1,14 @@
 use crate::{
     midi,
-    widget::{ByTitle, MidiController01Udp, Widget},
+    widget::{ByTitle, MidiController01Udp, MidiControllerBoolUdp, Widget},
 };
-use caw_core::{IsPositive, Sig, SigShared};
+use caw_core::{Sig, SigShared};
 use caw_midi::MidiMessagesT;
 use lazy_static::lazy_static;
 
 pub type KnobWithSpace = (
     Sig<SigShared<MidiController01Udp>>,
-    Sig<SigShared<IsPositive<MidiController01Udp>>>,
+    Sig<SigShared<MidiControllerBoolUdp>>,
 );
 
 lazy_static! {
@@ -45,10 +45,7 @@ fn new_knob_with_space(
         let value = controllers
             .get_with_initial_value_01(controller.into(), initial_value_01)
             .shared();
-        let space = controllers
-            .get_with_initial_value_01(space_controller.into(), 0.0)
-            .is_positive()
-            .shared();
+        let space = controllers.get_bool(space_controller.into()).shared();
         (value, space)
     })
 }

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

@@ -10,6 +10,9 @@ pub use xy::{xy, xy_with_space};
 pub mod computer_keyboard;
 pub use computer_keyboard::computer_keyboard;
 
+pub mod num_keys_bit_7;
+pub use num_keys_bit_7::{num_keys_bits_7, num_keys_bits_7_with_space};
+
 mod midi;
 mod server;
 mod widget;

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

@@ -0,0 +1,87 @@
+use crate::{
+    midi,
+    widget::{ByTitle, MidiControllerBoolUdp, MidiControllerU7Udp, Widget},
+};
+use caw_core::{Sig, SigShared};
+use caw_midi::MidiMessagesT;
+use lazy_static::lazy_static;
+
+pub type NumKeysBits7WithSpace = (
+    Sig<SigShared<MidiControllerU7Udp>>,
+    Sig<SigShared<MidiControllerBoolUdp>>,
+);
+
+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<NumKeysBits7WithSpace> = Default::default();
+}
+
+fn new_num_keys_bits_7_with_space(title: String) -> NumKeysBits7WithSpace {
+    BY_TITLE.get_or_insert(title.as_str(), || {
+        let channel = midi::alloc_channel();
+        let controller = midi::alloc_controller(channel);
+        let space_controller = midi::alloc_controller(channel);
+        let widget = Widget::new(
+            title.clone(),
+            channel,
+            "num-keys-bits7",
+            vec![
+                format!("--controller={}", controller),
+                format!("--space-controller={}", space_controller),
+            ],
+        )
+        .unwrap();
+        let controllers = widget.channel().controllers();
+        let value = controllers.get_u7(controller.into()).shared();
+        let space = controllers.get_bool(space_controller.into()).shared();
+        (value, space)
+    })
+}
+
+fn new_num_keys_bits_7(title: String) -> Sig<SigShared<MidiControllerU7Udp>> {
+    new_num_keys_bits_7_with_space(title).0
+}
+
+mod builder {
+    use super::*;
+    use caw_builder_proc_macros::builder;
+    use caw_core::{Sig, SigShared};
+
+    builder! {
+        #[constructor = "num_keys_bits_7_"]
+        #[constructor_doc = "A 7-bit integer representing the state of the first 7 number keys"]
+        #[generic_setter_type_name = "X"]
+        #[build_fn = "new_num_keys_bits_7"]
+        #[build_ty = "Sig<SigShared<MidiControllerU7Udp>>"]
+        pub struct Props {
+            title: String,
+        }
+    }
+
+    pub fn num_keys_bits_7(title: impl Into<String>) -> Props {
+        num_keys_bits_7_(title.into())
+    }
+
+    builder! {
+        #[constructor = "num_keys_bits_7_with_space_"]
+        #[constructor_doc = "A 7-bit integer representing the state of the first 7 number keys"]
+        #[generic_setter_type_name = "X"]
+        #[build_fn = "new_num_keys_bits_7_with_space"]
+        #[build_ty = "NumKeysBits7WithSpace"]
+        pub struct WithSpaceProps {
+            title: String,
+        }
+    }
+
+    pub fn num_keys_bits_7_with_space(
+        title: impl Into<String>,
+    ) -> WithSpaceProps {
+        num_keys_bits_7_with_space_(title.into())
+    }
+}
+
+pub use builder::{num_keys_bits_7, num_keys_bits_7_with_space};

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

@@ -1,6 +1,6 @@
 use crate::server::{self, MidiChannelUdp};
 use caw_core::Sig;
-use caw_midi::MidiController01;
+use caw_midi::{MidiController01, MidiControllerBool, MidiControllerU7};
 use midly::num::u4;
 use std::{collections::HashMap, process::Command, sync::Mutex};
 
@@ -73,3 +73,5 @@ impl<T: Clone> ByTitle<T> {
 }
 
 pub type MidiController01Udp = MidiController01<MidiChannelUdp>;
+pub type MidiControllerU7Udp = MidiControllerU7<MidiChannelUdp>;
+pub type MidiControllerBoolUdp = MidiControllerBool<MidiChannelUdp>;

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

@@ -7,7 +7,9 @@ use std::time::{Duration, Instant};
 use caw_keyboard::{Note, note};
 use caw_midi::MidiEvent;
 use caw_midi_udp_client::*;
-use caw_widgets::{AxisLabels, Button, ComputerKeyboard, Knob, Xy};
+use caw_widgets::{
+    AxisLabels, Button, ComputerKeyboard, Knob, NumKeysBits7, Xy,
+};
 use clap::{Parser, Subcommand};
 use midly::num::u7;
 
@@ -40,6 +42,12 @@ enum Command {
         #[arg(long, default_value_t = note::B_2)]
         start_note: Note,
     },
+    NumKeysBits7 {
+        #[arg(short, long, default_value_t = 0)]
+        controller: u8,
+        #[arg(long)]
+        space_controller: Option<u8>,
+    },
 }
 
 #[derive(Parser)]
@@ -226,5 +234,54 @@ fn main() {
                 }
             }
         }
+        Command::NumKeysBits7 {
+            controller,
+            space_controller,
+        } => {
+            let mut num_keys_bits_7 =
+                NumKeysBits7::new(cli.title.as_deref()).unwrap();
+            num_keys_bits_7.tick().unwrap();
+            let send = |value| {
+                client
+                    .send(MidiEvent {
+                        channel,
+                        message: MidiMessage::Controller {
+                            controller: controller.into(),
+                            value,
+                        },
+                    })
+                    .unwrap()
+            };
+            let mut prev = num_keys_bits_7.value();
+            let mut prev_space = false;
+            loop {
+                num_keys_bits_7.tick().unwrap();
+                let value = num_keys_bits_7.value();
+                if is_spam() || value != prev {
+                    send(value);
+                    prev = value;
+                }
+                let space = num_keys_bits_7.is_space_pressed();
+                if let Some(space_controller) = space_controller {
+                    if is_spam() || space != prev_space {
+                        client
+                            .send(MidiEvent {
+                                channel,
+                                message: MidiMessage::Controller {
+                                    controller: space_controller.into(),
+                                    value: if space {
+                                        u7::max_value()
+                                    } else {
+                                        0.into()
+                                    },
+                                },
+                            })
+                            .unwrap();
+
+                        prev_space = space;
+                    }
+                }
+            }
+        }
     }
 }