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

rename Widget to Render and CustomWidget to Widget

Browse source
This commit is contained in:
🪞👃🪞 2024-12-04 21:24:38 +01:00
parent f018988567
commit bf3c7630a4
20 changed files with 144 additions and 144 deletions
Download patch file Download diff file Expand all files Collapse all files

2
crates/tek_api/src/lib.rs
View file

@ -150,7 +150,7 @@ fn query_ports(client: &Client, names: Vec<String>) -> BTreeMap<String, Port<Uno
//}
//}
//impl<E: Engine> Widget for JackDevice<E> {
//impl<E: Engine> Render for JackDevice<E> {
//type Engine = E;
//fn min_size(&self, to: E::Size) -> Perhaps<E::Size> {
//self.state.read().unwrap().layout(to)

4
crates/tek_core/examples/demo.rs
View file

@ -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|{

52
crates/tek_core/src/engine.rs
View file

@ -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.

94
crates/tek_core/src/space.rs
View file

@ -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>);

2
crates/tek_core/src/test.rs
View file

@ -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]))

42
crates/tek_core/src/tui.rs
View file

@ -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) }

16
crates/tek_tui/src/lib.rs
View file

@ -75,8 +75,8 @@ impl TuiTheme {
}
pub trait FocusWrap<T> {
fn wrap <'a, W: Widget<Engine = Tui>> (self, focus: T, content: &'a W)
-> impl Widget<Engine = Tui> + 'a;
fn wrap <'a, W: Render<Engine = Tui>> (self, focus: T, content: &'a W)
-> impl Render<Engine = Tui> + 'a;
}
pub fn to_focus_command (input: &TuiInput) -> Option<FocusCommand> {
@ -139,12 +139,12 @@ pub fn to_focus_command (input: &TuiInput) -> Option<FocusCommand> {
}
}
pub trait StatusBar: Widget<Engine = Tui> {
pub trait StatusBar: Render<Engine = Tui> {
type State;
fn hotkey_fg () -> Color where Self: Sized;
fn update (&mut self, state: &Self::State) where Self: Sized;
fn command (commands: &[[impl Widget<Engine = Tui>;3]])
-> impl Widget<Engine = Tui> + '_
fn command (commands: &[[impl Render<Engine = Tui>;3]])
-> impl Render<Engine = Tui> + '_
where
Self: Sized
{
@ -161,7 +161,7 @@ pub trait StatusBar: Widget<Engine = Tui> {
})
}
fn with <'a> (state: &'a Self::State, content: impl Widget<Engine=Tui>) -> impl Widget<Engine=Tui>
fn with <'a> (state: &'a Self::State, content: impl Render<Engine=Tui>) -> impl Render<Engine=Tui>
where Self: Sized, &'a Self::State: Into<Self>
{
Split::up(1, state.into(), content)
@ -172,9 +172,9 @@ fn content_with_menu_and_status <'a, A, S, C> (
content: &'a A,
menu_bar: &'a Option<MenuBar<Tui, S, C>>,
status_bar: &'a Option<impl StatusBar>
) -> impl Widget<Engine = Tui> + 'a
) -> impl Render<Engine = Tui> + 'a
where
A: Widget<Engine = Tui>,
A: Render<Engine = Tui>,
S: Send + Sync + 'a,
C: Command<S>
{

6
crates/tek_tui/src/todo_tui_mixer.rs
View file

@ -95,7 +95,7 @@ pub struct TrackView<'a, E: Engine> {
pub entered: bool,
}
impl<'a> Widget for TrackView<'a, Tui> {
impl<'a> Render for TrackView<'a, Tui> {
type Engine = Tui;
fn min_size (&self, area: [u16;2]) -> Perhaps<[u16;2]> {
todo!()
@ -132,7 +132,7 @@ impl<'a> Widget for TrackView<'a, Tui> {
impl Content for Mixer<Tui> {
type Engine = Tui;
fn content (&self) -> impl Widget<Engine = Tui> {
fn content (&self) -> impl Render<Engine = Tui> {
Stack::right(|add| {
for channel in self.tracks.iter() {
add(channel)?;
@ -144,7 +144,7 @@ impl Content for Mixer<Tui> {
impl Content for Track<Tui> {
type Engine = Tui;
fn content (&self) -> impl Widget<Engine = Tui> {
fn content (&self) -> impl Render<Engine = Tui> {
TrackView {
chain: Some(&self),
direction: tek_core::Direction::Right,

2
crates/tek_tui/src/todo_tui_plugin.rs
View file

@ -31,7 +31,7 @@ impl<E> Plugin<E> {
})
}
}
impl Widget for Plugin<Tui> {
impl Render for Plugin<Tui> {
type Engine = Tui;
fn min_size (&self, to: [u16;2]) -> Perhaps<[u16;2]> {
Ok(Some(to))

4
crates/tek_tui/src/todo_tui_sampler.rs
View file

@ -316,7 +316,7 @@ impl Sample {
}
}
impl Widget for SamplerView<Tui> {
impl Render for SamplerView<Tui> {
type Engine = Tui;
fn min_size (&self, to: [u16;2]) -> Perhaps<[u16;2]> {
todo!()
@ -371,7 +371,7 @@ fn draw_sample (
Ok(label1.len() + label2.len() + 4)
}
impl Widget for AddSampleModal {
impl Render for AddSampleModal {
type Engine = Tui;
fn min_size (&self, to: [u16;2]) -> Perhaps<[u16;2]> {
todo!()

2
crates/tek_tui/src/tui_app_arranger.rs
View file

@ -154,7 +154,7 @@ impl StatusBar for ArrangerStatus {
impl Content for ArrangerStatus {
type Engine = Tui;
fn content (&self) -> impl Widget<Engine = Tui> {
fn content (&self) -> impl Render<Engine = Tui> {
let label = match self {
Self::Transport => "TRANSPORT",
Self::ArrangerMix => "PROJECT",

10
crates/tek_tui/src/tui_app_transport.rs
View file

@ -50,8 +50,8 @@ pub enum TransportFocus {
}
impl FocusWrap<TransportFocus> for TransportFocus {
fn wrap <'a, W: Widget<Engine = Tui>> (self, focus: TransportFocus, content: &'a W)
-> impl Widget<Engine = Tui> + 'a
fn wrap <'a, W: Render<Engine = Tui>> (self, focus: TransportFocus, content: &'a W)
-> impl Render<Engine = Tui> + 'a
{
let focused = focus == self;
let corners = focused.then_some(CORNERS);
@ -61,8 +61,8 @@ impl FocusWrap<TransportFocus> for TransportFocus {
}
impl FocusWrap<TransportFocus> for Option<TransportFocus> {
fn wrap <'a, W: Widget<Engine = Tui>> (self, focus: TransportFocus, content: &'a W)
-> impl Widget<Engine = Tui> + 'a
fn wrap <'a, W: Render<Engine = Tui>> (self, focus: TransportFocus, content: &'a W)
-> impl Render<Engine = Tui> + 'a
{
let focused = Some(focus) == self;
let corners = focused.then_some(CORNERS);
@ -97,7 +97,7 @@ impl StatusBar for TransportStatusBar {
impl Content for TransportStatusBar {
type Engine = Tui;
fn content (&self) -> impl Widget<Engine = Tui> {
fn content (&self) -> impl Render<Engine = Tui> {
todo!();
""
}

26
crates/tek_tui/src/tui_view_arranger.rs
View file

@ -3,7 +3,7 @@ use crate::*;
/// Layout for standalone arranger app.
impl Content for ArrangerTui {
type Engine = Tui;
fn content (&self) -> impl Widget<Engine = Tui> {
fn content (&self) -> impl Render<Engine = Tui> {
let arranger_focused = self.arranger_focused();
Split::down(
1,
@ -90,7 +90,7 @@ fn track_widths (tracks: &[ArrangerTrack]) -> Vec<(usize, usize)> {
pub fn arranger_content_vertical (
view: &ArrangerTui,
factor: usize
) -> impl Widget<Engine = Tui> + use<'_> {
) -> impl Render<Engine = Tui> + use<'_> {
let timebase = view.clock().timebase();
let current = &view.clock().playhead;
let tracks = view.tracks();
@ -107,7 +107,7 @@ pub fn arranger_content_vertical (
let cols: &[(usize, usize)] = cols.as_ref();
let any_size = |_|Ok(Some([0,0]));
// column separators
add(&CustomWidget::new(any_size, move|to: &mut TuiOutput|{
add(&Widget::new(any_size, move|to: &mut TuiOutput|{
let style = Some(Style::default().fg(sep_fg));
Ok(for x in cols.iter().map(|col|col.1) {
let x = scenes_w + to.area().x() + x as u16;
@ -115,7 +115,7 @@ pub fn arranger_content_vertical (
})
}))?;
// row separators
add(&CustomWidget::new(any_size, move|to: &mut TuiOutput|{
add(&Widget::new(any_size, move|to: &mut TuiOutput|{
Ok(for y in rows.iter().map(|row|row.1) {
let y = to.area().y() + (y / PPQ) as u16 + 1;
if y >= to.buffer.area.height { break }
@ -213,7 +213,7 @@ pub fn arranger_content_vertical (
// full grid with header and footer
add(&col!(header, content))?;
// cursor
add(&CustomWidget::new(any_size, move|to: &mut TuiOutput|{
add(&Widget::new(any_size, move|to: &mut TuiOutput|{
let area = to.area();
let focused = view.arranger_focused();
let selected = view.selected;
@ -276,14 +276,14 @@ pub fn arranger_content_vertical (
pub fn arranger_content_horizontal (
view: &ArrangerTui,
) -> impl Widget<Engine = Tui> + use<'_> {
) -> impl Render<Engine = Tui> + use<'_> {
let focused = view.arranger_focused();
let _tracks = view.tracks();
lay!(
focused.then_some(Background(TuiTheme::border_bg())),
row!(
// name
CustomWidget::new(|_|{todo!()}, |_: &mut TuiOutput|{
Widget::new(|_|{todo!()}, |_: &mut TuiOutput|{
todo!()
//let Self(tracks, selected) = self;
//let yellow = Some(Style::default().yellow().bold().not_dim());
@ -307,7 +307,7 @@ pub fn arranger_content_horizontal (
//Ok(Some(area))
}),
// monitor
CustomWidget::new(|_|{todo!()}, |_: &mut TuiOutput|{
Widget::new(|_|{todo!()}, |_: &mut TuiOutput|{
todo!()
//let Self(tracks) = self;
//let mut area = to.area();
@ -332,7 +332,7 @@ pub fn arranger_content_horizontal (
//Ok(Some(area))
}),
// record
CustomWidget::new(|_|{todo!()}, |_: &mut TuiOutput|{
Widget::new(|_|{todo!()}, |_: &mut TuiOutput|{
todo!()
//let Self(tracks) = self;
//let mut area = to.area();
@ -357,7 +357,7 @@ pub fn arranger_content_horizontal (
//Ok(Some(area))
}),
// overdub
CustomWidget::new(|_|{todo!()}, |_: &mut TuiOutput|{
Widget::new(|_|{todo!()}, |_: &mut TuiOutput|{
todo!()
//let Self(tracks) = self;
//let mut area = to.area();
@ -385,7 +385,7 @@ pub fn arranger_content_horizontal (
//Ok(Some(area))
}),
// erase
CustomWidget::new(|_|{todo!()}, |_: &mut TuiOutput|{
Widget::new(|_|{todo!()}, |_: &mut TuiOutput|{
todo!()
//let Self(tracks) = self;
//let mut area = to.area();
@ -408,7 +408,7 @@ pub fn arranger_content_horizontal (
//Ok(Some(area))
}),
// gain
CustomWidget::new(|_|{todo!()}, |_: &mut TuiOutput|{
Widget::new(|_|{todo!()}, |_: &mut TuiOutput|{
todo!()
//let Self(tracks) = self;
//let mut area = to.area();
@ -431,7 +431,7 @@ pub fn arranger_content_horizontal (
//Ok(Some(area))
}),
// scenes
CustomWidget::new(|_|{todo!()}, |to: &mut TuiOutput|{
Widget::new(|_|{todo!()}, |to: &mut TuiOutput|{
let [x, y, _, height] = to.area();
let mut x2 = 0;
Ok(for (scene_index, scene) in view.scenes().iter().enumerate() {

2
crates/tek_tui/src/tui_view_file_browser.rs
View file

@ -2,7 +2,7 @@ use crate::*;
impl Content for FileBrowser {
type Engine = Tui;
fn content (&self) -> impl Widget<Engine = Tui> {
fn content (&self) -> impl Render<Engine = Tui> {
Stack::down(|add|{
let mut i = 0;
for (_, name) in self.dirs.iter() {

10
crates/tek_tui/src/tui_view_phrase_editor.rs
View file

@ -54,7 +54,7 @@ impl<'a, T: HasEditor> From<&'a T> for PhraseView<'a> {
impl<'a> Content for PhraseView<'a> {
type Engine = Tui;
fn content (&self) -> impl Widget<Engine = Tui> {
fn content (&self) -> impl Render<Engine = Tui> {
let Self {
focused,
entered,
@ -104,13 +104,13 @@ impl<'a> Content for PhraseView<'a> {
lay!(
row!(
CustomWidget::new(|to:[u16;2]|Ok(Some(to.clip_w(2))), move|to: &mut TuiOutput|{
Widget::new(|to:[u16;2]|Ok(Some(to.clip_w(2))), move|to: &mut TuiOutput|{
Ok(if to.area().h() >= 2 {
view_mode.render_keys(to, *note_hi, *note_lo)
})
}).fill_y(),
lay!(
CustomWidget::new(|to|Ok(Some(to)), |to: &mut TuiOutput|{
Widget::new(|to|Ok(Some(to)), |to: &mut TuiOutput|{
size.set_wh(to.area.w(), to.area.h() as usize - 1);
let draw = to.area().h() >= 2;
Ok(if draw {
@ -119,7 +119,7 @@ impl<'a> Content for PhraseView<'a> {
)
})
}).fill_x(),
CustomWidget::new(|to|Ok(Some(to)), move|to: &mut TuiOutput|{
Widget::new(|to|Ok(Some(to)), move|to: &mut TuiOutput|{
Ok(if *focused && *entered {
view_mode.render_cursor(
to,
@ -137,7 +137,7 @@ impl<'a> Content for PhraseView<'a> {
//} else {
//Color::Rgb(70, 80, 50)
//}))),
CustomWidget::new(|to:[u16;2]|Ok(Some(to.clip_h(1))), move|to: &mut TuiOutput|{
Widget::new(|to:[u16;2]|Ok(Some(to.clip_h(1))), move|to: &mut TuiOutput|{
//let playhead_inactive = Style::default().fg(Color::Rgb(255,255,255)).bg(Color::Rgb(40,50,30));
//let playhead_active = playhead_inactive.clone().yellow().bold().not_dim();
//if let Some(_) = phrase {

2
crates/tek_tui/src/tui_view_phrase_length.rs
View file

@ -2,7 +2,7 @@ use crate::*;
impl Content for PhraseLength {
type Engine = Tui;
fn content (&self) -> impl Widget<Engine = Tui> {
fn content (&self) -> impl Render<Engine = Tui> {
Layers::new(move|add|{
match self.focus {
None => add(&row!(

2
crates/tek_tui/src/tui_view_phrase_list.rs
View file

@ -25,7 +25,7 @@ impl<'a, T: HasPhraseList> From<&'a T> for PhraseListView<'a> {
// TODO: Display phrases always in order of appearance
impl<'a> Content for PhraseListView<'a> {
type Engine = Tui;
fn content (&self) -> impl Widget<Engine = Tui> {
fn content (&self) -> impl Render<Engine = Tui> {
let Self { title, focused, entered, phrases, index, mode } = self;
let content = Stack::down(move|add|match mode {
Some(PhrasesMode::Import(_, ref browser)) => {

2
crates/tek_tui/src/tui_view_phrase_selector.rs
View file

@ -37,7 +37,7 @@ impl<'a> PhraseSelector<'a> {
// TODO: Display phrases always in order of appearance
impl<'a> Content for PhraseSelector<'a> {
type Engine = Tui;
fn content (&self) -> impl Widget<Engine = Tui> {
fn content (&self) -> impl Render<Engine = Tui> {
let Self { title, phrase, focused, entered } = self;
let content = Layers::new(move|add|{
if let Some((instant, Some(phrase))) = phrase {

4
crates/tek_tui/src/tui_view_sequencer.rs
View file

@ -2,7 +2,7 @@ use crate::*;
impl Content for SequencerTui {
type Engine = Tui;
fn content (&self) -> impl Widget<Engine = Tui> {
fn content (&self) -> impl Render<Engine = Tui> {
lay!(self.size, SequencerStatusBar::with(self, col!(
TransportView::from(self),
Split::right(20,
@ -27,7 +27,7 @@ impl Content for SequencerTui {
impl Content for SequencerStatusBar {
type Engine = Tui;
fn content (&self) -> impl Widget<Engine = Tui> {
fn content (&self) -> impl Render<Engine = Tui> {
let orange = Color::Rgb(255,128,0);
let yellow = Color::Rgb(255,255,0);
let black = Color::Rgb(0,0,0);

4
crates/tek_tui/src/tui_view_transport.rs
View file

@ -1,6 +1,6 @@
use crate::*;
impl Widget for TransportTui {
impl Render for TransportTui {
type Engine = Tui;
fn min_size (&self, to: [u16;2]) -> Perhaps<[u16;2]> {
TransportView::from(self).min_size(to)
@ -23,7 +23,7 @@ pub struct TransportView {
impl Content for TransportView {
type Engine = Tui;
fn content (&self) -> impl Widget<Engine = Tui> {
fn content (&self) -> impl Render<Engine = Tui> {
let Self { state, selected, focused, bpm, sync, quant, beat, msu, } = self;
row!(
selected.wrap(TransportFocus::PlayPause, &Styled(