genericize layout rendering

crates/tek_core/src/audio.rs

@@ -19,7 +19,7 @@ pub trait Device<E: Engine>: Component<E> + Process {
 impl<D, E: Engine> Device<E> for D where D: Component<E> + Process {}
 
 impl<E: Engine> Render<E> for Box<dyn Device<E>> {
-    fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
+    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
         (**self).render(to)
     }
 }

crates/tek_core/src/audio/device.rs

@@ -17,7 +17,7 @@ impl<E: Engine> std::fmt::Debug for JackDevice<E> {
     }
 }
 impl<E: Engine> Render<E> for JackDevice<E> {
-    fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
+    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
         self.state.read().unwrap().render(to)
     }
 }

crates/tek_core/src/engine.rs

@@ -7,6 +7,28 @@ pub trait App<T: Engine> {
     fn run (self, context: T) -> Usually<T>;
 }
 
+/// Platform backend.
+pub trait Engine: Sized {
+    fn setup (&mut self) -> Usually<()> { Ok(()) }
+    fn exited (&self) -> bool;
+    fn teardown (&mut self) -> Usually<()> { Ok(()) }
+
+    /// Unit of distance.
+    type Unit: Number;
+    type Area: Rectangle<Self::Unit>;
+
+    type HandleInput;
+    type Handled;
+    type RenderInput;
+    type Rendered;
+
+    // FIXME
+    fn area (&self) -> Self::Area;
+    // FIXME
+    fn with_area (&mut self, x: Self::Unit, y: Self::Unit, w: Self::Unit, h: Self::Unit)
+        -> &mut Self;
+}
+
 pub trait Number: Send + Sync + Copy
     + Add<Self, Output=Self>
     + Sub<Self, Output=Self>
@@ -19,25 +41,6 @@ impl<T> Number for T where
         + Ord + PartialEq + Eq
 {}
 
-/// Platform backend.
-pub trait Engine: Sized {
-    fn setup (&mut self) -> Usually<()> { Ok(()) }
-    fn exited (&self) -> bool;
-    fn teardown (&mut self) -> Usually<()> { Ok(()) }
-
-    /// Unit of distance.
-    type Unit: Number;
-
-    type HandleInput;
-    type Handled;
-    type RenderInput;
-    type Rendered;
-}
-
-pub trait HandleContext {}
-
-pub trait RenderContext {}
-
 submod! {
     collect
     component

crates/tek_core/src/engine/collect.rs

@@ -6,7 +6,7 @@ pub enum Collected<'a, E: Engine> {
 }
 
 impl<'a, E: Engine> Render<E> for Collected<'a, E> {
-    fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
+    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
         match self {
             Self::Box(item) => (*item).render(to),
             Self::Ref(item) => (*item).render(to),

crates/tek_core/src/engine/layout.rs

@@ -1,7 +1,7 @@
 use crate::*;
 
 /// Compute drawing area before rendering 
-pub trait Layout<E: Engine> {
+pub trait Layout<E: Engine>: Render<E> {
     fn layout (&self, area: impl Rectangle<E::Unit>) -> Perhaps<impl Rectangle<E::Unit>>;
 }
 /// Enforce minimum size of drawing area
@@ -98,3 +98,73 @@ impl<E: Engine, L: Layout<E>> Layout<E> for Offset<E::Unit, L> {
         }
     }
 }
+
+impl<E: Engine, R: Render<E> + Layout<E>> Render<E> for Min<E::Unit, R> {
+    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
+        self.layout(to.area())?
+            .map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
+            .map(|to|match self {
+                Self::W(_, inner) => inner,
+                Self::H(_, inner) => inner,
+                Self::WH(_, _, inner) => inner,
+            }.render(to))
+            .transpose()
+            .map(|x|x.flatten())
+    }
+}
+
+impl<E: Engine, R: Render<E> + Layout<E>> Render<E> for Max<E::Unit, R> {
+    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
+        self.layout(to.area())?
+            .map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
+            .map(|to|match self {
+                Self::W(_, inner) => inner,
+                Self::H(_, inner) => inner,
+                Self::WH(_, _, inner) => inner,
+            }.render(to))
+            .transpose()
+            .map(|x|x.flatten())
+    }
+}
+
+impl<E: Engine, R: Render<E> + Layout<E>> Render<E> for Inset<E::Unit, R> {
+    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
+        self.layout(to.area())?
+            .map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
+            .map(|to|match self {
+                Self::W(_, inner) => inner,
+                Self::H(_, inner) => inner,
+                Self::WH(_, _, inner) => inner,
+            }.render(to))
+            .transpose()
+            .map(|x|x.flatten())
+    }
+}
+
+impl<E: Engine, R: Render<E> + Layout<E>> Render<E> for Outset<E::Unit, R> {
+    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
+        self.layout(to.area())?
+            .map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
+            .map(|to|match self {
+                Self::W(_, inner) => inner,
+                Self::H(_, inner) => inner,
+                Self::WH(_, _, inner) => inner,
+            }.render(to))
+            .transpose()
+            .map(|x|x.flatten())
+    }
+}
+
+impl<E: Engine, R: Render<E> + Layout<E>> Render<E> for Offset<E::Unit, R> {
+    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
+        self.layout(to.area())?
+            .map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
+            .map(|to|match self {
+                Self::X(_, inner) => inner,
+                Self::Y(_, inner) => inner,
+                Self::XY(_, _, inner) => inner,
+            }.render(to))
+            .transpose()
+            .map(|x|x.flatten())
+    }
+}

