tek/crates/tek_layout/src/pull.rs

use crate::*;

impl<E: Engine, W: Render<E>> LayoutPull<E> for W {}

pub trait LayoutPull<E: Engine>: Render<E> + Sized {
    fn pull_x (self, x: E::Unit) -> Pull<E, Self> {
        Pull::X(x, self)
    }
    fn pull_y (self, y: E::Unit) -> Pull<E, Self> {
        Pull::Y(y, self)
    }
    fn pull_xy (self, x: E::Unit, y: E::Unit) -> Pull<E, Self> {
        Pull::XY(x, y, self)
    }
}

/// Move origin point of drawing area
pub enum Pull<E: Engine, T: Render<E>> {
    _Unused(PhantomData<E>),
    /// Move origin to the right
    X(E::Unit, T),
    /// Move origin downwards
    Y(E::Unit, T),
    /// Move origin to the right and downwards
    XY(E::Unit, E::Unit, T),
}

impl<E: Engine, T: Render<E>> Pull<E, T> {
    pub fn inner (&self) -> &T {
        match self {
            Self::X(_, i) => i,
            Self::Y(_, i) => i,
            Self::XY(_, _, i) => i,
            _ => unreachable!(),
        }
    }
    pub fn x (&self) -> E::Unit {
        match self {
            Self::X(x, _) => *x,
            Self::Y(_, _) => E::Unit::default(),
            Self::XY(x, _, _) => *x,
            _ => unreachable!(),
        }
    }
    pub fn y (&self) -> E::Unit {
        match self {
            Self::X(_, _) => E::Unit::default(),
            Self::Y(y, _) => *y,
            Self::XY(_, y, _) => *y,
            _ => unreachable!(),
        }
    }
}

impl<E: Engine, T: Render<E>> Render<E> for Pull<E, T> {
    fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
        self.inner().min_size(to)
    }
    fn render (&self, to: &mut E::Output) -> Usually<()> {
        let area = to.area();
        Ok(self.min_size(area.wh().into())?
            .map(|size|to.render_in(match *self {
                Self::X(x, _)     => [area.x().minus(x), area.y(),          size.w(), size.h()],
                Self::Y(y, _)     => [area.x(),     area.y().minus(y),      size.w(), size.h()],
                Self::XY(x, y, _) => [area.x().minus(x), area.y().minus(y), size.w(), size.h()],
                _ => unreachable!(),
            }.into(), self.inner())).transpose()?.unwrap_or(()))
    }
}