sirtimbly/IronCalc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

UPDATE: Adds web app (#79)

Browse Source 
Things missing:

* Browse mode
* Front end tests
* Storybook
This commit is contained in:
Nicolás Hatcher Andrés
2024-08-18 11:44:16 +02:00
committed by GitHub
parent 083548608e
commit dc23a7f29c
89 changed files with 11245 additions and 364 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
base/src/constants.rs
View File

@@ -6,6 +6,8 @@ pub(crate) const DEFAULT_COLUMN_WIDTH: f64 = 100.0;
pub(crate) const DEFAULT_ROW_HEIGHT: f64 = 21.0;
pub(crate) const COLUMN_WIDTH_FACTOR: f64 = 12.0;
pub(crate) const ROW_HEIGHT_FACTOR: f64 = 2.0;
pub(crate) const DEFAULT_WINDOW_HEIGH: i64 = 600;
pub(crate) const DEFAULT_WINDOW_WIDTH: i64 = 800;
pub(crate) const LAST_COLUMN: i32 = 16_384;
pub(crate) const LAST_ROW: i32 = 1_048_576;

1
base/src/lib.rs
View File

@@ -57,4 +57,5 @@ pub mod mock_time;
pub use model::get_milliseconds_since_epoch;
pub use model::Model;
pub use user_model::BorderArea;
pub use user_model::UserModel;

10
base/src/new_empty.rs
View File

@@ -4,6 +4,7 @@ use std::collections::HashMap;
use crate::{
calc_result::Range,
constants::{DEFAULT_WINDOW_HEIGH, DEFAULT_WINDOW_WIDTH},
expressions::{
lexer::LexerMode,
parser::{
@@ -353,7 +354,14 @@ impl Model {
let now = dt.format("%Y-%m-%dT%H:%M:%SZ").to_string();
let mut views = HashMap::new();
views.insert(0, WorkbookView { sheet: 0 });
views.insert(
0,
WorkbookView {
sheet: 0,
window_width: DEFAULT_WINDOW_WIDTH,
window_height: DEFAULT_WINDOW_HEIGH,
},
);
// String versions of the locale are added here to simplify the serialize/deserialize logic
let workbook = Workbook {

6
base/src/test/user_model/mod.rs
View File

@@ -1,14 +1,20 @@
mod test_add_delete_sheets;
mod test_autofill_columns;
mod test_autofill_rows;
mod test_border;
mod test_clear_cells;
mod test_diff_queue;
mod test_evaluation;
mod test_general;
mod test_grid_lines;
mod test_keyboard_navigation;
mod test_on_area_selection;
mod test_on_expand_selected_range;
mod test_on_paste_styles;
mod test_rename_sheet;
mod test_row_column;
mod test_styles;
mod test_to_from_bytes;
mod test_undo_redo;
mod test_view;
mod test_window_size;

12
base/src/test/user_model/test_add_delete_sheets.rs
View File

@@ -82,3 +82,15 @@ fn delete_sheet_propagates() {
let sheets_info = model2.get_worksheets_properties();
assert_eq!(sheets_info.len(), 1);
}
#[test]
fn delete_last_sheet() {
// Deleting the last sheet, selects the previous
let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
model.new_sheet();
model.new_sheet();
model.set_selected_sheet(2).unwrap();
model.delete_sheet(2).unwrap();
assert_eq!(model.get_selected_sheet(), 1);
}

416
base/src/test/user_model/test_border.rs Normal file
View File

@@ -0,0 +1,416 @@
#![allow(clippy::unwrap_used)]
use crate::{
expressions::{types::Area, utils::number_to_column},
types::{Border, BorderItem, BorderStyle},
BorderArea, UserModel,
};
#[test]
fn borders_all() {
let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
// We set an outer border in cells F5:H9
let range = &Area {
sheet: 0,
row: 5,
column: 6,
width: 3,
height: 4,
};
assert_eq!(number_to_column(6).unwrap(), "F");
assert_eq!(number_to_column(8).unwrap(), "H");
// ATM we don't have a way to create the object from Rust, that's ok.
let border_area: BorderArea = serde_json::from_str(
r##"{
"item": {
"style": "thin",
"color": "#FF5566"
},
"type": "All"
}"##,
)
.unwrap();
model.set_area_with_border(range, &border_area).unwrap();
for row in 5..9 {
for column in 6..9 {
let style = model.get_cell_style(0, row, column).unwrap();
let border_item = BorderItem {
style: BorderStyle::Thin,
color: Some("#FF5566".to_string()),
};
let expected_border = Border {
diagonal_up: false,
diagonal_down: false,
left: Some(border_item.clone()),
right: Some(border_item.clone()),
top: Some(border_item.clone()),
bottom: Some(border_item.clone()),
diagonal: None,
};
assert_eq!(style.border, expected_border);
}
}
// Lets remove all of them:
let border_area: BorderArea = serde_json::from_str(
r##"{
"item": {
"style": "thin",
"color": "#FF5566"
},
"type": "None"
}"##,
)
.unwrap();
model.set_area_with_border(range, &border_area).unwrap();
for row in 5..9 {
for column in 6..9 {
let style = model.get_cell_style(0, row, column).unwrap();
let expected_border = Border {
diagonal_up: false,
diagonal_down: false,
left: None,
right: None,
top: None,
bottom: None,
diagonal: None,
};
assert_eq!(style.border, expected_border);
}
}
}
#[test]
fn borders_inner() {
let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
// We set an outer border in cells F5:H9
let range = &Area {
sheet: 0,
row: 5,
column: 6,
width: 3,
height: 4,
};
assert_eq!(number_to_column(6).unwrap(), "F");
assert_eq!(number_to_column(8).unwrap(), "H");
// ATM we don't have a way to create the object from Rust, that's ok.
let border_area: BorderArea = serde_json::from_str(
r##"{
"item": {
"style": "thin",
"color": "#FF5566"
},
"type": "Inner"
}"##,
)
.unwrap();
model.set_area_with_border(range, &border_area).unwrap();
// The inner part all have borders
for row in 6..8 {
for column in 7..8 {
let style = model.get_cell_style(0, row, column).unwrap();
let border_item = BorderItem {
style: BorderStyle::Thin,
color: Some("#FF5566".to_string()),
};
let expected_border = Border {
diagonal_up: false,
diagonal_down: false,
left: Some(border_item.clone()),
right: Some(border_item.clone()),
top: Some(border_item.clone()),
bottom: Some(border_item.clone()),
diagonal: None,
};
assert_eq!(style.border, expected_border);
}
}
// F5 has border only left and bottom
{
// We check the border on F5
let style = model.get_cell_style(0, 5, 6).unwrap();
let border_item = BorderItem {
style: BorderStyle::Thin,
color: Some("#FF5566".to_string()),
};
// It should be right and bottom
let expected_border = Border {
diagonal_up: false,
diagonal_down: false,
left: None,
right: Some(border_item.clone()),
top: None,
bottom: Some(border_item),
diagonal: None,
};
assert_eq!(style.border, expected_border);
}
{
// Then let's try the bottom-right border
let style = model.get_cell_style(0, 8, 8).unwrap();
let border_item = BorderItem {
style: BorderStyle::Thin,
color: Some("#FF5566".to_string()),
};
// It should be only left and top
let expected_border = Border {
diagonal_up: false,
diagonal_down: false,
left: Some(border_item.clone()),
right: None,
top: Some(border_item.clone()),
bottom: None,
diagonal: None,
};
assert_eq!(style.border, expected_border);
}
}
#[test]
fn borders_outer() {
let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
// We set an outer border in cells F5:H9
let range = &Area {
sheet: 0,
row: 5,
column: 6,
width: 3,
height: 4,
};
assert_eq!(number_to_column(6).unwrap(), "F");
assert_eq!(number_to_column(8).unwrap(), "H");
// ATM we don't have a way to create the object from Rust, that's ok.
let border_area: BorderArea = serde_json::from_str(
r##"{
"item": {
"style": "thin",
"color": "#FF5566"
},
"type": "Outer"
}"##,
)
.unwrap();
model.set_area_with_border(range, &border_area).unwrap();
{
// We check the border on F5
let style = model.get_cell_style(0, 5, 6).unwrap();
let border_item = BorderItem {
style: BorderStyle::Thin,
color: Some("#FF5566".to_string()),
};
// It should be only left and top
let expected_border = Border {
diagonal_up: false,
diagonal_down: false,
left: Some(border_item.clone()),
right: None,
top: Some(border_item),
bottom: None,
diagonal: None,
};
assert_eq!(style.border, expected_border);
}
{
// Then let's try the bottom-right border
let style = model.get_cell_style(0, 8, 8).unwrap();
let border_item = BorderItem {
style: BorderStyle::Thin,
color: Some("#FF5566".to_string()),
};
// It should be only left and top
let expected_border = Border {
diagonal_up: false,
diagonal_down: false,
left: None,
right: Some(border_item.clone()),
top: None,
bottom: Some(border_item.clone()),
diagonal: None,
};
assert_eq!(style.border, expected_border);
}
}
#[test]
fn borders_top() {
let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
// We set an outer border in cells F5:H9
let range = &Area {
sheet: 0,
row: 5,
column: 6,
width: 3,
height: 4,
};
assert_eq!(number_to_column(6).unwrap(), "F");
assert_eq!(number_to_column(8).unwrap(), "H");
// ATM we don't have a way to create the object from Rust, that's ok.
let border_area: BorderArea = serde_json::from_str(
r##"{
"item": {
"style": "thin",
"color": "#FF5566"
},
"type": "Top"
}"##,
)
.unwrap();
model.set_area_with_border(range, &border_area).unwrap();
for row in 5..9 {
for column in 6..9 {
let style = model.get_cell_style(0, row, column).unwrap();
let border_item = BorderItem {
style: BorderStyle::Thin,
color: Some("#FF5566".to_string()),
};
let expected_border = Border {
diagonal_up: false,
diagonal_down: false,
left: None,
right: None,
top: Some(border_item.clone()),
bottom: None,
diagonal: None,
};
assert_eq!(style.border, expected_border);
}
}
}
#[test]
fn borders_right() {
let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
// We set an outer border in cells F5:H9
let range = &Area {
sheet: 0,
row: 5,
column: 6,
width: 3,
height: 4,
};
assert_eq!(number_to_column(6).unwrap(), "F");
assert_eq!(number_to_column(8).unwrap(), "H");
// ATM we don't have a way to create the object from Rust, that's ok.
let border_area: BorderArea = serde_json::from_str(
r##"{
"item": {
"style": "thin",
"color": "#FF5566"
},
"type": "Right"
}"##,
)
.unwrap();
model.set_area_with_border(range, &border_area).unwrap();
for row in 5..9 {
for column in 6..9 {
let style = model.get_cell_style(0, row, column).unwrap();
let border_item = BorderItem {
style: BorderStyle::Thin,
color: Some("#FF5566".to_string()),
};
let expected_border = Border {
diagonal_up: false,
diagonal_down: false,
left: None,
right: Some(border_item.clone()),
top: None,
bottom: None,
diagonal: None,
};
assert_eq!(style.border, expected_border);
}
}
}
#[test]
fn borders_bottom() {
let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
// We set an outer border in cells F5:H9
let range = &Area {
sheet: 0,
row: 5,
column: 6,
width: 3,
height: 4,
};
assert_eq!(number_to_column(6).unwrap(), "F");
assert_eq!(number_to_column(8).unwrap(), "H");
// ATM we don't have a way to create the object from Rust, that's ok.
let border_area: BorderArea = serde_json::from_str(
r##"{
"item": {
"style": "thin",
"color": "#FF5566"
},
"type": "Bottom"
}"##,
)
.unwrap();
model.set_area_with_border(range, &border_area).unwrap();
for row in 5..9 {
for column in 6..9 {
let style = model.get_cell_style(0, row, column).unwrap();
let border_item = BorderItem {
style: BorderStyle::Thin,
color: Some("#FF5566".to_string()),
};
let expected_border = Border {
diagonal_up: false,
diagonal_down: false,
left: None,
right: None,
top: None,
bottom: Some(border_item.clone()),
diagonal: None,
};
assert_eq!(style.border, expected_border);
}
}
}
#[test]
fn borders_left() {
let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
// We set an outer border in cells F5:H9
let range = &Area {
sheet: 0,
row: 5,
column: 6,
width: 3,
height: 4,
};
assert_eq!(number_to_column(6).unwrap(), "F");
assert_eq!(number_to_column(8).unwrap(), "H");
// ATM we don't have a way to create the object from Rust, that's ok.
let border_area: BorderArea = serde_json::from_str(
r##"{
"item": {
"style": "thin",
"color": "#FF5566"
},
"type": "Left"
}"##,
)
.unwrap();
model.set_area_with_border(range, &border_area).unwrap();
for row in 5..9 {
for column in 6..9 {
let style = model.get_cell_style(0, row, column).unwrap();
let border_item = BorderItem {
style: BorderStyle::Thin,
color: Some("#FF5566".to_string()),
};
let expected_border = Border {
diagonal_up: false,
diagonal_down: false,
left: Some(border_item.clone()),
right: None,
top: None,
bottom: None,
diagonal: None,
};
assert_eq!(style.border, expected_border);
}
}
}