crates/tek_core/src/engine/render.rs

@@ -2,12 +2,12 @@ use crate::*;
 
 /// Render to output.
 pub trait Render<E: Engine>: Send + Sync {
-    fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered>;
+    fn render (&self, to: &mut E) -> Perhaps<E::Rendered>;
 }
 
 /// Options can be rendered optionally.
 impl<R, E: Engine> Render<E> for Option<R> where R: Render<E> {
-    fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
+    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
         match self {
             Some(component) => component.render(to),
             None => Ok(None)
@@ -17,42 +17,42 @@ impl<R, E: Engine> Render<E> for Option<R> where R: Render<E> {
 
 /// Boxed references can be rendered.
 impl<'a, E: Engine> Render<E> for Box<dyn Render<E> + 'a> {
-    fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
+    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
         (**self).render(to)
     }
 }
 
 /// Immutable references can be rendered.
 impl<R, E: Engine> Render<E> for &R where R: Render<E> {
-    fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
+    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
         (*self).render(to)
     }
 }
 
 /// Mutable references can be rendered.
 impl<R, E: Engine> Render<E> for &mut R where R: Render<E> {
-    fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
+    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
         (**self).render(to)
     }
 }
 
 /// Counted references can be rendered.
 impl<R, E: Engine> Render<E> for Arc<R> where R: Render<E> {
-    fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
+    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
         self.as_ref().render(to)
     }
 }
 
 /// References behind a [Mutex] can be rendered.
 impl<R, E: Engine> Render<E> for Mutex<R> where R: Render<E> {
-    fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
+    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
         self.lock().unwrap().render(to)
     }
 }
 
 /// References behind a [RwLock] can be rendered.
 impl<R, E: Engine> Render<E> for RwLock<R> where R: Render<E> {
-    fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
+    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
         self.read().unwrap().render(to)
     }
 }
