From 58b305b9f6d13007d2ea62775054c95177f81092 Mon Sep 17 00:00:00 2001 From: Nathan Reiner Date: Thu, 25 Jul 2024 00:40:37 +0200 Subject: first sketch --- src/widgets/luaeditor/buffer.rs | 134 +++++++++++++++ src/widgets/luaeditor/cursor.rs | 102 ++++++++++++ src/widgets/luaeditor/mod.rs | 132 +++++++++++++++ src/widgets/mod.rs | 2 + src/widgets/sheetview.rs | 360 ++++++++++++++++++++++++++++++++++++++++ 5 files changed, 730 insertions(+) create mode 100644 src/widgets/luaeditor/buffer.rs create mode 100644 src/widgets/luaeditor/cursor.rs create mode 100644 src/widgets/luaeditor/mod.rs create mode 100644 src/widgets/mod.rs create mode 100644 src/widgets/sheetview.rs (limited to 'src/widgets') diff --git a/src/widgets/luaeditor/buffer.rs b/src/widgets/luaeditor/buffer.rs new file mode 100644 index 0000000..bdbee8d --- /dev/null +++ b/src/widgets/luaeditor/buffer.rs @@ -0,0 +1,134 @@ +use std::str::FromStr; + +use super::cursor::{Cursor, CursorMove}; + +#[derive(Default, Debug)] +pub struct Buffer { + lines: Vec, + cursor: Cursor, +} + +impl Buffer { + pub fn new() -> Self { + Self { + lines: Vec::new(), + cursor: Cursor::new().with_position(0, 0).with_max(0, 0) + } + } + + fn refresh_line_max(&mut self) { + self.cursor + .set_x_max(self.lines[self.cursor.y() as usize].len()) + } + + fn refresh_buffer_max(&mut self) { + self.cursor.set_y_max(self.lines.len() - 1); + } + + fn refresh_max(&mut self) { + self.refresh_line_max(); + self.refresh_buffer_max(); + } + + pub fn insert(&mut self, c: char) { + match c { + '\n' => { + let (a, b) = { + let line = self.current_line(); + let (a, b) = line.split_at(self.cursor.x()); + (a.to_string(), b.to_string()) + }; + + { + *self.current_line_mut() = a; + } + self.cursor.move_unchecked(CursorMove::Down(1)); + self.cursor.move_unchecked(CursorMove::Begin); + self.lines.insert(self.cursor().y(), b); + self.refresh_max() + } + _ => { + let x = self.cursor().x(); + self.current_line_mut().insert(x, c); + self.refresh_line_max(); + self.cursor.move_checked(CursorMove::Right(1)); + } + } + } + + pub fn delete(&mut self) { + if self.cursor.is_at_start() && !self.cursor.is_at_top() { + let old_line = self.current_line_mut().clone(); + self.lines.remove(self.cursor.y()); + self.cursor.move_checked(CursorMove::Up(1)); + self.refresh_line_max(); + + let new_x = self.current_line().len(); + self.current_line_mut().push_str(&old_line); + self.cursor.move_checked(CursorMove::Jump((new_x, self.cursor.y()))); + + self.refresh_buffer_max() + } else { + let x = self.cursor.x() - 1; + self.current_line_mut().remove(x); + self.refresh_line_max(); + self.cursor.move_checked(CursorMove::Left(1)); + } + + } + + pub fn line(&self, index: usize) -> Option<&String> { + self.lines.get(index) + } + + fn line_mut(&mut self, index: usize) -> Option<&mut String> { + self.lines.get_mut(index) + } + + pub fn current_line(&self) -> &String { + self.line(self.cursor.y() as usize).unwrap() + } + + fn current_line_mut(&mut self) -> &mut String { + self.line_mut(self.cursor.y() as usize).unwrap() + } + + pub fn cursor(&self) -> &Cursor { + &self.cursor + } + + pub fn move_cursor(&mut self, m: CursorMove) { + match m { + CursorMove::Up(_) + | CursorMove::Down(_) + | CursorMove::Top + | CursorMove::Bottom + | CursorMove::Jump(_) => { + self.cursor.move_checked(m); + self.cursor.set_x_max(self.current_line().len()); + self.cursor.correct_cursor_position(); + } + CursorMove::Left(_) | CursorMove::Right(_) | CursorMove::Begin | CursorMove::End => { + self.cursor.move_checked(m) + } + } + } + + pub fn lines(&self) -> &Vec { + &self.lines + } +} + +impl FromStr for Buffer { + type Err = (); + + fn from_str(s: &str) -> Result { + let lines: Vec<_> = s.lines().map(|s| s.to_string()).collect(); + let mut buffer = Self::new(); + buffer.lines = lines; + + buffer.refresh_max(); + + Ok(buffer) + } +} diff --git a/src/widgets/luaeditor/cursor.rs b/src/widgets/luaeditor/cursor.rs new file mode 100644 index 0000000..c4466d0 --- /dev/null +++ b/src/widgets/luaeditor/cursor.rs @@ -0,0 +1,102 @@ + +pub enum CursorMove { + Up(usize), + Down(usize), + Left(usize), + Right(usize), + Top, + Bottom, + Begin, + End, + Jump((usize, usize)), +} + +#[derive(Default, Debug)] +pub struct Cursor { + x: isize, + y: isize, + x_max: isize, + y_max: isize, +} + +impl Cursor { + pub fn new() -> Self { + Self { + x: 0, + y: 0, + x_max: 0, + y_max: 0, + } + } + + pub fn with_position(mut self, x: isize, y: isize) -> Self { + self.x = x; + self.y = y; + self + } + + pub fn with_max(mut self, x: isize, y: isize) -> Self { + self.x_max = x; + self.y_max = y; + self + } + + pub fn x(&self) -> usize { + self.x as usize + } + + pub fn y(&self) -> usize { + self.y as usize + } + + pub fn set_x_max(&mut self, max: usize) { + self.x_max = max as isize; + } + + pub fn set_y_max(&mut self, max: usize) { + self.y_max = max as isize; + } + + pub fn move_checked(&mut self, m: CursorMove) { + self.move_unchecked(m); + self.correct_cursor_position(); + } + + pub fn move_unchecked(&mut self, m: CursorMove) { + match m { + CursorMove::Up(n) => self.y -= n as isize, + CursorMove::Down(n) => self.y += n as isize, + CursorMove::Left(n) => self.x -= n as isize, + CursorMove::Right(n) => self.x += n as isize, + CursorMove::Top => self.y = 0, + CursorMove::Bottom => self.y = self.y_max, + CursorMove::Begin => self.x = 0, + CursorMove::End => self.x = self.x_max, + CursorMove::Jump((x, y)) => { + self.x = x as isize; + self.y = y as isize; + } + }; + } + + pub fn correct_cursor_position(&mut self) { + self.y = self.y.max(0).min(self.y_max); + self.x = self.x.max(0).min(self.x_max); + } + + pub fn is_at_start(&self) -> bool { + self.x == 0 + } + + pub fn is_at_end(&self) -> bool { + self.x == self.x_max + } + + pub fn is_at_top(&self) -> bool { + self.y == 0 + } + + pub fn is_at_bottom(&self) -> bool { + self.y == self.y_max + } +} diff --git a/src/widgets/luaeditor/mod.rs b/src/widgets/luaeditor/mod.rs new file mode 100644 index 0000000..723d8b5 --- /dev/null +++ b/src/widgets/luaeditor/mod.rs @@ -0,0 +1,132 @@ +use std::str::FromStr; + +use ratatui::{ + crossterm::event::{KeyCode, KeyEvent}, + prelude::BlockExt, + style::Stylize, + text::ToSpan, + widgets::{Block, Widget}, +}; + +pub mod buffer; +pub mod cursor; + +use buffer::Buffer; + +use self::cursor::CursorMove; + +#[derive(Debug)] +pub struct LuaEditor<'a> { + block: Option>, + scroll: usize, + buffer: Buffer, +} + +impl<'a> LuaEditor<'a> { + pub fn new(content: S) -> Self + where + S: AsRef, + { + Self { + block: None, + scroll: 0, + buffer: Buffer::from_str(content.as_ref()).unwrap(), + } + } + + pub fn block(mut self, block: Option>) -> Self { + self.block = block; + self + } + + pub fn handle_key_event(&mut self, event: KeyEvent) { + match event.code { + KeyCode::Char(c) => self.buffer.insert(c), + KeyCode::Backspace => { + self.buffer.delete(); + } + KeyCode::Enter => { + self.buffer.insert('\n'); + } + KeyCode::Left => self.buffer.move_cursor(CursorMove::Left(1)), + KeyCode::Right => self.buffer.move_cursor(CursorMove::Right(1)), + KeyCode::Up => self.buffer.move_cursor(CursorMove::Up(1)), + KeyCode::Down => self.buffer.move_cursor(CursorMove::Down(1)), + KeyCode::Home => {} + KeyCode::End => {} + KeyCode::PageUp => {} + KeyCode::PageDown => {} + KeyCode::Tab => self.buffer.insert('\t'), + KeyCode::BackTab => {} + KeyCode::Delete => {} + KeyCode::Insert => {} + KeyCode::F(_) => {} + KeyCode::Null => {} + KeyCode::Esc => {} + KeyCode::CapsLock => {} + KeyCode::ScrollLock => {} + KeyCode::NumLock => {} + KeyCode::PrintScreen => {} + KeyCode::Pause => {} + KeyCode::Menu => {} + KeyCode::KeypadBegin => {} + KeyCode::Media(_) => {} + KeyCode::Modifier(_) => {} + } + } + + pub fn text(&self) -> String { + self.buffer.lines().join("\n") + } +} + +impl Widget for &mut LuaEditor<'_> { + fn render(self, area: ratatui::prelude::Rect, buf: &mut ratatui::prelude::Buffer) + where + Self: Sized, + { + self.block.render(area, buf); + let inner_area = self.block.inner_if_some(area); + + for (i, line) in self.buffer.lines().iter().enumerate().skip(self.scroll) { + let replace = &line.replace('\t', " "); + let span = replace.to_span(); + let mut span_area = inner_area.clone(); + span_area.height = 1; + span_area.y += i as u16; + + if !inner_area.contains(span_area.into()) { + break; + } + + span.render(span_area, buf) + } + + let mut cursor_area = inner_area.clone(); + cursor_area.width = 1; + cursor_area.height = 1; + cursor_area.y += self.buffer.cursor().y() as u16; + cursor_area.x += self.buffer.cursor().x() as u16; + + let (first, _) = self + .buffer + .current_line() + .split_at(self.buffer.cursor().x() as usize); + + for c in first.chars() { + if c == '\t' { + cursor_area.x += 1; + } + } + + self.buffer + .current_line() + .chars() + .nth(self.buffer.cursor().x() as usize) + .map(|c| if c == '\t' { ' ' } else { c }) + .unwrap_or(' ') + .to_span() + .reversed() + .render(cursor_area, buf); + } +} diff --git a/src/widgets/mod.rs b/src/widgets/mod.rs new file mode 100644 index 0000000..8a9b1a0 --- /dev/null +++ b/src/widgets/mod.rs @@ -0,0 +1,2 @@ +pub mod sheetview; +pub mod luaeditor; diff --git a/src/widgets/sheetview.rs b/src/widgets/sheetview.rs new file mode 100644 index 0000000..57894a2 --- /dev/null +++ b/src/widgets/sheetview.rs @@ -0,0 +1,360 @@ +use std::{ + sync::{Arc, Mutex}, + thread::JoinHandle, +}; + +use layout::Offset; +use mlua::Function; +use ratatui::{ + crossterm::event::{KeyCode, KeyEvent, KeyModifiers}, + prelude::*, + style::Stylize, + text::ToLine, + widgets::{block::BlockExt, Block, Clear, Gauge, Widget}, +}; + +use crate::sheet::{ + cell::Cell, + register::{Register, SheetId}, +}; + +use super::luaeditor::LuaEditor; + +const DEFAULT_COLUMN_WIDTH: u16 = 10; + +#[derive(Debug)] +pub struct SheetView<'a> { + block: Option>, + luaeditor: Option>, + sheet: SheetId, + selection: Option<(u16, u16)>, + cursor: (u16, u16), + scroll: (u16, u16), + error_window: Option, + process_handle: Option>>, + process_progress: Arc>, +} + +impl<'a> SheetView<'a> { + pub fn new(sheet: SheetId) -> Self { + Self { + block: None, + luaeditor: None, + sheet, + selection: None, + cursor: (0, 0), + scroll: (0, 0), + error_window: None, + process_handle: None, + process_progress: Arc::new(Mutex::new(0)), + } + } + + pub fn block(mut self, block: Block<'a>) -> Self { + self.block = Some(block); + self + } + + pub fn sheet(mut self, sheet: SheetId) -> Self { + self.sheet = sheet; + self + } + + pub fn move_cursor_by(&mut self, delta: (i32, i32)) { + let lock = Register::get(self.sheet).unwrap(); + let sheet = lock.read().unwrap(); + + self.cursor.0 = ((self.cursor.0 as i32) + delta.0) + .max(0) + .min(sheet.height() as i32 - 1) as u16; + self.cursor.1 = ((self.cursor.1 as i32) + delta.1) + .max(0) + .min(sheet.width() as i32 - 1) as u16; + } + + pub fn select_mode(&mut self, flag: bool) { + if flag { + self.selection = Some(self.cursor); + } else { + self.selection = None; + } + } + + pub fn is_select_mode(&self) -> bool { + self.selection.is_some() + } + + pub fn toggle_select_mode(&mut self) { + self.select_mode(!self.is_select_mode()); + } + + pub fn selection(&self) -> Vec<(u16, u16)> { + let mut selection = Vec::new(); + + if let Some((row, column)) = self.selection_range() { + for i in row.0..=row.1 { + for j in column.0..=column.1 { + selection.push((i, j)) + } + } + } + + selection + } + + fn is_in_selection(&mut self, row: u16, column: u16) -> bool { + if let Some((row_range, column_range)) = self.selection_range() { + row >= row_range.0 + && row <= row_range.1 + && column >= column_range.0 + && column <= column_range.1 + } else { + false + } + } + + fn selection_range(&self) -> Option<((u16, u16), (u16, u16))> { + if let Some(selection) = self.selection { + let row = if selection.0 > self.cursor.0 { + (self.cursor.0, selection.0) + } else { + (selection.0, self.cursor.0) + }; + + let column = if selection.1 > self.cursor.1 { + (self.cursor.1, selection.1) + } else { + (selection.1, self.cursor.1) + }; + + Some((row, column)) + } else { + None + } + } + + fn join_process_handle_on_finished(&mut self) { + if let Some(handle) = self.process_handle.take() { + if handle.is_finished() { + self.error_window = handle.join().unwrap(); + self.process_handle = None; + } else { + self.process_handle = Some(handle); + } + } + } + + pub fn handle_key_event(&mut self, event: KeyEvent) { + if self.process_handle.is_some() { + self.join_process_handle_on_finished() + } else if let Some(_) = &self.error_window { + self.error_window = None; + } else if let Some(textarea) = &mut self.luaeditor { + match event.code { + KeyCode::Char('r') if event.modifiers == KeyModifiers::CONTROL => { + let script = textarea.text(); + *self.process_progress.lock().unwrap() = 0; + + let lua = crate::lua::new_instance().unwrap(); + let result = lua + .load(script.clone()) + .set_name("Temp Script") + .eval::(); + match result { + Ok(_) => { + let (width, height) = { + let lock = Register::get(self.sheet).unwrap(); + let sheet = lock.write().unwrap(); + (sheet.width(), sheet.height()) + }; + + let mut cells = Vec::new(); + + if let Some(_) = self.selection { + cells = self.selection() + } else { + for row in 0..height { + for column in 0..width { + cells.push((row as u16, column as u16)); + } + } + } + + { + let process_progress = Arc::clone(&self.process_progress); + let sheet = self.sheet; + self.process_handle = Some(std::thread::spawn(move || { + let lua = crate::lua::new_instance().unwrap(); + let func = lua + .load(script) + .set_name("Temp Script") + .eval::() + .unwrap(); + for (i, (row, column)) in cells.iter().enumerate() { + *process_progress.lock().unwrap() = i * 100 / cells.len(); + let cellref = { + let lock = Register::get(sheet).unwrap(); + let sheet = lock.read().unwrap(); + sheet.get_ref(*row as usize, *column as usize) + }; + if let Err(error) = func.call::<_, Cell>(cellref) { + return Some(error.to_string()); + } + } + + None + })); + } + } + Err(error) => { + self.error_window = Some(error.to_string()); + } + } + } + KeyCode::Esc => { + self.luaeditor = None; + } + _ => { + textarea.handle_key_event(event); + } + } + } else { + match event.code { + KeyCode::Char('j') => self.move_cursor_by((1, 0)), + KeyCode::Char('k') => self.move_cursor_by((-1, 0)), + KeyCode::Char('h') => self.move_cursor_by((0, -1)), + KeyCode::Char('l') => self.move_cursor_by((0, 1)), + KeyCode::Char('v') => self.toggle_select_mode(), + KeyCode::Char('s') => { + let editor = LuaEditor::new("function(cell)\n\t\nend") + .block(Some(Block::bordered().title(" Temp Script "))); + self.luaeditor = Some(editor) + } + _ => {} + } + } + } +} + +impl Widget for &mut SheetView<'_> { + fn render(self, area: ratatui::prelude::Rect, buf: &mut ratatui::prelude::Buffer) + where + Self: Sized, + { + let lock = Register::get(self.sheet).unwrap(); + let sheet = lock.read().unwrap(); + + let splits = Layout::horizontal([Constraint::Min(1), Constraint::Length(50)]).split(area); + let block_area = if self.luaeditor.is_some() { + splits[0] + } else { + area + }; + + let sheet_area = self.block.inner_if_some(block_area); + + let viewport_rows = sheet.height().min(sheet_area.height as usize); + let viewport_columns = sheet + .width() + .min((sheet_area.width / DEFAULT_COLUMN_WIDTH) as usize); + + if self.cursor.0 >= viewport_rows as u16 + self.scroll.0 { + self.scroll.0 = self.cursor.0 - viewport_rows as u16 + 1; + } else if self.cursor.0 < self.scroll.0 { + self.scroll.0 = self.cursor.0; + } + + if self.cursor.1 >= viewport_columns as u16 + self.scroll.1 { + self.scroll.1 = self.cursor.1 - viewport_columns as u16 + 1; + } else if self.cursor.1 < self.scroll.1 { + self.scroll.1 = self.cursor.1; + } + + for row in 0..viewport_rows as u16 { + for column in 0..(viewport_columns + 1) as u16 { + let (cell_pos_y, cell_pos_x) = (row + self.scroll.0, column + self.scroll.1); + + if let Some(cell) = sheet.get_cell(cell_pos_y as usize, cell_pos_x as usize) { + let cell = cell.to_string() + " "; + + let line = if (cell_pos_y, cell_pos_x) == self.cursor { + cell.to_line().bg(Color::Rgb(120, 90, 90)).white() + } else if self.is_in_selection(cell_pos_y, cell_pos_x) { + cell.to_line().bg(Color::Rgb(120, 120, 90)).white() + } else if (row + column) % 2 == 0 { + cell.to_line().bg(Color::Rgb(30, 30, 30)).white() + } else { + cell.to_line().bg(Color::Rgb(50, 50, 50)).white() + }; + + let rect = Rect::new( + sheet_area.x + column * DEFAULT_COLUMN_WIDTH, + sheet_area.y + row, + (sheet_area.width - column * DEFAULT_COLUMN_WIDTH) + .min(DEFAULT_COLUMN_WIDTH), + 1, + ); + + line.render(rect, buf); + } + } + } + + self.block.render(block_area, buf); + + if let Some(textarea) = &mut self.luaeditor { + textarea.render(splits[1], buf) + } + + if let Some(error_msg) = &self.error_window { + let lines = error_msg.lines().collect::>(); + let height = lines.len() as u16 + 2; + let width = lines.iter().map(|s| s.len()).max().unwrap_or(0) as u16 + 2; + + let centered = Rect::new( + (area.width - width) / 2, + (area.height - height) / 2, + width, + height, + ); + + let block = Block::bordered().red().on_black().bold().title(" Error "); + let inner_centered = block.inner(centered); + Clear::default().render(centered, buf); + block.render(centered, buf); + + for (i, line) in lines.iter().enumerate() { + let line = line.replace('\t', " ").red().on_black().bold(); + line.render(inner_centered.offset(Offset { x: 0, y: i as i32 }), buf); + } + } + + self.join_process_handle_on_finished(); + + if self.process_handle.is_some() { + let height = 3; + let width = area.width / 2; + + let centered = Rect::new( + (area.width - width) / 2, + (area.height - height) / 2, + width, + height, + ); + + let progress = *self.process_progress.lock().unwrap(); + let gauge = Gauge::default() + .block(Block::bordered().title("Progress").on_black()) + .gauge_style( + Style::default() + .fg(Color::White) + .bg(Color::Black) + .add_modifier(Modifier::ITALIC), + ) + .percent(progress as u16); + + Clear::default().render(centered, buf); + gauge.render(centered, buf); + } + } +} -- cgit v1.2.3-70-g09d2