diff --git a/examples/iter.rs b/examples/iter.rs index c61589b..61162ca 100644 --- a/examples/iter.rs +++ b/examples/iter.rs @@ -1,28 +1,47 @@ +use std::sync::Arc; + use osui::prelude::*; fn main() -> std::io::Result<()> { let screen = Screen::new(); + screen.extension(InputExtension); - app().draw(&screen); + app(screen.clone()).draw(&screen); screen.run() } -pub fn app() -> Rsx { - let items: State> = use_state(vec![1, 2]); - let count = use_state(3); +pub fn app(screen: Arc) -> Rsx { + let items: State> = use_state(Vec::new()); + let count = use_state(1); run! { - use count ref items { - items.get().push(count.get_dl()); - **count.get() += 1; + ref count, items { + loop { + items.get().push(count.get_dl()); + **count.get() += 1; + std::thread::sleep(std::time::Duration::from_millis(100)); + } } } rsx! { - FlexRow { - for item in items { - static "{item}" + @AlwaysFocused; + @Handler::new({ + let screen = screen.clone(); + move |_, e: &crossterm::event::Event| { + if let crossterm::event::Event::Key(crossterm::event::KeyEvent { code, .. }) = e { + if *code == crossterm::event::KeyCode::Esc { + screen.close(); + } + } + } + }); + Scroll { + FlexRow { + for item in items { + static "{item}" + } } } } diff --git a/examples/tour.rs b/examples/tour.rs index ffeed5b..bae1f6f 100644 --- a/examples/tour.rs +++ b/examples/tour.rs @@ -70,7 +70,6 @@ pub fn app(screen: Arc) -> Rsx { Input { } } - @Transform::new().margin(0, 1); FlexRow { "Password" diff --git a/src/elements/div.rs b/src/elements/div.rs index d5c5700..efd5478 100644 --- a/src/elements/div.rs +++ b/src/elements/div.rs @@ -11,14 +11,14 @@ pub struct DivRenderer<'a>(pub &'a mut RawTransform); pub struct Div { children: Vec>, - size: (u16, u16), + render: (u16, u16), } impl Div { pub fn new() -> Self { Div { children: Vec::new(), - size: (0, 0), + render: (0, 0), } } } @@ -26,30 +26,37 @@ impl Div { impl Element for Div { fn render( &mut self, - scope: &mut crate::render_scope::RenderScope, + scope: &mut crate::prelude::RenderScope, _: &crate::render_scope::RenderContext, ) { - let (width, height) = scope.get_size_or(self.size.0, self.size.1); - scope.use_area(width, height); + scope.use_area(self.render.0, self.render.1); } fn after_render( &mut self, - scope: &mut crate::render_scope::RenderScope, + parent_scope: &mut crate::render_scope::RenderScope, render_context: &crate::render_scope::RenderContext, ) { - let mut transform = scope.get_transform().clone(); + let mut transform = { + let (width, height) = parent_scope.get_size_or_parent(); + let mut t = parent_scope.get_transform().clone(); + t.width = width; + t.height = height; + t.transform_parent(parent_scope.get_parent_transform()); + t + }; + + let mut scope = crate::render_scope::RenderScope::new(); + scope.set_parent_transform(transform.clone()); + + transform.width = 0; + transform.height = 0; let mut renderer = DivRenderer(&mut transform); - - let (w, h) = scope.get_parent_size(); - scope.set_parent_size(renderer.0.width, renderer.0.height); - for widget in &self.children { scope.render_widget(&mut renderer, render_context.get_context(), widget); } - scope.set_parent_size(w, h); - self.size = (renderer.0.width, renderer.0.height); + self.render = (transform.width, transform.height); } fn draw_child(&mut self, element: &Arc) { @@ -77,5 +84,6 @@ impl ElementRenderer for DivRenderer<'_> { self.0.height = self.0.height.max(t.height + (t.py * 2)); t.x += self.0.x + self.0.px; t.y += self.0.y + self.0.py; + t.offset_y = self.0.offset_y; } } diff --git a/src/elements/flex.rs b/src/elements/flex.rs deleted file mode 100644 index 26ff7d4..0000000 --- a/src/elements/flex.rs +++ /dev/null @@ -1,177 +0,0 @@ -use std::sync::Arc; - -use crate::{ - prelude::ElementRenderer, - style::RawTransform, - widget::{Element, Widget}, - NoRenderRoot, -}; - -pub struct RowRenderer<'a>(&'a mut RawTransform, u16, &'a mut u16); -pub struct ColumnRenderer<'a>(&'a mut RawTransform, u16, &'a mut u16); - -pub struct FlexRow { - pub gap: u16, - children: Vec>, - size: (u16, u16), -} - -pub struct FlexCol { - pub gap: u16, - children: Vec>, - size: (u16, u16), -} - -impl FlexRow { - pub fn new() -> Self { - Self { - children: Vec::new(), - size: (0, 0), - gap: 0, - } - } -} - -impl FlexCol { - pub fn new() -> Self { - Self { - children: Vec::new(), - size: (0, 0), - gap: 0, - } - } -} - -impl Element for FlexRow { - fn render( - &mut self, - scope: &mut crate::render_scope::RenderScope, - _: &crate::render_scope::RenderContext, - ) { - let (width, height) = scope.get_size_or(self.size.0, self.size.1); - scope.use_area(width, height); - } - - fn after_render( - &mut self, - scope: &mut crate::render_scope::RenderScope, - render_context: &crate::render_scope::RenderContext, - ) { - let mut transform = scope.get_transform().clone(); - let transform_before = transform.clone(); - let (w, h) = scope.get_parent_size(); - scope.set_parent_size(transform.width, transform.height); - let mut v = 0; - - let mut renderer = RowRenderer(&mut transform, self.gap, &mut v); - - for widget in &self.children { - scope.render_widget(&mut renderer, render_context.get_context(), widget); - } - scope.set_parent_size(w, h); - scope.set_transform_raw(transform_before); - self.size = (transform.width, transform.height); - } - - fn draw_child(&mut self, element: &Arc) { - self.children.push(element.clone()); - element.inject(|w| w.component(NoRenderRoot)); - } - - fn undraw_child(&mut self, element: &Arc) { - if let Some(i) = self.children.iter().position(|v| Arc::ptr_eq(v, element)) { - self.children.remove(i); - } - } - - fn is_ghost(&mut self) -> bool { - true - } - - fn as_any(&self) -> &dyn std::any::Any { - self - } - - fn as_any_mut(&mut self) -> &mut dyn std::any::Any { - self - } -} - -impl Element for FlexCol { - fn render( - &mut self, - scope: &mut crate::render_scope::RenderScope, - _: &crate::render_scope::RenderContext, - ) { - let (width, height) = scope.get_size_or(self.size.0, self.size.1); - scope.use_area(width, height); - } - - fn after_render( - &mut self, - scope: &mut crate::render_scope::RenderScope, - render_context: &crate::render_scope::RenderContext, - ) { - let mut transform = scope.get_transform().clone(); - let transform_before = transform.clone(); - let (w, h) = scope.get_parent_size(); - scope.set_parent_size(transform.width, transform.height); - let mut v = 0; - - let mut renderer = ColumnRenderer(&mut transform, self.gap, &mut v); - - for widget in &self.children { - scope.render_widget(&mut renderer, render_context.get_context(), widget); - } - scope.set_parent_size(w, h); - scope.set_transform_raw(transform_before); - self.size = (transform.width, transform.height); - } - - fn draw_child(&mut self, element: &Arc) { - self.children.push(element.clone()); - element.inject(|w| w.component(NoRenderRoot)); - } - - fn is_ghost(&mut self) -> bool { - true - } - - fn as_any(&self) -> &dyn std::any::Any { - self - } - - fn as_any_mut(&mut self) -> &mut dyn std::any::Any { - self - } -} - -impl ElementRenderer for RowRenderer<'_> { - fn before_draw(&mut self, scope: &mut crate::prelude::RenderScope, _widget: &Arc) { - let t = scope.get_transform_mut(); - self.0.width = self.0.width.max(*self.2 + t.width + (t.px * 2)); - self.0.height = self.0.height.max(t.height + (t.py * 2)); - - t.x += self.0.x; - t.y += self.0.y + *self.2; - *self.2 += t.height + self.1 + (t.py * 2); - - t.px += self.0.px; - t.py += self.0.py; - } -} - -impl ElementRenderer for ColumnRenderer<'_> { - fn before_draw(&mut self, scope: &mut crate::prelude::RenderScope, _widget: &Arc) { - let t = scope.get_transform_mut(); - self.0.width = self.0.width.max(*self.2 + t.width + (t.px * 2)); - self.0.height = self.0.height.max(t.height + (t.py * 2)); - - t.x += self.0.x + *self.2; - t.y += self.0.y; - *self.2 += t.width + self.1 + (t.px * 2); - - t.px += self.0.px; - t.py += self.0.py; - } -} diff --git a/src/elements/flex/column.rs b/src/elements/flex/column.rs new file mode 100644 index 0000000..b1a4436 --- /dev/null +++ b/src/elements/flex/column.rs @@ -0,0 +1,98 @@ +use std::sync::Arc; + +use crate::{ + prelude::ElementRenderer, + style::RawTransform, + widget::{Element, Widget}, + NoRenderRoot, +}; + +pub struct ColumnRenderer<'a>(&'a mut RawTransform, u16, &'a mut u16); + +pub struct FlexCol { + pub gap: u16, + children: Vec>, + render: (u16, u16), +} + +impl FlexCol { + pub fn new() -> Self { + Self { + children: Vec::new(), + gap: 0, + render: (0, 0), + } + } +} + +impl Element for FlexCol { + fn render( + &mut self, + scope: &mut crate::prelude::RenderScope, + _: &crate::render_scope::RenderContext, + ) { + scope.use_area(self.render.0, self.render.1); + } + + fn after_render( + &mut self, + parent_scope: &mut crate::render_scope::RenderScope, + render_context: &crate::render_scope::RenderContext, + ) { + let mut transform = { + let (width, height) = parent_scope.get_size_or_parent(); + let mut t = parent_scope.get_transform().clone(); + t.width = width; + t.height = height; + t.transform_parent(parent_scope.get_parent_transform()); + t + }; + + let mut scope = crate::render_scope::RenderScope::new(); + scope.set_parent_transform(transform.clone()); + + transform.width = 0; + let mut v = 0; + let mut renderer = ColumnRenderer(&mut transform, self.gap, &mut v); + for widget in &self.children { + scope.render_widget(&mut renderer, render_context.get_context(), widget); + } + + self.render = (transform.width, transform.height); + } + + fn draw_child(&mut self, element: &Arc) { + self.children.push(element.clone()); + element.inject(|w| w.component(NoRenderRoot)); + } + + fn is_ghost(&mut self) -> bool { + true + } + + fn as_any(&self) -> &dyn std::any::Any { + self + } + + fn as_any_mut(&mut self) -> &mut dyn std::any::Any { + self + } +} + +impl ElementRenderer for ColumnRenderer<'_> { + fn before_draw(&mut self, scope: &mut crate::prelude::RenderScope, _widget: &Arc) { + let t = scope.get_transform_mut(); + // self.0.width = self.0.width.max(*self.2 + t.width + (t.px * 2)); + self.0.height = self.0.height.max(t.height + (t.py * 2)); + + t.x += self.0.x + *self.2; + t.y += self.0.y; + *self.2 += t.width + self.1 + (t.px * 2); + + t.px += self.0.px; + t.py += self.0.py; + + self.0.width += t.width + (t.px * 2) + self.1; + t.offset_y = self.0.offset_y; + } +} diff --git a/src/elements/flex/mod.rs b/src/elements/flex/mod.rs new file mode 100644 index 0000000..48c6444 --- /dev/null +++ b/src/elements/flex/mod.rs @@ -0,0 +1,5 @@ +mod row; +pub use row::*; + +mod column; +pub use column::*; diff --git a/src/elements/flex/row.rs b/src/elements/flex/row.rs new file mode 100644 index 0000000..902ceb3 --- /dev/null +++ b/src/elements/flex/row.rs @@ -0,0 +1,104 @@ +use std::sync::Arc; + +use crate::{ + prelude::ElementRenderer, + style::RawTransform, + widget::{Element, Widget}, + NoRenderRoot, +}; + +pub struct RowRenderer<'a>(&'a mut RawTransform, u16, &'a mut u16); + +pub struct FlexRow { + pub gap: u16, + children: Vec>, + render: (u16, u16), +} + +impl FlexRow { + pub fn new() -> Self { + Self { + children: Vec::new(), + gap: 0, + render: (0, 0), + } + } +} + +impl Element for FlexRow { + fn render( + &mut self, + scope: &mut crate::prelude::RenderScope, + _: &crate::render_scope::RenderContext, + ) { + scope.use_area(self.render.0, self.render.1); + } + + fn after_render( + &mut self, + parent_scope: &mut crate::render_scope::RenderScope, + render_context: &crate::render_scope::RenderContext, + ) { + let mut transform = { + let (width, height) = parent_scope.get_size_or_parent(); + let mut t = parent_scope.get_transform().clone(); + t.width = width; + t.height = height; + t.transform_parent(parent_scope.get_parent_transform()); + t + }; + + let mut scope = crate::render_scope::RenderScope::new(); + scope.set_parent_transform(transform.clone()); + + transform.height = 0; + let mut v = 0; + let mut renderer = RowRenderer(&mut transform, self.gap, &mut v); + for widget in &self.children { + scope.render_widget(&mut renderer, render_context.get_context(), widget); + } + + self.render = (transform.width, transform.height); + } + + fn draw_child(&mut self, element: &Arc) { + self.children.push(element.clone()); + element.inject(|w| w.component(NoRenderRoot)); + } + + fn undraw_child(&mut self, element: &Arc) { + if let Some(i) = self.children.iter().position(|v| Arc::ptr_eq(v, element)) { + self.children.remove(i); + } + } + + fn is_ghost(&mut self) -> bool { + true + } + + fn as_any(&self) -> &dyn std::any::Any { + self + } + + fn as_any_mut(&mut self) -> &mut dyn std::any::Any { + self + } +} + +impl ElementRenderer for RowRenderer<'_> { + fn before_draw(&mut self, scope: &mut crate::prelude::RenderScope, _widget: &Arc) { + let t = scope.get_transform_mut(); + self.0.width = self.0.width.max(*self.2 + t.width + (t.px * 2)); + // self.0.height = self.0.height.max(t.height + (t.py * 2)); + + t.x += self.0.x; + t.y += self.0.y + *self.2; + *self.2 += t.height + self.1 + (t.py * 2); + + t.px += self.0.px; + t.py += self.0.py; + + self.0.height += t.height + (t.py * 2) + self.1; + t.offset_y = self.0.offset_y; + } +} diff --git a/src/elements/mod.rs b/src/elements/mod.rs index f7edd3e..f408d11 100644 --- a/src/elements/mod.rs +++ b/src/elements/mod.rs @@ -3,12 +3,14 @@ pub mod flex; pub mod heading; pub mod input; pub mod paginator; +pub mod scroll; pub use div::*; pub use flex::*; pub use heading::*; pub use input::*; pub use paginator::*; +pub use scroll::*; use crate::Element; diff --git a/src/elements/paginator.rs b/src/elements/paginator.rs index c07d46c..7ff6270 100644 --- a/src/elements/paginator.rs +++ b/src/elements/paginator.rs @@ -10,16 +10,16 @@ use crate::{ pub struct Paginator { children: Vec>, - size: (u16, u16), index: usize, + render: (u16, u16), } impl Paginator { pub fn new() -> Self { Self { children: Vec::new(), - size: (0, 0), index: 0, + render: (0, 0), } } } @@ -27,28 +27,35 @@ impl Paginator { impl Element for Paginator { fn render( &mut self, - scope: &mut crate::render_scope::RenderScope, + scope: &mut crate::prelude::RenderScope, _: &crate::render_scope::RenderContext, ) { - let (width, height) = scope.get_size_or(self.size.0, self.size.1); - scope.use_area(width, height); + scope.use_area(self.render.0, self.render.1); } fn after_render( &mut self, - scope: &mut crate::render_scope::RenderScope, + parent_scope: &mut crate::render_scope::RenderScope, render_context: &crate::render_scope::RenderContext, ) { if let Some(widget) = self.children.get(self.index) { - let mut transform = scope.get_transform().clone(); - let mut renderer = DivRenderer(&mut transform); - let (w, h) = scope.get_parent_size(); - scope.set_parent_size(renderer.0.width, renderer.0.height); + let mut transform = { + let (width, height) = parent_scope.get_size_or_parent(); + let mut t = parent_scope.get_transform().clone(); + t.width = width; + t.height = height; + t.transform_parent(parent_scope.get_parent_transform()); + t + }; + let mut scope = crate::render_scope::RenderScope::new(); + scope.set_parent_transform(transform.clone()); + + transform.height = 0; + let mut renderer = DivRenderer(&mut transform); scope.render_widget(&mut renderer, render_context.get_context(), widget); - scope.set_parent_size(w, h); - self.size = (renderer.0.width, renderer.0.height); + self.render = (transform.width, transform.height); } } diff --git a/src/elements/scroll.rs b/src/elements/scroll.rs new file mode 100644 index 0000000..3d760b7 --- /dev/null +++ b/src/elements/scroll.rs @@ -0,0 +1,132 @@ +use std::sync::Arc; + +use crossterm::event::Event; + +use crate::{ + prelude::ElementRenderer, + style::RawTransform, + widget::{Element, Widget}, + NoRenderRoot, +}; + +pub struct ScrollRenderer<'a>(&'a mut RawTransform); + +pub struct Scroll { + pub scroll_offset: u16, + children: Vec>, + render: (u16, u16), +} + +impl Scroll { + pub fn new() -> Self { + Self { + scroll_offset: 0, + children: Vec::new(), + render: (0, 0), + } + } +} + +impl Element for Scroll { + fn render( + &mut self, + scope: &mut crate::prelude::RenderScope, + _: &crate::render_scope::RenderContext, + ) { + scope.use_area(self.render.0, self.render.1); + } + + fn after_render( + &mut self, + parent_scope: &mut crate::render_scope::RenderScope, + render_context: &crate::render_scope::RenderContext, + ) { + let mut transform = { + let (width, height) = parent_scope.get_size_or_parent(); + let mut t = parent_scope.get_transform().clone(); + t.width = width; + t.height = height; + t.transform_parent(parent_scope.get_parent_transform()); + t + }; + + transform.offset_y = self.scroll_offset; + + let mut scope = crate::render_scope::RenderScope::new(); + scope.set_parent_transform(transform.clone()); + + transform.width = 0; + transform.height = 0; + let mut renderer = ScrollRenderer(&mut transform); + for widget in &self.children { + scope.render_widget(&mut renderer, render_context.get_context(), widget); + } + + self.render = (transform.width, transform.height); + } + + fn draw_child(&mut self, element: &Arc) { + self.children.push(element.clone()); + element.inject(|w| w.component(NoRenderRoot)); + } + + fn undraw_child(&mut self, element: &Arc) { + if let Some(i) = self.children.iter().position(|v| Arc::ptr_eq(v, element)) { + self.children.remove(i); + } + } + + fn event(&mut self, event: &dyn crate::prelude::Event) { + if let Some(e) = event.get::() { + match e { + Event::Key(k) => match k.code { + crossterm::event::KeyCode::PageUp => { + self.scroll_offset = self.scroll_offset.saturating_sub(1) + } + crossterm::event::KeyCode::PageDown => { + if self.scroll_offset + 1 < self.render.1 { + self.scroll_offset += 1; + } + } + _ => {} + }, + + Event::Mouse(m) => match m.kind { + crossterm::event::MouseEventKind::ScrollDown => { + if self.scroll_offset + 1 < self.render.1 { + self.scroll_offset += 1; + } + } + crossterm::event::MouseEventKind::ScrollUp => { + self.scroll_offset = self.scroll_offset.saturating_sub(1) + } + _ => {} + }, + _ => {} + } + } + } + + fn is_ghost(&mut self) -> bool { + true + } + + fn as_any(&self) -> &dyn std::any::Any { + self + } + + fn as_any_mut(&mut self) -> &mut dyn std::any::Any { + self + } +} + +impl ElementRenderer for ScrollRenderer<'_> { + fn before_draw(&mut self, scope: &mut crate::prelude::RenderScope, _widget: &Arc) { + let t = scope.get_transform_mut(); + self.0.width = self.0.width.max(t.width + (t.px * 2)); + self.0.height = self.0.height.max(t.height + (t.py * 2)); + t.x += self.0.x + self.0.px; + t.y += self.0.y + self.0.py; + t.offset_y = self.0.offset_y; + } +} diff --git a/src/extensions/input_handling.rs b/src/extensions/input_handling.rs index 94156a6..8d80f0c 100644 --- a/src/extensions/input_handling.rs +++ b/src/extensions/input_handling.rs @@ -1,4 +1,14 @@ -use crate::extensions::{Extension, Context}; +use std::io::stdout; + +use crossterm::{ + event::{ + DisableMouseCapture, EnableMouseCapture, KeyboardEnhancementFlags, + PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags, + }, + execute, +}; + +use crate::extensions::{Context, Extension}; pub struct InputExtension; @@ -6,6 +16,12 @@ impl Extension for InputExtension { fn init(&mut self, ctx: &Context) { let ctx = ctx.clone(); crossterm::terminal::enable_raw_mode().unwrap(); + execute!( + stdout(), + PushKeyboardEnhancementFlags(KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES) + ) + .unwrap(); + execute!(stdout(), EnableMouseCapture).unwrap(); std::thread::spawn(move || loop { if let Ok(e) = crossterm::event::read() { ctx.event(&e); @@ -14,6 +30,8 @@ impl Extension for InputExtension { } fn on_close(&mut self) { + execute!(stdout(), PopKeyboardEnhancementFlags).unwrap(); + execute!(stdout(), DisableMouseCapture).unwrap(); crossterm::terminal::disable_raw_mode().unwrap(); } } diff --git a/src/lib.rs b/src/lib.rs index c432b16..caaaf6d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -36,6 +36,7 @@ use crate::{ prelude::{Context, ElementRenderer}, render_scope::RenderScope, state::DependencyHandler, + style::RawTransform, widget::{BoxedElement, DynWidget, Element, StaticWidget, Widget, WidgetLoad}, }; @@ -190,8 +191,9 @@ impl Screen { pub fn render(self: &Arc, ctx: &Context) -> std::io::Result<()> { let mut scope = RenderScope::new(); let mut renderer = ScreenRenderer; - let (w, h) = crossterm::terminal::size().unwrap(); - scope.set_parent_size(w, h); + let mut transform = RawTransform::new(); + (transform.width, transform.height) = crossterm::terminal::size().unwrap(); + scope.set_parent_transform(transform); ctx.render_root(&mut scope); utils::clear()?; diff --git a/src/render_scope.rs b/src/render_scope.rs index 6e10914..02429bc 100644 --- a/src/render_scope.rs +++ b/src/render_scope.rs @@ -44,9 +44,8 @@ enum RenderMethod { #[derive(Clone)] pub struct RenderScope { transform: RawTransform, + parent_transform: RawTransform, render_stack: Vec, - parent_width: u16, - parent_height: u16, style: Style, } @@ -79,9 +78,8 @@ impl RenderScope { pub fn new() -> RenderScope { RenderScope { transform: RawTransform::new(), + parent_transform: RawTransform::new(), render_stack: Vec::new(), - parent_width: 0, - parent_height: 0, style: Style::new(), } } @@ -93,8 +91,16 @@ impl RenderScope { /// Applies a `Transform` to this scope, factoring in parent dimensions. pub fn set_transform(&mut self, transform: &Transform) { - transform.use_dimensions(self.parent_width, self.parent_height, &mut self.transform); - transform.use_position(self.parent_width, self.parent_height, &mut self.transform); + transform.use_dimensions( + self.parent_transform.width, + self.parent_transform.height, + &mut self.transform, + ); + transform.use_position( + self.parent_transform.width, + self.parent_transform.height, + &mut self.transform, + ); self.transform.px = transform.px; self.transform.py = transform.py; } @@ -164,6 +170,7 @@ impl RenderScope { format!("\nā”‚{}ā”‚", " ".repeat(width as usize - 2)) .repeat(height as usize - 2), ), + &self.parent_transform, ); } } @@ -181,6 +188,7 @@ impl RenderScope { format!("\nā”‚{}ā”‚", " ".repeat(width as usize - 2)) .repeat(height as usize - 2), ), + &self.parent_transform, ); } } @@ -192,6 +200,7 @@ impl RenderScope { .take(height as usize) .collect::>() .join("\n"), + &self.parent_transform, ), } @@ -204,12 +213,14 @@ impl RenderScope { self.transform.y + self.transform.py + y, &utils::hex_ansi(c), t, + &self.parent_transform, ); } else { utils::print( self.transform.x + self.transform.px, self.transform.y + self.transform.py, t, + &self.parent_transform, ); } } @@ -220,12 +231,14 @@ impl RenderScope { self.transform.y + self.transform.py + y, &utils::hex_ansi_bg(c), t, + &self.parent_transform, ); } else { utils::print( self.transform.x + self.transform.px, self.transform.y + self.transform.py, t, + &self.parent_transform, ); } } @@ -234,18 +247,18 @@ impl RenderScope { self.transform.y + self.transform.py + y, &utils::hex_ansi(*c), t, + &self.parent_transform, + ), + RenderMethod::Rectangle(x, y, width, height, color) => utils::print_liner( + self.transform.x + self.transform.px + x, + self.transform.y + self.transform.py + y, + &hex_ansi_bg(*color), + &std::iter::repeat(" ".repeat(*width as usize)) + .take(*height as usize) + .collect::>() + .join("\n"), + &self.parent_transform, ), - RenderMethod::Rectangle(x, y, width, height, color) => { - utils::print_liner( - self.transform.x + self.transform.px + x, - self.transform.y + self.transform.py + y, - &hex_ansi_bg(*color), - &std::iter::repeat(" ".repeat(*width as usize)) - .take(*height as usize) - .collect::>() - .join("\n"), - ); - } } } } @@ -282,12 +295,12 @@ impl RenderScope { pub fn get_size_or_parent(&self) -> (u16, u16) { ( if self.transform.width == 0 { - self.parent_width + self.parent_transform.width } else { self.transform.width }, if self.transform.height == 0 { - self.parent_height + self.parent_transform.height } else { self.transform.height }, @@ -295,14 +308,18 @@ impl RenderScope { } /// Gets the dimensions of the parent container. - pub fn get_parent_size(&self) -> (u16, u16) { - (self.parent_width, self.parent_height) + pub fn get_parent_transform(&self) -> &RawTransform { + &self.parent_transform } /// Sets the dimensions of the parent container. - pub fn set_parent_size(&mut self, width: u16, height: u16) { - self.parent_width = width; - self.parent_height = height; + // pub fn set_parent_size(&mut self, width: u16, height: u16) { + // self.parent_transform.width = width; + // self.parent_transform.height = height; + // } + + pub fn set_parent_transform(&mut self, transform: RawTransform) { + self.parent_transform = transform; } /// Returns a mutable reference to the internal raw transform. diff --git a/src/style.rs b/src/style.rs index 6296754..a7abc1d 100644 --- a/src/style.rs +++ b/src/style.rs @@ -19,6 +19,7 @@ pub struct RawTransform { pub height: u16, pub px: u16, pub py: u16, + pub offset_y: u16, } /// Horizontal or vertical position relative to a parent container. @@ -169,6 +170,31 @@ impl RawTransform { height: 0, px: 0, py: 0, + offset_y: 0, + } + } + + pub fn transform_parent(&mut self, parent: &Self) { + let child_bottom = self.y + self.height; + let parent_bottom = parent.y + parent.height; + + let child_right = self.x + self.width; + let parent_right = parent.x + parent.width; + + if child_bottom > parent_bottom { + if parent_bottom > self.y { + self.height = parent_bottom - self.y; + } else { + self.height = 0; + } + } + + if child_right > parent_right { + if parent_right > self.x { + self.width = parent_right - self.x; + } else { + self.width = 0; + } } } } diff --git a/src/utils.rs b/src/utils.rs index 031149f..59ebde8 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -3,6 +3,8 @@ use std::io::{self, Write}; +use crate::style::RawTransform; + /// Clears the terminal screen and moves the cursor to the top-left corner. /// /// # Returns @@ -107,16 +109,40 @@ pub fn hex_ansi_bg(hex: u32) -> String { format!("\x1b[48;2;{r};{g};{b}m") } -pub(crate) fn print(x: u16, y: u16, text: &str) { +pub(crate) fn print(x: u16, y: u16, text: &str, parent_transform: &RawTransform) { for (i, line) in text.lines().enumerate() { - print!("\x1b[{};{}H{line}\x1b[0m", y + i as u16 + 1, x + 1); + if parent_transform.offset_y > y + i as u16 { + continue; + } + + let y = y + i as u16 - parent_transform.offset_y; + + if y >= parent_transform.height + parent_transform.y + parent_transform.py { + break; + } + print!("\x1b[{};{}H{line}\x1b[0m", y + 1, x + 1); flush().unwrap(); } } -pub(crate) fn print_liner(x: u16, y: u16, liner: &str, text: &str) { +pub(crate) fn print_liner( + x: u16, + y: u16, + liner: &str, + text: &str, + parent_transform: &RawTransform, +) { for (i, line) in text.lines().enumerate() { - print!("\x1b[{};{}H{liner}{line}\x1b[0m", y + i as u16 + 1, x + 1); + if parent_transform.offset_y > y + i as u16 { + continue; + } + + let y = y + i as u16 - parent_transform.offset_y; + + if y >= parent_transform.height + parent_transform.y + parent_transform.py { + break; + } + print!("\x1b[{};{}H{liner}{line}\x1b[0m", y + 1, x + 1); flush().unwrap(); } }