output: remodularize

output/src/output.rs

@@ -21,131 +21,3 @@ pub trait Output: Send + Sync + Sized {
     #[inline] fn h (&self) -> Self::Unit { self.area().h() }
     #[inline] fn wh (&self) -> Self::Size { self.area().wh().into() }
 }
-
-/// Renderable with dynamic dispatch.
-pub trait Render<E: Output> {
-    /// Compute layout.
-    fn layout (&self, area: E::Area) -> E::Area;
-    /// Write data to display.
-    fn render (&self, output: &mut E);
-    /// Perform type erasure, turning `self` into an opaque [RenderBox].
-    fn boxed <'a> (self) -> Box<dyn Render<E> + 'a> where Self: Sized + 'a {
-        Box::new(self) as Box<dyn Render<E> + 'a>
-    }
-}
-
-/// Most importantly, every [Content] is also a [Render].
-///
-/// However, the converse does not hold true.
-/// Instead, the [Content::content] method returns an
-/// opaque [Render] pointer.
-impl<E: Output, C: Content<E>> Render<E> for C {
-    fn layout (&self, area: E::Area) -> E::Area { Content::layout(self, area) }
-    fn render (&self, output: &mut E) { Content::render(self, output) }
-}
-
-/// Opaque pointer to a renderable living on the heap.
-///
-/// Return this from [Content::content] to use dynamic dispatch.
-pub type RenderBox<E> = Box<dyn Render<E>>;
-
-/// You can render from a box.
-impl<E: Output> Content<E> for RenderBox<E> {
-    fn content (&self) -> impl Render<E> + '_ { self.deref() }
-    //fn boxed <'b> (self) -> RenderBox<'b, E> where Self: Sized + 'b { self }
-}
-
-/// You can render from an opaque pointer.
-impl<E: Output> Content<E> for &dyn Render<E> where Self: Sized {
-    fn content (&self) -> impl Render<E> + '_ {
-        #[allow(suspicious_double_ref_op)]
-        self.deref()
-    }
-    fn layout (&self, area: E::Area) -> E::Area {
-        #[allow(suspicious_double_ref_op)]
-        Render::layout(self.deref(), area)
-    }
-    fn render (&self, output: &mut E) {
-        #[allow(suspicious_double_ref_op)]
-        Render::render(self.deref(), output)
-    }
-}
-
-/// Composable renderable with static dispatch.
-pub trait Content<E: Output> {
-    /// Return a [Render]able of a specific type.
-    fn content (&self) -> impl Render<E> + '_ { () }
-    /// Perform layout. By default, delegates to [Self::content].
-    fn layout (&self, area: E::Area) -> E::Area { self.content().layout(area) }
-    /// Draw to output. By default, delegates to [Self::content].
-    fn render (&self, output: &mut E) { self.content().render(output) }
-}
-
-/// Every pointer to [Content] is a [Content].
-impl<E: Output, C: Content<E>> Content<E> for &C {
-    fn content (&self) -> impl Render<E> + '_ { (*self).content() }
-    fn layout (&self, area: E::Area) -> E::Area { (*self).layout(area) }
-    fn render (&self, output: &mut E) { (*self).render(output) }
-}
-
-/// The platonic ideal unit of [Content]: total emptiness at dead center (e=1vg^sqrt(-1))
-impl<E: Output> Content<E> for () {
-    fn layout (&self, area: E::Area) -> E::Area { area.center().to_area_pos().into() }
-    fn render (&self, _: &mut E) {}
-}
-
-impl<E: Output, T: Content<E>> Content<E> for Option<T> {
-    fn content (&self) -> impl Render<E> + '_ {
-        self.as_ref()
-    }
-    fn layout (&self, area: E::Area) -> E::Area {
-        self.as_ref()
-            .map(|content|content.layout(area))
-            .unwrap_or([0.into(), 0.into(), 0.into(), 0.into(),].into())
-    }
-    fn render (&self, output: &mut E) {
-        self.as_ref()
-            .map(|content|content.render(output));
-    }
-}
-
-/// Implement [Content] with composable content for a struct.
-#[macro_export] macro_rules! content {
-    // Implement for all [Output]s.
-    (|$self:ident:$Struct:ty| $content:expr) => {
-        impl<E: Output> Content<E> for $Struct {
-            fn content (&$self) -> impl Render<E> + '_ { Some($content) }
-        }
-    };
-    // Implement for specific [Output].
-    ($Output:ty:|
-        $self:ident:
-        $Struct:ident$(<$($($L:lifetime)? $($T:ident)? $(:$Trait:path)?),+>)?
-    |$content:expr) => {
-        impl $(<$($($L)? $($T)? $(:$Trait)?),+>)? Content<$Output>
-        for $Struct $(<$($($L)? $($T)?),+>)? {
-            fn content (&$self) -> impl Render<$Output> + '_ { $content }
-        }
-    };
-}
-
-/// Implement [Content] with custom rendering for a struct.
-#[macro_export] macro_rules! render {
-    (|$self:ident:$Struct:ident $(<
-        $($L:lifetime),* $($T:ident $(:$Trait:path)?),*
-    >)?, $to:ident | $render:expr) => {
-        impl <$($($L),*)? E: Output, $($T$(:$Trait)?),*> Content<E>
-        for $Struct $(<$($L),* $($T),*>>)? {
-            fn render (&$self, $to: &mut E) { $render }
-        }
-    };
-    ($Output:ty:|
-        $self:ident:
-        $Struct:ident $(<$($($L:lifetime)? $($T:ident)? $(:$Trait:path)?),+>)?, $to:ident
-    |$render:expr) => {
-        impl $(<$($($L)? $($T)? $(:$Trait)?),+>)? Content<$Output>
-        for $Struct $(<$($($L)? $($T)?),+>)? {
-            fn render (&$self, $to: &mut $Output) { $render }
-        }
-    };
-}