Process -> Audio; Layers2 -> Layers

crates/tek_core/src/audio.rs

@@ -1,10 +1,31 @@
 use jack::*;
 use crate::*;
 
-submod! { device event ports }
+/// Trait for things that have a JACK process callback.
+pub trait Audio {
+    fn process (&mut self, _: &Client, _: &ProcessScope) -> Control {
+        Control::Continue
+    }
+}
+
+/// Trait for things that may expose JACK ports.
+pub trait Ports {
+    fn audio_ins (&self) -> Usually<Vec<&Port<Unowned>>> {
+        Ok(vec![])
+    }
+    fn audio_outs (&self) -> Usually<Vec<&Port<Unowned>>> {
+        Ok(vec![])
+    }
+    fn midi_ins (&self) -> Usually<Vec<&Port<Unowned>>> {
+        Ok(vec![])
+    }
+    fn midi_outs (&self) -> Usually<Vec<&Port<Unowned>>> {
+        Ok(vec![])
+    }
+}
 
 /// A UI component that may be associated with a JACK client by the `Jack` factory.
-pub trait Device<E: Engine>: Component<E> + Process {
+pub trait Device<E: Engine>: Component<E> + Audio {
     /// Perform type erasure for collecting heterogeneous devices.
     fn boxed (self) -> Box<dyn Device<E>> where Self: Sized + 'static {
         Box::new(self)
@@ -12,13 +33,7 @@ pub trait Device<E: Engine>: Component<E> + Process {
 }
 
 /// All things that implement the required traits can be treated as `Device`.
-impl<E: Engine, W: Component<E> + Process> Device<E> for W {}
-
-//impl<'a, E: Engine> Render<E> for Box<dyn Device<E> + 'a> {
-    //fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
-        //(**self).render(to)
-    //}
-//}
+impl<E: Engine, W: Component<E> + Audio> Device<E> for W {}
 
 /// Wraps [Client] or [DynamicAsyncClient] in place.
 pub enum JackClient {
@@ -57,52 +72,24 @@ impl JackClient {
                 ClosureProcessHandler::new(Box::new({
                     let state = state.clone();
                     move|c: &Client, s: &ProcessScope|process(&state, c, s)
-                }) as BoxedProcessHandler)
+                }) as BoxedAudioHandler)
             )?)
         })
     }
 }
 
 pub type DynamicAsyncClient =
-    AsyncClient<DynamicNotifications, DynamicProcessHandler>;
+    AsyncClient<DynamicNotifications, DynamicAudioHandler>;
 
-type DynamicProcessHandler =
-    ClosureProcessHandler<BoxedProcessHandler>;
+type DynamicAudioHandler =
+    ClosureProcessHandler<BoxedAudioHandler>;
 
-pub type BoxedProcessHandler =
+pub type BoxedAudioHandler =
     Box<dyn FnMut(&Client, &ProcessScope)-> Control + Send>;
 
-/// Trait for things that have a JACK process callback.
-pub trait Process {
-    fn process (&mut self, _: &Client, _: &ProcessScope) -> Control {
-        Control::Continue
-    }
-}
-
-/// Define the JACK process callback associated with a struct.
-#[macro_export] macro_rules! process {
-    ($T:ty) => {
-        impl Process for $T {}
-    };
-    ($T:ty |$self:ident, $c:ident, $s:ident|$block:tt) => {
-        impl Process for $T {
-            fn process (&mut $self, $c: &Client, $s: &ProcessScope) -> Control {
-                $block
-            }
-        }
-    };
-    ($T:ty = $process:path) => {
-        impl Process for $T {
-            fn process (&mut self, c: &Client, s: &ProcessScope) -> Control {
-                $process(self, c, s)
-            }
-        }
-    }
-}
-
 /// Just run thing with JACK. Returns the activated client.
 pub fn jack_run <T, E: Engine> (name: &str, app: &Arc<RwLock<T>>) -> Usually<DynamicAsyncClient>
-    where T: Handle<E> + Process + Send + Sync + 'static
+    where T: Handle<E> + Audio + Send + Sync + 'static
 {
     let options = ClientOptions::NO_START_SERVER;
     let (client, _status) = Client::new(name, options)?;
@@ -120,7 +107,7 @@ pub fn jack_run <T, E: Engine> (name: &str, app: &Arc<RwLock<T>>) -> Usually<Dyn
                 app.write().unwrap().process(c, s)
                 //Control::Continue
             }
-        }) as BoxedProcessHandler)
+        }) as BoxedAudioHandler)
     )?)
 }
 
@@ -133,6 +120,7 @@ pub struct Jack {
     pub midi_outs:  Vec<String>,
     pub audio_outs: Vec<String>,
 }
