summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/app.rs81
-rw-r--r--src/lua/iobuffer.rs38
-rw-r--r--src/lua/mod.rs80
-rw-r--r--src/main.rs20
-rw-r--r--src/sheet/cell.rs198
-rw-r--r--src/sheet/mod.rs98
-rw-r--r--src/sheet/register.rs60
-rw-r--r--src/tui.rs22
-rw-r--r--src/widgets/luaeditor/buffer.rs134
-rw-r--r--src/widgets/luaeditor/cursor.rs102
-rw-r--r--src/widgets/luaeditor/mod.rs132
-rw-r--r--src/widgets/mod.rs2
-rw-r--r--src/widgets/sheetview.rs360
13 files changed, 1327 insertions, 0 deletions
diff --git a/src/app.rs b/src/app.rs
new file mode 100644
index 0000000..3544fdf
--- /dev/null
+++ b/src/app.rs
@@ -0,0 +1,81 @@
+use std::{io, time::Duration};
+
+use crate::{sheet::register::Register, tui, widgets::sheetview::SheetView};
+
+use ratatui::{
+ crossterm::event::{self, Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers},
+ prelude::*,
+ widgets::Block,
+};
+
+#[derive(Debug)]
+pub struct App<'a> {
+ exit: bool,
+ view: SheetView<'a>,
+}
+
+impl App<'_> {
+ pub fn new() -> Self {
+ let sheet_id = Register::create(200, 1000);
+ let sheet = Register::get(sheet_id).unwrap();
+
+ {
+ let mut sheet = sheet.write().unwrap();
+
+ for row in 0..sheet.height() {
+ for column in 0..sheet.width() {
+ sheet.set_cell(row, column, format!("{}/{}", row, column).into());
+ }
+ }
+ }
+
+ let view = SheetView::new(sheet_id).block(Block::bordered().title("Sheet"));
+
+ Self { exit: false, view }
+ }
+
+ pub fn run(&mut self, terminal: &mut tui::Tui) -> io::Result<()> {
+ while !self.exit {
+ terminal.draw(|frame| self.render_frame(frame))?;
+ self.handle_events()?;
+ }
+
+ Ok(())
+ }
+
+ fn render_frame(&mut self, frame: &mut Frame) {
+ frame.render_widget(self, frame.size());
+ }
+
+ fn handle_events(&mut self) -> io::Result<()> {
+ if event::poll(Duration::from_millis(100))? {
+ match event::read()? {
+ Event::Key(key_event) if key_event.kind == KeyEventKind::Press => {
+ self.handle_key_event(key_event)
+ }
+ _ => {}
+ }
+ }
+ Ok(())
+ }
+
+ fn handle_key_event(&mut self, key_event: KeyEvent) {
+ match key_event.code {
+ KeyCode::Char('q') if key_event.modifiers == KeyModifiers::CONTROL => self.exit(),
+ _ => self.view.handle_key_event(key_event),
+ }
+ }
+
+ fn exit(&mut self) {
+ self.exit = true;
+ }
+}
+
+impl Widget for &mut App<'_> {
+ fn render(self, area: Rect, buf: &mut Buffer)
+ where
+ Self: Sized,
+ {
+ self.view.render(area, buf);
+ }
+}
diff --git a/src/lua/iobuffer.rs b/src/lua/iobuffer.rs
new file mode 100644
index 0000000..1150e0d
--- /dev/null
+++ b/src/lua/iobuffer.rs
@@ -0,0 +1,38 @@
+use std::sync::RwLock;
+
+pub struct IoBuffer {
+ buffer: String,
+}
+
+impl IoBuffer {
+ const fn new() -> Self {
+ Self {
+ buffer: String::new(),
+ }
+ }
+
+ pub fn get(&self) -> String {
+ self.buffer.clone()
+ }
+
+ pub fn write<S>(&mut self, value: S)
+ where
+ S: AsRef<str>
+ {
+ self.buffer += value.as_ref();
+ }
+
+ pub fn writeln<S>(&mut self, value: S)
+ where
+ S: AsRef<str>
+ {
+ self.buffer += value.as_ref();
+ self.buffer += "\n";
+ }
+}
+
+static STDOUT_BUFFER: RwLock<IoBuffer> = RwLock::new(IoBuffer::new());
+
+pub fn iobuffer() -> &'static RwLock<IoBuffer> {
+ &STDOUT_BUFFER
+}
diff --git a/src/lua/mod.rs b/src/lua/mod.rs
new file mode 100644
index 0000000..5d45ee9
--- /dev/null
+++ b/src/lua/mod.rs
@@ -0,0 +1,80 @@
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use mlua::prelude::*;
+
+use crate::sheet::{cell::CellRef, register::Register};
+
+pub mod iobuffer;
+
+fn print(_: &Lua, args: LuaMultiValue) -> LuaResult<()> {
+ let mut writer = iobuffer::iobuffer().write().unwrap();
+
+ for (i, arg) in args.iter().enumerate() {
+ if let Some(ud) = arg.as_userdata() {
+ if ud.is::<CellRef>() {
+ writer.write(ud.borrow::<CellRef>().unwrap().value().to_string());
+ } else {
+ writer.write(format!("{:#?}", ud));
+ }
+ } else {
+ writer.write(format!("{:#?}", arg));
+ }
+
+ if i < args.len() - 1 {
+ writer.write(", ");
+ }
+ }
+ writer.writeln("");
+ Ok(())
+}
+
+pub fn new_instance() -> LuaResult<Lua> {
+ let lua = Lua::new();
+
+ let print_binding = lua.create_function(print)?;
+ lua.globals().set("print", print_binding)?;
+
+ {
+ let math = lua.globals().get::<_, LuaTable>("math");
+ let randomseed = math.unwrap().get::<_, LuaFunction>("randomseed").unwrap();
+
+ let seed = SystemTime::now()
+ .duration_since(UNIX_EPOCH)
+ .unwrap()
+ .as_millis();
+ randomseed.call::<_, ()>(seed).unwrap();
+ }
+
+ let neosheet = lua.create_table()?;
+
+ let register = Register;
+ neosheet.set("sheets", register)?;
+
+ lua.globals().set("neosheet", neosheet)?;
+
+ Ok(lua)
+}
+
+#[cfg(test)]
+mod test {
+ use mlua::Function;
+
+ use super::new_instance;
+
+ #[test]
+ fn function_eval() {
+ let lua = new_instance().unwrap();
+ let func: Function = lua
+ .load(
+ r#"
+ function(a, b, c)
+ return a + b * c
+ end
+ "#,
+ )
+ .eval()
+ .unwrap();
+ eprintln!("{}", func.call::<_, String>((1, 2, 3, 4)).unwrap());
+ assert!(false);
+ }
+}
diff --git a/src/main.rs b/src/main.rs
new file mode 100644
index 0000000..bbfafb1
--- /dev/null
+++ b/src/main.rs
@@ -0,0 +1,20 @@
+use mlua::prelude::*;
+use std::io;
+
+pub mod app;
+pub mod sheet;
+pub mod tui;
+pub mod widgets;
+pub mod lua;
+
+fn run() -> io::Result<()> {
+ let mut terminal = tui::init()?;
+ let app_result = app::App::new().run(&mut terminal);
+ tui::restore()?;
+ app_result
+}
+
+fn main() -> LuaResult<()> {
+ run()?;
+ Ok(())
+}
diff --git a/src/sheet/cell.rs b/src/sheet/cell.rs
new file mode 100644
index 0000000..413e299
--- /dev/null
+++ b/src/sheet/cell.rs
@@ -0,0 +1,198 @@
+use std::fmt::Display;
+
+use mlua::{FromLua, IntoLua, UserData, Value};
+
+use super::register::{Register, SheetId};
+
+#[derive(Debug, Clone)]
+pub enum Cell {
+ String(String),
+ Number(f64),
+}
+
+impl Cell {
+ pub fn new_empty() -> Self {
+ Cell::String("".to_string())
+ }
+}
+
+impl<'lua> IntoLua<'lua> for Cell {
+ fn into_lua(self, lua: &'lua mlua::Lua) -> mlua::Result<mlua::Value<'lua>> {
+ match self {
+ Cell::String(s) => s.into_lua(lua),
+ Cell::Number(n) => n.into_lua(lua),
+ }
+ }
+}
+
+impl<'lua> FromLua<'lua> for Cell {
+ fn from_lua(value: mlua::Value<'lua>, _: &'lua mlua::Lua) -> mlua::Result<Self> {
+ match value {
+ Value::Nil => Ok(Cell::new_empty()),
+ Value::Boolean(b) => Ok(Cell::String(b.to_string())),
+ Value::Integer(n) => Ok(Cell::String(n.to_string())),
+ Value::Number(n) => Ok(Cell::String(n.to_string())),
+ Value::String(s) => Ok(Cell::String(s.to_str()?.to_string())),
+ _ => Err(mlua::Error::runtime(
+ "cell content must be number or string",
+ )),
+ }
+ }
+}
+
+impl Display for Cell {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ Cell::String(s) => s.fmt(f),
+ Cell::Number(n) => n.fmt(f),
+ }
+ }
+}
+
+impl From<String> for Cell {
+ fn from(value: String) -> Self {
+ Cell::String(value.clone())
+ }
+}
+
+impl From<&str> for Cell {
+ fn from(value: &str) -> Self {
+ Cell::String(value.to_string())
+ }
+}
+
+macro_rules! cell_from_integer {
+ ($($number:ty),+ $(,)?) => {
+ $(
+ impl From<$number> for Cell {
+ fn from(value: $number) -> Self {
+ Cell::Number(value as f64)
+ }
+ }
+ )*
+ };
+}
+
+#[rustfmt::skip]
+cell_from_integer!(
+ i8, i16, i32, i64, i128, isize,
+ u8, u16, u32, u64, u128, usize,
+ f32, f64
+);
+
+#[derive(Debug, Clone, Copy)]
+pub struct CellRef {
+ row: usize,
+ column: usize,
+ sheet_id: SheetId,
+}
+
+impl CellRef {
+ pub fn new(sheet_id: SheetId, row: usize, column: usize) -> Option<Self> {
+ Register::get(sheet_id)
+ .map(|sheet| {
+ sheet.read().unwrap().get_cell(row, column).map(|_| Self {
+ sheet_id,
+ row,
+ column,
+ })
+ })
+ .unwrap_or(None)
+ }
+
+ pub fn value(&self) -> Cell {
+ return Register::get(self.sheet_id)
+ .unwrap()
+ .read()
+ .unwrap()
+ .get_cell(self.row, self.column)
+ .unwrap()
+ .clone();
+ }
+
+ pub fn set_value(&mut self, value: Cell) {
+ Register::get(self.sheet_id)
+ .unwrap()
+ .write()
+ .unwrap()
+ .set_cell(self.row, self.column, value);
+ }
+
+ pub fn left(&self) -> Option<Self> {
+ if self.column > 0 {
+ Self::new(self.sheet_id, self.row, self.column - 1)
+ } else {
+ None
+ }
+ }
+
+ pub fn right(&self) -> Option<Self> {
+ Self::new(self.sheet_id, self.row, self.column + 1)
+ }
+
+ pub fn up(&self) -> Option<Self> {
+ if self.row > 0 {
+ Self::new(self.sheet_id, self.row - 1, self.column)
+ } else {
+ None
+ }
+ }
+
+ pub fn down(&self) -> Option<Self> {
+ Self::new(self.sheet_id, self.row + 1, self.column)
+ }
+
+ pub fn begin(&self) -> Option<Self> {
+ Self::new(self.sheet_id, self.row, 0)
+ }
+
+ pub fn end(&self) -> Option<Self> {
+ Self::new(
+ self.sheet_id,
+ self.row,
+ Register::get(self.sheet_id)
+ .unwrap()
+ .read()
+ .unwrap()
+ .width()
+ - 1,
+ )
+ }
+
+ pub fn top(&self) -> Option<Self> {
+ Self::new(self.sheet_id, 0, self.column)
+ }
+
+ pub fn bottom(&self) -> Option<Self> {
+ Self::new(
+ self.sheet_id,
+ Register::get(self.sheet_id)
+ .unwrap()
+ .read()
+ .unwrap()
+ .height()
+ - 1,
+ self.column,
+ )
+ }
+}
+
+impl UserData for CellRef
+where
+ Self: Sized,
+{
+ fn add_fields<'lua, F: mlua::UserDataFields<'lua, Self>>(fields: &mut F) {
+ fields.add_field_method_get("row", |_, this| Ok(this.row));
+ fields.add_field_method_get("column", |_, this| Ok(this.column));
+ fields.add_field_method_get("value", |_, this| Ok(this.value()));
+ fields.add_field_method_set("value", |_, this, value| Ok(this.set_value(value)));
+ fields.add_field_method_get("left", |lua, this| this.left().into_lua(lua));
+ fields.add_field_method_get("right", |lua, this| this.right().into_lua(lua));
+ fields.add_field_method_get("up", |lua, this| this.up().into_lua(lua));
+ fields.add_field_method_get("down", |lua, this| this.down().into_lua(lua));
+ fields.add_field_method_get("begin", |lua, this| this.begin().into_lua(lua));
+ fields.add_field_method_get("end", |lua, this| this.end().into_lua(lua));
+ fields.add_field_method_get("top", |lua, this| this.top().into_lua(lua));
+ fields.add_field_method_get("bottom", |lua, this| this.bottom().into_lua(lua));
+ }
+}
diff --git a/src/sheet/mod.rs b/src/sheet/mod.rs
new file mode 100644
index 0000000..015e3d8
--- /dev/null
+++ b/src/sheet/mod.rs
@@ -0,0 +1,98 @@
+use cell::{Cell, CellRef};
+use mlua::{IntoLua, UserData, Value};
+use register::{Register, SheetId};
+
+pub mod cell;
+pub mod register;
+
+#[derive(Debug, Default, Clone)]
+pub struct Sheet {
+ id: register::SheetId,
+ rows: Vec<Vec<Cell>>,
+}
+
+impl Sheet {
+ pub(self) fn new(width: usize, height: usize, id: register::SheetId) -> Self {
+ Self {
+ id,
+ rows: vec![vec![Cell::new_empty(); width]; height],
+ }
+ }
+
+ pub fn set_cell(&mut self, row: usize, column: usize, cell: Cell) {
+ if row < self.height() && column < self.width() {
+ self.rows[row][column] = cell
+ }
+ }
+
+ pub fn get_cell<'a>(&'a self, row: usize, column: usize) -> Option<&'a Cell> {
+ if let Some(r) = self.rows.get(row) {
+ if let Some(_) = r.get(column) {
+ return Some(&self.rows[row][column]);
+ }
+ }
+
+ None
+ }
+
+ pub fn get_ref(&self, row: usize, column: usize) -> Option<CellRef> {
+ CellRef::new(self.id, row, column)
+ }
+
+ pub fn height(&self) -> usize {
+ self.rows.len()
+ }
+
+ pub fn set_height(&mut self, mut height: usize) {
+ height = height.max(1);
+ self.rows
+ .resize(height, vec![Cell::new_empty(); self.width()])
+ }
+
+ pub fn width(&self) -> usize {
+ self.rows.get(0).map(|r| r.len()).unwrap_or(1)
+ }
+
+ pub fn set_width(&mut self, mut width: usize) {
+ width = width.max(1);
+ for row in self.rows.iter_mut() {
+ row.resize(width, Cell::new_empty());
+ }
+ }
+
+ pub fn id(&self) -> register::SheetId {
+ self.id
+ }
+}
+
+struct SheetLuaRef {
+ id: SheetId,
+}
+
+impl SheetLuaRef {
+ pub fn new(id: SheetId) -> Self {
+ Self { id }
+ }
+}
+
+impl UserData for SheetLuaRef {
+ fn add_fields<'lua, F: mlua::UserDataFields<'lua, Self>>(fields: &mut F) {
+ fields.add_field_method_get("width", |_, luaref| {
+ Ok(Register::get(luaref.id).unwrap().read().unwrap().width())
+ });
+
+ fields.add_field_method_get("height", |_, luaref| {
+ Ok(Register::get(luaref.id).unwrap().read().unwrap().height())
+ });
+ }
+
+ fn add_methods<'lua, M: mlua::UserDataMethods<'lua, Self>>(methods: &mut M) {
+ methods.add_method_mut("cell", |lua, luaref, (row, column): (usize, usize)| {
+ if let Some(_) = Register::get(luaref.id) {
+ Ok(CellRef::new(luaref.id, row, column).into_lua(lua).unwrap())
+ } else {
+ Ok(Value::Nil)
+ }
+ })
+ }
+}
diff --git a/src/sheet/register.rs b/src/sheet/register.rs
new file mode 100644
index 0000000..aa5245b
--- /dev/null
+++ b/src/sheet/register.rs
@@ -0,0 +1,60 @@
+use std::sync::{Arc, RwLock};
+
+use mlua::{UserData, Value};
+
+use super::{Sheet, SheetLuaRef};
+
+static REGISTER: RwLock<Vec<Arc<RwLock<Sheet>>>> = RwLock::new(Vec::new());
+
+pub type SheetId = usize;
+
+#[derive(Debug)]
+pub struct Register;
+
+impl Register {
+ pub fn create(width: usize, height: usize) -> SheetId {
+ let mut register = REGISTER.write().unwrap();
+
+ let id = register.len();
+ let sheet = Sheet::new(width, height, id);
+ register.push(Arc::new(RwLock::new(sheet)));
+ id
+ }
+
+ pub fn get<'a>(id: SheetId) -> Option<Arc<RwLock<Sheet>>> {
+ let register = REGISTER.read().unwrap();
+
+ if id < register.len() {
+ Some(Arc::clone(&register[id]))
+ } else {
+ None
+ }
+ }
+}
+
+impl UserData for Register {
+ fn add_methods<'lua, M: mlua::UserDataMethods<'lua, Self>>(methods: &mut M) {
+ methods.add_function_mut("create", |lua, (width, height): (usize, usize)| {
+ let id = Register::create(width, height);
+ let luaref = SheetLuaRef::new(id);
+ if let Ok(ud) = lua.create_userdata(luaref) {
+ Ok(Value::UserData(ud))
+ } else {
+ Ok(Value::Nil)
+ }
+ });
+
+ methods.add_function_mut("get", |lua, id: SheetId| {
+ if let Some(_) = Register::get(id) {
+ let luaref = SheetLuaRef::new(id);
+ if let Ok(ud) = lua.create_userdata(luaref) {
+ Ok(Value::UserData(ud))
+ } else {
+ Ok(Value::Nil)
+ }
+ } else {
+ Ok(Value::Nil)
+ }
+ })
+ }
+}
diff --git a/src/tui.rs b/src/tui.rs
new file mode 100644
index 0000000..5669855
--- /dev/null
+++ b/src/tui.rs
@@ -0,0 +1,22 @@
+use std::io::{self, stdout, Stdout};
+
+use ratatui::{backend::CrosstermBackend, crossterm::{terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen}, ExecutableCommand}, Terminal};
+
+
+pub type Tui = Terminal<CrosstermBackend<Stdout>>;
+
+pub fn init() -> io::Result<Tui> {
+ stdout().execute(EnterAlternateScreen)?;
+ enable_raw_mode()?;
+ let mut terminal = Terminal::new(CrosstermBackend::new(stdout()))?;
+
+ terminal.clear()?;
+
+ Ok(terminal)
+}
+
+pub fn restore() -> io::Result<()> {
+ stdout().execute(LeaveAlternateScreen)?;
+ disable_raw_mode()?;
+ Ok(())
+}
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<String>,
+ 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<String> {
+ &self.lines
+ }
+}
+
+impl FromStr for Buffer {
+ type Err = ();
+
+ fn from_str(s: &str) -> Result<Self, Self::Err> {
+ 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<Block<'a>>,
+ scroll: usize,
+ buffer: Buffer,
+}
+
+impl<'a> LuaEditor<'a> {
+ pub fn new<S>(content: S) -> Self
+ where
+ S: AsRef<str>,
+ {
+ Self {
+ block: None,
+ scroll: 0,
+ buffer: Buffer::from_str(content.as_ref()).unwrap(),
+ }
+ }
+
+ pub fn block(mut self, block: Option<Block<'a>>) -> 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<Block<'a>>,
+ luaeditor: Option<LuaEditor<'a>>,
+ sheet: SheetId,
+ selection: Option<(u16, u16)>,
+ cursor: (u16, u16),
+ scroll: (u16, u16),
+ error_window: Option<String>,
+ process_handle: Option<JoinHandle<Option<String>>>,
+ process_progress: Arc<Mutex<usize>>,
+}
+
+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::<Function>();
+ 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::<Function>()
+ .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::<Vec<_>>();
+ 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);
+ }
+ }
+}
generated by cgit v1.2.3-70-g09d2 (git 2.53.0) at 2026-05-12 23:40:34 +0000