separate Input and Output impls

engine/src/content.rs

@@ -1,23 +1,22 @@
 use crate::*;
 /// Build a [Render]able out of other [Render]ables,
 /// then apply optional custom render/layout on top.
-pub trait Content<E: Engine>: Send + Sync + Sized {
+pub trait Content<E: Output>: Send + Sync + Sized {
     fn content (&self) -> impl Render<E> { () }
     fn layout (&self, area: E::Area) -> E::Area { self.content().layout(area) }
-    fn render (&self, output: &mut E::Output) { self.content().render(output) }
+    fn render (&self, output: &mut E) { self.content().render(output) }
 }
-impl<E: Engine, C: Content<E>> Content<E> for &C {
+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::Output) { (*self).render(output) }
+    fn render (&self, output: &mut E) { (*self).render(output) }
 }
 /// The platonic ideal unit of [Content]: total emptiness at dead center.
-impl<E: Engine> Content<E> for () {
+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::Output) {}
+    fn render (&self, _: &mut E) {}
 }
-
-impl<E: Engine, T: Content<E>> Content<E> for Option<T> {
+impl<E: Output, T: Content<E>> Content<E> for Option<T> {
     fn content (&self) -> impl Render<E> {
         self.as_ref()
     }
@@ -26,8 +25,22 @@ impl<E: Engine, T: Content<E>> Content<E> for Option<T> {
             .map(|content|content.layout(area))
             .unwrap_or([0.into(), 0.into(), 0.into(), 0.into(),].into())
     }
-    fn render (&self, output: &mut E::Output) {
+    fn render (&self, output: &mut E) {
         self.as_ref()
             .map(|content|content.render(output));
     }
 }
+//impl<E: Output, T: Content<E>, E: 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));
+    //}
+//}

engine/src/engine.rs

@@ -3,17 +3,9 @@ use crate::*;
 /// Platform backend.
 pub trait Engine: Send + Sync + Sized {
     /// Input event type
-    type Input: Input<Self>;
-    /// Result of handling input
-    type Handled;
+    type Input: Input;
     /// Render target
-    type Output: Output<Self>;
-    /// Unit of length
-    type Unit: Coordinate;
-    /// Rectangle without offset
-    type Size: Size<Self::Unit>;
-    /// Rectangle with offset
-    type Area: Area<Self::Unit>;
+    type Output: Output;
     /// Prepare before run
     fn setup (&mut self) -> Usually<()> { Ok(()) }
     /// True if done
@@ -21,3 +13,38 @@ pub trait Engine: Send + Sync + Sized {
     /// Clean up after run
     fn teardown (&mut self) -> Usually<()> { Ok(()) }
 }
+
+/// Event source
+pub trait Input: Send + Sync + Sized {
+    /// Type of input event
+    type Event;
+    /// Result of handling input
+    type Handled;
+    /// Currently handled event
+    fn event (&self) -> &Self::Event;
+    /// Whether component should exit
+    fn is_done (&self) -> bool;
+    /// Mark component as done
+    fn done (&self);
+}
+
+/// Render target
+pub trait Output: Send + Sync + Sized {
+    /// Unit of length
+    type Unit: Coordinate;
+    /// Rectangle without offset
+    type Size: Size<Self::Unit>;
+    /// Rectangle with offset
+    type Area: Area<Self::Unit>;
+    /// Current output area
+    fn area (&self) -> Self::Area;
+    /// Mutable pointer to area
+    fn area_mut (&mut self) -> &mut Self::Area;
+    /// Render widget in area
+    fn place (&mut self, area: Self::Area, content: &impl Render<Self>);
+    #[inline] fn x (&self) -> Self::Unit { self.area().x() }
+    #[inline] fn y (&self) -> Self::Unit { self.area().y() }
+    #[inline] fn w (&self) -> Self::Unit { self.area().w() }
+    #[inline] fn h (&self) -> Self::Unit { self.area().h() }
+    #[inline] fn wh (&self) -> Self::Size { self.area().wh().into() }
+}

engine/src/handle.rs

@@ -0,0 +1,61 @@
+use crate::*;
+use std::sync::{Mutex, Arc, RwLock};
+
+/// Implement the [Handle] trait.
+#[macro_export] macro_rules! handle {
+    (|$self:ident:$Struct:ty,$input:ident|$handler:expr) => {
+        impl<E: Engine> Handle<E> for $Struct {
+            fn handle (&mut $self, $input: &E) -> Perhaps<E::Handled> {
+                $handler
+            }
+        }
+    };
+    ($E:ty: |$self:ident:$Struct:ty,$input:ident|$handler:expr) => {
+        impl Handle<$E> for $Struct {
+            fn handle (&mut $self, $input: &$E) -> Perhaps<<$E as Input>::Handled> {
+                $handler
+            }
+        }
+    }
+}
+
+/// Handle input
+pub trait Handle<E: Input>: Send + Sync {
+    fn handle (&mut self, _input: &E) -> Perhaps<E::Handled> {
+        Ok(None)
+    }
+}
+impl<E: Input, H: Handle<E>> Handle<E> for &mut H {
+    fn handle (&mut self, context: &E) -> Perhaps<E::Handled> {
+        (*self).handle(context)
+    }
+}
+impl<E: Input, H: Handle<E>> Handle<E> for Option<H> {
+    fn handle (&mut self, context: &E) -> Perhaps<E::Handled> {
+        if let Some(ref mut handle) = self {
+            handle.handle(context)
+        } else {
+            Ok(None)
+        }
+    }
+}
+impl<H, E: Input> Handle<E> for Mutex<H> where H: Handle<E> {
+    fn handle (&mut self, context: &E) -> Perhaps<E::Handled> {
+        self.get_mut().unwrap().handle(context)
+    }
+}
+impl<H, E: Input> Handle<E> for Arc<Mutex<H>> where H: Handle<E> {
+    fn handle (&mut self, context: &E) -> Perhaps<E::Handled> {
+        self.lock().unwrap().handle(context)
+    }
+}
+impl<H, E: Input> Handle<E> for RwLock<H> where H: Handle<E> {
+    fn handle (&mut self, context: &E) -> Perhaps<E::Handled> {
+        self.write().unwrap().handle(context)
+    }
+}
+impl<H, E: Input> Handle<E> for Arc<RwLock<H>> where H: Handle<E> {
+    fn handle (&mut self, context: &E) -> Perhaps<E::Handled> {
+        self.write().unwrap().handle(context)
+    }
+}

engine/src/input.rs

@@ -1,17 +0,0 @@
-use crate::*;
-
-mod handle; pub use self::handle::*;
-mod command; pub use self::command::*;
-mod event_map; pub use self::event_map::*;
-
-/// Current input state
-pub trait Input<E: Engine> {
-    /// Type of input event
-    type Event;
-    /// Currently handled event
-    fn event (&self) -> &Self::Event;
-    /// Whether component should exit
-    fn is_done (&self) -> bool;
-    /// Mark component as done
-    fn done (&self);
-}

engine/src/input/handle.rs

@@ -1,53 +0,0 @@
-use crate::*;
-use std::sync::{Mutex, Arc, RwLock};
-
-#[macro_export] macro_rules! handle {
-    (<$E:ty>|$self:ident:$Struct:ty,$input:ident|$handler:expr) => {
-        impl Handle<$E> for $Struct {
-            fn handle (&mut $self, $input: &<$E as Engine>::Input) -> Perhaps<<$E as Engine>::Handled> {
-                $handler
-            }
-        }
-    }
-}
-
-/// Handle input
-pub trait Handle<E: Engine>: Send + Sync {
-    fn handle (&mut self, _input: &E::Input) -> Perhaps<E::Handled> {
-        Ok(None)
-    }
-}
-impl<E: Engine, H: Handle<E>> Handle<E> for &mut H {
-    fn handle (&mut self, context: &E::Input) -> Perhaps<E::Handled> {
-        (*self).handle(context)
-    }
-}
-impl<E: Engine, H: Handle<E>> Handle<E> for Option<H> {
-    fn handle (&mut self, context: &E::Input) -> Perhaps<E::Handled> {
-        if let Some(ref mut handle) = self {
-            handle.handle(context)
-        } else {
-            Ok(None)
-        }
-    }
-}
-impl<H, E: Engine> Handle<E> for Mutex<H> where H: Handle<E> {
-    fn handle (&mut self, context: &E::Input) -> Perhaps<E::Handled> {
-        self.get_mut().unwrap().handle(context)
-    }
-}
-impl<H, E: Engine> Handle<E> for Arc<Mutex<H>> where H: Handle<E> {
-    fn handle (&mut self, context: &E::Input) -> Perhaps<E::Handled> {
-        self.lock().unwrap().handle(context)
-    }
-}
-impl<H, E: Engine> Handle<E> for RwLock<H> where H: Handle<E> {
-    fn handle (&mut self, context: &E::Input) -> Perhaps<E::Handled> {
-        self.write().unwrap().handle(context)
-    }
-}
-impl<H, E: Engine> Handle<E> for Arc<RwLock<H>> where H: Handle<E> {
-    fn handle (&mut self, context: &E::Input) -> Perhaps<E::Handled> {
-        self.write().unwrap().handle(context)
-    }
-}

engine/src/lib.rs

@@ -2,8 +2,15 @@
 
 //mod component; pub use self::component::*;
 mod engine; pub use self::engine::*;
-mod input;  pub use self::input::*;
-mod output; pub use self::output::*;
+mod handle; pub use self::handle::*;
+mod command; pub use self::command::*;
+mod event_map; pub use self::event_map::*;
+mod coordinate; pub use self::coordinate::*;
+mod size; pub use self::size::*;
+mod area; pub use self::area::*;
+mod render;  pub use self::render::*;
+mod content; pub use self::content::*;
+mod thunk;   pub use self::thunk::*;
 
 pub use std::error::Error;
 

engine/src/output.rs

@@ -1,24 +0,0 @@
-use crate::*;
-
-mod coordinate; pub use self::coordinate::*;
-mod size; pub use self::size::*;
-mod area; pub use self::area::*;
-
-mod render;  pub use self::render::*;
-mod content; pub use self::content::*;
-mod thunk;   pub use self::thunk::*;
-
-/// Rendering target
-pub trait Output<E: Engine> {
-    /// Current output area
-    fn area (&self) -> E::Area;
-    /// Mutable pointer to area
-    fn area_mut (&mut self) -> &mut E::Area;
-    /// Render widget in area
-    fn place (&mut self, area: E::Area, content: &impl Render<E>);
-    #[inline] fn x (&self) -> E::Unit { self.area().x() }
-    #[inline] fn y (&self) -> E::Unit { self.area().y() }
-    #[inline] fn w (&self) -> E::Unit { self.area().w() }
-    #[inline] fn h (&self) -> E::Unit { self.area().h() }
-    #[inline] fn wh (&self) -> E::Size { self.area().wh().into() }
-}

engine/src/render.rs

@@ -2,64 +2,64 @@ use crate::*;
 use std::ops::Deref;
 
 /// Custom layout and rendering.
-pub trait Render<E: Engine>: Send + Sync {
+pub trait Render<E: Output>: Send + Sync {
     fn layout (&self, area: E::Area) -> E::Area;
-    fn render (&self, output: &mut E::Output);
+    fn render (&self, output: &mut E);
     fn boxed <'a> (self) -> RenderBox<'a, E> where Self: Sized + 'a {
         Box::new(self) as RenderBox<'a, E>
     }
 }
 
-pub type RenderDyn<'a, Engine> = dyn Render<Engine> + 'a;
-impl<'a, E: Engine> Content<E> for &RenderDyn<'a, E> where Self: Sized {
+pub type RenderDyn<'a, Output> = dyn Render<Output> + 'a;
+impl<'a, E: Output> Content<E> for &RenderDyn<'a, E> where Self: Sized {
     fn content (&self) -> impl Render<E> { *self }
     fn layout (&self, area: E::Area) -> E::Area { Render::layout(self.deref(), area) }
-    fn render (&self, output: &mut E::Output) { Render::render(self.deref(), output) }
+    fn render (&self, output: &mut E) { Render::render(self.deref(), output) }
 }
 
-pub type RenderBox<'a, E: Engine> = Box<RenderDyn<'a, E>>;
-impl<'a, E: Engine> Content<E> for RenderBox<'a, E> {
+pub type RenderBox<'a, E: Output> = Box<RenderDyn<'a, E>>;
+impl<'a, E: Output> Content<E> for RenderBox<'a, E> {
     fn content (&self) -> impl Render<E> { self.deref() }
 }
 
-impl<E: Engine, C: Content<E>> Render<E> for C {
+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::Output) { Content::render(self, output) }
+    fn render (&self, output: &mut E) { Content::render(self, output) }
 }
 
 #[macro_export] macro_rules! render {
     (($self:ident:$Struct:ty) => $content:expr) => {
-        impl <E: Engine> Content<E> for $Struct {
+        impl <E: Output> Content<E> for $Struct {
             fn content (&$self) -> impl Render<E> { Some($content) }
         }
     };
     (|$self:ident:$Struct:ident $(<
         $($L:lifetime),* $($T:ident $(:$Trait:path)?),*
     >)?, $to:ident | $render:expr) => {
-        impl <$($($L),*)? E: Engine, $($T$(:$Trait)?),*> Content<E>
+        impl <$($($L),*)? E: Output, $($T$(:$Trait)?),*> Content<E>
         for $Struct $(<$($L),* $($T),*>>)? {
-            fn render (&$self, $to: &mut E::Output) { $render }
+            fn render (&$self, $to: &mut E) { $render }
         }
     };
-    ($Engine:ty:
+    ($Output:ty:
         ($self:ident:$Struct:ident $(<$(
             $($L:lifetime)? $($T:ident)? $(:$Trait:path)?
         ),+>)?) => $content:expr
     ) => {
-        impl $(<$($($L)? $($T)? $(:$Trait)?),+>)? Content<$Engine>
+        impl $(<$($($L)? $($T)? $(:$Trait)?),+>)? Content<$Output>
         for $Struct $(<$($($L)? $($T)?),+>)? {
-            fn content (&$self) -> impl Render<$Engine> { $content }
+            fn content (&$self) -> impl Render<$Output> { $content }
         }
     };
 
-    ($Engine:ty:
+    ($Output:ty:
         |$self:ident : $Struct:ident $(<$(
             $($L:lifetime)? $($T:ident)? $(:$Trait:path)?
         ),+>)?, $to:ident| $render:expr
     ) => {
-        impl $(<$($($L)? $($T)? $(:$Trait)?),+>)? Content<$Engine>
+        impl $(<$($($L)? $($T)? $(:$Trait)?),+>)? Content<$Output>
         for $Struct $(<$($($L)? $($T)?),+>)? {
-            fn render (&$self, $to: &mut <$Engine as Engine>::Output) { $render }
+            fn render (&$self, $to: &mut $Output) { $render }
         }
     };
 }

engine/src/thunk.rs

@@ -1,10 +1,10 @@
 use crate::*;
 use std::marker::PhantomData;
 /// Lazily-evaluated [Render]able.
-pub struct Thunk<E: Engine, T: Render<E>, F: Fn()->T + Send + Sync>(F, PhantomData<E>);
-impl<E: Engine, T: Render<E>, F: Fn()->T + Send + Sync> Thunk<E, T, F> {
+pub struct Thunk<E: Output, T: Render<E>, F: Fn()->T + Send + Sync>(F, PhantomData<E>);
+impl<E: Output, T: Render<E>, F: Fn()->T + Send + Sync> Thunk<E, T, F> {
     pub fn new (thunk: F) -> Self { Self(thunk, Default::default()) }
 }
-impl<E: Engine, T: Render<E>, F: Fn()->T + Send + Sync> Content<E> for Thunk<E, T, F> {
+impl<E: Output, T: Render<E>, F: Fn()->T + Send + Sync> Content<E> for Thunk<E, T, F> {
     fn content (&self) -> impl Render<E> { (self.0)() }
 }