136
base/src/test/user_model/test_keyboard_navigation.rs Normal file
View File

@@ -0,0 +1,136 @@
#![allow(clippy::unwrap_used)]
use crate::{
constants::{
DEFAULT_COLUMN_WIDTH, DEFAULT_ROW_HEIGHT, DEFAULT_WINDOW_HEIGH, DEFAULT_WINDOW_WIDTH,
LAST_COLUMN,
},
test::util::new_empty_model,
UserModel,
};
#[test]
fn basic_navigation() {
let model = new_empty_model();
let mut model = UserModel::from_model(model);
model.on_arrow_right().unwrap();
let view = model.get_selected_view();
assert_eq!(view.range, [1, 2, 1, 2]);
assert_eq!(view.column, 2);
assert_eq!(view.row, 1);
model.on_arrow_left().unwrap();
let view = model.get_selected_view();
assert_eq!(view.range, [1, 1, 1, 1]);
assert_eq!(view.column, 1);
assert_eq!(view.row, 1);
model.on_arrow_left().unwrap();
let view = model.get_selected_view();
assert_eq!(view.range, [1, 1, 1, 1]);
assert_eq!(view.column, 1);
assert_eq!(view.row, 1);
model.on_arrow_down().unwrap();
let view = model.get_selected_view();
assert_eq!(view.range, [2, 1, 2, 1]);
assert_eq!(view.column, 1);
assert_eq!(view.row, 2);
model.on_arrow_up().unwrap();
let view = model.get_selected_view();
assert_eq!(view.range, [1, 1, 1, 1]);
assert_eq!(view.column, 1);
assert_eq!(view.row, 1);
model.on_arrow_up().unwrap();
let view = model.get_selected_view();
assert_eq!(view.range, [1, 1, 1, 1]);
assert_eq!(view.column, 1);
assert_eq!(view.row, 1);
}
#[test]
fn scroll_right() {
let window_width = DEFAULT_WINDOW_WIDTH as f64;
let column_width = DEFAULT_COLUMN_WIDTH;
let column_count = f64::floor(window_width / column_width) as i32;
let model = new_empty_model();
let mut model = UserModel::from_model(model);
model.on_arrow_right().unwrap();
model.set_selected_cell(3, column_count).unwrap();
model.on_arrow_right().unwrap();
let view = model.get_selected_view();
assert_eq!(view.left_column, 2);
model.on_arrow_right().unwrap();
let view = model.get_selected_view();
assert_eq!(view.left_column, 3);
}
#[test]
fn last_colum() {
let model = new_empty_model();
let mut model = UserModel::from_model(model);
model.set_selected_cell(3, LAST_COLUMN).unwrap();
let view = model.get_selected_view();
assert_eq!(view.column, LAST_COLUMN);
model.on_arrow_right().unwrap();
let view = model.get_selected_view();
assert_eq!(view.column, LAST_COLUMN);
}
#[test]
fn page_down() {
let model = new_empty_model();
let mut model = UserModel::from_model(model);
let window_height = DEFAULT_WINDOW_HEIGH as f64;
let row_height = DEFAULT_ROW_HEIGHT;
let row_count = f64::floor(window_height / row_height) as i32;
model.on_page_down().unwrap();
let view = model.get_selected_view();
assert_eq!(view.row, 1 + row_count);
let scroll_y = model.get_scroll_y().unwrap();
assert_eq!(scroll_y, (row_count as f64) * DEFAULT_ROW_HEIGHT);
}
// we just test that page up and page down are inverse operations
#[test]
fn page_up() {
let model = new_empty_model();
let mut model = UserModel::from_model(model);
model.on_page_down().unwrap();
let row1 = model.get_selected_view().row;
model.on_page_down().unwrap();
let row2 = model.get_selected_view().row;
model.on_page_down().unwrap();
let row3 = model.get_selected_view().row;
model.on_page_down().unwrap();
model.on_page_up().unwrap();
assert_eq!(model.get_selected_view().row, row3);
model.on_page_up().unwrap();
assert_eq!(model.get_selected_view().row, row2);
model.on_page_up().unwrap();
assert_eq!(model.get_selected_view().row, row1);
model.on_page_up().unwrap();
assert_eq!(model.get_selected_view().row, 1);
}
#[test]
fn page_up_fails_on_row1() {
let model = new_empty_model();
let mut model = UserModel::from_model(model);
model.on_arrow_up().unwrap();
assert_eq!(model.get_selected_view().row, 1);
}

