group tui_engine and tui_content; cargo update

tui/src/lib.rs

@@ -1,11 +1,5 @@
-mod tui_buffer;  pub use self::tui_buffer::*;
-mod tui_color;   pub use self::tui_color::*;
-mod tui_content; pub use self::tui_content::*;
 mod tui_engine;  pub use self::tui_engine::*;
-mod tui_file;    pub use self::tui_file::*;
-mod tui_input;   pub use self::tui_input::*;
-mod tui_output;  pub use self::tui_output::*;
-mod tui_perf;    pub use self::tui_perf::*;
+mod tui_content; pub use self::tui_content::*;
 
 pub use ::tengri_input as input;
 pub(crate) use ::tengri_input::*;

tui/src/tui_content.rs

@@ -1,6 +1,10 @@
 use crate::*;
 use crate::Color::*;
 use ratatui::prelude::Position;
+
+mod tui_color; pub use self::tui_color::*;
+mod tui_file;  pub use self::tui_file::*;
+
 macro_rules! impl_content_layout_render {
     ($Output:ty: |$self:ident: $Struct:ty, $to:ident| layout = $layout:expr; render = $render:expr) => {
         impl Content<$Output> for $Struct {
@@ -13,19 +17,24 @@ impl_content_layout_render!(TuiOut: |self: &str, to|
     layout = to.center_xy([self.chars().count() as u16, 1]);
     render = {let [x, y, ..] = Content::layout(self, to.area());
               to.blit(self, x, y, None)});
+
 impl_content_layout_render!(TuiOut: |self: String, to|
     layout = to.center_xy([self.chars().count() as u16, 1]);
     render = {let [x, y, ..] = Content::layout(self, to.area());
               to.blit(self, x, y, None)});
+
 impl_content_layout_render!(TuiOut: |self: std::sync::RwLock<String>, to|
     layout = Content::<TuiOut>::layout(&self.read().unwrap(), to);
     render = Content::<TuiOut>::render(&self.read().unwrap(), to));
+
 impl_content_layout_render!(TuiOut: |self: std::sync::RwLockReadGuard<'_, String>, to|
     layout = Content::<TuiOut>::layout(&**self, to);
     render = Content::<TuiOut>::render(&**self, to));
+
 impl_content_layout_render!(TuiOut: |self: Arc<str>, to|
     layout = to.center_xy([self.chars().count() as u16, 1]);
     render = to.blit(self, to.area.x(), to.area.y(), None));
+
 impl<T: Content<TuiOut>> Content<TuiOut> for std::sync::Arc<T> {
     fn layout (&self, to: [u16;4]) -> [u16;4] {
         Content::<TuiOut>::layout(&**self, to)

tui/src/tui_content/tui_color.rs

@@ -1,5 +1,6 @@
 use crate::*;
 use rand::{thread_rng, distributions::uniform::UniformSampler};
+
 impl Tui {
     pub const fn null     () -> Color { Color::Reset }
     pub const fn g   (g: u8) -> Color { Color::Rgb(g, g, g) }
@@ -23,7 +24,9 @@ impl Tui {
     //fn ti1 () -> Color { Color::Rgb(150, 160, 90) }
     //fn ti2 () -> Color { Color::Rgb(120, 130, 100) }
 }
+
 pub trait HasColor { fn color (&self) -> ItemColor; }
+
 #[macro_export] macro_rules! has_color {
     (|$self:ident:$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?|$cb:expr) => {
         impl $(<$($L),*$($T $(: $U)?),*>)? HasColor for $Struct $(<$($L),*$($T),*>)? {
@@ -31,17 +34,22 @@ pub trait HasColor { fn color (&self) -> ItemColor; }
         }
     }
 }
+
 /// A color in OKHSL and RGB representations.
 #[derive(Debug, Default, Copy, Clone, PartialEq)] pub struct ItemColor {
     pub okhsl: Okhsl<f32>,
     pub rgb:   Color,
 }
+
 from!(|okhsl: Okhsl<f32>|ItemColor = Self { okhsl, rgb: okhsl_to_rgb(okhsl) });
+
 pub fn okhsl_to_rgb (color: Okhsl<f32>) -> Color {
     let Srgb { red, green, blue, .. }: Srgb<f32> = Srgb::from_color_unclamped(color);
     Color::Rgb((red   * 255.0) as u8, (green * 255.0) as u8, (blue  * 255.0) as u8,)
 }
+
 from!(|rgb: Color|ItemColor = Self { rgb, okhsl: rgb_to_okhsl(rgb) });
+
 pub fn rgb_to_okhsl (color: Color) -> Okhsl<f32> {
     if let Color::Rgb(r, g, b) = color {
         Okhsl::from_color(Srgb::new(r as f32 / 255.0, g as f32 / 255.0, b as f32 / 255.0))
@@ -49,6 +57,7 @@ pub fn rgb_to_okhsl (color: Color) -> Okhsl<f32> {
         unreachable!("only Color::Rgb is supported")
     }
 }
+
 // A single color within item theme parameters, in OKHSL and RGB representations.
 impl ItemColor {
     pub const fn from_rgb (rgb: Color) -> Self {
@@ -77,6 +86,7 @@ impl ItemColor {
         self.okhsl.mix(other.okhsl, distance).into()
     }
 }
+
 /// A color in OKHSL and RGB with lighter and darker variants.
 #[derive(Debug, Default, Copy, Clone, PartialEq)] pub struct ItemPalette {
     pub base:     ItemColor,
@@ -87,6 +97,7 @@ impl ItemColor {
     pub darker:   ItemColor,
     pub darkest:  ItemColor,
 }
+
 impl ItemPalette {
     pub const G: [Self;256] = {
         let mut builder = konst::array::ArrayBuilder::new();
@@ -159,5 +170,6 @@ impl ItemPalette {
         }
     }
 }
+
 from!(|base: Color|    ItemPalette = Self::from_tui_color(base));
 from!(|base: ItemColor|ItemPalette = Self::from_item_color(base));

tui/src/tui_engine.rs

@@ -1,5 +1,11 @@
 use crate::*;
 use std::time::Duration;
+
+mod tui_buffer;  pub use self::tui_buffer::*;
+mod tui_input;   pub use self::tui_input::*;
+mod tui_output;  pub use self::tui_output::*;
+mod tui_perf;    pub use self::tui_perf::*;
+
 pub struct Tui {
     pub exited:  Arc<AtomicBool>,
     pub backend: CrosstermBackend<Stdout>,
@@ -7,6 +13,31 @@ pub struct Tui {
     pub area:    [u16;4],
     pub perf:    PerfModel,
 }
+
+pub trait TuiRun<R: Render<TuiOut> + Handle<TuiIn> + 'static> {
+    /// Run an app in the main loop.
+    fn run (&self, state: &Arc<RwLock<R>>) -> Usually<()>;
+}
+
+impl<T: Render<TuiOut> + Handle<TuiIn> + 'static> TuiRun<T> for Arc<RwLock<Tui>> {
+    fn run (&self, state: &Arc<RwLock<T>>) -> Usually<()> {
+        let _input_thread = TuiIn::run_input(self, state, Duration::from_millis(100));
+        self.write().unwrap().setup()?;
+        let render_thread = TuiOut::run_output(self, state, Duration::from_millis(10));
+        match render_thread.join() {
+            Ok(result) => {
+                self.write().unwrap().teardown()?;
+                println!("\n\rRan successfully: {result:?}\n\r");
+            },
+            Err(error) => {
+                self.write().unwrap().teardown()?;
+                panic!("\n\rRender thread failed: {error:?}.\n\r")
+            },
+        }
+        Ok(())
+    }
+}
+
 impl Tui {
     /// Construct a new TUI engine and wrap it for shared ownership.
     pub fn new () -> Usually<Arc<RwLock<Self>>> {
@@ -58,25 +89,3 @@ impl Tui {
         disable_raw_mode().map_err(Into::into)
     }
 }
-pub trait TuiRun<R: Render<TuiOut> + Handle<TuiIn> + 'static> {
-    /// Run an app in the main loop.
-    fn run (&self, state: &Arc<RwLock<R>>) -> Usually<()>;
-}
-impl<T: Render<TuiOut> + Handle<TuiIn> + 'static> TuiRun<T> for Arc<RwLock<Tui>> {
-    fn run (&self, state: &Arc<RwLock<T>>) -> Usually<()> {
-        let _input_thread = TuiIn::run_input(self, state, Duration::from_millis(100));
-        self.write().unwrap().setup()?;
-        let render_thread = TuiOut::run_output(self, state, Duration::from_millis(10));
-        match render_thread.join() {
-            Ok(result) => {
-                self.write().unwrap().teardown()?;
-                println!("\n\rRan successfully: {result:?}\n\r");
-            },
-            Err(error) => {
-                self.write().unwrap().teardown()?;
-                panic!("\n\rRender thread failed: {error:?}.\n\r")
-            },
-        }
-        Ok(())
-    }
-}

tui/src/tui_engine/tui_buffer.rs

@@ -1,4 +1,5 @@
 use crate::*;
+
 pub fn buffer_update (buf: &mut Buffer, area: [u16;4], callback: &impl Fn(&mut Cell, u16, u16)) {
     for row in 0..area.h() {
         let y = area.y() + row;
@@ -12,16 +13,19 @@ pub fn buffer_update (buf: &mut Buffer, area: [u16;4], callback: &impl Fn(&mut C
         }
     }
 }
+
 #[derive(Default)] pub struct BigBuffer {
     pub width:   usize,
     pub height:  usize,
     pub content: Vec<Cell>
 }
+
 impl std::fmt::Debug for BigBuffer {
     fn fmt (&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
         write!(f, "[BB {}x{} ({})]", self.width, self.height, self.content.len())
     }
 }
+
 impl BigBuffer {
     pub fn new (width: usize, height: usize) -> Self {
         Self { width, height, content: vec![Cell::default(); width*height] }
@@ -38,4 +42,5 @@ impl BigBuffer {
         y * self.width + x
     }
 }
+
 from!(|size:(usize, usize)| BigBuffer = Self::new(size.0, size.1));

tui/src/tui_engine/tui_input.rs

@@ -2,6 +2,7 @@ use crate::*;
 use std::time::Duration;
 use std::thread::{spawn, JoinHandle};
 use crossterm::event::{poll, read};
+
 #[derive(Debug, Clone)] pub struct TuiIn(pub Arc<AtomicBool>, pub Event);
 impl Input for TuiIn {
     type Event = Event;