@@ -62,8 +62,8 @@ impl<R, E: Engine> Render<E> for RwLock<R> where R: Render<E> {
 /// Rendering unboxed closures should also be possible;
 /// but in practice implementing the trait for an unboxed
 /// `Fn` closure causes an impl conflict.
-impl<'a, E: Engine> Render<E> for Box<dyn Fn(&mut E::RenderInput) -> Perhaps<E::Rendered> + Send + Sync + 'a> {
+impl<'a, E: Engine> Render<E> for Box<dyn Fn(&mut E) -> Perhaps<E::Rendered> + Send + Sync + 'a> {
-    fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
+    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
         (*self)(to)
     }
 }

crates/tek_core/src/tui.rs

@@ -26,6 +26,7 @@ pub struct Tui {
 }
 impl Engine for Tui {
     type Unit        = u16;
+    type Area        = Rect;
     type HandleInput = Self;
     type Handled     = bool;
     type RenderInput = Self;
@@ -47,6 +48,15 @@ impl Engine for Tui {
         stdout().execute(LeaveAlternateScreen)?;
         disable_raw_mode().map_err(Into::into)
     }
+    // FIXME
+    fn area (&self) -> Self::Area {
+        self.area
+    }
+    #[inline]
+    fn with_area (&mut self, x: u16, y: u16, w: u16, h: u16) -> &mut Self {
+        self.with_rect(Rect { x, y, width: w, height: h });
+        self
+    }
 }
 impl Tui {
     /// Run the main loop.
@@ -113,9 +123,6 @@ impl Tui {
     pub fn event (&self) -> TuiEvent {
         self.event.read().unwrap().clone().unwrap()
     }
-    pub fn area (&self) -> Rect {
-        self.area
-    }
     pub fn buffer (&mut self) -> &mut Buffer {
         &mut self.buffers[self.buffer]
     }
@@ -172,11 +179,6 @@ impl Tui {
         self.with_area(x, y, width, height)
     }
     #[inline]
-    pub fn with_area (&mut self, x: u16, y: u16, w: u16, h: u16) -> &mut Self {
-        self.with_rect(Rect { x, y, width: w, height: h });
-        self
-    }
-    #[inline]
     pub fn with_rect (&mut self, area: Rect) -> &mut Self {
         self.area = area;
         self
@@ -221,3 +223,11 @@ pub fn half_block (lower: bool, upper: bool) -> Option<char> {
         _ => None
     }
 }
+
+impl Rectangle<u16> for Rect {
+    fn x (&self) -> u16 { self.x }
+    fn y (&self) -> u16 { self.y }
+    fn w (&self) -> u16 { self.width }
+    fn h (&self) -> u16 { self.height }
+}
+

crates/tek_core/src/tui/tui_layout.rs

@@ -1,82 +1,5 @@
 use crate::*;
 
-impl Rectangle<u16> for Rect {
-    fn x (&self) -> u16 { self.x }
-    fn y (&self) -> u16 { self.y }
-    fn w (&self) -> u16 { self.width }
-    fn h (&self) -> u16 { self.height }
-}
-
-impl<R> Render<Tui> for Min<<Tui as Engine>::Unit, R> where R: Render<Tui> + Layout<Tui> {
-    fn render (&self, to: &mut Tui) -> Perhaps<Rect> {
-        self.layout(to.area())?
-            .map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
-            .map(|to|match self {
-                Self::W(_, inner) => inner,
-                Self::H(_, inner) => inner,
-                Self::WH(_, _, inner) => inner,
-            }.render(to))
-            .transpose()
-            .map(|x|x.flatten())
-    }
-}
-
-impl<R> Render<Tui> for Max<<Tui as Engine>::Unit, R> where R: Render<Tui> + Layout<Tui> {
-    fn render (&self, to: &mut Tui) -> Perhaps<Rect> {
-        self.layout(to.area())?
-            .map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
-            .map(|to|match self {
-                Self::W(_, inner) => inner,
-                Self::H(_, inner) => inner,
-                Self::WH(_, _, inner) => inner,
-            }.render(to))
-            .transpose()
-            .map(|x|x.flatten())
-    }
-}
-
-impl<R> Render<Tui> for Inset<<Tui as Engine>::Unit, R> where R: Render<Tui> + Layout<Tui> {
-    fn render (&self, to: &mut Tui) -> Perhaps<Rect> {
-        self.layout(to.area())?
-            .map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
-            .map(|to|match self {
-                Self::W(_, inner) => inner,
-                Self::H(_, inner) => inner,
-                Self::WH(_, _, inner) => inner,
-            }.render(to))
-            .transpose()
-            .map(|x|x.flatten())
-    }
-}
-
-impl<R> Render<Tui> for Outset<<Tui as Engine>::Unit, R> where R: Render<Tui> + Layout<Tui> {
-    fn render (&self, to: &mut Tui) -> Perhaps<Rect> {
-        self.layout(to.area())?
-            .map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
-            .map(|to|match self {
-                Self::W(_, inner) => inner,
-                Self::H(_, inner) => inner,
-                Self::WH(_, _, inner) => inner,
-            }.render(to))
-            .transpose()
-            .map(|x|x.flatten())
-    }
-}
-
-impl<R> Render<Tui> for Offset<<Tui as Engine>::Unit, R> where R: Render<Tui> + Layout<Tui> {
-    fn render (&self, to: &mut Tui) -> Perhaps<Rect> {
-        self.layout(to.area())?
-            .map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
-            .map(|to|match self {
-                Self::X(_, inner) => inner,
-                Self::Y(_, inner) => inner,
-                Self::XY(_, _, inner) => inner,
-            }.render(to))
-            .transpose()
-            .map(|x|x.flatten())
-    }
-}
-
 impl<'a> Render<Tui> for Layered<'a, Tui> {
     fn render (&self, to: &mut Tui) -> Perhaps<Rect> {
         let area = to.area();
@@ -138,3 +61,46 @@ impl<'a> Split<'a, Tui> {
         Ok((Rect { x, y, width, height }, areas))
     }
 }
+
+// TODO
+//impl<'a> Split<'a, Tui> {
+    //pub fn render_areas (&self, to: &mut Tui)
+        //-> Usually<(Rectangle<Tui>, Vec<Option<Rectangle<Tui>>>)>
+    //{
+        //let area = to.area();
+        //let mut w = 0u16;
+        //let mut h = 0u16;
+        //let mut areas = vec![];
+        //Ok((match self.direction {
+            //Direction::Down => {
+                //for component in self.items.0.iter() {
+                    //if h >= area.h() {
+                        //break
+                    //}
+                    //let result = Offset::Y(h, component).render(to)?;
+                    //areas.push(result);
+                    //if let Some(Rect { width, height, .. }) = result {
+                        //h += height;
+                        //w = w.max(width)
+                    //}
+                //}
+                //(area.x(), area.y(), w, h)
+            //},
+            //Direction::Right => {
+                //for component in self.items.0.iter() {
+                    //if w >= area.x() {
+                        //break
+                    //}
+                    //let result = Offset::X(w, component).render(to)?;
+                    //areas.push(result);
+                    //if let Some(Rect { width, height, .. }) = result {
+                        //w += width;
+                        //h = h.max(height)
+                    //}
+                //}
+                //(area.x(), area.y(), w, h)
+            //},
+            //_ => todo!()
+        //}, areas))
+    //}
+//}