Update some packages

Author: gridbugs

computer-keyboard/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "caw_computer_keyboard"
-version = "0.2.1"
+version = "0.2.2"
 description = "Use a computer keyboard to control caw synthesizer modules"
 authors = ["Stephen Sherratt <[email protected]>"]
 license = "MIT"

computer-keyboard/src/lib.rs

@@ -165,6 +165,58 @@ where
 }
 
 impl<K> Keyboard<K> {
+    pub fn new<F: FnMut(Key) -> K>(mut f: F) -> Self {
+        Keyboard {
+            a: f(Key::A),
+            b: f(Key::B),
+            c: f(Key::C),
+            d: f(Key::D),
+            e: f(Key::E),
+            f: f(Key::F),
+            g: f(Key::G),
+            h: f(Key::H),
+            i: f(Key::I),
+            j: f(Key::J),
+            k: f(Key::K),
+            l: f(Key::L),
+            m: f(Key::M),
+            n: f(Key::N),
+            o: f(Key::O),
+            p: f(Key::P),
+            q: f(Key::Q),
+            r: f(Key::R),
+            s: f(Key::S),
+            t: f(Key::T),
+            u: f(Key::U),
+            v: f(Key::V),
+            w: f(Key::W),
+            x: f(Key::X),
+            y: f(Key::Y),
+            z: f(Key::Z),
+            n0: f(Key::N0),
+            n1: f(Key::N1),
+            n2: f(Key::N2),
+            n3: f(Key::N3),
+            n4: f(Key::N4),
+            n5: f(Key::N5),
+            n6: f(Key::N6),
+            n7: f(Key::N7),
+            n8: f(Key::N8),
+            n9: f(Key::N9),
+            left_bracket: f(Key::LeftBracket),
+            right_bracket: f(Key::RightBracket),
+            semicolon: f(Key::Semicolon),
+            apostrophe: f(Key::Apostrophe),
+            comma: f(Key::Comma),
+            period: f(Key::Period),
+            minus: f(Key::Minus),
+            equals: f(Key::Equals),
+            slash: f(Key::Slash),
+            space: f(Key::Space),
+            backspace: f(Key::Backspace),
+            backslash: f(Key::Backslash),
+        }
+    }
     pub fn map<K_, F: FnMut(&K) -> K_>(&self, mut f: F) -> Keyboard<K_> {
         Keyboard {
             a: f(&self.a),

core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "caw_core"
-version = "0.3.2"
+version = "0.3.3"
 description = "Core types for caw software-defined modular synthesizer"
 authors = ["Stephen Sherratt <[email protected]>"]
 license = "MIT"

core/src/frame_sig.rs

@@ -1,5 +1,10 @@
 use crate::{Buf, ConstBuf, Filter, Sig, SigCtx, SigT};
-use std::{cell::RefCell, fmt::Debug, rc::Rc};
+use std::{
+    cell::RefCell,
+    fmt::Debug,
+    rc::Rc,
+    sync::{Arc, RwLock},
+};
 
 /// A signal with values produced each audio frame. This is distinct from the `SigT` trait whose
 /// values are produced for each audio sample. Each audio frame corresponds to the sound driver
@@ -531,6 +536,40 @@ where
     })
 }
 
+#[derive(Default)]
+pub struct FrameSigVar<T>(Arc<RwLock<T>>);
+
+impl<T> FrameSigVar<T> {
+    pub fn new(value: T) -> Self {
+        Self(Arc::new(RwLock::new(value)))
+    }
+
+    pub fn set(&self, value: T) {
+        *self.0.write().unwrap() = value;
+    }
+}
+
+impl<T> Clone for FrameSigVar<T> {
+    fn clone(&self) -> Self {
+        Self(Arc::clone(&self.0))
+    }
+}
+
+impl<T> FrameSigT for FrameSigVar<T>
+where
+    T: Clone,
+{
+    type Item = T;
+
+    fn frame_sample(&mut self, _ctx: &SigCtx) -> Self::Item {
+        self.0.read().unwrap().clone()
+    }
+}
+
+pub fn frame_sig_var<T: Clone>(value: T) -> FrameSig<FrameSigVar<T>> {
+    FrameSig(FrameSigVar::new(value))
+}
+
 pub struct FrameSigBoxed<T>(Box<dyn FrameSigT<Item = T>>);
 
 impl<T> FrameSigT for FrameSigBoxed<T>

