unspeaker/tengri
1
0
Fork 0
mirror of https://codeberg.org/unspeaker/tengri.git synced 2026-09-18 05:16:44 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

remove View and lifetime from Draw/Drawn
Some checks failed
/ build (push) Has been cancelled
Details

Browse source
This commit is contained in:
facile pop culture reference 2026-08-23 11:29:40 +03:00
parent 41ef62146b
commit 4172fa2577
13 changed files with 250 additions and 248 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/layout/area.rs
View file

@ -6,7 +6,7 @@ use crate::*;
/// let _ = area(XYWH(1, 2, 3, 4), "southeast");
/// let _ = area(Some(XYWH(1, 2, 3, 4)), "southeast");
/// ```
pub fn area <'a, S: Screen, T: Draw<'a, S>, U: Into<Option<XYWH<S::Unit>>>> (
pub fn area <'a, S: Screen, T: Draw<S>, U: Into<Option<XYWH<S::Unit>>>> (
origin: U, it: T
) -> Area<S, T> {
Area(origin.into(), it)
@ -17,8 +17,8 @@ pub struct Area<S: Screen, T>(
pub T,
);
impl<'a, S: Screen, T: Draw<'a, S>> Draw<'a, S> for Area<S, T> {
fn draw (&self, to: &mut S) -> Drawn<'a, S::Unit> {
impl<'a, S: Screen, T: Draw<S>> Draw<S> for Area<S, T> {
fn draw (&self, to: &mut S) -> Drawn<S::Unit> {
to.draw(self.0, &self.1)
}
}

142
src/layout/axis.rs
View file