33
base/src/test/user_model/test_on_area_selection.rs Normal file
View File

@@ -0,0 +1,33 @@
#![allow(clippy::unwrap_used)]
use crate::{
constants::{DEFAULT_COLUMN_WIDTH, DEFAULT_WINDOW_WIDTH},
test::util::new_empty_model,
UserModel,
};
#[test]
fn basic_test() {
let model = new_empty_model();
let mut model = UserModel::from_model(model);
model.on_area_selecting(2, 4).unwrap();
let view = model.get_selected_view();
assert_eq!(view.range, [1, 1, 2, 4]);
}
// this checks that is we select in the boundary we automatically scroll
#[test]
fn scroll_right() {
let model = new_empty_model();
let mut model = UserModel::from_model(model);
let window_width = DEFAULT_WINDOW_WIDTH as f64;
let column_width = DEFAULT_COLUMN_WIDTH;
let column_count = f64::floor(window_width / column_width) as i32;
model.set_selected_cell(3, column_count).unwrap();
model.on_area_selecting(3, column_count + 3).unwrap();
let view = model.get_selected_view();
assert_eq!(view.range, [3, column_count, 3, column_count + 3]);
assert_eq!(view.left_column, 4);
}

151
base/src/test/user_model/test_on_expand_selected_range.rs Normal file
View File

@@ -0,0 +1,151 @@
#![allow(clippy::unwrap_used)]
use crate::{
constants::{DEFAULT_COLUMN_WIDTH, DEFAULT_WINDOW_WIDTH, LAST_COLUMN},
test::util::new_empty_model,
UserModel,
};
#[test]
fn arrow_right() {
let model = new_empty_model();
let mut model = UserModel::from_model(model);
model.on_expand_selected_range("ArrowRight").unwrap();
let view = model.get_selected_view();
assert_eq!(view.range, [1, 1, 1, 2]);
}
#[test]
fn arrow_right_decreases() {
// if the selected cell is on the upper right corner, right-arrow will decrease the size of teh area
let model = new_empty_model();
let mut model = UserModel::from_model(model);
let (start_row, start_column, end_row, end_column) = (5, 3, 10, 8);
model.set_selected_cell(start_row, end_column).unwrap();
model
.set_selected_range(start_row, start_column, end_row, end_column)
.unwrap();
model.on_expand_selected_range("ArrowRight").unwrap();
let view = model.get_selected_view();
assert_eq!(
view.range,
[start_row, start_column + 1, end_row, end_column]
);
}
#[test]
fn arrow_right_last_column() {
let model = new_empty_model();
let mut model = UserModel::from_model(model);
model.set_selected_cell(1, LAST_COLUMN).unwrap();
let view = model.get_selected_view();
assert_eq!(view.range, [1, LAST_COLUMN, 1, LAST_COLUMN]);
}
#[test]
fn arrow_right_scroll_right() {
let window_width = DEFAULT_WINDOW_WIDTH as f64;
let column_width = DEFAULT_COLUMN_WIDTH;
let column_count = f64::floor(window_width / column_width) as i32;
let model = new_empty_model();
let mut model = UserModel::from_model(model);
// initially the column to the left is A
let view = model.get_selected_view();
assert_eq!(view.left_column, 1);
// We select all columns from 1 to the last visible
let (start_row, start_column, end_row, end_column) = (1, 1, 1, column_count);
model.set_selected_cell(start_row, start_column).unwrap();
model
.set_selected_range(start_row, start_column, end_row, end_column)
.unwrap();
// Now we select one more column
model.on_expand_selected_range("ArrowRight").unwrap();
// The view has updated and the first visible column is B
let view = model.get_selected_view();
assert_eq!(
view.range,
[start_row, start_column, end_row, end_column + 1]
);
assert_eq!(view.left_column, 2);
// now we click on cell B2 and we
model.set_selected_cell(2, 2).unwrap();
model.on_expand_selected_range("ArrowLeft").unwrap();
let view = model.get_selected_view();
assert_eq!(view.range, [2, 1, 2, 2]);
assert_eq!(view.left_column, 1);
// a second arrow left won't do anything
model.on_expand_selected_range("ArrowLeft").unwrap();
let view = model.get_selected_view();
assert_eq!(view.range, [2, 1, 2, 2]);
assert_eq!(view.left_column, 1);
}
#[test]
fn arrow_left() {
let model = new_empty_model();
let mut model = UserModel::from_model(model);
model.set_selected_cell(5, 3).unwrap();
model.set_selected_range(5, 3, 10, 8).unwrap();
model.on_expand_selected_range("ArrowLeft").unwrap();
let view = model.get_selected_view();
assert_eq!(view.range, [5, 3, 10, 7]);
}
#[test]
fn arrow_left_left_border() {
let model = new_empty_model();
let mut model = UserModel::from_model(model);
model.on_expand_selected_range("ArrowLeft").unwrap();
let view = model.get_selected_view();
assert_eq!(view.range, [1, 1, 1, 1]);
}
#[test]
fn arrow_left_increases() {
// If the selected cell is on the top right corner
// arrow left increases the selected area by
let model = new_empty_model();
let mut model = UserModel::from_model(model);
let (start_row, start_column, end_row, end_column) = (4, 10, 4, 20);
model.set_selected_cell(start_row, end_column).unwrap();
model
.set_selected_range(start_row, start_column, end_row, end_column)
.unwrap();
model.on_expand_selected_range("ArrowLeft").unwrap();
let view = model.get_selected_view();
assert_eq!(
view.range,
[start_row, start_column - 1, end_row, end_column]
);
}
#[test]
fn arrow_left_scrolls_left() {
// If the selected cell is on the top right corner
// arrow left increases the selected area by
let model = new_empty_model();
let mut model = UserModel::from_model(model);
model.set_top_left_visible_cell(1, 50).unwrap();
model.set_selected_cell(1, 50).unwrap();
// arrow left x 2
model.on_expand_selected_range("ArrowLeft").unwrap();
model.on_expand_selected_range("ArrowLeft").unwrap();
let view = model.get_selected_view();
assert_eq!(view.range, [1, 48, 1, 50]);
assert_eq!(view.left_column, 48);
assert_eq!(view.column, 50);
}

