mirror of
https://github.com/storytold/deckcraft.git
synced 2026-11-17 11:21:27 -06:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
2c135484c1 | ||
|
|
352b1ee170 | ||
|
|
82fddc8ffd | ||
|
|
1629e4d953 | ||
|
|
497582406d | ||
|
|
e1ca71495c | ||
|
|
5c698493bc | ||
|
|
f964d06cc5 | ||
|
|
ac73229ef4 | ||
|
|
1ec01a091a |
@@ -0,0 +1,31 @@
|
||||
# This file is machine-generated by `gh actions-lock`.
|
||||
# Do not edit by hand; run `gh actions-lock` to update.
|
||||
# Docs: https://gh.io/actions-lockfile
|
||||
version: 'v0.0.3'
|
||||
workflows:
|
||||
'.github/workflows/ci.yml':
|
||||
- 'actions/checkout@v7.0.1'
|
||||
- 'step-security/harden-runner@v2.22.4'
|
||||
'.github/workflows/freebsd.yml': []
|
||||
'.github/workflows/house-rules.yml': []
|
||||
'.github/workflows/lockfile.yml':
|
||||
- 'actions/checkout@v7.0.1'
|
||||
- 'step-security/harden-runner@v2.22.4'
|
||||
'.github/workflows/nix.yml': []
|
||||
'.github/workflows/packaging-lint.yml':
|
||||
- 'actions/checkout@v7.0.1'
|
||||
- 'step-security/harden-runner@v2.22.4'
|
||||
'.github/workflows/release.yml': []
|
||||
'.github/workflows/sonarcloud.yml': []
|
||||
'.github/workflows/windows-arm64.yml': []
|
||||
dependencies:
|
||||
'actions/checkout@v7.0.1':
|
||||
ref: 'v7.0.1'
|
||||
commit: 'sha1-3d3c42e5aac5ba805825da76410c181273ba90b1'
|
||||
owner_id: 44036562
|
||||
repo_id: 197814629
|
||||
'step-security/harden-runner@v2.22.4':
|
||||
ref: 'v2.22.4'
|
||||
commit: 'sha1-1d88384fd173af6ecb012dfd0264a306b711241a'
|
||||
owner_id: 88700172
|
||||
repo_id: 422287306
|
||||
@@ -27,11 +27,11 @@ jobs:
|
||||
CRAFT_FONTS_REF: 37827adc41fd165f9a9234ac40f94dbad353aa69
|
||||
steps:
|
||||
- name: Harden runner
|
||||
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
|
||||
uses: step-security/harden-runner@v2.22.4
|
||||
with:
|
||||
egress-policy: audit
|
||||
- name: Check out craft-fonts
|
||||
uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
|
||||
uses: actions/checkout@v7.0.1
|
||||
with:
|
||||
repository: storytold/craft-fonts
|
||||
ref: ${{ env.CRAFT_FONTS_REF }}
|
||||
|
||||
@@ -0,0 +1,34 @@
|
||||
name: Lockfile
|
||||
|
||||
# Fails when .github/workflows/actions.lock is out of sync with the workflows, or when a locked pin
|
||||
# no longer verifies upstream, so a moved tag cannot slip a different commit into a run.
|
||||
# Docs: https://gh.io/actions-lockfile
|
||||
on:
|
||||
pull_request:
|
||||
push:
|
||||
branches: [main]
|
||||
workflow_dispatch:
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
env:
|
||||
GH_TOKEN: ${{ github.token }}
|
||||
|
||||
jobs:
|
||||
lockfile:
|
||||
name: Lockfile is in sync
|
||||
runs-on: ubuntu-24.04
|
||||
timeout-minutes: 10
|
||||
steps:
|
||||
- name: Harden runner
|
||||
uses: step-security/harden-runner@v2.22.4
|
||||
with:
|
||||
egress-policy: audit
|
||||
- uses: actions/checkout@v7.0.1
|
||||
with:
|
||||
persist-credentials: false
|
||||
- name: Install gh-actions-lock
|
||||
run: gh extension install github/gh-actions-lock --pin v0.4.1
|
||||
- name: Verify the lockfile
|
||||
run: gh actions-lock --verify
|
||||
@@ -28,10 +28,10 @@ jobs:
|
||||
runs-on: windows-latest
|
||||
steps:
|
||||
- name: Harden runner
|
||||
uses: step-security/harden-runner@1d88384fd173af6ecb012dfd0264a306b711241a # v2.22.4
|
||||
uses: step-security/harden-runner@v2.22.4
|
||||
with:
|
||||
egress-policy: audit
|
||||
- uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
|
||||
- uses: actions/checkout@v7.0.1
|
||||
with:
|
||||
persist-credentials: false
|
||||
- name: Install the pinned packaging toolchain
|
||||
|
||||
@@ -239,3 +239,7 @@ the `ROADMAP.md` progress log, and update each touched doc's status line and rev
|
||||
- Workflows in `.github/workflows/` call the shared workflows in [`storytold/craft-common-actions`](https://github.com/storytold/craft-common-actions) at `@main`, with their inputs and secrets. No other jobs: if no shared workflow does what's needed, it doesn't go here.
|
||||
- Don't add or change CI in a feature or fix PR. If the existing workflows can't build or test a change, link an existing craft-common-actions issue or PR, or open a new issue, or a PR only for a small fix that is safe for every app and does not increase CI time.
|
||||
- Some workflow files here still run their own jobs. Don't add to them. Moving a job into craft-common-actions is its own task, never part of another PR, and the job stays here until a shared workflow runs it.
|
||||
|
||||
## Shared libraries
|
||||
|
||||
Before adding or changing file-format, codec, protocol, or reusable UI code, check `storytold/craft-libs` and its open PRs first; reuse or extend the shared library rather than duplicating it locally, keep app-specific policy and model mapping in the app, and preserve behavior, security/resource limits, attribution, and regression coverage during cutovers.
|
||||
|
||||
Generated
+25
-2
@@ -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,6 +1350,8 @@ name = "deckcraft-pptx"
|
||||
version = "0.19.0"
|
||||
dependencies = [
|
||||
"craft-cfb",
|
||||
"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",
|
||||
|
||||
@@ -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" }
|
||||
|
||||
@@ -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" });
|
||||
}
|
||||
|
||||
@@ -433,6 +433,15 @@ pub(crate) fn shape_of(s: &Session, id: ShapeId) -> Result<deckcraft_model::Shap
|
||||
pub fn xfrm_of(doc: &deckcraft_model::Presentation, sel: &crate::Selection, shape: &deckcraft_model::Shape) -> 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;
|
||||
|
||||
@@ -139,11 +139,13 @@ pub struct Damage {
|
||||
pub media: Vec<String>,
|
||||
/// Slides a `.pptx` lists but that couldn't be read, so they are not in the presentation.
|
||||
pub slides: Vec<String>,
|
||||
/// Content a `.pptx` had that was cut to fit a limit; the file still opened.
|
||||
pub warnings: Vec<String>,
|
||||
}
|
||||
|
||||
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<String>)> {
|
||||
fn open_other(name: &str, bytes: &[u8]) -> Result<(Presentation, Vec<String>, Vec<String>)> {
|
||||
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<String>)> {
|
||||
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<Value> {
|
||||
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<Value> {
|
||||
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(())
|
||||
|
||||
@@ -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"));
|
||||
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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.
|
||||
|
||||
+186
-16
@@ -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<Merge> {
|
||||
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 {
|
||||
|
||||
@@ -12,6 +12,8 @@ workspace = true
|
||||
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 }
|
||||
|
||||
+16
-67
@@ -348,73 +348,7 @@ fn arc_to(d: &mut String, cur: (f64, f64), wr: f64, hr: f64, st: f64, sw: f64) -
|
||||
}
|
||||
|
||||
/// Parse our path syntax into commands.
|
||||
pub fn parse_path(d: &str) -> Vec<(char, Vec<f64>)> {
|
||||
let mut out = vec![];
|
||||
let mut cmd: Option<char> = None;
|
||||
let mut nums: Vec<f64> = vec![];
|
||||
let flush = |cmd: Option<char>, nums: &mut Vec<f64>, out: &mut Vec<(char, Vec<f64>)>| {
|
||||
if let Some(c) = cmd {
|
||||
let n = match c {
|
||||
'M' | 'L' => 2,
|
||||
'C' => 6,
|
||||
'Q' => 4,
|
||||
_ => 0,
|
||||
};
|
||||
if n == 0 {
|
||||
out.push((c, vec![]));
|
||||
} else {
|
||||
for (i, chunk) in nums.chunks(n).enumerate() {
|
||||
if chunk.len() == n && out.len() < 1_000_000 {
|
||||
// Repeated coordinates after M continue as L.
|
||||
let c2 = if c == 'M' && i > 0 { 'L' } else { c };
|
||||
out.push((c2, chunk.to_vec()));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
nums.clear();
|
||||
};
|
||||
let mut token = String::new();
|
||||
let push_tok = |token: &mut String, nums: &mut Vec<f64>| {
|
||||
if !token.is_empty() {
|
||||
if let Ok(v) = token.parse::<f64>()
|
||||
&& v.is_finite()
|
||||
{
|
||||
nums.push(v);
|
||||
}
|
||||
token.clear();
|
||||
}
|
||||
};
|
||||
let cs: Vec<char> = d.chars().collect();
|
||||
for (i, &ch) in cs.iter().enumerate() {
|
||||
match ch {
|
||||
// An 'E' inside a number followed by a digit (or a sign and a digit) is an exponent,
|
||||
// not the end command.
|
||||
'E' if !token.is_empty() && {
|
||||
let n1 = cs.get(i + 1).copied().unwrap_or(' ');
|
||||
let n2 = cs.get(i + 2).copied().unwrap_or(' ');
|
||||
n1.is_ascii_digit() || ((n1 == '-' || n1 == '+') && n2.is_ascii_digit())
|
||||
} =>
|
||||
{
|
||||
token.push(ch)
|
||||
}
|
||||
'M' | 'L' | 'C' | 'Q' | 'Z' | 'm' | 'l' | 'c' | 'q' | 'z' | 'E' => {
|
||||
push_tok(&mut token, &mut nums);
|
||||
flush(cmd, &mut nums, &mut out);
|
||||
cmd = Some(ch.to_ascii_uppercase());
|
||||
}
|
||||
' ' | ',' | '\t' | '\n' => push_tok(&mut token, &mut nums),
|
||||
'-' if !token.is_empty() && !token.ends_with(['e', 'E']) => {
|
||||
push_tok(&mut token, &mut nums);
|
||||
token.push(ch);
|
||||
}
|
||||
c => token.push(c),
|
||||
}
|
||||
}
|
||||
push_tok(&mut token, &mut nums);
|
||||
flush(cmd, &mut nums, &mut out);
|
||||
out
|
||||
}
|
||||
pub use craft_drawingml::custgeom::parse_path;
|
||||
|
||||
/// Write custom paths as `a:custGeom`. Coordinates are integers in the file, so small path spaces
|
||||
/// are scaled up.
|
||||
@@ -596,3 +530,18 @@ mod tests {
|
||||
assert!(parse_path("garbage ### C 1").is_empty() || parse_path("garbage").is_empty());
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod shared_path_tests {
|
||||
use super::parse_path;
|
||||
|
||||
#[test]
|
||||
fn shared_path_tokens_preserve_exponents_repeats_and_dropped_tails() {
|
||||
assert_eq!(
|
||||
parse_path("M1E2 -3E-1 4 5 L6-7 Q8 9 10 11 Z"),
|
||||
vec![('M', vec![100.0, -0.3]), ('L', vec![4.0, 5.0]), ('L', vec![6.0, -7.0]), ('Q', vec![8.0, 9.0, 10.0, 11.0]), ('Z', vec![]),]
|
||||
);
|
||||
assert_eq!(parse_path("M0 0 L1"), vec![('M', vec![0.0, 0.0])]);
|
||||
assert_eq!(parse_path("MNaN 0 1 2"), vec![('M', vec![0.0, 1.0])]);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -71,6 +71,12 @@ pub fn import_checked(bytes: &[u8]) -> Result<(Presentation, Vec<String>), 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<String>, Vec<String>), 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)]
|
||||
|
||||
+28
-2
@@ -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<String>,
|
||||
/// 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<String, bool>,
|
||||
}
|
||||
|
||||
/// 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<Presentation, PptxError> {
|
||||
/// 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<String>), 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<String>, Vec<String>), 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<String>), 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<String>, Vec<String>), PptxError> {
|
||||
let mut lost_slides: Vec<String> = 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,
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
+57
-244
@@ -1,259 +1,72 @@
|
||||
//! 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).
|
||||
//! 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};
|
||||
|
||||
use crate::opc::NS_A;
|
||||
use crate::xml::{A, W};
|
||||
|
||||
/// Well-known built-in table style GUIDs (format identifiers) and our equivalent ids.
|
||||
const KNOWN: &[(&str, &str)] = &[
|
||||
("{2D5ABB26-0587-4C30-8999-92F81FD0307C}", "none"),
|
||||
("{5940675A-B579-460E-94D1-54222C63F5DA}", "grid"),
|
||||
("{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}", "medium2-accent1"),
|
||||
("{073A0DAA-6AF3-43AB-8588-CEC1D06C72B9}", "medium2-tx1"),
|
||||
("{21E4AEA4-8DFA-4A89-87EB-49C32662AFE8}", "medium2-accent2"),
|
||||
("{F5AB1C69-6EDB-4FF4-983F-18BD219EF322}", "medium2-accent3"),
|
||||
("{00A15C55-8517-42AA-B614-E9B94910E393}", "medium2-accent4"),
|
||||
("{7DF18680-E054-41AD-8BC1-D1AEF772440D}", "medium2-accent5"),
|
||||
("{93296810-A885-4BE3-A3E7-6D5BEEA58F35}", "medium2-accent6"),
|
||||
];
|
||||
|
||||
/// GUIDs we write as built-in references (no definition needed).
|
||||
const BUILTIN_WRITE: [&str; 3] = ["none", "grid", "medium2-accent1"];
|
||||
|
||||
fn fnv(s: &str, seed: u64) -> u64 {
|
||||
let mut h = 0xcbf2_9ce4_8422_2325u64 ^ seed;
|
||||
for b in s.bytes() {
|
||||
h ^= b as u64;
|
||||
h = h.wrapping_mul(0x0100_0000_01b3);
|
||||
}
|
||||
h
|
||||
pub fn table_styles_xml(used: &[String], defs: &[deckcraft_model::table::TableStyleDef]) -> Vec<u8> {
|
||||
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"))
|
||||
})
|
||||
}
|
||||
|
||||
/// A stable GUID derived from text (version-4 layout).
|
||||
pub fn guid(text: &str) -> String {
|
||||
let a = fnv(text, 0x5163_7261_6674);
|
||||
let b = fnv(text, 0x7461_626c_6573);
|
||||
format!(
|
||||
"{{{:08X}-{:04X}-4{:03X}-8{:03X}-{:012X}}}",
|
||||
(a >> 32) as u32,
|
||||
(a >> 16) as u16,
|
||||
(a & 0x0fff) as u16,
|
||||
(b >> 48) as u16 & 0x0fff,
|
||||
b & 0xffff_ffff_ffff
|
||||
)
|
||||
}
|
||||
#[cfg(test)]
|
||||
#[path = "tables_legacy.rs"]
|
||||
mod legacy;
|
||||
|
||||
#[cfg(test)]
|
||||
fn own_guid(style: &str) -> String {
|
||||
guid(&format!("deckcraft-table-style:{style}"))
|
||||
}
|
||||
|
||||
/// Is `g` the GUID DeckCraft writes for one of its own styles?
|
||||
pub fn is_own_guid(g: &str) -> bool {
|
||||
let up = g.to_ascii_uppercase();
|
||||
deckcraft_model::table::table_styles().iter().any(|(id, _)| own_guid(id) == up)
|
||||
}
|
||||
|
||||
/// Table style GUID → our style id (or the GUID itself when unknown).
|
||||
pub fn style_from_guid(g: &str) -> String {
|
||||
let up = g.to_ascii_uppercase();
|
||||
if let Some((_, s)) = KNOWN.iter().find(|(k, _)| *k == up) {
|
||||
return s.to_string();
|
||||
}
|
||||
for (id, _) in deckcraft_model::table::table_styles() {
|
||||
if own_guid(&id) == up {
|
||||
return id;
|
||||
}
|
||||
}
|
||||
if g.is_empty() { "none".into() } else { g.to_string() }
|
||||
}
|
||||
|
||||
/// GUID to write for our style id, and whether a definition must be written.
|
||||
pub fn guid_for_style(style: &str) -> (String, bool) {
|
||||
if style.starts_with('{') {
|
||||
return (style.to_string(), false);
|
||||
}
|
||||
if BUILTIN_WRITE.contains(&style)
|
||||
&& let Some((g, _)) = KNOWN.iter().find(|(_, s)| *s == style)
|
||||
{
|
||||
return (g.to_string(), false);
|
||||
}
|
||||
let known = deckcraft_model::table::table_styles().iter().any(|(id, _)| id == style);
|
||||
if known { (own_guid(style), true) } else { ("{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}".into(), false) }
|
||||
}
|
||||
|
||||
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<u8> {
|
||||
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<String> = std::collections::HashSet::new();
|
||||
let mut def_of: std::collections::HashMap<String, &deckcraft_model::table::TableStyleDef> = 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<String> = deckcraft_model::table::table_styles().into_iter().map(|(id, _)| id).collect();
|
||||
used.extend(["unknown<&\"".into(), "Custom".into(), "Custom".into(), "CUSTOM".into()]);
|
||||
for raw in [
|
||||
"<a:tblStyle xmlns:a=\"urn:test\"/>",
|
||||
"<tblStyle>", // Existing lenient partial-root policy.
|
||||
"<tblStyle></other><trailing/>",
|
||||
"<!--prefix--><tblStyle name=\"&\"/>",
|
||||
"<notAStyle/>",
|
||||
"",
|
||||
"<tblStyle><child/></tblStyle>",
|
||||
] {
|
||||
let defs = vec![
|
||||
TableStyleDef { id: "custom".into(), raw: raw.into(), ..Default::default() },
|
||||
TableStyleDef { id: "CUSTOM".into(), raw: "<tblStyle second=\"1\"/>".into(), ..Default::default() },
|
||||
TableStyleDef { id: "unused".into(), raw: "<tblStyle unused=\"1\"/>".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!("{}{}", "<tblStyle>".repeat(depth), "</tblStyle>".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());
|
||||
assert_eq!(style_from_guid(""), "none");
|
||||
let custom = "{abcdef00-0000-0000-0000-000000000000}";
|
||||
assert_eq!(style_from_guid(custom), custom);
|
||||
assert_eq!(guid_for_style(custom), (custom.to_string(), false));
|
||||
assert_eq!(guid_for_style("unknown"), guid_for_style("medium2-accent1"));
|
||||
for (id, _) in deckcraft_model::table::table_styles() {
|
||||
let generated = own_guid(&id);
|
||||
assert!(is_own_guid(&generated.to_ascii_lowercase()));
|
||||
if guid_for_style(&id).1 {
|
||||
assert_eq!(guid_for_style(&id).0, generated);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn style_parts_follow_schema_order() {
|
||||
const ORDER: [&str; 14] = [
|
||||
|
||||
@@ -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<u8> {
|
||||
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<String> = std::collections::HashSet::new();
|
||||
let mut def_of: std::collections::HashMap<String, &deckcraft_model::table::TableStyleDef> = 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()
|
||||
}
|
||||
@@ -65,6 +65,8 @@ pub struct Exp<'a> {
|
||||
n_kept: u32,
|
||||
pub slide_parts: HashMap<SlideId, String>,
|
||||
pub table_styles: Vec<String>,
|
||||
/// 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<String>,
|
||||
placeholder: Option<String>,
|
||||
@@ -558,6 +560,7 @@ pub fn export(p: &Presentation, main_ct: &str) -> Result<Vec<u8>, 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<Vec<u8>, 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()
|
||||
}
|
||||
|
||||
|
||||
@@ -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()) {
|
||||
|
||||
@@ -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("<a:tr ").expect("row");
|
||||
let end = xml.rfind("</a:tr>").expect("row end") + "</a:tr>".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() {
|
||||
|
||||
@@ -232,6 +232,8 @@ pub fn gradient_editor(ui: &mut Ui, id: &str, g: &Gradient, sc: &ColorScheme) ->
|
||||
let (marks, _) = ui.allocate_exact_size(vec2(bar.width(), 14.0), Sense::hover());
|
||||
let drag_id = ui.scope_id().with((id, "drag"));
|
||||
let mut dragging: Option<(usize, f64)> = ui.data_mut(|d| d.get_temp(drag_id));
|
||||
// A double-clicked stop opens its colour menu, as in PowerPoint (#2175).
|
||||
let mut open_color = false;
|
||||
for (i, s) in g.stops.iter().enumerate() {
|
||||
let pos = dragging.filter(|d| d.0 == i).map_or(s.pos, |d| d.1);
|
||||
let x = bar.min.x + pos as f32 * bar.width();
|
||||
@@ -245,6 +247,10 @@ pub fn gradient_editor(ui: &mut Ui, id: &str, g: &Gradient, sc: &ColorScheme) ->
|
||||
if resp.clicked() || resp.drag_started() {
|
||||
sel = i;
|
||||
}
|
||||
if resp.double_clicked() {
|
||||
sel = i;
|
||||
open_color = true;
|
||||
}
|
||||
if resp.dragged()
|
||||
&& let Some(p) = resp.interact_pointer_pos()
|
||||
{
|
||||
@@ -287,7 +293,12 @@ pub fn gradient_editor(ui: &mut Ui, id: &str, g: &Gradient, sc: &ColorScheme) ->
|
||||
let (sw, _) = ui.allocate_exact_size(vec2(18.0, 18.0), Sense::hover());
|
||||
ui.painter().rect(sw, CornerRadius::same(3), c32(&s.color, sc), Stroke::new(1.0, t.border), egui::StrokeKind::Inside);
|
||||
let r = widgets::drop_button(ui, "", vec2(24.0, 20.0), true);
|
||||
widgets::color_popup(&r).show(|ui| {
|
||||
r.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, "Stop color"));
|
||||
let mut popup = widgets::color_popup(&r);
|
||||
if open_color {
|
||||
popup = popup.open_memory(egui::SetOpenCommand::Bool(true));
|
||||
}
|
||||
popup.show(|ui| {
|
||||
if let Some(Some(c)) = widgets::color_grid(ui, sc, None) {
|
||||
let mut ng = g.clone();
|
||||
ng.stops[sel].color = with_alpha(c, alpha_of(&s.color));
|
||||
@@ -516,7 +527,58 @@ pub fn pattern_editor(ui: &mut Ui, pt: &PatternFill, sc: &ColorScheme) -> Option
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#![allow(clippy::unwrap_used, clippy::expect_used)]
|
||||
|
||||
use super::*;
|
||||
use egui_kittest::Harness;
|
||||
use egui_kittest::kittest::Queryable;
|
||||
|
||||
/// #2175: double-clicking a gradient stop selects it and opens its colour menu; a colour
|
||||
/// picked there colours that stop.
|
||||
#[test]
|
||||
fn double_clicking_a_stop_opens_its_color_menu() {
|
||||
let sc = deckcraft_model::Theme::default().colors;
|
||||
let start = Gradient {
|
||||
stops: vec![
|
||||
GradientStop { pos: 0.0, color: ColorRef::scheme(SchemeSlot::Accent1) },
|
||||
GradientStop { pos: 1.0, color: ColorRef::scheme(SchemeSlot::Accent2) },
|
||||
],
|
||||
..default_gradient(ColorRef::scheme(SchemeSlot::Accent1), 90.0)
|
||||
};
|
||||
// The gradient, and whether the interface fonts are in (they apply from the next frame).
|
||||
let mut h = Harness::builder().with_size(vec2(400.0, 700.0)).with_step_dt(1.0 / 60.0).build_ui_state(
|
||||
move |ui, (g, fonts): &mut (Gradient, bool)| {
|
||||
if !*fonts {
|
||||
theme::install_fonts(ui.ctx());
|
||||
*fonts = true;
|
||||
return;
|
||||
}
|
||||
if let Some(ng) = gradient_editor(ui, "test-grad", &g.clone(), &sc) {
|
||||
*g = ng;
|
||||
}
|
||||
},
|
||||
(start, false),
|
||||
);
|
||||
h.run_steps(3);
|
||||
assert!(h.query_by_label("Theme Colors").is_none(), "the menu starts closed");
|
||||
let stop = h.get_by_label("Gradient stop 2").rect().center();
|
||||
h.hover_at(stop);
|
||||
h.run_steps(1);
|
||||
for _ in 0..2 {
|
||||
for pressed in [true, false] {
|
||||
h.event(egui::Event::PointerButton { pos: stop, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE });
|
||||
h.run_steps(1);
|
||||
}
|
||||
}
|
||||
h.run_steps(2);
|
||||
assert!(h.query_by_label("Theme Colors").is_some(), "the colour menu opened");
|
||||
h.get_by_label(SchemeSlot::Accent6.label()).click();
|
||||
h.run_steps(2);
|
||||
let g = &h.state().0;
|
||||
assert_eq!(g.stops.len(), 2, "no stop was added");
|
||||
assert_eq!(g.stops[1].color, ColorRef::scheme(SchemeSlot::Accent6), "the double-clicked stop took the colour");
|
||||
assert_eq!(g.stops[0].color, ColorRef::scheme(SchemeSlot::Accent1));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn gradient_json_retains_flip_mode() {
|
||||
|
||||
@@ -552,7 +552,8 @@ impl Show {
|
||||
true
|
||||
}
|
||||
|
||||
/// On entering a slide: auto-play its first step when it begins With/After Previous.
|
||||
/// On entering a slide: auto-play its first step when it begins With/After Previous, once the
|
||||
/// slide's transition is over.
|
||||
/// `ShowState` already starts such a step when it enters the slide (#631: asking it for the
|
||||
/// next step again finished the step at once, so the slide appeared fully built), so only
|
||||
/// its clock starts here. Autoplay previews start an On Click first step themselves.
|
||||
@@ -568,7 +569,9 @@ impl Show {
|
||||
None
|
||||
};
|
||||
if let Some(k) = started {
|
||||
self.step_start = now;
|
||||
// The slide's transition plays first; its animations start when it has finished, as
|
||||
// in PowerPoint (#2089).
|
||||
self.step_start = self.trans.as_ref().map_or(now, |t| now.max(t.start + t.dur));
|
||||
self.media_clock = Some((k, f64::NEG_INFINITY));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -516,6 +516,41 @@ fn a_transition_keeps_the_old_slide_in_its_own_texture() {
|
||||
assert!(show.tex.is_none(), "the new slide gets a texture of its own instead of overwriting the old one");
|
||||
}
|
||||
|
||||
/// #2089: a slide's With Previous entrance waits for the slide's transition to finish, as in
|
||||
/// PowerPoint, instead of playing under it.
|
||||
#[test]
|
||||
fn animations_start_after_the_slides_transition() {
|
||||
let mut s = deckcraft_engine::Session::with_new();
|
||||
s.execute("slide.new", &json!({})).unwrap();
|
||||
s.execute("transition.set", &json!({"kind": "fade", "index": 1, "duration": 400})).unwrap();
|
||||
let id = s.active().unwrap().doc.slides[1].shapes[0].id;
|
||||
s.execute("animation.add", &json!({"effect": "fade", "class": "entrance", "ids": [id.0], "start": "withPrevious", "duration": 500})).unwrap();
|
||||
let doc = s.active().unwrap().doc.clone();
|
||||
let mut show = Show::new(&doc, 0, false, false);
|
||||
let a = show.state.next(&doc);
|
||||
assert_eq!(a, ShowAction::Slide(1));
|
||||
assert!(show.apply(a, &doc, 10.0));
|
||||
assert!(show.trans.is_some(), "the fade plays");
|
||||
assert!(show.state.playing, "the With Previous step is under way");
|
||||
assert!((show.clock_snapshot().step_start - 10.4).abs() < 1e-9, "its clock starts when the 0.4 s fade ends");
|
||||
let tl = ShowState::timeline(&doc, 1);
|
||||
let at = |now: f64| state_for(&tl, id, show.state.step, now - show.clock_snapshot().step_start, &[], &[]);
|
||||
assert!(!at(10.3).visible, "hidden while the transition plays");
|
||||
assert!(at(10.6).visible && at(10.6).opacity < 1.0, "fading in after it");
|
||||
// The step is not cut short by the time the transition took.
|
||||
let mut actions = Vec::new();
|
||||
assert!(show.queue_clock_actions(&doc, 10.8, &mut actions));
|
||||
assert!(actions.is_empty(), "0.4 s into a 0.5 s step: still playing");
|
||||
|
||||
// Without a transition the step starts at once, as before.
|
||||
s.execute("transition.set", &json!({"kind": "none", "index": 1})).unwrap();
|
||||
let doc = s.active().unwrap().doc.clone();
|
||||
let mut show = Show::new(&doc, 0, false, false);
|
||||
let a = show.state.next(&doc);
|
||||
assert!(show.apply(a, &doc, 10.0));
|
||||
assert_eq!(show.clock_snapshot().step_start, 10.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn going_back_plays_the_left_slides_transition_reversed() {
|
||||
// #1531: Back from B to A played A's own entrance transition. PowerPoint plays the one B came
|
||||
|
||||
@@ -1,2 +1,11 @@
|
||||
sonar.projectKey=storytold_deckcraft
|
||||
sonar.organization=storytold
|
||||
|
||||
# githubactions:S7637 asks for every action to be pinned to a commit SHA. A workflow covered by
|
||||
# .github/workflows/actions.lock runs the commit the lockfile records, so its tag refs are pinned
|
||||
# and the lockfile covers the actions those actions use too. Sonar does not read lockfiles yet, so
|
||||
# the rule flags the tag refs anyway:
|
||||
# https://community.sonarsource.com/t/githubactions-s7637-false-positives-for-actions-pinned-through-native-actions-lock/190814
|
||||
sonar.issue.ignore.multicriteria=gha-lockfile
|
||||
sonar.issue.ignore.multicriteria.gha-lockfile.ruleKey=githubactions:S7637
|
||||
sonar.issue.ignore.multicriteria.gha-lockfile.resourceKey=.github/workflows/**
|
||||
|
||||
Reference in New Issue
Block a user