not working

libk/src/util/editor.rs

@@ -0,0 +1,174 @@
+use crate::drivers::io::keyboard::{KeyStroke, get_keystroke_async};
+use crate::prelude::*;
+use crate::resources::font::{FONT_CP850_8X16, FONT_SPLEEN_8X16, Font};
+use crate::std::application::frame::Frame;
+use crate::std::application::render::RenderError;
+use crate::std::application::window::Window;
+use crate::std::application::{Application, Error};
+use crate::std::ascii::Writer;
+use crate::std::maths::geometry::Vec2;
+use alloc::string::ToString;
+
+pub struct Editor {
+    cursor_line: usize,
+    cursor_col: usize,
+
+    mode: Mode,
+    buffer: String,
+    window: Window,
+}
+
+impl Default for Editor {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<'a> Editor {
+    const PADDING: usize = 8;
+
+    pub const fn new() -> Self {
+        Self {
+            cursor_line: 0,
+            cursor_col: 0,
+
+            mode: Mode::Nor,
+            buffer: String::new(),
+            window: Window::new(),
+        }
+    }
+
+    fn render(&'a self) -> Result<Frame<'a>, RenderError> {
+        let mut frame = Frame::new(&self.window);
+        let writer = Writer::new(Font::default());
+
+        let (width, height) = writer.font_size().into();
+
+        let mut col = Self::PADDING;
+        let mut line = Self::PADDING;
+        let mut scale = 1;
+
+        for ch in self.buffer.chars() {
+            if ch == '\n' {
+                line += scale * height;
+                col = Self::PADDING;
+                scale = 1;
+                continue;
+            }
+
+            if width * scale + col > frame.dimensions().x() {
+                line += scale * height;
+                col = Self::PADDING;
+            }
+
+            writer.render_glyph(&mut frame, Vec2::new(col, line), ch as u8, scale)?;
+            col += scale * width;
+        }
+
+        Ok(frame)
+    }
+
+    fn get_lines(&self) -> Vec<&str> {
+        self.buffer.split('\n').collect::<Vec<&str>>();
+        todo!()
+    }
+
+    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
+    fn move_cursor(&mut self, x: i32, y: i32) {
+        todo!()
+    }
+
+    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
+    fn delete_char(&mut self) {
+        todo!()
+    }
+
+    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
+    fn insert_char(&mut self, c: char) {
+        todo!()
+    }
+
+    #[allow(unused_variables, dead_code, clippy::needless_pass_by_ref_mut)]
+    fn splitline(&mut self) {
+        todo!()
+    }
+}
+
+impl Application for Editor {
+    type Output = ();
+    async fn run(&mut self, _args: Vec<alloc::string::String>) -> Result<Self::Output, Error> {
+        self.window.set_dimensions(Vec2::new(1280, 800));
+        self.window.set_position(Vec2::new(0, 0));
+        self.window.open();
+
+        self.buffer = "Hello world, this is a test init. idk test \n ewntuiewi gjk gfdfg gndf ngdfgnmdfg ndfgmndfg gdfndfnkg njkdgjkndfjnkg ngnjfgnfgnfg fgn fn gfj gnfg jnfgjfngjk fgnjfgnjk jnkdgjnkdfg gfnd njkgdfgjn d fjnkgjkndfgjkndfgjn gndfjnk njkgdfng jnkfgdjknd jnfkgnjk".to_string();
+
+        loop {
+            if let Err(_err) = self.render().and_then(|frame| frame.render()) {
+                // TODO: Handle error
+                return Err(Error::ApplicationFailed("Rendering failed".to_string()));
+            }
+
+            let keystroke = get_keystroke_async().await;
+
+            match self.mode {
+                Mode::Nor => match keystroke {
+                    KeyStroke::Char('i') => self.mode = Mode::Ins,
+                    KeyStroke::Char('`') => return Ok(()),
+                    _ => {}
+                },
+                Mode::Ins => {
+                    match keystroke {
+                        KeyStroke::Char(c) => {
+                            match c {
+                                // escape
+                                '\x1B' => self.mode = Mode::Nor,
+                                // delete
+                                '\x7F' => self.delete_char(),
+                                // backspace
+                                '\x08' => {
+                                    self.move_cursor(-1, 0);
+                                    self.delete_char();
+                                }
+                                // enter
+                                '\n' => self.splitline(),
+                                _ => {
+                                    self.insert_char(c);
+                                    self.move_cursor(1, 0);
+                                }
+                            }
+                        }
+                        KeyStroke::Left => {
+                            self.move_cursor(-1, 0);
+                        }
+                        KeyStroke::Right => {
+                            self.move_cursor(1, 0);
+                        }
+                        KeyStroke::Up => {
+                            self.move_cursor(0, -1);
+                        }
+                        KeyStroke::Down => {
+                            self.move_cursor(0, 1);
+                        }
+                        KeyStroke::None => {}
+                        _ => {}
+                    }
+                }
+            }
+        }
+    }
+}
+
+pub enum Mode {
+    Nor,
+    Ins,
+}
+
+impl core::fmt::Display for Mode {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Nor => write!(f, "Normal"),
+            Self::Ins => write!(f, "Insert"),
+        }
+    }
+}