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())
     }