mirror of
https://codeberg.org/unspeaker/tek.git
synced 2025-12-06 11:46:41 +01:00
remove comment heap
This commit is contained in:
parent
73432a220a
commit
ca16a91015
1 changed files with 0 additions and 366 deletions
|
|
@ -114,369 +114,3 @@ impl<E: Engine, T: Content<E>, F: Fn()->T + Send + Sync> Content<E> for Thunk<E,
|
|||
}
|
||||
};
|
||||
}
|
||||
|
||||
//impl<E: Engine, R: Render<E>> Render<E> for &R {}
|
||||
|
||||
//pub trait Render<E: Engine>: Send + Sync {
|
||||
//fn render (&self, _: &mut E::Output);
|
||||
//}
|
||||
|
||||
//impl<E: Engine, L: Layout<E>> Render<E> for L {
|
||||
//fn render (&self, to: &mut E::Output) {
|
||||
//if let Some(content) = self.layout() {
|
||||
//content.render(to)
|
||||
//}
|
||||
//}
|
||||
//}
|
||||
|
||||
//impl<E: Engine, L: Layout<E>> Layout<E> for &L {}
|
||||
|
||||
///// Something that can be represented by a renderable component.
|
||||
//pub trait Content<E: Engine>: Send + Sync {
|
||||
//fn content (&self) -> Option<impl Render<E>>;
|
||||
//}
|
||||
//impl<E: Engine, C: Content<E>> Content<E> for &C {
|
||||
//fn content (&self) -> Option<impl Render<E>> {
|
||||
//(*self).content()
|
||||
//}
|
||||
//}
|
||||
|
||||
///// Something that writes to an [Output].
|
||||
//pub trait Render<E: Engine>: Send + Sync {
|
||||
///// Minimum size to use
|
||||
//fn min_size (&self, _: E::Size) -> Perhaps<E::Size> {
|
||||
//Ok(None)
|
||||
//}
|
||||
///// Draw to output render target
|
||||
//fn render (&self, _: &mut E::Output) -> Usually<()> {
|
||||
//Ok(())
|
||||
//}
|
||||
//}
|
||||
//impl<E: Engine> Render<E> for &dyn Render<E> {
|
||||
//fn min_size (&self, to: E::Size) -> Perhaps<E::Size> { (*self).min_size(to) }
|
||||
//fn render (&self, to: &mut E::Output) -> Usually<()> { (*self).render(to) }
|
||||
//}
|
||||
//impl<E: Engine, R: Render<E>> Render<E> for &R {
|
||||
//fn min_size (&self, to: E::Size) -> Perhaps<E::Size> { (*self).min_size(to) }
|
||||
//fn render (&self, to: &mut E::Output) -> Usually<()> { (*self).render(to) }
|
||||
//}
|
||||
//impl<E: Engine, R: Render<E>> Render<E> for Option<R> {
|
||||
//fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
//if let Some(content) = self {
|
||||
//content.min_size(to)
|
||||
//} else {
|
||||
//Ok(None)
|
||||
//}
|
||||
//}
|
||||
//fn render (&self, to: &mut E::Output) -> Usually<()> {
|
||||
//if let Some(content) = self {
|
||||
//content.render(to)?;
|
||||
//}
|
||||
//Ok(())
|
||||
//}
|
||||
//}
|
||||
|
||||
///// Define custom content for a struct.
|
||||
/////
|
||||
///// This code wires the `Content` and `Render` traits together,
|
||||
///// since the only way to have the cake and eat it too is by
|
||||
///// implementing both traits for a given renderable.
|
||||
//#[macro_export] macro_rules! render {
|
||||
|
||||
//// Implement from [Content] for all [Engine]s
|
||||
//(|$self:ident:$Struct:ident$(<$($L:lifetime),*E$(,$T:ident$(:$U:path)?)*$(,)?>)?|$cb:expr) => {
|
||||
//impl<E: Engine, $($($L),*$($T $(: $U)?),*)?> Content<E> for $Struct $(<$($L,)* E, $($T),*>)? {
|
||||
//fn content (&$self) -> Option<impl Render<$E>> { Some($cb) }
|
||||
//}
|
||||
//impl<E: Engine, $($($L),*$($T $(: $U)?),*)?> Render<E> for $Struct $(<$($L,)* E, $($T),*>)? {
|
||||
//fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
//self.content().unwrap().min_size(to)
|
||||
//}
|
||||
//fn render (&self, to: &mut E::Output) -> Usually<()> {
|
||||
//self.content().unwrap().render(to)
|
||||
//}
|
||||
//}
|
||||
//};
|
||||
|
||||
//// Implement from [min_size] and [render] callbacks for all engines
|
||||
//($Struct:ident$(<$($L:lifetime),*E$(,$T:ident$(:$U:path)?)*$(,)?>)?
|
||||
//|$self1:ident, $to1:ident|$min_size:expr,
|
||||
//|$self2:ident, $to2:ident|$render:expr) =>
|
||||
//{
|
||||
//impl<E: Engine, $($($L),*$($T $(: $U)?),*)?> Content<E> for $Struct $(<$($L,)* E, $($T),*>)? {
|
||||
//fn content (&self) -> Option<impl Render<E>> { Some(self) }
|
||||
//}
|
||||
//impl<E: Engine, $($($L),*$($T $(: $U)?),*)?> Render<E> for $Struct $(<$($L,)* E, $($T),*>)? {
|
||||
//fn min_size (&$self1, $to1: E::Size) -> Perhaps<E::Size> { $min_size }
|
||||
//fn render (&$self2, $to2: &mut E::Output) -> Usually<()> { $render }
|
||||
//}
|
||||
//};
|
||||
|
||||
//// Implement from [Content] for a particular [Engine]
|
||||
//(<$E:ty>|$self:ident:$Struct:ident$(<
|
||||
//$($($L:lifetime),+)?
|
||||
//$($($T:ident$(:$U:path)?),+)?
|
||||
//>)?|$cb:expr) => {
|
||||
//impl $(<
|
||||
//$($($L),+)?
|
||||
//$($($T$(:$U)?),+)?
|
||||
//>)? Content<$E> for $Struct $(<
|
||||
//$($($L),+)?
|
||||
//$($($T),+)?
|
||||
//>)? {
|
||||
//fn content (&$self) -> Option<impl Render<$E>> {
|
||||
//Some($cb)
|
||||
//}
|
||||
//}
|
||||
//impl $(<
|
||||
//$($($L),+)?
|
||||
//$($($T$(:$U)?),+)?
|
||||
//>)? Render<$E> for $Struct $(<
|
||||
//$($($L),+)?
|
||||
//$($($T),+)?
|
||||
//>)? {
|
||||
//fn min_size (&self, to: <$E as Engine>::Size) -> Perhaps<<$E as Engine>::Size> {
|
||||
//self.content().map(|content|content.min_size(to)).unwrap_or(Ok(None))
|
||||
//}
|
||||
//fn render (&self, to: &mut <$E as Engine>::Output) -> Usually<()> {
|
||||
//self.content().map(|content|content.render(to)).unwrap_or(Ok(()))
|
||||
//}
|
||||
//}
|
||||
//};
|
||||
|
||||
//// Implement from [min_size] and [render] callbacks for a particular [Engine]
|
||||
//(<$E:ty>($self:ident:$Struct:ident$(<$($L:lifetime),*$(,$T:ident$(:$U:path)?)*$(,)?>)?)
|
||||
//|$to1:ident|$min_size:expr, |$to2:ident|$render:expr) =>
|
||||
//{
|
||||
//impl $(<
|
||||
//$($L),* $($($T$(:$U)?),+)?
|
||||
//>)? Content<$E> for $Struct $(<
|
||||
//$($L),* $($($T),+)?
|
||||
//>)? {
|
||||
//fn content (&self) -> Option<impl Render<$E>> { Some(self) }
|
||||
//}
|
||||
//impl $(<
|
||||
//$($L),* $($($T$(:$U)?),+)?
|
||||
//>)? Render<$E> for $Struct $(<
|
||||
//$($L),* $($($T),+)?
|
||||
//>)? {
|
||||
//fn min_size (&$self, $to1: <$E as Engine>::Size) -> Perhaps<<$E as Engine>::Size> {
|
||||
//$min_size
|
||||
//}
|
||||
//fn render (&$self, $to2: &mut <$E as Engine>::Output) -> Usually<()> {
|
||||
//$render
|
||||
//}
|
||||
//}
|
||||
//}
|
||||
|
||||
//}
|
||||
|
||||
////impl<E: Engine, C: Content<E>> Content<E> for &mut C {}
|
||||
////impl<E: Engine, C: Content<E>> Content<E> for Option<C> {}
|
||||
////impl<E: Engine, C: Content<E>> Content<E> for Arc<C> {}
|
||||
////impl<E: Engine, C: Content<E>> Content<E> for Mutex<C> {}
|
||||
////impl<E: Engine, C: Content<E>> Content<E> for RwLock<C> {}
|
||||
|
||||
////impl<E: Engine, C: Content<E>> Render<E> for C {}
|
||||
|
||||
////impl<E: Engine, C: Content<E>> Render<E> for C {
|
||||
/////// Minimum size to use
|
||||
////fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
////self.content().map(|content|content.min_size(to))
|
||||
////.unwrap_or(Ok(None))
|
||||
////}
|
||||
/////// Draw to output render target
|
||||
////fn render (&self, to: &mut E::Output) -> Usually<()> {
|
||||
////self.content().map(|content|content.render(to))
|
||||
////.unwrap_or(Ok(()))
|
||||
////}
|
||||
////}
|
||||
|
||||
//[>***
|
||||
|
||||
|
||||
//impl<E: Engine, R: Render<E> + Send + Sync> Content<E> for R {}
|
||||
|
||||
////impl<E: Engine, R: Render<E>> Content<E> for R {
|
||||
////fn content (&self) -> Option<impl Render<E>> {
|
||||
////Some(self)
|
||||
////}
|
||||
////}
|
||||
|
||||
///// All implementors of [Content] can be [Render]ed.
|
||||
//impl<E: Engine, C: Content<E>> Render<E> for C {
|
||||
///// Minimum size to use
|
||||
//fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
//self.content().map(|content|content.min_size(to))
|
||||
//.unwrap_or(Ok(None))
|
||||
//}
|
||||
///// Draw to output render target
|
||||
//fn render (&self, to: &mut E::Output) -> Usually<()> {
|
||||
//self.content().map(|content|content.render(to))
|
||||
//.unwrap_or(Ok(()))
|
||||
//}
|
||||
//}
|
||||
|
||||
////impl<E: Engine, C: Content<E>> Content<E> for &C {
|
||||
////fn content (&self) -> Option<impl Render<E>> {
|
||||
////Some(self)
|
||||
////}
|
||||
////}
|
||||
|
||||
////impl<E: Engine, C: Content<E>> Content<E> for Option<C> {
|
||||
////fn content (&self) -> Option<impl Render<E>> {
|
||||
////Some(self)
|
||||
////}
|
||||
////}
|
||||
|
||||
|
||||
//impl<E: Engine, R: Render<E>> Render<E> for &R {
|
||||
//fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
//(*self).min_size(to)
|
||||
//}
|
||||
//fn render (&self, to: &mut E::Output) -> Usually<()> {
|
||||
//(*self).render(to)
|
||||
//}
|
||||
//}
|
||||
|
||||
//impl<E: Engine, R: Render<E>> Render<E> for Option<R> {
|
||||
//fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
//self.map(|content|content.min_size(to))
|
||||
//.unwrap_or(Ok(None))
|
||||
//}
|
||||
//fn render (&self, to: &mut E::Output) -> Usually<()> {
|
||||
//self.map(|content|content.render(to))
|
||||
//.unwrap_or(Ok(()))
|
||||
//}
|
||||
//}
|
||||
|
||||
////impl<E: Engine> Render<E> for &dyn Render<E> {
|
||||
////fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
////(*self).min_size(to)
|
||||
////}
|
||||
////fn render (&self, to: &mut E::Output) -> Usually<()> {
|
||||
////(*self).render(to)
|
||||
////}
|
||||
////}
|
||||
|
||||
////impl<E: Engine> Render<E> for &mut dyn Render<E> {
|
||||
////fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
////(*self).min_size(to)
|
||||
////}
|
||||
////fn render (&self, to: &mut E::Output) -> Usually<()> {
|
||||
////(*self).render(to)
|
||||
////}
|
||||
////}
|
||||
|
||||
////impl<E: Engine> Render<E> for Box<dyn Render<E> + '_> {
|
||||
////fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
////(**self).min_size(to)
|
||||
////}
|
||||
////fn render (&self, to: &mut E::Output) -> Usually<()> {
|
||||
////(**self).render(to)
|
||||
////}
|
||||
////}
|
||||
|
||||
////impl<E: Engine, W: Render<E>> Render<E> for Arc<W> {
|
||||
////fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
////self.as_ref().min_size(to)
|
||||
////}
|
||||
////fn render (&self, to: &mut E::Output) -> Usually<()> {
|
||||
////self.as_ref().render(to)
|
||||
////}
|
||||
////}
|
||||
|
||||
////impl<E: Engine, W: Render<E>> Render<E> for Mutex<W> {
|
||||
////fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
////self.lock().unwrap().min_size(to)
|
||||
////}
|
||||
////fn render (&self, to: &mut E::Output) -> Usually<()> {
|
||||
////self.lock().unwrap().render(to)
|
||||
////}
|
||||
////}
|
||||
|
||||
////impl<E: Engine, W: Render<E>> Render<E> for RwLock<W> {
|
||||
////fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
////self.read().unwrap().min_size(to)
|
||||
////}
|
||||
////fn render (&self, to: &mut E::Output) -> Usually<()> {
|
||||
////self.read().unwrap().render(to)
|
||||
////}
|
||||
////}
|
||||
|
||||
////impl<E: Engine, W: Render<E>> Render<E> for Option<W> {
|
||||
////fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
////Ok(self.as_ref().map(|widget|widget.min_size(to)).transpose()?.flatten())
|
||||
////}
|
||||
////fn render (&self, to: &mut E::Output) -> Usually<()> {
|
||||
////self.as_ref().map(|widget|widget.render(to)).unwrap_or(Ok(()))
|
||||
////}
|
||||
////}
|
||||
|
||||
///// Cast to dynamic pointer
|
||||
//pub fn widget <E, T> (w: &T) -> &dyn Render<E>
|
||||
//where E: Engine, T: Render<E>
|
||||
//{
|
||||
//w as &dyn Render<E>
|
||||
//}
|
||||
|
||||
///// Ad-hoc widget with custom rendering.
|
||||
//pub fn render <E, F> (render: F) -> impl Render<E>
|
||||
//where E: Engine, F: Fn(&mut E::Output)->Usually<()>+Send+Sync
|
||||
//{
|
||||
//Widget::new(|_|Ok(Some([0.into(),0.into()].into())), render)
|
||||
//}
|
||||
|
||||
///// A custom [Render] defined by passing layout and render closures in place.
|
||||
//pub struct Widget<
|
||||
//E: Engine,
|
||||
//L: Send + Sync + Fn(E::Size)->Perhaps<E::Size>,
|
||||
//R: Send + Sync + Fn(&mut E::Output)->Usually<()>
|
||||
//>(L, R, PhantomData<E>);
|
||||
|
||||
//impl<
|
||||
//E: Engine,
|
||||
//L: Send + Sync + Fn(E::Size)->Perhaps<E::Size>,
|
||||
//R: Send + Sync + Fn(&mut E::Output)->Usually<()>
|
||||
//> Widget<E, L, R> {
|
||||
//pub fn new (layout: L, render: R) -> Self {
|
||||
//Self(layout, render, Default::default())
|
||||
//}
|
||||
//}
|
||||
|
||||
//impl<
|
||||
//E: Engine,
|
||||
//L: Send + Sync + Fn(E::Size)->Perhaps<E::Size>,
|
||||
//R: Send + Sync + Fn(&mut E::Output)->Usually<()>
|
||||
//> Render<E> for Widget<E, L, R> {
|
||||
//fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
//self.0(to)
|
||||
//}
|
||||
//fn render (&self, to: &mut E::Output) -> Usually<()> {
|
||||
//self.1(to)
|
||||
//}
|
||||
//}
|
||||
|
||||
///// Has static methods for conditional rendering,
|
||||
///// in unary and binary forms.
|
||||
//pub struct Cond;
|
||||
|
||||
//impl Cond {
|
||||
///// Render `item` when `cond` is true.
|
||||
//pub fn when <E: Engine, A: Render<E>> (cond: bool, item: A) -> When<E, A> {
|
||||
//When(cond, item, Default::default())
|
||||
//}
|
||||
///// Render `item` if `cond` is true, otherwise render `other`.
|
||||
//pub fn either <E: Engine, A: Render<E>, B: Render<E>> (cond: bool, item: A, other: B) -> Either<E, A, B> {
|
||||
//Either(cond, item, other, Default::default())
|
||||
//}
|
||||
//}
|
||||
|
||||
///// Renders `self.1` when `self.0` is true.
|
||||
//pub struct When<E: Engine, A: Render<E>>(bool, A, PhantomData<E>);
|
||||
|
||||
///// Renders `self.1` when `self.0` is true, otherwise renders `self.2`
|
||||
//pub struct Either<E: Engine, A: Render<E>, B: Render<E>>(bool, A, B, PhantomData<E>);
|
||||
|
||||
|
||||
//**/
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue