diff --git a/Cargo.lock b/Cargo.lock index d51d6ce04..20fc1c938 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -891,6 +891,17 @@ dependencies = [ "serde", ] +[[package]] +name = "craft-drawingml" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=cff5af869dbf6926801c9ac63a927d155202ba3b#cff5af869dbf6926801c9ac63a927d155202ba3b" +dependencies = [ + "craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=cff5af869dbf6926801c9ac63a927d155202ba3b)", + "kurbo", + "log", + "serde", +] + [[package]] name = "craft-fonts-build" version = "0.1.0" @@ -1064,6 +1075,16 @@ dependencies = [ "thiserror 2.0.21", ] +[[package]] +name = "craft-xml" +version = "0.1.0" +source = "git+https://github.com/storytold/craft-libs?rev=cff5af869dbf6926801c9ac63a927d155202ba3b#cff5af869dbf6926801c9ac63a927d155202ba3b" +dependencies = [ + "quick-xml 0.41.0", + "serde", + "thiserror 2.0.21", +] + [[package]] name = "craft-xml" version = "0.1.0" @@ -1209,7 +1230,7 @@ dependencies = [ name = "deckcraft-color" version = "0.19.0" dependencies = [ - "craft-drawingml", + "craft-drawingml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=44d83fa8f635333dcb3c231f87381387a1f5631b)", ] [[package]] @@ -1266,7 +1287,7 @@ dependencies = [ name = "deckcraft-geom" version = "0.19.0" dependencies = [ - "craft-drawingml", + "craft-drawingml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=44d83fa8f635333dcb3c231f87381387a1f5631b)", "kurbo", "serde", ] @@ -1329,7 +1350,8 @@ name = "deckcraft-pptx" version = "0.19.0" dependencies = [ "craft-cfb", - "craft-drawingml", + "craft-drawingml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=44d83fa8f635333dcb3c231f87381387a1f5631b)", + "craft-drawingml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=cff5af869dbf6926801c9ac63a927d155202ba3b)", "craft-opc", "craft-xml 0.1.0 (git+https://github.com/storytold/craft-libs?rev=ea24422ae9859dc5da398d0462bc87f8e02e0d10)", "deckcraft-color", diff --git a/Cargo.toml b/Cargo.toml index bcb704a2d..b8baca81a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -18,6 +18,8 @@ craft-cfb = { git = "https://github.com/storytold/craft-libs", rev = "ea24422ae9 # XML writer primitives; parser admission and OOXML policy stay app-local. craft-xml = { git = "https://github.com/storytold/craft-libs", rev = "ea24422ae9859dc5da398d0462bc87f8e02e0d10", version = "0.1.0" } # DrawingML colours, themes and text (craft-libs#778, #792): the model DeckCraft reads and writes. +# Isolated table XML writer; existing DrawingML model/readers keep their revision. +craft-drawingml-table = { package = "craft-drawingml", git = "https://github.com/storytold/craft-libs", rev = "cff5af869dbf6926801c9ac63a927d155202ba3b" } craft-drawingml = { git = "https://github.com/storytold/craft-libs", rev = "44d83fa8f635333dcb3c231f87381387a1f5631b", version = "0.1.0" } # internal deckcraft-geom = { path = "crates/geom" } diff --git a/apps/deckcraft-cli/src/main.rs b/apps/deckcraft-cli/src/main.rs index 5701b72f8..420f4f1a5 100644 --- a/apps/deckcraft-cli/src/main.rs +++ b/apps/deckcraft-cli/src/main.rs @@ -148,6 +148,9 @@ fn warn_if_damaged(path: &str, opened: &serde_json::Value) { if slides > 0 { eprintln!("deckcraft-cli: warning: {path}: {slides} slide{} couldn't be read and left out", if slides == 1 { "" } else { "s" }); } + for w in opened.get("importWarnings").and_then(|v| v.as_array()).into_iter().flatten().filter_map(|w| w.as_str()) { + eprintln!("deckcraft-cli: warning: {path}: {w}"); + } if media > 0 { eprintln!("deckcraft-cli: warning: {path}: {media} picture or media file{} couldn't be read", if media == 1 { "" } else { "s" }); } diff --git a/crates/engine/src/cmd.rs b/crates/engine/src/cmd.rs index 38e6c363c..4bf90c3a6 100644 --- a/crates/engine/src/cmd.rs +++ b/crates/engine/src/cmd.rs @@ -433,6 +433,15 @@ pub(crate) fn shape_of(s: &Session, id: ShapeId) -> Result Xfrm { let mut x = shape.xfrm.unwrap_or_else(|| ctx_xfrm(doc, sel, shape)); if let deckcraft_model::ShapeKind::Table(t) = &shape.kind { + // A loaded table may not be normalized yet: measure the bounded grid an edit will + // leave, not every cell the file stored. + let normalized; + let t = if t.is_normalized() { + t + } else { + normalized = t.normalized(); + &normalized + }; let drawn: f64 = table_drawn_heights(doc, sel, t).iter().sum(); if drawn.is_finite() && drawn > x.h { x.h = drawn; diff --git a/crates/engine/src/cmd/file.rs b/crates/engine/src/cmd/file.rs index a1c781f96..744950f4b 100644 --- a/crates/engine/src/cmd/file.rs +++ b/crates/engine/src/cmd/file.rs @@ -139,11 +139,13 @@ pub struct Damage { pub media: Vec, /// Slides a `.pptx` lists but that couldn't be read, so they are not in the presentation. pub slides: Vec, + /// Content a `.pptx` had that was cut to fit a limit; the file still opened. + pub warnings: Vec, } impl Damage { pub fn is_empty(&self) -> bool { - self.media.is_empty() && self.slides.is_empty() + self.media.is_empty() && self.slides.is_empty() && self.warnings.is_empty() } } @@ -151,17 +153,17 @@ impl Damage { pub fn open_checked(name: &str, bytes: &[u8]) -> Result<(Presentation, Damage)> { if deckcraft_format::sniff(bytes) { let (p, media) = deckcraft_format::load_checked(bytes).map_err(|e| EngineError::Other(e.to_string()))?; - return Ok((p, Damage { media, slides: vec![] })); + return Ok((p, Damage { media, ..Default::default() })); } - open_other(name, bytes).map(|(p, slides)| (p, Damage { media: vec![], slides })) + open_other(name, bytes).map(|(p, slides, warnings)| (p, Damage { slides, warnings, ..Default::default() })) } -fn open_other(name: &str, bytes: &[u8]) -> Result<(Presentation, Vec)> { +fn open_other(name: &str, bytes: &[u8]) -> Result<(Presentation, Vec, Vec)> { if deckcraft_pptx::sniff(bytes) { - let (mut p, lost_slides) = deckcraft_pptx::import_checked(bytes).map_err(|e| EngineError::Other(e.to_string()))?; + let (mut p, lost_slides, warnings) = deckcraft_pptx::import_report(bytes).map_err(|e| EngineError::Other(e.to_string()))?; deckcraft_format::repair(&mut p); probe_clips(&mut p); - return Ok((p, lost_slides)); + return Ok((p, lost_slides, warnings)); } if deckcraft_pptx::is_encrypted(bytes) { return Err(EngineError::Other(format!("{name} is password-protected. DeckCraft can't open password-protected presentations yet."))); @@ -180,7 +182,7 @@ fn open_other(name: &str, bytes: &[u8]) -> Result<(Presentation, Vec)> { if p.slides.is_empty() { p = defaults::new_presentation(None); } - return Ok((p, vec![])); + return Ok((p, vec![], vec![])); } Err(EngineError::Other(format!("{name}: not a presentation DeckCraft can read"))) } @@ -276,7 +278,7 @@ fn adopt_loaded(s: &mut Session, f: LoadedFile) -> Result { let st = s.doc()?; Ok(json!({ "document": i, "slides": st.doc.slides.len(), "missingFonts": st.missing_fonts, - "damagedMedia": damaged.media, "lostSlides": damaged.slides, + "damagedMedia": damaged.media, "lostSlides": damaged.slides, "importWarnings": damaged.warnings, })) } @@ -311,7 +313,9 @@ fn open_bytes(s: &mut Session, p: &Value) -> Result { let (doc, damaged) = open_checked(name, &data)?; let i = add_opened(s, name, None, doc); report_damage(s, &damaged)?; - Ok(json!({"document": i, "missingFonts": s.doc()?.missing_fonts, "damagedMedia": damaged.media, "lostSlides": damaged.slides})) + Ok( + json!({"document": i, "missingFonts": s.doc()?.missing_fonts, "damagedMedia": damaged.media, "lostSlides": damaged.slides, "importWarnings": damaged.warnings}), + ) } /// Tell the user which pictures, media and slides a damaged file lost, and mark the copy repaired. @@ -339,6 +343,10 @@ fn report_damage(s: &mut Session, damaged: &Damage) -> Result<()> { if n == 1 { "was" } else { "were" }, )); } + for w in &damaged.warnings { + text.push_str(w); + text.push_str(". "); + } text.push_str("It was opened as a repaired copy; save it under a new name to keep the original file."); s.ui_requests.push(crate::UiRequest::Message { text }); Ok(()) diff --git a/crates/engine/src/cmd/table.rs b/crates/engine/src/cmd/table.rs index 86d753a2c..0034645f8 100644 --- a/crates/engine/src/cmd/table.rs +++ b/crates/engine/src/cmd/table.rs @@ -286,6 +286,12 @@ fn with_table(s: &mut Session, p: &Value, cmd: &str, f: impl Fn(&mut Table) -> R }; let r = edit_shapes(s, &json!({"id": id}), cmd, |sh| match &mut sh.kind { ShapeKind::Table(t) => { + // Edits walk the grid: bound it first (a loaded table need not be normalized yet). + // An over-cap table is refused, not trimmed: a trim would delete rows while reporting success. + if t.over_cap() { + return Err(bad(cmd, format!("the table is larger than {} cells; edit refused", deckcraft_model::table::MAX_CELLS))); + } + t.normalize(); f(t)?; t.normalize(); let (w, h) = (t.width(), t.height()); @@ -319,10 +325,17 @@ fn rows_cols(s: &mut Session, p: &Value, op: &str, name: &'static str) -> Result let op = op.to_string(); with_table(s, p, name, move |t| { match op.as_str() { - "rowAbove" => t.insert_row(r), - "rowBelow" => t.insert_row(r.saturating_add(1)), - "colLeft" => t.insert_col(c), - "colRight" => t.insert_col(c.saturating_add(1)), + "rowAbove" | "rowBelow" | "colLeft" | "colRight" => { + let ok = match op.as_str() { + "rowAbove" => t.insert_row(r), + "rowBelow" => t.insert_row(r.saturating_add(1)), + "colLeft" => t.insert_col(c), + _ => t.insert_col(c.saturating_add(1)), + }; + if !ok { + return Err(bad(name, format!("the table is at its {}-cell limit", deckcraft_model::table::MAX_CELLS))); + } + } "delRow" => { if !t.delete_row(r) { return Err(bad(name, "can't delete the last row")); diff --git a/crates/engine/src/drawtable.rs b/crates/engine/src/drawtable.rs index 2b49b7ac7..8c26e7ad5 100644 --- a/crates/engine/src/drawtable.rs +++ b/crates/engine/src/drawtable.rs @@ -115,7 +115,7 @@ fn split_rows(t: &mut Table, y: f64, x0: f64, x1: f64) -> bool { let b = match ys.iter().position(|e| (e - y).abs() <= SNAP) { Some(b) => b, None => { - if t.rows.len() >= MAX_GRID { + if t.rows.len() >= MAX_GRID || t.cols.len().saturating_mul(t.rows.len().saturating_add(1)) > deckcraft_model::table::MAX_CELLS { return false; } let Some(k) = ys.windows(2).position(|w| w[0] < y && y < w[1]) else { return false }; @@ -273,4 +273,17 @@ mod tests { } assert!(t.rows.len() <= MAX_GRID && n > 100, "{} rows", t.rows.len()); } + + #[test] + fn pencil_refuses_a_row_past_the_cell_cap() { + let cols = 1000; + let rows = deckcraft_model::table::MAX_CELLS / cols; + let mut t = Table { + cols: vec![10.0; cols], + rows: vec![deckcraft_model::table::Row { height: 50.0, cells: vec![Cell::new(""); cols] }; rows], + ..Default::default() + }; + assert!(!draw_line(&mut t, (0.0, 25.0), (10_000.0, 25.0))); + assert_eq!((t.n_rows(), t.n_cols()), (rows, cols)); + } } diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index 66494ea22..7d9fff63b 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -7297,6 +7297,45 @@ fn master_body_placeholder_format_keeps_per_level_formatting() { assert_eq!(shown(&s), vec![Some(28.0), Some(24.0)]); } +#[test] +fn table_edits_past_the_cell_cap_are_refused_not_trimmed() { + use deckcraft_model::table::{MAX_CELLS, Row}; + let mut s = session(); + let id = table_at(&mut s, &[100.0, 100.0], json!([["a", "b"], ["c", "d"]])); + let cols = 200; + let rows = MAX_CELLS / cols; + let big = deckcraft_model::Table { + cols: vec![1.0; cols], + rows: vec![Row { height: 1.0, cells: vec![Default::default(); cols] }; rows], + ..Default::default() + }; + for sl in std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc).slides.iter_mut() { + for sh in std::sync::Arc::make_mut(sl).shapes.iter_mut() { + if sh.id == id { + sh.kind = deckcraft_model::ShapeKind::Table(big.clone()); + } + } + } + for cmd in ["table.insertRowAbove", "table.insertRowBelow"] { + let e = s.execute(cmd, &json!({"id": id.0, "row": 0})).unwrap_err().to_string(); + assert!(e.contains("cell limit"), "{cmd}: {e}"); + } + let e = s.execute("table.insertColumnLeft", &json!({"id": id.0, "col": 0})).unwrap_err().to_string(); + assert!(e.contains("cell limit"), "{e}"); + assert_eq!(table_of(&s, id), big, "a refused insert leaves every row in place"); + // A table already over the cap is refused too, not trimmed behind a success. + let huge = deckcraft_model::Table { rows: vec![Row { height: 1.0, cells: vec![Default::default(); cols] }; rows + 1], ..big.clone() }; + for sl in std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().doc).slides.iter_mut() { + for sh in std::sync::Arc::make_mut(sl).shapes.iter_mut() { + if sh.id == id { + sh.kind = deckcraft_model::ShapeKind::Table(huge.clone()); + } + } + } + assert!(s.execute("table.deleteRow", &json!({"id": id.0, "row": 0})).is_err()); + assert_eq!(table_of(&s, id).n_rows(), rows + 1); +} + /// #2059: Decrease Font Size (Ctrl+[, Cmd+Shift+,) steps down one size at a time from any size: /// PowerPoint's list up to 96, then 8 points at a time above it, as Increase Font Size steps up. /// A size above 66 used to shrink straight to 66. diff --git a/crates/model/src/table.rs b/crates/model/src/table.rs index 118851ecd..9079c4058 100644 --- a/crates/model/src/table.rs +++ b/crates/model/src/table.rs @@ -83,6 +83,12 @@ impl Default for Table { } } +/// Cells a table may hold after [`Table::normalize`] (PowerPoint's own limit is 75 x 75). +pub const MAX_CELLS: usize = 100_000; +/// Cell visits [`Table::merge`] may spend growing its rectangle over existing merges: a few +/// passes over the largest grid, where a real table needs one or two. +const MAX_MERGE_WORK: usize = 16 * MAX_CELLS; + impl Table { pub fn new(rows: usize, cols: usize, width: f64, row_height: f64) -> Self { let rows = rows.clamp(1, 1000); @@ -113,15 +119,24 @@ impl Table { self.rows.iter().map(|r| r.height).sum() } /// Insert an empty row before `at`. A merge the new row falls inside grows to cover it. - pub fn insert_row(&mut self, at: usize) { + /// Returns false, leaving the table as it was, when the row would take it past [`MAX_CELLS`]. + pub fn insert_row(&mut self, at: usize) -> bool { + if self.cols.len().saturating_mul(self.rows.len().saturating_add(1)) > MAX_CELLS { + return false; + } let at = at.min(self.rows.len()); let merges = self.merges(); let h = self.rows.get(at.saturating_sub(1)).map(|r| r.height).unwrap_or(30.0); self.rows.insert(at, Row { height: h, cells: (0..self.cols.len()).map(|_| Cell::new("")).collect() }); self.set_merges(merges.into_iter().map(|m| m.insert_row(at))); + true } /// Insert an empty column before `at`. A merge the new column falls inside grows to cover it. - pub fn insert_col(&mut self, at: usize) { + /// Returns false, leaving the table as it was, when the column would take it past [`MAX_CELLS`]. + pub fn insert_col(&mut self, at: usize) -> bool { + if self.cols.len().saturating_add(1).saturating_mul(self.rows.len()) > MAX_CELLS { + return false; + } let at = at.min(self.cols.len()); let merges = self.merges(); let w = self.cols.get(at.saturating_sub(1)).copied().unwrap_or(80.0); @@ -131,6 +146,7 @@ impl Table { r.cells.insert(i, Cell::new("")); } self.set_merges(merges.into_iter().map(|m| m.insert_col(at))); + true } /// Delete row `at`. Merges through it shrink; a merge anchored on it moves its anchor (and /// text) to the next row it covers. @@ -170,8 +186,12 @@ impl Table { true } /// The merged areas: every uncovered cell spanning more than one cell, clipped to the grid. + /// Merges of a well-formed table do not overlap, so together they cover at most the grid; a + /// file's overlapping spans past that are dropped, so rebuilding them cannot revisit cells + /// without bound. fn merges(&self) -> Vec { let (nr, nc) = (self.rows.len(), self.cols.len()); + let mut area = nr.saturating_mul(nc); let mut out = vec![]; for (r, row) in self.rows.iter().enumerate() { for (c, cell) in row.cells.iter().enumerate().take(nc) { @@ -180,7 +200,10 @@ impl Table { } let rs = (cell.row_span.max(1) as usize).min(nr - r); let gs = (cell.grid_span.max(1) as usize).min(nc - c); - if rs > 1 || gs > 1 { + if (rs > 1 || gs > 1) + && let Some(left) = area.checked_sub(rs.saturating_mul(gs)) + { + area = left; out.push(Merge { r, c, rs, gs }); } } @@ -233,9 +256,17 @@ impl Table { if r1 >= self.rows.len() || c1 >= self.cols.len() || (r0 == r1 && c0 == c1) { return false; } - // Grow the rectangle until no existing merge sticks out of it. + // Grow the rectangle until no existing merge sticks out of it. Each pass reads the whole + // grid and may grow it by one row, so the passes are charged against + // [`MAX_MERGE_WORK`]: past it the merge is refused, before anything changed. let (mut r0, mut c0, mut r1, mut c1) = (r0, c0, r1, c1); + let pass = self.rows.len().saturating_mul(self.cols.len()).max(1); + let mut work = 0usize; loop { + work = work.saturating_add(pass); + if work > MAX_MERGE_WORK { + return false; + } let before = (r0, c0, r1, c1); for (r, row) in self.rows.iter().enumerate() { for (c, cell) in row.cells.iter().enumerate().take(self.cols.len()) { @@ -289,21 +320,50 @@ impl Table { return false; } // Spans come from the file and may reach past the table; only walk the cells that exist. - for rr in r..r.saturating_add(rs).min(self.rows.len()) { - for cc in c..c.saturating_add(gs).min(self.cols.len()) { - if let Some(x) = self.cell_mut(rr, cc) { - x.h_merge = false; - x.v_merge = false; - x.grid_span = 1; - x.row_span = 1; - } + let end = r.saturating_add(rs).min(self.rows.len()); + let gs = gs.min(self.cols.len().saturating_sub(c)); + for row in self.rows.get_mut(r..end).unwrap_or_default() { + for x in row.cells.iter_mut().skip(c).take(gs) { + x.h_merge = false; + x.v_merge = false; + x.grid_span = 1; + x.row_span = 1; } } true } - /// Make every row have exactly `cols.len()` cells (repair after loading). - pub fn normalize(&mut self) { + /// Whether the grid is as [`Table::normalize`] leaves it: within [`MAX_CELLS`], every row + /// exactly `cols.len()` cells wide. + pub fn is_normalized(&self) -> bool { let n = self.cols.len(); + n <= MAX_CELLS && self.rows.len() <= (MAX_CELLS / n.max(1)).max(1) && self.rows.iter().all(|r| r.cells.len() == n) + } + /// Whether [`Table::normalize`] would drop rows or columns to fit [`MAX_CELLS`]. + pub fn over_cap(&self) -> bool { + let n = self.cols.len(); + n > MAX_CELLS || self.rows.len() > (MAX_CELLS / n.max(1)).max(1) + } + /// What [`Table::normalize`] would leave of this table, cloning only the rows and cells that + /// survive (an oversized table is not copied whole first). + pub fn normalized(&self) -> Table { + let n = self.cols.len().min(MAX_CELLS); + let keep = (MAX_CELLS / n.max(1)).max(1); + let rows = self.rows.iter().take(keep).map(|r| Row { height: r.height, cells: r.cells.iter().take(n).cloned().collect() }).collect(); + let mut t = Table { cols: self.cols[..n].to_vec(), rows, background: self.background.clone(), style: self.style.clone(), ..*self }; + t.normalize(); + if self.over_cap() { + t.clip_spans(); + } + t + } + /// Make every row have exactly `cols.len()` cells (repair after loading). A grid over + /// [`MAX_CELLS`] loses its last rows (and columns) first, so a file naming many rows and many + /// columns but few cells cannot make this allocate their product. + pub fn normalize(&mut self) { + let truncated = self.over_cap(); + self.cols.truncate(MAX_CELLS); + let n = self.cols.len(); + self.rows.truncate((MAX_CELLS / n.max(1)).max(1)); for r in &mut self.rows { r.cells.resize_with(n, || Cell::new("")); for c in &mut r.cells { @@ -311,6 +371,20 @@ impl Table { c.row_span = c.row_span.max(1); } } + if truncated { + self.clip_spans(); + } + } + /// Cut every merge span to the rows and columns that remain, so no merge reaches past a + /// table that lost rows or columns to the cell cap. + fn clip_spans(&mut self) { + let (nr, nc) = (self.rows.len(), self.cols.len()); + for (ri, r) in self.rows.iter_mut().enumerate() { + for (ci, c) in r.cells.iter_mut().enumerate() { + c.row_span = c.row_span.min((nr - ri) as u32).max(1); + c.grid_span = c.grid_span.min((nc - ci) as u32).max(1); + } + } } } @@ -519,6 +593,102 @@ mod tests { } } + /// Each cell spans two rows, uncovered: merging the last two rows would grow the rectangle a + /// row per pass over the whole grid, 10,000 passes. The merge is refused at its work bound + /// instead, leaving the table as it was; a small merge still works. + #[test] + fn merge_expansion_stops_at_its_work_bound() { + let mut t = Table::new(1_000, 10, 400.0, 30.0); + for row in &mut t.rows { + for c in &mut row.cells { + c.row_span = 2; + } + } + let before = t.clone(); + assert!(!t.merge(998, 0, 999, 9)); + assert_eq!(t, before); + let mut small = Table::new(4, 4, 400.0, 30.0); + assert!(small.merge(0, 0, 1, 1)); + assert!(small.is_normalized() && !Table { cols: vec![1.0; 3], rows: vec![Row::default(); 2], ..Default::default() }.is_normalized()); + } + + #[test] + fn normalize_caps_a_sparse_grid_at_max_cells() { + // 1,000 columns and 1,000 empty rows would be a million cells. + let mut t = Table { cols: vec![10.0; 1000], rows: vec![Row::default(); 1000], ..Default::default() }; + t.normalize(); + assert_eq!(t.cols.len(), 1000); + assert_eq!(t.rows.len(), MAX_CELLS / 1000); + assert!(t.rows.iter().all(|r| r.cells.len() == 1000)); + // Columns alone past the cap keep one row of MAX_CELLS cells. + let mut t = Table { cols: vec![1.0; MAX_CELLS + 5], rows: vec![Row::default(); 3], ..Default::default() }; + t.normalize(); + assert_eq!((t.cols.len(), t.rows.len()), (MAX_CELLS, 1)); + // `normalized` leaves what `normalize` does. + let wide = Table { cols: vec![10.0; 1000], rows: vec![Row { height: 1.0, cells: vec![Cell::new("x"); 1500] }; 150], ..Default::default() }; + let mut n = wide.clone(); + n.normalize(); + assert_eq!(wide.normalized(), n); + // A normal table is untouched. + let mut t = Table::new(4, 4, 400.0, 30.0); + t.normalize(); + assert_eq!((t.n_rows(), t.n_cols()), (4, 4)); + } + + #[test] + fn overlapping_file_spans_rebuild_in_bounded_work() { + // Every cell an uncovered anchor spanning to the far corner: their areas add up to about + // n^4 / 4, but only what fits the grid is kept, so an edit's rebuild stays near n^2. + let n = 200; + let mut t = Table::new(n, n, 400.0, 30.0); + for row in &mut t.rows { + for c in &mut row.cells { + c.grid_span = u32::MAX; + c.row_span = u32::MAX; + } + } + assert_eq!(t.merges().len(), 1, "the first anchor already covers the whole grid"); + assert!(t.insert_row(n)); + assert_eq!(t.n_rows(), n + 1); + assert!(t.split(0, 0)); + } + + /// A table at the cell cap refuses another row or column instead of losing rows to + /// normalization, and the cap sits above PowerPoint's own 75 x 75. + #[test] + fn insert_past_the_cap_is_refused() { + const { assert!(MAX_CELLS >= 75 * 75) }; + let mut t = + Table { cols: vec![1.0; 200], rows: vec![Row { height: 1.0, cells: vec![Cell::new(""); 200] }; MAX_CELLS / 200], ..Default::default() }; + assert!(!t.over_cap()); + let before = t.clone(); + assert!(!t.insert_row(0)); + assert!(!t.insert_col(0)); + assert_eq!(t, before); + assert!(Table::new(75, 75, 100.0, 10.0).insert_row(0)); + } + + /// A merge that crosses the truncation boundary is clipped to the rows and columns that remain. + #[test] + fn merges_are_clipped_when_the_cap_drops_rows() { + let cols = 1000; + let rows = MAX_CELLS / cols + 1; + let mut t = Table { cols: vec![1.0; cols], rows: vec![Row { height: 1.0, cells: vec![Cell::new(""); cols] }; rows], ..Default::default() }; + t.rows[0].cells[0].row_span = rows as u32; + t.rows[0].cells[cols - 1].grid_span = 5; + let n = t.normalized(); + assert_eq!(n.rows.len(), rows - 1); + assert_eq!(n.rows[0].cells[0].row_span as usize, rows - 1); + assert_eq!(n.rows[0].cells[cols - 1].grid_span, 1); + t.normalize(); + assert_eq!(t.rows[0].cells[0].row_span as usize, rows - 1); + // Within the cap, spans are left as the file wrote them. + let mut small = Table::new(3, 3, 30.0, 10.0); + small.rows[2].cells[2].grid_span = 4; + small.normalize(); + assert_eq!(small.rows[2].cells[2].grid_span, 4); + } + fn merged() -> Table { // 4x4 with a 2x2 merge at (1,1) holding "M". let mut t = Table::new(4, 4, 400.0, 30.0); @@ -552,10 +722,10 @@ mod tests { fn row_and_column_edits_keep_merges_consistent() { for at in 0..=4 { let mut t = merged(); - t.insert_row(at); + assert!(t.insert_row(at)); assert_topology(&t); let mut t = merged(); - t.insert_col(at); + assert!(t.insert_col(at)); assert_topology(&t); } for at in 0..4 { diff --git a/crates/pptx/Cargo.toml b/crates/pptx/Cargo.toml index aceba9f72..6be4dd23e 100644 --- a/crates/pptx/Cargo.toml +++ b/crates/pptx/Cargo.toml @@ -13,6 +13,7 @@ craft-opc.workspace = true craft-xml.workspace = true craft-cfb.workspace = true craft-drawingml.workspace = true +craft-drawingml-table.workspace = true deckcraft-model = { workspace = true } deckcraft-geom = { workspace = true } deckcraft-color = { workspace = true } diff --git a/crates/pptx/src/lib.rs b/crates/pptx/src/lib.rs index 2c86937e7..9335b4e26 100644 --- a/crates/pptx/src/lib.rs +++ b/crates/pptx/src/lib.rs @@ -71,6 +71,12 @@ pub fn import_checked(bytes: &[u8]) -> Result<(Presentation, Vec), PptxE read::import_checked(bytes) } +/// [`import_checked`], plus warnings for content cut to fit a limit (a table past the cell cap +/// keeps its leading rows); the file still opens. +pub fn import_report(bytes: &[u8]) -> Result<(Presentation, Vec, Vec), PptxError> { + read::import_report(bytes) +} + /// [`import`] with a lower presentation-wide chart point budget, so tests reach the over-budget /// path without a multi-million-point chart. #[doc(hidden)] diff --git a/crates/pptx/src/read.rs b/crates/pptx/src/read.rs index 7ece2c628..2c0ec8810 100644 --- a/crates/pptx/src/read.rs +++ b/crates/pptx/src/read.rs @@ -71,6 +71,8 @@ pub struct Imp<'a> { pub tag_bytes: usize, /// The tag budget ran out and the warning was given. pub tags_capped: bool, + /// What the file lost that the reader kept going past (see [`MAX_IMPORT_WARNINGS`]). + pub warnings: Vec, /// Bytes of preserved theme XML kept by the masters read so far. pub theme_extra_bytes: usize, /// Shapes read from SmartArt drawings so far (see `shapes::MAX_SMARTART_SHAPES`). @@ -82,7 +84,17 @@ pub struct Imp<'a> { pub has_rels: HashMap, } +/// Import warnings kept; a hostile file with many oversized tables adds no more than this. +const MAX_IMPORT_WARNINGS: usize = 32; + impl Imp<'_> { + /// Record something the file lost, and log it. + pub fn warn(&mut self, msg: String) { + log::warn!("pptx: {msg}"); + if self.warnings.len() < MAX_IMPORT_WARNINGS { + self.warnings.push(msg); + } + } pub fn alloc(&mut self) -> u32 { self.next = self.next.saturating_add(1); self.next @@ -598,6 +610,7 @@ pub fn import_theme(bytes: &[u8]) -> Result<(deckcraft_model::theme::Theme, Vec< tags_by_part: HashMap::new(), tag_bytes: 0, tags_capped: false, + warnings: vec![], theme_extra_bytes: 0, smartart_shapes: 0, diagram_xml_bytes: 0, @@ -616,13 +629,24 @@ pub fn import(bytes: &[u8]) -> Result { /// or truncated slide part, or an entry whose relationship is missing): those slides are left /// out, so a caller can say so (#203). pub fn import_checked(bytes: &[u8]) -> Result<(Presentation, Vec), PptxError> { - import_with_chart_points(bytes, chart::MAX_PRESENTATION_CHART_POINTS) + import_report(bytes).map(|(p, lost, _)| (p, lost)) +} + +/// [`import_checked`], plus warnings for content the file had that was cut to fit a limit (a +/// table past the cell cap keeps its leading rows). +pub fn import_report(bytes: &[u8]) -> Result<(Presentation, Vec, Vec), PptxError> { + import_report_with_chart_points(bytes, chart::MAX_PRESENTATION_CHART_POINTS) } const MAX_SLIDE_ENTRIES: usize = 10_000; /// [`import_checked`] with the presentation's chart point budget set (tests lower it). pub(crate) fn import_with_chart_points(bytes: &[u8], chart_points_cap: usize) -> Result<(Presentation, Vec), PptxError> { + import_report_with_chart_points(bytes, chart_points_cap).map(|(p, lost, _)| (p, lost)) +} + +/// [`import_report`] with the presentation's chart point budget set. +fn import_report_with_chart_points(bytes: &[u8], chart_points_cap: usize) -> Result<(Presentation, Vec, Vec), PptxError> { let mut lost_slides: Vec = vec![]; let pkg = Package::open(bytes)?; let root_rels = pkg.rels(""); @@ -663,6 +687,7 @@ pub(crate) fn import_with_chart_points(bytes: &[u8], chart_points_cap: usize) -> tags_by_part: HashMap::new(), tag_bytes: 0, tags_capped: false, + warnings: vec![], theme_extra_bytes: 0, smartart_shapes: 0, diagram_xml_bytes: 0, @@ -697,7 +722,7 @@ pub(crate) fn import_with_chart_points(bytes: &[u8], chart_points_cap: usize) -> p.media = std::mem::take(&mut imp.media); p.next_id = imp.next; p.fix_next_id(); - Ok((p, lost_slides)) + Ok((p, lost_slides, std::mem::take(&mut imp.warnings))) } /// Masters, layouts and slides to read, in file order and without duplicates: (master paths, @@ -1637,6 +1662,7 @@ mod rollback_tests { tags_by_part: HashMap::new(), tag_bytes: 0, tags_capped: false, + warnings: vec![], theme_extra_bytes: 0, smartart_shapes: 0, diagram_xml_bytes: 0, diff --git a/crates/pptx/src/read/shapes.rs b/crates/pptx/src/read/shapes.rs index bcef9f8c5..7ff66018a 100644 --- a/crates/pptx/src/read/shapes.rs +++ b/crates/pptx/src/read/shapes.rs @@ -856,6 +856,9 @@ fn table(imp: &mut Imp, part: &Part, tbl: &El) -> Table { let n = t.rows.iter().map(|r| r.cells.len()).max().unwrap_or(0); t.cols = vec![72.0; n]; } + if t.over_cap() { + imp.warn(format!("a table in {} is over {} cells; its last rows were left out", part.name, deckcraft_model::table::MAX_CELLS)); + } t.normalize(); t } diff --git a/crates/pptx/src/tables.rs b/crates/pptx/src/tables.rs index 62dc983c4..081433243 100644 --- a/crates/pptx/src/tables.rs +++ b/crates/pptx/src/tables.rs @@ -1,190 +1,55 @@ -//! Table styles: our style ids ↔ table style GUIDs, and `tableStyles.xml` definitions for the -//! styles we write (generated from theme accents, matching how DeckCraft draws them). - -use crate::opc::NS_A; -use crate::xml::{A, W}; - -// Keep file-format identifiers in the shared DrawingML implementation. The local -// writer below still owns DeckCraft's table style definitions and XML policy. +//! Table style XML uses the shared writer; app XML admission remains unchanged. pub use craft_drawingml::table::styles::{guid, guid_for_style, is_own_guid, style_from_guid}; +pub fn table_styles_xml(used: &[String], defs: &[deckcraft_model::table::TableStyleDef]) -> Vec { + craft_drawingml_table::table::styles::table_styles_xml_with(used, defs.iter().map(|d| (d.id.as_str(), d.raw.as_str())), "DeckCraft", |raw| { + crate::xml::parse(raw.as_bytes()).is_ok_and(|x| x.root.is("tblStyle")) + }) +} + +#[cfg(test)] +#[path = "tables_legacy.rs"] +mod legacy; + +#[cfg(test)] fn own_guid(style: &str) -> String { guid(&format!("deckcraft-table-style:{style}")) } -fn clr(w: &mut W, slot: &str, mods: &[(&str, i32)]) { - if mods.is_empty() { - w.val("a:schemeClr", slot); - return; - } - w.open("a:schemeClr", A::new().a("val", slot)); - for (n, v) in mods { - w.val(n, v); - } - w.close("a:schemeClr"); -} - -fn solid(w: &mut W, slot: &str, mods: &[(&str, i32)]) { - w.open0("a:fill"); - w.open0("a:solidFill"); - clr(w, slot, mods); - w.close("a:solidFill"); - w.close("a:fill"); -} - -fn borders(w: &mut W, b: Option<(&str, &[(&str, i32)], i32)>) { - w.open0("a:tcBdr"); - if let Some((slot, mods, width)) = b { - for side in ["a:left", "a:right", "a:top", "a:bottom", "a:insideH", "a:insideV"] { - w.open0(side); - w.open("a:ln", A::new().a("w", width).a("cmpd", "sng")); - w.open0("a:solidFill"); - clr(w, slot, mods); - w.close("a:solidFill"); - w.close("a:ln"); - w.close(side); - } - } - w.close("a:tcBdr"); -} - -fn txt(w: &mut W, bold: bool, color: Option<&str>) { - w.open("a:tcTxStyle", A::new().o("b", bold.then_some("on"))); - w.open("a:fontRef", A::new().a("idx", "minor")); - w.val("a:prstClr", "black"); - w.close("a:fontRef"); - match color { - Some(c) => w.val("a:schemeClr", c), - None => w.val("a:schemeClr", "dk1"), - } - w.close("a:tcTxStyle"); -} - -/// Write one `a:tblStyle` for our style id. -fn style_def(w: &mut W, id: &str, name: &str) { - let kind = id.split('-').next().unwrap_or("medium2"); - let acc = match id.rsplit('-').next().unwrap_or("accent1") { - "tx1" => "dk1", - a if a.starts_with("accent") => a, - _ => "accent1", - }; - let acc: &str = acc; - w.open("a:tblStyle", A::new().a("styleId", own_guid(id)).a("styleName", name)); - let part = - |w: &mut W, tag: &str, bold: bool, text: Option<&str>, fill: Option<(&str, &[(&str, i32)])>, bdr: Option<(&str, &[(&str, i32)], i32)>| { - w.open0(tag); - if bold || text.is_some() { - txt(w, bold, text); - } - w.open0("a:tcStyle"); - borders(w, bdr); - if let Some((s, m)) = fill { - solid(w, s, m); - } - w.close("a:tcStyle"); - w.close(tag); - }; - match kind { - "grid" => { - part(w, "a:wholeTbl", false, Some("dk1"), None, Some(("dk1", &[], 9525))); - } - "light1" => { - part(w, "a:wholeTbl", false, Some("dk1"), None, None); - part(w, "a:band1H", false, None, Some((acc, &[("a:tint", 20000)])), None); - part(w, "a:band1V", false, None, Some((acc, &[("a:tint", 20000)])), None); - part(w, "a:lastCol", true, None, None, None); - part(w, "a:firstCol", true, None, None, None); - part(w, "a:lastRow", true, None, None, None); - part(w, "a:firstRow", true, None, None, Some((acc, &[], 12700))); - } - "light2" => { - part(w, "a:wholeTbl", false, Some("dk1"), None, Some((acc, &[], 12700))); - // Schema order: … lastCol, firstCol, lastRow, …, firstRow. - part(w, "a:firstCol", true, None, None, None); - part(w, "a:lastRow", true, None, None, None); - part(w, "a:firstRow", true, Some("lt1"), Some((acc, &[])), Some((acc, &[], 12700))); - } - "dark1" => { - part(w, "a:wholeTbl", false, Some("lt1"), Some((acc, &[("a:shade", 75000)])), Some(("lt1", &[], 12700))); - part(w, "a:band1H", false, None, Some((acc, &[("a:shade", 60000)])), None); - part(w, "a:band1V", false, None, Some((acc, &[("a:shade", 60000)])), None); - part(w, "a:firstCol", true, None, None, None); - part(w, "a:lastRow", true, None, None, None); - part(w, "a:firstRow", true, Some("lt1"), Some(("dk1", &[])), None); - } - "medium4" => { - part(w, "a:wholeTbl", false, Some("dk1"), Some((acc, &[("a:tint", 20000)])), Some((acc, &[], 9525))); - part(w, "a:band1H", false, None, Some((acc, &[("a:tint", 40000)])), None); - part(w, "a:band1V", false, None, Some((acc, &[("a:tint", 40000)])), None); - part(w, "a:lastCol", true, None, None, None); - part(w, "a:firstCol", true, None, None, None); - part(w, "a:lastRow", true, None, None, None); - part(w, "a:firstRow", true, None, Some((acc, &[("a:tint", 40000)])), None); - } - _ => { - // medium2 - part(w, "a:wholeTbl", false, Some("dk1"), Some((acc, &[("a:tint", 20000)])), Some(("lt1", &[], 12700))); - part(w, "a:band1H", false, None, Some((acc, &[("a:tint", 40000)])), None); - part(w, "a:band1V", false, None, Some((acc, &[("a:tint", 40000)])), None); - part(w, "a:lastCol", true, Some("lt1"), Some((acc, &[])), None); - part(w, "a:firstCol", true, Some("lt1"), Some((acc, &[])), None); - part(w, "a:lastRow", true, Some("lt1"), Some((acc, &[])), None); - part(w, "a:firstRow", true, Some("lt1"), Some((acc, &[])), None); - } - } - w.close("a:tblStyle"); -} - -/// `ppt/tableStyles.xml` with definitions for the styles in `used`: ours, generated, and those the -/// opened file defined (`defs`), written back as they were read. -pub fn table_styles_xml(used: &[String], defs: &[deckcraft_model::table::TableStyleDef]) -> Vec { - let mut w = W::new(); - w.open("a:tblStyleLst", A::new().a("xmlns:a", NS_A).a("def", "{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}")); - let names = deckcraft_model::table::table_styles(); - // Indexes instead of scans: written ids (as given and ASCII lower-case), and the file's - // definitions by lower-case id (the first wins). - let mut done: std::collections::HashSet<&str> = std::collections::HashSet::new(); - let mut done_lower: std::collections::HashSet = std::collections::HashSet::new(); - let mut def_of: std::collections::HashMap = std::collections::HashMap::new(); - for d in defs { - def_of.entry(d.id.to_ascii_lowercase()).or_insert(d); - } - for s in used { - if !done.insert(s.as_str()) { - continue; - } - done_lower.insert(s.to_ascii_lowercase()); - if let Some(d) = def_of.get(&s.to_ascii_lowercase()) - && crate::xml::parse(d.raw.as_bytes()).is_ok_and(|x| x.root.is("tblStyle")) - { - w.raw(&d.raw); - continue; - } - let (_, define) = guid_for_style(s); - if !define { - continue; - } - let name = names.iter().find(|(id, _)| id == s).map(|(_, n)| format!("DeckCraft {n}")).unwrap_or_else(|| s.clone()); - style_def(&mut w, s, &name); - } - // Styles the file defined but no table uses still belong to the deck. - for d in defs { - if done_lower.contains(&d.id.to_ascii_lowercase()) { - continue; - } - if crate::xml::parse(d.raw.as_bytes()).is_ok_and(|x| x.root.is("tblStyle")) { - done_lower.insert(d.id.to_ascii_lowercase()); - w.raw(&d.raw); - } - } - w.close("a:tblStyleLst"); - w.finish() -} - #[cfg(test)] mod tests { use super::*; + #[test] + fn shared_writer_matches_legacy_bytes_and_admission() { + use deckcraft_model::table::TableStyleDef; + let mut used: Vec = deckcraft_model::table::table_styles().into_iter().map(|(id, _)| id).collect(); + used.extend(["unknown<&\"".into(), "Custom".into(), "Custom".into(), "CUSTOM".into()]); + for raw in [ + "", + "", // Existing lenient partial-root policy. + "", + "", + "", + "", + "", + ] { + let defs = vec![ + TableStyleDef { id: "custom".into(), raw: raw.into(), ..Default::default() }, + TableStyleDef { id: "CUSTOM".into(), raw: "".into(), ..Default::default() }, + TableStyleDef { id: "unused".into(), raw: "".into(), ..Default::default() }, + ]; + for selection in [&used[..], &[][..]] { + assert_eq!(table_styles_xml(selection, &defs), legacy::table_styles_xml(selection, &defs), "{raw:?}"); + } + } + for depth in [255, 256, 257] { + let raw = format!("{}{}", "".repeat(depth), "".repeat(depth)); + let defs = [TableStyleDef { id: "custom".into(), raw, ..Default::default() }]; + assert_eq!(table_styles_xml(&used, &defs), legacy::table_styles_xml(&used, &defs)); + } + } + #[test] fn shared_style_catalog_matches_deckcraft() { assert_eq!(deckcraft_model::table::table_styles(), craft_drawingml::table::table_styles()); diff --git a/crates/pptx/src/tables_legacy.rs b/crates/pptx/src/tables_legacy.rs new file mode 100644 index 000000000..b5d71dc4b --- /dev/null +++ b/crates/pptx/src/tables_legacy.rs @@ -0,0 +1,182 @@ +//! Table styles: our style ids ↔ table style GUIDs, and `tableStyles.xml` definitions for the +//! styles we write (generated from theme accents, matching how DeckCraft draws them). + +use crate::opc::NS_A; +use crate::xml::{A, W}; + +// Keep file-format identifiers in the shared DrawingML implementation. The local +// writer below still owns DeckCraft's table style definitions and XML policy. +pub use craft_drawingml::table::styles::{guid, guid_for_style}; + +fn own_guid(style: &str) -> String { + guid(&format!("deckcraft-table-style:{style}")) +} + +fn clr(w: &mut W, slot: &str, mods: &[(&str, i32)]) { + if mods.is_empty() { + w.val("a:schemeClr", slot); + return; + } + w.open("a:schemeClr", A::new().a("val", slot)); + for (n, v) in mods { + w.val(n, v); + } + w.close("a:schemeClr"); +} + +fn solid(w: &mut W, slot: &str, mods: &[(&str, i32)]) { + w.open0("a:fill"); + w.open0("a:solidFill"); + clr(w, slot, mods); + w.close("a:solidFill"); + w.close("a:fill"); +} + +fn borders(w: &mut W, b: Option<(&str, &[(&str, i32)], i32)>) { + w.open0("a:tcBdr"); + if let Some((slot, mods, width)) = b { + for side in ["a:left", "a:right", "a:top", "a:bottom", "a:insideH", "a:insideV"] { + w.open0(side); + w.open("a:ln", A::new().a("w", width).a("cmpd", "sng")); + w.open0("a:solidFill"); + clr(w, slot, mods); + w.close("a:solidFill"); + w.close("a:ln"); + w.close(side); + } + } + w.close("a:tcBdr"); +} + +fn txt(w: &mut W, bold: bool, color: Option<&str>) { + w.open("a:tcTxStyle", A::new().o("b", bold.then_some("on"))); + w.open("a:fontRef", A::new().a("idx", "minor")); + w.val("a:prstClr", "black"); + w.close("a:fontRef"); + match color { + Some(c) => w.val("a:schemeClr", c), + None => w.val("a:schemeClr", "dk1"), + } + w.close("a:tcTxStyle"); +} + +/// Write one `a:tblStyle` for our style id. +fn style_def(w: &mut W, id: &str, name: &str) { + let kind = id.split('-').next().unwrap_or("medium2"); + let acc = match id.rsplit('-').next().unwrap_or("accent1") { + "tx1" => "dk1", + a if a.starts_with("accent") => a, + _ => "accent1", + }; + let acc: &str = acc; + w.open("a:tblStyle", A::new().a("styleId", own_guid(id)).a("styleName", name)); + let part = + |w: &mut W, tag: &str, bold: bool, text: Option<&str>, fill: Option<(&str, &[(&str, i32)])>, bdr: Option<(&str, &[(&str, i32)], i32)>| { + w.open0(tag); + if bold || text.is_some() { + txt(w, bold, text); + } + w.open0("a:tcStyle"); + borders(w, bdr); + if let Some((s, m)) = fill { + solid(w, s, m); + } + w.close("a:tcStyle"); + w.close(tag); + }; + match kind { + "grid" => { + part(w, "a:wholeTbl", false, Some("dk1"), None, Some(("dk1", &[], 9525))); + } + "light1" => { + part(w, "a:wholeTbl", false, Some("dk1"), None, None); + part(w, "a:band1H", false, None, Some((acc, &[("a:tint", 20000)])), None); + part(w, "a:band1V", false, None, Some((acc, &[("a:tint", 20000)])), None); + part(w, "a:lastCol", true, None, None, None); + part(w, "a:firstCol", true, None, None, None); + part(w, "a:lastRow", true, None, None, None); + part(w, "a:firstRow", true, None, None, Some((acc, &[], 12700))); + } + "light2" => { + part(w, "a:wholeTbl", false, Some("dk1"), None, Some((acc, &[], 12700))); + // Schema order: … lastCol, firstCol, lastRow, …, firstRow. + part(w, "a:firstCol", true, None, None, None); + part(w, "a:lastRow", true, None, None, None); + part(w, "a:firstRow", true, Some("lt1"), Some((acc, &[])), Some((acc, &[], 12700))); + } + "dark1" => { + part(w, "a:wholeTbl", false, Some("lt1"), Some((acc, &[("a:shade", 75000)])), Some(("lt1", &[], 12700))); + part(w, "a:band1H", false, None, Some((acc, &[("a:shade", 60000)])), None); + part(w, "a:band1V", false, None, Some((acc, &[("a:shade", 60000)])), None); + part(w, "a:firstCol", true, None, None, None); + part(w, "a:lastRow", true, None, None, None); + part(w, "a:firstRow", true, Some("lt1"), Some(("dk1", &[])), None); + } + "medium4" => { + part(w, "a:wholeTbl", false, Some("dk1"), Some((acc, &[("a:tint", 20000)])), Some((acc, &[], 9525))); + part(w, "a:band1H", false, None, Some((acc, &[("a:tint", 40000)])), None); + part(w, "a:band1V", false, None, Some((acc, &[("a:tint", 40000)])), None); + part(w, "a:lastCol", true, None, None, None); + part(w, "a:firstCol", true, None, None, None); + part(w, "a:lastRow", true, None, None, None); + part(w, "a:firstRow", true, None, Some((acc, &[("a:tint", 40000)])), None); + } + _ => { + // medium2 + part(w, "a:wholeTbl", false, Some("dk1"), Some((acc, &[("a:tint", 20000)])), Some(("lt1", &[], 12700))); + part(w, "a:band1H", false, None, Some((acc, &[("a:tint", 40000)])), None); + part(w, "a:band1V", false, None, Some((acc, &[("a:tint", 40000)])), None); + part(w, "a:lastCol", true, Some("lt1"), Some((acc, &[])), None); + part(w, "a:firstCol", true, Some("lt1"), Some((acc, &[])), None); + part(w, "a:lastRow", true, Some("lt1"), Some((acc, &[])), None); + part(w, "a:firstRow", true, Some("lt1"), Some((acc, &[])), None); + } + } + w.close("a:tblStyle"); +} + +/// `ppt/tableStyles.xml` with definitions for the styles in `used`: ours, generated, and those the +/// opened file defined (`defs`), written back as they were read. +pub fn table_styles_xml(used: &[String], defs: &[deckcraft_model::table::TableStyleDef]) -> Vec { + let mut w = W::new(); + w.open("a:tblStyleLst", A::new().a("xmlns:a", NS_A).a("def", "{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}")); + let names = deckcraft_model::table::table_styles(); + // Indexes instead of scans: written ids (as given and ASCII lower-case), and the file's + // definitions by lower-case id (the first wins). + let mut done: std::collections::HashSet<&str> = std::collections::HashSet::new(); + let mut done_lower: std::collections::HashSet = std::collections::HashSet::new(); + let mut def_of: std::collections::HashMap = std::collections::HashMap::new(); + for d in defs { + def_of.entry(d.id.to_ascii_lowercase()).or_insert(d); + } + for s in used { + if !done.insert(s.as_str()) { + continue; + } + done_lower.insert(s.to_ascii_lowercase()); + if let Some(d) = def_of.get(&s.to_ascii_lowercase()) + && crate::xml::parse(d.raw.as_bytes()).is_ok_and(|x| x.root.is("tblStyle")) + { + w.raw(&d.raw); + continue; + } + let (_, define) = guid_for_style(s); + if !define { + continue; + } + let name = names.iter().find(|(id, _)| id == s).map(|(_, n)| format!("DeckCraft {n}")).unwrap_or_else(|| s.clone()); + style_def(&mut w, s, &name); + } + // Styles the file defined but no table uses still belong to the deck. + for d in defs { + if done_lower.contains(&d.id.to_ascii_lowercase()) { + continue; + } + if crate::xml::parse(d.raw.as_bytes()).is_ok_and(|x| x.root.is("tblStyle")) { + done_lower.insert(d.id.to_ascii_lowercase()); + w.raw(&d.raw); + } + } + w.close("a:tblStyleLst"); + w.finish() +} diff --git a/crates/pptx/src/write.rs b/crates/pptx/src/write.rs index fe498ab58..96cd5800a 100644 --- a/crates/pptx/src/write.rs +++ b/crates/pptx/src/write.rs @@ -65,6 +65,8 @@ pub struct Exp<'a> { n_kept: u32, pub slide_parts: HashMap, pub table_styles: Vec, + /// A table past the cell cap was met; export fails rather than write a trimmed one. + pub table_over_cap: bool, /// The ids in `table_styles`, for checking membership without a scan. pub table_style_set: std::collections::HashSet, placeholder: Option, @@ -558,6 +560,7 @@ pub fn export(p: &Presentation, main_ct: &str) -> Result, PptxError> { n_kept: 0, slide_parts: HashMap::new(), table_styles: vec![], + table_over_cap: false, table_style_set: Default::default(), placeholder: None, }; @@ -766,6 +769,12 @@ pub fn export(p: &Presentation, main_ct: &str) -> Result, PptxError> { root.add_new(&k.rel_type, &k.name, false); } x.pkg.rels("", &root); + if x.table_over_cap { + return Err(PptxError::Unsupported(format!( + "a table has more than {} cells; export refused rather than drop rows", + deckcraft_model::table::MAX_CELLS + ))); + } x.pkg.finish() } diff --git a/crates/pptx/src/write/shapes.rs b/crates/pptx/src/write/shapes.rs index df7a226df..a5833c4d1 100644 --- a/crates/pptx/src/write/shapes.rs +++ b/crates/pptx/src/write/shapes.rs @@ -724,8 +724,8 @@ fn frame_close(w: &mut W) { } fn table(w: &mut W, x: &mut Exp, o: &mut Out, t: &Table) { - let mut t = t.clone(); - t.normalize(); + x.table_over_cap |= t.over_cap(); + let t = t.normalized(); w.open0("a:tbl"); let (guid, _) = crate::tables::guid_for_style(&t.style); if x.table_style_set.insert(t.style.clone()) { diff --git a/crates/pptx/tests/it/malformed.rs b/crates/pptx/tests/it/malformed.rs index 04b219c29..6a4e88823 100644 --- a/crates/pptx/tests/it/malformed.rs +++ b/crates/pptx/tests/it/malformed.rs @@ -288,6 +288,44 @@ fn unreadable_slide_is_reported() { assert_eq!(deckcraft_pptx::import(&broken).expect("import").slides.len(), 1); } +fn table_deck(rows: usize, cols: usize) -> deckcraft_model::Presentation { + use deckcraft_model::table::Row; + use deckcraft_model::{Shape, ShapeId, ShapeKind, Table, Xfrm}; + let mut p = defaults::new_presentation(None); + let id = ShapeId(p.alloc_id().expect("ids")); + let t = Table { cols: vec![1.0; cols], rows: vec![Row { height: 1.0, cells: vec![Default::default(); cols] }; rows], ..Default::default() }; + let slide = std::sync::Arc::make_mut(&mut p.slides[0]); + slide.shapes.push(Shape { id, name: "T".into(), xfrm: Some(Xfrm::new(0.0, 0.0, 10.0, 10.0)), kind: ShapeKind::Table(t), ..Default::default() }); + p +} + +/// A table past the cell cap opens with its leading rows and an import warning; saving one that +/// is over the cap is an error, never a silent trim. +#[test] +fn oversized_table_warns_on_import_and_refuses_export() { + let max = deckcraft_model::table::MAX_CELLS; + let cols = 1000; + let rows = max / cols; + // A table exactly at the cap round-trips with no warning. + let bytes = deckcraft_pptx::export(&table_deck(rows, cols)).expect("export at the cap"); + let (_, _, warnings) = deckcraft_pptx::import_report(&bytes).expect("import"); + assert!(warnings.is_empty(), "{warnings:?}"); + // One more row in the file: kept truncated, and reported. + let mut es = entries(&bytes); + let slide = es.iter_mut().find(|(n, _)| n == "ppt/slides/slide1.xml").expect("slide1"); + let xml = String::from_utf8(std::mem::take(&mut slide.1)).expect("utf8"); + let start = xml.rfind("").expect("row end") + "".len(); + slide.1 = format!("{}{}{}", &xml[..end], &xml[start..end], &xml[end..]).into_bytes(); + let (q, _, warnings) = deckcraft_pptx::import_report(&rezip(&es)).expect("import"); + assert_eq!(warnings.len(), 1, "{warnings:?}"); + let t = q.slides[0].shapes.iter().find_map(|s| if let deckcraft_model::ShapeKind::Table(t) = &s.kind { Some(t) } else { None }).expect("table"); + assert_eq!((t.rows.len(), t.cols.len()), (rows, cols)); + // A model table past the cap is refused on export. + let err = deckcraft_pptx::export(&table_deck(rows + 1, cols)).expect_err("over the cap"); + assert!(err.to_string().contains("table"), "{err}"); +} + /// Missing slide relationships must not turn a damaged deck into a clean partial load (#1910). #[test] fn missing_slide_relationships_are_reported() {