+
 impl Jack {
     pub fn new (name: &str) -> Usually<Self> {
         Ok(Self {
@@ -180,7 +168,7 @@ impl Jack {
                 move|c: &Client, s: &ProcessScope|{
                     state.write().unwrap().process(c, s)
                 }
-            }) as BoxedProcessHandler)
+            }) as BoxedAudioHandler)
         )?;
         Ok(JackDevice {
             ports: UnownedJackPorts {
@@ -230,3 +218,219 @@ fn query_ports (
         ports
     })
 }
+
+/// Notification handler used by the [Jack] factory
+/// when constructing [JackDevice]s.
+pub type DynamicNotifications =
+    Notifications<Box<dyn Fn(JackEvent) + Send + Sync>>;
+
+#[derive(Debug)]
+/// Event enum for JACK events.
+pub enum JackEvent {
+    ThreadInit,
+    Shutdown(ClientStatus, String),
+    Freewheel(bool),
+    SampleRate(Frames),
+    ClientRegistration(String, bool),
+    PortRegistration(PortId, bool),
+    PortRename(PortId, String, String),
+    PortsConnected(PortId, PortId, bool),
+    GraphReorder,
+    XRun,
+}
+
+/// Generic notification handler that emits [JackEvent]
+pub struct Notifications<T: Fn(JackEvent) + Send>(pub T);
+
+impl<T: Fn(JackEvent) + Send> NotificationHandler for Notifications<T> {
+    fn thread_init (&self, _: &Client) {
+        self.0(JackEvent::ThreadInit);
+    }
+
+    fn shutdown (&mut self, status: ClientStatus, reason: &str) {
+        self.0(JackEvent::Shutdown(status, reason.into()));
+    }
+
+    fn freewheel (&mut self, _: &Client, enabled: bool) {
+        self.0(JackEvent::Freewheel(enabled));
+    }
+
+    fn sample_rate (&mut self, _: &Client, frames: Frames) -> Control {
+        self.0(JackEvent::SampleRate(frames));
+        Control::Quit
+    }
+
+    fn client_registration (&mut self, _: &Client, name: &str, reg: bool) {
+        self.0(JackEvent::ClientRegistration(name.into(), reg));
+    }
+
+    fn port_registration (&mut self, _: &Client, id: PortId, reg: bool) {
+        self.0(JackEvent::PortRegistration(id, reg));
+    }
+
+    fn port_rename (&mut self, _: &Client, id: PortId, old: &str, new: &str) -> Control {
+        self.0(JackEvent::PortRename(id, old.into(), new.into()));
+        Control::Continue
+    }
+
+    fn ports_connected (&mut self, _: &Client, a: PortId, b: PortId, are: bool) {
+        self.0(JackEvent::PortsConnected(a, b, are));
+    }
+
+    fn graph_reorder (&mut self, _: &Client) -> Control {
+        self.0(JackEvent::GraphReorder);
+        Control::Continue
+    }
+
+    fn xrun (&mut self, _: &Client) -> Control {
+        self.0(JackEvent::XRun);
+        Control::Continue
+    }
+}
+
+/// A [Device] bound to a JACK client and a set of ports.
+pub struct JackDevice<E: Engine> {
+    /// The active JACK client of this device.
+    pub client: DynamicAsyncClient,
+    /// The device state, encapsulated for sharing between threads.
+    pub state:  Arc<RwLock<Box<dyn Device<E>>>>,
+    /// Unowned copies of the device's JACK ports, for connecting to the device.
+    /// The "real" readable/writable `Port`s are owned by the `state`.
+    pub ports:  UnownedJackPorts,
+}
+
+impl<E: Engine> std::fmt::Debug for JackDevice<E> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("JackDevice").field("ports", &self.ports).finish()
+    }
+}
+
+impl<E: Engine> Widget for JackDevice<E> {
+    type Engine = E;
+    fn layout (&self, to: E::Area) -> Perhaps<E::Area> {
+        self.state.read().unwrap().layout(to)
+    }
+    fn render (&self, to: &mut E) -> Perhaps<E::Area> {
+        self.state.read().unwrap().render(to)
+    }
+}
+
+impl<E: Engine> Handle<E> for JackDevice<E> {
+    fn handle (&mut self, from: &E::HandleInput) -> Perhaps<E::Handled> {
+        self.state.write().unwrap().handle(from)
+    }
+}
+
+impl<E: Engine> Ports for JackDevice<E> {
+    fn audio_ins (&self) -> Usually<Vec<&Port<Unowned>>> {
+        Ok(self.ports.audio_ins.values().collect())
+    }
+    fn audio_outs (&self) -> Usually<Vec<&Port<Unowned>>> {
+        Ok(self.ports.audio_outs.values().collect())
+    }
+    fn midi_ins (&self) -> Usually<Vec<&Port<Unowned>>> {
+        Ok(self.ports.midi_ins.values().collect())
+    }
+    fn midi_outs (&self) -> Usually<Vec<&Port<Unowned>>> {
+        Ok(self.ports.midi_outs.values().collect())
+    }
+}
+
+impl<E: Engine> JackDevice<E> {
+    /// Returns a locked mutex of the state's contents.
+    pub fn state (&self) -> LockResult<RwLockReadGuard<Box<dyn Device<E>>>> {
+        self.state.read()
+    }
+    /// Returns a locked mutex of the state's contents.
+    pub fn state_mut (&self) -> LockResult<RwLockWriteGuard<Box<dyn Device<E>>>> {
+        self.state.write()
+    }
+    pub fn connect_midi_in (&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
+        Ok(self.client.as_client().connect_ports(port, self.midi_ins()?[index])?)
+    }
+    pub fn connect_midi_out (&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
+        Ok(self.client.as_client().connect_ports(self.midi_outs()?[index], port)?)
+    }
+    pub fn connect_audio_in (&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
+        Ok(self.client.as_client().connect_ports(port, self.audio_ins()?[index])?)
+    }
+    pub fn connect_audio_out (&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
+        Ok(self.client.as_client().connect_ports(self.audio_outs()?[index], port)?)
+    }
+}
+
+/// Collection of JACK ports as [AudioIn]/[AudioOut]/[MidiIn]/[MidiOut].
+#[derive(Default, Debug)]
+pub struct JackPorts {
+    pub audio_ins:  BTreeMap<String, Port<AudioIn>>,
+    pub midi_ins:   BTreeMap<String, Port<MidiIn>>,
+    pub audio_outs: BTreeMap<String, Port<AudioOut>>,
+    pub midi_outs:  BTreeMap<String, Port<MidiOut>>,
+}
+
+/// Collection of JACK ports as [Unowned].
+#[derive(Default, Debug)]
+pub struct UnownedJackPorts {
+    pub audio_ins:  BTreeMap<String, Port<Unowned>>,
+    pub midi_ins:   BTreeMap<String, Port<Unowned>>,
+    pub audio_outs: BTreeMap<String, Port<Unowned>>,
+    pub midi_outs:  BTreeMap<String, Port<Unowned>>,
+}
+
+impl JackPorts {
+    pub fn clone_unowned (&self) -> UnownedJackPorts {
+        let mut unowned = UnownedJackPorts::default();
+        for (name, port) in self.midi_ins.iter() {
+            unowned.midi_ins.insert(name.clone(), port.clone_unowned());
+        }
+        for (name, port) in self.midi_outs.iter() {
+            unowned.midi_outs.insert(name.clone(), port.clone_unowned());
+        }
+        for (name, port) in self.audio_ins.iter() {
+            unowned.audio_ins.insert(name.clone(), port.clone_unowned());
+        }
+        for (name, port) in self.audio_outs.iter() {
+            unowned.audio_outs.insert(name.clone(), port.clone_unowned());
+        }
+        unowned
+    }
+}
+
+/// Implement the `Ports` trait.
+#[macro_export] macro_rules! ports {
+    ($T:ty $({ $(audio: {
+        $(ins:  |$ai_arg:ident|$ai_impl:expr,)?
+        $(outs: |$ao_arg:ident|$ao_impl:expr,)?
+    })? $(midi: {
+        $(ins:  |$mi_arg:ident|$mi_impl:expr,)?
+        $(outs: |$mo_arg:ident|$mo_impl:expr,)?
+    })?})?) => {
+        impl Ports for $T {$(
+            $(
+                $(fn audio_ins <'a> (&'a self) -> Usually<Vec<&'a Port<Unowned>>> {
+                    let cb = |$ai_arg:&'a Self|$ai_impl;
+                    cb(self)
+                })?
+            )?
+            $(
+                $(fn audio_outs <'a> (&'a self) -> Usually<Vec<&'a Port<Unowned>>> {
+                    let cb = (|$ao_arg:&'a Self|$ao_impl);
+                    cb(self)
+                })?
+            )?
+        )? $(
+            $(
+                $(fn midi_ins <'a> (&'a self) -> Usually<Vec<&'a Port<Unowned>>> {
+                    let cb = (|$mi_arg:&'a Self|$mi_impl);
+                    cb(self)
+                })?
+            )?
+            $(
+                $(fn midi_outs <'a> (&'a self) -> Usually<Vec<&'a Port<Unowned>>> {
+                    let cb = (|$mo_arg:&'a Self|$mo_impl);
+                    cb(self)
+                })?
+            )?
+        )?}
+    };
+}