core/src/lib.rs

@@ -4,12 +4,12 @@ pub mod frame_sig_ops;
 mod sig;
 pub mod sig_ops;
 pub use frame_sig::{
-    frame_sig_shared, FrameSig, FrameSigEdges, FrameSigShared, FrameSigT,
-    Triggerable,
+    frame_sig_shared, frame_sig_var, FrameSig, FrameSigEdges, FrameSigShared,
+    FrameSigT, FrameSigVar, Triggerable,
 };
 pub use sig::{
     sig_shared, Buf, ConstBuf, Filter, GateToTrigRisingEdge, Sig, SigAbs,
     SigBoxed, SigCtx, SigSampleIntoBufT, SigShared, SigT,
 };
 pub mod stereo;
-pub use stereo::{Channel, Stereo};
+pub use stereo::{Channel, Stereo, StereoPair};

core/src/stereo.rs

@@ -31,6 +31,8 @@ pub struct Stereo<L, R> {
     pub right: R,
 }
 
+pub type StereoPair<T> = Stereo<T, T>;
+
 impl<L, R> Stereo<L, R> {
     pub fn new(left: L, right: R) -> Self {
         Self { left, right }

interactive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "caw_interactive"
-version = "0.3.2"
+version = "0.3.3"
 description = "Interactive keyboard and mouse control, and visualization for the caw synthesizer framework"
 authors = ["Stephen Sherratt <[email protected]>"]
 license = "MIT"

interactive/src/input.rs

@@ -1,7 +1,6 @@
 pub use caw_computer_keyboard::{Key, Keyboard as KeyboardGeneric};
-use caw_core::{FrameSig, FrameSigT, SigCtx};
+use caw_core::{frame_sig_var, FrameSig, FrameSigT, FrameSigVar};
 use sdl2::{keyboard::Scancode, mouse::MouseButton as SdlMouseButton};
-use std::sync::{Arc, RwLock};
 
 #[derive(Debug, Clone, Copy)]
 pub enum MouseButton {
@@ -19,22 +18,6 @@ pub struct MouseGeneric<P, B> {
     pub middle: B,
 }
 
-impl<P, B> MouseGeneric<P, B> {
-    fn map<P_, B_, FP: FnMut(&P) -> P_, FB: FnMut(&B) -> B_>(
-        &self,
-        mut f_position: FP,
-        mut f_button: FB,
-    ) -> MouseGeneric<P_, B_> {
-        MouseGeneric {
-            x_01: f_position(&self.x_01),
-            y_01: f_position(&self.y_01),
-            left: f_button(&self.left),
-            right: f_button(&self.right),
-            middle: f_button(&self.middle),
-        }
-    }
-}
-
 impl<P: Clone, B: Clone> MouseGeneric<P, B> {
     pub fn button(&self, mouse_button: MouseButton) -> B {
         use MouseButton::*;
@@ -54,27 +37,9 @@ impl<P: Clone, B: Clone> MouseGeneric<P, B> {
     }
 }
 
-/// A signal for keyboard and mouse inputs from sdl. Always yields the same value during any given
-/// frame.
-pub struct FrameSigInput<T: Copy>(Arc<RwLock<T>>);
-
-impl<T: Copy> FrameSigT for FrameSigInput<T> {
-    type Item = T;
-
-    fn frame_sample(&mut self, _ctx: &SigCtx) -> Self::Item {
-        *self.0.read().unwrap()
-    }
-}
-
-impl<T: Copy> Clone for FrameSigInput<T> {
-    fn clone(&self) -> Self {
-        FrameSigInput(Arc::clone(&self.0))
-    }
-}
-
-pub type Keyboard = KeyboardGeneric<FrameSig<FrameSigInput<bool>>>;
+pub type Keyboard = KeyboardGeneric<FrameSig<FrameSigVar<bool>>>;
 pub type Mouse =
-    MouseGeneric<FrameSig<FrameSigInput<f32>>, FrameSig<FrameSigInput<bool>>>;
+    MouseGeneric<FrameSig<FrameSigVar<f32>>, FrameSig<FrameSigVar<bool>>>;
 
 #[derive(Clone)]
 pub struct Input {
@@ -105,66 +70,18 @@ impl Input {
 
 #[derive(Clone)]
 pub struct InputState {
-    keyboard: KeyboardGeneric<Arc<RwLock<bool>>>,
-    mouse: MouseGeneric<Arc<RwLock<f32>>, Arc<RwLock<bool>>>,
+    keyboard: KeyboardGeneric<FrameSig<FrameSigVar<bool>>>,
+    mouse:
+        MouseGeneric<FrameSig<FrameSigVar<f32>>, FrameSig<FrameSigVar<bool>>>,
 }
 
 impl InputState {
     pub(crate) fn new() -> Self {
-        let mk_key = || Arc::new(RwLock::new(false));
-        let mk_position = || Arc::new(RwLock::new(0.0));
-        let mk_button = || Arc::new(RwLock::new(false));
+        let mk_key = |_| frame_sig_var(false);
+        let mk_position = || frame_sig_var(0.0);
+        let mk_button = || frame_sig_var(false);
         Self {
-            keyboard: KeyboardGeneric {
-                a: mk_key(),
-                b: mk_key(),
-                c: mk_key(),
-                d: mk_key(),
-                e: mk_key(),
-                f: mk_key(),
-                g: mk_key(),
-                h: mk_key(),
-                i: mk_key(),
-                j: mk_key(),
-                k: mk_key(),
-                l: mk_key(),
-                m: mk_key(),
-                n: mk_key(),
-                o: mk_key(),
-                p: mk_key(),
-                q: mk_key(),
-                r: mk_key(),
-                s: mk_key(),
-                t: mk_key(),
-                u: mk_key(),
-                v: mk_key(),
-                w: mk_key(),
-                x: mk_key(),
-                y: mk_key(),
-                z: mk_key(),
-                n0: mk_key(),
-                n1: mk_key(),
-                n2: mk_key(),
-                n3: mk_key(),
-                n4: mk_key(),
-                n5: mk_key(),
-                n6: mk_key(),
-                n7: mk_key(),
-                n8: mk_key(),
-                n9: mk_key(),
-                left_bracket: mk_key(),
-                right_bracket: mk_key(),
-                semicolon: mk_key(),
-                apostrophe: mk_key(),
-                comma: mk_key(),
-                period: mk_key(),
-                minus: mk_key(),
-                equals: mk_key(),
-                slash: mk_key(),
-                space: mk_key(),
-                backspace: mk_key(),
-                backslash: mk_key(),
-            },
+            keyboard: KeyboardGeneric::new(mk_key),
             mouse: MouseGeneric {
                 x_01: mk_position(),
                 y_01: mk_position(),
@@ -227,12 +144,12 @@ impl InputState {
             Scancode::Backslash => &self.keyboard.backslash,
             _ => return,
         };
-        *key_state.write().unwrap() = pressed;
+        key_state.0.set(pressed);
     }
 
     pub(crate) fn set_mouse_position(&self, x_01: f32, y_01: f32) {
-        *self.mouse.x_01.write().unwrap() = x_01;
-        *self.mouse.y_01.write().unwrap() = y_01;
+        self.mouse.x_01.0.set(x_01);
+        self.mouse.y_01.0.set(y_01);
     }
 
     pub(crate) fn set_mouse_button(
@@ -246,19 +163,15 @@ impl InputState {
             SdlMouseButton::Middle => &self.mouse.middle,
             _ => return,
         };
-        *button_state.write().unwrap() = pressed;
+        button_state.0.set(pressed);
     }
 
     pub fn keyboard(&self) -> Keyboard {
-        self.keyboard
-            .map(|key| FrameSig(FrameSigInput(Arc::clone(key))))
+        self.keyboard.clone()
     }
 
     pub fn mouse(&self) -> Mouse {
-        self.mouse.map(
-            |position| FrameSig(FrameSigInput(Arc::clone(position))),
-            |button| FrameSig(FrameSigInput(Arc::clone(button))),
-        )
+        self.mouse.clone()
     }
 
     pub fn input(&self) -> Input {