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

removing engine generic from transforms

Browse source
This commit is contained in:
🪞👃🪞 2025-01-18 02:52:54 +01:00
parent 452bdf9598
commit a949117017
8 changed files with 184 additions and 184 deletions
Download patch file Download diff file Expand all files Collapse all files

73
output/src/op_align.rs
View file

@ -1,23 +1,40 @@
use crate::*;
use RefAtom::*;
#[derive(Debug, Copy, Clone, Default)] pub enum Alignment { #[default] Center, X, Y, NW, N, NE, E, SE, S, SW, W }
pub struct Align<E, A>(PhantomData<E>, Alignment, A);
impl<E, A> Align<E, A> {
pub fn c (a: A) -> Self { Self(Default::default(), Alignment::Center, a) }
pub fn x (a: A) -> Self { Self(Default::default(), Alignment::X, a) }
pub fn y (a: A) -> Self { Self(Default::default(), Alignment::Y, a) }
pub fn n (a: A) -> Self { Self(Default::default(), Alignment::N, a) }
pub fn s (a: A) -> Self { Self(Default::default(), Alignment::S, a) }
pub fn e (a: A) -> Self { Self(Default::default(), Alignment::E, a) }
pub fn w (a: A) -> Self { Self(Default::default(), Alignment::W, a) }
pub fn nw (a: A) -> Self { Self(Default::default(), Alignment::NW, a) }
pub fn sw (a: A) -> Self { Self(Default::default(), Alignment::SW, a) }
pub fn ne (a: A) -> Self { Self(Default::default(), Alignment::NE, a) }
pub fn se (a: A) -> Self { Self(Default::default(), Alignment::SE, a) }
pub struct Align<A>(Alignment, A);
try_from_atoms!(<'a, E>: Align<RenderBox<'a, E>>: |state, atoms| {
let head = atoms.next()?;
if head.kind() != TokenKind::Key { return None }
match head.text() {
"align/c" => return Some(Self::c(state.get_content(atoms.next()?).expect("no content"))),
"align/x" => return Some(Self::x(state.get_content(atoms.next()?).expect("no content"))),
"align/y" => return Some(Self::y(state.get_content(atoms.next()?).expect("no content"))),
"align/n" => return Some(Self::n(state.get_content(atoms.next()?).expect("no content"))),
"align/s" => return Some(Self::s(state.get_content(atoms.next()?).expect("no content"))),
"align/e" => return Some(Self::e(state.get_content(atoms.next()?).expect("no content"))),
"align/w" => return Some(Self::w(state.get_content(atoms.next()?).expect("no content"))),
"align/nw" => return Some(Self::nw(state.get_content(atoms.next()?).expect("no content"))),
"align/ne" => return Some(Self::ne(state.get_content(atoms.next()?).expect("no content"))),
"align/sw" => return Some(Self::sw(state.get_content(atoms.next()?).expect("no content"))),
"align/se" => return Some(Self::se(state.get_content(atoms.next()?).expect("no content"))),
_ => {}
}
});
impl<A> Align<A> {
pub fn c (a: A) -> Self { Self(Alignment::Center, a) }
pub fn x (a: A) -> Self { Self(Alignment::X, a) }
pub fn y (a: A) -> Self { Self(Alignment::Y, a) }
pub fn n (a: A) -> Self { Self(Alignment::N, a) }
pub fn s (a: A) -> Self { Self(Alignment::S, a) }
pub fn e (a: A) -> Self { Self(Alignment::E, a) }
pub fn w (a: A) -> Self { Self(Alignment::W, a) }
pub fn nw (a: A) -> Self { Self(Alignment::NW, a) }
pub fn sw (a: A) -> Self { Self(Alignment::SW, a) }
pub fn ne (a: A) -> Self { Self(Alignment::NE, a) }
pub fn se (a: A) -> Self { Self(Alignment::SE, a) }
}
impl<E: Output, A: Content<E>> Content<E> for Align<E, A> {
impl<E: Output, A: Content<E>> Content<E> for Align<A> {
fn content (&self) -> impl Render<E> {
&self.2
&self.1
}
fn layout (&self, on: E::Area) -> E::Area {
use Alignment::*;
@ -26,7 +43,7 @@ impl<E: Output, A: Content<E>> Content<E> for Align<E, A> {
let cy = on.y()+(on.h().minus(it.h())/2.into());
let fx = (on.x()+on.w()).minus(it.w());
let fy = (on.y()+on.h()).minus(it.h());
let [x, y] = match self.1 {
let [x, y] = match self.0 {
Center => [cx, cy],
X => [cx, it.y()],
Y => [it.x(), cy],
@ -45,25 +62,3 @@ impl<E: Output, A: Content<E>> Content<E> for Align<E, A> {
to.place(Content::layout(self, to.area()), &self.content())
}
}
impl<'a, E: Output + 'a, T: ViewContext<'a, E>> TryFromAtom<'a, T> for Align<E, RenderBox<'a, E>> {
fn try_from_atom (
state: &'a T,
head: &impl Atom,
tail: &'a [impl Atom]
) -> Option<Self> {
Some(match (head.to_ref(), tail) {
(Key("align/c"), [a]) => Self::c(state.get_content(a).expect("no content")),
(Key("align/x"), [a]) => Self::x(state.get_content(a).expect("no content")),
(Key("align/y"), [a]) => Self::y(state.get_content(a).expect("no content")),
(Key("align/n"), [a]) => Self::n(state.get_content(a).expect("no content")),
(Key("align/s"), [a]) => Self::s(state.get_content(a).expect("no content")),
(Key("align/e"), [a]) => Self::e(state.get_content(a).expect("no content")),
(Key("align/w"), [a]) => Self::w(state.get_content(a).expect("no content")),
(Key("align/nw"), [a]) => Self::nw(state.get_content(a).expect("no content")),
(Key("align/ne"), [a]) => Self::ne(state.get_content(a).expect("no content")),
(Key("align/sw"), [a]) => Self::sw(state.get_content(a).expect("no content")),
(Key("align/se"), [a]) => Self::se(state.get_content(a).expect("no content")),
_ => return None
})
}
}