crates/tek_core/src/audio/device.rs

@@ -1,70 +0,0 @@
-use ::jack::*;
-use crate::*;
-
-/// A [Device] bound to a JACK client and a set of ports.
-pub struct JackDevice<E: Engine> {
-    /// The active JACK client of this device.
-    pub client: DynamicAsyncClient,
-    /// The device state, encapsulated for sharing between threads.
-    pub state:  Arc<RwLock<Box<dyn Device<E>>>>,
-    /// Unowned copies of the device's JACK ports, for connecting to the device.
-    /// The "real" readable/writable `Port`s are owned by the `state`.
-    pub ports:  UnownedJackPorts,
-}
-impl<E: Engine> std::fmt::Debug for JackDevice<E> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("JackDevice").field("ports", &self.ports).finish()
-    }
-}
-impl<E: Engine> Widget for JackDevice<E> {
-    type Engine = E;
-    fn layout (&self, to: E::Area) -> Perhaps<E::Area> {
-        self.state.read().unwrap().layout(to)
-    }
-    fn render (&self, to: &mut E) -> Perhaps<E::Area> {
-        self.state.read().unwrap().render(to)
-    }
-}
-impl<E: Engine> Handle<E> for JackDevice<E> {
-    fn handle (&mut self, from: &E::HandleInput) -> Perhaps<E::Handled> {
-        self.state.write().unwrap().handle(from)
-    }
-}
-impl<E: Engine> Ports for JackDevice<E> {
-    fn audio_ins (&self) -> Usually<Vec<&Port<Unowned>>> {
-        Ok(self.ports.audio_ins.values().collect())
-    }
-    fn audio_outs (&self) -> Usually<Vec<&Port<Unowned>>> {
-        Ok(self.ports.audio_outs.values().collect())
-    }
-    fn midi_ins (&self) -> Usually<Vec<&Port<Unowned>>> {
-        Ok(self.ports.midi_ins.values().collect())
-    }
-    fn midi_outs (&self) -> Usually<Vec<&Port<Unowned>>> {
-        Ok(self.ports.midi_outs.values().collect())
-    }
-}
-impl<E: Engine> JackDevice<E> {
-    /// Returns a locked mutex of the state's contents.
-    pub fn state (&self) -> LockResult<RwLockReadGuard<Box<dyn Device<E>>>> {
-        self.state.read()
-    }
-    /// Returns a locked mutex of the state's contents.
-    pub fn state_mut (&self) -> LockResult<RwLockWriteGuard<Box<dyn Device<E>>>> {
-        self.state.write()
-    }
-    pub fn connect_midi_in (&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
-        Ok(self.client.as_client().connect_ports(port, self.midi_ins()?[index])?)
-    }
-    pub fn connect_midi_out (&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
-        Ok(self.client.as_client().connect_ports(self.midi_outs()?[index], port)?)
-    }
-    pub fn connect_audio_in (&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
-        Ok(self.client.as_client().connect_ports(port, self.audio_ins()?[index])?)
-    }
-    pub fn connect_audio_out (&self, index: usize, port: &Port<Unowned>) -> Usually<()> {
-        Ok(self.client.as_client().connect_ports(self.audio_outs()?[index], port)?)
-    }
-}
-
-

