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

UPDATE: Merge cells

Browse Source
This commit is contained in:
Nicolás Hatcher
2025-03-01 11:21:00 +01:00
parent c554d929f4
commit 48727b1b39
21 changed files with 513 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
base/src/cell.rs
View File

@@ -89,6 +89,8 @@ impl Cell {
Cell::CellFormulaNumber { s, .. } => *s = style,
Cell::CellFormulaString { s, .. } => *s = style,
Cell::CellFormulaError { s, .. } => *s = style,
// Should we throw an error here?
Cell::Merged { .. } => {}
};
}
@@ -104,6 +106,8 @@ impl Cell {
Cell::CellFormulaNumber { s, .. } => *s,
Cell::CellFormulaString { s, .. } => *s,
Cell::CellFormulaError { s, .. } => *s,
// A merged cell has no style
Cell::Merged { .. } => 0,
}
}
@@ -119,6 +123,7 @@ impl Cell {
Cell::CellFormulaNumber { .. } => CellType::Number,
Cell::CellFormulaString { .. } => CellType::Text,
Cell::CellFormulaError { .. } => CellType::ErrorValue,
Cell::Merged { .. } => CellType::Number,
}
}
@@ -156,6 +161,7 @@ impl Cell {
let v = ei.to_localized_error_string(language);
CellValue::String(v)
}
Cell::Merged { .. } => CellValue::None,
}
}

1
base/src/lib.rs
View File

@@ -59,6 +59,7 @@ pub mod mock_time;
pub use model::get_milliseconds_since_epoch;
pub use model::Model;
pub use model::CellStructure;
pub use user_model::BorderArea;
pub use user_model::ClipboardData;
pub use user_model::UserModel;

112
base/src/model.rs
View File

