bye DynamicDevice; now to reenable playback...

src/core.rs

@@ -15,10 +15,24 @@ pub use crossterm::event::{Event, KeyEvent, KeyCode, KeyModifiers};
 
 macro_rules! submod { ($($name:ident)*) => { $(mod $name; pub use self::$name::*;)* }; }
 
-submod!( device handle jack keymap midi port render run time );
+submod!( handle jack keymap midi port render run time );
 
 pub type Usually<T> = Result<T, Box<dyn Error>>;
 
+pub trait Component: Render + Handle {}
+
+impl<T: Render + Handle> Component for T {}
+
+/// A UI component that may have presence on the JACK grap.
+pub trait Device: Render + Handle + Ports + Send + Sync {
+    fn boxed (self) -> Box<dyn Device> where Self: Sized + 'static {
+        Box::new(self)
+    }
+}
+
+/// All things that implement the required traits can be treated as `Device`.
+impl<T: Render + Handle + Ports + Send + Sync> Device for T {}
+
 // Reexport macros:
 pub use crate::{
     render,

src/core/device.rs

@@ -1,77 +0,0 @@
-use crate::core::*;
-
-pub trait Component: Render + Handle {}
-
-impl<T: Render + Handle> Component for T {}
-
-/// A UI component that may have presence on the JACK grap.
-pub trait Device: Render + Handle + Ports + Send + Sync {
-    fn boxed (self) -> Box<dyn Device> where Self: Sized + 'static {
-        Box::new(self)
-    }
-}
-
-/// All things that implement the required traits can be treated as `Device`.
-impl<T: Render + Handle + Ports + Send + Sync> Device for T {}
-
-/// A device dynamicammy composed of state and handlers.
-pub struct DynamicDevice<T> {
-    pub state:   Arc<Mutex<T>>,
-    pub render:  Mutex<Box<dyn FnMut(&T, &mut Buffer, Rect)->Usually<Rect> + Send>>,
-    pub handle:  Arc<Mutex<Box<dyn FnMut(&mut T, &AppEvent)->Usually<bool> + Send>>>,
-    pub process: Arc<Mutex<Box<dyn FnMut(&mut T, &Client, &ProcessScope)->Control + Send>>>,
-    pub client:  Option<DynamicAsyncClient>
-}
-
-impl<T> Handle for DynamicDevice<T> {
-    fn handle (&mut self, event: &AppEvent) -> Usually<bool> {
-        self.handle.lock().unwrap()(&mut *self.state.lock().unwrap(), event)
-    }
-}
-
-impl<T: Send> Render for DynamicDevice<T> {
-    fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
-        self.render.lock().unwrap()(&*self.state.lock().unwrap(), buf, area)
-    }
-}
-
-impl<T: Ports + Send + Sync + 'static> Ports for DynamicDevice<T> {}
-
-impl<T: Send + Sync + 'static> DynamicDevice<T> {
-    pub fn new <'a, R, H, P> (render: R, handle: H, process: P, state: T) -> Self where
-        R: FnMut(&T, &mut Buffer, Rect)    -> Usually<Rect> + Send + 'static,
-        H: FnMut(&mut T, &AppEvent)        -> Usually<bool> + Send + 'static,
-        P: FnMut(&mut T, &Client, &ProcessScope) -> Control + Send + 'static,
-    {
-        Self {
-            state:   Arc::new(Mutex::new(state)),
-            render:  Mutex::new(Box::new(render)),
-            handle:  Arc::new(Mutex::new(Box::new(handle))),
-            process: Arc::new(Mutex::new(Box::new(process))),
-            client:  None,
-        }
-    }
-    pub fn state (&self) -> std::sync::MutexGuard<'_, T> {
-        self.state.lock().unwrap()
-    }
-    pub fn activate (mut self, client: Client) -> Usually<Self> {
-        self.client = Some(client.activate_async(Notifications(Box::new({
-            let state  = self.state.clone();
-            let handle = self.handle.clone();
-            move|event|{
-                let mut state = state.lock().unwrap();
-                let mut handle = handle.lock().unwrap();
-                handle(&mut state, &event).unwrap();
-            }
-        }) as Box<dyn Fn(AppEvent) + Send + Sync>), ClosureProcessHandler::new(Box::new({
-            let state   = self.state.clone();
-            let process = self.process.clone();
-            move|client: &Client, scope: &ProcessScope|{
-                let mut state = state.lock().unwrap();
-                let mut process = process.lock().unwrap();
-                (process)(&mut state, client, scope)
-            }
-        }) as BoxedProcessHandler))?);
-        Ok(self)
-    }
-}

src/model/looper.rs

@@ -1,29 +1,9 @@
 use crate::core::*;
 
 pub struct Looper {
-    name: String
+    pub name: String
 }
-
-impl Looper {
-    pub fn new (name: &str) -> Result<DynamicDevice<Self>, Box<dyn Error>> {
-        Ok(DynamicDevice::new(render, handle, process, Self {
-            name: name.into(),
-        }))
-    }
-}
-
-pub fn process (_: &mut Looper, _: &Client, _: &ProcessScope) -> Control {
-    Control::Continue
-}
-
-pub fn render (_: &Looper, _: &mut Buffer, _: Rect) -> Usually<Rect> {
-    Ok(Rect::default())
-}
-
-pub fn handle (_: &mut Looper, _: &AppEvent) -> Usually<bool> {
-    Ok(false)
-}
-
-pub const ACTIONS: [(&'static str, &'static str);1] = [
-    ("Ins/Del", "Add/remove loop"),
-];
+render!(Looper);
+handle!(Looper);
+process!(Looper);
+ports!(Looper);

src/model/mixer.rs

@@ -6,30 +6,28 @@ pub struct Mixer {
     pub selected_track:  usize,
     pub selected_column: usize,
 }
+render!(Mixer = crate::view::mixer::render);
+handle!(Mixer = crate::control::mixer::handle);
+process!(Mixer = process);
 
 impl Mixer {
-    pub fn new (name: &str) -> Result<DynamicDevice<Self>, Box<dyn Error>> {
+    pub fn new (name: &str) -> Usually<Self> {
         let (client, _status) = Client::new(name, ClientOptions::NO_START_SERVER)?;
-        Ok(DynamicDevice::new(
-            crate::view::mixer::render,
-            crate::control::mixer::handle,
-            process, 
-            Self {
-                name: name.into(),
-                selected_column: 0,
-                selected_track:  1,
-                tracks: vec![
-                    MixerTrack::new(&client, 1, "Mono 1")?,
-                    MixerTrack::new(&client, 1, "Mono 2")?,
-                    MixerTrack::new(&client, 2, "Stereo 1")?,
-                    MixerTrack::new(&client, 2, "Stereo 2")?,
-                    MixerTrack::new(&client, 2, "Stereo 3")?,
-                    MixerTrack::new(&client, 2, "Bus 1")?,
-                    MixerTrack::new(&client, 2, "Bus 2")?,
-                    MixerTrack::new(&client, 2, "Mix")?,
-                ],
-            }
-        ))
+        Ok(Self {
+            name: name.into(),
+            selected_column: 0,
+            selected_track:  1,
+            tracks: vec![
+                MixerTrack::new(&client, 1, "Mono 1")?,
+                MixerTrack::new(&client, 1, "Mono 2")?,
+                MixerTrack::new(&client, 2, "Stereo 1")?,
+                MixerTrack::new(&client, 2, "Stereo 2")?,
+                MixerTrack::new(&client, 2, "Stereo 3")?,
+                MixerTrack::new(&client, 2, "Bus 1")?,
+                MixerTrack::new(&client, 2, "Bus 2")?,
+                MixerTrack::new(&client, 2, "Mix")?,
+            ],
+        })
     }
 }
 
@@ -59,7 +57,7 @@ pub struct MixerTrack {
 }
 
 impl MixerTrack {
-    pub fn new (jack: &Client, channels: u8, name: &str) -> Result<Self, Box<dyn Error>> {
+    pub fn new (jack: &Client, channels: u8, name: &str) -> Usually<Self> {
         let mut input_ports  = vec![];
         let mut insert_ports = vec![];
         let mut return_ports = vec![];