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

genericize layout rendering

Browse source
This commit is contained in:
🪞👃🪞 2024-09-06 23:32:13 +03:00
parent 1d21071c86
commit 4855609a7d
8 changed files with 167 additions and 118 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -19,7 +19,7 @@ pub trait Device<E: Engine>: Component<E> + Process {
impl<D, E: Engine> Device<E> for D where D: Component<E> + Process {}
impl<E: Engine> Render<E> for Box<dyn Device<E>> {
fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
(**self).render(to)
}
}

2
crates/tek_core/src/audio/device.rs
View file

@ -17,7 +17,7 @@ impl<E: Engine> std::fmt::Debug for JackDevice<E> {
}
}
impl<E: Engine> Render<E> for JackDevice<E> {
fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
self.state.read().unwrap().render(to)
}
}

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

@ -7,6 +7,28 @@ pub trait App<T: Engine> {
fn run (self, context: T) -> Usually<T>;
}
/// Platform backend.
pub trait Engine: Sized {
fn setup (&mut self) -> Usually<()> { Ok(()) }
fn exited (&self) -> bool;
fn teardown (&mut self) -> Usually<()> { Ok(()) }
/// Unit of distance.
type Unit: Number;
type Area: Rectangle<Self::Unit>;
type HandleInput;
type Handled;
type RenderInput;
type Rendered;
// FIXME
fn area (&self) -> Self::Area;
// FIXME
fn with_area (&mut self, x: Self::Unit, y: Self::Unit, w: Self::Unit, h: Self::Unit)
-> &mut Self;
}
pub trait Number: Send + Sync + Copy
+ Add<Self, Output=Self>
+ Sub<Self, Output=Self>
@ -19,25 +41,6 @@ impl<T> Number for T where
+ Ord + PartialEq + Eq
{}
/// Platform backend.
pub trait Engine: Sized {
fn setup (&mut self) -> Usually<()> { Ok(()) }
fn exited (&self) -> bool;
fn teardown (&mut self) -> Usually<()> { Ok(()) }
/// Unit of distance.
type Unit: Number;
type HandleInput;
type Handled;
type RenderInput;
type Rendered;
}
pub trait HandleContext {}
pub trait RenderContext {}
submod! {
collect
component

2
crates/tek_core/src/engine/collect.rs
View file

@ -6,7 +6,7 @@ pub enum Collected<'a, E: Engine> {
}
impl<'a, E: Engine> Render<E> for Collected<'a, E> {
fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
match self {
Self::Box(item) => (*item).render(to),
Self::Ref(item) => (*item).render(to),

72
crates/tek_core/src/engine/layout.rs
View file

@ -1,7 +1,7 @@
use crate::*;
/// Compute drawing area before rendering
pub trait Layout<E: Engine> {
pub trait Layout<E: Engine>: Render<E> {
fn layout (&self, area: impl Rectangle<E::Unit>) -> Perhaps<impl Rectangle<E::Unit>>;
}
/// Enforce minimum size of drawing area
@ -98,3 +98,73 @@ impl<E: Engine, L: Layout<E>> Layout<E> for Offset<E::Unit, L> {
}
}
}
impl<E: Engine, R: Render<E> + Layout<E>> Render<E> for Min<E::Unit, R> {
fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
self.layout(to.area())?
.map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
.map(|to|match self {
Self::W(_, inner) => inner,
Self::H(_, inner) => inner,
Self::WH(_, _, inner) => inner,
}.render(to))
.transpose()
.map(|x|x.flatten())
}
}
impl<E: Engine, R: Render<E> + Layout<E>> Render<E> for Max<E::Unit, R> {
fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
self.layout(to.area())?
.map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
.map(|to|match self {
Self::W(_, inner) => inner,
Self::H(_, inner) => inner,
Self::WH(_, _, inner) => inner,
}.render(to))
.transpose()
.map(|x|x.flatten())
}
}
impl<E: Engine, R: Render<E> + Layout<E>> Render<E> for Inset<E::Unit, R> {
fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
self.layout(to.area())?
.map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
.map(|to|match self {
Self::W(_, inner) => inner,
Self::H(_, inner) => inner,
Self::WH(_, _, inner) => inner,
}.render(to))
.transpose()
.map(|x|x.flatten())
}
}
impl<E: Engine, R: Render<E> + Layout<E>> Render<E> for Outset<E::Unit, R> {
fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
self.layout(to.area())?
.map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
.map(|to|match self {
Self::W(_, inner) => inner,
Self::H(_, inner) => inner,
Self::WH(_, _, inner) => inner,
}.render(to))
.transpose()
.map(|x|x.flatten())
}
}
impl<E: Engine, R: Render<E> + Layout<E>> Render<E> for Offset<E::Unit, R> {
fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
self.layout(to.area())?
.map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
.map(|to|match self {
Self::X(_, inner) => inner,
Self::Y(_, inner) => inner,
Self::XY(_, _, inner) => inner,
}.render(to))
.transpose()
.map(|x|x.flatten())
}
}