@@ -31,6 +31,7 @@ use crate::{
};
use chrono_tz::Tz;
use serde::{Deserialize, Serialize};
#[cfg(test)]
pub use crate::mock_time::get_milliseconds_since_epoch;
@@ -72,6 +73,27 @@ pub(crate) enum CellState {
Evaluating,
}
/// Cell structure indicates if the cell is part of a merged cell or not
#[derive(Clone, Serialize, Deserialize)]
pub enum CellStructure {
/// The cell is not part of a merged cell
Simple,
/// The cell is part of a merged cell, and teh root cell is (row, column)
Merged {
/// Row of the root cell
row: i32,
/// Column of the root cell
column: i32,
},
/// The cell is the root of a merged cell of dimensions (width, height)
MergedRoot {
/// Width of the merged cell
width: i32,
/// Height of the merged cell
height: i32,
},
}
/// A parsed formula for a defined name
#[derive(Clone)]
pub(crate) enum ParsedDefinedName {
@@ -751,6 +773,7 @@ impl Model {
}
}
}
Merged { .. } => CalcResult::EmptyCell,
}
}
@@ -1438,6 +1461,10 @@ impl Model {
value: String,
) -> Result<(), String> {
// If value starts with "'" then we force the style to be quote_prefix
let cell = self.workbook.worksheet(sheet)?.cell(row, column);
if matches!(cell, Some(Cell::Merged { .. })) {
return Err("Cannot set value on merged cell".to_string());
}
let style_index = self.get_cell_style_index(sheet, row, column)?;
if let Some(new_value) = value.strip_prefix('\'') {
// First check if it needs quoting
@@ -2258,6 +2285,91 @@ impl Model {
pub fn delete_row_style(&mut self, sheet: u32, row: i32) -> Result<(), String> {
self.workbook.worksheet_mut(sheet)?.delete_row_style(row)
}
/// Returns the geometric structure of a cell
pub fn get_cell_structure(
&self,
sheet: u32,
row: i32,
column: i32,
) -> Result<CellStructure, String> {
let worksheet = self.workbook.worksheet(sheet)?;
worksheet.get_cell_structure(row, column)
}
/// Merges cells
pub fn merge_cells(
&mut self,
sheet: u32,
row: i32,
column: i32,
width: i32,
height: i32,
) -> Result<(), String> {
let worksheet = self.workbook.worksheet_mut(sheet)?;
let sheet_data = &mut worksheet.sheet_data;
// First check that it is possible to merge the cells
for r in row..(row + height) {
for c in column..(column + width) {
if let Some(Cell::Merged { .. }) =
sheet_data.get(&r).and_then(|row_data| row_data.get(&c))
{
return Err("Cannot merge cells".to_string());
}
}
}
worksheet
.merged_cells
.insert((row, column), (width, height));
for r in row..(row + height) {
for c in column..(column + width) {
// We remove everything except the "root" cell:
if r == row && c == column {
continue;
}
if let Some(row_data) = sheet_data.get_mut(&r) {
row_data.remove(&c);
row_data.insert(c, Cell::Merged { r: row, c: column });
} else {
let mut row_data = HashMap::new();
row_data.insert(c, Cell::Merged { r: row, c: column });
sheet_data.insert(r, row_data);
}
}
}
Ok(())
}
/// Unmerges cells
pub fn unmerge_cells(&mut self, sheet: u32, row: i32, column: i32) -> Result<(), String> {
let s = self.get_cell_style_index(sheet, row, column)?;
let worksheet = self.workbook.worksheet_mut(sheet)?;
let sheet_data = &mut worksheet.sheet_data;
let (width, height) = match worksheet.merged_cells.get(&(row, column)) {
Some((w, h)) => (*w, *h),
None => return Ok(()),
};
worksheet.merged_cells.remove(&(row, column));
for r in row..(row + width) {
for c in column..(column + height) {
// We remove everything except the "root" cell:
if r == row && c == column {
continue;
}
if let Some(row_data) = sheet_data.get_mut(&r) {
row_data.remove(&c);
if s != 0 {
row_data.insert(c, Cell::EmptyCell { s });
}
} else if s != 0 {
let mut row_data = HashMap::new();
row_data.insert(c, Cell::EmptyCell { s });
sheet_data.insert(r, row_data);
}
}
}
Ok(())
}
}
#[cfg(test)]

2
base/src/new_empty.rs
View File

@@ -58,10 +58,10 @@ impl Model {
rows: vec![],
comments: vec![],
dimension: "A1".to_string(),
merge_cells: vec![],
name: name.to_string(),
shared_formulas: vec![],
sheet_data: Default::default(),
merged_cells: HashMap::new(),
sheet_id,
state: SheetState::Visible,
color: Default::default(),

7
base/src/types.rs
View File

@@ -110,7 +110,7 @@ pub struct Worksheet {
pub sheet_id: u32,
pub state: SheetState,
pub color: Option<String>,
pub merge_cells: Vec<String>,
pub merged_cells: HashMap<(i32, i32), (i32, i32)>,
pub comments: Vec<Comment>,
pub frozen_rows: i32,
pub frozen_columns: i32,
@@ -217,7 +217,10 @@ pub enum Cell {
// Error Message: "Not implemented function"
m: String,
},
// TODO: Array formulas
Merged {
r: i32,
c: i32,
}, // TODO: Array formulas
}
impl Default for Cell {

110
base/src/user_model/common.rs
View File

@@ -11,7 +11,7 @@ use crate::{
types::{Area, CellReferenceIndex},
utils::{is_valid_column_number, is_valid_row},
},
model::Model,
model::{CellStructure, Model},
types::{
Alignment, BorderItem, CellType, Col, HorizontalAlignment, SheetProperties, SheetState,
Style, VerticalAlignment,
@@ -1869,6 +1869,57 @@ impl UserModel {
Ok(())
}
/// Merges cells
pub fn merge_cells(
&mut self,
sheet: u32,
row: i32,
column: i32,
width: i32,
height: i32,
) -> Result<(), String> {
let old_data = Vec::new();
let diff_list = vec![Diff::MergeCells {
sheet,
row,
column,
width,
height,
old_data,
}];
self.model.merge_cells(sheet, row, column, width, height)?;
self.push_diff_list(diff_list);
self.evaluate_if_not_paused();
Ok(())
}
/// Check if cell is part of a merged cell
pub fn get_cell_structure(&self, sheet: u32, row: i32, column: i32) -> Result<CellStructure, String> {
self.model.get_cell_structure(sheet, row, column)
}
/// Unmerges cells
pub fn unmerge_cells(&mut self, sheet: u32, row: i32, column: i32) -> Result<(), String> {
let (width, height) = self
.model
.workbook
.worksheet(sheet)?
.merged_cells
.get(&(row, column))
.ok_or("No merged cells found")?;
let diff_list = vec![Diff::UnmergeCells {
sheet,
row,
column,
width: *width,
height: *height,
}];
self.model.unmerge_cells(sheet, row, column)?;
self.push_diff_list(diff_list);
self.evaluate_if_not_paused();
Ok(())
}
// **** Private methods ****** //
pub(crate) fn push_diff_list(&mut self, diff_list: DiffList) {
@@ -2112,7 +2163,6 @@ impl UserModel {
worksheet.frozen_rows = old_data.frozen_rows;
worksheet.state = old_data.state.clone();
worksheet.color = old_data.color.clone();
worksheet.merge_cells = old_data.merge_cells.clone();
worksheet.shared_formulas = old_data.shared_formulas.clone();
self.model.reset_parsed_structures();
@@ -2163,6 +2213,34 @@ impl UserModel {
self.model.delete_row_style(*sheet, *row)?;
}
}
Diff::MergeCells {
sheet,
row,
column,
width,
height,
old_data,
} => {
needs_evaluation = true;
self.model.unmerge_cells(*sheet, *row, *column)?;
// for (r, c, v) in old_data.iter() {
// self.model
// .workbook
// .worksheet_mut(*sheet)?
// .update_cell(*r, *c, v.clone())?;
// }
}
Diff::UnmergeCells {
sheet,
row,
column,
width,
height,
} => {
needs_evaluation = true;
self.model
.merge_cells(*sheet, *row, *column, *width, *height)?;
}
}
}
if needs_evaluation {
@@ -2364,6 +2442,34 @@ impl UserModel {
} => {
self.model.delete_row_style(*sheet, *row)?;
}
Diff::MergeCells {
sheet,
row,
column,
width,
height,
old_data: _,
} => {
needs_evaluation = true;
self.model
.merge_cells(*sheet, *row, *column, *width, *height)?;
// for (r, c, v) in old_data.iter() {
// self.model
// .workbook
// .worksheet_mut(*sheet)?
// .update_cell(*r, *c, v.clone())?;
// }
}
Diff::UnmergeCells {
sheet,
row,
column,
width,
height,
} => {
needs_evaluation = true;
self.model.unmerge_cells(*sheet, *row, *column)?;
}
}
}

16
base/src/user_model/history.rs
View File

@@ -161,7 +161,21 @@ pub(crate) enum Diff {
new_scope: Option<u32>,
new_formula: String,
},
// FIXME: we are missing SetViewDiffs
MergeCells {
sheet: u32,
row: i32,
column: i32,
width: i32,
height: i32,
old_data: Vec<(Cell, Style)>,
},
UnmergeCells {
sheet: u32,
row: i32,
column: i32,
width: i32,
height: i32,
}, // FIXME: we are missing SetViewDiffs
}
pub(crate) type DiffList = Vec<Diff>;

136
base/src/user_model/ui.rs
View File

@@ -2,7 +2,10 @@
use serde::{Deserialize, Serialize};
use crate::expressions::utils::{is_valid_column_number, is_valid_row};
use crate::{
expressions::utils::{is_valid_column_number, is_valid_row},
CellStructure,
};
use super::common::UserModel;
@@ -97,26 +100,47 @@ impl UserModel {
if !is_valid_row(row) {
return Err(format!("Invalid row: '{row}'"));
}
if self.model.workbook.worksheet(sheet).is_err() {
return Err(format!("Invalid worksheet index {}", sheet));
}
if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
if let Some(view) = worksheet.views.get_mut(&0) {
view.row = row;
view.column = column;
view.range = [row, column, row, column];
let worksheet = self.model.workbook.worksheet_mut(sheet)?;
let structure = worksheet.get_cell_structure(row, column)?;
// check if the selected cell is a merged cell
let [row_start, columns_start, row_end, columns_end] = match structure {
CellStructure::Simple => [row, column, row, column],
CellStructure::Merged {
row: row_start,
column: column_start,
} => {
let (width, height) = match worksheet.merged_cells.get(&(row_start, column_start)) {
Some(s) => s,
None => return Err(format!("Merged cell not found: ({row_start}, {column_start}) when clicking at ({row}, {column}).")),
};
let row_end = row_start + height - 1;
let column_end = column_start + width - 1;
[row_start, column_start, row_end, column_end]
}
CellStructure::MergedRoot { width, height } => {
let row_start = row;
let columns_start = column;
let row_end = row + height - 1;
let columns_end = column + width - 1;
[row_start, columns_start, row_end, columns_end]
}
};
if let Some(view) = worksheet.views.get_mut(&0) {
view.row = row_start;
view.column = columns_start;
view.range = [row_start, columns_start, row_end, columns_end];
}
Ok(())
}
/// Sets the selected range. Note that the selected cell must be in one of the corners.
pub fn set_selected_range(
&mut self,
start_row: i32,
start_column: i32,
end_row: i32,
end_column: i32,
row_start: i32,
column_start: i32,
row_end: i32,
column_end: i32,
) -> Result<(), String> {
let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
view.sheet
@@ -124,42 +148,72 @@ impl UserModel {
0
};
if !is_valid_column_number(start_column) {
return Err(format!("Invalid column: '{start_column}'"));
if !is_valid_column_number(column_start) {
return Err(format!("Invalid column: '{column_start}'"));
}
if !is_valid_row(start_row) {
return Err(format!("Invalid row: '{start_row}'"));
if !is_valid_row(row_start) {
return Err(format!("Invalid row: '{row_start}'"));
}
if !is_valid_column_number(end_column) {
return Err(format!("Invalid column: '{end_column}'"));
if !is_valid_column_number(column_end) {
return Err(format!("Invalid column: '{column_end}'"));
}
if !is_valid_row(end_row) {
return Err(format!("Invalid row: '{end_row}'"));
if !is_valid_row(row_end) {
return Err(format!("Invalid row: '{row_end}'"));
}
if self.model.workbook.worksheet(sheet).is_err() {
return Err(format!("Invalid worksheet index {}", sheet));
}
if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
if let Some(view) = worksheet.views.get_mut(&0) {
let selected_row = view.row;
let selected_column = view.column;
// The selected cells must be on one of the corners of the selected range:
if selected_row != start_row && selected_row != end_row {
return Err(format!(
"The selected cells is not in one of the corners. Row: '{}' and row range '({}, {})'",
selected_row, start_row, end_row
));
let mut start_row = row_start;
let mut start_column = column_start;
let mut end_row = row_end;
let mut end_column = column_end;
let worksheet = self.model.workbook.worksheet_mut(sheet)?;
let merged_cells = &worksheet.merged_cells;
if !merged_cells.is_empty() {
// We need to check if there are merged cells in the selected range
for row in row_start..=row_end {
for column in column_start..=column_end {
let structure = &worksheet.get_cell_structure(row, column)?;
match structure {
CellStructure::Simple => {}
CellStructure::Merged { row: r, column: c } => {
// The selected range must contain the merged cell
let (width, height) = match merged_cells.get(&(*r, *c)) {
Some(s) => s,
None => return Err(format!("Merged cell not found: ({r}, {c}) when selecting range ({start_row}, {start_column}, {end_row}, {end_column}).")),
};
start_row = start_row.min(*r);
start_column = start_column.min(*c);
end_row = end_row.max(*r + height - 1);
end_column = end_column.max(*c + width - 1);
}
CellStructure::MergedRoot { width, height } => {
// The selected range must contain the merged cell
end_row = end_row.max(row + height - 1);
end_column = end_column.max(column + width - 1);
}
}
}
if selected_column != start_column && selected_column != end_column {
return Err(format!(
"The selected cells is not in one of the corners. Column '{}' and column range '({}, {})'",
selected_column, start_column, end_column
));
}
view.range = [start_row, start_column, end_row, end_column];
}
}
if let Some(view) = worksheet.views.get_mut(&0) {
// let selected_row = view.row;
// let selected_column = view.column;
// // The selected cells must be on one of the corners of the selected range:
// if selected_row != start_row && selected_row != end_row {
// return Err(format!(
// "The selected cells is not in one of the corners. Row: '{}' and row range '({}, {})'",
// selected_row, start_row, end_row
// ));
// }
// if selected_column != start_column && selected_column != end_column {
// return Err(format!(
// "The selected cells is not in one of the corners. Column '{}' and column range '({}, {})'",
// selected_column, start_column, end_column
// ));
// }
view.range = [start_row, start_column, end_row, end_column];
}
Ok(())
}

19
base/src/worksheet.rs
View File

@@ -1,6 +1,7 @@
use crate::constants::{self, LAST_COLUMN, LAST_ROW};
use crate::expressions::types::CellReferenceIndex;
use crate::expressions::utils::{is_valid_column_number, is_valid_row};
use crate::CellStructure;
use crate::{expressions::token::Error, types::*};
use std::collections::HashMap;
@@ -38,6 +39,24 @@ impl Worksheet {
self.sheet_data.get(&row)?.get(&column)
}
pub fn get_cell_structure(&self, row: i32, column: i32) -> Result<CellStructure, String> {
if let Some((width, height)) = self.merged_cells.get(&(row, column)) {
return Ok(CellStructure::MergedRoot {
width: *width,
height: *height,
});
}
let cell = self.cell(row, column);
if let Some(Cell::Merged { r, c }) = cell {
return Ok(CellStructure::Merged {
row: *r,
column: *c,
});
}
Ok(CellStructure::Simple)
}
pub(crate) fn cell_mut(&mut self, row: i32, column: i32) -> Option<&mut Cell> {
self.sheet_data.get_mut(&row)?.get_mut(&column)
}