From 496c13e7b448fe57caa3cfe191368f6c8ac58172 Mon Sep 17 00:00:00 2001 From: Hamza Date: Mon, 16 Nov 2026 20:04:07 +0500 Subject: [PATCH 1/2] XLSX: keep Page Setup's first page number A sheet set to First page number 7 has pageSetup firstPageNumber="7" useFirstPageNumber="1"; neither attribute was read, so a save reset it to Automatic. PrintSettings now holds it (None for Automatic), the reader takes the number when useFirstPageNumber is on, and the writer writes both in the schema's order. A JSON workbook leaves it out when Automatic, so existing files are written as before. Fixes #4293 --- crates/model/src/features/print.rs | 19 +++++++++++++++ crates/xlsx/src/sheet_read.rs | 2 ++ crates/xlsx/src/sheet_write.rs | 7 ++++++ crates/xlsx/src/tests/page_order.rs | 36 +++++++++++++++++++++++++++++ crates/xlsx/src/tests/roundtrip.rs | 1 + 5 files changed, 65 insertions(+) diff --git a/crates/model/src/features/print.rs b/crates/model/src/features/print.rs index 694c2ac6d..c4cf82bad 100644 --- a/crates/model/src/features/print.rs +++ b/crates/model/src/features/print.rs @@ -53,6 +53,11 @@ pub struct PrintSettings { /// sheet is more than one page wide and tall. #[serde(default)] pub page_order: PageOrder, + /// Page Setup › Page › First page number: the number the sheet's first printed page takes, + /// or `None` for Automatic (XLSX `pageSetup firstPageNumber` with `useFirstPageNumber`). Left + /// out of a JSON workbook when Automatic, so files without it are written as before. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub first_page_number: Option, } fn yes() -> bool { @@ -187,6 +192,7 @@ impl Default for PrintSettings { hf_scale_with_doc: true, hf_align_with_margins: true, page_order: PageOrder::DownThenOver, + first_page_number: None, } } } @@ -281,4 +287,17 @@ mod tests { p = serde_json::from_value(saved).unwrap(); assert_eq!(p, PrintSettings::default()); } + + #[test] + fn first_page_number_is_saved_only_when_set() { + // Automatic writes nothing, so a JSON workbook without a first page number is unchanged and + // one saved before the field existed loads as Automatic. + let saved = serde_json::to_value(PrintSettings::default()).unwrap(); + assert!(saved.get("first_page_number").is_none(), "{saved}"); + assert_eq!(serde_json::from_value::(saved).unwrap().first_page_number, None); + let p = PrintSettings { first_page_number: Some(7), ..Default::default() }; + let saved = serde_json::to_value(&p).unwrap(); + assert_eq!(saved["first_page_number"], 7); + assert_eq!(serde_json::from_value::(saved).unwrap(), p); + } } diff --git a/crates/xlsx/src/sheet_read.rs b/crates/xlsx/src/sheet_read.rs index f2ec76683..eedf13120 100644 --- a/crates/xlsx/src/sheet_read.rs +++ b/crates/xlsx/src/sheet_read.rs @@ -267,6 +267,8 @@ pub fn read_sheet(cx: &mut Ctx<'_>, part: &str, name: &str) -> Result<(Sheet, cr } // `downThenOver` when absent (ECMA-376's default); an unknown value reads as that too. sheet.print.page_order = e.attr("pageOrder").and_then(PageOrder::parse).unwrap_or_default(); + // The number counts only when `useFirstPageNumber` says so; otherwise it's Automatic. + sheet.print.first_page_number = e.flag("useFirstPageNumber", false).then(|| e.attr_u32("firstPageNumber")).flatten(); if let Some(p) = e.attr_u32("paperSize").and_then(paper_name) { sheet.print.paper = p.to_string(); } diff --git a/crates/xlsx/src/sheet_write.rs b/crates/xlsx/src/sheet_write.rs index c405667b1..0e63c5524 100644 --- a/crates/xlsx/src/sheet_write.rs +++ b/crates/xlsx/src/sheet_write.rs @@ -409,6 +409,9 @@ fn write_sheet_printing<'a>(s: &mut String, sheet: &'a Sheet, rels: &mut Rels, o if p.scale != 100 && (10..=400).contains(&p.scale) { let _ = write!(s, " scale=\"{}\"", p.scale); } + if let Some(n) = p.first_page_number { + let _ = write!(s, " firstPageNumber=\"{n}\""); + } if let Some((w, h)) = p.fit_to { let _ = write!(s, " fitToWidth=\"{w}\" fitToHeight=\"{h}\""); } @@ -417,6 +420,10 @@ fn write_sheet_printing<'a>(s: &mut String, sheet: &'a Sheet, rels: &mut Rels, o let _ = write!(s, " pageOrder=\"{}\"", p.page_order.id()); } let _ = write!(s, " orientation=\"{}\"", if p.orientation == Orientation::Landscape { "landscape" } else { "portrait" }); + // In the schema's attribute order, as Excel writes it: after the orientation. + if p.first_page_number.is_some() { + s.push_str(" useFirstPageNumber=\"1\""); + } if let Some(id) = kept.page_setup_id() { let _ = write!(s, " r:id=\"{id}\""); } diff --git a/crates/xlsx/src/tests/page_order.rs b/crates/xlsx/src/tests/page_order.rs index b74dc6f96..7e616ace5 100644 --- a/crates/xlsx/src/tests/page_order.rs +++ b/crates/xlsx/src/tests/page_order.rs @@ -73,3 +73,39 @@ fn page_margins_are_written_as_their_decimals() { let xml = sheet_xml(&write_xlsx(&Workbook::new()).unwrap()); assert!(xml.contains(r#""#), "{xml}"); } + +#[test] +fn first_page_number_is_read_and_written_back() { + // #4293: Excel writes Page Setup's First page number 7 as these two attributes; both were lost. + let body = r#""#; + let (wb, _) = read_xlsx(&minimal(body, &[], "", "")).unwrap(); + assert_eq!(wb.sheet(0).unwrap().print.first_page_number, Some(7)); + let bytes = write_xlsx(&wb).unwrap(); + let xml = sheet_xml(&bytes); + assert_eq!(page_setup(&xml), r#""#); + let (back, _) = read_xlsx(&bytes).unwrap(); + assert_eq!(back.sheet(0).unwrap().print.first_page_number, Some(7)); + // In the schema's order with the other attributes: after the scale, before Fit To. + let mut wb = back; + wb.sheet_mut(0).unwrap().print.scale = 80; + wb.sheet_mut(0).unwrap().print.fit_to = Some((1, 2)); + let xml = sheet_xml(&write_xlsx(&wb).unwrap()); + assert!(page_setup(&xml).contains(r#"scale="80" firstPageNumber="7" fitToWidth="1""#), "{xml}"); + // Automatic: no number, a number Excel keeps without using it, and `useFirstPageNumber="0"`. + for body in [ + r#""#, + r#""#, + r#""#, + "", + ] { + let (wb, _) = read_xlsx(&minimal(body, &[], "", "")).unwrap(); + assert_eq!(wb.sheet(0).unwrap().print.first_page_number, None, "{body}"); + let xml = sheet_xml(&write_xlsx(&wb).unwrap()); + assert!(!xml.contains("irstPageNumber"), "{body}: {xml}"); + } + // 1 is a number of its own (Excel's field shows 1, not Automatic) and is kept too. + let mut wb = Workbook::new(); + wb.sheet_mut(0).unwrap().print.first_page_number = Some(1); + let xml = sheet_xml(&write_xlsx(&wb).unwrap()); + assert!(xml.contains(r#"firstPageNumber="1""#) && xml.contains(r#"useFirstPageNumber="1""#), "{xml}"); +} diff --git a/crates/xlsx/src/tests/roundtrip.rs b/crates/xlsx/src/tests/roundtrip.rs index da88df3d9..8f29b28de 100644 --- a/crates/xlsx/src/tests/roundtrip.rs +++ b/crates/xlsx/src/tests/roundtrip.rs @@ -310,6 +310,7 @@ fn sample() -> Workbook { hf_scale_with_doc: false, hf_align_with_margins: true, page_order: PageOrder::OverThenDown, + first_page_number: Some(7), }; s.sparklines.push(Sparkline { cell: at("J2"), source: "B2:B3".into(), kind: SparklineKind::WinLoss, color: Color::Rgb(0x112233), markers: true }); s.tables.push(Table { From 8d8716cdc0ea15553132c2002585f6bbadbb2577 Mon Sep 17 00:00:00 2001 From: Hamza Date: Mon, 16 Nov 2026 20:10:00 +0500 Subject: [PATCH 2/2] XLSX: a hidden Total Row keeps its calculations A table whose Total Row was turned off still holds each column's total: Excel writes totalsRowFunction, totalsRowLabel and a custom totalsRowFormula without totalsRowCount, and restores them when the row is turned back on. The reader took them, but the writer wrote them only while the row was shown, so a save lost a custom formula or an Average and Excel brought back SUBTOTAL(109,...) instead. They are now written whether the row is shown or not. Fixes #4296 --- crates/xlsx/src/sheet_write/parts.rs | 38 +++++++-------- crates/xlsx/src/tests/roundtrip.rs | 70 ++++++++++++++++++++++++++++ 2 files changed, 89 insertions(+), 19 deletions(-) diff --git a/crates/xlsx/src/sheet_write/parts.rs b/crates/xlsx/src/sheet_write/parts.rs index eab48d097..2c0c5b483 100644 --- a/crates/xlsx/src/sheet_write/parts.rs +++ b/crates/xlsx/src/sheet_write/parts.rs @@ -142,27 +142,27 @@ pub(super) fn table_xml(t: &Table, cols: &[String], name: &str, id: u32, out: &m } let _ = write!(s, " name=\"{}\"", esc_attr(&encode_xstring(name))); let totals = col.map(|c| c.totals).unwrap_or_default(); - if t.totals_row { - let f = match totals { - TotalsFn::None => None, - TotalsFn::Average => Some("average"), - TotalsFn::Count => Some("count"), - TotalsFn::CountNums => Some("countNums"), - TotalsFn::Max => Some("max"), - TotalsFn::Min => Some("min"), - TotalsFn::Sum => Some("sum"), - TotalsFn::StdDev => Some("stdDev"), - TotalsFn::Var => Some("var"), - TotalsFn::Custom => Some("custom"), - }; - if let Some(f) = f { - let _ = write!(s, " totalsRowFunction=\"{f}\""); - } else if let Some(l) = col.and_then(|c| c.totals_label.as_ref()) { - let _ = write!(s, " totalsRowLabel=\"{}\"", esc_attr(l)); - } + // A hidden Total Row keeps each column's calculation, as Excel's files do: turning the row + // back on restores it (#4296). The reader takes them whether the row is shown or not. + let f = match totals { + TotalsFn::None => None, + TotalsFn::Average => Some("average"), + TotalsFn::Count => Some("count"), + TotalsFn::CountNums => Some("countNums"), + TotalsFn::Max => Some("max"), + TotalsFn::Min => Some("min"), + TotalsFn::Sum => Some("sum"), + TotalsFn::StdDev => Some("stdDev"), + TotalsFn::Var => Some("var"), + TotalsFn::Custom => Some("custom"), + }; + if let Some(f) = f { + let _ = write!(s, " totalsRowFunction=\"{f}\""); + } else if let Some(l) = col.and_then(|c| c.totals_label.as_ref()) { + let _ = write!(s, " totalsRowLabel=\"{}\"", esc_attr(l)); } let calc = col.and_then(|c| c.formula.as_ref()).filter(|f| !f.is_empty()); - let custom = if t.totals_row && totals == TotalsFn::Custom { col.and_then(|c| c.totals_label.as_ref()) } else { None }; + let custom = if totals == TotalsFn::Custom { col.and_then(|c| c.totals_label.as_ref()) } else { None }; let xml = col.and_then(|c| c.xml.as_ref()); if calc.is_none() && custom.is_none() && xml.is_none() { s.push_str("/>"); diff --git a/crates/xlsx/src/tests/roundtrip.rs b/crates/xlsx/src/tests/roundtrip.rs index da88df3d9..c2a4e1902 100644 --- a/crates/xlsx/src/tests/roundtrip.rs +++ b/crates/xlsx/src/tests/roundtrip.rs @@ -1406,6 +1406,76 @@ fn table_newline_column_and_backslash_name_survive() { assert!(gridcraft_formula::parse("COUNTA(\\_Prime.1[Name])").is_ok(), "backslash table name parses as a structured reference"); } +/// #4296: a table whose Total Row is turned off keeps each column's calculation in the file, as +/// Excel writes it, so turning the row back on in Excel restores a custom formula or Average. +#[test] +fn hidden_total_row_keeps_its_calculations() { + let col = |name: &str, totals: TotalsFn, label: Option<&str>| TableColumn { + name: name.into(), + totals, + totals_label: label.map(str::to_string), + formula: None, + unique_name: None, + xml: None, + }; + let mut wb = Workbook::new(); + let s = wb.sheet_mut(0).unwrap(); + s.tables.push(Table { + id: 1, + name: "Table1".into(), + range: rr("A1:C3"), + header_row: true, + totals_row: false, + columns: vec![ + col("Group", TotalsFn::None, Some("Total")), + col("Amount", TotalsFn::Custom, Some("SUM(B2:B3)+10")), + col("Mean", TotalsFn::Average, None), + ], + style: "TableStyleMedium2".into(), + banded_rows: true, + banded_cols: false, + first_col: false, + last_col: false, + filter_button: true, + filter: vec![], + table_type: None, + connection_id: None, + }); + let bytes = write_xlsx(&wb).unwrap(); + let mut xml = String::new(); + zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap().by_name("xl/tables/table1.xml").unwrap().read_to_string(&mut xml).unwrap(); + // Still a table without a total row: no totalsRowCount, and its range unchanged. + assert!(xml.contains(r#"ref="A1:C3""#) && xml.contains(r#"totalsRowShown="0""#) && !xml.contains("totalsRowCount"), "{xml}"); + for part in [ + r#"name="Group" totalsRowLabel="Total"/>"#, + r#"name="Amount" totalsRowFunction="custom">SUM(B2:B3)+10"#, + r#"name="Mean" totalsRowFunction="average"/>"#, + ] { + assert!(xml.contains(part), "{part}: {xml}"); + } + let (back, report) = read_xlsx(&bytes).unwrap(); + assert!(report.warnings.is_empty(), "{:?}", report.warnings); + let t = &back.sheet(0).unwrap().tables[0]; + assert!(!t.totals_row); + assert_eq!(t.range.a1(), "A1:C3"); + let got: Vec<_> = t.columns.iter().map(|c| (c.totals, c.totals_label.clone())).collect(); + assert_eq!(got, vec![(TotalsFn::None, Some("Total".into())), (TotalsFn::Custom, Some("SUM(B2:B3)+10".into())), (TotalsFn::Average, None)]); + // A table that never had a total row writes no calculation. + let mut plain = wb.clone(); + plain.sheet_mut(0).unwrap().tables[0].columns = + vec![col("Group", TotalsFn::None, None), col("Amount", TotalsFn::None, None), col("Mean", TotalsFn::None, None)]; + let mut xml = String::new(); + zip::ZipArchive::new(std::io::Cursor::new(write_xlsx(&plain).unwrap())) + .unwrap() + .by_name("xl/tables/table1.xml") + .unwrap() + .read_to_string(&mut xml) + .unwrap(); + for attr in ["totalsRowFunction", "totalsRowLabel", "totalsRowFormula"] { + assert!(!xml.contains(attr), "{attr}: {xml}"); + } +} + /// A table that is only a header row and a totals row (Insert Table on one row, then Total /// Row) is written like the header-only and one-data-row shapes, not dropped on save. #[test]