Compare commits
1 Commits
feature/da
...
feature/ni
| Author | SHA1 | Date | |
|---|---|---|---|
|
3edb068a01 |
4
.github/workflows/pypi.yml
vendored
4
.github/workflows/pypi.yml
vendored
@@ -117,7 +117,7 @@ jobs:
|
||||
MATURIN_REPOSITORY_URL: "https://test.pypi.org/legacy/"
|
||||
with:
|
||||
command: upload
|
||||
args: "--skip-existing **/*.whl **/*.tar.gz"
|
||||
args: "--skip-existing **/*.whl"
|
||||
working-directory: bindings/python
|
||||
|
||||
publish-pypi:
|
||||
@@ -137,5 +137,5 @@ jobs:
|
||||
MATURIN_REPOSITORY_URL: "https://upload.pypi.org/legacy/"
|
||||
with:
|
||||
command: upload
|
||||
args: "--skip-existing **/*.whl **/*.tar.gz"
|
||||
args: "--skip-existing **/*.whl"
|
||||
working-directory: bindings/python
|
||||
|
||||
29
Cargo.lock
generated
29
Cargo.lock
generated
@@ -437,6 +437,7 @@ dependencies = [
|
||||
"chrono-tz",
|
||||
"csv",
|
||||
"js-sys",
|
||||
"once_cell",
|
||||
"rand",
|
||||
"regex",
|
||||
"regex-lite",
|
||||
@@ -720,10 +721,11 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "pyo3"
|
||||
version = "0.25.0"
|
||||
version = "0.23.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f239d656363bcee73afef85277f1b281e8ac6212a1d42aa90e55b90ed43c47a4"
|
||||
checksum = "57fe09249128b3173d092de9523eaa75136bf7ba85e0d69eca241c7939c933cc"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"indoc",
|
||||
"libc",
|
||||
"memoffset",
|
||||
@@ -737,9 +739,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "pyo3-build-config"
|
||||
version = "0.25.0"
|
||||
version = "0.23.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "755ea671a1c34044fa165247aaf6f419ca39caa6003aee791a0df2713d8f1b6d"
|
||||
checksum = "1cd3927b5a78757a0d71aa9dff669f903b1eb64b54142a9bd9f757f8fde65fd7"
|
||||
dependencies = [
|
||||
"once_cell",
|
||||
"target-lexicon",
|
||||
@@ -747,9 +749,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "pyo3-ffi"
|
||||
version = "0.25.0"
|
||||
version = "0.23.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "fc95a2e67091e44791d4ea300ff744be5293f394f1bafd9f78c080814d35956e"
|
||||
checksum = "dab6bb2102bd8f991e7749f130a70d05dd557613e39ed2deeee8e9ca0c4d548d"
|
||||
dependencies = [
|
||||
"libc",
|
||||
"pyo3-build-config",
|
||||
@@ -757,9 +759,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "pyo3-macros"
|
||||
version = "0.25.0"
|
||||
version = "0.23.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a179641d1b93920829a62f15e87c0ed791b6c8db2271ba0fd7c2686090510214"
|
||||
checksum = "91871864b353fd5ffcb3f91f2f703a22a9797c91b9ab497b1acac7b07ae509c7"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"pyo3-macros-backend",
|
||||
@@ -769,9 +771,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "pyo3-macros-backend"
|
||||
version = "0.25.0"
|
||||
version = "0.23.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9dff85ebcaab8c441b0e3f7ae40a6963ecea8a9f5e74f647e33fcf5ec9a1e89e"
|
||||
checksum = "43abc3b80bc20f3facd86cd3c60beed58c3e2aa26213f3cda368de39c60a27e4"
|
||||
dependencies = [
|
||||
"heck",
|
||||
"proc-macro2",
|
||||
@@ -782,9 +784,8 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "pyroncalc"
|
||||
version = "0.5.7"
|
||||
version = "0.5.0"
|
||||
dependencies = [
|
||||
"bitcode",
|
||||
"ironcalc",
|
||||
"pyo3",
|
||||
"serde",
|
||||
@@ -984,9 +985,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "target-lexicon"
|
||||
version = "0.13.2"
|
||||
version = "0.12.16"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e502f78cdbb8ba4718f566c418c52bc729126ffd16baee5baa718cf25dd5a69a"
|
||||
checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
|
||||
|
||||
[[package]]
|
||||
name = "thiserror"
|
||||
|
||||
@@ -17,6 +17,7 @@ chrono = "0.4"
|
||||
chrono-tz = "0.10"
|
||||
regex = { version = "1.0", optional = true}
|
||||
regex-lite = { version = "0.1.6", optional = true}
|
||||
once_cell = "1.16.0"
|
||||
bitcode = "0.6.3"
|
||||
csv = "1.3.0"
|
||||
|
||||
|
||||
@@ -212,12 +212,6 @@ impl Model {
|
||||
if column_count <= 0 {
|
||||
return Err("Please use insert columns instead".to_string());
|
||||
}
|
||||
if !(1..=LAST_COLUMN).contains(&column) {
|
||||
return Err(format!("Column number '{column}' is not valid."));
|
||||
}
|
||||
if column + column_count - 1 > LAST_COLUMN {
|
||||
return Err("Cannot delete columns beyond the last column of the sheet".to_string());
|
||||
}
|
||||
|
||||
// first column being deleted
|
||||
let column_start = column;
|
||||
@@ -390,13 +384,6 @@ impl Model {
|
||||
if row_count <= 0 {
|
||||
return Err("Please use insert rows instead".to_string());
|
||||
}
|
||||
if !(1..=LAST_ROW).contains(&row) {
|
||||
return Err(format!("Row number '{row}' is not valid."));
|
||||
}
|
||||
if row + row_count - 1 > LAST_ROW {
|
||||
return Err("Cannot delete rows beyond the last row of the sheet".to_string());
|
||||
}
|
||||
|
||||
// Move cells
|
||||
let worksheet = &self.workbook.worksheet(sheet)?;
|
||||
let mut all_rows: Vec<i32> = worksheet.sheet_data.keys().copied().collect();
|
||||
@@ -457,7 +444,7 @@ impl Model {
|
||||
/// * Column is one of the extremes of the range. The new extreme would be target_column.
|
||||
/// Range is then normalized
|
||||
/// * Any other case, range is left unchanged.
|
||||
/// NOTE: This moves the data and column styles along with the formulas
|
||||
/// NOTE: This does NOT move the data in the columns or move the colum styles
|
||||
pub fn move_column_action(
|
||||
&mut self,
|
||||
sheet: u32,
|
||||
@@ -473,70 +460,7 @@ impl Model {
|
||||
return Err("Initial column out of boundaries".to_string());
|
||||
}
|
||||
|
||||
if delta == 0 {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// Preserve cell contents, width and style of the column being moved
|
||||
let original_refs = self
|
||||
.workbook
|
||||
.worksheet(sheet)?
|
||||
.column_cell_references(column)?;
|
||||
let mut original_cells = Vec::new();
|
||||
for r in &original_refs {
|
||||
let cell = self
|
||||
.workbook
|
||||
.worksheet(sheet)?
|
||||
.cell(r.row, column)
|
||||
.ok_or("Expected Cell to exist")?;
|
||||
let style_idx = cell.get_style();
|
||||
let formula_or_value = self
|
||||
.get_cell_formula(sheet, r.row, column)?
|
||||
.unwrap_or_else(|| cell.get_text(&self.workbook.shared_strings, &self.language));
|
||||
original_cells.push((r.row, formula_or_value, style_idx));
|
||||
self.cell_clear_all(sheet, r.row, column)?;
|
||||
}
|
||||
|
||||
let width = self.workbook.worksheet(sheet)?.get_column_width(column)?;
|
||||
let style = self.workbook.worksheet(sheet)?.get_column_style(column)?;
|
||||
|
||||
if delta > 0 {
|
||||
for c in column + 1..=target_column {
|
||||
let refs = self.workbook.worksheet(sheet)?.column_cell_references(c)?;
|
||||
for r in refs {
|
||||
self.move_cell(sheet, r.row, c, r.row, c - 1)?;
|
||||
}
|
||||
|
||||
let w = self.workbook.worksheet(sheet)?.get_column_width(c)?;
|
||||
let s = self.workbook.worksheet(sheet)?.get_column_style(c)?;
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
.set_column_width_and_style(c - 1, w, s)?;
|
||||
}
|
||||
} else {
|
||||
for c in (target_column..=column - 1).rev() {
|
||||
let refs = self.workbook.worksheet(sheet)?.column_cell_references(c)?;
|
||||
for r in refs {
|
||||
self.move_cell(sheet, r.row, c, r.row, c + 1)?;
|
||||
}
|
||||
|
||||
let w = self.workbook.worksheet(sheet)?.get_column_width(c)?;
|
||||
let s = self.workbook.worksheet(sheet)?.get_column_style(c)?;
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
.set_column_width_and_style(c + 1, w, s)?;
|
||||
}
|
||||
}
|
||||
|
||||
for (r, value, style_idx) in original_cells {
|
||||
self.set_user_input(sheet, r, target_column, value)?;
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
.set_cell_style(r, target_column, style_idx)?;
|
||||
}
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
.set_column_width_and_style(target_column, width, style)?;
|
||||
// TODO: Add the actual displacement of data and styles
|
||||
|
||||
// Update all formulas in the workbook
|
||||
self.displace_cells(
|
||||
@@ -549,88 +473,4 @@ impl Model {
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Displaces cells due to a move row action
|
||||
/// from initial_row to target_row = initial_row + row_delta
|
||||
/// References will be updated following the same rules as move_column_action
|
||||
/// NOTE: This moves the data and row styles along with the formulas
|
||||
pub fn move_row_action(&mut self, sheet: u32, row: i32, delta: i32) -> Result<(), String> {
|
||||
// Check boundaries
|
||||
let target_row = row + delta;
|
||||
if !(1..=LAST_ROW).contains(&target_row) {
|
||||
return Err("Target row out of boundaries".to_string());
|
||||
}
|
||||
if !(1..=LAST_ROW).contains(&row) {
|
||||
return Err("Initial row out of boundaries".to_string());
|
||||
}
|
||||
|
||||
if delta == 0 {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let original_cols = self.get_columns_for_row(sheet, row, false)?;
|
||||
let mut original_cells = Vec::new();
|
||||
for c in &original_cols {
|
||||
let cell = self
|
||||
.workbook
|
||||
.worksheet(sheet)?
|
||||
.cell(row, *c)
|
||||
.ok_or("Expected Cell to exist")?;
|
||||
let style_idx = cell.get_style();
|
||||
let formula_or_value = self
|
||||
.get_cell_formula(sheet, row, *c)?
|
||||
.unwrap_or_else(|| cell.get_text(&self.workbook.shared_strings, &self.language));
|
||||
original_cells.push((*c, formula_or_value, style_idx));
|
||||
self.cell_clear_all(sheet, row, *c)?;
|
||||
}
|
||||
|
||||
if delta > 0 {
|
||||
for r in row + 1..=target_row {
|
||||
let cols = self.get_columns_for_row(sheet, r, false)?;
|
||||
for c in cols {
|
||||
self.move_cell(sheet, r, c, r - 1, c)?;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for r in (target_row..=row - 1).rev() {
|
||||
let cols = self.get_columns_for_row(sheet, r, false)?;
|
||||
for c in cols {
|
||||
self.move_cell(sheet, r, c, r + 1, c)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (c, value, style_idx) in original_cells {
|
||||
self.set_user_input(sheet, target_row, c, value)?;
|
||||
self.workbook
|
||||
.worksheet_mut(sheet)?
|
||||
.set_cell_style(target_row, c, style_idx)?;
|
||||
}
|
||||
|
||||
let worksheet = &mut self.workbook.worksheet_mut(sheet)?;
|
||||
let mut new_rows = Vec::new();
|
||||
for r in worksheet.rows.iter() {
|
||||
if r.r == row {
|
||||
let mut nr = r.clone();
|
||||
nr.r = target_row;
|
||||
new_rows.push(nr);
|
||||
} else if delta > 0 && r.r > row && r.r <= target_row {
|
||||
let mut nr = r.clone();
|
||||
nr.r -= 1;
|
||||
new_rows.push(nr);
|
||||
} else if delta < 0 && r.r < row && r.r >= target_row {
|
||||
let mut nr = r.clone();
|
||||
nr.r += 1;
|
||||
new_rows.push(nr);
|
||||
} else {
|
||||
new_rows.push(r.clone());
|
||||
}
|
||||
}
|
||||
worksheet.rows = new_rows;
|
||||
|
||||
// Update all formulas in the workbook
|
||||
self.displace_cells(&(DisplaceData::RowMove { sheet, row, delta }))?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
@@ -314,9 +314,6 @@ impl Lexer {
|
||||
} else if name_upper == self.language.booleans.r#false {
|
||||
return TokenType::Boolean(false);
|
||||
}
|
||||
if self.peek_char() == Some('(') {
|
||||
return TokenType::Ident(name);
|
||||
}
|
||||
if self.mode == LexerMode::A1 {
|
||||
let parsed_reference = utils::parse_reference_a1(&name_upper);
|
||||
if parsed_reference.is_some()
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::expressions::utils::column_to_number;
|
||||
use crate::language::get_language;
|
||||
use crate::locale::get_locale;
|
||||
|
||||
@@ -686,29 +685,3 @@ fn test_comparisons() {
|
||||
assert_eq!(lx.next_token(), Number(7.0));
|
||||
assert_eq!(lx.next_token(), EOF);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_log10_is_cell_reference() {
|
||||
let mut lx = new_lexer("LOG10", true);
|
||||
assert_eq!(
|
||||
lx.next_token(),
|
||||
Reference {
|
||||
sheet: None,
|
||||
column: column_to_number("LOG").unwrap(),
|
||||
row: 10,
|
||||
absolute_column: false,
|
||||
absolute_row: false,
|
||||
}
|
||||
);
|
||||
assert_eq!(lx.next_token(), EOF);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_log10_is_function() {
|
||||
let mut lx = new_lexer("LOG10(100)", true);
|
||||
assert_eq!(lx.next_token(), Ident("LOG10".to_string()));
|
||||
assert_eq!(lx.next_token(), LeftParenthesis);
|
||||
assert_eq!(lx.next_token(), Number(100.0));
|
||||
assert_eq!(lx.next_token(), RightParenthesis);
|
||||
assert_eq!(lx.next_token(), EOF);
|
||||
}
|
||||
|
||||
@@ -717,7 +717,7 @@ impl Parser {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: 0,
|
||||
message: format!("sheet not found: {}", context.sheet),
|
||||
message: "sheet not found".to_string(),
|
||||
};
|
||||
}
|
||||
};
|
||||
@@ -850,7 +850,7 @@ impl Parser {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: 0,
|
||||
message: format!("sheet not found: {}", context.sheet),
|
||||
message: "sheet not found".to_string(),
|
||||
};
|
||||
}
|
||||
};
|
||||
@@ -878,7 +878,7 @@ impl Parser {
|
||||
return Node::ParseErrorKind {
|
||||
formula: self.lexer.get_formula(),
|
||||
position: 0,
|
||||
message: format!("table sheet not found: {}", table.sheet_name),
|
||||
message: "sheet not found".to_string(),
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
@@ -2,19 +2,15 @@ use crate::functions::Function;
|
||||
|
||||
use super::Node;
|
||||
|
||||
use once_cell::sync::Lazy;
|
||||
use regex::Regex;
|
||||
use std::sync::OnceLock;
|
||||
|
||||
static RANGE_REFERENCE_REGEX: OnceLock<Regex> = OnceLock::new();
|
||||
|
||||
#[allow(clippy::expect_used)]
|
||||
fn get_re() -> &'static Regex {
|
||||
RANGE_REFERENCE_REGEX
|
||||
.get_or_init(|| Regex::new(r":[A-Z]*[0-9]*$").expect("Regex is known to be valid"))
|
||||
}
|
||||
static RE: Lazy<Regex> =
|
||||
Lazy::new(|| Regex::new(r":[A-Z]*[0-9]*$").expect("Regex is known to be valid"));
|
||||
|
||||
fn is_range_reference(s: &str) -> bool {
|
||||
get_re().is_match(s)
|
||||
RE.is_match(s)
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -609,9 +605,6 @@ fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signatu
|
||||
Function::Choose => vec![Signature::Scalar; arg_count],
|
||||
Function::Column => args_signature_row(arg_count),
|
||||
Function::Columns => args_signature_one_vector(arg_count),
|
||||
Function::Ln => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Log => args_signature_scalars(arg_count, 1, 1),
|
||||
Function::Log10 => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Cos => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Cosh => args_signature_scalars(arg_count, 1, 0),
|
||||
Function::Max => vec![Signature::Vector; arg_count],
|
||||
@@ -823,9 +816,6 @@ fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
|
||||
Function::Round => scalar_arguments(args),
|
||||
Function::Rounddown => scalar_arguments(args),
|
||||
Function::Roundup => scalar_arguments(args),
|
||||
Function::Ln => scalar_arguments(args),
|
||||
Function::Log => scalar_arguments(args),
|
||||
Function::Log10 => scalar_arguments(args),
|
||||
Function::Sin => scalar_arguments(args),
|
||||
Function::Sinh => scalar_arguments(args),
|
||||
Function::Sqrt => scalar_arguments(args),
|
||||
|
||||
@@ -2,7 +2,7 @@ use super::{super::utils::quote_name, Node, Reference};
|
||||
use crate::constants::{LAST_COLUMN, LAST_ROW};
|
||||
use crate::expressions::parser::move_formula::to_string_array_node;
|
||||
use crate::expressions::parser::static_analysis::add_implicit_intersection;
|
||||
use crate::expressions::token::{OpSum, OpUnary};
|
||||
use crate::expressions::token::OpUnary;
|
||||
use crate::{expressions::types::CellReferenceRC, number_format::to_excel_precision_str};
|
||||
|
||||
pub enum DisplaceData {
|
||||
@@ -28,11 +28,6 @@ pub enum DisplaceData {
|
||||
column: i32,
|
||||
delta: i32,
|
||||
},
|
||||
RowMove {
|
||||
sheet: u32,
|
||||
row: i32,
|
||||
delta: i32,
|
||||
},
|
||||
ColumnMove {
|
||||
sheet: u32,
|
||||
column: i32,
|
||||
@@ -164,29 +159,6 @@ pub(crate) fn stringify_reference(
|
||||
}
|
||||
}
|
||||
}
|
||||
DisplaceData::RowMove {
|
||||
sheet,
|
||||
row: move_row,
|
||||
delta,
|
||||
} => {
|
||||
if sheet_index == *sheet {
|
||||
if row == *move_row {
|
||||
row += *delta;
|
||||
} else if *delta > 0 {
|
||||
// Moving the row downwards
|
||||
if row > *move_row && row <= *move_row + *delta {
|
||||
// Intermediate rows move up by one position
|
||||
row -= 1;
|
||||
}
|
||||
} else if *delta < 0 {
|
||||
// Moving the row upwards
|
||||
if row < *move_row && row >= *move_row + *delta {
|
||||
// Intermediate rows move down by one position
|
||||
row += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
DisplaceData::ColumnMove {
|
||||
sheet,
|
||||
column: move_column,
|
||||
@@ -195,18 +167,14 @@ pub(crate) fn stringify_reference(
|
||||
if sheet_index == *sheet {
|
||||
if column == *move_column {
|
||||
column += *delta;
|
||||
} else if *delta > 0 {
|
||||
// Moving the column to the right
|
||||
if column > *move_column && column <= *move_column + *delta {
|
||||
// Intermediate columns move left by one position
|
||||
column -= 1;
|
||||
}
|
||||
} else if *delta < 0 {
|
||||
// Moving the column to the left
|
||||
if column < *move_column && column >= *move_column + *delta {
|
||||
// Intermediate columns move right by one position
|
||||
column += 1;
|
||||
}
|
||||
} else if (*delta > 0
|
||||
&& column > *move_column
|
||||
&& column <= *move_column + *delta)
|
||||
|| (*delta < 0
|
||||
&& column < *move_column
|
||||
&& column >= *move_column + *delta)
|
||||
{
|
||||
column -= *delta;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -483,32 +451,34 @@ fn stringify(
|
||||
kind,
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
),
|
||||
OpSumKind { kind, left, right } => {
|
||||
let left_str = stringify(left, context, displace_data, export_to_excel);
|
||||
// if kind is minus then we need parentheses in the right side if they are OpSumKind or CompareKind
|
||||
let right_str = if (matches!(kind, OpSum::Minus) && matches!(**right, OpSumKind { .. }))
|
||||
| matches!(**right, CompareKind { .. })
|
||||
{
|
||||
format!(
|
||||
"({})",
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
)
|
||||
} else {
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
};
|
||||
|
||||
format!("{left_str}{kind}{right_str}")
|
||||
}
|
||||
OpSumKind { kind, left, right } => format!(
|
||||
"{}{}{}",
|
||||
stringify(left, context, displace_data, export_to_excel),
|
||||
kind,
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
),
|
||||
OpProductKind { kind, left, right } => {
|
||||
let x = match **left {
|
||||
OpSumKind { .. } | CompareKind { .. } => format!(
|
||||
OpSumKind { .. } => format!(
|
||||
"({})",
|
||||
stringify(left, context, displace_data, export_to_excel)
|
||||
),
|
||||
CompareKind { .. } => format!(
|
||||
"({})",
|
||||
stringify(left, context, displace_data, export_to_excel)
|
||||
),
|
||||
_ => stringify(left, context, displace_data, export_to_excel),
|
||||
};
|
||||
let y = match **right {
|
||||
OpSumKind { .. } | CompareKind { .. } | OpProductKind { .. } => format!(
|
||||
OpSumKind { .. } => format!(
|
||||
"({})",
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
),
|
||||
CompareKind { .. } => format!(
|
||||
"({})",
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
),
|
||||
OpProductKind { .. } => format!(
|
||||
"({})",
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
),
|
||||
@@ -619,43 +589,10 @@ fn stringify(
|
||||
WrongVariableKind(name) => name.to_string(),
|
||||
UnaryKind { kind, right } => match kind {
|
||||
OpUnary::Minus => {
|
||||
let needs_parentheses = match **right {
|
||||
BooleanKind(_)
|
||||
| NumberKind(_)
|
||||
| StringKind(_)
|
||||
| ReferenceKind { .. }
|
||||
| RangeKind { .. }
|
||||
| WrongReferenceKind { .. }
|
||||
| WrongRangeKind { .. }
|
||||
| OpRangeKind { .. }
|
||||
| OpConcatenateKind { .. }
|
||||
| OpProductKind { .. }
|
||||
| OpPowerKind { .. }
|
||||
| FunctionKind { .. }
|
||||
| InvalidFunctionKind { .. }
|
||||
| ArrayKind(_)
|
||||
| DefinedNameKind(_)
|
||||
| TableNameKind(_)
|
||||
| WrongVariableKind(_)
|
||||
| ImplicitIntersection { .. }
|
||||
| CompareKind { .. }
|
||||
| ErrorKind(_)
|
||||
| ParseErrorKind { .. }
|
||||
| EmptyArgKind => false,
|
||||
|
||||
OpSumKind { .. } | UnaryKind { .. } => true,
|
||||
};
|
||||
if needs_parentheses {
|
||||
format!(
|
||||
"-({})",
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
)
|
||||
} else {
|
||||
format!(
|
||||
"-{}",
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
)
|
||||
}
|
||||
format!(
|
||||
"-{}",
|
||||
stringify(right, context, displace_data, export_to_excel)
|
||||
)
|
||||
}
|
||||
OpUnary::Percentage => {
|
||||
format!(
|
||||
|
||||
@@ -32,39 +32,3 @@ fn exp_order() {
|
||||
let t = parser.parse("(5)^(4)", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "5^4");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn correct_parenthesis() {
|
||||
let worksheets = vec!["Sheet1".to_string()];
|
||||
let mut parser = Parser::new(worksheets, vec![], HashMap::new());
|
||||
|
||||
let cell_reference = CellReferenceRC {
|
||||
sheet: "Sheet1".to_string(),
|
||||
row: 1,
|
||||
column: 1,
|
||||
};
|
||||
|
||||
let t = parser.parse("-(1 + 1)", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "-(1+1)");
|
||||
|
||||
let t = parser.parse("1 - (3 + 4)", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "1-(3+4)");
|
||||
|
||||
let t = parser.parse("-(1.05*(0.0284 + 0.0046) - 0.0284)", &cell_reference);
|
||||
assert_eq!(
|
||||
to_string(&t, &cell_reference),
|
||||
"-(1.05*(0.0284+0.0046)-0.0284)"
|
||||
);
|
||||
|
||||
let t = parser.parse("1 + (3+5)", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "1+3+5");
|
||||
|
||||
let t = parser.parse("1 - (3+5)", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "1-(3+5)");
|
||||
|
||||
let t = parser.parse("(1 - 3) - (3+5)", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "1-3-(3+5)");
|
||||
|
||||
let t = parser.parse("1 + (3<5)", &cell_reference);
|
||||
assert_eq!(to_string(&t, &cell_reference), "1+(3<5)");
|
||||
}
|
||||
|
||||
@@ -211,6 +211,4 @@ fn test_names() {
|
||||
assert!(!is_valid_identifier("test€"));
|
||||
assert!(!is_valid_identifier("truñe"));
|
||||
assert!(!is_valid_identifier("tr&ue"));
|
||||
|
||||
assert!(!is_valid_identifier("LOG10"));
|
||||
}
|
||||
|
||||
@@ -246,7 +246,7 @@ impl Model {
|
||||
}
|
||||
// None of the cases matched so we return the default
|
||||
// If there is an even number of args is the last one otherwise is #N/A
|
||||
if args_count.is_multiple_of(2) {
|
||||
if args_count % 2 == 0 {
|
||||
return self.evaluate_node_in_context(&args[args_count - 1], cell);
|
||||
}
|
||||
CalcResult::Error {
|
||||
@@ -262,7 +262,7 @@ impl Model {
|
||||
if args_count < 2 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
if !args_count.is_multiple_of(2) {
|
||||
if args_count % 2 != 0 {
|
||||
// Missing value for last condition
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
|
||||
@@ -2,7 +2,6 @@ use crate::cast::NumberOrArray;
|
||||
use crate::constants::{LAST_COLUMN, LAST_ROW};
|
||||
use crate::expressions::parser::ArrayNode;
|
||||
use crate::expressions::types::CellReferenceIndex;
|
||||
use crate::number_format::to_precision;
|
||||
use crate::single_number_fn;
|
||||
use crate::{
|
||||
calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
|
||||
@@ -312,7 +311,7 @@ impl Model {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let value = match self.get_number(&args[0], cell) {
|
||||
Ok(f) => to_precision(f, 15),
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
};
|
||||
let number_of_digits = match self.get_number(&args[1], cell) {
|
||||
@@ -328,13 +327,12 @@ impl Model {
|
||||
let scale = 10.0_f64.powf(number_of_digits);
|
||||
CalcResult::Number((value * scale).round() / scale)
|
||||
}
|
||||
|
||||
pub(crate) fn fn_roundup(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() != 2 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let value = match self.get_number(&args[0], cell) {
|
||||
Ok(f) => to_precision(f, 15),
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
};
|
||||
let number_of_digits = match self.get_number(&args[1], cell) {
|
||||
@@ -354,13 +352,12 @@ impl Model {
|
||||
CalcResult::Number((value * scale).floor() / scale)
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn fn_rounddown(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() != 2 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let value = match self.get_number(&args[0], cell) {
|
||||
Ok(f) => to_precision(f, 15),
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
};
|
||||
let number_of_digits = match self.get_number(&args[1], cell) {
|
||||
@@ -381,16 +378,6 @@ impl Model {
|
||||
}
|
||||
}
|
||||
|
||||
single_number_fn!(fn_log10, |f| if f <= 0.0 {
|
||||
Err(Error::NUM)
|
||||
} else {
|
||||
Ok(f64::log10(f))
|
||||
});
|
||||
single_number_fn!(fn_ln, |f| if f <= 0.0 {
|
||||
Err(Error::NUM)
|
||||
} else {
|
||||
Ok(f64::ln(f))
|
||||
});
|
||||
single_number_fn!(fn_sin, |f| Ok(f64::sin(f)));
|
||||
single_number_fn!(fn_cos, |f| Ok(f64::cos(f)));
|
||||
single_number_fn!(fn_tan, |f| Ok(f64::tan(f)));
|
||||
@@ -444,47 +431,6 @@ impl Model {
|
||||
CalcResult::Number(f64::atan2(y, x))
|
||||
}
|
||||
|
||||
pub(crate) fn fn_log(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
let n_args = args.len();
|
||||
if !(1..=2).contains(&n_args) {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
let x = match self.get_number(&args[0], cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
};
|
||||
let y = if n_args == 1 {
|
||||
10.0
|
||||
} else {
|
||||
match self.get_number(&args[1], cell) {
|
||||
Ok(f) => f,
|
||||
Err(s) => return s,
|
||||
}
|
||||
};
|
||||
if x <= 0.0 {
|
||||
return CalcResult::Error {
|
||||
error: Error::NUM,
|
||||
origin: cell,
|
||||
message: "Number must be positive".to_string(),
|
||||
};
|
||||
}
|
||||
if y == 1.0 {
|
||||
return CalcResult::Error {
|
||||
error: Error::DIV,
|
||||
origin: cell,
|
||||
message: "Logarithm base cannot be 1".to_string(),
|
||||
};
|
||||
}
|
||||
if y <= 0.0 {
|
||||
return CalcResult::Error {
|
||||
error: Error::NUM,
|
||||
origin: cell,
|
||||
message: "Logarithm base must be positive".to_string(),
|
||||
};
|
||||
}
|
||||
CalcResult::Number(f64::log(x, y))
|
||||
}
|
||||
|
||||
pub(crate) fn fn_power(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
if args.len() != 2 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
|
||||
@@ -54,9 +54,6 @@ pub enum Function {
|
||||
Columns,
|
||||
Cos,
|
||||
Cosh,
|
||||
Log,
|
||||
Log10,
|
||||
Ln,
|
||||
Max,
|
||||
Min,
|
||||
Pi,
|
||||
@@ -253,7 +250,7 @@ pub enum Function {
|
||||
}
|
||||
|
||||
impl Function {
|
||||
pub fn into_iter() -> IntoIter<Function, 198> {
|
||||
pub fn into_iter() -> IntoIter<Function, 195> {
|
||||
[
|
||||
Function::And,
|
||||
Function::False,
|
||||
@@ -280,9 +277,6 @@ impl Function {
|
||||
Function::Atanh,
|
||||
Function::Abs,
|
||||
Function::Pi,
|
||||
Function::Ln,
|
||||
Function::Log,
|
||||
Function::Log10,
|
||||
Function::Sqrt,
|
||||
Function::Sqrtpi,
|
||||
Function::Atan2,
|
||||
@@ -540,10 +534,6 @@ impl Function {
|
||||
"POWER" => Some(Function::Power),
|
||||
"ATAN2" => Some(Function::Atan2),
|
||||
|
||||
"LN" => Some(Function::Ln),
|
||||
"LOG" => Some(Function::Log),
|
||||
"LOG10" => Some(Function::Log10),
|
||||
|
||||
"MAX" => Some(Function::Max),
|
||||
"MIN" => Some(Function::Min),
|
||||
"PRODUCT" => Some(Function::Product),
|
||||
@@ -744,9 +734,6 @@ impl fmt::Display for Function {
|
||||
Function::Switch => write!(f, "SWITCH"),
|
||||
Function::True => write!(f, "TRUE"),
|
||||
Function::Xor => write!(f, "XOR"),
|
||||
Function::Log => write!(f, "LOG"),
|
||||
Function::Log10 => write!(f, "LOG10"),
|
||||
Function::Ln => write!(f, "LN"),
|
||||
Function::Sin => write!(f, "SIN"),
|
||||
Function::Cos => write!(f, "COS"),
|
||||
Function::Tan => write!(f, "TAN"),
|
||||
@@ -974,9 +961,6 @@ impl Model {
|
||||
Function::True => self.fn_true(args, cell),
|
||||
Function::Xor => self.fn_xor(args, cell),
|
||||
// Math and trigonometry
|
||||
Function::Log => self.fn_log(args, cell),
|
||||
Function::Log10 => self.fn_log10(args, cell),
|
||||
Function::Ln => self.fn_ln(args, cell),
|
||||
Function::Sin => self.fn_sin(args, cell),
|
||||
Function::Cos => self.fn_cos(args, cell),
|
||||
Function::Tan => self.fn_tan(args, cell),
|
||||
|
||||
@@ -350,7 +350,7 @@ impl Model {
|
||||
// FIXME: This function shares a lot of code with apply_ifs. Can we merge them?
|
||||
pub(crate) fn fn_countifs(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
|
||||
let args_count = args.len();
|
||||
if args_count < 2 || !args_count.is_multiple_of(2) {
|
||||
if args_count < 2 || args_count % 2 == 1 {
|
||||
return CalcResult::new_args_number_error(cell);
|
||||
}
|
||||
|
||||
@@ -476,7 +476,7 @@ impl Model {
|
||||
F: FnMut(f64),
|
||||
{
|
||||
let args_count = args.len();
|
||||
if args_count < 3 || args_count.is_multiple_of(2) {
|
||||
if args_count < 3 || args_count % 2 == 0 {
|
||||
return Err(CalcResult::new_args_number_error(cell));
|
||||
}
|
||||
let arg_0 = self.evaluate_node_in_context(&args[0], cell);
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
use std::{collections::HashMap, sync::OnceLock};
|
||||
use std::collections::HashMap;
|
||||
|
||||
use bitcode::{Decode, Encode};
|
||||
use once_cell::sync::Lazy;
|
||||
|
||||
#[derive(Encode, Decode, Clone)]
|
||||
pub struct Booleans {
|
||||
@@ -30,17 +31,14 @@ pub struct Language {
|
||||
pub errors: Errors,
|
||||
}
|
||||
|
||||
static LANGUAGES: OnceLock<HashMap<String, Language>> = OnceLock::new();
|
||||
|
||||
#[allow(clippy::expect_used)]
|
||||
fn get_languages() -> &'static HashMap<String, Language> {
|
||||
LANGUAGES.get_or_init(|| {
|
||||
bitcode::decode(include_bytes!("language.bin")).expect("Failed parsing language file")
|
||||
})
|
||||
}
|
||||
static LANGUAGES: Lazy<HashMap<String, Language>> = Lazy::new(|| {
|
||||
bitcode::decode(include_bytes!("language.bin")).expect("Failed parsing language file")
|
||||
});
|
||||
|
||||
pub fn get_language(id: &str) -> Result<&Language, String> {
|
||||
get_languages()
|
||||
let language = LANGUAGES
|
||||
.get(id)
|
||||
.ok_or_else(|| format!("Language is not supported: '{id}'"))
|
||||
.ok_or(format!("Language is not supported: '{id}'"))?;
|
||||
Ok(language)
|
||||
}
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
use std::{collections::HashMap, sync::OnceLock};
|
||||
|
||||
use bitcode::{Decode, Encode};
|
||||
use once_cell::sync::Lazy;
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
#[derive(Encode, Decode, Clone)]
|
||||
pub struct Locale {
|
||||
@@ -64,17 +65,12 @@ pub struct DecimalFormats {
|
||||
pub standard: String,
|
||||
}
|
||||
|
||||
static LOCALES: OnceLock<HashMap<String, Locale>> = OnceLock::new();
|
||||
|
||||
#[allow(clippy::expect_used)]
|
||||
fn get_locales() -> &'static HashMap<String, Locale> {
|
||||
LOCALES.get_or_init(|| {
|
||||
bitcode::decode(include_bytes!("locales.bin")).expect("Failed parsing locale")
|
||||
})
|
||||
}
|
||||
static LOCALES: Lazy<HashMap<String, Locale>> =
|
||||
Lazy::new(|| bitcode::decode(include_bytes!("locales.bin")).expect("Failed parsing locale"));
|
||||
|
||||
pub fn get_locale(id: &str) -> Result<&Locale, String> {
|
||||
get_locales()
|
||||
.get(id)
|
||||
.ok_or_else(|| format!("Invalid locale: '{id}'"))
|
||||
// TODO: pass the locale once we implement locales in Rust
|
||||
let locale = LOCALES.get(id).ok_or("Invalid locale")?;
|
||||
Ok(locale)
|
||||
}
|
||||
|
||||
@@ -55,16 +55,12 @@ mod test_arrays;
|
||||
mod test_escape_quotes;
|
||||
mod test_extend;
|
||||
mod test_fn_fv;
|
||||
mod test_fn_round;
|
||||
mod test_fn_type;
|
||||
mod test_frozen_rows_and_columns;
|
||||
mod test_geomean;
|
||||
mod test_get_cell_content;
|
||||
mod test_implicit_intersection;
|
||||
mod test_issue_155;
|
||||
mod test_ln;
|
||||
mod test_log;
|
||||
mod test_log10;
|
||||
mod test_percentage;
|
||||
mod test_set_functions_error_handling;
|
||||
mod test_today;
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::constants::{DEFAULT_ROW_HEIGHT, LAST_COLUMN, LAST_ROW};
|
||||
use crate::constants::{DEFAULT_ROW_HEIGHT, LAST_COLUMN};
|
||||
use crate::model::Model;
|
||||
use crate::test::util::new_empty_model;
|
||||
use crate::types::Col;
|
||||
@@ -508,10 +508,6 @@ fn test_move_column_right() {
|
||||
assert_eq!(model._get_formula("E5"), "=SUM(H3:J7)");
|
||||
assert_eq!(model._get_formula("E6"), "=SUM(H3:H7)");
|
||||
assert_eq!(model._get_formula("E7"), "=SUM(G3:G7)");
|
||||
|
||||
// Data moved as well
|
||||
assert_eq!(model._get_text("G1"), "1");
|
||||
assert_eq!(model._get_text("H1"), "3");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -536,249 +532,5 @@ fn tets_move_column_error() {
|
||||
assert!(result.is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_move_row_down() {
|
||||
let mut model = new_empty_model();
|
||||
populate_table(&mut model);
|
||||
// Formulas referencing rows 3 and 4
|
||||
model._set("E3", "=G3");
|
||||
model._set("E4", "=G4");
|
||||
model._set("E5", "=SUM(G3:J3)");
|
||||
model._set("E6", "=SUM(G3:G3)");
|
||||
model._set("E7", "=SUM(G4:G4)");
|
||||
model.evaluate();
|
||||
|
||||
// Move row 3 down by one position
|
||||
let result = model.move_row_action(0, 3, 1);
|
||||
assert!(result.is_ok());
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_formula("E3"), "=G3");
|
||||
assert_eq!(model._get_formula("E4"), "=G4");
|
||||
assert_eq!(model._get_formula("E5"), "=SUM(G4:J4)");
|
||||
assert_eq!(model._get_formula("E6"), "=SUM(G4:G4)");
|
||||
assert_eq!(model._get_formula("E7"), "=SUM(G3:G3)");
|
||||
|
||||
// Data moved as well
|
||||
assert_eq!(model._get_text("G4"), "-2");
|
||||
assert_eq!(model._get_text("G3"), "");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_move_row_up() {
|
||||
let mut model = new_empty_model();
|
||||
populate_table(&mut model);
|
||||
// Formulas referencing rows 4 and 5
|
||||
model._set("E4", "=G4");
|
||||
model._set("E5", "=G5");
|
||||
model._set("E6", "=SUM(G4:J4)");
|
||||
model._set("E7", "=SUM(G4:G4)");
|
||||
model._set("E8", "=SUM(G5:G5)");
|
||||
model.evaluate();
|
||||
|
||||
// Move row 5 up by one position
|
||||
let result = model.move_row_action(0, 5, -1);
|
||||
assert!(result.is_ok());
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_formula("E4"), "=G4");
|
||||
assert_eq!(model._get_formula("E5"), "=G5");
|
||||
assert_eq!(model._get_formula("E6"), "=SUM(G5:J5)");
|
||||
assert_eq!(model._get_formula("E7"), "=SUM(G5:G5)");
|
||||
assert_eq!(model._get_formula("E8"), "=SUM(G4:G4)");
|
||||
|
||||
// Data moved as well
|
||||
assert_eq!(model._get_text("G4"), "");
|
||||
assert_eq!(model._get_text("G5"), "");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_move_row_error() {
|
||||
let mut model = new_empty_model();
|
||||
model.evaluate();
|
||||
|
||||
let result = model.move_row_action(0, 7, -10);
|
||||
assert!(result.is_err());
|
||||
|
||||
let result = model.move_row_action(0, -7, 20);
|
||||
assert!(result.is_err());
|
||||
|
||||
let result = model.move_row_action(0, LAST_ROW, 1);
|
||||
assert!(result.is_err());
|
||||
|
||||
let result = model.move_row_action(0, LAST_ROW + 1, -10);
|
||||
assert!(result.is_err());
|
||||
|
||||
// This works
|
||||
let result = model.move_row_action(0, LAST_ROW, -1);
|
||||
assert!(result.is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_move_row_down_absolute_refs() {
|
||||
let mut model = new_empty_model();
|
||||
populate_table(&mut model);
|
||||
// Absolute references
|
||||
model._set("E3", "=$G$3");
|
||||
model._set("E4", "=$G$4");
|
||||
model._set("E5", "=SUM($G$3:$J$3)");
|
||||
model._set("E6", "=SUM($G$3:$G$3)");
|
||||
model._set("E7", "=SUM($G$4:$G$4)");
|
||||
model.evaluate();
|
||||
|
||||
assert!(model.move_row_action(0, 3, 1).is_ok());
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_formula("E3"), "=$G$3");
|
||||
assert_eq!(model._get_formula("E4"), "=$G$4");
|
||||
assert_eq!(model._get_formula("E5"), "=SUM($G$4:$J$4)");
|
||||
assert_eq!(model._get_formula("E6"), "=SUM($G$4:$G$4)");
|
||||
assert_eq!(model._get_formula("E7"), "=SUM($G$3:$G$3)");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_move_column_right_absolute_refs() {
|
||||
let mut model = new_empty_model();
|
||||
populate_table(&mut model);
|
||||
// Absolute references
|
||||
model._set("E3", "=$G$3");
|
||||
model._set("E4", "=$H$3");
|
||||
model._set("E5", "=SUM($G$3:$J$7)");
|
||||
model._set("E6", "=SUM($G$3:$G$7)");
|
||||
model._set("E7", "=SUM($H$3:$H$7)");
|
||||
model.evaluate();
|
||||
|
||||
assert!(model.move_column_action(0, 7, 1).is_ok());
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_formula("E3"), "=$H$3");
|
||||
assert_eq!(model._get_formula("E4"), "=$G$3");
|
||||
assert_eq!(model._get_formula("E5"), "=SUM($H$3:$J$7)");
|
||||
assert_eq!(model._get_formula("E6"), "=SUM($H$3:$H$7)");
|
||||
assert_eq!(model._get_formula("E7"), "=SUM($G$3:$G$7)");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_move_row_down_mixed_refs() {
|
||||
let mut model = new_empty_model();
|
||||
populate_table(&mut model);
|
||||
model._set("E3", "=$G3"); // absolute col, relative row
|
||||
model._set("E4", "=$G4");
|
||||
model._set("E5", "=SUM($G3:$J3)");
|
||||
model._set("E6", "=SUM($G3:$G3)");
|
||||
model._set("E7", "=SUM($G4:$G4)");
|
||||
model._set("F3", "=H$3"); // relative col, absolute row
|
||||
model._set("F4", "=G$3");
|
||||
model.evaluate();
|
||||
|
||||
assert!(model.move_row_action(0, 3, 1).is_ok());
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_formula("E3"), "=$G3");
|
||||
assert_eq!(model._get_formula("E4"), "=$G4");
|
||||
assert_eq!(model._get_formula("E5"), "=SUM($G4:$J4)");
|
||||
assert_eq!(model._get_formula("E6"), "=SUM($G4:$G4)");
|
||||
assert_eq!(model._get_formula("E7"), "=SUM($G3:$G3)");
|
||||
assert_eq!(model._get_formula("F3"), "=G$4");
|
||||
assert_eq!(model._get_formula("F4"), "=H$4");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_move_column_right_mixed_refs() {
|
||||
let mut model = new_empty_model();
|
||||
populate_table(&mut model);
|
||||
model._set("E3", "=$G3");
|
||||
model._set("E4", "=$H3");
|
||||
model._set("E5", "=SUM($G3:$J7)");
|
||||
model._set("E6", "=SUM($G3:$G7)");
|
||||
model._set("E7", "=SUM($H3:$H7)");
|
||||
model._set("F3", "=H$3");
|
||||
model._set("F4", "=H$3");
|
||||
model.evaluate();
|
||||
|
||||
assert!(model.move_column_action(0, 7, 1).is_ok());
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_formula("E3"), "=$H3");
|
||||
assert_eq!(model._get_formula("E4"), "=$G3");
|
||||
assert_eq!(model._get_formula("E5"), "=SUM($H3:$J7)");
|
||||
assert_eq!(model._get_formula("E6"), "=SUM($H3:$H7)");
|
||||
assert_eq!(model._get_formula("E7"), "=SUM($G3:$G7)");
|
||||
assert_eq!(model._get_formula("F3"), "=G$3");
|
||||
assert_eq!(model._get_formula("F4"), "=G$3");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_move_row_height() {
|
||||
let mut model = new_empty_model();
|
||||
let sheet = 0;
|
||||
let custom_height = DEFAULT_ROW_HEIGHT * 2.0;
|
||||
// Set a custom height for row 3
|
||||
model
|
||||
.workbook
|
||||
.worksheet_mut(sheet)
|
||||
.unwrap()
|
||||
.set_row_height(3, custom_height)
|
||||
.unwrap();
|
||||
|
||||
// Record the original height of row 4 (should be the default)
|
||||
let original_row4_height = model.get_row_height(sheet, 4).unwrap();
|
||||
|
||||
// Move row 3 down by one position
|
||||
assert!(model.move_row_action(sheet, 3, 1).is_ok());
|
||||
|
||||
// The custom height should now be on row 4
|
||||
assert_eq!(model.get_row_height(sheet, 4), Ok(custom_height));
|
||||
|
||||
// Row 3 should now have the previous height of row 4
|
||||
assert_eq!(model.get_row_height(sheet, 3), Ok(original_row4_height));
|
||||
}
|
||||
|
||||
/// Moving a row down by two positions should shift formulas on intermediate
|
||||
/// rows by only one (the row that gets skipped), not by the full delta ‒ this
|
||||
/// guards against the regression fixed in the RowMove displacement logic.
|
||||
#[test]
|
||||
fn test_row_move_down_two_updates_intermediate_refs_by_one() {
|
||||
let mut model = new_empty_model();
|
||||
populate_table(&mut model);
|
||||
// Set up formulas to verify intermediate rows shift by 1 (not full delta).
|
||||
model._set("E3", "=G3"); // target row
|
||||
model._set("E4", "=G4"); // intermediate row
|
||||
model._set("E5", "=SUM(G3:J3)");
|
||||
model.evaluate();
|
||||
|
||||
// Move row 3 down by two positions (row 3 -> row 5)
|
||||
assert!(model.move_row_action(0, 3, 2).is_ok());
|
||||
model.evaluate();
|
||||
|
||||
// Assert that references for the moved row and intermediate row are correct.
|
||||
assert_eq!(model._get_formula("E3"), "=G3");
|
||||
assert_eq!(model._get_formula("E5"), "=G5");
|
||||
assert_eq!(model._get_formula("E4"), "=SUM(G5:J5)");
|
||||
}
|
||||
|
||||
/// Moving a column right by two positions should shift formulas on
|
||||
/// intermediate columns by only one, ensuring the ColumnMove displacement
|
||||
/// logic handles multi-position moves correctly.
|
||||
#[test]
|
||||
fn test_column_move_right_two_updates_intermediate_refs_by_one() {
|
||||
let mut model = new_empty_model();
|
||||
populate_table(&mut model);
|
||||
// Set up formulas to verify intermediate columns shift by 1 (not full delta).
|
||||
model._set("E3", "=$G3"); // target column
|
||||
model._set("E4", "=$H3"); // intermediate column
|
||||
model._set("E5", "=SUM($G3:$J7)");
|
||||
model.evaluate();
|
||||
|
||||
// Move column G (7) right by two positions (G -> I)
|
||||
assert!(model.move_column_action(0, 7, 2).is_ok());
|
||||
model.evaluate();
|
||||
|
||||
// Assert that references for moved and intermediate columns are correct.
|
||||
assert_eq!(model._get_formula("E3"), "=$I3");
|
||||
assert_eq!(model._get_formula("E4"), "=$G3");
|
||||
assert_eq!(model._get_formula("E5"), "=SUM($I3:$J7)");
|
||||
}
|
||||
|
||||
// A B C D E F G H I J K L M N O P Q R
|
||||
// 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
|
||||
|
||||
@@ -1,15 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn fn_round_approximation() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=ROUND(1.05*(0.0284+0.0046)-0.0284,4)");
|
||||
model._set("A2", "=ROUNDDOWN(1.05*(0.0284+0.0046)-0.0284,5)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"0.0063");
|
||||
assert_eq!(model._get_text("A2"), *"0.00625");
|
||||
}
|
||||
@@ -1,17 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn arguments() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=LN(100)");
|
||||
model._set("A2", "=LN()");
|
||||
model._set("A3", "=LN(100, 10)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"4.605170186");
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
}
|
||||
@@ -1,19 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn arguments() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=LOG(100)");
|
||||
model._set("A2", "=LOG()");
|
||||
model._set("A3", "=LOG(10000, 10)");
|
||||
model._set("A4", "=LOG(100, 10, 1)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"2");
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A3"), *"4");
|
||||
assert_eq!(model._get_text("A4"), *"#ERROR!");
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::test::util::new_empty_model;
|
||||
|
||||
#[test]
|
||||
fn arguments() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=LOG10(100)");
|
||||
model._set("A2", "=LOG10()");
|
||||
model._set("A3", "=LOG10(100, 10)");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"2");
|
||||
assert_eq!(model._get_text("A2"), *"#ERROR!");
|
||||
assert_eq!(model._get_text("A3"), *"#ERROR!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cell_and_function() {
|
||||
let mut model = new_empty_model();
|
||||
model._set("A1", "=LOG10");
|
||||
|
||||
model.evaluate();
|
||||
|
||||
// This is the cell LOG10
|
||||
assert_eq!(model._get_text("A1"), *"0");
|
||||
|
||||
model._set("LOG10", "1000");
|
||||
model._set("A2", "=LOG10(LOG10)");
|
||||
model.evaluate();
|
||||
|
||||
assert_eq!(model._get_text("A1"), *"1000");
|
||||
assert_eq!(model._get_text("A2"), *"3");
|
||||
}
|
||||
@@ -1,7 +1,6 @@
|
||||
mod test_add_delete_sheets;
|
||||
mod test_autofill_columns;
|
||||
mod test_autofill_rows;
|
||||
mod test_batch_row_column_diff;
|
||||
mod test_border;
|
||||
mod test_clear_cells;
|
||||
mod test_column_style;
|
||||
@@ -12,8 +11,6 @@ mod test_evaluation;
|
||||
mod test_general;
|
||||
mod test_grid_lines;
|
||||
mod test_keyboard_navigation;
|
||||
mod test_last_empty_cell;
|
||||
mod test_multi_row_column;
|
||||
mod test_on_area_selection;
|
||||
mod test_on_expand_selected_range;
|
||||
mod test_on_paste_styles;
|
||||
|
||||
@@ -1,675 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
#![allow(clippy::panic)]
|
||||
|
||||
use bitcode::decode;
|
||||
|
||||
use crate::{
|
||||
constants::{LAST_COLUMN, LAST_ROW},
|
||||
test::util::new_empty_model,
|
||||
user_model::history::{Diff, QueueDiffs},
|
||||
UserModel,
|
||||
};
|
||||
|
||||
fn last_diff_list(model: &mut UserModel) -> Vec<Diff> {
|
||||
let bytes = model.flush_send_queue();
|
||||
let queue: Vec<QueueDiffs> = decode(&bytes).unwrap();
|
||||
// Get the last operation's diff list
|
||||
queue.last().unwrap().list.clone()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn diff_invariant_insert_rows() {
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
assert!(model.insert_rows(0, 5, 3).is_ok());
|
||||
|
||||
let list = last_diff_list(&mut model);
|
||||
assert_eq!(list.len(), 1);
|
||||
assert!(matches!(
|
||||
&list[0],
|
||||
Diff::InsertRows {
|
||||
sheet: 0,
|
||||
row: 5,
|
||||
count: 3
|
||||
}
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn diff_invariant_insert_columns() {
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
assert!(model.insert_columns(0, 2, 4).is_ok());
|
||||
let list = last_diff_list(&mut model);
|
||||
assert_eq!(list.len(), 1);
|
||||
assert!(matches!(
|
||||
&list[0],
|
||||
Diff::InsertColumns {
|
||||
sheet: 0,
|
||||
column: 2,
|
||||
count: 4
|
||||
}
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn undo_redo_after_batch_delete() {
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Place values that will shift.
|
||||
model.set_user_input(0, 20, 1, "A").unwrap();
|
||||
model.set_user_input(0, 1, 20, "B").unwrap();
|
||||
|
||||
// Fill some of the rows we are about to delete for testing
|
||||
for r in 10..15 {
|
||||
model.set_user_input(0, r, 1, "tmp").unwrap();
|
||||
}
|
||||
|
||||
// Delete rows 10..14 and columns 5..8
|
||||
assert!(model.delete_rows(0, 10, 5).is_ok());
|
||||
assert!(model.delete_columns(0, 5, 4).is_ok());
|
||||
|
||||
// Verify shift
|
||||
assert_eq!(model.get_formatted_cell_value(0, 15, 1).unwrap(), "A");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 16).unwrap(), "B");
|
||||
|
||||
// Undo
|
||||
model.undo().unwrap(); // columns
|
||||
model.undo().unwrap(); // rows
|
||||
assert_eq!(model.get_formatted_cell_value(0, 20, 1).unwrap(), "A");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 20).unwrap(), "B");
|
||||
|
||||
// Redo
|
||||
model.redo().unwrap(); // rows
|
||||
model.redo().unwrap(); // columns
|
||||
assert_eq!(model.get_formatted_cell_value(0, 15, 1).unwrap(), "A");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 16).unwrap(), "B");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn diff_order_delete_rows() {
|
||||
// Verifies that delete diffs are generated with all data preserved
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Populate rows to delete
|
||||
for r in 5..10 {
|
||||
model.set_user_input(0, r, 1, &r.to_string()).unwrap();
|
||||
}
|
||||
|
||||
assert!(model.delete_rows(0, 5, 5).is_ok());
|
||||
|
||||
let list = last_diff_list(&mut model);
|
||||
assert_eq!(list.len(), 1);
|
||||
|
||||
// Should have one bulk diff with all the row data
|
||||
match &list[0] {
|
||||
Diff::DeleteRows {
|
||||
sheet,
|
||||
row,
|
||||
count,
|
||||
old_data,
|
||||
} => {
|
||||
assert_eq!(*sheet, 0);
|
||||
assert_eq!(*row, 5);
|
||||
assert_eq!(*count, 5);
|
||||
assert_eq!(old_data.len(), 5);
|
||||
// Verify the data was collected for each row
|
||||
for (i, row_data) in old_data.iter().enumerate() {
|
||||
let _expected_value = (5 + i).to_string();
|
||||
assert!(row_data.data.contains_key(&1));
|
||||
}
|
||||
}
|
||||
_ => panic!("Unexpected diff variant"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn batch_operations_with_formulas() {
|
||||
// Verifies formulas update correctly after batch ops
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
model.set_user_input(0, 1, 1, "10").unwrap();
|
||||
model.set_user_input(0, 5, 1, "=A1*2").unwrap(); // Will become A3 after insert
|
||||
|
||||
assert!(model.insert_rows(0, 2, 2).is_ok());
|
||||
|
||||
// Formula should now reference A1 (unchanged) but be in row 7
|
||||
assert_eq!(model.get_formatted_cell_value(0, 7, 1).unwrap(), "20");
|
||||
assert_eq!(model.get_cell_content(0, 7, 1).unwrap(), "=A1*2");
|
||||
|
||||
// Undo and verify formula is back at original position
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "20");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn edge_case_single_operation() {
|
||||
// Single row/column operations should still work correctly
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
assert!(model.insert_rows(0, 1, 1).is_ok());
|
||||
let list = last_diff_list(&mut model);
|
||||
assert_eq!(list.len(), 1);
|
||||
|
||||
assert!(model.insert_columns(0, 1, 1).is_ok());
|
||||
let list = last_diff_list(&mut model);
|
||||
assert_eq!(list.len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delete_empty_rows() {
|
||||
// Delete multiple empty rows and verify behavior
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Set data in rows 1 and 10, leaving rows 5-8 empty
|
||||
model.set_user_input(0, 1, 1, "Before").unwrap();
|
||||
model.set_user_input(0, 10, 1, "After").unwrap();
|
||||
|
||||
// Delete empty rows 5-8
|
||||
assert!(model.delete_rows(0, 5, 4).is_ok());
|
||||
|
||||
// Verify shift
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "Before");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 6, 1).unwrap(), "After");
|
||||
|
||||
// Verify diffs now use bulk operation
|
||||
let list = last_diff_list(&mut model);
|
||||
assert_eq!(list.len(), 1);
|
||||
match &list[0] {
|
||||
Diff::DeleteRows {
|
||||
sheet,
|
||||
row,
|
||||
count,
|
||||
old_data,
|
||||
} => {
|
||||
assert_eq!(*sheet, 0);
|
||||
assert_eq!(*row, 5);
|
||||
assert_eq!(*count, 4);
|
||||
assert_eq!(old_data.len(), 4);
|
||||
// All rows should be empty
|
||||
for row_data in old_data {
|
||||
assert!(row_data.data.is_empty());
|
||||
}
|
||||
}
|
||||
_ => panic!("Unexpected diff variant"),
|
||||
}
|
||||
|
||||
// Undo/redo
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 10, 1).unwrap(), "After");
|
||||
model.redo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 6, 1).unwrap(), "After");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delete_mixed_empty_and_filled_rows() {
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Alternating filled and empty rows
|
||||
model.set_user_input(0, 5, 1, "Row5").unwrap();
|
||||
model.set_user_input(0, 7, 1, "Row7").unwrap();
|
||||
model.set_user_input(0, 9, 1, "Row9").unwrap();
|
||||
model.set_user_input(0, 10, 1, "After").unwrap();
|
||||
|
||||
assert!(model.delete_rows(0, 5, 5).is_ok());
|
||||
assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "After");
|
||||
|
||||
// Verify mix of empty and filled row diffs
|
||||
let list = last_diff_list(&mut model);
|
||||
assert_eq!(list.len(), 1);
|
||||
match &list[0] {
|
||||
Diff::DeleteRows {
|
||||
sheet,
|
||||
row,
|
||||
count,
|
||||
old_data,
|
||||
} => {
|
||||
assert_eq!(*sheet, 0);
|
||||
assert_eq!(*row, 5);
|
||||
assert_eq!(*count, 5);
|
||||
assert_eq!(old_data.len(), 5);
|
||||
|
||||
// Count filled rows (should be 3: rows 5, 7, 9)
|
||||
let filled_count = old_data
|
||||
.iter()
|
||||
.filter(|row_data| !row_data.data.is_empty())
|
||||
.count();
|
||||
assert_eq!(filled_count, 3);
|
||||
}
|
||||
_ => panic!("Unexpected diff variant"),
|
||||
}
|
||||
|
||||
// Undo
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "Row5");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 7, 1).unwrap(), "Row7");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 9, 1).unwrap(), "Row9");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 10, 1).unwrap(), "After");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bulk_insert_rows_undo_redo() {
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Set up initial data
|
||||
model.set_user_input(0, 1, 1, "A1").unwrap();
|
||||
model.set_user_input(0, 2, 1, "A2").unwrap();
|
||||
model.set_user_input(0, 5, 1, "A5").unwrap();
|
||||
|
||||
// Insert 3 rows at position 3
|
||||
assert!(model.insert_rows(0, 3, 3).is_ok());
|
||||
|
||||
// Verify data has shifted
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "A1");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 2, 1).unwrap(), "A2");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 8, 1).unwrap(), "A5"); // A5 moved to A8
|
||||
|
||||
// Check diff structure
|
||||
let list = last_diff_list(&mut model);
|
||||
assert_eq!(list.len(), 1);
|
||||
assert!(matches!(
|
||||
&list[0],
|
||||
Diff::InsertRows {
|
||||
sheet: 0,
|
||||
row: 3,
|
||||
count: 3
|
||||
}
|
||||
));
|
||||
|
||||
// Undo
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "A5"); // Back to original position
|
||||
|
||||
// Redo
|
||||
model.redo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 8, 1).unwrap(), "A5"); // Shifted again
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bulk_insert_columns_undo_redo() {
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Set up initial data
|
||||
model.set_user_input(0, 1, 1, "A1").unwrap();
|
||||
model.set_user_input(0, 1, 2, "B1").unwrap();
|
||||
model.set_user_input(0, 1, 5, "E1").unwrap();
|
||||
|
||||
// Insert 3 columns at position 3
|
||||
assert!(model.insert_columns(0, 3, 3).is_ok());
|
||||
|
||||
// Verify data has shifted
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "A1");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 2).unwrap(), "B1");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 8).unwrap(), "E1"); // E1 moved to H1
|
||||
|
||||
// Check diff structure
|
||||
let list = last_diff_list(&mut model);
|
||||
assert_eq!(list.len(), 1);
|
||||
assert!(matches!(
|
||||
&list[0],
|
||||
Diff::InsertColumns {
|
||||
sheet: 0,
|
||||
column: 3,
|
||||
count: 3
|
||||
}
|
||||
));
|
||||
|
||||
// Undo
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 5).unwrap(), "E1"); // Back to original position
|
||||
|
||||
// Redo
|
||||
model.redo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 8).unwrap(), "E1"); // Shifted again
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bulk_delete_rows_round_trip() {
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Set up data with styles
|
||||
model.set_user_input(0, 3, 1, "Row3").unwrap();
|
||||
model.set_user_input(0, 4, 1, "Row4").unwrap();
|
||||
model.set_user_input(0, 5, 1, "Row5").unwrap();
|
||||
model.set_user_input(0, 6, 1, "Row6").unwrap();
|
||||
model.set_user_input(0, 7, 1, "After").unwrap();
|
||||
|
||||
// Set some row heights to verify they're preserved
|
||||
model.set_rows_height(0, 4, 4, 30.0).unwrap();
|
||||
model.set_rows_height(0, 5, 5, 40.0).unwrap();
|
||||
|
||||
// Delete rows 3-6
|
||||
assert!(model.delete_rows(0, 3, 4).is_ok());
|
||||
|
||||
// Verify deletion
|
||||
assert_eq!(model.get_formatted_cell_value(0, 3, 1).unwrap(), "After");
|
||||
|
||||
// Check diff structure
|
||||
let list = last_diff_list(&mut model);
|
||||
assert_eq!(list.len(), 1);
|
||||
match &list[0] {
|
||||
Diff::DeleteRows {
|
||||
sheet,
|
||||
row,
|
||||
count,
|
||||
old_data,
|
||||
} => {
|
||||
assert_eq!(*sheet, 0);
|
||||
assert_eq!(*row, 3);
|
||||
assert_eq!(*count, 4);
|
||||
assert_eq!(old_data.len(), 4);
|
||||
// Verify data was preserved
|
||||
assert!(old_data[0].data.contains_key(&1)); // Row3
|
||||
assert!(old_data[1].data.contains_key(&1)); // Row4
|
||||
assert!(old_data[2].data.contains_key(&1)); // Row5
|
||||
assert!(old_data[3].data.contains_key(&1)); // Row6
|
||||
}
|
||||
_ => panic!("Expected DeleteRows diff"),
|
||||
}
|
||||
|
||||
// Undo - should restore all data and row heights
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 3, 1).unwrap(), "Row3");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 4, 1).unwrap(), "Row4");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "Row5");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 6, 1).unwrap(), "Row6");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 7, 1).unwrap(), "After");
|
||||
assert_eq!(model.get_row_height(0, 4).unwrap(), 30.0);
|
||||
assert_eq!(model.get_row_height(0, 5).unwrap(), 40.0);
|
||||
|
||||
// Redo - should delete again
|
||||
model.redo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 3, 1).unwrap(), "After");
|
||||
|
||||
// Final undo to verify round-trip
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 3, 1).unwrap(), "Row3");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 4, 1).unwrap(), "Row4");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 5, 1).unwrap(), "Row5");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 6, 1).unwrap(), "Row6");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bulk_delete_columns_round_trip() {
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Set up data with styles
|
||||
model.set_user_input(0, 1, 3, "C1").unwrap();
|
||||
model.set_user_input(0, 1, 4, "D1").unwrap();
|
||||
model.set_user_input(0, 1, 5, "E1").unwrap();
|
||||
model.set_user_input(0, 1, 6, "F1").unwrap();
|
||||
model.set_user_input(0, 1, 7, "After").unwrap();
|
||||
|
||||
// Set some column widths to verify they're preserved
|
||||
model.set_columns_width(0, 4, 4, 100.0).unwrap();
|
||||
model.set_columns_width(0, 5, 5, 120.0).unwrap();
|
||||
|
||||
// Delete columns 3-6
|
||||
assert!(model.delete_columns(0, 3, 4).is_ok());
|
||||
|
||||
// Verify deletion
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 3).unwrap(), "After");
|
||||
|
||||
// Check diff structure
|
||||
let list = last_diff_list(&mut model);
|
||||
assert_eq!(list.len(), 1);
|
||||
match &list[0] {
|
||||
Diff::DeleteColumns {
|
||||
sheet,
|
||||
column,
|
||||
count,
|
||||
old_data,
|
||||
} => {
|
||||
assert_eq!(*sheet, 0);
|
||||
assert_eq!(*column, 3);
|
||||
assert_eq!(*count, 4);
|
||||
assert_eq!(old_data.len(), 4);
|
||||
// Verify data was preserved
|
||||
assert!(old_data[0].data.contains_key(&1)); // C1
|
||||
assert!(old_data[1].data.contains_key(&1)); // D1
|
||||
assert!(old_data[2].data.contains_key(&1)); // E1
|
||||
assert!(old_data[3].data.contains_key(&1)); // F1
|
||||
}
|
||||
_ => panic!("Expected DeleteColumns diff"),
|
||||
}
|
||||
|
||||
// Undo - should restore all data and column widths
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 3).unwrap(), "C1");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 4).unwrap(), "D1");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 5).unwrap(), "E1");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 6).unwrap(), "F1");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 7).unwrap(), "After");
|
||||
assert_eq!(model.get_column_width(0, 4).unwrap(), 100.0);
|
||||
assert_eq!(model.get_column_width(0, 5).unwrap(), 120.0);
|
||||
|
||||
// Redo - should delete again
|
||||
model.redo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 3).unwrap(), "After");
|
||||
|
||||
// Final undo to verify round-trip
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 3).unwrap(), "C1");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 4).unwrap(), "D1");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 5).unwrap(), "E1");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 6).unwrap(), "F1");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn complex_bulk_operations_sequence() {
|
||||
// Test a complex sequence of bulk operations
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Initial setup
|
||||
model.set_user_input(0, 1, 1, "A1").unwrap();
|
||||
model.set_user_input(0, 2, 2, "B2").unwrap();
|
||||
model.set_user_input(0, 3, 3, "C3").unwrap();
|
||||
|
||||
// Operation 1: Insert 2 rows at position 2
|
||||
model.insert_rows(0, 2, 2).unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "A1");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 4, 2).unwrap(), "B2"); // B2 moved down
|
||||
assert_eq!(model.get_formatted_cell_value(0, 5, 3).unwrap(), "C3"); // C3 moved down
|
||||
|
||||
// Operation 2: Insert 2 columns at position 2
|
||||
model.insert_columns(0, 2, 2).unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "A1");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 4, 4).unwrap(), "B2"); // B2 moved right
|
||||
assert_eq!(model.get_formatted_cell_value(0, 5, 5).unwrap(), "C3"); // C3 moved right
|
||||
|
||||
// Operation 3: Delete the inserted rows
|
||||
model.delete_rows(0, 2, 2).unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 2, 4).unwrap(), "B2");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 3, 5).unwrap(), "C3");
|
||||
|
||||
// Undo all operations
|
||||
model.undo().unwrap(); // Undo delete rows
|
||||
assert_eq!(model.get_formatted_cell_value(0, 4, 4).unwrap(), "B2");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 5, 5).unwrap(), "C3");
|
||||
|
||||
model.undo().unwrap(); // Undo insert columns
|
||||
assert_eq!(model.get_formatted_cell_value(0, 4, 2).unwrap(), "B2");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 5, 3).unwrap(), "C3");
|
||||
|
||||
model.undo().unwrap(); // Undo insert rows
|
||||
assert_eq!(model.get_formatted_cell_value(0, 2, 2).unwrap(), "B2");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 3, 3).unwrap(), "C3");
|
||||
|
||||
// Redo all operations
|
||||
model.redo().unwrap(); // Redo insert rows
|
||||
model.redo().unwrap(); // Redo insert columns
|
||||
model.redo().unwrap(); // Redo delete rows
|
||||
assert_eq!(model.get_formatted_cell_value(0, 2, 4).unwrap(), "B2");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 3, 5).unwrap(), "C3");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bulk_operations_with_formulas_update() {
|
||||
// Test that formulas update correctly with bulk operations
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Set up data and formulas
|
||||
model.set_user_input(0, 1, 1, "10").unwrap();
|
||||
model.set_user_input(0, 5, 1, "20").unwrap();
|
||||
model.set_user_input(0, 10, 1, "=A1+A5").unwrap(); // Formula referencing A1 and A5
|
||||
|
||||
// Insert 3 rows at position 3
|
||||
model.insert_rows(0, 3, 3).unwrap();
|
||||
|
||||
// Formula should update to reference the shifted cells
|
||||
assert_eq!(model.get_formatted_cell_value(0, 13, 1).unwrap(), "30"); // Formula moved down
|
||||
assert_eq!(model.get_cell_content(0, 13, 1).unwrap(), "=A1+A8"); // A5 became A8
|
||||
|
||||
// Undo
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 10, 1).unwrap(), "30");
|
||||
assert_eq!(model.get_cell_content(0, 10, 1).unwrap(), "=A1+A5");
|
||||
|
||||
// Now test column insertion
|
||||
model.set_user_input(0, 1, 5, "20").unwrap(); // Add value in E1
|
||||
model.set_user_input(0, 1, 10, "=A1+E1").unwrap();
|
||||
model.insert_columns(0, 3, 2).unwrap();
|
||||
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 12).unwrap(), "30"); // Formula moved right
|
||||
assert_eq!(model.get_cell_content(0, 1, 12).unwrap(), "=A1+G1"); // E1 became G1
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bulk_delete_with_styles() {
|
||||
// Test that cell and row/column styles are preserved
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Set up data with various styles
|
||||
for r in 5..10 {
|
||||
model.set_user_input(0, r, 1, &format!("Row{r}")).unwrap();
|
||||
model.set_rows_height(0, r, r, (r * 10) as f64).unwrap();
|
||||
}
|
||||
|
||||
// Delete and verify style preservation
|
||||
model.delete_rows(0, 5, 5).unwrap();
|
||||
|
||||
// Undo should restore all styles
|
||||
model.undo().unwrap();
|
||||
for r in 5..10 {
|
||||
assert_eq!(
|
||||
model.get_formatted_cell_value(0, r, 1).unwrap(),
|
||||
format!("Row{r}")
|
||||
);
|
||||
assert_eq!(model.get_row_height(0, r).unwrap(), (r * 10) as f64);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bulk_operations_large_count() {
|
||||
// Test operations with large counts
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Insert a large number of rows
|
||||
model.set_user_input(0, 1, 1, "Before").unwrap();
|
||||
model.set_user_input(0, 100, 1, "After").unwrap();
|
||||
|
||||
assert!(model.insert_rows(0, 50, 100).is_ok());
|
||||
|
||||
// Verify shift
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 1).unwrap(), "Before");
|
||||
assert_eq!(model.get_formatted_cell_value(0, 200, 1).unwrap(), "After"); // Moved by 100
|
||||
|
||||
// Check diff
|
||||
let list = last_diff_list(&mut model);
|
||||
assert_eq!(list.len(), 1);
|
||||
assert!(matches!(
|
||||
&list[0],
|
||||
Diff::InsertRows {
|
||||
sheet: 0,
|
||||
row: 50,
|
||||
count: 100
|
||||
}
|
||||
));
|
||||
|
||||
// Undo and redo
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 100, 1).unwrap(), "After");
|
||||
|
||||
model.redo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 200, 1).unwrap(), "After");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bulk_operations_error_cases() {
|
||||
// Test error conditions
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Negative count should fail
|
||||
assert!(model.insert_rows(0, 1, -5).is_err());
|
||||
assert!(model.insert_columns(0, 1, -5).is_err());
|
||||
assert!(model.delete_rows(0, 1, -5).is_err());
|
||||
assert!(model.delete_columns(0, 1, -5).is_err());
|
||||
|
||||
// Zero count should fail
|
||||
assert!(model.insert_rows(0, 1, 0).is_err());
|
||||
assert!(model.insert_columns(0, 1, 0).is_err());
|
||||
assert!(model.delete_rows(0, 1, 0).is_err());
|
||||
assert!(model.delete_columns(0, 1, 0).is_err());
|
||||
|
||||
// Out of bounds operations should fail
|
||||
assert!(model.delete_rows(0, LAST_ROW - 5, 10).is_err());
|
||||
assert!(model.delete_columns(0, LAST_COLUMN - 5, 10).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bulk_diff_serialization() {
|
||||
// Test that bulk diffs can be serialized/deserialized correctly
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Create some data
|
||||
model.set_user_input(0, 1, 1, "Test").unwrap();
|
||||
model.insert_rows(0, 2, 3).unwrap();
|
||||
|
||||
// Flush and get the serialized diffs
|
||||
let bytes = model.flush_send_queue();
|
||||
|
||||
// Create a new model and apply the diffs
|
||||
let base2 = new_empty_model();
|
||||
let mut model2 = UserModel::from_model(base2);
|
||||
|
||||
assert!(model2.apply_external_diffs(&bytes).is_ok());
|
||||
|
||||
// Verify the state matches
|
||||
assert_eq!(model2.get_formatted_cell_value(0, 1, 1).unwrap(), "Test");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn boundary_validation() {
|
||||
let base = new_empty_model();
|
||||
let mut model = UserModel::from_model(base);
|
||||
|
||||
// Test deleting rows beyond valid range
|
||||
assert!(model.delete_rows(0, LAST_ROW, 2).is_err());
|
||||
assert!(model.delete_rows(0, LAST_ROW + 1, 1).is_err());
|
||||
|
||||
// Test deleting columns beyond valid range
|
||||
assert!(model.delete_columns(0, LAST_COLUMN, 2).is_err());
|
||||
assert!(model.delete_columns(0, LAST_COLUMN + 1, 1).is_err());
|
||||
|
||||
// Test valid boundary deletions (should work with our empty row fix)
|
||||
assert!(model.delete_rows(0, LAST_ROW, 1).is_ok());
|
||||
assert!(model.delete_columns(0, LAST_COLUMN, 1).is_ok());
|
||||
}
|
||||
@@ -65,8 +65,8 @@ fn queue_undo_redo_multiple() {
|
||||
model1.set_user_input(0, row, 17, "=ROW()").unwrap();
|
||||
}
|
||||
|
||||
model1.insert_rows(0, 3, 1).unwrap();
|
||||
model1.insert_rows(0, 3, 1).unwrap();
|
||||
model1.insert_row(0, 3).unwrap();
|
||||
model1.insert_row(0, 3).unwrap();
|
||||
|
||||
// undo al of them
|
||||
while model1.can_undo() {
|
||||
|
||||
@@ -62,7 +62,7 @@ fn insert_remove_rows() {
|
||||
assert!(model.set_rows_height(0, 5, 5, 3.0 * height).is_ok());
|
||||
|
||||
// remove the row
|
||||
assert!(model.delete_rows(0, 5, 1).is_ok());
|
||||
assert!(model.delete_row(0, 5).is_ok());
|
||||
// Row 5 has now the normal height
|
||||
assert_eq!(model.get_row_height(0, 5), Ok(height));
|
||||
// There is no value in A5
|
||||
@@ -99,7 +99,7 @@ fn insert_remove_columns() {
|
||||
assert_eq!(model.get_column_width(0, 5).unwrap(), 3.0 * column_width);
|
||||
|
||||
// remove the column
|
||||
assert!(model.delete_columns(0, 5, 1).is_ok());
|
||||
assert!(model.delete_column(0, 5).is_ok());
|
||||
// Column 5 has now the normal width
|
||||
assert_eq!(model.get_column_width(0, 5), Ok(column_width));
|
||||
// There is no value in E5
|
||||
|
||||
@@ -1,55 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::constants::LAST_ROW;
|
||||
use crate::expressions::types::Area;
|
||||
use crate::test::util::new_empty_model;
|
||||
use crate::UserModel;
|
||||
|
||||
#[test]
|
||||
fn basic_tests() {
|
||||
let model = new_empty_model();
|
||||
let mut model = UserModel::from_model(model);
|
||||
// This is the first row, column 5
|
||||
model.set_user_input(0, 3, 5, "todo").unwrap();
|
||||
|
||||
// Row 3 before column 5 should be empty
|
||||
assert_eq!(
|
||||
model
|
||||
.get_last_non_empty_in_row_before_column(0, 3, 4)
|
||||
.unwrap(),
|
||||
None
|
||||
);
|
||||
// Row 3 before column 5 should be 5
|
||||
assert_eq!(
|
||||
model
|
||||
.get_last_non_empty_in_row_before_column(0, 3, 7)
|
||||
.unwrap(),
|
||||
Some(5)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_last_empty_cell() {
|
||||
let model = new_empty_model();
|
||||
let mut model = UserModel::from_model(model);
|
||||
|
||||
let column_g_range = Area {
|
||||
sheet: 0,
|
||||
row: 1,
|
||||
column: 7,
|
||||
width: 1,
|
||||
height: LAST_ROW,
|
||||
};
|
||||
|
||||
model
|
||||
.update_range_style(&column_g_range, "fill.bg_color", "#333444")
|
||||
.unwrap();
|
||||
|
||||
// Column 7 has a style but it is empty
|
||||
assert_eq!(
|
||||
model
|
||||
.get_last_non_empty_in_row_before_column(0, 3, 14)
|
||||
.unwrap(),
|
||||
None
|
||||
);
|
||||
}
|
||||
@@ -1,173 +0,0 @@
|
||||
#![allow(clippy::unwrap_used)]
|
||||
|
||||
use crate::{
|
||||
constants::{LAST_COLUMN, LAST_ROW},
|
||||
test::util::new_empty_model,
|
||||
UserModel,
|
||||
};
|
||||
|
||||
#[test]
|
||||
fn insert_multiple_rows_shifts_cells() {
|
||||
let model = new_empty_model();
|
||||
let mut model = UserModel::from_model(model);
|
||||
// Place a value below the insertion point.
|
||||
model.set_user_input(0, 10, 1, "42").unwrap();
|
||||
|
||||
// Insert 3 rows starting at row 5.
|
||||
assert!(model.insert_rows(0, 5, 3).is_ok());
|
||||
|
||||
// The original value should have moved down by 3 rows.
|
||||
assert_eq!(model.get_formatted_cell_value(0, 13, 1).unwrap(), "42");
|
||||
|
||||
// Undo / redo cycle should restore the same behaviour.
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 10, 1).unwrap(), "42");
|
||||
model.redo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 13, 1).unwrap(), "42");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn insert_rows_errors() {
|
||||
let model = new_empty_model();
|
||||
let mut model = UserModel::from_model(model);
|
||||
|
||||
// Negative or zero counts are rejected.
|
||||
assert_eq!(
|
||||
model.insert_rows(0, 1, -2),
|
||||
Err("Cannot add a negative number of cells :)".to_string())
|
||||
);
|
||||
assert_eq!(
|
||||
model.insert_rows(0, 1, 0),
|
||||
Err("Cannot add a negative number of cells :)".to_string())
|
||||
);
|
||||
|
||||
// Inserting too many rows so that the sheet would overflow.
|
||||
let too_many = LAST_ROW; // This guarantees max_row + too_many > LAST_ROW.
|
||||
assert_eq!(
|
||||
model.insert_rows(0, 1, too_many),
|
||||
Err(
|
||||
"Cannot shift cells because that would delete cells at the end of a column".to_string()
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn insert_multiple_columns_shifts_cells() {
|
||||
let model = new_empty_model();
|
||||
let mut model = UserModel::from_model(model);
|
||||
// Place a value to the right of the insertion point.
|
||||
model.set_user_input(0, 1, 10, "99").unwrap();
|
||||
|
||||
// Insert 3 columns starting at column 5.
|
||||
assert!(model.insert_columns(0, 5, 3).is_ok());
|
||||
|
||||
// The original value should have moved right by 3 columns.
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 13).unwrap(), "99");
|
||||
|
||||
// Undo / redo cycle.
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 10).unwrap(), "99");
|
||||
model.redo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 13).unwrap(), "99");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn insert_columns_errors() {
|
||||
let model = new_empty_model();
|
||||
let mut model = UserModel::from_model(model);
|
||||
|
||||
// Negative or zero counts are rejected.
|
||||
assert_eq!(
|
||||
model.insert_columns(0, 1, -2),
|
||||
Err("Cannot add a negative number of cells :)".to_string())
|
||||
);
|
||||
assert_eq!(
|
||||
model.insert_columns(0, 1, 0),
|
||||
Err("Cannot add a negative number of cells :)".to_string())
|
||||
);
|
||||
|
||||
// Overflow to the right.
|
||||
let too_many = LAST_COLUMN; // Ensures max_column + too_many > LAST_COLUMN
|
||||
assert_eq!(
|
||||
model.insert_columns(0, 1, too_many),
|
||||
Err("Cannot shift cells because that would delete cells at the end of a row".to_string())
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delete_multiple_rows_shifts_cells_upwards() {
|
||||
let model = new_empty_model();
|
||||
let mut model = UserModel::from_model(model);
|
||||
|
||||
// Populate rows 10..14 (to be deleted) so that the diff builder does not fail.
|
||||
for r in 10..15 {
|
||||
model.set_user_input(0, r, 1, "del").unwrap();
|
||||
}
|
||||
// Place a value below the deletion range.
|
||||
model.set_user_input(0, 20, 1, "keep").unwrap();
|
||||
|
||||
// Delete 5 rows starting at row 10.
|
||||
assert!(model.delete_rows(0, 10, 5).is_ok());
|
||||
|
||||
// The value originally at row 20 should now be at row 15.
|
||||
assert_eq!(model.get_formatted_cell_value(0, 15, 1).unwrap(), "keep");
|
||||
|
||||
// Undo / redo cycle.
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 20, 1).unwrap(), "keep");
|
||||
model.redo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 15, 1).unwrap(), "keep");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delete_rows_errors() {
|
||||
let model = new_empty_model();
|
||||
let mut model = UserModel::from_model(model);
|
||||
|
||||
// Negative or zero counts are rejected.
|
||||
assert_eq!(
|
||||
model.delete_rows(0, 1, -3),
|
||||
Err("Please use insert rows instead".to_string())
|
||||
);
|
||||
assert_eq!(
|
||||
model.delete_rows(0, 1, 0),
|
||||
Err("Please use insert rows instead".to_string())
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delete_multiple_columns_shifts_cells_left() {
|
||||
let model = new_empty_model();
|
||||
let mut model = UserModel::from_model(model);
|
||||
|
||||
// Place a value to the right of the deletion range.
|
||||
model.set_user_input(0, 1, 15, "88").unwrap();
|
||||
|
||||
// Delete 4 columns starting at column 5.
|
||||
assert!(model.delete_columns(0, 5, 4).is_ok());
|
||||
|
||||
// The value originally at column 15 should now be at column 11.
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 11).unwrap(), "88");
|
||||
|
||||
// Undo / redo cycle.
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 15).unwrap(), "88");
|
||||
model.redo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 11).unwrap(), "88");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delete_columns_errors() {
|
||||
let model = new_empty_model();
|
||||
let mut model = UserModel::from_model(model);
|
||||
|
||||
// Negative or zero counts are rejected.
|
||||
assert_eq!(
|
||||
model.delete_columns(0, 1, -4),
|
||||
Err("Please use insert columns instead".to_string())
|
||||
);
|
||||
assert_eq!(
|
||||
model.delete_columns(0, 1, 0),
|
||||
Err("Please use insert columns instead".to_string())
|
||||
);
|
||||
}
|
||||
@@ -24,7 +24,6 @@ fn csv_paste() {
|
||||
model.get_formatted_cell_value(0, 7, 7),
|
||||
Ok("21".to_string())
|
||||
);
|
||||
assert_eq!([4, 2, 5, 4], model.get_selected_view().range);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -46,7 +45,6 @@ fn csv_paste_formula() {
|
||||
model.get_formatted_cell_value(0, 1, 1),
|
||||
Ok("2022".to_string())
|
||||
);
|
||||
assert_eq!([1, 1, 1, 1], model.get_selected_view().range);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -71,7 +69,6 @@ fn tsv_crlf_paste() {
|
||||
model.get_formatted_cell_value(0, 7, 7),
|
||||
Ok("21".to_string())
|
||||
);
|
||||
assert_eq!([4, 2, 5, 4], model.get_selected_view().range);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -167,7 +164,7 @@ fn copy_paste_internal() {
|
||||
let copy = model.copy_to_clipboard().unwrap();
|
||||
assert_eq!(
|
||||
copy.csv,
|
||||
"42\t127\n\"A season of faith\t \"\"perfection\"\"\""
|
||||
"42\t127\n\"A season of faith\t \"\"perfection\"\"\"\t\n"
|
||||
);
|
||||
assert_eq!(copy.range, (1, 1, 2, 2));
|
||||
|
||||
|
||||
@@ -14,7 +14,7 @@ fn simple_insert_row() {
|
||||
for row in 1..5 {
|
||||
assert!(model.set_user_input(sheet, row, column, "123").is_ok());
|
||||
}
|
||||
assert!(model.insert_rows(sheet, 3, 1).is_ok());
|
||||
assert!(model.insert_row(sheet, 3).is_ok());
|
||||
assert_eq!(
|
||||
model.get_formatted_cell_value(sheet, 3, column).unwrap(),
|
||||
""
|
||||
@@ -40,7 +40,7 @@ fn simple_insert_column() {
|
||||
for column in 1..5 {
|
||||
assert!(model.set_user_input(sheet, row, column, "123").is_ok());
|
||||
}
|
||||
assert!(model.insert_columns(sheet, 3, 1).is_ok());
|
||||
assert!(model.insert_column(sheet, 3).is_ok());
|
||||
assert_eq!(model.get_formatted_cell_value(sheet, row, 3).unwrap(), "");
|
||||
|
||||
assert!(model.undo().is_ok());
|
||||
@@ -62,7 +62,7 @@ fn simple_delete_column() {
|
||||
.set_columns_width(0, 5, 5, DEFAULT_COLUMN_WIDTH * 3.0)
|
||||
.unwrap();
|
||||
|
||||
model.delete_columns(0, 5, 1).unwrap();
|
||||
model.delete_column(0, 5).unwrap();
|
||||
|
||||
assert_eq!(model.get_formatted_cell_value(0, 2, 5), Ok("".to_string()));
|
||||
assert_eq!(model.get_column_width(0, 5), Ok(DEFAULT_COLUMN_WIDTH));
|
||||
@@ -92,20 +92,20 @@ fn delete_column_errors() {
|
||||
let model = new_empty_model();
|
||||
let mut model = UserModel::from_model(model);
|
||||
assert_eq!(
|
||||
model.delete_columns(1, 1, 1),
|
||||
model.delete_column(1, 1),
|
||||
Err("Invalid sheet index".to_string())
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
model.delete_columns(0, 0, 1),
|
||||
model.delete_column(0, 0),
|
||||
Err("Column number '0' is not valid.".to_string())
|
||||
);
|
||||
assert_eq!(
|
||||
model.delete_columns(0, LAST_COLUMN + 1, 1),
|
||||
Err(format!("Column number '{}' is not valid.", LAST_COLUMN + 1))
|
||||
model.delete_column(0, LAST_COLUMN + 1),
|
||||
Err("Column number '16385' is not valid.".to_string())
|
||||
);
|
||||
|
||||
assert_eq!(model.delete_columns(0, LAST_COLUMN, 1), Ok(()));
|
||||
assert_eq!(model.delete_column(0, LAST_COLUMN), Ok(()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -119,7 +119,7 @@ fn simple_delete_row() {
|
||||
.set_rows_height(0, 15, 15, DEFAULT_ROW_HEIGHT * 3.0)
|
||||
.unwrap();
|
||||
|
||||
model.delete_rows(0, 15, 1).unwrap();
|
||||
model.delete_row(0, 15).unwrap();
|
||||
|
||||
assert_eq!(model.get_formatted_cell_value(0, 15, 6), Ok("".to_string()));
|
||||
assert_eq!(model.get_row_height(0, 15), Ok(DEFAULT_ROW_HEIGHT));
|
||||
@@ -150,7 +150,7 @@ fn simple_delete_row_no_style() {
|
||||
let mut model = UserModel::from_model(model);
|
||||
model.set_user_input(0, 15, 4, "3").unwrap();
|
||||
model.set_user_input(0, 15, 6, "=D15*2").unwrap();
|
||||
model.delete_rows(0, 15, 1).unwrap();
|
||||
model.delete_row(0, 15).unwrap();
|
||||
|
||||
assert_eq!(model.get_formatted_cell_value(0, 15, 6), Ok("".to_string()));
|
||||
}
|
||||
@@ -180,14 +180,14 @@ fn insert_row_evaluates() {
|
||||
model.set_user_input(0, 1, 1, "42").unwrap();
|
||||
model.set_user_input(0, 1, 2, "=A1*2").unwrap();
|
||||
|
||||
assert!(model.insert_rows(0, 1, 1).is_ok());
|
||||
assert!(model.insert_row(0, 1).is_ok());
|
||||
assert_eq!(model.get_formatted_cell_value(0, 2, 2).unwrap(), "84");
|
||||
model.undo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 2).unwrap(), "84");
|
||||
model.redo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 2, 2).unwrap(), "84");
|
||||
|
||||
model.delete_rows(0, 1, 1).unwrap();
|
||||
model.delete_row(0, 1).unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 1, 2).unwrap(), "84");
|
||||
assert_eq!(model.get_cell_content(0, 1, 2).unwrap(), "=A1*2");
|
||||
}
|
||||
@@ -199,7 +199,7 @@ fn insert_column_evaluates() {
|
||||
model.set_user_input(0, 1, 1, "42").unwrap();
|
||||
model.set_user_input(0, 10, 1, "=A1*2").unwrap();
|
||||
|
||||
assert!(model.insert_columns(0, 1, 1).is_ok());
|
||||
assert!(model.insert_column(0, 1).is_ok());
|
||||
assert_eq!(model.get_formatted_cell_value(0, 10, 2).unwrap(), "84");
|
||||
|
||||
model.undo().unwrap();
|
||||
@@ -207,7 +207,7 @@ fn insert_column_evaluates() {
|
||||
model.redo().unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 10, 2).unwrap(), "84");
|
||||
|
||||
model.delete_columns(0, 1, 1).unwrap();
|
||||
model.delete_column(0, 1).unwrap();
|
||||
assert_eq!(model.get_formatted_cell_value(0, 10, 1).unwrap(), "84");
|
||||
assert_eq!(model.get_cell_content(0, 10, 1).unwrap(), "=A1*2");
|
||||
}
|
||||
|
||||
@@ -55,7 +55,7 @@ fn set_the_range_does_not_set_the_cell() {
|
||||
assert_eq!(
|
||||
model.set_selected_range(5, 4, 10, 6),
|
||||
Err(
|
||||
"The selected cell is not in one of the corners. Row: '1' and row range '(5, 10)'"
|
||||
"The selected cells is not in one of the corners. Row: '1' and row range '(5, 10)'"
|
||||
.to_string()
|
||||
)
|
||||
);
|
||||
|
||||
@@ -13,8 +13,8 @@ use crate::{
|
||||
},
|
||||
model::Model,
|
||||
types::{
|
||||
Alignment, BorderItem, Cell, CellType, Col, HorizontalAlignment, SheetProperties,
|
||||
SheetState, Style, VerticalAlignment,
|
||||
Alignment, BorderItem, CellType, Col, HorizontalAlignment, SheetProperties, SheetState,
|
||||
Style, VerticalAlignment,
|
||||
},
|
||||
utils::is_valid_hex_color,
|
||||
};
|
||||
@@ -659,12 +659,8 @@ impl UserModel {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn clear_column_formatting(
|
||||
&mut self,
|
||||
sheet: u32,
|
||||
column: i32,
|
||||
diff_list: &mut Vec<Diff>,
|
||||
) -> Result<(), String> {
|
||||
fn clear_column_formatting(&mut self, sheet: u32, column: i32) -> Result<(), String> {
|
||||
let mut diff_list = Vec::new();
|
||||
let old_value = self.model.get_column_style(sheet, column)?;
|
||||
self.model.delete_column_style(sheet, column)?;
|
||||
diff_list.push(Diff::DeleteColumnStyle {
|
||||
@@ -743,15 +739,12 @@ impl UserModel {
|
||||
}
|
||||
}
|
||||
}
|
||||
self.push_diff_list(diff_list);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn clear_row_formatting(
|
||||
&mut self,
|
||||
sheet: u32,
|
||||
row: i32,
|
||||
diff_list: &mut Vec<Diff>,
|
||||
) -> Result<(), String> {
|
||||
fn clear_row_formatting(&mut self, sheet: u32, row: i32) -> Result<(), String> {
|
||||
let mut diff_list = Vec::new();
|
||||
let old_value = self.model.get_row_style(sheet, row)?;
|
||||
self.model.delete_row_style(sheet, row)?;
|
||||
diff_list.push(Diff::DeleteRowStyle {
|
||||
@@ -798,6 +791,8 @@ impl UserModel {
|
||||
}
|
||||
}
|
||||
}
|
||||
self.push_diff_list(diff_list);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -808,21 +803,19 @@ impl UserModel {
|
||||
/// * [UserModel::range_clear_contents]
|
||||
pub fn range_clear_formatting(&mut self, range: &Area) -> Result<(), String> {
|
||||
let sheet = range.sheet;
|
||||
let mut diff_list = Vec::new();
|
||||
if range.row == 1 && range.height == LAST_ROW {
|
||||
for column in range.column..range.column + range.width {
|
||||
self.clear_column_formatting(sheet, column, &mut diff_list)?;
|
||||
self.clear_column_formatting(sheet, column)?;
|
||||
}
|
||||
self.push_diff_list(diff_list);
|
||||
return Ok(());
|
||||
}
|
||||
if range.column == 1 && range.width == LAST_COLUMN {
|
||||
for row in range.row..range.row + range.height {
|
||||
self.clear_row_formatting(sheet, row, &mut diff_list)?;
|
||||
self.clear_row_formatting(sheet, row)?;
|
||||
}
|
||||
self.push_diff_list(diff_list);
|
||||
return Ok(());
|
||||
}
|
||||
let mut diff_list = Vec::new();
|
||||
for row in range.row..range.row + range.height {
|
||||
for column in range.column..range.column + range.width {
|
||||
if let Some(old_style) = self.model.get_cell_style_or_none(sheet, row, column)? {
|
||||
@@ -858,184 +851,105 @@ impl UserModel {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Inserts `row_count` blank rows starting at `row` (both 0-based).
|
||||
/// Inserts a row
|
||||
///
|
||||
/// Parameters
|
||||
/// * `sheet` – worksheet index.
|
||||
/// * `row` – first row to insert.
|
||||
/// * `row_count` – number of rows (> 0).
|
||||
///
|
||||
/// History: the method pushes `row_count` [`crate::user_model::history::Diff::InsertRow`]
|
||||
/// items **all using the same `row` index**. Replaying those diffs (undo / redo)
|
||||
/// is therefore immune to the row-shifts that happen after each individual
|
||||
/// insertion.
|
||||
///
|
||||
/// See also [`Model::insert_rows`].
|
||||
pub fn insert_rows(&mut self, sheet: u32, row: i32, row_count: i32) -> Result<(), String> {
|
||||
self.model.insert_rows(sheet, row, row_count)?;
|
||||
|
||||
let diff_list = vec![Diff::InsertRows {
|
||||
sheet,
|
||||
row,
|
||||
count: row_count,
|
||||
}];
|
||||
/// See also:
|
||||
/// * [Model::insert_rows]
|
||||
pub fn insert_row(&mut self, sheet: u32, row: i32) -> Result<(), String> {
|
||||
let diff_list = vec![Diff::InsertRow { sheet, row }];
|
||||
self.push_diff_list(diff_list);
|
||||
self.model.insert_rows(sheet, row, 1)?;
|
||||
self.evaluate_if_not_paused();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Inserts `column_count` blank columns starting at `column` (0-based).
|
||||
/// Deletes a row
|
||||
///
|
||||
/// Parameters
|
||||
/// * `sheet` – worksheet index.
|
||||
/// * `column` – first column to insert.
|
||||
/// * `column_count` – number of columns (> 0).
|
||||
///
|
||||
/// History: pushes one [`crate::user_model::history::Diff::InsertColumn`]
|
||||
/// per inserted column, all with the same `column` value, preventing index
|
||||
/// drift when the diffs are reapplied.
|
||||
///
|
||||
/// See also [`Model::insert_columns`].
|
||||
pub fn insert_columns(
|
||||
&mut self,
|
||||
sheet: u32,
|
||||
column: i32,
|
||||
column_count: i32,
|
||||
) -> Result<(), String> {
|
||||
self.model.insert_columns(sheet, column, column_count)?;
|
||||
|
||||
let diff_list = vec![Diff::InsertColumns {
|
||||
sheet,
|
||||
column,
|
||||
count: column_count,
|
||||
}];
|
||||
self.push_diff_list(diff_list);
|
||||
self.evaluate_if_not_paused();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Deletes `row_count` rows starting at `row`.
|
||||
///
|
||||
/// History: a [`crate::user_model::history::Diff::DeleteRow`] is created for
|
||||
/// each row, ordered **bottom → top**. Undo therefore recreates rows from
|
||||
/// top → bottom and redo removes them bottom → top, avoiding index drift.
|
||||
///
|
||||
/// See also [`Model::delete_rows`].
|
||||
pub fn delete_rows(&mut self, sheet: u32, row: i32, row_count: i32) -> Result<(), String> {
|
||||
/// See also:
|
||||
/// * [Model::delete_rows]
|
||||
pub fn delete_row(&mut self, sheet: u32, row: i32) -> Result<(), String> {
|
||||
let mut row_data = None;
|
||||
let worksheet = self.model.workbook.worksheet(sheet)?;
|
||||
let mut old_data = Vec::new();
|
||||
// Collect data for all rows to be deleted
|
||||
for r in row..row + row_count {
|
||||
let mut row_data = None;
|
||||
for rd in &worksheet.rows {
|
||||
if rd.r == r {
|
||||
row_data = Some(rd.clone());
|
||||
break;
|
||||
}
|
||||
for rd in &worksheet.rows {
|
||||
if rd.r == row {
|
||||
row_data = Some(rd.clone());
|
||||
break;
|
||||
}
|
||||
let data = match worksheet.sheet_data.get(&r) {
|
||||
Some(s) => s.clone(),
|
||||
None => HashMap::new(),
|
||||
};
|
||||
old_data.push(RowData {
|
||||
row: row_data,
|
||||
data,
|
||||
});
|
||||
}
|
||||
|
||||
self.model.delete_rows(sheet, row, row_count)?;
|
||||
|
||||
let diff_list = vec![Diff::DeleteRows {
|
||||
let data = match worksheet.sheet_data.get(&row) {
|
||||
Some(s) => s.clone(),
|
||||
None => return Err(format!("Row number '{row}' is not valid.")),
|
||||
};
|
||||
let old_data = Box::new(RowData {
|
||||
row: row_data,
|
||||
data,
|
||||
});
|
||||
let diff_list = vec![Diff::DeleteRow {
|
||||
sheet,
|
||||
row,
|
||||
count: row_count,
|
||||
old_data,
|
||||
}];
|
||||
self.push_diff_list(diff_list);
|
||||
self.model.delete_rows(sheet, row, 1)?;
|
||||
self.evaluate_if_not_paused();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Deletes `column_count` columns starting at `column`.
|
||||
/// Inserts a column
|
||||
///
|
||||
/// History: pushes one [`crate::user_model::history::Diff::DeleteColumn`]
|
||||
/// per column, **right → left**, so replaying the list is always safe with
|
||||
/// respect to index shifts.
|
||||
/// See also:
|
||||
/// * [Model::insert_columns]
|
||||
pub fn insert_column(&mut self, sheet: u32, column: i32) -> Result<(), String> {
|
||||
let diff_list = vec![Diff::InsertColumn { sheet, column }];
|
||||
self.push_diff_list(diff_list);
|
||||
self.model.insert_columns(sheet, column, 1)?;
|
||||
self.evaluate_if_not_paused();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Deletes a column
|
||||
///
|
||||
/// See also [`Model::delete_columns`].
|
||||
pub fn delete_columns(
|
||||
&mut self,
|
||||
sheet: u32,
|
||||
column: i32,
|
||||
column_count: i32,
|
||||
) -> Result<(), String> {
|
||||
/// See also:
|
||||
/// * [Model::delete_columns]
|
||||
pub fn delete_column(&mut self, sheet: u32, column: i32) -> Result<(), String> {
|
||||
let worksheet = self.model.workbook.worksheet(sheet)?;
|
||||
let mut old_data = Vec::new();
|
||||
// Collect data for all columns to be deleted
|
||||
for c in column..column + column_count {
|
||||
let mut column_data = None;
|
||||
for col in &worksheet.cols {
|
||||
if c >= col.min && c <= col.max {
|
||||
column_data = Some(Col {
|
||||
min: c,
|
||||
max: c,
|
||||
width: col.width,
|
||||
custom_width: col.custom_width,
|
||||
style: col.style,
|
||||
});
|
||||
break;
|
||||
}
|
||||
}
|
||||
if !is_valid_column_number(column) {
|
||||
return Err(format!("Column number '{column}' is not valid."));
|
||||
}
|
||||
|
||||
let mut data = HashMap::new();
|
||||
for (row_idx, row_data) in &worksheet.sheet_data {
|
||||
if let Some(cell) = row_data.get(&c) {
|
||||
data.insert(*row_idx, cell.clone());
|
||||
}
|
||||
let mut column_data = None;
|
||||
for col in &worksheet.cols {
|
||||
let min = col.min;
|
||||
let max = col.max;
|
||||
if column >= min && column <= max {
|
||||
column_data = Some(Col {
|
||||
min: column,
|
||||
max: column,
|
||||
width: col.width,
|
||||
custom_width: col.custom_width,
|
||||
style: col.style,
|
||||
});
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
old_data.push(ColumnData {
|
||||
let mut data = HashMap::new();
|
||||
for (row, row_data) in &worksheet.sheet_data {
|
||||
if let Some(cell) = row_data.get(&column) {
|
||||
data.insert(*row, cell.clone());
|
||||
}
|
||||
}
|
||||
|
||||
let diff_list = vec![Diff::DeleteColumn {
|
||||
sheet,
|
||||
column,
|
||||
old_data: Box::new(ColumnData {
|
||||
column: column_data,
|
||||
data,
|
||||
});
|
||||
}
|
||||
|
||||
self.model.delete_columns(sheet, column, column_count)?;
|
||||
|
||||
let diff_list = vec![Diff::DeleteColumns {
|
||||
sheet,
|
||||
column,
|
||||
count: column_count,
|
||||
old_data,
|
||||
}),
|
||||
}];
|
||||
self.push_diff_list(diff_list);
|
||||
self.evaluate_if_not_paused();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Moves a column horizontally and adjusts formulas
|
||||
pub fn move_column_action(
|
||||
&mut self,
|
||||
sheet: u32,
|
||||
column: i32,
|
||||
delta: i32,
|
||||
) -> Result<(), String> {
|
||||
let diff_list = vec![Diff::MoveColumn {
|
||||
sheet,
|
||||
column,
|
||||
delta,
|
||||
}];
|
||||
self.push_diff_list(diff_list);
|
||||
self.model.move_column_action(sheet, column, delta)?;
|
||||
self.evaluate_if_not_paused();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Moves a row vertically and adjusts formulas
|
||||
pub fn move_row_action(&mut self, sheet: u32, row: i32, delta: i32) -> Result<(), String> {
|
||||
let diff_list = vec![Diff::MoveRow { sheet, row, delta }];
|
||||
self.push_diff_list(diff_list);
|
||||
self.model.move_row_action(sheet, row, delta)?;
|
||||
self.model.delete_columns(sheet, column, 1)?;
|
||||
self.evaluate_if_not_paused();
|
||||
Ok(())
|
||||
}
|
||||
@@ -1681,66 +1595,6 @@ impl UserModel {
|
||||
Ok(self.model.workbook.worksheet(sheet)?.show_grid_lines)
|
||||
}
|
||||
|
||||
/// Returns the largest column in the row less than a column whose cell has a non empty value.
|
||||
/// If there are none it returns `None`.
|
||||
/// This is useful when rendering a part of a worksheet to know which cells spill over
|
||||
pub fn get_last_non_empty_in_row_before_column(
|
||||
&self,
|
||||
sheet: u32,
|
||||
row: i32,
|
||||
column: i32,
|
||||
) -> Result<Option<i32>, String> {
|
||||
let worksheet = self.model.workbook.worksheet(sheet)?;
|
||||
let data = worksheet.sheet_data.get(&row);
|
||||
if let Some(row_data) = data {
|
||||
let mut last_column = None;
|
||||
let mut columns: Vec<i32> = row_data.keys().copied().collect();
|
||||
columns.sort_unstable();
|
||||
for col in columns {
|
||||
if col < column {
|
||||
if let Some(cell) = worksheet.cell(row, col) {
|
||||
if matches!(cell, Cell::EmptyCell { .. }) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
last_column = Some(col);
|
||||
}
|
||||
}
|
||||
Ok(last_column)
|
||||
} else {
|
||||
Ok(None)
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the smallest column in the row larger than "column" whose cell has a non empty value.
|
||||
/// If there are none it returns `None`.
|
||||
/// This is useful when rendering a part of a worksheet to know which cells spill over
|
||||
pub fn get_first_non_empty_in_row_after_column(
|
||||
&self,
|
||||
sheet: u32,
|
||||
row: i32,
|
||||
column: i32,
|
||||
) -> Result<Option<i32>, String> {
|
||||
let worksheet = self.model.workbook.worksheet(sheet)?;
|
||||
let data = worksheet.sheet_data.get(&row);
|
||||
if let Some(row_data) = data {
|
||||
let mut columns: Vec<i32> = row_data.keys().copied().collect();
|
||||
// We sort the keys to ensure we are going from left to right
|
||||
columns.sort_unstable();
|
||||
for col in columns {
|
||||
if col > column {
|
||||
if let Some(cell) = worksheet.cell(row, col) {
|
||||
if matches!(cell, Cell::EmptyCell { .. }) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
return Ok(Some(col));
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
/// Returns a copy of the selected area
|
||||
pub fn copy_to_clipboard(&self) -> Result<Clipboard, String> {
|
||||
let selected_area = self.get_selected_view();
|
||||
@@ -1780,7 +1634,7 @@ impl UserModel {
|
||||
.map_err(|e| format!("Error converting from utf8: '{e}'"))?;
|
||||
|
||||
Ok(Clipboard {
|
||||
csv: csv.trim().to_string(),
|
||||
csv,
|
||||
data,
|
||||
sheet,
|
||||
range: (row_start, column_start, row_end, column_end),
|
||||
@@ -1948,7 +1802,7 @@ impl UserModel {
|
||||
}
|
||||
self.push_diff_list(diff_list);
|
||||
// select the pasted area
|
||||
self.set_selected_range(area.row, area.column, row - 1, column - 1)?;
|
||||
self.set_selected_range(area.row, area.column, row, column)?;
|
||||
self.evaluate_if_not_paused();
|
||||
Ok(())
|
||||
}
|
||||
@@ -2113,56 +1967,45 @@ impl UserModel {
|
||||
self.model.cell_clear_all(*sheet, *row, *column)?;
|
||||
}
|
||||
}
|
||||
Diff::InsertRows { sheet, row, count } => {
|
||||
self.model.delete_rows(*sheet, *row, *count)?;
|
||||
Diff::InsertRow { sheet, row } => {
|
||||
self.model.delete_rows(*sheet, *row, 1)?;
|
||||
needs_evaluation = true;
|
||||
}
|
||||
Diff::DeleteRows {
|
||||
Diff::DeleteRow {
|
||||
sheet,
|
||||
row,
|
||||
count: _,
|
||||
old_data,
|
||||
} => {
|
||||
needs_evaluation = true;
|
||||
self.model
|
||||
.insert_rows(*sheet, *row, old_data.len() as i32)?;
|
||||
self.model.insert_rows(*sheet, *row, 1)?;
|
||||
let worksheet = self.model.workbook.worksheet_mut(*sheet)?;
|
||||
for (i, row_data) in old_data.iter().enumerate() {
|
||||
let r = *row + i as i32;
|
||||
if let Some(row_style) = row_data.row.clone() {
|
||||
worksheet.rows.push(row_style);
|
||||
}
|
||||
worksheet.sheet_data.insert(r, row_data.data.clone());
|
||||
if let Some(row_data) = old_data.row.clone() {
|
||||
worksheet.rows.push(row_data);
|
||||
}
|
||||
worksheet.sheet_data.insert(*row, old_data.data.clone());
|
||||
}
|
||||
Diff::InsertColumns {
|
||||
sheet,
|
||||
column,
|
||||
count,
|
||||
} => {
|
||||
self.model.delete_columns(*sheet, *column, *count)?;
|
||||
Diff::InsertColumn { sheet, column } => {
|
||||
self.model.delete_columns(*sheet, *column, 1)?;
|
||||
needs_evaluation = true;
|
||||
}
|
||||
Diff::DeleteColumns {
|
||||
Diff::DeleteColumn {
|
||||
sheet,
|
||||
column,
|
||||
count: _,
|
||||
old_data,
|
||||
} => {
|
||||
needs_evaluation = true;
|
||||
self.model
|
||||
.insert_columns(*sheet, *column, old_data.len() as i32)?;
|
||||
// inserts an empty column
|
||||
self.model.insert_columns(*sheet, *column, 1)?;
|
||||
// puts all the data back
|
||||
let worksheet = self.model.workbook.worksheet_mut(*sheet)?;
|
||||
for (i, col_data) in old_data.iter().enumerate() {
|
||||
let c = *column + i as i32;
|
||||
for (row, cell) in &col_data.data {
|
||||
worksheet.update_cell(*row, c, cell.clone())?;
|
||||
}
|
||||
if let Some(col) = &col_data.column {
|
||||
let width = col.width * constants::COLUMN_WIDTH_FACTOR;
|
||||
let style = col.style;
|
||||
worksheet.set_column_width_and_style(c, width, style)?;
|
||||
}
|
||||
for (row, cell) in &old_data.data {
|
||||
worksheet.update_cell(*row, *column, cell.clone())?;
|
||||
}
|
||||
// makes sure that the width and style is correct
|
||||
if let Some(col) = &old_data.column {
|
||||
let width = col.width * constants::COLUMN_WIDTH_FACTOR;
|
||||
let style = col.style;
|
||||
worksheet.set_column_width_and_style(*column, width, style)?;
|
||||
}
|
||||
}
|
||||
Diff::SetFrozenRowsCount {
|
||||
@@ -2320,21 +2163,6 @@ impl UserModel {
|
||||
self.model.delete_row_style(*sheet, *row)?;
|
||||
}
|
||||
}
|
||||
Diff::MoveColumn {
|
||||
sheet,
|
||||
column,
|
||||
delta,
|
||||
} => {
|
||||
// For undo, we apply the opposite move
|
||||
self.model
|
||||
.move_column_action(*sheet, *column + *delta, -*delta)?;
|
||||
needs_evaluation = true;
|
||||
}
|
||||
Diff::MoveRow { sheet, row, delta } => {
|
||||
// For undo, we apply the opposite move
|
||||
self.model.move_row_action(*sheet, *row + *delta, -*delta)?;
|
||||
needs_evaluation = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
if needs_evaluation {
|
||||
@@ -2403,34 +2231,28 @@ impl UserModel {
|
||||
} => self
|
||||
.model
|
||||
.set_cell_style(*sheet, *row, *column, new_value)?,
|
||||
Diff::InsertRows { sheet, row, count } => {
|
||||
self.model.insert_rows(*sheet, *row, *count)?;
|
||||
Diff::InsertRow { sheet, row } => {
|
||||
self.model.insert_rows(*sheet, *row, 1)?;
|
||||
needs_evaluation = true;
|
||||
}
|
||||
Diff::DeleteRows {
|
||||
Diff::DeleteRow {
|
||||
sheet,
|
||||
row,
|
||||
count,
|
||||
old_data: _,
|
||||
} => {
|
||||
self.model.delete_rows(*sheet, *row, *count)?;
|
||||
self.model.delete_rows(*sheet, *row, 1)?;
|
||||
needs_evaluation = true;
|
||||
}
|
||||
Diff::InsertColumns {
|
||||
sheet,
|
||||
column,
|
||||
count,
|
||||
} => {
|
||||
self.model.insert_columns(*sheet, *column, *count)?;
|
||||
Diff::InsertColumn { sheet, column } => {
|
||||
needs_evaluation = true;
|
||||
self.model.insert_columns(*sheet, *column, 1)?;
|
||||
}
|
||||
Diff::DeleteColumns {
|
||||
Diff::DeleteColumn {
|
||||
sheet,
|
||||
column,
|
||||
count,
|
||||
old_data: _,
|
||||
} => {
|
||||
self.model.delete_columns(*sheet, *column, *count)?;
|
||||
self.model.delete_columns(*sheet, *column, 1)?;
|
||||
needs_evaluation = true;
|
||||
}
|
||||
Diff::SetFrozenRowsCount {
|
||||
@@ -2542,18 +2364,6 @@ impl UserModel {
|
||||
} => {
|
||||
self.model.delete_row_style(*sheet, *row)?;
|
||||
}
|
||||
Diff::MoveColumn {
|
||||
sheet,
|
||||
column,
|
||||
delta,
|
||||
} => {
|
||||
self.model.move_column_action(*sheet, *column, *delta)?;
|
||||
needs_evaluation = true;
|
||||
}
|
||||
Diff::MoveRow { sheet, row, delta } => {
|
||||
self.model.move_row_action(*sheet, *row, *delta)?;
|
||||
needs_evaluation = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -87,27 +87,23 @@ pub(crate) enum Diff {
|
||||
row: i32,
|
||||
old_value: Box<Option<Style>>,
|
||||
},
|
||||
InsertRows {
|
||||
InsertRow {
|
||||
sheet: u32,
|
||||
row: i32,
|
||||
count: i32,
|
||||
},
|
||||
DeleteRows {
|
||||
DeleteRow {
|
||||
sheet: u32,
|
||||
row: i32,
|
||||
count: i32,
|
||||
old_data: Vec<RowData>,
|
||||
old_data: Box<RowData>,
|
||||
},
|
||||
InsertColumns {
|
||||
InsertColumn {
|
||||
sheet: u32,
|
||||
column: i32,
|
||||
count: i32,
|
||||
},
|
||||
DeleteColumns {
|
||||
DeleteColumn {
|
||||
sheet: u32,
|
||||
column: i32,
|
||||
count: i32,
|
||||
old_data: Vec<ColumnData>,
|
||||
old_data: Box<ColumnData>,
|
||||
},
|
||||
DeleteSheet {
|
||||
sheet: u32,
|
||||
@@ -165,16 +161,6 @@ pub(crate) enum Diff {
|
||||
new_scope: Option<u32>,
|
||||
new_formula: String,
|
||||
},
|
||||
MoveColumn {
|
||||
sheet: u32,
|
||||
column: i32,
|
||||
delta: i32,
|
||||
},
|
||||
MoveRow {
|
||||
sheet: u32,
|
||||
row: i32,
|
||||
delta: i32,
|
||||
},
|
||||
// FIXME: we are missing SetViewDiffs
|
||||
}
|
||||
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
mod border;
|
||||
mod border_utils;
|
||||
mod common;
|
||||
pub(crate) mod history;
|
||||
mod history;
|
||||
mod ui;
|
||||
|
||||
pub use common::UserModel;
|
||||
|
||||
@@ -2,11 +2,7 @@
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::{
|
||||
constants::{LAST_COLUMN, LAST_ROW},
|
||||
expressions::utils::{is_valid_column_number, is_valid_row},
|
||||
worksheet::NavigationDirection,
|
||||
};
|
||||
use crate::expressions::utils::{is_valid_column_number, is_valid_row};
|
||||
|
||||
use super::common::UserModel;
|
||||
|
||||
@@ -114,7 +110,7 @@ impl UserModel {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Sets the selected range. Note that the selected cell must be in the selected range.
|
||||
/// 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,
|
||||
@@ -148,32 +144,16 @@ impl UserModel {
|
||||
if let Some(view) = worksheet.views.get_mut(&0) {
|
||||
let selected_row = view.row;
|
||||
let selected_column = view.column;
|
||||
if start_row == 1 && end_row == LAST_ROW {
|
||||
// full row selected. The cell must be at the top or the bottom of the range
|
||||
if selected_column != start_column && selected_column != end_column {
|
||||
return Err(format!(
|
||||
"The selected cell is not the column edge. Column '{selected_column}' and column range '({start_column}, {end_column})'"
|
||||
));
|
||||
}
|
||||
} else if start_column == 1 && end_column == LAST_COLUMN {
|
||||
// full column selected. The cell must be at the left or the right of the range
|
||||
if selected_row != start_row && selected_row != end_row {
|
||||
return Err(format!(
|
||||
"The selected cell is not in the row edge. Row: '{selected_row}' and row range '({start_row}, {end_row})'"
|
||||
));
|
||||
}
|
||||
} else {
|
||||
// The selected cell 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 cell is not in one of the corners. Row: '{selected_row}' and row range '({start_row}, {end_row})'"
|
||||
// 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: '{selected_row}' and row range '({start_row}, {end_row})'"
|
||||
));
|
||||
}
|
||||
if selected_column != start_column && selected_column != end_column {
|
||||
return Err(format!(
|
||||
"The selected cell is not in one of the corners. Column '{selected_column}' and column range '({start_column}, {end_column})'"
|
||||
}
|
||||
if selected_column != start_column && selected_column != end_column {
|
||||
return Err(format!(
|
||||
"The selected cells is not in one of the corners. Column '{selected_column}' and column range '({start_column}, {end_column})'"
|
||||
));
|
||||
}
|
||||
}
|
||||
view.range = [start_row, start_column, end_row, end_column];
|
||||
}
|
||||
@@ -210,17 +190,6 @@ impl UserModel {
|
||||
return Ok(());
|
||||
};
|
||||
let [row_start, column_start, row_end, column_end] = range;
|
||||
if ["ArrowUp", "ArrowDown"].contains(&key) && row_start == 1 && row_end == LAST_ROW {
|
||||
// full column selected, nothing to do
|
||||
return Ok(());
|
||||
}
|
||||
if ["ArrowRight", "ArrowLeft"].contains(&key)
|
||||
&& column_start == 1
|
||||
&& column_end == LAST_COLUMN
|
||||
{
|
||||
// full row selected, nothing to do
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
match key {
|
||||
"ArrowRight" => {
|
||||
@@ -503,7 +472,7 @@ impl UserModel {
|
||||
// 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 && row <= LAST_ROW {
|
||||
while row <= new_row + 1 {
|
||||
height += self.model.get_row_height(sheet, row)?;
|
||||
row += 1;
|
||||
}
|
||||
@@ -713,94 +682,4 @@ impl UserModel {
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// User navigates to the edge in the given direction
|
||||
pub fn on_navigate_to_edge_in_direction(
|
||||
&mut self,
|
||||
direction: NavigationDirection,
|
||||
) -> Result<(), String> {
|
||||
let (sheet, window_height, window_width) =
|
||||
if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
|
||||
(view.sheet, view.window_height, 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 row = view.row;
|
||||
let column = view.column;
|
||||
if !is_valid_row(row) || !is_valid_column_number(column) {
|
||||
return Err("Invalid row or column".to_string());
|
||||
}
|
||||
let (new_row, new_column) =
|
||||
worksheet.navigate_to_edge_in_direction(row, column, direction)?;
|
||||
if !is_valid_row(new_row) || !is_valid_column_number(new_column) {
|
||||
return Err("Invalid row or column after navigation".to_string());
|
||||
}
|
||||
if new_row == row && new_column == column {
|
||||
return Ok(()); // No change in selection
|
||||
}
|
||||
|
||||
let mut top_row = view.top_row;
|
||||
let mut left_column = view.left_column;
|
||||
|
||||
match direction {
|
||||
NavigationDirection::Left | NavigationDirection::Right => {
|
||||
// If the new column is not fully visible we 'scroll' until it is
|
||||
// We need to check two conditions:
|
||||
// 1. new_column > view.left_column
|
||||
// 2. right_column < new_column
|
||||
if new_column < view.left_column {
|
||||
left_column = new_column;
|
||||
} else {
|
||||
let mut c = new_column;
|
||||
let mut width = self.model.get_column_width(sheet, c)?;
|
||||
while c > 1 && width <= window_width as f64 {
|
||||
c -= 1;
|
||||
width += self.model.get_column_width(sheet, c)?;
|
||||
}
|
||||
if c > view.left_column {
|
||||
left_column = c;
|
||||
}
|
||||
}
|
||||
}
|
||||
NavigationDirection::Up | NavigationDirection::Down => {
|
||||
// If the new row is not fully visible we 'scroll' until it is
|
||||
// We need to check two conditions:
|
||||
// 1. new_row > view.top_row
|
||||
// 2. bottom_row < new_row
|
||||
if new_row < view.top_row {
|
||||
top_row = new_row;
|
||||
} else {
|
||||
let mut r = new_row;
|
||||
let mut height = self.model.get_row_height(sheet, r)?;
|
||||
while r > 1 && height <= window_height as f64 {
|
||||
r -= 1;
|
||||
height += self.model.get_row_height(sheet, r)?;
|
||||
}
|
||||
if r > view.top_row {
|
||||
top_row = r;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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.column = new_column;
|
||||
view.range = [new_row, new_column, new_row, new_column];
|
||||
|
||||
view.top_row = top_row;
|
||||
view.left_column = left_column;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4,20 +4,15 @@
|
||||
Example usage:
|
||||
|
||||
```javascript
|
||||
import { Model } from '@ironcalc/nodejs';
|
||||
import { Model } from '@ironcalc/wasm';
|
||||
|
||||
const model = new Model("Workbook1", "en", "UTC");
|
||||
|
||||
model.setUserInput(0, 1, 1, "=1+1");
|
||||
|
||||
const result1 = model.getFormattedCellValue(0, 1, 1);
|
||||
console.log('Cell value', result1); // "#ERROR"
|
||||
|
||||
model.evaluate();
|
||||
|
||||
const resultAfterEvaluate = model.getFormattedCellValue(0, 1, 1);
|
||||
console.log('Cell value', resultAfterEvaluate); // 2
|
||||
console.log('Cell value', result1);
|
||||
|
||||
let result2 = model.getCellStyle(0, 1, 1);
|
||||
console.log('Cell style', result2);
|
||||
```
|
||||
```
|
||||
8
bindings/nodejs/index.d.ts
vendored
8
bindings/nodejs/index.d.ts
vendored
@@ -59,10 +59,10 @@ export declare class UserModel {
|
||||
setSheetColor(sheet: number, color: string): void
|
||||
rangeClearAll(sheet: number, startRow: number, startColumn: number, endRow: number, endColumn: number): void
|
||||
rangeClearContents(sheet: number, startRow: number, startColumn: number, endRow: number, endColumn: number): void
|
||||
insertRows(sheet: number, row: number, rowCount: number): void
|
||||
insertColumns(sheet: number, column: number, columnCount: number): void
|
||||
deleteRows(sheet: number, row: number, rowCount: number): void
|
||||
deleteColumns(sheet: number, column: number, columnCount: number): void
|
||||
insertRow(sheet: number, row: number): void
|
||||
insertColumn(sheet: number, column: number): void
|
||||
deleteRow(sheet: number, row: number): void
|
||||
deleteColumn(sheet: number, column: number): void
|
||||
setRowHeight(sheet: number, row: number, height: number): void
|
||||
setColumnWidth(sheet: number, column: number, width: number): void
|
||||
getRowHeight(sheet: number, row: number): number
|
||||
|
||||
@@ -340,20 +340,4 @@ impl Model {
|
||||
.delete_defined_name(&name, scope)
|
||||
.map_err(|e| to_js_error(e.to_string()))
|
||||
}
|
||||
|
||||
#[napi(js_name = "moveColumn")]
|
||||
pub fn move_column(&mut self, sheet: u32, column: i32, delta: i32) -> Result<()> {
|
||||
self
|
||||
.model
|
||||
.move_column_action(sheet, column, delta)
|
||||
.map_err(to_js_error)
|
||||
}
|
||||
|
||||
#[napi(js_name = "moveRow")]
|
||||
pub fn move_row(&mut self, sheet: u32, row: i32, delta: i32) -> Result<()> {
|
||||
self
|
||||
.model
|
||||
.move_row_action(sheet, row, delta)
|
||||
.map_err(to_js_error)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -183,36 +183,24 @@ impl UserModel {
|
||||
.map_err(to_js_error)
|
||||
}
|
||||
|
||||
#[napi(js_name = "insertRows")]
|
||||
pub fn insert_rows(&mut self, sheet: u32, row: i32, row_count: i32) -> Result<()> {
|
||||
self
|
||||
.model
|
||||
.insert_rows(sheet, row, row_count)
|
||||
.map_err(to_js_error)
|
||||
#[napi(js_name = "insertRow")]
|
||||
pub fn insert_row(&mut self, sheet: u32, row: i32) -> Result<()> {
|
||||
self.model.insert_row(sheet, row).map_err(to_js_error)
|
||||
}
|
||||
|
||||
#[napi(js_name = "insertColumns")]
|
||||
pub fn insert_columns(&mut self, sheet: u32, column: i32, column_count: i32) -> Result<()> {
|
||||
self
|
||||
.model
|
||||
.insert_columns(sheet, column, column_count)
|
||||
.map_err(to_js_error)
|
||||
#[napi(js_name = "insertColumn")]
|
||||
pub fn insert_column(&mut self, sheet: u32, column: i32) -> Result<()> {
|
||||
self.model.insert_column(sheet, column).map_err(to_js_error)
|
||||
}
|
||||
|
||||
#[napi(js_name = "deleteRows")]
|
||||
pub fn delete_rows(&mut self, sheet: u32, row: i32, row_count: i32) -> Result<()> {
|
||||
self
|
||||
.model
|
||||
.delete_rows(sheet, row, row_count)
|
||||
.map_err(to_js_error)
|
||||
#[napi(js_name = "deleteRow")]
|
||||
pub fn delete_row(&mut self, sheet: u32, row: i32) -> Result<()> {
|
||||
self.model.delete_row(sheet, row).map_err(to_js_error)
|
||||
}
|
||||
|
||||
#[napi(js_name = "deleteColumns")]
|
||||
pub fn delete_columns(&mut self, sheet: u32, column: i32, column_count: i32) -> Result<()> {
|
||||
self
|
||||
.model
|
||||
.delete_columns(sheet, column, column_count)
|
||||
.map_err(to_js_error)
|
||||
#[napi(js_name = "deleteColumn")]
|
||||
pub fn delete_column(&mut self, sheet: u32, column: i32) -> Result<()> {
|
||||
self.model.delete_column(sheet, column).map_err(to_js_error)
|
||||
}
|
||||
|
||||
#[napi(js_name = "setRowsHeight")]
|
||||
@@ -663,20 +651,4 @@ impl UserModel {
|
||||
.delete_defined_name(&name, scope)
|
||||
.map_err(|e| to_js_error(e.to_string()))
|
||||
}
|
||||
|
||||
#[napi(js_name = "moveColumn")]
|
||||
pub fn move_column(&mut self, sheet: u32, column: i32, delta: i32) -> Result<()> {
|
||||
self
|
||||
.model
|
||||
.move_column_action(sheet, column, delta)
|
||||
.map_err(to_js_error)
|
||||
}
|
||||
|
||||
#[napi(js_name = "moveRow")]
|
||||
pub fn move_row(&mut self, sheet: u32, row: i32, delta: i32) -> Result<()> {
|
||||
self
|
||||
.model
|
||||
.move_row_action(sheet, row, delta)
|
||||
.map_err(to_js_error)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "pyroncalc"
|
||||
version = "0.5.7"
|
||||
version = "0.5.0"
|
||||
edition = "2021"
|
||||
|
||||
|
||||
@@ -13,8 +13,7 @@ crate-type = ["cdylib"]
|
||||
serde = { version = "1.0", features = ["derive"] }
|
||||
serde_json = "1.0"
|
||||
xlsx = { package= "ironcalc", path = "../../xlsx", version = "0.5.0" }
|
||||
pyo3 = { version = "0.25", features = ["extension-module"] }
|
||||
bitcode = "0.6.3"
|
||||
pyo3 = { version = "0.23", features = ["extension-module"] }
|
||||
|
||||
|
||||
[features]
|
||||
|
||||
@@ -10,6 +10,9 @@ You can add cell values, retrieve them and most importantly you can evaluate spr
|
||||
pip install ironcalc
|
||||
```
|
||||
|
||||
|
||||
|
||||
|
||||
## Compile and test
|
||||
|
||||
To compile this and test it:
|
||||
@@ -25,18 +28,4 @@ examples $ python example.py
|
||||
|
||||
From there if you use `python` you can `import ironcalc`. You can either create a new file, read it from a JSON string or import from Excel.
|
||||
|
||||
Hopefully the API is straightforward.
|
||||
|
||||
## Creating documentation
|
||||
|
||||
We use sphinx
|
||||
|
||||
```
|
||||
python -m venv venv
|
||||
source venv/bin/activate
|
||||
pip install maturin
|
||||
pip install sphinx
|
||||
maturin develop
|
||||
sphinx-build -M html docs html
|
||||
python -m http.server --directory html/html/
|
||||
```
|
||||
Hopefully the API is straightforward.
|
||||
@@ -1,9 +0,0 @@
|
||||
#!/bin/bash
|
||||
python -m venv venv
|
||||
source venv/bin/activate
|
||||
pip install patchelf
|
||||
pip install maturin
|
||||
pip install sphinx
|
||||
maturin develop
|
||||
sphinx-build -M html docs html
|
||||
python -m http.server --directory html/html/
|
||||
@@ -1,6 +1,6 @@
|
||||
|
||||
Raw API Reference
|
||||
-----------------
|
||||
API Reference
|
||||
-------------
|
||||
|
||||
In general methods in IronCalc use a 0-index base for the the sheet index and 1-index base for the row and column indexes.
|
||||
|
||||
@@ -28,7 +28,7 @@ In general methods in IronCalc use a 0-index base for the the sheet index and 1-
|
||||
|
||||
.. method:: get_cell_content(sheet: int, row: int, column: int) -> str
|
||||
|
||||
Returns the raw content of a cell. If the cell contains a formula,
|
||||
Returns the raw content of a cell. If the cell contains a formula,
|
||||
the returned string starts with ``"="``.
|
||||
|
||||
:param sheet: The sheet index (0-based).
|
||||
@@ -47,7 +47,7 @@ In general methods in IronCalc use a 0-index base for the the sheet index and 1-
|
||||
|
||||
.. method:: get_formatted_cell_value(sheet: int, row: int, column: int) -> str
|
||||
|
||||
Returns the cell’s value as a formatted string, taking into
|
||||
Returns the cell’s value as a formatted string, taking into
|
||||
account any number/currency/date formatting.
|
||||
|
||||
:param sheet: The sheet index (0-based).
|
||||
@@ -167,7 +167,7 @@ In general methods in IronCalc use a 0-index base for the the sheet index and 1-
|
||||
|
||||
.. method:: get_worksheets_properties() -> List[PySheetProperty]
|
||||
|
||||
Returns a list of :class:`PySheetProperty` describing each worksheet’s
|
||||
Returns a list of :class:`PySheetProperty` describing each worksheet’s
|
||||
name, visibility state, ID, and tab color.
|
||||
|
||||
:rtype: list of PySheetProperty
|
||||
@@ -204,7 +204,7 @@ In general methods in IronCalc use a 0-index base for the the sheet index and 1-
|
||||
|
||||
.. method:: test_panic()
|
||||
|
||||
A test method that deliberately panics in Rust.
|
||||
A test method that deliberately panics in Rust.
|
||||
Used for testing panic handling at the method level.
|
||||
|
||||
:raises WorkbookError: (wrapped Rust panic)
|
||||
@@ -8,8 +8,7 @@ IronCalc
|
||||
installation
|
||||
usage_examples
|
||||
top_level_methods
|
||||
raw_api_reference
|
||||
user_api_reference
|
||||
api_reference
|
||||
objects
|
||||
|
||||
IronCalc is a spreadsheet engine that allows you to create, modify and save spreadsheets.
|
||||
|
||||
@@ -1,13 +1,6 @@
|
||||
Top Level Methods
|
||||
-----------------
|
||||
|
||||
This module provides a set of top-level methods for creating and loading IronCalc models.
|
||||
|
||||
.. autofunction:: ironcalc.create
|
||||
.. autofunction:: ironcalc.load_from_xlsx
|
||||
.. autofunction:: ironcalc.load_from_icalc
|
||||
.. autofunction:: ironcalc.load_from_bytes
|
||||
.. autofunction:: ironcalc.create_user_model
|
||||
.. autofunction:: ironcalc.create_user_model_from_bytes
|
||||
.. autofunction:: ironcalc.create_user_model_from_xlsx
|
||||
.. autofunction:: ironcalc.create_user_model_from_icalc
|
||||
.. autofunction:: ironcalc.load_from_icalc
|
||||
@@ -1,41 +0,0 @@
|
||||
User API Reference
|
||||
------------------
|
||||
|
||||
This is the "user api". Models here have history, they evaluate automatically with each change and have a "diff" history.
|
||||
|
||||
|
||||
.. method:: save_to_xlsx(file: str)
|
||||
|
||||
Saves the user model to file in the XLSX format.
|
||||
|
||||
::param file: The file path to save the model to.
|
||||
|
||||
.. method:: save_to_icalc(file: str)
|
||||
|
||||
Saves the user model to file in the internal binary ic format.
|
||||
|
||||
::param file: The file path to save the model to.
|
||||
|
||||
.. method:: apply_external_diffs(external_diffs: bytes)
|
||||
|
||||
Applies external diffs to the model. This is used to apply changes from other instances of the model.
|
||||
|
||||
::param external_diffs: The external diffs to apply, as a byte array.
|
||||
|
||||
.. method:: flush_send_queue() -> bytes
|
||||
|
||||
Flushes the send queue and returns the bytes to be sent to the client. This is used to send changes to the client.
|
||||
|
||||
.. method:: set_user_input(sheet: int, row: int, column: int, value: str)
|
||||
|
||||
Sets an input in a cell, as would be done by a user typing into a spreadsheet cell.
|
||||
|
||||
.. method:: get_formatted_cell_value(sheet: int, row: int, column: int) -> str
|
||||
|
||||
Returns the cell’s value as a formatted string, taking into account any number/currency/date formatting.
|
||||
|
||||
.. method:: to_bytes() -> bytes
|
||||
|
||||
Returns the model as a byte array. This is useful for sending the model over a network or saving it to a file.
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
[project]
|
||||
name = "ironcalc"
|
||||
version = "0.5.7"
|
||||
version = "0.5.0"
|
||||
description = "Create, edit and evaluate Excel spreadsheets"
|
||||
requires-python = ">=3.10"
|
||||
keywords = [
|
||||
|
||||
@@ -1,89 +1,19 @@
|
||||
use pyo3::exceptions::PyException;
|
||||
use pyo3::{create_exception, prelude::*, wrap_pyfunction};
|
||||
|
||||
use types::{PyCellType, PySheetProperty, PyStyle};
|
||||
use xlsx::base::types::{Style, Workbook};
|
||||
use xlsx::base::{Model, UserModel};
|
||||
use types::{PySheetProperty, PyStyle};
|
||||
use xlsx::base::types::Style;
|
||||
use xlsx::base::Model;
|
||||
|
||||
use xlsx::export::{save_to_icalc, save_to_xlsx};
|
||||
use xlsx::import;
|
||||
|
||||
mod types;
|
||||
|
||||
use crate::types::PyCellType;
|
||||
|
||||
create_exception!(_ironcalc, WorkbookError, PyException);
|
||||
|
||||
#[pyclass]
|
||||
pub struct PyUserModel {
|
||||
/// The user model, which is a wrapper around the Model
|
||||
pub model: UserModel,
|
||||
}
|
||||
|
||||
#[pymethods]
|
||||
impl PyUserModel {
|
||||
/// Saves the user model to an xlsx file
|
||||
pub fn save_to_xlsx(&self, file: &str) -> PyResult<()> {
|
||||
let model = self.model.get_model();
|
||||
save_to_xlsx(model, file).map_err(|e| WorkbookError::new_err(e.to_string()))
|
||||
}
|
||||
|
||||
/// Saves the user model to file in the internal binary ic format
|
||||
pub fn save_to_icalc(&self, file: &str) -> PyResult<()> {
|
||||
let model = self.model.get_model();
|
||||
save_to_icalc(model, file).map_err(|e| WorkbookError::new_err(e.to_string()))
|
||||
}
|
||||
|
||||
pub fn apply_external_diffs(&mut self, external_diffs: &[u8]) -> PyResult<()> {
|
||||
self.model
|
||||
.apply_external_diffs(external_diffs)
|
||||
.map_err(|e| WorkbookError::new_err(e.to_string()))
|
||||
}
|
||||
|
||||
pub fn flush_send_queue(&mut self) -> Vec<u8> {
|
||||
self.model.flush_send_queue()
|
||||
}
|
||||
|
||||
pub fn set_user_input(
|
||||
&mut self,
|
||||
sheet: u32,
|
||||
row: i32,
|
||||
column: i32,
|
||||
value: &str,
|
||||
) -> PyResult<()> {
|
||||
self.model
|
||||
.set_user_input(sheet, row, column, value)
|
||||
.map_err(|e| WorkbookError::new_err(e.to_string()))
|
||||
}
|
||||
|
||||
pub fn get_formatted_cell_value(&self, sheet: u32, row: i32, column: i32) -> PyResult<String> {
|
||||
self.model
|
||||
.get_formatted_cell_value(sheet, row, column)
|
||||
.map_err(|e| WorkbookError::new_err(e.to_string()))
|
||||
}
|
||||
|
||||
/// Gets the dimensions of a worksheet, returning the bounds of all non-empty cells.
|
||||
/// Returns a tuple of (min_row, max_row, min_column, max_column).
|
||||
/// For an empty sheet, returns (1, 1, 1, 1).
|
||||
pub fn get_sheet_dimensions(&self, sheet: u32) -> PyResult<(i32, i32, i32, i32)> {
|
||||
let model = self.model.get_model();
|
||||
let worksheet = model
|
||||
.workbook
|
||||
.worksheet(sheet)
|
||||
.map_err(|e| WorkbookError::new_err(e.to_string()))?;
|
||||
let dimension = worksheet.dimension();
|
||||
Ok((
|
||||
dimension.min_row,
|
||||
dimension.max_row,
|
||||
dimension.min_column,
|
||||
dimension.max_column,
|
||||
))
|
||||
}
|
||||
|
||||
pub fn to_bytes(&self) -> PyResult<Vec<u8>> {
|
||||
let bytes = self.model.to_bytes();
|
||||
Ok(bytes)
|
||||
}
|
||||
}
|
||||
|
||||
/// This is a model implementing the 'raw' API
|
||||
#[pyclass]
|
||||
pub struct PyModel {
|
||||
@@ -102,12 +32,6 @@ impl PyModel {
|
||||
save_to_icalc(&self.model, file).map_err(|e| WorkbookError::new_err(e.to_string()))
|
||||
}
|
||||
|
||||
/// To bytes
|
||||
pub fn to_bytes(&self) -> PyResult<Vec<u8>> {
|
||||
let bytes = self.model.to_bytes();
|
||||
Ok(bytes)
|
||||
}
|
||||
|
||||
/// Evaluates the workbook
|
||||
pub fn evaluate(&mut self) {
|
||||
self.model.evaluate()
|
||||
@@ -301,24 +225,6 @@ impl PyModel {
|
||||
.map_err(|e| WorkbookError::new_err(e.to_string()))
|
||||
}
|
||||
|
||||
/// Gets the dimensions of a worksheet, returning the bounds of all non-empty cells.
|
||||
/// Returns a tuple of (min_row, max_row, min_column, max_column).
|
||||
/// For an empty sheet, returns (1, 1, 1, 1).
|
||||
pub fn get_sheet_dimensions(&self, sheet: u32) -> PyResult<(i32, i32, i32, i32)> {
|
||||
let worksheet = self
|
||||
.model
|
||||
.workbook
|
||||
.worksheet(sheet)
|
||||
.map_err(|e| WorkbookError::new_err(e.to_string()))?;
|
||||
let dimension = worksheet.dimension();
|
||||
Ok((
|
||||
dimension.min_row,
|
||||
dimension.max_row,
|
||||
dimension.min_column,
|
||||
dimension.max_column,
|
||||
))
|
||||
}
|
||||
|
||||
#[allow(clippy::panic)]
|
||||
pub fn test_panic(&self) -> PyResult<()> {
|
||||
panic!("This function panics for testing panic handling");
|
||||
@@ -343,19 +249,7 @@ pub fn load_from_icalc(file_name: &str) -> PyResult<PyModel> {
|
||||
Ok(PyModel { model })
|
||||
}
|
||||
|
||||
/// Loads a model from bytes
|
||||
/// This function expects the bytes to be in the internal binary ic format
|
||||
/// which is the same format used by the `save_to_icalc` function.
|
||||
#[pyfunction]
|
||||
pub fn load_from_bytes(bytes: &[u8]) -> PyResult<PyModel> {
|
||||
let workbook: Workbook =
|
||||
bitcode::decode(bytes).map_err(|e| WorkbookError::new_err(e.to_string()))?;
|
||||
let model =
|
||||
Model::from_workbook(workbook).map_err(|e| WorkbookError::new_err(e.to_string()))?;
|
||||
Ok(PyModel { model })
|
||||
}
|
||||
|
||||
/// Creates an empty model in the raw API
|
||||
/// Creates an empty model
|
||||
#[pyfunction]
|
||||
pub fn create(name: &str, locale: &str, tz: &str) -> PyResult<PyModel> {
|
||||
let model =
|
||||
@@ -363,49 +257,6 @@ pub fn create(name: &str, locale: &str, tz: &str) -> PyResult<PyModel> {
|
||||
Ok(PyModel { model })
|
||||
}
|
||||
|
||||
/// Creates a model with the user model API
|
||||
#[pyfunction]
|
||||
pub fn create_user_model(name: &str, locale: &str, tz: &str) -> PyResult<PyUserModel> {
|
||||
let model = UserModel::new_empty(name, locale, tz)
|
||||
.map_err(|e| WorkbookError::new_err(e.to_string()))?;
|
||||
Ok(PyUserModel { model })
|
||||
}
|
||||
|
||||
/// Creates a user model from an Excel file
|
||||
#[pyfunction]
|
||||
pub fn create_user_model_from_xlsx(
|
||||
file_path: &str,
|
||||
locale: &str,
|
||||
tz: &str,
|
||||
) -> PyResult<PyUserModel> {
|
||||
let model = import::load_from_xlsx(file_path, locale, tz)
|
||||
.map_err(|e| WorkbookError::new_err(e.to_string()))?;
|
||||
let model = UserModel::from_model(model);
|
||||
Ok(PyUserModel { model })
|
||||
}
|
||||
|
||||
/// Creates a user model from an icalc file
|
||||
#[pyfunction]
|
||||
pub fn create_user_model_from_icalc(file_name: &str) -> PyResult<PyUserModel> {
|
||||
let model =
|
||||
import::load_from_icalc(file_name).map_err(|e| WorkbookError::new_err(e.to_string()))?;
|
||||
let model = UserModel::from_model(model);
|
||||
Ok(PyUserModel { model })
|
||||
}
|
||||
|
||||
/// Creates a user model from bytes
|
||||
/// This function expects the bytes to be in the internal binary ic format
|
||||
/// which is the same format used by the `save_to_icalc` function.
|
||||
#[pyfunction]
|
||||
pub fn create_user_model_from_bytes(bytes: &[u8]) -> PyResult<PyUserModel> {
|
||||
let workbook: Workbook =
|
||||
bitcode::decode(bytes).map_err(|e| WorkbookError::new_err(e.to_string()))?;
|
||||
let model =
|
||||
Model::from_workbook(workbook).map_err(|e| WorkbookError::new_err(e.to_string()))?;
|
||||
let user_model = UserModel::from_model(model);
|
||||
Ok(PyUserModel { model: user_model })
|
||||
}
|
||||
|
||||
#[pyfunction]
|
||||
#[allow(clippy::panic)]
|
||||
pub fn test_panic() {
|
||||
@@ -421,14 +272,7 @@ fn ironcalc(m: &Bound<'_, PyModule>) -> PyResult<()> {
|
||||
m.add_function(wrap_pyfunction!(create, m)?)?;
|
||||
m.add_function(wrap_pyfunction!(load_from_xlsx, m)?)?;
|
||||
m.add_function(wrap_pyfunction!(load_from_icalc, m)?)?;
|
||||
m.add_function(wrap_pyfunction!(load_from_bytes, m)?)?;
|
||||
m.add_function(wrap_pyfunction!(test_panic, m)?)?;
|
||||
|
||||
// User model functions
|
||||
m.add_function(wrap_pyfunction!(create_user_model, m)?)?;
|
||||
m.add_function(wrap_pyfunction!(create_user_model_from_bytes, m)?)?;
|
||||
m.add_function(wrap_pyfunction!(create_user_model_from_xlsx, m)?)?;
|
||||
m.add_function(wrap_pyfunction!(create_user_model_from_icalc, m)?)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -6,52 +6,3 @@ def test_simple():
|
||||
model.evaluate()
|
||||
|
||||
assert model.get_formatted_cell_value(0, 1, 1) == "3"
|
||||
|
||||
bytes = model.to_bytes()
|
||||
|
||||
model2 = ic.load_from_bytes(bytes)
|
||||
assert model2.get_formatted_cell_value(0, 1, 1) == "3"
|
||||
|
||||
|
||||
def test_simple_user():
|
||||
model = ic.create_user_model("model", "en", "UTC")
|
||||
model.set_user_input(0, 1, 1, "=1+2")
|
||||
model.set_user_input(0, 1, 2, "=A1+3")
|
||||
|
||||
assert model.get_formatted_cell_value(0, 1, 1) == "3"
|
||||
assert model.get_formatted_cell_value(0, 1, 2) == "6"
|
||||
|
||||
diffs = model.flush_send_queue()
|
||||
|
||||
model2 = ic.create_user_model("model", "en", "UTC")
|
||||
model2.apply_external_diffs(diffs)
|
||||
assert model2.get_formatted_cell_value(0, 1, 1) == "3"
|
||||
assert model2.get_formatted_cell_value(0, 1, 2) == "6"
|
||||
|
||||
|
||||
def test_sheet_dimensions():
|
||||
# Test with empty sheet
|
||||
model = ic.create("model", "en", "UTC")
|
||||
min_row, max_row, min_col, max_col = model.get_sheet_dimensions(0)
|
||||
assert (min_row, max_row, min_col, max_col) == (1, 1, 1, 1)
|
||||
|
||||
# Add some cells
|
||||
model.set_user_input(0, 3, 5, "Hello")
|
||||
model.set_user_input(0, 10, 8, "World")
|
||||
model.evaluate()
|
||||
|
||||
# Check dimensions - should span from (3,5) to (10,8)
|
||||
min_row, max_row, min_col, max_col = model.get_sheet_dimensions(0)
|
||||
assert (min_row, max_row, min_col, max_col) == (3, 10, 5, 8)
|
||||
|
||||
|
||||
def test_sheet_dimensions_user_model():
|
||||
# Test with user model API as well
|
||||
model = ic.create_user_model("model", "en", "UTC")
|
||||
|
||||
# Add a single cell
|
||||
model.set_user_input(0, 2, 3, "Test")
|
||||
|
||||
# Check dimensions
|
||||
min_row, max_row, min_col, max_col = model.get_sheet_dimensions(0)
|
||||
assert (min_row, max_row, min_col, max_col) == (2, 2, 3, 3)
|
||||
|
||||
@@ -7,7 +7,6 @@ use wasm_bindgen::{
|
||||
use ironcalc_base::{
|
||||
expressions::{lexer::util::get_tokens as tokenizer, types::Area, utils::number_to_column},
|
||||
types::{CellType, Style},
|
||||
worksheet::NavigationDirection,
|
||||
BorderArea, ClipboardData, UserModel as BaseModel,
|
||||
};
|
||||
|
||||
@@ -196,61 +195,24 @@ impl Model {
|
||||
.map_err(to_js_error)
|
||||
}
|
||||
|
||||
#[wasm_bindgen(js_name = "insertRows")]
|
||||
pub fn insert_rows(&mut self, sheet: u32, row: i32, row_count: i32) -> Result<(), JsError> {
|
||||
self.model
|
||||
.insert_rows(sheet, row, row_count)
|
||||
.map_err(to_js_error)
|
||||
#[wasm_bindgen(js_name = "insertRow")]
|
||||
pub fn insert_row(&mut self, sheet: u32, row: i32) -> Result<(), JsError> {
|
||||
self.model.insert_row(sheet, row).map_err(to_js_error)
|
||||
}
|
||||
|
||||
#[wasm_bindgen(js_name = "insertColumns")]
|
||||
pub fn insert_columns(
|
||||
&mut self,
|
||||
sheet: u32,
|
||||
column: i32,
|
||||
column_count: i32,
|
||||
) -> Result<(), JsError> {
|
||||
self.model
|
||||
.insert_columns(sheet, column, column_count)
|
||||
.map_err(to_js_error)
|
||||
#[wasm_bindgen(js_name = "insertColumn")]
|
||||
pub fn insert_column(&mut self, sheet: u32, column: i32) -> Result<(), JsError> {
|
||||
self.model.insert_column(sheet, column).map_err(to_js_error)
|
||||
}
|
||||
|
||||
#[wasm_bindgen(js_name = "deleteRows")]
|
||||
pub fn delete_rows(&mut self, sheet: u32, row: i32, row_count: i32) -> Result<(), JsError> {
|
||||
self.model
|
||||
.delete_rows(sheet, row, row_count)
|
||||
.map_err(to_js_error)
|
||||
#[wasm_bindgen(js_name = "deleteRow")]
|
||||
pub fn delete_row(&mut self, sheet: u32, row: i32) -> Result<(), JsError> {
|
||||
self.model.delete_row(sheet, row).map_err(to_js_error)
|
||||
}
|
||||
|
||||
#[wasm_bindgen(js_name = "deleteColumns")]
|
||||
pub fn delete_columns(
|
||||
&mut self,
|
||||
sheet: u32,
|
||||
column: i32,
|
||||
column_count: i32,
|
||||
) -> Result<(), JsError> {
|
||||
self.model
|
||||
.delete_columns(sheet, column, column_count)
|
||||
.map_err(to_js_error)
|
||||
}
|
||||
|
||||
#[wasm_bindgen(js_name = "moveColumn")]
|
||||
pub fn move_column_action(
|
||||
&mut self,
|
||||
sheet: u32,
|
||||
column: i32,
|
||||
delta: i32,
|
||||
) -> Result<(), JsError> {
|
||||
self.model
|
||||
.move_column_action(sheet, column, delta)
|
||||
.map_err(to_js_error)
|
||||
}
|
||||
|
||||
#[wasm_bindgen(js_name = "moveRow")]
|
||||
pub fn move_row_action(&mut self, sheet: u32, row: i32, delta: i32) -> Result<(), JsError> {
|
||||
self.model
|
||||
.move_row_action(sheet, row, delta)
|
||||
.map_err(to_js_error)
|
||||
#[wasm_bindgen(js_name = "deleteColumn")]
|
||||
pub fn delete_column(&mut self, sheet: u32, column: i32) -> Result<(), JsError> {
|
||||
self.model.delete_column(sheet, column).map_err(to_js_error)
|
||||
}
|
||||
|
||||
#[wasm_bindgen(js_name = "setRowsHeight")]
|
||||
@@ -568,20 +530,6 @@ impl Model {
|
||||
self.model.on_page_up().map_err(to_js_error)
|
||||
}
|
||||
|
||||
#[wasm_bindgen(js_name = "onNavigateToEdgeInDirection")]
|
||||
pub fn on_navigate_to_edge_in_direction(&mut self, direction: &str) -> Result<(), JsError> {
|
||||
let direction = match direction {
|
||||
"ArrowLeft" => NavigationDirection::Left,
|
||||
"ArrowRight" => NavigationDirection::Right,
|
||||
"ArrowUp" => NavigationDirection::Up,
|
||||
"ArrowDown" => NavigationDirection::Down,
|
||||
_ => return Err(JsError::new(&format!("Invalid direction: {direction}"))),
|
||||
};
|
||||
self.model
|
||||
.on_navigate_to_edge_in_direction(direction)
|
||||
.map_err(to_js_error)
|
||||
}
|
||||
|
||||
#[wasm_bindgen(js_name = "setWindowWidth")]
|
||||
pub fn set_window_width(&mut self, window_width: f64) {
|
||||
self.model.set_window_width(window_width);
|
||||
@@ -742,28 +690,4 @@ impl Model {
|
||||
.delete_defined_name(name, scope)
|
||||
.map_err(|e| to_js_error(e.to_string()))
|
||||
}
|
||||
|
||||
#[wasm_bindgen(js_name = "getLastNonEmptyInRowBeforeColumn")]
|
||||
pub fn get_last_non_empty_in_row_before_column(
|
||||
&self,
|
||||
sheet: u32,
|
||||
row: i32,
|
||||
column: i32,
|
||||
) -> Result<Option<i32>, JsError> {
|
||||
self.model
|
||||
.get_last_non_empty_in_row_before_column(sheet, row, column)
|
||||
.map_err(to_js_error)
|
||||
}
|
||||
|
||||
#[wasm_bindgen(js_name = "getFirstNonEmptyInRowAfterColumn")]
|
||||
pub fn get_first_non_empty_in_row_after_column(
|
||||
&self,
|
||||
sheet: u32,
|
||||
row: i32,
|
||||
column: i32,
|
||||
) -> Result<Option<i32>, JsError> {
|
||||
self.model
|
||||
.get_first_non_empty_in_row_after_column(sheet, row, column)
|
||||
.map_err(to_js_error)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -130,82 +130,5 @@ test("autofill", () => {
|
||||
assert.strictEqual(result, "23");
|
||||
});
|
||||
|
||||
test('insertRows shifts cells', () => {
|
||||
const model = new Model('Workbook1', 'en', 'UTC');
|
||||
model.setUserInput(0, 1, 1, '42');
|
||||
model.insertRows(0, 1, 1);
|
||||
|
||||
assert.strictEqual(model.getCellContent(0, 1, 1), '');
|
||||
assert.strictEqual(model.getCellContent(0, 2, 1), '42');
|
||||
});
|
||||
|
||||
test('insertColumns shifts cells', () => {
|
||||
const model = new Model('Workbook1', 'en', 'UTC');
|
||||
model.setUserInput(0, 1, 1, 'A');
|
||||
model.setUserInput(0, 1, 2, 'B');
|
||||
|
||||
model.insertColumns(0, 2, 1);
|
||||
|
||||
assert.strictEqual(model.getCellContent(0, 1, 2), '');
|
||||
assert.strictEqual(model.getCellContent(0, 1, 3), 'B');
|
||||
});
|
||||
|
||||
test('deleteRows removes cells', () => {
|
||||
const model = new Model('Workbook1', 'en', 'UTC');
|
||||
model.setUserInput(0, 1, 1, '1');
|
||||
model.setUserInput(0, 2, 1, '2');
|
||||
|
||||
model.deleteRows(0, 1, 1);
|
||||
|
||||
assert.strictEqual(model.getCellContent(0, 1, 1), '2');
|
||||
assert.strictEqual(model.getCellContent(0, 2, 1), '');
|
||||
});
|
||||
|
||||
test('deleteColumns removes cells', () => {
|
||||
const model = new Model('Workbook1', 'en', 'UTC');
|
||||
model.setUserInput(0, 1, 1, 'A');
|
||||
model.setUserInput(0, 1, 2, 'B');
|
||||
|
||||
model.deleteColumns(0, 1, 1);
|
||||
|
||||
assert.strictEqual(model.getCellContent(0, 1, 1), 'B');
|
||||
assert.strictEqual(model.getCellContent(0, 1, 2), '');
|
||||
});
|
||||
|
||||
test("move row", () => {
|
||||
const model = new Model('Workbook1', 'en', 'UTC');
|
||||
model.setUserInput(0, 3, 5, "=G3");
|
||||
model.setUserInput(0, 4, 5, "=G4");
|
||||
model.setUserInput(0, 5, 5, "=SUM(G3:J3)");
|
||||
model.setUserInput(0, 6, 5, "=SUM(G3:G3)");
|
||||
model.setUserInput(0, 7, 5, "=SUM(G4:G4)");
|
||||
model.evaluate();
|
||||
|
||||
model.moveRow(0, 3, 1);
|
||||
model.evaluate();
|
||||
|
||||
assert.strictEqual(model.getCellContent(0, 3, 5), "=G3");
|
||||
assert.strictEqual(model.getCellContent(0, 4, 5), "=G4");
|
||||
assert.strictEqual(model.getCellContent(0, 5, 5), "=SUM(G4:J4)");
|
||||
assert.strictEqual(model.getCellContent(0, 6, 5), "=SUM(G4:G4)");
|
||||
assert.strictEqual(model.getCellContent(0, 7, 5), "=SUM(G3:G3)");
|
||||
});
|
||||
|
||||
test("move column", () => {
|
||||
const model = new Model('Workbook1', 'en', 'UTC');
|
||||
model.setUserInput(0, 3, 5, "=G3");
|
||||
model.setUserInput(0, 4, 5, "=H3");
|
||||
model.setUserInput(0, 5, 5, "=SUM(G3:J7)");
|
||||
model.setUserInput(0, 6, 5, "=SUM(G3:G7)");
|
||||
model.setUserInput(0, 7, 5, "=SUM(H3:H7)");
|
||||
model.evaluate();
|
||||
|
||||
model.moveColumn(0, 7, 1);
|
||||
model.evaluate();
|
||||
|
||||
assert.strictEqual(model.getCellContent(0, 3, 5), "=H3");
|
||||
assert.strictEqual(model.getCellContent(0, 4, 5), "=G3");
|
||||
assert.strictEqual(model.getCellContent(0, 5, 5), "=SUM(H3:J7)");
|
||||
assert.strictEqual(model.getCellContent(0, 6, 5), "=SUM(H3:H7)");
|
||||
assert.strictEqual(model.getCellContent(0, 7, 5), "=SUM(G3:G7)");
|
||||
});
|
||||
|
||||
1802
docs/package-lock.json
generated
1802
docs/package-lock.json
generated
File diff suppressed because it is too large
Load Diff
@@ -6,7 +6,7 @@
|
||||
},
|
||||
"devDependencies": {
|
||||
"markdown-it-mathjax3": "^4.3.2",
|
||||
"vitepress": "^v2.0.0-alpha.8",
|
||||
"vue": "^3.5.17"
|
||||
"vitepress": "^1.5.0",
|
||||
"vue": "^3.5.12"
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,57 +6,23 @@ lang: en-US
|
||||
|
||||
# Keyboard Shortcuts
|
||||
|
||||
From within your keyboard you can navigate and interact with the spreadsheet.
|
||||
From within your keyboard you can navigate and interact with the spreadsheet. This is a fairly interesting feature for power users.
|
||||
|
||||
## Navigation Shortcuts
|
||||
## Common Actions
|
||||
|
||||
| Action | Linux/Windows | Mac |
|
||||
| ----------------------- | ----------------- | -------------- |
|
||||
| Move one cell | Arrow Keys | Arrow Keys |
|
||||
| Move down (Excel-style) | Enter | Enter |
|
||||
| Move right | Tab | Tab |
|
||||
| Move left | Shift + Tab | Shift + Tab |
|
||||
| Jump to first column | Home | Fn + ← |
|
||||
| Jump to last column | End | Fn + → |
|
||||
| Scroll one screen down | PageDown | Fn + ↓ |
|
||||
| Scroll one screen up | PageUp | Fn + ↑ |
|
||||
| Jump to cell edge | Ctrl + Arrow Keys | ⌘ + Arrow Keys |
|
||||
| Jump to start of sheet | Ctrl + Home | ⌘ + Fn + ← |
|
||||
| Jump to end of sheet | Ctrl + End | ⌘ + Fn + → |
|
||||
| Action | Windows | Mac |
|
||||
| ------ | -------- | ----- |
|
||||
| Copy | ctrl + c | ⌘ + c |
|
||||
| Paste | ctrl + v | ⌘ + v |
|
||||
| Cut | ctrl + x | ⌘ + x |
|
||||
| Undo | ctrl + z | ⌘ + z |
|
||||
| Redo | ctrl + y | ⌘ + y |
|
||||
|
||||
## Selection & Editing
|
||||
## Navigation
|
||||
|
||||
| Action | Linux/Windows | Mac |
|
||||
| -------------------- | ------------------ | ------------------ |
|
||||
| Expand selection | Shift + Arrow Keys | Shift + Arrow Keys |
|
||||
| Start editing a cell | F2 | F2 |
|
||||
| Edit directly | Any key | Any key |
|
||||
|
||||
## Text Styling
|
||||
|
||||
| Action | Linux/Windows | Mac |
|
||||
| --------- | -------------- | ----- |
|
||||
| Bold | Ctrl + B | ⌘ + B |
|
||||
| Italic | Ctrl + I | ⌘ + I |
|
||||
| Underline | Ctrl + U | ⌘ + U |
|
||||
|
||||
## Undo / Redo
|
||||
|
||||
| Action | Linux/Windows | Mac |
|
||||
| ------ | ---------------------------- | -----------------------|
|
||||
| Undo | Ctrl + Z | ⌘ + Z |
|
||||
| Redo | Ctrl + Y or Ctrl + Shift + Z | ⌘ + Shift + Z or ⌘ + Y |
|
||||
|
||||
## Sheet Navigation
|
||||
|
||||
| Action | Linux/Windows | Mac |
|
||||
| -------------- | ---------------- | -------------- |
|
||||
| Next sheet | Alt + Arrow Down | ⌥ + Arrow Down |
|
||||
| Previous sheet | Alt + Arrow Up | ⌥ + Arrow Up |
|
||||
|
||||
## Miscellaneous
|
||||
|
||||
| Action | Linux/Windows/Mac |
|
||||
| ------------- | -------------------- |
|
||||
| Cancel action | Escape |
|
||||
| Delete cells | Delete |
|
||||
| <div style="width:200px">Action</div> | <div style="width:80px">Windows</div> | <div style="width:80px">Mac</div> |
|
||||
| ------------------------------------- | ------------------------------------- | --------------------------------- |
|
||||
| Move to beginning of row | ??? | Fn + Left Arrow |
|
||||
| Move to end of row | ??? | Fn + Right Arrow |
|
||||
| Move to previous sheet | Option + Arrow Up | Option + Arrow Up |
|
||||
| Move to next sheet | Option + Arrow Down | Option + Arrow Down |
|
||||
|
||||
@@ -66,8 +66,4 @@ Using IronCalc, a complex number is a string of the form "1+j3".
|
||||
|
||||
"#N/A" => #N/A
|
||||
|
||||
## Arrays
|
||||
|
||||
## References
|
||||
|
||||
A reference is a pointer to a single cell or a range of cells. The reference can either be entered manually, for example "A4", or as the result of a calculation, such as the OFFSET Function or the INDIRECT Function. A reference can also be built, for example with the Colon (\:) Operator.
|
||||
## Arrays
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 59 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 56 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 82 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 38 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 79 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 45 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 50 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 66 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 62 KiB |
@@ -16,7 +16,7 @@ You can track the progress in this [GitHub issue](https://github.com/ironcalc/Ir
|
||||
| CHOOSE | <Badge type="tip" text="Available" /> | – |
|
||||
| CHOOSECOLS | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| CHOOSEROWS | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| COLUMN | <Badge type="tip" text="Available" /> | [COLUMN](lookup_and_reference/column) |
|
||||
| COLUMN | <Badge type="tip" text="Available" /> | – |
|
||||
| COLUMNS | <Badge type="tip" text="Available" /> | – |
|
||||
| DROP | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| EXPAND | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
|
||||
@@ -4,28 +4,8 @@ outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# COLUMN function
|
||||
## Overview
|
||||
The COLUMN Function in IronCalc is a lookup & reference formula that is used to query and return the column number of a referenced Column or Cell.
|
||||
## Usage
|
||||
### Syntax
|
||||
**COLUMN(<span title="Reference" style="color:#1E88E5">reference</span>) => <span title="Number" style="color:#1E88E5">column</span>**
|
||||
### Argument descriptions
|
||||
* *reference* ([cell](/features/value-types#references), [optional](/features/optional-arguments.md)). The number of the cell you wish to reference the column number of.
|
||||
### Additional guidance
|
||||
* When referencing a range of cells, only the column number of the left most cell will be returned.
|
||||
* You are also able to reference complete columns instead of individual cells.
|
||||
### Returned value
|
||||
COLUMN returns the [number](/features/value-types#numbers) of the specific cell or column which is being referenced.
|
||||
### Error conditions
|
||||
* IronCalc currently does not support the referencing of cells with names.
|
||||
## Details
|
||||
The COLUMN Function can only be used to display the correlating number of a single column within a Sheet. If you wish to show the number of columns used within a specific range, you can use the COLUMNS Function.
|
||||
## Examples
|
||||
### No Cell Reference
|
||||
When no cell reference is made, the formula uses **=COLUMN()**. This will then output the column number of the cell where the formula is placed.<br><br>For example, if the formula is placed in cell A1, then "1" will be displayed.
|
||||
### With Cell Reference
|
||||
When a cell reference is made, the formula uses **=COLUMN([Referenced Cell])**. This will then output the column number of the referenced cell, regardless of where the formula is placed in the sheet.<br><br>For example, if the cell B1 is the referenced cell, "2" will be the output of the formula no matter where it is placed in the sheet.<br><br>**Note:** references do not always have to be specific cells, you can also reference complete columns. For example, **=COLUMN(B:B)** would also result in an output of "2".
|
||||
### Range References
|
||||
The COLUMN function can also be used to reference a range of Cells or Columns. In this case only the most left-hand column will be the resulting output.<br><br>For example, **=COLUMN(A1:J1)** will result in the ouput of "1".
|
||||
## Links
|
||||
# COLUMN
|
||||
|
||||
::: warning
|
||||
🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
|
||||
:::
|
||||
@@ -12,17 +12,17 @@ You can track the progress in this [GitHub issue](https://github.com/ironcalc/Ir
|
||||
| Function | Status | Documentation |
|
||||
| --------------- | ---------------------------------------------- | ------------- |
|
||||
| ABS | <Badge type="tip" text="Available" /> | – |
|
||||
| ACOS | <Badge type="tip" text="Available" /> | [ACOS](math_and_trigonometry/acos) |
|
||||
| ACOSH | <Badge type="tip" text="Available" /> | [ACOSH](math_and_trigonometry/acosh) |
|
||||
| ACOS | <Badge type="tip" text="Available" /> | – |
|
||||
| ACOSH | <Badge type="tip" text="Available" /> | – |
|
||||
| ACOT | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| ACOTH | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| AGGREGATE | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| ARABIC | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| ASIN | <Badge type="tip" text="Available" /> | [ASIN](math_and_trigonometry/asin) |
|
||||
| ASINH | <Badge type="tip" text="Available" /> | [ASINH](math_and_trigonometry/asinh) |
|
||||
| ATAN | <Badge type="tip" text="Available" /> | [ATAN](math_and_trigonometry/atan) |
|
||||
| ATAN2 | <Badge type="tip" text="Available" /> | [ATAN2](math_and_trigonometry/atan2) |
|
||||
| ATANH | <Badge type="tip" text="Available" /> | [ATANH](math_and_trigonometry/atanh) |
|
||||
| ASIN | <Badge type="tip" text="Available" /> | – |
|
||||
| ASINH | <Badge type="tip" text="Available" /> | – |
|
||||
| ATAN | <Badge type="tip" text="Available" /> | – |
|
||||
| ATAN2 | <Badge type="tip" text="Available" /> | – |
|
||||
| ATANH | <Badge type="tip" text="Available" /> | – |
|
||||
| BASE | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| CEILING | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| CEILING.MATH | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
@@ -30,7 +30,7 @@ You can track the progress in this [GitHub issue](https://github.com/ironcalc/Ir
|
||||
| COMBIN | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| COMBINA | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| COS | <Badge type="tip" text="Available" /> | [COS](math_and_trigonometry/cos) |
|
||||
| COSH | <Badge type="tip" text="Available" /> | [COSH](math_and_trigonometry/cosh) |
|
||||
| COSH | <Badge type="tip" text="Available" /> | – |
|
||||
| COT | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| COTH | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| CSC | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
@@ -49,9 +49,9 @@ You can track the progress in this [GitHub issue](https://github.com/ironcalc/Ir
|
||||
| ISO.CEILING | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| LCM | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| LET | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| LN | <Badge type="info" text="Available" /> | – |
|
||||
| LOG | <Badge type="info" text="Available" /> | – |
|
||||
| LOG10 | <Badge type="info" text="Available" /> | – |
|
||||
| LN | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| LOG | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| LOG10 | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| MDETERM | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| MINVERSE | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| MMULT | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
@@ -78,18 +78,18 @@ You can track the progress in this [GitHub issue](https://github.com/ironcalc/Ir
|
||||
| SEQUENCE | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| SIGN | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| SIN | <Badge type="tip" text="Available" /> | [SIN](math_and_trigonometry/sin) |
|
||||
| SINH | <Badge type="tip" text="Available" /> | [SINH](math_and_trigonometry/sinh) |
|
||||
| SINH | <Badge type="tip" text="Available" /> | – |
|
||||
| SQRT | <Badge type="tip" text="Available" /> | – |
|
||||
| SQRTPI | <Badge type="info" text="Available" /> | – |
|
||||
| SQRTPI | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| SUBTOTAL | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| SUM | <Badge type="tip" text="Available" /> | – |
|
||||
| SUMIF | <Badge type="tip" text="Available" /> | – |
|
||||
| SUMIFS | <Badge type="info" text="Available" /> | – |
|
||||
| SUMIFS | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| SUMPRODUCT | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| SUMSQ | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| SUMX2MY2 | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| SUMX2PY2 | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| SUMXMY2 | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
| TAN | <Badge type="tip" text="Available" /> | [TAN](math_and_trigonometry/tan) |
|
||||
| TANH | <Badge type="tip" text="Available" /> | [TANH](math_and_trigonometry/tanh) |
|
||||
| TANH | <Badge type="tip" text="Available" /> | – |
|
||||
| TRUNC | <Badge type="info" text="Not implemented yet" /> | – |
|
||||
|
||||
@@ -4,35 +4,8 @@ outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# ACOS function
|
||||
## Overview
|
||||
ACOS is a function of the Math and Trigonometry category that calculates the inverse cosine (arccosine) of a number in the range [-1 to 1], returning an angle in the range [0 to $\pi$], expressed in radians.
|
||||
## Usage
|
||||
### Syntax
|
||||
**ACOS(<span title="Number" style="color:#1E88E5">number</span>) => <span title="Number" style="color:#1E88E5">acos</span>**
|
||||
### Argument descriptions
|
||||
* *number* ([number](/features/value-types#numbers), required). The number whose arccosine is to be calculated, in the range [-1 to 1].
|
||||
### Additional guidance
|
||||
None.
|
||||
### Returned value
|
||||
ACOS returns a number in radians in the range [0 to $\pi$] that is the angle whose cosine is the specified number.
|
||||
### Error conditions
|
||||
* In common with many other IronCalc functions, ACOS propagates errors that are found in its argument.
|
||||
* If no argument, or more than one argument, is supplied, then ACOS returns the [`#ERROR!`](/features/error-types.md#error) error.
|
||||
* If the value of the *number* argument is not (or cannot be converted to) a [number](/features/value-types#numbers), then ACOS returns the [`#VALUE!`](/features/error-types.md#value) error.
|
||||
* If the value of the *number* argument lies outside the range [-1 to 1], then ACOS returns the [`#NUM!`](/features/error-types.md#num) error.
|
||||
* For some argument values, ACOS may return a [`#DIV/0!`](/features/error-types.md#div-0) error.
|
||||
<!--@include: ../markdown-snippets/error-type-details.txt-->
|
||||
## Details
|
||||
* The ACOS function utilizes the *acos()* method provided by the [Rust Standard Library](https://doc.rust-lang.org/std/).
|
||||
* The figure below illustrates the output of the ACOS function for angles $x$ in the range -1 to +1.
|
||||
<center><img src="/functions/images/arccosine-curve.png" width="350" alt="Graph showing acos(x) for x between -1 and +1."></center>
|
||||
# ACOS
|
||||
|
||||
## Examples
|
||||
[See some examples in IronCalc](https://app.ironcalc.com/?example=acos).
|
||||
|
||||
## Links
|
||||
* For more information about inverse trigonometric functions, visit Wikipedia's [Inverse trigonometric functions](https://en.wikipedia.org/wiki/Inverse_trigonometric_functions) page.
|
||||
* See also IronCalc's [SIN](/functions/math_and_trigonometry/sin), [COS](/functions/math_and_trigonometry/cos) and [TAN](/functions/math_and_trigonometry/tan) functions.
|
||||
* Visit Microsoft Excel's [ACOS function](https://support.microsoft.com/en-us/office/acos-function-cb73173f-d089-4582-afa1-76e5524b5d5b) page.
|
||||
* Both [Google Sheets](https://support.google.com/docs/answer/3093461) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/ACOS) provide versions of the ACOS function.
|
||||
::: warning
|
||||
🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
|
||||
:::
|
||||
@@ -3,40 +3,9 @@ layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
# ACOSH function
|
||||
## Overview
|
||||
ACOSH is a function of the Math and Trigonometry category that calculates the inverse hyperbolic cosine (hyperbolic arccosine) of a number, returning a non-negative value in the range [0, +∞).
|
||||
## Usage
|
||||
### Syntax
|
||||
**ACOSH(<span title="Number" style="color:#1E88E5">number</span>) => <span title="Number" style="color:#1E88E5">acosh</span>**
|
||||
### Argument descriptions
|
||||
* *number* ([number](/features/value-types#numbers), required). The value whose hyperbolic arccosine is to be calculated. The value must be greater than or equal to 1.
|
||||
|
||||
### Additional guidance
|
||||
The hyperbolic arccosine function is defined as:
|
||||
# ACOSH
|
||||
|
||||
$$
|
||||
\operatorname{acosh}(x) = \ln(x + \sqrt{x^2 - 1})
|
||||
$$
|
||||
|
||||
### Returned value
|
||||
ACOSH returns a [number](/features/value-types#numbers) in the range [0, +∞) that is the hyperbolic arccosine of the specified value, expressed in radians.
|
||||
### Error conditions
|
||||
* In common with many other IronCalc functions, ACOSH propagates errors that are found in its argument.
|
||||
* If no argument, or more than one argument, is supplied, then ACOSH returns the [`#ERROR!`](/features/error-types.md#error) error.
|
||||
* If the value of the *number* argument is not (or cannot be converted to) a [number](/features/value-types#numbers), then ACOSH returns the [`#VALUE!`](/features/error-types.md#value) error.
|
||||
* If the value of the *number* argument is less than 1, then ACOSH returns the [`#NUM!`](/features/error-types.md#num) error.
|
||||
<!--@include: ../markdown-snippets/error-type-details.txt-->
|
||||
## Details
|
||||
* The ACOSH function utilizes the *acosh()* method provided by the [Rust Standard Library](https://doc.rust-lang.org/std/).
|
||||
* The figure below illustrates the output of the ACOSH function for values $x \geq 1$ in the range [0, +∞).
|
||||
<center><img src="/functions/images/hyperbolicarccosine-curve.png" width="350" alt="Graph showing acosh(x) for x ≥ 1."></center>
|
||||
|
||||
## Examples
|
||||
[See some examples in IronCalc](https://app.ironcalc.com/?example=acosh).
|
||||
|
||||
## Links
|
||||
* For more information about inverse hyperbolic functions, visit Wikipedia's [Inverse hyperbolic functions](https://en.wikipedia.org/wiki/Inverse_hyperbolic_functions) page.
|
||||
* See also IronCalc's [COSH](/functions/math_and_trigonometry/cosh), [ASINH](/functions/math_and_trigonometry/asinh) and [ATANH](/functions/math_and_trigonometry/atanh) functions.
|
||||
* Visit Microsoft Excel's [ACOSH function](https://support.microsoft.com/en-us/office/acosh-function-e3992cc1-103f-4e72-9f04-624b9ef5ebfe) page.
|
||||
* Both [Google Sheets](https://support.google.com/docs/answer/3093391) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/ACOSH) provide versions of the ACOSH function.
|
||||
::: warning
|
||||
🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
|
||||
:::
|
||||
@@ -4,37 +4,8 @@ outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# ASIN function
|
||||
# ASIN
|
||||
|
||||
## Overview
|
||||
ASIN is a function of the Math and Trigonometry category that calculates the inverse sine (arcsine) of a number in the range [-1 to +1], returning an angle in the range [-$\pi$/2 to +$\pi$/2], expressed in radians.
|
||||
## Usage
|
||||
### Syntax
|
||||
**ASIN(<span title="Number" style="color:#1E88E5">number</span>) => <span title="Number" style="color:#1E88E5">asin</span>**
|
||||
### Argument descriptions
|
||||
* *number* ([number](/features/value-types#numbers), required). The number whose arcsine is to be calculated, in the range [-1 to +1].
|
||||
|
||||
### Additional guidance
|
||||
None.
|
||||
### Returned value
|
||||
ASIN returns a number in radians in the range [-$\pi$/2 to +$\pi$/2] that is the angle whose sine is the specified number.
|
||||
### Error conditions
|
||||
* In common with many other IronCalc functions, ASIN propagates errors that are found in its argument.
|
||||
* If no argument, or more than one argument, is supplied, then ASIN returns the [`#ERROR!`](/features/error-types.md#error) error.
|
||||
* If the value of the *number* argument is not (or cannot be converted to) a [number](/features/value-types#numbers), then ASIN returns the [`#VALUE!`](/features/error-types.md#value) error.
|
||||
* If the value of the *number* argument lies outside the range [-1 to +1], then ASIN returns the [`#NUM!`](/features/error-types.md#num) error.
|
||||
* For some argument values, ASIN may return a [`#DIV/0!`](/features/error-types.md#div-0) error.
|
||||
<!--@include: ../markdown-snippets/error-type-details.txt-->
|
||||
## Details
|
||||
* The ASIN function utilizes the *asin()* method provided by the [Rust Standard Library](https://doc.rust-lang.org/std/).
|
||||
* The figure below illustrates the output of the ASIN function for angles $x$ in the range -1 to +1 radians.
|
||||
<center><img src="/functions/images/arcsine-curve.png" width="350" alt="Graph showing sin(x) for x between -2π and +2π."></center>
|
||||
|
||||
## Examples
|
||||
[See some examples in IronCalc](https://app.ironcalc.com/?example=asin).
|
||||
|
||||
## Links
|
||||
* For more information about inverse trigonometric functions, visit Wikipedia's [Inverse trigonometric functions](https://en.wikipedia.org/wiki/Inverse_trigonometric_functions) page.
|
||||
* See also IronCalc's [SIN](/functions/math_and_trigonometry/sin), [COS](/functions/math_and_trigonometry/cos) and [TAN](/functions/math_and_trigonometry/tan) functions.
|
||||
* Visit Microsoft Excel's [ASIN function](https://support.microsoft.com/en-us/office/asin-function-81fb95e5-6d6f-48c4-bc45-58f955c6d347) page.
|
||||
* Both [Google Sheets](https://support.google.com/docs/answer/3093464) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/ASIN) provide versions of the ASIN function.
|
||||
::: warning
|
||||
🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
|
||||
:::
|
||||
@@ -4,36 +4,8 @@ outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# ASINH function
|
||||
## Overview
|
||||
ASINH is a function of the Math and Trigonometry category that calculates the inverse hyperbolic sine (hyperbolic arcsine) of a number, returning the hyperbolic angle expressed in radians.
|
||||
## Usage
|
||||
### Syntax
|
||||
**ASINH(<span title="Number" style="color:#1E88E5">number</span>) => <span title="Number" style="color:#1E88E5">asinh</span>**
|
||||
### Argument descriptions
|
||||
* *number* ([number](/features/value-types#numbers), required). The value whose inverse hyperbolic sine is to be calculated.
|
||||
### Additional guidance
|
||||
The hyperbolic arcsine function is defined as:
|
||||
$$
|
||||
\operatorname{asinh}(x) = \ln\!\left(x + \sqrt{x^2 + 1}\,\right)
|
||||
$$
|
||||
### Returned value
|
||||
ASINH returns a real [number](/features/value-types#numbers) in the range (-∞, +∞) that is the hyperbolic arcsine of the specified value, expressed in radians.
|
||||
### Error conditions
|
||||
* In common with many other IronCalc functions, ASINH propagates errors that are found in its argument.
|
||||
* If no argument, or more than one argument, is supplied, then ASINH returns the [`#ERROR!`](/features/error-types.md#error) error.
|
||||
* If the value of the *number* argument is not (or cannot be converted to) a [number](/features/value-types#numbers), then ASINH returns the [`#VALUE!`](/features/error-types.md#value) error.
|
||||
<!--@include: ../markdown-snippets/error-type-details.txt-->
|
||||
## Details
|
||||
* The ASINH function utilizes the *asinh()* method provided by the [Rust Standard Library](https://doc.rust-lang.org/std/).
|
||||
* The figure below illustrates the output of the ASINH function.
|
||||
<center><img src="/functions/images/hyperbolicarcsine-curve.png" width="350" alt="Graph showing asinh(x)."></center>
|
||||
# ASINH
|
||||
|
||||
## Examples
|
||||
[See some examples in IronCalc](https://app.ironcalc.com/?example=asinh).
|
||||
|
||||
## Links
|
||||
* For more information about inverse hyperbolic functions, visit Wikipedia's [Inverse hyperbolic functions](https://en.wikipedia.org/wiki/Inverse_hyperbolic_functions) page.
|
||||
* See also IronCalc's [SINH](/functions/math_and_trigonometry/sinh), [ACOSH](/functions/math_and_trigonometry/acosh) and [ATANH](/functions/math_and_trigonometry/atanh) functions.
|
||||
* Visit Microsoft Excel's [ASINH function](https://support.microsoft.com/de-de/office/asinh-function-62b4f5b6-d9cc-4c17-9d04-aa5371806c74) page.
|
||||
* Both [Google Sheets](https://support.google.com/docs/answer/3093393) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/ASINH) provide versions of the ASINH function.
|
||||
::: warning
|
||||
🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
|
||||
:::
|
||||
@@ -4,34 +4,8 @@ outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# ATAN function
|
||||
## Overview
|
||||
ATAN is a function of the Math and Trigonometry category that calculates the inverse tangent (arctangent) of a number, returning an angle in the range [-$\pi$/2 to +$\pi$/2], expressed in radians.
|
||||
## Usage
|
||||
### Syntax
|
||||
**ATAN (<span title="Number" style="color:#1E88E5">number</span>) => <span title="Number" style="color:#1E88E5">atan</span>**
|
||||
### Argument descriptions
|
||||
* *number* ([number](/features/value-types#numbers), required). The number whose arctangent is to be calculated, in the range [-$\infty$, +$\infty$].
|
||||
### Additional guidance
|
||||
None.
|
||||
### Returned value
|
||||
ATAN returns a number in radians in the range [-$\pi$/2 to +$\pi$/2] that is the angle whose tangent is the specified number.
|
||||
### Error conditions
|
||||
* In common with many other IronCalc functions, ATAN propagates errors that are found in its argument.
|
||||
* If no argument, or more than one argument, is supplied, then ATAN returns the [`#ERROR!`](/features/error-types.md#error) error.
|
||||
* If the value of the *number* argument is not (or cannot be converted to) a [number](/features/value-types#numbers), then ATAN returns the [`#VALUE!`](/features/error-types.md#value) error.
|
||||
* For some argument values, ATAN may return a [`#DIV/0!`](/features/error-types.md#div-0) error.
|
||||
<!--@include: ../markdown-snippets/error-type-details.txt-->
|
||||
## Details
|
||||
* The ATAN function utilizes the *atan()* method provided by the [Rust Standard Library](https://doc.rust-lang.org/std/).
|
||||
* The figure below illustrates the output of the ATAN function for angles $x$ in the range [-$\infty$, +$\infty$].
|
||||
<center><img src="/functions/images/arctangent-curve.png" width="350" alt="Graph showing atan(x) for x between [-$\infty$, +$\infty$]."></center>
|
||||
# ATAN
|
||||
|
||||
## Examples
|
||||
[See some examples in IronCalc](https://app.ironcalc.com/?example=atan).
|
||||
|
||||
## Links
|
||||
* For more information about inverse trigonometric functions, visit Wikipedia's [Inverse trigonometric functions](https://en.wikipedia.org/wiki/Inverse_trigonometric_functions) page.
|
||||
* See also IronCalc's [SIN](/functions/math_and_trigonometry/sin), [COS](/functions/math_and_trigonometry/cos) and [TAN](/functions/math_and_trigonometry/tan) functions.
|
||||
* Visit Microsoft Excel's [ATAN function](https://support.microsoft.com/en-us/office/atan-function-50746fa8-630a-406b-81d0-4a2aed395543) page.
|
||||
* Both [Google Sheets](https://support.google.com/docs/answer/3093395) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/ATAN) provide versions of the ATAN function.
|
||||
::: warning
|
||||
🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
|
||||
:::
|
||||
@@ -4,34 +4,8 @@ outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# ATAN2 function
|
||||
## Overview
|
||||
ATAN2 is a function of the Math and Trigonometry category that calculates the inverse tangent (arctangent) for the specified *x* and *y* coordinates. The arctangent returns the angle defined by the x-axis and a line defined by the origin and a point with coordinates (x,y). The returned angle is expressed in radians, in the range (-$\pi$, +$\pi$].
|
||||
## Usage
|
||||
### Syntax
|
||||
**ATAN2(<span title="Number" style="color:#1E88E5">x,y</span>) => <span title="Number" style="color:#1E88E5">atan2</span>**
|
||||
### Argument descriptions
|
||||
* *x* ([number](/features/value-types#numbers), required). Value of the x coordinate.
|
||||
* *y* ([number](/features/value-types#numbers), required). Value of the y coordinate.
|
||||
### Additional guidance
|
||||
If the returned value is positive, it represents a counterclockwise angle from the x-axis, while a negative value represents a clockwise angle.
|
||||
ATAN2(x,y) is equivalent to ATAN(y/x), with the difference that the x argument in ATAN2 can be 0.
|
||||
### Returned value
|
||||
ATAN2 returns a number in radians in the range (-$\pi$, +$\pi$] that is the inverse tangent for the specified x and y coordinates.
|
||||
### Error conditions
|
||||
* In common with many other IronCalc functions, ATAN2 propagates errors that are found in its argument.
|
||||
* If no argument, or arguments other than 2, are supplied, then ATAN2 returns the [`#ERROR!`](/features/error-types.md#error) error.
|
||||
* If the value of either the *x* or *y* argument is not (or cannot be converted to) a [number](/features/value-types#numbers), then ATAN2 returns the [`#VALUE!`](/features/error-types.md#value) error.
|
||||
* If both *x* and *y* are equal to 0, ATAN2 returns a [`#DIV/0!`](/features/error-types.md#div-0) error.
|
||||
<!--@include: ../markdown-snippets/error-type-details.txt-->
|
||||
## Details
|
||||
* The ATAN2 function utilizes the *atan2()* method provided by the [Rust Standard Library](https://doc.rust-lang.org/std/).
|
||||
## Examples
|
||||
[See some examples in IronCalc](https://app.ironcalc.com/?example=atan2).
|
||||
|
||||
## Links
|
||||
* For more information about inverse trigonometric functions, visit Wikipedia's [Inverse trigonometric functions](https://en.wikipedia.org/wiki/Inverse_trigonometric_functions) page.
|
||||
* See also IronCalc's [ATAN](/functions/math_and_trigonometry/atan), [TAN](/functions/math_and_trigonometry/tan) and [ASIN](/functions/math_and_trigonometry/asin) functions.
|
||||
* Visit Microsoft Excel's [ATAN2 function](https://support.microsoft.com/en-us/office/atan2-function-51123ced-348c-416a-b2e2-833f7868569f) page.
|
||||
* Both [Google Sheets](https://support.google.com/docs/answer/3093468) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/ATAN2) provide versions of the ATAN2 function.
|
||||
# ATAN2
|
||||
|
||||
::: warning
|
||||
🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
|
||||
:::
|
||||
@@ -4,37 +4,8 @@ outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
|
||||
# ATANH function
|
||||
## Overview
|
||||
ATANH is a function of the Math and Trigonometry category that calculates the inverse hyperbolic tangent (hyperbolic arctangent) of a number in the range (-1, +1), returning the hyperbolic angle expressed in radians.
|
||||
## Usage
|
||||
### Syntax
|
||||
**ATANH(<span title="Number" style="color:#1E88E5">number</span>) => <span title="Number" style="color:#1E88E5">atanh</span>**
|
||||
### Argument descriptions
|
||||
* *number* ([number](/features/value-types#numbers), required). The value whose inverse hyperbolic tangent is to be calculated, in the range (-1,+1).
|
||||
### Additional guidance
|
||||
The hyperbolic arctangent function is defined as:
|
||||
$$
|
||||
\operatorname{atanh}(x) = \tfrac{1}{2}\,\ln\!\left(\dfrac{1+x}{1-x}\right),\quad |x| < 1
|
||||
$$
|
||||
### Returned value
|
||||
ATANH returns a real [number](/features/value-types#numbers) in the range (-∞, +∞) that is the hyperbolic arctangent of the specified value, expressed in radians.
|
||||
### Error conditions
|
||||
* In common with many other IronCalc functions, ATANH propagates errors that are found in its argument.
|
||||
* If no argument, or more than one argument, is supplied, then ATANH returns the [`#ERROR!`](/features/error-types.md#error) error.
|
||||
* If the value of the *number* argument is not (or cannot be converted to) a [number](/features/value-types#numbers), then ATANH returns the [`#VALUE!`](/features/error-types.md#value) error.
|
||||
* If the value of the *number* argument lies outside the domain (-1, +1), then ATANH returns the [`#NUM!`](/features/error-types.md#num) error.
|
||||
<!--@include: ../markdown-snippets/error-type-details.txt-->
|
||||
## Details
|
||||
* The ATANH function utilizes the *atanh()* method provided by the [Rust Standard Library](https://doc.rust-lang.org/std/).
|
||||
* The figure below illustrates the output of the ATANH function.
|
||||
<center><img src="/functions/images/hyperbolicarctangent-curve.png" width="350" alt="Graph showing atanh(x)."></center>
|
||||
# ATANH
|
||||
|
||||
## Examples
|
||||
[See some examples in IronCalc](https://app.ironcalc.com/?example=atanh).
|
||||
|
||||
## Links
|
||||
* For more information about inverse hyperbolic functions, visit Wikipedia's [Inverse hyperbolic functions](https://en.wikipedia.org/wiki/Inverse_hyperbolic_functions) page.
|
||||
* See also IronCalc's [ASINH](/functions/math_and_trigonometry/asinh), [ACOSH](/functions/math_and_trigonometry/acosh) and [TANH](/functions/math_and_trigonometry/tanh) functions.
|
||||
* Visit Microsoft Excel's [ATANH function](https://support.microsoft.com/de-de/office/atanh-function-453534d1-76a5-4f17-8c04-c3f2feee0dd5) page.
|
||||
* Both [Google Sheets](https://support.google.com/docs/answer/3093397) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/ATANH) provide versions of the ATANH function.
|
||||
::: warning
|
||||
🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
|
||||
:::
|
||||
@@ -3,37 +3,9 @@ layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
# COSH function
|
||||
## Overview
|
||||
COSH is a function of the Math and Trigonometry category that calculates the hyperbolic cosine of a number.
|
||||
## Usage
|
||||
### Syntax
|
||||
**COSH(<span title="Number" style="color:#1E88E5">number</span>) => <span title="Number" style="color:#1E88E5">cosh</span>**
|
||||
### Argument descriptions
|
||||
* *number* ([number](/features/value-types#numbers), required). The hyperbolic angle whose hyperbolic cosine is to be calculated, expressed in radians.
|
||||
### Additional guidance
|
||||
The formula for the hyperbolic cosine is:
|
||||
$$
|
||||
\text{cosh(x)} = \dfrac{e^x+e^{-x}}{2}
|
||||
$$
|
||||
### Returned value
|
||||
COSH returns a real [number](/features/value-types#numbers) that is the hyperbolic cosine of the specified hyperbolic angle.
|
||||
### Error conditions
|
||||
* In common with many other IronCalc functions, COSH propagates errors that are found in its argument.
|
||||
* If no argument, or more than one argument, is supplied, then COSH returns the [`#ERROR!`](/features/error-types.md#error) error.
|
||||
* If the value of the *number* argument is not (or cannot be converted to) a [number](/features/value-types#numbers), then COSH returns the [`#VALUE!`](/features/error-types.md#value) error.
|
||||
* For some argument values, COSH may return a [`#DIV/0!`](/features/error-types.md#div-0) error.
|
||||
<!--@include: ../markdown-snippets/error-type-details.txt-->
|
||||
## Details
|
||||
* The COSH function utilizes the *cosh()* method provided by the [Rust Standard Library](https://doc.rust-lang.org/std/).
|
||||
* The figure below illustrates the COSH function.
|
||||
<center><img src="/functions/images/hyperboliccosine-curve.png" width="350" alt="Graph showing cosh(x)."></center>
|
||||
|
||||
## Examples
|
||||
[See some examples in IronCalc](https://app.ironcalc.com/?example=cosh).
|
||||
# COSH
|
||||
|
||||
## Links
|
||||
* For more information about hyperbolic functions, visit Wikipedia's [Hyperbolic functions](https://en.wikipedia.org/wiki/Hyperbolic_functions) page.
|
||||
* See also IronCalc's [SINH](/functions/math_and_trigonometry/sinh), [COS](/functions/math_and_trigonometry/cos) and [TAN](/functions/math_and_trigonometry/tan) functions.
|
||||
* Visit Microsoft Excel's [COSH function](https://support.microsoft.com/en-us/office/cosh-function-e460d426-c471-43e8-9540-a57ff3b70555) page.
|
||||
* Both [Google Sheets](https://support.google.com/docs/answer/3093477) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/COSH) provide versions of the COSH function.
|
||||
::: warning
|
||||
🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
|
||||
:::
|
||||
@@ -7,5 +7,6 @@ lang: en-US
|
||||
# LN
|
||||
|
||||
::: warning
|
||||
🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
@@ -7,5 +7,6 @@ lang: en-US
|
||||
# LOG
|
||||
|
||||
::: warning
|
||||
🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
@@ -7,5 +7,6 @@ lang: en-US
|
||||
# LOG10
|
||||
|
||||
::: warning
|
||||
🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
|
||||
🚧 This function is not yet available in IronCalc.
|
||||
[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
|
||||
:::
|
||||
@@ -3,37 +3,9 @@ layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
# SINH function
|
||||
## Overview
|
||||
SINH is a function of the Math and Trigonometry category that calculates the hyperbolic sine of a number.
|
||||
## Usage
|
||||
### Syntax
|
||||
**SINH(<span title="Number" style="color:#1E88E5">number</span>) => <span title="Number" style="color:#1E88E5">sinh</span>**
|
||||
### Argument descriptions
|
||||
* *number* ([number](/features/value-types#numbers), required). The hyperbolic angle whose hyperbolic sine is to be calculated, expressed in radians.
|
||||
### Additional guidance
|
||||
The formula for the hyperbolic sine is:
|
||||
$$
|
||||
\text{sinh(x)} = \dfrac{e^x-e^{-x}}{2}
|
||||
$$
|
||||
### Returned value
|
||||
SINH returns a real [number](/features/value-types#numbers) that is the hyperbolic sine of the specified hyperbolic angle.
|
||||
### Error conditions
|
||||
* In common with many other IronCalc functions, SINH propagates errors that are found in its argument.
|
||||
* If no argument, or more than one argument, is supplied, then SINH returns the [`#ERROR!`](/features/error-types.md#error) error.
|
||||
* If the value of the *number* argument is not (or cannot be converted to) a [number](/features/value-types#numbers), then SINH returns the [`#VALUE!`](/features/error-types.md#value) error.
|
||||
* For some argument values, SINH may return a [`#DIV/0!`](/features/error-types.md#div-0) error.
|
||||
<!--@include: ../markdown-snippets/error-type-details.txt-->
|
||||
## Details
|
||||
* The SINH function utilizes the *sinh()* method provided by the [Rust Standard Library](https://doc.rust-lang.org/std/).
|
||||
* The figure below illustrates the SINH function.
|
||||
<center><img src="/functions/images/hyperbolicsine-curve.png" width="350" alt="Graph showing sinh(x)."></center>
|
||||
|
||||
## Examples
|
||||
[See some examples in IronCalc](https://app.ironcalc.com/?example=sinh).
|
||||
# SINH
|
||||
|
||||
## Links
|
||||
* For more information about hyperbolic functions, visit Wikipedia's [Hyperbolic functions](https://en.wikipedia.org/wiki/Hyperbolic_functions) page.
|
||||
* See also IronCalc's [SIN](/functions/math_and_trigonometry/sin), [COS](/functions/math_and_trigonometry/cos) and [TAN](/functions/math_and_trigonometry/tan) functions.
|
||||
* Visit Microsoft Excel's [SINH function](https://support.microsoft.com/en-us/office/sinh-function-4958f7e2-0d2b-4846-8ef5-8475f3aea5fb) page.
|
||||
* Both [Google Sheets](https://support.google.com/docs/answer/3093517) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/SINH) provide versions of the SINH function.
|
||||
::: warning
|
||||
🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
|
||||
:::
|
||||
@@ -33,7 +33,7 @@ TAN returns a unitless [number](/features/value-types#numbers) that is the trigo
|
||||
* The figure below illustrates the output of the TAN function for angles $x$ in the range -2$π$ to +2$π$.
|
||||
<center><img src="/functions/images/tangent-curve.png" width="350" alt="Graph showing tan(x) for x between -2π and +2π."></center>
|
||||
|
||||
* Theoretically, $\text{tan}(x)$ is undefined for any critical $x$ that satisfies $x = \frac{\pi}{2} + k\pi$ (where $k$ is any integer). However, an exact representation of the mathematical constant $\pi$ requires infinite precision, which cannot be achieved with the floating-point representation available. Hence, TAN will return very large or very small values close to critical $x$ values.
|
||||
* Theoretically, $\text{tan}(x)$ is undefined for any critical $x$ that satisfies $x = \frac{\pi}{2} + k\pi$ (where $k$ is any integer). However, an exact representation of the mathmatical constant $\pi$ requires infinite precision, which cannot be achieved with the floating-point representation available. Hence, TAN will return very large or very small values close to critical $x$ values.
|
||||
## Examples
|
||||
[See some examples in IronCalc](https://app.ironcalc.com/?example=tan).
|
||||
|
||||
|
||||
@@ -3,37 +3,9 @@ layout: doc
|
||||
outline: deep
|
||||
lang: en-US
|
||||
---
|
||||
# TANH function
|
||||
## Overview
|
||||
TANH is a function of the Math and Trigonometry category that calculates the hyperbolic tangent of a number.
|
||||
## Usage
|
||||
### Syntax
|
||||
**TANH(<span title="Number" style="color:#1E88E5">number</span>) => <span title="Number" style="color:#1E88E5">tanh</span>**
|
||||
### Argument descriptions
|
||||
* *number* ([number](/features/value-types#numbers), required). The hyperbolic angle whose hyperbolic tangent is to be calculated, expressed in radians.
|
||||
### Additional guidance
|
||||
The formula for the hyperbolic tangent is:
|
||||
$$
|
||||
\text{tanh(x)} = \dfrac{sinh(x)}{cosh(x)} = \dfrac{e^x-e^{-x}}{e^x+e^{-x}}
|
||||
$$
|
||||
### Returned value
|
||||
TANH returns a real [number](/features/value-types#numbers) in the range (-1,+1) that is the hyperbolic tangent of the specified hyperbolic angle.
|
||||
### Error conditions
|
||||
* In common with many other IronCalc functions, TANH propagates errors that are found in its argument.
|
||||
* If no argument, or more than one argument, is supplied, then TANH returns the [`#ERROR!`](/features/error-types.md#error) error.
|
||||
* If the value of the *number* argument is not (or cannot be converted to) a [number](/features/value-types#numbers), then TANH returns the [`#VALUE!`](/features/error-types.md#value) error.
|
||||
* For some argument values, TANH may return a [`#DIV/0!`](/features/error-types.md#div-0) error.
|
||||
<!--@include: ../markdown-snippets/error-type-details.txt-->
|
||||
## Details
|
||||
* The TANH function utilizes the *tanh()* method provided by the [Rust Standard Library](https://doc.rust-lang.org/std/).
|
||||
* The figure below illustrates the TANH function.
|
||||
<center><img src="/functions/images/hyperbolictangent-curve.png" width="350" alt="Graph showing tanh(x)."></center>
|
||||
|
||||
## Examples
|
||||
[See some examples in IronCalc](https://app.ironcalc.com/?example=tanh).
|
||||
# TANH
|
||||
|
||||
## Links
|
||||
* For more information about hyperbolic functions, visit Wikipedia's [Hyperbolic functions](https://en.wikipedia.org/wiki/Hyperbolic_functions) page.
|
||||
* See also IronCalc's [SINH](/functions/math_and_trigonometry/sinh), [COSH](/functions/math_and_trigonometry/cosh) and [TAN](/functions/math_and_trigonometry/tan) functions.
|
||||
* Visit Microsoft Excel's [TANH function](https://support.microsoft.com/en-us/office/tanh-function-017222f0-a0c3-4f69-9787-b3202295dc6c) page.
|
||||
* Both [Google Sheets](https://support.google.com/docs/answer/3093755) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/TANH) provide versions of the TANH function.
|
||||
::: warning
|
||||
🚧 This function is implemented but currently lacks detailed documentation. For guidance, you may refer to the equivalent functionality in [Microsoft Excel documentation](https://support.microsoft.com/en-us/office/excel-functions-by-category-5f91f4e9-7b42-46d2-9bd1-63f26a86c0eb).
|
||||
:::
|
||||
1164
webapp/IronCalc/package-lock.json
generated
1164
webapp/IronCalc/package-lock.json
generated
File diff suppressed because it is too large
Load Diff
@@ -249,9 +249,6 @@ const Editor = (options: EditorOptions) => {
|
||||
}
|
||||
}}
|
||||
onPaste={(event) => event.stopPropagation()}
|
||||
onCopy={(event) => event.stopPropagation()}
|
||||
onDoubleClick={(event) => event.stopPropagation()}
|
||||
onCut={(event) => event.stopPropagation()}
|
||||
/>
|
||||
</div>
|
||||
);
|
||||
|
||||
@@ -14,8 +14,6 @@ import {
|
||||
ArrowUpToLine,
|
||||
Bold,
|
||||
ChevronDown,
|
||||
DecimalsArrowLeft,
|
||||
DecimalsArrowRight,
|
||||
Euro,
|
||||
Grid2X2,
|
||||
Grid2x2Check,
|
||||
@@ -38,7 +36,11 @@ import {
|
||||
} from "lucide-react";
|
||||
import { useRef, useState } from "react";
|
||||
import { useTranslation } from "react-i18next";
|
||||
import { ArrowMiddleFromLine } from "../../icons";
|
||||
import {
|
||||
ArrowMiddleFromLine,
|
||||
DecimalPlacesDecreaseIcon,
|
||||
DecimalPlacesIncreaseIcon,
|
||||
} from "../../icons";
|
||||
import { theme } from "../../theme";
|
||||
import BorderPicker from "../BorderPicker/BorderPicker";
|
||||
import ColorPicker from "../ColorPicker/ColorPicker";
|
||||
@@ -166,7 +168,7 @@ function Toolbar(properties: ToolbarProperties) {
|
||||
disabled={!canEdit}
|
||||
title={t("toolbar.decimal_places_decrease")}
|
||||
>
|
||||
<DecimalsArrowLeft />
|
||||
<DecimalPlacesDecreaseIcon />
|
||||
</StyledButton>
|
||||
<StyledButton
|
||||
type="button"
|
||||
@@ -179,7 +181,7 @@ function Toolbar(properties: ToolbarProperties) {
|
||||
disabled={!canEdit}
|
||||
title={t("toolbar.decimal_places_increase")}
|
||||
>
|
||||
<DecimalsArrowRight />
|
||||
<DecimalPlacesIncreaseIcon />
|
||||
</StyledButton>
|
||||
<FormatMenu
|
||||
numFmt={properties.numFmt}
|
||||
@@ -274,10 +276,10 @@ function Toolbar(properties: ToolbarProperties) {
|
||||
disabled={!canEdit}
|
||||
title={t("toolbar.font_color")}
|
||||
ref={fontColorButton}
|
||||
$underlinedColor={properties.fontColor}
|
||||
onClick={() => setFontColorPickerOpen(true)}
|
||||
>
|
||||
<Type />
|
||||
<ColorLine color={properties.fontColor} />
|
||||
</StyledButton>
|
||||
<StyledButton
|
||||
type="button"
|
||||
@@ -285,10 +287,10 @@ function Toolbar(properties: ToolbarProperties) {
|
||||
disabled={!canEdit}
|
||||
title={t("toolbar.fill_color")}
|
||||
ref={fillColorButton}
|
||||
$underlinedColor={properties.fillColor}
|
||||
onClick={() => setFillColorPickerOpen(true)}
|
||||
>
|
||||
<PaintBucket />
|
||||
<ColorLine color={properties.fillColor} />
|
||||
</StyledButton>
|
||||
<StyledButton
|
||||
type="button"
|
||||
@@ -446,7 +448,7 @@ function Toolbar(properties: ToolbarProperties) {
|
||||
/>
|
||||
<ColorPicker
|
||||
color={properties.fillColor}
|
||||
defaultColor=""
|
||||
defaultColor="#FFFFFF"
|
||||
title={t("color_picker.default")}
|
||||
onChange={(color): void => {
|
||||
if (color !== null) {
|
||||
@@ -499,64 +501,58 @@ const ToolbarContainer = styled("div")`
|
||||
scrollbar-width: none;
|
||||
`;
|
||||
|
||||
type TypeButtonProperties = { $pressed: boolean };
|
||||
export const StyledButton = styled("button", {
|
||||
shouldForwardProp: (prop) => prop !== "$pressed",
|
||||
})<TypeButtonProperties>(({ disabled, $pressed }) => {
|
||||
const result = {
|
||||
width: "24px",
|
||||
minWidth: "24px",
|
||||
height: "24px",
|
||||
display: "inline-flex",
|
||||
alignItems: "center",
|
||||
justifyContent: "center",
|
||||
fontSize: "12px",
|
||||
border: `0px solid ${theme.palette.common.white}`,
|
||||
borderRadius: "4px",
|
||||
transition: "all 0.2s",
|
||||
outline: `1px solid ${theme.palette.common.white}`,
|
||||
cursor: "pointer",
|
||||
backgroundColor: "white",
|
||||
padding: "0px",
|
||||
position: "relative" as const,
|
||||
svg: {
|
||||
width: "16px",
|
||||
height: "16px",
|
||||
},
|
||||
};
|
||||
if (disabled) {
|
||||
type TypeButtonProperties = { $pressed: boolean; $underlinedColor?: string };
|
||||
export const StyledButton = styled("button")<TypeButtonProperties>(
|
||||
({ disabled, $pressed, $underlinedColor }) => {
|
||||
const result = {
|
||||
width: "24px",
|
||||
minWidth: "24px",
|
||||
height: "24px",
|
||||
display: "inline-flex",
|
||||
alignItems: "center",
|
||||
justifyContent: "center",
|
||||
fontSize: "12px",
|
||||
border: `0px solid ${theme.palette.common.white}`,
|
||||
borderRadius: "4px",
|
||||
transition: "all 0.2s",
|
||||
outline: `1px solid ${theme.palette.common.white}`,
|
||||
cursor: "pointer",
|
||||
backgroundColor: "white",
|
||||
padding: "0px",
|
||||
svg: {
|
||||
width: "16px",
|
||||
height: "16px",
|
||||
},
|
||||
};
|
||||
if (disabled) {
|
||||
return {
|
||||
...result,
|
||||
color: theme.palette.grey["400"],
|
||||
cursor: "default",
|
||||
};
|
||||
}
|
||||
return {
|
||||
...result,
|
||||
color: theme.palette.grey["400"],
|
||||
cursor: "default",
|
||||
borderTop: $underlinedColor
|
||||
? `3px solid ${theme.palette.common.white}`
|
||||
: "none",
|
||||
borderBottom: $underlinedColor ? `3px solid ${$underlinedColor}` : "none",
|
||||
color: theme.palette.grey["900"],
|
||||
backgroundColor: $pressed
|
||||
? theme.palette.grey["300"]
|
||||
: theme.palette.common.white,
|
||||
"&:hover": {
|
||||
transition: "all 0.2s",
|
||||
outline: `1px solid ${theme.palette.grey["200"]}`,
|
||||
borderTopColor: theme.palette.common.white,
|
||||
},
|
||||
"&:active": {
|
||||
backgroundColor: theme.palette.grey["300"],
|
||||
outline: `1px solid ${theme.palette.grey["300"]}`,
|
||||
},
|
||||
};
|
||||
}
|
||||
return {
|
||||
...result,
|
||||
color: theme.palette.grey["900"],
|
||||
backgroundColor: $pressed
|
||||
? theme.palette.grey["300"]
|
||||
: theme.palette.common.white,
|
||||
"&:hover": {
|
||||
transition: "all 0.2s",
|
||||
outline: `1px solid ${theme.palette.grey["200"]}`,
|
||||
},
|
||||
"&:active": {
|
||||
backgroundColor: theme.palette.grey["300"],
|
||||
outline: `1px solid ${theme.palette.grey["300"]}`,
|
||||
},
|
||||
};
|
||||
});
|
||||
|
||||
const ColorLine = styled("div")<{ color: string }>(({ color }) => ({
|
||||
height: "3px",
|
||||
width: "16px",
|
||||
position: "absolute",
|
||||
bottom: "0px",
|
||||
left: "50%",
|
||||
transform: "translateX(-50%)",
|
||||
backgroundColor: color,
|
||||
}));
|
||||
},
|
||||
);
|
||||
|
||||
const Divider = styled("div")({
|
||||
width: "0px",
|
||||
|
||||
@@ -13,7 +13,6 @@ import Worksheet from "../Worksheet/Worksheet";
|
||||
import {
|
||||
COLUMN_WIDTH_SCALE,
|
||||
LAST_COLUMN,
|
||||
LAST_ROW,
|
||||
ROW_HEIGH_SCALE,
|
||||
} from "../WorksheetCanvas/constants";
|
||||
import type WorksheetCanvas from "../WorksheetCanvas/worksheetCanvas";
|
||||
@@ -250,8 +249,8 @@ const Workbook = (props: { model: Model; workbookState: WorkbookState }) => {
|
||||
onToggleUnderline(!value);
|
||||
},
|
||||
onNavigationToEdge: (direction: NavigationKey): void => {
|
||||
model.onNavigateToEdgeInDirection(direction);
|
||||
setRedrawId((id) => id + 1);
|
||||
console.log(direction);
|
||||
throw new Error("Function not implemented.");
|
||||
},
|
||||
onPageDown: (): void => {
|
||||
model.onPageDown();
|
||||
@@ -319,16 +318,6 @@ const Workbook = (props: { model: Model; workbookState: WorkbookState }) => {
|
||||
workbookState.clearCutRange();
|
||||
setRedrawId((id) => id + 1);
|
||||
},
|
||||
onSelectColumn: (): void => {
|
||||
const { column } = model.getSelectedView();
|
||||
model.setSelectedRange(1, column, LAST_ROW, column);
|
||||
setRedrawId((id) => id + 1);
|
||||
},
|
||||
onSelectRow: (): void => {
|
||||
const { row } = model.getSelectedView();
|
||||
model.setSelectedRange(row, 1, row, LAST_COLUMN);
|
||||
setRedrawId((id) => id + 1);
|
||||
},
|
||||
root: rootRef,
|
||||
});
|
||||
|
||||
@@ -484,7 +473,7 @@ const Workbook = (props: { model: Model; workbookState: WorkbookState }) => {
|
||||
sheet,
|
||||
clipboardId,
|
||||
});
|
||||
event.clipboardData.setData("text/plain", data.csv.trim());
|
||||
event.clipboardData.setData("text/plain", data.csv);
|
||||
event.clipboardData.setData("application/json", clipboardJsonStr);
|
||||
event.preventDefault();
|
||||
event.stopPropagation();
|
||||
|
||||
@@ -32,8 +32,6 @@ interface Options {
|
||||
onNextSheet: () => void;
|
||||
onPreviousSheet: () => void;
|
||||
onEscape: () => void;
|
||||
onSelectColumn: () => void;
|
||||
onSelectRow: () => void;
|
||||
root: RefObject<HTMLDivElement | null>;
|
||||
}
|
||||
|
||||
@@ -53,16 +51,6 @@ interface Options {
|
||||
// * Ctrl+u/i/b: style
|
||||
// * Ctrl+z/y: undo/redo
|
||||
// * F2: start editing
|
||||
// * Ctrl+Space: select column
|
||||
// * Shift+Space: select row
|
||||
//
|
||||
// # Not implemented yet:
|
||||
// * Ctrl+a: select all (continuous area around the selection, if it exists,
|
||||
// otherwise select whole sheet)
|
||||
// * Ctrl+Shift+Arrows: select to edge
|
||||
// * Ctrl+Shift+Home/End: select to end
|
||||
// * Ctrl+Shift++: (after selecting) insert row/column (also Alt+I, R or C)
|
||||
// * Ctrl+-: (after selecting) delete row/column
|
||||
|
||||
// References:
|
||||
// In Google Sheets: Ctrl+/ shows the list of keyboard shortcuts
|
||||
@@ -75,7 +63,6 @@ const useKeyboardNavigation = (
|
||||
const onKeyDown = useCallback(
|
||||
(event: KeyboardEvent) => {
|
||||
const { key } = event;
|
||||
const lowerKey = key.toLowerCase();
|
||||
const { root } = options;
|
||||
// Silence the linter
|
||||
if (!root.current) {
|
||||
@@ -84,40 +71,41 @@ const useKeyboardNavigation = (
|
||||
if (event.target !== root.current) {
|
||||
return;
|
||||
}
|
||||
const isCtrl = event.metaKey || event.ctrlKey;
|
||||
const isShift = event.shiftKey;
|
||||
const isAlt = event.altKey;
|
||||
if (isCtrl && !isShift && !isAlt) {
|
||||
// Ctrl+...
|
||||
switch (lowerKey) {
|
||||
if (event.metaKey || event.ctrlKey) {
|
||||
switch (key) {
|
||||
case "z": {
|
||||
options.onUndo();
|
||||
event.stopPropagation();
|
||||
event.preventDefault();
|
||||
|
||||
break;
|
||||
}
|
||||
case "y": {
|
||||
options.onRedo();
|
||||
event.stopPropagation();
|
||||
event.preventDefault();
|
||||
|
||||
break;
|
||||
}
|
||||
case "b": {
|
||||
options.onBold();
|
||||
event.stopPropagation();
|
||||
event.preventDefault();
|
||||
|
||||
break;
|
||||
}
|
||||
case "i": {
|
||||
options.onItalic();
|
||||
event.stopPropagation();
|
||||
event.preventDefault();
|
||||
|
||||
break;
|
||||
}
|
||||
case "u": {
|
||||
options.onUnderline();
|
||||
event.stopPropagation();
|
||||
event.preventDefault();
|
||||
|
||||
break;
|
||||
}
|
||||
case "a": {
|
||||
@@ -127,60 +115,18 @@ const useKeyboardNavigation = (
|
||||
event.preventDefault();
|
||||
break;
|
||||
}
|
||||
case " ": {
|
||||
options.onSelectColumn();
|
||||
event.stopPropagation();
|
||||
event.preventDefault();
|
||||
break;
|
||||
}
|
||||
// No default
|
||||
}
|
||||
if (isNavigationKey(key)) {
|
||||
// Ctrl+Arrows, Ctrl+Home/End
|
||||
options.onNavigationToEdge(key);
|
||||
// navigate_to_edge_in_direction
|
||||
event.stopPropagation();
|
||||
event.preventDefault();
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (isCtrl && isShift && !isAlt) {
|
||||
// Ctrl+Shift+...
|
||||
switch (lowerKey) {
|
||||
case "z": {
|
||||
options.onRedo();
|
||||
event.stopPropagation();
|
||||
event.preventDefault();
|
||||
break;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (isShift && !isAlt && !isCtrl) {
|
||||
// Shift+...
|
||||
switch (key) {
|
||||
case " ": {
|
||||
options.onSelectRow();
|
||||
event.stopPropagation();
|
||||
event.preventDefault();
|
||||
break;
|
||||
}
|
||||
case "ArrowRight":
|
||||
case "ArrowLeft":
|
||||
case "ArrowUp":
|
||||
case "ArrowDown": {
|
||||
options.onExpandAreaSelectedKeyboard(key);
|
||||
break;
|
||||
}
|
||||
case "Tab": {
|
||||
options.onArrowLeft();
|
||||
event.stopPropagation();
|
||||
event.preventDefault();
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (isAlt && !isCtrl && !isShift) {
|
||||
// Alt+...
|
||||
if (event.altKey) {
|
||||
switch (key) {
|
||||
case "ArrowDown": {
|
||||
// select next sheet
|
||||
@@ -197,23 +143,6 @@ const useKeyboardNavigation = (
|
||||
break;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (isCtrl || isAlt) {
|
||||
// Other combinations with Ctrl or Alt are not handled
|
||||
return;
|
||||
}
|
||||
|
||||
if (isEditingKey(key) || key === "Backspace") {
|
||||
const initText = key === "Backspace" ? "" : key;
|
||||
options.onEditKeyPressStart(initText);
|
||||
event.stopPropagation();
|
||||
event.preventDefault();
|
||||
return;
|
||||
}
|
||||
if (isShift) {
|
||||
// Other combinations with Shift are not handled
|
||||
return;
|
||||
}
|
||||
if (key === "F2") {
|
||||
options.onCellEditStart();
|
||||
@@ -221,44 +150,75 @@ const useKeyboardNavigation = (
|
||||
event.preventDefault();
|
||||
return;
|
||||
}
|
||||
if (isEditingKey(key) || key === "Backspace") {
|
||||
const initText = key === "Backspace" ? "" : key;
|
||||
options.onEditKeyPressStart(initText);
|
||||
event.stopPropagation();
|
||||
event.preventDefault();
|
||||
return;
|
||||
}
|
||||
// Worksheet Navigation
|
||||
if (event.shiftKey) {
|
||||
if (
|
||||
key === "ArrowRight" ||
|
||||
key === "ArrowLeft" ||
|
||||
key === "ArrowUp" ||
|
||||
key === "ArrowDown"
|
||||
) {
|
||||
options.onExpandAreaSelectedKeyboard(key);
|
||||
} else if (key === "Tab") {
|
||||
options.onArrowLeft();
|
||||
event.stopPropagation();
|
||||
event.preventDefault();
|
||||
}
|
||||
return;
|
||||
}
|
||||
switch (key) {
|
||||
case "ArrowRight":
|
||||
case "Tab": {
|
||||
options.onArrowRight();
|
||||
|
||||
break;
|
||||
}
|
||||
case "ArrowLeft": {
|
||||
options.onArrowLeft();
|
||||
|
||||
break;
|
||||
}
|
||||
case "ArrowDown":
|
||||
case "Enter": {
|
||||
options.onArrowDown();
|
||||
|
||||
break;
|
||||
}
|
||||
case "ArrowUp": {
|
||||
options.onArrowUp();
|
||||
|
||||
break;
|
||||
}
|
||||
case "End": {
|
||||
options.onKeyEnd();
|
||||
|
||||
break;
|
||||
}
|
||||
case "Home": {
|
||||
options.onKeyHome();
|
||||
|
||||
break;
|
||||
}
|
||||
case "Delete": {
|
||||
options.onCellsDeleted();
|
||||
|
||||
break;
|
||||
}
|
||||
case "PageDown": {
|
||||
options.onPageDown();
|
||||
|
||||
break;
|
||||
}
|
||||
case "PageUp": {
|
||||
options.onPageUp();
|
||||
|
||||
break;
|
||||
}
|
||||
case "Escape": {
|
||||
|
||||
@@ -1,7 +1,5 @@
|
||||
import { Menu, MenuItem, styled } from "@mui/material";
|
||||
import {
|
||||
ArrowLeftRight,
|
||||
ArrowUpDown,
|
||||
BetweenHorizontalStart,
|
||||
BetweenVerticalStart,
|
||||
ChevronRight,
|
||||
@@ -28,10 +26,6 @@ interface CellContextMenuProps {
|
||||
onUnfreezeRows: () => void;
|
||||
onDeleteRow: () => void;
|
||||
onDeleteColumn: () => void;
|
||||
onMoveColumnLeft: () => void;
|
||||
onMoveColumnRight: () => void;
|
||||
onMoveRowUp: () => void;
|
||||
onMoveRowDown: () => void;
|
||||
row: number;
|
||||
column: string;
|
||||
}
|
||||
@@ -52,10 +46,6 @@ const CellContextMenu = (properties: CellContextMenuProps) => {
|
||||
onUnfreezeRows,
|
||||
onDeleteRow,
|
||||
onDeleteColumn,
|
||||
onMoveColumnLeft,
|
||||
onMoveColumnRight,
|
||||
onMoveRowUp,
|
||||
onMoveRowDown,
|
||||
row,
|
||||
column,
|
||||
} = properties;
|
||||
@@ -68,12 +58,6 @@ const CellContextMenu = (properties: CellContextMenuProps) => {
|
||||
const [insertColumnMenuOpen, setInsertColumnMenuOpen] = useState(false);
|
||||
const insertColumnRef = useRef(null);
|
||||
|
||||
const [moveRowMenuOpen, setMoveRowMenuOpen] = useState(false);
|
||||
const moveRowRef = useRef(null);
|
||||
|
||||
const [moveColumnMenuOpen, setMoveColumnMenuOpen] = useState(false);
|
||||
const moveColumnRef = useRef(null);
|
||||
|
||||
return (
|
||||
<>
|
||||
<StyledMenu
|
||||
@@ -106,23 +90,6 @@ const CellContextMenu = (properties: CellContextMenuProps) => {
|
||||
<ChevronRightStyled />
|
||||
</StyledMenuItem>
|
||||
<MenuDivider />
|
||||
<StyledMenuItem
|
||||
ref={moveRowRef}
|
||||
onClick={() => setMoveRowMenuOpen(true)}
|
||||
>
|
||||
<ArrowUpDownStyled />
|
||||
<ItemNameStyled>{t("cell_context.move_row")}</ItemNameStyled>
|
||||
<ChevronRightStyled />
|
||||
</StyledMenuItem>
|
||||
<StyledMenuItem
|
||||
ref={moveColumnRef}
|
||||
onClick={() => setMoveColumnMenuOpen(true)}
|
||||
>
|
||||
<ArrowLeftRightStyled />
|
||||
<ItemNameStyled>{t("cell_context.move_column")}</ItemNameStyled>
|
||||
<ChevronRightStyled />
|
||||
</StyledMenuItem>
|
||||
<MenuDivider />
|
||||
<StyledMenuItem ref={freezeRef} onClick={() => setFreezeMenuOpen(true)}>
|
||||
<StyledSnowflake />
|
||||
<ItemNameStyled>{t("cell_context.freeze")}</ItemNameStyled>
|
||||
@@ -198,58 +165,6 @@ const CellContextMenu = (properties: CellContextMenuProps) => {
|
||||
</ItemNameStyled>
|
||||
</StyledMenuItem>
|
||||
</StyledMenu>
|
||||
<StyledMenu
|
||||
open={moveRowMenuOpen}
|
||||
onClose={() => setMoveRowMenuOpen(false)}
|
||||
anchorEl={moveRowRef.current}
|
||||
anchorOrigin={{
|
||||
vertical: "top",
|
||||
horizontal: "right",
|
||||
}}
|
||||
>
|
||||
<StyledMenuItem
|
||||
onClick={() => {
|
||||
onMoveRowUp();
|
||||
setMoveRowMenuOpen(false);
|
||||
}}
|
||||
>
|
||||
<ItemNameStyled>{t("cell_context.move_row_up")}</ItemNameStyled>
|
||||
</StyledMenuItem>
|
||||
<StyledMenuItem
|
||||
onClick={() => {
|
||||
onMoveRowDown();
|
||||
setMoveRowMenuOpen(false);
|
||||
}}
|
||||
>
|
||||
<ItemNameStyled>{t("cell_context.move_row_down")}</ItemNameStyled>
|
||||
</StyledMenuItem>
|
||||
</StyledMenu>
|
||||
<StyledMenu
|
||||
open={moveColumnMenuOpen}
|
||||
onClose={() => setMoveColumnMenuOpen(false)}
|
||||
anchorEl={moveColumnRef.current}
|
||||
anchorOrigin={{
|
||||
vertical: "top",
|
||||
horizontal: "right",
|
||||
}}
|
||||
>
|
||||
<StyledMenuItem
|
||||
onClick={() => {
|
||||
onMoveColumnLeft();
|
||||
setMoveColumnMenuOpen(false);
|
||||
}}
|
||||
>
|
||||
<ItemNameStyled>{t("cell_context.move_column_left")}</ItemNameStyled>
|
||||
</StyledMenuItem>
|
||||
<StyledMenuItem
|
||||
onClick={() => {
|
||||
onMoveColumnRight();
|
||||
setMoveColumnMenuOpen(false);
|
||||
}}
|
||||
>
|
||||
<ItemNameStyled>{t("cell_context.move_column_right")}</ItemNameStyled>
|
||||
</StyledMenuItem>
|
||||
</StyledMenu>
|
||||
<StyledMenu
|
||||
open={freezeMenuOpen}
|
||||
onClose={() => setFreezeMenuOpen(false)}
|
||||
@@ -315,20 +230,6 @@ const BetweenHorizontalStartStyled = styled(BetweenHorizontalStart)`
|
||||
padding-right: 10px;
|
||||
`;
|
||||
|
||||
const ArrowLeftRightStyled = styled(ArrowLeftRight)`
|
||||
width: 16px;
|
||||
height: 16px;
|
||||
color: ${theme.palette.grey[900]};
|
||||
padding-right: 10px;
|
||||
`;
|
||||
|
||||
const ArrowUpDownStyled = styled(ArrowUpDown)`
|
||||
width: 16px;
|
||||
height: 16px;
|
||||
color: ${theme.palette.grey[900]};
|
||||
padding-right: 10px;
|
||||
`;
|
||||
|
||||
const StyledSnowflake = styled(Snowflake)`
|
||||
width: 16px;
|
||||
height: 16px;
|
||||
|
||||
@@ -340,42 +340,22 @@ const Worksheet = forwardRef(
|
||||
anchorEl={cellOutline.current}
|
||||
onInsertRowAbove={(): void => {
|
||||
const view = model.getSelectedView();
|
||||
model.insertRows(view.sheet, view.row, 1);
|
||||
model.insertRow(view.sheet, view.row);
|
||||
setContextMenuOpen(false);
|
||||
}}
|
||||
onInsertRowBelow={(): void => {
|
||||
const view = model.getSelectedView();
|
||||
model.insertRows(view.sheet, view.row + 1, 1);
|
||||
model.insertRow(view.sheet, view.row + 1);
|
||||
setContextMenuOpen(false);
|
||||
}}
|
||||
onInsertColumnLeft={(): void => {
|
||||
const view = model.getSelectedView();
|
||||
model.insertColumns(view.sheet, view.column, 1);
|
||||
model.insertColumn(view.sheet, view.column);
|
||||
setContextMenuOpen(false);
|
||||
}}
|
||||
onInsertColumnRight={(): void => {
|
||||
const view = model.getSelectedView();
|
||||
model.insertColumns(view.sheet, view.column + 1, 1);
|
||||
setContextMenuOpen(false);
|
||||
}}
|
||||
onMoveColumnLeft={(): void => {
|
||||
const view = model.getSelectedView();
|
||||
model.moveColumn(view.sheet, view.column, -1);
|
||||
setContextMenuOpen(false);
|
||||
}}
|
||||
onMoveColumnRight={(): void => {
|
||||
const view = model.getSelectedView();
|
||||
model.moveColumn(view.sheet, view.column, 1);
|
||||
setContextMenuOpen(false);
|
||||
}}
|
||||
onMoveRowUp={(): void => {
|
||||
const view = model.getSelectedView();
|
||||
model.moveRow(view.sheet, view.row, -1);
|
||||
setContextMenuOpen(false);
|
||||
}}
|
||||
onMoveRowDown={(): void => {
|
||||
const view = model.getSelectedView();
|
||||
model.moveRow(view.sheet, view.row, 1);
|
||||
model.insertColumn(view.sheet, view.column + 1);
|
||||
setContextMenuOpen(false);
|
||||
}}
|
||||
onFreezeColumns={(): void => {
|
||||
@@ -400,12 +380,12 @@ const Worksheet = forwardRef(
|
||||
}}
|
||||
onDeleteRow={(): void => {
|
||||
const view = model.getSelectedView();
|
||||
model.deleteRows(view.sheet, view.row, 1);
|
||||
model.deleteRow(view.sheet, view.row);
|
||||
setContextMenuOpen(false);
|
||||
}}
|
||||
onDeleteColumn={(): void => {
|
||||
const view = model.getSelectedView();
|
||||
model.deleteColumns(view.sheet, view.column, 1);
|
||||
model.deleteColumn(view.sheet, view.column);
|
||||
setContextMenuOpen(false);
|
||||
}}
|
||||
row={model.getSelectedView().row}
|
||||
|
||||
@@ -179,7 +179,6 @@ const usePointer = (options: PointerSettings): PointerEvents => {
|
||||
if (cell) {
|
||||
if (editingCell) {
|
||||
if (
|
||||
model.getSelectedSheet() === editingCell.sheet &&
|
||||
cell.row === editingCell.row &&
|
||||
cell.column === editingCell.column
|
||||
) {
|
||||
|
||||
@@ -19,5 +19,3 @@ export const LAST_ROW = 1_048_576;
|
||||
|
||||
export const ROW_HEIGH_SCALE = 1;
|
||||
export const COLUMN_WIDTH_SCALE = 1;
|
||||
|
||||
export const cellPadding = 4;
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
import type { CellStyle, Model } from "@ironcalc/wasm";
|
||||
import type { Model } from "@ironcalc/wasm";
|
||||
import { columnNameFromNumber } from "@ironcalc/wasm";
|
||||
import { getColor } from "../Editor/util";
|
||||
import type { Cell } from "../types";
|
||||
@@ -8,7 +8,6 @@ import {
|
||||
LAST_COLUMN,
|
||||
LAST_ROW,
|
||||
ROW_HEIGH_SCALE,
|
||||
cellPadding,
|
||||
defaultTextColor,
|
||||
gridColor,
|
||||
gridSeparatorColor,
|
||||
@@ -55,20 +54,6 @@ export const defaultCellFontFamily = fonts.regular;
|
||||
export const headerFontFamily = fonts.regular;
|
||||
export const frozenSeparatorWidth = 3;
|
||||
|
||||
interface TextProperties {
|
||||
row: number;
|
||||
column: number;
|
||||
x: number;
|
||||
y: number;
|
||||
width: number;
|
||||
height: number;
|
||||
fontSize: number;
|
||||
textColor: string;
|
||||
font: string;
|
||||
underlined: boolean;
|
||||
strike: boolean;
|
||||
lines: [string, number, number, number][];
|
||||
}
|
||||
export default class WorksheetCanvas {
|
||||
sheetWidth: number;
|
||||
|
||||
@@ -108,9 +93,6 @@ export default class WorksheetCanvas {
|
||||
|
||||
refresh: () => void;
|
||||
|
||||
cells: TextProperties[];
|
||||
spills: Map<string, number>;
|
||||
|
||||
constructor(options: CanvasSettings) {
|
||||
this.model = options.model;
|
||||
this.sheetWidth = 0;
|
||||
@@ -134,10 +116,6 @@ export default class WorksheetCanvas {
|
||||
this.onRowHeightChanges = options.onRowHeightChanges;
|
||||
this.resetHeaders();
|
||||
this.cellOutlineHandle = attachOutlineHandle(this);
|
||||
|
||||
// a cell marked as "spill" means its left border should be skipped
|
||||
this.spills = new Map<string, number>();
|
||||
this.cells = [];
|
||||
}
|
||||
|
||||
setScrollPosition(scrollPosition: { left: number; top: number }): void {
|
||||
@@ -340,376 +318,7 @@ export default class WorksheetCanvas {
|
||||
return left;
|
||||
}
|
||||
|
||||
private getFontStyle(style: CellStyle): {
|
||||
font: string;
|
||||
color: string;
|
||||
fontSize: number;
|
||||
} {
|
||||
const fontSize = style.font?.sz || 13;
|
||||
let font = `${fontSize}px ${defaultCellFontFamily}`;
|
||||
let color = defaultTextColor;
|
||||
|
||||
if (style.font) {
|
||||
color = style.font.color;
|
||||
font = style.font.b ? `bold ${font}` : `400 ${font}`;
|
||||
if (style.font.i) {
|
||||
font = `italic ${font}`;
|
||||
}
|
||||
}
|
||||
|
||||
return { font, color, fontSize };
|
||||
}
|
||||
|
||||
private getAlignment(
|
||||
style: CellStyle,
|
||||
cellType: number,
|
||||
): { horizontal: string; vertical: string } {
|
||||
let horizontal = style.alignment?.horizontal || "general";
|
||||
const vertical = style.alignment?.vertical || "bottom";
|
||||
|
||||
if (horizontal === "general") {
|
||||
if (cellType === 1) {
|
||||
horizontal = "right";
|
||||
} else if (cellType === 4) {
|
||||
horizontal = "center";
|
||||
} else {
|
||||
horizontal = "left";
|
||||
}
|
||||
}
|
||||
|
||||
return { horizontal, vertical };
|
||||
}
|
||||
|
||||
// Computes the text of cells that are off the screen. They are important because their text may spill into the viewport.
|
||||
private computeCellTextLeftRight(
|
||||
selectedSheet: number,
|
||||
row: number,
|
||||
rowHeight: number,
|
||||
topLeftCell: Cell,
|
||||
bottomRightCell: Cell,
|
||||
): void {
|
||||
const frozenColumnsCount = this.model.getFrozenColumnsCount(selectedSheet);
|
||||
// First compute the text to the left of the viewport
|
||||
const columnToTheLeft = this.model.getLastNonEmptyInRowBeforeColumn(
|
||||
selectedSheet,
|
||||
row,
|
||||
topLeftCell.column,
|
||||
);
|
||||
// If it is one of the frozen columns it is already computed
|
||||
if (columnToTheLeft && columnToTheLeft > frozenColumnsCount) {
|
||||
const columnWidth = this.getColumnWidth(selectedSheet, columnToTheLeft);
|
||||
const [textX, textY] = this.getCoordinatesByCell(row, columnToTheLeft);
|
||||
this.computeCellText(
|
||||
row,
|
||||
columnToTheLeft,
|
||||
textX,
|
||||
textY,
|
||||
columnWidth,
|
||||
rowHeight,
|
||||
);
|
||||
}
|
||||
// Compute the text to the right of the viewport
|
||||
const columnToTheRight = this.model.getFirstNonEmptyInRowAfterColumn(
|
||||
selectedSheet,
|
||||
row,
|
||||
bottomRightCell.column,
|
||||
);
|
||||
|
||||
if (columnToTheRight) {
|
||||
const columnWidth = this.getColumnWidth(selectedSheet, columnToTheRight);
|
||||
const [textX, textY] = this.getCoordinatesByCell(row, columnToTheRight);
|
||||
this.computeCellText(
|
||||
row,
|
||||
columnToTheRight,
|
||||
textX,
|
||||
textY,
|
||||
columnWidth,
|
||||
rowHeight,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// Goes through all the visible cells and computes their text properties
|
||||
private computeCellsText(): void {
|
||||
const { topLeftCell, bottomRightCell } = this.getVisibleCells();
|
||||
const selectedSheet = this.model.getSelectedSheet();
|
||||
|
||||
this.cells = [];
|
||||
|
||||
const frozenColumns = this.model.getFrozenColumnsCount(selectedSheet);
|
||||
const frozenRows = this.model.getFrozenRowsCount(selectedSheet);
|
||||
|
||||
// Top-left-pane
|
||||
let x = headerColumnWidth + 0.5;
|
||||
let y = headerRowHeight + 0.5;
|
||||
for (let row = 1; row <= frozenRows; row += 1) {
|
||||
const rowHeight = this.getRowHeight(selectedSheet, row);
|
||||
this.computeCellTextLeftRight(
|
||||
selectedSheet,
|
||||
row,
|
||||
rowHeight,
|
||||
topLeftCell,
|
||||
bottomRightCell,
|
||||
);
|
||||
|
||||
x = headerColumnWidth + 0.5;
|
||||
for (let column = 1; column <= frozenColumns; column += 1) {
|
||||
const columnWidth = this.getColumnWidth(selectedSheet, column);
|
||||
this.computeCellText(row, column, x, y, columnWidth, rowHeight);
|
||||
|
||||
x += columnWidth;
|
||||
}
|
||||
y += rowHeight;
|
||||
}
|
||||
if (frozenRows === 0 && frozenColumns !== 0) {
|
||||
x = headerColumnWidth + 0.5;
|
||||
for (let column = 1; column <= frozenColumns; column += 1) {
|
||||
x += this.getColumnWidth(selectedSheet, column);
|
||||
}
|
||||
}
|
||||
|
||||
// If there are frozen rows draw a separator
|
||||
if (frozenRows) {
|
||||
y += frozenSeparatorWidth;
|
||||
}
|
||||
|
||||
// If there are frozen columns draw a separator
|
||||
if (frozenColumns) {
|
||||
x += frozenSeparatorWidth;
|
||||
}
|
||||
|
||||
const frozenX = x;
|
||||
const frozenY = y;
|
||||
// Top-right pane
|
||||
y = headerRowHeight + 0.5;
|
||||
for (let row = 1; row <= frozenRows; row += 1) {
|
||||
x = frozenX;
|
||||
const rowHeight = this.getRowHeight(selectedSheet, row);
|
||||
for (
|
||||
let { column } = topLeftCell;
|
||||
column <= bottomRightCell.column;
|
||||
column += 1
|
||||
) {
|
||||
const columnWidth = this.getColumnWidth(selectedSheet, column);
|
||||
this.computeCellText(row, column, x, y, columnWidth, rowHeight);
|
||||
|
||||
x += columnWidth;
|
||||
}
|
||||
y += rowHeight;
|
||||
}
|
||||
|
||||
// Bottom-left pane
|
||||
y = frozenY;
|
||||
for (let { row } = topLeftCell; row <= bottomRightCell.row; row += 1) {
|
||||
x = headerColumnWidth;
|
||||
const rowHeight = this.getRowHeight(selectedSheet, row);
|
||||
|
||||
this.computeCellTextLeftRight(
|
||||
selectedSheet,
|
||||
row,
|
||||
rowHeight,
|
||||
topLeftCell,
|
||||
bottomRightCell,
|
||||
);
|
||||
for (let column = 1; column <= frozenColumns; column += 1) {
|
||||
const columnWidth = this.getColumnWidth(selectedSheet, column);
|
||||
this.computeCellText(row, column, x, y, columnWidth, rowHeight);
|
||||
|
||||
x += columnWidth;
|
||||
}
|
||||
y += rowHeight;
|
||||
}
|
||||
|
||||
// Bottom-right pane
|
||||
y = frozenY;
|
||||
for (let { row } = topLeftCell; row <= bottomRightCell.row; row += 1) {
|
||||
x = frozenX;
|
||||
const rowHeight = this.getRowHeight(selectedSheet, row);
|
||||
|
||||
for (
|
||||
let { column } = topLeftCell;
|
||||
column <= bottomRightCell.column;
|
||||
column += 1
|
||||
) {
|
||||
const columnWidth = this.getColumnWidth(selectedSheet, column);
|
||||
this.computeCellText(row, column, x, y, columnWidth, rowHeight);
|
||||
|
||||
x += columnWidth;
|
||||
}
|
||||
y += rowHeight;
|
||||
}
|
||||
}
|
||||
|
||||
// Compute the text properties for a cell
|
||||
private computeCellText(
|
||||
row: number,
|
||||
column: number,
|
||||
x: number,
|
||||
y: number,
|
||||
width: number,
|
||||
height: number,
|
||||
) {
|
||||
const selectedSheet = this.model.getSelectedSheet();
|
||||
|
||||
const style = this.model.getCellStyle(selectedSheet, row, column);
|
||||
|
||||
const { font, color: textColor, fontSize } = this.getFontStyle(style);
|
||||
|
||||
// Number = 1,
|
||||
// Text = 2,
|
||||
// LogicalValue = 4,
|
||||
// ErrorValue = 16,
|
||||
// Array = 64,
|
||||
// CompoundData = 128,
|
||||
const cellType = this.model.getCellType(selectedSheet, row, column);
|
||||
const { horizontal: horizontalAlign, vertical: verticalAlign } =
|
||||
this.getAlignment(style, cellType);
|
||||
|
||||
const wrapText = style.alignment?.wrap_text || false;
|
||||
|
||||
const context = this.ctx;
|
||||
context.font = font;
|
||||
context.fillStyle = textColor;
|
||||
const fullText = this.model.getFormattedCellValue(
|
||||
selectedSheet,
|
||||
row,
|
||||
column,
|
||||
);
|
||||
|
||||
// Is there any better to determine the line height?
|
||||
const lineHeight = fontSize * 1.5;
|
||||
const lines = computeWrappedLines(
|
||||
fullText,
|
||||
wrapText,
|
||||
context,
|
||||
width - cellPadding,
|
||||
);
|
||||
const lineCount = lines.length;
|
||||
let maxWidth = 0;
|
||||
let minX = x;
|
||||
let maxX = x + width;
|
||||
const textProperties = {
|
||||
row,
|
||||
column,
|
||||
x: minX,
|
||||
y,
|
||||
width,
|
||||
height,
|
||||
fontSize,
|
||||
textColor,
|
||||
font,
|
||||
underlined: style.font?.u || false,
|
||||
strike: style.font?.strike || false,
|
||||
lines: [] as [string, number, number, number][],
|
||||
};
|
||||
|
||||
lines.forEach((text, line) => {
|
||||
const textWidth = context.measureText(text).width;
|
||||
let textX: number;
|
||||
let textY: number;
|
||||
// The idea is that in the present font-size and default row heigh,
|
||||
// top/bottom and center horizontalAlign coincide
|
||||
const verticalPadding = 4;
|
||||
if (horizontalAlign === "right") {
|
||||
textX = width - cellPadding + x - textWidth / 2;
|
||||
} else if (horizontalAlign === "center") {
|
||||
textX = x + width / 2;
|
||||
} else {
|
||||
// left aligned
|
||||
textX = cellPadding + x + textWidth / 2;
|
||||
}
|
||||
if (verticalAlign === "bottom") {
|
||||
textY =
|
||||
y +
|
||||
height -
|
||||
fontSize / 2 -
|
||||
verticalPadding +
|
||||
(line - lineCount + 1) * lineHeight;
|
||||
} else if (verticalAlign === "center") {
|
||||
textY = y + height / 2 + (line + (1 - lineCount) / 2) * lineHeight;
|
||||
} else {
|
||||
// aligned top
|
||||
textY = y + fontSize / 2 + verticalPadding + line * lineHeight;
|
||||
}
|
||||
textProperties.lines.push([text, textX, textY, textWidth]);
|
||||
minX = Math.min(minX, textX - textWidth / 2);
|
||||
maxX = Math.max(maxX, textX + textWidth / 2);
|
||||
maxWidth = Math.max(maxWidth, textX + textWidth / 2 - x);
|
||||
});
|
||||
// we need to see if the text spills to the right of the cell
|
||||
let leftColumnX = x;
|
||||
let rightColumnX = x + width;
|
||||
if (
|
||||
maxX > rightColumnX &&
|
||||
column < LAST_COLUMN &&
|
||||
this.model.getFormattedCellValue(selectedSheet, row, column + 1) === ""
|
||||
) {
|
||||
let spillColumn = column + 1;
|
||||
// Keep expanding the spill to the right until:
|
||||
// 1. There is a non-empty cell
|
||||
// 2. Reaches the end of the row
|
||||
// 3. There is the end of frozen columns
|
||||
const frozenColumns = this.model.getFrozenColumnsCount(selectedSheet);
|
||||
while (
|
||||
rightColumnX < maxX &&
|
||||
this.model.getFormattedCellValue(selectedSheet, row, spillColumn) ===
|
||||
"" &&
|
||||
spillColumn <= LAST_COLUMN &&
|
||||
((column < frozenColumns && spillColumn <= frozenColumns) ||
|
||||
column > frozenColumns)
|
||||
) {
|
||||
rightColumnX += this.model.getColumnWidth(selectedSheet, spillColumn);
|
||||
// marks (row, spillColumn) as spilling so we don't draw a border to the left
|
||||
this.spills.set(`${row}-${spillColumn}`, 1);
|
||||
spillColumn += 1;
|
||||
}
|
||||
}
|
||||
// Same thing in the other direction, to the left of the cell
|
||||
const frozenColumnsCount = this.model.getFrozenColumnsCount(selectedSheet);
|
||||
if (
|
||||
minX < leftColumnX &&
|
||||
column > 1 &&
|
||||
this.model.getFormattedCellValue(selectedSheet, row, column - 1) === ""
|
||||
) {
|
||||
let spillColumn = column - 1;
|
||||
// Keep expanding the spill to the left until:
|
||||
// 1. There is a non-empty cell
|
||||
// 2. Reaches the beginning of the row
|
||||
// 3. There is the end of frozen columns
|
||||
while (
|
||||
leftColumnX > minX &&
|
||||
this.model.getFormattedCellValue(selectedSheet, row, spillColumn) ===
|
||||
"" &&
|
||||
spillColumn >= 1 &&
|
||||
((column <= frozenColumnsCount && spillColumn <= frozenColumnsCount) ||
|
||||
column > frozenColumnsCount)
|
||||
) {
|
||||
leftColumnX -= this.getColumnWidth(selectedSheet, spillColumn);
|
||||
// This is tricky but correct. The reason is we only draw the left borders of the cells
|
||||
// (because the left border of a cell MUST be the right border of the one to the left).
|
||||
// So if we want to remove the right border of this cell we need to skip the left border of the next.
|
||||
this.spills.set(`${row}-${spillColumn + 1}`, 1);
|
||||
spillColumn -= 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (frozenColumnsCount > 0) {
|
||||
const frozenColumnsX =
|
||||
this.getCoordinatesByCell(row, frozenColumnsCount)[0] +
|
||||
this.getColumnWidth(selectedSheet, frozenColumnsCount);
|
||||
if (column > frozenColumnsCount) {
|
||||
leftColumnX = Math.max(leftColumnX, frozenColumnsX);
|
||||
} else {
|
||||
rightColumnX = Math.min(rightColumnX, frozenColumnsX);
|
||||
}
|
||||
}
|
||||
textProperties.x = leftColumnX;
|
||||
textProperties.width = rightColumnX - leftColumnX;
|
||||
this.cells.push(textProperties);
|
||||
}
|
||||
|
||||
/// Renders the cell style: colors, borders, etc. But not the text.
|
||||
private renderCellStyle(
|
||||
private renderCell(
|
||||
row: number,
|
||||
column: number,
|
||||
x: number,
|
||||
@@ -720,7 +329,6 @@ export default class WorksheetCanvas {
|
||||
const selectedSheet = this.model.getSelectedSheet();
|
||||
const style = this.model.getCellStyle(selectedSheet, row, column);
|
||||
|
||||
// first the background
|
||||
let backgroundColor = "#FFFFFF";
|
||||
if (style.fill.fg_color) {
|
||||
backgroundColor = style.fill.fg_color;
|
||||
@@ -728,9 +336,32 @@ export default class WorksheetCanvas {
|
||||
const cellGridColor = this.model.getShowGridLines(selectedSheet)
|
||||
? gridColor
|
||||
: backgroundColor;
|
||||
|
||||
const fontSize = style.font?.sz || 13;
|
||||
let font = `${fontSize}px ${defaultCellFontFamily}`;
|
||||
let textColor = defaultTextColor;
|
||||
if (style.font) {
|
||||
textColor = style.font.color;
|
||||
font = style.font.b ? `bold ${font}` : `400 ${font}`;
|
||||
if (style.font.i) {
|
||||
font = `italic ${font}`;
|
||||
}
|
||||
}
|
||||
let horizontalAlign = "general";
|
||||
if (style.alignment?.horizontal) {
|
||||
horizontalAlign = style.alignment.horizontal;
|
||||
}
|
||||
let verticalAlign = "bottom";
|
||||
if (style.alignment?.vertical) {
|
||||
verticalAlign = style.alignment.vertical;
|
||||
}
|
||||
const wrapText = style.alignment?.wrap_text || false;
|
||||
|
||||
const context = this.ctx;
|
||||
context.font = font;
|
||||
context.fillStyle = backgroundColor;
|
||||
context.fillRect(x, y, width, height);
|
||||
context.fillStyle = textColor;
|
||||
|
||||
// Let's do the border
|
||||
// Algorithm:
|
||||
@@ -742,13 +373,24 @@ export default class WorksheetCanvas {
|
||||
// We only set the left and top borders (right and bottom are set later)
|
||||
const border = style.border;
|
||||
|
||||
// we skip don't draw a left border if it is marked as a "spill cell"
|
||||
if (this.spills.get(`${row}-${column}`) !== 1) {
|
||||
let borderLeftColor = cellGridColor;
|
||||
let borderLeftWidth = 1;
|
||||
if (border.left) {
|
||||
borderLeftColor = border.left.color;
|
||||
switch (border.left.style) {
|
||||
let borderLeftColor = cellGridColor;
|
||||
let borderLeftWidth = 1;
|
||||
if (border.left) {
|
||||
borderLeftColor = border.left.color;
|
||||
switch (border.left.style) {
|
||||
case "thin":
|
||||
break;
|
||||
case "medium":
|
||||
borderLeftWidth = 2;
|
||||
break;
|
||||
case "thick":
|
||||
borderLeftWidth = 3;
|
||||
}
|
||||
} else {
|
||||
const leftStyle = this.model.getCellStyle(selectedSheet, row, column - 1);
|
||||
if (leftStyle.border.right) {
|
||||
borderLeftColor = leftStyle.border.right.color;
|
||||
switch (leftStyle.border.right.style) {
|
||||
case "thin":
|
||||
break;
|
||||
case "medium":
|
||||
@@ -757,37 +399,18 @@ export default class WorksheetCanvas {
|
||||
case "thick":
|
||||
borderLeftWidth = 3;
|
||||
}
|
||||
} else {
|
||||
const leftStyle = this.model.getCellStyle(
|
||||
selectedSheet,
|
||||
row,
|
||||
column - 1,
|
||||
);
|
||||
if (leftStyle.border.right) {
|
||||
borderLeftColor = leftStyle.border.right.color;
|
||||
switch (leftStyle.border.right.style) {
|
||||
case "thin":
|
||||
break;
|
||||
case "medium":
|
||||
borderLeftWidth = 2;
|
||||
break;
|
||||
case "thick":
|
||||
borderLeftWidth = 3;
|
||||
}
|
||||
} else if (style.fill.fg_color) {
|
||||
borderLeftColor = style.fill.fg_color;
|
||||
} else if (leftStyle.fill.fg_color) {
|
||||
borderLeftColor = leftStyle.fill.fg_color;
|
||||
}
|
||||
} else if (style.fill.fg_color) {
|
||||
borderLeftColor = style.fill.fg_color;
|
||||
} else if (leftStyle.fill.fg_color) {
|
||||
borderLeftColor = leftStyle.fill.fg_color;
|
||||
}
|
||||
|
||||
context.beginPath();
|
||||
context.strokeStyle = borderLeftColor;
|
||||
context.lineWidth = borderLeftWidth;
|
||||
context.moveTo(x, y);
|
||||
context.lineTo(x, y + height);
|
||||
context.stroke();
|
||||
}
|
||||
context.beginPath();
|
||||
context.strokeStyle = borderLeftColor;
|
||||
context.lineWidth = borderLeftWidth;
|
||||
context.moveTo(x, y);
|
||||
context.lineTo(x, y + height);
|
||||
context.stroke();
|
||||
|
||||
let borderTopColor = cellGridColor;
|
||||
let borderTopWidth = 1;
|
||||
@@ -827,56 +450,100 @@ export default class WorksheetCanvas {
|
||||
context.moveTo(x, y);
|
||||
context.lineTo(x + width, y);
|
||||
context.stroke();
|
||||
}
|
||||
|
||||
/// Renders the text in the cell.
|
||||
private renderCellText(textProperties: TextProperties) {
|
||||
const {
|
||||
x,
|
||||
y,
|
||||
width,
|
||||
height,
|
||||
font,
|
||||
underlined,
|
||||
strike,
|
||||
fontSize,
|
||||
textColor,
|
||||
lines,
|
||||
} = textProperties;
|
||||
const context = this.ctx;
|
||||
// Number = 1,
|
||||
// Text = 2,
|
||||
// LogicalValue = 4,
|
||||
// ErrorValue = 16,
|
||||
// Array = 64,
|
||||
// CompoundData = 128,
|
||||
|
||||
const cellType = this.model.getCellType(selectedSheet, row, column);
|
||||
const fullText = this.model.getFormattedCellValue(
|
||||
selectedSheet,
|
||||
row,
|
||||
column,
|
||||
);
|
||||
const padding = 4;
|
||||
if (horizontalAlign === "general") {
|
||||
if (cellType === 1) {
|
||||
horizontalAlign = "right";
|
||||
} else if (cellType === 4) {
|
||||
horizontalAlign = "center";
|
||||
} else {
|
||||
horizontalAlign = "left";
|
||||
}
|
||||
}
|
||||
|
||||
context.font = font;
|
||||
context.fillStyle = textColor;
|
||||
// Create a rectangular clipping region
|
||||
context.save();
|
||||
context.beginPath();
|
||||
context.rect(x, y, width, height);
|
||||
context.clip();
|
||||
|
||||
lines.forEach((line, _) => {
|
||||
const [textContent, textX, textY, textWidth] = line;
|
||||
context.fillText(textContent, textX, textY);
|
||||
// Is there any better to determine the line height?
|
||||
const lineHeight = fontSize * 1.5;
|
||||
const lines = computeWrappedLines(
|
||||
fullText,
|
||||
wrapText,
|
||||
context,
|
||||
width - padding,
|
||||
);
|
||||
const lineCount = lines.length;
|
||||
|
||||
if (underlined) {
|
||||
// There are no text-decoration in canvas. You have to do the underline yourself.
|
||||
const offset = Math.floor(fontSize / 2);
|
||||
context.beginPath();
|
||||
context.strokeStyle = textColor;
|
||||
context.lineWidth = 1;
|
||||
context.moveTo(textX - textWidth / 2, textY + offset);
|
||||
context.lineTo(textX + textWidth / 2, textY + offset);
|
||||
context.stroke();
|
||||
lines.forEach((text, line) => {
|
||||
const textWidth = context.measureText(text).width;
|
||||
let textX: number;
|
||||
let textY: number;
|
||||
// The idea is that in the present font-size and default row heigh,
|
||||
// top/bottom and center horizontalAlign coincide
|
||||
const verticalPadding = 4;
|
||||
if (horizontalAlign === "right") {
|
||||
textX = width - padding + x - textWidth / 2;
|
||||
} else if (horizontalAlign === "center") {
|
||||
textX = x + width / 2;
|
||||
} else {
|
||||
// left aligned
|
||||
textX = padding + x + textWidth / 2;
|
||||
}
|
||||
if (strike) {
|
||||
// There are no text-decoration in canvas. You have to do the strikethrough yourself.
|
||||
context.beginPath();
|
||||
context.strokeStyle = textColor;
|
||||
context.lineWidth = 1;
|
||||
context.moveTo(textX - textWidth / 2, textY);
|
||||
context.lineTo(textX + textWidth / 2, textY);
|
||||
context.stroke();
|
||||
if (verticalAlign === "bottom") {
|
||||
textY =
|
||||
y +
|
||||
height -
|
||||
fontSize / 2 -
|
||||
verticalPadding +
|
||||
(line - lineCount + 1) * lineHeight;
|
||||
} else if (verticalAlign === "center") {
|
||||
textY = y + height / 2 + (line + (1 - lineCount) / 2) * lineHeight;
|
||||
} else {
|
||||
// aligned top
|
||||
textY = y + fontSize / 2 + verticalPadding + line * lineHeight;
|
||||
}
|
||||
context.fillText(text, textX, textY);
|
||||
if (style.font) {
|
||||
if (style.font.u) {
|
||||
// There are no text-decoration in canvas. You have to do the underline yourself.
|
||||
const offset = Math.floor(fontSize / 2);
|
||||
context.beginPath();
|
||||
context.strokeStyle = textColor;
|
||||
context.lineWidth = 1;
|
||||
context.moveTo(textX - textWidth / 2, textY + offset);
|
||||
context.lineTo(textX + textWidth / 2, textY + offset);
|
||||
context.stroke();
|
||||
}
|
||||
if (style.font.strike) {
|
||||
// There are no text-decoration in canvas. You have to do the strikethrough yourself.
|
||||
context.beginPath();
|
||||
context.strokeStyle = textColor;
|
||||
context.lineWidth = 1;
|
||||
context.moveTo(textX - textWidth / 2, textY);
|
||||
context.lineTo(textX + textWidth / 2, textY);
|
||||
context.stroke();
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// remove the clipping region
|
||||
context.restore();
|
||||
}
|
||||
|
||||
@@ -1745,7 +1412,6 @@ export default class WorksheetCanvas {
|
||||
this.removeHandles();
|
||||
|
||||
const { topLeftCell, bottomRightCell } = this.getVisibleCells();
|
||||
this.computeCellsText();
|
||||
|
||||
const frozenColumns = this.model.getFrozenColumnsCount(selectedSheet);
|
||||
const frozenRows = this.model.getFrozenRowsCount(selectedSheet);
|
||||
@@ -1758,7 +1424,7 @@ export default class WorksheetCanvas {
|
||||
x = headerColumnWidth + 0.5;
|
||||
for (let column = 1; column <= frozenColumns; column += 1) {
|
||||
const columnWidth = this.getColumnWidth(selectedSheet, column);
|
||||
this.renderCellStyle(row, column, x, y, columnWidth, rowHeight);
|
||||
this.renderCell(row, column, x, y, columnWidth, rowHeight);
|
||||
x += columnWidth;
|
||||
}
|
||||
y += rowHeight;
|
||||
@@ -1808,7 +1474,7 @@ export default class WorksheetCanvas {
|
||||
column += 1
|
||||
) {
|
||||
const columnWidth = this.getColumnWidth(selectedSheet, column);
|
||||
this.renderCellStyle(row, column, x, y, columnWidth, rowHeight);
|
||||
this.renderCell(row, column, x, y, columnWidth, rowHeight);
|
||||
x += columnWidth;
|
||||
}
|
||||
y += rowHeight;
|
||||
@@ -1822,7 +1488,7 @@ export default class WorksheetCanvas {
|
||||
|
||||
for (let column = 1; column <= frozenColumns; column += 1) {
|
||||
const columnWidth = this.getColumnWidth(selectedSheet, column);
|
||||
this.renderCellStyle(row, column, x, y, columnWidth, rowHeight);
|
||||
this.renderCell(row, column, x, y, columnWidth, rowHeight);
|
||||
|
||||
x += columnWidth;
|
||||
}
|
||||
@@ -1841,18 +1507,13 @@ export default class WorksheetCanvas {
|
||||
column += 1
|
||||
) {
|
||||
const columnWidth = this.getColumnWidth(selectedSheet, column);
|
||||
this.renderCellStyle(row, column, x, y, columnWidth, rowHeight);
|
||||
this.renderCell(row, column, x, y, columnWidth, rowHeight);
|
||||
|
||||
x += columnWidth;
|
||||
}
|
||||
y += rowHeight;
|
||||
}
|
||||
|
||||
// Render all cell texts
|
||||
for (const cell of this.cells) {
|
||||
this.renderCellText(cell);
|
||||
}
|
||||
|
||||
// Draw column headers
|
||||
this.renderColumnHeaders(
|
||||
frozenColumns,
|
||||
|
||||
@@ -3,34 +3,6 @@ import type { Area, Cell } from "./types";
|
||||
import { type SelectedView, columnNameFromNumber } from "@ironcalc/wasm";
|
||||
import { LAST_COLUMN, LAST_ROW } from "./WorksheetCanvas/constants";
|
||||
|
||||
// FIXME: Use the `quoteName` function from the wasm module
|
||||
function nameNeedsQuoting(name: string): boolean {
|
||||
// it contains any of these characters: ()'$,;-+{} or space
|
||||
for (const char of name) {
|
||||
if (" ()'$,;-+{}".includes(char)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
// TODO:
|
||||
// - cell reference in A1 notation, e.g. B1048576 is quoted, B1048577 is not
|
||||
// - cell reference in R1C1 notation, e.g. RC, RC2, R5C, R-4C, RC-8, R, C
|
||||
// - integers
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Quotes a string sheet name if it needs to
|
||||
* NOTE: Invalid characters in a sheet name: \, /, *, [, ], :, ?
|
||||
*/
|
||||
export function quoteName(name: string): string {
|
||||
if (nameNeedsQuoting(name)) {
|
||||
return `'${name.replace(/'/g, "''")}'`;
|
||||
}
|
||||
return name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if the keypress should start editing
|
||||
*/
|
||||
@@ -94,8 +66,7 @@ export function rangeToStr(
|
||||
referenceName: string,
|
||||
): string {
|
||||
const { sheet, rowStart, rowEnd, columnStart, columnEnd } = range;
|
||||
const sheetName =
|
||||
sheet === referenceSheet ? "" : `${quoteName(referenceName)}!`;
|
||||
const sheetName = sheet === referenceSheet ? "" : `'${referenceName}'!`;
|
||||
if (rowStart === rowEnd && columnStart === columnEnd) {
|
||||
return `${sheetName}${columnNameFromNumber(columnStart)}${rowStart}`;
|
||||
}
|
||||
@@ -111,7 +82,7 @@ export function getFullRangeToString(
|
||||
worksheetNames: string[],
|
||||
): string {
|
||||
const [rowStart, columnStart, rowEnd, columnEnd] = selectedView.range;
|
||||
const sheetName = quoteName(worksheetNames[selectedView.sheet]);
|
||||
const sheetName = `${worksheetNames[selectedView.sheet]}`;
|
||||
|
||||
if (rowStart === rowEnd && columnStart === columnEnd) {
|
||||
return `${sheetName}!$${columnNameFromNumber(columnStart)}$${rowStart}`;
|
||||
|
||||
6
webapp/IronCalc/src/icons/decrease-decimal.svg
Normal file
6
webapp/IronCalc/src/icons/decrease-decimal.svg
Normal file
@@ -0,0 +1,6 @@
|
||||
<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
|
||||
<path d="M12.5 11.3333H5" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"/>
|
||||
<path d="M7 9.33333L5 11.3333L7 13.3333" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"/>
|
||||
<path d="M7.66667 4.33333C7.66667 3.59695 7.06971 3 6.33333 3C5.59695 3 5 3.59695 5 4.33333V5.66667C5 6.40305 5.59695 7 6.33333 7C7.06971 7 7.66667 6.40305 7.66667 5.66667V4.33333Z" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"/>
|
||||
<path d="M3 7H3.00667" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 659 B |
7
webapp/IronCalc/src/icons/increase-decimal.svg
Normal file
7
webapp/IronCalc/src/icons/increase-decimal.svg
Normal file
@@ -0,0 +1,7 @@
|
||||
<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
|
||||
<path d="M12.5 11.3333H5" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"/>
|
||||
<path d="M10.5 9.33333L12.5 11.3333L10.5 13.3333" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"/>
|
||||
<path d="M7.66667 4.33333C7.66667 3.59695 7.06971 3 6.33333 3C5.59695 3 5 3.59695 5 4.33333V5.66667C5 6.40305 5.59695 7 6.33333 7C7.06971 7 7.66667 6.40305 7.66667 5.66667V4.33333Z" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"/>
|
||||
<path d="M12.3333 4.33333C12.3333 3.59695 11.7364 3 11 3C10.2636 3 9.66667 3.59695 9.66667 4.33333V5.66667C9.66667 6.40305 10.2636 7 11 7C11.7364 7 12.3333 6.40305 12.3333 5.66667V4.33333Z" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"/>
|
||||
<path d="M3 7H3.00667" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 929 B |
@@ -1,3 +1,6 @@
|
||||
import DecimalPlacesDecreaseIcon from "./decrease-decimal.svg?react";
|
||||
import DecimalPlacesIncreaseIcon from "./increase-decimal.svg?react";
|
||||
|
||||
import BorderBottomIcon from "./border-bottom.svg?react";
|
||||
import BorderCenterHIcon from "./border-center-h.svg?react";
|
||||
import BorderCenterVIcon from "./border-center-v.svg?react";
|
||||
@@ -24,6 +27,8 @@ import Fx from "./fx.svg?react";
|
||||
|
||||
export {
|
||||
ArrowMiddleFromLine,
|
||||
DecimalPlacesDecreaseIcon,
|
||||
DecimalPlacesIncreaseIcon,
|
||||
BorderBottomIcon,
|
||||
BorderCenterHIcon,
|
||||
BorderCenterVIcon,
|
||||
|
||||
@@ -118,13 +118,7 @@
|
||||
"delete_column": "Delete column '{{column}}'",
|
||||
"freeze": "Freeze",
|
||||
"insert_row": "Insert row",
|
||||
"insert_column": "Insert column",
|
||||
"move_row": "Move row",
|
||||
"move_column": "Move column",
|
||||
"move_row_up": "Move row up",
|
||||
"move_row_down": "Move row down",
|
||||
"move_column_left": "Move column left",
|
||||
"move_column_right": "Move column right"
|
||||
"insert_column": "Insert column"
|
||||
},
|
||||
"color_picker": {
|
||||
"apply": "Add color",
|
||||
|
||||
@@ -46,8 +46,8 @@ export const theme = createTheme({
|
||||
contrastText: "#FFF",
|
||||
},
|
||||
grey: {
|
||||
"50": "#F5F5F5",
|
||||
"100": "#F2F2F2",
|
||||
"50": "#F2F2F2",
|
||||
"100": "#F5F5F5",
|
||||
"200": "#EEEEEE",
|
||||
"300": "#E0E0E0",
|
||||
"400": "#BDBDBD",
|
||||
|
||||
675
webapp/app.ironcalc.com/frontend/package-lock.json
generated
675
webapp/app.ironcalc.com/frontend/package-lock.json
generated
File diff suppressed because it is too large
Load Diff
@@ -1,6 +1,6 @@
|
||||
import "./App.css";
|
||||
import styled from "@emotion/styled";
|
||||
import { useEffect, useState } from "react";
|
||||
import { useCallback, useEffect, useState } from "react";
|
||||
import { FileBar } from "./components/FileBar";
|
||||
import LeftDrawer from "./components/LeftDrawer/LeftDrawer";
|
||||
import {
|
||||
@@ -10,10 +10,9 @@ import {
|
||||
} from "./components/rpc";
|
||||
import {
|
||||
createNewModel,
|
||||
deleteModelByUuid,
|
||||
deleteSelectedModel,
|
||||
// getModelsMetadata,
|
||||
// getSelectedUuid,
|
||||
getModelsMetadata,
|
||||
getSelectedUuid,
|
||||
loadModelFromStorageOrCreate,
|
||||
saveModelToStorage,
|
||||
saveSelectedModelInStorage,
|
||||
@@ -26,6 +25,13 @@ import { IronCalc, IronCalcIcon, Model, init } from "@ironcalc/workbook";
|
||||
function App() {
|
||||
const [model, setModel] = useState<Model | null>(null);
|
||||
const [isDrawerOpen, setIsDrawerOpen] = useState(false);
|
||||
const [modelsMetadata, setModelsMetadata] = useState(getModelsMetadata());
|
||||
const [selectedUuid, setSelectedUuid] = useState(getSelectedUuid());
|
||||
|
||||
const refreshModelsData = useCallback(() => {
|
||||
setModelsMetadata(getModelsMetadata());
|
||||
setSelectedUuid(getSelectedUuid());
|
||||
}, []);
|
||||
|
||||
useEffect(() => {
|
||||
async function start() {
|
||||
@@ -43,6 +49,7 @@ function App() {
|
||||
const importedModel = Model.from_bytes(model_bytes);
|
||||
localStorage.removeItem("selected");
|
||||
setModel(importedModel);
|
||||
refreshModelsData();
|
||||
} catch (e) {
|
||||
alert("Model not found, or failed to load");
|
||||
}
|
||||
@@ -52,6 +59,7 @@ function App() {
|
||||
const importedModel = Model.from_bytes(model_bytes);
|
||||
localStorage.removeItem("selected");
|
||||
setModel(importedModel);
|
||||
refreshModelsData();
|
||||
} catch (e) {
|
||||
alert("Example file not found, or failed to load");
|
||||
}
|
||||
@@ -59,10 +67,11 @@ function App() {
|
||||
// try to load from local storage
|
||||
const newModel = loadModelFromStorageOrCreate();
|
||||
setModel(newModel);
|
||||
refreshModelsData();
|
||||
}
|
||||
}
|
||||
start();
|
||||
}, []);
|
||||
}, [refreshModelsData]);
|
||||
|
||||
if (!model) {
|
||||
return (
|
||||
@@ -88,12 +97,14 @@ function App() {
|
||||
const handleNewModel = () => {
|
||||
const newModel = createNewModel();
|
||||
setModel(newModel);
|
||||
refreshModelsData();
|
||||
};
|
||||
|
||||
const handleSetModel = (uuid: string) => {
|
||||
const newModel = selectModelFromStorage(uuid);
|
||||
if (newModel) {
|
||||
setModel(newModel);
|
||||
refreshModelsData();
|
||||
}
|
||||
};
|
||||
|
||||
@@ -101,13 +112,7 @@ function App() {
|
||||
const newModel = deleteSelectedModel();
|
||||
if (newModel) {
|
||||
setModel(newModel);
|
||||
}
|
||||
};
|
||||
|
||||
const handleDeleteModelByUuid = (uuid: string) => {
|
||||
const newModel = deleteModelByUuid(uuid);
|
||||
if (newModel) {
|
||||
setModel(newModel);
|
||||
refreshModelsData();
|
||||
}
|
||||
};
|
||||
|
||||
@@ -118,7 +123,9 @@ function App() {
|
||||
onClose={() => setIsDrawerOpen(false)}
|
||||
newModel={handleNewModel}
|
||||
setModel={handleSetModel}
|
||||
onDelete={handleDeleteModelByUuid}
|
||||
models={modelsMetadata}
|
||||
selectedUuid={selectedUuid}
|
||||
setDeleteDialogOpen={() => {}}
|
||||
/>
|
||||
|
||||
<MainContent isDrawerOpen={isDrawerOpen}>
|
||||
@@ -130,12 +137,14 @@ function App() {
|
||||
const newModel = Model.from_bytes(bytes);
|
||||
saveModelToStorage(newModel);
|
||||
setModel(newModel);
|
||||
refreshModelsData();
|
||||
}}
|
||||
newModel={handleNewModel}
|
||||
setModel={handleSetModel}
|
||||
onDelete={handleDeleteModel}
|
||||
isDrawerOpen={isDrawerOpen}
|
||||
setIsDrawerOpen={setIsDrawerOpen}
|
||||
refreshModelsData={refreshModelsData}
|
||||
/>
|
||||
<IronCalc model={model} />
|
||||
</MainContent>
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user