mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-16 20:25:02 +00:00
Merge pull request #1862 from tsw2k/fix/rtf-table-grid-fallback
craft-rtf: tables keep their column grid on odd rows
This commit is contained in:
+121
-19
@@ -1,3 +1,6 @@
|
||||
use std::cmp::Reverse;
|
||||
use std::collections::BinaryHeap;
|
||||
|
||||
use super::reader::Reader;
|
||||
use super::state::{CommentData, Dest, HeaderFooter, HfPages, MARK_CLOSE, MARK_OPEN, MAX_PICT, NoteData, PageGeom};
|
||||
use super::{Arc, Block, Blocks, Cell, Document, FBlock, Flow, HashMap, InlineObject, Para, Paragraph, model};
|
||||
@@ -262,43 +265,142 @@ fn finalize(mut r: Reader) -> Parsed {
|
||||
Parsed { flow: Flow { blocks, meta: r.meta }, page: r.page, last_section, default_font, headers_footers, notes: r.notes, comments: r.comments }
|
||||
}
|
||||
|
||||
/// Most grid columns a table gets (the document model's own cap).
|
||||
const MAX_GRID_COLS: usize = 63;
|
||||
/// Grid columns under this width, in twips (6 pt), merge while the rows leave room: import widens
|
||||
/// any narrower column to 6 pt, which grows the table, and files exported from spreadsheets put
|
||||
/// edges a few twips apart.
|
||||
const MIN_GRID_GAP: i64 = 120;
|
||||
/// Grid columns of this width or less, in twips (1 pt), always merge: the document model refuses
|
||||
/// them, and would then give the table equal columns.
|
||||
const NO_GRID_GAP: i64 = 20;
|
||||
|
||||
/// The column grid of a table from its rows' cell right edges: every distinct edge starts a grid
|
||||
/// column, and each cell spans the grid columns between its left and right edges, as Word lays
|
||||
/// out RTF rows whose cells don't line up. Returns the widths in points, or none (equal columns)
|
||||
/// when the edges don't make a grid.
|
||||
/// when no grid fits, which only a row of more cells than grid columns can cause.
|
||||
///
|
||||
/// One odd row never costs the whole table its grid (a form exported from a spreadsheet, with
|
||||
/// many narrow columns, otherwise had its wide title squeezed into one of four equal columns):
|
||||
/// - Over [`MAX_GRID_COLS`] edges, or edges closer than [`MIN_GRID_GAP`], merge, leaving a column
|
||||
/// for each cell of the widest row ([`coarse_edges`]); each cell edge moves to the nearest
|
||||
/// grid edge.
|
||||
/// - A cell that ends at or before the previous one (a zero-width cell, or a cell with no
|
||||
/// `\cellx` of its own) still gets a grid column of its own; cells pushed past the table's
|
||||
/// right edge move back.
|
||||
pub(super) fn column_grid(rows: &mut [Vec<Cell>], rights: &[Vec<i32>]) -> Vec<f32> {
|
||||
if rights.len() != rows.len() {
|
||||
return Vec::new();
|
||||
}
|
||||
let mut edges: Vec<i32> = rights.iter().flatten().copied().filter(|&x| x > 0).collect();
|
||||
edges.sort_unstable();
|
||||
edges.dedup();
|
||||
let ok = rights.len() == rows.len()
|
||||
&& rows
|
||||
.iter()
|
||||
.zip(rights)
|
||||
.all(|(r, x)| r.len() == x.len() && x.windows(2).all(|w| w.first() < w.get(1)) && x.first().is_some_and(|&v| v > 0))
|
||||
&& !edges.is_empty()
|
||||
&& edges.len() <= 63;
|
||||
if !ok {
|
||||
if edges.is_empty() {
|
||||
return Vec::new();
|
||||
}
|
||||
for (row, x) in rows.iter_mut().zip(rights) {
|
||||
let grid = coarse_edges(&edges, rows.iter().map(Vec::len).max().unwrap_or(0));
|
||||
// Each cell's right edge as a grid edge number (1 = the first grid column's right edge).
|
||||
let mut ends: Vec<Vec<usize>> = Vec::with_capacity(rows.len());
|
||||
for (row, x) in rows.iter().zip(rights) {
|
||||
if row.len() > grid.len() {
|
||||
return Vec::new();
|
||||
}
|
||||
let mut at: Vec<usize> = Vec::with_capacity(row.len());
|
||||
let mut prev = 0;
|
||||
for i in 0..row.len() {
|
||||
let end = x.get(i).map_or(0, |&r| nearest_edge(&grid, r)).max(prev + 1);
|
||||
at.push(end);
|
||||
prev = end;
|
||||
}
|
||||
// Cells pushed past the right edge move back, each keeping a column of its own.
|
||||
let mut limit = grid.len();
|
||||
for end in at.iter_mut().rev() {
|
||||
*end = (*end).min(limit);
|
||||
limit = end.saturating_sub(1);
|
||||
}
|
||||
ends.push(at);
|
||||
}
|
||||
for (row, at) in rows.iter_mut().zip(&ends) {
|
||||
let mut left = 0;
|
||||
for (c, &right) in row.iter_mut().zip(x) {
|
||||
let span = edges.iter().filter(|&&e| e > left && e <= right).count().max(1);
|
||||
c.colspan = span as u32;
|
||||
left = right;
|
||||
for (c, &end) in row.iter_mut().zip(at) {
|
||||
c.colspan = u32::try_from(end.saturating_sub(left)).unwrap_or(1).max(1);
|
||||
left = end;
|
||||
}
|
||||
}
|
||||
let mut prev = 0;
|
||||
edges
|
||||
.iter()
|
||||
let mut prev = 0i64;
|
||||
grid.iter()
|
||||
.map(|&e| {
|
||||
let w = (e - prev) as f32 / 20.0;
|
||||
prev = e;
|
||||
let w = (i64::from(e) - prev) as f32 / 20.0;
|
||||
prev = i64::from(e);
|
||||
w
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The grid edges kept from the sorted, distinct, positive `edges`. The narrowest column merges
|
||||
/// into the next, one at a time, so an edge moves only when it has to: while there are over
|
||||
/// [`MAX_GRID_COLS`] columns, or columns of [`NO_GRID_GAP`] or less, and while a column is under
|
||||
/// [`MIN_GRID_GAP`] and more columns remain than the `widest_row`'s cells. The table's right edge
|
||||
/// is always kept.
|
||||
fn coarse_edges(edges: &[i32], widest_row: usize) -> Vec<i32> {
|
||||
let n = edges.len();
|
||||
// Each edge's neighbours among the edges still kept.
|
||||
let mut left: Vec<Option<usize>> = (0..n).map(|i| i.checked_sub(1)).collect();
|
||||
let mut right: Vec<Option<usize>> = (1..=n).map(|i| (i < n).then_some(i)).collect();
|
||||
let mut kept = vec![true; n];
|
||||
let at = |i: Option<usize>| i.and_then(|i| edges.get(i)).map_or(0, |&e| i64::from(e));
|
||||
let width = |i: usize, left: &[Option<usize>]| at(Some(i)) - at(left.get(i).copied().flatten());
|
||||
let mut narrowest: BinaryHeap<Reverse<(i64, usize)>> = (0..n).map(|i| Reverse((width(i, &left), i))).collect();
|
||||
let mut count = n;
|
||||
while count > 1 {
|
||||
let Some(Reverse((w, i))) = narrowest.pop() else {
|
||||
break;
|
||||
};
|
||||
// A column that has since grown, or gone, has a fresher entry or none.
|
||||
if !kept.get(i).copied().unwrap_or(false) || w != width(i, &left) {
|
||||
continue;
|
||||
}
|
||||
if count <= MAX_GRID_COLS && w > NO_GRID_GAP && (w >= MIN_GRID_GAP || count <= widest_row) {
|
||||
break;
|
||||
}
|
||||
// The column's right edge goes, unless it is the table's: then its left edge does.
|
||||
let last = right.get(i).copied().flatten().is_none();
|
||||
let Some(gone) = (if last { left.get(i).copied().flatten() } else { Some(i) }) else {
|
||||
break;
|
||||
};
|
||||
let before = left.get(gone).copied().flatten();
|
||||
let after = right.get(gone).copied().flatten();
|
||||
if let Some(slot) = before.and_then(|b| right.get_mut(b)) {
|
||||
*slot = after;
|
||||
}
|
||||
if let Some(a) = after {
|
||||
if let Some(slot) = left.get_mut(a) {
|
||||
*slot = before;
|
||||
}
|
||||
narrowest.push(Reverse((width(a, &left), a)));
|
||||
}
|
||||
if let Some(slot) = kept.get_mut(gone) {
|
||||
*slot = false;
|
||||
}
|
||||
count -= 1;
|
||||
}
|
||||
edges.iter().zip(&kept).filter(|&(_, &k)| k).map(|(&e, _)| e).collect()
|
||||
}
|
||||
|
||||
/// The number of the grid edge nearest `x` (1-based; 0 is the table's left edge).
|
||||
fn nearest_edge(grid: &[i32], x: i32) -> usize {
|
||||
if x <= 0 {
|
||||
return 0;
|
||||
}
|
||||
let p = grid.partition_point(|&e| e < x);
|
||||
let below = if p == 0 { 0 } else { grid.get(p - 1).copied().unwrap_or(0) };
|
||||
match grid.get(p) {
|
||||
Some(&above) if i64::from(above) - i64::from(x) <= i64::from(x) - i64::from(below) => p + 1,
|
||||
Some(_) => p,
|
||||
None => grid.len(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Parse RTF bytes into a document.
|
||||
pub fn import(bytes: &[u8]) -> Result<Document, String> {
|
||||
model::begin_import();
|
||||
|
||||
@@ -460,6 +460,141 @@ fn table_grid_from_cell_edges_and_borders() {
|
||||
assert_eq!(t.grid, [240.9, 241.0]);
|
||||
}
|
||||
|
||||
/// The table of `rtf`'s flow and every row's column spans; checks the spans fit the grid.
|
||||
fn grid_of(rtf: &[u8]) -> (Vec<f32>, Vec<Vec<u32>>) {
|
||||
let f = parse(rtf).unwrap();
|
||||
let FBlock::Table(t) = &f.blocks[0] else { panic!("no table") };
|
||||
let spans: Vec<Vec<u32>> = t.rows.iter().map(|r| r.iter().map(|c| c.colspan).collect()).collect();
|
||||
assert!(!t.widths.is_empty(), "the table kept no grid");
|
||||
assert_eq!(t.cols(), t.widths.len(), "spans {spans:?} don't fit {} grid columns", t.widths.len());
|
||||
assert!(t.widths.iter().all(|&w| w > 1.0), "a grid column under a point: {:?}", t.widths);
|
||||
(t.widths.clone(), spans)
|
||||
}
|
||||
|
||||
/// Width in points of the first `n` grid columns.
|
||||
fn first_cols(widths: &[f32], n: u32) -> f32 {
|
||||
widths.iter().take(n as usize).sum()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn table_grid_survives_more_than_63_edges() {
|
||||
// A form exported from a spreadsheet: a wide title over rows whose middle edge moves by
|
||||
// 100 twips, 80 distinct edges in all. The grid used to be dropped, giving equal columns.
|
||||
let mut rtf = String::from(r"{\rtf1\ansi\trowd\cellx6000\cellx8000\pard\intbl Title\cell Codes\cell\row");
|
||||
for k in 1..80 {
|
||||
rtf.push_str(&format!(r"\trowd\cellx{}\cellx8000\pard\intbl a\cell b\cell\row", k * 100));
|
||||
}
|
||||
rtf.push_str(r"\pard\par}");
|
||||
let (widths, spans) = grid_of(rtf.as_bytes());
|
||||
assert!(widths.len() <= 63, "{} grid columns", widths.len());
|
||||
assert!((widths.iter().sum::<f32>() - 400.0).abs() < 0.01, "the table keeps its 400 pt");
|
||||
// The title keeps its 300 pt, within a grid column's merge.
|
||||
let title = first_cols(&widths, spans[0][0]);
|
||||
assert!((title - 300.0).abs() <= 5.0, "title {title} pt");
|
||||
// The staircase still climbs: the 60th row's first cell is about 300 pt wide too.
|
||||
assert!((first_cols(&widths, spans[60][0]) - 300.0).abs() <= 5.0);
|
||||
|
||||
// The same through import: the document table has the grid, not equal columns.
|
||||
let d = import(rtf.as_bytes()).unwrap();
|
||||
let t = d.body.iter().find_map(|b| if let craft_wordmodel::Block::Table(t) = &**b { Some(t) } else { None }).unwrap();
|
||||
assert_eq!(t.grid.len(), widths.len());
|
||||
let w = t.rows[0].cells[0].props.width.unwrap();
|
||||
assert!((w - 300.0).abs() <= 5.0, "title cell {w} pt");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn table_grid_survives_a_zero_width_cell_and_a_missing_cellx() {
|
||||
// A zero-width cell (two edges at 3000) in one row: the other rows keep their grid.
|
||||
let (widths, spans) = grid_of(
|
||||
br"{\rtf1\ansi
|
||||
\trowd\cellx6000\cellx9000 \pard\intbl Title\cell b\cell\row
|
||||
\trowd\cellx2000\cellx2000\cellx9000 \pard\intbl a\cell\cell c\cell\row
|
||||
\pard\par}",
|
||||
);
|
||||
assert_eq!(first_cols(&widths, spans[0][0]), 300.0);
|
||||
assert_eq!(spans[1].len(), 3, "the zero-width cell is kept: {spans:?}");
|
||||
assert_eq!(first_cols(&widths, spans[1][0]), 100.0, "the cell before it keeps its width");
|
||||
|
||||
// A row with a third cell but only two `\cellx`.
|
||||
let (widths, spans) = grid_of(
|
||||
br"{\rtf1\ansi
|
||||
\trowd\cellx6000\cellx9000 \pard\intbl Title\cell b\cell\row
|
||||
\trowd\cellx2000\cellx6000 \pard\intbl a\cell b\cell extra\cell\row
|
||||
\pard\par}",
|
||||
);
|
||||
assert_eq!(first_cols(&widths, spans[0][0]), 300.0);
|
||||
assert_eq!(spans[1].len(), 3);
|
||||
assert_eq!(first_cols(&widths, spans[1][0]), 100.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn table_grid_merges_edges_a_few_twips_apart() {
|
||||
// Two rows that mean the same 3000-twip edge, 5 twips apart: one grid column, not one of
|
||||
// a quarter point (which the document model refuses, so the table got equal columns).
|
||||
let (widths, spans) = grid_of(
|
||||
br"{\rtf1\ansi
|
||||
\trowd\cellx3000\cellx9000 \pard\intbl a\cell b\cell\row
|
||||
\trowd\cellx3005\cellx9000 \pard\intbl c\cell d\cell\row
|
||||
\pard\par}",
|
||||
);
|
||||
assert_eq!(widths.len(), 2, "{widths:?}");
|
||||
assert_eq!(spans, [[1, 1], [1, 1]]);
|
||||
assert_eq!(widths.iter().sum::<f32>(), 450.0);
|
||||
}
|
||||
|
||||
/// `edges` as one table row, a cell for each.
|
||||
fn rtf_row(edges: &[usize]) -> String {
|
||||
let cells: String = edges.iter().map(|e| format!(r"\cellx{e}")).collect();
|
||||
format!(r"\trowd{cells}\pard\intbl {}\row", r"x\cell ".repeat(edges.len()))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn table_grid_keeps_a_column_for_each_cell_of_the_widest_row() {
|
||||
// 64 evenly spaced edges: merging by a common gap halves them to 32 columns, too few for a
|
||||
// row of 33 or more cells, and the table lost its grid.
|
||||
let edges: Vec<usize> = (1..=64).map(|k| k * 100).collect();
|
||||
for cells in [33, 40, 50, 62] {
|
||||
let wide: Vec<usize> = edges.iter().copied().take(cells).chain([6400]).collect();
|
||||
let rest: Vec<usize> = edges.iter().copied().skip(cells - 1).collect();
|
||||
let rtf = format!(r"{{\rtf1\ansi {}{}\pard\par}}", rtf_row(&wide), rtf_row(&rest));
|
||||
let (widths, spans) = grid_of(rtf.as_bytes());
|
||||
assert!((cells + 1..=63).contains(&widths.len()), "{cells} cells, {} grid columns", widths.len());
|
||||
assert_eq!(spans[0].len(), cells + 1, "every cell is kept");
|
||||
assert_eq!(widths.iter().sum::<f32>(), 320.0, "the table keeps its 320 pt");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn table_grid_merges_columns_import_would_widen() {
|
||||
// Columns under 6 pt that no row needs: import raises each one to 6 pt, so this table of
|
||||
// 3 pt columns doubled in width. Merged, it keeps its 60 pt.
|
||||
let mut rtf = String::from(r"{\rtf1\ansi ");
|
||||
for k in 1..=20 {
|
||||
rtf.push_str(&rtf_row(&[k * 60, 1200]));
|
||||
}
|
||||
rtf.push_str(r"\pard\par}");
|
||||
let (widths, _) = grid_of(rtf.as_bytes());
|
||||
assert!(widths.iter().all(|&w| w >= 6.0), "{widths:?}");
|
||||
let d = import(rtf.as_bytes()).unwrap();
|
||||
let t = d.body.iter().find_map(|b| if let craft_wordmodel::Block::Table(t) = &**b { Some(t) } else { None }).unwrap();
|
||||
assert_eq!(t.grid.iter().sum::<f32>(), 60.0, "{:?}", t.grid);
|
||||
|
||||
// A row that needs them keeps them, narrow as they are.
|
||||
let (widths, spans) = grid_of(format!(r"{{\rtf1\ansi {}\pard\par}}", rtf_row(&[60, 120, 180])).as_bytes());
|
||||
assert_eq!(widths, [3.0, 3.0, 3.0]);
|
||||
assert_eq!(spans, [[1, 1, 1]]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn table_grid_never_keeps_a_column_the_document_model_refuses() {
|
||||
// Three cells within a point of each other: too narrow to keep even for a row that needs
|
||||
// them. The row can't fit, so the table has no grid, and nothing panics.
|
||||
let f = parse(format!(r"{{\rtf1\ansi {}\pard\par}}", rtf_row(&[5, 10, 15])).as_bytes()).unwrap();
|
||||
let FBlock::Table(t) = &f.blocks[0] else { panic!("no table") };
|
||||
assert!(t.widths.is_empty(), "{:?}", t.widths);
|
||||
assert_eq!(t.rows[0].len(), 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn code_pages_from_ansicpg_and_font_charsets() {
|
||||
// The document's code page: Russian RTF as accounting systems write it.
|
||||
|
||||
Reference in New Issue
Block a user