@ -1,30 +1,30 @@
use crate::*;
pub enum Full<'a, S: Screen, I: Draw<'a, S>> {
pub enum Full<'a, S: Screen, I: Draw<S>> {
__(PhantomData<&'a S>), W(I), H(I), WH(I),
}
pub enum Exact<'a, S: Screen, I: Draw<'a, S>, X: Into<Option<S::Unit>>> {
pub enum Exact<'a, S: Screen, I: Draw<S>, X: Into<Option<S::Unit>>> {
__(PhantomData<&'a S>), W(I, X), H(I, X), WH(I, X, X),
}
pub enum Push<'a, S: Screen, I: Draw<'a, S>, X: Into<Option<S::Unit>>> {
pub enum Push<'a, S: Screen, I: Draw<S>, X: Into<Option<S::Unit>>> {
__(PhantomData<&'a S>), X(I, X), Y(I, X), XY(I, X, X),
}
pub enum Pull<'a, S: Screen, I: Draw<'a, S>, X: Into<Option<S::Unit>>> {
pub enum Pull<'a, S: Screen, I: Draw<S>, X: Into<Option<S::Unit>>> {
__(PhantomData<&'a S>), X(I, X), Y(I, X), XY(I, X, X),
}
pub enum Min<'a, S: Screen, I: Draw<'a, S>, X: Into<Option<S::Unit>>> {
pub enum Min<'a, S: Screen, I: Draw<S>, X: Into<Option<S::Unit>>> {
__(PhantomData<&'a S>), W(I, X), H(I, X), WH(I, X, X),
}
pub enum Max<'a, S: Screen, I: Draw<'a, S>, X: Into<Option<S::Unit>>> {
pub enum Max<'a, S: Screen, I: Draw<S>, X: Into<Option<S::Unit>>> {
__(PhantomData<&'a S>), W(I, X), H(I, X), WH(I, X, X),
}
pub enum Pad<'a, S: Screen, I: Draw<'a, S>, X: Into<Option<S::Unit>>> {
pub enum Pad<'a, S: Screen, I: Draw<S>, X: Into<Option<S::Unit>>> {
__(PhantomData<&'a S>), X(I, X), Y(I, X), XY(I, X, X),
}
@ -36,7 +36,7 @@ pub enum Pad<'a, S: Screen, I: Draw<'a, S>, X: Into<Option<S::Unit>>> {
/// assert_eq!(check_layout("1".full_wh())?, Some(XYWH(1u16, 1, 80, 25)));
/// # Ok(()) }
/// ```
pub trait LayoutFull<'a, S: Screen>: Draw<'a, S> + Sized {
pub trait LayoutFull<'a, S: Screen>: Draw<S> + Sized {
fn full_w (self) -> Full<'a, S, Self> { Full::W(self) }
fn full_h (self) -> Full<'a, S, Self> { Full::H(self) }
fn full_wh (self) -> Full<'a, S, Self> { Full::WH(self) }
@ -50,7 +50,7 @@ pub trait LayoutFull<'a, S: Screen>: Draw<'a, S> + Sized {
/// assert_eq!(check_layout("FOOBAR\nKILROY".exact_wh(2, 1))?, Some(XYWH(1, 1, 2, 1)));
/// # Ok(()) }
/// ```
pub trait LayoutExact<'a, S: Screen>: Draw<'a, S> + Sized {
pub trait LayoutExact<'a, S: Screen>: Draw<S> + Sized {
fn exact_w <X: Into<Option<S::Unit>> + Copy> (self, w: X)
-> Exact<'a, S, Self, X> { Exact::W(self, w) }
fn exact_h <X: Into<Option<S::Unit>> + Copy> (self, h: X)
@ -67,7 +67,7 @@ pub trait LayoutExact<'a, S: Screen>: Draw<'a, S> + Sized {
/// assert_eq!(check_layout("123456".min_w(5))?, Some(XYWH(1u16, 1, 6, 1)));
/// # Ok(()) }
/// ```
pub trait LayoutMin<'a, S: Screen>: Draw<'a, S> + Sized {
pub trait LayoutMin<'a, S: Screen>: Draw<S> + Sized {
fn min_w <X: Into<Option<S::Unit>> + Copy> (self, w: X)
-> Min<'a, S, Self, X> { Min::W(self, w) }
fn min_h <X: Into<Option<S::Unit>> + Copy> (self, h: X)
@ -76,7 +76,7 @@ pub trait LayoutMin<'a, S: Screen>: Draw<'a, S> + Sized {
-> Min<'a, S, Self, X> { Min::WH(self, w, h) }
}
pub trait LayoutMax<'a, S: Screen>: Draw<'a, S> + Sized {
pub trait LayoutMax<'a, S: Screen>: Draw<S> + Sized {
fn max_w <X: Into<Option<S::Unit>> + Copy> (self, w: X)
-> Max<'a, S, Self, X> { Max::W(self, w) }
fn max_h <X: Into<Option<S::Unit>> + Copy> (self, h: X)
@ -85,7 +85,7 @@ pub trait LayoutMax<'a, S: Screen>: Draw<'a, S> + Sized {
-> Max<'a, S, Self, X> { Max::WH(self, w, h) }
}
pub trait LayoutPad<'a, S: Screen>: Draw<'a, S> + Sized {
pub trait LayoutPad<'a, S: Screen>: Draw<S> + Sized {
fn pad_w <X: Into<Option<S::Unit>> + Copy> (self, w: X)
-> Pad<'a, S, Self, X> { Pad::X(self, w) }
fn pad_h <X: Into<Option<S::Unit>> + Copy> (self, h: X)
@ -102,7 +102,7 @@ pub trait LayoutPad<'a, S: Screen>: Draw<'a, S> + Sized {
/// assert_eq!(check_layout("1".push_xy(1, 1))?, Some(XYWH(2u16, 2, 1, 1)));
/// # Ok(()) }
/// ```
pub trait LayoutPush<'a, S: Screen>: Draw<'a, S> + Sized {
pub trait LayoutPush<'a, S: Screen>: Draw<S> + Sized {
fn push_x <X: Into<Option<S::Unit>> + Copy> (self, w: X)
-> Push<'a, S, Self, X> { Push::X(self, w) }
fn push_y <X: Into<Option<S::Unit>> + Copy> (self, h: X)
@ -119,7 +119,7 @@ pub trait LayoutPush<'a, S: Screen>: Draw<'a, S> + Sized {
/// assert_eq!(check_layout("1".pull_xy(1, 1))?, Some(XYWH(0u16, 0, 1, 1)));
/// # Ok(()) }
/// ```
pub trait LayoutPull<'a, S: Screen>: Draw<'a, S> + Sized {
pub trait LayoutPull<'a, S: Screen>: Draw<S> + Sized {
fn pull_x <X: Into<Option<S::Unit>> + Copy> (self, w: X)
-> Pull<'a, S, Self, X> { Pull::X(self, w) }
fn pull_y <X: Into<Option<S::Unit>> + Copy> (self, h: X)
@ -129,11 +129,11 @@ pub trait LayoutPull<'a, S: Screen>: Draw<'a, S> + Sized {
}
#[cfg(all(feature = "draw", feature = "eval"))]
pub fn kw_full <'a, O, S> (state: &'a S, to: &mut O, expr: &'a str)
-> PerhapsRef<'a, XYWH<O::Unit>>
pub fn kw_full <O, S> (state: &S, to: &mut O, expr: &str)
-> Perhaps<XYWH<O::Unit>>
where
O: Screen + 'a,
S: Interpret<'a, O, Option<XYWH<O::Unit>>>
O: Screen,
S: Interpret<O, Option<XYWH<O::Unit>>>
+ Namespace<bool>
+ Namespace<O::Unit>
+ Namespace<Option<O::Unit>>
@ -143,16 +143,16 @@ where
Some("full/x") | Some("full/w") => Full::W(thunk).draw(to)?,
Some("full/y") | Some("full/h") => Full::H(thunk).draw(to)?,
Some("full/xy") | Some("full/wh") => Full::WH(thunk).draw(to)?,
frag => return Err(format!("invalid variant: {frag:?}").into())
frag => return Err(format!("full: invalid variant: {frag:?}").into())
})
}
#[cfg(all(feature = "draw", feature = "eval"))]
pub fn kw_exact <'a, O, S> (state: &'a S, to: &mut O, expr: &'a str)
-> PerhapsRef<'a, XYWH<O::Unit>>
pub fn kw_exact <O, S> (state: &S, to: &mut O, expr: &str)
-> Perhaps<XYWH<O::Unit>>
where
O: Screen + 'a,
S: Interpret<'a, O, Option<XYWH<O::Unit>>>
O: Screen,
S: Interpret<O, Option<XYWH<O::Unit>>>
+ Namespace<bool>
+ Namespace<O::Unit>
+ Namespace<Option<O::Unit>>
@ -169,16 +169,16 @@ where
state.namespace(&expr.nth(1)?)?,
state.namespace(&expr.nth(2)?)?,
).draw(to)?,
_ => return Err(format!("invalid variant: {:?}", expr.head()?).into())
_ => return Err(format!("exact: invalid variant: {:?}", expr.head()?).into())
})
}
#[cfg(all(feature = "draw", feature = "eval"))]
pub fn kw_min <'a, O, S> (state: &'a S, to: &mut O, expr: &'a str)
-> PerhapsRef<'a, XYWH<O::Unit>>
pub fn kw_min <O, S> (state: &S, to: &mut O, expr: &str)
-> Perhaps<XYWH<O::Unit>>
where
O: Screen + 'a,
S: Interpret<'a, O, Option<XYWH<O::Unit>>>
O: Screen,
S: Interpret<O, Option<XYWH<O::Unit>>>
+ Namespace<bool>
+ Namespace<O::Unit>
+ Namespace<Option<O::Unit>>
@ -195,16 +195,16 @@ where
state.namespace(&expr.nth(1)?)?,
state.namespace(&expr.nth(2)?)?,
).draw(to)?,
_ => return Err(format!("invalid variant: {:?}", expr.head()?).into())
_ => return Err(format!("min: invalid variant: {:?}", expr.head()?).into())
})
}
#[cfg(all(feature = "draw", feature = "eval"))]
pub fn kw_max <'a, O, S> (state: &'a S, to: &mut O, expr: &'a str)
-> PerhapsRef<'a, XYWH<O::Unit>>
pub fn kw_max <O, S> (state: &S, to: &mut O, expr: &str)
-> Perhaps<XYWH<O::Unit>>
where
O: Screen + 'a,
S: Interpret<'a, O, Option<XYWH<O::Unit>>>
O: Screen,
S: Interpret<O, Option<XYWH<O::Unit>>>
+ Namespace<bool>
+ Namespace<O::Unit>
+ Namespace<Option<O::Unit>>
@ -221,16 +221,16 @@ where
state.namespace(&expr.nth(1)?)?,
state.namespace(&expr.nth(2)?)?,
).draw(to)?,
_ => return Err(format!("invalid variant: {:?}", expr.head()?).into())
_ => return Err(format!("max: invalid variant: {:?}", expr.head()?).into())
})
}
#[cfg(all(feature = "draw", feature = "eval"))]
pub fn kw_push <'a, O, S> (state: &'a S, to: &mut O, expr: &'a str)
-> PerhapsRef<'a, XYWH<O::Unit>>
pub fn kw_push <O, S> (state: &S, to: &mut O, expr: &str)
-> Perhaps<XYWH<O::Unit>>
where
O: Screen + 'a,
S: Interpret<'a, O, Option<XYWH<O::Unit>>>
O: Screen,
S: Interpret<O, Option<XYWH<O::Unit>>>
+ Namespace<bool>
+ Namespace<O::Unit>
+ Namespace<Option<O::Unit>>
@ -243,16 +243,16 @@ where
state.namespace(&expr.nth(1)?)?,
state.namespace(&expr.nth(2)?)?,
).draw(to)?,
_ => return Err(format!("invalid variant: {:?}", expr.head()?).into())
_ => return Err(format!("push: invalid variant: {:?}", expr.head()?).into())
})
}
#[cfg(all(feature = "draw", feature = "eval"))]
pub fn kw_pull <'a, O, S> (state: &'a S, to: &mut O, expr: &'a str)
-> PerhapsRef<'a, XYWH<O::Unit>>
pub fn kw_pull <O, S> (state: &S, to: &mut O, expr: &str)
-> Perhaps<XYWH<O::Unit>>
where
O: Screen + 'a,
S: Interpret<'a, O, Option<XYWH<O::Unit>>>
O: Screen,
S: Interpret<O, Option<XYWH<O::Unit>>>
+ Namespace<bool>
+ Namespace<O::Unit>
+ Namespace<Option<O::Unit>>
@ -265,16 +265,16 @@ where
state.namespace(&expr.nth(1)?)?,
state.namespace(&expr.nth(2)?)?,
).draw(to)?,
_ => return Err(format!("invalid variant: {:?}", expr.head()?).into())
_ => return Err(format!("pull: invalid variant: {:?}", expr.head()?).into())
})
}
#[cfg(all(feature = "draw", feature = "eval"))]
pub fn kw_pad <'a, O, S> (state: &'a S, to: &mut O, expr: &'a str)
-> PerhapsRef<'a, XYWH<O::Unit>>
pub fn kw_pad <O, S> (state: &S, to: &mut O, expr: &str)
-> Perhaps<XYWH<O::Unit>>
where
O: Screen + 'a,
S: Interpret<'a, O, Option<XYWH<O::Unit>>>
O: Screen,
S: Interpret<O, Option<XYWH<O::Unit>>>
+ Namespace<bool>
+ Namespace<O::Unit>
+ Namespace<Option<O::Unit>>
@ -291,12 +291,12 @@ where
state.namespace(&expr.nth(1)?)?,
state.namespace(&expr.nth(2)?)?,
).draw(to)?,
_ => return Err(format!("invalid variant: {:?}", expr.head()?).into())
_ => return Err(format!("pad: invalid variant: {:?}", expr.head()?).into())
})
}
impl <'a, S: Screen, I: Draw<'a, S>> Draw<'a, S> for Full<'a, S, I> {
fn draw (&self, to: &mut S) -> Drawn<'a, S::Unit> {
impl <'a, S: Screen, I: Draw<S>> Draw<S> for Full<'a, S, I> {
fn draw (&self, to: &mut S) -> Drawn<S::Unit> {
let XYWH(x0, y0, w0, h0) = to.area();
let item = match self {
Self::W(i) => i, Self::H(i) => i, Self::WH(i) => i, _ => unreachable!()
@ -313,8 +313,8 @@ impl <'a, S: Screen, I: Draw<'a, S>> Draw<'a, S> for Full<'a, S, I> {
}
}
impl <'a, S: Screen, I: Draw<'a, S>, X: Into<Option<S::Unit>> + Copy> Draw<'a, S> for Exact<'a, S, I, X> {
fn draw (&self, to: &mut S) -> Drawn<'a, S::Unit> {
impl <'a, S: Screen, I: Draw<S>, X: Into<Option<S::Unit>> + Copy> Draw<S> for Exact<'a, S, I, X> {
fn draw (&self, to: &mut S) -> Drawn<S::Unit> {
let XYWH(x0, y0, w0, h0) = to.area();
let (item, w1, h1) = match self {
Self::W(item, w1) => (item, (*w1).into(), None),
@ -335,8 +335,8 @@ impl <'a, S: Screen, I: Draw<'a, S>, X: Into<Option<S::Unit>> + Copy> Draw<'a, S
}
}
impl <'a, S: Screen, I: Draw<'a, S>, X: Into<Option<S::Unit>> + Copy> Draw<'a, S> for Min<'a, S, I, X> {
fn draw (&self, to: &mut S) -> Drawn<'a, S::Unit> {
impl <'a, S: Screen, I: Draw<S>, X: Into<Option<S::Unit>> + Copy> Draw<S> for Min<'a, S, I, X> {
fn draw (&self, to: &mut S) -> Drawn<S::Unit> {
let XYWH(x0, y0, w0, h0) = to.area();
let (item, w1, h1) = match self {
Self::W(item, w1) => (item, (*w1).into(), None),
@ -356,8 +356,8 @@ impl <'a, S: Screen, I: Draw<'a, S>, X: Into<Option<S::Unit>> + Copy> Draw<'a, S
}
}
impl <'a, S: Screen, I: Draw<'a, S>, X: Into<Option<S::Unit>> + Copy> Draw<'a, S> for Max<'a, S, I, X> {
fn draw (&self, to: &mut S) -> Drawn<'a, S::Unit> {
impl <'a, S: Screen, I: Draw<S>, X: Into<Option<S::Unit>> + Copy> Draw<S> for Max<'a, S, I, X> {
fn draw (&self, to: &mut S) -> Drawn<S::Unit> {
let XYWH(x, y, w0, h0) = to.area();
let (item, w, h) = match self {
Self::W(item, w) => (item, (*w).into().unwrap_or(w0), h0),
@ -369,8 +369,8 @@ impl <'a, S: Screen, I: Draw<'a, S>, X: Into<Option<S::Unit>> + Copy> Draw<'a, S
}
}
impl <'a, S: Screen, I: Draw<'a, S>, X: Into<Option<S::Unit>> + Copy> Draw<'a, S> for Push<'a, S, I, X> {
fn draw (&self, to: &mut S) -> Drawn<'a, S::Unit> {
impl <'a, S: Screen, I: Draw<S>, X: Into<Option<S::Unit>> + Copy> Draw<S> for Push<'a, S, I, X> {
fn draw (&self, to: &mut S) -> Drawn<S::Unit> {
match self {
Self::__(_) => unreachable!(),
Self::X(item, x1) if let Some(XYWH(x, y, w, h)) = to.size(None, item)? => {
@ -387,8 +387,8 @@ impl <'a, S: Screen, I: Draw<'a, S>, X: Into<Option<S::Unit>> + Copy> Draw<'a, S
}
}
impl <'a, S: Screen, I: Draw<'a, S>, X: Into<Option<S::Unit>> + Copy> Draw<'a, S> for Pull<'a, S, I, X> {
fn draw (&self, to: &mut S) -> Drawn<'a, S::Unit> {
impl <'a, S: Screen, I: Draw<S>, X: Into<Option<S::Unit>> + Copy> Draw<S> for Pull<'a, S, I, X> {
fn draw (&self, to: &mut S) -> Drawn<S::Unit> {
match self {
Self::__(_) => unreachable!(),
Self::X(item, x1) if let Some(XYWH(x, y, w, h)) = to.size(None, item)? => {
@ -411,8 +411,8 @@ impl <'a, S: Screen, I: Draw<'a, S>, X: Into<Option<S::Unit>> + Copy> Draw<'a, S
}
}
impl <'a, S: Screen, I: Draw<'a, S>, X: Into<Option<S::Unit>> + Copy> Draw<'a, S> for Pad<'a, S, I, X> {
fn draw (&self, to: &mut S) -> Drawn<'a, S::Unit> {
impl <'a, S: Screen, I: Draw<S>, X: Into<Option<S::Unit>> + Copy> Draw<S> for Pad<'a, S, I, X> {
fn draw (&self, to: &mut S) -> Drawn<S::Unit> {
let XYWH(x, y, w0, h0) = to.area();
let (item, w, h) = match self {
Self::X(item, w) => (item, (*w).into().unwrap_or_default(), Default::default()),
@ -430,20 +430,20 @@ impl <'a, S: Screen, I: Draw<'a, S>, X: Into<Option<S::Unit>> + Copy> Draw<'a, S
}
}
impl<'a, S: Screen, T: Draw<'a, S>> LayoutFull<'a, S> for T {}
impl<'a, S: Screen, T: Draw<S>> LayoutFull<'a, S> for T {}
impl<'a, S: Screen, T: Draw<'a, S>> LayoutExact<'a, S> for T {}
impl<'a, S: Screen, T: Draw<S>> LayoutExact<'a, S> for T {}
impl<'a, S: Screen, T: Draw<'a, S>> LayoutMin<'a, S> for T {}
impl<'a, S: Screen, T: Draw<S>> LayoutMin<'a, S> for T {}
impl<'a, S: Screen, T: Draw<'a, S>> LayoutMax<'a, S> for T {}
impl<'a, S: Screen, T: Draw<S>> LayoutMax<'a, S> for T {}
impl<'a, S: Screen, T: Draw<'a, S>> LayoutPush<'a, S> for T {}
impl<'a, S: Screen, T: Draw<S>> LayoutPush<'a, S> for T {}
impl<'a, S: Screen, T: Draw<'a, S>> LayoutPull<'a, S> for T {}
impl<'a, S: Screen, T: Draw<S>> LayoutPull<'a, S> for T {}
impl<'a, S: Screen, T: Draw<'a, S>> LayoutPad<'a, S> for T {}
impl<'a, S: Screen, T: Draw<S>> LayoutPad<'a, S> for T {}
pub fn check_layout <'a> (t: impl Draw<'a, Tui>) -> Drawn<'a, u16> {
pub fn check_layout <'a> (t: impl Draw<Tui>) -> Drawn<u16> {
Tui::Layout(XYWH(1u16, 1, 80, 25)).size(None, t)
}

59
src/layout/azimuth.rs
View file

@ -18,8 +18,8 @@ pub struct Origin<T>(
pub(crate) T
);
impl<'a, S: Screen, T: Draw<'a, S>> Draw<'a, S> for Origin<T> {
fn draw (&self, _to: &mut S) -> Drawn<'a, S::Unit> {
impl<'a, S: Screen, T: Draw<S>> Draw<S> for Origin<T> {
fn draw (&self, _to: &mut S) -> Drawn<S::Unit> {
todo!()
}
}
@ -36,11 +36,11 @@ impl<T: AsRef<Azimuth>> HasOrigin for T {
}
#[cfg(all(feature = "draw", feature = "eval"))]
pub fn kw_align <'a, O, S> (state: &'a S, to: &mut O, expr: &'a str)
-> Drawn<'a, O::Unit>
pub fn kw_align <O, S> (state: &S, to: &mut O, expr: &str)
-> Drawn<O::Unit>
where
O: Screen,
S: Interpret<'a, O, Option<XYWH<O::Unit>>>
S: Interpret<O, Option<XYWH<O::Unit>>>
+ Namespace<bool>
+ Namespace<O::Unit>
+ Namespace<Option<O::Unit>>
@ -58,7 +58,8 @@ where
Some("align/sw") => Align(Some(Azimuth::SW), thunk).draw(to)?,
Some("align/ne") => Align(Some(Azimuth::NE), thunk).draw(to)?,
Some("align/se") => Align(Some(Azimuth::SE), thunk).draw(to)?,
frag => return Err(format!("invalid variant: {frag:?}").into())
Some(frag) => return Err(format!("align: invalid variant: {frag}").into()),
None => unreachable!()
})
//Ok(matches!(expr.head().src()?.unwrap_or_default().split("/").next(), Some("align")).then(||{
//draw(move|output: &mut O|{state.interpret(output, &expr.nth(1))}).align(
@ -73,9 +74,9 @@ where
//}).transpose()?.flatten())
}
impl<'a, S: Screen, T: Draw<'a, S>> CanAlign<'a, S> for T {}
impl<'a, S: Screen, T: Draw<S>> CanAlign<'a, S> for T {}
pub trait CanAlign<'a, S: Screen>: Draw<'a, S> + Sized {
pub trait CanAlign<'a, S: Screen>: Draw<S> + Sized {
fn align (self, azimuth: impl Into<Option<Azimuth>>) -> Align<Self> {
Align(azimuth.into(), self)
}
@ -119,8 +120,8 @@ pub struct Align<T>(
pub(crate) T,
);
impl<'a, S: Screen, T: Draw<'a, S>> Draw<'a, S> for Align<T> {
fn draw (&self, to: &mut S) -> Drawn<'a, S::Unit> {
impl<'a, S: Screen, T: Draw<S>> Draw<S> for Align<T> {
fn draw (&self, to: &mut S) -> Drawn<S::Unit> {
let Self(azimuth, item) = self;
let area0 = to.area();
let size = to.size(area0, item)?;
@ -166,7 +167,7 @@ fn_kw_layout!(kw_split |state, output, expr| {
Some("bsp/w") => Split::West.stack(thunk_a, thunk_b).draw(output)?,
Some("bsp/a") => Split::Above.stack(thunk_a, thunk_b).draw(output)?,
Some("bsp/b") => Split::Below.stack(thunk_a, thunk_b).draw(output)?,
frag => return Err(format!("invalid variant: {frag:?}").into())
frag => return Err(format!("split: invalid variant: {frag:?}").into())
})
});
@ -187,7 +188,7 @@ pub struct Pair<A, B>(Split, A, B);
/// # fn test_split_stack () -> Usually<()> {
/// use ::tengri::*;
/// use Split::*;
/// fn size_of <'a, A: Draw<'a, Tui>, B: Draw<'a, Tui>> (stack: &Pair<Tui, A, B>) -> Drawn<'a, S::Unit> {
/// fn size_of <'a, A: Draw<Tui>, B: Draw<Tui>> (stack: &Pair<Tui, A, B>) -> Drawn<S::Unit> {
/// Tui::Layout(XYWH(0, 0, 80, 25)).size(None, stack)
/// }
/// assert_eq!(size_of(&split(East, "foo", "bar"))?, Some(XYWH(0, 0, 6, 1)));
@ -196,14 +197,14 @@ pub struct Pair<A, B>(Split, A, B);
/// assert_eq!(size_of(&split(East, split(South, "foo", "bar"), "baz"))?, Some(XYWH(0, 0, 6, 2)));
/// # return Ok(()); }
/// ```
pub fn split <'a, S: Screen, A: Draw<'a, S>, B: Draw<'a, S>> (
pub fn split <'a, S: Screen, A: Draw<S>, B: Draw<S>> (
split: Split, a: A, b: B
) -> Pair<A, B> {
Pair(split, a, b)
}
impl<'a, S: Screen, A: Draw<'a, S>, B: Draw<'a, S>> Draw<'a, S> for Pair<A, B> {
fn draw (&self, to: &mut S) -> Drawn<'a, S::Unit> {
impl<'a, S: Screen, A: Draw<S>, B: Draw<S>> Draw<S> for Pair<A, B> {
fn draw (&self, to: &mut S) -> Drawn<S::Unit> {
let Self(split, a, b, ..) = self;
let (area_a, area_b) = stack_areas(split, to, a, b)?;
let (drawn_a, drawn_b) = draw_stacks(split, to, a, area_a, None, b, area_b, None)?;
@ -214,10 +215,10 @@ impl<'a, S: Screen, A: Draw<'a, S>, B: Draw<'a, S>> Draw<'a, S> for Pair<A, B> {
fn draw_stacks <'a, S: Screen> (
split: &Split,
to: &mut S,
a: impl Draw<'a, S>,
a: impl Draw<S>,
area_a: impl Into<Option<XYWH<S::Unit>>>,
origin_a: impl Into<Option<Azimuth>>,
b: impl Draw<'a, S>,
b: impl Draw<S>,
area_b: impl Into<Option<XYWH<S::Unit>>>,
origin_b: impl Into<Option<Azimuth>>,
) -> UsuallyRef<'a, (Option<XYWH<S::Unit>>, Option<XYWH<S::Unit>>)> {
@ -254,8 +255,8 @@ fn draw_stacks <'a, S: Screen> (
pub fn stack_areas <'a, S: Screen> (
split: &Split,
to: &mut S,
a: impl Draw<'a, S>,
b: impl Draw<'a, S>,
a: impl Draw<S>,
b: impl Draw<S>,
) -> UsuallyRef<'a, (Option<XYWH<S::Unit>>, Option<XYWH<S::Unit>>)> {
let area_a = to.size(None, a)?;
Ok(match split {
@ -331,8 +332,8 @@ impl Split {
/// let _ = Split::East.stack(&"", &"");
/// let _ = Split::West.stack(&"", &"");
/// ```
pub const fn stack <'a, S: Screen, A: Draw<'a, S>, B: Draw<'a, S>> (&self, a: A, b: B)
-> impl Draw<'a, S>
pub const fn stack <'a, S: Screen, A: Draw<S>, B: Draw<S>> (&self, a: A, b: B)
-> impl Draw<S>
{
Pair(*self, a, b)
}
@ -346,8 +347,8 @@ impl Split {
/// let _ = Split::East.half(&"", &"");
/// let _ = Split::West.half(&"", &"");
/// ```
pub const fn half <'a, S: Screen, A: Draw<'a, S>, B: Draw<'a, S>> (&self, a: &A, b: &B)
-> impl Draw<'a, S>
pub const fn half <'a, S: Screen, A: Draw<S>, B: Draw<S>> (&self, a: &A, b: &B)
-> impl Draw<S>
{
draw(move|to: &mut S|{
let (area_a, area_b) = to.xywh().split_half(self);
@ -402,27 +403,27 @@ impl Split {
}
pub const fn east <'a, S: Screen, A: Draw<'a, S>, B: Draw<'a, S>> (a: A, b: B) -> impl Draw<'a, S> {
pub const fn east <'a, S: Screen, A: Draw<S>, B: Draw<S>> (a: A, b: B) -> impl Draw<S> {
Pair(Split::East, a, b)
}
pub const fn north <'a, S: Screen, A: Draw<'a, S>, B: Draw<'a, S>> (a: A, b: B) -> impl Draw<'a, S> {
pub const fn north <'a, S: Screen, A: Draw<S>, B: Draw<S>> (a: A, b: B) -> impl Draw<S> {
Pair(Split::North, a, b)
}
pub const fn west <'a, S: Screen, A: Draw<'a, S>, B: Draw<'a, S>> (a: A, b: B) -> impl Draw<'a, S> {
pub const fn west <'a, S: Screen, A: Draw<S>, B: Draw<S>> (a: A, b: B) -> impl Draw<S> {
Pair(Split::West, a, b)
}
pub const fn south <'a, S: Screen, A: Draw<'a, S>, B: Draw<'a, S>> (a: A, b: B) -> impl Draw<'a, S> {
pub const fn south <'a, S: Screen, A: Draw<S>, B: Draw<S>> (a: A, b: B) -> impl Draw<S> {
Pair(Split::South, a, b)
}
pub const fn above <'a, S: Screen, A: Draw<'a, S>, B: Draw<'a, S>> (a: A, b: B) -> impl Draw<'a, S> {
pub const fn above <'a, S: Screen, A: Draw<S>, B: Draw<S>> (a: A, b: B) -> impl Draw<S> {
Pair(Split::Above, a, b)
}
pub const fn below <'a, S: Screen, A: Draw<'a, S>, B: Draw<'a, S>> (a: A, b: B) -> impl Draw<'a, S> {
pub const fn below <'a, S: Screen, A: Draw<S>, B: Draw<S>> (a: A, b: B) -> impl Draw<S> {
Pair(Split::Below, a, b)
}

10
src/layout/cond.rs
View file

@ -10,11 +10,11 @@ fn_kw_layout!(kw_when |state, output, expr| {
/// Only render when condition is true.
///
/// ```
/// # use ::tengri::*; fn test <'a> () -> impl Draw<'a, Tui> {
/// # use ::tengri::*; fn test <'a> () -> impl Draw<Tui> {
/// when(true, "Yes")
/// # }
/// ```
pub const fn when <'a, T: Screen> (condition: bool, item: impl Draw<'a, T>) -> impl Draw<'a, T> {
pub const fn when <'a, T: Screen> (condition: bool, item: impl Draw<T>) -> impl Draw<T> {
draw(move|to: &mut T|if condition { item.draw(to) } else { Ok(Default::default()) })
}
@ -29,12 +29,12 @@ fn_kw_layout!(kw_either |state, output, expr| {
/// Render one thing if a condition is true and another false.
///
/// ```
/// # use ::tengri::*; fn test <'a> () -> impl Draw<'a, Tui> {
/// # use ::tengri::*; fn test <'a> () -> impl Draw<Tui> {
/// either(true, "Yes", "No")
/// # }
/// ```
pub const fn either <'a, T: Screen> (
condition: bool, a: impl Draw<'a, T>, b: impl Draw<'a, T>
) -> impl Draw<'a, T> {
condition: bool, a: impl Draw<T>, b: impl Draw<T>
) -> impl Draw<T> {
draw(move|to: &mut T|if condition { a.draw(to) } else { b.draw(to) })
}

52
src/layout/iter.rs
View file

@ -1,8 +1,8 @@
use super::*;
pub fn iter_south <'a, S: Screen, D: Draw<'a, S>, I: Iterator<Item = D>> (
pub fn iter_south <'a, S: Screen, D: Draw<S>, I: Iterator<Item = D>> (
iter: impl Fn()->I
) -> impl Draw<'a, S> {
) -> impl Draw<S> {
draw(move|to: &mut S|{
let XYWH(x, y, w, h) = to.area();
let mut y_next = y;
@ -22,9 +22,9 @@ pub fn iter_south <'a, S: Screen, D: Draw<'a, S>, I: Iterator<Item = D>> (
})
}
pub fn iter_east <'a, S: Screen, D: Draw<'a, S>, I: Iterator<Item = D>> (
pub fn iter_east <'a, S: Screen, D: Draw<S>, I: Iterator<Item = D>> (
iter: impl Fn()->I
) -> impl Draw<'a, S> {
) -> impl Draw<S> {
draw(move|to: &mut S|{
let XYWH(x, y, w, h) = to.area();
let mut x_next = x;
@ -45,16 +45,16 @@ pub fn iter_east <'a, S: Screen, D: Draw<'a, S>, I: Iterator<Item = D>> (
}
/// Iterate over a collection of the same kind of [Draw]able:
pub fn iter <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<'a, S>> (
pub fn iter <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
_iter: impl Fn()->I, _draw: impl Fn(D, usize)->U,
) -> impl Draw<'a, S> {
) -> impl Draw<S> {
draw(move|_to: &mut S|{ todo!() })
}
/// Iterate over a collection of the same kind of [Draw]able:
pub fn iter_once <'a, S: Screen, D: 'a, U: Draw<'a, S>> (
pub fn iter_once <'a, S: Screen, D: 'a, U: Draw<S>> (
_iter: impl Iterator<Item = D>, _draw: impl Fn(D, usize)->U,
) -> impl Draw<'a, S> {
) -> impl Draw<S> {
draw(move|_to: &mut S|{ todo!() })
}
@ -65,55 +65,55 @@ pub fn iter_dyn <
D, // Input doesn't need to be [Draw]able, output does
V: Fn()->I, // Function that returns the iterator
I: Iterator<Item = D>, // Type of the iterator
F: Fn(&D, usize)->dyn Draw<'a, S>, // Function that returns [Draw]able from iterator item
> (_items: V, _cb: F) -> impl Draw<'a, S> {
F: Fn(&D, usize)->dyn Draw<S>, // Function that returns [Draw]able from iterator item
> (_items: V, _cb: F) -> impl Draw<S> {
draw(move|_to: &mut S|{ todo!() })
}
pub fn iter_north <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<'a, S>> (
pub fn iter_north <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
_iter: impl Fn()->I, _draw: impl Fn(D, usize)->U,
) -> impl Draw<'a, S> {
) -> impl Draw<S> {
draw(move|_to: &mut S|{ todo!() })
}
pub fn iter_east_fixed <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<'a, S>> (
pub fn iter_east_fixed <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
_height: S::Unit, _iter: impl Fn()->I, _draw: impl Fn(D, usize)->U,
) -> impl Draw<'a, S> {
) -> impl Draw<S> {
draw(move|_to: &mut S|{ todo!() })
}
pub fn iter_south_fixed <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<'a, S>> (
pub fn iter_south_fixed <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
_height: S::Unit, _iter: impl Fn()->I, _draw: impl Fn(D, usize)->U,
) -> impl Draw<'a, S> {
) -> impl Draw<S> {
draw(move|_to: &mut S|{ todo!() })
}
pub fn iter_west <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<'a, S>> (
pub fn iter_west <'a, S: Screen, D: 'a, I: Iterator<Item = D>, U: Draw<S>> (
_iter: impl Fn()->I, _draw: impl Fn(D, usize)->U,
) -> impl Draw<'a, S> {
) -> impl Draw<S> {
draw(move|_to: &mut S|{ todo!() })
}
pub fn row_south <'a, S: Screen + 'a> (south: S::Unit, height: S::Unit, content: impl Draw<'a, S>)
-> impl Draw<'a, S>
pub fn row_south <'a, S: Screen + 'a> (south: S::Unit, height: S::Unit, content: impl Draw<S>)
-> impl Draw<S>
{
content.exact_h(height).push_y(south)
}
pub fn row_north <'a, S: Screen + 'a> (north: S::Unit, height: S::Unit, content: impl Draw<'a, S>)
-> impl Draw<'a, S>
pub fn row_north <'a, S: Screen + 'a> (north: S::Unit, height: S::Unit, content: impl Draw<S>)
-> impl Draw<S>
{
content.exact_h(height).pull_y(north)
}
pub fn col_east <'a, S: Screen + 'a> (east: S::Unit, width: S::Unit, content: impl Draw<'a, S>)
-> impl Draw<'a, S>
pub fn col_east <'a, S: Screen + 'a> (east: S::Unit, width: S::Unit, content: impl Draw<S>)
-> impl Draw<S>
{
content.exact_w(width).push_x(east)
}
pub fn col_west <'a, S: Screen + 'a> (west: S::Unit, width: S::Unit, content: impl Draw<'a, S>)
-> impl Draw<'a, S>
pub fn col_west <'a, S: Screen + 'a> (west: S::Unit, width: S::Unit, content: impl Draw<S>)
-> impl Draw<S>
{
content.exact_w(width).pull_x(west)
}