few changes

src/element/input.rs

@@ -65,9 +65,12 @@ impl KeyPressEventHandler for Input {
                     events.dispatch(InputUpdateEvent(self.0.clone()));
                 }
             }
-            _ => {}
+            _ => {
+                events.dispatch(InputKeyPress(self.0.clone(), *event));
+            }
         }
     }
 }
 
 event!(InputUpdateEvent(pub String));
+event!(InputKeyPress(pub String, pub KeyEvent));

src/extensions/keypress.rs

@@ -1,4 +1,4 @@
-use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
+use crossterm::event::KeyEvent;
 
 use crate::{
     events::{Close, Event, EventManager},
@@ -34,15 +34,13 @@ impl Extension for KeyPressExtension {
     fn tick_start(&mut self, _: &mut Screen, _: &mut EventManager) {}
 
     fn tick_end(&mut self, _: &mut Screen, events: &mut EventManager) {
+        if crossterm::event::poll(std::time::Duration::from_millis(13)).unwrap() {
             match crossterm::event::read().unwrap() {
                 crossterm::event::Event::Key(e) => {
-                if e.modifiers.contains(KeyModifiers::CONTROL) && e.code == KeyCode::Char('c') {
-                    events.dispatch(Close);
-                } else {
                     events.dispatch(e);
                 }
-            }
                 _ => {}
             }
         }
+    }
 }

src/extensions/mod.rs

@@ -1,4 +1,5 @@
 pub mod keypress;
+pub mod tick_rate;
 
 use crate::{events::EventManager, Screen};
 

src/extensions/tick_rate.rs

@@ -0,0 +1,13 @@
+use crate::extensions::Extension;
+
+pub struct TickRate(pub u8);
+
+impl Extension for TickRate {
+    fn init(&mut self, _: &mut crate::Screen, _: &mut crate::events::EventManager) {}
+
+    fn tick_end(&mut self, _: &mut crate::Screen, _: &mut crate::events::EventManager) {
+        std::thread::sleep(std::time::Duration::from_millis(1000 / self.0 as u64));
+    }
+
+    fn tick_start(&mut self, _: &mut crate::Screen, _: &mut crate::events::EventManager) {}
+}

src/main.rs

@@ -1,7 +1,10 @@
 use osui::{
-    element::input::{Input, InputUpdateEvent},
+    element::{
+        input::{Input, InputKeyPress},
+        rect::Rect,
+    },
     events::{Close, EventManager},
-    extensions::{keypress::KeyPressExtension, ExtensionManager},
+    extensions::{keypress::KeyPressExtension, tick_rate::TickRate, ExtensionManager},
     style::Transform,
     Screen,
 };
@@ -11,13 +14,27 @@ fn main() {
     let mut extensions = ExtensionManager::new();
     let mut events = EventManager::new();
     extensions.add(KeyPressExtension);
+    extensions.add(TickRate(255));
 
-    screen.draw(Input::new()).component(Transform::center());
+    screen
+        .draw(Rect(0xffffff))
+        .component(Transform::center().dimensions(30, 3));
 
-    events.on(|events, event: Box<InputUpdateEvent>| {
+    screen
+        .draw(format!("Type quit to quit"))
+        .component(Transform::new().bottom());
+
+    screen
+        .draw(Input::new())
+        .component(Transform::new().bottom());
+
+    events.on(|events, event: Box<InputKeyPress>| match event.1.code {
+        crossterm::event::KeyCode::Enter => {
             if event.0 == "quit" {
                 events.dispatch(Close);
             }
+        }
+        _ => {}
     });
 
     screen.run(&mut events, &mut extensions).unwrap();

src/render_scope.rs

@@ -49,18 +49,18 @@ impl RenderScope {
         for m in &self.render_stack {
             match m {
                 RenderMethod::Text(t) => {
-                    println!("\x1b[{};{}H{t}", self.transform.y + 1, self.transform.x + 1)
+                    utils::print(self.transform.x, self.transform.y, t);
                 }
                 RenderMethod::Rectangle(width, height, color) => {
-                    for i in 0..(*height) {
+                    utils::print_liner(
-                        println!(
+                        self.transform.x,
-                            "\x1b[{};{}H{}{}\x1b[0m",
+                        self.transform.y,
-                            self.transform.y + 1 + i,
+                        &hex_ansi_bg(*color),
-                            self.transform.x + 1,
+                        &std::iter::repeat(" ".repeat(*width as usize))
-                            hex_ansi_bg(*color),
+                            .take(*height as usize)
-                            " ".repeat(*width as usize)
+                            .collect::<Vec<_>>()
-                        )
+                            .join("\n"),
-                    }
+                    );
                 }
             }
         }

src/style.rs

@@ -9,8 +9,9 @@ pub struct RawTransform {
 
 #[derive(Debug, Clone)]
 pub enum Position {
-    Center,
     Const(u16),
+    Center,
+    End,
 }
 
 #[derive(Debug, Clone)]
@@ -45,19 +46,15 @@ impl Transform {
         }
     }
 
-    pub fn position(x: Position, y: Position) -> Transform {
+    pub fn bottom(mut self) -> Self {
-        Transform {
+        self.y = Position::End;
-            x,
+        self
-            y,
-            width: Dimension::Auto,
-            height: Dimension::Auto,
-        }
     }
 
-    pub fn dimensions(&mut self, width: u16, height: u16) -> Self {
+    pub fn dimensions(mut self, width: u16, height: u16) -> Self {
         self.width = Dimension::Const(width);
         self.height = Dimension::Const(height);
-        self.clone()
+        self
     }
 
     pub fn use_dimensions(&self, raw: &mut RawTransform) {
@@ -96,6 +93,7 @@ impl Position {
         match self {
             Self::Center => *r = (parent - size) / 2,
             Self::Const(n) => *r = *n,
+            Self::End => *r = parent - size,
         }
     }
 }

src/utils.rs

@@ -106,3 +106,17 @@ pub fn hex_ansi_bg(hex: u32) -> String {
     let b = (hex & 0xFF) as u8;
     format!("\x1b[48;2;{r};{g};{b}m")
 }
+
+pub(crate) fn print(x: u16, y: u16, text: &str) {
+    for (i, line) in text.lines().enumerate() {
+        print!("\x1b[{};{}H{line}\x1b[0m", y + i as u16 + 1, x + 1);
+        flush().unwrap();
+    }
+}
+
+pub(crate) fn print_liner(x: u16, y: u16, liner: &str, text: &str) {
+    for (i, line) in text.lines().enumerate() {
+        print!("\x1b[{};{}H{liner}{line}\x1b[0m", y + i as u16 + 1, x + 1);
+        flush().unwrap();
+    }
+}