20
crates/tek_core/src/engine/render.rs
View file

@ -2,12 +2,12 @@ use crate::*;
/// Render to output.
pub trait Render<E: Engine>: Send + Sync {
fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered>;
fn render (&self, to: &mut E) -> Perhaps<E::Rendered>;
}
/// Options can be rendered optionally.
impl<R, E: Engine> Render<E> for Option<R> where R: Render<E> {
fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
match self {
Some(component) => component.render(to),
None => Ok(None)
@ -17,42 +17,42 @@ impl<R, E: Engine> Render<E> for Option<R> where R: Render<E> {
/// Boxed references can be rendered.
impl<'a, E: Engine> Render<E> for Box<dyn Render<E> + 'a> {
fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
(**self).render(to)
}
}
/// Immutable references can be rendered.
impl<R, E: Engine> Render<E> for &R where R: Render<E> {
fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
(*self).render(to)
}
}
/// Mutable references can be rendered.
impl<R, E: Engine> Render<E> for &mut R where R: Render<E> {
fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
(**self).render(to)
}
}
/// Counted references can be rendered.
impl<R, E: Engine> Render<E> for Arc<R> where R: Render<E> {
fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
self.as_ref().render(to)
}
}
/// References behind a [Mutex] can be rendered.
impl<R, E: Engine> Render<E> for Mutex<R> where R: Render<E> {
fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
self.lock().unwrap().render(to)
}
}
/// References behind a [RwLock] can be rendered.
impl<R, E: Engine> Render<E> for RwLock<R> where R: Render<E> {
fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
self.read().unwrap().render(to)
}
}
@ -62,8 +62,8 @@ impl<R, E: Engine> Render<E> for RwLock<R> where R: Render<E> {
/// Rendering unboxed closures should also be possible;
/// but in practice implementing the trait for an unboxed
/// `Fn` closure causes an impl conflict.
impl<'a, E: Engine> Render<E> for Box<dyn Fn(&mut E::RenderInput) -> Perhaps<E::Rendered> + Send + Sync + 'a> {
fn render (&self, to: &mut E::RenderInput) -> Perhaps<E::Rendered> {
impl<'a, E: Engine> Render<E> for Box<dyn Fn(&mut E) -> Perhaps<E::Rendered> + Send + Sync + 'a> {
fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
(*self)(to)
}
}

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

@ -26,6 +26,7 @@ pub struct Tui {
}
impl Engine for Tui {
type Unit = u16;
type Area = Rect;
type HandleInput = Self;
type Handled = bool;
type RenderInput = Self;
@ -47,6 +48,15 @@ impl Engine for Tui {
stdout().execute(LeaveAlternateScreen)?;
disable_raw_mode().map_err(Into::into)
}
// FIXME
fn area (&self) -> Self::Area {
self.area
}
#[inline]
fn with_area (&mut self, x: u16, y: u16, w: u16, h: u16) -> &mut Self {
self.with_rect(Rect { x, y, width: w, height: h });
self
}
}
impl Tui {
/// Run the main loop.
@ -113,9 +123,6 @@ impl Tui {
pub fn event (&self) -> TuiEvent {
self.event.read().unwrap().clone().unwrap()
}
pub fn area (&self) -> Rect {
self.area
}
pub fn buffer (&mut self) -> &mut Buffer {
&mut self.buffers[self.buffer]
}
@ -172,11 +179,6 @@ impl Tui {
self.with_area(x, y, width, height)
}
#[inline]
pub fn with_area (&mut self, x: u16, y: u16, w: u16, h: u16) -> &mut Self {
self.with_rect(Rect { x, y, width: w, height: h });
self
}
#[inline]
pub fn with_rect (&mut self, area: Rect) -> &mut Self {
self.area = area;
self
@ -221,3 +223,11 @@ pub fn half_block (lower: bool, upper: bool) -> Option<char> {
_ => None
}
}
impl Rectangle<u16> for Rect {
fn x (&self) -> u16 { self.x }
fn y (&self) -> u16 { self.y }
fn w (&self) -> u16 { self.width }
fn h (&self) -> u16 { self.height }
}

120
crates/tek_core/src/tui/tui_layout.rs
View file

@ -1,82 +1,5 @@
use crate::*;
impl Rectangle<u16> for Rect {
fn x (&self) -> u16 { self.x }
fn y (&self) -> u16 { self.y }
fn w (&self) -> u16 { self.width }
fn h (&self) -> u16 { self.height }
}
impl<R> Render<Tui> for Min<<Tui as Engine>::Unit, R> where R: Render<Tui> + Layout<Tui> {
fn render (&self, to: &mut Tui) -> Perhaps<Rect> {
self.layout(to.area())?
.map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
.map(|to|match self {
Self::W(_, inner) => inner,
Self::H(_, inner) => inner,
Self::WH(_, _, inner) => inner,
}.render(to))
.transpose()
.map(|x|x.flatten())
}
}
impl<R> Render<Tui> for Max<<Tui as Engine>::Unit, R> where R: Render<Tui> + Layout<Tui> {
fn render (&self, to: &mut Tui) -> Perhaps<Rect> {
self.layout(to.area())?
.map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
.map(|to|match self {
Self::W(_, inner) => inner,
Self::H(_, inner) => inner,
Self::WH(_, _, inner) => inner,
}.render(to))
.transpose()
.map(|x|x.flatten())
}
}
impl<R> Render<Tui> for Inset<<Tui as Engine>::Unit, R> where R: Render<Tui> + Layout<Tui> {
fn render (&self, to: &mut Tui) -> Perhaps<Rect> {
self.layout(to.area())?
.map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
.map(|to|match self {
Self::W(_, inner) => inner,
Self::H(_, inner) => inner,
Self::WH(_, _, inner) => inner,
}.render(to))
.transpose()
.map(|x|x.flatten())
}
}
impl<R> Render<Tui> for Outset<<Tui as Engine>::Unit, R> where R: Render<Tui> + Layout<Tui> {
fn render (&self, to: &mut Tui) -> Perhaps<Rect> {
self.layout(to.area())?
.map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
.map(|to|match self {
Self::W(_, inner) => inner,
Self::H(_, inner) => inner,
Self::WH(_, _, inner) => inner,
}.render(to))
.transpose()
.map(|x|x.flatten())
}
}
impl<R> Render<Tui> for Offset<<Tui as Engine>::Unit, R> where R: Render<Tui> + Layout<Tui> {
fn render (&self, to: &mut Tui) -> Perhaps<Rect> {
self.layout(to.area())?
.map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
.map(|to|match self {
Self::X(_, inner) => inner,
Self::Y(_, inner) => inner,
Self::XY(_, _, inner) => inner,
}.render(to))
.transpose()
.map(|x|x.flatten())
}
}
impl<'a> Render<Tui> for Layered<'a, Tui> {
fn render (&self, to: &mut Tui) -> Perhaps<Rect> {
let area = to.area();
@ -138,3 +61,46 @@ impl<'a> Split<'a, Tui> {
Ok((Rect { x, y, width, height }, areas))
}
}
// TODO
//impl<'a> Split<'a, Tui> {
//pub fn render_areas (&self, to: &mut Tui)
//-> Usually<(Rectangle<Tui>, Vec<Option<Rectangle<Tui>>>)>
//{
//let area = to.area();
//let mut w = 0u16;
//let mut h = 0u16;
//let mut areas = vec![];
//Ok((match self.direction {
//Direction::Down => {
//for component in self.items.0.iter() {
//if h >= area.h() {
//break
//}
//let result = Offset::Y(h, component).render(to)?;
//areas.push(result);
//if let Some(Rect { width, height, .. }) = result {
//h += height;
//w = w.max(width)
//}
//}
//(area.x(), area.y(), w, h)
//},
//Direction::Right => {
//for component in self.items.0.iter() {
//if w >= area.x() {
//break
//}
//let result = Offset::X(w, component).render(to)?;
//areas.push(result);
//if let Some(Rect { width, height, .. }) = result {
//w += width;
//h = h.max(height)
//}
//}
//(area.x(), area.y(), w, h)
//},
//_ => todo!()
//}, areas))
//}
//}