mirror of
https://codeberg.org/unspeaker/tek.git
synced 2025-12-07 12:16:42 +01:00
rename Widget to Render and CustomWidget to Widget
This commit is contained in:
parent
f018988567
commit
bf3c7630a4
20 changed files with 144 additions and 144 deletions
|
|
@ -8,7 +8,7 @@ fn main () -> Usually<()> {
|
|||
|
||||
pub struct Demo<E: Engine> {
|
||||
index: usize,
|
||||
items: Vec<Box<dyn Widget<Engine = E>>>
|
||||
items: Vec<Box<dyn Render<Engine = E>>>
|
||||
}
|
||||
|
||||
impl Demo<Tui> {
|
||||
|
|
@ -35,7 +35,7 @@ impl Demo<Tui> {
|
|||
|
||||
impl Content for Demo<Tui> {
|
||||
type Engine = Tui;
|
||||
fn content (&self) -> impl Widget<Engine = Tui> {
|
||||
fn content (&self) -> impl Render<Engine = Tui> {
|
||||
let border_style = Style::default().fg(Color::Rgb(0,0,0));
|
||||
Align::Center(Layers::new(move|add|{
|
||||
|
||||
|
|
|
|||
|
|
@ -40,14 +40,14 @@ pub trait Output<E: Engine> {
|
|||
/// Mutable pointer to area
|
||||
fn area_mut (&mut self) -> &mut E::Area;
|
||||
/// Render widget in area
|
||||
fn render_in (&mut self, area: E::Area, widget: &dyn Widget<Engine = E>) -> Usually<()>;
|
||||
fn render_in (&mut self, area: E::Area, widget: &dyn Render<Engine = E>) -> Usually<()>;
|
||||
}
|
||||
/// Cast to dynamic pointer
|
||||
pub fn widget <E: Engine, T: Widget<Engine = E>> (w: &T) -> &dyn Widget<Engine = E> {
|
||||
w as &dyn Widget<Engine = E>
|
||||
pub fn widget <E: Engine, T: Render<Engine = E>> (w: &T) -> &dyn Render<Engine = E> {
|
||||
w as &dyn Render<Engine = E>
|
||||
}
|
||||
/// A renderable component
|
||||
pub trait Widget: Send + Sync {
|
||||
pub trait Render: Send + Sync {
|
||||
/// Engine for which this component is implemented
|
||||
type Engine: Engine;
|
||||
/// Minimum size to use
|
||||
|
|
@ -59,7 +59,7 @@ pub trait Widget: Send + Sync {
|
|||
/// Draw to output render target
|
||||
fn render (&self,to: &mut <Self::Engine as Engine>::Output) -> Usually<()>;
|
||||
}
|
||||
impl<E: Engine> Widget for &dyn Widget<Engine = E> {
|
||||
impl<E: Engine> Render for &dyn Render<Engine = E> {
|
||||
type Engine = E;
|
||||
fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
(*self).min_size(to)
|
||||
|
|
@ -68,7 +68,7 @@ impl<E: Engine> Widget for &dyn Widget<Engine = E> {
|
|||
(*self).render(to)
|
||||
}
|
||||
}
|
||||
impl<E: Engine> Widget for &mut dyn Widget<Engine = E> {
|
||||
impl<E: Engine> Render for &mut dyn Render<Engine = E> {
|
||||
type Engine = E;
|
||||
fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
(**self).min_size(to)
|
||||
|
|
@ -77,7 +77,7 @@ impl<E: Engine> Widget for &mut dyn Widget<Engine = E> {
|
|||
(**self).render(to)
|
||||
}
|
||||
}
|
||||
impl<'a, E: Engine> Widget for Box<dyn Widget<Engine = E> + 'a> {
|
||||
impl<'a, E: Engine> Render for Box<dyn Render<Engine = E> + 'a> {
|
||||
type Engine = E;
|
||||
fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
(**self).min_size(to)
|
||||
|
|
@ -86,7 +86,7 @@ impl<'a, E: Engine> Widget for Box<dyn Widget<Engine = E> + 'a> {
|
|||
(**self).render(to)
|
||||
}
|
||||
}
|
||||
impl<E: Engine, W: Widget<Engine = E>> Widget for Arc<W> {
|
||||
impl<E: Engine, W: Render<Engine = E>> Render for Arc<W> {
|
||||
type Engine = E;
|
||||
fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
self.as_ref().min_size(to)
|
||||
|
|
@ -95,7 +95,7 @@ impl<E: Engine, W: Widget<Engine = E>> Widget for Arc<W> {
|
|||
self.as_ref().render(to)
|
||||
}
|
||||
}
|
||||
impl<E: Engine, W: Widget<Engine = E>> Widget for Mutex<W> {
|
||||
impl<E: Engine, W: Render<Engine = E>> Render for Mutex<W> {
|
||||
type Engine = E;
|
||||
fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
self.lock().unwrap().min_size(to)
|
||||
|
|
@ -104,7 +104,7 @@ impl<E: Engine, W: Widget<Engine = E>> Widget for Mutex<W> {
|
|||
self.lock().unwrap().render(to)
|
||||
}
|
||||
}
|
||||
impl<E: Engine, W: Widget<Engine = E>> Widget for RwLock<W> {
|
||||
impl<E: Engine, W: Render<Engine = E>> Render for RwLock<W> {
|
||||
type Engine = E;
|
||||
fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
self.read().unwrap().min_size(to)
|
||||
|
|
@ -113,7 +113,7 @@ impl<E: Engine, W: Widget<Engine = E>> Widget for RwLock<W> {
|
|||
self.read().unwrap().render(to)
|
||||
}
|
||||
}
|
||||
impl<E: Engine, W: Widget<Engine = E>> Widget for Option<W> {
|
||||
impl<E: Engine, W: Render<Engine = E>> Render for Option<W> {
|
||||
type Engine = E;
|
||||
fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
Ok(self.as_ref().map(|widget|widget.min_size(to)).transpose()?.flatten())
|
||||
|
|
@ -123,12 +123,12 @@ impl<E: Engine, W: Widget<Engine = E>> Widget for Option<W> {
|
|||
}
|
||||
}
|
||||
/// Render either of two widgets depending on predicate
|
||||
pub struct Either<E: Engine, A: Widget<Engine = E>, B: Widget<Engine = E>>(
|
||||
pub struct Either<E: Engine, A: Render<Engine = E>, B: Render<Engine = E>>(
|
||||
pub bool,
|
||||
pub A,
|
||||
pub B,
|
||||
);
|
||||
impl<E: Engine, A: Widget<Engine = E>, B: Widget<Engine = E>> Widget for Either<E, A, B> {
|
||||
impl<E: Engine, A: Render<Engine = E>, B: Render<Engine = E>> Render for Either<E, A, B> {
|
||||
type Engine = E;
|
||||
fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
if self.0 { self.1.min_size(to) } else { self.2.min_size(to) }
|
||||
|
|
@ -137,8 +137,8 @@ impl<E: Engine, A: Widget<Engine = E>, B: Widget<Engine = E>> Widget for Either<
|
|||
if self.0 { self.1.render(to) } else { self.2.render(to) }
|
||||
}
|
||||
}
|
||||
/// A custom [Widget] defined by passing layout and render closures in place.
|
||||
pub struct CustomWidget<
|
||||
/// 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<()>
|
||||
|
|
@ -147,7 +147,7 @@ impl<
|
|||
E: Engine,
|
||||
L: Send + Sync + Fn(E::Size)->Perhaps<E::Size>,
|
||||
R: Send + Sync + Fn(&mut E::Output)->Usually<()>
|
||||
> CustomWidget<E, L, R> {
|
||||
> Widget<E, L, R> {
|
||||
pub fn new (layout: L, render: R) -> Self {
|
||||
Self(layout, render, Default::default())
|
||||
}
|
||||
|
|
@ -156,7 +156,7 @@ impl<
|
|||
E: Engine,
|
||||
L: Send + Sync + Fn(E::Size)->Perhaps<E::Size>,
|
||||
R: Send + Sync + Fn(&mut E::Output)->Usually<()>
|
||||
> Widget for CustomWidget<E, L, R> {
|
||||
> Render for Widget<E, L, R> {
|
||||
type Engine = E;
|
||||
fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
self.0(to)
|
||||
|
|
@ -165,13 +165,13 @@ impl<
|
|||
self.1(to)
|
||||
}
|
||||
}
|
||||
/// A [Widget] that contains other [Widget]s
|
||||
/// A [Render] that contains other [Render]s
|
||||
pub trait Content: Send + Sync {
|
||||
type Engine: Engine;
|
||||
fn content (&self) -> impl Widget<Engine = <Self as Content>::Engine>;
|
||||
fn content (&self) -> impl Render<Engine = <Self as Content>::Engine>;
|
||||
}
|
||||
/// Every struct that has [Content] is a renderable [Widget].
|
||||
impl<E: Engine, W: Content<Engine = E>> Widget for W {
|
||||
/// Every struct that has [Content] is a renderable [Render].
|
||||
impl<E: Engine, W: Content<Engine = E>> Render for W {
|
||||
type Engine = E;
|
||||
fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
self.content().min_size(to)
|
||||
|
|
@ -221,12 +221,12 @@ impl<H, E: Engine> Handle<E> for Arc<RwLock<H>> where H: Handle<E> {
|
|||
self.write().unwrap().handle(context)
|
||||
}
|
||||
}
|
||||
/// A UI component that can render itself as a [Widget], and [Handle] input.
|
||||
pub trait Component<E: Engine>: Widget<Engine = E> + Handle<E> {}
|
||||
/// Everything that implements [Widget] and [Handle] is a [Component].
|
||||
impl<E: Engine, C: Widget<Engine = E> + Handle<E>> Component<E> for C {}
|
||||
/// A UI component that can render itself as a [Render], and [Handle] input.
|
||||
pub trait Component<E: Engine>: Render<Engine = E> + Handle<E> {}
|
||||
/// Everything that implements [Render] and [Handle] is a [Component].
|
||||
impl<E: Engine, C: Render<Engine = E> + Handle<E>> Component<E> for C {}
|
||||
/// A UI component that has [Content] and can [Handle] input.
|
||||
pub trait ContentComponent<E: Engine>: Widget<Engine = E> + Handle<E> {}
|
||||
pub trait ContentComponent<E: Engine>: Render<Engine = E> + Handle<E> {}
|
||||
/// Everything that implements [Content] and [Handle] is a [Component].
|
||||
impl<E: Engine, C: Content<Engine = E> + Handle<E>> ContentComponent<E> for C {}
|
||||
/// A component that can exit.
|
||||
|
|
|
|||
|
|
@ -126,7 +126,7 @@ impl<N: Coordinate> Area<N> for [N;4] {
|
|||
#[inline] fn h (&self) -> N { self[3] }
|
||||
}
|
||||
|
||||
pub trait Layout<E: Engine>: Widget<Engine = E> + Sized {
|
||||
pub trait Layout<E: Engine>: Render<Engine = E> + Sized {
|
||||
fn align_center (self) -> Align<Self> { Align::Center(self) }
|
||||
fn align_n (self) -> Align<Self> { Align::N(self) }
|
||||
fn align_s (self) -> Align<Self> { Align::S(self) }
|
||||
|
|
@ -169,21 +169,21 @@ pub trait Layout<E: Engine>: Widget<Engine = E> + Sized {
|
|||
fn fill_y (self) -> Fill<E, Self> { Fill::Y(self) }
|
||||
fn fill_xy (self) -> Fill<E, Self> { Fill::XY(self) }
|
||||
fn debug (self) -> DebugOverlay<E, Self> { DebugOverlay(self) }
|
||||
fn split <W: Widget<Engine = E>> (
|
||||
fn split <W: Render<Engine = E>> (
|
||||
self, direction: Direction, amount: E::Unit, other: W
|
||||
) -> Split<E, Self, W> { Split::new(direction, amount, self, other) }
|
||||
fn split_flip <W: Widget<Engine = E>> (
|
||||
fn split_flip <W: Render<Engine = E>> (
|
||||
self, direction: Direction, amount: E::Unit, other: W
|
||||
) -> Split<E, W, Self> { Split::new(direction, amount, other, self) }
|
||||
}
|
||||
|
||||
impl<E: Engine, W: Widget<Engine = E>> Layout<E> for W {}
|
||||
impl<E: Engine, W: Render<Engine = E>> Layout<E> for W {}
|
||||
|
||||
pub struct DebugOverlay<E: Engine, W: Widget<Engine = E>>(pub W);
|
||||
pub struct DebugOverlay<E: Engine, W: Render<Engine = E>>(pub W);
|
||||
|
||||
pub enum Fill<E: Engine, W: Widget<Engine = E>> { X(W), Y(W), XY(W) }
|
||||
pub enum Fill<E: Engine, W: Render<Engine = E>> { X(W), Y(W), XY(W) }
|
||||
|
||||
impl<E: Engine, W: Widget<Engine = E>> Fill<E, W> {
|
||||
impl<E: Engine, W: Render<Engine = E>> Fill<E, W> {
|
||||
fn inner (&self) -> &W {
|
||||
match self {
|
||||
Self::X(inner) => &inner,
|
||||
|
|
@ -193,7 +193,7 @@ impl<E: Engine, W: Widget<Engine = E>> Fill<E, W> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<E: Engine, W: Widget<Engine = E>> Widget for Fill<E, W> {
|
||||
impl<E: Engine, W: Render<Engine = E>> Render for Fill<E, W> {
|
||||
type Engine = E;
|
||||
fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
let area = self.inner().min_size(to.into())?;
|
||||
|
|
@ -214,12 +214,12 @@ impl<E: Engine, W: Widget<Engine = E>> Widget for Fill<E, W> {
|
|||
|
||||
pub struct Layers<
|
||||
E: Engine,
|
||||
F: Send + Sync + Fn(&mut dyn FnMut(&dyn Widget<Engine = E>)->Usually<()>)->Usually<()>
|
||||
F: Send + Sync + Fn(&mut dyn FnMut(&dyn Render<Engine = E>)->Usually<()>)->Usually<()>
|
||||
>(pub F, PhantomData<E>);
|
||||
|
||||
impl<
|
||||
E: Engine,
|
||||
F: Send + Sync + Fn(&mut dyn FnMut(&dyn Widget<Engine = E>)->Usually<()>)->Usually<()>
|
||||
F: Send + Sync + Fn(&mut dyn FnMut(&dyn Render<Engine = E>)->Usually<()>)->Usually<()>
|
||||
> Layers<E, F> {
|
||||
#[inline]
|
||||
pub fn new (build: F) -> Self {
|
||||
|
|
@ -227,9 +227,9 @@ impl<
|
|||
}
|
||||
}
|
||||
|
||||
impl<E: Engine, F> Widget for Layers<E, F>
|
||||
impl<E: Engine, F> Render for Layers<E, F>
|
||||
where
|
||||
F: Send + Sync + Fn(&mut dyn FnMut(&dyn Widget<Engine = E>)->Usually<()>)->Usually<()>
|
||||
F: Send + Sync + Fn(&mut dyn FnMut(&dyn Render<Engine = E>)->Usually<()>)->Usually<()>
|
||||
{
|
||||
type Engine = E;
|
||||
fn min_size (&self, area: E::Size) -> Perhaps<E::Size> {
|
||||
|
|
@ -346,7 +346,7 @@ fn align<T, N: Coordinate, R: Area<N> + From<[N;4]>> (align: &Align<T>, outer: R
|
|||
}
|
||||
}
|
||||
|
||||
impl<E: Engine, T: Widget<Engine = E>> Widget for Align<T> {
|
||||
impl<E: Engine, T: Render<Engine = E>> Render for Align<T> {
|
||||
type Engine = E;
|
||||
fn min_size (&self, outer_area: E::Size) -> Perhaps<E::Size> {
|
||||
self.inner().min_size(outer_area)
|
||||
|
|
@ -380,7 +380,7 @@ impl<N: Coordinate, T> Fixed<N, T> {
|
|||
match self { Self::X(_, i) => i, Self::Y(_, i) => i, Self::XY(_, _, i) => i, }
|
||||
}
|
||||
}
|
||||
impl<E: Engine, T: Widget<Engine = E>> Widget for Fixed<E::Unit, T> {
|
||||
impl<E: Engine, T: Render<Engine = E>> Render for Fixed<E::Unit, T> {
|
||||
type Engine = E;
|
||||
fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
Ok(match self {
|
||||
|
|
@ -416,7 +416,7 @@ impl<N: Coordinate, T> Min<N, T> {
|
|||
match self { Self::X(_, i) => i, Self::Y(_, i) => i, Self::XY(_, _, i) => i, }
|
||||
}
|
||||
}
|
||||
impl<E: Engine, T: Widget<Engine = E>> Widget for Min<E::Unit, T> {
|
||||
impl<E: Engine, T: Render<Engine = E>> Render for Min<E::Unit, T> {
|
||||
type Engine = E;
|
||||
fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
Ok(self.inner().min_size(to)?.map(|to|match *self {
|
||||
|
|
@ -449,7 +449,7 @@ impl<N: Coordinate, T> Max<N, T> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<E: Engine, T: Widget<Engine = E>> Widget for Max<E:: Unit, T> {
|
||||
impl<E: Engine, T: Render<Engine = E>> Render for Max<E:: Unit, T> {
|
||||
type Engine = E;
|
||||
fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
Ok(self.inner().min_size(to)?.map(|to|match *self {
|
||||
|
|
@ -481,7 +481,7 @@ impl<N: Coordinate, T> Grow<N, T> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<E: Engine, T: Widget<Engine = E>> Widget for Grow<E::Unit, T> {
|
||||
impl<E: Engine, T: Render<Engine = E>> Render for Grow<E::Unit, T> {
|
||||
type Engine = E;
|
||||
fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
Ok(self.inner().min_size(to)?.map(|to|match *self {
|
||||
|
|
@ -507,13 +507,13 @@ pub enum Shrink<N: Coordinate, T> {
|
|||
XY(N, N, T),
|
||||
}
|
||||
|
||||
impl<N: Coordinate, T: Widget> Shrink<N, T> {
|
||||
impl<N: Coordinate, T: Render> Shrink<N, T> {
|
||||
fn inner (&self) -> &T {
|
||||
match self { Self::X(_, i) => i, Self::Y(_, i) => i, Self::XY(_, _, i) => i, }
|
||||
}
|
||||
}
|
||||
|
||||
impl<E: Engine, T: Widget<Engine = E>> Widget for Shrink<E::Unit, T> {
|
||||
impl<E: Engine, T: Render<Engine = E>> Render for Shrink<E::Unit, T> {
|
||||
type Engine = E;
|
||||
fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
Ok(self.inner().min_size(to)?.map(|to|match *self {
|
||||
|
|
@ -548,7 +548,7 @@ pub enum Inset<N: Coordinate, T> {
|
|||
XY(N, N, T),
|
||||
}
|
||||
|
||||
impl<N: Coordinate, T: Widget> Inset<N, T> {
|
||||
impl<N: Coordinate, T: Render> Inset<N, T> {
|
||||
pub fn inner (&self) -> &T {
|
||||
match self { Self::X(_, i) => i, Self::Y(_, i) => i, Self::XY(_, _, i) => i, }
|
||||
}
|
||||
|
|
@ -564,52 +564,52 @@ pub enum Outset<N: Coordinate, T> {
|
|||
XY(N, N, T),
|
||||
}
|
||||
|
||||
impl<N: Coordinate, T: Widget> Outset<N, T> {
|
||||
impl<N: Coordinate, T: Render> Outset<N, T> {
|
||||
pub fn inner (&self) -> &T {
|
||||
match self { Self::X(_, i) => i, Self::Y(_, i) => i, Self::XY(_, _, i) => i, }
|
||||
}
|
||||
}
|
||||
|
||||
impl<E: Engine, T: Widget<Engine = E>> Widget for Inset<E::Unit, T> {
|
||||
impl<E: Engine, T: Render<Engine = E>> Render for Inset<E::Unit, T> {
|
||||
type Engine = E;
|
||||
fn render (&self, to: &mut E::Output) -> Usually<()> {
|
||||
match *self {
|
||||
Self::X(x, ref inner) =>
|
||||
(inner as &dyn Widget<Engine = E>).shrink_x(x).push_x(x),
|
||||
(inner as &dyn Render<Engine = E>).shrink_x(x).push_x(x),
|
||||
Self::Y(y, ref inner) =>
|
||||
(inner as &dyn Widget<Engine = E>).shrink_y(y).push_y(y),
|
||||
(inner as &dyn Render<Engine = E>).shrink_y(y).push_y(y),
|
||||
Self::XY(x, y, ref inner) =>
|
||||
(inner as &dyn Widget<Engine = E>).shrink_xy(x, y).push_xy(x, y)
|
||||
(inner as &dyn Render<Engine = E>).shrink_xy(x, y).push_xy(x, y)
|
||||
}.render(to)
|
||||
}
|
||||
}
|
||||
|
||||
impl<E: Engine, T: Widget<Engine = E>> Widget for Outset<E::Unit, T> {
|
||||
impl<E: Engine, T: Render<Engine = E>> Render for Outset<E::Unit, T> {
|
||||
type Engine = E;
|
||||
fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
match *self {
|
||||
Self::X(x, ref inner) =>
|
||||
(inner as &dyn Widget<Engine = E>).grow_x(x + x),
|
||||
(inner as &dyn Render<Engine = E>).grow_x(x + x),
|
||||
Self::Y(y, ref inner) =>
|
||||
(inner as &dyn Widget<Engine = E>).grow_y(y + y),
|
||||
(inner as &dyn Render<Engine = E>).grow_y(y + y),
|
||||
Self::XY(x, y, ref inner) =>
|
||||
(inner as &dyn Widget<Engine = E>).grow_xy(x + x, y + y),
|
||||
(inner as &dyn Render<Engine = E>).grow_xy(x + x, y + y),
|
||||
}.min_size(to)
|
||||
}
|
||||
fn render (&self, to: &mut E::Output) -> Usually<()> {
|
||||
match *self {
|
||||
Self::X(x, ref inner) =>
|
||||
(inner as &dyn Widget<Engine = E>).push_x(x),
|
||||
(inner as &dyn Render<Engine = E>).push_x(x),
|
||||
Self::Y(y, ref inner) =>
|
||||
(inner as &dyn Widget<Engine = E>).push_y(y),
|
||||
(inner as &dyn Render<Engine = E>).push_y(y),
|
||||
Self::XY(x, y, ref inner) =>
|
||||
(inner as &dyn Widget<Engine = E>).push_xy(x, y),
|
||||
(inner as &dyn Render<Engine = E>).push_xy(x, y),
|
||||
}.render(to)
|
||||
}
|
||||
}
|
||||
|
||||
/// Move origin point of drawing area
|
||||
pub enum Push<N: Coordinate, T: Widget> {
|
||||
pub enum Push<N: Coordinate, T: Render> {
|
||||
/// Move origin to the right
|
||||
X(N, T),
|
||||
/// Move origin downwards
|
||||
|
|
@ -618,7 +618,7 @@ pub enum Push<N: Coordinate, T: Widget> {
|
|||
XY(N, N, T),
|
||||
}
|
||||
|
||||
impl<N: Coordinate, T: Widget> Push<N, T> {
|
||||
impl<N: Coordinate, T: Render> Push<N, T> {
|
||||
pub fn inner (&self) -> &T {
|
||||
match self { Self::X(_, i) => i, Self::Y(_, i) => i, Self::XY(_, _, i) => i, }
|
||||
}
|
||||
|
|
@ -630,7 +630,7 @@ impl<N: Coordinate, T: Widget> Push<N, T> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<E: Engine, T: Widget<Engine = E>> Widget for Push<E::Unit, T> {
|
||||
impl<E: Engine, T: Render<Engine = E>> Render for Push<E::Unit, T> {
|
||||
type Engine = E;
|
||||
fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
self.inner().min_size(to)
|
||||
|
|
@ -647,7 +647,7 @@ impl<E: Engine, T: Widget<Engine = E>> Widget for Push<E::Unit, T> {
|
|||
}
|
||||
|
||||
/// Move origin point of drawing area
|
||||
pub enum Pull<N: Coordinate, T: Widget> {
|
||||
pub enum Pull<N: Coordinate, T: Render> {
|
||||
/// Move origin to the right
|
||||
X(N, T),
|
||||
/// Move origin downwards
|
||||
|
|
@ -656,7 +656,7 @@ pub enum Pull<N: Coordinate, T: Widget> {
|
|||
XY(N, N, T),
|
||||
}
|
||||
|
||||
impl<N: Coordinate, T: Widget> Pull<N, T> {
|
||||
impl<N: Coordinate, T: Render> Pull<N, T> {
|
||||
pub fn inner (&self) -> &T {
|
||||
match self { Self::X(_, i) => i, Self::Y(_, i) => i, Self::XY(_, _, i) => i, }
|
||||
}
|
||||
|
|
@ -668,7 +668,7 @@ impl<N: Coordinate, T: Widget> Pull<N, T> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<E: Engine, T: Widget<Engine = E>> Widget for Pull<E::Unit, T> {
|
||||
impl<E: Engine, T: Render<Engine = E>> Render for Pull<E::Unit, T> {
|
||||
type Engine = E;
|
||||
fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
self.inner().min_size(to)
|
||||
|
|
@ -686,12 +686,12 @@ impl<E: Engine, T: Widget<Engine = E>> Widget for Pull<E::Unit, T> {
|
|||
|
||||
pub struct Stack<
|
||||
E: Engine,
|
||||
F: Send + Sync + Fn(&mut dyn FnMut(&dyn Widget<Engine = E>)->Usually<()>)->Usually<()>
|
||||
F: Send + Sync + Fn(&mut dyn FnMut(&dyn Render<Engine = E>)->Usually<()>)->Usually<()>
|
||||
>(pub F, pub Direction, PhantomData<E>);
|
||||
|
||||
impl<
|
||||
E: Engine,
|
||||
F: Send + Sync + Fn(&mut dyn FnMut(&dyn Widget<Engine = E>)->Usually<()>)->Usually<()>
|
||||
F: Send + Sync + Fn(&mut dyn FnMut(&dyn Render<Engine = E>)->Usually<()>)->Usually<()>
|
||||
> Stack<E, F> {
|
||||
#[inline] pub fn new (direction: Direction, build: F) -> Self {
|
||||
Self(build, direction, Default::default())
|
||||
|
|
@ -704,9 +704,9 @@ impl<
|
|||
}
|
||||
}
|
||||
|
||||
impl<E: Engine, F> Widget for Stack<E, F>
|
||||
impl<E: Engine, F> Render for Stack<E, F>
|
||||
where
|
||||
F: Send + Sync + Fn(&mut dyn FnMut(&dyn Widget<Engine = E>)->Usually<()>)->Usually<()>
|
||||
F: Send + Sync + Fn(&mut dyn FnMut(&dyn Render<Engine = E>)->Usually<()>)->Usually<()>
|
||||
{
|
||||
type Engine = E;
|
||||
fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
|
|
@ -808,11 +808,11 @@ where
|
|||
}
|
||||
|
||||
/// A binary split with fixed proportion
|
||||
pub struct Split<E: Engine, A: Widget<Engine = E>, B: Widget<Engine = E>>(
|
||||
pub struct Split<E: Engine, A: Render<Engine = E>, B: Render<Engine = E>>(
|
||||
pub Direction, pub E::Unit, A, B, PhantomData<E>
|
||||
);
|
||||
|
||||
impl<E: Engine, A: Widget<Engine = E>, B: Widget<Engine = E>> Split<E, A, B> {
|
||||
impl<E: Engine, A: Render<Engine = E>, B: Render<Engine = E>> Split<E, A, B> {
|
||||
pub fn new (direction: Direction, proportion: E::Unit, a: A, b: B) -> Self {
|
||||
Self(direction, proportion, a, b, Default::default())
|
||||
}
|
||||
|
|
@ -830,7 +830,7 @@ impl<E: Engine, A: Widget<Engine = E>, B: Widget<Engine = E>> Split<E, A, B> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<E: Engine, A: Widget<Engine = E>, B: Widget<Engine = E>> Widget for Split<E, A, B> {
|
||||
impl<E: Engine, A: Render<Engine = E>, B: Render<Engine = E>> Render for Split<E, A, B> {
|
||||
type Engine = E;
|
||||
fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
|
||||
Ok(Some(to))
|
||||
|
|
@ -876,7 +876,7 @@ impl<E: Engine> Measure<E> {
|
|||
pub fn format (&self) -> String { format!("{}x{}", self.w(), self.h()) }
|
||||
}
|
||||
|
||||
impl<E: Engine> Widget for Measure<E> {
|
||||
impl<E: Engine> Render for Measure<E> {
|
||||
type Engine = E;
|
||||
fn min_size (&self, _: E::Size) -> Perhaps<E::Size> {
|
||||
Ok(Some([0u16.into(), 0u16.into()].into()))
|
||||
|
|
@ -891,5 +891,5 @@ impl<E: Engine> Widget for Measure<E> {
|
|||
/// A scrollable area.
|
||||
pub struct Scroll<
|
||||
E: Engine,
|
||||
F: Send + Sync + Fn(&mut dyn FnMut(&dyn Widget<Engine = E>)->Usually<()>)->Usually<()>
|
||||
F: Send + Sync + Fn(&mut dyn FnMut(&dyn Render<Engine = E>)->Usually<()>)->Usually<()>
|
||||
>(pub F, pub Direction, pub u64, PhantomData<E>);
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ impl Engine for TestEngine {
|
|||
#[derive(Copy, Clone)]
|
||||
struct TestArea(u16, u16);
|
||||
|
||||
impl Widget for TestArea {
|
||||
impl Render for TestArea {
|
||||
type Engine = TestEngine;
|
||||
fn min_size (&self, to: [u16;2]) -> Perhaps<[u16;2]> {
|
||||
Ok(Some([to[0], to[1], self.0, self.1]))
|
||||
|
|
|
|||
|
|
@ -165,7 +165,7 @@ impl Output<Tui> for TuiOutput {
|
|||
#[inline] fn area_mut (&mut self) -> &mut [u16;4] { &mut self.area }
|
||||
#[inline] fn render_in (&mut self,
|
||||
area: [u16;4],
|
||||
widget: &dyn Widget<Engine = Tui>
|
||||
widget: &dyn Render<Engine = Tui>
|
||||
) -> Usually<()> {
|
||||
let last = self.area();
|
||||
*self.area_mut() = area;
|
||||
|
|
@ -287,7 +287,7 @@ pub fn buffer_update (buf: &mut Buffer, area: [u16;4], callback: &impl Fn(&mut C
|
|||
}
|
||||
}
|
||||
}
|
||||
impl Widget for &str {
|
||||
impl Render for &str {
|
||||
type Engine = Tui;
|
||||
fn min_size (&self, _: [u16;2]) -> Perhaps<[u16;2]> {
|
||||
// TODO: line breaks
|
||||
|
|
@ -299,7 +299,7 @@ impl Widget for &str {
|
|||
Ok(to.blit(&self, x, y, None))
|
||||
}
|
||||
}
|
||||
impl Widget for String {
|
||||
impl Render for String {
|
||||
type Engine = Tui;
|
||||
fn min_size (&self, _: [u16;2]) -> Perhaps<[u16;2]> {
|
||||
// TODO: line breaks
|
||||
|
|
@ -311,7 +311,7 @@ impl Widget for String {
|
|||
Ok(to.blit(&self, x, y, None))
|
||||
}
|
||||
}
|
||||
impl<T: Widget<Engine = Tui>> Widget for DebugOverlay<Tui, T> {
|
||||
impl<T: Render<Engine = Tui>> Render for DebugOverlay<Tui, T> {
|
||||
type Engine = Tui;
|
||||
fn min_size (&self, to: [u16;2]) -> Perhaps<[u16;2]> {
|
||||
self.0.min_size(to)
|
||||
|
|
@ -322,8 +322,8 @@ impl<T: Widget<Engine = Tui>> Widget for DebugOverlay<Tui, T> {
|
|||
Ok(to.blit(&format!("{w}x{h}+{x}+{y}"), x, y, Some(Style::default().green())))
|
||||
}
|
||||
}
|
||||
pub struct Styled<T: Widget<Engine = Tui>>(pub Option<Style>, pub T);
|
||||
impl Widget for Styled<&str> {
|
||||
pub struct Styled<T: Render<Engine = Tui>>(pub Option<Style>, pub T);
|
||||
impl Render for Styled<&str> {
|
||||
type Engine = Tui;
|
||||
fn min_size (&self, _: [u16;2]) -> Perhaps<[u16;2]> {
|
||||
Ok(Some([self.1.chars().count() as u16, 1]))
|
||||
|
|
@ -335,41 +335,41 @@ impl Widget for Styled<&str> {
|
|||
Ok(to.blit(&self.1, x, y, None))
|
||||
}
|
||||
}
|
||||
pub trait TuiStyle: Widget<Engine = Tui> + Sized {
|
||||
fn fg (self, color: Color) -> impl Widget<Engine = Tui> {
|
||||
pub trait TuiStyle: Render<Engine = Tui> + Sized {
|
||||
fn fg (self, color: Color) -> impl Render<Engine = Tui> {
|
||||
Layers::new(move |add|{ add(&Foreground(color))?; add(&self) })
|
||||
}
|
||||
fn bg (self, color: Color) -> impl Widget<Engine = Tui> {
|
||||
fn bg (self, color: Color) -> impl Render<Engine = Tui> {
|
||||
Layers::new(move |add|{ add(&Background(color))?; add(&self) })
|
||||
}
|
||||
fn bold (self, on: bool) -> impl Widget<Engine = Tui> {
|
||||
fn bold (self, on: bool) -> impl Render<Engine = Tui> {
|
||||
Layers::new(move |add|{ add(&Bold(on))?; add(&self) })
|
||||
}
|
||||
fn border (self, style: impl BorderStyle) -> impl Widget<Engine = Tui> {
|
||||
fn border (self, style: impl BorderStyle) -> impl Render<Engine = Tui> {
|
||||
Bordered(style, self)
|
||||
}
|
||||
}
|
||||
impl<W: Widget<Engine = Tui>> TuiStyle for W {}
|
||||
impl<W: Render<Engine = Tui>> TuiStyle for W {}
|
||||
pub struct Bold(pub bool);
|
||||
impl Widget for Bold {
|
||||
impl Render for Bold {
|
||||
type Engine = Tui;
|
||||
fn min_size (&self, _: [u16;2]) -> Perhaps<[u16;2]> { Ok(Some([0,0])) }
|
||||
fn render (&self, to: &mut TuiOutput) -> Usually<()> { Ok(to.fill_bold(to.area(), self.0)) }
|
||||
}
|
||||
pub struct Foreground(pub Color);
|
||||
impl Widget for Foreground {
|
||||
impl Render for Foreground {
|
||||
type Engine = Tui;
|
||||
fn min_size (&self, _: [u16;2]) -> Perhaps<[u16;2]> { Ok(Some([0,0])) }
|
||||
fn render (&self, to: &mut TuiOutput) -> Usually<()> { Ok(to.fill_fg(to.area(), self.0)) }
|
||||
}
|
||||
pub struct Background(pub Color);
|
||||
impl Widget for Background {
|
||||
impl Render for Background {
|
||||
type Engine = Tui;
|
||||
fn min_size (&self, _: [u16;2]) -> Perhaps<[u16;2]> { Ok(Some([0,0])) }
|
||||
fn render (&self, to: &mut TuiOutput) -> Usually<()> { Ok(to.fill_bg(to.area(), self.0)) }
|
||||
}
|
||||
pub struct Border<S: BorderStyle>(pub S);
|
||||
impl<S: BorderStyle> Widget for Border<S> {
|
||||
impl<S: BorderStyle> Render for Border<S> {
|
||||
type Engine = Tui;
|
||||
fn min_size (&self, _: [u16;2]) -> Perhaps<[u16;2]> {
|
||||
Ok(Some([0, 0]))
|
||||
|
|
@ -393,11 +393,11 @@ impl<S: BorderStyle> Widget for Border<S> {
|
|||
Ok(())
|
||||
}
|
||||
}
|
||||
pub struct Bordered<S: BorderStyle, W: Widget<Engine = Tui>>(pub S, pub W);
|
||||
impl<S: BorderStyle, W: Widget<Engine = Tui>> Content for Bordered<S, W> {
|
||||
pub struct Bordered<S: BorderStyle, W: Render<Engine = Tui>>(pub S, pub W);
|
||||
impl<S: BorderStyle, W: Render<Engine = Tui>> Content for Bordered<S, W> {
|
||||
type Engine = Tui;
|
||||
fn content (&self) -> impl Widget<Engine = Tui> {
|
||||
let content: &dyn Widget<Engine = Tui> = &self.1;
|
||||
fn content (&self) -> impl Render<Engine = Tui> {
|
||||
let content: &dyn Render<Engine = Tui> = &self.1;
|
||||
lay! { content.inset_xy(1, 1), Border(self.0) }.fill_xy()
|
||||
}
|
||||
}
|
||||
|
|
@ -497,7 +497,7 @@ macro_rules! border {
|
|||
}
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct $T(pub Style);
|
||||
impl Widget for $T {
|
||||
impl Render for $T {
|
||||
type Engine = Tui;
|
||||
fn min_size (&self, _: [u16;2]) -> Perhaps<[u16;2]> { Ok(Some([0,0])) }
|
||||
fn render (&self, to: &mut TuiOutput) -> Usually<()> { self.draw(to) }
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue