388 lines
15 KiB
Rust
388 lines
15 KiB
Rust
use std::{
|
|
cmp::{max, min}, collections::HashMap, io, path::PathBuf
|
|
};
|
|
|
|
use ratatui::{
|
|
DefaultTerminal, Frame, crossterm::event, layout::{self, Constraint, Layout, Rect}, prelude, style::{Color, Modifier, Style}, widgets::{Paragraph, Widget}
|
|
};
|
|
|
|
use crate::app::{
|
|
clipboard::Clipboard, error_msg::ErrorMessage, logic::calc::{CellType, Grid}, mode::Mode, screen::ScreenSpace
|
|
};
|
|
|
|
pub struct App {
|
|
pub exit: bool,
|
|
pub grid: Grid,
|
|
pub mode: Mode,
|
|
pub file: Option<PathBuf>,
|
|
pub error_msg: ErrorMessage,
|
|
pub vars: HashMap<String, String>,
|
|
pub screen: ScreenSpace,
|
|
// this could probably be a normal array
|
|
pub marks: HashMap<char, (usize, usize)>,
|
|
pub clipboard: Clipboard,
|
|
}
|
|
|
|
impl Widget for &App {
|
|
fn render(self, area: prelude::Rect, buf: &mut prelude::Buffer) {
|
|
let (x_max, y_max) = self.screen.how_many_cells_fit_in(&area, &self.vars);
|
|
|
|
let is_selected = |x: usize, y: usize| -> bool {
|
|
if let Mode::Visual((mut x1, mut y1)) = self.mode {
|
|
let (mut x2, mut y2) = self.grid.cursor();
|
|
x1 += 1;
|
|
y1 += 1;
|
|
x2 += 1;
|
|
y2 += 1;
|
|
|
|
// in-between the Xs
|
|
if (x >= x1 && x <= x2) || (x >= x2 && x <= x1) {
|
|
// in-between the Ys
|
|
if (y >= y1 && y <= y2) || (y >= y2 && y <= y1) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
false
|
|
};
|
|
|
|
for x in 0..x_max {
|
|
for y in 0..y_max {
|
|
let mut display = String::new();
|
|
let mut style = Style::new().fg(Color::White);
|
|
|
|
let cell_width = self.screen.get_cell_width(&self.vars) as u16;
|
|
let cell_height = self.screen.get_cell_height(&self.vars) as u16;
|
|
|
|
// Minus 1 because of header cells,
|
|
// the grid is shifted over (1,1), so if you need
|
|
// to index the grid, these are you values.
|
|
let mut x_idx: usize = 0;
|
|
let mut y_idx: usize = 0;
|
|
if x != 0 {
|
|
x_idx = x as usize - 1 + self.screen.scroll_x();
|
|
}
|
|
if y != 0 {
|
|
y_idx = y as usize - 1 + self.screen.scroll_y();
|
|
}
|
|
|
|
if is_selected(x.into(), y.into()) {
|
|
style = style.fg(Color::LightMagenta).bg(Color::Blue);
|
|
}
|
|
|
|
const ORANGE1: Color = Color::Rgb(200, 160, 0);
|
|
const ORANGE2: Color = Color::Rgb(180, 130, 0);
|
|
|
|
let mut should_render = true;
|
|
let mut suggest_upper_bound = None;
|
|
|
|
match (x == 0, y == 0) {
|
|
// 0,0 vi mode
|
|
(true, true) => {
|
|
display = self.mode.to_string();
|
|
style = self.mode.get_style();
|
|
}
|
|
// row names
|
|
(true, false) => {
|
|
display = y_idx.to_string();
|
|
|
|
let bg = if y_idx == self.grid.cursor().1 {
|
|
Color::DarkGray
|
|
} else if y_idx % 2 == 0 {
|
|
ORANGE1
|
|
} else {
|
|
ORANGE2
|
|
};
|
|
style = Style::new().fg(Color::White).bg(bg);
|
|
}
|
|
// column names
|
|
(false, true) => {
|
|
display = Grid::num_to_char(x_idx);
|
|
|
|
let bg = if x_idx == self.grid.cursor().0 {
|
|
Color::DarkGray
|
|
} else if x_idx % 2 == 0 {
|
|
ORANGE1
|
|
} else {
|
|
ORANGE2
|
|
};
|
|
|
|
style = Style::new().fg(Color::White).bg(bg)
|
|
}
|
|
// grid squares
|
|
(false, false) => {
|
|
match self.grid.get_cell_raw(x_idx, y_idx) {
|
|
Some(cell) => {
|
|
match cell {
|
|
CellType::Number(c) => display = c.to_string(),
|
|
CellType::String(s) => display = s.to_owned(),
|
|
CellType::Equation(e) => {
|
|
match self.grid.evaluate(e) {
|
|
Ok(val) => {
|
|
display = val.to_string();
|
|
style = Style::new()
|
|
.underline_color(Color::DarkGray)
|
|
.add_modifier(Modifier::UNDERLINED);
|
|
}
|
|
Err(err) => {
|
|
// the formula is broken
|
|
display = err.to_owned();
|
|
style = Style::new()
|
|
.fg(Color::Red)
|
|
.underline_color(Color::Red)
|
|
.add_modifier(Modifier::UNDERLINED)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
suggest_upper_bound = Some(display.len() as u16);
|
|
// check for cells to the right, see if we should truncate the cell width
|
|
for i in 1..(display.len() as f32 / cell_width as f32).ceil() as usize {
|
|
if let Some(_) = self.grid.get_cell_raw(x_idx + i, y_idx) {
|
|
suggest_upper_bound = Some(cell_width * i as u16);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
None => should_render = false,
|
|
}
|
|
if (x_idx, y_idx) == self.grid.cursor() {
|
|
should_render = true;
|
|
style = Style::new().fg(Color::Black).bg(Color::White);
|
|
// modify the style of the cell you are editing
|
|
if let Mode::Insert(_) = self.mode {
|
|
style = style.add_modifier(Modifier::ITALIC).add_modifier(Modifier::BOLD);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if should_render {
|
|
let x_off = area.x + (x * cell_width);
|
|
let y_off = area.y + (y * cell_height);
|
|
|
|
let area = if let Some(suggestion) = suggest_upper_bound {
|
|
let max_available_width = area.width - x_off;
|
|
// draw the biggest cell possible, without going OOB off the screen
|
|
let width = min(max_available_width, suggestion as u16);
|
|
// Don't draw too small tho, we want full-sized cells, minium
|
|
let width = max(cell_width, width);
|
|
|
|
Rect::new(x_off, y_off, width, cell_height)
|
|
} else {
|
|
Rect::new(x_off, y_off, cell_width, cell_height)
|
|
};
|
|
|
|
Paragraph::new(display).style(style).render(area, buf);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl App {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
exit: false,
|
|
grid: Grid::new(),
|
|
mode: Mode::Normal,
|
|
file: None,
|
|
error_msg: ErrorMessage::none(),
|
|
vars: HashMap::new(),
|
|
screen: ScreenSpace::new(),
|
|
marks: HashMap::new(),
|
|
clipboard: Clipboard::new(),
|
|
}
|
|
}
|
|
|
|
pub fn new_with_file(file: impl Into<PathBuf> + Clone) -> std::io::Result<Self> {
|
|
let mut app = Self::new();
|
|
app.file = Some(file.clone().into());
|
|
app.grid = Grid::new_from_file(file.into())?;
|
|
Ok(app)
|
|
}
|
|
|
|
pub fn run(&mut self, mut term: DefaultTerminal) -> Result<(), std::io::Error> {
|
|
while !self.exit {
|
|
term.draw(|frame| self.draw(frame))?;
|
|
self.handle_events()?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn draw(&self, frame: &mut Frame) {
|
|
let layout = Layout::default()
|
|
.direction(layout::Direction::Vertical)
|
|
.constraints([Constraint::Length(1), Constraint::Min(1)])
|
|
.split(frame.area());
|
|
|
|
let cmd_line = layout[0];
|
|
let body = layout[1];
|
|
|
|
let len = match &self.mode {
|
|
Mode::Insert(edit) | Mode::Command(edit) | Mode::Chord(edit) => edit.len(),
|
|
Mode::Normal => {
|
|
let (x, y) = self.grid.cursor();
|
|
let cell = self.grid.get_cell_raw(x, y).as_ref().map(|f| f.to_string().len()).unwrap_or_default();
|
|
cell
|
|
}
|
|
Mode::Visual(_) => 0,
|
|
};
|
|
// min 20 chars, expand if needed
|
|
let len = max(len as u16 + 1, 20);
|
|
|
|
let bottom_split = Layout::default()
|
|
.direction(layout::Direction::Horizontal)
|
|
.constraints([Constraint::Length(len), Constraint::Percentage(50), Constraint::Percentage(50)])
|
|
.split(cmd_line);
|
|
|
|
let cmd_line_left = bottom_split[0];
|
|
let cmd_line_right = bottom_split[1];
|
|
let cmd_line_debug = bottom_split[2];
|
|
|
|
match &self.mode {
|
|
Mode::Insert(editor) => {
|
|
frame.render_widget(editor, cmd_line_left);
|
|
}
|
|
Mode::Command(editor) => {
|
|
frame.render_widget(editor, cmd_line_left);
|
|
}
|
|
Mode::Chord(chord) => frame.render_widget(chord, cmd_line_left),
|
|
Mode::Normal => frame.render_widget(
|
|
Paragraph::new({
|
|
let (x, y) = self.grid.cursor();
|
|
let cell = self.grid.get_cell_raw(x, y).as_ref().map(|f| f.to_string()).unwrap_or_default();
|
|
cell
|
|
}),
|
|
cmd_line_left,
|
|
),
|
|
Mode::Visual(_) => {}
|
|
}
|
|
|
|
frame.render_widget(self, body);
|
|
frame.render_widget(&self.error_msg, cmd_line_right);
|
|
#[cfg(debug_assertions)]
|
|
frame.render_widget(
|
|
Paragraph::new(format!(
|
|
"x/w y/h: cursor{:?} scroll({}, {}) cell({}, {}) screen({}, {}) len{len}",
|
|
self.grid.cursor(),
|
|
self.screen.scroll_x(),
|
|
self.screen.scroll_y(),
|
|
self.screen.get_cell_width(&self.vars),
|
|
self.screen.get_cell_height(&self.vars),
|
|
body.width,
|
|
body.height,
|
|
)),
|
|
cmd_line_debug,
|
|
);
|
|
}
|
|
|
|
fn handle_events(&mut self) -> io::Result<()> {
|
|
match &mut self.mode {
|
|
Mode::Chord(chord) => match event::read()? {
|
|
event::Event::Key(key) => match key.code {
|
|
event::KeyCode::Esc => self.mode = Mode::Normal,
|
|
event::KeyCode::Char(c) => {
|
|
Mode::process_key(self, c);
|
|
}
|
|
event::KeyCode::Backspace => {
|
|
chord.backspace();
|
|
}
|
|
_ => {}
|
|
},
|
|
_ => {}
|
|
},
|
|
Mode::Insert(editor) => match event::read()? {
|
|
event::Event::Key(key) => match key.code {
|
|
event::KeyCode::Esc => {
|
|
// just cancel the operation
|
|
self.mode = Mode::Normal;
|
|
}
|
|
event::KeyCode::Enter => {
|
|
let v = editor.as_string();
|
|
|
|
// try to insert as a float
|
|
if let Ok(v) = v.parse::<f64>() {
|
|
self.grid.set_cell_raw(self.grid.cursor(), Some(v));
|
|
} else {
|
|
// if you can't, then insert as a string
|
|
if !v.is_empty() {
|
|
self.grid.set_cell_raw(self.grid.cursor(), Some(v));
|
|
} else {
|
|
self.grid.set_cell_raw::<CellType>(self.grid.cursor(), None);
|
|
}
|
|
}
|
|
|
|
self.mode = Mode::Normal;
|
|
}
|
|
event::KeyCode::Backspace => {
|
|
editor.backspace();
|
|
}
|
|
event::KeyCode::Char(c) => {
|
|
editor.add_char(c);
|
|
}
|
|
_ => {}
|
|
},
|
|
_ => {}
|
|
},
|
|
Mode::Normal => match event::read()? {
|
|
event::Event::Key(key_event) => match key_event.code {
|
|
event::KeyCode::F(_) => todo!(),
|
|
event::KeyCode::Char(c) => {
|
|
Mode::process_key(self, c);
|
|
}
|
|
_ => {}
|
|
},
|
|
_ => {}
|
|
},
|
|
Mode::Visual(_start_pos) => {
|
|
if let event::Event::Key(key) = event::read()? {
|
|
match key.code {
|
|
event::KeyCode::Char(c) => {
|
|
Mode::process_key(self, c);
|
|
}
|
|
event::KeyCode::Esc => self.mode = Mode::Normal,
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
Mode::Command(editor) => match event::read()? {
|
|
event::Event::Key(key) => match key.code {
|
|
event::KeyCode::Esc => {
|
|
// just cancel the operation
|
|
self.mode = Mode::Normal;
|
|
}
|
|
event::KeyCode::Enter => {
|
|
Mode::process_cmd(self);
|
|
self.mode = Mode::Normal;
|
|
}
|
|
event::KeyCode::Backspace => {
|
|
editor.backspace();
|
|
}
|
|
event::KeyCode::Char(c) => {
|
|
editor.add_char(c);
|
|
}
|
|
_ => {}
|
|
},
|
|
_ => {}
|
|
},
|
|
}
|
|
|
|
// make sure cursor is inside window
|
|
self.screen.scroll_based_on_cursor_location(self.grid.cursor(), &self.vars);
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_quit_cmd() {
|
|
let mut app = App::new();
|
|
assert!(!app.exit);
|
|
|
|
app.mode = Mode::Command(crate::app::mode::Chord::from(":q".to_string()));
|
|
Mode::process_cmd(&mut app);
|
|
|
|
assert!(app.exit);
|
|
}
|