crates/tek_core/src/audio/event.rs

@@ -1,71 +0,0 @@
-use ::jack::*;
-use crate::*;
-
-/// Notification handler used by the [Jack] factory
-/// when constructing [JackDevice]s.
-pub type DynamicNotifications =
-    Notifications<Box<dyn Fn(JackEvent) + Send + Sync>>;
-
-#[derive(Debug)]
-/// Event enum for JACK events.
-pub enum JackEvent {
-    ThreadInit,
-    Shutdown(ClientStatus, String),
-    Freewheel(bool),
-    SampleRate(Frames),
-    ClientRegistration(String, bool),
-    PortRegistration(PortId, bool),
-    PortRename(PortId, String, String),
-    PortsConnected(PortId, PortId, bool),
-    GraphReorder,
-    XRun,
-}
-
-/// Generic notification handler that emits [JackEvent]
-pub struct Notifications<T: Fn(JackEvent) + Send>(pub T);
-
-impl<T: Fn(JackEvent) + Send> NotificationHandler for Notifications<T> {
-    fn thread_init (&self, _: &Client) {
-        self.0(JackEvent::ThreadInit);
-    }
-
-    fn shutdown (&mut self, status: ClientStatus, reason: &str) {
-        self.0(JackEvent::Shutdown(status, reason.into()));
-    }
-
-    fn freewheel (&mut self, _: &Client, enabled: bool) {
-        self.0(JackEvent::Freewheel(enabled));
-    }
-
-    fn sample_rate (&mut self, _: &Client, frames: Frames) -> Control {
-        self.0(JackEvent::SampleRate(frames));
-        Control::Quit
-    }
-
-    fn client_registration (&mut self, _: &Client, name: &str, reg: bool) {
-        self.0(JackEvent::ClientRegistration(name.into(), reg));
-    }
-
-    fn port_registration (&mut self, _: &Client, id: PortId, reg: bool) {
-        self.0(JackEvent::PortRegistration(id, reg));
-    }
-
-    fn port_rename (&mut self, _: &Client, id: PortId, old: &str, new: &str) -> Control {
-        self.0(JackEvent::PortRename(id, old.into(), new.into()));
-        Control::Continue
-    }
-
-    fn ports_connected (&mut self, _: &Client, a: PortId, b: PortId, are: bool) {
-        self.0(JackEvent::PortsConnected(a, b, are));
-    }
-
-    fn graph_reorder (&mut self, _: &Client) -> Control {
-        self.0(JackEvent::GraphReorder);
-        Control::Continue
-    }
-
-    fn xrun (&mut self, _: &Client) -> Control {
-        self.0(JackEvent::XRun);
-        Control::Continue
-    }
-}

crates/tek_core/src/audio/ports.rs