48
base/src/test/user_model/test_on_paste_styles.rs Normal file
View File

@@ -0,0 +1,48 @@
#![allow(clippy::unwrap_used)]
use crate::test::util::new_empty_model;
use crate::types::Fill;
use crate::UserModel;
#[test]
fn simple_pasting() {
let model = new_empty_model();
let mut model = UserModel::from_model(model);
let mut style = model.get_cell_style(0, 1, 1).unwrap();
style.fill = Fill {
pattern_type: "solid".to_string(),
fg_color: Some("#FF5577".to_string()),
bg_color: Some("#33FF44".to_string()),
};
let styles = vec![vec![style.clone()]];
model.set_selected_cell(5, 4).unwrap();
model.set_selected_range(5, 4, 10, 9).unwrap();
model.on_paste_styles(&styles).unwrap();
for row in 5..10 {
for column in 4..9 {
let cell_style = model.get_cell_style(0, row, column).unwrap();
assert_eq!(cell_style, style);
}
}
model.undo().unwrap();
let base_style = model.get_cell_style(0, 100, 100).unwrap();
for row in 5..10 {
for column in 4..9 {
let cell_style = model.get_cell_style(0, row, column).unwrap();
assert_eq!(cell_style, base_style);
}
}
model.redo().unwrap();
for row in 5..10 {
for column in 4..9 {
let cell_style = model.get_cell_style(0, row, column).unwrap();
assert_eq!(cell_style, style);
}
}
}

17
base/src/test/user_model/test_view.rs
View File

