unspeaker/tek
1
0
Fork 0
mirror of https://codeberg.org/unspeaker/tek.git synced 2025-12-06 19:56:42 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

remove old code

Browse source
This commit is contained in:
🪞👃🪞 2024-12-16 19:46:10 +01:00
parent 8861dab9db
commit d5dd746b35
2 changed files with 0 additions and 139 deletions
Download patch file Download diff file Expand all files Collapse all files

33
crates/tek/src/core/output.rs
View file

@ -15,39 +15,6 @@ pub fn widget <E: Engine, T: Render<E>> (w: &T) -> &dyn Render<E> {
w as &dyn Render<E>
}
/// A [Render] that contains other [Render]s
pub trait Content<E: Engine>: Send + Sync {
fn content (&self) -> impl Render<E>;
}
//impl<E: Engine, C: Content<E>> Render<E> for &C {
//fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
//self.content().min_size(to)
//}
//fn render (&self, to: &mut E::Output) -> Usually<()> {
//match self.min_size(to.area().wh().into())? {
//Some(wh) => to.render_in(to.area().clip(wh).into(), &self.content()),
//None => Ok(())
//}
//}
//}
/*
/// Every struct that has [Content] is a renderable [Render].
impl<E: Engine, C: Content<E>> Render<E> for C {
fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
self.content().min_size(to)
}
fn render (&self, to: &mut E::Output) -> Usually<()> {
match self.min_size(to.area().wh().into())? {
Some(wh) => to.render_in(to.area().clip(wh).into(), &self.content()),
None => Ok(())
}
}
}
*/
/// A renderable component
pub trait Render<E: Engine>: Send + Sync {
/// Minimum size to use

106
crates/tek/src/layout/bsp.rs
View file

@ -42,109 +42,3 @@ impl<E: Engine, X: Render<E>, Y: Render<E>> Default for Bsp<E, X, Y> {
Self::Null(Default::default())
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
//impl<E: Engine> LayoutBspStatic<E> for E {}
//pub trait LayoutBspStatic<E: Engine>: {
//fn n <A: Render<E>, B: Render<E>> (a: A, b: B) -> ToNorth<E, A, B> {
//ToNorth(None, a, b)
//}
//fn s <A: Render<E>, B: Render<E>> (a: A, b: B) -> ToSouth<E, A, B> {
//ToSouth(None, a, b)
//}
//fn e <A: Render<E>, B: Render<E>> (a: A, b: B) -> ToEast<E, A, B> {
//ToEast(None, a, b)
//}
//fn w <A: Render<E>, B: Render<E>> (a: A, b: B) -> ToWest<E, A, B> {
//ToWest(None, a, b)
//}
//fn i <A: Render<E>, B: Render<E>> (a: A, b: B) -> Over<E, A, B> {
//Over(Default::default(), a, b)
//}
//fn o <A: Render<E>, B: Render<E>> (a: A, b: B) -> Under<E, A, B> {
//Under(Default::default(), a, b)
//}
//}
//pub trait LayoutBspFixedStatic<E: Engine>: {
//fn to_north <A: Render<E>, B: Render<E>> (n: E::Unit, a: A, b: B) -> ToNorth<E, A, B> {
//ToNorth(Some(n), a, b)
//}
//fn to_south <A: Render<E>, B: Render<E>> (n: E::Unit, a: A, b: B) -> ToSouth<E, A, B> {
//ToSouth(Some(n), a, b)
//}
//fn to_east <A: Render<E>, B: Render<E>> (n: E::Unit, a: A, b: B) -> ToEast<E, A, B> {
//ToEast(Some(n), a, b)
//}
//fn to_west <A: Render<E>, B: Render<E>> (n: E::Unit, a: A, b: B) -> ToWest<E, A, B> {
//ToWest(Some(n), a, b)
//}
//}
//pub struct Over<E: Engine, A: Render<E>, B: Render<E>>(PhantomData<E>, A, B);
//pub struct Under<E: Engine, A: Render<E>, B: Render<E>>(PhantomData<E>, A, B);
//pub struct ToNorth<E: Engine, A: Render<E>, B: Render<E>>(Option<E::Unit>, A, B);
//pub struct ToSouth<E: Engine, A: Render<E>, B: Render<E>>(Option<E::Unit>, A, B);
//pub struct ToEast<E: Engine, A, B>(Option<E::Unit>, A, B);
//pub struct ToWest<E: Engine, A: Render<E>, B: Render<E>>(Option<E::Unit>, A, B);
//impl<E: Engine, A: Render<E>, B: Render<E>> Render<E> for Over<E, A, B> {
//fn min_size (&self, _: E::Size) -> Perhaps<E::Size> {
//todo!();
//}
//fn render (&self, _: &mut E::Output) -> Usually<()> {
//Ok(())
//}
//}
//impl<E: Engine, A: Render<E>, B: Render<E>> Render<E> for Under<E, A, B> {
//fn min_size (&self, _: E::Size) -> Perhaps<E::Size> {
//todo!();
//}
//fn render (&self, _: &mut E::Output) -> Usually<()> {
//Ok(())
//}
//}
//impl<E: Engine, A: Render<E>, B: Render<E>> Render<E> for ToNorth<E, A, B> {
//fn min_size (&self, _: E::Size) -> Perhaps<E::Size> {
//todo!();
//}
//fn render (&self, _: &mut E::Output) -> Usually<()> {
//Ok(())
//}
//}
//impl<E: Engine, A: Render<E>, B: Render<E>> Render<E> for ToSouth<E, A, B> {
//fn min_size (&self, _: E::Size) -> Perhaps<E::Size> {
//todo!();
//}
//fn render (&self, _: &mut E::Output) -> Usually<()> {
//Ok(())
//}
//}
//impl<E: Engine, A: Render<E>, B: Render<E>> Render<E> for ToWest<E, A, B> {
//fn min_size (&self, _: E::Size) -> Perhaps<E::Size> {
//todo!();
//}
//fn render (&self, _: &mut E::Output) -> Usually<()> {
//Ok(())
//}
//}
//impl<E: Engine, A: Render<E>, B: Render<E>> Render<E> for ToEast<E, A, B> {
//fn min_size (&self, _: E::Size) -> Perhaps<E::Size> {
//todo!();
//}
//fn render (&self, _: &mut E::Output) -> Usually<()> {
//Ok(())
//}
//}