@@ -1,94 +0,0 @@
-use ::jack::*;
-use crate::*;
-
-/// Collection of JACK ports as [AudioIn]/[AudioOut]/[MidiIn]/[MidiOut].
-#[derive(Default, Debug)]
-pub struct JackPorts {
-    pub audio_ins:  BTreeMap<String, Port<AudioIn>>,
-    pub midi_ins:   BTreeMap<String, Port<MidiIn>>,
-    pub audio_outs: BTreeMap<String, Port<AudioOut>>,
-    pub midi_outs:  BTreeMap<String, Port<MidiOut>>,
-}
-
-/// Collection of JACK ports as [Unowned].
-#[derive(Default, Debug)]
-pub struct UnownedJackPorts {
-    pub audio_ins:  BTreeMap<String, Port<Unowned>>,
-    pub midi_ins:   BTreeMap<String, Port<Unowned>>,
-    pub audio_outs: BTreeMap<String, Port<Unowned>>,
-    pub midi_outs:  BTreeMap<String, Port<Unowned>>,
-}
-
-impl JackPorts {
-    pub fn clone_unowned (&self) -> UnownedJackPorts {
-        let mut unowned = UnownedJackPorts::default();
-        for (name, port) in self.midi_ins.iter() {
-            unowned.midi_ins.insert(name.clone(), port.clone_unowned());
-        }
-        for (name, port) in self.midi_outs.iter() {
-            unowned.midi_outs.insert(name.clone(), port.clone_unowned());
-        }
-        for (name, port) in self.audio_ins.iter() {
-            unowned.audio_ins.insert(name.clone(), port.clone_unowned());
-        }
-        for (name, port) in self.audio_outs.iter() {
-            unowned.audio_outs.insert(name.clone(), port.clone_unowned());
-        }
-        unowned
-    }
-}
-
-/// Trait for things that may expose JACK ports.
-pub trait Ports {
-    fn audio_ins (&self) -> Usually<Vec<&Port<Unowned>>> {
-        Ok(vec![])
-    }
-    fn audio_outs (&self) -> Usually<Vec<&Port<Unowned>>> {
-        Ok(vec![])
-    }
-    fn midi_ins (&self) -> Usually<Vec<&Port<Unowned>>> {
-        Ok(vec![])
-    }
-    fn midi_outs (&self) -> Usually<Vec<&Port<Unowned>>> {
-        Ok(vec![])
-    }
-}
-
-/// Implement the `Ports` trait.
-#[macro_export] macro_rules! ports {
-    ($T:ty $({ $(audio: {
-        $(ins:  |$ai_arg:ident|$ai_impl:expr,)?
-        $(outs: |$ao_arg:ident|$ao_impl:expr,)?
-    })? $(midi: {
-        $(ins:  |$mi_arg:ident|$mi_impl:expr,)?
-        $(outs: |$mo_arg:ident|$mo_impl:expr,)?
-    })?})?) => {
-        impl Ports for $T {$(
-            $(
-                $(fn audio_ins <'a> (&'a self) -> Usually<Vec<&'a Port<Unowned>>> {
-                    let cb = |$ai_arg:&'a Self|$ai_impl;
-                    cb(self)
-                })?
-            )?
-            $(
-                $(fn audio_outs <'a> (&'a self) -> Usually<Vec<&'a Port<Unowned>>> {
-                    let cb = (|$ao_arg:&'a Self|$ao_impl);
-                    cb(self)
-                })?
-            )?
-        )? $(
-            $(
-                $(fn midi_ins <'a> (&'a self) -> Usually<Vec<&'a Port<Unowned>>> {
-                    let cb = (|$mi_arg:&'a Self|$mi_impl);
-                    cb(self)
-                })?
-            )?
-            $(
-                $(fn midi_outs <'a> (&'a self) -> Usually<Vec<&'a Port<Unowned>>> {
-                    let cb = (|$mo_arg:&'a Self|$mo_impl);
-                    cb(self)
-                })?
-            )?
-        )?}
-    };
-}

crates/tek_core/src/engine.rs

@@ -25,6 +25,10 @@ pub trait Engine: Send + Sync + Sized {
     // FIXME
     fn with_area (&mut self, x: Self::Unit, y: Self::Unit, w: Self::Unit, h: Self::Unit)
         -> &mut Self;
+    // FIXME
+    fn render_in (
+        &mut self, area: Self::Area, widget: &impl Widget<Engine = Self>
+    ) -> Perhaps<Self::Area>;
 }
 
 submod! {

crates/tek_core/src/engine/collect.rs

@@ -52,9 +52,7 @@ impl<'a, E: Engine> Collect<'a, E> for Collection<'a, E> {
     }
 }
 
-pub struct Layers<'a, E: Engine, const N: usize>(pub [&'a dyn Widget<Engine = E>;N]);
-
-pub struct Layers2<
+pub struct Layers<
     E: Engine,
     F: Send + Sync + Fn(&mut dyn FnMut(&dyn Widget<Engine = E>)->Usually<()>)->Usually<()>
 >(pub F, PhantomData<E>);
@@ -62,7 +60,7 @@ pub struct Layers2<
 impl<
     E: Engine,
     F: Send + Sync + Fn(&mut dyn FnMut(&dyn Widget<Engine = E>)->Usually<()>)->Usually<()>
