UPDATE: Ladies and gentlemen: conditional formatting!

(and everything in between)

.github/workflows/test-coverage.yaml

@@ -1,10 +1,7 @@
 name: Coverage
 
 on:
-  pull_request:
+  workflow_dispatch:
-  push:
-    branches:
-      - main
 
 jobs:
   coverage:

CHANGELOG.md

@@ -12,6 +12,7 @@
 
 - Fixed several issues with pasting content
 - Fixed several issues with borders
+- Fixed bug where columns and rows could be resized to negative width and height, respectively
 
 ## [0.2.0] - 2024-11-06 (The HN release)
 

Makefile

@@ -10,6 +10,7 @@ format:
 
 .PHONY: tests
 tests: lint
+	cargo test
 	make remove-artifacts
 	# Regretabbly we need to build the wasm twice, once for the nodejs tests
 	# and a second one for the vitest.

base/src/cell.rs

@@ -176,18 +176,3 @@ impl Cell {
         }
     }
 }
-
-// Implementing methods for MergedCells struct
-
-impl MergedCells {
-    pub fn is_cell_part_of_merged_cells(&self, row: i32, col: i32) -> bool {
-        // This is merge Mother cell so do not include this cell as part of Merged Cells
-        if row == self.0 && col == self.1 {
-            return false;
-        }
-
-        let result: bool = (row >= self.0 && row <= self.2) && (col >= self.1 && col <= self.3);
-
-        result
-    }
-}

base/src/constants.rs

@@ -6,7 +6,7 @@ pub(crate) const DEFAULT_COLUMN_WIDTH: f64 = 125.0;
 pub(crate) const DEFAULT_ROW_HEIGHT: f64 = 28.0;
 pub(crate) const COLUMN_WIDTH_FACTOR: f64 = 12.0;
 pub(crate) const ROW_HEIGHT_FACTOR: f64 = 2.0;
-pub(crate) const DEFAULT_WINDOW_HEIGH: i64 = 600;
+pub(crate) const DEFAULT_WINDOW_HEIGHT: i64 = 600;
 pub(crate) const DEFAULT_WINDOW_WIDTH: i64 = 800;
 
 pub(crate) const LAST_COLUMN: i32 = 16_384;

base/src/expressions/lexer/test/test_util.rs

@@ -24,6 +24,25 @@ fn test_get_tokens() {
     assert_eq!(l.end, 10);
 }
 
+#[test]
+fn get_tokens_unicode() {
+    let formula = "'🇵🇭 Philippines'!A1";
+    let t = get_tokens(formula);
+    assert_eq!(t.len(), 1);
+
+    let expected = TokenType::Reference {
+        sheet: Some("🇵🇭 Philippines".to_string()),
+        row: 1,
+        column: 1,
+        absolute_column: false,
+        absolute_row: false,
+    };
+    let l = t.first().expect("expected token");
+    assert_eq!(l.token, expected);
+    assert_eq!(l.start, 0);
+    assert_eq!(l.end, 19);
+}
+
 #[test]
 fn test_simple_tokens() {
     assert_eq!(

base/src/expressions/parser/mod.rs

@@ -49,15 +49,7 @@ pub mod stringify;
 pub mod walk;
 
 #[cfg(test)]
-mod test;
+mod tests;
-
-#[cfg(test)]
-mod test_ranges;
-
-#[cfg(test)]
-mod test_move_formula;
-#[cfg(test)]
-mod test_tables;
 
 pub(crate) fn parse_range(formula: &str) -> Result<(i32, i32, i32, i32), String> {
     let mut lexer = lexer::Lexer::new(
@@ -522,20 +514,6 @@ impl Parser {
                 let mut absolute_row1 = left.absolute_row;
                 let mut absolute_row2 = right.absolute_row;
 
-                if self.lexer.is_a1_mode() {
-                    if !left.absolute_row {
-                        row1 -= context.row
-                    };
-                    if !left.absolute_column {
-                        column1 -= context.column
-                    };
-                    if !right.absolute_row {
-                        row2 -= context.row
-                    };
-                    if !right.absolute_column {
-                        column2 -= context.column
-                    };
-                }
                 if row1 > row2 {
                     (row2, row1) = (row1, row2);
                     (absolute_row2, absolute_row1) = (absolute_row1, absolute_row2);
@@ -544,6 +522,22 @@ impl Parser {
                     (column2, column1) = (column1, column2);
                     (absolute_column2, absolute_column1) = (absolute_column1, absolute_column2);
                 }
+
+                if self.lexer.is_a1_mode() {
+                    if !absolute_row1 {
+                        row1 -= context.row
+                    };
+                    if !absolute_column1 {
+                        column1 -= context.column
+                    };
+                    if !absolute_row2 {
+                        row2 -= context.row
+                    };
+                    if !absolute_column2 {
+                        column2 -= context.column
+                    };
+                }
+
                 match sheet_index {
                     Some(index) => Node::RangeKind {
                         sheet_name: sheet,

base/src/expressions/parser/stringify.rs

@@ -456,11 +456,65 @@ fn stringify(
             };
             format!("{}{}{}", x, kind, y)
         }
-        OpPowerKind { left, right } => format!(
+        OpPowerKind { left, right } => {
-            "{}^{}",
+            let x = match **left {
-            stringify(left, context, displace_data, use_original_name),
+                BooleanKind(_)
-            stringify(right, context, displace_data, use_original_name)
+                | NumberKind(_)
-        ),
+                | StringKind(_)
+                | ReferenceKind { .. }
+                | RangeKind { .. }
+                | WrongReferenceKind { .. }
+                | VariableKind(_)
+                | WrongRangeKind { .. } => {
+                    stringify(left, context, displace_data, use_original_name)
+                }
+                OpRangeKind { .. }
+                | OpConcatenateKind { .. }
+                | OpProductKind { .. }
+                | OpPowerKind { .. }
+                | FunctionKind { .. }
+                | InvalidFunctionKind { .. }
+                | ArrayKind(_)
+                | UnaryKind { .. }
+                | ErrorKind(_)
+                | ParseErrorKind { .. }
+                | OpSumKind { .. }
+                | CompareKind { .. }
+                | EmptyArgKind => format!(
+                    "({})",
+                    stringify(left, context, displace_data, use_original_name)
+                ),
+            };
+            let y = match **right {
+                BooleanKind(_)
+                | NumberKind(_)
+                | StringKind(_)
+                | ReferenceKind { .. }
+                | RangeKind { .. }
+                | WrongReferenceKind { .. }
+                | VariableKind(_)
+                | WrongRangeKind { .. } => {
+                    stringify(right, context, displace_data, use_original_name)
+                }
+                OpRangeKind { .. }
+                | OpConcatenateKind { .. }
+                | OpProductKind { .. }
+                | OpPowerKind { .. }
+                | FunctionKind { .. }
+                | InvalidFunctionKind { .. }
+                | ArrayKind(_)
+                | UnaryKind { .. }
+                | ErrorKind(_)
+                | ParseErrorKind { .. }
+                | OpSumKind { .. }
+                | CompareKind { .. }
+                | EmptyArgKind => format!(
+                    "({})",
+                    stringify(right, context, displace_data, use_original_name)
+                ),
+            };
+            format!("{}^{}", x, y)
+        }
         InvalidFunctionKind { name, args } => {
             format_function(name, args, context, displace_data, use_original_name)
         }

base/src/expressions/parser/tests/mod.rs

@@ -0,0 +1,6 @@
+mod test_general;
+mod test_issue_155;
+mod test_move_formula;
+mod test_ranges;
+mod test_stringify;
+mod test_tables;

base/src/expressions/parser/tests/test_general.rs

@@ -3,17 +3,11 @@
 use std::collections::HashMap;
 
 use crate::expressions::lexer::LexerMode;
-use crate::expressions::parser::stringify::DisplaceData;
+use crate::expressions::parser::stringify::{
-
+    to_rc_format, to_string, to_string_displaced, DisplaceData,
-use super::super::types::CellReferenceRC;
-use super::Parser;
-use super::{
-    super::parser::{
-        stringify::{to_rc_format, to_string},
-        Node,
-    },
-    stringify::to_string_displaced,
 };
+use crate::expressions::parser::{Node, Parser};
+use crate::expressions::types::CellReferenceRC;
 
 struct Formula<'a> {
     initial: &'a str,

base/src/expressions/parser/tests/test_issue_155.rs

@@ -0,0 +1,69 @@
+#![allow(clippy::panic)]
+
+use std::collections::HashMap;
+
+use crate::expressions::parser::stringify::to_string;
+use crate::expressions::parser::Parser;
+use crate::expressions::types::CellReferenceRC;
+
+#[test]
+fn issue_155_parser() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 2,
+        column: 2,
+    };
+    let t = parser.parse("A$1:A2", &Some(cell_reference.clone()));
+    assert_eq!(to_string(&t, &cell_reference), "A$1:A2");
+}
+
+#[test]
+fn issue_155_parser_case_2() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 20,
+        column: 20,
+    };
+    let t = parser.parse("C$1:D2", &Some(cell_reference.clone()));
+    assert_eq!(to_string(&t, &cell_reference), "C$1:D2");
+}
+
+#[test]
+fn issue_155_parser_only_row() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 20,
+        column: 20,
+    };
+    // This is tricky, I am not sure what to do in these cases
+    let t = parser.parse("A$2:B1", &Some(cell_reference.clone()));
+    assert_eq!(to_string(&t, &cell_reference), "A1:B$2");
+}
+
+#[test]
+fn issue_155_parser_only_column() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 20,
+        column: 20,
+    };
+    // This is tricky, I am not sure what to do in these cases
+    let t = parser.parse("D1:$A3", &Some(cell_reference.clone()));
+    assert_eq!(to_string(&t, &cell_reference), "$A1:D3");
+}

base/src/expressions/parser/tests/test_move_formula.rs

@@ -1,10 +1,8 @@
 use std::collections::HashMap;
 
 use crate::expressions::parser::move_formula::{move_formula, MoveContext};
-use crate::expressions::types::Area;
+use crate::expressions::parser::Parser;
-
+use crate::expressions::types::{Area, CellReferenceRC};
-use super::super::types::CellReferenceRC;
-use super::Parser;
 
 #[test]
 fn test_move_formula() {

base/src/expressions/parser/tests/test_ranges.rs

@@ -2,9 +2,9 @@ use std::collections::HashMap;
 
 use crate::expressions::lexer::LexerMode;
 
-use super::super::parser::stringify::{to_rc_format, to_string};
+use crate::expressions::parser::stringify::{to_rc_format, to_string};
-use super::super::types::CellReferenceRC;
+use crate::expressions::parser::Parser;
-use super::Parser;
+use crate::expressions::types::CellReferenceRC;
 
 struct Formula<'a> {
     formula_a1: &'a str,

base/src/expressions/parser/tests/test_stringify.rs

@@ -0,0 +1,34 @@
+#![allow(clippy::panic)]
+
+use std::collections::HashMap;
+
+use crate::expressions::parser::stringify::to_string;
+use crate::expressions::parser::Parser;
+use crate::expressions::types::CellReferenceRC;
+
+#[test]
+fn exp_order() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+    let t = parser.parse("(1 + 2)^3  + 4", &Some(cell_reference.clone()));
+    assert_eq!(to_string(&t, &cell_reference), "(1+2)^3+4");
+
+    let t = parser.parse("(C5 + 3)^R4", &Some(cell_reference.clone()));
+    assert_eq!(to_string(&t, &cell_reference), "(C5+3)^R4");
+
+    let t = parser.parse("(C5 + 3)^(R4*6)", &Some(cell_reference.clone()));
+    assert_eq!(to_string(&t, &cell_reference), "(C5+3)^(R4*6)");
+
+    let t = parser.parse("(C5)^(R4)", &Some(cell_reference.clone()));
+    assert_eq!(to_string(&t, &cell_reference), "C5^R4");
+
+    let t = parser.parse("(5)^(4)", &Some(cell_reference.clone()));
+    assert_eq!(to_string(&t, &cell_reference), "5^4");
+}

base/src/expressions/parser/tests/test_tables.rs

@@ -6,8 +6,8 @@ use crate::expressions::parser::stringify::to_string;
 use crate::expressions::utils::{number_to_column, parse_reference_a1};
 use crate::types::{Table, TableColumn, TableStyleInfo};
 
