mirror of
https://codeberg.org/unspeaker/tengri.git
synced 2026-03-13 12:10:44 +01:00
510 lines
15 KiB
Rust
510 lines
15 KiB
Rust
pub use self::logical::*; mod logical {
|
|
use crate::*;
|
|
|
|
/// Thunks can be natural error boundaries!
|
|
///
|
|
/// ```
|
|
/// let _ = tengri::ErrorBoundary::<tengri::Tui, &'static str>::new(Ok(Some("hello")));
|
|
/// let _ = tengri::ErrorBoundary::<tengri::Tui, &'static str>::new(Ok(None));
|
|
/// let _ = tengri::ErrorBoundary::<tengri::Tui, &'static str>::new(Err("draw fail".into()));
|
|
/// ```
|
|
pub struct ErrorBoundary<O: Out, T: Draw<O>>(
|
|
pub Perhaps<T>,
|
|
pub PhantomData<O>,
|
|
);
|
|
|
|
/// Late-evaluate a rendering.
|
|
///
|
|
/// ```
|
|
/// let _ = tengri::Thunk::<tengri::Tui, _>::new(|out|{});
|
|
/// ```
|
|
pub struct Thunk<O: Out, F: Fn(&mut O)>(
|
|
pub F,
|
|
pub PhantomData<O>,
|
|
);
|
|
|
|
/// Memoize a rendering.
|
|
///
|
|
/// ```
|
|
/// let _ = tengri::Memo::new((), ());
|
|
/// ```
|
|
#[derive(Debug, Default)] pub struct Memo<T, U> {
|
|
pub value: T,
|
|
pub view: Arc<RwLock<U>>
|
|
}
|
|
}
|
|
|
|
pub use self::spatial::*; mod spatial {
|
|
use crate::*;
|
|
|
|
/// A binary split or layer.
|
|
///
|
|
/// ```
|
|
/// let _ = tengri::Bsp::n((), ());
|
|
/// let _ = tengri::Bsp::s((), ());
|
|
/// let _ = tengri::Bsp::e((), ());
|
|
/// let _ = tengri::Bsp::w((), ());
|
|
/// let _ = tengri::Bsp::a((), ());
|
|
/// let _ = tengri::Bsp::b((), ());
|
|
/// ```
|
|
pub struct Bsp<Head, Tail>(
|
|
/// Direction of split
|
|
pub(crate) Direction,
|
|
/// First element.
|
|
pub(crate) Head,
|
|
/// Second element.
|
|
pub(crate) Tail,
|
|
);
|
|
|
|
/// A point (X, Y).
|
|
///
|
|
/// ```
|
|
/// let xy = tengri::XY(0u16, 0);
|
|
/// ```
|
|
#[cfg_attr(test, derive(Arbitrary))]
|
|
#[derive(Copy, Clone, Debug, Default, PartialEq)] pub struct XY<C: Coord>(
|
|
pub C, pub C
|
|
);
|
|
|
|
/// A size (Width, Height).
|
|
///
|
|
/// ```
|
|
/// let wh = tengri::WH(0u16, 0);
|
|
/// ```
|
|
#[cfg_attr(test, derive(Arbitrary))]
|
|
#[derive(Copy, Clone, Debug, Default, PartialEq)] pub struct WH<C: Coord>(
|
|
pub C, pub C
|
|
);
|
|
|
|
/// Point with size.
|
|
///
|
|
/// ```
|
|
/// let xywh = tengri::XYWH(0u16, 0, 0, 0);
|
|
/// assert_eq!(tengri::XYWH(10u16, 10, 20, 20).center(), tengri::XY(20, 20));
|
|
/// ```
|
|
///
|
|
/// * [ ] TODO: anchor field (determines at which corner/side is X0 Y0)
|
|
///
|
|
#[cfg_attr(test, derive(Arbitrary))]
|
|
#[derive(Copy, Clone, Debug, Default, PartialEq)] pub struct XYWH<C: Coord>(
|
|
pub C, pub C, pub C, pub C
|
|
);
|
|
|
|
/// A cardinal direction.
|
|
///
|
|
/// ```
|
|
/// let direction = tengri::Direction::Above;
|
|
/// ```
|
|
#[cfg_attr(test, derive(Arbitrary))]
|
|
#[derive(Copy, Clone, PartialEq, Debug)] pub enum Direction {
|
|
North, South, East, West, Above, Below
|
|
}
|
|
|
|
/// 9th of area to place.
|
|
///
|
|
/// ```
|
|
/// let alignment = tengri::Alignment::Center;
|
|
/// ```
|
|
#[cfg_attr(test, derive(Arbitrary))]
|
|
#[derive(Debug, Copy, Clone, Default)] pub enum Alignment {
|
|
#[default] Center, X, Y, NW, N, NE, E, SE, S, SW, W
|
|
}
|
|
|
|
/// A widget that tracks its rendered width and height.
|
|
///
|
|
/// ```
|
|
/// let measure = tengri::Measure::<tengri::Tui>::default();
|
|
/// ```
|
|
#[derive(Default)] pub struct Measure<O: Out> {
|
|
pub __: PhantomData<O>,
|
|
pub x: Arc<AtomicUsize>,
|
|
pub y: Arc<AtomicUsize>,
|
|
}
|
|
|
|
/// Show an item only when a condition is true.
|
|
///
|
|
/// ```
|
|
/// fn test () -> impl tengri::Draw<tengri::Tui> {
|
|
/// tengri::when(true, "Yes")
|
|
/// }
|
|
/// ```
|
|
pub struct When<O, T>(pub bool, pub T, pub PhantomData<O>);
|
|
pub const fn when<O, T>(condition: bool, content: T) -> When<O, T> {
|
|
When(condition, content, PhantomData)
|
|
}
|
|
|
|
/// Show one item if a condition is true and another if the condition is false.
|
|
///
|
|
/// ```
|
|
/// fn test () -> impl tengri::Draw<tengri::Tui> {
|
|
/// tengri::either(true, "Yes", "No")
|
|
/// }
|
|
/// ```
|
|
pub struct Either<E, A, B>(pub bool, pub A, pub B, pub PhantomData<E>);
|
|
pub const fn either<E, A, B>(condition: bool, content_a: A, content_b: B) -> Either<E, A, B> {
|
|
Either(condition, content_a, content_b, PhantomData)
|
|
}
|
|
|
|
/// Increment X and/or Y coordinate.
|
|
///
|
|
/// ```
|
|
/// let pushed = tengri::Push::XY(2, 2, "Hello");
|
|
/// ```
|
|
pub enum Push<U, A> { X(U, A), Y(U, A), XY(U, U, A), }
|
|
|
|
/// Decrement X and/or Y coordinate.
|
|
///
|
|
/// ```
|
|
/// let pulled = tengri::Pull::XY(2, 2, "Hello");
|
|
/// ```
|
|
pub enum Pull<U, A> { X(U, A), Y(U, A), XY(U, U, A), }
|
|
|
|
/// Set the content to fill the container.
|
|
///
|
|
/// ```
|
|
/// let filled = tengri::Fill::XY("Hello");
|
|
/// ```
|
|
pub enum Fill<A> { X(A), Y(A), XY(A) }
|
|
|
|
/// Set fixed size for content.
|
|
///
|
|
/// ```
|
|
/// let fixed = tengri::Fixed::XY(3, 5, "Hello"); // 3x5
|
|
/// ```
|
|
pub enum Fixed<U, A> { X(U, A), Y(U, A), XY(U, U, A), }
|
|
|
|
/// Set the maximum width and/or height of the content.
|
|
///
|
|
/// ```
|
|
/// let maximum = tengri::Max::XY(3, 5, "Hello"); // 3x1
|
|
/// ```
|
|
pub enum Max<U, A> { X(U, A), Y(U, A), XY(U, U, A), }
|
|
|
|
/// Set the minimum width and/or height of the content.
|
|
///
|
|
/// ```
|
|
/// let minimum = tengri::Min::XY(3, 5, "Hello"); // 5x5
|
|
/// ```
|
|
pub enum Min<U, A> { X(U, A), Y(U, A), XY(U, U, A), }
|
|
|
|
/// Decrease the width and/or height of the content.
|
|
///
|
|
/// ```
|
|
/// let shrunk = tengri::Shrink::XY(2, 0, "Hello"); // 1x1
|
|
/// ```
|
|
pub enum Shrink<U, A> { X(U, A), Y(U, A), XY(U, U, A), }
|
|
|
|
/// Increaase the width and/or height of the content.
|
|
///
|
|
/// ```
|
|
/// let expanded = tengri::Expand::XY(5, 3, "HELLO"); // 15x3
|
|
/// ```
|
|
pub enum Expand<U, A> { X(U, A), Y(U, A), XY(U, U, A), }
|
|
|
|
/// Align position of inner area to middle, side, or corner of outer area.
|
|
///
|
|
///
|
|
/// ```
|
|
/// use ::tengri::*;
|
|
/// let area = XYWH(10u16, 10, 20, 20);
|
|
/// fn test (area: XYWH<u16>, item: &impl Draw<Tui>, expected: [u16;4]) {
|
|
/// //assert_eq!(Lay::layout(item, area), expected);
|
|
/// //assert_eq!(Draw::layout(item, area), expected);
|
|
/// };
|
|
///
|
|
/// let four = ||Fixed::XY(4, 4, "");
|
|
/// test(area, &Align::nw(four()), [10, 10, 4, 4]);
|
|
/// test(area, &Align::n(four()), [18, 10, 4, 4]);
|
|
/// test(area, &Align::ne(four()), [26, 10, 4, 4]);
|
|
/// test(area, &Align::e(four()), [26, 18, 4, 4]);
|
|
/// test(area, &Align::se(four()), [26, 26, 4, 4]);
|
|
/// test(area, &Align::s(four()), [18, 26, 4, 4]);
|
|
/// test(area, &Align::sw(four()), [10, 26, 4, 4]);
|
|
/// test(area, &Align::w(four()), [10, 18, 4, 4]);
|
|
///
|
|
/// let two_by_four = ||Fixed::XY(4, 2, "");
|
|
/// test(area, &Align::nw(two_by_four()), [10, 10, 4, 2]);
|
|
/// test(area, &Align::n(two_by_four()), [18, 10, 4, 2]);
|
|
/// test(area, &Align::ne(two_by_four()), [26, 10, 4, 2]);
|
|
/// test(area, &Align::e(two_by_four()), [26, 19, 4, 2]);
|
|
/// test(area, &Align::se(two_by_four()), [26, 28, 4, 2]);
|
|
/// test(area, &Align::s(two_by_four()), [18, 28, 4, 2]);
|
|
/// test(area, &Align::sw(two_by_four()), [10, 28, 4, 2]);
|
|
/// test(area, &Align::w(two_by_four()), [10, 19, 4, 2]);
|
|
/// ```
|
|
pub struct Align<T>(pub Alignment, pub T);
|
|
|
|
// TODO DOCUMENTME
|
|
pub enum Pad<U, A> { X(U, A), Y(U, A), XY(U, U, A), }
|
|
|
|
// TODO DOCUMENTME
|
|
pub struct Bordered<S, W>(pub bool, pub S, pub W);
|
|
|
|
// TODO DOCUMENTME
|
|
pub struct Border<S>(pub bool, pub S);
|
|
|
|
/// TODO DOCUMENTME
|
|
///
|
|
/// ```
|
|
/// use tengri::{Bounded, XYWH};
|
|
/// let area = XYWH(0, 0, 0, 0);
|
|
/// let content = "";
|
|
/// let bounded: Bounded<tengri::Tui, _> = Bounded(area, content);
|
|
/// ```
|
|
pub struct Bounded<O: Out, D>(pub XYWH<O::Unit>, pub D);
|
|
|
|
/// Draws items from an iterator.
|
|
///
|
|
/// ```
|
|
/// // FIXME let map = tengri::Map(||[].iter(), |_|{});
|
|
/// ```
|
|
pub struct Map<O, A, B, I, F, G>
|
|
where
|
|
I: Iterator<Item = A> + Send + Sync,
|
|
F: Fn() -> I + Send + Sync,
|
|
{
|
|
/// Function that returns iterator over stacked components
|
|
pub get_iter: F,
|
|
/// Function that returns each stacked component
|
|
pub get_item: G,
|
|
|
|
pub __: PhantomData<(O, B)>,
|
|
}
|
|
/// A color in OKHSL and RGB representations.
|
|
#[derive(Debug, Default, Copy, Clone, PartialEq)] pub struct ItemColor {
|
|
pub okhsl: Okhsl<f32>,
|
|
#[cfg(feature = "tui")] pub rgb: Color,
|
|
}
|
|
/// A color in OKHSL and RGB with lighter and darker variants.
|
|
#[derive(Debug, Default, Copy, Clone, PartialEq)] pub struct ItemTheme {
|
|
pub base: ItemColor,
|
|
pub light: ItemColor,
|
|
pub lighter: ItemColor,
|
|
pub lightest: ItemColor,
|
|
pub dark: ItemColor,
|
|
pub darker: ItemColor,
|
|
pub darkest: ItemColor,
|
|
}
|
|
// TODO DOCUMENTME
|
|
pub struct FieldH<Theme, Label, Value>(pub Theme, pub Label, pub Value);
|
|
// TODO DOCUMENTME
|
|
pub struct FieldV<Theme, Label, Value>(pub Theme, pub Label, pub Value);
|
|
// TODO:
|
|
pub struct Field<C, T, U> {
|
|
pub direction: Direction,
|
|
pub label: Option<T>,
|
|
pub label_fg: Option<C>,
|
|
pub label_bg: Option<C>,
|
|
pub label_align: Option<Direction>,
|
|
pub value: Option<U>,
|
|
pub value_fg: Option<C>,
|
|
pub value_bg: Option<C>,
|
|
pub value_align: Option<Direction>,
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "tui")] pub use self::terminal::*;
|
|
#[cfg(feature = "tui")] mod terminal {
|
|
use crate::*;
|
|
|
|
/// The TUI engine.
|
|
///
|
|
/// ```
|
|
/// # fn main () -> tengri::Usually<()> {
|
|
/// let tui = tengri::Tui::new(Box::new(vec![0u8;0]))?;
|
|
/// # Ok(()) }
|
|
/// ```
|
|
pub struct Tui {
|
|
/// Exit flag
|
|
pub exited: Arc<AtomicBool>,
|
|
/// Error message
|
|
pub error: Option<Arc<str>>,
|
|
/// Performance counter
|
|
pub perf: PerfModel,
|
|
/// Ratatui backend
|
|
pub backend: RwLock<CrosstermBackend<Box<dyn Write + Send + Sync>>>,
|
|
/// Current tnput event
|
|
pub event: Option<TuiEvent>,
|
|
/// Current output buffer
|
|
pub buffer: RwLock<Buffer>,
|
|
/// FIXME unused?
|
|
pub area: XYWH<u16>,
|
|
}
|
|
|
|
#[derive(Debug)] pub struct TuiThread {
|
|
pub exit: Arc<AtomicBool>,
|
|
pub perf: Arc<PerfModel>,
|
|
pub join: JoinHandle<()>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Eq, PartialEq, PartialOrd)] pub struct TuiEvent(
|
|
pub Event
|
|
);
|
|
|
|
#[derive(Debug, Clone, Eq, PartialEq, PartialOrd)] pub struct TuiKey(
|
|
pub Option<KeyCode>,
|
|
pub KeyModifiers
|
|
);
|
|
|
|
/// TUI buffer sized by `usize` instead of `u16`.
|
|
#[derive(Default)] pub struct BigBuffer {
|
|
pub width: usize,
|
|
pub height: usize,
|
|
pub content: Vec<Cell>
|
|
}
|
|
|
|
// TODO DOCUMENTME
|
|
pub struct Foreground<Color, Item>(pub Color, pub Item);
|
|
|
|
// TODO DOCUMENTME
|
|
pub struct Background<Color, Item>(pub Color, pub Item);
|
|
|
|
pub struct Modify<T>(pub bool, pub Modifier, pub T);
|
|
|
|
pub struct Styled<T>(pub Option<Style>, pub T);
|
|
|
|
/// A cell that takes up 3 rows on its own,
|
|
/// but stacks, giving (N+1)*2 rows per N cells.
|
|
pub struct Phat<T> {
|
|
pub width: u16,
|
|
pub height: u16,
|
|
pub content: T,
|
|
pub colors: [Color;4],
|
|
}
|
|
|
|
/// A three-column layout.
|
|
pub struct Tryptich<A, B, C> {
|
|
pub top: bool,
|
|
pub h: u16,
|
|
pub left: (u16, A),
|
|
pub middle: (u16, B),
|
|
pub right: (u16, C),
|
|
}
|
|
|
|
/// Repeat a string, e.g. for background
|
|
pub enum Repeat<'a> {
|
|
X(&'a str),
|
|
Y(&'a str),
|
|
XY(&'a str)
|
|
}
|
|
|
|
/// Scroll indicator
|
|
pub enum Scrollbar {
|
|
/// Horizontal scrollbar
|
|
X { offset: usize, length: usize, total: usize, },
|
|
/// Vertical scrollbar
|
|
Y { offset: usize, length: usize, total: usize, }
|
|
}
|
|
}
|
|
|
|
pub use self::textual::*;
|
|
mod textual {
|
|
/// Displays an owned [str]-like with fixed maximum width.
|
|
///
|
|
/// Width is computed using [unicode_width].
|
|
pub struct TrimString<T: AsRef<str>>(pub u16, pub T);
|
|
/// Displays a borrowed [str]-like with fixed maximum width
|
|
///
|
|
/// Width is computed using [unicode_width].
|
|
pub struct TrimStringRef<'a, T: AsRef<str>>(pub u16, pub &'a T);
|
|
}
|
|
|
|
#[cfg(feature = "jack")] pub use self::aural::*;
|
|
#[cfg(feature = "jack")] mod aural {
|
|
use crate::*;
|
|
use ::jack::*;
|
|
|
|
/// Wraps [JackState], and through it [jack::Client] when connected.
|
|
///
|
|
/// ```
|
|
/// let jack = tengri::Jack::default();
|
|
/// ```
|
|
#[derive(Clone, Debug, Default)] pub struct Jack<'j> (
|
|
pub(crate) Arc<RwLock<JackState<'j>>>
|
|
);
|
|
|
|
/// This is a connection which may be [Inactive], [Activating], or [Active].
|
|
/// In the [Active] and [Inactive] states, [JackState::client] returns a
|
|
/// [jack::Client], which you can use to talk to the JACK API.
|
|
///
|
|
/// ```
|
|
/// let state = tengri::JackState::default();
|
|
/// ```
|
|
#[derive(Debug, Default)] pub enum JackState<'j> {
|
|
/// Unused
|
|
#[default] Inert,
|
|
/// Before activation.
|
|
Inactive(Client),
|
|
/// During activation.
|
|
Activating,
|
|
/// After activation. Must not be dropped for JACK thread to persist.
|
|
Active(DynamicAsyncClient<'j>),
|
|
}
|
|
|
|
/// Event enum for JACK events.
|
|
///
|
|
/// ```
|
|
/// let event = tengri::JackEvent::XRun;
|
|
/// ```
|
|
#[derive(Debug, Clone, PartialEq)] pub enum JackEvent {
|
|
ThreadInit,
|
|
Shutdown(ClientStatus, Arc<str>),
|
|
Freewheel(bool),
|
|
SampleRate(Frames),
|
|
ClientRegistration(Arc<str>, bool),
|
|
PortRegistration(PortId, bool),
|
|
PortRename(PortId, Arc<str>, Arc<str>),
|
|
PortsConnected(PortId, PortId, bool),
|
|
GraphReorder,
|
|
XRun,
|
|
}
|
|
|
|
/// Generic notification handler that emits [JackEvent]
|
|
///
|
|
/// ```
|
|
/// let notify = tengri::JackNotify(|_|{});
|
|
/// ```
|
|
pub struct JackNotify<T: Fn(JackEvent) + Send>(pub T);
|
|
|
|
/// Running JACK [AsyncClient] with maximum type erasure.
|
|
///
|
|
/// One [Box] contains function that handles [JackEvent]s.
|
|
///
|
|
/// Another [Box] containing a function that handles realtime IO.
|
|
///
|
|
/// That's all it knows about them.
|
|
pub type DynamicAsyncClient<'j>
|
|
= AsyncClient<DynamicNotifications<'j>, DynamicAudioHandler<'j>>;
|
|
|
|
/// Notification handler wrapper for [BoxedAudioHandler].
|
|
pub type DynamicAudioHandler<'j> =
|
|
::jack::contrib::ClosureProcessHandler<(), BoxedAudioHandler<'j>>;
|
|
|
|
/// Boxed realtime callback.
|
|
pub type BoxedAudioHandler<'j> =
|
|
Box<dyn FnMut(&Client, &ProcessScope) -> Control + Send + Sync + 'j>;
|
|
|
|
/// Notification handler wrapper for [BoxedJackEventHandler].
|
|
pub type DynamicNotifications<'j> =
|
|
JackNotify<BoxedJackEventHandler<'j>>;
|
|
|
|
/// Boxed [JackEvent] callback.
|
|
pub type BoxedJackEventHandler<'j> =
|
|
Box<dyn Fn(JackEvent) + Send + Sync + 'j>;
|
|
}
|
|
|
|
pub use self::temporal::*; mod temporal {
|
|
use crate::*;
|
|
|
|
/// Performance counter
|
|
#[derive(Debug)]
|
|
pub struct PerfModel {
|
|
pub clock: quanta::Clock,
|
|
/// Measurement has a small cost. Disable it here.
|
|
pub enabled: bool,
|
|
// In nanoseconds. Time used by last iteration.
|
|
pub used: AtomicF64,
|
|
// In microseconds. Max prescribed time for iteration (frame, chunk...).
|
|
pub window: AtomicF64,
|
|
}
|
|
}
|