-> Layers2<E, F> {
+> Layers<E, F> {
     pub fn new (build: F) -> Self {
         Self(build, Default::default())
     }
@@ -73,25 +71,6 @@ impl<
     //pub &'a I
 //);
 
-pub struct Layered<'a, E: Engine>(pub Collection<'a, E>);
-
-impl<'a, E: Engine> Layered<'a, E> {
-    pub fn new () -> Self {
-        Self(Collection::new())
-    }
-}
-
-impl<'a, E: Engine> Collect<'a, E> for Layered<'a, E> {
-    fn add_box (mut self, item: Box<dyn Widget<Engine = E> + 'a>) -> Self {
-        self.0 = self.0.add_box(item);
-        self
-    }
-    fn add_ref (mut self, item: &'a dyn Widget<Engine = E>) -> Self {
-        self.0 = self.0.add_ref(item);
-        self
-    }
-}
-
 #[derive(Copy, Clone)]
 pub enum Direction { Up, Down, Left, Right }
 

crates/tek_core/src/engine/component.rs

@@ -3,7 +3,10 @@ use crate::*;
 pub trait Widget: Send + Sync {
     type Engine: Engine;
     fn layout (&self, to: <<Self as Widget>::Engine as Engine>::Area) ->
-        Perhaps<<<Self as Widget>::Engine as Engine>::Area>;
+        Perhaps<<<Self as Widget>::Engine as Engine>::Area>
+    {
+        Ok(Some(to))
+    }
     fn render (&self, to: &mut Self::Engine) ->
         Perhaps<<<Self as Widget>::Engine as Engine>::Area>;
 }
@@ -86,7 +89,10 @@ impl<E: Engine, W: Content<Engine = E>> Widget for W {
         self.content().layout(to)
     }
     fn render (&self, to: &mut E) -> Perhaps<E::Area> {
-        self.content().render(to)
+        match self.layout(to.area())? {
+            Some(area) => to.render_in(area, &self.content()),
+            None => Ok(None)
+        }
     }
 }
 

crates/tek_core/src/tui.rs

@@ -58,6 +58,16 @@ impl Engine for Tui {
         self.with_rect([x, y, w, h]);
         self
     }
+    #[inline]
+    fn render_in (
+        &mut self, area: [u16;4], widget: &impl Widget<Engine = Self>
+    ) -> Perhaps<[u16;4]> {
+        let last = self.area;
+        self.area = area;
+        let next = widget.render(self)?;
+        self.area = last;
+        Ok(next)
+    }
 }
 impl Tui {
     /// Run the main loop.

crates/tek_core/src/tui/tui_layout.rs

@@ -53,56 +53,21 @@ impl<'a> Split<'a, Tui> {
     }
 }
 
-impl<'a, const N: usize> Widget for Layers<'a, Tui, N> {
-    type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
-        let [x, y, ..] = area;
-        let mut w = 0;
-        let mut h = 0;
-        for layer in self.0.iter() {
-            if let Some(layer_area) = layer.layout(area)? {
-                w = w.max(layer_area.w());
-                h = h.max(layer_area.h());
-            }
-        }
-        Ok(Some([x, y, w, h]))
-    }
-    fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
-        self.layout(to.area())?
-            .map(|area| {
-                for layer in self.0.iter() {
-                    layer.render(to.with_rect(area))?;
-                }
-                Ok(area)
-            })
-            .transpose()
-    }
-}
-
-impl<F> Widget for Layers2<Tui, F>
+impl<F> Widget for Layers<Tui, F>
 where
     F: Send + Sync + Fn(&mut dyn FnMut(&dyn Widget<Engine = Tui>)->Usually<()>)->Usually<()>
 {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
-        let [x, y, ..] = area;
-        let mut w = 0;
-        let mut h = 0;
-        (self.0)(&mut |layer| {
-            if let Some(layer_area) = layer.layout(area)? {
-                w = w.max(layer_area.w());
-                h = h.max(layer_area.h());
-            }
-            Ok(())
-        })?;
-        Ok(Some([x, y, w, h]))
-    }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
-        self.layout(to.area())?
-            .map(|area|(self.0)(&mut |layer| {
-                layer.render(to.with_rect(area))?;
-                Ok(())
-            }).map(|_|area))
+        let area = to.area();
+        to.blit(&format!("L1 {area:?}"), 10, 10, None)?;
+        let area = self.layout(to.area())?;
+        to.blit(&format!("L2 {area:?}"), 10, 11, None)?;
+        area.map(|area|(self.0)(&mut |layer| {
+            to.blit(&format!("L3 {area:?}"), 10, 12, None)?;
+            to.render_in(area, &layer)?;
+            Ok(())
+        }).map(|_|area))
             .transpose()
     }
 }
@@ -129,8 +94,7 @@ impl<T: Widget<Engine = Tui>> Widget for Align<T> {
     }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
         self.layout(to.area())?
-            .map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
-            .map(|to|self.inner().render(to))
+            .map(|area|to.render_in(area, self.inner()))
             .transpose()
             .map(|x|x.flatten())
     }

crates/tek_mixer/src/mixer.rs

@@ -25,7 +25,7 @@ impl<E: Engine> Mixer<E> {
         self.tracks.get(self.selected_track)
     }
 }