@@ -52,19 +52,12 @@ fn set_the_cell_sets_the_range() {
fn set_the_range_does_not_set_the_cell() {
let model = new_empty_model();
let mut model = UserModel::from_model(model);
model.set_selected_range(5, 4, 10, 6).unwrap();
assert_eq!(model.get_selected_sheet(), 0);
assert_eq!(model.get_selected_cell(), (0, 1, 1));
assert_eq!(
model.get_selected_view(),
SelectedView {
sheet: 0,
row: 1,
column: 1,
range: [5, 4, 10, 6],
top_row: 1,
left_column: 1
}
model.set_selected_range(5, 4, 10, 6),
Err(
"The selected cells is not in one of the corners. Row: '1' and row range '(5, 10)'"
.to_string()
)
);
}

29
base/src/test/user_model/test_window_size.rs Normal file
View File

@@ -0,0 +1,29 @@
#![allow(clippy::unwrap_used)]
use crate::{
constants::{DEFAULT_ROW_HEIGHT, DEFAULT_WINDOW_HEIGH, DEFAULT_WINDOW_WIDTH},
test::util::new_empty_model,
UserModel,
};
#[test]
fn basic_test() {
let model = new_empty_model();
let mut model = UserModel::from_model(model);
let window_height = model.get_window_height().unwrap();
assert_eq!(window_height, DEFAULT_WINDOW_HEIGH);
let window_width = model.get_window_width().unwrap();
assert_eq!(window_width, DEFAULT_WINDOW_WIDTH);
// Set the window height to double the default and check that page_down behaves as expected
model.set_window_height((window_height * 2) as f64);
model.on_page_down().unwrap();
let row_height = DEFAULT_ROW_HEIGHT;
let row_count = f64::floor((window_height * 2) as f64 / row_height) as i32;
let view = model.get_selected_view();
assert_eq!(view.row, 1 + row_count);
let scroll_y = model.get_scroll_y().unwrap();
assert_eq!(scroll_y, (row_count as f64) * DEFAULT_ROW_HEIGHT);
}

4
base/src/types.rs
View File

@@ -33,6 +33,10 @@ pub struct WorkbookSettings {
pub struct WorkbookView {
/// The index of the currently selected sheet.
pub sheet: u32,
/// The current width of the window
pub window_width: i64,
/// The current heigh of the window
pub window_height: i64,
}
/// An internal representation of an IronCalc Workbook

511
base/src/user_model.rs → base/src/user_model/common.rs
View File

@@ -2,7 +2,6 @@
use std::{collections::HashMap, fmt::Debug};
use bitcode::{Decode, Encode};
use serde::{Deserialize, Serialize};
use crate::{
@@ -13,180 +12,35 @@ use crate::{
},
model::Model,
types::{
Alignment, BorderItem, BorderStyle, Cell, CellType, Col, HorizontalAlignment, Row,
SheetProperties, Style, VerticalAlignment,
Alignment, BorderItem, BorderStyle, CellType, Col, HorizontalAlignment, SheetProperties,
Style, VerticalAlignment,
},
utils::is_valid_hex_color,
};
use crate::user_model::history::{
ColumnData, Diff, DiffList, DiffType, History, QueueDiffs, RowData,
};
#[derive(Serialize, Deserialize)]
#[cfg_attr(test, derive(PartialEq, Debug))]
pub struct SelectedView {
pub sheet: u32,
pub row: i32,
pub column: i32,
pub range: [i32; 4],
pub top_row: i32,
pub left_column: i32,
pub enum BorderType {
All,
Inner,
Outer,
Top,
Right,
Bottom,
Left,
CenterH,
CenterV,
None,
}
#[derive(Clone, Encode, Decode)]
struct RowData {
row: Option<Row>,
data: HashMap<i32, Cell>,
}
#[derive(Clone, Encode, Decode)]
struct ColumnData {
column: Option<Col>,
data: HashMap<i32, Cell>,
}
#[derive(Clone, Encode, Decode)]
enum Diff {
// Cell diffs
SetCellValue {
sheet: u32,
row: i32,
column: i32,
new_value: String,
old_value: Box<Option<Cell>>,
},
CellClearContents {
sheet: u32,
row: i32,
column: i32,
old_value: Box<Option<Cell>>,
},
CellClearAll {
sheet: u32,
row: i32,
column: i32,
old_value: Box<Option<Cell>>,
old_style: Box<Style>,
},
SetCellStyle {
sheet: u32,
row: i32,
column: i32,
old_value: Box<Style>,
new_value: Box<Style>,
},
// Column and Row diffs
SetColumnWidth {
sheet: u32,
column: i32,
new_value: f64,
old_value: f64,
},
SetRowHeight {
sheet: u32,
row: i32,
new_value: f64,
old_value: f64,
},
InsertRow {
sheet: u32,
row: i32,
},
DeleteRow {
sheet: u32,
row: i32,
old_data: Box<RowData>,
},
InsertColumn {
sheet: u32,
column: i32,
},
DeleteColumn {
sheet: u32,
column: i32,
old_data: Box<ColumnData>,
},
SetFrozenRowsCount {
sheet: u32,
new_value: i32,
old_value: i32,
},
SetFrozenColumnsCount {
sheet: u32,
new_value: i32,
old_value: i32,
},
DeleteSheet {
sheet: u32,
},
NewSheet {
index: u32,
name: String,
},
RenameSheet {
index: u32,
old_value: String,
new_value: String,
},
SetSheetColor {
index: u32,
old_value: String,
new_value: String,
},
SetShowGridLines {
sheet: u32,
old_value: bool,
new_value: bool,
}, // FIXME: we are missing SetViewDiffs
}
type DiffList = Vec<Diff>;
#[derive(Default)]
struct History {
undo_stack: Vec<DiffList>,
redo_stack: Vec<DiffList>,
}
impl History {
fn push(&mut self, diff_list: DiffList) {
self.undo_stack.push(diff_list);
self.redo_stack = vec![];
}
fn undo(&mut self) -> Option<Vec<Diff>> {
match self.undo_stack.pop() {
Some(diff_list) => {
self.redo_stack.push(diff_list.clone());
Some(diff_list)
}
None => None,
}
}
fn redo(&mut self) -> Option<Vec<Diff>> {
match self.redo_stack.pop() {
Some(diff_list) => {
self.undo_stack.push(diff_list.clone());
Some(diff_list)
}
None => None,
}
}
fn clear(&mut self) {
self.redo_stack = vec![];
self.undo_stack = vec![];
}
}
#[derive(Clone, Encode, Decode)]
enum DiffType {
Undo,
Redo,
}
#[derive(Clone, Encode, Decode)]
struct QueueDiffs {
r#type: DiffType,
list: DiffList,
/// This is the struct for a border area
#[derive(Serialize, Deserialize)]
pub struct BorderArea {
item: BorderItem,
r#type: BorderType,
}
fn boolean(value: &str) -> Result<bool, String> {
@@ -292,7 +146,7 @@ fn vertical(value: &str) -> Result<VerticalAlignment, String> {
/// # }
/// ```
pub struct UserModel {
model: Model,
pub(crate) model: Model,
history: History,
send_queue: Vec<QueueDiffs>,
pause_evaluation: bool,
@@ -540,6 +394,14 @@ impl UserModel {
self.push_diff_list(vec![Diff::DeleteSheet { sheet }]);
// There is no coming back
self.history.clear();
let sheet_count = self.model.workbook.worksheets.len() as u32;
// If we are deleting the last sheet we need to change the selected sheet
if sheet == sheet_count - 1 && sheet_count > 1 {
if let Some(view) = self.model.workbook.views.get_mut(&self.model.view_id) {
view.sheet = sheet_count - 2;
};
}
self.model.delete_sheet(sheet)?;
Ok(())
}
@@ -828,6 +690,155 @@ impl UserModel {
self.model.set_frozen_columns(sheet, frozen_columns)
}
/// Paste `styles` in the selected area
pub fn on_paste_styles(&mut self, styles: &[Vec<Style>]) -> Result<(), String> {
let styles_heigh = styles.len() as i32;
let styles_width = styles[0].len() as i32;
let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
view.sheet
} else {
return Ok(());
};
let range = if let Ok(worksheet) = self.model.workbook.worksheet(sheet) {
if let Some(view) = worksheet.views.get(&self.model.view_id) {
view.range
} else {
return Ok(());
}
} else {
return Ok(());
};
// If the pasted area is smaller than the selected area we increase it
let [row_start, column_start, row_end, column_end] = range;
let last_row = row_end.max(row_start + styles_heigh - 1);
let last_column = column_end.max(column_start + styles_width - 1);
let mut diff_list = Vec::new();
for row in row_start..=last_row {
for column in column_start..=last_column {
let row_index = ((row - row_start) % styles_heigh) as usize;
let column_index = ((column - column_start) % styles_width) as usize;
let style = &styles[row_index][column_index];
let old_value = self.model.get_style_for_cell(sheet, row, column);
self.model.set_cell_style(sheet, row, column, style)?;
diff_list.push(Diff::SetCellStyle {
sheet,
row,
column,
old_value: Box::new(old_value),
new_value: Box::new(style.clone()),
});
}
}
self.push_diff_list(diff_list);
// select the pasted range
if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
if let Some(view) = worksheet.views.get_mut(&self.model.view_id) {
view.range = [row_start, column_start, last_row, last_column];
}
}
Ok(())
}
/// Sets the border
pub fn set_area_with_border(
&mut self,
range: &Area,
border_area: &BorderArea,
) -> Result<(), String> {
// FIXME: We need to set the border also in neighbouring cells.
let sheet = range.sheet;
let mut diff_list = Vec::new();
let last_row = range.row + range.height - 1;
let last_column = range.column + range.width - 1;
for row in range.row..=last_row {
for column in range.column..=last_column {
let old_value = self.model.get_style_for_cell(sheet, row, column);
let mut style = old_value.clone();
// First remove all existing borders
style.border.top = None;
style.border.right = None;
style.border.bottom = None;
style.border.left = None;
match border_area.r#type {
BorderType::All => {
style.border.top = Some(border_area.item.clone());
style.border.right = Some(border_area.item.clone());
style.border.bottom = Some(border_area.item.clone());
style.border.left = Some(border_area.item.clone());
}
BorderType::Inner => {
if row != range.row {
style.border.top = Some(border_area.item.clone());
}
if row != last_row {
style.border.bottom = Some(border_area.item.clone());
}
if column != range.column {
style.border.left = Some(border_area.item.clone());
}
if column != last_column {
style.border.right = Some(border_area.item.clone());
}
}
BorderType::Outer => {
if row == range.row {
style.border.top = Some(border_area.item.clone());
}
if row == last_row {
style.border.bottom = Some(border_area.item.clone());
}
if column == range.column {
style.border.left = Some(border_area.item.clone());
}
if column == last_column {
style.border.right = Some(border_area.item.clone());
}
}
BorderType::Top => style.border.top = Some(border_area.item.clone()),
BorderType::Right => style.border.right = Some(border_area.item.clone()),
BorderType::Bottom => style.border.bottom = Some(border_area.item.clone()),
BorderType::Left => style.border.left = Some(border_area.item.clone()),
BorderType::CenterH => {
if row != range.row {
style.border.top = Some(border_area.item.clone());
}
if row != last_row {
style.border.bottom = Some(border_area.item.clone());
}
}
BorderType::CenterV => {
if column != range.column {
style.border.left = Some(border_area.item.clone());
}
if column != last_column {
style.border.right = Some(border_area.item.clone());
}
}
BorderType::None => {
// noop, we already removed all the borders
}
}
self.model.set_cell_style(sheet, row, column, &style)?;
diff_list.push(Diff::SetCellStyle {
sheet,
row,
column,
old_value: Box::new(old_value),
new_value: Box::new(style),
});
}
}
self.push_diff_list(diff_list);
Ok(())
}
/// Updates the range with a cell style.
/// See also:
/// * [Model::set_cell_style]
@@ -1154,166 +1165,6 @@ impl UserModel {
self.model.get_worksheets_properties()
}
/// Returns the selected sheet index
pub fn get_selected_sheet(&self) -> u32 {
if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
view.sheet
} else {
0
}
}
/// Returns the selected cell
pub fn get_selected_cell(&self) -> (u32, i32, i32) {
let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
view.sheet
} else {
0
};
if let Ok(worksheet) = self.model.workbook.worksheet(sheet) {
if let Some(view) = worksheet.views.get(&self.model.view_id) {
return (sheet, view.row, view.column);
}
}
// return a safe default
(0, 1, 1)
}
/// Returns selected view
pub fn get_selected_view(&self) -> SelectedView {
let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
view.sheet
} else {
0
};
if let Ok(worksheet) = self.model.workbook.worksheet(sheet) {
if let Some(view) = worksheet.views.get(&self.model.view_id) {
return SelectedView {
sheet,
row: view.row,
column: view.column,
range: view.range,
top_row: view.top_row,
left_column: view.left_column,
};
}
}
// return a safe default
SelectedView {
sheet: 0,
row: 1,
column: 1,
range: [1, 1, 1, 1],
top_row: 1,
left_column: 1,
}
}
/// Sets the the selected sheet
pub fn set_selected_sheet(&mut self, sheet: u32) -> Result<(), String> {
if self.model.workbook.worksheet(sheet).is_err() {
return Err(format!("Invalid worksheet index {}", sheet));
}
if let Some(view) = self.model.workbook.views.get_mut(&0) {
view.sheet = sheet;
}
Ok(())
}
/// Sets the selected cell
pub fn set_selected_cell(&mut self, row: i32, column: i32) -> Result<(), String> {
let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
view.sheet
} else {
0
};
if !is_valid_column_number(column) {
return Err(format!("Invalid column: '{column}'"));
}
if !is_valid_row(row) {
return Err(format!("Invalid row: '{row}'"));
}
if self.model.workbook.worksheet(sheet).is_err() {
return Err(format!("Invalid worksheet index {}", sheet));
}
if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
if let Some(view) = worksheet.views.get_mut(&0) {
view.row = row;
view.column = column;
view.range = [row, column, row, column];
}
}
Ok(())
}
/// Sets the selected range
pub fn set_selected_range(
&mut self,
start_row: i32,
start_column: i32,
end_row: i32,
end_column: i32,
) -> Result<(), String> {
let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
view.sheet
} else {
0
};
if !is_valid_column_number(start_column) {
return Err(format!("Invalid column: '{start_column}'"));
}
if !is_valid_column_number(start_row) {
return Err(format!("Invalid row: '{start_row}'"));
}
if !is_valid_column_number(end_column) {
return Err(format!("Invalid column: '{end_column}'"));
}
if !is_valid_column_number(end_row) {
return Err(format!("Invalid row: '{end_row}'"));
}
if self.model.workbook.worksheet(sheet).is_err() {
return Err(format!("Invalid worksheet index {}", sheet));
}
if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
if let Some(view) = worksheet.views.get_mut(&0) {
view.range = [start_row, start_column, end_row, end_column];
}
}
Ok(())
}
/// Sets the value of the first visible cell
pub fn set_top_left_visible_cell(
&mut self,
top_row: i32,
left_column: i32,
) -> Result<(), String> {
let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
view.sheet
} else {
0
};
if !is_valid_column_number(left_column) {
return Err(format!("Invalid column: '{left_column}'"));
}
if !is_valid_column_number(top_row) {
return Err(format!("Invalid row: '{top_row}'"));
}
if self.model.workbook.worksheet(sheet).is_err() {
return Err(format!("Invalid worksheet index {}", sheet));
}
if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
if let Some(view) = worksheet.views.get_mut(&0) {
view.top_row = top_row;
view.left_column = left_column;
}
}
Ok(())
}
/// Set the gid lines in the worksheet to visible (`true`) or hidden (`false`)
pub fn set_show_grid_lines(&mut self, sheet: u32, show_grid_lines: bool) -> Result<(), String> {
let old_value = self.model.workbook.worksheet(sheet)?.show_grid_lines;
@@ -1643,7 +1494,7 @@ impl UserModel {
mod tests {
use crate::{
types::{HorizontalAlignment, VerticalAlignment},
user_model::{horizontal, vertical},
user_model::common::{horizontal, vertical},
};
#[test]

164
base/src/user_model/history.rs Normal file
View File

@@ -0,0 +1,164 @@
use std::collections::HashMap;
use bitcode::{Decode, Encode};
use crate::types::{Cell, Col, Row, Style};
#[derive(Clone, Encode, Decode)]
pub(crate) struct RowData {
pub(crate) row: Option<Row>,
pub(crate) data: HashMap<i32, Cell>,
}
#[derive(Clone, Encode, Decode)]
pub(crate) struct ColumnData {
pub(crate) column: Option<Col>,
pub(crate) data: HashMap<i32, Cell>,
}
#[derive(Clone, Encode, Decode)]
pub(crate) enum Diff {
// Cell diffs
SetCellValue {
sheet: u32,
row: i32,
column: i32,
new_value: String,
old_value: Box<Option<Cell>>,
},
CellClearContents {
sheet: u32,
row: i32,
column: i32,
old_value: Box<Option<Cell>>,
},
CellClearAll {
sheet: u32,
row: i32,
column: i32,
old_value: Box<Option<Cell>>,
old_style: Box<Style>,
},
SetCellStyle {
sheet: u32,
row: i32,
column: i32,
old_value: Box<Style>,
new_value: Box<Style>,
},
// Column and Row diffs
SetColumnWidth {
sheet: u32,
column: i32,
new_value: f64,
old_value: f64,
},
SetRowHeight {
sheet: u32,
row: i32,
new_value: f64,
old_value: f64,
},
InsertRow {
sheet: u32,
row: i32,
},
DeleteRow {
sheet: u32,
row: i32,
old_data: Box<RowData>,
},
InsertColumn {
sheet: u32,
column: i32,
},
DeleteColumn {
sheet: u32,
column: i32,
old_data: Box<ColumnData>,
},
SetFrozenRowsCount {
sheet: u32,
new_value: i32,
old_value: i32,
},
SetFrozenColumnsCount {
sheet: u32,
new_value: i32,
old_value: i32,
},
DeleteSheet {
sheet: u32,
},
NewSheet {
index: u32,
name: String,
},
RenameSheet {
index: u32,
old_value: String,
new_value: String,
},
SetSheetColor {
index: u32,
old_value: String,
new_value: String,
},
SetShowGridLines {
sheet: u32,
old_value: bool,
new_value: bool,
}, // FIXME: we are missing SetViewDiffs
}
pub(crate) type DiffList = Vec<Diff>;
#[derive(Default)]
pub(crate) struct History {
pub(crate) undo_stack: Vec<DiffList>,
pub(crate) redo_stack: Vec<DiffList>,
}
impl History {
pub fn push(&mut self, diff_list: DiffList) {
self.undo_stack.push(diff_list);
self.redo_stack = vec![];
}
pub fn undo(&mut self) -> Option<Vec<Diff>> {
match self.undo_stack.pop() {
Some(diff_list) => {
self.redo_stack.push(diff_list.clone());
Some(diff_list)
}
None => None,
}
}
pub fn redo(&mut self) -> Option<Vec<Diff>> {
match self.redo_stack.pop() {
Some(diff_list) => {
self.undo_stack.push(diff_list.clone());
Some(diff_list)
}
None => None,
}
}
pub fn clear(&mut self) {
self.redo_stack = vec![];
self.undo_stack = vec![];
}
}
#[derive(Clone, Encode, Decode)]
pub enum DiffType {
Undo,
Redo,
}
#[derive(Clone, Encode, Decode)]
pub struct QueueDiffs {
pub r#type: DiffType,
pub list: DiffList,
}

12
base/src/user_model/mod.rs Normal file
View File

@@ -0,0 +1,12 @@
#![deny(missing_docs)]
mod common;
mod history;
mod ui;
pub use common::UserModel;
#[cfg(test)]
pub use ui::SelectedView;
pub use common::BorderArea;

687
base/src/user_model/ui.rs Normal file
View File

@@ -0,0 +1,687 @@
#![deny(missing_docs)]
use serde::{Deserialize, Serialize};
use crate::expressions::utils::{is_valid_column_number, is_valid_row};
use super::common::UserModel;
#[derive(Serialize, Deserialize)]
#[cfg_attr(test, derive(PartialEq, Debug))]
pub struct SelectedView {
pub sheet: u32,
pub row: i32,
pub column: i32,
pub range: [i32; 4],
pub top_row: i32,
pub left_column: i32,
}
impl UserModel {
/// Returns the selected sheet index
pub fn get_selected_sheet(&self) -> u32 {
if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
view.sheet
} else {
0
}
}
/// Returns the selected cell
pub fn get_selected_cell(&self) -> (u32, i32, i32) {
let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
view.sheet
} else {
0
};
if let Ok(worksheet) = self.model.workbook.worksheet(sheet) {
if let Some(view) = worksheet.views.get(&self.model.view_id) {
return (sheet, view.row, view.column);
}
}
// return a safe default
(0, 1, 1)
}
/// Returns selected view
pub fn get_selected_view(&self) -> SelectedView {
let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
view.sheet
} else {
0
};
if let Ok(worksheet) = self.model.workbook.worksheet(sheet) {
if let Some(view) = worksheet.views.get(&self.model.view_id) {
return SelectedView {
sheet,
row: view.row,
column: view.column,
range: view.range,
top_row: view.top_row,
left_column: view.left_column,
};
}
}
// return a safe default
SelectedView {
sheet: 0,
row: 1,
column: 1,
range: [1, 1, 1, 1],
top_row: 1,
left_column: 1,
}
}
/// Sets the the selected sheet
pub fn set_selected_sheet(&mut self, sheet: u32) -> Result<(), String> {
if self.model.workbook.worksheet(sheet).is_err() {
return Err(format!("Invalid worksheet index {}", sheet));
}
if let Some(view) = self.model.workbook.views.get_mut(&0) {
view.sheet = sheet;
}
Ok(())
}
/// Sets the selected cell for the current view. Note that this also sets the selected range
pub fn set_selected_cell(&mut self, row: i32, column: i32) -> Result<(), String> {
let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
view.sheet
} else {
0
};
if !is_valid_column_number(column) {
return Err(format!("Invalid column: '{column}'"));
}
if !is_valid_row(row) {
return Err(format!("Invalid row: '{row}'"));
}
if self.model.workbook.worksheet(sheet).is_err() {
return Err(format!("Invalid worksheet index {}", sheet));
}
if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
if let Some(view) = worksheet.views.get_mut(&0) {
view.row = row;
view.column = column;
view.range = [row, column, row, column];
}
}
Ok(())
}
/// Sets the selected range. Note that the selected cell must be in one of the corners.
pub fn set_selected_range(
&mut self,
start_row: i32,
start_column: i32,
end_row: i32,
end_column: i32,
) -> Result<(), String> {
let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
view.sheet
} else {
0
};
if !is_valid_column_number(start_column) {
return Err(format!("Invalid column: '{start_column}'"));
}
if !is_valid_row(start_row) {
return Err(format!("Invalid row: '{start_row}'"));
}
if !is_valid_column_number(end_column) {
return Err(format!("Invalid column: '{end_column}'"));
}
if !is_valid_row(end_row) {
return Err(format!("Invalid row: '{end_row}'"));
}
if self.model.workbook.worksheet(sheet).is_err() {
return Err(format!("Invalid worksheet index {}", sheet));
}
if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
if let Some(view) = worksheet.views.get_mut(&0) {
let selected_row = view.row;
let selected_column = view.column;
// The selected cells must be on one of the corners of the selected range:
if selected_row != start_row && selected_row != end_row {
return Err(format!(
"The selected cells is not in one of the corners. Row: '{}' and row range '({}, {})'",
selected_row, start_row, end_row
));
}
if selected_column != start_column && selected_column != end_column {
return Err(format!(
"The selected cells is not in one of the corners. Column '{}' and column range '({}, {})'",
selected_column, start_column, end_column
));
}
view.range = [start_row, start_column, end_row, end_column];
}
}
Ok(())
}
/// The selected range is expanded with the keyboard
pub fn on_expand_selected_range(&mut self, key: &str) -> Result<(), String> {
let (sheet, window_width, window_height) =
if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
(
view.sheet,
view.window_width as f64,
view.window_height as f64,
)
} else {
return Ok(());
};
let (selected_row, selected_column, range, top_row, left_column) =
if let Ok(worksheet) = self.model.workbook.worksheet(sheet) {
if let Some(view) = worksheet.views.get(&self.model.view_id) {
(
view.row,
view.column,
view.range,
view.top_row,
view.left_column,
)
} else {
return Ok(());
}
} else {
return Ok(());
};
let [row_start, column_start, row_end, column_end] = range;
match key {
"ArrowRight" => {
if selected_column > column_start {
let new_column = column_start + 1;
if !(is_valid_column_number(new_column)) {
return Ok(());
}
self.set_selected_range(row_start, new_column, row_end, column_end)?;
} else {
let new_column = column_end + 1;
if !is_valid_column_number(new_column) {
return Ok(());
}
// if the column is not fully visible we 'scroll' right until it is
let mut width = 0.0;
let mut c = left_column;
while c <= new_column {
width += self.model.get_column_width(sheet, c)?;
c += 1;
}
if width > window_width {
self.set_top_left_visible_cell(top_row, left_column + 1)?;
}
self.set_selected_range(row_start, column_start, row_end, column_end + 1)?;
}
}
"ArrowLeft" => {
if selected_column < column_end {
let new_column = column_end - 1;
if !is_valid_column_number(new_column) {
return Ok(());
}
if new_column < left_column {
self.set_top_left_visible_cell(top_row, new_column)?;
}
self.set_selected_range(row_start, column_start, row_end, new_column)?;
} else {
let new_column = column_start - 1;
if !is_valid_column_number(new_column) {
return Ok(());
}
if new_column < left_column {
self.set_top_left_visible_cell(top_row, new_column)?;
}
self.set_selected_range(row_start, new_column, row_end, column_end)?;
}
}
"ArrowUp" => {
if selected_row < row_end {
let new_row = row_end - 1;
if !is_valid_row(new_row) {
return Ok(());
}
self.set_selected_range(row_start, column_start, new_row, column_end)?;
} else {
let new_row = row_start - 1;
if !is_valid_row(new_row) {
return Ok(());
}
if new_row < top_row {
self.set_top_left_visible_cell(new_row, left_column)?;
}
self.set_selected_range(new_row, column_start, row_end, column_end)?;
}
}
"ArrowDown" => {
if selected_row > row_start {
let new_row = row_start + 1;
if !is_valid_row(new_row) {
return Ok(());
}
self.set_selected_range(new_row, column_start, row_end, column_end)?;
} else {
let new_row = row_end + 1;
if !is_valid_row(new_row) {
return Ok(());
}
let mut height = 0.0;
let mut r = top_row;
while r <= new_row + 1 {
height += self.model.get_row_height(sheet, r)?;
r += 1;
}
if height >= window_height {
self.set_top_left_visible_cell(top_row + 1, left_column)?;
}
self.set_selected_range(row_start, column_start, new_row, column_end)?;
}
}
_ => {}
}
Ok(())
}
/// Sets the value of the first visible cell
pub fn set_top_left_visible_cell(
&mut self,
top_row: i32,
left_column: i32,
) -> Result<(), String> {
let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
view.sheet
} else {
0
};
if !is_valid_column_number(left_column) {
return Err(format!("Invalid column: '{left_column}'"));
}
if !is_valid_row(top_row) {
return Err(format!("Invalid row: '{top_row}'"));
}
if self.model.workbook.worksheet(sheet).is_err() {
return Err(format!("Invalid worksheet index {}", sheet));
}
if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
if let Some(view) = worksheet.views.get_mut(&0) {
view.top_row = top_row;
view.left_column = left_column;
}
}
Ok(())
}
/// Sets the width of the window
pub fn set_window_width(&mut self, window_width: f64) {
if let Some(view) = self.model.workbook.views.get_mut(&self.model.view_id) {
view.window_width = window_width as i64;
};
}
/// Gets the width of the window
pub fn get_window_width(&mut self) -> Result<i64, String> {
if let Some(view) = self.model.workbook.views.get_mut(&self.model.view_id) {
return Ok(view.window_width);
};
Err("View not found".to_string())
}
/// Sets the height of the window
pub fn set_window_height(&mut self, window_height: f64) {
if let Some(view) = self.model.workbook.views.get_mut(&self.model.view_id) {
view.window_height = window_height as i64;
};
}
/// Gets the height of the window
pub fn get_window_height(&mut self) -> Result<i64, String> {
if let Some(view) = self.model.workbook.views.get_mut(&self.model.view_id) {
return Ok(view.window_height);
};
Err("View not found".to_string())
}
/// User presses right arrow
pub fn on_arrow_right(&mut self) -> Result<(), String> {
let (sheet, window_width) =
if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
(view.sheet, view.window_width)
} else {
return Err("View not found".to_string());
};
let worksheet = match self.model.workbook.worksheet(sheet) {
Ok(s) => s,
Err(_) => return Err("Worksheet not found".to_string()),
};
let view = match worksheet.views.get(&self.model.view_id) {
Some(s) => s,
None => return Err("View not found".to_string()),
};
let new_column = view.column + 1;
if !is_valid_column_number(new_column) {
return Ok(());
}
// if the column is not fully visible we 'scroll' right until it is
let mut width = 0.0;
let mut column = view.left_column;
while column <= new_column {
width += self.model.get_column_width(sheet, column)?;
column += 1;
}
if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
if let Some(view) = worksheet.views.get_mut(&self.model.view_id) {
view.column = new_column;
view.range = [view.row, new_column, view.row, new_column];
if width > window_width as f64 {
view.left_column += 1;
}
}
}
Ok(())
}
/// User presses left arrow
pub fn on_arrow_left(&mut self) -> Result<(), String> {
let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
view.sheet
} else {
return Err("View not found".to_string());
};
let worksheet = match self.model.workbook.worksheet(sheet) {
Ok(s) => s,
Err(_) => return Err("Worksheet not found".to_string()),
};
let view = match worksheet.views.get(&self.model.view_id) {
Some(s) => s,
None => return Err("View not found".to_string()),
};
let new_column = view.column - 1;
if !is_valid_column_number(new_column) {
return Ok(());
}
// if the column is not fully visible we 'scroll' right until it is
if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
if let Some(view) = worksheet.views.get_mut(&self.model.view_id) {
view.column = new_column;
view.range = [view.row, new_column, view.row, new_column];
if new_column < view.left_column {
view.left_column = new_column;
}
}
}
Ok(())
}
/// User presses up arrow key
pub fn on_arrow_up(&mut self) -> Result<(), String> {
let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
view.sheet
} else {
return Err("View not found".to_string());
};
let worksheet = match self.model.workbook.worksheet(sheet) {
Ok(s) => s,
Err(_) => return Err("Worksheet not found".to_string()),
};
let view = match worksheet.views.get(&self.model.view_id) {
Some(s) => s,
None => return Err("View not found".to_string()),
};
let new_row = view.row - 1;
if !is_valid_row(new_row) {
return Ok(());
}
// if the column is not fully visible we 'scroll' right until it is
if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
if let Some(view) = worksheet.views.get_mut(&self.model.view_id) {
view.row = new_row;
view.range = [new_row, view.column, new_row, view.column];
if new_row < view.top_row {
view.top_row = new_row;
}
}
}
Ok(())
}
/// User presses down arrow key
pub fn on_arrow_down(&mut self) -> Result<(), String> {
let (sheet, window_height) =
if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
(view.sheet, view.window_height)
} else {
return Err("View not found".to_string());
};
let worksheet = match self.model.workbook.worksheet(sheet) {
Ok(s) => s,
Err(_) => return Err("Worksheet not found".to_string()),
};
let view = match worksheet.views.get(&self.model.view_id) {
Some(s) => s,
None => return Err("View not found".to_string()),
};
let new_row = view.row + 1;
if !is_valid_row(new_row) {
return Ok(());
}
// if the row is not fully visible we 'scroll' down until it is
let mut height = 0.0;
let mut row = view.top_row;
while row <= new_row + 1 {
height += self.model.get_row_height(sheet, row)?;
row += 1;
}
if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
if let Some(view) = worksheet.views.get_mut(&self.model.view_id) {
view.row = new_row;
view.range = [new_row, view.column, new_row, view.column];
if height > window_height as f64 {
view.top_row += 1;
}
}
}
Ok(())
}
// TODO: This function should be memoized
/// Returns the x-coordinate of the cell in the top left corner
pub fn get_scroll_x(&self) -> Result<f64, String> {
let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
view.sheet
} else {
return Err("View not found".to_string());
};
let worksheet = match self.model.workbook.worksheet(sheet) {
Ok(s) => s,
Err(_) => return Err("Worksheet not found".to_string()),
};
let view = match worksheet.views.get(&self.model.view_id) {
Some(s) => s,
None => return Err("View not found".to_string()),
};
let mut scroll_x = 0.0;
for column in 1..view.left_column {
scroll_x += self.model.get_column_width(sheet, column)?;
}
Ok(scroll_x)
}
// TODO: This function should be memoized
/// Returns the y-coordinate of the cell in the top left corner
pub fn get_scroll_y(&self) -> Result<f64, String> {
let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
view.sheet
} else {
return Err("View not found".to_string());
};
let worksheet = match self.model.workbook.worksheet(sheet) {
Ok(s) => s,
Err(_) => return Err("Worksheet not found".to_string()),
};
let view = match worksheet.views.get(&self.model.view_id) {
Some(s) => s,
None => return Err("View not found".to_string()),
};
let mut scroll_y = 0.0;
for row in 1..view.top_row {
scroll_y += self.model.get_row_height(sheet, row)?;
}
Ok(scroll_y)
}
/// User presses page down.
/// The `top_row` is now the first row that is not fully visible
pub fn on_page_down(&mut self) -> Result<(), String> {
let (sheet, window_height) =
if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
(view.sheet, view.window_height)
} else {
return Err("View not found".to_string());
};
let worksheet = match self.model.workbook.worksheet(sheet) {
Ok(s) => s,
Err(_) => return Err("Worksheet not found".to_string()),
};
let view = match worksheet.views.get(&self.model.view_id) {
Some(s) => s,
None => return Err("View not found".to_string()),
};
let mut last_row = view.top_row;
let mut height = self.model.get_row_height(sheet, last_row)?;
while height <= window_height as f64 {
last_row += 1;
height += self.model.get_row_height(sheet, last_row)?;
}
if !is_valid_row(last_row) {
return Ok(());
}
let row_delta = view.row - view.top_row;
if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
if let Some(view) = worksheet.views.get_mut(&self.model.view_id) {
view.top_row = last_row;
view.row = view.top_row + row_delta;
view.range = [view.row, view.column, view.row, view.column];
}
}
Ok(())
}
/// On page up. tis needs to be the inverse of page down
pub fn on_page_up(&mut self) -> Result<(), String> {
let (sheet, window_height) =
if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
(view.sheet, view.window_height as f64)
} else {
return Err("View not found".to_string());
};
let worksheet = match self.model.workbook.worksheet(sheet) {
Ok(s) => s,
Err(_) => return Err("Worksheet not found".to_string()),
};
let view = match worksheet.views.get(&self.model.view_id) {
Some(s) => s,
None => return Err("View not found".to_string()),
};
let mut first_row = view.top_row;
let mut height = self.model.get_row_height(sheet, first_row)?;
while height <= window_height && first_row > 1 {
first_row -= 1;
height += self.model.get_row_height(sheet, first_row)?;
}
let row_delta = view.row - view.top_row;
if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
if let Some(view) = worksheet.views.get_mut(&self.model.view_id) {
view.top_row = first_row;
view.row = view.top_row + row_delta;
view.range = [view.row, view.column, view.row, view.column];
}
}
Ok(())
}
/// We extend the selection to cell (target_row, target_column)
pub fn on_area_selecting(&mut self, target_row: i32, target_column: i32) -> Result<(), String> {
let (sheet, window_width, window_height) =
if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
(
view.sheet,
view.window_width as f64,
view.window_height as f64,
)
} else {
return Ok(());
};
let (selected_row, selected_column, range, top_row, left_column) =
if let Ok(worksheet) = self.model.workbook.worksheet(sheet) {
if let Some(view) = worksheet.views.get(&self.model.view_id) {
(
view.row,
view.column,
view.range,
view.top_row,
view.left_column,
)
} else {
return Ok(());
}
} else {
return Ok(());
};
let [row_start, column_start, _row_end, _column_end] = range;
let mut new_left_column = left_column;
if target_column >= selected_column {
let mut width = 0.0;
let mut column = left_column;
while column <= target_column {
width += self.model.get_column_width(sheet, column)?;
column += 1;
}
while width > window_width {
width -= self.model.get_column_width(sheet, new_left_column)?;
new_left_column += 1;
}
} else if target_column < new_left_column {
new_left_column = target_column;
}
let mut new_top_row = top_row;
if target_row >= selected_row {
let mut height = 0.0;
let mut row = top_row;
while row <= target_row {
height += self.model.get_row_height(sheet, row)?;
row += 1;
}
while height > window_height {
height -= self.model.get_row_height(sheet, new_top_row)?;
new_top_row += 1;
}
} else if target_row < new_top_row {
new_top_row = target_row;
}
if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
if let Some(view) = worksheet.views.get_mut(&self.model.view_id) {
view.range = [row_start, column_start, target_row, target_column];
if new_top_row != top_row {
view.top_row = new_top_row;
}
if new_left_column != left_column {
view.left_column = new_left_column;
}
}
}
Ok(())
}
}