Merge pull request #34 from osui-rs/scroll

Scroll

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 {
+pub fn app(screen: Arc<Screen>) -> Rsx {
-    let items: State<Vec<i32>> = use_state(vec![1, 2]);
+    let items: State<Vec<i32>> = use_state(Vec::new());
-    let count = use_state(3);
+    let count = use_state(1);
 
     run! {
-        use count ref items {
+        ref count, items {
-            items.get().push(count.get_dl());
+            loop {
-            **count.get() += 1;
+                items.get().push(count.get_dl());
+                **count.get() += 1;
+                std::thread::sleep(std::time::Duration::from_millis(100));
+            }
         }
     }
 
     rsx! {
-        FlexRow {
+        @AlwaysFocused;
-            for item in items {
+        @Handler::new({
-                static "{item}"
+            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}"
+                }
             }
         }
     }

examples/tour.rs

@@ -70,7 +70,6 @@ pub fn app(screen: Arc<Screen>) -> Rsx {
                     Input { }
                 }
 
-                @Transform::new().margin(0, 1);
                 FlexRow
                 {
                     "Password"

src/elements/div.rs

@@ -11,14 +11,14 @@ pub struct DivRenderer<'a>(pub &'a mut RawTransform);
 
 pub struct Div {
     children: Vec<Arc<Widget>>,
-    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(self.render.0, self.render.1);
-        scope.use_area(width, height);
     }
 
     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<Widget>) {
@@ -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;
     }
 }

src/elements/flex.rs

@@ -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<Arc<Widget>>,
-    size: (u16, u16),
-}
-
-pub struct FlexCol {
-    pub gap: u16,
-    children: Vec<Arc<Widget>>,
-    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<Widget>) {
-        self.children.push(element.clone());
-        element.inject(|w| w.component(NoRenderRoot));
-    }
-
-    fn undraw_child(&mut self, element: &Arc<Widget>) {
-        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<Widget>) {
-        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<Widget>) {
-        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<Widget>) {
-        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;
-    }
-}

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<Arc<Widget>>,
+    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<Widget>) {
+        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<Widget>) {
+        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;
+    }
+}

src/elements/flex/mod.rs

@@ -0,0 +1,5 @@
+mod row;
+pub use row::*;
+
+mod column;
+pub use column::*;

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<Arc<Widget>>,
+    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<Widget>) {
+        self.children.push(element.clone());
+        element.inject(|w| w.component(NoRenderRoot));
+    }
+
+    fn undraw_child(&mut self, element: &Arc<Widget>) {
+        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<Widget>) {
+        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;
+    }
+}

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;
 

src/elements/paginator.rs

@@ -10,16 +10,16 @@ use crate::{
 
 pub struct Paginator {
     children: Vec<Arc<Widget>>,
-    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(self.render.0, self.render.1);
-        scope.use_area(width, height);
     }
 
     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 transform = {
-            let mut renderer = DivRenderer(&mut transform);
+                let (width, height) = parent_scope.get_size_or_parent();
-            let (w, h) = scope.get_parent_size();
+                let mut t = parent_scope.get_transform().clone();
-            scope.set_parent_size(renderer.0.width, renderer.0.height);
+                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.render = (transform.width, transform.height);
-            self.size = (renderer.0.width, renderer.0.height);
         }
     }
 

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<Arc<Widget>>,
+    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<Widget>) {
+        self.children.push(element.clone());
+        element.inject(|w| w.component(NoRenderRoot));
+    }
+
+    fn undraw_child(&mut self, element: &Arc<Widget>) {
+        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::<crossterm::event::Event>() {
+            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<Widget>) {
+        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;
+    }
+}

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();
     }
 }

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<Self>, ctx: &Context) -> std::io::Result<()> {
         let mut scope = RenderScope::new();
         let mut renderer = ScreenRenderer;
-        let (w, h) = crossterm::terminal::size().unwrap();
+        let mut transform = RawTransform::new();
-        scope.set_parent_size(w, h);
+        (transform.width, transform.height) = crossterm::terminal::size().unwrap();
+        scope.set_parent_transform(transform);
         ctx.render_root(&mut scope);
 
         utils::clear()?;

src/render_scope.rs

@@ -44,9 +44,8 @@ enum RenderMethod {
 #[derive(Clone)]
 pub struct RenderScope {
     transform: RawTransform,
+    parent_transform: RawTransform,
     render_stack: Vec<RenderMethod>,
-    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_dimensions(
-        transform.use_position(self.parent_width, self.parent_height, &mut self.transform);
+            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::<Vec<_>>()
                     .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::<Vec<_>>()
+                        .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::<Vec<_>>()
-                            .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) {
+    pub fn get_parent_transform(&self) -> &RawTransform {
-        (self.parent_width, self.parent_height)
+        &self.parent_transform
     }
 
     /// Sets the dimensions of the parent container.
-    pub fn set_parent_size(&mut self, width: u16, height: u16) {
+    // pub fn set_parent_size(&mut self, width: u16, height: u16) {
-        self.parent_width = width;
+    //     self.parent_transform.width = width;
-        self.parent_height = height;
+    //     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.

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;
+            }
         }
     }
 }

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();
     }
 }