-use super::super::types::CellReferenceRC;
+use crate::expressions::parser::Parser;
-use super::Parser;
+use crate::expressions::types::CellReferenceRC;
 
 fn create_test_table(
     table_name: &str,

base/src/formatter/format.rs

@@ -245,6 +245,9 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
         }
         ParsePart::Number(p) => {
             let mut text = "".to_string();
+            if let Some(c) = p.currency {
+                text = format!("{}", c);
+            }
             let tokens = &p.tokens;
             value = value * 100.0_f64.powi(p.percent) / (1000.0_f64.powi(p.comma));
             // p.precision is the number of significant digits _after_ the decimal point

base/src/formatter/lexer.rs

@@ -10,6 +10,7 @@ pub struct Lexer {
 pub enum Token {
     Color(i32),              // [Red] or [Color 23]
     Condition(Compare, f64), // [<=100] (Comparator, number)
+    Currency(char),          // [$€] ($ currency symbol)
     Literal(char), // €, $, (, ), /, :, +, -, ^, ', {, }, <, =, !, ~, > and space or scaped \X
     Spacer(char),  // *X
     Ghost(char),   // _X
@@ -274,6 +275,15 @@ impl Lexer {
                                 self.set_error("Failed to parse condition");
                                 Token::ILLEGAL
                             }
+                        } else if c == '$' {
+                            // currency
+                            self.read_next_char();
+                            if let Some(currency) = self.read_next_char() {
+                                self.read_next_char();
+                                return Token::Currency(currency);
+                            }
+                            self.set_error("Failed to parse currency");
+                            Token::ILLEGAL
                         } else {
                             // Color
                             if let Some(index) = self.consume_color() {

base/src/formatter/mod.rs

@@ -74,6 +74,7 @@ mod test;
 //
 // * Color [Red] or [Color 23] or [Color23]
 // * Conditions [<100]
+// * Currency [$€]
 // * Space _X when X is any given char
 // * A spacer of chars: *X where X is repeated as much as possible
 // * Literals: $, (, ), :, +, - and space

base/src/formatter/parser.rs

@@ -40,6 +40,7 @@ pub struct NumberPart {
     pub is_scientific: bool,
     pub scientific_minus: bool,
     pub exponent_digit_count: i32,
+    pub currency: Option<char>,
 }
 
 pub struct DatePart {
@@ -114,6 +115,7 @@ impl Parser {
         let mut exponent_digit_count = 0;
         let mut number = 'i';
         let mut index = 0;
+        let mut currency = None;
 
         while token != Token::EOF && token != Token::Separator {
             let next_token = self.lexer.next_token();
@@ -170,6 +172,9 @@ impl Parser {
                 Token::Condition(cmp, value) => {
                     condition = Some((cmp, value));
                 }
+                Token::Currency(c) => {
+                    currency = Some(c);
+                }
                 Token::QuestionMark => {
                     tokens.push(TextToken::Digit(Digit {
                         kind: '?',
@@ -291,6 +296,7 @@ impl Parser {
                 is_scientific,
                 scientific_minus,
                 exponent_digit_count,
+                currency,
             })
         }
     }

base/src/formatter/test/test_general.rs

@@ -76,6 +76,14 @@ fn test_color() {
     assert_eq!(format_number(3.1, "[blue]0.00", locale).color, Some(4));
 }
 
+#[test]
+fn dollar_euro() {
+    let locale = get_default_locale();
+    let format = "[$€]#,##0.00";
+    let t = format_number(3.1, format, locale);
+    assert_eq!(t.text, "€3.10");
+}
+
 #[test]
 fn test_parts() {
     let locale = get_default_locale();

base/src/functions/financial.rs

@@ -89,6 +89,9 @@ fn compute_future_value(
     if rate == 0.0 {
         return Ok(-pv - pmt * nper);
     }
+    if rate == -1.0 && nper < 0.0 {
+        return Err((Error::DIV, "Divide by zero".to_string()));
+    }
 
     let rate_nper = (1.0 + rate).powf(nper);
     let fv = if period_start {

base/src/functions/logical.rs

@@ -136,6 +136,9 @@ impl Model {
     }
 
     pub(crate) fn fn_or(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.is_empty() {
+            return CalcResult::new_args_number_error(cell);
+        }
         let mut result = false;
         for arg in args {
             match self.evaluate_node_in_context(arg, cell) {

base/src/functions/mod.rs

@@ -140,6 +140,7 @@ pub enum Function {
     Countifs,
     Maxifs,
     Minifs,
+    Geomean,
 
     // Date and time
     Date,
@@ -248,7 +249,7 @@ pub enum Function {
 }
 
 impl Function {
-    pub fn into_iter() -> IntoIter<Function, 194> {
+    pub fn into_iter() -> IntoIter<Function, 195> {
         [
             Function::And,
             Function::False,
@@ -348,6 +349,7 @@ impl Function {
             Function::Countifs,
             Function::Maxifs,
             Function::Minifs,
+            Function::Geomean,
             Function::Year,
             Function::Day,
             Function::Month,
@@ -611,6 +613,7 @@ impl Function {
             "COUNTIFS" => Some(Function::Countifs),
             "MAXIFS" | "_XLFN.MAXIFS" => Some(Function::Maxifs),
             "MINIFS" | "_XLFN.MINIFS" => Some(Function::Minifs),
+            "GEOMEAN" => Some(Function::Geomean),
             // Date and Time
             "YEAR" => Some(Function::Year),
             "DAY" => Some(Function::Day),
@@ -818,6 +821,7 @@ impl fmt::Display for Function {
             Function::Countifs => write!(f, "COUNTIFS"),
             Function::Maxifs => write!(f, "MAXIFS"),
             Function::Minifs => write!(f, "MINIFS"),
+            Function::Geomean => write!(f, "GEOMEAN"),
             Function::Year => write!(f, "YEAR"),
             Function::Day => write!(f, "DAY"),
             Function::Month => write!(f, "MONTH"),
@@ -1054,6 +1058,7 @@ impl Model {
             Function::Countifs => self.fn_countifs(args, cell),
             Function::Maxifs => self.fn_maxifs(args, cell),
             Function::Minifs => self.fn_minifs(args, cell),
+            Function::Geomean => self.fn_geomean(args, cell),
             // Date and Time
             Function::Year => self.fn_year(args, cell),
             Function::Day => self.fn_day(args, cell),

base/src/functions/statistical.rs

@@ -635,4 +635,85 @@ impl Model {
         }
         CalcResult::Number(max)
     }
+
+    pub(crate) fn fn_geomean(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.is_empty() {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let mut count = 0.0;
+        let mut product = 1.0;
+        for arg in args {
+            match self.evaluate_node_in_context(arg, cell) {
+                CalcResult::Number(value) => {
+                    count += 1.0;
+                    product *= value;
+                }
+                CalcResult::Boolean(b) => {
+                    if let Node::ReferenceKind { .. } = arg {
+                    } else {
+                        product *= if b { 1.0 } else { 0.0 };
+                        count += 1.0;
+                    }
+                }
+                CalcResult::Range { left, right } => {
+                    if left.sheet != right.sheet {
+                        return CalcResult::new_error(
+                            Error::VALUE,
+                            cell,
+                            "Ranges are in different sheets".to_string(),
+                        );
+                    }
+                    for row in left.row..(right.row + 1) {
+                        for column in left.column..(right.column + 1) {
+                            match self.evaluate_cell(CellReferenceIndex {
+                                sheet: left.sheet,
+                                row,
+                                column,
+                            }) {
+                                CalcResult::Number(value) => {
+                                    count += 1.0;
+                                    product *= value;
+                                }
+                                error @ CalcResult::Error { .. } => return error,
+                                CalcResult::Range { .. } => {
+                                    return CalcResult::new_error(
+                                        Error::ERROR,
+                                        cell,
+                                        "Unexpected Range".to_string(),
+                                    );
+                                }
+                                _ => {}
+                            }
+                        }
+                    }
+                }
+                error @ CalcResult::Error { .. } => return error,
+                CalcResult::String(s) => {
+                    if let Node::ReferenceKind { .. } = arg {
+                        // Do nothing
+                    } else if let Ok(t) = s.parse::<f64>() {
+                        product *= t;
+                        count += 1.0;
+                    } else {
+                        return CalcResult::Error {
+                            error: Error::VALUE,
+                            origin: cell,
+                            message: "Argument cannot be cast into number".to_string(),
+                        };
+                    }
+                }
+                _ => {
+                    // Ignore everything else
+                }
+            };
+        }
+        if count == 0.0 {
+            return CalcResult::Error {
+                error: Error::DIV,
+                origin: cell,
+                message: "Division by Zero".to_string(),
+            };
+        }
+        CalcResult::Number(product.powf(1.0 / count))
+    }
 }

base/src/model.rs

@@ -15,7 +15,7 @@ use crate::{
         },
         token::{get_error_by_name, Error, OpCompare, OpProduct, OpSum, OpUnary},
         types::*,
-        utils::{self, is_valid_column_number, is_valid_row, parse_reference_a1},
+        utils::{self, is_valid_column_number, is_valid_row},
     },
     formatter::{
         format::{format_number, parse_formatted_number},
@@ -747,29 +747,6 @@ impl Model {
         self.workbook.worksheet(sheet)?.is_empty_cell(row, column)
     }
 
-    /// Returns 'true' if the cell belongs to any Merged cells
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use ironcalc_base::Model;
-    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// let mut model = Model::new_empty("model", "en", "UTC")?;
-    /// model.merge_cells(0, "A1:D5");
-    /// assert_eq!(model.is_part_of_merged_cells(0, 1, 2)?, true);
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn is_part_of_merged_cells(
-        &self,
-        sheet: u32,
-        row: i32,
-        column: i32,
-    ) -> Result<bool, String> {
-        self.workbook
-            .worksheet(sheet)?
-            .is_part_of_merged_cells(row, column)
-    }
-
     pub(crate) fn evaluate_cell(&mut self, cell_reference: CellReferenceIndex) -> CalcResult {
         let row_data = match self.workbook.worksheets[cell_reference.sheet as usize]
             .sheet_data
@@ -1248,14 +1225,6 @@ impl Model {
         column: i32,
         value: &str,
     ) -> Result<(), String> {
-        // Checking first whether cell we are updating is part of Merged cells
-        // if so returning with Err
-        if self.is_part_of_merged_cells(sheet, row, column)? {
-            return Err(format!(
-                "Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
-                row, column
-            ));
-        }
         let style_index = self.get_cell_style_index(sheet, row, column)?;
         let new_style_index;
         if common::value_needs_quoting(value, &self.language) {
@@ -1306,15 +1275,6 @@ impl Model {
         column: i32,
         value: bool,
     ) -> Result<(), String> {
-        // Checking first whether cell we are updating is part of Merged cells
-        // if so returning with Err
-        if self.is_part_of_merged_cells(sheet, row, column)? {
-            return Err(format!(
-                "Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
-                row, column
-            ));
-        }
-
         let style_index = self.get_cell_style_index(sheet, row, column)?;
         let new_style_index = if self.workbook.styles.style_is_quote_prefix(style_index) {
             self.workbook
@@ -1357,14 +1317,6 @@ impl Model {
         column: i32,
         value: f64,
     ) -> Result<(), String> {
-        // Checking first whether cell we are updating is part of Merged cells
-        // if so returning with Err
-        if self.is_part_of_merged_cells(sheet, row, column)? {
-            return Err(format!(
-                "Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
-                row, column
-            ));
-        }
         let style_index = self.get_cell_style_index(sheet, row, column)?;
         let new_style_index = if self.workbook.styles.style_is_quote_prefix(style_index) {
             self.workbook
@@ -1410,12 +1362,6 @@ impl Model {
         column: i32,
         formula: String,
     ) -> Result<(), String> {
-        if self.is_part_of_merged_cells(sheet, row, column)? {
-            return Err(format!(
-                "Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
-                row, column
-            ));
-        }
         let mut style_index = self.get_cell_style_index(sheet, row, column)?;
         if self.workbook.styles.style_is_quote_prefix(style_index) {
             style_index = self
@@ -1468,14 +1414,6 @@ impl Model {
         column: i32,
         value: String,
     ) -> Result<(), String> {
-        // Checking first whether cell we are updating is part of Merged cells
-        // if so returning with Err
-        if self.is_part_of_merged_cells(sheet, row, column)? {
-            return Err(format!(
-                "Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
-                row, column
-            ));
-        }
         // If value starts with "'" then we force the style to be quote_prefix
         let style_index = self.get_cell_style_index(sheet, row, column)?;
         if let Some(new_value) = value.strip_prefix('\'') {
@@ -1990,7 +1928,6 @@ impl Model {
     /// Sets the number of frozen rows to `frozen_rows` in the workbook.
     /// Fails if `frozen`_rows` is either too small (<0) or too large (>LAST_ROW)`
     pub fn set_frozen_rows(&mut self, sheet: u32, frozen_rows: i32) -> Result<(), String> {
-        // TODO: What is frozen rows and do we need to take of this if row we are frozing is part of merge cells ?
         if let Some(worksheet) = self.workbook.worksheets.get_mut(sheet as usize) {
             if frozen_rows < 0 {
                 return Err("Frozen rows cannot be negative".to_string());
@@ -2008,7 +1945,6 @@ impl Model {
     /// Sets the number of frozen columns to `frozen_column` in the workbook.
     /// Fails if `frozen`_columns` is either too small (<0) or too large (>LAST_COLUMN)`
     pub fn set_frozen_columns(&mut self, sheet: u32, frozen_columns: i32) -> Result<(), String> {
-        // TODO: What is frozen columns and do we need to take of this if column we are frozing is part of merge cells ?
         if let Some(worksheet) = self.workbook.worksheets.get_mut(sheet as usize) {
             if frozen_columns < 0 {
                 return Err("Frozen columns cannot be negative".to_string());
@@ -2050,164 +1986,6 @@ impl Model {
             .worksheet_mut(sheet)?
             .set_row_height(column, height)
     }
-
-    fn parse_merged_range(&mut self, range: &str) -> Result<(i32, i32, i32, i32), String> {
-        let parts: Vec<&str> = range.split(':').collect();
-        if parts.len() == 1 {
-            Err(format!("Invalid range: '{}'", range))
-        } else if parts.len() == 2 {
-            match (parse_reference_a1(parts[0]), parse_reference_a1(parts[1])) {
-                (Some(left), Some(right)) => {
-                    return Ok((left.row, left.column, right.row, right.column));
-                }
-                _ => return Err(format!("Invalid range: '{}'", range)),
-            }
-        } else {
-            return Err(format!("Invalid range: '{}'", range));
-        }
-    }
-
-    // Implementing public APIS related to Merge cells handling
-
-    /// Merges given selected cells
-    /// If no overlap, it will create that merged cells with left most top cell value representing the whole merged cells
-    /// If new merge cells creation overlaps with any of the existing merged cells, Overlapped merged cells gets unmerged
-    /// and new merge cells gets added
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use ironcalc_base::Model;
-    /// # use ironcalc_base::cell::CellValue;
-    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// let mut model = Model::new_empty("model", "en", "UTC")?;
-    /// model.merge_cells(0, "D4:F6").unwrap();
-    /// model.merge_cells(0, "A1:B4").unwrap();
-    /// assert_eq!(model.workbook.worksheet(0).unwrap().merged_cells_list.len(), 2);
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// See also:
-    /// * [Model::update_cell_with_formula()]
-    /// * [Model::update_cell_with_number()]
-    /// * [Model::update_cell_with_bool()]
-    /// * [Model::update_cell_with_text()]
-    pub fn merge_cells(&mut self, sheet: u32, range_ref: &str) -> Result<(), String> {
-        match self.parse_merged_range(range_ref) {
-            Ok(parsed_merge_cell_range) => {
-                // ATTENTION 2: Below thing we can support here but keeping it simple
-                // Web or different client needs to keep this in mind
-                // User can give errored parse ranges like C3:A1
-                // Where col_start and row_start and is greated then col_end and row_end
-                // Return error in these scenario
-                if parsed_merge_cell_range.0 > parsed_merge_cell_range.2
-                    || parsed_merge_cell_range.1 > parsed_merge_cell_range.3
-                {
-                    return Err(
-                        "Invalid parse range. Merge Mother cell always be top left cell"
-                            .to_string(),
-                    );
-                }
-
-                let mut merged_cells_overlaped_list: Vec<bool> = Vec::new();
-                // checking whether our new range overlaps with any of the already existing merged cells
-                // if so, need to unmerge those and create this new one
-                {
-                    let worksheet = self.workbook.worksheet(sheet)?;
-                    let merged_cells = worksheet.get_merged_cells_list();
-
-                    for merge_node in merged_cells {
-                        // checking whether any overlapping exist with this merge cell
-                        if !(parsed_merge_cell_range.1 > merge_node.3
-                            || parsed_merge_cell_range.3 < merge_node.1
-                            || parsed_merge_cell_range.0 > merge_node.2
-                            || parsed_merge_cell_range.2 < merge_node.0)
-                        {
-                            // overlap has happened
-                            merged_cells_overlaped_list.push(true);
-                        } else {
-                            merged_cells_overlaped_list.push(false);
-                        }
-                    }
-                }
-
-                if !merged_cells_overlaped_list.is_empty() {
-                    // Lets take Mutable ref to Merge cell and deletes all those nodes which has overlapped
-                    let worksheet = self.workbook.worksheet_mut(sheet)?;
-                    let merged_cells_list_mut = worksheet.get_merged_cells_list_mut();
-                    let mut merged_cells_overlaped_list_iter = merged_cells_overlaped_list.iter();
-                    merged_cells_list_mut
-                        .retain(|_| !(*merged_cells_overlaped_list_iter.next().unwrap()))
-                }
-
-                // Now need to update (n*m - 1) cells with empty cell ( except the Mother cell )
-                for row_index in parsed_merge_cell_range.0..=parsed_merge_cell_range.2 {
-                    for col_index in parsed_merge_cell_range.1..=parsed_merge_cell_range.3 {
-                        // skip Mother cell
-                        if row_index == parsed_merge_cell_range.0
-                            && col_index == parsed_merge_cell_range.2
-                        {
-                            continue;
-                        }
-
-                        //update the node with empty cell
-                        {
-                            self.workbook.worksheet_mut(sheet)?.update_cell(
-                                row_index,
-                                col_index,
-                                Cell::EmptyCell { s: 0 },
-                            )?;
-                        }
-                    }
-                }
-
-                let new_merged_cells = MergedCells::new(parsed_merge_cell_range);
-                {
-                    self.workbook
-                        .worksheet_mut(sheet)?
-                        .merged_cells_list
-                        .push(new_merged_cells);
-                }
-            }
-            Err(err) => {
-                return Err(err);
-            }
-        }
-        Ok(())
-    }
-
-    /// Unmerges a given/selected merged cells
-    /// Once unmerged, only top most left corner value gets retained and all the others will have empty cell
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use ironcalc_base::Model;
-    /// # use ironcalc_base::cell::CellValue;
-    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// let mut model = Model::new_empty("model", "en", "UTC")?;
-    /// model.merge_cells(0, "D4:F6");
-    /// model.unmerge_cells(0, "D4:F6");
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn unmerge_cells(&mut self, sheet: u32, range_ref: &str) -> Result<(), String> {
-        let worksheet = self.workbook.worksheet(sheet)?;
-        let merged_cells = worksheet.get_merged_cells_list();
-        for (index, merge_node) in merged_cells.iter().enumerate() {
-            let merge_block_range_ref = merge_node.get_merged_cells_str_ref()?;
-            // finding the merge cell node to be deleted
-            if merge_block_range_ref.as_str() == range_ref {
-                // Merge cell to be deleted is found
-                self.workbook
-                    .worksheet_mut(sheet)?
-                    .merged_cells_list
-                    .remove(index);
-                return Ok(());
-            }
-        }
-        Err("Invalid merge_cell_ref, Merged cells to be deleted is not found".to_string())
-    }
 }
 
 #[cfg(test)]

base/src/new_empty.rs

@@ -4,7 +4,7 @@ use std::collections::HashMap;
 
 use crate::{
     calc_result::Range,
-    constants::{DEFAULT_WINDOW_HEIGH, DEFAULT_WINDOW_WIDTH},
+    constants::{DEFAULT_WINDOW_HEIGHT, DEFAULT_WINDOW_WIDTH},
     expressions::{
         lexer::LexerMode,
         parser::{
@@ -57,7 +57,7 @@ impl Model {
             rows: vec![],
             comments: vec![],
             dimension: "A1".to_string(),
-            merged_cells_list: vec![],
+            merge_cells: vec![],
             name: name.to_string(),
             shared_formulas: vec![],
             sheet_data: Default::default(),
@@ -68,6 +68,7 @@ impl Model {
             frozen_rows: 0,
             show_grid_lines: true,
             views,
+            conditional_formatting: vec![]
         }
     }
 
@@ -359,7 +360,7 @@ impl Model {
             WorkbookView {
                 sheet: 0,
                 window_width: DEFAULT_WINDOW_WIDTH,
-                window_height: DEFAULT_WINDOW_HEIGH,
+                window_height: DEFAULT_WINDOW_HEIGHT,
             },
         );
 

base/src/styles.rs

@@ -223,14 +223,6 @@ impl Model {
         column: i32,
         style: &Style,
     ) -> Result<(), String> {
-        // Checking first whether cell we are updating is part of Merged cells
-        // if so returning with Err
-        if self.is_part_of_merged_cells(sheet, row, column)? {
-            return Err(format!(
-                "Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
-                row, column
-            ));
-        }
         let style_index = self.workbook.styles.get_style_index_or_create(style);
         self.workbook
             .worksheet_mut(sheet)?
@@ -260,14 +252,6 @@ impl Model {
         column: i32,
         style_name: &str,
     ) -> Result<(), String> {
-        // Checking first whether cell we are updating is part of Merged cells
-        // if so returning with Err
-        if self.is_part_of_merged_cells(sheet, row, column)? {
-            return Err(format!(
-                "Cell row : {}, col : {} is part of merged cells block, so singular update to the cell is not possible",
-                row, column
-            ));
-        }
         let style_index = self.workbook.styles.get_style_index_by_name(style_name)?;
         self.workbook
             .worksheet_mut(sheet)?

base/src/test/mod.rs

@@ -46,14 +46,17 @@ pub(crate) mod util;
 
 mod engineering;
 mod test_fn_offset;
+mod test_fn_or;
 mod test_number_format;
 
 mod test_escape_quotes;
 mod test_extend;
+mod test_fn_fv;
 mod test_fn_type;
 mod test_frozen_rows_and_columns;
+mod test_geomean;
 mod test_get_cell_content;
-mod test_model_merge_cell_fns;
+mod test_issue_155;
 mod test_percentage;
 mod test_set_functions_error_handling;
 mod test_today;

base/src/test/test_column_width.rs

@@ -82,3 +82,21 @@ fn test_column_width_higher_edge() {
     assert!((worksheet.get_column_width(17).unwrap() - DEFAULT_COLUMN_WIDTH).abs() < f64::EPSILON);
     assert_eq!(model.get_cell_style_index(0, 23, 16), Ok(1));
 }
+
+#[test]
+fn test_column_width_negative() {
+    let mut model = new_empty_model();
+    let result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_column_width(16, -1.0);
+    assert_eq!(result, Err("Can not set a negative width: -1".to_string()));
+    assert_eq!(model.workbook.worksheets[0].cols.len(), 0);
+    let worksheet = model.workbook.worksheet(0).unwrap();
+    assert_eq!(
+        (worksheet.get_column_width(16).unwrap()),
+        DEFAULT_COLUMN_WIDTH
+    );
+    assert_eq!(model.get_cell_style_index(0, 23, 16), Ok(0));
+}

base/src/test/test_fn_formulatext.rs

@@ -2,9 +2,6 @@
 
 use crate::test::util::new_empty_model;
 
-#[test]
-fn simple_cases() {}
-
 #[test]
 fn wrong_number_of_arguments() {
     let mut model = new_empty_model();

base/src/test/test_fn_fv.rs

@@ -0,0 +1,36 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn computation() {
+    let i2 = "=-C2*(1+D2)^E2-F2*((D2+1)*((1+D2)^E2-1))/D2";
+
+    let mut model = new_empty_model();
+    model._set("C2", "1");
+    model._set("D2", "2");
+    model._set("E2", "3");
+    model._set("F2", "4");
+
+    model._set("I2", i2);
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("I2"), "-183");
+    assert_eq!(model._get_formula("I2"), i2);
+}
+
+#[test]
+fn format_as_currency() {
+    let mut model = new_empty_model();
+    model._set("C2", "1");
+    model._set("D2", "2");
+    model._set("E2", "3");
+    model._set("F2", "4");
+
+    model._set("I2", "=FV(D2,E2,F2,C2,1)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("I2"), "-$183.00");
+}

base/src/test/test_fn_or.rs

@@ -0,0 +1,36 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn fn_or() {
+    let mut model = new_empty_model();
+    model._set("A1", "=OR(1, 0)");
+    model._set("A2", "=OR(0, 0)");
+    model._set("A3", "=OR(true, false)");
+    model._set("A4", "=OR(false, false)");
+
+    model.evaluate();
+    assert_eq!(model._get_text("A1"), *"TRUE");
+    assert_eq!(model._get_text("A2"), *"FALSE");
+    assert_eq!(model._get_text("A3"), *"TRUE");
+    assert_eq!(model._get_text("A4"), *"FALSE");
+}
+
+#[test]
+fn fn_or_no_arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=OR()");
+    model.evaluate();
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+}
+
+#[test]
+fn fn_or_missing_arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=OR(,)");
+    model._set("A2", "=OR(,1)");
+    model.evaluate();
+    assert_eq!(model._get_text("A1"), *"FALSE");
+    assert_eq!(model._get_text("A2"), *"TRUE");
+}

base/src/test/test_general.rs

@@ -1,5 +1,7 @@
 #![allow(clippy::unwrap_used)]
 
+use crate::constants::DEFAULT_ROW_HEIGHT;
+
 use crate::cell::CellValue;
 
 use crate::number_format::to_excel_precision_str;
@@ -113,6 +115,15 @@ fn test_set_row_height() {
     worksheet.set_row_height(5, 5.0).unwrap();
     let worksheet = model.workbook.worksheet(0).unwrap();
     assert!((5.0 - worksheet.row_height(5).unwrap()).abs() < f64::EPSILON);
+
+    let worksheet = model.workbook.worksheet_mut(0).unwrap();
+    let result = worksheet.set_row_height(6, -1.0);
+    assert_eq!(result, Err("Can not set a negative height: -1".to_string()));
+
+    assert_eq!(worksheet.row_height(6).unwrap(), DEFAULT_ROW_HEIGHT);
+
+    worksheet.set_row_height(6, 0.0).unwrap();
+    assert_eq!(worksheet.row_height(6).unwrap(), 0.0);
 }
 
 #[test]

base/src/test/test_geomean.rs

@@ -0,0 +1,27 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn test_fn_geomean_arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=GEOMEAN()");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+}
+
+#[test]
+fn test_fn_geomean_minimal() {
+    let mut model = new_empty_model();
+    model._set("B1", "1");
+    model._set("B2", "2");
+    model._set("B3", "3");
+    model._set("B4", "'2");
+    // B5 is empty
+    model._set("B6", "true");
+    model._set("A1", "=GEOMEAN(B1:B6)");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"1.817120593");
+}

base/src/test/test_issue_155.rs

@@ -0,0 +1,14 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn issue_155() {
+    let mut model = new_empty_model();
+    model._set("A1", "1");
+    model._set("A2", "2");
+    model._set("B2", "=A$1:A2");
+    model.evaluate();
+
+    assert_eq!(model._get_formula("B2"), "=A$1:A2".to_string());
+}

base/src/test/test_model_merge_cell_fns.rs

@@ -1,155 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::{test::util::new_empty_model, types::CellType};
-
-#[test]
-fn test_model_set_fns_related_to_merge_cells() {
-    let mut model = new_empty_model();
-
-    // creating a merge cell of D1:F2
-    model.merge_cells(0, "D1:F2").unwrap();
-
-    // Updating the mother cell of Merge cells and expecting the update to go through
-    model.set_user_input(0, 1, 4, "Hello".to_string()).unwrap();
-    assert_eq!(model.get_cell_content(0, 1, 4).unwrap(), "Hello");
-    assert_eq!(model.get_cell_type(0, 1, 4).unwrap(), CellType::Text);
-
-    // Updating cell which is not in Merge cell block
-    assert_eq!(model.set_user_input(0, 1, 3, "Hello".to_string()), Ok(()));
-    assert_eq!(model.get_cell_content(0, 1, 3), Ok("Hello".to_string()));
-    assert_eq!(model.get_cell_type(0, 1, 3), Ok(CellType::Text));
-
-    // 1: testing with set_user_input()
-    assert_eq!(
-        model
-            .set_user_input(0, 1, 5, "Hello".to_string()),
-        Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
-    );
-    assert_eq!(model.get_cell_content(0, 1, 5), Ok("".to_string()));
-    assert_eq!(model.get_cell_type(0, 1, 5), Ok(CellType::Number));
-
-    // 2: testing with update_cell_with_bool()
-    assert_eq!(
-        model
-            .update_cell_with_bool(0, 1, 5, true),
-        Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
-    );
-    assert_eq!(model.get_cell_content(0, 1, 5), Ok("".to_string()));
-    assert_eq!(model.get_cell_type(0, 1, 5), Ok(CellType::Number));
-
-    // 3: testing with update_cell_with_formula()
-    assert_eq!(
-        model
-            .update_cell_with_formula(0, 1, 5, "=SUM(A1+A2)".to_string()),
-        Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
-    );
-    assert_eq!(model.get_cell_type(0, 1, 5), Ok(CellType::Number));
-
-    // 4: testing with update_cell_with_number()
-    assert_eq!(
-        model
-            .update_cell_with_number(0, 1, 5, 10.0),
-        Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
-    );
-    assert_eq!(model.get_cell_content(0, 1, 5), Ok("".to_string()));
-    assert_eq!(model.get_cell_type(0, 1, 5), Ok(CellType::Number));
-
-    // 5: testing with update_cell_with_text()
-    assert_eq!(
-        model
-            .update_cell_with_text(0, 1, 5, "new text"),
-        Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
-    );
-    assert_eq!(model.get_cell_content(0, 1, 5), Ok("".to_string()));
-    assert_eq!(model.get_cell_type(0, 1, 5), Ok(CellType::Number));
-}
-
-#[test]
-fn test_model_merge_cells_crud_api() {
-    let mut model = new_empty_model();
-
-    // creating a merge cell of D4:F6
-    model.merge_cells(0, "D4:F6").unwrap();
-    model
-        .set_user_input(0, 4, 4, "Merge Block".to_string())
-        .unwrap();
-    // CRUD APIS testing on Merge Cells
-
-    // Case1: Creating a new merge cell without overlapping
-    // Newly created Merge block is left to D4:F6
-    assert_eq!(model.merge_cells(0, "A1:B4"), Ok(()));
-    assert_eq!(
-        model.workbook.worksheet(0).unwrap().merged_cells_list.len(),
-        2
-    );
-    model.set_user_input(0, 1, 1, "left".to_string()).unwrap();
-
-    // Newly created Merge block is right to D4:F6
-    assert_eq!(model.merge_cells(0, "G1:H7"), Ok(()));
-    assert_eq!(
-        model.workbook.worksheet(0).unwrap().merged_cells_list.len(),
-        3
-    );
-    model.set_user_input(0, 1, 7, "right".to_string()).unwrap();
-
-    // Newly created Merge block is above to D4:F6
-    assert_eq!(model.merge_cells(0, "C1:D3"), Ok(()));
-    assert_eq!(
-        model.workbook.worksheet(0).unwrap().merged_cells_list.len(),
-        4
-    );
-    model.set_user_input(0, 1, 3, "top".to_string()).unwrap();
-
-    // Newly created Merge block is down to D4:F6
-    assert_eq!(model.merge_cells(0, "D8:E9"), Ok(()));
-    assert_eq!(
-        model.workbook.worksheet(0).unwrap().merged_cells_list.len(),
-        5
-    );
-    model.set_user_input(0, 8, 4, "down".to_string()).unwrap();
-
-    // Case2: Creating a new merge cell with overlapping with other 3 merged cell
-    assert_eq!(model.merge_cells(0, "C1:G4"), Ok(()));
-    assert_eq!(
-        model.workbook.worksheet(0).unwrap().merged_cells_list.len(),
-        3
-    );
-    model
-        .set_user_input(0, 1, 3, "overlapped_new_merge_block".to_string())
-        .unwrap();
-
-    // Case3: Giving wrong parsing range
-    assert_eq!(
-        model.merge_cells(0, "C3:A1"),
-        Err("Invalid parse range. Merge Mother cell always be top left cell".to_string())
-    );
-    assert_eq!(
-        model.merge_cells(0, "CA:A1"),
-        Err("Invalid range: 'CA:A1'".to_string())
-    );
-    assert_eq!(
-        model.merge_cells(0, "C0:A1"),
-        Err("Invalid range: 'C0:A1'".to_string())
-    );
-    assert_eq!(
-        model.merge_cells(0, "C1:A0"),
-        Err("Invalid range: 'C1:A0'".to_string())
-    );
-    assert_eq!(
-        model.merge_cells(0, "C1"),
-        Err("Invalid range: 'C1'".to_string())
-    );
-    assert_eq!(
-        model.merge_cells(0, "C1:A1:B1"),
-        Err("Invalid range: 'C1:A1:B1'".to_string())
-    );
-
-    // Case3: Giving wrong merge_ref, which would resulting in error (Merge cell to be deleted is not found)
-    assert_eq!(
-        model.unmerge_cells(0, "C1:E1"),
-        Err("Invalid merge_cell_ref, Merged cells to be deleted is not found".to_string())
-    );
-
-    // Case4: unmerge scenario
-    assert_eq!(model.unmerge_cells(0, "C1:G4"), Ok(()));
-}

base/src/test/test_styles.rs

@@ -62,45 +62,3 @@ fn test_create_named_style() {
     let style = model.get_style_for_cell(0, 1, 1).unwrap();
     assert!(style.font.b);
 }
-
-#[test]
-fn test_model_style_set_fns_in_merge_cell_context() {
-    let mut model = new_empty_model();
-
-    // creating a merge cell of D1:F2
-    model.merge_cells(0, "D1:F2").unwrap();
-    model.set_user_input(0, 1, 4, "Hello".to_string()).unwrap();
-
-    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
-    assert!(!style.font.b);
-    style.font.b = true;
-
-    // Updating the mother cell of Merge cells and expecting the update to go through
-    // This should make the text "Hello" in bold format
-    assert_eq!(model.set_cell_style(0, 1, 4, &style), Ok(()));
-
-    // 1: testing with set_cell_style()
-    let original_style: Style = model.get_style_for_cell(0, 1, 5).unwrap();
-    assert_eq!(
-        model
-            .set_cell_style(0, 1, 5, &style),
-        Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
-    );
-    assert_eq!(model.get_style_for_cell(0, 1, 5), Ok(original_style));
-
-    // 2: testing with set_cell_style_by_name
-    let mut style = model.get_style_for_cell(0, 1, 4).unwrap();
-    style.font.b = true;
-    assert_eq!(
-        model.workbook.styles.create_named_style("bold", &style),
-        Ok(())
-    );
-
-    let original_style: Style = model.get_style_for_cell(0, 1, 5).unwrap();
-    assert_eq!(
-        model
-            .set_cell_style_by_name(0, 1, 5, "bold"),
-        Err("Cell row : 1, col : 5 is part of merged cells block, so singular update to the cell is not possible".to_string())
-    );
-    assert_eq!(model.get_style_for_cell(0, 1, 5), Ok(original_style));
-}

base/src/test/test_worksheet.rs

@@ -283,87 +283,3 @@ fn test_worksheet_navigate_to_edge_in_direction() {
     assert_eq!(navigate(8, 3, NavigationDirection::Up), (6, 3));
     assert_eq!(navigate(9, 3, NavigationDirection::Up), (6, 3));
 }
-
-// Tests Merge cells related functions of worksheet
-
-#[test]
-fn test_merge_cell_fns_worksheet() {
-    let mut model = new_empty_model();
-
-    // Adding one Merge cell
-    model.merge_cells(0, "D1:E3").unwrap();
-
-    // Lets check whether D1 (Mother Merge cell) is part of Merge block or not
-    // It should not be considered as part of Merge cell
-    assert!(!model
-        .workbook
-        .worksheet(0)
-        .unwrap()
-        .is_part_of_merged_cells(1, 4)
-        .unwrap(),);
-
-    // Lets give cell which is actually part of Merge block and expect true from fn
-    assert!(model
-        .workbook
-        .worksheet(0)
-        .unwrap()
-        .is_part_of_merged_cells(2, 4)
-        .unwrap());
-
-    // Lets give cell which is not a part of Merge block and expect false from fn
-    assert!(!model
-        .workbook
-        .worksheet(0)
-        .unwrap()
-        .is_part_of_merged_cells(2, 6)
-        .unwrap());
-
-    // Lets give an Invalid row
-    assert_eq!(
-        model
-            .workbook
-            .worksheet(0)
-            .unwrap()
-            .is_part_of_merged_cells(0, 1),
-        Err("Incorrect row or column".to_string())
-    );
-
-    //Lets give Invalid column
-    assert_eq!(
-        model
-            .workbook
-            .worksheet(0)
-            .unwrap()
-            .is_part_of_merged_cells(1, 0),
-        Err("Incorrect row or column".to_string())
-    );
-
-    // Verifying get fns of worksheet
-    assert_eq!(
-        model
-            .workbook
-            .worksheet(0)
-            .unwrap()
-            .get_merged_cells_list()
-            .len(),
-        1
-    );
-    {
-        let merge_cell_vec = model
-            .workbook
-            .worksheet_mut(0)
-            .unwrap()
-            .get_merged_cells_list_mut();
-        merge_cell_vec.remove(0);
-
-        assert_eq!(
-            model
-                .workbook
-                .worksheet(0)
-                .unwrap()
-                .get_merged_cells_list()
-                .len(),
-            0
-        );
-    }
-}

base/src/test/user_model/test_keyboard_navigation.rs

@@ -2,7 +2,7 @@
 
 use crate::{
     constants::{
-        DEFAULT_COLUMN_WIDTH, DEFAULT_ROW_HEIGHT, DEFAULT_WINDOW_HEIGH, DEFAULT_WINDOW_WIDTH,
+        DEFAULT_COLUMN_WIDTH, DEFAULT_ROW_HEIGHT, DEFAULT_WINDOW_HEIGHT, DEFAULT_WINDOW_WIDTH,
         LAST_COLUMN,
     },
     test::util::new_empty_model,
@@ -87,7 +87,7 @@ fn last_colum() {
 fn page_down() {
     let model = new_empty_model();
     let mut model = UserModel::from_model(model);
-    let window_height = DEFAULT_WINDOW_HEIGH as f64;
+    let window_height = DEFAULT_WINDOW_HEIGHT as f64;
     let row_height = DEFAULT_ROW_HEIGHT;
     let row_count = f64::floor(window_height / row_height) as i32;
     model.on_page_down().unwrap();

base/src/test/user_model/test_window_size.rs

@@ -1,7 +1,7 @@
 #![allow(clippy::unwrap_used)]
 
 use crate::{
-    constants::{DEFAULT_ROW_HEIGHT, DEFAULT_WINDOW_HEIGH, DEFAULT_WINDOW_WIDTH},
+    constants::{DEFAULT_ROW_HEIGHT, DEFAULT_WINDOW_HEIGHT, DEFAULT_WINDOW_WIDTH},
     test::util::new_empty_model,
     UserModel,
 };
@@ -11,7 +11,7 @@ fn basic_test() {
     let model = new_empty_model();
     let mut model = UserModel::from_model(model);
     let window_height = model.get_window_height().unwrap();
-    assert_eq!(window_height, DEFAULT_WINDOW_HEIGH);
+    assert_eq!(window_height, DEFAULT_WINDOW_HEIGHT);
 
     let window_width = model.get_window_width().unwrap();
     assert_eq!(window_width, DEFAULT_WINDOW_WIDTH);

base/src/types.rs

@@ -3,7 +3,6 @@ use serde::{Deserialize, Serialize};
 use std::{collections::HashMap, fmt::Display};
 
 use crate::expressions::token::Error;
-use crate::expressions::utils::number_to_column;
 
 fn default_as_false() -> bool {
     false
@@ -36,7 +35,7 @@ pub struct WorkbookView {
     pub sheet: u32,
     /// The current width of the window
     pub window_width: i64,
-    /// The current heigh of the window
+    /// The current height of the window
     pub window_height: i64,
 }
 
@@ -111,13 +110,33 @@ pub struct Worksheet {
     pub sheet_id: u32,
     pub state: SheetState,
     pub color: Option<String>,
-    pub merged_cells_list: Vec<MergedCells>,
+    pub merge_cells: Vec<String>,
     pub comments: Vec<Comment>,
     pub frozen_rows: i32,
     pub frozen_columns: i32,
     pub views: HashMap<u32, WorksheetView>,
     /// Whether or not to show the grid lines in the worksheet
     pub show_grid_lines: bool,
+    pub conditional_formatting: Vec<ConditionalFormatting>
+}
+
+#[derive(Encode, Decode, Debug, PartialEq, Clone)]
+pub struct ColorScale {
+
+}
+
+#[derive(Encode, Decode, Debug, PartialEq, Clone)]
+pub enum CfRule {
+    ColorScale {
+        priority: u32,
+    },
+    CellIs,
+}
+
+#[derive(Encode, Decode, Debug, PartialEq, Clone)]
+pub struct ConditionalFormatting {
+    sqref: String,
+    cf_rule: Vec<CfRule>
 }
 
 /// Internal representation of Excel's sheet_data
@@ -352,43 +371,6 @@ pub enum FontScheme {
     None,
 }
 
-// MergedCells type
-// There will be one MergedCells struct maintained for every Merged cells that we load
-// merge_cell_range : Its tuple having [row_start, column_start, row_end, column_end]
-#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
-pub struct MergedCells(pub i32, pub i32, pub i32, pub i32);
-
-// implementing accessor function
-impl MergedCells {
-    // Method which returns range_ref from the tuple
-    // ex : (3,1,4,2) is interpreted as A3:B4
-    pub fn get_merged_cells_str_ref(&self) -> Result<String, String> {
-        let start_column = number_to_column(self.1).ok_or(format!(
-            "Error while converting column start {} number to column string ref",
-            self.1
-        ))?;
-        let end_column = number_to_column(self.3).ok_or(format!(
-            "Error while converting column end {} number to column string ref",
-            self.3
-        ))?;
-        return Ok(start_column
-            + &self.0.to_string()
-            + &":".to_string()
-            + &end_column
-            + &self.2.to_string());
-    }
-
-    // Only Public function where Merge cell can be created
-    pub fn new(merge_cell_parsed_range: (i32, i32, i32, i32)) -> Self {
-        Self(
-            merge_cell_parsed_range.0,
-            merge_cell_parsed_range.1,
-            merge_cell_parsed_range.2,
-            merge_cell_parsed_range.3,
-        )
-    }
-}
-
 impl Display for FontScheme {
     fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {

base/src/units.rs

@@ -309,6 +309,7 @@ impl Model {
             Function::Sum => self.units_fn_sum_like(args, cell),
             Function::Average => self.units_fn_sum_like(args, cell),
             Function::Pmt => self.units_fn_currency(args, cell),
+            Function::Fv => self.units_fn_currency(args, cell),
             Function::Nper => self.units_fn_currency(args, cell),
             Function::Npv => self.units_fn_currency(args, cell),
             Function::Irr => self.units_fn_percentage(args, cell),

base/src/user_model/common.rs

@@ -342,7 +342,7 @@ impl UserModel {
             old_value: Box::new(old_value),
         }];
 
-        let line_count = value.split("\n").count();
+        let line_count = value.split('\n').count();
         let row_height = self.model.get_row_height(sheet, row)?;
         let cell_height = (line_count as f64) * DEFAULT_ROW_HEIGHT;
         if cell_height > row_height {
@@ -713,7 +713,7 @@ impl UserModel {
 
     /// Paste `styles` in the selected area
     pub fn on_paste_styles(&mut self, styles: &[Vec<Style>]) -> Result<(), String> {
-        let styles_heigh = styles.len() as i32;
+        let styles_height = styles.len() as i32;
         let styles_width = styles[0].len() as i32;
         let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
             view.sheet
@@ -732,13 +732,13 @@ impl UserModel {
 
         // If the pasted area is smaller than the selected area we increase it
         let [row_start, column_start, row_end, column_end] = range;
-        let last_row = row_end.max(row_start + styles_heigh - 1);
+        let last_row = row_end.max(row_start + styles_height - 1);
         let last_column = column_end.max(column_start + styles_width - 1);
 
         let mut diff_list = Vec::new();
         for row in row_start..=last_row {
             for column in column_start..=last_column {
-                let row_index = ((row - row_start) % styles_heigh) as usize;
+                let row_index = ((row - row_start) % styles_height) as usize;
                 let column_index = ((column - column_start) % styles_width) as usize;
                 let style = &styles[row_index][column_index];
                 let old_value = self.model.get_style_for_cell(sheet, row, column)?;

base/src/worksheet.rs

@@ -255,11 +255,14 @@ impl Worksheet {
     ///   * If the row does not a have a style we add it.
     ///   * If it has we modify the height and make sure it is applied.
     ///
-    /// Fails if column index is outside allowed range.
+    /// Fails if row index is outside allowed range or height is negative.
     pub fn set_row_height(&mut self, row: i32, height: f64) -> Result<(), String> {
         if !is_valid_row(row) {
             return Err(format!("Row number '{row}' is not valid."));
         }
+        if height < 0.0 {
+            return Err(format!("Can not set a negative height: {height}"));
+        }
 
         let rows = &mut self.rows;
         for r in rows.iter_mut() {
@@ -284,7 +287,7 @@ impl Worksheet {
     ///   * If the column does not a have a width we simply add it
     ///   * If it has, it might be part of a range and we ned to split the range.
     ///
-    /// Fails if column index is outside allowed range.
+    /// Fails if column index is outside allowed range or width is negative.
     pub fn set_column_width(&mut self, column: i32, width: f64) -> Result<(), String> {
         self.set_column_width_and_style(column, width, None)
     }
@@ -298,6 +301,9 @@ impl Worksheet {
         if !is_valid_column_number(column) {
             return Err(format!("Column number '{column}' is not valid."));
         }
+        if width < 0.0 {
+            return Err(format!("Can not set a negative width: {width}"));
+        }
         let cols = &mut self.cols;
         let mut col = Col {
             min: column,
@@ -524,23 +530,6 @@ impl Worksheet {
         Ok(is_empty)
     }
 
-    /// Returns true if cell part of Merged Cells.
-    /// First cell of Merged cells block is not considered as part of Merged cells
-    /// Ex : if Merged cells were A1-C3, A1 is not considered as part of Merged cells block
-    pub fn is_part_of_merged_cells(&self, row: i32, column: i32) -> Result<bool, String> {
-        if !is_valid_column_number(column) || !is_valid_row(row) {
-            return Err("Incorrect row or column".to_string());
-        }
-
-        // traverse through Vector of Merged Cells and return (linear search)
-        for merged_cells in &self.merged_cells_list {
-            if merged_cells.is_cell_part_of_merged_cells(row, column) {
-                return Ok(true);
-            }
-        }
-        Ok(false)
-    }
-
     /// It provides convenient method for user navigation in the spreadsheet by jumping to edges.
     /// Spreadsheet engines usually allow this method of navigation by using CTRL+arrows.
     /// Behaviour summary:
@@ -594,16 +583,6 @@ impl Worksheet {
             }
         }
     }
-
-    /// Returns mutable reference to Vector of Merged cells list
-    pub fn get_merged_cells_list_mut(&mut self) -> &mut Vec<MergedCells> {
-        &mut self.merged_cells_list
-    }
-
-    /// Returns reference to Vector of Merged cells list
-    pub fn get_merged_cells_list(&self) -> &Vec<MergedCells> {
-        &self.merged_cells_list
-    }
 }
 
 struct WalkFoundCells {

bindings/python/src/lib.rs

@@ -10,6 +10,8 @@ use xlsx::import;
 
 mod types;
 
+use crate::types::PyCellType;
+
 create_exception!(_ironcalc, WorkbookError, PyException);
 
 /// This is a model implementing the 'raw' API
@@ -58,6 +60,21 @@ impl PyModel {
 
     // Get values
 
+    /// Get raw value
+    pub fn get_cell_content(&self, sheet: u32, row: i32, column: i32) -> PyResult<String> {
+        self.model
+            .get_cell_content(sheet, row, column)
+            .map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
+    /// Get cell type
+    pub fn get_cell_type(&self, sheet: u32, row: i32, column: i32) -> PyResult<PyCellType> {
+        self.model
+            .get_cell_type(sheet, row, column)
+            .map(|cell_type| cell_type.into())
+            .map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
     /// Get formatted value
     pub fn get_formatted_cell_value(&self, sheet: u32, row: i32, column: i32) -> PyResult<String> {
         self.model

bindings/python/src/types.rs

@@ -1,7 +1,7 @@
 use pyo3::prelude::*;
 use xlsx::base::types::{
-    Alignment, Border, BorderItem, BorderStyle, Fill, Font, FontScheme, HorizontalAlignment, Style,
+    Alignment, Border, BorderItem, BorderStyle, CellType, Fill, Font, FontScheme,
-    VerticalAlignment,
+    HorizontalAlignment, Style, VerticalAlignment,
 };
 
 #[derive(Clone)]
@@ -161,6 +161,17 @@ pub struct PyFill {
     pub bg_color: Option<String>,
 }
 
+#[pyclass(eq, eq_int)]
+#[derive(PartialEq, Clone)]
+pub enum PyCellType {
+    Number = 1,
+    Text = 2,
+    LogicalValue = 4,
+    ErrorValue = 16,
+    Array = 64,
+    CompoundData = 128,
+}
+
 // Conversions from references to Py* types to non-Py types
 
 // Enums
@@ -426,3 +437,31 @@ impl From<Style> for PyStyle {
         }
     }
 }
+
+// Conversion from PyCellType to CellType
+impl From<PyCellType> for CellType {
+    fn from(py_cell_type: PyCellType) -> Self {
+        match py_cell_type {
+            PyCellType::Number => CellType::Number,
+            PyCellType::Text => CellType::Text,
+            PyCellType::LogicalValue => CellType::LogicalValue,
+            PyCellType::ErrorValue => CellType::ErrorValue,
+            PyCellType::Array => CellType::Array,
+            PyCellType::CompoundData => CellType::CompoundData,
+        }
+    }
+}
+
+// Conversion from CellType to PyCellType
+impl From<CellType> for PyCellType {
+    fn from(cell_type: CellType) -> Self {
+        match cell_type {
+            CellType::Number => PyCellType::Number,
+            CellType::Text => PyCellType::Text,
+            CellType::LogicalValue => PyCellType::LogicalValue,
+            CellType::ErrorValue => PyCellType::ErrorValue,
+            CellType::Array => PyCellType::Array,
+            CellType::CompoundData => PyCellType::CompoundData,
+        }
+    }
+}

docs/src/.vitepress/config.mts

@@ -2003,7 +2003,7 @@ export default defineConfig({
             link: "/programming/python-bindings",
           },
           {
-            text: "JavScript",
+            text: "JavaScript",
             link: "/programming/javascript-bindings",
           },
         ],

docs/src/functions/financial/fv.md

@@ -4,8 +4,46 @@ outline: deep
 lang: en-US
 ---
 
-# FV
+# FV function
+## Overview
+FV (<u>F</u>uture <u>V</u>alue) is a function of the Financial category that can be used to predict the future value of an investment or asset based on its present value.
 
-::: warning
+FV can be used to calculate future value over a specified number of compounding periods. A fixed interest rate or yield is assumed over all periods, and a fixed payment or deposit can be applied at the start or end of every period.
-🚧 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).
+
-:::
+If your interest rate varies between periods, use the [FVSCHEDULE](/functions/financial/fvschedule) function instead of FV.
+## Usage
+### Syntax
+**FV(rate, nper, pmt, pv, type)**
+### Argument descriptions
+* *rate*. The fixed percentage interest rate or yield per period.
+* *nper*. The number of compounding periods to be taken into account. While this will often be an integer, non-integer values are accepted and processed.
+* *pmt*. The fixed amount paid or deposited each compounding period.
+* *pv* (optional). The present value or starting amount of the asset (default 0).
+* *type* (optional). A logical value indicating whether the payment due dates are at the end (0) of the compounding periods or at the beginning (any non-zero value). The default is 0 when omitted.
+### Additional guidance
+* Make sure that the *rate* argument specifies the interest rate or yield applicable to the compounding period, based on the value chosen for *nper*.
+* The *pmt* and *pv* arguments should be expressed in the same currency unit. The value returned is expressed in the same currency unit.
+* To ensure a worthwhile result, one of the *pmt* and *pv* arguments should be non-zero.
+* The setting of the *type* argument only affects the calculation for non-zero values of the *pmt* argument.
+<!--@include: ../markdown-snippets/error-type-details.md-->
+
+## Details
+* If *rate* = 0, FV is given by the equation:
+$$
+FV = -pv - (pmt \times nper)
+$$
+
+* If *rate* <> 0 and *type* = 0, FV is given by the equation:
+$$ FV = -pv \times (1 + rate)^{nper} - \dfrac{pmt\times\big({(1+rate)^{nper}-1}\big)}{rate}
+$$
+* If *rate* <> 0 and *type* <> 0, FV is given by the equation:
+$$ FV = -pv \times (1 + rate)^{nper} - \dfrac{pmt\times\big({(1+rate)^{nper}-1}\big) \times(1+rate)}{rate}
+$$
+## Examples
+[See this example in IronCalc](https://app.ironcalc.com/?example=fv).
+
+## Links
+* For more information about the concept of "future value" in finance, visit Wikipedia's [Future value](https://en.wikipedia.org/wiki/Future_value) page.
+* See also IronCalc's [NPER](/functions/financial/nper), [PMT](/functions/financial/pmt), [PV](/functions/financial/pv) and [RATE](/functions/financial/rate) functions.
+* Visit Microsoft Excel's [FV function](https://support.microsoft.com/en-gb/office/fv-function-2eef9f44-a084-4c61-bdd8-4fe4bb1b71b3) page.
+* Both [Google Sheets](https://support.google.com/docs/answer/3093224) and [LibreOffice Calc](https://wiki.documentfoundation.org/Documentation/Calc_Functions/FV) provide versions of the FV function.

docs/src/functions/markdown-snippets/error-type-details.md

@@ -0,0 +1 @@
+* For information about the different types of errors that you may encounter when using IronCalc functions, visit our [Error Types](/features/error-types) page.

docs/src/functions/statistical.md

@@ -9,13 +9,13 @@ lang: en-US
 At the moment IronCalc only supports a few function in this section.  
 You can track the progress in this [GitHub issue](https://github.com/ironcalc/IronCalc/issues/55).
 
-| Function                 | Status                                         | Documentation |
+| Function                 | Status                                           | Documentation |
-| ------------------------ | ---------------------------------------------- | ------------- |
+| ------------------------ |--------------------------------------------------| ------------- |
 | AVEDEV                   | <Badge type="info" text="Not implemented yet" /> | –             |
-| AVERAGE                  | <Badge type="tip" text="Available" />          | –             |
+| AVERAGE                  | <Badge type="tip" text="Available" />            | –             |
-| AVERAGEA                 | <Badge type="tip" text="Available" />          | –             |
+| AVERAGEA                 | <Badge type="tip" text="Available" />            | –             |
-| AVERAGEIF                | <Badge type="tip" text="Available" />          | –             |
+| AVERAGEIF                | <Badge type="tip" text="Available" />            | –             |
-| AVERAGEIFS               | <Badge type="tip" text="Available" />          | –             |
+| AVERAGEIFS               | <Badge type="tip" text="Available" />            | –             |
 | BETA.DIST                | <Badge type="info" text="Not implemented yet" /> | –             |
 | BETA.INV                 | <Badge type="info" text="Not implemented yet" /> | –             |
 | BINOM.DIST               | <Badge type="info" text="Not implemented yet" /> | –             |
@@ -29,11 +29,11 @@ You can track the progress in this [GitHub issue](https://github.com/ironcalc/Ir
 | CONFIDENCE.NORM          | <Badge type="info" text="Not implemented yet" /> | –             |
 | CONFIDENCE.T             | <Badge type="info" text="Not implemented yet" /> | –             |
 | CORREL                   | <Badge type="info" text="Not implemented yet" /> | –             |
-| COUNT                    | <Badge type="tip" text="Available" />          | –             |
+| COUNT                    | <Badge type="tip" text="Available" />            | –             |
-| COUNTA                   | <Badge type="tip" text="Available" />          | –             |
+| COUNTA                   | <Badge type="tip" text="Available" />            | –             |
-| COUNTBLANK               | <Badge type="tip" text="Available" />          | –             |
+| COUNTBLANK               | <Badge type="tip" text="Available" />            | –             |
-| COUNTIF                  | <Badge type="tip" text="Available" />          | –             |
+| COUNTIF                  | <Badge type="tip" text="Available" />            | –             |
-| COUNTIFS                 | <Badge type="tip" text="Available" />          | –             |
+| COUNTIFS                 | <Badge type="tip" text="Available" />            | –             |
 | COVARIANCE.P             | <Badge type="info" text="Not implemented yet" /> | –             |
 | COVARIANCE.S             | <Badge type="info" text="Not implemented yet" /> | –             |
 | DEVSQ                    | <Badge type="info" text="Not implemented yet" /> | –             |
@@ -58,7 +58,7 @@ You can track the progress in this [GitHub issue](https://github.com/ironcalc/Ir
 | GAMMALN                  | <Badge type="info" text="Not implemented yet" /> | –             |
 | GAMMALN.PRECISE          | <Badge type="info" text="Not implemented yet" /> | –             |
 | GAUSS                    | <Badge type="info" text="Not implemented yet" /> | –             |
-| GEOMEAN                  | <Badge type="info" text="Not implemented yet" /> | –             |
+| GEOMEAN                  | <Badge type="info" text="Available" />            | –             |
 | GROWTH                   | <Badge type="info" text="Not implemented yet" /> | –             |
 | HARMEAN                  | <Badge type="info" text="Not implemented yet" /> | –             |
 | HYPGEOM.DIST             | <Badge type="info" text="Not implemented yet" /> | –             |
@@ -69,9 +69,9 @@ You can track the progress in this [GitHub issue](https://github.com/ironcalc/Ir
 | LOGEST                   | <Badge type="info" text="Not implemented yet" /> | –             |
 | LOGNORM.DIST             | <Badge type="info" text="Not implemented yet" /> | –             |
 | LOGNORM.INV              | <Badge type="info" text="Not implemented yet" /> | –             |
-| MAX                      | <Badge type="tip" text="Available" />          | –             |
+| MAX                      | <Badge type="tip" text="Available" />            | –             |
 | MAXA                     | <Badge type="info" text="Not implemented yet" /> | –             |
-| MAXIFS                   | <Badge type="tip" text="Available" />          | –             |
+| MAXIFS                   | <Badge type="tip" text="Available" />            | –             |
 | MEDIAN                   | <Badge type="info" text="Not implemented yet" /> | –             |
 | MODE.MULT                | <Badge type="info" text="Not implemented yet" /> | –             |
 | MODE.SNGL                | <Badge type="info" text="Not implemented yet" /> | –             |

docs/src/functions/statistical/geomean.md

@@ -7,6 +7,5 @@ lang: en-US
 # GEOMEAN
 
 ::: warning
-🚧 This function is not yet available in IronCalc.
+🚧 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).
-[Follow development here](https://github.com/ironcalc/IronCalc/labels/Functions)
 :::

webapp/src/AppComponents/FileBar.tsx

@@ -35,6 +35,11 @@ export function FileBar(properties: {
         }}
         onDelete={properties.onDelete}
       />
+      <HelpButton
+        onClick={() => window.open("https://docs.ironcalc.com", "_blank")}
+      >
+        Help
+      </HelpButton>
       <WorkbookTitle
         name={properties.model.getName()}
         onNameChange={(name) => {
@@ -84,7 +89,7 @@ export function FileBar(properties: {
 
 const StyledDesktopLogo = styled(IronCalcLogo)`
   width: 120px;
-  margin-left: 10px;
+  margin-left: 12px;
   @media (max-width: 769px) {
     display: none;
   }
@@ -98,6 +103,19 @@ const StyledIronCalcIcon = styled(IronCalcIcon)`
   }
 `;
 
+const HelpButton = styled("div")`
+  display: flex;
+  align-items: center;
+  font-size: 12px;
+  font-family: Inter;
+  padding: 8px;
+  border-radius: 4px;
+  cursor: pointer;
+  &:hover {
+    background-color: #f2f2f2;
+  }
+`;
+
 const Toast = styled("div")`
   font-weight: 400;
   font-size: 12px;
@@ -107,7 +125,7 @@ const Toast = styled("div")`
 `;
 
 const Divider = styled("div")`
-  margin: 10px;
+  margin: 0px 8px 0px 16px;
   height: 12px;
   border-left: 1px solid #e0e0e0;
 `;

webapp/src/AppComponents/FileMenu.tsx

@@ -1,6 +1,6 @@
 import styled from "@emotion/styled";
 import { Menu, MenuItem, Modal } from "@mui/material";
-import { FileDown, FileUp, Plus, Trash2 } from "lucide-react";
+import { Check, FileDown, FileUp, Plus, Trash2 } from "lucide-react";
 import { useRef, useState } from "react";
 import { UploadFileDialog } from "./UploadFileDialog";
 import { getModelsMetadata, getSelectedUuid } from "./storage";
@@ -29,9 +29,9 @@ export function FileMenu(props: {
           setMenuOpen(false);
         }}
       >
-        <span style={{ width: "20px" }}>
+        <CheckIndicator>
-          {uuid === selectedUuid ? "•" : ""}
+          {uuid === selectedUuid ? <StyledCheck /> : ""}
-        </span>
+        </CheckIndicator>
         <MenuItemText
           style={{
             maxWidth: "240px",
@@ -57,9 +57,19 @@ export function FileMenu(props: {
         open={isMenuOpen}
         onClose={(): void => setMenuOpen(false)}
         anchorEl={anchorElement.current}
+        sx={{
+          "& .MuiPaper-root": { borderRadius: "8px", padding: "4px 0px" },
+          "& .MuiList-root": { padding: "0" },
+        }}
+
         // anchorOrigin={properties.anchorOrigin}
       >
-        <MenuItemWrapper onClick={props.newModel}>
+        <MenuItemWrapper
+          onClick={() => {
+            props.newModel();
+            setMenuOpen(false);
+          }}
+        >
           <StyledPlus />
           <MenuItemText>New</MenuItemText>
         </MenuItemWrapper>
@@ -149,12 +159,19 @@ const StyledTrash = styled(Trash2)`
   padding-right: 10px;
 `;
 
+const StyledCheck = styled(Check)`
+  width: 16px;
+  height: 16px;
+  color: #333333;
+  padding-right: 10px;
+`;
+
 const MenuDivider = styled("div")`
-  width: 80%;
+  width: 100%;
   margin: auto;
-  margin-top: 8px;
+  margin-top: 4px;
-  margin-bottom: 8px;
+  margin-bottom: 4px;
-  border-top: 1px solid #e0e0e0;
+  border-top: 1px solid #eeeeee;
 `;
 
 const MenuItemText = styled("div")`
@@ -166,7 +183,12 @@ const MenuItemWrapper = styled(MenuItem)`
   display: flex;
   justify-content: flex-start;
   font-size: 14px;
-  width: 100%;
+  width: calc(100% - 8px);
+  min-width: 172px;
+  margin: 0px 4px;
+  border-radius: 4px;
+  padding: 8px;
+  height: 32px;
 `;
 
 const FileMenuWrapper = styled("div")`
@@ -174,11 +196,16 @@ const FileMenuWrapper = styled("div")`
   align-items: center;
   font-size: 12px;
   font-family: Inter;
-  padding: 10px;
+  padding: 8px;
-  height: 20px;
   border-radius: 4px;
   cursor: pointer;
   &:hover {
     background-color: #f2f2f2;
   }
 `;
+
+const CheckIndicator = styled("span")`
+  display: flex;
+  justify-content: center;
+  min-width: 26px;
+`;

webapp/src/AppComponents/UploadFileDialog.tsx

@@ -134,7 +134,7 @@ export function UploadFileDialog(properties: {
                     width: 16,
                     color: "#EFAA6D",
                     backgroundColor: "#F2994A1A",
-                    padding: "2px 4px",
+                    padding: "2px 6px",
                     borderRadius: 4,
                   }}
                 />
@@ -192,7 +192,13 @@ export function UploadFileDialog(properties: {
         <BookOpen
           style={{ width: 16, height: 16, marginLeft: 12, marginRight: 8 }}
         />
-        <span>Learn more about importing files into IronCalc</span>
+        <UploadFooterLink
+          href="https://docs.ironcalc.com/web-application/importing-files.html"
+          target="_blank"
+          rel="noopener noreferrer"
+        >
+          Learn more about importing files into IronCalc
+        </UploadFooterLink>
       </UploadFooter>
     </UploadDialog>
   );
@@ -202,34 +208,46 @@ const Cross = styled("div")`
   &:hover {
     background-color: #f5f5f5;
   }
+  display: flex;
   border-radius: 4px;
-  height: 16px;
+  height: 24px;
-  width: 16px;
+  width: 24px;
+  cursor: pointer;
+  align-items: center;
+  justify-content: center;
 `;
 
 const DocLink = styled("span")`
   color: #f2994a;
-  text-decoration: underline;
+  text-decoration: none;
   &:hover {
-    font-weight: bold;
+    text-decoration: underline;
   }
 `;
 
 const UploadFooter = styled("div")`
-  height: 40px;
+  height: 44px;
   border-top: 1px solid #e0e0e0;
-  font-size: 12px;
-  font-weight: 400;
   color: #757575;
   display: flex;
   align-items: center;
 `;
 
+const UploadFooterLink = styled("a")`
+  font-size: 12px;
+  font-weight: 400;
+  color: #757575;
+  text-decoration: none;
+  &:hover {
+    text-decoration: underline;
+  }
+`;
+
 const UploadTitle = styled("div")`
   display: flex;
   align-items: center;
   border-bottom: 1px solid #e0e0e0;
-  height: 40px;
+  height: 44px;
   font-size: 14px;
   font-weight: 500;
 `;
@@ -241,7 +259,8 @@ const UploadDialog = styled("div")`
   left: 50%;
   top: 50%;
   transform: translate(-50%, -50%);
-  width: 455px;
+  width: 460px;
+  max-width: 90%;
   height: 285px;
   background: #fff;
   border: 1px solid #e0e0e0;
@@ -251,6 +270,16 @@ const UploadDialog = styled("div")`
 `;
 
 const DropZone = styled("div")`
+  &:hover {
+    border: 1px dashed #f2994a;
+    transition: 0.2s ease-in-out;
+    gap: 8px;
+    background: linear-gradient(
+      180deg,
+      rgba(242, 153, 74, 0.12) 0%,
+      rgba(242, 153, 74, 0) 100%
+    );
+  }
   flex-grow: 2;
   border-radius: 10px;
   text-align: center;
@@ -259,7 +288,7 @@ const DropZone = styled("div")`
   font-family: Arial, sans-serif;
   cursor: pointer;
   background-color: #faebd7;
-  border: 1px dashed #f2994a;
+  border: 1px dashed #efaa6d;
   background: linear-gradient(
     180deg,
     rgba(242, 153, 74, 0.08) 0%,
@@ -268,4 +297,6 @@ const DropZone = styled("div")`
   display: flex;
   flex-direction: column;
   vertical-align: center;
+  gap: 16px;
+  transition: 0.2s ease-in-out;
 `;

webapp/src/components/WorksheetCanvas/worksheetCanvas.ts

@@ -867,14 +867,18 @@ export default class WorksheetCanvas {
         frozenRows,
         frozenColumns,
       );
-      xFrozenEnd += this.getColumnWidth(
+      if (frozenColumns > 0) {
-        this.model.getSelectedSheet(),
+        xFrozenEnd += this.getColumnWidth(
-        frozenColumns,
+          this.model.getSelectedSheet(),
-      );
+          frozenColumns,
-      yFrozenEnd += this.getRowHeight(
+        );
-        this.model.getSelectedSheet(),
+      }
-        frozenRows,
+      if (frozenRows > 0) {
-      );
+        yFrozenEnd += this.getRowHeight(
+          this.model.getSelectedSheet(),
+          frozenRows,
+        );
+      }
       if (startRow <= frozenRows && endRow > frozenRows) {
         yEnd = Math.max(yEnd, yFrozenEnd);
       }

webapp/src/components/colorPicker.tsx

@@ -71,6 +71,7 @@ const ColorPicker = (properties: ColorPickerProps) => {
             setColor(newColor);
           }}
         />
+        <HorizontalDivider />
         <ColorPickerInput>
           <HexWrapper>
             <HexLabel>{"Hex"}</HexLabel>
@@ -131,6 +132,8 @@ const ColorPicker = (properties: ColorPickerProps) => {
 const RecentLabel = styled.div`
   font-family: "Inter";
   font-size: 12px;
+  font-family: Inter;
+  margin: 8px 8px 0px 8px;
   color: ${theme.palette.text.secondary};
 `;
 
@@ -138,14 +141,17 @@ const ColorList = styled.div`
   display: flex;
   flex-wrap: wrap;
   flex-direction: row;
+  margin: 8px;
+  justify-content: flex-start;
+  gap: 4.7px;
 `;
 
 const Button = styled.button<{ $color: string }>`
-  width: 20px;
+  width: 16px;
-  height: 20px;
+  height: 16px;
   ${({ $color }): string => {
     if ($color.toUpperCase() === "#FFFFFF") {
-      return `border: 1px solid ${theme.palette.grey["600"]};`;
+      return `border: 1px solid ${theme.palette.grey["300"]};`;
     }
     return `border: 1px solid ${$color};`;
   }}
@@ -153,17 +159,19 @@ const Button = styled.button<{ $color: string }>`
     return $color;
   }};
   box-sizing: border-box;
-  margin-top: 10px;
+  margin-top: 0px;
-  margin-right: 10px;
+  border-radius: 4px;
-  border-radius: 2px;
+  &:hover {
+    cursor: pointer;
+    outline: 1px solid ${theme.palette.grey["300"]};
+    outline-offset: 1px;
+  }
 `;
 
 const HorizontalDivider = styled.div`
   height: 0px;
   width: 100%;
-  border-top: 1px solid ${theme.palette.grey["400"]};
+  border-top: 1px solid ${theme.palette.grey["200"]};
-  margin-top: 15px;
-  margin-bottom: 5px;
 `;
 
 // const StyledPopover = styled(Popover)`
@@ -183,7 +191,7 @@ const HorizontalDivider = styled.div`
 const ColorPickerDialog = styled.div`
   background: ${theme.palette.background.default};
   width: ${colorPickerWidth}px;
-  padding: 15px;
+  padding: 0px;
   display: flex;
   flex-direction: column;
 
@@ -193,11 +201,11 @@ const ColorPickerDialog = styled.div`
   }
   & .react-colorful__saturation {
     border-bottom: none;
-    border-radius: 5px;
+    border-radius: 0px;
   }
   & .react-colorful__hue {
-    height: 20px;
+    height: 8px;
-    margin-top: 15px;
+    margin: 8px;
     border-radius: 5px;
   }
   & .react-colorful__saturation-pointer {
@@ -206,19 +214,22 @@ const ColorPickerDialog = styled.div`
   }
   & .react-colorful__hue-pointer {
     width: 7px;
-    border-radius: 3px;
+    border-radius: 8px;
+    height: 16px;
+    width: 16px;
+    border-bottom: 1px solid #eee;
   }
 `;
 
 const HashLabel = styled.div`
   margin: auto 0px auto 10px;
   font-size: 13px;
-  color: #7d8ec2;
+  color: #333;
   font-family: ${theme.typography.button.fontFamily};
 `;
 
 const HexLabel = styled.div`
-  margin: auto 10px auto 0px;
+  margin: auto 0px;
   font-size: 12px;
   display: inline-flex;
   font-family: ${theme.typography.button.fontFamily};
@@ -227,15 +238,22 @@ const HexLabel = styled.div`
 const HexColorInputBox = styled.div`
   display: inline-flex;
   flex-grow: 1;
-  margin-right: 10px;
   width: 140px;
   height: 28px;
-  border: 1px solid ${theme.palette.grey["600"]};
+  border: 1px solid ${theme.palette.grey["300"]};
   border-radius: 5px;
+  &:hover {
+    border: 1px solid ${theme.palette.grey["600"]};
+  }
+  &:focus-within {
+    outline: 2px solid ${theme.palette.secondary.main};
+    outline-offset: 1px;
+  }
 `;
 
 const HexWrapper = styled.div`
   display: flex;
+  gap: 8px;
   flex-grow: 1;
   & input {
     min-width: 0px;
@@ -259,7 +277,7 @@ const Swatch = styled.div<{ $color: string }>`
   display: inline-flex;
   ${({ $color }): string => {
     if ($color.toUpperCase() === "#FFFFFF") {
-      return `border: 1px solid ${theme.palette.grey["600"]};`;
+      return `border: 1px solid ${theme.palette.grey["300"]};`;
     }
     return `border: 1px solid ${$color};`;
   }}
@@ -273,7 +291,8 @@ const ColorPickerInput = styled.div`
   display: flex;
   flex-direction: row;
   align-items: center;
-  margin-top: 15px;
+  margin: 8px;
+  gap: 8px;
 `;
 
 export default ColorPicker;

webapp/src/components/constants.tsx

@@ -1,3 +1,3 @@
-export const TOOLBAR_HEIGH = 48;
+export const TOOLBAR_HEIGHT = 48;
-export const FORMULA_BAR_HEIGH = 40;
+export const FORMULA_BAR_HEIGHT = 40;
-export const NAVIGATION_HEIGH = 40;
+export const NAVIGATION_HEIGHT = 40;

webapp/src/components/editor/util.tsx

@@ -7,6 +7,16 @@ import {
 } from "@ironcalc/wasm";
 import type { ActiveRange } from "../workbookState";
 
+function sliceString(
+  text: string,
+  startScalar: number,
+  endScalar: number,
+): string {
+  const scalarValues = Array.from(text);
+  const sliced = scalarValues.slice(startScalar, endScalar);
+  return sliced.join("");
+}
+
 export function tokenIsReferenceType(token: TokenType): token is Reference {
   return typeof token === "object" && "Reference" in token;
 }
@@ -127,7 +137,7 @@ function getFormulaHTML(
         }
         html.push(
           <span key={index} style={{ color }}>
-            {formula.slice(start, end)}
+            {sliceString(formula, start, end)}
           </span>,
         );
         activeRanges.push({
@@ -162,7 +172,7 @@ function getFormulaHTML(
         }
         html.push(
           <span key={index} style={{ color }}>
-            {formula.slice(start, end)}
+            {sliceString(formula, start, end)}
           </span>,
         );
         colorCount += 1;
@@ -176,7 +186,7 @@ function getFormulaHTML(
           color,
         });
       } else {
-        html.push(<span key={index}>{formula.slice(start, end)}</span>);
+        html.push(<span key={index}>{sliceString(formula, start, end)}</span>);
       }
     }
     html = [<span key="equals">=</span>].concat(html);

webapp/src/components/formatMenu.tsx

@@ -34,11 +34,18 @@ const FormatMenu = (properties: FormatMenuProps) => {
       >
         {properties.children}
       </ChildrenWrapper>
-      <Menu
+      <StyledMenu
         open={isMenuOpen}
         onClose={(): void => setMenuOpen(false)}
         anchorEl={anchorElement.current}
-        anchorOrigin={properties.anchorOrigin}
+        anchorOrigin={{
+          vertical: "bottom",
+          horizontal: "left",
+        }}
+        transformOrigin={{
+          vertical: "top",
+          horizontal: "left",
+        }}
       >
         <MenuItemWrapper onClick={(): void => onSelect(NumberFormats.AUTO)}>
           <MenuItemText>{t("toolbar.format_menu.auto")}</MenuItemText>
@@ -107,7 +114,7 @@ const FormatMenu = (properties: FormatMenuProps) => {
         <MenuItemWrapper onClick={(): void => setPickerOpen(true)}>
           <MenuItemText>{t("toolbar.format_menu.custom")}</MenuItemText>
         </MenuItemWrapper>
-      </Menu>
+      </StyledMenu>
       <FormatPicker
         numFmt={properties.numFmt}
         onChange={onSelect}
@@ -119,18 +126,40 @@ const FormatMenu = (properties: FormatMenuProps) => {
   );
 };
 
+const StyledMenu = styled(Menu)`
+  & .MuiPaper-root {
+    border-radius: 8px;
+    padding: 4px 0px;
+    margin-left: -4px; // Starting with a small offset
+  }
+  & .MuiList-root {
+    padding: 0;
+  }
+`;
+
 const MenuItemWrapper = styled(MenuItem)`
   display: flex;
   justify-content: space-between;
   font-size: 12px;
-  width: 100%;
+  width: calc(100% - 8px);
+  min-width: 172px;
+  margin: 0px 4px;
+  border-radius: 4px;
+  padding: 8px;
+  height: 32px;
 `;
 
 const ChildrenWrapper = styled("div")`
   display: flex;
 `;
 
-const MenuDivider = styled("div")``;
+const MenuDivider = styled("div")`
+  width: 100%;
+  margin: auto;
+  margin-top: 4px;
+  margin-bottom: 4px;
+  border-top: 1px solid #eeeeee;
+`;
 
 const MenuItemText = styled("div")`
   color: #000;

webapp/src/components/formatPicker.tsx

@@ -1,13 +1,9 @@
-import {
+import styled from "@emotion/styled";
-  Button,
+import { Dialog, TextField } from "@mui/material";
-  Dialog,
+import { Check } from "lucide-react";
-  DialogActions,
-  DialogContent,
-  DialogTitle,
-  TextField,
-} from "@mui/material";
 import { useState } from "react";
 import { useTranslation } from "react-i18next";
+import { theme } from "../theme";
 
 type FormatPickerProps = {
   className?: string;
@@ -22,17 +18,53 @@ const FormatPicker = (properties: FormatPickerProps) => {
   const { t } = useTranslation();
   const [formatCode, setFormatCode] = useState(properties.numFmt);
 
+  const handleClose = () => {
+    properties.onClose();
+  };
+
   const onSubmit = (format_code: string): void => {
     properties.onChange(format_code);
     properties.onClose();
   };
   return (
-    <Dialog open={properties.open} onClose={properties.onClose}>
+    <Dialog
-      <DialogTitle>{t("num_fmt.title")}</DialogTitle>
+      open={properties.open}
-      <DialogContent dividers>
+      onClose={properties.onClose}
-        <TextField
+      PaperProps={{
+        style: { minWidth: "280px" },
+      }}
+    >
+      <StyledDialogTitle>
+        {t("num_fmt.title")}
+        <Cross onClick={handleClose} onKeyDown={() => {}}>
+          <svg
+            width="16"
+            height="16"
+            viewBox="0 0 16 16"
+            fill="none"
+            xmlns="http://www.w3.org/2000/svg"
+          >
+            <title>Close</title>
+            <path
+              d="M12 4.5L4 12.5"
+              stroke="#333333"
+              strokeLinecap="round"
+              strokeLinejoin="round"
+            />
+            <path
+              d="M4 4.5L12 12.5"
+              stroke="#333333"
+              strokeLinecap="round"
+              strokeLinejoin="round"
+            />
+          </svg>
+        </Cross>
+      </StyledDialogTitle>
+
+      <StyledDialogContent>
+        <StyledTextField
+          autoFocus
           defaultValue={properties.numFmt}
-          label={t("num_fmt.label")}
           name="format_code"
           onChange={(event) => setFormatCode(event.target.value)}
           onKeyDown={(event) => {
@@ -40,15 +72,94 @@ const FormatPicker = (properties: FormatPickerProps) => {
           }}
           spellCheck="false"
           onClick={(event) => event.stopPropagation()}
+          onFocus={(event) => event.target.select()}
         />
-      </DialogContent>
+      </StyledDialogContent>
-      <DialogActions>
+      <DialogFooter>
-        <Button onClick={() => onSubmit(formatCode)}>
+        <StyledButton onClick={() => onSubmit(formatCode)}>
+          <Check
+            style={{ width: "16px", height: "16px", marginRight: "8px" }}
+          />
           {t("num_fmt.save")}
-        </Button>
+        </StyledButton>
-      </DialogActions>
+      </DialogFooter>
     </Dialog>
   );
 };
 
+const StyledDialogTitle = styled("div")`
+  display: flex;
+  align-items: center;
+  height: 44px;
+  font-size: 14px;
+  font-weight: 500;
+  font-family: Inter;
+  padding: 0px 12px;
+  justify-content: space-between;
+  border-bottom: 1px solid ${theme.palette.grey["300"]};
+`;
+
+const Cross = styled("div")`
+  &:hover {
+    background-color: ${theme.palette.grey["100"]};
+  }
+  display: flex;
+  border-radius: 4px;
+  height: 24px;
+  width: 24px;
+  cursor: pointer;
+  align-items: center;
+  justify-content: center;
+`;
+
+const StyledDialogContent = styled("div")`
+  font-size: 12px;
+  margin: 12px;
+`;
+
+const StyledTextField = styled(TextField)`
+  width: 100%;
+  min-width: 320px;
+  border-radius: 4px;
+  overflow: hidden;
+  & .MuiInputBase-input {
+    font-size: 14px;
+    padding: 10px;
+    border: 1px solid ${theme.palette.grey["300"]};
+    border-radius: 4px;
+    color: ${theme.palette.common.black};
+    background-color: ${theme.palette.common.white};
+  }
+  &:hover .MuiInputBase-input {
+    border: 1px solid ${theme.palette.grey["500"]};
+  }
+`;
+
+const DialogFooter = styled("div")`
+  color: #757575;
+  display: flex;
+  align-items: center;
+  border-top: 1px solid ${theme.palette.grey["300"]};
+  font-family: Inter;
+  justify-content: flex-end;
+  padding: 12px;
+`;
+
+const StyledButton = styled("div")`
+  cursor: pointer;
+  color: #ffffff;
+  background: #f2994a;
+  padding: 0px 10px;
+  height: 36px;
+  line-height: 36px;
+  border-radius: 4px;
+  display: flex;
+  align-items: center;
+  font-family: "Inter";
+  font-size: 14px;
+  &:hover {
+    background: #d68742;
+  }
+`;
+
 export default FormatPicker;

webapp/src/components/formulabar.tsx

@@ -5,7 +5,7 @@ import {
   COLUMN_WIDTH_SCALE,
   ROW_HEIGH_SCALE,
 } from "./WorksheetCanvas/constants";
-import { FORMULA_BAR_HEIGH } from "./constants";
+import { FORMULA_BAR_HEIGHT } from "./constants";
 import Editor from "./editor/editor";
 import type { WorkbookState } from "./workbookState";
 
@@ -122,7 +122,7 @@ const Container = styled("div")`
   align-items: center;
   background: ${(properties): string =>
     properties.theme.palette.background.default};
-  height: ${FORMULA_BAR_HEIGH}px;
+  height: ${FORMULA_BAR_HEIGHT}px;
 `;
 
 const AddressContainer = styled("div")`

webapp/src/components/navigation/menus.tsx

@@ -1,17 +1,10 @@
-import {
+import { Dialog, TextField, styled } from "@mui/material";
-  Button,
-  Dialog,
-  DialogActions,
-  DialogContent,
-  DialogTitle,
-  TextField,
-  styled,
-} from "@mui/material";
 import Menu from "@mui/material/Menu";
 import MenuItem from "@mui/material/MenuItem";
 import { Check } from "lucide-react";
 import { useState } from "react";
 import { useTranslation } from "react-i18next";
+import { theme } from "../../theme";
 import type { SheetOptions } from "./types";
 
 function isWhiteColor(color: string): boolean {
@@ -28,32 +21,65 @@ interface SheetRenameDialogProps {
 export const SheetRenameDialog = (properties: SheetRenameDialogProps) => {
   const { t } = useTranslation();
   const [name, setName] = useState(properties.defaultName);
+  const handleClose = () => {
+    properties.close();
+  };
   return (
     <Dialog open={properties.isOpen} onClose={properties.close}>
-      <DialogTitle>{t("sheet_rename.title")}</DialogTitle>
+      <StyledDialogTitle>
-      <DialogContent dividers>
+        {t("sheet_rename.title")}
-        <TextField
+        <Cross onClick={handleClose} onKeyDown={() => {}}>
+          <svg
+            width="16"
+            height="16"
+            viewBox="0 0 16 16"
+            fill="none"
+            xmlns="http://www.w3.org/2000/svg"
+          >
+            <title>Close</title>
+            <path
+              d="M12 4.5L4 12.5"
+              stroke="#333333"
+              strokeLinecap="round"
+              strokeLinejoin="round"
+            />
+            <path
+              d="M4 4.5L12 12.5"
+              stroke="#333333"
+              strokeLinecap="round"
+              strokeLinejoin="round"
+            />
+          </svg>
+        </Cross>
+      </StyledDialogTitle>
+      <StyledDialogContent>
+        <StyledTextField
+          autoFocus
           defaultValue={properties.defaultName}
-          label={t("sheet_rename.label")}
           onClick={(event) => event.stopPropagation()}
           onKeyDown={(event) => {
             event.stopPropagation();
+            if (event.key === "Enter") {
+              properties.onNameChanged(name);
+              properties.close();
+            }
           }}
           onChange={(event) => {
             setName(event.target.value);
           }}
           spellCheck="false"
+          onPaste={(event) => event.stopPropagation()}
         />
-      </DialogContent>
+      </StyledDialogContent>
-      <DialogActions>
+      <DialogFooter>
-        <Button
+        <StyledButton
           onClick={() => {
             properties.onNameChanged(name);
           }}
         >
           {t("sheet_rename.rename")}
-        </Button>
+        </StyledButton>
-      </DialogActions>
+      </DialogFooter>
     </Dialog>
   );
 };
@@ -146,4 +172,78 @@ const ItemName = styled("div")`
   color: #333;
 `;
 
+const StyledDialogTitle = styled("div")`
+  display: flex;
+  align-items: center;
+  height: 44px;
+  font-size: 14px;
+  font-weight: 500;
+  font-family: Inter;
+  padding: 0px 12px;
+  justify-content: space-between;
+  border-bottom: 1px solid ${theme.palette.grey["300"]};
+`;
+
+const Cross = styled("div")`
+  &:hover {
+    background-color: ${theme.palette.grey["100"]};
+  }
+  display: flex;
+  border-radius: 4px;
+  height: 24px;
+  width: 24px;
+  cursor: pointer;
+  align-items: center;
+  justify-content: center;
+`;
+
+const StyledDialogContent = styled("div")`
+  font-size: 12px;
+  margin: 12px;
+`;
+
+const StyledTextField = styled(TextField)`
+  width: 100%;
+  border-radius: 4px;
+  overflow: hidden;
+  & .MuiInputBase-input {
+    font-size: 14px;
+    padding: 10px;
+    border: 1px solid ${theme.palette.grey["300"]};
+    border-radius: 4px;
+    color: ${theme.palette.common.black};
+    background-color: ${theme.palette.common.white};
+  }
+  &:hover .MuiInputBase-input {
+    border: 1px solid ${theme.palette.grey["500"]};
+  }
+`;
+
+const DialogFooter = styled("div")`
+  color: #757575;
+  display: flex;
+  align-items: center;
+  border-top: 1px solid ${theme.palette.grey["300"]};
+  font-family: Inter;
+  justify-content: flex-end;
+  padding: 12px;
+`;
+
+const StyledButton = styled("div")`
+  cursor: pointer;
+  color: #ffffff;
+  background: #f2994a;
+  padding: 0px 10px;
+  height: 36px;
+  line-height: 36px;
+  border-radius: 4px;
+  display: flex;
+  align-items: center;
+  font-family: "Inter";
+  font-size: 14px;
+  &:hover {
+    background: #d68742;
+  }
+`;
+
 export default SheetListMenu;

webapp/src/components/navigation/navigation.tsx

@@ -2,7 +2,8 @@ import { styled } from "@mui/material";
 import { Menu, Plus } from "lucide-react";
 import { useState } from "react";
 import { useTranslation } from "react-i18next";
-import { NAVIGATION_HEIGH } from "../constants";
+import { theme } from "../../theme";
+import { NAVIGATION_HEIGHT } from "../constants";
 import { StyledButton } from "../toolbar";
 import type { WorkbookState } from "../workbookState";
 import SheetListMenu from "./menus";
@@ -96,17 +97,19 @@ const Container = styled("div")`
   left: 0px;
   right: 0px;
   display: flex;
-  height: ${NAVIGATION_HEIGH}px;
+  height: ${NAVIGATION_HEIGHT}px;
   align-items: center;
   padding-left: 12px;
   font-family: Inter;
   background-color: #fff;
-  border-top: 1px solid #E0E0E0;
+  border-top: 1px solid #e0e0e0;
 `;
 
 const Sheets = styled("div")`
   flex-grow: 2;
   overflow: hidden;
+  overflow-x: auto;
+  scrollbar-width: none;
 `;
 
 const SheetInner = styled("div")`
@@ -114,10 +117,20 @@ const SheetInner = styled("div")`
 `;
 
 const Advert = styled("a")`
+  display: flex;
+  align-items: center;
   color: #f2994a;
-  margin-right: 12px;
+  padding: 0px 12px;
   font-size: 12px;
   text-decoration: none;
+  border-left: 1px solid ${theme.palette.grey["300"]};
+  transition: color 0.2s ease-in-out;
+  &:hover {
+    text-decoration: underline;
+  }
+  @media (max-width: 769px) {
+    height: 100%;
+  }
 `;
 
 export default Navigation;

webapp/src/components/toolbar.tsx

@@ -36,7 +36,7 @@ import {
 import { theme } from "../theme";
 import BorderPicker from "./borderPicker";
 import ColorPicker from "./colorPicker";
-import { TOOLBAR_HEIGH } from "./constants";
+import { TOOLBAR_HEIGHT } from "./constants";
 import FormatMenu from "./formatMenu";
 import {
   NumberFormats,
@@ -251,6 +251,16 @@ function Toolbar(properties: ToolbarProperties) {
       >
         <PaintBucket />
       </StyledButton>
+      <StyledButton
+        type="button"
+        $pressed={false}
+        onClick={() => setBorderPickerOpen(true)}
+        ref={borderButton}
+        disabled={!canEdit}
+        title={t("toolbar.borders.title")}
+      >
+        <Grid2X2 />
+      </StyledButton>
       <Divider />
       <StyledButton
         type="button"
@@ -318,17 +328,7 @@ function Toolbar(properties: ToolbarProperties) {
       >
         <ArrowDownToLine />
       </StyledButton>
-      <Divider />
+
-      <StyledButton
-        type="button"
-        $pressed={false}
-        onClick={() => setBorderPickerOpen(true)}
-        ref={borderButton}
-        disabled={!canEdit}
-        title={t("toolbar.borders.title")}
-      >
-        <Grid2X2 />
-      </StyledButton>
       <Divider />
       <StyledButton
         type="button"
@@ -385,8 +385,8 @@ const ToolbarContainer = styled("div")`
   flex-shrink: 0;
   align-items: center;
   background: ${({ theme }) => theme.palette.background.paper};
-  height: ${TOOLBAR_HEIGH}px;
+  height: ${TOOLBAR_HEIGHT}px;
-  line-height: ${TOOLBAR_HEIGH}px;
+  line-height: ${TOOLBAR_HEIGHT}px;
   border-bottom: 1px solid ${({ theme }) => theme.palette.grey["300"]};
   font-family: Inter;
   border-radius: 4px 4px 0px 0px;

webapp/src/components/workbook.tsx

@@ -530,7 +530,7 @@ const Workbook = (props: { model: Model; workbookState: WorkbookState }) => {
           );
           setRedrawId((id) => id + 1);
         }}
-        fillColor={style.fill.fg_color || "#FFF"}
+        fillColor={style.fill.fg_color || "#FFFFFF"}
         fontColor={style.font.color}
         bold={style.font.b}
         underline={style.font.u}

webapp/src/components/worksheet.tsx

@@ -9,9 +9,9 @@ import {
 } from "./WorksheetCanvas/constants";
 import WorksheetCanvas from "./WorksheetCanvas/worksheetCanvas";
 import {
-  FORMULA_BAR_HEIGH,
+  FORMULA_BAR_HEIGHT,
-  NAVIGATION_HEIGH,
+  NAVIGATION_HEIGHT,
-  TOOLBAR_HEIGH,
+  TOOLBAR_HEIGHT,
 } from "./constants";
 import Editor from "./editor/editor";
 import type { Cell } from "./types";
@@ -104,10 +104,16 @@ function Worksheet(props: {
         editor: editor,
       },
       onColumnWidthChanges(sheet, column, width) {
+        if (width < 0) {
+          return;
+        }
         model.setColumnWidth(sheet, column, width);
         worksheetCanvas.current?.renderSheet();
       },
       onRowHeightChanges(sheet, row, height) {
+        if (height < 0) {
+          return;
+        }
         model.setRowHeight(sheet, row, height);
         worksheetCanvas.current?.renderSheet();
       },
@@ -433,10 +439,10 @@ const SheetContainer = styled("div")`
 const Wrapper = styled("div")({
   position: "absolute",
   overflow: "scroll",
-  top: TOOLBAR_HEIGH + FORMULA_BAR_HEIGH + 1,
+  top: TOOLBAR_HEIGHT + FORMULA_BAR_HEIGHT + 1,
   left: 0,
   right: 0,
-  bottom: NAVIGATION_HEIGH + 1,
+  bottom: NAVIGATION_HEIGHT + 1,
   overscrollBehavior: "none",
 });
 

xlsx/src/export/worksheets.rs

@@ -246,18 +246,8 @@ pub(crate) fn get_worksheet_xml(
     }
     let sheet_data = sheet_data_str.join("");
 
-    for merged_cells_ref in &worksheet.merged_cells_list {
+    for merge_cell_ref in &worksheet.merge_cells {
-        let merged_cells_range_str_ref: String = match merged_cells_ref.get_merged_cells_str_ref() {
+        merged_cells_str.push(format!("<mergeCell ref=\"{merge_cell_ref}\"/>"))
-            Ok(merged_cells_ref) => merged_cells_ref,
-            Err(err) => {
-                // ATTENTION : This should not happen. There should not be error while exporting
-                // already imported/created Mergedcells structure
-                // Currently, this function does not return any error. so logging the error and skipping this errored one
-                println!("{}", err);
-                continue;
-            }
-        };
-        merged_cells_str.push(format!("<mergeCell ref=\"{merged_cells_range_str_ref}\"/>"))
     }
     let merged_cells_count = merged_cells_str.len();
 

xlsx/src/import/worksheets.rs

@@ -10,7 +10,7 @@ use ironcalc_base::{
         utils::{column_to_number, parse_reference_a1},
     },
     types::{
-        Cell, Col, Comment, DefinedName, MergedCells, Row, SheetData, SheetState, Table, Worksheet,
+        Cell, Col, Comment, DefinedName, Row, SheetData, SheetState, Table, Worksheet,
         WorksheetView,
     },
 };
@@ -148,12 +148,71 @@ fn load_columns(ws: Node) -> Result<Vec<Col>, XlsxError> {
     Ok(cols)
 }
 
-fn load_merge_cells_nodes(ws: Node) -> Result<Vec<MergedCells>, XlsxError> {
+
+// https://c-rex.net/samples/ooxml/e1/Part4/OOXML_P4_DOCX_cfRule_topic_ID0EFKO4.html
+fn load_conditional_formatting(ws: Node) -> Result<Vec<String>, XlsxError> {
+    // Conditional Formatting
+    // <conditionalFormatting sqref="B1:B9">
+    //     <cfRule type="colorScale" priority="1">
+    //         <colorScale>
+    //             <cfvo type="min"/>
+    //             <cfvo type="max"/>
+    //             <color rgb="FFF8696B"/>
+    //             <color rgb="FFFCFCFF"/>
+    //         </colorScale>
+    //     </cfRule>
+    // </conditionalFormatting>
+    let mut conditional_formatting = Vec::new();
+    let conditional_formatting_nodes = ws
+        .children()
+        .filter(|n| n.has_tag_name("conditionalFormattng"))
+        .collect::<Vec<Node>>();
+    for format in conditional_formatting_nodes {
+        let reference = get_attribute(&format, "sqref")?.to_string();
+        // cfRule
+        let cf_rule_nodes = ws
+            .children()
+            .filter(|n| n.has_tag_name("cfRule"))
+            .collect::<Vec<Node>>();
+        if cf_rule_nodes.len() == 1 {
+            let cf_rule = cf_rule_nodes[0] ;
+            let cf_type = get_attribute(&cf_rule, "type")?.to_string();
+            match cf_type.as_str() {
+                "colorScale" => {
+                    todo!()
+                }
+                "aboveAverage" => {
+                    let dxf_id = get_attribute(&cf_rule, "dxfId")?.to_string();
+                    todo!()
+                }
+                "notContainsBlanks" => {
+                    let dxf_id = get_attribute(&cf_rule, "dxfId")?.to_string();
+
+                }
+                _ => {}
+                
+            }
+        }
+        // priority
+
+        // if type is avobeAverage then avobeAverage (and equlAverage)
+
+        // dxfId for some types((Differential Formatting Id) What style to apply when the criteria are met
+
+        // Posible children
+        // formula
+        // colorScales
+    }
+
+    Ok(conditional_formatting)
+}
+
+fn load_merge_cells(ws: Node) -> Result<Vec<String>, XlsxError> {
     // 18.3.1.55 Merge Cells
     // <mergeCells count="1">
     //    <mergeCell ref="K7:L10"/>
     // </mergeCells>
-    let mut merged_cells_list: Vec<MergedCells> = Vec::new();
+    let mut merge_cells = Vec::new();
     let merge_cells_nodes = ws
         .children()
         .filter(|n| n.has_tag_name("mergeCells"))
@@ -161,18 +220,10 @@ fn load_merge_cells_nodes(ws: Node) -> Result<Vec<MergedCells>, XlsxError> {
     if merge_cells_nodes.len() == 1 {
         for merge_cell in merge_cells_nodes[0].children() {
             let reference = get_attribute(&merge_cell, "ref")?.to_string();
-            match parse_range(&reference) {
+            merge_cells.push(reference);
-                Ok(parsed_merge_cell_range) => {
-                    let merge_cell_node = MergedCells::new(parsed_merge_cell_range);
-                    merged_cells_list.push(merge_cell_node);
-                }
-                Err(err) => {
-                    println!("encountered error while parsing merge cell ref : {}", err);
-                }
-            }
         }
     }
-    Ok(merged_cells_list)
+    Ok(merge_cells)
 }
 
 fn load_sheet_color(ws: Node) -> Result<Option<String>, XlsxError> {
@@ -951,19 +1002,9 @@ pub(super) fn load_sheet<R: Read + std::io::Seek>(
         sheet_data.insert(row_index, data_row);
     }
 
-    let merge_cells_nodes = load_merge_cells_nodes(ws)?;
+    let merge_cells = load_merge_cells(ws)?;
 
-    // Conditional Formatting
+    let conditional_formatting = load_conditional_formatting(ws)?;
-    // <conditionalFormatting sqref="B1:B9">
-    //     <cfRule type="colorScale" priority="1">
-    //         <colorScale>
-    //             <cfvo type="min"/>
-    //             <cfvo type="max"/>
-    //             <color rgb="FFF8696B"/>
-    //             <color rgb="FFFCFCFF"/>
-    //         </colorScale>
-    //     </cfRule>
-    // </conditionalFormatting>
     // pageSetup
     // <pageSetup orientation="portrait" r:id="rId1"/>
 
@@ -990,7 +1031,7 @@ pub(super) fn load_sheet<R: Read + std::io::Seek>(
             sheet_id,
             state: state.to_owned(),
             color,
-            merged_cells_list: merge_cells_nodes,
+            merge_cells,
             comments: settings.comments,
             frozen_rows: sheet_view.frozen_rows,
             frozen_columns: sheet_view.frozen_columns,

xlsx/tests/test.rs

@@ -406,7 +406,7 @@ fn test_exporting_merged_cells() {
             .worksheets
             .first()
             .unwrap()
-            .merged_cells_list
+            .merge_cells
             .clone();
         // exporting and saving it in another xlsx
         model.evaluate();
@@ -423,7 +423,7 @@ fn test_exporting_merged_cells() {
                 .worksheets
                 .first()
                 .unwrap()
-                .merged_cells_list
+                .merge_cells
                 .clone();
             assert_eq!(expected_merge_cell_ref, *got_merge_cell_ref);
             fs::remove_file(temp_file_name).unwrap();
@@ -437,7 +437,7 @@ fn test_exporting_merged_cells() {
                 .worksheets
                 .get_mut(0)
                 .unwrap()
-                .merged_cells_list
+                .merge_cells
                 .clear();
 
             save_to_xlsx(&temp_model, temp_file_name).unwrap();
@@ -447,7 +447,7 @@ fn test_exporting_merged_cells() {
                 .worksheets
                 .first()
                 .unwrap()
-                .merged_cells_list
+                .merge_cells
                 .len();
             assert!(*got_merge_cell_ref_cnt == 0);
         }
@@ -494,73 +494,3 @@ fn test_documentation_xlsx() {
     }
     fs::remove_dir_all(&dir).unwrap();
 }
-
-#[test]
-fn test_merge_cell_import_export_behaviors() {
-    // loading the xlsx file containing merged cells
-    let example_file_name = "tests/Merged_cells.xlsx";
-    let mut model = load_from_xlsx(example_file_name, "en", "UTC").unwrap();
-
-    // Case1 : To check whether Merge cells structures got imported properly or not
-    let imported_merge_cell_vec = model.workbook.worksheet(0).unwrap().get_merged_cells_list();
-
-    assert_eq!(imported_merge_cell_vec.len(), 5);
-    let range_refs_of_merge_cell: Vec<String> = imported_merge_cell_vec
-        .iter()
-        .map(|cell| cell.get_merged_cells_str_ref().unwrap())
-        .collect();
-    assert_eq!(
-        range_refs_of_merge_cell,
-        [
-            "C1:D3".to_string(),
-            "A1:B4".to_string(),
-            "G1:H7".to_string(),
-            "D8:E9".to_string(),
-            "D4:F6".to_string()
-        ]
-    );
-
-    // Create one More Merge cell which Overlaps with 3 More
-    model.merge_cells(0, "A1:D5").unwrap();
-    model
-        .set_user_input(0, 1, 1, "New overlapped Merge cell".to_string())
-        .unwrap();
-
-    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
-    style.font.b = true;
-    assert_eq!(
-        model.workbook.styles.create_named_style("bold", &style),
-        Ok(())
-    );
-
-    model.set_cell_style_by_name(0, 1, 1, "bold").unwrap();
-
-    // Lets export to different Excell
-    let exported_merge_cell_xlsx = "temporary_exported_mergecells.xlsx";
-    save_to_xlsx(&model, exported_merge_cell_xlsx).unwrap();
-
-    {
-        let temp_model = load_from_xlsx(exported_merge_cell_xlsx, "en", "UTC").unwrap();
-        // Loading the exported sheet back and verifying whether it got exported properly or not
-        let imported_merge_cell_vec = temp_model
-            .workbook
-            .worksheet(0)
-            .unwrap()
-            .get_merged_cells_list();
-
-        assert_eq!(imported_merge_cell_vec.len(), 3);
-        let range_refs_of_merge_cell: Vec<String> = imported_merge_cell_vec
-            .iter()
-            .map(|cell| cell.get_merged_cells_str_ref().unwrap())
-            .collect();
-        assert_eq!(
-            range_refs_of_merge_cell,
-            [
-                "G1:H7".to_string(),
-                "D8:E9".to_string(),
-                "A1:D5".to_string()
-            ]
-        );
-    }
-    fs::remove_file(exported_merge_cell_xlsx).unwrap();
-}