-impl<E: Engine> Process for Mixer<E> {
+impl<E: Engine> Audio for Mixer<E> {
     fn process (&mut self, _: &Client, _: &ProcessScope) -> Control {
         Control::Continue
     }

crates/tek_mixer/src/plugin.rs

@@ -39,7 +39,7 @@ impl<E> Plugin<E> {
     }
 }
 
-impl<E> Process for Plugin<E> {
+impl<E> Audio for Plugin<E> {
     fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
         match self.plugin.as_mut() {
             Some(PluginKind::LV2(LV2Plugin {

crates/tek_mixer/src/sample_add.rs

@@ -22,7 +22,11 @@ pub struct AddSampleModal {
 
 exit!(AddSampleModal);
 
-impl Render<Tui> for AddSampleModal {
+impl Widget for AddSampleModal {
+    type Engine = Tui;
+    fn layout (&self, to: [u16;4]) -> Perhaps<[u16;4]> {
+        todo!()
+    }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
         let area = to.area();
         to.make_dim();

crates/tek_mixer/src/sampler.rs

@@ -13,7 +13,6 @@ pub struct Sampler {
     pub modal:       Arc<Mutex<Option<Box<dyn Exit + Send>>>>,
     pub output_gain: f32
 }
-process!(Sampler = Sampler::process);
 
 impl Sampler {
     pub fn from_edn <'e> (args: &[Edn<'e>]) -> Usually<JackDevice<Tui>> {
@@ -83,14 +82,6 @@ impl Sampler {
         None
     }
 
-    pub fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
-        self.process_midi_in(scope);
-        self.clear_output_buffer();
-        self.process_audio_out(scope);
-        self.write_output_buffer(scope);
-        Control::Continue
-    }
-
     /// Create [Voice]s from [Sample]s in response to MIDI input.
     fn process_midi_in (&mut self, scope: &ProcessScope) {
         for RawMidi { time, bytes } in self.ports.midi_ins.get("midi").unwrap().iter(scope) {
@@ -144,8 +135,12 @@ impl Sampler {
     }
 }
 
-impl Layout<Tui> for Sampler {
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
-        todo!()
+impl Audio for Sampler {
+    fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
+        self.process_midi_in(scope);
+        self.clear_output_buffer();
+        self.process_audio_out(scope);
+        self.write_output_buffer(scope);
+        Control::Continue
     }
 }

crates/tek_mixer/src/sampler_view.rs

@@ -1,6 +1,10 @@
 use crate::*;
 
-impl Render<Tui> for Sampler {
+impl Widget for Sampler {
+    type Engine = Tui;
+    fn layout (&self, to: [u16;4]) -> Perhaps<[u16;4]> {
+        todo!()
+    }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
         tui_render_sampler(self, to)
     }

crates/tek_sequencer/src/arranger_view_h.rs

@@ -4,17 +4,17 @@ pub fn draw (state: &Arranger<Tui>, to: &mut Tui) -> Perhaps<[u16;4]> {
     let area = to.area();
     let area = [area.x(), area.y(), area.w(), area.h().min((2 + state.tracks.len() * 2) as u16)];
     let tracks = state.tracks.as_slice();
-    Layers([
-        &state.focused.then_some(FillBg(COLOR_BG0)),
-        &Split::right()
+    Layers::new(|add|{
+        add(&state.focused.then_some(FillBg(COLOR_BG0)))?;
+        add(&Split::right()
             .add(TrackNameColumn(tracks, state.selected))
             .add(TrackMonitorColumn(tracks))
             .add(TrackRecordColumn(tracks))
             .add(TrackOverdubColumn(tracks))
             .add(TrackEraseColumn(tracks))
             .add(TrackGainColumn(tracks))
-            .add(TrackScenesColumn(tracks, state.scenes.as_slice(), state.selected))
-    ]).render(to.with_rect(area))
+            .add(TrackScenesColumn(tracks, state.scenes.as_slice(), state.selected)))
+    }).render(to.with_rect(area))
 }
 
 struct TrackNameColumn<'a>(&'a [Sequencer<Tui>], ArrangerFocus);

crates/tek_sequencer/src/arranger_view_v.rs

@@ -38,24 +38,21 @@ pub fn draw <'a, 'b> (
     let offset = 3 + scene_name_max_len(state.scenes.as_ref()) as u16;
     let tracks = state.tracks.as_ref();
     let scenes = state.scenes.as_ref();
-    Layers([
+    Layers::new(|add|{
         //.add_ref(&FillBg(Color::Rgb(30, 33, 36)))//COLOR_BG1))//bg_lo(state.focused, state.entered)))
-        &ColumnSeparators(offset, cols),
-        &RowSeparators(rows),
-        &CursorFocus(state.selected, offset, cols, rows),
-        &Split::down()
+        add(&ColumnSeparators(offset, cols))?;
+        add(&RowSeparators(rows))?;
+        add(&CursorFocus(state.selected, offset, cols, rows))?;
+        add(&Split::down()
             .add_ref(&TracksHeader(offset, cols, tracks))
-            .add_ref(&SceneRows(offset, cols, rows, tracks, scenes))
-    ]).render(to.with_rect(area))
+            .add_ref(&SceneRows(offset, cols, rows, tracks, scenes)))
+    }).render(to.with_rect(area))
 }
 
 struct ColumnSeparators<'a>(u16, &'a [(usize, usize)]);
 
 impl<'a> Widget for ColumnSeparators<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
-        todo!()
-    }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
         let area = to.area();
         let Self(offset, cols) = self;
@@ -74,9 +71,6 @@ struct RowSeparators<'a>(&'a [(usize, usize)]);
 
 impl<'a> Widget for RowSeparators<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
-        todo!()
-    }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
         let area = to.area();
         let Self(rows) = self;
@@ -101,9 +95,6 @@ struct CursorFocus<'a>(
 
 impl<'a> Widget for CursorFocus<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
-        todo!()
-    }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
         let area = to.area();
         let Self(selected, offset, cols, rows) = *self;
@@ -171,9 +162,6 @@ struct TracksHeader<'a>(u16, &'a[(usize, usize)], &'a [Sequencer<Tui>]);
 
 impl<'a> Widget for TracksHeader<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
-        todo!()
-    }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
         let area = to.area();
         let Self(offset, track_cols, tracks) = *self;
@@ -195,9 +183,6 @@ struct SceneRows<'a>(u16, &'a[(usize, usize)], &'a[(usize, usize)], &'a[Sequence
 
 impl<'a> Widget for SceneRows<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
-        todo!()
-    }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
         let area = to.area();
         let Self(offset, track_cols, scene_rows, tracks, scenes) = *self;
@@ -228,9 +213,6 @@ struct SceneRow<'a>(&'a[Sequencer<Tui>], &'a Scene, &'a[(usize, usize)], u16);
 
 impl<'a> Widget for SceneRow<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
-        todo!()
-    }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
         let area = to.area();
         let Self(tracks, scene, track_cols, offset) = self;
@@ -258,9 +240,6 @@ struct SceneClip<'a>(&'a Sequencer<Tui>, usize);
 
 impl<'a> Widget for SceneClip<'a> {
     type Engine = Tui;
-    fn layout (&self, area: [u16;4]) -> Perhaps<[u16;4]> {
-        todo!()
-    }
     fn render (&self, to: &mut Tui) -> Perhaps<[u16;4]> {
         let area = to.area();
         let Self(track, clip) = self;

crates/tek_sequencer/src/sequencer_view_h.rs

@@ -15,13 +15,13 @@ impl Sequencer<Tui> {
         let area = [area.x() + 10, area.y(), area.w().saturating_sub(10), area.h().min(66)];
         Lozenge(Style::default().fg(Nord::BG2)).draw(to.with_rect(area))?;
         let area = [area.x() + 1, area.y(), area.w().saturating_sub(1), area.h()];
-        Layers([
-            &SequenceKeys(&self),
-            &self.phrase.as_ref().map(|phrase|SequenceTimer(&self, phrase.clone())),
-            &SequenceNotes(&self),
-            &SequenceCursor(&self),
-            &SequenceZoom(&self),
-        ]).render(to.with_rect(area))?;
+        Layers::new(|add|{
+            add(&SequenceKeys(&self))?;
+            add(&self.phrase.as_ref().map(|phrase|SequenceTimer(&self, phrase.clone())))?;
+            add(&SequenceNotes(&self))?;
+            add(&SequenceCursor(&self))?;
+            add(&SequenceZoom(&self))
+        }).render(to.with_rect(area))?;
         Ok(())
     }
 

crates/tek_sequencer/src/transport.rs

@@ -181,7 +181,7 @@ impl Focusable<Tui> for TransportToolbar<Tui> {
         self.focused = focused
     }
 }
-impl<E: Engine> Process for TransportToolbar<E> {
+impl<E: Engine> Audio for TransportToolbar<E> {
     fn process (&mut self, _: &Client, scope: &ProcessScope) -> Control {
         self.update(&scope);
         Control::Continue

crates/tek_sequencer/src/transport_view.rs

@@ -17,7 +17,7 @@ impl Content for TransportToolbar<Tui> {
 impl Content for TransportPlayPauseButton<Tui> {
     type Engine = Tui;
     fn content (&self) -> impl Widget<Engine = Tui> {
-        Layers2::new(|add|{
+        Layers::new(|add|{
             //add(&self.focused.then_some(CORNERS))?;
             add(&Styled(match self.value {
                 Some(TransportState::Stopped)  => Some(GRAY_DIM.bold()),

crates/tek_test/src/main.rs

@@ -34,10 +34,16 @@ impl Demo<Tui> {
 impl Content for Demo<Tui> {
     type Engine = Tui;
     fn content (&self) -> impl Widget<Engine = Tui> {
-        Layers2::new(|add|{
-            add(&Align::Center("FOOBAR"))?;
-            add(&Align::Center("FOO"))?;
-            Ok(())
+        //Align::Center("FOO")
+        //Layers2::new(|_|Ok(()))
+        //Layers2::new(|add|add(&Align::Center("FOO")))
+        Layers::new(|add|{
+            add(&FillBg(Color::Rgb(0,128,128)))?;
+            add(&Layers::new(|add|{
+                add(&Align::Center("....."))?;
+                add(&Align::Center("FOO"))?;
+                Ok(())
+            }))
         })
         //Align::Center(&self.items[self.index] as &dyn Widget<Engine = Tui>)
     }